From c46ae072ec799e999de85af914a9eea207d66c3b Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Mon, 26 Jan 2026 10:40:02 +0100
Subject: [PATCH 001/219] Make alloy gas estimator configurable (#4081)

# Description
Adds the ability to configure past_blocks and reward_percentile
parameters for the EIP-1559 gas price estimator. Previously, alloy's
hardcoded defaults (10 blocks, 20th percentile) were always used.


# Changes

[x] Add configurable_alloy.rs - a gas estimator that calls
eth_feeHistory with custom parameters, then uses alloy's default
estimation algorithm
[x] Extend GasEstimatorType::Alloy config variant with optional
past-blocks and reward-percentile fields
[x] Default values match alloy's hardcoded constants (10 blocks, 20.0
percentile) for backwards compatibility
---
 crates/driver/src/infra/blockchain/gas.rs     |  13 +-
 crates/driver/src/infra/config/file/mod.rs    | 154 +++++++++++++++++-
 .../shared/src/gas_price_estimation/alloy.rs  |  51 ------
 .../configurable_alloy.rs                     | 102 ++++++++++++
 crates/shared/src/gas_price_estimation/mod.rs |  18 +-
 5 files changed, 277 insertions(+), 61 deletions(-)
 delete mode 100644 crates/shared/src/gas_price_estimation/alloy.rs
 create mode 100644 crates/shared/src/gas_price_estimation/configurable_alloy.rs

diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index f67885d532..510eb1ace0 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -11,7 +11,7 @@ use {
     ethrpc::Web3,
     shared::gas_price_estimation::{
         GasPriceEstimating,
-        alloy::Eip1559GasPriceEstimator,
+        configurable_alloy::{ConfigurableGasPriceEstimator, EstimatorConfig},
         eth_node::NodeGasPriceEstimator,
     },
     std::sync::Arc,
@@ -36,7 +36,16 @@ impl GasPriceEstimator {
     ) -> Result<Self, Error> {
         let gas: Arc<dyn GasPriceEstimating> = match gas_estimator_type {
             GasEstimatorType::Web3 => Arc::new(NodeGasPriceEstimator::new(web3.alloy.clone())),
-            GasEstimatorType::Alloy => Arc::new(Eip1559GasPriceEstimator::new(web3.alloy.clone())),
+            GasEstimatorType::Alloy {
+                past_blocks,
+                reward_percentile,
+            } => Arc::new(ConfigurableGasPriceEstimator::new(
+                web3.alloy.clone(),
+                EstimatorConfig {
+                    past_blocks: *past_blocks,
+                    reward_percentile: *reward_percentile,
+                },
+            )),
         };
         // TODO: simplify logic by moving gas price adjustments out of the individual
         // mempool configs
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index 4b4b20e7a7..ad0c4d8184 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -6,6 +6,10 @@ use {
     reqwest::Url,
     serde::{Deserialize, Deserializer, Serialize},
     serde_with::serde_as,
+    shared::gas_price_estimation::configurable_alloy::{
+        default_past_blocks,
+        default_reward_percentile,
+    },
     solver::solver::Arn,
     std::{collections::HashMap, time::Duration},
 };
@@ -735,13 +739,32 @@ pub struct LiquoriceConfig {
     pub http_timeout: Duration,
 }
 
-#[derive(Clone, Debug, Deserialize, Default)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-#[serde(tag = "estimator")]
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields, tag = "estimator")]
 pub enum GasEstimatorType {
     Web3,
-    #[default]
-    Alloy,
+    /// EIP-1559 gas estimator using alloy's algorithm.
+    /// Optionally configure the fee history query parameters.
+    #[serde(rename_all = "kebab-case")]
+    Alloy {
+        /// Number of blocks to look back for fee history (default: 10)
+        #[serde(default = "default_past_blocks")]
+        past_blocks: u64,
+        /// Percentile of rewards to use for priority fee estimation (default:
+        /// 20.0). This is what Metamask uses as medium priority:
+        /// https://github.com/MetaMask/core/blob/0fd4b397e7237f104d1c81579a0c4321624d076b/packages/gas-fee-controller/src/fetchGasEstimatesViaEthFeeHistory/calculateGasFeeEstimatesForPriorityLevels.ts#L14-L45
+        #[serde(default = "default_reward_percentile")]
+        reward_percentile: f64,
+    },
+}
+
+impl Default for GasEstimatorType {
+    fn default() -> Self {
+        Self::Alloy {
+            past_blocks: default_past_blocks(),
+            reward_percentile: default_reward_percentile(),
+        }
+    }
 }
 
 /// Defines various strategies to prioritize orders.
@@ -967,3 +990,124 @@ enum AtBlock {
     /// Use the latest finalized block.
     Finalized,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gas_estimator_alloy_defaults() {
+        let config: GasEstimatorType = toml::from_str(
+            r#"
+            estimator = "alloy"
+        "#,
+        )
+        .unwrap();
+
+        match config {
+            GasEstimatorType::Alloy {
+                past_blocks,
+                reward_percentile,
+            } => {
+                assert_eq!(past_blocks, 10);
+                assert_eq!(reward_percentile, 20.0);
+            }
+            _ => panic!("expected Alloy variant"),
+        }
+    }
+
+    #[test]
+    fn gas_estimator_alloy_custom_past_blocks() {
+        let config: GasEstimatorType = toml::from_str(
+            r#"
+            estimator = "alloy"
+            past-blocks = 5
+        "#,
+        )
+        .unwrap();
+
+        match config {
+            GasEstimatorType::Alloy {
+                past_blocks,
+                reward_percentile,
+            } => {
+                assert_eq!(past_blocks, 5);
+                assert_eq!(reward_percentile, 20.0);
+            }
+            _ => panic!("expected Alloy variant"),
+        }
+    }
+
+    #[test]
+    fn gas_estimator_alloy_custom_percentile() {
+        let config: GasEstimatorType = toml::from_str(
+            r#"
+            estimator = "alloy"
+            reward-percentile = 50.0
+        "#,
+        )
+        .unwrap();
+
+        match config {
+            GasEstimatorType::Alloy {
+                past_blocks,
+                reward_percentile,
+            } => {
+                assert_eq!(past_blocks, 10);
+                assert_eq!(reward_percentile, 50.0);
+            }
+            _ => panic!("expected Alloy variant"),
+        }
+    }
+
+    #[test]
+    fn gas_estimator_alloy_all_custom() {
+        let config: GasEstimatorType = toml::from_str(
+            r#"
+            estimator = "alloy"
+            past-blocks = 20
+            reward-percentile = 75.0
+        "#,
+        )
+        .unwrap();
+
+        match config {
+            GasEstimatorType::Alloy {
+                past_blocks,
+                reward_percentile,
+            } => {
+                assert_eq!(past_blocks, 20);
+                assert_eq!(reward_percentile, 75.0);
+            }
+            _ => panic!("expected Alloy variant"),
+        }
+    }
+
+    #[test]
+    fn gas_estimator_web3() {
+        let config: GasEstimatorType = toml::from_str(
+            r#"
+            estimator = "web3"
+        "#,
+        )
+        .unwrap();
+
+        assert!(matches!(config, GasEstimatorType::Web3));
+    }
+
+    #[test]
+    fn gas_estimator_default() {
+        let config = GasEstimatorType::default();
+
+        match config {
+            GasEstimatorType::Alloy {
+                past_blocks,
+                reward_percentile,
+            } => {
+                assert_eq!(past_blocks, 10);
+                assert_eq!(reward_percentile, 20.0);
+            }
+            _ => panic!("expected Alloy variant as default"),
+        }
+    }
+}
diff --git a/crates/shared/src/gas_price_estimation/alloy.rs b/crates/shared/src/gas_price_estimation/alloy.rs
deleted file mode 100644
index 9faf2190ff..0000000000
--- a/crates/shared/src/gas_price_estimation/alloy.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-//! Uses `alloy`'s logic for suggesting reasonable EIP-1559
-//! gas price values. It computes the suggested gas price
-//! based on the 20th percentile of fee rewards for
-//! transactions of the last 10 blocks.
-//! See <https://github.com/alloy-rs/alloy/blob/ad56bf0b974974179ee39daf694e400dba0f8ff7/crates/provider/src/utils.rs#L107-L122>
-//! for the implementation details.
-
-use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559, u128_to_f64},
-    alloy::providers::Provider,
-    anyhow::{Context, Result},
-    ethrpc::AlloyProvider,
-    futures::TryFutureExt,
-    tracing::instrument,
-};
-
-/// Estimates an EIP-1559 gas price based on the 20th percentile of fee rewards
-/// for transactions of the last 10 blocks.
-pub struct Eip1559GasPriceEstimator(AlloyProvider);
-
-impl Eip1559GasPriceEstimator {
-    pub fn new(provider: AlloyProvider) -> Self {
-        Self(provider)
-    }
-}
-
-#[async_trait::async_trait]
-impl GasPriceEstimating for Eip1559GasPriceEstimator {
-    /// Returns alloy's estimation for the EIP-1559 gas price.
-    #[instrument(skip(self))]
-    async fn estimate(&self) -> Result<crate::gas_price_estimation::price::GasPrice1559> {
-        let fees = self
-            .0
-            .estimate_eip1559_fees()
-            .map_err(|err| anyhow::anyhow!("could not estimate EIP 1559 fees: {err:?}"))
-            .await?;
-
-        let max_fee_per_gas = u128_to_f64(fees.max_fee_per_gas)
-            .context("could not convert max_fee_per_gas to f64")?;
-
-        Ok(GasPrice1559 {
-            // We reuse `max_fee_per_gas` since the base fee only actually
-            // exists in a mined block. For price estimates used to configure
-            // the gas price of a transaction the base fee doesn't matter.
-            base_fee_per_gas: max_fee_per_gas,
-            max_fee_per_gas,
-            max_priority_fee_per_gas: u128_to_f64(fees.max_priority_fee_per_gas)
-                .context("could not convert max_priority_fee_per_gas to f64")?,
-        })
-    }
-}
diff --git a/crates/shared/src/gas_price_estimation/configurable_alloy.rs b/crates/shared/src/gas_price_estimation/configurable_alloy.rs
new file mode 100644
index 0000000000..671497d7cf
--- /dev/null
+++ b/crates/shared/src/gas_price_estimation/configurable_alloy.rs
@@ -0,0 +1,102 @@
+//! Configurable EIP-1559 gas price estimator.
+//!
+//! Unlike alloy's default estimator which uses hardcoded values (10 blocks,
+//! 20th percentile), this estimator allows configuring:
+//! - Number of blocks to look back
+//! - Reward percentile to use
+
+use {
+    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559, u128_to_f64},
+    alloy::{
+        eips::BlockNumberOrTag,
+        providers::{Provider, utils::eip1559_default_estimator},
+    },
+    anyhow::{Context, Result},
+    ethrpc::AlloyProvider,
+    tracing::instrument,
+};
+
+#[derive(Debug, Clone, Copy)]
+pub struct EstimatorConfig {
+    /// Number of blocks to look back for fee history
+    pub past_blocks: u64,
+    /// Percentile of rewards to use for priority fee estimation
+    pub reward_percentile: f64,
+}
+
+pub fn default_past_blocks() -> u64 {
+    10
+}
+
+pub fn default_reward_percentile() -> f64 {
+    20.0
+}
+
+/// A configurable EIP-1559 gas price estimator.
+///
+/// Uses alloy's default estimation algorithm but with configurable
+/// `past_blocks` and `reward_percentile` parameters for the fee history query.
+pub struct ConfigurableGasPriceEstimator {
+    provider: AlloyProvider,
+    config: EstimatorConfig,
+}
+
+impl ConfigurableGasPriceEstimator {
+    pub fn new(provider: AlloyProvider, config: EstimatorConfig) -> Self {
+        Self { provider, config }
+    }
+}
+
+#[async_trait::async_trait]
+impl GasPriceEstimating for ConfigurableGasPriceEstimator {
+    #[instrument(skip(self), fields(
+        past_blocks = %self.config.past_blocks,
+        reward_percentile = %self.config.reward_percentile
+    ))]
+    async fn estimate(&self) -> Result<GasPrice1559> {
+        // Fetch fee history with our configured parameters
+        let fee_history = self
+            .provider
+            .get_fee_history(
+                self.config.past_blocks,
+                BlockNumberOrTag::Latest,
+                &[self.config.reward_percentile],
+            )
+            .await
+            .context("failed to fetch fee history")?;
+
+        // Get base fee: use latest block's base fee, or fall back to fetching
+        // latest block directly if fee history is empty
+        let base_fee_per_gas = match fee_history.latest_block_base_fee() {
+            Some(base_fee) if base_fee != 0 => base_fee,
+            _ => {
+                // empty response, fetch basefee from latest block directly
+                let block = self
+                    .provider
+                    .get_block_by_number(BlockNumberOrTag::Latest)
+                    .await
+                    .context("failed to fetch latest block")?
+                    .context("latest block not found")?;
+                u128::from(
+                    block
+                        .header
+                        .base_fee_per_gas
+                        .context("base_fee_per_gas not available (eip1559 not supported)")?,
+                )
+            }
+        };
+
+        // Use alloy's default estimation algorithm
+        let estimation =
+            eip1559_default_estimator(base_fee_per_gas, &fee_history.reward.unwrap_or_default());
+
+        Ok(GasPrice1559 {
+            base_fee_per_gas: u128_to_f64(base_fee_per_gas)
+                .context("could not convert base_fee_per_gas to f64")?,
+            max_fee_per_gas: u128_to_f64(estimation.max_fee_per_gas)
+                .context("could not convert max_fee_per_gas to f64")?,
+            max_priority_fee_per_gas: u128_to_f64(estimation.max_priority_fee_per_gas)
+                .context("could not convert max_priority_fee_per_gas to f64")?,
+        })
+    }
+}
diff --git a/crates/shared/src/gas_price_estimation/mod.rs b/crates/shared/src/gas_price_estimation/mod.rs
index 6f49cee005..2aad505340 100644
--- a/crates/shared/src/gas_price_estimation/mod.rs
+++ b/crates/shared/src/gas_price_estimation/mod.rs
@@ -1,4 +1,4 @@
-pub mod alloy;
+pub mod configurable_alloy;
 pub mod driver;
 pub mod eth_node;
 pub mod fake;
@@ -9,7 +9,12 @@ use {
     crate::{
         ethrpc::Web3,
         gas_price_estimation::{
-            alloy::Eip1559GasPriceEstimator,
+            configurable_alloy::{
+                ConfigurableGasPriceEstimator,
+                EstimatorConfig,
+                default_past_blocks,
+                default_reward_percentile,
+            },
             eth_node::NodeGasPriceEstimator,
             priority::PriorityGasPriceEstimating,
         },
@@ -73,7 +78,14 @@ pub async fn create_priority_estimator(
                 estimators.push(Box::new(NodeGasPriceEstimator::new(web3.alloy.clone())))
             }
             GasEstimatorType::Alloy => {
-                estimators.push(Box::new(Eip1559GasPriceEstimator::new(web3.alloy.clone())))
+                let estimator = ConfigurableGasPriceEstimator::new(
+                    web3.alloy.clone(),
+                    EstimatorConfig {
+                        past_blocks: default_past_blocks(),
+                        reward_percentile: default_reward_percentile(),
+                    },
+                );
+                estimators.push(Box::new(estimator))
             }
         }
     }

From 22ba97683094ecec762c277cfee71a5ab1bc96c5 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 26 Jan 2026 10:45:55 +0100
Subject: [PATCH 002/219] Improve handling of unverifiable quotes (#4085)

# Description
Currently the quote verification leads to weird results - especially for
Ondo tokens. Routing these tokens requires the use of a proprietary API
which does not give out usable call data without an actual trade intent.
To adhere to the API solvers simply leave the execution plan of their
solution blank (pre interactions, regular interactions, JIT orders).
Normally this would lead to a revert in the trade simulation which would
in turn cause our system to keep the quotes but mark them as
unverifiable.
However, if the settlement contract has enough buy_tokens to pay for the
entire quoted amount the simulation will not revert but the analysis
afterwards will sniff out that the quote is giving money away for free.
This will then lead to the quote getting discarded entirely.
This causes 2 main issues:
1. it is possible to get a `fast` quote (which skips verification
alltogether) and then end up with `NoLiquidity` errors for `optimal`
quotes which is confusing
2. said `NoLiquidity` errors then prevent users from placing orders

# Changes
Since this needs to be resolved urgently I went for a relatively simple
approach where we detect whether a solution contains any execution plan
at all. Now we only discard quotes that are too inaccurate if the solver
actually tried to provide such a plan. If no plan is provided we simply
assume it's because no plan could be provided.
Note that there is still an incentive to provide verifiable calldata
because any verifiable quote will be preferred over any non-verifiable
quote. So solvers that don't make the effort to provide the calldata
will basically never win quotes for trades where it's possible to
provide calldata.

Minor other changes:
* renamed `Error::TooInaccurate` to `Error::BuffersPayForOrder` to
hopefully make the error case more self explanatory
* adjusted some getter functions to return `impl Iterator` instead of
`Vec` to avoid unnecessary cloning

## How to test
This is very hard to test with unit or e2e tests. Given how small the
actual change is I think existing e2e tests should be enough to cover
the correctness of the regular case and a deployment to prod will show
if we now indeed handle the Ondo token case better.
---
 .../price_estimation/trade_verifier/mod.rs    | 77 ++++++++++++-------
 crates/shared/src/trade_finding/external.rs   |  6 +-
 crates/shared/src/trade_finding/mod.rs        | 32 +++++---
 3 files changed, 74 insertions(+), 41 deletions(-)

diff --git a/crates/shared/src/price_estimation/trade_verifier/mod.rs b/crates/shared/src/price_estimation/trade_verifier/mod.rs
index 76a2d2ba50..4f5cee74cc 100644
--- a/crates/shared/src/price_estimation/trade_verifier/mod.rs
+++ b/crates/shared/src/price_estimation/trade_verifier/mod.rs
@@ -223,9 +223,9 @@ impl TradeVerifier {
                     solver: trade.solver(),
                     verified: true,
                     execution: QuoteExecution {
-                        interactions: map_interactions_data(&trade.interactions()),
-                        pre_interactions: map_interactions_data(&trade.pre_interactions()),
-                        jit_orders: trade.jit_orders(),
+                        interactions: map_interactions_data(trade.interactions()),
+                        pre_interactions: map_interactions_data(trade.pre_interactions()),
+                        jit_orders: trade.jit_orders().cloned().collect(),
                     },
                 };
                 tracing::warn!(
@@ -305,7 +305,7 @@ impl TradeVerifier {
                 summary.out_amount = I512::from(query.in_amount.get()) + summary.out_amount;
             } else if summary.out_amount < I512::ZERO {
                 tracing::debug!("Trade out amount is negative");
-                return Err(Error::TooInaccurate);
+                return Err(Error::BuffersPayForOrder);
             }
         }
 
@@ -517,9 +517,9 @@ impl TradeVerifying for TradeVerifier {
                 solver: trade.solver(),
                 verified: false,
                 execution: QuoteExecution {
-                    interactions: map_interactions_data(&trade.interactions()),
-                    pre_interactions: map_interactions_data(&trade.pre_interactions()),
-                    jit_orders: trade.jit_orders(),
+                    interactions: map_interactions_data(trade.interactions()),
+                    pre_interactions: map_interactions_data(trade.pre_interactions()),
+                    jit_orders: trade.jit_orders().cloned().collect(),
                 },
             })
             .context("solver provided no gas estimate");
@@ -537,20 +537,42 @@ impl TradeVerifying for TradeVerifier {
             .await
         {
             Ok(verified) => Ok(verified),
-            Err(Error::SimulationFailed(err)) => {
-                tracing::debug!(estimate = ?unverified_result, ?err, "quote verification failed");
-                unverified_result
-            }
-            Err(err @ Error::TooInaccurate) => {
-                tracing::debug!("discarding quote because it's too inaccurate");
-                Err(err.into())
+            Err(err) => {
+                // For some tokens it's not possible to provide verifiable calldata in the
+                // quote (e.g. when they require the use of proprietary APIs which don't give
+                // out calldata willy nilly).
+                //
+                // Since you can't magically make up calldata that makes your quote verifiable
+                // solvers don't provide any call data in those cases.
+                // This has 2 possible outcomes:
+                // 1. the settlement contract has enough buy_tokens to pay for the order =>
+                //    Error::BuffersPayForOrder
+                // 2. not enough buy tokens in buffer => error::SimulationFailure
+                //
+                // To make handling of these quotes more predictable we'll only discard
+                // `Error::BufferPayForOrder` errors if the solver actually tried to provide a
+                // an execution plan but it's just not correct. In all other cases we just flag
+                // the solution as unverified but let it pass.
+                let has_execution_plan = trade.has_execution_plan();
+                if has_execution_plan && matches!(err, Error::BuffersPayForOrder) {
+                    tracing::debug!(
+                        has_execution_plan,
+                        "discarding quote because buffers pay for order"
+                    );
+                    Err(err.into())
+                } else {
+                    tracing::debug!(estimate = ?unverified_result, ?err, "quote verification failed");
+                    unverified_result
+                }
             }
         }
     }
 }
 
-fn encode_interactions(interactions: &[Interaction]) -> Vec<EncodedInteraction> {
-    interactions.iter().map(|i| i.encode()).collect()
+fn encode_interactions<'a>(
+    interactions: impl IntoIterator<Item = &'a Interaction>,
+) -> Vec<EncodedInteraction> {
+    interactions.into_iter().map(|i| i.encode()).collect()
 }
 
 #[expect(clippy::too_many_arguments)]
@@ -565,7 +587,7 @@ fn encode_settlement(
     domain_separator: &DomainSeparator,
     settlement: Address,
 ) -> Result<EncodedSettlement> {
-    let mut trade_interactions = encode_interactions(&trade.interactions());
+    let mut trade_interactions = encode_interactions(trade.interactions());
     if query.buy_token == BUY_ETH_ADDRESS {
         // Because the `driver` manages `WETH` unwraps under the hood the `TradeFinder`
         // does not have to emit unwraps to pay out `ETH` in a trade.
@@ -624,7 +646,7 @@ fn encode_settlement(
 
     let user_interactions = verification.pre_interactions.iter().cloned();
     let pre_interactions: Vec<_> = user_interactions
-        .chain(trade.pre_interactions())
+        .chain(trade.pre_interactions().cloned())
         .chain([trade_setup_interaction])
         .collect();
 
@@ -899,7 +921,7 @@ fn ensure_quote_accuracy(
         .context("summary buy token is missing")?;
 
     if (*sell_token_lost >= sell_token_lost_limit) || (*buy_token_lost >= buy_token_lost_limit) {
-        return Err(Error::TooInaccurate);
+        return Err(Error::BuffersPayForOrder);
     }
 
     Ok(Estimate {
@@ -908,9 +930,9 @@ fn ensure_quote_accuracy(
         solver: trade.solver(),
         verified: true,
         execution: QuoteExecution {
-            interactions: map_interactions_data(&trade.interactions()),
-            pre_interactions: map_interactions_data(&trade.pre_interactions()),
-            jit_orders: trade.jit_orders(),
+            interactions: map_interactions_data(trade.interactions()),
+            pre_interactions: map_interactions_data(trade.pre_interactions()),
+            jit_orders: trade.jit_orders().cloned().collect(),
         },
     })
 }
@@ -927,9 +949,10 @@ pub struct PriceQuery {
 #[derive(thiserror::Error, Debug)]
 enum Error {
     /// Verification logic ran successfully but the quote was deemed too
-    /// inaccurate to be usable.
-    #[error("too inaccurate")]
-    TooInaccurate,
+    /// inaccurate because too many buy tokens came from the settlement
+    /// contract's buffers.
+    #[error("buffers pay for order")]
+    BuffersPayForOrder,
     /// Some error caused the simulation to not finish successfully.
     #[error("quote could not be simulated")]
     SimulationFailed(#[from] anyhow::Error),
@@ -1010,7 +1033,7 @@ mod tests {
 
         let estimate =
             ensure_quote_accuracy(&low_threshold, &query, &Default::default(), &sell_more);
-        assert!(matches!(estimate, Err(Error::TooInaccurate)));
+        assert!(matches!(estimate, Err(Error::BuffersPayForOrder)));
 
         // passes with slightly higher tolerance
         let estimate =
@@ -1030,7 +1053,7 @@ mod tests {
 
         let estimate =
             ensure_quote_accuracy(&low_threshold, &query, &Default::default(), &pay_out_more);
-        assert!(matches!(estimate, Err(Error::TooInaccurate)));
+        assert!(matches!(estimate, Err(Error::BuffersPayForOrder)));
 
         // passes with slightly higher tolerance
         let estimate =
diff --git a/crates/shared/src/trade_finding/external.rs b/crates/shared/src/trade_finding/external.rs
index ca180729dc..dae60321a4 100644
--- a/crates/shared/src/trade_finding/external.rs
+++ b/crates/shared/src/trade_finding/external.rs
@@ -219,9 +219,9 @@ impl TradeFinding for ExternalTradeFinder {
             gas_estimate,
             solver: trade.solver(),
             execution: QuoteExecution {
-                interactions: map_interactions_data(&trade.interactions()),
-                pre_interactions: map_interactions_data(&trade.pre_interactions()),
-                jit_orders: trade.jit_orders(),
+                interactions: map_interactions_data(trade.interactions()),
+                pre_interactions: map_interactions_data(trade.pre_interactions()),
+                jit_orders: trade.jit_orders().cloned().collect(),
             },
         })
     }
diff --git a/crates/shared/src/trade_finding/mod.rs b/crates/shared/src/trade_finding/mod.rs
index 824e5c8b3a..a406500d60 100644
--- a/crates/shared/src/trade_finding/mod.rs
+++ b/crates/shared/src/trade_finding/mod.rs
@@ -95,24 +95,32 @@ impl TradeKind {
         }
     }
 
-    pub fn interactions(&self) -> Vec<Interaction> {
+    /// Returns whether the solution contains anything that could
+    /// actually produce the promised buy tokens.
+    pub fn has_execution_plan(&self) -> bool {
+        self.interactions().next().is_some()
+            || self.jit_orders().next().is_some()
+            || self.pre_interactions().next().is_some()
+    }
+
+    pub fn interactions(&self) -> impl std::iter::Iterator<Item = &Interaction> {
         match self {
-            TradeKind::Legacy(trade) => trade.interactions.clone(),
-            TradeKind::Regular(trade) => trade.interactions.clone(),
+            TradeKind::Legacy(trade) => trade.interactions.iter(),
+            TradeKind::Regular(trade) => trade.interactions.iter(),
         }
     }
 
-    pub fn pre_interactions(&self) -> Vec<Interaction> {
+    pub fn pre_interactions(&self) -> impl std::iter::Iterator<Item = &Interaction> {
         match self {
-            TradeKind::Legacy(_) => Vec::new(),
-            TradeKind::Regular(trade) => trade.pre_interactions.clone(),
+            TradeKind::Legacy(_) => [].iter(),
+            TradeKind::Regular(trade) => trade.pre_interactions.iter(),
         }
     }
 
-    pub fn jit_orders(&self) -> Vec<dto::JitOrder> {
+    pub fn jit_orders(&self) -> impl std::iter::Iterator<Item = &dto::JitOrder> {
         match self {
-            TradeKind::Legacy(_) => Vec::new(),
-            TradeKind::Regular(trade) => trade.jit_orders.clone(),
+            TradeKind::Legacy(_) => [].iter(),
+            TradeKind::Regular(trade) => trade.jit_orders.iter(),
         }
     }
 }
@@ -281,9 +289,11 @@ pub fn map_interactions(interactions: &[InteractionData]) -> Vec<Interaction> {
     interactions.iter().cloned().map(Into::into).collect()
 }
 
-pub fn map_interactions_data(interactions: &[Interaction]) -> Vec<InteractionData> {
+pub fn map_interactions_data<'a>(
+    interactions: impl IntoIterator<Item = &'a Interaction>,
+) -> Vec<InteractionData> {
     interactions
-        .iter()
+        .into_iter()
         .map(|i| i.to_interaction_data())
         .collect()
 }

From adda1aebada3c5b06a2313a0dbc39d441a7b3839 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 26 Jan 2026 11:17:07 +0100
Subject: [PATCH 003/219] Log solve request data transfer (#4082)

# Description
Some solvers reported that some requests come significantly delayed
(judging by the auction deadline). Currently we have no way to
distinguish between receiving the start of the `/solve` request and
streaming the actual data.
This PR makes this possible by making the `solve` handler take a raw
http request and stream the body afterwards.

# Changes
Instead of:
1. collecting the whole body into a `String` (including utf8 check)
2. logging that we received a request
3. putting that `String` into an `Arc` to make copying it cheap
4. deserializing the string into a `SolveRequest`

We now do:
1. receive raw http request
2. log that we received it
3. stream the body into a cheaply copyable `Bytes` type
4. log how long the data transfer took
5. deserialize raw bytes into `SolveRequest`

Since handling the raw request seems to bypass axum's request size
checks I did it manually for this endpoint.

## How to test
Existing tests should suffice

---------

Co-authored-by: ilya <ilya@cow.fi>
---
 Cargo.lock                                    |  1 +
 Cargo.toml                                    |  1 +
 crates/driver/Cargo.toml                      |  1 +
 crates/driver/src/domain/competition/mod.rs   |  3 +-
 .../src/domain/competition/pre_processing.rs  | 13 ++--
 crates/driver/src/infra/api/mod.rs            |  2 +-
 .../driver/src/infra/api/routes/solve/mod.rs  | 77 ++++++++++++++++---
 crates/driver/src/infra/observe/mod.rs        |  8 +-
 8 files changed, 84 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 838549e714..108ddec027 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2732,6 +2732,7 @@ dependencies = [
  "ethrpc",
  "futures",
  "hex-literal",
+ "http-body 0.4.6",
  "humantime",
  "humantime-serde",
  "hyper 0.14.32",
diff --git a/Cargo.toml b/Cargo.toml
index 3d725f5013..ed1c68a30e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ flate2 = "1.0.30"
 futures = "0.3.30"
 const-hex = "1.17.0"
 hex-literal = "0.4.1"
+http-body = "0.4.6"
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
 hyper = "0.14.29"
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 6edf782820..edd2f47f6e 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -30,6 +30,7 @@ ethrpc = { workspace = true }
 futures = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
+http-body = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 hyper = { workspace = true }
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index a0d2c41d0c..5c83a800b1 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -22,6 +22,7 @@ use {
         util::{Bytes, math},
     },
     futures::{StreamExt, future::Either, stream::FuturesUnordered},
+    hyper::body::Bytes as RequestBytes,
     itertools::Itertools,
     std::{
         cmp::Reverse,
@@ -112,7 +113,7 @@ impl Competition {
     }
 
     /// Solve an auction as part of this competition.
-    pub async fn solve(&self, auction: Arc<String>) -> Result<Option<Solved>, Error> {
+    pub async fn solve(&self, auction: RequestBytes) -> Result<Option<Solved>, Error> {
         let start = Instant::now();
         let timer = ::observe::metrics::metrics()
             .on_auction_overhead_start("driver", "pre_processing_total");
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index 8b0f4b47ac..99bd4bb178 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -13,6 +13,7 @@ use {
     anyhow::{Context, Result},
     chrono::Utc,
     futures::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered},
+    hyper::body::Bytes as RequestBytes,
     itertools::Itertools,
     model::{
         interaction::InteractionData,
@@ -73,7 +74,7 @@ impl std::fmt::Debug for Utilities {
 #[derive(Debug)]
 struct ControlBlock {
     /// Auction for which the data aggregation task was spawned.
-    solve_request: Arc<String>,
+    solve_request: RequestBytes,
     /// Data aggregation task.
     tasks: DataFetchingTasks,
 }
@@ -90,7 +91,7 @@ impl DataAggregator {
     /// only once for all connected solvers to share.
     pub async fn start_or_get_tasks_for_auction(
         &self,
-        request: Arc<String>,
+        request: RequestBytes,
     ) -> Result<DataFetchingTasks> {
         let mut lock = self.control.lock().await;
         let current_auction = &lock.solve_request;
@@ -99,7 +100,7 @@ impl DataAggregator {
         // requests per auction. That means we can use the significantly
         // cheaper string comparison instead of parsing the JSON to compare
         // the auction ids.
-        if &request == current_auction {
+        if request == current_auction {
             let id = lock.tasks.auction.clone().await.id;
             init_auction_id_in_span(id.map(|i| i.0));
             tracing::debug!("await running data aggregation task");
@@ -164,7 +165,7 @@ impl DataAggregator {
         }
     }
 
-    async fn assemble_tasks(&self, request: Arc<String>) -> Result<DataFetchingTasks> {
+    async fn assemble_tasks(&self, request: RequestBytes) -> Result<DataFetchingTasks> {
         let auction = self.utilities.parse_request(request).await?;
 
         let balances =
@@ -211,14 +212,14 @@ impl Utilities {
     /// Parses the JSON body of the `/solve` request during the unified
     /// auction pre-processing since eagerly deserializing these requests
     /// is surprisingly costly because their are so big.
-    async fn parse_request(&self, solve_request: Arc<String>) -> Result<Arc<Auction>> {
+    async fn parse_request(&self, solve_request: RequestBytes) -> Result<Arc<Auction>> {
         let auction_dto: SolveRequest = {
             let _timer = metrics::get().processing_stage_timer("parse_dto");
             let _timer2 =
                 observe::metrics::metrics().on_auction_overhead_start("driver", "parse_dto");
             // deserialization takes tens of milliseconds so run it on a blocking task
             tokio::task::spawn_blocking(move || {
-                serde_json::from_str(&solve_request).context("could not parse solve request")
+                serde_json::from_slice(&solve_request).context("could not parse solve request")
             })
             .await
             .context("failed to await blocking task")??
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index afd3f27578..5b42fc88e5 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -31,7 +31,7 @@ use {
 mod error;
 pub mod routes;
 
-const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
+pub const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
 
 pub struct Api {
     pub solvers: Vec<Solver>,
diff --git a/crates/driver/src/infra/api/routes/solve/mod.rs b/crates/driver/src/infra/api/routes/solve/mod.rs
index 3750b7ef1f..6ed72ffef5 100644
--- a/crates/driver/src/infra/api/routes/solve/mod.rs
+++ b/crates/driver/src/infra/api/routes/solve/mod.rs
@@ -2,11 +2,16 @@ pub mod dto;
 
 pub use dto::AuctionError;
 use {
-    crate::infra::{
-        api::{Error, State},
-        observe,
+    crate::{
+        domain::competition,
+        infra::{
+            api::{Error, REQUEST_BODY_LIMIT, State},
+            observe,
+        },
     },
-    std::sync::Arc,
+    axum::{body::Body, http::Request},
+    hyper::body::Bytes,
+    std::time::{Duration, Instant},
     tracing::Instrument,
 };
 
@@ -16,17 +21,21 @@ pub(in crate::infra::api) fn solve(router: axum::Router<State>) -> axum::Router<
 
 async fn route(
     state: axum::extract::State<State>,
-    // take the request body as a raw string to delay parsing as much
-    // as possible because many requests don't have to be parsed at all
-    req: String,
+    // Take the request as raw request to extract the body as a stream.
+    // This delays interpreting the data as much as possible and allows
+    // logging how long the raw data transfer takes.
+    request: Request<Body>,
 ) -> Result<axum::Json<dto::SolveResponse>, (hyper::StatusCode, axum::Json<Error>)> {
+    let solver = state.solver().name().as_str();
+
     let handle_request = async {
+        let body_bytes = collect_request_body(request, solver).await?;
         let competition = state.competition();
-        let result = competition.solve(Arc::new(req)).await;
+        let result = competition.solve(body_bytes).await;
         // Solving takes some time, so there is a chance for the settlement queue to
         // have capacity again.
         competition.ensure_settle_queue_capacity()?;
-        observe::solved(state.solver().name(), &result);
+        observe::solved(solver, &result);
         Ok(axum::Json(dto::SolveResponse::new(
             result?,
             &competition.solver,
@@ -34,6 +43,54 @@ async fn route(
     };
 
     handle_request
-        .instrument(tracing::info_span!("/solve", solver = %state.solver().name(), auction_id = tracing::field::Empty))
+        .instrument(tracing::info_span!(
+            "/solve",
+            solver,
+            auction_id = tracing::field::Empty
+        ))
         .await
 }
+
+async fn collect_request_body(
+    request: Request<Body>,
+    solver: &str,
+) -> Result<Bytes, competition::Error> {
+    tracing::trace!("start streaming request body");
+    let start = Instant::now();
+
+    // accepting the raw request bypasses axum's request body limiting layer
+    // so we have to manually ensure the body has a reasonable size.
+    let limited_body = http_body::Limited::new(request.into_body(), REQUEST_BODY_LIMIT);
+    let body_bytes = hyper::body::to_bytes(limited_body).await.map_err(|err| {
+        tracing::warn!(?err, "failed to stream request body");
+        competition::Error::MalformedRequest
+    })?;
+
+    let duration = start.elapsed();
+    Metrics::measure_solve_transfer_time(solver, duration);
+    tracing::trace!(?duration, "finished streaming request body");
+    Ok(body_bytes)
+}
+
+#[derive(prometheus_metric_storage::MetricStorage)]
+struct Metrics {
+    /// Time spent by the driver reading the full solve request body into
+    /// memory.
+    #[metric(labels("solver"))]
+    #[metric(buckets(0.0001, 0.0005, 0.002, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.75, 1, 1.5))]
+    solve_request_body_read_duration_seconds: prometheus::HistogramVec,
+}
+
+impl Metrics {
+    fn get() -> &'static Metrics {
+        Metrics::instance(::observe::metrics::get_storage_registry())
+            .expect("unexpected error getting metrics instance")
+    }
+
+    fn measure_solve_transfer_time(solver: &str, time: Duration) {
+        Self::get()
+            .solve_request_body_read_duration_seconds
+            .with_label_values(&[solver])
+            .observe(time.as_secs_f64());
+    }
+}
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 0847778fbe..0a6f232b5b 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -222,27 +222,27 @@ pub fn settled(solver: &solver::Name, result: &Result<competition::Settled, comp
 }
 
 /// Observe the result of solving an auction.
-pub fn solved(solver: &solver::Name, result: &Result<Option<Solved>, competition::Error>) {
+pub fn solved(solver: &str, result: &Result<Option<Solved>, competition::Error>) {
     match result {
         Ok(Some(solved)) => {
             tracing::info!(?solved, "solved auction");
             metrics::get()
                 .solutions
-                .with_label_values(&[solver.as_str(), "Success"])
+                .with_label_values(&[solver, "Success"])
                 .inc();
         }
         Ok(None) => {
             tracing::debug!("no solution found");
             metrics::get()
                 .solutions
-                .with_label_values(&[solver.as_str(), "SolutionNotFound"])
+                .with_label_values(&[solver, "SolutionNotFound"])
                 .inc();
         }
         Err(err) => {
             tracing::warn!(?err, "failed to solve auction");
             metrics::get()
                 .solutions
-                .with_label_values(&[solver.as_str(), competition_error(err)])
+                .with_label_values(&[solver, competition_error(err)])
                 .inc();
         }
     }

From 5ca01e7e45fd926b25cd169655684e44ca10c5c1 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 26 Jan 2026 12:03:15 +0100
Subject: [PATCH 004/219] Replace RPC mempool API with in-memory tracking
 (#4086)

# Description
In order to know which gas price we have to beat at least (in case of
cancellations) we made the driver scan the RPC node's mempool using the
respective API as this is the ultimate source of truth.
However, this has 2 issues:
1. not widely supported
2. introduces latency (apparently up to 2s on mainnet at times)

Especially the latency seemingly causes us to not notify the connected
solver about the tx submission at times. The submission process works as
follows:
1. driver receives a `/settle` call and starts the submission
2. driver does the usual tx submission where it monitors the submission
deadline and initiate the cancellation if necessary
3. due to an [issue](https://github.com/cowprotocol/services/pull/3427)
with dead block streams the driver also monitors if the autopilot is
still waiting for the response for the `/settle` call
4. if the autopilot terminates the `/settle` call the driver only polls
the submission future for 1 more second but otherwise simply stops
polling it
([code](https://github.com/cowprotocol/services/blob/main/crates/driver/src/domain/competition/mod.rs#L630-L643))

Usually the submission future and autopilot detect the breach of the
submission deadline at the same time so the settle future naturally
executes the cancellation logic during that grace period. However, with
the latency introduced by the mempool API this grace period is often not
sufficient anymore (especially on mainnet). Doing some back of the
napkin calculation using logs it appears as if the driver is currently
not cancelling and submitting the respective notification for ~40% of
the `/settle` calls.

There is an argument to be made that the submission strategy should be
refactored more broadly to ensure that cancellations always get
initiated (instead of just stopping to poll the settle future) but this
PR should at least already resolve the current issue.

# Changes
Instead of using the RPC's `mempool` API we simply store the last
successfully submitted transactions in memory. Now that we only have to
lookup a key in a `Dashmap` the latency will be as it was before.
---
 crates/driver/src/domain/competition/mod.rs | 15 +++---
 crates/driver/src/domain/mempools.rs        | 57 +++++++++++----------
 crates/driver/src/infra/mempool/mod.rs      | 31 +++++++++--
 crates/e2e/Cargo.toml                       |  2 +-
 4 files changed, 66 insertions(+), 39 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 5c83a800b1..655ccc568f 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -634,19 +634,20 @@ impl Competition {
                     // disconnected). This is a fallback to recover from issues
                     // like a stuck driver (e.g., stalled block stream).
                     Either::Left((_closed, settle_fut)) => {
-                        // Add a grace period to give driver the last chance to fetch the settlement
-                        // tx.
+                        tracing::debug!("autopilot terminated settle call");
+                        // Add a grace period to give driver the last chance to cancel the
+                        // tx if needed.
                         tokio::time::timeout(Duration::from_secs(1), settle_fut)
                             .await
-                            .unwrap_or_else(|_| Err(DeadlineExceeded.into()))
+                            .unwrap_or_else(|_| {
+                                tracing::error!("didn't finish tx submission within grace period");
+                                Err(DeadlineExceeded.into())
+                            })
                     }
                     Either::Right((res, _)) => res,
                 };
                 observe::settled(self.solver.name(), &result);
-
-                if let Err(err) = response_sender.send(result) {
-                    tracing::error!(?err, "Failed to send /settle response");
-                }
+                let _ = response_sender.send(result);
             }
             .instrument(tracing_span)
             .await
diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index 40a32b9dc5..afd6fec97a 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -145,7 +145,7 @@ impl Mempools {
             .minimum_replacement_gas_price(mempool, solver, nonce)
             .await;
         let final_gas_price = match &replacement_gas_price {
-            Ok(Some(replacement_gas_price))
+            Some(replacement_gas_price)
                 if replacement_gas_price.max() > current_gas_price.max() =>
             {
                 *replacement_gas_price
@@ -281,7 +281,7 @@ impl Mempools {
         // replacement gas price, but if that fails for whatever reason
         // we use our best estimate based on the originally submitted tx
         let final_gas_price = match &replacement_gas_price {
-            Ok(Some(replacement)) => *replacement,
+            Some(replacement) => *replacement,
             _ => fallback_gas_price,
         };
 
@@ -311,35 +311,40 @@ impl Mempools {
             .await
     }
 
-    /// Tries to determine the minimum price to replace an existing
-    /// transaction in the mempool.
+    /// Computes minimum price to replace the last tx that was submitted
+    /// with the given nonce. Returns `None` if no tx was submitted with
+    /// that nonce yet.
     async fn minimum_replacement_gas_price(
         &self,
         mempool: &infra::Mempool,
         solver: &Solver,
-        nonce: u64,
-    ) -> anyhow::Result<Option<eth::GasPrice>> {
-        let pending_tx = match mempool
-            .find_pending_tx_in_mempool(solver.address(), nonce)
-            .await?
-        {
-            Some(tx) => tx,
-            None => return Ok(None),
-        };
+        next_nonce: u64,
+    ) -> Option<eth::GasPrice> {
+        if let Some(last_submission) = mempool.last_submission(solver.address()) {
+            (last_submission.nonce == next_nonce)
+                .then_some(last_submission.gas_price * GAS_PRICE_BUMP)
+        } else {
+            // If we don't have the last submission in-memory (i.e. first submission
+            // attempt after a restart) we try to inspect the nodes transaction mempool.
+            // This is only done as a backup since it can incur significant latency and
+            // is generally not very widely supported.
+            let pending_tx = mempool
+                .find_pending_tx_in_mempool(solver.address(), next_nonce)
+                .await
+                .inspect_err(|err| tracing::debug!(?err, "could not inspect tx mempool"))
+                .ok()??;
 
-        let pending_tx_gas_price = eth::GasPrice::new(
-            eth::U256::from(pending_tx.max_fee_per_gas()).into(),
-            eth::U256::from(pending_tx.max_priority_fee_per_gas().with_context(|| {
-                format!(
-                    "pending tx is not EIP 1559 ({})",
-                    pending_tx.inner.tx_hash()
-                )
-            })?)
-            .into(),
-            eth::U256::from(pending_tx.max_fee_per_gas()).into(),
-        );
-        // in order to replace a tx we need to increase the price
-        Ok(Some(pending_tx_gas_price * GAS_PRICE_BUMP))
+            let pending_tx_gas_price = eth::GasPrice::new(
+                eth::U256::from(pending_tx.max_fee_per_gas()).into(),
+                eth::U256::from(pending_tx.max_priority_fee_per_gas().or_else(|| {
+                    tracing::error!(tx = ?pending_tx.inner.tx_hash(), "pending tx is not EIP 1559");
+                    None
+                })?)
+                .into(),
+                eth::U256::from(pending_tx.max_fee_per_gas()).into(),
+            );
+            Some(pending_tx_gas_price * GAS_PRICE_BUMP)
+        }
     }
 }
 
diff --git a/crates/driver/src/infra/mempool/mod.rs b/crates/driver/src/infra/mempool/mod.rs
index ac25841d3f..00d017908a 100644
--- a/crates/driver/src/infra/mempool/mod.rs
+++ b/crates/driver/src/infra/mempool/mod.rs
@@ -7,11 +7,14 @@ use {
     alloy::{
         consensus::Transaction,
         eips::BlockNumberOrTag,
+        primitives::Address,
         providers::{Provider, ext::TxPoolApi},
         rpc::types::TransactionRequest,
     },
     anyhow::Context,
+    dashmap::DashMap,
     ethrpc::Web3,
+    std::sync::Arc,
     url::Url,
 };
 
@@ -64,6 +67,13 @@ pub enum RevertProtection {
 pub struct Mempool {
     transport: Web3,
     config: Config,
+    last_submissions: Arc<DashMap<Address, Submission>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Submission {
+    pub nonce: u64,
+    pub gas_price: eth::GasPrice,
 }
 
 impl std::fmt::Display for Mempool {
@@ -79,7 +89,11 @@ impl Mempool {
         for account in solver_accounts {
             transport.wallet.register_signer(account);
         }
-        Self { transport, config }
+        Self {
+            transport,
+            config,
+            last_submissions: Default::default(),
+        }
     }
 
     /// Fetches the transaction count (nonce) for the given address at the
@@ -153,19 +167,19 @@ impl Mempool {
                     solver = ?solver.address(),
                     "successfully submitted tx to mempool"
                 );
+                self.last_submissions
+                    .insert(solver.address(), Submission { nonce, gas_price });
                 Ok(eth::TxId(*tx.tx_hash()))
             }
             Err(err) => {
                 // log pending tx in case we failed to replace a pending tx
-                let pending_tx = self
-                    .find_pending_tx_in_mempool(solver.address(), nonce)
-                    .await;
+                let last_submission = self.last_submission(solver.address());
 
                 tracing::debug!(
                     ?err,
                     new_gas_price = ?gas_price,
                     ?nonce,
-                    ?pending_tx,
+                    ?last_submission,
                     ?gas_limit,
                     solver = ?solver.address(),
                     "failed to submit tx to mempool"
@@ -199,6 +213,13 @@ impl Mempool {
         Ok(pending_tx)
     }
 
+    /// Looks up the last tx that was submitted for that signer.
+    pub fn last_submission(&self, signer: eth::Address) -> Option<Submission> {
+        self.last_submissions
+            .get(&signer)
+            .map(|entry| entry.value().clone())
+    }
+
     pub fn config(&self) -> &Config {
         &self.config
     }
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 6bc22e894f..5507ec5045 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -9,7 +9,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true, default-features = false, features = ["json-rpc", "providers", "rpc-client", "rpc-types", "transports", "reqwest", "signers", "signer-local", "signer-mnemonic", "provider-anvil-api", "provider-debug-api", "sol-types"] }
+alloy = { workspace = true, default-features = false, features = ["json-rpc", "providers", "provider-txpool-api", "rpc-client", "rpc-types", "transports", "reqwest", "signers", "signer-local", "signer-mnemonic", "provider-anvil-api", "provider-debug-api", "sol-types"] }
 alloy-signer = {workspace = true, default-features = false, features = ["eip712"]}
 anyhow = { workspace = true }
 app-data = { workspace = true }

From 7081b03f66c5154cc84ae93f79542425803b4639 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Mon, 26 Jan 2026 13:00:35 +0100
Subject: [PATCH 005/219] Optimize live orders queries based on
 confirmed_valid_to column (#4055)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Second part of https://github.com/cowprotocol/services/pull/4047 which
introduced optimized queries based on the introduced confirmed_valid_to
column

It is **crucial** for the database to be already migrated manually as
described in previous PR before applying this one.

# Changes
- [x] Adapt user_orders_with_quote query to use new column
- [x] Adapt solvable_orders query to use new column

## How to test
Tested on a test-db created by @MartinquaXD which contains a snapshot of
prod data. The optimized queries run significantly faster due to changes
in `orders` table and new indices.

## Related Issues
https://github.com/cowprotocol/services/pull/4021

---------

Co-authored-by: ilya <ilya@cow.fi>
Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/database/src/orders.rs                 | 96 ++++++++-----------
 database/README.md                            |  2 +
 .../sql/V098__set_true_valid_to_non_null.sql  |  8 ++
 .../V099__create_true_valid_to_indexes.sql    |  4 +
 4 files changed, 56 insertions(+), 54 deletions(-)
 create mode 100644 database/sql/V098__set_true_valid_to_non_null.sql
 create mode 100644 database/sql/V099__create_true_valid_to_indexes.sql

diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index d1f77cb052..78e2d73b86 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -721,26 +721,23 @@ pub fn solvable_orders(
     /// - pending pre-signature
     /// - ethflow specific invalidation conditions
     const OPEN_ORDERS: &str = r#"
-    WITH live_orders AS (
+    WITH live_orders AS MATERIALIZED (
         SELECT o.*
         FROM   orders o
-        LEFT   JOIN ethflow_orders e ON e.uid = o.uid
         WHERE  o.cancellation_timestamp IS NULL
-          AND  o.valid_to >= $1
-          AND (e.valid_to IS NULL OR e.valid_to >= $1)
-          AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
-          AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
-          AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
-                                                                         AND op.placement_error IS NOT NULL)
+            AND o.true_valid_to >= $1
+            AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
     ),
     trades_agg AS (
-         SELECT t.order_uid,
-                SUM(t.buy_amount) AS sum_buy,
-                SUM(t.sell_amount) AS sum_sell,
-                SUM(t.fee_amount) AS sum_fee
-         FROM trades t
-         JOIN live_orders lo ON lo.uid = t.order_uid
-         GROUP BY t.order_uid
+        SELECT t.order_uid,
+           SUM(t.buy_amount) AS sum_buy,
+           SUM(t.sell_amount) AS sum_sell,
+           SUM(t.fee_amount) AS sum_fee
+        FROM trades t
+        JOIN live_orders lo ON lo.uid = t.order_uid
+        GROUP BY t.order_uid
     )
     SELECT
         lo.uid,
@@ -960,46 +957,37 @@ pub async fn user_orders_with_quote(
     owner: &Address,
 ) -> Result<Vec<OrderWithQuote>, sqlx::Error> {
     // Optimized version following the same pattern as OPEN_ORDERS
-    #[rustfmt::skip]
     const QUERY: &str = r#"
-WITH live_orders AS (
-    SELECT o.*
-    FROM   orders o
-    LEFT   JOIN ethflow_orders e ON e.uid = o.uid
-    WHERE  o.cancellation_timestamp IS NULL
-      AND  o.valid_to >= $1
-      AND (e.valid_to IS NULL OR e.valid_to >= $1)
-      AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
-      AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
-      AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
-                                                                     AND op.placement_error IS NOT NULL)
-      AND  o.owner = $2
-      AND  o.class = 'limit'
-),
-trades_agg AS (
-     SELECT t.order_uid,
-            SUM(t.buy_amount) AS sum_buy,
-            SUM(t.sell_amount) AS sum_sell,
-            SUM(t.fee_amount) AS sum_fee
-     FROM trades t
-     JOIN live_orders lo ON lo.uid = t.order_uid
-     GROUP BY t.order_uid
-)
-SELECT
-    o_quotes.sell_amount as quote_sell_amount,
-    lo.sell_amount as order_sell_amount,
-    o_quotes.buy_amount as quote_buy_amount,
-    lo.buy_amount as order_buy_amount,
-    lo.kind as order_kind,
-    o_quotes.gas_amount as quote_gas_amount,
-    o_quotes.gas_price as quote_gas_price,
-    o_quotes.sell_token_price as quote_sell_token_price
-FROM live_orders lo
-LEFT JOIN trades_agg ta ON  ta.order_uid = lo.uid
-INNER JOIN order_quotes o_quotes ON lo.uid = o_quotes.order_uid
-WHERE ((lo.kind = 'sell' AND COALESCE(ta.sum_sell,0) < lo.sell_amount) OR
-       (lo.kind = 'buy'  AND COALESCE(ta.sum_buy ,0) < lo.buy_amount))
-"#;
+    WITH live_orders AS MATERIALIZED (
+        SELECT o.*
+        FROM   orders o
+        WHERE  o.cancellation_timestamp IS NULL
+            AND o.true_valid_to >= $1
+            AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
+            AND  o.owner = $2
+            AND  o.class = 'limit'
+    )
+    SELECT
+        o_quotes.sell_amount  AS quote_sell_amount,
+        lo.sell_amount        AS order_sell_amount,
+        o_quotes.buy_amount   AS quote_buy_amount,
+        lo.buy_amount         AS order_buy_amount,
+        lo.kind               AS order_kind,
+        o_quotes.gas_amount   AS quote_gas_amount,
+        o_quotes.gas_price    AS quote_gas_price,
+        o_quotes.sell_token_price AS quote_sell_token_price
+    FROM live_orders lo
+    INNER JOIN order_quotes o_quotes ON lo.uid = o_quotes.order_uid
+    WHERE (
+        lo.kind = 'sell'
+        AND COALESCE((SELECT SUM(sell_amount) FROM trades WHERE order_uid = lo.uid), 0) < lo.sell_amount
+    ) OR (
+        lo.kind = 'buy'
+        AND COALESCE((SELECT SUM(buy_amount) FROM trades WHERE order_uid = lo.uid), 0) < lo.buy_amount
+    );
+    "#;
     sqlx::query_as::<_, OrderWithQuote>(QUERY)
         .bind(min_valid_to)
         .bind(owner)
diff --git a/database/README.md b/database/README.md
index 4e427976a7..04d5407171 100644
--- a/database/README.md
+++ b/database/README.md
@@ -272,6 +272,8 @@ Indexes:
 - order_sell_buy_tokens: btree(`sell_token`, `buy_token`)
 - user_order_creation_timestamp: btree(`owner`, `creation_timestamp` DESC)
 - version_idx: btree(`settlement_contract`)
+- orders\_true\_valid\_to: btree(`true_valid_to`)
+- okay\_onchain\_orders: btree(`uid`) WHERE placement\_error IS NOT NULL
 
 ### fee_policies
 
diff --git a/database/sql/V098__set_true_valid_to_non_null.sql b/database/sql/V098__set_true_valid_to_non_null.sql
new file mode 100644
index 0000000000..76a0928527
--- /dev/null
+++ b/database/sql/V098__set_true_valid_to_non_null.sql
@@ -0,0 +1,8 @@
+-- migrate any remaining orders
+UPDATE orders
+SET true_valid_to = COALESCE(
+    (SELECT ethflow_orders.valid_to FROM ethflow_orders WHERE ethflow_orders.uid = orders.uid),
+    orders.valid_to
+);
+-- at this point every order has the true_valid_to filled in
+ALTER TABLE orders ALTER COLUMN true_valid_to SET NOT NULL;
diff --git a/database/sql/V099__create_true_valid_to_indexes.sql b/database/sql/V099__create_true_valid_to_indexes.sql
new file mode 100644
index 0000000000..1b4754f29b
--- /dev/null
+++ b/database/sql/V099__create_true_valid_to_indexes.sql
@@ -0,0 +1,4 @@
+--index on `true_valid_to` for quickly discarding expired orders
+CREATE INDEX CONCURRENTLY orders_true_valid_to ON orders USING btree (true_valid_to);
+-- further drops the query from 100ms to 80ms (warmed cache)
+CREATE INDEX CONCURRENTLY okay_onchain_orders ON onchain_placed_orders USING btree (uid) WHERE placement_error IS NOT NULL;

From a71f5776eb227f054b29fe5fb082c25a0baaf293 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 26 Jan 2026 12:36:17 +0000
Subject: [PATCH 006/219] [TRIVIAL] Remove atty and move maplit to
 dev-dependencies (#4089)

# Description
While migrating the orderbook to axum I did another pass over the
dependencies and found that atty not only is deprecated, it has a
RUSTSEC because its unmaintained and a proper replacement since Rust
1.70

# Changes
- [ ] Replace deprecated atty crate with std::io::IsTerminal
(https://github.com/softprops/atty/blob/master/README.md?plain=1#L3-L7)
- [ ] Move maplit to dev-dependencies

## How to test
Compilation

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .cargo/audit.toml                            | 12 ------
 Cargo.lock                                   | 45 +-------------------
 Cargo.toml                                   |  1 -
 crates/observe/Cargo.toml                    |  1 -
 crates/observe/src/tracing.rs                |  5 ++-
 crates/solver/Cargo.toml                     |  2 +-
 crates/solver/src/interactions/allowances.rs |  3 +-
 7 files changed, 6 insertions(+), 63 deletions(-)

diff --git a/.cargo/audit.toml b/.cargo/audit.toml
index fbc8447a84..6b6afa04fe 100644
--- a/.cargo/audit.toml
+++ b/.cargo/audit.toml
@@ -29,22 +29,10 @@ ignore = [
     # Needs upgrade to 0.3.20+ (minimal risk in current usage)
     "RUSTSEC-2025-0055",
 
-    # atty - Unmaintained (RUSTSEC-2024-0375)
-    # Migrate to std::io::IsTerminal (tracked in #3338)
-    "RUSTSEC-2024-0375",
-
-    # atty - Unsound potential unaligned read (RUSTSEC-2021-0145)
-    # Will be removed when migrating to std::io::IsTerminal
-    "RUSTSEC-2021-0145",
-
     # derivative - Unmaintained (RUSTSEC-2024-0388)
     # Evaluate alternatives (tracked in #3338)
     "RUSTSEC-2024-0388",
 
-    # adler - Unmaintained (RUSTSEC-2025-0056)
-    # Use adler2 instead (tracked in #3338)
-    "RUSTSEC-2025-0056",
-
     # instant - Unmaintained (RUSTSEC-2024-0384)
     # Use web-time instead (tracked in #3338)
     "RUSTSEC-2024-0384",
diff --git a/Cargo.lock b/Cargo.lock
index 108ddec027..bad5e2cfac 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1136,17 +1136,6 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "auto_impl"
 version = "1.3.0"
@@ -3521,15 +3510,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -4643,7 +4623,7 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
- "hermit-abi 0.5.2",
+ "hermit-abi",
  "libc",
 ]
 
@@ -4718,7 +4698,6 @@ name = "observe"
 version = "0.1.0"
 dependencies = [
  "async-trait",
- "atty",
  "axum",
  "chrono",
  "console-subscriber",
@@ -7939,28 +7918,6 @@ dependencies = [
  "wasite",
 ]
 
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
 [[package]]
 name = "windows-core"
 version = "0.62.2"
diff --git a/Cargo.toml b/Cargo.toml
index ed1c68a30e..d0c677d393 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,7 +60,6 @@ web3 = { version = "0.19.0", default-features = false }
 app-data = { path = "crates/app-data" }
 arc-swap = "1.7.1"
 async-stream = "0.3.5"
-atty = "0.2"
 autopilot = { path = "crates/autopilot" }
 aws-config = "1.5.1"
 aws-sdk-s3 = { version = "1.34.0", default-features = false }
diff --git a/crates/observe/Cargo.toml b/crates/observe/Cargo.toml
index 0a21e36dfa..91578c049f 100644
--- a/crates/observe/Cargo.toml
+++ b/crates/observe/Cargo.toml
@@ -7,7 +7,6 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 axum = { workspace = true }
-atty = { workspace = true }
 async-trait = { workspace = true }
 chrono = { workspace = true, features = ["now"] }
 console-subscriber = { workspace = true, optional = true }
diff --git a/crates/observe/src/tracing.rs b/crates/observe/src/tracing.rs
index 98b1012b80..76b01e2196 100644
--- a/crates/observe/src/tracing.rs
+++ b/crates/observe/src/tracing.rs
@@ -84,11 +84,12 @@ fn set_tracing_subscriber(config: &Config) {
                     .with_filter($env_filter)
                     .boxed()
             } else {
+                let is_terminal = std::io::IsTerminal::is_terminal(&std::io::stdout());
                 tracing_subscriber::fmt::layer()
                     .with_timer(timer)
-                    .with_ansi(atty::is(atty::Stream::Stdout))
+                    .with_ansi(is_terminal)
                     .map_event_format(|formatter| TraceIdFmt {
-                        inner: formatter.with_ansi(atty::is(atty::Stream::Stdout)),
+                        inner: formatter.with_ansi(is_terminal),
                     })
                     .with_writer(writer)
                     .with_filter($env_filter)
diff --git a/crates/solver/Cargo.toml b/crates/solver/Cargo.toml
index eac8a5b21a..71efe6cdcd 100644
--- a/crates/solver/Cargo.toml
+++ b/crates/solver/Cargo.toml
@@ -22,7 +22,6 @@ observe = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 itertools = { workspace = true }
-maplit = { workspace = true }
 model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
@@ -36,6 +35,7 @@ tracing = { workspace = true }
 
 [dev-dependencies]
 derivative = { workspace = true }
+maplit = { workspace = true }
 tokio = { workspace = true, features = ["test-util"] }
 testlib = { workspace = true }
 mockall = { workspace = true }
diff --git a/crates/solver/src/interactions/allowances.rs b/crates/solver/src/interactions/allowances.rs
index 085289d2dc..345e40c047 100644
--- a/crates/solver/src/interactions/allowances.rs
+++ b/crates/solver/src/interactions/allowances.rs
@@ -12,7 +12,6 @@ use {
     anyhow::{Context as _, Result, anyhow, ensure},
     contracts::alloy::ERC20,
     ethrpc::Web3,
-    maplit::hashmap,
     shared::{
         http_solver::model::TokenAmount,
         interaction::{EncodedInteraction, Interaction},
@@ -155,7 +154,7 @@ impl AllowanceManaging for AllowanceManager {
         Ok(fetch_allowances(
             self.web3.alloy.clone(),
             self.owner,
-            hashmap! { spender => tokens },
+            HashMap::from([(spender, tokens)]),
         )
         .await?
         .remove(&spender)

From 0188a29597b7ac70459afeacebfcbb06f9213bc2 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 26 Jan 2026 14:16:31 +0100
Subject: [PATCH 007/219] Remove useless logs (#4084)

# Description
Our services are extremely chatty which is annoying for debugging and
overwhelms our logging infra. This PR removes or strips down logs that
should not be needed.

# Changes
- removes huge structs like calldata, access lists, and duplicated
transactions - calldata is still preserved where it matters most (when
resimulating quotes, or in revert errors)
- removes tempo items that needlessly get printed in every log of the
respective trace (where it seemed useful I added 1 log that contained
the data)
- removes logs when solutions could not be merged (this is an optimistic
optimization and solutions are not expected to always be mergeable)
- downgraded some logs from `debug` to `trace` (the ones I think I never
used for any debugging but on the surface level seemed like they might
be useful eventually)
- 404 errors from `/notify` requests
---
 crates/autopilot/src/infra/api.rs             | 12 +---------
 crates/autopilot/src/run_loop.rs              | 14 ++++++++----
 crates/autopilot/src/shadow.rs                |  4 ++--
 crates/driver/src/domain/competition/mod.rs   | 11 +++-------
 .../src/domain/competition/solution/mod.rs    | 22 +++++--------------
 .../domain/competition/solution/settlement.rs |  6 +++--
 .../domain/competition/solution/slippage.rs   |  4 ++--
 crates/driver/src/domain/eth/mod.rs           | 15 ++-----------
 crates/driver/src/domain/quote.rs             |  6 ++++-
 crates/driver/src/infra/observe/mod.rs        |  7 +-----
 crates/driver/src/infra/solver/mod.rs         |  6 +++--
 crates/driver/src/util/http.rs                |  2 +-
 crates/shared/src/price_estimation/mod.rs     |  3 ++-
 crates/shared/src/trade_finding/mod.rs        |  3 ++-
 14 files changed, 44 insertions(+), 71 deletions(-)

diff --git a/crates/autopilot/src/infra/api.rs b/crates/autopilot/src/infra/api.rs
index d45789c671..d7c7477af5 100644
--- a/crates/autopilot/src/infra/api.rs
+++ b/crates/autopilot/src/infra/api.rs
@@ -83,17 +83,7 @@ async fn get_native_price(
 
     let start = Instant::now();
     match state.estimator.estimate_native_price(token, timeout).await {
-        Ok(price) => {
-            let elapsed = start.elapsed();
-            tracing::debug!(
-                ?token,
-                ?timeout,
-                ?elapsed,
-                ?price,
-                "estimated native token price"
-            );
-            Json(NativeTokenPrice { price }).into_response()
-        }
+        Ok(price) => Json(NativeTokenPrice { price }).into_response(),
         Err(err) => {
             let elapsed = start.elapsed();
             tracing::warn!(
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index f793d07c8a..6fce69cbc2 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -245,7 +245,7 @@ impl RunLoop {
 
     /// Sleeps until the next auction is supposed to start, builds it and
     /// returns it.
-    #[instrument(skip(self, prev_auction), fields(prev_auction = prev_auction.as_ref().map(|a| a.id)))]
+    #[instrument(skip_all)]
     async fn next_auction(
         &self,
         start_block: BlockInfo,
@@ -264,7 +264,7 @@ impl RunLoop {
             return None;
         }
 
-        observe::log_auction_delta(&previous, &auction);
+        observe::log_auction_delta(&previous, &auction, &start_block);
         self.probes.liveness.auction();
         Metrics::auction_ready(start_block.observed_at);
         Some(auction)
@@ -311,7 +311,7 @@ impl RunLoop {
         })
     }
 
-    #[instrument(skip_all, fields(auction_id = auction.id, auction_block = auction.block, auction_orders = auction.orders.len()))]
+    #[instrument(skip_all)]
     async fn single_run(self: &Arc<Self>, auction: domain::Auction) {
         let single_run_start = Instant::now();
         tracing::info!(auction_id = ?auction.id, "solving");
@@ -1129,10 +1129,15 @@ pub mod observe {
             self,
             competition::{Unscored, winner_selection::Ranking},
         },
+        ethrpc::block_stream::BlockInfo,
         std::collections::HashSet,
     };
 
-    pub fn log_auction_delta(previous: &Option<domain::Auction>, current: &domain::Auction) {
+    pub fn log_auction_delta(
+        previous: &Option<domain::Auction>,
+        current: &domain::Auction,
+        start_block: &BlockInfo,
+    ) {
         let previous_uids = match previous {
             Some(previous) => previous
                 .orders
@@ -1158,6 +1163,7 @@ pub mod observe {
             removed = ?removed,
             "Orders no longer in auction"
         );
+        tracing::debug!(auction_id = current.id, ?start_block);
     }
 
     pub fn bids(bids: &[domain::competition::Bid<Unscored>]) {
diff --git a/crates/autopilot/src/shadow.rs b/crates/autopilot/src/shadow.rs
index 9198c21fd1..5c28857a7f 100644
--- a/crates/autopilot/src/shadow.rs
+++ b/crates/autopilot/src/shadow.rs
@@ -77,12 +77,12 @@ impl RunLoop {
         loop {
             // We use this as a synchronization mechanism to sync the run loop starts with
             // the next mined block
-            let _ = ethrpc::block_stream::next_block(&self.current_block).await;
+            let start_block = ethrpc::block_stream::next_block(&self.current_block).await;
             let Some(auction) = self.next_auction().await else {
                 tokio::time::sleep(Duration::from_secs(1)).await;
                 continue;
             };
-            observe::log_auction_delta(&previous, &auction);
+            observe::log_auction_delta(&previous, &auction, &start_block);
             self.liveness.auction();
 
             self.single_run(&auction)
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 655ccc568f..869d51d683 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -768,14 +768,9 @@ fn merge(
     for solution in solutions.take(MAX_SOLUTIONS_TO_MERGE) {
         let mut extension = vec![];
         for already_merged in merged.iter() {
-            match solution.merge(already_merged, max_orders_per_merged_solution) {
-                Ok(merged) => {
-                    observe::merged(&solution, already_merged, &merged);
-                    extension.push(merged);
-                }
-                Err(err) => {
-                    observe::not_merged(&solution, already_merged, err);
-                }
+            if let Ok(merged) = solution.merge(already_merged, max_orders_per_merged_solution) {
+                observe::merged(&solution, already_merged, &merged);
+                extension.push(merged);
             }
         }
 
diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index f637661f98..46404cc955 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -51,18 +51,22 @@ pub struct WrapperCall {
 /// A solution represents a set of orders which the solver has found an optimal
 /// way to settle. A [`Solution`] is generated by a solver as a response to a
 /// [`competition::Auction`]. See also [`settlement::Settlement`].
-#[derive(Clone)]
+#[derive(derive_more::Debug, Clone)]
 pub struct Solution {
     id: Id,
     trades: Vec<Trade>,
     prices: Prices,
+    #[debug(ignore)]
     pre_interactions: Vec<eth::Interaction>,
+    #[debug(ignore)]
     interactions: Vec<Interaction>,
+    #[debug(ignore)]
     post_interactions: Vec<eth::Interaction>,
     solver: Solver,
     weth: eth::WethAddress,
     gas: Option<eth::Gas>,
     flashloans: HashMap<order::Uid, Flashloan>,
+    #[debug(ignore)]
     wrappers: Vec<WrapperCall>,
 }
 
@@ -515,22 +519,6 @@ impl Solution {
     }
 }
 
-impl std::fmt::Debug for Solution {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        f.debug_struct("Solution")
-            .field("id", &self.id)
-            .field("trades", &self.trades)
-            .field("prices", &self.prices)
-            .field("pre_interactions", &self.pre_interactions)
-            .field("interactions", &self.interactions)
-            .field("post_interactions", &self.post_interactions)
-            .field("solver", &self.solver.name())
-            .field("gas", &self.gas)
-            .field("flashloans", &self.flashloans)
-            .finish()
-    }
-}
-
 /// Given two solutions returns the factors with
 /// which prices of the second solution would have to be multiplied so that the
 /// given token would have the same price in both solutions.
diff --git a/crates/driver/src/domain/competition/solution/settlement.rs b/crates/driver/src/domain/competition/solution/settlement.rs
index 26a4327fb5..a53cb14a0b 100644
--- a/crates/driver/src/domain/competition/solution/settlement.rs
+++ b/crates/driver/src/domain/competition/solution/settlement.rs
@@ -37,20 +37,22 @@ use {
 /// for the solver (earning reduced rewards). Enforcing these rules ensures that
 /// the settlement can be broadcast safely with high confidence that it will not
 /// be reverted and that it will not result in slashing for the solver.
-#[derive(Debug, Clone)]
+#[derive(derive_more::Debug, Clone)]
 pub struct Settlement {
     pub auction_id: auction::Id,
     /// The prepared on-chain transaction for this settlement
     transaction: SettlementTx,
     /// The gas parameters used by the settlement.
     pub gas: Gas,
+    #[debug(ignore)]
     solution: Solution,
 }
 
-#[derive(Debug, Clone)]
+#[derive(derive_more::Debug, Clone)]
 struct SettlementTx {
     /// Transaction with all internalizable interactions omitted
     internalized: eth::Tx,
+    #[debug(ignore)]
     /// Full Transaction without internalizing any interactions
     uninternalized: eth::Tx,
     /// Whether this settlement has interactions that could make it revert
diff --git a/crates/driver/src/domain/competition/solution/slippage.rs b/crates/driver/src/domain/competition/solution/slippage.rs
index acb30cb147..458a22648d 100644
--- a/crates/driver/src/domain/competition/solution/slippage.rs
+++ b/crates/driver/src/domain/competition/solution/slippage.rs
@@ -87,7 +87,7 @@ impl Parameters {
                 .checked_div(&interaction.output.amount)
                 .ok_or(super::error::Math::DivisionByZero)?
         } else {
-            tracing::warn!(
+            tracing::trace!(
                 input_token = ?interaction.input.token,
                 output_token = ?interaction.output.token,
                 "unable to compute capped slippage; falling back to relative slippage",
@@ -98,7 +98,7 @@ impl Parameters {
                 .into()
         };
 
-        tracing::debug!(?interaction, ?slippage, "applying slippage to liquidity",);
+        tracing::trace!(?interaction, ?slippage, "applying slippage to liquidity",);
         Ok((
             MaxInput(eth::Asset {
                 amount: interaction.input.amount + slippage,
diff --git a/crates/driver/src/domain/eth/mod.rs b/crates/driver/src/domain/eth/mod.rs
index f09d6db76c..53a72b84c4 100644
--- a/crates/driver/src/domain/eth/mod.rs
+++ b/crates/driver/src/domain/eth/mod.rs
@@ -364,27 +364,16 @@ pub enum TxStatus {
 }
 
 /// An onchain transaction.
-#[derive(Clone)]
+#[derive(derive_more::Debug, Clone)]
 pub struct Tx {
     pub from: Address,
     pub to: Address,
     pub value: Ether,
     pub input: Bytes<Vec<u8>>,
+    #[debug(ignore)]
     pub access_list: AccessList,
 }
 
-impl std::fmt::Debug for Tx {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Tx")
-            .field("from", &self.from)
-            .field("to", &self.to)
-            .field("value", &self.value)
-            .field("input", &self.input)
-            .field("access_list", &self.access_list)
-            .finish()
-    }
-}
-
 impl From<Tx> for TransactionRequest {
     fn from(value: Tx) -> Self {
         TransactionRequest::default()
diff --git a/crates/driver/src/domain/quote.rs b/crates/driver/src/domain/quote.rs
index f2b5b33554..ad513d0bfc 100644
--- a/crates/driver/src/domain/quote.rs
+++ b/crates/driver/src/domain/quote.rs
@@ -20,15 +20,19 @@ use {
 };
 
 /// A quote describing the expected outcome of an order.
-#[derive(Debug)]
+#[derive(derive_more::Debug)]
 pub struct Quote {
     pub clearing_prices: HashMap<eth::Address, eth::U256>,
+    #[debug(ignore)]
     pub pre_interactions: Vec<eth::Interaction>,
+    #[debug(ignore)]
     pub interactions: Vec<eth::Interaction>,
     pub solver: eth::Address,
     pub gas: Option<eth::Gas>,
     /// Which `tx.origin` is required to make the quote simulation pass.
+    #[debug(ignore)]
     pub tx_origin: Option<eth::Address>,
+    #[debug(ignore)]
     pub jit_orders: Vec<solution::trade::Jit>,
 }
 
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 0a6f232b5b..07e1b06a12 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -132,12 +132,7 @@ pub fn encoding_failed(solver: &solver::Name, id: &solution::Id, err: &solution:
 
 /// Observe that two solutions were merged.
 pub fn merged(first: &Solution, other: &Solution, result: &Solution) {
-    tracing::debug!(?first, ?other, ?result, "merged solutions");
-}
-
-/// Observe that it was not possible to merge two solutions.
-pub fn not_merged(first: &Solution, other: &Solution, err: solution::error::Merge) {
-    tracing::debug!(?err, ?first, ?other, "solutions can't be merged");
+    tracing::trace!(?first, ?other, ?result, "merged solutions");
 }
 
 /// Observe that scoring is about to start.
diff --git a/crates/driver/src/infra/solver/mod.rs b/crates/driver/src/infra/solver/mod.rs
index 2dc592f5ed..1294375479 100644
--- a/crates/driver/src/infra/solver/mod.rs
+++ b/crates/driver/src/infra/solver/mod.rs
@@ -448,8 +448,10 @@ impl Solver {
         }
         let response_size = self.config.response_size_limit_max_bytes;
         let future = async move {
-            if let Err(error) = util::http::send(response_size, req).await {
-                tracing::warn!(?error, "failed to notify solver");
+            if let Err(error) = util::http::send(response_size, req).await
+                && !matches!(error, util::http::Error::NotOk { code: 404, .. })
+            {
+                tracing::debug!(?error, "failed to notify solver");
             }
         };
         tokio::task::spawn(future.in_current_span());
diff --git a/crates/driver/src/util/http.rs b/crates/driver/src/util/http.rs
index 47b2891610..fee7493b61 100644
--- a/crates/driver/src/util/http.rs
+++ b/crates/driver/src/util/http.rs
@@ -31,7 +31,7 @@ pub async fn send(limit_bytes: usize, req: reqwest::RequestBuilder) -> Result<St
 
 #[derive(Debug, Error)]
 pub enum Error {
-    #[error("response error: {0:?}")]
+    #[error("response error: {0}")]
     Response(#[from] reqwest::Error),
     #[error("the response was too large, the limit was {limit_bytes} bytes")]
     ResponseTooLarge { limit_bytes: usize },
diff --git a/crates/shared/src/price_estimation/mod.rs b/crates/shared/src/price_estimation/mod.rs
index dbbb5a2361..6c5ae2251b 100644
--- a/crates/shared/src/price_estimation/mod.rs
+++ b/crates/shared/src/price_estimation/mod.rs
@@ -535,7 +535,7 @@ pub struct Verification {
     pub buy_token_destination: BuyTokenDestination,
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
+#[derive(Clone, derive_more::Debug, Default, Eq, PartialEq, Deserialize)]
 pub struct Estimate {
     pub out_amount: U256,
     /// full gas cost when settling this order alone on gp
@@ -545,6 +545,7 @@ pub struct Estimate {
     /// Did we verify the correctness of this estimate's properties?
     pub verified: bool,
     /// Data associated with this estimation.
+    #[debug(ignore)]
     pub execution: QuoteExecution,
 }
 
diff --git a/crates/shared/src/trade_finding/mod.rs b/crates/shared/src/trade_finding/mod.rs
index a406500d60..812e53141e 100644
--- a/crates/shared/src/trade_finding/mod.rs
+++ b/crates/shared/src/trade_finding/mod.rs
@@ -30,11 +30,12 @@ pub trait TradeFinding: Send + Sync + 'static {
 }
 
 /// A quote.
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, derive_more::Debug, Default, Eq, PartialEq)]
 pub struct Quote {
     pub out_amount: U256,
     pub gas_estimate: u64,
     pub solver: Address,
+    #[debug(ignore)]
     pub execution: QuoteExecution,
 }
 

From 5ba1e1efb0f6890b8fe755927d1076cb94092bc3 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 26 Jan 2026 14:48:55 +0100
Subject: [PATCH 008/219] Fetch inflight orders from DB (#4087)

# Description
In order to avoid solver solutions conflicting with each other once a
solution for an order was proposed it will get removed from the auction
until its submission deadline has been reached. So far this was managed
entirely in-memory which can lead to issues whenever the autopilot gets
restarted.

# Changes
Since the DB scheme refactor a while ago we now have all the data we
need to recover inflight orders from the DB. This PR replaces the
in-memory inflight order handling by looking them up from the DB.

To make the query fast enough I added an index on the deadline column on
the `competition_auctions` table. With that the query takes ~0.1ms to
look up 10 auctions worth of inflight orders.

<details>
<summary>execution plan</summary>

```
"Unique  (cost=1352.80..1352.98 rows=35 width=57) (actual time=0.041..0.043 rows=1 loops=1)"
"  ->  Sort  (cost=1352.80..1352.89 rows=35 width=57) (actual time=0.040..0.041 rows=1 loops=1)"
"        Sort Key: pte.order_uid"
"        Sort Method: quicksort  Memory: 25kB"
"        ->  Nested Loop  (cost=1.86..1351.90 rows=35 width=57) (actual time=0.028..0.033 rows=1 loops=1)"
"              ->  Nested Loop Anti Join  (cost=1.29..1339.25 rows=4 width=24) (actual time=0.023..0.028 rows=1 loops=1)"
"                    Join Filter: (s.solution_uid = ps.uid)"
"                    ->  Nested Loop  (cost=0.86..1171.92 rows=4 width=24) (actual time=0.013..0.020 rows=2 loops=1)"
"                          ->  Index Scan using competition_auction_deadline on competition_auctions ca  (cost=0.43..11.96 rows=5 width=8) (actual time=0.005..0.006 rows=2 loops=1)"
"                                Index Cond: (deadline > 24300390)"
"                          ->  Index Scan using proposed_solutions_pkey on proposed_solutions ps  (cost=0.43..231.80 rows=19 width=16) (actual time=0.003..0.006 rows=1 loops=2)"
"                                Index Cond: (auction_id = ca.id)"
"                                Filter: is_winner"
"                                Rows Removed by Filter: 8"
"                    ->  Index Scan using settlements_auction_id on settlements s  (cost=0.43..41.69 rows=11 width=16) (actual time=0.003..0.003 rows=0 loops=2)"
"                          Index Cond: (auction_id = ca.id)"
"              ->  Index Only Scan using proposed_trade_executions_pkey on proposed_trade_executions pte  (cost=0.56..3.15 rows=1 width=73) (actual time=0.004..0.004 rows=1 loops=1)"
"                    Index Cond: ((auction_id = ps.auction_id) AND (solution_uid = ps.uid))"
"                    Heap Fetches: 1"
"Planning Time: 0.543 ms"
"Execution Time: 0.079 ms"
```
</details>

## How to test
added a new unit test for the DB query
---
 crates/autopilot/src/infra/persistence/mod.rs |  23 ++-
 crates/autopilot/src/run_loop.rs              |  30 ++--
 crates/database/src/solver_competition_v2.rs  | 148 ++++++++++++++++++
 database/README.md                            |   1 +
 database/sql/V100__add_auction_deadline.sql   |   2 +
 5 files changed, 182 insertions(+), 22 deletions(-)
 create mode 100644 database/sql/V100__add_auction_deadline.sql

diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index e9b8dec947..b816358fda 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -21,7 +21,7 @@ use {
             SellTokenSource as DbSellTokenSource,
             SigningScheme as DbSigningScheme,
         },
-        solver_competition_v2::{Order, Solution},
+        solver_competition_v2::{self, Order, Solution},
     },
     domain::auction::order::{
         BuyTokenDestination as DomainBuyTokenDestination,
@@ -1024,6 +1024,27 @@ impl Persistence {
             .context("solver_competition::fetch_solver_winning_solutions")?,
         )
     }
+
+    /// Fetches orders which are currently inflight. Those orders should
+    /// be omitted from the current auction to avoid onchain reverts.
+    pub async fn fetch_in_flight_orders(
+        &self,
+        current_block: u64,
+    ) -> anyhow::Result<HashSet<crate::domain::OrderUid>> {
+        let _timer = Metrics::get()
+            .database_queries
+            .with_label_values(&["inflight_orders"])
+            .start_timer();
+
+        let mut ex = self.postgres.pool.acquire().await.context("acquire")?;
+        let orders =
+            solver_competition_v2::fetch_in_flight_orders(&mut ex, current_block.cast_signed())
+                .await?;
+        Ok(orders
+            .into_iter()
+            .map(|o| crate::domain::OrderUid(o.0))
+            .collect())
+    }
 }
 
 #[derive(prometheus_metric_storage::MetricStorage)]
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 6fce69cbc2..937f50000f 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -3,7 +3,6 @@ use {
         database::competition::Competition,
         domain::{
             self,
-            OrderUid,
             auction::Id,
             competition::{
                 self,
@@ -53,7 +52,6 @@ use {
         },
         time::{Duration, Instant},
     },
-    tokio::sync::Mutex,
     tracing::{Instrument, instrument},
 };
 
@@ -83,7 +81,6 @@ pub struct RunLoop {
     solver_participation_guard: SolverParticipationGuard,
     solvable_orders_cache: Arc<SolvableOrdersCache>,
     trusted_tokens: AutoUpdatingTokenList,
-    in_flight_orders: Arc<Mutex<HashSet<OrderUid>>>,
     probes: Probes,
     /// Maintenance tasks that should run before every runloop to have
     /// the most recent data available.
@@ -126,7 +123,6 @@ impl RunLoop {
             solver_participation_guard,
             solvable_orders_cache,
             trusted_tokens,
-            in_flight_orders: Default::default(),
             probes,
             maintenance,
             competition_updates_sender,
@@ -403,11 +399,6 @@ impl RunLoop {
         block_deadline: u64,
     ) {
         let solved_order_uids: HashSet<_> = solution.orders().keys().cloned().collect();
-        self.in_flight_orders
-            .lock()
-            .await
-            .extend(solved_order_uids.clone());
-
         let solution_id = solution.id();
         let solver = solution.solver();
         let self_ = self.clone();
@@ -420,7 +411,6 @@ impl RunLoop {
             match self_
                 .settle(
                     &driver_,
-                    solved_order_uids.clone(),
                     solver,
                     auction_id,
                     solution_id,
@@ -734,11 +724,9 @@ impl RunLoop {
 
     /// Execute the solver's solution. Returns Ok when the corresponding
     /// transaction has been mined.
-    #[expect(clippy::too_many_arguments)]
     async fn settle(
         &self,
         driver: &infra::Driver,
-        solved_order_uids: HashSet<OrderUid>,
         solver: eth::Address,
         auction_id: i64,
         solution_id: u64,
@@ -794,12 +782,6 @@ impl RunLoop {
 
         self.store_execution_ended(solver, auction_id, solution_uid, &result);
 
-        // Clean up the in-flight orders regardless the result.
-        self.in_flight_orders
-            .lock()
-            .await
-            .retain(|order| !solved_order_uids.contains(order));
-
         result
     }
 
@@ -913,13 +895,19 @@ impl RunLoop {
         Err(SettleError::Timeout)
     }
 
-    /// Removes orders that are currently being settled to avoid solvers trying
-    /// to fill an order a second time.
+    /// Removes orders that are currently being settled to avoid solver
+    /// solutions conflicting with each other.
     async fn remove_in_flight_orders(
         &self,
         mut auction: domain::RawAuctionData,
     ) -> domain::RawAuctionData {
-        let in_flight = &*self.in_flight_orders.lock().await;
+        let in_flight = self
+            .persistence
+            .fetch_in_flight_orders(auction.block)
+            .await
+            .inspect_err(|err| tracing::warn!(?err, "failed to fetch in-flight orders"))
+            .unwrap_or_default();
+
         if in_flight.is_empty() {
             return auction;
         };
diff --git a/crates/database/src/solver_competition_v2.rs b/crates/database/src/solver_competition_v2.rs
index 0a61cd8382..11aefbcdc9 100644
--- a/crates/database/src/solver_competition_v2.rs
+++ b/crates/database/src/solver_competition_v2.rs
@@ -563,6 +563,35 @@ fn map_rows_to_solutions(rows: Vec<SolutionRow>) -> Result<Vec<Solution>, sqlx::
     Ok(solutions)
 }
 
+/// Fetches all orders for which we must assume that there are
+/// still onchain transactions being mined or submitted.
+///
+/// Those are all orders (JIT or regular) that belong to winning
+/// solutions with a deadline greater than the current block
+/// where the execution actually has not been observed onchain yet.
+pub async fn fetch_in_flight_orders(
+    ex: &mut PgConnection,
+    current_block: i64,
+) -> Result<Vec<OrderUid>, sqlx::Error> {
+    const QUERY: &str = r#"
+    SELECT DISTINCT order_uid
+    FROM competition_auctions ca
+    JOIN proposed_solutions ps ON ps.auction_id = ca.id
+    JOIN proposed_trade_executions pte ON pte.auction_id = ca.id AND pte.solution_uid = ps.uid
+    WHERE ca.deadline > $1
+        AND ps.is_winner = true
+        AND NOT EXISTS (
+            SELECT 1 FROM settlements s
+            WHERE s.auction_id = ca.id AND s.solution_uid = ps.uid
+        );
+    "#;
+
+    sqlx::query_as(QUERY)
+        .bind(current_block)
+        .fetch_all(ex)
+        .await
+}
+
 #[cfg(test)]
 mod tests {
     use {
@@ -1242,4 +1271,123 @@ mod tests {
         assert_eq!(auction_participants.len(), 1);
         assert_eq!(auction_participants[0].participant, solutions[0].solver);
     }
+
+    #[tokio::test]
+    #[ignore]
+    async fn postgres_fetch_inflight_orders() {
+        let mut db = PgConnection::connect("postgresql://").await.unwrap();
+        let mut db = db.begin().await.unwrap();
+        crate::clear_DANGER_(&mut db).await.unwrap();
+
+        let order_uid = |i| ByteArray([i; 56]);
+        let order = |i| Order {
+            uid: order_uid(i),
+            ..Default::default()
+        };
+        let solutions = vec![
+            Solution {
+                uid: 0,
+                id: 0.into(),
+                orders: vec![order(0)],
+                is_winner: true,
+                ..Default::default()
+            },
+            Solution {
+                uid: 1,
+                id: 0.into(),
+                orders: vec![order(1)],
+                is_winner: true,
+                ..Default::default()
+            },
+        ];
+        crate::auction::save(
+            &mut db,
+            crate::auction::Auction {
+                id: 0,
+                block: 0,
+                deadline: 5,
+                order_uids: Default::default(),
+                price_tokens: Default::default(),
+                price_values: Default::default(),
+                surplus_capturing_jit_order_owners: Default::default(),
+            },
+        )
+        .await
+        .unwrap();
+        save(&mut db, 0, &solutions).await.unwrap();
+
+        let solutions = vec![
+            Solution {
+                uid: 2,
+                id: 1.into(),
+                orders: vec![order(2)],
+                is_winner: true,
+                ..Default::default()
+            },
+            Solution {
+                uid: 3,
+                id: 1.into(),
+                orders: vec![order(3)],
+                is_winner: true,
+                ..Default::default()
+            },
+        ];
+        crate::auction::save(
+            &mut db,
+            crate::auction::Auction {
+                id: 1,
+                block: 5,
+                deadline: 10,
+                order_uids: Default::default(),
+                price_tokens: Default::default(),
+                price_values: Default::default(),
+                surplus_capturing_jit_order_owners: Default::default(),
+            },
+        )
+        .await
+        .unwrap();
+        save(&mut db, 1, &solutions).await.unwrap();
+
+        // all orders in flight at block 4
+        let early_block = fetch_in_flight_orders(&mut db, 4).await.unwrap();
+        assert_eq!(early_block.len(), 4);
+        assert!(
+            [0, 1, 2, 3]
+                .into_iter()
+                .all(|id| early_block.contains(&order_uid(id)))
+        );
+
+        // only orders from the later auction in flight at block 5
+        let later_block = fetch_in_flight_orders(&mut db, 5).await.unwrap();
+        assert_eq!(later_block.len(), 2);
+        assert!(
+            [2, 3]
+                .into_iter()
+                .all(|id| later_block.contains(&order_uid(id)))
+        );
+
+        // observe settlement event
+        crate::events::insert_settlement(
+            &mut db,
+            &EventIndex {
+                block_number: 5,
+                log_index: 0,
+            },
+            &Default::default(),
+        )
+        .await
+        .unwrap();
+        // associate with auction 1
+        settlements::update_settlement_auction(&mut db, 5, 0, 1)
+            .await
+            .unwrap();
+        // associate with solution 3
+        settlements::update_settlement_solver(&mut db, 5, 0, Default::default(), 3)
+            .await
+            .unwrap();
+
+        // when an order gets marked as settled we dont consider it inflight anymore
+        let later_block_with_settlement = fetch_in_flight_orders(&mut db, 5).await.unwrap();
+        assert_eq!(later_block_with_settlement, vec![order_uid(2)]);
+    }
 }
diff --git a/database/README.md b/database/README.md
index 04d5407171..8176269204 100644
--- a/database/README.md
+++ b/database/README.md
@@ -64,6 +64,7 @@ Contains all auctions for which a valid solver competition exists.
 
 Indexes:
 - PRIMARY KEY: btree(`id`)
+- competition_auction_deadline: btree(`deadline`)
 
 ### ethflow\_orders
 
diff --git a/database/sql/V100__add_auction_deadline.sql b/database/sql/V100__add_auction_deadline.sql
new file mode 100644
index 0000000000..46e29b8ae3
--- /dev/null
+++ b/database/sql/V100__add_auction_deadline.sql
@@ -0,0 +1,2 @@
+-- adds index on the deadline of an auction to quickly look up inflight orders from the db
+CREATE INDEX CONCURRENTLY competition_auction_deadline ON competition_auctions USING BTREE(deadline);

From 03cad15cfc31cedfde79ba5751473deeaf31880a Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 27 Jan 2026 10:23:15 +0100
Subject: [PATCH 009/219] Stop enforcing body size limit (#4092)

# Description
The shadow competition broke because the driver is now rejecting
`/solve` requests that are too large due to this new
[code](https://github.com/cowprotocol/services/pull/4082/changes#diff-b997d6f696c5591860aef8658bb56d2a03fc4fa6b37b5e0432ce8e5e4e356aa9R61-R64).
This was surprising to me because that code was added specifically
because the new handler is bypassing the original content length
limiting layer so I would have expected huge requests to already cause
issues.

During the investigation I confirmed using the `/solve` requests stored
on S3 that recent auctions are indeed larger than. 10MB. Afterwards I
spun up a driver locally and sent that solve request to the original
code to confirm that it's indeed not throwing any errors.
I further investigated and concluded that the issue is how we build the
driver's http router. The size limiting layer is the first thing that
gets added to the router but it should actually be the last. This caused
the size limit to never go into effect.

# Changes
To resolve the issue quickly and remove this breaking change ASAP I
simply removed the new size limiting logic from the `/solve` request.
In a follow up PR I'll make the size limit configurable and fix the
router.

## How to test
manual test
---
 crates/driver/src/infra/api/mod.rs              |  2 +-
 crates/driver/src/infra/api/routes/solve/mod.rs | 15 +++++++--------
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index 5b42fc88e5..afd3f27578 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -31,7 +31,7 @@ use {
 mod error;
 pub mod routes;
 
-pub const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
+const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
 
 pub struct Api {
     pub solvers: Vec<Solver>,
diff --git a/crates/driver/src/infra/api/routes/solve/mod.rs b/crates/driver/src/infra/api/routes/solve/mod.rs
index 6ed72ffef5..b378dae435 100644
--- a/crates/driver/src/infra/api/routes/solve/mod.rs
+++ b/crates/driver/src/infra/api/routes/solve/mod.rs
@@ -5,7 +5,7 @@ use {
     crate::{
         domain::competition,
         infra::{
-            api::{Error, REQUEST_BODY_LIMIT, State},
+            api::{Error, State},
             observe,
         },
     },
@@ -58,13 +58,12 @@ async fn collect_request_body(
     tracing::trace!("start streaming request body");
     let start = Instant::now();
 
-    // accepting the raw request bypasses axum's request body limiting layer
-    // so we have to manually ensure the body has a reasonable size.
-    let limited_body = http_body::Limited::new(request.into_body(), REQUEST_BODY_LIMIT);
-    let body_bytes = hyper::body::to_bytes(limited_body).await.map_err(|err| {
-        tracing::warn!(?err, "failed to stream request body");
-        competition::Error::MalformedRequest
-    })?;
+    let body_bytes = hyper::body::to_bytes(request.into_body())
+        .await
+        .map_err(|err| {
+            tracing::warn!(?err, "failed to stream request body");
+            competition::Error::MalformedRequest
+        })?;
 
     let duration = start.elapsed();
     Metrics::measure_solve_transfer_time(solver, duration);

From de28ec157233dee6e96dec1d7ac55ac18de0b6e0 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Tue, 27 Jan 2026 16:25:01 +0100
Subject: [PATCH 010/219] =?UTF-8?q?Revert=20"Optimize=20live=20orders=20qu?=
 =?UTF-8?q?eries=20based=20on=20confirmed=5Fvalid=5Fto=20colu=E2=80=A6=20(?=
 =?UTF-8?q?#4094)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
This reverts commit 7081b03f66c5154cc84ae93f79542425803b4639. (PR
https://github.com/cowprotocol/services/pull/4055)
The migrations will be revisited as they could not be applied to prod
due to lockup and long duration.
---
 crates/database/src/orders.rs                 | 96 +++++++++++--------
 database/README.md                            |  2 -
 .../sql/V098__set_true_valid_to_non_null.sql  |  8 --
 .../V099__create_true_valid_to_indexes.sql    |  4 -
 4 files changed, 54 insertions(+), 56 deletions(-)
 delete mode 100644 database/sql/V098__set_true_valid_to_non_null.sql
 delete mode 100644 database/sql/V099__create_true_valid_to_indexes.sql

diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index 78e2d73b86..d1f77cb052 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -721,23 +721,26 @@ pub fn solvable_orders(
     /// - pending pre-signature
     /// - ethflow specific invalidation conditions
     const OPEN_ORDERS: &str = r#"
-    WITH live_orders AS MATERIALIZED (
+    WITH live_orders AS (
         SELECT o.*
         FROM   orders o
+        LEFT   JOIN ethflow_orders e ON e.uid = o.uid
         WHERE  o.cancellation_timestamp IS NULL
-            AND o.true_valid_to >= $1
-            AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
-            AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
-            AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
+          AND  o.valid_to >= $1
+          AND (e.valid_to IS NULL OR e.valid_to >= $1)
+          AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
+          AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
+          AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
+                                                                         AND op.placement_error IS NOT NULL)
     ),
     trades_agg AS (
-        SELECT t.order_uid,
-           SUM(t.buy_amount) AS sum_buy,
-           SUM(t.sell_amount) AS sum_sell,
-           SUM(t.fee_amount) AS sum_fee
-        FROM trades t
-        JOIN live_orders lo ON lo.uid = t.order_uid
-        GROUP BY t.order_uid
+         SELECT t.order_uid,
+                SUM(t.buy_amount) AS sum_buy,
+                SUM(t.sell_amount) AS sum_sell,
+                SUM(t.fee_amount) AS sum_fee
+         FROM trades t
+         JOIN live_orders lo ON lo.uid = t.order_uid
+         GROUP BY t.order_uid
     )
     SELECT
         lo.uid,
@@ -957,37 +960,46 @@ pub async fn user_orders_with_quote(
     owner: &Address,
 ) -> Result<Vec<OrderWithQuote>, sqlx::Error> {
     // Optimized version following the same pattern as OPEN_ORDERS
+    #[rustfmt::skip]
     const QUERY: &str = r#"
-    WITH live_orders AS MATERIALIZED (
-        SELECT o.*
-        FROM   orders o
-        WHERE  o.cancellation_timestamp IS NULL
-            AND o.true_valid_to >= $1
-            AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
-            AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
-            AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
-            AND  o.owner = $2
-            AND  o.class = 'limit'
-    )
-    SELECT
-        o_quotes.sell_amount  AS quote_sell_amount,
-        lo.sell_amount        AS order_sell_amount,
-        o_quotes.buy_amount   AS quote_buy_amount,
-        lo.buy_amount         AS order_buy_amount,
-        lo.kind               AS order_kind,
-        o_quotes.gas_amount   AS quote_gas_amount,
-        o_quotes.gas_price    AS quote_gas_price,
-        o_quotes.sell_token_price AS quote_sell_token_price
-    FROM live_orders lo
-    INNER JOIN order_quotes o_quotes ON lo.uid = o_quotes.order_uid
-    WHERE (
-        lo.kind = 'sell'
-        AND COALESCE((SELECT SUM(sell_amount) FROM trades WHERE order_uid = lo.uid), 0) < lo.sell_amount
-    ) OR (
-        lo.kind = 'buy'
-        AND COALESCE((SELECT SUM(buy_amount) FROM trades WHERE order_uid = lo.uid), 0) < lo.buy_amount
-    );
-    "#;
+WITH live_orders AS (
+    SELECT o.*
+    FROM   orders o
+    LEFT   JOIN ethflow_orders e ON e.uid = o.uid
+    WHERE  o.cancellation_timestamp IS NULL
+      AND  o.valid_to >= $1
+      AND (e.valid_to IS NULL OR e.valid_to >= $1)
+      AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
+      AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
+      AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
+                                                                     AND op.placement_error IS NOT NULL)
+      AND  o.owner = $2
+      AND  o.class = 'limit'
+),
+trades_agg AS (
+     SELECT t.order_uid,
+            SUM(t.buy_amount) AS sum_buy,
+            SUM(t.sell_amount) AS sum_sell,
+            SUM(t.fee_amount) AS sum_fee
+     FROM trades t
+     JOIN live_orders lo ON lo.uid = t.order_uid
+     GROUP BY t.order_uid
+)
+SELECT
+    o_quotes.sell_amount as quote_sell_amount,
+    lo.sell_amount as order_sell_amount,
+    o_quotes.buy_amount as quote_buy_amount,
+    lo.buy_amount as order_buy_amount,
+    lo.kind as order_kind,
+    o_quotes.gas_amount as quote_gas_amount,
+    o_quotes.gas_price as quote_gas_price,
+    o_quotes.sell_token_price as quote_sell_token_price
+FROM live_orders lo
+LEFT JOIN trades_agg ta ON  ta.order_uid = lo.uid
+INNER JOIN order_quotes o_quotes ON lo.uid = o_quotes.order_uid
+WHERE ((lo.kind = 'sell' AND COALESCE(ta.sum_sell,0) < lo.sell_amount) OR
+       (lo.kind = 'buy'  AND COALESCE(ta.sum_buy ,0) < lo.buy_amount))
+"#;
     sqlx::query_as::<_, OrderWithQuote>(QUERY)
         .bind(min_valid_to)
         .bind(owner)
diff --git a/database/README.md b/database/README.md
index 8176269204..32819cf1d5 100644
--- a/database/README.md
+++ b/database/README.md
@@ -273,8 +273,6 @@ Indexes:
 - order_sell_buy_tokens: btree(`sell_token`, `buy_token`)
 - user_order_creation_timestamp: btree(`owner`, `creation_timestamp` DESC)
 - version_idx: btree(`settlement_contract`)
-- orders\_true\_valid\_to: btree(`true_valid_to`)
-- okay\_onchain\_orders: btree(`uid`) WHERE placement\_error IS NOT NULL
 
 ### fee_policies
 
diff --git a/database/sql/V098__set_true_valid_to_non_null.sql b/database/sql/V098__set_true_valid_to_non_null.sql
deleted file mode 100644
index 76a0928527..0000000000
--- a/database/sql/V098__set_true_valid_to_non_null.sql
+++ /dev/null
@@ -1,8 +0,0 @@
--- migrate any remaining orders
-UPDATE orders
-SET true_valid_to = COALESCE(
-    (SELECT ethflow_orders.valid_to FROM ethflow_orders WHERE ethflow_orders.uid = orders.uid),
-    orders.valid_to
-);
--- at this point every order has the true_valid_to filled in
-ALTER TABLE orders ALTER COLUMN true_valid_to SET NOT NULL;
diff --git a/database/sql/V099__create_true_valid_to_indexes.sql b/database/sql/V099__create_true_valid_to_indexes.sql
deleted file mode 100644
index 1b4754f29b..0000000000
--- a/database/sql/V099__create_true_valid_to_indexes.sql
+++ /dev/null
@@ -1,4 +0,0 @@
---index on `true_valid_to` for quickly discarding expired orders
-CREATE INDEX CONCURRENTLY orders_true_valid_to ON orders USING btree (true_valid_to);
--- further drops the query from 100ms to 80ms (warmed cache)
-CREATE INDEX CONCURRENTLY okay_onchain_orders ON onchain_placed_orders USING btree (uid) WHERE placement_error IS NOT NULL;

From 8d6851c992879731ea2ed4c3c29bf19fc62d9e84 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Wed, 28 Jan 2026 10:48:51 +0100
Subject: [PATCH 011/219] Add no-op placeholder migrations for the numbering to
 be continuous (#4096)

# Description
We needed to revert migrations V098, V099, and V097 was spelled wrongly
(lowercase v). Since then V100 has been added and it makes flyway
complain about missing interim migrations.

Adding no-op migrations is enough to keep the continuity.

# Changes
Adds no-op migrations V097, V098 and V099
---
 database/sql/V097__no_op_placeholder.sql           | 1 +
 database/sql/V098__no_op_placeholder.sql           | 1 +
 database/sql/V099__no_op_placeholder.sql           | 1 +
 database/sql/v097__drop_old_cancellation_index.sql | 6 ------
 4 files changed, 3 insertions(+), 6 deletions(-)
 create mode 100644 database/sql/V097__no_op_placeholder.sql
 create mode 100644 database/sql/V098__no_op_placeholder.sql
 create mode 100644 database/sql/V099__no_op_placeholder.sql
 delete mode 100644 database/sql/v097__drop_old_cancellation_index.sql

diff --git a/database/sql/V097__no_op_placeholder.sql b/database/sql/V097__no_op_placeholder.sql
new file mode 100644
index 0000000000..e670655000
--- /dev/null
+++ b/database/sql/V097__no_op_placeholder.sql
@@ -0,0 +1 @@
+-- Migration was omitted to keep numbering continuity, for more information see PR #4096
\ No newline at end of file
diff --git a/database/sql/V098__no_op_placeholder.sql b/database/sql/V098__no_op_placeholder.sql
new file mode 100644
index 0000000000..e670655000
--- /dev/null
+++ b/database/sql/V098__no_op_placeholder.sql
@@ -0,0 +1 @@
+-- Migration was omitted to keep numbering continuity, for more information see PR #4096
\ No newline at end of file
diff --git a/database/sql/V099__no_op_placeholder.sql b/database/sql/V099__no_op_placeholder.sql
new file mode 100644
index 0000000000..e670655000
--- /dev/null
+++ b/database/sql/V099__no_op_placeholder.sql
@@ -0,0 +1 @@
+-- Migration was omitted to keep numbering continuity, for more information see PR #4096
\ No newline at end of file
diff --git a/database/sql/v097__drop_old_cancellation_index.sql b/database/sql/v097__drop_old_cancellation_index.sql
deleted file mode 100644
index 4615206ee2..0000000000
--- a/database/sql/v097__drop_old_cancellation_index.sql
+++ /dev/null
@@ -1,6 +0,0 @@
--- drop index over (creation_timestamp, cancellation timestamp)
--- since it can only be used optimally for queries on the creation_timestamp
--- and a new index over the cancellation timestamp was created in the previous
--- migration
-DROP INDEX IF EXISTS order_creation_cancellation;
-

From d2e2e2d5b6eaab7c9bd869b1e64bab361e59eb82 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Wed, 28 Jan 2026 15:50:38 +0100
Subject: [PATCH 012/219] Rewrite migration V100 to be optional (#4098)

# Description
The migration V100 creates index on competition_auction_deadline on
competition_auctions. To make the prod deployment viable it needs to be
optional (IF NOT EXISTS) which will enable to apply it manually
beforehand.

# Changes
Update the V100 migration to specify IF NOT EXISTS.

## How to test
Will apply the migration manually and deploy on staging to verify.
---
 database/sql/V100__add_auction_deadline.sql | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/database/sql/V100__add_auction_deadline.sql b/database/sql/V100__add_auction_deadline.sql
index 46e29b8ae3..629aa3cfc8 100644
--- a/database/sql/V100__add_auction_deadline.sql
+++ b/database/sql/V100__add_auction_deadline.sql
@@ -1,2 +1,2 @@
 -- adds index on the deadline of an auction to quickly look up inflight orders from the db
-CREATE INDEX CONCURRENTLY competition_auction_deadline ON competition_auctions USING BTREE(deadline);
+CREATE INDEX CONCURRENTLY IF NOT EXISTS competition_auction_deadline ON competition_auctions USING BTREE(deadline);

From 3fefcc03489535a3b2e1efef8d7979f9163a7571 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 28 Jan 2026 14:52:55 +0000
Subject: [PATCH 013/219] Move order outside market log to callsites (#4090)

# Description
The log inside the unwrap does not provide an actionable info, the lack
or order ID, from address, quote ID, make it extremely hard to follow up
on.

More context in
https://cowservices.slack.com/archives/C0375NV72SC/p1769440848303459

# Changes
- [ ] Remove the log from the unwrap
- [ ] Place it in the (seemingly) more relevant callsites

## How to test
NA
---
 crates/shared/src/order_validation.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 70eb6897d3..9db1e46594 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -755,6 +755,7 @@ impl OrderValidating for OrderValidator {
                             },
                             data.kind,
                         ) {
+                            tracing::debug!(%uid, ?owner, ?class, "order being flagged as outside market price");
                             self.check_max_limit_orders(owner).await?;
                         }
                         (class, Some(quote))
@@ -786,6 +787,7 @@ impl OrderValidating for OrderValidator {
                     },
                     data.kind,
                 ) {
+                    tracing::debug!(%uid, ?owner, ?class, "order being flagged as outside market price");
                     self.check_max_limit_orders(owner).await?;
                 }
                 (OrderClass::Limit, None)
@@ -1002,14 +1004,7 @@ pub fn is_order_outside_market_price(
         }
     };
 
-    check().unwrap_or_else(|| {
-        tracing::warn!(
-            ?order,
-            ?quote,
-            "failed to check if order is outside market price"
-        );
-        true
-    })
+    check().unwrap_or(true)
 }
 
 pub struct InvalidSigningScheme;

From ff38a3eb1801c52df891c5daeba31c327eccfaef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 28 Jan 2026 15:14:14 +0000
Subject: [PATCH 014/219] Add configurable database connection pool size
 (#4097)

# Description
We had an incident where latency increase due to queries waiting for
available connections. This PR provides a configuration for that.

Adds `--db-max-connections` (env: DB_MAX_CONNECTIONS) flag to configure
the maximum database pool size. Default is 10.

# Changes
- [ ] New config for DB connection pool size
- [ ] Add it to autopilot, orderbook, refunder

## How to test
E2E + staging (?)

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 crates/autopilot/src/arguments.rs             |  9 +++--
 crates/autopilot/src/database/mod.rs          | 34 ++++++++++++++-----
 .../src/database/onchain_order_events/mod.rs  |  6 +---
 crates/autopilot/src/run.rs                   | 12 +++++--
 crates/orderbook/src/arguments.rs             |  5 +++
 crates/orderbook/src/database/mod.rs          | 25 ++++++++++++--
 crates/orderbook/src/database/orders.rs       | 12 +++----
 .../src/database/solver_competition.rs        |  2 +-
 crates/orderbook/src/orderbook.rs             |  3 +-
 crates/orderbook/src/run.rs                   | 10 ++++--
 crates/refunder/src/arguments.rs              |  5 +++
 crates/refunder/src/lib.rs                    |  7 ++--
 crates/shared/src/arguments.rs                | 19 ++++++++++-
 13 files changed, 113 insertions(+), 36 deletions(-)

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 193be1a5a9..1d0b89897d 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -1,5 +1,5 @@
 use {
-    crate::infra,
+    crate::{database::INSERT_BATCH_SIZE_DEFAULT, infra},
     alloy::primitives::{Address, U256},
     anyhow::{Context, anyhow, ensure},
     chrono::{DateTime, Utc},
@@ -37,6 +37,9 @@ pub struct Arguments {
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
+    #[clap(flatten)]
+    pub database_pool: shared::arguments::DatabasePoolConfig,
+
     /// Address of the ethflow contracts. If not specified, eth-flow orders are
     /// disabled.
     /// In general, one contract is sufficient for the service to function.
@@ -69,7 +72,7 @@ pub struct Arguments {
     pub db_write_url: Url,
 
     /// The number of order events to insert in a single batch.
-    #[clap(long, env, default_value = "500")]
+    #[clap(long, env, default_value_t = INSERT_BATCH_SIZE_DEFAULT)]
     pub insert_batch_size: NonZeroUsize,
 
     /// Skip syncing past events (useful for local deployments)
@@ -370,6 +373,7 @@ impl std::fmt::Display for Arguments {
             http_client,
             token_owner_finder,
             price_estimation,
+            database_pool,
             tracing_node_url,
             ethflow_contracts,
             ethflow_indexing_start,
@@ -418,6 +422,7 @@ impl std::fmt::Display for Arguments {
         write!(f, "{http_client}")?;
         write!(f, "{token_owner_finder}")?;
         write!(f, "{price_estimation}")?;
+        write!(f, "{database_pool}")?;
         display_option(f, "tracing_node_url", tracing_node_url)?;
         writeln!(f, "ethflow_contracts: {ethflow_contracts:?}")?;
         writeln!(f, "ethflow_indexing_start: {ethflow_indexing_start:?}")?;
diff --git a/crates/autopilot/src/database/mod.rs b/crates/autopilot/src/database/mod.rs
index f6a981c5ee..98f7c4bbb6 100644
--- a/crates/autopilot/src/database/mod.rs
+++ b/crates/autopilot/src/database/mod.rs
@@ -1,7 +1,11 @@
 use {
     num::ToPrimitive,
-    sqlx::{Executor, PgConnection, PgPool},
-    std::{num::NonZeroUsize, time::Duration},
+    shared::arguments::DB_MAX_CONNECTIONS_DEFAULT,
+    sqlx::{Executor, PgConnection, PgPool, postgres::PgPoolOptions},
+    std::{
+        num::{NonZeroU32, NonZeroUsize},
+        time::Duration,
+    },
     tracing::Instrument,
 };
 
@@ -15,9 +19,21 @@ pub mod onchain_order_events;
 pub mod order_events;
 mod quotes;
 
+pub const INSERT_BATCH_SIZE_DEFAULT: NonZeroUsize = NonZeroUsize::new(500).unwrap();
+
 #[derive(Debug, Clone)]
 pub struct Config {
     pub insert_batch_size: NonZeroUsize,
+    pub max_pool_size: NonZeroU32,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            insert_batch_size: INSERT_BATCH_SIZE_DEFAULT,
+            max_pool_size: DB_MAX_CONNECTIONS_DEFAULT,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -27,15 +43,15 @@ pub struct Postgres {
 }
 
 impl Postgres {
-    pub async fn new(url: &str, insert_batch_size: NonZeroUsize) -> sqlx::Result<Self> {
-        let pool = PgPool::connect(url).await?;
+    pub async fn new(url: &str, config: Config) -> sqlx::Result<Self> {
+        let pool = PgPoolOptions::new()
+            .max_connections(config.max_pool_size.get())
+            .connect(url)
+            .await?;
 
         Self::start_db_metrics_job(pool.clone());
 
-        Ok(Self {
-            pool,
-            config: Config { insert_batch_size },
-        })
+        Ok(Self { pool, config })
     }
 
     fn start_db_metrics_job(pool: PgPool) {
@@ -57,7 +73,7 @@ impl Postgres {
     }
 
     pub async fn with_defaults() -> sqlx::Result<Self> {
-        Self::new("postgresql://", NonZeroUsize::new(500).unwrap()).await
+        Self::new("postgresql://", Default::default()).await
     }
 
     pub async fn update_database_metrics(&self) -> sqlx::Result<()> {
diff --git a/crates/autopilot/src/database/onchain_order_events/mod.rs b/crates/autopilot/src/database/onchain_order_events/mod.rs
index d4af7be9b1..bf4d352aff 100644
--- a/crates/autopilot/src/database/onchain_order_events/mod.rs
+++ b/crates/autopilot/src/database/onchain_order_events/mod.rs
@@ -780,7 +780,6 @@ mod test {
 
     use {
         super::*,
-        crate::database::Config,
         alloy::primitives::U256,
         contracts::alloy::CoWSwapOnchainOrders,
         database::{byte_array::ByteArray, onchain_broadcasted_orders::OnchainOrderPlacement},
@@ -802,7 +801,6 @@ mod test {
             order_quoting::{MockOrderQuoting, Quote, QuoteData},
         },
         sqlx::PgPool,
-        std::num::NonZeroUsize,
     };
 
     #[test]
@@ -1250,9 +1248,7 @@ mod test {
         let onchain_order_parser = OnchainOrderParser {
             db: Postgres {
                 pool: PgPool::connect_lazy("postgresql://").unwrap(),
-                config: Config {
-                    insert_batch_size: NonZeroUsize::new(500).unwrap(),
-                },
+                config: Default::default(),
             },
             trampoline: HooksTrampoline::Instance::deployed(&web3.alloy)
                 .await
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 14e6ac8731..38ba0bd965 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -163,9 +163,15 @@ pub async fn start(args: impl Iterator<Item = String>) {
 /// Assumes tracing and metrics registry have already been set up.
 pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     assert!(args.shadow.is_none(), "cannot run in shadow mode");
-    let db_write = Postgres::new(args.db_write_url.as_str(), args.insert_batch_size)
-        .await
-        .unwrap();
+    let db_write = Postgres::new(
+        args.db_write_url.as_str(),
+        crate::database::Config {
+            insert_batch_size: args.insert_batch_size,
+            max_pool_size: args.database_pool.db_max_connections,
+        },
+    )
+    .await
+    .unwrap();
 
     // If the DB is in read-only mode, running ANALYZE is not possible and will
     // trigger and error https://www.postgresql.org/docs/current/hot-standby.html
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index f788d3541a..a5dcad6de6 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -28,6 +28,9 @@ pub struct Arguments {
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
+    #[clap(flatten)]
+    pub database_pool: shared::arguments::DatabasePoolConfig,
+
     /// A tracing Ethereum node URL to connect to, allowing a separate node URL
     /// to be used exclusively for tracing calls.
     #[clap(long, env)]
@@ -181,6 +184,7 @@ impl std::fmt::Display for Arguments {
             http_client,
             token_owner_finder,
             price_estimation,
+            database_pool,
             tracing_node_url,
             bind_address,
             min_order_validity_period,
@@ -211,6 +215,7 @@ impl std::fmt::Display for Arguments {
         write!(f, "{http_client}")?;
         write!(f, "{token_owner_finder}")?;
         write!(f, "{price_estimation}")?;
+        write!(f, "{database_pool}")?;
         display_option(f, "tracing_node_url", tracing_node_url)?;
         writeln!(f, "bind_address: {bind_address}")?;
         let _intentionally_ignored = db_url;
diff --git a/crates/orderbook/src/database/mod.rs b/crates/orderbook/src/database/mod.rs
index fa6f1092df..76a44ad7cc 100644
--- a/crates/orderbook/src/database/mod.rs
+++ b/crates/orderbook/src/database/mod.rs
@@ -14,26 +14,45 @@ use {
     anyhow::Result,
     database::byte_array::ByteArray,
     model::order::Order,
-    sqlx::{PgConnection, PgPool},
+    shared::arguments::DB_MAX_CONNECTIONS_DEFAULT,
+    sqlx::{PgConnection, PgPool, postgres::PgPoolOptions},
 };
 
 // TODO: There is remaining optimization potential by implementing sqlx encoding
 // and decoding for U256 directly instead of going through BigDecimal. This is
 // not very important as this is fast enough anyway.
 
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub max_pool_size: u32,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            // Match SQLx default pool size
+            max_pool_size: DB_MAX_CONNECTIONS_DEFAULT.get(),
+        }
+    }
+}
+
 // The pool uses an Arc internally.
 #[derive(Clone)]
 pub struct Postgres {
     pub pool: PgPool,
+    pub config: Config,
 }
 
 // The implementation is split up into several modules which contain more public
 // methods.
 
 impl Postgres {
-    pub fn try_new(uri: &str) -> Result<Self> {
+    pub fn try_new(uri: &str, config: Config) -> Result<Self> {
         Ok(Self {
-            pool: PgPool::connect_lazy(uri)?,
+            pool: PgPoolOptions::new()
+                .max_connections(config.max_pool_size)
+                .connect_lazy(uri)?,
+            config,
         })
     }
 
diff --git a/crates/orderbook/src/database/orders.rs b/crates/orderbook/src/database/orders.rs
index aa115e33dc..067f444a66 100644
--- a/crates/orderbook/src/database/orders.rs
+++ b/crates/orderbook/src/database/orders.rs
@@ -867,7 +867,7 @@ mod tests {
     async fn postgres_replace_order() {
         let owner = Address::repeat_byte(0x77);
 
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
 
         let old_order = Order {
@@ -933,7 +933,7 @@ mod tests {
     async fn postgres_replace_order_no_cancellation_on_error() {
         let owner = Address::repeat_byte(0x77);
 
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
 
         let old_order = Order {
@@ -977,7 +977,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn postgres_presignature_status() {
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
         let uid = OrderUid([0u8; 56]);
         let order = Order {
@@ -1050,7 +1050,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn postgres_cancel_orders() {
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
 
         // Define some helper closures to make the test easier to read.
@@ -1099,7 +1099,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn postgres_insert_orders_with_interactions() {
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
 
         let interaction = |byte: u8| InteractionData {
@@ -1156,7 +1156,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn postgres_insert_orders_with_interactions_and_verified() {
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
 
         let quote = Quote {
diff --git a/crates/orderbook/src/database/solver_competition.rs b/crates/orderbook/src/database/solver_competition.rs
index 8aba3a057d..a04ece3e1d 100644
--- a/crates/orderbook/src/database/solver_competition.rs
+++ b/crates/orderbook/src/database/solver_competition.rs
@@ -124,7 +124,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn not_found_error() {
-        let db = Postgres::try_new("postgresql://").unwrap();
+        let db = Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&db.pool).await.unwrap();
 
         let result = db
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index 3c77c6515a..2b91f941b1 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -684,7 +684,8 @@ mod tests {
                 ))
             });
 
-        let database = crate::database::Postgres::try_new("postgresql://").unwrap();
+        let database =
+            crate::database::Postgres::try_new("postgresql://", Default::default()).unwrap();
         database::clear_DANGER(&database.pool).await.unwrap();
         database.insert_order(&old_order).await.unwrap();
 
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 9229cd8b20..04e65e5fd3 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -172,13 +172,17 @@ pub async fn run(args: Arguments) {
         .await
         .expect("Deployed contract constants don't match the ones in this binary");
     let domain_separator = DomainSeparator::new(chain_id, *settlement_contract.address());
-    let postgres_write =
-        Postgres::try_new(args.db_write_url.as_str()).expect("failed to create database");
+    let db_config = crate::database::Config {
+        max_pool_size: args.database_pool.db_max_connections.get(),
+    };
+    let postgres_write = Postgres::try_new(args.db_write_url.as_str(), db_config.clone())
+        .expect("failed to create database");
 
     let postgres_read = if let Some(db_read_url) = args.db_read_url
         && args.db_write_url != db_read_url
     {
-        Postgres::try_new(db_read_url.as_str()).expect("failed to create read replica databaseR")
+        Postgres::try_new(db_read_url.as_str(), db_config)
+            .expect("failed to create read replica database")
     } else {
         postgres_write.clone()
     };
diff --git a/crates/refunder/src/arguments.rs b/crates/refunder/src/arguments.rs
index 2dccf273cb..5e3c09d9bc 100644
--- a/crates/refunder/src/arguments.rs
+++ b/crates/refunder/src/arguments.rs
@@ -19,6 +19,9 @@ pub struct Arguments {
     #[clap(flatten)]
     pub logging: LoggingArguments,
 
+    #[clap(flatten)]
+    pub database_pool: shared::arguments::DatabasePoolConfig,
+
     /// Minimum time in seconds an order must have been valid for
     /// to be eligible for refunding
     #[clap(
@@ -94,6 +97,7 @@ impl std::fmt::Display for Arguments {
             ethflow_contracts,
             metrics_port,
             logging,
+            database_pool,
             db_url,
             refunder_pk,
             max_gas_price,
@@ -104,6 +108,7 @@ impl std::fmt::Display for Arguments {
         write!(f, "{http_client}")?;
         write!(f, "{ethrpc}")?;
         write!(f, "{logging}")?;
+        write!(f, "{database_pool}")?;
         writeln!(f, "min_validity_duration: {min_validity_duration:?}")?;
         writeln!(f, "min_price_deviation_bps: {min_price_deviation_bps}")?;
         let _intentionally_ignored = db_url;
diff --git a/crates/refunder/src/lib.rs b/crates/refunder/src/lib.rs
index a3132063db..4fc9a59675 100644
--- a/crates/refunder/src/lib.rs
+++ b/crates/refunder/src/lib.rs
@@ -12,7 +12,7 @@ use {
     observe::metrics::LivenessChecking,
     refund_service::RefundService,
     shared::http_client::HttpClientFactory,
-    sqlx::PgPool,
+    sqlx::postgres::PgPoolOptions,
     std::{
         sync::{Arc, RwLock},
         time::{Duration, Instant},
@@ -54,7 +54,10 @@ pub async fn run(args: arguments::Arguments) {
         );
     }
 
-    let pg_pool = PgPool::connect_lazy(args.db_url.as_str()).expect("failed to create database");
+    let pg_pool = PgPoolOptions::new()
+        .max_connections(args.database_pool.db_max_connections.get())
+        .connect_lazy(args.db_url.as_str())
+        .expect("failed to create database");
 
     let liveness = Arc::new(Liveness {
         // Program will be healthy at the start even if no loop was ran yet.
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 59e72a6d69..46f542e195 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -13,7 +13,7 @@ use {
     std::{
         collections::HashSet,
         fmt::{self, Display, Formatter},
-        num::NonZeroU64,
+        num::{NonZeroU32, NonZeroU64},
         str::FromStr,
         time::Duration,
     },
@@ -126,6 +126,23 @@ pub fn tracing_config(args: &TracingArguments, service_name: String) -> Option<T
     ))
 }
 
+// Matches SQLx default connection pool size.
+// SAFETY: 10 > 0
+pub const DB_MAX_CONNECTIONS_DEFAULT: NonZeroU32 = NonZeroU32::new(10).unwrap();
+
+#[derive(Debug, Clone, clap::Parser)]
+pub struct DatabasePoolConfig {
+    /// Maximum number of connections in the database connection pool.
+    #[clap(long, env, default_value_t = DB_MAX_CONNECTIONS_DEFAULT)]
+    pub db_max_connections: NonZeroU32,
+}
+
+impl Display for DatabasePoolConfig {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        writeln!(f, "db_max_connections: {}", self.db_max_connections)
+    }
+}
+
 #[derive(clap::Parser)]
 #[group(skip)]
 pub struct Arguments {

From 2507e915d509c08b58e21394b9062a6cfa68476f Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Wed, 28 Jan 2026 16:53:42 +0100
Subject: [PATCH 015/219] Fix migrations introducing indexes on true_valid_to
 (#4095)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Reinstates https://github.com/cowprotocol/services/pull/4055 with
improved migrations that should successfully apply
to prod.

The previous migrations tended to lock-up indefinitely on prod database
when running UPDATE on all rows in the `orders` table to ensure
`true_valid_to` is not null. This was done as an additional safety layer
as these rows have been manually backfilled previously, so it is no
longer needed and turned out to be problematic.

Additionally, the index creation can take more time than is allowed for
release deployment which causes them to be aborted. It is easier to
create them manually and have the migration CREATE INDEX IF NOT EXISTS.

# Changes
- Had to move migrations from 098, 099 to 101, 102 as there was a
migration 100 merged in the meantime.

- Moves migration 098 to 101.
Removes conservative backfill of empty `true_valid_to` which caused a
lock-up on the prod database.
- Moves migration 099 to 102
Makes index creation optional (CREATE INDEX IF NOT EXISTS) as they will
be created manually, to ensure smooth deployment.

---------

Co-authored-by: ilya <ilya@cow.fi>
Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 database/sql/V101__set_true_valid_to_non_null.sql   | 1 +
 database/sql/V102__create_true_valid_to_indexes.sql | 4 ++++
 2 files changed, 5 insertions(+)
 create mode 100644 database/sql/V101__set_true_valid_to_non_null.sql
 create mode 100644 database/sql/V102__create_true_valid_to_indexes.sql

diff --git a/database/sql/V101__set_true_valid_to_non_null.sql b/database/sql/V101__set_true_valid_to_non_null.sql
new file mode 100644
index 0000000000..a75a1afb7a
--- /dev/null
+++ b/database/sql/V101__set_true_valid_to_non_null.sql
@@ -0,0 +1 @@
+ALTER TABLE orders ALTER COLUMN true_valid_to SET NOT NULL;
diff --git a/database/sql/V102__create_true_valid_to_indexes.sql b/database/sql/V102__create_true_valid_to_indexes.sql
new file mode 100644
index 0000000000..66baebc5be
--- /dev/null
+++ b/database/sql/V102__create_true_valid_to_indexes.sql
@@ -0,0 +1,4 @@
+--index on `true_valid_to` for quickly discarding expired orders
+CREATE INDEX CONCURRENTLY IF NOT EXISTS orders_true_valid_to ON orders USING btree (true_valid_to);
+-- further drops the query from 100ms to 80ms (warmed cache)
+CREATE INDEX CONCURRENTLY IF NOT EXISTS okay_onchain_orders ON onchain_placed_orders USING btree (uid) WHERE placement_error IS NOT NULL;

From ff190ad02d91a87da0cf30167b030bd4f6f0cdfc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 29 Jan 2026 09:39:44 +0000
Subject: [PATCH 016/219] Migrate gas estimation to match alloy's type (#4054)

> [!CAUTION]
> Review with care! The changes are non trivial and there is one
breaking change, the gas price returned by the driver no longer includes
the base fee!

# Description

Refactors gas price handling to use integer arithmetic and alloy's
native types instead of floating-point
calculations. This eliminates precision loss in gas price calculations
and better aligns with alloy's conventions.

The removal of the base fee is not a true removal, before this change,
the base fee was either 0 or the max value available, both leading to
inaccurate results. The new code removes the base fee from the type that
was being used to describe the estimations (because the base_fee isn't
an estimate, it comes in the previous block); but starts querying the
chain for the latest block so it's able to get the proper base_fee (if
available). The gas estimates themselves should suffer a big change
(since the estimate code is the same) but the effective gas price should
become more accurate due to the inclusion of the base fee in the
calculations.

# Changes

- Replace custom GasPrice1559 with alloy's Eip1559Estimation throughout
codebase
- Change GasPrice::base from FeePerGas to Option<u64> to match alloy's
base fee representation
- Migrate gas calculations from f64 to u128/U256 integer arithmetic
- Implement calc_effective_gas_price from alloy for effective gas price
calculations
- Add base_fee: Option<u64> to BlockInfo for proper EIP-1559 support
- Update API responses to return u128 directly instead of wrapped U256
- Add scaling helper methods (scaled_by_pct, scaled_by_pml) for clearer
gas price adjustments

# How to test

> [!NOTE]
> Tested on staging, starting at Mon, 19 Jan 2026 12:10:18 +0000.
> Performed a successful trade:
https://staging.explorer.cow.fi/lens/orders/0x06677572a2715cc28241a34f5d669247fba167c8d9adc3fcd338e40a3c52ea4109fbad1ea29c36dfe4f8f7baa87c5edf85e0d9f3696e28f5

1. Run existing test suite: cargo test
2. Verify gas price estimation endpoints return expected values
3. Test refunder gas price calculations with various scenarios (new tx,
replacement tx, max gas price limits)
4. Verify settlement submissions use correct gas parameters

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 .../driver/src/domain/competition/auction.rs  |  13 +-
 .../domain/competition/solution/settlement.rs |   9 +-
 crates/driver/src/domain/eth/gas.rs           |  30 +--
 crates/driver/src/domain/mempools.rs          |  37 ++--
 .../driver/src/infra/api/routes/gasprice.rs   |  31 +--
 crates/driver/src/infra/blockchain/gas.rs     |  35 +++-
 crates/driver/src/infra/blockchain/mod.rs     |  15 +-
 crates/driver/src/infra/mempool/mod.rs        |  20 +-
 crates/driver/src/tests/setup/solver.rs       |  14 +-
 crates/ethrpc/src/block_stream/mod.rs         |  19 +-
 crates/refunder/src/submitter.rs              |  84 ++++----
 crates/shared/src/gas_price.rs                |  37 +++-
 .../configurable_alloy.rs                     |  24 ++-
 .../shared/src/gas_price_estimation/driver.rs |  54 +++--
 .../src/gas_price_estimation/eth_node.rs      |  27 ++-
 .../shared/src/gas_price_estimation/fake.rs   |  23 ++-
 crates/shared/src/gas_price_estimation/mod.rs |  53 ++++-
 .../shared/src/gas_price_estimation/price.rs  | 192 ------------------
 .../src/gas_price_estimation/priority.rs      |  47 ++---
 crates/shared/src/order_quoting.rs            |  44 ++--
 .../src/price_estimation/competition/quote.rs |  16 +-
 21 files changed, 334 insertions(+), 490 deletions(-)
 delete mode 100644 crates/shared/src/gas_price_estimation/price.rs

diff --git a/crates/driver/src/domain/competition/auction.rs b/crates/driver/src/domain/competition/auction.rs
index c91779d029..10bc830db7 100644
--- a/crates/driver/src/domain/competition/auction.rs
+++ b/crates/driver/src/domain/competition/auction.rs
@@ -2,12 +2,13 @@ use {
     crate::{
         domain::{
             competition::{self},
-            eth,
+            eth::{self, GasPrice},
             liquidity,
             time,
         },
         infra::{Ethereum, blockchain, solver::Timeouts},
     },
+    alloy::primitives::U256,
     std::collections::{HashMap, HashSet},
     thiserror::Error,
 };
@@ -56,11 +57,19 @@ impl Auction {
             true
         });
 
+        let gas_est = eth.gas_price().await?;
+        let base_fee = eth.current_block().borrow().base_fee;
+        let gas_price = GasPrice::new(
+            U256::from(gas_est.max_fee_per_gas).into(),
+            U256::from(gas_est.max_priority_fee_per_gas).into(),
+            base_fee,
+        );
+
         Ok(Self {
             id,
             orders,
             tokens,
-            gas_price: eth.gas_price().await?,
+            gas_price,
             deadline,
             surplus_capturing_jit_order_owners,
         })
diff --git a/crates/driver/src/domain/competition/solution/settlement.rs b/crates/driver/src/domain/competition/solution/settlement.rs
index a53cb14a0b..63bf90be3c 100644
--- a/crates/driver/src/domain/competition/solution/settlement.rs
+++ b/crates/driver/src/domain/competition/solution/settlement.rs
@@ -12,6 +12,7 @@ use {
         },
         infra::{Simulator, blockchain::Ethereum, observe, solver::ManageNativeToken},
     },
+    alloy::primitives::U256,
     futures::future::try_join_all,
     std::collections::{BTreeSet, HashMap, HashSet},
     tracing::instrument,
@@ -176,7 +177,9 @@ impl Settlement {
 
         // Ensure that the solver has sufficient balance for the settlement to be mined
         // even if the gas price keeps climbing during the tx submission.
-        let required_eth_balance = gas.required_balance(price * 2.);
+        let required_eth_balance =
+            // Converting to U256 first avoids possible overflow
+            gas.required_balance(U256::from(price.max_fee_per_gas).saturating_mul(U256::from(2)));
         if eth.balance(solution.solver().address()).await? < required_eth_balance {
             return Err(Error::SolverAccountInsufficientBalance(
                 required_eth_balance,
@@ -400,7 +403,7 @@ impl Gas {
 
     /// The balance required to ensure settlement execution with the given gas
     /// parameters.
-    pub fn required_balance(&self, price: eth::GasPrice) -> eth::Ether {
-        self.limit * price.max()
+    pub fn required_balance(&self, max_fee_per_gas: U256) -> eth::Ether {
+        self.limit * max_fee_per_gas.into()
     }
 }
diff --git a/crates/driver/src/domain/eth/gas.rs b/crates/driver/src/domain/eth/gas.rs
index 1f93bf672e..efb72ef7ae 100644
--- a/crates/driver/src/domain/eth/gas.rs
+++ b/crates/driver/src/domain/eth/gas.rs
@@ -1,7 +1,8 @@
 use {
     super::{Ether, U256},
+    alloy::eips::eip1559::calc_effective_gas_price,
     derive_more::{Display, From, Into},
-    std::{ops, ops::Add},
+    std::ops::{self, Add},
 };
 
 /// Gas amount in gas units.
@@ -37,16 +38,18 @@ pub struct GasPrice {
     tip: FeePerGas,
     /// The current base gas price that will be charged to all accounts on the
     /// next block.
-    base: FeePerGas,
+    base: u64,
 }
 
 impl GasPrice {
     /// Returns the estimated [`EffectiveGasPrice`] for the gas price estimate.
     pub fn effective(&self) -> EffectiveGasPrice {
-        let max = self.max.0.0;
-        let base = self.base.0.0;
-        let tip = self.tip.0.0;
-        max.min(base.saturating_add(tip)).into()
+        U256::from(calc_effective_gas_price(
+            u128::try_from(self.max.0.0).expect("max fee per gas should fit in a u128"),
+            u128::try_from(self.tip.0.0).expect("max priority fee per gas should fit in a u128"),
+            Some(self.base),
+        ))
+        .into()
     }
 
     pub fn max(&self) -> FeePerGas {
@@ -57,11 +60,11 @@ impl GasPrice {
         self.tip
     }
 
-    pub fn base(&self) -> FeePerGas {
+    pub fn base(&self) -> u64 {
         self.base
     }
 
-    pub fn new(max: FeePerGas, tip: FeePerGas, base: FeePerGas) -> Self {
+    pub fn new(max: FeePerGas, tip: FeePerGas, base: u64) -> Self {
         Self { max, tip, base }
     }
 }
@@ -80,17 +83,6 @@ impl std::ops::Mul<f64> for GasPrice {
     }
 }
 
-impl From<EffectiveGasPrice> for GasPrice {
-    fn from(value: EffectiveGasPrice) -> Self {
-        let value = value.0.0;
-        Self {
-            max: value.into(),
-            tip: value.into(),
-            base: value.into(),
-        }
-    }
-}
-
 /// The amount of ETH to pay as fees for a single unit of gas. This is
 /// `{max,max_priority,base}_fee_per_gas` as defined by EIP-1559.
 ///
diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index afd6fec97a..b5928a4f5e 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -8,7 +8,7 @@ use {
         },
         infra::{self, Ethereum, observe, solver::Solver},
     },
-    alloy::consensus::Transaction,
+    alloy::{consensus::Transaction, eips::eip1559::Eip1559Estimation},
     anyhow::Context,
     ethrpc::block_stream::into_stream,
     futures::{FutureExt, StreamExt, future::select_ok},
@@ -18,9 +18,9 @@ use {
 
 /// Factor by how much a transaction fee needs to be increased to override a
 /// pending transaction at the same nonce. The correct factor is actually
-/// 1.125 but to avoid rounding issues on chains with very low gas prices
+/// 12.5% but to avoid rounding issues on chains with very low gas prices
 /// we increase slightly more.
-const GAS_PRICE_BUMP: f64 = 1.13;
+const GAS_PRICE_BUMP_PCT: u64 = 13;
 
 /// The gas amount required to cancel a transaction.
 const CANCELLATION_GAS_AMOUNT: u64 = 21000;
@@ -146,7 +146,7 @@ impl Mempools {
             .await;
         let final_gas_price = match &replacement_gas_price {
             Some(replacement_gas_price)
-                if replacement_gas_price.max() > current_gas_price.max() =>
+                if replacement_gas_price.max_fee_per_gas > current_gas_price.max_fee_per_gas =>
             {
                 *replacement_gas_price
             }
@@ -268,11 +268,11 @@ impl Mempools {
     async fn cancel(
         &self,
         mempool: &infra::mempool::Mempool,
-        original_tx_gas_price: eth::GasPrice,
+        original_tx_gas_price: Eip1559Estimation,
         solver: &Solver,
         nonce: u64,
     ) -> Result<TxId, Error> {
-        let fallback_gas_price = original_tx_gas_price * GAS_PRICE_BUMP;
+        let fallback_gas_price = original_tx_gas_price.scaled_by_pct(GAS_PRICE_BUMP_PCT);
         let replacement_gas_price = self
             .minimum_replacement_gas_price(mempool, solver, nonce)
             .await;
@@ -314,15 +314,19 @@ impl Mempools {
     /// Computes minimum price to replace the last tx that was submitted
     /// with the given nonce. Returns `None` if no tx was submitted with
     /// that nonce yet.
+    #[tracing::instrument(skip_all)]
     async fn minimum_replacement_gas_price(
         &self,
         mempool: &infra::Mempool,
         solver: &Solver,
         next_nonce: u64,
-    ) -> Option<eth::GasPrice> {
+    ) -> Option<Eip1559Estimation> {
         if let Some(last_submission) = mempool.last_submission(solver.address()) {
-            (last_submission.nonce == next_nonce)
-                .then_some(last_submission.gas_price * GAS_PRICE_BUMP)
+            if last_submission.nonce == next_nonce {
+                Some(last_submission.gas_price.scaled_by_pct(GAS_PRICE_BUMP_PCT))
+            } else {
+                None
+            }
         } else {
             // If we don't have the last submission in-memory (i.e. first submission
             // attempt after a restart) we try to inspect the nodes transaction mempool.
@@ -334,16 +338,15 @@ impl Mempools {
                 .inspect_err(|err| tracing::debug!(?err, "could not inspect tx mempool"))
                 .ok()??;
 
-            let pending_tx_gas_price = eth::GasPrice::new(
-                eth::U256::from(pending_tx.max_fee_per_gas()).into(),
-                eth::U256::from(pending_tx.max_priority_fee_per_gas().or_else(|| {
+            let pending_tx_gas_price = Eip1559Estimation {
+                max_fee_per_gas: pending_tx.max_fee_per_gas(),
+                max_priority_fee_per_gas: pending_tx.max_priority_fee_per_gas().or_else(|| {
                     tracing::error!(tx = ?pending_tx.inner.tx_hash(), "pending tx is not EIP 1559");
                     None
-                })?)
-                .into(),
-                eth::U256::from(pending_tx.max_fee_per_gas()).into(),
-            );
-            Some(pending_tx_gas_price * GAS_PRICE_BUMP)
+                })?,
+            };
+
+            Some(pending_tx_gas_price.scaled_by_pct(GAS_PRICE_BUMP_PCT))
         }
     }
 }
diff --git a/crates/driver/src/infra/api/routes/gasprice.rs b/crates/driver/src/infra/api/routes/gasprice.rs
index 2c66f40d7a..175d13dec6 100644
--- a/crates/driver/src/infra/api/routes/gasprice.rs
+++ b/crates/driver/src/infra/api/routes/gasprice.rs
@@ -1,12 +1,7 @@
 use {
-    crate::{
-        domain::eth,
-        infra::{Ethereum, api::error::Error},
-        util::serialize,
-    },
+    crate::infra::{Ethereum, api::error::Error},
+    alloy::eips::eip1559::Eip1559Estimation,
     axum::Json,
-    serde::{Deserialize, Serialize},
-    serde_with::serde_as,
     tracing::instrument,
 };
 
@@ -14,29 +9,15 @@ pub(in crate::infra::api) fn gasprice(app: axum::Router<Ethereum>) -> axum::Rout
     app.route("/gasprice", axum::routing::get(route))
 }
 
-/// Gas price components in EIP-1559 format.
-#[serde_as]
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GasPriceResponse {
-    #[serde_as(as = "serialize::U256")]
-    pub max_fee_per_gas: eth::U256,
-    #[serde_as(as = "serialize::U256")]
-    pub max_priority_fee_per_gas: eth::U256,
-    #[serde_as(as = "serialize::U256")]
-    pub base_fee_per_gas: eth::U256,
-}
-
 #[instrument(skip(eth))]
 async fn route(
     eth: axum::extract::State<Ethereum>,
-) -> Result<Json<GasPriceResponse>, (hyper::StatusCode, axum::Json<Error>)> {
+) -> Result<Json<Eip1559Estimation>, (hyper::StatusCode, axum::Json<Error>)> {
     // For simplicity we use the default time limit (None)
     let gas_price = eth.gas_price().await?;
 
-    Ok(Json(GasPriceResponse {
-        max_fee_per_gas: gas_price.max().0.0,
-        max_priority_fee_per_gas: gas_price.tip().0.0,
-        base_fee_per_gas: gas_price.base().0.0,
+    Ok(Json(Eip1559Estimation {
+        max_fee_per_gas: gas_price.max_fee_per_gas,
+        max_priority_fee_per_gas: gas_price.max_priority_fee_per_gas,
     }))
 }
diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index 510eb1ace0..8c8741fdd5 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -8,6 +8,8 @@ use {
         domain::eth,
         infra::{config::file::GasEstimatorType, mempool},
     },
+    alloy::eips::eip1559::Eip1559Estimation,
+    anyhow::anyhow,
     ethrpc::Web3,
     shared::gas_price_estimation::{
         GasPriceEstimating,
@@ -84,20 +86,34 @@ impl GasPriceEstimator {
     /// If additional tip is configured, it will be added to the gas price. This
     /// is to increase the chance of a transaction being included in a block, in
     /// case private submission networks are used.
-    pub async fn estimate(&self) -> Result<eth::GasPrice, Error> {
+    pub async fn estimate(&self) -> Result<Eip1559Estimation, Error> {
         let estimate = self.gas.estimate().await.map_err(Error::GasPrice)?;
 
         let max_priority_fee_per_gas = {
             // the driver supports tweaking the tx gas price tip in case the gas
             // price estimator is systematically too low => compute configured tip bump
             let (max_additional_tip, tip_percentage_increase) = self.additional_tip;
-            let additional_tip = f64::from(max_additional_tip)
-                .min(estimate.max_priority_fee_per_gas * tip_percentage_increase);
+
+            // Calculate additional tip in integer space to avoid precision loss
+            // Convert percentage to basis points (multiply by 10000) to maintain precision
+            // e.g., tip_percentage_increase = 0.125 (12.5%) becomes 1250
+            let overflow_err = || {
+                Error::GasPrice(anyhow!(
+                    "overflow on multiplication (max_priority_fee_per_gas * tip_percentage_as_bps)"
+                ))
+            };
+            let tip_percentage_as_bps = tip_percentage_increase * 10000.0;
+            let calculated_tip = eth::U256::from(estimate.max_priority_fee_per_gas)
+                .checked_mul(eth::U256::from(tip_percentage_as_bps))
+                .ok_or_else(overflow_err)?
+                / eth::U256::from(10000u128);
+
+            let additional_tip = max_additional_tip.min(calculated_tip);
 
             // make sure we tip at least some configurable minimum amount
             std::cmp::max(
                 self.min_priority_fee,
-                eth::U256::from(estimate.max_priority_fee_per_gas + additional_tip),
+                eth::U256::from(estimate.max_priority_fee_per_gas) + additional_tip,
             )
         };
 
@@ -113,10 +129,11 @@ impl GasPriceEstimator {
             )));
         }
 
-        Ok(eth::GasPrice::new(
-            suggested_max_fee_per_gas.into(),
-            max_priority_fee_per_gas.into(),
-            eth::U256::from(estimate.base_fee_per_gas).into(),
-        ))
+        Ok(Eip1559Estimation {
+            max_fee_per_gas: u128::try_from(suggested_max_fee_per_gas)
+                .map_err(|err| Error::GasPrice(err.into()))?,
+            max_priority_fee_per_gas: u128::try_from(max_priority_fee_per_gas)
+                .map_err(|err| Error::GasPrice(err.into()))?,
+        })
     }
 }
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 0a0595ae4e..d3d58dcfb8 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -4,6 +4,7 @@ use {
         domain::{eth, eth::U256},
     },
     alloy::{
+        eips::eip1559::Eip1559Estimation,
         network::TransactionBuilder,
         providers::Provider,
         rpc::types::{TransactionReceipt, TransactionRequest},
@@ -15,6 +16,7 @@ use {
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     shared::{
         account_balances::{BalanceSimulator, SimulationError},
+        gas_price_estimation::Eip1559EstimationExt,
         price_estimation::trade_verifier::balance_overrides::{
             BalanceOverrides,
             BalanceOverriding,
@@ -236,7 +238,7 @@ impl Ethereum {
     /// The gas price is determined based on the deadline by which the
     /// transaction must be included on-chain. A shorter deadline requires a
     /// higher gas price to increase the likelihood of timely inclusion.
-    pub async fn gas_price(&self) -> Result<eth::GasPrice, Error> {
+    pub async fn gas_price(&self) -> Result<Eip1559Estimation, Error> {
         self.inner.gas.estimate().await
     }
 
@@ -291,6 +293,7 @@ impl Ethereum {
 
     #[instrument(skip(self), ret(level = Level::DEBUG))]
     pub(super) async fn simulation_gas_price(&self) -> Option<u128> {
+        let base_fee = self.current_block().borrow().base_fee;
         // Some nodes don't pick a reasonable default value when you don't specify a gas
         // price and default to 0. Additionally some sneaky tokens have special code
         // paths that detect that case to try to behave differently during simulations
@@ -298,15 +301,7 @@ impl Ethereum {
         // default value we estimate the current gas price upfront. But because it's
         // extremely rare that tokens behave that way we are fine with falling back to
         // the node specific fallback value instead of failing the whole call.
-        let gas_price = self.inner.gas.estimate().await.ok()?.effective().0.0;
-        u128::try_from(gas_price)
-            .inspect_err(|err| {
-                tracing::debug!(
-                    ?err,
-                    "failed to convert gas estimate to u128, returning None"
-                );
-            })
-            .ok()
+        Some(self.inner.gas.estimate().await.ok()?.effective(base_fee))
     }
 
     pub fn web3(&self) -> &Web3 {
diff --git a/crates/driver/src/infra/mempool/mod.rs b/crates/driver/src/infra/mempool/mod.rs
index 00d017908a..1b120a7e5c 100644
--- a/crates/driver/src/infra/mempool/mod.rs
+++ b/crates/driver/src/infra/mempool/mod.rs
@@ -6,7 +6,7 @@ use {
     },
     alloy::{
         consensus::Transaction,
-        eips::BlockNumberOrTag,
+        eips::{BlockNumberOrTag, eip1559::Eip1559Estimation},
         primitives::Address,
         providers::{Provider, ext::TxPoolApi},
         rpc::types::TransactionRequest,
@@ -73,7 +73,7 @@ pub struct Mempool {
 #[derive(Debug, Clone)]
 pub struct Submission {
     pub nonce: u64,
-    pub gas_price: eth::GasPrice,
+    pub gas_price: Eip1559Estimation,
 }
 
 impl std::fmt::Display for Mempool {
@@ -121,23 +121,13 @@ impl Mempool {
     pub async fn submit(
         &self,
         tx: eth::Tx,
-        gas_price: eth::GasPrice,
+        gas_price: Eip1559Estimation,
         gas_limit: eth::Gas,
         solver: &infra::Solver,
         nonce: u64,
     ) -> Result<eth::TxId, mempools::Error> {
-        let max_fee_per_gas = gas_price
-            .max()
-            .0
-            .0
-            .try_into()
-            .map_err(anyhow::Error::from)?;
-        let max_priority_fee_per_gas = gas_price
-            .tip()
-            .0
-            .0
-            .try_into()
-            .map_err(anyhow::Error::from)?;
+        let max_fee_per_gas = gas_price.max_fee_per_gas;
+        let max_priority_fee_per_gas = gas_price.max_priority_fee_per_gas;
         let gas_limit = gas_limit.0.try_into().map_err(anyhow::Error::from)?;
 
         let tx_request = TransactionRequest::default()
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index 15e89414dc..79f147657b 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -20,6 +20,7 @@ use {
     number::testing::ApproxEq,
     serde_json::{Value, json},
     serde_with::{DisplayFromStr, serde_as},
+    shared::gas_price_estimation::Eip1559EstimationExt,
     solvers_dto::auction::FlashloanHint,
     std::{
         collections::{HashMap, HashSet},
@@ -488,14 +489,8 @@ impl Solver {
             axum::routing::post(
                 move |axum::extract::State(state): axum::extract::State<State>,
                  axum::extract::Json(req): axum::extract::Json<serde_json::Value>| async move {
-                    let effective_gas_price = eth
-                        .gas_price()
-                        .await
-                        .unwrap()
-                        .effective()
-                        .0
-                        .0
-                        .to_string();
+                    let base_fee = eth.current_block().borrow().base_fee;
+                    let effective_gas_price = eth.gas_price().await.unwrap().effective(base_fee).to_string();
                     let expected = json!({
                         "id": (!config.quote).then_some("1"),
                         "tokens": tokens_json,
@@ -558,11 +553,10 @@ fn check_solve_request(request: Value, expected: Value) {
         request.rest, expected.rest,
         "/solve request body does not match expectation"
     );
-
     assert!(
         request
             .effective_gas_price
-            .is_approx_eq(&expected.effective_gas_price, Some(15.0)),
+            .is_approx_eq(&expected.effective_gas_price, Some(1.0)), // 1.0%
     );
 }
 
diff --git a/crates/ethrpc/src/block_stream/mod.rs b/crates/ethrpc/src/block_stream/mod.rs
index f746ad7fe4..c1538574fa 100644
--- a/crates/ethrpc/src/block_stream/mod.rs
+++ b/crates/ethrpc/src/block_stream/mod.rs
@@ -56,6 +56,7 @@ pub struct BlockInfo {
     pub timestamp: u64,
     pub gas_limit: U256,
     pub gas_price: U256,
+    pub base_fee: u64,
     /// When the system noticed the new block.
     pub observed_at: Instant,
 }
@@ -69,6 +70,7 @@ impl Default for BlockInfo {
             timestamp: Default::default(),
             gas_limit: Default::default(),
             gas_price: Default::default(),
+            base_fee: Default::default(),
             observed_at: Instant::now(),
         }
     }
@@ -89,19 +91,7 @@ impl TryFrom<Block> for BlockInfo {
     type Error = anyhow::Error;
 
     fn try_from(value: Block) -> std::result::Result<Self, Self::Error> {
-        Ok(Self {
-            number: value.header.number,
-            hash: value.header.hash,
-            parent_hash: value.header.parent_hash,
-            timestamp: value.header.timestamp,
-            gas_limit: U256::from(value.header.gas_limit),
-            gas_price: value
-                .header
-                .base_fee_per_gas
-                .map(U256::from)
-                .context("no gas price")?,
-            observed_at: Instant::now(),
-        })
+        value.header.try_into()
     }
 }
 
@@ -119,6 +109,9 @@ impl TryFrom<alloy::rpc::types::Header> for BlockInfo {
                 .base_fee_per_gas
                 .map(U256::from)
                 .context("no gas price")?,
+            base_fee: value
+                .base_fee_per_gas
+                .ok_or_else(|| anyhow!("no base fee available"))?,
             observed_at: Instant::now(),
         })
     }
diff --git a/crates/refunder/src/submitter.rs b/crates/refunder/src/submitter.rs
index 4872f1ab55..73d8a074af 100644
--- a/crates/refunder/src/submitter.rs
+++ b/crates/refunder/src/submitter.rs
@@ -9,13 +9,13 @@
 // In the re-newed attempt for submission the same nonce is used as before.
 
 use {
-    alloy::{primitives::Address, providers::Provider},
+    alloy::{eips::eip1559::Eip1559Estimation, primitives::Address, providers::Provider},
     anyhow::{Context, Result},
     contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
     database::OrderUid,
     shared::{
         ethrpc::Web3,
-        gas_price_estimation::{GasPriceEstimating, price::GasPrice1559},
+        gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
     },
     std::time::Duration,
 };
@@ -24,22 +24,17 @@ use {
 // send out EIP1559 txs.
 // Example: If the prevailing gas is 10Gwei and the buffer factor is 1.20
 // then the gas_price used will be 12.
-const GAS_PRICE_BUFFER_FACTOR: f64 = 1.3;
+const GAS_PRICE_BUFFER_PCT: u64 = 30;
 
 // In order to resubmit a new tx with the same nonce, the gas tip and
 // max_fee_per_gas needs to be increased by at least 10 percent.
-const GAS_PRICE_BUMP: f64 = 1.125;
-
-/// Type safe cast to avoid unexpected issues due to type changes.
-const fn f64_to_u128(n: f64) -> u128 {
-    n as u128
-}
+const GAS_PRICE_BUMP_PERMIL: u64 = 125;
 
 pub struct Submitter {
     pub web3: Web3,
     pub signer_address: Address,
     pub gas_estimator: Box<dyn GasPriceEstimating>,
-    pub gas_parameters_of_last_tx: Option<GasPrice1559>,
+    pub gas_parameters_of_last_tx: Option<Eip1559Estimation>,
     pub nonce_of_last_submission: Option<u64>,
     pub max_gas_price: u64,
     pub start_priority_fee_tip: u64,
@@ -88,8 +83,8 @@ impl Submitter {
         let tx_result = ethflow_contract
             .invalidateOrdersIgnoringNotAllowed(encoded_ethflow_orders)
             // Gas conversions are lossy but technically the should not have decimal points even though they're floats
-            .max_priority_fee_per_gas(f64_to_u128(gas_price.max_priority_fee_per_gas))
-            .max_fee_per_gas(f64_to_u128(gas_price.max_fee_per_gas))
+            .max_priority_fee_per_gas(gas_price.max_priority_fee_per_gas)
+            .max_fee_per_gas(gas_price.max_fee_per_gas)
             .from(self.signer_address)
             .nonce(nonce)
             .send()
@@ -110,19 +105,19 @@ impl Submitter {
 }
 
 fn calculate_submission_gas_price(
-    gas_price_of_last_submission: Option<GasPrice1559>,
-    web3_gas_estimation: GasPrice1559,
+    gas_price_of_last_submission: Option<Eip1559Estimation>,
+    web3_gas_estimation: Eip1559Estimation,
     newest_nonce: u64,
     nonce_of_last_submission: Option<u64>,
     max_gas_price: u64,
     start_priority_fee_tip: u64,
-) -> Result<GasPrice1559> {
+) -> Result<Eip1559Estimation> {
     // The gas price of the refund tx is the current prevailing gas price
     // of the web3 gas estimation plus a buffer.
-    let mut new_gas_price = web3_gas_estimation.bump(GAS_PRICE_BUFFER_FACTOR);
+    let mut new_gas_price = web3_gas_estimation.scaled_by_pct(GAS_PRICE_BUFFER_PCT);
     // limit the prio_fee to max_fee_per_gas as otherwise tx is invalid
     new_gas_price.max_priority_fee_per_gas =
-        (start_priority_fee_tip as f64).min(new_gas_price.max_fee_per_gas);
+        (start_priority_fee_tip as u128).min(new_gas_price.max_fee_per_gas);
 
     // If tx from the previous submission was not mined,
     // we incease the tip and max_gas_fee for miners
@@ -130,7 +125,8 @@ fn calculate_submission_gas_price(
     if Some(newest_nonce) == nonce_of_last_submission
         && let Some(gas_price_of_last_submission) = gas_price_of_last_submission
     {
-        let gas_price_of_last_submission = gas_price_of_last_submission.bump(GAS_PRICE_BUMP);
+        let gas_price_of_last_submission =
+            gas_price_of_last_submission.scaled_by_pml(GAS_PRICE_BUMP_PERMIL);
         new_gas_price.max_fee_per_gas = new_gas_price
             .max_fee_per_gas
             .max(gas_price_of_last_submission.max_fee_per_gas);
@@ -139,7 +135,7 @@ fn calculate_submission_gas_price(
             .max(gas_price_of_last_submission.max_priority_fee_per_gas);
     }
 
-    if new_gas_price.max_fee_per_gas > max_gas_price as f64 {
+    if new_gas_price.max_fee_per_gas > max_gas_price as u128 {
         tracing::warn!(
             "Refunding txs are likely not mined in time, as the current gas price {:?} is higher \
              than MAX_GAS_PRICE specified {:?}",
@@ -147,9 +143,9 @@ fn calculate_submission_gas_price(
             max_gas_price
         );
         new_gas_price.max_fee_per_gas =
-            f64::min(max_gas_price as f64, new_gas_price.max_fee_per_gas);
+            u128::min(max_gas_price as u128, new_gas_price.max_fee_per_gas);
     }
-    new_gas_price.max_priority_fee_per_gas = f64::min(
+    new_gas_price.max_priority_fee_per_gas = u128::min(
         new_gas_price.max_priority_fee_per_gas,
         new_gas_price.max_fee_per_gas,
     );
@@ -166,11 +162,10 @@ mod tests {
         const TEST_START_PRIORITY_FEE_TIP: u64 = 2_000_000_000;
 
         // First case: previous tx was successful
-        let max_fee_per_gas = 4_000_000_000f64;
-        let web3_gas_estimation = GasPrice1559 {
-            base_fee_per_gas: 2_000_000_000f64,
+        let max_fee_per_gas = 4_000_000_000_u128;
+        let web3_gas_estimation = Eip1559Estimation {
             max_fee_per_gas,
-            max_priority_fee_per_gas: 3_000_000_000f64,
+            max_priority_fee_per_gas: 3_000_000_000_u128,
         };
         let newest_nonce = 1;
         let nonce_of_last_submission = None;
@@ -184,19 +179,18 @@ mod tests {
             TEST_START_PRIORITY_FEE_TIP,
         )
         .unwrap();
-        let expected_result = GasPrice1559 {
-            max_fee_per_gas: max_fee_per_gas * GAS_PRICE_BUFFER_FACTOR,
-            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as f64,
-            base_fee_per_gas: 2_000_000_000f64,
+
+        let expected_result = Eip1559Estimation {
+            max_fee_per_gas: max_fee_per_gas * (100 + GAS_PRICE_BUFFER_PCT as u128) / 100,
+            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as u128,
         };
         assert_eq!(result, expected_result);
         // Second case: Previous tx was not successful
         let nonce_of_last_submission = Some(newest_nonce);
-        let max_fee_per_gas_of_last_tx = max_fee_per_gas * 2f64;
-        let gas_price_of_last_submission = GasPrice1559 {
+        let max_fee_per_gas_of_last_tx = max_fee_per_gas * 2;
+        let gas_price_of_last_submission = Eip1559Estimation {
             max_fee_per_gas: max_fee_per_gas_of_last_tx,
-            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as f64,
-            base_fee_per_gas: 2_000_000_000f64,
+            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as u128,
         };
         let result = calculate_submission_gas_price(
             Some(gas_price_of_last_submission),
@@ -207,18 +201,19 @@ mod tests {
             TEST_START_PRIORITY_FEE_TIP,
         )
         .unwrap();
-        let expected_result = GasPrice1559 {
-            max_fee_per_gas: max_fee_per_gas_of_last_tx * GAS_PRICE_BUMP,
-            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as f64 * GAS_PRICE_BUMP,
-            base_fee_per_gas: 2_000_000_000f64,
+        let expected_result = Eip1559Estimation {
+            max_fee_per_gas: max_fee_per_gas_of_last_tx * (1000 + GAS_PRICE_BUMP_PERMIL as u128)
+                / 1000,
+            max_priority_fee_per_gas: (TEST_START_PRIORITY_FEE_TIP as u128)
+                * (1000 + GAS_PRICE_BUMP_PERMIL as u128)
+                / 1000,
         };
         assert_eq!(result, expected_result);
         // Thrid case: MAX_GAS_PRICE is not exceeded
-        let max_fee_per_gas = TEST_MAX_GAS_PRICE as f64 + 1000f64;
-        let web3_gas_estimation = GasPrice1559 {
-            base_fee_per_gas: 2_000_000_000f64,
+        let max_fee_per_gas = TEST_MAX_GAS_PRICE as u128 + 1000_u128;
+        let web3_gas_estimation = Eip1559Estimation {
             max_fee_per_gas,
-            max_priority_fee_per_gas: 3_000_000_000f64,
+            max_priority_fee_per_gas: 3_000_000_000_u128,
         };
         let nonce_of_last_submission = None;
         let gas_price_of_last_submission = None;
@@ -231,10 +226,9 @@ mod tests {
             TEST_START_PRIORITY_FEE_TIP,
         )
         .unwrap();
-        let expected_result = GasPrice1559 {
-            base_fee_per_gas: 2_000_000_000f64,
-            max_fee_per_gas: TEST_MAX_GAS_PRICE as f64,
-            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as f64,
+        let expected_result = Eip1559Estimation {
+            max_fee_per_gas: TEST_MAX_GAS_PRICE as u128,
+            max_priority_fee_per_gas: TEST_START_PRIORITY_FEE_TIP as u128,
         };
         assert_eq!(result, expected_result);
     }
diff --git a/crates/shared/src/gas_price.rs b/crates/shared/src/gas_price.rs
index a3c8fa1d9b..69ec87eaa2 100644
--- a/crates/shared/src/gas_price.rs
+++ b/crates/shared/src/gas_price.rs
@@ -5,9 +5,9 @@
 //! anomalies.
 
 use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559},
+    crate::gas_price_estimation::GasPriceEstimating,
+    alloy::eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
     anyhow::Result,
-    tracing::instrument,
 };
 
 /// An instrumented gas price estimator that wraps an inner one.
@@ -33,18 +33,37 @@ impl<T> GasPriceEstimating for InstrumentedGasEstimator<T>
 where
     T: GasPriceEstimating,
 {
-    #[instrument(skip_all)]
-    async fn estimate(&self) -> Result<GasPrice1559> {
-        let estimate = self.inner.estimate().await?;
+    async fn estimate(&self) -> Result<Eip1559Estimation> {
+        self.inner.estimate().await
+    }
+
+    async fn base_fee(&self) -> Result<Option<u64>> {
+        self.inner.base_fee().await
+    }
+
+    #[tracing::instrument(skip_all)]
+    async fn effective_gas_price(&self) -> Result<u128> {
+        let estimate = self.estimate().await?;
+        let base_fee = self.inner.base_fee().await?;
         self.metrics
-            .gas_price
-            .set(estimate.effective_gas_price() / 1e9);
-        Ok(estimate)
+            .base_fee
+            .set(base_fee.unwrap_or(0).cast_signed());
+
+        let effective_gas_price = calc_effective_gas_price(
+            estimate.max_fee_per_gas,
+            estimate.max_priority_fee_per_gas,
+            base_fee,
+        );
+
+        self.metrics.gas_price.set(effective_gas_price as f64 / 1e9);
+        Ok(effective_gas_price)
     }
 }
 
 #[derive(prometheus_metric_storage::MetricStorage)]
 struct Metrics {
-    /// Last measured gas price in gwei
+    /// Last measured effective gas price in gwei
     gas_price: prometheus::Gauge,
+    /// Last measured base fee
+    base_fee: prometheus::IntGauge,
 }
diff --git a/crates/shared/src/gas_price_estimation/configurable_alloy.rs b/crates/shared/src/gas_price_estimation/configurable_alloy.rs
index 671497d7cf..5a0840b257 100644
--- a/crates/shared/src/gas_price_estimation/configurable_alloy.rs
+++ b/crates/shared/src/gas_price_estimation/configurable_alloy.rs
@@ -6,9 +6,9 @@
 //! - Reward percentile to use
 
 use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559, u128_to_f64},
+    crate::gas_price_estimation::GasPriceEstimating,
     alloy::{
-        eips::BlockNumberOrTag,
+        eips::{BlockId, BlockNumberOrTag, eip1559::Eip1559Estimation},
         providers::{Provider, utils::eip1559_default_estimator},
     },
     anyhow::{Context, Result},
@@ -49,11 +49,19 @@ impl ConfigurableGasPriceEstimator {
 
 #[async_trait::async_trait]
 impl GasPriceEstimating for ConfigurableGasPriceEstimator {
+    async fn base_fee(&self) -> Result<Option<u64>> {
+        Ok(self
+            .provider
+            .get_block(BlockId::latest())
+            .await?
+            .and_then(|block| block.header.base_fee_per_gas))
+    }
+
     #[instrument(skip(self), fields(
         past_blocks = %self.config.past_blocks,
         reward_percentile = %self.config.reward_percentile
     ))]
-    async fn estimate(&self) -> Result<GasPrice1559> {
+    async fn estimate(&self) -> Result<Eip1559Estimation> {
         // Fetch fee history with our configured parameters
         let fee_history = self
             .provider
@@ -90,13 +98,9 @@ impl GasPriceEstimating for ConfigurableGasPriceEstimator {
         let estimation =
             eip1559_default_estimator(base_fee_per_gas, &fee_history.reward.unwrap_or_default());
 
-        Ok(GasPrice1559 {
-            base_fee_per_gas: u128_to_f64(base_fee_per_gas)
-                .context("could not convert base_fee_per_gas to f64")?,
-            max_fee_per_gas: u128_to_f64(estimation.max_fee_per_gas)
-                .context("could not convert max_fee_per_gas to f64")?,
-            max_priority_fee_per_gas: u128_to_f64(estimation.max_priority_fee_per_gas)
-                .context("could not convert max_priority_fee_per_gas to f64")?,
+        Ok(Eip1559Estimation {
+            max_fee_per_gas: estimation.max_fee_per_gas,
+            max_priority_fee_per_gas: estimation.max_priority_fee_per_gas,
         })
     }
 }
diff --git a/crates/shared/src/gas_price_estimation/driver.rs b/crates/shared/src/gas_price_estimation/driver.rs
index 8c3b98f85b..5e1d7b1c16 100644
--- a/crates/shared/src/gas_price_estimation/driver.rs
+++ b/crates/shared/src/gas_price_estimation/driver.rs
@@ -1,11 +1,11 @@
 use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559},
-    alloy::primitives::U256,
-    anyhow::{Context, Result},
-    number::serialization::HexOrDecimalU256,
+    crate::gas_price_estimation::GasPriceEstimating,
+    alloy::{
+        eips::{BlockId, eip1559::Eip1559Estimation},
+        providers::{DynProvider, Provider},
+    },
+    anyhow::{Context, Result, anyhow},
     reqwest::Url,
-    serde::Deserialize,
-    serde_with::serde_as,
     std::{
         sync::Arc,
         time::{Duration, Instant},
@@ -21,40 +21,29 @@ pub struct DriverGasEstimator {
     client: reqwest::Client,
     url: Url,
     cache: Arc<Mutex<Option<CachedGasPrice>>>,
+    provider: DynProvider,
 }
 
 #[derive(Debug, Clone)]
 struct CachedGasPrice {
-    price: GasPrice1559,
+    price: Eip1559Estimation,
     timestamp: Instant,
 }
 
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-/// Gas price components in EIP-1559 format.
-struct GasPriceResponse {
-    #[serde_as(as = "HexOrDecimalU256")]
-    max_fee_per_gas: U256,
-    #[serde_as(as = "HexOrDecimalU256")]
-    max_priority_fee_per_gas: U256,
-    #[serde_as(as = "HexOrDecimalU256")]
-    base_fee_per_gas: U256,
-}
-
 const CACHE_DURATION: Duration = Duration::from_secs(5);
 
 impl DriverGasEstimator {
-    pub fn new(client: reqwest::Client, driver_url: Url) -> Self {
+    pub fn new(client: reqwest::Client, driver_url: Url, provider: DynProvider) -> Self {
         Self {
             client,
             url: driver_url,
             cache: Arc::new(Mutex::new(None)),
+            provider,
         }
     }
 
     #[instrument(skip(self))]
-    async fn fetch_gas_price(&self) -> Result<GasPrice1559> {
+    async fn fetch_gas_price(&self) -> Result<Eip1559Estimation> {
         let response = self
             .client
             .get(self.url.clone())
@@ -63,14 +52,13 @@ impl DriverGasEstimator {
             .context("failed to send request to driver")?
             .error_for_status()
             .context("driver returned error status")?
-            .json::<GasPriceResponse>()
+            .json::<Eip1559Estimation>()
             .await
             .context("failed to parse driver response")?;
 
-        Ok(GasPrice1559 {
-            base_fee_per_gas: f64::from(response.base_fee_per_gas),
-            max_fee_per_gas: f64::from(response.max_fee_per_gas),
-            max_priority_fee_per_gas: f64::from(response.max_priority_fee_per_gas),
+        Ok(Eip1559Estimation {
+            max_fee_per_gas: response.max_fee_per_gas,
+            max_priority_fee_per_gas: response.max_priority_fee_per_gas,
         })
     }
 }
@@ -78,7 +66,7 @@ impl DriverGasEstimator {
 #[async_trait::async_trait]
 impl GasPriceEstimating for DriverGasEstimator {
     #[instrument(skip(self))]
-    async fn estimate(&self) -> Result<GasPrice1559> {
+    async fn estimate(&self) -> Result<Eip1559Estimation> {
         // Lock cache for entire duration of this method to prevent concurrent network
         // requests
         let mut cache = self.cache.lock().await;
@@ -98,4 +86,14 @@ impl GasPriceEstimating for DriverGasEstimator {
 
         Ok(price)
     }
+
+    async fn base_fee(&self) -> Result<Option<u64>> {
+        Ok(self
+            .provider
+            .get_block(BlockId::latest())
+            .await?
+            .ok_or_else(|| anyhow!("fecthed block does not have header"))?
+            .header
+            .base_fee_per_gas)
+    }
 }
diff --git a/crates/shared/src/gas_price_estimation/eth_node.rs b/crates/shared/src/gas_price_estimation/eth_node.rs
index 6082c45db2..fa7fad9508 100644
--- a/crates/shared/src/gas_price_estimation/eth_node.rs
+++ b/crates/shared/src/gas_price_estimation/eth_node.rs
@@ -4,9 +4,12 @@
 //! This approach is ported from the [`cowprotocol/gas-estimation`](https://github.com/cowprotocol/gas-estimation/tree/v0.7.3) crate's legacy estimation.
 
 use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559, u128_to_f64},
-    alloy::providers::Provider,
-    anyhow::{Context, Result},
+    crate::gas_price_estimation::GasPriceEstimating,
+    alloy::{
+        eips::{BlockId, eip1559::Eip1559Estimation},
+        providers::Provider,
+    },
+    anyhow::{Context, Result, anyhow},
     ethrpc::AlloyProvider,
 };
 
@@ -23,18 +26,26 @@ impl NodeGasPriceEstimator {
 impl GasPriceEstimating for NodeGasPriceEstimator {
     /// Returns the result of calling the `eth_gasPrice` endpoint as the gas
     /// estimation.
-    async fn estimate(&self) -> Result<GasPrice1559> {
+    async fn estimate(&self) -> Result<Eip1559Estimation> {
         let legacy = self
             .0
             .get_gas_price()
             .await
-            .context("failed to get web3 gas price")
-            .map(u128_to_f64)??;
+            .context("failed to get web3 gas price")?;
 
-        Ok(GasPrice1559 {
-            base_fee_per_gas: 0.0,
+        Ok(Eip1559Estimation {
             max_fee_per_gas: legacy,
             max_priority_fee_per_gas: legacy,
         })
     }
+
+    async fn base_fee(&self) -> Result<Option<u64>> {
+        Ok(self
+            .0
+            .get_block(BlockId::latest())
+            .await?
+            .ok_or_else(|| anyhow!("fecthed block does not have header"))?
+            .header
+            .base_fee_per_gas)
+    }
 }
diff --git a/crates/shared/src/gas_price_estimation/fake.rs b/crates/shared/src/gas_price_estimation/fake.rs
index 19f8e56de9..d19facce0f 100644
--- a/crates/shared/src/gas_price_estimation/fake.rs
+++ b/crates/shared/src/gas_price_estimation/fake.rs
@@ -1,20 +1,33 @@
 use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559},
+    crate::gas_price_estimation::GasPriceEstimating,
+    alloy::eips::eip1559::Eip1559Estimation,
     anyhow::Result,
 };
 
-#[derive(Default)]
-pub struct FakeGasPriceEstimator(pub GasPrice1559);
+pub struct FakeGasPriceEstimator(pub Eip1559Estimation);
+
+impl Default for FakeGasPriceEstimator {
+    fn default() -> Self {
+        Self(Eip1559Estimation {
+            max_fee_per_gas: Default::default(),
+            max_priority_fee_per_gas: Default::default(),
+        })
+    }
+}
 
 impl FakeGasPriceEstimator {
-    pub fn new(gas_price: GasPrice1559) -> Self {
+    pub fn new(gas_price: Eip1559Estimation) -> Self {
         Self(gas_price)
     }
 }
 
 #[async_trait::async_trait]
 impl GasPriceEstimating for FakeGasPriceEstimator {
-    async fn estimate(&self) -> Result<GasPrice1559> {
+    async fn estimate(&self) -> Result<Eip1559Estimation> {
         Ok(self.0)
     }
+
+    async fn base_fee(&self) -> Result<Option<u64>> {
+        Ok(Default::default())
+    }
 }
diff --git a/crates/shared/src/gas_price_estimation/mod.rs b/crates/shared/src/gas_price_estimation/mod.rs
index 2aad505340..b7755cc1fd 100644
--- a/crates/shared/src/gas_price_estimation/mod.rs
+++ b/crates/shared/src/gas_price_estimation/mod.rs
@@ -2,7 +2,6 @@ pub mod configurable_alloy;
 pub mod driver;
 pub mod eth_node;
 pub mod fake;
-pub mod price;
 pub mod priority;
 
 use {
@@ -20,7 +19,10 @@ use {
         },
         http_client::HttpClientFactory,
     },
-    ::alloy::providers::Provider,
+    ::alloy::{
+        eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
+        providers::Provider,
+    },
     anyhow::Result,
     std::str::FromStr,
     tracing::instrument,
@@ -32,7 +34,19 @@ pub use {driver::DriverGasEstimator, fake::FakeGasPriceEstimator};
 #[async_trait::async_trait]
 pub trait GasPriceEstimating: Send + Sync {
     /// Estimate the gas price for a transaction to be mined "quickly".
-    async fn estimate(&self) -> Result<crate::gas_price_estimation::price::GasPrice1559>;
+    async fn estimate(&self) -> Result<Eip1559Estimation>;
+
+    async fn base_fee(&self) -> Result<Option<u64>>;
+
+    async fn effective_gas_price(&self) -> Result<u128> {
+        let estimate = self.estimate().await?;
+        let base_fee = self.base_fee().await?;
+        Ok(calc_effective_gas_price(
+            estimate.max_fee_per_gas,
+            estimate.max_priority_fee_per_gas,
+            base_fee,
+        ))
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -72,6 +86,7 @@ pub async fn create_priority_estimator(
                 estimators.push(Box::new(DriverGasEstimator::new(
                     http_factory.create(),
                     url.clone(),
+                    web3.alloy.clone(),
                 )));
             }
             GasEstimatorType::Web3 => {
@@ -96,9 +111,33 @@ pub async fn create_priority_estimator(
     Ok(PriorityGasPriceEstimating::new(estimators))
 }
 
-fn u128_to_f64(val: u128) -> Result<f64> {
-    if val > 2u128.pow(f64::MANTISSA_DIGITS) {
-        anyhow::bail!(format!("could not convert u128 to f64: {val}"));
+/// Extension trait for EIP-1559 gas price estimations.
+pub trait Eip1559EstimationExt {
+    /// Calculates the effective gas price that will be paid given the base fee.
+    fn effective(self, base_fee: u64) -> u128;
+
+    /// Scales fees by a multiplier in parts per thousand (e.g., 100 = +10%).
+    fn scaled_by_pml(self, pml: u64) -> Self;
+}
+
+impl Eip1559EstimationExt for Eip1559Estimation {
+    fn effective(self, base_fee: u64) -> u128 {
+        calc_effective_gas_price(
+            self.max_fee_per_gas,
+            self.max_priority_fee_per_gas,
+            Some(base_fee),
+        )
+    }
+
+    fn scaled_by_pml(mut self, pml: u64) -> Self {
+        self.max_fee_per_gas = {
+            let n = self.max_fee_per_gas;
+            n * (1000 + pml as u128) / 1000
+        };
+        self.max_priority_fee_per_gas = {
+            let n = self.max_priority_fee_per_gas;
+            n * (1000 + pml as u128) / 1000
+        };
+        self
     }
-    Ok(val as f64)
 }
diff --git a/crates/shared/src/gas_price_estimation/price.rs b/crates/shared/src/gas_price_estimation/price.rs
deleted file mode 100644
index 8d1e3ec04f..0000000000
--- a/crates/shared/src/gas_price_estimation/price.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Vendored implementation of GasPrice1559 to start removing the dependency on
-// the gas_estimation crate
-use serde::Serialize;
-
-/// EIP1559 gas price
-#[derive(Debug, Default, Clone, Copy, PartialEq, PartialOrd, Serialize)]
-pub struct GasPrice1559 {
-    // Estimated base fee for the pending block (block currently being mined)
-    pub base_fee_per_gas: f64,
-    // Maximum gas price willing to pay for the transaction.
-    pub max_fee_per_gas: f64,
-    // Priority fee used to incentivize miners to include the tx in case of network congestion.
-    pub max_priority_fee_per_gas: f64,
-}
-
-impl GasPrice1559 {
-    // Estimate the effective gas price based on the current network conditions
-    // (base_fee_per_gas) Beware that gas price for mined transaction could be
-    // different from estimated value in case of 1559 tx
-    // (because base_fee_per_gas can change between estimation and mining the tx).
-    pub fn effective_gas_price(&self) -> f64 {
-        std::cmp::min_by(
-            self.max_fee_per_gas,
-            self.max_priority_fee_per_gas + self.base_fee_per_gas,
-            |a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal),
-        )
-    }
-
-    // Bump gas price by factor.
-    pub fn bump(self, factor: f64) -> Self {
-        Self {
-            max_fee_per_gas: self.max_fee_per_gas * factor,
-            max_priority_fee_per_gas: self.max_priority_fee_per_gas * factor,
-            ..self
-        }
-    }
-
-    // Ceil gas price (since its defined as float).
-    pub fn ceil(self) -> Self {
-        Self {
-            max_fee_per_gas: self.max_fee_per_gas.ceil(),
-            max_priority_fee_per_gas: self.max_priority_fee_per_gas.ceil(),
-            ..self
-        }
-    }
-
-    // If current cap if higher then the input, set to input.
-    pub fn limit_cap(self, cap: f64) -> Self {
-        Self {
-            max_fee_per_gas: self.max_fee_per_gas.min(cap),
-            max_priority_fee_per_gas: self
-                .max_priority_fee_per_gas
-                .min(self.max_fee_per_gas.min(cap)), /* enforce max_priority_fee_per_gas <=
-                                                      * max_fee_per_gas */
-            ..self
-        }
-    }
-}
-
-impl std::fmt::Display for GasPrice1559 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let format_unit = |wei| {
-            let gwei: f64 = wei / 1e9;
-            if gwei >= 1.0 {
-                format!("{:.2} Gwei", gwei)
-            } else {
-                format!("{wei} wei")
-            }
-        };
-        write!(
-            f,
-            "{{ max_fee: {}, max_priority_fee: {}, base_fee: {} }}",
-            format_unit(self.max_fee_per_gas),
-            format_unit(self.max_priority_fee_per_gas),
-            format_unit(self.base_fee_per_gas),
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::gas_price_estimation::price::GasPrice1559;
-
-    // Copied from the source: https://github.com/ashleygwilliams/assert_approx_eq/blob/master/src/lib.rs
-    // should be removed as we move away from expressing gas in f64
-    macro_rules! assert_approx_eq {
-        ($a:expr, $b:expr) => {{
-            let eps = 1.0e-6;
-            let (a, b) = (&$a, &$b);
-            assert!(
-                (*a - *b).abs() < eps,
-                "assertion failed: `(left !== right)` (left: `{:?}`, right: `{:?}`, expect diff: \
-                 `{:?}`, real diff: `{:?}`)",
-                *a,
-                *b,
-                eps,
-                (*a - *b).abs()
-            );
-        }};
-    }
-
-    #[test]
-    fn bump_and_ceil() {
-        let gas_price = GasPrice1559 {
-            max_fee_per_gas: 2.0,
-            max_priority_fee_per_gas: 3.0,
-            ..Default::default()
-        };
-
-        let gas_price_bumped = GasPrice1559 {
-            max_fee_per_gas: 2.25,
-            max_priority_fee_per_gas: 3.375,
-            ..Default::default()
-        };
-
-        let gas_price_bumped_and_ceiled = GasPrice1559 {
-            max_fee_per_gas: 3.0,
-            max_priority_fee_per_gas: 4.0,
-            ..Default::default()
-        };
-
-        assert_eq!(gas_price.bump(1.125), gas_price_bumped);
-        assert_eq!(gas_price.bump(1.125).ceil(), gas_price_bumped_and_ceiled);
-    }
-
-    #[test]
-    fn limit_cap_only_max_fee_capped() {
-        let gas_price = GasPrice1559 {
-            max_fee_per_gas: 5.0,
-            max_priority_fee_per_gas: 3.0,
-            ..Default::default()
-        };
-
-        let gas_price_capped = GasPrice1559 {
-            max_fee_per_gas: 4.0,
-            max_priority_fee_per_gas: 3.0,
-            ..Default::default()
-        };
-
-        assert_eq!(gas_price.limit_cap(4.0), gas_price_capped);
-    }
-
-    #[test]
-    fn limit_cap_max_fee_and_max_priority_capped() {
-        let gas_price = GasPrice1559 {
-            max_fee_per_gas: 5.0,
-            max_priority_fee_per_gas: 3.0,
-            ..Default::default()
-        };
-
-        let gas_price_capped = GasPrice1559 {
-            max_fee_per_gas: 2.0,
-            max_priority_fee_per_gas: 2.0,
-            ..Default::default()
-        };
-
-        assert_eq!(gas_price.limit_cap(2.0), gas_price_capped);
-    }
-
-    #[test]
-    fn estimate_eip1559() {
-        assert_approx_eq!(
-            GasPrice1559 {
-                max_fee_per_gas: 10.0,
-                max_priority_fee_per_gas: 5.0,
-                base_fee_per_gas: 2.0
-            }
-            .effective_gas_price(),
-            7.0
-        );
-
-        assert_approx_eq!(
-            GasPrice1559 {
-                max_fee_per_gas: 10.0,
-                max_priority_fee_per_gas: 8.0,
-                base_fee_per_gas: 2.0
-            }
-            .effective_gas_price(),
-            10.0
-        );
-
-        assert_approx_eq!(
-            GasPrice1559 {
-                max_fee_per_gas: 10.0,
-                max_priority_fee_per_gas: 10.0,
-                base_fee_per_gas: 2.0
-            }
-            .effective_gas_price(),
-            10.0
-        );
-    }
-}
diff --git a/crates/shared/src/gas_price_estimation/priority.rs b/crates/shared/src/gas_price_estimation/priority.rs
index ba04669d69..c6ad5fca19 100644
--- a/crates/shared/src/gas_price_estimation/priority.rs
+++ b/crates/shared/src/gas_price_estimation/priority.rs
@@ -1,5 +1,6 @@
 use {
-    crate::gas_price_estimation::{GasPriceEstimating, price::GasPrice1559},
+    crate::gas_price_estimation::GasPriceEstimating,
+    alloy::eips::eip1559::Eip1559Estimation,
     anyhow::{Result, anyhow},
     std::{
         future::Future,
@@ -35,10 +36,10 @@ impl PriorityGasPriceEstimating {
         Self { estimators }
     }
 
-    async fn prioritize<'a, T, F>(&'a self, operation: T) -> Result<GasPrice1559>
+    async fn prioritize<'a, T, F, O>(&'a self, operation: T) -> Result<O>
     where
         T: Fn(&'a dyn GasPriceEstimating) -> F,
-        F: Future<Output = Result<GasPrice1559>>,
+        F: Future<Output = Result<O>>,
     {
         for (i, estimator) in self.estimators.iter().enumerate() {
             match operation(estimator.estimator.as_ref()).await {
@@ -62,9 +63,13 @@ impl PriorityGasPriceEstimating {
 
 #[async_trait::async_trait]
 impl GasPriceEstimating for PriorityGasPriceEstimating {
-    async fn estimate(&self) -> Result<GasPrice1559> {
+    async fn estimate(&self) -> Result<Eip1559Estimation> {
         self.prioritize(|estimator| estimator.estimate()).await
     }
+
+    async fn base_fee(&self) -> Result<Option<u64>> {
+        self.prioritize(|estimator| estimator.base_fee()).await
+    }
 }
 
 #[cfg(test)]
@@ -73,40 +78,22 @@ mod tests {
         crate::gas_price_estimation::{
             GasPriceEstimating,
             MockGasPriceEstimating,
-            price::GasPrice1559,
             priority::PriorityGasPriceEstimating,
         },
+        alloy::eips::eip1559::Eip1559Estimation,
         anyhow::anyhow,
         futures::future::FutureExt,
     };
 
-    // Copied from the source: https://github.com/ashleygwilliams/assert_approx_eq/blob/master/src/lib.rs
-    // should be removed as we move away from expressing gas in f64
-    macro_rules! assert_approx_eq {
-        ($a:expr, $b:expr) => {{
-            let eps = 1.0e-6;
-            let (a, b) = (&$a, &$b);
-            assert!(
-                (*a - *b).abs() < eps,
-                "assertion failed: `(left !== right)` (left: `{:?}`, right: `{:?}`, expect diff: \
-                 `{:?}`, real diff: `{:?}`)",
-                *a,
-                *b,
-                eps,
-                (*a - *b).abs()
-            );
-        }};
-    }
-
     #[test]
     fn prioritize_picks_first_if_first_succeeds() {
         let mut estimator_0 = MockGasPriceEstimating::new();
         let estimator_1 = MockGasPriceEstimating::new();
 
         estimator_0.expect_estimate().times(1).returning(|| {
-            Ok(GasPrice1559 {
-                base_fee_per_gas: 1.0,
-                ..Default::default()
+            Ok(Eip1559Estimation {
+                max_fee_per_gas: 10,
+                max_priority_fee_per_gas: 0,
             })
         });
 
@@ -126,16 +113,16 @@ mod tests {
             .times(1)
             .returning(|| Err(anyhow!("")));
         estimator_1.expect_estimate().times(1).returning(|| {
-            Ok(GasPrice1559 {
-                base_fee_per_gas: 2.0,
-                ..Default::default()
+            Ok(Eip1559Estimation {
+                max_fee_per_gas: 10,
+                max_priority_fee_per_gas: 0,
             })
         });
 
         let priority =
             PriorityGasPriceEstimating::new(vec![Box::new(estimator_0), Box::new(estimator_1)]);
         let result = priority.estimate().now_or_never().unwrap().unwrap();
-        assert_approx_eq!(result.base_fee_per_gas, 2.0);
+        assert_eq!(result.max_fee_per_gas, 10);
     }
 
     #[test]
diff --git a/crates/shared/src/order_quoting.rs b/crates/shared/src/order_quoting.rs
index 7f844f4e6c..dd47e3f9d0 100644
--- a/crates/shared/src/order_quoting.rs
+++ b/crates/shared/src/order_quoting.rs
@@ -462,9 +462,9 @@ impl OrderQuoter {
         };
 
         let trade_query = Arc::new(parameters.to_price_query(self.default_quote_timeout));
-        let (gas_estimate, trade_estimate, sell_token_price, _) = futures::try_join!(
+        let (effective_gas_price, trade_estimate, sell_token_price, _) = futures::try_join!(
             self.gas_estimator
-                .estimate()
+                .effective_gas_price()
                 .map_err(|err| CalculateQuoteError::from((
                     EstimatorKind::Gas,
                     PriceEstimationError::ProtocolInternal(err)
@@ -496,7 +496,7 @@ impl OrderQuoter {
         };
         let fee_parameters = FeeParameters {
             gas_amount: trade_estimate.gas as _,
-            gas_price: gas_estimate.effective_gas_price(),
+            gas_price: effective_gas_price as f64,
             sell_token_price,
         };
 
@@ -786,7 +786,7 @@ mod tests {
         super::*,
         crate::{
             account_balances::MockBalanceFetching,
-            gas_price_estimation::{FakeGasPriceEstimator, price::GasPrice1559},
+            gas_price_estimation::FakeGasPriceEstimator,
             price_estimation::{
                 HEALTHY_PRICE_ESTIMATION_TIME,
                 MockPriceEstimating,
@@ -795,6 +795,7 @@ mod tests {
         },
         Address,
         U256 as AlloyU256,
+        alloy::eips::eip1559::Eip1559Estimation,
         chrono::Utc,
         futures::FutureExt,
         mockall::{Sequence, predicate::eq},
@@ -853,10 +854,9 @@ mod tests {
             additional_gas: 0,
             timeout: None,
         };
-        let gas_price = GasPrice1559 {
-            base_fee_per_gas: 1.5,
-            max_fee_per_gas: 3.0,
-            max_priority_fee_per_gas: 0.5,
+        let gas_price = Eip1559Estimation {
+            max_fee_per_gas: 2,
+            max_priority_fee_per_gas: 1,
         };
 
         let mut price_estimator = MockPriceEstimating::new();
@@ -994,10 +994,9 @@ mod tests {
             additional_gas: 2,
             timeout: None,
         };
-        let gas_price = GasPrice1559 {
-            base_fee_per_gas: 1.5,
-            max_fee_per_gas: 3.0,
-            max_priority_fee_per_gas: 0.5,
+        let gas_price = Eip1559Estimation {
+            max_fee_per_gas: 2,
+            max_priority_fee_per_gas: 1,
         };
 
         let mut price_estimator = MockPriceEstimating::new();
@@ -1130,10 +1129,9 @@ mod tests {
             additional_gas: 0,
             timeout: None,
         };
-        let gas_price = GasPrice1559 {
-            base_fee_per_gas: 1.5,
-            max_fee_per_gas: 3.0,
-            max_priority_fee_per_gas: 0.5,
+        let gas_price = Eip1559Estimation {
+            max_fee_per_gas: 2,
+            max_priority_fee_per_gas: 1,
         };
 
         let mut price_estimator = MockPriceEstimating::new();
@@ -1267,10 +1265,9 @@ mod tests {
             additional_gas: 0,
             timeout: None,
         };
-        let gas_price = GasPrice1559 {
-            base_fee_per_gas: 1.,
-            max_fee_per_gas: 2.,
-            max_priority_fee_per_gas: 0.,
+        let gas_price = Eip1559Estimation {
+            max_fee_per_gas: 1,
+            max_priority_fee_per_gas: 0,
         };
 
         let mut price_estimator = MockPriceEstimating::new();
@@ -1341,10 +1338,9 @@ mod tests {
             additional_gas: 0,
             timeout: None,
         };
-        let gas_price = GasPrice1559 {
-            base_fee_per_gas: 1.,
-            max_fee_per_gas: 2.,
-            max_priority_fee_per_gas: 0.,
+        let gas_price = Eip1559Estimation {
+            max_fee_per_gas: 2,
+            max_priority_fee_per_gas: 0,
         };
 
         let mut price_estimator = MockPriceEstimating::new();
diff --git a/crates/shared/src/price_estimation/competition/quote.rs b/crates/shared/src/price_estimation/competition/quote.rs
index b0ef01a748..8c6be7c544 100644
--- a/crates/shared/src/price_estimation/competition/quote.rs
+++ b/crates/shared/src/price_estimation/competition/quote.rs
@@ -112,8 +112,7 @@ impl PriceRanking {
                 let gas = gas.clone();
                 let native = native.clone();
                 let gas = gas
-                    .estimate()
-                    .map_ok(|gas| gas.effective_gas_price())
+                    .effective_gas_price()
                     .map_err(PriceEstimationError::ProtocolInternal);
                 let (native_price, gas_price) = futures::try_join!(
                     native.estimate_native_price(token.into_alloy(), timeout),
@@ -122,7 +121,7 @@ impl PriceRanking {
 
                 Ok(RankingContext {
                     native_price,
-                    gas_price,
+                    gas_price: gas_price as f64,
                 })
             }
         }
@@ -159,14 +158,14 @@ mod tests {
     use {
         super::*,
         crate::{
-            gas_price_estimation::{FakeGasPriceEstimator, price::GasPrice1559},
+            gas_price_estimation::FakeGasPriceEstimator,
             price_estimation::{
                 MockPriceEstimating,
                 QuoteVerificationMode,
                 native::MockNativePriceEstimating,
             },
         },
-        alloy::primitives::U256,
+        alloy::{eips::eip1559::Eip1559Estimation, primitives::U256},
         model::order::OrderKind,
     };
 
@@ -193,10 +192,9 @@ mod tests {
         native
             .expect_estimate_native_price()
             .returning(move |_, _| async { Ok(0.5) }.boxed());
-        let gas = Arc::new(FakeGasPriceEstimator::new(GasPrice1559 {
-            base_fee_per_gas: 2.0,
-            max_fee_per_gas: 2.0,
-            max_priority_fee_per_gas: 2.0,
+        let gas = Arc::new(FakeGasPriceEstimator::new(Eip1559Estimation {
+            max_fee_per_gas: 2,
+            max_priority_fee_per_gas: 2,
         }));
         PriceRanking::BestBangForBuck {
             native: Arc::new(native),

From 0519c04f9584e461f059b81eb9709a72e3c4a72a Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 29 Jan 2026 13:39:44 +0300
Subject: [PATCH 017/219] [TRIVIAL] Add Plasma to OpenApi (#4100)

Adds Plasma URLs to the orderbook's OpenAPI.
---
 crates/orderbook/openapi.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 3027e8fbd6..79a07a488a 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -39,6 +39,10 @@ servers:
     url: "https://api.cow.fi/bnb"
   - description: BNB (Staging)
     url: "https://barn.api.cow.fi/bnb"
+  - description: Plasma (Prod)
+    url: "https://api.cow.fi/plasma"
+  - description: Plasma (Staging)
+    url: "https://barn.api.cow.fi/plasma"
   - description: Sepolia (Prod)
     url: "https://api.cow.fi/sepolia"
   - description: Sepolia (Staging)

From 0e65c61b39d18b56c46c38c44872f4c5f2f9390d Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Thu, 29 Jan 2026 12:16:26 +0100
Subject: [PATCH 018/219] Optimize order queries by using true_valid_to (#4104)

# Description
Reinstates queries from
https://github.com/cowprotocol/services/pull/4055 to accelerate live
order queries based
on the newly introduced `true_valid_to` column and its indexes.

Tested on a test-db created by @MartinquaXD which contains a snapshot of
prod data. The optimized queries run significantly faster due to changes
in `orders` table and new indices.

# Changes
- [x] Adapt user_orders_with_quote query to use new column
- [x] Adapt solvable_orders query to use new column

## How to test
Tested on the test database created by @MartinquaXD by analyzing query
plan (`EXPLAIN (ANALYZE, BUFFERS)`). In the worst case, the latency has
improved 40x (from 20s to 0.5s).
---
 crates/database/src/orders.rs | 96 +++++++++++++++--------------------
 database/README.md            |  2 +
 2 files changed, 44 insertions(+), 54 deletions(-)

diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index d1f77cb052..8da392897a 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -721,26 +721,23 @@ pub fn solvable_orders(
     /// - pending pre-signature
     /// - ethflow specific invalidation conditions
     const OPEN_ORDERS: &str = r#"
-    WITH live_orders AS (
+    WITH live_orders AS MATERIALIZED (
         SELECT o.*
         FROM   orders o
-        LEFT   JOIN ethflow_orders e ON e.uid = o.uid
         WHERE  o.cancellation_timestamp IS NULL
-          AND  o.valid_to >= $1
-          AND (e.valid_to IS NULL OR e.valid_to >= $1)
-          AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
-          AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
-          AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
-                                                                         AND op.placement_error IS NOT NULL)
+            AND o.true_valid_to >= $1
+            AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
     ),
     trades_agg AS (
-         SELECT t.order_uid,
-                SUM(t.buy_amount) AS sum_buy,
-                SUM(t.sell_amount) AS sum_sell,
-                SUM(t.fee_amount) AS sum_fee
-         FROM trades t
-         JOIN live_orders lo ON lo.uid = t.order_uid
-         GROUP BY t.order_uid
+        SELECT t.order_uid,
+            SUM(t.buy_amount) AS sum_buy,
+            SUM(t.sell_amount) AS sum_sell,
+            SUM(t.fee_amount) AS sum_fee
+        FROM trades t
+        JOIN live_orders lo ON lo.uid = t.order_uid
+        GROUP BY t.order_uid
     )
     SELECT
         lo.uid,
@@ -960,46 +957,37 @@ pub async fn user_orders_with_quote(
     owner: &Address,
 ) -> Result<Vec<OrderWithQuote>, sqlx::Error> {
     // Optimized version following the same pattern as OPEN_ORDERS
-    #[rustfmt::skip]
     const QUERY: &str = r#"
-WITH live_orders AS (
-    SELECT o.*
-    FROM   orders o
-    LEFT   JOIN ethflow_orders e ON e.uid = o.uid
-    WHERE  o.cancellation_timestamp IS NULL
-      AND  o.valid_to >= $1
-      AND (e.valid_to IS NULL OR e.valid_to >= $1)
-      AND NOT EXISTS (SELECT 1 FROM invalidations               i  WHERE i.order_uid = o.uid)
-      AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid      = o.uid)
-      AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders       op WHERE op.uid      = o.uid
-                                                                     AND op.placement_error IS NOT NULL)
-      AND  o.owner = $2
-      AND  o.class = 'limit'
-),
-trades_agg AS (
-     SELECT t.order_uid,
-            SUM(t.buy_amount) AS sum_buy,
-            SUM(t.sell_amount) AS sum_sell,
-            SUM(t.fee_amount) AS sum_fee
-     FROM trades t
-     JOIN live_orders lo ON lo.uid = t.order_uid
-     GROUP BY t.order_uid
-)
-SELECT
-    o_quotes.sell_amount as quote_sell_amount,
-    lo.sell_amount as order_sell_amount,
-    o_quotes.buy_amount as quote_buy_amount,
-    lo.buy_amount as order_buy_amount,
-    lo.kind as order_kind,
-    o_quotes.gas_amount as quote_gas_amount,
-    o_quotes.gas_price as quote_gas_price,
-    o_quotes.sell_token_price as quote_sell_token_price
-FROM live_orders lo
-LEFT JOIN trades_agg ta ON  ta.order_uid = lo.uid
-INNER JOIN order_quotes o_quotes ON lo.uid = o_quotes.order_uid
-WHERE ((lo.kind = 'sell' AND COALESCE(ta.sum_sell,0) < lo.sell_amount) OR
-       (lo.kind = 'buy'  AND COALESCE(ta.sum_buy ,0) < lo.buy_amount))
-"#;
+    WITH live_orders AS MATERIALIZED (
+        SELECT o.*
+        FROM   orders o
+        WHERE  o.cancellation_timestamp IS NULL
+            AND o.true_valid_to >= $1
+            AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
+            AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
+            AND  o.owner = $2
+            AND  o.class = 'limit'
+    )
+    SELECT
+        o_quotes.sell_amount  AS quote_sell_amount,
+        lo.sell_amount        AS order_sell_amount,
+        o_quotes.buy_amount   AS quote_buy_amount,
+        lo.buy_amount         AS order_buy_amount,
+        lo.kind               AS order_kind,
+        o_quotes.gas_amount   AS quote_gas_amount,
+        o_quotes.gas_price    AS quote_gas_price,
+        o_quotes.sell_token_price AS quote_sell_token_price
+    FROM live_orders lo
+    INNER JOIN order_quotes o_quotes ON lo.uid = o_quotes.order_uid
+    WHERE (
+        lo.kind = 'sell'
+        AND COALESCE((SELECT SUM(sell_amount) FROM trades WHERE order_uid = lo.uid), 0) < lo.sell_amount
+    ) OR (
+        lo.kind = 'buy'
+        AND COALESCE((SELECT SUM(buy_amount) FROM trades WHERE order_uid = lo.uid), 0) < lo.buy_amount
+    );
+    "#;
     sqlx::query_as::<_, OrderWithQuote>(QUERY)
         .bind(min_valid_to)
         .bind(owner)
diff --git a/database/README.md b/database/README.md
index 32819cf1d5..155d6731f7 100644
--- a/database/README.md
+++ b/database/README.md
@@ -176,6 +176,7 @@ Indexes:
 - PRIMARY KEY: btree(`uid`)
 - event\_index: btree(`block_number`, `index`)
 - order\_sender: hash(sender)
+- okay\_onchain\_orders: btree(`uid`) WHERE placement\_error IS NOT NULL
 
 ### order\_events
 
@@ -273,6 +274,7 @@ Indexes:
 - order_sell_buy_tokens: btree(`sell_token`, `buy_token`)
 - user_order_creation_timestamp: btree(`owner`, `creation_timestamp` DESC)
 - version_idx: btree(`settlement_contract`)
+- orders\_true\_valid\_to: btree(`true_valid_to`)
 
 ### fee_policies
 

From 7fb5cc43cfcfb78709117b69a4f831ea95bf6e48 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 29 Jan 2026 18:04:25 +0300
Subject: [PATCH 019/219] Fix haircut logic (#4093)

# Description

The haircut feature had a critical bug where the driver-reported
`sell_amount` would exceed the user's signed one. For example:
- User signed: sell_amount = 5 ETH
 - Solver proposed a solution with the same sell amount
 - Driver reported: sellAmount = 5.25 ETH (with 5% haircut added)
- The settlement executed onchain, but autopilot couldn't make sense of
it due to the unexpected sell amount
 - The circuit breaker also detects this and bans the solver

# Changes
1. Removed haircut from `sell_amount()` - Now returns only executed +
fee, which is the actual amount that left the user's wallet
2. Added `haircut_in_sell_token()` helper - Computes haircut amount
converted to sell token
3. Updated `custom_prices()` - Applies haircut only for quotes/scoring
purposes, making bids more conservative without affecting reported
amounts
4. Added `Jit::custom_prices()` - JIT orders don't have a haircut (for
now), so they use simple sell/buy amount derivation


## How to test
Adjusted existing and added new tests that fail on the `main` branch,
but work with the fix.
---
 .../src/domain/competition/solution/trade.rs  |  64 +++--
 crates/driver/src/tests/cases/haircut.rs      |  99 +++++++-
 crates/driver/src/tests/setup/mod.rs          |   2 +-
 crates/e2e/tests/e2e/limit_orders.rs          | 239 +++++++++++++++++-
 4 files changed, 370 insertions(+), 34 deletions(-)

diff --git a/crates/driver/src/domain/competition/solution/trade.rs b/crates/driver/src/domain/competition/solution/trade.rs
index 89495728f4..40a97ebf2c 100644
--- a/crates/driver/src/domain/competition/solution/trade.rs
+++ b/crates/driver/src/domain/competition/solution/trade.rs
@@ -96,10 +96,10 @@ impl Trade {
         &self,
         prices: &ClearingPrices,
     ) -> Result<CustomClearingPrices, error::Math> {
-        Ok(CustomClearingPrices {
-            sell: self.buy_amount(prices)?.into(),
-            buy: self.sell_amount(prices)?.into(),
-        })
+        match self {
+            Trade::Fulfillment(fulfillment) => fulfillment.custom_prices(prices),
+            Trade::Jit(jit) => jit.custom_prices(prices),
+        }
     }
 
     pub fn receiver(&self) -> eth::Address {
@@ -224,25 +224,8 @@ impl Fulfillment {
                 .ok_or(Math::DivisionByZero)?,
         };
 
-        // haircut_fee is denominated in the order's target token (sell token for
-        // sell orders, buy token for buy orders). Convert to sell token for buy
-        // orders.
-        let haircut_in_sell_token = match self.order.side {
-            order::Side::Sell => self.haircut_fee,
-            order::Side::Buy => self
-                .haircut_fee
-                .checked_mul(prices.buy)
-                .ok_or(Math::Overflow)?
-                .checked_div(prices.sell)
-                .ok_or(Math::DivisionByZero)?,
-        };
-
         Ok(eth::TokenAmount(
-            before_fee
-                .checked_add(self.fee().0)
-                .ok_or(Math::Overflow)?
-                .checked_add(haircut_in_sell_token)
-                .ok_or(Math::Overflow)?,
+            before_fee.checked_add(self.fee().0).ok_or(Math::Overflow)?,
         ))
     }
 
@@ -263,13 +246,36 @@ impl Fulfillment {
         Ok(eth::TokenAmount(amount))
     }
 
+    /// Computes the haircut amount in sell token for use in custom_prices().
+    /// This applies haircut to pricing while keeping sell_amount() clean for
+    /// reporting.
+    fn haircut_in_sell_token(&self, prices: &ClearingPrices) -> Result<eth::U256, error::Math> {
+        match self.order.side {
+            order::Side::Sell => Ok(self.haircut_fee),
+            order::Side::Buy => self
+                .haircut_fee
+                .checked_mul(prices.buy)
+                .ok_or(Math::Overflow)?
+                .checked_div(prices.sell)
+                .ok_or(Math::DivisionByZero),
+        }
+    }
+
     pub fn custom_prices(
         &self,
         prices: &ClearingPrices,
     ) -> Result<CustomClearingPrices, error::Math> {
+        // Include haircut in custom prices for quotes/scoring.
+        // This makes bids more conservative without affecting the actual
+        // reported sell_amount (which is used for user-facing reporting).
+        let haircut = self.haircut_in_sell_token(prices)?;
         Ok(CustomClearingPrices {
             sell: self.buy_amount(prices)?.into(),
-            buy: self.sell_amount(prices)?.into(),
+            buy: self
+                .sell_amount(prices)?
+                .0
+                .checked_add(haircut)
+                .ok_or(Math::Overflow)?,
         })
     }
 
@@ -509,6 +515,18 @@ impl Jit {
         };
         Ok(eth::TokenAmount(amount))
     }
+
+    pub fn custom_prices(
+        &self,
+        prices: &ClearingPrices,
+    ) -> Result<CustomClearingPrices, error::Math> {
+        // JIT orders don't have haircut, so custom prices are simply derived
+        // from sell_amount and buy_amount.
+        Ok(CustomClearingPrices {
+            sell: self.buy_amount(prices)?.into(),
+            buy: self.sell_amount(prices)?.into(),
+        })
+    }
 }
 
 /// The amounts executed by a trade.
diff --git a/crates/driver/src/tests/cases/haircut.rs b/crates/driver/src/tests/cases/haircut.rs
index 770a39731e..86093659e9 100644
--- a/crates/driver/src/tests/cases/haircut.rs
+++ b/crates/driver/src/tests/cases/haircut.rs
@@ -13,9 +13,12 @@ use {
     number::units::EthUnit,
 };
 
-/// Test that haircut correctly reduces the solution score for orders in real
-/// auctions. The haircut adjusts clearing prices to report lower output
-/// amounts, making the bid more conservative.
+/// Test that haircut correctly reduces the solution score for sell orders.
+/// The haircut adjusts clearing prices to report lower output amounts, making
+/// the bid more conservative.
+///
+/// Also verifies that the reported sell amount matches the user's signed
+/// sell amount exactly (fill-or-kill requires exact execution).
 #[tokio::test]
 #[ignore]
 async fn order_haircut_reduces_score() {
@@ -24,6 +27,7 @@ async fn order_haircut_reduces_score() {
     // We set a generous buy_amount limit (e.g., 2 B) to create slack
     let side = order::Side::Sell;
     let kind = order::Kind::Limit;
+    let signed_sell_amount = ab_order().sell_amount;
 
     // First, get baseline without haircut
     let test_no_haircut = tests::setup()
@@ -77,6 +81,37 @@ async fn order_haircut_reduces_score() {
         score_no_haircut,
         percentage
     );
+
+    // Verify that reported sell amount matches signed amount exactly.
+    // Fill-or-kill orders require exact execution.
+    let solution = solve_with_haircut.solution();
+    let orders = solution.get("orders").unwrap().as_object().unwrap();
+    for (_uid, order_data) in orders {
+        let executed_sell = order_data
+            .get("executedSell")
+            .and_then(|v| v.as_str())
+            .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+            .unwrap();
+        let limit_sell = order_data
+            .get("limitSell")
+            .and_then(|v| v.as_str())
+            .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+            .unwrap();
+
+        assert!(
+            executed_sell == signed_sell_amount,
+            "Sell order: executedSell {} does not match signed sell amount {} (fill-or-kill \
+             requires exact execution)",
+            executed_sell,
+            signed_sell_amount
+        );
+        assert!(
+            executed_sell <= limit_sell,
+            "executedSell {} exceeds limitSell {}",
+            executed_sell,
+            limit_sell
+        );
+    }
 }
 
 /// Test that haircut is properly applied for buy orders.
@@ -85,11 +120,17 @@ async fn order_haircut_reduces_score() {
 /// score. Note: The percentage reduction for buy orders differs from sell
 /// orders because the haircut is applied to the executed buy amount, not
 /// directly to surplus.
+///
+/// Also verifies that:
+/// - `executedBuy == signedBuyAmount` (fill-or-kill must execute exactly)
+/// - `executedSell <= sellLimit` (don't take more than user's maximum)
 #[tokio::test]
 #[ignore]
 async fn buy_order_haircut() {
     let side = order::Side::Buy;
     let kind = order::Kind::Limit;
+    let signed_buy_amount = 2u64.eth();
+    let sell_limit = 100u64.ether().into_wei();
 
     // For buy orders, we need to set a buy_amount that creates enough surplus.
     // The pool has 100000:6000 ratio. For a buy order wanting 2.97 B,
@@ -101,8 +142,8 @@ async fn buy_order_haircut() {
             ab_order()
                 .side(side)
                 .kind(kind)
-                .buy_amount(2u64.eth()) // Target buy amount
-                .sell_amount(100u64.ether().into_wei()) // Generous sell limit creates surplus
+                .buy_amount(signed_buy_amount) // Target buy amount (what user signs for)
+                .sell_amount(sell_limit) // Generous sell limit creates surplus
                 .solver_fee(Some(eth::U256::from(100))),
         )
         .solution(ab_solution())
@@ -120,8 +161,8 @@ async fn buy_order_haircut() {
             ab_order()
                 .side(side)
                 .kind(kind)
-                .buy_amount(2u64.eth()) // Same target buy amount
-                .sell_amount(100u64.ether().into_wei()) // Same generous sell limit
+                .buy_amount(signed_buy_amount) // Same target buy amount
+                .sell_amount(sell_limit) // Same generous sell limit
                 .solver_fee(Some(eth::U256::from(100))),
         )
         .solution(ab_solution())
@@ -152,4 +193,48 @@ async fn buy_order_haircut() {
         score_no_haircut,
         percentage
     );
+
+    // Verify buy order constraints:
+    // - Fill-or-kill must execute exactly (executedBuy == signedBuyAmount)
+    // - Don't take more than user's maximum (executedSell <= sellLimit)
+    let solution = solve_with_haircut.solution();
+    let orders = solution.get("orders").unwrap().as_object().unwrap();
+    for (_uid, order_data) in orders {
+        let executed_sell = order_data
+            .get("executedSell")
+            .and_then(|v| v.as_str())
+            .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+            .unwrap();
+        let executed_buy = order_data
+            .get("executedBuy")
+            .and_then(|v| v.as_str())
+            .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+            .unwrap();
+        let limit_sell = order_data
+            .get("limitSell")
+            .and_then(|v| v.as_str())
+            .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+            .unwrap();
+
+        assert!(
+            executed_buy == signed_buy_amount,
+            "Buy order: executedBuy {} does not match signed buy amount {} (fill-or-kill requires \
+             exact execution)",
+            executed_buy,
+            signed_buy_amount
+        );
+        assert!(
+            executed_sell <= sell_limit,
+            "Buy order: executedSell {} exceeds sell limit {}. Haircut should reduce surplus, not \
+             inflate sell amount!",
+            executed_sell,
+            sell_limit
+        );
+        assert!(
+            executed_sell <= limit_sell,
+            "executedSell {} exceeds limitSell {}",
+            executed_sell,
+            limit_sell
+        );
+    }
 }
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 09f62f2ca0..e336fe7945 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -1266,7 +1266,7 @@ impl SolveOk<'_> {
     /// Extracts the first solution from the response. This is expected to be
     /// always valid if there is a valid solution, as we expect from driver to
     /// not send multiple solutions (yet).
-    fn solution(&self) -> serde_json::Value {
+    pub fn solution(&self) -> serde_json::Value {
         let solutions = self.solutions();
         assert_eq!(solutions.len(), 1);
         let solution = solutions[0].clone();
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index ca278b097d..ed71e6e609 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -57,13 +57,23 @@ async fn local_node_no_liquidity_limit_order() {
     run_test(no_liquidity_limit_order).await;
 }
 
-/// Test that orders with haircut configured still execute on-chain.
+/// Test that sell orders with haircut configured still execute on-chain.
 /// The haircut reduces the reported surplus but the order should still be
 /// fillable and execute successfully.
 #[tokio::test]
 #[ignore]
 async fn local_node_limit_order_with_haircut() {
-    run_test(limit_order_with_haircut_test).await;
+    run_test(sell_order_with_haircut_test).await;
+}
+
+/// Test that buy orders with haircut configured still execute on-chain.
+/// For buy orders, verifies that:
+/// - executedBuy >= signedBuyAmount (user gets at least what they signed for)
+/// - executedSell <= sellLimit (don't take more than user's maximum)
+#[tokio::test]
+#[ignore]
+async fn local_node_buy_order_with_haircut() {
+    run_test(buy_order_with_haircut_test).await;
 }
 
 /// The block number from which we will fetch state for the forked tests.
@@ -1175,7 +1185,7 @@ async fn no_liquidity_limit_order(web3: Web3) {
 /// Test that a limit order with haircut configured still executes on-chain.
 /// The haircut adjusts clearing prices to report lower surplus, but the order
 /// should still be fillable since the limit price allows for enough slack.
-async fn limit_order_with_haircut_test(web3: Web3) {
+async fn sell_order_with_haircut_test(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
     let [solver] = onchain.make_solvers(1u64.eth()).await;
@@ -1322,4 +1332,227 @@ async fn limit_order_with_haircut_test(web3: Web3) {
         "Trader should have received between 9 and 9.5 ETH (AMM output minus haircut), but got {}",
         trader_received
     );
+
+    // Wait for solver competition data to be indexed
+    tracing::info!("Waiting for solver competition to be indexed");
+    let indexed = || async {
+        onchain.mint_block().await;
+        match services.get_trades(&order_id).await.unwrap().first() {
+            Some(trade) => services
+                .get_solver_competition(trade.tx_hash.unwrap())
+                .await
+                .is_ok(),
+            None => false,
+        }
+    };
+    wait_for_condition(TIMEOUT, indexed).await.unwrap();
+
+    let trades = services.get_trades(&order_id).await.unwrap();
+    let tx_hash = trades[0].tx_hash.unwrap();
+    let competition = services.get_solver_competition(tx_hash).await.unwrap();
+
+    // Find our order in the winning solution
+    let winner = competition
+        .solutions
+        .iter()
+        .find(|s| s.is_winner)
+        .expect("Should have winning solution");
+
+    let reported_order = winner
+        .orders
+        .iter()
+        .find(|o| o.id == order_id)
+        .expect("Order should be in solution");
+
+    let signed_sell_amount = U256::from(order.sell_amount);
+    let reported_sell_amount = reported_order.sell_amount;
+
+    assert!(
+        reported_sell_amount <= signed_sell_amount,
+        "Driver reported sell_amount {} exceeds signed sell_amount {}. Haircut should reduce \
+         surplus/score, not inflate the reported sell amount!",
+        reported_sell_amount,
+        signed_sell_amount
+    );
+}
+
+/// Test that a buy order with haircut configured executes correctly.
+/// For buy orders, the user signs for a specific buy_amount they want to
+/// receive, and sell_amount is the maximum they're willing to pay.
+/// Verifies that reported amounts respect these constraints.
+async fn buy_order_with_haircut_test(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(1u64.eth()).await;
+    let [trader] = onchain.make_accounts(1u64.eth()).await;
+    let [token_a, token_b] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    // Create and fund Uniswap pool (1:1 ratio)
+    token_a.mint(solver.address(), 1000u64.eth()).await;
+    token_b.mint(solver.address(), 1000u64.eth()).await;
+    onchain
+        .contracts()
+        .uniswap_v2_factory
+        .createPair(*token_a.address(), *token_b.address())
+        .from(solver.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    token_a
+        .approve(
+            *onchain.contracts().uniswap_v2_router.address(),
+            1000u64.eth(),
+        )
+        .from(solver.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    token_b
+        .approve(
+            *onchain.contracts().uniswap_v2_router.address(),
+            1000u64.eth(),
+        )
+        .from(solver.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    onchain
+        .contracts()
+        .uniswap_v2_router
+        .addLiquidity(
+            *token_a.address(),
+            *token_b.address(),
+            1000u64.eth(),
+            1000u64.eth(),
+            U256::ZERO,
+            U256::ZERO,
+            solver.address(),
+            U256::MAX,
+        )
+        .from(solver.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Fund trader with token_a for selling
+    token_a.mint(trader.address(), 100u64.eth()).await;
+    token_a
+        .approve(onchain.contracts().allowance, 100u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Start protocol with 500 bps (5%) haircut
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args_and_haircut(Default::default(), solver, 500)
+        .await;
+
+    // Create BUY order: want to buy 5 token_b, willing to sell up to 10 token_a.
+    // At 1:1 ratio (with ~0.3% AMM fee), we'd need ~5.04 token_a.
+    // We use a generous sell_limit to ensure the order executes, then verify
+    // that the driver's reported sell_amount doesn't exceed reasonable bounds.
+    let signed_buy_amount = 5u64.eth();
+    let sell_limit = 10u64.eth(); // Generous limit to ensure execution
+    let order = OrderCreation {
+        sell_token: *token_a.address(),
+        sell_amount: sell_limit,
+        buy_token: *token_b.address(),
+        buy_amount: signed_buy_amount,
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Buy,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let order_id = services.create_order(&order).await.unwrap();
+
+    onchain.mint_block().await;
+    let limit_order = services.get_order(&order_id).await.unwrap();
+    assert_eq!(limit_order.metadata.class, OrderClass::Limit);
+
+    // Wait for trade to execute
+    tracing::info!("Waiting for buy order trade with haircut.");
+    let trader_b_balance_before = token_b.balanceOf(trader.address()).call().await.unwrap();
+    wait_for_condition(TIMEOUT, || async {
+        let balance_after = token_b.balanceOf(trader.address()).call().await.unwrap();
+        balance_after > trader_b_balance_before
+    })
+    .await
+    .unwrap();
+
+    // Wait for solver competition data to be indexed
+    tracing::info!("Waiting for solver competition to be indexed");
+    let indexed = || async {
+        onchain.mint_block().await;
+        match services.get_trades(&order_id).await.unwrap().first() {
+            Some(trade) => services
+                .get_solver_competition(trade.tx_hash.unwrap())
+                .await
+                .is_ok(),
+            None => false,
+        }
+    };
+    wait_for_condition(TIMEOUT, indexed).await.unwrap();
+
+    let trades = services.get_trades(&order_id).await.unwrap();
+    let tx_hash = trades[0].tx_hash.unwrap();
+    let competition = services.get_solver_competition(tx_hash).await.unwrap();
+
+    // Find our order in the winning solution
+    let winner = competition
+        .solutions
+        .iter()
+        .find(|s| s.is_winner)
+        .expect("Should have winning solution");
+
+    let reported_order = winner
+        .orders
+        .iter()
+        .find(|o| o.id == order_id)
+        .expect("Order should be in solution");
+
+    let signed_buy_amount_u256 = U256::from(signed_buy_amount);
+    let sell_limit_u256 = U256::from(sell_limit);
+    let reported_sell_amount = reported_order.sell_amount;
+    let reported_buy_amount = reported_order.buy_amount;
+
+    // For buy orders:
+    // 1. User should get at least what they signed for
+    assert!(
+        reported_buy_amount >= signed_buy_amount_u256,
+        "Buy order: reported buy_amount {} is less than signed buy_amount {}",
+        reported_buy_amount,
+        signed_buy_amount_u256
+    );
+
+    // 2. Don't take more than user's maximum
+    assert!(
+        reported_sell_amount <= sell_limit_u256,
+        "Driver reported sell_amount {} exceeds sell limit {}",
+        reported_sell_amount,
+        sell_limit_u256
+    );
+
+    // 3. Reported sell_amount should be close to what's actually needed (~5.04 ETH
+    //    for buying 5 ETH at 1:1 with 0.3% fee).
+    // We check that sell_amount is less than 5.2 ETH (5.0 ETH + 5% haircut = 5.25
+    // ETH).
+    let reasonable_max_sell = U256::from(5_200_000_000_000_000_000u128); // 5.2 ETH
+    assert!(
+        reported_sell_amount <= reasonable_max_sell,
+        "Driver reported sell_amount {} exceeds expected max {} (actual needed is ~5.04 ETH). \
+         Haircut should reduce surplus/score, not inflate the reported sell amount!",
+        reported_sell_amount,
+        reasonable_max_sell
+    );
 }

From d63e52f480ed6273234c9b4fbfe13605c71be54f Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 30 Jan 2026 15:55:55 +0300
Subject: [PATCH 020/219] [TRIVIAL] Drop the db solver participation guard
 (#4099)

# Description
Cleans up the codebase by removing the DB solver participation guard.
It's been used in a log-only mode for a while. Given the lack of demand
for this functionality, it doesn't make sense to keep it. Also, even if
it were decided to enable it, the logic would need to be reworked to
cover some edge cases, which would take some time to implement.
---
 crates/autopilot/src/arguments.rs             | 151 +-----
 .../autopilot/src/domain/competition/mod.rs   |   6 +-
 .../competition/participation_guard/db.rs     | 210 --------
 .../competition/participation_guard/mod.rs    |  67 ---
 .../participation_guard/onchain.rs            |  20 -
 .../domain/competition/winner_selection.rs    |   1 -
 crates/autopilot/src/domain/mod.rs            |   5 -
 crates/autopilot/src/infra/mod.rs             |   2 +-
 crates/autopilot/src/infra/persistence/mod.rs |  57 ---
 crates/autopilot/src/infra/solvers/dto/mod.rs |   1 -
 .../autopilot/src/infra/solvers/dto/notify.rs |  34 --
 crates/autopilot/src/infra/solvers/mod.rs     |  27 +-
 crates/autopilot/src/run.rs                   |  17 +-
 crates/autopilot/src/run_loop.rs              |  37 +-
 crates/database/src/solver_competition_v2.rs  | 454 ------------------
 crates/driver/src/infra/api/mod.rs            |   1 -
 crates/driver/src/infra/api/routes/mod.rs     |   2 -
 .../src/infra/api/routes/notify/dto/mod.rs    |   3 -
 .../api/routes/notify/dto/notify_request.rs   |  42 --
 .../driver/src/infra/api/routes/notify/mod.rs |  17 -
 crates/driver/src/infra/notify/mod.rs         |   9 +-
 .../driver/src/infra/notify/notification.rs   |  14 -
 .../src/infra/solver/dto/notification.rs      |  11 -
 crates/e2e/src/setup/services.rs              |   2 -
 crates/e2e/tests/e2e/main.rs                  |   1 -
 .../tests/e2e/solver_participation_guard.rs   | 359 --------------
 crates/solvers-dto/src/notification.rs        |  12 -
 27 files changed, 15 insertions(+), 1547 deletions(-)
 delete mode 100644 crates/autopilot/src/domain/competition/participation_guard/db.rs
 delete mode 100644 crates/autopilot/src/domain/competition/participation_guard/mod.rs
 delete mode 100644 crates/autopilot/src/domain/competition/participation_guard/onchain.rs
 delete mode 100644 crates/autopilot/src/infra/solvers/dto/notify.rs
 delete mode 100644 crates/driver/src/infra/api/routes/notify/dto/mod.rs
 delete mode 100644 crates/driver/src/infra/api/routes/notify/dto/notify_request.rs
 delete mode 100644 crates/driver/src/infra/api/routes/notify/mod.rs
 delete mode 100644 crates/e2e/tests/e2e/solver_participation_guard.rs

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 1d0b89897d..a6cb1cf8ca 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -248,10 +248,6 @@ pub struct Arguments {
     #[clap(long, env)]
     pub archive_node_url: Option<Url>,
 
-    /// Configuration for the solver participation guard.
-    #[clap(flatten)]
-    pub db_based_solver_participation_guard: DbBasedSolverParticipationGuardConfig,
-
     /// Configures whether the autopilot filters out orders with insufficient
     /// balances.
     #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
@@ -282,89 +278,6 @@ pub struct Arguments {
     pub max_maintenance_timeout: Duration,
 }
 
-#[derive(Debug, clap::Parser)]
-pub struct DbBasedSolverParticipationGuardConfig {
-    /// Enables or disables the solver participation guard
-    #[clap(
-        id = "db_enabled",
-        long = "db-based-solver-participation-guard-enabled",
-        env = "DB_BASED_SOLVER_PARTICIPATION_GUARD_ENABLED",
-        default_value = "true"
-    )]
-    pub enabled: bool,
-
-    /// Sets the duration for which the solver remains blacklisted.
-    /// Technically, the time-to-live for the solver participation blacklist
-    /// cache.
-    #[clap(long, env, default_value = "5m", value_parser = humantime::parse_duration)]
-    pub solver_blacklist_cache_ttl: Duration,
-
-    #[clap(flatten)]
-    pub non_settling_solvers_finder_config: NonSettlingSolversFinderConfig,
-
-    #[clap(flatten)]
-    pub low_settling_solvers_finder_config: LowSettlingSolversFinderConfig,
-}
-
-#[derive(Debug, clap::Parser)]
-pub struct NonSettlingSolversFinderConfig {
-    /// Enables search of non-settling solvers.
-    #[clap(
-        id = "non_settling_solvers_blacklisting_enabled",
-        long = "non-settling-solvers-blacklisting-enabled",
-        env = "NON_SETTLING_SOLVERS_BLACKLISTING_ENABLED",
-        default_value = "true",
-        action = clap::ArgAction::Set,
-    )]
-    pub enabled: bool,
-
-    /// The number of last auctions to check solver participation eligibility.
-    #[clap(
-        id = "non_settling_last_auctions_participation_count",
-        long = "non-settling-last-auctions-participation-count",
-        env = "NON_SETTLING_LAST_AUCTIONS_PARTICIPATION_COUNT",
-        default_value = "3"
-    )]
-    pub last_auctions_participation_count: u32,
-}
-
-#[derive(Debug, clap::Parser)]
-pub struct LowSettlingSolversFinderConfig {
-    /// Enables search of non-settling solvers.
-    #[clap(
-        id = "low_settling_solvers_blacklisting_enabled",
-        long = "low-settling-solvers-blacklisting-enabled",
-        env = "LOW_SETTLING_SOLVERS_BLACKLISTING_ENABLED",
-        default_value = "true",
-        action = clap::ArgAction::Set,
-    )]
-    pub enabled: bool,
-
-    /// The number of last auctions to check solver participation eligibility.
-    #[clap(
-        id = "low_settling_last_auctions_participation_count",
-        long = "low-settling-last-auctions-participation-count",
-        env = "LOW_SETTLING_LAST_AUCTIONS_PARTICIPATION_COUNT",
-        default_value = "100"
-    )]
-    pub last_auctions_participation_count: u32,
-
-    /// The minimum number of winning solutions to start considering the solver.
-    #[clap(
-        id = "low_settling_min_wins_threshold",
-        long = "low-settling-min-wins-threshold",
-        env = "LOW_SETTLING_MIN_WINS_THRESHOLD",
-        default_value = "3"
-    )]
-    pub min_wins_threshold: u32,
-
-    /// A max failure rate for a solver to remain eligible for
-    /// participation in the competition. Otherwise, the solver will be
-    /// banned.
-    #[clap(long, env, default_value = "0.9")]
-    pub solver_max_settlement_failure_rate: f64,
-}
-
 impl std::fmt::Display for Arguments {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let Self {
@@ -409,7 +322,6 @@ impl std::fmt::Display for Arguments {
             max_winners_per_auction,
             archive_node_url,
             max_solutions_per_solver,
-            db_based_solver_participation_guard,
             disable_order_balance_filter,
             disable_1271_order_balance_filter,
             disable_1271_order_sig_filter,
@@ -482,10 +394,6 @@ impl std::fmt::Display for Arguments {
         writeln!(f, "max_winners_per_auction: {max_winners_per_auction:?}")?;
         writeln!(f, "archive_node_url: {archive_node_url:?}")?;
         writeln!(f, "max_solutions_per_solver: {max_solutions_per_solver:?}")?;
-        writeln!(
-            f,
-            "db_based_solver_participation_guard: {db_based_solver_participation_guard:?}"
-        )?;
         writeln!(
             f,
             "disable_order_balance_filter: {disable_order_balance_filter}"
@@ -511,7 +419,6 @@ pub struct Solver {
     pub url: Url,
     pub submission_account: Account,
     pub fairness_threshold: Option<U256>,
-    pub requested_timeout_on_problems: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -561,31 +468,15 @@ impl FromStr for Solver {
             }
         };
 
-        let mut fairness_threshold: Option<U256> = Default::default();
-        let mut requested_timeout_on_problems = false;
-
-        if let Some(value) = parts.get(3) {
-            match U256::from_str_radix(value, 10) {
-                Ok(parsed_fairness_threshold) => {
-                    fairness_threshold = Some(parsed_fairness_threshold);
-                }
-                Err(_) => {
-                    requested_timeout_on_problems =
-                        value.to_lowercase() == "requested-timeout-on-problems";
-                }
-            }
-        };
-
-        if let Some(value) = parts.get(4) {
-            requested_timeout_on_problems = value.to_lowercase() == "requested-timeout-on-problems";
-        }
+        let fairness_threshold = parts
+            .get(3)
+            .and_then(|value| U256::from_str_radix(value, 10).ok());
 
         Ok(Self {
             name: name.to_owned(),
             url,
             fairness_threshold,
             submission_account,
-            requested_timeout_on_problems,
         })
     }
 }
@@ -818,7 +709,6 @@ mod test {
             name: "name1".into(),
             url: Url::parse("http://localhost:8080").unwrap(),
             fairness_threshold: None,
-            requested_timeout_on_problems: false,
             submission_account: Account::Address(address!(
                 "C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
             )),
@@ -834,7 +724,6 @@ mod test {
             name: "name1".into(),
             url: Url::parse("http://localhost:8080").unwrap(),
             fairness_threshold: None,
-            requested_timeout_on_problems: false,
             submission_account: Account::Kms(
                 Arn::from_str("arn:aws:kms:supersecretstuff").unwrap(),
             ),
@@ -853,40 +742,6 @@ mod test {
                 "C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
             )),
             fairness_threshold: Some(U256::from(10).pow(U256::from(18))),
-            requested_timeout_on_problems: false,
-        };
-        assert_eq!(driver, expected);
-    }
-
-    #[test]
-    fn parse_driver_with_accepts_unsettled_blocking_flag() {
-        let argument =
-            "name1|http://localhost:8080|0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2|requested-timeout-on-problems";
-        let driver = Solver::from_str(argument).unwrap();
-        let expected = Solver {
-            name: "name1".into(),
-            url: Url::parse("http://localhost:8080").unwrap(),
-            submission_account: Account::Address(address!(
-                "C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-            )),
-            fairness_threshold: None,
-            requested_timeout_on_problems: true,
-        };
-        assert_eq!(driver, expected);
-    }
-
-    #[test]
-    fn parse_driver_with_threshold_and_accepts_unsettled_blocking_flag() {
-        let argument = "name1|http://localhost:8080|0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2|1000000000000000000|requested-timeout-on-problems";
-        let driver = Solver::from_str(argument).unwrap();
-        let expected = Solver {
-            name: "name1".into(),
-            url: Url::parse("http://localhost:8080").unwrap(),
-            submission_account: Account::Address(address!(
-                "C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-            )),
-            fairness_threshold: Some(U256::from(10).pow(U256::from(18))),
-            requested_timeout_on_problems: true,
         };
         assert_eq!(driver, expected);
     }
diff --git a/crates/autopilot/src/domain/competition/mod.rs b/crates/autopilot/src/domain/competition/mod.rs
index a5ea589a9c..0a3a25e51a 100644
--- a/crates/autopilot/src/domain/competition/mod.rs
+++ b/crates/autopilot/src/domain/competition/mod.rs
@@ -8,13 +8,9 @@ use {
 };
 
 mod bid;
-mod participation_guard;
 pub mod winner_selection;
 
-pub use {
-    bid::{Bid, RankType, Ranked, Scored, Unscored},
-    participation_guard::SolverParticipationGuard,
-};
+pub use bid::{Bid, RankType, Ranked, Scored, Unscored};
 
 type SolutionId = u64;
 
diff --git a/crates/autopilot/src/domain/competition/participation_guard/db.rs b/crates/autopilot/src/domain/competition/participation_guard/db.rs
deleted file mode 100644
index 4c7b0ba53b..0000000000
--- a/crates/autopilot/src/domain/competition/participation_guard/db.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-use {
-    crate::{
-        arguments::{
-            DbBasedSolverParticipationGuardConfig,
-            LowSettlingSolversFinderConfig,
-            NonSettlingSolversFinderConfig,
-        },
-        domain::{Metrics, eth},
-        infra::{self, solvers::dto},
-    },
-    chrono::{DateTime, Utc},
-    ethrpc::block_stream::CurrentBlockWatcher,
-    std::{
-        collections::{HashMap, HashSet},
-        sync::Arc,
-        time::{Duration, Instant},
-    },
-    tokio::join,
-};
-
-/// Checks the DB by searching for solvers that won N last consecutive auctions
-/// and either never settled any of them or their settlement success rate is
-/// lower than `min_settlement_success_rate`.
-#[derive(Clone)]
-pub(super) struct SolverValidator(Arc<Inner>);
-
-struct Inner {
-    persistence: infra::Persistence,
-    banned_solvers: dashmap::DashMap<eth::Address, Instant>,
-    ttl: Duration,
-    non_settling_config: NonSettlingSolversFinderConfig,
-    low_settling_config: LowSettlingSolversFinderConfig,
-    drivers_by_address: HashMap<eth::Address, Arc<infra::Driver>>,
-}
-
-impl SolverValidator {
-    pub fn new(
-        persistence: infra::Persistence,
-        current_block: CurrentBlockWatcher,
-        competition_updates_receiver: tokio::sync::mpsc::UnboundedReceiver<()>,
-        db_based_validator_config: DbBasedSolverParticipationGuardConfig,
-        drivers_by_address: HashMap<eth::Address, Arc<infra::Driver>>,
-    ) -> Self {
-        let self_ = Self(Arc::new(Inner {
-            persistence,
-            banned_solvers: Default::default(),
-            ttl: db_based_validator_config.solver_blacklist_cache_ttl,
-            non_settling_config: db_based_validator_config.non_settling_solvers_finder_config,
-            low_settling_config: db_based_validator_config.low_settling_solvers_finder_config,
-            drivers_by_address,
-        }));
-
-        self_.start_maintenance(competition_updates_receiver, current_block);
-
-        self_
-    }
-
-    /// Update the internal cache only once the competition auctions table is
-    /// updated to avoid redundant DB queries on each block or any other
-    /// timeout.
-    fn start_maintenance(
-        &self,
-        mut competition_updates_receiver: tokio::sync::mpsc::UnboundedReceiver<()>,
-        current_block: CurrentBlockWatcher,
-    ) {
-        let self_ = self.clone();
-        tokio::spawn(async move {
-            while competition_updates_receiver.recv().await.is_some() {
-                let current_block = current_block.borrow().number;
-
-                let (non_settling_solvers, mut low_settling_solvers) = join!(
-                    self_.find_non_settling_solvers(current_block),
-                    self_.find_low_settling_solvers(current_block)
-                );
-                // Non-settling issue has a higher priority, remove duplicates from low-settling
-                // solvers.
-                low_settling_solvers.retain(|solver| !non_settling_solvers.contains(solver));
-
-                let found_at = Instant::now();
-                let banned_until = Utc::now() + self_.0.ttl;
-
-                self_.post_process(
-                    &non_settling_solvers,
-                    dto::notify::BanReason::UnsettledConsecutiveAuctions,
-                    found_at,
-                    current_block,
-                    banned_until,
-                );
-                self_.post_process(
-                    &low_settling_solvers,
-                    dto::notify::BanReason::HighSettleFailureRate,
-                    found_at,
-                    current_block,
-                    banned_until,
-                );
-            }
-            tracing::error!("stream of settlement updates terminated unexpectedly");
-        });
-    }
-
-    async fn find_non_settling_solvers(&self, current_block: u64) -> HashSet<eth::Address> {
-        if !self.0.non_settling_config.enabled {
-            return Default::default();
-        }
-
-        match self
-            .0
-            .persistence
-            .find_non_settling_solvers(
-                self.0.non_settling_config.last_auctions_participation_count,
-                current_block,
-            )
-            .await
-        {
-            Ok(solvers) => solvers.into_iter().collect(),
-            Err(err) => {
-                tracing::warn!(?err, "error while searching for non-settling solvers");
-                Default::default()
-            }
-        }
-    }
-
-    async fn find_low_settling_solvers(&self, current_block: u64) -> HashSet<eth::Address> {
-        if !self.0.low_settling_config.enabled {
-            return Default::default();
-        }
-
-        match self
-            .0
-            .persistence
-            .find_low_settling_solvers(
-                self.0.low_settling_config.last_auctions_participation_count,
-                current_block,
-                self.0
-                    .low_settling_config
-                    .solver_max_settlement_failure_rate,
-                self.0.low_settling_config.min_wins_threshold,
-            )
-            .await
-        {
-            Ok(solvers) => solvers.into_iter().collect(),
-            Err(err) => {
-                tracing::warn!(?err, "error while searching for low-settling solvers");
-                Default::default()
-            }
-        }
-    }
-
-    /// Updates the cache and notifies the solvers.
-    fn post_process(
-        &self,
-        solvers: &HashSet<eth::Address>,
-        ban_reason: dto::notify::BanReason,
-        found_at_timestamp: Instant,
-        found_at_block: u64,
-        banned_until: DateTime<Utc>,
-    ) {
-        let non_settling_solver_names: Vec<&str> = solvers
-            .iter()
-            .filter_map(|solver| self.0.drivers_by_address.get(solver))
-            .map(|driver| {
-                Metrics::get()
-                    .banned_solver
-                    .with_label_values(&[driver.name.as_ref(), ban_reason.as_str()])
-                    .inc();
-                // Check if solver accepted this feature. This should be removed once the
-                // CIP making this mandatory has been approved.
-                if driver.requested_timeout_on_problems {
-                    let is_absent_or_expired = self
-                        .0
-                        .banned_solvers
-                        .get(&driver.submission_address)
-                        .is_none_or(|entry| entry.elapsed() >= self.0.ttl);
-                    // The solver should try again once the cache is expired.
-                    if is_absent_or_expired {
-                        tracing::debug!(solver = ?driver.name, "disabling solver temporarily");
-                        infra::notify_banned_solver(driver.clone(), ban_reason, banned_until);
-                        self.0
-                            .banned_solvers
-                            .insert(driver.submission_address, found_at_timestamp);
-                    }
-                }
-                driver.name.as_ref()
-            })
-            .collect();
-
-        if non_settling_solver_names.is_empty() {
-            return;
-        }
-
-        let log_message = match ban_reason {
-            dto::notify::BanReason::UnsettledConsecutiveAuctions => "found non-settling solvers",
-            dto::notify::BanReason::HighSettleFailureRate => {
-                "found high-failure-settlement solvers"
-            }
-        };
-        tracing::debug!(solvers = ?non_settling_solver_names, ?found_at_block, log_message);
-    }
-}
-
-#[async_trait::async_trait]
-impl super::SolverValidator for SolverValidator {
-    async fn is_allowed(&self, solver: &eth::Address) -> anyhow::Result<bool> {
-        if let Some(entry) = self.0.banned_solvers.get(solver) {
-            return Ok(entry.elapsed() >= self.0.ttl);
-        }
-
-        Ok(true)
-    }
-}
diff --git a/crates/autopilot/src/domain/competition/participation_guard/mod.rs b/crates/autopilot/src/domain/competition/participation_guard/mod.rs
deleted file mode 100644
index dcff407581..0000000000
--- a/crates/autopilot/src/domain/competition/participation_guard/mod.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-mod db;
-mod onchain;
-
-use {
-    crate::{arguments::DbBasedSolverParticipationGuardConfig, domain::eth, infra},
-    std::sync::Arc,
-};
-
-/// This struct checks whether a solver can participate in the competition by
-/// using different validators.
-#[derive(Clone)]
-pub struct SolverParticipationGuard(Arc<Inner>);
-
-struct Inner {
-    /// Stores the validators in order they will be called.
-    validators: Vec<Box<dyn SolverValidator + Send + Sync>>,
-}
-
-impl SolverParticipationGuard {
-    pub fn new(
-        eth: infra::Ethereum,
-        persistence: infra::Persistence,
-        competition_updates_receiver: tokio::sync::mpsc::UnboundedReceiver<()>,
-        db_based_validator_config: DbBasedSolverParticipationGuardConfig,
-        drivers: impl IntoIterator<Item = Arc<infra::Driver>>,
-    ) -> Self {
-        let mut validators: Vec<Box<dyn SolverValidator + Send + Sync>> = Vec::new();
-
-        let current_block = eth.current_block().clone();
-        let database_solver_participation_validator = db::SolverValidator::new(
-            persistence,
-            current_block,
-            competition_updates_receiver,
-            db_based_validator_config,
-            drivers
-                .into_iter()
-                .map(|driver| (driver.submission_address, driver.clone()))
-                .collect(),
-        );
-        validators.push(Box::new(database_solver_participation_validator));
-
-        let onchain_solver_participation_validator = onchain::Validator { eth };
-        validators.push(Box::new(onchain_solver_participation_validator));
-
-        Self(Arc::new(Inner { validators }))
-    }
-
-    /// Checks if a solver can participate in the competition.
-    /// Sequentially asks internal validators to avoid redundant RPC calls in
-    /// the following order:
-    /// 1. DB-based validator: operates fast since it uses in-memory cache.
-    /// 2. Onchain-based validator: only then calls the Authenticator contract.
-    pub async fn can_participate(&self, solver: &eth::Address) -> anyhow::Result<bool> {
-        for validator in &self.0.validators {
-            if !validator.is_allowed(solver).await? {
-                return Ok(false);
-            }
-        }
-
-        Ok(true)
-    }
-}
-
-#[async_trait::async_trait]
-trait SolverValidator: Send + Sync {
-    async fn is_allowed(&self, solver: &eth::Address) -> anyhow::Result<bool>;
-}
diff --git a/crates/autopilot/src/domain/competition/participation_guard/onchain.rs b/crates/autopilot/src/domain/competition/participation_guard/onchain.rs
deleted file mode 100644
index 70ef3b16f2..0000000000
--- a/crates/autopilot/src/domain/competition/participation_guard/onchain.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use crate::{domain::eth, infra};
-
-/// Calls Authenticator contract to check if a solver has a sufficient
-/// permission.
-pub(super) struct Validator {
-    pub eth: infra::Ethereum,
-}
-
-#[async_trait::async_trait]
-impl super::SolverValidator for Validator {
-    async fn is_allowed(&self, solver: &eth::Address) -> anyhow::Result<bool> {
-        Ok(self
-            .eth
-            .contracts()
-            .authenticator()
-            .isSolver(*solver)
-            .call()
-            .await?)
-    }
-}
diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 976692e06b..2a5b6f12dd 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -1219,7 +1219,6 @@ mod tests {
             solver_address.to_string(),
             None,
             crate::arguments::Account::Address(solver_address),
-            false,
         )
         .await
         .unwrap();
diff --git a/crates/autopilot/src/domain/mod.rs b/crates/autopilot/src/domain/mod.rs
index df25fa082b..deb7d0da9c 100644
--- a/crates/autopilot/src/domain/mod.rs
+++ b/crates/autopilot/src/domain/mod.rs
@@ -18,11 +18,6 @@ pub use {
 #[derive(prometheus_metric_storage::MetricStorage)]
 #[metric(subsystem = "domain")]
 pub struct Metrics {
-    /// How many times the solver marked as non-settling based on the database
-    /// statistics.
-    #[metric(labels("solver", "reason"))]
-    pub banned_solver: prometheus::IntCounterVec,
-
     /// Tracks settlements that couldn't be matched to the database solutions.
     #[metric(labels("solver_address"))]
     pub inconsistent_settlements: prometheus::IntCounterVec,
diff --git a/crates/autopilot/src/infra/mod.rs b/crates/autopilot/src/infra/mod.rs
index 11c2d58857..4d34b214b7 100644
--- a/crates/autopilot/src/infra/mod.rs
+++ b/crates/autopilot/src/infra/mod.rs
@@ -8,5 +8,5 @@ pub use {
     blockchain::Ethereum,
     order_validation::banned,
     persistence::Persistence,
-    solvers::{Driver, notify_banned_solver},
+    solvers::Driver,
 };
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index b816358fda..c6fcf7e4d7 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -946,63 +946,6 @@ impl Persistence {
         Ok(())
     }
 
-    /// Finds solvers that won `last_auctions_count` consecutive auctions but
-    /// never settled any of them. The current block is used to prevent
-    /// selecting auctions with deadline after the current block since they
-    /// still can be settled.
-    pub async fn find_non_settling_solvers(
-        &self,
-        last_auctions_count: u32,
-        current_block: u64,
-    ) -> anyhow::Result<Vec<eth::Address>> {
-        let mut ex = self.postgres.pool.acquire().await.context("acquire")?;
-        let _timer = Metrics::get()
-            .database_queries
-            .with_label_values(&["find_non_settling_solvers"])
-            .start_timer();
-
-        Ok(database::solver_competition_v2::find_non_settling_solvers(
-            &mut ex,
-            last_auctions_count,
-            current_block,
-        )
-        .await
-        .context("failed to fetch non-settling solvers")?
-        .into_iter()
-        .map(|solver| eth::Address(solver.0.into()))
-        .collect())
-    }
-
-    /// Finds solvers that have a failure settling rate above the given
-    /// ratio. The current block is used to prevent selecting auctions with
-    /// deadline after the current block since they still can be settled.
-    pub async fn find_low_settling_solvers(
-        &self,
-        last_auctions_count: u32,
-        current_block: u64,
-        max_failure_rate: f64,
-        min_wins_threshold: u32,
-    ) -> anyhow::Result<Vec<eth::Address>> {
-        let mut ex = self.postgres.pool.acquire().await.context("acquire")?;
-        let _timer = Metrics::get()
-            .database_queries
-            .with_label_values(&["find_low_settling_solvers"])
-            .start_timer();
-
-        Ok(database::solver_competition_v2::find_low_settling_solvers(
-            &mut ex,
-            last_auctions_count,
-            current_block,
-            max_failure_rate,
-            min_wins_threshold,
-        )
-        .await
-        .context("solver_competition::find_low_settling_solvers")?
-        .into_iter()
-        .map(|solver| eth::Address(solver.0.into()))
-        .collect())
-    }
-
     pub async fn get_solver_winning_solutions(
         &self,
         auction_id: domain::auction::Id,
diff --git a/crates/autopilot/src/infra/solvers/dto/mod.rs b/crates/autopilot/src/infra/solvers/dto/mod.rs
index 5365700ce8..d3a156294c 100644
--- a/crates/autopilot/src/infra/solvers/dto/mod.rs
+++ b/crates/autopilot/src/infra/solvers/dto/mod.rs
@@ -1,7 +1,6 @@
 //! Types for communicating with drivers as defined in
 //! `crates/driver/openapi.yml`.
 
-pub mod notify;
 pub mod reveal;
 pub mod settle;
 pub mod solve;
diff --git a/crates/autopilot/src/infra/solvers/dto/notify.rs b/crates/autopilot/src/infra/solvers/dto/notify.rs
deleted file mode 100644
index 7a63a0bc4a..0000000000
--- a/crates/autopilot/src/infra/solvers/dto/notify.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use {
-    chrono::{DateTime, Utc},
-    serde::Serialize,
-    serde_with::serde_as,
-};
-
-#[serde_as]
-#[derive(Clone, Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub enum Request {
-    Banned {
-        reason: BanReason,
-        until: DateTime<Utc>,
-    },
-}
-
-#[serde_as]
-#[derive(Clone, Copy, Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub enum BanReason {
-    /// The driver won multiple consecutive auctions but never settled them.
-    UnsettledConsecutiveAuctions,
-    /// Driver's settle failure rate is above the threshold.
-    HighSettleFailureRate,
-}
-
-impl BanReason {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            BanReason::UnsettledConsecutiveAuctions => "non_settling",
-            BanReason::HighSettleFailureRate => "high_settle_failure_rate",
-        }
-    }
-}
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index 430ed70de3..38334631b8 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -1,12 +1,11 @@
 use {
     self::dto::{reveal, settle, solve},
-    crate::{arguments::Account, domain::eth, infra::solvers::dto::notify, util},
+    crate::{arguments::Account, domain::eth, util},
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
-    chrono::{DateTime, Utc},
     observe::tracing::tracing_headers,
     reqwest::{Client, StatusCode},
-    std::{sync::Arc, time::Duration},
+    std::time::Duration,
     thiserror::Error,
     tracing::instrument,
     url::Url,
@@ -25,7 +24,6 @@ pub struct Driver {
     // another driver solved with surplus exceeding this driver's surplus by `threshold`
     pub fairness_threshold: Option<eth::Ether>,
     pub submission_address: eth::Address,
-    pub requested_timeout_on_problems: bool,
     client: Client,
 }
 
@@ -44,7 +42,6 @@ impl Driver {
         name: String,
         fairness_threshold: Option<eth::Ether>,
         submission_account: Account,
-        requested_timeout_on_problems: bool,
     ) -> Result<Self, Error> {
         let submission_address = match submission_account {
             Account::Kms(key_id) => {
@@ -78,7 +75,6 @@ impl Driver {
                 .build()
                 .map_err(Error::FailedToBuildClient)?,
             submission_address,
-            requested_timeout_on_problems,
         })
     }
 
@@ -123,10 +119,6 @@ impl Driver {
         Ok(())
     }
 
-    pub async fn notify(&self, request: notify::Request) -> Result<()> {
-        self.request_response("notify", request).await
-    }
-
     async fn request_response<Response, Request>(
         &self,
         path: &str,
@@ -189,18 +181,3 @@ pub async fn response_body_with_size_limit(
     }
     Ok(bytes)
 }
-
-/// Notifies the non-settling driver in a fire-and-forget manner.
-pub fn notify_banned_solver(
-    non_settling_driver: Arc<Driver>,
-    reason: notify::BanReason,
-    banned_until: DateTime<Utc>,
-) {
-    let request = notify::Request::Banned {
-        reason,
-        until: banned_until,
-    };
-    tokio::spawn(async move {
-        let _ = non_settling_driver.notify(request).await;
-    });
-}
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 38ba0bd965..9784938a5f 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -15,7 +15,7 @@ use {
                 event_retriever::CoWSwapOnchainOrdersContract,
             },
         },
-        domain::{self, competition::SolverParticipationGuard},
+        domain,
         event_updater::EventUpdater,
         infra,
         maintenance::Maintenance,
@@ -430,9 +430,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         None
     };
 
-    let (competition_updates_sender, competition_updates_receiver) =
-        tokio::sync::mpsc::unbounded_channel();
-
     let persistence =
         infra::persistence::Persistence::new(args.s3.into().unwrap(), Arc::new(db_write.clone()))
             .instrument(info_span!("persistence_init"))
@@ -669,7 +666,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
                 driver.name.clone(),
                 driver.fairness_threshold.map(Into::into),
                 driver.submission_account,
-                driver.requested_timeout_on_problems,
             )
             .await
             .map(Arc::new)
@@ -683,20 +679,11 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .into_iter()
         .collect();
 
-    let solver_participation_guard = SolverParticipationGuard::new(
-        eth.clone(),
-        persistence.clone(),
-        competition_updates_receiver,
-        args.db_based_solver_participation_guard,
-        drivers.iter().cloned(),
-    );
-
     let run = RunLoop::new(
         run_loop_config,
         eth,
         persistence.clone(),
         drivers,
-        solver_participation_guard,
         solvable_orders_cache,
         trusted_tokens,
         run_loop::Probes {
@@ -704,7 +691,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
             startup,
         },
         Arc::new(maintenance),
-        competition_updates_sender,
     );
     run.run_forever(shutdown_controller).await;
 
@@ -737,7 +723,6 @@ async fn shadow_mode(args: Arguments) -> ! {
                 // this address for anything important so we
                 // can simply generate random addresses here.
                 Account::Address(Address::random()),
-                driver.requested_timeout_on_problems,
             )
             .await
             .map(Arc::new)
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 937f50000f..0b2ef60f33 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -8,7 +8,6 @@ use {
                 self,
                 Solution,
                 SolutionError,
-                SolverParticipationGuard,
                 Unscored,
                 winner_selection::{self, Ranking},
             },
@@ -78,14 +77,12 @@ pub struct RunLoop {
     eth: infra::Ethereum,
     persistence: infra::Persistence,
     drivers: Vec<Arc<infra::Driver>>,
-    solver_participation_guard: SolverParticipationGuard,
     solvable_orders_cache: Arc<SolvableOrdersCache>,
     trusted_tokens: AutoUpdatingTokenList,
     probes: Probes,
     /// Maintenance tasks that should run before every runloop to have
     /// the most recent data available.
     maintenance: Arc<Maintenance>,
-    competition_updates_sender: tokio::sync::mpsc::UnboundedSender<()>,
     winner_selection: winner_selection::Arbitrator,
     /// Notifier that wakes the main loop on new blocks or orders
     wake_notify: Arc<tokio::sync::Notify>,
@@ -98,12 +95,10 @@ impl RunLoop {
         eth: infra::Ethereum,
         persistence: infra::Persistence,
         drivers: Vec<Arc<infra::Driver>>,
-        solver_participation_guard: SolverParticipationGuard,
         solvable_orders_cache: Arc<SolvableOrdersCache>,
         trusted_tokens: AutoUpdatingTokenList,
         probes: Probes,
         maintenance: Arc<Maintenance>,
-        competition_updates_sender: tokio::sync::mpsc::UnboundedSender<()>,
     ) -> Self {
         let max_winners = config.max_winners_per_auction.get();
         let weth = eth.contracts().wrapped_native_token();
@@ -120,12 +115,10 @@ impl RunLoop {
             eth,
             persistence,
             drivers,
-            solver_participation_guard,
             solvable_orders_cache,
             trusted_tokens,
             probes,
             maintenance,
-            competition_updates_sender,
             winner_selection: winner_selection::Arbitrator::new(max_winners, weth),
             wake_notify,
         }
@@ -538,26 +531,6 @@ impl RunLoop {
             competition_table,
         };
 
-        let save_solutions = self
-            .persistence
-            .save_solutions(auction.id, ranking.all())
-            .map(|res| match res {
-                Ok(_) => {
-                    // Notify the solver participation guard that the proposed solutions have been
-                    // saved.
-                    if let Err(err) = self.competition_updates_sender.send(()) {
-                        tracing::error!(?err, "failed to notify solver participation guard");
-                    }
-                    Ok(())
-                }
-                Err(err) => {
-                    // Don't error if saving of auction and solution fails, until stable.
-                    // Various edge cases with JIT orders verifiable only in production.
-                    tracing::warn!(?err, "failed to save new competition data");
-                    Err(err.0.context("failed to save solutions"))
-                }
-            });
-
         tracing::trace!(?competition, "saving competition");
 
         futures::try_join!(
@@ -579,7 +552,6 @@ impl RunLoop {
             self.persistence
                 .store_fee_policies(auction.id, fee_policies)
                 .map_err(|e| e.context("failed to fee_policies")),
-            save_solutions
         )
         .inspect_err(|err| tracing::warn!(?err, "failed to write post processed data to DB"))?;
 
@@ -684,11 +656,14 @@ impl RunLoop {
     {
         let (can_participate, response) = {
             let driver = driver.clone();
-            let guard = self.solver_participation_guard.clone();
+            let eth = self.eth.clone();
             let mut handle = tokio::task::spawn(async move {
                 let fetch_response = driver.solve(request);
-                let check_allowed = guard.can_participate(&driver.submission_address);
-                tokio::join!(check_allowed, fetch_response)
+                let check_allowed = eth
+                    .contracts()
+                    .authenticator()
+                    .isSolver(driver.submission_address);
+                tokio::join!(check_allowed.call(), fetch_response)
             });
             tokio::time::timeout(self.config.solve_deadline, &mut handle)
                 .await
diff --git a/crates/database/src/solver_competition_v2.rs b/crates/database/src/solver_competition_v2.rs
index 11aefbcdc9..046090b1e9 100644
--- a/crates/database/src/solver_competition_v2.rs
+++ b/crates/database/src/solver_competition_v2.rs
@@ -209,115 +209,6 @@ pub async fn fetch_auction_participants(
     sqlx::query_as(QUERY).bind(auction_id).fetch_all(ex).await
 }
 
-/// Identifies solvers that have consistently failed to settle solutions in
-/// recent N auctions.
-///
-/// 1. Retrieves `last_auctions_count` most recent auctions already ended
-///    auctions by filtering them by their deadlines.
-/// 2. Identifies solvers who won these auctions but did not submit a successful
-///    settlement.
-/// 3. Counts how often each solver appears in these unsuccessful cases.
-/// 4. Determines the total number of auctions considered.
-/// 5. Flags solvers who failed to settle in all of these auctions.
-/// 6. Returns a list of solvers that have consistently failed to settle
-///    solutions.
-#[instrument(skip_all)]
-pub async fn find_non_settling_solvers(
-    ex: &mut PgConnection,
-    last_auctions_count: u32,
-    current_block: u64,
-) -> Result<Vec<Address>, sqlx::Error> {
-    const QUERY: &str = r#"
-WITH
-    last_auctions AS (
-        SELECT ps.auction_id, ps.solver
-        FROM (
-            SELECT DISTINCT ca.id AS auction_id
-            FROM competition_auctions ca
-            WHERE ca.deadline <= $1
-            ORDER BY ca.id DESC
-            LIMIT $2
-        ) latest_auctions
-        JOIN proposed_solutions ps ON ps.auction_id = latest_auctions.auction_id
-        WHERE ps.is_winner = true
-    ),
-    unsuccessful_solvers AS (
-        SELECT la.auction_id, la.solver
-        FROM last_auctions la
-        LEFT JOIN settlements s
-        ON la.auction_id = s.auction_id AND la.solver = s.solver
-        WHERE s.auction_id IS NULL
-    ),
-    solver_appearance_count AS (
-        SELECT solver, COUNT(DISTINCT auction_id) AS appearance_count
-        FROM unsuccessful_solvers
-        GROUP BY solver
-    ),
-    auction_count AS (
-        SELECT COUNT(DISTINCT auction_id) AS total_auctions
-        FROM last_auctions
-    ),
-    consistent_solvers AS (
-        SELECT sa.solver
-        FROM solver_appearance_count sa, auction_count ac
-        WHERE sa.appearance_count = ac.total_auctions
-    )
-SELECT DISTINCT solver
-FROM consistent_solvers;
-    "#;
-
-    sqlx::query_scalar(QUERY)
-        .bind(sqlx::types::BigDecimal::from(current_block))
-        .bind(i64::from(last_auctions_count))
-        .fetch_all(ex)
-        .await
-}
-
-#[instrument(skip_all)]
-pub async fn find_low_settling_solvers(
-    ex: &mut PgConnection,
-    last_auctions_count: u32,
-    current_block: u64,
-    max_failure_rate: f64,
-    min_wins_threshold: u32,
-) -> Result<Vec<Address>, sqlx::Error> {
-    const QUERY: &str = r#"
-WITH
-    last_auctions AS (
-        SELECT ps.auction_id, ps.solver
-        FROM (
-            SELECT DISTINCT ca.id AS auction_id
-            FROM competition_auctions ca
-            WHERE ca.deadline <= $1
-            ORDER BY ca.id DESC
-            LIMIT $2
-        ) latest_auctions
-        JOIN proposed_solutions ps ON ps.auction_id = latest_auctions.auction_id
-        WHERE ps.is_winner = true
-    ),
-    solver_settlement_counts AS (
-        SELECT la.solver,
-               COUNT(DISTINCT la.auction_id) AS total_wins,
-               COUNT(DISTINCT s.auction_id) AS total_settlements
-        FROM last_auctions la
-        LEFT JOIN settlements s
-        ON la.auction_id = s.auction_id AND la.solver = s.solver
-        GROUP BY la.solver
-    )
-SELECT solver
-FROM solver_settlement_counts
-WHERE total_wins >= $3 AND (1 - (total_settlements::decimal / NULLIF(total_wins, 0))) > $4;
-    "#;
-
-    sqlx::query_scalar(QUERY)
-        .bind(sqlx::types::BigDecimal::from(current_block))
-        .bind(i64::from(last_auctions_count))
-        .bind(i64::from(min_wins_threshold))
-        .bind(max_failure_rate)
-        .fetch_all(ex)
-        .await
-}
-
 #[derive(Clone, Debug, PartialEq, Default)]
 pub struct Solution {
     // Unique Id generated by the autopilot to uniquely identify the solution within Auction
@@ -702,351 +593,6 @@ mod tests {
         assert!(fetched_solutions[2].orders.len() == 3);
     }
 
-    #[tokio::test]
-    #[ignore]
-    async fn postgres_non_settling_solvers_roundtrip() {
-        let mut db = PgConnection::connect("postgresql://").await.unwrap();
-        let mut db = db.begin().await.unwrap();
-        crate::clear_DANGER_(&mut db).await.unwrap();
-
-        let non_settling_solver = ByteArray([1u8; 20]);
-
-        let mut solution_uid = 0;
-        let deadline_block = 100u64;
-        let last_auctions_count = 3i64;
-        // competition_auctions
-        // Insert auctions within the deadline
-        for auction_id in 1..=4 {
-            let auction = auction::Auction {
-                id: auction_id,
-                block: auction_id,
-                deadline: i64::try_from(deadline_block).unwrap(),
-                order_uids: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-                surplus_capturing_jit_order_owners: Default::default(),
-            };
-            auction::save(&mut db, auction).await.unwrap();
-        }
-
-        // Insert auctions outside the deadline
-        for auction_id in 5..=6 {
-            let auction = auction::Auction {
-                id: auction_id,
-                block: auction_id,
-                deadline: i64::try_from(deadline_block).unwrap() + auction_id,
-                order_uids: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-                surplus_capturing_jit_order_owners: Default::default(),
-            };
-            auction::save(&mut db, auction).await.unwrap();
-        }
-
-        // proposed_solutions
-        // Non-settling solver wins `last_auctions_count` auctions within the deadline
-        for auction_id in 2..=4 {
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: auction_id,
-                id: solution_uid.into(),
-                solver: non_settling_solver,
-                is_winner: true,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-
-        // Another non-settling solver wins not all the auctions within the deadline
-        for auction_id in 2..=4 {
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: auction_id,
-                id: solution_uid.into(),
-                solver: ByteArray([2u8; 20]),
-                is_winner: auction_id != 2,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-
-        // One more non-settling solver has `last_auctions_count` winning auctions but
-        // not consecutive
-        for auction_id in 1..=4 {
-            // Break the sequence
-            if auction_id == 2 {
-                continue;
-            }
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: auction_id,
-                id: solution_uid.into(),
-                solver: ByteArray([3u8; 20]),
-                is_winner: true,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-
-        // One more non-settling solver has `last_auctions_count` winning auctions but
-        // some of them are outside the deadline
-        for auction_id in 3..=5 {
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: auction_id,
-                id: solution_uid.into(),
-                solver: ByteArray([4u8; 20]),
-                is_winner: true,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-
-        // Verify only the non-settling solver is returned
-        let result = find_non_settling_solvers(
-            &mut db,
-            u32::try_from(last_auctions_count).unwrap(),
-            deadline_block,
-        )
-        .await
-        .unwrap();
-        assert_eq!(result, vec![non_settling_solver]);
-
-        // Non-settling solver settles one of the auctions
-        let event = EventIndex {
-            block_number: 4,
-            log_index: 0,
-        };
-        let settlement = Settlement {
-            solver: non_settling_solver,
-            transaction_hash: ByteArray([0u8; 32]),
-        };
-        events::insert_settlement(&mut db, &event, &settlement)
-            .await
-            .unwrap();
-
-        // The same result until the auction_id is updated in the settlements table
-        let result = find_non_settling_solvers(
-            &mut db,
-            u32::try_from(last_auctions_count).unwrap(),
-            deadline_block,
-        )
-        .await
-        .unwrap();
-        assert_eq!(result, vec![non_settling_solver]);
-
-        settlements::update_settlement_auction(&mut db, 4, 0, 4)
-            .await
-            .unwrap();
-
-        let result = find_non_settling_solvers(
-            &mut db,
-            u32::try_from(last_auctions_count).unwrap(),
-            deadline_block,
-        )
-        .await
-        .unwrap();
-        assert!(result.is_empty());
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn postgres_low_settling_solvers_roundtrip() {
-        let mut db = PgConnection::connect("postgresql://").await.unwrap();
-        let mut db = db.begin().await.unwrap();
-        crate::clear_DANGER_(&mut db).await.unwrap();
-
-        let deadline_block = 2u64;
-        let last_auctions_count = 100i64;
-        let max_failure_ratio = 0.6;
-        let min_wins_threshold = 2;
-        let mut solution_uid = 0;
-
-        for auction_id in 1..=10 {
-            let auction = auction::Auction {
-                id: auction_id,
-                block: auction_id,
-                deadline: i64::try_from(deadline_block).unwrap(),
-                order_uids: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-                surplus_capturing_jit_order_owners: Default::default(),
-            };
-            auction::save(&mut db, auction).await.unwrap();
-        }
-
-        // Settles only 20% of won auctions
-        let low_settling_solver = ByteArray([1u8; 20]);
-        for auction_id in 1..=5 {
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: solution_uid,
-                id: auction_id.into(),
-                solver: low_settling_solver,
-                is_winner: true,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-        let event = EventIndex {
-            block_number: 1,
-            log_index: 0,
-        };
-        let settlement = Settlement {
-            solver: low_settling_solver,
-            transaction_hash: ByteArray([0u8; 32]),
-        };
-        events::insert_settlement(&mut db, &event, &settlement)
-            .await
-            .unwrap();
-        settlements::update_settlement_auction(&mut db, 1, 0, 1)
-            .await
-            .unwrap();
-
-        // Settles 0% of won auctions
-        let non_settling_solver = ByteArray([2u8; 20]);
-        for auction_id in 1..=5 {
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: solution_uid,
-                id: auction_id.into(),
-                solver: non_settling_solver,
-                is_winner: true,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-
-        // Settled 40% of won auctions
-        let settling_solver = ByteArray([3u8; 20]);
-        for auction_id in 1..=5 {
-            solution_uid += 1;
-            let solutions = vec![Solution {
-                uid: solution_uid,
-                id: auction_id.into(),
-                solver: settling_solver,
-                is_winner: true,
-                filtered_out: false,
-                score: Default::default(),
-                orders: Default::default(),
-                price_tokens: Default::default(),
-                price_values: Default::default(),
-            }];
-            save_solutions(&mut db, auction_id, &solutions)
-                .await
-                .unwrap();
-        }
-        for auction_id in 2..=3 {
-            let event = EventIndex {
-                block_number: auction_id,
-                log_index: 0,
-            };
-            let settlement = Settlement {
-                solver: settling_solver,
-                transaction_hash: ByteArray([u8::try_from(auction_id).unwrap(); 32]),
-            };
-            events::insert_settlement(&mut db, &event, &settlement)
-                .await
-                .unwrap();
-            settlements::update_settlement_auction(&mut db, auction_id, 0, auction_id)
-                .await
-                .unwrap();
-        }
-
-        let result = find_low_settling_solvers(
-            &mut db,
-            u32::try_from(last_auctions_count).unwrap(),
-            deadline_block,
-            max_failure_ratio,
-            min_wins_threshold,
-        )
-        .await
-        .unwrap();
-
-        assert_eq!(result.len(), 2);
-        assert!(result.contains(&low_settling_solver));
-        assert!(result.contains(&non_settling_solver));
-
-        // Both won only 5 auctions. With threshold 6, no solver should be returned.
-        assert!(
-            find_low_settling_solvers(
-                &mut db,
-                u32::try_from(last_auctions_count).unwrap(),
-                deadline_block,
-                max_failure_ratio,
-                6,
-            )
-            .await
-            .unwrap()
-            .is_empty()
-        );
-
-        // Low settling solver settles another auction
-        let event = EventIndex {
-            block_number: 2,
-            log_index: 1,
-        };
-        let settlement = Settlement {
-            solver: low_settling_solver,
-            transaction_hash: ByteArray([2u8; 32]),
-        };
-        events::insert_settlement(&mut db, &event, &settlement)
-            .await
-            .unwrap();
-        settlements::update_settlement_auction(&mut db, 2, 1, 2)
-            .await
-            .unwrap();
-
-        let result = find_low_settling_solvers(
-            &mut db,
-            u32::try_from(last_auctions_count).unwrap(),
-            deadline_block,
-            max_failure_ratio,
-            min_wins_threshold,
-        )
-        .await
-        .unwrap();
-
-        // Now, it is not a low-settling solver anymore
-        assert_eq!(result, vec![non_settling_solver]);
-    }
-
     #[tokio::test]
     #[ignore]
     async fn postgres_load_by_tx_hash() {
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index afd3f27578..38d106a258 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -96,7 +96,6 @@ impl Api {
             let router = routes::solve(router);
             let router = routes::reveal(router);
             let router = routes::settle(router);
-            let router = routes::notify(router);
 
             let bad_order_config = solver.bad_order_detection();
             let mut bad_tokens =
diff --git a/crates/driver/src/infra/api/routes/mod.rs b/crates/driver/src/infra/api/routes/mod.rs
index dcd4afffc8..9ea3bdf93f 100644
--- a/crates/driver/src/infra/api/routes/mod.rs
+++ b/crates/driver/src/infra/api/routes/mod.rs
@@ -2,7 +2,6 @@ mod gasprice;
 mod healthz;
 mod info;
 mod metrics;
-mod notify;
 mod quote;
 mod reveal;
 mod settle;
@@ -13,7 +12,6 @@ pub(super) use {
     healthz::healthz,
     info::info,
     metrics::metrics,
-    notify::notify,
     quote::{OrderError, quote},
     reveal::reveal,
     settle::settle,
diff --git a/crates/driver/src/infra/api/routes/notify/dto/mod.rs b/crates/driver/src/infra/api/routes/notify/dto/mod.rs
deleted file mode 100644
index 9a24eedbc1..0000000000
--- a/crates/driver/src/infra/api/routes/notify/dto/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod notify_request;
-
-pub use notify_request::NotifyRequest;
diff --git a/crates/driver/src/infra/api/routes/notify/dto/notify_request.rs b/crates/driver/src/infra/api/routes/notify/dto/notify_request.rs
deleted file mode 100644
index c812453e32..0000000000
--- a/crates/driver/src/infra/api/routes/notify/dto/notify_request.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use {
-    crate::infra::notify,
-    chrono::{DateTime, Utc},
-    serde::Deserialize,
-    serde_with::serde_as,
-};
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum NotifyRequest {
-    Banned {
-        reason: BanReason,
-        until: DateTime<Utc>,
-    },
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum BanReason {
-    /// The driver won multiple consecutive auctions but never settled them.
-    UnsettledConsecutiveAuctions,
-    /// Driver's settle failure rate is above the threshold.
-    HighSettleFailureRate,
-}
-
-impl From<NotifyRequest> for notify::Kind {
-    fn from(value: NotifyRequest) -> Self {
-        match value {
-            NotifyRequest::Banned { reason, until } => notify::Kind::Banned {
-                reason: match reason {
-                    BanReason::UnsettledConsecutiveAuctions => {
-                        notify::BanReason::UnsettledConsecutiveAuctions
-                    }
-                    BanReason::HighSettleFailureRate => notify::BanReason::HighSettleFailureRate,
-                },
-                until,
-            },
-        }
-    }
-}
diff --git a/crates/driver/src/infra/api/routes/notify/mod.rs b/crates/driver/src/infra/api/routes/notify/mod.rs
deleted file mode 100644
index 3e952a6c6c..0000000000
--- a/crates/driver/src/infra/api/routes/notify/mod.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-mod dto;
-
-use crate::infra::api::{Error, State};
-
-pub(in crate::infra::api) fn notify(router: axum::Router<State>) -> axum::Router<State> {
-    router.route("/notify", axum::routing::post(route))
-}
-
-async fn route(
-    state: axum::extract::State<State>,
-    req: axum::Json<dto::NotifyRequest>,
-) -> Result<hyper::StatusCode, (hyper::StatusCode, axum::Json<Error>)> {
-    let solver = &state.solver().name().0;
-    tracing::debug!(?req, ?solver, "received a notification");
-    state.solver().notify(None, None, req.0.into());
-    Ok(hyper::StatusCode::OK)
-}
diff --git a/crates/driver/src/infra/notify/mod.rs b/crates/driver/src/infra/notify/mod.rs
index 14187231b8..321335d8c8 100644
--- a/crates/driver/src/infra/notify/mod.rs
+++ b/crates/driver/src/infra/notify/mod.rs
@@ -6,14 +6,7 @@ use {
 pub mod liquidity_sources;
 mod notification;
 
-pub use notification::{
-    BanReason,
-    Kind,
-    Notification,
-    ScoreKind,
-    Settlement,
-    SimulationSucceededAtLeastOnce,
-};
+pub use notification::{Kind, Notification, ScoreKind, Settlement, SimulationSucceededAtLeastOnce};
 use {
     super::simulator,
     crate::domain::{eth, mempools::Error},
diff --git a/crates/driver/src/infra/notify/notification.rs b/crates/driver/src/infra/notify/notification.rs
index 265bcab5b2..c8d4e48f21 100644
--- a/crates/driver/src/infra/notify/notification.rs
+++ b/crates/driver/src/infra/notify/notification.rs
@@ -3,7 +3,6 @@ use {
         competition::{auction, solution},
         eth::{self, Ether, TokenAddress},
     },
-    chrono::{DateTime, Utc},
     std::collections::BTreeSet,
 };
 
@@ -46,11 +45,6 @@ pub enum Kind {
     DriverError(String),
     /// On-chain solution postprocessing timed out.
     PostprocessingTimedOut,
-    /// The solver has been banned for a specific reason.
-    Banned {
-        reason: BanReason,
-        until: DateTime<Utc>,
-    },
     /// The solver sent an invalid request format
     DeserializationError(String),
 }
@@ -66,14 +60,6 @@ pub enum ScoreKind {
     MissingPrice(TokenAddress),
 }
 
-#[derive(Debug)]
-pub enum BanReason {
-    /// The driver won multiple consecutive auctions but never settled them.
-    UnsettledConsecutiveAuctions,
-    /// Driver's settle failure rate is above the threshold.
-    HighSettleFailureRate,
-}
-
 #[derive(Debug)]
 pub enum Settlement {
     /// Winning solver settled successfully transaction onchain.
diff --git a/crates/driver/src/infra/solver/dto/notification.rs b/crates/driver/src/infra/solver/dto/notification.rs
index 40f1be47a4..e06a344024 100644
--- a/crates/driver/src/infra/solver/dto/notification.rs
+++ b/crates/driver/src/infra/solver/dto/notification.rs
@@ -58,17 +58,6 @@ pub fn new(
             notify::Kind::PostprocessingTimedOut => {
                 solvers_dto::notification::Kind::PostprocessingTimedOut
             }
-            notify::Kind::Banned { reason, until } => solvers_dto::notification::Kind::Banned {
-                reason: match reason {
-                    notify::BanReason::UnsettledConsecutiveAuctions => {
-                        solvers_dto::notification::BanReason::UnsettledConsecutiveAuctions
-                    }
-                    notify::BanReason::HighSettleFailureRate => {
-                        solvers_dto::notification::BanReason::HighSettleFailureRate
-                    }
-                },
-                until,
-            },
             notify::Kind::DeserializationError(reason) => {
                 solvers_dto::notification::Kind::DeserializationError { reason }
             }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index a56ff2120a..023e36fe40 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -204,8 +204,6 @@ impl<'a> Services<'a> {
 
         let args = [
             "autopilot".to_string(),
-            "--non-settling-solvers-blacklisting-enabled=false".to_string(),
-            "--low-settling-solvers-blacklisting-enabled=false".to_string(),
             "--max-run-loop-delay=100ms".to_string(),
             "--run-loop-native-price-timeout=500ms".to_string(),
             format!("--ethflow-contracts={ethflow_contracts}"),
diff --git a/crates/e2e/tests/e2e/main.rs b/crates/e2e/tests/e2e/main.rs
index d2b5f840a4..738e30317b 100644
--- a/crates/e2e/tests/e2e/main.rs
+++ b/crates/e2e/tests/e2e/main.rs
@@ -35,7 +35,6 @@ mod refunder;
 mod replace_order;
 mod smart_contract_orders;
 mod solver_competition;
-mod solver_participation_guard;
 mod submission;
 mod token_metadata;
 mod tracking_insufficient_funds;
diff --git a/crates/e2e/tests/e2e/solver_participation_guard.rs b/crates/e2e/tests/e2e/solver_participation_guard.rs
deleted file mode 100644
index b5a16e2ec9..0000000000
--- a/crates/e2e/tests/e2e/solver_participation_guard.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-use {
-    alloy::primitives::{Address, U256},
-    e2e::setup::{
-        Db,
-        ExtraServiceArgs,
-        MintableToken,
-        OnchainComponents,
-        Services,
-        TIMEOUT,
-        TestAccount,
-        run_test,
-        wait_for_condition,
-    },
-    ethrpc::{Web3, alloy::CallBuilderExt},
-    model::{
-        order::{OrderClass, OrderCreation, OrderKind},
-        signature::EcdsaSigningScheme,
-    },
-    number::units::EthUnit,
-    sqlx::Row,
-    std::time::Instant,
-};
-
-#[tokio::test]
-#[ignore]
-async fn local_node_non_settling_solver() {
-    run_test(non_settling_solver).await;
-}
-
-#[tokio::test]
-#[ignore]
-async fn local_node_low_settling_solver() {
-    run_test(low_settling_solver).await;
-}
-
-#[tokio::test]
-#[ignore]
-async fn local_node_not_allowed_solver() {
-    run_test(not_allowed_solver).await;
-}
-
-async fn non_settling_solver(web3: Web3) {
-    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
-
-    let [solver, solver_b] = onchain.make_solvers(1u64.eth()).await;
-    let (trader_a, token_a, token_b) = setup(&mut onchain, &solver).await;
-
-    let services = Services::new(&onchain).await;
-    let args = ExtraServiceArgs {
-        autopilot: vec![
-            "--non-settling-solvers-blacklisting-enabled=true".to_string(),
-            "--low-settling-solvers-blacklisting-enabled=true".to_string(),
-            // The solver gets banned for 40s.
-            "--solver-blacklist-cache-ttl=40s".to_string(),
-        ],
-        ..Default::default()
-    };
-    services.start_protocol_with_args(args, solver).await;
-
-    // Amount of order should be more or equal the non-settling threshold, which is
-    // 3.
-    for _ in 0..4 {
-        execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-            .await
-            .unwrap();
-    }
-
-    let pool = services.db();
-    let settled_auction_ids = fetch_last_settled_auction_ids(pool).await;
-    assert_eq!(settled_auction_ids.len(), 4);
-    // Build 5 blocks to make sure the submission deadline is passed, which is 5 by
-    // default.
-    for _ in 0..5 {
-        onchain.mint_block().await;
-    }
-
-    // Simulate failed settlements by replacing the solver for the last 3
-    // settlements.
-    let last_auctions = settled_auction_ids
-        .iter()
-        .take(3)
-        .cloned()
-        .collect::<Vec<_>>();
-    replace_solver_for_auction_ids(pool, &last_auctions, &solver_b.address()).await;
-    // The competition still passes since the stats are updated only after a new
-    // solution from anyone is received and stored.
-    let now = Instant::now();
-    assert!(
-        execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-            .await
-            .is_ok()
-    );
-    // Now, the stat is updated, and the solver is banned.
-    assert!(
-        execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-            .await
-            .is_err()
-    );
-
-    // 40 seconds is the cache TTL, and 5 seconds is added to compensate any
-    // possible delays.
-    let sleep_timeout_secs = 40 - now.elapsed().as_secs() + 5;
-    println!(
-        "Sleeping for {sleep_timeout_secs} seconds to reset the solver participation guard cache"
-    );
-    tokio::time::sleep(tokio::time::Duration::from_secs(sleep_timeout_secs)).await;
-    // The cache is reset, and the solver is allowed to participate again.
-    execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-        .await
-        .unwrap();
-}
-
-async fn low_settling_solver(web3: Web3) {
-    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
-
-    let [solver, solver_b] = onchain.make_solvers(1u64.eth()).await;
-    let (trader_a, token_a, token_b) = setup(&mut onchain, &solver).await;
-
-    let services = Services::new(&onchain).await;
-    let args = ExtraServiceArgs {
-        autopilot: vec![
-            "--non-settling-solvers-blacklisting-enabled=true".to_string(),
-            "--low-settling-solvers-blacklisting-enabled=true".to_string(),
-            // The solver gets banned for 40s.
-            "--solver-blacklist-cache-ttl=40s".to_string(),
-            // The solver is banned if the failure settlement rate is above 55%.
-            "--solver-max-settlement-failure-rate=0.55".to_string(),
-        ],
-        ..Default::default()
-    };
-    services.start_protocol_with_args(args, solver).await;
-
-    // Create 5 orders, to easily test 60% of them failing, which is 3/5.
-    for _ in 0..5 {
-        execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-            .await
-            .unwrap();
-    }
-
-    let pool = services.db();
-    let settled_auction_ids = fetch_last_settled_auction_ids(pool).await;
-    assert_eq!(settled_auction_ids.len(), 5);
-    // Build 5 blocks to make sure the submission deadline is passed, which is 5 by
-    // default.
-    for _ in 0..5 {
-        onchain.mint_block().await;
-    }
-
-    // Simulate low settling rate by replacing the solver for the 60% of the
-    // settlements.
-    let random_auctions = settled_auction_ids
-        .iter()
-        .enumerate()
-        .filter_map(|(i, id)| (i % 2 == 0).then_some(*id))
-        .collect::<Vec<_>>();
-    replace_solver_for_auction_ids(pool, &random_auctions, &solver_b.address()).await;
-    // The competition still passes since the stats are updated only after a new
-    // solution from anyone is received and stored.
-    let now = Instant::now();
-    execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-        .await
-        .unwrap();
-    // Now, the stat is updated, and the solver is banned.
-    execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-        .await
-        .unwrap_err();
-
-    // 40 seconds is the cache TTL, and 5 seconds is added to compensate any
-    // possible delays.
-    let sleep_timeout_secs = 40 - now.elapsed().as_secs() + 5;
-    println!(
-        "Sleeping for {sleep_timeout_secs} seconds to reset the solver participation guard cache"
-    );
-    tokio::time::sleep(tokio::time::Duration::from_secs(sleep_timeout_secs)).await;
-    // The cache is reset, and the solver is allowed to participate again.
-    execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-        .await
-        .unwrap();
-}
-
-async fn not_allowed_solver(web3: Web3) {
-    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
-
-    let [solver] = onchain.make_solvers(1u64.eth()).await;
-    let (trader_a, token_a, token_b) = setup(&mut onchain, &solver).await;
-
-    let solver_address = solver.address();
-    let services = Services::new(&onchain).await;
-    services.start_protocol(solver).await;
-
-    execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-        .await
-        .unwrap();
-
-    // Ban the solver
-    onchain
-        .contracts()
-        .gp_authenticator
-        .removeSolver(solver_address)
-        .send_and_watch()
-        .await
-        .unwrap();
-
-    assert!(
-        execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-            .await
-            .is_err()
-    );
-
-    // Unban the solver
-    onchain
-        .contracts()
-        .gp_authenticator
-        .addSolver(solver_address)
-        .send_and_watch()
-        .await
-        .unwrap();
-
-    execute_order(&onchain, &trader_a, &token_a, &token_b, &services)
-        .await
-        .unwrap();
-}
-
-async fn setup(
-    onchain: &mut OnchainComponents,
-    solver: &TestAccount,
-) -> (TestAccount, MintableToken, MintableToken) {
-    let [trader_a] = onchain.make_accounts(1u64.eth()).await;
-    let [token_a, token_b] = onchain
-        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
-        .await;
-
-    // Fund trader accounts
-    token_a.mint(trader_a.address(), 1000u64.eth()).await;
-
-    // Create and fund Uniswap pool
-    token_a.mint(solver.address(), 1000u64.eth()).await;
-    token_b.mint(solver.address(), 1000u64.eth()).await;
-    onchain
-        .contracts()
-        .uniswap_v2_factory
-        .createPair(*token_a.address(), *token_b.address())
-        .from(solver.address())
-        .send_and_watch()
-        .await
-        .unwrap();
-
-    token_a
-        .approve(
-            *onchain.contracts().uniswap_v2_router.address(),
-            1000u64.eth(),
-        )
-        .from(solver.address())
-        .send_and_watch()
-        .await
-        .unwrap();
-
-    token_b
-        .approve(
-            *onchain.contracts().uniswap_v2_router.address(),
-            1000u64.eth(),
-        )
-        .from(solver.address())
-        .send_and_watch()
-        .await
-        .unwrap();
-    onchain
-        .contracts()
-        .uniswap_v2_router
-        .addLiquidity(
-            *token_a.address(),
-            *token_b.address(),
-            1000u64.eth(),
-            1000u64.eth(),
-            U256::ZERO,
-            U256::ZERO,
-            solver.address(),
-            U256::MAX,
-        )
-        .from(solver.address())
-        .send_and_watch()
-        .await
-        .unwrap();
-
-    // Approve GPv2 for trading
-
-    token_a
-        .approve(onchain.contracts().allowance, 1000u64.eth())
-        .from(trader_a.address())
-        .send_and_watch()
-        .await
-        .unwrap();
-
-    (trader_a, token_a, token_b)
-}
-
-async fn replace_solver_for_auction_ids(pool: &Db, auction_ids: &[i64], solver: &Address) {
-    for auction_id in auction_ids {
-        sqlx::query("UPDATE settlements SET solver = $1 WHERE auction_id = $2")
-            .bind(solver.as_slice())
-            .bind(auction_id)
-            .execute(pool)
-            .await
-            .unwrap();
-    }
-}
-
-async fn fetch_last_settled_auction_ids(pool: &Db) -> Vec<i64> {
-    sqlx::query("SELECT auction_id FROM settlements ORDER BY auction_id DESC")
-        .fetch_all(pool)
-        .await
-        .unwrap()
-        .into_iter()
-        .filter_map(|row| {
-            let auction_id: Option<i64> = row.try_get(0).unwrap();
-            auction_id
-        })
-        .collect()
-}
-
-async fn execute_order(
-    onchain: &OnchainComponents,
-    trader_a: &TestAccount,
-    token_a: &MintableToken,
-    token_b: &MintableToken,
-    services: &Services<'_>,
-) -> anyhow::Result<()> {
-    let order = OrderCreation {
-        sell_token: *token_a.address(),
-        sell_amount: 10u64.eth(),
-        buy_token: *token_b.address(),
-        buy_amount: 5u64.eth(),
-        valid_to: model::time::now_in_epoch_seconds() + 300,
-        kind: OrderKind::Sell,
-        ..Default::default()
-    }
-    .sign(
-        EcdsaSigningScheme::Eip712,
-        &onchain.contracts().domain_separator,
-        &trader_a.signer,
-    );
-    let balance_before = token_b.balanceOf(trader_a.address()).call().await.unwrap();
-    let order_id = services.create_order(&order).await.unwrap();
-    onchain.mint_block().await;
-    let limit_order = services.get_order(&order_id).await.unwrap();
-    assert_eq!(limit_order.metadata.class, OrderClass::Limit);
-    let auction_ids_before = fetch_last_settled_auction_ids(services.db()).await.len();
-
-    // Drive solution
-    tracing::info!("Waiting for trade.");
-    wait_for_condition(TIMEOUT, || async {
-        let balance_after = token_b.balanceOf(trader_a.address()).call().await.unwrap();
-        let balance_changes = balance_after.checked_sub(balance_before).unwrap() >= 5u64.eth();
-        let auction_ids_after =
-            fetch_last_settled_auction_ids(services.db()).await.len() > auction_ids_before;
-        balance_changes && auction_ids_after
-    })
-    .await
-}
diff --git a/crates/solvers-dto/src/notification.rs b/crates/solvers-dto/src/notification.rs
index b63e2a8fa4..7abdb0b53f 100644
--- a/crates/solvers-dto/src/notification.rs
+++ b/crates/solvers-dto/src/notification.rs
@@ -4,7 +4,6 @@ use {
         primitives::{Address, B256, U256},
         rpc::types::AccessList,
     },
-    chrono::{DateTime, Utc},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::{DisplayFromStr, serde_as},
@@ -69,10 +68,6 @@ pub enum Kind {
     Expired,
     Fail,
     PostprocessingTimedOut,
-    Banned {
-        reason: BanReason,
-        until: DateTime<Utc>,
-    },
     DeserializationError {
         reason: String,
     },
@@ -92,10 +87,3 @@ pub struct Tx {
     pub value: U256,
     pub access_list: AccessList,
 }
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase", tag = "reason")]
-pub enum BanReason {
-    UnsettledConsecutiveAuctions,
-    HighSettleFailureRate,
-}

From 64cd00bab43619b96c3a02b561e28f6c42186c04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Fri, 30 Jan 2026 13:04:10 +0000
Subject: [PATCH 021/219] [TRIVIAL] Fix playground configs (#4108)

# Description
Estimators were expecting different strings and the tx gas was missing
from the driver

# Changes

- [ ] Remove Native from gas estimators
- [ ] Add "Driver" to the native price estimators
- [ ] Add tx-gas-limit to the driver config

## How to test
Run docker compose and check if autopilot, orderbook and driver are up

Co-authored-by: Claude <noreply@anthropic.com>
---
 playground/docker-compose.fork.yml            | 4 ++--
 playground/docker-compose.non-interactive.yml | 6 +++---
 playground/driver.toml                        | 2 ++
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/playground/docker-compose.fork.yml b/playground/docker-compose.fork.yml
index d697c061ba..b0c89b63f0 100644
--- a/playground/docker-compose.fork.yml
+++ b/playground/docker-compose.fork.yml
@@ -80,7 +80,7 @@ services:
       - ENABLE_EIP1271_ORDERS=true
       - PRICE_ESTIMATORS=None
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=baseline|http://driver/baseline
+      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
       - DRIVERS=baseline|http://driver/baseline
       - BIND_ADDRESS=0.0.0.0:80
       - CHAIN_ID=$CHAIN
@@ -114,7 +114,7 @@ services:
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
       - SETTLE_INTERVAL=15s
-      - GAS_ESTIMATORS=Native,Web3
+      - GAS_ESTIMATORS=Web3
       - PRICE_ESTIMATORS=None
       - BLOCK_STREAM_POLL_INTERVAL=1s
       - NATIVE_PRICE_CACHE_MAX_UPDATE_SIZE=100
diff --git a/playground/docker-compose.non-interactive.yml b/playground/docker-compose.non-interactive.yml
index f56f605072..c9d5fca62f 100644
--- a/playground/docker-compose.non-interactive.yml
+++ b/playground/docker-compose.non-interactive.yml
@@ -82,7 +82,7 @@ services:
       - ENABLE_EIP1271_ORDERS=true
       - PRICE_ESTIMATORS=None
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=baseline|http://driver/baseline
+      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
       - DRIVERS=baseline|http://driver/baseline
       - BIND_ADDRESS=0.0.0.0:80
       - CHAIN_ID=$CHAIN
@@ -115,7 +115,7 @@ services:
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
       - SETTLE_INTERVAL=15s
-      - GAS_ESTIMATORS=Native,Web3
+      - GAS_ESTIMATORS=Web3
       - PRICE_ESTIMATORS=None
       - NATIVE_PRICE_ESTIMATORS=baseline
       - BLOCK_STREAM_POLL_INTERVAL=1s
@@ -123,7 +123,7 @@ services:
       - NATIVE_PRICE_CACHE_MAX_AGE=20m
       - SOLVER_TIME_LIMIT=5
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=baseline|http://driver/baseline
+      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
       - DRIVERS=baseline|http://driver/baseline|0xa0Ee7A142d267C1f36714E4a8F75612F20a79720
       - SKIP_EVENT_SYNC=true
       - BASELINE_SOURCES=None
diff --git a/playground/driver.toml b/playground/driver.toml
index a5933cde5f..9099b173ae 100644
--- a/playground/driver.toml
+++ b/playground/driver.toml
@@ -1,3 +1,5 @@
+tx-gas-limit = "45000000"
+
 [[solver]]
 name = "baseline" # Arbitrary name given to this solver, must be unique
 endpoint = "http://baseline"

From 8dd0fddba728888b79d4045bc708698d4d43880a Mon Sep 17 00:00:00 2001
From: MarcusWentz <52706599+MarcusWentz@users.noreply.github.com>
Date: Fri, 30 Jan 2026 10:30:34 -0500
Subject: [PATCH 022/219] Update playground frontend Dockerfile (#4103)

# Description

Fixes Docker pnpm version error.

# Changes

Enable and prepare corepack version before running pnpm install.

# Fixes

https://github.com/cowprotocol/services/issues/4101
---
 playground/Dockerfile.cowswap  | 68 ++++++++++++++++++----------------
 playground/Dockerfile.explorer | 22 ++++++-----
 2 files changed, 50 insertions(+), 40 deletions(-)

diff --git a/playground/Dockerfile.cowswap b/playground/Dockerfile.cowswap
index 7ba495ced9..8318bd5760 100644
--- a/playground/Dockerfile.cowswap
+++ b/playground/Dockerfile.cowswap
@@ -2,6 +2,10 @@
 FROM docker.io/node:22-bookworm-slim AS node-build
 WORKDIR /usr/src/app
 
+# Enable Corepack and prepare pnpm
+RUN corepack enable \
+    && corepack prepare pnpm@10.12.1 --activate
+
 # RPC URL args
 ARG REACT_APP_NETWORK_URL_1=https://rpc.mevblocker.io
 ARG REACT_APP_NETWORK_URL_5=https://ethereum-goerli.publicnode.com
@@ -10,54 +14,56 @@ ARG REACT_APP_NETWORK_URL_100=https://gnosis.publicnode.com
 # Orderbook URL args
 ARG REACT_APP_ORDER_BOOK_URLS='{"1":"https://api.cow.fi/mainnet","100":"https://api.cow.fi/goerli","5":"https://api.cow.fi/xdai"}'
 
-# Install dependencies
+# Install system dependencies
 RUN --mount=type=cache,target=/var/cache/apt,sharing=locked apt-get update && \
-    apt-get install -y git libssl-dev pkg-config git jq python3 make g++
-
-# Clone the repo to the present working directory
-RUN git clone https://github.com/cowprotocol/cowswap . && \
-    git submodule update --init --recursive
+    apt-get install -y git libssl-dev pkg-config jq python3 make g++ && \
+    rm -rf /var/lib/apt/lists/*
 
-# Install npm dependencies
-RUN yarn install --frozen-lockfile --no-cache
+# Clone the repo, initialize submodules, and install dependencies
+RUN git clone https://github.com/cowprotocol/cowswap . \
+    && git submodule update --init --recursive \
+    && pnpm install --frozen-lockfile
 
-# Set the environment variable "chain"
+# Set environment variable "chain"
 ARG CHAIN
-ENV CHAIN=$CHAIN
+ENV CHAIN="$CHAIN"
 
-# Set the environment variable "ETH_RPC_URL"
+# Set environment variable "ETH_RPC_URL"
 ARG ETH_RPC_URL
-ENV ETH_RPC_URL=$ETH_RPC_URL
+ENV ETH_RPC_URL="$ETH_RPC_URL"
 
-# Set the default environment variables
-ENV REACT_APP_NETWORK_URL_1=$REACT_APP_NETWORK_URL_1
-ENV REACT_APP_NETWORK_URL_5=$REACT_APP_NETWORK_URL_5
-ENV REACT_APP_NETWORK_URL_100=$REACT_APP_NETWORK_URL_100
-ENV REACT_APP_ORDER_BOOK_URLS=$REACT_APP_ORDER_BOOK_URLS
+# Set default environment variables for network and order book URLs
+ENV REACT_APP_NETWORK_URL_1="$REACT_APP_NETWORK_URL_1"
+ENV REACT_APP_NETWORK_URL_5="$REACT_APP_NETWORK_URL_5"
+ENV REACT_APP_NETWORK_URL_100="$REACT_APP_NETWORK_URL_100"
+ENV REACT_APP_ORDER_BOOK_URLS="$REACT_APP_ORDER_BOOK_URLS"
 
-# Update environment variables based on "chain" and "ETH_RPC_URL" and build the frontend
-RUN if [ -n "$ETH_RPC_URL" ]; then \
+# Update environment variables based on "chain" and "ETH_RPC_URL", then build safely
+RUN set -e; \
+    if [ -n "$ETH_RPC_URL" ]; then \
         case "$CHAIN" in \
             1) \
-                REACT_APP_NETWORK_URL_1=$ETH_RPC_URL \
-                REACT_APP_ORDER_BOOK_URLS=$(echo $REACT_APP_ORDER_BOOK_URLS | jq --arg chain "1" '.[$chain]="http://127.0.0.1:8080"') \
+                REACT_APP_NETWORK_URL_1="$ETH_RPC_URL"; \
+                REACT_APP_ORDER_BOOK_URLS=$(echo "$REACT_APP_ORDER_BOOK_URLS" | jq --arg chain "1" '.[$chain]="http://127.0.0.1:8080"'); \
                 ;; \
             5) \
-                REACT_APP_NETWORK_URL_5=$ETH_RPC_URL \
-                REACT_APP_ORDER_BOOK_URLS=$(echo $REACT_APP_ORDER_BOOK_URLS | jq --arg chain "5" '.[$chain]="http://127.0.0.1:8080"') \
+                REACT_APP_NETWORK_URL_5="$ETH_RPC_URL"; \
+                REACT_APP_ORDER_BOOK_URLS=$(echo "$REACT_APP_ORDER_BOOK_URLS" | jq --arg chain "5" '.[$chain]="http://127.0.0.1:8080"'); \
                 ;; \
             100) \
-                REACT_APP_NETWORK_URL_100=$ETH_RPC_URL \
-                REACT_APP_ORDER_BOOK_URLS=$(echo $REACT_APP_ORDER_BOOK_URLS | jq --arg chain "100" '.[$chain]="http://127.0.0.1:8080"') \
+                REACT_APP_NETWORK_URL_100="$ETH_RPC_URL"; \
+                REACT_APP_ORDER_BOOK_URLS=$(echo "$REACT_APP_ORDER_BOOK_URLS" | jq --arg chain "100" '.[$chain]="http://127.0.0.1:8080"'); \
                 ;; \
         esac; \
-        NODE_OPTIONS="--max-old-space-size=4096" NX_NO_CLOUD=true yarn build --env REACT_APP_NETWORK_URL_1=$REACT_APP_NETWORK_URL_1 \
-                   --env REACT_APP_NETWORK_URL_5=$REACT_APP_NETWORK_URL_5 \
-                   --env REACT_APP_NETWORK_URL_100=$REACT_APP_NETWORK_URL_100 \
-                   --env REACT_APP_ORDER_BOOK_URLS="$REACT_APP_ORDER_BOOK_URLS"; \
-    fi
+    fi; \
+    export REACT_APP_NETWORK_URL_1 REACT_APP_NETWORK_URL_5 REACT_APP_NETWORK_URL_100 REACT_APP_ORDER_BOOK_URLS; \
+    NODE_OPTIONS="--max-old-space-size=4096" NX_NO_CLOUD=true pnpm run build \
+        --env REACT_APP_NETWORK_URL_1="$REACT_APP_NETWORK_URL_1" \
+        --env REACT_APP_NETWORK_URL_5="$REACT_APP_NETWORK_URL_5" \
+        --env REACT_APP_NETWORK_URL_100="$REACT_APP_NETWORK_URL_100" \
+        --env REACT_APP_ORDER_BOOK_URLS="$REACT_APP_ORDER_BOOK_URLS"
 
-# Stage 2: Copy the frontend to the nginx container
+# Stage 2: Copy the frontend build to the nginx container
 FROM docker.io/nginx:1.21-alpine AS frontend
 COPY --from=node-build /usr/src/app/build/cowswap /usr/share/nginx/html
 EXPOSE 80
diff --git a/playground/Dockerfile.explorer b/playground/Dockerfile.explorer
index 34a2929007..917923a0f4 100644
--- a/playground/Dockerfile.explorer
+++ b/playground/Dockerfile.explorer
@@ -2,23 +2,27 @@
 FROM docker.io/node:22-bookworm-slim AS node-build
 WORKDIR /usr/src/app
 
-# Install dependencies
+# Install system dependencies needed for building
 RUN --mount=type=cache,target=/var/cache/apt,sharing=locked apt-get update && \
-    apt-get install -y git libssl-dev pkg-config git autoconf automake file g++ libtool make python3
+    apt-get install -y git libssl-dev pkg-config autoconf automake file g++ libtool make python3 && \
+    rm -rf /var/lib/apt/lists/*
 
-# Clone the repo to the present working directory
-RUN git clone https://github.com/cowprotocol/cowswap . && \
-    git submodule update --init --recursive
+# Enable Corepack and prepare pnpm
+RUN corepack enable \
+    && corepack prepare pnpm@10.12.1 --activate
 
-# Install npm dependencies
-RUN yarn install --frozen-lockfile --no-cache
+# Clone the repo, initialize submodules, and install dependencies
+RUN git clone https://github.com/cowprotocol/cowswap . \
+    && git submodule update --init --recursive \
+    && pnpm install --frozen-lockfile
 
+# Set environment variable for the order book
 ENV REACT_APP_ORDER_BOOK_URLS='{"1":"http://localhost:8080"}'
 
 # Build the frontend
-RUN APP_ID=1 yarn build:explorer
+RUN APP_ID=1 pnpm run build:explorer
 
-# Stage 2: Copy the frontend to the nginx container
+# Stage 2: Copy the frontend build to the nginx container
 FROM docker.io/nginx:1.21-alpine AS frontend
 COPY --from=node-build /usr/src/app/build/explorer /usr/share/nginx/html
 EXPOSE 80

From 00ae19d28764dd37bb4b44301ec44838cd5bf0a2 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 2 Feb 2026 14:18:31 +0300
Subject: [PATCH 023/219] Normalize ECDSA signature `v` parameter for Solidity
 `ecrecover` compatibility (#4107)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

This PR fixes an issue where EIP-712 signatures with `v = 0` or `1`
(modern EIP-2 format) pass off-chain validation but fail on-chain
settlement with `GPv2: invalid signature`.
# Problem
Some wallets (e.g., Bitget Wallet) produce ECDSA signatures using the
modern EIP-2 format, where `v ∈ {0, 1}`, while Solidity's `ecrecover`
precompile expects the legacy format where `v ∈ {27, 28}`.
Off-chain (Alloy library): The
https://github.com/alloy-rs/core/blob/main/crates/primitives/src/signature/sig.rs
internally normalizes `v` to a boolean parity before recovery, so
signatures with `v = 0` or `1` recover correctly.
On-chain (Solidity): The `ecrecover` precompile
https://coders-errand.com/ecrecover-signature-verification-ethereum/.
When given `v = 0`, it returns `address(0)`, which triggers the

https://github.com/cowprotocol/contracts/blob/main/src/contracts/mixins/GPv2Signing.sol#L207-L208:
```
signer = ecrecover(message, v, r, s);
require(signer != address(0), "GPv2: invalid ecdsa signature");
```
This mismatch causes orders to pass orderbook validation but fail at
settlement.
# Solution
Normalize `v` to the legacy format (`27/28`) at signature parsing time
in `EcdsaSignature::from_bytes()`:
```
let normalized_v = match v {
    0 | 27 => 27,
    1 | 28 => 28,
    _ => anyhow::bail!("invalid signature v value: {v}, expected 0, 1, 27, or 28"),
};
```
This ensures:
1. Signatures are stored with normalized `v` values
2. Both off-chain validation and on-chain `ecrecover` receive compatible
parameters
3. The fix applies to all entry points (`Signature::from_bytes`, JSON
deserialization)
# Reproducing the Issue
The issue can be verified using a real failed order and Foundry's cast
tool to call the `ecrecover` precompile directly:
Failed order:
- Order UID:
`0xb8e19962dd762067afb9f169684abfcbf2cb13bdc7a62ae2e680ebd5ce18c9bcca0c9c4a650cc4ed406d4a6dd031cdd9d4ebf0dc697a0686`
- Order hash (struct hash):
`0xb8e19962dd762067afb9f169684abfcbf2cb13bdc7a62ae2e680ebd5ce18c9bc`
- Expected signer (owner): `0xca0c9c4a650cc4ed406d4a6dd031cdd9d4ebf0dc`
- Signature:
`0xAB2E74AA0D67233ADC7B52C3B832357ED35F2052338D820D4DA66210EFA7A9684601726CB76BD26DDD958EFE291CFB57E02C39B3F60FBB8BBED1E891FB14CB5D00`
- r:
`0xAB2E74AA0D67233ADC7B52C3B832357ED35F2052338D820D4DA66210EFA7A968`
- s:
`0x4601726CB76BD26DDD958EFE291CFB57E02C39B3F60FBB8BBED1E891FB14CB5D`
- v: `0x00` ← the problem
## Step 1: Compute the EIP-712 message hash
To avoid computing it manually, I grabbed it from a Tenderly
simulation[[URL](https://dashboard.tenderly.co/cow-protocol/barn/simulator/babc6191-e15a-470c-83e0-5825b8a4501b/debugger?trace=0.0.4.1.1.0)].
```
MESSAGE_HASH="0xb8e19962dd762067afb9f169684abfcbf2cb13bdc7a62ae2e680ebd5ce18c9bc"
```
## Step 2: Test ecrecover with `v=0` (returns zero address - FAILS
on-chain)
```
cast call 0x0000000000000000000000000000000000000001 \
"${MESSAGE_HASH}0000000000000000000000000000000000000000000000000000000000000000AB2E74AA0D67233ADC7B52C3B832357ED35F2052338D820D4DA66210EFA7A9684601726CB76BD26DDD958EFE291CFB57E02C39B3F60FBB8BBED1E891FB14CB5D" \
--rpc-url https://eth.llamarpc.com
```
### Returns:
`0x0000000000000000000000000000000000000000000000000000000000000000`
## Step 3: Test ecrecover with `v=27` (returns correct signer - WORKS)
```
cast call 0x0000000000000000000000000000000000000001 \
"${MESSAGE_HASH}000000000000000000000000000000000000000000000000000000000000001bAB2E74AA0D67233ADC7B52C3B832357ED35F2052338D820D4DA66210EFA7A9684601726CB76BD26DDD958EFE291CFB57E02C39B3F60FBB8BBED1E891FB14CB5D" \
--rpc-url https://eth.llamarpc.com
```
### Returns:
`0x000000000000000000000000ca0c9c4a650cc4ed406d4a6dd031cdd9d4ebf0dc` ✅
---
 .../src/domain/competition/order/signature.rs |  22 +-
 .../driver/src/infra/solver/dto/solution.rs   |  12 +-
 crates/model/src/order.rs                     | 217 ++++++++++++------
 crates/model/src/signature.rs                 | 211 +++++++++++++----
 crates/shared/src/encoded_settlement.rs       |   5 +-
 5 files changed, 349 insertions(+), 118 deletions(-)

diff --git a/crates/driver/src/domain/competition/order/signature.rs b/crates/driver/src/domain/competition/order/signature.rs
index 2964fdc8e3..852f8b3606 100644
--- a/crates/driver/src/domain/competition/order/signature.rs
+++ b/crates/driver/src/domain/competition/order/signature.rs
@@ -13,21 +13,29 @@ pub struct Signature {
 }
 
 impl Signature {
-    pub fn to_boundary_signature(&self) -> model::signature::Signature {
+    pub fn to_boundary_signature(&self) -> anyhow::Result<model::signature::Signature> {
         // TODO Different signing schemes imply different sizes of signature data, which
         // indicates that I'm missing an invariant in my types and I need to fix
         // that PreSign, for example, carries no data. Everything should be
         // reflected in the types!
-        match self.scheme {
+        Ok(match self.scheme {
             Scheme::Eip712 => model::signature::Signature::Eip712(EcdsaSignature::from_bytes(
-                self.data.0.as_slice().try_into().unwrap(),
-            )),
+                self.data
+                    .0
+                    .as_slice()
+                    .try_into()
+                    .map_err(|_| anyhow::anyhow!("ECDSA signature must be 65 bytes"))?,
+            )?),
             Scheme::EthSign => model::signature::Signature::EthSign(EcdsaSignature::from_bytes(
-                self.data.0.as_slice().try_into().unwrap(),
-            )),
+                self.data
+                    .0
+                    .as_slice()
+                    .try_into()
+                    .map_err(|_| anyhow::anyhow!("ECDSA signature must be 65 bytes"))?,
+            )?),
             Scheme::Eip1271 => model::signature::Signature::Eip1271(self.data.clone().into()),
             Scheme::PreSign => model::signature::Signature::PreSign,
-        }
+        })
     }
 }
 
diff --git a/crates/driver/src/infra/solver/dto/solution.rs b/crates/driver/src/infra/solver/dto/solution.rs
index 3bb6e357c1..a3794444a5 100644
--- a/crates/driver/src/infra/solver/dto/solution.rs
+++ b/crates/driver/src/infra/solver/dto/solution.rs
@@ -328,11 +328,13 @@ impl JitOrder {
 
         let signer = signature
             .to_boundary_signature()
-            .recover_owner(
-                self.0.signature.as_slice(),
-                &DomainSeparator(domain_separator.0),
-                &self.raw_order_data().hash_struct(),
-            )
+            .and_then(|sig| {
+                sig.recover_owner(
+                    self.0.signature.as_slice(),
+                    &DomainSeparator(domain_separator.0),
+                    &self.raw_order_data().hash_struct(),
+                )
+            })
             .map_err(|e| super::Error(e.to_string()))?;
 
         if matches!(
diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index 251e330d16..e27279e540 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -1072,7 +1072,9 @@ mod tests {
 
     #[test]
     fn deserialization_and_back() {
-        let value = json!(
+        // Input JSON has v=0x01, which gets normalized to v=28 (0x1c) for Solidity
+        // ecrecover compatibility. Serialization then outputs v=0x1c.
+        let input_json = json!(
         {
             "creationDate": "1970-01-01T00:00:03Z",
             "owner": "0x0000000000000000000000000000000000000001",
@@ -1109,6 +1111,7 @@ mod tests {
             },
             "fullAppData": "123",
         });
+
         let signing_scheme = EcdsaSigningScheme::Eip712;
         let expected = Order {
             metadata: OrderMetadata {
@@ -1146,82 +1149,166 @@ mod tests {
                 buy_token_balance: BuyTokenDestination::Internal,
             },
             signature: EcdsaSignature {
-                v: 1,
+                // v=0x01 in input gets normalized to 28 for Solidity ecrecover compatibility
+                v: 28,
                 r: b256!("0200000000000000000000000000000000000000000000000000000000000003"),
                 s: b256!("0400000000000000000000000000000000000000000000000000000000000005"),
             }
             .to_signature(signing_scheme),
             interactions: Interactions::default(),
         };
-        let deserialized: Order = serde_json::from_value(value.clone()).unwrap();
+
+        // After deserialization, v=0x01 becomes v=28
+        let deserialized: Order = serde_json::from_value(input_json).unwrap();
         assert_eq!(deserialized, expected);
+
+        // Serialization outputs the normalized v=0x1c (28)
+        let expected_output_json = json!(
+        {
+            "creationDate": "1970-01-01T00:00:03Z",
+            "owner": "0x0000000000000000000000000000000000000001",
+            "uid": "0x1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+            "availableBalance": null,
+            "executedBuyAmount": "3",
+            "executedSellAmount": "5",
+            "executedSellAmountBeforeFees": "4",
+            "executedFeeAmount": "1",
+            "invalidated": true,
+            "sellToken": "0x000000000000000000000000000000000000000a",
+            "buyToken": "0x0000000000000000000000000000000000000009",
+            "receiver": "0x000000000000000000000000000000000000000b",
+            "sellAmount": "1",
+            "buyAmount": "0",
+            "validTo": 4294967295u32,
+            "appData": "0x6000000000000000000000000000000000000000000000000000000000000007",
+            "feeAmount": "115792089237316195423570985008687907853269984665640564039457584007913129639935",
+            "executedFee": "1",
+            "executedFeeToken": "0x000000000000000000000000000000000000000a",
+            "kind": "buy",
+            "class": "limit",
+            "partiallyFillable": false,
+            "signature": "0x02000000000000000000000000000000000000000000000000000000000000030400000000000000000000000000000000000000000000000000000000000005\
+        1c",
+            "signingScheme": "eip712",
+            "status": "open",
+            "settlementContract": "0x0000000000000000000000000000000000000002",
+            "sellTokenBalance": "external",
+            "buyTokenBalance": "internal",
+            "isLiquidityOrder": false,
+            "interactions": {
+                    "pre": [],
+                    "post": [],
+            },
+            "fullAppData": "123",
+        });
         let serialized = serde_json::to_value(expected).unwrap();
-        assert_json_matches!(serialized, value);
+        assert_json_matches!(serialized, expected_output_json);
     }
 
     #[test]
     fn order_creation_serialization() {
         let owner = Address::repeat_byte(0xff);
-        for (signature, signing_scheme, from, signature_bytes) in [
-            (
-                Signature::default_with(SigningScheme::Eip712),
-                "eip712",
-                Some(owner),
-                "0x0000000000000000000000000000000000000000000000000000000000000000\
-                   0000000000000000000000000000000000000000000000000000000000000000\
-                   00",
-            ),
-            (
-                Signature::default_with(SigningScheme::EthSign),
-                "ethsign",
-                None,
-                "0x0000000000000000000000000000000000000000000000000000000000000000\
-                   0000000000000000000000000000000000000000000000000000000000000000\
-                   00",
-            ),
-            (Signature::PreSign, "presign", Some(owner), "0x"),
-        ] {
-            let order = OrderCreation {
-                sell_token: Address::repeat_byte(0x11),
-                buy_token: Address::repeat_byte(0x22),
-                receiver: Some(Address::repeat_byte(0x33)),
-                sell_amount: alloy::primitives::U256::from(123),
-                buy_amount: alloy::primitives::U256::from(456),
-                valid_to: 1337,
-                app_data: OrderCreationAppData::Hash {
-                    hash: AppDataHash([0x44; 32]),
-                },
-                fee_amount: alloy::primitives::U256::from(789),
-                kind: OrderKind::Sell,
-                partially_fillable: false,
-                sell_token_balance: SellTokenSource::Erc20,
-                buy_token_balance: BuyTokenDestination::Erc20,
-                from,
-                signature,
-                quote_id: Some(42),
-            };
-            let order_json = json!({
-                "sellToken": "0x1111111111111111111111111111111111111111",
-                "buyToken": "0x2222222222222222222222222222222222222222",
-                "receiver": "0x3333333333333333333333333333333333333333",
-                "sellAmount": "123",
-                "buyAmount": "456",
-                "validTo": 1337,
-                "appData": "0x4444444444444444444444444444444444444444444444444444444444444444",
-                "feeAmount": "789",
-                "kind": "sell",
-                "partiallyFillable": false,
-                "sellTokenBalance": "erc20",
-                "buyTokenBalance": "erc20",
-                "quoteId": 42,
-                "signingScheme": signing_scheme,
-                "signature": signature_bytes,
-                "from": from,
-            });
-
-            assert_json_matches!(json!(order), order_json);
-            assert_eq!(order, serde_json::from_value(order_json).unwrap());
-        }
+
+        let template_order = OrderCreation {
+            sell_token: Address::repeat_byte(0x11),
+            buy_token: Address::repeat_byte(0x22),
+            receiver: Some(Address::repeat_byte(0x33)),
+            sell_amount: alloy::primitives::U256::from(123),
+            buy_amount: alloy::primitives::U256::from(456),
+            valid_to: 1337,
+            app_data: OrderCreationAppData::Hash {
+                hash: AppDataHash([0x44; 32]),
+            },
+            fee_amount: alloy::primitives::U256::from(789),
+            kind: OrderKind::Sell,
+            partially_fillable: false,
+            sell_token_balance: SellTokenSource::Erc20,
+            buy_token_balance: BuyTokenDestination::Erc20,
+            from: Some(owner),
+            signature: Signature::PreSign,
+            quote_id: Some(42),
+        };
+
+        // Test PreSign round-trip (no signature normalization needed)
+        let presign_order = template_order.clone();
+        let presign_json = json!({
+            "sellToken": "0x1111111111111111111111111111111111111111",
+            "buyToken": "0x2222222222222222222222222222222222222222",
+            "receiver": "0x3333333333333333333333333333333333333333",
+            "sellAmount": "123",
+            "buyAmount": "456",
+            "validTo": 1337,
+            "appData": "0x4444444444444444444444444444444444444444444444444444444444444444",
+            "feeAmount": "789",
+            "kind": "sell",
+            "partiallyFillable": false,
+            "sellTokenBalance": "erc20",
+            "buyTokenBalance": "erc20",
+            "quoteId": 42,
+            "signingScheme": "presign",
+            "signature": "0x",
+            "from": owner,
+        });
+        assert_json_matches!(json!(presign_order), presign_json);
+        assert_eq!(presign_order, serde_json::from_value(presign_json).unwrap());
+
+        // Test ECDSA signature with v normalization.
+        // Input JSON has v=0x00, which normalizes to v=27 (0x1b).
+        let input_json_v0 = json!({
+            "sellToken": "0x1111111111111111111111111111111111111111",
+            "buyToken": "0x2222222222222222222222222222222222222222",
+            "receiver": "0x3333333333333333333333333333333333333333",
+            "sellAmount": "123",
+            "buyAmount": "456",
+            "validTo": 1337,
+            "appData": "0x4444444444444444444444444444444444444444444444444444444444444444",
+            "feeAmount": "789",
+            "kind": "sell",
+            "partiallyFillable": false,
+            "sellTokenBalance": "erc20",
+            "buyTokenBalance": "erc20",
+            "quoteId": 42,
+            "signingScheme": "eip712",
+            "signature": "0x0000000000000000000000000000000000000000000000000000000000000000\
+                          0000000000000000000000000000000000000000000000000000000000000000\
+                          00",
+            "from": owner,
+        });
+        let expected_order = OrderCreation {
+            signature: Signature::Eip712(EcdsaSignature {
+                r: B256::ZERO,
+                s: B256::ZERO,
+                v: 27, // normalized from v=0
+            }),
+            ..template_order.clone()
+        };
+
+        // Deserialization normalizes v=0 to v=27
+        let deserialized: OrderCreation = serde_json::from_value(input_json_v0).unwrap();
+        assert_eq!(deserialized, expected_order);
+
+        // Serialization outputs normalized v=0x1b
+        let output_json_v27 = json!({
+            "sellToken": "0x1111111111111111111111111111111111111111",
+            "buyToken": "0x2222222222222222222222222222222222222222",
+            "receiver": "0x3333333333333333333333333333333333333333",
+            "sellAmount": "123",
+            "buyAmount": "456",
+            "validTo": 1337,
+            "appData": "0x4444444444444444444444444444444444444444444444444444444444444444",
+            "feeAmount": "789",
+            "kind": "sell",
+            "partiallyFillable": false,
+            "sellTokenBalance": "erc20",
+            "buyTokenBalance": "erc20",
+            "quoteId": 42,
+            "signingScheme": "eip712",
+            "signature": "0x0000000000000000000000000000000000000000000000000000000000000000\
+                          0000000000000000000000000000000000000000000000000000000000000000\
+                          1b",
+            "from": owner,
+        });
+        assert_json_matches!(json!(expected_order), output_json_v27);
     }
 
     #[test]
@@ -1379,7 +1466,7 @@ mod tests {
                 order_uid: OrderUid(hex!(
                     "2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"
                 )),
-                signature: EcdsaSignature::from_bytes(signature),
+                signature: EcdsaSignature::from_bytes(signature).unwrap(),
                 signing_scheme: *signing_scheme,
             };
             let owner = cancellation.validate(&domain_separator).unwrap();
diff --git a/crates/model/src/signature.rs b/crates/model/src/signature.rs
index 378fad0018..70da569597 100644
--- a/crates/model/src/signature.rs
+++ b/crates/model/src/signature.rs
@@ -118,12 +118,7 @@ impl Signature {
                 let bytes: [u8; 65] = bytes
                     .try_into()
                     .context("ECDSA signature must be 65 bytes long")?;
-                EcdsaSignature {
-                    r: B256::from_slice(&bytes[..32]),
-                    s: B256::from_slice(&bytes[32..64]),
-                    v: bytes[64],
-                }
-                .to_signature(
+                EcdsaSignature::from_bytes(&bytes)?.to_signature(
                     scheme
                         .try_to_ecdsa_scheme()
                         .expect("scheme is an ecdsa scheme"),
@@ -255,13 +250,24 @@ impl SigningScheme {
     }
 }
 
-#[derive(Eq, PartialEq, Clone, Copy, Debug, Default, Hash)]
+#[derive(Eq, PartialEq, Clone, Copy, Debug, Hash)]
 pub struct EcdsaSignature {
     pub r: B256,
     pub s: B256,
     pub v: u8,
 }
 
+impl Default for EcdsaSignature {
+    fn default() -> Self {
+        Self {
+            r: B256::ZERO,
+            s: B256::ZERO,
+            // Use normalized v value (equivalent to 0) for Solidity ecrecover compatibility
+            v: 27,
+        }
+    }
+}
+
 pub fn hashed_eip712_message(domain_separator: &DomainSeparator, struct_hash: &[u8; 32]) -> B256 {
     let mut message = [0u8; 66];
     // 0x19 0x01 are the magic prefix bytes for the domain separator
@@ -308,12 +314,23 @@ impl EcdsaSignature {
         bytes
     }
 
-    pub fn from_bytes(bytes: &[u8; 65]) -> Self {
-        EcdsaSignature {
+    pub fn from_bytes(bytes: &[u8; 65]) -> Result<Self> {
+        let v = bytes[64];
+        // Normalize v to legacy format (27/28) for Solidity ecrecover compatibility.
+        // Modern EIP-2 signatures use v = 0 or 1, but Solidity's ecrecover expects
+        // v = 27 or 28. Alloy normalizes internally for off-chain recovery, but
+        // on-chain ecrecover(hash, v=0, r, s) returns address(0) and fails.
+        // Only valid v values are 0, 1, 27, 28.
+        let normalized_v = match v {
+            0 | 27 => 27,
+            1 | 28 => 28,
+            _ => anyhow::bail!("invalid signature v value: {v}, expected 0, 1, 27, or 28"),
+        };
+        Ok(EcdsaSignature {
             r: B256::from_slice(&bytes[..32]),
             s: B256::from_slice(&bytes[32..64]),
-            v: bytes[64],
-        }
+            v: normalized_v,
+        })
     }
 
     pub fn recover(
@@ -338,7 +355,7 @@ impl EcdsaSignature {
         let message = hashed_signing_message(signing_scheme, domain_separator, struct_hash);
         // Unwrap because the only error is for invalid messages which we don't create.
         let signature = key.sign_hash_sync(&message).unwrap();
-        Self::from_bytes(&signature.as_bytes())
+        Self::from_bytes(&signature.as_bytes()).expect("signing produces valid v values")
     }
 
     /// Returns an arbitrary non-zero signature that can be used for recovery
@@ -380,7 +397,7 @@ impl<'de> Deserialize<'de> for EcdsaSignature {
                 write!(
                     formatter,
                     "the 65 ecdsa signature bytes as a hex encoded string, ordered as r, s, v, \
-                     where v is either 27 or 28"
+                     where v is 0, 1, 27, or 28"
                 )
             }
 
@@ -400,7 +417,7 @@ impl<'de> Deserialize<'de> for EcdsaSignature {
                         "failed to decode {s:?} as hex ecdsa signature: {err}"
                     ))
                 })?;
-                Ok(EcdsaSignature::from_bytes(&bytes))
+                EcdsaSignature::from_bytes(&bytes).map_err(de::Error::custom)
             }
         }
 
@@ -437,6 +454,7 @@ mod tests {
         assert!(Signature::from_bytes(SigningScheme::EthSign, &[0u8; 20]).is_err());
         assert!(Signature::from_bytes(SigningScheme::PreSign, &[0u8; 32]).is_err());
 
+        // Note: v=0 in input bytes gets normalized to v=27 for ecrecover compatibility
         assert_eq!(
             Signature::from_bytes(SigningScheme::Eip712, &[0u8; 65]).unwrap(),
             Signature::default_with(SigningScheme::Eip712)
@@ -461,13 +479,17 @@ mod tests {
 
     #[test]
     fn signature_to_bytes() {
+        // Default ECDSA signatures have normalized v = 27 (equivalent to 0)
+        let mut expected_ecdsa = [0u8; 65];
+        expected_ecdsa[64] = 27;
+
         assert_eq!(
             Signature::default_with(SigningScheme::Eip712).to_bytes(),
-            [0u8; 65].to_vec()
+            expected_ecdsa.to_vec()
         );
         assert_eq!(
             Signature::default_with(SigningScheme::EthSign).to_bytes(),
-            [0u8; 65].to_vec()
+            expected_ecdsa.to_vec()
         );
         assert_eq!(
             Signature::default_with(SigningScheme::PreSign).to_bytes(),
@@ -490,31 +512,8 @@ mod tests {
 
     #[test]
     fn deserialize_and_back() {
+        // Test round-trip for non-ECDSA signatures (no normalization needed)
         for (signature, json) in [
-            (
-                Signature::Eip712(Default::default()),
-                json!({
-                    "signingScheme": "eip712",
-                    "signature": "0x\
-                        0000000000000000000000000000000000000000000000000000000000000000\
-                        0000000000000000000000000000000000000000000000000000000000000000\
-                        00",
-                }),
-            ),
-            (
-                Signature::EthSign(EcdsaSignature {
-                    r: B256::repeat_byte(1),
-                    s: B256::repeat_byte(2),
-                    v: 3,
-                }),
-                json!({
-                    "signingScheme": "ethsign",
-                    "signature": "0x\
-                        0101010101010101010101010101010101010101010101010101010101010101\
-                        0202020202020202020202020202020202020202020202020202020202020202\
-                        03",
-                }),
-            ),
             (
                 Signature::Eip1271(vec![1, 2, 3]),
                 json!({
@@ -540,6 +539,57 @@ mod tests {
             assert_eq!(signature, serde_json::from_value(json.clone()).unwrap());
             assert_json_matches!(json, json!(signature));
         }
+
+        // Test ECDSA signature deserialization with v normalization.
+        // Input v=0x00 normalizes to v=27, so serialization outputs v=0x1b.
+        let input_json = json!({
+            "signingScheme": "eip712",
+            "signature": "0x\
+                0000000000000000000000000000000000000000000000000000000000000000\
+                0000000000000000000000000000000000000000000000000000000000000000\
+                00",
+        });
+        let expected_signature = Signature::Eip712(EcdsaSignature {
+            r: B256::ZERO,
+            s: B256::ZERO,
+            v: 27, // normalized from v=0
+        });
+        let expected_output_json = json!({
+            "signingScheme": "eip712",
+            "signature": "0x\
+                0000000000000000000000000000000000000000000000000000000000000000\
+                0000000000000000000000000000000000000000000000000000000000000000\
+                1b",
+        });
+
+        let deserialized: Signature = serde_json::from_value(input_json).unwrap();
+        assert_eq!(deserialized, expected_signature);
+        assert_json_matches!(json!(deserialized), expected_output_json);
+
+        // Test EthSign with v=1 normalizing to v=28
+        let input_json = json!({
+            "signingScheme": "ethsign",
+            "signature": "0x\
+                0101010101010101010101010101010101010101010101010101010101010101\
+                0202020202020202020202020202020202020202020202020202020202020202\
+                01",
+        });
+        let expected_signature = Signature::EthSign(EcdsaSignature {
+            r: B256::repeat_byte(1),
+            s: B256::repeat_byte(2),
+            v: 28, // normalized from v=1
+        });
+        let expected_output_json = json!({
+            "signingScheme": "ethsign",
+            "signature": "0x\
+                0101010101010101010101010101010101010101010101010101010101010101\
+                0202020202020202020202020202020202020202020202020202020202020202\
+                1c",
+        });
+
+        let deserialized: Signature = serde_json::from_value(input_json).unwrap();
+        assert_eq!(deserialized, expected_signature);
+        assert_json_matches!(json!(deserialized), expected_output_json);
     }
 
     #[test]
@@ -628,4 +678,85 @@ mod tests {
             hashed_ethsign_message(&domain_separator, &struct_hash)
         );
     }
+
+    #[test]
+    fn ecdsa_signature_v_normalization() {
+        // Modern EIP-2 signatures use v = 0 or 1, but Solidity's ecrecover expects
+        // v = 27 or 28. This test verifies that v values are normalized correctly.
+
+        // v = 0 should be normalized to 27
+        let mut bytes_v0 = [0u8; 65];
+        bytes_v0[64] = 0;
+        let sig = EcdsaSignature::from_bytes(&bytes_v0).unwrap();
+        assert_eq!(sig.v, 27);
+        assert_eq!(sig.to_bytes()[64], 27);
+
+        // v = 1 should be normalized to 28
+        let mut bytes_v1 = [0u8; 65];
+        bytes_v1[64] = 1;
+        let sig = EcdsaSignature::from_bytes(&bytes_v1).unwrap();
+        assert_eq!(sig.v, 28);
+        assert_eq!(sig.to_bytes()[64], 28);
+
+        // v = 27 should stay 27
+        let mut bytes_v27 = [0u8; 65];
+        bytes_v27[64] = 27;
+        let sig = EcdsaSignature::from_bytes(&bytes_v27).unwrap();
+        assert_eq!(sig.v, 27);
+        assert_eq!(sig.to_bytes()[64], 27);
+
+        // v = 28 should stay 28
+        let mut bytes_v28 = [0u8; 65];
+        bytes_v28[64] = 28;
+        let sig = EcdsaSignature::from_bytes(&bytes_v28).unwrap();
+        assert_eq!(sig.v, 28);
+        assert_eq!(sig.to_bytes()[64], 28);
+
+        // Verify normalization also works through Signature::from_bytes
+        let sig = Signature::from_bytes(SigningScheme::Eip712, &bytes_v0).unwrap();
+        assert_eq!(sig.to_bytes()[64], 27);
+
+        let sig = Signature::from_bytes(SigningScheme::EthSign, &bytes_v1).unwrap();
+        assert_eq!(sig.to_bytes()[64], 28);
+    }
+
+    #[test]
+    fn ecdsa_signature_invalid_v_rejected() {
+        // Invalid v values should be rejected
+        for invalid_v in [2u8, 3, 26, 29, 30, 255] {
+            let mut bytes = [0u8; 65];
+            bytes[64] = invalid_v;
+
+            // EcdsaSignature::from_bytes should return an error
+            let result = EcdsaSignature::from_bytes(&bytes);
+            assert!(
+                result.is_err(),
+                "v={invalid_v} should be rejected but was accepted"
+            );
+
+            // Signature::from_bytes should also return an error
+            let result = Signature::from_bytes(SigningScheme::Eip712, &bytes);
+            assert!(
+                result.is_err(),
+                "v={invalid_v} should be rejected via Signature::from_bytes"
+            );
+
+            // Deserialization should also fail
+            let hex_sig = format!(
+                "0x{}{}{}",
+                const_hex::encode([0u8; 32]),
+                const_hex::encode([0u8; 32]),
+                const_hex::encode([invalid_v])
+            );
+            let json = json!({
+                "signingScheme": "eip712",
+                "signature": hex_sig,
+            });
+            let result: Result<Signature, _> = serde_json::from_value(json);
+            assert!(
+                result.is_err(),
+                "v={invalid_v} should be rejected during deserialization"
+            );
+        }
+    }
 }
diff --git a/crates/shared/src/encoded_settlement.rs b/crates/shared/src/encoded_settlement.rs
index 61bc8ce86e..ceca3aac28 100644
--- a/crates/shared/src/encoded_settlement.rs
+++ b/crates/shared/src/encoded_settlement.rs
@@ -181,8 +181,11 @@ mod tests {
     #[test]
     fn trade_signature_encoding() {
         let owner = Address::repeat_byte(1);
+        // Default EcdsaSignature has v = 27 (normalized for Solidity ecrecover)
+        let mut default_ecdsa_bytes = vec![0; 65];
+        default_ecdsa_bytes[64] = 27;
         for (signature, bytes) in [
-            (Signature::Eip712(Default::default()), vec![0; 65]),
+            (Signature::Eip712(Default::default()), default_ecdsa_bytes),
             (
                 Signature::EthSign(EcdsaSignature {
                     r: B256::repeat_byte(1),

From 77bbbdf153b001df08b484340fded4bc6333eda5 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 2 Feb 2026 18:08:47 +0300
Subject: [PATCH 024/219] Fix haircut mismatch between reported and on-chain
 amounts (#4109)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Fixes the mismatch between driver-reported amounts and on-chain executed
amounts when the haircut is configured. Previously, the driver reported
higher buy amounts than users actually received on-chain (for sell
orders), resulting in a discrepancy that matched the configured haircut.

Root cause: `sell_amount()` and `buy_amount()` did NOT include haircut,
but `custom_prices()` (used for on-chain encoding) DID. This caused
reported amounts to differ from on-chain execution.

# Changes
Include haircut effects in `sell_amount()` and `buy_amount()` so that:
 - Reported amounts include haircut
 - On-chain execution matches reported amounts
 - Autopilot scores based on actual (haircutted) amounts

For sell orders:
 - `sell_amount()` → unchanged (user sells exactly what they signed)
 - `buy_amount()` → reduced by haircut (user receives less)
For buy orders:
 - `sell_amount()` → increased by haircut (user pays more)
- `buy_amount()` → unchanged (user receives exactly what they signed
for)

## How to test
Adjusted existing tests.

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 .../src/domain/competition/solution/trade.rs  |  60 ++++++----
 crates/driver/src/domain/quote.rs             |   6 +-
 crates/driver/src/tests/cases/haircut.rs      | 111 ++++++++++++++----
 crates/e2e/tests/e2e/limit_orders.rs          |  59 +++++-----
 4 files changed, 163 insertions(+), 73 deletions(-)

diff --git a/crates/driver/src/domain/competition/solution/trade.rs b/crates/driver/src/domain/competition/solution/trade.rs
index 40a97ebf2c..f89f2a8549 100644
--- a/crates/driver/src/domain/competition/solution/trade.rs
+++ b/crates/driver/src/domain/competition/solution/trade.rs
@@ -212,6 +212,9 @@ impl Fulfillment {
     }
 
     /// The effective amount that left the user's wallet including all fees.
+    ///
+    /// For buy orders, this includes the haircut effect (haircut increases the
+    /// effective sell amount the user pays).
     pub fn sell_amount(&self, prices: &ClearingPrices) -> Result<eth::TokenAmount, error::Math> {
         let before_fee = match self.order.side {
             order::Side::Sell => self.executed.0,
@@ -224,31 +227,51 @@ impl Fulfillment {
                 .ok_or(Math::DivisionByZero)?,
         };
 
+        let with_fee = before_fee.checked_add(self.fee().0).ok_or(Math::Overflow)?;
+        // Add haircut for buy orders (haircut is in buy token, convert to sell token)
+        let haircut = match self.order.side {
+            order::Side::Sell => eth::U256::ZERO, // Haircut applied to buy_amount for sell orders
+            order::Side::Buy => self.haircut_in_sell_token(prices)?,
+        };
+
         Ok(eth::TokenAmount(
-            before_fee.checked_add(self.fee().0).ok_or(Math::Overflow)?,
+            with_fee.checked_add(haircut).ok_or(Math::Overflow)?,
         ))
     }
 
     /// The effective amount the user received after all fees.
     ///
     /// Settlement contract uses `ceil` division for buy amount calculation.
+    ///
+    /// For sell orders, this includes the haircut effect (haircut reduces the
+    /// effective buy amount the user receives).
     pub fn buy_amount(&self, prices: &ClearingPrices) -> Result<eth::TokenAmount, error::Math> {
         let amount = match self.order.side {
             order::Side::Buy => self.executed.0,
-            order::Side::Sell => self
-                .executed
-                .0
-                .checked_mul(prices.sell)
-                .ok_or(Math::Overflow)?
-                .checked_ceil_div(&prices.buy)
-                .ok_or(Math::DivisionByZero)?,
+            order::Side::Sell => {
+                // Base buy amount from executed sell
+                let base = self
+                    .executed
+                    .0
+                    .checked_mul(prices.sell)
+                    .ok_or(Math::Overflow)?
+                    .checked_ceil_div(&prices.buy)
+                    .ok_or(Math::DivisionByZero)?;
+                // Reduce by haircut (haircut is in sell token, convert to buy token)
+                let haircut_in_buy = self
+                    .haircut_fee
+                    .checked_mul(prices.sell)
+                    .ok_or(Math::Overflow)?
+                    .checked_div(prices.buy)
+                    .ok_or(Math::DivisionByZero)?;
+                base.checked_sub(haircut_in_buy).ok_or(Math::Negative)?
+            }
         };
         Ok(eth::TokenAmount(amount))
     }
 
-    /// Computes the haircut amount in sell token for use in custom_prices().
-    /// This applies haircut to pricing while keeping sell_amount() clean for
-    /// reporting.
+    /// Computes the haircut amount in sell token.
+    /// Used for buy orders to add haircut to the sell amount.
     fn haircut_in_sell_token(&self, prices: &ClearingPrices) -> Result<eth::U256, error::Math> {
         match self.order.side {
             order::Side::Sell => Ok(self.haircut_fee),
@@ -261,21 +284,18 @@ impl Fulfillment {
         }
     }
 
+    /// Computes custom clearing prices for this trade.
+    ///
+    /// Note: This function relies on `sell_amount()` and `buy_amount()` to
+    /// correctly incorporate all adjustments (fees, haircuts). No additional
+    /// modifications are applied here.
     pub fn custom_prices(
         &self,
         prices: &ClearingPrices,
     ) -> Result<CustomClearingPrices, error::Math> {
-        // Include haircut in custom prices for quotes/scoring.
-        // This makes bids more conservative without affecting the actual
-        // reported sell_amount (which is used for user-facing reporting).
-        let haircut = self.haircut_in_sell_token(prices)?;
         Ok(CustomClearingPrices {
             sell: self.buy_amount(prices)?.into(),
-            buy: self
-                .sell_amount(prices)?
-                .0
-                .checked_add(haircut)
-                .ok_or(Math::Overflow)?,
+            buy: self.sell_amount(prices)?.into(),
         })
     }
 
diff --git a/crates/driver/src/domain/quote.rs b/crates/driver/src/domain/quote.rs
index ad513d0bfc..ee25380a40 100644
--- a/crates/driver/src/domain/quote.rs
+++ b/crates/driver/src/domain/quote.rs
@@ -68,10 +68,8 @@ impl Quote {
     /// Compute clearing prices for the quote.
     ///
     /// Uses uniform clearing prices from the solution, adjusted for haircut
-    /// when enabled. This uses the same approach as settlement encoding:
-    /// `custom_prices()` which internally uses `sell_amount()` and
-    /// `buy_amount()` to include the haircut in the effective trade
-    /// amounts.
+    /// when enabled. Uses `custom_prices()` which includes haircut effects
+    /// to make quotes conservative for users.
     fn compute_clearing_prices(
         solution: &competition::Solution,
     ) -> Result<HashMap<eth::Address, eth::U256>, Error> {
diff --git a/crates/driver/src/tests/cases/haircut.rs b/crates/driver/src/tests/cases/haircut.rs
index 86093659e9..a4b6a60fbf 100644
--- a/crates/driver/src/tests/cases/haircut.rs
+++ b/crates/driver/src/tests/cases/haircut.rs
@@ -10,15 +10,20 @@ use {
             setup::{ab_order, ab_pool, ab_solution},
         },
     },
-    number::units::EthUnit,
+    number::{testing::ApproxEq, units::EthUnit},
 };
 
+/// Haircut in basis points used across tests (500 bps = 5%)
+const HAIRCUT_BPS: u32 = 500;
+
 /// Test that haircut correctly reduces the solution score for sell orders.
-/// The haircut adjusts clearing prices to report lower output amounts, making
-/// the bid more conservative.
+/// The haircut reduces the reported buy_amount, making the bid more
+/// conservative.
 ///
-/// Also verifies that the reported sell amount matches the user's signed
-/// sell amount exactly (fill-or-kill requires exact execution).
+/// Verifies that:
+/// - `executedSell == signedSellAmount` (fill-or-kill requires exact execution)
+/// - `executedBuy` with haircut < `executedBuy` without haircut (haircut
+///   reduces output)
 #[tokio::test]
 #[ignore]
 async fn order_haircut_reduces_score() {
@@ -60,7 +65,7 @@ async fn order_haircut_reduces_score() {
                 .solver_fee(Some(eth::U256::from(100))),
         )
         .solution(ab_solution())
-        .solvers(vec![tests::setup::test_solver().haircut_bps(500)])
+        .solvers(vec![tests::setup::test_solver().haircut_bps(HAIRCUT_BPS)])
         .done()
         .await;
 
@@ -82,6 +87,22 @@ async fn order_haircut_reduces_score() {
         percentage
     );
 
+    // Extract executedBuy from baseline (no haircut)
+    let solution_no_haircut = solve_no_haircut.solution();
+    let orders_no_haircut = solution_no_haircut
+        .get("orders")
+        .unwrap()
+        .as_object()
+        .unwrap();
+    let executed_buy_no_haircut = orders_no_haircut
+        .values()
+        .next()
+        .unwrap()
+        .get("executedBuy")
+        .and_then(|v| v.as_str())
+        .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+        .unwrap();
+
     // Verify that reported sell amount matches signed amount exactly.
     // Fill-or-kill orders require exact execution.
     let solution = solve_with_haircut.solution();
@@ -92,6 +113,11 @@ async fn order_haircut_reduces_score() {
             .and_then(|v| v.as_str())
             .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
             .unwrap();
+        let executed_buy = order_data
+            .get("executedBuy")
+            .and_then(|v| v.as_str())
+            .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+            .unwrap();
         let limit_sell = order_data
             .get("limitSell")
             .and_then(|v| v.as_str())
@@ -111,26 +137,39 @@ async fn order_haircut_reduces_score() {
             executed_sell,
             limit_sell
         );
+
+        // Verify haircut reduces executedBuy for sell orders by approximately
+        // HAIRCUT_BPS
+        let expected_buy =
+            executed_buy_no_haircut * eth::U256::from(10000 - HAIRCUT_BPS) / eth::U256::from(10000);
+        assert!(
+            executed_buy.is_approx_eq(&expected_buy, Some(0.01)),
+            "Sell order: executedBuy {} should be ~{}% of baseline {} (expected ~{})",
+            executed_buy,
+            100 - HAIRCUT_BPS / 100,
+            executed_buy_no_haircut,
+            expected_buy
+        );
     }
 }
 
 /// Test that haircut is properly applied for buy orders.
-/// For buy orders, the haircut reduces the effective buy amount, which
-/// increases the sell amount the user pays. This reduces surplus and thus the
-/// score. Note: The percentage reduction for buy orders differs from sell
-/// orders because the haircut is applied to the executed buy amount, not
-/// directly to surplus.
+/// For buy orders, the haircut increases the sell_amount the user pays.
+/// This reduces surplus and thus the score.
 ///
-/// Also verifies that:
+/// Verifies that:
 /// - `executedBuy == signedBuyAmount` (fill-or-kill must execute exactly)
-/// - `executedSell <= sellLimit` (don't take more than user's maximum)
+/// - `executedSell <= sellLimit` (haircut increases sell, but must stay within
+///   limit)
+/// - `executedSell` with haircut > `executedSell` without haircut (haircut
+///   increases cost)
 #[tokio::test]
 #[ignore]
 async fn buy_order_haircut() {
     let side = order::Side::Buy;
     let kind = order::Kind::Limit;
     let signed_buy_amount = 2u64.eth();
-    let sell_limit = 100u64.ether().into_wei();
+    let signed_sell_limit = 100u64.ether().into_wei();
 
     // For buy orders, we need to set a buy_amount that creates enough surplus.
     // The pool has 100000:6000 ratio. For a buy order wanting 2.97 B,
@@ -143,7 +182,7 @@ async fn buy_order_haircut() {
                 .side(side)
                 .kind(kind)
                 .buy_amount(signed_buy_amount) // Target buy amount (what user signs for)
-                .sell_amount(sell_limit) // Generous sell limit creates surplus
+                .sell_amount(signed_sell_limit) // Generous sell limit creates surplus
                 .solver_fee(Some(eth::U256::from(100))),
         )
         .solution(ab_solution())
@@ -162,11 +201,11 @@ async fn buy_order_haircut() {
                 .side(side)
                 .kind(kind)
                 .buy_amount(signed_buy_amount) // Same target buy amount
-                .sell_amount(sell_limit) // Same generous sell limit
+                .sell_amount(signed_sell_limit) // Same generous sell limit
                 .solver_fee(Some(eth::U256::from(100))),
         )
         .solution(ab_solution())
-        .solvers(vec![tests::setup::test_solver().haircut_bps(500)])
+        .solvers(vec![tests::setup::test_solver().haircut_bps(HAIRCUT_BPS)])
         .done()
         .await;
 
@@ -194,6 +233,22 @@ async fn buy_order_haircut() {
         percentage
     );
 
+    // Extract executedSell from baseline (no haircut)
+    let solution_no_haircut = solve_no_haircut.solution();
+    let orders_no_haircut = solution_no_haircut
+        .get("orders")
+        .unwrap()
+        .as_object()
+        .unwrap();
+    let executed_sell_no_haircut = orders_no_haircut
+        .values()
+        .next()
+        .unwrap()
+        .get("executedSell")
+        .and_then(|v| v.as_str())
+        .and_then(|s| eth::U256::from_str_radix(s, 10).ok())
+        .unwrap();
+
     // Verify buy order constraints:
     // - Fill-or-kill must execute exactly (executedBuy == signedBuyAmount)
     // - Don't take more than user's maximum (executedSell <= sellLimit)
@@ -224,11 +279,11 @@ async fn buy_order_haircut() {
             signed_buy_amount
         );
         assert!(
-            executed_sell <= sell_limit,
-            "Buy order: executedSell {} exceeds sell limit {}. Haircut should reduce surplus, not \
-             inflate sell amount!",
+            executed_sell <= signed_sell_limit,
+            "Buy order: executedSell {} exceeds sell limit {}. Haircut increases sell_amount but \
+             it must still respect the user's limit!",
             executed_sell,
-            sell_limit
+            signed_sell_limit
         );
         assert!(
             executed_sell <= limit_sell,
@@ -236,5 +291,19 @@ async fn buy_order_haircut() {
             executed_sell,
             limit_sell
         );
+
+        // Verify haircut increases executedSell for buy orders.
+        // For buy orders, haircut increases the sell amount proportionally.
+        let haircut_ratio = 1.0 + (HAIRCUT_BPS as f64 / 10000.0); // ~1.05 for 500 bps
+        let expected_sell =
+            eth::U256::from((executed_sell_no_haircut.to::<u128>() as f64 * haircut_ratio) as u128);
+        assert!(
+            executed_sell.is_approx_eq(&expected_sell, Some(0.02)),
+            "Buy order: executedSell {} should be ~{:.1}% higher than baseline {} (expected ~{})",
+            executed_sell,
+            (haircut_ratio - 1.0) * 100.0,
+            executed_sell_no_haircut,
+            expected_sell
+        );
     }
 }
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index ed71e6e609..d4de694f72 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -57,19 +57,21 @@ async fn local_node_no_liquidity_limit_order() {
     run_test(no_liquidity_limit_order).await;
 }
 
-/// Test that sell orders with haircut configured still execute on-chain.
-/// The haircut reduces the reported surplus but the order should still be
-/// fillable and execute successfully.
+/// Test that sell orders with haircut configured execute on-chain with
+/// haircutted amounts. The haircut reduces both the reported buy_amount and
+/// the on-chain buy_amount (they should match). User receives less than
+/// without haircut, with the difference going to the settlement contract.
 #[tokio::test]
 #[ignore]
 async fn local_node_limit_order_with_haircut() {
     run_test(sell_order_with_haircut_test).await;
 }
 
-/// Test that buy orders with haircut configured still execute on-chain.
-/// For buy orders, verifies that:
-/// - executedBuy >= signedBuyAmount (user gets at least what they signed for)
-/// - executedSell <= sellLimit (don't take more than user's maximum)
+/// Test that buy orders with haircut configured execute on-chain with
+/// haircutted amounts. The haircut increases both the reported sell_amount and
+/// the on-chain sell_amount (they should match). Verifies that:
+/// - executedBuy == signedBuyAmount (user gets exactly what they signed for)
+/// - executedSell includes haircut (but still <= sellLimit)
 #[tokio::test]
 #[ignore]
 async fn local_node_buy_order_with_haircut() {
@@ -1182,9 +1184,10 @@ async fn no_liquidity_limit_order(web3: Web3) {
     assert!(balance_after.checked_sub(balance_before).unwrap() >= 5u64.eth());
 }
 
-/// Test that a limit order with haircut configured still executes on-chain.
-/// The haircut adjusts clearing prices to report lower surplus, but the order
-/// should still be fillable since the limit price allows for enough slack.
+/// Test that a limit order with haircut configured executes on-chain with
+/// haircutted amounts. The haircut reduces the buy_amount the user receives,
+/// both in reported amounts and on-chain execution (they should match).
+/// The haircut difference goes to the settlement contract.
 async fn sell_order_with_haircut_test(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -1299,9 +1302,9 @@ async fn sell_order_with_haircut_test(web3: Web3) {
     .await
     .unwrap();
 
-    // Verify that haircut (positive slippage) remains in the settlement contract.
-    // The haircut is 500 bps (5%) of the executed sell amount (10 ETH).
-    // At 1:1 pool ratio, this is approximately 0.5 ETH worth of token_b.
+    // Verify that haircut DOES affect on-chain execution.
+    // The haircut reduces the buy_amount the user receives, with the difference
+    // going to the settlement contract.
     let trader_balance_after = token_b.balanceOf(trader_a.address()).call().await.unwrap();
     let settlement_balance_after = token_b
         .balanceOf(*onchain.contracts().gp_settlement.address())
@@ -1316,20 +1319,19 @@ async fn sell_order_with_haircut_test(web3: Web3) {
         .checked_sub(settlement_balance_before)
         .unwrap();
 
-    // Expected haircut: 5% of 10 ETH sell amount = 0.5 ETH (in buy token terms at
-    // ~1:1 ratio). Allow some tolerance for fees and rounding.
+    // With 500 bps (5%) haircut on ~9.87 ETH buy amount, settlement should receive
+    // ~0.49 ETH. Allow some tolerance for AMM fees and rounding.
     assert!(
         settlement_received >= 0.4.eth() && settlement_received <= 0.6.eth(),
-        "Settlement contract should have received haircut (positive slippage) between 0.4 and 0.6 \
-         ETH, but got {}",
+        "Settlement contract should have received haircut (~0.49 ETH), but got {}",
         settlement_received
     );
 
-    // Expected trader amount: output (~9.87 ETH at 1:1 ratio with 0.3% fee)
-    // minus haircut (~0.5 ETH) = ~9.37 ETH. Allow tolerance for rounding.
+    // Expected trader amount: AMM output minus haircut (~9.87 - 0.49 = ~9.38 ETH).
+    // Haircut reduces what trader receives on-chain.
     assert!(
         trader_received >= 9u64.eth() && trader_received <= 9.5.eth(),
-        "Trader should have received between 9 and 9.5 ETH (AMM output minus haircut), but got {}",
+        "Trader should have received AMM output minus haircut (~9.38 ETH), but got {}",
         trader_received
     );
 
@@ -1379,7 +1381,8 @@ async fn sell_order_with_haircut_test(web3: Web3) {
 /// Test that a buy order with haircut configured executes correctly.
 /// For buy orders, the user signs for a specific buy_amount they want to
 /// receive, and sell_amount is the maximum they're willing to pay.
-/// Verifies that reported amounts respect these constraints.
+/// Haircut increases the sell_amount on-chain (user pays more).
+/// Verifies that reported amounts match on-chain execution.
 async fn buy_order_with_haircut_test(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -1543,15 +1546,15 @@ async fn buy_order_with_haircut_test(web3: Web3) {
         sell_limit_u256
     );
 
-    // 3. Reported sell_amount should be close to what's actually needed (~5.04 ETH
-    //    for buying 5 ETH at 1:1 with 0.3% fee).
-    // We check that sell_amount is less than 5.2 ETH (5.0 ETH + 5% haircut = 5.25
-    // ETH).
-    let reasonable_max_sell = U256::from(5_200_000_000_000_000_000u128); // 5.2 ETH
+    // 3. For buy orders, haircut INCREASES sell_amount (user pays more). Base
+    //    needed is ~5.04 ETH, with 5% haircut on 5 ETH buy amount = 0.25 ETH. So
+    //    sell_amount should be ~5.04 + 0.25 = ~5.29 ETH. We allow up to 5.5 ETH to
+    //    account for variance.
+    let reasonable_max_sell = 5.5.eth();
     assert!(
         reported_sell_amount <= reasonable_max_sell,
-        "Driver reported sell_amount {} exceeds expected max {} (actual needed is ~5.04 ETH). \
-         Haircut should reduce surplus/score, not inflate the reported sell amount!",
+        "Driver reported sell_amount {} exceeds expected max {} (actual needed + haircut is ~5.29 \
+         ETH)",
         reported_sell_amount,
         reasonable_max_sell
     );

From 05d199675ad5e9a48c4a9fc1e6e77312bf8a607f Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Mon, 2 Feb 2026 17:55:31 +0100
Subject: [PATCH 025/219] Support fractional vol fee bips in orderbook (#4112)

# Description

We were rounding fractional bips (e.g. `0.3`) to zero. This PR increases
the scale so we can handle basis point values lower than 0. At this
moment we have volume fee overrides for correlated assets sets to 0.3
and it works fine in autopilot, but /quote endpoint rounds to zero
instead, so this fix is needed.

## How to test

Unit tests & I tested by deploying this branch to staging.

---------

Co-authored-by: ilya <ilya@cow.fi>
---
 crates/orderbook/src/quoter.rs | 58 ++++++++++++++++++++++++++++++----
 crates/shared/src/arguments.rs | 48 +++++++++++++++++++++++++---
 2 files changed, 94 insertions(+), 12 deletions(-)

diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs
index b7ffde175f..ceec043b5d 100644
--- a/crates/orderbook/src/quoter.rs
+++ b/crates/orderbook/src/quoter.rs
@@ -228,14 +228,18 @@ fn get_vol_fee_adjusted_quote_data(
     // Calculate the volume (surplus token amount) to apply fee to
     // Following driver's logic in
     // crates/driver/src/domain/competition/solution/fee.rs:189-202:
+    // Use high precision scaling to support sub-basis-point fee factors (e.g., 0.3
+    // BPS)
+    let scaled_factor = U256::from(factor.to_high_precision());
+    let scale = U512::from(FeeFactor::HIGH_PRECISION_SCALE);
     let (adjusted_sell_amount, adjusted_buy_amount) = match side {
         OrderQuoteSide::Sell { .. } => {
             // For SELL orders, fee is calculated on buy amount
             let protocol_fee = U256::uint_try_from(
                 quote
                     .buy_amount
-                    .widening_mul(U256::from(factor.to_bps()))
-                    .checked_div(U512::from(FeeFactor::MAX_BPS))
+                    .widening_mul(scaled_factor)
+                    .checked_div(scale)
                     .ok_or_else(|| anyhow::anyhow!("volume fee calculation division by zero"))?,
             )
             .map_err(|_| anyhow::anyhow!("volume fee calculation overflow"))?;
@@ -249,11 +253,10 @@ fn get_vol_fee_adjusted_quote_data(
             // For BUY orders, fee is calculated on sell amount + network fee.
             // Network fee is already in sell token, so it is added to get the total volume.
             let total_sell_volume = quote.sell_amount.saturating_add(quote.fee_amount);
-            let factor = U256::from(factor.to_bps());
-            let volume_bps: Uint<512, 8> = total_sell_volume.widening_mul(factor);
+            let volume_scaled: Uint<512, 8> = total_sell_volume.widening_mul(scaled_factor);
             let protocol_fee = U256::uint_try_from(
-                volume_bps
-                    .checked_div(U512::from(FeeFactor::MAX_BPS))
+                volume_scaled
+                    .checked_div(scale)
                     .ok_or_else(|| anyhow::anyhow!("volume fee calculation division by zero"))?,
             )
             .map_err(|_| anyhow::anyhow!("volume fee calculation overflow"))?;
@@ -268,7 +271,7 @@ fn get_vol_fee_adjusted_quote_data(
     Ok(AdjustedQuoteData {
         sell_amount: adjusted_sell_amount,
         buy_amount: adjusted_buy_amount,
-        protocol_fee_bps: Some(factor.to_bps().to_string()),
+        protocol_fee_bps: Some(factor.to_bps_str()),
     })
 }
 
@@ -568,4 +571,45 @@ mod tests {
         assert_eq!(result.buy_amount, 100u64.eth());
         assert_eq!(result.protocol_fee_bps, None);
     }
+
+    #[test]
+    fn test_volume_fee_sub_basis_point_precision() {
+        // Test sub-BPS precision: 0.00003 = 0.3 BPS
+        let volume_fee = FeeFactor::try_from(0.00003).unwrap();
+        let volume_fee_config = VolumeFeeConfig {
+            factor: Some(volume_fee),
+            effective_from_timestamp: None,
+        };
+        let volume_fee_policy = VolumeFeePolicy::new(vec![], Some(volume_fee), false);
+
+        // Large amount to make the sub-BPS fee visible
+        let sell_amount = 1_000_000u64.eth();
+        let buy_amount = 1_000_000u64.eth();
+        let quote = create_test_quote(sell_amount, buy_amount);
+        let side = OrderQuoteSide::Sell {
+            sell_amount: model::quote::SellAmount::BeforeFee {
+                value: number::nonzero::NonZeroU256::try_from(sell_amount).unwrap(),
+            },
+        };
+
+        let result = get_vol_fee_adjusted_quote_data(
+            &quote,
+            &side,
+            Some(&volume_fee_config),
+            &volume_fee_policy,
+            TEST_BUY_TOKEN,
+            TEST_SELL_TOKEN,
+        )
+        .unwrap();
+
+        // Protocol fee = 0.3 BPS
+        assert_eq!(result.protocol_fee_bps, Some("0.3".to_string()));
+        assert_eq!(result.sell_amount, sell_amount);
+
+        // Expected fee: 1_000_000 * 0.00003 = 30 tokens
+        // buy_amount should be reduced by 30 tokens
+        let expected_fee = 30u64.eth();
+        let expected_buy = buy_amount - expected_fee;
+        assert_eq!(result.buy_amount, expected_buy);
+    }
 }
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 46f542e195..9f9238f006 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -549,17 +549,30 @@ impl FromStr for ExternalSolver {
 pub struct FeeFactor(f64);
 
 impl FeeFactor {
-    /// Number of basis points that make up 100%.
-    pub const MAX_BPS: u32 = 10_000;
+    /// High precision scale factor (1 million) for sub-basis-point precision.
+    /// Allows representing factors like 0.00003 (0.3 BPS) without rounding to
+    /// 0. Also used for converting to BPS string with 2 decimal precision
+    /// (1_000_000 / 100 = 10_000 BPS scale).
+    pub const HIGH_PRECISION_SCALE: u64 = 1_000_000;
 
     pub fn new(factor: f64) -> Self {
         Self(factor)
     }
 
     /// Converts the fee factor to basis points (BPS).
-    /// For example, 0.0002 -> 2 BPS
-    pub fn to_bps(&self) -> u64 {
-        (self.0 * f64::from(Self::MAX_BPS)).round() as u64
+    /// Supports fractional BPS values (e.g., 0.00003 -> "0.3")
+    /// Rounds to 2 decimal places to avoid floating point representation
+    /// issues.
+    pub fn to_bps_str(&self) -> String {
+        let bps = (self.0 * Self::HIGH_PRECISION_SCALE as f64).round() / 100.0;
+        format!("{bps}")
+    }
+
+    /// Converts the fee factor to a high precision scaled integer.
+    /// For example, 0.00003 -> 30 (with scale of 1_000_000)
+    /// This allows sub-basis-point precision in calculations.
+    pub fn to_high_precision(&self) -> u64 {
+        (self.0 * Self::HIGH_PRECISION_SCALE as f64).round() as u64
     }
 
     /// Get the inner value
@@ -714,4 +727,29 @@ mod test {
             .is_err()
         );
     }
+
+    #[test]
+    fn fee_factor_to_bps() {
+        assert_eq!(FeeFactor::new(0.0001).to_bps_str(), "1");
+        assert_eq!(FeeFactor::new(0.001).to_bps_str(), "10");
+
+        // Fractional BPS values (sub-basis-point precision)
+        assert_eq!(FeeFactor::new(0.00003).to_bps_str(), "0.3");
+        assert_eq!(FeeFactor::new(0.00005).to_bps_str(), "0.5");
+        assert_eq!(FeeFactor::new(0.000025).to_bps_str(), "0.25");
+        assert_eq!(FeeFactor::new(0.000075).to_bps_str(), "0.75");
+        assert_eq!(FeeFactor::new(0.00015).to_bps_str(), "1.5");
+
+        assert_eq!(FeeFactor::new(0.0).to_bps_str(), "0");
+    }
+
+    #[test]
+    fn fee_factor_to_high_precision() {
+        // Verify high precision scaling
+        assert_eq!(FeeFactor::new(0.00003).to_high_precision(), 30);
+        assert_eq!(FeeFactor::new(0.0001).to_high_precision(), 100);
+        assert_eq!(FeeFactor::new(0.001).to_high_precision(), 1000);
+        assert_eq!(FeeFactor::new(0.01).to_high_precision(), 10_000);
+        assert_eq!(FeeFactor::new(0.1).to_high_precision(), 100_000);
+    }
 }

From 5690fc4de0d92f330a25e2d379c406ad78657ae3 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 3 Feb 2026 09:11:26 +0100
Subject: [PATCH 026/219] Improve autopilot maintenance (#4113)

# Description
While looking into the degraded time to happy moo SLI it became apparent
that ethflow orders have a significantly worse SLI compared to "regular"
orders.
Ethflow orders are not harder to solve for than any other orders but
they are special in the way they enter the system. Instead of having a
REST API call that puts those orders into the DB they get placed by
calling the ethflow contract onchain. The autopilot then indexes those
events and puts them into the DB.

Since the autopilot run loop is synced to the block chain (start a new
auction right after seeing a new block) ethflow orders are comparable to
regular orders that ALWAYS get placed at the worst possible time
(immediately before cutting the auction).

Due to being overwhelmed with indexing ethflow orders because of a trade
inventive we moved ethflow indexing off of the critical path (see
[here](https://github.com/cowprotocol/services/pull/3849)) but that also
had the consequence of more ethflow orders not making it into the first
possible auction which immediately delays them at least by 12s.

# Changes
This PR puts ethflow order indexing back on the critical path while
still avoiding the issue that caused us to move it off the critical path
in the first place.
Instead of having a system where the autopilot triggers the maintenance
to happen before a new auction or after new block appearing (when
waiting for submitted solutions) with an additional background task that
checks every second for new ethflow orders that need indexing.
This PR moves autopilot maintenance (i.e. block indexing) completely
into a background task which triggers ASAP when the system sees a new
block. In order to build the auction only after the blocks have been
indexed this background tasks feeds a channel of processed blocks. The
autopilot then only has to wait for this channel to yield a block with a
high enough block number.

So the properties of the new solutions are:
* event indexing has as little delay as possible
* indexing runs concurrently so it's as fast as possible (without
speeding up the individual code paths)
* autopilot can wait for data from a given block to be processed fully
* autopilot stops waiting after a configurable amount of time to keep
running auctions even if indexing is slow for whatever reason

## How to test
Covered by existing e2e tests
---
 Cargo.lock                          |   1 +
 crates/autopilot/Cargo.toml         |   1 +
 crates/autopilot/src/maintenance.rs | 163 +++++++++++++++++-----------
 crates/autopilot/src/run.rs         |  15 ++-
 crates/autopilot/src/run_loop.rs    |  15 +--
 5 files changed, 113 insertions(+), 82 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bad5e2cfac..ff0a319dcd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1203,6 +1203,7 @@ dependencies = [
  "thiserror 1.0.69",
  "tikv-jemallocator",
  "tokio",
+ "tokio-stream",
  "tower 0.4.13",
  "tower-http 0.4.4",
  "tracing",
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index c75a4ad24b..4d293dff5b 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -59,6 +59,7 @@ sqlx = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
+tokio-stream = { workspace = true }
 tower = { workspace = true }
 tower-http = { workspace = true, features = ["trace"] }
 tracing = { workspace = true }
diff --git a/crates/autopilot/src/maintenance.rs b/crates/autopilot/src/maintenance.rs
index 766d6a8b70..ff3c4ca74f 100644
--- a/crates/autopilot/src/maintenance.rs
+++ b/crates/autopilot/src/maintenance.rs
@@ -25,9 +25,45 @@ use {
         sync::Arc,
         time::{Duration, Instant},
     },
-    tokio::sync::Mutex,
+    tokio::sync::watch,
+    tokio_stream::wrappers::WatchStream,
 };
 
+/// Component to sync with the maintenance logic that runs in a background task.
+/// This allows us to run the maintenance logic ASAP but still wait for it to
+/// finish in a convenient manner.
+#[derive(Clone)]
+pub struct MaintenanceSync {
+    /// How long the autopilot wants to wait at most.
+    timeout: Duration,
+    last_processed_block: watch::Receiver<u64>,
+}
+
+impl MaintenanceSync {
+    pub async fn wait_until_block_processed(&self, block: u64) {
+        let _timer = observe::metrics::metrics()
+            .on_auction_overhead_start("autopilot", "wait_for_maintenance");
+
+        if let Err(_timeout) = tokio::time::timeout(self.timeout, self.wait_inner(block)).await {
+            tracing::debug!("timed out waiting for maintenance");
+        }
+    }
+
+    async fn wait_inner(&self, target_block: u64) {
+        if *self.last_processed_block.borrow() >= target_block {
+            return;
+        }
+
+        let mut stream = WatchStream::new(self.last_processed_block.clone());
+        loop {
+            let processed_block = stream.next().await.unwrap();
+            if processed_block >= target_block {
+                return;
+            }
+        }
+    }
+}
+
 /// Coordinates all the updates that need to run a new block
 /// to ensure a consistent view of the system.
 pub struct Maintenance {
@@ -38,56 +74,70 @@ pub struct Maintenance {
     db_cleanup: Postgres,
     /// All indexing tasks to keep cow amms up to date.
     cow_amm_indexer: Vec<Arc<dyn Maintaining>>,
-    /// On which block we last ran an update successfully.
-    last_processed: Mutex<BlockInfo>,
-    /// Limits the amount of time the autopilot may spend running the
-    /// maintenance logic between 2 auctions. When this times out we prefer
-    /// running a not fully updated auction over stalling the protocol any
-    /// further.
-    timeout: Duration,
+    /// Tasks to index ethflow orders that were submitted onchain.
+    ethflow_indexer: Vec<EthflowIndexer>,
 }
 
 impl Maintenance {
     pub fn new(
         settlement_indexer: EventUpdater<Indexer, GPv2SettlementContract>,
         db_cleanup: Postgres,
-        timeout: Duration,
     ) -> Self {
         Self {
             settlement_indexer,
             db_cleanup,
             cow_amm_indexer: Default::default(),
-            last_processed: Default::default(),
-            timeout,
+            ethflow_indexer: Default::default(),
         }
     }
 
-    /// Runs all update tasks in a coordinated manner to ensure the system
-    /// has a consistent state.
-    pub async fn update(&self, new_block: &BlockInfo) {
-        let mut last_block = self.last_processed.lock().await;
-        metrics().last_seen_block.set(new_block.number);
-        if last_block.number > new_block.number || last_block.hash == new_block.hash {
-            // `new_block` is neither newer than `last_block` nor a reorg
-            return;
+    /// Spawns a background task continously processing the latest block.
+    /// Returns a `[MaintenanceSync]` that handles waiting for a specific
+    /// block to be processed.
+    pub fn spawn_maintenance_task(
+        self,
+        blocks: CurrentBlockWatcher,
+        timeout: Duration,
+    ) -> MaintenanceSync {
+        let (sender, receiver) = watch::channel(blocks.borrow().number);
+
+        tokio::task::spawn(async move {
+            let mut stream = into_stream(blocks);
+            loop {
+                let block = stream
+                    .next()
+                    .await
+                    .expect("block stream terminated unexpectedly");
+                self.index_until_block(block, &sender).await;
+            }
+        });
+
+        MaintenanceSync {
+            last_processed_block: receiver,
+            timeout,
         }
+    }
 
+    async fn index_until_block(&self, block: BlockInfo, last_processed_block: &watch::Sender<u64>) {
+        metrics().last_seen_block.set(block.number);
         let start = Instant::now();
 
-        if let Err(err) = tokio::time::timeout(self.timeout, self.update_inner()).await {
-            tracing::warn!(?err, block = new_block.number, "failed to run maintenance");
+        if let Err(err) = self.update_inner().await {
+            tracing::warn!(?err, block = block.number, "failed to run maintenance");
             metrics().updates.with_label_values(&["error"]).inc();
             return;
         }
+
         tracing::info!(
-            block = new_block.number,
+            block = block.number,
             time = ?start.elapsed(),
             "successfully ran maintenance task"
         );
-
+        metrics().last_updated_block.set(block.number);
         metrics().updates.with_label_values(&["success"]).inc();
-        metrics().last_updated_block.set(new_block.number);
-        *last_block = *new_block;
+        if let Err(err) = last_processed_block.send(block.number) {
+            tracing::warn!(?err, "nobody listening for processed blocks anymore");
+        }
     }
 
     async fn update_inner(&self) -> Result<()> {
@@ -99,6 +149,22 @@ impl Maintenance {
                 self.settlement_indexer.run_maintenance()
             ),
             Self::timed_future("db_cleanup", self.db_cleanup.run_maintenance()),
+            Self::timed_future(
+                "cow_amm_indexer",
+                futures::future::try_join_all(
+                    self.cow_amm_indexer
+                        .iter()
+                        .map(|indexer| indexer.run_maintenance()),
+                ),
+            ),
+            Self::timed_future(
+                "ethflow_indexer",
+                futures::future::try_join_all(
+                    self.ethflow_indexer
+                        .iter()
+                        .map(|indexer| indexer.run_maintenance()),
+                ),
+            ),
         )?;
 
         Ok(())
@@ -106,18 +172,15 @@ impl Maintenance {
 
     /// Registers all maintenance tasks that are necessary to correctly support
     /// ethflow orders.
-    pub fn spawn_ethflow_indexer(&mut self, ethflow_indexer: EthflowIndexer) {
-        tokio::task::spawn(async move {
-            loop {
-                let _ =
-                    Self::timed_future("ethflow_indexer", ethflow_indexer.run_maintenance()).await;
-                tokio::time::sleep(std::time::Duration::from_millis(1_000)).await;
-            }
-        });
+    pub fn add_ethflow_indexer(&mut self, ethflow_indexer: EthflowIndexer) {
+        self.ethflow_indexer.push(ethflow_indexer);
     }
 
-    pub fn with_cow_amms(&mut self, registry: &cow_amm::Registry) {
-        self.cow_amm_indexer = registry.maintenance_tasks().clone();
+    /// Registers all maintenance tasks that are necessary to correctly support
+    /// CoW AMMs.
+    pub fn add_cow_amm_indexer(&mut self, registry: &cow_amm::Registry) {
+        self.cow_amm_indexer
+            .extend(registry.maintenance_tasks().clone());
     }
 
     /// Runs the future and collects runtime metrics.
@@ -129,36 +192,6 @@ impl Maintenance {
         let _timer2 = observe::metrics::metrics().on_auction_overhead_start("autopilot", label);
         fut.await
     }
-
-    /// Spawns a background task that runs on every new block but also
-    /// at least after every `update_interval`.
-    pub fn spawn_cow_amm_indexing_task(self_: Arc<Self>, current_block: CurrentBlockWatcher) {
-        tokio::task::spawn(async move {
-            let mut stream = into_stream(current_block);
-            loop {
-                let _ = match stream.next().await {
-                    Some(block) => {
-                        metrics().last_seen_block.set(block.number);
-                        block
-                    }
-                    None => panic!("block stream terminated unexpectedly"),
-                };
-
-                // TODO: move this back into `Self::update_inner()` once we
-                // store cow amms in the DB to avoid incredibly slow restarts.
-                let _ = Self::timed_future(
-                    "cow_amm_indexer",
-                    futures::future::try_join_all(
-                        self_
-                            .cow_amm_indexer
-                            .iter()
-                            .map(|indexer| async move { indexer.run_maintenance().await }),
-                    ),
-                )
-                .await;
-            }
-        });
-    }
 }
 
 type EthflowIndexer =
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 9784938a5f..3faef30513 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -577,12 +577,8 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     let trusted_tokens =
         AutoUpdatingTokenList::from_configuration(market_makable_token_list_configuration).await;
 
-    let mut maintenance = Maintenance::new(
-        settlement_event_indexer,
-        db_write.clone(),
-        args.max_maintenance_timeout,
-    );
-    maintenance.with_cow_amms(&cow_amm_registry);
+    let mut maintenance = Maintenance::new(settlement_event_indexer, db_write.clone());
+    maintenance.add_cow_amm_indexer(&cow_amm_registry);
 
     if !args.ethflow_contracts.is_empty() {
         let ethflow_refund_start_block = determine_ethflow_refund_indexing_start(
@@ -638,7 +634,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .await
         .expect("Should be able to initialize event updater. Database read issues?");
 
-        maintenance.spawn_ethflow_indexer(onchain_order_indexer);
+        maintenance.add_ethflow_indexer(onchain_order_indexer);
         // refunds are not critical for correctness and can therefore be indexed
         // sporadically in a background task
         let service_maintainer = ServiceMaintenance::new(vec![Arc::new(refund_event_handler)]);
@@ -679,6 +675,9 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .into_iter()
         .collect();
 
+    let awaiter = maintenance
+        .spawn_maintenance_task(eth.current_block().clone(), args.max_maintenance_timeout);
+
     let run = RunLoop::new(
         run_loop_config,
         eth,
@@ -690,7 +689,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
             liveness: liveness.clone(),
             startup,
         },
-        Arc::new(maintenance),
+        awaiter,
     );
     run.run_forever(shutdown_controller).await;
 
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 0b2ef60f33..7a8a0be012 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -19,7 +19,7 @@ use {
             solvers::dto::{settle, solve},
         },
         leader_lock_tracker::LeaderLockTracker,
-        maintenance::Maintenance,
+        maintenance::MaintenanceSync,
         run::Liveness,
         shutdown_controller::ShutdownController,
         solvable_orders::SolvableOrdersCache,
@@ -82,7 +82,7 @@ pub struct RunLoop {
     probes: Probes,
     /// Maintenance tasks that should run before every runloop to have
     /// the most recent data available.
-    maintenance: Arc<Maintenance>,
+    maintenance: MaintenanceSync,
     winner_selection: winner_selection::Arbitrator,
     /// Notifier that wakes the main loop on new blocks or orders
     wake_notify: Arc<tokio::sync::Notify>,
@@ -98,7 +98,7 @@ impl RunLoop {
         solvable_orders_cache: Arc<SolvableOrdersCache>,
         trusted_tokens: AutoUpdatingTokenList,
         probes: Probes,
-        maintenance: Arc<Maintenance>,
+        maintenance: MaintenanceSync,
     ) -> Self {
         let max_winners = config.max_winners_per_auction.get();
         let weth = eth.contracts().wrapped_native_token();
@@ -125,11 +125,6 @@ impl RunLoop {
     }
 
     pub async fn run_forever(self, mut control: ShutdownController) {
-        Maintenance::spawn_cow_amm_indexing_task(
-            self.maintenance.clone(),
-            self.eth.current_block().clone(),
-        );
-
         let mut last_auction = None;
         let mut last_block = None;
 
@@ -263,7 +258,9 @@ impl RunLoop {
     /// the latest available state.
     async fn run_maintenance(&self, block: &BlockInfo) {
         let start = Instant::now();
-        self.maintenance.update(block).await;
+        self.maintenance
+            .wait_until_block_processed(block.number)
+            .await;
         Metrics::ran_maintenance(start.elapsed());
     }
 

From e68c266c4b6ba7cb5ac29d23c722d50feb9dc834 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 3 Feb 2026 12:38:13 +0000
Subject: [PATCH 027/219] Remove ethcontract+web3+primitive-types (#4106)

Completes the Alloy migration by removing the last remaining legacy
Ethereum libraries: `ethcontract`, `web3`, and `primitive-types`. These
dependencies are no longer needed and can be fully removed, simplifying
the dependency tree.

**Key change**: The labelling layer for observability now operates at
the `Web3` wrapper level instead of directly on `DynProvider`, ensuring
the wallet state is properly preserved when creating labeled provider
instances.

# Changes

- [x] Remove `ethcontract`, `web3`, and `primitive-types` from workspace
dependencies
- [x] Delete unused legacy ethrpc implementations (`buffered.rs`,
`http.rs`, `instrumented.rs`, `alloy/conversions.rs`)
- [x] Migrate `ProviderLabelingExt` from `DynProvider` to `Web3`
wrapper, preserving wallet state across labeled instances
- [x] Clean up ethrpc module structure and simplify exports
- [x] Update imports across affected crates to use Alloy types only
- [x] Remove legacy references from contract vendoring script and test
setup

## How to test
Existing tests
---
 Cargo.lock                                    | 194 +-----
 Cargo.toml                                    |   3 -
 README.md                                     |   3 +-
 crates/autopilot/Cargo.toml                   |   1 -
 crates/autopilot/src/boundary/mod.rs          |   6 +-
 crates/autopilot/src/infra/blockchain/mod.rs  |   2 -
 crates/autopilot/src/run.rs                   |  29 +-
 crates/contracts/src/bin/vendor.rs            |   4 -
 crates/driver/Cargo.toml                      |   2 -
 crates/driver/src/boundary/mod.rs             |   6 +-
 .../driver/src/infra/blockchain/contracts.rs  |   4 +-
 crates/driver/src/infra/blockchain/mod.rs     |  18 +-
 crates/driver/src/infra/config/file/mod.rs    |  10 -
 crates/driver/src/tests/setup/mod.rs          |   3 +-
 crates/e2e/tests/e2e/hooks.rs                 |  11 +-
 crates/ethrpc/Cargo.toml                      |   3 -
 crates/ethrpc/src/alloy/conversions.rs        | 173 -----
 crates/ethrpc/src/alloy/instrumentation.rs    |  31 +-
 crates/ethrpc/src/alloy/mod.rs                |  25 +-
 .../{block_stream/mod.rs => block_stream.rs}  |   6 +-
 crates/ethrpc/src/buffered.rs                 | 600 ------------------
 crates/ethrpc/src/http.rs                     | 305 ---------
 crates/ethrpc/src/instrumented.rs             | 151 -----
 crates/ethrpc/src/lib.rs                      | 108 +---
 crates/ethrpc/src/mock.rs                     | 182 +-----
 crates/orderbook/src/run.rs                   |  22 +-
 crates/refunder/src/lib.rs                    |   4 +-
 crates/shared/Cargo.toml                      |   2 -
 crates/shared/src/account_balances/mod.rs     |   4 +-
 .../shared/src/account_balances/simulation.rs |   4 +-
 .../src/bad_token/token_owner_finder/mod.rs   |   4 +-
 crates/shared/src/ethrpc.rs                   |  18 +-
 crates/shared/src/order_validation.rs         |   6 +-
 .../src/price_estimation/competition/quote.rs |  27 +-
 crates/shared/src/price_estimation/factory.rs |   4 +-
 .../trade_verifier/balance_overrides/mod.rs   |   4 +-
 .../src/signature_validator/simulation.rs     |  21 +-
 .../sources/balancer_v2/pool_fetching/mod.rs  |   7 +-
 .../src/sources/balancer_v2/pools/weighted.rs |   4 +-
 crates/shared/src/sources/uniswap_v2/mod.rs   |   3 +-
 .../src/sources/uniswap_v3/pool_fetching.rs   |   3 +-
 crates/solvers/src/domain/solver.rs           |   2 +-
 42 files changed, 133 insertions(+), 1886 deletions(-)
 delete mode 100644 crates/ethrpc/src/alloy/conversions.rs
 rename crates/ethrpc/src/{block_stream/mod.rs => block_stream.rs} (99%)
 delete mode 100644 crates/ethrpc/src/buffered.rs
 delete mode 100644 crates/ethrpc/src/http.rs
 delete mode 100644 crates/ethrpc/src/instrumented.rs

diff --git a/Cargo.lock b/Cargo.lock
index ff0a319dcd..f94928ee4f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -102,7 +102,7 @@ dependencies = [
  "k256",
  "once_cell",
  "rand 0.8.5",
- "secp256k1 0.30.0",
+ "secp256k1",
  "serde",
  "serde_json",
  "serde_with",
@@ -1209,7 +1209,6 @@ dependencies = [
  "tracing",
  "url",
  "vergen",
- "web3",
  "winner-selection",
 ]
 
@@ -2264,12 +2263,6 @@ dependencies = [
  "tracing-subscriber",
 ]
 
-[[package]]
-name = "convert_case"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
-
 [[package]]
 name = "convert_case"
 version = "0.6.0"
@@ -2597,19 +2590,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "derive_more"
-version = "0.99.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
-dependencies = [
- "convert_case 0.4.0",
- "proc-macro2",
- "quote",
- "rustc_version 0.4.1",
- "syn 2.0.114",
-]
-
 [[package]]
 name = "derive_more"
 version = "1.0.0"
@@ -2718,7 +2698,6 @@ dependencies = [
  "cow-amm",
  "dashmap",
  "derive_more 1.0.0",
- "ethcontract",
  "ethrpc",
  "futures",
  "hex-literal",
@@ -2755,7 +2734,6 @@ dependencies = [
  "tracing",
  "url",
  "vergen",
- "web3",
 ]
 
 [[package]]
@@ -2925,90 +2903,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "ethabi"
-version = "18.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7413c5f74cc903ea37386a8965a936cbeb334bd270862fdece542c1b2dcbc898"
-dependencies = [
- "ethereum-types",
- "hex",
- "once_cell",
- "regex",
- "serde",
- "serde_json",
- "sha3",
- "thiserror 1.0.69",
- "uint",
-]
-
-[[package]]
-name = "ethbloom"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c22d4b5885b6aa2fe5e8b9329fb8d232bf739e434e6b87347c63bdd00c120f60"
-dependencies = [
- "crunchy",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "tiny-keccak",
-]
-
-[[package]]
-name = "ethcontract"
-version = "0.25.9"
-source = "git+https://github.com/cowprotocol/ethcontract-rs?rev=8e112a88988040cde6110379ee6d1be768a13244#8e112a88988040cde6110379ee6d1be768a13244"
-dependencies = [
- "arrayvec",
- "aws-config",
- "aws-sdk-kms",
- "ethcontract-common",
- "futures",
- "futures-timer",
- "hex",
- "jsonrpc-core",
- "lazy_static",
- "primitive-types",
- "rlp",
- "secp256k1 0.27.0",
- "serde",
- "serde_json",
- "thiserror 1.0.69",
- "uint",
- "web3",
- "zeroize",
-]
-
-[[package]]
-name = "ethcontract-common"
-version = "0.25.9"
-source = "git+https://github.com/cowprotocol/ethcontract-rs?rev=8e112a88988040cde6110379ee6d1be768a13244#8e112a88988040cde6110379ee6d1be768a13244"
-dependencies = [
- "ethabi",
- "hex",
- "serde",
- "serde_derive",
- "serde_json",
- "thiserror 1.0.69",
- "tiny-keccak",
- "web3",
-]
-
-[[package]]
-name = "ethereum-types"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d215cbf040552efcbe99a38372fe80ab9d00268e20012b79fcd0f073edd8ee"
-dependencies = [
- "ethbloom",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "primitive-types",
- "uint",
-]
-
 [[package]]
 name = "ethrpc"
 version = "0.1.0"
@@ -3017,13 +2911,11 @@ dependencies = [
  "anyhow",
  "async-trait",
  "const-hex",
- "ethcontract",
  "futures",
  "itertools 0.14.0",
  "jsonrpc-core",
  "mockall",
  "observe",
- "primitive-types",
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
@@ -3036,7 +2928,6 @@ dependencies = [
  "tower 0.4.13",
  "tracing",
  "url",
- "web3",
 ]
 
 [[package]]
@@ -3931,16 +3822,6 @@ dependencies = [
  "unicode-normalization",
 ]
 
-[[package]]
-name = "idna"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -3971,24 +3852,6 @@ dependencies = [
  "parity-scale-codec",
 ]
 
-[[package]]
-name = "impl-rlp"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28220f89297a075ddc7245cd538076ee98b01f2a9c23a53a4f1105d5a322808"
-dependencies = [
- "rlp",
-]
-
-[[package]]
-name = "impl-serde"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc88fc67028ae3db0c853baa36269d398d5f45b6982f95549ff5def78c935cd"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "impl-trait-for-tuples"
 version = "0.2.3"
@@ -5179,8 +5042,6 @@ checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
 dependencies = [
  "fixed-hash",
  "impl-codec",
- "impl-rlp",
- "impl-serde",
  "uint",
 ]
 
@@ -6043,15 +5904,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "secp256k1"
-version = "0.27.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25996b82292a7a57ed3508f052cfff8640d38d32018784acd714758b43da9c8f"
-dependencies = [
- "secp256k1-sys 0.8.2",
-]
-
 [[package]]
 name = "secp256k1"
 version = "0.30.0"
@@ -6060,19 +5912,10 @@ checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
 dependencies = [
  "bitcoin_hashes",
  "rand 0.8.5",
- "secp256k1-sys 0.10.1",
+ "secp256k1-sys",
  "serde",
 ]
 
-[[package]]
-name = "secp256k1-sys"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4473013577ec77b4ee3668179ef1186df3146e2cf2d927bd200974c6fe60fd99"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "secp256k1-sys"
 version = "0.10.1"
@@ -6349,7 +6192,6 @@ dependencies = [
  "number",
  "observe",
  "order-validation",
- "primitive-types",
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
@@ -6367,7 +6209,6 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "url",
- "web3",
 ]
 
 [[package]]
@@ -7860,37 +7701,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "web3"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5388522c899d1e1c96a4c307e3797e0f697ba7c77dd8e0e625ecba9dd0342937"
-dependencies = [
- "arrayvec",
- "base64 0.21.7",
- "bytes",
- "derive_more 0.99.20",
- "ethabi",
- "ethereum-types",
- "futures",
- "futures-timer",
- "headers",
- "hex",
- "idna 0.4.0",
- "jsonrpc-core",
- "log",
- "once_cell",
- "parking_lot",
- "pin-project",
- "reqwest 0.11.27",
- "rlp",
- "secp256k1 0.27.0",
- "serde",
- "serde_json",
- "tiny-keccak",
- "url",
-]
-
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
diff --git a/Cargo.toml b/Cargo.toml
index d0c677d393..773660c1ac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,6 @@ clap = { version = "4.5.6", features = ["derive", "env"] }
 dashmap = "6.1.0"
 derivative = "2.2.0"
 derive_more = { version = "1.0.0", features = ["full"] }
-ethcontract = { git = "https://github.com/cowprotocol/ethcontract-rs", rev = "8e112a88988040cde6110379ee6d1be768a13244", default-features = false, features = ["aws-kms"] }
 mimalloc = "0.1.43"
 tikv-jemallocator = { version = "0.6", features = ["unprefixed_malloc_on_supported_platforms", "profiling"] }
 jemalloc_pprof = { version = "0.8", features = ["symbolize"] }
@@ -34,7 +33,6 @@ itertools = "0.14"
 maplit = "1.0.2"
 mockall = "0.12.1"
 num = "0.4.3"
-primitive-types = "0.12"
 prometheus = "0.13.4"
 prometheus-metric-storage = "0.5.0"
 rand = "0.8.5"
@@ -56,7 +54,6 @@ tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", features = ["json"] }
 url = "2.5.0"
 warp = { git = 'https://github.com/cowprotocol/warp.git', rev = "586244e", default-features = false }
-web3 = { version = "0.19.0", default-features = false }
 app-data = { path = "crates/app-data" }
 arc-swap = "1.7.1"
 async-stream = "0.3.5"
diff --git a/README.md b/README.md
index d7a257b7fe..4d5268fce2 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ The `autopilot` connects to the same PostgreSQL database as the `orderbook` and
 
 There are additional crates that live in the cargo workspace.
 
-- `contracts` provides _[ethcontract-rs](https://github.com/gnosis/ethcontract-rs)_ based smart contract bindings
+- `contracts` provides Alloy-based smart contract bindings
 - `database` provides the shared database and storage layer logic shared between the `autopilot` and `orderbook`
 - `driver` an in-development binary that intends to replace the `solver`; it has a slightly different design that allows co-location with external solvers
 - `e2e` end-to-end tests
@@ -160,4 +160,3 @@ Each process opens a UNIX socket at `/tmp/log_filter_override_<program_name>_<pi
 You can also reset the log filter to the filter the program was initially started with by entering `reset`.
 
 See [here](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives) for documentation on the supported log filter format.
-
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 4d293dff5b..e741776a36 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -64,7 +64,6 @@ tower = { workspace = true }
 tower-http = { workspace = true, features = ["trace"] }
 tracing = { workspace = true }
 url = { workspace = true }
-web3 = { workspace = true }
 winner-selection = { workspace = true }
 
 [dev-dependencies]
diff --git a/crates/autopilot/src/boundary/mod.rs b/crates/autopilot/src/boundary/mod.rs
index 698b827ae5..7142d7e8c0 100644
--- a/crates/autopilot/src/boundary/mod.rs
+++ b/crates/autopilot/src/boundary/mod.rs
@@ -29,11 +29,7 @@ pub mod order;
 
 /// Builds a web3 client based on the ethrpc args config.
 pub fn web3_client(ethrpc: &Url, ethrpc_args: &shared::ethrpc::Arguments) -> Web3 {
-    let http_factory =
-        shared::http_client::HttpClientFactory::new(&shared::http_client::Arguments {
-            http_timeout: std::time::Duration::from_secs(10),
-        });
-    shared::ethrpc::web3(ethrpc_args, &http_factory, ethrpc, "base")
+    shared::ethrpc::web3(ethrpc_args, ethrpc, "base")
 }
 
 pub struct SolvableOrders {
diff --git a/crates/autopilot/src/infra/blockchain/mod.rs b/crates/autopilot/src/infra/blockchain/mod.rs
index e3d136e5a8..b771441d45 100644
--- a/crates/autopilot/src/infra/blockchain/mod.rs
+++ b/crates/autopilot/src/infra/blockchain/mod.rs
@@ -178,8 +178,6 @@ impl From<alloy::rpc::types::trace::geth::CallFrame> for eth::CallFrame {
 
 #[derive(Debug, Error)]
 pub enum Error {
-    #[error("web3 error: {0:?}")]
-    Web3(#[from] web3::error::Error),
     #[error("alloy transport error: {0:?}")]
     Alloy(#[from] alloy::transports::TransportError),
     #[error("missing field {0}, node client bug?")]
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 3faef30513..2b0cad10d8 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -178,15 +178,12 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     crate::database::run_database_metrics_work(db_write.clone());
 
     let http_factory = HttpClientFactory::new(&args.http_client);
-    let web3 = shared::ethrpc::web3(
-        &args.shared.ethrpc,
-        &http_factory,
-        &args.shared.node_url,
-        "base",
-    );
-    let simulation_web3 = args.shared.simulation_node_url.as_ref().map(|node_url| {
-        shared::ethrpc::web3(&args.shared.ethrpc, &http_factory, node_url, "simulation")
-    });
+    let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
+    let simulation_web3 = args
+        .shared
+        .simulation_node_url
+        .as_ref()
+        .map(|node_url| shared::ethrpc::web3(&args.shared.ethrpc, node_url, "simulation"));
 
     let chain_id = web3
         .alloy
@@ -334,12 +331,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     let trace_call_detector = args.tracing_node_url.as_ref().map(|tracing_node_url| {
         CachingDetector::new(
             Box::new(TraceCallDetector::new(
-                shared::ethrpc::web3(
-                    &args.shared.ethrpc,
-                    &http_factory,
-                    tracing_node_url,
-                    "trace",
-                ),
+                shared::ethrpc::web3(&args.shared.ethrpc, tracing_node_url, "trace"),
                 *eth.contracts().settlement().address(),
                 finder,
             )),
@@ -734,12 +726,7 @@ async fn shadow_mode(args: Arguments) -> ! {
         .into_iter()
         .collect();
 
-    let web3 = shared::ethrpc::web3(
-        &args.shared.ethrpc,
-        &http_factory,
-        &args.shared.node_url,
-        "base",
-    );
+    let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
     let weth = WETH9::Instance::deployed(&web3.alloy)
         .await
         .expect("couldn't find deployed WETH contract");
diff --git a/crates/contracts/src/bin/vendor.rs b/crates/contracts/src/bin/vendor.rs
index 36bd8fce6a..2d26a17e27 100644
--- a/crates/contracts/src/bin/vendor.rs
+++ b/crates/contracts/src/bin/vendor.rs
@@ -1,7 +1,3 @@
-//! This script is used to vendor Truffle JSON artifacts to be used for code
-//! generation with `ethcontract`. This is done instead of fetching contracts
-//! at build time to reduce the risk of failure.
-
 use {
     anyhow::Result,
     reqwest::Url,
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index edd2f47f6e..d93e4f4631 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -55,7 +55,6 @@ toml = { workspace = true }
 tower = { workspace = true }
 tower-http = { workspace = true, features = ["limit", "trace"] }
 url = { workspace = true, features = ["serde"] }
-web3 = { workspace = true, features = ["http"] }
 
 # These still use { workspace = true } because they're used at
 # the boundary between driver and shared.
@@ -65,7 +64,6 @@ web3 = { workspace = true, features = ["http"] }
 anyhow = { workspace = true }
 clap = { workspace = true }
 contracts = { workspace = true }
-ethcontract = { workspace = true }
 model = { workspace = true }
 observe = { workspace = true }
 shared = { workspace = true }
diff --git a/crates/driver/src/boundary/mod.rs b/crates/driver/src/boundary/mod.rs
index 0e220a985d..630616a9f3 100644
--- a/crates/driver/src/boundary/mod.rs
+++ b/crates/driver/src/boundary/mod.rs
@@ -56,9 +56,5 @@ fn web3_client(ethrpc: &Url, max_batch_size: usize, max_concurrent_requests: usi
         ethrpc_max_concurrent_requests: max_concurrent_requests,
         ethrpc_batch_delay: Default::default(),
     };
-    let http_factory =
-        shared::http_client::HttpClientFactory::new(&shared::http_client::Arguments {
-            http_timeout: std::time::Duration::from_secs(10),
-        });
-    shared::ethrpc::web3(&ethrpc_args, &http_factory, ethrpc, "base")
+    shared::ethrpc::web3(&ethrpc_args, ethrpc, "base")
 }
diff --git a/crates/driver/src/infra/blockchain/contracts.rs b/crates/driver/src/infra/blockchain/contracts.rs
index deb0aed0c2..7ca0287e3f 100644
--- a/crates/driver/src/infra/blockchain/contracts.rs
+++ b/crates/driver/src/infra/blockchain/contracts.rs
@@ -51,7 +51,7 @@ impl Contracts {
         web3: &Web3,
         chain: Chain,
         addresses: Addresses,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self, alloy::contract::Error> {
         let settlement = GPv2Settlement::Instance::new(
             addresses
                 .settlement
@@ -167,8 +167,6 @@ impl Contracts {
 
 #[derive(Debug, Error)]
 pub enum Error {
-    #[error("method error: {0:?}")]
-    Method(#[from] ethcontract::errors::MethodError),
     #[error("method error: {0:?}")]
     Rpc(#[from] alloy::contract::Error),
 }
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index d3d58dcfb8..1e1bb52890 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -12,8 +12,7 @@ use {
     },
     anyhow::anyhow,
     chain::Chain,
-    ethcontract::errors::ExecutionError,
-    ethrpc::{Web3, block_stream::CurrentBlockWatcher},
+    ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     shared::{
         account_balances::{BalanceSimulator, SimulationError},
         gas_price_estimation::Eip1559EstimationExt,
@@ -73,8 +72,6 @@ impl Rpc {
 
 #[derive(Debug, Error)]
 pub enum RpcError {
-    #[error("web3 error: {0:?}")]
-    Web3(#[from] web3::error::Error),
     #[error("alloy transport error: {0:?}")]
     Alloy(#[from] alloy::transports::TransportError),
     #[error("unsupported chain")]
@@ -161,7 +158,7 @@ impl Ethereum {
     /// the provided label.
     pub fn with_metric_label(&self, label: String) -> Self {
         Self {
-            web3: ethrpc::instrumented::instrument_with_label(&self.web3, label),
+            web3: self.web3.labeled(label),
             ..self.clone()
         }
     }
@@ -326,10 +323,6 @@ pub enum Error {
     ContractRpc(#[from] alloy::contract::Error),
     #[error("alloy rpc error: {0:?}")]
     Rpc(#[from] alloy::transports::RpcError<TransportErrorKind>),
-    #[error("method error: {0:?}")]
-    Method(#[from] ethcontract::errors::MethodError),
-    #[error("web3 error: {0:?}")]
-    Web3(#[from] web3::error::Error),
     #[error("gas price estimation error: {0}")]
     GasPrice(boundary::Error),
     #[error("access list estimation error: {0:?}")]
@@ -342,11 +335,6 @@ impl Error {
     pub fn is_revert(&self) -> bool {
         // This behavior is node dependent
         match self {
-            Error::Method(error) => matches!(error.inner, ExecutionError::Revert(_)),
-            Error::Web3(inner) => {
-                let error = ExecutionError::from(inner.clone());
-                matches!(error, ExecutionError::Revert(_))
-            }
             Error::GasPrice(_) => false,
             Error::AccessList(_) => true,
             Error::ContractRpc(_) => true,
@@ -362,7 +350,6 @@ impl Error {
 impl From<contracts::Error> for Error {
     fn from(err: contracts::Error) -> Self {
         match err {
-            contracts::Error::Method(err) => Self::Method(err),
             contracts::Error::Rpc(err) => Self::ContractRpc(err),
         }
     }
@@ -372,7 +359,6 @@ impl From<SimulationError> for Error {
     fn from(err: SimulationError) -> Self {
         match err {
             SimulationError::Method(err) => Self::ContractRpc(err),
-            SimulationError::Web3(err) => Self::Web3(err),
         }
     }
 }
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index ad0c4d8184..bf12ac0895 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -138,16 +138,6 @@ enum BlockNumber {
     Earliest,
 }
 
-impl From<BlockNumber> for web3::types::BlockNumber {
-    fn from(bn: BlockNumber) -> Self {
-        match bn {
-            BlockNumber::Pending => web3::types::BlockNumber::Pending,
-            BlockNumber::Latest => web3::types::BlockNumber::Latest,
-            BlockNumber::Earliest => web3::types::BlockNumber::Earliest,
-        }
-    }
-}
-
 impl From<BlockNumber> for BlockNumberOrTag {
     fn from(value: BlockNumber) -> Self {
         match value {
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index e336fe7945..e4202ef77d 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -1131,8 +1131,7 @@ impl Test {
 
     pub async fn settle_with_solver(&self, solver_name: &str, solution_id: u64) -> Settle {
         let submission_deadline_latest_block: u64 =
-            u64::try_from(self.web3().eth().block_number().await.unwrap()).unwrap()
-                + self.settle_submission_deadline;
+            self.web3().alloy.get_block_number().await.unwrap() + self.settle_submission_deadline;
         let old_balances = self.balances().await;
         let res = self
             .client
diff --git a/crates/e2e/tests/e2e/hooks.rs b/crates/e2e/tests/e2e/hooks.rs
index 5f21c2f615..2339f7e281 100644
--- a/crates/e2e/tests/e2e/hooks.rs
+++ b/crates/e2e/tests/e2e/hooks.rs
@@ -13,7 +13,7 @@ use {
         safe::Safe,
         wait_for_condition,
     },
-    ethrpc::alloy::{CallBuilderExt, conversions::IntoLegacy},
+    ethrpc::alloy::CallBuilderExt,
     model::{
         order::{OrderCreation, OrderCreationAppData, OrderKind},
         quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
@@ -357,13 +357,8 @@ async fn signature(web3: Web3) {
     services.create_order(&order).await.unwrap();
     onchain.mint_block().await;
 
-    let balance = token
-        .balanceOf(safe.address())
-        .call()
-        .await
-        .unwrap()
-        .into_legacy();
-    assert_eq!(balance, 5u64.eth().into_legacy());
+    let balance = token.balanceOf(safe.address()).call().await.unwrap();
+    assert_eq!(balance, 5u64.eth());
 
     // Check that the Safe really hasn't been deployed yet.
     let code = web3.alloy.get_code_at(safe.address()).await.unwrap();
diff --git a/crates/ethrpc/Cargo.toml b/crates/ethrpc/Cargo.toml
index a40c2ec12b..f500517f1e 100644
--- a/crates/ethrpc/Cargo.toml
+++ b/crates/ethrpc/Cargo.toml
@@ -15,13 +15,11 @@ alloy = { workspace = true, default-features = false, features = ["json-rpc", "p
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 const-hex = { workspace = true }
-ethcontract = { workspace = true }
 futures = { workspace = true }
 itertools = { workspace = true }
 jsonrpc-core.workspace = true
 mockall = { workspace = true, optional = true }
 observe = { workspace = true }
-primitive-types = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
@@ -34,7 +32,6 @@ tokio-stream = { workspace = true }
 tower = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
-web3 = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }
diff --git a/crates/ethrpc/src/alloy/conversions.rs b/crates/ethrpc/src/alloy/conversions.rs
deleted file mode 100644
index fcd04baec2..0000000000
--- a/crates/ethrpc/src/alloy/conversions.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-use std::collections::HashMap;
-
-/////////////////////////////////
-// Conversions to the alloy types
-/////////////////////////////////
-
-pub trait IntoAlloy {
-    /// The corresponding Alloy type.
-    type To;
-
-    /// Converts the legacy type to the corresponding Alloy type.
-    fn into_alloy(self) -> Self::To;
-}
-
-impl IntoAlloy for ethcontract::I256 {
-    type To = alloy::primitives::I256;
-
-    fn into_alloy(self) -> Self::To {
-        let mut buf = [0u8; 32];
-        self.to_little_endian(&mut buf);
-        alloy::primitives::I256::from_le_bytes(buf)
-    }
-}
-
-impl IntoAlloy for primitive_types::U256 {
-    type To = alloy::primitives::U256;
-
-    fn into_alloy(self) -> Self::To {
-        let mut buf = [0u8; 32];
-        self.to_little_endian(&mut buf);
-        alloy::primitives::U256::from_le_bytes(buf)
-    }
-}
-
-impl IntoAlloy for primitive_types::U512 {
-    type To = alloy::primitives::U512;
-
-    fn into_alloy(self) -> Self::To {
-        let mut buf = [0u8; 64];
-        self.to_little_endian(&mut buf);
-        alloy::primitives::U512::from_le_bytes(buf)
-    }
-}
-
-impl IntoAlloy for primitive_types::H160 {
-    type To = alloy::primitives::Address;
-
-    fn into_alloy(self) -> Self::To {
-        alloy::primitives::Address(self.0.into())
-    }
-}
-
-impl IntoAlloy for primitive_types::H256 {
-    type To = alloy::primitives::aliases::B256;
-
-    fn into_alloy(self) -> Self::To {
-        alloy::primitives::aliases::B256::new(self.0)
-    }
-}
-
-impl IntoAlloy for web3::types::BlockNumber {
-    type To = alloy::eips::BlockNumberOrTag;
-
-    fn into_alloy(self) -> Self::To {
-        match self {
-            web3::types::BlockNumber::Finalized => alloy::eips::BlockNumberOrTag::Finalized,
-            web3::types::BlockNumber::Safe => alloy::eips::BlockNumberOrTag::Safe,
-            web3::types::BlockNumber::Latest => alloy::eips::BlockNumberOrTag::Latest,
-            web3::types::BlockNumber::Earliest => alloy::eips::BlockNumberOrTag::Earliest,
-            web3::types::BlockNumber::Pending => alloy::eips::BlockNumberOrTag::Pending,
-            web3::types::BlockNumber::Number(number) => {
-                alloy::eips::BlockNumberOrTag::Number(number.as_u64())
-            }
-        }
-    }
-}
-
-impl IntoAlloy for web3::types::BlockId {
-    type To = alloy::eips::BlockId;
-
-    fn into_alloy(self) -> Self::To {
-        match self {
-            web3::types::BlockId::Hash(hash) => {
-                alloy::eips::BlockId::Hash(alloy::eips::RpcBlockHash::from(hash.into_alloy()))
-            }
-            web3::types::BlockId::Number(number) => {
-                alloy::eips::BlockId::Number(number.into_alloy())
-            }
-        }
-    }
-}
-
-impl IntoAlloy for ethcontract::tokens::Bytes<Vec<u8>> {
-    type To = alloy::primitives::Bytes;
-
-    fn into_alloy(self) -> Self::To {
-        alloy::primitives::Bytes::copy_from_slice(self.0.as_slice())
-    }
-}
-
-impl IntoAlloy for web3::types::Bytes {
-    type To = alloy::primitives::Bytes;
-
-    fn into_alloy(self) -> Self::To {
-        alloy::primitives::Bytes::copy_from_slice(self.0.as_slice())
-    }
-}
-
-impl IntoAlloy for HashMap<ethcontract::H256, ethcontract::H256> {
-    type To = HashMap<
-        alloy::primitives::B256,
-        alloy::primitives::B256,
-        alloy::primitives::map::FbBuildHasher<32>,
-    >;
-
-    fn into_alloy(self) -> Self::To {
-        self.into_iter()
-            .map(|(k, v)| (k.into_alloy(), v.into_alloy()))
-            .collect()
-    }
-}
-
-//////////////////////////////////
-// Conversions to the legacy types
-//////////////////////////////////
-
-pub trait IntoLegacy {
-    /// The corresponding legacy type.
-    type To;
-
-    /// Converts the alloy type to the corresponding legacy type.
-    fn into_legacy(self) -> Self::To;
-}
-
-impl IntoLegacy for alloy::primitives::U256 {
-    type To = primitive_types::U256;
-
-    fn into_legacy(self) -> Self::To {
-        primitive_types::U256(self.into_limbs())
-    }
-}
-
-impl IntoLegacy for alloy::primitives::U512 {
-    type To = primitive_types::U512;
-
-    fn into_legacy(self) -> Self::To {
-        primitive_types::U512(self.into_limbs())
-    }
-}
-
-impl IntoLegacy for alloy::primitives::Address {
-    type To = primitive_types::H160;
-
-    fn into_legacy(self) -> Self::To {
-        primitive_types::H160(self.into())
-    }
-}
-
-impl IntoLegacy for alloy::primitives::aliases::B256 {
-    type To = primitive_types::H256;
-
-    fn into_legacy(self) -> Self::To {
-        primitive_types::H256(self.into())
-    }
-}
-
-impl IntoLegacy for alloy::primitives::Bytes {
-    type To = web3::types::Bytes;
-
-    fn into_legacy(self) -> Self::To {
-        web3::types::Bytes(self.to_vec())
-    }
-}
diff --git a/crates/ethrpc/src/alloy/instrumentation.rs b/crates/ethrpc/src/alloy/instrumentation.rs
index 38d0d8b36f..d4bd4143b4 100644
--- a/crates/ethrpc/src/alloy/instrumentation.rs
+++ b/crates/ethrpc/src/alloy/instrumentation.rs
@@ -9,9 +9,9 @@
 //! trait to conveniently create a new `Provider` with an additional
 //! [`LabelingLayer`].
 use {
-    crate::alloy::RpcClientRandomIdExt,
+    crate::{Web3, alloy::RpcClientRandomIdExt},
     alloy::{
-        providers::{DynProvider, Provider, ProviderBuilder},
+        providers::{Provider, ProviderBuilder},
         rpc::{
             client::RpcClient,
             json_rpc::{RequestPacket, ResponsePacket, SerializedRequest},
@@ -151,16 +151,29 @@ where
 
 pub trait ProviderLabelingExt {
     /// Creates a new provider tagged with another label.
-    fn labeled(&self, label: String) -> Self;
+    fn labeled<S: ToString>(&self, label: S) -> Self;
 }
 
-impl ProviderLabelingExt for DynProvider {
-    fn labeled(&self, label: String) -> Self {
-        let is_local = self.client().is_local();
-        let transport = self.client().transport().clone();
-        let transport_with_label = LabelingLayer { label }.layer(transport);
+impl ProviderLabelingExt for Web3 {
+    fn labeled<S: ToString>(&self, label: S) -> Self {
+        let is_local = self.alloy.client().is_local();
+        let transport = self.alloy.client().transport().clone();
+        let transport_with_label = LabelingLayer {
+            label: label.to_string(),
+        }
+        .layer(transport);
         let client = RpcClient::with_random_id(transport_with_label, is_local);
-        ProviderBuilder::new().connect_client(client).erased()
+        let alloy = ProviderBuilder::new()
+            .wallet(self.wallet.clone())
+            // TODO: eventually remove this and all the other simple nonce managers
+            .with_simple_nonce_management()
+            .connect_client(client)
+            .erased();
+
+        Self {
+            alloy,
+            wallet: self.wallet.clone(),
+        }
     }
 }
 
diff --git a/crates/ethrpc/src/alloy/mod.rs b/crates/ethrpc/src/alloy/mod.rs
index 6e6b12a07e..1e2679bd53 100644
--- a/crates/ethrpc/src/alloy/mod.rs
+++ b/crates/ethrpc/src/alloy/mod.rs
@@ -1,5 +1,4 @@
 mod buffering;
-pub mod conversions;
 pub mod errors;
 mod evm_ext;
 mod instrumentation;
@@ -13,22 +12,18 @@ use {
     },
     buffering::BatchCallLayer,
     instrumentation::{InstrumentationLayer, LabelingLayer},
-    std::time::Duration,
 };
 pub use {evm_ext::EvmProviderExt, instrumentation::ProviderLabelingExt, wallet::MutWallet};
 
 /// Creates an [`RpcClient`] from the given URL with [`LabelingLayer`],
 /// [`InstrumentationLayer`] and [`BatchCallLayer`].
-fn rpc(url: &str) -> RpcClient {
+fn rpc(url: &str, config: Config, label: Option<&str>) -> RpcClient {
     ClientBuilder::default()
         .layer(LabelingLayer {
-            label: "main".into(),
+            label: label.unwrap_or("main").into(),
         })
         .layer(InstrumentationLayer)
-        .layer(BatchCallLayer::new(Config {
-            ethrpc_batch_delay: Duration::ZERO,
-            ..Default::default()
-        }))
+        .layer(BatchCallLayer::new(config))
         .http(url.parse().unwrap())
 }
 
@@ -38,10 +33,10 @@ fn rpc(url: &str) -> RpcClient {
 ///
 /// This is useful for components that need to avoid batching (e.g., block
 /// stream polling on high-frequency chains).
-fn unbuffered_rpc(url: &str) -> RpcClient {
+fn unbuffered_rpc(url: &str, label: Option<&str>) -> RpcClient {
     ClientBuilder::default()
         .layer(LabelingLayer {
-            label: "main_unbuffered".into(),
+            label: label.unwrap_or("main_unbuffered").into(),
         })
         .layer(InstrumentationLayer)
         .http(url.parse().unwrap())
@@ -53,8 +48,8 @@ fn unbuffered_rpc(url: &str) -> RpcClient {
 /// Useful for read-only operations like block polling.
 ///
 /// Returns a copy of the [`MutWallet`] so the caller can modify it later.
-pub fn unbuffered_provider(url: &str) -> (AlloyProvider, MutWallet) {
-    let rpc = unbuffered_rpc(url);
+pub fn unbuffered_provider(url: &str, label: Option<&str>) -> (AlloyProvider, MutWallet) {
+    let rpc = unbuffered_rpc(url, label);
     let wallet = MutWallet::default();
     let provider = ProviderBuilder::new()
         .wallet(wallet.clone())
@@ -68,13 +63,13 @@ pub fn unbuffered_provider(url: &str) -> (AlloyProvider, MutWallet) {
 /// Creates a provider with the provided URL and an empty [`MutWallet`].
 ///
 /// Returns a copy of the [`MutWallet`] so the caller can modify it later.
-pub fn provider(url: &str) -> (AlloyProvider, MutWallet) {
-    let rpc = rpc(url);
+pub fn provider(url: &str, config: Config, label: Option<&str>) -> (AlloyProvider, MutWallet) {
+    let rpc = rpc(url, config, label);
     let wallet = MutWallet::default();
     let provider = ProviderBuilder::new()
         .wallet(wallet.clone())
         // will query the node for the nonce every time that it is needed
-        // adds overhead but makes working with alloy/ethcontract at the same time much simpler
+        // adds overhead but makes working with alloy at the same time much simpler
         .with_simple_nonce_management()
         .connect_client(rpc)
         .erased();
diff --git a/crates/ethrpc/src/block_stream/mod.rs b/crates/ethrpc/src/block_stream.rs
similarity index 99%
rename from crates/ethrpc/src/block_stream/mod.rs
rename to crates/ethrpc/src/block_stream.rs
index c1538574fa..eeff615e5d 100644
--- a/crates/ethrpc/src/block_stream/mod.rs
+++ b/crates/ethrpc/src/block_stream.rs
@@ -1,5 +1,5 @@
 use {
-    crate::{AlloyProvider, alloy::ProviderLabelingExt},
+    crate::AlloyProvider,
     alloy::{
         eips::{BlockId, BlockNumberOrTag},
         primitives::{B256, U256},
@@ -235,8 +235,8 @@ pub async fn current_block_stream(
 ) -> Result<CurrentBlockWatcher> {
     // Build an alloy transport specifically for the current block stream to avoid
     // batching requests together on chains with a very high block frequency.
-    let (provider, _) = crate::alloy::unbuffered_provider(url.as_str());
-    let provider = provider.labeled("base_currentBlockStream".into());
+    let (provider, _) =
+        crate::alloy::unbuffered_provider(url.as_str(), Some("base_currentBlockStream"));
 
     let first_block = provider.current_block().await?;
     tracing::debug!(number=%first_block.number, hash=?first_block.hash, "polled block");
diff --git a/crates/ethrpc/src/buffered.rs b/crates/ethrpc/src/buffered.rs
deleted file mode 100644
index c942c4ef90..0000000000
--- a/crates/ethrpc/src/buffered.rs
+++ /dev/null
@@ -1,600 +0,0 @@
-//! A buffered `Transport` implementation that automatically groups JSON RPC
-//! requests into batches.
-
-use {
-    super::MAX_BATCH_SIZE,
-    ethcontract::{
-        jsonrpc::Call,
-        web3::{BatchTransport, Error as Web3Error, RequestId, Transport},
-    },
-    futures::{
-        channel::{mpsc, oneshot},
-        future::{self, BoxFuture, FutureExt as _},
-        stream::{self, FusedStream, Stream, StreamExt as _},
-    },
-    serde_json::Value,
-    std::{
-        collections::{BTreeMap, BTreeSet},
-        fmt::Write,
-        future::Future,
-        num::NonZeroUsize,
-        sync::Arc,
-        time::Duration,
-    },
-    tokio::task::JoinHandle,
-    tracing::Instrument as _,
-};
-
-/// Buffered transport configuration.
-#[derive(Debug)]
-pub struct Configuration {
-    /// The maximum amount of concurrent batches to send to the node.
-    ///
-    /// Specifying `None` means no limit on concurrency.
-    pub max_concurrent_requests: Option<NonZeroUsize>,
-    /// The maximum batch size.
-    pub max_batch_len: usize,
-    /// An additional minimum delay to wait for collecting requests.
-    ///
-    /// The delay starts counting after receiving the first request.
-    pub batch_delay: Duration,
-}
-
-impl Default for Configuration {
-    fn default() -> Self {
-        // Default configuration behaves kind of like TCP Nagle.
-        Self {
-            max_concurrent_requests: NonZeroUsize::new(1),
-            max_batch_len: MAX_BATCH_SIZE,
-            batch_delay: Duration::default(),
-        }
-    }
-}
-
-/// Buffered `Transport` implementation that implements automatic batching of
-/// JSONRPC requests.
-#[derive(Clone, Debug)]
-pub struct BufferedTransport<Inner> {
-    inner: Arc<Inner>,
-    calls: mpsc::UnboundedSender<CallContext>,
-}
-
-type RpcResult = Result<Value, Web3Error>;
-
-type CallContext = (RequestId, Call, Option<String>, oneshot::Sender<RpcResult>);
-
-impl<Inner> BufferedTransport<Inner>
-where
-    Inner: BatchTransport + Send + Sync + 'static,
-    Inner::Out: Send,
-    Inner::Batch: Send,
-{
-    /// Create a new buffered transport with the default configuration.
-    pub fn new(inner: Inner) -> Self {
-        Self::with_config(inner, Default::default())
-    }
-
-    /// Creates a new buffered transport with the specified configuration.
-    pub fn with_config(inner: Inner, config: Configuration) -> Self {
-        let inner = Arc::new(inner);
-        let (calls, receiver) = mpsc::unbounded();
-        Self::background_worker(inner.clone(), config, receiver);
-
-        Self { inner, calls }
-    }
-
-    /// Start a background worker for handling batched requests.
-    fn background_worker(
-        inner: Arc<Inner>,
-        config: Configuration,
-        calls: mpsc::UnboundedReceiver<CallContext>,
-    ) -> JoinHandle<()> {
-        tokio::task::spawn(batched_for_each(config, calls, move |batch| {
-            let inner = inner.clone();
-            async move {
-                let (mut requests, mut trace_ids, mut senders): (Vec<_>, Vec<_>, Vec<_>) =
-                    itertools::multiunzip(
-                        batch
-                            .into_iter()
-                            .filter(|(_, _, _, sender)| !sender.is_canceled())
-                            .map(|(id, request, trace_id, sender)| {
-                                ((id, request), trace_id, sender)
-                            }),
-                    );
-                match requests.len() {
-                    0 => (),
-                    1 => {
-                        let ((id, request), trace_id, sender) =
-                            (requests.remove(0), trace_ids.remove(0), senders.remove(0));
-                        let result = match (&request, trace_id) {
-                            (Call::MethodCall(_), Some(trace_id)) => {
-                                let span =
-                                    observe::distributed_tracing::request_id::info_span(trace_id);
-                                inner.send(id, request).instrument(span).await
-                            }
-                            _ => inner.send(id, request).await,
-                        };
-                        let _ = sender.send(result);
-                    }
-                    n => {
-                        let results = match build_rpc_metadata(&requests, &trace_ids) {
-                            Ok(metadata) => {
-                                let span =
-                                    observe::distributed_tracing::request_id::info_span(metadata);
-                                inner.send_batch(requests).instrument(span).await
-                            }
-                            Err(err) => {
-                                tracing::error!(
-                                    ?err,
-                                    "failed to build metadata, sending RPC calls without the \
-                                     metadata header"
-                                );
-                                inner.send_batch(requests).await
-                            }
-                        }
-                        .unwrap_or_else(|err| vec![Err(err); n]);
-                        for (sender, result) in senders.into_iter().zip(results) {
-                            let _ = sender.send(result);
-                        }
-                    }
-                }
-            }
-        }))
-    }
-
-    /// Queue a call by sending it over calls channel to the background worker.
-    fn queue_call(&self, id: RequestId, request: Call) -> oneshot::Receiver<RpcResult> {
-        let (sender, receiver) = oneshot::channel();
-        let trace_id = observe::distributed_tracing::request_id::from_current_span();
-        let context = (id, request, trace_id, sender);
-        self.calls
-            .unbounded_send(context)
-            .expect("worker task unexpectedly dropped");
-        receiver
-    }
-
-    /// Executes a call.
-    async fn execute_call(&self, id: RequestId, request: Call) -> RpcResult {
-        let method = match &request {
-            Call::MethodCall(call) => call.method.as_str(),
-            _ => "none",
-        };
-
-        tracing::trace!(%id, %method, "queueing call");
-
-        let response = self.queue_call(id, request);
-        let result = response.await.expect("worker task unexpectedly dropped");
-
-        tracing::trace!(%id, ok = %result.is_ok(), "received response");
-
-        result
-    }
-}
-
-impl<Inner> Transport for BufferedTransport<Inner>
-where
-    Inner: BatchTransport + Send + Sync + 'static,
-    Inner::Out: Send,
-    Inner::Batch: Send,
-{
-    type Out = BoxFuture<'static, RpcResult>;
-
-    fn prepare(&self, method: &str, params: Vec<Value>) -> (RequestId, Call) {
-        self.inner.prepare(method, params)
-    }
-
-    fn send(&self, id: RequestId, request: Call) -> Self::Out {
-        let this = self.clone();
-
-        async move { this.execute_call(id, request).await }
-            .in_current_span()
-            .boxed()
-    }
-}
-
-impl<Inner> BatchTransport for BufferedTransport<Inner>
-where
-    Inner: BatchTransport + Send + Sync + 'static,
-    Inner::Out: Send,
-    Inner::Batch: Send,
-{
-    type Batch = BoxFuture<'static, Result<Vec<RpcResult>, Web3Error>>;
-
-    fn send_batch<T>(&self, requests: T) -> Self::Batch
-    where
-        T: IntoIterator<Item = (RequestId, Call)>,
-    {
-        let this = self.clone();
-        let requests = requests.into_iter().collect::<Vec<_>>();
-
-        async move {
-            let responses = requests
-                .into_iter()
-                .map(|(id, request)| this.execute_call(id, request));
-            Ok(future::join_all(responses).await)
-        }
-        .in_current_span()
-        .boxed()
-    }
-}
-
-/// Batches a stream into chunks.
-///
-/// This is very similar to `futures::stream::StreamExt::ready_chunks` with the
-/// difference that it allows configuring a minimum delay for a batch, so
-/// waiting for a small amount of time to allow the stream to produce additional
-/// items, thus decreasing the chance of batches of size 1.
-fn batched_for_each<T, St, F, Fut>(
-    config: Configuration,
-    items: St,
-    work: F,
-) -> impl Future<Output = ()>
-where
-    St: Stream<Item = T> + FusedStream + Unpin,
-    F: Fn(Vec<T>) -> Fut,
-    Fut: Future<Output = ()>,
-{
-    let concurrency_limit = config.max_concurrent_requests.map(NonZeroUsize::get);
-
-    let batches = stream::unfold(items, move |mut items| async move {
-        let mut chunk = vec![items.next().await?];
-
-        let delay = tokio::time::sleep(config.batch_delay).fuse();
-        futures::pin_mut!(delay);
-
-        while chunk.len() < config.max_batch_len {
-            futures::select_biased! {
-                item = items.next() => match item {
-                    Some(item) => chunk.push(item),
-                    None => break,
-                },
-                _ = delay => break,
-            }
-        }
-
-        Some((chunk, items))
-    });
-
-    batches.for_each_concurrent(concurrency_limit, work)
-}
-
-/// Builds a metadata string representation for RPC requests.
-///
-/// This function takes an iterator of requests and their corresponding trace
-/// IDs, and generates a metadata string that groups the requests by their trace
-/// IDs and method names. The format of the output string is as follows:
-///
-/// `trace_id:method_name(index1,index2,...),method_name(index1,index2,...
-/// )|trace_id:...`
-///
-/// Each trace ID is followed by a colon and a list of method names. Each method
-/// name is followed by a list of indices (representing the position of the
-/// request in the original vector) enclosed in parentheses. Different method
-/// names are separated by commas. If there are multiple trace IDs, their
-/// entries are separated by a pipe character.
-///
-/// If a trace ID is `None`, it is represented as "null" in the output string.
-/// All requests with absent trace IDs are grouped together under "null".
-///
-/// # Arguments
-///
-/// * `requests` - A vector of tuples, where each tuple contains a request ID
-///   and a `Call` object representing the RPC request.
-/// * `trace_ids` - A vector of optional strings representing the trace IDs of
-///   the requests. The trace IDs correspond to the requests in the same
-///   position in the `requests` vector.
-///
-/// # Returns
-///
-/// This function returns a string representing the metadata header.
-fn build_rpc_metadata(
-    requests: &[(RequestId, Call)],
-    trace_ids: &[Option<String>],
-) -> anyhow::Result<String> {
-    // Group the requests by trace ID(sorted) and method name(sorted) where values
-    // are sorted indices.
-    let mut grouped_metadata: BTreeMap<String, BTreeMap<String, BTreeSet<usize>>> = BTreeMap::new();
-    for (idx, ((_, call), trace_id)) in requests.iter().zip(trace_ids).enumerate() {
-        if let Call::MethodCall(call) = call {
-            let trace_id = trace_id.clone().unwrap_or("null".to_string());
-            grouped_metadata
-                .entry(trace_id)
-                .or_default()
-                .entry(call.method.clone())
-                .or_default()
-                .insert(idx);
-        }
-    }
-
-    let mut metadata_str = String::new();
-
-    let mut grouped_metadata_iter = grouped_metadata.into_iter().peekable();
-    while let Some((trace_id, methods)) = grouped_metadata_iter.next() {
-        // New entry starts with the trace_id
-        write!(metadata_str, "{trace_id}:")?;
-
-        // Followed by the method names and their indices
-        let mut methods_iter = methods.into_iter().peekable();
-        while let Some((method, indices)) = methods_iter.next() {
-            write!(metadata_str, "{method}(")?;
-
-            let indices_str = format_indices_as_ranges(indices)?;
-            write!(metadata_str, "{indices_str}")?;
-
-            write!(metadata_str, ")")?;
-
-            if methods_iter.peek().is_some() {
-                write!(metadata_str, ",")?;
-            }
-        }
-
-        if grouped_metadata_iter.peek().is_some() {
-            write!(metadata_str, "|")?;
-        }
-    }
-
-    Ok(metadata_str)
-}
-
-/// Formats a set of indices as a string of ranges.
-///
-/// This function takes a set of indices and formats them as a string where
-/// consecutive indices are represented as ranges. For example, the set
-/// `{1, 2, 3, 5, 6, 8}` would be formatted as the string `"1..3,5..6,8"`.
-///
-/// # Arguments
-///
-/// * `indices` - A set of indices to format. The indices should be unique and
-///   sorted in ascending order.
-///
-/// # Returns
-///
-/// This function returns a string representing the indices as ranges. Each
-/// range is formatted as `start..end`, and ranges are separated by commas.
-/// Single indices (i.e., indices that are not part of a range) are represented
-/// as themselves.
-fn format_indices_as_ranges(indices: BTreeSet<usize>) -> anyhow::Result<String> {
-    let mut result = String::new();
-    let mut indices = indices.into_iter();
-    // Initialize the start and last variables with the first index.
-    let mut start = match indices.next() {
-        Some(index) => index,
-        None => return Ok(result),
-    };
-    let mut last = start;
-
-    // Iterate over the rest of the indices
-    for index in indices {
-        // If the current index is the next consecutive number, update last index.
-        if index == last + 1 {
-            last = index;
-        // Otherwise, there is no need to accumulate the range anymore. Append
-        // the range to the result string.
-        } else {
-            append_sequence(&mut result, start, last)?;
-            write!(result, ",")?;
-            // Reset the start and last indices with the current value.
-            start = index;
-            last = index;
-        }
-    }
-
-    // Append the remaining data.
-    append_sequence(&mut result, start, last)?;
-
-    Ok(result)
-}
-
-/// This function formats a range of integers into a condensed string
-/// representation and appends it to the given buffer. The format varies based
-/// on the relationship between `start` and `last`:
-///
-/// - If `start` is equal to `last`, it indicates a single value, which is
-///   appended as such.
-/// - If `start` is one less than `last` (i.e., they are consecutive), both
-///   numbers are appended separated by a comma.
-/// - Otherwise, the numbers between `start` and `last` (inclusive) are
-///   represented as a range using two dots (e.g., "start..last").
-fn append_sequence(buffer: &mut String, start: usize, last: usize) -> core::fmt::Result {
-    if start == last {
-        write!(buffer, "{start}")
-    } else if start == last - 1 {
-        write!(buffer, "{start},{last}")
-    } else {
-        write!(buffer, "{start}..{last}")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::mock::MockTransport,
-        ethcontract::{
-            U256,
-            Web3,
-            jsonrpc::{Id, MethodCall, Params},
-        },
-        mockall::predicate,
-        serde_json::json,
-    };
-
-    #[tokio::test]
-    async fn batches_calls_when_joining() {
-        let transport = MockTransport::new();
-        transport
-            .mock()
-            .expect_execute_batch()
-            .with(predicate::eq(vec![
-                ("foo".to_owned(), vec![json!(true), json!("stuff")]),
-                ("bar".to_owned(), vec![json!(42), json!("answer")]),
-            ]))
-            .returning(|_| Ok(vec![Ok(json!("hello")), Ok(json!("world"))]));
-
-        let transport = BufferedTransport::new(transport);
-
-        let (foo, bar) = futures::join!(
-            transport.execute("foo", vec![json!(true), json!("stuff")]),
-            transport.execute("bar", vec![json!(42), json!("answer")]),
-        );
-        assert_eq!(foo.unwrap(), json!("hello"));
-        assert_eq!(bar.unwrap(), json!("world"));
-    }
-
-    #[tokio::test]
-    async fn no_batching_with_only_one_request() {
-        let transport = MockTransport::new();
-        transport
-            .mock()
-            .expect_execute()
-            .with(
-                predicate::eq("single".to_owned()),
-                predicate::eq(vec![json!("request")]),
-            )
-            .returning(|_, _| Ok(json!(42)));
-
-        let transport = BufferedTransport::new(transport);
-
-        let response = transport
-            .execute("single", vec![json!("request")])
-            .await
-            .unwrap();
-        assert_eq!(response, json!(42));
-    }
-
-    #[tokio::test]
-    async fn batches_separate_web3_instances() {
-        let transport = MockTransport::new();
-        transport
-            .mock()
-            .expect_execute_batch()
-            .with(predicate::eq(vec![
-                ("eth_chainId".to_owned(), vec![]),
-                ("eth_chainId".to_owned(), vec![]),
-                ("eth_chainId".to_owned(), vec![]),
-            ]))
-            .returning(|_| {
-                Ok(vec![
-                    Ok(json!("0x2a")),
-                    Ok(json!("0x2a")),
-                    Ok(json!("0x2a")),
-                ])
-            });
-
-        let web3 = Web3::new(BufferedTransport::new(transport));
-
-        let chain_ids = future::try_join_all(vec![
-            web3.clone().eth().chain_id(),
-            web3.clone().eth().chain_id(),
-            web3.clone().eth().chain_id(),
-        ])
-        .await
-        .unwrap();
-
-        assert_eq!(chain_ids, vec![U256::from(42); 3]);
-    }
-
-    #[tokio::test]
-    async fn resolves_call_after_dropping_transport() {
-        let transport = MockTransport::new();
-        transport
-            .mock()
-            .expect_execute()
-            .with(predicate::eq("used".to_owned()), predicate::eq(vec![]))
-            .returning(|_, _| Ok(json!(1337)));
-
-        let transport = BufferedTransport::new(transport);
-
-        let unused = transport.execute("unused", vec![]);
-        let unpolled = transport.execute("unpolled", vec![]);
-        let used = transport.execute("used", vec![]);
-        drop((unused, transport));
-
-        assert_eq!(used.await.unwrap(), json!(1337));
-        drop(unpolled);
-    }
-
-    #[test]
-    fn test_format_indices_as_ranges() {
-        // empty string
-        let indices = BTreeSet::new();
-        assert_eq!(format_indices_as_ranges(indices).unwrap(), "");
-
-        // a single value
-        let indices = vec![2].into_iter().collect();
-        assert_eq!(format_indices_as_ranges(indices).unwrap(), "2");
-
-        // only a range
-        let indices = vec![1, 2, 3, 4, 5].into_iter().collect();
-        assert_eq!(format_indices_as_ranges(indices).unwrap(), "1..5");
-
-        // 2 subsequent values range
-        let indices = vec![2, 3].into_iter().collect();
-        assert_eq!(format_indices_as_ranges(indices).unwrap(), "2,3");
-
-        // no ranges
-        let indices = vec![1, 3, 5, 7].into_iter().collect();
-        assert_eq!(format_indices_as_ranges(indices).unwrap(), "1,3,5,7");
-
-        // ends with a non-range value
-        let indices = vec![1, 2, 3, 5, 7, 8, 9, 10, 20].into_iter().collect();
-        assert_eq!(
-            format_indices_as_ranges(indices).unwrap(),
-            "1..3,5,7..10,20"
-        );
-
-        // ends with a range value
-        let indices = vec![1, 2, 3, 5, 6, 7, 8, 10, 11, 12].into_iter().collect();
-        assert_eq!(
-            format_indices_as_ranges(indices).unwrap(),
-            "1..3,5..8,10..12"
-        );
-    }
-
-    fn method_call(method: &str) -> Call {
-        Call::MethodCall(MethodCall {
-            jsonrpc: None,
-            method: method.to_string(),
-            params: Params::None,
-            id: Id::Null,
-        })
-    }
-
-    #[test]
-    fn test_build_rpc_metadata_header() {
-        let requests = vec![
-            (1001, method_call("eth_sendTransaction")), // 0
-            (1001, method_call("eth_call")),            // 1
-            (1001, method_call("eth_sendTransaction")), // 2
-            (1002, method_call("eth_call")),            // 3
-            (9999, method_call("eth_call")),            // 4
-            (1001, method_call("eth_sendTransaction")), // 5
-            (1002, method_call("eth_call")),            // 6
-            (1002, method_call("eth_call")),            // 7
-            (1001, method_call("eth_sendTransaction")), // 8
-            (9999, method_call("eth_sendTransaction")), // 9
-            (9999, method_call("eth_sendTransaction")), // 10
-            (9999, method_call("eth_sendTransaction")), // 11
-        ];
-        let trace_ids = vec![
-            Some("1001".to_string()), // 0
-            Some("1001".to_string()), // 1
-            Some("1001".to_string()), // 2
-            Some("1002".to_string()), // 3
-            None,                     // 4
-            Some("1001".to_string()), // 5
-            Some("1002".to_string()), // 6
-            Some("1002".to_string()), // 7
-            Some("1001".to_string()), // 8
-            None,                     // 9
-            None,                     // 10
-            None,                     // 11
-        ];
-        let metadata_header = build_rpc_metadata(&requests, &trace_ids).unwrap();
-        assert_eq!(
-            metadata_header,
-            "1001:eth_call(1),eth_sendTransaction(0,2,5,8)|1002:eth_call(3,6,7)|null:eth_call(4),\
-             eth_sendTransaction(9..11)"
-        );
-    }
-}
diff --git a/crates/ethrpc/src/http.rs b/crates/ethrpc/src/http.rs
deleted file mode 100644
index 2f1d89fd54..0000000000
--- a/crates/ethrpc/src/http.rs
+++ /dev/null
@@ -1,305 +0,0 @@
-use {
-    futures::{FutureExt, future::BoxFuture},
-    jsonrpc_core::types::{Call, Output, Request, Value},
-    observe::tracing::tracing_headers,
-    reqwest::{Client, Url, header},
-    serde::{Deserialize, Serialize, de::DeserializeOwned},
-    std::{
-        collections::HashMap,
-        fmt::{Debug, Formatter},
-        sync::{
-            Arc,
-            atomic::{AtomicUsize, Ordering},
-        },
-    },
-    web3::{
-        BatchTransport,
-        RequestId,
-        Transport,
-        error::{Error as Web3Error, TransportError},
-        helpers,
-    },
-};
-
-#[derive(Clone)]
-pub struct HttpTransport {
-    client: Client,
-    inner: Arc<Inner>,
-}
-
-struct Inner {
-    url: Url,
-    id: AtomicUsize,
-    /// Name of the transport used in logs to distinguish different transports.
-    name: String,
-}
-
-impl HttpTransport {
-    pub fn new(client: Client, url: Url, name: String) -> Self {
-        Self {
-            client,
-            inner: Arc::new(Inner {
-                url,
-                id: AtomicUsize::new(0),
-                name,
-            }),
-        }
-    }
-
-    fn next_id(&self) -> RequestId {
-        self.inner.id.fetch_add(1, Ordering::SeqCst)
-    }
-
-    fn new_request(&self) -> (Client, Arc<Inner>) {
-        (self.client.clone(), self.inner.clone())
-    }
-}
-
-impl Debug for HttpTransport {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("HttpTransport")
-            .field("url", &self.inner.url)
-            .finish()
-    }
-}
-
-// Id is only used for logging.
-async fn execute_rpc<T: DeserializeOwned>(
-    client: Client,
-    inner: Arc<Inner>,
-    id: RequestId,
-    request: &Request,
-) -> Result<T, Web3Error> {
-    let body = serde_json::to_string(&request)?;
-
-    let request_id = observe::distributed_tracing::request_id::from_current_span();
-
-    tracing::trace!(name = %inner.name, %id, %body, "executing request");
-    let mut request_builder = client
-        .post(inner.url.clone())
-        .header(header::CONTENT_TYPE, "application/json")
-        .header("X-RPC-REQUEST-ID", id.to_string())
-        .headers(tracing_headers())
-        .body(body);
-    match request {
-        Request::Single(Call::MethodCall(call)) => {
-            if let Some(metadata) = &request_id {
-                request_builder = request_builder.header("X-REQUEST-ID", metadata);
-            }
-            request_builder = request_builder.header("X-RPC-METHOD", call.method.clone());
-        }
-        Request::Batch(_) => {
-            if let Some(ref metadata) = request_id {
-                request_builder = request_builder.header("X-RPC-BATCH-METADATA", metadata);
-            }
-        }
-        _ => {}
-    }
-    let response = request_builder
-        .send()
-        .await
-        .map_err(|err: reqwest::Error| {
-            tracing::warn!(
-                name = %inner.name,
-                rpc_request_id = %id,
-                request_id,
-                error = %err,
-                "failed to send request"
-            );
-            Web3Error::Transport(TransportError::Message(err.to_string()))
-        })?;
-    let status = response.status();
-    let text = response.text().await.map_err(|err: reqwest::Error| {
-        tracing::warn!(
-            name = %inner.name,
-            rpc_request_id = %id,
-            request_id,
-            error = %err,
-            "failed to get response body"
-        );
-        Web3Error::Transport(TransportError::Message(err.to_string()))
-    })?;
-    // Log the raw text before decoding to get more information on responses that
-    // aren't valid json. Debug encoding so we don't get control characters like
-    // newlines in the output.
-    tracing::trace!(name = %inner.name, %id, body = %text.trim(), "received response");
-    if !status.is_success() {
-        let error_msg = format!("HTTP error {status}");
-
-        return Err(Web3Error::Transport(TransportError::Message(error_msg)));
-    }
-
-    let result = jsonrpc_core::serde_from_str(&text).map_err(|err| {
-        tracing::warn!(
-            name = %inner.name,
-            rpc_request_id = %id,
-            request_id,
-            error = %err,
-            raw_response = %text.trim(),
-            "failed to decode JSON response"
-        );
-        Web3Error::Decoder(format!(
-            "{:?}, raw response: {}, rpc_request_id: {}, request_id: {:?}, {}",
-            err,
-            inner.name,
-            id,
-            request_id,
-            text.trim()
-        ))
-    })?;
-    Ok(result)
-}
-
-type RpcResult = Result<Value, Web3Error>;
-
-impl Transport for HttpTransport {
-    type Out = BoxFuture<'static, RpcResult>;
-
-    fn prepare(&self, method: &str, params: Vec<Value>) -> (RequestId, Call) {
-        let id = self.next_id();
-        let request = helpers::build_request(id, method, params);
-        (id, request)
-    }
-
-    fn send(&self, id: RequestId, call: Call) -> Self::Out {
-        let (client, inner) = self.new_request();
-
-        async move {
-            let output = execute_rpc(client, inner, id, &Request::Single(call)).await?;
-            helpers::to_result_from_output(output)
-        }
-        .boxed()
-    }
-}
-
-impl BatchTransport for HttpTransport {
-    type Batch = BoxFuture<'static, Result<Vec<RpcResult>, Web3Error>>;
-
-    fn send_batch<T>(&self, requests: T) -> Self::Batch
-    where
-        T: IntoIterator<Item = (RequestId, Call)>,
-    {
-        // Batch calls don't need an id but it helps associate the response log to the
-        // request log.
-        let id = self.next_id();
-        let (client, inner) = self.new_request();
-        let (ids, calls): (Vec<_>, Vec<_>) = requests.into_iter().unzip();
-
-        async move {
-            let outputs = execute_rpc(client, inner, id, &Request::Batch(calls)).await?;
-            handle_batch_response(&ids, outputs)
-        }
-        .boxed()
-    }
-}
-
-/// Workaround for Erigon nodes, which encode each element of the Batch Response
-/// as a String rather than a deserializable JSON object
-#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-enum OutputOrString {
-    String(String),
-    Output(Output),
-}
-
-impl OutputOrString {
-    fn try_into_output(self) -> Result<Output, Web3Error> {
-        Ok(match self {
-            OutputOrString::String(string) => jsonrpc_core::serde_from_str(&string)?,
-            OutputOrString::Output(output) => output,
-        })
-    }
-}
-
-fn handle_batch_response(
-    ids: &[RequestId],
-    outputs: Vec<OutputOrString>,
-) -> Result<Vec<RpcResult>, Web3Error> {
-    if ids.len() != outputs.len() {
-        return Err(Web3Error::InvalidResponse(
-            "unexpected number of responses".to_string(),
-        ));
-    }
-    let mut outputs = outputs
-        .into_iter()
-        .map(|output_or_string| {
-            let output = output_or_string.try_into_output()?;
-            Ok((
-                id_of_output(&output)?,
-                helpers::to_result_from_output(output),
-            ))
-        })
-        .collect::<Result<HashMap<_, _>, Web3Error>>()?;
-    ids.iter()
-        .map(|id| {
-            outputs.remove(id).ok_or_else(|| {
-                Web3Error::InvalidResponse(format!("batch response is missing id {id}"))
-            })
-        })
-        .collect()
-}
-
-fn id_of_output(output: &Output) -> Result<RequestId, Web3Error> {
-    let id = match output {
-        Output::Success(success) => &success.id,
-        Output::Failure(failure) => &failure.id,
-    };
-    match id {
-        jsonrpc_core::Id::Num(num) => Ok(*num as RequestId),
-        _ => Err(Web3Error::InvalidResponse(
-            "response id is not u64".to_string(),
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn handles_batch_response_being_in_different_order_than_input() {
-        let ids = vec![0, 1, 2];
-        // This order is different from the ids.
-        let outputs = [1u64, 0, 2]
-            .iter()
-            .map(|&id| {
-                OutputOrString::Output(Output::Success(jsonrpc_core::Success {
-                    jsonrpc: None,
-                    result: id.into(),
-                    id: jsonrpc_core::Id::Num(id),
-                }))
-            })
-            .collect();
-        let results = handle_batch_response(&ids, outputs)
-            .unwrap()
-            .into_iter()
-            .map(|result| result.unwrap().as_u64().unwrap() as usize)
-            .collect::<Vec<_>>();
-        // The order of the ids should have been restored.
-        assert_eq!(ids, results);
-    }
-
-    #[test]
-    fn handles_batch_items_that_are_strings() {
-        let result = handle_batch_response(
-            &[1],
-            vec![OutputOrString::String("{\"result\": 1, \"id\": 1}".into())],
-        )
-        .unwrap()
-        .into_iter()
-        .map(|result| result.unwrap().as_u64().unwrap() as usize)
-        .collect::<Vec<_>>();
-        assert_eq!(vec![1], result);
-    }
-
-    #[test]
-    fn errors_on_invalid_string_batch_responses() {
-        assert!(
-            handle_batch_response(
-                &[1],
-                vec![OutputOrString::String("there is no spoon".into())],
-            )
-            .is_err()
-        );
-    }
-}
diff --git a/crates/ethrpc/src/instrumented.rs b/crates/ethrpc/src/instrumented.rs
deleted file mode 100644
index 0cb9bf9ffb..0000000000
--- a/crates/ethrpc/src/instrumented.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-use {
-    crate::alloy::ProviderLabelingExt,
-    ethcontract::{
-        jsonrpc::types::{Call, Value},
-        transport::DynTransport,
-    },
-    futures::{FutureExt, future::BoxFuture},
-    std::sync::Arc,
-    web3::{BatchTransport, RequestId, Transport, error::Error as Web3Error},
-};
-
-#[derive(prometheus_metric_storage::MetricStorage, Clone, Debug)]
-#[metric(subsystem = "rpc")]
-struct Metrics {
-    /// Number of inflight RPC requests for ethereum node.
-    #[metric(labels("component", "method"))]
-    requests_inflight: prometheus::IntGaugeVec,
-
-    /// Number of completed RPC requests for ethereum node.
-    #[metric(labels("component", "method"))]
-    requests_complete: prometheus::IntCounterVec,
-
-    /// Execution time for each RPC request (batches are counted as one
-    /// request).
-    #[metric(labels("component", "method"))]
-    requests_duration_seconds: prometheus::HistogramVec,
-
-    /// Number of RPC requests initiated within a batch request
-    #[metric(labels("component", "method"))]
-    inner_batch_requests_initiated: prometheus::IntCounterVec,
-}
-
-impl Metrics {
-    #[must_use]
-    fn on_request_start(&self, label: &str, method: &str) -> impl Drop + use<> {
-        let requests_inflight = self.requests_inflight.with_label_values(&[label, method]);
-        let requests_complete = self.requests_complete.with_label_values(&[label, method]);
-        let requests_duration_seconds = self
-            .requests_duration_seconds
-            .with_label_values(&[label, method]);
-
-        requests_inflight.inc();
-        let timer = requests_duration_seconds.start_timer();
-
-        scopeguard::guard(timer, move |timer| {
-            requests_inflight.dec();
-            requests_complete.inc();
-            timer.stop_and_record();
-        })
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct InstrumentedTransport(Arc<Inner>);
-
-impl InstrumentedTransport {
-    pub fn new(label: String, transport: DynTransport) -> Self {
-        Self(Arc::new(Inner {
-            metrics: Metrics::instance(observe::metrics::get_storage_registry()).unwrap(),
-            transport,
-            label,
-        }))
-    }
-
-    pub fn with_additional_label(&self, label: String) -> Self {
-        Self(Arc::new(Inner {
-            label: format!("{}_{label}", self.0.label),
-            transport: self.0.transport.clone(),
-            metrics: self.0.metrics,
-        }))
-    }
-}
-
-/// Adds metrics for RPC requests using the provided label.
-pub fn instrument_with_label(web3: &crate::Web3, label: String) -> crate::Web3 {
-    let transport = web3.transport().clone();
-    let instrumented = match transport.downcast::<InstrumentedTransport>() {
-        Some(instrumented) => instrumented.with_additional_label(label.clone()),
-        _ => InstrumentedTransport::new(label.clone(), transport),
-    };
-    crate::Web3 {
-        legacy: web3::Web3::new(DynTransport::new(instrumented)),
-        alloy: web3.alloy.labeled(label),
-        wallet: web3.wallet.clone(),
-    }
-}
-
-#[derive(Debug)]
-struct Inner {
-    metrics: &'static Metrics,
-    transport: DynTransport,
-    label: String,
-}
-
-type RpcResult = Result<Value, Web3Error>;
-
-impl Transport for InstrumentedTransport {
-    type Out = BoxFuture<'static, RpcResult>;
-
-    fn prepare(&self, method: &str, params: Vec<Value>) -> (RequestId, Call) {
-        self.0.transport.prepare(method, params)
-    }
-
-    fn send(&self, id: RequestId, call: Call) -> Self::Out {
-        let inner = self.0.clone();
-
-        async move {
-            let _guard = inner
-                .metrics
-                .on_request_start(&inner.label, method_name(&call));
-            inner.transport.send(id, call).await
-        }
-        .boxed()
-    }
-}
-
-impl BatchTransport for InstrumentedTransport {
-    type Batch = BoxFuture<'static, Result<Vec<RpcResult>, Web3Error>>;
-
-    fn send_batch<R>(&self, requests: R) -> Self::Batch
-    where
-        R: IntoIterator<Item = (RequestId, Call)>,
-    {
-        let inner = self.0.clone();
-        let requests: Vec<_> = requests.into_iter().collect();
-
-        async move {
-            let _guard = inner.metrics.on_request_start(&inner.label, "batch");
-            let metrics = inner.metrics;
-            let label = &inner.label;
-
-            let requests = requests.into_iter().inspect(move |(_id, call)| {
-                metrics
-                    .inner_batch_requests_initiated
-                    .with_label_values(&[label, method_name(call)])
-                    .inc()
-            });
-
-            inner.transport.send_batch(requests).await
-        }
-        .boxed()
-    }
-}
-
-fn method_name(call: &Call) -> &str {
-    match call {
-        Call::MethodCall(method) => &method.method,
-        Call::Notification(notification) => &notification.method,
-        Call::Invalid { .. } => "invalid",
-    }
-}
diff --git a/crates/ethrpc/src/lib.rs b/crates/ethrpc/src/lib.rs
index 27e353e67f..b84d8a7fb4 100644
--- a/crates/ethrpc/src/lib.rs
+++ b/crates/ethrpc/src/lib.rs
@@ -1,24 +1,12 @@
 pub mod alloy;
 pub mod block_stream;
-pub mod buffered;
-pub mod http;
-pub mod instrumented;
 #[cfg(any(test, feature = "test-util"))]
 pub mod mock;
 
-use {
-    self::{buffered::BufferedTransport, http::HttpTransport},
-    crate::alloy::MutWallet,
-    ::alloy::providers::DynProvider,
-    ethcontract::transport::DynTransport,
-    reqwest::{Client, Url},
-    std::{num::NonZeroUsize, time::Duration},
-    web3::Transport,
-};
+use {crate::alloy::MutWallet, ::alloy::providers::DynProvider, reqwest::Url, std::time::Duration};
 
 pub const MAX_BATCH_SIZE: usize = 100;
 
-pub type Web3Transport = DynTransport;
 pub type AlloyProvider = DynProvider;
 
 /// This is just a thin wrapper around providers (clients communicating
@@ -28,21 +16,12 @@ pub type AlloyProvider = DynProvider;
 /// to convert each call site to use the new provider bit by bit instead of
 /// having to everything at once.
 #[derive(Debug, Clone)]
-pub struct Web3<T: Transport = DynTransport> {
-    pub legacy: web3::Web3<T>,
+pub struct Web3 {
     pub alloy: AlloyProvider,
     pub wallet: MutWallet,
 }
 
-impl<T: Transport> std::ops::Deref for Web3<T> {
-    type Target = web3::Web3<T>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.legacy
-    }
-}
-
-impl Web3<DynTransport> {
+impl Web3 {
     // for tests
     pub fn new_from_env() -> Self {
         let url = &std::env::var("NODE_URL").unwrap();
@@ -50,14 +29,8 @@ impl Web3<DynTransport> {
     }
 
     pub fn new_from_url(url: &str) -> Self {
-        let legacy_transport = create_test_transport(url);
-        let web3 = web3::Web3::new(legacy_transport);
-        let (alloy, wallet) = crate::alloy::provider(url);
-        Self {
-            legacy: web3,
-            alloy,
-            wallet,
-        }
+        let (alloy, wallet) = crate::alloy::provider(url, Default::default(), None);
+        Self { alloy, wallet }
     }
 }
 
@@ -76,76 +49,25 @@ pub struct Config {
     pub ethrpc_batch_delay: Duration,
 }
 
-impl Config {
-    /// Returns the buffered transport configuration or `None` if batching is
-    /// disabled.
-    fn into_buffered_configuration(self) -> Option<buffered::Configuration> {
-        match (
-            self.ethrpc_max_batch_size,
-            self.ethrpc_max_concurrent_requests,
-        ) {
-            (0 | 1, 0) => None,
-            _ => Some(buffered::Configuration {
-                max_concurrent_requests: NonZeroUsize::new(self.ethrpc_max_concurrent_requests),
-                max_batch_len: self.ethrpc_max_batch_size.max(1),
-                batch_delay: self.ethrpc_batch_delay,
-            }),
-        }
-    }
-}
-
 impl Default for Config {
     fn default() -> Self {
         Self {
             ethrpc_max_batch_size: 20,
             ethrpc_max_concurrent_requests: 10,
-            ethrpc_batch_delay: Duration::from_millis(5),
+            ethrpc_batch_delay: Duration::ZERO,
         }
     }
 }
 
-/// Create a Web3 instance.
-pub fn web3(
-    args: Config,
-    http_factory: reqwest::ClientBuilder,
-    url: &Url,
-    name: impl ToString,
-) -> Web3 {
-    let http = http_factory.cookie_store(true).build().unwrap();
-    let http = HttpTransport::new(http, url.clone(), name.to_string());
-    let buffered_config = args.into_buffered_configuration();
-    let (legacy, alloy, wallet) = match buffered_config {
-        Some(config) => {
-            let legacy = Web3Transport::new(BufferedTransport::with_config(http, config));
-            let (alloy, wallet) = alloy::provider(url.as_str());
-            (legacy, alloy, wallet)
-        }
-        None => {
-            let legacy = Web3Transport::new(http);
-            let (alloy, wallet) = alloy::unbuffered_provider(url.as_str());
-            (legacy, alloy, wallet)
-        }
+/// Create a Web3 instance with an optional label for observability.
+pub fn web3(args: Config, url: &Url, label: Option<&str>) -> Web3 {
+    let (alloy, wallet) = match (
+        args.ethrpc_max_batch_size,
+        args.ethrpc_max_concurrent_requests,
+    ) {
+        (0 | 1, 0) => alloy::unbuffered_provider(url.as_str(), label),
+        _ => alloy::provider(url.as_str(), args, label),
     };
-    let instrumented = instrumented::InstrumentedTransport::new(name.to_string(), legacy);
-
-    Web3 {
-        legacy: web3::Web3::new(Web3Transport::new(instrumented)),
-        alloy,
-        wallet,
-    }
-}
 
-/// Convenience method to create a transport from a URL.
-pub fn create_test_transport(url: &str) -> Web3Transport {
-    let http_transport = HttpTransport::new(
-        Client::builder()
-            .timeout(Duration::from_secs(10))
-            .build()
-            .unwrap(),
-        url.try_into().unwrap(),
-        "test".into(),
-    );
-    let dyn_transport = Web3Transport::new(http_transport);
-    let instrumented = instrumented::InstrumentedTransport::new("test".into(), dyn_transport);
-    Web3Transport::new(instrumented)
+    Web3 { alloy, wallet }
 }
diff --git a/crates/ethrpc/src/mock.rs b/crates/ethrpc/src/mock.rs
index ef5dd5b5b8..2ed9f586cb 100644
--- a/crates/ethrpc/src/mock.rs
+++ b/crates/ethrpc/src/mock.rs
@@ -3,28 +3,11 @@
 use {
     crate::{Web3, alloy::MutWallet},
     alloy::providers::{Provider, ProviderBuilder, mock::Asserter},
-    ethcontract::{
-        dyns::DynTransport,
-        futures::future::{self, Ready},
-        jsonrpc::{Call, Id, MethodCall, Params},
-        web3::{self, BatchTransport, RequestId, Transport},
-    },
-    serde_json::Value,
-    std::{
-        fmt::{self, Debug, Formatter},
-        sync::{
-            Arc,
-            Mutex,
-            MutexGuard,
-            atomic::{AtomicUsize, Ordering},
-        },
-    },
 };
 
-impl Web3<MockTransport> {
+impl Web3 {
     pub fn with_asserter(asserter: Asserter) -> Self {
         Web3 {
-            legacy: web3::Web3::new(MockTransport::new()),
             // this will not behave like the original mock transport but it's only used
             // in one place so let's keep this for now and fix it when we switch to
             // alloy in the 1 place that uses the mock provider.
@@ -34,174 +17,13 @@ impl Web3<MockTransport> {
             wallet: MutWallet::default(),
         }
     }
-
-    // HACK(jmg-duarte): used to convert a MockTransport -> DynTransport so we can
-    // remove ethcontract imports from shared should be fixed in a follow up PR,
-    // removing web3 from ethrpc
-    pub fn erased(self) -> Web3<DynTransport> {
-        Web3 {
-            legacy: web3::Web3::new(DynTransport::new(self.legacy.transport().clone())),
-            alloy: self.alloy,
-            wallet: self.wallet,
-        }
-    }
 }
 
-pub fn web3() -> Web3<MockTransport> {
+pub fn web3() -> Web3 {
     Web3 {
-        legacy: web3::Web3::new(MockTransport::new()),
-        // this will not behave like the original mock transport but it's only used
-        // in one place so let's keep this for now and fix it when we switch to
-        // alloy in the 1 place that uses the mock provider.
         alloy: ProviderBuilder::new()
             .connect_mocked_client(Asserter::new())
             .erased(),
         wallet: MutWallet::default(),
     }
 }
-
-/// An intermediate trait used for `mockall` to automatically generate a mock
-/// transport for us.
-#[mockall::automock]
-pub trait MockableTransport {
-    fn execute(&self, method: String, params: Vec<Value>) -> web3::Result<Value>;
-    fn execute_batch(
-        &self,
-        requests: Vec<(String, Vec<Value>)>,
-    ) -> web3::Result<Vec<web3::Result<Value>>>;
-}
-
-#[derive(Clone, Default)]
-pub struct MockTransport(Arc<Inner>);
-
-#[derive(Default)]
-pub struct Inner {
-    inner: Mutex<MockMockableTransport>,
-    current_id: AtomicUsize,
-}
-
-impl MockTransport {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn mock(&self) -> MutexGuard<'_, MockMockableTransport> {
-        self.0.inner.lock().unwrap()
-    }
-}
-
-impl Debug for MockTransport {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.debug_struct("MockTransport").finish()
-    }
-}
-
-impl Transport for MockTransport {
-    type Out = Ready<web3::Result<Value>>;
-
-    fn prepare(&self, method: &str, params: Vec<Value>) -> (RequestId, Call) {
-        let id = self.0.current_id.fetch_add(1, Ordering::SeqCst);
-        (
-            id,
-            Call::MethodCall(MethodCall {
-                jsonrpc: None,
-                method: method.to_owned(),
-                params: Params::Array(params),
-                id: Id::Null,
-            }),
-        )
-    }
-
-    fn send(&self, _: RequestId, call: Call) -> Self::Out {
-        let (method, params) = extract_call(call);
-        let response = self.mock().execute(method, params);
-        future::ready(response)
-    }
-}
-
-impl BatchTransport for MockTransport {
-    type Batch = Ready<web3::Result<Vec<web3::Result<Value>>>>;
-
-    fn send_batch<T>(&self, requests: T) -> Self::Batch
-    where
-        T: IntoIterator<Item = (RequestId, Call)>,
-    {
-        let batch = requests
-            .into_iter()
-            .map(|(_, call)| extract_call(call))
-            .collect();
-        let responses = self.mock().execute_batch(batch);
-        future::ready(responses)
-    }
-}
-
-fn extract_call(call: Call) -> (String, Vec<Value>) {
-    match call {
-        Call::MethodCall(MethodCall {
-            method,
-            params: Params::Array(params),
-            ..
-        }) => (method, params),
-        _ => panic!("unexpected call {call:?}"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, mockall::predicate::*, serde_json::json};
-
-    #[tokio::test]
-    async fn can_mock_single_requests() {
-        let transport = MockTransport::new();
-        transport
-            .mock()
-            .expect_execute()
-            .with(
-                eq("foo_bar".to_owned()),
-                eq(vec![json!(true), json!("stuff")]),
-            )
-            .returning(|_, _| Ok(json!("hello")));
-
-        assert_eq!(
-            transport
-                .execute("foo_bar", vec![json!(true), json!("stuff")])
-                .await
-                .unwrap(),
-            json!("hello")
-        );
-    }
-
-    #[tokio::test]
-    async fn can_mock_batch_requests() {
-        let transport = MockTransport::new();
-        transport
-            .mock()
-            .expect_execute_batch()
-            .with(eq(vec![
-                ("foo_bar".to_owned(), vec![json!(true), json!("stuff")]),
-                ("do_thing".to_owned(), vec![]),
-                ("fail_thing".to_owned(), vec![json!(42)]),
-            ]))
-            .returning(|_| {
-                Ok(vec![
-                    Ok(json!("hello")),
-                    Ok(json!("world")),
-                    Err(web3::Error::Transport(
-                        web3::error::TransportError::Message("bad".to_string()),
-                    )),
-                ])
-            });
-
-        let responses = transport
-            .send_batch(vec![
-                transport.prepare("foo_bar", vec![json!(true), json!("stuff")]),
-                transport.prepare("do_thing", vec![]),
-                transport.prepare("fail_thing", vec![json!(42)]),
-            ])
-            .await
-            .unwrap();
-        assert_eq!(responses[0].as_ref().unwrap(), &json!("hello"));
-        assert_eq!(responses[1].as_ref().unwrap(), &json!("world"));
-        assert!(responses[2].is_err());
-    }
-}
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 04e65e5fd3..1271d956e6 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -78,15 +78,12 @@ pub async fn start(args: impl Iterator<Item = String>) {
 pub async fn run(args: Arguments) {
     let http_factory = HttpClientFactory::new(&args.http_client);
 
-    let web3 = shared::ethrpc::web3(
-        &args.shared.ethrpc,
-        &http_factory,
-        &args.shared.node_url,
-        "base",
-    );
-    let simulation_web3 = args.shared.simulation_node_url.as_ref().map(|node_url| {
-        shared::ethrpc::web3(&args.shared.ethrpc, &http_factory, node_url, "simulation")
-    });
+    let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
+    let simulation_web3 = args
+        .shared
+        .simulation_node_url
+        .as_ref()
+        .map(|node_url| shared::ethrpc::web3(&args.shared.ethrpc, node_url, "simulation"));
 
     let chain_id = web3
         .alloy
@@ -259,12 +256,7 @@ pub async fn run(args: Arguments) {
     let trace_call_detector = args.tracing_node_url.as_ref().map(|tracing_node_url| {
         CachingDetector::new(
             Box::new(TraceCallDetector::new(
-                shared::ethrpc::web3(
-                    &args.shared.ethrpc,
-                    &http_factory,
-                    tracing_node_url,
-                    "trace",
-                ),
+                shared::ethrpc::web3(&args.shared.ethrpc, tracing_node_url, "trace"),
                 *settlement_contract.address(),
                 finder,
             )),
diff --git a/crates/refunder/src/lib.rs b/crates/refunder/src/lib.rs
index 4fc9a59675..c5a13365d4 100644
--- a/crates/refunder/src/lib.rs
+++ b/crates/refunder/src/lib.rs
@@ -11,7 +11,6 @@ use {
     contracts::alloy::CoWSwapEthFlow,
     observe::metrics::LivenessChecking,
     refund_service::RefundService,
-    shared::http_client::HttpClientFactory,
     sqlx::postgres::PgPoolOptions,
     std::{
         sync::{Arc, RwLock},
@@ -40,8 +39,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
 }
 
 pub async fn run(args: arguments::Arguments) {
-    let http_factory = HttpClientFactory::new(&args.http_client);
-    let web3 = shared::ethrpc::web3(&args.ethrpc, &http_factory, &args.node_url, "base");
+    let web3 = shared::ethrpc::web3(&args.ethrpc, &args.node_url, "base");
     if let Some(expected_chain_id) = args.chain_id {
         let chain_id = web3
             .alloy
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index dc991e85c7..14538595f1 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -36,7 +36,6 @@ model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
 order-validation = { workspace = true }
-primitive-types = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
@@ -52,7 +51,6 @@ tokio = { workspace = true, features = ["macros", "time", "signal"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 url = { workspace = true }
-web3 = { workspace = true }
 
 mockall = { workspace = true, optional = true }
 
diff --git a/crates/shared/src/account_balances/mod.rs b/crates/shared/src/account_balances/mod.rs
index 17b7463d53..03b853d41e 100644
--- a/crates/shared/src/account_balances/mod.rs
+++ b/crates/shared/src/account_balances/mod.rs
@@ -191,7 +191,7 @@ impl BalanceSimulator {
             )>::abi_decode(&response.0)
             .map_err(|err| {
                 tracing::error!(?err, "failed to decode balance response");
-                web3::error::Error::Decoder("failed to decode balance response".to_string())
+                alloy::contract::Error::AbiError(alloy::dyn_abi::Error::SolTypes(err))
             })?;
 
         let simulation = Simulation {
@@ -226,6 +226,4 @@ pub struct Simulation {
 pub enum SimulationError {
     #[error("method error: {0:?}")]
     Method(#[from] alloy::contract::Error),
-    #[error("web3 error: {0:?}")]
-    Web3(#[from] web3::error::Error),
 }
diff --git a/crates/shared/src/account_balances/simulation.rs b/crates/shared/src/account_balances/simulation.rs
index 7f5a70a6cf..b497fae6c5 100644
--- a/crates/shared/src/account_balances/simulation.rs
+++ b/crates/shared/src/account_balances/simulation.rs
@@ -8,7 +8,7 @@ use {
     alloy::primitives::{Address, U256},
     anyhow::Result,
     contracts::alloy::{BalancerV2Vault::BalancerV2Vault, ERC20},
-    ethrpc::Web3,
+    ethrpc::{Web3, alloy::ProviderLabelingExt},
     futures::future,
     model::order::SellTokenSource,
     tracing::instrument,
@@ -28,7 +28,7 @@ impl Balances {
         // contracts exist at addresses that get called. This allows us to
         // properly check if the `source` is not supported for the deployment
         // work without additional code paths :tada:!
-        let web3 = ethrpc::instrumented::instrument_with_label(web3, "balanceFetching".into());
+        let web3 = web3.labeled("balanceFetching");
 
         Self {
             web3,
diff --git a/crates/shared/src/bad_token/token_owner_finder/mod.rs b/crates/shared/src/bad_token/token_owner_finder/mod.rs
index 2e1fd183c5..e12b41de61 100644
--- a/crates/shared/src/bad_token/token_owner_finder/mod.rs
+++ b/crates/shared/src/bad_token/token_owner_finder/mod.rs
@@ -33,7 +33,7 @@ use {
     anyhow::{Context, Result},
     chain::Chain,
     contracts::alloy::{BalancerV2Vault, ERC20, IUniswapV3Factory},
-    ethrpc::alloy::errors::ContractErrorExt,
+    ethrpc::alloy::{ProviderLabelingExt, errors::ContractErrorExt},
     futures::{Stream, StreamExt as _},
     rate_limit::Strategy,
     reqwest::Url,
@@ -294,7 +294,7 @@ pub async fn init(
     base_tokens: &BaseTokens,
     settlement_contract: Address,
 ) -> Result<Arc<dyn TokenOwnerFinding>> {
-    let web3 = ethrpc::instrumented::instrument_with_label(&web3, "tokenOwners".into());
+    let web3 = web3.labeled("tokenOwners");
     let finders = args
         .token_owner_finders
         .as_deref()
diff --git a/crates/shared/src/ethrpc.rs b/crates/shared/src/ethrpc.rs
index d855f0c7af..51e52eb495 100644
--- a/crates/shared/src/ethrpc.rs
+++ b/crates/shared/src/ethrpc.rs
@@ -1,11 +1,10 @@
-pub use ethrpc::{Web3, Web3Transport};
+pub use ethrpc::Web3;
 use {
-    crate::http_client::HttpClientFactory,
-    reqwest::Url,
     std::{
         fmt::{self, Display, Formatter},
         time::Duration,
     },
+    url::Url,
 };
 
 pub const MAX_BATCH_SIZE: usize = 100;
@@ -59,13 +58,8 @@ impl Arguments {
     }
 }
 
-/// Create a Web3 instance.
-pub fn web3(
-    args: &Arguments,
-    http_factory: &HttpClientFactory,
-    url: &Url,
-    name: impl ToString,
-) -> Web3 {
-    let http_builder = http_factory.builder();
-    ethrpc::web3(args.ethrpc(), http_builder, url, name)
+/// Create a Web3 instance with a label for observability.
+pub fn web3(args: &Arguments, url: &Url, name: impl ToString) -> Web3 {
+    let label = name.to_string();
+    ethrpc::web3(args.ethrpc(), url, Some(&label))
 }
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 9db1e46594..8460a501b3 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -23,7 +23,6 @@ use {
     app_data::{AppDataHash, Hook, Hooks, ValidatedAppData, Validator},
     async_trait::async_trait,
     contracts::alloy::{HooksTrampoline, WETH9},
-    ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
     model::{
         DomainSeparator,
         interaction::InteractionData,
@@ -608,10 +607,9 @@ impl OrderValidating for OrderValidator {
         // Happens before signature verification because a miscalculated app data hash
         // by the API user would lead to being unable to validate the signature below.
         let app_data = self.validate_app_data(&order.app_data, &full_app_data_override)?;
-        let app_data_signer = app_data.inner.protocol.signer.map(IntoLegacy::into_legacy);
+        let app_data_signer = app_data.inner.protocol.signer;
 
-        let owner =
-            order.verify_owner(domain_separator, app_data_signer.map(IntoAlloy::into_alloy))?;
+        let owner = order.verify_owner(domain_separator, app_data_signer)?;
         tracing::debug!(?owner, "recovered owner from order and signature");
         let signing_scheme = order.signature.scheme();
         let data = OrderData {
diff --git a/crates/shared/src/price_estimation/competition/quote.rs b/crates/shared/src/price_estimation/competition/quote.rs
index 8c6be7c544..2caa30c786 100644
--- a/crates/shared/src/price_estimation/competition/quote.rs
+++ b/crates/shared/src/price_estimation/competition/quote.rs
@@ -8,11 +8,10 @@ use {
         Query,
         QuoteVerificationMode,
     },
+    alloy::primitives::{Address, U256},
     anyhow::Context,
-    ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
     futures::future::{BoxFuture, FutureExt, TryFutureExt},
     model::order::OrderKind,
-    primitive_types::{H160, U256},
     std::{cmp::Ordering, sync::Arc, time::Duration},
     tracing::instrument,
 };
@@ -27,9 +26,7 @@ impl PriceEstimating for CompetitionEstimator<Arc<dyn PriceEstimating>> {
                 OrderKind::Buy => query.sell_token,
                 OrderKind::Sell => query.buy_token,
             };
-            let get_context = self
-                .ranking
-                .provide_context(out_token.into_legacy(), query.timeout);
+            let get_context = self.ranking.provide_context(out_token, query.timeout);
 
             // Filter out obviously wrong estimates:
             // - 0 gas cost would lead to us paying huge subsidies
@@ -100,7 +97,7 @@ fn compare_quote(query: &Query, a: &Estimate, b: &Estimate, context: &RankingCon
 impl PriceRanking {
     async fn provide_context(
         &self,
-        token: H160,
+        token: Address,
         timeout: Duration,
     ) -> Result<RankingContext, PriceEstimationError> {
         match self {
@@ -114,10 +111,8 @@ impl PriceRanking {
                 let gas = gas
                     .effective_gas_price()
                     .map_err(PriceEstimationError::ProtocolInternal);
-                let (native_price, gas_price) = futures::try_join!(
-                    native.estimate_native_price(token.into_alloy(), timeout),
-                    gas
-                )?;
+                let (native_price, gas_price) =
+                    futures::try_join!(native.estimate_native_price(token, timeout), gas)?;
 
                 Ok(RankingContext {
                     native_price,
@@ -148,8 +143,16 @@ impl RankingContext {
             // High fees mean paying more `sell_token` for your buy order.
             OrderKind::Buy => eth_out + fees,
         };
-        // converts `NaN` and `(-∞, 0]` to `0`
-        U256::from_f64_lossy(effective_eth_out)
+        match effective_eth_out {
+            // converts `NaN` and `(-∞, 0]` to `0`
+            v if v.is_sign_negative() || v.is_nan() => U256::ZERO,
+            // Previous case already covered negative infinity
+            v if v.is_infinite() => U256::MAX,
+            // Note on truncation: previously we used primitive_types::U256::from_f64_lossy which
+            // truncated the floating point, while alloy is slightly more faithful to the original
+            // value and rounds to closest integer: [0, 0.5) => 0, [0.5, 1] => 1
+            v => U256::from(v.trunc()),
+        }
     }
 }
 
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index 0893f4cd68..305ecc11e8 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -31,7 +31,7 @@ use {
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
     contracts::alloy::WETH9,
-    ethrpc::block_stream::CurrentBlockWatcher,
+    ethrpc::{alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     number::nonzero::NonZeroU256,
     rate_limit::RateLimiter,
     reqwest::Url,
@@ -99,7 +99,7 @@ impl<'a> PriceEstimatorFactory<'a> {
         let Some(web3) = network.simulation_web3.clone() else {
             return Ok(None);
         };
-        let web3 = ethrpc::instrumented::instrument_with_label(&web3, "simulator".into());
+        let web3 = web3.labeled("simulator");
 
         let tenderly = shared_args
             .tenderly
diff --git a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs b/crates/shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs
index 44668f70b9..3462f18802 100644
--- a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs
+++ b/crates/shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs
@@ -542,7 +542,7 @@ mod tests {
         let balance_overrides = BalanceOverrides {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(mock_web3.erased(), 60),
+                Detector::new(mock_web3, 60),
                 Mutex::new(SizedCache::with_size(100)),
             )),
         };
@@ -590,7 +590,7 @@ mod tests {
         let balance_overrides = BalanceOverrides {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(mock_web3.erased(), 60),
+                Detector::new(mock_web3, 60),
                 Mutex::new(SizedCache::with_size(100)),
             )),
         };
diff --git a/crates/shared/src/signature_validator/simulation.rs b/crates/shared/src/signature_validator/simulation.rs
index 4f2a6e755f..d7d3adfa99 100644
--- a/crates/shared/src/signature_validator/simulation.rs
+++ b/crates/shared/src/signature_validator/simulation.rs
@@ -8,7 +8,7 @@ use {
     crate::price_estimation::trade_verifier::balance_overrides::BalanceOverriding,
     alloy::{
         dyn_abi::SolType,
-        primitives::Address,
+        primitives::{Address, U256},
         rpc::types::state::StateOverride,
         sol_types::{SolCall, sol_data},
         transports::RpcError,
@@ -19,8 +19,7 @@ use {
         GPv2Settlement,
         support::Signatures,
     },
-    ethrpc::{Web3, alloy::conversions::IntoLegacy},
-    primitive_types::U256,
+    ethrpc::{Web3, alloy::ProviderLabelingExt},
     std::sync::Arc,
     tracing::instrument,
 };
@@ -44,7 +43,7 @@ impl Validator {
         vault_relayer: Address,
         balance_overrider: Arc<dyn BalanceOverriding>,
     ) -> Self {
-        let web3 = ethrpc::instrumented::instrument_with_label(web3, "signatureValidation".into());
+        let web3 = web3.labeled("signatureValidation");
         Self {
             signatures_address,
             settlement,
@@ -148,14 +147,12 @@ impl Validator {
             })
             .map_err(|_| SignatureValidationError::Invalid)?;
 
-        let gas_used = <sol_data::Uint<256>>::abi_decode(&response_bytes.0)
-            .with_context(|| {
-                format!(
-                    "could not decode signature check result: {}",
-                    const_hex::encode(&response_bytes.0)
-                )
-            })?
-            .into_legacy();
+        let gas_used = <sol_data::Uint<256>>::abi_decode(&response_bytes.0).with_context(|| {
+            format!(
+                "could not decode signature check result: {}",
+                const_hex::encode(&response_bytes.0)
+            )
+        })?;
 
         Ok(Simulation { gas_used })
     }
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs b/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
index 3d9c027643..5cb30bfc92 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
+++ b/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
@@ -51,7 +51,10 @@ use {
         BalancerV2WeightedPoolFactoryV3,
         BalancerV2WeightedPoolFactoryV4,
     },
-    ethrpc::block_stream::{BlockRetrieving, CurrentBlockWatcher},
+    ethrpc::{
+        alloy::ProviderLabelingExt,
+        block_stream::{BlockRetrieving, CurrentBlockWatcher},
+    },
     model::TokenPair,
     reqwest::{Client, Url},
     std::{
@@ -247,7 +250,7 @@ impl BalancerPoolFetcher {
         deny_listed_pool_ids: Vec<B256>,
     ) -> Result<Self> {
         let pool_initializer = BalancerSubgraphClient::from_subgraph_url(subgraph_url, client)?;
-        let web3 = ethrpc::instrumented::instrument_with_label(&web3, "balancerV2".into());
+        let web3 = web3.labeled("balancerV2");
         let fetcher = Arc::new(Cache::new(
             create_aggregate_pool_fetcher(
                 web3,
diff --git a/crates/shared/src/sources/balancer_v2/pools/weighted.rs b/crates/shared/src/sources/balancer_v2/pools/weighted.rs
index 3e60249538..56a7e16734 100644
--- a/crates/shared/src/sources/balancer_v2/pools/weighted.rs
+++ b/crates/shared/src/sources/balancer_v2/pools/weighted.rs
@@ -151,7 +151,7 @@ mod tests {
             providers::{Provider, ProviderBuilder, mock::Asserter},
             sol_types::SolCall,
         },
-        ethrpc::{Web3, mock::MockTransport},
+        ethrpc::Web3,
         futures::future,
         maplit::btreemap,
     };
@@ -279,7 +279,7 @@ mod tests {
 
         let asserter = Asserter::new();
         asserter.push_success(&10);
-        let web3 = Web3::<MockTransport>::with_asserter(asserter);
+        let web3 = Web3::with_asserter(asserter);
 
         let factory =
             BalancerV2WeightedPoolFactory::Instance::new(Address::default(), web3.alloy.clone());
diff --git a/crates/shared/src/sources/uniswap_v2/mod.rs b/crates/shared/src/sources/uniswap_v2/mod.rs
index 8c07616489..d23a4d1d6f 100644
--- a/crates/shared/src/sources/uniswap_v2/mod.rs
+++ b/crates/shared/src/sources/uniswap_v2/mod.rs
@@ -16,6 +16,7 @@ use {
     alloy::primitives::{Address, B256},
     anyhow::{Context, Result},
     contracts::alloy::IUniswapLikeRouter,
+    ethrpc::alloy::ProviderLabelingExt,
     hex_literal::hex,
     std::{fmt::Display, str::FromStr, sync::Arc},
 };
@@ -102,7 +103,7 @@ impl UniV2BaselineSourceParameters {
     }
 
     pub async fn into_source(&self, web3: &Web3) -> Result<UniV2BaselineSource> {
-        let web3 = ethrpc::instrumented::instrument_with_label(web3, "uniswapV2".into());
+        let web3 = web3.labeled("uniswapV2");
         let router =
             contracts::alloy::IUniswapLikeRouter::Instance::new(self.router, web3.alloy.clone());
         let factory = router.factory().call().await.context("factory")?;
diff --git a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs b/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
index 9eab04c7ae..f839e2107a 100644
--- a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
+++ b/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
@@ -20,6 +20,7 @@ use {
     },
     ethrpc::{
         Web3,
+        alloy::ProviderLabelingExt,
         block_stream::{BlockRetrieving, RangeInclusive},
     },
     itertools::{Either, Itertools},
@@ -287,7 +288,7 @@ impl UniswapV3PoolFetcher {
         max_pools_to_initialize: usize,
         max_pools_per_tick_query: usize,
     ) -> Result<Self> {
-        let web3 = ethrpc::instrumented::instrument_with_label(&web3, "uniswapV3".into());
+        let web3 = web3.labeled("uniswapV3");
         let checkpoint = PoolsCheckpointHandler::new(
             subgraph_url,
             client,
diff --git a/crates/solvers/src/domain/solver.rs b/crates/solvers/src/domain/solver.rs
index fc58155fe8..ac1463eaab 100644
--- a/crates/solvers/src/domain/solver.rs
+++ b/crates/solvers/src/domain/solver.rs
@@ -79,7 +79,7 @@ impl Solver {
     pub async fn new(config: Config) -> Self {
         let uni_v3_quoter_v2 = match config.uni_v3_node_url {
             Some(url) => {
-                let web3 = ethrpc::web3(Default::default(), Default::default(), &url, "baseline");
+                let web3 = ethrpc::web3(Default::default(), &url, Some("baseline"));
                 contracts::alloy::UniswapV3QuoterV2::Instance::deployed(&web3.alloy)
                     .await
                     .map(Arc::new)

From 3760d319d0162cb826936c538ac7deeceead947a Mon Sep 17 00:00:00 2001
From: tilacog <tilacog@gmail.com>
Date: Tue, 3 Feb 2026 11:16:23 -0300
Subject: [PATCH 028/219] =?UTF-8?q?Trait=E2=80=91Based=20Architecture=20fo?=
 =?UTF-8?q?r=20Refunder=20Service=20(#4051)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Description

This PR follows up on #4029 and introduces a **trait‑based
architecture** for the `refunder` crate. By decoupling the
`RefundService` from concrete database and blockchain implementations,
we can now write unit tests without relying on (heavyweight) integration
tests.


### Changes

- Added a new `traits.rs` module that defines `DbRead`, `ChainRead`, and
`ChainWrite` traits to abstract the two main boundaries of the system.
- Created an `infra/` module housing the previous concrete
implementations of those traits:
  - `AlloyChain` implements `ChainRead`
  - `Postgres` implements `DbRead`
- Made `RefundService` generic over those traits, so we can use mocks
for unit testing it (and thes real/production implementations) as
needed.
- Extracted `identify_uids_refunding_status` into its own function, to
simplify testing.
- Moved the `RefundStatus` enum into `traits.rs` so it lives alongside
the related abstractions.
- Reorganized the service construction inside `run()` for clearer flow.
- Added a suite of unit tests that use mocks to cover a variety of
scenarios.

### How to test

Run the unit tests with:

```bash
cargo nextest run -p refunder
```
---
 Cargo.lock                            |  111 +--
 crates/e2e/tests/e2e/refunder.rs      |   24 +-
 crates/refunder/Cargo.toml            |    5 +
 crates/refunder/src/infra/chain.rs    |   64 ++
 crates/refunder/src/infra/database.rs |   89 ++
 crates/refunder/src/infra/mod.rs      |    6 +
 crates/refunder/src/lib.rs            |   77 +-
 crates/refunder/src/refund_service.rs | 1229 +++++++++++++++++++------
 crates/refunder/src/submitter.rs      |  112 +--
 crates/refunder/src/traits.rs         |  142 +++
 10 files changed, 1440 insertions(+), 419 deletions(-)
 create mode 100644 crates/refunder/src/infra/chain.rs
 create mode 100644 crates/refunder/src/infra/database.rs
 create mode 100644 crates/refunder/src/infra/mod.rs
 create mode 100644 crates/refunder/src/traits.rs

diff --git a/Cargo.lock b/Cargo.lock
index f94928ee4f..ffdab7f40b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -47,9 +47,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "alloy"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05c97aa0031055a663e364890f2bc15879d6ec38dae9fbeece68fcc82d9cdb81"
+checksum = "3cb837e538ce3eac04e357ef47b8acead0b14c83ec6bcafedd167e6a60c40876"
 dependencies = [
  "alloy-consensus",
  "alloy-contract",
@@ -84,9 +84,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e30ab0d3e3c32976f67fc1a96179989e45a69594af42003a6663332f9b0bb9d"
+checksum = "12870ab65b131f609257436935047eec3cfabee8809732f6bf5a69fe2a18cf2e"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -111,9 +111,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus-any"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20736b1f9d927d875d8777ef0c2250d4c57ea828529a9dbfa2c628db57b911e"
+checksum = "47c66b14d2187de0c4efe4ef678aaa57a6a34cccdbea3a0773627fac9bd128f4"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -125,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-contract"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "008aba161fce2a0d94956ae09d7d7a09f8fbdf18acbef921809ef126d6cdaf97"
+checksum = "e9bf6afe8c25b63c98927c6f76d90cf8dc443cc4980a7d824151c84a6e568934"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
@@ -216,9 +216,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-eips"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15b85157b7be31fc4adf6acfefcb0d4308cba5dbd7a8d8e62bcc02ff37d6131a"
+checksum = "f076d25ddfcd2f1cbcc234e072baf97567d1df0e3fccdc1f8af8cc8b18dc6299"
 dependencies = [
  "alloy-eip2124",
  "alloy-eip2930",
@@ -251,9 +251,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-json-rpc"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60f045b69b5e80b8944b25afe74ae6b974f3044d84b4a7a113da04745b2524cc"
+checksum = "250dbd8496f04eabe997e6e4c5186a0630b8bc3dbe7552e1fd917d491ef811e9"
 dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
@@ -266,9 +266,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-network"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b314ed5bdc7f449c53853125af2db5ac4d3954a9f4b205e7d694f02fc1932d1"
+checksum = "fd45cdac957d1fa1d0c18f54f262350eb72f1adc38dd1f8b15f33f0747c6a60c"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
@@ -292,9 +292,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-network-primitives"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e9762ac5cca67b0f6ab614f7f8314942eead1c8eeef61511ea43a6ff048dbe0"
+checksum = "fba5c43e055effb5bd33dbc74b1ab7fe0f367d8801a25af9e7c716b3ef5e440b"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -334,9 +334,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-provider"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea8f7ca47514e7f552aa9f3f141ab17351332c6637e3bf00462d8e7c5f10f51f"
+checksum = "9e87a90cacc27dffd91fa6440145934a782227d31b9876444c5924d3607084ea"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -379,9 +379,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-pubsub"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4082778c908aa801a1f9fdc85d758812842ab4b2aaba58e9dbe7626d708ab7e1"
+checksum = "c24a102935aa9d5a8b8fc8c47f39a0823672c33f0b27b5806292cb80988e6345"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -423,9 +423,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-client"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26dd083153d2cb73cce1516f5a3f9c3af74764a2761d901581a355777468bd8f"
+checksum = "57a65bb9060e43e9738bbd7c30d742ed962d609f2123a665bbdab7e6e0f13fd3"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -448,9 +448,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c998214325cfee1fbe61e5abaed3a435f4ca746ac7399b46feb57c364552452"
+checksum = "98bfd40f4e36cb29015ec744bc764629edbe823ec6b95aceef2684090c142976"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-anvil",
@@ -464,9 +464,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-anvil"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2b03d65fcf579fbf17d3aac32271f99e2b562be04097436cd6e766b3e06613b"
+checksum = "1ac7d0dbb62e807028554e34c2b5724a1f57132792684107c32009e84fcf4044"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -476,9 +476,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-any"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b4a6f49d161ef83354d5ba3c8bc83c8ee464cb90182b215551d5c4b846579be"
+checksum = "8faa6f22068857f58579271b15e042f4725ad35cdce2ed4778ba32ffd3102b92"
 dependencies = [
  "alloy-consensus-any",
  "alloy-rpc-types-eth",
@@ -487,9 +487,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-debug"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "467025b916f32645f322a085d0017f2996d0200ac89dd82a4fc2bf0f17b9afa3"
+checksum = "ccb37a9eee8e7a19bb07b5cd55d33457884e44b212588b7429c5d318d2b90295"
 dependencies = [
  "alloy-primitives",
  "derive_more 2.1.1",
@@ -499,9 +499,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-eth"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11920b16ab7c86052f990dcb4d25312fb2889faf506c4ee13dc946b450536989"
+checksum = "1ec734cce11f7fe889950b36b51589397528b26beb6f890834a2131ee9f174d7"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
@@ -520,9 +520,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-trace"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "498375e6a13b6edd04422a13d2b1a6187183e5a3aa14c5907b4c566551248bab"
+checksum = "7fe64cd4af2e68b2154ac02a7908249a448fbd3d1d05890786a5af93686083cc"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -534,9 +534,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-txpool"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9123d321ecd70925646eb2c60b1d9b7a965f860fbd717643e2c20fcf85d48d"
+checksum = "9504c0f00a72883e640abc4681a5691a57dec693bc28d4aa80257c8e1e9e6e1f"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -546,9 +546,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-serde"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1a0d2d5c64881f3723232eaaf6c2d9f4f88b061c63e87194b2db785ff3aa31f"
+checksum = "27f076bfd74fccc63d50546e1765359736357a953de2eb778b7b6191571735e6"
 dependencies = [
  "alloy-primitives",
  "serde",
@@ -557,9 +557,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ea4ac9765e5a7582877ca53688e041fe184880fe75f16edf0945b24a319c710"
+checksum = "d80748c209a68421ab6f737828ce6ede7543569a5cad099c1ec16fc1baa05620"
 dependencies = [
  "alloy-dyn-abi",
  "alloy-primitives",
@@ -574,9 +574,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-aws"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cf9b92d8e2a467942397b8b07c75bf05f32d0cbe290959a75518f18141ae8"
+checksum = "a2a0b80a0e21c1b8d7321d0a88bd115ad1182c293ca7e3dd0217c156f98b5b1e"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -593,9 +593,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-local"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c9d85b9f7105ab5ce7dae7b0da33cd9d977601a48f759e1c82958978dd1a905"
+checksum = "17eb1eb39351b4bf20bb0710d8d3a91eb7918d3f3de2f3835f556842e33865cb"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -685,9 +685,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e72f5c4ba505ebead6a71144d72f21a70beadfb2d84e0a560a985491ecb71de"
+checksum = "4a0c1a0288cdff6ee2b2c2c98ab42889d221ca8a9ee4120ede59b5449e0dcb20"
 dependencies = [
  "alloy-json-rpc",
  "auto_impl",
@@ -708,9 +708,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-http"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "400dc298aaabdbd48be05448c4a19eaa38416c446043f3e54561249149269c32"
+checksum = "36dfa207caf6b528b9466c714626f5b2dfd5e8d4595a74631d5670672dac102b"
 dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
@@ -723,9 +723,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-ws"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c38b4472f2bbd96a27f393de9e2f12adca0dc1075fb4d0f7c8f3557c5c600392"
+checksum = "91620efb46f8d011e37f74fac53a643e830a7bb24982143094b887003cbfb6be"
 dependencies = [
  "alloy-pubsub",
  "alloy-transport",
@@ -756,9 +756,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-tx-macros"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2183706e24173309b0ab0e34d3e53cf3163b71a419803b2b3b0c1fb7ff7a941"
+checksum = "bb0d567f4830dea921868c7680004ae0c7f221b05e6477db6c077c7953698f56"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -5395,10 +5395,13 @@ dependencies = [
  "futures",
  "humantime",
  "mimalloc",
+ "mockall",
  "number",
  "observe",
  "prometheus",
  "prometheus-metric-storage",
+ "rand 0.8.5",
+ "rstest",
  "shared",
  "sqlx",
  "tikv-jemallocator",
@@ -5658,9 +5661,9 @@ checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
 
 [[package]]
 name = "rust_decimal"
-version = "1.39.0"
+version = "1.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35affe401787a9bd846712274d97654355d21b2a2c092a3139aabe31e9022282"
+checksum = "61f703d19852dbf87cbc513643fa81428361eb6940f1ac14fd58155d295a3eb0"
 dependencies = [
  "arrayvec",
  "num-traits",
diff --git a/crates/e2e/tests/e2e/refunder.rs b/crates/e2e/tests/e2e/refunder.rs
index d33ade45aa..01ace9ad94 100644
--- a/crates/e2e/tests/e2e/refunder.rs
+++ b/crates/e2e/tests/e2e/refunder.rs
@@ -292,13 +292,13 @@ async fn run_refunder_threshold_test(
 
     advance_time_past_expiration(&web3, valid_to).await;
 
-    let mut refund_service = RefundService::new(
+    let mut refund_service = RefundService::from_components(
         services.db().clone(),
         web3.clone(),
-        vec![ethflow_contract.clone()],
+        vec![*ethflow_contract.address()],
         validity.enforced,
         slippage.enforced,
-        Box::new(refunder_account.signer.clone()),
+        refunder_account.signer.clone(),
         MAX_GAS_PRICE,
         START_PRIORITY_FEE_TIP,
         None,
@@ -419,13 +419,13 @@ async fn refunder_skips_invalidated_orders(web3: Web3) {
 
     advance_time_past_expiration(&web3, valid_to).await;
 
-    let mut refund_service = RefundService::new(
+    let mut refund_service = RefundService::from_components(
         services.db().clone(),
         web3.clone(),
-        vec![ethflow_contract.clone()],
+        vec![*ethflow_contract.address()],
         0, // min_validity_duration = 0 (permissive)
         0, // min_price_deviation_bps = 0 (permissive)
-        Box::new(refunder_account.signer.clone()),
+        refunder_account.signer.clone(),
         MAX_GAS_PRICE,
         START_PRIORITY_FEE_TIP,
         None,
@@ -527,13 +527,13 @@ async fn refunder_skips_settled_orders(web3: Web3) {
         "Settled order should not be invalidated on-chain"
     );
 
-    let mut refund_service = RefundService::new(
+    let mut refund_service = RefundService::from_components(
         services.db().clone(),
         web3.clone(),
-        vec![ethflow_contract.clone()],
+        vec![*ethflow_contract.address()],
         0, // min_validity_duration = 0 (permissive)
         0, // min_price_deviation_bps = 0 (permissive)
-        Box::new(refunder_account.signer),
+        refunder_account.signer,
         MAX_GAS_PRICE,
         START_PRIORITY_FEE_TIP,
         None,
@@ -624,13 +624,13 @@ async fn refunder_multiple_ethflow_contracts(web3: Web3) {
 
     advance_time_past_expiration(&web3, valid_to).await;
 
-    let mut refund_service = RefundService::new(
+    let mut refund_service = RefundService::from_components(
         services.db().clone(),
         web3,
-        vec![ethflow_contract.clone(), ethflow_contract_2.clone()],
+        vec![*ethflow_contract.address(), *ethflow_contract_2.address()],
         validity_duration as i64 / 2,
         10,
-        Box::new(refunder.signer),
+        refunder.signer,
         MAX_GAS_PRICE,
         START_PRIORITY_FEE_TIP,
         None,
diff --git a/crates/refunder/Cargo.toml b/crates/refunder/Cargo.toml
index e81abd9417..f6d1d7bac3 100644
--- a/crates/refunder/Cargo.toml
+++ b/crates/refunder/Cargo.toml
@@ -28,6 +28,11 @@ tokio = { workspace = true, features = ["macros", "time", "rt-multi-thread"] }
 tracing = { workspace = true }
 url = { workspace = true }
 
+[dev-dependencies]
+mockall = { workspace = true }
+rand = { workspace = true }
+rstest = { workspace = true }
+
 [lints]
 workspace = true
 
diff --git a/crates/refunder/src/infra/chain.rs b/crates/refunder/src/infra/chain.rs
new file mode 100644
index 0000000000..f7b660a5f9
--- /dev/null
+++ b/crates/refunder/src/infra/chain.rs
@@ -0,0 +1,64 @@
+//! Blockchain access via Alloy.
+
+use {
+    crate::traits::{ChainRead, RefundStatus},
+    alloy::{primitives::Address, providers::Provider, rpc::types::TransactionRequest},
+    anyhow::{Result, anyhow},
+    contracts::alloy::CoWSwapEthFlow,
+    ethrpc::{AlloyProvider, block_stream::timestamp_of_current_block_in_seconds},
+    std::collections::HashMap,
+};
+
+/// [`ChainRead`] implementation using Alloy.
+pub struct AlloyChain {
+    provider: AlloyProvider,
+    ethflow_contracts: HashMap<Address, CoWSwapEthFlow::Instance>,
+}
+
+impl AlloyChain {
+    pub fn new(provider: AlloyProvider, ethflow_addresses: Vec<Address>) -> Self {
+        let ethflow_contracts = ethflow_addresses
+            .into_iter()
+            .map(|addr| {
+                let instance = CoWSwapEthFlow::Instance::new(addr, provider.clone());
+                (addr, instance)
+            })
+            .collect();
+        Self {
+            provider,
+            ethflow_contracts,
+        }
+    }
+}
+
+impl ChainRead for AlloyChain {
+    async fn current_block_timestamp(&self) -> Result<u32> {
+        timestamp_of_current_block_in_seconds(&self.provider).await
+    }
+
+    async fn can_receive_eth(&self, address: Address) -> bool {
+        let tx = TransactionRequest::default()
+            .to(address)
+            .value(alloy::primitives::U256::from(1));
+
+        self.provider.estimate_gas(tx).await.is_ok()
+    }
+
+    fn ethflow_addresses(&self) -> Vec<Address> {
+        self.ethflow_contracts.keys().copied().collect()
+    }
+
+    async fn get_order_status(
+        &self,
+        ethflow_address: Address,
+        order_hash: alloy::primitives::B256,
+    ) -> Result<RefundStatus> {
+        let contract = self
+            .ethflow_contracts
+            .get(&ethflow_address)
+            .ok_or_else(|| anyhow!("Unknown EthFlow contract: {ethflow_address}"))?;
+
+        let order = contract.orders(order_hash).call().await?;
+        Ok(order.into())
+    }
+}
diff --git a/crates/refunder/src/infra/database.rs b/crates/refunder/src/infra/database.rs
new file mode 100644
index 0000000000..2bbbf246d2
--- /dev/null
+++ b/crates/refunder/src/infra/database.rs
@@ -0,0 +1,89 @@
+//! Database access via PostgreSQL.
+
+use {
+    crate::traits::DbRead,
+    alloy::primitives::Address,
+    anyhow::{Context, Result},
+    contracts::alloy::CoWSwapEthFlow::EthFlowOrder,
+    database::{
+        OrderUid,
+        ethflow_orders::{EthOrderPlacement, read_order, refundable_orders},
+        orders::read_order as read_db_order,
+    },
+    number::conversions::big_decimal_to_u256,
+    sqlx::PgPool,
+    std::time::Duration,
+};
+
+/// [`DbRead`] implementation using PostgreSQL.
+pub struct Postgres {
+    pool: PgPool,
+    lookback_time: Option<Duration>,
+}
+
+impl Postgres {
+    pub fn new(pool: PgPool, lookback_time: Option<Duration>) -> Self {
+        Self {
+            pool,
+            lookback_time,
+        }
+    }
+}
+
+impl DbRead for Postgres {
+    async fn get_refundable_orders(
+        &self,
+        block_time: i64,
+        min_validity_duration: i64,
+        min_price_deviation: f64,
+    ) -> Result<Vec<EthOrderPlacement>> {
+        let mut ex = self.pool.acquire().await?;
+        refundable_orders(
+            &mut ex,
+            block_time,
+            min_validity_duration,
+            min_price_deviation,
+            self.lookback_time,
+        )
+        .await
+        .context("Error while retrieving the refundable ethflow orders from db")
+    }
+
+    async fn get_ethflow_order_data(&self, uid: &OrderUid) -> Result<EthFlowOrder::Data> {
+        let mut ex = self
+            .pool
+            .acquire()
+            .await
+            .with_context(|| format!("acquire connection for uid {uid:?}"))?;
+        let order = read_db_order(&mut ex, uid)
+            .await
+            .with_context(|| format!("read order {uid:?}"))?
+            .with_context(|| format!("missing order {uid:?}"))?;
+        let ethflow_order = read_order(&mut ex, uid)
+            .await
+            .with_context(|| format!("read ethflow order {uid:?}"))?
+            .with_context(|| format!("missing ethflow order {uid:?}"))?;
+
+        let receiver = order
+            .receiver
+            .with_context(|| format!("order {uid:?} missing receiver"))?;
+        let sell_amount = big_decimal_to_u256(&order.sell_amount)
+            .with_context(|| format!("order {uid:?} invalid sell_amount"))?;
+        let buy_amount = big_decimal_to_u256(&order.buy_amount)
+            .with_context(|| format!("order {uid:?} invalid buy_amount"))?;
+        let fee_amount = big_decimal_to_u256(&order.fee_amount)
+            .with_context(|| format!("order {uid:?} invalid fee_amount"))?;
+
+        Ok(EthFlowOrder::Data {
+            buyToken: Address::from(order.buy_token.0),
+            receiver: Address::from(receiver.0),
+            sellAmount: sell_amount,
+            buyAmount: buy_amount,
+            appData: order.app_data.0.into(),
+            feeAmount: fee_amount,
+            validTo: ethflow_order.valid_to as u32,
+            partiallyFillable: order.partially_fillable,
+            quoteId: 0i64, // quoteId is not important for refunding and will be ignored
+        })
+    }
+}
diff --git a/crates/refunder/src/infra/mod.rs b/crates/refunder/src/infra/mod.rs
new file mode 100644
index 0000000000..fc1819c3cf
--- /dev/null
+++ b/crates/refunder/src/infra/mod.rs
@@ -0,0 +1,6 @@
+//! Production implementations of `DbRead`, `ChainRead`, and `ChainWrite`.
+
+mod chain;
+mod database;
+
+pub use {chain::AlloyChain, database::Postgres};
diff --git a/crates/refunder/src/lib.rs b/crates/refunder/src/lib.rs
index c5a13365d4..92815ec760 100644
--- a/crates/refunder/src/lib.rs
+++ b/crates/refunder/src/lib.rs
@@ -1,14 +1,24 @@
+//! Automated refunder for expired EthFlow orders.
+//!
+//! Monitors EthFlow orders and returns ETH to users whose orders expired
+//! without filling. Runs every 30 seconds: queries database, validates on-chain
+//! status, submits batch refunds.
+//!
+//! Shares PostgreSQL with orderbook (read-only). Refunds tracked via on-chain
+//! events.
+
 pub mod arguments;
+pub mod infra;
 pub mod refund_service;
 pub mod submitter;
+pub mod traits;
 
 // Re-export commonly used types for external consumers (e.g., e2e tests)
-pub use refund_service::RefundStatus;
+pub use traits::RefundStatus;
 use {
     crate::arguments::Arguments,
     alloy::{providers::Provider, signers::local::PrivateKeySigner},
     clap::Parser,
-    contracts::alloy::CoWSwapEthFlow,
     observe::metrics::LivenessChecking,
     refund_service::RefundService,
     sqlx::postgres::PgPoolOptions,
@@ -39,7 +49,26 @@ pub async fn start(args: impl Iterator<Item = String>) {
 }
 
 pub async fn run(args: arguments::Arguments) {
+    // Observability setup
+    let liveness = Arc::new(Liveness {
+        last_successful_loop: RwLock::new(Instant::now()),
+    });
+    observe::metrics::serve_metrics(
+        liveness.clone(),
+        ([0, 0, 0, 0], args.metrics_port).into(),
+        Default::default(),
+        Default::default(),
+    );
+
+    // Database initialization
+    let pg_pool = PgPoolOptions::new()
+        .max_connections(args.database_pool.db_max_connections.get())
+        .connect_lazy(args.db_url.as_str())
+        .expect("failed to create database");
+
+    // Blockchain/RPC setup
     let web3 = shared::ethrpc::web3(&args.ethrpc, &args.node_url, "base");
+
     if let Some(expected_chain_id) = args.chain_id {
         let chain_id = web3
             .alloy
@@ -52,45 +81,31 @@ pub async fn run(args: arguments::Arguments) {
         );
     }
 
-    let pg_pool = PgPoolOptions::new()
-        .max_connections(args.database_pool.db_max_connections.get())
-        .connect_lazy(args.db_url.as_str())
-        .expect("failed to create database");
+    // Signer configuration
+    let signer = args
+        .refunder_pk
+        .parse::<PrivateKeySigner>()
+        .expect("couldn't parse refunder private key");
 
-    let liveness = Arc::new(Liveness {
-        // Program will be healthy at the start even if no loop was ran yet.
-        last_successful_loop: RwLock::new(Instant::now()),
-    });
-    observe::metrics::serve_metrics(
-        liveness.clone(),
-        ([0, 0, 0, 0], args.metrics_port).into(),
-        Default::default(),
-        Default::default(),
-    );
+    // Service construction
+    let min_validity_duration =
+        i64::try_from(args.min_validity_duration.as_secs()).unwrap_or(i64::MAX);
 
-    let ethflow_contracts = args
-        .ethflow_contracts
-        .iter()
-        .map(|contract| CoWSwapEthFlow::Instance::new(*contract, web3.alloy.clone()))
-        .collect();
-    let refunder_account = Box::new(
-        args.refunder_pk
-            .parse::<PrivateKeySigner>()
-            .expect("couldn't parse refunder private key"),
-    );
-    let mut refunder = RefundService::new(
+    let mut refunder = RefundService::from_components(
         pg_pool,
         web3,
-        ethflow_contracts,
-        i64::try_from(args.min_validity_duration.as_secs()).unwrap_or(i64::MAX),
+        args.ethflow_contracts,
+        min_validity_duration,
         args.min_price_deviation_bps,
-        refunder_account,
+        signer,
         args.max_gas_price,
         args.start_priority_fee_tip,
         Some(args.lookback_time),
     );
+
+    // Main loop
     loop {
-        tracing::info!("Staring a new refunding loop");
+        tracing::info!("Starting a new refunding loop");
         match refunder.try_to_refund_all_eligible_orders().await {
             Ok(_) => {
                 track_refunding_loop_result("success");
diff --git a/crates/refunder/src/refund_service.rs b/crates/refunder/src/refund_service.rs
index 2c7924d6da..ca1e087589 100644
--- a/crates/refunder/src/refund_service.rs
+++ b/crates/refunder/src/refund_service.rs
@@ -1,271 +1,194 @@
+//! Refund eligibility checks and batch submission.
+
 use {
-    crate::submitter::Submitter,
-    alloy::{
-        network::TxSigner,
-        primitives::{Address, B256, Signature},
-        providers::Provider,
-        rpc::types::TransactionRequest,
-    },
-    anyhow::{Context, Result, anyhow},
-    contracts::alloy::CoWSwapEthFlow,
-    database::{
-        OrderUid,
-        ethflow_orders::{EthOrderPlacement, read_order, refundable_orders},
-        orders::read_order as read_db_order,
+    crate::{
+        infra::{AlloyChain, Postgres},
+        submitter::Submitter,
+        traits::{ChainRead, ChainWrite, DbRead, RefundStatus},
     },
-    ethrpc::{Web3, block_stream::timestamp_of_current_block_in_seconds},
+    alloy::primitives::{Address, B256},
+    anyhow::Result,
+    database::{OrderUid, ethflow_orders::EthOrderPlacement},
     futures::{StreamExt, stream},
-    number::conversions::big_decimal_to_u256,
-    shared::gas_price_estimation::eth_node::NodeGasPriceEstimator,
-    sqlx::PgPool,
-    std::{collections::HashMap, time::Duration},
+    std::collections::HashMap,
 };
 
-pub const NO_OWNER: Address = Address::ZERO;
-pub const INVALIDATED_OWNER: Address = Address::repeat_byte(0xff);
 const MAX_NUMBER_OF_UIDS_PER_REFUND_TX: usize = 30;
+const BASIS_POINT_DENOMINATOR: f64 = 10_000.0;
 
 type CoWSwapEthFlowAddress = Address;
 
-pub struct RefundService {
-    pub db: PgPool,
-    pub web3: Web3,
-    pub ethflow_contracts: Vec<CoWSwapEthFlow::Instance>,
-    pub min_validity_duration: i64,
-    pub min_price_deviation: f64,
-    pub submitter: Submitter,
-    pub max_gas_price: u64,
-    pub start_priority_fee_tip: u64,
-    pub lookback_time: Option<Duration>,
+/// Extracts the EthFlow contract address from an order if it's in the
+/// allowlist.
+///
+/// Returns `None` (with a warning log) if the contract is not enabled for
+/// refunds.
+fn extract_known_ethflow_address(
+    eth_order_placement: &EthOrderPlacement,
+    known_ethflow_addresses: &[Address],
+) -> Option<Address> {
+    let ethflow_contract_address = Address::from_slice(&eth_order_placement.uid.0[32..52]);
+    if known_ethflow_addresses.contains(&ethflow_contract_address) {
+        Some(ethflow_contract_address)
+    } else {
+        tracing::warn!(
+            uid = const_hex::encode_prefixed(eth_order_placement.uid.0),
+            ethflow = ?ethflow_contract_address,
+            "refunding orders from specific contract is not enabled",
+        );
+        None
+    }
 }
 
-/// Status of an EthFlow order refund eligibility.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum RefundStatus {
-    /// Order has already been refunded or cancelled.
-    Refunded,
-    /// Order is still active and eligible for refund, with the given owner
-    /// address.
-    NotYetRefunded(Address),
-    /// Order is invalid (never created, already freed, or owner cannot receive
-    /// ETH).
-    Invalid,
+/// Queries on-chain refund status for a single order.
+///
+/// Returns `None` if the status query fails. Marks orders as `Invalid` if
+/// the owner cannot receive ETH.
+async fn query_order_refund_status<C: ChainRead>(
+    chain: &C,
+    eth_order_placement: &EthOrderPlacement,
+    ethflow_contract_address: Address,
+) -> Option<(OrderUid, RefundStatus, Address)> {
+    use RefundStatus::*;
+    let order_hash: [u8; 32] = eth_order_placement.uid.0[0..32]
+        .try_into()
+        .expect("order_uid slice with incorrect length");
+
+    let status = match chain
+        .get_order_status(ethflow_contract_address, B256::from(order_hash))
+        .await
+    {
+        Err(err) => {
+            tracing::error!(
+                uid =? B256::from(order_hash),
+                ?err,
+                "Error while getting the current onchain status of the order"
+            );
+            return None;
+        }
+        Ok(NotYetRefunded(owner)) if !chain.can_receive_eth(owner).await => {
+            tracing::warn!(
+                uid = const_hex::encode_prefixed(eth_order_placement.uid.0),
+                ?owner,
+                "Order owner cannot receive ETH - marking as invalid"
+            );
+            Invalid
+        }
+        Ok(other) => other,
+    };
+
+    Some((eth_order_placement.uid, status, ethflow_contract_address))
 }
 
-impl From<CoWSwapEthFlow::CoWSwapEthFlow::ordersReturn> for RefundStatus {
-    fn from(value: CoWSwapEthFlow::CoWSwapEthFlow::ordersReturn) -> Self {
-        match value.owner {
-            NO_OWNER => Self::Invalid,
-            INVALIDATED_OWNER => Self::Refunded,
-            owner => Self::NotYetRefunded(owner),
+/// Filters `refundable_order_uids` by on-chain status, returning only orders
+/// that need refund, grouped by EthFlow contract.
+///
+/// Excludes orders from unknown contracts, failed status queries, already
+/// refunded orders, and owners that can't receive ETH.
+async fn identify_uids_refunding_status<C: ChainRead>(
+    chain: &C,
+    refundable_order_uids: &[EthOrderPlacement],
+) -> HashMap<CoWSwapEthFlowAddress, Vec<OrderUid>> {
+    let known_ethflow_addresses = chain.ethflow_addresses();
+
+    let futures = refundable_order_uids
+        .iter()
+        .filter_map(|eth_order_placement| {
+            let address =
+                extract_known_ethflow_address(eth_order_placement, &known_ethflow_addresses)?;
+            Some((eth_order_placement, address))
+        })
+        .map(|(eth_order_placement, ethflow_contract_address)| {
+            query_order_refund_status(chain, eth_order_placement, ethflow_contract_address)
+        });
+
+    let uid_with_latest_refundablility = futures::future::join_all(futures).await;
+    let mut to_be_refunded_uids = HashMap::<_, Vec<_>>::new();
+    let mut invalid_uids = Vec::new();
+    for (uid, status, contract_address) in uid_with_latest_refundablility.into_iter().flatten() {
+        match status {
+            RefundStatus::Refunded => (),
+            RefundStatus::Invalid => invalid_uids.push(uid),
+            RefundStatus::NotYetRefunded(_) => {
+                to_be_refunded_uids
+                    .entry(contract_address)
+                    .or_default()
+                    .push(uid);
+            }
         }
     }
+    if !invalid_uids.is_empty() {
+        // In exceptional cases, e.g. if the refunder tries to refund orders from a
+        // previous contract, the order_owners could be zero, or the owner cannot
+        // receive ETH (e.g. EOF contracts or contracts with restrictive receive logic)
+        tracing::warn!(
+            "Skipping invalid orders (not created in current contract or owner cannot receive \
+             ETH). Uids: {:?}",
+            invalid_uids
+        );
+    }
+    to_be_refunded_uids
 }
 
-impl RefundService {
-    #[allow(clippy::too_many_arguments)]
+pub struct RefundService<D, CR, CW>
+where
+    D: DbRead,
+    CR: ChainRead,
+    CW: ChainWrite,
+{
+    pub database: D,
+    pub chain: CR,
+    pub submitter: CW,
+    pub min_validity_duration: i64,
+    pub min_price_deviation_bps: i64,
+}
+
+impl<D, CR, CW> RefundService<D, CR, CW>
+where
+    D: DbRead,
+    CR: ChainRead,
+    CW: ChainWrite,
+{
     pub fn new(
-        db: PgPool,
-        web3: Web3,
-        ethflow_contracts: Vec<CoWSwapEthFlow::Instance>,
+        database: D,
+        chain: CR,
+        submitter: CW,
         min_validity_duration: i64,
         min_price_deviation_bps: i64,
-        signer: Box<dyn TxSigner<Signature> + Send + Sync + 'static>,
-        max_gas_price: u64,
-        start_priority_fee_tip: u64,
-        lookback_time: Option<Duration>,
     ) -> Self {
-        let signer_address = signer.address();
-        let gas_estimator = Box::new(NodeGasPriceEstimator::new(web3.alloy.clone()));
-        web3.wallet.register_signer(signer);
         RefundService {
-            db,
-            web3: web3.clone(),
-            ethflow_contracts,
+            database,
+            chain,
+            submitter,
             min_validity_duration,
-            min_price_deviation: min_price_deviation_bps as f64 / 10000f64,
-            max_gas_price,
-            start_priority_fee_tip,
-            submitter: Submitter {
-                web3,
-                signer_address,
-                gas_estimator,
-                gas_parameters_of_last_tx: None,
-                nonce_of_last_submission: None,
-                max_gas_price,
-                start_priority_fee_tip,
-            },
-            lookback_time,
+            min_price_deviation_bps,
         }
     }
 
+    /// Fetches refundable orders from DB, validates on-chain, and submits batch
+    /// refunds. Individual failures are logged and skipped.
     pub async fn try_to_refund_all_eligible_orders(&mut self) -> Result<()> {
         let refundable_order_uids = self.get_refundable_ethflow_orders_from_db().await?;
 
-        let to_be_refunded_uids = self
-            .identify_uids_refunding_status_via_web3_calls(refundable_order_uids)
-            .await;
+        let to_be_refunded_uids =
+            identify_uids_refunding_status(&self.chain, &refundable_order_uids).await;
 
         self.send_out_refunding_tx(to_be_refunded_uids).await?;
         Ok(())
     }
 
+    /// Fetches expired EthFlow orders that haven't been refunded, invalidated,
+    /// or filled.
     pub async fn get_refundable_ethflow_orders_from_db(&self) -> Result<Vec<EthOrderPlacement>> {
-        let block_time = timestamp_of_current_block_in_seconds(&self.web3.alloy).await? as i64;
-
-        let mut ex = self.db.acquire().await?;
-        refundable_orders(
-            &mut ex,
-            block_time,
-            self.min_validity_duration,
-            self.min_price_deviation,
-            self.lookback_time,
-        )
-        .await
-        .map_err(|err| {
-            anyhow!(
-                "Error while retrieving the refundable ethflow orders from db: {:?}",
-                err
-            )
-        })
-    }
+        let block_time = self.chain.current_block_timestamp().await? as i64;
 
-    /// Checks if an address can receive ETH by simulating a small transfer.
-    /// Returns true for EOAs and contracts with working receive/fallback
-    /// functions.
-    async fn can_receive_eth(&self, address: Address) -> bool {
-        // Try to estimate gas for sending a minimal amount of ETH
-        let tx = TransactionRequest::default()
-            .to(address)
-            .value(alloy::primitives::U256::from(1));
-
-        self.web3
-            .alloy
-            .estimate_gas(tx)
-            .await
-            .inspect_err(|err| {
-                tracing::warn!(
-                    ?address,
-                    ?err,
-                    "Address cannot receive ETH - will skip refund"
-                );
-            })
-            .is_ok()
-    }
-
-    async fn identify_uids_refunding_status_via_web3_calls(
-        &self,
-        refundable_order_uids: Vec<EthOrderPlacement>,
-    ) -> HashMap<CoWSwapEthFlowAddress, Vec<OrderUid>> {
-        let futures = refundable_order_uids
-            .into_iter()
-            .filter_map(|eth_order_placement| {
-                // Owner of the ethflow order is always the ethflow contract itself
-                let ethflow_contract_address =
-                    Address::from_slice(&eth_order_placement.uid.0[32..52]);
-                let ethflow_contract = self
-                    .ethflow_contracts
-                    .iter()
-                    .find(|contract| *contract.address() == ethflow_contract_address);
-                if ethflow_contract.is_none() {
-                    tracing::warn!(
-                        uid = const_hex::encode_prefixed(eth_order_placement.uid.0),
-                        ethflow = ?ethflow_contract_address,
-                        "refunding orders from specific contract is not enabled",
-                    );
-                }
-                ethflow_contract.map(|contract| (eth_order_placement, contract))
-            })
-            .map(|(eth_order_placement, ethflow_contract)| async move {
-                let order_hash: [u8; 32] = eth_order_placement.uid.0[0..32]
-                    .try_into()
-                    .expect("order_uid slice with incorrect length");
-                let order = ethflow_contract.orders(order_hash.into()).call().await;
-                let order_owner = match order {
-                    Ok(order) => order.owner,
-                    Err(err) => {
-                        tracing::error!(
-                            uid =? B256::from(order_hash),
-                            ?err,
-                            "Error while getting the current onchain status ot the order"
-                        );
-                        return None;
-                    }
-                };
-                let refund_status = if order_owner == INVALIDATED_OWNER {
-                    RefundStatus::Refunded
-                } else if order_owner == NO_OWNER {
-                    RefundStatus::Invalid
-                } else if !self.can_receive_eth(order_owner).await {
-                    tracing::warn!(
-                        uid = const_hex::encode_prefixed(eth_order_placement.uid.0),
-                        owner = ?order_owner,
-                        "Order owner cannot receive ETH - marking as invalid"
-                    );
-                    RefundStatus::Invalid
-                } else {
-                    RefundStatus::NotYetRefunded(order_owner)
-                };
-
-                Some((eth_order_placement.uid, refund_status, ethflow_contract))
-            });
-
-        let uid_with_latest_refundablility = futures::future::join_all(futures).await;
-        let mut to_be_refunded_uids = HashMap::<_, Vec<_>>::new();
-        let mut invalid_uids = Vec::new();
-        for (uid, refund_status, ethflow_contract) in
-            uid_with_latest_refundablility.into_iter().flatten()
-        {
-            match refund_status {
-                RefundStatus::Refunded => (),
-                RefundStatus::Invalid => invalid_uids.push(uid),
-                RefundStatus::NotYetRefunded(_) => {
-                    to_be_refunded_uids
-                        .entry(*ethflow_contract.address())
-                        .or_default()
-                        .push(uid);
-                }
-            }
-        }
-        if !invalid_uids.is_empty() {
-            // In exceptional cases, e.g. if the refunder tries to refund orders from a
-            // previous contract, the order_owners could be zero, or the owner cannot
-            // receive ETH (e.g. EOF contracts or contracts with restrictive receive logic)
-            tracing::warn!(
-                "Skipping invalid orders (not created in current contract or owner cannot receive \
-                 ETH). Uids: {:?}",
-                invalid_uids
-            );
-        }
-        to_be_refunded_uids
-    }
-
-    async fn get_ethflow_data_from_db(
-        &self,
-        uid: &OrderUid,
-    ) -> Result<CoWSwapEthFlow::EthFlowOrder::Data> {
-        let mut ex = self.db.acquire().await.context("acquire")?;
-        let order = read_db_order(&mut ex, uid)
-            .await
-            .context("read order")?
-            .context("missing order")?;
-        let ethflow_order = read_order(&mut ex, uid)
+        self.database
+            .get_refundable_orders(
+                block_time,
+                self.min_validity_duration,
+                self.min_price_deviation_bps as f64 / BASIS_POINT_DENOMINATOR,
+            )
             .await
-            .context("read ethflow order")?
-            .context("missing ethflow order")?;
-
-        Ok(CoWSwapEthFlow::EthFlowOrder::Data {
-            buyToken: Address::from(order.buy_token.0),
-            // ethflow orders have always a receiver. It's enforced by the contract.
-            receiver: Address::from(order.receiver.unwrap().0),
-            sellAmount: big_decimal_to_u256(&order.sell_amount).unwrap(),
-            buyAmount: big_decimal_to_u256(&order.buy_amount).unwrap(),
-            appData: order.app_data.0.into(),
-            feeAmount: big_decimal_to_u256(&order.fee_amount).unwrap(),
-            validTo: ethflow_order.valid_to as u32,
-            partiallyFillable: order.partially_fillable,
-            quoteId: 0i64, // quoteId is not important for refunding and will be ignored
-        })
     }
 
     async fn send_out_refunding_tx(
@@ -285,13 +208,8 @@ impl RefundService {
             tracing::debug!("Trying to refund the following uids: {:?}", uids);
 
             let futures = uids.iter().map(|uid| {
-                let (uid, self_) = (*uid, &self);
-                async move {
-                    self_
-                        .get_ethflow_data_from_db(&uid)
-                        .await
-                        .context(format!("uid {uid:?}"))
-                }
+                let (uid, database) = (*uid, &self.database);
+                async move { database.get_ethflow_order_data(&uid).await }
             });
             let encoded_ethflow_orders: Vec<_> = stream::iter(futures)
                 .buffer_unordered(10)
@@ -303,7 +221,7 @@ impl RefundService {
                 .collect()
                 .await;
             self.submitter
-                .submit(uids, encoded_ethflow_orders, contract)
+                .submit_batch(&uids, encoded_ethflow_orders, contract)
                 .await?;
         }
 
@@ -311,37 +229,804 @@ impl RefundService {
     }
 }
 
+impl RefundService<Postgres, AlloyChain, Submitter> {
+    /// Creates a `RefundService` from its (concrete) components.
+    #[allow(clippy::too_many_arguments)]
+    pub fn from_components(
+        db: sqlx::PgPool,
+        web3: ethrpc::Web3,
+        ethflow_addresses: Vec<Address>,
+        min_validity_duration: i64,
+        min_price_deviation_bps: i64,
+        signer: alloy::signers::local::PrivateKeySigner,
+        max_gas_price: u64,
+        start_priority_fee_tip: u64,
+        lookback_time: Option<std::time::Duration>,
+    ) -> Self {
+        // Database layer
+        let database = Postgres::new(db, lookback_time);
+
+        // Chain reader
+        let chain = AlloyChain::new(web3.alloy.clone(), ethflow_addresses);
+
+        // Signer/wallet configuration
+        let signer_address = signer.address();
+        web3.wallet.register_signer(signer);
+
+        // Transaction submitter
+        let gas_estimator = Box::new(
+            shared::gas_price_estimation::eth_node::NodeGasPriceEstimator::new(web3.alloy.clone()),
+        );
+        let submitter = Submitter {
+            web3,
+            signer_address,
+            gas_estimator,
+            gas_parameters_of_last_tx: None,
+            nonce_of_last_submission: None,
+            max_gas_price,
+            start_priority_fee_tip,
+        };
+
+        Self::new(
+            database,
+            chain,
+            submitter,
+            min_validity_duration,
+            min_price_deviation_bps,
+        )
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use {
         super::*,
-        alloy::primitives::address,
-        shared::gas_price_estimation::eth_node::NodeGasPriceEstimator,
+        crate::traits::{
+            MockChainRead,
+            MockChainWrite,
+            MockDbRead,
+            test::{MockChainReadExt, MockDbReadExt},
+        },
+        alloy::primitives::Address,
+        anyhow::anyhow,
+        contracts::alloy::CoWSwapEthFlow::EthFlowOrder,
+        database::{byte_array::ByteArray, ethflow_orders::EthOrderPlacement},
+        rand::random,
+        rstest::rstest,
+        std::collections::{HashMap, HashSet},
     };
 
-    /// Creates a minimal RefundService for testing purposes.
-    fn new_test_service(web3: Web3) -> RefundService {
-        RefundService {
-            db: PgPool::connect_lazy("postgresql://").unwrap(),
-            web3: web3.clone(),
-            ethflow_contracts: vec![],
-            min_validity_duration: 0,
-            min_price_deviation: 0.0,
-            max_gas_price: 0,
-            start_priority_fee_tip: 0,
-            submitter: Submitter {
-                web3: web3.clone(),
-                signer_address: Address::ZERO,
-                gas_estimator: Box::new(NodeGasPriceEstimator::new(web3.alloy.clone())),
-                gas_parameters_of_last_tx: None,
-                nonce_of_last_submission: None,
-                max_gas_price: 0,
-                start_priority_fee_tip: 0,
-            },
-            lookback_time: None,
+    /// Test addresses with semantic meaning for filtering logic.
+    pub const KNOWN_ETHFLOW: Address = Address::repeat_byte(0x11);
+    pub const KNOWN_ETHFLOW_2: Address = Address::repeat_byte(0x22);
+    pub const EOA_OWNER: Address = Address::repeat_byte(0x44);
+    pub const CONTRACT_REJECTING_ETH: Address = Address::repeat_byte(0x55);
+    pub const UNKNOWN_ETHFLOW: Address = Address::repeat_byte(0x66);
+
+    /// Asserts the expected number of orders per contract in a grouped result.
+    ///
+    /// # Panics
+    /// Panics if the number of orders for the specified contract does not match
+    /// the expected count, or if the set of UID suffixes differs.
+    #[track_caller]
+    fn assert_orders_by_contract(
+        result: &HashMap<CoWSwapEthFlowAddress, Vec<OrderUid>>,
+        contract: Address,
+        expected_uid_suffixes: &[u8],
+    ) {
+        // Retrieve the order list for the contract (empty slice if missing)
+        let orders = result.get(&contract).map(|v| v.as_slice()).unwrap_or(&[]);
+
+        // Verify the count
+        let actual_count = orders.len();
+        let expected_count = expected_uid_suffixes.len();
+        assert_eq!(
+            actual_count, expected_count,
+            "Expected {expected_count} orders for contract {contract}, got {actual_count}"
+        );
+
+        // Verify the UID suffixes (order‑independent)
+        let actual_suffixes: HashSet<u8> = orders.iter().map(|uid| uid.0[31]).collect();
+        let expected_suffixes: HashSet<u8> = expected_uid_suffixes.iter().copied().collect();
+
+        assert_eq!(
+            actual_suffixes, expected_suffixes,
+            "Order uid_suffixes mismatch for contract {contract}"
+        );
+    }
+
+    /// Builds an `EthOrderPlacement` with the given contract address embedded
+    /// in the UID.
+    ///
+    /// # UID Structure (56 bytes total)
+    ///
+    /// The CoW Protocol Order UID has the following layout:
+    /// - Bytes 0-31: Order hash (keccak256 of order data)
+    /// - Bytes 32-51: Contract address (EthFlow contract that created the
+    ///   order)
+    /// - Bytes 52-55: Valid-to timestamp (big-endian u32)
+    ///
+    /// This function creates a test UID where:
+    /// - `uid_suffix` is placed at byte 31 (end of order hash) for easy
+    ///   identification
+    /// - `contract_addr` occupies bytes 32-52 to simulate the EthFlow contract
+    ///   address
+    ///
+    /// # Arguments
+    /// - `uid_suffix`: A byte value placed at position 31 to distinguish test
+    ///   orders
+    /// - `contract_addr`: The EthFlow contract address to embed in bytes 32-52
+    fn create_test_order_placement(uid_suffix: u8, contract_addr: Address) -> EthOrderPlacement {
+        let mut uid_bytes = [0u8; 56];
+        uid_bytes[31] = uid_suffix;
+        uid_bytes[32..52].copy_from_slice(contract_addr.as_slice());
+        EthOrderPlacement {
+            uid: ByteArray(uid_bytes),
+            valid_to: 1000,
         }
     }
 
+    // Tests
+
+    /// Orders with owners that cannot receive ETH are filtered out.
+    #[rstest]
+    #[case::eoa_can_receive_eth(EOA_OWNER, true)]
+    #[case::contract_rejects_eth(CONTRACT_REJECTING_ETH, false)]
+    #[tokio::test]
+    async fn test_eth_receivability_filtering(#[case] owner: Address, #[case] can_receive: bool) {
+        let mut mock_chain = MockChainRead::new();
+
+        mock_chain
+            // Configure the known EthFlow contracts so orders from KNOWN_ETHFLOW pass the
+            // allowlist check
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            // All orders report as "not yet refunded" with the parameterized owner address
+            // This sets up the precondition for testing the ETH receivability check
+            .with_order_status(RefundStatus::NotYetRefunded(owner));
+
+        // Return parameterized ETH receivability result to test both EOA (can receive)
+        // and contract-rejecting-ETH (cannot receive) scenarios
+        mock_chain
+            .expect_can_receive_eth()
+            .withf(move |addr| *addr == owner)
+            .returning(move |_| can_receive);
+
+        let order = create_test_order_placement(1, KNOWN_ETHFLOW);
+        let result = identify_uids_refunding_status(&mock_chain, &[order]).await;
+
+        let expected_orders: &[u8] = if can_receive { &[1] } else { &[] };
+        assert_orders_by_contract(&result, KNOWN_ETHFLOW, expected_orders);
+    }
+
+    /// Orders from unknown EthFlow contracts are filtered out.
+    #[rstest]
+    #[case::known_contract_included(KNOWN_ETHFLOW)]
+    #[case::unknown_contract_filtered(UNKNOWN_ETHFLOW)]
+    #[tokio::test]
+    async fn test_ethflow_contract_filtering(#[case] contract: Address) {
+        let mut mock_chain = MockChainRead::new();
+        mock_chain
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            .with_order_status(RefundStatus::NotYetRefunded(EOA_OWNER))
+            .receiving_eth();
+
+        let order = create_test_order_placement(1, contract);
+        let result = identify_uids_refunding_status(&mock_chain, &[order]).await;
+
+        let expected_suffixes: &[u8] = if contract == KNOWN_ETHFLOW { &[1] } else { &[] };
+        assert_orders_by_contract(&result, contract, expected_suffixes);
+    }
+
+    /// Orders with non-refundable status or status query errors are excluded.
+    #[rstest]
+    #[case::already_refunded(Some(RefundStatus::Refunded))]
+    #[case::invalid_order(Some(RefundStatus::Invalid))]
+    #[case::status_query_error(None)]
+    #[tokio::test]
+    async fn test_non_refundable_status_excludes_order(#[case] status: Option<RefundStatus>) {
+        let mut mock_chain = MockChainRead::new();
+
+        // Allow the order through the allowlist check
+        mock_chain.with_ethflow_addresses(vec![KNOWN_ETHFLOW]);
+
+        // Return the parameterized status (Refunded, Invalid, or Error) to verify
+        // that orders with non-refundable statuses are excluded from the result
+        mock_chain
+            .expect_get_order_status()
+            .returning(move |_, _| status.ok_or(anyhow!("RPC error")));
+
+        let order = create_test_order_placement(1, KNOWN_ETHFLOW);
+        let result = identify_uids_refunding_status(&mock_chain, &[order]).await;
+
+        assert!(result.is_empty());
+    }
+
+    /// When all orders are already refunded on-chain, the result is empty.
+    ///
+    /// This verifies the edge case where no orders need refund, which should
+    /// result in an empty map (and thus no submission).
+    #[tokio::test]
+    async fn test_all_orders_already_refunded() {
+        let mut mock_chain = MockChainRead::new();
+        mock_chain
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            .with_order_status(RefundStatus::Refunded);
+
+        let orders: Vec<_> = (1..=5)
+            .map(|i| create_test_order_placement(i, KNOWN_ETHFLOW))
+            .collect();
+
+        let result = identify_uids_refunding_status(&mock_chain, &orders).await;
+
+        assert!(
+            result.is_empty(),
+            "All orders were refunded; result should be empty"
+        );
+    }
+
+    /// A single order is forwarded to the submitter with correct arguments.
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_calls_submitter() {
+        let order = create_test_order_placement(1, KNOWN_ETHFLOW);
+        let uid = order.uid;
+
+        let mut mock_db = MockDbRead::new();
+        mock_db.with_default_ethflow_order_data();
+
+        let mock_chain = MockChainRead::new();
+
+        let mut mock_submitter = MockChainWrite::new();
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .withf(|uids, orders, contract| {
+                uids.len() == 1 && orders.len() == 1 && *contract == KNOWN_ETHFLOW
+            })
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let mut uids_by_contract = HashMap::new();
+        uids_by_contract.insert(KNOWN_ETHFLOW, vec![uid]);
+
+        let result = service.send_out_refunding_tx(uids_by_contract).await;
+        assert!(result.is_ok());
+    }
+
+    /// Empty order map does not trigger any submission.
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_empty_map_skips_submission() {
+        // No expectations needed for DB or chain because empty input short-circuits
+        // before any DB and chain calls
+        let mock_db = MockDbRead::new();
+        let mock_chain = MockChainRead::new();
+
+        // Submitter has no expectations: test will fail if submit is called,
+        // verifying that empty input correctly skips submission
+        let mock_submitter = MockChainWrite::new();
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let result = service.send_out_refunding_tx(HashMap::new()).await;
+        assert!(result.is_ok());
+    }
+
+    /// Orders are capped at `MAX_NUMBER_OF_UIDS_PER_REFUND_TX` per contract.
+    #[rstest]
+    #[case::below_max_no_truncation(29, 29)]
+    #[case::at_max_no_truncation(
+        MAX_NUMBER_OF_UIDS_PER_REFUND_TX,
+        MAX_NUMBER_OF_UIDS_PER_REFUND_TX
+    )]
+    #[case::one_above_max_truncates(31, MAX_NUMBER_OF_UIDS_PER_REFUND_TX)]
+    #[case::above_max_truncates(35, MAX_NUMBER_OF_UIDS_PER_REFUND_TX)]
+    #[case::double_max_truncates(60, MAX_NUMBER_OF_UIDS_PER_REFUND_TX)]
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_order_count_boundary(
+        #[case] input_count: usize,
+        #[case] expected_count: usize,
+    ) {
+        let mut mock_db = MockDbRead::new();
+        mock_db.with_default_ethflow_order_data();
+
+        let mock_chain = MockChainRead::new();
+
+        let mut mock_submitter = MockChainWrite::new();
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .withf(move |uids, orders, _| {
+                uids.len() == expected_count && orders.len() == expected_count
+            })
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let mut uids_by_contract = HashMap::new();
+        let uids = (0..input_count as u8)
+            .map(|i| create_test_order_placement(i, KNOWN_ETHFLOW).uid)
+            .collect();
+        uids_by_contract.insert(KNOWN_ETHFLOW, uids);
+
+        let result = service.send_out_refunding_tx(uids_by_contract).await;
+        assert!(result.is_ok());
+    }
+
+    /// Orders from multiple contracts trigger separate submissions.
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_multiple_contracts() {
+        let mut mock_db = MockDbRead::new();
+        mock_db.with_default_ethflow_order_data();
+
+        let mock_chain = MockChainRead::new();
+
+        let mut mock_submitter = MockChainWrite::new();
+
+        // Expect exactly 2 submissions because orders are grouped by contract,
+        // and each contract gets its own refund transaction
+        mock_submitter
+            .expect_submit_batch()
+            .times(2)
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let uid1 = create_test_order_placement(1, KNOWN_ETHFLOW).uid;
+        let uid2 = create_test_order_placement(2, KNOWN_ETHFLOW_2).uid;
+        let mut uids_by_contract = HashMap::new();
+        uids_by_contract.insert(KNOWN_ETHFLOW, vec![uid1]);
+        uids_by_contract.insert(KNOWN_ETHFLOW_2, vec![uid2]);
+
+        let result = service.send_out_refunding_tx(uids_by_contract).await;
+        assert!(result.is_ok());
+    }
+
+    /// DB errors for individual orders are skipped; other orders proceed.
+    ///
+    /// # Current Behavior (documented, not necessarily ideal)
+    ///
+    /// When a DB lookup fails for an order:
+    /// - The error is logged and the order data is excluded from the submission
+    /// - However, the UID is still included in the submission
+    ///
+    /// This means `submit` receives:
+    /// - `uids`: ALL original UIDs (including those with failed lookups)
+    /// - `orders`: Only the order data for successful lookups
+    ///
+    /// This creates a mismatch between UIDs and order data. See the TODO in
+    /// `test_send_out_refunding_tx_all_db_calls_fail_still_submits` for
+    /// discussion of potential fixes.
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_db_error_skips_order() {
+        let uid1 = create_test_order_placement(1, KNOWN_ETHFLOW).uid;
+        let uid2 = create_test_order_placement(2, KNOWN_ETHFLOW).uid;
+
+        let mut mock_db = MockDbRead::new();
+
+        // First order (uid_suffix=1) fails DB lookup to test error handling
+        mock_db
+            .expect_get_ethflow_order_data()
+            .withf(|uid| uid.0[31] == 1)
+            .returning(|_| Err(anyhow!("DB error")));
+
+        // Second order (uid_suffix=2) succeeds to verify partial success behavior
+        mock_db
+            .expect_get_ethflow_order_data()
+            .withf(|uid| uid.0[31] == 2)
+            .returning(|_| Ok(EthFlowOrder::Data::default()));
+
+        let mock_chain = MockChainRead::new();
+
+        let mut mock_submitter = MockChainWrite::new();
+
+        // Current behavior: ALL UIDs are passed, but only successful order data.
+        // - uids contains both uid1 (suffix=1) and uid2 (suffix=2)
+        // - orders contains only 1 entry (from uid2's successful lookup)
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .withf(|uids, orders, _| {
+                let has_both_uids = uids.len() == 2
+                    && uids.iter().any(|uid| uid.0[31] == 1)
+                    && uids.iter().any(|uid| uid.0[31] == 2);
+                let has_one_order = orders.len() == 1;
+                has_both_uids && has_one_order
+            })
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let mut uids_by_contract = HashMap::new();
+        uids_by_contract.insert(KNOWN_ETHFLOW, vec![uid1, uid2]);
+
+        let result = service.send_out_refunding_tx(uids_by_contract).await;
+        assert!(result.is_ok());
+    }
+
+    /// If every DB lookup fails, we still call the submitter with the original
+    /// UIDs but without any order data.
+    ///
+    /// What actually happens:
+    /// - Each failed order‑data fetch is logged and ignored (it doesn't stop
+    ///   the whole batch).
+    /// - The submitter gets the same list of UIDs we started with, but the
+    ///   `orders` slice may be empty (or contain fewer entries) because some or
+    ///   all lookups failed.
+    ///
+    /// TODO: Is this the behavior we really want? Submitting a refund that
+    /// contains UIDs but no order details feels off. Possible fixes:
+    /// 1. Skip the submission entirely when `encoded_ethflow_orders` is empty.
+    /// 2. Return an error if *all* order‑data lookups fail.
+    /// 3. Filter the UID list so it only includes IDs with successful lookups.
+    ///
+    /// NOTE: This test complements
+    /// `test_send_out_refunding_tx_db_error_skips_order`. That test covers
+    /// partial DB failure (some lookups succeed); this one covers
+    /// total DB failure (all lookups fail). Together they verify that DB errors
+    /// are non-fatal and UIDs are always preserved regardless of lookup
+    /// success.
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_all_db_calls_fail_still_submits() {
+        let uid1 = create_test_order_placement(1, KNOWN_ETHFLOW).uid;
+        let uid2 = create_test_order_placement(2, KNOWN_ETHFLOW).uid;
+
+        let mut mock_db = MockDbRead::new();
+
+        // All DB lookups fail to test edge case where no order data is available
+        mock_db
+            .expect_get_ethflow_order_data()
+            .returning(|_| Err(anyhow!("DB connection lost")));
+
+        let mock_chain = MockChainRead::new();
+
+        let mut mock_submitter = MockChainWrite::new();
+
+        // Verify submission still happens with original UIDs but empty orders list
+        // This documents current (possibly unintended) behavior where UIDs and orders
+        // mismatch
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .withf(|uids, orders, contract| {
+                // UIDs are preserved, but orders is empty because all DB lookups failed
+                uids.len() == 2 && orders.is_empty() && *contract == KNOWN_ETHFLOW
+            })
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let mut uids_by_contract = HashMap::new();
+        uids_by_contract.insert(KNOWN_ETHFLOW, vec![uid1, uid2]);
+
+        let result = service.send_out_refunding_tx(uids_by_contract).await;
+        assert!(result.is_ok());
+    }
+
+    /// Submitter error on first contract short-circuits; remaining contracts
+    /// are not attempted.
+    ///
+    /// NOTE: HashMap iteration order is non-deterministic, so we cannot predict
+    /// which contract will be processed first. This test verifies that:
+    /// 1. The error propagates (result is Err)
+    /// 2. Only one submission is attempted (times(1))
+    ///
+    /// The test remains valid regardless of iteration order because both
+    /// contracts would fail with the same error.
+    #[tokio::test]
+    async fn test_send_out_refunding_tx_error_short_circuits() {
+        let mut mock_db = MockDbRead::new();
+        // Return order data successfully; the error will come from submission
+        mock_db.with_default_ethflow_order_data();
+
+        let mock_chain = MockChainRead::new();
+
+        let mut mock_submitter = MockChainWrite::new();
+
+        // Fail on first submission to verify error propagation stops processing
+        // Due to HashMap's non-deterministic iteration order, we cannot predict
+        // which contract will be attempted first, but we know only one will be tried
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .returning(|_, _, _| Err(anyhow!("Submission failed")));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let uid1 = create_test_order_placement(1, KNOWN_ETHFLOW).uid;
+        let uid2 = create_test_order_placement(2, KNOWN_ETHFLOW_2).uid;
+        let mut uids_by_contract = HashMap::new();
+        uids_by_contract.insert(KNOWN_ETHFLOW, vec![uid1]);
+        uids_by_contract.insert(KNOWN_ETHFLOW_2, vec![uid2]);
+
+        let result = service.send_out_refunding_tx(uids_by_contract).await;
+        assert!(result.is_err());
+    }
+
+    /// An eligible order is fetched, validated, and submitted for refund.
+    #[tokio::test]
+    async fn test_try_to_refund_happy_path() {
+        let mut mock_db = MockDbRead::new();
+        let order = vec![create_test_order_placement(1, KNOWN_ETHFLOW)];
+        mock_db.with_refundable_orders(order);
+
+        mock_db.with_default_ethflow_order_data();
+
+        let mut mock_chain = MockChainRead::new();
+        mock_chain
+            .with_block_timestamp(1000)
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            .with_order_status(RefundStatus::NotYetRefunded(EOA_OWNER))
+            .receiving_eth();
+
+        let mut mock_submitter = MockChainWrite::new();
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let result = service.try_to_refund_all_eligible_orders().await;
+        assert!(result.is_ok());
+    }
+
+    /// Empty database result does not trigger any submission.
+    #[tokio::test]
+    async fn test_try_to_refund_empty_db_result() {
+        let mut mock_db = MockDbRead::new();
+        mock_db.with_refundable_orders(vec![]);
+
+        let mut mock_chain = MockChainRead::new();
+        mock_chain
+            .with_block_timestamp(1000)
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW]);
+
+        // Submitter has no expectations: test fails if submit is called
+        let mock_submitter = MockChainWrite::new();
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let result = service.try_to_refund_all_eligible_orders().await;
+        assert!(result.is_ok());
+    }
+
+    /// When some orders are already refunded on-chain, only pending orders are
+    /// submitted.
+    #[tokio::test]
+    async fn test_try_to_refund_mixed_orders() {
+        let order_valid = create_test_order_placement(1, KNOWN_ETHFLOW);
+        let order_refunded = create_test_order_placement(2, KNOWN_ETHFLOW);
+
+        let mut mock_db = MockDbRead::new();
+
+        // Return two orders from DB: one still needs refund, one already refunded
+        // on-chain
+        mock_db.with_refundable_orders(vec![order_valid, order_refunded]);
+
+        // Return order data for the order that passes on-chain validation
+        mock_db.with_default_ethflow_order_data();
+
+        let mut mock_chain = MockChainRead::new();
+
+        // Block timestamp and known contracts for DB query
+        mock_chain
+            .with_block_timestamp(1000)
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            .receiving_eth();
+
+        // Order 1 (uid_suffix=1) is eligible for refund
+        mock_chain
+            .expect_get_order_status()
+            .withf(|_, order_hash| order_hash.0[31] == 1)
+            .returning(|_, _| Ok(RefundStatus::NotYetRefunded(EOA_OWNER)));
+
+        // Order 2 (uid_suffix=2) was already refunded on-chain, should be filtered out
+        mock_chain
+            .expect_get_order_status()
+            .withf(|_, order_hash| order_hash.0[31] == 2)
+            .returning(|_, _| Ok(RefundStatus::Refunded));
+
+        let mut mock_submitter = MockChainWrite::new();
+
+        // Only 1 order should be submitted (order 2 is filtered out as already
+        // refunded)
+        mock_submitter
+            .expect_submit_batch()
+            .times(1)
+            .withf(|uids, _, _| uids.len() == 1)
+            .returning(|_, _, _| Ok(()));
+
+        let mut service = RefundService::new(mock_db, mock_chain, mock_submitter, 3600, 100);
+
+        let result = service.try_to_refund_all_eligible_orders().await;
+        assert!(result.is_ok());
+    }
+
+    /// Orders are grouped by their originating EthFlow contract.
+    #[tokio::test]
+    async fn test_identify_groups_orders_by_contract() {
+        let order1 = create_test_order_placement(1, KNOWN_ETHFLOW);
+        let order2 = create_test_order_placement(2, KNOWN_ETHFLOW);
+        let order3 = create_test_order_placement(3, KNOWN_ETHFLOW_2);
+
+        let mut mock_chain = MockChainRead::new();
+        mock_chain
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW, KNOWN_ETHFLOW_2])
+            .with_order_status(RefundStatus::NotYetRefunded(EOA_OWNER))
+            .receiving_eth();
+
+        let result = identify_uids_refunding_status(&mock_chain, &[order1, order2, order3]).await;
+
+        assert_eq!(result.len(), 2);
+        assert_orders_by_contract(&result, KNOWN_ETHFLOW, &[1, 2]);
+        assert_orders_by_contract(&result, KNOWN_ETHFLOW_2, &[3]);
+    }
+
+    /// Empty input returns empty result.
+    #[tokio::test]
+    async fn test_identify_empty_input() {
+        let mut mock_chain = MockChainRead::new();
+        mock_chain.with_ethflow_addresses(vec![KNOWN_ETHFLOW]);
+
+        let result = identify_uids_refunding_status(&mock_chain, &[]).await;
+
+        assert!(result.is_empty());
+    }
+
+    /// Verifies that the order hash is correctly extracted from UID bytes
+    /// [0..32].
+    ///
+    /// The refund service extracts the order hash from the first 32 bytes of
+    /// the UID to query on-chain status.
+    #[tokio::test]
+    async fn test_order_hash_extraction_from_uid() {
+        let expected_hash: [u8; 32] = random();
+
+        let mut mock_chain = MockChainRead::new();
+        mock_chain
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            .receiving_eth();
+
+        // Capture the order_hash passed to get_order_status and verify it matches
+        mock_chain
+            .expect_get_order_status()
+            .withf(move |_, order_hash| order_hash.0 == expected_hash)
+            .returning(|_, _| Ok(RefundStatus::NotYetRefunded(EOA_OWNER)));
+
+        // Build a UID with the expected hash in bytes [0..32]
+        let mut uid_bytes = [0u8; 56];
+        uid_bytes[0..32].copy_from_slice(&expected_hash);
+        uid_bytes[32..52].copy_from_slice(KNOWN_ETHFLOW.as_slice());
+
+        let order = EthOrderPlacement {
+            uid: ByteArray(uid_bytes),
+            valid_to: 1000,
+        };
+
+        let result = identify_uids_refunding_status(&mock_chain, &[order]).await;
+
+        // Verify the result contains our order with the expected hash
+        let uids = result
+            .get(&KNOWN_ETHFLOW)
+            .expect("should have orders for contract");
+        assert_eq!(uids.len(), 1);
+        assert_eq!(&uids[0].0[0..32], &expected_hash);
+    }
+
+    /// Verifies that the contract address is correctly extracted from UID bytes
+    /// [32..52].
+    ///
+    /// The refund service extracts the EthFlow contract address from bytes
+    /// 32-52 to determine which contract the order belongs to. This test
+    /// ensures the extraction produces the correct Address value.
+    #[rstest]
+    #[case::known_ethflow(KNOWN_ETHFLOW)]
+    #[case::known_ethflow_2(KNOWN_ETHFLOW_2)]
+    #[case::all_zeros(Address::ZERO)]
+    #[case::all_ones(Address::repeat_byte(0xFF))]
+    #[tokio::test]
+    async fn test_contract_address_extraction_from_uid(#[case] contract: Address) {
+        let mut mock_chain = MockChainRead::new();
+
+        // Only allow the specific contract being tested
+        mock_chain
+            .with_ethflow_addresses(vec![contract])
+            .with_order_status(RefundStatus::NotYetRefunded(EOA_OWNER))
+            .receiving_eth();
+
+        // Build a UID with the contract address in bytes [32..52]
+        let mut uid_bytes = [0u8; 56];
+        uid_bytes[31] = 1; // uid_suffix for identification
+        uid_bytes[32..52].copy_from_slice(contract.as_slice());
+
+        let order = EthOrderPlacement {
+            uid: ByteArray(uid_bytes),
+            valid_to: 1000,
+        };
+
+        let result = identify_uids_refunding_status(&mock_chain, &[order]).await;
+
+        // The order should be grouped under the correct contract
+        assert_orders_by_contract(&result, contract, &[1]);
+    }
+
+    /// Multiple orders with different owners are filtered based on each owner's
+    /// ability to receive ETH.
+    ///
+    /// This test verifies that the ETH receivability check is performed
+    /// per-owner, not globally. Orders from owners that can receive ETH are
+    /// included; orders from owners that cannot receive ETH are excluded.
+    #[tokio::test]
+    async fn test_mixed_eth_receivability_multiple_owners() {
+        // Define owners with different ETH receivability
+        const OWNER_CAN_RECEIVE_1: Address = Address::repeat_byte(0xA1);
+        const OWNER_CAN_RECEIVE_2: Address = Address::repeat_byte(0xA2);
+        const OWNER_CANNOT_RECEIVE_1: Address = Address::repeat_byte(0xB1);
+        const OWNER_CANNOT_RECEIVE_2: Address = Address::repeat_byte(0xB2);
+
+        let mut mock_chain = MockChainRead::new();
+        mock_chain.with_ethflow_addresses(vec![KNOWN_ETHFLOW]);
+
+        // Each order has a different owner
+        mock_chain
+            .expect_get_order_status()
+            .returning(|_, order_hash| {
+                let owner = match order_hash.0[31] {
+                    1 => OWNER_CAN_RECEIVE_1,
+                    2 => OWNER_CANNOT_RECEIVE_1,
+                    3 => OWNER_CAN_RECEIVE_2,
+                    4 => OWNER_CANNOT_RECEIVE_2,
+                    _ => unreachable!(),
+                };
+                Ok(RefundStatus::NotYetRefunded(owner))
+            });
+
+        // ETH receivability depends on owner address
+        mock_chain
+            .expect_can_receive_eth()
+            .returning(|owner| [OWNER_CAN_RECEIVE_1, OWNER_CAN_RECEIVE_2].contains(&owner));
+
+        let orders: Vec<_> = (1..=4)
+            .map(|i| create_test_order_placement(i, KNOWN_ETHFLOW))
+            .collect();
+
+        let result = identify_uids_refunding_status(&mock_chain, &orders).await;
+
+        // Only orders 1 and 3 (owners that can receive ETH) should be included
+        assert_orders_by_contract(&result, KNOWN_ETHFLOW, &[1, 3]);
+    }
+
+    /// When multiple status queries fail, all failed orders are excluded.
+    #[tokio::test]
+    async fn test_multiple_status_query_failures() {
+        // Orders 1 and 2 fail with RPC errors to test partial failure handling
+        // Order 3 succeeds to verify successful orders are still processed
+        let order1 = create_test_order_placement(1, KNOWN_ETHFLOW);
+        let order2 = create_test_order_placement(2, KNOWN_ETHFLOW);
+        let order3 = create_test_order_placement(3, KNOWN_ETHFLOW);
+
+        let mut mock_chain = MockChainRead::new();
+
+        // All orders pass the allowlist check
+        mock_chain
+            .with_ethflow_addresses(vec![KNOWN_ETHFLOW])
+            .receiving_eth() // Owner can receive ETH (only relevant for order 3 which passes status check)
+
+            .expect_get_order_status()
+            .returning(|_, order_hash| {
+                match order_hash.0[31] {
+                    1 | 2 => Err(anyhow!("RPC timeout")),
+                    3 => Ok(RefundStatus::NotYetRefunded(EOA_OWNER)),
+                    _ => unreachable!()
+                }
+            });
+
+        let result = identify_uids_refunding_status(&mock_chain, &[order1, order2, order3]).await;
+
+        // Only order 3 should be included (orders 1 and 2 failed status check)
+        assert_orders_by_contract(&result, KNOWN_ETHFLOW, &[3]);
+    }
+
     /// Verifies that `can_receive_eth()` correctly identifies addresses that
     /// cannot receive ETH transfers. Some smart contracts reject ETH transfers
     /// (e.g., EOF contracts or contracts without receive/fallback functions),
@@ -352,24 +1037,34 @@ mod tests {
     #[tokio::test]
     #[ignore] // Run with: cargo test --package refunder --lib test_problematic_sepolia_address -- --ignored
     async fn test_problematic_sepolia_address() {
-        let web3 = Web3::new_from_url("https://ethereum-sepolia-rpc.publicnode.com");
-        let service = new_test_service(web3);
+        use crate::infra::AlloyChain;
+
+        let (provider, _wallet) = ethrpc::alloy::provider(
+            "https://ethereum-sepolia-rpc.publicnode.com",
+            ethrpc::Config::default(),
+            None,
+        );
+        let chain = AlloyChain::new(provider, vec![]);
 
         // EOF contract that cannot receive ETH (0xef01... bytecode prefix)
-        let problematic = address!("0x66C9152339ce05EE0C8A8eff9EeF8230AbFe8350");
+        let problematic: Address = "0x66C9152339ce05EE0C8A8eff9EeF8230AbFe8350"
+            .parse()
+            .unwrap();
 
         // Normal EOA for comparison
-        let working = address!("0x5b485e4431853F82d89dba68220A422CC17cE024");
+        let working: Address = "0x5b485e4431853F82d89dba68220A422CC17cE024"
+            .parse()
+            .unwrap();
 
         // Test that can_receive_eth correctly identifies the problematic address
         assert!(
-            !service.can_receive_eth(problematic).await,
+            !chain.can_receive_eth(problematic).await,
             "EOF contract should be identified as unable to receive ETH"
         );
 
         // Test that can_receive_eth correctly identifies a working address
         assert!(
-            service.can_receive_eth(working).await,
+            chain.can_receive_eth(working).await,
             "Normal EOA should be identified as able to receive ETH"
         );
     }
diff --git a/crates/refunder/src/submitter.rs b/crates/refunder/src/submitter.rs
index 73d8a074af..6d6075d304 100644
--- a/crates/refunder/src/submitter.rs
+++ b/crates/refunder/src/submitter.rs
@@ -1,14 +1,12 @@
-// This submitter has the following logic:
-// It tries to submit a tx - as EIP1559 - with a small tx tip,
-// but a quite high max_fee_per_gas such that it's likely being mined quickly
-//
-// Then it waits for 5 blocks. If the tx is not mined, it will return an error
-// and it needs to be called again. If the last submission was not successful,
-// this submitter stores the last gas_price in order to submit the new tx with
-// a higher gas price, in order to avoid: ErrReplaceUnderpriced erros
-// In the re-newed attempt for submission the same nonce is used as before.
+//! Refund transaction submitter.
+//!
+//! Submits EIP-1559 transactions with a small tip but high `max_fee_per_gas`
+//! to get mined quickly. Waits 5 blocks for confirmation; on timeout, the next
+//! call bumps gas price (using the same nonce) to avoid
+//! `ErrReplaceUnderpriced`.
 
 use {
+    crate::traits::ChainWrite,
     alloy::{eips::eip1559::Eip1559Estimation, primitives::Address, providers::Provider},
     anyhow::{Context, Result},
     contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
@@ -30,6 +28,8 @@ const GAS_PRICE_BUFFER_PCT: u64 = 30;
 // max_fee_per_gas needs to be increased by at least 10 percent.
 const GAS_PRICE_BUMP_PERMIL: u64 = 125;
 
+const TIMEOUT_5_BLOCKS: Duration = Duration::from_secs(60);
+
 pub struct Submitter {
     pub web3: Web3,
     pub signer_address: Address,
@@ -40,47 +40,31 @@ pub struct Submitter {
     pub start_priority_fee_tip: u64,
 }
 
-impl Submitter {
-    async fn get_submission_nonce(&self) -> Result<u64> {
-        // this command returns the tx count ever mined at the latest block
-        // Mempool tx are not considered.
-        self.web3
-            .alloy
-            .get_transaction_count(self.signer_address)
-            .await
-            .with_context(|| {
-                format!(
-                    "could not get latest nonce for address {:?}",
-                    self.signer_address
-                )
-            })
-    }
-
-    pub async fn submit(
+impl ChainWrite for Submitter {
+    async fn submit_batch(
         &mut self,
-        uids: Vec<OrderUid>,
+        uids: &[OrderUid],
         encoded_ethflow_orders: Vec<EthFlowOrder::Data>,
         ethflow_contract: Address,
     ) -> Result<()> {
-        const TIMEOUT_5_BLOCKS: Duration = Duration::from_secs(60);
-
-        let gas_price_estimation = self.gas_estimator.estimate().await?;
-        let nonce = self.get_submission_nonce().await?;
-        let gas_price = calculate_submission_gas_price(
-            self.gas_parameters_of_last_tx,
-            gas_price_estimation,
-            nonce,
-            self.nonce_of_last_submission,
-            self.max_gas_price,
-            self.start_priority_fee_tip,
-        )?;
-
-        self.gas_parameters_of_last_tx = Some(gas_price);
-        self.nonce_of_last_submission = Some(nonce);
-
-        let ethflow_contract =
-            CoWSwapEthFlow::Instance::new(ethflow_contract, self.web3.alloy.clone());
-        let tx_result = ethflow_contract
+        {
+            let gas_price_estimation = self.gas_estimator.estimate().await?;
+            let nonce = self.get_submission_nonce().await?;
+            let gas_price = calculate_submission_gas_price(
+                self.gas_parameters_of_last_tx,
+                gas_price_estimation,
+                nonce,
+                self.nonce_of_last_submission,
+                self.max_gas_price,
+                self.start_priority_fee_tip,
+            )?;
+
+            self.gas_parameters_of_last_tx = Some(gas_price);
+            self.nonce_of_last_submission = Some(nonce);
+
+            let ethflow_contract =
+                CoWSwapEthFlow::Instance::new(ethflow_contract, self.web3.alloy.clone());
+            let tx_result = ethflow_contract
             .invalidateOrdersIgnoringNotAllowed(encoded_ethflow_orders)
             // Gas conversions are lossy but technically the should not have decimal points even though they're floats
             .max_priority_fee_per_gas(gas_price.max_priority_fee_per_gas)
@@ -90,17 +74,35 @@ impl Submitter {
             .send()
             .await?.with_timeout(Some(TIMEOUT_5_BLOCKS)).get_receipt().await;
 
-        match tx_result {
-            Ok(receipt) => {
-                tracing::debug!(
-                    "Tx to refund the orderuids {:?} yielded following result {:?}",
-                    uids,
-                    receipt
-                );
+            match tx_result {
+                Ok(receipt) => {
+                    tracing::debug!(
+                        "Tx to refund the orderuids {:?} yielded following result {:?}",
+                        uids,
+                        receipt
+                    );
+                }
+                Err(err) => tracing::debug!("transaction failed with: {err}"),
             }
-            Err(err) => tracing::debug!("transaction failed with: {err}"),
+            Ok(())
         }
-        Ok(())
+    }
+}
+
+impl Submitter {
+    async fn get_submission_nonce(&self) -> Result<u64> {
+        // this command returns the tx count ever mined at the latest block
+        // Mempool tx are not considered.
+        self.web3
+            .alloy
+            .get_transaction_count(self.signer_address)
+            .await
+            .with_context(|| {
+                format!(
+                    "could not get latest nonce for address {:?}",
+                    self.signer_address
+                )
+            })
     }
 }
 
diff --git a/crates/refunder/src/traits.rs b/crates/refunder/src/traits.rs
new file mode 100644
index 0000000000..197e9837dc
--- /dev/null
+++ b/crates/refunder/src/traits.rs
@@ -0,0 +1,142 @@
+//! Trait definitions for database and blockchain access.
+
+#![allow(async_fn_in_trait)]
+
+use {
+    alloy::primitives::{Address, B256},
+    anyhow::Result,
+    contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
+    database::{OrderUid, ethflow_orders::EthOrderPlacement},
+};
+
+const NO_OWNER: Address = Address::ZERO;
+const INVALIDATED_OWNER: Address = Address::repeat_byte(0xff);
+
+/// Status of an EthFlow order refund eligibility.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RefundStatus {
+    /// Order has already been refunded or cancelled.
+    Refunded,
+    /// Order is still active and eligible for refund, with the given owner
+    /// address.
+    NotYetRefunded(Address),
+    /// Order is invalid (never created, already freed, or owner cannot receive
+    /// ETH).
+    Invalid,
+}
+
+impl From<CoWSwapEthFlow::CoWSwapEthFlow::ordersReturn> for RefundStatus {
+    fn from(value: CoWSwapEthFlow::CoWSwapEthFlow::ordersReturn) -> Self {
+        match value.owner {
+            NO_OWNER => Self::Invalid,
+            INVALIDATED_OWNER => Self::Refunded,
+            owner => Self::NotYetRefunded(owner),
+        }
+    }
+}
+
+/// Database read operations.
+#[cfg_attr(test, mockall::automock)]
+pub trait DbRead: Send + Sync {
+    /// Fetches orders eligible for refund (expired, not invalidated, not
+    /// filled, meets price deviation threshold).
+    async fn get_refundable_orders(
+        &self,
+        block_time: i64,
+        min_validity_duration: i64,
+        min_price_deviation: f64,
+    ) -> Result<Vec<EthOrderPlacement>>;
+
+    /// Fetches the EthFlow order data for `uid`.
+    async fn get_ethflow_order_data(&self, uid: &OrderUid) -> Result<EthFlowOrder::Data>;
+}
+
+/// Blockchain read operations.
+#[cfg_attr(test, mockall::automock)]
+pub trait ChainRead: Send + Sync {
+    /// Returns the current block's timestamp.
+    async fn current_block_timestamp(&self) -> Result<u32>;
+
+    /// Returns `true` if `address` can receive ETH
+    async fn can_receive_eth(&self, address: Address) -> bool;
+
+    /// Returns the configured EthFlow contract addresses.
+    fn ethflow_addresses(&self) -> Vec<Address>;
+
+    /// Queries the on-chain refund status of an order.
+    async fn get_order_status(
+        &self,
+        ethflow_address: Address,
+        order_hash: B256,
+    ) -> Result<RefundStatus>;
+}
+
+/// Blockchain write operations.
+#[cfg_attr(test, mockall::automock)]
+pub trait ChainWrite: Send + Sync {
+    /// Submits a batch refund transaction.
+    async fn submit_batch(
+        &mut self,
+        uids: &[OrderUid],
+        encoded_ethflow_orders: Vec<EthFlowOrder::Data>,
+        ethflow_contract: Address,
+    ) -> Result<()>;
+}
+
+#[cfg(test)]
+pub mod test {
+    use super::*;
+
+    /// Extension trait for `MockChainRead` to reduce mock setup boilerplate.
+    pub trait MockChainReadExt {
+        fn with_block_timestamp(&mut self, timestamp: u32) -> &mut Self;
+        fn with_ethflow_addresses(&mut self, addresses: Vec<Address>) -> &mut Self;
+        fn with_order_status(&mut self, status: RefundStatus) -> &mut Self;
+        fn receiving_eth(&mut self) -> &mut Self;
+    }
+
+    impl MockChainReadExt for MockChainRead {
+        fn with_block_timestamp(&mut self, timestamp: u32) -> &mut Self {
+            self.expect_current_block_timestamp()
+                .returning(move || Ok(timestamp));
+            self
+        }
+
+        fn with_ethflow_addresses(&mut self, addresses: Vec<Address>) -> &mut Self {
+            self.expect_ethflow_addresses()
+                .returning(move || addresses.clone());
+            self
+        }
+
+        fn with_order_status(&mut self, status: RefundStatus) -> &mut Self {
+            self.expect_get_order_status()
+                .returning(move |_, _| Ok(status));
+            self
+        }
+
+        fn receiving_eth(&mut self) -> &mut Self {
+            self.expect_can_receive_eth().returning(|_| true);
+            self
+        }
+    }
+
+    /// Extension trait for `MockDbRead` to reduce mock setup boilerplate.
+    pub trait MockDbReadExt {
+        fn with_default_ethflow_order_data(&mut self) -> &mut Self;
+        fn with_refundable_orders(&mut self, orders: Vec<EthOrderPlacement>) -> &mut Self;
+    }
+
+    impl MockDbReadExt for MockDbRead {
+        fn with_default_ethflow_order_data(&mut self) -> &mut Self {
+            self.expect_get_ethflow_order_data()
+                .returning(|_| Ok(EthFlowOrder::Data::default()));
+            self
+        }
+
+        fn with_refundable_orders(&mut self, orders: Vec<EthOrderPlacement>) -> &mut Self {
+            self.expect_get_refundable_orders()
+                .returning(move |_, _, _| Ok(orders.clone()));
+            self
+        }
+    }
+}

From 838fafee62ea30c48de6d8c5e27156c611f66289 Mon Sep 17 00:00:00 2001
From: Anuj Bansal <anuj@cow.fi>
Date: Tue, 3 Feb 2026 20:35:40 +0530
Subject: [PATCH 029/219] Fix tini zombie reaping with shared process namespace
 (#4114)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Adds the `-s` (subreaper) flag to tini in the Dockerfile entrypoint to
fix zombie process reaping when `shareProcessNamespace: true` is set in
Kubernetes deployments.

## Problem

Our Kubernetes deployments use `shareProcessNamespace: true` to allow
sidecar containers (like the memory monitor) to access `/proc` of the
main process. However, this causes the following warning:

```
[WARN  tini (82)] Tini is not running as PID 1 and isn't registered as a child subreaper.
Zombie processes will not be re-parented to Tini, so zombie reaping won't work.
To fix the problem, use the -s option or set the environment variable TINI_SUBREAPER to register Tini as a child subreaper, or run Tini as PID 1.
```

When `shareProcessNamespace` is enabled, Kubernetes' pause container
becomes PID 1 instead of tini:

```
PID 1: pause (Kubernetes infrastructure)
├── tini -- autopilot
│   └── autopilot
└── /bin/sh -c (memory-monitor sidecar)
```

Without PID 1 status, tini cannot reap zombie (orphaned) child processes
by default.

## Solution

The `-s` flag tells tini to register as a **child subreaper** via the
`PR_SET_CHILD_SUBREAPER` prctl. This Linux kernel feature allows a
non-PID-1 process to adopt and reap orphaned descendant processes,
restoring proper zombie cleanup.
---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 96fc535b91..40a74e5626 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -61,4 +61,4 @@ COPY --from=cargo-build /orderbook /usr/local/bin/orderbook
 COPY --from=cargo-build /refunder /usr/local/bin/refunder
 COPY --from=cargo-build /solvers /usr/local/bin/solvers
 
-ENTRYPOINT ["/usr/bin/tini", "--"]
+ENTRYPOINT ["/usr/bin/tini", "-s", "--"]

From e239bd38a12fc013d3bc8fd12f5067e9841c30a6 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 3 Feb 2026 17:59:59 +0100
Subject: [PATCH 030/219] [TRIVIAL] Fix vulnerability by bumping bytes crate
 version (#4121)

# Description
The `cargo audit` action complained about the `bytes` crate being
vulnerable. The recommended fix is to upgrade `bytes` to version
`1.11.1` (patch version bump).

## How to test
`cargo audit` action
---
 Cargo.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ffdab7f40b..8dd5ec4ef7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1929,9 +1929,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 dependencies = [
  "serde",
 ]
@@ -2538,7 +2538,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ab67060fc6b8ef687992d439ca0fa36e7ed17e9a0b16b25b601e8757df720de"
 dependencies = [
  "data-encoding",
- "syn 2.0.114",
+ "syn 1.0.109",
 ]
 
 [[package]]

From be8ec55a3ff9ae54fb477bc85853042775b68dd2 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 3 Feb 2026 18:00:15 +0100
Subject: [PATCH 031/219] [TRIVIAL] Fix verbose log (#4120)

# Description
There was a slight oversight in
https://github.com/cowprotocol/services/pull/4084. Instead of printing
only the solver name we now print all the internals which is quite a
lot.

# Changes
* only log the solver name again
* stop logging the weth address as well
---
 crates/driver/src/domain/competition/solution/mod.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index 46404cc955..01bdac1626 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -62,7 +62,9 @@ pub struct Solution {
     interactions: Vec<Interaction>,
     #[debug(ignore)]
     post_interactions: Vec<eth::Interaction>,
+    #[debug("{}", solver.name())]
     solver: Solver,
+    #[debug(ignore)]
     weth: eth::WethAddress,
     gas: Option<eth::Gas>,
     flashloans: HashMap<order::Uid, Flashloan>,

From 993e2d426f6ec1347757410b8cdb3453af2d63d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 3 Feb 2026 17:56:56 +0000
Subject: [PATCH 032/219] [TRIVIAL] Remove unused error (#4124)

# Description
Removes an unused error, this could actually have made it in #4106 but
VSCode looked like an Xmas tree, I wasn't expecting this to be this
simple.

# Changes

- [ ] Removes unused error
- [ ] Removes accompanying From
---
 crates/driver/src/infra/blockchain/contracts.rs | 7 -------
 crates/driver/src/infra/blockchain/mod.rs       | 8 --------
 2 files changed, 15 deletions(-)

diff --git a/crates/driver/src/infra/blockchain/contracts.rs b/crates/driver/src/infra/blockchain/contracts.rs
index 7ca0287e3f..3ef81c4b03 100644
--- a/crates/driver/src/infra/blockchain/contracts.rs
+++ b/crates/driver/src/infra/blockchain/contracts.rs
@@ -10,7 +10,6 @@ use {
     },
     ethrpc::Web3,
     std::collections::HashMap,
-    thiserror::Error,
 };
 
 #[derive(Debug, Clone)]
@@ -164,9 +163,3 @@ impl Contracts {
         &self.cow_amm_helper_by_factory
     }
 }
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("method error: {0:?}")]
-    Rpc(#[from] alloy::contract::Error),
-}
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 1e1bb52890..32abce8509 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -347,14 +347,6 @@ impl Error {
     }
 }
 
-impl From<contracts::Error> for Error {
-    fn from(err: contracts::Error) -> Self {
-        match err {
-            contracts::Error::Rpc(err) => Self::ContractRpc(err),
-        }
-    }
-}
-
 impl From<SimulationError> for Error {
     fn from(err: SimulationError) -> Self {
         match err {

From fe6e19a124aa2036e937c6e7bca7206ce17f59e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 3 Feb 2026 17:57:08 +0000
Subject: [PATCH 033/219] [TRIVIAL] Rename Web3's DynProvider alloy -> provider
 (#4123)

# Description
Renames alloy to provider. Done in a separate PR from the removal due to
the number of changes

# Changes

- [ ] `alloy` -> `provider`
---
 .../ethflow_events/event_retriever.rs         |  2 +-
 .../onchain_order_events/ethflow_events.rs    |  6 +-
 .../onchain_order_events/event_retriever.rs   |  2 +-
 .../src/database/onchain_order_events/mod.rs  | 10 ++-
 .../src/infra/blockchain/contracts.rs         | 14 ++--
 crates/autopilot/src/infra/blockchain/mod.rs  | 10 +--
 crates/autopilot/src/run.rs                   | 18 ++--
 crates/cow-amm/src/factory.rs                 |  2 +-
 crates/cow-amm/src/maintainers.rs             |  2 +-
 crates/cow-amm/src/registry.rs                |  4 +-
 .../src/boundary/liquidity/balancer/v2/mod.rs | 15 ++--
 crates/driver/src/boundary/liquidity/mod.rs   |  2 +-
 .../src/boundary/liquidity/uniswap/v2.rs      |  2 +-
 .../driver/src/boundary/liquidity/zeroex.rs   |  2 +-
 .../src/domain/competition/pre_processing.rs  |  2 +-
 .../driver/src/infra/blockchain/contracts.rs  | 12 +--
 crates/driver/src/infra/blockchain/gas.rs     |  4 +-
 crates/driver/src/infra/blockchain/mod.rs     | 14 ++--
 crates/driver/src/infra/blockchain/token.rs   |  2 +-
 crates/driver/src/infra/mempool/mod.rs        |  6 +-
 crates/driver/src/tests/cases/settle.rs       |  2 +-
 crates/driver/src/tests/setup/blockchain.rs   | 82 ++++++++++---------
 crates/driver/src/tests/setup/mod.rs          |  5 +-
 crates/driver/src/tests/setup/solver.rs       |  2 +-
 crates/e2e/src/setup/deploy.rs                | 70 ++++++++--------
 .../e2e/src/setup/onchain_components/mod.rs   | 25 +++---
 crates/e2e/src/setup/services.rs              |  2 +-
 crates/e2e/tests/e2e/app_data_signer.rs       |  2 +-
 crates/e2e/tests/e2e/banned_users.rs          |  8 +-
 crates/e2e/tests/e2e/cow_amm.rs               | 44 +++++-----
 crates/e2e/tests/e2e/eth_integration.rs       |  6 +-
 crates/e2e/tests/e2e/eth_safe.rs              |  4 +-
 crates/e2e/tests/e2e/ethflow.rs               | 12 +--
 crates/e2e/tests/e2e/hooks.rs                 | 18 ++--
 crates/e2e/tests/e2e/limit_orders.rs          | 12 +--
 crates/e2e/tests/e2e/liquidity.rs             | 14 ++--
 .../e2e/liquidity_source_notification.rs      | 12 +--
 .../e2e/tests/e2e/place_order_with_quote.rs   |  4 +-
 crates/e2e/tests/e2e/quote_verification.rs    | 12 +--
 crates/e2e/tests/e2e/refunder.rs              |  8 +-
 crates/e2e/tests/e2e/replace_order.rs         |  4 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |  4 +-
 crates/e2e/tests/e2e/submission.rs            | 24 +++---
 crates/e2e/tests/e2e/wrapper.rs               |  8 +-
 crates/ethrpc/src/alloy/instrumentation.rs    |  6 +-
 crates/ethrpc/src/block_stream.rs             |  8 +-
 crates/ethrpc/src/lib.rs                      | 12 ++-
 crates/ethrpc/src/mock.rs                     |  4 +-
 crates/orderbook/src/run.rs                   | 30 +++----
 crates/refunder/src/lib.rs                    |  2 +-
 crates/refunder/src/refund_service.rs         |  6 +-
 crates/refunder/src/submitter.rs              |  4 +-
 .../shared/src/account_balances/simulation.rs | 10 +--
 .../src/bad_token/token_owner_finder/mod.rs   |  2 +-
 crates/shared/src/bad_token/trace_call.rs     | 14 ++--
 crates/shared/src/code_fetching.rs            |  2 +-
 crates/shared/src/event_handling.rs           | 46 ++++++-----
 crates/shared/src/gas_price_estimation/mod.rs |  8 +-
 crates/shared/src/order_validation.rs         | 29 +++----
 .../balance_overrides/detector.rs             |  4 +-
 .../price_estimation/trade_verifier/mod.rs    |  4 +-
 .../src/signature_validator/simulation.rs     |  2 +-
 .../sources/balancer_v2/pool_fetching/mod.rs  |  2 +-
 .../src/sources/balancer_v2/pools/common.rs   |  4 +-
 .../src/sources/balancer_v2/pools/weighted.rs |  4 +-
 crates/shared/src/sources/swapr.rs            |  5 +-
 crates/shared/src/sources/uniswap_v2/mod.rs   | 14 ++--
 .../src/sources/uniswap_v2/pool_fetching.rs   |  6 +-
 .../src/sources/uniswap_v3/pool_fetching.rs   |  2 +-
 crates/shared/src/token_info.rs               |  2 +-
 crates/shared/src/trace_many.rs               |  2 +-
 crates/solver/src/interactions/allowances.rs  |  4 +-
 crates/solver/src/interactions/weth.rs        | 14 ++--
 crates/solver/src/liquidity/balancer_v2.rs    |  2 +-
 crates/solver/src/liquidity/zeroex.rs         |  4 +-
 .../src/settlement/settlement_encoder.rs      | 10 +--
 crates/solvers/src/domain/solver.rs           |  2 +-
 77 files changed, 413 insertions(+), 372 deletions(-)

diff --git a/crates/autopilot/src/database/ethflow_events/event_retriever.rs b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
index aa7ae2e83a..b1ed267ad2 100644
--- a/crates/autopilot/src/database/ethflow_events/event_retriever.rs
+++ b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
@@ -30,7 +30,7 @@ impl AlloyEventRetrieving for EthFlowRefundRetriever {
     type Event = CoWSwapEthFlow::CoWSwapEthFlowEvents;
 
     fn provider(&self) -> &alloy::providers::DynProvider {
-        &self.web3.alloy
+        &self.web3.provider
     }
 
     fn filter(&self) -> alloy::rpc::types::Filter {
diff --git a/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs b/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs
index 9dd67203b7..ab68bb1d4f 100644
--- a/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs
+++ b/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs
@@ -262,7 +262,7 @@ async fn find_indexing_start_block(
 
     if last_indexed_block > 0 {
         return block_number_to_block_number_hash(
-            &web3.alloy,
+            &web3.provider,
             BlockNumberOrTag::Number(last_indexed_block),
         )
         .await
@@ -271,7 +271,7 @@ async fn find_indexing_start_block(
     }
     if let Some(start_block) = fallback_start_block {
         return block_number_to_block_number_hash(
-            &web3.alloy,
+            &web3.provider,
             BlockNumberOrTag::Number(start_block),
         )
         .await
@@ -279,7 +279,7 @@ async fn find_indexing_start_block(
         .context("failed to fetch fallback indexing start block");
     }
     if let Some(chain_id) = settlement_fallback_chain_id {
-        return settlement_deployment_block_number_hash(&web3.alloy, chain_id)
+        return settlement_deployment_block_number_hash(&web3.provider, chain_id)
             .await
             .map(Some)
             .context("failed to fetch settlement deployment block");
diff --git a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
index bde093e170..a56e10fe68 100644
--- a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
+++ b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
@@ -43,6 +43,6 @@ impl AlloyEventRetrieving for CoWSwapOnchainOrdersContract {
     }
 
     fn provider(&self) -> &alloy::providers::DynProvider {
-        &self.web3.alloy
+        &self.web3.provider
     }
 }
diff --git a/crates/autopilot/src/database/onchain_order_events/mod.rs b/crates/autopilot/src/database/onchain_order_events/mod.rs
index bf4d352aff..dfa02e5700 100644
--- a/crates/autopilot/src/database/onchain_order_events/mod.rs
+++ b/crates/autopilot/src/database/onchain_order_events/mod.rs
@@ -393,9 +393,11 @@ async fn get_block_numbers_of_events(
     let futures = event_block_numbers
         .into_iter()
         .map(|block_number| async move {
-            let timestamp =
-                timestamp_of_block_in_seconds(&web3.alloy, BlockNumberOrTag::Number(block_number))
-                    .await?;
+            let timestamp = timestamp_of_block_in_seconds(
+                &web3.provider,
+                BlockNumberOrTag::Number(block_number),
+            )
+            .await?;
             Ok((block_number, timestamp))
         });
     let block_number_timestamp_pair: Vec<anyhow::Result<(u64, u32)>> =
@@ -1250,7 +1252,7 @@ mod test {
                 pool: PgPool::connect_lazy("postgresql://").unwrap(),
                 config: Default::default(),
             },
-            trampoline: HooksTrampoline::Instance::deployed(&web3.alloy)
+            trampoline: HooksTrampoline::Instance::deployed(&web3.provider)
                 .await
                 .unwrap(),
             web3,
diff --git a/crates/autopilot/src/infra/blockchain/contracts.rs b/crates/autopilot/src/infra/blockchain/contracts.rs
index afbebbea14..3409a444d2 100644
--- a/crates/autopilot/src/infra/blockchain/contracts.rs
+++ b/crates/autopilot/src/infra/blockchain/contracts.rs
@@ -45,7 +45,7 @@ impl Contracts {
                 .settlement
                 .or_else(|| GPv2Settlement::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         let signatures = contracts::alloy::support::Signatures::Instance::new(
@@ -53,7 +53,7 @@ impl Contracts {
                 .signatures
                 .or_else(|| contracts::alloy::support::Signatures::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         let weth = WETH9::Instance::new(
@@ -61,7 +61,7 @@ impl Contracts {
                 .weth
                 .or_else(|| WETH9::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         let balances = Balances::Instance::new(
@@ -69,7 +69,7 @@ impl Contracts {
                 .balances
                 .or_else(|| Balances::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         let trampoline = HooksTrampoline::Instance::new(
@@ -77,10 +77,10 @@ impl Contracts {
                 .trampoline
                 .or_else(|| HooksTrampoline::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
-        let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.alloy)
+        let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.provider)
             .await
             .ok();
 
@@ -99,7 +99,7 @@ impl Contracts {
                 .call()
                 .await
                 .expect("authenticator address"),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         Self {
diff --git a/crates/autopilot/src/infra/blockchain/mod.rs b/crates/autopilot/src/infra/blockchain/mod.rs
index b771441d45..90248b9ac9 100644
--- a/crates/autopilot/src/infra/blockchain/mod.rs
+++ b/crates/autopilot/src/infra/blockchain/mod.rs
@@ -32,7 +32,7 @@ impl Rpc {
         ethrpc_args: &shared::ethrpc::Arguments,
     ) -> Result<Self, Error> {
         let web3 = boundary::web3_client(url, ethrpc_args);
-        let chain = Chain::try_from(web3.alloy.get_chain_id().await?)
+        let chain = Chain::try_from(web3.provider.get_chain_id().await?)
             .map_err(|_| Error::UnsupportedChain)?;
 
         Ok(Self {
@@ -87,7 +87,7 @@ impl Ethereum {
 
         Self {
             current_block: current_block_args
-                .stream(url, unbuffered_web3.alloy.clone())
+                .stream(url, unbuffered_web3.provider.clone())
                 .await
                 .expect("couldn't initialize current block stream"),
             web3,
@@ -113,10 +113,10 @@ impl Ethereum {
 
     pub async fn transaction(&self, hash: eth::TxId) -> Result<eth::Transaction, Error> {
         let (receipt, traces): (Option<TransactionReceipt>, GethTrace) = tokio::try_join!(
-            self.web3.alloy.get_transaction_receipt(hash.0),
+            self.web3.provider.get_transaction_receipt(hash.0),
             // Use unbuffered transport for the Debug API since not all providers support
             // batched debug calls.
-            self.unbuffered_web3.alloy.debug_trace_transaction(
+            self.unbuffered_web3.provider.debug_trace_transaction(
                 hash.0,
                 GethDebugTracingOptions::new_tracer(GethDebugBuiltInTracerType::CallTracer),
             )
@@ -131,7 +131,7 @@ impl Ethereum {
                 )))?;
         let block = self
             .web3
-            .alloy
+            .provider
             .get_block_by_hash(block_hash)
             .await?
             .ok_or(Error::TransactionNotFound)?;
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 2b0cad10d8..8833155918 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -186,7 +186,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .map(|node_url| shared::ethrpc::web3(&args.shared.ethrpc, node_url, "simulation"));
 
     let chain_id = web3
-        .alloy
+        .provider
         .get_chain_id()
         .instrument(info_span!("chain_id"))
         .await
@@ -240,9 +240,9 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         addr
     });
     let vault =
-        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.alloy.clone()));
+        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.provider.clone()));
 
-    let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.alloy)
+    let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.provider)
         .instrument(info_span!("uniswapv3_deployed"))
         .await
         .inspect_err(|err| tracing::warn!(%err, "error while fetching IUniswapV3Factory instance"))
@@ -353,7 +353,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     let token_info_fetcher = Arc::new(CachedTokenInfoFetcher::new(Arc::new(TokenInfoFetcher {
         web3: web3.clone(),
     })));
-    let block_retriever = Arc::new(web3.alloy.clone());
+    let block_retriever = Arc::new(web3.provider.clone());
 
     let code_fetcher = Arc::new(CachedCodeFetcher::new(Arc::new(web3.clone())));
 
@@ -414,7 +414,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
 
     let skip_event_sync_start = if args.skip_event_sync {
         Some(
-            block_number_to_block_number_hash(&web3.alloy, BlockNumberOrTag::Latest)
+            block_number_to_block_number_hash(&web3.provider, BlockNumberOrTag::Latest)
                 .await
                 .expect("Failed to fetch latest block"),
         )
@@ -444,7 +444,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     };
     let settlement_event_indexer = EventUpdater::new(
         boundary::events::settlement::GPv2SettlementContract::new(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *eth.contracts().settlement().address(),
         ),
         boundary::events::settlement::Indexer::new(
@@ -727,13 +727,13 @@ async fn shadow_mode(args: Arguments) -> ! {
         .collect();
 
     let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
-    let weth = WETH9::Instance::deployed(&web3.alloy)
+    let weth = WETH9::Instance::deployed(&web3.provider)
         .await
         .expect("couldn't find deployed WETH contract");
 
     let trusted_tokens = {
         let chain_id = web3
-            .alloy
+            .provider
             .get_chain_id()
             .await
             .expect("Could not get chainId");
@@ -765,7 +765,7 @@ async fn shadow_mode(args: Arguments) -> ! {
     let current_block = args
         .shared
         .current_block
-        .stream(args.shared.node_url, web3.alloy.clone())
+        .stream(args.shared.node_url, web3.provider.clone())
         .await
         .expect("couldn't initialize current block stream");
 
diff --git a/crates/cow-amm/src/factory.rs b/crates/cow-amm/src/factory.rs
index 54f6d7984b..214a3a6f40 100644
--- a/crates/cow-amm/src/factory.rs
+++ b/crates/cow-amm/src/factory.rs
@@ -30,6 +30,6 @@ impl AlloyEventRetrieving for Factory {
     }
 
     fn provider(&self) -> &DynProvider {
-        &self.web3.alloy
+        &self.web3.provider
     }
 }
diff --git a/crates/cow-amm/src/maintainers.rs b/crates/cow-amm/src/maintainers.rs
index fe39199a65..b4c93a2f84 100644
--- a/crates/cow-amm/src/maintainers.rs
+++ b/crates/cow-amm/src/maintainers.rs
@@ -28,7 +28,7 @@ impl EmptyPoolRemoval {
             .traded_tokens()
             .iter()
             .map(move |token| async move {
-                ERC20::Instance::new(*token, self.web3.alloy.clone())
+                ERC20::Instance::new(*token, self.web3.provider.clone())
                     .balanceOf(*amm_address)
                     .call()
                     .await
diff --git a/crates/cow-amm/src/registry.rs b/crates/cow-amm/src/registry.rs
index 864b6ec1cc..1a20c4b58f 100644
--- a/crates/cow-amm/src/registry.rs
+++ b/crates/cow-amm/src/registry.rs
@@ -44,7 +44,7 @@ impl Registry {
     ) {
         let storage = Storage::new(
             deployment_block,
-            CowAmmLegacyHelper::Instance::new(helper_contract, self.web3.alloy.clone()),
+            CowAmmLegacyHelper::Instance::new(helper_contract, self.web3.provider.clone()),
             factory,
             db,
         )
@@ -57,7 +57,7 @@ impl Registry {
             address: factory,
         };
         let event_handler =
-            EventHandler::new(Arc::new(self.web3.alloy.clone()), indexer, storage, None);
+            EventHandler::new(Arc::new(self.web3.provider.clone()), indexer, storage, None);
         let token_balance_maintainer =
             EmptyPoolRemoval::new(self.storage.clone(), self.web3.clone());
 
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
index 0e61710b0f..72287f6eb2 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
@@ -104,7 +104,7 @@ async fn init_liquidity(
 ) -> Result<impl LiquidityCollecting + use<>> {
     let web3 = eth.web3().clone();
     let contracts = BalancerContracts {
-        vault: BalancerV2Vault::Instance::new(config.vault.0, web3.alloy.clone()),
+        vault: BalancerV2Vault::Instance::new(config.vault.0, web3.provider.clone()),
         factories: [
             config
                 .weighted
@@ -112,7 +112,7 @@ async fn init_liquidity(
                 .map(|&factory| {
                     BalancerFactoryInstance::Weighted(BalancerV2WeightedPoolFactory::Instance::new(
                         factory,
-                        web3.alloy.clone(),
+                        web3.provider.clone(),
                     ))
                 })
                 .collect::<Vec<_>>(),
@@ -121,7 +121,10 @@ async fn init_liquidity(
                 .iter()
                 .map(|&factory| {
                     BalancerFactoryInstance::WeightedV3(
-                        BalancerV2WeightedPoolFactoryV3::Instance::new(factory, web3.alloy.clone()),
+                        BalancerV2WeightedPoolFactoryV3::Instance::new(
+                            factory,
+                            web3.provider.clone(),
+                        ),
                     )
                 })
                 .collect::<Vec<_>>(),
@@ -131,7 +134,7 @@ async fn init_liquidity(
                 .map(|&factory| {
                     BalancerFactoryInstance::StableV2(BalancerV2StablePoolFactoryV2::Instance::new(
                         factory,
-                        web3.alloy.clone(),
+                        web3.provider.clone(),
                     ))
                 })
                 .collect::<Vec<_>>(),
@@ -142,7 +145,7 @@ async fn init_liquidity(
                     BalancerFactoryInstance::LiquidityBootstrapping(
                         BalancerV2LiquidityBootstrappingPoolFactory::Instance::new(
                             factory,
-                            web3.alloy.clone(),
+                            web3.provider.clone(),
                         ),
                     )
                 })
@@ -154,7 +157,7 @@ async fn init_liquidity(
                     BalancerFactoryInstance::ComposableStable(
                         BalancerV2ComposableStablePoolFactory::Instance::new(
                             factory,
-                            web3.alloy.clone(),
+                            web3.provider.clone(),
                         ),
                     )
                 })
diff --git a/crates/driver/src/boundary/liquidity/mod.rs b/crates/driver/src/boundary/liquidity/mod.rs
index f34ec43781..0c91256ae9 100644
--- a/crates/driver/src/boundary/liquidity/mod.rs
+++ b/crates/driver/src/boundary/liquidity/mod.rs
@@ -56,7 +56,7 @@ impl Fetcher {
     /// Creates a new fetcher for the specified configuration.
     pub async fn try_new(eth: &Ethereum, config: &infra::liquidity::Config) -> Result<Self> {
         let block_stream = eth.current_block();
-        let block_retriever = Arc::new(eth.web3().alloy.clone());
+        let block_retriever = Arc::new(eth.web3().provider.clone());
 
         let uni_v2: Vec<_> = future::try_join_all(
             config
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v2.rs b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
index 6c2d33d9a6..4d51435a77 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v2.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
@@ -133,7 +133,7 @@ where
     R: PoolReading + Send + Sync + 'static,
     F: FnOnce(Web3, PairProvider) -> R,
 {
-    let router = IUniswapLikeRouter::Instance::new(config.router.0, eth.web3().alloy.clone());
+    let router = IUniswapLikeRouter::Instance::new(config.router.0, eth.web3().provider.clone());
     let settlement = eth.contracts().settlement().clone();
     let pool_fetcher = {
         let factory = router.factory().call().await?;
diff --git a/crates/driver/src/boundary/liquidity/zeroex.rs b/crates/driver/src/boundary/liquidity/zeroex.rs
index 13c15d4c3b..fbc5b44a7e 100644
--- a/crates/driver/src/boundary/liquidity/zeroex.rs
+++ b/crates/driver/src/boundary/liquidity/zeroex.rs
@@ -87,7 +87,7 @@ pub async fn collector(
     let eth = eth.with_metric_label("zeroex".into());
     let settlement = *eth.contracts().settlement().address();
     let web3 = eth.web3().clone();
-    let contract = contracts::alloy::IZeroex::Instance::deployed(&web3.alloy).await?;
+    let contract = contracts::alloy::IZeroex::Instance::deployed(&web3.provider).await?;
     let http_client_factory = &HttpClientFactory::new(&shared::http_client::Arguments {
         http_timeout: config.http_timeout,
     });
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index 99bd4bb178..bc67effeb0 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -140,7 +140,7 @@ impl DataAggregator {
             .map(|(factory, helper)| (factory.0, helper.0))
             .collect();
         let cow_amm_cache =
-            cow_amm::Cache::new(eth.web3().alloy.clone(), cow_amm_helper_by_factory);
+            cow_amm::Cache::new(eth.web3().provider.clone(), cow_amm_helper_by_factory);
 
         Self {
             utilities: Arc::new(Utilities {
diff --git a/crates/driver/src/infra/blockchain/contracts.rs b/crates/driver/src/infra/blockchain/contracts.rs
index 3ef81c4b03..4b19cc1226 100644
--- a/crates/driver/src/infra/blockchain/contracts.rs
+++ b/crates/driver/src/infra/blockchain/contracts.rs
@@ -57,18 +57,18 @@ impl Contracts {
                 .map(Into::into)
                 .or_else(|| GPv2Settlement::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
         let vault_relayer = settlement.vaultRelayer().call().await?;
         let vault =
-            BalancerV2Vault::Instance::new(settlement.vault().call().await?, web3.alloy.clone());
+            BalancerV2Vault::Instance::new(settlement.vault().call().await?, web3.provider.clone());
         let balance_helper = Balances::Instance::new(
             addresses
                 .balances
                 .map(Into::into)
                 .or_else(|| Balances::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
         let signatures = contracts::alloy::support::Signatures::Instance::new(
             addresses
@@ -76,7 +76,7 @@ impl Contracts {
                 .map(Into::into)
                 .or_else(|| contracts::alloy::support::Signatures::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         let weth = WETH9::Instance::new(
@@ -85,7 +85,7 @@ impl Contracts {
                 .map(Into::into)
                 .or_else(|| WETH9::deployment_address(&chain.id()))
                 .unwrap(),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
 
         let settlement_domain_separator = eth::DomainSeparator(
@@ -101,7 +101,7 @@ impl Contracts {
         let flashloan_router = addresses
             .flashloan_router
             .or_else(|| FlashLoanRouter::deployment_address(&chain.id()).map(eth::ContractAddress))
-            .map(|address| FlashLoanRouter::Instance::new(address.0, web3.alloy.clone()));
+            .map(|address| FlashLoanRouter::Instance::new(address.0, web3.provider.clone()));
 
         Ok(Self {
             settlement,
diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index 8c8741fdd5..a4d9a48ce3 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -37,12 +37,12 @@ impl GasPriceEstimator {
         mempools: &[mempool::Config],
     ) -> Result<Self, Error> {
         let gas: Arc<dyn GasPriceEstimating> = match gas_estimator_type {
-            GasEstimatorType::Web3 => Arc::new(NodeGasPriceEstimator::new(web3.alloy.clone())),
+            GasEstimatorType::Web3 => Arc::new(NodeGasPriceEstimator::new(web3.provider.clone())),
             GasEstimatorType::Alloy {
                 past_blocks,
                 reward_percentile,
             } => Arc::new(ConfigurableGasPriceEstimator::new(
-                web3.alloy.clone(),
+                web3.provider.clone(),
                 EstimatorConfig {
                     past_blocks: *past_blocks,
                     reward_percentile: *reward_percentile,
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 32abce8509..ecdb544e7a 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -54,7 +54,7 @@ impl Rpc {
             args.max_batch_size,
             args.max_concurrent_requests,
         );
-        let chain = Chain::try_from(web3.alloy.get_chain_id().await?)?;
+        let chain = Chain::try_from(web3.provider.get_chain_id().await?)?;
 
         Ok(Self { web3, chain, args })
     }
@@ -112,7 +112,7 @@ impl Ethereum {
         let Rpc { web3, chain, args } = rpc;
 
         let current_block_stream = current_block_args
-            .stream(args.url.clone(), web3.alloy.clone())
+            .stream(args.url.clone(), web3.provider.clone())
             .await
             .expect("couldn't initialize current block stream");
 
@@ -170,7 +170,7 @@ impl Ethereum {
 
     /// Check if a smart contract is deployed to the given address.
     pub async fn is_contract(&self, address: eth::Address) -> Result<bool, Error> {
-        let code = self.web3.alloy.get_code_at(address).await?;
+        let code = self.web3.provider.get_code_at(address).await?;
         Ok(!code.is_empty())
     }
 
@@ -197,7 +197,7 @@ impl Ethereum {
             _ => tx,
         };
 
-        let access_list = self.web3.alloy.create_access_list(&tx).pending().await?;
+        let access_list = self.web3.provider.create_access_list(&tx).pending().await?;
 
         Ok(access_list
             .ensure_ok()
@@ -222,7 +222,7 @@ impl Ethereum {
 
         let estimated_gas = self
             .web3
-            .alloy
+            .provider
             .estimate_gas(tx)
             .pending()
             .await
@@ -246,7 +246,7 @@ impl Ethereum {
     /// Returns the current [`eth::Ether`] balance of the specified account.
     pub async fn balance(&self, address: eth::Address) -> Result<eth::Ether, Error> {
         self.web3
-            .alloy
+            .provider
             .get_balance(address)
             .await
             .map(Into::into)
@@ -261,7 +261,7 @@ impl Ethereum {
     /// Returns the transaction's on-chain inclusion status.
     pub async fn transaction_status(&self, tx_hash: &eth::TxId) -> Result<eth::TxStatus, Error> {
         self.web3
-            .alloy
+            .provider
             .get_transaction_receipt(tx_hash.0)
             .await
             .map(|result| {
diff --git a/crates/driver/src/infra/blockchain/token.rs b/crates/driver/src/infra/blockchain/token.rs
index dfa27f223b..1f4aa4227c 100644
--- a/crates/driver/src/infra/blockchain/token.rs
+++ b/crates/driver/src/infra/blockchain/token.rs
@@ -14,7 +14,7 @@ pub struct Erc20 {
 impl Erc20 {
     pub(super) fn new(eth: &Ethereum, address: eth::TokenAddress) -> Self {
         Self {
-            token: contracts::alloy::ERC20::Instance::new(address.0.0, eth.web3.alloy.clone()),
+            token: contracts::alloy::ERC20::Instance::new(address.0.0, eth.web3.provider.clone()),
         }
     }
 
diff --git a/crates/driver/src/infra/mempool/mod.rs b/crates/driver/src/infra/mempool/mod.rs
index 1b120a7e5c..09ff772e3a 100644
--- a/crates/driver/src/infra/mempool/mod.rs
+++ b/crates/driver/src/infra/mempool/mod.rs
@@ -100,7 +100,7 @@ impl Mempool {
     /// specified block number. If no block number is provided in the config,
     /// uses the alloy's default behavior.
     pub async fn get_nonce(&self, address: eth::Address) -> Result<u64, mempools::Error> {
-        let call = self.transport.alloy.get_transaction_count(address);
+        let call = self.transport.provider.get_transaction_count(address);
         match self.config.nonce_block_number {
             Some(BlockNumberOrTag::Latest) => call.latest(),
             Some(BlockNumberOrTag::Earliest) => call.earliest(),
@@ -143,7 +143,7 @@ impl Mempool {
 
         let submission = self
             .transport
-            .alloy
+            .provider
             .send_transaction(tx_request)
             .await
             .map_err(anyhow::Error::from);
@@ -188,7 +188,7 @@ impl Mempool {
     ) -> anyhow::Result<Option<alloy::rpc::types::Transaction>> {
         let tx_pool_content = self
             .transport
-            .alloy
+            .provider
             .txpool_content_from(signer)
             .await
             .context("failed to query pending transactions")?;
diff --git a/crates/driver/src/tests/cases/settle.rs b/crates/driver/src/tests/cases/settle.rs
index 6a69e68c50..f184381c0e 100644
--- a/crates/driver/src/tests/cases/settle.rs
+++ b/crates/driver/src/tests/cases/settle.rs
@@ -118,7 +118,7 @@ async fn submits_huge_solution() {
     // half of the block gas limit, we want it to be submitted/settled as long as it
     // fits in the block.
     test.web3()
-        .alloy
+        .provider
         .raw_request::<_, bool>("evm_setBlockGasLimit".into(), (9_000_000,))
         .await
         .unwrap();
diff --git a/crates/driver/src/tests/setup/blockchain.rs b/crates/driver/src/tests/setup/blockchain.rs
index a5a1fe42d8..984e4ed58f 100644
--- a/crates/driver/src/tests/setup/blockchain.rs
+++ b/crates/driver/src/tests/setup/blockchain.rs
@@ -254,10 +254,10 @@ impl Blockchain {
         web3.wallet.register_signer(primary_account);
 
         // Use the primary account to fund the trader, cow amm and the solver with ETH.
-        let balance = web3.alloy.get_balance(primary_address).await.unwrap();
+        let balance = web3.provider.get_balance(primary_address).await.unwrap();
         wait_for(
             &web3,
-            web3.alloy.send_and_watch(
+            web3.provider.send_and_watch(
                 TransactionRequest::default()
                     .from(primary_address)
                     .to(main_trader_address)
@@ -267,15 +267,15 @@ impl Blockchain {
         .await
         .unwrap();
 
-        let weth = contracts::alloy::WETH9::Instance::deploy_builder(web3.alloy.clone())
+        let weth = contracts::alloy::WETH9::Instance::deploy_builder(web3.provider.clone())
             .from(main_trader_address)
             .deploy()
             .await
             .unwrap();
-        let weth = WETH9::WETH9::new(weth, web3.alloy.clone());
+        let weth = WETH9::WETH9::new(weth, web3.provider.clone());
         wait_for(
             &web3,
-            web3.alloy.send_and_watch(
+            web3.provider.send_and_watch(
                 TransactionRequest::default()
                     .from(primary_address)
                     .to(*weth.address())
@@ -286,14 +286,16 @@ impl Blockchain {
         .unwrap();
 
         // Set up the settlement contract and related contracts.
-        let vault_authorizer =
-            BalancerV2Authorizer::Instance::deploy_builder(web3.alloy.clone(), main_trader_address)
-                .from(main_trader_address)
-                .deploy()
-                .await
-                .unwrap();
+        let vault_authorizer = BalancerV2Authorizer::Instance::deploy_builder(
+            web3.provider.clone(),
+            main_trader_address,
+        )
+        .from(main_trader_address)
+        .deploy()
+        .await
+        .unwrap();
         let vault = BalancerV2Vault::Instance::deploy_builder(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             vault_authorizer,
             *weth.address(),
             alloy::primitives::U256::ZERO,
@@ -303,11 +305,11 @@ impl Blockchain {
         .deploy()
         .await
         .unwrap();
-        let authenticator = GPv2AllowListAuthentication::deploy(web3.alloy.clone())
+        let authenticator = GPv2AllowListAuthentication::deploy(web3.provider.clone())
             .await
             .unwrap();
         let mut settlement = GPv2Settlement::GPv2Settlement::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *authenticator.address(),
             vault,
         )
@@ -319,7 +321,7 @@ impl Blockchain {
                 // replace the vault relayer code to allow the settlement
                 // contract at a specific address.
                 let mut code = web3
-                    .alloy
+                    .provider
                     .get_code_at(vault_relayer)
                     .await
                     .unwrap()
@@ -333,31 +335,35 @@ impl Blockchain {
                 }
                 code
             };
-            web3.alloy
+            web3.provider
                 .anvil_set_code(vault_relayer, vault_relayer_code.into())
                 .await
                 .unwrap();
 
             // Note: (settlement.address() == authenticator_address) != settlement_address
-            let settlement_code = web3.alloy.get_code_at(*settlement.address()).await.unwrap();
-            web3.alloy
+            let settlement_code = web3
+                .provider
+                .get_code_at(*settlement.address())
+                .await
+                .unwrap();
+            web3.provider
                 .anvil_set_code(settlement_address, settlement_code)
                 .await
                 .unwrap();
 
             settlement =
-                GPv2Settlement::GPv2Settlement::new(settlement_address, web3.alloy.clone());
+                GPv2Settlement::GPv2Settlement::new(settlement_address, web3.provider.clone());
         }
 
         let balances_address = match config.balances_address {
             Some(balances_address) => balances_address,
-            None => Balances::Instance::deploy_builder(web3.alloy.clone())
+            None => Balances::Instance::deploy_builder(web3.provider.clone())
                 .from(main_trader_address)
                 .deploy()
                 .await
                 .unwrap(),
         };
-        let balances = Balances::Instance::new(balances_address, web3.alloy.clone());
+        let balances = Balances::Instance::new(balances_address, web3.provider.clone());
 
         authenticator
             .initializeManager(main_trader_address)
@@ -369,22 +375,22 @@ impl Blockchain {
         let signatures_address = if let Some(signatures_address) = config.signatures_address {
             signatures_address
         } else {
-            Signatures::Instance::deploy_builder(web3.alloy.clone())
+            Signatures::Instance::deploy_builder(web3.provider.clone())
                 .from(main_trader_address)
                 .deploy()
                 .await
                 .unwrap()
         };
-        let signatures = Signatures::Instance::new(signatures_address, web3.alloy.clone());
+        let signatures = Signatures::Instance::new(signatures_address, web3.provider.clone());
 
         let flashloan_router_address =
-            FlashLoanRouter::Instance::deploy_builder(web3.alloy.clone(), *settlement.address())
+            FlashLoanRouter::Instance::deploy_builder(web3.provider.clone(), *settlement.address())
                 .from(main_trader_address)
                 .deploy()
                 .await
                 .unwrap();
         let flashloan_router =
-            FlashLoanRouter::Instance::new(flashloan_router_address, web3.alloy.clone());
+            FlashLoanRouter::Instance::new(flashloan_router_address, web3.provider.clone());
 
         let mut trader_addresses: Vec<Address> = Vec::new();
         for config in config.solvers {
@@ -396,7 +402,7 @@ impl Blockchain {
                 .unwrap();
             wait_for(
                 &web3,
-                web3.alloy.send_and_watch(
+                web3.provider.send_and_watch(
                     TransactionRequest::default()
                         .from(primary_address)
                         .to(config.address())
@@ -419,13 +425,13 @@ impl Blockchain {
         let mut tokens = HashMap::new();
         for pool in config.pools.iter() {
             if pool.reserve_a.token != "WETH" && !tokens.contains_key(pool.reserve_a.token) {
-                let token = ERC20Mintable::Instance::deploy(web3.alloy.clone())
+                let token = ERC20Mintable::Instance::deploy(web3.provider.clone())
                     .await
                     .unwrap();
                 tokens.insert(pool.reserve_a.token, token);
             }
             if pool.reserve_b.token != "WETH" && !tokens.contains_key(pool.reserve_b.token) {
-                let token = ERC20Mintable::Instance::deploy(web3.alloy.clone())
+                let token = ERC20Mintable::Instance::deploy(web3.provider.clone())
                     .await
                     .unwrap();
                 tokens.insert(pool.reserve_b.token, token);
@@ -433,15 +439,17 @@ impl Blockchain {
         }
         // Create the uniswap factory.
         let contract_address = contracts::alloy::UniswapV2Factory::Instance::deploy_builder(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             main_trader_address,
         )
         .from(main_trader_address)
         .deploy()
         .await
         .unwrap();
-        let uniswap_factory =
-            contracts::alloy::UniswapV2Factory::Instance::new(contract_address, web3.alloy.clone());
+        let uniswap_factory = contracts::alloy::UniswapV2Factory::Instance::new(
+            contract_address,
+            web3.provider.clone(),
+        );
         // Create and fund a uniswap pair for each pool. Fund the settlement contract
         // with the same liquidity as the pool, to allow for internalized interactions.
         let mut pairs = Vec::new();
@@ -471,7 +479,7 @@ impl Blockchain {
                     .call()
                     .await
                     .unwrap(),
-                web3.alloy.clone(),
+                web3.provider.clone(),
             );
             pairs.push(Pair {
                 token_a: pool.reserve_a.token,
@@ -729,11 +737,11 @@ impl Blockchain {
             // Find the pair to use for this order and calculate the buy and sell amounts.
             let sell_token = ERC20::Instance::new(
                 self.get_token_wrapped(order.sell_token),
-                self.web3.alloy.clone(),
+                self.web3.provider.clone(),
             );
             let buy_token = ERC20::Instance::new(
                 self.get_token_wrapped(order.buy_token),
-                self.web3.alloy.clone(),
+                self.web3.provider.clone(),
             );
             let pair = self.find_pair(order);
             let execution = self.execution(order);
@@ -859,7 +867,7 @@ impl Blockchain {
     }
 
     pub async fn set_auto_mining(&self, enabled: bool) {
-        self.web3.alloy.evm_set_automine(enabled).await.unwrap();
+        self.web3.provider.evm_set_automine(enabled).await.unwrap();
     }
 }
 
@@ -958,7 +966,7 @@ impl Drop for Node {
 /// wait for transactions to be confirmed before proceeding with the test. When
 /// switching from geth back to hardhat, this function can be removed.
 pub async fn wait_for<T>(web3: &Web3, fut: impl Future<Output = T>) -> T {
-    let block = web3.alloy.get_block_number().await.unwrap();
+    let block = web3.provider.get_block_number().await.unwrap();
     let result = fut.await;
     wait_for_block(web3, block + 1).await;
     result
@@ -968,7 +976,7 @@ pub async fn wait_for<T>(web3: &Web3, fut: impl Future<Output = T>) -> T {
 pub async fn wait_for_block(web3: &Web3, block: u64) {
     tokio::time::timeout(std::time::Duration::from_secs(15), async {
         loop {
-            let next_block = web3.alloy.get_block_number().await.unwrap();
+            let next_block = web3.provider.get_block_number().await.unwrap();
             if next_block >= block {
                 break;
             }
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index e4202ef77d..5d1af8abde 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -1131,7 +1131,8 @@ impl Test {
 
     pub async fn settle_with_solver(&self, solver_name: &str, solution_id: u64) -> Settle {
         let submission_deadline_latest_block: u64 =
-            self.web3().alloy.get_block_number().await.unwrap() + self.settle_submission_deadline;
+            self.web3().provider.get_block_number().await.unwrap()
+                + self.settle_submission_deadline;
         let old_balances = self.balances().await;
         let res = self
             .client
@@ -1185,7 +1186,7 @@ impl Test {
             "ETH",
             self.blockchain
                 .web3
-                .alloy
+                .provider
                 .get_balance(self.trader_address)
                 .await
                 .unwrap(),
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index 79f147657b..ca01351e46 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -412,7 +412,7 @@ impl Solver {
             .flat_map(|f| {
                 let build_token = |token_name: String| async move {
                     let token = config.blockchain.get_token_wrapped(token_name.as_str());
-                    let contract = ERC20::Instance::new(token, config.blockchain.web3.alloy.clone());
+                    let contract = ERC20::Instance::new(token, config.blockchain.web3.provider.clone());
                     let settlement = config.blockchain.settlement.address();
                     (
                         token.encode_hex_with_prefix(),
diff --git a/crates/e2e/src/setup/deploy.rs b/crates/e2e/src/setup/deploy.rs
index 217cbf234b..f6963d31fb 100644
--- a/crates/e2e/src/setup/deploy.rs
+++ b/crates/e2e/src/setup/deploy.rs
@@ -47,48 +47,50 @@ pub struct Contracts {
 impl Contracts {
     pub async fn deployed_with(web3: &Web3, deployed: DeployedContracts) -> Self {
         let network_id = web3
-            .alloy
+            .provider
             .get_chain_id()
             .await
             .expect("get network ID failed")
             .to_string();
         tracing::info!("connected to forked test network {}", network_id);
 
-        let gp_settlement = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let gp_settlement = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let balances = match deployed.balances {
-            Some(address) => Balances::Instance::new(address, web3.alloy.clone()),
-            None => Balances::Instance::deployed(&web3.alloy)
+            Some(address) => Balances::Instance::new(address, web3.provider.clone()),
+            None => Balances::Instance::deployed(&web3.provider)
                 .await
                 .expect("failed to find balances contract"),
         };
         let signatures = match deployed.signatures {
-            Some(address) => Signatures::Instance::new(address, web3.alloy.clone()),
-            None => Signatures::Instance::deployed(&web3.alloy)
+            Some(address) => Signatures::Instance::new(address, web3.provider.clone()),
+            None => Signatures::Instance::deployed(&web3.provider)
                 .await
                 .expect("failed to find signatures contract"),
         };
 
-        let flashloan_router = FlashLoanRouter::Instance::deployed(&web3.alloy).await.ok();
+        let flashloan_router = FlashLoanRouter::Instance::deployed(&web3.provider)
+            .await
+            .ok();
 
         Self {
             chain_id: network_id
                 .parse()
                 .expect("Couldn't parse network ID to u64"),
-            balancer_vault: BalancerV2Vault::Instance::deployed(&web3.alloy)
+            balancer_vault: BalancerV2Vault::Instance::deployed(&web3.provider)
                 .await
                 .unwrap(),
-            gp_authenticator: GPv2AllowListAuthentication::Instance::deployed(&web3.alloy)
+            gp_authenticator: GPv2AllowListAuthentication::Instance::deployed(&web3.provider)
                 .await
                 .unwrap(),
-            uniswap_v2_factory: UniswapV2Factory::Instance::deployed(&web3.alloy)
+            uniswap_v2_factory: UniswapV2Factory::Instance::deployed(&web3.provider)
                 .await
                 .unwrap(),
-            uniswap_v2_router: UniswapV2Router02::Instance::deployed(&web3.alloy)
+            uniswap_v2_router: UniswapV2Router02::Instance::deployed(&web3.provider)
                 .await
                 .unwrap(),
-            weth: WETH9::Instance::deployed(&web3.alloy).await.unwrap(),
+            weth: WETH9::Instance::deployed(&web3.provider).await.unwrap(),
             allowance: gp_settlement
                 .vaultRelayer()
                 .call()
@@ -103,11 +105,11 @@ impl Contracts {
                     .0,
             ),
             ethflows: vec![
-                CoWSwapEthFlow::Instance::deployed(&web3.alloy)
+                CoWSwapEthFlow::Instance::deployed(&web3.provider)
                     .await
                     .unwrap(),
             ],
-            hooks: HooksTrampoline::Instance::deployed(&web3.alloy)
+            hooks: HooksTrampoline::Instance::deployed(&web3.provider)
                 .await
                 .unwrap(),
             gp_settlement,
@@ -119,7 +121,7 @@ impl Contracts {
 
     pub async fn deploy(web3: &Web3) -> Self {
         let network_id = web3
-            .alloy
+            .provider
             .get_chain_id()
             .await
             .expect("get network ID failed")
@@ -127,19 +129,22 @@ impl Contracts {
         tracing::info!("connected to test network {}", network_id);
 
         let accounts = web3
-            .alloy
+            .provider
             .get_accounts()
             .await
             .expect("get accounts failed");
         let admin = accounts[0];
 
-        let weth = WETH9::Instance::deploy(web3.alloy.clone()).await.unwrap();
-
-        let balancer_authorizer = BalancerV2Authorizer::Instance::deploy(web3.alloy.clone(), admin)
+        let weth = WETH9::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
+
+        let balancer_authorizer =
+            BalancerV2Authorizer::Instance::deploy(web3.provider.clone(), admin)
+                .await
+                .unwrap();
         let balancer_vault = BalancerV2Vault::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *balancer_authorizer.address(),
             *weth.address(),
             U256::ZERO,
@@ -148,18 +153,18 @@ impl Contracts {
         .await
         .unwrap();
 
-        let uniswap_v2_factory = UniswapV2Factory::Instance::deploy(web3.alloy.clone(), admin)
+        let uniswap_v2_factory = UniswapV2Factory::Instance::deploy(web3.provider.clone(), admin)
             .await
             .unwrap();
         let uniswap_v2_router = UniswapV2Router02::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *uniswap_v2_factory.address(),
             *weth.address(),
         )
         .await
         .unwrap();
 
-        let gp_authenticator = GPv2AllowListAuthentication::Instance::deploy(web3.alloy.clone())
+        let gp_authenticator = GPv2AllowListAuthentication::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
         gp_authenticator
@@ -168,16 +173,16 @@ impl Contracts {
             .await
             .expect("failed to initialize manager");
         let gp_settlement = GPv2Settlement::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *gp_authenticator.address(),
             *balancer_vault.address(),
         )
         .await
         .unwrap();
-        let balances = Balances::Instance::deploy(web3.alloy.clone())
+        let balances = Balances::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
-        let signatures = Signatures::Instance::deploy(web3.alloy.clone())
+        let signatures = Signatures::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
 
@@ -208,24 +213,25 @@ impl Contracts {
         );
 
         let ethflow = CoWSwapEthFlow::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *gp_settlement.address(),
             *weth.address(),
         )
         .await
         .unwrap();
         let ethflow_secondary = CoWSwapEthFlow::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *gp_settlement.address(),
             *weth.address(),
         )
         .await
         .unwrap();
-        let hooks = HooksTrampoline::Instance::deploy(web3.alloy.clone(), *gp_settlement.address())
-            .await
-            .unwrap();
+        let hooks =
+            HooksTrampoline::Instance::deploy(web3.provider.clone(), *gp_settlement.address())
+                .await
+                .unwrap();
         let flashloan_router =
-            FlashLoanRouter::Instance::deploy(web3.alloy.clone(), *gp_settlement.address())
+            FlashLoanRouter::Instance::deploy(web3.provider.clone(), *gp_settlement.address())
                 .await
                 .unwrap();
 
diff --git a/crates/e2e/src/setup/onchain_components/mod.rs b/crates/e2e/src/setup/onchain_components/mod.rs
index ecafbaee3e..1524b8ef59 100644
--- a/crates/e2e/src/setup/onchain_components/mod.rs
+++ b/crates/e2e/src/setup/onchain_components/mod.rs
@@ -54,7 +54,7 @@ impl TestAccount {
     }
 
     pub async fn nonce(&self, web3: &Web3) -> u64 {
-        web3.alloy
+        web3.provider
             .get_transaction_count(self.address())
             .await
             .unwrap()
@@ -293,7 +293,7 @@ impl OnchainComponents {
 
         for solver in &solvers {
             self.web3
-                .alloy
+                .provider
                 .anvil_send_impersonated_transaction_with_config(
                     gpv2_auth
                         .addSolver(solver.address())
@@ -313,7 +313,7 @@ impl OnchainComponents {
 
         if let Some(router) = &self.contracts.flashloan_router {
             self.web3
-                .alloy
+                .provider
                 .anvil_send_impersonated_transaction_with_config(
                     gpv2_auth
                         .addSolver(*router.address())
@@ -339,13 +339,14 @@ impl OnchainComponents {
         let mut res = Vec::with_capacity(N);
 
         for _ in 0..N {
-            let contract_address = ERC20Mintable::Instance::deploy_builder(self.web3.alloy.clone())
+            let contract_address = ERC20Mintable::Instance::deploy_builder(self.web3.provider.clone())
                 // We can't escape the .from here because we need to ensure Minter permissions later on
                 .from(minter)
                 .deploy()
                 .await
                 .expect("ERC20Mintable deployment failed");
-            let contract = ERC20Mintable::Instance::new(contract_address, self.web3.alloy.clone());
+            let contract =
+                ERC20Mintable::Instance::new(contract_address, self.web3.provider.clone());
 
             res.push(MintableToken { contract, minter });
         }
@@ -361,7 +362,7 @@ impl OnchainComponents {
     ) -> [MintableToken; N] {
         let minter = self
             .web3
-            .alloy
+            .provider
             .get_accounts()
             .await
             .expect("getting accounts failed")[0];
@@ -497,7 +498,7 @@ impl OnchainComponents {
                 .call()
                 .await
                 .expect("failed to get Uniswap V2 pair"),
-            self.web3.alloy.clone(),
+            self.web3.provider.clone(),
         );
         assert!(!pair.address().is_zero(), "Uniswap V2 pair is not deployed");
 
@@ -524,7 +525,7 @@ impl OnchainComponents {
     pub async fn deploy_cow_token(&self, supply: U256) -> CowToken {
         let holder = NetworkWallet::<Ethereum>::default_signer_address(&self.web3().wallet);
         let contract = CowProtocolToken::CowProtocolToken::deploy(
-            self.web3.alloy.clone(),
+            self.web3.provider.clone(),
             holder,
             holder,
             supply,
@@ -591,9 +592,9 @@ impl OnchainComponents {
     }
 
     pub async fn send_wei(&self, to: Address, amount: U256) {
-        let balance_before = self.web3.alloy.get_balance(to).await.unwrap();
+        let balance_before = self.web3.provider.get_balance(to).await.unwrap();
         self.web3
-            .alloy
+            .provider
             .send_transaction(TransactionRequest::default().with_to(to).with_value(amount))
             .await
             .unwrap()
@@ -606,13 +607,13 @@ impl OnchainComponents {
         // supposedly succeeds but the balances still don't get changed.
         // If you hit this assert try using a different block number for your
         // forked test.
-        let balance_after = self.web3.alloy.get_balance(to).await.unwrap();
+        let balance_after = self.web3.provider.get_balance(to).await.unwrap();
         assert_eq!(balance_after, balance_before + amount);
     }
 
     pub async fn mint_block(&self) {
         tracing::info!("mining block");
-        self.web3.alloy.evm_mine(None).await.unwrap();
+        self.web3.provider.evm_mine(None).await.unwrap();
     }
 
     pub fn contracts(&self) -> &Contracts {
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 023e36fe40..c018566960 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -924,7 +924,7 @@ impl<'a> Services<'a> {
 
     async fn mint_block(&self) {
         tracing::info!("mining block");
-        self.web3.alloy.evm_mine(None).await.unwrap();
+        self.web3.provider.evm_mine(None).await.unwrap();
     }
 }
 
diff --git a/crates/e2e/tests/e2e/app_data_signer.rs b/crates/e2e/tests/e2e/app_data_signer.rs
index 4fe3fba81a..3630647dd2 100644
--- a/crates/e2e/tests/e2e/app_data_signer.rs
+++ b/crates/e2e/tests/e2e/app_data_signer.rs
@@ -94,7 +94,7 @@ async fn order_creation_checks_metadata_signer(web3: Web3) {
 
     // EIP-1271
 
-    let safe = Safe::deploy(safe_owner.clone(), web3.alloy.clone()).await;
+    let safe = Safe::deploy(safe_owner.clone(), web3.provider.clone()).await;
     token_a.mint(safe.address(), 10u64.eth()).await;
     safe.exec_alloy_call(
         token_a
diff --git a/crates/e2e/tests/e2e/banned_users.rs b/crates/e2e/tests/e2e/banned_users.rs
index 5e4ab46dd3..4171cea0dd 100644
--- a/crates/e2e/tests/e2e/banned_users.rs
+++ b/crates/e2e/tests/e2e/banned_users.rs
@@ -35,15 +35,15 @@ async fn forked_mainnet_onchain_banned_user_test(web3: Web3) {
 
     let token_dai = ERC20::Instance::new(
         address!("6b175474e89094c44da98b954eedeac495271d0f"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     let token_usdt = ERC20::Instance::new(
         address!("dac17f958d2ee523a2206206994597c13d831ec7"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_dai
                 .transfer(BANNED_USER, 1000u64.eth())
@@ -61,7 +61,7 @@ async fn forked_mainnet_onchain_banned_user_test(web3: Web3) {
         .unwrap();
 
     // Approve GPv2 for trading
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_dai
                 .approve(onchain.contracts().allowance, 1000u64.eth())
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 78ab8afe62..0cb0cf730d 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -69,14 +69,15 @@ async fn cow_amm_jit(web3: Web3) {
     .await;
 
     // set up cow_amm
-    let oracle =
-        contracts::alloy::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(web3.alloy.clone())
-            .await
-            .unwrap();
+    let oracle = contracts::alloy::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(
+        web3.provider.clone(),
+    )
+    .await
+    .unwrap();
 
     let cow_amm_factory =
         contracts::alloy::cow_amm::CowAmmConstantProductFactory::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *onchain.contracts().gp_settlement.address(),
         )
         .await
@@ -146,7 +147,7 @@ async fn cow_amm_jit(web3: Web3) {
         .send_and_watch()
         .await
         .unwrap();
-    let cow_amm = contracts::alloy::cow_amm::CowAmm::Instance::new(cow_amm, web3.alloy.clone());
+    let cow_amm = contracts::alloy::cow_amm::CowAmm::Instance::new(cow_amm, web3.provider.clone());
 
     // Start system with the regular baseline solver as a quoter but a mock solver
     // for the actual solver competition. That way we can handcraft a solution
@@ -201,7 +202,7 @@ async fn cow_amm_jit(web3: Web3) {
     // a relatively small valid_to and we initialize the chain with a date in
     // the past so the computer's current time is way ahead of the blockchain.
     let block = web3
-        .alloy
+        .provider
         .get_block(alloy::eips::BlockId::latest())
         .await
         .unwrap()
@@ -382,10 +383,10 @@ async fn cow_amm_driver_support(web3: Web3) {
     // since changing the forked number would result in very costly ~1 year of event
     // syncing, we deploy the following SCs
     let deployed_contracts = {
-        let balances = Balances::Instance::deploy(web3.alloy.clone())
+        let balances = Balances::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
-        let signatures = Signatures::Instance::deploy(web3.alloy.clone())
+        let signatures = Signatures::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
         DeployedContracts {
@@ -404,12 +405,12 @@ async fn cow_amm_driver_support(web3: Web3) {
     // create necessary token instances
     let usdc = ERC20::Instance::new(
         address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     let usdt = ERC20::Instance::new(
         address!("dac17f958d2ee523a2206206994597c13d831ec7"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     // Unbalance the cow amm enough that baseline is able to rebalance
@@ -452,7 +453,7 @@ async fn cow_amm_driver_support(web3: Web3) {
     // settle.
 
     // Give trader some USDC
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             usdc.transfer(trader.address(), 1000u64.matom())
                 .from(USDC_WHALE_MAINNET)
@@ -479,14 +480,14 @@ async fn cow_amm_driver_support(web3: Web3) {
     const ZERO_BALANCE_AMM: Address = address!("b3bf81714f704720dcb0351ff0d42eca61b069fc");
     let pendle_token = ERC20::Instance::new(
         address!("808507121b80c02388fad14726482e061b8da827"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
     let balance = pendle_token
         .balanceOf(ZERO_BALANCE_AMM)
         .call()
         .await
         .unwrap();
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             pendle_token
                 .transfer(
@@ -690,14 +691,15 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     // the user order.
 
     // Set up the CoW AMM as before
-    let oracle =
-        contracts::alloy::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(web3.alloy.clone())
-            .await
-            .unwrap();
+    let oracle = contracts::alloy::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(
+        web3.provider.clone(),
+    )
+    .await
+    .unwrap();
 
     let cow_amm_factory =
         contracts::alloy::cow_amm::CowAmmConstantProductFactory::Instance::deploy(
-            web3.alloy.clone(),
+            web3.provider.clone(),
             *onchain.contracts().gp_settlement.address(),
         )
         .await
@@ -780,7 +782,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
         .await
         .unwrap();
     let cow_amm =
-        contracts::alloy::cow_amm::CowAmm::Instance::new(cow_amm_address, web3.alloy.clone());
+        contracts::alloy::cow_amm::CowAmm::Instance::new(cow_amm_address, web3.provider.clone());
 
     // Start system with the mocked solver. Baseline is still required for the
     // native price estimation.
@@ -831,7 +833,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
 
     // Get the current block timestamp
     let block = web3
-        .alloy
+        .provider
         .get_block(alloy::eips::BlockId::latest())
         .await
         .unwrap()
diff --git a/crates/e2e/tests/e2e/eth_integration.rs b/crates/e2e/tests/e2e/eth_integration.rs
index 51eaa0f4b2..1a0417ddb2 100644
--- a/crates/e2e/tests/e2e/eth_integration.rs
+++ b/crates/e2e/tests/e2e/eth_integration.rs
@@ -46,7 +46,7 @@ async fn eth_integration(web3: Web3) {
         .await
         .unwrap();
 
-    let trader_a_eth_balance_before = web3.alloy.get_balance(trader_a.address()).await.unwrap();
+    let trader_a_eth_balance_before = web3.provider.get_balance(trader_a.address()).await.unwrap();
 
     let services = Services::new(&onchain).await;
     services.start_protocol(solver).await;
@@ -109,8 +109,8 @@ async fn eth_integration(web3: Web3) {
     tracing::info!("Waiting for trade.");
     onchain.mint_block().await;
     let trade_happened = || async {
-        let balance_a = web3.alloy.get_balance(trader_a.address()).await.unwrap();
-        let balance_b = web3.alloy.get_balance(trader_b.address()).await.unwrap();
+        let balance_a = web3.provider.get_balance(trader_a.address()).await.unwrap();
+        let balance_b = web3.provider.get_balance(trader_b.address()).await.unwrap();
 
         let trader_a_eth_decreased = (balance_a - trader_a_eth_balance_before) == 49u64.eth();
         let trader_b_eth_increased = balance_b >= 49u64.eth();
diff --git a/crates/e2e/tests/e2e/eth_safe.rs b/crates/e2e/tests/e2e/eth_safe.rs
index cdba2f6bfd..3925e8f60f 100644
--- a/crates/e2e/tests/e2e/eth_safe.rs
+++ b/crates/e2e/tests/e2e/eth_safe.rs
@@ -22,7 +22,7 @@ async fn test(web3: Web3) {
 
     let [solver] = onchain.make_solvers(10u64.eth()).await;
     let [trader] = onchain.make_accounts(10u64.eth()).await;
-    let safe = Safe::deploy(trader.clone(), web3.alloy.clone()).await;
+    let safe = Safe::deploy(trader.clone(), web3.provider.clone()).await;
     let [token] = onchain
         .deploy_tokens_with_weth_uni_v2_pools(1000u64.eth(), 1000u64.eth())
         .await;
@@ -77,7 +77,7 @@ async fn test(web3: Web3) {
 
     tracing::info!("Waiting for trade.");
     let trade_happened = || async {
-        let safe_balance = web3.alloy.get_balance(safe.address()).await.unwrap();
+        let safe_balance = web3.provider.get_balance(safe.address()).await.unwrap();
         // the balance is slightly less because of the fee
         U256::from(3_899_000_000_000_000_000_u128) <= safe_balance
             && safe_balance <= U256::from(4_000_000_000_000_000_000_u128)
diff --git a/crates/e2e/tests/e2e/ethflow.rs b/crates/e2e/tests/e2e/ethflow.rs
index bf1025bd0a..eabbb5a6f8 100644
--- a/crates/e2e/tests/e2e/ethflow.rs
+++ b/crates/e2e/tests/e2e/ethflow.rs
@@ -152,7 +152,7 @@ async fn eth_flow_tx(web3: Web3) {
     let quote: OrderQuoteResponse = test_submit_quote(&services, &quote_request).await;
 
     let valid_to = chrono::offset::Utc::now().timestamp() as u32
-        + timestamp_of_current_block_in_seconds(&web3.alloy)
+        + timestamp_of_current_block_in_seconds(&web3.provider)
             .await
             .unwrap()
         + 3600;
@@ -260,7 +260,7 @@ async fn eth_flow_without_quote(web3: Web3) {
     services.start_protocol(solver).await;
 
     let valid_to = chrono::offset::Utc::now().timestamp() as u32
-        + timestamp_of_current_block_in_seconds(&web3.alloy)
+        + timestamp_of_current_block_in_seconds(&web3.provider)
             .await
             .unwrap()
         + 3600;
@@ -311,7 +311,7 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
     services.start_protocol(solver).await;
 
     // Create an order that only exists to be cancelled.
-    let valid_to = timestamp_of_current_block_in_seconds(&web3.alloy)
+    let valid_to = timestamp_of_current_block_in_seconds(&web3.provider)
         .await
         .unwrap()
         + 60;
@@ -348,7 +348,7 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
     let receiver = Address::repeat_byte(0x42);
     let sell_amount = 1u64.eth();
     let valid_to = chrono::offset::Utc::now().timestamp() as u32
-        + timestamp_of_current_block_in_seconds(&web3.alloy)
+        + timestamp_of_current_block_in_seconds(&web3.provider)
             .await
             .unwrap()
         + 60;
@@ -498,7 +498,7 @@ async fn test_order_was_settled(ethflow_order: &ExtendedEthFlowOrder, onchain: &
     wait_for_condition(TIMEOUT, || async {
         onchain.mint_block().await;
         let buy_token =
-            ERC20Mintable::Instance::new(ethflow_order.0.buyToken, onchain.web3().alloy.clone());
+            ERC20Mintable::Instance::new(ethflow_order.0.buyToken, onchain.web3().provider.clone());
         let receiver_buy_token_balance = buy_token
             .balanceOf(ethflow_order.0.receiver)
             .call()
@@ -836,7 +836,7 @@ async fn eth_flow_zero_buy_amount(web3: Web3) {
 
     let place_order = async |trader: TestAccount, buy_amount: u64| {
         let valid_to = chrono::offset::Utc::now().timestamp() as u32
-            + timestamp_of_current_block_in_seconds(&web3.alloy)
+            + timestamp_of_current_block_in_seconds(&web3.provider)
                 .await
                 .unwrap()
             + 3600;
diff --git a/crates/e2e/tests/e2e/hooks.rs b/crates/e2e/tests/e2e/hooks.rs
index 2339f7e281..39696c2904 100644
--- a/crates/e2e/tests/e2e/hooks.rs
+++ b/crates/e2e/tests/e2e/hooks.rs
@@ -251,12 +251,12 @@ async fn allowance(web3: Web3) {
 async fn signature(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
-    let chain_id = U256::from(web3.alloy.get_chain_id().await.unwrap());
+    let chain_id = U256::from(web3.provider.get_chain_id().await.unwrap());
 
     let [solver] = onchain.make_solvers(1u64.eth()).await;
     let [trader] = onchain.make_accounts(1u64.eth()).await;
 
-    let safe_infra = onchain_components::safe::Infrastructure::new(web3.alloy.clone()).await;
+    let safe_infra = onchain_components::safe::Infrastructure::new(web3.provider.clone()).await;
 
     // Prepare the Safe creation transaction, but don't execute it! This will
     // be executed as a pre-hook.
@@ -287,7 +287,7 @@ async fn signature(web3: Web3) {
     let safe_address = safe_creation_builder.clone().call().await.unwrap();
     let safe = Safe::deployed(
         chain_id,
-        contracts::alloy::GnosisSafe::Instance::new(safe_address, web3.alloy.clone()),
+        contracts::alloy::GnosisSafe::Instance::new(safe_address, web3.provider.clone()),
         trader.clone(),
     );
 
@@ -361,7 +361,7 @@ async fn signature(web3: Web3) {
     assert_eq!(balance, 5u64.eth());
 
     // Check that the Safe really hasn't been deployed yet.
-    let code = web3.alloy.get_code_at(safe.address()).await.unwrap();
+    let code = web3.provider.get_code_at(safe.address()).await.unwrap();
     assert_eq!(code.0.len(), 0);
 
     tracing::info!("Waiting for trade.");
@@ -387,7 +387,7 @@ async fn signature(web3: Web3) {
     assert!(balance >= order.buy_amount);
 
     // Check Safe was deployed
-    let code = web3.alloy.get_code_at(safe.address()).await.unwrap();
+    let code = web3.provider.get_code_at(safe.address()).await.unwrap();
     assert_ne!(code.0.len(), 0);
 
     tracing::info!("Waiting for auction to be cleared.");
@@ -401,7 +401,7 @@ async fn partial_fills(web3: Web3) {
     let [solver] = onchain.make_solvers(1u64.eth()).await;
     let [trader] = onchain.make_accounts(3u64.eth()).await;
 
-    let counter = contracts::alloy::test::Counter::Instance::deploy(web3.alloy.clone())
+    let counter = contracts::alloy::test::Counter::Instance::deploy(web3.provider.clone())
         .await
         .unwrap();
 
@@ -523,12 +523,12 @@ async fn partial_fills(web3: Web3) {
 async fn quote_verification(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
-    let chain_id = U256::from(web3.alloy.get_chain_id().await.unwrap());
+    let chain_id = U256::from(web3.provider.get_chain_id().await.unwrap());
 
     let [trader] = onchain.make_accounts(1u64.eth()).await;
     let [solver] = onchain.make_solvers(1u64.eth()).await;
 
-    let safe_infra = onchain_components::safe::Infrastructure::new(web3.alloy.clone()).await;
+    let safe_infra = onchain_components::safe::Infrastructure::new(web3.provider.clone()).await;
 
     // Prepare the Safe creation transaction, but don't execute it! This will
     // be executed as a pre-hook.
@@ -554,7 +554,7 @@ async fn quote_verification(web3: Web3) {
 
     let safe = Safe::deployed(
         chain_id,
-        contracts::alloy::GnosisSafe::Instance::new(safe_address, web3.alloy.clone()),
+        contracts::alloy::GnosisSafe::Instance::new(safe_address, web3.provider.clone()),
         trader.clone(),
     );
 
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index d4de694f72..6417277b19 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -863,16 +863,16 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
 
     let token_usdc = ERC20::Instance::new(
         address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     let token_usdt = ERC20::Instance::new(
         address!("dac17f958d2ee523a2206206994597c13d831ec7"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     // Give trader some USDC
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdc
                 .transfer(trader.address(), 1000u64.matom())
@@ -963,16 +963,16 @@ async fn forked_gnosis_single_limit_order_test(web3: Web3) {
 
     let token_usdc = ERC20::Instance::new(
         address!("ddafbb505ad214d7b80b1f830fccc89b60fb7a83"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     let token_wxdai = ERC20::Instance::new(
         address!("e91d153e0b41518a2ce8dd3d7944fa863463a97d"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     // Give trader some USDC
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdc
                 .transfer(trader.address(), 1000u64.matom())
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index cba31e19ad..5e13e3baf2 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -54,21 +54,21 @@ async fn zero_ex_liquidity(web3: Web3) {
 
     let token_usdc = ERC20::Instance::new(
         address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     let token_usdt = ERC20::Instance::new(
         address!("dac17f958d2ee523a2206206994597c13d831ec7"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     web3.wallet.register_signer(solver.signer.clone());
-    let zeroex = IZeroex::Instance::deployed(&web3.alloy).await.unwrap();
+    let zeroex = IZeroex::Instance::deployed(&web3.provider).await.unwrap();
 
     let amount = 500u64.matom();
 
     // Give trader some USDC
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdc
                 .transfer(trader.address(), amount)
@@ -87,7 +87,7 @@ async fn zero_ex_liquidity(web3: Web3) {
 
     // Give 0x maker a bit more USDT
     // With a lower amount 0x contract shows much lower fillable amount
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdt
                 .transfer(
@@ -107,7 +107,7 @@ async fn zero_ex_liquidity(web3: Web3) {
         .await
         .unwrap();
     // Required for the remaining fillable taker amount
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdc
                 .transfer(solver.address(), amount)
@@ -159,7 +159,7 @@ async fn zero_ex_liquidity(web3: Web3) {
         &trader.signer,
     );
 
-    let chain_id = web3.alloy.get_chain_id().await.unwrap();
+    let chain_id = web3.provider.get_chain_id().await.unwrap();
     let zeroex_liquidity_orders = create_zeroex_liquidity_orders(
         order.clone(),
         zeroex_maker.clone(),
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index cef36e12b8..8a2cb42b1f 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -65,17 +65,17 @@ async fn liquidity_source_notification(web3: Web3) {
     // Access trade tokens contracts
     let token_usdc = ERC20::Instance::new(
         address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     let token_usdt = ERC20::Instance::new(
         address!("dac17f958d2ee523a2206206994597c13d831ec7"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     // CoW onchain setup
     // Fund trader
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdc
                 .transfer(trader.address(), trade_amount)
@@ -93,7 +93,7 @@ async fn liquidity_source_notification(web3: Web3) {
         .unwrap();
 
     // Fund solver
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdc
                 .transfer(solver.address(), trade_amount)
@@ -122,7 +122,7 @@ async fn liquidity_source_notification(web3: Web3) {
 
     // Liquorice settlement contract through which we will trade with the
     // `liquorice_maker`
-    let liquorice_settlement = LiquoriceSettlement::Instance::deployed(&web3.alloy)
+    let liquorice_settlement = LiquoriceSettlement::Instance::deployed(&web3.provider)
         .await
         .unwrap();
 
@@ -133,7 +133,7 @@ async fn liquidity_source_notification(web3: Web3) {
         .expect("no balance manager found");
 
     // Fund `liquorice_maker`
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             token_usdt
                 .transfer(liquorice_maker.address(), trade_amount)
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index e1aeb18774..07bef2aa6c 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -57,7 +57,7 @@ async fn place_order_with_quote(web3: Web3) {
     services.start_protocol(solver.clone()).await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
@@ -140,7 +140,7 @@ async fn disabled_same_sell_and_buy_token_order_feature(web3: Web3) {
     services.start_protocol(solver.clone()).await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 295cb0c636..a288b082b4 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -143,7 +143,7 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
         "https" => url.set_scheme("wss").unwrap(),
         _ => unreachable!("unexpected scheme"),
     }
-    let block_stream = ethrpc::block_stream::current_block_ws_stream(web3.alloy.clone(), url)
+    let block_stream = ethrpc::block_stream::current_block_ws_stream(web3.provider.clone(), url)
         .await
         .unwrap();
     let onchain = OnchainComponents::deployed(web3.clone()).await;
@@ -421,7 +421,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
     assert!(
         onchain
             .web3()
-            .alloy
+            .provider
             .get_balance(trader.address())
             .await
             .unwrap()
@@ -567,7 +567,7 @@ async fn trace_based_balance_detection(web3: Web3) {
     // offset within a struct mapping, making it undetectable by standard slot
     // calculation methods
     let struct_offset_token =
-        contracts::alloy::test::NonStandardERC20Balances::Instance::deploy(web3.alloy.clone())
+        contracts::alloy::test::NonStandardERC20Balances::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
 
@@ -577,14 +577,14 @@ async fn trace_based_balance_detection(web3: Web3) {
     // calling another contract to get a balance--or calling another contract to
     // *not* get a balance)
     let local_storage_token = contracts::alloy::test::RemoteERC20Balances::Instance::deploy(
-        web3.alloy.clone(),
+        web3.provider.clone(),
         weth,
         true,
     )
     .await
     .unwrap();
     let delegated_storage_token = contracts::alloy::test::RemoteERC20Balances::Instance::deploy(
-        web3.alloy.clone(),
+        web3.provider.clone(),
         weth,
         false,
     )
@@ -697,7 +697,7 @@ async fn trace_based_balance_detection(web3: Web3) {
         let (override_token, state_override) = override_result.unwrap();
 
         // Call balanceOf with the state override to verify it works
-        let token_contract = ERC20::Instance::new(token, web3.alloy.clone());
+        let token_contract = ERC20::Instance::new(token, web3.provider.clone());
         let balance = token_contract
             .balanceOf(test_account)
             .state(AddressMap::from_iter([(
diff --git a/crates/e2e/tests/e2e/refunder.rs b/crates/e2e/tests/e2e/refunder.rs
index 01ace9ad94..36f50f5a7b 100644
--- a/crates/e2e/tests/e2e/refunder.rs
+++ b/crates/e2e/tests/e2e/refunder.rs
@@ -31,11 +31,11 @@ async fn advance_time_past_expiration(web3: &Web3, valid_to: u32) {
     // Add 60 seconds buffer so the order is definitively expired, not just at the
     // boundary.
     let target_timestamp = valid_to as u64 + 60;
-    web3.alloy
+    web3.provider
         .evm_set_next_block_timestamp(target_timestamp)
         .await
         .expect("Must be able to set block timestamp");
-    web3.alloy
+    web3.provider
         .evm_mine(None)
         .await
         .expect("Unable to mine next block");
@@ -277,7 +277,7 @@ async fn run_refunder_threshold_test(
     let ethflow_contract = onchain.contracts().ethflows.first().unwrap();
 
     // Compute absolute valid_to timestamp from blockchain time + duration
-    let valid_to = timestamp_of_current_block_in_seconds(&web3.alloy)
+    let valid_to = timestamp_of_current_block_in_seconds(&web3.provider)
         .await
         .unwrap()
         + validity.order;
@@ -596,7 +596,7 @@ async fn refunder_multiple_ethflow_contracts(web3: Web3) {
     let buy_token = *token.address();
 
     let validity_duration = 600u32;
-    let valid_to = timestamp_of_current_block_in_seconds(&web3.alloy)
+    let valid_to = timestamp_of_current_block_in_seconds(&web3.provider)
         .await
         .unwrap()
         + validity_duration;
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index d2175f94e2..ef76ccdcc6 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -153,7 +153,7 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) {
         .unwrap();
 
     // disable auto mining to prevent order being immediately executed
-    web3.alloy.evm_set_automine(false).await.unwrap();
+    web3.provider.evm_set_automine(false).await.unwrap();
 
     // Place Orders
     let services = Services::new(&onchain).await;
@@ -224,7 +224,7 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) {
     );
 
     // Continue automining so our order can be executed
-    web3.alloy
+    web3.provider
         .evm_set_automine(true)
         .await
         .expect("Must be able to disable auto-mining");
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 3c8e9e5a42..bc1ca03996 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -29,7 +29,7 @@ async fn smart_contract_orders(web3: Web3) {
     let [solver] = onchain.make_solvers(1u64.eth()).await;
     let [trader] = onchain.make_accounts(1u64.eth()).await;
 
-    let safe = Safe::deploy(trader, web3.alloy.clone()).await;
+    let safe = Safe::deploy(trader, web3.provider.clone()).await;
 
     let [token] = onchain
         .deploy_tokens_with_weth_uni_v2_pools(100_000u64.eth(), 100_000u64.eth())
@@ -155,7 +155,7 @@ async fn erc1271_gas_limit(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
     let [solver] = onchain.make_solvers(1u64.eth()).await;
-    let trader = contracts::alloy::test::GasHog::Instance::deploy(web3.alloy.clone())
+    let trader = contracts::alloy::test::GasHog::Instance::deploy(web3.provider.clone())
         .await
         .unwrap();
 
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index f45c449e98..562c7fd87a 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -71,7 +71,7 @@ async fn test_cancel_on_expiry(web3: Web3) {
     services.start_protocol(solver.clone()).await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
@@ -98,7 +98,7 @@ async fn test_cancel_on_expiry(web3: Web3) {
 
     // Start tracking confirmed blocks so we can find the transaction later
     let block_stream = web3
-        .alloy
+        .provider
         .watch_blocks()
         .await
         .expect("must be able to create blocks filter")
@@ -112,11 +112,11 @@ async fn test_cancel_on_expiry(web3: Web3) {
     .unwrap();
 
     // Restart mining, but with blocks that are too small to fit the settlement
-    web3.alloy
+    web3.provider
         .evm_set_block_gas_limit(100_000)
         .await
         .expect("Must be able to set block gas limit");
-    web3.alloy
+    web3.provider
         .evm_set_interval_mining(1)
         .await
         .expect("Must be able to set mining interval");
@@ -167,7 +167,7 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
         .await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
@@ -196,7 +196,7 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
     services.create_order(&order).await.unwrap();
     // Start tracking confirmed blocks so we can find the transaction later
     let block_stream = web3
-        .alloy
+        .provider
         .watch_blocks()
         .await
         .expect("must be able to create blocks filter")
@@ -213,7 +213,7 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
     .unwrap();
 
     // Continue mining to confirm the settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(true)
         .await
         .expect("Must be able to enable automine");
@@ -278,7 +278,7 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
         .await;
 
     // Disable auto-mine so we don't accidentally mine a settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(false)
         .await
         .expect("Must be able to disable automine");
@@ -358,7 +358,7 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
 
     // Start tracking confirmed blocks so we can find the transaction later
     let block_stream = web3
-        .alloy
+        .provider
         .watch_blocks()
         .await
         .expect("must be able to create blocks filter")
@@ -375,7 +375,7 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
     .unwrap();
 
     // Continue mining to confirm the settlement
-    web3.alloy
+    web3.provider
         .evm_set_automine(true)
         .await
         .expect("Must be able to enable automine");
@@ -411,7 +411,7 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
 
 async fn get_pending_tx(account: Address, web3: &Web3) -> Option<Transaction> {
     let txpool = web3
-        .alloy
+        .provider
         .txpool_content()
         .await
         .expect("must be able to inspect mempool");
@@ -428,7 +428,7 @@ async fn get_confirmed_transaction(
         let block_hashes = block_hash_stream.next().await.unwrap();
         for block_hash in block_hashes {
             let transaction_senders = web3
-                .alloy
+                .provider
                 .get_block_receipts(block_hash.into())
                 .await
                 .unwrap()
diff --git a/crates/e2e/tests/e2e/wrapper.rs b/crates/e2e/tests/e2e/wrapper.rs
index f7653a2ed8..6bcf5c47f6 100644
--- a/crates/e2e/tests/e2e/wrapper.rs
+++ b/crates/e2e/tests/e2e/wrapper.rs
@@ -50,11 +50,11 @@ async fn forked_mainnet_wrapper_test(web3: Web3) {
     let token_weth = onchain.contracts().weth.clone();
     let token_usdc = ERC20::Instance::new(
         address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
-        web3.alloy.clone(),
+        web3.provider.clone(),
     );
 
     // Authorize the empty wrapper as a solver
-    web3.alloy
+    web3.provider
         .anvil_send_impersonated_transaction_with_config(
             onchain
                 .contracts()
@@ -214,7 +214,7 @@ async fn forked_mainnet_wrapper_test(web3: Web3) {
     tracing::info!("Settlement transaction hash: {:?}", solve_tx_hash);
 
     let solve_tx = web3
-        .alloy
+        .provider
         .get_transaction_by_hash(solve_tx_hash)
         .await
         .unwrap()
@@ -245,7 +245,7 @@ async fn forked_mainnet_wrapper_test(web3: Web3) {
     };
 
     let trace = web3
-        .alloy
+        .provider
         .debug_trace_transaction(solve_tx_hash, tracing_options)
         .await
         .unwrap();
diff --git a/crates/ethrpc/src/alloy/instrumentation.rs b/crates/ethrpc/src/alloy/instrumentation.rs
index d4bd4143b4..02dbfa5eaa 100644
--- a/crates/ethrpc/src/alloy/instrumentation.rs
+++ b/crates/ethrpc/src/alloy/instrumentation.rs
@@ -156,8 +156,8 @@ pub trait ProviderLabelingExt {
 
 impl ProviderLabelingExt for Web3 {
     fn labeled<S: ToString>(&self, label: S) -> Self {
-        let is_local = self.alloy.client().is_local();
-        let transport = self.alloy.client().transport().clone();
+        let is_local = self.provider.client().is_local();
+        let transport = self.provider.client().transport().clone();
         let transport_with_label = LabelingLayer {
             label: label.to_string(),
         }
@@ -171,7 +171,7 @@ impl ProviderLabelingExt for Web3 {
             .erased();
 
         Self {
-            alloy,
+            provider: alloy,
             wallet: self.wallet.clone(),
         }
     }
diff --git a/crates/ethrpc/src/block_stream.rs b/crates/ethrpc/src/block_stream.rs
index eeff615e5d..cd1de4448b 100644
--- a/crates/ethrpc/src/block_stream.rs
+++ b/crates/ethrpc/src/block_stream.rs
@@ -526,7 +526,7 @@ mod tests {
 
         let alloy_provider = Web3::new_from_env();
         let ws_node = std::env::var("NODE_WS_URL").unwrap().parse().unwrap();
-        let receiver = current_block_ws_stream(alloy_provider.alloy, ws_node)
+        let receiver = current_block_ws_stream(alloy_provider.provider, ws_node)
             .await
             .unwrap();
         let mut stream = into_stream(receiver);
@@ -543,13 +543,13 @@ mod tests {
 
         // single block
         let range = RangeInclusive::try_new(5, 5).unwrap();
-        let blocks = web3.alloy.blocks(range).await.unwrap();
+        let blocks = web3.provider.blocks(range).await.unwrap();
         assert_eq!(blocks.len(), 1);
         assert_eq!(blocks.last().unwrap().0, 5);
 
         // multiple blocks
         let range = RangeInclusive::try_new(5, 8).unwrap();
-        let blocks = web3.alloy.blocks(range).await.unwrap();
+        let blocks = web3.provider.blocks(range).await.unwrap();
         assert_eq!(blocks.len(), 4);
         assert_eq!(blocks.last().unwrap().0, 8);
         assert_eq!(blocks.first().unwrap().0, 5);
@@ -562,7 +562,7 @@ mod tests {
             current_block_number,
         )
         .unwrap();
-        let blocks = web3.alloy.blocks(range).await.unwrap();
+        let blocks = web3.provider.blocks(range).await.unwrap();
         assert_eq!(blocks.len(), 6);
         assert_eq!(blocks.last().unwrap().0, 5);
         assert_eq!(blocks.first().unwrap().0, 0);
diff --git a/crates/ethrpc/src/lib.rs b/crates/ethrpc/src/lib.rs
index b84d8a7fb4..c11eac9386 100644
--- a/crates/ethrpc/src/lib.rs
+++ b/crates/ethrpc/src/lib.rs
@@ -17,7 +17,7 @@ pub type AlloyProvider = DynProvider;
 /// having to everything at once.
 #[derive(Debug, Clone)]
 pub struct Web3 {
-    pub alloy: AlloyProvider,
+    pub provider: AlloyProvider,
     pub wallet: MutWallet,
 }
 
@@ -30,7 +30,10 @@ impl Web3 {
 
     pub fn new_from_url(url: &str) -> Self {
         let (alloy, wallet) = crate::alloy::provider(url, Default::default(), None);
-        Self { alloy, wallet }
+        Self {
+            provider: alloy,
+            wallet,
+        }
     }
 }
 
@@ -69,5 +72,8 @@ pub fn web3(args: Config, url: &Url, label: Option<&str>) -> Web3 {
         _ => alloy::provider(url.as_str(), args, label),
     };
 
-    Web3 { alloy, wallet }
+    Web3 {
+        provider: alloy,
+        wallet,
+    }
 }
diff --git a/crates/ethrpc/src/mock.rs b/crates/ethrpc/src/mock.rs
index 2ed9f586cb..53dd3aeb3f 100644
--- a/crates/ethrpc/src/mock.rs
+++ b/crates/ethrpc/src/mock.rs
@@ -11,7 +11,7 @@ impl Web3 {
             // this will not behave like the original mock transport but it's only used
             // in one place so let's keep this for now and fix it when we switch to
             // alloy in the 1 place that uses the mock provider.
-            alloy: ProviderBuilder::new()
+            provider: ProviderBuilder::new()
                 .connect_mocked_client(asserter)
                 .erased(),
             wallet: MutWallet::default(),
@@ -21,7 +21,7 @@ impl Web3 {
 
 pub fn web3() -> Web3 {
     Web3 {
-        alloy: ProviderBuilder::new()
+        provider: ProviderBuilder::new()
             .connect_mocked_client(Asserter::new())
             .erased(),
         wallet: MutWallet::default(),
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 1271d956e6..c17bcc5bfd 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -86,7 +86,7 @@ pub async fn run(args: Arguments) {
         .map(|node_url| shared::ethrpc::web3(&args.shared.ethrpc, node_url, "simulation"));
 
     let chain_id = web3
-        .alloy
+        .provider
         .get_chain_id()
         .await
         .expect("Could not get chainId");
@@ -98,14 +98,14 @@ pub async fn run(args: Arguments) {
     }
 
     let settlement_contract = match args.shared.settlement_contract_address {
-        Some(address) => GPv2Settlement::Instance::new(address, web3.alloy.clone()),
-        None => GPv2Settlement::Instance::deployed(&web3.alloy)
+        Some(address) => GPv2Settlement::Instance::new(address, web3.provider.clone()),
+        None => GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .expect("load settlement contract"),
     };
     let balances_contract = match args.shared.balances_contract_address {
-        Some(address) => Balances::Instance::new(address, web3.alloy.clone()),
-        None => Balances::Instance::deployed(&web3.alloy.clone())
+        Some(address) => Balances::Instance::new(address, web3.provider.clone()),
+        None => Balances::Instance::deployed(&web3.provider.clone())
             .await
             .expect("load balances contract"),
     };
@@ -116,15 +116,15 @@ pub async fn run(args: Arguments) {
         .expect("Couldn't get vault relayer address");
     let signatures_contract = match args.shared.signatures_contract_address {
         Some(address) => {
-            contracts::alloy::support::Signatures::Instance::new(address, web3.alloy.clone())
+            contracts::alloy::support::Signatures::Instance::new(address, web3.provider.clone())
         }
-        None => contracts::alloy::support::Signatures::Instance::deployed(&web3.alloy)
+        None => contracts::alloy::support::Signatures::Instance::deployed(&web3.provider)
             .await
             .expect("load signatures contract"),
     };
     let native_token = match args.shared.native_token_address {
-        Some(address) => WETH9::Instance::new(address, web3.alloy.clone()),
-        None => WETH9::Instance::deployed(&web3.alloy)
+        Some(address) => WETH9::Instance::new(address, web3.provider.clone()),
+        None => WETH9::Instance::deployed(&web3.provider)
             .await
             .expect("load native token contract"),
     };
@@ -156,11 +156,11 @@ pub async fn run(args: Arguments) {
         }
     });
     let vault =
-        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.alloy.clone()));
+        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.provider.clone()));
 
     let hooks_contract = match args.shared.hooks_contract_address {
-        Some(address) => HooksTrampoline::Instance::new(address, web3.alloy.clone()),
-        None => HooksTrampoline::Instance::deployed(&web3.alloy)
+        Some(address) => HooksTrampoline::Instance::new(address, web3.provider.clone()),
+        None => HooksTrampoline::Instance::deployed(&web3.provider)
             .await
             .expect("load hooks trampoline contract"),
     };
@@ -234,7 +234,7 @@ pub async fn run(args: Arguments) {
     allowed_tokens.push(BUY_ETH_ADDRESS);
     let unsupported_tokens = args.unsupported_tokens.clone();
 
-    let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.alloy)
+    let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.provider)
         .await
         .inspect_err(|err| tracing::warn!(%err, "error while fetching IUniswapV3Factory instance"))
         .ok();
@@ -278,7 +278,7 @@ pub async fn run(args: Arguments) {
     let current_block_stream = args
         .shared
         .current_block
-        .stream(args.shared.node_url.clone(), web3.alloy.clone())
+        .stream(args.shared.node_url.clone(), web3.provider.clone())
         .await
         .unwrap();
 
@@ -392,7 +392,7 @@ pub async fn run(args: Arguments) {
     let fast_quoter = create_quoter(fast_price_estimator, QuoteVerificationMode::Unverified);
 
     let app_data_validator = Validator::new(args.app_data_size_limit);
-    let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.alloy)
+    let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.provider)
         .await
         .ok();
     let order_validator = Arc::new(OrderValidator::new(
diff --git a/crates/refunder/src/lib.rs b/crates/refunder/src/lib.rs
index 92815ec760..94b4b9d49a 100644
--- a/crates/refunder/src/lib.rs
+++ b/crates/refunder/src/lib.rs
@@ -71,7 +71,7 @@ pub async fn run(args: arguments::Arguments) {
 
     if let Some(expected_chain_id) = args.chain_id {
         let chain_id = web3
-            .alloy
+            .provider
             .get_chain_id()
             .await
             .expect("Could not get chainId");
diff --git a/crates/refunder/src/refund_service.rs b/crates/refunder/src/refund_service.rs
index ca1e087589..0ef475d1a0 100644
--- a/crates/refunder/src/refund_service.rs
+++ b/crates/refunder/src/refund_service.rs
@@ -247,7 +247,7 @@ impl RefundService<Postgres, AlloyChain, Submitter> {
         let database = Postgres::new(db, lookback_time);
 
         // Chain reader
-        let chain = AlloyChain::new(web3.alloy.clone(), ethflow_addresses);
+        let chain = AlloyChain::new(web3.provider.clone(), ethflow_addresses);
 
         // Signer/wallet configuration
         let signer_address = signer.address();
@@ -255,7 +255,9 @@ impl RefundService<Postgres, AlloyChain, Submitter> {
 
         // Transaction submitter
         let gas_estimator = Box::new(
-            shared::gas_price_estimation::eth_node::NodeGasPriceEstimator::new(web3.alloy.clone()),
+            shared::gas_price_estimation::eth_node::NodeGasPriceEstimator::new(
+                web3.provider.clone(),
+            ),
         );
         let submitter = Submitter {
             web3,
diff --git a/crates/refunder/src/submitter.rs b/crates/refunder/src/submitter.rs
index 6d6075d304..7930af9ba6 100644
--- a/crates/refunder/src/submitter.rs
+++ b/crates/refunder/src/submitter.rs
@@ -63,7 +63,7 @@ impl ChainWrite for Submitter {
             self.nonce_of_last_submission = Some(nonce);
 
             let ethflow_contract =
-                CoWSwapEthFlow::Instance::new(ethflow_contract, self.web3.alloy.clone());
+                CoWSwapEthFlow::Instance::new(ethflow_contract, self.web3.provider.clone());
             let tx_result = ethflow_contract
             .invalidateOrdersIgnoringNotAllowed(encoded_ethflow_orders)
             // Gas conversions are lossy but technically the should not have decimal points even though they're floats
@@ -94,7 +94,7 @@ impl Submitter {
         // this command returns the tx count ever mined at the latest block
         // Mempool tx are not considered.
         self.web3
-            .alloy
+            .provider
             .get_transaction_count(self.signer_address)
             .await
             .with_context(|| {
diff --git a/crates/shared/src/account_balances/simulation.rs b/crates/shared/src/account_balances/simulation.rs
index b497fae6c5..6842373d01 100644
--- a/crates/shared/src/account_balances/simulation.rs
+++ b/crates/shared/src/account_balances/simulation.rs
@@ -79,7 +79,7 @@ impl Balances {
                 std::cmp::min(balance, allowance)
             }
             SellTokenSource::External => {
-                let vault = BalancerV2Vault::new(self.vault(), &self.web3.alloy);
+                let vault = BalancerV2Vault::new(self.vault(), &self.web3.provider);
                 let balance = token.balanceOf(query.owner);
                 let approved = vault.hasApprovedRelayer(query.owner, self.vault_relayer());
                 let allowance = token.allowance(query.owner, self.vault());
@@ -94,7 +94,7 @@ impl Balances {
                 }
             }
             SellTokenSource::Internal => {
-                let vault = BalancerV2Vault::new(self.vault(), &self.web3.alloy);
+                let vault = BalancerV2Vault::new(self.vault(), &self.web3.provider);
                 let balance = vault.getInternalBalance(query.owner, vec![query.token]);
                 let approved = vault.hasApprovedRelayer(query.owner, self.vault_relayer());
                 let (balance, approved) = futures::try_join!(
@@ -120,7 +120,7 @@ impl BalanceFetching for Balances {
             .iter()
             .map(|query| async {
                 if query.interactions.is_empty() {
-                    let token = ERC20::Instance::new(query.token, self.web3.alloy.clone());
+                    let token = ERC20::Instance::new(query.token, self.web3.provider.clone());
                     self.tradable_balance_simple(query, &token).await
                 } else {
                     self.tradable_balance_simulated(query).await
@@ -181,11 +181,11 @@ mod tests {
         let web3 = Web3::new_from_env();
         let settlement = GPv2Settlement::GPv2Settlement::new(
             alloy::primitives::address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
         let balances = contracts::alloy::support::Balances::Instance::new(
             address!("3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
-            web3.alloy.clone(),
+            web3.provider.clone(),
         );
         let balances = Balances::new(
             &web3,
diff --git a/crates/shared/src/bad_token/token_owner_finder/mod.rs b/crates/shared/src/bad_token/token_owner_finder/mod.rs
index e12b41de61..12319b1778 100644
--- a/crates/shared/src/bad_token/token_owner_finder/mod.rs
+++ b/crates/shared/src/bad_token/token_owner_finder/mod.rs
@@ -425,7 +425,7 @@ impl TokenOwnerFinding for TokenOwnerFinder {
         token: Address,
         min_balance: U256,
     ) -> Result<Option<(Address, U256)>> {
-        let instance = ERC20::Instance::new(token, self.web3.alloy.clone());
+        let instance = ERC20::Instance::new(token, self.web3.provider.clone());
 
         // We use a stream with ready_chunks so that we can start with the addresses of
         // fast TokenOwnerFinding implementations first without having to wait
diff --git a/crates/shared/src/bad_token/trace_call.rs b/crates/shared/src/bad_token/trace_call.rs
index d5821b46b5..bc3cf34c41 100644
--- a/crates/shared/src/bad_token/trace_call.rs
+++ b/crates/shared/src/bad_token/trace_call.rs
@@ -550,7 +550,7 @@ mod tests {
         // observe::tracing::initialize("orderbook::bad_token=debug,
         // shared::transport=debug", tracing::level_filters::LevelFilter::OFF);
         let web3 = Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
 
         let base_tokens = &[
             testlib::tokens::WETH,
@@ -723,7 +723,7 @@ mod tests {
         //   the callback that I didn't follow in the SC code.
         // - 0x4f9254c83eb525f9fcf346490bbb3ed28a81c667 Not sure why deny listed.
 
-        let settlement = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let settlement = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let finder = Arc::new(TokenOwnerFinder {
@@ -755,13 +755,13 @@ mod tests {
                     base_tokens: base_tokens.to_vec(),
                 }),
                 Arc::new(BalancerVaultFinder(
-                    BalancerV2Vault::Instance::deployed(&web3.alloy)
+                    BalancerV2Vault::Instance::deployed(&web3.provider)
                         .await
                         .unwrap(),
                 )),
                 Arc::new(
                     UniswapV3Finder::new(
-                        IUniswapV3Factory::Instance::deployed(&web3.alloy)
+                        IUniswapV3Factory::Instance::deployed(&web3.provider)
                             .await
                             .unwrap(),
                         base_tokens.to_vec(),
@@ -800,10 +800,10 @@ mod tests {
         observe::tracing::initialize(&observe::Config::default().with_env_filter("shared=debug"));
         let web3 = Web3::new_from_env();
         let base_tokens = vec![testlib::tokens::WETH];
-        let settlement = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let settlement = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
-        let factory = IUniswapV3Factory::Instance::deployed(&web3.alloy)
+        let factory = IUniswapV3Factory::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let univ3 = Arc::new(
@@ -931,7 +931,7 @@ mod tests {
 
         let web3 = Web3::new_from_env();
 
-        let settlement = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let settlement = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let finder = Arc::new(TokenOwnerFinder {
diff --git a/crates/shared/src/code_fetching.rs b/crates/shared/src/code_fetching.rs
index e2d1f5a0fd..a1e78da06d 100644
--- a/crates/shared/src/code_fetching.rs
+++ b/crates/shared/src/code_fetching.rs
@@ -27,7 +27,7 @@ pub trait CodeFetching: Send + Sync + 'static {
 impl CodeFetching for Web3 {
     #[instrument(skip_all)]
     async fn code(&self, address: Address) -> Result<Bytes> {
-        Ok(self.alloy.get_code_at(address).await?)
+        Ok(self.provider.get_code_at(address).await?)
     }
 
     #[instrument(skip_all)]
diff --git a/crates/shared/src/event_handling.rs b/crates/shared/src/event_handling.rs
index 6adfc60f7c..3c785234ce 100644
--- a/crates/shared/src/event_handling.rs
+++ b/crates/shared/src/event_handling.rs
@@ -840,7 +840,7 @@ mod tests {
     #[ignore]
     async fn past_events_by_block_hashes_test() {
         let web3 = Web3::new_from_env();
-        let contract = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let contract = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let storage = EventStorage { events: vec![] };
@@ -865,7 +865,7 @@ mod tests {
             ),
         ];
         let event_handler =
-            EventHandler::new(Arc::new(web3.alloy.clone()), contract, storage, None);
+            EventHandler::new(Arc::new(web3.provider.clone()), contract, storage, None);
         let (replacement_blocks, _) = event_handler.past_events_by_block_hashes(&blocks).await;
         assert_eq!(replacement_blocks, blocks[..2]);
     }
@@ -874,24 +874,28 @@ mod tests {
     #[ignore]
     async fn update_events_test() {
         let web3 = Web3::new_from_env();
-        let contract = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let contract = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let storage = EventStorage { events: vec![] };
-        let current_block = web3.alloy.get_block_number().await.unwrap();
+        let current_block = web3.provider.get_block_number().await.unwrap();
 
         const NUMBER_OF_BLOCKS: u64 = 300;
 
         //get block in history (current_block - NUMBER_OF_BLOCKS)
         let block = web3
-            .alloy
+            .provider
             .get_block_by_number(current_block.saturating_sub(NUMBER_OF_BLOCKS).into())
             .await
             .unwrap()
             .unwrap();
         let block = (block.number(), block.hash());
-        let mut event_handler =
-            EventHandler::new(Arc::new(web3.alloy.clone()), contract, storage, Some(block));
+        let mut event_handler = EventHandler::new(
+            Arc::new(web3.provider.clone()),
+            contract,
+            storage,
+            Some(block),
+        );
         let _result = event_handler.update_events().await;
         // add logs to event handler and observe
     }
@@ -901,25 +905,29 @@ mod tests {
     async fn multiple_new_blocks_but_no_reorg_test() {
         tracing_subscriber::fmt::init();
         let web3 = Web3::new_from_env();
-        let contract = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let contract = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
         let storage: EventStorage<GPv2Settlement::GPv2Settlement::GPv2SettlementEvents> =
             EventStorage { events: vec![] };
-        let current_block = web3.alloy.get_block_number().await.unwrap();
+        let current_block = web3.provider.get_block_number().await.unwrap();
 
         const NUMBER_OF_BLOCKS: u64 = 300;
 
         //get block in history (current_block - NUMBER_OF_BLOCKS)
         let block = web3
-            .alloy
+            .provider
             .get_block_by_number(current_block.saturating_sub(NUMBER_OF_BLOCKS).into())
             .await
             .unwrap()
             .unwrap();
         let block = (block.number(), block.hash());
-        let mut event_handler =
-            EventHandler::new(Arc::new(web3.alloy.clone()), contract, storage, Some(block));
+        let mut event_handler = EventHandler::new(
+            Arc::new(web3.provider.clone()),
+            contract,
+            storage,
+            Some(block),
+        );
         let _result = event_handler.update_events().await;
         tracing::info!("wait for at least 2 blocks to see if we hit the new code path");
         tokio::time::sleep(tokio::time::Duration::from_millis(26_000)).await;
@@ -930,11 +938,11 @@ mod tests {
     #[ignore]
     async fn optional_block_skipping() {
         let web3 = Web3::new_from_env();
-        let contract = GPv2Settlement::Instance::deployed(&web3.alloy)
+        let contract = GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .unwrap();
 
-        let current_block = web3.alloy.get_block_number().await.unwrap();
+        let current_block = web3.provider.get_block_number().await.unwrap();
         // In this test we query for events multiple times. Newer events might be
         // included each time we query again for the same events, but we want to
         // disregard them.
@@ -956,13 +964,13 @@ mod tests {
 
         let storage_empty = EventStorage { events: vec![] };
         let event_start = block_number_to_block_number_hash(
-            &web3.alloy,
+            &web3.provider,
             BlockNumberOrTag::Number(current_block - RANGE_SIZE),
         )
         .await
         .unwrap();
         let mut base_event_handler = EventHandler::new(
-            Arc::new(web3.alloy.clone()),
+            Arc::new(web3.provider.clone()),
             contract.clone(),
             storage_empty,
             Some(event_start),
@@ -978,13 +986,13 @@ mod tests {
         // date but using `new_skip_blocks_before` if there are no events
         let storage_empty = EventStorage { events: vec![] };
         let event_start = block_number_to_block_number_hash(
-            &web3.alloy,
+            &web3.provider,
             BlockNumberOrTag::Number(current_block - RANGE_SIZE),
         )
         .await
         .unwrap();
         let mut base_block_skip_event_handler = EventHandler::new_skip_blocks_before(
-            Arc::new(web3.alloy.clone()),
+            Arc::new(web3.provider.clone()),
             contract.clone(),
             storage_empty,
             event_start,
@@ -1022,7 +1030,7 @@ mod tests {
             events: vec![last_event.clone()],
         };
         let mut nonempty_event_handler = EventHandler::new_skip_blocks_before(
-            Arc::new(web3.alloy.clone()),
+            Arc::new(web3.provider.clone()),
             contract,
             storage_nonempty,
             // Same event start as for the two previous event handlers. The test checks that this
diff --git a/crates/shared/src/gas_price_estimation/mod.rs b/crates/shared/src/gas_price_estimation/mod.rs
index b7755cc1fd..040eaf41d6 100644
--- a/crates/shared/src/gas_price_estimation/mod.rs
+++ b/crates/shared/src/gas_price_estimation/mod.rs
@@ -76,7 +76,7 @@ pub async fn create_priority_estimator(
     web3: &Web3,
     estimator_types: &[GasEstimatorType],
 ) -> Result<impl GasPriceEstimating + use<>> {
-    let network_id = web3.alloy.get_chain_id().await?.to_string();
+    let network_id = web3.provider.get_chain_id().await?.to_string();
     let mut estimators = Vec::<Box<dyn GasPriceEstimating>>::new();
 
     for estimator_type in estimator_types {
@@ -86,15 +86,15 @@ pub async fn create_priority_estimator(
                 estimators.push(Box::new(DriverGasEstimator::new(
                     http_factory.create(),
                     url.clone(),
-                    web3.alloy.clone(),
+                    web3.provider.clone(),
                 )));
             }
             GasEstimatorType::Web3 => {
-                estimators.push(Box::new(NodeGasPriceEstimator::new(web3.alloy.clone())))
+                estimators.push(Box::new(NodeGasPriceEstimator::new(web3.provider.clone())))
             }
             GasEstimatorType::Alloy => {
                 let estimator = ConfigurableGasPriceEstimator::new(
-                    web3.alloy.clone(),
+                    web3.provider.clone(),
                     EstimatorConfig {
                         past_blocks: default_past_blocks(),
                         reward_percentile: default_reward_percentile(),
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 8460a501b3..1167dd8430 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -1056,7 +1056,7 @@ mod tests {
 
     #[tokio::test]
     async fn pre_validate_err() {
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validity_configuration = OrderValidPeriodConfiguration {
             min: Duration::from_secs(1),
             max_market: Duration::from_secs(100),
@@ -1203,7 +1203,7 @@ mod tests {
     #[tokio::test]
     async fn pre_validate_ok() {
         let native_token =
-            WETH9::Instance::new(Address::repeat_byte(0xef), ethrpc::mock::web3().alloy);
+            WETH9::Instance::new(Address::repeat_byte(0xef), ethrpc::mock::web3().provider);
         let validity_configuration = OrderValidPeriodConfiguration {
             min: Duration::from_secs(1),
             max_market: Duration::from_secs(100),
@@ -1294,7 +1294,7 @@ mod tests {
     #[tokio::test]
     async fn pre_validate_same_tokens_allow_sell() {
         let native_token =
-            WETH9::Instance::new(Address::repeat_byte(0xef), ethrpc::mock::web3().alloy);
+            WETH9::Instance::new(Address::repeat_byte(0xef), ethrpc::mock::web3().provider);
         let validity_configuration = OrderValidPeriodConfiguration {
             min: Duration::from_secs(1),
             max_market: Duration::from_secs(100),
@@ -1402,7 +1402,7 @@ mod tests {
 
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -1614,7 +1614,7 @@ mod tests {
             .expect_count()
             .returning(|_| Ok(MAX_LIMIT_ORDERS_PER_USER));
 
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -1695,7 +1695,7 @@ mod tests {
         limit_order_counter
             .expect_count()
             .returning(|_| Ok(MAX_LIMIT_ORDERS_PER_USER));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -1760,7 +1760,7 @@ mod tests {
             .returning(|_, _| Ok(()));
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -1818,7 +1818,7 @@ mod tests {
             .returning(|_, _| Ok(()));
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -1881,7 +1881,7 @@ mod tests {
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
 
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -1946,7 +1946,7 @@ mod tests {
             .returning(|_, _| Err(TransferSimulationError::InsufficientBalance));
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -2010,7 +2010,7 @@ mod tests {
             .returning(|_| Err(SignatureValidationError::Invalid));
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -2080,7 +2080,8 @@ mod tests {
                 .returning(move |_, _| Err(create_error()));
             let mut limit_order_counter = MockLimitOrderCounting::new();
             limit_order_counter.expect_count().returning(|_| Ok(0u64));
-            let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+            let native_token =
+                WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
             let validator = OrderValidator::new(
                 native_token,
                 Arc::new(order_validation::banned::Users::none()),
@@ -2175,7 +2176,7 @@ mod tests {
             .returning(|_, _| Err(TransferSimulationError::InsufficientBalance));
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         let validator = OrderValidator::new(
             native_token,
             Arc::new(order_validation::banned::Users::none()),
@@ -2586,7 +2587,7 @@ mod tests {
             .expect_validate_signature_and_get_additional_gas()
             .returning(|_| Ok(default_verification_gas_limit()));
         let mut limit_order_counter = MockLimitOrderCounting::new();
-        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().alloy);
+        let native_token = WETH9::Instance::new([0xef; 20].into(), ethrpc::mock::web3().provider);
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
         let validator = OrderValidator::new(
             native_token,
diff --git a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs b/crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs
index 481ccdaae2..909c0ff107 100644
--- a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs
+++ b/crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs
@@ -134,7 +134,7 @@ impl Detector {
 
         let trace = self
             .web3
-            .alloy
+            .provider
             .debug_trace_call(
                 call_request,
                 BlockId::latest(),
@@ -293,7 +293,7 @@ impl Detector {
         let overrides = strategy.state_override(&holder, &test_balance);
 
         // Call balanceOf with the override
-        let token_contract = ERC20::Instance::new(token, self.web3.alloy.clone());
+        let token_contract = ERC20::Instance::new(token, self.web3.provider.clone());
         let balance = token_contract
             .balanceOf(holder)
             .state(overrides)
diff --git a/crates/shared/src/price_estimation/trade_verifier/mod.rs b/crates/shared/src/price_estimation/trade_verifier/mod.rs
index 4f5cee74cc..85b42835f7 100644
--- a/crates/shared/src/price_estimation/trade_verifier/mod.rs
+++ b/crates/shared/src/price_estimation/trade_verifier/mod.rs
@@ -98,7 +98,7 @@ impl TradeVerifier {
         tokens_without_verification: HashSet<Address>,
     ) -> Result<Self> {
         let settlement_contract =
-            GPv2Settlement::GPv2Settlement::new(settlement, web3.alloy.clone());
+            GPv2Settlement::GPv2Settlement::new(settlement, web3.provider.clone());
         let domain_separator =
             DomainSeparator(settlement_contract.domainSeparator().call().await?.0);
         Ok(Self {
@@ -168,7 +168,7 @@ impl TradeVerifier {
         let settle_call = legacy_settlement_to_alloy(settlement).abi_encode();
         let block = *self.block_stream.borrow();
 
-        let solver = Solver::Instance::new(solver_address, self.web3.alloy.clone());
+        let solver = Solver::Instance::new(solver_address, self.web3.provider.clone());
         let swap_simulation = solver.swap(
                 *self.settlement.address(),
                 tokens.clone(),
diff --git a/crates/shared/src/signature_validator/simulation.rs b/crates/shared/src/signature_validator/simulation.rs
index d7d3adfa99..b284464a52 100644
--- a/crates/shared/src/signature_validator/simulation.rs
+++ b/crates/shared/src/signature_validator/simulation.rs
@@ -63,7 +63,7 @@ impl Validator {
         // change), the order's validity can be directly determined by whether
         // the signature matches the expected hash of the order data, checked
         // with isValidSignature method called on the owner's contract
-        let contract = ERC1271SignatureValidator::new(check.signer, &self.web3.alloy);
+        let contract = ERC1271SignatureValidator::new(check.signer, &self.web3.provider);
         let magic_bytes = contract
             .isValidSignature(check.hash.into(), check.signature.clone().into())
             .call()
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs b/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
index 5cb30bfc92..6c99612470 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
+++ b/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
@@ -329,7 +329,7 @@ async fn create_aggregate_pool_fetcher(
     let registered_pools = pool_initializer.initialize_pools().await?;
     let fetched_block_number = registered_pools.fetched_block_number;
     let fetched_block_hash = web3
-        .alloy
+        .provider
         .get_block_by_number(BlockNumberOrTag::Number(fetched_block_number))
         .await?
         .context("failed to get block by block number")?
diff --git a/crates/shared/src/sources/balancer_v2/pools/common.rs b/crates/shared/src/sources/balancer_v2/pools/common.rs
index bd84d77f5f..d1dcae8438 100644
--- a/crates/shared/src/sources/balancer_v2/pools/common.rs
+++ b/crates/shared/src/sources/balancer_v2/pools/common.rs
@@ -872,7 +872,7 @@ mod tests {
         let pool_info_fetcher = PoolInfoFetcher {
             vault: BalancerV2Vault::Instance::new(
                 Address::repeat_byte(0xba),
-                ethrpc::mock::web3().alloy,
+                ethrpc::mock::web3().provider,
             ),
             factory: MockFactoryIndexing::new(),
             token_infos: Arc::new(token_infos),
@@ -898,7 +898,7 @@ mod tests {
         let pool_info_fetcher = PoolInfoFetcher {
             vault: BalancerV2Vault::Instance::new(
                 Address::repeat_byte(0xba),
-                ethrpc::mock::web3().alloy,
+                ethrpc::mock::web3().provider,
             ),
             factory: MockFactoryIndexing::new(),
             token_infos: Arc::new(token_infos),
diff --git a/crates/shared/src/sources/balancer_v2/pools/weighted.rs b/crates/shared/src/sources/balancer_v2/pools/weighted.rs
index 56a7e16734..fc0f6debc5 100644
--- a/crates/shared/src/sources/balancer_v2/pools/weighted.rs
+++ b/crates/shared/src/sources/balancer_v2/pools/weighted.rs
@@ -282,7 +282,7 @@ mod tests {
         let web3 = Web3::with_asserter(asserter);
 
         let factory =
-            BalancerV2WeightedPoolFactory::Instance::new(Address::default(), web3.alloy.clone());
+            BalancerV2WeightedPoolFactory::Instance::new(Address::default(), web3.provider.clone());
         let pool_info = PoolInfo {
             common: common::PoolInfo {
                 id: B256::repeat_byte(0x90),
@@ -300,7 +300,7 @@ mod tests {
         };
 
         let pool_state = {
-            let block = web3.alloy.get_block_number().await.unwrap();
+            let block = web3.provider.get_block_number().await.unwrap();
 
             let pool_state = factory.fetch_pool_state(
                 &pool_info,
diff --git a/crates/shared/src/sources/swapr.rs b/crates/shared/src/sources/swapr.rs
index 045c890aba..d4a3062f97 100644
--- a/crates/shared/src/sources/swapr.rs
+++ b/crates/shared/src/sources/swapr.rs
@@ -26,7 +26,8 @@ impl PoolReading for SwaprPoolReader {
         let fetch_pool = self.0.read_state(pair, block);
 
         async move {
-            let pair_contract = ISwaprPair::Instance::new(pair_address, self.0.web3.alloy.clone());
+            let pair_contract =
+                ISwaprPair::Instance::new(pair_address, self.0.web3.provider.clone());
             let fetch_fee = pair_contract.swapFee().block(block);
 
             let (pool, fee) = futures::join!(fetch_pool, fetch_fee.call().into_future());
@@ -111,7 +112,7 @@ mod tests {
     #[ignore]
     async fn fetch_swapr_pool() {
         let web3 = Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
         let pool_fetcher = uniswap_v2::UniV2BaselineSourceParameters::from_baseline_source(
             BaselineSource::Swapr,
             &version,
diff --git a/crates/shared/src/sources/uniswap_v2/mod.rs b/crates/shared/src/sources/uniswap_v2/mod.rs
index d23a4d1d6f..aee970fc35 100644
--- a/crates/shared/src/sources/uniswap_v2/mod.rs
+++ b/crates/shared/src/sources/uniswap_v2/mod.rs
@@ -105,7 +105,7 @@ impl UniV2BaselineSourceParameters {
     pub async fn into_source(&self, web3: &Web3) -> Result<UniV2BaselineSource> {
         let web3 = web3.labeled("uniswapV2");
         let router =
-            contracts::alloy::IUniswapLikeRouter::Instance::new(self.router, web3.alloy.clone());
+            contracts::alloy::IUniswapLikeRouter::Instance::new(self.router, web3.provider.clone());
         let factory = router.factory().call().await.context("factory")?;
         let pair_provider = pair_provider::PairProvider {
             factory,
@@ -207,7 +207,7 @@ mod tests {
         token1: Address,
         expected_pool_address: Address,
     ) {
-        let version_ = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version_ = web3.provider.get_chain_id().await.unwrap().to_string();
         assert_eq!(version_, version, "wrong node for test");
         let source = UniV2BaselineSourceParameters::from_baseline_source(source, version)
             .unwrap()
@@ -223,7 +223,7 @@ mod tests {
     #[ignore]
     async fn baseline_mainnet() {
         let web3 = ethrpc::Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
         assert_eq!(version, "1", "test must be run with mainnet node");
         let test = |source, token0, token1, expected| {
             test_baseline_source(&web3, "1", source, token0, token1, expected)
@@ -256,7 +256,7 @@ mod tests {
     #[ignore]
     async fn baseline_sepolia() {
         let web3 = ethrpc::Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
         assert_eq!(version, "11155111", "test must be run with mainnet node");
         let test = |source, token0, token1, expected| {
             test_baseline_source(&web3, "11155111", source, token0, token1, expected)
@@ -276,7 +276,7 @@ mod tests {
     #[ignore]
     async fn baseline_xdai() {
         let web3 = ethrpc::Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
         assert_eq!(version, "100", "test must be run with xdai node");
         let test = |source, token0, token1, expected| {
             test_baseline_source(&web3, "100", source, token0, token1, expected)
@@ -305,7 +305,7 @@ mod tests {
     #[ignore]
     async fn fetch_baoswap_pool() {
         let web3 = Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
         let pool_fetcher =
             UniV2BaselineSourceParameters::from_baseline_source(BaselineSource::Baoswap, &version)
                 .unwrap()
@@ -341,7 +341,7 @@ mod tests {
     #[ignore]
     async fn fetch_honeyswap_pool() {
         let web3 = Web3::new_from_env();
-        let version = web3.alloy.get_chain_id().await.unwrap().to_string();
+        let version = web3.provider.get_chain_id().await.unwrap().to_string();
         let pool_fetcher = UniV2BaselineSourceParameters::from_baseline_source(
             BaselineSource::Honeyswap,
             &version,
diff --git a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs b/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
index 85b69d592c..7e322491fe 100644
--- a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
+++ b/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
@@ -274,15 +274,15 @@ impl PoolReading for DefaultPoolReader {
         let pair_address = self.pair_provider.pair_address(&pair);
 
         // Fetch ERC20 token balances of the pools to sanity check with reserves
-        let token0 = ERC20::Instance::new(pair.get().0, self.web3.alloy.clone());
-        let token1 = ERC20::Instance::new(pair.get().1, self.web3.alloy.clone());
+        let token0 = ERC20::Instance::new(pair.get().0, self.web3.provider.clone());
+        let token1 = ERC20::Instance::new(pair.get().1, self.web3.provider.clone());
 
         async move {
             let fetch_token0_balance = token0.balanceOf(pair_address).block(block);
             let fetch_token1_balance = token1.balanceOf(pair_address).block(block);
 
             let pair_contract =
-                IUniswapLikePair::Instance::new(pair_address, self.web3.alloy.clone());
+                IUniswapLikePair::Instance::new(pair_address, self.web3.provider.clone());
             let fetch_reserves = pair_contract.getReserves().block(block);
 
             let (reserves, token0_balance, token1_balance) = futures::join!(
diff --git a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs b/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
index f839e2107a..5047e408db 100644
--- a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
+++ b/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
@@ -302,7 +302,7 @@ impl UniswapV3PoolFetcher {
 
         let events = tokio::sync::Mutex::new(EventHandler::new(
             block_retriever,
-            UniswapV3PoolEventFetcher(web3.alloy),
+            UniswapV3PoolEventFetcher(web3.provider),
             RecentEventsCache::default(),
             Some(init_block),
         ));
diff --git a/crates/shared/src/token_info.rs b/crates/shared/src/token_info.rs
index 844316a5e4..44fc73aa75 100644
--- a/crates/shared/src/token_info.rs
+++ b/crates/shared/src/token_info.rs
@@ -52,7 +52,7 @@ impl TokenInfoFetcher {
             });
         }
 
-        let erc20 = ERC20::Instance::new(address, self.web3.alloy.clone());
+        let erc20 = ERC20::Instance::new(address, self.web3.provider.clone());
         let (decimals, symbol) = {
             let decimals = erc20.decimals();
             let symbol = erc20.symbol();
diff --git a/crates/shared/src/trace_many.rs b/crates/shared/src/trace_many.rs
index 4b6e955a2c..a4033a6799 100644
--- a/crates/shared/src/trace_many.rs
+++ b/crates/shared/src/trace_many.rs
@@ -24,7 +24,7 @@ pub async fn trace_many(
         .zip(std::iter::repeat([TraceType::Trace].as_slice()))
         .collect();
 
-    web3.alloy.trace_call_many(r.as_slice()).latest().await
+    web3.provider.trace_call_many(r.as_slice()).latest().await
 }
 
 /// Check the return value of `trace_many` for whether all top level
diff --git a/crates/solver/src/interactions/allowances.rs b/crates/solver/src/interactions/allowances.rs
index 345e40c047..168210e411 100644
--- a/crates/solver/src/interactions/allowances.rs
+++ b/crates/solver/src/interactions/allowances.rs
@@ -152,7 +152,7 @@ impl AllowanceManaging for AllowanceManager {
         spender: Address,
     ) -> Result<Allowances> {
         Ok(fetch_allowances(
-            self.web3.alloy.clone(),
+            self.web3.provider.clone(),
             self.owner,
             HashMap::from([(spender, tokens)]),
         )
@@ -171,7 +171,7 @@ impl AllowanceManaging for AllowanceManager {
         }
 
         let allowances =
-            fetch_allowances(self.web3.alloy.clone(), self.owner, spender_tokens).await?;
+            fetch_allowances(self.web3.provider.clone(), self.owner, spender_tokens).await?;
         let mut result = Vec::new();
         for request in requests {
             let allowance = allowances
diff --git a/crates/solver/src/interactions/weth.rs b/crates/solver/src/interactions/weth.rs
index 97016384a1..5189bc73fc 100644
--- a/crates/solver/src/interactions/weth.rs
+++ b/crates/solver/src/interactions/weth.rs
@@ -46,7 +46,7 @@ mod tests {
 
     #[test]
     fn encode_unwrap_weth() {
-        let weth = WETH9::Instance::new([0x42; 20].into(), ethrpc::mock::web3().alloy);
+        let weth = WETH9::Instance::new([0x42; 20].into(), ethrpc::mock::web3().provider);
         let amount = U256::from(13_370_000_000_000_000_000u128);
         let interaction = UnwrapWethInteraction {
             weth: weth.clone(),
@@ -66,11 +66,11 @@ mod tests {
     #[test]
     fn merge_same_native_token() {
         let mut unwrap0 = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::ONE,
         };
         let unwrap1 = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::from(2),
         };
 
@@ -81,11 +81,11 @@ mod tests {
     #[test]
     fn merge_different_native_token() {
         let mut unwrap0 = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::ONE,
         };
         let unwrap1 = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x02; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x02; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::from(2),
         };
 
@@ -97,11 +97,11 @@ mod tests {
     #[should_panic]
     fn merge_u256_overflow() {
         let mut unwrap0 = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::ONE,
         };
         let unwrap1 = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::MAX,
         };
 
diff --git a/crates/solver/src/liquidity/balancer_v2.rs b/crates/solver/src/liquidity/balancer_v2.rs
index 3892b12b77..9ce7a836de 100644
--- a/crates/solver/src/liquidity/balancer_v2.rs
+++ b/crates/solver/src/liquidity/balancer_v2.rs
@@ -255,7 +255,7 @@ mod tests {
     fn dummy_contracts() -> (Address, BalancerV2Vault::Instance) {
         (
             Address::from_slice(&[0xc0; 20]),
-            BalancerV2Vault::Instance::new([0xc1; 20].into(), ethrpc::mock::web3().alloy),
+            BalancerV2Vault::Instance::new([0xc1; 20].into(), ethrpc::mock::web3().provider),
         )
     }
 
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index d31d4adb83..503be0c60f 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -383,7 +383,7 @@ pub mod tests {
         let sell_token = Address::with_last_byte(1);
         let zeroex = Arc::new(IZeroex::Instance::new(
             Default::default(),
-            ethrpc::mock::web3().alloy,
+            ethrpc::mock::web3().provider,
         ));
         let allowances =
             Allowances::new(*zeroex.address(), hashmap! { sell_token => U256::from(99) });
@@ -429,7 +429,7 @@ pub mod tests {
         let sell_token = Address::with_last_byte(1);
         let zeroex = Arc::new(IZeroex::Instance::new(
             Default::default(),
-            ethrpc::mock::web3().alloy,
+            ethrpc::mock::web3().provider,
         ));
         let allowances = Allowances::new(
             *zeroex.address(),
diff --git a/crates/solver/src/settlement/settlement_encoder.rs b/crates/solver/src/settlement/settlement_encoder.rs
index e9f17a2c83..d3aee36909 100644
--- a/crates/solver/src/settlement/settlement_encoder.rs
+++ b/crates/solver/src/settlement/settlement_encoder.rs
@@ -627,7 +627,7 @@ pub mod tests {
 
     #[test]
     fn settlement_merges_unwraps_for_same_token() {
-        let weth = WETH9::Instance::new([0x42; 20].into(), ethrpc::mock::web3().alloy);
+        let weth = WETH9::Instance::new([0x42; 20].into(), ethrpc::mock::web3().provider);
 
         let mut encoder = SettlementEncoder::new(HashMap::new());
         encoder.add_unwrap(UnwrapWethInteraction {
@@ -757,11 +757,11 @@ pub mod tests {
     fn settlement_encoder_appends_unwraps_for_different_tokens() {
         let mut encoder = SettlementEncoder::new(HashMap::new());
         encoder.add_unwrap(UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::ONE,
         });
         encoder.add_unwrap(UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x02; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x02; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::from(2),
         });
 
@@ -786,7 +786,7 @@ pub mod tests {
             alloy::primitives::Bytes::default(),
         );
         let unwrap = UnwrapWethInteraction {
-            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().alloy),
+            weth: WETH9::Instance::new([0x01; 20].into(), ethrpc::mock::web3().provider),
             amount: U256::ONE,
         };
 
@@ -966,7 +966,7 @@ pub mod tests {
             .add_trade(order_1_3, U256::from(11), U256::ZERO)
             .unwrap();
 
-        let weth = WETH9::Instance::new(Address::with_last_byte(2), ethrpc::mock::web3().alloy);
+        let weth = WETH9::Instance::new(Address::with_last_byte(2), ethrpc::mock::web3().provider);
         encoder.add_unwrap(UnwrapWethInteraction {
             weth,
             amount: U256::from(12),
diff --git a/crates/solvers/src/domain/solver.rs b/crates/solvers/src/domain/solver.rs
index ac1463eaab..80c4ff52f6 100644
--- a/crates/solvers/src/domain/solver.rs
+++ b/crates/solvers/src/domain/solver.rs
@@ -80,7 +80,7 @@ impl Solver {
         let uni_v3_quoter_v2 = match config.uni_v3_node_url {
             Some(url) => {
                 let web3 = ethrpc::web3(Default::default(), &url, Some("baseline"));
-                contracts::alloy::UniswapV3QuoterV2::Instance::deployed(&web3.alloy)
+                contracts::alloy::UniswapV3QuoterV2::Instance::deployed(&web3.provider)
                     .await
                     .map(Arc::new)
                     .inspect_err(|err| {

From fde29a405f35039195347696979e89490b81607b Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Wed, 4 Feb 2026 09:48:14 +0100
Subject: [PATCH 034/219] Log tracing spans in JSON logger (#4117)

# Description
In order to reduce load on the logging infra we want to switch to
structured logging (JSON). However, when we tested the current setup we
realized that the `request_id` (among other things) was not logged which
made debugging things basically impossible.

# Changes
Adjusted the custom JSON formatter to iterate over parent spans and
serialize their names and associated fields.
Conceptually the current logic is slightly awkward as the field
formatter formats the fields to JSON and later when we format the whole
log line we re-parse the formatted string to JSON and the serialize it
again. But unless this is actually causing issues when it's deployed
I'll not address in order to unblock structured logging ASAP.

## How to test
Manual tests (spans are at the end)
original version:
```
{
    "timestamp":"2026-02-03T09:51:18.773085+00:00",
    "level":"INFO",
    "fields":{
        "message":"- \"GET /api/v1/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/native_price HTTP/1.1\" 404 \"-\" \"curl/8.7.1\" 5.229292ms",
        "log.target":"orderbook::api::request_summary",
        "log.module_path":"warp::filters::log",
        "log.file":"/Users/martin/.cargo/git/checkouts/warp-ee983b87d3028bb6/586244e/src/filters/log.rs",
        "log.line":37
    },
    "target":"log",
    "trace_id":"4aaa6c6e6e56f103d5cf975005c15d85"
```

default JSON logger:
```
{
    "timestamp":"2026-02-03T09:40:00.265994Z",
    "level":"INFO",
    "fields":{
        "message":"- \"GET /api/v1/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/native_price HTTP/1.1\" 404 \"-\" \"curl/8.7.1\" 2.721875ms",
        "log.target":"orderbook::api::request_summary",
        "log.module_path":"warp::filters::log",
        "log.file":"/Users/martin/.cargo/git/checkouts/warp-ee983b87d3028bb6/586244e/src/filters/log.rs",
        "log.line":37
    },
    "target":"orderbook::api::request_summary",
    "span":{
        "request_id":"6",
        "name":"http_request"
    },
    "spans":[
        {
            "request_id":"6",
            "name":"http_request"
        }
    ]
}
```

new version:
```
{
    "timestamp":"2026-02-03T09:41:25.529338+00:00",
    "level":"INFO",
    "fields":{
        "message":"- \"GET /api/v1/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/native_price HTTP/1.1\" 404 \"-\" \"curl/8.7.1\" 6.522583ms",
        "log.target":"orderbook::api::request_summary",
        "log.module_path":"warp::filters::log",
        "log.file":"/Users/martin/.cargo/git/checkouts/warp-ee983b87d3028bb6/586244e/src/filters/log.rs",
        "log.line":37
    },
    "target":"log",
    "trace_id":"cd6bf89be55582b19fd046b7c111f2b1",
    "spans":{
        "http_request":{
             "request_id":"0"
         }
     }
}
```
---
 .../distributed_tracing/trace_id_format.rs    | 55 ++++++++++++++++++-
 crates/observe/src/tracing.rs                 |  2 +
 2 files changed, 54 insertions(+), 3 deletions(-)

diff --git a/crates/observe/src/distributed_tracing/trace_id_format.rs b/crates/observe/src/distributed_tracing/trace_id_format.rs
index dc2766a31d..7bc18b910c 100644
--- a/crates/observe/src/distributed_tracing/trace_id_format.rs
+++ b/crates/observe/src/distributed_tracing/trace_id_format.rs
@@ -2,7 +2,11 @@ use {
     chrono::Utc,
     opentelemetry::trace::{TraceContextExt, TraceId},
     serde::ser::{SerializeMap, Serializer as _},
-    std::{fmt, io},
+    std::{
+        collections::{HashMap, hash_map::Entry},
+        fmt,
+        io,
+    },
     tracing::{Event, Span, Subscriber},
     tracing_opentelemetry::OpenTelemetrySpanExt,
     tracing_serde::{AsSerde, fields::AsMap},
@@ -11,6 +15,7 @@ use {
             FmtContext,
             FormatEvent,
             FormatFields,
+            FormattedFields,
             format::{Format, Full, Writer},
             time::FormatTime,
         },
@@ -40,7 +45,13 @@ use {
 ///     "status": 200
 ///   },
 ///   "target": "warp::filters::trace",
-///   "trace_id": "4bf92f3577b34da6a3ce929d0e0e4736"
+///   "trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
+///   "spans": {
+///     "spanName1": {
+///       "field1": 123,
+///       "field2": "abc"
+///     }
+///   }
 /// }
 /// ```
 pub struct TraceIdJsonFormat;
@@ -52,7 +63,7 @@ where
 {
     fn format_event(
         &self,
-        _ctx: &FmtContext<'_, S, N>,
+        ctx: &FmtContext<'_, S, N>,
         mut writer: Writer<'_>,
         event: &Event<'_>,
     ) -> std::fmt::Result
@@ -79,6 +90,44 @@ where
                 serializer.serialize_entry("trace_id", &trace_id.to_string())?;
             }
 
+            // serialize all parent span names and their fields
+            if let Some(scope) = ctx.event_scope() {
+                let mut parent_spans = HashMap::<String, serde_json::Value>::new();
+
+                for span in scope.from_root() {
+                    let current_span_fields: serde_json::Map<String, serde_json::Value> = span
+                        .extensions()
+                        .get::<FormattedFields<N>>()
+                        .and_then(|fields| serde_json::from_str(fields.as_str()).ok())
+                        .unwrap_or_default();
+
+                    match parent_spans.entry(span.name().to_string()) {
+                        Entry::Vacant(entry) => {
+                            entry.insert(serde_json::Value::Object(current_span_fields));
+                        }
+                        Entry::Occupied(mut entry) => {
+                            // the desired format does not preserve the hierarchy of spans
+                            // so theoretically there could be nested spans with the same
+                            // name so we merge the fields of all spans with the same name
+                            //
+                            // if there are duplicated fields the value of the span closest
+                            // to the processed event wins
+                            //
+                            // also theoretically we could detect fields getting overwritten
+                            // but we couldn't log that without causing a stack overflow so we
+                            // don't
+                            entry
+                                .get_mut()
+                                .as_object_mut()
+                                .expect("fields get initialized with an object")
+                                .extend(current_span_fields.into_iter())
+                        }
+                    }
+                }
+
+                serializer.serialize_entry("spans", &parent_spans)?;
+            }
+
             serializer.end()
         };
 
diff --git a/crates/observe/src/tracing.rs b/crates/observe/src/tracing.rs
index 76b01e2196..7b827424aa 100644
--- a/crates/observe/src/tracing.rs
+++ b/crates/observe/src/tracing.rs
@@ -79,6 +79,8 @@ fn set_tracing_subscriber(config: &Config) {
             if config.use_json_format {
                 // structured logging
                 tracing_subscriber::fmt::layer()
+                    .with_ansi(false)
+                    .fmt_fields(tracing_subscriber::fmt::format::JsonFields::default())
                     .event_format(TraceIdJsonFormat)
                     .with_writer(writer)
                     .with_filter($env_filter)

From bc2788e2960fa168b579901d727d6b81f41a36db Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 5 Feb 2026 14:26:41 +0100
Subject: [PATCH 035/219] Initial Claude setup (#4122)

# Description

Add instructions for Claude to work more efficiently.

Expect .env.claude with secrets filled in. Contact me.

None of this was written by hand. To put together the order debugging
document I took transcripts of both Felix's talks on the topic and our
internal docs and threw it at Claude. Then I tried it for an order and
made some edits.

# Changes

- [x] Sets up MCP servers for main DB and analytics DB
- [x] Sets up MPC for fetch
- [x] Add CLAUDE.md instructing Claude about the project and coding
practices (formatting, style, etc.)
- [x] Adds a document telling Claude how to debug orders so it knows
what to do next time you ask him "y order {uid} not filled"
- [x] Added a comman so you can run `/debug-order
0xd997dc715a7610c75e5f97548685befacb7ea5ad878cb4bac1816903514ed84d1dffc418c0d83bd8b98ab3d2e07b83bf5439f4236981a392`
within Claude Code


## How to test

Ask Claude Coe to do stuff for you.

<!--
## Related Issues

Fixes #
-->
---
 .claude/commands/debug-order.md |  18 +
 .gitignore                      |   1 +
 .mcp.json                       |  25 ++
 CLAUDE.md                       | 167 ++++++++
 docs/COW_ORDER_DEBUG_SKILL.md   | 651 ++++++++++++++++++++++++++++++++
 5 files changed, 862 insertions(+)
 create mode 100644 .claude/commands/debug-order.md
 create mode 100644 .mcp.json
 create mode 100644 CLAUDE.md
 create mode 100644 docs/COW_ORDER_DEBUG_SKILL.md

diff --git a/.claude/commands/debug-order.md b/.claude/commands/debug-order.md
new file mode 100644
index 0000000000..92708aadc9
--- /dev/null
+++ b/.claude/commands/debug-order.md
@@ -0,0 +1,18 @@
+---
+description: Debug why a CoW Protocol order failed to match
+---
+
+Debug order: $ARGUMENTS
+
+Read and follow the instructions in ./docs/COW_ORDER_DEBUG_SKILL.md to investigate this order.
+
+Key steps:
+1. Parse the order UID and network from arguments (default: mainnet)
+2. Fetch order data from API to get status and details
+3. Check order_events in DB for lifecycle events
+4. Search Victoria Logs for the order UID
+   - For finding discarded solutions where the order UID appears in calldata, use regex: `.*ORDER_UID_WITHOUT_0X.*` plus `discarded`
+5. Identify root cause and report findings with evidence
+6. If you haven't found anything go wild and try all SQL / log searches / codebase searches you can think of
+
+Always show your evidence (log lines, DB results, API responses) when presenting findings.
diff --git a/.gitignore b/.gitignore
index 5ff5e4c1e7..b86a4933ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@
 /.idea
 **/testing.*.toml
 /playground/.env
+.env.claude
diff --git a/.mcp.json b/.mcp.json
new file mode 100644
index 0000000000..609c8b46d2
--- /dev/null
+++ b/.mcp.json
@@ -0,0 +1,25 @@
+{
+  "mcpServers": {
+    "postgres-protocol": {
+      "command": "/bin/bash",
+      "args": [
+        "-c",
+        "set -a && source .env.claude && set +a && npx -y @modelcontextprotocol/server-postgres \"${COW_DB_URL}\""
+      ]
+    },
+    "postgres-analytics": {
+      "command": "/bin/bash",
+      "args": [
+        "-c",
+        "set -a && source .env.claude && set +a && npx -y @modelcontextprotocol/server-postgres \"${COW_ANALYTICS_DB_URL}\""
+      ]
+    },
+    "fetch": {
+      "command": "/bin/bash",
+      "args": [
+        "-c",
+        "set -a && source .env.claude && set +a && /opt/homebrew/bin/uvx mcp-server-fetch"
+      ]
+    }
+  }
+}
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000..c8b776a3dd
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,167 @@
+# Cow Protocol Services
+
+Backend services for Cow Protocol, a decentralized trading protocol with batch auctions on EVM networks.
+
+## Project Structure
+
+This is a Rust workspace containing multiple services and libraries:
+
+### Main Services (Binaries)
+- **orderbook** - HTTP API for order submission and queries
+- **autopilot** - Protocol driver that manages auctions
+- **driver** - Handles liquidity collection and solution selection
+- **solvers** - Internal solver engine (baseline)
+- **refunder** - Handles refunds
+
+### Key Libraries
+- **shared** - Common functionality (pricing, liquidity, gas estimation)
+- **database** - PostgreSQL abstraction and migrations
+- **model** - Serialization models for API
+- **contracts** - Smart contract bindings
+
+## Architecture Overview
+
+```
+User signs order → Orderbook validates → Autopilot includes in auction
+                                              ↓
+                    ┌─────────────────────────┴─────────────────────────┐
+                    ↓                                                   ↓
+          Colocated External Solvers                    Our Drivers + Non-Colocated Solvers
+          (run their own driver+solver)                      ↓                    ↓
+                    │                                 Our solvers          External solver APIs
+                    │                                 (baseline,           (non-colocated partners
+                    │                                  balancer, ...)       like 1inch, 0x, etc)
+                    └─────────────────────────┬─────────────────────────┘
+                                              ↓
+                              Autopilot ranks solutions, picks winner(s)
+                                              ↓
+                              Winning driver submits to chain (2-3 block window)
+                                              ↓
+                              Settlement contract executes:
+                              1. Pre-interactions (incl user pre-hooks)
+                              2. Transfer sell tokens in
+                              3. Main interactions (swaps/routing)
+                              4. Pay out buy tokens
+                              5. Post-interactions (incl user post-hooks)
+                                              ↓
+                              Circuit breaker monitors compliance
+```
+
+**Solver types:**
+- **Colocated**: External partners run their own driver + solver. Full control, full responsibility.
+- **Non-colocated**: We run the driver, configured with their solver API endpoint. We handle simulation/submission.
+
+**Key components:**
+- **Orderbook**: Validates + stores orders, handles quoting
+- **Autopilot**: Central auctioneer, runs every ~12-15s (eventually every block), filters orders, adds fee policies, sends auction to solvers, ranks solutions
+- **Driver**: Fetches liquidity, encodes solutions to calldata, simulates, submits to chain. Handles everything except route-finding.
+- **Solver Engine**: Pure math — finds best routes/matches. Can be internal (baseline, balancer) or external API calls.
+- **Circuit Breaker**: Monitors on-chain settlements match off-chain auction outcomes. Jails misbehaving solvers.
+
+## Technology Stack
+
+- **Language**: Rust 2021+ Edition
+- **Runtime**: Tokio async
+- **Database**: PostgreSQL with sqlx
+- **Web3**: Alloy
+- **HTTP**: Axum
+
+## Documentation
+
+- **Protocol Documentation**: https://docs.cow.fi/
+  - Technical Reference: API specs and SDK docs
+  - Concepts: Protocol fundamentals and architecture
+
+## Testing
+
+- Use `just` commands for running tests (see Justfile)
+- E2E tests available in `crates/e2e`
+- Local development environment in `playground/`
+
+## Directory Structure
+
+```
+crates/         # 25+ Rust crates (binaries + libraries)
+database/       # PostgreSQL migrations and schemas
+playground/     # Local dev environment
+configs/        # Configuration files
+```
+
+# General Coding Instructions
+
+If there is a test you can run then run it or `cargo check` or `cargo build`; run it after you have made changes.
+Use rust-analyzer MCP when appropriate such as finding usages or renaming. After a change run "cargo +nightly fmt".
+
+## Code Style
+
+Instead of using full paths like `volume_fee_bucket_overrides: Vec<shared::arguments::TokenBucketFeeOverride>`, import the type at the beginning so you don't have to use the full path later.
+
+Don't add a lot of comments. Add comments only if the code is a bit weird or the concept is not clear.
+
+## CoW Protocol Database Access
+
+**Always show the SQL query before executing it** against postgres MCP tools (`mcp__postgres-protocol__query`, `mcp__postgres-analytics__query`).
+
+**Query timeout**: MCP servers are configured with a 120 second timeout. For potentially long-running queries, prefix with `SET statement_timeout = '30s';` (or appropriate duration) to fail fast:
+```sql
+SET statement_timeout = '30s';
+SELECT ... FROM large_table ...;
+```
+If a query times out, try a different approach (add more filters, use a smaller time range, simplify aggregations, or break into smaller queries).
+
+Read-only replica available via MCP. If that fails for some reason, then you can use psql with:
+```bash
+source .env.claude && PGPASSWORD="$COW_DB_PASSWORD" psql \
+  -h "$COW_DB_HOST" -p "$COW_DB_PORT" -U "$COW_DB_USER" -d <database> -c "<query>"
+```
+but use MCP where possible.
+
+Databases: `mainnet`, `arbitrum-one`, `base`, `linea`, `polygon`, `xdai`, `sepolia`, `plasma`, `ink`, `bnb` etc.
+
+## RPC Node
+
+Use `$ETH_MAINNET_RPC` from `.env.claude` for mainnet. Use `cast` or whatever tools you want freely.
+
+## Grafana Logs Access
+
+Query logs via the Grafana API (credentials in `.env.claude`):
+
+```bash
+source .env.claude && curl -s -H "Authorization: Bearer $GRAFANA_API_TOKEN" \
+  "$GRAFANA_URL/api/ds/query" \
+  -X POST -H "Content-Type: application/json" \
+  -d '{
+    "queries": [{
+      "refId": "A",
+      "datasource": {"type": "victoriametrics-logs-datasource", "uid": "'"$VICTORIA_LOGS_DATASOURCE_UID"'"},
+      "expr": "<search_term>",
+      "queryType": "instant"
+    }],
+    "from": "now-1h",
+    "to": "now"
+  }'
+```
+Adjust expr for search terms (e.g., plasma, ink, error)
+Adjust from/to for time range (e.g., now-15m, now-24h)
+Parse log lines with: | jq -r '.results.A.frames[0].data.values[1][]'
+
+## Etherscan API (V2)
+
+Use MCP `mcp__fetch__fetch` tool. API Key in `.env.claude` as `$ETHERSCAN_API_KEY`.
+
+**Important**: V1 API is deprecated. Use V2 with the `chainid` parameter:
+- Mainnet: `chainid=1`
+- Arbitrum: `chainid=42161`
+- Base: `chainid=8453`
+
+Example URL format:
+```
+https://api.etherscan.io/v2/api?chainid=1&module=account&action=balance&address=<addr>&tag=latest&apikey=<key>
+```
+
+Read the API key from `.env.claude` and use it directly in the URL (MCP fetch doesn't do shell variable substitution).
+
+## Investigating orders
+
+When asked to look into what happened to an order read file ./docs/COW_ORDER_DEBUG_SKILL.md and follow the instructions there.
+Make heavy use of logs and DB to find all info you need and present finding to the user with evidence.
diff --git a/docs/COW_ORDER_DEBUG_SKILL.md b/docs/COW_ORDER_DEBUG_SKILL.md
new file mode 100644
index 0000000000..02020253ff
--- /dev/null
+++ b/docs/COW_ORDER_DEBUG_SKILL.md
@@ -0,0 +1,651 @@
+# CoW Protocol Order Debug Skill
+
+Debug why CoW Protocol orders fail to match. Requires DB access + Victoria Logs access (via Grafana).
+
+## Quick Checklist
+
+Run through these in order:
+
+1. [ ] **Order status** — Check API status first (cancelled/expired/fulfilled/open)
+2. [ ] **User cancellation** — If cancelled, search logs for `order cancelled ORDER_UID` FIRST
+3. [ ] **Order in auction** — Was order in autopilot auction? When?
+4. [ ] **Solver bids** — Did any solver bid? What happened to their solution?
+5. [ ] **Settlement outcome** — Did settlement succeed/fail/timeout?
+6. [ ] **Limit price sanity** — Was quote reasonable? Check slippage, fees, gas
+7. [ ] **Price movement** — Did price move between quote and expiry?
+
+---
+
+## 1. Fetch Order Data
+
+```bash
+# Replace $NETWORK (mainnet/gnosis/arbitrum) and $ORDER_UID
+curl -s "https://api.cow.fi/$NETWORK/api/v1/orders/$ORDER_UID" | jq .
+
+# For staging orders:
+curl -s "https://barn.api.cow.fi/$NETWORK/api/v1/orders/$ORDER_UID" | jq .
+```
+
+### GPV2Order Struct (Smart Contract Source of Truth)
+
+| Field | Meaning | Debug Notes |
+|-------|---------|-------------|
+| `sellToken` | Token being sold | |
+| `buyToken` | Token being bought | |
+| `sellAmount` | Amount to sell (wei) | For sell orders, this is exact |
+| `buyAmount` | Min amount to receive | For buy orders, this is exact |
+| `validTo` | Unix timestamp expiry | Check if expired |
+| `appData` | Hash of metadata JSON | Contains hooks, partner fees, flash loan hints |
+| `feeAmount` | **Legacy, always 0** | Fee now in limit price |
+| `kind` | "sell" or "buy" | |
+| `partiallyFillable` | bool | Swaps = false (fill-or-kill), limits can be true |
+| `sellTokenBalance` | **Legacy, always "erc20"** | Balancer vault balances never took off |
+| `buyTokenBalance` | **Legacy, always "erc20"** | |
+| `signingScheme` | eip712/ethsign/presign/eip1271 | See signing section |
+| `signature` | The actual signature bytes | |
+| `receiver` | Who gets buy tokens | null = order owner |
+
+**Additional API fields:**
+- `class`: "market" vs "limit" — see note below
+- `status`: fulfilled/open/cancelled/expired
+- `surplusFee`: Protocol's fee estimate for limit orders
+- `surplusFeeTimestamp`: Must be <10 min old or order won't enter auction
+
+**Note on order class:** In the DB, almost every order is stored as `class = 'limit'`. The "market" vs "limit" distinction is about **fee policy**, not order type:
+- **Market order**: Had a quote attached, and the order's limit price is within that quote (in-market). Gets market fee policy.
+- **Limit order**: Either no quote, or limit price is outside the quote (out-of-market). Gets limit fee policy with surplus fee.
+
+The `appData.metadata.orderClass` field shows what the UI intended, but the actual classification is determined by comparing the order's price to the quote at placement time.
+
+---
+
+## 2. Signing Schemes
+
+Orders can fail if signature validation fails. Different schemes have different failure modes:
+
+| Scheme | Type | Validation | Common Failures |
+|--------|------|------------|-----------------|
+| `eip712` | EOA | Static, checked once | Sig doesn't match order fields, or signed by unexpected user |
+| `ethsign` | EOA (legacy) | Static, checked once | Same as above |
+
+**Note on unexpected signers:** The majority of signature issues are valid signatures but signed by an unexpected user. This causes the settlement contract to attempt transferring tokens from an account that doesn't have the necessary balance.
+| `presign` | Smart contract | On-chain state (`setPreSignature`) | User called `setPreSignature(uid, false)` to cancel |
+| `eip1271` | Smart contract | Calls `isValidSignature()` at settlement time | Contract state changed, Safe signer removed, custom logic rejects |
+
+**EIP-1271 is dynamic** — signature can be valid at order placement but invalid later. Autopilot re-checks these every auction.
+
+```bash
+# Check if presign is set (returns signed boolean)
+cast call $SETTLEMENT_CONTRACT "preSignature(bytes)" $ORDER_UID --rpc-url $RPC
+```
+
+---
+
+## 3. Check Logs (Victoria Logs via Grafana)
+
+Logs are stored in Victoria Logs and accessible via Grafana API.
+
+**Query template (bash):**
+```bash
+# Set time range (milliseconds)
+NOW_MS=$(($(date +%s) * 1000))
+FROM_MS=$((NOW_MS - 43200000))  # 12 hours ago
+
+# Set search term (use full order UID with 0x prefix)
+SEARCH_TERM="0xd997dc715a7610c75e5f97548685befacb7ea5ad878cb4bac1816903514ed84d1dffc418c0d83bd8b98ab3d2e07b83bf5439f4236981a392"
+
+# Query Victoria Logs
+# - NOT container:controller excludes nginx access logs
+# - network:$NETWORK filters to specific chain (mainnet, bnb, arbitrum-one, base, etc)
+source .env.claude
+curl -s "${GRAFANA_URL}/api/ds/query?ds_type=victoriametrics-logs-datasource" \
+  -H 'accept: application/json' \
+  -H 'content-type: application/json' \
+  -H "x-datasource-uid: ${VICTORIA_LOGS_DATASOURCE_UID}" \
+  -H 'x-plugin-id: victoriametrics-logs-datasource' \
+  -H "Authorization: Bearer ${GRAFANA_API_TOKEN}" \
+  --data-raw "{\"queries\":[{\"refId\":\"A\",\"datasource\":{\"type\":\"victoriametrics-logs-datasource\",\"uid\":\"${VICTORIA_LOGS_DATASOURCE_UID}\"},\"editorMode\":\"code\",\"expr\":\"NOT container:controller ${SEARCH_TERM} | sort by (_time) asc\",\"queryType\":\"instant\",\"maxLines\":100}],\"from\":\"${FROM_MS}\",\"to\":\"${NOW_MS}\"}" \
+  | jq -r '.results.A.frames[0].data.values[1][]'
+```
+
+**Key query parameters:**
+- `expr`: Search term (just text, e.g., order UID or auction ID). Add `| sort by (_time) asc` for chronological order
+- `queryType`: Use `"instant"` to get log lines. Use `"hits"` to get histogram/counts
+- `maxLines`: Number of log lines to return
+- `from`/`to`: Millisecond timestamps
+
+**Example searches:**
+```bash
+# Search by order UID for a specific network, excluding nginx
+"expr": "NOT container:controller network:bnb ORDER_UID | sort by (_time) asc"
+
+# Search by auction ID
+"expr": "NOT container:controller 22788649 | sort by (_time) asc"
+
+# Search by solver name + auction
+"expr": "NOT container:controller baseline 22788649 | sort by (_time) asc"
+
+# Filter by log content on specific network
+"expr": "NOT container:controller network:mainnet order cancelled | sort by (_time) asc"
+
+# Search by request_id to trace quote→bid issues (useful when order was placed with quote from solver X but that solver never bid)
+"expr": "NOT container:controller $REQUEST_ID | sort by (_time) asc"
+```
+
+**Useful filters:**
+- `NOT container:controller` — excludes nginx access logs (REQUIRED for order UID searches)
+- `network:$NETWORK` — filter by chain (works for some log sources, not all)
+
+**Note:** Victoria Logs uses simple text matching. Always use the **full order UID with 0x prefix** for reliable matching.
+
+**IMPORTANT - Run targeted lifecycle queries:** Always use `NOT container:controller` to exclude nginx:
+
+```bash
+# Run these queries IN PARALLEL to quickly find all lifecycle events (use FULL order UID with 0x):
+"expr": "NOT container:controller order created ORDER_UID | sort by (_time) asc"
+"expr": "NOT container:controller order cancelled ORDER_UID | sort by (_time) asc"
+"expr": "NOT container:controller proposed solution ORDER_UID | sort by (_time) asc"
+"expr": "NOT container:controller settlement failed ORDER_UID | sort by (_time) asc"
+"expr": "NOT container:controller filtered ORDER_UID | sort by (_time) asc"
+
+# Find discarded solutions where order appears in calldata (use regex with order UID bytes without 0x prefix)
+"expr": "discarded .*ORDER_UID_WITHOUT_0X.* | sort by (_time) asc"
+```
+
+**What to look for:**
+- `order created` — order placement with quote_id
+- `New orders in auction` — order entered auction
+- `computed solutions` — solver found a route
+- `solved auction` — solver submitted winning bid
+- `filtered out in-flight` — order being settled
+- `order cancelled` — user cancelled via API
+
+**Get auction competition data:**
+```bash
+curl -s "https://api.cow.fi/$NETWORK/api/v1/solver_competition/$AUCTION_ID" | jq .
+```
+
+---
+
+## 4. Common Log Patterns
+
+**IMPORTANT:** Many log messages use **spaces** not underscores (e.g., `order cancelled` not `order_cancelled`).
+
+**Order lifecycle (search by order UID):**
+```
+orderbook::api::post_order: order created           # Order placed
+autopilot::run_loop::observe: New orders in auction # Added to auction
+driver::infra::observe: computed solutions          # Solver found route
+driver::infra::observe: solved auction              # Solver won
+autopilot::run_loop: filtered out in-flight         # Being settled
+autopilot::run_loop: settlement failed              # Settlement failed (check err=)
+orderbook::orderbook: order cancelled               # User cancelled via API
+```
+
+**Issues to watch for:**
+- `order cancelled` — user cancelled the order (check timestamp vs settlement!)
+- `settlement failed err=Timeout` — driver timed out during settlement
+- `settlement failed` — settlement failed (other reasons)
+- `filtered` — order excluded from auction (check reason)
+- `error` or `Error` — something went wrong
+- `revert` — simulation or settlement failed
+- `insufficient_balance` / `insufficient_allowance` — user moved funds
+
+---
+
+## 5. Quote History
+
+### Method 1: API response (easiest)
+The order API response includes the quote that was used:
+
+```bash
+curl -s "https://api.cow.fi/$NETWORK/api/v1/orders/$ORDER_UID" | jq '.quote'
+```
+
+Returns:
+```json
+{
+  "sellAmount": "4300531427036176000",
+  "buyAmount": "16788289774218687968",
+  "feeAmount": "3270684063997860",
+  "solver": "0x3980daa7eaad0b7e0c53cfc5c2760037270da54d",
+  "verified": true,
+  ...
+}
+```
+
+### Method 2: Database
+```sql
+SELECT q.id, q.sell_amount, q.buy_amount, q.gas_amount, q.solver, q.created
+FROM quotes q
+JOIN order_quotes oq ON oq.quote_id = q.id
+WHERE oq.order_uid = '\x$ORDER_UID_HEX';
+```
+
+### Method 3: Logs (fallback)
+Find the quote_id from the "order created" log:
+
+```bash
+"expr": "NOT container:controller order created ORDER_UID | sort by (_time) asc"
+```
+
+**Example log line:**
+```
+orderbook::api::post_order: order created order_uid=0x... quote_id=Some(2720468) quote_solver=Some(0x3980...)
+```
+
+Then search for quote details by ID:
+```bash
+"expr": "NOT container:controller $QUOTE_ID | sort by (_time) asc"
+```
+
+---
+
+## 6. Quoting Deep Dive
+
+Quotes determine the limit price users sign. Bad quotes = orders that can't fill.
+
+### Quote Process
+
+```
+UI requests quote → Orderbook sends "fake auction" (single order, infinite slippage) to all solvers
+                           ↓
+                    Solvers return: exchange rate + calldata (recipe)
+                           ↓
+                    In parallel, orderbook also fetches:
+                    - Gas price estimate
+                    - Native price of sell token (to convert gas cost)
+                    - Native price of buy token (needed for surplus scoring later)
+                           ↓
+                    Simulate winning solver's calldata → get gas units
+                           ↓
+                    network_fee = gas_units × gas_price / sell_token_native_price
+                           ↓
+                    Return quote with exchange rate + network fee
+```
+
+### Quote Types
+
+| Type | Behavior | Use Case |
+|------|----------|----------|
+| **Fast** | Returns after first 3 solver responses, always unverified | UI responsiveness |
+| **Optimal** | Waits for all solvers (5s timeout), attempts verification | Actual order placement |
+| **Native** | Cached quote for "buy 0.1 ETH with token X" | Native price lookups |
+
+**Verified vs Unverified:**
+- Verified = simulation succeeded, high confidence quote is achievable
+- Unverified = simulation failed or skipped, solver might have bad math
+
+### Limit Price Calculation
+
+```
+min_buy_amount = (sell_amount - network_fee) × exchange_rate × (1 - slippage) × (1 - partner_fee)
+```
+
+**Smart slippage**: Smaller orders get higher slippage bc network fee dominates. A 10% gas price spike on a $10 order (where fee is ~$2) eats way more than on a $1M order.
+
+---
+
+## 7. Order Placement Validation
+
+Orderbook rejects orders that have no chance of executing. Checks:
+
+| Check | Failure Mode |
+|-------|--------------|
+| Signature valid | Bad sig, wrong signer |
+| Balance sufficient | Fill-or-kill needs full amount, partial needs >0 |
+| Approval set | Need approval on GPV2VaultRelayer (not settlement contract directly) |
+| AppData pre-image exists | AppData JSON must be provided in full with order, or pre-image must be added to backend beforehand |
+| Rate limit | Too many orders per trader |
+| Quote attached + valid | If quote ID provided, must exist and match |
+
+**If order placed without quote** (common for bots): Orderbook re-quotes to classify as market vs limit order.
+
+---
+
+## 8. Autopilot Filtering (Why Order Not In Auction)
+
+Even after placement, autopilot filters orders each auction. Current filters:
+
+| Filter | Why |
+|--------|-----|
+| Signature re-check | presign/eip1271 can become invalid |
+| Balance re-check | User moved funds |
+| Native price exists | Can't score surplus without ETH-denominated value |
+| Fee policy applied | Protocol fee calculation |
+
+**Mainnet currently has ~6000 orders in auction** — drivers also do their own prioritization/filtering.
+
+---
+
+## 9. Limit Order Specific Checks
+
+### 9.1 Surplus Fee Validation
+
+```bash
+# From order JSON, verify:
+surplusFee != null
+surplusFeeTimestamp is within last 10 minutes
+```
+
+**If missing/stale, check surplus fee computation logs:**
+```bash
+# Victoria Logs query
+"expr": "surplus_fee $ORDER_UID | sort by (_time) asc"
+```
+
+**Surplus fee error logs:**
+```bash
+"expr": "surplus_fee error | sort by (_time) asc"
+```
+
+### 9.2 Auction Filtering Check
+
+```bash
+# Check if order is in current auction:
+curl -s "https://api.cow.fi/$NETWORK/api/v1/auction" | jq '.orders[] | select(.uid == "$ORDER_UID")'
+```
+
+If not present, order is filtered. Check filter logs:
+```bash
+# Victoria Logs query
+"expr": "filtered $ORDER_UID | sort by (_time) asc"
+```
+
+**Common filter reasons:**
+- `insufficient_balance`
+- `insufficient_allowance`  
+- `invalid_signature` (ERC-1271 state changed, presign cancelled)
+- `pre_interaction_error`
+- `no_native_price` (can't get ETH price for buy token)
+
+### 9.3 Market Price Verification
+
+Compute effective sell amount:
+```
+effectiveSellAmount = sellAmount - surplusFee
+```
+
+**For SELL orders:**
+```bash
+curl -s -X POST "https://barn.api.cow.fi/$NETWORK/api/v1/quote" \
+  -H 'content-type: application/json' \
+  -d '{
+    "from": "$OWNER",
+    "sellToken": "$SELL_TOKEN",
+    "buyToken": "$BUY_TOKEN",
+    "kind": "sell",
+    "sellAmountAfterFee": "$EFFECTIVE_SELL_AMOUNT"
+  }' | jq '.quote.buyAmount'
+```
+→ Order's `buyAmount` should be **less than** this quote.
+
+**For BUY orders:**
+```bash
+curl -s -X POST "https://barn.api.cow.fi/$NETWORK/api/v1/quote" \
+  -H 'content-type: application/json' \
+  -d '{
+    "from": "$OWNER",
+    "sellToken": "$SELL_TOKEN",
+    "buyToken": "$BUY_TOKEN",
+    "kind": "buy",
+    "buyAmountAfterFee": "$BUY_AMOUNT"
+  }' | jq '.quote.sellAmount'
+```
+→ Order's `effectiveSellAmount` should be **greater than** this quote.
+
+---
+
+## 10. Settlement Flow (On-Chain)
+
+When driver wins, it has 2-3 blocks to land the tx.
+
+### Settlement Contract Execution Order
+
+```solidity
+settle(
+    IERC20[] tokens,           // All tokens involved
+    uint256[] clearingPrices,  // Exchange rates
+    Trade[] trades,            // Orders being filled
+    Interaction[][3] interactions  // [pre, main, post]
+)
+```
+
+**Execution sequence:**
+1. **Pre-interactions** — Solver prep + user pre-hooks (unstaking, approvals, etc)
+2. **For each trade:**
+   - Convert Trade → Order struct
+   - Verify signature (presign/eip1271 checked NOW)
+   - Compute transfer amounts
+   - Update filledAmounts mapping (replay protection)
+   - Transfer sell tokens INTO settlement contract
+3. **Main interactions** — The actual swaps/routing (Uniswap calls, etc)
+4. **Pay out** — Transfer buy tokens to receivers, enforce min amounts
+5. **Post-interactions** — Solver cleanup + user post-hooks (bridging, etc)
+
+### Driver Submission Behavior
+
+- Uses private RPCs (MEV Blocker) to avoid failed tx costs + get MEV protection
+- Gas bumps on each block if not included
+- Monitors chain state, cancels if settlement becomes invalid (liquidity moved, etc)
+- **Penalty** if solution proposed but not settled
+
+---
+
+## 11. Auction Runtime Issues
+
+Order is in auction but still not matching?
+
+**Auction orders log:**
+```bash
+# Victoria Logs query (just the auction ID number)
+"expr": "$AUCTION_ID | sort by (_time) asc"
+```
+
+**Specific auction run:**
+```bash
+"expr": "$RUN_ID | sort by (_time) asc"
+```
+
+### JIT Orders & CoW AMMs
+
+Solvers can inject "just-in-time" orders (e.g., from market makers). These normally don't count toward surplus scoring bc they're not public.
+
+**Exception:** CoW AMM contracts are whitelisted — autopilot includes "surplus capturing JIT order owners" in auction. Orders from these contracts DO count for surplus.
+
+If debugging a CoW AMM interaction, check if the AMM contract is in the whitelist.
+
+---
+
+## 12. Circuit Breaker Monitoring
+
+The circuit breaker watches all on-chain settlements and compares against off-chain auction outcomes.
+
+**It enforces:**
+- Winning solver is actually the one settling
+- Settled amounts match reported amounts
+- No protocol violations
+
+**Violations → solver jailed** (deny-listed until they contact team, explain, fix).
+
+Check circuit breaker logs if solver claims they won but settlement didn't happen or was rejected.
+
+---
+
+## 13. DB Queries (Direct Access)
+
+### Check order state in DB:
+```sql
+SELECT
+  uid, creation_timestamp, owner, sell_token, buy_token,
+  sell_amount, buy_amount, valid_to, kind, class,
+  surplus_fee, surplus_fee_timestamp
+FROM orders
+WHERE uid = '\x$ORDER_UID_HEX';
+```
+
+### Check order lifecycle events:
+The `order_events` table tracks order state changes. This is often the fastest way to understand what happened.
+
+```sql
+SELECT timestamp, label::text
+FROM order_events
+WHERE order_uid = '\x$ORDER_UID_HEX'
+ORDER BY timestamp;
+```
+
+**Event labels:**
+| Label | Meaning |
+|-------|---------|
+| `created` | Order was placed |
+| `ready` | Order ready for auction inclusion |
+| `considered` | Order was considered in an auction |
+| `executing` | Order is being settled (in-flight) |
+| `traded` | Order was filled on-chain |
+| `cancelled` | User cancelled the order |
+| `filtered` | Order was filtered out of auction |
+| `invalid` | Order became invalid (balance/allowance/signature) |
+
+**Example lifecycle:** `created` → `ready` → `considered` → `executing` → `traded`
+
+### Check quotes for order:
+```sql
+SELECT 
+  q.id, q.sell_token, q.buy_token, q.sell_amount, q.buy_amount,
+  q.gas_amount, q.solver, q.created
+FROM quotes q
+JOIN order_quotes oq ON oq.quote_id = q.id
+WHERE oq.order_uid = '\x$ORDER_UID_HEX';
+```
+
+### Check auction inclusion history:
+```sql
+SELECT 
+  auction_id, order_uid, included, filtered_reason
+FROM auction_orders
+WHERE order_uid = '\x$ORDER_UID_HEX'
+ORDER BY auction_id DESC
+LIMIT 20;
+```
+
+You can also check attempts in `settlement_executions` tables.
+
+### Check successful settlements:
+```sql
+SELECT
+  tx_hash, solver, order_uid, executed_sell_amount, executed_buy_amount
+FROM settlements s
+JOIN trades t ON t.settlement_id = s.id
+WHERE t.order_uid = '\x$ORDER_UID_HEX';
+```
+
+### Check presignature events (for presign orders):
+```sql
+SELECT block_number, signed
+FROM presignature_events
+WHERE order_uid = '\x$ORDER_UID_HEX'
+ORDER BY block_number;
+```
+If `signed = false`, the user revoked their presignature on-chain.
+
+---
+
+## 14. AppData Deep Dive
+
+AppData is a hash of a JSON document (the JSON must be provided in full or its pre-image registered beforehand). **Cannot be verified on-chain** (smart contract just sees hash), so all enforcement is off-chain/soft.
+
+### Common AppData Fields
+
+```json
+{
+  "version": "1.0.0",
+  "metadata": {
+    "partnerFee": {
+      "recipient": "0x...",
+      "bps": 30
+    },
+    "hooks": {
+      "pre": [{ "target": "0x...", "callData": "0x...", "gasLimit": "100000" }],
+      "post": [{ "target": "0x...", "callData": "0x...", "gasLimit": "100000" }]
+    },
+    "flashLoan": {
+      "lender": "0x...",
+      "token": "0x...",
+      "amount": "1000000000000000000"
+    }
+  }
+}
+```
+
+**Debug implications:**
+- Partner fee misconfigured → order's effective price is wrong
+- Pre-hook fails → settlement reverts at pre-interaction stage
+- Post-hook fails → settlement reverts after swaps (user loses gas but trade doesn't complete)
+- Flash loan hints help solver but don't guarantee execution
+
+```bash
+# Fetch appData content
+curl -s "https://api.cow.fi/$NETWORK/api/v1/app_data/$APP_DATA_HASH"
+```
+
+---
+
+## 15. Useful Links
+
+| Resource | URL |
+|----------|-----|
+| Order Explorer | `https://explorer.cow.fi/orders/$ORDER_UID` |
+| Grafana Logs (Victoria Logs) | `$GRAFANA_URL/explore` (see .env.claude) |
+| API Docs | `https://api.cow.fi/docs/` |
+| Block-to-Date | `https://etherscan.io/blockdateconverter` |
+| Barn (Staging) | `https://barn.cow.fi` |
+| Settlement Contract | `0x9008D19f58AAbD9eD0D60971565AA8510560ab41` |
+
+---
+
+## 16. Decision Tree
+
+```
+Order not matched?
+│
+├─ Is order in auction?
+│  ├─ NO → Check autopilot logs for filter reason
+│  │       → Common: balance, allowance, signature, no native price
+│  │
+│  └─ YES → Did solvers bid?
+│           ├─ NO → Price probably out of market
+│           │       → Verify with quote API
+│           │       → Check price movement since quote
+│           │
+│           └─ YES → What happened to winning bid?
+│                    → Check solver pod for revert/error
+│                    → Get auction_id, check competition endpoint
+│
+├─ Is it a limit order?
+│  └─ Has surplusFee? Is it fresh (<10min)?
+│     → NO: Check surplus fee computation logs
+│
+├─ Check signing scheme
+│  └─ presign/eip1271? → State may have changed since placement
+│
+└─ Check appData
+   └─ Hooks defined? → Pre/post hook might be failing
+```
+
+---
+
+## 17. Common Root Causes
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| No surplusFee | Quote computation failed | Check estimator logs |
+| surplusFee stale | Background task stuck | Escalate to #backend |
+| Filtered: insufficient_balance | User moved funds | Wait for rebalance |
+| Filtered: invalid_signature | ERC-1271/presign state changed | User must re-sign or re-presign |
+| Filtered: no_native_price | Can't price buy token in ETH | Token has no liquidity path to ETH |
+| No solver bids | Price out of market | User adjusts limit |
+| Solver bid reverted | Liquidity changed between auction and settlement | Normal MEV/timing |
+| Quote outlier | Single estimator gave bad price | Check if quote was verified |
+| Unverified quote accepted | Simulation failed but UI showed price anyway | User signed bad limit price |
+| Pre-hook revert | User's pre-hook call failed | Check hook calldata + target |
+| Gas estimate too low | API gas estimation bug | Known issue, being fixed |

From 86fe6a083c8bbd282c2bcee7adf9ac0f73ddd94a Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 5 Feb 2026 17:16:07 +0300
Subject: [PATCH 036/219] Don't notify solvers about failed solutions with a
 haircut fee (#4115)

# Description
This PR addresses [a
comment](https://github.com/cowprotocol/services/pull/4049#pullrequestreview-3687251046)
that suggests avoiding notifying solvers on failed solutions encoding
that were configured with a haircut fee. Also, updates the metric to
easily identify the error rate of solutions with the haircut fee to
configure a new alert to take any action.
---
 crates/driver/src/domain/competition/mod.rs   | 32 +++++++++-----
 .../src/domain/competition/solution/mod.rs    | 10 +++++
 .../domain/competition/solution/settlement.rs |  5 +++
 crates/driver/src/infra/observe/mod.rs        | 44 ++++++++++++++++---
 4 files changed, 74 insertions(+), 17 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 869d51d683..6355119ccb 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -239,6 +239,7 @@ impl Competition {
                     .user_trades()
                     .map(|trade| trade.order().uid)
                     .collect();
+                let has_haircut = solution.has_haircut();
                 observe::encoding(&id);
                 let settlement = solution
                     .encode(
@@ -248,10 +249,10 @@ impl Competition {
                         self.solver.solver_native_token(),
                     )
                     .await;
-                (id, orders, settlement)
+                (id, orders, has_haircut, settlement)
             })
             .collect::<FuturesUnordered<_>>()
-            .filter_map(|(id, orders, result)| async move {
+            .filter_map(|(id, orders, has_haircut, result)| async move {
                 match result {
                     Ok(solution) => {
                         self.risk_detector.encoding_succeeded(&orders);
@@ -261,8 +262,11 @@ impl Competition {
                     Err(_err) if id.solutions().len() > 1 => None,
                     Err(err) => {
                         self.risk_detector.encoding_failed(&orders);
-                        observe::encoding_failed(self.solver.name(), &id, &err);
-                        notify::encoding_failed(&self.solver, auction.id(), &id, &err);
+                        observe::encoding_failed(self.solver.name(), &id, &err, has_haircut);
+                        // don't notify on errors for solutions with haircut
+                        if !has_haircut {
+                            notify::encoding_failed(&self.solver, auction.id(), &id, &err);
+                        }
                         None
                     }
                 }
@@ -362,6 +366,7 @@ impl Competition {
         // gets picked by the procotol.
         if let Ok(remaining) = deadline.remaining() {
             let score_ref = &mut score;
+            let has_haircut = settlement.has_haircut();
             let simulate_on_new_blocks = async move {
                 let mut stream =
                     ethrpc::block_stream::into_stream(self.eth.current_block().clone());
@@ -369,19 +374,22 @@ impl Competition {
                     if let Err(infra::simulator::Error::Revert(err)) =
                         self.simulate_settlement(&settlement).await
                     {
-                        observe::winner_voided(block, &err);
+                        observe::winner_voided(self.solver.name(), block, &err, has_haircut);
                         *score_ref = None;
                         self.settlements
                             .lock()
                             .unwrap()
                             .retain(|s| s.solution().get() != solution_id);
-                        notify::simulation_failed(
-                            &self.solver,
-                            auction.id(),
-                            settlement.solution(),
-                            &infra::simulator::Error::Revert(err),
-                            true,
-                        );
+                        // Only notify solver if solution doesn't have haircut
+                        if !has_haircut {
+                            notify::simulation_failed(
+                                &self.solver,
+                                auction.id(),
+                                settlement.solution(),
+                                &infra::simulator::Error::Revert(err),
+                                true,
+                            );
+                        }
                         return;
                     }
                 }
diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index 01bdac1626..35f9b64615 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -519,6 +519,16 @@ impl Solution {
                 )
             })
     }
+
+    /// Returns true if any trade in this solution has a non-zero haircut fee.
+    /// Used to determine if simulation failures should suppress solver
+    /// notifications.
+    pub fn has_haircut(&self) -> bool {
+        self.trades.iter().any(|trade| match trade {
+            Trade::Fulfillment(fulfillment) => !fulfillment.haircut_fee().is_zero(),
+            Trade::Jit(_) => false, // JIT orders don't have haircut
+        })
+    }
 }
 
 /// Given two solutions returns the factors with
diff --git a/crates/driver/src/domain/competition/solution/settlement.rs b/crates/driver/src/domain/competition/solution/settlement.rs
index 63bf90be3c..c7ad4a33d7 100644
--- a/crates/driver/src/domain/competition/solution/settlement.rs
+++ b/crates/driver/src/domain/competition/solution/settlement.rs
@@ -339,6 +339,11 @@ impl Settlement {
             .map(|(token, amount)| (token, amount.into()))
             .collect()
     }
+
+    /// Returns true if this settlement's solution has any trades with haircut.
+    pub fn has_haircut(&self) -> bool {
+        self.solution.has_haircut()
+    }
 }
 
 /// Should the interactions be internalized?
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 07e1b06a12..8ee025539e 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -122,11 +122,26 @@ pub fn encoding(id: &solution::Id) {
 }
 
 /// Observe that settlement encoding failed.
-pub fn encoding_failed(solver: &solver::Name, id: &solution::Id, err: &solution::Error) {
-    tracing::info!(?id, ?err, "discarded solution: settlement encoding");
+pub fn encoding_failed(
+    solver: &solver::Name,
+    id: &solution::Id,
+    err: &solution::Error,
+    has_haircut: bool,
+) {
+    tracing::info!(
+        ?id,
+        ?err,
+        has_haircut,
+        "discarded solution: settlement encoding"
+    );
+    let reason = if has_haircut {
+        "SettlementEncodingHaircut"
+    } else {
+        "SettlementEncoding"
+    };
     metrics::get()
         .dropped_solutions
-        .with_label_values(&[solver.as_str(), "SettlementEncoding"])
+        .with_label_values(&[solver.as_str(), reason])
         .inc();
 }
 
@@ -164,8 +179,27 @@ pub fn score(settlement: &Settlement, score: &eth::Ether) {
 
 // Observe that the winning settlement started failing upon arrival of a new
 // block
-pub fn winner_voided(block: BlockInfo, err: &simulator::RevertError) {
-    tracing::warn!(block = block.number, ?err, "solution reverts on new block");
+pub fn winner_voided(
+    solver: &solver::Name,
+    block: BlockInfo,
+    err: &simulator::RevertError,
+    has_haircut: bool,
+) {
+    tracing::warn!(
+        block = block.number,
+        ?err,
+        has_haircut,
+        "solution reverts on new block"
+    );
+    let reason = if has_haircut {
+        "SimulationRevertHaircut"
+    } else {
+        "SimulationRevert"
+    };
+    metrics::get()
+        .dropped_solutions
+        .with_label_values(&[solver.as_str(), reason])
+        .inc();
 }
 
 pub fn revealing() {

From 04a3915f53c67e153dd7ce3b84465b4656674b28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 5 Feb 2026 19:43:37 +0000
Subject: [PATCH 037/219] Optimize total_surplus query (#4116)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
We've been experiencing latency spikes on several endpoints, we've
pinned this down to the time it takes to acquire DB connections from the
pool; when checking RDS monitoring, the surplus query always shows up at
the top.

The current theory is that the query is a bit slower than it could be,
as more users request the main swap page, their surplus is loaded (even
if they don't request it — i.e. load the wallet modal) and if some of
these users have a larger amount of orders, they're taking up
connections that other endpoints aren't getting.

I looked into the user distribution, here are the results:

|log_bucket|bucket_start|num_users|pct|cumulative_users|cumulative_pct|
|----------|------------|---------|---|----------------|--------------|
|0|1|295329|83.86|295329|83.86|
|1|10|51334|14.58|346663|98.44|
|2|100|5071|1.44|351734|99.88|
|3|1000|306|0.09|352040|99.96|
|4|10000|106|0.03|352146|99.99|
|5|100000|28|0.01|352174|100.00|

<details><summary>Distribution Query</summary>
<p>

```sql
WITH buckets AS (
    SELECT
        floor(log(order_count))::int as log_bucket,
        power(10, floor(log(order_count)))::int as bucket_start,
        count(*) as num_users
    FROM (
        SELECT owner, count(*) as order_count
        FROM orders
        GROUP BY owner
    ) sub
    GROUP BY 1, 2
)
SELECT
    log_bucket,
    bucket_start,
    num_users,
    round(100.0 * num_users / sum(num_users) over(), 2) as pct,
    sum(num_users) over(order by log_bucket) as cumulative_users,
    round(100.0 * sum(num_users) over(order by log_bucket) / sum(num_users) over(), 2) as cumulative_pct
FROM buckets
ORDER BY log_bucket;
```

</p>
</details>

However, if it was just this, it would be too simple. Depending on the
user, they might have no orders and only onchain orders (note that the
max number of onchain orders is around ~10k), some will have skewed data
distributions across tables too, leading to analyzing and optimizing
this query a bit tricky.

There are two crucial changes to the query — removing ARRAY_AGG and
adding indexes — the first makes it so that the DB does not have to
materialize a potentially big array in memory, which would otherwise
lead to bad estimations too; the second provides better "access paths"
to some of the information the query requires.

### RDS Stats (1h)

Before

<img width="2374" height="438" alt="Screenshot 2026-02-05 at 11-12-43
CloudWatch eu-central-1"
src="https://github.com/user-attachments/assets/06326a41-dfd5-4799-a0de-b0ab15a6349b"
/>

After

<img width="2368" height="1228" alt="Screenshot 2026-02-05 at 11-14-53
CloudWatch eu-central-1"
src="https://github.com/user-attachments/assets/7822d4c9-35bd-45c7-aecc-c5a271c7aded"
/>

# Changes
- [ ] Replace the query with the optimized one
- [ ] Create indexes (already done to avoid issues during migration)

## Query Plans

<details><summary>Before</summary>
<p>

```
Aggregate  (cost=1033006.55..1033006.56 rows=1 width=8) (actual time=130139.025..130143.456 rows=1 loops=1)
  ->  Append  (cost=1032650.26..1033006.51 rows=2 width=100) (actual time=31175.499..130090.776 rows=10998 loops=1)
        ->  Subquery Scan on "*SELECT* 1"  (cost=1032650.26..1032856.24 rows=1 width=100) (actual time=31175.498..130085.109 rows=10998 loops=1)
              ->  Nested Loop  (cost=1032650.26..1032856.23 rows=1 width=100) (actual time=31175.497..130079.454 rows=10998 loops=1)
                    Join Filter: (t.order_uid = o.uid)
                    InitPlan 3 (returns $5)
                      ->  Finalize Aggregate  (cost=1032601.57..1032601.58 rows=1 width=32) (actual time=30761.210..30765.632 rows=1 loops=1)
                            ->  Gather  (cost=1032601.35..1032601.56 rows=2 width=32) (actual time=30678.267..30689.666 rows=3 loops=1)
                                  Workers Planned: 2
                                  Workers Launched: 2
                                  ->  Partial Aggregate  (cost=1031601.35..1031601.36 rows=1 width=32) (actual time=30675.862..30675.863 rows=1 loops=3)
                                        ->  Parallel Bitmap Heap Scan on orders  (cost=24591.99..1030861.56 rows=295913 width=57) (actual time=278.099..30619.932 rows=226281 loops=3)
                                              Recheck Cond: (owner = '\x10dad59905d93ca37cd25a35f25349cb5956ba8e'::bytea)
                                              Rows Removed by Index Recheck: 737927
                                              Heap Blocks: exact=15162 lossy=55571
                                              ->  Bitmap Index Scan on order_owner  (cost=0.00..24414.44 rows=710192 width=0) (actual time=271.994..271.994 rows=749143 loops=1)
                                                    Index Cond: (owner = '\x10dad59905d93ca37cd25a35f25349cb5956ba8e'::bytea)
                    InitPlan 4 (returns $6)
                      ->  Aggregate  (cost=47.00..47.01 rows=1 width=32) (actual time=0.021..0.022 rows=1 loops=1)
                            ->  Bitmap Heap Scan on onchain_placed_orders  (cost=4.09..46.97 rows=11 width=57) (actual time=0.017..0.018 rows=0 loops=1)
                                  Recheck Cond: (sender = '\x10dad59905d93ca37cd25a35f25349cb5956ba8e'::bytea)
                                  ->  Bitmap Index Scan on order_sender  (cost=0.00..4.08 rows=11 width=0) (actual time=0.013..0.013 rows=0 loops=1)
                                        Index Cond: (sender = '\x10dad59905d93ca37cd25a35f25349cb5956ba8e'::bytea)
                    ->  Nested Loop  (cost=1.12..136.08 rows=2 width=188) (actual time=31172.849..109529.707 rows=10914 loops=1)
                          ->  Index Scan using orders_pkey on orders o  (cost=0.56..85.71 rows=10 width=123) (actual time=31172.113..101635.999 rows=678843 loops=1)
                                Index Cond: (uid = ANY (array_cat($5, $6)))
                          ->  Index Only Scan using order_rewards_pkey on order_execution oe  (cost=0.56..5.01 rows=3 width=65) (actual time=0.011..0.011 rows=0 loops=678843)
                                Index Cond: (order_uid = o.uid)
                                Heap Fetches: 170
                    ->  Index Scan using trade_order_uid on trades t  (cost=0.56..0.74 rows=2 width=81) (actual time=0.416..0.416 rows=1 loops=10914)
                          Index Cond: (order_uid = oe.order_uid)
                    SubPlan 1
                      ->  Index Scan using auction_prices_pkey on auction_prices ap  (cost=0.58..35.00 rows=16 width=11) (actual time=1.428..1.428 rows=1 loops=9675)
                            Index Cond: ((auction_id = oe.auction_id) AND (token = o.buy_token))
                    SubPlan 2
                      ->  Index Scan using auction_prices_pkey on auction_prices ap_1  (cost=0.58..35.00 rows=16 width=11) (actual time=1.596..1.596 rows=1 loops=1323)
                            Index Cond: ((auction_id = oe.auction_id) AND (token = o.sell_token))
        ->  Subquery Scan on "*SELECT* 2"  (cost=2.09..150.26 rows=1 width=100) (actual time=0.010..0.013 rows=0 loops=1)
              ->  Nested Loop  (cost=2.09..150.25 rows=1 width=100) (actual time=0.009..0.012 rows=0 loops=1)
                    Join Filter: (j.uid = t_1.order_uid)
                    ->  Nested Loop  (cost=1.54..79.45 rows=1 width=192) (actual time=0.009..0.010 rows=0 loops=1)
                          ->  Nested Loop Anti Join  (cost=0.98..74.32 rows=1 width=127) (actual time=0.009..0.010 rows=0 loops=1)
                                ->  Index Scan using jit_user_order_creation_timestamp on jit_orders j  (cost=0.42..33.62 rows=8 width=127) (actual time=0.008..0.009 rows=0 loops=1)
                                      Index Cond: (owner = '\x10dad59905d93ca37cd25a35f25349cb5956ba8e'::bytea)
                                ->  Index Only Scan using orders_pkey on orders o_1  (cost=0.56..5.08 rows=1 width=57) (never executed)
                                      Index Cond: (uid = j.uid)
                                      Heap Fetches: 0
                          ->  Index Only Scan using order_rewards_pkey on order_execution oe_1  (cost=0.56..5.11 rows=3 width=65) (never executed)
                                Index Cond: (order_uid = j.uid)
                                Heap Fetches: 0
                    ->  Index Scan using trade_order_uid on trades t_1  (cost=0.56..0.74 rows=2 width=81) (never executed)
                          Index Cond: (order_uid = oe_1.order_uid)
                    SubPlan 5
                      ->  Index Scan using auction_prices_pkey on auction_prices ap_2  (cost=0.58..35.00 rows=16 width=11) (never executed)
                            Index Cond: ((auction_id = oe_1.auction_id) AND (token = j.buy_token))
                    SubPlan 6
                      ->  Index Scan using auction_prices_pkey on auction_prices ap_3  (cost=0.58..35.00 rows=16 width=11) (never executed)
                            Index Cond: ((auction_id = oe_1.auction_id) AND (token = j.sell_token))
Planning Time: 4.788 ms
Execution Time: 130157.850 ms
```

</p>
</details>

<details><summary>After</summary>
<p>

```
Aggregate  (cost=14614.00..14614.01 rows=1 width=8) (actual time=1901.439..1902.539 rows=1 loops=1)
  Buffers: shared hit=11838 read=4075
  I/O Timings: shared read=2240.469
  ->  Gather Merge  (cost=14557.86..14604.91 rows=404 width=136) (actual time=1900.725..1902.018 rows=917 loops=1)
        Workers Planned: 2
        Workers Launched: 2
        Buffers: shared hit=11838 read=4075
        I/O Timings: shared read=2240.469
        ->  Sort  (cost=13557.83..13558.25 rows=168 width=136) (actual time=762.591..762.628 rows=306 loops=3)
              Sort Key: "*SELECT* 2".uid
              Sort Method: quicksort  Memory: 49kB
              Buffers: shared hit=11838 read=4075
              I/O Timings: shared read=2240.469
              Worker 0:  Sort Method: quicksort  Memory: 115kB
              Worker 1:  Sort Method: quicksort  Memory: 25kB
              ->  Parallel Append  (cost=2.25..13551.63 rows=168 width=136) (actual time=2.247..762.040 rows=306 loops=3)
                    Buffers: shared hit=11824 read=4075
                    I/O Timings: shared read=2240.469
                    ->  Subquery Scan on "*SELECT* 2"  (cost=24.42..13550.79 rows=53 width=136) (actual time=3.496..1892.483 rows=709 loops=1)
                          Buffers: shared hit=9702 read=3415
                          I/O Timings: shared read=1854.511
                          ->  Nested Loop Left Join  (cost=24.42..13550.26 rows=53 width=136) (actual time=3.495..1892.175 rows=709 loops=1)
                                Buffers: shared hit=9702 read=3415
                                I/O Timings: shared read=1854.511
                                ->  Nested Loop  (cost=23.84..13414.32 rows=53 width=155) (actual time=1.455..762.309 rows=709 loops=1)
                                      Buffers: shared hit=8050 read=1521
                                      I/O Timings: shared read=736.402
                                      ->  Nested Loop  (cost=23.28..12573.83 rows=195 width=245) (actual time=1.418..667.512 rows=709 loops=1)
                                            Buffers: shared hit=5387 read=1337
                                            I/O Timings: shared read=647.346
                                            ->  Nested Loop  (cost=22.73..9169.44 rows=796 width=180) (actual time=1.397..584.403 rows=711 loops=1)
                                                  Buffers: shared hit=2649 read=1211
                                                  I/O Timings: shared read=570.801
                                                  ->  Bitmap Heap Scan on onchain_placed_orders opo  (cost=22.17..2343.76 rows=796 width=57) (actual time=0.699..6.255 rows=711 loops=1)
                                                        Recheck Cond: (sender = '\x8ef4fb956d0cb06ca9e3db76040f08154e8d0122'::bytea)
                                                        Buffers: shared hit=56 read=248
                                                        I/O Timings: shared read=2.028
                                                        ->  Bitmap Index Scan on order_sender  (cost=0.00..21.97 rows=796 width=0) (actual time=0.044..0.044 rows=711 loops=1)
                                                              Index Cond: (sender = '\x8ef4fb956d0cb06ca9e3db76040f08154e8d0122'::bytea)
                                                              Buffers: shared hit=4
                                                  ->  Index Scan using orders_pkey on orders o  (cost=0.56..8.57 rows=1 width=123) (actual time=0.812..0.812 rows=1 loops=711)
                                                        Index Cond: (uid = opo.uid)
                                                        Filter: (owner <> '\x8ef4fb956d0cb06ca9e3db76040f08154e8d0122'::bytea)
                                                        Buffers: shared hit=2593 read=963
                                                        I/O Timings: shared read=568.773
                                            ->  Index Only Scan using order_rewards_pkey on order_execution oe  (cost=0.56..4.25 rows=3 width=65) (actual time=0.115..0.115 rows=1 loops=711)
                                                  Index Cond: (order_uid = o.uid)
                                                  Heap Fetches: 16
                                                  Buffers: shared hit=2738 read=126
                                                  I/O Timings: shared read=76.545
                                      ->  Index Only Scan using trades_covering on trades t  (cost=0.56..4.29 rows=2 width=81) (actual time=0.132..0.133 rows=1 loops=709)
                                            Index Cond: (order_uid = o.uid)
                                            Heap Fetches: 0
                                            Buffers: shared hit=2663 read=184
                                            I/O Timings: shared read=89.056
                                ->  Index Scan using auction_prices_pkey on auction_prices ap  (cost=0.58..31.94 rows=16 width=40) (actual time=1.590..1.590 rows=1 loops=709)
                                      Index Cond: ((auction_id = oe.auction_id) AND (token = CASE o.kind WHEN 'sell'::orderkind THEN o.buy_token ELSE o.sell_token END))
                                      Buffers: shared hit=1652 read=1894
                                      I/O Timings: shared read=1118.109
                    ->  Subquery Scan on "*SELECT* 1"  (cost=2.25..4428.09 rows=350 width=136) (actual time=3.233..393.256 rows=208 loops=1)
                          Buffers: shared hit=2119 read=660
                          I/O Timings: shared read=385.958
                          ->  Nested Loop  (cost=2.25..4424.59 rows=350 width=136) (actual time=3.233..393.181 rows=208 loops=1)
                                Join Filter: (t_1.order_uid = o_1.uid)
                                Buffers: shared hit=2119 read=660
                                I/O Timings: shared read=385.958
                                ->  Nested Loop Left Join  (cost=1.70..3742.63 rows=156 width=149) (actual time=3.212..369.737 rows=208 loops=1)
                                      Buffers: shared hit=1320 read=618
                                      I/O Timings: shared read=364.992
                                      ->  Nested Loop  (cost=1.12..3316.62 rows=156 width=188) (actual time=1.266..28.471 rows=208 loops=1)
                                            Buffers: shared hit=849 read=49
                                            I/O Timings: shared read=26.775
                                            ->  Index Only Scan using orders_owner_covering on orders o_1  (cost=0.56..187.36 rows=638 width=123) (actual time=1.247..2.194 rows=210 loops=1)
                                                  Index Cond: (owner = '\x8ef4fb956d0cb06ca9e3db76040f08154e8d0122'::bytea)
                                                  Heap Fetches: 1
                                                  Buffers: shared hit=24 read=7
                                                  I/O Timings: shared read=2.038
                                            ->  Index Only Scan using order_rewards_pkey on order_execution oe_1  (cost=0.56..4.87 rows=3 width=65) (actual time=0.124..0.124 rows=1 loops=210)
                                                  Index Cond: (order_uid = o_1.uid)
                                                  Heap Fetches: 4
                                                  Buffers: shared hit=825 read=42
                                                  I/O Timings: shared read=24.736
                                      ->  Index Scan using auction_prices_pkey on auction_prices ap_1  (cost=0.58..34.99 rows=16 width=40) (actual time=1.639..1.639 rows=1 loops=208)
                                            Index Cond: ((auction_id = oe_1.auction_id) AND (token = CASE o_1.kind WHEN 'sell'::orderkind THEN o_1.buy_token ELSE o_1.sell_token END))
                                            Buffers: shared hit=471 read=569
                                            I/O Timings: shared read=338.217
                                ->  Index Only Scan using trades_covering on trades t_1  (cost=0.56..4.29 rows=2 width=81) (actual time=0.109..0.109 rows=1 loops=208)
                                      Index Cond: (order_uid = oe_1.order_uid)
                                      Heap Fetches: 0
                                      Buffers: shared hit=799 read=42
                                      I/O Timings: shared read=20.966
                    ->  Subquery Scan on "*SELECT* 3"  (cost=2.67..94.60 rows=1 width=136) (actual time=0.012..0.014 rows=0 loops=1)
                          Buffers: shared hit=3
                          ->  Nested Loop Left Join  (cost=2.67..94.59 rows=1 width=136) (actual time=0.011..0.013 rows=0 loops=1)
                                Buffers: shared hit=3
                                ->  Nested Loop  (cost=2.09..91.83 rows=1 width=159) (actual time=0.011..0.013 rows=0 loops=1)
                                      Buffers: shared hit=3
                                      ->  Nested Loop  (cost=1.54..87.55 rows=1 width=208) (actual time=0.011..0.012 rows=0 loops=1)
                                            Buffers: shared hit=3
                                            ->  Nested Loop Anti Join  (cost=0.98..82.50 rows=1 width=127) (actual time=0.011..0.011 rows=0 loops=1)
                                                  Buffers: shared hit=3
                                                  ->  Index Scan using jit_user_order_creation_timestamp on jit_orders j  (cost=0.42..37.21 rows=9 width=127) (actual time=0.010..0.010 rows=0 loops=1)
                                                        Index Cond: (owner = '\x8ef4fb956d0cb06ca9e3db76040f08154e8d0122'::bytea)
                                                        Buffers: shared hit=3
                                                  ->  Index Only Scan using orders_pkey on orders o_2  (cost=0.56..5.02 rows=1 width=57) (never executed)
                                                        Index Cond: (uid = j.uid)
                                                        Heap Fetches: 0
                                            ->  Index Only Scan using trades_covering on trades t_2  (cost=0.56..5.03 rows=2 width=81) (never executed)
                                                  Index Cond: (order_uid = j.uid)
                                                  Heap Fetches: 0
                                      ->  Index Only Scan using order_rewards_pkey on order_execution oe_2  (cost=0.56..4.25 rows=3 width=65) (never executed)
                                            Index Cond: (order_uid = t_2.order_uid)
                                            Heap Fetches: 0
                                ->  Index Scan using auction_prices_pkey on auction_prices ap_2  (cost=0.58..35.01 rows=16 width=40) (never executed)
                                      Index Cond: ((auction_id = oe_2.auction_id) AND (token = CASE j.kind WHEN 'sell'::orderkind THEN j.buy_token ELSE j.sell_token END))
Planning:
  Buffers: shared hit=892 read=21
  I/O Timings: shared read=14.023
Planning Time: 18.375 ms
Execution Time: 1902.681 ms
```

</p>
</details>

## How to test

Due to the fact that floating point addition is not commutative and the
order specified in the old query is not deterministic (the ORDER BY uid
is merely an approximation that matches) the validation script leaves
some room for differences, 1e-9 to be precise.

<details><summary>Validation script</summary>
<p>

```
#!/usr/bin/env python3
"""
Compare original and optimized surplus queries for correctness.
Picks random addresses and verifies both queries return identical results.
"""

import os
import sys
import psycopg2
from psycopg2 import sql
from decimal import Decimal

# Connection settings - override with environment variables
DB_CONFIG = {
    "host": os.getenv("DB_HOST", "localhost"),
    "port": os.getenv("DB_PORT", "5432"),
    "dbname": os.getenv("DB_NAME", "your_database"),
    "user": os.getenv("DB_USER", "your_user"),
    "password": os.getenv("DB_PASSWORD", ""),
}

ORIGINAL_QUERY = """
WITH regular_orders AS (
    SELECT ARRAY_AGG(uid) AS ids FROM orders WHERE owner = $1
),
onchain_orders AS (
    SELECT ARRAY_AGG(uid) AS ids FROM onchain_placed_orders WHERE sender = $1
),
trade_components AS (
    SELECT
       CASE kind
          WHEN 'sell' THEN t.buy_amount
          WHEN 'buy' THEN t.sell_amount - t.fee_amount
       END AS trade_amount,
       CASE kind
          WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * o.buy_amount / o.sell_amount
          WHEN 'buy' THEN t.buy_amount * o.sell_amount / o.buy_amount
       END AS limit_amount,
       o.kind,
       CASE kind
          WHEN 'sell' THEN (SELECT price FROM auction_prices ap WHERE ap.token = o.buy_token AND ap.auction_id = oe.auction_id)
          WHEN 'buy' THEN (SELECT price FROM auction_prices ap WHERE ap.token = o.sell_token AND ap.auction_id = oe.auction_id)
       END AS surplus_token_native_price
    FROM orders o
    JOIN trades t ON o.uid = t.order_uid
    JOIN order_execution oe ON o.uid = oe.order_uid
    WHERE o.uid = ANY(ARRAY_CAT((SELECT ids FROM regular_orders), (SELECT ids FROM onchain_orders)))
    UNION ALL
    SELECT
       CASE j.kind
          WHEN 'sell' THEN t.buy_amount
          WHEN 'buy' THEN t.sell_amount - t.fee_amount
       END AS trade_amount,
       CASE j.kind
          WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * j.buy_amount / j.sell_amount
          WHEN 'buy' THEN t.buy_amount * j.sell_amount / j.buy_amount
       END AS limit_amount,
       j.kind,
       CASE j.kind
          WHEN 'sell' THEN (SELECT price FROM auction_prices ap WHERE ap.token = j.buy_token AND ap.auction_id = oe.auction_id)
          WHEN 'buy' THEN (SELECT price FROM auction_prices ap WHERE ap.token = j.sell_token AND ap.auction_id = oe.auction_id)
       END AS surplus_token_native_price
    FROM jit_orders j
    JOIN trades t ON j.uid = t.order_uid
    JOIN order_execution oe ON j.uid = oe.order_uid
    WHERE j.owner = $1 AND NOT EXISTS (
        SELECT 1
        FROM orders o
        WHERE o.uid = j.uid
    )
),
trade_surplus AS (
    SELECT
        CASE kind
            WHEN 'sell' THEN (trade_amount - limit_amount) * surplus_token_native_price
            WHEN 'buy' THEN (limit_amount - trade_amount) * surplus_token_native_price
        END / POWER(10, 18) AS surplus_in_wei
    FROM trade_components
)
SELECT
   COALESCE(SUM(surplus_in_wei), 0) AS total_surplus_in_wei
FROM trade_surplus;
"""

OPTIMIZED_QUERY = """
WITH trade_components AS (
    -- Regular orders: join trades first, then order_execution
    SELECT
        o.uid,
        CASE o.kind
            WHEN 'sell' THEN t.buy_amount
            WHEN 'buy' THEN t.sell_amount - t.fee_amount
        END AS trade_amount,
        CASE o.kind
            WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * o.buy_amount / o.sell_amount
            WHEN 'buy' THEN t.buy_amount * o.sell_amount / o.buy_amount
        END AS limit_amount,
        o.kind,
        ap.price AS surplus_token_native_price
    FROM orders o
    JOIN trades t ON t.order_uid = o.uid
    JOIN order_execution oe ON oe.order_uid = t.order_uid
    LEFT JOIN auction_prices ap
        ON ap.auction_id = oe.auction_id
        AND ap.token = CASE o.kind WHEN 'sell' THEN o.buy_token ELSE o.sell_token END
    WHERE o.owner = $1

    UNION ALL

    -- Onchain placed orders (if sender differs from owner)
    SELECT
        o.uid,
        CASE o.kind
            WHEN 'sell' THEN t.buy_amount
            WHEN 'buy' THEN t.sell_amount - t.fee_amount
        END AS trade_amount,
        CASE o.kind
            WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * o.buy_amount / o.sell_amount
            WHEN 'buy' THEN t.buy_amount * o.sell_amount / o.buy_amount
        END AS limit_amount,
        o.kind,
        ap.price AS surplus_token_native_price
    FROM onchain_placed_orders opo
    JOIN orders o ON o.uid = opo.uid AND o.owner != $1
    JOIN trades t ON t.order_uid = o.uid
    JOIN order_execution oe ON oe.order_uid = t.order_uid
    LEFT JOIN auction_prices ap
        ON ap.auction_id = oe.auction_id
        AND ap.token = CASE o.kind WHEN 'sell' THEN o.buy_token ELSE o.sell_token END
    WHERE opo.sender = $1

    UNION ALL

    -- JIT orders
    SELECT
        j.uid,
        CASE j.kind
            WHEN 'sell' THEN t.buy_amount
            WHEN 'buy' THEN t.sell_amount - t.fee_amount
        END AS trade_amount,
        CASE j.kind
            WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * j.buy_amount / j.sell_amount
            WHEN 'buy' THEN t.buy_amount * j.sell_amount / j.buy_amount
        END AS limit_amount,
        j.kind,
        ap.price AS surplus_token_native_price
    FROM jit_orders j
    JOIN trades t ON t.order_uid = j.uid
    JOIN order_execution oe ON oe.order_uid = t.order_uid
    LEFT JOIN auction_prices ap
        ON ap.auction_id = oe.auction_id
        AND ap.token = CASE j.kind WHEN 'sell' THEN j.buy_token ELSE j.sell_token END
    WHERE j.owner = $1
      AND NOT EXISTS (SELECT 1 FROM orders o WHERE o.uid = j.uid)
)
SELECT
    COALESCE(SUM(surplus_in_wei ORDER BY uid), 0) AS total_surplus_in_wei
FROM (
    SELECT
        uid,
        CASE kind
            WHEN 'sell' THEN (trade_amount - limit_amount) * surplus_token_native_price
            WHEN 'buy' THEN (limit_amount - trade_amount) * surplus_token_native_price
        END / POWER(10, 18) AS surplus_in_wei
    FROM trade_components
) ts;
"""

# Query to get random addresses with varying order counts
SAMPLE_ADDRESSES_QUERY = """
WITH address_order_counts AS (
    SELECT owner AS address, COUNT(*) AS order_count
    FROM orders
    GROUP BY owner
),
bucketed AS (
    SELECT
        address,
        order_count,
        CASE
            WHEN order_count < 10 THEN '0: 1-9'
            WHEN order_count < 100 THEN '1: 10-99'
            WHEN order_count < 1000 THEN '2: 100-999'
            WHEN order_count < 10000 THEN '3: 1000-9999'
            ELSE '4: 10000+'
        END AS bucket
    FROM address_order_counts
)
SELECT address, order_count, bucket
FROM (
    SELECT address, order_count, bucket,
           ROW_NUMBER() OVER (PARTITION BY bucket ORDER BY RANDOM()) AS rn
    FROM bucketed
) ranked
WHERE rn <= %s
ORDER BY bucket, order_count;
"""


def get_connection():
    return psycopg2.connect(**DB_CONFIG)


def fetch_sample_addresses(conn, samples_per_bucket=5):
    """Get random addresses from each order count bucket."""
    with conn.cursor() as cur:
        cur.execute(SAMPLE_ADDRESSES_QUERY, (samples_per_bucket,))
        return cur.fetchall()


def run_query(conn, query, address):
    """Run a query with the given address parameter."""
    # Convert $1 placeholder to %s for psycopg2
    pg_query = query.replace("$1", "%s")
    # Count how many parameters we need
    param_count = pg_query.count("%s")
    with conn.cursor() as cur:
        cur.execute(pg_query, tuple([address] * param_count))
        result = cur.fetchone()
        return result[0] if result else None


def compare_results(original, optimized, tolerance=1e-9):
    """Compare two numeric results with floating point tolerance."""
    if original is None and optimized is None:
        return True, "both NULL"
    if original is None or optimized is None:
        return False, f"NULL mismatch: original={original}, optimized={optimized}"

    # Convert to float for comparison
    orig_float = float(original)
    opt_float = float(optimized)

    if orig_float == opt_float:
        return True, "exact match"

    # Check relative difference for non-zero values
    if orig_float != 0:
        rel_diff = abs(orig_float - opt_float) / abs(orig_float)
        if rel_diff < tolerance:
            return True, f"within tolerance (rel_diff={rel_diff:.2e})"

    # Check absolute difference for values near zero
    abs_diff = abs(orig_float - opt_float)
    if abs_diff < tolerance:
        return True, f"within tolerance (abs_diff={abs_diff:.2e})"

    return False, f"MISMATCH: original={orig_float}, optimized={opt_float}, diff={abs_diff}"


def main():
    samples_per_bucket = int(sys.argv[1]) if len(sys.argv) > 1 else 5

    print(f"Comparing original vs optimized query ({samples_per_bucket} samples per bucket)")
    print("=" * 80)

    conn = get_connection()

    # Get sample addresses
    print("\nFetching sample addresses...")
    addresses = fetch_sample_addresses(conn, samples_per_bucket)
    print(f"Found {len(addresses)} addresses across buckets\n")

    passed = 0
    failed = 0
    current_bucket = None

    for address, order_count, bucket in addresses:
        if bucket != current_bucket:
            current_bucket = bucket
            print(f"\n--- Bucket: {bucket} ---")

        # Run both queries
        original_result = run_query(conn, ORIGINAL_QUERY, address)
        optimized_result = run_query(conn, OPTIMIZED_QUERY, address)

        # Compare
        match, reason = compare_results(original_result, optimized_result)

        addr_hex = "0x" + address.hex() if isinstance(address, (bytes, memoryview)) else str(address)
        status = "✓" if match else "✗"

        print(f"  {status} {addr_hex[:18]}... ({order_count:>5} orders): {reason}")

        if match:
            passed += 1
        else:
            failed += 1
            # Print detailed values on failure
            print(f"      Original:  {original_result}")
            print(f"      Optimized: {optimized_result}")

    # Summary
    print("\n" + "=" * 80)
    print(f"SUMMARY: {passed} passed, {failed} failed out of {passed + failed} tests")

    conn.close()

    return 0 if failed == 0 else 1


if __name__ == "__main__":
    sys.exit(main())
```

</p>
</details>

To validate the performance, I think it's best we give it a run in prod
for anywhere from 30 minutes to 2 hours.
Even while requiring indexes, the new query *should* be faster.
---
 .../orderbook/src/database/total_surplus.rs   | 119 ++++++++++--------
 database/README.md                            |  11 ++
 ...__create_convering_indexes_for_surplus.sql |   3 +
 3 files changed, 82 insertions(+), 51 deletions(-)
 create mode 100644 database/sql/V103__create_convering_indexes_for_surplus.sql

diff --git a/crates/orderbook/src/database/total_surplus.rs b/crates/orderbook/src/database/total_surplus.rs
index 3fc446fa1c..d90a16c0a7 100644
--- a/crates/orderbook/src/database/total_surplus.rs
+++ b/crates/orderbook/src/database/total_surplus.rs
@@ -9,76 +9,93 @@ use {
 /// and **NOT** quoted price) since march 2023.
 async fn fetch_total_surplus(ex: &mut PgConnection, user: &Address) -> Result<f64, sqlx::Error> {
     const TOTAL_SURPLUS_QUERY: &str = r#"
-WITH regular_orders AS (
-    SELECT ARRAY_AGG(uid) AS ids FROM orders WHERE owner = $1
-),
-onchain_orders AS (
-    SELECT ARRAY_AGG(uid) AS ids FROM onchain_placed_orders WHERE sender = $1
-),
-trade_components AS (
+WITH trade_components AS (
     SELECT
-       CASE kind
-          -- so much was actually bought
-          WHEN 'sell' THEN t.buy_amount
-          -- so much was actually converted to buy tokens
-          WHEN 'buy' THEN t.sell_amount - t.fee_amount
-       END AS trade_amount,
-       CASE kind
-          -- so much had to be bought at least (given exeucted amount and limit price)
-          WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * o.buy_amount / o.sell_amount
-          -- so much could be converted to buy_token at most (given executed amount and limit price)
-          WHEN 'buy' THEN t.buy_amount * o.sell_amount / o.buy_amount
-       END AS limit_amount,
-       o.kind,
-       CASE kind
-          WHEN 'sell' THEN (SELECT price FROM auction_prices ap WHERE ap.token = o.buy_token AND ap.auction_id = oe.auction_id)
-          WHEN 'buy' THEN (SELECT price FROM auction_prices ap WHERE ap.token = o.sell_token AND ap.auction_id = oe.auction_id)
-       END AS surplus_token_native_price
+        o.uid,
+        CASE o.kind
+            WHEN 'sell' THEN t.buy_amount
+            WHEN 'buy' THEN t.sell_amount - t.fee_amount
+        END AS trade_amount,
+        CASE o.kind
+            WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * o.buy_amount / o.sell_amount
+            WHEN 'buy' THEN t.buy_amount * o.sell_amount / o.buy_amount
+        END AS limit_amount,
+        o.kind,
+        ap.price AS surplus_token_native_price
     FROM orders o
-    JOIN trades t ON o.uid = t.order_uid
-    JOIN order_execution oe ON o.uid = oe.order_uid
-    -- use this weird construction instead of `where owner=address or sender=address` to help postgres make efficient use of indices
-    WHERE uid = ANY(ARRAY_CAT((SELECT ids FROM regular_orders), (SELECT ids FROM onchain_orders)))
+    JOIN trades t ON t.order_uid = o.uid
+    JOIN order_execution oe ON oe.order_uid = t.order_uid
+    LEFT JOIN auction_prices ap
+        ON ap.auction_id = oe.auction_id
+        AND ap.token = CASE o.kind WHEN 'sell' THEN o.buy_token ELSE o.sell_token END
+    WHERE o.owner = $1
+
+    UNION ALL
+
+    SELECT
+        o.uid,
+        CASE o.kind
+            -- so much was actually bought
+            WHEN 'sell' THEN t.buy_amount
+            -- so much was actually converted to buy tokens
+            WHEN 'buy' THEN t.sell_amount - t.fee_amount
+        END AS trade_amount,
+        CASE o.kind
+            -- so much had to be bought at least (given executed amount and limit price)
+            WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * o.buy_amount / o.sell_amount
+            -- so much could be converted to buy_token at most (given executed amount and limit price)
+            WHEN 'buy' THEN t.buy_amount * o.sell_amount / o.buy_amount
+        END AS limit_amount,
+        o.kind,
+        ap.price AS surplus_token_native_price
+    FROM onchain_placed_orders opo
+    JOIN orders o ON o.uid = opo.uid AND o.owner != $1
+    JOIN trades t ON t.order_uid = o.uid
+    JOIN order_execution oe ON oe.order_uid = t.order_uid
+    LEFT JOIN auction_prices ap
+        ON ap.auction_id = oe.auction_id
+        AND ap.token = CASE o.kind WHEN 'sell' THEN o.buy_token ELSE o.sell_token END
+    WHERE opo.sender = $1
 
     UNION ALL
 
     -- Additional query for jit_orders
     SELECT
-       CASE j.kind
-          WHEN 'sell' THEN t.buy_amount
-          WHEN 'buy' THEN t.sell_amount - t.fee_amount
-       END AS trade_amount,
-       CASE j.kind
-          WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * j.buy_amount / j.sell_amount
-          WHEN 'buy' THEN t.buy_amount * j.sell_amount / j.buy_amount
-       END AS limit_amount,
-       j.kind,
-       CASE j.kind
-          WHEN 'sell' THEN (SELECT price FROM auction_prices ap WHERE ap.token = j.buy_token AND ap.auction_id = oe.auction_id)
-          WHEN 'buy' THEN (SELECT price FROM auction_prices ap WHERE ap.token = j.sell_token AND ap.auction_id = oe.auction_id)
-       END AS surplus_token_native_price
+        j.uid,
+        CASE j.kind
+            WHEN 'sell' THEN t.buy_amount
+            WHEN 'buy' THEN t.sell_amount - t.fee_amount
+        END AS trade_amount,
+        CASE j.kind
+            WHEN 'sell' THEN (t.sell_amount - t.fee_amount) * j.buy_amount / j.sell_amount
+            WHEN 'buy' THEN t.buy_amount * j.sell_amount / j.buy_amount
+        END AS limit_amount,
+        j.kind,
+        ap.price AS surplus_token_native_price
     FROM jit_orders j
     JOIN trades t ON j.uid = t.order_uid
-    JOIN order_execution oe ON j.uid = oe.order_uid
-    WHERE j.owner = $1 AND NOT EXISTS (
+    JOIN order_execution oe ON t.order_uid = oe.order_uid
+    LEFT JOIN auction_prices ap
+        ON ap.auction_id = oe.auction_id
+        AND ap.token = CASE j.kind WHEN 'sell' THEN j.buy_token ELSE j.sell_token END
+    WHERE j.owner = $1
+      AND NOT EXISTS (
         SELECT 1
         FROM orders o
         WHERE o.uid = j.uid
     )
-),
-trade_surplus AS (
+)
+SELECT
+    COALESCE(SUM(surplus_in_wei ORDER BY uid), 0) AS total_surplus_in_wei
+FROM (
     SELECT
+        uid,
         CASE kind
-            -- amounts refer to tokens bought; more is better
             WHEN 'sell' THEN (trade_amount - limit_amount) * surplus_token_native_price
-            -- amounts refer to tokens sold; less is better
             WHEN 'buy' THEN (limit_amount - trade_amount) * surplus_token_native_price
         END / POWER(10, 18) AS surplus_in_wei
     FROM trade_components
-)
-SELECT
-   COALESCE(SUM(surplus_in_wei), 0) AS total_surplus_in_wei
-FROM trade_surplus
+) ts;
 "#;
 
     sqlx::query_scalar(TOTAL_SURPLUS_QUERY)
diff --git a/database/README.md b/database/README.md
index 155d6731f7..206b169c97 100644
--- a/database/README.md
+++ b/database/README.md
@@ -8,6 +8,7 @@ Some tables only store data emitted via smart contract events. Because we only h
 [CoWSwapEthFlow](https://github.com/cowprotocol/ethflowcontract/blob/main/src/CoWSwapEthFlow.sol) we actually deployed twice so events related to the staging environment should only show up in the staging DB and likewise for production.
 It's also important to note that we only index events from blocks that we are certain will not get reorged. That means specifically that events will be indexed with a block delay of at least 64.
 
+
 ### app\_data
 
 Associates the 32 bytes contract app data with the corresponding full app data.
@@ -626,3 +627,13 @@ We support different expiration times for orders with different signing schemes.
  market    | Short lived order that may receive surplus. Users agree to a static fee upfront by signing it.
  liquidity | These orders must be traded at their limit price and may not receive any surplus. Violating this is a slashable offence.
  limit     | Long lived order that may receive surplus. Users sign a static fee of 0 upfront and either the backend or the solvers compute a dynamic fee that gets taken from the surplus (while still respecting the user's limit price!).
+
+## Notes on Migrations
+
+Migrations that require a long running process *must* be done manually, this is due to the limitations the weekly release process imposes:
+* The deployment must complete under 5 minutes
+* The pod has a `processDeadlineSeconds` defaulting to 600 seconds
+
+To avoid extending the process, we resort to manually applying complicated migrations.
+
+The above also comes into play when dealing with indexes, as their construction with flyway may lock up rows, degrading SLI.
diff --git a/database/sql/V103__create_convering_indexes_for_surplus.sql b/database/sql/V103__create_convering_indexes_for_surplus.sql
new file mode 100644
index 0000000000..d6e783f055
--- /dev/null
+++ b/database/sql/V103__create_convering_indexes_for_surplus.sql
@@ -0,0 +1,3 @@
+-- covering indexes to avoid IO when calculating the total surplus for users
+CREATE INDEX CONCURRENTLY IF NOT EXISTS trades_covering ON trades (order_uid) INCLUDE (buy_amount, sell_amount, fee_amount);
+CREATE INDEX CONCURRENTLY IF NOT EXISTS orders_owner_covering ON orders (owner) INCLUDE (uid, kind, buy_amount, sell_amount, fee_amount, buy_token, sell_token);

From f8087e5b4c1904059741d91a8c93e687ce4d446e Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 6 Feb 2026 12:18:55 +0100
Subject: [PATCH 038/219] Filter refunded ethflow orders from all solvable
 orders query (#4129)

# Description
In a recent change the query to return ALL solvable orders suddenly
returned ~45K orders more. This caused an increased memory usage on the
start of the autopilot and made the DB query slower than it could be.

# Changes
Filter out refunded ethflow orders from solvable orders query.

## How to test
confirmed with a manual query execution that the number of returned
orders is in line with the final_auction_size + filtered_out_queries
indicating that the all_solvable_orders query and the incremental logic
afterwards agree with each other.

increase in memory usage
<img width="1474" height="376" alt="Screenshot 2026-02-06 at 10 45 44"
src="https://github.com/user-attachments/assets/feb15290-d848-485e-8526-523d40605dcf"
/>

first auction after restart is huge
<img width="857" height="331" alt="Screenshot 2026-02-06 at 10 53 45"
src="https://github.com/user-attachments/assets/e486f253-d9ce-44a1-b64b-8b03b31172e3"
/>
---
 crates/database/src/orders.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index 8da392897a..62be3eae81 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -729,6 +729,7 @@ pub fn solvable_orders(
             AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
+            AND NOT EXISTS (SELECT 1 FROM ethflow_refunds r WHERE r.order_uid = o.uid)
     ),
     trades_agg AS (
         SELECT t.order_uid,

From 0474b7e0b6d6248dd53172c38a952f3ee2075944 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 6 Feb 2026 14:24:14 +0300
Subject: [PATCH 039/219] Upgrade `time` crate (#4130)

Upgrades the `time` crate to satisfy `cargo audit`.
---
 Cargo.lock | 18 +++++++++---------
 Cargo.toml |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8dd5ec4ef7..423221c014 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2538,7 +2538,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ab67060fc6b8ef687992d439ca0fa36e7ed17e9a0b16b25b601e8757df720de"
 dependencies = [
  "data-encoding",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -4436,9 +4436,9 @@ dependencies = [
 
 [[package]]
 name = "num-conv"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
 
 [[package]]
 name = "num-integer"
@@ -6871,9 +6871,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.45"
+version = "0.3.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9e442fc33d7fdb45aa9bfeb312c095964abdf596f7567261062b2a7107aaabd"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
 dependencies = [
  "deranged",
  "itoa",
@@ -6888,15 +6888,15 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b36ee98fd31ec7426d599183e8fe26932a8dc1fb76ddb6214d05493377d34ca"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
 
 [[package]]
 name = "time-macros"
-version = "0.2.25"
+version = "0.2.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71e552d1249bf61ac2a52db88179fd0673def1e1ad8243a00d9ec9ed71fee3dd"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
 dependencies = [
  "num-conv",
  "time-core",
diff --git a/Cargo.toml b/Cargo.toml
index 773660c1ac..1853a4e068 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -92,7 +92,7 @@ solvers = { path = "crates/solvers" }
 solvers-dto = { path = "crates/solvers-dto" }
 testlib = { path = "crates/testlib" }
 winner-selection = { path = "crates/winner-selection" }
-time = "0.3.37"
+time = "0.3.47"
 tiny-keccak = "2.0.2"
 tower = "0.4"
 tower-http = "0.4"

From 950180e2b5911a2980dce9192e3be3ef42673862 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 6 Feb 2026 12:59:34 +0100
Subject: [PATCH 040/219] Tighter filter on all solvable orders query (#4131)

# Description
Forgot that I already hit `merge when ready` on
https://github.com/cowprotocol/services/pull/4129 so I was to slow to
merge the same optimization for the open orders query.
---
 crates/database/src/orders.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index 62be3eae81..ce95a6d913 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -967,6 +967,7 @@ pub async fn user_orders_with_quote(
             AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)
+            AND NOT EXISTS (SELECT 1 FROM ethflow_refunds r WHERE r.order_uid = o.uid)
             AND  o.owner = $2
             AND  o.class = 'limit'
     )

From 2f144c6545c83597cf15eb07a2687d4e0f73bd71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Fri, 6 Feb 2026 12:02:31 +0000
Subject: [PATCH 041/219] Do not panic on failure to acquire connections to
 store events (#4132)

# Description
During a particularly bad period of volatility we failed to acquire a DB
connection on time which lead to a panic

<details><summary>Partial Stacktrace</summary>
<p>

```
1770314825856	2026-02-05T18:07:05.856Z	2026-02-05T18:07:03.033Z ERROR observe::tracing: thread 'tokio-runtime-worker' panicked at /src/crates/autopilot/src/infra/persistence/mod.rs:301:54:
1770314825856	2026-02-05T18:07:05.856Z	failed to acquire tx: PoolTimedOut
1770314825856	2026-02-05T18:07:05.856Z	stack backtrace:
1770314825856	2026-02-05T18:07:05.856Z	   0: observe::tracing::tracing_panic_hook
1770314825856	2026-02-05T18:07:05.856Z	             at ./src/crates/observe/src/tracing.rs:187:21
1770314825856	2026-02-05T18:07:05.856Z	   1: <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/alloc/src/boxed.rs:2220:9
1770314825856	2026-02-05T18:07:05.856Z	   2: observe::panic_hook::install::{{closure}}
1770314825856	2026-02-05T18:07:05.856Z	             at ./src/crates/observe/src/panic_hook.rs:14:9
1770314825856	2026-02-05T18:07:05.856Z	   3: <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/alloc/src/boxed.rs:2220:9
1770314825856	2026-02-05T18:07:05.856Z	   4: std::panicking::panic_with_hook
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/std/src/panicking.rs:833:13
1770314825856	2026-02-05T18:07:05.856Z	   5: std::panicking::panic_handler::{{closure}}
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/std/src/panicking.rs:698:13
1770314825856	2026-02-05T18:07:05.856Z	   6: std::sys::backtrace::__rust_end_short_backtrace
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/std/src/sys/backtrace.rs:176:18
1770314825856	2026-02-05T18:07:05.856Z	   7: __rustc::rust_begin_unwind
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/std/src/panicking.rs:689:5
1770314825856	2026-02-05T18:07:05.856Z	   8: core::panicking::panic_fmt
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/core/src/panicking.rs:80:14
1770314825856	2026-02-05T18:07:05.856Z	   9: core::result::unwrap_failed
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/core/src/result.rs:1867:5
1770314825856	2026-02-05T18:07:05.856Z	  10: core::result::Result<T,E>::expect
1770314825856	2026-02-05T18:07:05.856Z	             at ./rustc/254b59607d4417e9dffbc307138ae5c86280fe4c/library/core/src/result.rs:1185:23
1770314825856	2026-02-05T18:07:05.856Z	  11: autopilot::infra::persistence::Persistence::store_order_events::{{closure}}
1770314825856	2026-02-05T18:07:05.856Z	             at ./src/crates/autopilot/src/infra/persistence/mod.rs:301:54
```

</p>
</details>

# Changes

- [ ] Remove the panic
- [ ] Log on error and continue

## How to test
NA
---
 crates/autopilot/src/infra/persistence/mod.rs | 13 +++++++++++--
 crates/database/src/orders.rs                 |  1 +
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index c6fcf7e4d7..3f3d0b2f5f 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -298,8 +298,17 @@ impl Persistence {
         let order_uids = order_uids.into_iter().collect();
         tokio::spawn(
             async move {
-                let mut tx = db.pool.acquire().await.expect("failed to acquire tx");
-                store_order_events(&mut tx, order_uids, label, Utc::now()).await;
+                match db.pool.acquire().await {
+                    Ok(mut tx) => {
+                        store_order_events(&mut tx, order_uids, label, Utc::now()).await;
+                    }
+                    Err(err) => {
+                        tracing::error!(
+                            ?err,
+                            "failed to acquire a connection to store order events!"
+                        );
+                    }
+                };
             }
             .instrument(tracing::Span::current()),
         );
diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index ce95a6d913..c318393123 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -964,6 +964,7 @@ pub async fn user_orders_with_quote(
         FROM   orders o
         WHERE  o.cancellation_timestamp IS NULL
             AND o.true_valid_to >= $1
+            AND NOT EXISTS (SELECT 1 FROM ethflow_refunds r WHERE r.order_uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM invalidations i WHERE i.order_uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM onchain_order_invalidations oi WHERE oi.uid = o.uid)
             AND NOT EXISTS (SELECT 1 FROM onchain_placed_orders op WHERE op.uid = o.uid AND op.placement_error IS NOT NULL)

From a0b65c1b03f8de9a1e9f29ad4d1af3873266fd58 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 6 Feb 2026 18:13:51 +0300
Subject: [PATCH 042/219] Normalize approximation native token decimals (#4125)

# Description
Instead of validating that native price approximation token pairs have
matching decimals at startup, this PR normalizes prices based on the
decimal difference between tokens, as was suggested in another PR
comment[[link](https://github.com/cowprotocol/services/pull/4119#pullrequestreview-3749864175)].

# Changes
- Added `ApproximationToken` type that stores both the approximation
address and a normalization factor `(10^(to_decimals - from_decimals))`
- Factory fetches decimals for all approximation token pairs at startup
and computes normalization factors
- Price approximation now multiplies the fetched price by the
normalization factor, correctly handling tokens with different decimals

## How to test
Added unit tests for normalization in both directions (source > target
decimals and target > source decimals)
---
 crates/autopilot/src/solvable_orders.rs       |   6 +-
 crates/shared/src/price_estimation/factory.rs |  57 ++++++-
 crates/shared/src/price_estimation/mod.rs     |   3 -
 .../price_estimation/native_price_cache.rs    | 155 +++++++++++++++++-
 4 files changed, 202 insertions(+), 19 deletions(-)

diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 458aab5523..db46801587 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -913,6 +913,7 @@ mod tests {
                 HEALTHY_PRICE_ESTIMATION_TIME,
                 PriceEstimationError,
                 native::MockNativePriceEstimating,
+                native_price_cache::ApproximationToken,
             },
             signature_validator::{MockSignatureValidating, SignatureValidationError},
         },
@@ -1151,7 +1152,10 @@ mod tests {
             Default::default(),
             3,
             // Set to use native price approximations for the following tokens
-            HashMap::from([(token1, token_approx1), (token2, token_approx2)]),
+            HashMap::from([
+                (token1, ApproximationToken::same_decimals(token_approx1)),
+                (token2, ApproximationToken::same_decimals(token_approx2)),
+            ]),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
         let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index 305ecc11e8..195df20563 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -7,7 +7,7 @@ use {
         external::ExternalPriceEstimator,
         instrumented::InstrumentedPriceEstimator,
         native::{self, NativePriceEstimator},
-        native_price_cache::CachingNativePriceEstimator,
+        native_price_cache::{ApproximationToken, CachingNativePriceEstimator},
         sanitized::SanitizedPriceEstimator,
         trade_verifier::{TradeVerifier, TradeVerifying},
     },
@@ -384,6 +384,10 @@ impl<'a> PriceEstimatorFactory<'a> {
             CompetitionEstimator::new(estimators, PriceRanking::MaxOutAmount)
                 .with_verification(self.args.quote_verification)
                 .with_early_return(results_required);
+        let approximation_tokens = self.build_approximation_tokens().await.context(
+            "failed to build native price approximation tokens with normalization factors",
+        )?;
+
         let native_estimator = Arc::new(CachingNativePriceEstimator::new(
             Box::new(competition_estimator),
             self.args.native_price_cache_max_age,
@@ -391,15 +395,56 @@ impl<'a> PriceEstimatorFactory<'a> {
             Some(self.args.native_price_cache_max_update_size),
             self.args.native_price_prefetch_time,
             self.args.native_price_cache_concurrent_requests,
-            self.args
-                .native_price_approximation_tokens
-                .iter()
-                .copied()
-                .collect(),
+            approximation_tokens,
             self.args.quote_timeout,
         ));
         Ok(native_estimator)
     }
+
+    /// Builds the approximation tokens mapping with normalization factors based
+    /// on decimal differences between token pairs.
+    async fn build_approximation_tokens(&self) -> Result<HashMap<Address, ApproximationToken>> {
+        let pairs = &self.args.native_price_approximation_tokens;
+        if pairs.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        // Collect all unique addresses to fetch their decimals
+        let all_addresses: Vec<Address> = pairs
+            .iter()
+            .flat_map(|(from, to)| [*from, *to])
+            .collect::<std::collections::HashSet<_>>()
+            .into_iter()
+            .collect();
+
+        let token_infos = self.components.tokens.get_token_infos(&all_addresses).await;
+
+        let mut approximation_tokens = HashMap::new();
+        for (from_token, to_token) in pairs {
+            let from_decimals = token_infos
+                .get(from_token)
+                .and_then(|info| info.decimals)
+                .with_context(|| {
+                    format!(
+                        "could not fetch decimals for approximation source token {from_token:?}"
+                    )
+                })?;
+
+            let to_decimals = token_infos
+                .get(to_token)
+                .and_then(|info| info.decimals)
+                .with_context(|| {
+                    format!("could not fetch decimals for approximation target token {to_token:?}")
+                })?;
+
+            approximation_tokens.insert(
+                *from_token,
+                ApproximationToken::with_normalization((*to_token, to_decimals), from_decimals),
+            );
+        }
+
+        Ok(approximation_tokens)
+    }
 }
 
 /// Trait for modelling the initialization of a Price estimator and its verified
diff --git a/crates/shared/src/price_estimation/mod.rs b/crates/shared/src/price_estimation/mod.rs
index 6c5ae2251b..1535c742cc 100644
--- a/crates/shared/src/price_estimation/mod.rs
+++ b/crates/shared/src/price_estimation/mod.rs
@@ -260,9 +260,6 @@ pub struct Arguments {
     /// "<token1>|<approx_token1>,<token2>|<approx_token2>"
     /// - token1 is a token address for which we get the native token price
     /// - approx_token1 is a token address used for the price approximation
-    ///
-    /// It is very important that both tokens in the pair have the same number
-    /// of decimals.
     #[clap(
         long,
         env,
diff --git a/crates/shared/src/price_estimation/native_price_cache.rs b/crates/shared/src/price_estimation/native_price_cache.rs
index 5e95f7e45f..bf49185402 100644
--- a/crates/shared/src/price_estimation/native_price_cache.rs
+++ b/crates/shared/src/price_estimation/native_price_cache.rs
@@ -20,6 +20,47 @@ use {
     tracing::{Instrument, instrument},
 };
 
+/// Represents a token used for price approximation, including the normalization
+/// factor needed to convert between tokens with potentially different decimals.
+#[derive(Debug, Clone, Copy)]
+pub struct ApproximationToken {
+    /// The address of the token to use for price approximation.
+    pub address: Address,
+    /// The factor to multiply the approximated price by to normalize for
+    /// decimal differences. Computed as 10^(to_decimals - from_decimals).
+    pub normalization_factor: f64,
+}
+
+impl ApproximationToken {
+    /// Creates an approximation token with no decimal normalization needed
+    /// (both tokens have the same decimals).
+    pub fn same_decimals(address: Address) -> Self {
+        Self {
+            address,
+            normalization_factor: 1.0,
+        }
+    }
+
+    /// Creates an approximation token with the specified normalization factor.
+    /// The normalization factor converts prices from the approximation token's
+    /// decimal basis to the source token's decimal basis.
+    pub fn with_normalization(
+        (peg_token, peg_token_decimals): (Address, u8),
+        token_decimals: u8,
+    ) -> Self {
+        let decimals_diff = i32::from(peg_token_decimals) - i32::from(token_decimals);
+        Self {
+            address: peg_token,
+            normalization_factor: 10f64.powi(decimals_diff),
+        }
+    }
+
+    /// Applies the normalization factor to a price.
+    pub fn normalize_price(&self, price: f64) -> f64 {
+        price * self.normalization_factor
+    }
+}
+
 #[derive(prometheus_metric_storage::MetricStorage)]
 struct Metrics {
     /// native price cache hits misses
@@ -61,9 +102,9 @@ struct Inner {
     /// This can be useful for tokens that are hard to route but are pegged to
     /// the same underlying asset so approximating their native prices is deemed
     /// safe (e.g. csUSDL => Dai).
-    /// It's very important that the 2 tokens have the same number of decimals.
+    /// The normalization factor handles decimal differences between tokens.
     /// After startup this is a read only value.
-    approximation_tokens: HashMap<Address, Address>,
+    approximation_tokens: HashMap<Address, ApproximationToken>,
     quote_timeout: Duration,
 }
 
@@ -191,12 +232,17 @@ impl Inner {
                 }
             };
 
-            let token_to_fetch = *self.approximation_tokens.get(token).unwrap_or(token);
+            let approximation = self
+                .approximation_tokens
+                .get(token)
+                .copied()
+                .unwrap_or(ApproximationToken::same_decimals(*token));
 
             let result = self
                 .estimator
-                .estimate_native_price(token_to_fetch, request_timeout)
-                .await;
+                .estimate_native_price(approximation.address, request_timeout)
+                .await
+                .map(|price| approximation.normalize_price(price));
 
             // update price in cache
             if should_cache(&result) {
@@ -341,7 +387,7 @@ impl CachingNativePriceEstimator {
         update_size: Option<usize>,
         prefetch_time: Duration,
         concurrent_requests: usize,
-        approximation_tokens: HashMap<Address, Address>,
+        approximation_tokens: HashMap<Address, ApproximationToken>,
         quote_timeout: Duration,
     ) -> Self {
         let inner = Arc::new(Inner {
@@ -582,10 +628,16 @@ mod tests {
             None,
             Default::default(),
             1,
-            // set token approximations for tokens 1 and 2
+            // set token approximations for tokens 1 and 2 (same decimals)
             HashMap::from([
-                (Address::with_last_byte(1), Address::with_last_byte(100)),
-                (Address::with_last_byte(2), Address::with_last_byte(200)),
+                (
+                    Address::with_last_byte(1),
+                    ApproximationToken::same_decimals(Address::with_last_byte(100)),
+                ),
+                (
+                    Address::with_last_byte(2),
+                    ApproximationToken::same_decimals(Address::with_last_byte(200)),
+                ),
             ]),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
@@ -622,6 +674,91 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn approximation_normalizes_when_target_has_more_decimals() {
+        // Scenario: Token 1 is USDC-like (6 decimals), approximated by DAI-like token
+        // 100 (18 decimals) Both worth $1, so they're pegged 1:1 in value
+        let mut inner = MockNativePriceEstimating::new();
+        // DAI-like token returns price of 5e-22 ETH per wei (smallest unit)
+        inner
+            .expect_estimate_native_price()
+            .times(1)
+            .withf(move |t, _| *t == token(100))
+            .returning(|_, _| async { Ok(5e-22) }.boxed());
+
+        // from_decimals=6 (USDC), to_decimals=18 (DAI)
+        // Normalization factor = 10^(18-6) = 10^12
+        // Price should be 5e-22 * 10^12 = 5e-10 ETH per USDC microunit
+        let estimator = CachingNativePriceEstimator::new(
+            Box::new(inner),
+            Duration::from_millis(30),
+            Default::default(),
+            None,
+            Default::default(),
+            1,
+            HashMap::from([(
+                Address::with_last_byte(1),
+                ApproximationToken::with_normalization((Address::with_last_byte(100), 18), 6),
+            )]),
+            HEALTHY_PRICE_ESTIMATION_TIME,
+        );
+
+        let price = estimator
+            .estimate_native_price(Address::with_last_byte(1), HEALTHY_PRICE_ESTIMATION_TIME)
+            .await
+            .unwrap();
+        // 5e-22 * 10^12 = 5e-10
+        // Note: small floating point error due to 10^12 not being exactly representable
+        let expected = 5e-10;
+        assert!(
+            (price - expected).abs() / expected < f64::EPSILON,
+            "price {price} not within relative epsilon of {expected}"
+        );
+    }
+
+    #[tokio::test]
+    async fn approximation_normalizes_when_target_has_fewer_decimals() {
+        // Scenario: Token 1 is DAI-like (18 decimals), approximated by USDC-like token
+        // 100 (6 decimals) Both worth $1, so they're pegged 1:1 in value
+        let mut inner = MockNativePriceEstimating::new();
+        // USDC-like token returns price of 5e-10 ETH per microunit (smallest unit)
+        inner
+            .expect_estimate_native_price()
+            .times(1)
+            .withf(move |t, _| *t == token(100))
+            .returning(|_, _| async { Ok(5e-10) }.boxed());
+
+        // from_decimals=18 (DAI), to_decimals=6 (USDC)
+        // Normalization factor = 10^(6-18) = 10^-12
+        // Price should be 5e-10 * 10^-12 = 5e-22 ETH per DAI wei
+        let estimator = CachingNativePriceEstimator::new(
+            Box::new(inner),
+            Duration::from_millis(30),
+            Default::default(),
+            None,
+            Default::default(),
+            1,
+            HashMap::from([(
+                Address::with_last_byte(1),
+                ApproximationToken::with_normalization((Address::with_last_byte(100), 6), 18),
+            )]),
+            HEALTHY_PRICE_ESTIMATION_TIME,
+        );
+
+        let price = estimator
+            .estimate_native_price(Address::with_last_byte(1), HEALTHY_PRICE_ESTIMATION_TIME)
+            .await
+            .unwrap();
+        // 5e-10 * 10^-12 = 5e-22
+        // Note: small floating point error due to 10^-12 not being exactly
+        // representable
+        let expected = 5e-22;
+        assert!(
+            (price - expected).abs() / expected < f64::EPSILON,
+            "price {price} not within relative epsilon of {expected}"
+        );
+    }
+
     #[tokio::test]
     async fn caches_nonrecoverable_failed_estimates() {
         let mut inner = MockNativePriceEstimating::new();

From 0512c46141dcf8815b2c47c330158cc49b5534ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Fri, 6 Feb 2026 16:06:25 +0000
Subject: [PATCH 043/219] Create composite index orders(owner, class,
 true_valid_to) (#4133)

# Description
The create_order endpoint is suffering from latency issues due to the
`user_orders_with_quote` being super slow (we've seen up to 50s), this
PR adds an index and removes the MATERIALIZE keyword to provide more
optimization opportunities for the query planner

<details><summary>Plan before</summary>
<p>

```
Nested Loop  (cost=29.14..122.50 rows=1 width=58) (actual time=0.036..0.038 rows=0 loops=1)
  Buffers: shared hit=4
  ->  Nested Loop Anti Join  (cost=28.58..113.92 rows=1 width=79) (actual time=0.036..0.037 rows=0 loops=1)
        Buffers: shared hit=4
        ->  Nested Loop Anti Join  (cost=28.44..97.75 rows=1 width=79) (actual time=0.036..0.037 rows=0 loops=1)
              Buffers: shared hit=4
              ->  Nested Loop Anti Join  (cost=28.17..89.44 rows=1 width=79) (actual time=0.036..0.037 rows=0 loops=1)
                    Buffers: shared hit=4
                    ->  Nested Loop Anti Join  (cost=27.89..73.21 rows=1 width=79) (actual time=0.036..0.037 rows=0 loops=1)
                          Buffers: shared hit=4
                          ->  Bitmap Heap Scan on orders o  (cost=27.62..64.90 rows=1 width=79) (actual time=0.035..0.036 rows=0 loops=1)
                                Recheck Cond: ((true_valid_to >= '4294967295'::bigint) AND (owner = '\xfd659bc79a2b542728e3f372870d22ed31358ed6'::bytea))
                                Filter: ((cancellation_timestamp IS NULL) AND (class = 'limit'::orderclass) AND (((kind = 'sell'::orderkind) AND (COALESCE((SubPlan 1), '0'::numeric) < sell_amount)) OR ((kind = 'buy'::orderkind) AND (COALESCE((SubPlan 2), '0'::numeric) < buy_amount))))
                                Buffers: shared hit=4
                                ->  BitmapAnd  (cost=27.62..27.62 rows=1 width=0) (actual time=0.033..0.034 rows=0 loops=1)
                                      Buffers: shared hit=4
                                      ->  Bitmap Index Scan on orders_true_valid_to  (cost=0.00..4.51 rows=10 width=0) (actual time=0.023..0.023 rows=312 loops=1)
                                            Index Cond: (true_valid_to >= '4294967295'::bigint)
                                            Buffers: shared hit=3
                                      ->  Bitmap Index Scan on order_owner  (cost=0.00..22.86 rows=381 width=0) (actual time=0.003..0.003 rows=0 loops=1)
                                            Index Cond: (owner = '\xfd659bc79a2b542728e3f372870d22ed31358ed6'::bytea)
                                            Buffers: shared hit=1
                                SubPlan 1
                                  ->  Aggregate  (cost=16.62..16.63 rows=1 width=32) (never executed)
                                        ->  Index Scan using trade_order_uid on trades  (cost=0.56..16.61 rows=3 width=11) (never executed)
                                              Index Cond: (order_uid = o.uid)
                                SubPlan 2
                                  ->  Aggregate  (cost=16.62..16.63 rows=1 width=32) (never executed)
                                        ->  Index Scan using trade_order_uid on trades trades_1  (cost=0.56..16.61 rows=3 width=11) (never executed)
                                              Index Cond: (order_uid = o.uid)
                          ->  Index Only Scan using ethflow_refunds_pkey on ethflow_refunds r  (cost=0.27..4.29 rows=1 width=57) (never executed)
                                Index Cond: (order_uid = o.uid)
                                Heap Fetches: 0
                    ->  Index Only Scan using invalidations_order_uid on invalidations i  (cost=0.28..8.29 rows=1 width=57) (never executed)
                          Index Cond: (order_uid = o.uid)
                          Heap Fetches: 0
              ->  Index Only Scan using onchain_order_invalidations_pkey on onchain_order_invalidations oi  (cost=0.27..4.29 rows=1 width=57) (never executed)
                    Index Cond: (uid = o.uid)
                    Heap Fetches: 0
        ->  Index Only Scan using okay_onchain_orders on onchain_placed_orders op  (cost=0.14..8.16 rows=1 width=57) (never executed)
              Index Cond: (uid = o.uid)
              Heap Fetches: 0
  ->  Index Scan using order_quotes_pkey on order_quotes o_quotes  (cost=0.56..8.57 rows=1 width=93) (never executed)
        Index Cond: (order_uid = o.uid)
Planning:
  Buffers: shared hit=95
Planning Time: 0.816 ms
Execution Time: 0.101 ms
```

</p>
</details>

<details><summary>Plan after</summary>
<p>

```
Hash Anti Join  (cost=2977.50..115918.76 rows=1386 width=67) (actual time=0.012..0.014 rows=0 loops=1)
  Hash Cond: (o.uid = op.uid)
  Buffers: shared hit=4
  ->  Hash Anti Join  (cost=2918.73..115842.49 rows=1386 width=124) (actual time=0.012..0.013 rows=0 loops=1)
        Hash Cond: (o.uid = i.order_uid)
        Buffers: shared hit=4
        ->  Nested Loop  (cost=2798.94..115705.20 rows=1386 width=124) (actual time=0.012..0.013 rows=0 loops=1)
              Buffers: shared hit=4
              ->  Hash Anti Join  (cost=2798.38..103609.69 rows=1412 width=81) (actual time=0.012..0.013 rows=0 loops=1)
                    Hash Cond: (o.uid = oi.uid)
                    Buffers: shared hit=4
                    ->  Hash Anti Join  (cost=2186.48..102979.96 rows=1414 width=81) (actual time=0.012..0.012 rows=0 loops=1)
                          Hash Cond: (o.uid = r.order_uid)
                          Buffers: shared hit=4
                          ->  Index Scan using idx_orders_owner_class_valid on orders o  (cost=0.56..100776.17 rows=1419 width=81) (actual time=0.011..0.012 rows=0 loops=1)
                                Index Cond: ((owner = '\xfd659bc79a2b542728e3f372870d22ed31358ed6'::bytea) AND (class = 'limit'::orderclass) AND (true_valid_to >= '4294967295'::bigint))
                                Filter: ((cancellation_timestamp IS NULL) AND (((kind = 'sell'::orderkind) AND (COALESCE((SubPlan 1), '0'::numeric) < sell_amount)) OR ((kind = 'buy'::orderkind) AND (COALESCE((SubPlan 2), '0'::numeric) < buy_amount))))
                                Buffers: shared hit=4
                                SubPlan 1
                                  ->  Aggregate  (cost=8.60..8.61 rows=1 width=32) (never executed)
                                        ->  Index Only Scan using idx_trades_covering on trades  (cost=0.56..8.59 rows=2 width=9) (never executed)
                                              Index Cond: (order_uid = o.uid)
                                              Heap Fetches: 0
                                SubPlan 2
                                  ->  Aggregate  (cost=8.60..8.61 rows=1 width=32) (never executed)
                                        ->  Index Only Scan using idx_trades_covering on trades trades_1  (cost=0.56..8.59 rows=2 width=11) (never executed)
                                              Index Cond: (order_uid = o.uid)
                                              Heap Fetches: 0
                          ->  Hash  (cost=1515.41..1515.41 rows=53641 width=57) (never executed)
                                ->  Seq Scan on ethflow_refunds r  (cost=0.00..1515.41 rows=53641 width=57) (never executed)
                    ->  Hash  (cost=398.62..398.62 rows=17062 width=57) (never executed)
                          ->  Seq Scan on onchain_order_invalidations oi  (cost=0.00..398.62 rows=17062 width=57) (never executed)
              ->  Index Scan using order_quotes_pkey on order_quotes o_quotes  (cost=0.56..8.57 rows=1 width=100) (never executed)
                    Index Cond: (order_uid = o.uid)
        ->  Hash  (cost=78.24..78.24 rows=3324 width=57) (never executed)
              ->  Seq Scan on invalidations i  (cost=0.00..78.24 rows=3324 width=57) (never executed)
  ->  Hash  (cost=53.80..53.80 rows=398 width=57) (never executed)
        ->  Index Only Scan using okay_onchain_orders on onchain_placed_orders op  (cost=0.27..53.80 rows=398 width=57) (never executed)
              Heap Fetches: 0
Planning:
  Buffers: shared hit=95
Planning Time: 0.833 ms
Execution Time: 0.071 ms
```

</p>
</details>

# Changes

- [ ] Adding the composite index
- [ ] Dropping the MATERIALIZE

## How to test
Create index in prod, push a test image, though this should be an easy
win
---
 crates/database/src/orders.rs                 | 2 +-
 database/README.md                            | 3 +++
 database/sql/V104__create_composite_index.sql | 2 ++
 3 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 database/sql/V104__create_composite_index.sql

diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index c318393123..0e661d7729 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -959,7 +959,7 @@ pub async fn user_orders_with_quote(
 ) -> Result<Vec<OrderWithQuote>, sqlx::Error> {
     // Optimized version following the same pattern as OPEN_ORDERS
     const QUERY: &str = r#"
-    WITH live_orders AS MATERIALIZED (
+    WITH live_orders AS (
         SELECT o.*
         FROM   orders o
         WHERE  o.cancellation_timestamp IS NULL
diff --git a/database/README.md b/database/README.md
index 206b169c97..6a15f205d0 100644
--- a/database/README.md
+++ b/database/README.md
@@ -276,6 +276,8 @@ Indexes:
 - user_order_creation_timestamp: btree(`owner`, `creation_timestamp` DESC)
 - version_idx: btree(`settlement_contract`)
 - orders\_true\_valid\_to: btree(`true_valid_to`)
+- orders_owner_covering: btree(`owner`) INCLUDE (`uid`, `kind`, `buy_amount`, `sell_amount`, `fee_amount`, `buy_token`, `sell_token`)
+- orders_owner_class_valid_composite: btree(`owner`, `class`, `true_valid_to` DESC) WHERE cancellation_timestamp IS NULL
 
 ### fee_policies
 
@@ -480,6 +482,7 @@ This table contains data of [`Trade`](https://github.com/cowprotocol/contracts/b
 Indexes:
 - PRIMARY KEY: btree(`block_number`, `log_index`)
 - trade\_order\_uid: btree (`order_uid`, `block_number`, `log_index`)
+- trades_covering: btree(`order_uid`) INCLUDE (`buy_amount`, `sell_amount`, `fee_amount`)
 
 ### surplus\_capturing\_jit\_order\_owners
 
diff --git a/database/sql/V104__create_composite_index.sql b/database/sql/V104__create_composite_index.sql
new file mode 100644
index 0000000000..25c8c3f57f
--- /dev/null
+++ b/database/sql/V104__create_composite_index.sql
@@ -0,0 +1,2 @@
+-- composite index to speed up query for user orders with quote
+CREATE INDEX CONCURRENTLY IF NOT EXISTS orders_owner_class_valid_composite ON orders (owner, class, true_valid_to DESC) WHERE cancellation_timestamp IS NULL;

From b8548195cef5badfd49f71af1feb1f30b976d253 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 9 Feb 2026 23:39:56 +0300
Subject: [PATCH 044/219] Update CLAUDE.md (#4128)

Adds some details about the project that help Claude provide better
results.
---
 CLAUDE.md | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 65 insertions(+), 6 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index c8b776a3dd..0ed24cd9cb 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,6 +18,13 @@ This is a Rust workspace containing multiple services and libraries:
 - **database** - PostgreSQL abstraction and migrations
 - **model** - Serialization models for API
 - **contracts** - Smart contract bindings
+- **ethrpc** - Extended Ethereum RPC client with batching layer
+- **chain** - Blockchain interaction utilities
+- **number** - Numerical type extensions and conversions for 256-bit integers
+- **app-data** - Order metadata validation with 8KB default size limit
+- **alerter** - Monitors orderbook metrics for orders that should be solved but aren't
+- **testlib** - Shared helpers for writing unit and end-to-end tests
+- **observe** - Initialization and helper functions for logging and metrics
 
 ## Architecture Overview
 
@@ -60,7 +67,7 @@ User signs order → Orderbook validates → Autopilot includes in auction
 
 ## Technology Stack
 
-- **Language**: Rust 2021+ Edition
+- **Language**: Rust 2024 Edition
 - **Runtime**: Tokio async
 - **Database**: PostgreSQL with sqlx
 - **Web3**: Alloy
@@ -71,12 +78,39 @@ User signs order → Orderbook validates → Autopilot includes in auction
 - **Protocol Documentation**: https://docs.cow.fi/
   - Technical Reference: API specs and SDK docs
   - Concepts: Protocol fundamentals and architecture
-
-## Testing
-
-- Use `just` commands for running tests (see Justfile)
+- **Alloy (Web3 library)**: Fetch https://alloy.rs/introduction/prompting for an AI-optimized guide covering providers, transactions, contracts, and migration from ethers-rs
+
+## Development Commands
+
+### Testing
+- Use `cargo nextest run` instead of `cargo test` (CI uses nextest and handles global state differently)
+- Run specific test suites:
+  - Unit tests: `cargo nextest run`
+  - Database tests: `cargo nextest run postgres -p orderbook -p database -p autopilot --test-threads 1 --run-ignored ignored-only`
+  - E2E local tests: `cargo nextest run -p e2e local_node --test-threads 1 --failure-output final --run-ignored ignored-only`
+  - E2E forked tests: `cargo nextest run -p e2e forked_node --test-threads 1 --run-ignored ignored-only --failure-output final`
+  - Driver tests: `RUST_MIN_STACK=3145728 cargo nextest run -p driver --test-threads 1 --run-ignored ignored-only`
 - E2E tests available in `crates/e2e`
-- Local development environment in `playground/`
+
+### Testing Requirements
+- PostgreSQL tests require local database: Run `docker compose up -d` first
+- Forked network tests require `anvil` (from Foundry) and RPC URLs
+  - Anvil binary: configurable via `ANVIL_COMMAND` env var (defaults to `"anvil"`, must be in PATH)
+  - Required env vars: `FORK_URL_MAINNET` and `FORK_URL_GNOSIS` (RPC endpoints for forking)
+- Use `--test-threads 1` for database and E2E tests to avoid conflicts
+- CI runs doc-tests, unit tests, DB tests, E2E tests (local and forked), and driver tests
+
+### Linting and Formatting
+- Format: **always** run with the nightly toolchain: `cargo +nightly fmt --all`
+- Spot format: `cargo +nightly fmt -- <path>` (never call stable `cargo fmt`)
+- Lint: `cargo clippy --locked --workspace --all-features --all-targets -- -D warnings`
+- Check format: `cargo +nightly fmt --all -- --check`
+
+### Local Development Environment
+- Start local PostgreSQL: `docker compose up -d`
+- Full playground environment: `docker compose -f playground/docker-compose.fork.yml up -d`
+- For forked network tests, set environment variables: `FORK_URL_MAINNET` and `FORK_URL_GNOSIS`
+- Reset playground: `docker compose -f playground/docker-compose.fork.yml down --remove-orphans --volumes`
 
 ## Directory Structure
 
@@ -87,6 +121,31 @@ playground/     # Local dev environment
 configs/        # Configuration files
 ```
 
+## Workspace Configuration
+
+- Rust Edition 2024
+- Uses workspace dependencies for consistency
+- Tokio-console support: **Only available in playground environment** (set `TOKIO_CONSOLE=true` to activate when running in playground)
+- Production builds do **not** include tokio-console overhead
+- Runtime log filter changes via UNIX socket at `/tmp/log_filter_override_<program_name>_<pid>.sock`
+- Memory allocator: Uses jemalloc by default with built-in heap profiling support (enable at runtime via MALLOC_CONF environment variable). Can optionally use mimalloc via `--features mimalloc-allocator`
+
+## Playground Environment
+
+- Runs in **Fork** mode: anvil forks a real network via `ETH_RPC_URL` (set in `playground/.env`). A clean local network mode is planned but not yet implemented.
+- Access full local development stack with CoW Swap UI at http://localhost:8000
+- CoW Explorer available at http://localhost:8001
+- Orderbook API at http://localhost:8080
+- Database admin (Adminer) at http://localhost:8082
+- Uses test mnemonic: "test test test test test test test test test test test junk"
+- First 10 accounts have 10000 ETH balance by default, set by anvil
+
+## Development Notes
+
+- Binaries support `--help` for comprehensive command documentation
+- OpenAPI documentation available for orderbook, driver, and solver APIs
+- Performance profiling: Only available in playground (requires tokio-console feature + tokio_unstable cfg)
+
 # General Coding Instructions
 
 If there is a test you can run then run it or `cargo check` or `cargo build`; run it after you have made changes.

From 903bcd335435a1decfafe34ed31f515916904520 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 10 Feb 2026 11:09:46 +0100
Subject: [PATCH 045/219] Mount flyway.conf in docker-compose.yaml (#4138)

# Description
Concurrent index creation with flyway requires a configuration parameter
to be set to avoid deadlocks in postgres. This setting was already
configured and shipped in the built docker images but the
`docker-compose.yaml` file that's used to spin up a DB locally for
running e2e tests for example does not mount that file yet which leads
to migrations deadlocking when you run `docker compose up`

# Changes
mount `flyway.conf` in `docker-compose.yaml`.

## How to test
run `docker compose up` from the repo root and check that migrations
finished successfully

<img width="930" height="257" alt="Screenshot 2026-02-10 at 09 59 01"
src="https://github.com/user-attachments/assets/8cc082a4-7d57-4c41-b6da-2195695e453d"
/>
---
 docker-compose.yaml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docker-compose.yaml b/docker-compose.yaml
index a29d1ac6e6..75b479a2a5 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -32,6 +32,9 @@ services:
       - type: bind
         source: ./database/sql/
         target: /flyway/sql
+      - type: bind
+        source: ./database/conf/
+        target: /flyway/conf
 
 volumes:
   postgres:

From adf5fca39fb8f232110158cda947d3765ae0d2c1 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 10 Feb 2026 19:56:17 +0300
Subject: [PATCH 046/219] Fix flaky autopilot follower e2e test (#4139)

# Description
Fixes the flaky autopilot follower e2e test that fails almost always on
#4136. After adding some logs, etc, I could finally find all the
possible race conditions and fix the test assertions.
---
 .github/codeql/codeql-config.yml         |  4 +++
 .github/workflows/codeql.yml             |  1 +
 crates/e2e/tests/e2e/autopilot_leader.rs | 43 +++++++++++++++++++-----
 3 files changed, 40 insertions(+), 8 deletions(-)
 create mode 100644 .github/codeql/codeql-config.yml

diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
new file mode 100644
index 0000000000..3db817d664
--- /dev/null
+++ b/.github/codeql/codeql-config.yml
@@ -0,0 +1,4 @@
+name: "CoW Protocol CodeQL Config"
+
+paths-ignore:
+  - crates/e2e
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 60b13c2982..15e583eb92 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -33,6 +33,7 @@ jobs:
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
+        config-file: .github/codeql/codeql-config.yml
 
     - name: Perform CodeQL Analysis
       uses: github/codeql-action/analyze@181d5eefc20863364f96762470ba6f862bdef56b # v3.29.2
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 7ff1e1fc7d..02f47a2c6d 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -12,7 +12,6 @@ use {
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::order::{OrderCreation, OrderKind},
     number::units::EthUnit,
-    std::time::Duration,
 };
 
 #[tokio::test]
@@ -103,6 +102,7 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
             const_hex::encode(solver2.address())),
         "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2".to_string(),
         "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+        "--metrics-address=0.0.0.0:9591".to_string(),
         "--api-address=0.0.0.0:12089".to_string(),
         "--enable-leader-lock=true".to_string(),
     ]).await;
@@ -160,18 +160,45 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
 
     // Stop autopilot-leader, follower should take over
     manual_shutdown.shutdown();
-    onchain.mint_block().await;
-    assert!(
-        tokio::time::timeout(Duration::from_secs(15), autopilot_leader)
-            .await
-            .is_ok()
-    );
+    let is_leader_shutdown = || async {
+        onchain.mint_block().await;
+        autopilot_leader.is_finished()
+    };
+    wait_for_condition(TIMEOUT, is_leader_shutdown)
+        .await
+        .unwrap();
+
+    // Wait for the follower to step up as leader by checking its metrics endpoint
+    let is_follower_leader = || async {
+        onchain.mint_block().await;
+        let Ok(response) = reqwest::get("http://0.0.0.0:9591/metrics").await else {
+            return false;
+        };
+        let Ok(body) = response.text().await else {
+            return false;
+        };
+        body.lines()
+            .any(|line| line.trim().contains("leader_lock_tracker_is_leader 1"))
+    };
+    wait_for_condition(TIMEOUT, is_follower_leader)
+        .await
+        .unwrap();
 
     // Run 10 txs, autopilot-backup is in charge
     // - only test_solver2 should participate and settle
     for i in 1..=10 {
         tracing::info!("Tx with autopilot-backup {i}");
-        let uid = services.create_order(&order()).await.unwrap();
+        let uid_cell = std::cell::Cell::new(None);
+        let try_create_order = || async {
+            onchain.mint_block().await;
+            if let Ok(uid) = services.create_order(&order()).await {
+                uid_cell.set(Some(uid));
+                return true;
+            }
+            false
+        };
+        wait_for_condition(TIMEOUT, try_create_order).await.unwrap();
+        let uid = uid_cell.into_inner().unwrap();
 
         tracing::info!("waiting for trade");
         let indexed_trades = || async {

From 8a30f89a71b48e88eb53cbb73e1f73746ea0abe3 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Wed, 11 Feb 2026 14:34:23 +0100
Subject: [PATCH 047/219] Optimize autopilot maintenance (#4141)

# Description
Currently the autopilot maintenance is on the critical path before we
can build a new auction. But some of the work that's being done is
actually not necessary to build fully updated auctions. Steps that are
currently not essential are:
* pruning the DB
* associating a settlement with a proposed solution (as long as we
process all events of a settlement we know which orders have been
filled)

Ever since there are smart contracts that are listed as solvers
attributing a settlement to a solution is pretty time consuming since we
need to use `debug_traceTransaction`. This regularly takes hundreds of
milliseconds so moving this off of the hot path will be a huge win.

# Changes
To account for that the maintenance now distinguishes between essential
tasks and optional tasks. In order to move settlement attribution our of
the essentials I moved the settlement observer out of the settlement
event indexer into the autopilot maintenance component. Also now that we
have this split we can move ethflow refund indexing into the autopilot
maintenance under the optional category.

## How to test
existing e2e tests for general correctness
manual deployment to prod to confirm speed improvement

Tested on prod together with some other change.
1: current setup
2: new node infra
3: new node infra + this PR
<img width="1070" height="304" alt="Screenshot 2026-02-11 at 13 31 44"
src="https://github.com/user-attachments/assets/53505169-9012-42ca-9a08-df539b902ed6"
/>
---
 .../src/boundary/events/settlement.rs         | 20 +---
 crates/autopilot/src/maintenance.rs           | 99 +++++++++++++++----
 crates/autopilot/src/run.rs                   | 20 ++--
 3 files changed, 93 insertions(+), 46 deletions(-)

diff --git a/crates/autopilot/src/boundary/events/settlement.rs b/crates/autopilot/src/boundary/events/settlement.rs
index ef4206efe6..d097c06ba7 100644
--- a/crates/autopilot/src/boundary/events/settlement.rs
+++ b/crates/autopilot/src/boundary/events/settlement.rs
@@ -1,5 +1,5 @@
 use {
-    crate::{database::Postgres, domain::settlement},
+    crate::database::Postgres,
     alloy::{
         primitives::Address,
         rpc::types::{Filter, Log},
@@ -35,16 +35,14 @@ impl AlloyEventRetrieving for GPv2SettlementContract {
 
 pub struct Indexer {
     db: Postgres,
-    start_index: u64,
-    settlement_observer: settlement::Observer,
+    start_indexing_block: u64,
 }
 
 impl Indexer {
-    pub fn new(db: Postgres, settlement_observer: settlement::Observer, start_index: u64) -> Self {
+    pub fn new(db: Postgres, start_indexing_block: u64) -> Self {
         Self {
             db,
-            settlement_observer,
-            start_index,
+            start_indexing_block,
         }
     }
 }
@@ -57,7 +55,7 @@ impl EventStoring<(GPv2SettlementEvents, Log)> for Indexer {
     async fn last_event_block(&self) -> Result<u64> {
         super::read_last_block_from_db(&self.db.pool, INDEX_NAME)
             .await
-            .map(|last_block| last_block.max(self.start_index))
+            .map(|last_block| last_block.max(self.start_indexing_block))
     }
 
     async fn persist_last_indexed_block(&mut self, latest_block: u64) -> Result<()> {
@@ -74,10 +72,6 @@ impl EventStoring<(GPv2SettlementEvents, Log)> for Indexer {
         crate::database::events::replace_events(&mut transaction, events, from_block).await?;
         database::settlements::delete(&mut transaction, from_block).await?;
         transaction.commit().await?;
-
-        self.settlement_observer
-            .post_process_outstanding_settlement_transactions()
-            .await;
         Ok(())
     }
 
@@ -85,10 +79,6 @@ impl EventStoring<(GPv2SettlementEvents, Log)> for Indexer {
         let mut transaction = self.db.pool.begin().await?;
         crate::database::events::append_events(&mut transaction, events).await?;
         transaction.commit().await?;
-
-        self.settlement_observer
-            .post_process_outstanding_settlement_transactions()
-            .await;
         Ok(())
     }
 }
diff --git a/crates/autopilot/src/maintenance.rs b/crates/autopilot/src/maintenance.rs
index ff3c4ca74f..b279ea5c20 100644
--- a/crates/autopilot/src/maintenance.rs
+++ b/crates/autopilot/src/maintenance.rs
@@ -3,17 +3,19 @@ use {
         boundary::events::settlement::{GPv2SettlementContract, Indexer},
         database::{
             Postgres,
+            ethflow_events::event_retriever::EthFlowRefundRetriever,
             onchain_order_events::{
                 OnchainOrderParser,
                 ethflow_events::{EthFlowData, EthFlowDataForDb},
                 event_retriever::CoWSwapOnchainOrdersContract,
             },
         },
+        domain::settlement,
         event_updater::EventUpdater,
     },
     anyhow::Result,
     ethrpc::block_stream::{BlockInfo, CurrentBlockWatcher, into_stream},
-    futures::StreamExt,
+    futures::{FutureExt, StreamExt},
     prometheus::{
         HistogramVec,
         IntCounterVec,
@@ -27,11 +29,13 @@ use {
     },
     tokio::sync::watch,
     tokio_stream::wrappers::WatchStream,
+    tracing::Instrument,
 };
 
 /// Component to sync with the maintenance logic that runs in a background task.
-/// This allows us to run the maintenance logic ASAP but still wait for it to
-/// finish in a convenient manner.
+/// This allows us to run the maintenance logic as soon as we see a new block
+/// while still making the autopilot run loop only wait for updates that are
+/// essential for building new auctions.
 #[derive(Clone)]
 pub struct MaintenanceSync {
     /// How long the autopilot wants to wait at most.
@@ -75,19 +79,26 @@ pub struct Maintenance {
     /// All indexing tasks to keep cow amms up to date.
     cow_amm_indexer: Vec<Arc<dyn Maintaining>>,
     /// Tasks to index ethflow orders that were submitted onchain.
-    ethflow_indexer: Vec<EthflowIndexer>,
+    ethflow_order_indexer: Vec<EthflowOrderIndexer>,
+    /// Tasks to index ethflow refunds.
+    ethflow_refund_indexer: Vec<EthflowRefundIndexer>,
+    /// Component to correctly attribute a settlement to a proposed solution.
+    settlement_observer: settlement::Observer,
 }
 
 impl Maintenance {
     pub fn new(
         settlement_indexer: EventUpdater<Indexer, GPv2SettlementContract>,
         db_cleanup: Postgres,
+        settlement_observer: settlement::Observer,
     ) -> Self {
         Self {
             settlement_indexer,
             db_cleanup,
             cow_amm_indexer: Default::default(),
-            ethflow_indexer: Default::default(),
+            ethflow_order_indexer: Default::default(),
+            ethflow_refund_indexer: Default::default(),
+            settlement_observer,
         }
     }
 
@@ -108,7 +119,12 @@ impl Maintenance {
                     .next()
                     .await
                     .expect("block stream terminated unexpectedly");
-                self.index_until_block(block, &sender).await;
+                self.index_until_block(block, &sender)
+                    .instrument(tracing::info_span!(
+                        "autopilot_maintenance",
+                        block = block.number
+                    ))
+                    .await;
             }
         });
 
@@ -122,33 +138,45 @@ impl Maintenance {
         metrics().last_seen_block.set(block.number);
         let start = Instant::now();
 
-        if let Err(err) = self.update_inner().await {
-            tracing::warn!(?err, block = block.number, "failed to run maintenance");
+        if let Err(err) = self.run_essential_maintenance().await {
+            tracing::warn!(?err, "failed to run essential maintenance");
             metrics().updates.with_label_values(&["error"]).inc();
             return;
         }
 
         tracing::info!(
-            block = block.number,
             time = ?start.elapsed(),
-            "successfully ran maintenance task"
+            "successfully ran essential maintenance tasks"
         );
         metrics().last_updated_block.set(block.number);
         metrics().updates.with_label_values(&["success"]).inc();
         if let Err(err) = last_processed_block.send(block.number) {
             tracing::warn!(?err, "nobody listening for processed blocks anymore");
         }
+
+        // only after we informed the run_loop that the essential updates are done we
+        // kick off the optional maintenance tasks
+        let start = Instant::now();
+        if let Err(err) = self.run_optional_maintenance().await {
+            tracing::warn!(?err, "failed to run optional maintenance");
+            return;
+        }
+        tracing::info!(
+            time = ?start.elapsed(),
+            "successfully ran optional maintenance tasks"
+        );
     }
 
-    async fn update_inner(&self) -> Result<()> {
-        let _timer =
-            observe::metrics::metrics().on_auction_overhead_start("autopilot", "maintenance_total");
+    /// Runs all the maintenance tasks that are needed to ensure the next
+    /// auction gets built using the most up-to-date information.
+    async fn run_essential_maintenance(&self) -> Result<()> {
+        let _timer = observe::metrics::metrics()
+            .on_auction_overhead_start("autopilot", "maintenance_essential");
         tokio::try_join!(
             Self::timed_future(
                 "settlement_indexer",
                 self.settlement_indexer.run_maintenance()
             ),
-            Self::timed_future("db_cleanup", self.db_cleanup.run_maintenance()),
             Self::timed_future(
                 "cow_amm_indexer",
                 futures::future::try_join_all(
@@ -158,9 +186,9 @@ impl Maintenance {
                 ),
             ),
             Self::timed_future(
-                "ethflow_indexer",
+                "ethflow_order_indexer",
                 futures::future::try_join_all(
-                    self.ethflow_indexer
+                    self.ethflow_order_indexer
                         .iter()
                         .map(|indexer| indexer.run_maintenance()),
                 ),
@@ -170,10 +198,41 @@ impl Maintenance {
         Ok(())
     }
 
+    /// Runs all the maintenance tasks that should run eventually but are not
+    /// very time sensitive.
+    async fn run_optional_maintenance(&self) -> Result<()> {
+        let _timer = observe::metrics::metrics()
+            .on_auction_overhead_start("autopilot", "maintenance_optional");
+        tokio::try_join!(
+            Self::timed_future("db_cleanup", self.db_cleanup.run_maintenance()),
+            Self::timed_future(
+                "ethflow_refund_indexer",
+                futures::future::try_join_all(
+                    self.ethflow_refund_indexer
+                        .iter()
+                        .map(|indexer| indexer.run_maintenance()),
+                ),
+            ),
+            Self::timed_future(
+                "settlement_attribution",
+                self.settlement_observer
+                    .post_process_outstanding_settlement_transactions()
+                    .map(|_| Ok(()))
+            )
+        )?;
+
+        Ok(())
+    }
+
     /// Registers all maintenance tasks that are necessary to correctly support
     /// ethflow orders.
-    pub fn add_ethflow_indexer(&mut self, ethflow_indexer: EthflowIndexer) {
-        self.ethflow_indexer.push(ethflow_indexer);
+    pub fn add_ethflow_indexing(
+        &mut self,
+        order_indexer: EthflowOrderIndexer,
+        refund_indexer: EthflowRefundIndexer,
+    ) {
+        self.ethflow_order_indexer.push(order_indexer);
+        self.ethflow_refund_indexer.push(refund_indexer);
     }
 
     /// Registers all maintenance tasks that are necessary to correctly support
@@ -194,9 +253,11 @@ impl Maintenance {
     }
 }
 
-type EthflowIndexer =
+type EthflowOrderIndexer =
     EventUpdater<OnchainOrderParser<EthFlowData, EthFlowDataForDb>, CoWSwapOnchainOrdersContract>;
 
+type EthflowRefundIndexer = EventUpdater<Postgres, EthFlowRefundRetriever>;
+
 #[derive(prometheus_metric_storage::MetricStorage)]
 #[metric(subsystem = "autopilot_maintenance")]
 struct Metrics {
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 8833155918..d8279bb93d 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -46,7 +46,6 @@ use {
         baseline_solver::BaseTokens,
         code_fetching::CachedCodeFetcher,
         http_client::HttpClientFactory,
-        maintenance::ServiceMaintenance,
         order_quoting::{self, OrderQuoter},
         price_estimation::factory::{self, PriceEstimatorFactory},
         signature_validator,
@@ -426,8 +425,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         infra::persistence::Persistence::new(args.s3.into().unwrap(), Arc::new(db_write.clone()))
             .instrument(info_span!("persistence_init"))
             .await;
-    let settlement_observer =
-        crate::domain::settlement::Observer::new(eth.clone(), persistence.clone());
     let settlement_contract_start_index = match GPv2Settlement::deployment_block(&chain_id) {
         Some(block) => {
             tracing::debug!(block, "found settlement contract deployment");
@@ -449,7 +446,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         ),
         boundary::events::settlement::Indexer::new(
             db_write.clone(),
-            settlement_observer,
             settlement_contract_start_index,
         ),
         block_retriever.clone(),
@@ -568,8 +564,14 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     // updated in background task
     let trusted_tokens =
         AutoUpdatingTokenList::from_configuration(market_makable_token_list_configuration).await;
+    let settlement_observer =
+        crate::domain::settlement::Observer::new(eth.clone(), persistence.clone());
 
-    let mut maintenance = Maintenance::new(settlement_event_indexer, db_write.clone());
+    let mut maintenance = Maintenance::new(
+        settlement_event_indexer,
+        db_write.clone(),
+        settlement_observer,
+    );
     maintenance.add_cow_amm_indexer(&cow_amm_registry);
 
     if !args.ethflow_contracts.is_empty() {
@@ -626,13 +628,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .await
         .expect("Should be able to initialize event updater. Database read issues?");
 
-        maintenance.add_ethflow_indexer(onchain_order_indexer);
-        // refunds are not critical for correctness and can therefore be indexed
-        // sporadically in a background task
-        let service_maintainer = ServiceMaintenance::new(vec![Arc::new(refund_event_handler)]);
-        tokio::task::spawn(
-            service_maintainer.run_maintenance_on_new_block(eth.current_block().clone()),
-        );
+        maintenance.add_ethflow_indexing(onchain_order_indexer, refund_event_handler);
     }
 
     let run_loop_config = run_loop::Config {

From 2f704dcaa88fc600940bd99e86a223642f53dca5 Mon Sep 17 00:00:00 2001
From: Augusto Collerone <collerone.augusto@gmail.com>
Date: Wed, 11 Feb 2026 13:48:26 -0300
Subject: [PATCH 048/219] [M2] Integrate block explorer URL override for
 Otterscan (#4077)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

This is a copy of [a stale
PR](https://github.com/cowprotocol/services/pull/4012)

This PR delivers part of **Milestone 2: Frontend Integration** of the
[CoW Grants Program RFP: CoW Protocol Playground Block Explorer
Integration](https://forum.cow.fi/t/grant-application-cow-protocol-playground-block-explorer-integration/3284/1)
proposal by CoBuilders.

Updates the CoW Swap and Explorer Dockerfiles to use
`REACT_APP_BLOCK_EXPLORER_URL`, enabling all block explorer links to
point to the local Otterscan instance (port 8003) instead of Etherscan.


![demo_after](https://github.com/user-attachments/assets/ec25432e-9be5-430e-bb1b-582a7ed5a454)

## Milestone 2 Deliverables

### CoW Swap Frontend Integration
- [x] Configure `REACT_APP_BLOCK_EXPLORER_URL=http://localhost:8003` in
build
- [x] Transaction hash links point to local Otterscan
- [x] Address links point to local Otterscan
- [x] All navigation flows work correctly

### CoW Explorer Frontend Integration
- [x] Configure `REACT_APP_BLOCK_EXPLORER_URL=http://localhost:8003` in
build
- [x] "View on Blockchain" links point to local Otterscan
- [x] Address and token links point to local Otterscan
- [x] All navigation flows work correctly

### Success Criteria
> *"One-click navigation from frontends to the local block explorer for
all transactions and addresses"*

- Clicking any explorer link in CoW Swap (port 8000) → Opens in
Otterscan (port 8003)
- Clicking any explorer link in CoW Explorer (port 8001) → Opens in
Otterscan (port 8003)

## Changes

### Modified Files
| File | Changes |
|------|---------|
| `Dockerfile.cowswap` | Added `REACT_APP_BLOCK_EXPLORER_URL` build arg
|
| `Dockerfile.explorer` | Added `REACT_APP_BLOCK_EXPLORER_URL` env var |

## Architecture

```
┌─────────────┐     ┌─────────────┐
│  CoW Swap   │     │ CoW Explorer│
│ (port 8000) │     │ (port 8001) │
└──────┬──────┘     └──────┬──────┘
       │                   │
       │   All explorer    │
       │   links now       │
       │   point to ───────┤
       │                   │
       └───────────┬───────┘
                   │
                   ▼
           ┌─────────────┐
           │  Otterscan  │
           │ (port 8003) │
           └─────────────┘
```

## Dependencies

This PR depends on:
- **PR:** cowprotocol/cowswap#XXX - Adds `REACT_APP_BLOCK_EXPLORER_URL`
env var support

## Testing

1. Start the playground:
   ```bash
   docker compose -f docker-compose.fork.yml up --build
   ```

2. Open CoW Swap at `http://localhost:8000`:
   - Make a swap or view transaction history
   - Click any "View on Explorer" or transaction link
   - **Expected:** Opens `http://localhost:8003/tx/{hash}`

3. Open CoW Explorer at `http://localhost:8001`:
   - Browse any order or transaction
   - Click any address or transaction link
   - **Expected:** Opens `http://localhost:8003/address/{addr}`

4. Verify Otterscan shows the transaction/address details with full
traces

## Demo

<!-- Add GIF/video showing the flow -->
1. User clicks transaction in CoW Swap
2. Otterscan opens with full transaction details
3. Traces, logs, and gas profiling visible locally

## Milestones

| Milestone | Description | Status |
|-----------|-------------|--------|
| M1 | Otterscan Integration | [PR
#4000](https://github.com/cowprotocol/services/pull/4000) |
| M2 | Frontend Integration | **This PR** (+ cowswap PR) |
| M3 | Documentation | Pending |

---

*Submitted by [CoBuilders](https://cobuilders.xyz) as part of the CoW
Grants Program*

---------

Co-authored-by: Ignacio <ignacio@cobuilders.xyz>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
---
 playground/Dockerfile.cowswap  | 12 ++++++++++--
 playground/Dockerfile.explorer |  6 ++++--
 playground/README.md           |  4 ++--
 playground/nginx-spa.conf      | 10 ++++++++++
 4 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100644 playground/nginx-spa.conf

diff --git a/playground/Dockerfile.cowswap b/playground/Dockerfile.cowswap
index 8318bd5760..3ec5168217 100644
--- a/playground/Dockerfile.cowswap
+++ b/playground/Dockerfile.cowswap
@@ -10,6 +10,10 @@ RUN corepack enable \
 ARG REACT_APP_NETWORK_URL_1=https://rpc.mevblocker.io
 ARG REACT_APP_NETWORK_URL_5=https://ethereum-goerli.publicnode.com
 ARG REACT_APP_NETWORK_URL_100=https://gnosis.publicnode.com
+ARG REACT_APP_EXPLORER_URL_DEV=http://localhost:8001
+
+# Block explorer URL (Otterscan for local development)
+ARG REACT_APP_BLOCK_EXPLORER_URL=http://localhost:8003
 
 # Orderbook URL args
 ARG REACT_APP_ORDER_BOOK_URLS='{"1":"https://api.cow.fi/mainnet","100":"https://api.cow.fi/goerli","5":"https://api.cow.fi/xdai"}'
@@ -37,6 +41,8 @@ ENV REACT_APP_NETWORK_URL_1="$REACT_APP_NETWORK_URL_1"
 ENV REACT_APP_NETWORK_URL_5="$REACT_APP_NETWORK_URL_5"
 ENV REACT_APP_NETWORK_URL_100="$REACT_APP_NETWORK_URL_100"
 ENV REACT_APP_ORDER_BOOK_URLS="$REACT_APP_ORDER_BOOK_URLS"
+ENV REACT_APP_EXPLORER_URL_DEV="$REACT_APP_EXPLORER_URL_DEV"
+ENV REACT_APP_BLOCK_EXPLORER_URL="$REACT_APP_BLOCK_EXPLORER_URL"
 
 # Update environment variables based on "chain" and "ETH_RPC_URL", then build safely
 RUN set -e; \
@@ -56,12 +62,14 @@ RUN set -e; \
                 ;; \
         esac; \
     fi; \
-    export REACT_APP_NETWORK_URL_1 REACT_APP_NETWORK_URL_5 REACT_APP_NETWORK_URL_100 REACT_APP_ORDER_BOOK_URLS; \
+    export REACT_APP_NETWORK_URL_1 REACT_APP_NETWORK_URL_5 REACT_APP_NETWORK_URL_100 REACT_APP_ORDER_BOOK_URLS REACT_APP_EXPLORER_URL_DEV REACT_APP_BLOCK_EXPLORER_URL; \
     NODE_OPTIONS="--max-old-space-size=4096" NX_NO_CLOUD=true pnpm run build \
         --env REACT_APP_NETWORK_URL_1="$REACT_APP_NETWORK_URL_1" \
         --env REACT_APP_NETWORK_URL_5="$REACT_APP_NETWORK_URL_5" \
         --env REACT_APP_NETWORK_URL_100="$REACT_APP_NETWORK_URL_100" \
-        --env REACT_APP_ORDER_BOOK_URLS="$REACT_APP_ORDER_BOOK_URLS"
+        --env REACT_APP_ORDER_BOOK_URLS="$REACT_APP_ORDER_BOOK_URLS" \
+        --env REACT_APP_EXPLORER_URL_DEV="$REACT_APP_EXPLORER_URL_DEV" \
+        --env REACT_APP_BLOCK_EXPLORER_URL="$REACT_APP_BLOCK_EXPLORER_URL"
 
 # Stage 2: Copy the frontend build to the nginx container
 FROM docker.io/nginx:1.21-alpine AS frontend
diff --git a/playground/Dockerfile.explorer b/playground/Dockerfile.explorer
index 917923a0f4..19d38cf664 100644
--- a/playground/Dockerfile.explorer
+++ b/playground/Dockerfile.explorer
@@ -16,14 +16,16 @@ RUN git clone https://github.com/cowprotocol/cowswap . \
     && git submodule update --init --recursive \
     && pnpm install --frozen-lockfile
 
-# Set environment variable for the order book
+# Build environment variables
 ENV REACT_APP_ORDER_BOOK_URLS='{"1":"http://localhost:8080"}'
+ENV REACT_APP_BLOCK_EXPLORER_URL=http://localhost:8003
 
 # Build the frontend
-RUN APP_ID=1 pnpm run build:explorer
+RUN APP_ID=1 REACT_APP_BLOCK_EXPLORER_URL=$REACT_APP_BLOCK_EXPLORER_URL pnpm run build:explorer
 
 # Stage 2: Copy the frontend build to the nginx container
 FROM docker.io/nginx:1.21-alpine AS frontend
 COPY --from=node-build /usr/src/app/build/explorer /usr/share/nginx/html
+COPY nginx-spa.conf /etc/nginx/conf.d/default.conf
 EXPOSE 80
 CMD ["nginx", "-g", "daemon off;"]
diff --git a/playground/README.md b/playground/README.md
index 497d625cbd..3269971f77 100644
--- a/playground/README.md
+++ b/playground/README.md
@@ -42,7 +42,7 @@ Now with Rabby configured, and the services started, you can browse to http://lo
 > The EthFlow is not configured by default, the next section explains how to set it up.
 > You can follow along with watching the logs of the `autopilot`, `driver`, and `baseline` solver to see how the Protocol interacts.
 > If you make any changes to the files in your repo directory, services will automatically be recompiled and restarted.
-> The CoW Explorer is avialable at http://localhost:8001 to see more information about transaction status
+> The CoW Explorer is available at http://localhost:8001 to see more information about transaction status
 
 ### Resetting the playground
 
@@ -147,7 +147,7 @@ In this mode, the stack will spin up:
 - Driver
 - Baseline
 - Cow Swap
-- Cow Explorer (*not yet implemented*)
+- Cow Explorer
 
 ### Local
 
diff --git a/playground/nginx-spa.conf b/playground/nginx-spa.conf
new file mode 100644
index 0000000000..2d96d1589b
--- /dev/null
+++ b/playground/nginx-spa.conf
@@ -0,0 +1,10 @@
+server {
+    listen 80;
+    server_name localhost;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+}

From 5db7fbb1b76ddb8d988b9307dcefe16d4f5aab2d Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Wed, 11 Feb 2026 18:04:27 +0100
Subject: [PATCH 049/219] Fix true_valid_to updating (#4134)

# Description
`true_valid_to` is not always updated as needed. It can happen that
ethflow order events are parsed first, before order creation takes place
which results in `true_valid_to` to first be set correctly, and then set
to `u32::MAX` when inserting the order.

Ethflow orders as a whole get parsed off onchain events and the logic
(regarding the above) currently is as follows:

Custom onchain data parser would pick up on the Ethflow related events
and insert the ethflow_orders row with correct order uid and valid_to. I
have included logic to update related order's true_valid_to to the same
value, but it does not exist in the db yet
Orders parsed from order placement events will get inserted into the
database, ignoring conflicts. Since the newly created ethflow order does
not yet exist in the database, it will get inserted with the valid_to
set as u32::MAX and true_valid_to having the same value.
There is no other point in time for the true_valid_to to get correctly
updated, which leaves us with two options:

Use the smaller of two: ethflow_orders.valid_to, orders.valid_to when
inserting an order.
Change the order of how onchain events are parsed - first parse the
order creation events and only then append the custom info (which
includes ethflow).
The solution 1 seems more robust since We will always end up with the
smallest value when inserting an order.
I am not sure what might the implications of changing the onchain event
parsing order.

# Changes
Adds a clause
```sql
COALESCE(
	(SELECT LEAST($21, valid_to) FROM ethflow_orders WHERE uid = $1),
	$21
)
```
to INSERT_ORDER query which will always take the smallest of
`ethflow_orders.valid_to` and the value currently being inserted.

# Deployment
When hotfix is applied, services will correctly attribute
`true_valid_to` and manual backfill will be performed.

## How to test
Tested on ethflow E2E test `local_node_eth_flow_tx` confirmed the faulty
behaviour can occur and added assert that ensures the resulting
true_valid_to is **not** `u32::MAX`

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/database/src/ethflow_orders.rs | 23 +++--------------------
 crates/database/src/orders.rs         | 13 ++++++++++++-
 crates/database/src/trades.rs         |  2 +-
 crates/e2e/tests/e2e/ethflow.rs       | 25 ++++++++++++++++++++++++-
 4 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/crates/database/src/ethflow_orders.rs b/crates/database/src/ethflow_orders.rs
index 05886feb53..146a714af5 100644
--- a/crates/database/src/ethflow_orders.rs
+++ b/crates/database/src/ethflow_orders.rs
@@ -37,6 +37,9 @@ pub async fn insert_or_overwrite_ethflow_order(
     )
     .await?;
 
+    // Update true_valid_to field if order already in the database
+    // as the Ethflow orders get inserted with validity of u32::MAX
+    // and the true validity is contained in the EthOrderPlacement
     const UPDATE_TRUE_VALID_TO_QUERY: &str = r#"
         UPDATE orders
         SET true_valid_to = $1
@@ -51,26 +54,6 @@ pub async fn insert_or_overwrite_ethflow_order(
     Ok(())
 }
 
-// Ethflow orders are created with valid_to equal to u32::MAX, their
-// true validity is parsed from Settlement contract events.
-#[instrument(skip_all)]
-pub async fn update_true_valid_to_for_ethflow_order(
-    ex: &mut PgConnection,
-    event: &EthOrderPlacement,
-) -> Result<(), sqlx::Error> {
-    const QUERY: &str = r#"
-        UPDATE orders
-        SET true_valid_to = $1
-        WHERE uid = $2
-    "#;
-    sqlx::query(QUERY)
-        .bind(event.valid_to)
-        .bind(event.uid)
-        .execute(ex)
-        .await?;
-    Ok(())
-}
-
 #[derive(Clone, Debug, Default, sqlx::FromRow, Eq, PartialEq)]
 pub struct EthOrderData {
     pub uid: OrderUid,
diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index 0e661d7729..b7a8e5abe4 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -148,7 +148,18 @@ INSERT INTO orders (
     class,
     true_valid_to
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)
+VALUES (
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20,
+    -- Ethflow orders are inserted with valid_to set to u32::MAX. Their true validity is stored in
+    -- the ethflow_orders table.
+    -- If there already exists an Ethflow order with the same uid, take smaller of the two valid_to values
+    CASE 
+        WHEN $21 = 4294967295 THEN  -- u32::MAX
+            COALESCE((SELECT valid_to FROM ethflow_orders WHERE uid = $1), $21)
+        ELSE 
+            $21
+    END
+)
     "#;
 
 #[instrument(skip_all)]
diff --git a/crates/database/src/trades.rs b/crates/database/src/trades.rs
index 7c7430b128..13628a39f9 100644
--- a/crates/database/src/trades.rs
+++ b/crates/database/src/trades.rs
@@ -705,7 +705,7 @@ mod tests {
         }
 
         // Sort expected trades by block_number DESC (matching query ORDER BY)
-        expected_trades.sort_by(|a, b| b.block_number.cmp(&a.block_number));
+        expected_trades.sort_by_key(|trade| std::cmp::Reverse(trade.block_number));
 
         // Test limit: get first 2 trades (blocks 4 and 3 in DESC order)
         let result = trades(&mut db, Some(&owner), None, 0, 2)
diff --git a/crates/e2e/tests/e2e/ethflow.rs b/crates/e2e/tests/e2e/ethflow.rs
index eabbb5a6f8..3cf2406a5e 100644
--- a/crates/e2e/tests/e2e/ethflow.rs
+++ b/crates/e2e/tests/e2e/ethflow.rs
@@ -6,7 +6,7 @@ use {
     anyhow::bail,
     autopilot::database::onchain_order_events::ethflow_events::WRAP_ALL_SELECTOR,
     contracts::alloy::{CoWSwapEthFlow, ERC20Mintable, WETH9},
-    database::order_events::OrderEventLabel,
+    database::{byte_array::ByteArray, order_events::OrderEventLabel},
     e2e::setup::{
         ACCOUNT_ENDPOINT,
         API_HOST,
@@ -49,6 +49,7 @@ use {
     refunder::RefundStatus,
     reqwest::Client,
     shared::signature_validator::check_erc1271_result,
+    std::ops::DerefMut,
 };
 
 const DAI_PER_ETH: u64 = 1_000;
@@ -243,6 +244,28 @@ async fn eth_flow_tx(web3: Web3) {
         .await
         .unwrap();
     assert_eq!(allowance, alloy::primitives::U256::ZERO);
+
+    // Check that true_valid_to is equal to the ethflow_order's valid to
+    let uid = ethflow_order
+        .uid(onchain.contracts(), ethflow_contract)
+        .await;
+    let mut db = services.db().acquire().await.unwrap();
+    let true_valid_to: (i64,) = sqlx::query_as("SELECT true_valid_to FROM orders WHERE uid = $1")
+        .bind(ByteArray(uid.0))
+        .fetch_one(db.deref_mut())
+        .await
+        .unwrap();
+    assert_eq!(
+        true_valid_to.0,
+        services
+            .get_order(&uid)
+            .await
+            .unwrap()
+            .metadata
+            .ethflow_data
+            .unwrap()
+            .user_valid_to
+    );
 }
 
 async fn eth_flow_without_quote(web3: Web3) {

From 558b1bc9471c6747867b2e7d21cf9c53e07ccb2d Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 11 Feb 2026 22:04:05 +0300
Subject: [PATCH 050/219] Shared native price cache (#4136)

# Description
Replaces #4044. Once we started forwarding native price estimates from
the orderbook to autopilot, CoinGecko API usage went up. This happened
because the estimator moved to autopilot, which now handles all requests
and also relies on CoinGecko.

This PR refactors native price estimation in a way described below,
according to the diagram created by @MartinquaXD:
<img width="2394" height="1512" alt="image"
src="https://github.com/user-attachments/assets/e29e620b-5e64-4b87-b72f-f494315465a4"
/>

# Changes
- Split `CachingNativePriceEstimator` into three focused components: a
passive `Cache` (shared data store), a
`CachingNativePriceEstimator` (on-demand price fetching with caching),
and a `NativePriceUpdater` (background maintenance worker).
- The autopilot now creates a single shared `Cache` instance used by
both the API-facing estimator and the auction
competition estimator, eliminating duplicate price fetches for the same
tokens.
- Added an `--api-native-price-estimators` flag to the autopilot,
allowing the API endpoint to use different native price estimator
sources than the auction pipeline (falls back to
`--native-price-estimators`, if unset).
- Replaced the implicit priority-based update system (`high_priority` +
`replace_high_priority`) with an explicit token tracking via
`set_tokens_to_update()`, called during the solvable orders cache
building in the autopilot.
- Moved cache + updater wiring out of the shared factory into each
binary, so each service composes the shared building blocks as needed:
  - Orderbook: creates its own `Cache` + `CachingNativePriceEstimator`.
- Autopilot: Creates 2 separate `CachingNativePriceEstimators` that
share a single instance of `Cache`. One of the estimators is wrapped
with the `NativePriceUpdater`, which is used in the auction competition.
Another one serves the autopilot's API request without a maintenance
task.
- Removed the unused `--native-price-cache-max-update-size` flag (dead
code after the refactoring removed the truncation logic).

## How to test
Existing tests + staging and prod.

# Follow-up tasks

- The cache is unbounded. This needs to be revisited, and probably
adding a simple LRU cache would be safer.
---
 Cargo.lock                                    |   1 +
 crates/autopilot/src/arguments.rs             |  41 +
 crates/autopilot/src/run.rs                   |  60 +-
 crates/autopilot/src/solvable_orders.rs       | 158 +---
 crates/e2e/src/setup/services.rs              |   2 +-
 crates/orderbook/src/run.rs                   |  23 +-
 crates/shared/Cargo.toml                      |   1 +
 crates/shared/src/price_estimation/factory.rs |  53 +-
 crates/shared/src/price_estimation/mod.rs     |  41 -
 .../price_estimation/native_price_cache.rs    | 788 ++++++++----------
 10 files changed, 536 insertions(+), 632 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 423221c014..afda6769b8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6168,6 +6168,7 @@ dependencies = [
  "alloy",
  "anyhow",
  "app-data",
+ "arc-swap",
  "async-stream",
  "async-trait",
  "bigdecimal",
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index a6cb1cf8ca..e22d464a2b 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -96,6 +96,11 @@ pub struct Arguments {
     #[clap(long, env)]
     pub native_price_estimators: NativePriceEstimators,
 
+    /// Estimators for the API endpoint. Falls back to
+    /// `--native-price-estimators` if unset.
+    #[clap(long, env)]
+    pub api_native_price_estimators: Option<NativePriceEstimators>,
+
     /// How many successful price estimates for each order will cause a native
     /// price estimation to return its result early. It's possible to pass
     /// values greater than the total number of enabled estimators but that
@@ -276,6 +281,26 @@ pub struct Arguments {
     /// further.
     #[clap(long, env, default_value = "5s", value_parser = humantime::parse_duration)]
     pub max_maintenance_timeout: Duration,
+
+    /// How often the native price estimator should refresh its cache.
+    #[clap(
+        long,
+        env,
+        default_value = "1s",
+        value_parser = humantime::parse_duration,
+    )]
+    pub native_price_cache_refresh: Duration,
+
+    /// How long before expiry the native price cache should try to update the
+    /// price in the background. This value has to be smaller than
+    /// `--native-price-cache-max-age`.
+    #[clap(
+        long,
+        env,
+        default_value = "80s",
+        value_parser = humantime::parse_duration,
+    )]
+    pub native_price_prefetch_time: Duration,
 }
 
 impl std::fmt::Display for Arguments {
@@ -296,6 +321,7 @@ impl std::fmt::Display for Arguments {
             allowed_tokens,
             unsupported_tokens,
             native_price_estimators,
+            api_native_price_estimators,
             min_order_validity_period,
             banned_users,
             banned_users_max_cache_size,
@@ -327,6 +353,8 @@ impl std::fmt::Display for Arguments {
             disable_1271_order_sig_filter,
             enable_leader_lock,
             max_maintenance_timeout,
+            native_price_cache_refresh,
+            native_price_prefetch_time,
         } = self;
 
         write!(f, "{shared}")?;
@@ -345,6 +373,11 @@ impl std::fmt::Display for Arguments {
         writeln!(f, "allowed_tokens: {allowed_tokens:?}")?;
         writeln!(f, "unsupported_tokens: {unsupported_tokens:?}")?;
         writeln!(f, "native_price_estimators: {native_price_estimators}")?;
+        display_option(
+            f,
+            "api_native_price_estimators",
+            api_native_price_estimators,
+        )?;
         writeln!(
             f,
             "min_order_validity_period: {min_order_validity_period:?}"
@@ -408,6 +441,14 @@ impl std::fmt::Display for Arguments {
         )?;
         writeln!(f, "enable_leader_lock: {enable_leader_lock}")?;
         writeln!(f, "max_maintenance_timeout: {max_maintenance_timeout:?}")?;
+        writeln!(
+            f,
+            "native_price_cache_refresh: {native_price_cache_refresh:?}"
+        )?;
+        writeln!(
+            f,
+            "native_price_prefetch_time: {native_price_prefetch_time:?}"
+        )?;
         Ok(())
     }
 }
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index d8279bb93d..b80ef71acf 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -47,7 +47,10 @@ use {
         code_fetching::CachedCodeFetcher,
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
-        price_estimation::factory::{self, PriceEstimatorFactory},
+        price_estimation::{
+            factory::{self, PriceEstimatorFactory},
+            native::NativePriceEstimating,
+        },
         signature_validator,
         sources::{BaselineSource, uniswap_v2::UniV2BaselineSourceParameters},
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
@@ -386,17 +389,44 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     .await
     .expect("failed to initialize price estimator factory");
 
-    let native_price_estimator = price_estimator_factory
-        .native_price_estimator(
-            args.native_price_estimators.as_slice(),
-            args.native_price_estimation_results_required,
-            eth.contracts().weth().clone(),
-        )
-        .instrument(info_span!("native_price_estimator"))
-        .await
-        .unwrap();
+    let weth = eth.contracts().weth().clone();
     let prices = db_write.fetch_latest_prices().await.unwrap();
-    native_price_estimator.initialize_cache(prices);
+    let shared_cache = shared::price_estimation::native_price_cache::Cache::new(
+        args.price_estimation.native_price_cache_max_age,
+        prices,
+    );
+    let api_sources = args
+        .api_native_price_estimators
+        .as_ref()
+        .unwrap_or(&args.native_price_estimators);
+    let api_native_price_estimator: Arc<dyn NativePriceEstimating> = Arc::new(
+        price_estimator_factory
+            .caching_native_price_estimator(
+                api_sources.as_slice(),
+                args.native_price_estimation_results_required,
+                &weth,
+                shared_cache.clone(),
+            )
+            .instrument(info_span!("api_native_price_estimator"))
+            .await,
+    );
+
+    let competition_native_price_updater = {
+        let caching = price_estimator_factory
+            .caching_native_price_estimator(
+                args.native_price_estimators.as_slice(),
+                args.native_price_estimation_results_required,
+                &weth,
+                shared_cache.clone(),
+            )
+            .instrument(info_span!("competition_native_price_updater"))
+            .await;
+        shared::price_estimation::native_price_cache::NativePriceUpdater::new(
+            caching,
+            args.native_price_cache_refresh,
+            args.native_price_prefetch_time,
+        )
+    };
 
     let price_estimator = price_estimator_factory
         .price_estimator(
@@ -406,7 +436,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
                 .iter()
                 .map(|price_estimator_driver| price_estimator_driver.clone().into())
                 .collect::<Vec<_>>(),
-            native_price_estimator.clone(),
+            api_native_price_estimator.clone(),
             gas_price_estimator.clone(),
         )
         .unwrap();
@@ -470,7 +500,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
 
     let quoter = Arc::new(OrderQuoter::new(
         price_estimator,
-        native_price_estimator.clone(),
+        api_native_price_estimator.clone(),
         gas_price_estimator,
         Arc::new(db_write.clone()),
         order_quoting::Validity {
@@ -502,7 +532,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         ),
         balance_fetcher.clone(),
         bad_token_detector.clone(),
-        native_price_estimator.clone(),
+        competition_native_price_updater.clone(),
         signature_validator.clone(),
         *eth.contracts().weth().address(),
         args.limit_order_price_factor
@@ -527,7 +557,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     let (api_shutdown_sender, api_shutdown_receiver) = tokio::sync::oneshot::channel();
     let api_task = tokio::spawn(infra::api::serve(
         args.api_address,
-        native_price_estimator.clone(),
+        api_native_price_estimator,
         args.price_estimation.quote_timeout,
         api_shutdown_receiver,
     ));
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index db46801587..be5bc52745 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -9,7 +9,6 @@ use {
     bigdecimal::BigDecimal,
     database::order_events::OrderEventLabel,
     futures::{FutureExt, StreamExt, future::join_all, stream::FuturesUnordered},
-    indexmap::IndexSet,
     itertools::Itertools,
     model::{
         order::{Order, OrderClass, OrderUid},
@@ -23,7 +22,7 @@ use {
         bad_token::BadTokenDetecting,
         price_estimation::{
             native::{NativePriceEstimating, to_normalized_price},
-            native_price_cache::CachingNativePriceEstimator,
+            native_price_cache::NativePriceUpdater,
         },
         remaining_amounts,
         signature_validator::{SignatureCheck, SignatureValidating},
@@ -91,7 +90,7 @@ pub struct SolvableOrdersCache {
     balance_fetcher: Arc<dyn BalanceFetching>,
     bad_token_detector: Arc<dyn BadTokenDetecting>,
     cache: Mutex<Option<Inner>>,
-    native_price_estimator: Arc<CachingNativePriceEstimator>,
+    native_price_estimator: Arc<NativePriceUpdater>,
     signature_validator: Arc<dyn SignatureValidating>,
     metrics: &'static Metrics,
     weth: Address,
@@ -120,7 +119,7 @@ impl SolvableOrdersCache {
         banned_users: banned::Users,
         balance_fetcher: Arc<dyn BalanceFetching>,
         bad_token_detector: Arc<dyn BadTokenDetecting>,
-        native_price_estimator: Arc<CachingNativePriceEstimator>,
+        native_price_estimator: Arc<NativePriceUpdater>,
         signature_validator: Arc<dyn SignatureValidating>,
         weth: Address,
         limit_order_price_factor: BigDecimal,
@@ -469,12 +468,12 @@ async fn find_banned_user_orders(orders: &[Order], banned_users: &banned::Users)
 }
 
 async fn get_native_prices(
-    tokens: &[Address],
-    native_price_estimator: &CachingNativePriceEstimator,
+    tokens: HashSet<Address>,
+    native_price_estimator: &NativePriceUpdater,
     timeout: Duration,
 ) -> BTreeMap<Address, alloy::primitives::U256> {
     native_price_estimator
-        .estimate_native_prices_with_timeout(tokens, timeout)
+        .update_tokens_and_fetch_prices(tokens, timeout)
         .await
         .into_iter()
         .flat_map(|(token, result)| {
@@ -615,7 +614,7 @@ fn filter_dust_orders(mut orders: Vec<Order>, balances: &Balances) -> Vec<Order>
 
 async fn get_orders_with_native_prices(
     orders: Vec<Order>,
-    native_price_estimator: &CachingNativePriceEstimator,
+    native_price_estimator: &NativePriceUpdater,
     metrics: &Metrics,
     additional_tokens: impl IntoIterator<Item = Address>,
     timeout: Duration,
@@ -626,16 +625,12 @@ async fn get_orders_with_native_prices(
         .chain(additional_tokens)
         .collect::<HashSet<_>>();
 
-    let prices = get_native_prices(
-        &traded_tokens.into_iter().collect::<Vec<_>>(),
-        native_price_estimator,
-        timeout,
-    )
-    .await;
+    let prices = get_native_prices(traded_tokens, native_price_estimator, timeout).await;
 
     // Filter orders so that we only return orders that have prices
     let mut filtered_market_orders = 0_i64;
-    let (usable, filtered): (Vec<_>, Vec<_>) = orders.into_iter().partition(|order| {
+    let mut orders = orders;
+    orders.retain(|order| {
         let (t0, t1) = (&order.data.sell_token, &order.data.buy_token);
         match (prices.get(t0), prices.get(t1)) {
             (Some(_), Some(_)) => true,
@@ -645,57 +640,12 @@ async fn get_orders_with_native_prices(
             }
         }
     });
-    let tokens_by_priority = prioritize_missing_prices(filtered);
-    native_price_estimator.replace_high_priority(tokens_by_priority);
 
-    // Record separate metrics just for missing native token prices for market
-    // orders, as they should be prioritized.
     metrics
         .auction_market_order_missing_price
         .set(filtered_market_orders);
 
-    (usable, prices)
-}
-
-/// Computes which missing native prices are the most urgent to fetch.
-/// Prices for recent orders have the highest priority because those are most
-/// likely market orders which users expect to get settled ASAP.
-/// For the remaining orders we prioritize token prices that are needed the most
-/// often. That way we have the chance to make a majority of orders solvable
-/// with very few fetch requests.
-fn prioritize_missing_prices(mut orders: Vec<Order>) -> IndexSet<Address> {
-    /// How old an order can be at most to be considered a market order.
-    const MARKET_ORDER_AGE: chrono::Duration = chrono::Duration::minutes(30);
-    let now = chrono::Utc::now();
-
-    // newer orders at the start
-    orders.sort_by_key(|o| std::cmp::Reverse(o.metadata.creation_date));
-
-    let mut high_priority_tokens = IndexSet::new();
-    let mut most_used_tokens = HashMap::<Address, usize>::new();
-    for order in orders {
-        let sell_token = order.data.sell_token;
-        let buy_token = order.data.buy_token;
-        let is_market = now.signed_duration_since(order.metadata.creation_date) <= MARKET_ORDER_AGE;
-
-        if is_market {
-            // already correct priority because orders were sorted by creation_date
-            high_priority_tokens.extend([sell_token, buy_token]);
-        } else {
-            // count how often tokens are used to prioritize popular tokens
-            *most_used_tokens.entry(sell_token).or_default() += 1;
-            *most_used_tokens.entry(buy_token).or_default() += 1;
-        }
-    }
-
-    // popular tokens at the start
-    let most_used_tokens = most_used_tokens
-        .into_iter()
-        .sorted_by_key(|entry| std::cmp::Reverse(entry.1))
-        .map(|(token, _)| token);
-
-    high_priority_tokens.extend(most_used_tokens);
-    high_priority_tokens
+    (orders, prices)
 }
 
 async fn find_unsupported_tokens(
@@ -913,7 +863,12 @@ mod tests {
                 HEALTHY_PRICE_ESTIMATION_TIME,
                 PriceEstimationError,
                 native::MockNativePriceEstimating,
-                native_price_cache::ApproximationToken,
+                native_price_cache::{
+                    ApproximationToken,
+                    Cache,
+                    CachingNativePriceEstimator,
+                    NativePriceUpdater,
+                },
             },
             signature_validator::{MockSignatureValidating, SignatureValidationError},
         },
@@ -956,16 +911,16 @@ mod tests {
             .withf(move |token, _| *token == token3)
             .returning(|_, _| async { Ok(0.25) }.boxed());
 
-        let native_price_estimator = CachingNativePriceEstimator::new(
+        let cache = Cache::new(Duration::from_secs(10), Default::default());
+        let caching_estimator = CachingNativePriceEstimator::new(
             Box::new(native_price_estimator),
-            Duration::from_secs(10),
-            Duration::MAX,
-            None,
-            Default::default(),
+            cache,
             3,
             Default::default(),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
+        let native_price_estimator =
+            NativePriceUpdater::new(caching_estimator, Duration::MAX, Default::default());
         let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
         let (filtered_orders, prices) = get_orders_with_native_prices(
@@ -1047,21 +1002,23 @@ mod tests {
             .withf(move |token, _| *token == token5)
             .returning(|_, _| async { Ok(5.) }.boxed());
 
-        let native_price_estimator = CachingNativePriceEstimator::new(
+        let cache = Cache::new(Duration::from_secs(10), Default::default());
+        let caching_estimator = CachingNativePriceEstimator::new(
             Box::new(native_price_estimator),
-            Duration::from_secs(10),
-            Duration::MAX,
-            None,
-            Default::default(),
+            cache,
             1,
             Default::default(),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
+        let native_price_estimator = NativePriceUpdater::new(
+            caching_estimator,
+            Duration::from_millis(5),
+            Default::default(),
+        );
         let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
-        // We'll have no native prices in this call. But this call will cause a
-        // background task to fetch the missing prices so we'll have them in the
-        // next call.
+        // We'll have no native prices in this call. But set_tokens_to_update
+        // will cause the background task to fetch them in the next cycle.
         let (filtered_orders, prices) = get_orders_with_native_prices(
             orders.clone(),
             &native_price_estimator,
@@ -1073,8 +1030,8 @@ mod tests {
         assert!(filtered_orders.is_empty());
         assert!(prices.is_empty());
 
-        // Wait for native prices to get fetched.
-        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+        // Wait for native prices to get fetched by the background task.
+        tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
 
         // Now we have all the native prices we want.
         let (filtered_orders, prices) = get_orders_with_native_prices(
@@ -1144,12 +1101,10 @@ mod tests {
             .withf(move |token, _| *token == token_approx2)
             .returning(|_, _| async { Ok(50.) }.boxed());
 
-        let native_price_estimator = CachingNativePriceEstimator::new(
+        let cache = Cache::new(Duration::from_secs(10), Default::default());
+        let caching_estimator = CachingNativePriceEstimator::new(
             Box::new(native_price_estimator),
-            Duration::from_secs(10),
-            Duration::MAX,
-            None,
-            Default::default(),
+            cache,
             3,
             // Set to use native price approximations for the following tokens
             HashMap::from([
@@ -1158,6 +1113,8 @@ mod tests {
             ]),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
+        let native_price_estimator =
+            NativePriceUpdater::new(caching_estimator, Duration::MAX, Default::default());
         let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
         let (filtered_orders, prices) = get_orders_with_native_prices(
@@ -1544,41 +1501,4 @@ mod tests {
             orders_with_balance(orders, &balances, settlement_contract, false);
         assert!(filtered_without_override.is_empty());
     }
-
-    #[test]
-    fn prioritizes_missing_prices() {
-        let now = chrono::Utc::now();
-
-        let order = |sell_token, buy_token, age| Order {
-            metadata: OrderMetadata {
-                creation_date: now - chrono::Duration::minutes(age),
-                ..Default::default()
-            },
-            data: OrderData {
-                sell_token,
-                buy_token,
-                ..Default::default()
-            },
-            ..Default::default()
-        };
-
-        let orders = vec![
-            order(Address::with_last_byte(4), Address::with_last_byte(6), 31),
-            order(Address::with_last_byte(4), Address::with_last_byte(6), 31),
-            // older market order
-            order(Address::with_last_byte(1), Address::with_last_byte(2), 29),
-            order(Address::with_last_byte(5), Address::with_last_byte(6), 31),
-            // youngest market order
-            order(Address::with_last_byte(1), Address::with_last_byte(3), 1),
-        ];
-        let result = prioritize_missing_prices(orders);
-        assert!(result.into_iter().eq([
-            Address::with_last_byte(1), // coming from youngest market order
-            Address::with_last_byte(3), // coming from youngest market order
-            Address::with_last_byte(2), // coming from older market order
-            Address::with_last_byte(6), // coming from limit order (part of 3 orders)
-            Address::with_last_byte(4), // coming from limit order (part of 2 orders)
-            Address::with_last_byte(5), // coming from limit order (part of 1 orders)
-        ]));
-    }
 }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index c018566960..7e2b4afd04 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -138,7 +138,6 @@ impl<'a> Services<'a> {
             format!("--node-ws-url={NODE_WS_HOST}"),
             "--simulation-node-url=http://localhost:8545".to_string(),
             "--native-price-cache-max-age=2s".to_string(),
-            "--native-price-prefetch-time=500ms".to_string(),
             format!(
                 "--hooks-contract-address={:?}",
                 self.contracts.hooks.address()
@@ -150,6 +149,7 @@ impl<'a> Services<'a> {
     fn autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
         self.api_autopilot_arguments().chain([
             "--quote-timeout=10s".to_string(),
+            "--native-price-prefetch-time=500ms".to_string(),
             "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
                 .to_string(),
         ])
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index c17bcc5bfd..981dfe3357 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -315,16 +315,21 @@ pub async fn run(args: Arguments) {
     .await
     .expect("failed to initialize price estimator factory");
 
-    let native_price_estimator = price_estimator_factory
-        .native_price_estimator(
-            args.native_price_estimators.as_slice(),
-            args.fast_price_estimation_results_required,
-            native_token.clone(),
-        )
-        .await
-        .unwrap();
     let prices = postgres_write.fetch_latest_prices().await.unwrap();
-    native_price_estimator.initialize_cache(prices);
+    let cache = shared::price_estimation::native_price_cache::Cache::new(
+        args.price_estimation.native_price_cache_max_age,
+        prices,
+    );
+    let native_price_estimator: Arc<dyn NativePriceEstimating> = Arc::new(
+        price_estimator_factory
+            .caching_native_price_estimator(
+                args.native_price_estimators.as_slice(),
+                args.fast_price_estimation_results_required,
+                &native_token,
+                cache,
+            )
+            .await,
+    );
 
     let price_estimator = price_estimator_factory
         .price_estimator(
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 14538595f1..752be21c00 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -12,6 +12,7 @@ doctest = false
 alloy = { workspace = true, features = ["sol-types", "signer-local", "rand", "provider-trace-api"] }
 anyhow = { workspace = true }
 app-data = { workspace = true }
+arc-swap = { workspace = true }
 bytes-hex = { workspace = true }
 async-trait = { workspace = true }
 bigdecimal = { workspace = true }
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index 195df20563..74ac93f0f1 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -6,8 +6,8 @@ use {
         competition::CompetitionEstimator,
         external::ExternalPriceEstimator,
         instrumented::InstrumentedPriceEstimator,
-        native::{self, NativePriceEstimator},
-        native_price_cache::{ApproximationToken, CachingNativePriceEstimator},
+        native::{self, NativePriceEstimating, NativePriceEstimator},
+        native_price_cache::{self, ApproximationToken},
         sanitized::SanitizedPriceEstimator,
         trade_verifier::{TradeVerifier, TradeVerifying},
     },
@@ -23,7 +23,6 @@ use {
             ExternalSolver,
             buffered::{self, BufferedRequest, NativePriceBatchFetching},
             competition::PriceRanking,
-            native::NativePriceEstimating,
         },
         tenderly_api::TenderlyCodeSimulator,
         token_info::TokenInfoFetching,
@@ -360,22 +359,18 @@ impl<'a> PriceEstimatorFactory<'a> {
         ))
     }
 
+    /// Creates a native price estimator from the given sources.
     pub async fn native_price_estimator(
         &mut self,
         native: &[Vec<NativePriceEstimatorSource>],
         results_required: NonZeroUsize,
-        weth: WETH9::Instance,
-    ) -> Result<Arc<CachingNativePriceEstimator>> {
-        anyhow::ensure!(
-            self.args.native_price_cache_max_age > self.args.native_price_prefetch_time,
-            "price cache prefetch time needs to be less than price cache max age"
-        );
-
+        weth: &WETH9::Instance,
+    ) -> Result<Box<dyn NativePriceEstimating>> {
         let mut estimators = Vec::with_capacity(native.len());
         for stage in native.iter() {
             let mut stages = Vec::with_capacity(stage.len());
             for source in stage {
-                stages.push(self.create_native_estimator(source, &weth).await?);
+                stages.push(self.create_native_estimator(source, weth).await?);
             }
             estimators.push(stages);
         }
@@ -384,21 +379,33 @@ impl<'a> PriceEstimatorFactory<'a> {
             CompetitionEstimator::new(estimators, PriceRanking::MaxOutAmount)
                 .with_verification(self.args.quote_verification)
                 .with_early_return(results_required);
-        let approximation_tokens = self.build_approximation_tokens().await.context(
-            "failed to build native price approximation tokens with normalization factors",
-        )?;
-
-        let native_estimator = Arc::new(CachingNativePriceEstimator::new(
-            Box::new(competition_estimator),
-            self.args.native_price_cache_max_age,
-            self.args.native_price_cache_refresh,
-            Some(self.args.native_price_cache_max_update_size),
-            self.args.native_price_prefetch_time,
+        Ok(Box::new(competition_estimator))
+    }
+
+    /// Creates a [`CachingNativePriceEstimator`] that wraps a native price
+    /// estimator with an in-memory cache.
+    pub async fn caching_native_price_estimator(
+        &mut self,
+        native: &[Vec<NativePriceEstimatorSource>],
+        results_required: NonZeroUsize,
+        weth: &WETH9::Instance,
+        cache: native_price_cache::Cache,
+    ) -> native_price_cache::CachingNativePriceEstimator {
+        let inner = self
+            .native_price_estimator(native, results_required, weth)
+            .await
+            .expect("failed to build native price estimator");
+        let approximation_tokens = self
+            .build_approximation_tokens()
+            .await
+            .expect("failed to build native price approximation tokens");
+        native_price_cache::CachingNativePriceEstimator::new(
+            inner,
+            cache,
             self.args.native_price_cache_concurrent_requests,
             approximation_tokens,
             self.args.quote_timeout,
-        ));
-        Ok(native_estimator)
+        )
     }
 
     /// Builds the approximation tokens mapping with normalization factors based
diff --git a/crates/shared/src/price_estimation/mod.rs b/crates/shared/src/price_estimation/mod.rs
index 1535c742cc..e8bb14150b 100644
--- a/crates/shared/src/price_estimation/mod.rs
+++ b/crates/shared/src/price_estimation/mod.rs
@@ -164,15 +164,6 @@ pub struct Arguments {
     #[clap(long, env, verbatim_doc_comment)]
     pub price_estimation_rate_limiter: Option<Strategy>,
 
-    /// How often the native price estimator should refresh its cache.
-    #[clap(
-        long,
-        env,
-        default_value = "1s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub native_price_cache_refresh: Duration,
-
     /// How long cached native prices stay valid.
     #[clap(
         long,
@@ -182,23 +173,6 @@ pub struct Arguments {
     )]
     pub native_price_cache_max_age: Duration,
 
-    /// How long before expiry the native price cache should try to update the
-    /// price in the background. This is useful to make sure that prices are
-    /// usable at all times. This value has to be smaller than
-    /// `--native-price-cache-max-age`.
-    #[clap(
-        long,
-        env,
-        default_value = "80s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub native_price_prefetch_time: Duration,
-
-    /// How many cached native token prices can be updated at most in one
-    /// maintenance cycle.
-    #[clap(long, env, default_value = "3")]
-    pub native_price_cache_max_update_size: usize,
-
     /// How many price estimation requests can be executed concurrently in the
     /// maintenance task.
     #[clap(long, env, default_value = "1")]
@@ -354,10 +328,7 @@ impl Display for Arguments {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         let Self {
             price_estimation_rate_limiter,
-            native_price_cache_refresh,
             native_price_cache_max_age,
-            native_price_prefetch_time,
-            native_price_cache_max_update_size,
             native_price_cache_concurrent_requests,
             amount_to_estimate_prices_with,
             balancer_sor_url,
@@ -377,22 +348,10 @@ impl Display for Arguments {
             "price_estimation_rate_limites",
             price_estimation_rate_limiter,
         )?;
-        writeln!(
-            f,
-            "native_price_cache_refresh: {native_price_cache_refresh:?}"
-        )?;
         writeln!(
             f,
             "native_price_cache_max_age: {native_price_cache_max_age:?}"
         )?;
-        writeln!(
-            f,
-            "native_price_prefetch_time: {native_price_prefetch_time:?}"
-        )?;
-        writeln!(
-            f,
-            "native_price_cache_max_update_size: {native_price_cache_max_update_size}"
-        )?;
         writeln!(
             f,
             "native_price_cache_concurrent_requests: {native_price_cache_concurrent_requests}"
diff --git a/crates/shared/src/price_estimation/native_price_cache.rs b/crates/shared/src/price_estimation/native_price_cache.rs
index bf49185402..201d3dc3a5 100644
--- a/crates/shared/src/price_estimation/native_price_cache.rs
+++ b/crates/shared/src/price_estimation/native_price_cache.rs
@@ -6,14 +6,14 @@ use {
         from_normalized_price,
     },
     alloy::primitives::Address,
+    arc_swap::ArcSwap,
     bigdecimal::BigDecimal,
     futures::{FutureExt, StreamExt},
-    indexmap::IndexSet,
     prometheus::{IntCounter, IntCounterVec, IntGauge},
     rand::Rng,
     std::{
-        collections::{HashMap, hash_map::Entry},
-        sync::{Arc, Mutex, MutexGuard, Weak},
+        collections::{HashMap, HashSet},
+        sync::{Arc, Mutex, MutexGuard},
         time::{Duration, Instant},
     },
     tokio::time,
@@ -62,57 +62,30 @@ impl ApproximationToken {
 }
 
 #[derive(prometheus_metric_storage::MetricStorage)]
-struct Metrics {
+struct CacheMetrics {
     /// native price cache hits misses
     #[metric(labels("result"))]
     native_price_cache_access: IntCounterVec,
     /// number of items in cache
     native_price_cache_size: IntGauge,
-    /// number of background updates performed
-    native_price_cache_background_updates: IntCounter,
-    /// number of items in cache that are outdated
-    native_price_cache_outdated_entries: IntGauge,
 }
 
-impl Metrics {
+impl CacheMetrics {
     fn get() -> &'static Self {
-        Metrics::instance(observe::metrics::get_storage_registry()).unwrap()
+        CacheMetrics::instance(observe::metrics::get_storage_registry()).unwrap()
     }
 }
 
-/// Wrapper around `Box<dyn PriceEstimating>` which caches successful price
-/// estimates for some time and supports updating the cache in the background.
-///
-/// The size of the underlying cache is unbounded.
-///
-/// Is an Arc internally.
-#[derive(Clone)]
-pub struct CachingNativePriceEstimator(Arc<Inner>);
-
-struct Inner {
-    cache: Mutex<HashMap<Address, CachedResult>>,
-    high_priority: Mutex<IndexSet<Address>>,
-    estimator: Box<dyn NativePriceEstimating>,
-    max_age: Duration,
-    concurrent_requests: usize,
-    // TODO remove when implementing a less hacky solution
-    /// Maps a requested token to an approximating token. If the system
-    /// wants to get the native price for the requested token the native
-    /// price of the approximating token should be fetched and returned instead.
-    /// This can be useful for tokens that are hard to route but are pegged to
-    /// the same underlying asset so approximating their native prices is deemed
-    /// safe (e.g. csUSDL => Dai).
-    /// The normalization factor handles decimal differences between tokens.
-    /// After startup this is a read only value.
-    approximation_tokens: HashMap<Address, ApproximationToken>,
-    quote_timeout: Duration,
+#[derive(prometheus_metric_storage::MetricStorage)]
+struct UpdaterMetrics {
+    /// number of background updates performed
+    native_price_cache_background_updates: IntCounter,
 }
 
-struct UpdateTask {
-    inner: Weak<Inner>,
-    update_interval: Duration,
-    update_size: Option<usize>,
-    prefetch_time: Duration,
+impl UpdaterMetrics {
+    fn get() -> &'static Self {
+        UpdaterMetrics::instance(observe::metrics::get_storage_registry()).unwrap()
+    }
 }
 
 type CacheEntry = Result<f64, PriceEstimationError>;
@@ -131,25 +104,30 @@ struct CachedResult {
 const ACCUMULATIVE_ERRORS_THRESHOLD: u32 = 5;
 
 impl CachedResult {
-    fn new(
-        result: CacheEntry,
-        updated_at: Instant,
-        requested_at: Instant,
-        current_accumulative_errors_count: u32,
-    ) -> Self {
-        let estimator_internal_errors_count =
-            matches!(result, Err(PriceEstimationError::EstimatorInternal(_)))
-                .then_some(current_accumulative_errors_count + 1)
-                .unwrap_or_default();
+    fn new(result: CacheEntry) -> Self {
+        let now = Instant::now();
+        let is_accumulating_error =
+            matches!(result, Err(PriceEstimationError::EstimatorInternal(_)));
 
         Self {
             result,
-            updated_at,
-            requested_at,
-            accumulative_errors_count: estimator_internal_errors_count,
+            updated_at: now,
+            requested_at: now,
+            accumulative_errors_count: u32::from(is_accumulating_error),
         }
     }
 
+    fn update(&mut self, result: CacheEntry) {
+        let now = Instant::now();
+        self.requested_at = now;
+        self.updated_at = now;
+        self.accumulative_errors_count = match result {
+            Err(PriceEstimationError::EstimatorInternal(_)) => self.accumulative_errors_count + 1,
+            _ => 0,
+        };
+        self.result = result;
+    }
+
     /// The result is not ready if the estimator has returned an internal error
     /// and consecutive errors are less than
     /// `ESTIMATOR_INTERNAL_ERRORS_THRESHOLD`.
@@ -159,132 +137,6 @@ impl CachedResult {
     }
 }
 
-impl Inner {
-    // Returns a single cached price and updates its `requested_at` field.
-    fn get_cached_price(
-        token: Address,
-        now: Instant,
-        cache: &mut MutexGuard<HashMap<Address, CachedResult>>,
-        max_age: &Duration,
-        create_missing_entry: bool,
-    ) -> Option<CachedResult> {
-        match cache.entry(token) {
-            Entry::Occupied(mut entry) => {
-                let entry = entry.get_mut();
-                entry.requested_at = now;
-                let is_recent = now.saturating_duration_since(entry.updated_at) < *max_age;
-                is_recent.then_some(entry.clone())
-            }
-            Entry::Vacant(entry) => {
-                if create_missing_entry {
-                    // Create an outdated cache entry so the background task keeping the cache warm
-                    // will fetch the price during the next maintenance cycle.
-                    // This should happen only for prices missing while building the auction.
-                    // Otherwise malicious actors could easily cause the cache size to blow up.
-                    let outdated_timestamp = now.checked_sub(*max_age).unwrap();
-                    tracing::trace!(?token, "create outdated price entry");
-                    entry.insert(CachedResult::new(
-                        Ok(0.),
-                        outdated_timestamp,
-                        now,
-                        Default::default(),
-                    ));
-                }
-                None
-            }
-        }
-    }
-
-    fn get_ready_to_use_cached_price(
-        token: Address,
-        now: Instant,
-        cache: &mut MutexGuard<HashMap<Address, CachedResult>>,
-        max_age: &Duration,
-        create_missing_entry: bool,
-    ) -> Option<CachedResult> {
-        Self::get_cached_price(token, now, cache, max_age, create_missing_entry)
-            .filter(|cached| cached.is_ready())
-    }
-
-    /// Checks cache for the given tokens one by one. If the price is already
-    /// cached, it gets returned. If it's not in the cache, a new price
-    /// estimation request gets issued. We check the cache before each
-    /// request because they can take a long time and some other task might
-    /// have fetched some requested price in the meantime.
-    fn estimate_prices_and_update_cache<'a>(
-        &'a self,
-        tokens: &'a [Address],
-        max_age: Duration,
-        request_timeout: Duration,
-    ) -> futures::stream::BoxStream<'a, (Address, NativePriceEstimateResult)> {
-        let estimates = tokens.iter().map(move |token| async move {
-            let current_accumulative_errors_count = {
-                // check if the price is cached by now
-                let now = Instant::now();
-                let mut cache = self.cache.lock().unwrap();
-
-                match Self::get_cached_price(*token, now, &mut cache, &max_age, false) {
-                    Some(cached) if cached.is_ready() => {
-                        return (*token, cached.result);
-                    }
-                    Some(cached) => cached.accumulative_errors_count,
-                    None => Default::default(),
-                }
-            };
-
-            let approximation = self
-                .approximation_tokens
-                .get(token)
-                .copied()
-                .unwrap_or(ApproximationToken::same_decimals(*token));
-
-            let result = self
-                .estimator
-                .estimate_native_price(approximation.address, request_timeout)
-                .await
-                .map(|price| approximation.normalize_price(price));
-
-            // update price in cache
-            if should_cache(&result) {
-                let now = Instant::now();
-                let mut cache = self.cache.lock().unwrap();
-
-                cache.insert(
-                    *token,
-                    CachedResult::new(result.clone(), now, now, current_accumulative_errors_count),
-                );
-            };
-
-            (*token, result)
-        });
-        futures::stream::iter(estimates)
-            .buffered(self.concurrent_requests)
-            .boxed()
-    }
-
-    /// Tokens with highest priority first.
-    fn sorted_tokens_to_update(&self, max_age: Duration, now: Instant) -> Vec<Address> {
-        let mut outdated: Vec<_> = self
-            .cache
-            .lock()
-            .unwrap()
-            .iter()
-            .filter(|(_, cached)| now.saturating_duration_since(cached.updated_at) > max_age)
-            .map(|(token, cached)| (*token, cached.requested_at))
-            .collect();
-
-        let high_priority = self.high_priority.lock().unwrap().clone();
-        let index = |token: &Address| high_priority.get_index_of(token).unwrap_or(usize::MAX);
-        outdated.sort_by_cached_key(|entry| {
-            (
-                index(&entry.0),            // important items have a low index
-                std::cmp::Reverse(entry.1), // important items have recent (i.e. "big") timestamp
-            )
-        });
-        outdated.into_iter().map(|(token, _)| token).collect()
-    }
-}
-
 fn should_cache(result: &Result<f64, PriceEstimationError>) -> bool {
     // We don't want to cache errors that we consider transient
     match result {
@@ -302,137 +154,84 @@ fn should_cache(result: &Result<f64, PriceEstimationError>) -> bool {
     }
 }
 
-impl UpdateTask {
-    /// Single run of the background updating process.
-    async fn single_update(&self, inner: &Inner) {
-        let metrics = Metrics::get();
-        metrics
-            .native_price_cache_size
-            .set(i64::try_from(inner.cache.lock().unwrap().len()).unwrap_or(i64::MAX));
-
-        let max_age = inner.max_age.saturating_sub(self.prefetch_time);
-        let mut outdated_entries = inner.sorted_tokens_to_update(max_age, Instant::now());
-
-        tracing::trace!(tokens = ?outdated_entries, first_n = ?self.update_size, "outdated prices to fetch");
-
-        metrics
-            .native_price_cache_outdated_entries
-            .set(i64::try_from(outdated_entries.len()).unwrap_or(i64::MAX));
-
-        outdated_entries.truncate(self.update_size.unwrap_or(usize::MAX));
-
-        if outdated_entries.is_empty() {
-            return;
-        }
-
-        let mut stream =
-            inner.estimate_prices_and_update_cache(&outdated_entries, max_age, inner.quote_timeout);
-        while stream.next().await.is_some() {}
-        metrics
-            .native_price_cache_background_updates
-            .inc_by(outdated_entries.len() as u64);
-    }
+/// Passive shared data store for native price cache entries. Clone via internal
+/// `Arc`.
+#[derive(Clone)]
+pub struct Cache(Arc<CacheInner>);
 
-    /// Runs background updates until inner is no longer alive.
-    async fn run(self) {
-        while let Some(inner) = self.inner.upgrade() {
-            let now = Instant::now();
-            self.single_update(&inner).await;
-            tokio::time::sleep(self.update_interval.saturating_sub(now.elapsed())).await;
-        }
-    }
+struct CacheInner {
+    data: Mutex<HashMap<Address, CachedResult>>,
+    max_age: Duration,
 }
 
-impl CachingNativePriceEstimator {
-    pub fn initialize_cache(&self, prices: HashMap<Address, BigDecimal>) {
+impl Cache {
+    pub fn new(max_age: Duration, initial_prices: HashMap<Address, BigDecimal>) -> Self {
         let mut rng = rand::thread_rng();
         let now = std::time::Instant::now();
 
-        let cache = prices
+        let data = initial_prices
             .into_iter()
             .filter_map(|(token, price)| {
-                // Generate random `updated_at` timestamp
-                // to avoid spikes of expired prices.
-                let percent_expired = rng.gen_range(50..=90);
-                let age = self.0.max_age.as_secs() * percent_expired / 100;
-                let updated_at = now - Duration::from_secs(age);
-
+                let updated_at = Self::random_updated_at(max_age, now, &mut rng);
                 Some((
                     token,
-                    CachedResult::new(
-                        Ok(from_normalized_price(price)?),
+                    CachedResult {
+                        result: Ok(from_normalized_price(price)?),
                         updated_at,
-                        now,
-                        Default::default(),
-                    ),
+                        requested_at: now,
+                        accumulative_errors_count: 0,
+                    },
                 ))
             })
             .collect::<HashMap<_, _>>();
 
-        *self.0.cache.lock().unwrap() = cache;
+        Self(Arc::new(CacheInner {
+            data: Mutex::new(data),
+            max_age,
+        }))
     }
 
-    /// Creates new CachingNativePriceEstimator using `estimator` to calculate
-    /// native prices which get cached a duration of `max_age`.
-    /// Spawns a background task maintaining the cache once per
-    /// `update_interval`. Only soon to be outdated prices get updated and
-    /// recently used prices have a higher priority. If `update_size` is
-    /// `Some(n)` at most `n` prices get updated per interval.
-    /// If `update_size` is `None` no limit gets applied.
-    #[expect(clippy::too_many_arguments)]
-    pub fn new(
-        estimator: Box<dyn NativePriceEstimating>,
-        max_age: Duration,
-        update_interval: Duration,
-        update_size: Option<usize>,
-        prefetch_time: Duration,
-        concurrent_requests: usize,
-        approximation_tokens: HashMap<Address, ApproximationToken>,
-        quote_timeout: Duration,
-    ) -> Self {
-        let inner = Arc::new(Inner {
-            estimator,
-            cache: Default::default(),
-            high_priority: Default::default(),
-            max_age,
-            concurrent_requests,
-            approximation_tokens,
-            quote_timeout,
-        });
+    fn max_age(&self) -> Duration {
+        self.0.max_age
+    }
 
-        let update_task = UpdateTask {
-            inner: Arc::downgrade(&inner),
-            update_interval,
-            update_size,
-            prefetch_time,
-        }
-        .run()
-        .instrument(tracing::info_span!("caching_native_price_estimator"));
-        tokio::spawn(update_task);
+    /// Returns a randomized `updated_at` timestamp that is 50-90% of max_age
+    /// in the past, to avoid spikes of expired prices all being fetched at
+    /// once.
+    fn random_updated_at(max_age: Duration, now: Instant, rng: &mut impl Rng) -> Instant {
+        let percent_expired = rng.gen_range(50..=90);
+        let age = max_age.as_secs() * percent_expired / 100;
+        now - Duration::from_secs(age)
+    }
 
-        Self(inner)
+    fn len(&self) -> usize {
+        self.0.data.lock().unwrap().len()
     }
 
-    /// Only returns prices that are currently cached. Missing prices will get
-    /// prioritized to get fetched during the next cycles of the maintenance
-    /// background task.
+    fn get_cached_price(
+        token: Address,
+        now: Instant,
+        cache: &mut MutexGuard<HashMap<Address, CachedResult>>,
+        max_age: &Duration,
+    ) -> Option<CachedResult> {
+        let entry = cache.get_mut(&token)?;
+        entry.requested_at = now;
+        let is_recent = now.saturating_duration_since(entry.updated_at) < *max_age;
+        (is_recent && entry.is_ready()).then_some(entry.clone())
+    }
+
+    /// Only returns prices that are currently cached.
     fn get_cached_prices(
         &self,
         tokens: &[Address],
     ) -> HashMap<Address, Result<f64, PriceEstimationError>> {
         let now = Instant::now();
-        let mut cache = self.0.cache.lock().unwrap();
+        let mut cache = self.0.data.lock().unwrap();
         let mut results = HashMap::default();
         for token in tokens {
-            let cached = Inner::get_ready_to_use_cached_price(
-                *token,
-                now,
-                &mut cache,
-                &self.0.max_age,
-                true,
-            );
+            let cached = Self::get_cached_price(*token, now, &mut cache, &self.0.max_age);
             let label = if cached.is_some() { "hits" } else { "misses" };
-            Metrics::get()
+            CacheMetrics::get()
                 .native_price_cache_access
                 .with_label_values(&[label])
                 .inc_by(1);
@@ -443,17 +242,118 @@ impl CachingNativePriceEstimator {
         results
     }
 
-    pub fn replace_high_priority(&self, tokens: IndexSet<Address>) {
-        tracing::trace!(?tokens, "update high priority tokens");
-        *self.0.high_priority.lock().unwrap() = tokens;
+    fn insert(&self, token: Address, result: CacheEntry) {
+        let mut cache = self.0.data.lock().unwrap();
+        cache
+            .entry(token)
+            .and_modify(|value| value.update(result.clone()))
+            .or_insert_with(|| CachedResult::new(result));
+    }
+}
+
+/// Wrapper around `Box<dyn NativePriceEstimating>` which caches successful
+/// price estimates for some time. Does not spawn any background tasks.
+///
+/// Is an Arc internally.
+#[derive(Clone)]
+pub struct CachingNativePriceEstimator(Arc<CachingInner>);
+
+struct CachingInner {
+    estimator: Box<dyn NativePriceEstimating>,
+    cache: Cache,
+    concurrent_requests: usize,
+    // TODO remove when implementing a less hacky solution
+    /// Maps a requested token to an approximating token. If the system
+    /// wants to get the native price for the requested token the native
+    /// price of the approximating token should be fetched and returned instead.
+    /// This can be useful for tokens that are hard to route but are pegged to
+    /// the same underlying asset so approximating their native prices is deemed
+    /// safe (e.g. csUSDL => Dai).
+    /// The normalization factor handles decimal differences between tokens.
+    /// After startup this is a read only value.
+    approximation_tokens: HashMap<Address, ApproximationToken>,
+    quote_timeout: Duration,
+}
+
+impl CachingNativePriceEstimator {
+    pub fn new(
+        estimator: Box<dyn NativePriceEstimating>,
+        cache: Cache,
+        concurrent_requests: usize,
+        approximation_tokens: HashMap<Address, ApproximationToken>,
+        quote_timeout: Duration,
+    ) -> Self {
+        let inner = Arc::new(CachingInner {
+            estimator,
+            cache,
+            concurrent_requests,
+            approximation_tokens,
+            quote_timeout,
+        });
+        Self(inner)
     }
 
-    pub async fn estimate_native_prices_with_timeout<'a>(
+    /// Checks cache for the given tokens one by one. If the price is already
+    /// cached, it gets returned. If it's not in the cache, a new price
+    /// estimation request gets issued. We check the cache before each
+    /// request because they can take a long time and some other task might
+    /// have fetched some requested price in the meantime.
+    fn estimate_prices_and_update_cache<'a, I>(
         &'a self,
-        tokens: &'a [Address],
+        tokens: I,
+        max_age: Duration,
+        request_timeout: Duration,
+    ) -> futures::stream::BoxStream<'a, (Address, NativePriceEstimateResult)>
+    where
+        I: IntoIterator<Item = Address>,
+        I::IntoIter: Send + 'a,
+    {
+        let estimates = tokens.into_iter().map(move |token| async move {
+            // check if the price is cached by now
+            let now = Instant::now();
+            {
+                let mut cache = self.0.cache.0.data.lock().unwrap();
+                if let Some(cached) = Cache::get_cached_price(token, now, &mut cache, &max_age) {
+                    return (token, cached.result);
+                }
+            }
+
+            let approximation = self
+                .0
+                .approximation_tokens
+                .get(&token)
+                .copied()
+                .unwrap_or(ApproximationToken::same_decimals(token));
+
+            let result = self
+                .0
+                .estimator
+                .estimate_native_price(approximation.address, request_timeout)
+                .await
+                .map(|price| approximation.normalize_price(price));
+
+            // update price in cache
+            if should_cache(&result) {
+                self.0.cache.insert(token, result.clone());
+            };
+
+            (token, result)
+        });
+        futures::stream::iter(estimates)
+            .buffered(self.0.concurrent_requests)
+            .boxed()
+    }
+
+    fn cache(&self) -> &Cache {
+        &self.0.cache
+    }
+
+    pub async fn fetch_prices(
+        &self,
+        tokens: &[Address],
         timeout: Duration,
     ) -> HashMap<Address, NativePriceEstimateResult> {
-        let mut prices = self.get_cached_prices(tokens);
+        let mut prices = self.0.cache.get_cached_prices(tokens);
         if timeout.is_zero() {
             return prices;
         }
@@ -464,8 +364,7 @@ impl CachingNativePriceEstimator {
             .copied()
             .collect();
         let price_stream =
-            self.0
-                .estimate_prices_and_update_cache(&uncached_tokens, self.0.max_age, timeout);
+            self.estimate_prices_and_update_cache(uncached_tokens, self.0.cache.max_age(), timeout);
 
         let _ = time::timeout(timeout, async {
             let mut price_stream = price_stream;
@@ -491,12 +390,12 @@ impl NativePriceEstimating for CachingNativePriceEstimator {
         async move {
             let cached = {
                 let now = Instant::now();
-                let mut cache = self.0.cache.lock().unwrap();
-                Inner::get_ready_to_use_cached_price(token, now, &mut cache, &self.0.max_age, false)
+                let mut cache = self.0.cache.0.data.lock().unwrap();
+                Cache::get_cached_price(token, now, &mut cache, &self.0.cache.0.max_age)
             };
 
             let label = if cached.is_some() { "hits" } else { "misses" };
-            Metrics::get()
+            CacheMetrics::get()
                 .native_price_cache_access
                 .with_label_values(&[label])
                 .inc_by(1);
@@ -505,8 +404,7 @@ impl NativePriceEstimating for CachingNativePriceEstimator {
                 return cached.result;
             }
 
-            self.0
-                .estimate_prices_and_update_cache(&[token], self.0.max_age, timeout)
+            self.estimate_prices_and_update_cache([token], self.0.cache.max_age(), timeout)
                 .next()
                 .await
                 .unwrap()
@@ -516,6 +414,98 @@ impl NativePriceEstimating for CachingNativePriceEstimator {
     }
 }
 
+/// Background maintenance worker that periodically updates native prices
+/// for a set of tokens. Uses a `CachingNativePriceEstimator` for fetching
+/// and caching prices.
+pub struct NativePriceUpdater {
+    estimator: CachingNativePriceEstimator,
+    tokens_to_update: ArcSwap<HashSet<Address>>,
+}
+
+impl NativePriceUpdater {
+    pub fn new(
+        estimator: CachingNativePriceEstimator,
+        update_interval: Duration,
+        prefetch_time: Duration,
+    ) -> Arc<Self> {
+        assert!(
+            estimator.cache().max_age() > prefetch_time,
+            "price cache prefetch time ({:?}) must be less than max age ({:?})",
+            prefetch_time,
+            estimator.cache().max_age(),
+        );
+
+        let updater = Arc::new(Self {
+            estimator,
+            tokens_to_update: ArcSwap::new(Arc::new(HashSet::new())),
+        });
+
+        // Don't keep the updater alive just for the background task
+        let weak = Arc::downgrade(&updater);
+        let update_task = async move {
+            while let Some(updater) = weak.upgrade() {
+                let now = Instant::now();
+                updater.single_update(prefetch_time).await;
+                drop(updater);
+                tokio::time::sleep(update_interval.saturating_sub(now.elapsed())).await;
+            }
+        }
+        .instrument(tracing::info_span!("native_price_updater"));
+        tokio::spawn(update_task);
+
+        updater
+    }
+
+    /// Replaces the full set of tokens that should be maintained by the
+    /// background task and fetches their current prices.
+    pub async fn update_tokens_and_fetch_prices(
+        &self,
+        tokens: HashSet<Address>,
+        timeout: Duration,
+    ) -> HashMap<Address, NativePriceEstimateResult> {
+        tracing::trace!(?tokens, "update tokens to maintain");
+        let token_list: Vec<_> = tokens.iter().copied().collect();
+        self.tokens_to_update.store(Arc::new(tokens));
+        self.estimator.fetch_prices(&token_list, timeout).await
+    }
+
+    async fn single_update(&self, prefetch_time: Duration) {
+        let metrics = UpdaterMetrics::get();
+        let cache = self.estimator.cache();
+
+        CacheMetrics::get()
+            .native_price_cache_size
+            .set(i64::try_from(cache.len()).unwrap_or(i64::MAX));
+
+        let tokens_to_update = self.tokens_to_update.load_full();
+        if tokens_to_update.is_empty() {
+            return;
+        }
+
+        let max_age = cache.max_age().saturating_sub(prefetch_time);
+        let timeout = self.estimator.0.quote_timeout;
+        self.estimator
+            .estimate_prices_and_update_cache(tokens_to_update.iter().copied(), max_age, timeout)
+            // Drive the stream to completion. Results are written to the cache as
+            // a side effect, so we don't need to inspect them here.
+            .for_each(|_| async {})
+            .await;
+        metrics
+            .native_price_cache_background_updates
+            .inc_by(tokens_to_update.len() as u64);
+    }
+}
+
+impl NativePriceEstimating for NativePriceUpdater {
+    fn estimate_native_price(
+        &self,
+        token: Address,
+        timeout: Duration,
+    ) -> futures::future::BoxFuture<'_, NativePriceEstimateResult> {
+        self.estimator.estimate_native_price(token, timeout)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use {
@@ -534,6 +524,24 @@ mod tests {
         Address::left_padding_from(&u.to_be_bytes())
     }
 
+    /// Helper to create a CachingNativePriceEstimator with its own Cache
+    /// (convenience for tests that don't need a separate Cache).
+    fn create_caching_estimator(
+        inner: MockNativePriceEstimating,
+        max_age: Duration,
+        concurrent_requests: usize,
+        approximation_tokens: HashMap<Address, ApproximationToken>,
+    ) -> CachingNativePriceEstimator {
+        let cache = Cache::new(max_age, Default::default());
+        CachingNativePriceEstimator::new(
+            Box::new(inner),
+            cache,
+            concurrent_requests,
+            approximation_tokens,
+            HEALTHY_PRICE_ESTIMATION_TIME,
+        )
+    }
+
     #[tokio::test]
     async fn caches_successful_estimates_with_loaded_prices() {
         let mut inner = MockNativePriceEstimating::new();
@@ -545,23 +553,20 @@ mod tests {
 
         let prices =
             HashMap::from_iter((0..10).map(|t| (token(t), BigDecimal::try_from(1e18).unwrap())));
+        let cache = Cache::new(Duration::from_secs(MAX_AGE_SECS), prices);
         let estimator = CachingNativePriceEstimator::new(
             Box::new(inner),
-            Duration::from_secs(MAX_AGE_SECS),
-            Default::default(),
-            None,
-            Default::default(),
+            cache,
             1,
             Default::default(),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
-        estimator.initialize_cache(prices);
 
         {
             // Check that `updated_at` timestamps are initialized with
             // reasonable values.
-            let cache = estimator.0.cache.lock().unwrap();
-            for value in cache.values() {
+            let data = estimator.cache().0.data.lock().unwrap();
+            for value in data.values() {
                 let elapsed = value.updated_at.elapsed();
                 assert!(elapsed >= min_age && elapsed <= max_age);
             }
@@ -583,16 +588,8 @@ mod tests {
             .times(1)
             .returning(|_, _| async { Ok(1.0) }.boxed());
 
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
-            Duration::from_millis(30),
-            Default::default(),
-            None,
-            Default::default(),
-            1,
-            Default::default(),
-            HEALTHY_PRICE_ESTIMATION_TIME,
-        );
+        let estimator =
+            create_caching_estimator(inner, Duration::from_millis(30), 1, Default::default());
 
         for _ in 0..10 {
             let result = estimator
@@ -621,12 +618,9 @@ mod tests {
             .withf(move |t, _| *t == token(200))
             .returning(|_, _| async { Ok(200.0) }.boxed());
 
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
+        let estimator = create_caching_estimator(
+            inner,
             Duration::from_millis(30),
-            Default::default(),
-            None,
-            Default::default(),
             1,
             // set token approximations for tokens 1 and 2 (same decimals)
             HashMap::from([
@@ -639,7 +633,6 @@ mod tests {
                     ApproximationToken::same_decimals(Address::with_last_byte(200)),
                 ),
             ]),
-            HEALTHY_PRICE_ESTIMATION_TIME,
         );
 
         // no approximation token used for token 0
@@ -689,18 +682,14 @@ mod tests {
         // from_decimals=6 (USDC), to_decimals=18 (DAI)
         // Normalization factor = 10^(18-6) = 10^12
         // Price should be 5e-22 * 10^12 = 5e-10 ETH per USDC microunit
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
+        let estimator = create_caching_estimator(
+            inner,
             Duration::from_millis(30),
-            Default::default(),
-            None,
-            Default::default(),
             1,
             HashMap::from([(
                 Address::with_last_byte(1),
                 ApproximationToken::with_normalization((Address::with_last_byte(100), 18), 6),
             )]),
-            HEALTHY_PRICE_ESTIMATION_TIME,
         );
 
         let price = estimator
@@ -731,18 +720,14 @@ mod tests {
         // from_decimals=18 (DAI), to_decimals=6 (USDC)
         // Normalization factor = 10^(6-18) = 10^-12
         // Price should be 5e-10 * 10^-12 = 5e-22 ETH per DAI wei
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
+        let estimator = create_caching_estimator(
+            inner,
             Duration::from_millis(30),
-            Default::default(),
-            None,
-            Default::default(),
             1,
             HashMap::from([(
                 Address::with_last_byte(1),
                 ApproximationToken::with_normalization((Address::with_last_byte(100), 6), 18),
             )]),
-            HEALTHY_PRICE_ESTIMATION_TIME,
         );
 
         let price = estimator
@@ -767,16 +752,8 @@ mod tests {
             .times(1)
             .returning(|_, _| async { Err(PriceEstimationError::NoLiquidity) }.boxed());
 
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
-            Duration::from_millis(30),
-            Default::default(),
-            None,
-            Default::default(),
-            1,
-            Default::default(),
-            HEALTHY_PRICE_ESTIMATION_TIME,
-        );
+        let estimator =
+            create_caching_estimator(inner, Duration::from_millis(30), 1, Default::default());
 
         for _ in 0..10 {
             let result = estimator
@@ -838,16 +815,8 @@ mod tests {
                 async { Err(PriceEstimationError::EstimatorInternal(anyhow!("boom"))) }.boxed()
             });
 
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
-            Duration::from_millis(100),
-            Duration::from_millis(200),
-            None,
-            Default::default(),
-            1,
-            Default::default(),
-            HEALTHY_PRICE_ESTIMATION_TIME,
-        );
+        let estimator =
+            create_caching_estimator(inner, Duration::from_millis(100), 1, Default::default());
 
         // First 3 calls: The cache is not used. Counter gets increased.
         for _ in 0..3 {
@@ -910,16 +879,8 @@ mod tests {
             .times(10)
             .returning(|_, _| async { Err(PriceEstimationError::RateLimited) }.boxed());
 
-        let estimator = CachingNativePriceEstimator::new(
-            Box::new(inner),
-            Duration::from_millis(30),
-            Default::default(),
-            None,
-            Default::default(),
-            1,
-            Default::default(),
-            HEALTHY_PRICE_ESTIMATION_TIME,
-        );
+        let estimator =
+            create_caching_estimator(inner, Duration::from_millis(30), 1, Default::default());
 
         for _ in 0..10 {
             let result = estimator
@@ -951,33 +912,28 @@ mod tests {
                 assert_eq!(passed_token, token(1));
                 async { Ok(2.0) }.boxed()
             });
-        // maintenance task updates n=1 outdated prices
+        // maintenance task updates outdated prices (order is non-deterministic)
         inner
             .expect_estimate_native_price()
-            .times(1)
-            .returning(|passed_token, _| {
-                assert_eq!(passed_token, token(1));
-                async { Ok(4.0) }.boxed()
-            });
-        // user requested something which has been skipped by the maintenance task
-        inner
-            .expect_estimate_native_price()
-            .times(1)
+            .times(2)
             .returning(|passed_token, _| {
-                assert_eq!(passed_token, token(0));
-                async { Ok(3.0) }.boxed()
+                let price = if passed_token == token(0) { 3.0 } else { 4.0 };
+                async move { Ok(price) }.boxed()
             });
 
+        let cache = Cache::new(Duration::from_millis(30), Default::default());
         let estimator = CachingNativePriceEstimator::new(
             Box::new(inner),
-            Duration::from_millis(30),
-            Duration::from_millis(50),
-            Some(1),
-            Duration::default(),
+            cache,
             1,
             Default::default(),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
+        let updater = NativePriceUpdater::new(
+            estimator.clone(),
+            Duration::from_millis(50),
+            Duration::default(),
+        );
 
         // fill cache with 2 different queries
         let result = estimator
@@ -989,6 +945,14 @@ mod tests {
             .await;
         assert_eq!(result.as_ref().unwrap().to_i64().unwrap(), 2);
 
+        // Tell the updater about these tokens
+        updater
+            .update_tokens_and_fetch_prices(
+                [token(0), token(1)].into_iter().collect(),
+                Duration::ZERO,
+            )
+            .await;
+
         // wait for maintenance cycle
         tokio::time::sleep(Duration::from_millis(60)).await;
 
@@ -1010,22 +974,28 @@ mod tests {
             .expect_estimate_native_price()
             .times(10)
             .returning(move |_, _| async { Ok(1.0) }.boxed());
-        // background task updates all outdated prices
         inner
             .expect_estimate_native_price()
             .times(10)
             .returning(move |_, _| async { Ok(2.0) }.boxed());
 
+        let cache = Cache::new(Duration::from_millis(30), Default::default());
         let estimator = CachingNativePriceEstimator::new(
             Box::new(inner),
-            Duration::from_millis(30),
-            Duration::from_millis(50),
-            None,
-            Duration::default(),
+            cache,
             1,
             Default::default(),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
+        let all_tokens: HashSet<_> = (0..10).map(Address::with_last_byte).collect();
+        let updater = NativePriceUpdater::new(
+            estimator.clone(),
+            Duration::from_millis(50),
+            Duration::default(),
+        );
+        updater
+            .update_tokens_and_fetch_prices(all_tokens, Duration::ZERO)
+            .await;
 
         let tokens: Vec<_> = (0..10).map(Address::with_last_byte).collect();
         for token in &tokens {
@@ -1057,7 +1027,6 @@ mod tests {
             .expect_estimate_native_price()
             .times(BATCH_SIZE)
             .returning(|_, _| async { Ok(1.0) }.boxed());
-        // background task updates all outdated prices
         inner
             .expect_estimate_native_price()
             .times(BATCH_SIZE)
@@ -1069,16 +1038,25 @@ mod tests {
                 .boxed()
             });
 
+        let cache = Cache::new(Duration::from_millis(30), Default::default());
         let estimator = CachingNativePriceEstimator::new(
             Box::new(inner),
-            Duration::from_millis(30),
-            Duration::from_millis(50),
-            None,
-            Duration::default(),
+            cache,
             BATCH_SIZE,
             Default::default(),
             HEALTHY_PRICE_ESTIMATION_TIME,
         );
+        let all_tokens: HashSet<_> = (0..BATCH_SIZE as u64)
+            .map(|u| Address::left_padding_from(&u.to_be_bytes()))
+            .collect();
+        let updater = NativePriceUpdater::new(
+            estimator.clone(),
+            Duration::from_millis(50),
+            Duration::default(),
+        );
+        updater
+            .update_tokens_and_fetch_prices(all_tokens, Duration::ZERO)
+            .await;
 
         let tokens: Vec<_> = (0..BATCH_SIZE as u64).map(token).collect();
         for token in &tokens {
@@ -1090,9 +1068,6 @@ mod tests {
         }
 
         // wait for maintenance cycle
-        // although we have 100 requests which all take 100ms to complete the
-        // maintenance cycle completes sooner because all requests are handled
-        // concurrently.
         tokio::time::sleep(Duration::from_millis(60 + WAIT_TIME_MS)).await;
 
         for token in &tokens {
@@ -1103,39 +1078,4 @@ mod tests {
             assert_eq!(price.to_i64().unwrap(), 2);
         }
     }
-
-    #[test]
-    fn outdated_entries_prioritized() {
-        let t0 = Address::with_last_byte(0);
-        let t1 = Address::with_last_byte(1);
-        let now = Instant::now();
-        let inner = Inner {
-            cache: Mutex::new(
-                [
-                    (t0, CachedResult::new(Ok(0.), now, now, Default::default())),
-                    (t1, CachedResult::new(Ok(0.), now, now, Default::default())),
-                ]
-                .into_iter()
-                .collect(),
-            ),
-            high_priority: Default::default(),
-            estimator: Box::new(MockNativePriceEstimating::new()),
-            max_age: Default::default(),
-            concurrent_requests: 1,
-            approximation_tokens: Default::default(),
-            quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-        };
-
-        let now = now + Duration::from_secs(1);
-
-        *inner.high_priority.lock().unwrap() = std::iter::once(t0).collect();
-        let tokens = inner.sorted_tokens_to_update(Duration::from_secs(0), now);
-        assert_eq!(tokens[0], t0);
-        assert_eq!(tokens[1], t1);
-
-        *inner.high_priority.lock().unwrap() = std::iter::once(t1).collect();
-        let tokens = inner.sorted_tokens_to_update(Duration::from_secs(0), now);
-        assert_eq!(tokens[0], t1);
-        assert_eq!(tokens[1], t0);
-    }
 }

From d72d91d0e9aa7a09221331aed8a3103fd5b73490 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 12 Feb 2026 09:26:01 +0100
Subject: [PATCH 051/219] Skip checks for defined appCodes (#4118)

# Description

For the integration with Euler we want to skip balance checks, because
the order will get the necessary funds from wrapper execution. This PR
skip balance checks where wrappers are defined, mirroring what we do for
flash loans with flash loan hints.

Signature checks are skipped for all 1271 orders, but kept for
presign/Eip712 as these should always be valid independent of
prehooks/wrappers. We have been running this way in prod for a while and
I just cleaned up the flags.

# Changes

- [x] Skip balance validation for ordres with wrappers
- [x] A cache so we don't keep parsing appdata for every auction
- [x] Nuked disable_1271_order_sig_filter and
disable_1271_order_balance_filter config flags - 1271 now just always
skips these checks

## How to test

Unit tests.
---
 Cargo.lock                                  |   1 +
 crates/app-data/Cargo.toml                  |   1 +
 crates/app-data/src/app_data.rs             |  47 +++
 crates/autopilot/Cargo.toml                 |   2 +-
 crates/autopilot/src/arguments.rs           |  21 --
 crates/autopilot/src/run.rs                 |  13 -
 crates/autopilot/src/solvable_orders.rs     | 306 ++++++++------------
 crates/driver/src/domain/competition/mod.rs |   5 +
 crates/shared/src/order_validation.rs       |   6 +-
 9 files changed, 177 insertions(+), 225 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index afda6769b8..540b74e1fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -840,6 +840,7 @@ dependencies = [
  "bytes-hex",
  "const-hex",
  "hex-literal",
+ "moka",
  "number",
  "serde",
  "serde_json",
diff --git a/crates/app-data/Cargo.toml b/crates/app-data/Cargo.toml
index b8cd0e1ff0..7265a009b4 100644
--- a/crates/app-data/Cargo.toml
+++ b/crates/app-data/Cargo.toml
@@ -10,6 +10,7 @@ alloy = { workspace = true, features = ["serde"] }
 anyhow = { workspace = true }
 bytes-hex = { workspace = true }
 const-hex = { workspace = true }
+moka = { workspace = true, features = ["sync"] }
 number = { path = "../number" }
 serde = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/app-data/src/app_data.rs b/crates/app-data/src/app_data.rs
index 0f997acf51..ac5b49fe50 100644
--- a/crates/app-data/src/app_data.rs
+++ b/crates/app-data/src/app_data.rs
@@ -3,6 +3,7 @@ use {
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result, anyhow},
     bytes_hex::BytesHex,
+    moka::sync::Cache,
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Deserializer, Serialize, Serializer, de},
     serde_with::serde_as,
@@ -343,6 +344,34 @@ impl Root {
     }
 }
 
+/// Caches whether a given app data document contains wrappers, keyed by
+/// hash. This avoids re-parsing the same JSON across orders and auction
+/// cycles. We're using the default TinyLFU eviction policy, but the capacity is
+/// large enough that we don't expect eviction to be a problem in practice, but
+/// we limit the size to prevent potential memory exhaustion attacks.
+pub struct WrapperCache(Cache<AppDataHash, bool>);
+
+impl WrapperCache {
+    pub fn new(capacity: u64) -> Self {
+        Self(Cache::new(capacity))
+    }
+
+    /// Returns `true` if order appData contains non-empty wrappers
+    pub fn has_wrappers(&self, hash: &AppDataHash, document: Option<&str>) -> bool {
+        if let Some(cached) = self.0.get(hash) {
+            return cached;
+        }
+        let result = document.is_some_and(|doc| {
+            serde_json::from_str::<Root>(doc)
+                .ok()
+                .and_then(|root| root.metadata)
+                .is_some_and(|m| !m.wrappers.is_empty())
+        });
+        self.0.insert(*hash, result);
+        result
+    }
+}
+
 // uid as 56 bytes: 32 for orderDigest, 20 for ownerAddress and 4 for validTo
 #[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct OrderUid(pub [u8; 56]);
@@ -770,6 +799,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn wrapper_cache_detects_wrappers() {
+        let cache = WrapperCache::new(100);
+        let h = |b: u8| AppDataHash([b; 32]);
+
+        assert!(!cache.has_wrappers(&h(1), None));
+        assert!(!cache.has_wrappers(&h(2), Some("{}")));
+        assert!(!cache.has_wrappers(&h(3), Some(r#"{"metadata": {}}"#)));
+        assert!(!cache.has_wrappers(&h(4), Some(r#"{"metadata": {"wrappers": []}}"#)));
+        assert!(cache.has_wrappers(
+            &h(5),
+            Some(r#"{"metadata": {"wrappers": [{"address": "0x0000000000000000000000000000000000000001", "data": "0x"}]}}"#),
+        ));
+
+        // Second call hits the cache
+        assert!(cache.has_wrappers(&h(5), None));
+    }
+
     #[test]
     fn misc() {
         let mut validator = Validator::default();
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index e741776a36..feddf27dbc 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -40,7 +40,6 @@ humantime = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 mimalloc = { workspace = true, optional = true }
-tikv-jemallocator = { workspace = true }
 model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
@@ -57,6 +56,7 @@ serde_with = { workspace = true }
 shared = { workspace = true }
 sqlx = { workspace = true }
 strum = { workspace = true }
+tikv-jemallocator = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
 tokio-stream = { workspace = true }
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index e22d464a2b..3057f514a0 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -258,17 +258,6 @@ pub struct Arguments {
     #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
     pub disable_order_balance_filter: bool,
 
-    // Configures whether the autopilot filters out EIP-1271 orders even if their signatures are
-    // invalid. This is useful as a workaround to let flashloan orders go through as they rely
-    // on preHooks behing executed to make the signatures valid.
-    #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub disable_1271_order_sig_filter: bool,
-
-    /// Configures whether the autopilot skips balance checks for EIP-1271
-    /// orders.
-    #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub disable_1271_order_balance_filter: bool,
-
     /// Enables the usage of leader lock in the database
     /// The second instance of autopilot will act as a follower
     /// and not cut any auctions.
@@ -349,8 +338,6 @@ impl std::fmt::Display for Arguments {
             archive_node_url,
             max_solutions_per_solver,
             disable_order_balance_filter,
-            disable_1271_order_balance_filter,
-            disable_1271_order_sig_filter,
             enable_leader_lock,
             max_maintenance_timeout,
             native_price_cache_refresh,
@@ -431,14 +418,6 @@ impl std::fmt::Display for Arguments {
             f,
             "disable_order_balance_filter: {disable_order_balance_filter}"
         )?;
-        writeln!(
-            f,
-            "disable_1271_order_balance_filter: {disable_1271_order_balance_filter}"
-        )?;
-        writeln!(
-            f,
-            "disable_1271_order_sig_filter: {disable_1271_order_sig_filter}"
-        )?;
         writeln!(f, "enable_leader_lock: {enable_leader_lock}")?;
         writeln!(f, "max_maintenance_timeout: {max_maintenance_timeout:?}")?;
         writeln!(
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index b80ef71acf..0235ad4036 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -51,7 +51,6 @@ use {
             factory::{self, PriceEstimatorFactory},
             native::NativePriceEstimating,
         },
-        signature_validator,
         sources::{BaselineSource, uniswap_v2::UniV2BaselineSourceParameters},
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
         token_list::{AutoUpdatingTokenList, TokenListConfiguration},
@@ -253,15 +252,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     let chain = Chain::try_from(chain_id).expect("incorrect chain ID");
 
     let balance_overrider = args.price_estimation.balance_overrides.init(web3.clone());
-    let signature_validator = signature_validator::validator(
-        &web3,
-        signature_validator::Contracts {
-            settlement: eth.contracts().settlement().clone(),
-            signatures: eth.contracts().signatures().clone(),
-            vault_relayer,
-        },
-        balance_overrider.clone(),
-    );
 
     let balance_fetcher = account_balances::cached(
         &web3,
@@ -533,7 +523,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         balance_fetcher.clone(),
         bad_token_detector.clone(),
         competition_native_price_updater.clone(),
-        signature_validator.clone(),
         *eth.contracts().weth().address(),
         args.limit_order_price_factor
             .try_into()
@@ -547,8 +536,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         args.run_loop_native_price_timeout,
         *eth.contracts().settlement().address(),
         args.disable_order_balance_filter,
-        args.disable_1271_order_sig_filter,
-        args.disable_1271_order_balance_filter,
     );
 
     let liveness = Arc::new(Liveness::new(args.max_auction_age));
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index be5bc52745..bb2bd94d55 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -8,7 +8,7 @@ use {
     anyhow::{Context, Result},
     bigdecimal::BigDecimal,
     database::order_events::OrderEventLabel,
-    futures::{FutureExt, StreamExt, future::join_all, stream::FuturesUnordered},
+    futures::{FutureExt, future::join_all},
     itertools::Itertools,
     model::{
         order::{Order, OrderClass, OrderUid},
@@ -25,7 +25,6 @@ use {
             native_price_cache::NativePriceUpdater,
         },
         remaining_amounts,
-        signature_validator::{SignatureCheck, SignatureValidating},
     },
     std::{
         collections::{BTreeMap, HashMap, HashSet, btree_map::Entry},
@@ -91,7 +90,6 @@ pub struct SolvableOrdersCache {
     bad_token_detector: Arc<dyn BadTokenDetecting>,
     cache: Mutex<Option<Inner>>,
     native_price_estimator: Arc<NativePriceUpdater>,
-    signature_validator: Arc<dyn SignatureValidating>,
     metrics: &'static Metrics,
     weth: Address,
     limit_order_price_factor: BigDecimal,
@@ -100,8 +98,7 @@ pub struct SolvableOrdersCache {
     native_price_timeout: Duration,
     settlement_contract: Address,
     disable_order_balance_filter: bool,
-    disable_1271_order_sig_filter: bool,
-    disable_1271_order_balance_filter: bool,
+    wrapper_cache: app_data::WrapperCache,
 }
 
 type Balances = HashMap<Query, U256>;
@@ -120,7 +117,6 @@ impl SolvableOrdersCache {
         balance_fetcher: Arc<dyn BalanceFetching>,
         bad_token_detector: Arc<dyn BadTokenDetecting>,
         native_price_estimator: Arc<NativePriceUpdater>,
-        signature_validator: Arc<dyn SignatureValidating>,
         weth: Address,
         limit_order_price_factor: BigDecimal,
         protocol_fees: domain::ProtocolFees,
@@ -128,9 +124,8 @@ impl SolvableOrdersCache {
         native_price_timeout: Duration,
         settlement_contract: Address,
         disable_order_balance_filter: bool,
-        disable_1271_order_sig_filter: bool,
-        disable_1271_order_balance_filter: bool,
     ) -> Arc<Self> {
+        let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
         Arc::new(Self {
             min_order_validity_period,
             persistence,
@@ -139,8 +134,7 @@ impl SolvableOrdersCache {
             bad_token_detector,
             cache: Mutex::new(None),
             native_price_estimator,
-            signature_validator,
-            metrics: Metrics::instance(observe::metrics::get_storage_registry()).unwrap(),
+            metrics,
             weth,
             limit_order_price_factor,
             protocol_fees,
@@ -148,8 +142,7 @@ impl SolvableOrdersCache {
             native_price_timeout,
             settlement_contract,
             disable_order_balance_filter,
-            disable_1271_order_sig_filter,
-            disable_1271_order_balance_filter,
+            wrapper_cache: app_data::WrapperCache::new(20_000),
         })
     }
 
@@ -186,6 +179,17 @@ impl SolvableOrdersCache {
         let mut invalid_order_uids = HashSet::new();
         let mut filtered_order_events = Vec::new();
 
+        let balance_filter_exempt_orders: HashSet<_> = orders
+            .iter()
+            .filter(|order| {
+                self.wrapper_cache.has_wrappers(
+                    &order.data.app_data,
+                    order.metadata.full_app_data.as_deref(),
+                )
+            })
+            .map(|order| order.metadata.uid)
+            .collect();
+
         let (balances, orders, cow_amms) = {
             let queries = orders.iter().map(Query::from_order).collect::<Vec<_>>();
             tokio::join!(
@@ -202,7 +206,7 @@ impl SolvableOrdersCache {
                 orders,
                 &balances,
                 self.settlement_contract,
-                self.disable_1271_order_balance_filter,
+                &balance_filter_exempt_orders,
             );
             let removed = counter.checkpoint("insufficient_balance", &orders);
             invalid_order_uids.extend(removed);
@@ -398,18 +402,13 @@ impl SolvableOrdersCache {
         counter: &mut OrderFilterCounter,
         invalid_order_uids: &mut HashSet<OrderUid>,
     ) -> Vec<Order> {
-        let filter_invalid_signatures = find_invalid_signature_orders(
-            &orders,
-            self.signature_validator.as_ref(),
-            self.disable_1271_order_sig_filter,
-        );
+        let presignature_pending_orders = find_presignature_pending_orders(&orders);
 
-        let (banned_user_orders, invalid_signature_orders, unsupported_token_orders) = tokio::join!(
+        let (banned_user_orders, unsupported_token_orders) = tokio::join!(
             self.timed_future(
                 "banned_user_filtering",
                 find_banned_user_orders(&orders, &self.banned_users)
             ),
-            self.timed_future("invalid_signature_filtering", filter_invalid_signatures),
             self.timed_future(
                 "unsupported_token_filtering",
                 find_unsupported_tokens(&orders, self.bad_token_detector.clone())
@@ -418,10 +417,10 @@ impl SolvableOrdersCache {
         tracing::trace!("filtered invalid orders");
 
         counter.checkpoint_by_invalid_orders("banned_user", &banned_user_orders);
-        counter.checkpoint_by_invalid_orders("invalid_signature", &invalid_signature_orders);
+        counter.checkpoint_by_invalid_orders("invalid_signature", &presignature_pending_orders);
         counter.checkpoint_by_invalid_orders("unsupported_token", &unsupported_token_orders);
         invalid_order_uids.extend(banned_user_orders);
-        invalid_order_uids.extend(invalid_signature_orders);
+        invalid_order_uids.extend(presignature_pending_orders);
         invalid_order_uids.extend(unsupported_token_orders);
 
         orders.retain(|order| !invalid_order_uids.contains(&order.metadata.uid));
@@ -483,59 +482,19 @@ async fn get_native_prices(
         .collect()
 }
 
-/// Finds unsigned PreSign and EIP-1271 orders whose signatures are no longer
-/// validating.
-async fn find_invalid_signature_orders(
-    orders: &[Order],
-    signature_validator: &dyn SignatureValidating,
-    disable_1271_order_sig_filter: bool,
-) -> Vec<OrderUid> {
-    let mut invalid_orders = vec![];
-    let mut signature_check_futures = FuturesUnordered::new();
-
-    for order in orders {
-        if let Signature::Eip1271(_) = &order.signature
-            && disable_1271_order_sig_filter
-        {
-            continue;
-        }
-        if matches!(
-            order.metadata.status,
-            model::order::OrderStatus::PresignaturePending
-        ) {
-            invalid_orders.push(order.metadata.uid);
-            continue;
-        }
-
-        if let Signature::Eip1271(signature) = &order.signature {
-            signature_check_futures.push(async {
-                let (hash, signer, _) = order.metadata.uid.parts();
-                match signature_validator
-                    .validate_signature(SignatureCheck {
-                        signer,
-                        hash: hash.0,
-                        signature: signature.clone(),
-                        interactions: order.interactions.pre.clone(),
-                        // TODO delete balance and signature logic in the autopilot
-                        // altogether
-                        balance_override: None,
-                    })
-                    .await
-                {
-                    Ok(_) => None,
-                    Err(_) => Some(order.metadata.uid),
-                }
-            });
-        }
-    }
-
-    while let Some(res) = signature_check_futures.next().await {
-        if let Some(invalid_order_uid) = res {
-            invalid_orders.push(invalid_order_uid);
-        }
-    }
-
-    invalid_orders
+/// Finds orders with pending presignatures. EIP-1271 signature validation is
+/// skipped entirely - the driver validates signatures before settlement.
+fn find_presignature_pending_orders(orders: &[Order]) -> Vec<OrderUid> {
+    orders
+        .iter()
+        .filter(|order| {
+            matches!(
+                order.metadata.status,
+                model::order::OrderStatus::PresignaturePending
+            )
+        })
+        .map(|order| order.metadata.uid)
+        .collect()
 }
 
 /// Removes orders that can't possibly be settled because there isn't enough
@@ -544,12 +503,17 @@ fn orders_with_balance(
     mut orders: Vec<Order>,
     balances: &Balances,
     settlement_contract: Address,
-    disable_1271_order_balance_filter: bool,
+    filter_bypass_orders: &HashSet<OrderUid>,
 ) -> Vec<Order> {
     // Prefer newer orders over older ones.
     orders.sort_by_key(|order| std::cmp::Reverse(order.metadata.creation_date));
     orders.retain(|order| {
-        if disable_1271_order_balance_filter && matches!(order.signature, Signature::Eip1271(_)) {
+        // Skip balance check for all EIP-1271 orders (they can rely on pre-interactions
+        // to unlock funds) or orders with wrappers (wrappers produce the required
+        // balance at settlement time).
+        if matches!(order.signature, Signature::Eip1271(_))
+            || filter_bypass_orders.contains(&order.metadata.uid)
+        {
             return true;
         }
 
@@ -852,11 +816,7 @@ mod tests {
         alloy::primitives::{Address, B256},
         futures::FutureExt,
         maplit::{btreemap, hashset},
-        mockall::predicate::eq,
-        model::{
-            interaction::InteractionData,
-            order::{Interactions, OrderBuilder, OrderData, OrderMetadata, OrderUid},
-        },
+        model::order::{OrderBuilder, OrderData, OrderMetadata, OrderUid},
         shared::{
             bad_token::list_based::ListBasedDetector,
             price_estimation::{
@@ -870,7 +830,6 @@ mod tests {
                     NativePriceUpdater,
                 },
             },
-            signature_validator::{MockSignatureValidating, SignatureValidationError},
         },
     };
 
@@ -1176,48 +1135,29 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn filters_invalidated_eip1271_signatures() {
+    #[test]
+    fn finds_presignature_pending_orders() {
+        let presign_uid = OrderUid::from_parts(B256::repeat_byte(1), Address::repeat_byte(11), 1);
         let orders = vec![
+            // PresignaturePending order - should be found
             Order {
                 metadata: OrderMetadata {
-                    uid: OrderUid::from_parts(B256::repeat_byte(1), Address::repeat_byte(11), 1),
+                    uid: presign_uid,
+                    status: model::order::OrderStatus::PresignaturePending,
                     ..Default::default()
                 },
-                interactions: Interactions {
-                    pre: vec![InteractionData {
-                        target: Address::from_slice(&[0xe1; 20]),
-                        value: alloy::primitives::U256::ZERO,
-                        call_data: vec![1, 2],
-                    }],
-                    post: vec![InteractionData {
-                        target: Address::from_slice(&[0xe2; 20]),
-                        value: alloy::primitives::U256::ZERO,
-                        call_data: vec![3, 4],
-                    }],
-                },
                 ..Default::default()
             },
+            // EIP-1271 order - not PresignaturePending
             Order {
                 metadata: OrderMetadata {
                     uid: OrderUid::from_parts(B256::repeat_byte(2), Address::repeat_byte(22), 2),
                     ..Default::default()
                 },
                 signature: Signature::Eip1271(vec![2, 2]),
-                interactions: Interactions {
-                    pre: vec![InteractionData {
-                        target: Address::from_slice(&[0xe3; 20]),
-                        value: alloy::primitives::U256::ZERO,
-                        call_data: vec![5, 6],
-                    }],
-                    post: vec![InteractionData {
-                        target: Address::from_slice(&[0xe4; 20]),
-                        value: alloy::primitives::U256::ZERO,
-                        call_data: vec![7, 9],
-                    }],
-                },
                 ..Default::default()
             },
+            // Regular order - not PresignaturePending
             Order {
                 metadata: OrderMetadata {
                     uid: OrderUid::from_parts(B256::repeat_byte(3), Address::repeat_byte(33), 3),
@@ -1225,75 +1165,10 @@ mod tests {
                 },
                 ..Default::default()
             },
-            Order {
-                metadata: OrderMetadata {
-                    uid: OrderUid::from_parts(B256::repeat_byte(4), Address::repeat_byte(44), 4),
-                    ..Default::default()
-                },
-                signature: Signature::Eip1271(vec![4, 4, 4, 4]),
-                ..Default::default()
-            },
-            Order {
-                metadata: OrderMetadata {
-                    uid: OrderUid::from_parts(B256::repeat_byte(5), Address::repeat_byte(55), 5),
-                    ..Default::default()
-                },
-                signature: Signature::Eip1271(vec![5, 5, 5, 5, 5]),
-                ..Default::default()
-            },
         ];
 
-        let mut signature_validator = MockSignatureValidating::new();
-        signature_validator
-            .expect_validate_signature()
-            .with(eq(SignatureCheck {
-                signer: Address::repeat_byte(22),
-                hash: [2; 32],
-                signature: vec![2, 2],
-                interactions: vec![InteractionData {
-                    target: Address::from_slice(&[0xe3; 20]),
-                    value: alloy::primitives::U256::ZERO,
-                    call_data: vec![5, 6],
-                }],
-                balance_override: None,
-            }))
-            .returning(|_| Ok(()));
-        signature_validator
-            .expect_validate_signature()
-            .with(eq(SignatureCheck {
-                signer: Address::repeat_byte(44),
-                hash: [4; 32],
-                signature: vec![4, 4, 4, 4],
-                interactions: vec![],
-                balance_override: None,
-            }))
-            .returning(|_| Err(SignatureValidationError::Invalid));
-        signature_validator
-            .expect_validate_signature()
-            .with(eq(SignatureCheck {
-                signer: Address::repeat_byte(55),
-                hash: [5; 32],
-                signature: vec![5, 5, 5, 5, 5],
-                interactions: vec![],
-                balance_override: None,
-            }))
-            .returning(|_| Ok(()));
-
-        let invalid_signature_orders =
-            find_invalid_signature_orders(&orders, &signature_validator, false).await;
-        assert_eq!(
-            invalid_signature_orders,
-            vec![OrderUid::from_parts(
-                B256::repeat_byte(4),
-                Address::repeat_byte(44),
-                4
-            )]
-        );
-        let invalid_signature_orders_with_1271_filter_disabled =
-            find_invalid_signature_orders(&orders, &signature_validator, true).await;
-        // if we switch off the 1271 filter no orders should be returned as containing
-        // invalid signatures
-        assert_eq!(invalid_signature_orders_with_1271_filter_disabled, vec![]);
+        let pending_orders = find_presignature_pending_orders(&orders);
+        assert_eq!(pending_orders, vec![presign_uid]);
     }
 
     #[test]
@@ -1456,7 +1331,9 @@ mod tests {
         .collect();
         let expected = &[0, 2, 4];
 
-        let filtered = orders_with_balance(orders.clone(), &balances, settlement_contract, false);
+        let no_bypass: HashSet<OrderUid> = HashSet::new();
+        let filtered =
+            orders_with_balance(orders.clone(), &balances, settlement_contract, &no_bypass);
         assert_eq!(filtered.len(), expected.len());
         for index in expected {
             let found = filtered.iter().any(|o| o.data == orders[*index].data);
@@ -1465,8 +1342,10 @@ mod tests {
     }
 
     #[test]
-    fn eip1271_orders_can_skip_balance_filtering() {
+    fn eip1271_and_wrapper_orders_skip_balance_filtering() {
         let settlement_contract = Address::repeat_byte(1);
+
+        // EIP-1271 order (should skip balance check)
         let eip1271_order = Order {
             data: OrderData {
                 sell_token: Address::with_last_byte(7),
@@ -1476,9 +1355,17 @@ mod tests {
                 ..Default::default()
             },
             signature: Signature::Eip1271(vec![1, 2, 3]),
+            metadata: OrderMetadata {
+                uid: OrderUid::from_parts(B256::repeat_byte(6), Address::repeat_byte(66), 6),
+                ..Default::default()
+            },
             ..Default::default()
         };
-        let regular_order = Order {
+
+        // Order with wrappers in bypass set (should skip balance check)
+        let wrapper_order_uid =
+            OrderUid::from_parts(B256::repeat_byte(7), Address::repeat_byte(77), 7);
+        let wrapper_order = Order {
             data: OrderData {
                 sell_token: Address::with_last_byte(8),
                 sell_amount: alloy::primitives::U256::from(10),
@@ -1486,19 +1373,60 @@ mod tests {
                 partially_fillable: false,
                 ..Default::default()
             },
+            metadata: OrderMetadata {
+                uid: wrapper_order_uid,
+                ..Default::default()
+            },
             ..Default::default()
         };
 
-        let orders = vec![regular_order.clone(), eip1271_order.clone()];
-        let balances: Balances = Default::default();
+        // Regular ECDSA order without wrappers (should be filtered)
+        let regular_order = Order {
+            data: OrderData {
+                sell_token: Address::with_last_byte(9),
+                sell_amount: alloy::primitives::U256::from(10),
+                fee_amount: alloy::primitives::U256::from(5),
+                partially_fillable: false,
+                ..Default::default()
+            },
+            metadata: OrderMetadata {
+                uid: OrderUid::from_parts(B256::repeat_byte(8), Address::repeat_byte(88), 8),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
 
-        let filtered = orders_with_balance(orders.clone(), &balances, settlement_contract, true);
-        // 1271 filter is disabled, only the regular order is filtered out
-        assert_eq!(filtered.len(), 1);
-        assert!(matches!(filtered[0].signature, Signature::Eip1271(_)));
+        let orders = vec![
+            regular_order.clone(),
+            eip1271_order.clone(),
+            wrapper_order.clone(),
+        ];
+        let balances: Balances = Default::default(); // No balances
+
+        // EIP-1271 order and wrapper order should be retained, regular order filtered
+        let wrapper_set = HashSet::from([wrapper_order_uid]);
+        let filtered =
+            orders_with_balance(orders.clone(), &balances, settlement_contract, &wrapper_set);
+        assert_eq!(filtered.len(), 2);
+        assert!(
+            filtered
+                .iter()
+                .any(|o| o.metadata.uid == eip1271_order.metadata.uid)
+        );
+        assert!(
+            filtered
+                .iter()
+                .any(|o| o.metadata.uid == wrapper_order.metadata.uid)
+        );
 
-        let filtered_without_override =
-            orders_with_balance(orders, &balances, settlement_contract, false);
-        assert!(filtered_without_override.is_empty());
+        // Without wrapper set, only EIP-1271 order should be retained
+        let empty_set: HashSet<OrderUid> = HashSet::new();
+        let filtered_no_wrappers =
+            orders_with_balance(orders, &balances, settlement_contract, &empty_set);
+        assert_eq!(filtered_no_wrappers.len(), 1);
+        assert_eq!(
+            filtered_no_wrappers[0].metadata.uid,
+            eip1271_order.metadata.uid
+        );
     }
 }
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 6355119ccb..5c51e38bb1 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -463,6 +463,11 @@ impl Competition {
                 }
             }
 
+            // wrappers can produce the required funds at settlement time
+            if !order.app_data.wrappers().is_empty() {
+                return true;
+            }
+
             let remaining_balance = match balances.get_mut(&(
                 order.trader(),
                 order.sell.token,
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 1167dd8430..f7909ae54c 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -412,6 +412,7 @@ impl OrderValidator {
         app_data: &OrderAppData,
     ) -> Result<(), ValidationError> {
         let mut res = Ok(());
+        let has_wrappers = !app_data.inner.protocol.wrappers.is_empty();
 
         // Simulate transferring a small token balance into the settlement contract.
         // As a spam protection we require that an account must have at least 1 atom
@@ -447,13 +448,16 @@ impl OrderValidator {
                     TransferSimulationError::InsufficientAllowance
                     | TransferSimulationError::InsufficientBalance
                     | TransferSimulationError::TransferFailed,
-                ) if order.signature == Signature::PreSign => {
+                ) if order.signature == Signature::PreSign || has_wrappers => {
                     // Pre-sign orders do not require sufficient balance or allowance.
                     // The idea is that this allows smart contracts to place orders bundled with
                     // other transactions that either produce the required balance or set the
                     // allowance. This would, for example, allow a Gnosis Safe to bundle the
                     // pre-signature transaction with a WETH wrap and WETH approval to the vault
                     // relayer contract.
+                    //
+                    // Similarly, orders with wrappers may produce the required balance or
+                    // allowance as part of the wrapper execution.
                     return Ok(());
                 }
                 Err(err) => match err {

From 1c28e494e2846f9860d7e2c44e23c04732836748 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 12 Feb 2026 15:07:03 +0000
Subject: [PATCH 052/219] Migrate orderbook API from warp to axum (#4080)

# Description

This PR migrates the orderbook API from Warp to Axum. The migration
modernizes our web framework while maintaining API
compatibility, with improved code organization and reduced complexity
(~200 lines removed).

# Changes

- Replace Warp filters with Axum Router and centralized AppState for
dependency injection
- Migrate all 18 API endpoints (v1 and v2) to Axum handler functions
- Update dependencies: remove warp, add axum, tower, tower-http
- Reorganize routes hierarchically with .nest(), alphabetically by
prefix
- Fix route conflicts using .merge() for multiple HTTP methods on same
path
- Fix bug in get_trades_v2 (use database_read instead of database_write)
- Add comprehensive E2E test suite for HTTP behavior validation in
malformed_requests.rs


# How to test

Existing tests + staging

I deployed these changes to base staging to ensure metrics were working,
here's the graph

<img width="2076" height="508" alt="Screenshot 2026-01-23 at 12-42-46
Edit panel - GPv2 - Dashboards - Amazon Managed Grafana"
src="https://github.com/user-attachments/assets/549c9309-ab40-46bb-b238-83771920d450"
/>

Follow up:
<img width="2076" height="544" alt="image"
src="https://github.com/user-attachments/assets/d088934b-0bc6-4633-8305-232c5cfe0d46"
/>

Unmarked spots are running `main`, the wrong image was labeling
endpoints with unknown because it was a fallback.
That code has been removed and replaced with the current metric labeling
scheme.

That scheme can be improved (read, made less verbose and error prone
while being more general) but we need to change the metrics label, which
I didn't do to minimize changes.

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 Cargo.lock                                    |  77 +--
 Cargo.toml                                    |   1 -
 crates/driver/src/infra/api/routes/healthz.rs |  10 +-
 crates/driver/src/tests/setup/orderbook.rs    |   4 +-
 crates/e2e/src/setup/proxy.rs                 |   9 +-
 crates/e2e/tests/e2e/malformed_requests.rs    |  23 +-
 crates/e2e/tests/e2e/replace_order.rs         |   4 +-
 crates/model/src/order.rs                     |   2 +
 crates/observe/Cargo.toml                     |   1 -
 crates/observe/src/distributed_tracing/mod.rs |   1 -
 .../src/distributed_tracing/tracing_warp.rs   |  23 -
 crates/orderbook/Cargo.toml                   |   4 +-
 crates/orderbook/openapi.yml                  |  16 +-
 crates/orderbook/src/api.rs                   | 536 ++++++++++--------
 crates/orderbook/src/api/cancel_order.rs      | 156 +++--
 crates/orderbook/src/api/cancel_orders.rs     |  59 +-
 crates/orderbook/src/api/get_app_data.rs      |  66 +--
 crates/orderbook/src/api/get_auction.rs       |  49 +-
 crates/orderbook/src/api/get_native_price.rs  |  66 +--
 crates/orderbook/src/api/get_order_by_uid.rs  |  66 +--
 crates/orderbook/src/api/get_order_status.rs  |  55 +-
 crates/orderbook/src/api/get_orders_by_tx.rs  |  61 +-
 .../src/api/get_solver_competition.rs         | 158 +++---
 .../src/api/get_solver_competition_v2.rs      | 109 ++--
 .../orderbook/src/api/get_token_metadata.rs   |  47 +-
 crates/orderbook/src/api/get_total_surplus.rs |  55 +-
 crates/orderbook/src/api/get_trades.rs        | 131 ++---
 crates/orderbook/src/api/get_trades_v2.rs     | 189 +++---
 crates/orderbook/src/api/get_user_orders.rs   | 107 ++--
 crates/orderbook/src/api/post_order.rs        | 332 +++++------
 crates/orderbook/src/api/post_quote.rs        | 139 ++---
 crates/orderbook/src/api/put_app_data.rs      | 112 ++--
 crates/orderbook/src/api/version.rs           |  17 +-
 crates/orderbook/src/app_data.rs              |  19 +-
 crates/orderbook/src/run.rs                   |  52 +-
 crates/orderbook/src/solver_competition.rs    |   2 +-
 crates/solvers/src/api/routes/healthz.rs      |   9 +-
 playground/docker-compose.non-interactive.yml |   2 +-
 38 files changed, 1295 insertions(+), 1474 deletions(-)
 delete mode 100644 crates/observe/src/distributed_tracing/tracing_warp.rs

diff --git a/Cargo.lock b/Cargo.lock
index 540b74e1fe..422f11eeb6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3364,30 +3364,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "headers"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270"
-dependencies = [
- "base64 0.21.7",
- "bytes",
- "headers-core",
- "http 0.2.12",
- "httpdate",
- "mime",
- "sha1",
-]
-
-[[package]]
-name = "headers-core"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
-dependencies = [
- "http 0.2.12",
-]
-
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -4231,16 +4207,6 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
-[[package]]
-name = "mime_guess"
-version = "2.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
-dependencies = [
- "mime",
- "unicase",
-]
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -4583,7 +4549,6 @@ dependencies = [
  "tracing-opentelemetry",
  "tracing-serde",
  "tracing-subscriber",
- "warp",
 ]
 
 [[package]]
@@ -4743,6 +4708,7 @@ dependencies = [
  "anyhow",
  "app-data",
  "async-trait",
+ "axum",
  "bigdecimal",
  "cached",
  "chain",
@@ -4776,10 +4742,11 @@ dependencies = [
  "thiserror 1.0.69",
  "tikv-jemallocator",
  "tokio",
+ "tower 0.4.13",
+ "tower-http 0.4.4",
  "tracing",
  "url",
  "vergen",
- "warp",
 ]
 
 [[package]]
@@ -5871,12 +5838,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "scoped-tls"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
-
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -7408,12 +7369,6 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
-[[package]]
-name = "unicase"
-version = "2.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
-
 [[package]]
 name = "unicode-bidi"
 version = "0.3.18"
@@ -7567,32 +7522,6 @@ dependencies = [
  "try-lock",
 ]
 
-[[package]]
-name = "warp"
-version = "0.3.7"
-source = "git+https://github.com/cowprotocol/warp.git?rev=586244e#586244eabb564b9f9573436ee0e23edfc73f4861"
-dependencies = [
- "bytes",
- "futures-channel",
- "futures-util",
- "headers",
- "http 0.2.12",
- "hyper 0.14.32",
- "log",
- "mime",
- "mime_guess",
- "percent-encoding",
- "pin-project",
- "scoped-tls",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "tokio",
- "tokio-util",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"
diff --git a/Cargo.toml b/Cargo.toml
index 1853a4e068..57ed351635 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -53,7 +53,6 @@ tokio-stream = { version = "0.1.15", features = ["sync"] }
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", features = ["json"] }
 url = "2.5.0"
-warp = { git = 'https://github.com/cowprotocol/warp.git', rev = "586244e", default-features = false }
 app-data = { path = "crates/app-data" }
 arc-swap = "1.7.1"
 async-stream = "0.3.5"
diff --git a/crates/driver/src/infra/api/routes/healthz.rs b/crates/driver/src/infra/api/routes/healthz.rs
index 157f557a93..62fc74b469 100644
--- a/crates/driver/src/infra/api/routes/healthz.rs
+++ b/crates/driver/src/infra/api/routes/healthz.rs
@@ -1,9 +1,13 @@
-use axum::{http::StatusCode, response::IntoResponse, routing::get};
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    routing::get,
+};
 
 pub(in crate::infra::api) fn healthz(app: axum::Router<()>) -> axum::Router<()> {
     app.route("/healthz", get(route))
 }
 
-async fn route() -> impl IntoResponse {
-    StatusCode::OK
+async fn route() -> Response {
+    StatusCode::OK.into_response()
 }
diff --git a/crates/driver/src/tests/setup/orderbook.rs b/crates/driver/src/tests/setup/orderbook.rs
index 440b6ec9cf..8b3da45a3a 100644
--- a/crates/driver/src/tests/setup/orderbook.rs
+++ b/crates/driver/src/tests/setup/orderbook.rs
@@ -7,7 +7,7 @@ use {
         Router,
         extract::Path,
         http::StatusCode,
-        response::IntoResponse,
+        response::{IntoResponse, Response},
         routing::get,
     },
     std::{collections::HashMap, net::SocketAddr},
@@ -59,7 +59,7 @@ impl Orderbook {
     async fn app_data_handler(
         Path(app_data): Path<String>,
         Extension(app_data_storage): Extension<HashMap<app_data::AppDataHash, app_data::Root>>,
-    ) -> impl IntoResponse {
+    ) -> Response {
         tracing::debug!("Orderbook received an app_data request: {}", app_data);
 
         let app_data_hash = match app_data.parse::<app_data::AppDataHash>() {
diff --git a/crates/e2e/src/setup/proxy.rs b/crates/e2e/src/setup/proxy.rs
index 9173213c26..85474f8ae3 100644
--- a/crates/e2e/src/setup/proxy.rs
+++ b/crates/e2e/src/setup/proxy.rs
@@ -12,7 +12,12 @@
 //! cluster.
 
 use {
-    axum::{Router, body::Body, http::Request, response::IntoResponse},
+    axum::{
+        Router,
+        body::Body,
+        http::Request,
+        response::{IntoResponse, Response},
+    },
     hyper::body::to_bytes,
     std::{collections::VecDeque, net::SocketAddr, sync::Arc},
     tokio::{sync::RwLock, task::JoinHandle},
@@ -109,7 +114,7 @@ async fn handle_request(
     client: reqwest::Client,
     state: ProxyState,
     req: Request<Body>,
-) -> impl IntoResponse {
+) -> Response {
     let (parts, body) = req.into_parts();
 
     // Convert body to bytes once for reuse across retries
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 8dc9c09fab..fb9aff9df4 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -119,13 +119,18 @@ async fn http_validation(web3: Web3) {
     }
 
     // Test malformed auction IDs
-    let invalid_auction_ids: Vec<(&str, &str)> = vec![
-        ("not-a-number", "non-numeric"),
-        ("-1", "negative number"),
-        ("99999999999999999999999", "u64 overflow"),
-    ];
-
-    for (id, description) in invalid_auction_ids {
+    // Note: "-1" returns 404 because it doesn't match the u64 route pattern at all,
+    // while non-numeric strings return 400 as they match the path but fail
+    // deserialization
+    for (id, description, expected_status) in [
+        ("not-a-number", "non-numeric", StatusCode::NOT_FOUND),
+        ("-1", "negative number", StatusCode::NOT_FOUND),
+        (
+            "99999999999999999999999",
+            "u64 overflow",
+            StatusCode::NOT_FOUND,
+        ),
+    ] {
         let response = client
             .get(format!("{API_HOST}/api/v1/solver_competition/{id}"))
             .send()
@@ -134,8 +139,8 @@ async fn http_validation(web3: Web3) {
 
         assert_eq!(
             response.status(),
-            StatusCode::NOT_FOUND,
-            "Expected 404 for invalid AuctionId ({description}): {id}"
+            expected_status,
+            "Expected {expected_status} for invalid AuctionId ({description}): {id}"
         );
     }
 
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index ef76ccdcc6..c1c8d65cff 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -23,7 +23,7 @@ fn parse_order_replacement_error(status: StatusCode, body: &str) -> Option<Order
     let error: ApiError = serde_json::from_str(body).ok()?;
 
     match status {
-        StatusCode::BAD_REQUEST => match error.error_type {
+        StatusCode::BAD_REQUEST => match error.error_type.as_ref() {
             "InvalidSignature" => Some(OrderReplacementError::InvalidSignature),
             "OldOrderActivelyBidOn" => Some(OrderReplacementError::OldOrderActivelyBidOn),
             _ => None,
@@ -46,7 +46,7 @@ fn parse_order_cancellation_error(
     let error: ApiError = serde_json::from_str(body).ok()?;
 
     match status {
-        StatusCode::BAD_REQUEST => match error.error_type {
+        StatusCode::BAD_REQUEST => match error.error_type.as_ref() {
             "InvalidSignature" => Some(OrderCancellationError::InvalidSignature),
             "AlreadyCancelled" => Some(OrderCancellationError::AlreadyCancelled),
             "OrderFullyExecuted" => Some(OrderCancellationError::OrderFullyExecuted),
diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index e27279e540..cd4085a9fd 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -731,6 +731,8 @@ pub struct OrderMetadata {
     pub quote: Option<OrderQuote>,
 }
 
+pub const ORDER_UID_LIMIT: usize = 1024;
+
 // uid as 56 bytes: 32 for orderDigest, 20 for ownerAddress and 4 for validTo
 #[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct OrderUid(pub [u8; 56]);
diff --git a/crates/observe/Cargo.toml b/crates/observe/Cargo.toml
index 91578c049f..ee99edca35 100644
--- a/crates/observe/Cargo.toml
+++ b/crates/observe/Cargo.toml
@@ -26,7 +26,6 @@ tracing = { workspace = true }
 tracing-opentelemetry = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 tracing-serde = { workspace = true }
-warp = { workspace = true }
 jemalloc_pprof = { workspace = true }
 
 [lints]
diff --git a/crates/observe/src/distributed_tracing/mod.rs b/crates/observe/src/distributed_tracing/mod.rs
index 03d8ca7d3c..6bb9302c14 100644
--- a/crates/observe/src/distributed_tracing/mod.rs
+++ b/crates/observe/src/distributed_tracing/mod.rs
@@ -1,4 +1,3 @@
 pub mod request_id;
 pub mod trace_id_format;
 pub mod tracing_axum;
-pub mod tracing_warp;
diff --git a/crates/observe/src/distributed_tracing/tracing_warp.rs b/crates/observe/src/distributed_tracing/tracing_warp.rs
deleted file mode 100644
index 7688397081..0000000000
--- a/crates/observe/src/distributed_tracing/tracing_warp.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use {
-    crate::{distributed_tracing::request_id::request_id, tracing::HeaderExtractor},
-    opentelemetry::global,
-    tracing::info,
-    tracing_opentelemetry::OpenTelemetrySpanExt,
-    warp::http::HeaderMap,
-};
-
-pub fn make_span(info: warp::trace::Info) -> tracing::Span {
-    let headers: &HeaderMap = info.request_headers();
-
-    // Extract OTEL context from headers
-    let parent_cx = global::get_text_map_propagator(|prop| prop.extract(&HeaderExtractor(headers)));
-
-    let span = tracing::info_span!("http_request", request_id = %request_id(headers));
-    span.set_parent(parent_cx); // sets parent context for distributed trace
-    {
-        let _span = span.enter();
-        info!(method = %info.method(), path = %info.path(), "HTTP request");
-    }
-
-    span
-}
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 1f26181049..936b89986d 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -20,6 +20,7 @@ alloy = { workspace = true }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 async-trait = { workspace = true }
+axum = { workspace = true }
 bigdecimal = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
@@ -52,9 +53,10 @@ strum = { workspace = true }
 sqlx = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
+tower = { workspace = true }
+tower-http = { workspace = true, features = ["cors", "trace"] }
 tracing = { workspace = true }
 url = { workspace = true }
-warp = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 79a07a488a..9434a62d98 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -81,6 +81,8 @@ paths:
           description: "Forbidden, your account is deny-listed."
         "404":
           description: No route was found quoting the order.
+        "422":
+          description: Unable to parse request body as valid JSON.
         "429":
           description: Too many order placements.
         "500":
@@ -121,6 +123,8 @@ paths:
           description: Invalid signature.
         "404":
           description: One or more orders were not found and no orders were cancelled.
+        "422":
+          description: Unable to parse request body as valid JSON.
   "/api/v1/orders/{UID}":
     get:
       operationId: getOrder
@@ -177,6 +181,8 @@ paths:
           description: Invalid signature.
         "404":
           description: Order was not found.
+        "422":
+          description: Unable to parse request body as valid JSON.
   "/api/v1/orders/{UID}/status":
     get:
       operationId: getOrderStatus
@@ -437,6 +443,8 @@ paths:
                 $ref: "#/components/schemas/PriceEstimationError"
         "404":
           description: No route was found for the specified order.
+        "422":
+          description: Unable to parse request body as valid JSON.
         "429":
           description: Too many order quotes.
         "500":
@@ -626,6 +634,8 @@ paths:
                 $ref: "#/components/schemas/AppDataHash"
         "400":
           description: Error validating full `appData`
+        "422":
+          description: Unable to parse request body as valid JSON.
         "500":
           description: Error storing the full `appData`
   /api/v1/app_data:
@@ -657,6 +667,8 @@ paths:
                 $ref: "#/components/schemas/AppDataHash"
         "400":
           description: Error validating full `appData`
+        "422":
+          description: Unable to parse request body as valid JSON.
         "500":
           description: Error storing the full `appData`
   "/api/v1/users/{address}/total_surplus":
@@ -1643,7 +1655,9 @@ components:
             - UnsupportedToken
             - InvalidAppData
             - AppDataHashMismatch
+            - AppDataMismatch
             - AppdataFromMismatch
+            - MetadataSerializationFailed
             - OldOrderActivelyBidOn
         description:
           type: string
@@ -1676,7 +1690,7 @@ components:
           enum:
             - QuoteNotVerified
             - UnsupportedToken
-            - ZeroAmount
+            - NoLiquidity
             - UnsupportedOrderType
         description:
           type: string
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 0fa277a975..7123b5a0e0 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -1,23 +1,30 @@
 use {
-    crate::{app_data, database::Postgres, orderbook::Orderbook, quoter::QuoteHandler},
-    anyhow::Result,
-    observe::distributed_tracing::tracing_warp::make_span,
-    serde::{Deserialize, Serialize, de::DeserializeOwned},
+    crate::{
+        app_data,
+        database::Postgres,
+        orderbook::Orderbook,
+        quoter::QuoteHandler,
+        solver_competition::LoadSolverCompetitionError,
+    },
+    axum::{
+        Router,
+        extract::DefaultBodyLimit,
+        http::{Request, StatusCode},
+        middleware::{self, Next},
+        response::{IntoResponse, Json, Response},
+    },
+    hyper::header::USER_AGENT,
+    observe::distributed_tracing::tracing_axum::{self, record_trace_id},
+    serde::{Deserialize, Serialize},
     shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     std::{
-        convert::Infallible,
+        borrow::Cow,
         fmt::Debug,
         sync::Arc,
         time::{Duration, Instant},
     },
-    warp::{
-        Filter,
-        Rejection,
-        Reply,
-        filters::BoxedFilter,
-        hyper::StatusCode,
-        reply::{Json, WithStatus, json, with_status},
-    },
+    tower::ServiceBuilder,
+    tower_http::{cors::CorsLayer, trace::TraceLayer},
 };
 
 mod cancel_order;
@@ -40,126 +47,250 @@ mod post_quote;
 mod put_app_data;
 mod version;
 
+const ALLOWED_METHODS: &[axum::http::Method] = &[
+    axum::http::Method::GET,
+    axum::http::Method::POST,
+    axum::http::Method::DELETE,
+    axum::http::Method::OPTIONS,
+    axum::http::Method::PUT,
+    axum::http::Method::PATCH,
+    axum::http::Method::HEAD,
+];
+
+/// Centralized application state shared across all API handlers
+pub struct AppState {
+    pub database_write: Postgres,
+    pub database_read: Postgres,
+    pub orderbook: Arc<Orderbook>,
+    pub quotes: QuoteHandler,
+    pub app_data: Arc<app_data::Registry>,
+    pub native_price_estimator: Arc<dyn NativePriceEstimating>,
+    pub quote_timeout: Duration,
+}
+
+async fn summarize_request(
+    req: Request<axum::body::Body>,
+    next: Next<axum::body::Body>,
+) -> Response {
+    let method = req.method().to_string();
+    let uri = req.uri().to_string();
+
+    let user_agent = req
+        .headers()
+        .get(USER_AGENT)
+        .map(|user_agent| user_agent.to_str().unwrap_or("invalid (non-ASCII)"))
+        .unwrap_or("unset")
+        .to_string();
+
+    let timer = Instant::now();
+    let response = next.run(req).await;
+    let status = response.status().as_u16();
+
+    tracing::info!(
+        method,
+        uri,
+        user_agent,
+        status,
+        elapsed = ?timer.elapsed(),
+        "request_summary",
+    );
+
+    response
+}
+
+/// Middleware that automatically tracks metrics using Axum's MatchedPath
+async fn with_matched_path_metric(
+    req: Request<axum::body::Body>,
+    next: Next<axum::body::Body>,
+) -> Response {
+    let metrics = ApiMetrics::instance(observe::metrics::get_storage_registry()).unwrap();
+
+    // Extract matched path and HTTP method
+    let matched_path = req
+        .extensions()
+        .get::<axum::extract::MatchedPath>()
+        .map(|path| path.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+
+    let response = {
+        let _timer = metrics
+            .requests_duration_seconds
+            .with_label_values(&[&matched_path])
+            .start_timer();
+        next.run(req).await
+    };
+    let status = response.status();
+
+    // Track completed requests
+    metrics
+        .requests_complete
+        .with_label_values(&[&matched_path, status.as_str()])
+        .inc();
+
+    // Track rejected requests (4xx and 5xx status codes)
+    if status.is_client_error() || status.is_server_error() {
+        metrics
+            .requests_rejected
+            .with_label_values(&[status.as_str()])
+            .inc();
+    }
+
+    response
+}
+
+const MAX_JSON_BODY_PAYLOAD: u64 = 1024 * 16;
+
 pub fn handle_all_routes(
     database_write: Postgres,
     database_read: Postgres,
     orderbook: Arc<Orderbook>,
-    quotes: Arc<QuoteHandler>,
+    quotes: QuoteHandler,
     app_data: Arc<app_data::Registry>,
     native_price_estimator: Arc<dyn NativePriceEstimating>,
     quote_timeout: Duration,
-) -> impl Filter<Extract = (impl Reply,), Error = Rejection> + Clone {
-    // Note that we add a string with endpoint's name to all responses.
-    // This string will be used later to report metrics.
-    // It is not used to form the actual server response.
-
-    let routes = vec![
+) -> Router {
+    let app_data_size_limit = app_data.size_limit();
+
+    let state = Arc::new(AppState {
+        database_write,
+        database_read,
+        orderbook,
+        quotes,
+        app_data,
+        native_price_estimator,
+        quote_timeout,
+    });
+
+    let routes = [
+        // V1 routes
+        (
+            "/api/v1/account/:owner/orders",
+            axum::routing::get(get_user_orders::get_user_orders_handler),
+        ),
+        (
+            "/api/v1/app_data",
+            axum::routing::put(put_app_data::put_app_data_without_hash)
+                .layer(DefaultBodyLimit::max(app_data_size_limit)),
+        ),
         (
-            "v1/create_order",
-            box_filter(post_order::post_order(orderbook.clone())),
+            "/api/v1/app_data/:hash",
+            axum::routing::get(get_app_data::get_app_data_handler).merge(
+                axum::routing::put(put_app_data::put_app_data_with_hash)
+                    .layer(DefaultBodyLimit::max(app_data_size_limit)),
+            ),
         ),
         (
-            "v1/get_order",
-            box_filter(get_order_by_uid::get_order_by_uid(orderbook.clone())),
+            "/api/v1/auction",
+            axum::routing::get(get_auction::get_auction_handler),
         ),
         (
-            "v1/get_order_status",
-            box_filter(get_order_status::get_status(orderbook.clone())),
+            "/api/v1/orders",
+            axum::routing::post(post_order::post_order_handler)
+                .merge(axum::routing::delete(cancel_orders::cancel_orders_handler)),
         ),
         (
-            "v1/get_trades",
-            box_filter(get_trades::get_trades(database_read.clone())),
+            "/api/v1/orders/:uid",
+            axum::routing::get(get_order_by_uid::get_order_by_uid_handler)
+                .merge(axum::routing::delete(cancel_order::cancel_order_handler)),
         ),
         (
-            "v2/get_trades",
-            box_filter(get_trades_v2::get_trades(database_read.clone())),
+            "/api/v1/orders/:uid/status",
+            axum::routing::get(get_order_status::get_status_handler),
         ),
         (
-            "v1/cancel_order",
-            box_filter(cancel_order::cancel_order(orderbook.clone())),
+            "/api/v1/quote",
+            axum::routing::post(post_quote::post_quote_handler),
         ),
+        // /solver_competition routes (specific before parameterized)
         (
-            "v1/cancel_orders",
-            box_filter(cancel_orders::filter(orderbook.clone())),
+            "/api/v1/solver_competition/latest",
+            axum::routing::get(get_solver_competition::get_solver_competition_latest_handler),
         ),
         (
-            "v1/get_user_orders",
-            box_filter(get_user_orders::get_user_orders(orderbook.clone())),
+            "/api/v1/solver_competition/by_tx_hash/:tx_hash",
+            axum::routing::get(get_solver_competition::get_solver_competition_by_hash_handler),
         ),
         (
-            "v1/get_orders_by_tx",
-            box_filter(get_orders_by_tx::get_orders_by_tx(orderbook.clone())),
+            "/api/v1/solver_competition/:auction_id",
+            axum::routing::get(get_solver_competition::get_solver_competition_by_id_handler),
         ),
-        ("v1/post_quote", box_filter(post_quote::post_quote(quotes))),
         (
-            "v1/auction",
-            box_filter(get_auction::get_auction(orderbook.clone())),
+            "/api/v1/token/:token/metadata",
+            axum::routing::get(get_token_metadata::get_token_metadata_handler),
         ),
         (
-            "v1/solver_competition",
-            box_filter(get_solver_competition::get(Arc::new(
-                database_write.clone(),
-            ))),
+            "/api/v1/token/:token/native_price",
+            axum::routing::get(get_native_price::get_native_price_handler),
         ),
         (
-            "v2/solver_competition",
-            box_filter(get_solver_competition_v2::get(database_write.clone())),
+            "/api/v1/trades",
+            axum::routing::get(get_trades::get_trades_handler),
         ),
         (
-            "v1/solver_competition/latest",
-            box_filter(get_solver_competition::get_latest(Arc::new(
-                database_write.clone(),
-            ))),
+            "/api/v1/transactions/:hash/orders",
+            axum::routing::get(get_orders_by_tx::get_orders_by_tx_handler),
         ),
         (
-            "v2/solver_competition/latest",
-            box_filter(get_solver_competition_v2::get_latest(
-                database_write.clone(),
-            )),
+            "/api/v1/users/:user/total_surplus",
+            axum::routing::get(get_total_surplus::get_total_surplus_handler),
         ),
-        ("v1/version", box_filter(version::version())),
         (
-            "v1/get_native_price",
-            box_filter(get_native_price::get_native_price(
-                native_price_estimator,
-                quote_timeout,
-            )),
+            "/api/v1/version",
+            axum::routing::get(version::version_handler),
         ),
+        // V2 routes
+        // /solver_competition routes (specific before parameterized)
         (
-            "v1/get_app_data",
-            get_app_data::get(database_read.clone()).boxed(),
+            "/api/v2/solver_competition/latest",
+            axum::routing::get(get_solver_competition_v2::get_solver_competition_latest_handler),
         ),
         (
-            "v1/put_app_data",
-            box_filter(put_app_data::filter(app_data)),
+            "/api/v2/solver_competition/by_tx_hash/:tx_hash",
+            axum::routing::get(get_solver_competition_v2::get_solver_competition_by_hash_handler),
         ),
         (
-            "v1/get_total_surplus",
-            box_filter(get_total_surplus::get(database_read.clone())),
+            "/api/v2/solver_competition/:auction_id",
+            axum::routing::get(get_solver_competition_v2::get_solver_competition_by_id_handler),
         ),
         (
-            "v1/get_token_metadata",
-            box_filter(get_token_metadata::get_token_metadata(database_read)),
+            "/api/v2/trades",
+            axum::routing::get(get_trades_v2::get_trades_handler),
         ),
     ];
 
-    finalize_router(routes, "orderbook::api::request_summary")
-}
-
-pub type ApiReply = WithStatus<Json>;
-
-// We turn Rejection into Reply to workaround warp not setting CORS headers on
-// rejections.
-async fn handle_rejection(err: Rejection) -> Result<impl Reply, Infallible> {
-    let response = err.default_response();
-
+    // Initialize metrics
     let metrics = ApiMetrics::instance(observe::metrics::get_storage_registry()).unwrap();
-    metrics
-        .requests_rejected
-        .with_label_values(&[response.status().as_str()])
-        .inc();
+    metrics.reset_requests_rejected();
 
-    Ok(response)
+    let mut api_router = Router::new();
+    for (path, method_router) in routes {
+        metrics.reset_requests_complete(path);
+        api_router = api_router.route(path, method_router);
+    }
+    let api_router = api_router.with_state(state);
+
+    let cors = CorsLayer::new()
+        .allow_origin(tower_http::cors::Any)
+        .allow_methods(ALLOWED_METHODS.to_vec())
+        .allow_headers(vec![
+            axum::http::header::ORIGIN,
+            axum::http::header::CONTENT_TYPE,
+            // Must be lower case due to the HTTP-2 spec
+            axum::http::HeaderName::from_static("x-auth-token"),
+            axum::http::HeaderName::from_static("x-appid"),
+        ]);
+
+    api_router
+        .layer(DefaultBodyLimit::max(MAX_JSON_BODY_PAYLOAD as usize))
+        .layer(cors)
+        .layer(middleware::from_fn(summarize_request))
+        .layer(middleware::from_fn(with_matched_path_metric))
+        .layer(
+            ServiceBuilder::new()
+                .layer(TraceLayer::new_for_http().make_span_with(tracing_axum::make_span))
+                .map_request(record_trace_id),
+        )
 }
 
 #[derive(prometheus_metric_storage::MetricStorage, Clone, Debug)]
@@ -200,43 +331,38 @@ impl ApiMetrics {
         }
     }
 
-    fn reset_requests_complete(&self, method: &str) {
+    fn reset_requests_complete(&self, path: &str) {
         for status in Self::INITIAL_STATUSES {
             self.requests_complete
-                .with_label_values(&[method, status.as_str()])
+                .with_label_values(&[path, status.as_str()])
                 .reset();
         }
     }
-
-    fn on_request_completed(&self, method: &str, status: StatusCode, timer: Instant) {
-        self.requests_complete
-            .with_label_values(&[method, status.as_str()])
-            .inc();
-        self.requests_duration_seconds
-            .with_label_values(&[method])
-            .observe(timer.elapsed().as_secs_f64());
-    }
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct Error<'a> {
-    pub error_type: &'a str,
-    pub description: &'a str,
+pub struct Error {
+    pub error_type: Cow<'static, str>,
+    pub description: Cow<'static, str>,
     /// Additional arbitrary data that can be attached to an API error.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub data: Option<serde_json::Value>,
 }
 
-pub fn error(error_type: &str, description: impl AsRef<str>) -> Json {
-    json(&Error {
-        error_type,
-        description: description.as_ref(),
+pub fn error(error_type: &'static str, description: impl AsRef<str>) -> Json<Error> {
+    Json(Error {
+        error_type: error_type.into(),
+        description: Cow::Owned(description.as_ref().to_owned()),
         data: None,
     })
 }
 
-pub fn rich_error(error_type: &str, description: impl AsRef<str>, data: impl Serialize) -> Json {
+pub fn rich_error(
+    error_type: &'static str,
+    description: impl AsRef<str>,
+    data: impl Serialize,
+) -> Json<Error> {
     let data = match serde_json::to_value(&data) {
         Ok(value) => Some(value),
         Err(err) => {
@@ -245,146 +371,52 @@ pub fn rich_error(error_type: &str, description: impl AsRef<str>, data: impl Ser
         }
     };
 
-    json(&Error {
-        error_type,
-        description: description.as_ref(),
+    Json(Error {
+        error_type: error_type.into(),
+        description: Cow::Owned(description.as_ref().to_owned()),
         data,
     })
 }
 
-pub fn internal_error_reply() -> ApiReply {
-    with_status(
-        error("InternalServerError", ""),
+pub fn internal_error_reply() -> Response {
+    (
         StatusCode::INTERNAL_SERVER_ERROR,
+        error("InternalServerError", ""),
     )
+        .into_response()
 }
 
-pub fn convert_json_response<T, E>(result: Result<T, E>) -> WithStatus<Json>
-where
-    T: Serialize,
-    E: IntoWarpReply + Debug,
-{
-    match result {
-        Ok(response) => with_status(warp::reply::json(&response), StatusCode::OK),
-        Err(err) => err.into_warp_reply(),
-    }
-}
-
-pub trait IntoWarpReply {
-    fn into_warp_reply(self) -> ApiReply;
-}
+// Newtype wrapper for PriceEstimationError to allow IntoResponse implementation
+// (orphan rules prevent implementing IntoResponse directly on external types)
+pub(crate) struct PriceEstimationErrorWrapper(pub(crate) PriceEstimationError);
 
-pub async fn response_body(response: warp::hyper::Response<warp::hyper::Body>) -> Vec<u8> {
-    let mut body = response.into_body();
-    let mut result = Vec::new();
-    while let Some(bytes) = futures::StreamExt::next(&mut body).await {
-        result.extend_from_slice(bytes.unwrap().as_ref());
-    }
-    result
-}
-
-const MAX_JSON_BODY_PAYLOAD: u64 = 1024 * 16;
-
-pub fn extract_payload<T: DeserializeOwned + Send>()
--> impl Filter<Extract = (T,), Error = Rejection> + Clone {
-    // (rejecting huge payloads)...
-    extract_payload_with_max_size(MAX_JSON_BODY_PAYLOAD)
-}
-
-pub fn extract_payload_with_max_size<T: DeserializeOwned + Send>(
-    max_size: u64,
-) -> impl Filter<Extract = (T,), Error = Rejection> + Clone {
-    warp::body::content_length_limit(max_size).and(warp::body::json())
-}
-
-pub type BoxedRoute = BoxedFilter<(Box<dyn Reply>,)>;
-
-pub fn box_filter<Filter_, Reply_>(filter: Filter_) -> BoxedFilter<(Box<dyn Reply>,)>
-where
-    Filter_: Filter<Extract = (Reply_,), Error = Rejection> + Send + Sync + 'static,
-    Reply_: Reply + Send + 'static,
-{
-    filter.map(|a| Box::new(a) as Box<dyn Reply>).boxed()
-}
-
-/// Sets up basic metrics, cors and proper log tracing for all routes.
-///
-/// # Panics
-///
-/// This method panics if `routes` is empty.
-pub fn finalize_router(
-    routes: Vec<(&'static str, BoxedRoute)>,
-    log_prefix: &'static str,
-) -> impl Filter<Extract = (impl Reply,), Error = Rejection> + Clone {
-    let metrics = ApiMetrics::instance(observe::metrics::get_storage_registry()).unwrap();
-    metrics.reset_requests_rejected();
-    for (method, _) in &routes {
-        metrics.reset_requests_complete(method);
-    }
-
-    let router = routes
-        .into_iter()
-        .fold(
-            Option::<BoxedFilter<(&'static str, Box<dyn Reply>)>>::None,
-            |router, (method, route)| {
-                let route = route.map(move |result| (method, result)).untuple_one();
-                let next = match router {
-                    Some(router) => router.or(route).unify().boxed(),
-                    None => route.boxed(),
-                };
-                Some(next)
-            },
-        )
-        .expect("routes cannot be empty");
-
-    let instrumented =
-        warp::any()
-            .map(Instant::now)
-            .and(router)
-            .map(|timer, method, reply: Box<dyn Reply>| {
-                let response = reply.into_response();
-                metrics.on_request_completed(method, response.status(), timer);
-                response
-            });
-
-    // Final setup
-    let cors = warp::cors()
-        .allow_any_origin()
-        .allow_methods(vec![
-            "GET", "POST", "DELETE", "OPTIONS", "PUT", "PATCH", "HEAD",
-        ])
-        .allow_headers(vec!["Origin", "Content-Type", "X-Auth-Token", "X-AppId"]);
-
-    warp::path!("api" / ..)
-        .and(instrumented)
-        .recover(handle_rejection)
-        .with(cors)
-        .with(warp::log::log(log_prefix))
-        .with(warp::trace::trace(make_span))
-}
-
-impl IntoWarpReply for PriceEstimationError {
-    fn into_warp_reply(self) -> WithStatus<Json> {
-        match self {
-            Self::UnsupportedToken { token, reason } => with_status(
+impl IntoResponse for PriceEstimationErrorWrapper {
+    fn into_response(self) -> Response {
+        match self.0 {
+            PriceEstimationError::UnsupportedToken { token, reason } => (
+                StatusCode::BAD_REQUEST,
                 error(
                     "UnsupportedToken",
                     format!("Token {token:?} is unsupported: {reason:}"),
                 ),
+            )
+                .into_response(),
+            PriceEstimationError::UnsupportedOrderType(order_type) => (
                 StatusCode::BAD_REQUEST,
-            ),
-            Self::UnsupportedOrderType(order_type) => with_status(
                 error(
                     "UnsupportedOrderType",
                     format!("{order_type} not supported"),
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
-            Self::NoLiquidity | Self::RateLimited | Self::EstimatorInternal(_) => with_status(
-                error("NoLiquidity", "no route found"),
+            )
+                .into_response(),
+            PriceEstimationError::NoLiquidity
+            | PriceEstimationError::RateLimited
+            | PriceEstimationError::EstimatorInternal(_) => (
                 StatusCode::NOT_FOUND,
-            ),
-            Self::ProtocolInternal(err) => {
+                error("NoLiquidity", "no route found"),
+            )
+                .into_response(),
+            PriceEstimationError::ProtocolInternal(err) => {
                 tracing::error!(?err, "PriceEstimationError::Other");
                 internal_error_reply()
             }
@@ -392,6 +424,36 @@ impl IntoWarpReply for PriceEstimationError {
     }
 }
 
+impl IntoResponse for LoadSolverCompetitionError {
+    fn into_response(self) -> Response {
+        match self {
+            err @ LoadSolverCompetitionError::NotFound => {
+                (StatusCode::NOT_FOUND, error("NotFound", err.to_string())).into_response()
+            }
+            LoadSolverCompetitionError::Other(err) => {
+                tracing::error!(?err, "failed to load solver competition");
+                internal_error_reply()
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+pub async fn response_body<B>(response: axum::http::Response<B>) -> Vec<u8>
+where
+    B: axum::body::HttpBody + Unpin,
+    B::Data: AsRef<[u8]>,
+    B::Error: Debug,
+{
+    let mut body = response.into_body();
+    let mut result = Vec::new();
+    while let Some(frame) = body.data().await {
+        let bytes = frame.unwrap();
+        result.extend_from_slice(bytes.as_ref());
+    }
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, serde::ser, serde_json::json};
@@ -400,8 +462,8 @@ mod tests {
     fn rich_errors_skip_unset_data_field() {
         assert_eq!(
             serde_json::to_value(&Error {
-                error_type: "foo",
-                description: "bar",
+                error_type: "foo".into(),
+                description: "bar".into(),
                 data: None,
             })
             .unwrap(),
@@ -412,8 +474,8 @@ mod tests {
         );
         assert_eq!(
             serde_json::to_value(Error {
-                error_type: "foo",
-                description: "bar",
+                error_type: "foo".into(),
+                description: "bar".into(),
                 data: Some(json!(42)),
             })
             .unwrap(),
@@ -427,6 +489,8 @@ mod tests {
 
     #[tokio::test]
     async fn rich_errors_handle_serialization_errors() {
+        use axum::body::HttpBody;
+
         struct AlwaysErrors;
         impl Serialize for AlwaysErrors {
             fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
@@ -437,16 +501,16 @@ mod tests {
             }
         }
 
-        let body = warp::hyper::body::to_bytes(
-            rich_error("foo", "bar", AlwaysErrors)
-                .into_response()
-                .into_body(),
-        )
-        .await
-        .unwrap();
+        let response = rich_error("foo", "bar", AlwaysErrors).into_response();
+        let mut body = response.into_body();
+        let mut bytes = Vec::new();
+        while let Some(frame) = body.data().await {
+            let chunk = frame.unwrap();
+            bytes.extend_from_slice(&chunk);
+        }
 
         assert_eq!(
-            serde_json::from_slice::<serde_json::Value>(&body).unwrap(),
+            serde_json::from_slice::<serde_json::Value>(&bytes).unwrap(),
             json!({
                 "errorType": "foo",
                 "description": "bar",
diff --git a/crates/orderbook/src/api/cancel_order.rs b/crates/orderbook/src/api/cancel_order.rs
index ae141b299d..a0c331c3e9 100644
--- a/crates/orderbook/src/api/cancel_order.rs
+++ b/crates/orderbook/src/api/cancel_order.rs
@@ -1,60 +1,84 @@
 use {
-    crate::{
-        api::{IntoWarpReply, convert_json_response, extract_payload},
-        orderbook::{OrderCancellationError, Orderbook},
+    crate::{api::AppState, orderbook::OrderCancellationError},
+    axum::{
+        Json,
+        body,
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Response},
     },
-    anyhow::Result,
     model::order::{CancellationPayload, OrderCancellation, OrderUid},
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, hyper::StatusCode, reply::with_status},
+    std::{str::FromStr, sync::Arc},
 };
 
-pub fn cancel_order_request()
--> impl Filter<Extract = (OrderCancellation,), Error = Rejection> + Clone {
-    warp::path!("v1" / "orders" / OrderUid)
-        .and(warp::delete())
-        .and(extract_payload())
-        .map(|uid, payload: CancellationPayload| OrderCancellation {
-            order_uid: uid,
-            signature: payload.signature,
-            signing_scheme: payload.signing_scheme,
-        })
+pub async fn cancel_order_handler(
+    State(state): State<Arc<AppState>>,
+    Path(uid): Path<String>,
+    body: body::Bytes,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(uid) = OrderUid::from_str(&uid) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+    let Ok(payload) = serde_json::from_slice::<CancellationPayload>(&body) else {
+        return StatusCode::BAD_REQUEST.into_response();
+    };
+
+    let order_cancellation = OrderCancellation {
+        order_uid: uid,
+        signature: payload.signature,
+        signing_scheme: payload.signing_scheme,
+    };
+    state
+        .orderbook
+        .cancel_order(order_cancellation)
+        .await
+        .map(|_| Json("Cancelled"))
+        .into_response()
 }
 
-impl IntoWarpReply for OrderCancellationError {
-    fn into_warp_reply(self) -> super::ApiReply {
+impl IntoResponse for OrderCancellationError {
+    fn into_response(self) -> Response {
         match self {
-            Self::InvalidSignature => with_status(
+            Self::InvalidSignature => (
+                StatusCode::BAD_REQUEST,
                 super::error("InvalidSignature", "Malformed signature"),
+            )
+                .into_response(),
+            Self::AlreadyCancelled => (
                 StatusCode::BAD_REQUEST,
-            ),
-            Self::AlreadyCancelled => with_status(
                 super::error("AlreadyCancelled", "Order is already cancelled"),
+            )
+                .into_response(),
+            Self::OrderFullyExecuted => (
                 StatusCode::BAD_REQUEST,
-            ),
-            Self::OrderFullyExecuted => with_status(
                 super::error("OrderFullyExecuted", "Order is fully executed"),
+            )
+                .into_response(),
+            Self::OrderExpired => (
                 StatusCode::BAD_REQUEST,
-            ),
-            Self::OrderExpired => with_status(
                 super::error("OrderExpired", "Order is expired"),
-                StatusCode::BAD_REQUEST,
-            ),
-            Self::OrderNotFound => with_status(
-                super::error("OrderNotFound", "Order not located in database"),
+            )
+                .into_response(),
+            Self::OrderNotFound => (
                 StatusCode::NOT_FOUND,
-            ),
-            Self::WrongOwner => with_status(
+                super::error("OrderNotFound", "Order not located in database"),
+            )
+                .into_response(),
+            Self::WrongOwner => (
+                StatusCode::UNAUTHORIZED,
                 super::error(
                     "WrongOwner",
                     "Signature recovery's owner doesn't match order's",
                 ),
-                StatusCode::UNAUTHORIZED,
-            ),
-            Self::OnChainOrder => with_status(
-                super::error("OnChainOrder", "On-chain orders must be cancelled on-chain"),
+            )
+                .into_response(),
+            Self::OnChainOrder => (
                 StatusCode::BAD_REQUEST,
-            ),
+                super::error("OnChainOrder", "On-chain orders must be cancelled on-chain"),
+            )
+                .into_response(),
             Self::Other(err) => {
                 tracing::error!(?err, "cancel_order");
                 crate::api::internal_error_reply()
@@ -63,22 +87,6 @@ impl IntoWarpReply for OrderCancellationError {
     }
 }
 
-pub fn cancel_order_response(result: Result<(), OrderCancellationError>) -> super::ApiReply {
-    convert_json_response(result.map(|_| "Cancelled"))
-}
-
-pub fn cancel_order(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    cancel_order_request().and_then(move |order| {
-        let orderbook = orderbook.clone();
-        async move {
-            let result = orderbook.cancel_order(order).await;
-            Result::<_, Infallible>::Ok(cancel_order_response(result))
-        }
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use {
@@ -86,9 +94,10 @@ mod tests {
         alloy::primitives::b256,
         model::signature::{EcdsaSignature, EcdsaSigningScheme},
         serde_json::json,
-        warp::{Reply, test::request},
     };
 
+    type Result = std::result::Result<Json<&'static str>, OrderCancellationError>;
+
     #[test]
     fn cancellation_payload_deserialization() {
         assert_eq!(
@@ -111,57 +120,34 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn cancel_order_request_ok() {
-        let filter = cancel_order_request();
-        let cancellation = OrderCancellation::default();
-
-        let request = request()
-            .path(&format!("/v1/orders/{}", cancellation.order_uid))
-            .method("DELETE")
-            .header("content-type", "application/json")
-            .json(&CancellationPayload {
-                signature: cancellation.signature,
-                signing_scheme: cancellation.signing_scheme,
-            });
-        let result = request.filter(&filter).await.unwrap();
-        assert_eq!(result, cancellation);
-    }
-
     #[test]
     fn cancel_order_response_ok() {
-        let response = cancel_order_response(Ok(())).into_response();
+        let response = (Result::Ok(Json("Cancelled"))).into_response();
         assert_eq!(response.status(), StatusCode::OK);
     }
 
     #[test]
     fn cancel_order_response_err() {
-        let response =
-            cancel_order_response(Err(OrderCancellationError::InvalidSignature)).into_response();
+        let response = Result::Err(OrderCancellationError::InvalidSignature).into_response();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
-        let response =
-            cancel_order_response(Err(OrderCancellationError::OrderFullyExecuted)).into_response();
+        let response = Result::Err(OrderCancellationError::OrderFullyExecuted).into_response();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
-        let response =
-            cancel_order_response(Err(OrderCancellationError::AlreadyCancelled)).into_response();
+        let response = Result::Err(OrderCancellationError::AlreadyCancelled).into_response();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
-        let response =
-            cancel_order_response(Err(OrderCancellationError::OrderExpired)).into_response();
+        let response = Result::Err(OrderCancellationError::OrderExpired).into_response();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
-        let response =
-            cancel_order_response(Err(OrderCancellationError::WrongOwner)).into_response();
+        let response = Result::Err(OrderCancellationError::WrongOwner).into_response();
         assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
 
-        let response =
-            cancel_order_response(Err(OrderCancellationError::OrderNotFound)).into_response();
+        let response = Result::Err(OrderCancellationError::OrderNotFound).into_response();
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
 
-        let response = cancel_order_response(Err(OrderCancellationError::Other(
-            anyhow::Error::msg("test error"),
+        let response = Result::Err(OrderCancellationError::Other(anyhow::Error::msg(
+            "test error",
         )))
         .into_response();
         assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
diff --git a/crates/orderbook/src/api/cancel_orders.rs b/crates/orderbook/src/api/cancel_orders.rs
index b252fd8dae..4c6f8e47e5 100644
--- a/crates/orderbook/src/api/cancel_orders.rs
+++ b/crates/orderbook/src/api/cancel_orders.rs
@@ -1,32 +1,41 @@
 use {
-    crate::{
-        api::{convert_json_response, extract_payload},
-        orderbook::{OrderCancellationError, Orderbook},
+    crate::{api::AppState, orderbook::OrderCancellationError},
+    anyhow::anyhow,
+    axum::{
+        Json,
+        body,
+        extract::State,
+        response::{IntoResponse, Response},
     },
-    anyhow::Result,
-    model::order::SignedOrderCancellations,
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection},
+    hyper::StatusCode,
+    model::order::{ORDER_UID_LIMIT, SignedOrderCancellations},
+    std::sync::Arc,
 };
 
-pub fn request() -> impl Filter<Extract = (SignedOrderCancellations,), Error = Rejection> + Clone {
-    warp::path!("v1" / "orders")
-        .and(warp::delete())
-        .and(extract_payload())
-}
+pub async fn cancel_orders_handler(
+    State(state): State<Arc<AppState>>,
+    body: body::Bytes,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(cancellations) = serde_json::from_slice::<SignedOrderCancellations>(&body) else {
+        return StatusCode::BAD_REQUEST.into_response();
+    };
 
-pub fn response(result: Result<(), OrderCancellationError>) -> super::ApiReply {
-    convert_json_response(result.map(|_| "Cancelled"))
-}
+    // Explicitly limit the number of orders cancelled in a batch as the request
+    // size limit *does not* provide a proper bound for this
+    if cancellations.data.order_uids.len() > ORDER_UID_LIMIT {
+        return Err::<&'static str, _>(OrderCancellationError::Other(anyhow!(
+            "too many orders ({} > 1024)",
+            cancellations.data.order_uids.len()
+        )))
+        .into_response();
+    }
 
-pub fn filter(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    request().and_then(move |cancellations| {
-        let orderbook = orderbook.clone();
-        async move {
-            let result = orderbook.cancel_orders(cancellations).await;
-            Result::<_, Infallible>::Ok(response(result))
-        }
-    })
+    state
+        .orderbook
+        .cancel_orders(cancellations)
+        .await
+        .map(|_| Json("Cancelled"))
+        .into_response()
 }
diff --git a/crates/orderbook/src/api/get_app_data.rs b/crates/orderbook/src/api/get_app_data.rs
index 21c3a099e2..68ff733611 100644
--- a/crates/orderbook/src/api/get_app_data.rs
+++ b/crates/orderbook/src/api/get_app_data.rs
@@ -1,42 +1,38 @@
 use {
-    crate::database::Postgres,
-    anyhow::Result,
+    crate::api::AppState,
     app_data::{AppDataDocument, AppDataHash},
-    reqwest::StatusCode,
-    std::convert::Infallible,
-    warp::{Filter, Rejection, Reply, reply},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    std::{str::FromStr, sync::Arc},
 };
 
-pub fn request() -> impl Filter<Extract = (AppDataHash,), Error = Rejection> + Clone {
-    warp::path!("v1" / "app_data" / AppDataHash).and(warp::get())
-}
+pub async fn get_app_data_handler(
+    State(state): State<Arc<AppState>>,
+    Path(contract_app_data): Path<String>,
+) -> Response {
+    let Ok(contract_app_data) = AppDataHash::from_str(&contract_app_data) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-pub fn get(
-    database: Postgres,
-) -> impl Filter<Extract = (Box<dyn Reply>,), Error = Rejection> + Clone {
-    request().and_then(move |contract_app_data: AppDataHash| {
-        let database = database.clone();
-        async move {
-            let result = database.get_full_app_data(&contract_app_data).await;
-            Result::<_, Infallible>::Ok(match result {
-                Ok(Some(response)) => {
-                    let response = reply::with_status(
-                        reply::json(&AppDataDocument {
-                            full_app_data: response,
-                        }),
-                        StatusCode::OK,
-                    );
-                    Box::new(response) as Box<dyn Reply>
-                }
-                Ok(None) => Box::new(reply::with_status(
-                    "full app data not found",
-                    StatusCode::NOT_FOUND,
-                )),
-                Err(err) => {
-                    tracing::error!(?err, "get_app_data_by_hash");
-                    Box::new(crate::api::internal_error_reply())
-                }
-            })
+    let result = state
+        .database_read
+        .get_full_app_data(&contract_app_data)
+        .await;
+    match result {
+        Ok(Some(response)) => (
+            StatusCode::OK,
+            Json(AppDataDocument {
+                full_app_data: response,
+            }),
+        )
+            .into_response(),
+        Ok(None) => (StatusCode::NOT_FOUND, "full app data not found").into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_app_data_by_hash");
+            crate::api::internal_error_reply()
         }
-    })
+    }
 }
diff --git a/crates/orderbook/src/api/get_auction.rs b/crates/orderbook/src/api/get_auction.rs
index cfe169f8a7..1577fdc363 100644
--- a/crates/orderbook/src/api/get_auction.rs
+++ b/crates/orderbook/src/api/get_auction.rs
@@ -1,34 +1,25 @@
 use {
-    crate::{api::ApiReply, orderbook::Orderbook},
-    anyhow::Result,
-    reqwest::StatusCode,
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, reply::with_status},
+    crate::api::AppState,
+    axum::{
+        extract::State,
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    std::sync::Arc,
 };
 
-fn get_auction_request() -> impl Filter<Extract = (), Error = Rejection> + Clone {
-    warp::path!("v1" / "auction").and(warp::get())
-}
-
-pub fn get_auction(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    get_auction_request().and_then(move || {
-        let orderbook = orderbook.clone();
-        async move {
-            let result = orderbook.get_auction().await;
-            let reply = match result {
-                Ok(Some(auction)) => with_status(warp::reply::json(&auction), StatusCode::OK),
-                Ok(None) => with_status(
-                    super::error("NotFound", "There is no active auction"),
-                    StatusCode::NOT_FOUND,
-                ),
-                Err(err) => {
-                    tracing::error!(?err, "/api/v1/get_auction");
-                    crate::api::internal_error_reply()
-                }
-            };
-            Result::<_, Infallible>::Ok(reply)
+pub async fn get_auction_handler(State(state): State<Arc<AppState>>) -> Response {
+    let result = state.orderbook.get_auction().await;
+    match result {
+        Ok(Some(auction)) => Json(auction).into_response(),
+        Ok(None) => (
+            StatusCode::NOT_FOUND,
+            super::error("NotFound", "There is no active auction"),
+        )
+            .into_response(),
+        Err(err) => {
+            tracing::error!(?err, "/api/v1/get_auction");
+            crate::api::internal_error_reply()
         }
-    })
+    }
 }
diff --git a/crates/orderbook/src/api/get_native_price.rs b/crates/orderbook/src/api/get_native_price.rs
index b2c027ebce..563b73bad5 100644
--- a/crates/orderbook/src/api/get_native_price.rs
+++ b/crates/orderbook/src/api/get_native_price.rs
@@ -1,50 +1,30 @@
 use {
-    crate::api::{ApiReply, IntoWarpReply},
+    crate::api::{AppState, PriceEstimationErrorWrapper},
     alloy::primitives::Address,
-    anyhow::Result,
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
     model::quote::NativeTokenPrice,
-    shared::price_estimation::native::NativePriceEstimating,
-    std::{convert::Infallible, sync::Arc, time::Duration},
-    warp::{Filter, Rejection, hyper::StatusCode, reply::with_status},
+    std::{str::FromStr, sync::Arc},
 };
 
-fn get_native_prices_request() -> impl Filter<Extract = (Address,), Error = Rejection> + Clone {
-    warp::path!("v1" / "token" / Address / "native_price").and(warp::get())
-}
-
-pub fn get_native_price(
-    estimator: Arc<dyn NativePriceEstimating>,
-    quote_timeout: Duration,
-) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    get_native_prices_request().and_then(move |token: Address| {
-        let estimator = estimator.clone();
-        async move {
-            let result = estimator.estimate_native_price(token, quote_timeout).await;
-            let reply = match result {
-                Ok(price) => with_status(
-                    warp::reply::json(&NativeTokenPrice { price }),
-                    StatusCode::OK,
-                ),
-                Err(err) => err.into_warp_reply(),
-            };
-            Result::<_, Infallible>::Ok(reply)
-        }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, alloy::primitives::address, futures::FutureExt, warp::test::request};
+pub async fn get_native_price_handler(
+    State(state): State<Arc<AppState>>,
+    Path(token): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(token) = Address::from_str(&token) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-    #[test]
-    fn native_prices_query() {
-        let path = "/v1/token/0xdac17f958d2ee523a2206206994597c13d831ec7/native_price";
-        let request = request().path(path).method("GET");
-        let result = request
-            .filter(&get_native_prices_request())
-            .now_or_never()
-            .unwrap()
-            .unwrap();
-        assert_eq!(result, address!("dac17f958d2ee523a2206206994597c13d831ec7"));
-    }
+    state
+        .native_price_estimator
+        .estimate_native_price(token, state.quote_timeout)
+        .await
+        .map(|price| Json(NativeTokenPrice { price }))
+        .map_err(PriceEstimationErrorWrapper)
+        .into_response()
 }
diff --git a/crates/orderbook/src/api/get_order_by_uid.rs b/crates/orderbook/src/api/get_order_by_uid.rs
index 9a579eacaf..4e0b9e6e71 100644
--- a/crates/orderbook/src/api/get_order_by_uid.rs
+++ b/crates/orderbook/src/api/get_order_by_uid.rs
@@ -1,16 +1,30 @@
 use {
-    crate::orderbook::Orderbook,
+    crate::api::AppState,
     anyhow::Result,
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
     model::order::{Order, OrderUid},
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, hyper::StatusCode, reply},
+    std::{str::FromStr, sync::Arc},
 };
 
-pub fn get_order_by_uid_request() -> impl Filter<Extract = (OrderUid,), Error = Rejection> + Clone {
-    warp::path!("v1" / "orders" / OrderUid).and(warp::get())
+pub async fn get_order_by_uid_handler(
+    State(state): State<Arc<AppState>>,
+    Path(uid): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(uid) = OrderUid::from_str(&uid) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+
+    let result = state.orderbook.get_order(&uid).await;
+    get_order_by_uid_response(result)
 }
 
-pub fn get_order_by_uid_response(result: Result<Option<Order>>) -> super::ApiReply {
+pub fn get_order_by_uid_response(result: Result<Option<Order>>) -> Response {
     let order = match result {
         Ok(order) => order,
         Err(err) => {
@@ -19,47 +33,23 @@ pub fn get_order_by_uid_response(result: Result<Option<Order>>) -> super::ApiRep
         }
     };
     match order {
-        Some(order) => reply::with_status(reply::json(&order), StatusCode::OK),
-        None => reply::with_status(
-            super::error("NotFound", "Order was not found"),
+        Some(order) => (StatusCode::OK, Json(order)).into_response(),
+        None => (
             StatusCode::NOT_FOUND,
-        ),
+            super::error("NotFound", "Order was not found"),
+        )
+            .into_response(),
     }
 }
 
-pub fn get_order_by_uid(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    get_order_by_uid_request().and_then(move |uid| {
-        let orderbook = orderbook.clone();
-        async move {
-            let result = orderbook.get_order(&uid).await;
-            Result::<_, Infallible>::Ok(get_order_by_uid_response(result))
-        }
-    })
-}
-
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::api::response_body,
-        warp::{Reply, test::request},
-    };
-
-    #[tokio::test]
-    async fn get_order_by_uid_request_ok() {
-        let uid = OrderUid::default();
-        let request = request().path(&format!("/v1/orders/{uid}")).method("GET");
-        let filter = get_order_by_uid_request();
-        let result = request.filter(&filter).await.unwrap();
-        assert_eq!(result, uid);
-    }
+    use {super::*, crate::api::response_body};
 
     #[tokio::test]
     async fn get_order_by_uid_response_ok() {
         let order = Order::default();
-        let response = get_order_by_uid_response(Ok(Some(order.clone()))).into_response();
+        let response = get_order_by_uid_response(Ok(Some(order.clone())));
         assert_eq!(response.status(), StatusCode::OK);
         let body = response_body(response).await;
         let response_order: Order = serde_json::from_slice(body.as_slice()).unwrap();
@@ -68,7 +58,7 @@ mod tests {
 
     #[tokio::test]
     async fn get_order_by_uid_response_non_existent() {
-        let response = get_order_by_uid_response(Ok(None)).into_response();
+        let response = get_order_by_uid_response(Ok(None));
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
 }
diff --git a/crates/orderbook/src/api/get_order_status.rs b/crates/orderbook/src/api/get_order_status.rs
index 90f0d5336e..e90e9537a3 100644
--- a/crates/orderbook/src/api/get_order_status.rs
+++ b/crates/orderbook/src/api/get_order_status.rs
@@ -1,36 +1,35 @@
 use {
-    crate::{
-        api::ApiReply,
-        orderbook::{OrderStatusError, Orderbook},
+    crate::{api::AppState, orderbook::OrderStatusError},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
     },
-    anyhow::Result,
     model::order::OrderUid,
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, hyper::StatusCode, reply},
+    std::{str::FromStr, sync::Arc},
 };
 
-fn get_status_request() -> impl Filter<Extract = (OrderUid,), Error = Rejection> + Clone {
-    warp::path!("v1" / "orders" / OrderUid / "status").and(warp::get())
-}
+pub async fn get_status_handler(
+    State(state): State<Arc<AppState>>,
+    Path(uid): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(uid) = OrderUid::from_str(&uid) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-pub fn get_status(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    get_status_request().and_then(move |uid| {
-        let orderbook = orderbook.clone();
-        async move {
-            let status = orderbook.get_order_status(&uid).await;
-            Result::<_, Infallible>::Ok(match status {
-                Ok(status) => warp::reply::with_status(warp::reply::json(&status), StatusCode::OK),
-                Err(OrderStatusError::NotFound) => reply::with_status(
-                    super::error("NotFound", "Order status was not found"),
-                    StatusCode::NOT_FOUND,
-                ),
-                Err(err) => {
-                    tracing::error!(?err, "get_order_status");
-                    *Box::new(crate::api::internal_error_reply())
-                }
-            })
+    let status = state.orderbook.get_order_status(&uid).await;
+    match status {
+        Ok(status) => Json(status).into_response(),
+        Err(err @ OrderStatusError::NotFound) => (
+            StatusCode::NOT_FOUND,
+            super::error("NotFound", err.to_string()),
+        )
+            .into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_order_status");
+            crate::api::internal_error_reply()
         }
-    })
+    }
 }
diff --git a/crates/orderbook/src/api/get_orders_by_tx.rs b/crates/orderbook/src/api/get_orders_by_tx.rs
index dc357227de..a06acee9db 100644
--- a/crates/orderbook/src/api/get_orders_by_tx.rs
+++ b/crates/orderbook/src/api/get_orders_by_tx.rs
@@ -1,47 +1,30 @@
 use {
-    crate::{api::ApiReply, orderbook::Orderbook},
+    crate::api::AppState,
     alloy::primitives::B256,
-    anyhow::Result,
-    reqwest::StatusCode,
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, reply::with_status},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    std::{str::FromStr, sync::Arc},
 };
 
-pub fn get_orders_by_tx_request() -> impl Filter<Extract = (B256,), Error = Rejection> + Clone {
-    warp::path!("v1" / "transactions" / B256 / "orders").and(warp::get())
-}
+pub async fn get_orders_by_tx_handler(
+    State(state): State<Arc<AppState>>,
+    Path(hash): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(hash) = B256::from_str(&hash) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-pub fn get_orders_by_tx(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    get_orders_by_tx_request().and_then(move |hash: B256| {
-        let orderbook = orderbook.clone();
-        async move {
-            let result = orderbook.get_orders_for_tx(&hash).await;
-            Result::<_, Infallible>::Ok(match result {
-                Ok(response) => with_status(warp::reply::json(&response), StatusCode::OK),
-                Err(err) => {
-                    tracing::error!(?err, "get_orders_by_tx");
-                    crate::api::internal_error_reply()
-                }
-            })
+    let result = state.orderbook.get_orders_for_tx(&hash).await;
+    match result {
+        Ok(response) => Json(response).into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_orders_by_tx");
+            crate::api::internal_error_reply()
         }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, std::str::FromStr};
-
-    #[tokio::test]
-    async fn request_ok() {
-        let hash_str = "0x0191dbb560e936bd3320d5a505c9c05580a0ebb7e12fe117551ac26e484f295e";
-        let result = warp::test::request()
-            .path(&format!("/v1/transactions/{hash_str}/orders"))
-            .method("GET")
-            .filter(&get_orders_by_tx_request())
-            .await
-            .unwrap();
-        assert_eq!(result.0, B256::from_str(hash_str).unwrap().0);
     }
 }
diff --git a/crates/orderbook/src/api/get_solver_competition.rs b/crates/orderbook/src/api/get_solver_competition.rs
index 26e7a38390..4335160139 100644
--- a/crates/orderbook/src/api/get_solver_competition.rs
+++ b/crates/orderbook/src/api/get_solver_competition.rs
@@ -1,114 +1,88 @@
 use {
-    crate::solver_competition::{Identifier, LoadSolverCompetitionError, SolverCompetitionStoring},
+    crate::{
+        api::AppState,
+        solver_competition::{Identifier, SolverCompetitionStoring},
+    },
     alloy::primitives::B256,
-    anyhow::Result,
-    model::{AuctionId, solver_competition::SolverCompetitionAPI},
-    reqwest::StatusCode,
-    std::{convert::Infallible, sync::Arc},
-    warp::{
-        Filter,
-        Rejection,
-        reply::{Json, WithStatus, with_status},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
     },
+    model::{AuctionId, solver_competition::SolverCompetitionAPI},
+    std::{str::FromStr, sync::Arc},
 };
 
-fn request_id() -> impl Filter<Extract = (Identifier,), Error = Rejection> + Clone {
-    warp::path!("v1" / "solver_competition" / AuctionId)
-        .and(warp::get())
-        .map(Identifier::Id)
-}
+pub async fn get_solver_competition_by_id_handler(
+    State(state): State<Arc<AppState>>,
+    Path(auction_id): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(auction_id) = auction_id.parse::<u64>() else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-fn request_hash() -> impl Filter<Extract = (Identifier,), Error = Rejection> + Clone {
-    warp::path!("v1" / "solver_competition" / "by_tx_hash" / B256)
-        .and(warp::get())
-        .map(Identifier::Transaction)
-}
+    // We use u64 to ensure that negative numbers are returned as BAD_REQUEST
+    // however, there's a gap between u64::MAX and i64::MAX, numbers beyond i64::MAX
+    // will be marked as NOT_FOUND as they're positive (and as such, valid) but
+    // they are not covered by our system
+    if auction_id >= AuctionId::MAX.cast_unsigned() {
+        return crate::solver_competition::LoadSolverCompetitionError::NotFound.into_response();
+    }
 
-fn request_latest() -> impl Filter<Extract = (), Error = Rejection> + Clone {
-    warp::path!("v1" / "solver_competition" / "latest").and(warp::get())
-}
-pub fn get(
-    handler: Arc<dyn SolverCompetitionStoring>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    request_id()
-        .or(request_hash())
-        .unify()
-        .and_then(move |identifier: Identifier| {
-            let handler = handler.clone();
-            async move {
-                let result = handler.load_competition(identifier).await;
-                Result::<_, Infallible>::Ok(response(result))
-            }
-        })
+    let handler: &dyn SolverCompetitionStoring = &state.database_read;
+    handler
+        .load_competition(Identifier::Id(auction_id.cast_signed()))
+        .await
+        .map(Json)
+        .into_response()
 }
 
-pub fn get_latest(
-    handler: Arc<dyn SolverCompetitionStoring>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    request_latest().and_then(move || {
-        let handler = handler.clone();
-        async move {
-            let result = handler.load_latest_competition().await;
-            Result::<_, Infallible>::Ok(response(result))
-        }
-    })
+pub async fn get_solver_competition_by_hash_handler(
+    State(state): State<Arc<AppState>>,
+    Path(tx_hash): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(tx_hash) = B256::from_str(&tx_hash) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+
+    let handler: &dyn SolverCompetitionStoring = &state.database_read;
+    handler
+        .load_competition(Identifier::Transaction(tx_hash))
+        .await
+        .map(Json)
+        .into_response()
 }
 
-fn response(
-    result: Result<SolverCompetitionAPI, crate::solver_competition::LoadSolverCompetitionError>,
-) -> WithStatus<Json> {
-    match result {
-        Ok(response) => with_status(warp::reply::json(&response), StatusCode::OK),
-        Err(LoadSolverCompetitionError::NotFound) => with_status(
-            super::error("NotFound", "no competition found"),
-            StatusCode::NOT_FOUND,
-        ),
-        Err(LoadSolverCompetitionError::Other(err)) => {
-            tracing::error!(?err, "load solver competition");
-            crate::api::internal_error_reply()
-        }
-    }
+pub async fn get_solver_competition_latest_handler(
+    State(state): State<Arc<AppState>>,
+) -> Result<Json<SolverCompetitionAPI>, crate::solver_competition::LoadSolverCompetitionError> {
+    let handler: &dyn SolverCompetitionStoring = &state.database_read;
+    handler.load_latest_competition().await.map(Json)
 }
 
 #[cfg(test)]
 mod tests {
     use {
-        super::*,
-        crate::solver_competition::MockSolverCompetitionStoring,
-        warp::{Reply, test::request},
+        crate::solver_competition::LoadSolverCompetitionError,
+        axum::response::IntoResponse,
+        hyper::StatusCode,
     };
 
     #[tokio::test]
-    async fn test() {
-        let mut storage = MockSolverCompetitionStoring::new();
-        storage
-            .expect_load_competition()
-            .times(2)
-            .returning(|_| Ok(Default::default()));
-        storage
-            .expect_load_competition()
-            .times(1)
-            .return_once(|_| Err(LoadSolverCompetitionError::NotFound));
-        let filter = get(Arc::new(storage));
-
-        let request_ = request().path("/v1/solver_competition/0").method("GET");
-        let response = request_.filter(&filter).await.unwrap().into_response();
-        dbg!(&response);
-        assert_eq!(response.status(), StatusCode::OK);
-
-        let request_ = request()
-            .path(
-                "/v1/solver_competition/by_tx_hash/\
-                 0xd51f28edffcaaa76be4a22f6375ad289272c037f3cc072345676e88d92ced8b5",
-            )
-            .method("GET");
-        let response = request_.filter(&filter).await.unwrap().into_response();
-        dbg!(&response);
-        assert_eq!(response.status(), StatusCode::OK);
+    async fn test_response_not_found() {
+        let error = LoadSolverCompetitionError::NotFound;
+        let resp = error.into_response();
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    }
 
-        let request_ = request().path("/v1/solver_competition/1337").method("GET");
-        let response = request_.filter(&filter).await.unwrap().into_response();
-        dbg!(&response);
-        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    #[tokio::test]
+    async fn test_response_internal_error() {
+        let error = LoadSolverCompetitionError::Other(anyhow::anyhow!("test error"));
+        let resp = error.into_response();
+        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 }
diff --git a/crates/orderbook/src/api/get_solver_competition_v2.rs b/crates/orderbook/src/api/get_solver_competition_v2.rs
index 85850a8ec9..1e332c0446 100644
--- a/crates/orderbook/src/api/get_solver_competition_v2.rs
+++ b/crates/orderbook/src/api/get_solver_competition_v2.rs
@@ -1,76 +1,57 @@
 use {
-    crate::{
-        database::Postgres,
-        solver_competition::{Identifier, LoadSolverCompetitionError},
-    },
+    crate::{api::AppState, solver_competition::LoadSolverCompetitionError},
     alloy::primitives::B256,
-    anyhow::Result,
-    model::{AuctionId, solver_competition_v2::Response},
-    reqwest::StatusCode,
-    std::convert::Infallible,
-    warp::{
-        Filter,
-        Rejection,
-        reply::{Json, WithStatus, with_status},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
     },
+    model::{AuctionId, solver_competition_v2::Response as CompetitionResponse},
+    std::{str::FromStr, sync::Arc},
 };
 
-fn request_id() -> impl Filter<Extract = (Identifier,), Error = Rejection> + Clone {
-    warp::path!("v2" / "solver_competition" / AuctionId)
-        .and(warp::get())
-        .map(Identifier::Id)
-}
+pub async fn get_solver_competition_by_id_handler(
+    State(state): State<Arc<AppState>>,
+    Path(auction_id): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(auction_id) = auction_id.parse::<AuctionId>() else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-fn request_hash() -> impl Filter<Extract = (Identifier,), Error = Rejection> + Clone {
-    warp::path!("v2" / "solver_competition" / "by_tx_hash" / B256)
-        .and(warp::get())
-        .map(Identifier::Transaction)
+    state
+        .database_read
+        .load_competition_by_id(auction_id)
+        .await
+        .map(Json)
+        .into_response()
 }
 
-fn request_latest() -> impl Filter<Extract = (), Error = Rejection> + Clone {
-    warp::path!("v2" / "solver_competition" / "latest").and(warp::get())
-}
-
-pub fn get(db: Postgres) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    request_id()
-        .or(request_hash())
-        .unify()
-        .and_then(move |identifier: Identifier| {
-            let db = db.clone();
-            async move {
-                let result = match identifier {
-                    Identifier::Id(id) => db.load_competition_by_id(id).await,
-                    Identifier::Transaction(hash) => db.load_competition_by_tx_hash(hash).await,
-                };
-                Result::<_, Infallible>::Ok(response(result))
-            }
-        })
-}
+pub async fn get_solver_competition_by_hash_handler(
+    State(state): State<Arc<AppState>>,
+    Path(tx_hash): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(tx_hash) = B256::from_str(&tx_hash) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-pub fn get_latest(
-    db: Postgres,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    request_latest().and_then(move || {
-        let db = db.clone();
-        async move {
-            let result = db.load_latest_competition().await;
-            Result::<_, Infallible>::Ok(response(result))
-        }
-    })
+    state
+        .database_read
+        .load_competition_by_tx_hash(tx_hash)
+        .await
+        .map(Json)
+        .into_response()
 }
 
-fn response(
-    result: Result<Response, crate::solver_competition::LoadSolverCompetitionError>,
-) -> WithStatus<Json> {
-    match result {
-        Ok(response) => with_status(warp::reply::json(&response), StatusCode::OK),
-        Err(LoadSolverCompetitionError::NotFound) => with_status(
-            super::error("NotFound", "no competition found"),
-            StatusCode::NOT_FOUND,
-        ),
-        Err(LoadSolverCompetitionError::Other(err)) => {
-            tracing::error!(?err, "load solver competition");
-            crate::api::internal_error_reply()
-        }
-    }
+pub async fn get_solver_competition_latest_handler(
+    State(state): State<Arc<AppState>>,
+) -> Result<Json<CompetitionResponse>, LoadSolverCompetitionError> {
+    state
+        .database_read
+        .load_latest_competition()
+        .await
+        .map(Json)
 }
diff --git a/crates/orderbook/src/api/get_token_metadata.rs b/crates/orderbook/src/api/get_token_metadata.rs
index d8f0631564..04794b61d9 100644
--- a/crates/orderbook/src/api/get_token_metadata.rs
+++ b/crates/orderbook/src/api/get_token_metadata.rs
@@ -1,31 +1,30 @@
 use {
-    crate::database::Postgres,
+    crate::api::AppState,
     alloy::primitives::Address,
-    hyper::StatusCode,
-    std::convert::Infallible,
-    warp::{Filter, Rejection, reply},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    std::{str::FromStr, sync::Arc},
 };
 
-fn get_native_prices_request() -> impl Filter<Extract = (Address,), Error = Rejection> + Clone {
-    warp::path!("v1" / "token" / Address / "metadata").and(warp::get())
-}
-
-pub fn get_token_metadata(
-    db: Postgres,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    get_native_prices_request().and_then(move |token: Address| {
-        let db = db.clone();
-        async move {
-            let result = db.token_metadata(&token).await;
-            let response = match result {
-                Ok(metadata) => reply::with_status(reply::json(&metadata), StatusCode::OK),
-                Err(err) => {
-                    tracing::error!(?err, ?token, "Failed to fetch token's first trade block");
-                    crate::api::internal_error_reply()
-                }
-            };
+pub async fn get_token_metadata_handler(
+    State(state): State<Arc<AppState>>,
+    Path(token): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(token) = Address::from_str(&token) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-            Result::<_, Infallible>::Ok(response)
+    let result = state.database_read.token_metadata(&token).await;
+    match result {
+        Ok(metadata) => Json(metadata).into_response(),
+        Err(err) => {
+            tracing::error!(?err, ?token, "Failed to fetch token's first trade block");
+            crate::api::internal_error_reply()
         }
-    })
+    }
 }
diff --git a/crates/orderbook/src/api/get_total_surplus.rs b/crates/orderbook/src/api/get_total_surplus.rs
index afdbc07b93..143b67b9e8 100644
--- a/crates/orderbook/src/api/get_total_surplus.rs
+++ b/crates/orderbook/src/api/get_total_surplus.rs
@@ -1,30 +1,37 @@
 use {
-    crate::database::Postgres,
+    crate::api::AppState,
     alloy::primitives::Address,
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
     serde_json::json,
-    std::convert::Infallible,
-    warp::{Filter, Rejection, http::StatusCode, reply::with_status},
+    std::{str::FromStr, sync::Arc},
 };
 
-pub fn get(db: Postgres) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    warp::path!("v1" / "users" / Address / "total_surplus")
-        .and(warp::get())
-        .and_then(move |user| {
-            let db = db.clone();
-            async move {
-                let surplus = db.total_surplus(&user).await;
-                Result::<_, Infallible>::Ok(match surplus {
-                    Ok(surplus) => with_status(
-                        warp::reply::json(&json!({
-                            "totalSurplus": surplus.to_string()
-                        })),
-                        StatusCode::OK,
-                    ),
-                    Err(err) => {
-                        tracing::error!(?err, ?user, "failed to compute total surplus");
-                        crate::api::internal_error_reply()
-                    }
-                })
-            }
-        })
+pub async fn get_total_surplus_handler(
+    State(state): State<Arc<AppState>>,
+    Path(user): Path<String>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(user) = Address::from_str(&user) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+
+    let surplus = state.database_read.total_surplus(&user).await;
+    match surplus {
+        Ok(surplus) => (
+            StatusCode::OK,
+            Json(json!({
+                "totalSurplus": surplus.to_string()
+            })),
+        )
+            .into_response(),
+        Err(err) => {
+            tracing::error!(?err, ?user, "failed to compute total surplus");
+            crate::api::internal_error_reply()
+        }
+    }
 }
diff --git a/crates/orderbook/src/api/get_trades.rs b/crates/orderbook/src/api/get_trades.rs
index a104c7cb55..fd8dcaf907 100644
--- a/crates/orderbook/src/api/get_trades.rs
+++ b/crates/orderbook/src/api/get_trades.rs
@@ -1,22 +1,23 @@
 use {
     crate::{
-        api::{ApiReply, error},
-        database::{
-            Postgres,
-            trades::{TradeFilter, TradeRetrieving},
-        },
+        api::{AppState, error},
+        database::trades::{TradeFilter, TradeRetrieving},
     },
     alloy::primitives::Address,
-    anyhow::{Context, Result},
+    anyhow::Context,
+    axum::{
+        extract::{Query, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
     model::order::OrderUid,
     serde::Deserialize,
-    std::convert::Infallible,
-    warp::{Filter, Rejection, hyper::StatusCode, reply::with_status},
+    std::sync::Arc,
 };
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct Query {
+pub(crate) struct QueryParams {
     pub order_uid: Option<OrderUid>,
     pub owner: Option<Address>,
 }
@@ -26,7 +27,7 @@ enum TradeFilterError {
     InvalidFilter(String),
 }
 
-impl Query {
+impl QueryParams {
     fn trade_filter(&self) -> TradeFilter {
         TradeFilter {
             order_uid: self.order_uid,
@@ -44,87 +45,71 @@ impl Query {
     }
 }
 
-fn get_trades_request()
--> impl Filter<Extract = (Result<TradeFilter, TradeFilterError>,), Error = Rejection> + Clone {
-    warp::path!("v1" / "trades")
-        .and(warp::get())
-        .and(warp::query::<Query>())
-        .map(|query: Query| query.validate())
-}
+pub async fn get_trades_handler(
+    State(state): State<Arc<AppState>>,
+    Query(query): Query<QueryParams>,
+) -> Response {
+    let trade_filter = match query.validate() {
+        Ok(trade_filter) => trade_filter,
+        Err(TradeFilterError::InvalidFilter(msg)) => {
+            let err = error("InvalidTradeFilter", msg);
+            return (StatusCode::BAD_REQUEST, err).into_response();
+        }
+    };
 
-pub fn get_trades(db: Postgres) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    get_trades_request().and_then(move |request_result| {
-        let database = db.clone();
-        async move {
-            Result::<_, Infallible>::Ok(match request_result {
-                Ok(trade_filter) => {
-                    let result = database.trades(&trade_filter).await.context("get_trades");
-                    match result {
-                        Ok(reply) => with_status(warp::reply::json(&reply), StatusCode::OK),
-                        Err(err) => {
-                            tracing::error!(?err, "get_trades");
-                            crate::api::internal_error_reply()
-                        }
-                    }
-                }
-                Err(TradeFilterError::InvalidFilter(msg)) => {
-                    let err = error("InvalidTradeFilter", msg);
-                    with_status(err, StatusCode::BAD_REQUEST)
-                }
-            })
+    let result = state
+        .database_read
+        .trades(&trade_filter)
+        .await
+        .context("get_trades");
+    match result {
+        Ok(reply) => Json(reply).into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_trades");
+            crate::api::internal_error_reply()
         }
-    })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        warp::test::{RequestBuilder, request},
-    };
-
-    #[tokio::test]
-    async fn get_trades_request_ok() {
-        let trade_filter = |request: RequestBuilder| async move {
-            let filter = get_trades_request();
-            request.method("GET").filter(&filter).await
-        };
+    use {super::*, alloy::primitives::Address, model::order::OrderUid};
 
+    #[test]
+    fn query_validation_ok() {
         let owner = Address::with_last_byte(1);
-        let owner_path = format!("/v1/trades?owner=0x{owner:x}");
-        let result = trade_filter(request().path(owner_path.as_str()))
-            .await
-            .unwrap()
-            .unwrap();
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: None,
+        };
+        let result = query.validate().unwrap();
         assert_eq!(result.owner, Some(owner));
         assert_eq!(result.order_uid, None);
 
         let uid = OrderUid([1u8; 56]);
-        let order_uid_path = format!("/v1/trades?orderUid={uid}");
-        let result = trade_filter(request().path(order_uid_path.as_str()))
-            .await
-            .unwrap()
-            .unwrap();
+        let query = QueryParams {
+            owner: None,
+            order_uid: Some(uid),
+        };
+        let result = query.validate().unwrap();
         assert_eq!(result.owner, None);
         assert_eq!(result.order_uid, Some(uid));
     }
 
-    #[tokio::test]
-    async fn get_trades_request_err() {
-        let trade_filter = |request: RequestBuilder| async move {
-            let filter = get_trades_request();
-            request.method("GET").filter(&filter).await
-        };
-
+    #[test]
+    fn query_validation_err() {
         let owner = Address::with_last_byte(1);
         let uid = OrderUid([1u8; 56]);
-        let path = format!("/v1/trades?owner=0x{owner:x}&orderUid={uid}");
-
-        let result = trade_filter(request().path(path.as_str())).await.unwrap();
-        assert!(result.is_err());
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: Some(uid),
+        };
+        assert!(query.validate().is_err());
 
-        let path = "/v1/trades";
-        let result = trade_filter(request().path(path)).await.unwrap();
-        assert!(result.is_err());
+        let query = QueryParams {
+            owner: None,
+            order_uid: None,
+        };
+        assert!(query.validate().is_err());
     }
 }
diff --git a/crates/orderbook/src/api/get_trades_v2.rs b/crates/orderbook/src/api/get_trades_v2.rs
index a570ccf3a5..b3c1073849 100644
--- a/crates/orderbook/src/api/get_trades_v2.rs
+++ b/crates/orderbook/src/api/get_trades_v2.rs
@@ -1,22 +1,23 @@
 use {
     crate::{
-        api::{ApiReply, error},
-        database::{
-            Postgres,
-            trades::{PaginatedTradeFilter, TradeRetrievingPaginated},
-        },
+        api::{AppState, error},
+        database::trades::{PaginatedTradeFilter, TradeRetrievingPaginated},
     },
     alloy::primitives::Address,
-    anyhow::{Context, Result},
+    anyhow::Context,
+    axum::{
+        extract::{Query, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
     model::order::OrderUid,
     serde::Deserialize,
-    std::convert::Infallible,
-    warp::{Filter, Rejection, hyper::StatusCode, reply::with_status},
+    std::sync::Arc,
 };
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct Query {
+pub(crate) struct QueryParams {
     pub order_uid: Option<OrderUid>,
     pub owner: Option<Address>,
     pub offset: Option<u64>,
@@ -34,7 +35,7 @@ enum TradeFilterError {
     InvalidLimit(u64, u64),
 }
 
-impl Query {
+impl QueryParams {
     fn trade_filter(&self, offset: u64, limit: u64) -> PaginatedTradeFilter {
         PaginatedTradeFilter {
             order_uid: self.order_uid,
@@ -63,126 +64,124 @@ impl Query {
     }
 }
 
-fn get_trades_request()
--> impl Filter<Extract = (Result<PaginatedTradeFilter, TradeFilterError>,), Error = Rejection> + Clone
-{
-    warp::path!("v2" / "trades")
-        .and(warp::get())
-        .and(warp::query::<Query>())
-        .map(|query: Query| query.validate())
-}
+pub async fn get_trades_handler(
+    State(state): State<Arc<AppState>>,
+    Query(query): Query<QueryParams>,
+) -> Response {
+    let trade_filter = match query.validate() {
+        Ok(trade_filter) => trade_filter,
+        Err(TradeFilterError::InvalidFilter(msg)) => {
+            let err = error("InvalidTradeFilter", msg);
+            return (StatusCode::BAD_REQUEST, err).into_response();
+        }
+        Err(TradeFilterError::InvalidLimit(min, max)) => {
+            let err = error(
+                "InvalidLimit",
+                format!("limit must be between {min} and {max}"),
+            );
+            return (StatusCode::BAD_REQUEST, err).into_response();
+        }
+    };
 
-pub fn get_trades(db: Postgres) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    get_trades_request().and_then(move |request_result| {
-        let database = db.clone();
-        async move {
-            Result::<_, Infallible>::Ok(match request_result {
-                Ok(trade_filter) => {
-                    let result = database
-                        .trades_paginated(&trade_filter)
-                        .await
-                        .context("get_trades_v2");
-                    match result {
-                        Ok(reply) => with_status(warp::reply::json(&reply), StatusCode::OK),
-                        Err(err) => {
-                            tracing::error!(?err, "get_trades_v2");
-                            crate::api::internal_error_reply()
-                        }
-                    }
-                }
-                Err(TradeFilterError::InvalidFilter(msg)) => {
-                    let err = error("InvalidTradeFilter", msg);
-                    with_status(err, StatusCode::BAD_REQUEST)
-                }
-                Err(TradeFilterError::InvalidLimit(min, max)) => {
-                    let err = error(
-                        "InvalidLimit",
-                        format!("limit must be between {min} and {max}"),
-                    );
-                    with_status(err, StatusCode::BAD_REQUEST)
-                }
-            })
+    let result = state
+        .database_read
+        .trades_paginated(&trade_filter)
+        .await
+        .context("get_trades_v2");
+    match result {
+        Ok(reply) => (StatusCode::OK, Json(reply)).into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_trades_v2");
+            crate::api::internal_error_reply()
         }
-    })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        warp::test::{RequestBuilder, request},
-    };
-
-    #[tokio::test]
-    async fn get_trades_request_ok() {
-        let trade_filter = |request: RequestBuilder| async move {
-            let filter = get_trades_request();
-            request.method("GET").filter(&filter).await
-        };
+    use {super::*, alloy::primitives::Address, model::order::OrderUid};
 
+    #[test]
+    fn query_validation_ok() {
         let owner = Address::with_last_byte(1);
-        let owner_path = format!("/v2/trades?owner=0x{owner:x}");
-        let result = trade_filter(request().path(owner_path.as_str()))
-            .await
-            .unwrap()
-            .unwrap();
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: None,
+            offset: None,
+            limit: None,
+        };
+        let result = query.validate().unwrap();
         assert_eq!(result.owner, Some(owner));
         assert_eq!(result.order_uid, None);
         assert_eq!(result.offset, DEFAULT_OFFSET);
         assert_eq!(result.limit, DEFAULT_LIMIT);
 
         let uid = OrderUid([1u8; 56]);
-        let order_uid_path = format!("/v2/trades?orderUid={uid}");
-        let result = trade_filter(request().path(order_uid_path.as_str()))
-            .await
-            .unwrap()
-            .unwrap();
+        let query = QueryParams {
+            owner: None,
+            order_uid: Some(uid),
+            offset: None,
+            limit: None,
+        };
+        let result = query.validate().unwrap();
         assert_eq!(result.owner, None);
         assert_eq!(result.order_uid, Some(uid));
         assert_eq!(result.offset, DEFAULT_OFFSET);
         assert_eq!(result.limit, DEFAULT_LIMIT);
 
         // Test with custom offset and limit
-        let owner_path = format!("/v2/trades?owner=0x{owner:x}&offset=10&limit=50");
-        let result = trade_filter(request().path(owner_path.as_str()))
-            .await
-            .unwrap()
-            .unwrap();
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: None,
+            offset: Some(10),
+            limit: Some(50),
+        };
+        let result = query.validate().unwrap();
         assert_eq!(result.owner, Some(owner));
         assert_eq!(result.offset, 10);
         assert_eq!(result.limit, 50);
     }
 
-    #[tokio::test]
-    async fn get_trades_request_err() {
-        let trade_filter = |request: RequestBuilder| async move {
-            let filter = get_trades_request();
-            request.method("GET").filter(&filter).await
-        };
-
+    #[test]
+    fn query_validation_err() {
         let owner = Address::with_last_byte(1);
         let uid = OrderUid([1u8; 56]);
-        let path = format!("/v2/trades?owner=0x{owner:x}&orderUid={uid}");
-
-        let result = trade_filter(request().path(path.as_str())).await.unwrap();
-        assert!(result.is_err());
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: Some(uid),
+            offset: None,
+            limit: None,
+        };
+        assert!(query.validate().is_err());
 
-        let path = "/v2/trades";
-        let result = trade_filter(request().path(path)).await.unwrap();
-        assert!(result.is_err());
+        let query = QueryParams {
+            owner: None,
+            order_uid: None,
+            offset: None,
+            limit: None,
+        };
+        assert!(query.validate().is_err());
 
         // Test limit validation
-        let path = format!("/v2/trades?owner=0x{owner:x}&limit=0");
-        let result = trade_filter(request().path(path.as_str())).await.unwrap();
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: None,
+            offset: None,
+            limit: Some(0),
+        };
         assert!(matches!(
-            result,
+            query.validate(),
             Err(TradeFilterError::InvalidLimit(MIN_LIMIT, MAX_LIMIT))
         ));
 
-        let path = format!("/v2/trades?owner=0x{owner:x}&limit=1001");
-        let result = trade_filter(request().path(path.as_str())).await.unwrap();
+        let query = QueryParams {
+            owner: Some(owner),
+            order_uid: None,
+            offset: None,
+            limit: Some(1001),
+        };
         assert!(matches!(
-            result,
+            query.validate(),
             Err(TradeFilterError::InvalidLimit(MIN_LIMIT, MAX_LIMIT))
         ));
     }
diff --git a/crates/orderbook/src/api/get_user_orders.rs b/crates/orderbook/src/api/get_user_orders.rs
index 77783b29bf..07daef1352 100644
--- a/crates/orderbook/src/api/get_user_orders.rs
+++ b/crates/orderbook/src/api/get_user_orders.rs
@@ -1,82 +1,57 @@
 use {
-    crate::{api::ApiReply, orderbook::Orderbook},
+    crate::api::AppState,
     alloy::primitives::Address,
-    anyhow::Result,
+    axum::{
+        extract::{Path, Query, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
     serde::Deserialize,
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, hyper::StatusCode, reply::with_status},
+    std::{str::FromStr, sync::Arc},
 };
 
 #[derive(Clone, Copy, Debug, Deserialize)]
-struct Query {
+pub(crate) struct QueryParams {
     offset: Option<u64>,
     limit: Option<u64>,
 }
 
-fn request() -> impl Filter<Extract = (Address, Query), Error = Rejection> + Clone {
-    warp::path!("v1" / "account" / Address / "orders")
-        .and(warp::get())
-        .and(warp::query::<Query>())
-}
+pub async fn get_user_orders_handler(
+    State(state): State<Arc<AppState>>,
+    Path(owner): Path<String>,
+    Query(query): Query<QueryParams>,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(owner) = Address::from_str(&owner) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
 
-pub fn get_user_orders(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    request().and_then(move |owner: Address, query: Query| {
-        let orderbook = orderbook.clone();
-        async move {
-            const DEFAULT_OFFSET: u64 = 0;
-            const DEFAULT_LIMIT: u64 = 10;
-            const MIN_LIMIT: u64 = 1;
-            const MAX_LIMIT: u64 = 1000;
-            let offset = query.offset.unwrap_or(DEFAULT_OFFSET);
-            let limit = query.limit.unwrap_or(DEFAULT_LIMIT);
-            if !(MIN_LIMIT..=MAX_LIMIT).contains(&limit) {
-                return Ok(with_status(
-                    super::error(
-                        "LIMIT_OUT_OF_BOUNDS",
-                        format!("The pagination limit is [{MIN_LIMIT},{MAX_LIMIT}]."),
-                    ),
-                    StatusCode::BAD_REQUEST,
-                ));
-            }
-            let result = orderbook.get_user_orders(&owner, offset, limit).await;
-            Result::<_, Infallible>::Ok(match result {
-                Ok(reply) => with_status(warp::reply::json(&reply), StatusCode::OK),
-                Err(err) => {
-                    tracing::error!(?err, "get_user_orders");
-                    crate::api::internal_error_reply()
-                }
-            })
-        }
-    })
-}
+    const DEFAULT_OFFSET: u64 = 0;
+    const DEFAULT_LIMIT: u64 = 10;
+    const MIN_LIMIT: u64 = 1;
+    const MAX_LIMIT: u64 = 1000;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+    let offset = query.offset.unwrap_or(DEFAULT_OFFSET);
+    let limit = query.limit.unwrap_or(DEFAULT_LIMIT);
 
-    #[tokio::test]
-    async fn request_() {
-        let path = "/v1/account/0x0000000000000000000000000000000000000001/orders";
-        let result = warp::test::request()
-            .path(path)
-            .method("GET")
-            .filter(&request())
-            .await
-            .unwrap();
-        assert_eq!(result.0, Address::with_last_byte(1));
-        assert_eq!(result.1.offset, None);
-        assert_eq!(result.1.limit, None);
+    if !(MIN_LIMIT..=MAX_LIMIT).contains(&limit) {
+        return (
+            StatusCode::BAD_REQUEST,
+            super::error(
+                "LIMIT_OUT_OF_BOUNDS",
+                format!("The pagination limit is [{MIN_LIMIT},{MAX_LIMIT}]."),
+            ),
+        )
+            .into_response();
+    }
 
-        let path = "/v1/account/0x0000000000000000000000000000000000000001/orders?offset=1&limit=2";
-        let result = warp::test::request()
-            .path(path)
-            .method("GET")
-            .filter(&request())
-            .await
-            .unwrap();
-        assert_eq!(result.1.offset, Some(1));
-        assert_eq!(result.1.limit, Some(2));
+    let result = state.orderbook.get_user_orders(&owner, offset, limit).await;
+    match result {
+        Ok(reply) => (StatusCode::OK, Json(reply)).into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_user_orders");
+            crate::api::internal_error_reply()
+        }
     }
 }
diff --git a/crates/orderbook/src/api/post_order.rs b/crates/orderbook/src/api/post_order.rs
index 7a57ac4ed4..8e2bfea75e 100644
--- a/crates/orderbook/src/api/post_order.rs
+++ b/crates/orderbook/src/api/post_order.rs
@@ -1,12 +1,17 @@
 use {
     crate::{
-        api::{ApiReply, IntoWarpReply, error, extract_payload},
-        orderbook::{AddOrderError, OrderReplacementError, Orderbook},
+        api::{AppState, error},
+        orderbook::{AddOrderError, OrderReplacementError},
+    },
+    axum::{
+        Json,
+        body,
+        extract::State,
+        http::StatusCode,
+        response::{IntoResponse, Response},
     },
-    anyhow::Result,
     model::{
-        order::{AppdataFromMismatch, OrderCreation, OrderUid},
-        quote::QuoteId,
+        order::{AppdataFromMismatch, OrderCreation},
         signature,
     },
     shared::order_validation::{
@@ -15,77 +20,97 @@ use {
         PartialValidationError,
         ValidationError,
     },
-    std::{convert::Infallible, sync::Arc},
-    warp::{
-        Filter,
-        Rejection,
-        hyper::StatusCode,
-        reply::{self, with_status},
-    },
+    std::sync::Arc,
 };
 
-pub fn create_order_request() -> impl Filter<Extract = (OrderCreation,), Error = Rejection> + Clone
-{
-    warp::path!("v1" / "orders")
-        .and(warp::post())
-        .and(extract_payload())
+pub async fn post_order_handler(State(state): State<Arc<AppState>>, body: body::Bytes) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let order = match serde_json::from_slice::<OrderCreation>(&body) {
+        Ok(order) => order,
+        Err(err) => return (StatusCode::BAD_REQUEST, err.to_string()).into_response(),
+    };
+
+    state
+        .orderbook
+        .add_order(order.clone())
+        .await
+        .map(|(order_uid, quote_metadata)| {
+            let quote_id = quote_metadata.as_ref().and_then(|q| q.id);
+            let quote_solver = quote_metadata.as_ref().map(|q| q.solver);
+            tracing::debug!(%order_uid, ?quote_id, ?quote_solver, "order created");
+            (StatusCode::CREATED, Json(order_uid))
+        })
+        .inspect_err(|err| {
+            tracing::debug!(?order, ?err, "error creating order");
+        })
+        .into_response()
 }
 
 pub struct PartialValidationErrorWrapper(pub PartialValidationError);
-impl IntoWarpReply for PartialValidationErrorWrapper {
-    fn into_warp_reply(self) -> ApiReply {
+impl IntoResponse for PartialValidationErrorWrapper {
+    fn into_response(self) -> Response {
         match self.0 {
-            PartialValidationError::UnsupportedBuyTokenDestination(dest) => with_status(
+            PartialValidationError::UnsupportedBuyTokenDestination(dest) => (
+                StatusCode::BAD_REQUEST,
                 error("UnsupportedBuyTokenDestination", format!("Type {dest:?}")),
+            )
+                .into_response(),
+            PartialValidationError::UnsupportedSellTokenSource(src) => (
                 StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::UnsupportedSellTokenSource(src) => with_status(
                 error("UnsupportedSellTokenSource", format!("Type {src:?}")),
+            )
+                .into_response(),
+            PartialValidationError::UnsupportedOrderType => (
                 StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::UnsupportedOrderType => with_status(
                 error(
                     "UnsupportedOrderType",
                     "This order type is currently not supported",
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::Forbidden => with_status(
-                error("Forbidden", "Forbidden, your account is deny-listed"),
+            )
+                .into_response(),
+            PartialValidationError::Forbidden => (
                 StatusCode::FORBIDDEN,
-            ),
-            PartialValidationError::ValidTo(OrderValidToError::Insufficient) => with_status(
+                error("Forbidden", "Forbidden, your account is deny-listed"),
+            )
+                .into_response(),
+            PartialValidationError::ValidTo(OrderValidToError::Insufficient) => (
+                StatusCode::BAD_REQUEST,
                 error(
                     "InsufficientValidTo",
                     "validTo is not far enough in the future",
                 ),
+            )
+                .into_response(),
+            PartialValidationError::ValidTo(OrderValidToError::Excessive) => (
                 StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::ValidTo(OrderValidToError::Excessive) => with_status(
                 error("ExcessiveValidTo", "validTo is too far into the future"),
+            )
+                .into_response(),
+            PartialValidationError::InvalidNativeSellToken => (
                 StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::InvalidNativeSellToken => with_status(
                 error(
                     "InvalidNativeSellToken",
                     "The chain's native token (Ether/xDai) cannot be used as the sell token",
                 ),
+            )
+                .into_response(),
+            PartialValidationError::SameBuyAndSellToken => (
                 StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::SameBuyAndSellToken => with_status(
                 error(
                     "SameBuyAndSellToken",
                     "Buy token is the same as the sell token.",
                 ),
+            )
+                .into_response(),
+            PartialValidationError::UnsupportedToken { token, reason } => (
                 StatusCode::BAD_REQUEST,
-            ),
-            PartialValidationError::UnsupportedToken { token, reason } => with_status(
                 error(
                     "UnsupportedToken",
                     format!("Token {token:?} is unsupported: {reason}"),
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
             PartialValidationError::Other(err) => {
                 tracing::error!(?err, "PartialValidatonError");
                 crate::api::internal_error_reply()
@@ -95,14 +120,16 @@ impl IntoWarpReply for PartialValidationErrorWrapper {
 }
 
 pub struct AppDataValidationErrorWrapper(pub AppDataValidationError);
-impl IntoWarpReply for AppDataValidationErrorWrapper {
-    fn into_warp_reply(self) -> ApiReply {
+impl IntoResponse for AppDataValidationErrorWrapper {
+    fn into_response(self) -> Response {
         match self.0 {
-            AppDataValidationError::Invalid(err) => with_status(
+            AppDataValidationError::Invalid(err) => (
+                StatusCode::BAD_REQUEST,
                 error("InvalidAppData", format!("{err:?}")),
+            )
+                .into_response(),
+            AppDataValidationError::Mismatch { provided, actual } => (
                 StatusCode::BAD_REQUEST,
-            ),
-            AppDataValidationError::Mismatch { provided, actual } => with_status(
                 error(
                     "AppDataHashMismatch",
                     format!(
@@ -110,30 +137,34 @@ impl IntoWarpReply for AppDataValidationErrorWrapper {
                          {provided:?}",
                     ),
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
         }
     }
 }
 
 pub struct ValidationErrorWrapper(ValidationError);
-impl IntoWarpReply for ValidationErrorWrapper {
-    fn into_warp_reply(self) -> ApiReply {
+impl IntoResponse for ValidationErrorWrapper {
+    fn into_response(self) -> Response {
         match self.0 {
-            ValidationError::Partial(pre) => PartialValidationErrorWrapper(pre).into_warp_reply(),
-            ValidationError::AppData(err) => AppDataValidationErrorWrapper(err).into_warp_reply(),
-            ValidationError::PriceForQuote(err) => err.into_warp_reply(),
-            ValidationError::MissingFrom => with_status(
+            ValidationError::Partial(pre) => PartialValidationErrorWrapper(pre).into_response(),
+            ValidationError::AppData(err) => AppDataValidationErrorWrapper(err).into_response(),
+            ValidationError::PriceForQuote(err) => {
+                super::PriceEstimationErrorWrapper(err).into_response()
+            }
+            ValidationError::MissingFrom => (
+                StatusCode::BAD_REQUEST,
                 error(
                     "MissingFrom",
                     "From address must be specified for on-chain signature",
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
             ValidationError::AppdataFromMismatch(AppdataFromMismatch {
                 from,
                 app_data_signer,
-            }) => with_status(
+            }) => (
+                StatusCode::BAD_REQUEST,
                 error(
                     "AppdataFromMismatch",
                     format!(
@@ -141,9 +172,10 @@ impl IntoWarpReply for ValidationErrorWrapper {
                          {app_data_signer:?} specified in the app data"
                     ),
                 ),
+            )
+                .into_response(),
+            ValidationError::WrongOwner(signature::Recovered { message, signer }) => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::WrongOwner(signature::Recovered { message, signer }) => with_status(
                 error(
                     "WrongOwner",
                     format!(
@@ -151,78 +183,90 @@ impl IntoWarpReply for ValidationErrorWrapper {
                          from address"
                     ),
                 ),
+            )
+                .into_response(),
+            ValidationError::InvalidEip1271Signature(hash) => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::InvalidEip1271Signature(hash) => with_status(
                 error(
                     "InvalidEip1271Signature",
                     format!("signature for computed order hash {hash:?} is not valid"),
                 ),
+            )
+                .into_response(),
+            ValidationError::InsufficientBalance => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::InsufficientBalance => with_status(
                 error(
                     "InsufficientBalance",
                     "order owner must have funds worth at least x in his account",
                 ),
+            )
+                .into_response(),
+            ValidationError::InsufficientAllowance => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::InsufficientAllowance => with_status(
                 error(
                     "InsufficientAllowance",
                     "order owner must give allowance to VaultRelayer",
                 ),
+            )
+                .into_response(),
+            ValidationError::InvalidSignature => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::InvalidSignature => with_status(
                 error("InvalidSignature", "invalid signature"),
+            )
+                .into_response(),
+            ValidationError::NonZeroFee => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::NonZeroFee => with_status(
                 error("NonZeroFee", "Fee must be zero"),
-                StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::SellAmountOverflow => with_status(
+            )
+                .into_response(),
+            ValidationError::SellAmountOverflow => (
+                StatusCode::INTERNAL_SERVER_ERROR,
                 error(
                     "SellAmountOverflow",
                     "Sell amount + fee amount must fit in U256",
                 ),
-                StatusCode::INTERNAL_SERVER_ERROR,
-            ),
-            ValidationError::TransferSimulationFailed => with_status(
+            )
+                .into_response(),
+            ValidationError::TransferSimulationFailed => (
+                StatusCode::BAD_REQUEST,
                 error(
                     "TransferSimulationFailed",
                     "sell token cannot be transferred",
                 ),
+            )
+                .into_response(),
+            ValidationError::QuoteNotVerified => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::QuoteNotVerified => with_status(
                 error(
                     "QuoteNotVerified",
                     "No quote for this trade could be verified to be accurate. Aborting the order \
                      creation since it will likely not be executed.",
                 ),
+            )
+                .into_response(),
+            ValidationError::ZeroAmount => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::ZeroAmount => with_status(
                 error("ZeroAmount", "Buy or sell amount is zero."),
+            )
+                .into_response(),
+            ValidationError::IncompatibleSigningScheme => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::IncompatibleSigningScheme => with_status(
                 error(
                     "IncompatibleSigningScheme",
                     "Signing scheme is not compatible with order placement method.",
                 ),
+            )
+                .into_response(),
+            ValidationError::TooManyLimitOrders => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::TooManyLimitOrders => with_status(
                 error("TooManyLimitOrders", "Too many limit orders"),
+            )
+                .into_response(),
+            ValidationError::TooMuchGas => (
                 StatusCode::BAD_REQUEST,
-            ),
-            ValidationError::TooMuchGas => with_status(
                 error("TooMuchGas", "Executing order requires too many gas units"),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
 
             ValidationError::Other(err) => {
                 tracing::error!(?err, "ValidationErrorWrapper");
@@ -232,14 +276,15 @@ impl IntoWarpReply for ValidationErrorWrapper {
     }
 }
 
-impl IntoWarpReply for AddOrderError {
-    fn into_warp_reply(self) -> ApiReply {
+impl IntoResponse for AddOrderError {
+    fn into_response(self) -> Response {
         match self {
-            Self::OrderValidation(err) => ValidationErrorWrapper(err).into_warp_reply(),
-            Self::DuplicatedOrder => with_status(
-                error("DuplicatedOrder", "order already exists"),
+            Self::OrderValidation(err) => ValidationErrorWrapper(err).into_response(),
+            Self::DuplicatedOrder => (
                 StatusCode::BAD_REQUEST,
-            ),
+                error("DuplicatedOrder", "order already exists"),
+            )
+                .into_response(),
             Self::Database(err) => {
                 tracing::error!(?err, "AddOrderError");
                 crate::api::internal_error_reply()
@@ -253,38 +298,43 @@ impl IntoWarpReply for AddOrderError {
                 );
                 crate::api::internal_error_reply()
             }
-            AddOrderError::OrderNotFound(err) => err.into_warp_reply(),
-            AddOrderError::InvalidAppData(err) => reply::with_status(
-                super::error("InvalidAppData", err.to_string()),
+            AddOrderError::OrderNotFound(err) => err.into_response(),
+            AddOrderError::InvalidAppData(err) => (
                 StatusCode::BAD_REQUEST,
-            ),
-            AddOrderError::InvalidReplacement(err) => err.into_warp_reply(),
-            AddOrderError::MetadataSerializationFailed(err) => reply::with_status(
-                super::error("MetadataSerializationFailed", err.to_string()),
+                super::error("InvalidAppData", err.to_string()),
+            )
+                .into_response(),
+            AddOrderError::InvalidReplacement(err) => err.into_response(),
+            AddOrderError::MetadataSerializationFailed(err) => (
                 StatusCode::INTERNAL_SERVER_ERROR,
-            ),
+                super::error("MetadataSerializationFailed", err.to_string()),
+            )
+                .into_response(),
         }
     }
 }
 
-impl IntoWarpReply for OrderReplacementError {
-    fn into_warp_reply(self) -> super::ApiReply {
+impl IntoResponse for OrderReplacementError {
+    fn into_response(self) -> Response {
         match self {
-            OrderReplacementError::InvalidSignature => with_status(
-                super::error("InvalidSignature", "Malformed signature"),
+            OrderReplacementError::InvalidSignature => (
                 StatusCode::BAD_REQUEST,
-            ),
-            OrderReplacementError::WrongOwner => with_status(
-                super::error("WrongOwner", "Old and new orders have different signers"),
+                super::error("InvalidSignature", "Malformed signature"),
+            )
+                .into_response(),
+            OrderReplacementError::WrongOwner => (
                 StatusCode::UNAUTHORIZED,
-            ),
-            OrderReplacementError::OldOrderActivelyBidOn => with_status(
+                super::error("WrongOwner", "Old and new orders have different signers"),
+            )
+                .into_response(),
+            OrderReplacementError::OldOrderActivelyBidOn => (
+                StatusCode::BAD_REQUEST,
                 super::error(
                     "OldOrderActivelyBidOn",
                     "The old order is actively beign bid on in recent auctions",
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
             OrderReplacementError::Other(err) => {
                 tracing::error!(?err, "replace_order");
                 crate::api::internal_error_reply()
@@ -293,70 +343,20 @@ impl IntoWarpReply for OrderReplacementError {
     }
 }
 
-pub fn create_order_response(
-    result: Result<(OrderUid, Option<QuoteId>), AddOrderError>,
-) -> ApiReply {
-    match result {
-        Ok((uid, _)) => with_status(warp::reply::json(&uid), StatusCode::CREATED),
-        Err(err) => err.into_warp_reply(),
-    }
-}
-
-pub fn post_order(
-    orderbook: Arc<Orderbook>,
-) -> impl Filter<Extract = (ApiReply,), Error = Rejection> + Clone {
-    create_order_request().and_then(move |order: OrderCreation| {
-        let orderbook = orderbook.clone();
-        async move {
-            let result = orderbook
-                .add_order(order.clone())
-                .await
-                .map(|(order_uid, quote_metadata)| {
-                    let quote_id = quote_metadata.as_ref().and_then(|q| q.id);
-                    let quote_solver = quote_metadata.as_ref().map(|q| q.solver);
-                    tracing::debug!(%order_uid, ?quote_id, ?quote_solver, "order created");
-                    (order_uid, quote_metadata.and_then(|quote| quote.id))
-                })
-                .inspect_err(|err| {
-                    tracing::debug!(?order, ?err, "error creating order");
-                });
-
-            Result::<_, Infallible>::Ok(create_order_response(result))
-        }
-    })
-}
-
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::api::response_body,
-        model::order::{OrderCreation, OrderUid},
-        serde_json::json,
-        warp::{Reply, test::request},
-    };
+    use {super::*, crate::api::response_body, model::order::OrderUid, serde_json::json};
 
-    #[tokio::test]
-    async fn create_order_request_ok() {
-        let filter = create_order_request();
-        let order_payload = OrderCreation::default();
-        let request = request()
-            .path("/v1/orders")
-            .method("POST")
-            .header("content-type", "application/json")
-            .json(&order_payload);
-        let result = request.filter(&filter).await.unwrap();
-        assert_eq!(result, order_payload);
-    }
+    type Result = std::result::Result<(StatusCode, Json<OrderUid>), AddOrderError>;
 
     #[tokio::test]
     async fn create_order_response_created() {
         let uid = OrderUid([1u8; 56]);
-        let response = create_order_response(Ok((uid, Some(42)))).into_response();
+        let response = Result::Ok((StatusCode::CREATED, Json(uid))).into_response();
         assert_eq!(response.status(), StatusCode::CREATED);
         let body = response_body(response).await;
         let body: serde_json::Value = serde_json::from_slice(body.as_slice()).unwrap();
-        let expected= json!(
+        let expected = json!(
             "0x0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
         );
         assert_eq!(body, expected);
@@ -364,7 +364,7 @@ mod tests {
 
     #[tokio::test]
     async fn create_order_response_duplicate() {
-        let response = create_order_response(Err(AddOrderError::DuplicatedOrder)).into_response();
+        let response = Result::Err(AddOrderError::DuplicatedOrder).into_response();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
         let body = response_body(response).await;
         let body: serde_json::Value = serde_json::from_slice(body.as_slice()).unwrap();
diff --git a/crates/orderbook/src/api/post_quote.rs b/crates/orderbook/src/api/post_quote.rs
index 57cc81c680..90febb2575 100644
--- a/crates/orderbook/src/api/post_quote.rs
+++ b/crates/orderbook/src/api/post_quote.rs
@@ -1,80 +1,72 @@
 use {
     super::post_order::{AppDataValidationErrorWrapper, PartialValidationErrorWrapper},
     crate::{
-        api::{self, ApiReply, IntoWarpReply, convert_json_response, error, rich_error},
-        quoter::{OrderQuoteError, QuoteHandler},
+        api::{AppState, error, rich_error},
+        quoter::OrderQuoteError,
+    },
+    axum::{
+        Json,
+        body,
+        extract::State,
+        response::{IntoResponse, Response},
     },
-    anyhow::Result,
     model::quote::OrderQuoteRequest,
     reqwest::StatusCode,
     shared::order_quoting::CalculateQuoteError,
-    std::{convert::Infallible, sync::Arc},
-    thiserror::Error,
-    warp::{Filter, Rejection},
+    std::sync::Arc,
 };
 
-fn post_quote_request() -> impl Filter<Extract = (OrderQuoteRequest,), Error = Rejection> + Clone {
-    warp::path!("v1" / "quote")
-        .and(warp::post())
-        .and(api::extract_payload())
-}
+pub async fn post_quote_handler(State(state): State<Arc<AppState>>, body: body::Bytes) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(request) = serde_json::from_slice::<OrderQuoteRequest>(&body) else {
+        return StatusCode::BAD_REQUEST.into_response();
+    };
 
-pub fn post_quote(
-    quotes: Arc<QuoteHandler>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    post_quote_request().and_then(move |request: OrderQuoteRequest| {
-        let quotes = quotes.clone();
-        async move {
-            let result = quotes
-                .calculate_quote(&request)
-                .await
-                .map_err(OrderQuoteErrorWrapper);
-            if let Err(err) = &result {
-                tracing::warn!(%err, ?request, "post_quote error");
-            }
-            Result::<_, Infallible>::Ok(convert_json_response(result))
-        }
-    })
+    state
+        .quotes
+        .calculate_quote(&request)
+        .await
+        .map(Json)
+        .inspect_err(|err| tracing::warn!(%err, ?request, "post_quote error"))
+        .into_response()
 }
 
-#[derive(Debug, Error)]
-#[error(transparent)]
-pub struct OrderQuoteErrorWrapper(pub OrderQuoteError);
-impl IntoWarpReply for OrderQuoteErrorWrapper {
-    fn into_warp_reply(self) -> ApiReply {
-        match self.0 {
-            OrderQuoteError::AppData(err) => AppDataValidationErrorWrapper(err).into_warp_reply(),
-            OrderQuoteError::Order(err) => PartialValidationErrorWrapper(err).into_warp_reply(),
-            OrderQuoteError::CalculateQuote(err) => {
-                CalculateQuoteErrorWrapper(err).into_warp_reply()
-            }
+impl IntoResponse for OrderQuoteError {
+    fn into_response(self) -> Response {
+        match self {
+            OrderQuoteError::AppData(err) => AppDataValidationErrorWrapper(err).into_response(),
+            OrderQuoteError::Order(err) => PartialValidationErrorWrapper(err).into_response(),
+            OrderQuoteError::CalculateQuote(err) => CalculateQuoteErrorWrapper(err).into_response(),
         }
     }
 }
 
 pub struct CalculateQuoteErrorWrapper(CalculateQuoteError);
-impl IntoWarpReply for CalculateQuoteErrorWrapper {
-    fn into_warp_reply(self) -> ApiReply {
+impl IntoResponse for CalculateQuoteErrorWrapper {
+    fn into_response(self) -> Response {
         match self.0 {
-            CalculateQuoteError::Price { source, .. } => source.into_warp_reply(),
-            CalculateQuoteError::SellAmountDoesNotCoverFee { fee_amount } => {
-                warp::reply::with_status(
-                    rich_error(
-                        "SellAmountDoesNotCoverFee",
-                        "The sell amount for the sell order is lower than the fee.",
-                        serde_json::json!({ "fee_amount": fee_amount }),
-                    ),
-                    StatusCode::BAD_REQUEST,
-                )
+            CalculateQuoteError::Price { source, .. } => {
+                super::PriceEstimationErrorWrapper(source).into_response()
             }
-            CalculateQuoteError::QuoteNotVerified => warp::reply::with_status(
+            CalculateQuoteError::SellAmountDoesNotCoverFee { fee_amount } => (
+                StatusCode::BAD_REQUEST,
+                rich_error(
+                    "SellAmountDoesNotCoverFee",
+                    "The sell amount for the sell order is lower than the fee.",
+                    serde_json::json!({ "fee_amount": fee_amount }),
+                ),
+            )
+                .into_response(),
+            CalculateQuoteError::QuoteNotVerified => (
+                StatusCode::BAD_REQUEST,
                 error(
                     "QuoteNotVerified",
                     "No quote for this trade could be verified to be accurate. Orders for this \
                      trade will likely not be executed.",
                 ),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
             CalculateQuoteError::Other(err) => {
                 tracing::error!(?err, "CalculateQuoteErrorWrapper");
                 crate::api::internal_error_reply()
@@ -110,7 +102,6 @@ mod tests {
         serde_json::json,
         shared::order_quoting::CalculateQuoteError,
         std::{str::FromStr, time::Duration},
-        warp::{Reply, test::request},
     };
 
     #[test]
@@ -270,32 +261,6 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn post_quote_request_ok() {
-        let filter = post_quote_request();
-        let request_payload = OrderQuoteRequest::default();
-        let request = request()
-            .path("/v1/quote")
-            .method("POST")
-            .header("content-type", "application/json")
-            .json(&request_payload);
-        let result = request.filter(&filter).await.unwrap();
-        assert_eq!(result, request_payload);
-    }
-
-    #[tokio::test]
-    async fn post_quote_request_err() {
-        let filter = post_quote_request();
-        let request_payload = OrderQuoteRequest::default();
-        // Path is wrong!
-        let request = request()
-            .path("/v1/fee_quote")
-            .method("POST")
-            .header("content-type", "application/json")
-            .json(&request_payload);
-        assert!(request.filter(&filter).await.is_err());
-    }
-
     #[tokio::test]
     async fn post_quote_response_ok() {
         let quote = OrderQuote {
@@ -324,10 +289,7 @@ mod tests {
             verified: false,
             protocol_fee_bps: Some("2".to_string()),
         };
-        let response = convert_json_response::<OrderQuoteResponse, OrderQuoteErrorWrapper>(Ok(
-            order_quote_response.clone(),
-        ))
-        .into_response();
+        let response = (StatusCode::OK, Json(order_quote_response.clone())).into_response();
         assert_eq!(response.status(), StatusCode::OK);
         let body = response_body(response).await;
         let body: serde_json::Value = serde_json::from_slice(body.as_slice()).unwrap();
@@ -337,12 +299,9 @@ mod tests {
 
     #[tokio::test]
     async fn post_quote_response_err() {
-        let response = convert_json_response::<OrderQuoteResponse, OrderQuoteErrorWrapper>(Err(
-            OrderQuoteErrorWrapper(OrderQuoteError::CalculateQuote(CalculateQuoteError::Other(
-                anyhow!("Uh oh - error"),
-            ))),
-        ))
-        .into_response();
+        let response =
+            OrderQuoteError::CalculateQuote(CalculateQuoteError::Other(anyhow!("Uh oh - error")))
+                .into_response();
         assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
         let body = response_body(response).await;
         let body: serde_json::Value = serde_json::from_slice(body.as_slice()).unwrap();
diff --git a/crates/orderbook/src/api/put_app_data.rs b/crates/orderbook/src/api/put_app_data.rs
index 4bf9e417d2..835628fa44 100644
--- a/crates/orderbook/src/api/put_app_data.rs
+++ b/crates/orderbook/src/api/put_app_data.rs
@@ -1,69 +1,81 @@
 use {
-    crate::api::{IntoWarpReply, internal_error_reply},
-    anyhow::Result,
+    crate::api::{AppState, internal_error_reply},
     app_data::{AppDataDocument, AppDataHash},
-    reqwest::StatusCode,
-    std::{convert::Infallible, sync::Arc},
-    warp::{Filter, Rejection, body, reply},
+    axum::{
+        body::{self},
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    std::{str::FromStr, sync::Arc},
 };
 
-fn request(
-    max_size: usize,
-) -> impl Filter<Extract = (Option<AppDataHash>, AppDataDocument), Error = Rejection> + Clone {
-    let opt = warp::path::param::<AppDataHash>()
-        .map(Some)
-        .or_else(|_| async { Ok::<(Option<AppDataHash>,), std::convert::Infallible>((None,)) });
-    warp::path!("v1" / "app_data" / ..)
-        .and(opt)
-        .and(warp::put())
-        .and(body::content_length_limit(max_size as _))
-        .and(body::json())
+pub async fn put_app_data_without_hash(
+    State(state): State<Arc<AppState>>,
+    body: body::Bytes,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(document) = serde_json::from_slice::<AppDataDocument>(&body) else {
+        return StatusCode::BAD_REQUEST.into_response();
+    };
+
+    state
+        .app_data
+        .register(None, document.full_app_data.as_bytes())
+        .await
+        .into_response()
 }
 
-fn response(
-    result: Result<(crate::app_data::Registered, AppDataHash), crate::app_data::RegisterError>,
-) -> super::ApiReply {
-    match result {
-        Ok((registered, hash)) => {
-            let status = match registered {
-                crate::app_data::Registered::New => StatusCode::CREATED,
-                crate::app_data::Registered::AlreadyExisted => StatusCode::OK,
-            };
-            reply::with_status(reply::json(&hash), status)
-        }
-        Err(err) => err.into_warp_reply(),
-    }
+pub async fn put_app_data_with_hash(
+    State(state): State<Arc<AppState>>,
+    Path(hash): Path<String>,
+    body: body::Bytes,
+) -> Response {
+    // TODO: remove after all downstream callers have been notified of the status
+    // code changes
+    let Ok(hash) = AppDataHash::from_str(&hash) else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+    let Ok(document) = serde_json::from_slice::<AppDataDocument>(&body) else {
+        return StatusCode::BAD_REQUEST.into_response();
+    };
+
+    state
+        .app_data
+        .register(Some(hash), document.full_app_data.as_bytes())
+        .await
+        .into_response()
 }
 
-pub fn filter(
-    registry: Arc<crate::app_data::Registry>,
-) -> impl Filter<Extract = (super::ApiReply,), Error = Rejection> + Clone {
-    request(registry.size_limit()).and_then(move |hash, document: AppDataDocument| {
-        let registry = registry.clone();
-        async move {
-            let result = registry
-                .register(hash, document.full_app_data.as_bytes())
-                .await;
-            Result::<_, Infallible>::Ok(response(result))
-        }
-    })
+impl IntoResponse for crate::app_data::Register {
+    fn into_response(self) -> Response {
+        let status = match self.status {
+            crate::app_data::RegistrationStatus::New => StatusCode::CREATED,
+            crate::app_data::RegistrationStatus::AlreadyExisted => StatusCode::OK,
+        };
+        (status, Json(self.hash)).into_response()
+    }
 }
 
-impl IntoWarpReply for crate::app_data::RegisterError {
-    fn into_warp_reply(self) -> super::ApiReply {
+impl IntoResponse for crate::app_data::RegisterError {
+    fn into_response(self) -> Response {
         match self {
-            Self::Invalid(err) => reply::with_status(
+            Self::Invalid(err) => (
+                StatusCode::BAD_REQUEST,
                 super::error("AppDataInvalid", err.to_string()),
+            )
+                .into_response(),
+            err @ Self::HashMismatch { .. } => (
                 StatusCode::BAD_REQUEST,
-            ),
-            err @ Self::HashMismatch { .. } => reply::with_status(
                 super::error("AppDataHashMismatch", err.to_string()),
+            )
+                .into_response(),
+            err @ Self::DataMismatch { .. } => (
                 StatusCode::BAD_REQUEST,
-            ),
-            err @ Self::DataMismatch { .. } => reply::with_status(
                 super::error("AppDataMismatch", err.to_string()),
-                StatusCode::BAD_REQUEST,
-            ),
+            )
+                .into_response(),
             Self::Other(err) => {
                 tracing::error!(?err, "app_data::SaveError::Other");
                 internal_error_reply()
diff --git a/crates/orderbook/src/api/version.rs b/crates/orderbook/src/api/version.rs
index 04b5c698c5..20489608b7 100644
--- a/crates/orderbook/src/api/version.rs
+++ b/crates/orderbook/src/api/version.rs
@@ -1,16 +1,3 @@
-use {
-    reqwest::StatusCode,
-    std::convert::Infallible,
-    warp::{Filter, Rejection, Reply, reply::with_status},
-};
-
-pub fn version() -> impl Filter<Extract = (Box<dyn Reply>,), Error = Rejection> + Clone {
-    warp::path!("v1" / "version")
-        .and(warp::get())
-        .and_then(|| async {
-            Result::<_, Infallible>::Ok(Box::new(with_status(
-                env!("VERGEN_GIT_DESCRIBE"),
-                StatusCode::OK,
-            )) as Box<dyn Reply>)
-        })
+pub async fn version_handler() -> &'static str {
+    env!("VERGEN_GIT_DESCRIBE")
 }
diff --git a/crates/orderbook/src/app_data.rs b/crates/orderbook/src/app_data.rs
index 9844df4bac..bd6326f174 100644
--- a/crates/orderbook/src/app_data.rs
+++ b/crates/orderbook/src/app_data.rs
@@ -43,7 +43,7 @@ impl Registry {
         &self,
         hash: Option<AppDataHash>,
         document: &[u8],
-    ) -> Result<(Registered, AppDataHash), RegisterError> {
+    ) -> Result<Register, RegisterError> {
         let validated = self
             .validator
             .validate(document)
@@ -60,8 +60,14 @@ impl Registry {
             .insert_full_app_data(&validated.hash, &validated.document)
             .await
         {
-            Ok(()) => Ok((Registered::New, validated.hash)),
-            Err(InsertError::Duplicate) => Ok((Registered::AlreadyExisted, validated.hash)),
+            Ok(()) => Ok(Register {
+                status: RegistrationStatus::New,
+                hash: validated.hash,
+            }),
+            Err(InsertError::Duplicate) => Ok(Register {
+                status: RegistrationStatus::AlreadyExisted,
+                hash: validated.hash,
+            }),
             Err(InsertError::Mismatch(existing)) => Err(RegisterError::DataMismatch { existing }),
             Err(InsertError::Other(err)) => Err(RegisterError::Other(err)),
         }
@@ -95,13 +101,18 @@ impl Registry {
 }
 
 #[derive(Debug)]
-pub enum Registered {
+pub enum RegistrationStatus {
     /// The app data was newly added to the registry.
     New,
     /// An identical app data was already registered.
     AlreadyExisted,
 }
 
+pub struct Register {
+    pub status: RegistrationStatus,
+    pub hash: AppDataHash,
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum RegisterError {
     #[error("appData is invalid: {0}")]
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 981dfe3357..e6f9fa0f42 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -22,7 +22,7 @@ use {
         WETH9,
         support::Balances,
     },
-    futures::{FutureExt, StreamExt},
+    futures::StreamExt,
     model::{DomainSeparator, order::BUY_ETH_ADDRESS},
     num::ToPrimitive,
     observe::metrics::{DEFAULT_METRICS_PORT, serve_metrics},
@@ -53,9 +53,8 @@ use {
         sources::{self, BaselineSource, uniswap_v2::UniV2BaselineSourceParameters},
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     },
-    std::{convert::Infallible, future::Future, net::SocketAddr, sync::Arc, time::Duration},
+    std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
     tokio::task::{self, JoinHandle},
-    warp::Filter,
 };
 
 pub async fn start(args: impl Iterator<Item = String>) {
@@ -448,17 +447,15 @@ pub async fn run(args: Arguments) {
     ));
 
     check_database_connection(orderbook.as_ref()).await;
-    let quotes = Arc::new(
-        QuoteHandler::new(
-            order_validator,
-            optimal_quoter,
-            app_data.clone(),
-            args.volume_fee_config,
-            args.shared.volume_fee_bucket_overrides.clone(),
-            args.shared.enable_sell_equals_buy_volume_fee,
-        )
-        .with_fast_quoter(fast_quoter),
-    );
+    let quotes = QuoteHandler::new(
+        order_validator,
+        optimal_quoter,
+        app_data.clone(),
+        args.volume_fee_config,
+        args.shared.volume_fee_bucket_overrides.clone(),
+        args.shared.enable_sell_equals_buy_volume_fee,
+    )
+    .with_fast_quoter(fast_quoter);
 
     let (shutdown_sender, shutdown_receiver) = tokio::sync::oneshot::channel();
     let serve_api = serve_api(
@@ -539,14 +536,14 @@ fn serve_api(
     database: Postgres,
     database_replica: Postgres,
     orderbook: Arc<Orderbook>,
-    quotes: Arc<QuoteHandler>,
+    quotes: QuoteHandler,
     app_data: Arc<crate::app_data::Registry>,
     address: SocketAddr,
     shutdown_receiver: impl Future<Output = ()> + Send + 'static,
     native_price_estimator: Arc<dyn NativePriceEstimating>,
     quote_timeout: Duration,
 ) -> JoinHandle<()> {
-    let filter = api::handle_all_routes(
+    let app = api::handle_all_routes(
         database,
         database_replica,
         orderbook,
@@ -554,19 +551,18 @@ fn serve_api(
         app_data,
         native_price_estimator,
         quote_timeout,
-    )
-    .boxed();
+    );
     tracing::info!(%address, "serving order book");
-    let warp_svc = warp::service(filter);
-    let make_svc = hyper::service::make_service_fn(move |_| {
-        let svc = warp_svc.clone();
-        async move { Ok::<_, Infallible>(svc) }
-    });
-    let server = hyper::Server::bind(&address)
-        .serve(make_svc)
-        .with_graceful_shutdown(shutdown_receiver)
-        .map(|_| ());
-    task::spawn(server)
+
+    let server = axum::Server::bind(&address)
+        .serve(app.into_make_service())
+        .with_graceful_shutdown(shutdown_receiver);
+
+    task::spawn(async move {
+        if let Err(err) = server.await {
+            tracing::error!(?err, "server error");
+        }
+    })
 }
 
 /// Check that important constants such as the EIP 712 Domain Separator and
diff --git a/crates/orderbook/src/solver_competition.rs b/crates/orderbook/src/solver_competition.rs
index 9cd1c2c2e0..1e852019af 100644
--- a/crates/orderbook/src/solver_competition.rs
+++ b/crates/orderbook/src/solver_competition.rs
@@ -24,7 +24,7 @@ pub trait SolverCompetitionStoring: Send + Sync {
     async fn load_competition(
         &self,
         identifier: Identifier,
-    ) -> Result<SolverCompetitionAPI, LoadSolverCompetitionError>;
+    ) -> Result<SolverCompetitionAPI, crate::solver_competition::LoadSolverCompetitionError>;
 
     /// Retrieves the solver competition for the most recent auction.
     ///
diff --git a/crates/solvers/src/api/routes/healthz.rs b/crates/solvers/src/api/routes/healthz.rs
index 7e39e585dc..fc34fe28c8 100644
--- a/crates/solvers/src/api/routes/healthz.rs
+++ b/crates/solvers/src/api/routes/healthz.rs
@@ -1,5 +1,8 @@
-use axum::{http::StatusCode, response::IntoResponse};
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
 
-pub async fn healthz() -> impl IntoResponse {
-    StatusCode::OK
+pub async fn healthz() -> Response {
+    StatusCode::OK.into_response()
 }
diff --git a/playground/docker-compose.non-interactive.yml b/playground/docker-compose.non-interactive.yml
index c9d5fca62f..356fc8652b 100644
--- a/playground/docker-compose.non-interactive.yml
+++ b/playground/docker-compose.non-interactive.yml
@@ -115,7 +115,7 @@ services:
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
       - SETTLE_INTERVAL=15s
-      - GAS_ESTIMATORS=Web3
+      - GAS_ESTIMATORS=Web3,Alloy
       - PRICE_ESTIMATORS=None
       - NATIVE_PRICE_ESTIMATORS=baseline
       - BLOCK_STREAM_POLL_INTERVAL=1s

From 6bd3e6f3730a57a189c070c71acae68075412762 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Fri, 13 Feb 2026 10:55:37 +0100
Subject: [PATCH 053/219] Propagate request ID from Forwarder (#4150)

# Description

I wanted to get all logs for a quote request, but when I searched for
request ID in OpenSearch I only got requests from the orderbook but none
from the autopilot which should have shown native price fetching. This
PR adds request ID propagation to the forwarder.
---
 .../shared/src/price_estimation/native/forwarder.rs   | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/crates/shared/src/price_estimation/native/forwarder.rs b/crates/shared/src/price_estimation/native/forwarder.rs
index 4d6aaa72d4..28089b9a1a 100644
--- a/crates/shared/src/price_estimation/native/forwarder.rs
+++ b/crates/shared/src/price_estimation/native/forwarder.rs
@@ -35,14 +35,15 @@ impl Forwarder {
             .join(format!("native_price/{:?}", token).as_str())
             .context("failed to construct autopilot URL")?;
 
-        let response = self
+        let mut request = self
             .client
             .get(url)
             .query(&[("timeout_ms", timeout.as_millis() as u64)])
-            .timeout(timeout)
-            .send()
-            .await
-            .context("failed to send request")?;
+            .timeout(timeout);
+        if let Some(id) = observe::distributed_tracing::request_id::from_current_span() {
+            request = request.header("X-REQUEST-ID", id);
+        }
+        let response = request.send().await.context("failed to send request")?;
 
         match response.status() {
             StatusCode::OK => {

From 4e243385822417340b09fabecf880d9791742201 Mon Sep 17 00:00:00 2001
From: Aryan Godara <65490434+AryanGodara@users.noreply.github.com>
Date: Fri, 13 Feb 2026 15:44:58 +0530
Subject: [PATCH 054/219] Add openAPI reference to ink (#4111)

# Description
Added Ink staging and prod URLs for OpenAPI spec
---
 crates/orderbook/openapi.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 9434a62d98..b47831b118 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -43,6 +43,10 @@ servers:
     url: "https://api.cow.fi/plasma"
   - description: Plasma (Staging)
     url: "https://barn.api.cow.fi/plasma"
+  - description: Ink (Prod)
+    url: "https://api.cow.fi/ink"
+  - description: Ink (Staging)
+    url: "https://barn.api.cow.fi/ink"
   - description: Sepolia (Prod)
     url: "https://api.cow.fi/sepolia"
   - description: Sepolia (Staging)

From d28b2a019f6a524d344c263bc7d304306c8ec2cf Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 11:29:32 +0100
Subject: [PATCH 055/219] Don't re-hash appdata every time (#4152)

# Description
A surprising amount of time when building a new auction is lost when
assembling the final orders. This step involves inspecting the appdata
and recovering the partner fee from that.
The current implementation has 2 major flaws:
* it re-parses the appdata during every auction
* it parses AND hashes the data in every auction

While the ideal fix would be to only parse the appdata once this is more
involved and we can already get an easy win by just omitting the hashing
part. I'll follow up with a PR that avoids the unnecessary parsing as
well.

# Changes
- don't validate the appdata only parse it since that skips the
re-hashing of the data which we don't need at this point

## How to test
Measured performance with tempo
`assemble_orders` went from 88ms to 50ms

Before
<img width="964" height="172" alt="Screenshot 2026-02-13 at 08 22 33"
src="https://github.com/user-attachments/assets/d11c3e9e-9638-4762-ba17-c7376abef1b6"
/>

After
<img width="1072" height="151" alt="Screenshot 2026-02-13 at 08 22 40"
src="https://github.com/user-attachments/assets/76355c10-2d25-431e-9d8f-859cacbfc0b6"
/>

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
 crates/autopilot/src/domain/fee/mod.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/crates/autopilot/src/domain/fee/mod.rs b/crates/autopilot/src/domain/fee/mod.rs
index fcbea4ba92..966fdda141 100644
--- a/crates/autopilot/src/domain/fee/mod.rs
+++ b/crates/autopilot/src/domain/fee/mod.rs
@@ -13,7 +13,6 @@ use {
         domain::{self, eth},
     },
     alloy::primitives::{Address, U256},
-    app_data::Validator,
     chrono::{DateTime, Utc},
     rust_decimal::Decimal,
     shared::{
@@ -164,14 +163,13 @@ impl ProtocolFees {
         let Some(full_app_data) = order.metadata.full_app_data.as_ref() else {
             return vec![];
         };
-        let Ok(validated) = Validator::new(usize::MAX).validate(full_app_data.as_bytes()) else {
+        let Ok(parsed_app_data) = app_data::parse(full_app_data.as_bytes()) else {
             return vec![];
         };
 
         let mut accumulated = Decimal::ZERO;
 
-        validated
-            .protocol
+        parsed_app_data
             .partner_fee
             .iter()
             .map(move |partner_fee| {

From bf0f77851c876ac2d5e28c6ddac9c4ff33aa298f Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 12:08:49 +0100
Subject: [PATCH 056/219] Move storing order events fully off the hot path
 (#4149)

# Description
While building a new auction we also store a bunch of order events for
debugging purposes. This already happens mostly in a background task but
the conversion from the owned collection to a collection of the type the
persistence layer expects still happens on the hot path.

# Changes
Introduce a second function for storing order events which takes a
collection (`impl IntoIterator`) and a conversion function. This then
allows us to move the collection as is into the background task and do
the conversion there.

## How to test
I measured the optimization using tempo but the exact numbers are a bit
hard to nail down because only some of the instrumented logic is on the
hot path and it doesn't get displayed that well in the tempo UI.
Based on the time and size of the `assemble_orders` span it looks like
the new version shaves off ~45ms or so.

Before
<img width="1455" height="185" alt="Screenshot 2026-02-13 at 07 51 15"
src="https://github.com/user-attachments/assets/5a21e14c-1b6a-4e07-8f11-8e73bd901206"
/>

After
<img width="1524" height="170" alt="Screenshot 2026-02-13 at 07 51 27"
src="https://github.com/user-attachments/assets/d5739756-0ffd-4a64-bc1d-c615e2d31049"
/>
---
 crates/autopilot/src/infra/persistence/mod.rs | 19 ++++++++++++++++++-
 crates/autopilot/src/solvable_orders.rs       | 12 ++++++------
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index 3f3d0b2f5f..207f8d645d 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -294,10 +294,27 @@ impl Persistence {
         order_uids: impl IntoIterator<Item = domain::OrderUid>,
         label: boundary::OrderEventLabel,
     ) {
+        let order_uids: Vec<_> = order_uids.into_iter().collect();
+        self.store_order_events_owned(order_uids, std::convert::identity, label);
+    }
+
+    /// A variants of [`store_order_events`] where [`items`] is already an owned
+    /// collection which allows us to move the logic to convert an item to a
+    /// [`domain::OrderUid`] into the background task as well.
+    pub fn store_order_events_owned<I, F>(
+        &self,
+        items: I,
+        convert: F,
+        label: boundary::OrderEventLabel,
+    ) where
+        I: IntoIterator + Send + 'static,
+        I::Item: Send,
+        F: (Fn(I::Item) -> domain::OrderUid) + Send + 'static,
+    {
         let db = self.postgres.clone();
-        let order_uids = order_uids.into_iter().collect();
         tokio::spawn(
             async move {
+                let order_uids = items.into_iter().map(convert).collect();
                 match db.pool.acquire().await {
                     Ok(mut tx) => {
                         store_order_events(&mut tx, order_uids, label, Utc::now()).await;
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index bb2bd94d55..46a5c761ba 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -266,14 +266,14 @@ impl SolvableOrdersCache {
         if store_events {
             // spawning a background task since `order_events` table insert operation takes
             // a while and the result is ignored.
-            self.persistence.store_order_events(
-                invalid_order_uids.iter().map(|id| domain::OrderUid(id.0)),
+            self.persistence.store_order_events_owned(
+                invalid_order_uids,
+                |uid| domain::OrderUid(uid.0),
                 OrderEventLabel::Invalid,
             );
-            self.persistence.store_order_events(
-                filtered_order_events
-                    .iter()
-                    .map(|id| domain::OrderUid(id.0)),
+            self.persistence.store_order_events_owned(
+                filtered_order_events,
+                |uid| domain::OrderUid(uid.0),
                 OrderEventLabel::Filtered,
             );
         }

From 49d8b6e3b2865c644c2902e346d88ac7bbae9d44 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 12:08:57 +0100
Subject: [PATCH 057/219] Make autopilot sync more granular (#4144)

# Description
While https://github.com/cowprotocol/services/pull/4141 achieved the
goal of reducing the time before we build a fresh auction it also came
with the oddity that the metrics suggest slower order execution while
the time to happy moo SLI was very healthy.
The reason for the weird metrics is that the autopilot task that
monitors for landed transactions previously waited for ALL of the
maintenance task to finish before looking up the settlement from the DB
(see
[here](https://github.com/cowprotocol/services/blob/main/crates/autopilot/src/run_loop.rs#L843-L850))
while the PR unintentionally changed this part as well to only wait for
the minimum processing.

Improved latency metrics
<img width="943" height="601" alt="Screenshot 2026-02-11 at 16 15 19"
src="https://github.com/user-attachments/assets/501a3012-1cc9-449f-9046-894cf0ffe8c8"
/>

Degraded runloop and settle metrics
<img width="933" height="298" alt="Screenshot 2026-02-11 at 16 15 27"
src="https://github.com/user-attachments/assets/49e0d0d4-3f90-4012-890e-ec5f18394342"
/>

Despite not degraded time to happy moo
<img width="1404" height="339" alt="Screenshot 2026-02-11 at 16 16 14"
src="https://github.com/user-attachments/assets/181b4caf-8a8e-4c7c-91da-28369b1274b8"
/>

# Changes
Fix metrics by allowing `MaintenanceSync` to either wait for partial or
full processing of the given block. Before building the auction we now
explicitly await partial processing to be done while later on when we
determine whether a solution was submitted we wait for the block to be
fully processed.

# Alternatives Considered
* have 1 update channel for every maintenance sub task and have it push
updates => discarded because it's more granular than we need
* replace watch stream with struct with atomic counters for every update
type => discarded because awaiting changes on those counters is more
complicated than just 2 watch streams

Overall I'm not super happy with the solution so I'm happy to hear
alternative suggestions if you have any.
---
 crates/autopilot/src/maintenance.rs | 54 ++++++++++++++++++++++-------
 crates/autopilot/src/run_loop.rs    | 29 ++++++----------
 2 files changed, 52 insertions(+), 31 deletions(-)

diff --git a/crates/autopilot/src/maintenance.rs b/crates/autopilot/src/maintenance.rs
index b279ea5c20..f17e66abf6 100644
--- a/crates/autopilot/src/maintenance.rs
+++ b/crates/autopilot/src/maintenance.rs
@@ -40,25 +40,42 @@ use {
 pub struct MaintenanceSync {
     /// How long the autopilot wants to wait at most.
     timeout: Duration,
-    last_processed_block: watch::Receiver<u64>,
+    /// This is the last block where essential processing like indexing events
+    /// was completed.
+    partially_processed_block: watch::Receiver<u64>,
+    /// This is the last block that has been fully processed.
+    fully_processed_block: watch::Receiver<u64>,
+}
+
+pub enum SyncTarget {
+    /// Essential processing (e.g. event indexing) of the given block is
+    /// sufficient,
+    PartiallyProcessed(u64),
+    /// The given block as to be fully processed.
+    FullyProcessed(u64),
 }
 
 impl MaintenanceSync {
-    pub async fn wait_until_block_processed(&self, block: u64) {
+    pub async fn wait_until_block_processed(&self, target: SyncTarget) {
         let _timer = observe::metrics::metrics()
             .on_auction_overhead_start("autopilot", "wait_for_maintenance");
 
-        if let Err(_timeout) = tokio::time::timeout(self.timeout, self.wait_inner(block)).await {
+        if let Err(_timeout) = tokio::time::timeout(self.timeout, self.wait_inner(target)).await {
             tracing::debug!("timed out waiting for maintenance");
         }
     }
 
-    async fn wait_inner(&self, target_block: u64) {
-        if *self.last_processed_block.borrow() >= target_block {
+    async fn wait_inner(&self, target: SyncTarget) {
+        let (relevant_updates, target_block) = match target {
+            SyncTarget::FullyProcessed(block) => (&self.partially_processed_block, block),
+            SyncTarget::PartiallyProcessed(block) => (&self.fully_processed_block, block),
+        };
+
+        if *relevant_updates.borrow() >= target_block {
             return;
         }
 
-        let mut stream = WatchStream::new(self.last_processed_block.clone());
+        let mut stream = WatchStream::new(relevant_updates.clone());
         loop {
             let processed_block = stream.next().await.unwrap();
             if processed_block >= target_block {
@@ -110,7 +127,8 @@ impl Maintenance {
         blocks: CurrentBlockWatcher,
         timeout: Duration,
     ) -> MaintenanceSync {
-        let (sender, receiver) = watch::channel(blocks.borrow().number);
+        let (full_tx, full_rx) = watch::channel(blocks.borrow().number);
+        let (partial_tx, partial_rx) = watch::channel(blocks.borrow().number);
 
         tokio::task::spawn(async move {
             let mut stream = into_stream(blocks);
@@ -119,7 +137,7 @@ impl Maintenance {
                     .next()
                     .await
                     .expect("block stream terminated unexpectedly");
-                self.index_until_block(block, &sender)
+                self.index_until_block(block, &partial_tx, &full_tx)
                     .instrument(tracing::info_span!(
                         "autopilot_maintenance",
                         block = block.number
@@ -129,12 +147,18 @@ impl Maintenance {
         });
 
         MaintenanceSync {
-            last_processed_block: receiver,
+            partially_processed_block: partial_rx,
+            fully_processed_block: full_rx,
             timeout,
         }
     }
 
-    async fn index_until_block(&self, block: BlockInfo, last_processed_block: &watch::Sender<u64>) {
+    async fn index_until_block(
+        &self,
+        block: BlockInfo,
+        partially_processed_block: &watch::Sender<u64>,
+        fully_processed_block: &watch::Sender<u64>,
+    ) {
         metrics().last_seen_block.set(block.number);
         let start = Instant::now();
 
@@ -150,8 +174,11 @@ impl Maintenance {
         );
         metrics().last_updated_block.set(block.number);
         metrics().updates.with_label_values(&["success"]).inc();
-        if let Err(err) = last_processed_block.send(block.number) {
-            tracing::warn!(?err, "nobody listening for processed blocks anymore");
+        if let Err(err) = partially_processed_block.send(block.number) {
+            tracing::warn!(
+                ?err,
+                "nobody listening for partially processed blocks anymore"
+            );
         }
 
         // only after we informed the run_loop that the essential updates are done we
@@ -161,6 +188,9 @@ impl Maintenance {
             tracing::warn!(?err, "failed to run optional maintenance");
             return;
         }
+        if let Err(err) = fully_processed_block.send(block.number) {
+            tracing::warn!(?err, "nobody listening for fully processed blocks anymore");
+        }
         tracing::info!(
             time = ?start.elapsed(),
             "successfully ran optional maintenance tasks"
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 7a8a0be012..7e36d04e68 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -19,7 +19,7 @@ use {
             solvers::dto::{settle, solve},
         },
         leader_lock_tracker::LeaderLockTracker,
-        maintenance::MaintenanceSync,
+        maintenance::{MaintenanceSync, SyncTarget},
         run::Liveness,
         shutdown_controller::ShutdownController,
         solvable_orders::SolvableOrdersCache,
@@ -208,7 +208,12 @@ impl RunLoop {
             current_block
         };
 
-        self.run_maintenance(&auction_block).await;
+        {
+            let _timer = Metrics::get().service_maintenance_time.start_timer();
+            self.maintenance
+                .wait_until_block_processed(SyncTarget::PartiallyProcessed(auction_block.number))
+                .await;
+        }
 
         match self
             .solvable_orders_cache
@@ -254,16 +259,6 @@ impl RunLoop {
         Some(auction)
     }
 
-    /// Runs maintenance on all components to ensure the system uses
-    /// the latest available state.
-    async fn run_maintenance(&self, block: &BlockInfo) {
-        let start = Instant::now();
-        self.maintenance
-            .wait_until_block_processed(block.number)
-            .await;
-        Metrics::ran_maintenance(start.elapsed());
-    }
-
     async fn cut_auction(&self) -> Option<domain::Auction> {
         let Some(auction) = self.solvable_orders_cache.current_auction().await else {
             tracing::debug!("no current auction");
@@ -842,7 +837,9 @@ impl RunLoop {
             let block = ethrpc::block_stream::next_block(self.eth.current_block()).await;
             // Run maintenance to ensure the system processed the last available block so
             // it's possible to find the tx in the DB in the next line.
-            self.run_maintenance(&block).await;
+            self.maintenance
+                .wait_until_block_processed(SyncTarget::FullyProcessed(block.number))
+                .await;
 
             match self
                 .persistence
@@ -1066,12 +1063,6 @@ impl Metrics {
             .observe(elapsed.as_secs_f64());
     }
 
-    fn ran_maintenance(elapsed: Duration) {
-        Self::get()
-            .service_maintenance_time
-            .observe(elapsed.as_secs_f64());
-    }
-
     fn single_run_completed(elapsed: Duration) {
         Self::get().single_run_time.observe(elapsed.as_secs_f64());
     }

From eb99f9920ef926757fe7cb4ac117b1119fb3566c Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 12:09:40 +0100
Subject: [PATCH 058/219] Store orders and quotes reference counted in auction
 (#4153)

# Description
Currently the solvable orders cache stores raw owned instances of orders
and quotes.
This is painful for 2 reasons:
* `solvable_orders_after()` clones all orders and quotes to do the
incremental update (see
[here](https://github.com/cowprotocol/services/blob/main/crates/autopilot/src/solvable_orders.rs#L377-L378))
* `update()` clones all orders at the start (see
[here](https://github.com/cowprotocol/services/blob/main/crates/autopilot/src/solvable_orders.rs#L172-L176))

Both of these can be made very cheap by storing `Arc`ed instances.

# Alternatives considered
Theoretically one could also collect `&Order` when building the auction
and use `std::mem::take()` to move the existing hashmaps into
`solvable_orders_after()`. But using `&Order` is less flexible and more
complicated and `std::mem::take()` requires extra attention when
handling errors in `solvable_orders_after()` to not leave the cache in a
broken state or completely empty.

# Changes
- put all orders and quotes in `Arc`s.

## How to test
I only tested the approach with using `&Order` but it's reasonable to
assume that the improvement for `cloning_relevant_orders()` will be very
similar when cloning `Arc`s instead of collecting references.
Also I expect the highlighted section of `get_solvable_orders` (1st
screenshot) to disappear as well with this PR.
Both speed ups would combine to ~50ms.

Before
<img width="733" height="298" alt="Screenshot 2026-02-13 at 08 51 46"
src="https://github.com/user-attachments/assets/03ca9054-627b-4241-aa62-bd8a4e211283"
/>

After
<img width="630" height="295" alt="Screenshot 2026-02-13 at 08 52 09"
src="https://github.com/user-attachments/assets/56a5e3de-f98c-4fb4-8631-03f46ff513bc"
/>
---
 crates/autopilot/src/boundary/mod.rs          |  11 +-
 crates/autopilot/src/boundary/order.rs        |  15 +-
 crates/autopilot/src/database/auction.rs      |  13 +-
 crates/autopilot/src/domain/fee/mod.rs        |  10 +-
 crates/autopilot/src/infra/persistence/mod.rs |  10 +-
 crates/autopilot/src/solvable_orders.rs       | 301 ++++++++++--------
 6 files changed, 207 insertions(+), 153 deletions(-)

diff --git a/crates/autopilot/src/boundary/mod.rs b/crates/autopilot/src/boundary/mod.rs
index 7142d7e8c0..ab71671bfa 100644
--- a/crates/autopilot/src/boundary/mod.rs
+++ b/crates/autopilot/src/boundary/mod.rs
@@ -22,7 +22,12 @@ pub use {
     },
     shared::order_validation::{Amounts, is_order_outside_market_price},
 };
-use {crate::domain, ethrpc::Web3, std::collections::HashMap, url::Url};
+use {
+    crate::domain,
+    ethrpc::Web3,
+    std::{collections::HashMap, sync::Arc},
+    url::Url,
+};
 
 pub mod events;
 pub mod order;
@@ -33,8 +38,8 @@ pub fn web3_client(ethrpc: &Url, ethrpc_args: &shared::ethrpc::Arguments) -> Web
 }
 
 pub struct SolvableOrders {
-    pub orders: HashMap<domain::OrderUid, model::order::Order>,
-    pub quotes: HashMap<domain::OrderUid, domain::Quote>,
+    pub orders: HashMap<domain::OrderUid, Arc<model::order::Order>>,
+    pub quotes: HashMap<domain::OrderUid, Arc<domain::Quote>>,
     pub latest_settlement_block: u64,
     /// Used as a checkpoint - meaning at this point in time
     /// **at least** the stored orders were present in the system.
diff --git a/crates/autopilot/src/boundary/order.rs b/crates/autopilot/src/boundary/order.rs
index 372e4090b3..04d43fb5bf 100644
--- a/crates/autopilot/src/boundary/order.rs
+++ b/crates/autopilot/src/boundary/order.rs
@@ -4,7 +4,7 @@ use {
 };
 
 pub fn to_domain(
-    order: model::order::Order,
+    order: &model::order::Order,
     protocol_fees: Vec<domain::fee::Policy>,
     quote: Option<domain::Quote>,
 ) -> domain::Order {
@@ -30,20 +30,27 @@ pub fn to_domain(
         partially_fillable: order.data.partially_fillable,
         executed: remaining_order.executed_amount.into(),
         pre_interactions: if order_is_untouched {
-            order.interactions.pre.into_iter().map(Into::into).collect()
+            order
+                .interactions
+                .pre
+                .iter()
+                .cloned()
+                .map(Into::into)
+                .collect()
         } else {
             Default::default()
         },
         post_interactions: order
             .interactions
             .post
-            .into_iter()
+            .iter()
+            .cloned()
             .map(Into::into)
             .collect(),
         sell_token_balance: order.data.sell_token_balance.into(),
         buy_token_balance: order.data.buy_token_balance.into(),
         app_data: order.data.app_data.into(),
-        signature: order.signature.into(),
+        signature: order.signature.clone().into(),
         quote,
     }
 }
diff --git a/crates/autopilot/src/database/auction.rs b/crates/autopilot/src/database/auction.rs
index ac24f60772..a1a2ea21df 100644
--- a/crates/autopilot/src/database/auction.rs
+++ b/crates/autopilot/src/database/auction.rs
@@ -11,7 +11,7 @@ use {
         event_storing_helpers::{create_db_search_parameters, create_quote_row},
         order_quoting::{QuoteData, QuoteSearchParameters, QuoteStoring},
     },
-    std::{collections::HashMap, ops::DerefMut},
+    std::{collections::HashMap, ops::DerefMut, sync::Arc},
 };
 
 #[async_trait::async_trait]
@@ -75,11 +75,11 @@ impl Postgres {
         sqlx::query("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ")
             .execute(ex.deref_mut())
             .await?;
-        let orders: HashMap<domain::OrderUid, Order> =
+        let orders: HashMap<domain::OrderUid, Arc<Order>> =
             database::orders::solvable_orders(&mut ex, i64::from(min_valid_to))
                 .map(|result| match result {
                     Ok(order) => full_order_into_model_order(order)
-                        .map(|order| (domain::OrderUid(order.metadata.uid.0), order)),
+                        .map(|order| (domain::OrderUid(order.metadata.uid.0), Arc::new(order))),
                     Err(err) => Err(anyhow::Error::from(err)),
                 })
                 .try_collect()
@@ -88,7 +88,12 @@ impl Postgres {
             .await?
             .to_u64()
             .context("latest_settlement_block is not u64")?;
-        let quotes = self.read_quotes(orders.keys()).await?;
+        let quotes = self
+            .read_quotes(orders.keys())
+            .await?
+            .into_iter()
+            .map(|(uid, quote)| (uid, Arc::new(quote)))
+            .collect();
         Ok(boundary::SolvableOrders {
             orders,
             quotes,
diff --git a/crates/autopilot/src/domain/fee/mod.rs b/crates/autopilot/src/domain/fee/mod.rs
index 966fdda141..d6bdd659ff 100644
--- a/crates/autopilot/src/domain/fee/mod.rs
+++ b/crates/autopilot/src/domain/fee/mod.rs
@@ -233,7 +233,7 @@ impl ProtocolFees {
     /// protocol fees if necessary.
     pub fn apply(
         &self,
-        order: boundary::Order,
+        order: &boundary::Order,
         quote: Option<domain::Quote>,
         surplus_capturing_jit_order_owners: &[eth::Address],
     ) -> domain::Order {
@@ -248,7 +248,7 @@ impl ProtocolFees {
         });
 
         let partner_fee =
-            Self::get_partner_fee(&order, &reference_quote, self.max_partner_fee.get());
+            Self::get_partner_fee(order, &reference_quote, self.max_partner_fee.get());
 
         if surplus_capturing_jit_order_owners.contains(&order.metadata.owner) {
             return boundary::order::to_domain(order, partner_fee, quote);
@@ -259,7 +259,7 @@ impl ProtocolFees {
 
     fn apply_policies(
         &self,
-        order: boundary::Order,
+        order: &boundary::Order,
         quote: domain::Quote,
         partner_fees: Vec<Policy>,
     ) -> domain::Order {
@@ -273,8 +273,8 @@ impl ProtocolFees {
 
         let protocol_fees = fee_policies
             .iter()
-            .filter_map(|fee_policy| Self::protocol_fee_into_policy(&order, &quote, fee_policy))
-            .flat_map(|policy| self.variant_fee_apply(&order, &quote, policy))
+            .filter_map(|fee_policy| Self::protocol_fee_into_policy(order, &quote, fee_policy))
+            .flat_map(|policy| self.variant_fee_apply(order, &quote, policy))
             .chain(partner_fees)
             .collect::<Vec<_>>();
 
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index 207f8d645d..b6980c749a 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -558,8 +558,8 @@ impl Persistence {
     /// order creation timestamp, and minimum validity period.
     pub async fn solvable_orders_after(
         &self,
-        mut current_orders: HashMap<domain::OrderUid, model::order::Order>,
-        mut current_quotes: HashMap<domain::OrderUid, domain::Quote>,
+        mut current_orders: HashMap<domain::OrderUid, Arc<model::order::Order>>,
+        mut current_quotes: HashMap<domain::OrderUid, Arc<domain::Quote>>,
         after_timestamp: DateTime<Utc>,
         after_block: u64,
         min_valid_to: u32,
@@ -587,7 +587,7 @@ impl Persistence {
 
         // Fetch the orders that were updated after the given block and were created or
         // cancelled after the given timestamp.
-        let next_orders: HashMap<domain::OrderUid, model::order::Order> = {
+        let next_orders: HashMap<domain::OrderUid, Arc<model::order::Order>> = {
             let _timer = Metrics::get()
                 .database_queries
                 .with_label_values(&["open_orders_after"])
@@ -600,7 +600,7 @@ impl Persistence {
             )
             .map(|result| match result {
                 Ok(order) => full_order_into_model_order(order)
-                    .map(|order| (domain::OrderUid(order.metadata.uid.0), order)),
+                    .map(|order| (domain::OrderUid(order.metadata.uid.0), Arc::new(order))),
                 Err(err) => Err(anyhow::Error::from(err)),
             })
             .try_collect()
@@ -674,7 +674,7 @@ impl Persistence {
                 let order_uid = domain::OrderUid(quote.order_uid.0);
                 match dto::quote::into_domain(quote) {
                     Ok(quote) => {
-                        current_quotes.insert(order_uid, quote);
+                        current_quotes.insert(order_uid, Arc::new(quote));
                     }
                     Err(err) => tracing::warn!(?order_uid, ?err, "failed to convert quote from db"),
                 }
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 46a5c761ba..22db019b77 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -191,7 +191,10 @@ impl SolvableOrdersCache {
             .collect();
 
         let (balances, orders, cow_amms) = {
-            let queries = orders.iter().map(Query::from_order).collect::<Vec<_>>();
+            let queries = orders
+                .iter()
+                .map(|o| Query::from_order(o.as_ref()))
+                .collect::<Vec<_>>();
             tokio::join!(
                 self.fetch_balances(queries),
                 self.filter_invalid_orders(orders, &mut counter, &mut invalid_order_uids,),
@@ -303,9 +306,12 @@ impl SolvableOrdersCache {
                     let quote = db_solvable_orders
                         .quotes
                         .get(&order.metadata.uid.into())
-                        .cloned();
-                    self.protocol_fees
-                        .apply(order, quote, &surplus_capturing_jit_order_owners)
+                        .map(|quote| quote.as_ref().clone());
+                    self.protocol_fees.apply(
+                        order.as_ref(),
+                        quote,
+                        &surplus_capturing_jit_order_owners,
+                    )
                 })
                 .collect(),
             prices: prices
@@ -398,10 +404,10 @@ impl SolvableOrdersCache {
     /// Executed orders filtering in parallel.
     async fn filter_invalid_orders(
         &self,
-        mut orders: Vec<Order>,
+        mut orders: Vec<Arc<Order>>,
         counter: &mut OrderFilterCounter,
         invalid_order_uids: &mut HashSet<OrderUid>,
-    ) -> Vec<Order> {
+    ) -> Vec<Arc<Order>> {
         let presignature_pending_orders = find_presignature_pending_orders(&orders);
 
         let (banned_user_orders, unsupported_token_orders) = tokio::join!(
@@ -447,7 +453,10 @@ impl SolvableOrdersCache {
 
 /// Finds all orders whose owners or receivers are in the set of "banned"
 /// users.
-async fn find_banned_user_orders(orders: &[Order], banned_users: &banned::Users) -> Vec<OrderUid> {
+async fn find_banned_user_orders(
+    orders: &[Arc<Order>],
+    banned_users: &banned::Users,
+) -> Vec<OrderUid> {
     let banned = banned_users
         .banned(
             orders
@@ -484,7 +493,7 @@ async fn get_native_prices(
 
 /// Finds orders with pending presignatures. EIP-1271 signature validation is
 /// skipped entirely - the driver validates signatures before settlement.
-fn find_presignature_pending_orders(orders: &[Order]) -> Vec<OrderUid> {
+fn find_presignature_pending_orders(orders: &[Arc<Order>]) -> Vec<OrderUid> {
     orders
         .iter()
         .filter(|order| {
@@ -500,11 +509,11 @@ fn find_presignature_pending_orders(orders: &[Order]) -> Vec<OrderUid> {
 /// Removes orders that can't possibly be settled because there isn't enough
 /// balance.
 fn orders_with_balance(
-    mut orders: Vec<Order>,
+    mut orders: Vec<Arc<Order>>,
     balances: &Balances,
     settlement_contract: Address,
     filter_bypass_orders: &HashSet<OrderUid>,
-) -> Vec<Order> {
+) -> Vec<Arc<Order>> {
     // Prefer newer orders over older ones.
     orders.sort_by_key(|order| std::cmp::Reverse(order.metadata.creation_date));
     orders.retain(|order| {
@@ -546,7 +555,7 @@ fn orders_with_balance(
 
 /// Filters out dust orders i.e. partially fillable orders that, when scaled
 /// have a 0 buy or sell amount.
-fn filter_dust_orders(mut orders: Vec<Order>, balances: &Balances) -> Vec<Order> {
+fn filter_dust_orders(mut orders: Vec<Arc<Order>>, balances: &Balances) -> Vec<Arc<Order>> {
     orders.retain(|order| {
         if !order.data.partially_fillable {
             return true;
@@ -559,7 +568,7 @@ fn filter_dust_orders(mut orders: Vec<Order>, balances: &Balances) -> Vec<Order>
         };
 
         let Ok(remaining) =
-            remaining_amounts::Remaining::from_order_with_balance(&order.into(), balance)
+            remaining_amounts::Remaining::from_order_with_balance(&order.as_ref().into(), balance)
         else {
             return false;
         };
@@ -577,12 +586,12 @@ fn filter_dust_orders(mut orders: Vec<Order>, balances: &Balances) -> Vec<Order>
 }
 
 async fn get_orders_with_native_prices(
-    orders: Vec<Order>,
+    orders: Vec<Arc<Order>>,
     native_price_estimator: &NativePriceUpdater,
     metrics: &Metrics,
     additional_tokens: impl IntoIterator<Item = Address>,
     timeout: Duration,
-) -> (Vec<Order>, BTreeMap<Address, alloy::primitives::U256>) {
+) -> (Vec<Arc<Order>>, BTreeMap<Address, alloy::primitives::U256>) {
     let traded_tokens = orders
         .iter()
         .flat_map(|order| [order.data.sell_token, order.data.buy_token])
@@ -613,7 +622,7 @@ async fn get_orders_with_native_prices(
 }
 
 async fn find_unsupported_tokens(
-    orders: &[Order],
+    orders: &[Arc<Order>],
     bad_token: Arc<dyn BadTokenDetecting>,
 ) -> Vec<OrderUid> {
     let bad_tokens = join_all(
@@ -660,10 +669,10 @@ async fn find_unsupported_tokens(
 /// Filter out limit orders which are far enough outside the estimated native
 /// token price.
 fn filter_mispriced_limit_orders(
-    mut orders: Vec<Order>,
+    mut orders: Vec<Arc<Order>>,
     prices: &BTreeMap<Address, alloy::primitives::U256>,
     price_factor: &BigDecimal,
-) -> Vec<Order> {
+) -> Vec<Arc<Order>> {
     orders.retain(|order| {
         if !order.is_limit_order() {
             return true;
@@ -710,7 +719,7 @@ struct OrderFilterCounter {
 type Reason = &'static str;
 
 impl OrderFilterCounter {
-    fn new(metrics: &'static Metrics, orders: &[Order]) -> Self {
+    fn new(metrics: &'static Metrics, orders: &[Arc<Order>]) -> Self {
         // Eagerly store the candidate orders. This ensures that that gauge is
         // always up to date even if there are errors in the auction building
         // process.
@@ -736,7 +745,7 @@ impl OrderFilterCounter {
     }
 
     /// Creates a new checkpoint from the current remaining orders.
-    fn checkpoint(&mut self, reason: Reason, orders: &[Order]) -> Vec<OrderUid> {
+    fn checkpoint(&mut self, reason: Reason, orders: &[Arc<Order>]) -> Vec<OrderUid> {
         let filtered_orders = orders
             .iter()
             .fold(self.orders.clone(), |mut order_uids, order| {
@@ -784,7 +793,7 @@ impl OrderFilterCounter {
     /// If there are orders that have been filtered out since the last
     /// checkpoint these orders will get recorded with the readon "other".
     /// Returns these catch-all orders.
-    fn record(mut self, orders: &[Order]) -> Vec<OrderUid> {
+    fn record(mut self, orders: &[Arc<Order>]) -> Vec<OrderUid> {
         let removed = self.checkpoint("other", orders);
 
         self.metrics.auction_creations.inc();
@@ -840,18 +849,22 @@ mod tests {
         let token3 = Address::repeat_byte(3);
 
         let orders = vec![
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token2)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token3)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token2)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token3)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
         ];
 
         let mut native_price_estimator = MockNativePriceEstimating::new();
@@ -909,30 +922,38 @@ mod tests {
         let token5 = Address::repeat_byte(5);
 
         let orders = vec![
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token2)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token2)
-                .with_buy_token(token3)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token3)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token2)
-                .with_buy_token(token4)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token2)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token2)
+                    .with_buy_token(token3)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token3)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token2)
+                    .with_buy_token(token4)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
         ];
 
         let mut native_price_estimator = MockNativePriceEstimating::new();
@@ -1023,24 +1044,30 @@ mod tests {
         let token_approx2 = Address::repeat_byte(5);
 
         let orders = vec![
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token2)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token2)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token3)
-                .with_buy_amount(alloy::primitives::U256::ONE)
-                .with_sell_amount(alloy::primitives::U256::ONE)
-                .build(),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token2)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token2)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token3)
+                    .with_buy_amount(alloy::primitives::U256::ONE)
+                    .with_sell_amount(alloy::primitives::U256::ONE)
+                    .build(),
+            ),
         ];
 
         let mut native_price_estimator = MockNativePriceEstimating::new();
@@ -1109,18 +1136,20 @@ mod tests {
         ]
         .into_iter()
         .enumerate()
-        .map(|(i, owner)| Order {
-            metadata: OrderMetadata {
-                owner,
-                uid: OrderUid([i as u8; 56]),
-                ..Default::default()
-            },
-            data: OrderData {
-                buy_amount: alloy::primitives::U256::ONE,
-                sell_amount: alloy::primitives::U256::ONE,
+        .map(|(i, owner)| {
+            Arc::new(Order {
+                metadata: OrderMetadata {
+                    owner,
+                    uid: OrderUid([i as u8; 56]),
+                    ..Default::default()
+                },
+                data: OrderData {
+                    buy_amount: alloy::primitives::U256::ONE,
+                    sell_amount: alloy::primitives::U256::ONE,
+                    ..Default::default()
+                },
                 ..Default::default()
-            },
-            ..Default::default()
+            })
         })
         .collect::<Vec<_>>();
 
@@ -1140,31 +1169,31 @@ mod tests {
         let presign_uid = OrderUid::from_parts(B256::repeat_byte(1), Address::repeat_byte(11), 1);
         let orders = vec![
             // PresignaturePending order - should be found
-            Order {
+            Arc::new(Order {
                 metadata: OrderMetadata {
                     uid: presign_uid,
                     status: model::order::OrderStatus::PresignaturePending,
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
             // EIP-1271 order - not PresignaturePending
-            Order {
+            Arc::new(Order {
                 metadata: OrderMetadata {
                     uid: OrderUid::from_parts(B256::repeat_byte(2), Address::repeat_byte(22), 2),
                     ..Default::default()
                 },
                 signature: Signature::Eip1271(vec![2, 2]),
                 ..Default::default()
-            },
+            }),
             // Regular order - not PresignaturePending
-            Order {
+            Arc::new(Order {
                 metadata: OrderMetadata {
                     uid: OrderUid::from_parts(B256::repeat_byte(3), Address::repeat_byte(33), 3),
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
         ];
 
         let pending_orders = find_presignature_pending_orders(&orders);
@@ -1178,18 +1207,24 @@ mod tests {
         let token2 = Address::with_last_byte(2);
         let bad_token = Arc::new(ListBasedDetector::deny_list(vec![token0]));
         let orders = vec![
-            OrderBuilder::default()
-                .with_sell_token(token0)
-                .with_buy_token(token1)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token1)
-                .with_buy_token(token2)
-                .build(),
-            OrderBuilder::default()
-                .with_sell_token(token0)
-                .with_buy_token(token2)
-                .build(),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token0)
+                    .with_buy_token(token1)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token1)
+                    .with_buy_token(token2)
+                    .build(),
+            ),
+            Arc::new(
+                OrderBuilder::default()
+                    .with_sell_token(token0)
+                    .with_buy_token(token2)
+                    .build(),
+            ),
         ];
         let unsupported_tokens_orders = find_unsupported_tokens(&orders, bad_token)
             .now_or_never()
@@ -1213,19 +1248,21 @@ mod tests {
         };
         let price_factor = "0.95".parse().unwrap();
 
-        let order = |sell_amount: u8, buy_amount: u8| Order {
-            data: OrderData {
-                sell_token,
-                sell_amount: alloy::primitives::U256::from(sell_amount),
-                buy_token,
-                buy_amount: alloy::primitives::U256::from(buy_amount),
-                ..Default::default()
-            },
-            metadata: OrderMetadata {
-                class: OrderClass::Limit,
+        let order = |sell_amount: u8, buy_amount: u8| {
+            Arc::new(Order {
+                data: OrderData {
+                    sell_token,
+                    sell_amount: alloy::primitives::U256::from(sell_amount),
+                    buy_token,
+                    buy_amount: alloy::primitives::U256::from(buy_amount),
+                    ..Default::default()
+                },
+                metadata: OrderMetadata {
+                    class: OrderClass::Limit,
+                    ..Default::default()
+                },
                 ..Default::default()
-            },
-            ..Default::default()
+            })
         };
 
         let valid_orders = vec![
@@ -1251,7 +1288,7 @@ mod tests {
         );
 
         let mut order = order(10, 21);
-        order.data.partially_fillable = true;
+        Arc::make_mut(&mut order).data.partially_fillable = true;
         let orders = vec![order];
         assert_eq!(
             filter_mispriced_limit_orders(orders, &prices, &price_factor).len(),
@@ -1264,7 +1301,7 @@ mod tests {
         let settlement_contract = Address::repeat_byte(1);
         let orders = vec![
             // enough balance for sell and fee
-            Order {
+            Arc::new(Order {
                 data: OrderData {
                     sell_token: Address::with_last_byte(2),
                     sell_amount: alloy::primitives::U256::ONE,
@@ -1273,9 +1310,9 @@ mod tests {
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
             // missing fee balance
-            Order {
+            Arc::new(Order {
                 data: OrderData {
                     sell_token: Address::with_last_byte(3),
                     sell_amount: alloy::primitives::U256::ONE,
@@ -1284,9 +1321,9 @@ mod tests {
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
             // at least 1 partially fillable balance
-            Order {
+            Arc::new(Order {
                 data: OrderData {
                     sell_token: Address::with_last_byte(4),
                     sell_amount: alloy::primitives::U256::from(2),
@@ -1295,9 +1332,9 @@ mod tests {
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
             // 0 partially fillable balance
-            Order {
+            Arc::new(Order {
                 data: OrderData {
                     sell_token: Address::with_last_byte(5),
                     sell_amount: alloy::primitives::U256::from(2),
@@ -1306,9 +1343,9 @@ mod tests {
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
             // considered flashloan order because of special receiver
-            Order {
+            Arc::new(Order {
                 data: OrderData {
                     sell_token: Address::with_last_byte(6),
                     sell_amount: alloy::primitives::U256::from(200),
@@ -1318,7 +1355,7 @@ mod tests {
                     ..Default::default()
                 },
                 ..Default::default()
-            },
+            }),
         ];
         let balances = [
             (Query::from_order(&orders[0]), U256::from(2)),
@@ -1346,7 +1383,7 @@ mod tests {
         let settlement_contract = Address::repeat_byte(1);
 
         // EIP-1271 order (should skip balance check)
-        let eip1271_order = Order {
+        let eip1271_order = Arc::new(Order {
             data: OrderData {
                 sell_token: Address::with_last_byte(7),
                 sell_amount: alloy::primitives::U256::from(10),
@@ -1360,12 +1397,12 @@ mod tests {
                 ..Default::default()
             },
             ..Default::default()
-        };
+        });
 
         // Order with wrappers in bypass set (should skip balance check)
         let wrapper_order_uid =
             OrderUid::from_parts(B256::repeat_byte(7), Address::repeat_byte(77), 7);
-        let wrapper_order = Order {
+        let wrapper_order = Arc::new(Order {
             data: OrderData {
                 sell_token: Address::with_last_byte(8),
                 sell_amount: alloy::primitives::U256::from(10),
@@ -1378,10 +1415,10 @@ mod tests {
                 ..Default::default()
             },
             ..Default::default()
-        };
+        });
 
         // Regular ECDSA order without wrappers (should be filtered)
-        let regular_order = Order {
+        let regular_order = Arc::new(Order {
             data: OrderData {
                 sell_token: Address::with_last_byte(9),
                 sell_amount: alloy::primitives::U256::from(10),
@@ -1394,7 +1431,7 @@ mod tests {
                 ..Default::default()
             },
             ..Default::default()
-        };
+        });
 
         let orders = vec![
             regular_order.clone(),

From 9b50da5606620e304a4109d02273ad5e79086d66 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 12:11:10 +0100
Subject: [PATCH 059/219] Skip tx simulation on endpoints that don't mine
 reverts (#4143)

# Description
Based on our logs it seems like simulating a tx before submission can
take up to 500ms. Since our submission logic know which mempool mines
reverting txs and which don't we can simply skip the simulation step
when the current mempool does not mine reverting txs.

# Changes
skip tx simulation (estimate_gas()) in mempools that don't mine
reverting txs (e.g. mevblocker).
---
 crates/driver/src/domain/mempools.rs | 34 ++++++++++++++++------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index b5928a4f5e..fb606842c8 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -105,22 +105,26 @@ impl Mempools {
         // The tx is simulated before submitting the solution to the competition, but a
         // delay between that and the actual execution can cause the simulation to be
         // invalid which doesn't make sense to submit to the mempool anymore.
-        if let Err(err) = self.ethereum.estimate_gas(tx.clone()).await {
-            if err.is_revert() {
-                tracing::info!(
-                    ?err,
-                    "settlement tx simulation reverted before submitting to the mempool"
-                );
-                return Err(Error::SimulationRevert {
-                    submitted_at_block: current_block,
-                    reverted_at_block: current_block,
-                });
-            } else {
-                tracing::warn!(
-                    ?err,
-                    "couldn't simulate tx before submitting to the mempool"
-                );
+        if mempool.reverts_can_get_mined() {
+            if let Err(err) = self.ethereum.estimate_gas(tx.clone()).await {
+                if err.is_revert() {
+                    tracing::info!(
+                        ?err,
+                        "settlement tx simulation reverted before submitting to the mempool"
+                    );
+                    return Err(Error::SimulationRevert {
+                        submitted_at_block: current_block,
+                        reverted_at_block: current_block,
+                    });
+                } else {
+                    tracing::warn!(
+                        ?err,
+                        "couldn't simulate tx before submitting to the mempool"
+                    );
+                }
             }
+        } else {
+            tracing::trace!("skipping tx simulation because mempool does not mine reverting txs");
         }
 
         // Fetch the nonce to avoid race conditions between concurrent

From 0c04766fa2d606c1ff9b908000b4549f159a1c6e Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 12:44:04 +0100
Subject: [PATCH 060/219] Remove price filtering from autopilot (#4148)

# Description
First PR in a series of small optimizations in the auction building
logic.

# Changes
removes filtering of orders based on the existing native prices
this feature was never enabled and with the stronger focus on filtering
as little as possible in the autopilot it should also not be enabled in
the future
---
 crates/autopilot/src/arguments.rs       |   7 --
 crates/autopilot/src/run.rs             |   3 -
 crates/autopilot/src/solvable_orders.rs | 109 ------------------------
 3 files changed, 119 deletions(-)

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 3057f514a0..410f8dba11 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -135,11 +135,6 @@ pub struct Arguments {
     )]
     pub max_auction_age: Duration,
 
-    /// Used to filter out limit orders with prices that are too far from the
-    /// market price. 0 means no filtering.
-    #[clap(long, env, default_value = "0")]
-    pub limit_order_price_factor: f64,
-
     /// The URL of a list of tokens our settlement contract is willing to
     /// internalize.
     #[clap(long, env)]
@@ -315,7 +310,6 @@ impl std::fmt::Display for Arguments {
             banned_users,
             banned_users_max_cache_size,
             max_auction_age,
-            limit_order_price_factor,
             trusted_tokens_url,
             trusted_tokens,
             trusted_tokens_update_interval,
@@ -375,7 +369,6 @@ impl std::fmt::Display for Arguments {
             "banned_users_max_cache_size: {banned_users_max_cache_size:?}"
         )?;
         writeln!(f, "max_auction_age: {max_auction_age:?}")?;
-        writeln!(f, "limit_order_price_factor: {limit_order_price_factor:?}")?;
         display_option(f, "trusted_tokens_url", trusted_tokens_url)?;
         writeln!(f, "trusted_tokens: {trusted_tokens:?}")?;
         writeln!(
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 0235ad4036..8a57ee6233 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -524,9 +524,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         bad_token_detector.clone(),
         competition_native_price_updater.clone(),
         *eth.contracts().weth().address(),
-        args.limit_order_price_factor
-            .try_into()
-            .expect("limit order price factor can't be converted to BigDecimal"),
         domain::ProtocolFees::new(
             &args.fee_policies_config,
             args.shared.volume_fee_bucket_overrides.clone(),
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 22db019b77..d8ea74a8dd 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -6,7 +6,6 @@ use {
     },
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result},
-    bigdecimal::BigDecimal,
     database::order_events::OrderEventLabel,
     futures::{FutureExt, future::join_all},
     itertools::Itertools,
@@ -15,7 +14,6 @@ use {
         signature::Signature,
         time::now_in_epoch_seconds,
     },
-    number::conversions::u256_to_big_decimal,
     prometheus::{Histogram, HistogramVec, IntCounter, IntCounterVec, IntGauge, IntGaugeVec},
     shared::{
         account_balances::{BalanceFetching, Query},
@@ -92,7 +90,6 @@ pub struct SolvableOrdersCache {
     native_price_estimator: Arc<NativePriceUpdater>,
     metrics: &'static Metrics,
     weth: Address,
-    limit_order_price_factor: BigDecimal,
     protocol_fees: domain::ProtocolFees,
     cow_amm_registry: cow_amm::Registry,
     native_price_timeout: Duration,
@@ -118,7 +115,6 @@ impl SolvableOrdersCache {
         bad_token_detector: Arc<dyn BadTokenDetecting>,
         native_price_estimator: Arc<NativePriceUpdater>,
         weth: Address,
-        limit_order_price_factor: BigDecimal,
         protocol_fees: domain::ProtocolFees,
         cow_amm_registry: cow_amm::Registry,
         native_price_timeout: Duration,
@@ -136,7 +132,6 @@ impl SolvableOrdersCache {
             native_price_estimator,
             metrics,
             weth,
-            limit_order_price_factor,
             protocol_fees,
             cow_amm_registry,
             native_price_timeout,
@@ -259,10 +254,6 @@ impl SolvableOrdersCache {
         let removed = counter.checkpoint("missing_price", &orders);
         filtered_order_events.extend(removed);
 
-        let orders = filter_mispriced_limit_orders(orders, &prices, &self.limit_order_price_factor);
-        let removed = counter.checkpoint("out_of_market", &orders);
-        filtered_order_events.extend(removed);
-
         let removed = counter.record(&orders);
         filtered_order_events.extend(removed);
 
@@ -666,45 +657,6 @@ async fn find_unsupported_tokens(
         .collect()
 }
 
-/// Filter out limit orders which are far enough outside the estimated native
-/// token price.
-fn filter_mispriced_limit_orders(
-    mut orders: Vec<Arc<Order>>,
-    prices: &BTreeMap<Address, alloy::primitives::U256>,
-    price_factor: &BigDecimal,
-) -> Vec<Arc<Order>> {
-    orders.retain(|order| {
-        if !order.is_limit_order() {
-            return true;
-        }
-
-        let sell_price = *prices.get(&order.data.sell_token).unwrap();
-        let buy_price = *prices.get(&order.data.buy_token).unwrap();
-
-        // Convert the sell and buy price to the native token (ETH) and make sure that
-        // sell is higher than buy with the configurable price factor.
-        let (sell_native, buy_native) = match (
-            order.data.sell_amount.checked_mul(sell_price),
-            order.data.buy_amount.checked_mul(buy_price),
-        ) {
-            (Some(sell), Some(buy)) => (sell, buy),
-            _ => {
-                tracing::warn!(
-                    order_uid = %order.metadata.uid,
-                    "limit order overflow computing native amounts",
-                );
-                return false;
-            }
-        };
-
-        let sell_native = u256_to_big_decimal(&sell_native);
-        let buy_native = u256_to_big_decimal(&buy_native);
-
-        sell_native >= buy_native * price_factor
-    });
-    orders
-}
-
 /// Order filtering state for recording filtered orders over the course of
 /// building an auction.
 struct OrderFilterCounter {
@@ -1235,67 +1187,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn filters_mispriced_orders() {
-        let sell_token = Address::repeat_byte(1);
-        let buy_token = Address::repeat_byte(2);
-
-        // Prices are set such that 1 sell token is equivalent to 2 buy tokens.
-        // Additionally, they are scaled to large values to allow for overflows.
-        let prices = btreemap! {
-            sell_token => alloy::primitives::U256::MAX / alloy::primitives::U256::from(100),
-            buy_token => alloy::primitives::U256::MAX / alloy::primitives::U256::from(200),
-        };
-        let price_factor = "0.95".parse().unwrap();
-
-        let order = |sell_amount: u8, buy_amount: u8| {
-            Arc::new(Order {
-                data: OrderData {
-                    sell_token,
-                    sell_amount: alloy::primitives::U256::from(sell_amount),
-                    buy_token,
-                    buy_amount: alloy::primitives::U256::from(buy_amount),
-                    ..Default::default()
-                },
-                metadata: OrderMetadata {
-                    class: OrderClass::Limit,
-                    ..Default::default()
-                },
-                ..Default::default()
-            })
-        };
-
-        let valid_orders = vec![
-            // Reasonably priced order, doesn't get filtered.
-            order(100, 200),
-            // Slightly out of price order, doesn't get filtered.
-            order(10, 21),
-        ];
-
-        let invalid_orders = vec![
-            // Out of price order gets filtered out.
-            order(10, 100),
-            // Overflow sell value gets filtered.
-            order(255, 1),
-            // Overflow buy value gets filtered.
-            order(100, 255),
-        ];
-
-        let orders = [valid_orders.clone(), invalid_orders].concat();
-        assert_eq!(
-            filter_mispriced_limit_orders(orders, &prices, &price_factor),
-            valid_orders,
-        );
-
-        let mut order = order(10, 21);
-        Arc::make_mut(&mut order).data.partially_fillable = true;
-        let orders = vec![order];
-        assert_eq!(
-            filter_mispriced_limit_orders(orders, &prices, &price_factor).len(),
-            1
-        );
-    }
-
     #[test]
     fn orders_with_balance_() {
         let settlement_contract = Address::repeat_byte(1);

From 80f1b6985e4ca21746bf3e4ef38553079ed382b0 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 15:10:39 +0100
Subject: [PATCH 061/219] Speed up removing old orders and quotes (#4151)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
The incremental solvable orders query so far blindly inserted updated
orders in to the set of open orders and then ran a filtering step over
ALL open orders and quotes separately.
This is pretty wasteful since the new/updated orders are significantly
fewer than the set of ALL orders and 3 of 4 things we check we only need
to check on the new/updated orders.
Also we don't have to go over ALL quotes if we just remove the quotes
together with the orders.

# Changes
- determine whether to insert or remove orders based on the new
information returned by the incremental DB query
- whenever we remove an order we also remove the associated quote to
never run do a `.retain()` on ALL quotes
- still do a `.retain()` on the open orders to find expired orders as
the incremental orders query will not flag those - while we still scan
the whole list twice the most complicated checks could be moved to the
part that only runs on the updated orders so this `.retain()` still is a
lot faster than before.

## How to test
Measured performance with tempo
Retain orders went from 2.5ms to 283µs
and we dropped the 6.6ms from retaining quotes completely

Before
<img width="1298" height="298" alt="Screenshot 2026-02-13 at 08 13 38"
src="https://github.com/user-attachments/assets/fd375cf9-851b-4a67-be36-4dae00c49461"
/>

After
<img width="1333" height="271" alt="Screenshot 2026-02-13 at 08 13 24"
src="https://github.com/user-attachments/assets/2feabd4c-64fa-4b49-ab1b-8bedb42d9711"
/>
---
 crates/autopilot/src/infra/persistence/mod.rs | 41 +++++++++++--------
 1 file changed, 25 insertions(+), 16 deletions(-)

diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index b6980c749a..bf5f610a9d 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -612,20 +612,9 @@ impl Persistence {
             .to_u64()
             .context("latest_settlement_block is not u64")?;
 
-        // Blindly insert all new orders into the cache.
+        // Insert new / updated orders or remove invalidated orders
+        // and the associated quote.
         for (uid, order) in next_orders {
-            current_orders.insert(uid, order);
-        }
-
-        // Filter out all the invalid orders.
-        current_orders.retain(|_uid, order| {
-            let expired = order.data.valid_to < min_valid_to
-                || order
-                    .metadata
-                    .ethflow_data
-                    .as_ref()
-                    .is_some_and(|data| data.user_valid_to < i64::from(min_valid_to));
-
             let invalidated = order.metadata.invalidated;
             let onchain_error = order
                 .metadata
@@ -645,10 +634,30 @@ impl Persistence {
                 }
             };
 
-            !expired && !invalidated && !onchain_error && !fulfilled
-        });
+            if invalidated || onchain_error || fulfilled {
+                current_orders.remove(&uid);
+                current_quotes.remove(&uid);
+            } else {
+                current_orders.insert(uid, order);
+            }
+        }
+
+        // Filter out all the expired orders and their quotes.
+        current_orders.retain(|uid, order| {
+            let expired = order.data.valid_to < min_valid_to
+                || order
+                    .metadata
+                    .ethflow_data
+                    .as_ref()
+                    .is_some_and(|data| data.user_valid_to < i64::from(min_valid_to));
 
-        current_quotes.retain(|uid, _| current_orders.contains_key(uid));
+            if expired {
+                current_quotes.remove(uid);
+                false
+            } else {
+                true
+            }
+        });
 
         {
             let _timer = Metrics::get()

From d2d7e4fc991f14005cfbd4048b4d990684603033 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 16:45:31 +0100
Subject: [PATCH 062/219] Speed up auction metrics (#4155)

# Description
A surprisingly big amount of time in the auction building process is
wasted with metrics.
By far the biggest offender is the function `checkpoint()` which figures
out which orders got filtered out since the last checkpoint. It does it
by cloning the currently alive orders and removing the still alive
orders from that map one by one. All the orders that are left over are
no longer alive.
This regularly incurs an overhead of a couple milliseconds each while
the alternative function `checkpoint_by_invalid_orders()` (which gets
the removed orders passed in) only takes a few microseconds.

Additionally constructing the an `OrderFilterCounter` also take ~5ms
because it clones the original set of orders and counts them already
there.

<img width="1649" height="682" alt="Screenshot 2026-02-13 at 12 29 01"
src="https://github.com/user-attachments/assets/076c6366-d6c5-4376-80a7-222a377812a3"
/>

# Changes
- drop `OrderFilterCounter` in favor of function on the metrics
- from all functions return a list of filtered orders such that we don't
have to do a ton of computations to diff the orders before and after a
filter function
- fixed resulting compile errors in the tests

This technically introduces breaking changes but IMO those are well
worth it:
* we don't populate the gauges once at the start of the process and once
at the end - instead we update individual gauges as we go
* some orders can **technically** be double counted. Since filtering for
banned users, unsupported tokens and invalid signatures happens in
parallel and happens separately the same order can be counted for
multiple things. The orders filtered that way are relatively few and
having the chance that orders fit multiple categories is even lower. On
the plus side if there are multiple things wrong with an order we now
learn about it. Since the exact numbers of filtered orders are not super
interesting anyway one can even consider this a debugging improvement.
---
 crates/autopilot/src/solvable_orders.rs | 301 ++++++++++--------------
 1 file changed, 118 insertions(+), 183 deletions(-)

diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index d8ea74a8dd..2d427cd15f 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -74,6 +74,45 @@ pub struct Metrics {
     auction_market_order_missing_price: IntGauge,
 }
 
+impl Metrics {
+    fn get() -> &'static Self {
+        Metrics::instance(observe::metrics::get_storage_registry()).unwrap()
+    }
+
+    fn track_filtered_orders(reason: &'static str, invalid_orders: &[OrderUid]) {
+        if invalid_orders.is_empty() {
+            return;
+        }
+
+        Metrics::get()
+            .auction_filtered_orders
+            .with_label_values(&[reason])
+            .set(i64::try_from(invalid_orders.len()).unwrap_or(i64::MAX));
+
+        tracing::debug!(
+            %reason,
+            count = invalid_orders.len(),
+            orders = ?invalid_orders, "filtered orders"
+        );
+    }
+
+    fn track_orders_in_final_auction(orders: &[Arc<Order>]) {
+        let metrics = Metrics::get();
+        metrics.auction_creations.inc();
+
+        let remaining_counts = orders
+            .iter()
+            .counts_by(|order| order.metadata.class.as_ref());
+        for class in OrderClass::VARIANTS {
+            let count = remaining_counts.get(class).copied().unwrap_or_default();
+            metrics
+                .auction_solvable_orders
+                .with_label_values(&[class])
+                .set(i64::try_from(count).unwrap_or(i64::MAX));
+        }
+    }
+}
+
 /// Keeps track and updates the set of currently solvable orders.
 /// For this we also need to keep track of user sell token balances for open
 /// orders so this is retrievable as well.
@@ -88,7 +127,6 @@ pub struct SolvableOrdersCache {
     bad_token_detector: Arc<dyn BadTokenDetecting>,
     cache: Mutex<Option<Inner>>,
     native_price_estimator: Arc<NativePriceUpdater>,
-    metrics: &'static Metrics,
     weth: Address,
     protocol_fees: domain::ProtocolFees,
     cow_amm_registry: cow_amm::Registry,
@@ -121,7 +159,6 @@ impl SolvableOrdersCache {
         settlement_contract: Address,
         disable_order_balance_filter: bool,
     ) -> Arc<Self> {
-        let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
         Arc::new(Self {
             min_order_validity_period,
             persistence,
@@ -130,7 +167,6 @@ impl SolvableOrdersCache {
             bad_token_detector,
             cache: Mutex::new(None),
             native_price_estimator,
-            metrics,
             weth,
             protocol_fees,
             cow_amm_registry,
@@ -170,7 +206,6 @@ impl SolvableOrdersCache {
             .cloned()
             .collect::<Vec<_>>();
 
-        let mut counter = OrderFilterCounter::new(self.metrics, &orders);
         let mut invalid_order_uids = HashSet::new();
         let mut filtered_order_events = Vec::new();
 
@@ -192,7 +227,7 @@ impl SolvableOrdersCache {
                 .collect::<Vec<_>>();
             tokio::join!(
                 self.fetch_balances(queries),
-                self.filter_invalid_orders(orders, &mut counter, &mut invalid_order_uids,),
+                self.filter_invalid_orders(orders, &mut invalid_order_uids),
                 self.timed_future("cow_amm_registry", self.cow_amm_registry.amms()),
             )
         };
@@ -200,17 +235,17 @@ impl SolvableOrdersCache {
         let orders = if self.disable_order_balance_filter {
             orders
         } else {
-            let orders = orders_with_balance(
+            let (orders, removed) = orders_with_balance(
                 orders,
                 &balances,
                 self.settlement_contract,
                 &balance_filter_exempt_orders,
             );
-            let removed = counter.checkpoint("insufficient_balance", &orders);
+            Metrics::track_filtered_orders("insufficient_balance", &removed);
             invalid_order_uids.extend(removed);
 
-            let orders = filter_dust_orders(orders, &balances);
-            let removed = counter.checkpoint("dust_order", &orders);
+            let (orders, removed) = filter_dust_orders(orders, &balances);
+            Metrics::track_filtered_orders("dust_order", &removed);
             filtered_order_events.extend(removed);
 
             orders
@@ -222,13 +257,12 @@ impl SolvableOrdersCache {
             .collect::<Vec<_>>();
 
         // create auction
-        let (orders, mut prices) = self
+        let (orders, removed, mut prices) = self
             .timed_future(
                 "get_orders_with_native_prices",
                 get_orders_with_native_prices(
                     orders,
                     &self.native_price_estimator,
-                    self.metrics,
                     cow_amm_tokens,
                     self.native_price_timeout,
                 ),
@@ -250,12 +284,10 @@ impl SolvableOrdersCache {
 
             entry.insert(weth_price);
         }
-
-        let removed = counter.checkpoint("missing_price", &orders);
+        Metrics::track_filtered_orders("missing_price", &removed);
         filtered_order_events.extend(removed);
 
-        let removed = counter.record(&orders);
-        filtered_order_events.extend(removed);
+        Metrics::track_orders_in_final_auction(&orders);
 
         if store_events {
             // spawning a background task since `order_events` table insert operation takes
@@ -320,7 +352,7 @@ impl SolvableOrdersCache {
         });
 
         tracing::debug!(%block, "updated current auction cache");
-        self.metrics
+        Metrics::get()
             .auction_update_total_time
             .observe(start.elapsed().as_secs_f64());
         Ok(())
@@ -396,7 +428,6 @@ impl SolvableOrdersCache {
     async fn filter_invalid_orders(
         &self,
         mut orders: Vec<Arc<Order>>,
-        counter: &mut OrderFilterCounter,
         invalid_order_uids: &mut HashSet<OrderUid>,
     ) -> Vec<Arc<Order>> {
         let presignature_pending_orders = find_presignature_pending_orders(&orders);
@@ -413,9 +444,9 @@ impl SolvableOrdersCache {
         );
         tracing::trace!("filtered invalid orders");
 
-        counter.checkpoint_by_invalid_orders("banned_user", &banned_user_orders);
-        counter.checkpoint_by_invalid_orders("invalid_signature", &presignature_pending_orders);
-        counter.checkpoint_by_invalid_orders("unsupported_token", &unsupported_token_orders);
+        Metrics::track_filtered_orders("banned_user", &banned_user_orders);
+        Metrics::track_filtered_orders("invalid_signature", &presignature_pending_orders);
+        Metrics::track_filtered_orders("unsupported_token", &unsupported_token_orders);
         invalid_order_uids.extend(banned_user_orders);
         invalid_order_uids.extend(presignature_pending_orders);
         invalid_order_uids.extend(unsupported_token_orders);
@@ -425,7 +456,7 @@ impl SolvableOrdersCache {
     }
 
     pub fn track_auction_update(&self, result: &str) {
-        self.metrics
+        Metrics::get()
             .auction_update
             .with_label_values(&[result])
             .inc();
@@ -433,8 +464,7 @@ impl SolvableOrdersCache {
 
     /// Runs the future and collects runtime metrics.
     async fn timed_future<T>(&self, label: &str, fut: impl Future<Output = T>) -> T {
-        let _timer = self
-            .metrics
+        let _timer = Metrics::get()
             .auction_update_stage_time
             .with_label_values(&[label])
             .start_timer();
@@ -504,10 +534,11 @@ fn orders_with_balance(
     balances: &Balances,
     settlement_contract: Address,
     filter_bypass_orders: &HashSet<OrderUid>,
-) -> Vec<Arc<Order>> {
+) -> (Vec<Arc<Order>>, Vec<OrderUid>) {
     // Prefer newer orders over older ones.
     orders.sort_by_key(|order| std::cmp::Reverse(order.metadata.creation_date));
-    orders.retain(|order| {
+    let mut filtered_orders = vec![];
+    let keep = |order: &Order| {
         // Skip balance check for all EIP-1271 orders (they can rely on pre-interactions
         // to unlock funds) or orders with wrappers (wrappers produce the required
         // balance at settlement time).
@@ -540,14 +571,27 @@ fn orders_with_balance(
             Some(balance) => balance,
         };
         balance >= needed_balance
+    };
+
+    orders.retain(|order| {
+        if keep(order) {
+            true
+        } else {
+            filtered_orders.push(order.metadata.uid);
+            false
+        }
     });
-    orders
+    (orders, filtered_orders)
 }
 
 /// Filters out dust orders i.e. partially fillable orders that, when scaled
 /// have a 0 buy or sell amount.
-fn filter_dust_orders(mut orders: Vec<Arc<Order>>, balances: &Balances) -> Vec<Arc<Order>> {
-    orders.retain(|order| {
+fn filter_dust_orders(
+    mut orders: Vec<Arc<Order>>,
+    balances: &Balances,
+) -> (Vec<Arc<Order>>, Vec<OrderUid>) {
+    let mut removed = vec![];
+    let keep = |order: &Order| {
         if !order.data.partially_fillable {
             return true;
         }
@@ -559,7 +603,7 @@ fn filter_dust_orders(mut orders: Vec<Arc<Order>>, balances: &Balances) -> Vec<A
         };
 
         let Ok(remaining) =
-            remaining_amounts::Remaining::from_order_with_balance(&order.as_ref().into(), balance)
+            remaining_amounts::Remaining::from_order_with_balance(&order.into(), balance)
         else {
             return false;
         };
@@ -572,17 +616,29 @@ fn filter_dust_orders(mut orders: Vec<Arc<Order>>, balances: &Balances) -> Vec<A
         };
 
         !sell_amount.is_zero() && !buy_amount.is_zero()
+    };
+
+    orders.retain(|order| {
+        if keep(order) {
+            true
+        } else {
+            removed.push(order.metadata.uid);
+            false
+        }
     });
-    orders
+    (orders, removed)
 }
 
 async fn get_orders_with_native_prices(
     orders: Vec<Arc<Order>>,
     native_price_estimator: &NativePriceUpdater,
-    metrics: &Metrics,
     additional_tokens: impl IntoIterator<Item = Address>,
     timeout: Duration,
-) -> (Vec<Arc<Order>>, BTreeMap<Address, alloy::primitives::U256>) {
+) -> (
+    Vec<Arc<Order>>,
+    Vec<OrderUid>,
+    BTreeMap<Address, alloy::primitives::U256>,
+) {
     let traded_tokens = orders
         .iter()
         .flat_map(|order| [order.data.sell_token, order.data.buy_token])
@@ -592,24 +648,26 @@ async fn get_orders_with_native_prices(
     let prices = get_native_prices(traded_tokens, native_price_estimator, timeout).await;
 
     // Filter orders so that we only return orders that have prices
-    let mut filtered_market_orders = 0_i64;
+    let mut removed_market_orders = 0_i64;
+    let mut removed_orders = vec![];
     let mut orders = orders;
     orders.retain(|order| {
-        let (t0, t1) = (&order.data.sell_token, &order.data.buy_token);
-        match (prices.get(t0), prices.get(t1)) {
-            (Some(_), Some(_)) => true,
-            _ => {
-                filtered_market_orders += i64::from(order.metadata.class == OrderClass::Market);
-                false
-            }
+        let both_prices_present = prices.contains_key(&order.data.sell_token)
+            && prices.contains_key(&order.data.buy_token);
+        if both_prices_present {
+            true
+        } else {
+            removed_orders.push(order.metadata.uid);
+            removed_market_orders += i64::from(order.metadata.class == OrderClass::Market);
+            false
         }
     });
 
-    metrics
+    Metrics::get()
         .auction_market_order_missing_price
-        .set(filtered_market_orders);
+        .set(removed_market_orders);
 
-    (orders, prices)
+    (orders, removed_orders, prices)
 }
 
 async fn find_unsupported_tokens(
@@ -657,119 +715,6 @@ async fn find_unsupported_tokens(
         .collect()
 }
 
-/// Order filtering state for recording filtered orders over the course of
-/// building an auction.
-struct OrderFilterCounter {
-    metrics: &'static Metrics,
-
-    /// Mapping of remaining order UIDs to their classes.
-    orders: HashMap<OrderUid, OrderClass>,
-    /// Running tally for counts of filtered orders.
-    counts: HashMap<Reason, usize>,
-}
-
-type Reason = &'static str;
-
-impl OrderFilterCounter {
-    fn new(metrics: &'static Metrics, orders: &[Arc<Order>]) -> Self {
-        // Eagerly store the candidate orders. This ensures that that gauge is
-        // always up to date even if there are errors in the auction building
-        // process.
-        let initial_counts = orders
-            .iter()
-            .counts_by(|order| order.metadata.class.as_ref());
-        for class in OrderClass::VARIANTS {
-            let count = initial_counts.get(class).copied().unwrap_or_default();
-            metrics
-                .auction_candidate_orders
-                .with_label_values(&[class])
-                .set(i64::try_from(count).unwrap_or(i64::MAX));
-        }
-
-        Self {
-            metrics,
-            orders: orders
-                .iter()
-                .map(|order| (order.metadata.uid, order.metadata.class))
-                .collect(),
-            counts: HashMap::new(),
-        }
-    }
-
-    /// Creates a new checkpoint from the current remaining orders.
-    fn checkpoint(&mut self, reason: Reason, orders: &[Arc<Order>]) -> Vec<OrderUid> {
-        let filtered_orders = orders
-            .iter()
-            .fold(self.orders.clone(), |mut order_uids, order| {
-                order_uids.remove(&order.metadata.uid);
-                order_uids
-            });
-
-        *self.counts.entry(reason).or_default() += filtered_orders.len();
-        for order_uid in filtered_orders.keys() {
-            self.orders.remove(order_uid).unwrap();
-        }
-        if !filtered_orders.is_empty() {
-            tracing::debug!(
-                %reason,
-                count = filtered_orders.len(),
-                orders = ?filtered_orders, "filtered orders"
-            );
-        }
-        filtered_orders.into_keys().collect()
-    }
-
-    /// Creates a new checkpoint based on the found invalid orders.
-    fn checkpoint_by_invalid_orders(&mut self, reason: Reason, invalid_orders: &[OrderUid]) {
-        if invalid_orders.is_empty() {
-            return;
-        }
-
-        let mut counter = 0;
-        for order_uid in invalid_orders {
-            if self.orders.remove(order_uid).is_some() {
-                counter += 1;
-            }
-        }
-        *self.counts.entry(reason).or_default() += counter;
-        if counter > 0 {
-            tracing::debug!(
-                %reason,
-                count = invalid_orders.len(),
-                orders = ?invalid_orders, "filtered orders"
-            );
-        }
-    }
-
-    /// Records the filter counter to metrics.
-    /// If there are orders that have been filtered out since the last
-    /// checkpoint these orders will get recorded with the readon "other".
-    /// Returns these catch-all orders.
-    fn record(mut self, orders: &[Arc<Order>]) -> Vec<OrderUid> {
-        let removed = self.checkpoint("other", orders);
-
-        self.metrics.auction_creations.inc();
-
-        let remaining_counts = self.orders.iter().counts_by(|(_, class)| class.as_ref());
-        for class in OrderClass::VARIANTS {
-            let count = remaining_counts.get(class).copied().unwrap_or_default();
-            self.metrics
-                .auction_solvable_orders
-                .with_label_values(&[class])
-                .set(i64::try_from(count).unwrap_or(i64::MAX));
-        }
-
-        for (reason, count) in self.counts {
-            self.metrics
-                .auction_filtered_orders
-                .with_label_values(&[reason])
-                .set(i64::try_from(count).unwrap_or(i64::MAX));
-        }
-
-        removed
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use {
@@ -845,12 +790,10 @@ mod tests {
         );
         let native_price_estimator =
             NativePriceUpdater::new(caching_estimator, Duration::MAX, Default::default());
-        let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
-        let (filtered_orders, prices) = get_orders_with_native_prices(
+        let (filtered_orders, _removed, prices) = get_orders_with_native_prices(
             orders.clone(),
             &native_price_estimator,
-            metrics,
             vec![],
             Duration::from_millis(100),
         )
@@ -947,35 +890,32 @@ mod tests {
             Duration::from_millis(5),
             Default::default(),
         );
-        let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
         // We'll have no native prices in this call. But set_tokens_to_update
         // will cause the background task to fetch them in the next cycle.
-        let (filtered_orders, prices) = get_orders_with_native_prices(
+        let (alive_orders, _removed_orders, prices) = get_orders_with_native_prices(
             orders.clone(),
             &native_price_estimator,
-            metrics,
             vec![token5],
             Duration::ZERO,
         )
         .await;
-        assert!(filtered_orders.is_empty());
+        assert!(alive_orders.is_empty());
         assert!(prices.is_empty());
 
         // Wait for native prices to get fetched by the background task.
         tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
 
         // Now we have all the native prices we want.
-        let (filtered_orders, prices) = get_orders_with_native_prices(
+        let (alive_orders, _removed_orders, prices) = get_orders_with_native_prices(
             orders.clone(),
             &native_price_estimator,
-            metrics,
             vec![token5],
             Duration::ZERO,
         )
         .await;
 
-        assert_eq!(filtered_orders, [orders[2].clone()]);
+        assert_eq!(alive_orders, [orders[2].clone()]);
         assert_eq!(
             prices,
             btreemap! {
@@ -1053,17 +993,15 @@ mod tests {
         );
         let native_price_estimator =
             NativePriceUpdater::new(caching_estimator, Duration::MAX, Default::default());
-        let metrics = Metrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
-        let (filtered_orders, prices) = get_orders_with_native_prices(
+        let (alive_orders, _removed_orders, prices) = get_orders_with_native_prices(
             orders.clone(),
             &native_price_estimator,
-            metrics,
             vec![],
             Duration::from_secs(10),
         )
         .await;
-        assert_eq!(filtered_orders, orders);
+        assert_eq!(alive_orders, orders);
         assert_eq!(
             prices,
             btreemap! {
@@ -1260,11 +1198,11 @@ mod tests {
         let expected = &[0, 2, 4];
 
         let no_bypass: HashSet<OrderUid> = HashSet::new();
-        let filtered =
+        let (alive_orders, _removed_orders) =
             orders_with_balance(orders.clone(), &balances, settlement_contract, &no_bypass);
-        assert_eq!(filtered.len(), expected.len());
+        assert_eq!(alive_orders.len(), expected.len());
         for index in expected {
-            let found = filtered.iter().any(|o| o.data == orders[*index].data);
+            let found = alive_orders.iter().any(|o| o.data == orders[*index].data);
             assert!(found, "{}", index);
         }
     }
@@ -1333,28 +1271,25 @@ mod tests {
 
         // EIP-1271 order and wrapper order should be retained, regular order filtered
         let wrapper_set = HashSet::from([wrapper_order_uid]);
-        let filtered =
+        let (alive_orders, _removed_orders) =
             orders_with_balance(orders.clone(), &balances, settlement_contract, &wrapper_set);
-        assert_eq!(filtered.len(), 2);
+        assert_eq!(alive_orders.len(), 2);
         assert!(
-            filtered
+            alive_orders
                 .iter()
                 .any(|o| o.metadata.uid == eip1271_order.metadata.uid)
         );
         assert!(
-            filtered
+            alive_orders
                 .iter()
                 .any(|o| o.metadata.uid == wrapper_order.metadata.uid)
         );
 
         // Without wrapper set, only EIP-1271 order should be retained
         let empty_set: HashSet<OrderUid> = HashSet::new();
-        let filtered_no_wrappers =
+        let (alive_orders, _removed_orders) =
             orders_with_balance(orders, &balances, settlement_contract, &empty_set);
-        assert_eq!(filtered_no_wrappers.len(), 1);
-        assert_eq!(
-            filtered_no_wrappers[0].metadata.uid,
-            eip1271_order.metadata.uid
-        );
+        assert_eq!(alive_orders.len(), 1);
+        assert_eq!(alive_orders[0].metadata.uid, eip1271_order.metadata.uid);
     }
 }

From 95b5017e60de2379eee735af1731c676dc55be9f Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 18:00:49 +0100
Subject: [PATCH 063/219] Remove unused config options / features (#4156)

# Description
This started out as an investigation into speeding up deny-listed token
filtering in the auction building process but I realized that there is
still some unfinished work of migrating away from the tracing based bad
token detection.

We already moved away from that bad token detection mechanism a while
ago but I didn't fully delete all the related code yet in case the new
mechanism doesn't work well enough. Since then we've been running the
services without the feature for many months so it's time to remove that
stuff now.

We are deleting so much here because only the tracing detector was using
all the logic to find owners of certain tokens onchain so that also went
with it.
Once that was done I also went ahead and tried to find any other args
that are unused.

# Changes
- remove `tracing_url` parameter which made the tracing bad token
detector unused
- removed tracing detector which made token owner finding stuff unused
- removed token owner finding stuff which made liquidity source configs
unused
- removed any other args that weren't used

## How to test
compiler
---
 crates/autopilot/src/arguments.rs             |  13 -
 crates/autopilot/src/run.rs                   |  66 +-
 crates/e2e/src/setup/services.rs              |   2 -
 crates/orderbook/src/arguments.rs             |  25 +-
 crates/orderbook/src/run.rs                   |  62 +-
 crates/shared/src/arguments.rs                | 139 +----
 crates/shared/src/bad_token/cache.rs          | 216 -------
 crates/shared/src/bad_token/mod.rs            |   2 -
 .../token_owner_finder/blockscout.rs          | 172 -----
 .../bad_token/token_owner_finder/ethplorer.rs | 179 ------
 .../bad_token/token_owner_finder/liquidity.rs | 113 ----
 .../src/bad_token/token_owner_finder/mod.rs   | 590 ------------------
 .../token_owner_finder/solvers/mod.rs         |  13 -
 .../token_owner_finder/solvers/solver_api.rs  |  30 -
 .../solvers/solver_finder.rs                  | 154 -----
 .../token_owner_finder/token_owner_list.rs    |  52 --
 crates/shared/src/bad_token/trace_call.rs     | 499 +--------------
 17 files changed, 8 insertions(+), 2319 deletions(-)
 delete mode 100644 crates/shared/src/bad_token/cache.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/blockscout.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/ethplorer.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/liquidity.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/mod.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/solvers/mod.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/solvers/solver_api.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/solvers/solver_finder.rs
 delete mode 100644 crates/shared/src/bad_token/token_owner_finder/token_owner_list.rs

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 410f8dba11..689be1705b 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -6,7 +6,6 @@ use {
     clap::ValueEnum,
     shared::{
         arguments::{FeeFactor, display_list, display_option, display_secret_option},
-        bad_token::token_owner_finder,
         http_client,
         price_estimation::{self, NativePriceEstimators},
     },
@@ -31,9 +30,6 @@ pub struct Arguments {
     #[clap(flatten)]
     pub http_client: http_client::Arguments,
 
-    #[clap(flatten)]
-    pub token_owner_finder: token_owner_finder::Arguments,
-
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
@@ -54,11 +50,6 @@ pub struct Arguments {
     #[clap(long, env)]
     pub ethflow_indexing_start: Option<u64>,
 
-    /// A tracing Ethereum node URL to connect to, allowing a separate node URL
-    /// to be used exclusively for tracing calls.
-    #[clap(long, env)]
-    pub tracing_node_url: Option<Url>,
-
     #[clap(long, env, default_value = "0.0.0.0:9589")]
     pub metrics_address: SocketAddr,
 
@@ -293,10 +284,8 @@ impl std::fmt::Display for Arguments {
             shared,
             order_quoting,
             http_client,
-            token_owner_finder,
             price_estimation,
             database_pool,
-            tracing_node_url,
             ethflow_contracts,
             ethflow_indexing_start,
             metrics_address,
@@ -341,10 +330,8 @@ impl std::fmt::Display for Arguments {
         write!(f, "{shared}")?;
         write!(f, "{order_quoting}")?;
         write!(f, "{http_client}")?;
-        write!(f, "{token_owner_finder}")?;
         write!(f, "{price_estimation}")?;
         write!(f, "{database_pool}")?;
-        display_option(f, "tracing_node_url", tracing_node_url)?;
         writeln!(f, "ethflow_contracts: {ethflow_contracts:?}")?;
         writeln!(f, "ethflow_indexing_start: {ethflow_indexing_start:?}")?;
         writeln!(f, "metrics_address: {metrics_address}")?;
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 8a57ee6233..1bc6d4f40f 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -27,9 +27,8 @@ use {
     alloy::{eips::BlockNumberOrTag, primitives::Address, providers::Provider},
     chain::Chain,
     clap::Parser,
-    contracts::alloy::{BalancerV2Vault, GPv2Settlement, IUniswapV3Factory, WETH9},
+    contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
     ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
-    futures::StreamExt,
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::LivenessChecking,
@@ -37,11 +36,8 @@ use {
         account_balances::{self, BalanceSimulator},
         arguments::tracing_config,
         bad_token::{
-            cache::CachingDetector,
             instrumented::InstrumentedBadTokenDetectorExt,
             list_based::{ListBasedDetector, UnknownTokenStrategy},
-            token_owner_finder,
-            trace_call::TraceCallDetector,
         },
         baseline_solver::BaseTokens,
         code_fetching::CachedCodeFetcher,
@@ -51,7 +47,6 @@ use {
             factory::{self, PriceEstimatorFactory},
             native::NativePriceEstimating,
         },
-        sources::{BaselineSource, uniswap_v2::UniV2BaselineSourceParameters},
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
         token_list::{AutoUpdatingTokenList, TokenListConfiguration},
     },
@@ -240,14 +235,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         }
         addr
     });
-    let vault =
-        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.provider.clone()));
-
-    let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.provider)
-        .instrument(info_span!("uniswapv3_deployed"))
-        .await
-        .inspect_err(|err| tracing::warn!(%err, "error while fetching IUniswapV3Factory instance"))
-        .ok();
 
     let chain = Chain::try_from(chain_id).expect("incorrect chain ID");
 
@@ -275,27 +262,6 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .expect("failed to create gas price estimator"),
     );
 
-    let baseline_sources = args
-        .shared
-        .baseline_sources
-        .clone()
-        .unwrap_or_else(|| shared::sources::defaults_for_network(&chain));
-    tracing::info!(?baseline_sources, "using baseline sources");
-    let univ2_sources = baseline_sources
-        .iter()
-        .filter_map(|source: &BaselineSource| {
-            UniV2BaselineSourceParameters::from_baseline_source(*source, &chain_id.to_string())
-        })
-        .chain(args.shared.custom_univ2_baseline_sources.iter().copied());
-    let pair_providers: Vec<_> = futures::stream::iter(univ2_sources)
-        .then(|source: UniV2BaselineSourceParameters| {
-            let web3 = &web3;
-            async move { source.into_source(web3).await.unwrap().pair_provider }
-        })
-        .collect()
-        .instrument(info_span!("pair_providers"))
-        .await;
-
     let base_tokens = Arc::new(BaseTokens::new(
         *eth.contracts().weth().address(),
         &args.shared.base_tokens,
@@ -305,39 +271,11 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     allowed_tokens.push(model::order::BUY_ETH_ADDRESS);
     let unsupported_tokens = args.unsupported_tokens.clone();
 
-    let finder = token_owner_finder::init(
-        &args.token_owner_finder,
-        web3.clone(),
-        &chain,
-        &http_factory,
-        &pair_providers,
-        vault.as_ref(),
-        uniswapv3_factory.as_ref(),
-        &base_tokens,
-        *eth.contracts().settlement().address(),
-    )
-    .instrument(info_span!("token_owner_finder_init"))
-    .await
-    .expect("failed to initialize token owner finders");
-
-    let trace_call_detector = args.tracing_node_url.as_ref().map(|tracing_node_url| {
-        CachingDetector::new(
-            Box::new(TraceCallDetector::new(
-                shared::ethrpc::web3(&args.shared.ethrpc, tracing_node_url, "trace"),
-                *eth.contracts().settlement().address(),
-                finder,
-            )),
-            args.shared.token_quality_cache_expiry,
-            args.shared.token_quality_cache_prefetch_time,
-        )
-    });
     let bad_token_detector = Arc::new(
         ListBasedDetector::new(
             allowed_tokens,
             unsupported_tokens,
-            trace_call_detector
-                .map(|detector| UnknownTokenStrategy::Forward(detector))
-                .unwrap_or(UnknownTokenStrategy::Allow),
+            UnknownTokenStrategy::Allow,
         )
         .instrumented(),
     );
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 7e2b4afd04..74226f468f 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -157,9 +157,7 @@ impl<'a> Services<'a> {
 
     fn api_autopilot_solver_arguments(&self) -> impl Iterator<Item = String> + use<> {
         [
-            "--baseline-sources=None".to_string(),
             "--network-block-interval=1s".to_string(),
-            "--solver-competition-auth=super_secret_key".to_string(),
             format!(
                 "--settlement-contract-address={:?}",
                 self.contracts.gp_settlement.address()
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index a5dcad6de6..11273c5406 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -3,8 +3,7 @@ use {
     chrono::{DateTime, Utc},
     reqwest::Url,
     shared::{
-        arguments::{FeeFactor, display_option, display_secret_option},
-        bad_token::token_owner_finder,
+        arguments::{FeeFactor, display_secret_option},
         http_client,
         price_estimation::{self, NativePriceEstimators},
     },
@@ -22,20 +21,12 @@ pub struct Arguments {
     #[clap(flatten)]
     pub http_client: http_client::Arguments,
 
-    #[clap(flatten)]
-    pub token_owner_finder: token_owner_finder::Arguments,
-
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
     #[clap(flatten)]
     pub database_pool: shared::arguments::DatabasePoolConfig,
 
-    /// A tracing Ethereum node URL to connect to, allowing a separate node URL
-    /// to be used exclusively for tracing calls.
-    #[clap(long, env)]
-    pub tracing_node_url: Option<Url>,
-
     #[clap(long, env, default_value = "0.0.0.0:8080")]
     pub bind_address: SocketAddr,
 
@@ -115,11 +106,6 @@ pub struct Arguments {
     #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
     pub eip1271_skip_creation_validation: bool,
 
-    /// If solvable orders haven't been successfully updated in this many blocks
-    /// attempting to get them errors and our liveness check fails.
-    #[clap(long, env, default_value = "24")]
-    pub solvable_orders_max_update_age_blocks: u64,
-
     /// Max number of limit orders per user.
     #[clap(long, env, default_value = "10")]
     pub max_limit_orders_per_user: u64,
@@ -182,10 +168,8 @@ impl std::fmt::Display for Arguments {
             shared,
             order_quoting,
             http_client,
-            token_owner_finder,
             price_estimation,
             database_pool,
-            tracing_node_url,
             bind_address,
             min_order_validity_period,
             max_order_validity_period,
@@ -195,7 +179,6 @@ impl std::fmt::Display for Arguments {
             banned_users_max_cache_size,
             allowed_tokens,
             eip1271_skip_creation_validation,
-            solvable_orders_max_update_age_blocks,
             native_price_estimators,
             fast_price_estimation_results_required,
             max_limit_orders_per_user,
@@ -213,10 +196,8 @@ impl std::fmt::Display for Arguments {
         write!(f, "{shared}")?;
         write!(f, "{order_quoting}")?;
         write!(f, "{http_client}")?;
-        write!(f, "{token_owner_finder}")?;
         write!(f, "{price_estimation}")?;
         write!(f, "{database_pool}")?;
-        display_option(f, "tracing_node_url", tracing_node_url)?;
         writeln!(f, "bind_address: {bind_address}")?;
         let _intentionally_ignored = db_url;
         writeln!(f, "db_url: SECRET")?;
@@ -244,10 +225,6 @@ impl std::fmt::Display for Arguments {
             f,
             "eip1271_skip_creation_validation: {eip1271_skip_creation_validation}"
         )?;
-        writeln!(
-            f,
-            "solvable_orders_max_update_age_blocks: {solvable_orders_max_update_age_blocks}",
-        )?;
         writeln!(f, "native_price_estimators: {native_price_estimators}")?;
         writeln!(
             f,
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index e6f9fa0f42..5e353e3c33 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -18,11 +18,9 @@ use {
         ChainalysisOracle,
         GPv2Settlement,
         HooksTrampoline,
-        IUniswapV3Factory,
         WETH9,
         support::Balances,
     },
-    futures::StreamExt,
     model::{DomainSeparator, order::BUY_ETH_ADDRESS},
     num::ToPrimitive,
     observe::metrics::{DEFAULT_METRICS_PORT, serve_metrics},
@@ -31,11 +29,8 @@ use {
         account_balances::{self, BalanceSimulator},
         arguments::tracing_config,
         bad_token::{
-            cache::CachingDetector,
             instrumented::InstrumentedBadTokenDetectorExt,
             list_based::{ListBasedDetector, UnknownTokenStrategy},
-            token_owner_finder,
-            trace_call::TraceCallDetector,
         },
         baseline_solver::BaseTokens,
         code_fetching::CachedCodeFetcher,
@@ -50,7 +45,6 @@ use {
             native::NativePriceEstimating,
         },
         signature_validator,
-        sources::{self, BaselineSource, uniswap_v2::UniV2BaselineSourceParameters},
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     },
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
@@ -154,8 +148,6 @@ pub async fn run(args: Arguments) {
             }
         }
     });
-    let vault =
-        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.provider.clone()));
 
     let hooks_contract = match args.shared.hooks_contract_address {
         Some(address) => HooksTrampoline::Instance::new(address, web3.provider.clone()),
@@ -204,26 +196,6 @@ pub async fn run(args: Arguments) {
         .expect("failed to create gas price estimator"),
     ));
 
-    let baseline_sources = args
-        .shared
-        .baseline_sources
-        .clone()
-        .unwrap_or_else(|| sources::defaults_for_network(&chain));
-    tracing::info!(?baseline_sources, "using baseline sources");
-    let univ2_sources = baseline_sources
-        .iter()
-        .filter_map(|source: &BaselineSource| {
-            UniV2BaselineSourceParameters::from_baseline_source(*source, &chain_id.to_string())
-        })
-        .chain(args.shared.custom_univ2_baseline_sources.iter().copied());
-    let pair_providers: Vec<_> = futures::stream::iter(univ2_sources)
-        .then(|source: UniV2BaselineSourceParameters| {
-            let web3 = &web3;
-            async move { source.into_source(web3).await.unwrap().pair_provider }
-        })
-        .collect()
-        .await;
-
     let base_tokens = Arc::new(BaseTokens::new(
         *native_token.address(),
         &args.shared.base_tokens,
@@ -233,43 +205,11 @@ pub async fn run(args: Arguments) {
     allowed_tokens.push(BUY_ETH_ADDRESS);
     let unsupported_tokens = args.unsupported_tokens.clone();
 
-    let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.provider)
-        .await
-        .inspect_err(|err| tracing::warn!(%err, "error while fetching IUniswapV3Factory instance"))
-        .ok();
-
-    let finder = token_owner_finder::init(
-        &args.token_owner_finder,
-        web3.clone(),
-        &chain,
-        &http_factory,
-        &pair_providers,
-        vault.as_ref(),
-        uniswapv3_factory.as_ref(),
-        &base_tokens,
-        *settlement_contract.address(),
-    )
-    .await
-    .expect("failed to initialize token owner finders");
-
-    let trace_call_detector = args.tracing_node_url.as_ref().map(|tracing_node_url| {
-        CachingDetector::new(
-            Box::new(TraceCallDetector::new(
-                shared::ethrpc::web3(&args.shared.ethrpc, tracing_node_url, "trace"),
-                *settlement_contract.address(),
-                finder,
-            )),
-            args.shared.token_quality_cache_expiry,
-            args.shared.token_quality_cache_prefetch_time,
-        )
-    });
     let bad_token_detector = Arc::new(
         ListBasedDetector::new(
             allowed_tokens,
             unsupported_tokens,
-            trace_call_detector
-                .map(|detector| UnknownTokenStrategy::Forward(detector))
-                .unwrap_or(UnknownTokenStrategy::Allow),
+            UnknownTokenStrategy::Allow,
         )
         .instrumented(),
     );
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 9f9238f006..3474375cbb 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -2,18 +2,14 @@
 //! the binaries.
 
 use {
-    crate::{
-        gas_price_estimation::GasEstimatorType,
-        sources::{BaselineSource, uniswap_v2::UniV2BaselineSourceParameters},
-        tenderly_api,
-    },
+    crate::{gas_price_estimation::GasEstimatorType, tenderly_api},
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
     observe::TracingConfig,
     std::{
         collections::HashSet,
         fmt::{self, Display, Formatter},
-        num::{NonZeroU32, NonZeroU64},
+        num::NonZeroU32,
         str::FromStr,
         time::Duration,
     },
@@ -196,59 +192,6 @@ pub struct Arguments {
     #[clap(long, env, use_value_delimiter = true)]
     pub base_tokens: Vec<Address>,
 
-    /// Which Liquidity sources to be used by Price Estimator.
-    #[clap(long, env, value_enum, ignore_case = true, use_value_delimiter = true)]
-    pub baseline_sources: Option<Vec<BaselineSource>>,
-
-    /// List of non hardcoded univ2-like contracts.
-    ///
-    /// For example to add a univ2-like liquidity source the argument could be
-    /// set to
-    ///
-    /// 0x0000000000000000000000000000000000000001|0x0000000000000000000000000000000000000000000000000000000000000002
-    ///
-    /// which sets the router address to 0x01 and the init code digest to 0x02.
-    #[clap(long, env, value_enum, ignore_case = true, use_value_delimiter = true)]
-    pub custom_univ2_baseline_sources: Vec<UniV2BaselineSourceParameters>,
-
-    /// The number of blocks kept in the pool cache.
-    #[clap(long, env, default_value = "10")]
-    pub pool_cache_blocks: NonZeroU64,
-
-    /// The number of pairs that are automatically updated in the pool cache.
-    #[clap(long, env, default_value = "4")]
-    pub pool_cache_maximum_recent_block_age: u64,
-
-    /// How often to retry requests in the pool cache.
-    #[clap(long, env, default_value = "5")]
-    pub pool_cache_maximum_retries: u32,
-
-    /// How long to sleep in seconds between retries in the pool cache.
-    #[clap(long, env, default_value = "1s", value_parser = humantime::parse_duration)]
-    pub pool_cache_delay_between_retries: Duration,
-
-    /// If solvers should use internal buffers to improve solution quality.
-    #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
-    pub use_internal_buffers: bool,
-
-    /// Value of the authorization header for the solver competition post api.
-    #[clap(long, env)]
-    pub solver_competition_auth: Option<String>,
-
-    /// If liquidity pool fetcher has caching mechanism, this argument defines
-    /// how old pool data is allowed to be before updating
-    #[clap(
-        long,
-        env,
-        default_value = "30s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub liquidity_fetcher_max_age_update: Duration,
-
-    /// The number of pools to initially populate the UniswapV3 cache
-    #[clap(long, env, default_value = "100")]
-    pub max_pools_to_initialize_cache: usize,
-
     /// The time between new blocks on the network.
     #[clap(long, env, value_parser = humantime::parse_duration)]
     pub network_block_interval: Option<Duration>,
@@ -279,31 +222,6 @@ pub struct Arguments {
     #[clap(long, env)]
     pub balancer_v2_vault_address: Option<Address>,
 
-    /// The amount of time a classification of a token into good or
-    /// bad is valid for.
-    #[clap(
-        long,
-        env,
-        default_value = "10m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub token_quality_cache_expiry: Duration,
-
-    /// How long before expiry the token quality cache should try to update the
-    /// token quality in the background. This is useful to make sure that token
-    /// quality for every cached token is usable at all times. This value
-    /// has to be smaller than `token_quality_cache_expiry`
-    /// This configuration also affects the period of the token quality
-    /// maintenance job. Maintenance period =
-    /// `token_quality_cache_prefetch_time` / 2
-    #[clap(
-        long,
-        env,
-        default_value = "2m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub token_quality_cache_prefetch_time: Duration,
-
     /// Custom volume fees for token buckets.
     /// Format: "factor:token1;token2;..." (e.g.,
     /// "0:0xA0b86...;0x6B175...;0xdAC17...") Orders where BOTH tokens are
@@ -397,13 +315,6 @@ impl Display for Arguments {
             simulation_node_url,
             gas_estimators,
             base_tokens,
-            baseline_sources,
-            pool_cache_blocks,
-            pool_cache_maximum_recent_block_age,
-            pool_cache_maximum_retries,
-            pool_cache_delay_between_retries,
-            use_internal_buffers,
-            solver_competition_auth,
             network_block_interval,
             settlement_contract_address,
             balances_contract_address,
@@ -411,11 +322,6 @@ impl Display for Arguments {
             native_token_address,
             hooks_contract_address,
             balancer_v2_vault_address,
-            custom_univ2_baseline_sources,
-            liquidity_fetcher_max_age_update,
-            max_pools_to_initialize_cache,
-            token_quality_cache_expiry,
-            token_quality_cache_prefetch_time,
             tracing,
             volume_fee_bucket_overrides,
             enable_sell_equals_buy_volume_fee,
@@ -430,26 +336,6 @@ impl Display for Arguments {
         display_option(f, "simulation_node_url", simulation_node_url)?;
         writeln!(f, "gas_estimators: {gas_estimators:?}")?;
         writeln!(f, "base_tokens: {base_tokens:?}")?;
-        writeln!(f, "baseline_sources: {baseline_sources:?}")?;
-        writeln!(f, "pool_cache_blocks: {pool_cache_blocks}")?;
-        writeln!(
-            f,
-            "pool_cache_maximum_recent_block_age: {pool_cache_maximum_recent_block_age}"
-        )?;
-        writeln!(
-            f,
-            "pool_cache_maximum_retries: {pool_cache_maximum_retries}"
-        )?;
-        writeln!(
-            f,
-            "pool_cache_delay_between_retries: {pool_cache_delay_between_retries:?}"
-        )?;
-        writeln!(f, "use_internal_buffers: {use_internal_buffers}")?;
-        display_secret_option(
-            f,
-            "solver_competition_auth",
-            solver_competition_auth.as_ref(),
-        )?;
         display_option(
             f,
             "network_block_interval",
@@ -485,27 +371,6 @@ impl Display for Arguments {
             "balancer_v2_vault_address",
             &balancer_v2_vault_address.map(|a| format!("{a:?}")),
         )?;
-        display_list(
-            f,
-            "custom_univ2_baseline_sources",
-            custom_univ2_baseline_sources,
-        )?;
-        writeln!(
-            f,
-            "liquidity_fetcher_max_age_update: {liquidity_fetcher_max_age_update:?}"
-        )?;
-        writeln!(
-            f,
-            "max_pools_to_initialize_cache: {max_pools_to_initialize_cache}"
-        )?;
-        writeln!(
-            f,
-            "token_quality_cache_expiry: {token_quality_cache_expiry:?}"
-        )?;
-        writeln!(
-            f,
-            "token_quality_cache_prefetch_time: {token_quality_cache_prefetch_time:?}"
-        )?;
         write!(f, "{tracing:?}")?;
         writeln!(
             f,
diff --git a/crates/shared/src/bad_token/cache.rs b/crates/shared/src/bad_token/cache.rs
deleted file mode 100644
index 86743a33a3..0000000000
--- a/crates/shared/src/bad_token/cache.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-use {
-    super::{BadTokenDetecting, TokenQuality},
-    alloy::primitives::Address,
-    anyhow::Result,
-    dashmap::DashMap,
-    futures::future::join_all,
-    std::{
-        ops::Div,
-        sync::Arc,
-        time::{Duration, Instant},
-    },
-    tracing::instrument,
-};
-
-pub struct CachingDetector {
-    inner: Box<dyn BadTokenDetecting>,
-    cache: DashMap<Address, (Instant, TokenQuality)>,
-    cache_expiry: Duration,
-    prefetch_time: Duration,
-}
-
-#[async_trait::async_trait]
-impl BadTokenDetecting for CachingDetector {
-    #[instrument(skip_all)]
-    async fn detect(&self, token: Address) -> Result<TokenQuality> {
-        if let Some(quality) = self.get_from_cache(&token, Instant::now()) {
-            return Ok(quality);
-        }
-
-        let result = self.inner.detect(token).await?;
-        self.cache.insert(token, (Instant::now(), result.clone()));
-        Ok(result)
-    }
-}
-
-impl CachingDetector {
-    pub fn new(
-        inner: Box<dyn BadTokenDetecting>,
-        cache_expiry: Duration,
-        prefetch_time: Duration,
-    ) -> Arc<Self> {
-        assert!(
-            cache_expiry > prefetch_time,
-            "token quality cache prefetch time needs to be less than token quality cache expiry"
-        );
-        let detector = Arc::new(Self {
-            inner,
-            cache: Default::default(),
-            cache_expiry,
-            prefetch_time,
-        });
-        detector.clone().spawn_maintenance_task();
-        detector
-    }
-
-    fn get_from_cache(&self, token: &Address, now: Instant) -> Option<TokenQuality> {
-        let (instant, quality) = self.cache.get(token)?.value().clone();
-        let still_valid = now.saturating_duration_since(instant) < self.cache_expiry;
-        still_valid.then_some(quality)
-    }
-
-    fn insert_many_into_cache(&self, tokens: impl Iterator<Item = (Address, TokenQuality)>) {
-        let now = Instant::now();
-        tokens.into_iter().for_each(|(token, quality)| {
-            self.cache.insert(token, (now, quality));
-        });
-    }
-
-    fn spawn_maintenance_task(self: Arc<Self>) {
-        // We need to prefetch the token quality the `prefetch_time` before the cache
-        // expires
-        let prefetch_time_to_expire = self.cache_expiry - self.prefetch_time;
-        // The maintenance frequency has to be at least double of the prefetch time
-        // frequency in order to guarantee that the prefetch time is executed
-        // before the token quality expires. This is because of the
-        // Nyquist–Shannon sampling theorem.
-        let maintenance_timeout = self.prefetch_time.div(2);
-        let detector = Arc::clone(&self);
-
-        tokio::task::spawn(async move {
-            loop {
-                let start = Instant::now();
-
-                let futures = detector.cache.iter().filter_map(|entry| {
-                    let (token, (instant, _)) = entry.pair();
-                    let (token, instant) = (*token, *instant);
-                    if start.saturating_duration_since(instant) < prefetch_time_to_expire {
-                        return None;
-                    }
-                    let detector = detector.clone();
-                    Some(async move {
-                        match detector.inner.detect(token).await {
-                            Ok(result) => Some((token, result)),
-                            Err(err) => {
-                                tracing::warn!(
-                                    ?token,
-                                    ?err,
-                                    "unable to determine token quality in the background task"
-                                );
-                                None
-                            }
-                        }
-                    })
-                });
-
-                let results = join_all(futures).await;
-                detector.insert_many_into_cache(results.into_iter().flatten());
-
-                let remaining_sleep = maintenance_timeout.saturating_sub(start.elapsed());
-                tokio::time::sleep(remaining_sleep).await;
-            }
-        });
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::bad_token::MockBadTokenDetecting, futures::FutureExt};
-
-    #[tokio::test]
-    async fn goes_to_cache() {
-        // Would panic if called twice.
-        let mut inner = MockBadTokenDetecting::new();
-        inner
-            .expect_detect()
-            .times(1)
-            .returning(|_| Ok(TokenQuality::Good));
-
-        let detector = CachingDetector::new(
-            Box::new(inner),
-            Duration::from_secs(1),
-            Duration::from_millis(200),
-        );
-
-        for _ in 0..2 {
-            let result = detector
-                .detect(Address::with_last_byte(0))
-                .now_or_never()
-                .unwrap();
-            assert!(result.unwrap().is_good());
-        }
-    }
-
-    #[tokio::test]
-    async fn cache_expires() {
-        let inner = MockBadTokenDetecting::new();
-        let token = Address::with_last_byte(0);
-        let detector = CachingDetector::new(
-            Box::new(inner),
-            Duration::from_secs(2),
-            Duration::from_millis(200),
-        );
-        let now = Instant::now();
-        detector.cache.insert(token, (now, TokenQuality::Good));
-        assert!(
-            detector
-                .get_from_cache(&token, now + Duration::from_secs(1))
-                .is_some()
-        );
-        assert!(
-            detector
-                .get_from_cache(&token, now + Duration::from_secs(3))
-                .is_none()
-        );
-    }
-
-    #[tokio::test]
-    async fn cache_prefetch_works() {
-        let mut inner = MockBadTokenDetecting::new();
-        // we expect it to be called twice: first time + prefetch time
-        let mut seq = mockall::Sequence::new();
-        // First call returns Ok(TokenQuality::Good)
-        inner
-            .expect_detect()
-            .times(1)
-            .in_sequence(&mut seq)
-            .returning(|_| Ok(TokenQuality::Good));
-        // Second call returns Ok(TokenQuality::Bad)
-        inner
-            .expect_detect()
-            .times(1)
-            .in_sequence(&mut seq)
-            .returning(|_| {
-                Ok(TokenQuality::Bad {
-                    reason: "bad token".to_string(),
-                })
-            });
-
-        let detector = CachingDetector::new(
-            Box::new(inner),
-            Duration::from_millis(200),
-            Duration::from_millis(50),
-        );
-
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(result.unwrap().is_good());
-        // Check that the result is the same because we haven't reached the prefetch
-        // time yet
-        tokio::time::sleep(Duration::from_millis(100)).await;
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(result.unwrap().is_good());
-        // We wait so the prefetch fetches the data
-        tokio::time::sleep(Duration::from_millis(70)).await;
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(!result.unwrap().is_good());
-    }
-}
diff --git a/crates/shared/src/bad_token/mod.rs b/crates/shared/src/bad_token/mod.rs
index 4cb030db2a..f4d146e74c 100644
--- a/crates/shared/src/bad_token/mod.rs
+++ b/crates/shared/src/bad_token/mod.rs
@@ -1,7 +1,5 @@
-pub mod cache;
 pub mod instrumented;
 pub mod list_based;
-pub mod token_owner_finder;
 pub mod trace_call;
 
 use {alloy::primitives::Address, anyhow::Result};
diff --git a/crates/shared/src/bad_token/token_owner_finder/blockscout.rs b/crates/shared/src/bad_token/token_owner_finder/blockscout.rs
deleted file mode 100644
index dacd5fd0d1..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/blockscout.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-use {
-    super::TokenOwnerProposing,
-    alloy::primitives::Address,
-    anyhow::Result,
-    chain::Chain,
-    prometheus::IntCounterVec,
-    prometheus_metric_storage::MetricStorage,
-    rate_limit::{RateLimiter, Strategy, back_off},
-    reqwest::{Client, Url},
-    serde::Deserialize,
-};
-
-pub struct BlockscoutTokenOwnerFinder {
-    client: Client,
-    base: Url,
-    api_key: Option<String>,
-    rate_limiter: Option<RateLimiter>,
-}
-
-impl BlockscoutTokenOwnerFinder {
-    pub fn with_network(client: Client, chain: &Chain) -> Result<Self> {
-        let base_url = match chain {
-            Chain::Mainnet => "https://eth.blockscout.com/api",
-            Chain::Goerli => "https://eth-goerli.blockscout.com/api",
-            Chain::Gnosis => "https://blockscout.com/xdai/mainnet/api",
-            Chain::Sepolia => "https://eth-sepolia.blockscout.com/api",
-            Chain::ArbitrumOne => "https://arbitrum.blockscout.com/api",
-            Chain::Base => "https://base.blockscout.com/api",
-            _ => anyhow::bail!("Chain not supported"),
-        };
-
-        Ok(Self {
-            client,
-            base: Url::parse(base_url)?,
-            api_key: None,
-            rate_limiter: None,
-        })
-    }
-
-    pub fn with_base_url(&mut self, base_url: Url) -> &mut Self {
-        self.base = base_url;
-        self
-    }
-
-    pub fn with_api_key(&mut self, api_key: String) -> &mut Self {
-        self.api_key = Some(api_key);
-        self
-    }
-
-    pub fn with_rate_limiter(&mut self, strategy: Strategy) -> &mut Self {
-        self.rate_limiter = Some(RateLimiter::from_strategy(
-            strategy,
-            "blockscout".to_owned(),
-        ));
-        self
-    }
-
-    async fn query_owners(&self, token: Address) -> Result<Vec<Address>> {
-        let mut url = self.base.clone();
-        url.query_pairs_mut()
-            .append_pair("module", "token")
-            .append_pair("action", "getTokenHolders")
-            .append_pair("contractaddress", &format!("{token:#x}"));
-
-        // Don't log the API key!
-        tracing::debug!(%url, "Querying Blockscout API");
-
-        if let Some(api_key) = &self.api_key {
-            url.query_pairs_mut().append_pair("apikey", api_key);
-        }
-
-        let request = self.client.get(url).send();
-        let response = match &self.rate_limiter {
-            Some(limiter) => limiter.execute(request, back_off::on_http_429).await??,
-            _ => request.await?,
-        };
-        let status = response.status();
-        let status_result = response.error_for_status_ref().map(|_| ());
-        let body = response.text().await?;
-
-        tracing::debug!(%status, %body, "Response from Blockscout API");
-
-        status_result?;
-        let parsed = serde_json::from_str::<Response>(&body)?;
-
-        // We technically only need one candidate, returning the top 2 in case there is
-        // a race condition and tokens have just been transferred out
-        Ok(parsed
-            .result
-            .into_iter()
-            .map(|owner| owner.address)
-            .take(2)
-            .collect())
-    }
-}
-
-#[derive(Deserialize)]
-struct Response {
-    result: Vec<TokenOwner>,
-}
-
-#[derive(Deserialize)]
-struct TokenOwner {
-    address: Address,
-}
-
-#[derive(MetricStorage, Clone, Debug)]
-#[metric(subsystem = "blockscout_token_owner_finding")]
-struct Metrics {
-    /// Tracks number of "ok" or "err" responses from blockscout.
-    #[metric(labels("result"))]
-    results: IntCounterVec,
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for BlockscoutTokenOwnerFinder {
-    async fn find_candidate_owners(&self, token: Address) -> Result<Vec<Address>> {
-        let metric = &Metrics::instance(observe::metrics::get_storage_registry())
-            .unwrap()
-            .results;
-
-        match self.query_owners(token).await {
-            Ok(ok) => {
-                metric.with_label_values(&["ok"]).inc();
-                Ok(ok)
-            }
-            Err(err) => {
-                tracing::warn!(?err, "error finding token owners with Blockscout");
-                metric.with_label_values(&["err"]).inc();
-                Err(err)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, alloy::primitives::address};
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_blockscout_token_finding_mainnet() {
-        let finder =
-            BlockscoutTokenOwnerFinder::with_network(Client::default(), &Chain::Mainnet).unwrap();
-        let owners = finder
-            .find_candidate_owners(address!("1337BedC9D22ecbe766dF105c9623922A27963EC"))
-            .await;
-        assert!(!owners.unwrap().is_empty());
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_blockscout_token_finding_xdai() {
-        let finder =
-            BlockscoutTokenOwnerFinder::with_network(Client::default(), &Chain::Gnosis).unwrap();
-        let owners = finder
-            .find_candidate_owners(address!("1337BedC9D22ecbe766dF105c9623922A27963EC"))
-            .await;
-        assert!(!owners.unwrap().is_empty());
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_blockscout_token_finding_no_owners() {
-        let finder =
-            BlockscoutTokenOwnerFinder::with_network(Client::default(), &Chain::Gnosis).unwrap();
-        let owners = finder
-            .find_candidate_owners(address!("000000000000000000000000000000000000def1"))
-            .await;
-        assert!(owners.unwrap().is_empty());
-    }
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/ethplorer.rs b/crates/shared/src/bad_token/token_owner_finder/ethplorer.rs
deleted file mode 100644
index 7aa37517e4..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/ethplorer.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-use {
-    super::TokenOwnerProposing,
-    alloy::primitives::Address,
-    anyhow::{Result, ensure},
-    chain::Chain,
-    prometheus::IntCounterVec,
-    prometheus_metric_storage::MetricStorage,
-    rate_limit::{RateLimiter, Strategy, back_off},
-    reqwest::{Client, StatusCode, Url},
-    serde::Deserialize,
-};
-
-const BASE: &str = "https://api.ethplorer.io";
-const FREE_API_KEY: &str = "freekey";
-
-pub struct EthplorerTokenOwnerFinder {
-    client: Client,
-    base: Url,
-    api_key: String,
-
-    /// The low tiers for Ethplorer have very aggressive rate limiting, so be
-    /// sure to setup a rate limiter for Ethplorer requests.
-    rate_limiter: Option<RateLimiter>,
-
-    metrics: &'static Metrics,
-}
-
-impl EthplorerTokenOwnerFinder {
-    pub fn try_with_network(
-        client: Client,
-        api_key: Option<String>,
-        chain: &Chain,
-    ) -> Result<Self> {
-        ensure!(
-            *chain == Chain::Mainnet,
-            "Ethplorer API unsupported network"
-        );
-        Ok(Self {
-            client,
-            base: Url::try_from(BASE).unwrap(),
-            api_key: api_key.unwrap_or_else(|| FREE_API_KEY.to_owned()),
-            rate_limiter: None,
-            metrics: Metrics::instance(observe::metrics::get_storage_registry())?,
-        })
-    }
-
-    pub fn with_base_url(&mut self, base_url: Url) -> &mut Self {
-        self.base = base_url;
-        self
-    }
-
-    pub fn with_rate_limiter(&mut self, strategy: Strategy) -> &mut Self {
-        self.rate_limiter = Some(RateLimiter::from_strategy(strategy, "ethplorer".to_owned()));
-        self
-    }
-
-    async fn query_owners(&self, token: Address) -> Result<Vec<Address>> {
-        let mut url = crate::url::join(&self.base, &format!("getTopTokenHolders/{token:?}"));
-        // We technically only need one candidate, returning the top 2 in case there
-        // is a race condition and tokens have just been transferred out.
-        url.query_pairs_mut().append_pair("limit", "2");
-
-        tracing::debug!(%url, "querying Ethplorer");
-        // Don't log the API key!
-        url.query_pairs_mut().append_pair("apiKey", &self.api_key);
-
-        let request = self.client.get(url).send();
-        let response = match &self.rate_limiter {
-            Some(limiter) => limiter.execute(request, back_off::on_http_429).await??,
-            _ => request.await?,
-        };
-
-        let status = response.status();
-        let status_result = response.error_for_status_ref().map(|_| ());
-        let body = response.text().await?;
-
-        tracing::debug!(%status, %body, "response from Ethplorer API");
-
-        // We need some special handling for "not a token contract" errors. In
-        // this case, we just want to return an empty token holder list to conform
-        // to the expectations of the `TokenHolderProposing` trait.
-        if status == StatusCode::BAD_REQUEST {
-            let err = serde_json::from_str::<Error>(&body)?;
-            if err.not_token_contract() {
-                return Ok(Default::default());
-            }
-        }
-        status_result?;
-
-        let parsed = serde_json::from_str::<Response>(&body)?;
-
-        Ok(parsed
-            .holders
-            .into_iter()
-            .map(|holder| holder.address)
-            .collect())
-    }
-}
-
-#[derive(Deserialize)]
-struct Response {
-    holders: Vec<Holder>,
-}
-
-#[derive(Deserialize)]
-struct Holder {
-    address: Address,
-}
-
-#[derive(Deserialize)]
-struct Error {
-    error: ErrorData,
-}
-
-#[derive(Deserialize)]
-struct ErrorData {
-    code: i64,
-}
-
-impl Error {
-    fn not_token_contract(&self) -> bool {
-        // https://github.com/EverexIO/Ethplorer/wiki/Ethplorer-API#error-codes
-        self.error.code == 150
-    }
-}
-
-#[derive(MetricStorage, Clone, Debug)]
-#[metric(subsystem = "ethplorer_token_owner_finding")]
-struct Metrics {
-    /// Tracks number of "ok" or "err" responses from ethplorer.
-    #[metric(labels("result"))]
-    results: IntCounterVec,
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for EthplorerTokenOwnerFinder {
-    async fn find_candidate_owners(&self, token: Address) -> Result<Vec<Address>> {
-        let metric = &self.metrics.results;
-        let result = self.query_owners(token).await;
-        match &result {
-            Ok(_) => metric.with_label_values(&["ok"]).inc(),
-            Err(err) => {
-                tracing::warn!(?err, "error finding token owners with Ethplorer");
-                metric.with_label_values(&["err"]).inc();
-            }
-        }
-
-        result
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, alloy::primitives::address};
-
-    #[tokio::test]
-    #[ignore]
-    async fn token_finding_mainnet() {
-        let finder =
-            EthplorerTokenOwnerFinder::try_with_network(Client::default(), None, &Chain::Mainnet)
-                .unwrap();
-        let owners = finder
-            .find_candidate_owners(address!("1337BedC9D22ecbe766dF105c9623922A27963EC"))
-            .await;
-        assert!(!owners.unwrap().is_empty());
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn returns_no_owners_on_invalid_token() {
-        let finder =
-            EthplorerTokenOwnerFinder::try_with_network(Client::default(), None, &Chain::Gnosis)
-                .unwrap();
-        let owners = finder
-            .find_candidate_owners(address!("000000000000000000000000000000000000def1"))
-            .await;
-        assert!(owners.unwrap().is_empty());
-    }
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/liquidity.rs b/crates/shared/src/bad_token/token_owner_finder/liquidity.rs
deleted file mode 100644
index a055df1de4..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/liquidity.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! Module containing liquidity-based token owner finding implementations.
-
-use {
-    super::TokenOwnerProposing,
-    crate::sources::{uniswap_v2::pair_provider::PairProvider, uniswap_v3_pair_provider},
-    alloy::{eips::BlockNumberOrTag, primitives::Address},
-    anyhow::Result,
-    contracts::alloy::{BalancerV2Vault, IUniswapV3Factory},
-    model::TokenPair,
-};
-
-pub struct UniswapLikePairProviderFinder {
-    pub inner: PairProvider,
-    pub base_tokens: Vec<Address>,
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for UniswapLikePairProviderFinder {
-    async fn find_candidate_owners(&self, token: Address) -> Result<Vec<Address>> {
-        Ok(self
-            .base_tokens
-            .iter()
-            .filter_map(|base_token| TokenPair::new(*base_token, token))
-            .map(|pair| self.inner.pair_address(&pair))
-            .collect())
-    }
-}
-
-/// The balancer vault contract contains all the balances of all pools.
-pub struct BalancerVaultFinder(pub BalancerV2Vault::Instance);
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for BalancerVaultFinder {
-    async fn find_candidate_owners(&self, _: Address) -> Result<Vec<Address>> {
-        Ok(vec![*self.0.address()])
-    }
-}
-
-pub struct UniswapV3Finder {
-    pub factory: IUniswapV3Factory::Instance,
-    pub base_tokens: Vec<Address>,
-    fee_values: Vec<u32>,
-}
-
-#[derive(Debug, Clone, Copy, clap::ValueEnum)]
-pub enum FeeValues {
-    /// Use hardcoded list
-    Static,
-    /// Fetch on creation based on events queried from node.
-    /// Some nodes struggle with the request and take a long time to respond
-    /// leading to timeouts.
-    Dynamic,
-}
-
-impl UniswapV3Finder {
-    pub async fn new(
-        factory: IUniswapV3Factory::Instance,
-        base_tokens: Vec<Address>,
-        fee_values: FeeValues,
-    ) -> Result<Self> {
-        let fee_values = match fee_values {
-            FeeValues::Static => vec![500, 3000, 10000, 100],
-            // We fetch these once at start up because we don't expect them to change often.
-            // Alternatively could use a time based cache.
-            FeeValues::Dynamic => Self::fee_values(&factory).await?,
-        };
-        tracing::debug!(?fee_values);
-        Ok(Self {
-            factory,
-            base_tokens,
-            fee_values,
-        })
-    }
-
-    // Possible fee values as given by
-    // https://github.com/Uniswap/v3-core/blob/9161f9ae4aaa109f7efdff84f1df8d4bc8bfd042/contracts/UniswapV3Factory.sol#L26
-    async fn fee_values(factory: &IUniswapV3Factory::Instance) -> Result<Vec<u32>> {
-        // We expect there to be few of these kind of events (currently there are 4) so
-        // fetching all of them is fine. Alternatively we could index these
-        // events in the database.
-        let events = factory
-            .FeeAmountEnabled_filter()
-            .from_block(BlockNumberOrTag::Earliest)
-            .to_block(BlockNumberOrTag::Latest)
-            .query()
-            .await?;
-        let fee_values = events
-            .into_iter()
-            .map(|(enabled, _)| {
-                enabled
-                    .fee
-                    .try_into()
-                    .expect("uint24 always fits inside u32")
-            })
-            .collect();
-        Ok(fee_values)
-    }
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for UniswapV3Finder {
-    async fn find_candidate_owners(&self, token: Address) -> Result<Vec<Address>> {
-        Ok(self
-            .base_tokens
-            .iter()
-            .filter_map(|base_token| TokenPair::new(*base_token, token))
-            .flat_map(|pair| self.fee_values.iter().map(move |fee| (pair, *fee)))
-            .map(|(pair, fee)| {
-                uniswap_v3_pair_provider::pair_address(self.factory.address(), &pair, fee)
-            })
-            .collect())
-    }
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/mod.rs b/crates/shared/src/bad_token/token_owner_finder/mod.rs
deleted file mode 100644
index 12319b1778..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/mod.rs
+++ /dev/null
@@ -1,590 +0,0 @@
-pub mod blockscout;
-pub mod ethplorer;
-pub mod liquidity;
-pub mod solvers;
-pub mod token_owner_list;
-
-use {
-    self::{
-        blockscout::BlockscoutTokenOwnerFinder,
-        liquidity::{
-            BalancerVaultFinder,
-            FeeValues,
-            UniswapLikePairProviderFinder,
-            UniswapV3Finder,
-        },
-    },
-    crate::{
-        arguments::{display_list, display_option, display_secret_option},
-        bad_token::token_owner_finder::{
-            ethplorer::EthplorerTokenOwnerFinder,
-            solvers::{
-                solver_api::SolverConfiguration,
-                solver_finder::AutoUpdatingSolverTokenOwnerFinder,
-            },
-            token_owner_list::TokenOwnerList,
-        },
-        baseline_solver::BaseTokens,
-        ethrpc::{MAX_BATCH_SIZE, Web3},
-        http_client::HttpClientFactory,
-        sources::uniswap_v2::pair_provider::PairProvider,
-    },
-    alloy::primitives::{Address, U256},
-    anyhow::{Context, Result},
-    chain::Chain,
-    contracts::alloy::{BalancerV2Vault, ERC20, IUniswapV3Factory},
-    ethrpc::alloy::{ProviderLabelingExt, errors::ContractErrorExt},
-    futures::{Stream, StreamExt as _},
-    rate_limit::Strategy,
-    reqwest::Url,
-    std::{
-        collections::HashMap,
-        fmt::{self, Display, Formatter},
-        sync::Arc,
-        time::Duration,
-    },
-};
-
-/// This trait abstracts various sources for proposing token owner candidates
-/// which are likely, but not guaranteed, to have some token balance.
-#[async_trait::async_trait]
-pub trait TokenOwnerProposing: Send + Sync {
-    /// Find candidate addresses that might own the token.
-    async fn find_candidate_owners(&self, token: Address) -> Result<Vec<Address>>;
-}
-
-/// To detect bad tokens we need to find some address on the network that owns
-/// the token so that we can use it in our simulations.
-#[async_trait::async_trait]
-pub trait TokenOwnerFinding: Send + Sync {
-    /// Find an addresses with at least `min_balance` of tokens and return it,
-    /// along with its actual balance.
-    async fn find_owner(
-        &self,
-        token: Address,
-        min_balance: U256,
-    ) -> Result<Option<(Address, U256)>>;
-}
-
-/// Arguments related to the token owner finder.
-#[derive(clap::Parser)]
-#[group(skip)]
-pub struct Arguments {
-    /// The token owner finding strategies to use.
-    #[clap(long, env, use_value_delimiter = true, value_enum)]
-    pub token_owner_finders: Option<Vec<TokenOwnerFindingStrategy>>,
-
-    /// The fee value strategy to use for locating Uniswap V3 pools as token
-    /// holders for bad token detection.
-    #[clap(long, env, default_value = "static", value_enum)]
-    pub token_owner_finder_uniswap_v3_fee_values: FeeValues,
-
-    /// The blockscout configuration.
-    #[clap(flatten)]
-    pub blockscout: Option<Blockscout>,
-
-    /// The ethplorer configuration.
-    #[clap(flatten)]
-    pub ethplorer: Option<Ethplorer>,
-
-    /// Token owner finding rate limiting strategy. See
-    /// --price-estimation-rate-limiter documentation for format details.
-    #[clap(long, env)]
-    pub token_owner_finder_rate_limiter: Option<Strategy>,
-
-    /// List of token addresses to be whitelisted as a potential token owners
-    /// For each token a list of owners is defined.
-    #[clap(
-        long,
-        env,
-        value_parser = parse_owners,
-        default_value = "",
-    )]
-    pub whitelisted_owners: HashMap<Address, Vec<Address>>,
-
-    /// The solvers urls to query the token owner pairs.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub solver_token_owners_urls: Vec<Url>,
-
-    /// Interval in seconds between consecutive queries to update the solver
-    /// token owner pairs. Values should be in pair with
-    /// `solver_token_owners_urls`
-    #[clap(long, env, use_value_delimiter = true, value_parser = humantime::parse_duration)]
-    pub solver_token_owners_cache_update_intervals: Vec<Duration>,
-}
-
-#[derive(clap::Parser)]
-#[clap(group(
-    clap::ArgGroup::new("blockscout")
-    .requires_all(&[
-    "blockscout_api_url",
-    "blockscout_api_key",
-    ])
-    .multiple(true)
-    .required(false),
-))]
-pub struct Blockscout {
-    /// Override the default blockscout API url for this network
-    #[clap(long, env, group = "blockscout", required = false)]
-    pub blockscout_api_url: Url,
-
-    /// The blockscout API key.
-    #[clap(long, env, group = "blockscout", required = false)]
-    pub blockscout_api_key: String,
-}
-
-#[derive(clap::Parser)]
-#[clap(group(
-    clap::ArgGroup::new("ethplorer")
-    .requires_all(&[
-    "ethplorer_api_url",
-    "ethplorer_api_key",
-    ])
-    .multiple(true)
-    .required(false),
-))]
-pub struct Ethplorer {
-    /// Override the default ethplorer API url
-    #[clap(long, env, group = "ethplorer", required = false)]
-    pub ethplorer_api_url: Url,
-
-    /// The Ethplorer token holder API key.
-    #[clap(long, env, group = "ethplorer", required = false)]
-    pub ethplorer_api_key: String,
-}
-
-fn parse_owners(s: &str) -> Result<HashMap<Address, Vec<Address>>> {
-    if s.is_empty() {
-        return Ok(Default::default());
-    }
-    s.split(';')
-        .map(|pair_str| {
-            let (key, values) = pair_str
-                .split_once(':')
-                .context("missing token and owners")?;
-            let key = key.trim().parse()?;
-            let values = values
-                .trim()
-                .split(',')
-                .map(|value| value.trim().parse().context("failed to parse token owner"))
-                .collect::<Result<_>>()?;
-            Ok((key, values))
-        })
-        .collect()
-}
-
-/// Support token owner finding strategies.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, clap::ValueEnum)]
-pub enum TokenOwnerFindingStrategy {
-    /// Using baseline liquidity pools as token owners.
-    ///
-    /// The actual liquidity pools used depends on the configured baseline
-    /// liquidity.
-    Liquidity,
-
-    /// Use the Blockscout token holder API to find token holders.
-    Blockscout,
-
-    /// Use the Ethplorer token holder API.
-    Ethplorer,
-
-    /// Use lists provided by the external solver teams
-    Solvers,
-}
-
-impl TokenOwnerFindingStrategy {
-    /// Returns the default set of token owner finding strategies.
-    pub fn defaults_for_network(chain: &Chain) -> &'static [Self] {
-        match chain {
-            Chain::Mainnet => &[Self::Liquidity, Self::Blockscout, Self::Ethplorer],
-            Chain::Gnosis => &[Self::Liquidity, Self::Blockscout],
-            Chain::Sepolia
-            | Chain::Goerli
-            | Chain::ArbitrumOne
-            | Chain::Base
-            | Chain::Bnb
-            | Chain::Optimism
-            | Chain::Avalanche
-            | Chain::Polygon
-            | Chain::Linea
-            | Chain::Plasma
-            | Chain::Ink
-            | Chain::Lens => &[Self::Liquidity],
-            Chain::Hardhat => panic!("unsupported chain for token owner finding"),
-        }
-    }
-}
-
-impl Display for Arguments {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let Self {
-            token_owner_finders,
-            token_owner_finder_uniswap_v3_fee_values,
-            blockscout,
-            ethplorer,
-            token_owner_finder_rate_limiter,
-            whitelisted_owners,
-            solver_token_owners_urls,
-            solver_token_owners_cache_update_intervals,
-        } = self;
-
-        writeln!(f, "token_owner_finders: {token_owner_finders:?}")?;
-        writeln!(
-            f,
-            "token_owner_finder_uniswap_v3_fee_values: \
-             {token_owner_finder_uniswap_v3_fee_values:?}"
-        )?;
-        display_option(
-            f,
-            "blockscout_api_url",
-            &blockscout
-                .as_ref()
-                .map(|blockscout| blockscout.blockscout_api_url.clone()),
-        )?;
-        display_secret_option(
-            f,
-            "blockscout_api_key",
-            blockscout
-                .as_ref()
-                .map(|blockscout| blockscout.blockscout_api_key.clone())
-                .as_ref(),
-        )?;
-        display_option(
-            f,
-            "ethplorer_api_url",
-            &ethplorer
-                .as_ref()
-                .map(|blockscout| blockscout.ethplorer_api_url.clone())
-                .as_ref(),
-        )?;
-        display_secret_option(
-            f,
-            "ethplorer_api_key",
-            ethplorer
-                .as_ref()
-                .map(|blockscout| blockscout.ethplorer_api_key.clone())
-                .as_ref(),
-        )?;
-        display_option(
-            f,
-            "token_owner_finder_rate_limiter",
-            token_owner_finder_rate_limiter,
-        )?;
-        writeln!(f, "whitelisted_owners, {whitelisted_owners:?}")?;
-        display_list(f, "solver_token_owners_urls", solver_token_owners_urls)?;
-        writeln!(
-            f,
-            "solver_token_owners_cache_update_intervals, \
-             {solver_token_owners_cache_update_intervals:?}"
-        )?;
-        Ok(())
-    }
-}
-
-/// Initializes a set of token owner finders.
-#[expect(clippy::too_many_arguments)]
-pub async fn init(
-    args: &Arguments,
-    web3: Web3,
-    chain: &Chain,
-    http_factory: &HttpClientFactory,
-    pair_providers: &[PairProvider],
-    vault: Option<&BalancerV2Vault::Instance>,
-    uniswapv3_factory: Option<&IUniswapV3Factory::Instance>,
-    base_tokens: &BaseTokens,
-    settlement_contract: Address,
-) -> Result<Arc<dyn TokenOwnerFinding>> {
-    let web3 = web3.labeled("tokenOwners");
-    let finders = args
-        .token_owner_finders
-        .as_deref()
-        .unwrap_or_else(|| TokenOwnerFindingStrategy::defaults_for_network(chain));
-    tracing::debug!(?finders, "initializing token owner finders");
-
-    let mut proposers = Vec::<Arc<dyn TokenOwnerProposing>>::new();
-
-    if finders.contains(&TokenOwnerFindingStrategy::Liquidity) {
-        proposers.extend(
-            pair_providers
-                .iter()
-                .map(|provider| -> Arc<dyn TokenOwnerProposing> {
-                    Arc::new(UniswapLikePairProviderFinder {
-                        inner: *provider,
-                        base_tokens: base_tokens.tokens().iter().copied().collect(),
-                    })
-                }),
-        );
-        if let Some(contract) = vault {
-            proposers.push(Arc::new(BalancerVaultFinder(contract.clone())));
-        }
-        if let Some(contract) = uniswapv3_factory {
-            proposers.push(Arc::new(
-                UniswapV3Finder::new(
-                    contract.clone(),
-                    base_tokens.tokens().iter().copied().collect(),
-                    args.token_owner_finder_uniswap_v3_fee_values,
-                )
-                .await?,
-            ));
-        }
-    }
-
-    if finders.contains(&TokenOwnerFindingStrategy::Blockscout) {
-        let mut blockscout =
-            BlockscoutTokenOwnerFinder::with_network(http_factory.create(), chain)?;
-        if let Some(blockscout_config) = &args.blockscout {
-            blockscout.with_base_url(blockscout_config.blockscout_api_url.clone());
-            blockscout.with_api_key(blockscout_config.blockscout_api_key.clone());
-        }
-        if let Some(strategy) = args.token_owner_finder_rate_limiter.clone() {
-            blockscout.with_rate_limiter(strategy);
-        }
-        proposers.push(Arc::new(blockscout));
-    }
-
-    if finders.contains(&TokenOwnerFindingStrategy::Ethplorer) {
-        let mut ethplorer = EthplorerTokenOwnerFinder::try_with_network(
-            http_factory.create(),
-            args.ethplorer
-                .as_ref()
-                .map(|ethplorer| ethplorer.ethplorer_api_key.clone()),
-            chain,
-        )?;
-        if let Some(ethplorer_config) = &args.ethplorer {
-            ethplorer.with_base_url(ethplorer_config.ethplorer_api_url.clone());
-        }
-        if let Some(strategy) = args.token_owner_finder_rate_limiter.clone() {
-            ethplorer.with_rate_limiter(strategy);
-        }
-        proposers.push(Arc::new(ethplorer));
-    }
-
-    if finders.contains(&TokenOwnerFindingStrategy::Solvers) {
-        for (url, update_interval) in args
-            .solver_token_owners_urls
-            .clone()
-            .into_iter()
-            .zip(args.solver_token_owners_cache_update_intervals.clone())
-        {
-            let identifier = url.to_string();
-            let solver = Box::new(SolverConfiguration {
-                url,
-                client: http_factory.create(),
-            });
-            let solver =
-                AutoUpdatingSolverTokenOwnerFinder::new(solver, update_interval, identifier);
-            proposers.push(Arc::new(solver));
-        }
-    }
-
-    proposers.push(Arc::new(TokenOwnerList::new(
-        args.whitelisted_owners.clone(),
-    )));
-
-    Ok(Arc::new(TokenOwnerFinder {
-        web3,
-        proposers,
-        settlement_contract,
-    }))
-}
-
-/// A `TokenOwnerFinding` implementation that queries a node with proposed owner
-/// candidates from an internal list of `TokenOwnerProposing` implementations.
-pub struct TokenOwnerFinder {
-    pub web3: Web3,
-    pub proposers: Vec<Arc<dyn TokenOwnerProposing>>,
-    pub settlement_contract: Address,
-}
-
-impl TokenOwnerFinder {
-    /// Stream of addresses that might own the token.
-    fn candidate_owners(&self, token: Address) -> impl Stream<Item = Address> + '_ {
-        // Combine the results of all finders into a single stream.
-        let streams = self.proposers.iter().map(|finder| {
-            futures::stream::once(finder.find_candidate_owners(token))
-                .filter_map(|result| async {
-                    match result {
-                        Ok(inner) => Some(futures::stream::iter(inner)),
-                        Err(err) => {
-                            tracing::warn!(?err, "token owner proposing failed");
-                            None
-                        }
-                    }
-                })
-                .flatten()
-                .boxed()
-        });
-        futures::stream::select_all(streams)
-    }
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerFinding for TokenOwnerFinder {
-    async fn find_owner(
-        &self,
-        token: Address,
-        min_balance: U256,
-    ) -> Result<Option<(Address, U256)>> {
-        let instance = ERC20::Instance::new(token, self.web3.provider.clone());
-
-        // We use a stream with ready_chunks so that we can start with the addresses of
-        // fast TokenOwnerFinding implementations first without having to wait
-        // for slow ones.
-        let stream = self.candidate_owners(token).ready_chunks(MAX_BATCH_SIZE);
-        futures::pin_mut!(stream);
-
-        while let Some(chunk) = stream.next().await {
-            let futures = chunk
-                .into_iter()
-                // The token balance assertions of the bad token test assume the token
-                // owner is not the settlement contract.
-                .filter(|owner| *owner != self.settlement_contract)
-                .map(|owner| {
-                    let balance = instance.balanceOf(owner);
-                    async move {
-                        match balance.call().await {
-                            Ok(balance) => Ok((owner, balance)),
-                            Err(err) if err.is_contract_error() => {
-                                Ok((owner, alloy::primitives::U256::ZERO))
-                            }
-                            Err(err) => Err(err),
-                        }
-                    }
-                });
-            let balances = futures::future::try_join_all(futures).await?;
-
-            if let Some((addr, balance)) = balances
-                .into_iter()
-                .find(|(_, balance)| *balance >= min_balance)
-            {
-                return Ok(Some((addr, balance)));
-            }
-        }
-
-        Ok(None)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use {super::*, alloy::primitives::address, clap::Parser};
-
-    const TOKEN1: Address = address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
-    const TOKEN2: Address = address!("7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9");
-    const OWNER1: Address = address!("06920c9fc643de77b99cb7670a944ad31eaaa260");
-    const OWNER2: Address = address!("06601571aa9d3e8f5f7cdd5b993192618964bab5");
-
-    #[test]
-    fn parse_owners_empty() {
-        assert_eq!(parse_owners("").unwrap(), Default::default());
-    }
-
-    #[test]
-    fn parse_owners_one_owner() {
-        let mut expected = HashMap::new();
-        expected.insert(TOKEN1, vec![OWNER1]);
-        let parsed = parse_owners(
-            "
-            0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2:
-                0x06920c9fc643de77b99cb7670a944ad31eaaa260
-        ",
-        )
-        .unwrap();
-        assert_eq!(parsed, expected);
-    }
-
-    #[test]
-    fn parse_owners_two_owners() {
-        let mut expected = HashMap::new();
-        expected.insert(TOKEN1, vec![OWNER1, OWNER2]);
-        let parsed = parse_owners(
-            "
-            0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2:
-                0x06920c9fc643de77b99cb7670a944ad31eaaa260,
-                0x06601571aa9d3e8f5f7cdd5b993192618964bab5
-        ",
-        )
-        .unwrap();
-        assert_eq!(parsed, expected);
-    }
-
-    #[test]
-    fn parse_owners_two_tokens_with_one_owners() {
-        let mut expected = HashMap::new();
-        expected.insert(TOKEN1, vec![OWNER1]);
-        expected.insert(TOKEN2, vec![OWNER2]);
-        let parsed = parse_owners(
-            "
-            0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2:
-                0x06920c9fc643de77b99cb7670a944ad31eaaa260;
-            0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9:
-                0x06601571aa9d3e8f5f7cdd5b993192618964bab5
-        ",
-        )
-        .unwrap();
-        assert_eq!(parsed, expected);
-    }
-
-    #[test]
-    fn parse_owners_err() {
-        assert!(parse_owners("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2:").is_err());
-        assert!(parse_owners("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").is_err());
-        assert!(parse_owners(":0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").is_err());
-    }
-
-    #[test]
-    fn blockscout_correctly_configured() {
-        let args = vec![
-            "test", // Program name
-            "--blockscout-api-key",
-            "someapikey",
-            "--blockscout-api-url",
-            "https://swap.cow.fi",
-        ];
-
-        let blockscout = Blockscout::try_parse_from(args);
-
-        assert!(blockscout.is_ok());
-    }
-
-    #[test]
-    fn blockscout_wrongly_configured() {
-        let args = vec![
-            "test", // Program name
-            "--blockscout-api-key",
-            "someapikey",
-        ];
-
-        let result = Blockscout::try_parse_from(args);
-
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn ethplorer_correctly_configured() {
-        let args = vec![
-            "test", // Program name
-            "--ethplorer-api-key",
-            "someapikey",
-            "--ethplorer-api-url",
-            "https://swap.cow.fi",
-        ];
-
-        let ethplorer = Ethplorer::try_parse_from(args);
-
-        assert!(ethplorer.is_ok());
-    }
-
-    #[test]
-    fn ethplorer_wrongly_configured() {
-        let args = vec![
-            "test", // Program name
-            "--ethplorer-api-key",
-            "someapikey",
-        ];
-
-        let result = Ethplorer::try_parse_from(args);
-
-        assert!(result.is_err());
-    }
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/solvers/mod.rs b/crates/shared/src/bad_token/token_owner_finder/solvers/mod.rs
deleted file mode 100644
index 1b153c56a7..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/solvers/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-pub mod solver_api;
-pub mod solver_finder;
-
-use {alloy::primitives::Address, anyhow::Result, std::collections::HashMap};
-
-type Token = Address;
-type Owner = Address;
-
-#[async_trait::async_trait]
-pub trait TokenOwnerSolverApi: Send + Sync {
-    /// Get token owner pairs from specific solver
-    async fn get_token_owner_pairs(&self) -> Result<HashMap<Token, Vec<Owner>>>;
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/solvers/solver_api.rs b/crates/shared/src/bad_token/token_owner_finder/solvers/solver_api.rs
deleted file mode 100644
index a14fa46537..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/solvers/solver_api.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use {
-    super::TokenOwnerSolverApi,
-    alloy::primitives::Address,
-    anyhow::{Context, Result},
-    reqwest::{Client, Url},
-    std::collections::HashMap,
-};
-
-type Token = Address;
-type Owner = Address;
-
-#[derive(Clone, Debug)]
-pub struct SolverConfiguration {
-    pub url: Url,
-    pub client: Client,
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerSolverApi for SolverConfiguration {
-    async fn get_token_owner_pairs(&self) -> Result<HashMap<Token, Vec<Owner>>> {
-        let response = self
-            .client
-            .get(self.url.clone())
-            .send()
-            .await?
-            .text()
-            .await?;
-        serde_json::from_str(&response).context(format!("bad query response: {response:?}"))
-    }
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/solvers/solver_finder.rs b/crates/shared/src/bad_token/token_owner_finder/solvers/solver_finder.rs
deleted file mode 100644
index a88ed4822f..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/solvers/solver_finder.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-use {
-    super::TokenOwnerSolverApi,
-    crate::bad_token::token_owner_finder::TokenOwnerProposing,
-    alloy::primitives::Address,
-    anyhow::Result,
-    prometheus::{
-        IntCounterVec,
-        core::{AtomicU64, GenericCounter},
-    },
-    std::{
-        collections::HashMap,
-        fmt::{self, Debug, Formatter},
-        sync::{Arc, RwLock},
-        time::Duration,
-    },
-    tracing::Instrument,
-};
-
-type Token = Address;
-type Owner = Address;
-
-#[derive(Debug)]
-pub struct AutoUpdatingSolverTokenOwnerFinder {
-    inner: Arc<Inner>,
-}
-
-#[derive(prometheus_metric_storage::MetricStorage, Clone, Debug)]
-struct Metrics {
-    /// Tracks how often a token owner update succeeded or failed.
-    #[metric(labels("identifier", "result"))]
-    token_owner_list_updates: IntCounterVec,
-}
-
-struct Inner {
-    solver: Box<dyn TokenOwnerSolverApi>,
-    cache: RwLock<HashMap<Token, Vec<Owner>>>,
-    metrics: &'static Metrics,
-    identifier: String,
-}
-
-impl Inner {
-    pub fn get_update_counter(&self, success: bool) -> GenericCounter<AtomicU64> {
-        let result = if success { "success" } else { "failure" };
-        self.metrics
-            .token_owner_list_updates
-            .with_label_values(&[&self.identifier, result])
-    }
-}
-
-impl AutoUpdatingSolverTokenOwnerFinder {
-    pub fn new(
-        solver: Box<dyn TokenOwnerSolverApi>,
-        update_interval: Duration,
-        identifier: String,
-    ) -> Self {
-        let inner = Arc::new(Inner {
-            solver,
-            cache: RwLock::new(Default::default()),
-            metrics: Metrics::instance(observe::metrics::get_storage_registry()).unwrap(),
-            identifier,
-        });
-
-        // reset metrics for consistent graphs in grafana
-        inner.get_update_counter(true).reset();
-        inner.get_update_counter(false).reset();
-
-        // spawn a background task to regularly update cache
-        {
-            let inner = inner.clone();
-            let updater = async move {
-                loop {
-                    let result = inner.update().await;
-                    inner.get_update_counter(result.is_ok()).inc();
-                    if let Err(err) = result {
-                        tracing::warn!(?err, "failed to update token list");
-                    }
-                    tokio::time::sleep(update_interval).await;
-                }
-            };
-            tokio::task::spawn(
-                updater.instrument(tracing::info_span!("auto_updating_token_owner_finder")),
-            );
-        }
-
-        Self { inner }
-    }
-
-    pub async fn update(&self) -> Result<()> {
-        self.inner.update().await
-    }
-}
-
-impl Inner {
-    async fn update(&self) -> Result<()> {
-        let token_owner_pairs = self.solver.get_token_owner_pairs().await?;
-
-        let mut cache = self.cache.write().unwrap();
-        *cache = token_owner_pairs;
-
-        Ok(())
-    }
-}
-
-impl Debug for Inner {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.debug_struct("Inner").field("cache", &self.cache).finish()
-    }
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for AutoUpdatingSolverTokenOwnerFinder {
-    async fn find_candidate_owners(&self, token: Token) -> Result<Vec<Owner>> {
-        Ok(self
-            .inner
-            .cache
-            .read()
-            .unwrap()
-            .get(&token)
-            .cloned()
-            .unwrap_or_default())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::bad_token::token_owner_finder::solvers::solver_api::SolverConfiguration,
-        alloy::primitives::address,
-        reqwest::{Client, Url},
-        std::str::FromStr,
-    };
-
-    #[tokio::test]
-    #[ignore]
-    async fn seasolver_e2e_test() {
-        let url = std::env::var("SEASOLVER_TOKEN_HOLDERS").unwrap();
-        let configuration = Box::new(SolverConfiguration {
-            url: Url::from_str(&url).unwrap(),
-            client: Client::new(),
-        });
-        let finder = AutoUpdatingSolverTokenOwnerFinder::new(
-            configuration,
-            Duration::from_secs(1000),
-            "test".to_owned(),
-        );
-        tokio::time::sleep(Duration::from_secs(10)).await;
-        let owners = finder
-            .find_candidate_owners(address!("132d8D2C76Db3812403431fAcB00F3453Fc42125"))
-            .await
-            .unwrap();
-        dbg!(owners);
-    }
-}
diff --git a/crates/shared/src/bad_token/token_owner_finder/token_owner_list.rs b/crates/shared/src/bad_token/token_owner_finder/token_owner_list.rs
deleted file mode 100644
index a1490661fe..0000000000
--- a/crates/shared/src/bad_token/token_owner_finder/token_owner_list.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use {
-    super::TokenOwnerProposing,
-    alloy::primitives::Address,
-    anyhow::Result,
-    std::collections::HashMap,
-};
-
-type Token = Address;
-type Owner = Address;
-
-pub struct TokenOwnerList {
-    owners: HashMap<Token, Vec<Owner>>,
-}
-
-impl TokenOwnerList {
-    pub fn new(owners: HashMap<Token, Vec<Owner>>) -> Self {
-        Self { owners }
-    }
-}
-
-#[async_trait::async_trait]
-impl TokenOwnerProposing for TokenOwnerList {
-    async fn find_candidate_owners(&self, token: Address) -> Result<Vec<Owner>> {
-        Ok(self.owners.get(&token).cloned().unwrap_or_default())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn token_owner_list_constructor_empty() {
-        let finder = TokenOwnerList::new(Default::default());
-        let candidate_owners = finder
-            .find_candidate_owners(Address::with_last_byte(10))
-            .await;
-        assert!(candidate_owners.unwrap().is_empty());
-    }
-
-    #[tokio::test]
-    async fn token_owner_list_constructor() {
-        let token = Address::with_last_byte(1);
-        let owners = vec![Address::with_last_byte(2), Address::with_last_byte(3)];
-        let finder = TokenOwnerList::new(HashMap::from([(token, owners.clone())]));
-        let candidate_owners = finder
-            .find_candidate_owners(Address::with_last_byte(1))
-            .await
-            .unwrap();
-        assert_eq!(owners, candidate_owners);
-    }
-}
diff --git a/crates/shared/src/bad_token/trace_call.rs b/crates/shared/src/bad_token/trace_call.rs
index bc3cf34c41..8b529edcf4 100644
--- a/crates/shared/src/bad_token/trace_call.rs
+++ b/crates/shared/src/bad_token/trace_call.rs
@@ -1,5 +1,5 @@
 use {
-    super::{BadTokenDetecting, TokenQuality, token_owner_finder::TokenOwnerFinding},
+    super::TokenQuality,
     crate::{ethrpc::Web3, trace_many},
     alloy::{
         primitives::{Address, U256, keccak256},
@@ -17,79 +17,10 @@ use {
     anyhow::{Context, Result, bail, ensure},
     contracts::alloy::ERC20,
     model::interaction::InteractionData,
-    std::{cmp, sync::Arc},
-    tracing::instrument,
 };
 
 const METHOD_NOT_FOUND_CODE: i64 = -32601;
 
-/// Detects whether a token is "bad" (works in unexpected ways that are
-/// problematic for solving) by simulating several transfers of a token. To find
-/// an initial address to transfer from we use the amm pair providers.
-/// Tokens are bad if:
-/// - we cannot find an amm pool of the token to one of the base tokens
-/// - transfer into the settlement contract or back out fails
-/// - a transfer loses total balance
-pub struct TraceCallDetector {
-    inner: TraceCallDetectorRaw,
-    finder: Arc<dyn TokenOwnerFinding>,
-}
-
-#[async_trait::async_trait]
-impl BadTokenDetecting for TraceCallDetector {
-    #[instrument(skip_all)]
-    async fn detect(&self, token: Address) -> Result<TokenQuality> {
-        let quality = self.detect_impl(token).await?;
-        tracing::debug!(?token, ?quality, "determined token quality");
-        Ok(quality)
-    }
-}
-
-impl TraceCallDetector {
-    pub fn new(web3: Web3, settlement: Address, finder: Arc<dyn TokenOwnerFinding>) -> Self {
-        Self {
-            inner: TraceCallDetectorRaw::new(web3, settlement),
-            finder,
-        }
-    }
-
-    async fn detect_impl(&self, token: Address) -> Result<TokenQuality> {
-        // Arbitrary amount that is large enough that small relative fees should be
-        // visible.
-        const MIN_AMOUNT: u64 = 100_000;
-        let (take_from, amount) = match self
-            .finder
-            .find_owner(token, U256::from(MIN_AMOUNT))
-            .await
-            .context("find_owner")?
-        {
-            Some((address, balance)) => {
-                // Don't use the full balance, but instead a portion of it. This
-                // makes the trace call less racy and prone to the transfer
-                // failing because of a balance change from one block to the
-                // next. This can happen because of either:
-                // - Block propagation - the trace_callMany is handled by a node that is 1 block
-                //   in the past
-                // - New block observed - the trace_callMany is executed on a block that came in
-                //   since we read the balance
-                let amount = cmp::max(balance / U256::from(2), U256::from(MIN_AMOUNT));
-
-                tracing::debug!(?token, ?address, ?amount, "found owner");
-                (address, amount)
-            }
-            None => {
-                return Ok(TokenQuality::bad(format!(
-                    "Could not find on chain source of the token with at least {MIN_AMOUNT} \
-                     balance.",
-                )));
-            }
-        };
-        self.inner
-            .test_transfer(take_from, token, amount, &[])
-            .await
-    }
-}
-
 /// Detects whether a token is "bad" (works in unexpected ways that are
 /// problematic for solving) by simulating several transfers of a token.
 #[derive(Debug, Clone)]
@@ -402,26 +333,8 @@ fn u256_from_be_bytes_strict(b: &[u8]) -> Option<U256> {
 mod tests {
     use {
         super::*,
-        crate::{
-            bad_token::token_owner_finder::{
-                TokenOwnerFinder,
-                blockscout::BlockscoutTokenOwnerFinder,
-                liquidity::{
-                    BalancerVaultFinder,
-                    FeeValues,
-                    UniswapLikePairProviderFinder,
-                    UniswapV3Finder,
-                },
-                solvers::{
-                    solver_api::SolverConfiguration,
-                    solver_finder::AutoUpdatingSolverTokenOwnerFinder,
-                },
-            },
-            sources::{BaselineSource, uniswap_v2},
-        },
         alloy::{
-            primitives::{Bytes, address},
-            providers::Provider,
+            primitives::Bytes,
             rpc::types::trace::parity::{
                 Action,
                 CallAction,
@@ -430,10 +343,6 @@ mod tests {
                 TransactionTrace,
             },
         },
-        chain::Chain,
-        contracts::alloy::{BalancerV2Vault, GPv2Settlement, IUniswapV3Factory},
-        ethrpc::Web3,
-        std::{env, time::Duration},
     };
 
     #[test]
@@ -542,408 +451,4 @@ mod tests {
         let expected = TokenQuality::Good;
         assert_eq!(result, expected);
     }
-
-    // cargo test -p shared mainnet_tokens -- --nocapture --ignored
-    #[tokio::test]
-    #[ignore]
-    async fn mainnet_tokens() {
-        // observe::tracing::initialize("orderbook::bad_token=debug,
-        // shared::transport=debug", tracing::level_filters::LevelFilter::OFF);
-        let web3 = Web3::new_from_env();
-        let version = web3.provider.get_chain_id().await.unwrap().to_string();
-
-        let base_tokens = &[
-            testlib::tokens::WETH,
-            testlib::tokens::DAI,
-            testlib::tokens::USDC,
-            testlib::tokens::USDT,
-            testlib::tokens::COMP,
-            testlib::tokens::MKR,
-            testlib::tokens::WBTC,
-        ];
-
-        // tokens from our deny list
-        let bad_tokens = &[
-            address!("0027449Bf0887ca3E431D263FFDeFb244D95b555"), // All balances are maxuint256
-            address!("0189d31f6629c359007f72b8d5ec8fa1c126f95c"),
-            address!("01995786f1435743c42b7f2276c496a610b58612"),
-            address!("072c46f392e729c1f0d92a307c2c6dba06b5d078"),
-            address!("074545177a36ab81aac783211f25e14f1ed03c2b"),
-            address!("07be1ead7aebee544618bdc688fa3cff09857c32"),
-            address!("0858a26055d6584e5b47bbecf7f7e8cbc390995b"),
-            address!("0aacfbec6a24756c20d41914f2caba817c0d8521"),
-            address!("0ba45a8b5d5575935b8158a88c631e9f9c95a2e5"),
-            address!("0e69d0a2bbb30abcb7e5cfea0e4fde19c00a8d47"),
-            address!("1016f3c0a1939fa27538339da7e2a300031b6f37"),
-            address!("106552c11272420aad5d7e94f8acab9095a6c952"),
-            address!("106d3c66d22d2dd0446df23d7f5960752994d600"),
-            address!("1337DEF18C680aF1f9f45cBcab6309562975b1dD"),
-            address!("1341a2257fa7b770420ef70616f888056f90926c"),
-            address!("1426cc6d52d1b14e2b3b1cb04d57ea42b39c4c7c"),
-            address!("14dd7ebe6cb084cb73ef377e115554d47dc9d61e"),
-            address!("15874d65e649880c2614e7a480cb7c9a55787ff6"),
-            address!("1681bcb589b3cfcf0c0616b0ce9b19b240643dc1"),
-            address!("18bdfc80b97cb97f6b466cce967849ce9cd9d58c"),
-            address!("1b9baf2a3edea91ee431f02d449a1044d5726669"),
-            address!("2129ff6000b95a973236020bcd2b2006b0d8e019"),
-            address!("239dc02a28a0774738463e06245544a72745d5c5"),
-            address!("251457b7c5d85251ca1ab384361c821330be2520"),
-            address!("25a1de1c3ee658fe034b8914a1d8d34110423af8"),
-            address!("26a79bd709a7ef5e5f747b8d8f83326ea044d8cc"),
-            address!("289d5488ab09f43471914e572ec9e3651c735af2"),
-            address!("298d492e8c1d909d3f63bc4a36c66c64acb3d695"),
-            address!("2b1fe2cea92436e8c34b7c215af66aaa2932a8b2"),
-            address!("31acf54fae6166dc2f90c4d6f20d379965e96bc1"),
-            address!("32c868f6318d6334b2250f323d914bc2239e4eee"),
-            address!("33f128394af03db639107473e52d84ff1290499e"),
-            address!("37611b28aca5673744161dc337128cfdd2657f69"),
-            address!("389999216860ab8e0175387a0c90e5c52522c945"),
-            address!("39b8523fa094b0dc045e2c3e5dff34b3f2ca6220"),
-            address!("3a6fe4c752eb8d571a660a776be4003d619c30a3"),
-            address!("3a9fff453d50d4ac52a6890647b823379ba36b9e"),
-            address!("3ea50b7ef6a7eaf7e966e2cb72b519c16557497c"),
-            address!("3fca773d13f831753ec3ae9f39ad4a6814ebb695"),
-            address!("41933422dc4a1cb8c822e06f12f7b52fa5e7e094"),
-            address!("45734927fa2f616fbe19e65f42a0ef3d37d1c80a"),
-            address!("45804880de22913dafe09f4980848ece6ecbaf78"),
-            address!("48be867b240d2ffaff69e0746130f2c027d8d3d2"),
-            address!("4a6be56a211a4c4e0dd4474d524138933c17f3e3"),
-            address!("4b86e0295e7d32433ffa6411b82b4f4e56a581e1"),
-            address!("4ba6ddd7b89ed838fed25d208d4f644106e34279"),
-            address!("4bae380b5d762d543d426331b8437926443ae9ec"),
-            address!("4bcddfcfa8cb923952bcf16644b36e5da5ca3184"),
-            address!("4c9d5672ae33522240532206ab45508116daf263"),
-            address!("4F9254C83EB525f9FCf346490bbb3ed28a81C667"),
-            address!("4fab740779c73aa3945a5cf6025bf1b0e7f6349c"),
-            address!("51d3e4c0b2c83e62f5d517d250b3e856897d2052"),
-            address!("53ba22cb4e5e9c1be0d73913764f572192a71aca"),
-            address!("56de8bc61346321d4f2211e3ac3c0a7f00db9b76"),
-            address!("576097fa17e1f702bb9167f0f08f2ea0898a3ea5"),
-            address!("577e7f9fa80ab33e87a01b701114257c8d9455a8"),
-            address!("586c680e9a6d21b81ebecf46d78844dab7b3bcf9"),
-            address!("5d0fa08aeb173ade44b0cf7f31d506d8e04f0ac8"),
-            address!("62359ed7505efc61ff1d56fef82158ccaffa23d7"),
-            address!("63d0eea1d7c0d1e89d7e665708d7e8997c0a9ed6"),
-            address!("66d31def9c47b62184d7f57175eed5b5d9b7f038"),
-            address!("671ab077497575dcafb68327d2d2329207323e74"),
-            address!("685aea4f02e39e5a5bb7f7117e88db1151f38364"),
-            address!("68e0a48d3bff6633a31d1d100b70f93c3859218b"),
-            address!("69692d3345010a207b759a7d1af6fc7f38b35c5e"),
-            address!("6a00b86e30167f73e38be086081b80213e8266aa"),
-            address!("6b8e77d3db1faa17f7b24c24242b6a1eb5008a16"),
-            address!("6e10aacb89a28d6fa0fe68790777fec7e7f01890"),
-            address!("6fcb6408499a7c0f242e32d77eb51ffa1dd28a7e"),
-            address!("714599f7604144a3fe1737c440a70fc0fd6503ea"),
-            address!("75fef397d74a2d11b64e6915cd847c1e7f8e5520"),
-            address!("76851a93977bea9264c32255b6457882035c7501"),
-            address!("79ba92dda26fce15e1e9af47d5cfdfd2a093e000"),
-            address!("7f0f118d083d5175ab9d2d34c4c8fa4f43c3f47b"),
-            address!("7ff4169a6b5122b664c51c95727d87750ec07c84"),
-            address!("801ea8c463a776e85344c565e355137b5c3324cd"),
-            address!("88ef27e69108b2633f8e1c184cc37940a075cc02"),
-            address!("8c7424c3000942e5a93de4a01ce2ec86c06333cb"),
-            address!("8eb24319393716668d768dcec29356ae9cffe285"),
-            address!("910524678c0b1b23ffb9285a81f99c29c11cbaed"),
-            address!("910985ffa7101bf5801dd2e91555c465efd9aab3"),
-            address!("925f2c11b99c1a4c46606898ee91ed3d450cfeda"),
-            address!("944eee930933be5e23b690c8589021ec8619a301"),
-            address!("94987bc8aa5f36cb2461c190134929a29c3df726"),
-            address!("97ad070879be5c31a03a1fe7e35dfb7d51d0eef1"),
-            address!("97b65710d03e12775189f0d113202cc1443b0aa2"),
-            address!("98ecf3d8e21adaafe16c00cc3ff681e72690278b"),
-            address!("99043bb680ab9262c7b2ac524e00b215efb7db9b"),
-            address!("99ddddd8dfe33905338a073047cfad72e6833c06"),
-            address!("9a514389172863f12854ad40090aa4b928028542"),
-            address!("9af15d7b8776fa296019979e70a5be53c714a7ec"),
-            address!("9ea3b5b4ec044b70375236a281986106457b20ef"),
-            address!("9f41da75ab2b8c6f0dcef7173c4bf66bd4f6b36a"),
-            address!("a03f1250aa448226ed4066d8d1722ddd8b51df59"),
-            address!("a2b4c0af19cc16a6cfacce81f192b024d625817d"),
-            address!("a3e059c0b01f07f211c85bf7b4f1d907afb011df"),
-            address!("a5959e9412d27041194c3c3bcbe855face2864f7"),
-            address!("a9a8377287ea9c6b8b4249dd502e75d34148fc5b"),
-            address!("adaa92cba08434c22d036c4115a6b3d7e2b5569b"),
-            address!("aee53701e18d5ff6af4964c3a381e7d09b9b9075"),
-            address!("b893a8049f250b57efa8c62d51527a22404d7c9a"),
-            address!("B96f0e9bb32760091eb2D6B0A5Ca0D2C7b5644B1"),
-            address!("ba7435a4b4c747e0101780073eeda872a69bdcd4"),
-            address!("bae5f2d8a1299e5c4963eaff3312399253f27ccb"),
-            address!("bd36b14c63f483b286c7b49b6eaffb2fe10aabc4"),
-            address!("bdea5bb640dbfc4593809deec5cdb8f99b704cd2"),
-            address!("bf04e48c5d8880306591ef888cde201d3984eb3e"),
-            address!("bf25ea982b4f850dafb4a95367b890eee5a9e8f2"),
-            address!("bf494f02ee3fde1f20bee6242bce2d1ed0c15e47"),
-            address!("c03841b5135600312707d39eb2af0d2ad5d51a91"),
-            address!("c10bbb8fd399d580b740ed31ff5ac94aa78ba9ed"),
-            address!("c12d1c73ee7dc3615ba4e37e4abfdbddfa38907e"),
-            address!("c40af1e4fecfa05ce6bab79dcd8b373d2e436c4e"),
-            address!("c4d586ef7be9ebe80bd5ee4fbd228fe2db5f2c4e"),
-            address!("c50ef449171a51fbeafd7c562b064b6471c36caa"),
-            address!("c626d951eff8e421448074bd2ad7805c6d585793"),
-            address!("c73c167e7a4ba109e4052f70d5466d0c312a344d"),
-            address!("c7c24fe893c21e8a4ef46eaf31badcab9f362841"),
-            address!("cd7492db29e2ab436e819b249452ee1bbdf52214"),
-            address!("cf0c122c6b73ff809c693db761e7baebe62b6a2e"),
-            address!("cf2f589bea4645c3ef47f1f33bebf100bee66e05"),
-            address!("cf8c23cf17bb5815d5705a15486fa83805415625"),
-            address!("d0834d08c83dbe216811aaea0eeffb2349e57634"),
-            address!("d0d3ebcad6a20ce69bc3bc0e1ec964075425e533"),
-            address!("d1afbccc9a2c2187ea544363b986ea0ab6ef08b5"),
-            address!("d375a513692336cf9eebce5e38869b447948016f"),
-            address!("d3f6571be1d91ac68b40daaa24075ca7e2f0f72e"),
-            address!("d50825f50384bc40d5a10118996ef503b3670afd"),
-            address!("d5281bb2d1ee94866b03a0fccdd4e900c8cb5091"),
-            address!("da1e53e088023fe4d1dc5a418581748f52cbd1b8"),
-            address!("dd339f370bbb18b8f389bd0443329d82ecf4b593"),
-            // Should be denied because can't approve more than balance
-            address!("decade1c6bf2cd9fb89afad73e4a519c867adcf5"),
-            address!("dfdd3459d4f87234751696840092ee20c970fb07"),
-            address!("e0bdaafd0aab238c55d68ad54e616305d4a21772"),
-            address!("e2d66561b39eadbd488868af8493fb55d4b9d084"),
-            address!("e302bf71b1f6f3024e7642f9c824ac86b58436a0"),
-            address!("ea319e87cf06203dae107dd8e5672175e3ee976c"),
-            address!("ed5e5ab076ae60bdb9c49ac255553e65426a2167"),
-            address!("eeee2a622330e6d2036691e983dee87330588603"),
-            address!("ef5b32486ed432b804a51d129f4d2fbdf18057ec"),
-            address!("f1365ab39e192808b5301bcf6da973830e9e817f"),
-            address!("f198B4a2631B7D0B9FAc36f8B546Ed3DCe472A47"),
-            address!("fad45e47083e4607302aa43c65fb3106f1cd7607"),
-            address!("fcaa8eef70f373e00ac29208023d106c846259ee"),
-            address!("ff69e48af1174da7f15d0c771861c33d3f19ed8a"),
-        ];
-
-        // Of the deny listed tokens the following are detected as good:
-        // - token 0xc12d1c73ee7dc3615ba4e37e4abfdbddfa38907e Has some kind of
-        //   "freezing" mechanism where some balance is unusuable. We don't seem to
-        //   trigger it.
-        // - 0x910524678c0b1b23ffb9285a81f99c29c11cbaed Has some kind of time lock that
-        //   we don't encounter.
-        // - 0xed5e5ab076ae60bdb9c49ac255553e65426a2167 Not sure why deny listed.
-        // - 0x1337def18c680af1f9f45cbcab6309562975b1dd Not sure why deny listed, maybe
-        //   the callback that I didn't follow in the SC code.
-        // - 0x4f9254c83eb525f9fcf346490bbb3ed28a81c667 Not sure why deny listed.
-
-        let settlement = GPv2Settlement::Instance::deployed(&web3.provider)
-            .await
-            .unwrap();
-        let finder = Arc::new(TokenOwnerFinder {
-            web3: web3.clone(),
-            settlement_contract: *settlement.address(),
-            proposers: vec![
-                Arc::new(UniswapLikePairProviderFinder {
-                    inner: uniswap_v2::UniV2BaselineSourceParameters::from_baseline_source(
-                        BaselineSource::UniswapV2,
-                        &version,
-                    )
-                    .unwrap()
-                    .into_source(&web3)
-                    .await
-                    .unwrap()
-                    .pair_provider,
-                    base_tokens: base_tokens.to_vec(),
-                }),
-                Arc::new(UniswapLikePairProviderFinder {
-                    inner: uniswap_v2::UniV2BaselineSourceParameters::from_baseline_source(
-                        BaselineSource::SushiSwap,
-                        &version,
-                    )
-                    .unwrap()
-                    .into_source(&web3)
-                    .await
-                    .unwrap()
-                    .pair_provider,
-                    base_tokens: base_tokens.to_vec(),
-                }),
-                Arc::new(BalancerVaultFinder(
-                    BalancerV2Vault::Instance::deployed(&web3.provider)
-                        .await
-                        .unwrap(),
-                )),
-                Arc::new(
-                    UniswapV3Finder::new(
-                        IUniswapV3Factory::Instance::deployed(&web3.provider)
-                            .await
-                            .unwrap(),
-                        base_tokens.to_vec(),
-                        FeeValues::Static,
-                    )
-                    .await
-                    .unwrap(),
-                ),
-                Arc::new(
-                    BlockscoutTokenOwnerFinder::with_network(
-                        reqwest::Client::new(),
-                        &Chain::Mainnet,
-                    )
-                    .unwrap(),
-                ),
-            ],
-        });
-        let token_cache = TraceCallDetector::new(web3, *settlement.address(), finder);
-
-        println!("testing good tokens");
-        for &token in base_tokens {
-            let result = token_cache.detect(token).await;
-            println!("token {token:?} is {result:?}");
-        }
-
-        println!("testing bad tokens");
-        for &token in bad_tokens {
-            let result = token_cache.detect(token).await;
-            println!("token {token:?} is {result:?}");
-        }
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn mainnet_univ3() {
-        observe::tracing::initialize(&observe::Config::default().with_env_filter("shared=debug"));
-        let web3 = Web3::new_from_env();
-        let base_tokens = vec![testlib::tokens::WETH];
-        let settlement = GPv2Settlement::Instance::deployed(&web3.provider)
-            .await
-            .unwrap();
-        let factory = IUniswapV3Factory::Instance::deployed(&web3.provider)
-            .await
-            .unwrap();
-        let univ3 = Arc::new(
-            UniswapV3Finder::new(factory, base_tokens, FeeValues::Dynamic)
-                .await
-                .unwrap(),
-        );
-        let finder = Arc::new(TokenOwnerFinder {
-            web3: web3.clone(),
-            settlement_contract: *settlement.address(),
-            proposers: vec![univ3],
-        });
-        let token_cache = TraceCallDetector::new(web3, *settlement.address(), finder);
-
-        let result = token_cache.detect(testlib::tokens::USDC).await;
-        dbg!(&result);
-        assert!(result.unwrap().is_good());
-
-        let only_v3_token = address!("f1b99e3e573a1a9c5e6b2ce818b617f0e664e86b");
-        let result = token_cache.detect(only_v3_token).await;
-        dbg!(&result);
-        assert!(result.unwrap().is_good());
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn yearn_vault_tokens() {
-        let tokens = [
-            address!("1025b1641d1F23C289412Dd5E5701e9810103a93"),
-            address!("132d8D2C76Db3812403431fAcB00F3453Fc42125"),
-            address!("1635b506a88fBF428465Ad65d00e8d6B6E5846C3"),
-            address!("16825039dfe2a5b01F3E1E6a2BBF9a576c6F95c4"),
-            address!("1b905331F7dE2748F4D6a0678e1521E20347643F"),
-            address!("23D3D0f1c697247d5e0a9efB37d8b0ED0C464f7f"),
-            address!("25212Df29073FfFA7A67399AcEfC2dd75a831A1A"),
-            address!("27B5739e22ad9033bcBf192059122d163b60349D"),
-            address!("2D5D4869381C4Fce34789BC1D38aCCe747E295AE"),
-            address!("2DfB14E32e2F8156ec15a2c21c3A6c053af52Be8"),
-            address!("2a38B9B0201Ca39B17B460eD2f11e4929559071E"),
-            address!("2e5c7e9B1Da0D9Cb2832eBb06241d18552A85400"),
-            address!("30FCf7c6cDfC46eC237783D94Fc78553E79d4E9C"),
-            address!("341bb10D8f5947f3066502DC8125d9b8949FD3D6"),
-            address!("378cb52b00F9D0921cb46dFc099CFf73b42419dC"),
-            address!("39CAF13a104FF567f71fd2A4c68C026FDB6E740B"),
-            address!("3B27F92C0e212C671EA351827EDF93DB27cc0c65"),
-            address!("3B96d491f067912D18563d56858Ba7d6EC67a6fa"),
-            address!("3c5DF3077BcF800640B5DAE8c91106575a4826E6"),
-            address!("4560b99C904aAD03027B5178CCa81584744AC01f"),
-            address!("490bD0886F221A5F79713D3E84404355A9293C50"),
-            address!("4B5BfD52124784745c1071dcB244C6688d2533d3"),
-            address!("528D50dC9a333f01544177a924893FA1F5b9F748"),
-            address!("59518884EeBFb03e90a18ADBAAAB770d4666471e"),
-            address!("595a68a8c9D5C230001848B69b1947ee2A607164"),
-            address!("5AB64C599FcC59f0f2726A300b03166A395578Da"),
-            address!("5a770DbD3Ee6bAF2802D29a901Ef11501C44797A"),
-            address!("5c0A86A32c129538D62C106Eb8115a8b02358d57"),
-            address!("5e69e8b51B71C8596817fD442849BD44219bb095"),
-            address!("5fA5B62c8AF877CB37031e0a3B2f34A78e3C56A6"),
-            address!("625b7DF2fa8aBe21B0A976736CDa4775523aeD1E"),
-            address!("671a912C10bba0CFA74Cfc2d6Fba9BA1ed9530B2"),
-            address!("67e019bfbd5a67207755D04467D6A70c0B75bF60"),
-            address!("6A5468752f8DB94134B6508dAbAC54D3b45efCE6"),
-            address!("6B5ce31AF687a671a804d8070Ddda99Cab926dfE"),
-            address!("6Ede7F19df5df6EF23bD5B9CeDb651580Bdf56Ca"),
-            address!("6d765CbE5bC922694afE112C140b8878b9FB0390"),
-            address!("7047F90229a057C13BF847C0744D646CFb6c9E1A"),
-            address!("718AbE90777F5B778B52D553a5aBaa148DD0dc5D"),
-            address!("790a60024bC3aea28385b60480f15a0771f26D09"),
-            address!("801Ab06154Bf539dea4385a39f5fa8534fB53073"),
-            address!("8414Db07a7F743dEbaFb402070AB01a4E0d2E45e"),
-            address!("84E13785B5a27879921D6F685f041421C7F482dA"),
-            address!("873fB544277FD7b977B196a826459a69E27eA4ea"),
-            address!("8b9C0c24307344B6D7941ab654b2Aeee25347473"),
-            address!("8cc94ccd0f3841a468184aCA3Cc478D2148E1757"),
-            address!("8ee57c05741aA9DB947A744E713C15d4d19D8822"),
-            address!("8fA3A9ecd9EFb07A8CE90A6eb014CF3c0E3B32Ef"),
-            address!("9A39f31DD5EDF5919A5C0c2433cE053fAD2E0336"),
-            address!("9d409a0A012CFbA9B15F6D4B36Ac57A46966Ab9a"),
-            address!("A696a63cc78DfFa1a63E9E50587C197387FF6C7E"),
-            address!("A74d4B67b3368E83797a35382AFB776bAAE4F5C8"),
-            address!("A9412Ffd7E0866755ae0dda3318470A61F62abe8"),
-            address!("B4AdA607B9d6b2c9Ee07A275e9616B84AC560139"),
-            address!("BCBB5b54Fa51e7b7Dc920340043B203447842A6b"),
-            address!("Bfedbcbe27171C418CDabC2477042554b1904857"),
-            address!("C4dAf3b5e2A9e93861c3FBDd25f1e943B8D87417"),
-            address!("D6Ea40597Be05c201845c0bFd2e96A60bACde267"),
-            address!("E537B5cc158EB71037D4125BDD7538421981E6AA"),
-            address!("E5eDcE53e39Cbc6d819E2C340BCF295e0084ff7c"),
-            address!("F29AE508698bDeF169B89834F76704C3B205aedf"),
-            address!("F59D66c1d593Fb10e2f8c2a6fD2C958792434B9c"),
-            address!("F6B9DFE6bc42ed2eaB44D6B829017f7B78B29f88"),
-            address!("FBEB78a723b8087fD2ea7Ef1afEc93d35E8Bed42"),
-            address!("FD0877d9095789cAF24c98F7CCe092fa8E120775"),
-            address!("a258C4606Ca8206D8aA700cE2143D7db854D168c"),
-            address!("a354F35829Ae975e850e23e9615b11Da1B3dC4DE"),
-            address!("b09F2a67a731466182518fae980feAe96479d80b"),
-            address!("b4D1Be44BfF40ad6e506edf43156577a3f8672eC"),
-            address!("c5F3D11580c41cD07104e9AF154Fc6428bb93c73"),
-            address!("c97232527B62eFb0D8ed38CF3EA103A6CcA4037e"),
-            address!("c97511a1dDB162C8742D39FF320CfDCd13fBcf7e"),
-            address!("d88dBBA3f9c4391Ee46f5FF548f289054db6E51C"),
-            address!("d8C620991b8E626C099eAaB29B1E3eEa279763bb"),
-            address!("d9788f3931Ede4D5018184E198699dC6d66C1915"),
-            address!("dA816459F1AB5631232FE5e97a05BBBb94970c95"),
-            address!("db25cA703181E7484a155DD612b06f57E12Be5F0"),
-            address!("e9Dc63083c464d6EDcCFf23444fF3CFc6886f6FB"),
-            address!("f2db9a7c0ACd427A680D640F02d90f6186E71725"),
-            address!("f8768814b88281DE4F532a3beEfA5b85B69b9324"),
-        ];
-
-        let solver_token_finder = Arc::new(AutoUpdatingSolverTokenOwnerFinder::new(
-            Box::new(SolverConfiguration {
-                url: env::var("SOLVER_TOKEN_OWNERS_URLS")
-                    .unwrap()
-                    .parse()
-                    .unwrap(),
-                client: reqwest::Client::new(),
-            }),
-            Duration::MAX,
-            "test".to_owned(),
-        ));
-
-        // Force the cache to update at least once.
-        solver_token_finder.update().await.unwrap();
-
-        let web3 = Web3::new_from_env();
-
-        let settlement = GPv2Settlement::Instance::deployed(&web3.provider)
-            .await
-            .unwrap();
-        let finder = Arc::new(TokenOwnerFinder {
-            web3: web3.clone(),
-            proposers: vec![solver_token_finder],
-            settlement_contract: *settlement.address(),
-        });
-        let token_cache = TraceCallDetector::new(web3, *settlement.address(), finder);
-
-        for token in tokens {
-            let result = token_cache.detect(token).await;
-            println!("token {token:?} is {result:?}");
-        }
-    }
 }

From 32b0408f0c2840a23dcc5d9f44dfd522e2afe0ce Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 13 Feb 2026 17:52:33 +0000
Subject: [PATCH 064/219] Bound native price cache with moka (#4154)

# Description
The native price cache is backed by an unbounded `Mutex<HashMap<Address,
CachedResult>>`. Entries are inserted on every price estimate but never
removed. Once at steady state with many unique tokens, the cache grows
without bound.

The size limit is currently hardcoded at 20k, since on mainnet we have
around that number of unique tokens:
```sql
SELECT COUNT(*) AS unique_token_count
FROM (SELECT sell_token AS token
      FROM orders
      UNION
      SELECT buy_token AS token
      FROM orders) t;

Returns -> 20109
```

Per cache entry breakdown:
- CachedResult value: ~32 bytes
- Address key: 20 bytes
- Moka internal overhead: ~100-120 bytes
- Total per entry: ~170 bytes

At 20,000 entries: ~3.4 MB upper bound

# Changes

- Replace the `Mutex<HashMap<...>>` cache with `moka::sync::Cache`.
- Adapt get_cached_price():
- No more MutexGuard parameter. Use data.get(&token) which returns
Option<CachedResult> (moka clones the value). Check staleness +
is_ready() on the returned value. No `requested_at` to update, since
moka tracks access internally.
- Remove the `requested_at` field from the `CachedResult` since it is
not needed anymore and turned out to be dead code.
- Adapt the `insert()` function to use
`entry_by_ref().and_compute_with()`, which gives gives atomic
read-modify-write for `accumulative_errors_count`.

## How to test
Existing tests.
---
 Cargo.lock                                    |  1 +
 crates/shared/Cargo.toml                      |  1 +
 .../price_estimation/native_price_cache.rs    | 78 +++++++++----------
 3 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 422f11eeb6..c40ca9c023 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6154,6 +6154,7 @@ dependencies = [
  "maplit",
  "mockall",
  "model",
+ "moka",
  "num",
  "number",
  "observe",
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 752be21c00..b156517aec 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -53,6 +53,7 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 url = { workspace = true }
 
+moka = { workspace = true, features = ["sync"] }
 mockall = { workspace = true, optional = true }
 
 [dev-dependencies]
diff --git a/crates/shared/src/price_estimation/native_price_cache.rs b/crates/shared/src/price_estimation/native_price_cache.rs
index 201d3dc3a5..87b98e1642 100644
--- a/crates/shared/src/price_estimation/native_price_cache.rs
+++ b/crates/shared/src/price_estimation/native_price_cache.rs
@@ -13,7 +13,7 @@ use {
     rand::Rng,
     std::{
         collections::{HashMap, HashSet},
-        sync::{Arc, Mutex, MutexGuard},
+        sync::Arc,
         time::{Duration, Instant},
     },
     tokio::time,
@@ -94,7 +94,6 @@ type CacheEntry = Result<f64, PriceEstimationError>;
 struct CachedResult {
     result: CacheEntry,
     updated_at: Instant,
-    requested_at: Instant,
     accumulative_errors_count: u32,
 }
 
@@ -112,14 +111,12 @@ impl CachedResult {
         Self {
             result,
             updated_at: now,
-            requested_at: now,
             accumulative_errors_count: u32::from(is_accumulating_error),
         }
     }
 
     fn update(&mut self, result: CacheEntry) {
         let now = Instant::now();
-        self.requested_at = now;
         self.updated_at = now;
         self.accumulative_errors_count = match result {
             Err(PriceEstimationError::EstimatorInternal(_)) => self.accumulative_errors_count + 1,
@@ -159,8 +156,10 @@ fn should_cache(result: &Result<f64, PriceEstimationError>) -> bool {
 #[derive(Clone)]
 pub struct Cache(Arc<CacheInner>);
 
+const MAX_CACHE_SIZE: u64 = 20_000;
+
 struct CacheInner {
-    data: Mutex<HashMap<Address, CachedResult>>,
+    data: moka::sync::Cache<Address, CachedResult>,
     max_age: Duration,
 }
 
@@ -169,26 +168,25 @@ impl Cache {
         let mut rng = rand::thread_rng();
         let now = std::time::Instant::now();
 
-        let data = initial_prices
-            .into_iter()
-            .filter_map(|(token, price)| {
+        let data = moka::sync::Cache::builder()
+            .max_capacity(MAX_CACHE_SIZE)
+            .build();
+
+        for (token, price) in initial_prices {
+            if let Some(price) = from_normalized_price(price) {
                 let updated_at = Self::random_updated_at(max_age, now, &mut rng);
-                Some((
+                data.insert(
                     token,
                     CachedResult {
-                        result: Ok(from_normalized_price(price)?),
+                        result: Ok(price),
                         updated_at,
-                        requested_at: now,
                         accumulative_errors_count: 0,
                     },
-                ))
-            })
-            .collect::<HashMap<_, _>>();
-
-        Self(Arc::new(CacheInner {
-            data: Mutex::new(data),
-            max_age,
-        }))
+                );
+            }
+        }
+
+        Self(Arc::new(CacheInner { data, max_age }))
     }
 
     fn max_age(&self) -> Duration {
@@ -205,19 +203,19 @@ impl Cache {
     }
 
     fn len(&self) -> usize {
-        self.0.data.lock().unwrap().len()
+        // Should never fire since we are bounded with MAX_CACHE_SIZE
+        usize::try_from(self.0.data.entry_count()).expect("cache size should fit in a usize")
     }
 
     fn get_cached_price(
         token: Address,
         now: Instant,
-        cache: &mut MutexGuard<HashMap<Address, CachedResult>>,
+        cache: &moka::sync::Cache<Address, CachedResult>,
         max_age: &Duration,
     ) -> Option<CachedResult> {
-        let entry = cache.get_mut(&token)?;
-        entry.requested_at = now;
+        let entry = cache.get(&token)?;
         let is_recent = now.saturating_duration_since(entry.updated_at) < *max_age;
-        (is_recent && entry.is_ready()).then_some(entry.clone())
+        (is_recent && entry.is_ready()).then_some(entry)
     }
 
     /// Only returns prices that are currently cached.
@@ -226,10 +224,9 @@ impl Cache {
         tokens: &[Address],
     ) -> HashMap<Address, Result<f64, PriceEstimationError>> {
         let now = Instant::now();
-        let mut cache = self.0.data.lock().unwrap();
         let mut results = HashMap::default();
         for token in tokens {
-            let cached = Self::get_cached_price(*token, now, &mut cache, &self.0.max_age);
+            let cached = Self::get_cached_price(*token, now, &self.0.data, &self.0.max_age);
             let label = if cached.is_some() { "hits" } else { "misses" };
             CacheMetrics::get()
                 .native_price_cache_access
@@ -243,11 +240,17 @@ impl Cache {
     }
 
     fn insert(&self, token: Address, result: CacheEntry) {
-        let mut cache = self.0.data.lock().unwrap();
-        cache
-            .entry(token)
-            .and_modify(|value| value.update(result.clone()))
-            .or_insert_with(|| CachedResult::new(result));
+        self.0
+            .data
+            .entry_by_ref(&token)
+            .and_upsert_with(|maybe_entry| match maybe_entry {
+                Some(entry) => {
+                    let mut cached = entry.into_value();
+                    cached.update(result);
+                    cached
+                }
+                None => CachedResult::new(result),
+            });
     }
 }
 
@@ -311,11 +314,10 @@ impl CachingNativePriceEstimator {
         let estimates = tokens.into_iter().map(move |token| async move {
             // check if the price is cached by now
             let now = Instant::now();
+            if let Some(cached) =
+                Cache::get_cached_price(token, now, &self.0.cache.0.data, &max_age)
             {
-                let mut cache = self.0.cache.0.data.lock().unwrap();
-                if let Some(cached) = Cache::get_cached_price(token, now, &mut cache, &max_age) {
-                    return (token, cached.result);
-                }
+                return (token, cached.result);
             }
 
             let approximation = self
@@ -390,8 +392,7 @@ impl NativePriceEstimating for CachingNativePriceEstimator {
         async move {
             let cached = {
                 let now = Instant::now();
-                let mut cache = self.0.cache.0.data.lock().unwrap();
-                Cache::get_cached_price(token, now, &mut cache, &self.0.cache.0.max_age)
+                Cache::get_cached_price(token, now, &self.0.cache.0.data, &self.0.cache.0.max_age)
             };
 
             let label = if cached.is_some() { "hits" } else { "misses" };
@@ -565,8 +566,7 @@ mod tests {
         {
             // Check that `updated_at` timestamps are initialized with
             // reasonable values.
-            let data = estimator.cache().0.data.lock().unwrap();
-            for value in data.values() {
+            for (_, value) in &estimator.cache().0.data {
                 let elapsed = value.updated_at.elapsed();
                 assert!(elapsed >= min_age && elapsed <= max_age);
             }

From 5b7d56e03c690782f794cb802f324ea2688027cb Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Feb 2026 23:41:04 +0100
Subject: [PATCH 065/219] Simplify deny listed tokens (#4157)

# Description
Originally the orderbook and autopilot tried to detect tokens with
unsupported behavior with sophisticated simulations.
Since then we:
* onboarded more solvers that could handle tokens that were previously
causing issues
* introduced quote simulation that can detect such tokens more reliably
* moved towards minimal intervention for problematic tokens in the
protocol itself

Today the only thing we actually make use of is a list of tokens that
are actually deny listed. Those should probably be revisited as well but
for now I decided to only simplify the code we have today while keeping
feature parity.

# Changes
- turned `ListBasedDetector` into a simple wrapper around a HashSet
- given that there is no more complicated or fallible logic in the
detection mechanism I decided to drop the instrumentation as well

This simplification should also drastically reduce the ~30ms we
currently spend on filtering out orders that trade deny-listed tokens.
<img width="617" height="87" alt="Screenshot 2026-02-13 at 16 57 47"
src="https://github.com/user-attachments/assets/6939d048-32ae-4be3-80b6-3816456d6ac6"
/>


## How to test
existing e2e tests
---
 crates/autopilot/src/arguments.rs             |   8 -
 crates/autopilot/src/run.rs                   |  29 +---
 crates/autopilot/src/solvable_orders.rs       |  73 +++------
 crates/orderbook/src/arguments.rs             |   8 -
 crates/orderbook/src/run.rs                   |  31 +---
 crates/shared/src/arguments.rs                |   7 -
 crates/shared/src/bad_token/instrumented.rs   |  73 ---------
 crates/shared/src/bad_token/list_based.rs     | 148 ++----------------
 crates/shared/src/bad_token/mod.rs            |  10 --
 crates/shared/src/order_validation.rs         | 118 +++-----------
 crates/shared/src/price_estimation/factory.rs |  10 +-
 .../shared/src/price_estimation/sanitized.rs  |  44 ++----
 12 files changed, 86 insertions(+), 473 deletions(-)
 delete mode 100644 crates/shared/src/bad_token/instrumented.rs

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 689be1705b..1b8c592e7e 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -70,12 +70,6 @@ pub struct Arguments {
     #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
     pub skip_event_sync: bool,
 
-    /// List of token addresses that should be allowed regardless of whether the
-    /// bad token detector thinks they are bad. Base tokens are
-    /// automatically allowed.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub allowed_tokens: Vec<Address>,
-
     /// List of token addresses to be ignored throughout service
     #[clap(long, env, use_value_delimiter = true)]
     pub unsupported_tokens: Vec<Address>,
@@ -291,7 +285,6 @@ impl std::fmt::Display for Arguments {
             metrics_address,
             api_address,
             skip_event_sync,
-            allowed_tokens,
             unsupported_tokens,
             native_price_estimators,
             api_native_price_estimators,
@@ -338,7 +331,6 @@ impl std::fmt::Display for Arguments {
         writeln!(f, "api_address: {api_address}")?;
         display_secret_option(f, "db_write_url", Some(&db_write_url))?;
         writeln!(f, "skip_event_sync: {skip_event_sync}")?;
-        writeln!(f, "allowed_tokens: {allowed_tokens:?}")?;
         writeln!(f, "unsupported_tokens: {unsupported_tokens:?}")?;
         writeln!(f, "native_price_estimators: {native_price_estimators}")?;
         display_option(
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 1bc6d4f40f..9c973aab7d 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -35,11 +35,7 @@ use {
     shared::{
         account_balances::{self, BalanceSimulator},
         arguments::tracing_config,
-        bad_token::{
-            instrumented::InstrumentedBadTokenDetectorExt,
-            list_based::{ListBasedDetector, UnknownTokenStrategy},
-        },
-        baseline_solver::BaseTokens,
+        bad_token::list_based::DenyListedTokens,
         code_fetching::CachedCodeFetcher,
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
@@ -262,23 +258,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .expect("failed to create gas price estimator"),
     );
 
-    let base_tokens = Arc::new(BaseTokens::new(
-        *eth.contracts().weth().address(),
-        &args.shared.base_tokens,
-    ));
-    let mut allowed_tokens = args.allowed_tokens.clone();
-    allowed_tokens.extend(base_tokens.tokens().iter());
-    allowed_tokens.push(model::order::BUY_ETH_ADDRESS);
-    let unsupported_tokens = args.unsupported_tokens.clone();
-
-    let bad_token_detector = Arc::new(
-        ListBasedDetector::new(
-            allowed_tokens,
-            unsupported_tokens,
-            UnknownTokenStrategy::Allow,
-        )
-        .instrumented(),
-    );
+    let deny_listed_tokens = DenyListedTokens::new(args.unsupported_tokens.clone());
 
     let token_info_fetcher = Arc::new(CachedTokenInfoFetcher::new(Arc::new(TokenInfoFetcher {
         web3: web3.clone(),
@@ -303,12 +283,11 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
                 .call()
                 .await
                 .expect("failed to query solver authenticator address"),
-            base_tokens: base_tokens.clone(),
             block_stream: eth.current_block().clone(),
         },
         factory::Components {
             http_factory: http_factory.clone(),
-            bad_token_detector: bad_token_detector.clone(),
+            deny_listed_tokens: deny_listed_tokens.clone(),
             tokens: token_info_fetcher.clone(),
             code_fetcher: code_fetcher.clone(),
         },
@@ -459,7 +438,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
             args.banned_users_max_cache_size.get().to_u64().unwrap(),
         ),
         balance_fetcher.clone(),
-        bad_token_detector.clone(),
+        deny_listed_tokens.clone(),
         competition_native_price_updater.clone(),
         *eth.contracts().weth().address(),
         domain::ProtocolFees::new(
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 2d427cd15f..92cc5605c2 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -7,7 +7,7 @@ use {
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result},
     database::order_events::OrderEventLabel,
-    futures::{FutureExt, future::join_all},
+    futures::FutureExt,
     itertools::Itertools,
     model::{
         order::{Order, OrderClass, OrderUid},
@@ -17,7 +17,7 @@ use {
     prometheus::{Histogram, HistogramVec, IntCounter, IntCounterVec, IntGauge, IntGaugeVec},
     shared::{
         account_balances::{BalanceFetching, Query},
-        bad_token::BadTokenDetecting,
+        bad_token::list_based::DenyListedTokens,
         price_estimation::{
             native::{NativePriceEstimating, to_normalized_price},
             native_price_cache::NativePriceUpdater,
@@ -124,7 +124,7 @@ pub struct SolvableOrdersCache {
     persistence: infra::Persistence,
     banned_users: banned::Users,
     balance_fetcher: Arc<dyn BalanceFetching>,
-    bad_token_detector: Arc<dyn BadTokenDetecting>,
+    deny_listed_tokens: DenyListedTokens,
     cache: Mutex<Option<Inner>>,
     native_price_estimator: Arc<NativePriceUpdater>,
     weth: Address,
@@ -150,7 +150,7 @@ impl SolvableOrdersCache {
         persistence: infra::Persistence,
         banned_users: banned::Users,
         balance_fetcher: Arc<dyn BalanceFetching>,
-        bad_token_detector: Arc<dyn BadTokenDetecting>,
+        deny_listed_tokens: DenyListedTokens,
         native_price_estimator: Arc<NativePriceUpdater>,
         weth: Address,
         protocol_fees: domain::ProtocolFees,
@@ -164,7 +164,7 @@ impl SolvableOrdersCache {
             persistence,
             banned_users,
             balance_fetcher,
-            bad_token_detector,
+            deny_listed_tokens,
             cache: Mutex::new(None),
             native_price_estimator,
             weth,
@@ -432,16 +432,13 @@ impl SolvableOrdersCache {
     ) -> Vec<Arc<Order>> {
         let presignature_pending_orders = find_presignature_pending_orders(&orders);
 
-        let (banned_user_orders, unsupported_token_orders) = tokio::join!(
-            self.timed_future(
+        let unsupported_token_orders = find_unsupported_tokens(&orders, &self.deny_listed_tokens);
+        let banned_user_orders = self
+            .timed_future(
                 "banned_user_filtering",
-                find_banned_user_orders(&orders, &self.banned_users)
-            ),
-            self.timed_future(
-                "unsupported_token_filtering",
-                find_unsupported_tokens(&orders, self.bad_token_detector.clone())
-            ),
-        );
+                find_banned_user_orders(&orders, &self.banned_users),
+            )
+            .await;
         tracing::trace!("filtered invalid orders");
 
         Metrics::track_filtered_orders("banned_user", &banned_user_orders);
@@ -670,46 +667,16 @@ async fn get_orders_with_native_prices(
     (orders, removed_orders, prices)
 }
 
-async fn find_unsupported_tokens(
+fn find_unsupported_tokens(
     orders: &[Arc<Order>],
-    bad_token: Arc<dyn BadTokenDetecting>,
+    deny_listed_tokens: &DenyListedTokens,
 ) -> Vec<OrderUid> {
-    let bad_tokens = join_all(
-        orders
-            .iter()
-            .flat_map(|o| o.data.token_pair().into_iter().flatten())
-            .unique()
-            .map(|token| {
-                let bad_token = bad_token.clone();
-                async move {
-                    match bad_token.detect(token).await {
-                        Ok(quality) => (!quality.is_good()).then_some(token),
-                        Err(err) => {
-                            tracing::warn!(
-                                ?token,
-                                ?err,
-                                "unable to determine token quality, assume good"
-                            );
-                            Some(token)
-                        }
-                    }
-                }
-            }),
-    )
-    .await
-    .into_iter()
-    .flatten()
-    .collect::<HashSet<_>>();
-
     orders
         .iter()
         .filter_map(|order| {
-            order
-                .data
-                .token_pair()
-                .into_iter()
-                .flatten()
-                .any(|token| bad_tokens.contains(&token))
+            [&order.data.buy_token, &order.data.sell_token]
+                .iter()
+                .any(|token| deny_listed_tokens.contains(token))
                 .then_some(order.metadata.uid)
         })
         .collect()
@@ -724,7 +691,7 @@ mod tests {
         maplit::{btreemap, hashset},
         model::order::{OrderBuilder, OrderData, OrderMetadata, OrderUid},
         shared::{
-            bad_token::list_based::ListBasedDetector,
+            bad_token::list_based::DenyListedTokens,
             price_estimation::{
                 HEALTHY_PRICE_ESTIMATION_TIME,
                 PriceEstimationError,
@@ -1095,7 +1062,7 @@ mod tests {
         let token0 = Address::with_last_byte(0);
         let token1 = Address::with_last_byte(1);
         let token2 = Address::with_last_byte(2);
-        let bad_token = Arc::new(ListBasedDetector::deny_list(vec![token0]));
+        let deny_listed_tokens = DenyListedTokens::new(vec![token0]);
         let orders = vec![
             Arc::new(
                 OrderBuilder::default()
@@ -1116,9 +1083,7 @@ mod tests {
                     .build(),
             ),
         ];
-        let unsupported_tokens_orders = find_unsupported_tokens(&orders, bad_token)
-            .now_or_never()
-            .unwrap();
+        let unsupported_tokens_orders = find_unsupported_tokens(&orders, &deny_listed_tokens);
         assert_eq!(
             unsupported_tokens_orders,
             [orders[0].metadata.uid, orders[2].metadata.uid]
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index 11273c5406..9f40f7a120 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -96,12 +96,6 @@ pub struct Arguments {
     #[clap(long, env, default_value = "2")]
     pub fast_price_estimation_results_required: NonZeroUsize,
 
-    /// List of token addresses that should be allowed regardless of whether the
-    /// bad token detector thinks they are bad. Base tokens are
-    /// automatically allowed.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub allowed_tokens: Vec<Address>,
-
     /// Skip EIP-1271 order signature validation on creation.
     #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
     pub eip1271_skip_creation_validation: bool,
@@ -177,7 +171,6 @@ impl std::fmt::Display for Arguments {
             unsupported_tokens,
             banned_users,
             banned_users_max_cache_size,
-            allowed_tokens,
             eip1271_skip_creation_validation,
             native_price_estimators,
             fast_price_estimation_results_required,
@@ -220,7 +213,6 @@ impl std::fmt::Display for Arguments {
             f,
             "banned_users_max_cache_size: {banned_users_max_cache_size:?}"
         )?;
-        writeln!(f, "allowed_tokens: {allowed_tokens:?}")?;
         writeln!(
             f,
             "eip1271_skip_creation_validation: {eip1271_skip_creation_validation}"
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 5e353e3c33..3be02485fb 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -21,18 +21,14 @@ use {
         WETH9,
         support::Balances,
     },
-    model::{DomainSeparator, order::BUY_ETH_ADDRESS},
+    model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::{DEFAULT_METRICS_PORT, serve_metrics},
     order_validation,
     shared::{
         account_balances::{self, BalanceSimulator},
         arguments::tracing_config,
-        bad_token::{
-            instrumented::InstrumentedBadTokenDetectorExt,
-            list_based::{ListBasedDetector, UnknownTokenStrategy},
-        },
-        baseline_solver::BaseTokens,
+        bad_token::list_based::DenyListedTokens,
         code_fetching::CachedCodeFetcher,
         gas_price::InstrumentedGasEstimator,
         http_client::HttpClientFactory,
@@ -196,23 +192,7 @@ pub async fn run(args: Arguments) {
         .expect("failed to create gas price estimator"),
     ));
 
-    let base_tokens = Arc::new(BaseTokens::new(
-        *native_token.address(),
-        &args.shared.base_tokens,
-    ));
-    let mut allowed_tokens = args.allowed_tokens.clone();
-    allowed_tokens.extend(base_tokens.tokens().iter());
-    allowed_tokens.push(BUY_ETH_ADDRESS);
-    let unsupported_tokens = args.unsupported_tokens.clone();
-
-    let bad_token_detector = Arc::new(
-        ListBasedDetector::new(
-            allowed_tokens,
-            unsupported_tokens,
-            UnknownTokenStrategy::Allow,
-        )
-        .instrumented(),
-    );
+    let deny_listed_tokens = DenyListedTokens::new(args.unsupported_tokens.clone());
 
     let current_block_stream = args
         .shared
@@ -241,12 +221,11 @@ pub async fn run(args: Arguments) {
                 .call()
                 .await
                 .expect("failed to query solver authenticator address"),
-            base_tokens: base_tokens.clone(),
             block_stream: current_block_stream.clone(),
         },
         factory::Components {
             http_factory: http_factory.clone(),
-            bad_token_detector: bad_token_detector.clone(),
+            deny_listed_tokens: deny_listed_tokens.clone(),
             tokens: token_info_fetcher.clone(),
             code_fetcher: code_fetcher.clone(),
         },
@@ -348,7 +327,7 @@ pub async fn run(args: Arguments) {
         )),
         validity_configuration,
         args.eip1271_skip_creation_validation,
-        bad_token_detector.clone(),
+        deny_listed_tokens.clone(),
         hooks_contract,
         optimal_quoter.clone(),
         balance_fetcher,
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 3474375cbb..a01f2a7dc3 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -187,11 +187,6 @@ pub struct Arguments {
     )]
     pub gas_estimators: Vec<GasEstimatorType>,
 
-    /// Base tokens used for finding multi-hop paths between multiple AMMs
-    /// Should be the most liquid tokens of the given network.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub base_tokens: Vec<Address>,
-
     /// The time between new blocks on the network.
     #[clap(long, env, value_parser = humantime::parse_duration)]
     pub network_block_interval: Option<Duration>,
@@ -314,7 +309,6 @@ impl Display for Arguments {
             chain_id,
             simulation_node_url,
             gas_estimators,
-            base_tokens,
             network_block_interval,
             settlement_contract_address,
             balances_contract_address,
@@ -335,7 +329,6 @@ impl Display for Arguments {
         display_option(f, "chain_id", chain_id)?;
         display_option(f, "simulation_node_url", simulation_node_url)?;
         writeln!(f, "gas_estimators: {gas_estimators:?}")?;
-        writeln!(f, "base_tokens: {base_tokens:?}")?;
         display_option(
             f,
             "network_block_interval",
diff --git a/crates/shared/src/bad_token/instrumented.rs b/crates/shared/src/bad_token/instrumented.rs
deleted file mode 100644
index d6a876b406..0000000000
--- a/crates/shared/src/bad_token/instrumented.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use {
-    super::{BadTokenDetecting, TokenQuality},
-    alloy::primitives::Address,
-    anyhow::Result,
-    prometheus::IntCounterVec,
-    prometheus_metric_storage::MetricStorage,
-    tracing::Instrument,
-};
-
-pub trait InstrumentedBadTokenDetectorExt {
-    fn instrumented(self) -> InstrumentedBadTokenDetector;
-}
-
-impl<T: BadTokenDetecting + 'static> InstrumentedBadTokenDetectorExt for T {
-    fn instrumented(self) -> InstrumentedBadTokenDetector {
-        InstrumentedBadTokenDetector {
-            inner: Box::new(self),
-        }
-    }
-}
-
-#[derive(MetricStorage, Clone, Debug)]
-#[metric(subsystem = "token_quality")]
-struct Metrics {
-    /// Tracks how many token detections result in good or bad token quality or
-    /// an error.
-    #[metric(labels("quality"))]
-    results: IntCounterVec,
-}
-
-pub struct InstrumentedBadTokenDetector {
-    inner: Box<dyn BadTokenDetecting>,
-}
-
-#[async_trait::async_trait]
-impl BadTokenDetecting for InstrumentedBadTokenDetector {
-    async fn detect(&self, token: Address) -> Result<TokenQuality> {
-        let result = self
-            .inner
-            .detect(token)
-            .instrument(tracing::info_span!(
-                "token_quality",
-                token = format!("{token:#x}")
-            ))
-            .await;
-
-        let label = match &result {
-            Ok(TokenQuality::Good) => "good",
-            // prometheus isn't very good for string based data so we simply log the bad
-            // tokens/errors and get the information from Kibana when we need it.
-            Err(err) => {
-                tracing::warn!(
-                    "bad token detection for {:?} returned error:\n{:?}",
-                    token,
-                    err
-                );
-                "error"
-            }
-            Ok(quality @ TokenQuality::Bad { .. }) => {
-                tracing::debug!("bad token detection for {:?} returned {:?}", token, quality);
-                "bad"
-            }
-        };
-
-        Metrics::instance(observe::metrics::get_storage_registry())
-            .expect("unexpected error getting metrics instance")
-            .results
-            .with_label_values(&[label])
-            .inc();
-
-        result
-    }
-}
diff --git a/crates/shared/src/bad_token/list_based.rs b/crates/shared/src/bad_token/list_based.rs
index 9731716b0f..27bd55a3c5 100644
--- a/crates/shared/src/bad_token/list_based.rs
+++ b/crates/shared/src/bad_token/list_based.rs
@@ -1,146 +1,26 @@
 use {
-    super::{BadTokenDetecting, TokenQuality},
     alloy::primitives::Address,
-    anyhow::Result,
-    std::sync::Arc,
-    tracing::instrument,
+    std::{collections::HashSet, sync::Arc},
 };
 
-/// If a token is neither in the allow nor the deny list treat it this way.
-pub enum UnknownTokenStrategy {
-    Allow,
-    Deny,
-    Forward(Arc<dyn BadTokenDetecting>),
-}
+/// Explicitly deny listed tokens.
+#[derive(Default, Clone)]
+pub struct DenyListedTokens(Arc<Inner>);
 
-/// Classify tokens with explicit allow and deny lists.
-pub struct ListBasedDetector {
-    allow_list: Vec<Address>,
-    deny_list: Vec<Address>,
-    strategy: UnknownTokenStrategy,
+#[derive(Default)]
+struct Inner {
+    deny_list: HashSet<Address>,
 }
 
-impl ListBasedDetector {
-    /// Panics if same token is both allowed and denied.
-    pub fn new(
-        allow_list: Vec<Address>,
-        deny_list: Vec<Address>,
-        strategy: UnknownTokenStrategy,
-    ) -> Self {
-        assert!(
-            allow_list.iter().all(|token| !deny_list.contains(token)),
-            "token is allowed and denied"
-        );
-        Self {
-            allow_list,
-            deny_list,
-            strategy,
-        }
-    }
-
-    pub fn deny_list(list: Vec<Address>) -> Self {
-        Self {
-            allow_list: Vec::new(),
-            deny_list: list,
-            strategy: UnknownTokenStrategy::Allow,
-        }
+impl DenyListedTokens {
+    pub fn new(deny_list: Vec<Address>) -> Self {
+        let deny_list = deny_list.into_iter().collect();
+        Self(Arc::new(Inner { deny_list }))
     }
 }
 
-#[async_trait::async_trait]
-impl BadTokenDetecting for ListBasedDetector {
-    #[instrument(skip_all)]
-    async fn detect(&self, token: Address) -> Result<TokenQuality> {
-        if self.allow_list.contains(&token) {
-            return Ok(TokenQuality::Good);
-        }
-
-        if self.deny_list.contains(&token) {
-            return Ok(TokenQuality::Bad {
-                reason: "token is explicitly deny listed".to_string(),
-            });
-        }
-
-        match &self.strategy {
-            UnknownTokenStrategy::Allow => Ok(TokenQuality::Good),
-            UnknownTokenStrategy::Deny => Ok(TokenQuality::Bad {
-                reason: "token is not allow listed".to_string(),
-            }),
-            UnknownTokenStrategy::Forward(inner) => inner.detect(token).await,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, crate::bad_token::MockBadTokenDetecting, futures::FutureExt};
-
-    #[test]
-    fn uses_lists() {
-        // Would panic if used.
-        let inner = MockBadTokenDetecting::new();
-        let detector = ListBasedDetector {
-            allow_list: vec![Address::with_last_byte(0)],
-            deny_list: vec![Address::with_last_byte(1)],
-            strategy: UnknownTokenStrategy::Forward(Arc::new(inner)),
-        };
-
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(result.unwrap().is_good());
-
-        let result = detector
-            .detect(Address::with_last_byte(1))
-            .now_or_never()
-            .unwrap();
-        assert!(!result.unwrap().is_good());
-    }
-
-    #[test]
-    fn not_in_list_default() {
-        let detector = ListBasedDetector {
-            allow_list: Vec::new(),
-            deny_list: Vec::new(),
-            strategy: UnknownTokenStrategy::Allow,
-        };
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(result.unwrap().is_good());
-
-        let detector = ListBasedDetector {
-            allow_list: Vec::new(),
-            deny_list: Vec::new(),
-            strategy: UnknownTokenStrategy::Deny,
-        };
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(!result.unwrap().is_good());
-    }
-
-    #[test]
-    fn not_in_list_forwards() {
-        let mut inner = MockBadTokenDetecting::new();
-        inner
-            .expect_detect()
-            .times(1)
-            .returning(|_| Ok(TokenQuality::Good));
-
-        let detector = ListBasedDetector {
-            allow_list: Vec::new(),
-            deny_list: Vec::new(),
-            strategy: UnknownTokenStrategy::Forward(Arc::new(inner)),
-        };
-
-        let result = detector
-            .detect(Address::with_last_byte(0))
-            .now_or_never()
-            .unwrap();
-        assert!(result.unwrap().is_good());
+impl DenyListedTokens {
+    pub fn contains(&self, token: &Address) -> bool {
+        self.0.deny_list.contains(token)
     }
 }
diff --git a/crates/shared/src/bad_token/mod.rs b/crates/shared/src/bad_token/mod.rs
index f4d146e74c..6fed7b5306 100644
--- a/crates/shared/src/bad_token/mod.rs
+++ b/crates/shared/src/bad_token/mod.rs
@@ -1,9 +1,6 @@
-pub mod instrumented;
 pub mod list_based;
 pub mod trace_call;
 
-use {alloy::primitives::Address, anyhow::Result};
-
 /// How well behaved a token is.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum TokenQuality {
@@ -22,10 +19,3 @@ impl TokenQuality {
         }
     }
 }
-
-/// Detect how well behaved a token is.
-#[cfg_attr(any(test, feature = "test-util"), mockall::automock)]
-#[async_trait::async_trait]
-pub trait BadTokenDetecting: Send + Sync {
-    async fn detect(&self, token: Address) -> Result<TokenQuality>;
-}
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index f7909ae54c..5839cfbec3 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -1,7 +1,7 @@
 use {
     crate::{
         account_balances::{self, BalanceFetching, TransferSimulationError},
-        bad_token::{BadTokenDetecting, TokenQuality},
+        bad_token::list_based::DenyListedTokens,
         code_fetching::CodeFetching,
         order_quoting::{
             CalculateQuoteError,
@@ -250,7 +250,7 @@ pub struct OrderValidator {
     banned_users: Arc<order_validation::banned::Users>,
     validity_configuration: OrderValidPeriodConfiguration,
     eip1271_skip_creation_validation: bool,
-    bad_token_detector: Arc<dyn BadTokenDetecting>,
+    deny_listed_tokens: DenyListedTokens,
     hooks: HooksTrampoline::Instance,
     /// For Full-Validation: performed time of order placement
     quoter: Arc<dyn OrderQuoting>,
@@ -321,7 +321,7 @@ impl OrderValidator {
         banned_users: Arc<order_validation::banned::Users>,
         validity_configuration: OrderValidPeriodConfiguration,
         eip1271_skip_creation_validation: bool,
-        bad_token_detector: Arc<dyn BadTokenDetecting>,
+        deny_listed_tokens: DenyListedTokens,
         hooks: HooksTrampoline::Instance,
         quoter: Arc<dyn OrderQuoting>,
         balance_fetcher: Arc<dyn BalanceFetching>,
@@ -338,7 +338,7 @@ impl OrderValidator {
             banned_users,
             validity_configuration,
             eip1271_skip_creation_validation,
-            bad_token_detector,
+            deny_listed_tokens,
             hooks,
             quoter,
             balance_fetcher,
@@ -524,14 +524,12 @@ impl OrderValidating for OrderValidator {
             return Err(PartialValidationError::InvalidNativeSellToken);
         }
 
-        for &token in &[order.sell_token, order.buy_token] {
-            if let TokenQuality::Bad { reason } = self
-                .bad_token_detector
-                .detect(token)
-                .await
-                .map_err(PartialValidationError::Other)?
-            {
-                return Err(PartialValidationError::UnsupportedToken { token, reason });
+        for token in &[order.sell_token, order.buy_token] {
+            if self.deny_listed_tokens.contains(token) {
+                return Err(PartialValidationError::UnsupportedToken {
+                    token: *token,
+                    reason: "token is deny listed".to_string(),
+                });
             }
         }
 
@@ -1037,7 +1035,6 @@ mod tests {
         super::*,
         crate::{
             account_balances::MockBalanceFetching,
-            bad_token::{MockBadTokenDetecting, TokenQuality},
             code_fetching::MockCodeFetching,
             order_quoting::{FindQuoteError, MockOrderQuoting},
             signature_validator::MockSignatureValidating,
@@ -1076,7 +1073,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::from_set(banned_users)),
             validity_configuration,
             false,
-            Arc::new(MockBadTokenDetecting::new()),
+            DenyListedTokens::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1214,16 +1211,6 @@ mod tests {
             max_limit: Duration::from_secs(200),
         };
 
-        let mut bad_token_detector = MockBadTokenDetecting::new();
-        bad_token_detector
-            .expect_detect()
-            .with(eq(Address::with_last_byte(1)))
-            .returning(|_| Ok(TokenQuality::Good));
-        bad_token_detector
-            .expect_detect()
-            .with(eq(Address::with_last_byte(2)))
-            .returning(|_| Ok(TokenQuality::Good));
-
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
         let validator = OrderValidator::new(
@@ -1231,7 +1218,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             validity_configuration,
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1305,16 +1292,6 @@ mod tests {
             max_limit: Duration::from_secs(200),
         };
 
-        let mut bad_token_detector = MockBadTokenDetecting::new();
-        bad_token_detector
-            .expect_detect()
-            .with(eq(Address::with_last_byte(1)))
-            .returning(|_| Ok(TokenQuality::Good));
-        bad_token_detector
-            .expect_detect()
-            .with(eq(Address::with_last_byte(2)))
-            .returning(|_| Ok(TokenQuality::Good));
-
         let mut limit_order_counter = MockLimitOrderCounting::new();
         limit_order_counter.expect_count().returning(|_| Ok(0u64));
         let validator = OrderValidator::new(
@@ -1322,7 +1299,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             validity_configuration,
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1377,14 +1354,10 @@ mod tests {
     #[tokio::test]
     async fn post_validate_ok() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -1416,7 +1389,7 @@ mod tests {
                 max_limit: Duration::from_secs(200),
             },
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             hooks.clone(),
             Arc::new(order_quoter),
             Arc::new(balance_fetcher),
@@ -1587,7 +1560,6 @@ mod tests {
     #[tokio::test]
     async fn post_validate_too_many_limit_orders() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter.expect_find_quote().returning(|_, _| {
             Ok(Quote {
@@ -1598,9 +1570,6 @@ mod tests {
                 fee_amount: Default::default(),
             })
         });
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -1628,7 +1597,7 @@ mod tests {
                 max_limit: Duration::from_secs(200),
             },
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1675,14 +1644,10 @@ mod tests {
     #[tokio::test]
     async fn post_limit_does_not_apply_to_in_market_orders() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -1705,7 +1670,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1751,14 +1716,10 @@ mod tests {
     #[tokio::test]
     async fn post_validate_err_zero_amount() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -1770,7 +1731,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1809,14 +1770,10 @@ mod tests {
     #[tokio::test]
     async fn post_validate_err_wrong_owner() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -1828,7 +1785,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1869,16 +1826,11 @@ mod tests {
     #[tokio::test]
     async fn post_validate_err_unsupported_token() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
+        let deny_listed_tokens = DenyListedTokens::new(vec![Address::with_last_byte(1)]);
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector.expect_detect().returning(|_| {
-            Ok(TokenQuality::Bad {
-                reason: Default::default(),
-            })
-        });
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -1891,7 +1843,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            deny_listed_tokens,
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1937,14 +1889,10 @@ mod tests {
     #[tokio::test]
     async fn post_validate_err_insufficient_balance() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Err(TransferSimulationError::InsufficientBalance));
@@ -1956,7 +1904,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -1997,15 +1945,11 @@ mod tests {
     #[tokio::test]
     async fn post_validate_err_invalid_eip1271_signature() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         let mut signature_validator = MockSignatureValidating::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -2020,7 +1964,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -2071,14 +2015,10 @@ mod tests {
             is_expected_error: impl Fn(ValidationError) -> bool,
         ) {
             let mut order_quoter = MockOrderQuoting::new();
-            let mut bad_token_detector = MockBadTokenDetecting::new();
             let mut balance_fetcher = MockBalanceFetching::new();
             order_quoter
                 .expect_find_quote()
                 .returning(|_, _| Ok(Default::default()));
-            bad_token_detector
-                .expect_detect()
-                .returning(|_| Ok(TokenQuality::Good));
             balance_fetcher
                 .expect_can_transfer()
                 .returning(move |_, _| Err(create_error()));
@@ -2091,7 +2031,7 @@ mod tests {
                 Arc::new(order_validation::banned::Users::none()),
                 OrderValidPeriodConfiguration::any(),
                 false,
-                Arc::new(bad_token_detector),
+                Default::default(),
                 HooksTrampoline::Instance::new(
                     Address::from([0xcf; 20]),
                     ProviderBuilder::new()
@@ -2167,14 +2107,10 @@ mod tests {
     #[test]
     fn allows_insufficient_balance_for_orders_with_sufficient_flashloan_hint() {
         let mut order_quoter = MockOrderQuoting::new();
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
         order_quoter
             .expect_find_quote()
             .returning(|_, _| Ok(Default::default()));
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Err(TransferSimulationError::InsufficientBalance));
@@ -2186,7 +2122,7 @@ mod tests {
             Arc::new(order_validation::banned::Users::none()),
             OrderValidPeriodConfiguration::any(),
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
@@ -2577,11 +2513,7 @@ mod tests {
             .with(eq(quote_id), eq(quote_search_parameters.clone()))
             .returning(move |_, _| Ok(quote_data.clone()));
 
-        let mut bad_token_detector = MockBadTokenDetecting::new();
         let mut balance_fetcher = MockBalanceFetching::new();
-        bad_token_detector
-            .expect_detect()
-            .returning(|_| Ok(TokenQuality::Good));
         balance_fetcher
             .expect_can_transfer()
             .returning(|_, _| Ok(()));
@@ -2602,7 +2534,7 @@ mod tests {
                 max_limit: Duration::from_secs(200),
             },
             false,
-            Arc::new(bad_token_detector),
+            Default::default(),
             HooksTrampoline::Instance::new(
                 Address::from([0xcf; 20]),
                 ProviderBuilder::new()
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index 74ac93f0f1..43fe6e1e01 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -13,8 +13,7 @@ use {
     },
     crate::{
         arguments,
-        bad_token::BadTokenDetecting,
-        baseline_solver::BaseTokens,
+        bad_token::list_based::DenyListedTokens,
         code_fetching::CachedCodeFetcher,
         ethrpc::Web3,
         gas_price_estimation::GasPriceEstimating,
@@ -61,14 +60,13 @@ pub struct Network {
     pub native_token: Address,
     pub settlement: Address,
     pub authenticator: Address,
-    pub base_tokens: Arc<BaseTokens>,
     pub block_stream: CurrentBlockWatcher,
 }
 
 /// The shared components needed for creating price estimators.
 pub struct Components {
     pub http_factory: HttpClientFactory,
-    pub bad_token_detector: Arc<dyn BadTokenDetecting>,
+    pub deny_listed_tokens: DenyListedTokens,
     pub tokens: Arc<dyn TokenInfoFetching>,
     pub code_fetcher: Arc<CachedCodeFetcher>,
 }
@@ -306,7 +304,7 @@ impl<'a> PriceEstimatorFactory<'a> {
         SanitizedPriceEstimator::new(
             estimator,
             self.network.native_token,
-            self.components.bad_token_detector.clone(),
+            self.components.deny_listed_tokens.clone(),
             false, // not estimating native price
         )
     }
@@ -320,7 +318,7 @@ impl<'a> PriceEstimatorFactory<'a> {
         SanitizedPriceEstimator::new(
             estimator,
             self.network.native_token,
-            self.components.bad_token_detector.clone(),
+            self.components.deny_listed_tokens.clone(),
             true, // estimating native price
         )
     }
diff --git a/crates/shared/src/price_estimation/sanitized.rs b/crates/shared/src/price_estimation/sanitized.rs
index 96b036cf30..48ecfd70aa 100644
--- a/crates/shared/src/price_estimation/sanitized.rs
+++ b/crates/shared/src/price_estimation/sanitized.rs
@@ -1,6 +1,6 @@
 use {
     crate::{
-        bad_token::{BadTokenDetecting, TokenQuality},
+        bad_token::list_based::DenyListedTokens,
         price_estimation::{
             Estimate,
             PriceEstimating,
@@ -21,7 +21,7 @@ use {
 /// ETH as buy token appropriately.
 pub struct SanitizedPriceEstimator {
     inner: Arc<dyn PriceEstimating>,
-    bad_token_detector: Arc<dyn BadTokenDetecting>,
+    deny_listed_tokens: DenyListedTokens,
     native_token: Address,
     /// Enables the short-circuiting logic in case the sell and buy tokens are
     /// the same
@@ -32,26 +32,25 @@ impl SanitizedPriceEstimator {
     pub fn new(
         inner: Arc<dyn PriceEstimating>,
         native_token: Address,
-        bad_token_detector: Arc<dyn BadTokenDetecting>,
+        deny_listed_tokens: DenyListedTokens,
         is_estimating_native_price: bool,
     ) -> Self {
         Self {
             inner,
             native_token,
-            bad_token_detector,
+            deny_listed_tokens,
             is_estimating_native_price,
         }
     }
 
     /// Checks if the traded tokens are supported by the protocol.
-    async fn handle_bad_tokens(&self, query: &Query) -> Result<(), PriceEstimationError> {
+    fn handle_deny_listed_tokens(&self, query: &Query) -> Result<(), PriceEstimationError> {
         for token in [query.sell_token, query.buy_token] {
-            match self.bad_token_detector.detect(token).await {
-                Err(err) => return Err(PriceEstimationError::ProtocolInternal(err)),
-                Ok(TokenQuality::Bad { reason }) => {
-                    return Err(PriceEstimationError::UnsupportedToken { token, reason });
-                }
-                _ => (),
+            if self.deny_listed_tokens.contains(&token) {
+                return Err(PriceEstimationError::UnsupportedToken {
+                    token,
+                    reason: "token is deny listed".to_string(),
+                });
             }
         }
         Ok(())
@@ -65,7 +64,7 @@ impl PriceEstimating for SanitizedPriceEstimator {
         query: Arc<Query>,
     ) -> futures::future::BoxFuture<'_, super::PriceEstimateResult> {
         async move {
-            self.handle_bad_tokens(&query).await?;
+            self.handle_deny_listed_tokens(&query)?;
             // When estimating native price the sell token is substituted by
             // native one. In that case, the output amount of the price
             // estimation can be trivially computed as the same amount as input
@@ -153,10 +152,7 @@ impl PriceEstimating for SanitizedPriceEstimator {
 mod tests {
     use {
         super::*,
-        crate::{
-            bad_token::{MockBadTokenDetecting, TokenQuality},
-            price_estimation::{HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
-        },
+        crate::price_estimation::{HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
         alloy::primitives::{Address, U256 as AlloyU256},
         model::order::OrderKind,
         number::nonzero::NonZeroU256,
@@ -166,16 +162,7 @@ mod tests {
 
     #[tokio::test]
     async fn handles_trivial_estimates_on_its_own() {
-        let mut bad_token_detector = MockBadTokenDetecting::new();
-        bad_token_detector.expect_detect().returning(|token| {
-            if token == BAD_TOKEN {
-                Ok(TokenQuality::Bad {
-                    reason: "Token not supported".into(),
-                })
-            } else {
-                Ok(TokenQuality::Good)
-            }
-        });
+        let deny_listed_tokens = DenyListedTokens::new(vec![BAD_TOKEN]);
 
         let native_token = Address::with_last_byte(42);
 
@@ -457,10 +444,9 @@ mod tests {
                 }
                 .boxed()
             });
-        let bad_token_detector = Arc::new(bad_token_detector);
         let sanitized_estimator = SanitizedPriceEstimator {
             inner: Arc::new(wrapped_estimator),
-            bad_token_detector: bad_token_detector.clone(),
+            deny_listed_tokens: deny_listed_tokens.clone(),
             native_token,
             is_estimating_native_price: true,
         };
@@ -563,7 +549,7 @@ mod tests {
 
         let sanitized_estimator_non_native = SanitizedPriceEstimator {
             inner: Arc::new(wrapped_estimator),
-            bad_token_detector,
+            deny_listed_tokens,
             native_token,
             is_estimating_native_price: false,
         };

From 8e7c79ff8290cca4f8620816bd720627eefd8a6b Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Mon, 16 Feb 2026 17:24:22 +0100
Subject: [PATCH 066/219] Extract common utils, serialization to shared and
 serde-ext (#4142)

# Description
The simulation refactoring PR (#4140) is large due to some common types
being moved out to `shared`. This PR covers these aspects and moves
common `driver` utilities to `shared`. Alongside these common
(de)serialization logic is moved to new crate `serde-ext`

# Changes
- [x] Move driver::util::bytes to `shared`
- [x] Remove util::Bytes from `autopilot`
- [x] Rename shared::ethrpc to web3 for a better name and to avoid
naming conflicts with the `ethrpc` crate
- [x] Move common (de)serialization logic to new `serde-ext` and use it
throughout `driver` and `solvers-dto`

## How to test
- E2E tests
- [ ] Staging deployment works
---
 Cargo.lock                                    |  12 ++
 Cargo.toml                                    |   1 +
 crates/autopilot/src/boundary/mod.rs          |   4 +-
 .../ethflow_events/event_retriever.rs         |   2 +-
 .../onchain_order_events/event_retriever.rs   |   2 +-
 crates/autopilot/src/infra/blockchain/mod.rs  |   5 +-
 crates/autopilot/src/run.rs                   |  10 +-
 crates/autopilot/src/util/bytes.rs            |  18 ---
 crates/autopilot/src/util/mod.rs              |   4 -
 crates/driver/Cargo.toml                      |   1 +
 .../src/boundary/liquidity/uniswap/v3.rs      |   2 +-
 crates/driver/src/boundary/mod.rs             |  33 ++----
 crates/driver/src/domain/competition/mod.rs   |  11 +-
 .../src/domain/competition/order/app_data.rs  |   4 +-
 .../src/domain/competition/order/mod.rs       |   7 +-
 .../src/domain/competition/order/signature.rs |  18 +--
 .../src/domain/competition/pre_processing.rs  |   9 +-
 .../risk_detector/bad_tokens/simulation.rs    |   2 +-
 .../domain/competition/solution/encoding.rs   |  21 ++--
 .../competition/solution/interaction.rs       |   8 +-
 crates/driver/src/domain/eth/mod.rs           |  11 +-
 .../src/infra/api/routes/quote/dto/order.rs   |   7 +-
 .../src/infra/api/routes/quote/dto/quote.rs   |  21 ++--
 .../api/routes/reveal/dto/reveal_response.rs  |  10 +-
 .../api/routes/solve/dto/solve_request.rs     |  25 ++---
 .../api/routes/solve/dto/solve_response.rs    |  15 ++-
 crates/driver/src/infra/blockchain/mod.rs     |  13 ++-
 crates/driver/src/infra/config/file/mod.rs    |  12 +-
 crates/driver/src/infra/mempool/mod.rs        |   7 +-
 .../liquidity_sources/liquorice/notifier.rs   |   9 +-
 crates/driver/src/infra/simulator/enso/dto.rs |   6 +-
 .../src/infra/simulator/tenderly/dto.rs       |   4 +-
 crates/driver/src/infra/solver/dto/auction.rs |   2 +-
 .../driver/src/infra/solver/dto/solution.rs   |   8 +-
 crates/driver/src/util/mod.rs                 |   4 +-
 crates/e2e/src/setup/deploy.rs                |   2 +-
 .../e2e/src/setup/onchain_components/mod.rs   |   2 +-
 crates/e2e/src/setup/services.rs              |   2 +-
 crates/e2e/tests/e2e/api_version.rs           |   2 +-
 crates/e2e/tests/e2e/app_data.rs              |   2 +-
 crates/e2e/tests/e2e/app_data_signer.rs       |   2 +-
 crates/e2e/tests/e2e/buffers.rs               |   2 +-
 crates/e2e/tests/e2e/cors.rs                  |   2 +-
 crates/e2e/tests/e2e/cow_amm.rs               |   2 +-
 crates/e2e/tests/e2e/deprecated_endpoints.rs  |   2 +-
 crates/e2e/tests/e2e/eth_integration.rs       |   2 +-
 crates/e2e/tests/e2e/eth_safe.rs              |   2 +-
 crates/e2e/tests/e2e/hooks.rs                 |   2 +-
 crates/e2e/tests/e2e/jit_orders.rs            |   2 +-
 crates/e2e/tests/e2e/limit_orders.rs          |   2 +-
 crates/e2e/tests/e2e/malformed_requests.rs    |   2 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |   2 +-
 crates/e2e/tests/e2e/partial_fill.rs          |   2 +-
 .../tests/e2e/partially_fillable_balance.rs   |   2 +-
 .../e2e/tests/e2e/partially_fillable_pool.rs  |   2 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |   2 +-
 crates/e2e/tests/e2e/protocol_fee.rs          |   2 +-
 crates/e2e/tests/e2e/quoting.rs               |   2 +-
 crates/e2e/tests/e2e/replace_order.rs         |   2 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |   2 +-
 crates/e2e/tests/e2e/solver_competition.rs    |   2 +-
 crates/e2e/tests/e2e/submission.rs            |   2 +-
 crates/e2e/tests/e2e/token_metadata.rs        |   2 +-
 .../tests/e2e/tracking_insufficient_funds.rs  |   2 +-
 crates/e2e/tests/e2e/trades_v2.rs             |   2 +-
 crates/e2e/tests/e2e/uncovered_order.rs       |   2 +-
 crates/e2e/tests/e2e/univ2.rs                 |   2 +-
 crates/e2e/tests/e2e/user_surplus.rs          |   2 +-
 crates/e2e/tests/e2e/vault_balances.rs        |   2 +-
 crates/e2e/tests/e2e/wrapper.rs               |   2 +-
 crates/orderbook/src/run.rs                   |   4 +-
 crates/refunder/src/arguments.rs              |   4 +-
 crates/refunder/src/lib.rs                    |   2 +-
 crates/refunder/src/submitter.rs              |   2 +-
 crates/serde-ext/Cargo.toml                   |  12 ++
 .../util/serialize => serde-ext/src}/hex.rs   |   0
 .../serialize/mod.rs => serde-ext/src/lib.rs} |   0
 .../util/serialize => serde-ext/src}/u256.rs  |  14 +--
 crates/shared/src/arguments.rs                |   2 +-
 crates/shared/src/bad_token/trace_call.rs     |   2 +-
 .../{driver/src/util => shared/src}/bytes.rs  |   0
 crates/shared/src/code_fetching.rs            |   2 +-
 crates/shared/src/gas_price_estimation/mod.rs |   2 +-
 crates/shared/src/lib.rs                      |   2 +-
 crates/shared/src/price_estimation/factory.rs |   2 +-
 .../sources/balancer_v2/pool_fetching/mod.rs  |   2 +-
 crates/shared/src/sources/swapr.rs            |   2 +-
 crates/shared/src/sources/uniswap_v2/mod.rs   |   2 +-
 .../src/sources/uniswap_v2/pool_fetching.rs   |   2 +-
 crates/shared/src/trace_many.rs               |   2 +-
 crates/shared/src/{ethrpc.rs => web3.rs}      |   0
 crates/solver/src/liquidity/balancer_v2.rs    |   2 +-
 crates/solver/src/liquidity/uniswap_v2.rs     |   2 +-
 crates/solver/src/liquidity/uniswap_v3.rs     |   2 +-
 crates/solver/src/liquidity/zeroex.rs         |   2 +-
 crates/solvers-dto/Cargo.toml                 |   1 +
 crates/solvers-dto/src/auction.rs             |   5 +-
 crates/solvers-dto/src/lib.rs                 | 106 ------------------
 crates/solvers-dto/src/notification.rs        |   3 +-
 crates/solvers-dto/src/solution.rs            |  15 ++-
 100 files changed, 230 insertions(+), 366 deletions(-)
 delete mode 100644 crates/autopilot/src/util/bytes.rs
 create mode 100644 crates/serde-ext/Cargo.toml
 rename crates/{driver/src/util/serialize => serde-ext/src}/hex.rs (100%)
 rename crates/{driver/src/util/serialize/mod.rs => serde-ext/src/lib.rs} (100%)
 rename crates/{driver/src/util/serialize => serde-ext/src}/u256.rs (72%)
 rename crates/{driver/src/util => shared/src}/bytes.rs (100%)
 rename crates/shared/src/{ethrpc.rs => web3.rs} (100%)

diff --git a/Cargo.lock b/Cargo.lock
index c40ca9c023..f2f53f5498 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2720,6 +2720,7 @@ dependencies = [
  "reqwest 0.11.27",
  "s3",
  "serde",
+ "serde-ext",
  "serde_json",
  "serde_with",
  "shared",
@@ -5966,6 +5967,16 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-ext"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "const-hex",
+ "serde",
+ "serde_with",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.228"
@@ -6331,6 +6342,7 @@ dependencies = [
  "const-hex",
  "number",
  "serde",
+ "serde-ext",
  "serde_with",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 57ed351635..61baa62db7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -105,6 +105,7 @@ proc-macro2 = "1.0.103"
 alloy-sol-macro-input = "1.4.1"
 alloy-sol-macro-expander = "1.4.1"
 jsonrpc-core = "18.0.0"
+serde-ext = { path = "crates/serde-ext" }
 
 [workspace.lints]
 clippy.cast_possible_wrap = "deny"
diff --git a/crates/autopilot/src/boundary/mod.rs b/crates/autopilot/src/boundary/mod.rs
index ab71671bfa..42d3439d85 100644
--- a/crates/autopilot/src/boundary/mod.rs
+++ b/crates/autopilot/src/boundary/mod.rs
@@ -33,8 +33,8 @@ pub mod events;
 pub mod order;
 
 /// Builds a web3 client based on the ethrpc args config.
-pub fn web3_client(ethrpc: &Url, ethrpc_args: &shared::ethrpc::Arguments) -> Web3 {
-    shared::ethrpc::web3(ethrpc_args, ethrpc, "base")
+pub fn web3_client(ethrpc: &Url, ethrpc_args: &shared::web3::Arguments) -> Web3 {
+    shared::web3::web3(ethrpc_args, ethrpc, "base")
 }
 
 pub struct SolvableOrders {
diff --git a/crates/autopilot/src/database/ethflow_events/event_retriever.rs b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
index b1ed267ad2..dfc159471a 100644
--- a/crates/autopilot/src/database/ethflow_events/event_retriever.rs
+++ b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
@@ -8,7 +8,7 @@ use {
         sol_types::SolEvent,
     },
     contracts::alloy::CoWSwapEthFlow::CoWSwapEthFlow,
-    shared::{ethrpc::Web3, event_handling::AlloyEventRetrieving},
+    shared::{event_handling::AlloyEventRetrieving, web3::Web3},
 };
 
 pub struct EthFlowRefundRetriever {
diff --git a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
index a56e10fe68..d321885e4a 100644
--- a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
+++ b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
@@ -5,7 +5,7 @@ use {
         sol_types::SolEvent,
     },
     contracts::alloy::CoWSwapOnchainOrders,
-    shared::{ethrpc::Web3, event_handling::AlloyEventRetrieving},
+    shared::{event_handling::AlloyEventRetrieving, web3::Web3},
 };
 
 // Note: we use a custom implementation of `EventRetrieving` rather than using
diff --git a/crates/autopilot/src/infra/blockchain/mod.rs b/crates/autopilot/src/infra/blockchain/mod.rs
index 90248b9ac9..f5a0f5df08 100644
--- a/crates/autopilot/src/infra/blockchain/mod.rs
+++ b/crates/autopilot/src/infra/blockchain/mod.rs
@@ -27,10 +27,7 @@ pub struct Rpc {
 impl Rpc {
     /// Instantiate an RPC client to an Ethereum (or Ethereum-compatible) node
     /// at the specifed URL.
-    pub async fn new(
-        url: &url::Url,
-        ethrpc_args: &shared::ethrpc::Arguments,
-    ) -> Result<Self, Error> {
+    pub async fn new(url: &url::Url, ethrpc_args: &shared::web3::Arguments) -> Result<Self, Error> {
         let web3 = boundary::web3_client(url, ethrpc_args);
         let chain = Chain::try_from(web3.provider.get_chain_id().await?)
             .map_err(|_| Error::UnsupportedChain)?;
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 9c973aab7d..39b4224be5 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -83,7 +83,7 @@ impl Liveness {
 
 /// Creates Web3 transport based on the given config.
 #[instrument(skip_all)]
-async fn ethrpc(url: &Url, ethrpc_args: &shared::ethrpc::Arguments) -> infra::blockchain::Rpc {
+async fn ethrpc(url: &Url, ethrpc_args: &shared::web3::Arguments) -> infra::blockchain::Rpc {
     infra::blockchain::Rpc::new(url, ethrpc_args)
         .await
         .expect("connect ethereum RPC")
@@ -93,7 +93,7 @@ async fn ethrpc(url: &Url, ethrpc_args: &shared::ethrpc::Arguments) -> infra::bl
 async fn unbuffered_ethrpc(url: &Url) -> infra::blockchain::Rpc {
     ethrpc(
         url,
-        &shared::ethrpc::Arguments {
+        &shared::web3::Arguments {
             ethrpc_max_batch_size: 0,
             ethrpc_max_concurrent_requests: 0,
             ethrpc_batch_delay: Default::default(),
@@ -170,12 +170,12 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     crate::database::run_database_metrics_work(db_write.clone());
 
     let http_factory = HttpClientFactory::new(&args.http_client);
-    let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
+    let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
     let simulation_web3 = args
         .shared
         .simulation_node_url
         .as_ref()
-        .map(|node_url| shared::ethrpc::web3(&args.shared.ethrpc, node_url, "simulation"));
+        .map(|node_url| shared::web3::web3(&args.shared.ethrpc, node_url, "simulation"));
 
     let chain_id = web3
         .provider
@@ -653,7 +653,7 @@ async fn shadow_mode(args: Arguments) -> ! {
         .into_iter()
         .collect();
 
-    let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
+    let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
     let weth = WETH9::Instance::deployed(&web3.provider)
         .await
         .expect("couldn't find deployed WETH contract");
diff --git a/crates/autopilot/src/util/bytes.rs b/crates/autopilot/src/util/bytes.rs
deleted file mode 100644
index c8b2d0992a..0000000000
--- a/crates/autopilot/src/util/bytes.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-/// A thin wrapper around a collection of bytes. Provides hex debug formatting.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
-pub struct Bytes<T>(pub T);
-
-impl<T> std::fmt::Debug for Bytes<T>
-where
-    T: AsRef<[u8]>,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", const_hex::encode_prefixed(&self.0))
-    }
-}
-
-impl<T> From<T> for Bytes<T> {
-    fn from(value: T) -> Self {
-        Self(value)
-    }
-}
diff --git a/crates/autopilot/src/util/mod.rs b/crates/autopilot/src/util/mod.rs
index 277ec7be2f..bb1babe21b 100644
--- a/crates/autopilot/src/util/mod.rs
+++ b/crates/autopilot/src/util/mod.rs
@@ -1,9 +1,5 @@
 use url::Url;
 
-mod bytes;
-
-pub use self::bytes::Bytes;
-
 /// Joins a path with a URL, ensuring that there is only one slash between them.
 /// It doesn't matter if the URL ends with a slash or the path starts with one.
 pub fn join(url: &Url, mut path: &str) -> Url {
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index d93e4f4631..f5a725802d 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -46,6 +46,7 @@ rand = { workspace = true }
 reqwest = { workspace = true }
 s3 = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+serde-ext = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 solvers-dto = { path = "../solvers-dto" }
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v3.rs b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
index f6d41df6b8..f717c852ef 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v3.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
@@ -93,7 +93,7 @@ pub fn to_interaction(
     eth::Interaction {
         target: encoded.0,
         value: encoded.1.into(),
-        call_data: crate::util::Bytes(encoded.2.0.to_vec()),
+        call_data: encoded.2,
     }
 }
 
diff --git a/crates/driver/src/boundary/mod.rs b/crates/driver/src/boundary/mod.rs
index 630616a9f3..8ab03cafe3 100644
--- a/crates/driver/src/boundary/mod.rs
+++ b/crates/driver/src/boundary/mod.rs
@@ -32,29 +32,18 @@ pub use {
     anyhow::{Error, Result},
     contracts,
     model::order::OrderData,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
-/// Builds a web3 client that buffers requests and sends them in a
-/// batch call.
-pub fn buffered_web3_client(
-    ethrpc: &Url,
-    max_batch_size: usize,
-    max_concurrent_requests: usize,
-) -> Web3 {
-    web3_client(ethrpc, max_batch_size, max_concurrent_requests)
-}
-
 /// Builds a web3 client that sends requests one by one.
-pub fn unbuffered_web3_client(ethrpc: &Url) -> Web3 {
-    web3_client(ethrpc, 0, 0)
-}
-
-fn web3_client(ethrpc: &Url, max_batch_size: usize, max_concurrent_requests: usize) -> Web3 {
-    let ethrpc_args = shared::ethrpc::Arguments {
-        ethrpc_max_batch_size: max_batch_size,
-        ethrpc_max_concurrent_requests: max_concurrent_requests,
-        ethrpc_batch_delay: Default::default(),
-    };
-    shared::ethrpc::web3(&ethrpc_args, ethrpc, "base")
+pub fn unbuffered_web3(ethrpc: &Url) -> Web3 {
+    shared::web3::web3(
+        &shared::web3::Arguments {
+            ethrpc_max_batch_size: 0,
+            ethrpc_max_concurrent_requests: 0,
+            ethrpc_batch_delay: Default::default(),
+        },
+        ethrpc,
+        "base",
+    )
 }
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 5c51e38bb1..afe65a25d3 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -19,8 +19,9 @@ use {
             simulator::{RevertError, SimulatorError},
             solver::{self, SolutionMerging, Solver},
         },
-        util::{Bytes, math},
+        util::math,
     },
+    alloy::primitives::Bytes,
     futures::{StreamExt, future::Either, stream::FuturesUnordered},
     hyper::body::Bytes as RequestBytes,
     itertools::Itertools,
@@ -851,22 +852,22 @@ pub struct PriceLimits {
 #[derive(Debug)]
 pub struct Revealed {
     /// The internalized calldata is the final calldata that appears onchain.
-    pub internalized_calldata: Bytes<Vec<u8>>,
+    pub internalized_calldata: Bytes,
     /// The uninternalized calldata must be known so that the CoW solver team
     /// can manually enforce certain rules which can not be enforced
     /// automatically.
-    pub uninternalized_calldata: Bytes<Vec<u8>>,
+    pub uninternalized_calldata: Bytes,
 }
 
 #[derive(Debug)]
 pub struct Settled {
     /// The transaction hash in which the solution was submitted.
     pub tx_hash: eth::TxId,
-    pub internalized_calldata: Bytes<Vec<u8>>,
+    pub internalized_calldata: Bytes,
     /// The uninternalized calldata must be known so that the CoW solver team
     /// can manually enforce certain rules which can not be enforced
     /// automatically.
-    pub uninternalized_calldata: Bytes<Vec<u8>>,
+    pub uninternalized_calldata: Bytes,
 }
 
 #[derive(Debug, thiserror::Error)]
diff --git a/crates/driver/src/domain/competition/order/app_data.rs b/crates/driver/src/domain/competition/order/app_data.rs
index 0134f331dc..d9c927457c 100644
--- a/crates/driver/src/domain/competition/order/app_data.rs
+++ b/crates/driver/src/domain/competition/order/app_data.rs
@@ -1,5 +1,5 @@
 use {
-    crate::util::Bytes,
+    alloy::primitives::FixedBytes,
     anyhow::Context,
     app_data::AppDataDocument,
     derive_more::From,
@@ -157,7 +157,7 @@ pub const APP_DATA_LEN: usize = 32;
 /// While this type holds the hash, the data itself is uploaded to IPFS. This
 /// hash is signed along with the order.
 #[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq)]
-pub struct AppDataHash(pub Bytes<[u8; APP_DATA_LEN]>);
+pub struct AppDataHash(pub FixedBytes<APP_DATA_LEN>);
 
 impl From<[u8; APP_DATA_LEN]> for AppDataHash {
     fn from(inner: [u8; APP_DATA_LEN]) -> Self {
diff --git a/crates/driver/src/domain/competition/order/mod.rs b/crates/driver/src/domain/competition/order/mod.rs
index e0935a96eb..3a7c6e1b59 100644
--- a/crates/driver/src/domain/competition/order/mod.rs
+++ b/crates/driver/src/domain/competition/order/mod.rs
@@ -2,8 +2,9 @@ use {
     crate::{
         domain::eth,
         infra::{Ethereum, blockchain},
-        util::{self, Bytes},
+        util,
     },
+    alloy::primitives::FixedBytes,
     derive_more::{From, Into},
     model::order::{BuyTokenDestination, SellTokenSource},
 };
@@ -199,7 +200,7 @@ pub const UID_LEN: usize = 56;
 
 /// UID of an order.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct Uid(pub Bytes<[u8; UID_LEN]>);
+pub struct Uid(pub FixedBytes<UID_LEN>);
 
 impl From<&solvers_dto::solution::OrderUid> for Uid {
     fn from(value: &solvers_dto::solution::OrderUid) -> Self {
@@ -213,7 +214,7 @@ impl Uid {
         bytes[0..32].copy_from_slice(order_hash.as_slice());
         bytes[32..52].copy_from_slice(owner.as_slice());
         bytes[52..56].copy_from_slice(&valid_to.to_be_bytes());
-        Self(Bytes(bytes))
+        Self(FixedBytes(bytes))
     }
 
     /// Address that authorized the order. Sell tokens will be taken
diff --git a/crates/driver/src/domain/competition/order/signature.rs b/crates/driver/src/domain/competition/order/signature.rs
index 852f8b3606..acddc8a30e 100644
--- a/crates/driver/src/domain/competition/order/signature.rs
+++ b/crates/driver/src/domain/competition/order/signature.rs
@@ -1,13 +1,10 @@
-use {
-    crate::{domain::eth, util::Bytes},
-    model::signature::EcdsaSignature,
-};
+use {crate::domain::eth, alloy::primitives::Bytes, model::signature::EcdsaSignature};
 
 /// Signature over the order data.
 #[derive(Debug, Clone)]
 pub struct Signature {
     pub scheme: Scheme,
-    pub data: Bytes<Vec<u8>>,
+    pub data: Bytes,
     /// The address used to sign and place this order.
     pub signer: eth::Address,
 }
@@ -21,17 +18,14 @@ impl Signature {
         Ok(match self.scheme {
             Scheme::Eip712 => model::signature::Signature::Eip712(EcdsaSignature::from_bytes(
                 self.data
-                    .0
-                    .as_slice()
-                    .try_into()
-                    .map_err(|_| anyhow::anyhow!("ECDSA signature must be 65 bytes"))?,
+                    .as_array()
+                    .ok_or_else(|| anyhow::anyhow!("ECDSA signature must be 65 bytes"))?,
             )?),
             Scheme::EthSign => model::signature::Signature::EthSign(EcdsaSignature::from_bytes(
                 self.data
                     .0
-                    .as_slice()
-                    .try_into()
-                    .map_err(|_| anyhow::anyhow!("ECDSA signature must be 65 bytes"))?,
+                    .as_array()
+                    .ok_or_else(|| anyhow::anyhow!("ECDSA signature must be 65 bytes"))?,
             )?),
             Scheme::Eip1271 => model::signature::Signature::Eip1271(self.data.clone().into()),
             Scheme::PreSign => model::signature::Signature::PreSign,
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index bc67effeb0..ce18e013ee 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -8,8 +8,8 @@ use {
             liquidity,
         },
         infra::{self, api::routes::solve::dto::SolveRequest, observe::metrics, tokens},
-        util::Bytes,
     },
+    alloy::primitives::{Bytes, FixedBytes},
     anyhow::{Context, Result},
     chrono::Utc,
     futures::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered},
@@ -287,7 +287,7 @@ impl Utilities {
                             .map(|i| InteractionData {
                                 target: i.target,
                                 value: i.value.0,
-                                call_data: i.call_data.0.clone(),
+                                call_data: i.call_data.0.to_vec(),
                             })
                             .collect()
                     } else {
@@ -460,7 +460,8 @@ impl Utilities {
                     },
                     kind: order::Kind::Limit,
                     side: template.order.kind.into(),
-                    app_data: order::app_data::AppDataHash(Bytes(template.order.app_data.0)).into(),
+                    app_data: order::app_data::AppDataHash(FixedBytes(template.order.app_data.0))
+                        .into(),
                     buy_token_balance: template.order.buy_token_balance.into(),
                     sell_token_balance: template.order.sell_token_balance.into(),
                     partial: match template.order.partially_fillable {
@@ -485,7 +486,7 @@ impl Utilities {
                     signature: match template.signature {
                         Signature::Eip1271(bytes) => order::Signature {
                             scheme: order::signature::Scheme::Eip1271,
-                            data: Bytes(bytes),
+                            data: Bytes::from(bytes),
                             signer: amm,
                         },
                         _ => {
diff --git a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
index 9392ce806e..f041b7c417 100644
--- a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
+++ b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
@@ -67,7 +67,7 @@ impl Detector {
                     .map(|i| InteractionData {
                         target: i.target,
                         value: i.value.0,
-                        call_data: i.call_data.0.clone(),
+                        call_data: i.call_data.to_vec(),
                     })
                     .collect();
                 let trader = order.trader().0;
diff --git a/crates/driver/src/domain/competition/solution/encoding.rs b/crates/driver/src/domain/competition/solution/encoding.rs
index 5ac39b6037..55e1128940 100644
--- a/crates/driver/src/domain/competition/solution/encoding.rs
+++ b/crates/driver/src/domain/competition/solution/encoding.rs
@@ -10,11 +10,10 @@ use {
             liquidity,
         },
         infra::{self, solver::ManageNativeToken},
-        util::Bytes,
     },
     allowance::Allowance,
     alloy::{
-        primitives::{Address, U256},
+        primitives::{Address, Bytes, FixedBytes, U256},
         sol_types::SolCall,
     },
     contracts::alloy::{FlashLoanRouter::LoanRequest, WETH9},
@@ -399,11 +398,11 @@ struct Trade {
     sell_amount: eth::U256,
     buy_amount: eth::U256,
     valid_to: u32,
-    app_data: Bytes<[u8; 32]>,
+    app_data: FixedBytes<32>,
     fee_amount: eth::U256,
     flags: Flags,
     executed_amount: eth::U256,
-    signature: Bytes<Vec<u8>>,
+    signature: Bytes,
 }
 
 struct Price {
@@ -424,7 +423,7 @@ struct Flags {
 pub mod codec {
     use {
         crate::domain::{competition::order, eth},
-        alloy::primitives::U256,
+        alloy::primitives::{Bytes, U256},
         contracts::alloy::GPv2Settlement,
     };
 
@@ -485,16 +484,14 @@ pub mod codec {
         }
     }
 
-    pub fn signature(signature: &order::Signature) -> super::Bytes<Vec<u8>> {
+    pub fn signature(signature: &order::Signature) -> Bytes {
         match signature.scheme {
             order::signature::Scheme::Eip712 | order::signature::Scheme::EthSign => {
                 signature.data.clone()
             }
-            order::signature::Scheme::Eip1271 => {
-                [signature.signer.as_slice(), signature.data.0.as_slice()]
-                    .concat()
-                    .into()
-            }
+            order::signature::Scheme::Eip1271 => [signature.signer.as_slice(), &signature.data]
+                .concat()
+                .into(),
             order::signature::Scheme::PreSign => signature.signer.to_vec().into(),
         }
     }
@@ -517,7 +514,7 @@ mod test {
             address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
         );
         assert_eq!(
-            interaction.call_data.0.as_slice(),
+            interaction.call_data.as_ref(),
             hex!(
                 "095ea7b3000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
             )
diff --git a/crates/driver/src/domain/competition/solution/interaction.rs b/crates/driver/src/domain/competition/solution/interaction.rs
index b7fc594c78..25468f39b0 100644
--- a/crates/driver/src/domain/competition/solution/interaction.rs
+++ b/crates/driver/src/domain/competition/solution/interaction.rs
@@ -1,6 +1,6 @@
-use crate::{
-    domain::{self, eth, liquidity},
-    util::Bytes,
+use {
+    crate::domain::{self, eth, liquidity},
+    alloy::primitives::Bytes,
 };
 
 /// Interaction with a smart contract which is needed to execute this solution
@@ -67,7 +67,7 @@ impl Interaction {
 pub struct Custom {
     pub target: eth::ContractAddress,
     pub value: eth::Ether,
-    pub call_data: Bytes<Vec<u8>>,
+    pub call_data: Bytes,
     pub allowances: Vec<eth::allowance::Required>,
     /// See the [`Interaction::inputs`] method.
     pub inputs: Vec<eth::Asset>,
diff --git a/crates/driver/src/domain/eth/mod.rs b/crates/driver/src/domain/eth/mod.rs
index 53a72b84c4..c2f4f85756 100644
--- a/crates/driver/src/domain/eth/mod.rs
+++ b/crates/driver/src/domain/eth/mod.rs
@@ -1,6 +1,5 @@
 use {
-    crate::util::Bytes,
-    alloy::rpc::types::TransactionRequest,
+    alloy::{primitives::Bytes, rpc::types::TransactionRequest},
     derive_more::{From, Into},
     number::u256_ext::U256Ext,
     solvers_dto::auction::FlashloanHint,
@@ -327,7 +326,7 @@ pub struct BlockNo(pub u64);
 pub struct Interaction {
     pub target: Address,
     pub value: Ether,
-    pub call_data: Bytes<Vec<u8>>,
+    pub call_data: Bytes,
 }
 
 impl From<Interaction> for model::interaction::InteractionData {
@@ -335,7 +334,7 @@ impl From<Interaction> for model::interaction::InteractionData {
         Self {
             target: interaction.target,
             value: interaction.value.0,
-            call_data: interaction.call_data.0,
+            call_data: interaction.call_data.to_vec(),
         }
     }
 }
@@ -369,7 +368,7 @@ pub struct Tx {
     pub from: Address,
     pub to: Address,
     pub value: Ether,
-    pub input: Bytes<Vec<u8>>,
+    pub input: Bytes,
     #[debug(ignore)]
     pub access_list: AccessList,
 }
@@ -380,7 +379,7 @@ impl From<Tx> for TransactionRequest {
             .from(value.from)
             .to(value.to)
             .value(value.value.0)
-            .input(value.input.0.into())
+            .input(value.input.into())
             .access_list(value.access_list.into())
     }
 }
diff --git a/crates/driver/src/infra/api/routes/quote/dto/order.rs b/crates/driver/src/infra/api/routes/quote/dto/order.rs
index c893e0f901..be8ef90319 100644
--- a/crates/driver/src/infra/api/routes/quote/dto/order.rs
+++ b/crates/driver/src/infra/api/routes/quote/dto/order.rs
@@ -1,8 +1,5 @@
 use {
-    crate::{
-        domain::{competition, eth, quote},
-        util::serialize,
-    },
+    crate::domain::{competition, eth, quote},
     serde::Deserialize,
     serde_with::serde_as,
 };
@@ -27,7 +24,7 @@ impl Order {
 pub struct Order {
     sell_token: eth::Address,
     buy_token: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     amount: eth::U256,
     kind: Kind,
     deadline: chrono::DateTime<chrono::Utc>,
diff --git a/crates/driver/src/infra/api/routes/quote/dto/quote.rs b/crates/driver/src/infra/api/routes/quote/dto/quote.rs
index ebc82de552..2b5b1038de 100644
--- a/crates/driver/src/infra/api/routes/quote/dto/quote.rs
+++ b/crates/driver/src/infra/api/routes/quote/dto/quote.rs
@@ -1,8 +1,5 @@
 use {
-    crate::{
-        domain::{self, competition::solution::encoding::codec, eth, quote},
-        util::serialize,
-    },
+    crate::domain::{self, competition::solution::encoding::codec, eth, quote},
     model::{
         order::{BuyTokenDestination, SellTokenSource},
         signature::SigningScheme,
@@ -34,7 +31,7 @@ impl Quote {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Quote {
-    #[serde_as(as = "HashMap<_, serialize::U256>")]
+    #[serde_as(as = "HashMap<_, serde_ext::U256>")]
     clearing_prices: HashMap<eth::Address, eth::U256>,
     pre_interactions: Vec<Interaction>,
     interactions: Vec<Interaction>,
@@ -51,9 +48,9 @@ pub struct Quote {
 #[serde(rename_all = "camelCase")]
 struct Interaction {
     target: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     value: eth::U256,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     call_data: Vec<u8>,
 }
 
@@ -73,21 +70,21 @@ impl From<eth::Interaction> for Interaction {
 struct JitOrder {
     buy_token: eth::Address,
     sell_token: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     sell_amount: eth::U256,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     buy_amount: eth::U256,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     executed_amount: eth::U256,
     receiver: eth::Address,
     partially_fillable: bool,
     valid_to: u32,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     app_data: [u8; 32],
     side: Side,
     sell_token_source: SellTokenSource,
     buy_token_destination: BuyTokenDestination,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     signature: Vec<u8>,
     signing_scheme: SigningScheme,
 }
diff --git a/crates/driver/src/infra/api/routes/reveal/dto/reveal_response.rs b/crates/driver/src/infra/api/routes/reveal/dto/reveal_response.rs
index 0f1d495042..bc5053a4d5 100644
--- a/crates/driver/src/infra/api/routes/reveal/dto/reveal_response.rs
+++ b/crates/driver/src/infra/api/routes/reveal/dto/reveal_response.rs
@@ -1,8 +1,4 @@
-use {
-    crate::{domain::competition, util::serialize},
-    serde::Serialize,
-    serde_with::serde_as,
-};
+use {crate::domain::competition, serde::Serialize, serde_with::serde_as};
 
 impl RevealResponse {
     pub fn new(reveal: competition::Revealed) -> Self {
@@ -26,8 +22,8 @@ pub struct RevealResponse {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct Calldata {
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     internalized: Vec<u8>,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     uninternalized: Vec<u8>,
 }
diff --git a/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs b/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs
index 5d534e6cd4..4818112e88 100644
--- a/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs
+++ b/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs
@@ -12,7 +12,6 @@ use {
             eth,
         },
         infra::{Ethereum, tokens},
-        util::serialize,
     },
     serde::Deserialize,
     serde_with::serde_as,
@@ -230,7 +229,7 @@ impl SolveRequest {
 #[serde(rename_all = "camelCase")]
 struct Token {
     pub address: eth::Address,
-    #[serde_as(as = "Option<serialize::U256>")]
+    #[serde_as(as = "Option<serde_ext::U256>")]
     pub price: Option<eth::U256>,
     pub trusted: bool,
 }
@@ -239,13 +238,13 @@ struct Token {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct Order {
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     uid: [u8; order::UID_LEN],
     sell_token: eth::Address,
     buy_token: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     sell_amount: eth::U256,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     buy_amount: eth::U256,
     protocol_fees: Vec<FeePolicy>,
     created: u32,
@@ -255,7 +254,7 @@ struct Order {
     owner: eth::Address,
     partially_fillable: bool,
     /// Always zero if the order is not partially fillable.
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     executed: eth::U256,
     pre_interactions: Vec<Interaction>,
     post_interactions: Vec<Interaction>,
@@ -264,10 +263,10 @@ struct Order {
     #[serde(default)]
     buy_token_balance: BuyTokenBalance,
     class: Class,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     app_data: [u8; order::app_data::APP_DATA_LEN],
     signing_scheme: SigningScheme,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     signature: Vec<u8>,
     quote: Option<Quote>,
 }
@@ -284,9 +283,9 @@ enum Kind {
 #[serde(rename_all = "camelCase")]
 struct Interaction {
     target: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     value: eth::U256,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     call_data: Vec<u8>,
 }
 
@@ -342,11 +341,11 @@ enum FeePolicy {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Quote {
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     pub sell_amount: eth::U256,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     pub buy_amount: eth::U256,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     pub fee: eth::U256,
     pub solver: eth::Address,
 }
diff --git a/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs b/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
index 4fde32eeed..c7777f950e 100644
--- a/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
+++ b/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
@@ -2,7 +2,6 @@ use {
     crate::{
         domain::{competition, competition::order, eth},
         infra::Solver,
-        util::serialize,
     },
     serde::Serialize,
     serde_with::serde_as,
@@ -72,11 +71,11 @@ pub struct Solution {
     /// in subsequent requests (reveal, settle).
     solution_id: u64,
     submission_address: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     score: eth::U256,
-    #[serde_as(as = "HashMap<serialize::Hex, _>")]
+    #[serde_as(as = "HashMap<serde_ext::Hex, _>")]
     orders: HashMap<OrderId, TradedOrder>,
-    #[serde_as(as = "HashMap<_, serialize::U256>")]
+    #[serde_as(as = "HashMap<_, serde_ext::U256>")]
     clearing_prices: HashMap<eth::Address, eth::U256>,
 }
 
@@ -87,17 +86,17 @@ pub struct TradedOrder {
     pub side: Side,
     pub sell_token: eth::Address,
     pub buy_token: eth::Address,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     /// Sell limit order amount.
     pub limit_sell: eth::U256,
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     /// Buy limit order amount.
     pub limit_buy: eth::U256,
     /// The effective amount that left the user's wallet including all fees.
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     pub executed_sell: eth::U256,
     /// The effective amount the user received after all fees.
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     pub executed_buy: eth::U256,
 }
 
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index ecdb544e7a..1244567c6e 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -20,6 +20,7 @@ use {
             BalanceOverrides,
             BalanceOverriding,
         },
+        web3,
     },
     std::{fmt, sync::Arc},
     thiserror::Error,
@@ -49,10 +50,14 @@ impl Rpc {
     /// Instantiate an RPC client to an Ethereum (or Ethereum-compatible) node
     /// at the specifed URL.
     pub async fn try_new(args: RpcArgs) -> Result<Self, RpcError> {
-        let web3 = boundary::buffered_web3_client(
+        let web3 = web3::web3(
+            &web3::Arguments {
+                ethrpc_max_batch_size: args.max_batch_size,
+                ethrpc_max_concurrent_requests: args.max_concurrent_requests,
+                ethrpc_batch_delay: Default::default(),
+            },
             &args.url,
-            args.max_batch_size,
-            args.max_concurrent_requests,
+            "base",
         );
         let chain = Chain::try_from(web3.provider.get_chain_id().await?)?;
 
@@ -212,7 +217,7 @@ impl Ethereum {
             .from(tx.from)
             .to(tx.to)
             .value(tx.value.0)
-            .input(tx.input.0.into())
+            .input(tx.input.into())
             .access_list(tx.access_list.into());
 
         let tx = match self.simulation_gas_price().await {
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index bf12ac0895..8f94ba854e 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -1,6 +1,6 @@
 pub use load::load;
 use {
-    crate::{domain::eth, infra, util::serialize},
+    crate::{domain::eth, infra},
     alloy::{eips::BlockNumberOrTag, primitives::Address},
     number::serialization::HexOrDecimalU256,
     reqwest::Url,
@@ -34,7 +34,7 @@ struct Config {
     /// Disable gas simulation and always use this fixed gas value instead. This
     /// can be useful for testing, but shouldn't be used in production since it
     /// will cause the driver to return invalid scores.
-    #[serde_as(as = "Option<serialize::U256>")]
+    #[serde_as(as = "Option<serde_ext::U256>")]
     disable_gas_simulation: Option<eth::U256>,
 
     /// Defines the gas estimator to use.
@@ -99,13 +99,13 @@ struct SubmissionConfig {
     /// The minimum priority fee in Gwei the solver is ensuring to pay in a
     /// settlement.
     #[serde(default)]
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     min_priority_fee: eth::U256,
 
     /// The maximum gas price in Gwei the solver is willing to pay in a
     /// settlement.
     #[serde(default = "default_gas_price_cap")]
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     gas_price_cap: eth::U256,
 
     /// The target confirmation time for settlement transactions used
@@ -159,7 +159,7 @@ struct Mempool {
     /// Maximum additional tip in Gwei that we are willing to give to
     /// the validator above regular gas price estimation.
     #[serde(default = "default_max_additional_tip")]
-    #[serde_as(as = "serialize::U256")]
+    #[serde_as(as = "serde_ext::U256")]
     max_additional_tip: eth::U256,
     /// Additional tip in percentage of max_fee_per_gas we are giving to
     /// validator above regular gas price estimation. Expects a
@@ -377,7 +377,7 @@ struct Slippage {
 
     /// The absolute slippage allowed by the solver.
     #[serde(rename = "absolute-slippage")]
-    #[serde_as(as = "Option<serialize::U256>")]
+    #[serde_as(as = "Option<serde_ext::U256>")]
     absolute: Option<eth::U256>,
 }
 
diff --git a/crates/driver/src/infra/mempool/mod.rs b/crates/driver/src/infra/mempool/mod.rs
index 09ff772e3a..8b7b39646e 100644
--- a/crates/driver/src/infra/mempool/mod.rs
+++ b/crates/driver/src/infra/mempool/mod.rs
@@ -1,6 +1,6 @@
 use {
     crate::{
-        boundary::unbuffered_web3_client,
+        boundary::{Web3, unbuffered_web3},
         domain::{eth, mempools},
         infra::{self, solver::Account},
     },
@@ -13,7 +13,6 @@ use {
     },
     anyhow::Context,
     dashmap::DashMap,
-    ethrpc::Web3,
     std::sync::Arc,
     url::Url,
 };
@@ -84,7 +83,7 @@ impl std::fmt::Display for Mempool {
 
 impl Mempool {
     pub fn new(config: Config, solver_accounts: Vec<Account>) -> Self {
-        let transport = unbuffered_web3_client(&config.url);
+        let transport = unbuffered_web3(&config.url);
         // Register the solver accounts into the wallet to submit txs on their behalf
         for account in solver_accounts {
             transport.wallet.register_signer(account);
@@ -137,7 +136,7 @@ impl Mempool {
             .max_fee_per_gas(max_fee_per_gas)
             .max_priority_fee_per_gas(max_priority_fee_per_gas)
             .gas_limit(gas_limit)
-            .input(tx.input.0.into())
+            .input(tx.input.into())
             .value(tx.value.0)
             .access_list(tx.access_list.into());
 
diff --git a/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs b/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
index 9818d2d366..9ea3292280 100644
--- a/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
+++ b/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
@@ -163,9 +163,8 @@ mod utils {
             crate::{
                 domain::eth,
                 infra::notify::liquidity_sources::liquorice::notifier::utils::extract_rfq_id_from_interaction,
-                util::Bytes,
             },
-            alloy::primitives::Address,
+            alloy::primitives::{Address, Bytes},
         };
 
         #[test]
@@ -176,7 +175,7 @@ mod utils {
             let rfq_id = extract_rfq_id_from_interaction(
                 &eth::Interaction {
                     target: liquorice_settlement_address,
-                    call_data: Bytes(calldata),
+                    call_data: calldata.into(),
                     value: 0.into(),
                 },
                 liquorice_settlement_address,
@@ -191,7 +190,7 @@ mod utils {
             let rfq_id = extract_rfq_id_from_interaction(
                 &eth::Interaction {
                     target: liquorice_settlement_address,
-                    call_data: Bytes(vec![]),
+                    call_data: Bytes::new(),
                     value: 0.into(),
                 },
                 liquorice_settlement_address,
@@ -205,7 +204,7 @@ mod utils {
             let rfq_id = extract_rfq_id_from_interaction(
                 &eth::Interaction {
                     target: Address::random(),
-                    call_data: Bytes(vec![]),
+                    call_data: Bytes::new(),
                     value: 0.into(),
                 },
                 Address::random(),
diff --git a/crates/driver/src/infra/simulator/enso/dto.rs b/crates/driver/src/infra/simulator/enso/dto.rs
index 141390a089..4edf5bc511 100644
--- a/crates/driver/src/infra/simulator/enso/dto.rs
+++ b/crates/driver/src/infra/simulator/enso/dto.rs
@@ -1,7 +1,7 @@
 //! Data transfer objects for interacting with the Enso Trade Simulator API.
 
 use {
-    crate::{domain::eth, util::serialize},
+    crate::domain::eth,
     alloy::rpc::types::AccessList,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
@@ -14,7 +14,7 @@ pub struct Request {
     pub chain_id: u64,
     pub from: eth::Address,
     pub to: eth::Address,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub data: Vec<u8>,
     pub value: eth::U256,
     pub gas_limit: u64,
@@ -34,6 +34,6 @@ pub struct Response {
     pub block_number: u64,
     pub success: bool,
     pub exit_reason: String,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub return_data: Vec<u8>,
 }
diff --git a/crates/driver/src/infra/simulator/tenderly/dto.rs b/crates/driver/src/infra/simulator/tenderly/dto.rs
index 4e8f70ffa8..d697bd2809 100644
--- a/crates/driver/src/infra/simulator/tenderly/dto.rs
+++ b/crates/driver/src/infra/simulator/tenderly/dto.rs
@@ -1,7 +1,7 @@
 //! Data transfer objects for interacting with the Tenderly API.
 
 use {
-    crate::{domain::eth, util::serialize},
+    crate::domain::eth,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
 };
@@ -12,7 +12,7 @@ pub struct Request {
     pub network_id: String,
     pub from: eth::Address,
     pub to: eth::Address,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub input: Vec<u8>,
     pub value: eth::U256,
     pub save: bool,
diff --git a/crates/driver/src/infra/solver/dto/auction.rs b/crates/driver/src/infra/solver/dto/auction.rs
index 6ef1963c2f..6bc212740c 100644
--- a/crates/driver/src/infra/solver/dto/auction.rs
+++ b/crates/driver/src/infra/solver/dto/auction.rs
@@ -361,7 +361,7 @@ fn interaction_from_domain(value: eth::Interaction) -> solvers_dto::auction::Int
     solvers_dto::auction::InteractionData {
         target: value.target,
         value: value.value.0,
-        call_data: value.call_data.0,
+        call_data: value.call_data.to_vec(),
     }
 }
 
diff --git a/crates/driver/src/infra/solver/dto/solution.rs b/crates/driver/src/infra/solver/dto/solution.rs
index a3794444a5..7b8f627fbd 100644
--- a/crates/driver/src/infra/solver/dto/solution.rs
+++ b/crates/driver/src/infra/solver/dto/solution.rs
@@ -6,8 +6,8 @@ use {
             liquidity,
         },
         infra::Solver,
-        util::Bytes,
     },
+    alloy::primitives::Bytes,
     app_data::AppDataHash,
     itertools::Itertools,
     model::{
@@ -150,7 +150,7 @@ impl Solutions {
                         .map(|interaction| eth::Interaction {
                             target: interaction.target,
                             value: interaction.value.into(),
-                            call_data: Bytes(interaction.calldata),
+                            call_data: Bytes::from(interaction.calldata),
                         })
                         .collect(),
                     solution
@@ -227,7 +227,7 @@ impl Solutions {
                         .map(|interaction| eth::Interaction {
                             target: interaction.target,
                             value: interaction.value.into(),
-                            call_data: Bytes(interaction.calldata),
+                            call_data: interaction.calldata.into(),
                         })
                         .collect(),
                     solver.clone(),
@@ -345,7 +345,7 @@ impl JitOrder {
             // signature bytes. This leads to the owner being encoded twice in
             // the final settlement calldata unless we remove that from the raw
             // data.
-            signature.data = Bytes(self.0.signature[20..].to_vec());
+            signature.data = Bytes::copy_from_slice(&self.0.signature[20..]);
         }
 
         signature.signer = signer;
diff --git a/crates/driver/src/util/mod.rs b/crates/driver/src/util/mod.rs
index 35fcc22956..38aff00c0d 100644
--- a/crates/driver/src/util/mod.rs
+++ b/crates/driver/src/util/mod.rs
@@ -1,8 +1,6 @@
-mod bytes;
 pub mod http;
 pub mod math;
 mod percent;
-pub mod serialize;
 mod time;
 
-pub use {bytes::Bytes, percent::Percent, time::Timestamp};
+pub use {percent::Percent, time::Timestamp};
diff --git a/crates/e2e/src/setup/deploy.rs b/crates/e2e/src/setup/deploy.rs
index f6963d31fb..83e3c1589a 100644
--- a/crates/e2e/src/setup/deploy.rs
+++ b/crates/e2e/src/setup/deploy.rs
@@ -18,7 +18,7 @@ use {
     },
     ethrpc::alloy::CallBuilderExt,
     model::DomainSeparator,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[derive(Default)]
diff --git a/crates/e2e/src/setup/onchain_components/mod.rs b/crates/e2e/src/setup/onchain_components/mod.rs
index 1524b8ef59..c5080fc3e9 100644
--- a/crates/e2e/src/setup/onchain_components/mod.rs
+++ b/crates/e2e/src/setup/onchain_components/mod.rs
@@ -23,7 +23,7 @@ use {
         signature::{EcdsaSignature, EcdsaSigningScheme},
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     std::{borrow::BorrowMut, ops::Deref},
 };
 
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 74226f468f..49ee87202c 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -26,7 +26,7 @@ use {
         trade::Trade,
     },
     reqwest::{Client, StatusCode, Url},
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     sqlx::Connection,
     std::{
         collections::{HashMap, hash_map::Entry},
diff --git a/crates/e2e/tests/e2e/api_version.rs b/crates/e2e/tests/e2e/api_version.rs
index fd1998ca57..8cf68b94bc 100644
--- a/crates/e2e/tests/e2e/api_version.rs
+++ b/crates/e2e/tests/e2e/api_version.rs
@@ -1,4 +1,4 @@
-use {e2e::setup::*, number::units::EthUnit, shared::ethrpc::Web3};
+use {e2e::setup::*, number::units::EthUnit, shared::web3::Web3};
 
 #[tokio::test]
 #[ignore]
diff --git a/crates/e2e/tests/e2e/app_data.rs b/crates/e2e/tests/e2e/app_data.rs
index 512c0d9d59..cd60790f08 100644
--- a/crates/e2e/tests/e2e/app_data.rs
+++ b/crates/e2e/tests/e2e/app_data.rs
@@ -9,7 +9,7 @@ use {
     },
     number::units::EthUnit,
     reqwest::StatusCode,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     std::str::FromStr,
 };
 
diff --git a/crates/e2e/tests/e2e/app_data_signer.rs b/crates/e2e/tests/e2e/app_data_signer.rs
index 3630647dd2..b08811dd32 100644
--- a/crates/e2e/tests/e2e/app_data_signer.rs
+++ b/crates/e2e/tests/e2e/app_data_signer.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 6d3736e420..e22e401ca7 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index 540385d082..06af718024 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -4,7 +4,7 @@
 use {
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     reqwest::{Method, StatusCode},
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 0cb0cf730d..7faa156388 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -29,7 +29,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     solvers_dto::solution::{
         BuyTokenBalance,
         Call,
diff --git a/crates/e2e/tests/e2e/deprecated_endpoints.rs b/crates/e2e/tests/e2e/deprecated_endpoints.rs
index 757d31cbde..f99788e04c 100644
--- a/crates/e2e/tests/e2e/deprecated_endpoints.rs
+++ b/crates/e2e/tests/e2e/deprecated_endpoints.rs
@@ -8,7 +8,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/eth_integration.rs b/crates/e2e/tests/e2e/eth_integration.rs
index 1a0417ddb2..fcd368ba7c 100644
--- a/crates/e2e/tests/e2e/eth_integration.rs
+++ b/crates/e2e/tests/e2e/eth_integration.rs
@@ -8,7 +8,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/eth_safe.rs b/crates/e2e/tests/e2e/eth_safe.rs
index 3925e8f60f..5b9cd7aa32 100644
--- a/crates/e2e/tests/e2e/eth_safe.rs
+++ b/crates/e2e/tests/e2e/eth_safe.rs
@@ -7,7 +7,7 @@ use {
         signature::{Signature, hashed_eip712_message},
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/hooks.rs b/crates/e2e/tests/e2e/hooks.rs
index 39696c2904..b88eedec5e 100644
--- a/crates/e2e/tests/e2e/hooks.rs
+++ b/crates/e2e/tests/e2e/hooks.rs
@@ -22,7 +22,7 @@ use {
     number::{nonzero::NonZeroU256, units::EthUnit},
     reqwest::StatusCode,
     serde_json::json,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index 0c7968ab49..b93218458a 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     solvers_dto::solution::{Asset, Solution},
     std::collections::HashMap,
 };
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 6417277b19..9777bb14b3 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -17,7 +17,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{conversions::big_decimal_to_big_uint, units::EthUnit},
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     std::{collections::HashMap, ops::DerefMut},
 };
 
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index fb9aff9df4..046f460c8b 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -6,7 +6,7 @@ use {
     orderbook::api::Error,
     reqwest::StatusCode,
     serde_json::json,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 const VALID_ORDER_UID: &str = "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index d9c6c84d37..a2dd9a5cdf 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -19,7 +19,7 @@ use {
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
     serde_json::json,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/partial_fill.rs b/crates/e2e/tests/e2e/partial_fill.rs
index eeb97a3551..7da2b5c875 100644
--- a/crates/e2e/tests/e2e/partial_fill.rs
+++ b/crates/e2e/tests/e2e/partial_fill.rs
@@ -8,7 +8,7 @@ use {
     },
     number::units::EthUnit,
     orderbook::dto::order::Status,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/partially_fillable_balance.rs b/crates/e2e/tests/e2e/partially_fillable_balance.rs
index c9d9ce08d1..520ba5d8fd 100644
--- a/crates/e2e/tests/e2e/partially_fillable_balance.rs
+++ b/crates/e2e/tests/e2e/partially_fillable_balance.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/partially_fillable_pool.rs b/crates/e2e/tests/e2e/partially_fillable_pool.rs
index 7898dabe1f..84e5c8a7ab 100644
--- a/crates/e2e/tests/e2e/partially_fillable_pool.rs
+++ b/crates/e2e/tests/e2e/partially_fillable_pool.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 #[tokio::test]
 #[ignore]
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 07bef2aa6c..47d7808297 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -9,7 +9,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     std::ops::DerefMut,
 };
 
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 7f12981675..42f34549b0 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -22,7 +22,7 @@ use {
     number::units::EthUnit,
     reqwest::StatusCode,
     serde_json::json,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 6437a94ea2..c9839e8865 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -9,7 +9,7 @@ use {
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
     serde_json::json,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     std::{
         sync::Arc,
         time::{Duration, Instant},
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index c1c8d65cff..ddc9ab1812 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -12,7 +12,7 @@ use {
         orderbook::{OrderCancellationError, OrderReplacementError},
     },
     reqwest::StatusCode,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 // Parse OrderReplacementError from HTTP response
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index bc1ca03996..3b70c85415 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -8,7 +8,7 @@ use {
     },
     number::units::EthUnit,
     reqwest::StatusCode,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index dbe659be82..1b03cea819 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     solvers_dto::solution::Solution,
     std::collections::HashMap,
 };
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 562c7fd87a..02528fc5fb 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -16,7 +16,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{nonzero::NonZeroU256, testing::ApproxEq, units::EthUnit},
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
     std::time::Duration,
 };
 
diff --git a/crates/e2e/tests/e2e/token_metadata.rs b/crates/e2e/tests/e2e/token_metadata.rs
index f234e58b2e..b04c5ccb9e 100644
--- a/crates/e2e/tests/e2e/token_metadata.rs
+++ b/crates/e2e/tests/e2e/token_metadata.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/tracking_insufficient_funds.rs b/crates/e2e/tests/e2e/tracking_insufficient_funds.rs
index 0ed43b79b8..93bacc84df 100644
--- a/crates/e2e/tests/e2e/tracking_insufficient_funds.rs
+++ b/crates/e2e/tests/e2e/tracking_insufficient_funds.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/trades_v2.rs b/crates/e2e/tests/e2e/trades_v2.rs
index 0877a4c64c..664157e4ec 100644
--- a/crates/e2e/tests/e2e/trades_v2.rs
+++ b/crates/e2e/tests/e2e/trades_v2.rs
@@ -7,7 +7,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/uncovered_order.rs b/crates/e2e/tests/e2e/uncovered_order.rs
index 8f6dd52624..a49e54243c 100644
--- a/crates/e2e/tests/e2e/uncovered_order.rs
+++ b/crates/e2e/tests/e2e/uncovered_order.rs
@@ -6,7 +6,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/univ2.rs b/crates/e2e/tests/e2e/univ2.rs
index 067fb3b3b2..57812bf129 100644
--- a/crates/e2e/tests/e2e/univ2.rs
+++ b/crates/e2e/tests/e2e/univ2.rs
@@ -9,7 +9,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/user_surplus.rs b/crates/e2e/tests/e2e/user_surplus.rs
index 71d029068f..4023affeb6 100644
--- a/crates/e2e/tests/e2e/user_surplus.rs
+++ b/crates/e2e/tests/e2e/user_surplus.rs
@@ -8,7 +8,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/vault_balances.rs b/crates/e2e/tests/e2e/vault_balances.rs
index bfc93b3393..d50fa3dff4 100644
--- a/crates/e2e/tests/e2e/vault_balances.rs
+++ b/crates/e2e/tests/e2e/vault_balances.rs
@@ -6,7 +6,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/wrapper.rs b/crates/e2e/tests/e2e/wrapper.rs
index 6bcf5c47f6..edffd1444b 100644
--- a/crates/e2e/tests/e2e/wrapper.rs
+++ b/crates/e2e/tests/e2e/wrapper.rs
@@ -18,7 +18,7 @@ use {
     },
     number::units::EthUnit,
     serde_json::json,
-    shared::ethrpc::Web3,
+    shared::web3::Web3,
 };
 
 /// The block number from which we will fetch state for the forked test.
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 3be02485fb..8ab767e4eb 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -67,12 +67,12 @@ pub async fn start(args: impl Iterator<Item = String>) {
 pub async fn run(args: Arguments) {
     let http_factory = HttpClientFactory::new(&args.http_client);
 
-    let web3 = shared::ethrpc::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
+    let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
     let simulation_web3 = args
         .shared
         .simulation_node_url
         .as_ref()
-        .map(|node_url| shared::ethrpc::web3(&args.shared.ethrpc, node_url, "simulation"));
+        .map(|node_url| shared::web3::web3(&args.shared.ethrpc, node_url, "simulation"));
 
     let chain_id = web3
         .provider
diff --git a/crates/refunder/src/arguments.rs b/crates/refunder/src/arguments.rs
index 5e3c09d9bc..36fab7d1d0 100644
--- a/crates/refunder/src/arguments.rs
+++ b/crates/refunder/src/arguments.rs
@@ -1,7 +1,7 @@
 use {
     alloy::primitives::Address,
     clap::Parser,
-    shared::{arguments::display_option, ethrpc, http_client, logging_args_with_default_filter},
+    shared::{arguments::display_option, http_client, logging_args_with_default_filter, web3},
     std::time::Duration,
     url::Url,
 };
@@ -14,7 +14,7 @@ pub struct Arguments {
     pub http_client: http_client::Arguments,
 
     #[clap(flatten)]
-    pub ethrpc: ethrpc::Arguments,
+    pub ethrpc: web3::Arguments,
 
     #[clap(flatten)]
     pub logging: LoggingArguments,
diff --git a/crates/refunder/src/lib.rs b/crates/refunder/src/lib.rs
index 94b4b9d49a..e9f17b9c0b 100644
--- a/crates/refunder/src/lib.rs
+++ b/crates/refunder/src/lib.rs
@@ -67,7 +67,7 @@ pub async fn run(args: arguments::Arguments) {
         .expect("failed to create database");
 
     // Blockchain/RPC setup
-    let web3 = shared::ethrpc::web3(&args.ethrpc, &args.node_url, "base");
+    let web3 = shared::web3::web3(&args.ethrpc, &args.node_url, "base");
 
     if let Some(expected_chain_id) = args.chain_id {
         let chain_id = web3
diff --git a/crates/refunder/src/submitter.rs b/crates/refunder/src/submitter.rs
index 7930af9ba6..54764091c5 100644
--- a/crates/refunder/src/submitter.rs
+++ b/crates/refunder/src/submitter.rs
@@ -12,8 +12,8 @@ use {
     contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
     database::OrderUid,
     shared::{
-        ethrpc::Web3,
         gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
+        web3::Web3,
     },
     std::time::Duration,
 };
diff --git a/crates/serde-ext/Cargo.toml b/crates/serde-ext/Cargo.toml
new file mode 100644
index 0000000000..e45beaa60a
--- /dev/null
+++ b/crates/serde-ext/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "serde-ext"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+const-hex = { workspace = true }
+serde = { workspace = true }
+serde_with = { workspace = true }
\ No newline at end of file
diff --git a/crates/driver/src/util/serialize/hex.rs b/crates/serde-ext/src/hex.rs
similarity index 100%
rename from crates/driver/src/util/serialize/hex.rs
rename to crates/serde-ext/src/hex.rs
diff --git a/crates/driver/src/util/serialize/mod.rs b/crates/serde-ext/src/lib.rs
similarity index 100%
rename from crates/driver/src/util/serialize/mod.rs
rename to crates/serde-ext/src/lib.rs
diff --git a/crates/driver/src/util/serialize/u256.rs b/crates/serde-ext/src/u256.rs
similarity index 72%
rename from crates/driver/src/util/serialize/u256.rs
rename to crates/serde-ext/src/u256.rs
index 3984c117dc..a0a5e0e9a0 100644
--- a/crates/driver/src/util/serialize/u256.rs
+++ b/crates/serde-ext/src/u256.rs
@@ -1,5 +1,5 @@
 use {
-    crate::domain::eth,
+    alloy::primitives as alloy,
     serde::{Deserializer, Serializer, de},
     serde_with::{DeserializeAs, SerializeAs},
 };
@@ -10,12 +10,12 @@ use {
 #[derive(Debug)]
 pub struct U256;
 
-impl<'de> DeserializeAs<'de, eth::U256> for U256 {
-    fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<eth::U256, D::Error> {
+impl<'de> DeserializeAs<'de, alloy::U256> for U256 {
+    fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<alloy::U256, D::Error> {
         struct Visitor;
 
         impl de::Visitor<'_> for Visitor {
-            type Value = eth::U256;
+            type Value = alloy::U256;
 
             fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                 write!(formatter, "a 256-bit decimal string")
@@ -25,7 +25,7 @@ impl<'de> DeserializeAs<'de, eth::U256> for U256 {
             where
                 E: de::Error,
             {
-                eth::U256::from_str_radix(s, 10).map_err(|err| {
+                alloy::U256::from_str_radix(s, 10).map_err(|err| {
                     de::Error::custom(format!("failed to decode {s:?} as a 256-bit number: {err}"))
                 })
             }
@@ -35,8 +35,8 @@ impl<'de> DeserializeAs<'de, eth::U256> for U256 {
     }
 }
 
-impl SerializeAs<eth::U256> for U256 {
-    fn serialize_as<S: Serializer>(source: &eth::U256, serializer: S) -> Result<S::Ok, S::Error> {
+impl SerializeAs<alloy::U256> for U256 {
+    fn serialize_as<S: Serializer>(source: &alloy::U256, serializer: S) -> Result<S::Ok, S::Error> {
         serializer.serialize_str(&source.to_string())
     }
 }
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index a01f2a7dc3..f261e58d74 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -143,7 +143,7 @@ impl Display for DatabasePoolConfig {
 #[group(skip)]
 pub struct Arguments {
     #[clap(flatten)]
-    pub ethrpc: crate::ethrpc::Arguments,
+    pub ethrpc: crate::web3::Arguments,
 
     #[clap(flatten)]
     pub current_block: crate::current_block::Arguments,
diff --git a/crates/shared/src/bad_token/trace_call.rs b/crates/shared/src/bad_token/trace_call.rs
index 8b529edcf4..67c6633a1f 100644
--- a/crates/shared/src/bad_token/trace_call.rs
+++ b/crates/shared/src/bad_token/trace_call.rs
@@ -1,6 +1,6 @@
 use {
     super::TokenQuality,
-    crate::{ethrpc::Web3, trace_many},
+    crate::{trace_many, web3::Web3},
     alloy::{
         primitives::{Address, U256, keccak256},
         rpc::{
diff --git a/crates/driver/src/util/bytes.rs b/crates/shared/src/bytes.rs
similarity index 100%
rename from crates/driver/src/util/bytes.rs
rename to crates/shared/src/bytes.rs
diff --git a/crates/shared/src/code_fetching.rs b/crates/shared/src/code_fetching.rs
index a1e78da06d..a1083f5ebc 100644
--- a/crates/shared/src/code_fetching.rs
+++ b/crates/shared/src/code_fetching.rs
@@ -2,7 +2,7 @@
 //! more easily be tested with mocked versions of these behaviours.
 
 use {
-    crate::ethrpc::Web3,
+    crate::web3::Web3,
     alloy::{
         primitives::{Address, Bytes},
         providers::Provider,
diff --git a/crates/shared/src/gas_price_estimation/mod.rs b/crates/shared/src/gas_price_estimation/mod.rs
index 040eaf41d6..e4dcdc772c 100644
--- a/crates/shared/src/gas_price_estimation/mod.rs
+++ b/crates/shared/src/gas_price_estimation/mod.rs
@@ -6,7 +6,6 @@ pub mod priority;
 
 use {
     crate::{
-        ethrpc::Web3,
         gas_price_estimation::{
             configurable_alloy::{
                 ConfigurableGasPriceEstimator,
@@ -18,6 +17,7 @@ use {
             priority::PriorityGasPriceEstimating,
         },
         http_client::HttpClientFactory,
+        web3::Web3,
     },
     ::alloy::{
         eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 15253452b6..9cbd012506 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -11,7 +11,6 @@ pub mod code_fetching;
 pub mod current_block;
 pub mod db_order_conversions;
 pub mod encoded_settlement;
-pub mod ethrpc;
 pub mod event_handling;
 pub mod event_storing_helpers;
 pub mod external_prices;
@@ -37,6 +36,7 @@ pub mod token_list;
 pub mod trace_many;
 pub mod trade_finding;
 pub mod url;
+pub mod web3;
 pub mod zeroex_api;
 
 /// anyhow errors are not clonable natively. This is a workaround that creates a
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index 43fe6e1e01..f46a9c8767 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -15,7 +15,6 @@ use {
         arguments,
         bad_token::list_based::DenyListedTokens,
         code_fetching::CachedCodeFetcher,
-        ethrpc::Web3,
         gas_price_estimation::GasPriceEstimating,
         http_client::HttpClientFactory,
         price_estimation::{
@@ -25,6 +24,7 @@ use {
         },
         tenderly_api::TenderlyCodeSimulator,
         token_info::TokenInfoFetching,
+        web3::Web3,
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs b/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
index 6c99612470..dae2f87569 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
+++ b/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
@@ -26,9 +26,9 @@ use {
         swap::fixed_point::Bfp,
     },
     crate::{
-        ethrpc::Web3,
         recent_block_cache::{Block, CacheConfig},
         token_info::TokenInfoFetching,
+        web3::Web3,
     },
     alloy::{
         eips::BlockNumberOrTag,
diff --git a/crates/shared/src/sources/swapr.rs b/crates/shared/src/sources/swapr.rs
index d4a3062f97..bb2d3a6d73 100644
--- a/crates/shared/src/sources/swapr.rs
+++ b/crates/shared/src/sources/swapr.rs
@@ -55,9 +55,9 @@ mod tests {
     use {
         super::*,
         crate::{
-            ethrpc::Web3,
             recent_block_cache::Block,
             sources::{BaselineSource, uniswap_v2},
+            web3::Web3,
         },
         alloy::{
             primitives::{Address, address},
diff --git a/crates/shared/src/sources/uniswap_v2/mod.rs b/crates/shared/src/sources/uniswap_v2/mod.rs
index aee970fc35..8d6025909d 100644
--- a/crates/shared/src/sources/uniswap_v2/mod.rs
+++ b/crates/shared/src/sources/uniswap_v2/mod.rs
@@ -10,8 +10,8 @@ use {
         pool_fetching::{DefaultPoolReader, PoolFetching, PoolReading},
     },
     crate::{
-        ethrpc::Web3,
         sources::{BaselineSource, swapr::SwaprPoolReader},
+        web3::Web3,
     },
     alloy::primitives::{Address, B256},
     anyhow::{Context, Result},
diff --git a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs b/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
index 7e322491fe..d27e85fa14 100644
--- a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
+++ b/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
@@ -1,6 +1,6 @@
 use {
     super::pair_provider::PairProvider,
-    crate::{baseline_solver::BaselineSolvable, ethrpc::Web3, recent_block_cache::Block},
+    crate::{baseline_solver::BaselineSolvable, recent_block_cache::Block, web3::Web3},
     alloy::{
         eips::BlockId,
         primitives::{Address, U256},
diff --git a/crates/shared/src/trace_many.rs b/crates/shared/src/trace_many.rs
index a4033a6799..96c9ddc473 100644
--- a/crates/shared/src/trace_many.rs
+++ b/crates/shared/src/trace_many.rs
@@ -1,5 +1,5 @@
 use {
-    crate::ethrpc::Web3,
+    crate::web3::Web3,
     alloy::{
         providers::ext::TraceApi,
         rpc::types::{
diff --git a/crates/shared/src/ethrpc.rs b/crates/shared/src/web3.rs
similarity index 100%
rename from crates/shared/src/ethrpc.rs
rename to crates/shared/src/web3.rs
diff --git a/crates/solver/src/liquidity/balancer_v2.rs b/crates/solver/src/liquidity/balancer_v2.rs
index 9ce7a836de..1ca1e2475f 100644
--- a/crates/solver/src/liquidity/balancer_v2.rs
+++ b/crates/solver/src/liquidity/balancer_v2.rs
@@ -20,10 +20,10 @@ use {
     anyhow::Result,
     model::TokenPair,
     shared::{
-        ethrpc::Web3,
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
         sources::balancer_v2::pool_fetching::BalancerPoolFetching,
+        web3::Web3,
     },
     std::{collections::HashSet, sync::Arc},
     tracing::instrument,
diff --git a/crates/solver/src/liquidity/uniswap_v2.rs b/crates/solver/src/liquidity/uniswap_v2.rs
index 4b917d5dc3..f6236a966c 100644
--- a/crates/solver/src/liquidity/uniswap_v2.rs
+++ b/crates/solver/src/liquidity/uniswap_v2.rs
@@ -13,10 +13,10 @@ use {
     anyhow::Result,
     model::TokenPair,
     shared::{
-        ethrpc::Web3,
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
         sources::uniswap_v2::pool_fetching::PoolFetching,
+        web3::Web3,
     },
     std::{
         collections::HashSet,
diff --git a/crates/solver/src/liquidity/uniswap_v3.rs b/crates/solver/src/liquidity/uniswap_v3.rs
index cd3d2b4f02..b3e2b4034b 100644
--- a/crates/solver/src/liquidity/uniswap_v3.rs
+++ b/crates/solver/src/liquidity/uniswap_v3.rs
@@ -15,10 +15,10 @@ use {
     model::TokenPair,
     num::{CheckedMul, rational::Ratio},
     shared::{
-        ethrpc::Web3,
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
         sources::uniswap_v3::pool_fetching::PoolFetching,
+        web3::Web3,
     },
     std::{
         collections::HashSet,
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index 503be0c60f..e6cf0f13e9 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -18,9 +18,9 @@ use {
     itertools::Itertools,
     model::{TokenPair, order::OrderKind},
     shared::{
-        ethrpc::Web3,
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
+        web3::Web3,
         zeroex_api::{OrderRecord, OrdersQuery, ZeroExApi},
     },
     std::{
diff --git a/crates/solvers-dto/Cargo.toml b/crates/solvers-dto/Cargo.toml
index fa1504ab30..3ac3c8df92 100644
--- a/crates/solvers-dto/Cargo.toml
+++ b/crates/solvers-dto/Cargo.toml
@@ -14,6 +14,7 @@ chrono = { workspace = true, features = ["serde"] }
 const-hex = { workspace = true }
 number = { workspace = true }
 serde = { workspace = true }
+serde-ext = { workspace = true }
 serde_with = { workspace = true }
 
 [lints]
diff --git a/crates/solvers-dto/src/auction.rs b/crates/solvers-dto/src/auction.rs
index ecb11ca914..f0d244de8d 100644
--- a/crates/solvers-dto/src/auction.rs
+++ b/crates/solvers-dto/src/auction.rs
@@ -1,5 +1,4 @@
 use {
-    super::serialize,
     alloy::primitives::{Address, B256, U256},
     app_data::AppDataHash,
     bigdecimal::BigDecimal,
@@ -28,7 +27,7 @@ pub struct Auction {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Order {
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub uid: [u8; 56],
     pub sell_token: Address,
     pub buy_token: Address,
@@ -273,7 +272,7 @@ pub struct ForeignLimitOrder {
     pub address: Address,
     #[serde_as(as = "HexOrDecimalU256")]
     pub gas_estimate: U256,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub hash: [u8; 32],
     pub maker_token: Address,
     pub taker_token: Address,
diff --git a/crates/solvers-dto/src/lib.rs b/crates/solvers-dto/src/lib.rs
index 2fe62793e6..d7c9d518dc 100644
--- a/crates/solvers-dto/src/lib.rs
+++ b/crates/solvers-dto/src/lib.rs
@@ -4,109 +4,3 @@
 pub mod auction;
 pub mod notification;
 pub mod solution;
-
-mod serialize {
-    use {
-        serde::{Deserializer, Serializer, de},
-        serde_with::{DeserializeAs, SerializeAs},
-    };
-
-    /// Serialize and deserialize binary data as a hexadecimal string.
-    #[derive(Debug)]
-    pub struct Hex;
-
-    impl<'de> DeserializeAs<'de, Vec<u8>> for Hex {
-        fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<Vec<u8>, D::Error> {
-            struct Visitor;
-
-            impl de::Visitor<'_> for Visitor {
-                type Value = Vec<u8>;
-
-                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                    write!(formatter, "a hex-encoded string starting with \"0x\"")
-                }
-
-                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-                where
-                    E: de::Error,
-                {
-                    if !s.starts_with("0x") {
-                        return Err(de::Error::custom(format!(
-                            "failed to decode {s:?} as a hex string: missing \"0x\" prefix",
-                        )));
-                    }
-                    const_hex::decode(&s[2..]).map_err(|err| {
-                        de::Error::custom(format!("failed to decode {s:?} as a hex string: {err}",))
-                    })
-                }
-            }
-
-            deserializer.deserialize_str(Visitor)
-        }
-    }
-
-    impl SerializeAs<Vec<u8>> for Hex {
-        fn serialize_as<S: Serializer>(source: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error> {
-            serializer.serialize_str(&bytes_to_hex_string(source.as_ref()))
-        }
-    }
-
-    impl<'de, const N: usize> DeserializeAs<'de, [u8; N]> for Hex {
-        fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<[u8; N], D::Error> {
-            struct Visitor<const N: usize> {
-                result: [u8; N],
-            }
-
-            impl<const N: usize> de::Visitor<'_> for Visitor<N> {
-                type Value = [u8; N];
-
-                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                    write!(
-                        formatter,
-                        "a hex-encoded string starting with \"0x\" containing {N} bytes",
-                    )
-                }
-
-                fn visit_str<E>(mut self, s: &str) -> Result<Self::Value, E>
-                where
-                    E: de::Error,
-                {
-                    if !s.starts_with("0x") {
-                        return Err(de::Error::custom(format!(
-                            "failed to decode {s:?} as a hex string: missing \"0x\" prefix",
-                        )));
-                    }
-                    let decoded = const_hex::decode(&s[2..]).map_err(|err| {
-                        de::Error::custom(format!("failed to decode {s:?} as a hex string: {err}",))
-                    })?;
-                    if decoded.len() != N {
-                        return Err(de::Error::custom(format!(
-                            "failed to decode {s:?} as a hex string: expected {N} bytes, got {}",
-                            decoded.len()
-                        )));
-                    }
-                    self.result.copy_from_slice(&decoded);
-                    Ok(self.result)
-                }
-            }
-
-            deserializer.deserialize_str(Visitor { result: [0; N] })
-        }
-    }
-
-    impl<const N: usize> SerializeAs<[u8; N]> for Hex {
-        fn serialize_as<S: Serializer>(source: &[u8; N], serializer: S) -> Result<S::Ok, S::Error> {
-            serializer.serialize_str(&bytes_to_hex_string(source))
-        }
-    }
-
-    fn bytes_to_hex_string(bytes: &[u8]) -> String {
-        let mut v = vec![0u8; 2 + bytes.len() * 2];
-        v[0] = b'0';
-        v[1] = b'x';
-        // Unwrap because only possible error is vector wrong size which cannot happen.
-        const_hex::encode_to_slice(bytes, &mut v[2..]).unwrap();
-        // Unwrap because encoded data is always valid utf8.
-        String::from_utf8(v).unwrap()
-    }
-}
diff --git a/crates/solvers-dto/src/notification.rs b/crates/solvers-dto/src/notification.rs
index 7abdb0b53f..2a12552b61 100644
--- a/crates/solvers-dto/src/notification.rs
+++ b/crates/solvers-dto/src/notification.rs
@@ -1,5 +1,4 @@
 use {
-    super::serialize,
     alloy::{
         primitives::{Address, B256, U256},
         rpc::types::AccessList,
@@ -81,7 +80,7 @@ type BlockNo = u64;
 pub struct Tx {
     pub from: Address,
     pub to: Address,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub input: Vec<u8>,
     #[serde_as(as = "HexOrDecimalU256")]
     pub value: U256,
diff --git a/crates/solvers-dto/src/solution.rs b/crates/solvers-dto/src/solution.rs
index 701d80f87c..0f457cd424 100644
--- a/crates/solvers-dto/src/solution.rs
+++ b/crates/solvers-dto/src/solution.rs
@@ -1,5 +1,4 @@
 use {
-    super::serialize,
     alloy::primitives::{Address, U256},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
@@ -36,7 +35,7 @@ pub struct Solution {
 
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize, Hash, Eq, PartialEq)]
-pub struct OrderUid(#[serde_as(as = "serialize::Hex")] pub [u8; 56]);
+pub struct OrderUid(#[serde_as(as = "serde_ext::Hex")] pub [u8; 56]);
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "camelCase")]
@@ -83,13 +82,13 @@ pub struct JitOrder {
     #[serde(default)]
     pub partially_fillable: bool,
     pub valid_to: u32,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub app_data: [u8; 32],
     pub kind: Kind,
     pub sell_token_balance: SellTokenBalance,
     pub buy_token_balance: BuyTokenBalance,
     pub signing_scheme: SigningScheme,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub signature: Vec<u8>,
 }
 
@@ -114,7 +113,7 @@ pub struct Call {
     pub target: Address,
     pub value: U256,
     #[serde(rename = "callData")]
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub calldata: Vec<u8>,
 }
 
@@ -141,7 +140,7 @@ pub struct CustomInteraction {
     #[serde_as(as = "HexOrDecimalU256")]
     pub value: U256,
     #[serde(rename = "callData")]
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub calldata: Vec<u8>,
     pub allowances: Vec<Allowance>,
     pub inputs: Vec<Asset>,
@@ -158,7 +157,7 @@ pub struct OrderInteraction {
     #[serde_as(as = "HexOrDecimalU256")]
     pub value: U256,
     #[serde(rename = "callData")]
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     pub calldata: Vec<u8>,
 }
 
@@ -224,7 +223,7 @@ pub struct Flashloan {
 #[serde(rename_all = "camelCase")]
 pub struct WrapperCall {
     pub address: Address,
-    #[serde_as(as = "serialize::Hex")]
+    #[serde_as(as = "serde_ext::Hex")]
     #[serde(default)]
     pub data: Vec<u8>,
 }

From 89bdca31a7e4ee05834f52033104f8eb5d0379c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 17 Feb 2026 10:18:27 +0000
Subject: [PATCH 067/219] Add TOML configuration to the autopilot (#4147)

# Description
Kicks off #4005; to start only one of the more annoying arguments was
migrated to validate the approach.

# Changes

- [ ] Add an optional config path
- [ ] Remove the drivers CLI arg
- [ ] Move the drivers argument to the TOML parsing

## How to test
* Migrate the drivers argument to TOML in the infra repo
* Run in staging
---
 Cargo.lock                                    |   2 +
 crates/autopilot/Cargo.toml                   |   6 +-
 crates/autopilot/src/arguments.rs             | 147 ++-----------
 crates/autopilot/src/config/mod.rs            |  60 ++++++
 crates/autopilot/src/config/solver.rs         | 201 ++++++++++++++++++
 .../domain/competition/winner_selection.rs    |   4 +-
 crates/autopilot/src/infra/solvers/mod.rs     |  16 +-
 crates/autopilot/src/lib.rs                   |   1 +
 crates/autopilot/src/run.rs                   |  46 ++--
 crates/e2e/Cargo.toml                         |   2 +-
 crates/e2e/src/setup/services.rs              |  51 +++--
 crates/e2e/tests/e2e/autopilot_leader.rs      |  75 +++++--
 crates/e2e/tests/e2e/buffers.rs               |  20 +-
 crates/e2e/tests/e2e/cow_amm.rs               |  58 ++++-
 crates/e2e/tests/e2e/jit_orders.rs            |  22 +-
 crates/e2e/tests/e2e/limit_orders.rs          |  71 +++++--
 crates/e2e/tests/e2e/liquidity.rs             |  20 +-
 .../e2e/liquidity_source_notification.rs      |  21 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |   3 +
 crates/e2e/tests/e2e/solver_competition.rs    |  86 ++++++--
 20 files changed, 645 insertions(+), 267 deletions(-)
 create mode 100644 crates/autopilot/src/config/mod.rs
 create mode 100644 crates/autopilot/src/config/solver.rs

diff --git a/Cargo.lock b/Cargo.lock
index f2f53f5498..2700c81635 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1201,10 +1201,12 @@ dependencies = [
  "shared",
  "sqlx",
  "strum",
+ "tempfile",
  "thiserror 1.0.69",
  "tikv-jemallocator",
  "tokio",
  "tokio-stream",
+ "toml",
  "tower 0.4.13",
  "tower-http 0.4.4",
  "tracing",
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index feddf27dbc..727cd5ef4b 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -63,14 +63,17 @@ tokio-stream = { workspace = true }
 tower = { workspace = true }
 tower-http = { workspace = true, features = ["trace"] }
 tracing = { workspace = true }
-url = { workspace = true }
+url = { workspace = true, features = ["serde"] }
 winner-selection = { workspace = true }
+toml = { workspace = true }
+tempfile = { workspace = true, optional = true }
 
 [dev-dependencies]
 maplit = { workspace = true }
 mockall = { workspace = true }
 tokio = { workspace = true, features = ["test-util"] }
 shared = { workspace = true, features = ["test-util"] }
+tempfile = { workspace = true }
 
 [build-dependencies]
 anyhow = { workspace = true }
@@ -82,3 +85,4 @@ workspace = true
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
 tokio-console = ["observe/tokio-console"]
+test-util = ["dep:tempfile"]
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 1b8c592e7e..55f27f5104 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -1,26 +1,23 @@
 use {
     crate::{database::INSERT_BATCH_SIZE_DEFAULT, infra},
-    alloy::primitives::{Address, U256},
-    anyhow::{Context, anyhow, ensure},
+    alloy::primitives::Address,
+    anyhow::Context,
     chrono::{DateTime, Utc},
     clap::ValueEnum,
     shared::{
-        arguments::{FeeFactor, display_list, display_option, display_secret_option},
+        arguments::{FeeFactor, display_option, display_secret_option},
         http_client,
         price_estimation::{self, NativePriceEstimators},
     },
-    std::{
-        fmt::{self, Display, Formatter},
-        net::SocketAddr,
-        num::NonZeroUsize,
-        str::FromStr,
-        time::Duration,
-    },
+    std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf, str::FromStr, time::Duration},
     url::Url,
 };
 
 #[derive(clap::Parser)]
-pub struct Arguments {
+pub struct CliArguments {
+    #[clap(long, env)]
+    pub config: PathBuf,
+
     #[clap(flatten)]
     pub shared: shared::arguments::Arguments,
 
@@ -139,11 +136,6 @@ pub struct Arguments {
     )]
     pub trusted_tokens_update_interval: Duration,
 
-    /// A list of drivers in the following format:
-    /// `<NAME>|<URL>|<SUBMISSION_ADDRESS>|<FAIRNESS_THRESHOLD>`
-    #[clap(long, env, use_value_delimiter = true)]
-    pub drivers: Vec<Solver>,
-
     /// The maximum number of blocks to wait for a settlement to appear on
     /// chain.
     #[clap(long, env, default_value = "5")]
@@ -272,9 +264,10 @@ pub struct Arguments {
     pub native_price_prefetch_time: Duration,
 }
 
-impl std::fmt::Display for Arguments {
+impl std::fmt::Display for CliArguments {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let Self {
+            config,
             shared,
             order_quoting,
             http_client,
@@ -295,7 +288,6 @@ impl std::fmt::Display for Arguments {
             trusted_tokens_url,
             trusted_tokens,
             trusted_tokens_update_interval,
-            drivers,
             submission_deadline,
             shadow,
             solve_deadline,
@@ -319,7 +311,7 @@ impl std::fmt::Display for Arguments {
             native_price_cache_refresh,
             native_price_prefetch_time,
         } = self;
-
+        write!(f, "{}", config.display())?;
         write!(f, "{shared}")?;
         write!(f, "{order_quoting}")?;
         write!(f, "{http_client}")?;
@@ -354,7 +346,6 @@ impl std::fmt::Display for Arguments {
             f,
             "trusted_tokens_update_interval: {trusted_tokens_update_interval:?}"
         )?;
-        display_list(f, "drivers", drivers.iter())?;
         writeln!(f, "submission_deadline: {submission_deadline}")?;
         display_option(f, "shadow", shadow)?;
         writeln!(f, "solve_deadline: {solve_deadline:?}")?;
@@ -404,75 +395,6 @@ impl std::fmt::Display for Arguments {
     }
 }
 
-/// External solver driver configuration
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Solver {
-    pub name: String,
-    pub url: Url,
-    pub submission_account: Account,
-    pub fairness_threshold: Option<U256>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Account {
-    /// AWS KMS is used to retrieve the solver public key
-    Kms(Arn),
-    /// Solver public key
-    Address(Address),
-}
-
-// Wrapper type for AWS ARN identifiers
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Arn(pub String);
-
-impl FromStr for Arn {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        // Could be more strict here, but this should suffice to catch unintended
-        // configuration mistakes
-        if s.starts_with("arn:aws:kms:") {
-            Ok(Self(s.to_string()))
-        } else {
-            Err(anyhow!("Invalid ARN identifier: {}", s))
-        }
-    }
-}
-
-impl Display for Solver {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}({})", self.name, self.url)
-    }
-}
-
-impl FromStr for Solver {
-    type Err = anyhow::Error;
-
-    fn from_str(solver: &str) -> anyhow::Result<Self> {
-        let parts: Vec<&str> = solver.split('|').collect();
-        ensure!(parts.len() >= 3, "not enough arguments for external solver");
-        let (name, url) = (parts[0], parts[1]);
-        let url: Url = url.parse()?;
-        let submission_account = match Arn::from_str(parts[2]) {
-            Ok(value) => Account::Kms(value),
-            _ => {
-                Account::Address(Address::from_str(parts[2]).context("failed to parse submission")?)
-            }
-        };
-
-        let fairness_threshold = parts
-            .get(3)
-            .and_then(|value| U256::from_str_radix(value, 10).ok());
-
-        Ok(Self {
-            name: name.to_owned(),
-            url,
-            fairness_threshold,
-            submission_account,
-        })
-    }
-}
-
 #[derive(clap::Parser, Debug, Clone)]
 pub struct FeePoliciesConfig {
     /// Describes how the protocol fees should be calculated.
@@ -665,7 +587,7 @@ impl FromStr for CowAmmConfig {
 
 #[cfg(test)]
 mod test {
-    use {super::*, alloy::primitives::address};
+    use super::*;
 
     #[test]
     fn test_fee_factor_limits() {
@@ -692,49 +614,4 @@ mod test {
             )
         }
     }
-
-    #[test]
-    fn parse_driver_submission_account_address() {
-        let argument = "name1|http://localhost:8080|0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
-        let driver = Solver::from_str(argument).unwrap();
-        let expected = Solver {
-            name: "name1".into(),
-            url: Url::parse("http://localhost:8080").unwrap(),
-            fairness_threshold: None,
-            submission_account: Account::Address(address!(
-                "C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-            )),
-        };
-        assert_eq!(driver, expected);
-    }
-
-    #[test]
-    fn parse_driver_submission_account_arn() {
-        let argument = "name1|http://localhost:8080|arn:aws:kms:supersecretstuff";
-        let driver = Solver::from_str(argument).unwrap();
-        let expected = Solver {
-            name: "name1".into(),
-            url: Url::parse("http://localhost:8080").unwrap(),
-            fairness_threshold: None,
-            submission_account: Account::Kms(
-                Arn::from_str("arn:aws:kms:supersecretstuff").unwrap(),
-            ),
-        };
-        assert_eq!(driver, expected);
-    }
-
-    #[test]
-    fn parse_driver_with_threshold() {
-        let argument = "name1|http://localhost:8080|0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2|1000000000000000000";
-        let driver = Solver::from_str(argument).unwrap();
-        let expected = Solver {
-            name: "name1".into(),
-            url: Url::parse("http://localhost:8080").unwrap(),
-            submission_account: Account::Address(address!(
-                "C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-            )),
-            fairness_threshold: Some(U256::from(10).pow(U256::from(18))),
-        };
-        assert_eq!(driver, expected);
-    }
 }
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
new file mode 100644
index 0000000000..68f348ffb5
--- /dev/null
+++ b/crates/autopilot/src/config/mod.rs
@@ -0,0 +1,60 @@
+use {
+    crate::config::solver::Solver,
+    anyhow::{anyhow, ensure},
+    serde::{Deserialize, Serialize},
+    std::path::Path,
+};
+
+pub mod solver;
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Configuration {
+    // #[serde(default)]
+    pub drivers: Vec<Solver>,
+}
+
+impl Configuration {
+    pub async fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
+        match toml::from_str(&tokio::fs::read_to_string(&path).await?) {
+            Ok(self_) => Ok(self_),
+            Err(err) if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") => Err(anyhow!(
+                "failed to parse TOML config at {}: {err:#?}",
+                path.as_ref().display()
+            )),
+            Err(_) => Err(anyhow!(
+                "failed to parse TOML config at: {}. Set TOML_TRACE_ERROR=1 to print parsing \
+                 error but this may leak secrets.",
+                path.as_ref().display()
+            )),
+        }
+    }
+
+    pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
+        Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
+    }
+
+    #[cfg(any(test, feature = "test-util"))]
+    pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
+        use std::io::Write;
+        let mut file = tempfile::NamedTempFile::new().expect("temp file creation should not fail");
+        file.write_all(
+            toml::to_string_pretty(self)
+                .expect("serialization should not fail")
+                .as_bytes(),
+        )
+        .expect("writing to temp file should not fail");
+        file
+    }
+
+    // Note for reviewers: if this and other validations are always applied,
+    // we should instead move them to the deserialization stage
+    // https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
+    pub fn validate(self) -> anyhow::Result<Self> {
+        ensure!(
+            !self.drivers.is_empty(),
+            "colocation is enabled but no drivers are configured"
+        );
+        Ok(self)
+    }
+}
diff --git a/crates/autopilot/src/config/solver.rs b/crates/autopilot/src/config/solver.rs
new file mode 100644
index 0000000000..c728f3e477
--- /dev/null
+++ b/crates/autopilot/src/config/solver.rs
@@ -0,0 +1,201 @@
+use {
+    alloy::primitives::Address,
+    core::fmt,
+    serde::{Deserialize, Deserializer, Serialize},
+    std::fmt::{Display, Formatter},
+    url::Url,
+};
+
+/// External solver driver configuration
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Solver {
+    pub name: String,
+    pub url: Url,
+    pub submission_account: Account,
+}
+
+impl Solver {
+    pub fn new(name: String, url: Url, account: Account) -> Self {
+        Self {
+            name,
+            url,
+            submission_account: account,
+        }
+    }
+}
+
+impl Display for Solver {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}({})", self.name, self.url)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Account {
+    /// AWS KMS is used to retrieve the solver public key
+    #[serde(deserialize_with = "deserialize_arn")]
+    Kms(Arn),
+    /// Solver public key
+    Address(Address),
+}
+
+// Wrapper type for AWS ARN identifiers
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
+pub struct Arn(pub String);
+
+fn deserialize_arn<'de, D>(deserializer: D) -> Result<Arn, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let raw_arn = String::deserialize(deserializer)?;
+    if raw_arn.starts_with("arn:aws:kms:") {
+        Ok(Arn(raw_arn))
+    } else {
+        Err(serde::de::Error::invalid_value(
+            serde::de::Unexpected::Str(raw_arn.as_str()),
+            &"expected value starting with \"arn:aws:kms\"",
+        ))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use {super::*, alloy::primitives::address};
+
+    #[test]
+    fn parse_driver_submission_account_address() {
+        let toml = r#"
+        name = "name1"
+        url = "http://localhost:8080"
+        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        "#;
+        let driver = toml::from_str::<Solver>(toml).unwrap();
+
+        let expected = Solver::new(
+            "name1".into(),
+            Url::parse("http://localhost:8080").unwrap(),
+            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
+        );
+        assert_eq!(driver, expected);
+    }
+
+    #[test]
+    fn parse_driver_submission_account_arn() {
+        let toml = r#"
+        name = "name1"
+        url = "http://localhost:8080"
+        submission-account.kms = "arn:aws:kms:supersecretstuff"
+        "#;
+        let driver = toml::from_str::<Solver>(toml).unwrap();
+
+        let expected = Solver::new(
+            "name1".into(),
+            Url::parse("http://localhost:8080").unwrap(),
+            Account::Kms(Arn("arn:aws:kms:supersecretstuff".into())),
+        );
+        assert_eq!(driver, expected);
+    }
+
+    #[test]
+    fn parse_driver_with_threshold() {
+        let toml = r#"
+        name = "name1"
+        url = "http://localhost:8080"
+        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        "#;
+        let driver = toml::from_str::<Solver>(toml).unwrap();
+
+        let expected = Solver::new(
+            "name1".into(),
+            Url::parse("http://localhost:8080").unwrap(),
+            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
+        );
+        assert_eq!(driver, expected);
+    }
+
+    #[test]
+    fn deserialize_valid_arn() {
+        let toml = r#"kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012""#;
+        let account = toml::from_str::<Account>(toml).unwrap();
+
+        let expected = Account::Kms(Arn("arn:aws:kms:us-east-1:123456789012:key/\
+                                         12345678-1234-1234-1234-123456789012"
+            .into()));
+        assert_eq!(account, expected);
+    }
+
+    #[test]
+    fn deserialize_invalid_arn_wrong_prefix() {
+        let toml = r#"kms = "arn:aws:s3:us-east-1:123456789012:bucket/mybucket""#;
+        let result = toml::from_str::<Account>(toml);
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("expected value starting with \"arn:aws:kms\""),
+            "Error message: {}",
+            err
+        );
+    }
+
+    #[test]
+    fn deserialize_invalid_arn_not_arn() {
+        let toml = r#"kms = "not-an-arn""#;
+        let result = toml::from_str::<Account>(toml);
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("expected value starting with \"arn:aws:kms\""),
+            "Error message: {}",
+            err
+        );
+    }
+
+    #[test]
+    fn parse_multiple_solvers() {
+        let toml = r#"
+        [[drivers]]
+        name = "solver1"
+        url = "http://localhost:8080"
+        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+
+        [[drivers]]
+        name = "solver2"
+        url = "http://localhost:8081"
+        # test the format used in the infra repo
+        [drivers.submission-account]
+        kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
+        "#;
+
+        #[derive(Deserialize)]
+        struct Config {
+            drivers: Vec<Solver>,
+        }
+
+        let config = toml::from_str::<Config>(toml).unwrap();
+
+        assert_eq!(config.drivers.len(), 2);
+
+        let expected_solver1 = Solver::new(
+            "solver1".into(),
+            Url::parse("http://localhost:8080").unwrap(),
+            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
+        );
+
+        let expected_solver2 = Solver::new(
+            "solver2".into(),
+            Url::parse("http://localhost:8081").unwrap(),
+            Account::Kms(Arn("arn:aws:kms:us-east-1:123456789012:key/\
+                              12345678-1234-1234-1234-123456789012"
+                .into())),
+        );
+
+        assert_eq!(config.drivers[0], expected_solver1);
+        assert_eq!(config.drivers[1], expected_solver2);
+    }
+}
diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 2a5b6f12dd..33f6346050 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -281,6 +281,7 @@ impl Ranking {
 mod tests {
     use {
         crate::{
+            config::solver::Account,
             domain::{
                 Auction,
                 Order,
@@ -1217,8 +1218,7 @@ mod tests {
         let driver = Driver::try_new(
             url::Url::parse("http://localhost").unwrap(),
             solver_address.to_string(),
-            None,
-            crate::arguments::Account::Address(solver_address),
+            Account::Address(solver_address),
         )
         .await
         .unwrap();
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index 38334631b8..a376bda7a9 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -1,6 +1,6 @@
 use {
     self::dto::{reveal, settle, solve},
-    crate::{arguments::Account, domain::eth, util},
+    crate::{config::solver::Account, domain::eth, util},
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
     observe::tracing::tracing_headers,
@@ -19,10 +19,6 @@ const RESPONSE_TIME_LIMIT: Duration = Duration::from_secs(60);
 pub struct Driver {
     pub name: String,
     pub url: Url,
-    // An optional threshold used to check "fairness" of provided solutions. If specified, a
-    // winning solution should be discarded if it contains at least one order, which
-    // another driver solved with surplus exceeding this driver's surplus by `threshold`
-    pub fairness_threshold: Option<eth::Ether>,
     pub submission_address: eth::Address,
     client: Client,
 }
@@ -40,7 +36,6 @@ impl Driver {
     pub async fn try_new(
         url: Url,
         name: String,
-        fairness_threshold: Option<eth::Ether>,
         submission_account: Account,
     ) -> Result<Self, Error> {
         let submission_address = match submission_account {
@@ -57,18 +52,11 @@ impl Driver {
             }
             Account::Address(address) => address,
         };
-        tracing::info!(
-            ?name,
-            ?url,
-            ?fairness_threshold,
-            ?submission_address,
-            "Creating solver"
-        );
+        tracing::info!(?name, ?url, ?submission_address, "Creating solver");
 
         Ok(Self {
             name,
             url,
-            fairness_threshold,
             client: Client::builder()
                 .timeout(RESPONSE_TIME_LIMIT)
                 .tcp_keepalive(Duration::from_secs(60))
diff --git a/crates/autopilot/src/lib.rs b/crates/autopilot/src/lib.rs
index a7742f2cb0..d4da505be8 100644
--- a/crates/autopilot/src/lib.rs
+++ b/crates/autopilot/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod arguments;
 pub mod boundary;
+pub mod config;
 pub mod database;
 pub mod domain;
 pub mod event_updater;
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 39b4224be5..abc6edc2ba 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -1,7 +1,8 @@
 use {
     crate::{
-        arguments::{Account, Arguments},
+        arguments::CliArguments,
         boundary,
+        config::{Configuration, solver::Account},
         database::{
             Postgres,
             ethflow_events::event_retriever::EthFlowRefundRetriever,
@@ -123,7 +124,14 @@ async fn ethereum(
 }
 
 pub async fn start(args: impl Iterator<Item = String>) {
-    let args = Arguments::parse_from(args);
+    let args = CliArguments::parse_from(args);
+
+    let config = Configuration::from_path(&args.config)
+        .await
+        .expect("failed to load configuration file")
+        .validate()
+        .expect("failed to validate configuration file");
+
     let obs_config = observe::Config::new(
         args.shared.logging.log_filter.as_str(),
         args.shared.logging.log_stderr_threshold,
@@ -141,19 +149,19 @@ pub async fn start(args: impl Iterator<Item = String>) {
 
     observe::metrics::setup_registry(Some("gp_v2_autopilot".into()), None);
 
-    if args.drivers.is_empty() {
-        panic!("colocation is enabled but no drivers are configured");
-    }
-
     if args.shadow.is_some() {
-        shadow_mode(args).await;
+        shadow_mode(args, config).await;
     } else {
-        run(args, ShutdownController::default()).await;
+        run(args, config, ShutdownController::default()).await;
     }
 }
 
 /// Assumes tracing and metrics registry have already been set up.
-pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
+pub async fn run(
+    args: CliArguments,
+    config: Configuration,
+    shutdown_controller: ShutdownController,
+) {
     assert!(args.shadow.is_none(), "cannot run in shadow mode");
     let db_write = Postgres::new(
         args.db_write_url.as_str(),
@@ -572,19 +580,14 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         enable_leader_lock: args.enable_leader_lock,
     };
 
-    let drivers_futures = args
+    let drivers_futures = config
         .drivers
         .into_iter()
         .map(|driver| async move {
-            infra::Driver::try_new(
-                driver.url,
-                driver.name.clone(),
-                driver.fairness_threshold.map(Into::into),
-                driver.submission_account,
-            )
-            .await
-            .map(Arc::new)
-            .expect("failed to load solver configuration")
+            infra::Driver::try_new(driver.url, driver.name.clone(), driver.submission_account)
+                .await
+                .map(Arc::new)
+                .expect("failed to load solver configuration")
         })
         .collect::<Vec<_>>();
 
@@ -616,7 +619,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
     api_task.await.ok();
 }
 
-async fn shadow_mode(args: Arguments) -> ! {
+async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
     let http_factory = HttpClientFactory::new(&args.http_client);
 
     let orderbook = infra::shadow::Orderbook::new(
@@ -624,14 +627,13 @@ async fn shadow_mode(args: Arguments) -> ! {
         args.shadow.expect("missing shadow mode configuration"),
     );
 
-    let drivers_futures = args
+    let drivers_futures = config
         .drivers
         .into_iter()
         .map(|driver| async move {
             infra::Driver::try_new(
                 driver.url,
                 driver.name.clone(),
-                driver.fairness_threshold.map(Into::into),
                 // HACK: the auction logic expects all drivers
                 // to use a different submission address. But
                 // in the shadow environment all drivers use
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 5507ec5045..df12e6e6a7 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -13,7 +13,7 @@ alloy = { workspace = true, default-features = false, features = ["json-rpc", "p
 alloy-signer = {workspace = true, default-features = false, features = ["eip712"]}
 anyhow = { workspace = true }
 app-data = { workspace = true }
-autopilot = { workspace = true }
+autopilot = { workspace = true, features = ["test-util"] }
 axum = { workspace = true }
 bigdecimal = { workspace = true }
 chrono = { workspace = true }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 49ee87202c..25f6958fa1 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -15,7 +15,13 @@ use {
         providers::ext::AnvilApi,
     },
     app_data::{AppDataDocument, AppDataHash},
-    autopilot::infra::persistence::dto,
+    autopilot::{
+        config::{
+            Configuration,
+            solver::{Account, Solver},
+        },
+        infra::persistence::dto,
+    },
     clap::Parser,
     model::{
         AuctionId,
@@ -216,8 +222,13 @@ impl<'a> Services<'a> {
         .collect();
         let args = ignore_overwritten_cli_params(args);
 
-        let args = autopilot::arguments::Arguments::try_parse_from(args).unwrap();
-        let join_handle = tokio::task::spawn(autopilot::run(args, control));
+        let args = autopilot::arguments::CliArguments::try_parse_from(args)
+            .map_err(|err| err.to_string())
+            .unwrap();
+        let config = autopilot::config::Configuration::from_path(&args.config)
+            .await
+            .unwrap();
+        let join_handle = tokio::task::spawn(autopilot::run(args, config, control));
         self.wait_until_autopilot_ready().await;
 
         join_handle
@@ -298,14 +309,23 @@ impl<'a> Services<'a> {
             colocation::LiquidityProvider::UniswapV2,
             false,
         );
+
+        let config_file = Configuration {
+            // replace the --drivers argument with a vec of Solver structs
+            drivers: vec![Solver::new(
+                "test_solver".to_string(),
+                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                Account::Address(solver.address()),
+            )],
+        }
+        .to_temp_path();
+
         self.start_autopilot(
             None,
             [
                 vec![
-                    format!(
-                        "--drivers=test_solver|http://localhost:11088/test_solver|{}|requested-timeout-on-problems",
-                        const_hex::encode(solver.address())
-                    ),
+                    // The config gets parsed as an extra argument, it will read the correct path
+                    format!("--config={}", config_file.path().display()),
                     "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                         .to_string(),
                     "--gas-estimators=http://localhost:11088/gasprice".to_string(),
@@ -349,6 +369,16 @@ impl<'a> Services<'a> {
             haircut_bps: 0,
         }];
 
+        // Create TOML config file for the driver
+        let config_file = Configuration {
+            drivers: vec![Solver::new(
+                "test_solver".to_string(),
+                Url::parse("http://localhost:11088/test_solver").unwrap(),
+                Account::Address(solver.address()),
+            )],
+        }
+        .to_temp_path();
+
         let (autopilot_args, api_args) = if run_baseline {
             solvers.push(
                 colocation::start_baseline_solver(
@@ -365,7 +395,7 @@ impl<'a> Services<'a> {
             // Here we call the baseline_solver "test_quoter" to make the native price
             // estimation use the baseline_solver instead of the test_quoter
             let autopilot_args = vec![
-                format!("--drivers=test_solver|http://localhost:11088/test_solver|{}", const_hex::encode(solver.address())),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
                 "--native-price-estimators=Driver|test_quoter|http://localhost:11088/baseline_solver,Driver|test_solver|http://localhost:11088/test_solver".to_string(),
             ];
@@ -375,10 +405,7 @@ impl<'a> Services<'a> {
             (autopilot_args, api_args)
         } else {
             let autopilot_args = vec![
-                format!(
-                    "--drivers=test_solver|http://localhost:11088/test_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 02f47a2c6d..bbcbf689e0 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -1,5 +1,11 @@
 use {
-    autopilot::shutdown_controller::ShutdownController,
+    autopilot::{
+        config::{
+            Configuration,
+            solver::{Account, Solver},
+        },
+        shutdown_controller::ShutdownController,
+    },
     e2e::setup::{
         OnchainComponents,
         Services,
@@ -12,6 +18,8 @@ use {
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::order::{OrderCreation, OrderKind},
     number::units::EthUnit,
+    std::str::FromStr,
+    url::Url,
 };
 
 #[tokio::test]
@@ -86,26 +94,55 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
     );
 
     // Configure autopilot-leader only with test_solver
-    let autopilot_leader = services.start_autopilot_with_shutdown_controller(None, vec![
-        format!("--drivers=test_solver|http://localhost:11088/test_solver|{}|requested-timeout-on-problems",
-            const_hex::encode(solver1.address())),
-        "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-        "--metrics-address=0.0.0.0:9590".to_string(),
-        "--api-address=0.0.0.0:12088".to_string(),
-        "--enable-leader-lock=true".to_string(),
-    ], control).await;
+    let config_file_leader = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+            Account::Address(solver1.address()),
+        )],
+    }
+    .to_temp_path();
+
+    let autopilot_leader = services
+        .start_autopilot_with_shutdown_controller(
+            None,
+            vec![
+                format!("--config={}", config_file_leader.path().display()),
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+                "--metrics-address=0.0.0.0:9590".to_string(),
+                "--api-address=0.0.0.0:12088".to_string(),
+                "--enable-leader-lock=true".to_string(),
+            ],
+            control,
+        )
+        .await;
 
     // Configure autopilot-backup only with test_solver2
-    let _autopilot_follower = services.start_autopilot(None, vec![
-        format!("--drivers=test_solver2|http://localhost:11088/test_solver2|{}|requested-timeout-on-problems",
-            const_hex::encode(solver2.address())),
-        "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2".to_string(),
-        "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-        "--metrics-address=0.0.0.0:9591".to_string(),
-        "--api-address=0.0.0.0:12089".to_string(),
-        "--enable-leader-lock=true".to_string(),
-    ]).await;
+    let config_file_follower = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver2".to_string(),
+            Url::from_str("http://localhost:11088/test_solver2").unwrap(),
+            Account::Address(solver2.address()),
+        )],
+    }
+    .to_temp_path();
+
+    let _autopilot_follower = services
+        .start_autopilot(
+            None,
+            vec![
+                format!("--config={}", config_file_follower.path().display()),
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+                "--metrics-address=0.0.0.0:9591".to_string(),
+                "--api-address=0.0.0.0:12089".to_string(),
+                "--enable-leader-lock=true".to_string(),
+            ],
+        )
+        .await;
 
     services
         .start_api(vec![
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index e22e401ca7..66045b5d2b 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,5 +1,9 @@
 use {
     ::alloy::primitives::U256,
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -8,6 +12,8 @@ use {
     },
     number::units::EthUnit,
     shared::web3::Web3,
+    std::str::FromStr,
+    url::Url,
 };
 
 #[tokio::test]
@@ -60,6 +66,15 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
         false,
     );
     let services = Services::new(&onchain).await;
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
@@ -70,10 +85,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
                     token_a = token_a.address(),
                     token_b = token_b.address()
                 ),
-                format!(
-                    "--drivers=test_solver|http://localhost:11088/test_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 7faa156388..77987a81bf 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -6,6 +6,10 @@ use {
             ext::{AnvilApi, ImpersonateConfig},
         },
     },
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     contracts::alloy::{
         ERC20,
         support::{Balances, Signatures},
@@ -38,7 +42,11 @@ use {
         SigningScheme,
         Solution,
     },
-    std::collections::{HashMap, HashSet},
+    std::{
+        collections::{HashMap, HashSet},
+        str::FromStr,
+    },
+    url::Url,
 };
 
 #[tokio::test]
@@ -179,14 +187,21 @@ async fn cow_amm_jit(web3: Web3) {
         false,
     );
     let services = Services::new(&onchain).await;
+
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "mock_solver".to_string(),
+            Url::from_str("http://localhost:11088/mock_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--drivers=mock_solver|http://localhost:11088/mock_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
@@ -551,11 +566,27 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
     );
     let services = Services::new(&onchain).await;
 
+    let config_file = Configuration {
+        drivers: vec![
+            Solver::new(
+                "test_solver".to_string(),
+                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                Account::Address(solver.address()),
+            ),
+            Solver::new(
+                "mock_solver".to_string(),
+                Url::from_str("http://localhost:11088/mock_solver").unwrap(),
+                Account::Address(solver.address()),
+            ),
+        ],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!("--drivers=test_solver|http://localhost:11088/test_solver|{},mock_solver|http://localhost:11088/mock_solver|{}", const_hex::encode(solver.address()), const_hex::encode(solver.address())),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
                 // it uses an older helper contract that was deployed before the desired cow amm
@@ -812,14 +843,21 @@ async fn cow_amm_opposite_direction(web3: Web3) {
         true,
     );
     let services = Services::new(&onchain).await;
+
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "mock_solver".to_string(),
+            Url::from_str("http://localhost:11088/mock_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--drivers=mock_solver|http://localhost:11088/mock_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index b93218458a..146bb701b5 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -1,5 +1,9 @@
 use {
     ::alloy::primitives::U256,
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     e2e::setup::{colocation::SolverEngine, mock::Mock, solution::JitOrder, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -9,7 +13,8 @@ use {
     number::units::EthUnit,
     shared::web3::Web3,
     solvers_dto::solution::{Asset, Solution},
-    std::collections::HashMap,
+    std::{collections::HashMap, str::FromStr},
+    url::Url,
 };
 
 #[tokio::test]
@@ -87,14 +92,21 @@ async fn single_limit_order_test(web3: Web3) {
 
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
+
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "mock_solver".to_string(),
+            Url::from_str("http://localhost:11088/mock_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--drivers=mock_solver|http://localhost:11088/mock_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 9777bb14b3..f847366195 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -4,6 +4,10 @@ use {
         primitives::{Address, U256, address},
         providers::ext::{AnvilApi, ImpersonateConfig},
     },
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     bigdecimal::BigDecimal,
     contracts::alloy::ERC20,
     database::byte_array::ByteArray,
@@ -18,7 +22,8 @@ use {
     },
     number::{conversions::big_decimal_to_big_uint, units::EthUnit},
     shared::web3::Web3,
-    std::{collections::HashMap, ops::DerefMut},
+    std::{collections::HashMap, ops::DerefMut, str::FromStr},
+    url::Url,
 };
 
 #[tokio::test]
@@ -482,15 +487,33 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
     let uid_b = services.create_order(&order_b).await.unwrap();
 
     // Start autopilot only once all the orders are created.
-    services.start_autopilot(
-        None,
-        vec![
-            format!("--drivers=solver1|http://localhost:11088/test_solver|{}|10000000000000000,solver2|http://localhost:11088/solver2|{}",
-            const_hex::encode(solver_a.address()), const_hex::encode(solver_b.address())),
-            "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-            "--max-winners-per-auction=2".to_string(),
+
+    let config_file = Configuration {
+        drivers: vec![
+            Solver::new(
+                "solver1".to_string(),
+                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                Account::Address(solver_a.address()),
+            ),
+            Solver::new(
+                "solver2".to_string(),
+                Url::from_str("http://localhost:11088/solver2").unwrap(),
+                Account::Address(solver_b.address()),
+            ),
         ],
-    ).await;
+    }
+    .to_temp_path();
+
+    services
+        .start_autopilot(
+            None,
+            vec![
+                format!("--config={}", config_file.path().display()),
+                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
+                "--max-winners-per-auction=2".to_string(),
+            ],
+        )
+        .await;
 
     // Wait for trade
     let indexed_trades = || async {
@@ -651,14 +674,21 @@ async fn too_many_limit_orders_test(web3: Web3) {
         colocation::LiquidityProvider::UniswapV2,
         false,
     );
+
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+            Account::Address(solver_address),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--drivers=test_solver|http://localhost:11088/test_solver|{}",
-                    const_hex::encode(solver_address)
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
@@ -747,14 +777,21 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
         colocation::LiquidityProvider::UniswapV2,
         false,
     );
+
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+            Account::Address(solver_address),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--drivers=test_solver|http://localhost:11088/test_solver|{}",
-                    const_hex::encode(solver_address)
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 5e13e3baf2..c7717377e4 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -6,6 +6,10 @@ use {
             ext::{AnvilApi, ImpersonateConfig},
         },
     },
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     chrono::{NaiveDateTime, Utc},
     contracts::alloy::{ERC20, IZeroex},
     e2e::{
@@ -27,6 +31,8 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
+    std::str::FromStr,
+    url::Url,
 };
 
 /// The block number from which we will fetch state for the forked tests.
@@ -189,16 +195,22 @@ async fn zero_ex_liquidity(web3: Web3) {
         },
         false,
     );
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                format!(
-                    "--drivers=test_solver|http://localhost:11088/test_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
             ],
         )
         .await;
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index 8a2cb42b1f..5e1e465904 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -4,6 +4,10 @@ use {
         providers::ext::{AnvilApi, ImpersonateConfig},
         signers::SignerSync,
     },
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     chrono::Utc,
     contracts::alloy::{ERC20, LiquoriceSettlement},
     driver::infra,
@@ -26,7 +30,8 @@ use {
     },
     number::units::EthUnit,
     solvers_dto::solution::Solution,
-    std::collections::HashMap,
+    std::{collections::HashMap, str::FromStr},
+    url::Url,
 };
 
 /// The block number from which we will fetch state for the forked tests.
@@ -199,16 +204,22 @@ http-timeout = "10s"
             liquorice_api.port
         )),
     );
+    let config_file = Configuration {
+        drivers: vec![Solver::new(
+            "liquorice_solver".to_string(),
+            Url::from_str("http://localhost:11088/liquorice_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                format!(
-                    "--drivers=liquorice_solver|http://localhost:11088/liquorice_solver|{}",
-                    const_hex::encode(solver.address())
-                ),
+                format!("--config={}", config_file.path().display()),
             ],
         )
         .await;
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index a2dd9a5cdf..583ff81eed 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -1,5 +1,6 @@
 use {
     ::alloy::primitives::U256,
+    autopilot::config::Configuration,
     database::order_events::OrderEventLabel,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
@@ -65,10 +66,12 @@ async fn order_cancellation(web3: Web3) {
         colocation::LiquidityProvider::UniswapV2,
         false,
     );
+    let config_file = Configuration::default().to_temp_path();
     services
         .start_autopilot(
             None,
             vec![
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 1b03cea819..0eb4951290 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -1,5 +1,9 @@
 use {
-    ::alloy::primitives::U256,
+    ::alloy::primitives::{U256, address},
+    autopilot::config::{
+        Configuration,
+        solver::{Account, Solver},
+    },
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -9,7 +13,8 @@ use {
     number::units::EthUnit,
     shared::web3::Web3,
     solvers_dto::solution::Solution,
-    std::collections::HashMap,
+    std::{collections::HashMap, str::FromStr},
+    url::Url,
 };
 
 #[tokio::test]
@@ -80,11 +85,27 @@ async fn solver_competition(web3: Web3) {
     );
 
     let services = Services::new(&onchain).await;
+
+    let config_file = Configuration {
+        drivers: vec![
+            Solver::new(
+                "test_solver".to_string(),
+                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                Account::Address(solver.address()),
+            ),
+            Solver::new(
+                "solver2".to_string(),
+                Url::from_str("http://localhost:11088/solver2").unwrap(),
+                Account::Address(solver.address()),
+            ),
+        ],
+    }
+    .to_temp_path();
+
     services.start_autopilot(
         None,
         vec![
-            format!("--drivers=test_solver|http://localhost:11088/test_solver|{},solver2|http://localhost:11088/solver2|{}", const_hex::encode(solver.address()), const_hex::encode(solver.address())
-            ),
+            format!("--config={}", config_file.path().display()),
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
         ],
     ).await;
@@ -220,14 +241,34 @@ async fn wrong_solution_submission_address(web3: Web3) {
     );
 
     let services = Services::new(&onchain).await;
-    services.start_autopilot(
-        None,
-        // Solver 1 has a wrong submission address, meaning that the solutions should be discarded from solver1
-        vec![
-            format!("--drivers=solver1|http://localhost:11088/test_solver|0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2,solver2|http://localhost:11088/solver2|{}", const_hex::encode(solver.address())),
-            "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
+
+    // Solver 1 has a wrong submission address, meaning that the solutions should be
+    // discarded from solver1
+    let config_file = Configuration {
+        drivers: vec![
+            Solver::new(
+                "solver1".to_string(),
+                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
+            ),
+            Solver::new(
+                "solver2".to_string(),
+                Url::from_str("http://localhost:11088/solver2").unwrap(),
+                Account::Address(solver.address()),
+            ),
         ],
-    ).await;
+    }
+    .to_temp_path();
+
+    services
+        .start_autopilot(
+            None,
+            vec![
+                format!("--config={}", config_file.path().display()),
+                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
+            ],
+        )
+        .await;
     services
         .start_api(vec![
             "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
@@ -366,15 +407,28 @@ async fn store_filtered_solutions(web3: Web3) {
 
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
+
+    let config_file = Configuration {
+        drivers: vec![
+            Solver::new(
+                "good_solver".to_string(),
+                Url::from_str("http://localhost:11088/good_solver").unwrap(),
+                Account::Address(good_solver_account.address()),
+            ),
+            Solver::new(
+                "bad_solver".to_string(),
+                Url::from_str("http://localhost:11088/bad_solver").unwrap(),
+                Account::Address(bad_solver_account.address()),
+            ),
+        ],
+    }
+    .to_temp_path();
+
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--drivers=good_solver|http://localhost:11088/good_solver|{},bad_solver|http://localhost:11088/bad_solver|{}",
-                    const_hex::encode(good_solver_account.address()),
-                    const_hex::encode(bad_solver_account.address()),
-                ),
+                format!("--config={}", config_file.path().display()),
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
                 "--max-winners-per-auction=10".to_string(),

From 52f7d7f6621c550955106829123a359bf24cdeef Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 17 Feb 2026 11:37:51 +0100
Subject: [PATCH 068/219] autopilot: send `/solve` requests with ref-counted
 body (#4159)

# Description
Currently the way the autopilot serializes `/solve` requests is still
sub optimal. While it does indeed only serialize the `/solve` requests
once it still allocates memory for every HTTP request it ultimately
sends.
Since `reqwest` also supports `Bytes` as the request body which are
already references counted we can save a bunch of allocating and copying
data by serializing the auction data into a `Bytes` instance and cloning
that into the individual `/solve` HTTP requests.

# Changes
- changes internal members of `solve::Request` from
`serde_json::RawValue` to `Bytes`
- adds a new `X-Auction-Id` header which is important for another
optimization but that has to be merged before said optimization
- moved original serialization from the executor thread to a background
task that's intended for blocking operations since serialization takes
quite a bit of time

## How to test
existing e2e tests
---
 Cargo.lock                                    | 15 +++++
 Cargo.toml                                    |  1 +
 crates/autopilot/Cargo.toml                   |  3 +-
 .../autopilot/src/infra/solvers/dto/solve.rs  | 57 ++++++++++++++-----
 crates/autopilot/src/infra/solvers/mod.rs     | 45 +++++++++------
 crates/autopilot/src/run_loop.rs              |  3 +-
 crates/autopilot/src/shadow.rs                |  3 +-
 7 files changed, 95 insertions(+), 32 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2700c81635..7e6e51088b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1164,6 +1164,7 @@ dependencies = [
  "async-trait",
  "axum",
  "bigdecimal",
+ "bytes",
  "bytes-hex",
  "chain",
  "chrono",
@@ -5462,6 +5463,7 @@ dependencies = [
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
+ "wasm-streams",
  "web-sys",
  "winreg",
 ]
@@ -7616,6 +7618,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "wasmtimer"
 version = "0.4.3"
diff --git a/Cargo.toml b/Cargo.toml
index 61baa62db7..84bcbc9b5a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,6 +60,7 @@ autopilot = { path = "crates/autopilot" }
 aws-config = "1.5.1"
 aws-sdk-s3 = { version = "1.34.0", default-features = false }
 bytes-hex = { path = "crates/bytes-hex" }
+bytes = "1.11.1"
 chain = { path = "crates/chain" }
 console-subscriber = "0.3.0"
 const_format = "0.2.32"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 727cd5ef4b..97750f6d16 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -19,6 +19,7 @@ alloy = { workspace = true, features = ["rand", "provider-debug-api", "provider-
 app-data = { workspace = true }
 axum = { workspace = true }
 bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
+bytes = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 bigdecimal = { workspace = true }
@@ -47,7 +48,7 @@ order-validation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
-reqwest = { workspace = true, features = ["gzip", "json"] }
+reqwest = { workspace = true, features = ["gzip", "json", "stream"] }
 rust_decimal = { workspace = true }
 s3 = { workspace = true }
 serde = { workspace = true }
diff --git a/crates/autopilot/src/infra/solvers/dto/solve.rs b/crates/autopilot/src/infra/solvers/dto/solve.rs
index a66b065fa8..ed6aeb9d9f 100644
--- a/crates/autopilot/src/infra/solvers/dto/solve.rs
+++ b/crates/autopilot/src/infra/solvers/dto/solve.rs
@@ -2,17 +2,22 @@ use {
     crate::{
         boundary,
         domain::{self, eth},
-        infra::persistence::dto::{self, order::Order},
+        infra::{
+            persistence::dto::{self, order::Order},
+            solvers::InjectIntoHttpRequest,
+        },
     },
     alloy::primitives::{Address, U256},
+    bytes::Bytes,
     chrono::{DateTime, Utc},
     itertools::Itertools,
     number::serialization::HexOrDecimalU256,
+    reqwest::RequestBuilder,
     serde::{Deserialize, Serialize},
     serde_with::{DisplayFromStr, serde_as},
     std::{
+        borrow::Cow,
         collections::{HashMap, HashSet},
-        sync::Arc,
         time::Duration,
     },
 };
@@ -21,17 +26,14 @@ use {
 /// request. The purpose of this is to make it ergonomic
 /// to serialize a request once and reuse the resulting
 /// string in multiple HTTP requests.
-#[derive(Clone, Debug, Serialize, derive_more::Display)]
-pub struct Request(Arc<serde_json::value::RawValue>);
-
-impl Request {
-    pub fn as_str(&self) -> &str {
-        self.0.get()
-    }
+#[derive(Clone, Debug)]
+pub struct Request {
+    auction_id: i64,
+    body: bytes::Bytes,
 }
 
 impl Request {
-    pub fn new(
+    pub async fn new(
         auction: &domain::Auction,
         trusted_tokens: &HashSet<Address>,
         time_limit: Duration,
@@ -64,9 +66,38 @@ impl Request {
             deadline: Utc::now() + chrono::Duration::from_std(time_limit).unwrap(),
             surplus_capturing_jit_order_owners: auction.surplus_capturing_jit_order_owners.to_vec(),
         };
-        Self(Arc::from(serde_json::value::to_raw_value(&helper).expect(
-            "only fails with non-string keys which we do not have",
-        )))
+        let auction_id = auction.id;
+
+        let body = tokio::task::spawn_blocking(move || {
+            let serialized = serde_json::to_vec(&helper).expect("type should be JSON serializable");
+            Bytes::from(serialized)
+        })
+        .await
+        .expect("inner task should not panic as serialization should work for the given type");
+
+        Self { body, auction_id }
+    }
+}
+
+impl InjectIntoHttpRequest for Request {
+    fn inject(&self, request: RequestBuilder) -> RequestBuilder {
+        request
+            .body(self.body.clone())
+            // announce which auction this request is for in the
+            // headers to help the driver detect duplicated
+            // `/solve` requests before streaming the body
+            .header("X-Auction-Id", self.auction_id)
+            // manually set the content type header for JSON since
+            // we can't use `request.json(self)`
+            .header(
+                hyper::header::CONTENT_TYPE,
+                hyper::header::HeaderValue::from_static("application/json")
+            )
+    }
+
+    fn body_to_string(&self) -> Cow<'_, str> {
+        let string = str::from_utf8(self.body.as_ref()).unwrap();
+        Cow::Borrowed(string)
     }
 }
 
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index a376bda7a9..c65155341f 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -4,8 +4,8 @@ use {
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
     observe::tracing::tracing_headers,
-    reqwest::{Client, StatusCode},
-    std::time::Duration,
+    reqwest::{Client, RequestBuilder, StatusCode},
+    std::{borrow::Cow, time::Duration},
     thiserror::Error,
     tracing::instrument,
     url::Url,
@@ -110,28 +110,22 @@ impl Driver {
     async fn request_response<Response, Request>(
         &self,
         path: &str,
-        request: Request,
+        payload: Request,
     ) -> Result<Response>
     where
         Response: serde::de::DeserializeOwned,
-        Request: serde::Serialize + Send + Sync + 'static,
+        Request: InjectIntoHttpRequest,
     {
         let url = util::join(&self.url, path);
+
         tracing::trace!(
-            path=&url.path(),
-            body=%serde_json::to_string_pretty(&request).unwrap(),
+            path = &url.path(),
+            body = %payload.body_to_string(),
             "solver request",
         );
-        let mut request = {
-            let builder = self.client.post(url.clone()).headers(tracing_headers());
-            // If the payload is very big then serializing it will block the
-            // executor a long time (mostly relevant for solve requests).
-            // That's why we always do it on a thread specifically for
-            // running blocking tasks.
-            tokio::task::spawn_blocking(move || builder.json(&request))
-                .await
-                .context("failed to build request")?
-        };
+
+        let request = self.client.post(url.clone()).headers(tracing_headers());
+        let mut request = payload.inject(request);
 
         if let Some(request_id) = observe::distributed_tracing::request_id::from_current_span() {
             request = request.header("X-REQUEST-ID", request_id);
@@ -169,3 +163,22 @@ pub async fn response_body_with_size_limit(
     }
     Ok(bytes)
 }
+
+trait InjectIntoHttpRequest {
+    fn inject(&self, request: RequestBuilder) -> RequestBuilder;
+    fn body_to_string(&self) -> Cow<'_, str>;
+}
+
+impl<T> InjectIntoHttpRequest for T
+where
+    T: serde::ser::Serialize + Sized,
+{
+    fn inject(&self, request: RequestBuilder) -> RequestBuilder {
+        request.json(&self)
+    }
+
+    fn body_to_string(&self) -> Cow<'_, str> {
+        let serialized = serde_json::to_string(&self).expect("type should be JSON serializable");
+        Cow::Owned(serialized)
+    }
+}
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 7e36d04e68..1b037f3ed3 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -561,7 +561,8 @@ impl RunLoop {
             auction,
             &self.trusted_tokens.all(),
             self.config.solve_deadline,
-        );
+        )
+        .await;
 
         let mut bids = futures::future::join_all(
             self.drivers
diff --git a/crates/autopilot/src/shadow.rs b/crates/autopilot/src/shadow.rs
index 5c28857a7f..02e5de879f 100644
--- a/crates/autopilot/src/shadow.rs
+++ b/crates/autopilot/src/shadow.rs
@@ -179,7 +179,8 @@ impl RunLoop {
     /// Runs the solver competition, making all configured drivers participate.
     #[instrument(skip_all)]
     async fn competition(&self, auction: &domain::Auction) -> Vec<Bid<Unscored>> {
-        let request = solve::Request::new(auction, &self.trusted_tokens.all(), self.solve_deadline);
+        let request =
+            solve::Request::new(auction, &self.trusted_tokens.all(), self.solve_deadline).await;
 
         futures::future::join_all(
             self.drivers

From 8f3b76cc6ec460b30d79e5923f4295256873ae32 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 17 Feb 2026 12:05:02 +0100
Subject: [PATCH 069/219] Only stream 1 `/solve` request body in driver (#4160)

# Description
Because the driver serves multiple solvers it receives a bunch of
duplicated `/solve` requests. There is already logic to deduplicate the
pre-processing but we there is still one part left that's done
unnecessarily often: streaming the HTTP body.
Streaming the http body currently takes up to 700ms which is
surprisingly slow considering that the HTTP request goes from one k8s
pod to another and not via the public internet.
I suspect the problem is that we are actually streaming ~10MB `/solve`
requests 23 times in parallel (numbers from mainnet).
https://github.com/cowprotocol/services/pull/4159 introduced a new
header (`X-Auction-Id`) that can be used to detect which auction a
request is related to without having to stream the entire body.

With this change everything but prioritizing (i.e. sorting and
allocating balances for orders) and the serialization of the driver's
`/solve` request will be de-duplicated. That means adding more solvers
to the driver will be less costly.
If we consider enforcing the same prioritization logic for ALL solvers
that could also be de-duplicated leading to more or less 0 overhead for
adding more solvers to the same driver.


# Changes
- inspect `X-Auction-Id` header to figure out whether we have to process
the request or just await an existing pre-processing task

Note that this change must be released AFTER
https://github.com/cowprotocol/services/pull/4159`. The reason is that
k8s first rolls out `driver` pods so there would be a period where the
old `autopilot` is still sending requests without the `X-Auction-Id`
header.

## How to test
e2e tests

---------

Co-authored-by: ilya <ilya@cow.fi>
---
 crates/driver/src/domain/competition/mod.rs   |  7 +-
 .../src/domain/competition/pre_processing.rs  | 70 ++++++++++++++-----
 .../driver/src/infra/api/routes/solve/mod.rs  | 57 ++-------------
 crates/driver/src/tests/setup/mod.rs          |  1 +
 4 files changed, 60 insertions(+), 75 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index afe65a25d3..f2761bbf32 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -22,8 +22,9 @@ use {
         util::math,
     },
     alloy::primitives::Bytes,
+    axum::body::Body,
     futures::{StreamExt, future::Either, stream::FuturesUnordered},
-    hyper::body::Bytes as RequestBytes,
+    hyper::Request,
     itertools::Itertools,
     std::{
         cmp::Reverse,
@@ -114,14 +115,14 @@ impl Competition {
     }
 
     /// Solve an auction as part of this competition.
-    pub async fn solve(&self, auction: RequestBytes) -> Result<Option<Solved>, Error> {
+    pub async fn solve(&self, request: Request<Body>) -> Result<Option<Solved>, Error> {
         let start = Instant::now();
         let timer = ::observe::metrics::metrics()
             .on_auction_overhead_start("driver", "pre_processing_total");
 
         let tasks = self
             .fetcher
-            .start_or_get_tasks_for_auction(auction)
+            .start_or_get_tasks_for_auction(request)
             .await
             .map_err(|err| {
                 tracing::error!(?err, "pre-processing auction failed");
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index ce18e013ee..ccd17ad8cc 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -11,9 +11,10 @@ use {
     },
     alloy::primitives::{Bytes, FixedBytes},
     anyhow::{Context, Result},
+    axum::body::Body,
     chrono::Utc,
     futures::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered},
-    hyper::body::Bytes as RequestBytes,
+    hyper::{Request, body::Bytes as RequestBytes},
     itertools::Itertools,
     model::{
         interaction::InteractionData,
@@ -25,9 +26,14 @@ use {
         price_estimation::trade_verifier::balance_overrides::BalanceOverrideRequest,
         signature_validator::SignatureValidating,
     },
-    std::{collections::HashMap, future::Future, sync::Arc, time::Duration},
+    std::{
+        collections::HashMap,
+        future::Future,
+        sync::Arc,
+        time::{Duration, Instant},
+    },
     tokio::sync::Mutex,
-    tracing::Instrument,
+    tracing::{Instrument, instrument},
 };
 
 type Shared<T> = futures::future::Shared<BoxFuture<'static, T>>;
@@ -74,7 +80,7 @@ impl std::fmt::Debug for Utilities {
 #[derive(Debug)]
 struct ControlBlock {
     /// Auction for which the data aggregation task was spawned.
-    solve_request: RequestBytes,
+    auction_id: i64,
     /// Data aggregation task.
     tasks: DataFetchingTasks,
 }
@@ -91,26 +97,34 @@ impl DataAggregator {
     /// only once for all connected solvers to share.
     pub async fn start_or_get_tasks_for_auction(
         &self,
-        request: RequestBytes,
+        request: Request<Body>,
     ) -> Result<DataFetchingTasks> {
         let mut lock = self.control.lock().await;
-        let current_auction = &lock.solve_request;
-
-        // The autopilot ensures that all drivers receive identical
-        // requests per auction. That means we can use the significantly
-        // cheaper string comparison instead of parsing the JSON to compare
-        // the auction ids.
-        if request == current_auction {
-            let id = lock.tasks.auction.clone().await.id;
-            init_auction_id_in_span(id.map(|i| i.0));
+        let current_auction = &lock.auction_id;
+
+        // Figure out for which auction this `/solve` request was issued
+        // by looking at the `X-Auction-Id` header.
+        let request_auction_id: i64 = request
+            .headers()
+            .get("X-Auction-Id")
+            .context("request has no X-Auction-Id header")?
+            .to_str()
+            .context("X-Auction-Id header is not ASCII")?
+            .parse()
+            .context("could not parse X-Auction-Id header as i64")?;
+
+        // Some other driver is already doing the pre-processing for this
+        // auction. Stop processing here and just await the existing task.
+        if request_auction_id == *current_auction {
+            init_auction_id_in_span(Some(request_auction_id));
             tracing::debug!("await running data aggregation task");
             return Ok(lock.tasks.clone());
         }
 
-        let tasks = self.assemble_tasks(request.clone()).await?;
+        let tasks = self.assemble_tasks(request).await?;
 
         tracing::debug!("started new data aggregation task");
-        lock.solve_request = request;
+        lock.auction_id = request_auction_id;
         lock.tasks = tasks.clone();
 
         Ok(tasks)
@@ -153,7 +167,7 @@ impl DataAggregator {
                 cow_amm_cache,
             }),
             control: Mutex::new(ControlBlock {
-                solve_request: Default::default(),
+                auction_id: Default::default(),
                 tasks: DataFetchingTasks {
                     auction: futures::future::pending().boxed().shared(),
                     balances: futures::future::pending().boxed().shared(),
@@ -165,7 +179,7 @@ impl DataAggregator {
         }
     }
 
-    async fn assemble_tasks(&self, request: RequestBytes) -> Result<DataFetchingTasks> {
+    async fn assemble_tasks(&self, request: Request<Body>) -> Result<DataFetchingTasks> {
         let auction = self.utilities.parse_request(request).await?;
 
         let balances =
@@ -212,7 +226,9 @@ impl Utilities {
     /// Parses the JSON body of the `/solve` request during the unified
     /// auction pre-processing since eagerly deserializing these requests
     /// is surprisingly costly because their are so big.
-    async fn parse_request(&self, solve_request: RequestBytes) -> Result<Arc<Auction>> {
+    async fn parse_request(&self, solve_request: Request<Body>) -> Result<Arc<Auction>> {
+        let solve_request = collect_request_body(solve_request).await?;
+
         let auction_dto: SolveRequest = {
             let _timer = metrics::get().processing_stage_timer("parse_dto");
             let _timer2 =
@@ -539,3 +555,19 @@ fn init_auction_id_in_span(id: Option<i64>) {
     debug_assert!(current_span.has_field("auction_id"));
     current_span.record("auction_id", id);
 }
+
+#[instrument(skip_all)]
+async fn collect_request_body(request: Request<Body>) -> Result<RequestBytes> {
+    tracing::trace!("start streaming request body");
+    let _timer =
+        observe::metrics::metrics().on_auction_overhead_start("driver", "stream_http_body");
+    let start = Instant::now();
+
+    let body_bytes = hyper::body::to_bytes(request.into_body())
+        .await
+        .context("failed to stream request body")?;
+
+    let duration = start.elapsed();
+    tracing::debug!(?duration, "finished streaming request body");
+    Ok(body_bytes)
+}
diff --git a/crates/driver/src/infra/api/routes/solve/mod.rs b/crates/driver/src/infra/api/routes/solve/mod.rs
index b378dae435..417ddd8b5e 100644
--- a/crates/driver/src/infra/api/routes/solve/mod.rs
+++ b/crates/driver/src/infra/api/routes/solve/mod.rs
@@ -2,16 +2,11 @@ pub mod dto;
 
 pub use dto::AuctionError;
 use {
-    crate::{
-        domain::competition,
-        infra::{
-            api::{Error, State},
-            observe,
-        },
+    crate::infra::{
+        api::{Error, State},
+        observe,
     },
     axum::{body::Body, http::Request},
-    hyper::body::Bytes,
-    std::time::{Duration, Instant},
     tracing::Instrument,
 };
 
@@ -29,9 +24,8 @@ async fn route(
     let solver = state.solver().name().as_str();
 
     let handle_request = async {
-        let body_bytes = collect_request_body(request, solver).await?;
         let competition = state.competition();
-        let result = competition.solve(body_bytes).await;
+        let result = competition.solve(request).await;
         // Solving takes some time, so there is a chance for the settlement queue to
         // have capacity again.
         competition.ensure_settle_queue_capacity()?;
@@ -50,46 +44,3 @@ async fn route(
         ))
         .await
 }
-
-async fn collect_request_body(
-    request: Request<Body>,
-    solver: &str,
-) -> Result<Bytes, competition::Error> {
-    tracing::trace!("start streaming request body");
-    let start = Instant::now();
-
-    let body_bytes = hyper::body::to_bytes(request.into_body())
-        .await
-        .map_err(|err| {
-            tracing::warn!(?err, "failed to stream request body");
-            competition::Error::MalformedRequest
-        })?;
-
-    let duration = start.elapsed();
-    Metrics::measure_solve_transfer_time(solver, duration);
-    tracing::trace!(?duration, "finished streaming request body");
-    Ok(body_bytes)
-}
-
-#[derive(prometheus_metric_storage::MetricStorage)]
-struct Metrics {
-    /// Time spent by the driver reading the full solve request body into
-    /// memory.
-    #[metric(labels("solver"))]
-    #[metric(buckets(0.0001, 0.0005, 0.002, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.75, 1, 1.5))]
-    solve_request_body_read_duration_seconds: prometheus::HistogramVec,
-}
-
-impl Metrics {
-    fn get() -> &'static Metrics {
-        Metrics::instance(::observe::metrics::get_storage_registry())
-            .expect("unexpected error getting metrics instance")
-    }
-
-    fn measure_solve_transfer_time(solver: &str, time: Duration) {
-        Self::get()
-            .solve_request_body_read_duration_seconds
-            .with_label_values(&[solver])
-            .observe(time.as_secs_f64());
-    }
-}
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 5d1af8abde..65b5424475 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -1059,6 +1059,7 @@ impl Test {
         let res = self
             .client
             .post(format!("http://{}/{}/solve", self.driver.addr, solver))
+            .header("X-Auction-Id", self.auction_id)
             .json(&driver::solve_req(self))
             .send()
             .await

From 889bfcef0dbe8cf24deec4995efb17d9a0104ab5 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 17 Feb 2026 14:09:46 +0100
Subject: [PATCH 070/219] Add more tracing spans (#4162)

# Description
This PR just adds more tracing spans to further improve our coverage
with tempo.
Mostly focuses on the autopilot: building new auction, indexing events,
winner selection
---
 .../domain/competition/winner_selection.rs    |  2 +
 crates/autopilot/src/infra/persistence/mod.rs |  4 +-
 crates/autopilot/src/maintenance.rs           |  3 +-
 crates/autopilot/src/run_loop.rs              |  8 ++--
 crates/autopilot/src/solvable_orders.rs       | 38 ++++++++++++-------
 crates/cow-amm/src/registry.rs                |  1 +
 crates/shared/src/event_handling.rs           |  6 ++-
 crates/winner-selection/src/arbitrator.rs     |  4 ++
 8 files changed, 46 insertions(+), 20 deletions(-)

diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 33f6346050..911cb63350 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -34,6 +34,7 @@ use {
     },
     ::winner_selection::state::{HasState, RankedItem, ScoredItem, UnscoredItem},
     std::collections::HashMap,
+    tracing::instrument,
     winner_selection::{self as winsel},
 };
 
@@ -56,6 +57,7 @@ impl Arbitrator {
     }
 
     /// Runs the entire auction mechanism on the passed in solutions.
+    #[instrument(skip_all)]
     pub fn arbitrate(&self, bids: Vec<Bid<Unscored>>, auction: &domain::Auction) -> Ranking {
         let context = auction.into();
         let mut bid_by_key = HashMap::with_capacity(bids.len());
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index bf5f610a9d..879967cc4a 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -38,7 +38,7 @@ use {
         time::Duration,
     },
     tokio::sync::mpsc,
-    tracing::Instrument,
+    tracing::{Instrument, instrument},
 };
 
 pub mod cli;
@@ -301,6 +301,7 @@ impl Persistence {
     /// A variants of [`store_order_events`] where [`items`] is already an owned
     /// collection which allows us to move the logic to convert an item to a
     /// [`domain::OrderUid`] into the background task as well.
+    #[instrument(skip_all)]
     pub fn store_order_events_owned<I, F>(
         &self,
         items: I,
@@ -1005,6 +1006,7 @@ impl Persistence {
 
     /// Fetches orders which are currently inflight. Those orders should
     /// be omitted from the current auction to avoid onchain reverts.
+    #[instrument(skip_all)]
     pub async fn fetch_in_flight_orders(
         &self,
         current_block: u64,
diff --git a/crates/autopilot/src/maintenance.rs b/crates/autopilot/src/maintenance.rs
index f17e66abf6..fc7f48e2c8 100644
--- a/crates/autopilot/src/maintenance.rs
+++ b/crates/autopilot/src/maintenance.rs
@@ -29,7 +29,7 @@ use {
     },
     tokio::sync::watch,
     tokio_stream::wrappers::WatchStream,
-    tracing::Instrument,
+    tracing::{Instrument, instrument},
 };
 
 /// Component to sync with the maintenance logic that runs in a background task.
@@ -56,6 +56,7 @@ pub enum SyncTarget {
 }
 
 impl MaintenanceSync {
+    #[instrument(skip_all)]
     pub async fn wait_until_block_processed(&self, target: SyncTarget) {
         let _timer = observe::metrics::metrics()
             .on_auction_overhead_start("autopilot", "wait_for_maintenance");
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 1b037f3ed3..47fefb0f82 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -192,6 +192,7 @@ impl RunLoop {
         });
     }
 
+    #[instrument(skip_all)]
     async fn update_caches(&self, prev_block: &mut Option<B256>, is_leader: bool) -> BlockInfo {
         let current_block = *self.eth.current_block().borrow();
         let time_since_last_block = current_block.observed_at.elapsed();
@@ -365,8 +366,7 @@ impl RunLoop {
                 solution,
                 solution_uid,
                 block_deadline,
-            )
-            .await;
+            );
         }
         tracing::trace!(auction_id = ?auction.id, "settlement execution started");
         observe::unsettled(&ranking, &auction);
@@ -374,7 +374,7 @@ impl RunLoop {
 
     /// Starts settlement execution in a background task. The function is async
     /// only to get access to the locks.
-    async fn start_settlement_execution(
+    fn start_settlement_execution(
         self: &Arc<Self>,
         auction_id: Id,
         single_run_start: Instant,
@@ -692,6 +692,7 @@ impl RunLoop {
 
     /// Execute the solver's solution. Returns Ok when the corresponding
     /// transaction has been mined.
+    #[instrument(skip_all, fields(driver = driver.name, solution_uid))]
     async fn settle(
         &self,
         driver: &infra::Driver,
@@ -867,6 +868,7 @@ impl RunLoop {
 
     /// Removes orders that are currently being settled to avoid solver
     /// solutions conflicting with each other.
+    #[instrument(skip_all)]
     async fn remove_in_flight_orders(
         &self,
         mut auction: domain::RawAuctionData,
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 92cc5605c2..226e6f0d02 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -32,6 +32,7 @@ use {
     },
     strum::VariantNames,
     tokio::sync::Mutex,
+    tracing::instrument,
 };
 
 #[derive(prometheus_metric_storage::MetricStorage)]
@@ -79,6 +80,7 @@ impl Metrics {
         Metrics::instance(observe::metrics::get_storage_registry()).unwrap()
     }
 
+    #[instrument(skip_all)]
     fn track_filtered_orders(reason: &'static str, invalid_orders: &[OrderUid]) {
         if invalid_orders.is_empty() {
             return;
@@ -96,6 +98,7 @@ impl Metrics {
         );
     }
 
+    #[instrument(skip_all)]
     fn track_orders_in_final_auction(orders: &[Arc<Order>]) {
         let metrics = Metrics::get();
         metrics.auction_creations.inc();
@@ -191,6 +194,7 @@ impl SolvableOrdersCache {
     /// Usually this method is called from update_task. If it isn't, which is
     /// the case in unit tests, then concurrent calls might overwrite each
     /// other's results.
+    #[instrument(skip_all)]
     pub async fn update(&self, block: u64, store_events: bool) -> Result<()> {
         let start = Instant::now();
 
@@ -323,20 +327,22 @@ impl SolvableOrdersCache {
             .collect::<Vec<_>>();
         let auction = domain::RawAuctionData {
             block,
-            orders: orders
-                .into_iter()
-                .map(|order| {
-                    let quote = db_solvable_orders
-                        .quotes
-                        .get(&order.metadata.uid.into())
-                        .map(|quote| quote.as_ref().clone());
-                    self.protocol_fees.apply(
-                        order.as_ref(),
-                        quote,
-                        &surplus_capturing_jit_order_owners,
-                    )
-                })
-                .collect(),
+            orders: tracing::info_span!("assemble_orders").in_scope(|| {
+                orders
+                    .into_iter()
+                    .map(|order| {
+                        let quote = db_solvable_orders
+                            .quotes
+                            .get(&order.metadata.uid.into())
+                            .map(|quote| quote.as_ref().clone());
+                        self.protocol_fees.apply(
+                            order.as_ref(),
+                            quote,
+                            &surplus_capturing_jit_order_owners,
+                        )
+                    })
+                    .collect()
+            }),
             prices: prices
                 .into_iter()
                 .map(|(key, value)| {
@@ -358,6 +364,7 @@ impl SolvableOrdersCache {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn fetch_balances(&self, queries: Vec<Query>) -> HashMap<Query, U256> {
         let fetched_balances = self
             .timed_future(
@@ -425,6 +432,7 @@ impl SolvableOrdersCache {
     }
 
     /// Executed orders filtering in parallel.
+    #[instrument(skip_all)]
     async fn filter_invalid_orders(
         &self,
         mut orders: Vec<Arc<Order>>,
@@ -526,6 +534,7 @@ fn find_presignature_pending_orders(orders: &[Arc<Order>]) -> Vec<OrderUid> {
 
 /// Removes orders that can't possibly be settled because there isn't enough
 /// balance.
+#[instrument(skip_all)]
 fn orders_with_balance(
     mut orders: Vec<Arc<Order>>,
     balances: &Balances,
@@ -626,6 +635,7 @@ fn filter_dust_orders(
     (orders, removed)
 }
 
+#[instrument(skip_all)]
 async fn get_orders_with_native_prices(
     orders: Vec<Arc<Order>>,
     native_price_estimator: &NativePriceUpdater,
diff --git a/crates/cow-amm/src/registry.rs b/crates/cow-amm/src/registry.rs
index 1a20c4b58f..1af451ac9e 100644
--- a/crates/cow-amm/src/registry.rs
+++ b/crates/cow-amm/src/registry.rs
@@ -68,6 +68,7 @@ impl Registry {
     }
 
     /// Returns all the deployed CoW AMMs
+    #[instrument(skip_all)]
     pub async fn amms(&self) -> Vec<Arc<Amm>> {
         let mut result = vec![];
         let lock = self.storage.read().await;
diff --git a/crates/shared/src/event_handling.rs b/crates/shared/src/event_handling.rs
index 3c785234ce..1c37aceca8 100644
--- a/crates/shared/src/event_handling.rs
+++ b/crates/shared/src/event_handling.rs
@@ -11,7 +11,7 @@ use {
     futures::{Stream, StreamExt, future},
     std::{pin::Pin, sync::Arc},
     tokio::sync::Mutex,
-    tracing::Instrument,
+    tracing::{Instrument, instrument},
 };
 
 // We expect that there is never a reorg that changes more than the last n
@@ -261,6 +261,7 @@ where
     }
 
     /// Defines block range, for which events should be fetched
+    #[instrument(skip_all)]
     async fn event_block_range(&self) -> Result<EventRange> {
         let handled_blocks = if self.last_handled_blocks.is_empty() {
             let last_handled_block = self.store.last_event_block().await?;
@@ -380,6 +381,7 @@ where
     }
 
     /// Get new events from the contract and insert them into the database.
+    #[instrument(skip_all)]
     pub async fn update_events(&mut self) -> Result<()> {
         let event_range = self.event_block_range().await?;
 
@@ -396,6 +398,7 @@ where
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn update_events_from_old_blocks(&mut self, range: RangeInclusive<u64>) -> Result<()> {
         // first get the blocks needed to update `last_handled_blocks` because if it
         // fails, it's safer to fail at the beginning of the function before we
@@ -466,6 +469,7 @@ where
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn update_events_from_latest_blocks(
         &mut self,
         latest_blocks: &[BlockNumberHash],
diff --git a/crates/winner-selection/src/arbitrator.rs b/crates/winner-selection/src/arbitrator.rs
index fa8740cd3a..b15c4cdc3a 100644
--- a/crates/winner-selection/src/arbitrator.rs
+++ b/crates/winner-selection/src/arbitrator.rs
@@ -19,6 +19,7 @@ use {
         cmp::Reverse,
         collections::{HashMap, HashSet},
     },
+    tracing::instrument,
 };
 
 /// Auction arbitrator responsible for selecting winning solutions.
@@ -33,6 +34,7 @@ impl Arbitrator {
     /// Runs the auction mechanism on solutions.
     ///
     /// Takes solutions and auction context, returns a ranking with winners.
+    #[instrument(skip_all)]
     pub fn arbitrate(
         &self,
         solutions: Vec<Solution<Unscored>>,
@@ -55,6 +57,7 @@ impl Arbitrator {
     }
 
     /// Removes unfair solutions from the set of all solutions.
+    #[instrument(skip_all)]
     fn partition_unfair_solutions(
         &self,
         solutions: Vec<Solution<Unscored>>,
@@ -611,6 +614,7 @@ impl Arbitrator {
     }
 
     /// Compute reference scores for winning solvers.
+    #[instrument(skip_all)]
     pub fn compute_reference_scores(&self, ranking: &Ranking) -> HashMap<Address, U256> {
         let mut reference_scores = HashMap::default();
 

From 77bf1886844ad8ac6cf816ecc2c5a8740f2e2f19 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Wed, 18 Feb 2026 10:48:18 +0100
Subject: [PATCH 071/219] [TRIVIAL] Fix granular autopilot sync (#4165)

# Description
https://github.com/cowprotocol/services/pull/4144 introduced more
granular sync mechanisms for the autopilot run loop.
In a commit addressing some comments an error must have sneaked which
causes the autopilot run loop to wait for fully processed blocks and the
`/settle` detection to wait for partially indexed blocks - the exact
opposite.

This causes us to wait a lot longer than necessary before building a new
auction.
Also our metrics still suggest that the run loop was 1 block longer than
it actually was.
---
 crates/autopilot/src/maintenance.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/autopilot/src/maintenance.rs b/crates/autopilot/src/maintenance.rs
index fc7f48e2c8..326f196495 100644
--- a/crates/autopilot/src/maintenance.rs
+++ b/crates/autopilot/src/maintenance.rs
@@ -68,8 +68,8 @@ impl MaintenanceSync {
 
     async fn wait_inner(&self, target: SyncTarget) {
         let (relevant_updates, target_block) = match target {
-            SyncTarget::FullyProcessed(block) => (&self.partially_processed_block, block),
-            SyncTarget::PartiallyProcessed(block) => (&self.fully_processed_block, block),
+            SyncTarget::FullyProcessed(block) => (&self.fully_processed_block, block),
+            SyncTarget::PartiallyProcessed(block) => (&self.partially_processed_block, block),
         };
 
         if *relevant_updates.borrow() >= target_block {

From 612246e08a74e6522d4e83878e6088aef460f2d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 09:49:43 +0000
Subject: [PATCH 072/219] =?UTF-8?q?Upgrade=20axum=200.6=20=E2=86=92=200.8?=
 =?UTF-8?q?=20and=20related=20HTTP=20dependencies=20(#4164)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Upgrade the HTTP dependency stack:
- axum: 0.6 → 0.8
- hyper: 0.14 → 1
- http-body: 0.4 → 1
- tower: 0.4 → 0.5
- tower-http: 0.4 → 0.6
- reqwest: 0.11 → 0.12 (version 0.13 changes the default TLS stack so it
will be further upgraded separately)


# Changes
- [ ] Replace axum::Server with tokio::net::TcpListener + axum::serve
- [ ] Update route parameter syntax from :param to {param}
- [ ] Remove body generic from middleware Next type
- [ ] Replace hyper::body::to_bytes with axum::body::to_bytes
- [ ] Replace hyper::StatusCode with axum::http::StatusCode throughout
- [ ] Update return types from hyper::Error to std::io::Error
- [ ] Replace HttpBody trait usage with axum::body::to_bytes helper
- [ ] Remove now-unused direct hyper/http-body deps from crates
- [ ] Convert Mock solver Default impl to async new() since
TcpListener::bind is async

## How to test
Staging
---
 Cargo.lock                                    | 302 ++++++++----------
 Cargo.toml                                    |  12 +-
 crates/autopilot/Cargo.toml                   |   1 -
 crates/autopilot/src/infra/api.rs             |   8 +-
 .../autopilot/src/infra/solvers/dto/solve.rs  |   4 +-
 crates/driver/Cargo.toml                      |   2 -
 crates/driver/src/domain/competition/mod.rs   |   3 +-
 .../src/domain/competition/pre_processing.rs  |  17 +-
 crates/driver/src/infra/api/error.rs          |  14 +-
 crates/driver/src/infra/api/mod.rs            |  15 +-
 .../driver/src/infra/api/routes/gasprice.rs   |   2 +-
 .../driver/src/infra/api/routes/quote/mod.rs  |   2 +-
 .../driver/src/infra/api/routes/reveal/mod.rs |   2 +-
 .../driver/src/infra/api/routes/settle/mod.rs |   2 +-
 .../driver/src/infra/api/routes/solve/mod.rs  |   2 +-
 crates/driver/src/tests/setup/mod.rs          |  14 +-
 crates/driver/src/tests/setup/orderbook.rs    |  13 +-
 crates/driver/src/tests/setup/solver.rs       |   7 +-
 crates/e2e/Cargo.toml                         |   1 -
 crates/e2e/src/api/liquorice/server.rs        |   7 +-
 crates/e2e/src/api/zeroex.rs                  |   7 +-
 crates/e2e/src/setup/proxy.rs                 |  10 +-
 crates/e2e/src/setup/solver/mock.rs           |  25 +-
 crates/e2e/tests/e2e/cow_amm.rs               |   6 +-
 crates/e2e/tests/e2e/jit_orders.rs            |   2 +-
 .../e2e/liquidity_source_notification.rs      |   2 +-
 crates/e2e/tests/e2e/quoting.rs               |   2 +-
 crates/e2e/tests/e2e/solver_competition.rs    |   4 +-
 crates/observe/src/metrics.rs                 |   6 +-
 crates/orderbook/Cargo.toml                   |   1 -
 crates/orderbook/src/api.rs                   |  68 ++--
 crates/orderbook/src/api/cancel_orders.rs     |   2 +-
 .../src/api/get_solver_competition.rs         |   3 +-
 crates/orderbook/src/run.rs                   |  16 +-
 crates/solvers/Cargo.toml                     |   1 -
 crates/solvers/src/api/mod.rs                 |  10 +-
 36 files changed, 284 insertions(+), 311 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7e6e51088b..f4717183d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -367,7 +367,7 @@ dependencies = [
  "lru 0.16.3",
  "parking_lot",
  "pin-project",
- "reqwest 0.12.28",
+ "reqwest",
  "serde",
  "serde_json",
  "thiserror 2.0.17",
@@ -435,7 +435,7 @@ dependencies = [
  "alloy-transport-ws",
  "futures",
  "pin-project",
- "reqwest 0.12.28",
+ "reqwest",
  "serde",
  "serde_json",
  "tokio",
@@ -714,7 +714,7 @@ checksum = "36dfa207caf6b528b9466c714626f5b2dfd5e8d4595a74631d5670672dac102b"
 dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
- "reqwest 0.12.28",
+ "reqwest",
  "serde_json",
  "tower 0.5.3",
  "tracing",
@@ -1162,7 +1162,7 @@ dependencies = [
  "anyhow",
  "app-data",
  "async-trait",
- "axum",
+ "axum 0.8.8",
  "bigdecimal",
  "bytes",
  "bytes-hex",
@@ -1179,7 +1179,6 @@ dependencies = [
  "futures",
  "hex-literal",
  "humantime",
- "hyper 0.14.32",
  "indexmap 2.13.0",
  "itertools 0.14.0",
  "maplit",
@@ -1193,7 +1192,7 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
- "reqwest 0.11.27",
+ "reqwest",
  "rust_decimal",
  "s3",
  "serde",
@@ -1208,8 +1207,8 @@ dependencies = [
  "tokio",
  "tokio-stream",
  "toml",
- "tower 0.4.13",
- "tower-http 0.4.4",
+ "tower 0.5.3",
+ "tower-http",
  "tracing",
  "url",
  "vergen",
@@ -1670,7 +1669,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf"
 dependencies = [
  "async-trait",
- "axum-core",
+ "axum-core 0.3.4",
  "bitflags 1.3.2",
  "bytes",
  "futures-util",
@@ -1678,21 +1677,50 @@ dependencies = [
  "http-body 0.4.6",
  "hyper 0.14.32",
  "itoa",
- "matchit",
+ "matchit 0.7.3",
  "memchr",
  "mime",
  "percent-encoding",
  "pin-project-lite",
  "rustversion",
  "serde",
+ "sync_wrapper 0.1.2",
+ "tower 0.4.13",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
+dependencies = [
+ "axum-core 0.5.6",
+ "bytes",
+ "form_urlencoded",
+ "futures-util",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.8.1",
+ "hyper-util",
+ "itoa",
+ "matchit 0.8.4",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
  "serde_json",
  "serde_path_to_error",
  "serde_urlencoded",
- "sync_wrapper 0.1.2",
+ "sync_wrapper 1.0.2",
  "tokio",
- "tower 0.4.13",
+ "tower 0.5.3",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -1712,6 +1740,25 @@ dependencies = [
  "tower-service",
 ]
 
+[[package]]
+name = "axum-core"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper 1.0.2",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.76"
@@ -2259,7 +2306,7 @@ dependencies = [
  "prettyplease",
  "proc-macro2",
  "quote",
- "reqwest 0.11.27",
+ "reqwest",
  "serde",
  "serde_json",
  "syn 2.0.114",
@@ -2287,9 +2334,9 @@ dependencies = [
 
 [[package]]
 name = "cookie"
-version = "0.17.0"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7efb37c3e1ccb1ff97164ad95ac1606e8ccd35b3fa0a7d99a304c7f4a428cc24"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
 dependencies = [
  "percent-encoding",
  "time",
@@ -2298,12 +2345,13 @@ dependencies = [
 
 [[package]]
 name = "cookie_store"
-version = "0.20.0"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "387461abbc748185c3a6e1673d826918b450b87ff22639429c694619a83b6cf6"
+checksum = "15b2c103cf610ec6cae3da84a766285b42fd16aad564758459e6ecf128c75206"
 dependencies = [
  "cookie",
- "idna 0.3.0",
+ "document-features",
+ "idna",
  "log",
  "publicsuffix",
  "serde",
@@ -2671,6 +2719,15 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "document-features"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
+dependencies = [
+ "litrs",
+]
+
 [[package]]
 name = "dotenvy"
 version = "0.15.7"
@@ -2691,7 +2748,7 @@ dependencies = [
  "anyhow",
  "app-data",
  "async-trait",
- "axum",
+ "axum 0.8.8",
  "bigdecimal",
  "bytes-hex",
  "chain",
@@ -2705,10 +2762,8 @@ dependencies = [
  "ethrpc",
  "futures",
  "hex-literal",
- "http-body 0.4.6",
  "humantime",
  "humantime-serde",
- "hyper 0.14.32",
  "itertools 0.14.0",
  "maplit",
  "mimalloc",
@@ -2720,7 +2775,7 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
- "reqwest 0.11.27",
+ "reqwest",
  "s3",
  "serde",
  "serde-ext",
@@ -2734,8 +2789,8 @@ dependencies = [
  "tikv-jemallocator",
  "tokio",
  "toml",
- "tower 0.4.13",
- "tower-http 0.4.4",
+ "tower 0.5.3",
+ "tower-http",
  "tracing",
  "url",
  "vergen",
@@ -2762,7 +2817,7 @@ dependencies = [
  "anyhow",
  "app-data",
  "autopilot",
- "axum",
+ "axum 0.8.8",
  "bigdecimal",
  "chrono",
  "clap",
@@ -2774,14 +2829,13 @@ dependencies = [
  "ethrpc",
  "futures",
  "hex-literal",
- "hyper 0.14.32",
  "itertools 0.14.0",
  "model",
  "number",
  "observe",
  "orderbook",
  "refunder",
- "reqwest 0.11.27",
+ "reqwest",
  "rstest",
  "serde_json",
  "shared",
@@ -2924,13 +2978,13 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
- "reqwest 0.11.27",
+ "reqwest",
  "scopeguard",
  "serde",
  "serde_json",
  "tokio",
  "tokio-stream",
- "tower 0.4.13",
+ "tower 0.5.3",
  "tracing",
  "url",
 ]
@@ -3492,12 +3546,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "http-range-header"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f"
-
 [[package]]
 name = "httparse"
 version = "1.10.1"
@@ -3564,6 +3612,7 @@ dependencies = [
  "http 1.4.0",
  "http-body 1.0.1",
  "httparse",
+ "httpdate",
  "itoa",
  "pin-project-lite",
  "pin-utils",
@@ -3629,19 +3678,6 @@ dependencies = [
  "tower-service",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
-dependencies = [
- "bytes",
- "hyper 0.14.32",
- "native-tls",
- "tokio",
- "tokio-native-tls",
-]
-
 [[package]]
 name = "hyper-tls"
 version = "0.6.0"
@@ -3677,9 +3713,11 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "socket2 0.6.1",
+ "system-configuration",
  "tokio",
  "tower-service",
  "tracing",
+ "windows-registry",
 ]
 
 [[package]]
@@ -3793,16 +3831,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
-[[package]]
-name = "idna"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -4091,6 +4119,12 @@ version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
+[[package]]
+name = "litrs"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
+
 [[package]]
 name = "lock_api"
 version = "0.4.14"
@@ -4180,6 +4214,12 @@ version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
 
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
 [[package]]
 name = "md-5"
 version = "0.10.6"
@@ -4533,7 +4573,7 @@ name = "observe"
 version = "0.1.0"
 dependencies = [
  "async-trait",
- "axum",
+ "axum 0.8.8",
  "chrono",
  "console-subscriber",
  "futures",
@@ -4641,7 +4681,7 @@ dependencies = [
  "bytes",
  "http 1.4.0",
  "opentelemetry",
- "reqwest 0.12.28",
+ "reqwest",
 ]
 
 [[package]]
@@ -4656,7 +4696,7 @@ dependencies = [
  "opentelemetry-proto",
  "opentelemetry_sdk",
  "prost 0.13.5",
- "reqwest 0.12.28",
+ "reqwest",
  "thiserror 2.0.17",
  "tokio",
  "tonic 0.13.1",
@@ -4712,7 +4752,7 @@ dependencies = [
  "anyhow",
  "app-data",
  "async-trait",
- "axum",
+ "axum 0.8.8",
  "bigdecimal",
  "cached",
  "chain",
@@ -4725,7 +4765,6 @@ dependencies = [
  "futures",
  "hex-literal",
  "humantime",
- "hyper 0.14.32",
  "mimalloc",
  "mockall",
  "model",
@@ -4736,7 +4775,7 @@ dependencies = [
  "order-validation",
  "prometheus",
  "prometheus-metric-storage",
- "reqwest 0.11.27",
+ "reqwest",
  "serde",
  "serde_json",
  "serde_with",
@@ -4746,8 +4785,8 @@ dependencies = [
  "thiserror 1.0.69",
  "tikv-jemallocator",
  "tokio",
- "tower 0.4.13",
- "tower-http 0.4.4",
+ "tower 0.5.3",
+ "tower-http",
  "tracing",
  "url",
  "vergen",
@@ -5186,7 +5225,7 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42ea446cab60335f76979ec15e12619a2165b5ae2c12166bef27d283a9fadf"
 dependencies = [
- "idna 1.1.0",
+ "idna",
  "psl-types",
 ]
 
@@ -5308,7 +5347,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "reqwest 0.11.27",
+ "reqwest",
  "thiserror 1.0.69",
  "tokio",
  "tracing",
@@ -5423,51 +5462,6 @@ version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 
-[[package]]
-name = "reqwest"
-version = "0.11.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
-dependencies = [
- "async-compression",
- "base64 0.21.7",
- "bytes",
- "cookie",
- "cookie_store",
- "encoding_rs",
- "futures-core",
- "futures-util",
- "h2 0.3.27",
- "http 0.2.12",
- "http-body 0.4.6",
- "hyper 0.14.32",
- "hyper-tls 0.5.0",
- "ipnet",
- "js-sys",
- "log",
- "mime",
- "native-tls",
- "once_cell",
- "percent-encoding",
- "pin-project-lite",
- "rustls-pemfile",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "sync_wrapper 0.1.2",
- "system-configuration",
- "tokio",
- "tokio-native-tls",
- "tokio-util",
- "tower-service",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-streams",
- "web-sys",
- "winreg",
-]
-
 [[package]]
 name = "reqwest"
 version = "0.12.28"
@@ -5476,17 +5470,23 @@ checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
 dependencies = [
  "base64 0.22.1",
  "bytes",
+ "cookie",
+ "cookie_store",
+ "encoding_rs",
  "futures-channel",
  "futures-core",
  "futures-util",
+ "h2 0.4.13",
  "http 1.4.0",
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.8.1",
- "hyper-tls 0.6.0",
+ "hyper-rustls 0.27.7",
+ "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
+ "mime",
  "native-tls",
  "percent-encoding",
  "pin-project-lite",
@@ -5497,12 +5497,14 @@ dependencies = [
  "sync_wrapper 1.0.2",
  "tokio",
  "tokio-native-tls",
+ "tokio-util",
  "tower 0.5.3",
- "tower-http 0.6.8",
+ "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
+ "wasm-streams",
  "web-sys",
 ]
 
@@ -5732,15 +5734,6 @@ dependencies = [
  "security-framework 3.5.1",
 ]
 
-[[package]]
-name = "rustls-pemfile"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
-dependencies = [
- "base64 0.21.7",
-]
-
 [[package]]
 name = "rustls-pki-types"
 version = "1.13.2"
@@ -6179,7 +6172,7 @@ dependencies = [
  "rand 0.8.5",
  "rate-limit",
  "regex",
- "reqwest 0.11.27",
+ "reqwest",
  "rust_decimal",
  "serde",
  "serde_json",
@@ -6297,7 +6290,7 @@ version = "0.1.0"
 dependencies = [
  "alloy",
  "anyhow",
- "axum",
+ "axum 0.8.8",
  "bigdecimal",
  "chain",
  "chrono",
@@ -6307,7 +6300,6 @@ dependencies = [
  "derive_more 1.0.0",
  "ethrpc",
  "futures",
- "hyper 0.14.32",
  "itertools 0.14.0",
  "mimalloc",
  "model",
@@ -6316,7 +6308,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "reqwest 0.11.27",
+ "reqwest",
  "serde",
  "serde_json",
  "serde_with",
@@ -6327,8 +6319,8 @@ dependencies = [
  "tikv-jemallocator",
  "tokio",
  "toml",
- "tower 0.4.13",
- "tower-http 0.4.4",
+ "tower 0.5.3",
+ "tower-http",
  "tracing",
  "url",
  "vergen",
@@ -7104,7 +7096,7 @@ checksum = "76c4eb7a4e9ef9d4763600161f12f5070b92a578e1b634db88a6887844c91a13"
 dependencies = [
  "async-stream",
  "async-trait",
- "axum",
+ "axum 0.6.20",
  "base64 0.21.7",
  "bytes",
  "h2 0.3.27",
@@ -7188,41 +7180,28 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "tower-http"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c5bb1d698276a2443e5ecfabc1008bf15a36c12e6a7176e7bf089ea9131140"
-dependencies = [
- "bitflags 2.10.0",
- "bytes",
- "futures-core",
- "futures-util",
- "http 0.2.12",
- "http-body 0.4.6",
- "http-range-header",
- "pin-project-lite",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "tower-http"
 version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
+ "async-compression",
  "bitflags 2.10.0",
  "bytes",
+ "futures-core",
  "futures-util",
  "http 1.4.0",
  "http-body 1.0.1",
+ "http-body-util",
  "iri-string",
  "pin-project-lite",
+ "tokio",
+ "tokio-util",
  "tower 0.5.3",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -7444,7 +7423,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
  "form_urlencoded",
- "idna 1.1.0",
+ "idna",
  "percent-encoding",
  "serde",
  "serde_derive",
@@ -7734,6 +7713,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.4.1"
@@ -7995,16 +7985,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "winreg"
-version = "0.50.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
-dependencies = [
- "cfg-if",
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "wit-bindgen"
 version = "0.46.0"
diff --git a/Cargo.toml b/Cargo.toml
index 84bcbc9b5a..3099d89977 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,7 @@ alloy = { version = "1.1.0", default-features = false }
 alloy-signer = { version = "1.1.0", default-features = false}
 anyhow = "1.0.100"
 async-trait = "0.1.80"
-axum = "0.6"
+axum = "0.8"
 bigdecimal = "0.3"
 cached = { version = "0.49.3", default-features = false }
 chrono = { version = "0.4.38", default-features = false }
@@ -24,10 +24,10 @@ flate2 = "1.0.30"
 futures = "0.3.30"
 const-hex = "1.17.0"
 hex-literal = "0.4.1"
-http-body = "0.4.6"
+http-body = "1"
+http-body-util = "0.1"
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
-hyper = "0.14.29"
 indexmap = "2.2.6"
 itertools = "0.14"
 maplit = "1.0.2"
@@ -37,7 +37,7 @@ prometheus = "0.13.4"
 prometheus-metric-storage = "0.5.0"
 rand = "0.8.5"
 regex = "1.10.4"
-reqwest = "0.11.27"
+reqwest = "0.12"
 rstest = "0.26"
 ruint = { version = "1.17.2", default-features = false }
 serde = { version = "1.0.203", features = ["derive"] }
@@ -94,8 +94,8 @@ testlib = { path = "crates/testlib" }
 winner-selection = { path = "crates/winner-selection" }
 time = "0.3.47"
 tiny-keccak = "2.0.2"
-tower = "0.4"
-tower-http = "0.4"
+tower = "0.5"
+tower-http = "0.6"
 tracing-opentelemetry = "0.31"
 tracing-serde = "0.2"
 vergen = "8"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 97750f6d16..ea51d503a6 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -33,7 +33,6 @@ database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-hyper = { workspace = true }
 observe = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
diff --git a/crates/autopilot/src/infra/api.rs b/crates/autopilot/src/infra/api.rs
index d7c7477af5..4d98afe86b 100644
--- a/crates/autopilot/src/infra/api.rs
+++ b/crates/autopilot/src/infra/api.rs
@@ -45,14 +45,14 @@ pub async fn serve(
     estimator: Arc<dyn NativePriceEstimating>,
     max_timeout: Duration,
     shutdown: oneshot::Receiver<()>,
-) -> Result<(), hyper::Error> {
+) -> Result<(), std::io::Error> {
     let state = State {
         estimator,
         allowed_timeout: MIN_TIMEOUT..=max_timeout,
     };
 
     let app = Router::new()
-        .route("/native_price/:token", get(get_native_price))
+        .route("/native_price/{token}", get(get_native_price))
         .with_state(state)
         .layer(
             tower::ServiceBuilder::new()
@@ -60,10 +60,10 @@ pub async fn serve(
                 .map_request(record_trace_id),
         );
 
-    let server = axum::Server::bind(&addr).serve(app.into_make_service());
+    let listener = tokio::net::TcpListener::bind(addr).await?;
     tracing::info!(?addr, "serving HTTP API");
 
-    server
+    axum::serve(listener, app)
         .with_graceful_shutdown(async {
             shutdown.await.ok();
         })
diff --git a/crates/autopilot/src/infra/solvers/dto/solve.rs b/crates/autopilot/src/infra/solvers/dto/solve.rs
index ed6aeb9d9f..da80a42fd4 100644
--- a/crates/autopilot/src/infra/solvers/dto/solve.rs
+++ b/crates/autopilot/src/infra/solvers/dto/solve.rs
@@ -90,8 +90,8 @@ impl InjectIntoHttpRequest for Request {
             // manually set the content type header for JSON since
             // we can't use `request.json(self)`
             .header(
-                hyper::header::CONTENT_TYPE,
-                hyper::header::HeaderValue::from_static("application/json")
+                reqwest::header::CONTENT_TYPE,
+                reqwest::header::HeaderValue::from_static("application/json")
             )
     }
 
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index f5a725802d..e174bb026f 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -30,10 +30,8 @@ ethrpc = { workspace = true }
 futures = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
-http-body = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
-hyper = { workspace = true }
 itertools = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 tikv-jemallocator = { workspace = true }
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index f2761bbf32..392ea46051 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -22,9 +22,8 @@ use {
         util::math,
     },
     alloy::primitives::Bytes,
-    axum::body::Body,
+    axum::{body::Body, http::Request},
     futures::{StreamExt, future::Either, stream::FuturesUnordered},
-    hyper::Request,
     itertools::Itertools,
     std::{
         cmp::Reverse,
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index ccd17ad8cc..a4d5105705 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -7,14 +7,21 @@ use {
             eth,
             liquidity,
         },
-        infra::{self, api::routes::solve::dto::SolveRequest, observe::metrics, tokens},
+        infra::{
+            self,
+            api::{REQUEST_BODY_LIMIT, routes::solve::dto::SolveRequest},
+            observe::metrics,
+            tokens,
+        },
     },
     alloy::primitives::{Bytes, FixedBytes},
     anyhow::{Context, Result},
-    axum::body::Body,
+    axum::{
+        body::{self, Body},
+        http::Request,
+    },
     chrono::Utc,
     futures::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered},
-    hyper::{Request, body::Bytes as RequestBytes},
     itertools::Itertools,
     model::{
         interaction::InteractionData,
@@ -557,13 +564,13 @@ fn init_auction_id_in_span(id: Option<i64>) {
 }
 
 #[instrument(skip_all)]
-async fn collect_request_body(request: Request<Body>) -> Result<RequestBytes> {
+async fn collect_request_body(request: Request<Body>) -> Result<body::Bytes> {
     tracing::trace!("start streaming request body");
     let _timer =
         observe::metrics::metrics().on_auction_overhead_start("driver", "stream_http_body");
     let start = Instant::now();
 
-    let body_bytes = hyper::body::to_bytes(request.into_body())
+    let body_bytes = axum::body::to_bytes(request.into_body(), REQUEST_BODY_LIMIT)
         .await
         .context("failed to stream request body")?;
 
diff --git a/crates/driver/src/infra/api/error.rs b/crates/driver/src/infra/api/error.rs
index 52629bdf3f..b7720c480c 100644
--- a/crates/driver/src/infra/api/error.rs
+++ b/crates/driver/src/infra/api/error.rs
@@ -32,7 +32,7 @@ pub struct Error {
     description: &'static str,
 }
 
-impl From<Kind> for (hyper::StatusCode, axum::Json<Error>) {
+impl From<Kind> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(value: Kind) -> Self {
         let description = match value {
             Kind::QuotingFailed => "No valid quote found",
@@ -59,7 +59,7 @@ impl From<Kind> for (hyper::StatusCode, axum::Json<Error>) {
             Kind::MalformedRequest => "Could not parse the request",
         };
         (
-            hyper::StatusCode::BAD_REQUEST,
+            axum::http::StatusCode::BAD_REQUEST,
             axum::Json(Error {
                 kind: value,
                 description,
@@ -68,7 +68,7 @@ impl From<Kind> for (hyper::StatusCode, axum::Json<Error>) {
     }
 }
 
-impl From<quote::Error> for (hyper::StatusCode, axum::Json<Error>) {
+impl From<quote::Error> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(value: quote::Error) -> Self {
         let error = match value {
             quote::Error::QuotingFailed(_) => Kind::QuotingFailed,
@@ -82,7 +82,7 @@ impl From<quote::Error> for (hyper::StatusCode, axum::Json<Error>) {
     }
 }
 
-impl From<competition::Error> for (hyper::StatusCode, axum::Json<Error>) {
+impl From<competition::Error> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(value: competition::Error) -> Self {
         let error = match value {
             competition::Error::SolutionNotAvailable => Kind::SolutionNotAvailable,
@@ -97,13 +97,13 @@ impl From<competition::Error> for (hyper::StatusCode, axum::Json<Error>) {
     }
 }
 
-impl From<blockchain::Error> for (hyper::StatusCode, axum::Json<Error>) {
+impl From<blockchain::Error> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(_: blockchain::Error) -> Self {
         Kind::Unknown.into()
     }
 }
 
-impl From<api::routes::AuctionError> for (hyper::StatusCode, axum::Json<Error>) {
+impl From<api::routes::AuctionError> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(value: api::routes::AuctionError) -> Self {
         let error = match value {
             api::routes::AuctionError::InvalidAuctionId => Kind::InvalidAuctionId,
@@ -116,7 +116,7 @@ impl From<api::routes::AuctionError> for (hyper::StatusCode, axum::Json<Error>)
     }
 }
 
-impl From<api::routes::OrderError> for (hyper::StatusCode, axum::Json<Error>) {
+impl From<api::routes::OrderError> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(value: api::routes::OrderError) -> Self {
         let error = match value {
             api::routes::OrderError::SameTokens => Kind::QuoteSameTokens,
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index 38d106a258..a6ac2cde60 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -31,7 +31,7 @@ use {
 mod error;
 pub mod routes;
 
-const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
+pub const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
 
 pub struct Api {
     pub solvers: Vec<Solver>,
@@ -53,7 +53,7 @@ impl Api {
         shutdown: impl Future<Output = ()> + Send + 'static,
         order_priority_strategies: Vec<OrderPriorityStrategy>,
         app_data_retriever: Option<AppDataRetriever>,
-    ) -> Result<(), hyper::Error> {
+    ) -> Result<(), std::io::Error> {
         // Add middleware.
         let mut app = axum::Router::new().layer(tower::ServiceBuilder::new().layer(
             tower_http::limit::RequestBodyLimitLayer::new(REQUEST_BODY_LIMIT),
@@ -148,12 +148,15 @@ impl Api {
             );
 
         // Start the server.
-        let server = axum::Server::bind(&self.addr).serve(app.into_make_service());
-        tracing::info!(port = server.local_addr().port(), "serving driver");
+        let listener = tokio::net::TcpListener::bind(self.addr).await?;
+        let local_addr = listener.local_addr()?;
+        tracing::info!(port = local_addr.port(), "serving driver");
         if let Some(addr_sender) = self.addr_sender {
-            addr_sender.send(server.local_addr()).unwrap();
+            addr_sender.send(local_addr).unwrap();
         }
-        server.with_graceful_shutdown(shutdown).await
+        axum::serve(listener, app)
+            .with_graceful_shutdown(shutdown)
+            .await
     }
 
     fn build_order_sorting_strategies(
diff --git a/crates/driver/src/infra/api/routes/gasprice.rs b/crates/driver/src/infra/api/routes/gasprice.rs
index 175d13dec6..f495e3ec66 100644
--- a/crates/driver/src/infra/api/routes/gasprice.rs
+++ b/crates/driver/src/infra/api/routes/gasprice.rs
@@ -12,7 +12,7 @@ pub(in crate::infra::api) fn gasprice(app: axum::Router<Ethereum>) -> axum::Rout
 #[instrument(skip(eth))]
 async fn route(
     eth: axum::extract::State<Ethereum>,
-) -> Result<Json<Eip1559Estimation>, (hyper::StatusCode, axum::Json<Error>)> {
+) -> Result<Json<Eip1559Estimation>, (axum::http::StatusCode, axum::Json<Error>)> {
     // For simplicity we use the default time limit (None)
     let gas_price = eth.gas_price().await?;
 
diff --git a/crates/driver/src/infra/api/routes/quote/mod.rs b/crates/driver/src/infra/api/routes/quote/mod.rs
index a55e7490cb..d3310c5292 100644
--- a/crates/driver/src/infra/api/routes/quote/mod.rs
+++ b/crates/driver/src/infra/api/routes/quote/mod.rs
@@ -17,7 +17,7 @@ pub(in crate::infra::api) fn quote(router: axum::Router<State>) -> axum::Router<
 async fn route(
     state: axum::extract::State<State>,
     order: axum::extract::Query<dto::Order>,
-) -> Result<axum::Json<dto::Quote>, (hyper::StatusCode, axum::Json<Error>)> {
+) -> Result<axum::Json<dto::Quote>, (axum::http::StatusCode, axum::Json<Error>)> {
     let handle_request = async {
         let order = order.0.into_domain();
         observe::quoting(&order);
diff --git a/crates/driver/src/infra/api/routes/reveal/mod.rs b/crates/driver/src/infra/api/routes/reveal/mod.rs
index 7a2d6081e5..08e388d761 100644
--- a/crates/driver/src/infra/api/routes/reveal/mod.rs
+++ b/crates/driver/src/infra/api/routes/reveal/mod.rs
@@ -18,7 +18,7 @@ pub(in crate::infra::api) fn reveal(router: axum::Router<State>) -> axum::Router
 async fn route(
     state: axum::extract::State<State>,
     req: axum::Json<dto::RevealRequest>,
-) -> Result<axum::Json<dto::RevealResponse>, (hyper::StatusCode, axum::Json<Error>)> {
+) -> Result<axum::Json<dto::RevealResponse>, (axum::http::StatusCode, axum::Json<Error>)> {
     let auction_id =
         auction::Id::try_from(req.auction_id).map_err(api::routes::AuctionError::from)?;
     let handle_request = async {
diff --git a/crates/driver/src/infra/api/routes/settle/mod.rs b/crates/driver/src/infra/api/routes/settle/mod.rs
index 2e53994c8b..fe3634da69 100644
--- a/crates/driver/src/infra/api/routes/settle/mod.rs
+++ b/crates/driver/src/infra/api/routes/settle/mod.rs
@@ -18,7 +18,7 @@ pub(in crate::infra::api) fn settle(router: axum::Router<State>) -> axum::Router
 async fn route(
     state: axum::extract::State<State>,
     req: axum::Json<dto::SettleRequest>,
-) -> Result<(), (hyper::StatusCode, axum::Json<Error>)> {
+) -> Result<(), (axum::http::StatusCode, axum::Json<Error>)> {
     let auction_id =
         auction::Id::try_from(req.auction_id).map_err(api::routes::AuctionError::from)?;
     let solver = state.solver().name().to_string();
diff --git a/crates/driver/src/infra/api/routes/solve/mod.rs b/crates/driver/src/infra/api/routes/solve/mod.rs
index 417ddd8b5e..baa78c6b4d 100644
--- a/crates/driver/src/infra/api/routes/solve/mod.rs
+++ b/crates/driver/src/infra/api/routes/solve/mod.rs
@@ -20,7 +20,7 @@ async fn route(
     // This delays interpreting the data as much as possible and allows
     // logging how long the raw data transfer takes.
     request: Request<Body>,
-) -> Result<axum::Json<dto::SolveResponse>, (hyper::StatusCode, axum::Json<Error>)> {
+) -> Result<axum::Json<dto::SolveResponse>, (axum::http::StatusCode, axum::Json<Error>)> {
     let solver = state.solver().name().as_str();
 
     let handle_request = async {
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 65b5424475..9b0416a128 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -41,10 +41,10 @@ use {
         providers::Provider,
         signers::local::PrivateKeySigner,
     },
+    axum::http::StatusCode,
     bigdecimal::{BigDecimal, FromPrimitive},
     ethrpc::Web3,
     futures::future::join_all,
-    hyper::StatusCode,
     model::order::{BuyTokenDestination, SellTokenSource},
     number::{serialization::HexOrDecimalU256, testing::ApproxEq},
     serde::{Deserialize, de::IntoDeserializer},
@@ -954,7 +954,7 @@ impl Setup {
                 flashloans: solution.flashloans.clone(),
             });
         }
-        let orderbook = Orderbook::start(&orders);
+        let orderbook = Orderbook::start(&orders).await;
         let quotes = orders
             .into_iter()
             .map(|order| blockchain.quote(&order))
@@ -1229,7 +1229,7 @@ pub struct SolveOk<'a> {
 impl<'a> Solve<'a> {
     /// Expect the /solve endpoint to have returned a 200 OK response.
     pub fn ok(self) -> SolveOk<'a> {
-        assert_eq!(self.status, hyper::StatusCode::OK);
+        assert_eq!(self.status, axum::http::StatusCode::OK);
         SolveOk {
             body: self.body,
             trades: self.trades,
@@ -1238,7 +1238,7 @@ impl<'a> Solve<'a> {
     }
 
     pub fn err(self) -> SolveErr {
-        assert_ne!(self.status, hyper::StatusCode::OK);
+        assert_ne!(self.status, axum::http::StatusCode::OK);
         SolveErr { body: self.body }
     }
 }
@@ -1401,7 +1401,7 @@ pub struct Reveal {
 impl Reveal {
     /// Expect the /reveal endpoint to have returned a 200 OK response.
     pub fn ok(self) -> RevealOk {
-        assert_eq!(self.status, hyper::StatusCode::OK);
+        assert_eq!(self.status, axum::http::StatusCode::OK);
         RevealOk { body: self.body }
     }
 
@@ -1477,7 +1477,7 @@ pub struct Quote<'a> {
 impl<'a> Quote<'a> {
     /// Expect the /quote endpoint to have returned a 200 OK response.
     pub fn ok(self) -> QuoteOk<'a> {
-        assert_eq!(self.status, hyper::StatusCode::OK);
+        assert_eq!(self.status, axum::http::StatusCode::OK);
         QuoteOk {
             trades: self.trades,
             body: self.body,
@@ -1687,7 +1687,7 @@ impl Settle {
     pub fn err(self) -> SettleErr {
         match self.status {
             SettleStatus::Err { status_code, body } => {
-                assert_eq!(status_code, hyper::StatusCode::BAD_REQUEST);
+                assert_eq!(status_code, axum::http::StatusCode::BAD_REQUEST);
                 SettleErr { body }
             }
             _ => panic!("expected a 400 BAD REQUEST response"),
diff --git a/crates/driver/src/tests/setup/orderbook.rs b/crates/driver/src/tests/setup/orderbook.rs
index 8b3da45a3a..3d48174ada 100644
--- a/crates/driver/src/tests/setup/orderbook.rs
+++ b/crates/driver/src/tests/setup/orderbook.rs
@@ -27,7 +27,7 @@ impl Orderbook {
     ///
     /// # Returns
     /// The `Orderbook` instance with the server listening address.
-    pub fn start(orders: &[Order]) -> Self {
+    pub async fn start(orders: &[Order]) -> Self {
         let app_data_storage = orders
             .iter()
             .filter_map(|order| {
@@ -43,15 +43,16 @@ impl Orderbook {
             .collect::<HashMap<_, _>>();
 
         let app = Router::new()
-            .route("/api/v1/app_data/:app_data", get(Self::app_data_handler))
+            .route("/api/v1/app_data/{app_data}", get(Self::app_data_handler))
             .layer(Extension(app_data_storage));
-        let server =
-            axum::Server::bind(&"0.0.0.0:0".parse().unwrap()).serve(app.into_make_service());
-        let addr = server.local_addr();
+        let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
 
         tracing::info!("Orderbook mock server listening on {}", addr);
 
-        tokio::spawn(server);
+        tokio::spawn(async move {
+            axum::serve(listener, app).await.unwrap();
+        });
 
         Orderbook { addr }
     }
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index ca01351e46..99537e8f9d 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -514,10 +514,9 @@ impl Solver {
             ),
         )
         .with_state(State(state));
-        let server =
-            axum::Server::bind(&"0.0.0.0:0".parse().unwrap()).serve(app.into_make_service());
-        let addr = server.local_addr();
-        tokio::spawn(async move { server.await.unwrap() });
+        let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
         Self { addr }
     }
 }
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index df12e6e6a7..eb024a69ea 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -26,7 +26,6 @@ driver = { workspace = true }
 ethrpc = { workspace = true, features = ["test-util"] }
 futures = { workspace = true }
 hex-literal = { workspace = true }
-hyper = { workspace = true }
 itertools = { workspace = true }
 model = { workspace = true, features = ["e2e"] }
 number = { workspace = true }
diff --git a/crates/e2e/src/api/liquorice/server.rs b/crates/e2e/src/api/liquorice/server.rs
index 8e6096b1f9..0f7bc8892e 100644
--- a/crates/e2e/src/api/liquorice/server.rs
+++ b/crates/e2e/src/api/liquorice/server.rs
@@ -33,14 +33,13 @@ impl LiquoriceApi {
             .with_state(state.clone());
 
         let addr = SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0));
-        let server = axum::Server::bind(&addr).serve(app.into_make_service());
-
-        let addr = server.local_addr();
+        let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+        let addr = listener.local_addr().unwrap();
         let port = addr.port();
         assert!(port > 0, "assigned port must be greater than 0");
 
         tokio::spawn(async move {
-            if let Err(err) = server.await {
+            if let Err(err) = axum::serve(listener, app).await {
                 tracing::error!(?err, "Liquorice API server failed");
                 panic!("Liquorice test server crashed: {}", err);
             }
diff --git a/crates/e2e/src/api/zeroex.rs b/crates/e2e/src/api/zeroex.rs
index d78cab693b..9ee37560de 100644
--- a/crates/e2e/src/api/zeroex.rs
+++ b/crates/e2e/src/api/zeroex.rs
@@ -43,14 +43,13 @@ impl ZeroExApi {
             .with_state(state);
 
         let addr = SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0));
-        let server = axum::Server::bind(&addr).serve(app.into_make_service());
-
-        let addr = server.local_addr();
+        let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+        let addr = listener.local_addr().unwrap();
         let port = addr.port();
         assert!(port > 0, "assigned port must be greater than 0");
 
         tokio::spawn(async move {
-            if let Err(err) = server.await {
+            if let Err(err) = axum::serve(listener, app).await {
                 tracing::error!(?err, "ZeroEx API server failed");
                 panic!("ZeroEx test server crashed: {}", err);
             }
diff --git a/crates/e2e/src/setup/proxy.rs b/crates/e2e/src/setup/proxy.rs
index 85474f8ae3..6c8ca9962f 100644
--- a/crates/e2e/src/setup/proxy.rs
+++ b/crates/e2e/src/setup/proxy.rs
@@ -18,7 +18,6 @@ use {
         http::Request,
         response::{IntoResponse, Response},
     },
-    hyper::body::to_bytes,
     std::{collections::VecDeque, net::SocketAddr, sync::Arc},
     tokio::{sync::RwLock, task::JoinHandle},
     url::Url,
@@ -104,10 +103,8 @@ async fn serve(listen_addr: SocketAddr, backends: Vec<Url>, state: ProxyState) {
     let app = Router::new().fallback(proxy_handler);
 
     tracing::info!(?listen_addr, ?backends, "starting reverse proxy");
-    axum::Server::bind(&listen_addr)
-        .serve(app.into_make_service())
-        .await
-        .unwrap();
+    let listener = tokio::net::TcpListener::bind(listen_addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
 }
 
 async fn handle_request(
@@ -118,7 +115,8 @@ async fn handle_request(
     let (parts, body) = req.into_parts();
 
     // Convert body to bytes once for reuse across retries
-    let body_bytes = match to_bytes(body).await {
+    // SAFETY: usize::MAX is ok here because it's a test
+    let body_bytes = match axum::body::to_bytes(body, usize::MAX).await {
         Ok(bytes) => bytes,
         Err(err) => {
             return (
diff --git a/crates/e2e/src/setup/solver/mock.rs b/crates/e2e/src/setup/solver/mock.rs
index dc29236ff4..e98bf214f9 100644
--- a/crates/e2e/src/setup/solver/mock.rs
+++ b/crates/e2e/src/setup/solver/mock.rs
@@ -51,8 +51,8 @@ impl Mock {
     }
 }
 
-impl Default for Mock {
-    fn default() -> Self {
+impl Mock {
+    pub async fn new() -> Self {
         let state = State {
             solution: Arc::new(Mutex::new(Arc::new(|| async { None }.boxed()))),
             auctions: Arc::new(Mutex::new(vec![])),
@@ -62,17 +62,20 @@ impl Default for Mock {
             .route("/solve", axum::routing::post(solve))
             .with_state(state.clone());
 
-        let server =
-            axum::Server::bind(&"0.0.0.0:0".parse().unwrap()).serve(app.into_make_service());
-
-        let mock = Mock {
-            state,
-            url: format!("http://{}", server.local_addr()).parse().unwrap(),
-        };
+        let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
+        let local_addr = listener.local_addr().unwrap();
 
-        tokio::task::spawn(server.with_graceful_shutdown(shutdown_signal()));
+        tokio::task::spawn(async move {
+            axum::serve(listener, app)
+                .with_graceful_shutdown(shutdown_signal())
+                .await
+                .unwrap();
+        });
 
-        mock
+        Mock {
+            state,
+            url: format!("http://{}", local_addr).parse().unwrap(),
+        }
     }
 }
 
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 77987a81bf..237aad19e6 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -161,7 +161,7 @@ async fn cow_amm_jit(web3: Web3) {
     // for the actual solver competition. That way we can handcraft a solution
     // for this test and don't have to implement complete support for CoW AMMs
     // in the baseline solver.
-    let mock_solver = Mock::default();
+    let mock_solver = Mock::new().await;
     colocation::start_driver(
         onchain.contracts(),
         vec![
@@ -532,7 +532,7 @@ async fn cow_amm_driver_support(web3: Web3) {
     );
 
     // spawn a mock solver so we can later assert things about the received auction
-    let mock_solver = Mock::default();
+    let mock_solver = Mock::new().await;
     colocation::start_driver_with_config_override(
         onchain.contracts(),
         vec![
@@ -817,7 +817,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
 
     // Start system with the mocked solver. Baseline is still required for the
     // native price estimation.
-    let mock_solver = Mock::default();
+    let mock_solver = Mock::new().await;
     colocation::start_driver(
         onchain.contracts(),
         vec![
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index 146bb701b5..da51e0bb04 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -62,7 +62,7 @@ async fn single_limit_order_test(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
-    let mock_solver = Mock::default();
+    let mock_solver = Mock::new().await;
 
     // Start system
     colocation::start_driver(
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index 5e1e465904..abb5723efa 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -167,7 +167,7 @@ async fn liquidity_source_notification(web3: Web3) {
     let liquorice_api = api::liquorice::server::LiquoriceApi::start().await;
 
     // CoW services setup
-    let liquorice_solver_api_mock = Mock::default();
+    let liquorice_solver_api_mock = Mock::new().await;
     let services = Services::new(&onchain).await;
 
     colocation::start_driver_with_config_override(
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index c9839e8865..672ab5e097 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -276,7 +276,7 @@ async fn quote_timeout(web3: Web3) {
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
 
-    let mock_solver = Mock::default();
+    let mock_solver = Mock::new().await;
 
     // Start system
     colocation::start_driver(
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 0eb4951290..76f2b53956 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -367,8 +367,8 @@ async fn store_filtered_solutions(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
-    let good_solver = Mock::default();
-    let bad_solver = Mock::default();
+    let good_solver = Mock::new().await;
+    let bad_solver = Mock::new().await;
 
     // Start system
     let base_tokens = vec![*token_a.address(), *token_b.address(), *token_c.address()];
diff --git a/crates/observe/src/metrics.rs b/crates/observe/src/metrics.rs
index bae2b1ec2e..9b427e6312 100644
--- a/crates/observe/src/metrics.rs
+++ b/crates/observe/src/metrics.rs
@@ -116,8 +116,10 @@ pub fn serve_metrics(
 
     tracing::info!(%address, "serving metrics");
     tokio::spawn(async move {
-        axum::Server::bind(&address)
-            .serve(app.into_make_service())
+        let listener = tokio::net::TcpListener::bind(address)
+            .await
+            .expect("failed to bind metrics server");
+        axum::serve(listener, app)
             .await
             .expect("failed to serve metrics")
     })
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 936b89986d..0b688bdc8c 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -33,7 +33,6 @@ futures = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
-hyper = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 tikv-jemallocator = { workspace = true }
 model = { workspace = true }
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 7123b5a0e0..30d0fed648 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -9,11 +9,10 @@ use {
     axum::{
         Router,
         extract::DefaultBodyLimit,
-        http::{Request, StatusCode},
+        http::{Request, StatusCode, header::USER_AGENT},
         middleware::{self, Next},
         response::{IntoResponse, Json, Response},
     },
-    hyper::header::USER_AGENT,
     observe::distributed_tracing::tracing_axum::{self, record_trace_id},
     serde::{Deserialize, Serialize},
     shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
@@ -68,10 +67,7 @@ pub struct AppState {
     pub quote_timeout: Duration,
 }
 
-async fn summarize_request(
-    req: Request<axum::body::Body>,
-    next: Next<axum::body::Body>,
-) -> Response {
+async fn summarize_request(req: Request<axum::body::Body>, next: Next) -> Response {
     let method = req.method().to_string();
     let uri = req.uri().to_string();
 
@@ -99,10 +95,7 @@ async fn summarize_request(
 }
 
 /// Middleware that automatically tracks metrics using Axum's MatchedPath
-async fn with_matched_path_metric(
-    req: Request<axum::body::Body>,
-    next: Next<axum::body::Body>,
-) -> Response {
+async fn with_matched_path_metric(req: Request<axum::body::Body>, next: Next) -> Response {
     let metrics = ApiMetrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
     // Extract matched path and HTTP method
@@ -165,7 +158,7 @@ pub fn handle_all_routes(
     let routes = [
         // V1 routes
         (
-            "/api/v1/account/:owner/orders",
+            "/api/v1/account/{owner}/orders",
             axum::routing::get(get_user_orders::get_user_orders_handler),
         ),
         (
@@ -174,7 +167,7 @@ pub fn handle_all_routes(
                 .layer(DefaultBodyLimit::max(app_data_size_limit)),
         ),
         (
-            "/api/v1/app_data/:hash",
+            "/api/v1/app_data/{hash}",
             axum::routing::get(get_app_data::get_app_data_handler).merge(
                 axum::routing::put(put_app_data::put_app_data_with_hash)
                     .layer(DefaultBodyLimit::max(app_data_size_limit)),
@@ -190,12 +183,12 @@ pub fn handle_all_routes(
                 .merge(axum::routing::delete(cancel_orders::cancel_orders_handler)),
         ),
         (
-            "/api/v1/orders/:uid",
+            "/api/v1/orders/{uid}",
             axum::routing::get(get_order_by_uid::get_order_by_uid_handler)
                 .merge(axum::routing::delete(cancel_order::cancel_order_handler)),
         ),
         (
-            "/api/v1/orders/:uid/status",
+            "/api/v1/orders/{uid}/status",
             axum::routing::get(get_order_status::get_status_handler),
         ),
         (
@@ -208,19 +201,19 @@ pub fn handle_all_routes(
             axum::routing::get(get_solver_competition::get_solver_competition_latest_handler),
         ),
         (
-            "/api/v1/solver_competition/by_tx_hash/:tx_hash",
+            "/api/v1/solver_competition/by_tx_hash/{tx_hash}",
             axum::routing::get(get_solver_competition::get_solver_competition_by_hash_handler),
         ),
         (
-            "/api/v1/solver_competition/:auction_id",
+            "/api/v1/solver_competition/{auction_id}",
             axum::routing::get(get_solver_competition::get_solver_competition_by_id_handler),
         ),
         (
-            "/api/v1/token/:token/metadata",
+            "/api/v1/token/{token}/metadata",
             axum::routing::get(get_token_metadata::get_token_metadata_handler),
         ),
         (
-            "/api/v1/token/:token/native_price",
+            "/api/v1/token/{token}/native_price",
             axum::routing::get(get_native_price::get_native_price_handler),
         ),
         (
@@ -228,11 +221,11 @@ pub fn handle_all_routes(
             axum::routing::get(get_trades::get_trades_handler),
         ),
         (
-            "/api/v1/transactions/:hash/orders",
+            "/api/v1/transactions/{hash}/orders",
             axum::routing::get(get_orders_by_tx::get_orders_by_tx_handler),
         ),
         (
-            "/api/v1/users/:user/total_surplus",
+            "/api/v1/users/{user}/total_surplus",
             axum::routing::get(get_total_surplus::get_total_surplus_handler),
         ),
         (
@@ -246,11 +239,11 @@ pub fn handle_all_routes(
             axum::routing::get(get_solver_competition_v2::get_solver_competition_latest_handler),
         ),
         (
-            "/api/v2/solver_competition/by_tx_hash/:tx_hash",
+            "/api/v2/solver_competition/by_tx_hash/{tx_hash}",
             axum::routing::get(get_solver_competition_v2::get_solver_competition_by_hash_handler),
         ),
         (
-            "/api/v2/solver_competition/:auction_id",
+            "/api/v2/solver_competition/{auction_id}",
             axum::routing::get(get_solver_competition_v2::get_solver_competition_by_id_handler),
         ),
         (
@@ -439,19 +432,12 @@ impl IntoResponse for LoadSolverCompetitionError {
 }
 
 #[cfg(test)]
-pub async fn response_body<B>(response: axum::http::Response<B>) -> Vec<u8>
-where
-    B: axum::body::HttpBody + Unpin,
-    B::Data: AsRef<[u8]>,
-    B::Error: Debug,
-{
-    let mut body = response.into_body();
-    let mut result = Vec::new();
-    while let Some(frame) = body.data().await {
-        let bytes = frame.unwrap();
-        result.extend_from_slice(bytes.as_ref());
-    }
-    result
+pub async fn response_body(response: axum::http::Response<axum::body::Body>) -> Vec<u8> {
+    // SAFETY: usize::MAX is ok here because it's a test
+    axum::body::to_bytes(response.into_body(), usize::MAX)
+        .await
+        .unwrap()
+        .to_vec()
 }
 
 #[cfg(test)]
@@ -489,8 +475,6 @@ mod tests {
 
     #[tokio::test]
     async fn rich_errors_handle_serialization_errors() {
-        use axum::body::HttpBody;
-
         struct AlwaysErrors;
         impl Serialize for AlwaysErrors {
             fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
@@ -502,12 +486,10 @@ mod tests {
         }
 
         let response = rich_error("foo", "bar", AlwaysErrors).into_response();
-        let mut body = response.into_body();
-        let mut bytes = Vec::new();
-        while let Some(frame) = body.data().await {
-            let chunk = frame.unwrap();
-            bytes.extend_from_slice(&chunk);
-        }
+        // SAFETY: usize::MAX is ok here because it's a test
+        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
+            .await
+            .unwrap();
 
         assert_eq!(
             serde_json::from_slice::<serde_json::Value>(&bytes).unwrap(),
diff --git a/crates/orderbook/src/api/cancel_orders.rs b/crates/orderbook/src/api/cancel_orders.rs
index 4c6f8e47e5..a44ae215de 100644
--- a/crates/orderbook/src/api/cancel_orders.rs
+++ b/crates/orderbook/src/api/cancel_orders.rs
@@ -5,9 +5,9 @@ use {
         Json,
         body,
         extract::State,
+        http::StatusCode,
         response::{IntoResponse, Response},
     },
-    hyper::StatusCode,
     model::order::{ORDER_UID_LIMIT, SignedOrderCancellations},
     std::sync::Arc,
 };
diff --git a/crates/orderbook/src/api/get_solver_competition.rs b/crates/orderbook/src/api/get_solver_competition.rs
index 4335160139..7be9e6ef0d 100644
--- a/crates/orderbook/src/api/get_solver_competition.rs
+++ b/crates/orderbook/src/api/get_solver_competition.rs
@@ -68,8 +68,7 @@ pub async fn get_solver_competition_latest_handler(
 mod tests {
     use {
         crate::solver_competition::LoadSolverCompetitionError,
-        axum::response::IntoResponse,
-        hyper::StatusCode,
+        axum::{http::StatusCode, response::IntoResponse},
     };
 
     #[tokio::test]
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 8ab767e4eb..950c157b46 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -473,12 +473,18 @@ fn serve_api(
     );
     tracing::info!(%address, "serving order book");
 
-    let server = axum::Server::bind(&address)
-        .serve(app.into_make_service())
-        .with_graceful_shutdown(shutdown_receiver);
-
     task::spawn(async move {
-        if let Err(err) = server.await {
+        let listener = match tokio::net::TcpListener::bind(address).await {
+            Ok(listener) => listener,
+            Err(err) => {
+                tracing::error!(?err, "failed to bind server");
+                return;
+            }
+        };
+        if let Err(err) = axum::serve(listener, app)
+            .with_graceful_shutdown(shutdown_receiver)
+            .await
+        {
             tracing::error!(?err, "server error");
         }
     })
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index 8467f88614..fba01b7051 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -23,7 +23,6 @@ const-hex = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-hyper = { workspace = true }
 itertools = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 num = { workspace = true }
diff --git a/crates/solvers/src/api/mod.rs b/crates/solvers/src/api/mod.rs
index 734365291c..dbb363cd5d 100644
--- a/crates/solvers/src/api/mod.rs
+++ b/crates/solvers/src/api/mod.rs
@@ -21,7 +21,7 @@ impl Api {
         self,
         bind: Option<oneshot::Sender<SocketAddr>>,
         shutdown: impl Future<Output = ()> + Send + 'static,
-    ) -> Result<(), hyper::Error> {
+    ) -> Result<(), std::io::Error> {
         let app = axum::Router::new()
             .layer(tower::ServiceBuilder::new().layer(
                 tower_http::limit::RequestBodyLimitLayer::new(REQUEST_BODY_LIMIT),
@@ -38,11 +38,13 @@ impl Api {
             // axum's default body limit needs to be disabled to not have the default limit on top of our custom limit
             .layer(axum::extract::DefaultBodyLimit::disable());
 
-        let server = axum::Server::bind(&self.addr).serve(app.into_make_service());
+        let listener = tokio::net::TcpListener::bind(self.addr).await?;
         if let Some(bind) = bind {
-            let _ = bind.send(server.local_addr());
+            let _ = bind.send(listener.local_addr()?);
         }
 
-        server.with_graceful_shutdown(shutdown).await
+        axum::serve(listener, app)
+            .with_graceful_shutdown(shutdown)
+            .await
     }
 }

From 65450c5919ac3d8d84656823a1fcf1d6f23a5db5 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 18 Feb 2026 11:49:26 +0000
Subject: [PATCH 073/219] Orderbook native price estimators fallback (#4161)

# Background
The orderbook's native price estimator is currently configured to use a
Forwarder estimator, which is basically the Autopilot's API. In case
Autopilot is down, quote competition can't proceed without native
prices, and no new orders can be placed during that time.

# Description
Adds an optional fallback native price estimator that kicks in when the
primary estimator experiences sustained failures. This protects native
price availability during primary estimator outages.

The fallback estimator tracks consecutive `ProtocolInternal` errors from
the primary. After a configurable threshold (3 errors), it switches to
the fallback estimator and periodically probes the primary to detect
recovery.

# Changes
- New `FallbackNativePriceEstimator`, which wraps a primary and fallback
estimator with automatic failover logic:
  - Tracks consecutive `ProtocolInternal` errors on the primary
  - Switches to fallback after 3 consecutive errors
  - Probes primary every 60s while in fallback mode
- Recovers to primary when a probe succeeds, otherwise, continue using
the fallback
- `Forwarder` error mapping: HTTP send failures now return
`ProtocolInternal` instead of a generic error, so the fallback estimator
can detect them
- New CLI argument `--native-price-estimators-fallback` on the orderbook
to optionally configure fallback estimators
- New factory method `caching_native_price_estimator_from_inner` to
allow injecting a pre-built inner estimator (with fallback wrapping)
into the caching layer

## How to test
New unit and e2e tests.
---
 .../e2e/tests/e2e/place_order_with_quote.rs   | 177 +++++-
 crates/orderbook/src/arguments.rs             |  10 +
 crates/orderbook/src/run.rs                   |  33 +-
 crates/shared/src/price_estimation/factory.rs |  11 +
 .../src/price_estimation/native/fallback.rs   | 532 ++++++++++++++++++
 .../src/price_estimation/native/forwarder.rs  |   6 +-
 .../shared/src/price_estimation/native/mod.rs |   8 +-
 7 files changed, 766 insertions(+), 11 deletions(-)
 create mode 100644 crates/shared/src/price_estimation/native/fallback.rs

diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 47d7808297..d5e4ea6d6a 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -1,7 +1,14 @@
 use {
     ::alloy::primitives::U256,
+    autopilot::{
+        config::{
+            Configuration,
+            solver::{Account, Solver},
+        },
+        shutdown_controller::ShutdownController,
+    },
     driver::domain::eth::NonZeroU256,
-    e2e::setup::*,
+    e2e::setup::{colocation, wait_for_condition, *},
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     model::{
         order::{OrderCreation, OrderKind},
@@ -10,7 +17,8 @@ use {
     },
     number::units::EthUnit,
     shared::web3::Web3,
-    std::ops::DerefMut,
+    std::{ops::DerefMut, str::FromStr},
+    url::Url,
 };
 
 #[tokio::test]
@@ -25,6 +33,12 @@ async fn local_node_disabled_same_sell_and_buy_token_order_feature() {
     run_test(disabled_same_sell_and_buy_token_order_feature).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_fallback_native_price_estimator() {
+    run_test(fallback_native_price_estimator).await;
+}
+
 async fn place_order_with_quote(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -162,3 +176,162 @@ async fn disabled_same_sell_and_buy_token_order_feature(web3: Web3) {
         matches!(services.submit_quote(&quote_request).await, Err((reqwest::StatusCode::BAD_REQUEST, response)) if response.contains("SameBuyAndSellToken"))
     );
 }
+
+async fn fallback_native_price_estimator(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 6u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(6u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![
+            colocation::start_baseline_solver(
+                "test_solver".into(),
+                solver.clone(),
+                *onchain.contracts().weth.address(),
+                vec![],
+                1,
+                true,
+            )
+            .await,
+        ],
+        colocation::LiquidityProvider::UniswapV2,
+        false,
+    );
+
+    let (manual_shutdown, control) = ShutdownController::new_manual_shutdown();
+    let autopilot_config_file = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+            Account::Address(solver.address()),
+        )],
+    }
+    .to_temp_path();
+    let autopilot_handle = services
+        .start_autopilot_with_shutdown_controller(
+            None,
+            vec![
+                format!("--config={}", autopilot_config_file.path().display()),
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+            ],
+            control,
+        )
+        .await;
+
+    services
+        .start_api(vec![
+            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
+            "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+            "--native-price-estimators-fallback=Driver|test_quoter|http://localhost:11088/test_solver"
+                .to_string(),
+            "--native-price-cache-max-age=2s".to_string(),
+        ])
+        .await;
+
+    tracing::info!("Quoting with autopilot running");
+    let quote_sell_amount = 1u64.eth();
+    let quote_request = OrderQuoteRequest {
+        from: trader.address(),
+        sell_token: *onchain.contracts().weth.address(),
+        buy_token: *token.address(),
+        side: OrderQuoteSide::Sell {
+            sell_amount: SellAmount::BeforeFee {
+                value: NonZeroU256::try_from(quote_sell_amount).unwrap(),
+            },
+        },
+        ..Default::default()
+    };
+    let quote_response = services.submit_quote(&quote_request).await.unwrap();
+    tracing::debug!(?quote_response);
+    assert!(quote_response.id.is_some());
+
+    tracing::info!("Placing order with autopilot running");
+    let order = OrderCreation {
+        quote_id: quote_response.id,
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: quote_sell_amount,
+        buy_token: *token.address(),
+        buy_amount: quote_response.quote.buy_amount,
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Sell,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    services.create_order(&order).await.unwrap();
+
+    tracing::info!("Shutting down autopilot");
+    manual_shutdown.shutdown();
+    wait_for_condition(TIMEOUT, || async {
+        onchain.mint_block().await;
+        autopilot_handle.is_finished()
+    })
+    .await
+    .unwrap();
+
+    // Wait for native price cache to expire (max age = 2s)
+    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+
+    // The FallbackNativePriceEstimator switches to fallback after 3 consecutive
+    // ProtocolInternal errors from the primary (forwarder → dead autopilot).
+    tracing::info!("Waiting for native price fallback to activate");
+    wait_for_condition(TIMEOUT, || async {
+        services.get_native_price(token.address()).await.is_ok()
+    })
+    .await
+    .unwrap();
+
+    tracing::info!("Quoting after autopilot shutdown (via fallback)");
+    let quote_response = services.submit_quote(&quote_request).await.unwrap();
+    tracing::debug!(?quote_response);
+    assert!(quote_response.id.is_some());
+
+    tracing::info!("Placing order after autopilot shutdown (via fallback)");
+    let order = OrderCreation {
+        quote_id: quote_response.id,
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: quote_sell_amount,
+        buy_token: *token.address(),
+        buy_amount: quote_response.quote.buy_amount,
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Sell,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    services.create_order(&order).await.unwrap();
+}
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index 9f40f7a120..ce2308f6a3 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -87,6 +87,11 @@ pub struct Arguments {
     #[clap(long, env)]
     pub native_price_estimators: NativePriceEstimators,
 
+    /// Fallback native price estimators to use when all primary estimators
+    /// are down.
+    #[clap(long, env)]
+    pub native_price_estimators_fallback: Option<NativePriceEstimators>,
+
     /// How many successful price estimates for each order will cause a fast
     /// or native price estimation to return its result early.
     /// The bigger the value the more the fast price estimation performs like
@@ -173,6 +178,7 @@ impl std::fmt::Display for Arguments {
             banned_users_max_cache_size,
             eip1271_skip_creation_validation,
             native_price_estimators,
+            native_price_estimators_fallback,
             fast_price_estimation_results_required,
             max_limit_orders_per_user,
             ipfs_gateway,
@@ -218,6 +224,10 @@ impl std::fmt::Display for Arguments {
             "eip1271_skip_creation_validation: {eip1271_skip_creation_validation}"
         )?;
         writeln!(f, "native_price_estimators: {native_price_estimators}")?;
+        writeln!(
+            f,
+            "native_price_estimators_fallback: {native_price_estimators_fallback:?}"
+        )?;
         writeln!(
             f,
             "fast_price_estimation_results_required: {fast_price_estimation_results_required}"
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 950c157b46..3de44aa8e8 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -38,7 +38,7 @@ use {
             PriceEstimating,
             QuoteVerificationMode,
             factory::{self, PriceEstimatorFactory},
-            native::NativePriceEstimating,
+            native::{FallbackNativePriceEstimator, NativePriceEstimating},
         },
         signature_validator,
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
@@ -238,14 +238,33 @@ pub async fn run(args: Arguments) {
         args.price_estimation.native_price_cache_max_age,
         prices,
     );
+    let primary = price_estimator_factory
+        .native_price_estimator(
+            args.native_price_estimators.as_slice(),
+            args.fast_price_estimation_results_required,
+            &native_token,
+        )
+        .await
+        .expect("failed to build primary native price estimator");
+
+    let inner: Box<dyn NativePriceEstimating> =
+        if let Some(ref fallback_config) = args.native_price_estimators_fallback {
+            let fallback = price_estimator_factory
+                .native_price_estimator(
+                    fallback_config.as_slice(),
+                    args.fast_price_estimation_results_required,
+                    &native_token,
+                )
+                .await
+                .expect("failed to build fallback native price estimator");
+            Box::new(FallbackNativePriceEstimator::new(primary, fallback))
+        } else {
+            primary
+        };
+
     let native_price_estimator: Arc<dyn NativePriceEstimating> = Arc::new(
         price_estimator_factory
-            .caching_native_price_estimator(
-                args.native_price_estimators.as_slice(),
-                args.fast_price_estimation_results_required,
-                &native_token,
-                cache,
-            )
+            .caching_native_price_estimator_from_inner(inner, cache)
             .await,
     );
 
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index f46a9c8767..be2f83e5d7 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -393,6 +393,17 @@ impl<'a> PriceEstimatorFactory<'a> {
             .native_price_estimator(native, results_required, weth)
             .await
             .expect("failed to build native price estimator");
+        self.caching_native_price_estimator_from_inner(inner, cache)
+            .await
+    }
+
+    /// Creates a [`CachingNativePriceEstimator`] from a pre-built inner
+    /// estimator.
+    pub async fn caching_native_price_estimator_from_inner(
+        &mut self,
+        inner: Box<dyn NativePriceEstimating>,
+        cache: native_price_cache::Cache,
+    ) -> native_price_cache::CachingNativePriceEstimator {
         let approximation_tokens = self
             .build_approximation_tokens()
             .await
diff --git a/crates/shared/src/price_estimation/native/fallback.rs b/crates/shared/src/price_estimation/native/fallback.rs
new file mode 100644
index 0000000000..0e83aa7727
--- /dev/null
+++ b/crates/shared/src/price_estimation/native/fallback.rs
@@ -0,0 +1,532 @@
+//! A native price estimator wrapper that automatically switches to a fallback
+//! estimator when the primary becomes unavailable.
+//!
+//! # State Machine
+//!
+//! The estimator operates as a two-state machine:
+//!
+//! ```text
+//!                  3 consecutive
+//!                ProtocolInternal errors
+//!   ┌─────────┐ ───────────────────────> ┌──────────┐
+//!   │ Primary │                          │ Fallback │
+//!   └─────────┘ <─────────────────────── └──────────┘
+//!                  probe succeeds
+//!               (every PROBE_INTERVAL)
+//! ```
+//!
+//! **Primary state**: All requests go to the primary estimator. A counter
+//! tracks consecutive [`PriceEstimationError::ProtocolInternal`] errors. Any
+//! success resets the counter. Once the counter reaches
+//! [`CONSECUTIVE_ERRORS_THRESHOLD`], the estimator switches to fallback and
+//! the current request is retried against the fallback.
+//!
+//! **Fallback state**: All requests go to the fallback estimator. Every
+//! [`PROBE_INTERVAL`], one request probes both the primary and fallback
+//! concurrently. If the primary probe succeeds, the estimator switches back to
+//! primary; otherwise it stays in fallback and resets the probe timer.
+//!
+//! Only `ProtocolInternal` errors (e.g. connection refused, timeouts) trigger
+//! the switch. Domain errors like `NoLiquidity` do not affect the state.
+
+use {
+    super::{NativePriceEstimateResult, NativePriceEstimating},
+    crate::price_estimation::PriceEstimationError,
+    alloy::primitives::Address,
+    futures::{FutureExt, future::BoxFuture},
+    std::{
+        sync::Mutex,
+        time::{Duration, Instant},
+    },
+};
+
+/// How often the estimator probes the primary while in fallback state.
+const PROBE_INTERVAL: Duration = Duration::from_secs(60);
+
+/// Number of consecutive `ProtocolInternal` errors from the primary before
+/// switching to fallback.
+const CONSECUTIVE_ERRORS_THRESHOLD: u32 = 3;
+
+enum State {
+    Primary {
+        /// Counts consecutive protocol internal errors from the primary
+        /// estimator.
+        consecutive_errors: u32,
+    },
+    Fallback {
+        /// Tracks when we last tried the primary.
+        last_probe: Instant,
+    },
+}
+
+/// What the estimator should do for the current request based on the current
+/// state and probe timing.
+enum Action {
+    /// Use the primary estimator.
+    Primary,
+    /// Use the fallback estimator directly (within probe interval).
+    Fallback,
+    /// Probe both primary and fallback concurrently (probe interval elapsed).
+    Probe,
+}
+
+/// Wraps a primary and fallback [`NativePriceEstimating`] implementation,
+/// automatically switching to the fallback when the primary experiences
+/// repeated `ProtocolInternal` failures and periodically probing to recover.
+pub struct FallbackNativePriceEstimator {
+    primary: Box<dyn NativePriceEstimating>,
+    fallback: Box<dyn NativePriceEstimating>,
+    state: Mutex<State>,
+}
+
+impl FallbackNativePriceEstimator {
+    pub fn new(
+        primary: Box<dyn NativePriceEstimating>,
+        fallback: Box<dyn NativePriceEstimating>,
+    ) -> Self {
+        Self {
+            primary,
+            fallback,
+            state: Mutex::new(State::Primary {
+                consecutive_errors: 0,
+            }),
+        }
+    }
+}
+
+impl FallbackNativePriceEstimator {
+    /// Returns `true` if the fallback should be used.
+    fn should_use_fallback(&self, result: &NativePriceEstimateResult) -> bool {
+        let Err(PriceEstimationError::ProtocolInternal(err)) = result else {
+            if let State::Primary {
+                consecutive_errors, ..
+            } = &mut *self.state.lock().unwrap()
+            {
+                *consecutive_errors = 0;
+            }
+            return false;
+        };
+
+        let (use_fallback, consecutive_errors) = {
+            let mut state = self.state.lock().unwrap();
+            let State::Primary {
+                consecutive_errors, ..
+            } = &mut *state
+            else {
+                return false;
+            };
+            *consecutive_errors += 1;
+            let count = *consecutive_errors;
+            if count >= CONSECUTIVE_ERRORS_THRESHOLD {
+                *state = State::Fallback {
+                    last_probe: Instant::now(),
+                };
+                (true, count)
+            } else {
+                (false, count)
+            }
+        };
+
+        if use_fallback {
+            tracing::info!(
+                ?err,
+                consecutive_errors,
+                "primary native price estimator down, switching to fallback"
+            );
+        } else {
+            tracing::debug!(
+                ?err,
+                consecutive_errors,
+                "primary native price estimator error, not yet switching to fallback"
+            );
+        }
+        use_fallback
+    }
+
+    fn next_action(&self) -> Action {
+        let mut state = self.state.lock().unwrap();
+        match &mut *state {
+            State::Primary { .. } => Action::Primary,
+            State::Fallback { last_probe } if last_probe.elapsed() >= PROBE_INTERVAL => {
+                // Update immediately to prevent concurrent requests from also
+                // probing (thundering herd).
+                *last_probe = Instant::now();
+                Action::Probe
+            }
+            State::Fallback { .. } => Action::Fallback,
+        }
+    }
+
+    async fn estimate_with_primary(
+        &self,
+        token: Address,
+        timeout: Duration,
+    ) -> NativePriceEstimateResult {
+        let result = self.primary.estimate_native_price(token, timeout).await;
+        if self.should_use_fallback(&result) {
+            self.fallback.estimate_native_price(token, timeout).await
+        } else {
+            result
+        }
+    }
+
+    async fn estimate_with_probe(
+        &self,
+        token: Address,
+        timeout: Duration,
+    ) -> NativePriceEstimateResult {
+        let (primary_result, fallback_result) = futures::join!(
+            self.primary.estimate_native_price(token, timeout),
+            self.fallback.estimate_native_price(token, timeout),
+        );
+
+        if matches!(
+            &primary_result,
+            Err(PriceEstimationError::ProtocolInternal(_))
+        ) {
+            {
+                let mut state = self.state.lock().unwrap();
+                *state = State::Fallback {
+                    last_probe: Instant::now(),
+                };
+            }
+            tracing::debug!("primary still down after probe, continuing with fallback");
+            fallback_result
+        } else {
+            {
+                let mut state = self.state.lock().unwrap();
+                *state = State::Primary {
+                    consecutive_errors: 0,
+                };
+            }
+            tracing::info!("primary native price estimator recovered");
+            primary_result
+        }
+    }
+}
+
+impl NativePriceEstimating for FallbackNativePriceEstimator {
+    fn estimate_native_price(
+        &self,
+        token: Address,
+        timeout: Duration,
+    ) -> BoxFuture<'_, NativePriceEstimateResult> {
+        async move {
+            match self.next_action() {
+                Action::Primary => self.estimate_with_primary(token, timeout).await,
+                Action::Probe => self.estimate_with_probe(token, timeout).await,
+                Action::Fallback => self.fallback.estimate_native_price(token, timeout).await,
+            }
+        }
+        .boxed()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        crate::price_estimation::native::MockNativePriceEstimating,
+        futures::FutureExt,
+    };
+
+    const TOKEN: Address = Address::with_last_byte(1);
+    const TIMEOUT: Duration = Duration::from_secs(5);
+
+    #[tokio::test]
+    async fn uses_primary_when_healthy() {
+        let mut primary = MockNativePriceEstimating::new();
+        primary
+            .expect_estimate_native_price()
+            .returning(|_, _| async { Ok(1.0) }.boxed());
+
+        let mut fallback = MockNativePriceEstimating::new();
+        fallback.expect_estimate_native_price().never();
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 1.0);
+    }
+
+    #[tokio::test]
+    async fn switches_to_fallback_on_protocol_internal() {
+        let mut primary = MockNativePriceEstimating::new();
+        primary
+            .expect_estimate_native_price()
+            .times(3)
+            .returning(|_, _| {
+                async {
+                    Err(PriceEstimationError::ProtocolInternal(anyhow::anyhow!(
+                        "connection refused"
+                    )))
+                }
+                .boxed()
+            });
+
+        let mut fallback = MockNativePriceEstimating::new();
+        fallback
+            .expect_estimate_native_price()
+            .times(1)
+            .returning(|_, _| async { Ok(2.0) }.boxed());
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        // First two errors: stay in primary, return the error
+        for _ in 0..2 {
+            let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+            assert!(matches!(
+                result,
+                Err(PriceEstimationError::ProtocolInternal(_))
+            ));
+        }
+
+        // Third error: threshold reached, switch to fallback
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 2.0);
+    }
+
+    #[tokio::test]
+    async fn stays_in_fallback_without_probing_before_interval() {
+        let mut primary = MockNativePriceEstimating::new();
+        // Called 3 times (threshold) for the initial failures, NOT called again before
+        // probe interval
+        primary
+            .expect_estimate_native_price()
+            .times(3)
+            .returning(|_, _| {
+                async {
+                    Err(PriceEstimationError::ProtocolInternal(anyhow::anyhow!(
+                        "connection refused"
+                    )))
+                }
+                .boxed()
+            });
+
+        let mut fallback = MockNativePriceEstimating::new();
+        // Called once when threshold is reached, once for the subsequent request
+        fallback
+            .expect_estimate_native_price()
+            .times(2)
+            .returning(|_, _| async { Ok(2.0) }.boxed());
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        // First two calls: primary errors returned (below threshold)
+        for _ in 0..2 {
+            let _ = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        }
+
+        // Third call: threshold reached, triggers fallback
+        let _ = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+
+        // Fourth call should use fallback directly (within probe interval)
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 2.0);
+    }
+
+    #[tokio::test]
+    async fn probes_primary_after_interval_and_recovers() {
+        let mut primary = MockNativePriceEstimating::new();
+        let mut call_count = 0u32;
+        primary
+            .expect_estimate_native_price()
+            .times(4) // 3 for threshold + 1 probe
+            .returning(move |_, _| {
+                call_count += 1;
+                if call_count <= 3 {
+                    // First 3 calls: primary is down (reaching threshold)
+                    async {
+                        Err(PriceEstimationError::ProtocolInternal(anyhow::anyhow!(
+                            "connection refused"
+                        )))
+                    }
+                    .boxed()
+                } else {
+                    // Fourth call (probe): primary recovered
+                    async { Ok(1.0) }.boxed()
+                }
+            });
+
+        let mut fallback = MockNativePriceEstimating::new();
+        // Called once when threshold is reached + once during probe (concurrent)
+        fallback
+            .expect_estimate_native_price()
+            .times(2)
+            .returning(|_, _| async { Ok(2.0) }.boxed());
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        // First two calls: primary errors returned (below threshold)
+        for _ in 0..2 {
+            let _ = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        }
+
+        // Third call: threshold reached, triggers fallback
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 2.0);
+
+        // Force probe interval to expire
+        {
+            let mut state = estimator.state.lock().unwrap();
+            *state = State::Fallback {
+                last_probe: Instant::now() - PROBE_INTERVAL - Duration::from_secs(1),
+            };
+        }
+
+        // This call should probe primary (which recovers) and return primary result
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 1.0);
+    }
+
+    #[tokio::test]
+    async fn probes_primary_after_interval_stays_in_fallback_if_still_down() {
+        let mut primary = MockNativePriceEstimating::new();
+        primary.expect_estimate_native_price().returning(|_, _| {
+            async {
+                Err(PriceEstimationError::ProtocolInternal(anyhow::anyhow!(
+                    "connection refused"
+                )))
+            }
+            .boxed()
+        });
+
+        let mut fallback = MockNativePriceEstimating::new();
+        fallback
+            .expect_estimate_native_price()
+            .returning(|_, _| async { Ok(2.0) }.boxed());
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        // First two calls: primary errors (below threshold)
+        for _ in 0..2 {
+            let _ = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        }
+
+        // Third call: threshold reached, triggers fallback
+        let _ = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+
+        // Force probe interval to expire
+        {
+            let mut state = estimator.state.lock().unwrap();
+            *state = State::Fallback {
+                last_probe: Instant::now() - PROBE_INTERVAL - Duration::from_secs(1),
+            };
+        }
+
+        // Probe fires, primary still down → use fallback result
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 2.0);
+    }
+
+    #[tokio::test]
+    async fn does_not_switch_on_fewer_than_threshold_errors() {
+        let mut primary = MockNativePriceEstimating::new();
+        let mut call_count = 0u32;
+        primary
+            .expect_estimate_native_price()
+            .times(3)
+            .returning(move |_, _| {
+                call_count += 1;
+                if call_count <= 2 {
+                    async {
+                        Err(PriceEstimationError::ProtocolInternal(anyhow::anyhow!(
+                            "transient error"
+                        )))
+                    }
+                    .boxed()
+                } else {
+                    // Third call: primary recovers before threshold
+                    async { Ok(1.0) }.boxed()
+                }
+            });
+
+        let mut fallback = MockNativePriceEstimating::new();
+        fallback.expect_estimate_native_price().never();
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        // Two errors: below threshold, stay in primary
+        for _ in 0..2 {
+            let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+            assert!(matches!(
+                result,
+                Err(PriceEstimationError::ProtocolInternal(_))
+            ));
+        }
+
+        // Third call: primary succeeds, fallback never used
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 1.0);
+    }
+
+    #[tokio::test]
+    async fn resets_counter_on_success() {
+        let mut primary = MockNativePriceEstimating::new();
+        let mut call_count = 0u32;
+        primary
+            .expect_estimate_native_price()
+            .times(4)
+            .returning(move |_, _| {
+                call_count += 1;
+                match call_count {
+                    // error, success, error, error — never reaches 3 consecutive
+                    1 | 3 | 4 => async {
+                        Err(PriceEstimationError::ProtocolInternal(anyhow::anyhow!(
+                            "transient error"
+                        )))
+                    }
+                    .boxed(),
+                    2 => async { Ok(1.0) }.boxed(),
+                    _ => unreachable!(),
+                }
+            });
+
+        let mut fallback = MockNativePriceEstimating::new();
+        fallback.expect_estimate_native_price().never();
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        // Call 1: error (consecutive_errors = 1)
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert!(matches!(
+            result,
+            Err(PriceEstimationError::ProtocolInternal(_))
+        ));
+
+        // Call 2: success (consecutive_errors reset to 0)
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert_eq!(result.unwrap(), 1.0);
+
+        // Call 3: error (consecutive_errors = 1)
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert!(matches!(
+            result,
+            Err(PriceEstimationError::ProtocolInternal(_))
+        ));
+
+        // Call 4: error (consecutive_errors = 2, still below threshold)
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert!(matches!(
+            result,
+            Err(PriceEstimationError::ProtocolInternal(_))
+        ));
+    }
+
+    #[tokio::test]
+    async fn does_not_switch_on_non_protocol_errors() {
+        let mut primary = MockNativePriceEstimating::new();
+        primary
+            .expect_estimate_native_price()
+            .times(1)
+            .returning(|_, _| async { Err(PriceEstimationError::NoLiquidity) }.boxed());
+
+        let mut fallback = MockNativePriceEstimating::new();
+        fallback.expect_estimate_native_price().never();
+
+        let estimator = FallbackNativePriceEstimator::new(Box::new(primary), Box::new(fallback));
+
+        let result = estimator.estimate_native_price(TOKEN, TIMEOUT).await;
+        assert!(matches!(result, Err(PriceEstimationError::NoLiquidity)));
+    }
+}
diff --git a/crates/shared/src/price_estimation/native/forwarder.rs b/crates/shared/src/price_estimation/native/forwarder.rs
index 28089b9a1a..bfff0073a2 100644
--- a/crates/shared/src/price_estimation/native/forwarder.rs
+++ b/crates/shared/src/price_estimation/native/forwarder.rs
@@ -43,7 +43,11 @@ impl Forwarder {
         if let Some(id) = observe::distributed_tracing::request_id::from_current_span() {
             request = request.header("X-REQUEST-ID", id);
         }
-        let response = request.send().await.context("failed to send request")?;
+        let response = request.send().await.map_err(|err| {
+            PriceEstimationError::ProtocolInternal(
+                anyhow::Error::new(err).context("failed to send request"),
+            )
+        })?;
 
         match response.status() {
             StatusCode::OK => {
diff --git a/crates/shared/src/price_estimation/native/mod.rs b/crates/shared/src/price_estimation/native/mod.rs
index 15f7bee858..b70e45ee8b 100644
--- a/crates/shared/src/price_estimation/native/mod.rs
+++ b/crates/shared/src/price_estimation/native/mod.rs
@@ -13,10 +13,16 @@ use {
 };
 
 mod coingecko;
+pub mod fallback;
 mod forwarder;
 mod oneinch;
 
-pub use self::{coingecko::CoinGecko, forwarder::Forwarder, oneinch::OneInch};
+pub use self::{
+    coingecko::CoinGecko,
+    fallback::FallbackNativePriceEstimator,
+    forwarder::Forwarder,
+    oneinch::OneInch,
+};
 
 pub type NativePrice = f64;
 pub type NativePriceEstimateResult = Result<NativePrice, PriceEstimationError>;

From 1a29bbe65743f50b9e669db5eb7dc6fc0c5d1150 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 12:43:50 +0000
Subject: [PATCH 074/219] Fix limit layer in driver and bump limit to 20Mb
 (#4170)

# Description
The upgrade to axum 0.8 required an upper bound on loading requests
completely into memory, so I reused the driver's limit. Turns out, the
limit was not correctly applied and the new API forced it.

This PR fixes the layer to work correctly and bumps the max request body
size to 20MB

# Changes
<!-- List of detailed changes (how the change is accomplished) -->

- [ ] Fix the limit layer
- [ ] Bump the default limit to 20MB

## How to test
Staging
---
 crates/driver/src/infra/api/mod.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index a6ac2cde60..07da4bfbf3 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -31,7 +31,7 @@ use {
 mod error;
 pub mod routes;
 
-pub const REQUEST_BODY_LIMIT: usize = 10 * 1024 * 1024;
+pub const REQUEST_BODY_LIMIT: usize = 20 * 1024 * 1024;
 
 pub struct Api {
     pub solvers: Vec<Solver>,
@@ -55,9 +55,7 @@ impl Api {
         app_data_retriever: Option<AppDataRetriever>,
     ) -> Result<(), std::io::Error> {
         // Add middleware.
-        let mut app = axum::Router::new().layer(tower::ServiceBuilder::new().layer(
-            tower_http::limit::RequestBodyLimitLayer::new(REQUEST_BODY_LIMIT),
-        ));
+        let mut app = axum::Router::new();
 
         let balance_fetcher = account_balances::cached(
             self.eth.web3(),
@@ -141,6 +139,9 @@ impl Api {
         app = app
             // axum's default body limit needs to be disabled to not have the default limit on top of our custom limit
             .layer(axum::extract::DefaultBodyLimit::disable())
+            .layer(tower::ServiceBuilder::new().layer(
+                tower_http::limit::RequestBodyLimitLayer::new(REQUEST_BODY_LIMIT),
+            ))
             .layer(
                 tower::ServiceBuilder::new()
                     .layer(tower_http::trace::TraceLayer::new_for_http().make_span_with(make_span))

From 24a47092dcce10c015eea2b0e53a95ef02abc4ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 13:23:04 +0000
Subject: [PATCH 075/219] Remove request body limit in the driver (#4171)

# Description
20Mb was not enough, this PR removes the limit.

# Changes

- [ ] Remove the limit layer

## How to test
Staging
---
 crates/driver/src/domain/competition/pre_processing.rs | 9 ++-------
 crates/driver/src/infra/api/mod.rs                     | 8 ++------
 2 files changed, 4 insertions(+), 13 deletions(-)

diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index a4d5105705..1b82c13246 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -7,12 +7,7 @@ use {
             eth,
             liquidity,
         },
-        infra::{
-            self,
-            api::{REQUEST_BODY_LIMIT, routes::solve::dto::SolveRequest},
-            observe::metrics,
-            tokens,
-        },
+        infra::{self, api::routes::solve::dto::SolveRequest, observe::metrics, tokens},
     },
     alloy::primitives::{Bytes, FixedBytes},
     anyhow::{Context, Result},
@@ -570,7 +565,7 @@ async fn collect_request_body(request: Request<Body>) -> Result<body::Bytes> {
         observe::metrics::metrics().on_auction_overhead_start("driver", "stream_http_body");
     let start = Instant::now();
 
-    let body_bytes = axum::body::to_bytes(request.into_body(), REQUEST_BODY_LIMIT)
+    let body_bytes = axum::body::to_bytes(request.into_body(), usize::MAX)
         .await
         .context("failed to stream request body")?;
 
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index 07da4bfbf3..c594b472a0 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -31,8 +31,6 @@ use {
 mod error;
 pub mod routes;
 
-pub const REQUEST_BODY_LIMIT: usize = 20 * 1024 * 1024;
-
 pub struct Api {
     pub solvers: Vec<Solver>,
     pub liquidity: liquidity::Fetcher,
@@ -137,11 +135,9 @@ impl Api {
         }
 
         app = app
-            // axum's default body limit needs to be disabled to not have the default limit on top of our custom limit
+            // axum's default body limit is 2MB too low for solvers, 20MB is still too low
+            // so instead of constantly guessing and updating, we disable the limit altogether
             .layer(axum::extract::DefaultBodyLimit::disable())
-            .layer(tower::ServiceBuilder::new().layer(
-                tower_http::limit::RequestBodyLimitLayer::new(REQUEST_BODY_LIMIT),
-            ))
             .layer(
                 tower::ServiceBuilder::new()
                     .layer(tower_http::trace::TraceLayer::new_for_http().make_span_with(make_span))

From 55de111bbfe07792531c01c85c82fb2b7c0a2e36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 13:33:14 +0000
Subject: [PATCH 076/219] [TRIVIAL] Bump alloy to 1.7.3 (#4168)

# Description
While looking into the dependencies I noticed our alloy version is a bit
behind, this PR updates it.

I've reviewed the changelog and there does not seem to be anything that
will surprise us. It brings the bonus of some preparations being made
for the glamsterdam network upgrade.

# Changes

- [ ] Alloy version bump to 1.7.3

## How to test
Compiler + Staging
---
 Cargo.lock | 118 ++++++++++++++++++++++++++++++-----------------------
 Cargo.toml |   4 +-
 2 files changed, 68 insertions(+), 54 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f4717183d6..a7cbe2f5ff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -47,9 +47,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "alloy"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb837e538ce3eac04e357ef47b8acead0b14c83ec6bcafedd167e6a60c40876"
+checksum = "4973038846323e4e69a433916522195dce2947770076c03078fc21c80ea0f1c4"
 dependencies = [
  "alloy-consensus",
  "alloy-contract",
@@ -84,9 +84,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12870ab65b131f609257436935047eec3cfabee8809732f6bf5a69fe2a18cf2e"
+checksum = "b0c0dc44157867da82c469c13186015b86abef209bf0e41625e4b68bac61d728"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -111,9 +111,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus-any"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47c66b14d2187de0c4efe4ef678aaa57a6a34cccdbea3a0773627fac9bd128f4"
+checksum = "ba4cdb42df3871cd6b346d6a938ec2ba69a9a0f49d1f82714bc5c48349268434"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -125,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-contract"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9bf6afe8c25b63c98927c6f76d90cf8dc443cc4980a7d824151c84a6e568934"
+checksum = "ca63b7125a981415898ffe2a2a696c83696c9c6bdb1671c8a912946bbd8e49e7"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
@@ -214,15 +214,28 @@ dependencies = [
  "thiserror 2.0.17",
 ]
 
+[[package]]
+name = "alloy-eip7928"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3231de68d5d6e75332b7489cfcc7f4dfabeba94d990a10e4b923af0e6623540"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "borsh",
+ "serde",
+]
+
 [[package]]
 name = "alloy-eips"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f076d25ddfcd2f1cbcc234e072baf97567d1df0e3fccdc1f8af8cc8b18dc6299"
+checksum = "b9f7ef09f21bd1e9cb8a686f168cb4a206646804567f0889eadb8dcc4c9288c8"
 dependencies = [
  "alloy-eip2124",
  "alloy-eip2930",
  "alloy-eip7702",
+ "alloy-eip7928",
  "alloy-primitives",
  "alloy-rlp",
  "alloy-serde",
@@ -251,9 +264,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-json-rpc"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "250dbd8496f04eabe997e6e4c5186a0630b8bc3dbe7552e1fd917d491ef811e9"
+checksum = "ff42cd777eea61f370c0b10f2648a1c81e0b783066cd7269228aa993afd487f7"
 dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
@@ -266,9 +279,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-network"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd45cdac957d1fa1d0c18f54f262350eb72f1adc38dd1f8b15f33f0747c6a60c"
+checksum = "8cbca04f9b410fdc51aaaf88433cbac761213905a65fe832058bcf6690585762"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
@@ -292,9 +305,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-network-primitives"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fba5c43e055effb5bd33dbc74b1ab7fe0f367d8801a25af9e7c716b3ef5e440b"
+checksum = "42d6d15e069a8b11f56bef2eccbad2a873c6dd4d4c81d04dda29710f5ea52f04"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -334,9 +347,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-provider"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e87a90cacc27dffd91fa6440145934a782227d31b9876444c5924d3607084ea"
+checksum = "d181c8cc7cf4805d7e589bf4074d56d55064fa1a979f005a45a62b047616d870"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -379,9 +392,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-pubsub"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c24a102935aa9d5a8b8fc8c47f39a0823672c33f0b27b5806292cb80988e6345"
+checksum = "e8bd82953194dec221aa4cbbbb0b1e2df46066fe9d0333ac25b43a311e122d13"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -423,9 +436,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-client"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57a65bb9060e43e9738bbd7c30d742ed962d609f2123a665bbdab7e6e0f13fd3"
+checksum = "f2792758a93ae32a32e9047c843d536e1448044f78422d71bf7d7c05149e103f"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -448,9 +461,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98bfd40f4e36cb29015ec744bc764629edbe823ec6b95aceef2684090c142976"
+checksum = "7bdcbf9dfd5eea8bfeb078b1d906da8cd3a39c4d4dbe7a628025648e323611f6"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-anvil",
@@ -464,9 +477,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-anvil"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ac7d0dbb62e807028554e34c2b5724a1f57132792684107c32009e84fcf4044"
+checksum = "e0a3100b76987c1b1dc81f3abe592b7edc29e92b1242067a69d65e0030b35cf9"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -476,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-any"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8faa6f22068857f58579271b15e042f4725ad35cdce2ed4778ba32ffd3102b92"
+checksum = "dd720b63f82b457610f2eaaf1f32edf44efffe03ae25d537632e7d23e7929e1a"
 dependencies = [
  "alloy-consensus-any",
  "alloy-rpc-types-eth",
@@ -487,9 +500,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-debug"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccb37a9eee8e7a19bb07b5cd55d33457884e44b212588b7429c5d318d2b90295"
+checksum = "e1b21e1ad18ff1b31ff1030e046462ab8168cf8894e6778cd805c8bdfe2bd649"
 dependencies = [
  "alloy-primitives",
  "derive_more 2.1.1",
@@ -499,9 +512,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-eth"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ec734cce11f7fe889950b36b51589397528b26beb6f890834a2131ee9f174d7"
+checksum = "9b2dc411f13092f237d2bf6918caf80977fc2f51485f9b90cb2a2f956912c8c9"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
@@ -520,9 +533,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-trace"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe64cd4af2e68b2154ac02a7908249a448fbd3d1d05890786a5af93686083cc"
+checksum = "1ad79f1e27e161943b5a4f99fe5534ef0849876214be411e0032c12f38e94daa"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -534,9 +547,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-txpool"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9504c0f00a72883e640abc4681a5691a57dec693bc28d4aa80257c8e1e9e6e1f"
+checksum = "d459f902a2313737bc66d18ed094c25d2aeb268b74d98c26bbbda2aa44182ab0"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -546,9 +559,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-serde"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27f076bfd74fccc63d50546e1765359736357a953de2eb778b7b6191571735e6"
+checksum = "e2ce1e0dbf7720eee747700e300c99aac01b1a95bb93f493a01e78ee28bb1a37"
 dependencies = [
  "alloy-primitives",
  "serde",
@@ -557,9 +570,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d80748c209a68421ab6f737828ce6ede7543569a5cad099c1ec16fc1baa05620"
+checksum = "2425c6f314522c78e8198979c8cbf6769362be4da381d4152ea8eefce383535d"
 dependencies = [
  "alloy-dyn-abi",
  "alloy-primitives",
@@ -574,9 +587,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-aws"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2a0b80a0e21c1b8d7321d0a88bd115ad1182c293ca7e3dd0217c156f98b5b1e"
+checksum = "e38b411077d7b17e464de7dfa599f5b94161cdffc25c2f28a90a3a345b6d6490"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -593,9 +606,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-local"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17eb1eb39351b4bf20bb0710d8d3a91eb7918d3f3de2f3835f556842e33865cb"
+checksum = "c3ecb71ee53d8d9c3fa7bac17542c8116ebc7a9726c91b1bf333ec3d04f5a789"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -685,9 +698,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0c1a0288cdff6ee2b2c2c98ab42889d221ca8a9ee4120ede59b5449e0dcb20"
+checksum = "fa186e560d523d196580c48bf00f1bf62e63041f28ecf276acc22f8b27bb9f53"
 dependencies = [
  "alloy-json-rpc",
  "auto_impl",
@@ -708,12 +721,13 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-http"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36dfa207caf6b528b9466c714626f5b2dfd5e8d4595a74631d5670672dac102b"
+checksum = "aa501ad58dd20acddbfebc65b52e60f05ebf97c52fa40d1b35e91f5e2da0ad0e"
 dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
+ "itertools 0.14.0",
  "reqwest",
  "serde_json",
  "tower 0.5.3",
@@ -723,9 +737,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-ws"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91620efb46f8d011e37f74fac53a643e830a7bb24982143094b887003cbfb6be"
+checksum = "b9f00445db69d63298e2b00a0ea1d859f00e6424a3144ffc5eba9c31da995e16"
 dependencies = [
  "alloy-pubsub",
  "alloy-transport",
@@ -756,9 +770,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-tx-macros"
-version = "1.4.2"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb0d567f4830dea921868c7680004ae0c7f221b05e6477db6c077c7953698f56"
+checksum = "6fa0c53e8c1e1ef4d01066b01c737fb62fc9397ab52c6e7bb5669f97d281b9bc"
 dependencies = [
  "darling",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 3099d89977..0669151eea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,10 +3,10 @@ resolver = "3"
 members = ["crates/*"]
 
 [workspace.dependencies]
-alloy = { version = "1.1.0", default-features = false }
+alloy = { version = "1.7.3", default-features = false }
 # alloy-signer was added because eip712 on the regular alloy crate brings way too much stuff with it
 # as such, this is a workaround to force feature unification over alloy to the feature set we want
-alloy-signer = { version = "1.1.0", default-features = false}
+alloy-signer = { version = "1.7.3", default-features = false}
 anyhow = "1.0.100"
 async-trait = "0.1.80"
 axum = "0.8"

From 4351d4c252d95f27edaadf8f96e5144527f4a464 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 13:33:24 +0000
Subject: [PATCH 077/219] [TRIVIAL] Bump opentelemetry->0.31 &
 tracing-opentelemetry->0.32.1 (#4169)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
One more for the upgrade pile. I'd like to think that this will slightly
improve service health due to some of the points in the changelog —
https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-sdk/CHANGELOG.md#0310

> * Fix: Restore true parallel exports in the async-native
BatchSpanProcessor by honoring OTEL_BSP_MAX_CONCURRENT_EXPORTS
(https://github.com/open-telemetry/opentelemetry-rust/pull/3028). A
regression in
https://github.com/open-telemetry/opentelemetry-rust/pull/2685
inadvertently awaited the export() future directly in
opentelemetry-sdk/src/trace/span_processor_with_async_runtime.rs instead
of spawning it on the runtime, forcing all exports to run sequentially.
> * Fix: batch size accounting in BatchSpanProcessor when queue is full
(https://github.com/open-telemetry/opentelemetry-rust/pull/3089).

# Changes

- [ ] Bump opentelemetry-* crates to 0.31
- [ ] Bump tracing-opentelemetry to 0.32.1

## How to test
Compile
---
 Cargo.lock                                    | 76 +++++++++++++------
 Cargo.toml                                    |  8 +-
 .../src/distributed_tracing/tracing_axum.rs   |  4 +-
 3 files changed, 61 insertions(+), 27 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a7cbe2f5ff..5d3ad257b7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4673,9 +4673,9 @@ dependencies = [
 
 [[package]]
 name = "opentelemetry"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf416e4cb72756655126f7dd7bb0af49c674f4c1b9903e80c009e0c37e552e6"
+checksum = "b84bcd6ae87133e903af7ef497404dda70c60d0ea14895fc8a5e6722754fc2a0"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -4687,9 +4687,9 @@ dependencies = [
 
 [[package]]
 name = "opentelemetry-http"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f6639e842a97dbea8886e3439710ae463120091e2e064518ba8e716e6ac36d"
+checksum = "d7a6d09a73194e6b66df7c8f1b680f156d916a1a942abf2de06823dd02b7855d"
 dependencies = [
  "async-trait",
  "bytes",
@@ -4700,40 +4700,41 @@ dependencies = [
 
 [[package]]
 name = "opentelemetry-otlp"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbee664a43e07615731afc539ca60c6d9f1a9425e25ca09c57bc36c87c55852b"
+checksum = "7a2366db2dca4d2ad033cad11e6ee42844fd727007af5ad04a1730f4cb8163bf"
 dependencies = [
  "http 1.4.0",
  "opentelemetry",
  "opentelemetry-http",
  "opentelemetry-proto",
  "opentelemetry_sdk",
- "prost 0.13.5",
+ "prost 0.14.3",
  "reqwest",
  "thiserror 2.0.17",
  "tokio",
- "tonic 0.13.1",
+ "tonic 0.14.4",
  "tracing",
 ]
 
 [[package]]
 name = "opentelemetry-proto"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e046fd7660710fe5a05e8748e70d9058dc15c94ba914e7c4faa7c728f0e8ddc"
+checksum = "a7175df06de5eaee9909d4805a3d07e28bb752c34cab57fa9cff549da596b30f"
 dependencies = [
  "opentelemetry",
  "opentelemetry_sdk",
- "prost 0.13.5",
- "tonic 0.13.1",
+ "prost 0.14.3",
+ "tonic 0.14.4",
+ "tonic-prost",
 ]
 
 [[package]]
 name = "opentelemetry_sdk"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11f644aa9e5e31d11896e024305d7e3c98a88884d9f8919dbf37a9991bc47a4b"
+checksum = "e14ae4f5991976fd48df6d843de219ca6d31b01daaab2dad5af2badeded372bd"
 dependencies = [
  "futures-channel",
  "futures-executor",
@@ -4741,7 +4742,6 @@ dependencies = [
  "opentelemetry",
  "percent-encoding",
  "rand 0.9.2",
- "serde_json",
  "thiserror 2.0.17",
 ]
 
@@ -5186,6 +5186,16 @@ dependencies = [
  "prost-derive 0.13.5",
 ]
 
+[[package]]
+name = "prost"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
+dependencies = [
+ "bytes",
+ "prost-derive 0.14.3",
+]
+
 [[package]]
 name = "prost-derive"
 version = "0.12.6"
@@ -5212,6 +5222,19 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "prost-derive"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "prost-types"
 version = "0.12.6"
@@ -7131,9 +7154,9 @@ dependencies = [
 
 [[package]]
 name = "tonic"
-version = "0.13.1"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e581ba15a835f4d9ea06c55ab1bd4dce26fc53752c69a04aac00703bfb49ba9"
+checksum = "7f32a6f80051a4111560201420c7885d0082ba9efe2ab61875c587bb6b18b9a0"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -7146,7 +7169,7 @@ dependencies = [
  "hyper-util",
  "percent-encoding",
  "pin-project",
- "prost 0.13.5",
+ "sync_wrapper 1.0.2",
  "tokio",
  "tokio-stream",
  "tower 0.5.3",
@@ -7155,6 +7178,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tonic-prost"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f86539c0089bfd09b1f8c0ab0239d80392af74c21bc9e0f15e1b4aca4c1647f"
+dependencies = [
+ "bytes",
+ "prost 0.14.3",
+ "tonic 0.14.4",
+]
+
 [[package]]
 name = "tower"
 version = "0.4.13"
@@ -7276,14 +7310,12 @@ dependencies = [
 
 [[package]]
 name = "tracing-opentelemetry"
-version = "0.31.0"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddcf5959f39507d0d04d6413119c04f33b623f4f951ebcbdddddfad2d0623a9c"
+checksum = "1ac28f2d093c6c477eaa76b23525478f38de514fa9aeb1285738d4b97a9552fc"
 dependencies = [
  "js-sys",
- "once_cell",
  "opentelemetry",
- "opentelemetry_sdk",
  "smallvec",
  "tracing",
  "tracing-core",
diff --git a/Cargo.toml b/Cargo.toml
index 0669151eea..3d3b525730 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -75,9 +75,9 @@ multibase = "0.9"
 number = { path = "crates/number" }
 observe = { path = "crates/observe" }
 order-validation = { path = "crates/order-validation" }
-opentelemetry = { version = "0.30", features = ["tracing"] }
-opentelemetry-otlp = "0.30"
-opentelemetry_sdk = "0.30"
+opentelemetry = { version = "0.31", features = ["tracing"] }
+opentelemetry-otlp = "0.31"
+opentelemetry_sdk = "0.31"
 orderbook = { path = "crates/orderbook" }
 paste = "1.0"
 pin-project-lite = "0.2.14"
@@ -96,7 +96,7 @@ time = "0.3.47"
 tiny-keccak = "2.0.2"
 tower = "0.5"
 tower-http = "0.6"
-tracing-opentelemetry = "0.31"
+tracing-opentelemetry = "0.32.1"
 tracing-serde = "0.2"
 vergen = "8"
 quote = "1.0.41"
diff --git a/crates/observe/src/distributed_tracing/tracing_axum.rs b/crates/observe/src/distributed_tracing/tracing_axum.rs
index d26fabcaec..8fbdf643c1 100644
--- a/crates/observe/src/distributed_tracing/tracing_axum.rs
+++ b/crates/observe/src/distributed_tracing/tracing_axum.rs
@@ -25,7 +25,9 @@ pub fn make_span<B>(request: &Request<B>) -> Span {
     let request_id = request_id(request.headers());
 
     let span = info_span!("http_request", ?request_id, trace_id = field::Empty);
-    span.set_parent(parent_context);
+    if let Err(err) = span.set_parent(parent_context) {
+        tracing::error!(?err, "failed to set request parent span!");
+    }
     {
         let _span = span.enter();
         info!(uri = %request.uri(), method = %request.method(), "HTTP request");

From 4c2987a5aa63eab9cddab248ace9438fa884b82f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 13:51:45 +0000
Subject: [PATCH 078/219] Update old de/serialization errors (#4163)

# Description
The error handling that is being removed was added to avoid breaking any
solver/partner code; the change was upped today (Feb 17th) and the teams
with touch points to the affected parties were notified

* https://nomevlabs.slack.com/archives/C036JAGRQ04/p1770811138347829
* https://nomevlabs.slack.com/archives/C0369B2UF6J/p1770810493856389

This PR "brings back" the newer and more accurate errors, relying on
Axum's default extractor behavior.

# Changes

- [ ] Remove custom deserialization code to provide old error codes
- [ ] Update E2E tests
- [ ] Update orderbook/openapi.yml

## How to test
E2E tests
---
 crates/e2e/tests/e2e/malformed_requests.rs    | 43 +++++++++----------
 crates/orderbook/openapi.yml                  | 18 ++++++++
 crates/orderbook/src/api/get_app_data.rs      |  8 +---
 crates/orderbook/src/api/get_native_price.rs  | 11 +----
 crates/orderbook/src/api/get_order_by_uid.rs  | 10 +----
 crates/orderbook/src/api/get_order_status.rs  | 10 +----
 crates/orderbook/src/api/get_orders_by_tx.rs  | 11 +----
 .../src/api/get_solver_competition.rs         | 19 ++------
 .../src/api/get_solver_competition_v2.rs      | 19 ++------
 .../orderbook/src/api/get_token_metadata.rs   | 11 +----
 crates/orderbook/src/api/get_total_surplus.rs | 10 +----
 crates/orderbook/src/api/get_user_orders.rs   | 10 +----
 crates/orderbook/src/api/post_order.rs        | 13 ++----
 crates/orderbook/src/api/post_quote.rs        | 12 ++----
 crates/orderbook/src/api/put_app_data.rs      | 24 ++---------
 15 files changed, 73 insertions(+), 156 deletions(-)

diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 046f460c8b..622a0ea7b0 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -53,8 +53,8 @@ async fn http_validation(web3: Web3) {
 
         assert_eq!(
             response.status(),
-            StatusCode::NOT_FOUND,
-            "Expected 404 for invalid OrderUid ({description}): {uid}"
+            StatusCode::BAD_REQUEST,
+            "Expected 400 for invalid OrderUid ({description}): {uid}"
         );
     }
 
@@ -76,8 +76,8 @@ async fn http_validation(web3: Web3) {
 
         assert_eq!(
             response.status(),
-            StatusCode::NOT_FOUND,
-            "Expected 404 for invalid Address ({description}): {addr}"
+            StatusCode::BAD_REQUEST,
+            "Expected 400 for invalid Address ({description}): {addr}"
         );
     }
 
@@ -90,8 +90,8 @@ async fn http_validation(web3: Web3) {
 
         assert_eq!(
             response.status(),
-            StatusCode::NOT_FOUND,
-            "Expected 404 for invalid token Address ({description}): {addr}"
+            StatusCode::BAD_REQUEST,
+            "Expected 400 for invalid token Address ({description}): {addr}"
         );
     }
 
@@ -113,22 +113,19 @@ async fn http_validation(web3: Web3) {
 
         assert_eq!(
             response.status(),
-            StatusCode::NOT_FOUND,
-            "Expected 404 for invalid tx hash ({description}): {hash}"
+            StatusCode::BAD_REQUEST,
+            "Expected 400 for invalid tx hash ({description}): {hash}"
         );
     }
 
     // Test malformed auction IDs
-    // Note: "-1" returns 404 because it doesn't match the u64 route pattern at all,
-    // while non-numeric strings return 400 as they match the path but fail
-    // deserialization
     for (id, description, expected_status) in [
-        ("not-a-number", "non-numeric", StatusCode::NOT_FOUND),
-        ("-1", "negative number", StatusCode::NOT_FOUND),
+        ("not-a-number", "non-numeric", StatusCode::BAD_REQUEST),
+        ("-1", "negative number", StatusCode::BAD_REQUEST),
         (
             "99999999999999999999999",
             "u64 overflow",
-            StatusCode::NOT_FOUND,
+            StatusCode::BAD_REQUEST,
         ),
     ] {
         let response = client
@@ -218,8 +215,8 @@ async fn http_validation(web3: Web3) {
 
     assert_eq!(
         response.status(),
-        StatusCode::BAD_REQUEST,
-        "Missing required fields should return 400"
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "Missing required fields should return 422"
     );
 
     // Wrong field types
@@ -241,8 +238,8 @@ async fn http_validation(web3: Web3) {
 
     assert_eq!(
         response.status(),
-        StatusCode::BAD_REQUEST,
-        "Wrong field types should return 400"
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "Wrong field types should return 422"
     );
 
     // Invalid enum value
@@ -261,8 +258,8 @@ async fn http_validation(web3: Web3) {
 
     assert_eq!(
         response.status(),
-        StatusCode::BAD_REQUEST,
-        "Invalid enum value should return 400"
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "Invalid enum value should return 422"
     );
 
     // Test error response formats
@@ -275,11 +272,13 @@ async fn http_validation(web3: Web3) {
         .await
         .unwrap();
 
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
 
     let body_text = response.text().await.unwrap();
     assert!(
-        body_text.contains("deserialize error") || body_text.contains("missing field"),
+        body_text.contains("deserialize")
+            || body_text.contains("missing field")
+            || body_text.contains("Failed to deserialize"),
         "Deserialization error should contain helpful description. Got: {body_text}"
     );
 
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index b47831b118..1d6a9eefc3 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -146,6 +146,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Order"
+        "400":
+          description: Invalid order UID.
         "404":
           description: Order was not found.
     delete:
@@ -206,6 +208,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/CompetitionOrderStatus"
+        "400":
+          description: Invalid order UID.
   "/api/v1/transactions/{txHash}/orders":
     get:
       operationId: getOrdersByTxHash
@@ -225,6 +229,8 @@ paths:
                 type: array
                 items:
                   $ref: "#/components/schemas/Order"
+        "400":
+          description: Invalid transaction hash.
   /api/v1/trades:
     get:
       operationId: getTrades
@@ -473,6 +479,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/SolverCompetitionResponse"
+        "400":
+          description: Invalid auction ID.
         "404":
           description: No competition information available for this auction id.
   "/api/v1/solver_competition/by_tx_hash/{tx_hash}":
@@ -496,6 +504,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/SolverCompetitionResponse"
+        "400":
+          description: Invalid transaction hash.
         "404":
           description: No competition information available for this `tx_hash`.
   /api/v1/solver_competition/latest:
@@ -533,6 +543,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/SolverCompetitionResponse"
+        "400":
+          description: Invalid auction ID.
         "404":
           description: No competition information available for this auction id.
   "/api/v2/solver_competition/by_tx_hash/{tx_hash}":
@@ -555,6 +567,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/SolverCompetitionResponse"
+        "400":
+          description: Invalid transaction hash.
         "404":
           description: No competition information available for this `tx_hash`.
   /api/v2/solver_competition/latest:
@@ -601,6 +615,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/AppDataObject"
+        "400":
+          description: Invalid app data hash.
         "404":
           description: No full `appData` stored for this hash.
     put:
@@ -697,6 +713,8 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/TotalSurplus"
+        "400":
+          description: Invalid address.
 components:
   schemas:
     TransactionHash:
diff --git a/crates/orderbook/src/api/get_app_data.rs b/crates/orderbook/src/api/get_app_data.rs
index 68ff733611..6b4f9f3a96 100644
--- a/crates/orderbook/src/api/get_app_data.rs
+++ b/crates/orderbook/src/api/get_app_data.rs
@@ -6,17 +6,13 @@ use {
         http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_app_data_handler(
     State(state): State<Arc<AppState>>,
-    Path(contract_app_data): Path<String>,
+    Path(contract_app_data): Path<AppDataHash>,
 ) -> Response {
-    let Ok(contract_app_data) = AppDataHash::from_str(&contract_app_data) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let result = state
         .database_read
         .get_full_app_data(&contract_app_data)
diff --git a/crates/orderbook/src/api/get_native_price.rs b/crates/orderbook/src/api/get_native_price.rs
index 563b73bad5..52c490aeb4 100644
--- a/crates/orderbook/src/api/get_native_price.rs
+++ b/crates/orderbook/src/api/get_native_price.rs
@@ -3,23 +3,16 @@ use {
     alloy::primitives::Address,
     axum::{
         extract::{Path, State},
-        http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
     model::quote::NativeTokenPrice,
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_native_price_handler(
     State(state): State<Arc<AppState>>,
-    Path(token): Path<String>,
+    Path(token): Path<Address>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(token) = Address::from_str(&token) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     state
         .native_price_estimator
         .estimate_native_price(token, state.quote_timeout)
diff --git a/crates/orderbook/src/api/get_order_by_uid.rs b/crates/orderbook/src/api/get_order_by_uid.rs
index 4e0b9e6e71..7cc11721e3 100644
--- a/crates/orderbook/src/api/get_order_by_uid.rs
+++ b/crates/orderbook/src/api/get_order_by_uid.rs
@@ -7,19 +7,13 @@ use {
         response::{IntoResponse, Json, Response},
     },
     model::order::{Order, OrderUid},
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_order_by_uid_handler(
     State(state): State<Arc<AppState>>,
-    Path(uid): Path<String>,
+    Path(uid): Path<OrderUid>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(uid) = OrderUid::from_str(&uid) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let result = state.orderbook.get_order(&uid).await;
     get_order_by_uid_response(result)
 }
diff --git a/crates/orderbook/src/api/get_order_status.rs b/crates/orderbook/src/api/get_order_status.rs
index e90e9537a3..40d92c9292 100644
--- a/crates/orderbook/src/api/get_order_status.rs
+++ b/crates/orderbook/src/api/get_order_status.rs
@@ -6,19 +6,13 @@ use {
         response::{IntoResponse, Json, Response},
     },
     model::order::OrderUid,
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_status_handler(
     State(state): State<Arc<AppState>>,
-    Path(uid): Path<String>,
+    Path(uid): Path<OrderUid>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(uid) = OrderUid::from_str(&uid) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let status = state.orderbook.get_order_status(&uid).await;
     match status {
         Ok(status) => Json(status).into_response(),
diff --git a/crates/orderbook/src/api/get_orders_by_tx.rs b/crates/orderbook/src/api/get_orders_by_tx.rs
index a06acee9db..a50c2dd43d 100644
--- a/crates/orderbook/src/api/get_orders_by_tx.rs
+++ b/crates/orderbook/src/api/get_orders_by_tx.rs
@@ -3,22 +3,15 @@ use {
     alloy::primitives::B256,
     axum::{
         extract::{Path, State},
-        http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_orders_by_tx_handler(
     State(state): State<Arc<AppState>>,
-    Path(hash): Path<String>,
+    Path(hash): Path<B256>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(hash) = B256::from_str(&hash) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let result = state.orderbook.get_orders_for_tx(&hash).await;
     match result {
         Ok(response) => Json(response).into_response(),
diff --git a/crates/orderbook/src/api/get_solver_competition.rs b/crates/orderbook/src/api/get_solver_competition.rs
index 7be9e6ef0d..b94574b0bf 100644
--- a/crates/orderbook/src/api/get_solver_competition.rs
+++ b/crates/orderbook/src/api/get_solver_competition.rs
@@ -6,23 +6,16 @@ use {
     alloy::primitives::B256,
     axum::{
         extract::{Path, State},
-        http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
     model::{AuctionId, solver_competition::SolverCompetitionAPI},
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_solver_competition_by_id_handler(
     State(state): State<Arc<AppState>>,
-    Path(auction_id): Path<String>,
+    Path(auction_id): Path<u64>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(auction_id) = auction_id.parse::<u64>() else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     // We use u64 to ensure that negative numbers are returned as BAD_REQUEST
     // however, there's a gap between u64::MAX and i64::MAX, numbers beyond i64::MAX
     // will be marked as NOT_FOUND as they're positive (and as such, valid) but
@@ -41,14 +34,8 @@ pub async fn get_solver_competition_by_id_handler(
 
 pub async fn get_solver_competition_by_hash_handler(
     State(state): State<Arc<AppState>>,
-    Path(tx_hash): Path<String>,
+    Path(tx_hash): Path<B256>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(tx_hash) = B256::from_str(&tx_hash) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let handler: &dyn SolverCompetitionStoring = &state.database_read;
     handler
         .load_competition(Identifier::Transaction(tx_hash))
diff --git a/crates/orderbook/src/api/get_solver_competition_v2.rs b/crates/orderbook/src/api/get_solver_competition_v2.rs
index 1e332c0446..71e7c48354 100644
--- a/crates/orderbook/src/api/get_solver_competition_v2.rs
+++ b/crates/orderbook/src/api/get_solver_competition_v2.rs
@@ -3,23 +3,16 @@ use {
     alloy::primitives::B256,
     axum::{
         extract::{Path, State},
-        http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
     model::{AuctionId, solver_competition_v2::Response as CompetitionResponse},
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_solver_competition_by_id_handler(
     State(state): State<Arc<AppState>>,
-    Path(auction_id): Path<String>,
+    Path(auction_id): Path<AuctionId>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(auction_id) = auction_id.parse::<AuctionId>() else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     state
         .database_read
         .load_competition_by_id(auction_id)
@@ -30,14 +23,8 @@ pub async fn get_solver_competition_by_id_handler(
 
 pub async fn get_solver_competition_by_hash_handler(
     State(state): State<Arc<AppState>>,
-    Path(tx_hash): Path<String>,
+    Path(tx_hash): Path<B256>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(tx_hash) = B256::from_str(&tx_hash) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     state
         .database_read
         .load_competition_by_tx_hash(tx_hash)
diff --git a/crates/orderbook/src/api/get_token_metadata.rs b/crates/orderbook/src/api/get_token_metadata.rs
index 04794b61d9..06782b4dd4 100644
--- a/crates/orderbook/src/api/get_token_metadata.rs
+++ b/crates/orderbook/src/api/get_token_metadata.rs
@@ -3,22 +3,15 @@ use {
     alloy::primitives::Address,
     axum::{
         extract::{Path, State},
-        http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_token_metadata_handler(
     State(state): State<Arc<AppState>>,
-    Path(token): Path<String>,
+    Path(token): Path<Address>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(token) = Address::from_str(&token) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let result = state.database_read.token_metadata(&token).await;
     match result {
         Ok(metadata) => Json(metadata).into_response(),
diff --git a/crates/orderbook/src/api/get_total_surplus.rs b/crates/orderbook/src/api/get_total_surplus.rs
index 143b67b9e8..04d5434f2f 100644
--- a/crates/orderbook/src/api/get_total_surplus.rs
+++ b/crates/orderbook/src/api/get_total_surplus.rs
@@ -7,19 +7,13 @@ use {
         response::{IntoResponse, Json, Response},
     },
     serde_json::json,
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn get_total_surplus_handler(
     State(state): State<Arc<AppState>>,
-    Path(user): Path<String>,
+    Path(user): Path<Address>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(user) = Address::from_str(&user) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     let surplus = state.database_read.total_surplus(&user).await;
     match surplus {
         Ok(surplus) => (
diff --git a/crates/orderbook/src/api/get_user_orders.rs b/crates/orderbook/src/api/get_user_orders.rs
index 07daef1352..8330a72313 100644
--- a/crates/orderbook/src/api/get_user_orders.rs
+++ b/crates/orderbook/src/api/get_user_orders.rs
@@ -7,7 +7,7 @@ use {
         response::{IntoResponse, Json, Response},
     },
     serde::Deserialize,
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 #[derive(Clone, Copy, Debug, Deserialize)]
@@ -18,15 +18,9 @@ pub(crate) struct QueryParams {
 
 pub async fn get_user_orders_handler(
     State(state): State<Arc<AppState>>,
-    Path(owner): Path<String>,
+    Path(owner): Path<Address>,
     Query(query): Query<QueryParams>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(owner) = Address::from_str(&owner) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
     const DEFAULT_OFFSET: u64 = 0;
     const DEFAULT_LIMIT: u64 = 10;
     const MIN_LIMIT: u64 = 1;
diff --git a/crates/orderbook/src/api/post_order.rs b/crates/orderbook/src/api/post_order.rs
index 8e2bfea75e..c67270b84a 100644
--- a/crates/orderbook/src/api/post_order.rs
+++ b/crates/orderbook/src/api/post_order.rs
@@ -5,7 +5,6 @@ use {
     },
     axum::{
         Json,
-        body,
         extract::State,
         http::StatusCode,
         response::{IntoResponse, Response},
@@ -23,14 +22,10 @@ use {
     std::sync::Arc,
 };
 
-pub async fn post_order_handler(State(state): State<Arc<AppState>>, body: body::Bytes) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let order = match serde_json::from_slice::<OrderCreation>(&body) {
-        Ok(order) => order,
-        Err(err) => return (StatusCode::BAD_REQUEST, err.to_string()).into_response(),
-    };
-
+pub async fn post_order_handler(
+    State(state): State<Arc<AppState>>,
+    Json(order): Json<OrderCreation>,
+) -> Response {
     state
         .orderbook
         .add_order(order.clone())
diff --git a/crates/orderbook/src/api/post_quote.rs b/crates/orderbook/src/api/post_quote.rs
index 90febb2575..4981e6cc64 100644
--- a/crates/orderbook/src/api/post_quote.rs
+++ b/crates/orderbook/src/api/post_quote.rs
@@ -6,7 +6,6 @@ use {
     },
     axum::{
         Json,
-        body,
         extract::State,
         response::{IntoResponse, Response},
     },
@@ -16,13 +15,10 @@ use {
     std::sync::Arc,
 };
 
-pub async fn post_quote_handler(State(state): State<Arc<AppState>>, body: body::Bytes) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(request) = serde_json::from_slice::<OrderQuoteRequest>(&body) else {
-        return StatusCode::BAD_REQUEST.into_response();
-    };
-
+pub async fn post_quote_handler(
+    State(state): State<Arc<AppState>>,
+    Json(request): Json<OrderQuoteRequest>,
+) -> Response {
     state
         .quotes
         .calculate_quote(&request)
diff --git a/crates/orderbook/src/api/put_app_data.rs b/crates/orderbook/src/api/put_app_data.rs
index 835628fa44..a1b5be2876 100644
--- a/crates/orderbook/src/api/put_app_data.rs
+++ b/crates/orderbook/src/api/put_app_data.rs
@@ -2,24 +2,17 @@ use {
     crate::api::{AppState, internal_error_reply},
     app_data::{AppDataDocument, AppDataHash},
     axum::{
-        body::{self},
         extract::{Path, State},
         http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn put_app_data_without_hash(
     State(state): State<Arc<AppState>>,
-    body: body::Bytes,
+    Json(document): Json<AppDataDocument>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(document) = serde_json::from_slice::<AppDataDocument>(&body) else {
-        return StatusCode::BAD_REQUEST.into_response();
-    };
-
     state
         .app_data
         .register(None, document.full_app_data.as_bytes())
@@ -29,18 +22,9 @@ pub async fn put_app_data_without_hash(
 
 pub async fn put_app_data_with_hash(
     State(state): State<Arc<AppState>>,
-    Path(hash): Path<String>,
-    body: body::Bytes,
+    Path(hash): Path<AppDataHash>,
+    Json(document): Json<AppDataDocument>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(hash) = AppDataHash::from_str(&hash) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-    let Ok(document) = serde_json::from_slice::<AppDataDocument>(&body) else {
-        return StatusCode::BAD_REQUEST.into_response();
-    };
-
     state
         .app_data
         .register(Some(hash), document.full_app_data.as_bytes())

From a61a42f9a6771d7fc4ce5cefa152f35d04aeb86f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 15:13:32 +0000
Subject: [PATCH 079/219] Fix tracing spans on solvers (#4173)

# Description
https://github.com/cowprotocol/services/pull/4169 changed the
`set_parent` from silently failing to "returning an error" which I
proceeded to log as error, this is very spammy as it happens on every
HTTP request

Digging further, the issue is that the baseline solver does not set the
"main parent span" which we would like to have; so this PR also
addresses that (still needs to be enabled in infra)

# Changes

- [ ] Fix the log level
- [ ] Add & use tracing arguments in solvers

## How to test
Run a test in staging

Test in base, deployment around 14:52
<img width="1381" height="455" alt="Screenshot 2026-02-18 at 14 54 59"
src="https://github.com/user-attachments/assets/65d70a2b-25c0-4997-b0a3-5b0827655b1c"
/>
---
 crates/observe/src/distributed_tracing/tracing_axum.rs | 2 +-
 crates/solvers/src/infra/cli.rs                        | 4 ++++
 crates/solvers/src/run.rs                              | 3 ++-
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/observe/src/distributed_tracing/tracing_axum.rs b/crates/observe/src/distributed_tracing/tracing_axum.rs
index 8fbdf643c1..a2f1a1a755 100644
--- a/crates/observe/src/distributed_tracing/tracing_axum.rs
+++ b/crates/observe/src/distributed_tracing/tracing_axum.rs
@@ -26,7 +26,7 @@ pub fn make_span<B>(request: &Request<B>) -> Span {
 
     let span = info_span!("http_request", ?request_id, trace_id = field::Empty);
     if let Err(err) = span.set_parent(parent_context) {
-        tracing::error!(?err, "failed to set request parent span!");
+        tracing::debug!(?err, "failed to set request parent span");
     }
     {
         let _span = span.enter();
diff --git a/crates/solvers/src/infra/cli.rs b/crates/solvers/src/infra/cli.rs
index 601690a51e..49a13a1fbe 100644
--- a/crates/solvers/src/infra/cli.rs
+++ b/crates/solvers/src/infra/cli.rs
@@ -2,6 +2,7 @@
 
 use {
     clap::{Parser, Subcommand},
+    shared::arguments::TracingArguments,
     std::{net::SocketAddr, path::PathBuf},
 };
 
@@ -21,6 +22,9 @@ pub struct Args {
     #[clap(long, env, default_value = "false")]
     pub use_json_logs: bool,
 
+    #[clap(flatten)]
+    pub tracing: TracingArguments,
+
     /// The socket address to bind to.
     #[arg(long, env, default_value = "127.0.0.1:7872")]
     pub addr: SocketAddr,
diff --git a/crates/solvers/src/run.rs b/crates/solvers/src/run.rs
index 41cd1b71c3..ad87ccfe60 100644
--- a/crates/solvers/src/run.rs
+++ b/crates/solvers/src/run.rs
@@ -6,6 +6,7 @@ use {
         infra::{cli, config},
     },
     clap::Parser,
+    shared::arguments::tracing_config,
     std::net::SocketAddr,
     tokio::sync::oneshot,
 };
@@ -29,7 +30,7 @@ async fn run_with(args: cli::Args, bind: Option<oneshot::Sender<SocketAddr>>) {
         &args.log,
         tracing::Level::ERROR.into(),
         args.use_json_logs,
-        None,
+        tracing_config(&args.tracing, "solvers".into()),
     );
     observe::tracing::initialize_reentrant(&obs_config);
     #[cfg(unix)]

From 0f5da5818b28f53cba00ce59018425a173e81a1c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 17:29:08 +0000
Subject: [PATCH 080/219] Upgrade reqwest to 0.13 (#4172)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Upgrades reqwest to 0.13 — this carries the change from native-tls to
rustls by default, I tested this out and nothing broke

# Changes

- [ ] Upgrade reqwest to 0.13

## How to test
Tested on base staging, didn't see any issues
---
 Cargo.lock               | 341 +++++++++++++++++++++++++++++++++++----
 Cargo.toml               |   2 +-
 crates/driver/Cargo.toml |   2 +-
 crates/e2e/Cargo.toml    |   2 +-
 crates/shared/Cargo.toml |   2 +-
 5 files changed, 312 insertions(+), 37 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5d3ad257b7..4ee0250813 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -380,7 +380,7 @@ dependencies = [
  "lru 0.16.3",
  "parking_lot",
  "pin-project",
- "reqwest",
+ "reqwest 0.12.28",
  "serde",
  "serde_json",
  "thiserror 2.0.17",
@@ -448,7 +448,7 @@ dependencies = [
  "alloy-transport-ws",
  "futures",
  "pin-project",
- "reqwest",
+ "reqwest 0.12.28",
  "serde",
  "serde_json",
  "tokio",
@@ -728,7 +728,7 @@ dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
  "itertools 0.14.0",
- "reqwest",
+ "reqwest 0.12.28",
  "serde_json",
  "tower 0.5.3",
  "tracing",
@@ -1206,7 +1206,7 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
- "reqwest",
+ "reqwest 0.13.2",
  "rust_decimal",
  "s3",
  "serde",
@@ -2060,6 +2060,12 @@ dependencies = [
  "shlex",
 ]
 
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -2200,6 +2206,16 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
 [[package]]
 name = "compression-codecs"
 version = "0.4.36"
@@ -2320,7 +2336,7 @@ dependencies = [
  "prettyplease",
  "proc-macro2",
  "quote",
- "reqwest",
+ "reqwest 0.13.2",
  "serde",
  "serde_json",
  "syn 2.0.114",
@@ -2789,7 +2805,7 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
- "reqwest",
+ "reqwest 0.13.2",
  "s3",
  "serde",
  "serde-ext",
@@ -2849,7 +2865,7 @@ dependencies = [
  "observe",
  "orderbook",
  "refunder",
- "reqwest",
+ "reqwest 0.13.2",
  "rstest",
  "serde_json",
  "shared",
@@ -2992,7 +3008,7 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
- "reqwest",
+ "reqwest 0.13.2",
  "scopeguard",
  "serde",
  "serde_json",
@@ -3297,8 +3313,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -3308,9 +3326,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi",
  "wasip2",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -3999,6 +4019,28 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
 [[package]]
 name = "jobserver"
 version = "0.1.34"
@@ -4011,9 +4053,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.83"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -4172,6 +4214,12 @@ dependencies = [
  "hashbrown 0.16.1",
 ]
 
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
 [[package]]
 name = "macro-string"
 version = "0.1.4"
@@ -4695,7 +4743,7 @@ dependencies = [
  "bytes",
  "http 1.4.0",
  "opentelemetry",
- "reqwest",
+ "reqwest 0.12.28",
 ]
 
 [[package]]
@@ -4710,7 +4758,7 @@ dependencies = [
  "opentelemetry-proto",
  "opentelemetry_sdk",
  "prost 0.14.3",
- "reqwest",
+ "reqwest 0.12.28",
  "thiserror 2.0.17",
  "tokio",
  "tonic 0.14.4",
@@ -4789,7 +4837,7 @@ dependencies = [
  "order-validation",
  "prometheus",
  "prometheus-metric-storage",
- "reqwest",
+ "reqwest 0.13.2",
  "serde",
  "serde_json",
  "serde_with",
@@ -5272,6 +5320,62 @@ version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls 0.23.36",
+ "socket2 0.6.1",
+ "thiserror 2.0.17",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+dependencies = [
+ "aws-lc-rs",
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand 0.9.2",
+ "ring",
+ "rustc-hash",
+ "rustls 0.23.36",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.17",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2 0.6.1",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.43"
@@ -5384,7 +5488,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "reqwest",
+ "reqwest 0.13.2",
  "thiserror 1.0.69",
  "tokio",
  "tracing",
@@ -5504,6 +5608,44 @@ name = "reqwest"
 version = "0.12.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.8.1",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper 1.0.2",
+ "tokio",
+ "tokio-native-tls",
+ "tower 0.5.3",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
 dependencies = [
  "base64 0.22.1",
  "bytes",
@@ -5519,21 +5661,22 @@ dependencies = [
  "http-body-util",
  "hyper 1.8.1",
  "hyper-rustls 0.27.7",
- "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
  "mime",
- "native-tls",
  "percent-encoding",
  "pin-project-lite",
+ "quinn",
+ "rustls 0.23.36",
  "rustls-pki-types",
+ "rustls-platform-verifier",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper 1.0.2",
  "tokio",
- "tokio-native-tls",
+ "tokio-rustls 0.26.4",
  "tokio-util",
  "tower 0.5.3",
  "tower-http",
@@ -5777,9 +5920,37 @@ version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282"
 dependencies = [
+ "web-time",
  "zeroize",
 ]
 
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls 0.23.36",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki 0.103.8",
+ "security-framework 3.5.1",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
 [[package]]
 name = "rustls-webpki"
 version = "0.101.7"
@@ -5840,6 +6011,15 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "schannel"
 version = "0.1.28"
@@ -6209,7 +6389,7 @@ dependencies = [
  "rand 0.8.5",
  "rate-limit",
  "regex",
- "reqwest",
+ "reqwest 0.13.2",
  "rust_decimal",
  "serde",
  "serde_json",
@@ -6345,7 +6525,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "reqwest",
+ "reqwest 0.13.2",
  "serde",
  "serde_json",
  "serde_with",
@@ -7555,6 +7735,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "want"
 version = "0.3.1"
@@ -7587,9 +7777,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -7600,11 +7790,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.56"
+version = "0.4.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
 dependencies = [
  "cfg-if",
+ "futures-util",
  "js-sys",
  "once_cell",
  "wasm-bindgen",
@@ -7613,9 +7804,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -7623,9 +7814,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -7636,18 +7827,18 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "wasm-streams"
-version = "0.4.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
 dependencies = [
  "futures-util",
  "js-sys",
@@ -7672,9 +7863,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.83"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -7690,6 +7881,15 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
@@ -7718,6 +7918,15 @@ dependencies = [
  "wasite",
 ]
 
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.62.2"
@@ -7788,6 +7997,15 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -7824,6 +8042,21 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
@@ -7872,6 +8105,12 @@ dependencies = [
  "windows_x86_64_msvc 0.53.1",
 ]
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
@@ -7890,6 +8129,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.5"
@@ -7908,6 +8153,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.5"
@@ -7938,6 +8189,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.5"
@@ -7956,6 +8213,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.5"
@@ -7974,6 +8237,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.5"
@@ -7992,6 +8261,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.5"
diff --git a/Cargo.toml b/Cargo.toml
index 3d3b525730..3b65190132 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ prometheus = "0.13.4"
 prometheus-metric-storage = "0.5.0"
 rand = "0.8.5"
 regex = "1.10.4"
-reqwest = "0.12"
+reqwest = "0.13"
 rstest = "0.26"
 ruint = { version = "1.17.2", default-features = false }
 serde = { version = "1.0.203", features = ["derive"] }
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index e174bb026f..a3ceb59a24 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -41,7 +41,7 @@ number = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
-reqwest = { workspace = true }
+reqwest = { workspace = true, features = ["query"] }
 s3 = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde-ext = { workspace = true }
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index eb024a69ea..2541d0eb0c 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -31,7 +31,7 @@ model = { workspace = true, features = ["e2e"] }
 number = { workspace = true }
 observe = { workspace = true }
 orderbook = { workspace = true, features = ["e2e"] }
-reqwest = { workspace = true, features = ["blocking"] }
+reqwest = { workspace = true, features = ["blocking", "query"] }
 serde_json = { workspace = true }
 shared = { workspace = true }
 solver = { workspace = true }
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index b156517aec..3ae6756896 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -41,7 +41,7 @@ prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
 rate-limit = { workspace = true }
-reqwest = { workspace = true, features = ["cookies", "gzip", "json"] }
+reqwest = { workspace = true, features = ["cookies", "gzip", "json", "query"] }
 rust_decimal = { workspace = true, features = ["maths"] }
 serde = { workspace = true }
 serde_json = { workspace = true }

From 0743608fd386f8c1f02293514d05a2c5f69a6913 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 17:46:31 +0000
Subject: [PATCH 081/219] [TRIVIAL] Remove direct dependency on derivative
 crate (#4174)

# Description
I was reading through the issues when I saw the cargo audit one, even
though we still depend on derivative transitively (thus we can't remove
it from the audit list), getting Claude to remove our direct
dependencies was less than 5 minutes.

# Changes

- [ ] Replace derivative proc-macro usage with manual trait
implementations:

## How to test
Compilation + existing tests
---
 Cargo.lock                         |  2 -
 Cargo.toml                         |  1 -
 crates/shared/Cargo.toml           |  1 -
 crates/shared/src/zeroex_api.rs    | 41 +++++++++++++---
 crates/solver/Cargo.toml           |  1 -
 crates/solver/src/liquidity/mod.rs | 75 +++++++++++++++++++++---------
 6 files changed, 88 insertions(+), 33 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4ee0250813..875e41ae8e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6368,7 +6368,6 @@ dependencies = [
  "contracts",
  "dashmap",
  "database",
- "derivative",
  "derive_more 1.0.0",
  "ethrpc",
  "futures",
@@ -6480,7 +6479,6 @@ dependencies = [
  "async-trait",
  "const-hex",
  "contracts",
- "derivative",
  "ethrpc",
  "futures",
  "hex-literal",
diff --git a/Cargo.toml b/Cargo.toml
index 3b65190132..d3e4b4df54 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,6 @@ cached = { version = "0.49.3", default-features = false }
 chrono = { version = "0.4.38", default-features = false }
 clap = { version = "4.5.6", features = ["derive", "env"] }
 dashmap = "6.1.0"
-derivative = "2.2.0"
 derive_more = { version = "1.0.0", features = ["full"] }
 mimalloc = "0.1.43"
 tikv-jemallocator = { version = "0.6", features = ["unprefixed_malloc_on_supported_platforms", "profiling"] }
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 3ae6756896..9cc14c52b7 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -24,7 +24,6 @@ contracts = { workspace = true }
 dashmap = { workspace = true }
 database = { workspace = true }
 derive_more = { workspace = true }
-derivative = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
diff --git a/crates/shared/src/zeroex_api.rs b/crates/shared/src/zeroex_api.rs
index 32e3e8fa4d..9c3359cc02 100644
--- a/crates/shared/src/zeroex_api.rs
+++ b/crates/shared/src/zeroex_api.rs
@@ -8,7 +8,6 @@ use {
     alloy::primitives::{Address, B256, U256, address},
     anyhow::{Context, Result},
     chrono::{DateTime, NaiveDateTime, TimeZone, Utc},
-    derivative::Derivative,
     ethrpc::block_stream::{BlockInfo, CurrentBlockWatcher},
     number::serialization::HexOrDecimalU256,
     observe::tracing::tracing_headers,
@@ -82,11 +81,9 @@ impl Default for OrdersQuery {
 }
 
 #[serde_as]
-#[derive(Debug, Derivative, Clone, Deserialize, Serialize, Eq, PartialEq)]
-#[derivative(Default)]
+#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct OrderMetadata {
-    #[derivative(Default(value = "DateTime::<Utc>::MIN_UTC"))]
     pub created_at: DateTime<Utc>,
     #[serde(with = "bytes_hex")]
     pub order_hash: Vec<u8>,
@@ -94,6 +91,16 @@ pub struct OrderMetadata {
     pub remaining_fillable_taker_amount: u128,
 }
 
+impl Default for OrderMetadata {
+    fn default() -> Self {
+        Self {
+            created_at: DateTime::<Utc>::MIN_UTC,
+            order_hash: Default::default(),
+            remaining_fillable_taker_amount: Default::default(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct ZeroExSignature {
@@ -104,15 +111,13 @@ pub struct ZeroExSignature {
 }
 
 #[serde_as]
-#[derive(Debug, Derivative, Clone, Deserialize, Serialize, Eq, PartialEq)]
-#[derivative(Default)]
+#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct Order {
     /// The ID of the Ethereum chain where the `verifying_contract` is located.
     pub chain_id: u64,
     /// Timestamp in seconds of when the order expires. Expired orders cannot be
     /// filled.
-    #[derivative(Default(value = "NaiveDateTime::MAX.and_utc().timestamp() as u64"))]
     #[serde_as(as = "DisplayFromStr")]
     pub expiry: u64,
     /// The address of the entity that will receive any fees stipulated by the
@@ -156,6 +161,28 @@ pub struct Order {
     pub verifying_contract: Address,
 }
 
+impl Default for Order {
+    fn default() -> Self {
+        Self {
+            chain_id: Default::default(),
+            expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64,
+            fee_recipient: Default::default(),
+            maker: Default::default(),
+            maker_amount: Default::default(),
+            maker_token: Default::default(),
+            pool: Default::default(),
+            salt: Default::default(),
+            sender: Default::default(),
+            signature: Default::default(),
+            taker: Default::default(),
+            taker_amount: Default::default(),
+            taker_token: Default::default(),
+            taker_token_fee_amount: Default::default(),
+            verifying_contract: Default::default(),
+        }
+    }
+}
+
 #[derive(Debug, Default, Clone, Deserialize, Serialize, Eq, PartialEq)]
 pub struct OrderRecord(Arc<Inner>);
 
diff --git a/crates/solver/Cargo.toml b/crates/solver/Cargo.toml
index 71efe6cdcd..38c48ae415 100644
--- a/crates/solver/Cargo.toml
+++ b/crates/solver/Cargo.toml
@@ -34,7 +34,6 @@ tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 tracing = { workspace = true }
 
 [dev-dependencies]
-derivative = { workspace = true }
 maplit = { workspace = true }
 tokio = { workspace = true, features = ["test-util"] }
 testlib = { workspace = true }
diff --git a/crates/solver/src/liquidity/mod.rs b/crates/solver/src/liquidity/mod.rs
index cd4c789f49..5a118cd54b 100644
--- a/crates/solver/src/liquidity/mod.rs
+++ b/crates/solver/src/liquidity/mod.rs
@@ -4,8 +4,6 @@ pub mod uniswap_v2;
 pub mod uniswap_v3;
 pub mod zeroex;
 
-#[cfg(test)]
-use derivative::Derivative;
 use {
     crate::settlement::SettlementEncoder,
     alloy::primitives::{Address, U256},
@@ -85,8 +83,7 @@ pub enum Exchange {
 /// solvers. User orders (market + limit) containing OrderUid are the orders
 /// from the orderbook.
 #[derive(Debug, Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
+#[cfg_attr(test, derive(PartialEq))]
 pub enum LimitOrderId {
     Market(OrderUid),
     Limit(OrderUid),
@@ -102,8 +99,7 @@ pub enum LimitOrderId {
 /// (1) and (2) are gathered when the auction is cut and they are sent to
 /// searchers (3) are received from searchers as part of the solution.
 #[derive(Debug, Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
+#[cfg_attr(test, derive(PartialEq))]
 pub enum LiquidityOrderId {
     /// TODO: Split into different variants once we have a DTO of order model
     /// for `driver` in driver solver colocation TODO: The only reason why
@@ -130,8 +126,6 @@ impl From<u32> for LimitOrderId {
 
 /// Basic limit sell and buy orders
 #[derive(Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
 pub struct LimitOrder {
     // Opaque Identifier for debugging purposes
     pub id: LimitOrderId,
@@ -144,11 +138,25 @@ pub struct LimitOrder {
     pub partially_fillable: bool,
     /// Takes partiall fill into account.
     pub user_fee: U256,
-    #[cfg_attr(test, derivative(PartialEq = "ignore"))]
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
     pub exchange: Exchange,
 }
 
+#[cfg(test)]
+impl PartialEq for LimitOrder {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+            && self.sell_token == other.sell_token
+            && self.buy_token == other.buy_token
+            && self.sell_amount == other.sell_amount
+            && self.buy_amount == other.buy_amount
+            && self.kind == other.kind
+            && self.partially_fillable == other.partially_fillable
+            && self.user_fee == other.user_fee
+            && self.exchange == other.exchange
+    }
+}
+
 impl LimitOrder {
     /// Returns the full execution amount for the specified limit order.
     pub fn full_execution_amount(&self) -> U256 {
@@ -239,17 +247,24 @@ impl Default for LimitOrder {
 /// 2 sided constant product automated market maker with equal reserve value and
 /// a trading fee (e.g. Uniswap, Sushiswap)
 #[derive(Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
 pub struct ConstantProductOrder {
     pub address: Address,
     pub tokens: TokenPair,
     pub reserves: (u128, u128),
     pub fee: Ratio<u32>,
-    #[cfg_attr(test, derivative(PartialEq = "ignore"))]
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
 }
 
+#[cfg(test)]
+impl PartialEq for ConstantProductOrder {
+    fn eq(&self, other: &Self) -> bool {
+        self.address == other.address
+            && self.tokens == other.tokens
+            && self.reserves == other.reserves
+            && self.fee == other.fee
+    }
+}
+
 impl ConstantProductOrder {
     /// Creates a new constant product order from a Uniswap V2 pool and a
     /// settlement handler implementation.
@@ -280,17 +295,24 @@ impl From<Pool> for ConstantProductOrder {
 /// 2 sided weighted product automated market maker with weighted reserves and a
 /// trading fee (e.g. BalancerV2)
 #[derive(Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
 pub struct WeightedProductOrder {
     pub address: Address,
     pub reserves: BTreeMap<Address, WeightedTokenState>,
     pub fee: Bfp,
     pub version: WeightedPoolVersion,
-    #[cfg_attr(test, derivative(PartialEq = "ignore"))]
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
 }
 
+#[cfg(test)]
+impl PartialEq for WeightedProductOrder {
+    fn eq(&self, other: &Self) -> bool {
+        self.address == other.address
+            && self.reserves == other.reserves
+            && self.fee == other.fee
+            && self.version == other.version
+    }
+}
+
 impl std::fmt::Debug for WeightedProductOrder {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Weighted Product AMM {:?}", self.reserves.keys())
@@ -298,17 +320,24 @@ impl std::fmt::Debug for WeightedProductOrder {
 }
 
 #[derive(Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
 pub struct StablePoolOrder {
     pub address: Address,
     pub reserves: BTreeMap<Address, TokenState>,
     pub fee: Bfp,
     pub amplification_parameter: AmplificationParameter,
-    #[cfg_attr(test, derivative(PartialEq = "ignore"))]
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
 }
 
+#[cfg(test)]
+impl PartialEq for StablePoolOrder {
+    fn eq(&self, other: &Self) -> bool {
+        self.address == other.address
+            && self.reserves == other.reserves
+            && self.fee == other.fee
+            && self.amplification_parameter == other.amplification_parameter
+    }
+}
+
 impl std::fmt::Debug for StablePoolOrder {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Stable Pool AMM {:?}", self.reserves.keys())
@@ -348,15 +377,19 @@ impl Settleable for StablePoolOrder {
 
 /// Concentrated type of liquidity with ticks (e.g. UniswapV3)
 #[derive(Clone)]
-#[cfg_attr(test, derive(Derivative))]
-#[cfg_attr(test, derivative(PartialEq))]
 pub struct ConcentratedLiquidity {
     pub tokens: TokenPair,
     pub pool: PoolInfo,
-    #[cfg_attr(test, derivative(PartialEq = "ignore"))]
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
 }
 
+#[cfg(test)]
+impl PartialEq for ConcentratedLiquidity {
+    fn eq(&self, other: &Self) -> bool {
+        self.tokens == other.tokens && self.pool == other.pool
+    }
+}
+
 impl std::fmt::Debug for ConcentratedLiquidity {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Concentrated liquidity {:?}", self.pool)

From ffb235b40489e2c23f7f4ae93a7d9d156322da19 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 18 Feb 2026 19:23:36 +0100
Subject: [PATCH 082/219] Update Claude's victoria logs instructions (#4177)

# Description

An update of Claude's instructions after we migrated the logging system.
Also puts the querying behind a wrapper script so you can click "allow
reading logs" once instead of having to approve every single query.

Update your .env.claude from known sources.
---
 CLAUDE.md                     | 32 +++++++--------
 docs/COW_ORDER_DEBUG_SKILL.md | 71 ++++++++++----------------------
 scripts/vlogs                 | 76 +++++++++++++++++++++++++++++++++++
 3 files changed, 113 insertions(+), 66 deletions(-)
 create mode 100755 scripts/vlogs

diff --git a/CLAUDE.md b/CLAUDE.md
index 0ed24cd9cb..a8b983984f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -183,26 +183,24 @@ Use `$ETH_MAINNET_RPC` from `.env.claude` for mainnet. Use `cast` or whatever to
 
 ## Grafana Logs Access
 
-Query logs via the Grafana API (credentials in `.env.claude`):
+Use the `scripts/vlogs` wrapper to query Victoria Logs:
 
 ```bash
-source .env.claude && curl -s -H "Authorization: Bearer $GRAFANA_API_TOKEN" \
-  "$GRAFANA_URL/api/ds/query" \
-  -X POST -H "Content-Type: application/json" \
-  -d '{
-    "queries": [{
-      "refId": "A",
-      "datasource": {"type": "victoriametrics-logs-datasource", "uid": "'"$VICTORIA_LOGS_DATASOURCE_UID"'"},
-      "expr": "<search_term>",
-      "queryType": "instant"
-    }],
-    "from": "now-1h",
-    "to": "now"
-  }'
+# Basic usage
+scripts/vlogs "<expr>" [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]
+
+# Examples
+scripts/vlogs "NOT container:controller order created 0xabc..." --from now-24h
+scripts/vlogs "NOT container:controller network:mainnet settlement failed" --from now-6h --max 50
+scripts/vlogs "error" --env staging --from now-1h
+scripts/vlogs "NOT container:controller 0xabc..." --raw  # full JSON with labels
 ```
-Adjust expr for search terms (e.g., plasma, ink, error)
-Adjust from/to for time range (e.g., now-15m, now-24h)
-Parse log lines with: | jq -r '.results.A.frames[0].data.values[1][]'
+
+Defaults: `--from now-12h`, `--to now`, `--max 100`, `--env prod`
+
+Datasource UIDs (hardcoded in script): `vm-auth-prod` (production), `vm-auth-staging` (staging)
+
+With `--raw`, each log entry has an `all` field containing the full unparsed JSON log message (with timestamp, level, fields, spans, trace_id). Useful for extracting structured data like `order_uid`, `quote_id`, `request_id`, etc.
 
 ## Etherscan API (V2)
 
diff --git a/docs/COW_ORDER_DEBUG_SKILL.md b/docs/COW_ORDER_DEBUG_SKILL.md
index 02020253ff..4f9e719653 100644
--- a/docs/COW_ORDER_DEBUG_SKILL.md
+++ b/docs/COW_ORDER_DEBUG_SKILL.md
@@ -85,71 +85,44 @@ cast call $SETTLEMENT_CONTRACT "preSignature(bytes)" $ORDER_UID --rpc-url $RPC
 
 Logs are stored in Victoria Logs and accessible via Grafana API.
 
-**Query template (bash):**
+**Query using `scripts/vlogs`:**
 ```bash
-# Set time range (milliseconds)
-NOW_MS=$(($(date +%s) * 1000))
-FROM_MS=$((NOW_MS - 43200000))  # 12 hours ago
-
-# Set search term (use full order UID with 0x prefix)
-SEARCH_TERM="0xd997dc715a7610c75e5f97548685befacb7ea5ad878cb4bac1816903514ed84d1dffc418c0d83bd8b98ab3d2e07b83bf5439f4236981a392"
-
-# Query Victoria Logs
-# - NOT container:controller excludes nginx access logs
-# - network:$NETWORK filters to specific chain (mainnet, bnb, arbitrum-one, base, etc)
-source .env.claude
-curl -s "${GRAFANA_URL}/api/ds/query?ds_type=victoriametrics-logs-datasource" \
-  -H 'accept: application/json' \
-  -H 'content-type: application/json' \
-  -H "x-datasource-uid: ${VICTORIA_LOGS_DATASOURCE_UID}" \
-  -H 'x-plugin-id: victoriametrics-logs-datasource' \
-  -H "Authorization: Bearer ${GRAFANA_API_TOKEN}" \
-  --data-raw "{\"queries\":[{\"refId\":\"A\",\"datasource\":{\"type\":\"victoriametrics-logs-datasource\",\"uid\":\"${VICTORIA_LOGS_DATASOURCE_UID}\"},\"editorMode\":\"code\",\"expr\":\"NOT container:controller ${SEARCH_TERM} | sort by (_time) asc\",\"queryType\":\"instant\",\"maxLines\":100}],\"from\":\"${FROM_MS}\",\"to\":\"${NOW_MS}\"}" \
-  | jq -r '.results.A.frames[0].data.values[1][]'
-```
-
-**Key query parameters:**
-- `expr`: Search term (just text, e.g., order UID or auction ID). Add `| sort by (_time) asc` for chronological order
-- `queryType`: Use `"instant"` to get log lines. Use `"hits"` to get histogram/counts
-- `maxLines`: Number of log lines to return
-- `from`/`to`: Millisecond timestamps
+# Basic: search by order UID (use full UID with 0x prefix)
+scripts/vlogs "NOT container:controller ORDER_UID"
 
-**Example searches:**
-```bash
-# Search by order UID for a specific network, excluding nginx
-"expr": "NOT container:controller network:bnb ORDER_UID | sort by (_time) asc"
+# Filter by network
+scripts/vlogs "NOT container:controller network:bnb ORDER_UID"
 
 # Search by auction ID
-"expr": "NOT container:controller 22788649 | sort by (_time) asc"
+scripts/vlogs "NOT container:controller 22788649"
 
 # Search by solver name + auction
-"expr": "NOT container:controller baseline 22788649 | sort by (_time) asc"
+scripts/vlogs "NOT container:controller baseline 22788649"
 
-# Filter by log content on specific network
-"expr": "NOT container:controller network:mainnet order cancelled | sort by (_time) asc"
+# Custom time range and max lines
+scripts/vlogs "NOT container:controller ORDER_UID" --from now-24h --max 200
 
-# Search by request_id to trace quote→bid issues (useful when order was placed with quote from solver X but that solver never bid)
-"expr": "NOT container:controller $REQUEST_ID | sort by (_time) asc"
+# Full JSON output (includes labels like network, pod, parsed fields)
+scripts/vlogs "NOT container:controller ORDER_UID" --raw
 ```
 
-**Useful filters:**
+**Useful filters (part of the expr):**
 - `NOT container:controller` — excludes nginx access logs (REQUIRED for order UID searches)
-- `network:$NETWORK` — filter by chain (works for some log sources, not all)
+- `network:$NETWORK` — filter by chain (mainnet, bnb, arbitrum-one, base, etc)
 
 **Note:** Victoria Logs uses simple text matching. Always use the **full order UID with 0x prefix** for reliable matching.
 
-**IMPORTANT - Run targeted lifecycle queries:** Always use `NOT container:controller` to exclude nginx:
+**IMPORTANT - Run targeted lifecycle queries in parallel** (use FULL order UID with 0x):
 
 ```bash
-# Run these queries IN PARALLEL to quickly find all lifecycle events (use FULL order UID with 0x):
-"expr": "NOT container:controller order created ORDER_UID | sort by (_time) asc"
-"expr": "NOT container:controller order cancelled ORDER_UID | sort by (_time) asc"
-"expr": "NOT container:controller proposed solution ORDER_UID | sort by (_time) asc"
-"expr": "NOT container:controller settlement failed ORDER_UID | sort by (_time) asc"
-"expr": "NOT container:controller filtered ORDER_UID | sort by (_time) asc"
-
-# Find discarded solutions where order appears in calldata (use regex with order UID bytes without 0x prefix)
-"expr": "discarded .*ORDER_UID_WITHOUT_0X.* | sort by (_time) asc"
+scripts/vlogs "NOT container:controller order created ORDER_UID"
+scripts/vlogs "NOT container:controller order cancelled ORDER_UID"
+scripts/vlogs "NOT container:controller proposed solution ORDER_UID"
+scripts/vlogs "NOT container:controller settlement failed ORDER_UID"
+scripts/vlogs "NOT container:controller filtered ORDER_UID"
+
+# Find discarded solutions where order appears in calldata (use order UID bytes without 0x prefix)
+scripts/vlogs "discarded .*ORDER_UID_WITHOUT_0X.*"
 ```
 
 **What to look for:**
diff --git a/scripts/vlogs b/scripts/vlogs
new file mode 100755
index 0000000000..ed1616df2b
--- /dev/null
+++ b/scripts/vlogs
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Query Victoria Logs via Grafana API
+# Usage: vlogs <expr> [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]
+#
+# Examples:
+#   vlogs "order cancelled 0xabc123..."
+#   vlogs "NOT container:controller order created" --from now-24h --max 50
+#   vlogs "network:mainnet settlement failed" --from now-6h --env prod
+#   vlogs "error" --raw   # output full JSON instead of just log lines
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "$SCRIPT_DIR/.env.claude"
+
+# Defaults
+FROM="now-12h"
+TO="now"
+MAX_LINES=100
+ENV="prod"
+RAW=false
+
+# Parse arguments
+EXPR=""
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --from) FROM="$2"; shift 2 ;;
+    --to) TO="$2"; shift 2 ;;
+    --max) MAX_LINES="$2"; shift 2 ;;
+    --env) ENV="$2"; shift 2 ;;
+    --raw) RAW=true; shift ;;
+    --help|-h)
+      sed -n '2,8p' "$0"
+      exit 0
+      ;;
+    *)
+      if [[ -z "$EXPR" ]]; then
+        EXPR="$1"
+      else
+        EXPR="$EXPR $1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$EXPR" ]]; then
+  echo "Usage: vlogs <expr> [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]" >&2
+  exit 1
+fi
+
+case "$ENV" in
+  prod)    DS_UID="vm-auth-prod" ;;
+  staging) DS_UID="vm-auth-staging" ;;
+  *)       echo "Unknown env: $ENV (use prod or staging)" >&2; exit 1 ;;
+esac
+
+RESPONSE=$(curl -s --max-time 60 \
+  "${GRAFANA_URL}/api/ds/query?ds_type=victoriametrics-logs-datasource" \
+  -H 'content-type: application/json' \
+  -H "Authorization: Bearer ${GRAFANA_API_TOKEN}" \
+  -d "{\"queries\":[{\"refId\":\"A\",\"datasource\":{\"type\":\"victoriametrics-logs-datasource\",\"uid\":\"${DS_UID}\"},\"expr\":\"${EXPR} | sort by (_time) asc\",\"queryType\":\"instant\",\"maxLines\":${MAX_LINES}}],\"from\":\"${FROM}\",\"to\":\"${TO}\"}")
+
+if [[ -z "$RESPONSE" ]]; then
+  echo "Error: empty response (timeout or connection failure)" >&2
+  exit 1
+fi
+
+if [[ "$RAW" == "true" ]]; then
+  echo "$RESPONSE" | jq .
+else
+  echo "$RESPONSE" | jq -r '.results.A.frames[0].data.values[1][]' 2>/dev/null || {
+    echo "No results or unexpected response:" >&2
+    echo "$RESPONSE" | jq . 2>/dev/null || echo "$RESPONSE" >&2
+  }
+fi

From 4ccda4c17c72433b312519765f3316761f20b0e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 18 Feb 2026 19:08:03 +0000
Subject: [PATCH 083/219] Add extra label to distinguish requests with the same
 path (#4176)

# Description
The orderbook has some paths that are getting merged in the grafana
metrics, this fixes it by formatting it as "{HTTP Method} {Path}"

# Changes

- [ ] Change the label name / format to "{HTTP Method} {Path}"

## How to test
Staging
---
 crates/orderbook/src/api.rs | 110 ++++++++++++++++++++++--------------
 1 file changed, 69 insertions(+), 41 deletions(-)

diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 30d0fed648..3b3ae455ad 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -12,6 +12,7 @@ use {
         http::{Request, StatusCode, header::USER_AGENT},
         middleware::{self, Next},
         response::{IntoResponse, Json, Response},
+        routing::{delete, get, post, put},
     },
     observe::distributed_tracing::tracing_axum::{self, record_trace_id},
     serde::{Deserialize, Serialize},
@@ -98,18 +99,18 @@ async fn summarize_request(req: Request<axum::body::Body>, next: Next) -> Respon
 async fn with_matched_path_metric(req: Request<axum::body::Body>, next: Next) -> Response {
     let metrics = ApiMetrics::instance(observe::metrics::get_storage_registry()).unwrap();
 
-    // Extract matched path and HTTP method
+    let http_method = req.method().as_str();
     let matched_path = req
         .extensions()
         .get::<axum::extract::MatchedPath>()
         .map(|path| path.as_str())
-        .unwrap_or("unknown")
-        .to_string();
+        .unwrap_or("unknown");
+    let method_with_path = format!("{http_method} {matched_path}");
 
     let response = {
         let _timer = metrics
             .requests_duration_seconds
-            .with_label_values(&[&matched_path])
+            .with_label_values(&[&method_with_path])
             .start_timer();
         next.run(req).await
     };
@@ -118,7 +119,7 @@ async fn with_matched_path_metric(req: Request<axum::body::Body>, next: Next) ->
     // Track completed requests
     metrics
         .requests_complete
-        .with_label_values(&[&matched_path, status.as_str()])
+        .with_label_values(&[&method_with_path, status.as_str()])
         .inc();
 
     // Track rejected requests (4xx and 5xx status codes)
@@ -158,97 +159,121 @@ pub fn handle_all_routes(
     let routes = [
         // V1 routes
         (
+            "GET",
             "/api/v1/account/{owner}/orders",
-            axum::routing::get(get_user_orders::get_user_orders_handler),
+            get(get_user_orders::get_user_orders_handler),
         ),
         (
+            "PUT",
             "/api/v1/app_data",
-            axum::routing::put(put_app_data::put_app_data_without_hash)
+            put(put_app_data::put_app_data_without_hash)
                 .layer(DefaultBodyLimit::max(app_data_size_limit)),
         ),
         (
+            "GET",
+            "/api/v1/app_data/{hash}",
+            get(get_app_data::get_app_data_handler),
+        ),
+        (
+            "PUT",
             "/api/v1/app_data/{hash}",
-            axum::routing::get(get_app_data::get_app_data_handler).merge(
-                axum::routing::put(put_app_data::put_app_data_with_hash)
-                    .layer(DefaultBodyLimit::max(app_data_size_limit)),
-            ),
+            put(put_app_data::put_app_data_with_hash)
+                .layer(DefaultBodyLimit::max(app_data_size_limit)),
         ),
         (
+            "GET",
             "/api/v1/auction",
-            axum::routing::get(get_auction::get_auction_handler),
+            get(get_auction::get_auction_handler),
+        ),
+        (
+            "POST",
+            "/api/v1/orders",
+            post(post_order::post_order_handler),
         ),
         (
+            "DELETE",
             "/api/v1/orders",
-            axum::routing::post(post_order::post_order_handler)
-                .merge(axum::routing::delete(cancel_orders::cancel_orders_handler)),
+            delete(cancel_orders::cancel_orders_handler),
         ),
         (
+            "GET",
             "/api/v1/orders/{uid}",
-            axum::routing::get(get_order_by_uid::get_order_by_uid_handler)
-                .merge(axum::routing::delete(cancel_order::cancel_order_handler)),
+            get(get_order_by_uid::get_order_by_uid_handler),
         ),
         (
+            "DELETE",
+            "/api/v1/orders/{uid}",
+            delete(cancel_order::cancel_order_handler),
+        ),
+        (
+            "GET",
             "/api/v1/orders/{uid}/status",
-            axum::routing::get(get_order_status::get_status_handler),
+            get(get_order_status::get_status_handler),
         ),
         (
+            "POST",
             "/api/v1/quote",
-            axum::routing::post(post_quote::post_quote_handler),
+            post(post_quote::post_quote_handler),
         ),
         // /solver_competition routes (specific before parameterized)
         (
+            "GET",
             "/api/v1/solver_competition/latest",
-            axum::routing::get(get_solver_competition::get_solver_competition_latest_handler),
+            get(get_solver_competition::get_solver_competition_latest_handler),
         ),
         (
+            "GET",
             "/api/v1/solver_competition/by_tx_hash/{tx_hash}",
-            axum::routing::get(get_solver_competition::get_solver_competition_by_hash_handler),
+            get(get_solver_competition::get_solver_competition_by_hash_handler),
         ),
         (
+            "GET",
             "/api/v1/solver_competition/{auction_id}",
-            axum::routing::get(get_solver_competition::get_solver_competition_by_id_handler),
+            get(get_solver_competition::get_solver_competition_by_id_handler),
         ),
         (
+            "GET",
             "/api/v1/token/{token}/metadata",
-            axum::routing::get(get_token_metadata::get_token_metadata_handler),
+            get(get_token_metadata::get_token_metadata_handler),
         ),
         (
+            "GET",
             "/api/v1/token/{token}/native_price",
-            axum::routing::get(get_native_price::get_native_price_handler),
-        ),
-        (
-            "/api/v1/trades",
-            axum::routing::get(get_trades::get_trades_handler),
+            get(get_native_price::get_native_price_handler),
         ),
+        ("GET", "/api/v1/trades", get(get_trades::get_trades_handler)),
         (
+            "GET",
             "/api/v1/transactions/{hash}/orders",
-            axum::routing::get(get_orders_by_tx::get_orders_by_tx_handler),
+            get(get_orders_by_tx::get_orders_by_tx_handler),
         ),
         (
+            "GET",
             "/api/v1/users/{user}/total_surplus",
-            axum::routing::get(get_total_surplus::get_total_surplus_handler),
-        ),
-        (
-            "/api/v1/version",
-            axum::routing::get(version::version_handler),
+            get(get_total_surplus::get_total_surplus_handler),
         ),
+        ("GET", "/api/v1/version", get(version::version_handler)),
         // V2 routes
         // /solver_competition routes (specific before parameterized)
         (
+            "GET",
             "/api/v2/solver_competition/latest",
-            axum::routing::get(get_solver_competition_v2::get_solver_competition_latest_handler),
+            get(get_solver_competition_v2::get_solver_competition_latest_handler),
         ),
         (
+            "GET",
             "/api/v2/solver_competition/by_tx_hash/{tx_hash}",
-            axum::routing::get(get_solver_competition_v2::get_solver_competition_by_hash_handler),
+            get(get_solver_competition_v2::get_solver_competition_by_hash_handler),
         ),
         (
+            "GET",
             "/api/v2/solver_competition/{auction_id}",
-            axum::routing::get(get_solver_competition_v2::get_solver_competition_by_id_handler),
+            get(get_solver_competition_v2::get_solver_competition_by_id_handler),
         ),
         (
+            "GET",
             "/api/v2/trades",
-            axum::routing::get(get_trades_v2::get_trades_handler),
+            get(get_trades_v2::get_trades_handler),
         ),
     ];
 
@@ -257,8 +282,8 @@ pub fn handle_all_routes(
     metrics.reset_requests_rejected();
 
     let mut api_router = Router::new();
-    for (path, method_router) in routes {
-        metrics.reset_requests_complete(path);
+    for (method, path, method_router) in routes {
+        metrics.reset_requests_complete(method, path);
         api_router = api_router.route(path, method_router);
     }
     let api_router = api_router.with_state(state);
@@ -286,6 +311,8 @@ pub fn handle_all_routes(
         )
 }
 
+// NOTE(jmg-duarte): method is actually the request path, to avoid breaking
+// dashboards, the http_method was added
 #[derive(prometheus_metric_storage::MetricStorage, Clone, Debug)]
 #[metric(subsystem = "api")]
 struct ApiMetrics {
@@ -324,10 +351,11 @@ impl ApiMetrics {
         }
     }
 
-    fn reset_requests_complete(&self, path: &str) {
+    fn reset_requests_complete(&self, method: &str, path: &str) {
+        let method_with_path = format!("{method} {path}");
         for status in Self::INITIAL_STATUSES {
             self.requests_complete
-                .with_label_values(&[path, status.as_str()])
+                .with_label_values(&[&method_with_path, status.as_str()])
                 .reset();
         }
     }

From 6eb0a0f22626834426f976215e58378090e35a6c Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 19 Feb 2026 10:48:39 +0100
Subject: [PATCH 084/219] Make sure payload is correctly formatted (#4178)

# Description

Makes sure JSON payload is correctly escaped.
---
 scripts/vlogs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/scripts/vlogs b/scripts/vlogs
index ed1616df2b..048ae26720 100755
--- a/scripts/vlogs
+++ b/scripts/vlogs
@@ -55,11 +55,19 @@ case "$ENV" in
   *)       echo "Unknown env: $ENV (use prod or staging)" >&2; exit 1 ;;
 esac
 
+PAYLOAD=$(jq -n \
+  --arg uid "$DS_UID" \
+  --arg expr "$EXPR | sort by (_time) asc" \
+  --argjson maxLines "$MAX_LINES" \
+  --arg from "$FROM" \
+  --arg to "$TO" \
+  '{queries: [{refId: "A", datasource: {type: "victoriametrics-logs-datasource", uid: $uid}, expr: $expr, queryType: "instant", maxLines: $maxLines}], from: $from, to: $to}')
+
 RESPONSE=$(curl -s --max-time 60 \
   "${GRAFANA_URL}/api/ds/query?ds_type=victoriametrics-logs-datasource" \
   -H 'content-type: application/json' \
   -H "Authorization: Bearer ${GRAFANA_API_TOKEN}" \
-  -d "{\"queries\":[{\"refId\":\"A\",\"datasource\":{\"type\":\"victoriametrics-logs-datasource\",\"uid\":\"${DS_UID}\"},\"expr\":\"${EXPR} | sort by (_time) asc\",\"queryType\":\"instant\",\"maxLines\":${MAX_LINES}}],\"from\":\"${FROM}\",\"to\":\"${TO}\"}")
+  -d "$PAYLOAD")
 
 if [[ -z "$RESPONSE" ]]; then
   echo "Error: empty response (timeout or connection failure)" >&2

From c1014b7f59cc937e64b596977e62c1e46d78f126 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 19 Feb 2026 09:49:02 +0000
Subject: [PATCH 085/219] Bump sqlx to 0.8 and bigdecimal to 0.4 (#4175)

# Description
Since the newer axum landed and its friends are also being upgraded,
upgrading SQLx removes the "this code won't compile in a future version
of Rust warning, solves the cargo-audit part of the issue and even
reduces the size of some structs.

# Changes
- [ ] sqlx 0.7 -> 0.8; add 'derive' feature (required in 0.8 for
#[derive(sqlx::FromRow)] and #[derive(sqlx::Type)])
- [ ] bigdecimal 0.3 -> 0.4 (required by sqlx-postgres 0.8)
- [ ] Remove unfulfilled #[expect(clippy::large_enum_variant)] in
LeaderLockTracker (no longer needed because sqlx 0.8 reduced the type of
the Postgres connection by boxing it)
- [ ] Remove RUSTSEC-2024-0363 audit ignore (fixed by upgrading to sqlx
0.8.1+)


## How to test
Compile + testing in staging
---
 .cargo/audit.toml                           |   4 -
 Cargo.lock                                  | 139 ++++++--------------
 Cargo.toml                                  |   4 +-
 crates/autopilot/src/leader_lock_tracker.rs |   1 -
 crates/database/src/auction_prices.rs       |   2 +-
 crates/database/src/byte_array.rs           |   4 +-
 6 files changed, 48 insertions(+), 106 deletions(-)

diff --git a/.cargo/audit.toml b/.cargo/audit.toml
index 6b6afa04fe..7a70e26a46 100644
--- a/.cargo/audit.toml
+++ b/.cargo/audit.toml
@@ -21,10 +21,6 @@ ignore = [
     # No patch available yet (cryptography vulnerability)
     "RUSTSEC-2023-0071",
 
-    # sqlx - Binary protocol overflow (RUSTSEC-2024-0363)
-    # Needs upgrade to 0.8.1+ (breaking changes, tracked in #3338)
-    "RUSTSEC-2024-0363",
-
     # tracing-subscriber - ANSI escape injection (RUSTSEC-2025-0055)
     # Needs upgrade to 0.3.20+ (minimal risk in current usage)
     "RUSTSEC-2025-0055",
diff --git a/Cargo.lock b/Cargo.lock
index 875e41ae8e..f39bc6a032 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,19 +17,6 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
-[[package]]
-name = "ahash"
-version = "0.8.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
-dependencies = [
- "cfg-if",
- "getrandom 0.3.4",
- "once_cell",
- "version_check",
- "zerocopy",
-]
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -646,7 +633,7 @@ dependencies = [
  "alloy-json-abi",
  "alloy-sol-macro-input",
  "const-hex",
- "heck 0.5.0",
+ "heck",
  "indexmap 2.13.0",
  "proc-macro-error2",
  "proc-macro2",
@@ -665,7 +652,7 @@ dependencies = [
  "alloy-json-abi",
  "const-hex",
  "dunce",
- "heck 0.5.0",
+ "heck",
  "macro-string",
  "proc-macro2",
  "quote",
@@ -1087,7 +1074,7 @@ version = "3.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
 dependencies = [
- "event-listener 5.4.1",
+ "event-listener",
  "event-listener-strategy",
  "pin-project-lite",
 ]
@@ -1846,10 +1833,12 @@ checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445"
 
 [[package]]
 name = "bigdecimal"
-version = "0.3.1"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6773ddc0eafc0e509fb60e48dff7f450f8e674a0686ae8605e8d9901bd5eefa"
+checksum = "4d6867f1565b3aad85681f1015055b087fcfd840d6aeee6eee7f2da317603695"
 dependencies = [
+ "autocfg",
+ "libm",
  "num-bigint",
  "num-integer",
  "num-traits",
@@ -2128,7 +2117,7 @@ version = "4.5.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn 2.0.114",
@@ -3019,12 +3008,6 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "event-listener"
-version = "2.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
-
 [[package]]
 name = "event-listener"
 version = "5.4.1"
@@ -3042,7 +3025,7 @@ version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
 dependencies = [
- "event-listener 5.4.1",
+ "event-listener",
  "pin-project-lite",
 ]
 
@@ -3405,10 +3388,6 @@ name = "hashbrown"
 version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
-dependencies = [
- "ahash",
- "allocator-api2",
-]
 
 [[package]]
 name = "hashbrown"
@@ -3436,11 +3415,11 @@ dependencies = [
 
 [[package]]
 name = "hashlink"
-version = "0.8.4"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
 dependencies = [
- "hashbrown 0.14.5",
+ "hashbrown 0.15.5",
 ]
 
 [[package]]
@@ -3456,15 +3435,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -4154,11 +4124,10 @@ dependencies = [
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.27.0"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4e226dcd58b4be396f7bd3c20da8fdee2911400705297ba7d2d7cc2c30f716"
+checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
 dependencies = [
- "cc",
  "pkg-config",
  "vcpkg",
 ]
@@ -4401,7 +4370,7 @@ dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
  "equivalent",
- "event-listener 5.4.1",
+ "event-listener",
  "futures-util",
  "parking_lot",
  "portable-atomic",
@@ -6576,21 +6545,11 @@ dependencies = [
  "der",
 ]
 
-[[package]]
-name = "sqlformat"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bba3a93db0cc4f7bdece8bb09e77e2e785c20bfebf79eb8340ed80708048790"
-dependencies = [
- "nom",
- "unicode_categories",
-]
-
 [[package]]
 name = "sqlx"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9a2ccff1a000a5a59cd33da541d9f2fdcd9e6e8229cc200565942bff36d0aaa"
+checksum = "1fefb893899429669dcdd979aff487bd78f4064e5e7907e4269081e0ef7d97dc"
 dependencies = [
  "sqlx-core",
  "sqlx-macros",
@@ -6601,40 +6560,35 @@ dependencies = [
 
 [[package]]
 name = "sqlx-core"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24ba59a9342a3d9bab6c56c118be528b27c9b60e490080e9711a04dccac83ef6"
+checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6"
 dependencies = [
- "ahash",
- "atoi",
+ "base64 0.22.1",
  "bigdecimal",
- "byteorder",
  "bytes",
  "chrono",
  "crc",
  "crossbeam-queue",
  "either",
- "event-listener 2.5.3",
- "futures-channel",
+ "event-listener",
  "futures-core",
  "futures-intrusive",
  "futures-io",
  "futures-util",
+ "hashbrown 0.15.5",
  "hashlink",
- "hex",
  "indexmap 2.13.0",
  "log",
  "memchr",
  "native-tls",
  "once_cell",
- "paste",
  "percent-encoding",
  "serde",
  "serde_json",
  "sha2",
  "smallvec",
- "sqlformat",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tokio",
  "tokio-stream",
  "tracing",
@@ -6643,26 +6597,26 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea40e2345eb2faa9e1e5e326db8c34711317d2b5e08d0d5741619048a803127"
+checksum = "a2d452988ccaacfbf5e0bdbc348fb91d7c8af5bee192173ac3636b5fb6e6715d"
 dependencies = [
  "proc-macro2",
  "quote",
  "sqlx-core",
  "sqlx-macros-core",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
 name = "sqlx-macros-core"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5833ef53aaa16d860e92123292f1f6a3d53c34ba8b1969f152ef1a7bb803f3c8"
+checksum = "19a9c1841124ac5a61741f96e1d9e2ec77424bf323962dd894bdb93f37d5219b"
 dependencies = [
  "dotenvy",
  "either",
- "heck 0.4.1",
+ "heck",
  "hex",
  "once_cell",
  "proc-macro2",
@@ -6674,20 +6628,19 @@ dependencies = [
  "sqlx-mysql",
  "sqlx-postgres",
  "sqlx-sqlite",
- "syn 1.0.109",
- "tempfile",
+ "syn 2.0.114",
  "tokio",
  "url",
 ]
 
 [[package]]
 name = "sqlx-mysql"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ed31390216d20e538e447a7a9b959e06ed9fc51c37b514b46eb758016ecd418"
+checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
  "atoi",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bigdecimal",
  "bitflags 2.10.0",
  "byteorder",
@@ -6719,19 +6672,19 @@ dependencies = [
  "smallvec",
  "sqlx-core",
  "stringprep",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tracing",
  "whoami",
 ]
 
 [[package]]
 name = "sqlx-postgres"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c824eb80b894f926f89a0b9da0c7f435d27cdd35b8c655b114e58223918577e"
+checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
  "atoi",
- "base64 0.21.7",
+ "base64 0.22.1",
  "bigdecimal",
  "bitflags 2.10.0",
  "byteorder",
@@ -6741,7 +6694,6 @@ dependencies = [
  "etcetera",
  "futures-channel",
  "futures-core",
- "futures-io",
  "futures-util",
  "hex",
  "hkdf",
@@ -6760,16 +6712,16 @@ dependencies = [
  "smallvec",
  "sqlx-core",
  "stringprep",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "tracing",
  "whoami",
 ]
 
 [[package]]
 name = "sqlx-sqlite"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b244ef0a8414da0bed4bb1910426e890b19e5e9bccc27ada6b797d05c55ae0aa"
+checksum = "c2d12fe70b2c1b4401038055f90f151b78208de1f9f89a7dbfd41587a10c3eea"
 dependencies = [
  "atoi",
  "chrono",
@@ -6783,10 +6735,11 @@ dependencies = [
  "log",
  "percent-encoding",
  "serde",
+ "serde_urlencoded",
  "sqlx-core",
+ "thiserror 2.0.17",
  "tracing",
  "url",
- "urlencoding",
 ]
 
 [[package]]
@@ -6833,7 +6786,7 @@ version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn 2.0.114",
@@ -7628,12 +7581,6 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
-[[package]]
-name = "unicode_categories"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"
diff --git a/Cargo.toml b/Cargo.toml
index d3e4b4df54..3ed66ce276 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,7 @@ alloy-signer = { version = "1.7.3", default-features = false}
 anyhow = "1.0.100"
 async-trait = "0.1.80"
 axum = "0.8"
-bigdecimal = "0.3"
+bigdecimal = "0.4"
 cached = { version = "0.49.3", default-features = false }
 chrono = { version = "0.4.38", default-features = false }
 clap = { version = "4.5.6", features = ["derive", "env"] }
@@ -42,7 +42,7 @@ ruint = { version = "1.17.2", default-features = false }
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.117"
 serde_with = "3.8.1"
-sqlx = { version = "0.7", default-features = false, features = ["runtime-tokio", "tls-native-tls", "bigdecimal", "chrono", "postgres", "macros"] }
+sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "tls-native-tls", "bigdecimal", "chrono", "postgres", "macros", "derive"] }
 strum = { version = "0.27.2", features = ["derive"] }
 tempfile = "3.10.1"
 thiserror = "1.0.61"
diff --git a/crates/autopilot/src/leader_lock_tracker.rs b/crates/autopilot/src/leader_lock_tracker.rs
index 6bea9a6d3a..5c0458dfb9 100644
--- a/crates/autopilot/src/leader_lock_tracker.rs
+++ b/crates/autopilot/src/leader_lock_tracker.rs
@@ -2,7 +2,6 @@ use {database::leader_pg_lock::LeaderLock, observe::metrics};
 
 /// Tracks the autopilot leader lock status.
 /// Leader lock status is tracked based on calls to try_acquire()
-#[expect(clippy::large_enum_variant)]
 pub enum LeaderLockTracker {
     /// Leader lock mechanism is disabled.
     /// Only one autopilot instance should be running at all times.
diff --git a/crates/database/src/auction_prices.rs b/crates/database/src/auction_prices.rs
index 1db843d7e8..de8b1f57c6 100644
--- a/crates/database/src/auction_prices.rs
+++ b/crates/database/src/auction_prices.rs
@@ -142,6 +142,6 @@ mod tests {
             .await
             .unwrap()
             .unwrap();
-        assert_eq!(output, 3.into());
+        assert_eq!(output, BigDecimal::from(3));
     }
 }
diff --git a/crates/database/src/byte_array.rs b/crates/database/src/byte_array.rs
index e4886bbe40..0bca4af378 100644
--- a/crates/database/src/byte_array.rs
+++ b/crates/database/src/byte_array.rs
@@ -62,8 +62,8 @@ impl<const N: usize> Decode<'_, Postgres> for ByteArray<N> {
 }
 
 impl<const N: usize> Encode<'_, Postgres> for ByteArray<N> {
-    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull {
-        self.0.encode(buf)
+    fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> Result<IsNull, BoxDynError> {
+        self.0.encode_by_ref(buf)
     }
 }
 

From 871a312758897dded7a8c240c5be52d9821ac9fd Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Thu, 19 Feb 2026 12:34:27 +0100
Subject: [PATCH 086/219] autopilot: filter `&Order` instead of `Arc<Order>`
 (#4179)

# Description
In https://github.com/cowprotocol/services/pull/4153 I conjectured that
running the filter passes over `Vec<Arc<Order>>` will likely be as fast
as `Vec<&Order>`. To validate that claim I temporarily deployed this PR
and it did indeed drop the average average time to update solvable
orders by around 30ms. I suspect this is because memory pre-fetching
works better with pure slices of references instead of smart pointers
which may differ in layout depending on the compiled language.
<img width="1303" height="305" alt="Screenshot 2026-02-19 at 08 04 39"
src="https://github.com/user-attachments/assets/ae1f969d-1269-431e-8c15-783bda86401d"
/>

# Changes
- run all functions in solvable orders cache over `Vec<&Order>` instead
of `Vec<Arc<Order>>`.

## How to test
measured on prod
---
 crates/autopilot/src/solvable_orders.rs | 101 +++++++++++++-----------
 1 file changed, 55 insertions(+), 46 deletions(-)

diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 226e6f0d02..dc3c7b29fd 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -99,7 +99,7 @@ impl Metrics {
     }
 
     #[instrument(skip_all)]
-    fn track_orders_in_final_auction(orders: &[Arc<Order>]) {
+    fn track_orders_in_final_auction(orders: &[&Order]) {
         let metrics = Metrics::get();
         metrics.auction_creations.inc();
 
@@ -207,7 +207,7 @@ impl SolvableOrdersCache {
         let orders = db_solvable_orders
             .orders
             .values()
-            .cloned()
+            .map(|order| order.as_ref())
             .collect::<Vec<_>>();
 
         let mut invalid_order_uids = HashSet::new();
@@ -227,7 +227,7 @@ impl SolvableOrdersCache {
         let (balances, orders, cow_amms) = {
             let queries = orders
                 .iter()
-                .map(|o| Query::from_order(o.as_ref()))
+                .map(|o| Query::from_order(o))
                 .collect::<Vec<_>>();
             tokio::join!(
                 self.fetch_balances(queries),
@@ -335,11 +335,8 @@ impl SolvableOrdersCache {
                             .quotes
                             .get(&order.metadata.uid.into())
                             .map(|quote| quote.as_ref().clone());
-                        self.protocol_fees.apply(
-                            order.as_ref(),
-                            quote,
-                            &surplus_capturing_jit_order_owners,
-                        )
+                        self.protocol_fees
+                            .apply(order, quote, &surplus_capturing_jit_order_owners)
                     })
                     .collect()
             }),
@@ -433,11 +430,11 @@ impl SolvableOrdersCache {
 
     /// Executed orders filtering in parallel.
     #[instrument(skip_all)]
-    async fn filter_invalid_orders(
+    async fn filter_invalid_orders<'a>(
         &self,
-        mut orders: Vec<Arc<Order>>,
+        mut orders: Vec<&'a Order>,
         invalid_order_uids: &mut HashSet<OrderUid>,
-    ) -> Vec<Arc<Order>> {
+    ) -> Vec<&'a Order> {
         let presignature_pending_orders = find_presignature_pending_orders(&orders);
 
         let unsupported_token_orders = find_unsupported_tokens(&orders, &self.deny_listed_tokens);
@@ -479,10 +476,7 @@ impl SolvableOrdersCache {
 
 /// Finds all orders whose owners or receivers are in the set of "banned"
 /// users.
-async fn find_banned_user_orders(
-    orders: &[Arc<Order>],
-    banned_users: &banned::Users,
-) -> Vec<OrderUid> {
+async fn find_banned_user_orders(orders: &[&Order], banned_users: &banned::Users) -> Vec<OrderUid> {
     let banned = banned_users
         .banned(
             orders
@@ -519,7 +513,7 @@ async fn get_native_prices(
 
 /// Finds orders with pending presignatures. EIP-1271 signature validation is
 /// skipped entirely - the driver validates signatures before settlement.
-fn find_presignature_pending_orders(orders: &[Arc<Order>]) -> Vec<OrderUid> {
+fn find_presignature_pending_orders(orders: &[&Order]) -> Vec<OrderUid> {
     orders
         .iter()
         .filter(|order| {
@@ -535,12 +529,12 @@ fn find_presignature_pending_orders(orders: &[Arc<Order>]) -> Vec<OrderUid> {
 /// Removes orders that can't possibly be settled because there isn't enough
 /// balance.
 #[instrument(skip_all)]
-fn orders_with_balance(
-    mut orders: Vec<Arc<Order>>,
+fn orders_with_balance<'a>(
+    mut orders: Vec<&'a Order>,
     balances: &Balances,
     settlement_contract: Address,
     filter_bypass_orders: &HashSet<OrderUid>,
-) -> (Vec<Arc<Order>>, Vec<OrderUid>) {
+) -> (Vec<&'a Order>, Vec<OrderUid>) {
     // Prefer newer orders over older ones.
     orders.sort_by_key(|order| std::cmp::Reverse(order.metadata.creation_date));
     let mut filtered_orders = vec![];
@@ -592,10 +586,10 @@ fn orders_with_balance(
 
 /// Filters out dust orders i.e. partially fillable orders that, when scaled
 /// have a 0 buy or sell amount.
-fn filter_dust_orders(
-    mut orders: Vec<Arc<Order>>,
+fn filter_dust_orders<'a>(
+    mut orders: Vec<&'a Order>,
     balances: &Balances,
-) -> (Vec<Arc<Order>>, Vec<OrderUid>) {
+) -> (Vec<&'a Order>, Vec<OrderUid>) {
     let mut removed = vec![];
     let keep = |order: &Order| {
         if !order.data.partially_fillable {
@@ -636,13 +630,13 @@ fn filter_dust_orders(
 }
 
 #[instrument(skip_all)]
-async fn get_orders_with_native_prices(
-    orders: Vec<Arc<Order>>,
+async fn get_orders_with_native_prices<'a>(
+    orders: Vec<&'a Order>,
     native_price_estimator: &NativePriceUpdater,
     additional_tokens: impl IntoIterator<Item = Address>,
     timeout: Duration,
 ) -> (
-    Vec<Arc<Order>>,
+    Vec<&'a Order>,
     Vec<OrderUid>,
     BTreeMap<Address, alloy::primitives::U256>,
 ) {
@@ -678,7 +672,7 @@ async fn get_orders_with_native_prices(
 }
 
 fn find_unsupported_tokens(
-    orders: &[Arc<Order>],
+    orders: &[&Order],
     deny_listed_tokens: &DenyListedTokens,
 ) -> Vec<OrderUid> {
     orders
@@ -722,7 +716,7 @@ mod tests {
         let token2 = Address::repeat_byte(2);
         let token3 = Address::repeat_byte(3);
 
-        let orders = vec![
+        let orders = [
             Arc::new(
                 OrderBuilder::default()
                     .with_sell_token(token1)
@@ -768,14 +762,15 @@ mod tests {
         let native_price_estimator =
             NativePriceUpdater::new(caching_estimator, Duration::MAX, Default::default());
 
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (filtered_orders, _removed, prices) = get_orders_with_native_prices(
-            orders.clone(),
+            orders_ref,
             &native_price_estimator,
             vec![],
             Duration::from_millis(100),
         )
         .await;
-        assert_eq!(filtered_orders, [orders[1].clone()]);
+        assert_eq!(filtered_orders, [orders[1].as_ref()]);
         assert_eq!(
             prices,
             btreemap! {
@@ -793,7 +788,7 @@ mod tests {
         let token4 = Address::repeat_byte(4);
         let token5 = Address::repeat_byte(5);
 
-        let orders = vec![
+        let orders = [
             Arc::new(
                 OrderBuilder::default()
                     .with_sell_token(token1)
@@ -870,8 +865,9 @@ mod tests {
 
         // We'll have no native prices in this call. But set_tokens_to_update
         // will cause the background task to fetch them in the next cycle.
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (alive_orders, _removed_orders, prices) = get_orders_with_native_prices(
-            orders.clone(),
+            orders_ref,
             &native_price_estimator,
             vec![token5],
             Duration::ZERO,
@@ -884,15 +880,16 @@ mod tests {
         tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
 
         // Now we have all the native prices we want.
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (alive_orders, _removed_orders, prices) = get_orders_with_native_prices(
-            orders.clone(),
+            orders_ref,
             &native_price_estimator,
             vec![token5],
             Duration::ZERO,
         )
         .await;
 
-        assert_eq!(alive_orders, [orders[2].clone()]);
+        assert_eq!(alive_orders, [orders[2].as_ref()]);
         assert_eq!(
             prices,
             btreemap! {
@@ -912,7 +909,7 @@ mod tests {
         let token_approx1 = Address::repeat_byte(4);
         let token_approx2 = Address::repeat_byte(5);
 
-        let orders = vec![
+        let orders = [
             Arc::new(
                 OrderBuilder::default()
                     .with_sell_token(token1)
@@ -971,14 +968,20 @@ mod tests {
         let native_price_estimator =
             NativePriceUpdater::new(caching_estimator, Duration::MAX, Default::default());
 
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (alive_orders, _removed_orders, prices) = get_orders_with_native_prices(
-            orders.clone(),
+            orders_ref,
             &native_price_estimator,
             vec![],
             Duration::from_secs(10),
         )
         .await;
-        assert_eq!(alive_orders, orders);
+        assert!(
+            alive_orders
+                .iter()
+                .copied()
+                .eq(orders.iter().map(Arc::as_ref))
+        );
         assert_eq!(
             prices,
             btreemap! {
@@ -1020,8 +1023,9 @@ mod tests {
         })
         .collect::<Vec<_>>();
 
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let banned_user_orders = find_banned_user_orders(
-            &orders,
+            &orders_ref,
             &order_validation::banned::Users::from_set(banned_users),
         )
         .await;
@@ -1034,7 +1038,7 @@ mod tests {
     #[test]
     fn finds_presignature_pending_orders() {
         let presign_uid = OrderUid::from_parts(B256::repeat_byte(1), Address::repeat_byte(11), 1);
-        let orders = vec![
+        let orders = [
             // PresignaturePending order - should be found
             Arc::new(Order {
                 metadata: OrderMetadata {
@@ -1063,7 +1067,8 @@ mod tests {
             }),
         ];
 
-        let pending_orders = find_presignature_pending_orders(&orders);
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
+        let pending_orders = find_presignature_pending_orders(&orders_ref);
         assert_eq!(pending_orders, vec![presign_uid]);
     }
 
@@ -1073,7 +1078,7 @@ mod tests {
         let token1 = Address::with_last_byte(1);
         let token2 = Address::with_last_byte(2);
         let deny_listed_tokens = DenyListedTokens::new(vec![token0]);
-        let orders = vec![
+        let orders = [
             Arc::new(
                 OrderBuilder::default()
                     .with_sell_token(token0)
@@ -1093,7 +1098,8 @@ mod tests {
                     .build(),
             ),
         ];
-        let unsupported_tokens_orders = find_unsupported_tokens(&orders, &deny_listed_tokens);
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
+        let unsupported_tokens_orders = find_unsupported_tokens(&orders_ref, &deny_listed_tokens);
         assert_eq!(
             unsupported_tokens_orders,
             [orders[0].metadata.uid, orders[2].metadata.uid]
@@ -1103,7 +1109,7 @@ mod tests {
     #[test]
     fn orders_with_balance_() {
         let settlement_contract = Address::repeat_byte(1);
-        let orders = vec![
+        let orders = [
             // enough balance for sell and fee
             Arc::new(Order {
                 data: OrderData {
@@ -1173,8 +1179,9 @@ mod tests {
         let expected = &[0, 2, 4];
 
         let no_bypass: HashSet<OrderUid> = HashSet::new();
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (alive_orders, _removed_orders) =
-            orders_with_balance(orders.clone(), &balances, settlement_contract, &no_bypass);
+            orders_with_balance(orders_ref, &balances, settlement_contract, &no_bypass);
         assert_eq!(alive_orders.len(), expected.len());
         for index in expected {
             let found = alive_orders.iter().any(|o| o.data == orders[*index].data);
@@ -1237,7 +1244,7 @@ mod tests {
             ..Default::default()
         });
 
-        let orders = vec![
+        let orders = [
             regular_order.clone(),
             eip1271_order.clone(),
             wrapper_order.clone(),
@@ -1246,8 +1253,9 @@ mod tests {
 
         // EIP-1271 order and wrapper order should be retained, regular order filtered
         let wrapper_set = HashSet::from([wrapper_order_uid]);
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (alive_orders, _removed_orders) =
-            orders_with_balance(orders.clone(), &balances, settlement_contract, &wrapper_set);
+            orders_with_balance(orders_ref, &balances, settlement_contract, &wrapper_set);
         assert_eq!(alive_orders.len(), 2);
         assert!(
             alive_orders
@@ -1262,8 +1270,9 @@ mod tests {
 
         // Without wrapper set, only EIP-1271 order should be retained
         let empty_set: HashSet<OrderUid> = HashSet::new();
+        let orders_ref = orders.iter().map(|o| o.as_ref()).collect::<Vec<_>>();
         let (alive_orders, _removed_orders) =
-            orders_with_balance(orders, &balances, settlement_contract, &empty_set);
+            orders_with_balance(orders_ref, &balances, settlement_contract, &empty_set);
         assert_eq!(alive_orders.len(), 1);
         assert_eq!(alive_orders[0].metadata.uid, eip1271_order.metadata.uid);
     }

From e6eedb7400fa8eca4424c3b11a6bbd0c2302142c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 19 Feb 2026 16:56:52 +0000
Subject: [PATCH 087/219] Move fee policy configuration from CLI args to config
 file (#4158)

# Description
Extract FeeFactor from shared::arguments into its own shared::fee_factor
module, adding Serialize/Deserialize support

Requires https://github.com/cowprotocol/infrastructure/pull/4620 to be
merged before

# Changes

- [ ] Move FeePoliciesConfig, FeePolicy, FeePolicyKind,
FeePolicyOrderClass, and UpcomingFeePolicies from autopilot CLI
arguments to autopilot::config::fee_policy as serde-based config structs
- [ ] Read fee_policies_config from the TOML config file (flattened into
Configuration) instead of CLI flags
- [ ] Update all e2e tests to construct fee policy config via
Configuration structs and pass them through the config file

## How to test
E2E + staging
---
 crates/autopilot/src/arguments.rs             | 188 +----------------
 crates/autopilot/src/config/fee_policy.rs     | 182 ++++++++++++++++
 crates/autopilot/src/config/mod.rs            | 179 +++++++++++++++-
 crates/autopilot/src/config/solver.rs         |  28 +--
 crates/autopilot/src/domain/fee/mod.rs        |  46 ++--
 crates/autopilot/src/domain/fee/policy.rs     |  14 +-
 .../src/infra/persistence/dto/order.rs        |   2 +-
 crates/autopilot/src/run.rs                   |   2 +-
 crates/e2e/src/setup/fee.rs                   |  99 ---------
 crates/e2e/src/setup/mod.rs                   |   2 -
 crates/e2e/src/setup/services.rs              |  49 ++---
 crates/e2e/tests/e2e/autopilot_leader.rs      |  34 +--
 crates/e2e/tests/e2e/buffers.rs               |  19 +-
 crates/e2e/tests/e2e/cow_amm.rs               |  54 ++---
 crates/e2e/tests/e2e/jit_orders.rs            |  20 +-
 crates/e2e/tests/e2e/limit_orders.rs          | 108 +++++-----
 crates/e2e/tests/e2e/liquidity.rs             |  19 +-
 .../e2e/liquidity_source_notification.rs      |  20 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |   4 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  23 +-
 crates/e2e/tests/e2e/protocol_fee.rs          | 198 ++++++++++--------
 crates/e2e/tests/e2e/quote_verification.rs    |   7 +-
 crates/e2e/tests/e2e/quoting.rs               |   6 +-
 crates/e2e/tests/e2e/replace_order.rs         |   4 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |   3 +-
 crates/e2e/tests/e2e/solver_competition.rs    |  51 ++---
 crates/e2e/tests/e2e/submission.rs            |   9 +-
 crates/orderbook/src/arguments.rs             |   3 +-
 crates/orderbook/src/quoter.rs                |   5 +-
 crates/shared/src/arguments.rs                |  85 +-------
 crates/shared/src/fee.rs                      |   2 +-
 crates/shared/src/fee_factor.rs               | 146 +++++++++++++
 crates/shared/src/lib.rs                      |   1 +
 33 files changed, 825 insertions(+), 787 deletions(-)
 create mode 100644 crates/autopilot/src/config/fee_policy.rs
 delete mode 100644 crates/e2e/src/setup/fee.rs
 create mode 100644 crates/shared/src/fee_factor.rs

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 55f27f5104..f5f44193d6 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -2,10 +2,8 @@ use {
     crate::{database::INSERT_BATCH_SIZE_DEFAULT, infra},
     alloy::primitives::Address,
     anyhow::Context,
-    chrono::{DateTime, Utc},
-    clap::ValueEnum,
     shared::{
-        arguments::{FeeFactor, display_option, display_secret_option},
+        arguments::{display_option, display_secret_option},
         http_client,
         price_estimation::{self, NativePriceEstimators},
     },
@@ -172,10 +170,6 @@ pub struct CliArguments {
     )]
     pub solve_deadline: Duration,
 
-    /// Describes how the protocol fees should be calculated.
-    #[clap(flatten)]
-    pub fee_policies_config: FeePoliciesConfig,
-
     /// Arguments for uploading information to S3.
     #[clap(flatten)]
     pub s3: infra::persistence::cli::S3,
@@ -291,7 +285,6 @@ impl std::fmt::Display for CliArguments {
             submission_deadline,
             shadow,
             solve_deadline,
-            fee_policies_config,
             order_events_cleanup_interval,
             order_events_cleanup_threshold,
             db_write_url,
@@ -349,7 +342,6 @@ impl std::fmt::Display for CliArguments {
         writeln!(f, "submission_deadline: {submission_deadline}")?;
         display_option(f, "shadow", shadow)?;
         writeln!(f, "solve_deadline: {solve_deadline:?}")?;
-        writeln!(f, "fee_policies_config: {fee_policies_config:?}")?;
         writeln!(
             f,
             "order_events_cleanup_interval: {order_events_cleanup_interval:?}"
@@ -395,153 +387,6 @@ impl std::fmt::Display for CliArguments {
     }
 }
 
-#[derive(clap::Parser, Debug, Clone)]
-pub struct FeePoliciesConfig {
-    /// Describes how the protocol fees should be calculated.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub fee_policies: Vec<FeePolicy>,
-
-    /// Maximum partner fee allowed. If the partner fee specified is greater
-    /// than this maximum, the partner fee will be capped
-    #[clap(long, env, default_value = "0.01")]
-    pub fee_policy_max_partner_fee: FeeFactor,
-
-    /// Volume fee policies that will become effective at a future timestamp.
-    #[clap(flatten)]
-    pub upcoming_fee_policies: UpcomingFeePolicies,
-}
-
-/// A fee policy to be used for orders base on it's class.
-/// Examples:
-/// - Surplus with a high enough cap for limit orders: surplus:0.5:0.9:limit
-///
-/// - Surplus with cap for market orders: surplus:0.5:0.06:market
-///
-/// - Price improvement with a high enough cap for any order class:
-///   price_improvement:0.5:0.9:any
-///
-/// - Price improvement with cap for limit orders:
-///   price_improvement:0.5:0.06:limit
-///
-/// - Volume based fee for any order class: volume:0.1:any
-#[derive(Debug, Clone)]
-pub struct FeePolicy {
-    pub fee_policy_kind: FeePolicyKind,
-    pub fee_policy_order_class: FeePolicyOrderClass,
-}
-
-/// Fee policies that will become effective at a future timestamp.
-#[derive(clap::Parser, Debug, Clone)]
-pub struct UpcomingFeePolicies {
-    #[clap(
-        id = "upcoming_fee_policies",
-        long = "upcoming-fee-policies",
-        env = "UPCOMING_FEE_POLICIES",
-        use_value_delimiter = true
-    )]
-    pub fee_policies: Vec<FeePolicy>,
-
-    #[clap(
-        long = "upcoming-fee-policies-timestamp",
-        env = "UPCOMING_FEE_POLICIES_TIMESTAMP"
-    )]
-    pub effective_from_timestamp: Option<DateTime<Utc>>,
-}
-
-#[derive(clap::Parser, Debug, Clone)]
-pub enum FeePolicyKind {
-    /// How much of the order's surplus should be taken as a protocol fee.
-    Surplus {
-        factor: FeeFactor,
-        max_volume_factor: FeeFactor,
-    },
-    /// How much of the order's price improvement should be taken as a protocol
-    /// fee where price improvement is a difference between the executed price
-    /// and the best quote.
-    PriceImprovement {
-        factor: FeeFactor,
-        max_volume_factor: FeeFactor,
-    },
-    /// How much of the order's volume should be taken as a protocol fee.
-    Volume { factor: FeeFactor },
-}
-
-#[derive(clap::Parser, clap::ValueEnum, Clone, Debug)]
-pub enum FeePolicyOrderClass {
-    /// If a fee policy needs to be applied to in-market orders.
-    Market,
-    /// If a fee policy needs to be applied to limit orders.
-    Limit,
-    /// If a fee policy needs to be applied regardless of the order class.
-    Any,
-}
-
-impl FromStr for FeePolicy {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parts = s.split(':');
-        let kind = parts.next().context("missing fee policy kind")?;
-        let fee_policy_kind = match kind {
-            "surplus" => {
-                let factor = parts
-                    .next()
-                    .context("missing surplus factor")?
-                    .parse::<f64>()
-                    .map_err(|e| anyhow::anyhow!("invalid surplus factor: {}", e))?;
-                let max_volume_factor = parts
-                    .next()
-                    .context("missing max volume factor")?
-                    .parse::<f64>()
-                    .map_err(|e| anyhow::anyhow!("invalid max volume factor: {}", e))?;
-                Ok(FeePolicyKind::Surplus {
-                    factor: factor.try_into()?,
-                    max_volume_factor: max_volume_factor.try_into()?,
-                })
-            }
-            "priceImprovement" => {
-                let factor = parts
-                    .next()
-                    .context("missing price improvement factor")?
-                    .parse::<f64>()
-                    .map_err(|e| anyhow::anyhow!("invalid price improvement factor: {}", e))?;
-                let max_volume_factor = parts
-                    .next()
-                    .context("missing price improvement max volume factor")?
-                    .parse::<f64>()
-                    .map_err(|e| {
-                        anyhow::anyhow!("invalid price improvement max volume factor: {}", e)
-                    })?;
-                Ok(FeePolicyKind::PriceImprovement {
-                    factor: factor.try_into()?,
-                    max_volume_factor: max_volume_factor.try_into()?,
-                })
-            }
-            "volume" => {
-                let factor = parts
-                    .next()
-                    .context("missing volume factor")?
-                    .parse::<f64>()
-                    .map_err(|e| anyhow::anyhow!("invalid volume factor: {}", e))?;
-                Ok(FeePolicyKind::Volume {
-                    factor: factor.try_into()?,
-                })
-            }
-            _ => Err(anyhow::anyhow!("invalid fee policy kind: {}", kind)),
-        }?;
-        let fee_policy_order_class = FeePolicyOrderClass::from_str(
-            parts.next().context("missing fee policy order class")?,
-            true,
-        )
-        .map_err(|e| anyhow::anyhow!("invalid fee policy order class: {}", e))?;
-
-        Ok(FeePolicy {
-            fee_policy_kind,
-            fee_policy_order_class,
-        })
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct CowAmmConfig {
     /// Which contract to index for CoW AMM deployment events.
@@ -584,34 +429,3 @@ impl FromStr for CowAmmConfig {
         })
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_fee_factor_limits() {
-        let policies = vec![
-            "volume:1.0:market",
-            "volume:-1.0:limit",
-            "surplus:1.0:0.5:any",
-            "surplus:0.5:1.0:limit",
-            "surplus:0.5:-1.0:market",
-            "surplus:-1.0:0.5:limit",
-            "priceImprovement:1.0:0.5:market",
-            "priceImprovement:-1.0:0.5:any",
-            "priceImprovement:0.5:1.0:market",
-            "priceImprovement:0.5:-1.0:limit",
-        ];
-
-        for policy in policies {
-            assert!(
-                FeePolicy::from_str(policy)
-                    .err()
-                    .unwrap()
-                    .to_string()
-                    .contains("Factor must be in the range [0, 1)"),
-            )
-        }
-    }
-}
diff --git a/crates/autopilot/src/config/fee_policy.rs b/crates/autopilot/src/config/fee_policy.rs
new file mode 100644
index 0000000000..5597f4ba07
--- /dev/null
+++ b/crates/autopilot/src/config/fee_policy.rs
@@ -0,0 +1,182 @@
+use {
+    chrono::{DateTime, Utc},
+    serde::{Deserialize, Serialize},
+    shared::fee_factor::FeeFactor,
+};
+
+pub const fn default_max_partner_fee() -> FeeFactor {
+    FeeFactor::new(0.01)
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct FeePoliciesConfig {
+    /// Describes how the protocol fees should be calculated.
+    #[serde(default)]
+    pub policies: Vec<FeePolicy>,
+
+    /// Maximum partner fee allowed. If the partner fee specified is greater
+    /// than this maximum, the partner fee will be capped.
+    #[serde(default = "default_max_partner_fee")]
+    pub max_partner_fee: FeeFactor,
+
+    /// Fee policies that will become effective at a future timestamp.
+    #[serde(default)]
+    pub upcoming_policies: UpcomingFeePolicies,
+}
+
+impl Default for FeePoliciesConfig {
+    fn default() -> Self {
+        Self {
+            policies: Default::default(),
+            max_partner_fee: default_max_partner_fee(),
+            upcoming_policies: Default::default(),
+        }
+    }
+}
+
+/// A fee policy to be used for orders based on its class.
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct FeePolicy {
+    pub kind: FeePolicyKind,
+    pub order_class: FeePolicyOrderClass,
+}
+
+/// Fee policies that will become effective at a future timestamp.
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct UpcomingFeePolicies {
+    #[serde(default)]
+    pub policies: Vec<FeePolicy>,
+
+    /// Timestamp from which the `policies` will become active.
+    pub effective_from_timestamp: Option<DateTime<Utc>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum FeePolicyKind {
+    /// How much of the order's surplus should be taken as a protocol fee.
+    #[serde(rename_all = "kebab-case")]
+    Surplus {
+        factor: FeeFactor,
+        max_volume_factor: FeeFactor,
+    },
+    /// How much of the order's price improvement should be taken as a protocol
+    /// fee where price improvement is a difference between the executed price
+    /// and the best quote.
+    #[serde(rename_all = "kebab-case")]
+    PriceImprovement {
+        factor: FeeFactor,
+        max_volume_factor: FeeFactor,
+    },
+    /// How much of the order's volume should be taken as a protocol fee.
+    Volume { factor: FeeFactor },
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum FeePolicyOrderClass {
+    /// If a fee policy needs to be applied to in-market orders.
+    Market,
+    /// If a fee policy needs to be applied to limit orders.
+    Limit,
+    /// If a fee policy needs to be applied regardless of the order class.
+    Any,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_fee_policy_surplus() {
+        let toml = r#"
+        kind.surplus = { factor = 0.5, max-volume-factor = 0.9 }
+        order-class = "limit"
+        "#;
+        let policy: FeePolicy = toml::from_str(toml).unwrap();
+        assert!(matches!(
+            policy.kind,
+            FeePolicyKind::Surplus { factor, max_volume_factor }
+            if factor.get() == 0.5 && max_volume_factor.get() == 0.9
+        ));
+        assert!(matches!(policy.order_class, FeePolicyOrderClass::Limit));
+    }
+
+    #[test]
+    fn deserialize_fee_policy_volume() {
+        let toml = r#"
+        kind.volume = { factor = 0.1 }
+        order-class = "any"
+        "#;
+        let policy: FeePolicy = toml::from_str(toml).unwrap();
+        assert!(matches!(
+            policy.kind,
+            FeePolicyKind::Volume { factor } if factor.get() == 0.1
+        ));
+        assert!(matches!(policy.order_class, FeePolicyOrderClass::Any));
+    }
+
+    #[test]
+    fn deserialize_fee_policy_price_improvement() {
+        let toml = r#"
+        kind.price-improvement = { factor = 0.5, max-volume-factor = 0.06 }
+        order-class = "market"
+        "#;
+        let policy: FeePolicy = toml::from_str(toml).unwrap();
+        assert!(matches!(
+            policy.kind,
+            FeePolicyKind::PriceImprovement { factor, max_volume_factor }
+            if factor.get() == 0.5 && max_volume_factor.get() == 0.06
+        ));
+        assert!(matches!(policy.order_class, FeePolicyOrderClass::Market));
+    }
+
+    #[test]
+    fn deserialize_fee_policies_config_defaults() {
+        let toml = "";
+        let config: FeePoliciesConfig = toml::from_str(toml).unwrap();
+        assert!(config.policies.is_empty());
+        assert_eq!(config.max_partner_fee.get(), 0.01);
+        assert!(config.upcoming_policies.policies.is_empty());
+        assert!(config.upcoming_policies.effective_from_timestamp.is_none());
+    }
+
+    #[test]
+    fn deserialize_fee_policies_config_full() {
+        let toml = r#"
+        max-partner-fee = 0.005
+
+        [[policies]]
+        kind.surplus = { factor = 0.5, max-volume-factor = 0.9 }
+        order-class = "limit"
+
+        [[policies]]
+        kind.volume = { factor = 0.1 }
+        order-class = "any"
+
+        [upcoming-policies]
+        effective-from-timestamp = "2025-06-01T00:00:00Z"
+
+        [[upcoming-policies.policies]]
+        kind.volume = { factor = 0.2 }
+        order-class = "any"
+        "#;
+        let config: FeePoliciesConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.policies.len(), 2);
+        assert_eq!(config.max_partner_fee.get(), 0.005);
+        assert_eq!(config.upcoming_policies.policies.len(), 1);
+        assert!(config.upcoming_policies.effective_from_timestamp.is_some());
+    }
+
+    #[test]
+    fn deserialize_invalid_fee_factor() {
+        let toml = r#"
+        kind.volume = { factor = 1.5 }
+        order-class = "any"
+        "#;
+        assert!(toml::from_str::<FeePolicy>(toml).is_err());
+    }
+}
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index 68f348ffb5..c28bc7a7d0 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -1,17 +1,20 @@
 use {
-    crate::config::solver::Solver,
+    crate::config::{fee_policy::FeePoliciesConfig, solver::Solver},
     anyhow::{anyhow, ensure},
     serde::{Deserialize, Serialize},
     std::path::Path,
 };
 
+pub mod fee_policy;
 pub mod solver;
 
 #[derive(Debug, Default, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct Configuration {
-    // #[serde(default)]
     pub drivers: Vec<Solver>,
+
+    /// Describes how the protocol fees should be calculated.
+    pub fee_policies: FeePoliciesConfig,
 }
 
 impl Configuration {
@@ -34,7 +37,27 @@ impl Configuration {
         Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
     }
 
-    #[cfg(any(test, feature = "test-util"))]
+    // Note for reviewers: if this and other validations are always applied,
+    // we should instead move them to the deserialization stage
+    // https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
+    pub fn validate(self) -> anyhow::Result<Self> {
+        ensure!(
+            !self.drivers.is_empty(),
+            "colocation is enabled but no drivers are configured"
+        );
+        Ok(self)
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl Configuration {
+    pub fn test(name: &str, solver_address: alloy::primitives::Address) -> Self {
+        Self {
+            drivers: vec![Solver::test(name, solver_address)],
+            ..Default::default()
+        }
+    }
+
     pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
         use std::io::Write;
         let mut file = tempfile::NamedTempFile::new().expect("temp file creation should not fail");
@@ -47,14 +70,148 @@ impl Configuration {
         file
     }
 
-    // Note for reviewers: if this and other validations are always applied,
-    // we should instead move them to the deserialization stage
-    // https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
-    pub fn validate(self) -> anyhow::Result<Self> {
-        ensure!(
-            !self.drivers.is_empty(),
-            "colocation is enabled but no drivers are configured"
+    pub fn to_cli_args(&self) -> (tempfile::NamedTempFile, String) {
+        // Must return the temp_file because it gets deleted on drop
+        // disabling the cleanup will lead to a bunch of artifacts laying around
+        let named_temp_file = self.to_temp_path();
+        let cli_arg = format!("--config={}", named_temp_file.path().display());
+        (named_temp_file, cli_arg)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        crate::config::{
+            fee_policy::{FeePolicy, FeePolicyKind, FeePolicyOrderClass, UpcomingFeePolicies},
+            solver::Account,
+        },
+        alloy::primitives::address,
+    };
+
+    #[test]
+    fn deserialize_full_configuration() {
+        let toml = r#"
+        [[drivers]]
+        name = "solver1"
+        url = "http://localhost:8080"
+        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+
+        [[drivers]]
+        name = "solver2"
+        url = "http://localhost:8081"
+        submission-account.kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
+
+        [fee-policies]
+        max-partner-fee = 0.005
+
+        [[fee-policies.policies]]
+        kind.surplus = { factor = 0.5, max-volume-factor = 0.9 }
+        order-class = "limit"
+
+        [[fee-policies.policies]]
+        kind.volume = { factor = 0.1 }
+        order-class = "any"
+
+        [fee-policies.upcoming-policies]
+        effective-from-timestamp = "2025-06-01T00:00:00Z"
+
+        [[fee-policies.upcoming-policies.policies]]
+        kind.volume = { factor = 0.2 }
+        order-class = "any"
+        "#;
+
+        let config: Configuration = toml::from_str(toml).unwrap();
+
+        assert_eq!(config.drivers.len(), 2);
+        assert_eq!(config.drivers[0].name, "solver1");
+        assert_eq!(
+            config.drivers[0].submission_account,
+            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"))
         );
-        Ok(self)
+        assert_eq!(config.drivers[1].name, "solver2");
+
+        assert_eq!(config.fee_policies.max_partner_fee.get(), 0.005);
+        assert_eq!(config.fee_policies.policies.len(), 2);
+        assert!(matches!(
+            config.fee_policies.policies[0].kind,
+            FeePolicyKind::Surplus { .. }
+        ));
+        assert!(matches!(
+            config.fee_policies.policies[0].order_class,
+            FeePolicyOrderClass::Limit
+        ));
+        assert!(matches!(
+            config.fee_policies.policies[1].kind,
+            FeePolicyKind::Volume { .. }
+        ));
+        assert!(matches!(
+            config.fee_policies.policies[1].order_class,
+            FeePolicyOrderClass::Any
+        ));
+
+        assert_eq!(config.fee_policies.upcoming_policies.policies.len(), 1);
+        assert!(
+            config
+                .fee_policies
+                .upcoming_policies
+                .effective_from_timestamp
+                .is_some()
+        );
+    }
+
+    #[test]
+    fn deserialize_configuration_defaults() {
+        let toml = r#"
+        [[drivers]]
+        name = "solver1"
+        url = "http://localhost:8080"
+        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+
+        [fee-policies]
+        "#;
+
+        let config: Configuration = toml::from_str(toml).unwrap();
+
+        assert_eq!(config.drivers.len(), 1);
+        assert!(config.fee_policies.policies.is_empty());
+        assert_eq!(config.fee_policies.max_partner_fee.get(), 0.01);
+        assert!(config.fee_policies.upcoming_policies.policies.is_empty());
+        assert!(
+            config
+                .fee_policies
+                .upcoming_policies
+                .effective_from_timestamp
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = Configuration {
+            drivers: vec![Solver::test(
+                "solver1",
+                address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+            )],
+            fee_policies: FeePoliciesConfig {
+                policies: vec![FeePolicy {
+                    kind: FeePolicyKind::Surplus {
+                        factor: 0.5.try_into().unwrap(),
+                        max_volume_factor: 0.9.try_into().unwrap(),
+                    },
+                    order_class: FeePolicyOrderClass::Limit,
+                }],
+                max_partner_fee: 0.02.try_into().unwrap(),
+                upcoming_policies: UpcomingFeePolicies::default(),
+            },
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: Configuration = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(deserialized.drivers.len(), 1);
+        assert_eq!(deserialized.fee_policies.policies.len(), 1);
+        assert_eq!(deserialized.fee_policies.max_partner_fee.get(), 0.02);
     }
 }
diff --git a/crates/autopilot/src/config/solver.rs b/crates/autopilot/src/config/solver.rs
index c728f3e477..e00c06b810 100644
--- a/crates/autopilot/src/config/solver.rs
+++ b/crates/autopilot/src/config/solver.rs
@@ -60,6 +60,17 @@ where
     }
 }
 
+#[cfg(any(test, feature = "test-util"))]
+impl Solver {
+    pub fn test(name: &str, address: Address) -> Self {
+        Self {
+            name: name.to_string(),
+            url: format!("http://localhost:11088/{name}").parse().unwrap(),
+            submission_account: Account::Address(address),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use {super::*, alloy::primitives::address};
@@ -98,23 +109,6 @@ mod test {
         assert_eq!(driver, expected);
     }
 
-    #[test]
-    fn parse_driver_with_threshold() {
-        let toml = r#"
-        name = "name1"
-        url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-        "#;
-        let driver = toml::from_str::<Solver>(toml).unwrap();
-
-        let expected = Solver::new(
-            "name1".into(),
-            Url::parse("http://localhost:8080").unwrap(),
-            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
-        );
-        assert_eq!(driver, expected);
-    }
-
     #[test]
     fn deserialize_valid_arn() {
         let toml = r#"kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012""#;
diff --git a/crates/autopilot/src/domain/fee/mod.rs b/crates/autopilot/src/domain/fee/mod.rs
index d6bdd659ff..6d38c6c2f6 100644
--- a/crates/autopilot/src/domain/fee/mod.rs
+++ b/crates/autopilot/src/domain/fee/mod.rs
@@ -8,17 +8,19 @@ mod policy;
 
 use {
     crate::{
-        arguments::{self},
         boundary::{self},
+        config::fee_policy::{
+            FeePoliciesConfig,
+            FeePolicy,
+            FeePolicyOrderClass,
+            UpcomingFeePolicies,
+        },
         domain::{self, eth},
     },
     alloy::primitives::{Address, U256},
     chrono::{DateTime, Utc},
     rust_decimal::Decimal,
-    shared::{
-        arguments::{FeeFactor, TokenBucketFeeOverride},
-        fee::VolumeFeePolicy,
-    },
+    shared::{arguments::TokenBucketFeeOverride, fee::VolumeFeePolicy, fee_factor::FeeFactor},
     std::collections::HashSet,
 };
 
@@ -29,12 +31,12 @@ enum OrderClass {
     Any,
 }
 
-impl From<arguments::FeePolicyOrderClass> for OrderClass {
-    fn from(value: arguments::FeePolicyOrderClass) -> Self {
+impl From<FeePolicyOrderClass> for OrderClass {
+    fn from(value: FeePolicyOrderClass) -> Self {
         match value {
-            arguments::FeePolicyOrderClass::Market => Self::Market,
-            arguments::FeePolicyOrderClass::Limit => Self::Limit,
-            arguments::FeePolicyOrderClass::Any => Self::Any,
+            FeePolicyOrderClass::Market => Self::Market,
+            FeePolicyOrderClass::Limit => Self::Limit,
+            FeePolicyOrderClass::Any => Self::Any,
         }
     }
 }
@@ -45,11 +47,11 @@ pub struct ProtocolFee {
     order_class: OrderClass,
 }
 
-impl From<arguments::FeePolicy> for ProtocolFee {
-    fn from(value: arguments::FeePolicy) -> Self {
+impl From<FeePolicy> for ProtocolFee {
+    fn from(value: FeePolicy) -> Self {
         Self {
-            policy: value.fee_policy_kind.into(),
-            order_class: value.fee_policy_order_class.into(),
+            policy: value.kind.into(),
+            order_class: value.order_class.into(),
         }
     }
 }
@@ -59,15 +61,15 @@ pub struct UpcomingProtocolFees {
     effective_from_timestamp: DateTime<Utc>,
 }
 
-impl From<arguments::UpcomingFeePolicies> for Option<UpcomingProtocolFees> {
-    fn from(value: arguments::UpcomingFeePolicies) -> Self {
+impl From<UpcomingFeePolicies> for Option<UpcomingProtocolFees> {
+    fn from(value: UpcomingFeePolicies) -> Self {
         value
             // both config fields must be non-empty
             .effective_from_timestamp
-            .filter(|_| !value.fee_policies.is_empty())
+            .filter(|_| !value.policies.is_empty())
             .map(|effective_from_timestamp| UpcomingProtocolFees {
                 fee_policies: value
-                    .fee_policies
+                    .policies
                     .into_iter()
                     .map(ProtocolFee::from)
                     .collect::<Vec<_>>(),
@@ -87,7 +89,7 @@ pub struct ProtocolFees {
 
 impl ProtocolFees {
     pub fn new(
-        config: &arguments::FeePoliciesConfig,
+        config: &FeePoliciesConfig,
         volume_fee_bucket_overrides: Vec<TokenBucketFeeOverride>,
         enable_sell_equals_buy_volume_fee: bool,
     ) -> Self {
@@ -98,13 +100,13 @@ impl ProtocolFees {
         );
         Self {
             fee_policies: config
-                .fee_policies
+                .policies
                 .iter()
                 .cloned()
                 .map(ProtocolFee::from)
                 .collect(),
-            max_partner_fee: config.fee_policy_max_partner_fee,
-            upcoming_fee_policies: config.upcoming_fee_policies.clone().into(),
+            max_partner_fee: config.max_partner_fee,
+            upcoming_fee_policies: config.upcoming_policies.clone().into(),
             volume_fee_policy,
         }
     }
diff --git a/crates/autopilot/src/domain/fee/policy.rs b/crates/autopilot/src/domain/fee/policy.rs
index 48df4d1678..8902fc7fb9 100644
--- a/crates/autopilot/src/domain/fee/policy.rs
+++ b/crates/autopilot/src/domain/fee/policy.rs
@@ -1,10 +1,10 @@
 use {
     crate::{
-        arguments,
         boundary,
+        config::fee_policy::FeePolicyKind,
         domain::{self, fee::Quote},
     },
-    shared::{arguments::FeeFactor, fee::VolumeFeePolicy},
+    shared::{fee::VolumeFeePolicy, fee_factor::FeeFactor},
 };
 
 pub enum Policy {
@@ -27,24 +27,24 @@ pub struct Volume {
     factor: FeeFactor,
 }
 
-impl From<arguments::FeePolicyKind> for Policy {
-    fn from(policy_arg: arguments::FeePolicyKind) -> Self {
+impl From<FeePolicyKind> for Policy {
+    fn from(policy_arg: FeePolicyKind) -> Self {
         match policy_arg {
-            arguments::FeePolicyKind::Surplus {
+            FeePolicyKind::Surplus {
                 factor,
                 max_volume_factor,
             } => Policy::Surplus(Surplus {
                 factor,
                 max_volume_factor,
             }),
-            arguments::FeePolicyKind::PriceImprovement {
+            FeePolicyKind::PriceImprovement {
                 factor,
                 max_volume_factor,
             } => Policy::PriceImprovement(PriceImprovement {
                 factor,
                 max_volume_factor,
             }),
-            arguments::FeePolicyKind::Volume { factor } => Policy::Volume(Volume { factor }),
+            FeePolicyKind::Volume { factor } => Policy::Volume(Volume { factor }),
         }
     }
 }
diff --git a/crates/autopilot/src/infra/persistence/dto/order.rs b/crates/autopilot/src/infra/persistence/dto/order.rs
index e0f61141fb..6c0e3d6bbb 100644
--- a/crates/autopilot/src/infra/persistence/dto/order.rs
+++ b/crates/autopilot/src/infra/persistence/dto/order.rs
@@ -8,7 +8,7 @@ use {
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
-    shared::arguments::FeeFactor,
+    shared::fee_factor::FeeFactor,
 };
 
 #[serde_as]
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index abc6edc2ba..d9c5c0f135 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -450,7 +450,7 @@ pub async fn run(
         competition_native_price_updater.clone(),
         *eth.contracts().weth().address(),
         domain::ProtocolFees::new(
-            &args.fee_policies_config,
+            &config.fee_policies,
             args.shared.volume_fee_bucket_overrides.clone(),
             args.shared.enable_sell_equals_buy_volume_fee,
         ),
diff --git a/crates/e2e/src/setup/fee.rs b/crates/e2e/src/setup/fee.rs
deleted file mode 100644
index 25689cb9e1..0000000000
--- a/crates/e2e/src/setup/fee.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use chrono::{DateTime, Utc};
-
-#[derive(Default)]
-pub struct ProtocolFeesConfig {
-    pub protocol_fees: Vec<ProtocolFee>,
-    pub upcoming_protocol_fees: Option<UpcomingProtocolFees>,
-}
-
-#[derive(Clone)]
-pub struct UpcomingProtocolFees {
-    pub fee_policies: Vec<ProtocolFee>,
-    pub effective_from_timestamp: DateTime<Utc>,
-}
-
-#[derive(Clone)]
-pub struct ProtocolFee {
-    pub policy: FeePolicyKind,
-    pub policy_order_class: FeePolicyOrderClass,
-}
-
-#[derive(Clone)]
-pub enum FeePolicyOrderClass {
-    Market,
-    Limit,
-    Any,
-}
-
-impl std::fmt::Display for FeePolicyOrderClass {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FeePolicyOrderClass::Market => write!(f, "market"),
-            FeePolicyOrderClass::Limit => write!(f, "limit"),
-            FeePolicyOrderClass::Any => write!(f, "any"),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub enum FeePolicyKind {
-    /// How much of the order's surplus should be taken as a protocol fee.
-    Surplus { factor: f64, max_volume_factor: f64 },
-    /// How much of the order's volume should be taken as a protocol fee.
-    Volume { factor: f64 },
-    /// How much of the order's price improvement should be taken as a protocol
-    /// fee where price improvement is a difference between the executed price
-    /// and the best quote.
-    PriceImprovement { factor: f64, max_volume_factor: f64 },
-}
-
-impl std::fmt::Display for ProtocolFee {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let order_class_str = &self.policy_order_class.to_string();
-        match &self.policy {
-            FeePolicyKind::Surplus {
-                factor,
-                max_volume_factor,
-            } => write!(f, "surplus:{factor}:{max_volume_factor}:{order_class_str}"),
-            FeePolicyKind::Volume { factor } => {
-                write!(f, "volume:{factor}:{order_class_str}")
-            }
-            FeePolicyKind::PriceImprovement {
-                factor,
-                max_volume_factor,
-            } => write!(
-                f,
-                "priceImprovement:{factor}:{max_volume_factor}:{order_class_str}"
-            ),
-        }
-    }
-}
-
-impl ProtocolFeesConfig {
-    pub fn into_args(self) -> Vec<String> {
-        let mut args = Vec::new();
-        let fees_str = self
-            .protocol_fees
-            .iter()
-            .map(|fee| fee.to_string())
-            .collect::<Vec<_>>()
-            .join(",");
-        args.push(format!("--fee-policies={fees_str}"));
-
-        if let Some(upcoming_protocol_fees) = &self.upcoming_protocol_fees {
-            let upcoming_fees_str = upcoming_protocol_fees
-                .fee_policies
-                .iter()
-                .map(|fee| fee.to_string())
-                .collect::<Vec<_>>()
-                .join(",");
-            args.push(format!("--upcoming-fee-policies={}", upcoming_fees_str));
-            args.push(format!(
-                "--upcoming-fee-policies-timestamp={}",
-                upcoming_protocol_fees.effective_from_timestamp.to_rfc3339()
-            ));
-        }
-
-        args
-    }
-}
diff --git a/crates/e2e/src/setup/mod.rs b/crates/e2e/src/setup/mod.rs
index 26d0b44504..ee3ec0100d 100644
--- a/crates/e2e/src/setup/mod.rs
+++ b/crates/e2e/src/setup/mod.rs
@@ -1,8 +1,6 @@
 pub mod colocation;
 mod deploy;
-#[macro_use]
 pub mod onchain_components;
-pub mod fee;
 pub mod proxy;
 mod services;
 mod solver;
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 25f6958fa1..9410622e23 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -15,13 +15,7 @@ use {
         providers::ext::AnvilApi,
     },
     app_data::{AppDataDocument, AppDataHash},
-    autopilot::{
-        config::{
-            Configuration,
-            solver::{Account, Solver},
-        },
-        infra::persistence::dto,
-    },
+    autopilot::{config::Configuration, infra::persistence::dto},
     clap::Parser,
     model::{
         AuctionId,
@@ -228,6 +222,7 @@ impl<'a> Services<'a> {
         let config = autopilot::config::Configuration::from_path(&args.config)
             .await
             .unwrap();
+        tracing::info!("Loaded config: {:?}", config);
         let join_handle = tokio::task::spawn(autopilot::run(args, config, control));
         self.wait_until_autopilot_ready().await;
 
@@ -277,8 +272,18 @@ impl<'a> Services<'a> {
 
     /// Starts a basic version of the protocol with a single baseline solver.
     pub async fn start_protocol(&self, solver: TestAccount) {
-        self.start_protocol_with_args(Default::default(), solver)
-            .await;
+        // HACK: config is required so in the cases where it isn't passed (like the API
+        // version test), so we create a dummy one
+        let (_config_file, cli_arg) =
+            Configuration::test("test_solver", solver.address()).to_cli_args();
+        self.start_protocol_with_args(
+            ExtraServiceArgs {
+                api: Default::default(),
+                autopilot: vec![cli_arg],
+            },
+            solver,
+        )
+        .await;
     }
 
     pub async fn start_protocol_with_args(&self, args: ExtraServiceArgs, solver: TestAccount) {
@@ -310,22 +315,10 @@ impl<'a> Services<'a> {
             false,
         );
 
-        let config_file = Configuration {
-            // replace the --drivers argument with a vec of Solver structs
-            drivers: vec![Solver::new(
-                "test_solver".to_string(),
-                Url::from_str("http://localhost:11088/test_solver").unwrap(),
-                Account::Address(solver.address()),
-            )],
-        }
-        .to_temp_path();
-
         self.start_autopilot(
             None,
             [
                 vec![
-                    // The config gets parsed as an extra argument, it will read the correct path
-                    format!("--config={}", config_file.path().display()),
                     "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                         .to_string(),
                     "--gas-estimators=http://localhost:11088/gasprice".to_string(),
@@ -370,14 +363,8 @@ impl<'a> Services<'a> {
         }];
 
         // Create TOML config file for the driver
-        let config_file = Configuration {
-            drivers: vec![Solver::new(
-                "test_solver".to_string(),
-                Url::parse("http://localhost:11088/test_solver").unwrap(),
-                Account::Address(solver.address()),
-            )],
-        }
-        .to_temp_path();
+        let (_config_file, config_arg) =
+            Configuration::test("test_solver", solver.address()).to_cli_args();
 
         let (autopilot_args, api_args) = if run_baseline {
             solvers.push(
@@ -395,7 +382,7 @@ impl<'a> Services<'a> {
             // Here we call the baseline_solver "test_quoter" to make the native price
             // estimation use the baseline_solver instead of the test_quoter
             let autopilot_args = vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg.clone(),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
                 "--native-price-estimators=Driver|test_quoter|http://localhost:11088/baseline_solver,Driver|test_solver|http://localhost:11088/test_solver".to_string(),
             ];
@@ -405,7 +392,7 @@ impl<'a> Services<'a> {
             (autopilot_args, api_args)
         } else {
             let autopilot_args = vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index bbcbf689e0..506d334fff 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -1,11 +1,5 @@
 use {
-    autopilot::{
-        config::{
-            Configuration,
-            solver::{Account, Solver},
-        },
-        shutdown_controller::ShutdownController,
-    },
+    autopilot::{config::Configuration, shutdown_controller::ShutdownController},
     e2e::setup::{
         OnchainComponents,
         Services,
@@ -18,8 +12,6 @@ use {
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::order::{OrderCreation, OrderKind},
     number::units::EthUnit,
-    std::str::FromStr,
-    url::Url,
 };
 
 #[tokio::test]
@@ -94,20 +86,14 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
     );
 
     // Configure autopilot-leader only with test_solver
-    let config_file_leader = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-            Account::Address(solver1.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file_leader, config_arg_leader) =
+        Configuration::test("test_solver", solver1.address()).to_cli_args();
 
     let autopilot_leader = services
         .start_autopilot_with_shutdown_controller(
             None,
             vec![
-                format!("--config={}", config_file_leader.path().display()),
+                config_arg_leader,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
@@ -120,20 +106,14 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
         .await;
 
     // Configure autopilot-backup only with test_solver2
-    let config_file_follower = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver2".to_string(),
-            Url::from_str("http://localhost:11088/test_solver2").unwrap(),
-            Account::Address(solver2.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file_follower, config_arg_follower) =
+        Configuration::test("test_solver2", solver2.address()).to_cli_args();
 
     let _autopilot_follower = services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file_follower.path().display()),
+                config_arg_follower,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 66045b5d2b..9825e41c05 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,9 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::{
-        Configuration,
-        solver::{Account, Solver},
-    },
+    autopilot::config::Configuration,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -12,8 +9,6 @@ use {
     },
     number::units::EthUnit,
     shared::web3::Web3,
-    std::str::FromStr,
-    url::Url,
 };
 
 #[tokio::test]
@@ -66,14 +61,8 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
         false,
     );
     let services = Services::new(&onchain).await;
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
@@ -85,7 +74,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
                     token_a = token_a.address(),
                     token_b = token_b.address()
                 ),
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 237aad19e6..dc0f6e5541 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -6,10 +6,7 @@ use {
             ext::{AnvilApi, ImpersonateConfig},
         },
     },
-    autopilot::config::{
-        Configuration,
-        solver::{Account, Solver},
-    },
+    autopilot::config::{Configuration, solver::Solver},
     contracts::alloy::{
         ERC20,
         support::{Balances, Signatures},
@@ -42,11 +39,7 @@ use {
         SigningScheme,
         Solution,
     },
-    std::{
-        collections::{HashMap, HashSet},
-        str::FromStr,
-    },
-    url::Url,
+    std::collections::{HashMap, HashSet},
 };
 
 #[tokio::test]
@@ -188,20 +181,14 @@ async fn cow_amm_jit(web3: Web3) {
     );
     let services = Services::new(&onchain).await;
 
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "mock_solver".to_string(),
-            Url::from_str("http://localhost:11088/mock_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("mock_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
@@ -566,27 +553,20 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
     );
     let services = Services::new(&onchain).await;
 
-    let config_file = Configuration {
+    let (_config_file, config_arg) = Configuration {
         drivers: vec![
-            Solver::new(
-                "test_solver".to_string(),
-                Url::from_str("http://localhost:11088/test_solver").unwrap(),
-                Account::Address(solver.address()),
-            ),
-            Solver::new(
-                "mock_solver".to_string(),
-                Url::from_str("http://localhost:11088/mock_solver").unwrap(),
-                Account::Address(solver.address()),
-            ),
+            Solver::test("test_solver", solver.address()),
+            Solver::test("mock_solver", solver.address()),
         ],
+        ..Default::default()
     }
-    .to_temp_path();
+    .to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
                 // it uses an older helper contract that was deployed before the desired cow amm
@@ -844,20 +824,14 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     );
     let services = Services::new(&onchain).await;
 
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "mock_solver".to_string(),
-            Url::from_str("http://localhost:11088/mock_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("mock_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index da51e0bb04..4e945decba 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -1,9 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::{
-        Configuration,
-        solver::{Account, Solver},
-    },
+    autopilot::config::Configuration,
     e2e::setup::{colocation::SolverEngine, mock::Mock, solution::JitOrder, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -13,8 +10,7 @@ use {
     number::units::EthUnit,
     shared::web3::Web3,
     solvers_dto::solution::{Asset, Solution},
-    std::{collections::HashMap, str::FromStr},
-    url::Url,
+    std::collections::HashMap,
 };
 
 #[tokio::test]
@@ -93,20 +89,14 @@ async fn single_limit_order_test(web3: Web3) {
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
 
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "mock_solver".to_string(),
-            Url::from_str("http://localhost:11088/mock_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("mock_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index f847366195..79bb063cc4 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -6,6 +6,7 @@ use {
     },
     autopilot::config::{
         Configuration,
+        fee_policy::{FeePoliciesConfig, FeePolicy, FeePolicyKind},
         solver::{Account, Solver},
     },
     bigdecimal::BigDecimal,
@@ -14,7 +15,6 @@ use {
     driver::domain::eth::NonZeroU256,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
-    fee::{FeePolicyOrderClass, ProtocolFee, ProtocolFeesConfig},
     model::{
         order::{OrderClass, OrderCreation, OrderKind},
         quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
@@ -488,27 +488,24 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
 
     // Start autopilot only once all the orders are created.
 
-    let config_file = Configuration {
+    let (_config_file, config_arg) = Configuration {
         drivers: vec![
             Solver::new(
                 "solver1".to_string(),
                 Url::from_str("http://localhost:11088/test_solver").unwrap(),
                 Account::Address(solver_a.address()),
             ),
-            Solver::new(
-                "solver2".to_string(),
-                Url::from_str("http://localhost:11088/solver2").unwrap(),
-                Account::Address(solver_b.address()),
-            ),
+            Solver::test("solver2", solver_b.address()),
         ],
+        ..Default::default()
     }
-    .to_temp_path();
+    .to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
                 "--max-winners-per-auction=2".to_string(),
             ],
@@ -675,20 +672,14 @@ async fn too_many_limit_orders_test(web3: Web3) {
         false,
     );
 
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-            Account::Address(solver_address),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver_address).to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
@@ -778,20 +769,14 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
         false,
     );
 
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-            Account::Address(solver_address),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver_address).to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
@@ -1100,36 +1085,40 @@ async fn no_liquidity_limit_order(web3: Web3) {
         .unwrap();
 
     // Setup services
-    let protocol_fee_args = ProtocolFeesConfig {
-        protocol_fees: vec![
-            ProtocolFee {
-                policy: fee::FeePolicyKind::Surplus {
-                    factor: 0.5,
-                    max_volume_factor: 0.01,
+
+    let (_config_file, config_arg) = Configuration {
+        drivers: vec![Solver::test("test_solver", solver.address())],
+        fee_policies: FeePoliciesConfig {
+            policies: vec![
+                FeePolicy {
+                    kind: FeePolicyKind::Surplus {
+                        factor: 0.5.try_into().unwrap(),
+                        max_volume_factor: 0.01.try_into().unwrap(),
+                    },
+                    order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Limit,
                 },
-                policy_order_class: FeePolicyOrderClass::Limit,
-            },
-            ProtocolFee {
-                policy: fee::FeePolicyKind::PriceImprovement {
-                    factor: 0.5,
-                    max_volume_factor: 0.01,
+                FeePolicy {
+                    kind: FeePolicyKind::PriceImprovement {
+                        factor: 0.5.try_into().unwrap(),
+                        max_volume_factor: 0.01.try_into().unwrap(),
+                    },
+                    order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Market,
                 },
-                policy_order_class: FeePolicyOrderClass::Market,
-            },
-        ],
-        ..Default::default()
+            ],
+            ..Default::default()
+        },
     }
-    .into_args();
+    .to_cli_args();
 
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
                 autopilot: [
-                    protocol_fee_args,
-                    vec![format!("--unsupported-tokens={:#x}", unsupported.address())],
+                    config_arg,
+                    format!("--unsupported-tokens={:#x}", unsupported.address()),
                 ]
-                .concat(),
+                .to_vec(),
                 ..Default::default()
             },
             solver,
@@ -1296,9 +1285,19 @@ async fn sell_order_with_haircut_test(web3: Web3) {
 
     // Place Orders
     let services = Services::new(&onchain).await;
+
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
     // Start protocol with 500 bps (5%) haircut
     services
-        .start_protocol_with_args_and_haircut(Default::default(), solver, 500)
+        .start_protocol_with_args_and_haircut(
+            ExtraServiceArgs {
+                api: vec![],
+                autopilot: vec![config_arg],
+            },
+            solver,
+            500,
+        )
         .await;
 
     // Create order with generous limit to ensure there's slack for haircut
@@ -1490,8 +1489,19 @@ async fn buy_order_with_haircut_test(web3: Web3) {
 
     // Start protocol with 500 bps (5%) haircut
     let services = Services::new(&onchain).await;
+
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
+    // Start protocol with 500 bps (5%) haircut
     services
-        .start_protocol_with_args_and_haircut(Default::default(), solver, 500)
+        .start_protocol_with_args_and_haircut(
+            ExtraServiceArgs {
+                api: vec![],
+                autopilot: vec![config_arg],
+            },
+            solver,
+            500,
+        )
         .await;
 
     // Create BUY order: want to buy 5 token_b, willing to sell up to 10 token_a.
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index c7717377e4..8fa7accf03 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -6,10 +6,7 @@ use {
             ext::{AnvilApi, ImpersonateConfig},
         },
     },
-    autopilot::config::{
-        Configuration,
-        solver::{Account, Solver},
-    },
+    autopilot::config::Configuration,
     chrono::{NaiveDateTime, Utc},
     contracts::alloy::{ERC20, IZeroex},
     e2e::{
@@ -31,8 +28,6 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
-    std::str::FromStr,
-    url::Url,
 };
 
 /// The block number from which we will fetch state for the forked tests.
@@ -195,14 +190,8 @@ async fn zero_ex_liquidity(web3: Web3) {
         },
         false,
     );
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
@@ -210,7 +199,7 @@ async fn zero_ex_liquidity(web3: Web3) {
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                format!("--config={}", config_file.path().display()),
+                config_arg,
             ],
         )
         .await;
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index abb5723efa..a5d245b666 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -4,10 +4,7 @@ use {
         providers::ext::{AnvilApi, ImpersonateConfig},
         signers::SignerSync,
     },
-    autopilot::config::{
-        Configuration,
-        solver::{Account, Solver},
-    },
+    autopilot::config::Configuration,
     chrono::Utc,
     contracts::alloy::{ERC20, LiquoriceSettlement},
     driver::infra,
@@ -30,8 +27,7 @@ use {
     },
     number::units::EthUnit,
     solvers_dto::solution::Solution,
-    std::{collections::HashMap, str::FromStr},
-    url::Url,
+    std::collections::HashMap,
 };
 
 /// The block number from which we will fetch state for the forked tests.
@@ -204,14 +200,8 @@ http-timeout = "10s"
             liquorice_api.port
         )),
     );
-    let config_file = Configuration {
-        drivers: vec![Solver::new(
-            "liquorice_solver".to_string(),
-            Url::from_str("http://localhost:11088/liquorice_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_config_file, config_arg) =
+        Configuration::test("liquorice_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
@@ -219,7 +209,7 @@ http-timeout = "10s"
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                format!("--config={}", config_file.path().display()),
+                config_arg,
             ],
         )
         .await;
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index 583ff81eed..8bf2f4f206 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -66,12 +66,12 @@ async fn order_cancellation(web3: Web3) {
         colocation::LiquidityProvider::UniswapV2,
         false,
     );
-    let config_file = Configuration::default().to_temp_path();
+    let (_config_file, config_arg) = Configuration::default().to_cli_args();
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index d5e4ea6d6a..7e93a7d9cf 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -1,12 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::{
-        config::{
-            Configuration,
-            solver::{Account, Solver},
-        },
-        shutdown_controller::ShutdownController,
-    },
+    autopilot::{config::Configuration, shutdown_controller::ShutdownController},
     driver::domain::eth::NonZeroU256,
     e2e::setup::{colocation, wait_for_condition, *},
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
@@ -17,8 +11,7 @@ use {
     },
     number::units::EthUnit,
     shared::web3::Web3,
-    std::{ops::DerefMut, str::FromStr},
-    url::Url,
+    std::ops::DerefMut,
 };
 
 #[tokio::test]
@@ -225,19 +218,13 @@ async fn fallback_native_price_estimator(web3: Web3) {
     );
 
     let (manual_shutdown, control) = ShutdownController::new_manual_shutdown();
-    let autopilot_config_file = Configuration {
-        drivers: vec![Solver::new(
-            "test_solver".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-            Account::Address(solver.address()),
-        )],
-    }
-    .to_temp_path();
+    let (_autopilot_config_file, cli_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
     let autopilot_handle = services
         .start_autopilot_with_shutdown_controller(
             None,
             vec![
-                format!("--config={}", autopilot_config_file.path().display()),
+                cli_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 42f34549b0..207f7ffccd 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -1,10 +1,18 @@
 use {
     ::alloy::primitives::{Address, U256},
-    driver::domain::eth::NonZeroU256,
-    e2e::{
-        assert_approximately_eq,
-        setup::{fee::*, *},
+    autopilot::config::{
+        Configuration,
+        fee_policy::{
+            FeePoliciesConfig,
+            FeePolicy as ConfigFeePolicy,
+            FeePolicyKind as ConfigFeePolicyKind,
+            FeePolicyOrderClass as ConfigFeePolicyOrderClass,
+            UpcomingFeePolicies,
+        },
+        solver::Solver,
     },
+    driver::domain::eth::NonZeroU256,
+    e2e::{assert_approximately_eq, setup::*},
     ethrpc::alloy::CallBuilderExt,
     model::{
         fee_policy::FeePolicy,
@@ -56,19 +64,19 @@ async fn local_node_volume_fee_overrides() {
 }
 
 async fn combined_protocol_fees(web3: Web3) {
-    let limit_surplus_policy = ProtocolFee {
-        policy: FeePolicyKind::Surplus {
-            factor: 0.3,
-            max_volume_factor: 0.9,
+    let limit_surplus_policy = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::Surplus {
+            factor: 0.3.try_into().unwrap(),
+            max_volume_factor: 0.9.try_into().unwrap(),
         },
-        policy_order_class: FeePolicyOrderClass::Limit,
+        order_class: ConfigFeePolicyOrderClass::Limit,
     };
-    let market_price_improvement_policy = ProtocolFee {
-        policy: FeePolicyKind::PriceImprovement {
-            factor: 0.3,
-            max_volume_factor: 0.9,
+    let market_price_improvement_policy = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::PriceImprovement {
+            factor: 0.3.try_into().unwrap(),
+            max_volume_factor: 0.9.try_into().unwrap(),
         },
-        policy_order_class: FeePolicyOrderClass::Market,
+        order_class: ConfigFeePolicyOrderClass::Market,
     };
     let partner_fee_app_data = OrderCreationAppData::Full {
         full: json!({
@@ -152,20 +160,21 @@ async fn combined_protocol_fees(web3: Web3) {
         .await
         .unwrap();
 
-    let autopilot_config = [
-        ProtocolFeesConfig {
-            protocol_fees: vec![limit_surplus_policy, market_price_improvement_policy],
+    let (_config_file, config_arg) = Configuration {
+        drivers: vec![Solver::test("test_solver", solver.address())],
+        fee_policies: FeePoliciesConfig {
+            policies: vec![limit_surplus_policy, market_price_improvement_policy],
+            max_partner_fee: 0.02.try_into().unwrap(),
             ..Default::default()
-        }
-        .into_args(),
-        vec!["--fee-policy-max-partner-fee=0.02".to_string()],
-    ]
-    .concat();
+        },
+    }
+    .to_cli_args();
+
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: autopilot_config,
+                autopilot: vec![config_arg],
                 ..Default::default()
             },
             solver,
@@ -356,7 +365,7 @@ async fn combined_protocol_fees(web3: Web3) {
     let partner_fee_executed_fee_in_buy_token =
         fee_in_buy_token(&partner_fee_order, &partner_fee_quote_after.quote);
     assert!(
-        // see `--fee-policy-max-partner-fee` autopilot config argument, which is 0.02
+        // see `max-partner-fee` in the `[fee-policies]` autopilot config, which is 0.02
         partner_fee_executed_fee_in_buy_token
             >= (partner_fee_quote.quote.buy_amount * U256::from(2) / U256::from(100))
     );
@@ -412,7 +421,7 @@ async fn combined_protocol_fees(web3: Web3) {
 /// Tests that a partner can provide multiple partner fees and also use
 /// the `Surplus` and `PriceImprovement` fee policies. Also checks that
 /// the partner fees can not exceed the globally defined
-/// `--fee-policy-max-partner-fee` which defines how much of an order's volume
+/// `max-partner-fee` config which defines how much of an order's volume
 /// may be captured in total by partner fees.
 async fn surplus_partner_fee(web3: Web3) {
     // All these values are unreasonably high but result in easier math
@@ -506,13 +515,20 @@ async fn surplus_partner_fee(web3: Web3) {
         .await
         .unwrap();
 
+    let (_config_file, config_arg) = Configuration {
+        drivers: vec![Solver::test("test_solver", solver.address())],
+        fee_policies: FeePoliciesConfig {
+            max_partner_fee: MAX_PARTNER_VOLUME_FEE.try_into().unwrap(),
+            ..Default::default()
+        },
+    }
+    .to_cli_args();
+
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: vec![format!(
-                    "--fee-policy-max-partner-fee={MAX_PARTNER_VOLUME_FEE}"
-                )],
+                autopilot: vec![config_arg],
                 ..Default::default()
             },
             solver,
@@ -654,30 +670,20 @@ fn sell_order_from_quote(quote: &OrderQuoteResponse) -> OrderCreation {
 }
 
 async fn volume_fee_buy_order_test(web3: Web3) {
-    let fee_policy = FeePolicyKind::Volume { factor: 0.1 };
-    let outdated_fee_policy = FeePolicyKind::Volume { factor: 0.0002 };
-    let protocol_fee = ProtocolFee {
-        policy: fee_policy,
+    let fee_policy = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::Volume {
+            factor: 0.1.try_into().unwrap(),
+        },
         // The order is in-market, but specifying `Any` order class to make sure it is properly
         // applied
-        policy_order_class: FeePolicyOrderClass::Any,
+        order_class: ConfigFeePolicyOrderClass::Any,
     };
-    let outdated_protocol_fee = ProtocolFee {
-        policy: outdated_fee_policy,
-        policy_order_class: FeePolicyOrderClass::Any,
+    let outdated_fee_policy = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::Volume {
+            factor: 0.0002.try_into().unwrap(),
+        },
+        order_class: ConfigFeePolicyOrderClass::Any,
     };
-    // Protocol fee set twice to test that only one policy will apply if the
-    // autopilot is not configured to support multiple fees
-    let protocol_fee_args = ProtocolFeesConfig {
-        protocol_fees: vec![outdated_protocol_fee.clone(), outdated_protocol_fee],
-        upcoming_protocol_fees: Some(UpcomingProtocolFees {
-            fee_policies: vec![protocol_fee.clone(), protocol_fee],
-            // Set the effective time to 10 minutes ago to make sure the new policy
-            // is applied
-            effective_from_timestamp: chrono::Utc::now() - chrono::Duration::minutes(10),
-        }),
-    }
-    .into_args();
 
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -749,11 +755,28 @@ async fn volume_fee_buy_order_test(web3: Web3) {
         .unwrap();
 
     // Place Orders
+    // Protocol fee set twice to test that only one policy will apply if the
+    // autopilot is not configured to support multiple fees
+    let (_config_file, config_arg) = Configuration {
+        drivers: vec![Solver::test("test_solver", solver.address())],
+        fee_policies: FeePoliciesConfig {
+            policies: vec![outdated_fee_policy.clone(), outdated_fee_policy],
+            upcoming_policies: UpcomingFeePolicies {
+                policies: vec![fee_policy.clone(), fee_policy],
+                // Set the effective time to 10 minutes ago to make sure the new policy
+                // is applied
+                effective_from_timestamp: Some(chrono::Utc::now() - chrono::Duration::minutes(10)),
+            },
+            ..Default::default()
+        },
+    }
+    .to_cli_args();
+
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: protocol_fee_args,
+                autopilot: vec![config_arg],
                 ..Default::default()
             },
             solver,
@@ -811,30 +834,20 @@ async fn volume_fee_buy_order_test(web3: Web3) {
 }
 
 async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) {
-    let fee_policy = FeePolicyKind::Volume { factor: 0.1 };
-    let future_fee_policy = FeePolicyKind::Volume { factor: 0.0002 };
-    let protocol_fee = ProtocolFee {
-        policy: fee_policy,
+    let fee_policy = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::Volume {
+            factor: 0.1.try_into().unwrap(),
+        },
         // The order is in-market, but specifying `Any` order class to make sure it is properly
         // applied
-        policy_order_class: FeePolicyOrderClass::Any,
+        order_class: ConfigFeePolicyOrderClass::Any,
     };
-    let future_protocol_fee = ProtocolFee {
-        policy: future_fee_policy,
-        policy_order_class: FeePolicyOrderClass::Any,
+    let future_fee_policy = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::Volume {
+            factor: 0.0002.try_into().unwrap(),
+        },
+        order_class: ConfigFeePolicyOrderClass::Any,
     };
-    // Protocol fee set twice to test that only one policy will apply if the
-    // autopilot is not configured to support multiple fees
-    let protocol_fee_args = ProtocolFeesConfig {
-        protocol_fees: vec![protocol_fee.clone(), protocol_fee],
-        upcoming_protocol_fees: Some(UpcomingProtocolFees {
-            fee_policies: vec![future_protocol_fee.clone(), future_protocol_fee],
-            // Set the effective time to far in the future to make sure the new policy
-            // is NOT applied
-            effective_from_timestamp: chrono::Utc::now() + chrono::Duration::days(1),
-        }),
-    }
-    .into_args();
 
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -906,11 +919,28 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) {
         .unwrap();
 
     // Place Orders
+    // Protocol fee set twice to test that only one policy will apply if the
+    // autopilot is not configured to support multiple fees
+    let (_config_file, config_arg) = Configuration {
+        drivers: vec![Solver::test("test_solver", solver.address())],
+        fee_policies: FeePoliciesConfig {
+            policies: vec![fee_policy.clone(), fee_policy],
+            upcoming_policies: UpcomingFeePolicies {
+                policies: vec![future_fee_policy.clone(), future_fee_policy],
+                // Set the effective time to far in the future to make sure the new policy
+                // is NOT applied
+                effective_from_timestamp: Some(chrono::Utc::now() + chrono::Duration::days(1)),
+            },
+            ..Default::default()
+        },
+    }
+    .to_cli_args();
+
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: protocol_fee_args,
+                autopilot: vec![config_arg],
                 ..Default::default()
             },
             solver,
@@ -1042,9 +1072,11 @@ async fn volume_fee_overrides(web3: Web3) {
     }
 
     // Default volume fee: 1% (0.01)
-    let default_volume_fee = ProtocolFee {
-        policy: FeePolicyKind::Volume { factor: 0.01 },
-        policy_order_class: FeePolicyOrderClass::Any,
+    let default_volume_fee = ConfigFeePolicy {
+        kind: ConfigFeePolicyKind::Volume {
+            factor: 0.01.try_into().unwrap(),
+        },
+        order_class: ConfigFeePolicyOrderClass::Any,
     };
 
     // Bucket overrides (comma-separated, checked in order, first match wins):
@@ -1058,20 +1090,20 @@ async fn volume_fee_overrides(web3: Web3) {
         token_dai.address(),
         token_usdt.address()
     );
-    let autopilot_config = [
-        ProtocolFeesConfig {
-            protocol_fees: vec![default_volume_fee],
+
+    let (_config_file, config_arg) = Configuration {
+        drivers: vec![Solver::test("test_solver", solver.address())],
+        fee_policies: FeePoliciesConfig {
+            policies: vec![default_volume_fee],
             ..Default::default()
-        }
-        .into_args(),
-        vec![volume_fee_bucket_config.clone()],
-    ]
-    .concat();
+        },
+    }
+    .to_cli_args();
 
     // Orderbook (API) also needs the same bucket overrides for accurate quote
     // generation
     let api_config = vec![
-        volume_fee_bucket_config,
+        volume_fee_bucket_config.clone(),
         "--volume-fee-factor=0.01".to_string(), // Default 1% volume fee
     ];
 
@@ -1079,7 +1111,7 @@ async fn volume_fee_overrides(web3: Web3) {
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: autopilot_config,
+                autopilot: vec![config_arg, volume_fee_bucket_config],
                 api: api_config,
             },
             solver,
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index a288b082b4..846c30ee49 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -3,6 +3,7 @@ use {
         primitives::{Address, U256, address, map::AddressMap},
         providers::Provider,
     },
+    autopilot::config::Configuration,
     bigdecimal::{BigDecimal, Zero},
     e2e::setup::*,
     ethrpc::{Web3, alloy::CallBuilderExt},
@@ -372,6 +373,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) = Configuration::default().to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
@@ -383,7 +385,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
                     // auto-detection for balance overrides.
                     "--quote-autodetect-token-balance-overrides=true".to_string(),
                 ],
-                ..Default::default()
+                autopilot: vec![config_arg],
             },
             solver,
         )
@@ -522,11 +524,12 @@ async fn usdt_quote_verification(web3: Web3) {
 
     // Place Orders
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
                 api: vec!["--quote-autodetect-token-balance-overrides=true".to_string()],
-                ..Default::default()
+                autopilot: vec![config_arg],
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 672ab5e097..58195b1767 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -73,6 +73,7 @@ async fn test(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     // Start API with 0.02% (2 bps) volume fee
     let args = ExtraServiceArgs {
         api: vec![
@@ -80,7 +81,7 @@ async fn test(web3: Web3) {
             // Set a far future effective timestamp to ensure the fee is not applied
             "--volume-fee-effective-timestamp=2099-01-01T10:00:00Z".to_string(),
         ],
-        ..Default::default()
+        autopilot: vec![config_arg],
     };
     services.start_protocol_with_args(args, solver).await;
 
@@ -446,6 +447,7 @@ async fn volume_fee(web3: Web3) {
 
     tracing::info!("Starting services with volume fee.");
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     // Start API with 0.02% (2 bps) default volume fee
     // Bucket override: WETH<->override_token pair gets 5 bps (both tokens must be
     // in bucket)
@@ -460,7 +462,7 @@ async fn volume_fee(web3: Web3) {
                 override_token.address()
             ),
         ],
-        ..Default::default()
+        autopilot: vec![config_arg],
     };
     services.start_protocol_with_args(args, solver).await;
 
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index ddc9ab1812..d6ee8da953 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -467,6 +467,8 @@ async fn single_replace_order_test(web3: Web3) {
     onchain.set_solver_allowed(solver.address(), false).await;
 
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) =
+        autopilot::config::Configuration::test("test_solver", solver.address()).to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
@@ -474,7 +476,7 @@ async fn single_replace_order_test(web3: Web3) {
                 // with the solver being banned. To allow us to still create
                 // orders we override the quote verification to be disabled.
                 api: vec!["--quote-verification=prefer".into()],
-                ..Default::default()
+                autopilot: vec![config_arg],
             },
             solver.clone(),
         )
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 3b70c85415..54ebdd5052 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -173,11 +173,12 @@ async fn erc1271_gas_limit(web3: Web3) {
         .unwrap();
 
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
                 api: vec!["--max-gas-per-order=1000000".to_string()],
-                ..Default::default()
+                autopilot: vec![config_arg],
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 76f2b53956..0266874636 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -86,26 +86,19 @@ async fn solver_competition(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
-    let config_file = Configuration {
+    let (_config_file, config_arg) = Configuration {
         drivers: vec![
-            Solver::new(
-                "test_solver".to_string(),
-                Url::from_str("http://localhost:11088/test_solver").unwrap(),
-                Account::Address(solver.address()),
-            ),
-            Solver::new(
-                "solver2".to_string(),
-                Url::from_str("http://localhost:11088/solver2").unwrap(),
-                Account::Address(solver.address()),
-            ),
+            Solver::test("test_solver", solver.address()),
+            Solver::test("solver2", solver.address()),
         ],
+        ..Default::default()
     }
-    .to_temp_path();
+    .to_cli_args();
 
     services.start_autopilot(
         None,
         vec![
-            format!("--config={}", config_file.path().display()),
+            config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
         ],
     ).await;
@@ -244,27 +237,24 @@ async fn wrong_solution_submission_address(web3: Web3) {
 
     // Solver 1 has a wrong submission address, meaning that the solutions should be
     // discarded from solver1
-    let config_file = Configuration {
+    let (_config_file, config_arg) = Configuration {
         drivers: vec![
             Solver::new(
                 "solver1".to_string(),
                 Url::from_str("http://localhost:11088/test_solver").unwrap(),
                 Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
             ),
-            Solver::new(
-                "solver2".to_string(),
-                Url::from_str("http://localhost:11088/solver2").unwrap(),
-                Account::Address(solver.address()),
-            ),
+            Solver::test("solver2", solver.address()),
         ],
+        ..Default::default()
     }
-    .to_temp_path();
+    .to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
             ],
         )
@@ -408,27 +398,20 @@ async fn store_filtered_solutions(web3: Web3) {
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
 
-    let config_file = Configuration {
+    let (_config_file, config_arg) = Configuration {
         drivers: vec![
-            Solver::new(
-                "good_solver".to_string(),
-                Url::from_str("http://localhost:11088/good_solver").unwrap(),
-                Account::Address(good_solver_account.address()),
-            ),
-            Solver::new(
-                "bad_solver".to_string(),
-                Url::from_str("http://localhost:11088/bad_solver").unwrap(),
-                Account::Address(bad_solver_account.address()),
-            ),
+            Solver::test("good_solver", good_solver_account.address()),
+            Solver::test("bad_solver", bad_solver_account.address()),
         ],
+        ..Default::default()
     }
-    .to_temp_path();
+    .to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!("--config={}", config_file.path().display()),
+                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
                 "--max-winners-per-auction=10".to_string(),
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 02528fc5fb..bf9b73ff7a 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -7,6 +7,7 @@ use {
             types::{Transaction, TransactionReceipt},
         },
     },
+    autopilot::config::Configuration,
     e2e::setup::*,
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     futures::StreamExt,
@@ -156,11 +157,13 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
                 api: vec!["--same-tokens-policy=allow-sell".to_string()],
-                ..Default::default()
+                autopilot: vec![config_arg],
             },
             solver.clone(),
         )
@@ -267,11 +270,13 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
+    let (_config_file, config_arg) =
+        Configuration::test("test_solver", solver.address()).to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
                 api: vec!["--same-tokens-policy=allow-sell".to_string()],
-                ..Default::default()
+                autopilot: vec![config_arg],
             },
             solver.clone(),
         )
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index ce2308f6a3..dadd939594 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -3,7 +3,8 @@ use {
     chrono::{DateTime, Utc},
     reqwest::Url,
     shared::{
-        arguments::{FeeFactor, display_secret_option},
+        arguments::display_secret_option,
+        fee_factor::FeeFactor,
         http_client,
         price_estimation::{self, NativePriceEstimators},
     },
diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs
index ceec043b5d..71a60e2693 100644
--- a/crates/orderbook/src/quoter.rs
+++ b/crates/orderbook/src/quoter.rs
@@ -8,8 +8,9 @@ use {
         quote::{OrderQuote, OrderQuoteRequest, OrderQuoteResponse, OrderQuoteSide, PriceQuality},
     },
     shared::{
-        arguments::{FeeFactor, TokenBucketFeeOverride},
+        arguments::TokenBucketFeeOverride,
         fee::VolumeFeePolicy,
+        fee_factor::FeeFactor,
         order_quoting::{CalculateQuoteError, OrderQuoting, Quote, QuoteParameters},
         order_validation::{
             AppDataValidationError,
@@ -308,8 +309,8 @@ mod tests {
         model::quote::OrderQuoteSide,
         number::units::EthUnit,
         shared::{
-            arguments::FeeFactor,
             fee::VolumeFeePolicy,
+            fee_factor::FeeFactor,
             order_quoting::{Quote, QuoteData},
         },
     };
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index f261e58d74..63781d8b7f 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -2,7 +2,7 @@
 //! the binaries.
 
 use {
-    crate::{gas_price_estimation::GasEstimatorType, tenderly_api},
+    crate::{fee_factor::FeeFactor, gas_price_estimation::GasEstimatorType, tenderly_api},
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
     observe::TracingConfig,
@@ -402,64 +402,6 @@ impl FromStr for ExternalSolver {
     }
 }
 
-/// Fee factor representing a percentage in range [0, 1)
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct FeeFactor(f64);
-
-impl FeeFactor {
-    /// High precision scale factor (1 million) for sub-basis-point precision.
-    /// Allows representing factors like 0.00003 (0.3 BPS) without rounding to
-    /// 0. Also used for converting to BPS string with 2 decimal precision
-    /// (1_000_000 / 100 = 10_000 BPS scale).
-    pub const HIGH_PRECISION_SCALE: u64 = 1_000_000;
-
-    pub fn new(factor: f64) -> Self {
-        Self(factor)
-    }
-
-    /// Converts the fee factor to basis points (BPS).
-    /// Supports fractional BPS values (e.g., 0.00003 -> "0.3")
-    /// Rounds to 2 decimal places to avoid floating point representation
-    /// issues.
-    pub fn to_bps_str(&self) -> String {
-        let bps = (self.0 * Self::HIGH_PRECISION_SCALE as f64).round() / 100.0;
-        format!("{bps}")
-    }
-
-    /// Converts the fee factor to a high precision scaled integer.
-    /// For example, 0.00003 -> 30 (with scale of 1_000_000)
-    /// This allows sub-basis-point precision in calculations.
-    pub fn to_high_precision(&self) -> u64 {
-        (self.0 * Self::HIGH_PRECISION_SCALE as f64).round() as u64
-    }
-
-    /// Get the inner value
-    pub fn get(&self) -> f64 {
-        self.0
-    }
-}
-
-impl TryFrom<f64> for FeeFactor {
-    type Error = anyhow::Error;
-
-    fn try_from(value: f64) -> Result<Self, Self::Error> {
-        ensure!(
-            (0.0..1.0).contains(&value),
-            "Factor must be in the range [0, 1)"
-        );
-        Ok(FeeFactor(value))
-    }
-}
-
-impl FromStr for FeeFactor {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let value: f64 = s.parse().context("failed to parse fee factor as f64")?;
-        value.try_into()
-    }
-}
-
 /// Helper type for parsing token bucket fee overrides from strings
 #[derive(Debug, Clone)]
 pub struct TokenBucketFeeOverride {
@@ -585,29 +527,4 @@ mod test {
             .is_err()
         );
     }
-
-    #[test]
-    fn fee_factor_to_bps() {
-        assert_eq!(FeeFactor::new(0.0001).to_bps_str(), "1");
-        assert_eq!(FeeFactor::new(0.001).to_bps_str(), "10");
-
-        // Fractional BPS values (sub-basis-point precision)
-        assert_eq!(FeeFactor::new(0.00003).to_bps_str(), "0.3");
-        assert_eq!(FeeFactor::new(0.00005).to_bps_str(), "0.5");
-        assert_eq!(FeeFactor::new(0.000025).to_bps_str(), "0.25");
-        assert_eq!(FeeFactor::new(0.000075).to_bps_str(), "0.75");
-        assert_eq!(FeeFactor::new(0.00015).to_bps_str(), "1.5");
-
-        assert_eq!(FeeFactor::new(0.0).to_bps_str(), "0");
-    }
-
-    #[test]
-    fn fee_factor_to_high_precision() {
-        // Verify high precision scaling
-        assert_eq!(FeeFactor::new(0.00003).to_high_precision(), 30);
-        assert_eq!(FeeFactor::new(0.0001).to_high_precision(), 100);
-        assert_eq!(FeeFactor::new(0.001).to_high_precision(), 1000);
-        assert_eq!(FeeFactor::new(0.01).to_high_precision(), 10_000);
-        assert_eq!(FeeFactor::new(0.1).to_high_precision(), 100_000);
-    }
 }
diff --git a/crates/shared/src/fee.rs b/crates/shared/src/fee.rs
index e9ba175d80..dbbf67e734 100644
--- a/crates/shared/src/fee.rs
+++ b/crates/shared/src/fee.rs
@@ -1,5 +1,5 @@
 use {
-    crate::arguments::{FeeFactor, TokenBucketFeeOverride},
+    crate::{arguments::TokenBucketFeeOverride, fee_factor::FeeFactor},
     alloy::primitives::{Address, U256},
 };
 
diff --git a/crates/shared/src/fee_factor.rs b/crates/shared/src/fee_factor.rs
new file mode 100644
index 0000000000..ba26383d7c
--- /dev/null
+++ b/crates/shared/src/fee_factor.rs
@@ -0,0 +1,146 @@
+use {
+    anyhow::{Context, ensure},
+    serde::{Deserialize, Deserializer, Serialize, de::Unexpected},
+    std::str::FromStr,
+};
+
+/// Fee factor representing a percentage in range [0, 1)
+#[derive(Debug, Clone, Copy, PartialEq, Serialize)]
+pub struct FeeFactor(f64);
+
+impl FeeFactor {
+    /// High precision scale factor (1 million) for sub-basis-point precision.
+    /// Allows representing factors like 0.00003 (0.3 BPS) without rounding to
+    /// 0. Also used for converting to BPS string with 2 decimal precision
+    /// (1_000_000 / 100 = 10_000 BPS scale).
+    pub const HIGH_PRECISION_SCALE: u64 = 1_000_000;
+
+    pub const fn new(factor: f64) -> Self {
+        Self(factor)
+    }
+
+    /// Converts the fee factor to basis points (BPS).
+    /// Supports fractional BPS values (e.g., 0.00003 -> "0.3")
+    /// Rounds to 2 decimal places to avoid floating point representation
+    /// issues.
+    pub fn to_bps_str(&self) -> String {
+        let bps = (self.0 * Self::HIGH_PRECISION_SCALE as f64).round() / 100.0;
+        format!("{bps}")
+    }
+
+    /// Converts the fee factor to a high precision scaled integer.
+    /// For example, 0.00003 -> 30 (with scale of 1_000_000)
+    /// This allows sub-basis-point precision in calculations.
+    pub fn to_high_precision(&self) -> u64 {
+        (self.0 * Self::HIGH_PRECISION_SCALE as f64).round() as u64
+    }
+
+    /// Get the inner value
+    pub fn get(&self) -> f64 {
+        self.0
+    }
+}
+
+impl TryFrom<f64> for FeeFactor {
+    type Error = anyhow::Error;
+
+    fn try_from(value: f64) -> Result<Self, Self::Error> {
+        ensure!(
+            (0.0..1.0).contains(&value),
+            "Factor must be in the range [0, 1)"
+        );
+        Ok(FeeFactor(value))
+    }
+}
+
+impl FromStr for FeeFactor {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let value: f64 = s.parse().context("failed to parse fee factor as f64")?;
+        value.try_into()
+    }
+}
+
+impl<'de> Deserialize<'de> for FeeFactor {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let raw_fee_factor = f64::deserialize(deserializer)?;
+        FeeFactor::try_from(raw_fee_factor).map_err(|_| {
+            serde::de::Error::invalid_value(
+                Unexpected::Float(raw_fee_factor),
+                &"expected fee factor to be in interval [0, 1)",
+            )
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn fee_factor_to_bps() {
+        assert_eq!(FeeFactor::new(0.0001).to_bps_str(), "1");
+        assert_eq!(FeeFactor::new(0.001).to_bps_str(), "10");
+
+        // Fractional BPS values (sub-basis-point precision)
+        assert_eq!(FeeFactor::new(0.00003).to_bps_str(), "0.3");
+        assert_eq!(FeeFactor::new(0.00005).to_bps_str(), "0.5");
+        assert_eq!(FeeFactor::new(0.000025).to_bps_str(), "0.25");
+        assert_eq!(FeeFactor::new(0.000075).to_bps_str(), "0.75");
+        assert_eq!(FeeFactor::new(0.00015).to_bps_str(), "1.5");
+
+        assert_eq!(FeeFactor::new(0.0).to_bps_str(), "0");
+    }
+
+    #[test]
+    fn fee_factor_to_high_precision() {
+        // Verify high precision scaling
+        assert_eq!(FeeFactor::new(0.00003).to_high_precision(), 30);
+        assert_eq!(FeeFactor::new(0.0001).to_high_precision(), 100);
+        assert_eq!(FeeFactor::new(0.001).to_high_precision(), 1000);
+        assert_eq!(FeeFactor::new(0.01).to_high_precision(), 10_000);
+        assert_eq!(FeeFactor::new(0.1).to_high_precision(), 100_000);
+    }
+
+    #[test]
+    fn deserialize_valid_fee_factors() {
+        assert_eq!(
+            serde_json::from_str::<FeeFactor>("0.0").unwrap(),
+            FeeFactor::new(0.0)
+        );
+        assert_eq!(
+            serde_json::from_str::<FeeFactor>("0.5").unwrap(),
+            FeeFactor::new(0.5)
+        );
+        assert_eq!(
+            serde_json::from_str::<FeeFactor>("0.99").unwrap(),
+            FeeFactor::new(0.99)
+        );
+        assert_eq!(
+            serde_json::from_str::<FeeFactor>("0.00003").unwrap(),
+            FeeFactor::new(0.00003)
+        );
+    }
+
+    #[test]
+    fn deserialize_invalid_fee_factors() {
+        for value in ["1.0", "1.5", "-0.1", "-1.0"] {
+            let err = serde_json::from_str::<FeeFactor>(value).unwrap_err();
+            assert!(
+                err.to_string()
+                    .contains("expected fee factor to be in interval [0, 1)"),
+                "unexpected error for {value}: {err}"
+            );
+        }
+    }
+
+    #[test]
+    fn deserialize_wrong_type() {
+        assert!(serde_json::from_str::<FeeFactor>("\"not a number\"").is_err());
+        assert!(serde_json::from_str::<FeeFactor>("true").is_err());
+    }
+}
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 9cbd012506..ce416c2951 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -15,6 +15,7 @@ pub mod event_handling;
 pub mod event_storing_helpers;
 pub mod external_prices;
 pub mod fee;
+pub mod fee_factor;
 pub mod gas_price;
 pub mod gas_price_estimation;
 pub mod http_client;

From ce5c66727e6f85a9099d3787f327cf72be0d81a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 19 Feb 2026 18:06:41 +0000
Subject: [PATCH 088/219] Remove deny_unknown_fields for the new autopilot
 config (#4182)

# Description
Having this setting enabled leaves us in a chicken/egg problem where
deploying the services part breaks due to no config, and deploying infra
first breaks because the setting is unknown

The current strategy is:
* Infra first with the old env var set so the old autopilot can still
run
* Autopilot second, which will ignore the env var and work with the
config

# Changes

- [ ] Remove deny_unknown_fields from the autopilot config

## How to test
Next migration we'll find out if this truly works

---------

Co-authored-by: Marcin Szymczak <mail@marszy.com>
---
 crates/autopilot/src/config/mod.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index c28bc7a7d0..1a02840f22 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -9,7 +9,9 @@ pub mod fee_policy;
 pub mod solver;
 
 #[derive(Debug, Default, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+// NOTE: cannot add deny_unknown_fields during the config migration
+// as new ones get added in the config will fail parsing if extra fields are present
+#[serde(rename_all = "kebab-case", /* deny_unknown_fields */)]
 pub struct Configuration {
     pub drivers: Vec<Solver>,
 

From e461506d40adbc10bb1a4c52a4ddda0c7971826c Mon Sep 17 00:00:00 2001
From: extrawurst <776816+extrawurst@users.noreply.github.com>
Date: Thu, 19 Feb 2026 17:22:08 -0300
Subject: [PATCH 089/219] Revise pull request template format (#4183)

Updated the pull request template to use bullet points for changes.

# Description
The `Changes` section contains a list of changes, not a list of checks
that require a checkbox.

Latest example: https://github.com/cowprotocol/services/pull/4182

# Changes

* changes section in template is now bullet points and not checkboxes
---
 .github/pull_request_template.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 8384695eaf..b55ab18b58 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -4,8 +4,8 @@
 # Changes
 <!-- List of detailed changes (how the change is accomplished) -->
 
-- [ ] ...
-- [ ] ...
+* ...
+* ...
 
 ## How to test
 <!--- Include details of how to test your changes, including any pre-requisites. If no unit tests are included, please explain why and how to test manually
@@ -18,4 +18,4 @@
 ## Related Issues
 
 Fixes #
--->
\ No newline at end of file
+-->

From 270a007dea50578bdcb79d8aeb1d81a9ebe89e86 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Fri, 20 Feb 2026 18:09:52 +0000
Subject: [PATCH 090/219] Migrate trusted tokens to the config (#4189)

# Description
Migrates the trusted tokens to the main config. I've grouped to be
easier to read/find in config files

# Changes

* Removes the trusted tokens from the CliArgs
* Adds them to the new config file

## How to test
Staging
---
 Cargo.lock                                    |  1 +
 crates/autopilot/Cargo.toml                   |  1 +
 crates/autopilot/src/arguments.rs             | 28 ---------
 crates/autopilot/src/config/mod.rs            | 33 +++++++++-
 crates/autopilot/src/config/trusted_tokens.rs | 63 +++++++++++++++++++
 crates/autopilot/src/run.rs                   | 12 ++--
 crates/e2e/tests/e2e/buffers.rs               | 22 ++++---
 crates/e2e/tests/e2e/limit_orders.rs          |  1 +
 crates/e2e/tests/e2e/protocol_fee.rs          |  5 ++
 9 files changed, 122 insertions(+), 44 deletions(-)
 create mode 100644 crates/autopilot/src/config/trusted_tokens.rs

diff --git a/Cargo.lock b/Cargo.lock
index f39bc6a032..2a43b9a2aa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1180,6 +1180,7 @@ dependencies = [
  "futures",
  "hex-literal",
  "humantime",
+ "humantime-serde",
  "indexmap 2.13.0",
  "itertools 0.14.0",
  "maplit",
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index ea51d503a6..f5cf28d197 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -37,6 +37,7 @@ observe = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
+humantime-serde = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 mimalloc = { workspace = true, optional = true }
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index f5f44193d6..546f3bb897 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -115,25 +115,6 @@ pub struct CliArguments {
     )]
     pub max_auction_age: Duration,
 
-    /// The URL of a list of tokens our settlement contract is willing to
-    /// internalize.
-    #[clap(long, env)]
-    pub trusted_tokens_url: Option<Url>,
-
-    /// Hardcoded list of trusted tokens to use in addition to
-    /// `trusted_tokens_url`.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub trusted_tokens: Option<Vec<Address>>,
-
-    /// Time interval after which the trusted tokens list needs to be updated.
-    #[clap(
-        long,
-        env,
-        default_value = "1h",
-        value_parser = humantime::parse_duration,
-    )]
-    pub trusted_tokens_update_interval: Duration,
-
     /// The maximum number of blocks to wait for a settlement to appear on
     /// chain.
     #[clap(long, env, default_value = "5")]
@@ -279,9 +260,6 @@ impl std::fmt::Display for CliArguments {
             banned_users,
             banned_users_max_cache_size,
             max_auction_age,
-            trusted_tokens_url,
-            trusted_tokens,
-            trusted_tokens_update_interval,
             submission_deadline,
             shadow,
             solve_deadline,
@@ -333,12 +311,6 @@ impl std::fmt::Display for CliArguments {
             "banned_users_max_cache_size: {banned_users_max_cache_size:?}"
         )?;
         writeln!(f, "max_auction_age: {max_auction_age:?}")?;
-        display_option(f, "trusted_tokens_url", trusted_tokens_url)?;
-        writeln!(f, "trusted_tokens: {trusted_tokens:?}")?;
-        writeln!(
-            f,
-            "trusted_tokens_update_interval: {trusted_tokens_update_interval:?}"
-        )?;
         writeln!(f, "submission_deadline: {submission_deadline}")?;
         display_option(f, "shadow", shadow)?;
         writeln!(f, "solve_deadline: {solve_deadline:?}")?;
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index 1a02840f22..629e655a19 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -1,5 +1,9 @@
 use {
-    crate::config::{fee_policy::FeePoliciesConfig, solver::Solver},
+    crate::config::{
+        fee_policy::FeePoliciesConfig,
+        solver::Solver,
+        trusted_tokens::TrustedTokensConfig,
+    },
     anyhow::{anyhow, ensure},
     serde::{Deserialize, Serialize},
     std::path::Path,
@@ -7,6 +11,7 @@ use {
 
 pub mod fee_policy;
 pub mod solver;
+pub mod trusted_tokens;
 
 #[derive(Debug, Default, Deserialize, Serialize)]
 // NOTE: cannot add deny_unknown_fields during the config migration
@@ -17,6 +22,11 @@ pub struct Configuration {
 
     /// Describes how the protocol fees should be calculated.
     pub fee_policies: FeePoliciesConfig,
+
+    /// Configuration for trusted tokens that the settlement contract is willing
+    /// to internalize.
+    #[serde(default)]
+    pub trusted_tokens: TrustedTokensConfig,
 }
 
 impl Configuration {
@@ -90,6 +100,7 @@ mod tests {
             solver::Account,
         },
         alloy::primitives::address,
+        std::time::Duration,
     };
 
     #[test]
@@ -122,6 +133,11 @@ mod tests {
         [[fee-policies.upcoming-policies.policies]]
         kind.volume = { factor = 0.2 }
         order-class = "any"
+
+        [trusted-tokens]
+        url = "https://example.com/tokens.json"
+        tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        update-interval = "30m"
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -161,6 +177,13 @@ mod tests {
                 .effective_from_timestamp
                 .is_some()
         );
+
+        assert!(config.trusted_tokens.url.is_some());
+        assert_eq!(config.trusted_tokens.tokens.len(), 1);
+        assert_eq!(
+            config.trusted_tokens.update_interval,
+            Duration::from_secs(1800)
+        );
     }
 
     #[test]
@@ -187,6 +210,13 @@ mod tests {
                 .effective_from_timestamp
                 .is_none()
         );
+
+        assert!(config.trusted_tokens.url.is_none());
+        assert!(config.trusted_tokens.tokens.is_empty());
+        assert_eq!(
+            config.trusted_tokens.update_interval,
+            Duration::from_secs(3600)
+        );
     }
 
     #[test]
@@ -207,6 +237,7 @@ mod tests {
                 max_partner_fee: 0.02.try_into().unwrap(),
                 upcoming_policies: UpcomingFeePolicies::default(),
             },
+            ..Default::default()
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/autopilot/src/config/trusted_tokens.rs b/crates/autopilot/src/config/trusted_tokens.rs
new file mode 100644
index 0000000000..75d7b7849b
--- /dev/null
+++ b/crates/autopilot/src/config/trusted_tokens.rs
@@ -0,0 +1,63 @@
+use {
+    alloy::primitives::Address,
+    serde::{Deserialize, Serialize},
+    std::time::Duration,
+    url::Url,
+};
+
+fn default_update_interval() -> Duration {
+    Duration::from_secs(3600) // 1h
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct TrustedTokensConfig {
+    /// The URL of a list of tokens our settlement contract is willing to
+    /// internalize.
+    pub url: Option<Url>,
+
+    /// Hardcoded list of trusted tokens to use in addition to `url`.
+    #[serde(default)]
+    pub tokens: Vec<Address>,
+
+    /// Time interval after which the trusted tokens list needs to be updated.
+    #[serde(with = "humantime_serde", default = "default_update_interval")]
+    pub update_interval: Duration,
+}
+
+impl Default for TrustedTokensConfig {
+    fn default() -> Self {
+        Self {
+            url: None,
+            tokens: Vec::new(),
+            update_interval: default_update_interval(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let toml = "";
+        let config: TrustedTokensConfig = toml::from_str(toml).unwrap();
+        assert!(config.url.is_none());
+        assert!(config.tokens.is_empty());
+        assert_eq!(config.update_interval, Duration::from_secs(3600));
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        url = "https://example.com/tokens.json"
+        tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        update-interval = "30m"
+        "#;
+        let config: TrustedTokensConfig = toml::from_str(toml).unwrap();
+        assert!(config.url.is_some());
+        assert_eq!(config.tokens.len(), 1);
+        assert_eq!(config.update_interval, Duration::from_secs(1800));
+    }
+}
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index d9c5c0f135..eeac596a75 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -494,11 +494,11 @@ pub async fn run(
     );
 
     let market_makable_token_list_configuration = TokenListConfiguration {
-        url: args.trusted_tokens_url,
-        update_interval: args.trusted_tokens_update_interval,
+        url: config.trusted_tokens.url.clone(),
+        update_interval: config.trusted_tokens.update_interval,
         chain_id,
         client: http_factory.create(),
-        hardcoded: args.trusted_tokens.unwrap_or_default(),
+        hardcoded: config.trusted_tokens.tokens.clone(),
     };
     // updated in background task
     let trusted_tokens =
@@ -674,11 +674,11 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
         }
 
         AutoUpdatingTokenList::from_configuration(TokenListConfiguration {
-            url: args.trusted_tokens_url,
-            update_interval: args.trusted_tokens_update_interval,
+            url: config.trusted_tokens.url,
+            update_interval: config.trusted_tokens.update_interval,
             chain_id,
             client: http_factory.create(),
-            hardcoded: args.trusted_tokens.unwrap_or_default(),
+            hardcoded: config.trusted_tokens.tokens,
         })
         .await
     };
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 9825e41c05..4938a1c486 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,6 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::Configuration,
+    autopilot::config::{Configuration, trusted_tokens::TrustedTokensConfig},
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -61,19 +61,23 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
         false,
     );
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
+    let (_config_file, config_arg) = Configuration {
+        trusted_tokens: TrustedTokensConfig {
+            tokens: vec![
+                *onchain.contracts().weth.address(),
+                *token_a.address(),
+                *token_b.address(),
+            ],
+            ..Default::default()
+        },
+        ..Configuration::test("test_solver", solver.address())
+    }
+    .to_cli_args();
 
     services
         .start_autopilot(
             None,
             vec![
-                format!(
-                    "--trusted-tokens={weth:#x},{token_a:#x},{token_b:#x}",
-                    weth = onchain.contracts().weth.address(),
-                    token_a = token_a.address(),
-                    token_b = token_b.address()
-                ),
                 config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 79bb063cc4..46e55d5ca7 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -1107,6 +1107,7 @@ async fn no_liquidity_limit_order(web3: Web3) {
             ],
             ..Default::default()
         },
+        ..Default::default()
     }
     .to_cli_args();
 
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 207f7ffccd..a6bdf3ee62 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -167,6 +167,7 @@ async fn combined_protocol_fees(web3: Web3) {
             max_partner_fee: 0.02.try_into().unwrap(),
             ..Default::default()
         },
+        ..Default::default()
     }
     .to_cli_args();
 
@@ -521,6 +522,7 @@ async fn surplus_partner_fee(web3: Web3) {
             max_partner_fee: MAX_PARTNER_VOLUME_FEE.try_into().unwrap(),
             ..Default::default()
         },
+        ..Default::default()
     }
     .to_cli_args();
 
@@ -769,6 +771,7 @@ async fn volume_fee_buy_order_test(web3: Web3) {
             },
             ..Default::default()
         },
+        ..Default::default()
     }
     .to_cli_args();
 
@@ -933,6 +936,7 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) {
             },
             ..Default::default()
         },
+        ..Default::default()
     }
     .to_cli_args();
 
@@ -1097,6 +1101,7 @@ async fn volume_fee_overrides(web3: Web3) {
             policies: vec![default_volume_fee],
             ..Default::default()
         },
+        ..Default::default()
     }
     .to_cli_args();
 

From a0266b8cfdee6c979e08695c1eadc782bc9da07f Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 20 Feb 2026 21:38:19 +0100
Subject: [PATCH 091/219] Optimize uni v3 liquidity fetching (#4188)

# Description
The majority of time fetching uni v3 liquidity is spent cloning pool
states.
This makes up 3.6% of the entire CPU time of the driver.
<img width="1920" height="935" alt="Screenshot 2026-02-19 at 22 50 02"
src="https://github.com/user-attachments/assets/a59efa24-60c0-4a4e-9c36-428521ef0bc5"
/>


# Changes
This PR applies 2 optimizations:
* reuse existing allocation with `into_iter().filter().collect()`
* store `PoolInfo` in `Arc`s for cheap clones

I'd like to highlight the use of `Arc::make_mut`. If there is no `Arc`
pointing to the same allocation as our `Arc` we can simply get a mutable
reference. If there are other `Arc`s pointing to our allocation we deep
clone it and point our `Arc` to the new allocation (clone on write).
This is quite cool because together with the fact that `append_events`
takes an exclusive reference to the `pools` we know that there can be no
new `Arc` pointing to a recently updated `PoolInfo` before the function
is over. This ensures that every `PoolInfo` that needs to be updated
will always be cloned at most once.

## How to test
Briefly tested in prod

This yielded surprising results. The amount of time spent inside the uni
v3 liquidity fetching logic remained unchanged and even the time used
for allocations was pretty much unchanged.
But since the cloning of the data was moved to when it gets updated
instead of every time it's needed for a request the time needed to fetch
all the liquidity improved significantly. (still nothing to write home
about, though)
<img width="629" height="302" alt="Screenshot 2026-02-19 at 23 31 05"
src="https://github.com/user-attachments/assets/6dc00c53-4afe-4761-af37-d5848f0da4a0"
/>

Also some other CPU bound pre-processing tasks got faster as well:
<img width="630" height="300" alt="Screenshot 2026-02-19 at 23 31 14"
src="https://github.com/user-attachments/assets/307e4ad1-de24-477d-8a4d-3f5f140233d8"
/>
<img width="625" height="294" alt="Screenshot 2026-02-19 at 23 31 31"
src="https://github.com/user-attachments/assets/31060dcf-1a7b-4c84-8ee1-f3910ef65a8a"
/>
<img width="625" height="302" alt="Screenshot 2026-02-19 at 23 31 23"
src="https://github.com/user-attachments/assets/6c8af19f-942c-44d2-82c2-8b0058d0cf45"
/>
---
 .../src/boundary/liquidity/uniswap/v3.rs      |  2 +-
 .../src/sources/uniswap_v3/pool_fetching.rs   | 46 +++++++++++--------
 crates/solver/src/liquidity/mod.rs            |  2 +-
 3 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/crates/driver/src/boundary/liquidity/uniswap/v3.rs b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
index f717c852ef..ae3f9a71e4 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v3.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
@@ -56,7 +56,7 @@ pub fn to_domain(id: liquidity::Id, pool: ConcentratedLiquidity) -> Result<liqui
             )?,
             sqrt_price: SqrtPrice(pool.pool.state.sqrt_price),
             liquidity: Liquidity(u128::try_from(pool.pool.state.liquidity)?),
-            tick: Tick(pool.pool.state.tick.try_into()?),
+            tick: Tick(pool.pool.state.tick.clone().try_into()?),
             liquidity_net: pool
                 .pool
                 .state
diff --git a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs b/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
index 5047e408db..5ebc461074 100644
--- a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
+++ b/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
@@ -23,7 +23,6 @@ use {
         alloy::ProviderLabelingExt,
         block_stream::{BlockRetrieving, RangeInclusive},
     },
-    itertools::{Either, Itertools},
     model::TokenPair,
     num::{BigInt, Zero, rational::Ratio},
     number::serialization::HexOrDecimalU256,
@@ -44,7 +43,7 @@ pub trait PoolFetching: Send + Sync {
         &self,
         token_pairs: &HashSet<TokenPair>,
         at_block: Block,
-    ) -> Result<Vec<PoolInfo>>;
+    ) -> Result<Vec<Arc<PoolInfo>>>;
 }
 
 /// Pool data in a format prepared for solvers.
@@ -120,7 +119,7 @@ impl TryFrom<PoolData> for PoolInfo {
 #[derive(Default)]
 struct PoolsCheckpoint {
     /// Pools state.
-    pools: HashMap<Address, PoolInfo>,
+    pools: HashMap<Address, Arc<PoolInfo>>,
     /// Block number for which `pools` field was populated.
     block_number: u64,
     /// Pools that don't exist in `pools` field, therefore need to be
@@ -180,7 +179,7 @@ impl PoolsCheckpointHandler {
             .get_pools_with_ticks_by_ids(&pool_ids, registered_pools.fetched_block_number)
             .await?
             .into_iter()
-            .filter_map(|pool| Some((pool.id, pool.try_into().ok()?)))
+            .filter_map(|pool| Some((pool.id, Arc::new(pool.try_into().ok()?))))
             .collect::<HashMap<_, _>>();
         let pools_checkpoint = Mutex::new(PoolsCheckpoint {
             pools,
@@ -198,7 +197,7 @@ impl PoolsCheckpointHandler {
     /// For a given list of token pairs, fetches the pools for the ones that
     /// exist in the checkpoint. For the ones that don't exist, flag as
     /// missing and expect to exist after the next maintenance run.
-    fn get(&self, token_pairs: &HashSet<TokenPair>) -> (HashMap<Address, PoolInfo>, u64) {
+    fn get(&self, token_pairs: &HashSet<TokenPair>) -> (HashMap<Address, Arc<PoolInfo>>, u64) {
         let mut pool_ids = token_pairs
             .iter()
             .filter_map(|pair| self.pools_by_token_pair.get(pair))
@@ -210,11 +209,17 @@ impl PoolsCheckpointHandler {
         match pool_ids.peek() {
             Some(_) => {
                 let mut pools_checkpoint = self.pools_checkpoint.lock().unwrap();
-                let (existing_pools, missing_pools): (HashMap<Address, PoolInfo>, Vec<Address>) =
-                    pool_ids.partition_map(|pool_id| match pools_checkpoint.pools.get(pool_id) {
-                        Some(entry) => Either::Left((*pool_id, entry.clone())),
-                        _ => Either::Right(pool_id),
-                    });
+                let mut existing_pools = HashMap::<Address, Arc<PoolInfo>>::default();
+                let missing_pools = pool_ids
+                    .filter(|pool_id| match pools_checkpoint.pools.get(*pool_id) {
+                        Some(entry) => {
+                            existing_pools.insert(**pool_id, entry.clone());
+                            false
+                        }
+                        None => true,
+                    })
+                    .collect::<Vec<_>>();
+
                 tracing::trace!(
                     "cache hit: {:?}, cache miss: {:?}",
                     existing_pools.keys(),
@@ -255,7 +260,7 @@ impl PoolsCheckpointHandler {
         let mut checkpoint = self.pools_checkpoint.lock().unwrap();
         for pool in pools? {
             checkpoint.missing_pools.remove(&pool.id);
-            checkpoint.pools.insert(pool.id, pool.try_into()?);
+            checkpoint.pools.insert(pool.id, Arc::new(pool.try_into()?));
         }
 
         tracing::debug!("number of cached pools is {}", checkpoint.pools.len());
@@ -356,7 +361,7 @@ impl PoolFetching for UniswapV3PoolFetcher {
         &self,
         token_pairs: &HashSet<TokenPair>,
         at_block: Block,
-    ) -> Result<Vec<PoolInfo>> {
+    ) -> Result<Vec<Arc<PoolInfo>>> {
         let block_number = match at_block {
             Block::Recent | Block::Finalized => self
                 .events
@@ -412,11 +417,12 @@ impl PoolFetching for UniswapV3PoolFetcher {
 
 /// For a given checkpoint, append events to get a new checkpoint
 fn append_events(
-    pools: &mut HashMap<Address, PoolInfo>,
+    pools: &mut HashMap<Address, Arc<PoolInfo>>,
     events: Vec<WithAddress<UniswapV3PoolEvents>>,
 ) {
     for event in events {
-        if let Some(pool) = pools.get_mut(&event.address()).map(|pool| &mut pool.state) {
+        if let Some(pool) = pools.get_mut(&event.address()).map(Arc::make_mut) {
+            let pool = &mut pool.state;
             match event.inner() {
                 UniswapV3PoolEvents::Burn(burn) => {
                     let tick_lower = BigInt::from(burn.tickLower.as_i32());
@@ -606,10 +612,10 @@ mod tests {
     #[test]
     fn append_events_test_swap() {
         let address = Address::with_last_byte(1);
-        let pool = PoolInfo {
+        let pool = Arc::new(PoolInfo {
             address,
             ..Default::default()
-        };
+        });
         let mut pools = HashMap::from([(address, pool)]);
 
         let event = WithAddress::new(
@@ -634,10 +640,10 @@ mod tests {
     #[test]
     fn append_events_test_burn() {
         let address = Address::with_last_byte(1);
-        let pool = PoolInfo {
+        let pool = Arc::new(PoolInfo {
             address,
             ..Default::default()
-        };
+        });
         let mut pools = HashMap::from([(address, pool)]);
 
         // add first burn event
@@ -687,10 +693,10 @@ mod tests {
     #[test]
     fn append_events_test_mint() {
         let address = Address::with_last_byte(1);
-        let pool = PoolInfo {
+        let pool = Arc::new(PoolInfo {
             address,
             ..Default::default()
-        };
+        });
         let mut pools = HashMap::from([(address, pool)]);
 
         // add first mint event
diff --git a/crates/solver/src/liquidity/mod.rs b/crates/solver/src/liquidity/mod.rs
index 5a118cd54b..b4dcc4cc96 100644
--- a/crates/solver/src/liquidity/mod.rs
+++ b/crates/solver/src/liquidity/mod.rs
@@ -379,7 +379,7 @@ impl Settleable for StablePoolOrder {
 #[derive(Clone)]
 pub struct ConcentratedLiquidity {
     pub tokens: TokenPair,
-    pub pool: PoolInfo,
+    pub pool: Arc<PoolInfo>,
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
 }
 

From ce4e2a0f65bb2b13406a5b9ee371fad768949079 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 20 Feb 2026 21:40:03 +0100
Subject: [PATCH 092/219] Compress S3 body in blocking task (#4185)

# Description
Serializing the auction and compressing the bytes is CPU bound work and
takes quite long.
That stuff should be spawned on a block_task to not hog one of the
regular tokio runtime threads and cause spikes in tail latency.

# Changes
* spawn blocking task for serializing and compression s3 upload
---
 crates/autopilot/src/infra/persistence/mod.rs |  5 +++--
 crates/s3/Cargo.toml                          |  1 +
 crates/s3/src/lib.rs                          | 19 ++++++++++++++-----
 3 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index 879967cc4a..a57c6c6443 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -171,9 +171,10 @@ impl Persistence {
         let Some(s3) = self.s3.clone() else {
             return;
         };
-        let auction_dto = dto::auction::from_domain(auction.clone());
+        let auction = auction.clone();
         tokio::task::spawn(async move {
-            match s3.upload(id.to_string(), &auction_dto).await {
+            let auction_dto = dto::auction::from_domain(auction);
+            match s3.upload(id.to_string(), auction_dto).await {
                 Ok(key) => tracing::info!(?key, "uploaded auction to s3"),
                 Err(err) => tracing::warn!(?err, "failed to upload auction to s3"),
             }
diff --git a/crates/s3/Cargo.toml b/crates/s3/Cargo.toml
index c0fa2981d4..ce6ecb3883 100644
--- a/crates/s3/Cargo.toml
+++ b/crates/s3/Cargo.toml
@@ -12,6 +12,7 @@ aws-sdk-s3 = { workspace = true, features = ["rustls", "rt-tokio"] }
 flate2 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+tokio = { workspace = true }
 
 [dev-dependencies]
 chrono = { workspace = true, features = ["clock"] }
diff --git a/crates/s3/src/lib.rs b/crates/s3/src/lib.rs
index ee2235200b..d777b156fc 100644
--- a/crates/s3/src/lib.rs
+++ b/crates/s3/src/lib.rs
@@ -35,9 +35,18 @@ impl Uploader {
 
     /// Upload the bytes json encoded to the configured S3 bucket. Returns the
     /// key under which the file can be queried
-    pub async fn upload(&self, id: String, content: impl Serialize) -> Result<String> {
-        let bytes = serde_json::to_vec(&content)?;
-        let encoded = self.gzip(&bytes)?;
+    pub async fn upload(
+        &self,
+        id: String,
+        content: impl Serialize + Send + Sync + 'static,
+    ) -> Result<String> {
+        let encoded = tokio::task::spawn_blocking(move || {
+            let bytes = serde_json::to_vec(&content)?;
+            Self::gzip(&bytes)
+        })
+        .await
+        .context("compression task panicked")??;
+
         let key = std::path::Path::new(&self.filename_prefix)
             .join(format!("{id}.json"))
             .to_str()
@@ -75,7 +84,7 @@ impl Uploader {
     }
 
     /// Compresses the input bytes using Gzip.
-    fn gzip(&self, bytes: &[u8]) -> Result<Vec<u8>> {
+    fn gzip(bytes: &[u8]) -> Result<Vec<u8>> {
         let mut encoder = GzEncoder::new(bytes, Compression::best());
         let mut encoded: Vec<u8> = Vec::with_capacity(bytes.len());
         encoder.read_to_end(&mut encoded).context("gzip encoding")?;
@@ -109,7 +118,7 @@ mod tests {
 
         let uploader = Uploader::new(config).await;
         let key = uploader
-            .upload("test".to_string(), value.as_bytes())
+            .upload("test".to_string(), value.clone().into_bytes())
             .await
             .unwrap();
 

From a6d3976eb883564a292c9a0e5ca32a02758d2bb0 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 20 Feb 2026 21:53:58 +0100
Subject: [PATCH 093/219] Speedup event indexing (#4180)

# Description
Currently the event indexing logic is dominated by 2 calls:
* eth_getBlock
* eth_getLogs (events of fetched block)

This PR eliminates `eth_getLogs` calls.
Since the rest of the indexing logic is not dominated by `eth_getLogs` I
think the only way how we could meaningfully speed up the process
further is by subscribing to log filters and streaming the results as
soon as a new block was processed by the ethereum node.

# Changes
Since we already have a component that keeps track of the latest block I
created a new type that implements `BlockRetrieving` that simply
forwards `get_current_block()` calls to the block stream instead of
sending an RPC request.

Also adds a few tracing spans and replaces the awkward request batching
logic of the event handler with something easier to read.

## How to test
tested on staging mainnet (indexing overhead should be identical to
prod)
the time the autopilot waits for essential processing to be done
decreased from ~65ms to ~45ms

<img width="801" height="150" alt="Screenshot 2026-02-19 at 13 04 48"
src="https://github.com/user-attachments/assets/18ce0eb8-5e8c-4412-a12b-efa4c6b1f313"
/>
<img width="657" height="300" alt="Screenshot 2026-02-19 at 13 03 12"
src="https://github.com/user-attachments/assets/8f823a5c-a1d4-4bd0-ac10-c4c07fed068f"
/>
<img width="1262" height="302" alt="Screenshot 2026-02-19 at 13 05 44"
src="https://github.com/user-attachments/assets/8f007f53-9efb-44a4-b426-cf91d25cb0c4"
/>
---
 crates/autopilot/src/run.rs         | 15 ++++++--
 crates/cow-amm/src/factory.rs       | 12 +++----
 crates/cow-amm/src/maintainers.rs   | 10 +++---
 crates/cow-amm/src/registry.rs      | 26 ++++++++------
 crates/ethrpc/src/block_stream.rs   | 44 +++++++++++++++++++----
 crates/shared/src/event_handling.rs | 56 +++++++++++++++--------------
 6 files changed, 105 insertions(+), 58 deletions(-)

diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index eeac596a75..bd1c2a5a1b 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -29,7 +29,10 @@ use {
     chain::Chain,
     clap::Parser,
     contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
-    ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
+    ethrpc::{
+        Web3,
+        block_stream::{BlockRetriever, block_number_to_block_number_hash},
+    },
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::LivenessChecking,
@@ -271,7 +274,10 @@ pub async fn run(
     let token_info_fetcher = Arc::new(CachedTokenInfoFetcher::new(Arc::new(TokenInfoFetcher {
         web3: web3.clone(),
     })));
-    let block_retriever = Arc::new(web3.provider.clone());
+    let block_retriever = Arc::new(BlockRetriever {
+        provider: web3.provider.clone(),
+        block_stream: eth.current_block().clone(),
+    });
 
     let code_fetcher = Arc::new(CachedCodeFetcher::new(Arc::new(web3.clone())));
 
@@ -401,7 +407,10 @@ pub async fn run(
         boundary::web3_client(url, &args.shared.ethrpc)
     });
 
-    let mut cow_amm_registry = cow_amm::Registry::new(archive_node_web3);
+    let mut cow_amm_registry = cow_amm::Registry::new(Arc::new(BlockRetriever {
+        provider: archive_node_web3.provider,
+        block_stream: eth.current_block().clone(),
+    }));
     for config in &args.cow_amm_configs {
         cow_amm_registry
             .add_listener(
diff --git a/crates/cow-amm/src/factory.rs b/crates/cow-amm/src/factory.rs
index 214a3a6f40..713351b30f 100644
--- a/crates/cow-amm/src/factory.rs
+++ b/crates/cow-amm/src/factory.rs
@@ -5,16 +5,16 @@ use {
         rpc::types::{Filter, FilterSet},
         sol_types::SolEvent,
     },
-    contracts::alloy::cow_amm::CowAmmLegacyHelper::{
-        CowAmmLegacyHelper,
-        CowAmmLegacyHelper::CowAmmLegacyHelperEvents as CowAmmEvent,
+    contracts::alloy::cow_amm::CowAmmLegacyHelper::CowAmmLegacyHelper::{
+        self,
+        CowAmmLegacyHelperEvents as CowAmmEvent,
     },
-    ethrpc::Web3,
+    ethrpc::AlloyProvider,
     shared::event_handling::AlloyEventRetrieving,
 };
 
 pub(crate) struct Factory {
-    pub(crate) web3: Web3,
+    pub(crate) provider: AlloyProvider,
     pub(crate) address: Address,
 }
 
@@ -30,6 +30,6 @@ impl AlloyEventRetrieving for Factory {
     }
 
     fn provider(&self) -> &DynProvider {
-        &self.web3.provider
+        &self.provider
     }
 }
diff --git a/crates/cow-amm/src/maintainers.rs b/crates/cow-amm/src/maintainers.rs
index b4c93a2f84..4751eaae7a 100644
--- a/crates/cow-amm/src/maintainers.rs
+++ b/crates/cow-amm/src/maintainers.rs
@@ -1,7 +1,7 @@
 use {
     crate::{Amm, cache::Storage},
     contracts::alloy::ERC20,
-    ethrpc::Web3,
+    ethrpc::AlloyProvider,
     futures::{
         future::{join_all, select_ok},
         stream::{FuturesUnordered, StreamExt},
@@ -13,12 +13,12 @@ use {
 
 pub struct EmptyPoolRemoval {
     storage: Arc<RwLock<Vec<Storage>>>,
-    web3: Web3,
+    provider: AlloyProvider,
 }
 
 impl EmptyPoolRemoval {
-    pub fn new(storage: Arc<RwLock<Vec<Storage>>>, web3: Web3) -> Self {
-        Self { storage, web3 }
+    pub fn new(storage: Arc<RwLock<Vec<Storage>>>, provider: AlloyProvider) -> Self {
+        Self { storage, provider }
     }
 
     /// Checks if the given AMM has a zero token balance.
@@ -28,7 +28,7 @@ impl EmptyPoolRemoval {
             .traded_tokens()
             .iter()
             .map(move |token| async move {
-                ERC20::Instance::new(*token, self.web3.provider.clone())
+                ERC20::Instance::new(*token, self.provider.clone())
                     .balanceOf(*amm_address)
                     .call()
                     .await
diff --git a/crates/cow-amm/src/registry.rs b/crates/cow-amm/src/registry.rs
index 1af451ac9e..66b3146515 100644
--- a/crates/cow-amm/src/registry.rs
+++ b/crates/cow-amm/src/registry.rs
@@ -2,7 +2,10 @@ use {
     crate::{Amm, cache::Storage, factory::Factory, maintainers::EmptyPoolRemoval},
     alloy::primitives::Address,
     contracts::alloy::cow_amm::CowAmmLegacyHelper,
-    ethrpc::{Web3, block_stream::CurrentBlockWatcher},
+    ethrpc::{
+        AlloyProvider,
+        block_stream::{BlockRetriever, CurrentBlockWatcher},
+    },
     shared::{
         event_handling::EventHandler,
         maintenance::{Maintaining, ServiceMaintenance},
@@ -16,20 +19,24 @@ use {
 /// CoW AMM indexer which stores events in-memory.
 #[derive(Clone)]
 pub struct Registry {
-    web3: Web3,
+    block_retriever: Arc<BlockRetriever>,
     storage: Arc<RwLock<Vec<Storage>>>,
     maintenance_tasks: Vec<Arc<dyn Maintaining>>,
 }
 
 impl Registry {
-    pub fn new(web3: Web3) -> Self {
+    pub fn new(block_retriever: Arc<BlockRetriever>) -> Self {
         Self {
             storage: Default::default(),
-            web3,
+            block_retriever,
             maintenance_tasks: vec![],
         }
     }
 
+    fn provider(&self) -> &AlloyProvider {
+        &self.block_retriever.provider
+    }
+
     /// Registers a new listener to detect CoW AMMs deployed by `factory`.
     /// Interfacing with the CoW AMM happens via the
     /// [`contracts::CowAmmLegacyHelper`] deployed at `helper_contract`.
@@ -44,7 +51,7 @@ impl Registry {
     ) {
         let storage = Storage::new(
             deployment_block,
-            CowAmmLegacyHelper::Instance::new(helper_contract, self.web3.provider.clone()),
+            CowAmmLegacyHelper::Instance::new(helper_contract, self.provider().clone()),
             factory,
             db,
         )
@@ -53,13 +60,12 @@ impl Registry {
         self.storage.write().await.push(storage.clone());
 
         let indexer = Factory {
-            web3: self.web3.clone(),
+            provider: self.provider().clone(),
             address: factory,
         };
-        let event_handler =
-            EventHandler::new(Arc::new(self.web3.provider.clone()), indexer, storage, None);
+        let event_handler = EventHandler::new(self.block_retriever.clone(), indexer, storage, None);
         let token_balance_maintainer =
-            EmptyPoolRemoval::new(self.storage.clone(), self.web3.clone());
+            EmptyPoolRemoval::new(self.storage.clone(), self.provider().clone());
 
         self.maintenance_tasks
             .push(Arc::new(Mutex::new(event_handler)));
@@ -91,7 +97,7 @@ impl Registry {
 impl std::fmt::Debug for Registry {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct("Registry")
-            .field("web3", &self.web3)
+            .field("block_retriever", &self.block_retriever)
             .field("storage", &self.storage)
             .finish()
     }
diff --git a/crates/ethrpc/src/block_stream.rs b/crates/ethrpc/src/block_stream.rs
index cd1de4448b..aba53cae3a 100644
--- a/crates/ethrpc/src/block_stream.rs
+++ b/crates/ethrpc/src/block_stream.rs
@@ -238,7 +238,7 @@ pub async fn current_block_stream(
     let (provider, _) =
         crate::alloy::unbuffered_provider(url.as_str(), Some("base_currentBlockStream"));
 
-    let first_block = provider.current_block().await?;
+    let first_block = get_block_at_id(&provider, BlockId::latest()).await?;
     tracing::debug!(number=%first_block.number, hash=?first_block.hash, "polled block");
 
     let (sender, receiver) = watch::channel(first_block);
@@ -246,7 +246,7 @@ pub async fn current_block_stream(
         let mut previous_block = first_block;
         loop {
             tokio::time::sleep(poll_interval).await;
-            let block = match provider.current_block().await {
+            let block = match get_block_at_id(&provider, BlockId::latest()).await {
                 Ok(block) => block,
                 Err(err) => {
                     tracing::warn!("failed to get current block: {:?}", err);
@@ -357,18 +357,21 @@ pub trait BlockRetrieving: Debug + Send + Sync + 'static {
 
 #[async_trait::async_trait]
 impl BlockRetrieving for AlloyProvider {
+    #[instrument(skip_all)]
     async fn current_block(&self) -> Result<BlockInfo> {
-        get_block_at_id(self, BlockId::latest()).await?.try_into()
+        get_block_at_id(&self, BlockId::latest()).await
     }
 
+    #[instrument(skip_all)]
     async fn block(&self, number: u64) -> Result<BlockNumberHash> {
-        let block = get_block_at_id(self, BlockId::number(number)).await?;
-        Ok((block.header.number, block.header.hash))
+        let block = get_block_at_id(&self, BlockId::number(number)).await?;
+        Ok((block.number, block.hash))
     }
 
     /// Gets all blocks requested in the range. For successful results it's
     /// enforced that all the blocks are present, in the correct order and that
     /// there are no reorgs in the block range.
+    #[instrument(skip_all)]
     async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>> {
         let (start, end) = range.into_inner();
 
@@ -418,12 +421,39 @@ impl BlockRetrieving for AlloyProvider {
     }
 }
 
-async fn get_block_at_id(provider: &AlloyProvider, id: BlockId) -> Result<Block> {
+/// Version of [`BlockRetrieving`] that's optimized for the usage
+/// in the event indexing logic.
+#[derive(Debug, Clone)]
+pub struct BlockRetriever {
+    pub provider: AlloyProvider,
+    pub block_stream: watch::Receiver<BlockInfo>,
+}
+
+#[async_trait::async_trait]
+impl BlockRetrieving for BlockRetriever {
+    #[instrument(skip_all)]
+    async fn current_block(&self) -> Result<BlockInfo> {
+        Ok(*self.block_stream.borrow())
+    }
+
+    #[instrument(skip_all)]
+    async fn block(&self, number: u64) -> Result<BlockNumberHash> {
+        self.provider.block(number).await
+    }
+
+    #[instrument(skip_all)]
+    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>> {
+        self.provider.blocks(range).await
+    }
+}
+
+async fn get_block_at_id(provider: &AlloyProvider, id: BlockId) -> Result<BlockInfo> {
     let block = provider
         .get_block(id)
         .await
         .with_context(|| format!("failed to get block for {id:?}"))?
-        .with_context(|| format!("no block for {id:?}"))?;
+        .with_context(|| format!("no block for {id:?}"))?
+        .try_into()?;
 
     Ok(block)
 }
diff --git a/crates/shared/src/event_handling.rs b/crates/shared/src/event_handling.rs
index 1c37aceca8..4e3fb6c980 100644
--- a/crates/shared/src/event_handling.rs
+++ b/crates/shared/src/event_handling.rs
@@ -8,7 +8,7 @@ use {
     },
     anyhow::{Context, Result},
     ethrpc::block_stream::{BlockNumberHash, BlockRetrieving, RangeInclusive},
-    futures::{Stream, StreamExt, future},
+    futures::{Stream, StreamExt},
     std::{pin::Pin, sync::Arc},
     tokio::sync::Mutex,
     tracing::{Instrument, instrument},
@@ -102,6 +102,7 @@ where
 {
     type Event = (T::Event, Log);
 
+    #[instrument(skip_all)]
     async fn get_events_by_block_hash(&self, block_hash: B256) -> Result<Vec<Self::Event>> {
         let filter = self.filter().at_block_hash(block_hash);
         let events = self
@@ -265,14 +266,15 @@ where
     async fn event_block_range(&self) -> Result<EventRange> {
         let handled_blocks = if self.last_handled_blocks.is_empty() {
             let last_handled_block = self.store.last_event_block().await?;
-            self.block_retriever
+            &self
+                .block_retriever
                 .blocks(RangeInclusive::try_new(
                     last_handled_block,
                     last_handled_block,
                 )?)
                 .await?
         } else {
-            self.last_handled_blocks.clone()
+            &self.last_handled_blocks
         };
 
         let current_block = self.block_retriever.current_block().await?;
@@ -361,7 +363,7 @@ where
         let (latest_blocks, is_reorg) = match history_range {
             Some(_) => (latest_blocks, true),
             None => {
-                let (latest_blocks, is_reorg) = detect_reorg_path(&handled_blocks, &latest_blocks);
+                let (latest_blocks, is_reorg) = detect_reorg_path(handled_blocks, &latest_blocks);
                 (latest_blocks.to_vec(), is_reorg)
             }
         };
@@ -506,41 +508,40 @@ where
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn past_events_by_block_hashes(
         &self,
         blocks: &[BlockNumberHash],
     ) -> (Vec<BlockNumberHash>, Vec<E>) {
         let (mut blocks_filtered, mut events) = (vec![], vec![]);
-        for chunk in blocks.chunks(MAX_PARALLEL_RPC_CALLS) {
-            for (i, result) in future::join_all(
-                chunk
-                    .iter()
-                    .map(|block| self.contract.get_events_by_block_hash(block.1)),
-            )
-            .await
-            .into_iter()
-            .enumerate()
-            {
-                match result {
-                    Ok(e) => {
-                        if !e.is_empty() {
-                            tracing::debug!(
-                                "events fetched for block: {:?}, events: {}",
-                                blocks[i],
-                                e.len(),
-                            );
-                        }
-                        blocks_filtered.push(blocks[i]);
-                        events.extend(e);
+        let mut stream = futures::stream::iter(blocks.iter().cloned().enumerate().map(
+            async move |(index, block)| {
+                (index, self.contract.get_events_by_block_hash(block.1).await)
+            },
+        ))
+        .buffered(MAX_PARALLEL_RPC_CALLS);
+
+        while let Some((index, result)) = stream.next().await {
+            match result {
+                Ok(e) => {
+                    if !e.is_empty() {
+                        tracing::debug!(
+                            "events fetched for block: {:?}, events: {}",
+                            blocks[index],
+                            e.len(),
+                        );
                     }
-                    Err(_) => return (blocks_filtered, events),
+                    blocks_filtered.push(blocks[index]);
+                    events.extend(e);
                 }
+                Err(_) => return (blocks_filtered, events),
             }
         }
 
         (blocks_filtered, events)
     }
 
+    #[instrument(skip_all)]
     async fn past_events_by_block_number_range(
         &self,
         block_range: &RangeInclusive<u64>,
@@ -548,6 +549,7 @@ where
         self.contract.get_events_by_block_range(block_range).await
     }
 
+    #[instrument(skip_all)]
     fn update_last_handled_blocks(&mut self, blocks: &[BlockNumberHash]) {
         tracing::debug!(
             "blocks to update into last_handled_blocks: {:?} - {:?}, last_handled_blocks: {:?} - \
@@ -570,7 +572,7 @@ where
             .last_handled_blocks
             .len()
             .saturating_sub(MAX_REORG_BLOCK_COUNT as usize);
-        self.last_handled_blocks = self.last_handled_blocks[start_index..].to_vec();
+        self.last_handled_blocks.drain(..start_index);
         tracing::debug!(
             "last_handled_blocks after update: {:?} - {:?}",
             self.last_handled_blocks.first(),

From 2ae17d22a9b0dbdb61fc132dd954594d1a4e3912 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 23 Feb 2026 09:53:26 +0000
Subject: [PATCH 094/219] Upgrade prometheus to 0.14 (#4193)

# Description
Upgrades prometheus to 0.14 & the metrics macro to 0.6

Closes https://github.com/cowprotocol/services/issues/3338

# Changes

* Upgrades prometheus to 0.14 & the metrics macro to 0.6
* Changes some callsites to match the new with_label_values signatures

## How to test
Staging
---
 Cargo.lock                                    | 35 +++++++++++++------
 Cargo.toml                                    |  4 +--
 crates/autopilot/src/run_loop.rs              | 12 +++----
 crates/autopilot/src/shadow.rs                |  4 +--
 crates/driver/src/infra/observe/mod.rs        |  4 +--
 crates/orderbook/src/api.rs                   |  4 +--
 .../src/price_estimation/competition/mod.rs   |  2 +-
 crates/shared/src/request_sharing.rs          |  4 +--
 crates/shared/src/tenderly_api.rs             |  2 +-
 9 files changed, 42 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2a43b9a2aa..773d03f6bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5130,9 +5130,9 @@ dependencies = [
 
 [[package]]
 name = "prometheus"
-version = "0.13.4"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d33c28a30771f7f96db69893f78b857f7450d7e0237e9c8fc6427a81bae7ed1"
+checksum = "3ca5326d8d0b950a9acd87e6a3f94745394f62e4dae1b1ee22b2bc0c394af43a"
 dependencies = [
  "cfg-if",
  "fnv",
@@ -5140,29 +5140,28 @@ dependencies = [
  "memchr",
  "parking_lot",
  "protobuf",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
 name = "prometheus-metric-storage"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3282447ea0b07baa9011e45de96794c5963db0162c1001d2867750715d63ff14"
+checksum = "53a55c0609963f710688a781fb4de9bfc094dfb0dbfa46331486152c4b011330"
 dependencies = [
- "lazy_static",
  "prometheus",
  "prometheus-metric-storage-derive",
 ]
 
 [[package]]
 name = "prometheus-metric-storage-derive"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "239221aa10cd35277c58b8f6509280b2613321760b49584d7a7351a6aacb6963"
+checksum = "710d30cd8d768420cf9d0f1727c2709df928cd509810fcb98dd386580dccf919"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -5264,9 +5263,23 @@ dependencies = [
 
 [[package]]
 name = "protobuf"
-version = "2.28.0"
+version = "3.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
+checksum = "d65a1d4ddae7d8b5de68153b48f6aa3bba8cb002b243dbdbc55a5afbc98f99f4"
+dependencies = [
+ "once_cell",
+ "protobuf-support",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "protobuf-support"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e36c2f31e0a47f9280fb347ef5e461ffcd2c52dd520d8e216b52f93b0b0d7d6"
+dependencies = [
+ "thiserror 1.0.69",
+]
 
 [[package]]
 name = "psl-types"
diff --git a/Cargo.toml b/Cargo.toml
index 3ed66ce276..4d33fdf2d4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,8 +32,8 @@ itertools = "0.14"
 maplit = "1.0.2"
 mockall = "0.12.1"
 num = "0.4.3"
-prometheus = "0.13.4"
-prometheus-metric-storage = "0.5.0"
+prometheus = "0.14"
+prometheus-metric-storage = "0.6"
 rand = "0.8.5"
 regex = "1.10.4"
 reqwest = "0.13"
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 47fefb0f82..edcefd4993 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -995,7 +995,7 @@ impl Metrics {
     fn solve_ok(driver: &infra::Driver, elapsed: Duration) {
         Self::get()
             .solve
-            .with_label_values(&[&driver.name, "success"])
+            .with_label_values(&[driver.name.as_str(), "success"])
             .observe(elapsed.as_secs_f64())
     }
 
@@ -1008,14 +1008,14 @@ impl Metrics {
         };
         Self::get()
             .solve
-            .with_label_values(&[&driver.name, label])
+            .with_label_values(&[driver.name.as_str(), label])
             .observe(elapsed.as_secs_f64())
     }
 
     fn solution_ok(driver: &infra::Driver) {
         Self::get()
             .solutions
-            .with_label_values(&[&driver.name, "success"])
+            .with_label_values(&[driver.name.as_str(), "success"])
             .inc();
     }
 
@@ -1027,14 +1027,14 @@ impl Metrics {
         };
         Self::get()
             .solutions
-            .with_label_values(&[&driver.name, label])
+            .with_label_values(&[driver.name.as_str(), label])
             .inc();
     }
 
     fn settle_ok(driver: &infra::Driver, settled_order_count: usize, elapsed: Duration) {
         Self::get()
             .settle
-            .with_label_values(&[&driver.name, "success"])
+            .with_label_values(&[driver.name.as_str(), "success"])
             .observe(elapsed.as_secs_f64());
         Self::get()
             .settled
@@ -1049,7 +1049,7 @@ impl Metrics {
         };
         Self::get()
             .settle
-            .with_label_values(&[&driver.name, label])
+            .with_label_values(&[driver.name.as_str(), label])
             .observe(elapsed.as_secs_f64());
     }
 
diff --git a/crates/autopilot/src/shadow.rs b/crates/autopilot/src/shadow.rs
index 02e5de879f..de6072f4ef 100644
--- a/crates/autopilot/src/shadow.rs
+++ b/crates/autopilot/src/shadow.rs
@@ -205,14 +205,14 @@ impl RunLoop {
             Ok(response) => {
                 Metrics::get()
                     .results
-                    .with_label_values(&[&driver.name, "ok"])
+                    .with_label_values(&[driver.name.as_str(), "ok"])
                     .inc();
                 response.into_domain()
             }
             Err(err) => {
                 Metrics::get()
                     .results
-                    .with_label_values(&[&driver.name, "error"])
+                    .with_label_values(&[driver.name.as_str(), "error"])
                     .inc();
                 tracing::debug!(driver = driver.name, %err, "failed to fetch solutions");
                 return vec![];
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 8ee025539e..0e6524832a 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -392,7 +392,7 @@ pub fn mempool_executed(
     };
     metrics::get()
         .mempool_submission
-        .with_label_values(&[&mempool.to_string(), result])
+        .with_label_values(&[mempool.to_string().as_str(), result])
         .inc();
 
     // For some of the errors we are interested in observing the exact block numbers
@@ -425,7 +425,7 @@ pub fn mempool_executed(
         let blocks_passed = end.saturating_sub(*start);
         metrics::get()
             .mempool_submission_results_blocks_passed
-            .with_label_values(&[&mempool.to_string(), label])
+            .with_label_values(&[mempool.to_string().as_str(), label])
             .inc_by(blocks_passed);
     }
 }
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 3b3ae455ad..6ef5966e02 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -119,7 +119,7 @@ async fn with_matched_path_metric(req: Request<axum::body::Body>, next: Next) ->
     // Track completed requests
     metrics
         .requests_complete
-        .with_label_values(&[&method_with_path, status.as_str()])
+        .with_label_values(&[method_with_path.as_str(), status.as_str()])
         .inc();
 
     // Track rejected requests (4xx and 5xx status codes)
@@ -355,7 +355,7 @@ impl ApiMetrics {
         let method_with_path = format!("{method} {path}");
         for status in Self::INITIAL_STATUSES {
             self.requests_complete
-                .with_label_values(&[&method_with_path, status.as_str()])
+                .with_label_values(&[method_with_path.as_str(), status.as_str()])
                 .reset();
         }
     }
diff --git a/crates/shared/src/price_estimation/competition/mod.rs b/crates/shared/src/price_estimation/competition/mod.rs
index 90361dd153..a8e4d1f32c 100644
--- a/crates/shared/src/price_estimation/competition/mod.rs
+++ b/crates/shared/src/price_estimation/competition/mod.rs
@@ -159,7 +159,7 @@ impl<T: Send + Sync + 'static> CompetitionEstimator<T> {
         if result.is_ok() {
             metrics()
                 .queries_won
-                .with_label_values(&[name, kind.label()])
+                .with_label_values(&[name.as_str(), kind.label()])
                 .inc();
         }
         result
diff --git a/crates/shared/src/request_sharing.rs b/crates/shared/src/request_sharing.rs
index 461a618d77..54d618fd52 100644
--- a/crates/shared/src/request_sharing.rs
+++ b/crates/shared/src/request_sharing.rs
@@ -111,14 +111,14 @@ where
         if let Some(existing) = existing {
             Metrics::get()
                 .request_sharing_access
-                .with_label_values(&[&self.request_label, "hits"])
+                .with_label_values(&[self.request_label.as_str(), "hits"])
                 .inc();
             return existing;
         }
 
         Metrics::get()
             .request_sharing_access
-            .with_label_values(&[&self.request_label, "misses"])
+            .with_label_values(&[self.request_label.as_str(), "misses"])
             .inc();
 
         let shared = future(&request).shared();
diff --git a/crates/shared/src/tenderly_api.rs b/crates/shared/src/tenderly_api.rs
index d7b9cecfcb..c32c5988c1 100644
--- a/crates/shared/src/tenderly_api.rs
+++ b/crates/shared/src/tenderly_api.rs
@@ -145,7 +145,7 @@ impl TenderlyApi for Instrumented {
         Metrics::get()
             .tenderly_simulations
             .with_label_values(&[
-                &self.name,
+                self.name.as_str(),
                 match &result {
                     Ok(_) => "ok",
                     Err(_) => "err",

From a5111a1a846b9875b79e1ab2c644d1f0b7a3a0bb Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Mon, 23 Feb 2026 11:56:07 +0100
Subject: [PATCH 095/219] Fix order of tokens to improve caching (#4197)

# Description

When investigating CoinGecko usage I noticed our nginx cache is not
being optimally used, it is in fact used very little. The cache can only
trigger when the URL is the same. There are two issues: the batches have
different compositions and the tokens are not in deterministic order.
This PR fixes the second problem.
---
 .../shared/src/price_estimation/native/coingecko.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/crates/shared/src/price_estimation/native/coingecko.rs b/crates/shared/src/price_estimation/native/coingecko.rs
index 4824d7e2ee..24672f0465 100644
--- a/crates/shared/src/price_estimation/native/coingecko.rs
+++ b/crates/shared/src/price_estimation/native/coingecko.rs
@@ -105,15 +105,12 @@ impl CoinGecko {
     ) -> Result<HashMap<Token, f64>, PriceEstimationError> {
         let mut url = crate::url::join(&self.base_url, &self.chain);
         metrics::batch_size(tokens.len());
+        // Sort to make the token order deterministic for better caching on CoinGecko
+        // egress proxy which needs the URL to be the same for cache to be hit
+        let mut sorted_tokens: Vec<_> = tokens.iter().map(|token| format!("{token:#x}")).collect();
+        sorted_tokens.sort();
         url.query_pairs_mut()
-            .append_pair(
-                "contract_addresses",
-                &tokens
-                    .iter()
-                    .map(|token| format!("{token:#x}"))
-                    .collect::<Vec<_>>()
-                    .join(","),
-            )
+            .append_pair("contract_addresses", &sorted_tokens.join(","))
             .append_pair("vs_currencies", "eth")
             .append_pair("precision", "full");
 

From d178974902008199e1e85e2c38141f0ab2d4c81a Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 23 Feb 2026 12:09:07 +0100
Subject: [PATCH 096/219] Bulk insert order events query (#4184)

# Description
Because the insert order_events query tries to avoid duplicating the
last event entry it's quite awkward. That's probably why we didn't
replace it with a bulk request earlier. However, flamegraphs showed that
we spend a ridiculous 49% of our CPU time on inserting orders.

# Changes
Implemented awkward bulk insert query

## How to test
single insert variant was already tested before
1 new unit test for multi insert variant

Reduced CPU usage: **0.55 cores -> 0.2 cores**
<img width="763" height="211" alt="Screenshot 2026-02-19 at 20 28 27"
src="https://github.com/user-attachments/assets/f25e8c66-5480-4b21-a4c2-d4a1fdf654b7"
/>

Faster at handling other CPU bound work
<img width="626" height="298" alt="Screenshot 2026-02-19 at 20 28 55"
src="https://github.com/user-attachments/assets/e27730ca-31cc-4579-832b-d9ccaf2fe140"
/>

Total time spent on that query: **49% -> 3%**
<img width="1920" height="767" alt="Screenshot 2026-02-19 at 20 30 08"
src="https://github.com/user-attachments/assets/28b262ae-dd93-4a30-8122-d28543b7ac71"
/>
<img width="1920" height="636" alt="Screenshot 2026-02-19 at 20 30 17"
src="https://github.com/user-attachments/assets/81a5894f-b2a5-43a7-83c0-33e38b28923a"
/>
---
 crates/autopilot/src/database/order_events.rs |  18 +--
 crates/database/src/order_events.rs           | 117 +++++++++++++++---
 2 files changed, 102 insertions(+), 33 deletions(-)

diff --git a/crates/autopilot/src/database/order_events.rs b/crates/autopilot/src/database/order_events.rs
index 4a32c05f25..79523a6585 100644
--- a/crates/autopilot/src/database/order_events.rs
+++ b/crates/autopilot/src/database/order_events.rs
@@ -3,10 +3,7 @@ use {
     crate::domain,
     anyhow::Result,
     chrono::{DateTime, Utc},
-    database::{
-        byte_array::ByteArray,
-        order_events::{self, OrderEvent},
-    },
+    database::{byte_array::ByteArray, order_events},
     sqlx::{Acquire, Error, PgConnection},
     tokio::time::Instant,
 };
@@ -25,21 +22,14 @@ pub async fn store_order_events(
     timestamp: DateTime<Utc>,
 ) {
     let start = Instant::now();
+    let order_uids: Vec<_> = order_uids.into_iter().map(|o| ByteArray(o.0)).collect();
     let count = order_uids.len();
 
     let insert = async move {
         let mut ex = ex.begin().await?;
-
-        for uid in order_uids {
-            let event = OrderEvent {
-                order_uid: ByteArray(uid.0),
-                timestamp,
-                label,
-            };
-
-            order_events::insert_order_event(&mut ex, &event).await?;
+        for chunk in order_uids.chunks(1000) {
+            order_events::insert_order_events(&mut ex, chunk, timestamp, label).await?;
         }
-
         ex.commit().await
     };
 
diff --git a/crates/database/src/order_events.rs b/crates/database/src/order_events.rs
index e4656ebb1c..ebcd658fc2 100644
--- a/crates/database/src/order_events.rs
+++ b/crates/database/src/order_events.rs
@@ -51,30 +51,41 @@ pub struct OrderEvent {
 pub async fn insert_order_event(
     ex: &mut PgConnection,
     event: &OrderEvent,
+) -> Result<(), sqlx::Error> {
+    insert_order_events(ex, &[event.order_uid], event.timestamp, event.label).await
+}
+
+pub async fn insert_order_events(
+    ex: &mut PgConnection,
+    orders: &[OrderUid],
+    timestamp: DateTime<Utc>,
+    label: OrderEventLabel,
 ) -> Result<(), sqlx::Error> {
     const QUERY: &str = r#"
-        WITH cte AS (
-            SELECT label
-            FROM order_events
-            WHERE order_uid = $1
-            ORDER BY timestamp DESC
-            LIMIT 1
-        )
-        INSERT INTO order_events (order_uid, timestamp, label)
-        SELECT $1, $2, $3
-        WHERE NOT EXISTS (
-            SELECT 1
-            FROM cte
-            WHERE label = $3
-        )
+    WITH latest_events AS (
+        SELECT DISTINCT ON (order_uid) order_uid, label
+        FROM order_events
+        WHERE order_uid = ANY($1)
+        ORDER BY order_uid, timestamp DESC
+    ),
+    incoming AS (
+        SELECT t.order_uid, $2 AS timestamp, $3 AS label
+        FROM unnest($1) AS t(order_uid)
+    )
+    INSERT INTO order_events (order_uid, timestamp, label)
+    SELECT DISTINCT i.order_uid, i.timestamp, i.label
+    FROM incoming i
+    LEFT JOIN latest_events le ON le.order_uid = i.order_uid
+    WHERE le.label IS DISTINCT FROM i.label
     "#;
+
     sqlx::query(QUERY)
-        .bind(event.order_uid)
-        .bind(event.timestamp)
-        .bind(event.label)
+        .bind(orders)
+        .bind(timestamp)
+        .bind(label)
         .execute(ex)
-        .await
-        .map(|_| ())
+        .await?;
+    Ok(())
 }
 
 /// Deletes rows before the provided timestamp from the `order_events` table.
@@ -115,6 +126,7 @@ mod tests {
             byte_array::ByteArray,
             order_events::{OrderEvent, OrderEventLabel},
         },
+        chrono::TimeZone,
         sqlx::Connection,
     };
 
@@ -186,4 +198,71 @@ mod tests {
             .await
             .unwrap()
     }
+
+    #[tokio::test]
+    #[ignore]
+    async fn postgres_multi_insert() {
+        let mut db = PgConnection::connect("postgresql://").await.unwrap();
+        let mut ex = db.begin().await.unwrap();
+        crate::clear_DANGER_(&mut ex).await.unwrap();
+
+        let early = Utc.with_ymd_and_hms(2026, 2, 19, 0, 0, 0).unwrap();
+        let uid_a = ByteArray([1; 56]);
+        let uid_b = ByteArray([2; 56]);
+        let event_a = OrderEvent {
+            order_uid: uid_a,
+            timestamp: early,
+            label: OrderEventLabel::Created,
+        };
+        insert_order_event(&mut ex, &event_a).await.unwrap();
+        let event_b = OrderEvent {
+            order_uid: uid_b,
+            timestamp: early,
+            label: OrderEventLabel::Invalid,
+        };
+        insert_order_event(&mut ex, &event_b).await.unwrap();
+
+        let later = Utc.with_ymd_and_hms(2027, 2, 19, 0, 0, 0).unwrap();
+        insert_order_events(&mut ex, &[uid_a, uid_b], later, OrderEventLabel::Invalid)
+            .await
+            .unwrap();
+
+        let a = get_latest(&mut ex, &uid_a).await.unwrap();
+        assert_eq!(
+            a,
+            Some(OrderEvent {
+                order_uid: uid_a,
+                // new latest event was added
+                timestamp: later,
+                label: OrderEventLabel::Invalid,
+            })
+        );
+
+        let b = get_latest(&mut ex, &uid_b).await.unwrap();
+        assert_eq!(
+            b,
+            Some(OrderEvent {
+                order_uid: uid_b,
+                // since the latest event was already `Invalid`
+                // no new entry was created
+                timestamp: early,
+                label: OrderEventLabel::Invalid
+            })
+        );
+    }
+
+    #[tokio::test]
+    #[ignore]
+    async fn postgres_avoid_duplicate_uids() {
+        let mut db = PgConnection::connect("postgresql://").await.unwrap();
+        let mut ex = db.begin().await.unwrap();
+        crate::clear_DANGER_(&mut ex).await.unwrap();
+        let uid = ByteArray([1; 56]);
+        insert_order_events(&mut ex, &[uid, uid], Utc::now(), OrderEventLabel::Invalid)
+            .await
+            .unwrap();
+        let events = all_order_events(&mut ex).await;
+        // query didn't insert 2 identical events for the same uid
+        assert_eq!(events.len(), 1);
+    }
 }

From 8154b9d19ea69be318441facd871729f0234ef98 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 23 Feb 2026 12:10:52 +0100
Subject: [PATCH 097/219] Avoid unnecessary overhead from logging (#4191)

# Description
To my surprise do `tracing` macros not lazily evaluate expressions. So
in following code:
```rust
        tracing::trace!(
            path = &url.path(),
            body = %payload.body_to_string(),
            "solver request",
        );
```
`payload.body_to_string()` always gets evaluated but the `Display`
implementation of the resulting `String` gets called only when the log
is enabled.
This leads to the autopilot currently spending ~2% of the time in
`body_to_string()`.

To address this I introduced the `Lazy` type that delays the execution
of the passed in expression to when the `tracing` machinery actually
executed the `Display` or `Debug` functionality.

Additionally flamegraphs showed that the driver is currently burning
2.2% of its CPU time on logging auction deadlines. I downgraded that log
to `trace` since it's not really that useful.

# Changes
used `Lazy` in the autopilot
downgraded expensive log to `trace`

# Test
Manually tested that `body_to_string()` does not get called by injecting
a `panic!()` without causing tests to fail
added unit tests for `Lazy` in `observe` crate
---
 crates/autopilot/src/infra/solvers/mod.rs |  4 +-
 crates/driver/src/infra/observe/mod.rs    |  2 +-
 crates/observe/src/tracing.rs             | 54 +++++++++++++++++++++++
 3 files changed, 57 insertions(+), 3 deletions(-)

diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index c65155341f..e0835f6459 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -3,7 +3,7 @@ use {
     crate::{config::solver::Account, domain::eth, util},
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
-    observe::tracing::tracing_headers,
+    observe::tracing::{Lazy, tracing_headers},
     reqwest::{Client, RequestBuilder, StatusCode},
     std::{borrow::Cow, time::Duration},
     thiserror::Error,
@@ -120,7 +120,7 @@ impl Driver {
 
         tracing::trace!(
             path = &url.path(),
-            body = %payload.body_to_string(),
+            body = %Lazy(|| payload.body_to_string()),
             "solver request",
         );
 
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 0e6524832a..b743a9a3d6 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -455,7 +455,7 @@ fn competition_error(err: &competition::Error) -> &'static str {
 }
 
 pub fn deadline(deadline: &Deadline, timeouts: &Timeouts) {
-    tracing::debug!(?deadline, ?timeouts, "computed deadline");
+    tracing::trace!(?deadline, ?timeouts, "computed deadline");
 }
 
 pub fn sending_solve_request(solver: &str, remaining_time: Duration, is_quote_request: bool) {
diff --git a/crates/observe/src/tracing.rs b/crates/observe/src/tracing.rs
index 7b827424aa..4ff46c3ca7 100644
--- a/crates/observe/src/tracing.rs
+++ b/crates/observe/src/tracing.rs
@@ -237,3 +237,57 @@ pub fn tracing_headers() -> HeaderMap {
 
     headers
 }
+
+/// Helper struct to lazily evaluate an expression if a log is actually active.
+/// Sometimes you need to compute a value for logs. This expression gets
+/// evaluated eagerly in the `tracing` log macros. In order to only evaluate the
+/// expression when the log is actually enabled wrap the expression in a closure
+/// and wrap that in a [`Lazy`].
+pub struct Lazy<T>(pub T);
+
+impl<T, D> std::fmt::Debug for Lazy<T>
+where
+    T: Fn() -> D,
+    D: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", (self.0)())
+    }
+}
+
+impl<T, D> std::fmt::Display for Lazy<T>
+where
+    T: Fn() -> D,
+    D: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", (self.0)())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lazy_eval() {
+        let lazy = Lazy(|| "abc".to_string());
+
+        let display = format!("{}", lazy);
+        assert_eq!(display, "abc");
+
+        let debug = format!("{:?}", lazy);
+        assert_eq!(debug, "\"abc\"");
+    }
+
+    #[test]
+    fn lazy_in_macro() {
+        tracing::debug!(
+            miep = ?Lazy(|| {
+                panic!("this panic should not happen because we evaluate lazily");
+                #[expect(unreachable_code)]
+                "abc"
+            })
+        )
+    }
+}

From 3ec82fc90a599958b08412b1c9538cfa3b0be90f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 23 Feb 2026 12:14:24 +0000
Subject: [PATCH 098/219] Migrate banned users, order events cleanup, and S3
 config to config file (#4192)

# Description
Move banned_users, order_events_cleanup_interval/threshold, and S3
upload settings from CLI arguments to the TOML config file.

# Changes

- Add config modules: banned_users, order_events_cleanup, s3
- Remove infra::persistence::cli (S3 CLI args)
- Delete corresponding CLI arguments and Display impl entries
- Wire config values through run.rs

## How to test
Staging

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 crates/autopilot/src/arguments.rs             | 43 +------------
 crates/autopilot/src/config/banned_users.rs   | 58 ++++++++++++++++++
 crates/autopilot/src/config/mod.rs            | 61 +++++++++++++++++++
 .../src/config/order_events_cleanup.rs        | 59 ++++++++++++++++++
 crates/autopilot/src/config/s3.rs             | 56 +++++++++++++++++
 crates/autopilot/src/infra/persistence/cli.rs | 40 ------------
 crates/autopilot/src/infra/persistence/mod.rs |  1 -
 crates/autopilot/src/run.rs                   | 10 +--
 8 files changed, 240 insertions(+), 88 deletions(-)
 create mode 100644 crates/autopilot/src/config/banned_users.rs
 create mode 100644 crates/autopilot/src/config/order_events_cleanup.rs
 create mode 100644 crates/autopilot/src/config/s3.rs
 delete mode 100644 crates/autopilot/src/infra/persistence/cli.rs

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 546f3bb897..223239c730 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -1,5 +1,5 @@
 use {
-    crate::{database::INSERT_BATCH_SIZE_DEFAULT, infra},
+    crate::database::INSERT_BATCH_SIZE_DEFAULT,
     alloy::primitives::Address,
     anyhow::Context,
     shared::{
@@ -97,14 +97,6 @@ pub struct CliArguments {
     )]
     pub min_order_validity_period: Duration,
 
-    /// List of account addresses to be denied from order creation
-    #[clap(long, env, use_value_delimiter = true)]
-    pub banned_users: Vec<Address>,
-
-    /// Maximum number of entries to keep in the banned users cache.
-    #[clap(long, env, default_value = "10000")]
-    pub banned_users_max_cache_size: NonZeroUsize,
-
     /// If the auction hasn't been updated in this amount of time the pod fails
     /// the liveness check. Expects a value in seconds.
     #[clap(
@@ -151,20 +143,6 @@ pub struct CliArguments {
     )]
     pub solve_deadline: Duration,
 
-    /// Arguments for uploading information to S3.
-    #[clap(flatten)]
-    pub s3: infra::persistence::cli::S3,
-
-    /// Time interval in days between each cleanup operation of the
-    /// `order_events` database table.
-    #[clap(long, env, default_value = "1d", value_parser = humantime::parse_duration)]
-    pub order_events_cleanup_interval: Duration,
-
-    /// Age threshold in days for order events to be eligible for cleanup in the
-    /// `order_events` database table.
-    #[clap(long, env, default_value = "30d", value_parser = humantime::parse_duration)]
-    pub order_events_cleanup_threshold: Duration,
-
     /// Configurations for indexing CoW AMMs. Supplied in the form of:
     /// "<factory1>|<helper1>|<block1>,<factory2>|<helper2>,<block2>"
     /// - factory is contract address emmiting CoW AMM deployment events.
@@ -257,19 +235,14 @@ impl std::fmt::Display for CliArguments {
             native_price_estimators,
             api_native_price_estimators,
             min_order_validity_period,
-            banned_users,
-            banned_users_max_cache_size,
             max_auction_age,
             submission_deadline,
             shadow,
             solve_deadline,
-            order_events_cleanup_interval,
-            order_events_cleanup_threshold,
             db_write_url,
             insert_batch_size,
             native_price_estimation_results_required,
             max_settlement_transaction_wait,
-            s3,
             cow_amm_configs,
             max_run_loop_delay,
             run_loop_native_price_timeout,
@@ -305,23 +278,10 @@ impl std::fmt::Display for CliArguments {
             f,
             "min_order_validity_period: {min_order_validity_period:?}"
         )?;
-        writeln!(f, "banned_users: {banned_users:?}")?;
-        writeln!(
-            f,
-            "banned_users_max_cache_size: {banned_users_max_cache_size:?}"
-        )?;
         writeln!(f, "max_auction_age: {max_auction_age:?}")?;
         writeln!(f, "submission_deadline: {submission_deadline}")?;
         display_option(f, "shadow", shadow)?;
         writeln!(f, "solve_deadline: {solve_deadline:?}")?;
-        writeln!(
-            f,
-            "order_events_cleanup_interval: {order_events_cleanup_interval:?}"
-        )?;
-        writeln!(
-            f,
-            "order_events_cleanup_threshold: {order_events_cleanup_threshold:?}"
-        )?;
         writeln!(f, "insert_batch_size: {insert_batch_size}")?;
         writeln!(
             f,
@@ -331,7 +291,6 @@ impl std::fmt::Display for CliArguments {
             f,
             "max_settlement_transaction_wait: {max_settlement_transaction_wait:?}"
         )?;
-        writeln!(f, "s3: {s3:?}")?;
         writeln!(f, "cow_amm_configs: {cow_amm_configs:?}")?;
         writeln!(f, "max_run_loop_delay: {max_run_loop_delay:?}")?;
         writeln!(
diff --git a/crates/autopilot/src/config/banned_users.rs b/crates/autopilot/src/config/banned_users.rs
new file mode 100644
index 0000000000..7a2ef3fc6e
--- /dev/null
+++ b/crates/autopilot/src/config/banned_users.rs
@@ -0,0 +1,58 @@
+use {
+    alloy::primitives::Address,
+    serde::{Deserialize, Serialize},
+    std::num::NonZeroUsize,
+};
+
+fn default_max_cache_size() -> NonZeroUsize {
+    NonZeroUsize::new(10000).unwrap()
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct BannedUsersConfig {
+    /// List of account addresses to be denied from order creation.
+    #[serde(default)]
+    pub addresses: Vec<Address>,
+
+    /// Maximum number of entries to keep in the banned users cache.
+    #[serde(default = "default_max_cache_size")]
+    pub max_cache_size: NonZeroUsize,
+}
+
+impl Default for BannedUsersConfig {
+    fn default() -> Self {
+        Self {
+            addresses: Vec::new(),
+            max_cache_size: default_max_cache_size(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, alloy::primitives::address};
+
+    #[test]
+    fn deserialize_defaults() {
+        let toml = "";
+        let config: BannedUsersConfig = toml::from_str(toml).unwrap();
+        assert!(config.addresses.is_empty());
+        assert_eq!(config.max_cache_size.get(), 10000);
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        addresses = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        max-cache-size = 5000
+        "#;
+        let config: BannedUsersConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.addresses.len(), 1);
+        assert_eq!(
+            config.addresses[0],
+            address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")
+        );
+        assert_eq!(config.max_cache_size.get(), 5000);
+    }
+}
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index 629e655a19..0cee73ffff 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -1,6 +1,9 @@
 use {
     crate::config::{
+        banned_users::BannedUsersConfig,
         fee_policy::FeePoliciesConfig,
+        order_events_cleanup::OrderEventsCleanupConfig,
+        s3::S3Config,
         solver::Solver,
         trusted_tokens::TrustedTokensConfig,
     },
@@ -9,7 +12,10 @@ use {
     std::path::Path,
 };
 
+pub mod banned_users;
 pub mod fee_policy;
+pub mod order_events_cleanup;
+pub mod s3;
 pub mod solver;
 pub mod trusted_tokens;
 
@@ -27,6 +33,19 @@ pub struct Configuration {
     /// to internalize.
     #[serde(default)]
     pub trusted_tokens: TrustedTokensConfig,
+
+    /// Configuration for periodic cleanup of order events.
+    #[serde(default)]
+    pub order_events_cleanup: OrderEventsCleanupConfig,
+
+    /// Configuration for order validation rules.
+    #[serde(default)]
+    pub banned_users: BannedUsersConfig,
+
+    /// Configuration for uploading auction instances to S3.
+    /// If absent, S3 uploads are disabled.
+    #[serde(default)]
+    pub s3: Option<S3Config>,
 }
 
 impl Configuration {
@@ -138,6 +157,18 @@ mod tests {
         url = "https://example.com/tokens.json"
         tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
         update-interval = "30m"
+
+        [order-events-cleanup]
+        cleanup-interval = "12h"
+        cleanup-threshold = "7d"
+
+        [banned-users]
+        addresses = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        max-cache-size = 5000
+
+        [s3]
+        bucket = "my-bucket"
+        filename-prefix = "staging/mainnet/"
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -184,6 +215,22 @@ mod tests {
             config.trusted_tokens.update_interval,
             Duration::from_secs(1800)
         );
+
+        assert_eq!(
+            config.order_events_cleanup.cleanup_interval,
+            Duration::from_secs(43200)
+        );
+        assert_eq!(
+            config.order_events_cleanup.cleanup_threshold,
+            Duration::from_secs(604800)
+        );
+
+        assert_eq!(config.banned_users.addresses.len(), 1);
+        assert_eq!(config.banned_users.max_cache_size.get(), 5000);
+
+        let s3 = config.s3.unwrap();
+        assert_eq!(s3.bucket, "my-bucket");
+        assert_eq!(s3.filename_prefix, "staging/mainnet/");
     }
 
     #[test]
@@ -217,6 +264,20 @@ mod tests {
             config.trusted_tokens.update_interval,
             Duration::from_secs(3600)
         );
+
+        assert_eq!(
+            config.order_events_cleanup.cleanup_interval,
+            Duration::from_secs(86400)
+        );
+        assert_eq!(
+            config.order_events_cleanup.cleanup_threshold,
+            Duration::from_secs(2592000)
+        );
+
+        assert!(config.banned_users.addresses.is_empty());
+        assert_eq!(config.banned_users.max_cache_size.get(), 10000);
+
+        assert!(config.s3.is_none());
     }
 
     #[test]
diff --git a/crates/autopilot/src/config/order_events_cleanup.rs b/crates/autopilot/src/config/order_events_cleanup.rs
new file mode 100644
index 0000000000..5b21ccbf91
--- /dev/null
+++ b/crates/autopilot/src/config/order_events_cleanup.rs
@@ -0,0 +1,59 @@
+use {
+    serde::{Deserialize, Serialize},
+    std::time::Duration,
+};
+
+fn default_cleanup_interval() -> Duration {
+    Duration::from_secs(86400) // 1d
+}
+
+fn default_cleanup_threshold() -> Duration {
+    Duration::from_secs(2592000) // 30d
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct OrderEventsCleanupConfig {
+    /// Time interval between each cleanup operation of the `order_events`
+    /// database table.
+    #[serde(with = "humantime_serde", default = "default_cleanup_interval")]
+    pub cleanup_interval: Duration,
+
+    /// Age threshold for order events to be eligible for cleanup in the
+    /// `order_events` database table.
+    #[serde(with = "humantime_serde", default = "default_cleanup_threshold")]
+    pub cleanup_threshold: Duration,
+}
+
+impl Default for OrderEventsCleanupConfig {
+    fn default() -> Self {
+        Self {
+            cleanup_interval: default_cleanup_interval(),
+            cleanup_threshold: default_cleanup_threshold(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let toml = "";
+        let config: OrderEventsCleanupConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.cleanup_interval, Duration::from_secs(86400));
+        assert_eq!(config.cleanup_threshold, Duration::from_secs(2592000));
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        cleanup-interval = "12h"
+        cleanup-threshold = "7d"
+        "#;
+        let config: OrderEventsCleanupConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.cleanup_interval, Duration::from_secs(43200));
+        assert_eq!(config.cleanup_threshold, Duration::from_secs(604800));
+    }
+}
diff --git a/crates/autopilot/src/config/s3.rs b/crates/autopilot/src/config/s3.rs
new file mode 100644
index 0000000000..f6b5329a95
--- /dev/null
+++ b/crates/autopilot/src/config/s3.rs
@@ -0,0 +1,56 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct S3Config {
+    /// The S3 bucket where auction instances should be uploaded.
+    pub bucket: String,
+
+    /// Prepended to the auction id to form the final instance filename on S3.
+    /// Something like "staging/mainnet/"
+    pub filename_prefix: String,
+}
+
+impl From<S3Config> for s3::Config {
+    fn from(config: S3Config) -> Self {
+        Self {
+            bucket: config.bucket,
+            filename_prefix: config.filename_prefix,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        bucket = "my-bucket"
+        filename-prefix = "staging/mainnet/"
+        "#;
+        let config: S3Config = toml::from_str(toml).unwrap();
+        assert_eq!(config.bucket, "my-bucket");
+        assert_eq!(config.filename_prefix, "staging/mainnet/");
+    }
+
+    #[test]
+    fn missing_field_fails() {
+        let toml = r#"
+        bucket = "my-bucket"
+        "#;
+        assert!(toml::from_str::<S3Config>(toml).is_err());
+    }
+
+    #[test]
+    fn into_s3_config() {
+        let config = S3Config {
+            bucket: "my-bucket".to_string(),
+            filename_prefix: "prefix/".to_string(),
+        };
+        let s3_config: s3::Config = config.into();
+        assert_eq!(s3_config.bucket, "my-bucket");
+        assert_eq!(s3_config.filename_prefix, "prefix/");
+    }
+}
diff --git a/crates/autopilot/src/infra/persistence/cli.rs b/crates/autopilot/src/infra/persistence/cli.rs
deleted file mode 100644
index 7365743b14..0000000000
--- a/crates/autopilot/src/infra/persistence/cli.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! Command line arguments for persistence.
-
-use anyhow::Result;
-
-#[derive(clap::Parser, Debug, Clone)]
-pub struct S3 {
-    #[clap(long, env)]
-    /// The s3_instance_upload_* arguments configure how auction instances
-    /// should be uploaded to AWS S3.
-    /// They must either all be set or all not set.
-    pub s3_instance_upload_bucket: Option<String>,
-
-    /// Prepended to the auction id to form the final instance filename on S3.
-    /// Something like "staging/mainnet/"
-    #[clap(long, env)]
-    pub s3_instance_upload_filename_prefix: Option<String>,
-}
-
-impl S3 {
-    pub fn into(self) -> Result<Option<s3::Config>> {
-        let s3_args = &[
-            &self.s3_instance_upload_bucket,
-            &self.s3_instance_upload_filename_prefix,
-        ];
-        let all_some = s3_args.iter().all(|arg| arg.is_some());
-        let all_none = s3_args.iter().all(|arg| arg.is_none());
-        anyhow::ensure!(
-            all_some || all_none,
-            "either set all s3_instance_upload bucket arguments or none"
-        );
-        Ok(if all_some {
-            Some(s3::Config {
-                bucket: self.s3_instance_upload_bucket.unwrap(),
-                filename_prefix: self.s3_instance_upload_filename_prefix.unwrap(),
-            })
-        } else {
-            None
-        })
-    }
-}
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index a57c6c6443..90d98bb005 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -41,7 +41,6 @@ use {
     tracing::{Instrument, instrument},
 };
 
-pub mod cli;
 pub mod dto;
 
 #[derive(Clone)]
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index bd1c2a5a1b..76924af230 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -373,7 +373,7 @@ pub async fn run(
     };
 
     let persistence =
-        infra::persistence::Persistence::new(args.s3.into().unwrap(), Arc::new(db_write.clone()))
+        infra::persistence::Persistence::new(config.s3.map(Into::into), Arc::new(db_write.clone()))
             .instrument(info_span!("persistence_init"))
             .await;
     let settlement_contract_start_index = match GPv2Settlement::deployment_block(&chain_id) {
@@ -451,8 +451,8 @@ pub async fn run(
         persistence.clone(),
         infra::banned::Users::new(
             eth.contracts().chainalysis_oracle().clone(),
-            args.banned_users,
-            args.banned_users_max_cache_size.get().to_u64().unwrap(),
+            config.banned_users.addresses,
+            config.banned_users.max_cache_size.get().to_u64().unwrap(),
         ),
         balance_fetcher.clone(),
         deny_listed_tokens.clone(),
@@ -488,8 +488,8 @@ pub async fn run(
     );
 
     let order_events_cleaner_config = crate::periodic_db_cleanup::OrderEventsCleanerConfig::new(
-        args.order_events_cleanup_interval,
-        args.order_events_cleanup_threshold,
+        config.order_events_cleanup.cleanup_interval,
+        config.order_events_cleanup.cleanup_threshold,
     );
     let order_events_cleaner = crate::periodic_db_cleanup::OrderEventsCleaner::new(
         order_events_cleaner_config,

From 250f603222ea791b93edb887490509968dc1c1f2 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 23 Feb 2026 13:51:09 +0100
Subject: [PATCH 099/219] Serialize auction in blocking task (#4186)

# Description
The task that writes the current auction to the DB has 2 performance
issues:
* unnecessary conversions: instead of serializing the DTO to a JSON
string we convert it to `JsonValue` and let `sqlx` do the conversion to
string
* conversions on wrong task: serializing data is very slow and blocks an
entire runtime thread if we don't do the sync work in a blocking task
(the entire process often takes more than 1s)

# Changes
* skip 1 conversion by directly serializing the DTO to string and
writing a string to the DB (same pattern already applied by some other
JSON upload)
* serialize the DTO on a blocking task

## How to test
adjusted existing e2e tests, they show that the serialized data can be
read back into the exact JSON value we serialized in the first place
---
 crates/autopilot/src/database/auction.rs      |  9 +++++++--
 crates/autopilot/src/infra/persistence/mod.rs |  2 +-
 crates/database/src/auction.rs                | 16 +++++++++++-----
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/crates/autopilot/src/database/auction.rs b/crates/autopilot/src/database/auction.rs
index a1a2ea21df..f0c089195d 100644
--- a/crates/autopilot/src/database/auction.rs
+++ b/crates/autopilot/src/database/auction.rs
@@ -116,14 +116,19 @@ impl Postgres {
     pub async fn replace_current_auction(
         &self,
         new_auction_id: dto::AuctionId,
-        new_auction_data: &dto::RawAuctionData,
+        new_auction_data: dto::RawAuctionData,
     ) -> Result<()> {
         let _timer = super::Metrics::get()
             .database_queries
             .with_label_values(&["insert_auction_with_id"])
             .start_timer();
 
-        let data = serde_json::to_value(new_auction_data)?;
+        let data = tokio::task::spawn_blocking(move || {
+            serde_json::to_string(&new_auction_data).context("failed to serialize auction")
+        })
+        .await
+        .context("auction serialization task panicked")??;
+
         let mut ex = self.pool.acquire().await?;
         database::auction::insert_auction_with_id(&mut ex, new_auction_id, &data).await?;
         Ok(())
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index 90d98bb005..faba2186a3 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -80,7 +80,7 @@ impl Persistence {
         tokio::task::spawn(async move {
             while let Some(upload) = receiver.recv().await {
                 if let Err(err) = db
-                    .replace_current_auction(upload.auction_id, &upload.auction_data)
+                    .replace_current_auction(upload.auction_id, upload.auction_data)
                     .await
                 {
                     tracing::error!(?err, "failed to replace auction in DB");
diff --git a/crates/database/src/auction.rs b/crates/database/src/auction.rs
index 062836b93f..5659c97b05 100644
--- a/crates/database/src/auction.rs
+++ b/crates/database/src/auction.rs
@@ -29,17 +29,17 @@ pub async fn get_next_auction_id(ex: &mut PgConnection) -> Result<AuctionId, sql
 pub async fn insert_auction_with_id(
     ex: &mut PgConnection,
     id: AuctionId,
-    data: &JsonValue,
+    json: &str,
 ) -> Result<(), sqlx::Error> {
     const QUERY: &str = r#"
 WITH deleted AS (
     DELETE FROM auctions
 )
 INSERT INTO auctions (id, json)
-VALUES ($1, $2);
+VALUES ($1, $2::jsonb);
     "#;
 
-    sqlx::query(QUERY).bind(id).bind(data).execute(ex).await?;
+    sqlx::query(QUERY).bind(id).bind(json).execute(ex).await?;
     Ok(())
 }
 
@@ -105,7 +105,10 @@ mod tests {
 
         let value = JsonValue::Number(1.into());
         let id = get_next_auction_id(&mut db).await.unwrap();
-        insert_auction_with_id(&mut db, id, &value).await.unwrap();
+        let value_str = serde_json::to_string(&value).unwrap();
+        insert_auction_with_id(&mut db, id, &value_str)
+            .await
+            .unwrap();
         let (id_, value_) = load_most_recent(&mut db).await.unwrap().unwrap();
         assert_eq!(id, id_);
         assert_eq!(value, value_);
@@ -113,7 +116,10 @@ mod tests {
         let value = JsonValue::Number(2.into());
         let id_ = get_next_auction_id(&mut db).await.unwrap();
         assert_eq!(id + 1, id_);
-        insert_auction_with_id(&mut db, id_, &value).await.unwrap();
+        let value_str = serde_json::to_string(&value).unwrap();
+        insert_auction_with_id(&mut db, id_, &value_str)
+            .await
+            .unwrap();
         let (id, value_) = load_most_recent(&mut db).await.unwrap().unwrap();
         assert_eq!(value, value_);
         assert_eq!(id_, id);

From 14d102ee8ef62fcaf54efc81ca9fae7b024e77ff Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 23 Feb 2026 14:13:40 +0100
Subject: [PATCH 100/219] Restructure observe crate (#4196)

# Description
Follow up to this
[comment](https://github.com/cowprotocol/services/pull/4191#discussion_r2837775501)
suggesting a different structure for the `observe` crate. This PR goes a
bit further than the comment suggested but I think this setup makes the
most sense.

# Changes
old structure:
```
distributed_tracing
    - request_id.rs
    - trace_id_format.rs
    - tracing_axum.rs
lazy.rs
tracing.rs
tracing_reload_handler.rs
```

new structure:
```
tracing
    - distributed
        - axum.rs
        - headers.rs
        - request_id.rs
        - trace_id_format.rs
    - lazy.rs
    - init.rs
    - reload_handler.rs
```
---
 crates/autopilot/src/infra/api.rs             |   2 +-
 crates/autopilot/src/infra/solvers/mod.rs     |   4 +-
 crates/autopilot/src/run.rs                   |   2 +-
 crates/driver/src/infra/api/mod.rs            |   2 +-
 crates/driver/src/infra/observe/mod.rs        |   2 +-
 crates/driver/src/infra/solver/mod.rs         |   6 +-
 crates/driver/src/tests/setup/mod.rs          |   2 +-
 crates/e2e/src/setup/mod.rs                   |   2 +-
 crates/ethrpc/src/block_stream.rs             |   4 +-
 crates/observe/src/distributed_tracing/mod.rs |   3 -
 crates/observe/src/lib.rs                     |   5 +-
 crates/observe/src/panic_hook.rs              |   4 +-
 .../distributed/axum.rs}                      |   2 +-
 .../src/tracing/distributed/headers.rs        |  58 ++++++++
 crates/observe/src/tracing/distributed/mod.rs |   7 +
 .../distributed}/request_id.rs                |  29 +---
 .../distributed}/trace_id_format.rs           |   0
 .../src/{tracing.rs => tracing/init.rs}       | 124 ++----------------
 crates/observe/src/tracing/lazy.rs            |  53 ++++++++
 crates/observe/src/tracing/mod.rs             |   5 +
 .../reload_handler.rs}                        |   0
 crates/orderbook/src/api.rs                   |   4 +-
 crates/orderbook/src/ipfs.rs                  |   2 +-
 crates/orderbook/src/run.rs                   |   2 +-
 crates/refunder/src/lib.rs                    |   2 +-
 crates/shared/src/maintenance.rs              |   2 +-
 .../src/price_estimation/native/forwarder.rs  |   2 +-
 crates/shared/src/trade_finding/external.rs   |   4 +-
 crates/shared/src/zeroex_api.rs               |   4 +-
 crates/solvers/src/api/mod.rs                 |   2 +-
 crates/solvers/src/run.rs                     |   2 +-
 31 files changed, 169 insertions(+), 173 deletions(-)
 delete mode 100644 crates/observe/src/distributed_tracing/mod.rs
 rename crates/observe/src/{distributed_tracing/tracing_axum.rs => tracing/distributed/axum.rs} (93%)
 create mode 100644 crates/observe/src/tracing/distributed/headers.rs
 create mode 100644 crates/observe/src/tracing/distributed/mod.rs
 rename crates/observe/src/{distributed_tracing => tracing/distributed}/request_id.rs (87%)
 rename crates/observe/src/{distributed_tracing => tracing/distributed}/trace_id_format.rs (100%)
 rename crates/observe/src/{tracing.rs => tracing/init.rs} (66%)
 create mode 100644 crates/observe/src/tracing/lazy.rs
 create mode 100644 crates/observe/src/tracing/mod.rs
 rename crates/observe/src/{tracing_reload_handler.rs => tracing/reload_handler.rs} (100%)

diff --git a/crates/autopilot/src/infra/api.rs b/crates/autopilot/src/infra/api.rs
index 4d98afe86b..a0651eac99 100644
--- a/crates/autopilot/src/infra/api.rs
+++ b/crates/autopilot/src/infra/api.rs
@@ -8,7 +8,7 @@ use {
         routing::get,
     },
     model::quote::NativeTokenPrice,
-    observe::distributed_tracing::tracing_axum::{make_span, record_trace_id},
+    observe::tracing::distributed::axum::{make_span, record_trace_id},
     serde::Deserialize,
     shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     std::{
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index e0835f6459..361545e5e4 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -3,7 +3,7 @@ use {
     crate::{config::solver::Account, domain::eth, util},
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
-    observe::tracing::{Lazy, tracing_headers},
+    observe::tracing::{distributed::headers::tracing_headers, lazy::Lazy},
     reqwest::{Client, RequestBuilder, StatusCode},
     std::{borrow::Cow, time::Duration},
     thiserror::Error,
@@ -127,7 +127,7 @@ impl Driver {
         let request = self.client.post(url.clone()).headers(tracing_headers());
         let mut request = payload.inject(request);
 
-        if let Some(request_id) = observe::distributed_tracing::request_id::from_current_span() {
+        if let Some(request_id) = observe::tracing::distributed::request_id::from_current_span() {
             request = request.header("X-REQUEST-ID", request_id);
         }
 
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 76924af230..e019f4e87d 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -141,7 +141,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
         args.shared.logging.use_json_logs,
         tracing_config(&args.shared.tracing, "autopilot".into()),
     );
-    observe::tracing::initialize(&obs_config);
+    observe::tracing::init::initialize(&obs_config);
     observe::panic_hook::install();
     #[cfg(unix)]
     observe::heap_dump_handler::spawn_heap_dump_handler();
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index c594b472a0..c909704f9d 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -22,7 +22,7 @@ use {
     },
     error::Error,
     futures::Future,
-    observe::distributed_tracing::tracing_axum::{make_span, record_trace_id},
+    observe::tracing::distributed::axum::{make_span, record_trace_id},
     shared::account_balances,
     std::{net::SocketAddr, sync::Arc},
     tokio::sync::oneshot,
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index b743a9a3d6..ff2d315648 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -36,7 +36,7 @@ pub mod metrics;
 /// Setup the observability. The log argument configures the tokio tracing
 /// framework.
 pub fn init(obs_config: observe::Config) {
-    observe::tracing::initialize_reentrant(&obs_config);
+    observe::tracing::init::initialize_reentrant(&obs_config);
     metrics::init();
     #[cfg(unix)]
     observe::heap_dump_handler::spawn_heap_dump_handler();
diff --git a/crates/driver/src/infra/solver/mod.rs b/crates/driver/src/infra/solver/mod.rs
index 1294375479..93edc3165f 100644
--- a/crates/driver/src/infra/solver/mod.rs
+++ b/crates/driver/src/infra/solver/mod.rs
@@ -29,7 +29,7 @@ use {
     anyhow::Result,
     derive_more::{From, Into},
     num::BigRational,
-    observe::tracing::tracing_headers,
+    observe::tracing::distributed::headers::tracing_headers,
     reqwest::header::HeaderName,
     std::{
         collections::HashMap,
@@ -348,7 +348,7 @@ impl Solver {
             .body(body)
             .headers(tracing_headers())
             .timeout(timeout);
-        if let Some(id) = observe::distributed_tracing::request_id::from_current_span() {
+        if let Some(id) = observe::tracing::distributed::request_id::from_current_span() {
             req = req.header("X-REQUEST-ID", id);
         }
         super::observe::sending_solve_request(
@@ -443,7 +443,7 @@ impl Solver {
         let url = shared::url::join(&self.config.endpoint, "notify");
         super::observe::solver_request(&url, &body);
         let mut req = self.client.post(url).body(body).headers(tracing_headers());
-        if let Some(id) = observe::distributed_tracing::request_id::from_current_span() {
+        if let Some(id) = observe::tracing::distributed::request_id::from_current_span() {
             req = req.header("X-REQUEST-ID", id);
         }
         let response_size = self.config.response_size_limit_max_bytes;
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 9b0416a128..0be37f3482 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -883,7 +883,7 @@ impl Setup {
     /// Create the test: set up onchain contracts and pools, start a mock HTTP
     /// server for the solver and start the HTTP server for the driver.
     pub async fn done(self) -> Test {
-        observe::tracing::initialize_reentrant(
+        observe::tracing::init::initialize_reentrant(
             &observe::Config::default()
                 .with_env_filter("driver=trace,driver::tests::setup::blockchain=debug,warn"),
         );
diff --git a/crates/e2e/src/setup/mod.rs b/crates/e2e/src/setup/mod.rs
index ee3ec0100d..7fa2186162 100644
--- a/crates/e2e/src/setup/mod.rs
+++ b/crates/e2e/src/setup/mod.rs
@@ -189,7 +189,7 @@ async fn run<F, Fut, T>(
         false,
         None,
     );
-    observe::tracing::initialize_reentrant(&obs_config);
+    observe::tracing::init::initialize_reentrant(&obs_config);
     observe::panic_hook::install();
 
     services::ensure_e2e_readonly_user().await;
diff --git a/crates/ethrpc/src/block_stream.rs b/crates/ethrpc/src/block_stream.rs
index aba53cae3a..2e93c7ddf3 100644
--- a/crates/ethrpc/src/block_stream.rs
+++ b/crates/ethrpc/src/block_stream.rs
@@ -552,7 +552,9 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn mainnet() {
-        observe::tracing::initialize(&observe::Config::default().with_env_filter("shared=debug"));
+        observe::tracing::init::initialize(
+            &observe::Config::default().with_env_filter("shared=debug"),
+        );
 
         let alloy_provider = Web3::new_from_env();
         let ws_node = std::env::var("NODE_WS_URL").unwrap().parse().unwrap();
diff --git a/crates/observe/src/distributed_tracing/mod.rs b/crates/observe/src/distributed_tracing/mod.rs
deleted file mode 100644
index 6bb9302c14..0000000000
--- a/crates/observe/src/distributed_tracing/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod request_id;
-pub mod trace_id_format;
-pub mod tracing_axum;
diff --git a/crates/observe/src/lib.rs b/crates/observe/src/lib.rs
index e1993f79c0..ba9f85edf7 100644
--- a/crates/observe/src/lib.rs
+++ b/crates/observe/src/lib.rs
@@ -2,17 +2,14 @@
 //! improve the observability of a system. That includes initialization logic
 //! for metrics and logging as well as logging helper functions.
 pub mod config;
-pub mod distributed_tracing;
 pub mod future;
 #[cfg(unix)]
 pub mod heap_dump_handler;
 pub mod metrics;
 pub mod panic_hook;
 pub mod tracing;
-#[cfg(unix)]
-mod tracing_reload_handler;
 
 pub use {
+    crate::tracing::distributed::request_id,
     config::{Config, TracingConfig},
-    distributed_tracing::request_id,
 };
diff --git a/crates/observe/src/panic_hook.rs b/crates/observe/src/panic_hook.rs
index 1a592c2bd2..63f4d4bd53 100644
--- a/crates/observe/src/panic_hook.rs
+++ b/crates/observe/src/panic_hook.rs
@@ -38,7 +38,7 @@ mod tests {
     #[ignore]
     fn manual_thread() {
         let obs_config = Config::new("info", None, false, None);
-        crate::tracing::initialize(&obs_config);
+        crate::tracing::init::initialize(&obs_config);
 
         // Should print panic trace log but not kill the process.
         let handle = std::thread::spawn(|| panic!("you should see this message"));
@@ -57,7 +57,7 @@ mod tests {
     #[ignore]
     async fn manual_tokio() {
         let obs_config = Config::new("info", None, false, None);
-        crate::tracing::initialize(&obs_config);
+        crate::tracing::init::initialize(&obs_config);
 
         let handle = tokio::task::spawn(async { panic!("you should see this message") });
         assert!(handle.await.is_err());
diff --git a/crates/observe/src/distributed_tracing/tracing_axum.rs b/crates/observe/src/tracing/distributed/axum.rs
similarity index 93%
rename from crates/observe/src/distributed_tracing/tracing_axum.rs
rename to crates/observe/src/tracing/distributed/axum.rs
index a2f1a1a755..cb7d4263fd 100644
--- a/crates/observe/src/distributed_tracing/tracing_axum.rs
+++ b/crates/observe/src/tracing/distributed/axum.rs
@@ -1,5 +1,5 @@
 use {
-    crate::{request_id::request_id, tracing::HeaderExtractor},
+    crate::{request_id::request_id, tracing::distributed::headers::HeaderExtractor},
     axum::http::Request,
     opentelemetry::{global, trace::TraceContextExt},
     tracing::{Span, field, info, info_span},
diff --git a/crates/observe/src/tracing/distributed/headers.rs b/crates/observe/src/tracing/distributed/headers.rs
new file mode 100644
index 0000000000..2419b42727
--- /dev/null
+++ b/crates/observe/src/tracing/distributed/headers.rs
@@ -0,0 +1,58 @@
+use {
+    axum::http::{self, HeaderMap},
+    opentelemetry::{
+        Context,
+        global,
+        propagation::{Extractor, Injector},
+    },
+    tracing::Span,
+    tracing_opentelemetry::OpenTelemetrySpanExt,
+};
+
+pub struct HeaderExtractor<'a>(pub &'a HeaderMap);
+
+// Copied from https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-http/src/lib.rs
+// because that crate is using `http` crate v1 while warp is on v0.2
+impl Extractor for HeaderExtractor<'_> {
+    /// Get a value for a key from the HeaderMap.  If the value is not valid
+    /// ASCII, returns None.
+    fn get(&self, key: &str) -> Option<&str> {
+        self.0.get(key).and_then(|value| value.to_str().ok())
+    }
+
+    /// Collect all the keys from the HeaderMap.
+    fn keys(&self) -> Vec<&str> {
+        self.0
+            .keys()
+            .map(|value| value.as_str())
+            .collect::<Vec<_>>()
+    }
+}
+
+pub struct HeaderInjector<'a>(pub &'a mut http::HeaderMap);
+
+impl Injector for HeaderInjector<'_> {
+    /// Set a key and value in the HeaderMap. Does nothing if the key or value
+    /// are not valid inputs.
+    fn set(&mut self, key: &str, value: String) {
+        if let (Ok(name), Ok(val)) = (
+            http::header::HeaderName::from_bytes(key.as_bytes()),
+            http::header::HeaderValue::from_str(&value),
+        ) {
+            self.0.insert(name, val);
+        }
+    }
+}
+
+pub fn tracing_headers() -> HeaderMap {
+    let mut headers = HeaderMap::new();
+
+    Context::current();
+    let span = Span::current();
+    let cx = span.context();
+    global::get_text_map_propagator(|propagator| {
+        propagator.inject_context(&cx, &mut HeaderInjector(&mut headers))
+    });
+
+    headers
+}
diff --git a/crates/observe/src/tracing/distributed/mod.rs b/crates/observe/src/tracing/distributed/mod.rs
new file mode 100644
index 0000000000..f1d3955317
--- /dev/null
+++ b/crates/observe/src/tracing/distributed/mod.rs
@@ -0,0 +1,7 @@
+//! Module containing all the necessary pieces to trace logs across
+//! multiple services by passing open telemetry information via HTTP headers.
+
+pub mod axum;
+pub mod headers;
+pub mod request_id;
+pub mod trace_id_format;
diff --git a/crates/observe/src/distributed_tracing/request_id.rs b/crates/observe/src/tracing/distributed/request_id.rs
similarity index 87%
rename from crates/observe/src/distributed_tracing/request_id.rs
rename to crates/observe/src/tracing/distributed/request_id.rs
index 7bcbc49b94..48a1b926ed 100644
--- a/crates/observe/src/distributed_tracing/request_id.rs
+++ b/crates/observe/src/tracing/distributed/request_id.rs
@@ -95,7 +95,7 @@ impl<S: Subscriber + for<'lookup> LookupSpan<'lookup>> Layer<S> for RequestIdLay
         let Some(span) = ctx.span(id) else {
             return;
         };
-        if span.name() != crate::distributed_tracing::request_id::SPAN_NAME {
+        if span.name() != SPAN_NAME {
             return;
         }
 
@@ -126,17 +126,14 @@ mod test {
 
     fn init_tracing(env_filter: &str) {
         let obs_config = Config::new(env_filter, tracing::Level::ERROR.into(), false, None);
-        crate::tracing::initialize_reentrant(&obs_config);
+        crate::tracing::init::initialize_reentrant(&obs_config);
     }
 
     #[tokio::test]
     async fn request_id_from_current_span() {
         init_tracing("error");
         async {
-            assert_eq!(
-                Some("test".to_string()),
-                crate::distributed_tracing::request_id::from_current_span()
-            );
+            assert_eq!(Some("test".to_string()), from_current_span());
         }
         .instrument(info_span("test".to_string()))
         .await
@@ -146,10 +143,7 @@ mod test {
     async fn request_id_not_set() {
         init_tracing("debug");
         async {
-            assert_eq!(
-                None,
-                crate::distributed_tracing::request_id::from_current_span()
-            );
+            assert_eq!(None, from_current_span());
         }
         .await
     }
@@ -161,10 +155,7 @@ mod test {
             async {
                 async {
                     // we traverse the span hierarchy until we find a span with the request id
-                    assert_eq!(
-                        Some("test".to_string()),
-                        crate::distributed_tracing::request_id::from_current_span()
-                    );
+                    assert_eq!(Some("test".to_string()), from_current_span());
                 }
                 .instrument(tracing::info_span!("wrap2", value = "value2"))
                 .await
@@ -183,10 +174,7 @@ mod test {
             async {
                 async {
                     // if multiple ancestors have a request id we take the closest one
-                    assert_eq!(
-                        Some("test_inner".to_string()),
-                        crate::distributed_tracing::request_id::from_current_span()
-                    );
+                    assert_eq!(Some("test_inner".to_string()), from_current_span());
                 }
                 .instrument(tracing::info_span!("wrap", value = "value"))
                 .await
@@ -206,10 +194,7 @@ mod test {
                 async {
                     // we can spawn a new task and still find the request id if the spawned task
                     // was instrumented with a span that contains the request id
-                    assert_eq!(
-                        Some("test".to_string()),
-                        crate::distributed_tracing::request_id::from_current_span()
-                    );
+                    assert_eq!(Some("test".to_string()), from_current_span());
                 }
                 .instrument(Span::current()),
             )
diff --git a/crates/observe/src/distributed_tracing/trace_id_format.rs b/crates/observe/src/tracing/distributed/trace_id_format.rs
similarity index 100%
rename from crates/observe/src/distributed_tracing/trace_id_format.rs
rename to crates/observe/src/tracing/distributed/trace_id_format.rs
diff --git a/crates/observe/src/tracing.rs b/crates/observe/src/tracing/init.rs
similarity index 66%
rename from crates/observe/src/tracing.rs
rename to crates/observe/src/tracing/init.rs
index 4ff46c3ca7..0647ecfb55 100644
--- a/crates/observe/src/tracing.rs
+++ b/crates/observe/src/tracing/init.rs
@@ -1,20 +1,15 @@
 use {
     crate::{
         config::Config,
-        distributed_tracing::{
-            request_id::RequestIdLayer,
-            trace_id_format::{TraceIdFmt, TraceIdJsonFormat},
+        tracing::{
+            distributed::{
+                request_id::RequestIdLayer,
+                trace_id_format::{TraceIdFmt, TraceIdJsonFormat},
+            },
+            reload_handler::spawn_reload_handler,
         },
-        tracing_reload_handler::spawn_reload_handler,
-    },
-    axum::http::{self, HeaderMap},
-    opentelemetry::{
-        Context,
-        KeyValue,
-        global,
-        propagation::{Extractor, Injector},
-        trace::TracerProvider,
     },
+    opentelemetry::{KeyValue, global, trace::TracerProvider},
     opentelemetry_otlp::WithExportConfig,
     opentelemetry_sdk::{
         Resource,
@@ -23,8 +18,7 @@ use {
     },
     std::{panic::PanicHookInfo, sync::Once},
     time::macros::format_description,
-    tracing::{Span, level_filters::LevelFilter},
-    tracing_opentelemetry::OpenTelemetrySpanExt,
+    tracing::level_filters::LevelFilter,
     tracing_subscriber::{
         EnvFilter,
         Layer,
@@ -189,105 +183,3 @@ fn tracing_panic_hook(panic: &PanicHookInfo) {
     let backtrace = std::backtrace::Backtrace::force_capture();
     tracing::error!("thread '{name}' {panic}\nstack backtrace:\n{backtrace}");
 }
-
-pub struct HeaderExtractor<'a>(pub &'a HeaderMap);
-
-// Copied from https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-http/src/lib.rs
-// because that crate is using `http` crate v1 while warp is on v0.2
-impl Extractor for HeaderExtractor<'_> {
-    /// Get a value for a key from the HeaderMap.  If the value is not valid
-    /// ASCII, returns None.
-    fn get(&self, key: &str) -> Option<&str> {
-        self.0.get(key).and_then(|value| value.to_str().ok())
-    }
-
-    /// Collect all the keys from the HeaderMap.
-    fn keys(&self) -> Vec<&str> {
-        self.0
-            .keys()
-            .map(|value| value.as_str())
-            .collect::<Vec<_>>()
-    }
-}
-
-pub struct HeaderInjector<'a>(pub &'a mut http::HeaderMap);
-
-impl Injector for HeaderInjector<'_> {
-    /// Set a key and value in the HeaderMap. Does nothing if the key or value
-    /// are not valid inputs.
-    fn set(&mut self, key: &str, value: String) {
-        if let (Ok(name), Ok(val)) = (
-            http::header::HeaderName::from_bytes(key.as_bytes()),
-            http::header::HeaderValue::from_str(&value),
-        ) {
-            self.0.insert(name, val);
-        }
-    }
-}
-
-pub fn tracing_headers() -> HeaderMap {
-    let mut headers = HeaderMap::new();
-
-    Context::current();
-    let span = Span::current();
-    let cx = span.context();
-    global::get_text_map_propagator(|propagator| {
-        propagator.inject_context(&cx, &mut HeaderInjector(&mut headers))
-    });
-
-    headers
-}
-
-/// Helper struct to lazily evaluate an expression if a log is actually active.
-/// Sometimes you need to compute a value for logs. This expression gets
-/// evaluated eagerly in the `tracing` log macros. In order to only evaluate the
-/// expression when the log is actually enabled wrap the expression in a closure
-/// and wrap that in a [`Lazy`].
-pub struct Lazy<T>(pub T);
-
-impl<T, D> std::fmt::Debug for Lazy<T>
-where
-    T: Fn() -> D,
-    D: std::fmt::Debug,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", (self.0)())
-    }
-}
-
-impl<T, D> std::fmt::Display for Lazy<T>
-where
-    T: Fn() -> D,
-    D: std::fmt::Display,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", (self.0)())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn lazy_eval() {
-        let lazy = Lazy(|| "abc".to_string());
-
-        let display = format!("{}", lazy);
-        assert_eq!(display, "abc");
-
-        let debug = format!("{:?}", lazy);
-        assert_eq!(debug, "\"abc\"");
-    }
-
-    #[test]
-    fn lazy_in_macro() {
-        tracing::debug!(
-            miep = ?Lazy(|| {
-                panic!("this panic should not happen because we evaluate lazily");
-                #[expect(unreachable_code)]
-                "abc"
-            })
-        )
-    }
-}
diff --git a/crates/observe/src/tracing/lazy.rs b/crates/observe/src/tracing/lazy.rs
new file mode 100644
index 0000000000..0641cd1f63
--- /dev/null
+++ b/crates/observe/src/tracing/lazy.rs
@@ -0,0 +1,53 @@
+/// Helper struct to lazily evaluate an expression if a log is actually active.
+/// Sometimes you need to compute a value for logs. This expression gets
+/// evaluated eagerly in the `tracing` log macros. In order to only evaluate the
+/// expression when the log is actually enabled wrap the expression in a closure
+/// and wrap that in a [`Lazy`].
+pub struct Lazy<T>(pub T);
+
+impl<T, D> std::fmt::Debug for Lazy<T>
+where
+    T: Fn() -> D,
+    D: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", (self.0)())
+    }
+}
+
+impl<T, D> std::fmt::Display for Lazy<T>
+where
+    T: Fn() -> D,
+    D: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", (self.0)())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lazy_eval() {
+        let lazy = Lazy(|| "abc".to_string());
+
+        let display = format!("{}", lazy);
+        assert_eq!(display, "abc");
+
+        let debug = format!("{:?}", lazy);
+        assert_eq!(debug, "\"abc\"");
+    }
+
+    #[test]
+    fn lazy_in_macro() {
+        tracing::debug!(
+            miep = ?Lazy(|| {
+                panic!("this panic should not happen because we evaluate lazily");
+                #[expect(unreachable_code)]
+                "abc"
+            })
+        )
+    }
+}
diff --git a/crates/observe/src/tracing/mod.rs b/crates/observe/src/tracing/mod.rs
new file mode 100644
index 0000000000..bf4846c17c
--- /dev/null
+++ b/crates/observe/src/tracing/mod.rs
@@ -0,0 +1,5 @@
+pub mod distributed;
+pub mod init;
+pub mod lazy;
+#[cfg(unix)]
+mod reload_handler;
diff --git a/crates/observe/src/tracing_reload_handler.rs b/crates/observe/src/tracing/reload_handler.rs
similarity index 100%
rename from crates/observe/src/tracing_reload_handler.rs
rename to crates/observe/src/tracing/reload_handler.rs
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 6ef5966e02..8b6f88a107 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -14,7 +14,7 @@ use {
         response::{IntoResponse, Json, Response},
         routing::{delete, get, post, put},
     },
-    observe::distributed_tracing::tracing_axum::{self, record_trace_id},
+    observe::tracing::distributed::axum::{make_span, record_trace_id},
     serde::{Deserialize, Serialize},
     shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     std::{
@@ -306,7 +306,7 @@ pub fn handle_all_routes(
         .layer(middleware::from_fn(with_matched_path_metric))
         .layer(
             ServiceBuilder::new()
-                .layer(TraceLayer::new_for_http().make_span_with(tracing_axum::make_span))
+                .layer(TraceLayer::new_for_http().make_span_with(make_span))
                 .map_request(record_trace_id),
         )
 }
diff --git a/crates/orderbook/src/ipfs.rs b/crates/orderbook/src/ipfs.rs
index ff0a873a45..fbc2d8cc65 100644
--- a/crates/orderbook/src/ipfs.rs
+++ b/crates/orderbook/src/ipfs.rs
@@ -89,7 +89,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn not_found() {
-        observe::tracing::initialize(
+        observe::tracing::init::initialize(
             &observe::Config::default().with_env_filter("orderbook::ipfs=trace"),
         );
         let ipfs = Ipfs::new(Default::default(), "https://ipfs.io".parse().unwrap(), None);
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 3de44aa8e8..21201e63db 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -55,7 +55,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
         args.shared.logging.use_json_logs,
         tracing_config(&args.shared.tracing, "orderbook".into()),
     );
-    observe::tracing::initialize(&obs_config);
+    observe::tracing::init::initialize(&obs_config);
     tracing::info!("running order book with validated arguments:\n{}", args);
     observe::panic_hook::install();
     observe::metrics::setup_registry(Some("gp_v2_api".into()), None);
diff --git a/crates/refunder/src/lib.rs b/crates/refunder/src/lib.rs
index e9f17b9c0b..346ced2d3f 100644
--- a/crates/refunder/src/lib.rs
+++ b/crates/refunder/src/lib.rs
@@ -39,7 +39,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
         args.logging.use_json_logs,
         None,
     );
-    observe::tracing::initialize(&obs_config);
+    observe::tracing::init::initialize(&obs_config);
     observe::panic_hook::install();
     #[cfg(unix)]
     observe::heap_dump_handler::spawn_heap_dump_handler();
diff --git a/crates/shared/src/maintenance.rs b/crates/shared/src/maintenance.rs
index 5291f26467..44435a7e53 100644
--- a/crates/shared/src/maintenance.rs
+++ b/crates/shared/src/maintenance.rs
@@ -220,7 +220,7 @@ mod tests {
     #[tokio::test]
     async fn block_stream_retries_failed_blocks() {
         let obs_config = observe::Config::default().with_env_filter("debug");
-        observe::tracing::initialize(&obs_config);
+        observe::tracing::init::initialize(&obs_config);
 
         let mut mock_maintenance = MockMaintaining::new();
         let mut sequence = Sequence::new();
diff --git a/crates/shared/src/price_estimation/native/forwarder.rs b/crates/shared/src/price_estimation/native/forwarder.rs
index bfff0073a2..b3f0d71bb3 100644
--- a/crates/shared/src/price_estimation/native/forwarder.rs
+++ b/crates/shared/src/price_estimation/native/forwarder.rs
@@ -40,7 +40,7 @@ impl Forwarder {
             .get(url)
             .query(&[("timeout_ms", timeout.as_millis() as u64)])
             .timeout(timeout);
-        if let Some(id) = observe::distributed_tracing::request_id::from_current_span() {
+        if let Some(id) = observe::tracing::distributed::request_id::from_current_span() {
             request = request.header("X-REQUEST-ID", id);
         }
         let response = request.send().await.map_err(|err| {
diff --git a/crates/shared/src/trade_finding/external.rs b/crates/shared/src/trade_finding/external.rs
index dae60321a4..86e04bb4a3 100644
--- a/crates/shared/src/trade_finding/external.rs
+++ b/crates/shared/src/trade_finding/external.rs
@@ -19,7 +19,7 @@ use {
     anyhow::{Context, anyhow},
     ethrpc::block_stream::CurrentBlockWatcher,
     futures::FutureExt,
-    observe::tracing::tracing_headers,
+    observe::tracing::distributed::headers::tracing_headers,
     reqwest::{Client, header},
     tracing::instrument,
     url::Url,
@@ -63,7 +63,7 @@ impl ExternalTradeFinder {
                 deadline: chrono::Utc::now() + query.timeout,
             };
             let block_dependent = query.block_dependent;
-            let id = observe::distributed_tracing::request_id::from_current_span();
+            let id = observe::tracing::distributed::request_id::from_current_span();
             let client = self.client.clone();
             let quote_endpoint = self.quote_endpoint.clone();
             let block_hash = self.block_stream.borrow().hash;
diff --git a/crates/shared/src/zeroex_api.rs b/crates/shared/src/zeroex_api.rs
index 9c3359cc02..d29eacbea1 100644
--- a/crates/shared/src/zeroex_api.rs
+++ b/crates/shared/src/zeroex_api.rs
@@ -10,7 +10,7 @@ use {
     chrono::{DateTime, NaiveDateTime, TimeZone, Utc},
     ethrpc::block_stream::{BlockInfo, CurrentBlockWatcher},
     number::serialization::HexOrDecimalU256,
-    observe::tracing::tracing_headers,
+    observe::tracing::distributed::headers::tracing_headers,
     reqwest::{
         Client,
         ClientBuilder,
@@ -416,7 +416,7 @@ impl DefaultZeroExApi {
                     self.block_stream.borrow().hash.to_string(),
                 );
             };
-            if let Some(id) = observe::distributed_tracing::request_id::from_current_span() {
+            if let Some(id) = observe::tracing::distributed::request_id::from_current_span() {
                 request = request.header("X-REQUEST-ID", id);
             }
 
diff --git a/crates/solvers/src/api/mod.rs b/crates/solvers/src/api/mod.rs
index dbb363cd5d..7a866e3082 100644
--- a/crates/solvers/src/api/mod.rs
+++ b/crates/solvers/src/api/mod.rs
@@ -2,7 +2,7 @@
 
 use {
     crate::domain::solver::Solver,
-    observe::distributed_tracing::tracing_axum::{make_span, record_trace_id},
+    observe::tracing::distributed::axum::{make_span, record_trace_id},
     std::{future::Future, net::SocketAddr, sync::Arc},
     tokio::sync::oneshot,
 };
diff --git a/crates/solvers/src/run.rs b/crates/solvers/src/run.rs
index ad87ccfe60..272336f126 100644
--- a/crates/solvers/src/run.rs
+++ b/crates/solvers/src/run.rs
@@ -32,7 +32,7 @@ async fn run_with(args: cli::Args, bind: Option<oneshot::Sender<SocketAddr>>) {
         args.use_json_logs,
         tracing_config(&args.tracing, "solvers".into()),
     );
-    observe::tracing::initialize_reentrant(&obs_config);
+    observe::tracing::init::initialize_reentrant(&obs_config);
     #[cfg(unix)]
     observe::heap_dump_handler::spawn_heap_dump_handler();
 

From 6a9cd2e880d28b4f2eec2469f4293d75ac806101 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 23 Feb 2026 14:19:14 +0000
Subject: [PATCH 101/219] Remove backported header injector & extractor (#4200)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
The removed structs + impls were here because of incompatibility issues.
We've since fixed them, it's time to remove them 🗑️

# Changes

* Add opentelemetry-http dep
* Remove the HeaderInjector + HeaderExtractor

## How to test
Staging but this should be basically 1:1
---
 Cargo.lock                                    |  1 +
 Cargo.toml                                    |  1 +
 crates/observe/Cargo.toml                     |  1 +
 .../observe/src/tracing/distributed/axum.rs   |  3 +-
 .../src/tracing/distributed/headers.rs        | 44 ++-----------------
 5 files changed, 8 insertions(+), 42 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 773d03f6bd..dd95b2d56c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4611,6 +4611,7 @@ dependencies = [
  "futures",
  "jemalloc_pprof",
  "opentelemetry",
+ "opentelemetry-http",
  "opentelemetry-otlp",
  "opentelemetry_sdk",
  "pin-project-lite",
diff --git a/Cargo.toml b/Cargo.toml
index 4d33fdf2d4..850c47dc49 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -77,6 +77,7 @@ order-validation = { path = "crates/order-validation" }
 opentelemetry = { version = "0.31", features = ["tracing"] }
 opentelemetry-otlp = "0.31"
 opentelemetry_sdk = "0.31"
+opentelemetry-http = { version = "0.31", default-features = false } # disable internal-logging
 orderbook = { path = "crates/orderbook" }
 paste = "1.0"
 pin-project-lite = "0.2.14"
diff --git a/crates/observe/Cargo.toml b/crates/observe/Cargo.toml
index ee99edca35..02b8bdc1a1 100644
--- a/crates/observe/Cargo.toml
+++ b/crates/observe/Cargo.toml
@@ -27,6 +27,7 @@ tracing-opentelemetry = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 tracing-serde = { workspace = true }
 jemalloc_pprof = { workspace = true }
+opentelemetry-http = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/observe/src/tracing/distributed/axum.rs b/crates/observe/src/tracing/distributed/axum.rs
index cb7d4263fd..61f11ece9e 100644
--- a/crates/observe/src/tracing/distributed/axum.rs
+++ b/crates/observe/src/tracing/distributed/axum.rs
@@ -1,7 +1,8 @@
 use {
-    crate::{request_id::request_id, tracing::distributed::headers::HeaderExtractor},
+    crate::request_id::request_id,
     axum::http::Request,
     opentelemetry::{global, trace::TraceContextExt},
+    opentelemetry_http::HeaderExtractor,
     tracing::{Span, field, info, info_span},
     tracing_opentelemetry::OpenTelemetrySpanExt,
 };
diff --git a/crates/observe/src/tracing/distributed/headers.rs b/crates/observe/src/tracing/distributed/headers.rs
index 2419b42727..5d6a8fab7f 100644
--- a/crates/observe/src/tracing/distributed/headers.rs
+++ b/crates/observe/src/tracing/distributed/headers.rs
@@ -1,49 +1,11 @@
 use {
-    axum::http::{self, HeaderMap},
-    opentelemetry::{
-        Context,
-        global,
-        propagation::{Extractor, Injector},
-    },
+    axum::http::HeaderMap,
+    opentelemetry::{Context, global},
+    opentelemetry_http::HeaderInjector,
     tracing::Span,
     tracing_opentelemetry::OpenTelemetrySpanExt,
 };
 
-pub struct HeaderExtractor<'a>(pub &'a HeaderMap);
-
-// Copied from https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-http/src/lib.rs
-// because that crate is using `http` crate v1 while warp is on v0.2
-impl Extractor for HeaderExtractor<'_> {
-    /// Get a value for a key from the HeaderMap.  If the value is not valid
-    /// ASCII, returns None.
-    fn get(&self, key: &str) -> Option<&str> {
-        self.0.get(key).and_then(|value| value.to_str().ok())
-    }
-
-    /// Collect all the keys from the HeaderMap.
-    fn keys(&self) -> Vec<&str> {
-        self.0
-            .keys()
-            .map(|value| value.as_str())
-            .collect::<Vec<_>>()
-    }
-}
-
-pub struct HeaderInjector<'a>(pub &'a mut http::HeaderMap);
-
-impl Injector for HeaderInjector<'_> {
-    /// Set a key and value in the HeaderMap. Does nothing if the key or value
-    /// are not valid inputs.
-    fn set(&mut self, key: &str, value: String) {
-        if let (Ok(name), Ok(val)) = (
-            http::header::HeaderName::from_bytes(key.as_bytes()),
-            http::header::HeaderValue::from_str(&value),
-        ) {
-            self.0.insert(name, val);
-        }
-    }
-}
-
 pub fn tracing_headers() -> HeaderMap {
     let mut headers = HeaderMap::new();
 

From 1d3e3b8a41ea396089f054cd871409d7e40609ea Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Tue, 24 Feb 2026 09:10:12 +0100
Subject: [PATCH 102/219] Improve CoinGecko batching mechanism (#4202)

# Description

`estimate_prices_and_update_cache` iterates all tracked tokens, most of
which are cache hits that resolve instantly. With .buffered() a pending
cache miss at the front blocks yielding ready results behind it, keeping
all remaining slots occupied and preventing new futures from entering
the stream. This means expired tokens trickle into BufferedRequest too
slowly producing batches of 2-3 tokens instead of the max 20.


https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=63d75fe56901ecfe850ec03875615596
demonstrates this.
---
 crates/shared/src/price_estimation/native_price_cache.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/shared/src/price_estimation/native_price_cache.rs b/crates/shared/src/price_estimation/native_price_cache.rs
index 87b98e1642..ccc206ad63 100644
--- a/crates/shared/src/price_estimation/native_price_cache.rs
+++ b/crates/shared/src/price_estimation/native_price_cache.rs
@@ -342,7 +342,7 @@ impl CachingNativePriceEstimator {
             (token, result)
         });
         futures::stream::iter(estimates)
-            .buffered(self.0.concurrent_requests)
+            .buffer_unordered(self.0.concurrent_requests)
             .boxed()
     }
 

From 38287ec5a153c2547bcd31d196e03b8630924e91 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 24 Feb 2026 09:25:07 +0100
Subject: [PATCH 103/219] [TRIVIAL] Remove noisy tracing spans (#4203)

# Description
This function gets called hundreds of times within one span leading to a
tempo view that scrolls many pages which makes it hard to get the big
picture of the call.
The caller of the noisy call is also instrumented and measures the
execution time of all sub calls together so we'll not lose much
information.

# Changes
remove instrumentation of frequently called function
---
 crates/shared/src/sources/uniswap_v2/pool_fetching.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs b/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
index d27e85fa14..623df6eadf 100644
--- a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
+++ b/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
@@ -23,7 +23,6 @@ use {
         sync::{LazyLock, RwLock},
         time::Duration,
     },
-    tracing::instrument,
 };
 
 const POOL_SWAP_GAS_COST: usize = 60_000;
@@ -218,7 +217,6 @@ impl<Reader> PoolFetching for PoolFetcher<Reader>
 where
     Reader: PoolReading,
 {
-    #[instrument(skip_all)]
     async fn fetch(&self, token_pairs: HashSet<TokenPair>, at_block: Block) -> Result<Vec<Pool>> {
         let mut token_pairs: Vec<_> = token_pairs.into_iter().collect();
         {

From 7cf288e2a673b87deff4a2f6c19b0922265c34b1 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 24 Feb 2026 16:49:21 +0100
Subject: [PATCH 104/219] Autopilot measure network transfer (#4204)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Some solvers reported that `/solve` requests arrive with varying delays.
It's quite hard to pin point where the issues lies. While some
improvements on the autopilot definitely reduced the variance of the
delay greatly there are still new reports about this.
In order to get more data on this (especially from solvers NOT using the
CoW hosted reference driver) this PR tries to approximate the data
transfer times from the autopilot side.
This is accomplished by writing a slim wrapper around the fully
serialized payload `Bytes` that turns it into a stream. That way we can
at least measure the time it takes `hyper` to write the bytes to the
network stack. Since the consumer (external driver) will have
back-pressure on the transfer this measurement should come reasonably
close to the actual data transfer times.

# Changes
- added `BytesStream` that yields `Bytes` in 1MB chunks
- also measures time to start the transfer and the entire transfer time
- logs the result using the original tracing span (which now contains
the auction_id, and driver)

## How to test
added unit test for correctness of the yielded data
ran in e2e test to confirm the logs contain the expected spans

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
---
 .../src/infra/solvers/byte_stream.rs          | 94 +++++++++++++++++++
 .../autopilot/src/infra/solvers/dto/solve.rs  |  4 +-
 crates/autopilot/src/infra/solvers/mod.rs     |  1 +
 crates/autopilot/src/run_loop.rs              | 19 ++--
 4 files changed, 108 insertions(+), 10 deletions(-)
 create mode 100644 crates/autopilot/src/infra/solvers/byte_stream.rs

diff --git a/crates/autopilot/src/infra/solvers/byte_stream.rs b/crates/autopilot/src/infra/solvers/byte_stream.rs
new file mode 100644
index 0000000000..e4dd8f84a6
--- /dev/null
+++ b/crates/autopilot/src/infra/solvers/byte_stream.rs
@@ -0,0 +1,94 @@
+use {
+    bytes::Bytes,
+    futures::Stream,
+    std::{task::Poll, time::Instant},
+};
+
+/// Thin wrapper around a payload that already exists fully serialized
+/// in-memory. The purpose of converting that into a stream is to allow
+/// measuring the data transfer of the request body (for debugging and
+/// optimization purposes).
+///
+/// Note that this measurement is only an approximation of the truth.
+/// The reason is that this only measures how long it takes `hyper`
+/// to load the last byte from the body into the buffer of the network
+/// stack. However, given how big `/solve` requests are in practice
+/// `hyper` should have to flush the buffer a couple of times so the
+/// measured time should be reasonably accurate.
+pub struct ByteStream {
+    data: Bytes,
+    created_at: Instant,
+    first_polled_at: Option<Instant>,
+    span: tracing::Span,
+}
+
+impl ByteStream {
+    pub fn new(data: Bytes) -> Self {
+        Self {
+            data,
+            created_at: Instant::now(),
+            first_polled_at: None,
+            span: tracing::Span::current(),
+        }
+    }
+}
+
+// Since `hyper` uses `Bytes` under the hood which are reference counted
+// the chunks we yield can be as big as we want. To minimize overhead
+// that's only there for debugging purposes we always yield all the
+// data at once. The measurements will still be accurate because `hyper`
+// has to poll the stream once more to confirm that it's actually
+// exhausted.
+impl Stream for ByteStream {
+    type Item = Result<Bytes, std::io::Error>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        let this = self.as_mut().get_mut();
+
+        if this.first_polled_at.is_none() {
+            this.first_polled_at = Some(Instant::now());
+        }
+
+        if this.data.is_empty() {
+            let _span = this.span.enter();
+            let first_poll = this.first_polled_at.expect("initialized at first poll");
+            tracing::debug!(
+                to_transmission_start = ?first_poll.duration_since(this.created_at),
+                transmission = ?first_poll.elapsed(),
+                "finished streaming http request body"
+            );
+            Poll::Ready(None)
+        } else {
+            // steals all the data and leaves 0 bytes in self
+            let chunk = std::mem::take(&mut this.data);
+            Poll::Ready(Some(Ok(chunk)))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, futures::FutureExt, tokio_stream::StreamExt};
+
+    #[test]
+    fn byte_stream_yields_bytes() {
+        let original = Bytes::from_iter(0..100);
+        let mut stream = ByteStream::new(original.clone());
+
+        let chunk = stream
+            .next()
+            .now_or_never()
+            .expect("stream is always ready");
+        // stream always yields all the data on the first poll
+        assert_eq!(chunk.unwrap().unwrap(), original);
+
+        let chunk = stream
+            .next()
+            .now_or_never()
+            .expect("stream is always ready");
+        assert!(chunk.is_none());
+    }
+}
diff --git a/crates/autopilot/src/infra/solvers/dto/solve.rs b/crates/autopilot/src/infra/solvers/dto/solve.rs
index da80a42fd4..0746ed0faa 100644
--- a/crates/autopilot/src/infra/solvers/dto/solve.rs
+++ b/crates/autopilot/src/infra/solvers/dto/solve.rs
@@ -4,7 +4,7 @@ use {
         domain::{self, eth},
         infra::{
             persistence::dto::{self, order::Order},
-            solvers::InjectIntoHttpRequest,
+            solvers::{InjectIntoHttpRequest, byte_stream::ByteStream},
         },
     },
     alloy::primitives::{Address, U256},
@@ -82,7 +82,7 @@ impl Request {
 impl InjectIntoHttpRequest for Request {
     fn inject(&self, request: RequestBuilder) -> RequestBuilder {
         request
-            .body(self.body.clone())
+            .body(reqwest::Body::wrap_stream(ByteStream::new(self.body.clone())))
             // announce which auction this request is for in the
             // headers to help the driver detect duplicated
             // `/solve` requests before streaming the body
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index 361545e5e4..e5dd00263a 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -11,6 +11,7 @@ use {
     url::Url,
 };
 
+mod byte_stream;
 pub mod dto;
 
 const RESPONSE_SIZE_LIMIT: usize = 10_000_000;
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index edcefd4993..43ebbaed7a 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -650,14 +650,17 @@ impl RunLoop {
         let (can_participate, response) = {
             let driver = driver.clone();
             let eth = self.eth.clone();
-            let mut handle = tokio::task::spawn(async move {
-                let fetch_response = driver.solve(request);
-                let check_allowed = eth
-                    .contracts()
-                    .authenticator()
-                    .isSolver(driver.submission_address);
-                tokio::join!(check_allowed.call(), fetch_response)
-            });
+            let mut handle = tokio::task::spawn(
+                async move {
+                    let fetch_response = driver.solve(request);
+                    let check_allowed = eth
+                        .contracts()
+                        .authenticator()
+                        .isSolver(driver.submission_address);
+                    tokio::join!(check_allowed.call(), fetch_response)
+                }
+                .in_current_span(),
+            );
             tokio::time::timeout(self.config.solve_deadline, &mut handle)
                 .await
                 .map_err(|_| {

From c336771d65b609696a59377b9e06e5ec11775fbe Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 24 Feb 2026 16:53:33 +0100
Subject: [PATCH 105/219] Only check allowance of liquidity sources that are
 actually used (#4190)

# Description
Currently a lot of CPU time (~3.5%) is spent on fetching allowances for
the liquidity sources we index. This is problematic for 2 reasons:
* most liquidity sources are not used so fetching the settlement
contract's allowance is wasted time
* the driver seems to not use the fetched allowance and fetches them
again when encoding the tx (see
[1](https://github.com/cowprotocol/services/blob/main/crates/driver/src/domain/competition/solution/encoding.rs#L175),
[2](https://github.com/cowprotocol/services/blob/main/crates/driver/src/domain/competition/solution/mod.rs#L294-L299),
[3](https://github.com/cowprotocol/services/blob/main/crates/driver/src/domain/competition/solution/mod.rs#L427),
[4](https://github.com/cowprotocol/services/blob/main/crates/driver/src/domain/competition/solution/interaction.rs#L33-L62))

# Changes
deleted `solver::interactions::allowances` and it's usages

## How to test
e2e tests still work
---
 .../src/boundary/liquidity/balancer/v2/mod.rs |   3 -
 .../src/boundary/liquidity/uniswap/v2.rs      |  39 +-
 .../src/boundary/liquidity/uniswap/v3.rs      |  16 +-
 .../driver/src/boundary/liquidity/zeroex.rs   |   2 +-
 crates/solver/src/interactions/allowances.rs  | 403 ------------------
 crates/solver/src/interactions/mod.rs         |   1 -
 crates/solver/src/liquidity/balancer_v2.rs    |  68 +--
 crates/solver/src/liquidity/uniswap_v2.rs     | 148 +------
 crates/solver/src/liquidity/uniswap_v3.rs     | 178 +-------
 crates/solver/src/liquidity/zeroex.rs         |  93 +---
 10 files changed, 48 insertions(+), 903 deletions(-)
 delete mode 100644 crates/solver/src/interactions/allowances.rs

diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
index 72287f6eb2..3ef3baeac6 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
@@ -26,7 +26,6 @@ use {
         token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     },
     solver::{
-        interactions::allowances::Allowances,
         liquidity::balancer_v2::{self, BalancerV2Liquidity},
         liquidity_collector::{BackgroundInitLiquiditySource, LiquidityCollecting},
     },
@@ -54,7 +53,6 @@ fn to_interaction(
         // change this assumption, we would need to change it there as well.
         *receiver,
         pool.vault.0,
-        Allowances::empty(*receiver),
     );
 
     let interaction = handler.swap(
@@ -188,7 +186,6 @@ async fn init_liquidity(
     );
 
     Ok(BalancerV2Liquidity::new(
-        web3,
         balancer_pool_fetcher,
         *eth.contracts().settlement().address(),
         *contracts.vault.address(),
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v2.rs b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
index 4d51435a77..19e3040835 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v2.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
@@ -7,8 +7,6 @@ use {
         },
         infra::{self, blockchain::Ethereum},
     },
-    alloy::primitives::Address,
-    async_trait::async_trait,
     contracts::alloy::IUniswapLikeRouter,
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     shared::{
@@ -20,17 +18,13 @@ use {
         },
     },
     solver::{
-        interactions::allowances::{AllowanceManaging, Allowances, Approval, ApprovalRequest},
         liquidity::{
             ConstantProductOrder,
             uniswap_v2::{self, UniswapLikeLiquidity},
         },
         liquidity_collector::LiquidityCollecting,
     },
-    std::{
-        collections::HashSet,
-        sync::{Arc, Mutex},
-    },
+    std::sync::Arc,
 };
 
 /// Median gas used per UniswapInteraction (v2).
@@ -94,13 +88,9 @@ pub fn to_interaction(
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
 ) -> eth::Interaction {
-    let handler = uniswap_v2::Inner::new(
-        pool.router.0,
-        *receiver,
-        Mutex::new(Allowances::empty(*receiver)),
-    );
+    let handler = uniswap_v2::Inner::new(pool.router.0, *receiver);
 
-    let (_, interaction) = handler.settle(
+    let interaction = handler.settle(
         TokenAmount::new(input.0.token.into(), input.0.amount),
         TokenAmount::new(output.0.token.into(), output.0.amount),
     );
@@ -155,30 +145,9 @@ where
         )?)
     };
 
-    Ok(Box::new(UniswapLikeLiquidity::with_allowances(
+    Ok(Box::new(UniswapLikeLiquidity::new(
         *router.address(),
         *settlement.address(),
-        Box::new(NoAllowanceManaging),
         pool_fetcher,
     )))
 }
-
-/// An allowance manager that always reports no allowances.
-struct NoAllowanceManaging;
-
-#[async_trait]
-impl AllowanceManaging for NoAllowanceManaging {
-    async fn get_allowances(&self, _: HashSet<Address>, spender: Address) -> Result<Allowances> {
-        Ok(Allowances::empty(spender))
-    }
-
-    async fn get_approvals(&self, requests: &[ApprovalRequest]) -> Result<Vec<Approval>> {
-        Ok(requests
-            .iter()
-            .map(|request| Approval {
-                spender: request.spender,
-                token: request.token,
-            })
-            .collect())
-    }
-}
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v3.rs b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
index ae3f9a71e4..7e5e58f531 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v3.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
@@ -19,17 +19,13 @@ use {
         sources::uniswap_v3::pool_fetching::UniswapV3PoolFetcher,
     },
     solver::{
-        interactions::allowances::Allowances,
         liquidity::{
             ConcentratedLiquidity,
             uniswap_v3::{self, UniswapV3Liquidity, UniswapV3SettlementHandler},
         },
         liquidity_collector::{BackgroundInitLiquiditySource, LiquidityCollecting},
     },
-    std::{
-        collections::BTreeMap,
-        sync::{Arc, Mutex},
-    },
+    std::{collections::BTreeMap, sync::Arc},
 };
 
 pub fn to_domain(id: liquidity::Id, pool: ConcentratedLiquidity) -> Result<liquidity::Liquidity> {
@@ -77,14 +73,9 @@ pub fn to_interaction(
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
 ) -> eth::Interaction {
-    let handler = UniswapV3SettlementHandler::new(
-        pool.router.into(),
-        *receiver,
-        Mutex::new(Allowances::empty(*receiver)),
-        pool.fee.0,
-    );
+    let handler = UniswapV3SettlementHandler::new(pool.router.into(), *receiver, pool.fee.0);
 
-    let (_, interaction) = handler.settle(
+    let interaction = handler.settle(
         TokenAmount::new(input.0.token.into(), input.0.amount),
         TokenAmount::new(output.0.token.into(), output.0.amount),
     );
@@ -147,7 +138,6 @@ async fn init_liquidity(
     Ok(UniswapV3Liquidity::new(
         config.router.into(),
         *eth.contracts().settlement().address(),
-        web3,
         pool_fetcher,
     ))
 }
diff --git a/crates/driver/src/boundary/liquidity/zeroex.rs b/crates/driver/src/boundary/liquidity/zeroex.rs
index fbc5b44a7e..0c4b1c240a 100644
--- a/crates/driver/src/boundary/liquidity/zeroex.rs
+++ b/crates/driver/src/boundary/liquidity/zeroex.rs
@@ -98,6 +98,6 @@ pub async fn collector(
         blocks.clone(),
     )?);
     Ok(Box::new(
-        ZeroExLiquidity::new(web3, api, contract, settlement, blocks).await,
+        ZeroExLiquidity::new(api, contract, settlement, blocks).await,
     ))
 }
diff --git a/crates/solver/src/interactions/allowances.rs b/crates/solver/src/interactions/allowances.rs
deleted file mode 100644
index 168210e411..0000000000
--- a/crates/solver/src/interactions/allowances.rs
+++ /dev/null
@@ -1,403 +0,0 @@
-//! Module containing a general ERC20 allowance manager that allows components
-//! and interactions to query allowances to various contracts as well as keep
-//! generate interactions for them.
-
-use {
-    crate::interactions::Erc20ApproveInteraction,
-    alloy::{
-        network::Ethereum,
-        primitives::{Address, U256},
-        providers::DynProvider,
-    },
-    anyhow::{Context as _, Result, anyhow, ensure},
-    contracts::alloy::ERC20,
-    ethrpc::Web3,
-    shared::{
-        http_solver::model::TokenAmount,
-        interaction::{EncodedInteraction, Interaction},
-    },
-    std::{
-        collections::{HashMap, HashSet},
-        slice,
-    },
-};
-
-#[cfg_attr(test, mockall::automock)]
-#[async_trait::async_trait]
-pub trait AllowanceManaging: Send + Sync {
-    /// Retrieves allowances of the specified tokens for a given spender.
-    ///
-    /// This can be used to cache allowances for a bunch of tokens so that they
-    /// can be used within a context that doesn't allow `async` or errors.
-    async fn get_allowances(
-        &self,
-        tokens: HashSet<Address>,
-        spender: Address,
-    ) -> Result<Allowances>;
-
-    /// Returns the approval interaction for the specified token and spender for
-    /// at least the specified amount, if an approval is required.
-    async fn get_approval(&self, request: &ApprovalRequest) -> Result<Option<Approval>> {
-        Ok(self.get_approvals(slice::from_ref(request)).await?.pop())
-    }
-
-    /// Returns the requried approval interaction for the requests.
-    /// Does not return approvals when they aren't required.
-    async fn get_approvals(&self, requests: &[ApprovalRequest]) -> Result<Vec<Approval>>;
-}
-
-#[derive(Debug, Eq, PartialEq)]
-pub struct ApprovalRequest {
-    pub token: Address,
-    pub spender: Address,
-    pub amount: U256,
-}
-
-#[derive(Debug, Eq, PartialEq)]
-pub struct Allowances {
-    spender: Address,
-    allowances: HashMap<Address, U256>,
-}
-
-impl Allowances {
-    pub fn new(spender: Address, allowances: HashMap<Address, U256>) -> Self {
-        Self {
-            spender,
-            allowances,
-        }
-    }
-
-    pub fn empty(spender: Address) -> Self {
-        Self::new(spender, HashMap::new())
-    }
-
-    /// Gets the approval interaction for the specified token and amount.
-    pub fn approve_token(&self, token_amount: TokenAmount) -> Result<Option<Approval>> {
-        let allowance = self
-            .allowances
-            .get(&token_amount.token)
-            .copied()
-            .ok_or_else(|| anyhow!("missing allowance for token {:?}", token_amount.token))?;
-
-        Ok(if allowance < token_amount.amount {
-            Some(Approval {
-                token: token_amount.token,
-                spender: self.spender,
-            })
-        } else {
-            None
-        })
-    }
-
-    /// Gets the token approval, unconditionally approving in case the token
-    /// allowance is missing.
-    pub fn approve_token_or_default(&self, token_amount: TokenAmount) -> Option<Approval> {
-        let token = token_amount.token;
-
-        self.approve_token(token_amount).unwrap_or(Some(Approval {
-            token,
-            spender: self.spender,
-        }))
-    }
-
-    /// Extends the allowance cache with another.
-    pub fn extend(&mut self, other: Self) -> Result<()> {
-        ensure!(
-            self.spender == other.spender,
-            "failed to extend allowance cache for different spender"
-        );
-        self.allowances.extend(other.allowances);
-
-        Ok(())
-    }
-}
-
-/// An ERC20 approval interaction.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct Approval {
-    pub token: Address,
-    pub spender: Address,
-}
-
-impl Interaction for Approval {
-    fn encode(&self) -> EncodedInteraction {
-        let approve = Erc20ApproveInteraction {
-            token: self.token,
-            spender: self.spender,
-            amount: U256::MAX,
-        };
-
-        approve.encode()
-    }
-}
-
-/// An allowance manager that retrive approval interactions for a given owner
-/// address.
-pub struct AllowanceManager {
-    web3: Web3,
-    owner: Address,
-}
-
-impl AllowanceManager {
-    pub fn new(web3: Web3, owner: Address) -> Self {
-        Self { web3, owner }
-    }
-}
-
-#[async_trait::async_trait]
-impl AllowanceManaging for AllowanceManager {
-    async fn get_allowances(
-        &self,
-        tokens: HashSet<Address>,
-        spender: Address,
-    ) -> Result<Allowances> {
-        Ok(fetch_allowances(
-            self.web3.provider.clone(),
-            self.owner,
-            HashMap::from([(spender, tokens)]),
-        )
-        .await?
-        .remove(&spender)
-        .unwrap_or_else(|| Allowances::empty(spender)))
-    }
-
-    async fn get_approvals(&self, requests: &[ApprovalRequest]) -> Result<Vec<Approval>> {
-        let mut spender_tokens = HashMap::<_, HashSet<_>>::new();
-        for request in requests {
-            spender_tokens
-                .entry(request.spender)
-                .or_default()
-                .insert(request.token);
-        }
-
-        let allowances =
-            fetch_allowances(self.web3.provider.clone(), self.owner, spender_tokens).await?;
-        let mut result = Vec::new();
-        for request in requests {
-            let allowance = allowances
-                .get(&request.spender)
-                .with_context(|| format!("no allowances found for spender {}", request.spender))?
-                .approve_token(TokenAmount::new(request.token, request.amount))?;
-            result.extend(allowance);
-        }
-        Ok(result)
-    }
-}
-
-async fn fetch_allowances(
-    alloy: DynProvider<Ethereum>,
-    owner: Address,
-    spender_tokens: HashMap<Address, HashSet<Address>>,
-) -> Result<HashMap<Address, Allowances>> {
-    let futures = spender_tokens
-        .into_iter()
-        .flat_map(|(spender, tokens)| tokens.into_iter().map(move |token| (spender, token)))
-        .map(|(spender, token)| {
-            let alloy = alloy.clone();
-            async move {
-                let allowance = ERC20::Instance::new(token, alloy)
-                    .allowance(owner, spender)
-                    .call()
-                    .await;
-
-                (spender, token, allowance)
-            }
-        });
-    let results: Vec<_> = futures::future::join_all(futures).await;
-
-    let mut allowances = HashMap::new();
-    for (spender, token, allowance) in results {
-        let allowance = match allowance {
-            Ok(allowance) => allowance,
-            Err(err) => {
-                tracing::warn!("error retrieving allowance for token {:?}: {}", token, err);
-                continue;
-            }
-        };
-
-        allowances
-            .entry(spender)
-            .or_insert_with(|| Allowances::empty(spender))
-            .allowances
-            .insert(token, allowance);
-    }
-
-    Ok(allowances)
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        alloy::{
-            providers::{Provider, ProviderBuilder, mock::Asserter},
-            sol_types::SolValue,
-        },
-        maplit::{hashmap, hashset},
-    };
-
-    #[test]
-    fn approval_when_allowance_is_sufficient() {
-        let token = Address::repeat_byte(0x02);
-        let allowances = Allowances::new(
-            Address::repeat_byte(0x01),
-            hashmap! {
-                token => U256::from(100),
-            },
-        );
-
-        assert_eq!(
-            allowances
-                .approve_token(TokenAmount::new(token, U256::from(42)))
-                .unwrap(),
-            None
-        );
-        assert_eq!(
-            allowances
-                .approve_token(TokenAmount::new(token, U256::from(100)))
-                .unwrap(),
-            None
-        );
-    }
-
-    #[test]
-    fn approval_when_allowance_is_insufficient() {
-        let spender = Address::repeat_byte(0x01);
-        let token = Address::repeat_byte(0x02);
-        let allowances = Allowances::new(
-            spender,
-            hashmap! {
-                token => U256::from(100),
-            },
-        );
-
-        assert_eq!(
-            allowances
-                .approve_token(TokenAmount::new(token, U256::from(1337)))
-                .unwrap(),
-            Some(Approval { token, spender })
-        );
-    }
-
-    #[test]
-    fn approval_for_missing_token() {
-        let allowances = Allowances::new(
-            Address::repeat_byte(0x01),
-            hashmap! {
-                Address::repeat_byte(0x02) => U256::from(100),
-            },
-        );
-
-        assert!(
-            allowances
-                .approve_token(TokenAmount::new(Address::repeat_byte(0x03), U256::ZERO))
-                .is_err()
-        );
-    }
-
-    #[test]
-    fn approval_or_default_for_missing_token() {
-        let spender = Address::repeat_byte(0x01);
-        let token = Address::repeat_byte(0x02);
-        let allowances = Allowances::new(spender, hashmap! {});
-
-        assert_eq!(
-            allowances.approve_token_or_default(TokenAmount::new(token, U256::from(1337))),
-            Some(Approval { token, spender })
-        );
-    }
-
-    #[test]
-    fn extend_allowances_cache() {
-        let mut allowances = Allowances::new(
-            Address::repeat_byte(0x01),
-            hashmap! {
-                Address::repeat_byte(0x11) => U256::from(1),
-                Address::repeat_byte(0x12) => U256::from(2),
-            },
-        );
-        allowances
-            .extend(Allowances::new(
-                Address::repeat_byte(0x01),
-                hashmap! {
-                    Address::repeat_byte(0x11) => U256::from(42),
-                    Address::repeat_byte(0x13) => U256::from(3),
-                },
-            ))
-            .unwrap();
-
-        assert_eq!(
-            allowances.allowances,
-            hashmap! {
-                Address::repeat_byte(0x11) => U256::from(42),
-                Address::repeat_byte(0x12) => U256::from(2),
-                Address::repeat_byte(0x13) => U256::from(3),
-            },
-        );
-    }
-
-    #[test]
-    fn error_extending_allowances_for_different_spenders() {
-        let mut allowances = Allowances::empty(Address::repeat_byte(0x01));
-        assert!(
-            allowances
-                .extend(Allowances::empty(Address::repeat_byte(0x02)))
-                .is_err()
-        );
-    }
-
-    #[test]
-    fn approval_encode_interaction() {
-        let token = Address::repeat_byte(0x01);
-        let spender = Address::repeat_byte(0x02);
-        assert_eq!(
-            Approval { token, spender }.encode(),
-            (
-                token,
-                U256::ZERO,
-                const_hex::decode(
-                    "095ea7b3\
-                    0000000000000000000000000202020202020202020202020202020202020202\
-                    ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-                )
-                .unwrap().into()
-            )
-        );
-    }
-
-    #[tokio::test]
-    async fn fetch_skips_failed_allowance_calls() {
-        let owner = Address::repeat_byte(1);
-        let spender = Address::repeat_byte(2);
-
-        let asserter = Asserter::new();
-        let provider = ProviderBuilder::new().connect_mocked_client(asserter.clone());
-
-        asserter.push_success(&U256::from(1337).abi_encode());
-        asserter.push_failure_msg("test error");
-
-        let allowances = fetch_allowances(
-            provider.erased(),
-            owner,
-            hashmap! {
-                spender => hashset![Address::repeat_byte(0x11), Address::repeat_byte(0x22)],
-            },
-        )
-        .await
-        .unwrap();
-
-        // Poor man's assert + get
-        let allowances = allowances
-            .get(&spender)
-            .unwrap_or_else(|| panic!("should have a spender key {:?}", spender));
-        assert_eq!(allowances.spender, spender);
-        // We don't check which of the two (0x11, 0x22) got the error vs the result
-        // because it's order dependent and without a custom mock transport just for
-        // this test, we wouldn't be able to make it deterministic
-        assert_eq!(allowances.allowances.len(), 1);
-        assert_eq!(
-            allowances.allowances.values().next(),
-            Some(&U256::from(1337))
-        );
-    }
-}
diff --git a/crates/solver/src/interactions/mod.rs b/crates/solver/src/interactions/mod.rs
index 288f9932ed..08f9098962 100644
--- a/crates/solver/src/interactions/mod.rs
+++ b/crates/solver/src/interactions/mod.rs
@@ -1,4 +1,3 @@
-pub mod allowances;
 mod balancer_v2;
 mod erc20;
 mod uniswap_v2;
diff --git a/crates/solver/src/liquidity/balancer_v2.rs b/crates/solver/src/liquidity/balancer_v2.rs
index 1ca1e2475f..13344f87be 100644
--- a/crates/solver/src/liquidity/balancer_v2.rs
+++ b/crates/solver/src/liquidity/balancer_v2.rs
@@ -2,10 +2,7 @@
 
 use {
     crate::{
-        interactions::{
-            BalancerSwapGivenOutInteraction,
-            allowances::{AllowanceManager, AllowanceManaging, Allowances},
-        },
+        interactions::BalancerSwapGivenOutInteraction,
         liquidity::{
             AmmOrderExecution,
             Liquidity,
@@ -23,7 +20,6 @@ use {
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
         sources::balancer_v2::pool_fetching::BalancerPoolFetching,
-        web3::Web3,
     },
     std::{collections::HashSet, sync::Arc},
     tracing::instrument,
@@ -34,22 +30,18 @@ pub struct BalancerV2Liquidity {
     settlement: Address,
     vault: Address,
     pool_fetcher: Arc<dyn BalancerPoolFetching>,
-    allowance_manager: Box<dyn AllowanceManaging>,
 }
 
 impl BalancerV2Liquidity {
     pub fn new(
-        web3: Web3,
         pool_fetcher: Arc<dyn BalancerPoolFetching>,
         settlement: Address,
         vault: Address,
     ) -> Self {
-        let allowance_manager = AllowanceManager::new(web3, settlement);
         Self {
             settlement,
             vault,
             pool_fetcher,
-            allowance_manager: Box::new(allowance_manager),
         }
     }
 
@@ -60,15 +52,7 @@ impl BalancerV2Liquidity {
     ) -> Result<(Vec<StablePoolOrder>, Vec<WeightedProductOrder>)> {
         let pools = self.pool_fetcher.fetch(pairs, block).await?;
 
-        let tokens = pools.relevant_tokens();
-
-        let allowances = self
-            .allowance_manager
-            .get_allowances(tokens, self.vault)
-            .await?;
-
         let inner = Arc::new(Inner {
-            allowances,
             settlement: self.settlement,
             vault: self.vault,
         });
@@ -134,18 +118,13 @@ pub struct SettlementHandler {
 struct Inner {
     settlement: Address,
     vault: Address,
-    allowances: Allowances,
 }
 
 impl SettlementHandler {
-    pub fn new(pool_id: B256, settlement: Address, vault: Address, allowances: Allowances) -> Self {
+    pub fn new(pool_id: B256, settlement: Address, vault: Address) -> Self {
         SettlementHandler {
             pool_id,
-            inner: Arc::new(Inner {
-                settlement,
-                vault,
-                allowances,
-            }),
+            inner: Arc::new(Inner { settlement, vault }),
         }
     }
 
@@ -202,16 +181,6 @@ impl SettlementHandler {
         execution: AmmOrderExecution,
         encoder: &mut SettlementEncoder,
     ) -> Result<()> {
-        if let Some(approval) = self
-            .inner
-            .allowances
-            .approve_token(execution.input_max.clone())?
-        {
-            encoder.append_to_execution_plan_internalizable(
-                Arc::new(approval),
-                execution.internalizable,
-            );
-        }
         encoder.append_to_execution_plan_internalizable(
             Arc::new(self.swap(execution.input_max, execution.output)),
             execution.internalizable,
@@ -225,10 +194,9 @@ impl SettlementHandler {
 mod tests {
     use {
         super::*,
-        crate::interactions::allowances::{Approval, MockAllowanceManaging},
         alloy::primitives::U256,
         contracts::alloy::BalancerV2Vault,
-        maplit::{btreemap, hashmap, hashset},
+        maplit::{btreemap, hashset},
         mockall::predicate::*,
         model::TokenPair,
         shared::{
@@ -270,7 +238,6 @@ mod tests {
     #[tokio::test]
     async fn fetches_liquidity() {
         let mut pool_fetcher = MockBalancerPoolFetching::new();
-        let mut allowance_manager = MockAllowanceManaging::new();
 
         let weighted_pools = vec![
             WeightedPool {
@@ -378,20 +345,6 @@ mod tests {
                 }
             });
 
-        // Fetches allowances for all tokens in pools.
-        allowance_manager
-            .expect_get_allowances()
-            .with(
-                eq(hashset![
-                    Address::repeat_byte(0x70),
-                    Address::repeat_byte(0x71),
-                    Address::repeat_byte(0x73),
-                    Address::repeat_byte(0xb0),
-                ]),
-                always(),
-            )
-            .returning(|_, _| Ok(Allowances::empty(Address::repeat_byte(0xc1))));
-
         let base_tokens = BaseTokens::new(Address::repeat_byte(0xb0), &[]);
         let traded_pairs = [
             TokenPair::new(
@@ -417,7 +370,6 @@ mod tests {
             settlement,
             vault: *vault.address(),
             pool_fetcher: Arc::new(pool_fetcher),
-            allowance_manager: Box::new(allowance_manager),
         };
         let (stable_orders, weighted_orders) = liquidity_provider
             .get_orders(pairs, Block::Recent)
@@ -463,13 +415,6 @@ mod tests {
         let inner = Arc::new(Inner {
             settlement,
             vault: *vault.address(),
-            allowances: Allowances::new(
-                *vault.address(),
-                hashmap! {
-                    Address::repeat_byte(0x70) => U256::from(0),
-                    Address::repeat_byte(0x71) =>  U256::from(100),
-                },
-            ),
         });
         let handler = SettlementHandler {
             pool_id: B256::repeat_byte(0x90),
@@ -504,11 +449,6 @@ mod tests {
         assert_eq!(
             interactions,
             [
-                Approval {
-                    token: Address::repeat_byte(0x70),
-                    spender: *vault.address(),
-                }
-                .encode(),
                 BalancerSwapGivenOutInteraction {
                     settlement,
                     vault: *vault.address(),
diff --git a/crates/solver/src/liquidity/uniswap_v2.rs b/crates/solver/src/liquidity/uniswap_v2.rs
index f6236a966c..6a79ff3d75 100644
--- a/crates/solver/src/liquidity/uniswap_v2.rs
+++ b/crates/solver/src/liquidity/uniswap_v2.rs
@@ -1,10 +1,7 @@
 use {
     super::{AmmOrderExecution, ConstantProductOrder, SettlementHandling},
     crate::{
-        interactions::{
-            UniswapInteraction,
-            allowances::{AllowanceManager, AllowanceManaging, Allowances, Approval},
-        },
+        interactions::UniswapInteraction,
         liquidity::Liquidity,
         liquidity_collector::LiquidityCollecting,
         settlement::SettlementEncoder,
@@ -16,71 +13,35 @@ use {
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
         sources::uniswap_v2::pool_fetching::PoolFetching,
-        web3::Web3,
-    },
-    std::{
-        collections::HashSet,
-        sync::{Arc, Mutex},
     },
+    std::{collections::HashSet, sync::Arc},
     tracing::instrument,
 };
 
 pub struct UniswapLikeLiquidity {
     inner: Arc<Inner>,
     pool_fetcher: Arc<dyn PoolFetching>,
-    settlement_allowances: Box<dyn AllowanceManaging>,
 }
 
 pub struct Inner {
     router: Address,
     gpv2_settlement: Address,
-    // Mapping of how much allowance the router has per token to spend on behalf of the settlement
-    // contract
-    allowances: Mutex<Allowances>,
 }
 
 impl UniswapLikeLiquidity {
     pub fn new(
         router: Address,
         gpv2_settlement: Address,
-        web3: Web3,
-        pool_fetcher: Arc<dyn PoolFetching>,
-    ) -> Self {
-        let settlement_allowances = Box::new(AllowanceManager::new(web3, gpv2_settlement));
-        Self::with_allowances(router, gpv2_settlement, settlement_allowances, pool_fetcher)
-    }
-
-    pub fn with_allowances(
-        router: Address,
-        gpv2_settlement: Address,
-        settlement_allowances: Box<dyn AllowanceManaging>,
         pool_fetcher: Arc<dyn PoolFetching>,
     ) -> Self {
         Self {
             inner: Arc::new(Inner {
                 router,
                 gpv2_settlement,
-                allowances: Mutex::new(Allowances::empty(router)),
             }),
             pool_fetcher,
-            settlement_allowances,
         }
     }
-
-    async fn cache_allowances(&self, tokens: HashSet<Address>) -> Result<()> {
-        let allowances = self
-            .settlement_allowances
-            .get_allowances(tokens, self.inner.router)
-            .await?;
-
-        self.inner
-            .allowances
-            .lock()
-            .expect("Thread holding mutex panicked")
-            .extend(allowances)?;
-
-        Ok(())
-    }
 }
 
 #[async_trait::async_trait]
@@ -107,17 +68,15 @@ impl LiquidityCollecting for UniswapLikeLiquidity {
                 settlement_handling: self.inner.clone(),
             }))
         }
-        self.cache_allowances(tokens).await?;
         Ok(result)
     }
 }
 
 impl Inner {
-    pub fn new(router: Address, gpv2_settlement: Address, allowances: Mutex<Allowances>) -> Self {
+    pub fn new(router: Address, gpv2_settlement: Address) -> Self {
         Inner {
             router,
             gpv2_settlement,
-            allowances,
         }
     }
 
@@ -125,24 +84,15 @@ impl Inner {
         &self,
         token_amount_in_max: TokenAmount,
         token_amount_out: TokenAmount,
-    ) -> (Option<Approval>, UniswapInteraction) {
-        let approval = self
-            .allowances
-            .lock()
-            .expect("Thread holding mutex panicked")
-            .approve_token_or_default(token_amount_in_max.clone());
-
-        (
-            approval,
-            UniswapInteraction {
-                router: self.router,
-                settlement: self.gpv2_settlement,
-                amount_out: token_amount_out.amount,
-                amount_in_max: token_amount_in_max.amount,
-                token_in: token_amount_in_max.token,
-                token_out: token_amount_out.token,
-            },
-        )
+    ) -> UniswapInteraction {
+        UniswapInteraction {
+            router: self.router,
+            settlement: self.gpv2_settlement,
+            amount_out: token_amount_out.amount,
+            amount_in_max: token_amount_in_max.amount,
+            token_in: token_amount_in_max.token,
+            token_out: token_amount_out.token,
+        }
     }
 
     pub fn router(&self) -> Address {
@@ -158,78 +108,8 @@ impl SettlementHandling<ConstantProductOrder> for Inner {
     // Creates the required interaction to convert the given input into output.
     // Assumes slippage is already applied to `input_max`.
     fn encode(&self, execution: AmmOrderExecution, encoder: &mut SettlementEncoder) -> Result<()> {
-        let (approval, swap) = self.settle(execution.input_max, execution.output);
-        if let Some(approval) = approval {
-            encoder.append_to_execution_plan_internalizable(
-                Arc::new(approval),
-                execution.internalizable,
-            );
-        }
-        encoder.append_to_execution_plan_internalizable(Arc::new(swap), execution.internalizable);
+        let swap = Arc::new(self.settle(execution.input_max, execution.output));
+        encoder.append_to_execution_plan_internalizable(swap, execution.internalizable);
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        alloy::primitives::{Address, U256},
-        std::collections::HashMap,
-    };
-
-    impl Inner {
-        fn new_dummy(allowances: HashMap<Address, U256>) -> Self {
-            Self {
-                router: Address::default(),
-                gpv2_settlement: Default::default(),
-                allowances: Mutex::new(Allowances::new(Address::ZERO, allowances)),
-            }
-        }
-    }
-
-    #[test]
-    fn test_should_set_allowance() {
-        let token_a = Address::with_last_byte(1);
-        let token_b = Address::with_last_byte(2);
-        let allowances = maplit::hashmap! {
-            token_a => U256::from(100),
-            token_b => U256::from(200),
-        };
-
-        let inner = Inner::new_dummy(allowances);
-
-        // Token A below, equal, above
-        let (approval, _) = inner.settle(
-            TokenAmount::new(token_a, U256::from(50)),
-            TokenAmount::new(token_b, U256::from(100)),
-        );
-        assert_eq!(approval, None);
-
-        let (approval, _) = inner.settle(
-            TokenAmount::new(token_a, U256::from(99)),
-            TokenAmount::new(token_b, U256::from(100)),
-        );
-        assert_eq!(approval, None);
-
-        // Token B below, equal, above
-        let (approval, _) = inner.settle(
-            TokenAmount::new(token_b, U256::from(150)),
-            TokenAmount::new(token_a, U256::from(100)),
-        );
-        assert_eq!(approval, None);
-
-        let (approval, _) = inner.settle(
-            TokenAmount::new(token_b, U256::from(199)),
-            TokenAmount::new(token_a, U256::from(100)),
-        );
-        assert_eq!(approval, None);
-
-        // Untracked token
-        let (approval, _) = inner.settle(
-            TokenAmount::new(Address::with_last_byte(3), U256::from(1)),
-            TokenAmount::new(token_a, U256::from(100)),
-        );
-        assert_ne!(approval, None);
-    }
-}
diff --git a/crates/solver/src/liquidity/uniswap_v3.rs b/crates/solver/src/liquidity/uniswap_v3.rs
index b3e2b4034b..179a240e0c 100644
--- a/crates/solver/src/liquidity/uniswap_v3.rs
+++ b/crates/solver/src/liquidity/uniswap_v3.rs
@@ -1,10 +1,7 @@
 use {
     super::{AmmOrderExecution, ConcentratedLiquidity, SettlementHandling},
     crate::{
-        interactions::{
-            UniswapV3Interaction,
-            allowances::{AllowanceManager, AllowanceManaging, Allowances, Approval},
-        },
+        interactions::UniswapV3Interaction,
         liquidity::Liquidity,
         liquidity_collector::LiquidityCollecting,
         settlement::SettlementEncoder,
@@ -18,26 +15,18 @@ use {
         http_solver::model::TokenAmount,
         recent_block_cache::Block,
         sources::uniswap_v3::pool_fetching::PoolFetching,
-        web3::Web3,
-    },
-    std::{
-        collections::HashSet,
-        sync::{Arc, Mutex},
     },
+    std::{collections::HashSet, sync::Arc},
     tracing::instrument,
 };
 
 pub struct UniswapV3Liquidity {
     inner: Arc<Inner>,
     pool_fetcher: Arc<dyn PoolFetching>,
-    settlement_allowances: Box<dyn AllowanceManaging>,
 }
 pub struct Inner {
     pub router: Address,
     gpv2_settlement: Address,
-    // Mapping of how much allowance the router has per token to spend on behalf of the settlement
-    // contract
-    allowances: Mutex<Allowances>,
 }
 
 pub struct UniswapV3SettlementHandler {
@@ -46,17 +35,11 @@ pub struct UniswapV3SettlementHandler {
 }
 
 impl UniswapV3SettlementHandler {
-    pub fn new(
-        router: Address,
-        gpv2_settlement: Address,
-        allowances: Mutex<Allowances>,
-        fee: Ratio<u32>,
-    ) -> Self {
+    pub fn new(router: Address, gpv2_settlement: Address, fee: Ratio<u32>) -> Self {
         Self {
             inner: Arc::new(Inner {
                 router,
                 gpv2_settlement,
-                allowances,
             }),
             fee: ratio_to_u32(fee).unwrap(),
         }
@@ -80,36 +63,16 @@ impl UniswapV3Liquidity {
     pub fn new(
         router: Address,
         gpv2_settlement: Address,
-        web3: Web3,
         pool_fetcher: Arc<dyn PoolFetching>,
     ) -> Self {
-        let settlement_allowances = Box::new(AllowanceManager::new(web3, gpv2_settlement));
         Self {
             inner: Arc::new(Inner {
                 router,
                 gpv2_settlement,
-                allowances: Mutex::new(Allowances::empty(router)),
             }),
             pool_fetcher,
-            settlement_allowances,
         }
     }
-
-    async fn cache_allowances(&self, tokens: HashSet<Address>) -> Result<()> {
-        let router = self.inner.router;
-        let allowances = self
-            .settlement_allowances
-            .get_allowances(tokens, router)
-            .await?;
-
-        self.inner
-            .allowances
-            .lock()
-            .expect("Thread holding mutex panicked")
-            .extend(allowances)?;
-
-        Ok(())
-    }
 }
 
 #[async_trait::async_trait]
@@ -144,7 +107,6 @@ impl LiquidityCollecting for UniswapV3Liquidity {
                 pool,
             }))
         }
-        self.cache_allowances(tokens).await?;
         Ok(result)
     }
 }
@@ -154,31 +116,21 @@ impl UniswapV3SettlementHandler {
         &self,
         token_amount_in_max: TokenAmount,
         token_amount_out: TokenAmount,
-    ) -> (Option<Approval>, UniswapV3Interaction) {
-        let approval = self
-            .inner
-            .allowances
-            .lock()
-            .expect("Thread holding mutex panicked")
-            .approve_token_or_default(token_amount_in_max.clone());
-
+    ) -> UniswapV3Interaction {
         let fee = self.fee.try_into().expect("fee < (1 << 24)");
 
-        (
-            approval,
-            UniswapV3Interaction {
-                router: self.inner.router,
-                params: ExactOutputSingleParams {
-                    tokenIn: token_amount_in_max.token,
-                    tokenOut: token_amount_out.token,
-                    fee,
-                    recipient: self.inner.gpv2_settlement,
-                    amountOut: token_amount_out.amount,
-                    amountInMaximum: token_amount_in_max.amount,
-                    sqrtPriceLimitX96: alloy::primitives::U160::ZERO,
-                },
+        UniswapV3Interaction {
+            router: self.inner.router,
+            params: ExactOutputSingleParams {
+                tokenIn: token_amount_in_max.token,
+                tokenOut: token_amount_out.token,
+                fee,
+                recipient: self.inner.gpv2_settlement,
+                amountOut: token_amount_out.amount,
+                amountInMaximum: token_amount_in_max.amount,
+                sqrtPriceLimitX96: alloy::primitives::U160::ZERO,
             },
-        )
+        }
     }
 }
 
@@ -190,109 +142,15 @@ impl SettlementHandling<ConcentratedLiquidity> for UniswapV3SettlementHandler {
     // Creates the required interaction to convert the given input into output.
     // Assumes slippage is already applied to the `input_max` field.
     fn encode(&self, execution: AmmOrderExecution, encoder: &mut SettlementEncoder) -> Result<()> {
-        let (approval, swap) = self.settle(execution.input_max, execution.output);
-        if let Some(approval) = approval {
-            encoder.append_to_execution_plan_internalizable(
-                Arc::new(approval),
-                execution.internalizable,
-            );
-        }
-        encoder.append_to_execution_plan_internalizable(Arc::new(swap), execution.internalizable);
+        let swap = Arc::new(self.settle(execution.input_max, execution.output));
+        encoder.append_to_execution_plan_internalizable(swap, execution.internalizable);
         Ok(())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use {super::*, alloy::primitives::U256, num::rational::Ratio, std::collections::HashMap};
-
-    impl UniswapV3SettlementHandler {
-        fn new_dummy(allowances: HashMap<Address, U256>, fee: u32) -> Self {
-            Self {
-                inner: Arc::new(Inner {
-                    router: Default::default(),
-                    gpv2_settlement: Default::default(),
-                    allowances: Mutex::new(Allowances::new(Address::ZERO, allowances)),
-                }),
-                fee,
-            }
-        }
-    }
-
-    #[test]
-    fn test_should_set_allowance() {
-        let token_a = Address::with_last_byte(1);
-        let token_b = Address::with_last_byte(2);
-        let allowances = maplit::hashmap! {
-            token_a => U256::from(100),
-            token_b => U256::from(200),
-        };
-
-        let settlement_handler = UniswapV3SettlementHandler::new_dummy(allowances, 10);
-
-        // Token A below, equal, above
-        let (approval, _) = settlement_handler.settle(
-            TokenAmount {
-                token: token_a,
-                amount: U256::from(50),
-            },
-            TokenAmount {
-                token: token_b,
-                amount: U256::from(100),
-            },
-        );
-        assert_eq!(approval, None);
-
-        let (approval, _) = settlement_handler.settle(
-            TokenAmount {
-                token: token_a,
-                amount: U256::from(99),
-            },
-            TokenAmount {
-                token: token_b,
-                amount: U256::from(100),
-            },
-        );
-        assert_eq!(approval, None);
-
-        // Token B below, equal, above
-        let (approval, _) = settlement_handler.settle(
-            TokenAmount {
-                token: token_b,
-                amount: U256::from(150),
-            },
-            TokenAmount {
-                token: token_a,
-                amount: U256::from(100),
-            },
-        );
-        assert_eq!(approval, None);
-
-        let (approval, _) = settlement_handler.settle(
-            TokenAmount {
-                token: token_b,
-                amount: U256::from(199),
-            },
-            TokenAmount {
-                token: token_a,
-                amount: U256::from(100),
-            },
-        );
-        assert_eq!(approval, None);
-
-        // Untracked token
-        let (approval, _) = settlement_handler.settle(
-            TokenAmount {
-                token: Address::with_last_byte(3),
-                amount: U256::from(1),
-            },
-            TokenAmount {
-                token: token_a,
-                amount: U256::from(100),
-            },
-        );
-        assert_ne!(approval, None);
-    }
+    use {super::*, num::rational::Ratio};
 
     #[test]
     fn test_ratio_to_u32() {
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index e6cf0f13e9..542aa152e9 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -1,10 +1,7 @@
 use {
     super::{LimitOrderExecution, LimitOrderId, LiquidityOrderId, SettlementHandling},
     crate::{
-        interactions::{
-            ZeroExInteraction,
-            allowances::{AllowanceManager, AllowanceManaging, Allowances},
-        },
+        interactions::ZeroExInteraction,
         liquidity::{Exchange, LimitOrder, Liquidity},
         liquidity_collector::LiquidityCollecting,
         settlement::SettlementEncoder,
@@ -18,9 +15,7 @@ use {
     itertools::Itertools,
     model::{TokenPair, order::OrderKind},
     shared::{
-        http_solver::model::TokenAmount,
         recent_block_cache::Block,
-        web3::Web3,
         zeroex_api::{OrderRecord, OrdersQuery, ZeroExApi},
     },
     std::{
@@ -36,19 +31,16 @@ type OrderbookCache = ArcSwap<OrderBuckets>;
 pub struct ZeroExLiquidity {
     // todo: remove Arc
     pub zeroex: Arc<IZeroex::Instance>,
-    pub allowance_manager: Box<dyn AllowanceManaging>,
     pub orderbook_cache: Arc<OrderbookCache>,
 }
 
 impl ZeroExLiquidity {
     pub async fn new(
-        web3: Web3,
         api: Arc<dyn ZeroExApi>,
         zeroex: IZeroex::Instance,
         gpv2: Address,
         blocks_stream: CurrentBlockWatcher,
     ) -> Self {
-        let allowance_manager = AllowanceManager::new(web3, gpv2);
         let orderbook_cache: Arc<OrderbookCache> = Default::default();
         let cache = orderbook_cache.clone();
         tokio::spawn(
@@ -57,17 +49,12 @@ impl ZeroExLiquidity {
 
         Self {
             zeroex: Arc::new(zeroex),
-            allowance_manager: Box::new(allowance_manager),
             orderbook_cache,
         }
     }
 
     /// Turns 0x OrderRecord into liquidity which solvers can use.
-    fn record_into_liquidity(
-        &self,
-        record: OrderRecord,
-        allowances: Arc<Allowances>,
-    ) -> Option<Liquidity> {
+    fn record_into_liquidity(&self, record: OrderRecord) -> Option<Liquidity> {
         let sell_amount = U256::from(record.remaining_maker_amount().ok()?);
         if sell_amount.is_zero() || record.metadata().remaining_fillable_taker_amount == 0 {
             // filter out orders with 0 amounts to prevent errors in the solver
@@ -88,7 +75,6 @@ impl ZeroExLiquidity {
             settlement_handling: Arc::new(OrderSettlementHandler {
                 order_record: record,
                 zeroex: self.zeroex.clone(),
-                allowances,
             }),
             exchange: Exchange::ZeroEx,
         };
@@ -137,20 +123,10 @@ impl LiquidityCollecting for ZeroExLiquidity {
     ) -> Result<Vec<Liquidity>> {
         let zeroex_order_buckets = self.orderbook_cache.load();
         let filtered_zeroex_orders = get_useful_orders(zeroex_order_buckets.as_ref(), &pairs, 5);
-        let tokens: HashSet<_> = filtered_zeroex_orders
-            .iter()
-            .map(|o| o.order().taker_token)
-            .collect();
-
-        let allowances = Arc::new(
-            self.allowance_manager
-                .get_allowances(tokens, *self.zeroex.address())
-                .await?,
-        );
 
         let zeroex_liquidity_orders: Vec<_> = filtered_zeroex_orders
             .into_iter()
-            .flat_map(|order| self.record_into_liquidity(order, allowances.clone()))
+            .flat_map(|order| self.record_into_liquidity(order))
             .collect();
 
         Ok(zeroex_liquidity_orders)
@@ -213,7 +189,6 @@ pub struct OrderSettlementHandler {
     pub order_record: OrderRecord,
     // todo: remove Arc
     pub zeroex: Arc<IZeroex::Instance>,
-    allowances: Arc<Allowances>,
 }
 
 impl SettlementHandling<LimitOrder> for OrderSettlementHandler {
@@ -229,13 +204,6 @@ impl SettlementHandling<LimitOrder> for OrderSettlementHandler {
         let Ok(execution_filled) = u128::try_from(execution.filled) else {
             anyhow::bail!("0x only supports executed amounts of size u128");
         };
-        let approval = self.allowances.approve_token(TokenAmount::new(
-            self.order_record.order().taker_token,
-            execution.filled,
-        ))?;
-        if let Some(approval) = approval {
-            encoder.append_to_execution_plan(Arc::new(approval));
-        }
         encoder.append_to_execution_plan(Arc::new(ZeroExInteraction {
             taker_token_fill_amount: execution_filled,
             order: self.order_record.order().clone(),
@@ -249,8 +217,6 @@ impl SettlementHandling<LimitOrder> for OrderSettlementHandler {
 pub mod tests {
     use {
         super::*,
-        crate::interactions::allowances::Approval,
-        maplit::hashmap,
         shared::{
             baseline_solver::BaseTokens,
             http_solver::model::InternalizationStrategy,
@@ -379,62 +345,12 @@ pub mod tests {
     }
 
     #[tokio::test]
-    async fn interaction_encodes_approval_when_insufficient() {
-        let sell_token = Address::with_last_byte(1);
-        let zeroex = Arc::new(IZeroex::Instance::new(
-            Default::default(),
-            ethrpc::mock::web3().provider,
-        ));
-        let allowances =
-            Allowances::new(*zeroex.address(), hashmap! { sell_token => U256::from(99) });
-        let order_record = OrderRecord::new(
-            zeroex_api::Order {
-                taker_amount: 100,
-                taker_token: sell_token,
-                ..Default::default()
-            },
-            OrderMetadata::default(),
-        );
-        let handler = OrderSettlementHandler {
-            order_record: order_record.clone(),
-            zeroex: zeroex.clone(),
-            allowances: Arc::new(allowances),
-        };
-        let mut encoder = SettlementEncoder::default();
-        let execution = LimitOrderExecution::new(U256::from(100), U256::ZERO);
-        handler.encode(execution, &mut encoder).unwrap();
-        let [_, interactions, _] = encoder
-            .finish(InternalizationStrategy::SkipInternalizableInteraction)
-            .interactions;
-        assert_eq!(
-            interactions,
-            [
-                Approval {
-                    token: sell_token,
-                    spender: *zeroex.address(),
-                }
-                .encode(),
-                ZeroExInteraction {
-                    order: order_record.order().clone(),
-                    taker_token_fill_amount: 100,
-                    zeroex: zeroex.clone(),
-                }
-                .encode(),
-            ],
-        );
-    }
-
-    #[tokio::test]
-    async fn interaction_encodes_no_approval_when_sufficient() {
+    async fn interaction_encoding() {
         let sell_token = Address::with_last_byte(1);
         let zeroex = Arc::new(IZeroex::Instance::new(
             Default::default(),
             ethrpc::mock::web3().provider,
         ));
-        let allowances = Allowances::new(
-            *zeroex.address(),
-            hashmap! { sell_token => U256::from(100) },
-        );
         let order_record = OrderRecord::new(
             zeroex_api::Order {
                 taker_amount: 100,
@@ -446,7 +362,6 @@ pub mod tests {
         let handler = OrderSettlementHandler {
             order_record: order_record.clone(),
             zeroex: zeroex.clone(),
-            allowances: Arc::new(allowances),
         };
         let mut encoder = SettlementEncoder::default();
         let execution = LimitOrderExecution::new(U256::from(100), U256::ZERO);

From 47ea62907df3c87f8cfff375e5504104c2c5aa1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 25 Feb 2026 14:43:15 +0000
Subject: [PATCH 106/219] Migrate autopilot native price estimation config from
 CLI args to config file (#4194)

# Description
Move native price estimator settings (estimators, api_estimators,
results_required, cache_refresh_interval, native_price_prefetch_time)
from CLI arguments to the TOML config file.

# Changes

* Move the autopilot native price estimator settings
* Add tests

# Migration Guide

Autopilot native price estimator CLI arguments have been moved to the
TOML config file under the `[native-price-estimation]` table.

## Estimator format

Previously, estimator variants were specified as `|`-separated strings.
Now they are inline tables with a `type` field:

| Old (CLI) | New (TOML) |
|---|---|
| `CoinGecko` | `{ type = "CoinGecko" }` |
| `OneInchSpotPriceApi` | `{ type = "OneInchSpotPriceApi" }` |
| `Driver\|solver1\|http://localhost:8080` | `{ type = "Driver", name =
"solver1", url = "http://localhost:8080" }` |
| `Forwarder\|http://localhost:12088` | `{ type = "Forwarder", url =
"http://localhost:12088" }` |

Stages (previously separated by `;`) become separate inner arrays.
Estimators within a stage (previously separated by `,`) are elements of
the same inner array.

**Old (CLI):**
```
CoinGecko,OneInchSpotPriceApi;Driver|solver1|http://localhost:8080;Forwarder|http://localhost:12088
```

**New (TOML):**
```toml
[native-price-estimation]
estimators = [
    [{ type = "CoinGecko" }, { type = "OneInchSpotPriceApi" }],
    [{ type = "Driver", name = "solver1", url = "http://localhost:8080" }],
    [{ type = "Forwarder", url = "http://localhost:12088" }],
]
```

## Arguments

- `--native-price-estimators` (CLI) / `NATIVE_PRICE_ESTIMATORS` (env):
```toml
[native-price-estimation]
estimators = []
```

- `--api-native-price-estimators` (CLI) / `API_NATIVE_PRICE_ESTIMATORS`
(env):
```toml
[native-price-estimation]
api-estimators = []
```

- `--native-price-estimation-results-required` (CLI) /
`NATIVE_PRICE_ESTIMATION_RESULTS_REQUIRED` (env):
```toml
[native-price-estimation]
results-required = 2
```

- `--native-price-cache-refresh` (CLI) / `NATIVE_PRICE_CACHE_REFRESH`
(env):
```toml
[native-price-estimation]
cache-refresh-interval = "1s"
```

- `--native-price-prefetch-time` (CLI) / `NATIVE_PRICE_PREFETCH_TIME`
(env):
```toml
[native-price-estimation]
prefetch-time = "80s"
```


## How to test
Staging

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 Cargo.lock                                    |   1 +
 crates/autopilot/src/arguments.rs             |  64 +---------
 crates/autopilot/src/config/mod.rs            |  33 ++++-
 crates/autopilot/src/config/native_price.rs   | 118 ++++++++++++++++++
 crates/autopilot/src/run.rs                   |  17 +--
 crates/e2e/src/setup/services.rs              |  73 ++++++++---
 crates/shared/Cargo.toml                      |   1 +
 crates/shared/src/price_estimation/factory.rs |   2 +-
 crates/shared/src/price_estimation/mod.rs     | 111 ++++++++++++++--
 9 files changed, 319 insertions(+), 101 deletions(-)
 create mode 100644 crates/autopilot/src/config/native_price.rs

diff --git a/Cargo.lock b/Cargo.lock
index dd95b2d56c..837712e4b9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6381,6 +6381,7 @@ dependencies = [
  "testlib",
  "thiserror 1.0.69",
  "tokio",
+ "toml",
  "tracing",
  "tracing-subscriber",
  "url",
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 223239c730..0e88364672 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -5,7 +5,7 @@ use {
     shared::{
         arguments::{display_option, display_secret_option},
         http_client,
-        price_estimation::{self, NativePriceEstimators},
+        price_estimation::{self},
     },
     std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf, str::FromStr, time::Duration},
     url::Url,
@@ -69,25 +69,6 @@ pub struct CliArguments {
     #[clap(long, env, use_value_delimiter = true)]
     pub unsupported_tokens: Vec<Address>,
 
-    /// Which estimators to use to estimate token prices in terms of the chain's
-    /// native token. Estimators with the same name need to also be specified as
-    /// built-in, legacy or external price estimators (lookup happens in this
-    /// order in case of name collisions)
-    #[clap(long, env)]
-    pub native_price_estimators: NativePriceEstimators,
-
-    /// Estimators for the API endpoint. Falls back to
-    /// `--native-price-estimators` if unset.
-    #[clap(long, env)]
-    pub api_native_price_estimators: Option<NativePriceEstimators>,
-
-    /// How many successful price estimates for each order will cause a native
-    /// price estimation to return its result early. It's possible to pass
-    /// values greater than the total number of enabled estimators but that
-    /// will not have any further effect.
-    #[clap(long, env, default_value = "2")]
-    pub native_price_estimation_results_required: NonZeroUsize,
-
     /// The minimum amount of time an order has to be valid for.
     #[clap(
         long,
@@ -195,26 +176,6 @@ pub struct CliArguments {
     /// further.
     #[clap(long, env, default_value = "5s", value_parser = humantime::parse_duration)]
     pub max_maintenance_timeout: Duration,
-
-    /// How often the native price estimator should refresh its cache.
-    #[clap(
-        long,
-        env,
-        default_value = "1s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub native_price_cache_refresh: Duration,
-
-    /// How long before expiry the native price cache should try to update the
-    /// price in the background. This value has to be smaller than
-    /// `--native-price-cache-max-age`.
-    #[clap(
-        long,
-        env,
-        default_value = "80s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub native_price_prefetch_time: Duration,
 }
 
 impl std::fmt::Display for CliArguments {
@@ -232,8 +193,6 @@ impl std::fmt::Display for CliArguments {
             api_address,
             skip_event_sync,
             unsupported_tokens,
-            native_price_estimators,
-            api_native_price_estimators,
             min_order_validity_period,
             max_auction_age,
             submission_deadline,
@@ -241,7 +200,6 @@ impl std::fmt::Display for CliArguments {
             solve_deadline,
             db_write_url,
             insert_batch_size,
-            native_price_estimation_results_required,
             max_settlement_transaction_wait,
             cow_amm_configs,
             max_run_loop_delay,
@@ -252,8 +210,6 @@ impl std::fmt::Display for CliArguments {
             disable_order_balance_filter,
             enable_leader_lock,
             max_maintenance_timeout,
-            native_price_cache_refresh,
-            native_price_prefetch_time,
         } = self;
         write!(f, "{}", config.display())?;
         write!(f, "{shared}")?;
@@ -268,12 +224,6 @@ impl std::fmt::Display for CliArguments {
         display_secret_option(f, "db_write_url", Some(&db_write_url))?;
         writeln!(f, "skip_event_sync: {skip_event_sync}")?;
         writeln!(f, "unsupported_tokens: {unsupported_tokens:?}")?;
-        writeln!(f, "native_price_estimators: {native_price_estimators}")?;
-        display_option(
-            f,
-            "api_native_price_estimators",
-            api_native_price_estimators,
-        )?;
         writeln!(
             f,
             "min_order_validity_period: {min_order_validity_period:?}"
@@ -283,10 +233,6 @@ impl std::fmt::Display for CliArguments {
         display_option(f, "shadow", shadow)?;
         writeln!(f, "solve_deadline: {solve_deadline:?}")?;
         writeln!(f, "insert_batch_size: {insert_batch_size}")?;
-        writeln!(
-            f,
-            "native_price_estimation_results_required: {native_price_estimation_results_required}"
-        )?;
         writeln!(
             f,
             "max_settlement_transaction_wait: {max_settlement_transaction_wait:?}"
@@ -306,14 +252,6 @@ impl std::fmt::Display for CliArguments {
         )?;
         writeln!(f, "enable_leader_lock: {enable_leader_lock}")?;
         writeln!(f, "max_maintenance_timeout: {max_maintenance_timeout:?}")?;
-        writeln!(
-            f,
-            "native_price_cache_refresh: {native_price_cache_refresh:?}"
-        )?;
-        writeln!(
-            f,
-            "native_price_prefetch_time: {native_price_prefetch_time:?}"
-        )?;
         Ok(())
     }
 }
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index 0cee73ffff..8edce0979c 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -2,6 +2,7 @@ use {
     crate::config::{
         banned_users::BannedUsersConfig,
         fee_policy::FeePoliciesConfig,
+        native_price::NativePriceConfig,
         order_events_cleanup::OrderEventsCleanupConfig,
         s3::S3Config,
         solver::Solver,
@@ -14,6 +15,7 @@ use {
 
 pub mod banned_users;
 pub mod fee_policy;
+pub mod native_price;
 pub mod order_events_cleanup;
 pub mod s3;
 pub mod solver;
@@ -44,8 +46,9 @@ pub struct Configuration {
 
     /// Configuration for uploading auction instances to S3.
     /// If absent, S3 uploads are disabled.
-    #[serde(default)]
     pub s3: Option<S3Config>,
+
+    pub native_price_estimation: NativePriceConfig,
 }
 
 impl Configuration {
@@ -169,6 +172,13 @@ mod tests {
         [s3]
         bucket = "my-bucket"
         filename-prefix = "staging/mainnet/"
+
+        [native-price-estimation]
+        estimators = [
+            [{type = "CoinGecko"}, {type = "OneInchSpotPriceApi"}],
+            [{type = "Driver", name = "solver1", url = "http://localhost:8080"}],
+            [{type = "Forwarder", url = "http://localhost:12088"}],
+        ]
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -231,6 +241,24 @@ mod tests {
         let s3 = config.s3.unwrap();
         assert_eq!(s3.bucket, "my-bucket");
         assert_eq!(s3.filename_prefix, "staging/mainnet/");
+
+        use shared::price_estimation::{ExternalSolver, NativePriceEstimator};
+        assert_eq!(
+            config.native_price_estimation.estimators.as_slice(),
+            vec![
+                vec![
+                    NativePriceEstimator::CoinGecko,
+                    NativePriceEstimator::OneInchSpotPriceApi,
+                ],
+                vec![NativePriceEstimator::Driver(ExternalSolver {
+                    name: "solver1".to_string(),
+                    url: "http://localhost:8080".parse().unwrap(),
+                })],
+                vec![NativePriceEstimator::Forwarder {
+                    url: "http://localhost:12088".parse().unwrap(),
+                }],
+            ]
+        );
     }
 
     #[test]
@@ -242,6 +270,9 @@ mod tests {
         submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 
         [fee-policies]
+
+        [native-price-estimation]
+        estimators = []
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
diff --git a/crates/autopilot/src/config/native_price.rs b/crates/autopilot/src/config/native_price.rs
new file mode 100644
index 0000000000..3713d97320
--- /dev/null
+++ b/crates/autopilot/src/config/native_price.rs
@@ -0,0 +1,118 @@
+use {
+    serde::{Deserialize, Serialize},
+    shared::price_estimation::NativePriceEstimators,
+    std::{num::NonZeroUsize, time::Duration},
+};
+
+const fn default_native_price_estimation_results_required() -> NonZeroUsize {
+    NonZeroUsize::new(2).expect("value should not be zero")
+}
+
+const fn default_native_price_cache_refresh() -> Duration {
+    Duration::from_secs(1)
+}
+
+const fn default_native_price_prefetch_time() -> Duration {
+    Duration::from_secs(80)
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct NativePriceConfig {
+    /// Which estimators to use to estimate token prices in terms of the chain's
+    /// native token. Estimators with the same name need to also be specified as
+    /// built-in, legacy or external price estimators (lookup happens in this
+    /// order in case of name collisions)
+    pub estimators: NativePriceEstimators,
+
+    /// Estimators for the API endpoint. Falls back to
+    /// `--native-price-estimators` if unset.
+    pub api_estimators: Option<NativePriceEstimators>,
+
+    /// How many successful price estimates for each order will cause a native
+    /// price estimation to return its result early. It's possible to pass
+    /// values greater than the total number of enabled estimators but that
+    /// will not have any further effect.
+    #[serde(default = "default_native_price_estimation_results_required")]
+    pub results_required: NonZeroUsize,
+
+    /// How often the native price estimator should check for prices that need
+    /// to be udpated.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_native_price_cache_refresh"
+    )]
+    pub cache_refresh_interval: Duration,
+
+    /// How long before expiry the native price cache should try to update the
+    /// price in the background. This value has to be smaller than
+    /// `--native-price-cache-max-age`.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_native_price_prefetch_time"
+    )]
+    pub prefetch_time: Duration,
+}
+
+impl Default for NativePriceConfig {
+    fn default() -> Self {
+        Self {
+            estimators: Default::default(),
+            api_estimators: Default::default(),
+            results_required: default_native_price_estimation_results_required(),
+            cache_refresh_interval: default_native_price_cache_refresh(),
+            prefetch_time: default_native_price_prefetch_time(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let toml = r#"
+        estimators = []
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert!(config.estimators.as_slice().is_empty());
+        assert!(config.api_estimators.is_none());
+        assert_eq!(config.results_required.get(), 2);
+        assert_eq!(config.cache_refresh_interval, Duration::from_secs(1));
+        assert_eq!(config.prefetch_time, Duration::from_secs(80));
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        estimators = [[{type = "CoinGecko"}]]
+        api-estimators = [[{type = "OneInchSpotPriceApi"}]]
+        results-required = 3
+        cache-refresh-interval = "30s"
+        prefetch-time = "2m"
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.estimators.as_slice().len(), 1);
+        assert!(config.api_estimators.is_some());
+        assert_eq!(config.results_required.get(), 3);
+        assert_eq!(config.cache_refresh_interval, Duration::from_secs(30));
+        assert_eq!(config.prefetch_time, Duration::from_secs(120));
+    }
+
+    #[test]
+    fn missing_estimators_fails() {
+        let toml = "";
+        assert!(toml::from_str::<NativePriceConfig>(toml).is_err());
+    }
+
+    #[test]
+    fn default_impl() {
+        let config = NativePriceConfig::default();
+        assert!(config.estimators.as_slice().is_empty());
+        assert!(config.api_estimators.is_none());
+        assert_eq!(config.results_required.get(), 2);
+        assert_eq!(config.cache_refresh_interval, Duration::from_secs(1));
+        assert_eq!(config.prefetch_time, Duration::from_secs(80));
+    }
+}
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index e019f4e87d..9d9777b385 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -316,15 +316,16 @@ pub async fn run(
         args.price_estimation.native_price_cache_max_age,
         prices,
     );
-    let api_sources = args
-        .api_native_price_estimators
+    let api_sources = config
+        .native_price_estimation
+        .api_estimators
         .as_ref()
-        .unwrap_or(&args.native_price_estimators);
+        .unwrap_or(&config.native_price_estimation.estimators);
     let api_native_price_estimator: Arc<dyn NativePriceEstimating> = Arc::new(
         price_estimator_factory
             .caching_native_price_estimator(
                 api_sources.as_slice(),
-                args.native_price_estimation_results_required,
+                config.native_price_estimation.results_required,
                 &weth,
                 shared_cache.clone(),
             )
@@ -335,8 +336,8 @@ pub async fn run(
     let competition_native_price_updater = {
         let caching = price_estimator_factory
             .caching_native_price_estimator(
-                args.native_price_estimators.as_slice(),
-                args.native_price_estimation_results_required,
+                config.native_price_estimation.estimators.as_slice(),
+                config.native_price_estimation.results_required,
                 &weth,
                 shared_cache.clone(),
             )
@@ -344,8 +345,8 @@ pub async fn run(
             .await;
         shared::price_estimation::native_price_cache::NativePriceUpdater::new(
             caching,
-            args.native_price_cache_refresh,
-            args.native_price_prefetch_time,
+            config.native_price_estimation.cache_refresh_interval,
+            config.native_price_estimation.prefetch_time,
         )
     };
 
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 9410622e23..099c5819f5 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -15,7 +15,10 @@ use {
         providers::ext::AnvilApi,
     },
     app_data::{AppDataDocument, AppDataHash},
-    autopilot::{config::Configuration, infra::persistence::dto},
+    autopilot::{
+        config::{Configuration, native_price::NativePriceConfig},
+        infra::persistence::dto,
+    },
     clap::Parser,
     model::{
         AuctionId,
@@ -26,7 +29,10 @@ use {
         trade::Trade,
     },
     reqwest::{Client, StatusCode, Url},
-    shared::web3::Web3,
+    shared::{
+        price_estimation::{NativePriceEstimator, NativePriceEstimators},
+        web3::Web3,
+    },
     sqlx::Connection,
     std::{
         collections::{HashMap, hash_map::Entry},
@@ -132,7 +138,6 @@ impl<'a> Services<'a> {
 
     fn api_autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
         [
-            "--native-price-estimators=Forwarder|http://localhost:12088".to_string(),
             "--amount-to-estimate-prices-with=1000000000000000000".to_string(),
             "--block-stream-poll-interval=1s".to_string(),
             format!("--node-ws-url={NODE_WS_HOST}"),
@@ -147,12 +152,8 @@ impl<'a> Services<'a> {
     }
 
     fn autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
-        self.api_autopilot_arguments().chain([
-            "--quote-timeout=10s".to_string(),
-            "--native-price-prefetch-time=500ms".to_string(),
-            "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
-                .to_string(),
-        ])
+        self.api_autopilot_arguments()
+            .chain(["--quote-timeout=10s".to_string()])
     }
 
     fn api_autopilot_solver_arguments(&self) -> impl Iterator<Item = String> + use<> {
@@ -219,9 +220,17 @@ impl<'a> Services<'a> {
         let args = autopilot::arguments::CliArguments::try_parse_from(args)
             .map_err(|err| err.to_string())
             .unwrap();
-        let config = autopilot::config::Configuration::from_path(&args.config)
-            .await
-            .unwrap();
+        let config = Configuration {
+            native_price_estimation: NativePriceConfig {
+                estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
+                    "test_quoter".to_string(),
+                    Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                )]]),
+                prefetch_time: Duration::from_millis(500),
+                ..Default::default()
+            },
+            ..Configuration::from_path(&args.config).await.unwrap()
+        };
         tracing::info!("Loaded config: {:?}", config);
         let join_handle = tokio::task::spawn(autopilot::run(args, config, control));
         self.wait_until_autopilot_ready().await;
@@ -254,8 +263,8 @@ impl<'a> Services<'a> {
             "orderbook".to_string(),
             "--quote-timeout=10s".to_string(),
             "--quote-verification=enforce-when-possible".to_string(),
-            "--db-read-url".to_string(),
-            LOCAL_READ_ONLY_DB_URL.clone(),
+            "--native-price-estimators=Forwarder|http://localhost:12088".to_string(),
+            format!("--db-read-url={}", &*LOCAL_READ_ONLY_DB_URL),
         ]
         .into_iter()
         .chain(self.api_autopilot_solver_arguments())
@@ -363,8 +372,37 @@ impl<'a> Services<'a> {
         }];
 
         // Create TOML config file for the driver
-        let (_config_file, config_arg) =
-            Configuration::test("test_solver", solver.address()).to_cli_args();
+        let (_config_file, config_arg) = Configuration {
+            native_price_estimation: {
+                if run_baseline {
+                    NativePriceConfig {
+                        estimators: NativePriceEstimators::new(vec![vec![
+                            NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                Url::from_str("http://localhost:11088/baseline_solver").unwrap(),
+                            ),
+                            NativePriceEstimator::driver(
+                                "test_solver".to_string(),
+                                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                            ),
+                        ]]),
+                        ..Default::default()
+                    }
+                } else {
+                    NativePriceConfig {
+                        estimators: NativePriceEstimators::new(vec![vec![
+                            NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                            ),
+                        ]]),
+                        ..Default::default()
+                    }
+                }
+            },
+            ..Configuration::test("test_solver", solver.address())
+        }
+        .to_cli_args();
 
         let (autopilot_args, api_args) = if run_baseline {
             solvers.push(
@@ -384,7 +422,6 @@ impl<'a> Services<'a> {
             let autopilot_args = vec![
                 config_arg.clone(),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
-                "--native-price-estimators=Driver|test_quoter|http://localhost:11088/baseline_solver,Driver|test_solver|http://localhost:11088/test_solver".to_string(),
             ];
             let api_args = vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
@@ -395,8 +432,6 @@ impl<'a> Services<'a> {
                 config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
             ];
 
             let api_args = vec![
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 9cc14c52b7..c08c343b6b 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -65,6 +65,7 @@ mockall = { workspace = true }
 regex = { workspace = true }
 testlib = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
+toml = { workspace = true }
 
 [features]
 test-util = ["dep:mockall"]
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index be2f83e5d7..8c805e11ab 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -178,7 +178,7 @@ impl<'a> PriceEstimatorFactory<'a> {
         weth: &WETH9::Instance,
     ) -> Result<(String, Arc<dyn NativePriceEstimating>)> {
         match source {
-            NativePriceEstimatorSource::Forwarder(url) => {
+            NativePriceEstimatorSource::Forwarder { url } => {
                 let name = format!("Forwarder|{}", url);
                 Ok((
                     name.clone(),
diff --git a/crates/shared/src/price_estimation/mod.rs b/crates/shared/src/price_estimation/mod.rs
index e8bb14150b..9e83a0050e 100644
--- a/crates/shared/src/price_estimation/mod.rs
+++ b/crates/shared/src/price_estimation/mod.rs
@@ -39,10 +39,16 @@ pub mod sanitized;
 pub mod trade_finder;
 pub mod trade_verifier;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+impl NativePriceEstimators {
+    pub fn new(estimators: Vec<Vec<NativePriceEstimator>>) -> Self {
+        Self(estimators)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct ExternalSolver {
     pub name: String,
     pub url: Url,
@@ -72,19 +78,30 @@ impl FromStr for ExternalSolver {
     }
 }
 
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(tag = "type")]
 pub enum NativePriceEstimator {
     Driver(ExternalSolver),
-    Forwarder(Url),
+    Forwarder { url: Url },
     OneInchSpotPriceApi,
     CoinGecko,
 }
 
+impl NativePriceEstimator {
+    pub const fn driver(name: String, url: Url) -> Self {
+        Self::Driver(ExternalSolver { name, url })
+    }
+
+    pub const fn forwarder(url: Url) -> Self {
+        Self::Forwarder { url }
+    }
+}
+
 impl Display for NativePriceEstimator {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         let formatter = match self {
             NativePriceEstimator::Driver(s) => format!("Driver|{}|{}", &s.name, s.url),
-            NativePriceEstimator::Forwarder(url) => format!("Forwarder|{}", url),
+            NativePriceEstimator::Forwarder { url } => format!("Forwarder|{}", url),
             NativePriceEstimator::OneInchSpotPriceApi => "OneInchSpotPriceApi".into(),
             NativePriceEstimator::CoinGecko => "CoinGecko".into(),
         };
@@ -141,10 +158,11 @@ impl FromStr for NativePriceEstimator {
             "Driver" => Ok(NativePriceEstimator::Driver(ExternalSolver::from_str(
                 args,
             )?)),
-            "Forwarder" => Ok(NativePriceEstimator::Forwarder(
-                args.parse()
+            "Forwarder" => Ok(NativePriceEstimator::Forwarder {
+                url: args
+                    .parse()
                     .context("Forwarder price estimator invalid URL")?,
-            )),
+            }),
             _ => Err(anyhow::anyhow!("unsupported native price estimator: {}", s)),
         }
     }
@@ -604,7 +622,10 @@ mod tests {
             )
             .to_string(),
             &NativePriceEstimator::OneInchSpotPriceApi.to_string(),
-            &NativePriceEstimator::Forwarder("http://localhost:9588".parse().unwrap()).to_string(),
+            &NativePriceEstimator::Forwarder {
+                url: "http://localhost:9588".parse().unwrap(),
+            }
+            .to_string(),
             "Driver|one|http://localhost:1111/,Driver|two|http://localhost:2222/;Driver|three|http://localhost:3333/,Driver|four|http://localhost:4444/",
             &format!(
                 "Driver|one|http://localhost:1111/,Driver|two|http://localhost:2222/;{},Driver|four|http://localhost:4444/",
@@ -615,6 +636,78 @@ mod tests {
         }
     }
 
+    #[test]
+    fn toml_deserialize_estimators_empty() {
+        let toml = "estimators = []";
+
+        #[derive(Deserialize)]
+        struct Helper {
+            estimators: NativePriceEstimators,
+        }
+
+        let parsed: Helper = toml::from_str(toml).unwrap();
+        assert!(parsed.estimators.as_slice().is_empty());
+    }
+
+    #[test]
+    fn toml_deserialize_estimators_single_stage() {
+        let toml = r#"
+        estimators = [[{type = "CoinGecko"}, {type = "OneInchSpotPriceApi"}]]
+        "#;
+
+        #[derive(Deserialize)]
+        struct Helper {
+            estimators: NativePriceEstimators,
+        }
+
+        let parsed: Helper = toml::from_str(toml).unwrap();
+        assert_eq!(
+            parsed.estimators.as_slice(),
+            vec![vec![
+                NativePriceEstimator::CoinGecko,
+                NativePriceEstimator::OneInchSpotPriceApi,
+            ]]
+        );
+    }
+
+    #[test]
+    fn toml_deserialize_estimators_multiple_stages() {
+        let toml = r#"
+        estimators = [
+            [{type = "CoinGecko"}, {type = "Driver", name = "solver1", url = "http://localhost:8080"}],
+            [{type = "Forwarder", url = "http://localhost:12088"}],
+        ]
+        "#;
+
+        #[derive(Deserialize)]
+        struct Helper {
+            estimators: NativePriceEstimators,
+        }
+
+        let parsed: Helper = toml::from_str(toml).unwrap();
+        assert_eq!(
+            parsed.estimators.as_slice(),
+            vec![
+                vec![
+                    NativePriceEstimator::CoinGecko,
+                    NativePriceEstimator::Driver(ExternalSolver {
+                        name: "solver1".to_string(),
+                        url: "http://localhost:8080".parse().unwrap(),
+                    }),
+                ],
+                vec![NativePriceEstimator::Forwarder {
+                    url: "http://localhost:12088".parse().unwrap(),
+                }],
+            ]
+        );
+    }
+
+    #[test]
+    fn toml_deserialize_estimators_default() {
+        let estimators = NativePriceEstimators::default();
+        assert!(estimators.as_slice().is_empty());
+    }
+
     #[test]
     fn enable_coin_gecko_buffered() {
         let args = vec![

From e5dc1eafc272ef584f3ae721c61c1b54b684be26 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Wed, 25 Feb 2026 15:57:09 +0100
Subject: [PATCH 107/219] [TRIVIAL] Change gzip level to 3 (#4209)

# Description
gzip is super heavy on the CPU and currently we are compressing data
with the maximum level. However, gzip quickly reaches a level of
diminishing returns so this PR picks a more reasonable gzip compression
level based on a test.

```
Level 1:  2214921 bytes (62ms)
Level 2:  2179485 bytes (62ms)
Level 3:  2149025 bytes (65ms)
Level 4:  1981237 bytes (116ms)
Level 5:  1927338 bytes (133ms)
Level 6:  1883464 bytes (145ms)
Level 7:  1864462 bytes (159ms)
Level 8:  1844328 bytes (225ms)
Level 9:  1840352 bytes (301ms)
```

I picked a recently uploaded auction instance (~11MB) and compressed it
once with each level. This showed that level 3 cuts the runtime by ~80%
while degrading the compressed size by only 15% (from 1.84MB to 2.14MB).

This caused other blocking operations in the autopilot to run faster
(e.g. request serialization goes from ~90ms to ~70ms).
<img width="1400" height="744" alt="Screenshot 2026-02-25 at 07 54 37"
src="https://github.com/user-attachments/assets/59876cda-dd21-422c-830c-9e33850e2a0f"
/>


# Changes
Reduced gzip compression level from max (i.e. 9) to 3.
---
 crates/s3/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/s3/src/lib.rs b/crates/s3/src/lib.rs
index d777b156fc..468a11ffa2 100644
--- a/crates/s3/src/lib.rs
+++ b/crates/s3/src/lib.rs
@@ -85,7 +85,7 @@ impl Uploader {
 
     /// Compresses the input bytes using Gzip.
     fn gzip(bytes: &[u8]) -> Result<Vec<u8>> {
-        let mut encoder = GzEncoder::new(bytes, Compression::best());
+        let mut encoder = GzEncoder::new(bytes, Compression::new(3));
         let mut encoded: Vec<u8> = Vec::with_capacity(bytes.len());
         encoder.read_to_end(&mut encoded).context("gzip encoding")?;
         Ok(encoded)

From 6b242fda9d7bba43909f83e5d29403cfd956b804 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 26 Feb 2026 13:05:24 +0000
Subject: [PATCH 108/219] Move orderbook configuration from CLI args to TOML
 config file (#4195)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Migrate order validation, IPFS, volume fee, and misc orderbook settings
(unsupported tokens, banned users, EIP-1271 validation, gas limits,
same-tokens policy, etc.) from clap CLI arguments to a TOML
configuration file.


# Changes

* Migrates the parameters above
  * Groups IPFS, order validation and volume fee
* Refactors where applicable
* Adds unit tests for (de)serialization
# Orderbook Configuration Migration: CLI to TOML

# Migration Guide

The orderbook no longer accepts certain settings as CLI arguments. They
must now be provided in a TOML config file, passed via the new
**required** `--config` flag.

```bash
orderbook --config=/path/to/orderbook.toml ...
```

## Migrated settings

| Old CLI Argument | TOML Key |
|---|---|
| `--min-order-validity-period` |
`order-validation.min-order-validity-period` |
| `--max-order-validity-period` |
`order-validation.max-order-validity-period` |
| `--max-limit-order-validity-period` |
`order-validation.max-limit-order-validity-period` |
| `--max-limit-orders-per-user` |
`order-validation.max-limit-orders-per-user` |
| `--max-gas-per-order` | `order-validation.max-gas-per-order` |
| `--same-tokens-policy` | `order-validation.same-tokens-policy` |
| `--unsupported-tokens` | `unsupported-tokens` |
| `--banned-users` | `banned-users.addresses` |
| `--banned-users-max-cache-size` | `banned-users.max-cache-size` |
| `--eip1271-skip-creation-validation` |
`eip1271-skip-creation-validation` |
| `--ipfs-gateway` | `ipfs.gateway` |
| `--ipfs-pinata-auth` | `ipfs.auth-token` |
| `--app-data-size-limit` | `app-data-size-limit` |
| `--active-order-competition-threshold` |
`active-order-competition-threshold` |
| `--volume-fee-factor` | `volume-fee.factor` |
| `--volume-fee-effective-timestamp` |
`volume-fee.effective-from-timestamp` |

## Example

Before:

```bash
orderbook \
  --min-order-validity-period=2m \
  --max-order-validity-period=6h \
  --banned-users=0xdead000000000000000000000000000000000000 \
  --ipfs-gateway=https://gateway.pinata.cloud/ipfs/ \
  --ipfs-pinata-auth=my-secret-key \
  --volume-fee-factor=0.0002 \
  --volume-fee-effective-timestamp=2025-06-01T00:00:00Z \
  --same-tokens-policy=allow-sell \
  --bind-address=0.0.0.0:8080
```

After — create `orderbook.toml`:

```toml
same-tokens-policy = "allow-sell"

[order-validation]
min-order-validity-period = "2m"
max-order-validity-period = "6h"

[banned-users]
addresses = ["0xdead000000000000000000000000000000000000"]

[ipfs]
gateway = "https://gateway.pinata.cloud/ipfs/"
pinata-auth = "my-secret-key"

[volume-fee]
factor = 0.0002
effective-from-timestamp = "2025-06-01T00:00:00Z"
```

## How to test
Tests + Staging

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 Cargo.lock                                    |   3 +
 crates/e2e/Cargo.toml                         |   2 +-
 crates/e2e/src/setup/services.rs              |  38 ++-
 crates/e2e/tests/e2e/autopilot_leader.rs      |   3 +
 crates/e2e/tests/e2e/buffers.rs               |   3 +
 crates/e2e/tests/e2e/cors.rs                  |   6 +
 crates/e2e/tests/e2e/cow_amm.rs               |   9 +
 crates/e2e/tests/e2e/jit_orders.rs            |   3 +
 crates/e2e/tests/e2e/limit_orders.rs          |  24 +-
 crates/e2e/tests/e2e/liquidity.rs             |   3 +
 .../e2e/liquidity_source_notification.rs      |   3 +
 crates/e2e/tests/e2e/malformed_requests.rs    |   3 +
 crates/e2e/tests/e2e/order_cancellation.rs    |   3 +
 .../e2e/tests/e2e/place_order_with_quote.rs   |   3 +
 crates/e2e/tests/e2e/protocol_fee.rs          |  15 +-
 crates/e2e/tests/e2e/quoting.rs               |  33 ++-
 crates/e2e/tests/e2e/smart_contract_orders.rs |  11 +-
 crates/e2e/tests/e2e/solver_competition.rs    |   9 +
 crates/e2e/tests/e2e/submission.rs            |  21 +-
 crates/orderbook/Cargo.toml                   |   5 +
 crates/orderbook/src/arguments.rs             | 160 +---------
 crates/orderbook/src/config/banned_users.rs   |  28 ++
 crates/orderbook/src/config/ipfs.rs           |  94 ++++++
 crates/orderbook/src/config/mod.rs            | 280 ++++++++++++++++++
 .../orderbook/src/config/order_validation.rs  | 149 ++++++++++
 crates/orderbook/src/lib.rs                   |   1 +
 crates/orderbook/src/quoter.rs                |   2 +-
 crates/orderbook/src/run.rs                   |  50 ++--
 crates/shared/src/order_validation.rs         |   5 +-
 29 files changed, 759 insertions(+), 210 deletions(-)
 create mode 100644 crates/orderbook/src/config/banned_users.rs
 create mode 100644 crates/orderbook/src/config/ipfs.rs
 create mode 100644 crates/orderbook/src/config/mod.rs
 create mode 100644 crates/orderbook/src/config/order_validation.rs

diff --git a/Cargo.lock b/Cargo.lock
index 837712e4b9..d2186bc261 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4798,6 +4798,7 @@ dependencies = [
  "futures",
  "hex-literal",
  "humantime",
+ "humantime-serde",
  "mimalloc",
  "mockall",
  "model",
@@ -4815,9 +4816,11 @@ dependencies = [
  "shared",
  "sqlx",
  "strum",
+ "tempfile",
  "thiserror 1.0.69",
  "tikv-jemallocator",
  "tokio",
+ "toml",
  "tower 0.5.3",
  "tower-http",
  "tracing",
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 2541d0eb0c..72d88bf701 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -30,7 +30,7 @@ itertools = { workspace = true }
 model = { workspace = true, features = ["e2e"] }
 number = { workspace = true }
 observe = { workspace = true }
-orderbook = { workspace = true, features = ["e2e"] }
+orderbook = { workspace = true, features = ["e2e", "test-util"] }
 reqwest = { workspace = true, features = ["blocking", "query"] }
 serde_json = { workspace = true }
 shared = { workspace = true }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 099c5819f5..723f22b688 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -274,21 +274,22 @@ impl<'a> Services<'a> {
         let args = ignore_overwritten_cli_params(args);
 
         let args = orderbook::arguments::Arguments::try_parse_from(args).unwrap();
-        tokio::task::spawn(orderbook::run(args));
+        let config = orderbook::config::Configuration::from_path(&args.config)
+            .await
+            .unwrap();
+        tokio::task::spawn(orderbook::run(args, config));
 
         Self::wait_for_api_to_come_up().await;
     }
 
     /// Starts a basic version of the protocol with a single baseline solver.
     pub async fn start_protocol(&self, solver: TestAccount) {
-        // HACK: config is required so in the cases where it isn't passed (like the API
-        // version test), so we create a dummy one
-        let (_config_file, cli_arg) =
+        let (_autopilot_config_file, autopilot_cli_arg) =
             Configuration::test("test_solver", solver.address()).to_cli_args();
         self.start_protocol_with_args(
             ExtraServiceArgs {
-                api: Default::default(),
-                autopilot: vec![cli_arg],
+                autopilot: vec![autopilot_cli_arg],
+                ..Default::default()
             },
             solver,
         )
@@ -337,6 +338,17 @@ impl<'a> Services<'a> {
             .concat(),
         )
         .await;
+
+        let has_ob_config = args.api.iter().any(|a| a.starts_with("--config="));
+        let (_default_ob_config_file, api_args) = if has_ob_config {
+            (None, args.api)
+        } else {
+            let (file, arg) = orderbook::config::Configuration::default().to_cli_args();
+            let mut api = args.api;
+            api.push(arg);
+            (Some(file), api)
+        };
+
         self.start_api(
             [
                 vec![
@@ -344,7 +356,7 @@ impl<'a> Services<'a> {
                         .to_string(),
                     "--gas-estimators=http://localhost:11088/gasprice".to_string(),
                 ],
-                args.api,
+                api_args,
             ]
             .concat(),
         )
@@ -371,8 +383,8 @@ impl<'a> Services<'a> {
             haircut_bps: 0,
         }];
 
-        // Create TOML config file for the driver
-        let (_config_file, config_arg) = Configuration {
+        // Create TOML config files
+        let (_autopilot_config_file, autopilot_config_arg) = Configuration {
             native_price_estimation: {
                 if run_baseline {
                     NativePriceConfig {
@@ -403,6 +415,8 @@ impl<'a> Services<'a> {
             ..Configuration::test("test_solver", solver.address())
         }
         .to_cli_args();
+        let (_orderbook_config_file, orderbook_config_arg) =
+            orderbook::config::Configuration::default().to_cli_args();
 
         let (autopilot_args, api_args) = if run_baseline {
             solvers.push(
@@ -420,21 +434,23 @@ impl<'a> Services<'a> {
             // Here we call the baseline_solver "test_quoter" to make the native price
             // estimation use the baseline_solver instead of the test_quoter
             let autopilot_args = vec![
-                config_arg.clone(),
+                autopilot_config_arg.clone(),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
             ];
             let api_args = vec![
+                orderbook_config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
             ];
             (autopilot_args, api_args)
         } else {
             let autopilot_args = vec![
-                config_arg,
+                autopilot_config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ];
 
             let api_args = vec![
+                orderbook_config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ];
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 506d334fff..b4439d3677 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -124,8 +124,11 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
         )
         .await;
 
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver1,test_solver2|http://localhost:11088/test_solver2".to_string(),
             "--native-price-estimators=Forwarder|http://0.0.0.0:9588".to_string(),
         ])
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 4938a1c486..f92f31222f 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -84,8 +84,11 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index 06af718024..d3c33feaf1 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -18,8 +18,11 @@ async fn cors_preflight(web3: Web3) {
     let services = Services::new(&onchain).await;
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
             "--gas-estimators=http://localhost:11088/gasprice".to_string(),
         ])
@@ -75,8 +78,11 @@ async fn cors_headers_on_error(web3: Web3) {
     let services = Services::new(&onchain).await;
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
             "--gas-estimators=http://localhost:11088/gasprice".to_string(),
         ])
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index dc0f6e5541..ddf5f2b5c2 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -194,8 +194,11 @@ async fn cow_amm_jit(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
@@ -574,8 +577,11 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
@@ -837,8 +843,11 @@ async fn cow_amm_opposite_direction(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index 4e945decba..fdcb6fef9c 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -102,8 +102,11 @@ async fn single_limit_order_test(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 46e55d5ca7..625da8ec6e 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -21,6 +21,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{conversions::big_decimal_to_big_uint, units::EthUnit},
+    orderbook::config::order_validation::OrderValidationConfig,
     shared::web3::Web3,
     std::{collections::HashMap, ops::DerefMut, str::FromStr},
     url::Url,
@@ -445,8 +446,11 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
     );
 
     let services = Services::new(&onchain).await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
             "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
                 .to_string(),
@@ -685,9 +689,17 @@ async fn too_many_limit_orders_test(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        order_validation: OrderValidationConfig {
+            max_limit_orders_per_user: 1,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .to_cli_args();
     services
         .start_api(vec![
-            "--max-limit-orders-per-user=1".into(),
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
@@ -782,9 +794,17 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        order_validation: OrderValidationConfig {
+            max_limit_orders_per_user: 1,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .to_cli_args();
     services
         .start_api(vec![
-            "--max-limit-orders-per-user=1".into(),
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 8fa7accf03..82e498932e 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -203,8 +203,11 @@ async fn zero_ex_liquidity(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index a5d245b666..0461ca5c2f 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -213,8 +213,11 @@ http-timeout = "10s"
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 622a0ea7b0..44b10fe02c 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -25,8 +25,11 @@ async fn http_validation(web3: Web3) {
     let services = Services::new(&onchain).await;
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
             "--gas-estimators=http://localhost:11088/gasprice".to_string(),
         ])
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index 8bf2f4f206..ca1ab85c17 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -77,8 +77,11 @@ async fn order_cancellation(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 7e93a7d9cf..cd5474c78b 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -233,8 +233,11 @@ async fn fallback_native_price_estimator(web3: Web3) {
         )
         .await;
 
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
             "--gas-estimators=http://localhost:11088/gasprice".to_string(),
             "--native-price-estimators-fallback=Driver|test_quoter|http://localhost:11088/test_solver"
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index a6bdf3ee62..6234fba1d0 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -30,7 +30,7 @@ use {
     number::units::EthUnit,
     reqwest::StatusCode,
     serde_json::json,
-    shared::web3::Web3,
+    shared::{fee_factor::FeeFactor, web3::Web3},
 };
 
 #[tokio::test]
@@ -1107,10 +1107,15 @@ async fn volume_fee_overrides(web3: Web3) {
 
     // Orderbook (API) also needs the same bucket overrides for accurate quote
     // generation
-    let api_config = vec![
-        volume_fee_bucket_config.clone(),
-        "--volume-fee-factor=0.01".to_string(), // Default 1% volume fee
-    ];
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        volume_fee: Some(orderbook::config::VolumeFeeConfig {
+            factor: Some(FeeFactor::new(0.01)), // Default 1% volume fee
+            effective_from_timestamp: None,
+        }),
+        ..Default::default()
+    }
+    .to_cli_args();
+    let api_config = vec![ob_config_arg, volume_fee_bucket_config.clone()];
 
     let services = Services::new(&onchain).await;
     services
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 58195b1767..c3892c59d4 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -9,7 +9,7 @@ use {
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
     serde_json::json,
-    shared::web3::Web3,
+    shared::{fee_factor::FeeFactor, web3::Web3},
     std::{
         sync::Arc,
         time::{Duration, Instant},
@@ -75,12 +75,17 @@ async fn test(web3: Web3) {
     let services = Services::new(&onchain).await;
     let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     // Start API with 0.02% (2 bps) volume fee
-    let args = ExtraServiceArgs {
-        api: vec![
-            "--volume-fee-factor=0.0002".to_string(),
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        volume_fee: Some(orderbook::config::VolumeFeeConfig {
+            factor: Some(FeeFactor::new(0.0002)),
             // Set a far future effective timestamp to ensure the fee is not applied
-            "--volume-fee-effective-timestamp=2099-01-01T10:00:00Z".to_string(),
-        ],
+            effective_from_timestamp: Some("2099-01-01T10:00:00Z".parse().unwrap()),
+        }),
+        ..Default::default()
+    }
+    .to_cli_args();
+    let args = ExtraServiceArgs {
+        api: vec![ob_config_arg],
         autopilot: vec![config_arg],
     };
     services.start_protocol_with_args(args, solver).await;
@@ -308,8 +313,11 @@ async fn quote_timeout(web3: Web3) {
     /// (configurable but always 500ms in e2e tests)
     const MAX_QUOTE_TIME_MS: u64 = 500;
 
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_quoter".to_string(),
             "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
                 .to_string(),
@@ -451,11 +459,18 @@ async fn volume_fee(web3: Web3) {
     // Start API with 0.02% (2 bps) default volume fee
     // Bucket override: WETH<->override_token pair gets 5 bps (both tokens must be
     // in bucket)
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        volume_fee: Some(orderbook::config::VolumeFeeConfig {
+            factor: Some(FeeFactor::new(0.0002)),
+            // Set a past effective timestamp to ensure the fee is applied
+            effective_from_timestamp: Some("2000-01-01T10:00:00Z".parse().unwrap()),
+        }),
+        ..Default::default()
+    }
+    .to_cli_args();
     let args = ExtraServiceArgs {
         api: vec![
-            "--volume-fee-factor=0.0002".to_string(),
-            // Set a past effective timestamp to ensure the fee is applied
-            "--volume-fee-effective-timestamp=2000-01-01T10:00:00Z".to_string(),
+            ob_config_arg,
             format!(
                 "--volume-fee-bucket-overrides=0.0005:{};{}",
                 onchain.contracts().weth.address(),
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 54ebdd5052..60c1527387 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -7,6 +7,7 @@ use {
         signature::Signature,
     },
     number::units::EthUnit,
+    orderbook::config::order_validation::OrderValidationConfig,
     reqwest::StatusCode,
     shared::web3::Web3,
 };
@@ -174,10 +175,18 @@ async fn erc1271_gas_limit(web3: Web3) {
 
     let services = Services::new(&onchain).await;
     let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        order_validation: OrderValidationConfig {
+            max_gas_per_order: 1_000_000,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                api: vec!["--max-gas-per-order=1000000".to_string()],
+                api: vec![ob_config_arg],
                 autopilot: vec![config_arg],
             },
             solver,
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 0266874636..3d63df23f5 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -102,7 +102,10 @@ async fn solver_competition(web3: Web3) {
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
         ],
     ).await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services.start_api(vec![
+        ob_config_arg,
         "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
     ]).await;
 
@@ -259,8 +262,11 @@ async fn wrong_solution_submission_address(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
@@ -418,8 +424,11 @@ async fn store_filtered_solutions(web3: Web3) {
             ],
         )
         .await;
+    let (_ob_config_file, ob_config_arg) =
+        orderbook::config::Configuration::default().to_cli_args();
     services
         .start_api(vec![
+            ob_config_arg,
             "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
         ])
         .await;
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index bf9b73ff7a..016158eb80 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -17,6 +17,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{nonzero::NonZeroU256, testing::ApproxEq, units::EthUnit},
+    orderbook::config::order_validation::OrderValidationConfig,
     shared::web3::Web3,
     std::time::Duration,
 };
@@ -159,10 +160,18 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
     let services = Services::new(&onchain).await;
     let (_config_file, config_arg) =
         Configuration::test("test_solver", solver.address()).to_cli_args();
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        order_validation: OrderValidationConfig {
+            same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                api: vec!["--same-tokens-policy=allow-sell".to_string()],
+                api: vec![ob_config_arg],
                 autopilot: vec![config_arg],
             },
             solver.clone(),
@@ -272,10 +281,18 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
     let services = Services::new(&onchain).await;
     let (_config_file, config_arg) =
         Configuration::test("test_solver", solver.address()).to_cli_args();
+    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
+        order_validation: OrderValidationConfig {
+            same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                api: vec!["--same-tokens-policy=allow-sell".to_string()],
+                api: vec![ob_config_arg],
                 autopilot: vec![config_arg],
             },
             solver.clone(),
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 0b688bdc8c..d0d9026405 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -33,6 +33,7 @@ futures = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
+humantime-serde = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 tikv-jemallocator = { workspace = true }
 model = { workspace = true }
@@ -51,7 +52,9 @@ shared = { workspace = true }
 strum = { workspace = true }
 sqlx = { workspace = true }
 thiserror = { workspace = true }
+tempfile = { workspace = true, optional = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
+toml = { workspace = true }
 tower = { workspace = true }
 tower-http = { workspace = true, features = ["cors", "trace"] }
 tracing = { workspace = true }
@@ -59,6 +62,7 @@ url = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }
+tempfile = { workspace = true }
 tokio = { workspace = true, features = ["test-util"] }
 shared = { workspace = true, features = ["test-util"] }
 
@@ -72,4 +76,5 @@ workspace = true
 [features]
 e2e = []
 mimalloc-allocator = ["dep:mimalloc"]
+test-util = ["dep:tempfile"]
 tokio-console = ["observe/tokio-console"]
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index dadd939594..d064b29a23 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,14 +1,11 @@
 use {
-    alloy::primitives::Address,
-    chrono::{DateTime, Utc},
     reqwest::Url,
     shared::{
         arguments::display_secret_option,
-        fee_factor::FeeFactor,
         http_client,
         price_estimation::{self, NativePriceEstimators},
     },
-    std::{net::SocketAddr, num::NonZeroUsize, time::Duration},
+    std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf},
 };
 
 #[derive(clap::Parser)]
@@ -28,6 +25,10 @@ pub struct Arguments {
     #[clap(flatten)]
     pub database_pool: shared::arguments::DatabasePoolConfig,
 
+    /// Path to the TOML configuration file.
+    #[clap(long, env)]
+    pub config: PathBuf,
+
     #[clap(long, env, default_value = "0.0.0.0:8080")]
     pub bind_address: SocketAddr,
 
@@ -41,48 +42,6 @@ pub struct Arguments {
     #[clap(long, env)]
     pub db_read_url: Option<Url>,
 
-    /// The minimum amount of time in seconds an order has to be valid for.
-    #[clap(
-        long,
-        env,
-        default_value = "1m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub min_order_validity_period: Duration,
-
-    /// The maximum amount of time in seconds an order can be valid for.
-    /// Defaults to 3 hours. This restriction does not apply to liquidity
-    /// owner orders or presign orders.
-    #[clap(
-        long,
-        env,
-        default_value = "3h",
-        value_parser = humantime::parse_duration,
-    )]
-    pub max_order_validity_period: Duration,
-
-    /// The maximum amount of time in seconds a limit order can be valid for.
-    /// Defaults to 1 year.
-    #[clap(
-        long,
-        env,
-        default_value = "1y",
-        value_parser = humantime::parse_duration,
-    )]
-    pub max_limit_order_validity_period: Duration,
-
-    /// List of token addresses to be ignored throughout service
-    #[clap(long, env, use_value_delimiter = true)]
-    pub unsupported_tokens: Vec<Address>,
-
-    /// List of account addresses to be denied from order creation
-    #[clap(long, env, use_value_delimiter = true)]
-    pub banned_users: Vec<Address>,
-
-    /// Maximum number of entries to keep in the banned users cache.
-    #[clap(long, env, default_value = "100")]
-    pub banned_users_max_cache_size: NonZeroUsize,
-
     /// Which estimators to use to estimate token prices in terms of the chain's
     /// native token.
     #[clap(long, env)]
@@ -101,65 +60,6 @@ pub struct Arguments {
     /// estimators but that will not have any further effect.
     #[clap(long, env, default_value = "2")]
     pub fast_price_estimation_results_required: NonZeroUsize,
-
-    /// Skip EIP-1271 order signature validation on creation.
-    #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
-    pub eip1271_skip_creation_validation: bool,
-
-    /// Max number of limit orders per user.
-    #[clap(long, env, default_value = "10")]
-    pub max_limit_orders_per_user: u64,
-
-    /// If set, the orderbook will use this IPFS gateway to fetch full app data
-    /// for orders that only specify the contract app data hash.
-    #[clap(long, env)]
-    pub ipfs_gateway: Option<Url>,
-
-    /// Authentication key for Pinata IPFS gateway.
-    #[clap(long, env)]
-    pub ipfs_pinata_auth: Option<String>,
-
-    /// Set the maximum size in bytes of order app data.
-    #[clap(long, env, default_value = "8192")]
-    pub app_data_size_limit: usize,
-
-    /// The maximum gas amount a single order can use for getting settled.
-    #[clap(long, env, default_value = "8000000")]
-    pub max_gas_per_order: u64,
-
-    /// The number of past solver competitions to look back at to determine
-    /// whether an order is actively being bid on.
-    #[clap(long, env, default_value = "5")]
-    pub active_order_competition_threshold: u32,
-
-    #[clap(flatten)]
-    pub volume_fee_config: Option<VolumeFeeConfig>,
-
-    /// Controls if same sell and buy token orders are allowed.
-    /// Disallowed by default.
-    #[clap(long, env, default_value = "disallow")]
-    pub same_tokens_policy: shared::order_validation::SameTokensPolicy,
-}
-
-/// Volume-based protocol fee factor to be applied to quotes.
-#[derive(clap::Parser, Debug, Clone)]
-pub struct VolumeFeeConfig {
-    /// This is a decimal value (e.g., 0.0002 for 0.02% or 2 basis points).
-    /// The fee is applied to the surplus token (buy token for sell orders,
-    /// sell token for buy orders).
-    #[clap(
-        id = "volume_fee_factor",
-        long = "volume-fee-factor",
-        env = "VOLUME_FEE_FACTOR"
-    )]
-    pub factor: Option<FeeFactor>,
-
-    /// The timestamp from which the volume fee becomes effective.
-    #[clap(
-        long = "volume-fee-effective-timestamp",
-        env = "VOLUME_FEE_EFFECTIVE_TIMESTAMP"
-    )]
-    pub effective_from_timestamp: Option<DateTime<Utc>>,
 }
 
 impl std::fmt::Display for Arguments {
@@ -170,27 +70,13 @@ impl std::fmt::Display for Arguments {
             http_client,
             price_estimation,
             database_pool,
+            config,
             bind_address,
-            min_order_validity_period,
-            max_order_validity_period,
-            max_limit_order_validity_period,
-            unsupported_tokens,
-            banned_users,
-            banned_users_max_cache_size,
-            eip1271_skip_creation_validation,
             native_price_estimators,
             native_price_estimators_fallback,
             fast_price_estimation_results_required,
-            max_limit_orders_per_user,
-            ipfs_gateway,
-            ipfs_pinata_auth,
-            app_data_size_limit,
             db_write_url: db_url,
             db_read_url,
-            max_gas_per_order,
-            active_order_competition_threshold,
-            volume_fee_config,
-            same_tokens_policy,
         } = self;
 
         write!(f, "{shared}")?;
@@ -198,32 +84,11 @@ impl std::fmt::Display for Arguments {
         write!(f, "{http_client}")?;
         write!(f, "{price_estimation}")?;
         write!(f, "{database_pool}")?;
+        writeln!(f, "config: {}", config.display())?;
         writeln!(f, "bind_address: {bind_address}")?;
         let _intentionally_ignored = db_url;
         writeln!(f, "db_url: SECRET")?;
         display_secret_option(f, "db_read_url", db_read_url.as_ref())?;
-        writeln!(
-            f,
-            "min_order_validity_period: {min_order_validity_period:?}"
-        )?;
-        writeln!(
-            f,
-            "max_order_validity_period: {max_order_validity_period:?}"
-        )?;
-        writeln!(
-            f,
-            "max_limit_order_validity_period: {max_limit_order_validity_period:?}"
-        )?;
-        writeln!(f, "unsupported_tokens: {unsupported_tokens:?}")?;
-        writeln!(f, "banned_users: {banned_users:?}")?;
-        writeln!(
-            f,
-            "banned_users_max_cache_size: {banned_users_max_cache_size:?}"
-        )?;
-        writeln!(
-            f,
-            "eip1271_skip_creation_validation: {eip1271_skip_creation_validation}"
-        )?;
         writeln!(f, "native_price_estimators: {native_price_estimators}")?;
         writeln!(
             f,
@@ -233,17 +98,6 @@ impl std::fmt::Display for Arguments {
             f,
             "fast_price_estimation_results_required: {fast_price_estimation_results_required}"
         )?;
-        writeln!(f, "max_limit_orders_per_user: {max_limit_orders_per_user}")?;
-        writeln!(f, "ipfs_gateway: {ipfs_gateway:?}")?;
-        display_secret_option(f, "ipfs_pinata_auth", ipfs_pinata_auth.as_ref())?;
-        writeln!(f, "app_data_size_limit: {app_data_size_limit}")?;
-        writeln!(f, "max_gas_per_order: {max_gas_per_order}")?;
-        writeln!(
-            f,
-            "active_order_competition_threshold: {active_order_competition_threshold}"
-        )?;
-        writeln!(f, "volume_fee_config: {volume_fee_config:?}")?;
-        writeln!(f, "same_tokens_policy: {same_tokens_policy:?}")?;
 
         Ok(())
     }
diff --git a/crates/orderbook/src/config/banned_users.rs b/crates/orderbook/src/config/banned_users.rs
new file mode 100644
index 0000000000..e970795915
--- /dev/null
+++ b/crates/orderbook/src/config/banned_users.rs
@@ -0,0 +1,28 @@
+use {
+    alloy::primitives::Address,
+    serde::{Deserialize, Serialize},
+    std::num::NonZeroUsize,
+};
+
+const fn default_max_cache_size() -> NonZeroUsize {
+    NonZeroUsize::new(100).expect("value should be non-zero")
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct BannedUsersConfig {
+    #[serde(default)]
+    pub addresses: Vec<Address>,
+
+    /// Maximum number of entries to keep in the banned users cache.
+    #[serde(default = "default_max_cache_size")]
+    pub max_cache_size: NonZeroUsize,
+}
+
+impl Default for BannedUsersConfig {
+    fn default() -> Self {
+        Self {
+            addresses: Default::default(),
+            max_cache_size: default_max_cache_size(),
+        }
+    }
+}
diff --git a/crates/orderbook/src/config/ipfs.rs b/crates/orderbook/src/config/ipfs.rs
new file mode 100644
index 0000000000..bc365ecdf5
--- /dev/null
+++ b/crates/orderbook/src/config/ipfs.rs
@@ -0,0 +1,94 @@
+use {
+    serde::{Deserialize, Deserializer, Serialize},
+    url::Url,
+};
+
+/// The IPFS authentication token is injected by 1Password directly into the
+/// Pod's environment, completely bypassing Pulumi and making it unusable in the
+/// configuration file. Since the token does not contain `%` this is a
+/// workaround to allow the token to be read from the environment.
+fn deserialize_auth_token<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let Some(raw_auth_token) = Option::<String>::deserialize(deserializer)? else {
+        return Ok(None);
+    };
+    if let Some(env_var_name) = raw_auth_token.strip_prefix("%") {
+        let env_var_contents = std::env::var(env_var_name).map_err(|err| {
+            tracing::error!(%err, %env_var_name, "failed to load env var");
+            serde::de::Error::invalid_value(
+                serde::de::Unexpected::Str(env_var_name),
+                &"expected environment variable to be available",
+            )
+        })?;
+        Ok(Some(env_var_contents))
+    } else {
+        Ok(Some(raw_auth_token))
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct IpfsConfig {
+    /// IPFS gateway to fetch full app data for orders that only specify the
+    /// contract app data hash.
+    pub gateway: Url,
+
+    /// Authentication key for Pinata IPFS gateway.
+    #[serde(deserialize_with = "deserialize_auth_token")]
+    pub auth_token: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        gateway = "https://gateway.pinata.cloud/ipfs/"
+        auth-token = "my-secret-key"
+        "#;
+        let config: IpfsConfig = toml::from_str(toml).unwrap();
+        assert_eq!(
+            config.gateway.as_str(),
+            "https://gateway.pinata.cloud/ipfs/"
+        );
+        assert_eq!(config.auth_token.unwrap(), "my-secret-key");
+    }
+
+    #[test]
+    fn deserialize_auth_token_from_env() {
+        let env_var_name = "TEST_IPFS_AUTH_TOKEN_SECRET";
+        let env_var_value = "my-secret-from-env";
+        // SAFETY: no other threads access this env var.
+        unsafe { std::env::set_var(env_var_name, env_var_value) };
+
+        let toml = format!(
+            r#"
+            gateway = "https://gateway.pinata.cloud/ipfs/"
+            auth-token = "%{env_var_name}"
+            "#,
+        );
+        let config: IpfsConfig = toml::from_str(&toml).unwrap();
+        assert_eq!(config.auth_token.as_deref(), Some(env_var_value));
+
+        // SAFETY: no other threads access this env var.
+        unsafe { std::env::remove_var(env_var_name) };
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = IpfsConfig {
+            gateway: "https://gateway.pinata.cloud/ipfs/".parse().unwrap(),
+            auth_token: Some("my-secret-key".to_string()),
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: IpfsConfig = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(config.gateway.as_str(), deserialized.gateway.as_str());
+        assert_eq!(config.auth_token, deserialized.auth_token);
+    }
+}
diff --git a/crates/orderbook/src/config/mod.rs b/crates/orderbook/src/config/mod.rs
new file mode 100644
index 0000000000..2817820ef9
--- /dev/null
+++ b/crates/orderbook/src/config/mod.rs
@@ -0,0 +1,280 @@
+use {
+    crate::config::{
+        banned_users::BannedUsersConfig,
+        ipfs::IpfsConfig,
+        order_validation::OrderValidationConfig,
+    },
+    alloy::primitives::Address,
+    anyhow::anyhow,
+    chrono::{DateTime, Utc},
+    serde::{Deserialize, Serialize},
+    shared::fee_factor::FeeFactor,
+    std::path::Path,
+};
+
+pub mod banned_users;
+pub mod ipfs;
+pub mod order_validation;
+
+const fn default_app_data_size_limit() -> usize {
+    8192
+}
+
+const fn default_active_order_competition_threshold() -> u32 {
+    5
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct VolumeFeeConfig {
+    pub factor: Option<FeeFactor>,
+    pub effective_from_timestamp: Option<DateTime<Utc>>,
+}
+
+// NOTE: cannot add deny_unknown_fields during the config migration
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case" /* deny_unknown_fields */)]
+pub struct Configuration {
+    /// Configuration for the order validation system.
+    #[serde(default)]
+    pub order_validation: OrderValidationConfig,
+
+    /// Configuration for the banned users mechanism,
+    /// such as their addresses and the size of the banned user's cache.
+    #[serde(default)]
+    pub banned_users: BannedUsersConfig,
+
+    /// Configuration for the IPFS gateway, supports token authentication.
+    pub ipfs: Option<IpfsConfig>,
+
+    /// Configuration for the volume fee.
+    pub volume_fee: Option<VolumeFeeConfig>,
+
+    #[serde(default = "default_app_data_size_limit")]
+    pub app_data_size_limit: usize,
+
+    /// Missed auctions threshold after which an order is no longer "active".
+    #[serde(default = "default_active_order_competition_threshold")]
+    pub active_order_competition_threshold: u32,
+
+    /// Denylist of tokens (due to lack of support, or other reason).
+    #[serde(default)]
+    pub unsupported_tokens: Vec<Address>,
+
+    /// Whether to skip EIP-1271 signature validation.
+    #[serde(default)]
+    pub eip1271_skip_creation_validation: bool,
+}
+
+impl Default for Configuration {
+    fn default() -> Self {
+        Self {
+            order_validation: Default::default(),
+            ipfs: Default::default(),
+            app_data_size_limit: default_app_data_size_limit(),
+            active_order_competition_threshold: default_active_order_competition_threshold(),
+            volume_fee: None,
+            unsupported_tokens: Default::default(),
+            banned_users: Default::default(),
+            eip1271_skip_creation_validation: false,
+        }
+    }
+}
+
+impl Configuration {
+    pub async fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
+        match toml::from_str(&tokio::fs::read_to_string(&path).await?) {
+            Ok(self_) => Ok(self_),
+            Err(err) if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") => Err(anyhow!(
+                "failed to parse TOML config at {}: {err:#?}",
+                path.as_ref().display()
+            )),
+            Err(_) => Err(anyhow!(
+                "failed to parse TOML config at: {}. Set TOML_TRACE_ERROR=1 to print parsing \
+                 error but this may leak secrets.",
+                path.as_ref().display()
+            )),
+        }
+    }
+
+    pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
+        Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl Configuration {
+    pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
+        use std::io::Write;
+        let mut file = tempfile::NamedTempFile::new().expect("temp file creation should not fail");
+        file.write_all(
+            toml::to_string_pretty(self)
+                .expect("serialization should not fail")
+                .as_bytes(),
+        )
+        .expect("writing to temp file should not fail");
+        file
+    }
+
+    pub fn to_cli_args(&self) -> (tempfile::NamedTempFile, String) {
+        let named_temp_file = self.to_temp_path();
+        let cli_arg = format!("--config={}", named_temp_file.path().display());
+        (named_temp_file, cli_arg)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, shared::order_validation::SameTokensPolicy, std::time::Duration};
+
+    #[test]
+    fn deserialize_full_configuration() {
+        let toml = r#"
+        app-data-size-limit = 4096
+        active-order-competition-threshold = 10
+        unsupported-tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        eip1271-skip-creation-validation = true
+
+        [banned-users]
+        addresses = ["0xdead000000000000000000000000000000000000"]
+
+        [order-validation]
+        min-order-validity-period = "2m"
+        max-order-validity-period = "6h"
+        max-limit-order-validity-period = "30d"
+        max-limit-orders-per-user = 5
+        max-gas-per-order = 5000000
+        same-tokens-policy = "allow-sell"
+
+        [ipfs]
+        gateway = "https://gateway.pinata.cloud/ipfs/"
+        auth-token = "my-secret-key"
+
+        [volume-fee]
+        factor = 0.0002
+        effective-from-timestamp = "2025-06-01T00:00:00Z"
+        "#;
+
+        let config: Configuration = toml::from_str(toml).unwrap();
+
+        assert_eq!(config.app_data_size_limit, 4096);
+        assert_eq!(config.active_order_competition_threshold, 10);
+        assert_eq!(config.unsupported_tokens.len(), 1);
+        assert_eq!(config.banned_users.addresses.len(), 1);
+        assert!(config.eip1271_skip_creation_validation);
+
+        assert!(matches!(
+            config.order_validation.same_tokens_policy,
+            SameTokensPolicy::AllowSell
+        ));
+        assert_eq!(config.order_validation.max_limit_orders_per_user, 5);
+
+        assert_eq!(
+            config.order_validation.min_order_validity_period,
+            Duration::from_secs(120)
+        );
+        assert_eq!(
+            config.order_validation.max_order_validity_period,
+            Duration::from_secs(21600)
+        );
+        assert_eq!(
+            config.order_validation.max_limit_order_validity_period,
+            Duration::from_secs(2_592_000)
+        );
+
+        let ipfs = config.ipfs.unwrap();
+        assert_eq!(ipfs.gateway.as_str(), "https://gateway.pinata.cloud/ipfs/");
+        assert_eq!(ipfs.auth_token.unwrap(), "my-secret-key");
+
+        let vol_fee = config.volume_fee.unwrap();
+        assert_eq!(vol_fee.factor.unwrap().get(), 0.0002);
+        assert!(vol_fee.effective_from_timestamp.is_some());
+    }
+
+    #[test]
+    fn deserialize_configuration_defaults() {
+        let config: Configuration = toml::from_str("").unwrap();
+
+        assert_eq!(config.app_data_size_limit, 8192);
+        assert_eq!(config.active_order_competition_threshold, 5);
+
+        assert_eq!(
+            config.order_validation.min_order_validity_period,
+            Duration::from_secs(60)
+        );
+        assert_eq!(
+            config.order_validation.max_order_validity_period,
+            Duration::from_secs(10800)
+        );
+        assert_eq!(
+            config.order_validation.max_limit_order_validity_period,
+            Duration::from_secs(31_536_000)
+        );
+
+        assert!(config.ipfs.is_none());
+        assert!(config.volume_fee.is_none());
+        assert!(config.unsupported_tokens.is_empty());
+        assert!(config.banned_users.addresses.is_empty());
+        assert!(!config.eip1271_skip_creation_validation);
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = Configuration {
+            order_validation: OrderValidationConfig {
+                min_order_validity_period: Duration::from_secs(120),
+                max_order_validity_period: Duration::from_secs(7200),
+                max_limit_order_validity_period: Duration::from_secs(86400),
+                max_limit_orders_per_user: 5,
+                max_gas_per_order: 6_000_000,
+                same_tokens_policy: SameTokensPolicy::AllowSell,
+            },
+            ipfs: Some(IpfsConfig {
+                gateway: "https://gateway.pinata.cloud/ipfs/".parse().unwrap(),
+                auth_token: Some("secret".to_string()),
+            }),
+            app_data_size_limit: 4096,
+            active_order_competition_threshold: 10,
+            volume_fee: Some(VolumeFeeConfig {
+                factor: Some(0.0002.try_into().unwrap()),
+                effective_from_timestamp: None,
+            }),
+            unsupported_tokens: vec![
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+                    .parse()
+                    .unwrap(),
+            ],
+            banned_users: Default::default(),
+            eip1271_skip_creation_validation: true,
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: Configuration = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(config.app_data_size_limit, deserialized.app_data_size_limit);
+        assert_eq!(
+            config.active_order_competition_threshold,
+            deserialized.active_order_competition_threshold
+        );
+        assert!(deserialized.volume_fee.is_some());
+        assert_eq!(
+            config.volume_fee.as_ref().unwrap().factor.unwrap().get(),
+            deserialized
+                .volume_fee
+                .as_ref()
+                .unwrap()
+                .factor
+                .unwrap()
+                .get()
+        );
+        assert_eq!(config.unsupported_tokens, deserialized.unsupported_tokens);
+        assert_eq!(
+            config.banned_users.addresses,
+            deserialized.banned_users.addresses
+        );
+        assert_eq!(
+            config.eip1271_skip_creation_validation,
+            deserialized.eip1271_skip_creation_validation
+        );
+    }
+}
diff --git a/crates/orderbook/src/config/order_validation.rs b/crates/orderbook/src/config/order_validation.rs
new file mode 100644
index 0000000000..f6e882ad43
--- /dev/null
+++ b/crates/orderbook/src/config/order_validation.rs
@@ -0,0 +1,149 @@
+use {
+    serde::{Deserialize, Serialize},
+    shared::order_validation::SameTokensPolicy,
+    std::time::Duration,
+};
+
+const fn default_min_order_validity_period() -> Duration {
+    Duration::from_secs(60) // 1m
+}
+
+const fn default_max_order_validity_period() -> Duration {
+    Duration::from_secs(10800) // 3h
+}
+
+const fn default_max_limit_order_validity_period() -> Duration {
+    Duration::from_secs(31_536_000) // 1y
+}
+
+const fn default_max_limit_orders_per_user() -> u64 {
+    10
+}
+
+const fn default_max_gas_per_order() -> u64 {
+    8_000_000
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct OrderValidationConfig {
+    /// The minimum amount of time an order has to be valid for.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_min_order_validity_period"
+    )]
+    pub min_order_validity_period: Duration,
+
+    /// The maximum amount of time a market order can be valid for.
+    /// This restriction does not apply to liquidity owner orders or presign
+    /// orders.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_max_order_validity_period"
+    )]
+    pub max_order_validity_period: Duration,
+
+    /// The maximum amount of time a limit order can be valid for.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_max_limit_order_validity_period"
+    )]
+    pub max_limit_order_validity_period: Duration,
+
+    /// The maximum number of limit orders a user can have open.
+    #[serde(default = "default_max_limit_orders_per_user")]
+    pub max_limit_orders_per_user: u64,
+
+    /// Maximum gas value that can be spent per order.
+    #[serde(default = "default_max_gas_per_order")]
+    pub max_gas_per_order: u64,
+
+    /// Policy for orders where the buy and sell tokens are equal.
+    #[serde(default)]
+    pub same_tokens_policy: SameTokensPolicy,
+}
+
+impl Default for OrderValidationConfig {
+    fn default() -> Self {
+        Self {
+            min_order_validity_period: default_min_order_validity_period(),
+            max_order_validity_period: default_max_order_validity_period(),
+            max_limit_order_validity_period: default_max_limit_order_validity_period(),
+            max_limit_orders_per_user: default_max_limit_orders_per_user(),
+            max_gas_per_order: default_max_gas_per_order(),
+            same_tokens_policy: Default::default(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let config: OrderValidationConfig = toml::from_str("").unwrap();
+        assert_eq!(config.min_order_validity_period, Duration::from_secs(60));
+        assert_eq!(config.max_order_validity_period, Duration::from_secs(10800));
+        assert_eq!(
+            config.max_limit_order_validity_period,
+            Duration::from_secs(31_536_000)
+        );
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        min-order-validity-period = "2m"
+        max-order-validity-period = "6h"
+        max-limit-order-validity-period = "30d"
+        max-limit-orders-per-user = 10
+        max-gas-per-order = 5000000
+        same-tokens-policy = "allow-sell"
+        "#;
+        let config: OrderValidationConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.min_order_validity_period, Duration::from_secs(120));
+        assert_eq!(config.max_order_validity_period, Duration::from_secs(21600));
+        assert_eq!(
+            config.max_limit_order_validity_period,
+            Duration::from_secs(2_592_000)
+        );
+        assert_eq!(config.max_limit_orders_per_user, 10);
+        assert_eq!(config.max_gas_per_order, 5_000_000);
+        assert_eq!(config.same_tokens_policy, SameTokensPolicy::AllowSell);
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = OrderValidationConfig {
+            min_order_validity_period: Duration::from_secs(120),
+            max_order_validity_period: Duration::from_secs(7200),
+            max_limit_order_validity_period: Duration::from_secs(86400),
+            max_limit_orders_per_user: 5,
+            max_gas_per_order: 5_000_000,
+            same_tokens_policy: SameTokensPolicy::AllowSell,
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: OrderValidationConfig = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(
+            config.min_order_validity_period,
+            deserialized.min_order_validity_period
+        );
+        assert_eq!(
+            config.max_order_validity_period,
+            deserialized.max_order_validity_period
+        );
+        assert_eq!(
+            config.max_limit_order_validity_period,
+            deserialized.max_limit_order_validity_period
+        );
+        assert_eq!(
+            config.max_limit_orders_per_user,
+            deserialized.max_limit_orders_per_user
+        );
+        assert_eq!(config.max_gas_per_order, deserialized.max_gas_per_order);
+        assert_eq!(config.same_tokens_policy, deserialized.same_tokens_policy);
+    }
+}
diff --git a/crates/orderbook/src/lib.rs b/crates/orderbook/src/lib.rs
index 2b380334fa..5b71b41d52 100644
--- a/crates/orderbook/src/lib.rs
+++ b/crates/orderbook/src/lib.rs
@@ -1,6 +1,7 @@
 pub mod api;
 pub mod app_data;
 pub mod arguments;
+pub mod config;
 pub mod database;
 pub mod dto;
 mod ipfs;
diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs
index 71a60e2693..4201f5a4a6 100644
--- a/crates/orderbook/src/quoter.rs
+++ b/crates/orderbook/src/quoter.rs
@@ -1,5 +1,5 @@
 use {
-    crate::{app_data, arguments::VolumeFeeConfig},
+    crate::{app_data, config::VolumeFeeConfig},
     alloy::primitives::{U256, U512, Uint, ruint::UintTryFrom},
     bigdecimal::{BigDecimal, FromPrimitive},
     chrono::{TimeZone, Utc},
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 21201e63db..7f7aee98b8 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -2,6 +2,7 @@ use {
     crate::{
         api,
         arguments::Arguments,
+        config::Configuration,
         database::Postgres,
         ipfs::Ipfs,
         ipfs_app_data::IpfsAppData,
@@ -61,10 +62,13 @@ pub async fn start(args: impl Iterator<Item = String>) {
     observe::metrics::setup_registry(Some("gp_v2_api".into()), None);
     #[cfg(unix)]
     observe::heap_dump_handler::spawn_heap_dump_handler();
-    run(args).await;
+    let config = Configuration::from_path(&args.config)
+        .await
+        .expect("failed to load configuration file");
+    run(args, config).await;
 }
 
-pub async fn run(args: Arguments) {
+pub async fn run(args: Arguments, config: Configuration) {
     let http_factory = HttpClientFactory::new(&args.http_client);
 
     let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
@@ -192,7 +196,7 @@ pub async fn run(args: Arguments) {
         .expect("failed to create gas price estimator"),
     ));
 
-    let deny_listed_tokens = DenyListedTokens::new(args.unsupported_tokens.clone());
+    let deny_listed_tokens = DenyListedTokens::new(config.unsupported_tokens);
 
     let current_block_stream = args
         .shared
@@ -295,9 +299,9 @@ pub async fn run(args: Arguments) {
         .unwrap();
 
     let validity_configuration = OrderValidPeriodConfiguration {
-        min: args.min_order_validity_period,
-        max_market: args.max_order_validity_period,
-        max_limit: args.max_limit_order_validity_period,
+        min: config.order_validation.min_order_validity_period,
+        max_market: config.order_validation.max_order_validity_period,
+        max_limit: config.order_validation.max_limit_order_validity_period,
     };
 
     let create_quoter = |price_estimator: Arc<dyn PriceEstimating>,
@@ -333,7 +337,7 @@ pub async fn run(args: Arguments) {
     // them.
     let fast_quoter = create_quoter(fast_price_estimator, QuoteVerificationMode::Unverified);
 
-    let app_data_validator = Validator::new(args.app_data_size_limit);
+    let app_data_validator = Validator::new(config.app_data_size_limit);
     let chainalysis_oracle = ChainalysisOracle::Instance::deployed(&web3.provider)
         .await
         .ok();
@@ -341,32 +345,30 @@ pub async fn run(args: Arguments) {
         native_token,
         Arc::new(order_validation::banned::Users::new(
             chainalysis_oracle,
-            args.banned_users,
-            args.banned_users_max_cache_size.get().to_u64().unwrap(),
+            config.banned_users.addresses,
+            config.banned_users.max_cache_size.get().to_u64().unwrap(),
         )),
         validity_configuration,
-        args.eip1271_skip_creation_validation,
+        config.eip1271_skip_creation_validation,
         deny_listed_tokens.clone(),
         hooks_contract,
         optimal_quoter.clone(),
         balance_fetcher,
         signature_validator,
         Arc::new(postgres_write.clone()),
-        args.max_limit_orders_per_user,
+        config.order_validation.max_limit_orders_per_user,
         code_fetcher,
         app_data_validator.clone(),
-        args.max_gas_per_order,
-        args.same_tokens_policy,
+        config.order_validation.max_gas_per_order,
+        config.order_validation.same_tokens_policy,
     ));
-    let ipfs = args
-        .ipfs_gateway
-        .map(|url| {
-            Ipfs::new(
-                http_factory.builder(),
-                url,
-                args.ipfs_pinata_auth
-                    .map(|auth| format!("pinataGatewayToken={auth}")),
-            )
+    let ipfs = config
+        .ipfs
+        .map(|ipfs| {
+            let pinata_query = ipfs
+                .auth_token
+                .map(|auth| format!("pinataGatewayToken={auth}"));
+            Ipfs::new(http_factory.builder(), ipfs.gateway, pinata_query)
         })
         .map(IpfsAppData::new);
     let app_data = Arc::new(crate::app_data::Registry::new(
@@ -381,7 +383,7 @@ pub async fn run(args: Arguments) {
         postgres_read.clone(),
         order_validator.clone(),
         app_data.clone(),
-        args.active_order_competition_threshold,
+        config.active_order_competition_threshold,
     ));
 
     check_database_connection(orderbook.as_ref()).await;
@@ -389,7 +391,7 @@ pub async fn run(args: Arguments) {
         order_validator,
         optimal_quoter,
         app_data.clone(),
-        args.volume_fee_config,
+        config.volume_fee,
         args.shared.volume_fee_bucket_overrides.clone(),
         args.shared.enable_sell_equals_buy_volume_fee,
     )
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 5839cfbec3..39b5018077 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -212,8 +212,10 @@ pub trait LimitOrderCounting: Send + Sync {
     async fn count(&self, owner: Address) -> Result<u64>;
 }
 
-#[derive(Clone, Debug, clap::ValueEnum)]
+#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "kebab-case")]
 pub enum SameTokensPolicy {
+    #[default]
     Disallow,
     AllowSell,
     // Allow, TODO: Allow sell and buy orders with the same tokens (https://github.com/cowprotocol/services/issues/3963)
@@ -249,6 +251,7 @@ pub struct OrderValidator {
     native_token: WETH9::Instance,
     banned_users: Arc<order_validation::banned::Users>,
     validity_configuration: OrderValidPeriodConfiguration,
+    /// Whether to skip EIP-1271 signature validation.
     eip1271_skip_creation_validation: bool,
     deny_listed_tokens: DenyListedTokens,
     hooks: HooksTrampoline::Instance,

From 51a8fd0646ccb61ae4947687dafd8838cbd4645d Mon Sep 17 00:00:00 2001
From: openjarvis2026 <openjarvis@agentmail.to>
Date: Thu, 26 Feb 2026 13:12:49 -0300
Subject: [PATCH 109/219] [M3] docs(playground): add Using Otterscan user guide
 (#4146)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

This PR completes **Milestone 3: Documentation** of the [CoW Grants
Program RFP: CoW Protocol Playground Block Explorer
Integration](https://forum.cow.fi/t/grant-application-cow-protocol-playground-block-explorer-integration/3284/1)
proposal by CoBuilders.

### Documentation Strategy

Most of the technical documentation for this integration was delivered
inline with the implementation in M1 and M2:

| Milestone | Documentation Delivered |
|-----------|------------------------|
| **M1** ([#4000](https://github.com/cowprotocol/services/pull/4000)) |
README sections for Sourcify configuration, contract verification,
component table updates |
| **M2** ([#4077](https://github.com/cowprotocol/services/pull/4077),
[cowswap#6774](https://github.com/cowprotocol/cowswap/pull/6774)) |
Environment variable documentation in `.env` files, JSDoc comments in
source code |

**This PR** adds the remaining user-facing documentation: a practical
guide on how to use Otterscan for transaction inspection and debugging.

## Changes

Adds a "Using Otterscan" section to the playground README covering:
- How to access and use Otterscan (`http://localhost:8003`)
- Inspecting transactions (overview, traces, logs, gas profiling)
- Debugging failed transactions with trace analysis
- Example workflow: Tracing a CoW Swap settlement

## Milestones

| Milestone | Description | Status |
|-----------|-------------|--------|
| M1 | Otterscan Integration |
[#4000](https://github.com/cowprotocol/services/pull/4000) ✅ |
| M2 | Frontend Integration |
[#4077](https://github.com/cowprotocol/services/pull/4077) +
[cowswap#6774](https://github.com/cowprotocol/cowswap/pull/6774) ✅ |
| M3 | Documentation | **This PR** |

---

*Submitted by [CoBuilders](https://cobuilders.xyz) as part of the CoW
Grants Program*

---------

Co-authored-by: Augusto Collerone <collerone.augusto@gmail.com>
Co-authored-by: Ignacio <ignacio@cobuilders.xyz>
---
 playground/README.md                          |  72 ++++++++++++++++++
 .../docs/images/otterscan-failed-tx.png       | Bin 0 -> 140491 bytes
 .../docs/images/otterscan-revert-trace.png    | Bin 0 -> 88607 bytes
 playground/docs/images/otterscan-tx-logs.png  | Bin 0 -> 612073 bytes
 .../docs/images/otterscan-tx-overview.png     | Bin 0 -> 612400 bytes
 playground/docs/images/otterscan-tx-trace.png | Bin 0 -> 639438 bytes
 6 files changed, 72 insertions(+)
 create mode 100644 playground/docs/images/otterscan-failed-tx.png
 create mode 100644 playground/docs/images/otterscan-revert-trace.png
 create mode 100644 playground/docs/images/otterscan-tx-logs.png
 create mode 100644 playground/docs/images/otterscan-tx-overview.png
 create mode 100644 playground/docs/images/otterscan-tx-trace.png

diff --git a/playground/README.md b/playground/README.md
index 3269971f77..572024a57a 100644
--- a/playground/README.md
+++ b/playground/README.md
@@ -155,6 +155,78 @@ In this mode, the stack will spin up:
 
 - As per fork, but with a local node (not forked from Erigon)
 
+## Using Otterscan
+
+[Otterscan](https://github.com/otterscan/otterscan) is a local block explorer integrated into the playground.
+It provides powerful transaction analysis tools that work with your local Anvil chain — no external services required.
+
+For more details, see the [Otterscan documentation](https://docs.otterscan.io/).
+
+**Access Otterscan at:** http://localhost:8003
+
+### Inspecting Transactions
+
+When you make a swap in CoW Swap, all explorer links automatically point to your local Otterscan instance. You can:
+
+1. **View transaction overview**: See gas usage, status, block info, and decoded input data
+
+   ![Transaction overview](docs/images/otterscan-tx-overview.png)
+   *Transaction overview showing gas usage, status, token transfers, and decoded input data.*
+
+2. **Analyze transaction traces**: Expand the full call tree to see every internal call, including:
+   - Contract-to-contract calls
+   - Token transfers (ERC20, ERC721)
+   - Value transfers
+   - Delegate calls and static calls
+
+   ![Transaction trace](docs/images/otterscan-tx-trace.png)
+   *Full call trace of a `settle()` transaction showing internal calls, token transfers, and AMM interactions.*
+
+3. **View event logs**: See all emitted events with decoded parameters
+
+   ![Transaction logs](docs/images/otterscan-tx-logs.png)
+   *Event logs tab with decoded parameters for a CoW Swap settlement.*
+
+4. **Check gas profiling**: Understand gas consumption per operation
+
+For more on transaction analysis, see the [Otterscan documentation](https://docs.otterscan.io/).
+
+### Debugging Failed Transactions
+
+Otterscan is especially useful for debugging failed transactions:
+
+1. Navigate to the failed transaction in Otterscan
+
+   ![Failed transaction overview](docs/images/otterscan-failed-tx.png)
+   *Overview of a failed transaction showing the "Fail" status badge and decoded input data.*
+
+2. Check the **"Trace"** tab to see exactly where the transaction reverted
+
+   ![Failed transaction trace](docs/images/otterscan-revert-trace.png)
+   *Trace tab showing the full call tree of a failed transaction with multiple internal calls.*
+
+3. Look for the revert reason in the trace output (e.g., `Error(string)` or custom errors)
+4. For CoW Protocol transactions, you can trace the entire settlement flow including:
+   - Pre-interactions
+   - Token approvals and transfers
+   - AMM interactions (Uniswap, etc.)
+   - Post-interactions
+
+See the [Otterscan documentation](https://docs.otterscan.io/) for more details on trace analysis.
+
+### Example: Tracing a CoW Swap Settlement
+
+After executing a swap:
+
+1. Click the transaction link in the CoW Swap UI or CoW Explorer. This will open the transaction directly in your local Otterscan instance.
+2. Click on **"Trace"** to see the full execution flow.
+3. Expand the `settle()` call to see:
+   - How tokens flowed between parties
+   - Which liquidity sources were used
+   - Gas costs per operation
+
+> **Tip:** For details on how Otterscan displays verified source code, see the [Contract Verification with Sourcify](#contract-verification-with-sourcify) section below.
+
 ## Contract Verification with Sourcify
 
 The playground includes a local [Sourcify](https://sourcify.dev/) instance for contract verification. Sourcify is a decentralized contract verification service that matches deployed bytecode with source code. Verified contracts display their source code in Otterscan.
diff --git a/playground/docs/images/otterscan-failed-tx.png b/playground/docs/images/otterscan-failed-tx.png
new file mode 100644
index 0000000000000000000000000000000000000000..4b9b9f48f71371a0e72f4d66afddbf1b97e8eab1
GIT binary patch
literal 140491
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
S``t@fX=W+U*!`)WGye<83Xit{

literal 0
HcmV?d00001

diff --git a/playground/docs/images/otterscan-revert-trace.png b/playground/docs/images/otterscan-revert-trace.png
new file mode 100644
index 0000000000000000000000000000000000000000..9fa86986c99a2363941c026fb3750a35932b5d91
GIT binary patch
literal 88607
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

literal 0
HcmV?d00001

diff --git a/playground/docs/images/otterscan-tx-logs.png b/playground/docs/images/otterscan-tx-logs.png
new file mode 100644
index 0000000000000000000000000000000000000000..81e03d85ed66c09894328bc0cefaf063167897f2
GIT binary patch
literal 612073
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
T@@DTE;A8oR)%n76ZukES2g#M@

literal 0
HcmV?d00001

diff --git a/playground/docs/images/otterscan-tx-overview.png b/playground/docs/images/otterscan-tx-overview.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4e39e9b23fc0db432cf420b2ece21e6c3887d7d
GIT binary patch
literal 612400
zcmdSAbyS>9wmu3ZNRZ$f+-WQj++7-Iv~daU?oJ2<4esvNxLY8&y9R;>x8M%H{$}RP
z{LY+nXYQ=^{c&%v7pl5xYQ0r^*R!Af?0UnLK+<T)M945OFle$e5-QL}9R>!`4+#PK
zNp)Hx4GavbyrsCflB~EmxssE;nWc>>42(=zq6VU->JVO*jta$VBnc7Vo&rWJmIx4u
zIpC57K=B3x82LuDFN&!x&>A1Jd=C&B2w^0TKy$Ta3jfB6r<UOAsCP7+jv<olyX}49
z`{AbZCF5>4!+Cd={}s%)2-d`%yfm0!vgf93UC-qOzi{yO2}NL#XFo=q!8<X~0RY6`
z*?pe8J$=!Zx}1K9mR?Ofzi8J7QMSOqP$O@;<m$#Co+-ktSHP7rk-_BQobS|~7XsVy
zj7SJwFgA&3#?>~|X+Rnq5udpn*>pq6U`5n-FHBQmEG|W}z~qBLd@cmc4sl3*SfNkk
z*Fz)e6hR)Cy<C$B<FXnDbu*pQLyzfZ_o1}e*}Q?^8dN-|08N&$?TI_#nX^tg{YoQ`
zx7M0-btV*S!zqTVq}!uNsz$D%YrttLN{V>|n7+PlQEwVEGX}9u@O8;ok?~;OSMs5B
zL(ayY;y#fvWEcoF6upFTKSO_0r01bJ#!MsZpjTk*UTl)je{PndMvo+^<)ux>{2*}J
zfJ&JBp;vf&1i@G7z+e4Wud~{Hid#}BcR@5So>?D_n0zo#jz|UuYz;y$=6S|qHAVVt
zH<Mj&^;db!{K!5yqf{BJqpInF;SVOFY~t5#7r%OHj0b9a+e0aQ7=#&FBoY~qVgrQt
zgd^b(v1NJAdiW?kRc;-a#FRyH0B#vfalHd&9=eKYr)2p=5zDg9`CpD4{gv&i<G4Tb
zfb=o=1sci8SU`zF`jlhQ;i`9G8fF*b`D)MW4<bD4fiU0UkTqwzP-D<~Nxmt3`wg1I
zetj!~!2St|2bHad3JcMjy80`8@Va}bgoqIPxPP_AYh>~lOB~3rUaE{TR~SNZUtl8f
zZ-Pw$3<Rf*Z$?V8?3<!+9<K?{gatNx00C^jy33AUZXVx11aFAY`h+T@P7LOu>tMYK
zgYCsI!kEJ2{_g9*DnQ)mSIxI&^V66oiuF2ZAPCg`sv9hZzp>-u7;BS|950GLi%vAG
zc)xJhRgqJ~coOX`?phN0!SU64K-+guo@UmJAGozYDLNCi48Kl4>%2A)%%$KD$A&MA
z%)M2%k&2$Jo^c>iR^GWkd@S)%ARFR#FEGD+{8?4Y8njS7m9*%-2z$igM$8}4V5ATb
zOwyND<91Yy6<yve{h86uqcKI)-zjH&kMm-C2=IZyz0CQ*@xJ6>1b=K?qa*Ss;WRJ1
zqnWx;#H$wqN<2kM2jT%IHz&7OB6ly!zN`9@=+7D$W)JvwL-sHpWF!Oxw|6M`UN`|{
zD;snhllbFb(EORLU@~~Al?IX3h%0T7evgQT*k=p9N7(s}(7%QHGXVeht54)O5`jE1
zs70cub?bb|pR_)bYN7%~2sPi#e*#v++aPj&WL-p06Jg|e>j%5rCFy|s^9!W-odBZm
zI_GTwIntY43RDR)Hc=)_?_NSfDj^witf*e{AsM2$Fc}PZc66=41PVwj(Bz#;#A7J2
zSQM3cEa(@l6WPA#v&3pXL0Qy6j#LRQAE{|RF$d~b@#4JHJ^6YJW~t<STno-tL|cjI
z{M{*t1^zwp@c>NG7dAH4QCMSRT_!BKF823?jWCRT!!=grq}HD%?%3ypuZ&I|D968R
zHNVpBqVN!4`EI_6^4rvdM*lPSCf(V{t#3Q}i+m0y>YMA=ig3{}5`)yElnEHaZ}{IJ
zzA0XBn^o{opvFp-u+HQ6!H*C7(c98%+N;ouu*qgbcScc@EkU^-e<ZtFAcK{ipa`I_
zB|oMhq0yssjbDwM8>BTccf#NeW}?849T{pHk{(PRR2(FuPs5Q5r=y9ZEEvr#&pFDe
zS7K3WWgsijR<kbS=8Q^H(37vonO9X*K2<U(EiFwg^(>Kugw5fVf=iB7`SaZjjx$>u
zTQm7I1i^Z_9lE~B_iR_`2UQjvX}Dw2Nn#_#%*AulpvjY|Rjc<L#GD>PVqb%az(ik(
zk~#Dz8C>M}LWI8R%di%c<rw7LSgCMSaI~cPjKQaY(?U3^tgo%v>S-+`t+p+hXO=2l
z)elR#WS4>bN;)Na<=^xkg0968`rn&75W@9i^}p?BkZO9XJfIy?9ABYYRHsoaUaY90
zvmnVW>fUIVcw)H1Lfc<&be_^OiaYu=YCU>m9NF*CAKK4EqAI*Iox<&9eD!!K;Z^8`
z=B079dRTY)>dN_2W1o9}jq^L&5o#Wq8KDgqkLe`8x_SA6X4m3$&BMSdy9C-Xsxj&=
zksY@U_YpTc7cy5Ik?ngv!&&Q5j_VKOT>92Nz0CtbhMUHeTw2ynv%d)ClKTv|YXO>c
zTE0bJiYSVZXKaf|ipWOG$2P~pM~OyH(p1NO>=5o)k1dZrFv&B~>WtQv)HR#R)|lv+
zX;n4}*xvOIF9D_wbRe{l;(4!mfkUxFzC(U4j&}y>sa$hh8a82#Hp|4z3XS;3O8gpa
zOl^QRl<Sgj>E9Op;(d2{x_P1<;~eL<D)~$J9f*;M4~S3r*-3gxB8bz84I-Nevf2IS
zZfCZH`CIt5`Hmf01x3BZ_JZ=>Fk?TvG&<w)Xz&`O%A^x;IBxXrgt6)!=}EAp>)AE4
z>(aIP9WL$M4~?xT?5Lm4Z`o~R?Q~2%@#%z+^y&8tZHfN=eWSTIb#OL5GxlN4xpS9H
z|E)f+e%rS!P;C}<TD|eKxcvwFjvKC17P2J8v<dZW76Vm-4*Q1FSHjN1xoe<KI$|9V
zmpS@waA$ny=u6JayGlBDp&LyYJPcwbqDjmW5&|+!LJ!tKCi)L0EG4XqoE~<+YcRxQ
zGzZIK4h5*P0yIVrQC!h8$-LO*1(~?Y*^fk<^_rR5P1*T)UCz^n+$ou;s4*2{$>Z=_
zXwU5uTxUm1vh%~Hl&8Q`(Z;mBqY=C$BcYk3ZT#1+8U8=Ro0reH&cbgSUwesJiP?6i
z_XhONh3Uy|#qZE%Dssu-(Qy~Ys9>qM6<sR6$*8phx|dm7$sRP6&a0X$3i6MA)IO>2
znc1JYn?WzYoW`1QEB5^*eGa*M+Hb%7y6+2D`SII&%cNqn`XbdiUIm`u(C=~0%rlM|
zerE+U#Uy)mPxY!4#!8&d(YHgZaZj{#?B*KdB6dc0;-tK+%%?FDI&oCIygeTMM}(Ow
z-j-qY)<wIct{)yu3~Mu;B!s}L8C9>i?~jq+^>K$kzze~H;qA?7M)}_BST~xuJrK9?
z%Iyj;paLEZS%fs+H`!+GxA$F~Oze)XHNt4cbmZ9P-gR#VuS5jm&oLFTjB7nw$Er>p
z<aH)dvsf~40rb@#f2Xh89{@RkCNvA3SNCos?zirnr+i5u-B!c>T@}Oq7WU%W^V;Z<
z*CXS;!W$3ar-(`BOsAR~jYb#1P2kY5HN;0_u6$lwular>ZOEEvp>{s0^2vJT($#!K
zZ@8(vxKgA1v<#`rV)bK<;r5s4M6E;($RmV^i^xv5^=yoGqew3OiEF{0ZAqnZ`$_$5
z{@rq56Q{ZkIN6@gj&<?bL%KU^M!4F)WW}<&&Stk*FHTR7lZ}(kdd1q>{oRSaa>zWx
zf!B4xNlP>LM|<aQ;!lkTX5v4DsugQae?(gf>o1cvb{@k#h&(AK3EK(`@@OuFa*SIZ
zSr1zsSb^+L1aQ1cD*7PX>l0DJr&gS{6@2C19(|Yxv71z{q*0=;$>K>51+zRK4VNz)
zm+9g_y1azGwOeY7r5`$9KRIo3>|RcNST)z4@X8W&iSn)7Z(qLacU!pr+}Zl<RozpO
ze-`)<yc0o+ufs>@O4{<vd;fMjV5C!bLyy;=bJJ?K;nteFvRMDLm7@LZ((Gg`xe3|M
zxB1)N+YQjZ-dNlA4eBZQ#q2>xJXvR9;{o<&nXFf+`AO;b?>nly{OFawXv^r4>=c1g
z--E~c2D*~n%{qpO)@-?K|2^hAy~CTYtTy_OmmzCp$G)<@E3Brhh|jv$z?ZqoPTgm#
z!{~#~8@|)45bi?ztF`%d<4*o3p|huW^g5w9A$6bHr`dDfql?T>?Vn&74Eo7_B7YR|
ztRI3|pU{JujD!97-I>ZY{J@7t6Jsvb4dc^G5ZHXM3(lS8%0ZEA1;w3v0d}$J6%1pE
zq9QzbID$w9q6i&`xU|Q-rOUav7GvYbN9)<*%XXLF_TdNe_laxyRU)Maa8d>@@M~p(
zgN478Vxj2;$W&9-OhEw#0PQ2eyoM!$frs{Bp+7>f@BZGGf~ALf^_S1#U|`^||JMKG
zTYr7UK$}0_{iUU;nrDFai7h1*)u1i(KmK^V>V*EH|7#2Fzp8G?#p6bSff0d`l@L|)
zfIZ4Y48W0`A6VPTz}IwoD<>706BvpVu7!hYE+xrkKK>!otLWl``8LjnJj!sa1akUN
zEhi8PQ@ZopHE&KG@tdR3qtWq8tZRc|H}~y(u&b-0`_lvb(P~Xw645>!99-z_OV6q!
zinaB-l~M6k0SCJ@78r8}F3j)khTVogV0m=D%qOt%q&sN3!Hg&6a+;!!(-J3<1k{;Y
zC=h<GdlO=cxNbwJt=hkC^Z(7SJ7PP%{Vl0UllX<8Z`SqyPj~(wta|zsLNyKDykplV
z7^Hwd>k_%3fH4GL>|594ycU7^ldha7m>@6#GC2&~pLLD>G2&R|$kay+7}!7SLV~<U
z_|xVL^E!<L773E3mz>}AXU!Tq4u-lR>Yrw87$gpU=!l$cEYhDv|14v}ye2R2CiwHL
zf??qX9ns27FACxFpXKE+NFtiSY=53Rl20B%N1QuqB}PN|)7%jwpc>iu&$Eh1&JWCh
z>ariMyhNyf+CC(QF~sfv^Q;meQbz@apSnXQ4uU@kd;VC!?lN&61S@OnFt|`FYm;~6
zZPfaY3+jy57zQM)0b4RLOG`%Utp6E?-X@BGT{&^_lT|z=X~1AG<O<b~87B3Ag<=kG
zIKx~DobDH+JSueF2&yNoP<o}n&!1&dq$DMk9F!(0%)O|=(7U8PVaAlT%uOh@ARNjo
zpRNSynBIK&0(qaL3%?Yk!S|-|KLe6=luv=(Ml@yTH0TBJ|GQh-BT3XXA1J*kkLow4
z2#G7^e)4PX4X!Q=^U5n~?AMJ`<|&j^T~agxT!4*g!v*jBT`fjM%QY-V)Z6jt0gOEV
z8T49Ef6Dj?2VkvID&0Qp$J{VHupWT5`YJ~CL6ZG{jx_S-NO3~Nw6~wwYeZO`t1+j#
zK&yTR_$5Sjb#9JRZ78XhanY!e#}g0p9rj!Sn8_$&CHOIxFxE+8q%H=@53hSZE2`d{
z!st=D+%7RGDZXBIme$ZPHz5UMxj-O#wwt`XwtCmYruI6FSuKnQ$d4&|Mh`YznkbL0
zy|WT#&WU4MR5S-edcZckAL%xTJ5L68LOTC53rxbmKDqAXtdj#nBXVP6))7?5|EFKC
zJ3vG3+{QF^iL^0N==ZYv@(e30t8_J8u%?=r<fEb>O4zPBMVItIUCeM9V0etNzzVN|
z1i41rxc_@D=#^ojq#${?@SV9kErnWU)zn0@y`sr-4g8PSs+1+0psfHHb;)obgryca
z=1Kc{^W}F#3E%t0|0squQ;{2RjE|0jmE+<!DaxD>Q4Ifi9UKU-0;&(*AK|DCF~U(+
z0$3PSEw$@ql+^RvhjTDvx7#sIr6NrH@SGAt%Qz4)HB8O68Cqmj&t^@@!gP=zk3X$B
zIXSPKXE*7LWioe$={ssIa}Oxr&CK>Sl$IPJ`q0PTYI>g;W-4YHz`!FAePCCIdHCmh
z_}6$Yl3<`DLDTN>#(=Hg;-ACQC#rZTp^!G~%$+xbGu=*9Q&yIZjorY(e`ovl@<Q3!
z123;4o*Q0K*j+K+9MLc_JH{FX3|v$zwyTZEkYA#0<N)jBmjh+fGBSv{$TTFnx+oG7
z5@a?uHog#r83AHm<`{}yzGy3f>GF{=Y!lx?<SO3YMF)k!px~7seE<0BKLO;Alrgc1
za&zFh*VbTKCZ7K}l`nrxMP4H}&ko4~0v7EOon`0kQjlN!d^8~zC1wpyi_)wZHiCc^
zx>S=r3+yP$&&4M!l@nKV6H3w|D?#|Cb#!3ycieVGyIH<Te)^3m=e5^$fU+;a%CKs(
z6tk@gI(%k>7<`VSLoQ1}GYo7LQ%R$uJf<W1397Xkkk@LD3vQ!<%%)>NTkw1M*9c2_
zOIVx#FW}WfQbgZ<F!1oe>RCf|ge<P^=>mW)@wa&T$xL2EC=~D#2zO_o6r(+xr+-I=
zAb(wGUdjp2P!acgW4<RxSPA~0QRH_LbS+k~#2<SSMMMq5*yUzuX?{!txI)Y+&PnN>
zMBL(k*Vosjkvk(ne1eXq<ixM26JDwV4*Kx*^Fp3EGqoiUlp^-t4>Ok*0Q|7EwDiQ!
z47+f!N#*Yf6V>$lj36-%tq1oydrADKd6O|pG-+iUT@|E_WnOaqK#*yjCXL^@dOTV0
zlAA|zbRs9?S<;Id0onKeHA?)q9T|Z58j1lWwYA{@Ej4(=|8kFY12~FD_??)TkI28G
z3rT^+`0EXg9#hk~HdMp^Oguj2rv^Oh;lIQ7<lv5%aG^S}u-{c)2}9!m-PFuY&|mTz
zyYixOES#_JOoI$W#Wc5Hi8kc{Dr`3^kkY76MpHlR?;KX;&O2hxGO|S?Gg>ipmd61B
z)+Lf^Nbrd8Dm0xL@~G&!Zf`K_IUzx{$RqURxg;dcKV^uxYzWW@cmh;Zy_HQ&s1NIH
zC>ftgshh+kRNG_qR+C@0ztfi2A}W3Sp6g4%*bw;Ye~(Q6up|#VQi6sWKzS}!S!WjO
zZ?qsv7m6~-C}_MUXx}N*#lMik|1&uZFhJT{bCqsemx-{8x^}xaRU*z!-4klm{#`IZ
z2pQp>U76Hf+GjLJf)L3n^~zJ)OoR4QZoi-8H^{e}D&Q6#%jV~PMpQ}OBLaq@6rT@k
z51UzoacxooG_;X%l;S0UlIpOJoB&yJ%F@Yokw$&6WZ_)H<-;l^fC-}17aSa-+U9m#
zqSJITTdZi$XIP-%l9*xh!JUqh#dL1iE;F3*<AcF|1>D=S<VubYHvg7>zg2`YDlBVn
zk1O*;`MW<%a=Z?_)$`NT9Hgkx50>Oom>Hml|7YS<PMPDsKyn;N#oWrfv}`%Y!;5u3
z=WEljE}Q*9J=wV=l{?w(eweVkObVl3r)+wY!I)G^xaYavx_EMjtRt`NfXM0{iJ0d$
zr&>QN)mFE7se*h7mcTX+Sjk3>z9AB|$O+Fj_+p`CnAguig1%zWAz;23Kd!wK_2UP%
z@_{@eJf)!s1<yi43<3#3@0&u$;>g0Y;w-72D8Z!eo^BqA0)3+~Ab<)KMT5>e?>CI%
z|L=3KfHDZAG*S|LF7*2Ce@!>X^37n|qXV7>Jp7roR{Er2tO9nol=43ZiI1?bPi-d_
z_{5e|V^gajlrMvr@r5VG5O~G=jGERAakP$>`WcOJ40TUgrLeO4JGz1TC_b7RtUgwf
znd$3knqt)a$p9i?=*KBFQ?$bEWK|zcjE1o2oVPW(YNLL+j}9Cx><QX*eM)v_q`^V(
zs%yD|^mMer^G`KN9Vst#+ck+05x*F1osmGmcxT$nYeabZ*hHj4D=iD$QG=RrkW9gr
zRJK^Mz9$Wd|If1w+R38)O}^UEGLT*0gIiakv9ZIyW$%+ekp>Z0fFl6%GAlch=<C40
z5OiYo*S`e)Ui%kt#;iSYC-zXL7g2t7`scO&P6T)FzB0waGo6>7|1EPqGLDK$V`V@c
zCF?JM5t8QRY*}2D0gV}PAJI_K7C$Cn(UzWa)H(n}NX^dGCDec=)NqV%%a<pU4aRfb
zvzyb)hJg$eB}q;Z5c+6l<w9CXB@w0f@FA~NC%D*VA#&D0c{@oh?;BNZFWTb~#zNRv
zZ7Q-7Jc7dRh*uE|1*ZPR$}&nhSSn#TWwmJ)8fTr87}v(JiJCQ=;>hT4^K!n!0GKLr
z@Qz!jzc#Ia@D0w<mo+LR<onKgIk!J+f^&MvFjJ4mAUO(%KueStxe?~#%payq1XKqJ
zI8w*hJtf{FNC#7Zz@;<4*G<@ecc%ZRv<tdCg@xOXky&KZJ%2}WVih>i_O}$2l;uMQ
z0nknOg$VxdfBPG%2hhB}JZ;U_b10DHmiFdnCZv{@DQb<bz!TVa?muvP%X$3=3iFC<
zZo`XWvV>^^-xO)4sDZ(f5RDfxokqK&y*+}1wJKrP!+G$iNGT6xEmqAO4ZcFr@Jgrh
zVW<f5$2nCgQ9_gqxKjHz9sr=CD3%UAcfFY&4}(S(v_v{=(iwN8JIqR-_niMlnMNo5
z{w6Zp!ev79-sA)bC@;w)ALmbF)(;Z`ME9vu#vq$efC)4}Oxj>45mQ{0%D^9KxJ@+$
z<>7qAZ*%Cfe6tYHh?u}8#m^-!`X7Jumd)OY7{XU9smnM&j}~>;T1B6unk&y~y~5hR
zwX3n&XN+9lS7w)h`*%qHJ3!=*Y)W0-69ZfM@1B_!D1rp_S|*MHhHy%zT1%`^`q%%p
z>Ho`4OjQ33<9>+n!m-c)Ul<qrH;e<YBF)z}017LNOeY_MQTA88Pjb5heZm#x3sO=v
z!=u6rD)ri?ehtN2_J(2tcEiJwiMYrUy?QYlqTc2O#sR`j^5rsh22^$vBo0!R5?iB*
zyOJPc4Bope!%Gc`fv>3OTX$iG$CnffAKaB?bg{N^ag@}}*v8W8B8NvH38rPprKtQh
zO5kBX2DaP;4gE2^2CGmST{Sgjab+ecm0B81?K6B@lo6}FwB?h+w&oL2QBmM)TCwsX
zr)@B2y^kF1w*~<{tz|2lmgKJ%vRhtsN)jbEc;!xuMvL>KDyI8#$z(m0oHgON^8u1f
zH5iSl%+}k<q&_uFNnLz&A*vB6F?^+I<G4Ei2(SOlAOB(`Xw04c%^!r-sQwS~;oyN8
zY61bD=Yk<5ct1212=4wz$Zhy<US2`M9O8cRe|!1yKfK(tG$ktwgf4VT?t3{Eg7Xev
z`pwy!*;ZF;AP`tkUG0F3f}WrAo%~=9g0JT?C7F<zD2boJnFKl_k}m8^#2Ga3j*LJp
zr0`vu{4SKqz}tX+JOn6`7SfdyuGAD;6ZD70wfi9%R{DxT@IyK<Je<B#6@B<eQ}(pm
zabclwMecMQGV+_Z1?8Jg$i|KddwEWBfEL|GBV1B>TqgZEf6*f{A}onH-BU_TU1jDM
zX|+MT8iZ)R;8ibo+K8^a115DX)=Iz*pHCfavd}Zl49Y=ee%6$5>^MJd*d}G5p0pEE
z?6tkA;cWcHOv(>Y$Jt5Hl*`lJJlYNo@!Hcq4D)J={RD4ZpPu_yd+DbosW~mUIz&Un
ze|GD??}5K|qLARWw{g|93Wes}BxdmwU;lMOecBNtr{)P=pbXMp)n%%!A!bAVA4ZjX
z10_SxSj5MRH6xb3{O%`vvj*N=T$!M?N%aW3$GPz@!{Qz@*pq+XGc%X3$7r~c-O_Z9
zpD=^Kr0=oWK+F;GjW$2T@};ATA|p}5<z#ZQzNs=K2dhfn!Ou48@e@sU3e(j3(?>ug
zOmK;afUgkW=FyQh$M#>!6m?(9AH?8@>+u&VG3m%yO?3zsnww4scFydbMXM{z+fduy
zo=KLObUyl~s^KQe__Jz?Fe9So1-8R2)!E`#=yiS$N0DPlA<IhAP*=6HqzSGIEDL02
z*iHm1<DfvgHC@2nc;(I0IAfHRx1mbIfbyKYTI4b#MvX$;Ih$`~Nv&68QrY9Fa+sKy
zOi0K|F9P4EO6W}!IXO;GiSHd6{3XDxSd^8mA7$7jKPW0@@Egvl;i>m=lTSO*l()tQ
zgP))wuK)$(Uz=$CJ++dWt{1^PGWhRchXJRo{0Lez!qGG_Mq971=KwG;<R&resMy#r
z*{-yLac2wV@bzyt?xamzkAZS>mJ?ZmfQnzSsj0FpEiE_$WC(V1Wr<N=jxoh@+S@bS
zj%%6KzeY!EZ1oy|*P86faL)!Z`dp8f5(960#-!^QnV1Tm9&RAC!!6{yLEI<bKfOxG
zwtpCODh6fFrm@;jQ=LqSejj$828c<EWsVFFTil$iAd4FB@cACcqheuWGw|~M0A!Hv
zdQ&^xG_xt-D4%Hj>X6h;=dz{e<7*8AO0khow*Nt`JCLI!2pUX=(0>8RY19TH2_@+=
zIfh?1*X+xudN|}ra(6V&e9lXAO_-i$e@1IlV3Pp?H}Cihhdlnl!Y$bySdgt)j$NjF
zqQ5~`7zT_M5u;fsK_wlPm#tBe_dQ4C{;~~zmWneGzzDFo_=0vhrSrk!n9P52GPlQK
zv8IP!SE~xyoKfXdz2(@%EPqF2;Eip5?{Am`pKgcnH)#3a=NamscC$;1szbwd+zXQQ
z_>>M82>`>3()-KPi?wRJiNO++&&<muT$E|oHfufjrB67zdJ3lC2Ar<>lG-0$U>cNi
zK+6}-IZm8$u`(+mmM#A-T}8~GhS0A$4pHekno^!X2e2G(A=qZFEG>#e@YCwuZz`HH
z<X^4Y8)d0$ip$7*eSHs$Ug}R+OSD1LT2JwsE_hO5%3U~Alnj0VT}^cbPa80Rxhb$i
zFI`;c!|(x}SvCWes)db}KyYYSB?55}7!5}3{l63_p~9(B-zm!Qq7iP!&1>X45=Gul
zMqp?({{cS4OA(PlB<BuuaBwuY;ay{#%{wPwZ}<F;(iNicFAf+=ue*O3CHnZx0e7n;
zx%&G05|WcOs>&J~8mPt49nWKz@R+q{BdACzMUdaTaU^o1_8L!N6KAH)es2hOwLcS*
z<#%s67nyF~p~d{xeW9qV41iS=!lTuTM@kA>Zn7^<{a_C03?cOj-I>T%gm{pQKwWY_
z!+Bi!`PTUt#$ua0>$kg|^s;X8khg_1ioz@QiT*E7H^*Wf{3p$yjf{*QlWsOrrn3E?
zWu13MmBH~Bwu{w<`e4;*An9fiC=<xQpwMJ73kfIf9;6J%$SrB(eZ)|oV3pMI1l<<~
zg4lU+T;1G!om4p6l0zfcybhUNf2Oq9?T%+&j`N?ETvACz=A3N}EMEwz@k^b2Mno_A
zFd=ZE1l|s1xEUbxFOZDDE4|lu=z>4!*b6OfPY)mdmX?9-l!=S!D_)tC6Ci=gv}um{
zW8_IseB8sIX|o>L?=8*v-YFoONME=-c)-xm&@MQPl3>(G9GiVjPO$Ie=lW8?cQG+7
zWG92<P}*__;K5R!+w2qOSlokDwkAZ*Lx|EVy8?+REvCL!9lH$9`=!Lj7LJFEjxv?)
za6V8j;VUa!>))(p{2b40+dFPrQ&l*bp-W_GcQA_QG=OIJfpos(ntGu4PtM9pP`Vzm
z<9&o?n21<nqLL7zTFO)qhv;F;@0L@Q#7xn$Ut-t=W=07K{48$q%)K`4&Dtr(d<Q{F
z*7GWDeG?WLnX?|F<h9wguhwe)Dw8WmP|xjj8)we${oI!Um6N=tusF}WZ88klOg<Gy
zDO%HuF<B8C_CkAw{O^q<mJeyd^gQGV*ETD%miu>VI?8?AfG%CT1^|C&yLMPOyOs&=
zNOzfhBM29}o04Ik5WXf()-K<Os;A_OL1Y<^VVBxyH{@s&2r${07DN{Ys@k{zsKxi&
zzr($RizwqNTzFa9{)1)y6dl5OxA9Ejz}Dp0)v9~HzI%^XwbUCjO|rG5GEndvp>rA@
zx&W_8|G_H%DYX9eZ5r+;Cp<9toc}e?=^OcP`=s}db5>r5i7)xaA#cxxUKQ{hAU*0e
zXKe-=ml{j7<yYD&Oy$_p@Rzn1Wq3*7*o1FB>h}+1kKF(ir5)!s$<$Rx@WL>3Jtb>A
zCEgk;g9#!a<u1?KCUs8RK<(;}qWKW7<AwzQBf{75_4jgn5!F`5OAQ>}*EVx`)|D+^
zmKtqQ4Cf5zJ3G_|n%{S_8NG7f7T1K%r0s0OHYL>9z-ymocznEwRM2a(58vR(7EfBj
zhjBs{0z(|m$KNK@VoeqVKH1~QuFhB1q)B?4?R%{?7e;xDy<s4JvTWa3nEiv`GdE}r
z5txQ=;G;a&S9=;ZsU)E?A^g%VQT&#KZxXDbS9tx^UqXpS?1@G$iQt>U0~DG~MkMHB
z!Ts;#gEzj@LG#7Ts=)k*Q~%j~FCOg*D;vIO<PQ?ldG8FCEeBPO?N(YdJD$CSvdzbZ
zQ?T*z<>KiSO}Y$q1`4FN*`VT_>)~{vob2=6@>f#9v|rh*pb0eTwt!K5sW`muG6bag
z-{?I{OGNipCmI}<)70US;RTJyOEczcto3goYCI#Zn!WY519nS|-sra49g*`dcib!d
zzI<0lKjQQ9@)BD1l=DFa85uT9t+wx6KjONB!MxkMW;3gT%O&sa-!-r<i^JP+Rb^E0
zfe~IS_h-FQ!@>dWKL)3*rva8aPho7Ao0GNsC6$0isM|aEs&9010Ooz(G{v!1vUuvV
zN-PmE(Bl;JyzD8%yyUdh0ZTMeDik^`!{e;^R+V*{(|k&5AezJmn`1yq(o0QJr^9Su
zADC(IJRjQ{EXTDo0~xW|Y5b}ceTuD!|JK;~X5&N>%%{N6bUe~oyFX)4SD)<bJygTI
zhuY|cOLVkqg&PERGg*ZFH;I&FPC>oyw+ooJr*A|ww*~9+dHa$H*QSg24W>eGDL5*`
zpZb8(&dX18jm7Tm^8UD$`EuHd1vA<iM^!fI)MPbk4Q@~BRl``Ab1BM=!D~j_z##A@
zF}#MpY51Tt4XoC80zynP%jL(0L4<CAGq<H-qGtTT>bJHPqd7hImBRVB6yx;hRqs>5
zrT#;?-qwYB%NeztMopSSC2Dlr8mrsi8!iW>#c3ZL9I2Cfl2{EY#U8E>rN4RKxM5<i
zs$*BHV89weXZlRs>3w}<Xbt~(=HLeP8g(+d8*2X=P<(uR{(McQ|MOkQQ{W%|uIRx@
zJDyuoS9ciS)(Xv`qd*sL_=$qSjOyh%ryUO<*Sz9+iYJEhxWHohRI%fwmgj0Y@$RzP
zT6R-G)u1{w-WK}=@1-2_iTMYv1hVc5ioc>VJ92@9z+4zwhy}NCzqeQN&o_{ES@Vg>
z9umeN@JRBD1PVTjT{Xh_!(;6TOJ1cOKR3aROf-yP;;tY)ULl#^t>FZ=2cc?jRlYBV
z#(oQIH{fQSqTFdBL_)J~7?8$koupzNVL7t5XOZ^JgF>e&j#UgkbPN!sB4>1OKbPjp
zVc4s5f0VCiu^$+G`O|r#Zs-d3AY=oY5?TIicD!7!>QqU#(<}YLY>118SKVyIdi<m2
zb7RHR*Dno#g3PuL^wE9Fp4$@MH>5d1ctdI_S>t(SD>!}Va?)sr6SQ1g7JX#~CE;_M
zoHo8d36(_MkjGjpKvhYB$g>d`Qld1>Qd&@*19PwnNMkmKR|Sa@k_<8yhE|gUHeFf@
z!3jN<Ro}KrTYc|+fev#pSXF@+JTKfyg)<ZU$O`-Sjb9566>St499Mn8jK$62tNO7Z
zNMriNVIr1jQ^wCE?fx$*!;S(0)x)t!QU6-~OymEw8OMH=)r0@m)O5T4eAi%K#0+n4
zepU$xNn)vsh>FUCDz(#5nQfN4m4Zbc;77KW)8tAeKVPq#0ykUj^lmE3Zp+*1u3`JR
zgSC<bVa<i4t;@aDKAZ^;r5>_R4~BifxqiFH?l#{xuKsnYV>xeb`yW!tx~4k61pJO<
zU3walRg=dN@d-Hq#wgfx4xJo3Bi++<U0q#Y%Tn8gu_G)tHs-@&iNL(VblPbb*xwSb
zJBF{$8{_vA3b3EF#lW_>%oBQ&$K6XxH}nfzD|)$-bA6ZA&j$6G6=Jw*xGIq9Bo3ZN
z;j7St1NI;2yo{ywMWd$8uOsCNK(V5j*E~k9R^V0p1l3fzS4Iz$)y>BA0+V%YAAfm>
zhcNCp-{xNXJhjx>4zMhJ<NxaAb~>EosPY)spscwKA~3~KlI_9=3D5`q=7|0RWt(bZ
z57*{OAiIvV2P5PBQs;q299+-pY@*>F@a^*}t%LTH*{-%07uJQ{Q`dBcFMZ_Vh&P4R
zN;jvjnTZC&&h}>NP%G>zznOR$3Ok!EGsU9m9pH=b8+_uj{ULh?A3R&-?jCoT%nA}J
zC&Jy=Aw^3(h0;n%Nl9uH9+J#k|MMX_w^K+}$5My=Pgz;njRu0%Xmn%JkeLoV^)Ofb
z8lJ1m8AZr};P3CR?5alkC95e@ur?BSn9HqJS~;Qc;_7BNm%?UjF<YVx0Ezo^*)B<t
z`Ci6`?<ll>IhSm{d0mbpA@WC%yrG(Q4R3MYoj&b+8K1}QNhq0_SwpPqxCfB%IEa}3
zoNV81y(~hhInSss!&T5T*I1x)KmJ@jOp>{S?FJ1lzdQ#}Sle?>yuGguB=Pk<a-}mZ
zan#Y?aYag$&&GUMC40xLF56mAK;8O$f2b$a#FkYz&ZO@9cs5Y)xFrRKPu<$?P(9Jw
z+T2Wdul^ePr~}KdwSe}N)J$$$@SESoLx0K0@zgV2rn}aNqVgF1gFI1&*SZ1u0Wt^E
zso7_w{*Mk;D}2G(klD#BL2pY=;fU3)iTL`q^I?CbWR}d!4doV2r+p~%+ieX~m<Ro#
z(tf(+-LmF2nwvnj1{2+WMi-KyT(v5{(BOZk^Bf!Zwj01LNJB}SieY^hyqqVwc81SQ
ztL)^&9{d`9#$Vs_lh^fren&}H&FrgvmFK*z$8E;_1jEntF<VTJUZl*aH)vxXyChZv
z-0wF1G#eweX$Dl<qB2X%(lm9!l9Iu^YB9;8mTiqHOZRg)cuJxzp1}!Px(YPBT56fu
z(hbBd9K|tFBunWCmxL1jr!x7>?-o=f6nM9Bl2s8R@`oW-7WSg>!LMgkpxiFbxQD*8
zIuLnrdM1ZU8RxrLwUwV`qoY5?z(#G0kSWv2QmiU4S6TLQw}0#aL5_6zzUNKnajNO%
z?4w`;Sj}`;MFLEB6>dzC>~89)QC(6Nko924+O+*KiOuHfVBFERR8hxnSM=1&Tcx-H
z5x75eXPKbmR1Fg6mz<fMs$dZ6ev0U##B2ZdFaxVSs@_~5fr?hZKhTu_tkT%l?F#qr
z3O4KSDWOWhfwQgK#mM%|#6yVmoy+mhu$|F+vTv75s9sOUHv+(XDjHhq$y%s|d$0#G
z2l77Yrg5AxwZ5z_yCit&V2YxVSYosMbUj3K`9Xs}8?p6u;ERIJ-mtZO;bvT%*HC50
zBW0S~3b>v8=hefP?ruu2t1<WeD$c`F;}EyY?2zJxkpTnJ&c|!IF@yRb^_O!*|3!Or
z*5T-atuN@g3>vy(-&DOhH0AaEU^BhuC0*_<jrXI{i&Y9j@*>I9%k!F6?_!>Bt-k`q
z?-hn|g(&Uny1^IxRf@td;T`v8vBS?-$yr5vB{Id56<TedvOIQZiVdYEpin$n!L4t7
z>D20<Lm7Ya^ET$5V9T=tM0dB#+SKCl&Ns0o=Glx9H21jb1gGQJno_~*dHBqtt2lAu
z^Hq4(<M&g_c)qm>omb9bCJqip$+x3rxtFY>CDR*++6$$owi2C!3WHr!mb~a|f5UKG
zd}6tYORvyAa8{TY^|xPCSDuXvR0#xeABQK%5GOir5yn#PFrN;ymMzZj%<rh=&ZTg!
z&de{4O`!x~lR+IK;X^Z?DIzE7aBjZRZ(DD+f=5TuD^?5QDDh`4HaroCkONxw6demh
zALRr5>`CzP6^g$KcIjcMYMPqj`f}ayx2^5PiZcYmD`)X()i>WaHPjm~=oicWdb%Fm
zipu3;V9xkLhCBg1iF0qZ;RJShaAR<Jta;^IDdm!I+RfvhSnU<7;OJPRr#4##W^90&
z)$@%?de2;rWexYnM-ay_kx4sKXyxh3pRkHKmQ^L<gLcz&H=xGPb%-W;F&J!~<w=W1
zDzHdp11(tvmC90TF@!=7j&%e4(Tud@Uv9UeAxBb?1fp95(KkHSNDu+3xxG;JajJ2^
z_QCxxrpoKj)xda*)#ZEz%?9UPkXOh8d_>z`UPOucM3z-&uCSEhT!CzSdn54yeR<qD
zNZ?E&4*qEzs*iyU4JiaKMn7DeaIbpgYm?dDlq_R@D*riS<v0gT8zd>G1NjC1z&PlA
zEeL1(oby)bwdvCwtmyQ{VIN+?B3{IrW7nDa8b&XK3p2UpBTk^9?>PKA7S-JL%+|83
z0WyL2cVA^K3=*qOpmiV*j<%5cN@J+E?9UMS@#ZqA)DT!gl`9UDL5zdNnpggU5fxHj
z1yd_qw`t2tOU;xMP4b>6H6oIx*}i!ziOEL-ABNgKSfZz!`Cp7R&Gys?W=u?zsVgPF
zttj;!xE^NpeGvk%jul5<ax8V6ur9S4qM7dCt1x#m$snN@h7PL?kB{ar4k{hY0zL)a
z7HSwd@W2PdtElh5E~SGd5YOcja_A$N)#gG?%D4h3dji8a)p5E{MV9&;eV&Ov>dV6G
zY#0gqS;lpB=aE<5kUbzXbT-E&Jv~OWDx;vH#v$At6=clWlpeg`6{bokF*s7V+}vKz
zQZS5GAPs}zr?mvGf4V<dpr8~)o_OI&WzNpf&I3%@w1jj<;`n%4kF`uM?`xmbx*hAW
zBQ&6u0ZGb9r`>SIGRx~Kt;@qoO7D7%MkFp%6Xe3iD3_(Ik9g5E67Y586CdUhXMN4x
z2wxbB>wh|FH&q3(qcB>Ew9y|-Q)WODXcfq!Qp4An@vHAc1h|KWaZPS{mhsn8HCOD8
zSj9oh8l#S7Wwz^!Ml>`M2&$UZ7fxk_zdr>6!D~-<xMdxOEgg4-bF<MEajx>n#q&0a
z^7pO2Vg$k7ng)8(0~ND?=z(LilZTa2>HG83dLvSU23_?Oqv<*@^_9805!#sCN>(Wk
z1LNm`rEKqTOT^?ly5fw+8YQLj#VcT#38Mq%Z2XICHnn812UA(RPlQ&E#^C(6jdMuF
zqKr`XR`*@TwqGm{4Y4#+z3D|uYS$C1u}FW+rF8o3dvIm(lRYD>|Gy%h-+5u7JpVI7
z^Yf<Nz_smuEaGYI#Lj3wYp4FlGBq=GuEOIL^Bd<;IyQ=|Ebsd@z@ripgv<U12%EKI
zNng08ohC0ASNO>WUwdU7u7Hs>(<a*ZCuZ!-mSShgYs1a8QgQG5gSymydcWltw+*A#
zhYo4ootwF%)Y-5#aEtS4hj7I6!z087vk0E~@xZt#iPJ?$yE-pAI2viacZKhmsP#TP
z!Zl{C@sQi5DCGG9)pk7^$*RevYd0ZbPdA2Ye!Mc(tvKqyiGOpE;t~O+p2*4F#wSKX
zH?bEkXIGWXn%?X420U2u(sswao_bdri&0f-fxr-KXG*$Kzma`y!zb<Xu|`F}mVQZ$
zhO_a;)~My65u|$TXi{9?8d<63-nPQ}eLwwuo^<P)Tqfm`svj6uLC3!;oOQDnq&vQB
zNk;EqBS3>!QlFmPkkX61K*-#0$@-waI;G$FYzL@h$#vVP*bgJUS?+mk$RF6>pf6`f
zt}pmzEQOYz#Ed0qb$^{{2@If)m9&|qOkHEXK<T`Uw7JSvIwSLvCp%dB@zlb4*1NRU
zNaAgAF`r3|R~<R7V>nk!=AZwxpL)&Ij;Rj5Sm4@ae*6SnY|V3vwRvL5Sj&&_kPXsb
zLNk`r)Z=TI2?=r0(N~r=@Ok>?b+%BY=zcH*flORkvUCHq)=TvwwcT^0-`Yva>!{E<
z;6WIm)dK-DYnfi1&F-F_#5u;W<iy0n=OK+7$;s_fPA1v(*si2CCntI~wpi_Yi;Zcl
z?_FtgYct(tf5@X1=$M9yzc_7|>hEI@eF~T-1aF9Oad4E#p4U&|@riMQtqte?rj6F1
zKxh@S<e?8(vRov<jH#Dnjiz%e_TjQ6F->FP_u*}4Xf-9=BOz{3I0ogvzn%*N%WEAm
zdX8k!%o7+H3pR<+9m^^zYRtv(d8Rei*Q+I_CMQczO-;?#n#ys0(QS|}uNa~P8d4o6
zd!4RzW}jbNc%mswJ8^*+0f2-=($f5TISJQsA*UlC28C;UBRo8O=^5QTeY@*;5ZGx|
zrb9)z#*210I6t0;{kc!_{GPh>^M~Sr_#j^6b*8V^kn-~Sn{U5P6<%ZwOw7$8XY|{^
zmoUvUsIFAN>%3D!Nh_ZsVg%ot8s9hs=Sb*%?r3{Q=NeNV7t&m+T3iNwCUNU077<a|
za2y-87$zagN~^0gUloU&&#*_lv)J@VbL_RJ5eX2lO^(kp`7%9{-#??c`}-i2vdH+i
zIJ0+LZayUIdkuB?A67I0=Dk*vc(61wM#shv7$bw5cz8p8W#H2JVbOx3g$XsLo1E;1
z7n3?%lZt`AHlu|nWDWXTxS#eX_}ac3-MG2?)=E3oZpmxXctW3v7+qtp)YZ%X3YYYy
z*O#5;mlw^hm~rLW*VN8!Z2+9PG~Er&G|18G*&%Yvqr8fjopq>%3AAI{ax$0_=P5d&
z6J_~zHw$v7b574#x1up}mz(--moHVduw#?%0%&Gd#Fu2P?Bmm3su@P*T-zJ_Sm1X)
zk?Kra9>*u=Kjg`HBR$P!enUBa9)BTGY1u734fJmVLR!3>ncdZkrW6ghgBDiY*N)G<
zEaj;l)R7?61~n#t1vhEB-R_GC;i`5LW_7~8Yf4n?PbrK|AG_eRTbv4!lf0#UU-keU
zw-3&hN$n;AUfwT7RlF)>zP3q@j9ZfZ^;;>iH6_f<!<tDRl_$Z}ipP&v%c8rxBkB=!
zj|}BlhYC^<wGU?P=2e?1Z29trQr7CL1$E|o8&QpBzpVLP9Tf$y+MjNw6Bv>iDgxeq
zurn3%JRjOUf(qFFO=(oeq^|r<6KS!rlHPZ`?(*^+I)T<(XNV9J{rLJHKX@PC(S4a|
zY&5_o9*Nz8YfNC?((W%ypmF}DX*n@AmVdI+#`A4Anb+lX^~ndc4Lx#YJ1YRNPA17@
zG)$beoyg+oP(<6PAMzow-$<F=HU3+U1U>pD^y-Z5GqfB{##VD8HLlN7{MsaM3iKY0
zh(l)Oc1WD}PTB1tAHDR=!1eDQuKe;Xe6ALODdL`Ruq-S3bGFwy1<`j}{;KwKtEE=Y
z4-oLeRJ(m=ZZ6ZT)p8NM|5wJS3ia&^iN^Sj^czmoU0hWgT_#scLQzB0!h}S<K~}%K
zQePEf`13K7KMsj`cXrf&_Afx(HlI#X;I~jU!$dJE^E5&&cnUT>7%)LaG25gRyR)`~
zRa4gzCyArFLllb8)$Vm%lE*8?Q8DzyCHZKrv46LH+23|L(}F#*6>>OE7H)x;We2%6
zd}y+E-p?enrOkA0-Ow}ITT*7w<z6tbo^{N$l}tEaEko6=7n;BkI7^{U<Kama(|S$4
znN^Hmz;G7MFipX;H_x77$6v@?SWPgTiJdzZt%G7QUzG|>`NdKh6c)4BZOELkKAiYl
zc9&v)ROo>@Lg+zI$D1KGN^{Ao2d-dS=iIWZ^{3Z%c<3QZ)C>jNXcoxLWSZx@SeasT
zrLYal``{Kni*yX2Do7?*$o94?Jvp2X6Lf4uF*mK?$zlKXcpCz7s(&e<7;*vHKiBl<
zanUV!lZ@@FOIQe(b_||dpk_|<XN~V=%h+oD{&lp|t%<}PtZv8nu`Bm3!t0Mi64>`N
zfT=ldYbSYMQ~9c!_`J`S)9ZK~?bfK03t?L>1po3>{W=<~KMEwv>&TDK_9uaT*~e%`
z*1%}tA7+9(8~!VjyP1Mrq&v;d^g&=LMjf(IkJS5{!-_JR(=SE3{)i|Tjip<OaveL8
z{>s;Y2+67!fh)MDW~+u3MYnP+^@`^!^wxW?bn>0eq1`D3)hZR%b#B`qWkGsIvSrr0
zpv$SYs&g@;U6g!N<w1`|bysq#c!7pXPWM%@*3;Yp@H_io>{acTV*0umdHTQo+Z^6x
z`u2P1+nD<8=1_8<D=I73)IM`w^e7%~uY)vc)JG+HcSnc#yJTOQ)!%Gaw%x15xivd4
z1Kp-S>tw4apPYIjUPU@FXDzC<XFk*G%5}kt+Er+e4c#W075kgAatXYT9JU&sb2JVD
zvz}&&GG6$B_wCKkX4#nXur%~^6lS=Efe*vBr|0_nPt<(~110b8>e_5rpPcIy=-mvG
zbr?8XLj*^Ej8A7|?^V>_$Oh?9Hexm9dY}k49%}(VQY=K2z9{=?;qtmH_dneEsxs@;
zdZlOw&l~uh={y@;9#t-Y9|ydDN+0(um-+fX@x}##Da)`N6Y1>6+xyy;YQ>m~QXPih
zFu_!7@c_2jUgnzQ?w(vLybOF!2+<~{?%<hz>(qDam$zdt$e}>lL0Aq{*OuD-T77WZ
zkZvicGXjmQ>KFZ)KE(b=oV{5qtG<NwK69sy_$iMnzXR(O&n!051z(}Kn~*XyRw-Rw
zOS6rMYSN67dj7)XXTc;J64R2tSupUQ!Z%nf-?H3@b)0Gp1(@WXxUZ4aClp=8^i33J
zx~0kG1~Lumw|lTXL3J*^Fki;*!n$$3kqV>%(iS`E1M-Lu&@kz<eeuIQn<2M%vBsDr
ze<`}b11Qi7NYpHz2A#(VKn1BnCbg&Mhtqn)9)!5ZpJ5~gdeK7nCFA}3*XJXw#p9X$
z%RMHdSqWEA++TjWj7p$kT57!V^Gj;rP&tKGG=IS3^BG{Wppgk>fOs}u7mHDc(fKkz
zv7)qm1x-T>y8A55!h=RXp~_j-e1(p=e9^V3VTI;bhyLHWA*3pfCN<|Z1EkjYr=i7~
zC$W;xOGDi^P^GO5{`Zn%W9?q6|I0I=Lz#MuJ~T#hY?_N1Yt}Q=V>j}{cu7-^UI_m(
zH1*an@Z}r|v@kSx>6Q=j&g65g_4dEr2&qq9;0kj#eWRe+@w*!Z5LJH+ts}VpFaW5m
zkZIvC@6MlZk9=Ld_9<xZ@O_v^nISz~s48ade5_q<j`hs(eYgf%&^u<nftdUp(pb$*
z^o6R8jGsbAnKvW50mft`?mr!^?C!2KmVFa@zwM-1%kPRB4-_NGoA?ah9qpM=v?DQ?
zIyU8F7ePx0<d{r6e1r?^Qr?#i{^+|Y<7b*E65GTv!4GIHg>uPpkIvf?F&^8A8q;N9
z$dNB?#DabE2147Qc=6NyVU_Gf(w&q?#D^$VLjN_N3$&-Fn>D`FrQt<^?F7}?kXZ#-
zySI@~f-ZYXrl0zkou`u>S5uxZr88H^+2C8+gi<N_hzY8uy1|vl)8<hii5~W7>ze4d
zYb_T!rsNvk08FZp$2QkP^~}+Z#1`<55_5MQB7vJvYA1B=k%71jQajqI5F)4hw3!BL
zjXtrHcLmX3LF4$T*uQky`L<eiJzjFQp01beFXuEG*V6iV^&{U7wy=Os7)%^Hbh(K$
z>qSrUf8A5;R@d=3tx;Z7=YJojFXwwWs!PoMEc|@iQ-j2JHLE)JP2^huA3ElM%)85m
zVFE=a?jd36n#i4lp@yF+*$`jMV!^XsY=Gv8*3Xp%-kl9a!^EFW&?89VxD+?<7xcYt
zzpaU#KpCZ8CbSp=WL+@u?L5#l=S^~!J6Y+yI$6<iR7bRXzBR728+}UGy?A*#^@pSl
z3C^AkkSW%gPgJ`5(`<>Jn42<Qq-WSi-F$RnPIT_`s4}ss?eym-xUf6wz*D>h@IVVW
zKj-=~tB2EFPB!^aX8tHmmR|Thp1suhw{LxUSM<ACW=iy`vFaO_xZq(zK&fg~`OT*g
zFvQOgbDOe|;yrEB;UrD6yowk@e&_1Mx_PyMzhL&nq2AI+2X5C<;bR6^LMaM#113Iv
z8zt<=V_=NGl%L^|H>#X}JV4o;#(C(BSC6;&WFoyYHanZe;kc<)bXc8VT}CF1k}dck
z*Y;h{JT7h;sC5Sfmic#<ZF#i)<AC;-?ZXpE=O2fX?V#!hIX(KhwInP>94gyG@5|cD
z_g9xxF9fy&!m~!VJMW`9-8jz^;!CXu#$A)lt>#SFLg;#DJlL@mJ$abR?gvgXK^ppw
z@DYAumSn;*TCFw=@F79dNn`0eXeiZIWikonHYVXqv=T}vc%LPlT10jIAbUy&S;J*h
zlkfe8;>E!}&YE3w2a}Xp!;HfghtC3yMXD0pi7IQ_!;o^b2yspvT&#lgVKWH#isr0J
z536NfbAZ*V8Ggd#wM`9^T9<nGA^>E_tLOe8__H68AwZI~vV&(AE?M=|3D0@Vh;1T6
zcoe;EoUj+YKobUcUgl6T(MCZwi0*@iS<0{=FK1Q-s6h?y|L}EIL2*UxnnpwL5CQ}X
z0fJj_cMERm#@*c^IKiC+cMUYqxJz(%cXxO9**RyXW-jJGSG%j|s&0Diy*_*1cO^xA
z(U1Q|*ex<W6pu9bpd4B#mqA3d%8>A4ZzW@aH3*K?`eFwp%>}(qAqJMR+i`>7tTb*@
z;GyBRp3@a6V_Y2d`zvkQzx1GO?@33nNS8q-0>9i7D}+C;ZdJHnwOVz6yiXuIgr&g}
z3soOtFZcQox?LWWb`_`warY4Cv6ij#I?vB$<Ix&O=>bo=*R7ZRXrPhK$1&|F@<FpL
zq_=J!%@MBX*e)dO^7^rV29|!pUCY-}xD@64&)DV99m%W)Q~;dYEc~t>eE5I70OodM
z=pf^(ma}y0NpJfiP9UJx31`mbyuSiZt8`OkwnYnxPm(~@Vl#elvIr@RUgCdQ#iPdt
z^FJ>^*)ILnrxFDb?$&wBl5iVsHWM#*WgA7NkALphO(O257v2!R(yQN)FMIB`#@$|=
zw*2|w&3!roDtAsm-qpzoP|KD4B+2x$YIu_KNO2UTd6Ktn#UQ)16>2(JxGA4QSJng~
zZo&o^zGZxQy6IhY>aM9P7!%j^5uqv3XbdsGd^wFu+#l_5j(bNW$#mnrWWAL9XfobW
zoJTwI_^fM>uNnZ-B}$TfHhdThz%?wCG*WH!9FC;*2J(xT+7!Vz^8$a-`Byq;AdP3l
zc};sS3<^b^sLCUMsx&k5{rBqNa5;~wLsND1WVAx9eh;QUvUxFjB{OGAbYW(j6I=OJ
z#~dg(x-1iaAowWF`moTl=kc0AWhS|ALy-J6t<=&dd5|7b+$@JY5Y&yHlghh*JKh*^
zWZbq+UpxSSQr&{Z95s6#p^%iQbmFb8oym@FI*?-7r*w0@){J~JpRz@fL(YY+Oi0BZ
zEhERmhm#*!fuK<2im6;ps)M-}_Tgs}n$T~9D!^<!^*vP105m{7bn#t{VqYNjG5x(0
zB2v}o^P$*7hL|{a+m*&}@7KZFcV2y2D^n#hNWD9E&-H(*Bk*QbFP1)T-u~4#o&zAT
z2^Sy&<`CK&_C#bW<w_KKZDvLbz9e-W#Ben$&exkQew>|ep%+U)>@|pN-!sZC4N<yM
zJ&4qI*TqHFb(uH5#zj4}^RY5k+689MQ#soJU)8x^e_Kn0CB=V}^k`WHKqBFGfmOV?
z%1G*33<l)3Y2zC|p-z?cI=B@)8gJE_-D@Vh?|MAtdG`OfhkF^fKOL4WmYVm}NByg}
zY5EOZawo$pBE8*Lsf*t$_3mc+l=`RHP}o*5=J#eOy<2Dd*{&i+p^`7lygZBVcX$k>
z0oQQEd`6@-xNP`~q^PyVT3kF>i~SvT_GB^dNX10u5y)+uufhDnX@)#l+>u1w6XTkp
z!D4&6p^hKGp=Or=E><&2h`zlpt+q{{uB0|ScTN-DW9%8W4WlYACc+}HZMd}1Z*cN2
za9oSw@o3qKE3yO#zAS&F0-Nc0-y6qIQFquSCMqqh(`Vp<fh?wO)q7FLr<Z%xUWZd-
zkcDvu?`QC)$PdE?0FbHZ-C)uE*B@{*e4L!+Ayj9tUY$FPHPmgSlMD!Oh)iHE(-sAG
z88J^F>p;&CHHhp@2E3I{_gRSRPIhc1_2ZR%Det*Pq@vsiqa$aD^w(^3et96|stx@(
zxhE@TndzNx(IV{n`ZL5qiyJF9L~Y^+F((RCD{u0}z*(`LyHUHzg+@P*mywJTr=nV^
z&uZ%+339G+@^R-t?F6))0ZM~n!q!V40#Wv>_wBOlv13-1WdW~#JhSWp-7S94VFZ-p
z$HD2L*7DpVClGzI8wcDdb6$)G6B;7j2N~+7nqCF9ym`66TH#clI7Fc!T2nZZ-iuFe
zT~BF+75hY&)_ZE<HlEfH#@**z!ECwI+JerT<HhrPJMLGEOB><Rh~{Kg!5r&Fmp!X=
z8>YW@WZ~A<qmj-CSbPBC$NMn0eUlSDVrp;5q*9LyPUbtri0CMqhKg%hHU+!lsy=C)
zJB|U^(~>ta$G`u2{N?=I-s$m})BVXq9O78>|AfS%bh+)-f9frTw@|Hjab?!~Og5qQ
zMG3kbM@u!Sl-hPJ?l9QBlxDGaGM`fiF89JNnUpcBoxrWHH3<e}odwR}U|LMKZ+wrP
z(R;2Ofo@M{SWhA}{x^_Q2#}Y`(STYv$}F`y1UE!}yq6C_%j+um8WxR`hdWLh*VmhE
z6-dj?lQv-KPZL_l-{hQ4Ta?Z4gp)3Ws~caLR|JRq?U?S}Pg#oXDx4xca5QD5c)?bm
zUa1ThMR$M_A}Wu=rA)!E!0!f~5Z}o>yaZa|nV)_v1YSLE|9Hd)IW>@mk|@bjT6Qtm
zoTIWisf0eA{i~F^EX#vOBU494H{s=8jq!f|7qYJ@EG&Tr9sW@t!$A`XH6Aj1@p+Hb
z(1L-fPqr8jb>TUO^0L`rE1bdkyrp<xwONP)L3{ybRH)Hi3llAW!-8U(&|2ff#UR%*
zdZgKw_VID?>WWgV-m(x~7u<%S!B`l5N9EBUb%yd{Ai_zRy*!FX0*a5Z?r+O9du#I;
z89LH${JZQaiUB~xuf!0<UUVdH)qK>$Y+ayIdFYU5^*@Tk?Ig0eQK2VEFJBp+Y-r@R
z6SpTzn>z46#jegxQqioB-S1{dVZL0ts3eUq%)~~oC}8(QR|L0Sj|5lSPl6jCYYFG1
z#aX-_?p3dBU)~piaG{hsY~t#pz+cRr_PaSy@oxssqHOBas#3gn<$69pzJOG0b9KER
zRn*b35B1TxbIYwxAg9W^@-wJ}-lkY_A$>1yw+vHd3c&2giz=P>UK%vrg95c_K7@Vn
z-gkg(a7(^1W;b>kUf{hGwXboKo(OevTkMZglI_hvfzn#cZ72$TeXVMi#8Uch7zk4C
zrLnX&bXFdicLEQd=kxTp<5=3{(AMg({|eM{b;&Tn%mkX^E32HE#I3Wh#@@H<M+|ZN
zJm%pbZF1i6&gBy@tU=!4y7g;b{hFG4!!7oe;faO2^C<5Za6M37e?To2!7y1XzuhRU
z+uMCw#R;x^5Rf5-E#2h#VtqDdp&!pnrxMjcBRL*tSkKnO998w^WUeOB`^7mDCFQHl
zm+l_1<ecqoyosk%@9*9jVbQd7&^wv#C*v`m+wH#;I>=D)^9ASeQnP|i-6Zp~%JBx3
zLLg|-HGlkIb*5;-<Mu%0`SEHD#B2=&0aIPCvX(dL9gatP*g?Oho~z1!zzVd&%O1}M
zzPVzDq_dlnPM4q2k&#7=WZ1>fv<l8z<wT~s7P#|jw7rL&ogw!4t`Q%yh}(&aqQK|<
zRa{bh;j&N<YjD@GRkc^ScB)-<Rx1DmXcpB!(*l~LJ_ArLw#@g}`%#}Go!6&b!T4|8
zK&ee1^C29mlIuI}YS=rO;zqOGAp*a*Ox5h<SQR08*cI={-NJu~;a-LT1tW=1zemo<
zK$)g`-0M~>M>{lRK+J57DKRk-GE@E*)mq=6%@>x<{mKj^MqlPXj+(U!uxvW-%&-jy
zHq7+L^W_L*5dT=tmgdF(eG%ui#a%y{uaZQjanh(zBMo0N_KJ$*v|ZsN7ORBODUL8p
z1avNC%{M6mf9yAV3hnT*4a9|upUq6Qw&+obGTnCYA9D;VYDulczfhru0W~m^N~>i!
z7Y|c!_gv+k?g0)laY;{s9ailqzbW=R86K?EelD#1$D3o7zj^fb{%_F9%<H&J{oYno
zlZJP68-#xy_o6sw`g<l~Tq1iz=n&OGyH4*%VO|$v{0GzZWT~+7_oX=QUig~KNFsnY
zFJ(NZyRH;2Slq4wSGV2_Fg+%>h8%Ox^dlM1ByQl=5-u}XS~{!}?X#gYeYZIkZU`{>
zxX!Mmyq=I@nvV`Fv5N=~S0QQAskh5MkRfhY>N*4BehPhL=$$;hT3?Pw#e@NoYm6ii
z7-@9rjig9IjdAf&BZ)JWGb+ly2;#$^pPx$yP;RPZh8skRb%`(Zr{#B>Oq7vjS<F}F
z5gbmKR8ZzF18waR`ndx`g}Rv54Bpd*-A~c<H=z`G$%9?|uTPgZIW~XKCD?o4a_Upc
z3xHn+=#T`tvhYd=-RKNh8BUx&XyfA@$_R8w?6A!5?C#PrI(UaVx-clg%D>#X%RjJ;
z5H4o6%*-Rdf#|eoWfGN*EBl71i)E2twrV|Y^UcVYavSJN@FqizR<L%>Dx?o6F3WHi
z`kv^?LbtYz*k?oI`K-I8cNzhtcDY4O>*BKa$@&ABTW2>d)GJR*b>uvSe3rgncZZjo
zBm(?Mq<*KOM&T#EPhPP_zF~!>wBOLC=GuTe=t+BMm`4(s(6^;Q<yhkatXzYHw0i??
zh%j6Ot{JLxOwaj?Na?Ku!@EPH4Y2@*S<U^~bUukc&pfil?}#0Tm}xVf?6(e%G;E@e
z+DCwiQ(@`4Lnh7jRnI-}fwMN;tzv2g>F1xmJw<HLnBV?mdvl8}6-F4mqUm5A(BGFD
z5cjI?4r(0_KBxYf#)Uc&8Ws09|I+f`;+yW^B4*U&o;6wuu~R&W{}P3JGQfY?u$y5S
zQ7X0={7~m#DB_Hy!M6@w`z8jGNqAZVYi*mANEeOGIgKoAj41qf-eA}nG)%vgmWO$-
zLmzcoBES9Uut;QzX;)QcmAsV70AlWfn*#b?Bb%l0(GdEF?ZnmN4hG;;1fDTk@X(d*
zw{zKmHdov-%J<z7VmEKT<Wv1EjfC!2q?S!Lo4PQ%>&8ut%PK7((^89ke-5&;im3cM
zU18|aQZ}@HxZUni>izsse&+q|l_O;Lah>0a#u8Rjh)Kox>S#Xw<s5U7RURne45NuV
zNQ}R2U(&>tl-L;PZ?vz@1Gh8>`o}Sa?af1y|Eq>=xj19@`Y%1~=VAxp@*rKsK2h*C
z+@0<63q#$CbUVEhf#;B(#cV!<IAzZ`rsnK;gJF*fj_$8*6Wx~2%(m@h1Rfpdo<mai
z3dpNns~(+f7OS=C?pbuP%g!ogx&2RLqGbF)o6u?1>y`!!B=Y@jcu|M?A1vW>`u8Zi
z7qmY%WTnEg4UzJdt;D{RY?g&~BYdZRr7cYhfpQpsP}Xo^#wq6_XQ2-<5b>vuLexpe
zRxfW43bdFPvs5(3->$fm?jkl|wy@Pl%&RJ(t*cK9ipUTmImZjWlTSp{oG@F}vUg)|
z?wxVPEg5As{(>7Wf0(-V8<A9{qY)m9ykt&8h{>}R7#$QlqRAP<%F&|^L?MKOSU5O{
zsk2Sh|7?X9NQ-jCC+l?O)R>)kNbWM}gYY#;AE!cbShRJ%DZ&6SLe|^bgj)8hxJvDi
zZnAle>0?N>v5fLK%hCZi_cF#7KyDqtJl76#0zAj35yNLn+)wDoABJ^dOLVj1>M{cj
z$ch%WI+Wwz-nduZNln;p);1he8M+bau+j#K#~|slND)`ZI*ulH(-N=Dl|;PKP*oe8
z8-Fvb65{zEN^ukEtOgXQ5$Q|Yx*@2{^}o3-U4Qbmm*C7l+`6L>F`as@M}N+HMAsOa
zNHzbMTM-(DdpCZjYS-=J4`BR73UG})A!oi0`%2QeK=a+fBAe5hP|Ep2)pZ9zmi_|-
zH10>;Ptm21r<-+%B%`AR(?z5CulXYRPSo7D@2QU3l}VbvEuNT<N0oIHX?slUMO-q1
zYCKMl6V3Eq1#B#f#6{lkkDp8ys)%{io%7>>xlJ|z^?<55!E#+UrBHo#XS|cvlVb0Y
z`ND$-O>2=aFw4&Z=Jb}BKDMin>d%&;l^oa9kGAv+BI@xCQ_MNU*I@_wUCK9oe`8gX
z6*z5@O8+uicriMM9*LEmdM8e9jaAt9j<Fvz<q^)TijomE<!#omvDsuXyEQ+v2NLe}
z6Eo4iF7oI|`ft9O3ZGQNga(3ErUsMEERKUpssWtbgJWc44*t;POUoZ@*LLpByT7Q#
zs1?>m*&`5o%J;KWHFVd9%V%!ZGHz#OoPbq!8lOgWS8bN&fQ)R2A*v$>ofwd2iFJLM
zDd<XfUI_hL&$OXu%s2PAaoGL0uT~^<NX#lfeMlyAMEwt@`9#B}Ebh-1^=dynV_YRM
zuJBTML8)%&dZOnly~aqmfXvZ;1aD=M)6w4gll=_Ww)V(Oaf@C>Vm+XVn)B1+tT`Rb
z+#xG=&=T9P=W?3Nm%AF5B%z4|bajx+5nhF3UdDx%_*s{bukCx@_uF_)z9P72t1gSy
zE|zb|wB9lQ=E4GL+jrwwtmnxyq1G8Qm+5G^T@G{7jmKl$&d#XyrrI=yicM|Vni}m<
zgMU?W*d~Yvk`x)_d8+%;{f&^vEjkoGt1P%XfR^3t4Q@%S`?6Z9N<c{^WWG80P$amC
zA&|>!(mH~uR5vKp73oDjbDP%0GT#DkFG8%|*roo&%-AEa9)SI=Soq_l3_)%lyZSGB
z)cr_#1amT!*mH8!wmdX-t9|MaI}`QZdc~Dg#0QCrs1Ui*rW2k?Eh^M)iYOgf>ks7k
z-K0_Aus`UPJyK~As0zhJ{eK_($fM_ebD==K2;pvqcT?F%5$y~mi;{hKPZgdaE@X5B
zFUg!#!Ju3l;&El*k<4mz@|8!@J{l-O4VS-===MO0nLU6X6Xa}U6#_Hx<CK1#MWCvx
z3Pgkz81hj#O$mnPnGWu4E^CxbE{MgD$n~+~q!5y!?1y8DI<TBKt*`9L5aqu16G_%k
zu~)stvqAeKP0mLw5J8Dg|6TLVf~A~RMEG@Ja7b-61y}zpHC)W5&-0<~&Am>PHn;AG
zly2|8+C7n{X=80@HSsWZlU*Z#+Tr*s&t{F}2qKnq7>vl0JSV{5-YJMhlX?ES2l4JF
z&R3aUcATOQ3@TMy@hK4S`d9+-Wftpq7_J*PN~Tl#k~LxD&PT+(g@@FU(I3rc(+2TN
z<e^D}dw}50_PtdYs9>epgD|(;Zf&hO;hcx@H&BR0&1!}k9*s^-eK+1#dg=~^QSHj#
zNK>z7iDJb{9q@|#go<ttN_M}K++j;z?BWjV<?HVN0KB`X*)N8l$Y5}PCyh7XZG_)g
z`qgTfJaPG^X*!(dFP;EnzWcC(<4Dexa$PECb+RiQ%Y<h4YnD(f=Xxql-5ra~rJdvF
z)ZFrc`TNg~eoDV64OkjD*?A0g2b12Pm$?KF+9GL_Z2lYVQ*b#L*GP8>o@g0PHVjUF
z%opc;v4Ctf+pQaDv^-H6G9SET3ks4D@%?z`yr<XVf=@nxRF~nlBc6x(?lsjmqbNX$
zC#o3F=lL4n^VL@K78ojRs=u}Jkf6#btXs_}%n74DNYJ!d^UzL@`IfQ!blW<5d9P8-
z2T^EU{^HGs0*&G}`JC=JvY+o^EM-*P$8I&JSBqiw>D0~b-gES+XhN{>>AVg8wrE#6
zs-s9Mc4QOtThi`}+a>PV^*SDi(>%6%nB<?=&3~)mq6CxfVkCiJ%@py4AppeqmR3I=
zV-s1fC5Hk#)l+KcfUazfq$c`YPLx*sT&BX<(mO9?@1sR>+)%6m!z(oZI+a6(S<p)E
zcttKRHgsn*`E)$SwgtqQ?)Kyyfkhs*8G6+!T?OjoJinMujlPG?QY#31uk=B)B+N7%
zRE(Vc6<53_3>}hGE_5(WnX%9-QA85K%Zf^!TMz-);P9ySxn^C6G#)fd%N+k?r(mED
z3a_U|*?rmyBBd`#a52GEf(_5uQ1kshB$CYjh+0ry9n+J+pDc&m(w|c#1S}M1YsI1{
zP4NI@(H{VVrgw=QVQm7CzLepO&n+`^+R|EY(}%&;X`wMkzkf&uh+od`RF?PT4^8XG
z)M^ged6_MQ6+n<s9f&SR^lBCf1&<(tE{lvVJz{`I#-3B{-c+7=K&2KgE>YV|Uy&I}
zc%)cd)eplK=0-q_IC;FeF!3vjc`0~D52z9i*bBWxsKb%0@w)<$Cg-MpSm0yl^z5G;
zIk=lB5gZSfe8sVA|7Aol%^#(_A#!YtdcU+m`w)8g*w2*wy#seB!p3Qot8t?qJkXIe
zu6u(zP_*xbyY1E5PCqbt{^eNesmxj=X@mATO;@9Prg|Wroz>KUUf-QiGxnfuCY|U^
zk>>Vrx7GAqaM7PyJIad6PB0Bn=4<e%!N<O+l`|#^JhKme)IJUmu{3ghNl7%6v@1Z9
zQV0MU1RikJcFg=dOz$!nBoN3999(GbzPeuJ&OZmv3Q1__xeBwbHdEU5XZX)bT%k*{
zHCteJumorUDS1)?JRzQNz3PWA;Fu9!55Fq2fzvMgT_p^kd);D5{;$s*iRVU2&ttzK
zMQ2Sm%|98Nw%|OL<{fv&Hz)@8J5Wcmm8j6_9-9{K6Lia0y)vzp%$jPg_ij>4^J3-s
zR&vGNd-zH|fTg%i<^M*MbRA_so;1WWZZQS&G`{jZ!+EhCqK0iSy(`n;7-dfS<hG%n
zay_qguv*9Ib=H~)y2GRcj~7k1j?XdY?j`-aZsjYw{A)JRU{!Kx^zbxjYc_uoUlbih
zA`l@FO&}cGz=$6C(>?yYqf=FX8vE5NRN!ul6*uNOOZ~KYMX$eVVs~OG;{Iuc)VC`~
zMf3z<A-(%w{WDgt^NSW*8&`V#3LXqncsT{W?c*d*v9Kk-l+Cst5C8C<CA^YpvBs)e
zo-8K^H!@oCO4aCk_}H%zJ{+~pJ}6q}`seJmHh;=_&GY(0uXr7DB!cPGH2I--{-=^6
z2hBEpZLKkHbb9yo%&8q7Sjr<}gBDmzi9<!ajNP<pK#Qqb(CA_#DH^?h$iVTh0e@P!
zTkcGk>{BCN(EP~y7Z=R%c&<8uD#)k5HkSozt?Vw={%aPhiy<%I`q%3Pi%z3MrfD+>
zJqzR5I($6uB-69P7Z2$jJ~zI&&hcWcfxd+<`%SlUQb1^UczFI~Pe#@aX|eK0S)T|4
zH1#jG)r|&WeMmjxHBlWTn{Z~iZSD0*;0sp9tm%81*MB2!mqCuoz3;ddVXTbb*mt0l
z12gqwx&g$ZL1@fx9*uRw-x1--JW^aX$`ZT>d!4l-RT~fD;w;YRm?QtXrm8Gg)zo*O
zJSd<WsaCHvLiQQ=OuoPl7q8q~*y|z)tPLUU;Ig*vp!UQ%4+)_sI;Hs|Z*VMwTRoWb
zv_A=f7K`hVhC6mkWf*jKjfaA$tpg8%qCO9>Kv~HB*gFACtZm=Be*1z&&3`jzcyqT9
zma?2{V>+HAZlTmbbWmZc#YX?qQ@N#<W{=gZw#x;amtzHs{=^QX&ipZN-w-bY&0+H$
z*+nw>&7|0uMElRBDiC>Tvw}&2Zd(H-3Hm{{t*xclN+Y_20wP457#;dTFM1Mx6Vnd@
zT#QjO;e8;n&P??x6Pj?^4PzjyF6phW(lRnSl~*&4fP~)~dlHnKaia)0zc`E>00@e(
z`VxapPXxY8MfOl3OC3Qv{oC0DHXhfL;$nFGPQnGw5u8L_?}piZ3Lkz*e+$5ez13X-
z)Zp)x!nl%kTVEd5p8r(U0(}DBj4E2}7sIX1!jChF{|57n&Kxtd>Z#h-5GLoDV!ru<
z7Pb+bj6bnl8Ctm%84>WIbR%3lTF6kMU8LMIMPub#Dk>^T?bn)BKz~zEO8S!03RqE-
z(W<)^ih~?V!#?+%YvdiSSy-kSrXj;cIwx>%0*P0p={C@}ulUpmvsokjl-A9RqO_$!
zy9;rV(2oys?n24Ub)*XWU>TND#%dWBlX$LS*NJYx{5OxbLrv9m)}hzEo)=fY;q6d&
ze{;~1<Bv@s$3V|xpV8jn!3G2FmQU;?xyCa=z+??#m*~OPFzdV{rbTC{RUGcN>6r}m
zYVdJPBP7C?ChTGv#a7_cw~ea07u|6V&21nkGyInoc)+9aK5$kGB1#4wVWw&`G@iTi
z&Xz2;CCKm2mvG_}(vyt8SDNVieL>IF_pz&EG}CN6r+dJ5?DIWLi24T_Sab8oxO(Xu
z@g$dNP%XEzH=Skp_x^q<PX*J|rY{*TRi-{tKF>80#5zvn_XA|{7_2DJPo8$}&5fY5
zU|j&Qks?k<+;zQN!m$vX;RT2w8~}gOJvaks7nAS+?RuRiwX5rlsE+%m!Im;tKoph}
zpy{yG?4jCtR2lB{OF{F0SM7j0%7NG$08P9ss-RtDFD@L34PmE4tGdTd3Af{0fVE@z
zN?dr(6C};*P9Ms3lkd9fmRM`GA{Jd<Px~tn8|O*r$2tkrZ0?u7Cl-SWrreg~DjB%{
z_PBk6t|c^n%j0g4`&PawH0QqFw^d@Y(HUj<-hpxYqLa7*Yi<aWl9B7wYQR(&{5Bk#
z(<w3qj)O2;1r|7KaiQjk(ELVJwFV3)xWaX5p`n%GgJ!N^((O3#*vOHxbi!G{TVv-U
z4=5K;6xF^LK6mxD5G7&)jtT~#U{lW`O^Nmkqg~KdlsD(5a9V7BRo=1bj)2s0UZX^H
zW{Of2zi&^Xqtb4;7NX(j7L-GdcjBusVsmz~40DYIZ{SvZK3>kmND7cM@Y)|aKQ8dm
zJlSou&$)E2DKR=v4KWnsGjby9NMWhOK|g&z2+mYf+U*McYHA9`Z*IDP3AY;36~iWt
zQe$v10!Xvz--vv%LDhPPO7v}xO8MVKdtO%Q5AIL>*kZpObbYdSqR=G84woNEo4Ot4
z7a!<QBaP-gj>+}kKT%n%`a!RisYCmXKIZvv?k_;IWy^oA_#V>m(ls;HsvV~?9%H09
z09P7#=xDwp&8msa>tn}~&Pgq$ZW(K6&qC=^u6VK^Xdb7eSom~BQUODmL#wJap#F<J
z@$r0fI+-VQA?!>hi7RaXOF5~2yxrd@1|9VM51qR{&#)BF<-Cxz61TkBL!bT5LpLI-
zPK)?LLA(FKRdg-Gw>1!SB28$2^v->gViE5oz1uRPd_Y~G^a*(WN;euVeeP>s$1R<8
zvEqLiG#?ZVGX8NK<%w+lM6$_P$UkJEKMfzvC#O5~93(b&wGfV^n<j&ZVPrG`3_%JT
zzbz*+JT2)k&G!#7W&Jj^HlWY#hQ4~NJ3p*?kW_^nyLe|h=hH+I$u_)TJlxN&s%LTd
zd8<`a>eT<xaydtI+AW!V+~$v~g7d@zVAMoo1+MwpJ>jmOz$nEY9MFG?h)Z8$vaW2V
zM?Jjvm_|b%%)mQ5TFFo_28&vipbRQG*6t6$rLwfGkwdl=H+*mHho%BU@)1!Y=44|A
zn>e?gPbZ@(OlQ?l^Xs!+T~nc@5yaj8bpFbAK{G=hx!wNC;I#L69n;1utTz6rngj_6
zp|EjoHQS-@zclEbpc}5rs%$gXlA*`=%4Ff!q!lO6j<3>8qglbV0>h^PaC_ZTuZo@_
z_lLXrXlO`@WerO4ZXz8OY&Fl@LGM;wq7n2#5+)c7FYUGE!`MpWVIUvHg%$XNrxeeX
z9}r)Gm$X38Q)wZ2c!)%KQlI8-Vfg^H2!YRqecU?|nMf?K`JmFzrxVZjn(G%cc_e)~
zd34^OetACqw>37#*edk;rASF-E*nhi8xczi0`?zkzR7=~h<SMM=$2m~vu0`3eNmHK
ztUXoIfuuXYb$3fFPP7@sW5rfZ<(4e5eJN&P9KZ>eGO!m)%e9lh#U4z2>c+>jwhX7D
zZCj5HaW`5os1L=ax|prCHqhTB166$7v>Fbe*TJg@<EqeNb2(D0IV}?;qy6!GJqvO%
zuouOx&{&T!K$cujiKBYnGE?tY=Z~0y@YMuu)>C_2?Trr*__0>RRt#Mq&O*B<HaH!&
zzVV!JUAh%)hHd{$=XEU-H3k3vBGmJnUI>>?***IRps#K5O8Z1?)z3=O?O{{xb%RZf
zjcF`R9IUEy@;k4=1A{}=B@Dj;`ztwmsYBjDc`FNUU*~x-?`XqnB3u9527C!X5Rr6G
zr2I@=oMmuJYk)_Hd*skuYbjcB8@8-4WhpMi^G!+2{S@KbDgU}hCihT(TC9rW`?qHp
zf|X5GlQ;A3F1v!!USD~|ns{oDFO&7+SwHq4{jhQwlgy+#{vO~k{A2=ghOv=LVXG)x
zIA(b;0%Yz*UcNMNFf3enq)CiS^Yimp6EX?A^!27~&K*i>H5Ty>7@a)W#Vo>Kh4g&e
zi4f5v_0sF~;>&ue^w5Y<-};WgB*2=n5+_YbHwjV(ggqm1*0>xmR5;oMXb+??z&XL6
z1sP(Wut$}KpGb2!v-AF0++{6$+~F~0v^FvIy1ZippcbFk+}76@O>sB(;+Y-p{bBnk
zi5VxK8Ix4G=OH)UQ-vM=g}-H~&U)VSmBt9FUl4@;_)1~fX$NC}@N@I}S{6MbL>wRb
zniQqC5LsATx>`WkTOJg-z7g=4<AOF}eP(2_Vmjo;TGpaKJ|e54sTW`6g|N%V$F#3E
zQv&D^K73|tvm}-+ADDKGYPtEG8AN8kn!)2-M2nJj7O$#P7+#aS@o@sCZeQ7`b~>%D
z|EL{K3n5!DgGAO<7PC?#cFrFZrDvG_vDDfZZCFpBDrHvi(mVJ{gZGlJ-51WcDIGBl
zn|imb^`)}0I>mgvf@D<x;eJtT*Q|x3Y<h*SHF=cNEV0VVro(+?BI(xba(-e7v-hCR
zpL`e#vL3qdCMs>(wRnTwNd<2aImCH5<r<CfrQ3uasmPiP20F;t6awgCOtf#=G4+67
z-n|Cxtk76y5a!bi0w4Tt;ciA1->ihBWCiag@s7nIUzC1*Nr!k*L4jEJ>&2k01wJa?
zc^hcCNz=R6U>*TV^iu%|^HUDM+~P^O!GwbO%=|WY_ldlz(qbGG^DJkIL*4V)+G+Vx
z<&zyUHEds`WCrzo=Qp-y<B-Uj?oD=Q@mVvQ+?u1k5Hpshb4T%Y58EB-PP(0O&OX7n
zW?B+hSn^tGyq?D>w9!&|NOObFWsGsy7VV7i1wHi$SIca5c{U?hr~J=#K3y~YQ4&2^
zszSnH)k5sRKAS3@uQHqZwO;g5>&T|Tf-mnfJVvVpM*ISE^d~&hIpQ5j<1dnY!+XR-
zq_XEkj4H#aoo4RuN+W03lL}86Y7J`aQ7HK)%<EHeki2;G0#_(kSTs7MW)ZXE@H+?b
z0As%B(Nx?AY*{I#>?3*csY)q0XPeb1<;n}1-L+3)=-0VdX=E;rv{_Crg|sFt(740-
zo<UomGtzYDop~z?63twaPRXfCd4%FhX(ekD9~YYDzR#nKF1{@ASw+8z33(7KhMc%Q
z)Io5^*@B`mcH-1kVJ{k^Ny`{rekHP&(~{EuIx)e6)E<4$!*sONcVUHb2Ok+UN!!%z
z->{derokon!QTlvzlY)VY9WjFR!=pK-H5`HGke#mmtTdQ23gVd3`wvWtdT-}XZgOa
z#*nN{Fcmb73&Z!^V>jI^W4&GkJ_i(#1^H87^22K1Y;lCALj=?u`tsAfOUUpYWQ=}|
zvlrB55|8PmHD|gIK29j{H`=M{;lMD~Yr|f#vX8r6e|Ypkh4-7o!@u9=(P+26y?8mD
z3Sh778Hk|%j1mHu<NKd4r8rzEdZ5;o=DlW4UAu*>P1s_QO`iv6j^^9--D<C0##HMD
zuMKCX&6+6QyCmd8g5nfjA7;5m*RZ0CAj{G}(9-%4qz7JE)I|E+Tfqmd26cU7g_pO2
z&&{es`QyEr-f}9s-YO013~A5&u6t<T4@n+R!>`bzwGPmVCol}YE#-q`8edZA%+A_g
zidg3%x+7V$t1pW2mmQPQ6M)uu+SB^=9I^OeZ?bGJFmY8mYw0MnrP8Jj${|1hfObs3
zpo0EQB*W)oX7ZAExk+vRViS&VVvsm<BAjE=5E1<R>w$21SWT=QElSR!pBUoLkgEcp
z;%<2=iSk246jJ+&N%4kiu6kYzCd7F$2#E&5m-yE?qtX1?h_-<Gi-LCPkh}KqELAzm
zv8>q#=!@(A+{}U%_8E6Z8!Z~y!{Jf41+PY(Y<|npQGg<L`N8fguCk7IHi7kh&ZR`5
z!&N4t%u5daiIEY>20_o*KD>LOndj{5LzDUdX}8s&>gr4W2F!P2y*rfEEhc?QIt28<
zWcx>zIqSn{kj3+_pAcnb19JAV*QCXWV{z>bwY=%V6!%TFKrLX)YQzy4kAiP<J<Z1y
ztX@)B!$nlZCLWSsv=jCtjLFq=;X(X}D1?%31c;HPB>U5QoKKdL8C&iQAcvNf9Y<z|
zL)QhA+Y7t)h~S2Uch<TiJ&}aSpRwV1ez;BaqwZ4Z1y4g&7e63TBcyEjRGADHIZNo)
z+mQ}$w?{T3Kh%%A*+sO4!uI+?*BI1lfHGaAS0BNNOCp#@!5>+S%RgVXyic7#^4bj!
zOq%IdntVc?AD-x9#+t6YmJ%SpxYEWkmmv816bmlZG7nrJs#!*$lFiCtx}Ah$+ooPi
zdH`_$X<8t*=}VhpSoN_P_Mn}hS=z(ey#aF{ik%*wyPd5Gy90{1B5Pc&d^>rV1v><p
zcI!=`im%h5bB6U*g>_jI)M~VN4+Gb7=C|#dN)9tQ$-<8aRm^B8D~~vadAEH!O1yUD
zN0ojp7u=cR3mO^Wblo+Qi*mHmk-Ih3){(3}YFWt~@?eXSNehqibJJzc=DFn2(;=y~
zT`l#ciQC5b!BHpNq(41#z38p!bboW6L7!?D%x$~lb>58!3ijwqHXlpYblu~~CSzst
zO(yYqQWB5EXAN4b4J<bu{j{ADbYE+|$b*n5yUS!cDqNaDE?bT=sz}|b1fzu{gd%Kd
zE&$Inut_by+EhL=)t}}XHwsE~i_mc#W=8{6+r=-f^IWPqIqNzkC6mi#^&&ujt^DPH
z8w>QVr)++@7%bv))r*(z@);Y&??uqUJYV`F>{NUT@F3~VGwM8rgN5^-9%~OGPD-cQ
z-MlY96i@uh*>@^h%!A~|X1swO09Ej^#A9I)l?5u-LW5(S7mfvfluVRg?$wR??;e2>
zCH2w`HYXL$#r<N&HVLRIJeSrmjCHMCCGSa6->8N??Mb}q%7$sBQ|fgoF3hUH&73HQ
zRMwy$Vz~L^O*+T<4eE*?$a2=;SC}n`*=ye3a_Hmeh`!O+c3RW1?-CM}m;q-&w5#d_
zH4}q^?tp}xuK^0qWNn#InbpG~;`C|=o}O`OoV@&@%cK_{%O8>oCBw#WgnNe~ng3B7
zoyq-d;<WLwbQ>!~f~M(+?b9-5my2U<1tFLFmw45<%fX5F3&Z4;dRI|DpTBCz!#5ru
zAXl4rN?hA5=1OwD*s;aftv@?XuM#DSqQhVAPn9wh7O<q53~PuzRx+%~<@UX^$b2U~
zOvs{!gDn9g>E{ne9deA|YP>a0`3CC3yf*%|D_Vmi?9WXk`HwE%H<eFMg@&oP9|*>L
zIZhV_8O++`<;2l`eoz)RM>NKbyQog99E3OLi7uYX^-z$ui21Wrn)YqezS<WQl?SI*
z<wu;XlV*)deQj$E>qZd7jpR1;9v0!blA|hxb<)_2V0`XVg^{29NLx|Gvf;k6{OQo|
z{$fnM>D42?YoaEvY#U-2*kvxRehOa%yduHcU7B}j_b@8gR-c54--{O7fB%IOCsGL0
zlVPe_>;(T&<P(e}B+~#@pL9k2n`z(K@IBHT1GFs#;TPFbw|ia4_b6*MSnIJ`eCPyC
z;7?A3KTRGVeD?I~!&-Ce(d?KXeTB;rHH!q6+SE~fH3<bwkE@#Cpo~V}thLI1MBgAC
zq>rr4ou*om%>141-|p#`RucN~4p9vDKV7(JJ``A&ADr;o<U5WM?JG8|t$j``m1l>A
zuKfaRKThn`NXWwLJJ-24>C08Dxxo8jXU%5!1E8yZJXR~Blu}|J?q%o4NS@?Qb8UZ6
z!3UUW8A%Cpc0#O?lecdXk1*^`)N}Xtd!Ygwo#|^46^V4J&`?e-xw<7T;k@q5eoO)R
z*5Tyc55)(9TSOqriIL}RLd#w_dh#XD$LDIJd6dSd7}ULN58~)P3n}%>R(3?_z`#I!
zxT*;lcey9GXvJw6^oe~V0sU6R#_bb3s=0_lokthtXue;`)ewfJnOqZylyoU`XpH_3
z4Zr;Wyh)t%3SPN|{ft9UmH^n8+p)OO_R=s;*`bg0vx#-U@=#ht;MMpG6X<9zfEDMf
zabj2F-Ecd}{^OLcRHxzV=6wTxI87COssUV%84Rz6c81eW_GWI!(R|5$MRNjnl(1ZL
z;*77V_iVbWZM4nIfGV5<UDXX0%%I;})O_7manP%acUF@X0tXMj=jRx#xgG*+ja560
zc|*lo*Uc}L_NEreQ&+*dJ1Y806>>zl9i5`)z(}<C+;N8~7f`GNrxavYm||{^H%-1(
z#1+`kwmW(Ia1sKYDsT5HV0I08NNye9-NvCFv%XtvDN18MtQ!lG<DKHG9sK<$Bo(^N
zYuI~JQs9wz0|!>W6`GEy)0+l1PGK0{cTSKOU^a=(vrV=aRcrC{H7UJT`zOeR%3>LL
z@#st0pd)7>-4Kqd);eQy?;&h45S)lrkF%MhQP00-)0NXwQ3dDArRGaJY-0o<m{3{S
zE=0U=9nO@fjOZ^ccUti**)z62IrvQmV(cMAjjXK%5ZcrWU+)TknpFCh2%Cgjj-rJJ
zL%FwxRt)#;pEqCn5D&XPKiWuy{A<P=><~MbrIcO>>sY6fSB4*m#PjUuLLxOhqum%H
zDFsE~irX$Rd-TXWHl^(6%O~b+r1-vJlB+_$L;rbhLgM6#R_2H1225EyIIq$*9ltdc
zEyp+DWZ${F^UXrQ1RX>309kF@isatiGe?*UZ*2~7mq8LX1?Ejna0JXI%*U>p@hNcP
zKT?l?(<aTi_27r=B%s-HXsuDFO?J7pPwX9cw{4@vUJz0z@OJ)gW9>BK`n|La2zJqq
z%Lyq*3c8EMhb|l?k&m%%(JqK!K(pkZuaH@qVxWVR_7k*oJsVF>jM4=FAR-9Im1aA)
z+Ycou>@RCP{{k?rsR;Q(uKKe6!aP4x;1s*sHd-3<=y)Rnbgd6|?7i@6?66lJ_{W(k
zP`87FWfYvQv%b;Qf5)y@OVmx&i@zrdet;QWZ`ox~%UcYiDV3Qc`N1&@TdL|?y@aS+
zHqGwk%?gAB3@bAaxpvyi`JwbT?q1ffE@Rs~DHcCERM+1A8vW~rIuCNH%eDBvbhhsA
zrueg+<52GQOY_EpWm%=)cj{B1HLZVJUBs0>l3EyK<GCzvdjNRKp?W<YV;=k!Y6%FC
zI4bpwrQHan$}kkg9rS=z7-U<{1D8Amw`{_e4Ee6oWM^kTJ?)x0Lp$6}^+4agz2$#8
zGpc&aj=5U`+@7FeOk#JQrZjLfYhl71V+R5h=*0KUZlfM6ze83t{w)SS^6&{PM@>Qo
z19D^e6$+)js%cmC9Rd+kb@0GK(~i2O6~Bb#^TYtn#n?_YoY&2|;=eDSHS1S+>~nH<
z38~n25*w4_h6SDcJ4DQna1xbSDIHKzP|WWyjM1dOew=QB*LJ!2NXg}@h~KIf85Wi=
zz!#>xx&kRmWIx2OU#NFOy;s3PKYBMDrQ#izpeftRuqbTkPN^hX$}uMxLR=6-L&cj|
zd%`Uid?8Iu0r~a9{Y%nVR+(KNDW_}it8|ocmVbJg!-WiWRCX~Xn&vT2l8jqm-cgWK
z5}7ExxurX4o&(^f7C3cSJsI!p3L(#Zy<<f`w0u`SP~nH-pb;<3`cjz}YfGFUCb}Tr
z<V4FN(*>BZ3T6BKatNa>hQgQu;pumdC=`alRByVAREjMknqBqeTch4oU9fg?#-nvv
zqzvv%=Q8pL$j-vyJMM)EUIKPhs07x}4?`oeQE)KD-ACWA2To}?pdK8Ukkp2f^R(H?
zH8j4aN*}oNMTXiGx{n9)gLJvWM+h~M>!nqVT?<^A+|asT%k=`<E+O8Ux`<rjL3fi|
z<8p<pX`M$bJn+z8y@Yi%ri+~VdWJkzRUWgfO(y+0|GAL*uOch03uTH!?RrT?Wv_U=
z)AEm*Tw9S0Baw{Cr+UDNyt|uXYS&37_-O$FI)qYZvnY&B#h>N-rR()>*vVo(Cpo#x
z<i*SvRB(3d7H+nGA!xo|DOjlFNre7sDpLZDSS(SOUrAUICIsgFz8;Tudksy6eLU(o
z!(XrP1V&dBaAbqsUx$uHy`%Z7yEqT$-!uD~r*f*LpyP$wY<%6nrjcdC$tixI){zvM
zTYjsbE<3|%!sqrCpV$vwT=WNMNA2H&xoP#>2WHvmyjnD_%{d3Zl}1g>_uj*SlSkBV
z>l)J=C0weRGAOM*lUN2Ssky&|W|(v4Ex4Ovsg^W=ytt3?r{hn|xySV@BPwMZ9XCJ3
zpY*GI`qS#rklUB7`+ebSt0HYNz4B$JA<}qF|1>NjI=CCDXF`U!*)i6BE{pv4HF7bW
zY+$)fCkH#?5Iho{ZF^BXbfzkNMF$i_9!%GkWoIE`<|8e0Fkj-Ia=SD7>YdSBZh<T=
zDLJN2jszNP^qzFlX!3@J1zUa~%65WLt1+6lsNqV|&U}x(5jPl02Z`PGDa}i7VkqxK
zG?X}N%LT2XDCy|y<EUNVF35dXS5ikWUZ}LLbI2CywrkdS*(E^C>hA3x>&t%L$8(t-
zFitGN9gZpR$+WowT0dAmOGnF9tToow4N*)cX4WL4mKg}g5fo9N>FEpH;(_5|5OJ_l
z%*ne#-uJnkEE3I}q?}cgwXAor#?P0SJjGtY>J#bZ;bCEW00;`Qzk^Ria)lL&LVl^2
zIkn*@f_*uCeNmuj0xb9b8I@}%5R|zhf|H}f?81}#ybRJ1tA+`@9TR5MJvB54TxXV~
z%&^lWhx9reDZkG`Rha;*sNCeKbv~XaxFy)VGhjDVpUld228^Vvg|MqSn@_q*SnCfX
zta*S=0}l^v)R_9R{NekMvk%2A=}h^u$p-KzNr!eL*;QF@mSE6-90Ubmj8Mz?JK1>?
zaM^wC?p0l;l2sf<pdI?5x?9UyKCo0*N~G)w3-#m{IL3V6rZl%>y;w^FgEcEp3?rrO
zJPmRmH$jPn?OgvMCV3^g1d&5(vxGq>CntA~8>Gp=w;M4sGU9SBwO9A8m>?`4IP#4q
zvwPX#5`8@OPp-{pq`omWnEyAU++1p5SOKEef|YJruJNUY?&SXtT*=PKw>YMH@yG`2
zDSnTQRcC`tt<-O^4r?YAt+iW~C{L326wAsSVf5_<?XQc&J#X5V`H}XoFW>DryAK^=
zEGN0{sMUDhJHXBPuMJfkr~%!>n|S1#jTGP7Ce(V#?yjx^BMmCmwv?ueAybuSw0*|t
z+-qlKaJIl?JlY^kuHeHS`4H_#6va4<K)yAM()%CzZ~m^+w%K0++H$ZIUm!4g1V3Ip
z1zGNGMhliM6!}PUEz|-}<n?-;f9~<PJwe794j0^acGnXT?c&Ko{?FTQi~V@xT?*jT
z0$-!D=ppf3YD%ekAanC%97RlI<ei@eMJxPss$P4Fw1QOXZ%EnzHTt7>y!XMBYFt0c
z#t8qdZ0agONEN2<Hm{2nB<FY#K$t#XpRO+M%v<jaaidKzsq8l+LOHDF#DF<t<iH|C
zfr(%cxcSiGz-~p~pA{fwz^jH8RX8yBIFcTY?_0g^!N~#CyI2pj_kxnKB=8C^M+n=!
zU=Ab<qAZ{p6hOeaj_Nar8`sHni*j*!w{7{!`Di6@q~#0_IQ&MM<l-&Uu|}o{r?xi*
zyrQw^ctqBScH@{v?SNGeQy0&rOs0)?6SbZtL-bHpyso<>V&a(ZiZwO&LZ<uep3uD}
zXRMFfmuNja1)maKx!2-(37n-q&|~GkkUTPb6q->mt#{wLQsqVmJWaySBBD2i6Bp7n
zL8PgB<wCSZ<rExzzS>1|rL0Zgeu8M`yRW7uN59@pXEZt;7g<ds7CU(AwNdPC<^`Lb
z<kPz5lz$f7_M1X~7s)TanU%D(f#U8nE{ymt8Ooky)YFivFwCGLFXQXs1UPz#xJFtH
z_-g-(QZAK+X)yUZW*o#T$&n3f&FA`))&x>*J3rswLZnUEMq4k<9*v$K<eAoeVgC{T
z==3)uHGKKlEtGX{5XZdn8@uxx(fKcxnlNqE4tSceqm^9#uv&ibIG@XH`q!u1Xq%3T
z81NB|;|9kFZg{meU_$1Rge<E#jV5>e6EJ<$q7C7GeOE>54PY%tInj=lV9P@YBIiej
zY2P`wzuWPH=jbonL+!2Ps#`RTmBRhcRo8!2WNUxGLT$98F0UuekM+6B!Y6BZVvw67
zFvH}CwujkKw<`3G>OS|u&5-`9YE1x<eRUhHq;uJ3^gayq-HP|M8$lb%f%Dxh_UNRm
zpjuX<nv3yQ_@y+bwnjR}=C+=B^A7aby|QV`y$mVN$pAX0X{nM)+t*uE{)eqggx+Ff
zRPWlJ*&SKA_9B_m#!wEM1(99H-e9Uv&8wS~a{t}?6CFQlymE(_F75E*>P=^CJYS6^
zK)x?ha-<5u&l3*_Xtka&(w5R^+x$-7YXR5Im$@_+U)G>lpG;ZHSh5x93pO^)Pye};
zwXlc34n2_~oS#1|Jf7^!M2dJSID|fV&D<C+${kXv2#b@}VA{&4EG!*YGpv*rDCorp
zWwoR+t5{0_U(cDa0saPy>u}>za^5LIvK=M|MuIeLAs0J+qUZVTCT+!eFOFJXTM4;h
z%<t}P`Zg%3e^IIMO(>`BqPWj%m6SOAltoIMUS?P069cb8Hfvn7A&43C$HTLNBdBrm
z!G#>g3^)m83ZiOiF<FF<>DlQ2qFyJ?ZH0cc8oR@!Q8*Dr$m{19<&>{cVL^O6*PzgS
zd$<gW#I-J&v!SHq3Ckht?5-G)$D?;g1(S|aWqKL}TCde#0ABiJ8r*R0>K$k%kYfzu
zA7h#)Lr2s}jBhE8vU$N|qph#cwuEMbO58QXkUE@nLEENdjxt^YkI7F!_j!Ps*GllB
zk9=UfU+Mm1D4{!9k_M0Tp%f8M;S1pP5fF9#R=eSKAP`SOLX0yTfAVKXtOFokQ2;Sc
z@Hn;!H-8HT8i(7V{=u|!?U{`TWPGsDfx*H3ekz7F7M`M2ue#&rnShuPfk&(D8@RJx
zVkgs9z#y#fs)x|FU=Qe<6=A&Il>bEjmZTRy|GOCk1rL;rw0P2Y)*z>!V~x$UcrlFf
z*-1X`5Xwj@3)%Xv5+PpJw*p5m&@eMAQCu34+&g&kScFG)HsknCn`V0D=YBBTLLLjk
z*ax=3K)>8y^9a<%f!xXS|4wXpeR;GfDch}u0HLKhW!SG1iRkDk8c&z!Fm-!z)T6Rh
z4)T6deB@tXBEA_cy@4=U*Ov8;J6HpSy$9QxS^XwAN;n=<{y#e~Q2nXvp~?O7F<LRp
zvfEMv{XagV+T+#+R2y_|arh7^0>ldMX&RE=zb?_2Gl;0$Kj2`JXX(;ExyhBI?4n00
zJnF5S4juX-SA0S*KLDJvK^W;b$DNe|J70Zv(_Lw~29{J$ZrCs8kxF8L-k6)`hWGy4
zhw8G~aR;CQQt#>sc=iTdzJWdNYW@H_*6;@U>jbbjQ8~Z6JnO`43XqaL8&5V&t|=#H
zZP9{yxp_k^%TZEYi+y<KEUg(Wfs(6y0PC~yOz!S6Y+=gI<hC16iCp<WK;OgdspxK+
z;iKkci<|;K`}Bc^^X2etg^bO6UPf<W%{q-YVdcTYN0*CCOj`AECZn}~>prsWu>n)1
z19*0r2)NIIYez+C0sqGffI%%jC8fuo=x@mdoSo<+-~TrrVPX&zbqo?dQ4g5j(qw^u
z{uDllf60&wH}6eBj7zVK#4R2C10RU>1lO47_wC{WW$K#`BI5mrUh-nGF3vv<tfneF
zt@OV9tCCOU-YfTbV{~PIMVQLdc_l_IR_K!(o%dyl?<sV>y#)Zz*8~R^%n9<@o6YgR
z27Q9pFoEe48958UT4#7C>@ey`(%tMTNq94hf`pHDu*HO7Ur-QG(ay*P^F0UZm!38p
z3~ofZKZ-MNDTCW#P(jLwWs9EFnF}ua{kh!BGULqSM=jH#k|eUlH~v$hvW&UF6I;P&
zC+?n1oXk<V_+2}oYfq^0G{R(xjB!qbZ!OdIWAVcbMlqZ(dzSSF61tf`jHWQS$Ak3Q
zvpad^P?d_oYIkE#F&K1n5>W_8bXLL=rKt_*n{Joy9B_Wj{%j41#5CFPPm?4C9reJZ
zOAdWC4x_p{;`WDL>ku?#yQcKKqlemiJ<{QoBsrNmZfJfsrQY<|&A1bAwvG51_kk3U
zTANuiHuKEREFV@1MD9Ih00~1*_8+YOp_lhBs)WM<?{oR$d3KJ+cH9^82bwrs_=X`X
zuGA~2umiAZLTS9LB}~KBQUL;(CO|(QVZ7U|wo;|TI1j!;=3MC?p`!szx0&2ehw-dp
z;634Bwx#O5J6g>qN@g`<<=u|dgYZlylBy&peMmgU2+B-Xp3hj_w<B-&u3(?{A``Vm
zzdfp8d>wnYb?q{PP^@u%3ph*mNEIdP`dnc6{4c`JIx3ECOZ(k8jf4buNrJmO1QJNF
z;I6^lAwYn}2?Pu7ZjHNJ2oT)e-66QcSDCpp_q}W0@817dt5{Iob?ThGpZ)CL&KG#c
zGkbVGxp+K!nxZ23+W^aRWb<|1ZUmybin_vEp3*kS8f&uyP^0jTRI&?P0o;MVexro-
zuVoqAqnr0#B4d{}79<nz2a~<44RJwqP{m7w50?-XiC{g}meF0lz`BrKKnXmf`2GmV
z8r!9@sgF4AJKNoLc~*6&rbJqjhds3<w;9B+a~}Axn`g3aJ#|wlPu>A*KvScQr{`67
z2C7e%J@mW+9jmAv&;1dC^503T6<$CSWq9atcRR?{^i^JaH{BBH$Kq2)b-*&2+hN5A
z+P8;Sxv;nGQl=5Yi{`sS?es<?hZ2Mh_oU?DBNgzy^&&zU5l=|2xOpND9-f%tFcEBQ
zbr|4G?hdyxW%T^f?JAI`_3eu*`%F^{QPpb#kztdpu{9KF_8SQXE^`u^i#}5WL2_|G
z8>X*sGnV&y7>{B!wXE_BC>rqAlS~f*gr~jH?4ZO+{%4Xj=QriY8@96YeuP!gUb6fK
z9$L8q<v=q>YgQOB59||5{R-UXk&&Jx;xn0V;fr&!+kkC8)88NA&WO7o`gueW2|UC%
z6LHC(l<{oAg6zx4sf@vqo>K_Ymq3LjQbZ>+NnKKabt75S|6;*w<<^jVV7*JL9HJ=*
zpn0aK$Um=ufw?{v%=?J}Xl#3Jxt$yT(Ab0<)^{9IWr3Y6(GfKzto8BMQUw8;&rnwF
zDF;340}=`C5{T_;ZOy_HYPdYgkammL<Bh3i!x&s$l76gbkL_abQmevo%N5xw?;D_q
zft~;WhvLF>cwLU_*TXG(NKX@bpny4prDwa+xZiA7vA+eg(Pi~b<Dnm_v>6uM?`W3>
zab#DI864w;a-zN#07`ri>QY}kOqe1G(zhEdGXITG3>=V3m>NV99W{j3?XBW=PO_J|
zRjozVCy0uto4i-X-nU~WYMS~w){E%_jtHAc+r)9t?Mf~4IT`f;l)Q!A=Yiw7n*P0d
zLvPQ|TZyK{6xc(@Gc)Q&6{ytbf$K!m<_q4y34{Uq9m2qP)U+jp7iM=p@M)a439%%M
z0rZPd-IyOYar#Xa1Tbu*=|7Aj6|LO5jmz>R$|{}JldWjTA|K|M`Le4AZG*-y<nwzb
z9{E7_X*(fKLvZ0A1v^(-&5mqMcXhg^xzqz1Ww8dWLQz#Im%cns4pW=BJ9_nge~s=n
zpsE0kxBu3F2An<@Ehx^P@9s^=Se#eY1Gp3C_!>V_Vu<P7yOhTq+?N5hDePi6!O8Do
zl1|qvejm@RxV8(|pBMZ3#VzIWx>Tfd?&7t6ROcBrLApCX=}E8YmQDMD+~h7fTCCw{
zK1$Wk0Wc=4Z|a=|N07rm-fy8oAeC_^H``A=ZEf5|o4_*<=6BxH*U2}P(E)NK*7^a%
z2%(bDwPp3I-yRWr%+76({K@Ik@kLH*<*Vo<HGsjO&t+kF$I=g~QtFxuRgpU{6dZW<
zVqM9u5N;!;53kppFcHAUi{Aus%RfG<d|55d7;CnIe7Y(OS)<adxCHrO25gWMNQ^2N
zK<wyOpO=Hwe6D}eq7G`+DnGjwno$*uNG)NX<t7v{()(ghG=Ki^#=e4WB89ZL@$8pC
z{%`TC%h=_ywxNA-T;p7veil1oZcDM(IPWc0t@EZu62;L}k8?qJvLKmv2*~C0vcb2R
z3Ih}v3*P0-KB>hZC1c#U=N$An134k--thb}YGQo2KIa3D!)&w5kzdbEEOLB*y@ztk
z9YN&I9dIz-1809Br=t$;D?g|8kJ1@cP2E#73do|pKT7z{=d}Bundw}aTT|_Jk4Mwe
zPn`5~<iJ~19m+o!5^yBnS17GgOpkl+bT;y8^T0UFiB*X>Tm{)d%6#tNp;~B=gSGb!
zhqeTm%6(<PWCErT>@3qZ2UjG|_9U0VRQRsg8<J}j-)I&3ASJ4*b}pT<#6(5A02W2?
z%x96!UFI>?s&d~)F&W(HLJtp}SWrxQl%!{xkJ^4G*Ym*=PBnGBhEiu}&L3%w(U}~f
z*r6;c=igPJ{#+Zz0klkxRJ^mG&9Bj9@?V!dJ?SrwJz%ok*7L4oi19i_Yk5LfykR6;
zB%lIR^?+L%k?VS*nd1}=$uW+Pf>ugxO#v}6ew>ei0w{L4KjO!ivxZ3LoBB<3L>_Mi
zX825)9_~7tcGv6;i%;B5R@aQ3_I2WhhP|27%*Qhc%~!r7))mj&v`%&JN^SSxq@o>p
zUZW;)nYIFKdcF9O4FRSjP5K{$=|HW<b?MIb*7K2SZ?=U&)_Zttc3zfiYVyhTH}b9C
zp3EcJI8=D|vXN_PcAx@OG!i$@Bm7pwcot_1U&_|SOSeIMmwQMiT{=BaU7N(l(u?#W
zqJm_4))=4^O7uUHkcz}~^EA9QRTvLQ^d1qoV<a_amLd_~rb#ibB5TK^fQ|JjBI<x!
z#fV4npsL5ti6*il=Ifm?3UTiuYFZ-Z{A;Sa4Y6d}wNT<;rAZoM50#gm0p4tcKQ%M+
z?q_k&A4$Q|XER@S<t+lgANjJqq~)a@u_WZmz#%1lV;V-H%p}6UuiwT8p+k3hsQ477
z$+c6RHo;37e*bVki~H-sb$9kGzG6Obb3W50(LwpKPGktEYn@tztGsXeo>_2+F1d?E
z+I2{-GWkeu%DiHG`_7%K#&X`*-TBx|2kF~IfAKquS>ZA{0BSEB@(m?lLU4uN7pkI}
z2s4*$r+511dAke4)ThPBK3aC3)|qTaxs#g@=VworgSYzvM$hRW!)EnKMv^#_l$7Df
z@Z;0Q8HvJgk9zsJTjqGTdH0^v?bIkFIQTcGW!Tu^LW2??A%$bQFhSG<NwUMh(B#Nn
zl4U8S)9)#8YN+?qgR5^E$`Y^S7oZOUcE)|mx7TjzveqNqc%j<w2^vO$8e-Znlls5$
zLwddtbpEImbuTHvm}nQ%6yAObTF#Bv?Mp=|Dg~!Gb*BNmIoxocyd5j6S`5-IpubvY
zlfd8yy))|D1by6dFomC?7II27Fj(YyZf<TNttd};2AN~}ZZmL-SMpIiHCGk7d1Y}3
z4VAUG!|ozcMKaMn>TsMky1m}+OcX{tuyb_qV<(9cVbivs+yYn^bxKl6`Gj4IfP0|C
z-%65BeLs=)4sG+-=C<j)?M4u}SB6Rvqg}Od?O|C2K<*)Tjl>W?E9nrdl_ls(YVY`_
zQJU{Yf@2uQ9zkx3$znGJ_sy5pZbg)c%K|4iC#T>ckT->+9xvgDwbf}#GI7Y4WjlwZ
zr=d__Zfo%IJa=%&Y2>8F*_*xQ&FmH*Y@dD6-0rDMczW9x&_vt@Jp_&<<Fy^W4qoH}
zsOW~e)ukYPZ;XPl{VSmL5~jVXjCkL}h~0De^D8zTC#Q0m3*W^?n&A%xej!LrTbfJ)
zYsZ$Zk#~tuoIdWH<x_E><*w_prz8~Tx%<_TtX=I`2f}yI2SdH}TYaRGj*(1p^WQ5S
zQ-<&NHz4X9{T1mv5pO(6Yd@~<RyL5%AT3NcqXIKpV3T3;O=Wz2PXME0#J26hq^ggs
z7;YwX9Tz-|GDEY)kv@bjk2c&6>c?84g_tV1cEnrOungPs#sOnf>?fNW;flgHZIN9Y
zEk9?~cEA8krdAO*Wjc08MIV{qUjOkI0KU!G8mP&mF_>|DF2k)p`uq7x0iDv3(mp#!
zmDyZ1%+(J-K7j>TTmZfHDhI$0qztdhB(=k<zJAT6x-UyxBpom3w41wbb;_iNiM*6J
zRS)1j6o=FB)Fj{TJ@_o=KNAt0O&Ur`WLrnpY?(Wi%X8cghhd&wNy*7E!{^wZc*H6?
zAO3U!m*SWADW6=YO;00%i?oj=f$G<eQm>k*Hued8Q*%~|;^k4sV83@p<@tqE{TmQ2
z?iTiSP-hA)XJw{?H@$H^tRNCx#6?%_<cN337bBh9)ur6WatBNjEm$^xFz27QLOSi@
zj5y>v$p9x0{`es_S7}Uao%X~%ctaCCMyUEVBEopPpqmqBiFI+b6i1{Sr?9W2DX%~;
zlJZ*|pz%FrDqG0C=`g7Nazk$Q(44wYFF&G;r8i*L(aDX#E~<hg@on4hI;hULJ*`t&
z-6etkvjABldw@Zi>R!(_o!~7xS=v3HcL`KQ`y`%WY$u;9k(*u*K=yWDgp{$Vs|@K+
z9$;vkFH!ZQap+vHxF|Rsw!d|uKAl#W%=;YXUED$6{+?xEPO^zz3RY9bO$Ab29M)Ia
z=Z7mAk=Q}mF5x>k;Pgu^Z^i%>tqe`@&aFM>oxvC1+VxT<wed+xKBvgN8<NRmmi<vA
zRG^N1!yB!mEJtqNVh4qV{c)$kxg<7TPkfFK*EN|(C}y9Gbo>9gF8*;I{(k2(hg5Xb
z_&`nMI7OQ;d%6x@S^HGPznz5Y=y+zf5?n#QS0Q<nYroA$4tD*uV;|GItjXM9$0+Nz
z!dyj=>{c&$!S^78>w278H*)Q*W2N(SRwfv{xF(`Z*y7<_*Da9L+XoaFhML5DWGfaL
zu21N$#@fekfAeIpBccnP?~JROnXeuk7aGV^XMa-G2C8ZMG)tW}oN<`3v>SJ2B3axe
zn!F|AWzf6vE0ITu^xr%Ai1)IP)!iQQEJvM#m#Nb!jqpVv=M>>nK^5dauhY@H61f-Y
z-WQ}oLKnCy3)|$aZ*-cJomIK_XDXeMbv}1Fo8UBzkI5VWt~S$SFMiX7SQv^cYl=oh
z+H|;#y4PCFU7<?B{)57_{v`69aK3eb!0u^|{RCH~)Or~q=*|bs>VFiKO6b%W)kcgo
zHrE`+={&u!+yO5aco#G}pPCQjyp2FgE59$xK{Hpr$8t%AWT-S)?#3=2)6&pAA$gsf
z<ZsgrEZ1hQc-#r+-Xu!z#*|N;o6W=INY%<(WG8uQ9=vJUczqoD&wvTb&u9s@J4;!V
z^!;FRQ^aVsV@d!Qacg1nl$xKb?}86Df7n|s?5BcykmUbVc#z`%lt3<AUq+LhyO6qa
z>OazA>9IFc8hg9c0@Te~<*b!XWWT>K`wi8#AoCt0)V$qK$H3{5A2IjTu{^*muEg8Z
z?{*p>a(5?}GAi$j2CeM&EaRyQ%R2-DR84v0rP73*_chitOWsp9s&Y!S!%<Z#?h<%|
ziERs-I(5v41xj~QQ=5S0V+?8Peb8v<$LyKFQFjGde8!t-CmNh~CHT9m46LJH8p_Ht
zBlxANC@+I9v#;v|;Z*6ktez$iip5av8b(R2Dg=Q!C`8;=1SZzLp83{J)ugQY&^>st
zWQc4s_j7*heO8+V-lHAWNkWVh>R{jdoftGphK-=)Um>^*#h9|;r~8#HiCOF0(kv}G
zx8a~I@PyJd*bnVvszt+=p+HYKX%Ph*$Z&Kt&X8P=cYj(dWo~2?uTdOrqw8^Ge?-;E
z3mIYa15{vmAW<b1u7YKC0pUFo^cj@tJp0WEG=LfZZUwL*PKR2o=<|klJkSdX>G%-N
znWLrp0$aPwB;82sOE*_C6hhL<&<2rb{QB!NtnlYMlSO;{yB|!gl$2ru<i_ltk6CxR
zn7gt7#7Sw2AA)J4)Mjukz`)|k_L2U0mO7UKi5_p>H|D|MU1!h;e7R(h5g8*9X;}*@
z@6eyYmqkVBx6}qA`fY}7Ka9K3cZ$R0=J{v#=Yfd`vE-?e;FXLpO}&kZAnrdSu6Gtn
z#DO`?lWb671HeyO+rUi`R;Q19I&psOZ`c7qm2D^U%*XTkCeiND=KaIxw`%(RS!5|t
zw|9R<y_|e}mk4@QQ-v~z%tKmVT#r_yR+a}yn7Xh1lF>zZ^?XsWR<1j}wUufdQ&7DP
zh*x-X-k@@nwTORXNxjgqjsOntvK}|tD?l@K$$e+NlzwnLT7W+d(tct}t##EP-7g<n
zdN7`5?g3&rv~4UX_3e_6BZ>`weg5ha^bYd~9;JS2m4HKM=Aev)tHEpDPldM|jQeSs
zV&xGN+I`Sos>*x4-Ye8Ys2(6(Fnj{K<6q%Jo)&0tsh<K<A^yzotUxNVD_!>ry@Ql$
znWeitdq-?f&O>>Xl|^+ikW&ZVU-1q040{M(N4V2M=4hj7-1`!qSI@k58_W&=g>zL`
z63Ay0r)#?xL<sJF>9ljnH&wVnR98v59ixRY6@rA+1J01Al`zPtFreHi$xyJp%<2t#
zWL)7L2G7FEC<y+)Mb^$*ASXsF88BrcA(mXPgWq$;KR=$j1*w|vKy2jg0@(d@O}pJV
z(vwZydUp3+_V}ku1ETlq+@p}2Q1Txi?r7DPASNj6*DXI9or!l=I>e_qvn8Kx?~j1?
zPi@-_et#7y?q77n0>)y`F|4>Qw?5ntG$o~XGPODL1Cq(p8aNm0@?f^#kM)byAkd~`
z+3H%Yw!N}7I6o6R=^!$SI<x_<L&7{L!xw@p`aSe;v#nRV<?~#c#S0&^u0%XY(H!%c
zLx3e4+#H4)BLcW62A$?7FjE1@nJ$iS%KHk1gWQyxJ7dyQ-+13&W2$VF=0{2l7B;g+
zj9tH!{_uv<d2cEl!jMo(PnU)ChVp=3C2u89>M;ZK!kMQ{P^era>|WfrU|b`*z%f4U
zKAT7H;dfW3HfpCTL5Exm?FxBy+m{Qx8d=Poa}qDU<_!v5Jiy1X?VO1>xJH+<2>WsE
z-Mu8P+>3v3IC~H0dF}=a17%7{hu%=q25{RhyiMk|RTM#AiQLqSkv=i-iRq71F?Z`i
zz^B791Pa)hS~e|VL_Bgi`d*_W%^DmR*<4iYzT|5Ukw3RVJ;ldQLm4b;ni6%Rh~YZ~
z+1f=^B)oXLoTYiM(XBkI=u=yDj0qKF^M#U0y;lM^`cCqNp(;T$gu9!|ZhEA}L>Dr)
z;?^<|NPznZRj3Mb9W?j|7x>-5Y%&e5rSGs><qOIpKjT-;Q)O~n#Mijzy_L#H+c1(M
zu>}2QQzxapS@fQ~`A;o!AW>9`Y2q^`k*pTx_BTLiMG{P<@b7H@z%_YWT)<h`7mcCQ
z<dD{BB#B-8qX!s<paCj(xnDHu#y{q>iYDaq9#w37u$h)qh^CRvDJrY}LNM(n^5B5f
za=C@<J__Nbq*@@*c-$=fsMsbPE-<;^J}q87a?Sg6L31qMgPE`1U!AVeNeZ{*Zp+W~
zDW8F~@uVQ%uF)cH;jN^bpfj>+CdGIS<hKS7Qo-esbmpOeYoUAE{ndlh5&_yq9@W94
z)ly?BbK{TN>?7ah)^*IcY%X+6p_bFuIm9+4zAl`+dDxcLWi7W3jVGFDqPf!sw*wQ?
zJ5^;S<&JVMZx4f5nvZ~4u6e{$izOKu3ijeVdwHb-o%t~&IivwiZcuR%BCPQqtB`&-
z=tt0ZtRWjt-%|Zwy}~4nA98z>pR%*C{fI^<Fe5agDV~IqA7yuq6Q_8;WOJql*jR9<
z$=Rw;(!rySF5U5n7(@>VFK>RpAK?pQ+>WZTOY>RBU4iXKm*ph1(~EB2q?V0~xa|`j
zK(d&hlbR_#sscusEIi8IbLFO>0jizUmT_}~DfZ3s3$OTioC)LT_Mm`U6jg9mQj^`g
znv%V-LMA}{t<`MK4u&H`IL}W+!?nwqTAwEp-XTTZ8F0JY8K2dllaU-fMvGI@bdS??
zK^7zhOp6%v@eaXp%z7oQVOqpCb=JW>u2&oq=<;^4T#HeOWo>tZNl(p=feL2t%ehdU
z?oOr=EeL-fzuu0hEgk2u%eYMhv($gu1qqGP=^^vFrSg5s*yCgfSJ8|GGU5(;r}Bq`
zs^Mb9jtg+A{GngA-2A2aIXi!O7Dt89TVJ_ZfCV2msqi7cF8v1+DoETK;jkE5DTqjJ
zk*!;$RLVT;q%SI|Suc@5n&QmwxK}a`H<Sp}$kZ2u1}X>K+DYvC#FmLU62hrXn)#mb
zt^<bdDi=|SR68qH0j=cS!|lVx?}CTl!aQ##)$}w3$mZiijh$MN&$9)Lrg5=+8V812
zp{SfrP-hcS$rYfq^F7JFjZzX!ItzZc3ku?>cW@&<(8<)^blqS!;1{p&3w6HK#|;OM
z8xQI{0!j*P6?G5IX@~v3Az8t^e<zkL`GHOs2zf1mL*VE9c1LB)erPr)znp-~DhY!6
zrlno=ay2ojegr^zA9Np@Y3ee#vnv^EY^TFw#q|BJvo5;qPonzgtShs2$&&=my5<H+
zLvnb#$>|T(w$sep`nXe_gMUmb)s4FpL&7VKz8-PerYL%4%fOB81;Vcbm^*W!*26OC
z%fs>hv;{}Nok`mnB^|{)@8u384|kUd{X<7wPzn3R@o7Yk2tHfkaf&5uox%Gp!J$E5
zc%H<&S@C5P{*T*$&OI*phw=+o8@2Q$&~Z~ep!zaA9QZe5`gb4~xK>B}-vf4ll0OHs
zEj_(<D7oCcIW+T8=~=7uV`#bH$M|>+Au-2)6*C`#?7~i31d`g-fA&7{=DZO=(x}20
z$&>Y!m;<{D<WRlg1w7<_O(EL-e5V^8{H^9gsOzAf_XDZ*Lj5fDk{6}0aQGs6S=HlI
z$I0U$&r>#+<<u;VbNxb%rD<!v4xqkrxdM0hlbFY5^=^~r-Uh*jDI6YJD$PP_+VTud
zeN&xAvZ8*PQN0`r5QvV=YChWk84huwt2*v`Uh}4%ei{N%-+W81UEp<pj?14?lT>TF
zAR(K4TA+CElUcoxE@}0$Z;&M;&N{mAg9CBjaDQgynji!NEw@=2DV?6)&Bzanf1q{}
zqYpy+iu)@)guRf$1uGVr=JZ{m*z<x_gH;?t++Okls?SDH?WDo%Q>)c@-ynw18$ZX9
zP9osQaE+I?C#cwxz7zKpJQpD1Tp_>n&L1C)&Xa#{hJyIJ-=G;LGyuSw4}PEGi7*mf
z-;91-9?m#mk}lLxMv29VS2S^<JluM+z75N<kJm2kgV#t)i221+peo2OTMVZrkMwv$
z1S)2n`7T~IT!pAQM-w=f`Z7sTOj$n+25lPAI(s(Kr*p%7Q?{2by6qI|yz7rx5?*7d
zLhbk7cHm=X8wLtpnob@WZ&4zKkx`YsFmp@{$G7ew#Y@&XotMdD&{~Ci@Ng4Es{fgi
zrWYY1GG|6Tittc`5sS$VlV2T6QN}mL*-?viAF)k1#9u=SyrBm5-WSFM;W~v_kxvXr
zCtmv7+#H~GqA}*A`xY}=i-pcoeUU0d&Hiis&6UYl)Cp9CJL}>LL@Uh~bImw`os0-g
zy5KsV`l1U<(svcBV1)MmUwP3{9PuR{!|(G-Ws91uPR!qUTMg&pn;zH2`49qysVMRP
zXl0?LmnYVrY<)o9DLyOvT`&pNiDSB+HJEE|{zAn1<(uXef;jJX6V$HSa55J^O)^5z
zF2C~>>#KsZ$Fs_I!K+121|8>{cT?5VOJDFyHb%vI&QLP1miR`AjxCUO^}P4RZ!Ir~
zl8vBo)Jv>sNEkb&*udyI;fE02&o?C&CzsEUTTbBoR8%lgw{At$9>k{?jArG`>Wz+`
zO+_r2@C!XXL~xk*t;flg+ePwk4?K6$Y+GVJ+i4EZBPw?P(&y>aF;hkITEV_w_5R)P
zM~~=Qt0D*Q-LXP=ogwo3o-`#=RaUegzm{BO(mo;nT4;y@7dNgYX$?@341H`~wP@Vz
zMxC58$7hvf)voy|N0rA;Tb=YKGY~v_Zjqm#nsdqo7*e}AiDcucQ}s&P$NJbC-8x&8
zH8rF<Z<04^dTX~0ZQO+Yq{xeElM*}c#dgEvcxZq1ew#k?2)%L?Cex@liwIX#;?<V5
z;`VWW>s;~GwNBo?-j{6o5zd-r!B{p4XF;9ME8sdneVx_u><^?b3wrzRDr;VA2F{fm
z)v_F@a?)D`IuuF`D<3J^!QkWr3VA3w7=q$Tw8b0TYT>CQBm&3F-?X@~4$CL6Rcm3l
zK2P^PvV&kcJYrmVw+$Eu<-OR%bKd&p!@XIr^`0+50xe#h<U=6Fk$4!f+m?E6KNB5Y
z?rU_lTvL;x;}d>B1_yatEV3syR$<4^qE5?jm_D*^4h7WrGZ$k5g8>Zlq?Qs=s{<>t
z<FcX0C;d;_(jJ$j)nHhL4$z(_6tLeT2)BUV_Hg3Lb&Nrh&(3>;{oJPMIOSE5y_1e>
zCEF@`{RjOVkB@Li7#{^s{J9E`2rR>R*$rLhkj}xbxo&4$v+b{-(kq{Q<SN|tX5;-H
zzRC51URBNzj-#9LK<UrR3Q96a8$j@jo>z-<5vy~skMVxi$-<tEgWPlC7&|=h1gJKm
zb_^rnR12+Is}H6r_JO#%WBY=sKQ6#SYV&n!LM#+4eMt3z5B_eFVCzIKOI5BNv|Vsy
zdkb7D<Pg5rc(X57HJ-XS=%_R3nHuTgvd1vo>^%JI+XP31yP0X9@N;PW$Ok<E0iZy{
z3qqTL|By%QCp41V-<{D1FaniAm+F&thXzIvZIs*YPea4*h#^0{1g{nxW9NfPhewqy
zq0UGA_5yun>ltVunsFic{gpMY&%gDFq5D3_WCgY4_G#JTjfv#*$U5_Nwzkfko!qPH
z<<9`!n}<oeeq^h@#~HlM#lLH~Ou69D&(xO+I!ilvnKPc5*F!_`QoCxTLg;0uONM#9
zKnG&y^ZP)|<{9b~={#n$XW<$fejZ6e?_u+na;r!1Bd8sO6Z&~qPGqDq71sP_<x&Fe
z6iZ7{QuzS_WF+TU<z@D%KXI_aT#`9-nw^AYyl;1Diss|<kF?SbY+e8R#J)7OuAZHc
z9iHBL==E>2^OAV`w%}~Ad3a6xXTvuS=z|c^b{C*)7bI<=TXk^ZuQ2NiV>fm<lWn&L
zKYy9Bq$Xd^GHqK;y#39yoh`&r1-ahXe43KfRAh2mOYJHJAoa|;laB8?^VPeqw}##2
zxRLu}+Lixs-q<f|Q|%oVI2J6@`hG)V%+Ijrz!o53H~V&HEElaQQMpA+A?h9(^F1(i
zE=IH3l~=pbsn7yn6)q-7IFFci&EAuM%OXZPNJvoWlitg=hO#K~s}CD>(;E95QfeEn
zI5OK3rqH(RFGFi~WgS&{JRJzL-~%xA+xn{|kIAZUMU{3D2?DOAQoeVO{;1fn*FE;|
z?_Gf^?PS_uB*8XKIGU*c<%mbkk8i<q^{UewHyHD0Glmg`aXTL2qm28-fjIVhZb0>-
z<Yem`Quy<$5%Fg#^N-mN^Bq>nRc;SWrQASghcl&arxJfy;1`mTadQhpO?*ICM;wnq
zM2q{)@pD-fnWn0xw^#PYbp*vL+{Q*?exOXJDec&?O>436Tq;FGJSc6bP4bTK3-{f_
z72+42ducwET|qky65%f>Piba9Y=ZGJFqoC1X_hmi)k%wfTzj7QJzKI4bLEUqOw6TV
zCTLi>p3F4pBoOZLs8p&rY$6+%?I+tAb5q!=HZLpcG8z0%*q)LBG)zt2)tA1Z@Ep3<
zjCeQ;{YZRF!I74KVx>1OuQjhRej5@01@OtvC~b!ehBelrWZQfI<KU%>#=bF#2_-Kx
z4%o<-=%Q2O{%nl+E+#!zGIfq8JMtI7X@ndVbz#C5bB?e09iJX8fM<wE%_5RlK3l?Z
z?0X*)8kT!4adJP#Cm~dg&vxS(X>H1OvF=pg?qk-v+r3XqNevxSQld>+zPoQ=OD%1@
zMI!paf<rZ{L(k2eW`HeHS`@7J37-MKxN=O9Ip3dq;0c=a^Va?b+^j8^Jbj!UD-gOH
z9+a-k5^u1I8EV^n-`N=vSSWbIb|}WZPwyqHASW^WP#XbRjd6Yjl5dE}jJD~W%*0OZ
zo{b63DG3TO+bi~riPGaDB6vn3;Tj>8*IGiQBPRCikCbh8vRf&BK7VVqZ<6(J^-V5M
zm`SH@IcfD5`btgl4~G!+6VqQ`(d=J*K`bg~0V`U6lHW`B#B-(JLf*}z{K}aHPkzP>
zr4d!v!o(fJXBab!PL)>cuh*|xlm*x@GO=fu151(bj+rV2@An4@=Y`^!569nk$np;@
z;#fa=*a{2rIFcvoPyg{OU6_Z_(NDm=E;X$yDXh9w(zOq$d0+3f$kvSNY_s-A;Ed4s
z)i72?D)B#<mweVmeda(#;eLZob3YGKv>$b`H=SClaP1`bM1GFBS*#Wxe+D%Xn0~N)
z?X`8_=5#C`QB-NuvP;x>b9=(vKiJo2QvV4TXy#b%#_c!G)6_=wygU~9m8y6mG~npT
zaHG{B{8%3Whz#SJR#EF&V`Ch&z5<B>r_ewyRFFT};$=$T?fc}W0`Y4)F1kF`Q{_qy
z6&ts-F!31A4&$JHGw+i(^u@F}s+ml*6U$YH60M$Hbjm+gR4s>)d+7Aw7FuiZ4l=k6
znCJ%D_!%oHy*VCSd-`D^rgO5H8(5EznxUCM^~hOJe!CH4-eTfM5}fi8J;SD47$4uw
zf<``=>)Wai-c53471XxB<NkrzJR%76i=IJ1?ae2<W!U}@LpUehhV9wSO~CzNS{ZrZ
zU2JxB4X$gmp9<Gx2Z=fPZ+L!f0f<SEew7~w|8mw#R(_mpJ%1iB>Gvr79s>TIEF~>#
zBy4VYbbq;JNsf$hy4q()$~*EQ)=n-ZP`t#%M0y=@m)zo#GtAT*d1n4kk`kxwKbzA9
znY8N2`9CdZWw+9R=R*%AJg@cCz`qgq#As}6`6;JWJmgEKh})^=HhbB^1S3Rj+>j7g
z9D%XjHw$kMY}>_0a;bZi=&nM=yv|F+mT7F^`3K;PLcV@oHErJ;rd*2KruCGK_!tvl
zNYsvc-f@X|+P;*AAj&s_=xjJo0uC(g1E1HLjZ(#K06ptvD%R)1<JO(60;7IqJq=}d
z<M^HtQxB+ee7sYZ4iPRjp1eJy$79JJej2)-&0fieXGUbxHfGQ}d7b5BLGy?r&U!M#
z^i{8wLuct@OYMI97N<*+b(ojy{t{5NMJ#paV1+iZ@1MD!&2&5<Utxbd7I$vYk=(x-
zjJGb>U&c(UmF>iC^;Lm>b~#!&tevAt`}~tS>}5G*v)$}%ldi!mejUAXK_;<Y-FV)K
z3tByS-q{LIIb6giY~0D=G;d;eqP~6x0)H8mVH10M3?Z-DKGXI1Z{K8upR#bXSIj+^
z^5C%o8UZzIW!bH@W&5nw=HuAD=K;g-jZ)@6TjOxKL8sZ{{ml`q=)@gdWWkuKMhN)o
zDW{d58X{UB*OV+?;J@Mdw*TSHeK;d)j2=I7(C8y+G97a!A!5*5#i=w5L3e3{fV0q~
zA3t84Zb#XMNcR;MV6oVKB5<dFDe^c2GEM$5);Zzuy98&Lg;swXAJ_N>j2=YS>aMBf
z*ANqfL-uBcg?<|!LY!FM<EO_K0Rl$)sa;S6D?}zy^QfF$v#I`IX$}p6Og?Q&Z;h4W
z>dDI}6TJQ@spvxXv@<k7^Mq%rlw5n5pldDFi>|!drLMmcg|-&8-=YV<%`#bnac;Mz
zFGnYvT$Ns%i#NXkqIE>|W6wm_aKi@e-d9um32UX9L^HARM^bYnOt1_4gW0yhjbxVP
zeT0IXFeP-I-cqgS2L&7E?+0t@nPOE*@<QFas>Bru5Cuji)XE{CX+;+ecXPQA*>R9c
z82O4uvQniq-;>u|nyND+Cpub&$FNMEOPKhiS0`P0U<XtCXS=eoO!H0(r0pcdP~Pb~
zwfr8On>L+TIS$p?@C`#T&7oRLbn^6gH;}{X=edsgvxR|{7#pY;(9-20w)O7++jsq6
z6~K&E26=gPtMz7u<$102Ib`7eM!zq6%ahOSS6V-LKH}c4?H?=SI(pv(N;+H)9p*C6
zyHv&txs7K#m2-xz!5i-8hJQ>uaG2=3Ty8y~?4$3`+oF`+Z960@jb$Gcvmh=Wvyn6*
zT^e{szA$ZRN^jd2U)|FN2a^5KDF{z#*;rFEnOKl_A<%yXR3RARDT`e<&w&nH2UQ!-
z;2^)AwXRSVB~TdHDT)Fz!Gj1q>7ML4@9ZS!$D3`X2r{8PE$m#Onj8>`4XB~L1_Sfc
z3priHjYp@`Bac}JEksa&*H!AK5PAxYfYXkCvS{2}ANK<2qs}&i9m2KwQgZ<FD!oS?
z{jXIN0FHo1!59;2Ea}z~r6kVNYLn07EH#&11YPQBh5LA<Su&hBS0E|ys<CK%{z5zm
z^Y#7J>xnIw+p+N5G_`hmd=Ilx-{sv>tsZO%3-c9xnQ6TdKO`r)EJz!ukBKoCa+>|U
z*$SyZiY^j0l$DGEAyQExR|L0;L4hw~W~zC-Fs8~oD1g6&(e#==ZS8hR^o`GBh%jOY
zQSU3u&+7F==0BI0^}<@=_2ETTh~^nhO*GphKjrBGEut#?GgCYUtbOe6=!#nRd90Pl
zKa6T`zA>pw7%$*0@Fu+u98cGhDtMZmrqjBu6%3J4=Z#o04x(HQD9+D*DhOG)r~6dD
zSrlu2zAlpCQUs@6L>*=(mR}oex9g%D+xa84M4B!mp76*=I+}1rjMG5WaC5<^dwy6v
z)eu896N7m6231ZfPx=LCL+EOz?%+%9Mw?x0Uo`B6)FnOb&7+Bsj>`U9?yRE&B)lEH
zfP@=}YUZHUjP;%yQku-+`s^&KoK`*wINNESL>7&J@!m*-zOJFK5KT@iT9PMsNY-tl
z@MYrIEaCoS1Koj(s+kh{<;nH<3tIk(2U>j#k^IUk!n$dMv=wxh?O%BlZCvo*wJF<S
zh*}Oi7jDQ_d%l6&SHV@IBh(#H0WXAG+w@Z3=shLcRB5);6Z09p`L|#KEX2JAxB$Td
zVu_sCl@>UWd%@6=(XD$nQ+Lj_wks~>O#(;Yg{v`TNp&3}Jm2spE6}8L?9ukA9z#!R
zzEObb_Y_ED59hO?W=FUshi@a@NAgFv3SYw`a{kVb=NH@^^C`-k*O&)*Ug0XBqF2Fi
zr8w;r#Ri!jrQffcONCu3fo}L`u8nu1)>@%>Ogn&e$i6YP=cW3llc7-nt^7wE=zQ;=
zoJ60Pa~H_Ce$UC~q*;Y<ivQ(9`9zC>fiS!l`VuN1?#s|am)axa$J=5xBtSnO&5N-(
zG3DZ}n4iPf2-)$}CT@=|iraV0E8VxB49u=L0t5`b8lbon;G0Oe>$Ej;w6RUzPTtiQ
zOd7p={+Md+w5+<Jrz-QImrYqiQ?%kMQ(+E8MBh!P2AhBc8@^cX>s;lS^d7ui1*iJr
zlq_r_1!F%D{SZS=Fd2_LTa!kIamXwq1QoMFvsB`(e^ERZ80>@Y$ad4=k0NXW=K?cA
z$tf;Y9z?D<)P*;)X-5@}BB{XNAnCi_OLbi~LHpsPdAgr}5aXP%Mg?Es_*B8U)qGYc
zes?J;A^X;1UVh%CV5NDA1D(rx%8NJ{rA8v?c6?C$djWo@3V22p9}F5m3XEFPw1Z-9
zmD@;wL=h+oKlZ<`6Md1xKc$bGl%}QphMbY_eQ50#k(StmFk1|DC3SB_hw8{LU@al;
zR9JizZsB_ZZQ5y=)Vs(V5-k>HV&H5rs0W-Xo%QX+E-T^Sm`u4!Y!fs#+xlu1V6@|a
zsCgB4v3m5UT1;Ol%_D>w;;w<eJv1^$3+pDqqBZjI&%b4#5qyS=+@v?+_<XhcUA+2p
za!D(w{m3YTg>7zatebtTlC<F*jy&Cj08raX33rGlI)$$dCCOU4u?Xg@fU1xTmyzyY
zp8wx%{(DVuukU5Eix)0+96fE%dZ${y4KNb9ck|ZF>dAU1^E+F)R(_B_u5(qGVt4mA
zcA6aeI!H6pP5?Hxs2txiWzN02^n_I|Ev>ol;V%|ZchwI@M<+}2@ipKO&qq>yW|czC
z67^K0U~NzLZHN%n3A`QarDkD?z+=*U3lQ%90Dt$XBgjS4H0x}vb!yX}m-p#D*T6%x
z$O9ocr3tt)KZ8sCFkfq({r&q3m61qFakH6n11<(-hp+!axgx<uJU?#4CgmL)8T{Is
zD!G|am>&x);_3EiVbi_FG()Dd-pbV0Jx2XlVnh}`TLRMevpwaCxo|*Tkb#!-RU|X<
zh`&VYQleDf%plB%Jiwn#R7GK^U0FC5IY_}gfc$W&)lc(P7hMm72vY88NJwF|U?kGF
zbcxS|2@y{>i0IZDx?%{($V#6-*ZUSzQBlz{GRDC9`J$FbGr9P`M&bi0`Dl;H<IZ5d
zJwagMbva&ocXxTT9Z%AQgR>$jn_MGrqk?e*@6)0b8wUjC^f74pSu8U(d($-<jYP@2
zi8@5|ShNiW@?2N+P!?oIDf6Q|tJ@>nP{(*#6J3H4?vPT$1ln#inru_=8fRU&5vQKt
z^ef%1m@O&8^X#cU>B|j5CJCICs2En*DkTplM2=+hh^!WX`Br(LRMO;qFeJxv#<NJW
z3T4T*)`M(!B(MwJsN<nm*fzps)d|~A12xJj-NYZrh2)V^dRo<^Ok%7Og+i|=GxBFp
zkl>0+YN~HMmb@?T%B{tMeb-)O!-U~ht`}o<Wmqb?>1J~$rS_Nkzccf5r6qBE*|J66
zptL1|*I&Mmm20!DUX-NWsa>^F^OCCOA|LDgx<8xfQ3SS_PEUK^DezW_HC@0&G)*S(
z=a%hI<}j(5Pqkflqv2aXLzuT%mN>Wr05`Bhj{X2I{4*ECD#t_`us(jfV7*7;YNhZ&
zZI^Lkxbc>IBL079Q&DKw^>GM<g%Fm0m-ohP2SL3{Z-ee{5S`kDo#B%vmP<suG%p?J
zNN(5K>mW#QIIlW95c7_{q^fS0<QFCDN@cGFe%6C-U?IxMBZ?8gAo}$%W^vD5Bg01J
z-9u8KeL9SYONxa*1*lEP<9)?JY*q#7PXhLGlV}z`zC>!71o>^u67JYO-+u)TOha~-
zooV>(ax#;#Jq22XL2?=B?&Q;4zjKBY8%wv<kCUQ}1w1D;+Ua>9a!<cy-LEe26ZH6t
zAJt;w71+F+A?T1?G>MC>WM*;+L~{>X&I;Vv4P%85lme=__zK;R$|1q%RBfHOIAn{F
zeZSJ-I@juJJDvK1kqf>Vz{KRx=B-3k5fKqBV(=%had6&d8W`Z<625u<JPKVs;ABUs
zV-N8id|<IMNFLF@Yfn8OD}s@sagSBNYE_&zrJ`@Pw-6lQA1Kcnk5K^mPy&8uUw~Es
z+06P3Vz(WT&Xh&3;6*z*(4Ao7OM#p5fn@r+WrrOoZlaWq8gqU{%>p`VbEm?@$|uPJ
z771UUqx*3dHq;KO4Y4l+^au%;ZwgSE=i>5uj30B;Q$;^r8atU2Nz`$a;|{k+d4lXN
zU&EWW@zSBW-BqHg$*4m=ZG$#Q;EZbdnvyK>`vRq3q%?tyW=|xPiS=<W*U6@A=29N2
zdB)-3ljbKP=lN<S8J%rj$Yr7<cXZL!)oc6Mx7qe(mIT3$?;IPsbNcUI7o3}D{1UJf
z$MY<|jwH0^ct(Ipq46^C7f1xmKL5iR^rN%FkX*t!B-7ho=h8-P_TA?BQkEaOz~-!J
zCP4Z#XKhkj<?W<HHrpRwbmR08cQz~1G<gXJoti}Ne}`}v4OIzbWoP&gIKK-qaPt!r
zZNVdEoi3*w5haAg6k-MRCp`y0pAgL1wVyh@9bHI$*Hl<tnKBntS4fWWT{Rf);;m2c
z?-73655Nj_+!>*~1**ErPhY8JljMOgy1?V=$fl0mZ}^8Xawg!2piiHd`TmF6L_+@?
z=-g41kU)C<`n3WurOkXK;|-h&pRyFyUlWT0y?<G?`_rS&PFmSl_B!w%Z&M2Q-NQ@W
zCoKguYO8MJJn&xvJ8}yIa=QC1Q-}@<&QnB+0nFh9>abTLWY0&IMf`=mZzKZK#Aw%7
z<U;hJFkYT$dNfF(LI366JH5SdjEQ<#kG_8945>gNdIn<o;n2q-(R`_JT7!02L3!}$
z=^1SVB?GT|heVTaFV;6+!~)2X%5!v$fS>>d$)fi5myww7slFU?=0lRjI8`Z>S0$$S
zbaSV)Uh)$5Oya5ssDh+slQiF!v1!+c6uC&WApCN?3#Oi^G5^dJiQ>$UmWa4{-hGdA
z>+#X2>J|41wK`%vg(%lCd+_=PJ497VZ&d?6KTY#Vl5#=1dEvoLPvX%8n+i<Q2n+aP
zG0!3G?+5d1z3ifmKwq9xQ+MW^(;zi*N&`uQ_Ux-uJ1}Sp1N|45i7De*xugqJZfK!X
zka5YH9bB{^^$PVrHFFa%$o~jeF&5NMM);@e6L>TT4sAaAF2%5Yid3sTO#?c;{~I9q
zG^&U`l?sgdyu?^c*_qd<lazj7);V5pL`pm7Q<}aYv8?$RcX+O13N8|q|2>JHo;jS?
zR!EYOMfH-<oj&_})+edqq6{_ihR7^GDYN5n&xsNpDlU{yAeg-)z0ox6pcuWccOXmk
zP{5H1HzrY4G-!4gwykkhzOKUB!?xD(^SL&x7>e7Zwz<81_ABy6`KPn8vNG)o-K$p#
zt1#M-h=}Y!HjLP!*qYq~iQHebNN;g6e{7O|tzgu`{uGE^=oF`sS`Lo)d2%L{XCjFg
z){BymuHC#<RvF$}by9iio)F}op^RCF+1ajAU>A!u+|7FK$1Y!u*G_y=n=EiXYNvk%
zw{x*usjON4y2sjW=!N!zfbJWW)q~&-+6g@MfXYxQhFHrf8t)u>HG0X5hEOyE$)c~~
z(FNZ7?;+)N)9mb>l<1hs<SarPBLRKy_nc~7Ls2&IVt<w@4TanB8ohaP#UuOONLH_*
zGnM~*a5h2K@{%v`0%%QX^Z;V{e~<8-z(!;x&^A!`AY>l)*XX_)4#*Xp`QO7zCHZH~
zUK`Q>-<_lVq!37VU9;dNi5mGv>&~tPA(r`*|2$9fU6c#m=xF*~rnD)g<^DWe*7U`k
z?r(dNv$Kil++10JsvKC{H`4+8-i=}L!J0To!PuV8nXg13)+kR=uGfIx0!t=9V-|-1
z>#f0RY|Ka{hjE_ixK9iYk>kF=!CTx8E{*|&<ATm_9>6$^*IL^#v9XHw3Q-QFaQXpH
z@0zuBbpbPWM@&q@d(<#&T1L(RJ{03zm@;l06T)PUpL0vDE}{zGJ2|Jkxn#Jw8%s4|
z&swTjMaTYTdIDw@sQPW)*BlfYtSA~p6a3h5HHLAssavbM-op-hsD}5^P(IH#c}DZ6
z>1<bbIMqyW06Ig-Labyu)5qLz_YQT|W2i}N>Mp3_DlJKpSo*I`!TOWm+Q!VgVd%-P
z0NjHV{G5c_=5+wv%4s!6i@NzWzU8WHyKwX4`P;ok_8+g6bNl_503-KKk2ky7sOqqf
z;EuiV69Ul}DI7ldAt%y=IK#G6`<p4at2>o#%Q@Cy8?x^?+I7G<xg52vJl+LwGC!4O
z7C-ouV@VyBydlt=6!Pt>Z`q>WDLXIz!@Dku^IO~J`xyJ9-0F>h#jtc-%s;JQ^4N#~
z+YRWeDW}$G8G4y&)f^|o{x^tN`7)f5wtYFLmG|O2G`B8OMSlCVJQ9C-=Z$Y*Dz24Q
zrZpH>>|*Wo&k*n0ScJ2lgdefqNdzkD>(hFxGb-qhM+#f-9DomLS*%4=;>hzLNTpO%
zS%u&4ckG;~jExSqpOEP|6W-85GRJ<v@gE;W(AFBHtWtNyg!mTKvmJ1&^gi|X_Z8IF
zCqQ_GR$!l8%1+O&vI8-QVNaBlnUe~%k|c;wdP~9K0^<p_npH2aG#?TbJ_}P!`4=Q!
zcvT*gA*pW6XaVAr8MUJme)*%BV3p(z_W1o+Xc#v+W0v!s#`<@N(hExoZ<iDPSkj2b
z*Fn*3tHnQ?f-yH^$LIq?6lVg^B15xBXsIG4oW3boyHqa;V<z2K)j_?MW4h*W=E_w2
zzYxf`O({SK_QqbNi1{rXi}11o?Pk)%gpZ?4U6(1{n@&=2Iosv*by2xr29Ael^DwlT
zGicgXhr~WPQH1TyM9LY`GE??7c*IoQM_yA{wxmSFK9vmFL253{@Jcz4CteNg8zRmb
zZN$_4I-GXas1_-jFmNnqGHmKO@d~b<$~+Sb^-L*)M$o17N7la6M!~Sbmj#-1R%d2E
zmq*6g4A+qHydU?ug1-#P7sWYOAMQDFKsr4?+3pdj<gj&JRxM3!C$Win8}ctX)ZZ+M
zb_h;|r3zw`+J}EO%=s7=K}EcKo*CD{vT<{w2S*h(_x`4il40|&>uFHI;Y$qcFF`=f
z9<b5e!m6Muy0o9ixwKaBjQ)oOfIr@697@MeowSPMUHgqLH*HaKoKWZ!EmVw-_EjXD
zFOj?rbLVR>+?eli(vP^C=${akv=x>3wH2k3>#Q?FslCNMeCS2jF4v3Y$Oy>%+8M-9
zn3d%#B_&mmQ~kC>o-#8N=f{u=B#`~gcaIf*YL_>VDTX6X*EXy!hffvYOQeVe%Cn>O
z;jSQDQFF4T_+*w-c!z|d$cKw>ZS6JF?BUGo{TR~aJ1CCTQGbJ&i;F|}L(?Cb{nxrJ
zyxSx`1_&K2-%m@s?xH6D{PLybCvt8en4S3z)wJXh&C(7WsYJ_s*3?kZkKGqxu*2*h
zkvzw%Dv!L-S^1fK!%-&}eXZj))7Lu0QY~sTHN8up>c2`jf0x3)1?%A!7!|+@>XloT
zFKQTjS^l~8b17wjz1N>%pjMuv6=*!y-Tp4ett(AU_%}OBf!e=@ZId0&F~olj+bX|I
z!v2J9bAcX&lt9n9@8NP?(2$5FMU$e6JZsxebX3&LI9bEp){_TXR>m|4hf+ah&bN>m
zV|vy?CfqF(#oG>Li-~H)*f`QWPXTVF4{wB1-S(R%s@<edEkXI2o%a!JSb>T-_eNNh
zsw5%P9XCj-JgO*=U0#^x$cY4>ih20ktm2ndaoozek$nFQYW}%4|L?cM+ko4iVcT`z
z0`F(~*F~IN1j>L#u85vqZFlHKe2SFgmQ=7Rl=_=kh+qC+Vj<+9U-n8lOFhmQg1djj
zF}|rE>5TKcMMD7Qpm3!)QDnrMEa`1m7m(QFh?Qu)8ikK{rEcr=!XaDs@004Enav9x
z8yhQV9!RIJzaK&Biiy{gF$mLAu#4`P$Q`x|`4%jw$YH30&Zi+F`>ESME1dDAR9WSR
zP{o0BbyZZ}N*_7%4;k%DI>CM2J9zZ*|2|gu%PXA;N-2^eD21&Q{v{mb<%e9~-6*h%
zt4x8_BIIgdctAdY(-jB%yX67@FA|HhT`&pHyS=|kEcgGASX3}@zT92l@03iZ<vWm7
zurYH7wz}_105cbI?j5pz{nqFIIi&jBKmmt@RFW^TFeW-l>N)99UcIVcfm>A`4h~7N
z1>(-zASO@@dlcNdlYfBXJvIvi4@2x6yQxMP?i8Pne{8-Y2dy-+P6Bhv`fA{7`B=R7
zdH+1~{@s_d^4{kKnS5#SHxcOje=Zy!eiaH<Rww}W-LJ+}3&<ytQ8R3$<_?c;MJV<E
z?)*1@dO``2Q_%i@LaC}WG84&MjhUWy@}yVY)8?KuolTLQ11TheG4{&m#p9{YI1v1D
zSRmC$Pj|@R^(~r3`%4K=-V67>!QMR2{ijSk*>yTj{<sige<e9x{#Ybx1+gH<Lg(a5
zoafK;pw!Z_c&w1Kkf={s5G19QVnImC6g3@-a;%w_FMWJ=q^`ZTSpcufY{)C=zq!@F
ztb+fEEm!2h^=jZ!dWJH)dfmSyZy8$<1f*;144C1nqH!%hmryAEwJte1e)gPUY4qQA
zkNMn|L7^%a-sB(978&Ff6h0sZbZrbDOTSnnZX8|_hwL{+e)htDfwdz3;ey9f!;LRD
z-;^9zXuk}SRwDz@rkorS_IkaS#YMh62`xHr7H;S%iW(#4P83RdNG(<c^%;IIRG3C9
zG@d6ru)rN;dGinf{fKv8*zr7{UOGoCjZq#~^(-qy;VhvFL7GI8?5iTS?gVQbQb9se
zr4jF%Mef;4vZ58$*Z)b||K9~~i%YwWIgN{Z-*(FSjKuWj*qZSB|7xhb8h|uZaD9B-
z^Yrkbk{@?_dLc~1lMZQESN!~$_T9U{^x~%XwOW6(i>#}H!A0ToIy4wOIJC@k*<)ku
z5Hz&RodOg?*~8&9^kXrHGe|*3#!kVG#+}E`P8_X%Y=pbW*|j(hu~Q@w=}=CFs0h6X
z$@`NQ<~)-_WchUodmI9spBvaHbVy0pVLMR`FKaa8Cg4m?x?}REoDw8s+@sx%a;1u?
z7&oaZ=v6*OFv6VfgR*O|RsE2>e3i|0{w_oKH-iKIv9P3k9FX$I$0{e9>s5Q-P(toS
zJY2yhlFnD)>$VTvayY1wD_FFcT{`q5a9xWfBNSaNK3VTVxZeA$$kFMBoV}^Yq9a=P
z+Jtpy!t6nFwbYWlXcWC@bd@T+E5yxVy2Rl+Z<>DZfPzIK3I&1T5KyoZt`HE4wpzG2
z)<5~&+o+iD!=X8asrHIUanMBEAB&9<^uWp5O~ah(U>&`{<-QzB!R-xAuAeoCMJ9fy
zju8t)BF&DrPPz`A>h2|n*^&`tqpdnkFoyg)@z+nE3~wd!%8ZFBrTTYySos{fidn4b
zcHZAbTg)jE)JlD%uYWt2eE%VQj1=Z&G3c!J_5}<^6lZ(+;U72mzjyh6e|V30`V;~f
zIGM67w{Nm4D{%?_e479Ly#&cWA1f+=eXtVFyujk#|0|pGUNzF9Y}1Y_rOx-|fNBe(
zHnb1o|Bt=*jB0XS*M+AIrXn^3lxjt#BTc%BfOG{CdY9g$hK|Stl-_%<k_18vEkHz?
zbO?l+fOJ9$ozVGS=GuFId!04U*;9X=Gsf}<!$EoSym!6s`hpr|Lc*Rz=f7$VTQRPm
z2{&#z`w_&uQ{cGzJ(7UN4LlWgS-3{cK|!T(;rbVym#nwJv8k+=UQ?Hw91-x*{r%=(
zcNOo~MQ>b#opeBEG+)~*L8<z8L9s#4{@Z2#>sJ5tA78rj8$OwjSBSlty5&}5ELsm=
zu=&hqka2hY(}T#LK1h^5cWB~`*XKadQENTn5=!l<LwSlz3xmjh1>Nj=zd%Z6YN|)a
z3Bkrr3O=+L&OP1NrP_nFJE#bYHWo1gr_OY%atM!c>->$!p_7^u+vf01fPH0$0|lyO
zlsOxQ`8v;7FN&Kqe9`%Cp+z)Nq|dK>6y2u2(NN$imO8Jz2c23{*JUH!A`Bn8RR?^c
zq2_?fiT{rec;+lG%`Gugoe<gMf29WH!-(T^T&Z(Qy>BYnYLrzEbzd91(@b{Xr*41>
zmA|o=;yQ{Jxzwm6t7@xW5Cv2Ucw^I*z+4RRE~bnUp`E&H9C_1G_2nX;RcDEjZ2MgQ
z#QlGw^Pgf4eCMmer5v9EbCnG)X=V7ndbZhyQ{%<|Ut<38H~g1!)&rg5mjw#h98sqE
zs8{@Rk;EN7ff2%!BeCx@?`R9t9d3sTWhbIYxH%!mGP}dRk08hQl%?-MvbR{7!`k`h
z(e~B9f!e-WKgVcdVii%`xv?PyuTP@Knpx>H|5NM!@`C?R$iMv2^Uog)Ko`HKK$TJj
zw)1s!+aKm^WEOnu!F<kXfMp#++skLljI_$Xn7?%o5dO~x{y&`emp|hF{dX|-H{SfD
zO_atguZpGyt50M3eX&b^Y7)o?C#k8iRt4sfW9h6*pufE1U!M8jMfuM23|m0EoE?+y
zXJaBjYHCg81#PxqLW^pfPu?sQ$U=WKs{DkHlQD@X$Il^X8>aAG>R%Z2&j<eR>;xax
znFgq7X)jas-?-IZ9pXy>ZraZg^EZV2FK=Yd0{nf~yG${bU*$&sh4ZjH?Z?-Dk=DHm
zfZa%Hd+DL@KWoNc(<qPPcd%mRn|r?~vl)qiIPpjO?<D*sf&Rv0DbQYnC)sAc`YZnY
z4XQrpy?zaD$wINh^NT`sErIin20#Ag=f9@U|0o*1ruXh>U=?Uajc@#or~O|o(J9rq
zb)Oeo*7)D}8&CU}ckFugycn9uUf%lP7nx{K^T7b?MDg%fWhm*?Zt-fGhyM+a{+BfR
z>I5h<fky6EWr&Z;H>l6JMbV0-XYrTi;7$b9HTcH8zv9r}p=<B*sVd^5JPdx7jOSss
z=YE+2BB!RXa)v44FGb{U9NWOU`m29>wo3_+z!8pWa+beCslWK0=f&+JfAQ_VWfPv4
z0erJ`kth28ss#Ype&ye6|9SfVo9+MB_Fr*Y|JL?jvo?JHHuC=$82Q5o+_r~*xK0(!
z^M-{n3OCUt+eBcg|3{qoFN*S9l?L!z?XabhIa%Kl<JRVReQ(CPcwJU4q$R(yxSwnf
z<5@qltD%wE(ydSBIhd%asj)2E&FT|PF9OpekPre+h**u(2dn=jr20Smaz#zRVFzH3
zwl=w@oBF#EnWX%=>-S~AOTcUTbjxk=HCi5qjj{15)D#@gd<>(X`lftEN8|lCYqyeg
zguLRrMK+suM=o^;u%(K(rd(&fa+tG_*#A}e_zT>cT2~kn1f1}yN6Nh^35K`<gO_`j
zTkuY=>K-4?ZMbQokJs0XmFJi$=d&nUscF-x8AZyu+&vqh_pVU?G;}gI1tKth_Fa$F
zt0CD+3)+%)M@fiPh#~u+Rph>I(}<$VkF{*&VBd7lII%IV%Hd~W68pXIafVA{D-Lf$
z=q0@Kn4MSgkWY*iV^A$u^E|GB^GdhG+!dCKW!62S>tzTBYOcS7sVyH<{VbKAI|8r-
zYS?@MX8EB{RP`+I?(+LGq1~zdz>*xL-RaeA<JK$udf9v$$UPSNrnXi_z3JV&VIEim
zbl@I-cB!*J>@ya;r<vV{BYibqpBq~>B~5tE+ZZ=f$8{`HzP-h3YHf`^xGPmDJom}Z
z2&Qif9$?V`HD$j1TcGK`i$|BjsW4nPG3<?~TIoKpS~x1$Te3rkpIP;O!)F>zIi&cF
z(I$9Qj*XmHsqIAM)3+#dr@Hx=@*>{-$fTtA<L1zA&WZa}b=B^MmE)1c>jfOIviaH@
zrO;@rj4+k50Yl)3HewnXcKqPS^erBTcY|Q9XX^=#Mjc%O>^8O$`y;eE*L&*L99$65
zVPc{c!%lwi@i+eRoF^WlJ56QPV;nf+h6U148O(qGJdDng9~b!Fum3l&?b-8l(f~eo
zhqq@mNE-K?3uCYO)=1h87bw)GMHcYs`(h&A*fc=ZEIWto*Y{}krB+SigMbby(?E4g
zmt)OG&43*1bQx|f@O<tc>N^?qfL>teZxGb=kYz7jdx`B%?x%E=FJ|@X=DQ=zYOiHl
z(42j5gr{)p8l08-?W3OsR=#r&?r4C*u{3ZfxgM_&lJ9|9JP==H7OeBgcUfKn&vJ2_
zw8vCUr;$(RjS;&9XT^u~9FfoRSJ$O%DBmU~e*_`L5C$Ndm-{~rh%=r5=>V*;^99(V
z?~sBL2j#_!U~K(bt|^cR-ca`>#0pM@lyP;dJEr>x?=1|!KSBnL&N)dHTPjhY#Q(*@
z{f}Hq5CgP#`#s#Q7<$41X>Ix}Vaoe#>#LaY_uk2M3>%_Vd$pDpffl+mRJo)y*2ILe
zjt}jiWl>JM(Q`D>vEKJ6y&2fY!I<v3V-j*p=qXqy6T*(hsg!J~1V5UcHH!47ZBJL(
z*~F71f=)cvv2eTS(7{k@cP^^wmeBB%`gNt+lfFmmL=WcX1Li9s7v@%(<T=OLAS;ZO
z2hL7J+!GN*#kW(-LaTplmxG$|OzL!Ai^%NDb)45QZ`d==P3NGcw<}hH7au--3;Y|)
zEj>om?{S)~VTUFFbM8r<?tN@x8z!OcJ)+@4cxY7ckTx6(*1XHg##ZLIsPcL~A?c75
zdWOe*Edr-AR%t~W%!#=lr)%0aY}CJPJWCyq5Evq7cDq-9L=0S}A&ISNfR!kg;7Io^
zg`!9%f+JIL52uu)$If2-lwXsGk9EmNK=u6hA*=nv#U;DxYFfRvE>f}`x~Gnu;OW6$
z{@iFxL_lM8zGNTD22QpkY|}03KCZJf^aA^V2>eRIM~ALQh3WNz7Ghp#+j?S@Ik44A
zD|IrmNP9o^fP39%9)EQTwMuR>k!upK_Y|yUUp=F%n=#6dan$oTT7lO&b@hiaR*tbQ
zopgb<Um>JuyBBl)1t+`(F%tTod(NJ5wfzLqI4z@+g}P;x5`_(7?yB?t5qza;yZgYn
zGofUpxXxwbuCR-FI=25Cd|89vd2zsXQUcLDc5b{URbp+r#|XE(Uh+Qtg7GmCZ?uw*
zi1UmeD%ze`>U*X33l8}HX)5$wU3~*o-@44K509vxs(rRzzUi2m@GVSHK<AN?$ohA<
z#b~+3din!TXM8B6Wk|O8OT~1|^nR0RGF*MSnD2LoZRbkUBN>JYA9xLB!+t-VtJ`0=
zG%V^R9ZqQfDtY(XDB+2P!Nb(0lOr>CSJ;e-rt=EFdT{muLj;A4NvO%C#(>aIW5j(k
z(cJ|q6Zha`u<o9jeM_5+RQ{eY4J4)@w}Nyy9l3iD3W*_b*vic(=~XHw4{FM!8+U)Y
zO0INO+Juq+=CS<&KaYMxZFk*TyDQ5@_1W<0aB)8G>gJX`OJt8zJ?VI}uWBb?47MFB
zU|lt?WxpIrE(2`slS7s6r+Cwr(syONNjJdCoRbKZU~qKr!zwG+i_ilD;7MTvYniQS
zL2N~f`u!2`Ivf)7VP*v)5fNHYxHjJ(9_l=#mpxh>E^#DUwB%#<mK#2r0S(~$;=Fc@
zlIe)!u%f$>8+K|bk;VO;WUz7fd3@F4YUSM75dQHhsBt`_H~qnKiE$q(yTWnnr=9F?
zz5zD@FB`bCd<Bf<iv@TlcoEDP={(`OBv$?A?ckfhmvrxkttwYKh#G2id4$B}Jk|KG
z;NuF5JM8$k`8Xb@;kDhP$b2wGa4dbYojm0BBCrlwwhF3UU$DT7CoBTsA-%vV4@F4n
zC;f4ocr%9B>)b}|)3b7@=G1sw4TEp!KJK?4QF=~!8&1dXu5dVuP;X^J)Cu|Brh(*&
zgr$08BKe7~e2*slrxFKr*eK7Z`V7jJ%q_AFdA^kGu`ttBd$%!GSP_zaWdi+fKpA_A
z_L}2$>AC9mrALk(LJ36s17fvmIWR0cBqs6^gs3}KO2LpmI#j|+Z0a7QIAiR6KJBcu
zueN{|H6{$O^ma#FN}@-#bn~i3#$8x&x0eKfCqYHp^gnN&&DBnw=9-{dv1M84P_Sy)
zYIHI|wWt2pygm*w3h$3-F705yO(2Redv96P?(b`3TNo0TUm?2&wZT?gl>ISR07b`~
zTH{toTeqqmi^yOM6AV#mbU2%$Dwk}$G1F$>DQngW7+>~9c|Yw_JGn4kXyv&<pf#DV
zdAVvby%D@mlNt|hQBJrf!|Y><WOT$>6~%Slr+nkJxk6g+J{d>QT#-MgT}eW-16CEL
zD`@j<a=@`ee4?F=lesQlTbS%B(+!K?Oaa3oHJ_hZ8r&noQAsr*Mv{oakq+P|z}wcl
z+b!<afe~rJGou)TZbR}F>OyVhbY)!#JW1HuGUsj)fF8k4N99q(UaZGRt^+Ex?s)El
z<)&gQ?)|ouiKMCHqVDTe&7o|*YkXx5P{3zN*w(C!FS`&>eG+ct4!|eWKd3y=Hq_rw
zgO`lTwFz@D_>ob5ZcTHoC>BxY#K|ttJ{aD?u=V?C=31qt6>lR1dWuRKUC?389vn&7
ze%<Ua(H&*%;1e%(@Isveu}%*C$nL5uS}UR0Nf5Q1C7U@=BHjRHCZi0K+)vT52_ul4
zs!ifU+8;dICLWxFc@6dNEmtqC8lmf4I8&0I{=6h4umQ=<#gfa8tQyW=#ZfK7R)sWT
zw3^QV(Yg&(9Y0-R9G!ouiXPkkk@dcDs?NP7T}iA)3)ptwgAS2Mdk^j#=5vY(U}I%v
z4N9xY<L(0fp6Su?I*Dh(ld){wxFsZ%N=XEvl`+5XP1|Br=Y8q&EIB&<JV%&trd@r~
z0nTSt*NBu_$&u8UP%=FgBB9T4Zu}_2+?o!oWs*xBG|J??Tu=p{pp>#H7_t?yQFZF#
zGjN&33O4(Ni@)XD8F-LUVR1u^O{{&TrR-SPYVNF!&1iXdK)!Dty<MFkv1;BI&cTr*
zaw}KlV=PndWSlkv%}%5B{upDZSy$8m%}<j(>k@yHd>OMXch1!x_`NItX_McPUQ<|H
zTZQ+Bb6Co=0g~{=CHppCOj4J1@nV~q-X{vqYUsihWl<;Xw_=608>8Cxqnfld$b6Lc
zwvbc0`ADhBU>ecVdE++i&ALqj<O!t}by!FG`<)Bw4^U}!DTo%?RwgEG>zWr}E{>S6
z)9}nTum(A(gETka$BX2y`eVPz^Vg~7hHYO2<K0#z?T-{8G+pz!`bRBVRz)fUI{=(*
zU6*}s-}F6FYUQMMbG16%P%4!5Z=vRY@~Ih-K&@)A<TuBA8qW9$&QHy>OPVfV3ysCz
z`%0XPsLeb!M-d5XelUpaaMkbG+>8XRGk*LeNW<XRR?24f8{e4iQSh_Fh`J6k8R<|a
zDiNZ+c^`lGipR?vrH`+C!~yT9-JeJc)%NJZPNmehnr(mk2H?S#1}~+~mC_iy3A1oU
zV<1xd4q#8SREXx`gpXd=s5fa$znMAejzaZ)O6t^vKfYdqjL7-%$}raZ^sPDJuD6A~
z0D{v8R?3o~{B);xH>|B<k<>IrXhKod<~Vs-9^d87aFL>dIS`#~!ISgR=r_6_K?PVn
zawgrIdLy3El=tvbPbjBiMVNdxs;d@Ct%7Sf6<lu1L-trj=LS%3T*F7(b4_{a;rkOF
z%q`5yqOb*ls}o}qm(DrNj#uhJa4c6w?JBc2H)2m=;g#JZ`#nqI=2moAP^h2=>I+9<
z3|X$}O}Lz&``D_>>$kscghYo2g$^RT@mr&(5Ou{x>@kO_jG|$KN-GfhC@G%R^+)|+
ztUX~W>9~S!n|q`2*bGF}WfPT2{2#IQzr?S60YKG8Y`_ds49(LG-%ve#|0CaiER{45
zD_H;{^Gx#PNUS_X^dsf4!itH?FMAuo-5~&WRviFyDyY)EdLn$cfFX4`0I)F3rd_A_
z#~QUArzysvvtPM19qA*MitKt^6?KJ`k}a0vg{~LAa2<dR?}l(97xg(%TQ@Z8%HNZ`
zuF|dys&V4B2SrvNqLx!soh)t6d~rAvPank?;{MP|#Wf~C+Y)69u;s*aVPd_~%8s>G
z5$7?6?W^whl(NZ<rHV@Z<C3H)+m@aHC;E$BU$M|O=S_T0oLs>O05{04-lp?d_IcN*
zOROQ-^%ZKz!&mf`MQLgE^%(e25+k4j<5FH7#nw8K1l<sh+iM=?u&Uxt>;yJ@0Ul>w
ze}Jo!Uf12WCRwLuNyG4Wb{j5HrQ`k!>l46Bm69wk3B?KzKGKMF&nw!?)`@sJ5%0Yt
zG#8SUVWc>T_~sb%)8W^L=aQ%Km!zi)In1>DU;wVP`F(o71@MoZN)nZ;pWC`sVDGle
z-*75yHc9rMdm!ZpV?8RW6C(O7tixeC=8Fw7X`k4N>UrqP0FXQ#^k5iU?U)ZQEatYr
z<h+L5XlE|et_&M2WZT4Q?t4xbo-}{XPmfO>1H9UFyL=FYm(}Yy9Z@2e0-5_fBE(Ov
zB(jv{I*Sx6BT^iDI-L40fWH7oOl67}Yae{t+;ZeHB_;M1>5gRNtnDYCo66zs=CTfI
zC8Dd%<6$bnPHW4qv_ZC7^0@=nrhcGPI}gY}&H`udL?MO*sZ6a1Jx9VL7g8|ot?AxO
zfsD?UgDLerf+t4^O)>q1L<7)qO5$EEp~7Q&@Z*PBqKF+W`Er>&Qa<LC?#^@7@hucw
zb#Zv(#_hrOm4(49so>LxHT>4}+Ano4TNhP<b#d$<?fpVwH1r`5gJ0bn0bUa`KM2c`
zr_9VA%}Wf33ZP`ZE*Tj1sZBMHoGwgkZ#heK=>~k%dV1RdHFq;rL#2BDSY~RJ-nK`p
z!{39<`%shNxV68O$0E}U<x(<lJJ!lVU&KhkQT6<-z85R76fC$;HpBFLuVEya)kdqf
z9h$Zhw-@fo-+lqciH7=!ZY@NQBxIkwH#nRdN;cb0x<v452~Cf1hA6wdvIM*bSeXLw
zS0mTq!dsuBrvZQ4NmR9^Erpk5M9={%X#Jvv!h5vrYUidjoFbVt>-aSIQRDv0WX_NO
zbWxVWYmp^O;(@gI0zM6A+>`kxAk^w;(QzVLlq|Nhz1w#1cM$n1cKns&Egff)ZUeMH
zHNR!;`u*tDt+fPhdn18ddfWPZ^UA7#-@!-IzCO*MA$(NVT@LnfnAs`faCp%b#wc=g
zyWr;&-o9=xfV317Y#^Zl%I6eGe7*%_4VyifJsIvxhr#=!2Oer58(p-U0ldcFxP*PE
z5v%tj2xc2X&g_-7jKnbd3~HNoX&7T;jZVXKM&WWUk)phoyRtuK00ThZBYxuGxsDy;
zr)0C_qJ;|sm~pxbGTzmaI!5~A0eh(>7@?dABwi*AKs7}4sO@Uj6TGt{8tBDxe5<V(
zi(%~S7N6eLFe}8CPUbd1NA@`12^QqOu@nFRU=Mm%_zF?Ac6wNngu4dJ{<RTx+{59<
zEEEu&t4ZfXomHPE;H`5}Mq(QXGY64ON~Wjf3pM;8x_cV@-rxRsb{yk4-RPShliG5r
zE<P0LQ*Q~cUks9UwJ&%_TMjm9wfF^jc8or?_TcQ2k01a#N^n-qK)+b6WvyMO7uMiE
zO(!ke2{swa{syfu-c%I$WaCq20<Ze!z{`+CWN-p<w$*R2m&xM@?6mMv<CFWr?1-A>
z6b;jYhwUk1n~J$-()P(<-naOk?Fg?eWPLt7Xwc5i%F6mum?yVCF1puAp-BSx#3*7-
zT7r+?{0JhDrmIwgAeJ6enPa793_K2M%e6xQ))M#kj!&cN;H-Pq_t5mA2EXg~;%D<*
z>NG2_Ku&$P)c^v;j*H{PmbS_`i+FTm(~WA_@OG7>_bQjh?on{X{H>nC|J4!B37<we
z?6St^Vd6*29nZGDM|X4!Q}S(TnENga7RsxES8i=$V0Je{Z59B7G<TZQ!8sgAO!>#_
zbqHd2t7lE=rPC!z94J3*xkdlfR7X*0Yr1>=@*aUx17G73s<i3+eLG&<r`iD9?ZK#5
zK0UO3#2M1;&Y`li&pY-E<p-MZl6br$v>Ptf|M)T`wR22?jyLGUb)oN3S=zas5q_5m
zx3NFTc2#`im5%*(=m;+dw-2eR?qpW;2*~e*A6*d>fDPrZRmvYTbUYN{qh<my2_3JC
z4ujWWq6tJ-9^FqMx%m?DrHqww6NG?E;M|@B?-RYfRc-rC8&dOEWpOso<<i-$qfwiD
zn?;60HjnF}KaUU%u3S7#s8nPE=_Dl)@{`G&tZQ%RYKI*wSB!xi@MnLT6!d6+%KOFY
z^*NDM)0I$ac)Ri)%E-&R6Xfgr+UKUQ4>BUj{M#AX5LKQjK%CrH<81Pl#7GjoC5ZD>
ze>>)Gg}6RuU1tKQgIpgJ)R9#W<fw18rZ|BI!JHb-yM6i8{;xR2SIaeksG!twQ8fYI
z09~hIX{r!m*5JzxBv#+0z~2Pun=(rJ=DNLIS(>IAwnUX|Q>q8HyVL;1K#tY5tr=Pw
zz07w)8Uw;ZbV)*@uzY_%(wNvN(n@;(9N%tAkDz4~Ilej75uQF`fR)WpPd^Z!=~0$|
z;A~+)-j32}#3YX0x;xemec-#`(}CCYkR*eZCbRfEwbq^{!}NSMebyar{9q9D_B4cm
z$DLbkrZSFPIu<Ye0>y2C?k8xg9G_G1;>f&ykRxa9(`0)(XwBgiukpHGu&GV1KPE!f
zm>ecIFZga@Z5K_e|9NcHyZAA8T$spz77m=`YP3}iZ&@AKcvA;5)<Qx>rU2{eJT7%K
zMVQy?Bswl$lxfPNFHFWR{Yg<L&QnaqIS`dTM5(TOtImDUCa_QijbV(R+cp4I_YQn+
zWuPH&n)}NTYIHoB_ey4N)LjbfbZ|5M2=WWOEI+vUDa#|(dn&TT{zeR(kf8k$<i9Bo
zDczsyu$wv!novZKFU4%?X^D{X(Kfn&ibDQYb>l0;4S+1<){^9~qI%-sYd@|%;|VcH
zP+b%rYU*@olq?opGhbl<@^+Xw;ePffqT3dnm`$FVw}Ri8Pjxc_D?^q?-4KnX?pm(9
z<HvnK8*Wy`xArBwE1#mfpGjD;RvKeDAcyyD>yPTKJC(*xSgwc}gv0ez4S_T!j|;8}
zj`FCq#kzE|Qm)~EDv1e%rbB-Q_uv^x;YLOWbL%4!j-#g|_62K?@y<|O!ngH32RfrM
zFSPh+d~hss!UWXBdPV_iVgVyVb>h9ax9o;lo8%bMrvsX46Og(7#!CB+mt9GI@Rc0n
zt34~%V)+NMxp^C)r>W{Kv3bM@9+NuCDRi<0*DHEI=oa66ax{;H!%AG>?JRFp9v^k*
z;>lM~+RHWl0uS$legUaYUjlT!5e?|NSD4U!afV%4foaw7RjOp$T0J0E%|U%XbQr4(
zN}^}g*ly8238qq(;6jnUiP3~47uDsoq~>CLmBkK>Qhe;uS&p{H2V1?e76$k0ObvZp
zj9yGeb(}DTi>+G^s&Hy-5Ae2maV2_B@P#-|tf)V_TL2z$o4u4fnL^Pc^bo9V(wvof
z8kBZXR-OX+D11IpS(K@{|3*qmY7kuXzOf6^3fPbcXXiglrq270`HY(m#f!+Hi7?gu
z<A)yg<?ojx1Dg;&C9-d|wW>FglBawFPg0Rw0E*FZY_9GD-aZMp0aNf&!50CAZnL%N
zADXGuwz&<&nJ1U+bm`(!`Wv9hb|@~}>P_a6l#2c4Jp0Z_ax(xvq4nInME7_5HPv;~
z*y!OuTMGhGHFU2}aZoQMBV2f+s($@A@LbvL)tYGm`(AI9$u{PjU%2RXbsaC`w~mq*
zVB&PU7Kf7wQ>l<+_lDagm>zf9uKePSh3TFqeMBv%l@?Hj$ezeGGuy@(fJW_47>A^R
zEO050zrSIlOiR%LgWmAX*^dBH4+{oTWKUZ{nbSkXCd1L;`quSt0k(P`;IEdf-fg|f
zKVd%|%i}{T0)nsx=+d#v3-)@Ao-7{!*qUXH?bD<~gIC__Ol+DDkjieBUP9=)7G!Mz
z(9swz8OGt>azq+`xHD{m%Cg_I1Z>y4c!XmVzW!1;wfX|1Pu-8LQs1(8eGgtGiKVP>
zlW)h8^8F-^w>GQR5JNNd5Uav!%f7umIRYKiQQ*00LG-xjgzlExbRnt926Dt}#pX3%
z76$!B&g^|dh5;h|b~EJ)IJTaO(8XLcA7DOKq1Y#Si7l55c?4$_RsWUHIp!2h<p9vh
zc`|pX2@QCA^OpD&h&#L%vms@pny(b<1j#zJVqe4xV<>*akUer4wuL=g&X`IqlH+nx
zE;Ys=+qz}<rXlDf(BWjS*9JD>*?Q}+$!cTpM^V@#lu)YYA#;{heD_F|ry;It-Cpa4
z)9p1P`5sUrPHbJJn0w3FS>6_~)C8o5^lTsn0G?%465ITCOZ1(&OI>*ckvMR&IQ3j{
z)O)DzYO}K-K9Qzu`n0CJJ*3GCo2NKM92aMG81y~2o$H@quJz>lJh@VvlX}2#*!sG4
zKHRD3H0M;WwNl0x;c(a&*aFnft46Cj5R1%L#rEI5JxEs)7Z%X*Da@)U-#EJJH~mL{
zH%F38jW)Iruu(vAjgwB|(YSvW{XnJ)owUdaJld!WtIp{$cfjn;VDVuMu<~C9eY&XU
zn^ol5!G&TI?=2@Nrh&3qJCNULWwL*NxF4TPgPdivt3R^s=FyihNY^z6GJsv`Wjz?=
z$i8}VEAs(E!Zs}pX4P@Oj#Jdz=SNz}^lAmCb$e{O&t&ZG=7o55E3PBrEP0G@o=6J^
zP^jG_;^t}fy{O0;y<ZN3ZE4FK?zW{y?J)vXw6~g?iK)q4ITQVjVZz7-lzu<tiBFjF
zPxm9->AiJY(tKmLV1Ttkpc(VGj^vTI?NHlXStJMf+0h9vAA_7}xpPu`(d{c~y!qew
zDkqMfZ=q+2hlP&mD`Uux3r{hr*)@+)B9!#v_v#hCF&^1f=Z~hGc(&M=5Vc^msT1=F
zyi-7Ua1)t3G-`n7&o=AvkGArnKX*)eQF}c2A&X~E&i#a(m{!jQuJ=0p<6_B}xL44(
zI~MwusEwdH<Il|=%?mun(Tt7aVPnKv^k|j*$wvMI9i+~&!^pgSehL*3AaKF*8)EN!
zqwUy>pObEhx|(xx4`fOnz|lZ9)QKF*R|R%Ibb)aI;g$NQ+;}a~fXlaOR_jmRimt6u
z@fgi~&&uS#P<xspbK2Bm&GpUTV?g$i^+TrV0H}YNj_-l^$;MJvvBspyRT1;mVMCNY
ztpJEEo?<cAPhjLdUc)Yx-zc%^J!YnD{g|Bjk<~7+CHq^4)R4x1WCv-Hxv{`CoE|~H
z-KUg4Vt12}4yB_CW-ooSC3n`F!1L5CE_Fv3{@%Q(cGBIdc@b80D^<9Q_MF5qJLb(0
z0C!;moHnoLJw`vvs4cNMr(g|0?vqqXVuItI^Y|=}Kf_n#*s4)UGfgPa<MZH5{fqSm
zne>*41LdnabIMf*ao#59V)wk$e;%@B@SLX7Gsk-ypuqc~nuUC-?_G4QecDl`1W6L&
zyXbb4$&pooSLkAH%0@m~jpE(Saa7)hfVSOj8Kw#!B#{*LWBBc(t-?WZUP=<)ThS>A
zVT@GO^KpEh;yiAGeW{8ii{nf2YFRJo)`G>BAFI`oj%B8k=xy1?;swTCyP8WD?unHi
z*O0+5RC=BSbRP+aHk}_tt|jZ+G08A`KL?hCsEL>;)lpz=`TPPf&wDQi#H}oPEHX!D
z;CniDVg<wxhgI!0(e!f3R)zV72>EUau}hNnd(q;%3(?P}h8I!svj^cKixIonxa1jF
zHDhH_)qV?Hyv*N;lR(tTl_@ax`UtXkvk8>e5H!7Pb!OH31+Apdih_Cwop^y?(6}$B
z8utUxIFK+F$WKV4(GyY2FSk~;%#Jtt!LnyxZ8rD!)Fp(jBreDFpDYFgpe`ZWFbSBH
zYR*;H)3>Qi&$<|+hGBHYFvbD}4Nc6Z>UMumeF%V9&`Nj1C9e*bX%!Rxk(y1fKc_OO
zh|vw{-ran--mDJDZ9GRlN;wrWc(JWpT0Uk)nZA{!C%qf#6km9FQSgCP<V4+Ln`9uB
zC43CCs}C;gL5qqX9d?v!E!nr*dl{7}T3)H{Y=dMDwt*-gQ=Z3e*PfQpT}CD=Pt%n(
zX;Jj?WSOVo`mS&Zyd$z+#On&avgIJ>%y+)W+r8P!ado&783qRQ@ob)ym$KL<fT(2A
zSrrZ)GOtSia~D9YzX$uRWZQB*oPEzZDLe#^<En99(HQ_QYNVe^zLQ`T->~KoghTAn
z(eX<8(V#`&i@yc5|0(PIAAxjRvEhBAA+M7+PX00{_Qq;pFbxu`_JmR#=hKSpD=`jC
z3ZO+w?0%=RpRc<rRTHg1hz!Wz8MQeW_Ke=1M%!Kfq`I&7hA+n{>?+Hd2%zqq9y;=0
zG1BZMi{hnrE8F%O%=3<hgVi)3Ma_lYF%{iM<WJ|SPdr{}UtB7zleQi2;6SMjf>kGh
zhJ|MA5T5SDZFbvIaujH?SYjCxp80^!_NXlC18ix~N5zBHI{D?24i{{9hhRuL_gw(i
zGq2C|bHz~F<qn-R)6h2qMJ4)8$ZC>AVM`C6&LAlT-2!CFU;=ahC|J?7jdIm&CAl6J
z%$K>_y!hhuqlwukWNa0v>hJHCnan4Ljl8czPJQr#a9py_UCEV^tfj~$u@|n^4o&il
z%Lof>D?@@72a)pZ$XAHh=l*~dZImtGEb1}x*lKb6sqpGz4D7^9gv@(Gb7b?h&1D%i
zA9mWt5x2r+t<VTke|YBm0keB;v5@+)ak`(;lD-YN@F=wMm=*|}A$_PM=9qxpiV@4;
zVdr@pqm7)lbrk+eH)K|vOXws-!>xH7KyhJ}dOn)$<v$Lkj4^j6>jN30k^hxtI7JjM
zNek%oP#=js&k?t|*42nVa4zG=g3kNiGd=6SF!({I1;E<OX0z!d%vuYrzBiR*AZ2)8
zc5Bm13XW^RT!Xw9)5=prA&GVIbU>?{C#mtrEgqwHwu1Sby21|)!!O*UbQ&m^#D<u1
zv$_!x=wr@+E6hxVS`~6>K7Fqt+XY{~B=lK0FUmv6<-GzQIWqEFI+e?x6~m(-pY_CO
zKLf2_Lj*d1KMX(JZrgmdRhOWCs|NSQ>Mfm|R_jD7_w>U9ZtLAoII+<R8!Fuzr|!gZ
zD-lvXmA|y3q}#^KlWP2FaUm{QsYl9V=BzA-R(S$}kn3CM6qwH(1ra|vW-rk|+^%1e
zxJ<_|;g#+wBONB^lCpG5o@KJ6s7<)rrZpn7(XpZX`hDryZ(bBE6O;ZlNfNZK$&3@|
z>J_)HpKozXN&`S?zqYFKFOO1j0EQI#8{t=nI5G%8`iH-cfBV(Xd&PfPn*m^y3PcfM
z`}0oVA92;cNpSw(B=|Q8&i<PO|0V&DIr_iD7GR6>0Ppyzy*;iEYSQrq_-7bnde%|T
z0O+gaachrB;IoiZNELSOp6F%#`BX1}K)ap;NTTyzrG;+dA5g7WLf@+l`wPGtP6jHU
zl!2<~_mE$4C(o&_0o~i0O@p#upw2J8EM_BGnpc#)n7Qgi?$zJo%Y0YP>MQi9c=w}?
zaUC_PiAj6w)2utP$Cl5neIS9`(CC-OG627s;09Eq&X!?Pp`0~K!BxaQyGzoKZ<sUq
z`c>%hg^f9{FVDFYwLiZ3OOz@*Z7lyfSR#pnyUZTxH^-hFvclM|nOpnnBd}t?yI@3;
zTOu;=-=owJ`i1j-^G<iyT&Lz>%`yq5IZc|HW1%KFHevffQv>LBg@x+v*g~yYOBX2g
zBzX3cqjbjmd8qv~OVjta#&eyaI<fy0P5iwJBv@TwWz&{g8jS6`cTro&6d0w3wiihr
zR8*IbhezkNu#(s5JgAwPTABV@=-wpF22pBxrI4~~e7HNEW390CAO>6Ey!6Ey&#LvX
zO@hlrI-5KAY=54V=)qv|0_p1z&yTXHwE;gf1Wm`br9`m03*FE6&fVeWx(LWOKZ|nW
zjcD%_1}blbryNuiPdR`#Q=pM|6Eocja-@bswSZ}&(OEe!yF)&r=iGsHB<2k^^wC!L
z1t^Br{?FAW?E^YK2M<E9Kq~=`#&YE1rSqoQ&*_RsXFDN5-#{pv!TbBf$^q-zVEJF!
zC$Jgxb*4?#Xt`>g#}@YoE=IfD`ufUfMakP<cJ>Sd5Ve-L#x`tv;u9Cy(UwuJZv3Hl
z!LVy=H;)Bo2B!q-kIIp+(bdXVV$5<jnPra<@&DR+QFL>z_}Mb%YH2i$ezA?H_avRB
zuJ12!+1&fAgi_MYZ0XQ06Fs1bFiRIDa4KJO<Zr_t0b>&1I>=#h6C??#6vUCuHqI6V
zY^do%Rw~}`)J1iw^GW-EO}Y6RQmAE!o+54dB@d=YS324Jf>khJx_(RC$VnlAo2Lz}
z_Ud5AW<`geY6+OT@dv3EFQSjYJvN~NKsEguH0iToNAC#h8@gR8cv4|4r}Qtx(-yv-
zRZyu8nm&NxZu^>a4jUgqpi%w{uwzGp91jo{zSSIIom(Bxy*t!W_xn2lz2Ejf`wIg4
zM%v(e@AXqgn&WGp0%lp)^p89hzz(rSCVd3;=oIVNz9JD*vz<*$3etsr$xb&eTr(BC
z`}4(&P59UFXqM*Q%=?a;tEU@r%=?Veyy60qstiD}TOl7oD`S<wjFhmzKvLCJUrXSL
zu&?=kzIWuz*@tI=VXM!8ad~B80z1w4%OWfbfcPl(JMbYCofG`0i5|;*rHlq38%Gy1
z8v6Il&42G5_$tcA?Y0pEWZYeCj~PWO!h?c>+;%kSjHUoCwF6wzt95E#7)Lrv!u>t2
zeR&I5CTTjxUkHt!`+n`6yg%LgIod%4oGYR(WC;uoLQ4ytXl%QqvDuP=F8maWcYA*W
zs73i<ndav|A>-ojA&es8KvyQc#TTf}n1JGs&vUr@fYBZqya{)ouR)&bbc*&Fb(S~e
zfLI9Mx&8A~X6Juz`VZD;|0&XST>++Ba=>R027u2%oYeFI-CMVBFW%>F1^P_qo|Vx5
zJl}m;?s5Y&BfEyZ#Q@Cs6vj9v_}MH;_3B*>&_iuNK~Gg*b*D%^qZ^==bKcX4pSMMP
z9=@yf%u&1vcJ)`f#*L(Z1DGugER%9q+~ThQ1k4!m;ouj>7~Et4@vyaer~#UNpaH6+
zZTZr2s$~oi$irXIvMk^tc(5Yi3T1&)xkBEC-UoJ+JR=h2e!&V!0UWO>OagQ#8aP$&
zRyN(~UF~uBU+~wR!KZ}R<_Ap6BjD6JZfX87;I7kED7K%sTM4wM4apUj00)$SQ#}kr
zEE#~iw%9||f8MrpbDh?+ZLsHI&=la*oo~0W&w#szP7{lMUZD(tWp{As81y0-Bm@l5
zt@!gm?N9AYD_-~KEA3xv9|NeZ5<~@uI@|zGr7%{TK3%#KhC==P#u;B={~#a|Fu-N~
zThRWll>9#^XkJP<=hOJgq<!FY#z0N2bDt4ol`~%nINU+5sh?jLWghjX=7Rr4b9;y=
zB>)fUc^#$R61073UEfv%v~A6@<Bb*vEY`=#&qYfxx6&jRF$1k|1?sP@;#ejh{9VHT
zm%9aE{;8_-{fnxnr$SP>*IQk8_SC0<o^vW7>;G;UIp)%bl+V|!X>OX)I&t4PnQF_|
z5204q5O5hi9_p*pR-c4wVw`}5OQ9SQ#2G=OrZ2lY2QPpz%-&l9p6^aeYVca4)zcZz
zvUD4Qk{8gl6bdw&olfn90(*v}!~JPKfxwHY^b^B9lgB?{AAGB2|5QJ~A<gm$UV!C2
zbfgopm-7^|Hu4m5GP+DJ@<h18=60}?1(m#$9Ti?g&D5u@%C<vvH7tqS!m{>gd-#^P
zi^HMk=divy<BjD_;&kUm=ll-PrRs+PD#_RU0<Q$W*82f?zSbMT+ac}k;IhL`MMBdP
z)w~BHAj(f;tM1$+4PekJaoD7_Fq&H}ewjzLaq_-&3ox$ADDlA8cffX%iK58}NRjVF
zeRv_&5S&g1OY<h?x&o`O9p(|J9m^8DT}5ZL8LiqUzRsP!dHv?9bt+TYY!D3G=22_z
zv^ZcN*A2nc-i`1kNr%y;QY>F)dMXNR9|xidWGFCXOBeiTX`)&+KWlZOc3o{dd3LyD
zdU}%!9kykrIC+W!%*XPaH&PS0YFt)QV#Wq6c`dgRTuF7lZ9V1f4}Pyv=&o2xBJ{KZ
z&2$pPTGC|JK`u%7{X}Z?d#pp77^{)zhM4z$b^J8Y=d17P&R+GL^voQc8l4_bL4$<-
z45&y#o%+%7-vF7<uLinNjSgpAiH(u=B%i=nbgZlp>k`lSVN<MaUzyd4Pi8f4Z&Pk8
zW`+wTvDxswYO#9NL3P|9QOW*C0EN`NOBWZMw~`$8=kPLmR||LY1MO(F4HPJYQoSod
zP7A%ZdT#i+VbT6n4e{fx;HvdOpQbNwjg1JoG{JbtvCR##gn9~jI#JhS|Dmb%ceGH<
zeM*w`L2{RIDiR#LBRhQGCxl*5Jngj$+<hbQWG1O%Vkf?&Z(oAewBy{vbf9TEOncSy
zj`-n1|Hr`^+WzO*y9WR(wzbL!*IwfhmNU3}5uW_U3&oSwt9?Ft-q|e{Hq|5hC2i76
z56-~$lDa(B8Z++NH+GR&d`DjJ*W@r-op{C$0}Tk#tKaXPc4Jx^w<;&xx+<~bM4Z<i
zt?n93ZUveplaEs5hJGvorB8a>YOa9GvLCB2$N(>+n#y>f5ldW)KW6Y+N+q36vWFL_
z2A`ncBGM>Yk3Cis&QI1*rxd>a8N_nxCn11>wOiQ!4yI%hdt&QO2y`Vx_aTe)!n<Sp
z%*v#U_Lx?Zm-V-f?KjG+PP*<^M`&Kcpkz?b+=Hcz8<b*^`+UeVo3Dx&{ne+B1Jl0u
zQGgYF&IMj(WP;!}-+S_{l`Ztv>n>LgUFq|v&UFwe&dL1v!Y{B%jC2AUT<dW`<DUwQ
z8x)%3-S-dDiKUJtukaR;lLKzZiq{TKJWk)1VBVKy-~l73TDUy?b7hya_Yb}=n|rhq
z4<@<-Pv@(L-1X=fMy)DsvRhwLn4Tmj6F==tyn9pww8Dt9M&V<@vMyjb$>#(m`LgNn
zfnj>`#P#VM**=buyOwoGb!C_0C2kQ;iAJjdevMf4_qb%cYv|W!%~zt+?fqL9`ivb#
zfY&5uV@_u#LTsYbO;)0M)!Y@5M1|61T{7Jl`tlvO_oCkqoRmSBe}Ht%j$8Hp-q3zx
zxmM?Q#`vq6aR`BIOwG^Z^GcUQ8;iC|?d%BNtc>HJNvRao#)7hHtuv~zQ9$I8#!+9+
z%HF*D;QW3%X`$Q1$ytWZH;1hOl15If<25twK1y+vxzVY-`sMmn`NsWih1_Zei_xY(
z3KW}*J4QyHVs#z~+KgC?IWG=_$;1Z6!04JdNEeu<pVgTC_d6ecJNr{#1TXv!#+N@P
z+-`t=P|EQGjZ_cKmTeQBnt7PMueD6_C?l^x+_#}`2?{6zFQXqPs&Dv>@tfyNLI-Bd
ztEr4{vN+xg>_@bpBm{w4pE}H<t_oH#AuY#0uL?Ya8>U}_U+PeqRkt)ZAZ#F?9xO>!
zAn3$z30Y?}wY(Y|Qg<jCwP91YyIdb%U$<I$*S8}c@d@15R`b5kwtrD}!p%FY(ABv|
z%s<_iJ`XxpBz9oK57(jESilveirPR8v5G~EqT~3(SCs0AF>B}z6Kca^P}3DA{>+L^
zmpZcX8Yf#j=mPF?A%Uzgp&zYGx`%BJV)#Uh1wTJ0p=vgMd2xZ>EklO(U?li+SX{qZ
zcUudGh;^*cyy6b8qv5h~;{zU^@gfY=zF#r69=TLGI@F`!{c?Y&M&ELgcGW?{DUHbQ
z+gUl0d~bhm&=SHW&a1SDmFEo1j`#f3YXC|f?0Sf_4=QAcb(tz>5b-V@J`*60nb4cS
zoylJsvilyU>oME^M1Q2G-;pI{u)?{+V0Y7DhkDOwU$Eh840yAD(K9oE&ii2cK>yQ@
zyaWQ_WmYPt^g~4h&INz|+nMv%e(K9L)ek>XOumHZFYBk)T?Ai{=89@yjSh`)4&-X{
zVHdqSRAiO%dgk-NQd<>q`=O9HYp-M^?vTE8r}v?oRkKBP6r`~zefRmf#NO=sra{(p
z`f9&Nu$RgX2z-PU*^|39ro}3+sTcKfo%{_zx!mzfvgM<l1YQEm7N4S0ny}S3q3u}_
zE(Jbn4Z1Nm_*i&;YD}e~#vR_xk4*{1*x;V9=%Q4S;UK}9qX9zMMq3Qm>_Q1uh21&D
zW++c~;P8i!{Uh@6c3_7-IU%k@C<u?jYukbxQ#Nt3;d^^SCe6_8r(T1e2NitWyxyI^
zf6kxkO6BWJTa`K|e{hv4vT{82o;qS~v}c^6Cxkz}E==mIm|NZr%v>Q#L8{u$x>!~s
zTg$%4F@HzkmQ&?<7%-tRqpT1?&{KWbe$m;ocd4m>x756iRhvh-WP5+J)_&Q|C;ncT
zI|s^r8(O%So5>HkB?lvVZH-uul#wzP-1NK%vIGaagCA~NRozIHR(Zd?P!+lamuQ7v
zSf;J%i=SrS+O<0xvuCJEfoSu$2T={sV4<Pe)YyC*Db|(l4=%{r*g!g22VB>iSYBJY
z+9Wia>iFJHh%UC=w*2s&D{o&byJ{CJ*95M?I&OD?PNj8uwcb~AXo<3&wrH*+7Wd5n
z>@*;zGW18K<zSWO1-Y?z^SYIwQqGwf`Iicc77-fqmaT*A7^U!dyR*u-NA{xZ_HzS!
z9Ty$uRMJvVDO|EV{5chx`K<%F>_?b4i94zXSqFhjR+Dd~_)_w`#H?67bon!R@s-|2
zYLVP=E-%>pbZfL+YagrbLG@n7ys92YG4)tv_e6Jk43bv$aI2bLsRDu*@P!@od-$91
z8vE%0bB)JrOIh!dgSanVTvw@7veAAhZHMEs=yQuoPG-B!^2MnSSIlhn@#*&BVB{;u
z%amu$oo`Zt%%9(T!qXRUAJ^J{Np-%*tj)yn7)YV4=RE~ROP!^tYLqg*;_GwfwF*pD
z0t)j~I^ruvG6MI%PiK>nOTOI~AF>^0N%s^Vv#p#=dlWF{DBOw-QqzVk$C1QSI7jO(
zqNQ0<wsS7h3_y~Gx0eKM1t<T|bV&u*CS}~c+YgCbJ8N<gtc&*6<<zNqS7bl5!th#7
zp_m-Ys*$Kk+lhM}lUER`@Hl5pICDD2Vy=ix+Cf38R12B)V5D<m6dC=1Pwhq#M3|gQ
zuhzP!!12wzt>3=$Lr%`3;cZbTA1{4(J<3J=<Ep#PmO}#bN>K|D-0}<FkTEO9emlk3
zssi4*(aNG1O>I=tV?AzPnn8~EUDI(D&06bFJm0%F5^lquan33H8vKxkORA9;>39M6
znL7k~A2TXes6`Ri#fF|5$Ic(y565)$6*AbyLkhyeyD80%&9%+0%p_O8Ut6=^^IRO-
z@l;e%efMoRvf^H9n1u~5$?^}+BUXgak0K3fPL0{xM|EH;se1mUieVsyiHw?0rvt+E
z+@a#&cusjey)=9g7Jh^3#_~1@QAQVo`H&56z$_i)tY_zVi4>ZH8h4vVmyiLaVfm?1
zJt2NISpK1{e3r1d0Ln#bZ<bI$)eF4@+VG$9cz^z~)`DLU$a@Y*ihNMX`3R!h8S!C}
z@fH$Pe5%MT$EJMr?v*N`Pqc57Wxt<xV@84|wfw+>bmH_Lx@D)TJ-7TlLU}N648r$C
zl5wy5gS5bwvHJOAOmA<XRd@SGT}_v+GB3KMMU8D6bJ>F^`@JMjB!{G_UDx|n({zYc
z+#Rkh`N%;^BR?+@yU`QdwkIQTaW-RHmWhv1O1c-p1B;`4dZW2bZJk~7D?6oIR$E@%
z?`D02Hv&!am+Qlw*gcg$7iC0~S%jsaS<{Q;<3nY*#$1SKX}tOn_!w&U(XeKj$IHW5
zFX^J8Zahm{-$wuSt{kbOTlO#C4s|L1pn#aQop4CljG+aJOD?ab=l~mBMDMGQC#17H
zdb(--cx78AS@uAhWy^r{B>_zgFo-3Kyuu*NT2`-RZkKg6)*25@3~{smQf`68jXN>d
z=t{C%4cf&f>T?#~Jx|(U!i&h4UQA@y)VmdSOL+GM@M@iiizzp|Da1&b_giO{s^w>Y
zWEvB7R~#wzE;B!Up2V-nLG$kM;IrbXAVN>b$fnJY=aOd;wa?xXmoQJN(BQ^B(*_64
zD%V`R@wegYPuCj8rOwjSyf`Py?D<skO5z78YwM8OosD+{gKrc{z48+0v_=-g^ER*}
zTbr1#e^BaqxJB_<;2!S^Q96AN{P0{8VE18fkgx}dvDCv#iYGOnZml<0@?db|u;19m
zb<tBguQRbyVbBg|T3LO95n3D04*%}w<uMwO;gKvpv{!60W}9d@hagjWNt;^c$4s>P
zrXrh}{L1g82Z_1j3^ip_6)k0Rh?i%A`47(SPUg68KQL3duvwU0oJLp_Ya9V-h#ggY
zYBI_&R&j7dl3Swb>Uu^E7NM9=G<X?`NW7$Mqg`2^{(_R0Q7F!|wY5Neeq7lPGM#qI
zwCF113cswx=BkgV?iFTPM?tm?&mSN3^4#&g2ClH$`41BYv3fojr4*pgDurdfo7#IK
zBX%zZ>b5VGC}tK3*QjpT(f2bv$L#r4&kU)RzA41IF?W_LEpe-AMi<4>Z`w^!IZ`Cg
zcSfKv4_jm6SOiIvv;HZR@%%Sm6zGFNEIRU$2KD<OwPHCxQP>r|m=g_G%ubH+^s~L-
zOvQ(}E`~qu<GAPaP<K@YQ=<vVmm1}iar(+>i}*KJ(ow8-WG^K{mj+5RGr@Ep9T=M!
zFJa{5CFn;Kgatnf=E4=eE?I{ihF|1i6w|+T>-`FiC)6-Uf`0VXC_g(q?FJqElE7ur
zKJLNSR0{iO>U^7o0`?=7;9L(*S29?+!$6W>{ESb0`X#dJmpur?L4{H&_1E&nxE&Hn
zUb!u9dL(Z@P9s~dFv=RqVFSa$%iV`JylA&`FIyw9jdWv{y8Bvo_lABON@mf>#Wpf=
zzbIX$ltacMoIIpBAnwI-l4p`Di2~HJ^`)`7wG8|kTgx+#a<qq(@>n~&7C~Ad)3#Eq
zz`zs|;ZY}|k((J<cW|}sfLXDUx)is9>)~f#Kjbyeb<B4$^wT9)>>mygoakLJA6{n1
zkZml=E6Z6<#~74-``Tbc^-RNV$l_Cm-6~OPJl?h!`b<@^`0K@`+AZ99g2hK8x&eC{
z8(y11QB5;e1Hz4>(Ed0XRf`@q7p)S@I?9?aGO`Ux080I$-+IMnraHg%b<xELbE(w#
z4WcA*x=**oHm+-bZr4O$2jY_5GGcw?w1Ag2Te0qoTC#2rTn%{b(CHSRU@14zsSm~!
zZ7h5WG+D?vZn&fLIdpX`G!r|cLN^#6pPp{u7d;6THBFX-2<2Hufl;VdPvXw9&|}p+
zTC&1#Z>#-4HQ{>t<yk4<du$eo)=+MO&VUQxG(k-aYxHmoDSK00GAlR^UTUX|Kx79<
zShJnG0cW*n8VUHxK<9Tg_-_rYKK18eXO$u^fi0ey4aRL&Ohvhvyv`Ti!1#qW>Bc^B
zddwe!bXvVYe+^?p$FT3?M>p0R4%X80*p0%^21=^TPVP7>eE7nxm3vSq?j-A7_Tvxy
zI0}?C!i5Fv3Y(pkIk9>PN)Dq2%Y6<nGGyh)#s<hD->nkZN{xIBdtXBa+TU^|i(7Jc
zuxaF;VK20%Ht8;GKyV49usNbFlc%}Xe+MUeMi&lmvr)Ylh6qj6r{_6mOR*VA$zUV4
zTMXvg*j(z4w@VAgx6R{g92#*mMZV<)^c1ifQJb?C#;6JSu=A@%i@Ah+E}gQ20I~+B
z+IpP3p7<3tGLKQULpu5|yVRnZ7euS0{XleJ5ld*bd2@7UCk0s9?{%HK3li)0w3PF^
zJJl@=D`(9BBHkJ*A@-yzng1f#Z=`HBqt<E%0!=qx_~J9cgyBO*rpO99_NbLQR1kP@
z4N&<!;ogDUjwbzasWq~eLrO8nUhc2!YMdYRtFet1TgVjOknf;TR5Z7!y;w0&W>a^J
z;cjM9oqP>@ZL#niR%vd2uT4$eo<<izU7EtG1(-WdKc+=hxKV5XOL@>xJC=T>X!5KE
z-A#-^82CHJB&MJxm%73d8&rzegME4Kb{@tT(hs*VruqZ+q%mY0u(->j{k+XhujJG9
z@Hw9oecVh_DpyAzkzZj#ruJS^p_}Ske8u0n{npP5wX+;gQYcoQ|ATWhFTH>pn<IN)
zgaj_cGo+y1aqGs?!v=9=e>ja>n$Nd{(!1zWx;wAn^c)-<x^Q?~SOS5J@}cF!Ob^9p
z9R)6?kSdB3j8%7Azu64_YTjqnNm$WdZ8$&mx^TIb4O@`g?SeAz3SfrPu7yqAC8^b#
z%6cGI)-tHva->s>wBn4WR9Rd{PT|(ezqJRur-@&6iguq9j*E4ED_}c*o#B3}s=JN6
z!s`g^l0b04zEZmE)qw4-8W*2RrKoGPk2sP9Bgx&Jkei5mbEl5Zvecr3lb%d9kdstV
zc}AlyF5oJ7yL45)F-wz{v#o;BLvgrdZOIjgR11^I%uq?wGs!~r9;;_$CE}lW>@W>9
zj^%0(g+;~0JT93l%QGyOenRPID49?B(}?RUo)g$@JaPHXe|QC$vX|{k8M-2jiD&r!
z(*pH#pLr(lAewQ3Tvk_fWAwYYF2A+_ePO<$6f3;`w)DMvT&)RIl5m3#Qv<}I=RbD0
z;}{cN4q#XLqpq`9=ajHfDjm7l8)DfD<F?HtlV0bytnWyh)LlG!?jBYEb^b;c#^<!X
zpWT&X6@9+#dp!$U+d-}(mzu0pYw-VL?>)ns?6$R0D~gKviim=OqJVT!dRIiG*97Sx
zQbO;YAfO;1AiejRgwT5xkX}Lyp%*Ekh8jW(oQHRnv)8%SKHqljpWpk>>oN(?oX?nJ
z+~Xei7&A0%LoA#+&oql^pi`w{j1!m-8B&c@<a?ZR<4CvEF0wu)a;$%k$p5%_I*yQO
zkn6-;v>nr2di#B;1;3j#)N;+iGe!Ivy8wrbLy9%IcI2t1+LAuG#mQk<QC}yBTB#=1
zUT5lXuQcz)x*58*4Sc*ZN?+7uy;KjJL4W}1v>>~Q9R1kAb8mY$B2*f{_v_|KUM7R6
zE+$puuC(U1^=f~*7530jYI<8nw(z8+Cxa%_dBd4}i())mT<-Su;FNyiph9BtY(zv(
z?-(&jAB5B_n;+St*xqy38@c66a$eWdHoVjdEzD2g(ches8l3;x@v>Yd(oePYL$u$A
z+Ph@6rq6%bt2Vxid3Et<<izai4~^H&O5}U1%yYDKjJCE#3KU1V8;S^J0ZIgSDqep&
zS&~Hy@Sk1fI=tH1LLz+`K`;w$&D*zs1wII(`f{OyB5z>x8(4l&KgiG80a}IqPNBat
zlxArYvUIO^-wyiRh3CVP#0$F-@qmzghP1|dAoFkkY5PR}Q=fK1&z<YY+-TD#S50D`
z<!Urzto<v|<n63Ao>z1_esMCdntO`oF5177U=NDUkFLs&|IR_p`@s5wN1A=NRc+VF
zfI#8YC6wsVFNFTHp2vM$ILju*hvOCHn6TX3_}*;#P)%m5YSNcxHmWfu-L-w<QL6Ha
z7o}+AH`jebO-9yx60$l0E~0{REzx{XgW`BdNoOpesbJjAb9qXhbzpg7z)ao02M-A(
zn=G>&e68zYoJeLgdNIC%`<vz;_Ni=*EbCY+3OBdaNoL+hS?ATr$X9rTwF_4aRLkTq
z22_8Hw}~UUNQfiAyqhq($sZ9Hs(mdF?+<RSYqh>YxMuNMnO-oB$h6HM*}HfA<#z+z
zqg%QFEAJB1R|dp5dLYIv#1;-p<rhYPm8eacK-6Pfn!Aj1c*Y02i?!SoB)6AGfCldm
zrm7Ir3(Ecj*I7A|>RjYY#|BVuc_X6nhL$7G*k7tcE#aVtA}Oq7w=>qt%b9KMIw<cB
z*w?3fv#KIHC;b72=!LtipNDaiT($6EPT{~{OX4woBV3Gb><vjN>y5{wev6!glUge=
zB-ffQBW`~%>*U&@EiE4E$P?~Q#VAT~Q;@|j_pJ1W8y)UN!)D4_)s|nhaL(tnraN~%
z6$o=2d?oR*AOVk*b40RMVb<SwPiwrt-yzVu+1s)Gy5UX$xq$V!A7dU*Ei7}m>VCBC
z9`i<<5YPK8`_YFo{W4;lVtlUz6J!{0GvOq6%B`jiFJ3*=M${j7bVX!ABGf3}@iSW|
zbShCl?;~DEY?rbYH~2lf%c;e#*Q;USzi3>@(mB;vaAbZ?+?Tw%p@u#R{B2+cQ{f$`
z9KrZ4{5<2Og-aKkg7G}6o<=9>)<(GFCh@MNFkcH$h9)Eb3|krqdHdJgJOjnsrIC91
z!VT)au_E&VkNxF5eVz;(N`%F^=FdQOXNu0)Ti5Kkt{7UT(0kxg%WNam$U@d?Y9o)h
zvYc+e?=mK>HOjUz#-p_?cTo<v@-gjIjsKz8BSX2b9K4KgZ$1<-_VtXBU*IO&gS4dc
zA~o++MML(L5MfA-ik4(mUmYN}zl@5w*)Ej55)MA<uR01pSmTy~S&#F33c0R)OQOQ|
z8hr)7al>axmlvxP_UjzK!8YDhm0#O|*uNn*vuj!^NZ4q4c6-VXlxJN=I7~R>rmS0+
zQ}4tUm}vIE+lWb)sl5W~rjpe;a=B`(ix7T9seTkRc%sT(?@PCLF$rRiPWXc_$n7CI
z(3kqV*+lN+Mi!G)*EhdQgV8?%q6nQJkhQBuk%HrX3{>K>t{_TR257wXK}T<Gv#C`n
zARpmeI=r)~1ofn_7I%&j=S4NGffaJi1sQ|_<es^bzu<P#`QWEq<=GDeoIy}XNR|N`
z8MCLg61<f6)f0kUbLJIZ+B!D6JdV8mop)_b#Ij$}szvb3YYIl|>fy^V;P2O{@&ZHi
znOAQnz*Vnb^EDb%_vCbxZ{Z-MQ^M-UoJ392ENRy@)k{$u34|h3XM;~GOi$uv^i-=>
zhQ8G5Z+3e=KsMnGDN@bC9~dHZ1iX1ghIc$wpZ3OrcI|RV5Zq78fT-<yI=38MsM=P(
zJ)vs&v`RsRYv9{Awu70$IJ?b0t{P;a-B2B`%P!7;&;lLjWT`b4$U$9e$2rvq*R(tA
z);O3uQkC?*RLyNZ_TG>D{v*wY*-qi$C-zzRi7V{0RelMJ-CAZ%+U6Dr0N=DXUvx_d
zWRql_{-{&=5upjGl!%!ZEHj#*XqMB@E1F+i=;+lsGHU!4#mjF<6Wj3GSEO3ES;YTl
z!lw{YFhu+ff*I0s&sn^CG(}2P5_QQ8oTte-Xwp;hfOzOY_3%l~K*ad7RUhzBoF(G5
zD`?2J0)rJS;MA-C0N>L7em%RXmxrQqtPJ}pZ@jRFcYP3%AooB>rL-FD*CRCFtY|!j
z2TJ7J=rP)u%*;ziV+XPq1#1Yj&)fJ-!IUF2+DxjWmL0`q+daod<r)RagpNL`Ln_ks
zB@*OU9>cv0s$1C4WVH3bhz(6j9C)!zr2pYw4AhB3xB6*~6Ww=)E=)UY@XM?LVSMP;
zBv5o257aA*2=_^=81Mn%4Ea%xIGtJ-=@;D-?Y;FMe572<tCQ??5}ucDYNj>z0H1Mn
z#eAF%2T{Jb(s?)UcE3JaXz?(@67B*il)31ksSy|m>TTco`n%p-t^O=sS^RstqQmnz
z1tm|JJF4~4LXlClPn>ZtkCRJz%HUxHU-4s@UXPdoVHu!}xW&<rilWJ$Acb9&PwZ!<
zYb=-QI<`NY-cc=Drac%^Ydv&x&(_(vly4T>*B%lvy4_U;v1?I7ZPy6*y-<d3zJrSZ
zIa`!pX6FFsdVzW&OF5WKqmWg0O4oMG+SyX5jkoiGd&kuEZU3yCYZ#i1EfMPW;nFqz
z_p7d|X)JBudP;+_7G(%Ja%;xP1g7?waXECp;}^auA-^$9pe}AmAB|t7wi$f{Pz@!Y
z$;F1WlJD{S1eg?gdpUG+T(;d1oF`!|TY63^faC+O#TZ8lbSp{+Q$ZlUcy;kb_F;tk
z)-|xC6y`RPBdaY@&@kVf>ZsP}Iz{!%wza<eGBV~b;5_DX3H>j7j?v4jo#J{a@uu*;
zSeCb%Us~%-Z9Yt&G;dF}y%c6$tQ<H0A#w3K!EssX>Aj5ETh0rd&V`M2VyNqvS?J$q
z8Nf@H?>h;{<h^IreB5bn3)qf<<v}MI;|%EVm|O(BgnjH#gE1$2>a;Oj^&Zbqu;)DJ
zmPD0<%IpGAwPm}E#4DVnuQd=QZjy)*Nf7xuT`?3)id{EV>&$>sSmTO4&QJ)|1*n$V
z1(bk!E8b)`>xolTjVlm^1u-AMV7C941_J?Q-A_Qp*?<hn62o-D7Y?Ao77Nb`9uNKK
zSE0CZ==td05RkWepgt#t&s}5X%`#dfVddnJ4v9_)F=f=0U%^~gXg5$zf<q>o9D7z<
zOt&aTUDk?CDH+#;rn9t4E*;FysEto37Rt~>XX#Ocwt<X#X${C)4^8C_@NDCxbY8(#
z4avgjnzWy>`okwL1-2KDxdprg^xR6{eUG8D_{gGV)RD)2Uqy^d2KvEAt?Gc!0`#0L
zF?d~9(a$-bl`dXJ-CVvbk0iTiHIz4om&`Ehmm!GW*$g09<bz`JqYLUaK1kWb!tU^x
z?Kii;aZ9azEJ}v7G-e2Kq(%e7y+CSH`0L>NI>NCal|q?N<oU~FuRH}zijcgStFL3c
zFS>PXHeP%xP^D1#LEe-GTLw^P<rtgM@+9|#9nSi4v~Hpye<*eKKwk()nK@IZIj4Ly
zm_31V*_Q+XkkOH66(vmr<}3qG*Y$;t@(<taAJAG~i*zoOX|ov|*4ggB>fMELIPH9s
zOc4NFGUG_aPc@!F*PO1xM)LU1cfL)%r|D9+sx06SJ-LW9s#}&OOWC*e8aCJXm(dvr
zQZOaiK~&|SPNg#9)fo-Qf?~f8?ocg>Nv5&(fe<vs#2VobD0($b;k`Y2yGYKK;!6k?
zyPJ`~aH3`p#q^y%nD9uNr@8CNa*+yO6)z>iBUmu__X>spl^6I2P;^2?>4SbSs{n|E
zoPFH+)rq^b0sbj6a5u*{;a%P5rtfN%217qkrSe!y9)?NLmHO&!?UXwKK^(Qpx~%LF
z$~?}Cph77BQ$Rmx*6zhFXwW2+?WsOkZ*AaC_R&JX$_JEv7zIWR_y~GxGD)jg^w{Lw
z%$Jo8j801mXFxsJY=}vWw1lWzxU8ByNsva}4Ul|I*Q;Q(9D`F;DKx`{+;Fu985F`5
zwB;#6WFnWIZG4TeTJC$MOHzukJc<iT;yf)`i?k4S8zq4;63k5D`bM4JCF)rPuBX!v
zhu&|?_jS8kuhX=2n9d!;U|`3+UuF6<Ox=sMZGmpJs=lDK^D$DiIMz@x!S|)%ic7aO
z4}i%Fp)#kUB7tgoZiRY^_X+#Y1A>Csi`^lOES7mGUlJ1^2zc%#u1&f3ful*0@9nK~
zoVJI4_Nz4L+J(*e*Z18T!Pv))!TG8!e^rJ7bhd8x2hct$3Y;&P62<^Tq(Us`^H=cC
zpIw%R(t?NJlniuGL0RslzG~1*inUm!wc{~DvsCD~K6;^Rbf8uP&QEFh`l!{MYnBNa
zSw5u}7;i05x;^TGbh!J%+QHCxSn^=0M5FvRaN%SmX`Xy|uQBa}A)L6JzL$eajB*xB
zWXw^Z0+$2@2Zu?K?3K-da-71+W-Ug`$3Htnk9j8QgB%=6*^Zo&x{vL=b;N+e5x@<G
z74A&)+7PqSl402c<A=fHYh#QsX73+51`XQszKUfZ#)yPT*7dQ{S_CV28G9Ihkhp|Z
zXjUnU=*Ey!*j=yCu5^*kjy*SCzV5!Z_$Qd%r8aD>1Yjdch|~Hgr<aG9*>js5^gMSa
zY%VJHyFP|fyO`zPcUIX#I6d}^+i<HpI;#tOobu<;OtJ=`$~u;Lw_3zt?H$F}I#+hK
z^_{G?LDYycg`N9q9kbomFC&_Jo(nC~1C`1bC%b+A7LR4ylnwqd3*a||6Elwi9D0%Q
zBOup3_YSBZEkbAM(GlEzy8y>9KQ-inl6i;a)GI;5%O9Z1>rPKn)$UKgLP#Ykr<AO5
z3(@k7&oe3GO0R(`jJIwZm0Jo%Tl%Vs@uFk7g|m9_$47GbY`(>8>BT4yTNdrIJZred
z!Ta90dj8ob$UwlG!GR*Hs{3WcFS!;N<q>D6HC0Nf$lCPqr8JUk8B2=7?V9-os`fl2
zcHt#O<TV}LwUiI9)$sFvRSE8ki#sojBn)_p-rMVvr7UlIG~98m)e@l@xHj29uR9HE
zWI_HcHQ2d%uo)2-EzjC0$J>~d`SbIKZ*CGqCe`}Lq#DAwB`4s0KEDy{+DmeuPa@AA
zbJW3Ea-tNVO<*TGx*v*#os+sL<~+z9Y>8a^$|t1e+~>UAeNVSZ>(?q%lwLq6te`Yo
zj4$-&(EMV$-*;Z6>ymwEaV{#Gy~Za>pZhzP@vc(;Oo)5`r}imN|M_)7Lt#|iSUKeJ
zp8|`h+vn`*=B(UwlY!w%jM~*!&0rxuv=Rbux}R_0d)W917BV+RHZCWL7>yn!1-JbC
z*)B-&&2E?gO-&Gnymr~zvX%6c@MRdyehunHBY1DzG2a_})Q8!L9y^!H3-uV%zrX$N
z^aZMjo~in}ZtlWa&1#)ce~av~**g_P4UgpjKfkUO3G!_=daYD2mV+AZj)QUSQLAbe
zuE0qjcpAaOATA0qugLL57@yCd6Xs~fvH@OTk^mIGSU%p|Cj-N<9jYc4g-V3}1sD@u
zNt$}y+uM1?Pk%q*fAa>Yw1_$RfX?T<yNuY~jmg)IaaK<*ibCw-&+_9um^dZJvq<X!
z=`J10{KQ9U*C{^RVVDKnm*bCnFNHcK*QWd5;Lvnk=JewUYb~<|UlO$EQiPUlW|Fx;
zn#K6WuaqJm-Y^poN;t|{C|)*?Bvpb`O2+`9rqom8aDg&U<|~Z3ru)bZC^eRuf4|2d
z#uHTx6fP;b`gWG(r!@o)!cF)3XJSg04tugyFr4zKa?K{a>5aT({*G3+tyN9N7S+AY
zbQNgG-q%@;IhaS^+I#DfqvI+%1#5)&eV14t3)qIk-V9WOcIe9i;g{EDZmpq@#Avok
zs3l?GDFmHf^+3R>L?r@qqT2}fph%AAHBTmOy#pqaQpH~*;}jPBWpJNs{;`&Hr};M?
zixRVS#<&-jA(p@L?dHl9m)wv}8Rx%;%9XJojkBU0b=|CLP50$eYN#x0TvrubH!_x;
z97AzQM%(-S;jyNRT(Vr=+c&_J30jO3nV_5r%I^-MdAc<kqA7c2>p>KGfk8nLzW$+|
z;~NS^JA!Ax0NuSh)XFTm*pO`4vCVTPe{%9d=JTXZUo6**vX?_<@2$<ZF;pq6f7noO
zel<EOU@ZD{0v!c^5DQRw@hmEO?LY~0uVl9~h+?6hBdKXDcd`P(*9nm9>o^@D=fc^Z
z%*@X!tY95p1AelPmSe?(xTExgW6{1k*)WuK2rQXr74fBbAW`D%mA%G-Tzk(q06cw6
zvC&?lWU=w&-SN|*Rx<grS|)iOn4i;4io9aB|D6>A^|kOpzl@l94C9Zv&mOH#1)LOa
z!xi3-OrG(WmiDWq9|E3>S1EI~tmkJk*_&oj90T8}U-wkJavuF)1UdJ2QjrzeZwSv2
zSkvyop~JyIDJDx5C>owTfen;e^%q9_<xc5&4uj=f>#YO1;S}teB3;%kEFw;Sn&ZHC
zwQAB3B6L}LG#Y&G!F8&)gMGc;yAKY0w^qzq93Ye|WC{XZu<MLU<ujij$Th6w6&t|L
zIOfBEvbE|Gs)7zL4#CIn3fN2I4&0(%qNM@cc3%d4XjqpzlBn}kIFN7fE#Is^c9l<p
z3vx(lzqx;?9Fpg_@pXyc_@i-0X`H>hBiyq*n8cqkn1+Gcs=eAq`cEd30Ri=_9)~Mb
z%TrD2UA&Vb7su{@ldfXb?<Q2~Z32r*b+=Y!6F6o7TfH&T<}dxBsYhHTA9igA$Y+a9
zm(46y-g}yTg^7Z?Y7Qew8l5&oOj#kzCzH6<r-}(I9J4I8qrQH}jtp2hK9<Y99=V^M
zP)3azjG*1Q(OcO}7kbm{y<dW8b+gFhoJxdVv~!`^K_@=lFe}JU3#k0M*qn@gnlPaF
zew6q8QI2JzeiS&n`XihXV%kPJedDFQ{eGYSQ&A3Z!q@@gF;!B7e`w~YQZIs21hOb0
zCEzC9L-Kj|WoB2z99>zI&%|7QV=8i-5PQP@ohy{Atg$wHF<+$b;Ykd%-WXc-!*6mI
z$!i_W62bH>{BBReT~hUBEI@BDYXz?Xq%>F(;RCr`JrZl$(LWcfG{mCXFB6l)7%wC5
z>3#_@3Xw#>USdbjC0b!tL!i8ldOD>nQ+~nY3nehUATZA$18`&5>C7LlU6(evQ-_Kr
zfp2?~tzgP5@ncT=OIz3CE&|+D=?0TRV)W%8_0F?A&1;vFj0iCj$q}S$gg+uv{B49R
zLj@q@Pyi$SU<TxL>rGL$G}|qH4m5stehRGgkcHg+SnBl08AKDikGNjBo!Y`L;FQDu
z?~Lgngw^l|mI-5AMRXEV@q#?X@Ic`E>Yq}W?<pbAbRp8?0KIX7Z=y(lMXwW&2@1<`
z<N0pPsO`v1s1_k4uHOfuSN-46b|MTOmE>F}*9b4(MP%wnS!p?LrXLThE!YXWRmeoP
z)u1B;ZI#Qzhn;p#uokErerRqs-b%wHeFhGmQ`4UNaTPDS>Y0eEuqm=P5|&)bUtX1I
zQwSzhFDJ@PJBW_FMQu5x_%*_H8p$a4Gc_+Ev}eOdM((Me&o&HbOuk3K(f3JuF7nQ3
znMq3R>DG<@Tj3n?3Ebg8DM2P9^3d+kp_)y%{O#^rFP+^HYL3bZLm?WUJ~%rK-^O=x
zu_Q>vs@}t~io3|$pd5wps)N&SY&u25euzX81%N$a1T-4qV$kP2_w?NWohC)d66AuM
zbh((2^9EldA}Sq?bU5g}P9e{qWgm9V&t97_$2@3_49p-7vv3r|%4i4E@YwK?iefe!
zUs2QpHLb@G#=Jt?o!*&)Qsv2N$N4OiHra$>%?{SxL5}hbO&;TxPO`mNP7%IWZt<HM
zrbdVv(v5AVh5LEe$oiQrkDQR1&Zwg|*!|Jn8yb7-f>jn5)Oyor8>JcBGtP^W>8_8J
zOoM6c7aPEmD;O*kGLl;V(OBoZz)o~W(Hzq{u6muBVqow9h90`hcF240#t;ehasQkY
zI*-`|l@x<yEX>`Jrb52Q$HTs&vmJxzDT~%xYnC|4o<39*Vg|%6FI{x{E5vNXt(Vay
zh@UO3ngrsNkoG_jjSq$a`86lyw0wAjwxg@YxYZc)+yOQ>Rp9I#5D1497&xvnCZOis
zXnxtb@YIeLdD0xINGNwT=xkUNhf+gnj%~!;Z>(d1hdhHi&(9A8?d{|>vej{{I2P(8
zMB6oU!@mm5+yq0~cE>WJhPZQc#<}OIs&CvMQha-p<{9-phr2$YkW0T^6%=2%4%{$o
zqEN^(b7xsU%1Htt=2^Lzmp9^7G}JE((~*VpR|ZTZP;>GGV%gSC0P*pHS4>hkUg{bm
zZr3#I(KMYy33bHLQ);y_4>m1m#r((TUl*ou(0uQFF`ma+#*7}I;Xshvg9aiC^ZTr}
z{=UIlow)52c*$Y$Pb1TukFNQ85;WCz)GJ$P&1Q{iQ*=SfH&YgocqS5wE7<`SFF;LG
zi79t)m=aqG8MjkOYtg$t&I(E)p=kE^3s@vmY{G_~r)xOrmD2EuT49Z1i!!qBk>wi{
z8UF207#$Y!JMEWM%H{YdeE}v*cMRuL0~E##P5ECVL<A`PWduL@<uiVJ$Xph2Th<Ja
z8X-nae=J5(rEnV*mK*pg0|G%y$qdgUaw?&Gzi#f&gMc0f^&E5Xjg8`VoB^vHj|}9I
zW`C}2M&yhzhf`mThombBB2uNz4d=7Kdv3|U+%n<rb~<S%`lYvk4!2SksKD5(F8AkT
zS#dbH*=)Gf)`k{R#zKZh>NJ%7^mNSVojgx;yL+$}Sv~l0O#Gsy``$xt?`{pr*VYVm
zI>>iu%%!PBGdWEo842^lQG3oqSIjvrKsoY8EFncP;fcH4Wg)SyKb4b<)L6B$0daI&
zikF6kmovH~F!o{^FhTlI)NWt={)=3%!h!g~Wc{cojZc0f<N8zAu5@tW65=?HBJUbM
z=nG&k3$GRG$&NhgMJK^U*Z97L#=>O{aRr?0a)r!tTk$g-2aBy+ml<7l_X1x!O$HHF
zKLSd+OmNSpG#eT9x}dA%SzR`<oh|Rd9pU#g(lLx%+ba^mS(2XiRwW96LZWpn+Np(>
z@HgIp&sRF_Xw@7rC3e7+25iuQ7pWE|qfF-EuC!M7`x!I<cHx=hTt=V;Zyd8gBoqV{
zAXFlMW_fdw$@Ant)XAJ&zV5nBquR6jV-zt^slcv<M}T}sK7g76*VKABal86ay@qw?
zy@E;oyARC_!p!7v0?lcW-{@XWs8v;q-4nDahZx0lceBwvw}tQUk2i@_1KJs#W)Pq@
z3J2mM39I@STn=U7+Z&$m!Xs8A_p9vp2K!ooq)Lt<f7uCL`1s<yvTBc{1XY?W&{Mt&
z?s+3|m%7zX{S)b=`bBynr}YSc3oxD}iG_ynfUJN0`XG_8E%-<&8pz1CxIHq`_>z1J
z;-2ec71n(k8L!~OVeiT;S_I=NY`&Dh+YN&j<$XXo+-mz{KxGXH<Db`VcD!lDh0Zee
zsCs14hpp#$_;GEn`DvDc?~G_K>F&fChxbJmEPx0UQFuVe-Q`1vH}y1p2;K;%)LgeZ
zZG6J32K10Si>o6fL?Fj*6Vp}ipUF$em(=S%TjjO54u@?4t(xeLONgHyS^NpmUhRat
zT>zQjW0}b0W<fS0fW@Hdz=;Sw&Qad})vw^5qy3W6a8HJ|(H`(of~k*PZ&?~3m;<<O
z@K5(bYjRZ`WDVI7nj19mn#u>1Mqm5(cWYBDif7rF`B^pwznwRLGo8W8;2Z^_!^}@j
zU6>zdXLHMkgn`Mr<wr=%gb`|&r$RjY=9cQIX$P>#)ixOk)nyisyp_e|n4T)<q-uKi
z?v&cq%LC7gqPY<?PhgJeSq3Ud`o_Em6vkuDf>Omh`3a(vPmuDbDss<ZnfCkZF@8oN
zCX4ak)$`ZAk}978YDmSj#^+d<@qyxn%_>BBc;sFg#IBU|wdA;Xl)59c^C^!Dnj>p}
ztKhyb(Zv2~m)f~O+a=S(R5X&s9<~DTeS}0|$F~D0lXu>(I1?a{oJoPgfVz<HtFQ|%
zmo#UMP*W0iE8QCXGZH=VJWqjM2eNyRbF;Ke0k;>QQY#3!?8mP0JdV|-7#g4<mUSv3
zqUDXy@$!v<uK_s&n*{ALU7m1;|G+_XlBeW=Lh@ZQ%8#+odA$Y>GMb?Xpdu=5mf@HE
zL2a~^XmRLzmXFy9uSc3PFe5dyHW+r<P4{Pj9sx#Q+t8<sKV_2yrPF5<!lw{Bdj+v(
z(l6!jnc&BIc=vabs2F81y$^*ES^`ItJ)yV*I8{vM&r1-<;#bvxc1wG-T7;n8d}VG)
zZ%ej3bwZ!)<Ojptqb1vyaz8dU`?;kRQH5=m;qmm$%=jLBk>3LmXcGxxm%k@IJ6>EK
zVDy$Aba!-w%`qvAqX12Asr>bq{xm#hx5~W~^msnmA9f3<ep&vWD3ro%%UBpOP*@-5
zjL&*SbPNAJV=XGsR+B(mkbpXnRK+W_DYUKEy2^bG<%8n$ye8+z7)S<ot1~cS4+#L3
zl9@~@iC=QE4!f1@cL3;qVxBD8LuY?6K=c>C_Xd+J9@?S1k-$^L>CZd5CxhAJN4M-+
z#j#&VjzePS=w4!OKU@u2*OK*jLiU)P7{|hdvEoinA<O3R$n3>ki2^AexvbX8N`9>}
z#ez0mr?-L-A)}rti9jtrXnlh^zG~!YneyggCPvg#uNTWYfqfmCV=NV#R646Hk^|lx
z6zKUoq4pateTE$%(Z*ZrfQAwA43^7?iHkq&FR7)%uOR3}WT=0P)tr7Odjc^^?Gslq
zUc7wZ(iu~X`K;jJYP?M`fKjU-_#`XIf!W?MI;dE++>}OTQ2LXQt*L$x&t@a`KN@S4
zXqykElPd#-a4X?=Gutv1)-#JA_?7>@R{YOzILDrq<1WeoP~{CEWcr*2`grLo*tNzy
zD%F!w4L@sAVgY(YcGq#GkM~~uK%m4~Ta#Zx>FaLRY<L9tEh+NBf@ieWczTp^sTtZo
zrMHw4cBYYwNltjQK3>jt_oO=NrFOlCq_Ky9-mv9}F#=R~e0-^@K(<YvCss><@#wcZ
zyZ*LNHLvqNpp(|`K!y?k$Z|;~5bak1%;kic8LIul`f>JGRO8#8c;356ZO6G*vQe*@
zuZgJkYgRNnBTDyomFNJ44yCqwm|`ipR{44~K`hzeXfWH+-gQ{5TLv;RQ|_a4)_nuC
zPHc}->5byZp_M7$sJ9A#wzPof$7e_W!_7vEpGk;c(F0;J`u7XgO?@mcfWR-~gaR_^
z`oxlUuoVkzp|6p=^Q?sP_;G%w@j^X2=SF;<ZiPm6Z>)LfWR<E=oUm;vpkefo#SY9N
zHET4CyOXV(HAQNi!+?tSJG-PzEkRnL$G_Vz_qP>IXq*9&U|>?iCkntUDEz=-K&b>&
z?Vb<QE^|J8tWji^u{P>n*nSgeRAMC_?R`IUXUN=Kdf*P&FMesm)?*y1**$+CHStY@
zhFMdVmk@Vjuj$xRvBdyXL6>3ZO-414#>EcT-%UvW><aTXJCjLFKl%f}Nq^*R^BI^@
z-aoT~$?MnN*xB1J08M5AFCMcX6)0iPL8b-P6P1tsLmtF@`*wXG!yT)IQ}=d_@DI)I
zsIre6K$=Sh1P7CfP!|00n?mrvH>lx0oc(DMV4CiKHNe1cLMD>G8)5&x8L5KT01M_b
zJ1dO?Z$bW^rsP{d`1El?fb}=L&%eBQwDOt3DL?sFgQK78)%XureJeNQPYa>`R|}!M
z@7x>syGnq+pL}u0I{?>UJ#-a(Iq@p^AmMpw;5VQFyS>sL{F|+S|9p|~j5DW}@%CSx
znq+HI3H`rp&;R@wD?J4INe^gv02IUoymrPLNctz@g)A>{iIl(Fu=w|<^j>*(X3V+&
zA7c))#peCbAM0ONqb7A`l5d0mGD*N`{biEBeR}>f$^ROb|MHT*?a=@7lK-~`?phy^
z&LJAlB+Yt>MM)nU-%T$yy>sF#sk?LGKa7vS*KB}HMBp}q*zLS)`}~dYFtPEcQYc+A
zc-d0yGigWj%X&MPygTn!M!L#}tk*pdw(N?0A4hnLnlVrQ50i?suUP>x)QW5a3!pGw
zg~AoOX`!bn>;ez(1j&94=Or-w{g3jO62s>|Vy`G3?as7rhjLbs)-RI&rzq{}qnWz^
z1RCCi0*tYK#4S2j!i0V3nh;d7^>{Lx{sVQs*$7*7CrDDwMY;ciCX7X7-7HKgDtTwH
zp+?cIlxa=9|KtJPf4I-yD=cR?r2PzswEP?j*Hl*CLnoxrMO9!EH<{i6?^AiEtY3a1
zN3pEbq}FZ$4k%ozZlii({}F^gd&pEl(x(gzYB@Ntn;tN*q1}8a_wkl3SL6Bppy~Cf
zs#VmLvlsjBy6_N>#?*-hR-doeMEiSft$8Cx`1c14{1X&T0Kj#Ex+R4o&o1ugn*=zh
z>>2{RY{sHqW#dAveBL<={?+Mo#FKx8RR42B5|5(dcRWm7f6@pK_Yc$ueN_b7ci*7%
z{?M-3*rz=B*bmXDdnp@|Tt}^qqPWDOnQA1Hx4RL}hPr9V_AtIpeRr8(^glMBiN|NC
zoa|{M{JBC}6rzdSfbu{7t+OSARL=4SgU9a|W*zWm`9IrQWIR0bq^^Vi<Lx<%B}#bU
zKp)Uh_<(2?VmOS(*<rynE~WZB|GP&$qbD1<&K?yYFfRI`|5Nn*=ejk|er)!yAN!3{
z0Qzgs{^wre?~v-RJ^TGr`q!TQwP*j0Tl&j1{xXgKD@=ourSNn{`M`MU#i-ZjI~ex9
zh~4*Z)LgkkPTc>*x&MO8y=!F85X~0j@4zEU#!Wz?_oD4HytDXLK1<MD%YVxjR|@?J
z=S<Gv+$Dst{`=tnGhv`)aN!hxMD7y>AFHrr00t-R3S&+#O8Huns=K}@I{)u-81I_D
zfl;R4TtY_5afC?ubZVr~*9GU4YpcRn{(b4&n+0HUJExTZ?){AZIp1vde<senuTeZR
zFO(5_T?udU^S$_QQL&QcpOi5$D*PYYBmVjFO*&Dw8mIN*I+q#mE19-)t$*PD$dUU0
zFBqgAU$SC&pJn3gk2qPo!YO@J&fZm^`hfJ`ZPxiq@T4>DTjFhDXEUtW2V{aujsosR
zxVzedU&R>BwFavwDLo1Z2pGtcjrm~dAc@J>0S0eztnq@ui9dpA_&&}yeX%><w~c#l
z;4_5Os`#Y<4v`ubS8;MGpRh-X3}i@=!!$~a1Ef%0T@k?lkMVYNbPUvc9^D>SZ*A2h
zuBdMhrko5Vn{`Gqzkm#6cJi}h|Ep<w-@Y`Qr||@fN{ON7F>7xRd$Mjw+Oshx9~T!_
zY=&kzIsqnyvI3XG1b%I)c3gcbA~Kn*)y4{30YOik$;`UGHr=3ivgt22qW8Sm9;*-#
z5)utYYDyDulM6@Fr}d@gnEYK|HSfCz2M60HM;l$hI*ou|v^(5|90jQeI^)=y{m3HJ
z^*qb2?S^wa`XmneqrI~;e42=JE`|&;_M1;fv8rbRE3}*TBy<caim^-h-GH&^u$R#t
zTDR+YY<=;hbCbt-8Lp2MW$dn?yH03KJUl#LZMkM-yY8aIDaDwZ4+Yf%yk6#;y^Weo
zsdFcEdSAS<200>ZaN<|ch&2wi&I5Q8p%AoibP#x{pxb<Na>iB2&=JuHCteASw?QB6
z4P{8(3|D?aGO55fLiOLg=BhvIw(tJ_ni~#!tmoUrPKu;BW%TNxM7N`q!mNr+N!M%L
zDPq%8Y`JY7d!r@`bD?4!sAlz%qFu3d!uq&LsMq$qw6wfD`<Ax*-ddRZMjfWybv{h$
zV@EgxLwUisV4(X-BF_Hr_!by;k;?aDHQ05$!aC-ORLBSoBmV91Fj8y$J2cZ{H+xLN
z|EBa{wmj=v49!xoPOp4`k!uRIl?`;ZsmQQxzB}%v(dcA3S`RuyY17Zu|J(;E=Jo3*
zDWpIB%R?%n5lt4c=~B*<`}gk`yY3i|0{2F8Lk51H6kjGIEOF{qPG%{lh^C9BtfV(|
zr@^P6CPqXU`m!7bJ>}4?HT8l>S6EE~v_cEj7hHiD=Q3wOUy;>laTZzS6825Ak#5)a
zLYGlrYE!}(bUPxYJ;Azu8D07sLryC^LZZF<)Xjc(eZnIlA;BD*HMO5FW>O9rY@K?Z
z&!>5mlrR=Lem}w<+ZzDp+bfCO71$~9GAehS3+9{0WAq5Z3qF^xTRiJ1c_m<N1Jwwk
z1)n0tz5e)~BH3m<QE9tJeK()@>HNj{aq9;5a%nGEu-`4GjVbmk<g}5%6}F?OI4GE?
zZRlXN;y8%<Rqy9t&KW9@uctMnc)GN;JBCR4!*jRB^qxFHJv27<9!>X<e*845KzC!8
zYALdO$x*2Qq8kJi87PpXcIl@n;F-_yI_|wvFb7_ABkH~`@XTT_Dk|b_SJkW;pUn5Z
zO3c{NZiwmYLqbKQ-@V&(G$o$AYcLrvHVPVogJesaYI?~$p@=S|#}xjEjwmYOi5J;j
z8y$pNb&XviI%AkpJXAPzs_!^qy!QRQzNefXV+|^nJIA+b(FGf`f*C1zDm@S7T`CDz
zcJ!=!wvA_skaPYwYMxFj7E9sR1Vvfd2;i#hQ8aZl>-uz#1c7sPHSoB0ReR9OnozQY
z;U-qeH0TW!SRU3p>Ji;EX&d-AtWWo>7pNNczpTq>G>CouiPgb+C##d;H4%FLcx*f{
zWjeZDBYC=cCBSOIBoDq#^axNg&VX*D*()?8yAZ$K$K9)NC%fs~9X<^DoC77=K%MGs
zW_^<M4mDW22s#Y-D*AHBt(64Vu8)8?Yj0B_irEK5nbyPg?_=K4S<HK|BO6n2XEUd=
zu|swF@?lPTjNa)X=CX0F)j?>LEi%2vMV)r~`0j$w)?C}T*rM2e;C;CiQ4xOQ#R_+-
zab1vlY=V;yk(aMFYE0g~M4=FvTN*W1|AIP}hTPZl1s|hYE3?3rf3PAp>ZGwWS=Z&B
z)9;JK9ATrT>fEVf6DU~GhI?zHmlcJ#-h_#Q<_X>@&_l=w0q1m;aNJBTcB9&3!+p9Y
z%g|*MI3JZiCLTT9i(SlK@S$V{UqU^^1ymK~&3vKKy;{={QdYIhHeqF?nPcB<%f&|;
z1DWo$I__XfxpcI$JL>9jun=>dL$7{ql)+xr!n;?DLinotw}DneV9I<WQLeCaN0_qi
zl~=v}R0%27#P+i2(OQX5W@hG0QKI2WMsENa4e!3--ukzI<R5B0q~lkdy%MpE{L2W%
zFe~6Pm~{FLX|H6=!GSN`aq3J_8*K@W@v|~ylG{6&p2)>#c_df?YuBAgwidkUCVx6h
z?)83iK$dgVe4MqQR%PwIpz{QV(&TtoS<Gvr{>aLkwkDII6ooVVEQ;~Ea;;(l_khnk
z#>eXf>&5W_D@vH}h`27d$u<G=U6o6P|4>`q6ZWIkL#dAa61A2_IVQWZ3*vNB4jK*;
z8kj4c*5fhxAhWuY1U+ezUfv{g%Bol!$;Oc)!{)sflrW}18t27if4D9@wL*|hOGz3K
z-Ed<cDDdiaoeXuWW9h=&rvP)jXmhAv#?DKL9fo<T#gL2cKUyoC2*IvHJ;^a?UdL@-
zY#%<n&b)jm@+;-IBjwJG2mFOUJ_k0fgV~2YcY6352|#;){ZZa@#LAJ=;yaB!yl41#
zzXhTz#=Q8z$n|n>Ly3PP$C@nhp!2hj@5Z?6>0z$@Ay^E7i&*9v5wL=!Xb_-Lz{gJ`
zHV>=b9Gw!pP6?M6V`wXD-p^MZxd#?&YXv@dy7>$2)e2{sM)}t>Q6zKpomz8K5(AI(
zK0ukJOjS{s3VX6WVN+(B&cVS;3)fCIPEQKjF@Ip~(?X&38!TBhl*O*SwON<Nj<--j
z$D__OUqxa{bjKr&`ia(#)5VGY|BX6HN#s(Z_Kmo-UvZBs0xI=3j~Sz1db7AyCrtOg
zFSJ|e{NOdw_>g$z)W*_52h?DIOeeCe?7R6U?9g!>(g~#nRiBPG5VaZ!4X4BlJL6Ll
zeCnf^Ua$QX_b2Z`M*aaI|5U;JL2;ER@be&fgqX`$xq_mnta~8hHnd|rw_SPAhd8aE
z&I2xoe!KY{_{RXv=xeIFS=9Ole&RTLqfcjjb$8bRr4)VierK`gdQHQ06z<#`(1`%v
zMC?cdmQ4LY$bHXZq~gTci{PAvE6CSP3EQr<eQt5ZGoLLqL4{{#E?Ghs)l8II$1Sdh
z1kiS=K{nA;>xPb`;414MC#wx7s~@~6>ugJl?~-+W_G3JrDitvw&YKxo>Y2+PP%g6a
zucxY`b?spy9O|8H$Fzhj=*|-O-MVcW;p0hjE7`N8&MD0z>Qn^@&G;Ci%jLL<Hfm81
zmw;C<$zE2D$Lvn9zQ><Iqanj3PCEF_Sr!5&FPzQ6g2k-g#xJD^?d5f&!t~bCa!v||
zquj}Y-U-75E_t={&{eO_%@MXC;mdvKnUt~sfD7AAk>y%mO7+0?yKX&wBo(W!HG0z$
zLNKB&ioNcxAII#JlxYI|@DS_^@;Zp|()gM6!Uwdl<%&T8*JgWyp4<NVNl(OZaae90
zm9zlMZisfuy<IUaQwT2>+o0auvY&j3?z^^2O=ZO#x?zB?tk`)81|2}B)-%N1U5NA{
zK)06_o_Y-@tC13ugB2qVicubYt1f6c)NUwuC+4XS*T<+IogQxxd>=pa#NAY$G~)+|
zc-P>YZU44xFw=X>#*XXb7c1j0O&S3D&mCEiOMU10V3%$$$!imn0C~@%o?5C8TG-1z
z?tNPbKV}oS{ZFTyLuz{Ot@R5#=*@!`PN?$turPz^Y!Yax%BK=}>q0{HC{kE^B1$#M
zUa(<7k99C|VX?4yPs;i;I$=xp=%q<-Vyb`j!u<Rt#Vo$2nDPcIuT^A)Pg@@ik3>u#
zmn(qPt`7_hSiD49Eu4@YkNMkpGZIj|nn^Mj-;ZHL-1qK~<}ahJRoK6*J<3Mg5U+Y#
zhq)lp7ZMLL`5eu@D<Nu^w1)+98YU-4PYzcLs8-X*1jg}O6%9no#xK{YEQFFGaN<dt
zHQ3Mgg@Cd42`nOor*QHx+(ALKW)V9pYnSHA!~o5QhpcsJQ;2ILfZgs)@m&3tsMx09
z3)b~&n#|mIkOLQ9sdbnNJ%n8LdB<U0yY;qEOrhbJ1TjIWH3dCdSDE(ndo`&Sv`aO{
zkMSV8@&(K^US*$y<tl?m4eBA4W_Xw!>Ut#!Dzx_6*5S^*1#`K43xLs~Nm9$LCN-Zr
zWTAzCqsT~D#c;aZKw4y`aFQA3eyJBDkga&_H`Bc)|HA_r<&jvw#3ftYXKuKZZaA}6
z5K8^Jzd&k?9J#VEl})(>Km66r<;m9Z8Vi+V$9?jH>Sft0AqtlXx;Rwum|w5rdIWga
zp~h>sUyAp0X2Z`_tk|h*n58ZyS94uOvBy+d1FkO%oHMZD?U1}Ge}eP!KgKyX(BK?e
zhL;KMy+;EFIOnQ|sO|kj+A&3EbR#y!OVq)>%*&G%5E{=47_JI~-xjVoiEbR?)eD?^
zxe}o@bh6ZPbxzd<gKlitn51Qtx))yE3-t3%1MkF&9cv@J6F@|Saq4J?HEx%@4fTR2
zD|vd(lf7QYb9Bur6F5SlTi-bGJ_7C`wsGzY;u!wQgeb6?<UGaP-qYh4AARV8z|5$S
zYrpp0-gY?EPTN_VJ|#|D;$IT$r3=JxGjZSxNEun_Sy*^^)GqB+a8zb9@4wA>aiZs$
zs3<t(epV+Ku=;?2YZhcqpS(MbP&no1vs$)3pTuja+1T{udXVQKzV!x?tmlv})ve^S
zz3ST{KW|FhoX{z0M%zfarIz<e_CAnqlAKEPt={W(tCQXWuyEOt<w)V<5j~R{OvXuD
zLcJJK@vcbD2~)t7>AZ745dh}zpW82X`!L8xkI;y{CZGxP{3~90{HGl`e2hzOSTPYt
zF=ws1fXqzEwvWU^d?R$V=Q0Dk+r=+~<T*(p-Y3}5dIFF6@CeOtqNS0m!*t&aR7|(c
zX1Wi43egxyC+b#MC9P*neV>{5tTiCoTVC89#5e8nlAl*0%cr<oDv6JV&#IJ<UI2^T
z0&YfN+H_Jgswb!e7cgCYWRM)028u`U+djN^N68uyTuK%8s%rndvT}S3iAA6B*BiG}
zDHfS;Ai2rfAL&;sYmvH~zx<f{)~&B{R0H1vNFU$2D&1Ri`bBXo(Qz2A<Ic|{B+$^p
zG$dMv03#2F;Sh|Q**`<q)m?m&ZR`C7$7nYxX$Bs-iq(%iOAo(gn(Iw3Nn;ADro2cD
z4;*)PgK_qC(%fCLy^FA;Onyk+x;u~duw#Lu+2_$c&%l4o0$6e{3rHGTnq0&vVJ1bH
z#pupu@U2uNM1T3ga+x94zg#a-jd15!fAA+kPSiz8q~fPEA*tS(dUB@~rbTvT&O?h>
zGx!z;rIWurl554A@YV?DkTBwQ<X6pWr9lf%D?&G`^(`pnCy=)ny@14y;b3+L)9NeS
z_ta6!<qwkVRhBE~LRfPIh`WQT5qIVsEXr$DjtrezTd8_htdj(BG+(Ekr#&y;&52<-
zAR(A(<07EV#oLIqk`ON2fem_S{J#5<7WQ63erI=fsJ}n0o2ftp^+sC<b{djumFQe?
zI$VWfbDDI-SefXtilOOPef?0vJKdiSZi?>D*im1uY3sl!6I*GR^iC=FwV2AP8;+6{
zKvHw7k^D-<3ZG)8nN}h-1|3#LgLmAuhXKB$Vgh>Ys?L-O!W(obGJ(-Rocca|k6u2>
zPqk%5kP(UBTR{xd5*V(w2N8)wgpiQ{Dd3Y5bq%Yok@r{J+^1??FADFnb!B%vOcAQ{
zL%$ZPYg>t0bwvjGX!OWQOpc2HJ8=j{4)t<XA}?3PRWHEASxS^pTDAiM?e&<xWXIM)
z_TUDDPY%2u!NTed+&t&u|L<6~ADa}93Rl)=U~usl7ZB0DKi~lrOwr_*hR(G#^nl5)
zvMs+#pW4OJIPG5{bwiX)P2FWmX}DmlAg~Z==L&_2JnOFeqS>f*Vz~kp6>-7%)@sKK
zI+`_9q#U~98HYwoOt8l6v`ec!p(ozodkXx#I>*DkB68&^$l0ICG-~YWtUM0hR?E0r
zcfT)tM?&P@H=1P)fl>ut<WwfIB7SU|cj!>trtvbb?E0+!B`{>Xg*+0OsHqEThB>W#
zA<t83MuAr{gpnM%1}y(Ctu<qL-iz*!D>EZ%C+vMk>lG=%9Ddcq#Z;HxbBYofZM;St
zs9S?=JU_+ckKS1ufT;8}<P-7R0n39qR3gj{@j2E*IeyJZM%Pit5}dq>H0GE$7}uo&
za8l9>+-5&lBdj+Q&8`+eHmX<i?VythJhIhH16{QFRg3Y!NDZ^@ydg9FDC%SRxEEPV
zjgp*=UoT#Rccww`FaDTphUMJhS*l2`wcA<#a?cp1U#j-WXA#7y#+&5kyVWtRm__Yt
zrg@od<hWWaR24p(ii1#QrXSHvn!~U7g2R1Y?$Y1X$bALJ^{Wu}L>2YC$~;_6Pr*r5
zK(G!vs&ttyJt$Kg6NHC3a4_$8XAgR6Csr59vnh`At}y2fKE2LUtELnryf7|fmIH+w
z<cM*YoxTvlf1Gb9L6vVTbY=@XqL8}b4r{9V%B-B?%JrI5dg{m452}8^0b&c!S|C=D
zdjkxmX>C~E*T0Qli;?MU^SE;>OtwBplD)uc<?Ta^wJ5lCf=hRye?x*di8|?M{$jft
zovJh*4aF*nRuT8c%nR6K3^`%a3o$g<i}a<zsvW1vS#$O!Pfd8N)Lk8{dZX%C=#soZ
zig(tC^AU>1q3fdL_@$4F*G!kVVH0K}`9yG=&B8RB$o`D4(f#>o88_*OsFyem2`uRm
zhkC;<4YGiyYTCkbbbW0@bcTa+BCD3T;j$9Is^G-dr__)&=El6)<Ykhgy4nxRNs=gC
zb3$zh=4jmKIi4catLF#x`kx4S_7XWB968w4W!8?tQf%*+>Z~Q2VxA#Mzz4cR$3^K;
z;^|KLSfR;j_Cgs<$XJNe@s1<o-nQ53*w~5#4*H6-paf#qb}=Pq5A@L9VQmPXQn!nY
z`T@@>YB(~d!QY9MVTsXLx({YKSPcgk7_c`eY!s2qx#=32n|Kj8nfrJm^RH`4pNtIQ
zxcGIGbuCOdX9nwxOQuPx7nW0$AqTMef*N?T)@bdz1w}$dlmTc{4ebo-dQ=FP@!$9t
z8vh?0;63PtOW;4=qtz*uhu4G<;<Dx#<>rU(Uo)>bgF3`g%UzF^c2>MQffQVIak+tz
zg4chHBZX_6K%tjSTBOM&j(t7E>O6-DZny5`T<5GUgv6n3WP+1_W%@^*yh>nar5#Jy
zBhvga2U**w_6C{htC=LB$JG;$n-{ciB}Pe+Wdh4dvrf9Q-{Y3IO=gaigBifN)N1hQ
z5r<3Dsd;wgW8(Rg=Gp&Lz(@0(uYn@3$tn51t(gk)wedh*?R<iHjt5eB_MN^Lp5otd
zTE{$y3oe4v*KR3m<aI-HNs`w|EMeNw>NUZ|ibCt9FG97SIEw}2f>k;QUsF>br6`Et
zhwScO`_Rd-nk7B{B*uX=la|w>j;O@BnM?6LOFso5IYnIyGTrI$ceT;?l%`?I##RX|
zOHUm2V2*A}Y5twX>iCJYBMB|O%RKv;Bs(k1EL2MA5GKWB?Ox7P{sTW>7Ju^N!UeP3
zjd-5dYBn9cLL1r~C{zJ47k=f1S3#aWOT)B=D0R%rXxB6o_;T6)k9svuvdIy~MRTKQ
zDW+w;Q@maTUiIkRO8qb=BI0m)H3=zOVvsK^m=D8^a*6axIm!mVS<MXMsLsvP6Eq%%
zl&-t?2gM{E3f;V>{6rlsL@a6jWvk)2abqR!am?{`s3z&y^4Y00FQ+|Re;RXa?YOno
zMM%$hu@Fw~)|rGEG7LGGb{e;=$_t+}GT8wW-@3L?sz(lj>TbMikUH?2iLUU|#7;O7
zzNq>xtLdoLVK&}^u($EF#$Ce8nGqi4?4H9sVbjp)96vY)gn51<_@SU~PliLi(KtG1
zrC1Tpx|ejp#cnxa`q)??$tM)9B6L)<fqy|&2@^MEHJ`Yi<U_w!Q{Aj4{x&ChlD~lt
zx<AWaAe*1>>{ge#J|RskbxZ#tRr7XtTnclmzMlJf$hM=#&dP}C0Z)Ru(ek`o{UCAD
zC${^i-$`{xYnI<)jseGkxb)>G>RCG|F)>#t2A{d{5V4{OIyhQaCmc@!5%?Uf5T_`9
zNOcswi{XSBx-wx3%lm*6SnVn@-EqR9Iu2MymiP~_N<~Oxxtz}Uk^XDe1V2GN78}+m
z-~g`Xc81H;GodH&8cgF)%en>U;D1Kh&V(OumWTBc|E?yZzfbyJTdrh3ZuUe(1l*%2
zm8x-BQ?o`P#~b8kxYR<Wr_H@GAh=W_(%#q1%u_f(LxZ1D2;N^4BEx^`%HjVmxwAT(
zK-<0=Y=7l}jd;Vs9AC*HANA_2AFb0W+5QS~<z>o&oPhNNe=}dPN|gft?B`!S<7V2~
zZy%kUUsRTQxDcf60XBTB#VJxd<i>JNmR#=6Ipb+aE}z?~Wv`oR^~u2uBhT$2{?i|d
z<P(-Bm2E5{m3!ppDD$!_=2l<D(3-iC%Tw`1?{p2nm`^8xuw-m+k=;d1-4s2S$<>tL
zNc}#`k4JP<Hu%ZVIT`B^be~veAdL*nVk#}ltzX(xt(kEr$o>60SFW4?^hX>Qsu{~x
z$F=o+@=uBQ%>2uq1Nb!Z?LN=fi9_yz>{1duk-HsU4M(^dD!t{C*XJ))GlFfPaPK6P
zL<;(<iU{V=C`)wJO%T2FDpBvaqSN>Q){V@*eEn`DW}sTV121e3(CpD&%7&$C+aePy
zMt_JNq$X81)~EF9CFD@QMTAY=6k1b?ZW$KgljB)auZId$xgst&u2`rpB$##MXtoxq
z2M{3#?gIEbLuT8-YpNpM`+mLx7ikLo0^qE$%ovLi2ap8*T#QV;vKjjLkfV$iCOl_b
z?|kjD_D`7B_?uUW<u~DCa4$jK<;pbOM|MXsoS_%45JmD9sK^yX4?c=%HK3A)P)-*R
zDs|1KA}ebMLEKLfNxW8EE8R7>GUBT?=z_={Z;-8kir3M(w>(c#3^k{i0~zcyVt#sZ
zq=RtxW$yWHnP6*ho9fQK?N~z@dtP$c&Nh|T30Svkz9Q+tE=`oKXvTD0-j(=?+WI!C
zhi&%KukMv|z^FJO^@5!ADxR`+;vLbezJ8XjTT0$qRdYET5GfIgmE%lt(8HId6M~rg
zhm)*S^Q&FA2_B}asWGoc9mcF+#fQ^&p+OfsJ;^`99_ecJekP^pTu`e^giR7B^{5vA
zANJlmtjTnH7giK-P((*5Qgs+bDPo~X6;V)8Kp>$v5tSN20umq*QBY|r0xDf<5<=)b
z35bG%bVBHn4haxi2q6ia7x$jMoxNwyZ@zQBzs@!PcwGWl-Z#(ltY@utuY28VFv!t<
zFfd3XY8{j?){VTA<Upa_o?>i$QN<(E4Rq5Sx)~K~e+m<=A_nF*aAge?S~92C#u#;|
zfNF0oS^{x?BLyXZpU=TVT#};eZ|6CFwq4Tt*tb&Y1ac&H_LJ{ZCmLC`GXT}q%eLMR
z7DL2PnMMqMt@0xEv~6xjhY~4Orlh`>R@#s{k9+0fS$#PRP4hIDBp^th@-5S}lWVv_
zD%z-$qidYc8Ti%y_Rv4$<fhdB!Ggcu6G(C^+t>+K2nU>;hlq?+-T~FJu9A(qaM2yi
zgS<r_nbadWh_tLUX+xN$lfc>T!!lm&nKVx5<;}A7t-yM@fq&O)0z%q>?P%{(GJ)D2
zH5@G}L*6!-SKLZrlp;j(c{RLIe0fVz$dz_GffvE1+Y%7&OC1JMbA)-}?krxd#T}Ab
zgN4v8lQ3v(IoMfF`9t3N6d9K1IU75?*JHvYlu)t#NzXtV*2jjDY42+)<;g5WM&0?B
zdgdOB?NaRr8OIJEp#OS{1c&Fk+oT?>p@q_j)h~|P?VwZ*O&TkQSxBE}*+&%xOM}I*
zEIwtG{Hw5+kFR6XMTMx`yQ{)Y79t^gf`Ljj*hTr91|%!tcu8!Kbj6j}V=l!edhWDC
zs_h$JjNzvFIXx%#-c?`xc%Yd!c36dALe6+1I@aLIUR!k0UNV>V8WPAol1tb;y<8#Q
z)J9mlK+Q}E>8=1r^+I)SFT3Tg3&}XBDn-Gx&Gg)Gnj`bowE1PoaZ<2(5Ms1tEXCY6
z6(y+?bZEtjaSa+9KNYG~5{(Qjtr$t86vL!UaGg5b^J_ktTmiRR-Vq_9xVsk>xjHtE
zn~`%(0$SdjcCK|>3w&@r<M2*g?M3EiYpr9J=gjpHI;w|@KkiZ%Vn8ie_DNNx*GpQ#
zJ%c8VuTW4EV>cCS6NYDEJ@~?Q>kW<TvHb?>m{e4wwE!!JQ{R*^?BP)(mCbd!`~1*k
z7l*)g>EL-K0JGEP2Cb2Iq8^EqVuE5W2)&sJy<gIb{8iP#h@55*{ffwGLsq?PA~hi8
zQL$wyNS-Pc3^o*h1k-|s<$Deqq0Ac5OGIzeDJeNa%Ak!hA=rO?CMO{vvlXq9Tvo2o
zOxhtPlWMy!EBd91U4D9X{8->I)3lpOzF$`dj9fZ5GTnKJGUOc~H~2(O3K=6Wn&Q)R
z;!-kf>5ELn^7A$aE%oeIty%Hmslzc{&B>$WWqHLYM%eoGYf-(R1W@W$4txeNfpiX(
zWjY!qOLMd_=M^2wDpDveAh12R&G;+YCHblJfPo=$@cCfS4*0-kiIMkG<4#0WRsh?7
z^_;&v?c>>#v76QNOuLDqGj0z)9|?awaG8bNY}IB>^iCOJ6RK|Lj5+T1ykln|YiTv*
zg|M~I%HxY(B0ZoSz5In&1Jp7Q_1(w^PA;}f?HHw5b8Hv~%5<jkNrDGGy6)z}-g~Qq
zKNC}FE5Y;Pm?DK14z5WbcZgXf=ztxl8L9}ITaiSIk(RAfft!N9%bk9~ez>gxou6&5
z?v&!E*;z2;TrfZ75g<z8mQ#12PCVzUTAkvvGnlR-<#+{9-hF6FUyhpJui%;}<=d`1
z!Kf6z>sxi*BLK7aA33)5-v1%TmL1w}CVuylBhg35GAo>k%nX---9;iIgcL+iJ)<2l
z<Tngj3X!j52kU8&dyTitub$EqSPPQgZWAUdb-d#8X7}0GN435do<T2Ol4aIPY?e7m
zDbX{eILDRU7yWL_B}&e(b$dC+N!r__h_0VMol59wG0yp>WT?H%C@RhL%0S(ug*`MD
zG3~xgl4t<Jj?Z2LGNj8FqhRs~!pY?B2qTKKolN$>qL;A5hX{=d$RLKwpao57OeiNq
z#?jQ8ZaNM@t;$9K$8WchRK<IJ2XB-3V@n}IeiCoRvSIQjl1(IDqb%566Pg&@&ibbs
zhVEr+5;%6gF^G9^!6Ytd%+)G)r1H_lpdG$Z78#{#Odcds@}pAl;5L6?2sNkZnHVYC
zzI#9K@TU+E{$<Mi?y&^u-H;|y8I*$WQZ)g$Ur9RnahxVF#`;xiWn9b+b)<$sSmHM`
zn<$t-r67->AFXyj)gG3t<cajI*Ht!+jwO4ca{BeP?fi$JSs<_Kb^VYH$)TmiC{w|~
zZ?r4QQL8^m?b^c42l7h8@FVZFb4<(2p23C+tIU+U%c7`HnkE3UgAw=o=k}$Z2-DGS
zS5D;eGH_2#QH~+nQYniDgvwsnXXylXvwu*5QF1Lx&6sQ!Fjya;=}Cdi(fB6K3p@v@
zb|73NBDIii#812r$aWb?FanzFsp$_b=I(D;X57Cp@2{9@z&^L(`Grv;X-qBGYpQLS
zXvJ*Q#Hoh?s<pjYVJvUcwvjS%WuBPWRtfxGxx@W3${$xJ76@nid<Asa_bT@sYMhe3
zo<jy&>p^<lq-?HRoW=8vo!w{Hw9Lxd{c{3B_cDE^i}UNY*4~)gk=ozXbTW2L(@Ao}
z_64=BAeJ*Um8!0a7WWPfl(TWmz5f!EK)E1?JYY;n0+M8Hf#6m8HLXbEm7xlIiauwB
zZV^IVq~o~^Im#FEqgnT(v&&&9a;&Gu)Z|<by@tHE>}&U_a>7(uq7HZ>8+mq^u_s&8
ztj+Uv3;|5MAES0+t&==3&V`1#A}qc|wMH~b_}hBVE)QG^d37$r%dXzfCx!?Zz1J*_
zZ|{;9D3xkUEeYJSI>lJaibA3L<Kfkx=*40wWyZ(9^=nKgq3*i};fWElquo)SKTlaP
zXea>GqM?>#{^zV%*x+U9QaLCstCYHSUPiecbyd6lVk$K=!2w=*S2HsuVdb!1)c)BJ
zJ@%?qDq;9(%GCrrKdW<u;SV#h2(y$&W!cx>n%11|Gd7zl7B!g;$s4|xcZQl8XQfBp
z^@-4DFL2T4N|ZpH@!&LOs8)8fR*m@dV?w>ETVX@?`Y<mzOVro(9fv_C*!tt%7I`fR
z1QTm74rEYL8N_-lDl>eH@7HQ-es$B_Sa~pe(s|QPj{d%D-LiD=zahOXuWsoW0-|v0
z9ExY~7o#eIw_O=*?_>uFC{{(+%w#7vQ7x3$&4!WVVm=gWb5b5(S*H&)c_y@GC3tY!
zIzaYCQ@%5Cmrg?W)3$80eR|26)cc7!eZkfzb?9$g0;cg9MoZLN%j@YuW>)|yuPSq6
z4a(eS;{&|TYbp0lw;wIDCD*EW-I@<9HFYkxU5e5lYnbIbUnH!tmf*Hl!?qcim^G7q
zY7pX$-;bJ?2C24W$QE4HGVAqSG{FT-yn?9Z^2}6@GjM8mjRuJFY+PnrGg*;UE0Wlt
z>SZpl9e8bR>PD&8k`~fc3VhFA7V4guTUSNqK|$7sbhjh$9fa&FLpiK8WBTLxt8RBG
zw45<#haCD@``gt(sFs;Gmu)ZabA>^k%pwD*MOb#3L+*YQnH;YVNYqSORw|ntLqJz_
zh2SuH58&R_RdSCIFd5l5wCGf;I4mA*(-^Fcip6WLS~VLf&(oK)wW<DE5NEBr%xt2X
z0|M${W=E>LL?~RNndf)Y00`WKzjDm+8n=zBod<3-%^3039B0~oQ5KnF*etzQav`iT
z<=E>S+G$zAZ5YQ(HepTgYmX)yDAp`|*j^Wibo>>8FCHEog)S-{M5)7NMOvF)iDrxD
zx?3$V>OQKcG@QWuUFOz?0x0x(2V#brr7dZPw#l_&5OPSL6Mv^VMTHQC&u<vWq_F3g
z+wVxVo2eF{#7KrixvBj|W%EdPPfRMI%$VB%nWMNlP~O();E*{9+Q4u4`Dl@W47n)t
zm5x_79(&e^w0APkY5u`z=mF^bbL>k`EBwZ^`Y9t^8G%Jrq@}U=cYlZ==_34>MSDnR
z9e7wt)s2(}!1nFuhNYN+GI3T60oh_oq`mbB#y2{e)^U^U7hSjU2D$z=(CHcCSy*(8
zHnhHLYASWEuWUt+UhwuRfQBH0sF7&Clp<QIrYgrnB|#?ybnZ~YA95v6X>!Y-%#O2s
zH=?HSLt<^bwdudUGIaCx?y<T<53EKb(i~IKTxcIAtHICPkr>PvBGHbdD;Nm$(6bk|
zYHt?fqn>_l<|9&EeeA_{UNAHKbBm-%me9Nue!9*m>EMgo%{sFM^-b8|hwmgmnja+}
z|D*~-0k{#5Y#G};G-1$(qes4z8myvfb#9n2V=-_zZl&FV|8<^brIWZN(F?Z_0-Eb?
z>{dVZ?<9Dh%Nsz7-!k>5sy0ffZsZpldrzJ+z{T~eX0MQ*QVLZPx+B7`qxF-K4+Y4(
z+8)&g!4Jq7$uFBYUOIW=^3|xlbYuPxlwYMDo5%Ts?6n<_?Y()mWr}wCYXhS<-Mb&m
zmwWlBl;!)G?${7fABw^p-<d*9&s<^aweirQQFoY5vV$U8ZWTvpL{e^Cf((#WP3o&F
zI`9)NdJ1~m{rS!p&P~%|yYD|Y)_yuwv)oE0eY2v%=PRd#Vp%{40o*ni-GMq)Z56$9
z?h>Y7RK@f7@|Gbs7S5Zf%x&D<mdpg(Tp1}jW7&tzWalZaRH2i$mXqmFRIIsxXQe1A
zWn#<IHX&K2Lvkpik5}mR2`9WNW@A8SZ+|@=&5Pn))IkKHU?CClWH(M^^Pra_C@H3A
zBt2Y`(ghJIOI;%ynuY|xwZ<evw#+!%te<4g%kk^JL-&1Y=+=$BpSUW82~6^3(^(LZ
zJ$x8UsYo>*IPCwm9iog}PEI8wz@hgMwxF0Zl_^>t+R4k^XPW>hW>7{fwR@L(Ya0UF
z=3V=o>xRqe;PsW!wL=goZbjBOwIrIjxZ#381A|SXLvw=Cp0~QF7;AQ`TTAk_M#sXX
zK#t+jht%U)zlw4D_OY!M$(ILJ)h#&4tA6k%j#p0D&?0k?bVV*S-yHxZ_hq|+ypnlW
z0uu?~q9D_$EFd~1YHZqML@QDRFR_LJo*-Fq&3GbL9qT56!!CIqg;HFb-56}I<$-n*
z3BX$6Iv!K7FRW4<9jL@z=rOpyBQ@Kp_}lThjQBPI_`(hy_pShC?{WaH?jy4V)z|Au
ztZB40g5n=QAfyH@ed%Ma4A#n<)h($w7vJ~A&e5uRh^O0mC;DNiMwIO~ukw5+jmj;f
z4$5IwmsOXW!M)p)=ZV1!pyD)N#2#ee9&jzvvwVkuW;<%^VS2QJpMoeOsE^;+CJn|@
zx^y>pxq?hmGNQ)A(w$Vxp2cMl)47d@R?s1g6~5de8oe?Op_2M2@A4lvBAluL?EAJF
zk6~$1>rOC#Y^|&^*8>00?8qZYd)FF><pCX~IsL;CqIqljUS&aIl=L)Fy-!~Vpw4V!
z=)O2rdnqZ)390yx0X@uW!1F5Sm-wi-zrNpjMJBFmT_3Tr-H5V1rirF-pI^z8IwQ62
zCtc7)xYFBWBe2rlt1_&O)PFPA9pTm8_?mz0H(WhrME=_j^lVjYn48FqS#quHb*%95
zwFdhpWBy?DD}oSMaThX^3YSY1z53}p?#T=u>@wE$ltZ9}d2I4~<Vd|(S>w$|Vdf^5
zn%GC09&bfu*Ba*&OM-CS9}rTire^S}dB(t3V=07Dz<R>*Oju13AeFqS25`+&mEGA8
zW>%Q>9pyKS=I5lkja7zaQ#0>kuaYRr1JBE+++I#gRNhv826Y6_1q&K7lSI~5R`K&f
zH*ZY<sNeyQ8=Nq=eW>#F0pCg|;F7d{L)-s}Vo$hGp>wbxNB!2sXZi!r;ysfpg)Y4d
zX`y>%o3n&l*T$PYTp%iuJEC7Z$k4kI3{r#lJ%<as9-X<Qg*po-G-Hg#Ehoed(aOp2
z9YO<n9jgxyiAo23dk1?-`E_OuOSWdOck^3bR<H=skGDXn7C%S<Qy*v&IGEbw$*F$5
zPT@YxeiB7o3R<&B_-SS>zc$1uHrnELx|4WN78|;EsmnY#ddCI2KXC;~>#lxh95`2M
z(HtNiywaf^VVznU%%<JJ=SXnVEUnP64%f2762_b}zLA|wgDd<4g5Tz`>86T8rso8|
z-JWn&F>iloJk(DHB~T>|O8L>I08SO>psHy$;WojRY$F>1@qicUoaD#mS$&TAw*ul(
z?(%U{kYilF7RG40PfxtWK^d#i=3oY0h7B*3I}ta$x-!Gyo7aOKl)dH$D>?Zs3^HPK
z{4{B4q3-?aFWXqH0_fHbTm^wuL><<hx<wEe&qq*pf=|#;?!8;6GXQy!N|QNu)VnNH
zSmicP0ztWY(_=~`XbXs+cmvSspA&s3VL3vS=3gARefsE;`A0bPSW5URA{8j^1;H^v
zW!rMi9ph*LP1)`)y>7-9nAeG}f5<{T@7TBhaKZOf)E7uaPyLj)B*5Q&N*5B<6Z*3u
z?18hu%@vcn950@tX-ul>kgr*)WF(V^%eqW-U~N3GuCv~fd-0>dO(HceZh#l;D&ffn
z*p#Ei7<wgOT{sRg9@zZpI$kMTBXqbye2{ae{a)Y+{iUrr$$r*kpm5}fzOg5G!BV!M
z>6llRy>GF0|I(p<N$b?xo!@@WPr_YK`SCUG&NY3v7SWIyZoc@`ur0v!C_TS=-rC54
zC>@DdE>pf(770}R8D|9Owf&e(s-2B6&Iy;CX@5yRrh=4Y4u?_8ucuNAKky#P<huJB
zD>{@T>Of7IEowd~7x>j=2S<&023_ZMlIfTO7*>xi13Gt%sI1IWQsa>eHL0X8@grgm
z@q$l$Zk#MkpT}(hNZ8BT_pr(O%WmTC%pB1blBe3VSS>22L@kR;d>qX&6Y57`#F4NY
z<u_2|d{CVj#j2h~^;~S}H1RwTr^heXGNwUh8d)h}Vxu4~BD~AK);i5xoC!U^3{h?P
z!g5Tk=yR0)bZS%=5Pr;*A8<E8Rb{dQIbP$NOna8O!CZ9(dxPf11Gd7ed-cIS)~Tvo
zPfm{p#mB6^MRglVV4IA|uFQ=j*{<6&z0NTT&3SXm01@VParee>s?B|Z0aEoBM9^s+
zZpXEhRUl*OgjC|^do^3aP|e!Ru^Yt!b1d8Xpi~H@*nd^`dezCI8mPUeDpUCEjP2{I
ze8&o1z6^?nvs_CBBoXXImwgcc9Qa7So0<@{3`Ca0WN6DIBBIoV@<v*RRow^4vX)9z
z8Qy^7#@dFKBA4k1RSg2mm0k&4m^KW*?|=_9*loh(o*A$Q{Bw%hGY=dC20N!QZLNYT
z-NoBk_N1#S!&9d%Nz3p<tLMrI0}N!k4k;Vo7G)N5VIv?czc>+>SLZ;LyZ38?PY4KC
zMab!qhWCZ*c=fIP8}BI-D5)kiXBbK1h1Dfu0dsHscE9ypj(p=KVLS7<;MHoc2dLSN
z^>Lt7CtjeLY{0>J1`#Y9@1M`M6LktPMb^qHTo?;(1E~ZP+hJuC)BRs~eyd^p*qyR{
zXT0}zF7&QEN<_wIYvzD#duPAEN|+Pthz_x$B>`=f_DoV_dVADTmx->tw<xMsmS7v#
ztaBN}Tv_<~3Zj${cs2`@Fi8i1nc^bm^;GSlqC71RRlpk^G8b?~y+WKVgcKCz?F8Ea
zY>2EyfMcCx3sU}8JZB<kIdR7etoV-TKQR%yv?7G~7uE3L`O;dT!=Q<(Vn;ygW)5ek
zT=nD6=NSThQT<xtenI(h1bNTgvfB6yy(XXI`+i9X3T>&dIK0UfI^b2UkZ{RxY+@`_
z|8`r-P$&D{8lE*TN5Xg=eh3kd-|g1HNoKmOqcSBWx|hS|>y^68OxkX$AW$;Tum}!y
zf`KPRKRAc43*2%GsbJ4dHRH{4h&c)vA88Y17QCeO;1mCZ7oIukqg8@;Tgc;i;B6Ws
zIhii}y5!wF@Fbs&ZY`&wuuvUVUt3eqs3e+=&*I#mN~mgr+8W9vlXrrdX)(4jAn#K#
zT(Z>6^!{VA5s1@IxzrSp+V5h+C`Yqfb>>vHq1HOV_Ul007zdF@wXG{0&7abKNaO``
zfHt7nJ0o`Qf?Fk0OHPLFx12!KoA#~vSAS`BZIVgo$Bb37*=qor9XF3M0L=iQuUrnO
z63z7jz4Rq`D)6{Rk4Dw%cJ4<rZ*H^dfq2w9UU6RH3$NYG8}mClU54pFrUhu?CGLct
zFVZK&+pv^k+L4CM{7f<}Zx3JeT~((2imy@YQG^$rAkol8Emxu^9Y2sPJ=vD(u=8f$
zX<PcIoVtFpU~T$bw!2!K!I#vw(Uh-2Z&xal^*Qgb11U{sjez3D;>z4kFcgOCj#@{~
z-G<uYZcdt>EO4WABPZDL#zW~#B}yW|5D$ONuXD6T-wg->!(KzRsar5p7ze+if=jK|
z6ZC0yw;uq|*BzNQZZMs)kz%tSk^FwlDv81a?prkWTU7SQVOS1Tq%felLoDf3gP_fc
zp;_ykK2D%Uqob52I$^dnwrT`<{{Dcm@BG)Jh}k7YoA#CA;vvshHeSVxLWkpa=eeoq
zkpD1u0~#+|cK%oP<_7NIp|XHmj_H^>sK>1nC8^Hrz5;}JQqv((8+K44NPA#u*}GA~
zLVIOFpjSCYYtI#}Tjm+Sg`p>9sqFOO@sh?w>Qz`TWSOd)Z9K;Vo*9YN$~7JCd0IP#
zX#<G#j+GwQvCzU2z?x<-S(6EY=%Qe3x<KAP$|Wstj{L^eeOP;b`)={)SYyuXs*~mJ
zH7K4>RVw9dCER8b<x^w)2>AhqXS{Me@X}NA5*)}g<6O-3K6+&uo~+FLT0AtY7=+#L
z4N<K;^R6@ugq-(9YO<U60Y0p1d+eJ1-C(T5;$!@x|6l>6e8^9Z<HNY@4PPYVWdx=6
zjOKI&hgp3D5Ks#h+(+qzpf-KHciQkO9O$rG<&5cUI6HubR-)dGv92i;d)4cbclD5E
z<YIuPkp$}7fn!6v@;d#Lj3tCkuXL?(ZqPONj$diX@lN(SFp<vL<keZz?Km4@U+~gU
z+vJ4T#hF0wqHQm2wJR5sd)m|-9EPhJ#R<5TYNNrYz40Sr@~q%5jA6$C-2A=Pq;v6{
zhfV-d?M{-neqpLB0`1mK5hFC<64CqmjftOaS*9nMwN<u`Zq-oR?ON*g(+=~h2jZGl
zFZbY+4b`<-bEiG~O9nG{G`KU1+6ky{;sgvTTdd$=!_!77M2&oE+4UrLMBKrPLq?{_
zr$W1#D5I3EWKh9J(c4s8`*?%Y9S-DWRT(m{CZc(=Edn{L>j~4blN+#IrfS}`FJwB-
z(ZF6}6t!^%5lF>*@K^T^xOQVBYs}CoL+XS^xpAt=5LKHXIcKW~&49ZlTH&tDHJ7Dm
ztJN_qCjteEgD86iMeZVjIzjS04IJOyPNH@*kluJ1hvb~Gw6$(c(H!ARZ_>G1eNG5l
z66Jt|2%9X7rj!ey%=W>PfT)h?{=Qo|FTl+*&Zi4Hw#81cn^@JV)>^3D@ddQVpcSF7
z&WVT8NBQq}Ht!v{GPKZruCwV#g6+}-QDp%sHt=zZ)HG$pg}$x1YM#3B^0%DhKU_|T
z?DmL=L(z4nn7p$gpn4#pgR|JN#@c-l@{J4w@;+Jk-G0DiAg{9}-<d|;ToJk#I6V>y
zVJF@VmgW((XXbjpY{^N7Y|G-MuO>^TWWg{?0u}Ty$J8LbQuFh@3gv^QlL#OzXIink
z17j6zAWwTjHB%3^XX)pvw7BLZPZH*Bz+7ndK$w{TG#Gos+JZct6}wgHKUhLB8bs?7
z_-mzpOXzA(2`-RwD;vD<P9-qj%SV+zFOf?4K3nYYv`ZLJzL)RML%wIC#mE+wCoFu}
z?V^ngTiCEZE7*I}r3YFOCo?ZtpWR^sNnk*fEu>q(vH3clR<MwZ6#VhH90BkWLj!Id
zRbF#nv2&q|)i!K1AcObsC~@24!K6wm#C5+Q5d^hc4fwqjVg@4=Ut_VVcvV@lMwDpL
zR42fT0G*WCn`a6K^LU2Z3aH{o@C4x%mltt}b76`xs@I2P07_3~L%4Txgjg5L{uxlC
z2k1*p6W&{q`EBodJxnpBP@uD8%Jx)@YEc_tU(Jp7O{Rk5-vAkW+S#Uhf>Nez!KJQj
z`}I+(el^`JfYoi}NCX(yR$f@!AyXW^QBcY<YuK`cY|dGR8b@U)V^(8P&hG?z0sxeS
z?RHFurH`o`4m)UahjpJV7VlEExxq^4S{v?|3*--`K~My5N@g@GtQtAI&C?3{$b#do
zM-2uV0{Ul5!?qx5*V6$@<Kvp^n5NX6`;8UdU;7g{g^r^ipY1rdtmxb6<9o90s3+Mx
zd8zSNPQ#lj{Q^xh77D+--4STTin*@sIE{#n45TfEyxwXP<@t)<f97<X`Qa)Z2PV0B
z^eelv6m_TKfwrC4^n+WhFH%5zEj)Hl&&Dw1NR$p6lBwRPYB;Avu}DdNu<raoW{UA(
zh)rvS?m(;K>`e~=6~Ewilat#zcmvmKW#_1%sr|uI4tKL*PF<|~7gh78stXB?1H_G0
zeU*H-X{?^_Q0LVJH+GV=e^4`>JpdS=KzxLQ=(jnxmTS`&UT|q3KNb6=zp`;@YGP2?
zqWF8|U_<m5lCwuL%YPX%B{Cam+;dJw_|!DE(g^5&v$=J8HY^7=P<G#bzTaf`GVZvn
zNJoyB$AMG_xzqvvJk#@_>g6(1?SHe<erJv$E)EZCQN9M(yxRr88{yUJV#u5Kyi`7;
z8)FHyU|QfMi0Nv(uAbJ#Rb=dWA#SLZ9@hjW9L$%}IiN>>*iDeIBeQsOVTOf@3BwmK
z+vKz!ED8`j-i1rSdxfjXdeAssevOrQJ=~3Ds>3FXPy-Z_`ylq4_bee;uoYrsIaQcn
zS_$Ap#EI^=u0LsWNBQOr>9ADxxJ>YdXYV^BeQjpLV`O;vyB^+*PyCue_KSBm+spfG
zZYpE1wWz`~(h<AUvO5yL(7~qkGvBC*Er^aw!f~HwzOx31yFQ7==jw|5j#VplemP4q
zcxFy<W9dp%lHlwulD~IBc*{4j4$69$=;n;VgbFslEjSdOXrV_wtTcb<GCz)E^OXp+
zces6=Y<^2Ay~>c-cxT7|!RL!A{wjCE_~i1KfYwU8&k!-Uz-x&r$|!OUSPMi|81N+?
zlSFOD2^{Y919-LWqhFpAh_Rt|dhY7V@TgdbW}fS4E$U86K(;NyGmu;S;}_mvv$#fs
z4w)`f;VqPeFywFqyZM~yKwW}aa|EfL_vuHd88u^lMr;h7Q~aH(mou+CHcksLHy+!z
z1ECWLgh7qP46UWl(i}?pywupZSQhH*VlYzl?fSzDL(S`%P&y-v&*v$Qy;8Yl>J#YT
z`m$j5=+D7e&d}z`be;xn<}mKHalZc%>Wwz?fVDP&w#O%g0YMs5verCBZI@n@3(+~v
z%C(nbXyAi$S}STy<-o@f%g=I(37m7klB$zZ^$C|UU(tTLs;lF@FZz*xP~WKVysvd*
z@IpeKStABuQ!_O1Zse#~SlR-e(I5tilyO}zhc6e+<yV~sTEDh0uL<wTdi0g&>q5eQ
z6ndllSTdq?9+~OBTP{34{r-(4b1=s%d-*&&@y+IS17@yj(SvGPon+%%+0LO{Nu%R2
zp2)QQ9KX90=Gu#eEe^uDdHvDe>Ht-)S<`g;C-tfRGq>Vpb6U$)u7jk#2_6Bqu$e3l
z<(lkgQd=x*uyw;L0H9c!aURW;Nb>o(#+z?|Nmc=Vl$jXrxfJpkbeW_N7(W~Olwwb*
z=$M5e#pqqF{{2F*LpFnQ>2R}EQipbdtlwo$GIg%Wc;Fwb9*1L_eNqheTKApJrPC6j
z_v_9h13Z&xZ!fcagJ#WYF>@NC+4+hJ*zSABSN$a*m`Ie)BJ_FF1Qu~C?rO4qy=>b*
zKo)Wo$8PFAB5EHwm8w0c6S0K*kmWI;#ls4;8<M)aNk6gIJSOy2^$2o;$vFeRk%1?1
zq6I9YcO+I9UN1@Vd&O;#9N@JXn14F}pwV7?O8aAcrFQ48yk81XiqXHgPe9P;!RcYJ
zwb2O0c!75-4{@?geG4Qn&pQkL(<`T%B<+>O)>Y}mFJzs=k>m~bw@`r|Yrnzs#*lKe
zvAo+ZrL-~LBW`O8rPyGM4_xa3z&5YuSy)${vEC4Mt3Ezt+Tk3BxA^u3agVxO&<1PI
znEN@$<!HfGfqu5$SsU!&DX;N9FWhvdc7woMvnYqrxjOQ{T=KpB?et`U%bif9s4zOc
zeAss`u<|;${g)G72eYU*Q&*08R@<Ayk;9%rp*OChsh8~#=p((7fwMPSvF^-4dJ>nk
z$2n0-%bI8o4+?19_9ir>Rh9?ZRB{X@P_VM1nXz<2xf$@(U1I^W5PHujNiW3CItC!~
zVMW#@FDTiui+*Z0&>PBeg_FO1T{5EI9iO7}dnm`0J)74O^vICZk(Ux{h-!~Zuz&4D
zZq`-AzsPxH+pRW??^*!5(ijnn+APOkTCn=mcSeeZPbFR(1UaCtbzdec8sG%b2~zZX
zd4bl5wmfKbEM!++P`7*H{OJ;{l9;uy6rZxR3#rC6F~_C2cezzlQUzXj`6IWT=H9(d
zH<9Q83LrjGw{CT1KKeDtN;!Eo7<XKcRU<mVVp#=8hgJve3!Aifm@tW5PoOC0c6t6{
zGh{JP<+dfs5f3$_*F!8M^Z=?w?Ns_hMNc!FokQauseSJoY8MCAssV3T8B~8WF3ZUD
z@CyeEWpU8GRC}+C_1PF&Sw5yF_YyFFXQWiXa*K+rkLhp3L{cg*G$JGfpkEiXB3<8^
z3rxtOANjEtjiC0-Y0b3r*Q7qmm9JG0qtxeP0%g%K`Hs^D^Zn()ju&LlUlW2SQfjP9
zV`i$?%9X8-pFo@?`jkR)#epVzh1EkWqx!W$4tOtw<3QT!rlg=lNLEVS=z(Zej_;^Z
z!bK~n58u`4S_Gze2Gc)eskw@+7g4g#sc+1bYw-scWM`WVdv~4*mgMX1YJO2dzW(M^
zI@!PSuo&X{E!Ml%JE)9d>tlSd$k<i^ymz@an(cNF>$4^qY!3Duu<b0oihIv&ST2M2
z)6Ayc+uFl}08h?Ue=s+VGX&9-GXMeRH{jV#M&40vrNOm;q_<YKWhzDtrGv3ooUv^O
z=og_BkPcL`gL#pKB<Q!RNJiGmT1{7dro0H7vu*RQBA~^Q<86vanr9MM5?g)x9j4FQ
zmZ9a{>D@P#;jWQvurjJ?m(bWaR<|e5%^yK3%|!HMz%rrjRWl;uQi#$yQ)HLB<wW0%
z78r;^K+!-+W@01|V=8eYt)ex!N^*e&FM`DP16PM+7Kmr)J_Y|Vzmk3W3ZuvSly|u%
z)N_n+0C)M~lzFlZG@3qT*Y}YGUz%x9ah*(Bx8DxZuDFUIaqcXi`276wA9dsaKO6t=
zw73aWP$!Ayd9=Fkynq<$6|E0R;eWFQi>8W-TjEu^L-*pcdU;oJ(;sE2Gg;-i*~4!z
z4W@1nMx@mHm+0+U^e{^W2LaXY0(tmxEUy&o+xzh5_!!C8nVpqWDFd`4ud*%Rd{wWm
zoJ2Z3n()-q`qk7_?<cVYm?1v<M(7pgl8EMf0<rfn103Wj(5yk4{;XPNh{KsT8z0>~
z)zWiRIXNm3XoR*B^2{+e4gK_>+D&4M7Ox~y1ii5%My=FLQ5_j`raXMp=hzPoYQiS<
zD%JKy)QShWRCV0b!$z=kp@h}z+}YC#9UJe=wWhN>nNz6__Tdf9<%FDTZ(qGD6}ONP
z;5PiYUD|~wO2Do6ZnL3X+q&!hR3Ma`PdTcJZD0i|$QiojHrxcAAbztRkb~=9k`<t9
z7m?wtI3eT&%Nwch=9Y<mD6C^gDYnmiakUDuNS9N_0`L^8&HR;_o4t+^<GHthQG5c-
zWVI_>8!gUPb~VeqzRp}yG{-S{EsEA;HWt)oiDcrQJUTuK#0l%JV>K(uqSXz^KJQ;z
z4G`!$4_Ro{_1AZjHM`%K;&L-zQDy;28M5zytiVts&=5!OTJn@BxVqefbbtrua53`s
zAf4nwgj5hfYW>bw>rf`eMDrwRx<4Ls_%H##$X>T0=ZL2HXGBxkogNOLL*`gh-Et@e
z>Xz)m;g~=*p^{IhEZW^b&vztxz_||)naNiM%K8dz1F~U)B|szH6A$L1$p9#%9{?-l
zo=ue!piwWV!G^jJe0oL80fAEE$yblk6N$!vTt@D3VDwT*XH#0ks`nWE!7z$o(?=#|
zyi_0w&=dXUgWg#CRRa|hi=32Xz@^h&0b)TH^=Mp%7~PCOBq3A#heHJ|v!FBos24Wv
zm)W#=z)s%O5L}pNyzIV{tZI6tP0h3`ry;A=9jWO#XaW=*!%+A4wkzK|35D^yGXd5Q
zXbRR`W;hSCpO|jg$RDej5A+B?rc>Ne7T1akoMaju?W$D<%Bsq)YSAe1IXxMz8~M(O
zDS=t0s%2MX$+v;cF%vpYY$_n8<iCpx{}WH`$UIO`@n%Fsp4g;*z>=5|0t&4(L^*{I
zAH<Ze`z<}h4V|I1w8G@_B`2qKFAZfLKF+;AOEj_ji(b^_ZWASXcJCm&s8ehYeR9Bd
zN8Vr!yhik`TXL|m;|6PDWI4~O_&Ib-IcLB+*^hb&y}N722Xnm&@Uj!^x0YGQ06~*6
zOXY15VrHoH*TY3A)nN>+s%ZrZ%o#3=96>`C;@o}nQXU4?pG!1Qj93HIkzO~!YSrj_
z-s^J~t8%^H4!=*9%WzqV!v<x^qeaQ3?+$JoOBkBhdNQBv2b4yN<Zq{^H@$HenQTTk
zwD1*l>{jmHWrLG+wIN+EGKI+D!vz%__{Y059s&c{iTf1{n?Y8<by-{%JABMO&Q}6k
zb*K$}CfDK!_qIO&{)Wm-mJ|Jvb63B~vh9PBCzX9oi?H26C@)zl<%cBPjg!dqA_dy}
zh?BC9ct`c0qRzVQ!v-eUc5*z~VXz5wK#V#i_x&FH{3nL1(CmAc=6b@n`X-qSTgdsM
zq8ZBG`?~k78;#1JEwyvtD8?B~2COm{mGI8tilXHeZo|)}0UxzMIAxN}CJoFn_d+>O
z_UBn>Iq(F7vFGrr$C?esd~HGP=qR(XF7PYSwt*VTOs>&V$fcg$50aS&YZG_-b$MSS
z5WBCeOB^E(l$9Y{ZTQY#&hjF9&o!zeGMCJTx|^T*)M@YqDbv7VNP34FccdFYyK`hx
zDv|<cUbeNtRy$VuwYTb67-o=Uf6PITeNrrQA$o2)r@*Q+;07zu&8|DpEO|YBo2S&Q
zr%*pwJx9rK{W_>_7t#~0KM#cmc1D!?gxoj-R(#a*s_8IqazcqQIssEfx&jI)FCtLO
zt(jjgkdE@nT3}y+>ZnK;mOh71%|jVV>HEUeI*HDIn+Gr}M<a7$Hs{A-R{{V83nke{
ze}st$s}fqqU2+R7e-)%?1f85)0b0qZzK9r-F}>^BD2+|7I#~j&F*LgQsD#wmSo|u2
z`;)9?fBX%GxM%aBCXSufRf?zzl-*OMtifxU?7<N2>9MN!1B#PSEr`pEFTz4weKm&?
z23!A%`_>i@sW*xNxL57FWk;8*%S!DFUQ`Rw%5tJlBU#tu^rpU|r~$>(4Jw5-l)aF3
zBIc4J2*YE(-yBe{nfYA?{Tr$!G7L1QWog`e9-6Oz_u^Q{?h`*hn2588I4zb(@LS<W
z{Hs9tJ$|j%bDaG8HoarVrMo-39@BelAjrHGpqpGz`rh%piqYpz%?jmvGW4U|D#fGH
z(iYanV#4*E^B3~{adLTu4WbHD9lOseag|<>-gQ_>bZ<ByrS{~yO5d+}1t0iIpZBai
zJ02-=`h8DH%P}`4A%UoE&kFi(Cq7Xo*%tSWf1!zm>`Y(mj7anBy8Bc@KSnY+>7=qL
z^nC}_=Zy{mZt0FGeeP3I?6qW$yQ`$VH|kqn`(2L&Yg@mhrj7^OFW-pfSLr=G?NB}O
z03gst%vG&Z(8AD?{BX9pOo<lQ#<R5GlaS5hII#5zn@N<SXoz3>ezwK6qLDDMlX1cL
zF3<NL&|a=uqIGwix~{A8yJLseY3i~D8M*;?cfNn@Uo$50>9k2>nmXWNid&0N*{({q
zCn-5SE*ViO*0KY|s30i8OoCK-8EV@oCQ(n7WU$YOMm>oLvIp|Gf>w3vL1;!Yhd9+o
zxifI=opB?Ch{=i@M>;c`<gm6$Hq;(STzTTuf#fz(UEfbCAT44gCN8sRS|rz9P(lZa
zJ9GQ%8*tICD4wZL_%lA^pGR%mDQs&?>4ID}#Tm`__npxsS?d`6eU5im#&38Wm?&(L
zMR!}rczMNG@BVtNTW-Q+QGKzS4FI)rSR*qTl404b5jCf2VLBs52x>|)#PmSq407td
zfEdpiLG#tBI=wkqc|XFr6-WuBd|Onykv6RA)-URf)S7(vUXX=dDF!sNA_^v5of~$x
z3W+nQ2Ff7@<*WWf<mq9%DPmTfs4n=^x$AT@#$`;l*8_^WJ;SYvWOk^8Py(AHMR|5o
zs?KWts~GV6SnZSuSDTg&`m^6`Z%<0rUVSUrIb$yL8JqB0)Sf*Vf1DitQD@kH{|sgg
zz)G-0;DaI$gn$l-=>J*q<hN|@_b>K)Im?xjZ6P4KiU9CIGQjJdiu_|K!{03N_a)6A
zjg|HDzB|8Z0c^eVv@1~Vq<BgKA8ND{?BXc$7c?Ay|7t&IAGdb_7XWcU6ZoK{U3pEl
zr$qnf7y9po`{(PX<#6xHLzM>rAEdV5GA_hP=})%sPhaPUUz|7Iz0VQ^S>9(E=lx58
z?2h`ozq#)}eg2>SA|yo!Xwe;>JW?P#cF_^U6V~xpw(y5_`r*a4acL=>cLd>D^c+DA
z&;B1hbblYT|FhHf_d)yd>iTno{M{|{_l@?u<@j?~@WXokebD|sXn*Ei|8|}K2j2bv
zw|MPu*ZKdl>+CY&23uWfIT-qX6+t$?t>vL&wQ}8WEy_AKMjz^)kf**qU>Vo<=>I;V
ze+lFr5{ppJ+dzWwT2Ih2&PwzDDl6J|*YKevno<Zv^nVB9f0h#b=Y{k4ZSud%jsJKR
z|8`sdd5Zpcoqo5ne;>5pEyrJ2F<^ke-_XKeTBqNw?B56NcgyjY7Vz(b_V<nUXQ}=F
z9xUBs7=mvX9-g)NS?I|pCvWG9%te24!E48?0YQ<DH{Q2I_UlK990Kpk`0zYx<Y@!q
z*S{WfPvf_M>1#jzAxOJNF62|xK9uUZ(32;@5#dCjCq_@Yp!4Ysr<Gk#tfIu<aTgu@
z%a00s_8kIO`a=jj#7Vj!jn?u@u3K;3DY>fdod<18o1O|L^e<VR`m@CLzbvphaq9_X
z$N%^V6ZYqE=D4z3PL|^9@hqqdcc6izxyXL7MCH#o3wrCZ^k4t#@oX;m{!JwR<T=)k
zH^{FR+{j{&%@s&CmHrl97c=fU>qqXDixlarev*0XuRdp&{EqK<{N+E!<Ku0%)6JC;
zKk0&+=XmV(!Pn|Q=qT~)ZJ_4QtMA|Z)ra6tY{A!a7yb~wcB~Y9;PQp)bUGNMP(I*q
zWnFl~>7s~+&x8x|^J~FBJIp@-Q{Vq2B<1Jtcssz4{{y_ez?M&bI`C{wNBP}KTUD@I
z-$4<rn@<Y1cE9C=*<YCD^v~CbFZ#YKz(0p_vJP1)LxyX%N>*V&M}y|qq;qHUN_(uG
z05Q6~1D@q}B4=-3%l`NuRha$*mg4b`E#hlBhQEG&QhS&$QsSI?B%d^|_fNO}a#^Kz
z=^qPv6<APLSD?Q%jq>$u+nz?rK#y$mBSD)ivVcs|y$d4BZsvZX_}`;@*83k|AWoLO
z<rQ&OZ-hdQ?6-9Nm|H-38W(oUN`B{GUhau2Ta_!DSfFy%Wx@+?N!CyeTFH>&2U<8j
zzn-4!07&J=Yl|@maj>oTr*Z=oZ9Bg{7ofK3b-W?jxATe<8dFAL1m_^GC8{VKcgVuR
z>1Zd$kUveyaPr4VS0P#Q?ZWFHnhot8nz9@hca3xRh*bKBbgaev8K3G8+$4RgNOb4Y
z)?(%EKyS>`Hck#c7>l~(+7K;avtnC1S2hslk6%t60Va#=2Bs<-tFagA>$hfyTq_3p
z<KlG9%lHh$y)V8|^S-$_1wpU|3dW)}`Yr4Z8NEGoG-xrxL4L^;Yh@r6>}#=f^uUj|
zl_iXeg1o8)ez|WNw4H95m4g10=J(%~d;V!xCR?O)7<kJv!_E{?0P@yuF|P_It5*h+
z0l(HvY0*w>mI-v_7z=EjwnMg1K>k=5F~Hafe!Ele$Ct>JOG}gGwor&#X-~TI{FD9i
zIPG~l2S?XX`Ds0;r15s@@h~=IjqiBw)jH7shig4o5wL14xvi?8-XWl+=21VCWLMt?
zkkzjtFQ@_f86SXg5%xidLGMOEoIVcV#(pAisc}~T9Pj6CfZk3(FVJ7|;pu+q4?JQX
zrvUa79-sE`Bt4A&VYlLApfTl44FgBxN9PqaJ#<x0&L#lI=Yv0iH8jcs6bMd5O6lO&
zYUZn`VS-@G^fiyJ{F<dECroLNY{REbvjAZQYxA!e0cNg%y!NHOln0~F3IIXkaDkw2
zJDggSN!PAhN7@uP>ONQ-39nZf@Hn6!HF|y0>iCb=a`@-(7nApNM8n?sRK7IRQ*qp;
z$~OHLDw{jEgIiw2kI@XC?01^|9G5Vre2e&(;o%?rA-{_wv6N&lwhA=yzW;Tr*S%t?
zN$zYG-$(+1?V<)S)FWsF_JpFa7I+S5XYQM!f1+Xuk^mdQ&gecse%ML(g3@q|__5h~
zVf@0Adwnhmak@9&sS0|ybh)cRDc!$3Z8omnI^a6&5dnD7(lP~&wO^@H25Q-9+hkJ#
zcEy2X*WT;{^m5I0s@Ar~7HC|1r*tAWQhUp!J*sB1FQrJWw}*cyaqVK0f_^M1hwz0Y
zB*=?&7RYj&MG+V|f=8PW#Hej(9l~iHcHxb%x7gObSOu7LO<)v%J=on#yaA)BLU6=e
zp}3?)4IP}vYZD&I6E76r`|+&){<8XyC572;8HCu=@0Sh_7-^BMP}cii{tFGU$yz9k
z3C?3zQ|en($>Q3a8Dop<or(o+OXFWgY{={2i4|a)SHM~e1bzV6?c%hQG%(O#*fgV1
z0I<&iApovoKj56+1Fj&8lQi~nn*e!ZwY=GN9+09h;H(ZLAkYSR&>pKCcA~(KUhjqQ
zn}J<<qNq%JR6cyvUqT^&=o?B^h;V3wUPumeXsJ=GWEaZi{|sMC*Q!5;#w4>-UK(0B
zUI*mY=Xo4we*CCEx&eOsS##2NzjJ8I@1*a^qfn{4w|YP7J<Er{@sq&W;Rh!6Af$Ti
ztE+C10e(z9Fh(tcx%b@oiv_98MX66yK%e5TK@_u8K7cI4w<Yox;r)G71i+}VJ303F
zfYC0>5qCfmpI<<8;k??nhdVw*9y<G+wngN+2Pg*$r>4Rv$O2&E+r4^z)yKf-s2Y)S
zV3txC(1s|Ssyh5&tf2F%9DVl(H<<#;Ycr#ttn*(zsy=w0j%VN$kDE}o=EA6rMFO9=
zLIBjop8!N0L4;hIA)N1XKZL+}?%Mnl^SAH%eNE!H034ARl_qQRaxrRKE{0tAjAP}#
zmch#3y{XLla<e~9KYyQ!=S~w$VJB+jS%Bi>bGscB8e&9GpGjJKiK~xCLrmn1kBO=S
z%!RPlcSrwCMEwK*@WU?1OMQ=qqW^j4UcCgc--JIHXfM4ybGhj`y|OL%<SdRc>;$xN
z?nYzrRZ&KJW7I~UZcVKjt=>8^muSZD4_n>DAvd-(&JKyVbZG*<&<UXB$ZoLP!?h1)
zUr)U4AXtCGEc>w{d@<tF9c~v1K;43ar<F9K+Tg3jBP7BG^yL)r7%}a&I)T;ZO)>JC
zzDezyPJrhkxC%^Igp&yXo5<<wo70?z#edBJ+gd>L-FpDtR7us%`%qnLc3IpvRN!qb
zNu$cm^_xH0U@E=W>UjMG<YKG~ZAU}zr|gy4AeB0KlV7E!pid4hR!{f`P4fdQ26NUh
z;rokL8RBBFWt0QY{}~A&MF1UwpD0L5(*4#e@mFydfvJa{Wqrq(!Ns*GAVQI!PJQ*L
z!W8F(G?1fvWUT;vqsK(B4Q4HGli$ygxH<rl+A_ME0Tf+B9Ehm|=<(d66D@=@{Q6yU
z3YJ?nSXgG{k72pzu04QjR|PtILFO?azI;^dhD$^Dy{@wip;-HZq4EzEagBT5cs6x0
z9yf3Jx}V;djX_A~5h(9=WV`x*l!KhywO(F_a(}X4`HWTPG;ytxv?1Ojs-==w^x>-V
z<gSs4C)g+45kg^f(TV)xNDE-h(rtn^;YPM{{qrcvns-OzW<GH%h70OP?{UZ4aynyf
z2b3;r0s2q5rv?6ER#AKJJ6EJf28dltl(^7&$73{?F0Yj%SmmdHp1uX3sic3}=fT(0
zjgJxQIS4*rROiXY89iV<;RjSVOa#o@v>3J~#vm+V1GY%NqrLprrzpW5hICjUI`V>p
zx57c-l0P0#*m9P!M(QWnbL0(AO9Y4Bd}i@?<5a8UP60B+L-UxXos?B;XhZ0x<ott?
zmp9Ag{MW<v@3kLqelM<l76De9A5IlQAeM2dKS|jzhDJ8}jGr8!RhNnQPc||H#8kL4
zg4X+D{lnx^E3|;ovuA8emz_4y3zM%tjl42I9Dr|*MlSTfSA9-X8mcDso)TY6F%G{D
zwy7qstdFIiYdg5CxlEZ|(%?QF?871K4fHDHJbZ}6H<*)jpm!=3H;0BGhY+RfJR|K4
zj;9D|*ViQ^cE30s{gxr<Qg&u0P{EmWT}ND-@Fkox{%LB;AyMq4S6(9r0Y|aDvh)x4
z1d39<7kW}5I}td}nP{I!x@+ehiHFl(9sR2t=JO9ej^X$C8xZMuDWqsG?nU6NE&$A3
zC0jUi;*x;r>d=vJ@t<2Ym#?vkMS6b9Gfg2mAcEC^0J9!bKHLx4Sc^&DoA*w`->cWF
zdag;bI8SrSk<|m9e`1sjFa%vP{;ih++)?L+ck*Zypkjwn_#&pv2g$_XUm_tpHBU?*
zHv(F%;2qN#N~b;+bTxJ8ZsJ0e{x|bv`{e8vnC7(#!20o5q*$=tTh}%nbJ3CnEnCtq
z57VmK3DVEgH*$tEqVZGD7ub&~C)74|w}WNiw`c_}(%YIk6;qkmdtV|G=i0W{$Eb4Q
z_Hv}E!(K`c%Q8ptM@QZS=I=qgV+;b(*@Zge17#d*!nS-vsbo?3>19kxwNg}5dXPK^
z8>O=k-?3}GXr+_7{2`q{P?EPT`m9eE%hz=KbkE26kXXzi5`^u@)^#L0=Dw2ot9!5{
zzm-&Cw)Oxi%!Ll>IOyxkUTh2p#<AkWgMpCv$y_-Z&#vBb?nQw1?5vMua4!({hr*r$
zLuJh?fDWZ*T9|sl)!o2$CDfmrN;<GL=>#5f3w)fOn>Abmboon&ecJb9N~FGTnpi8l
z8`X)LcvM^lZ#<@32Wsiux<hz3=SPbya_AOTXJ;#!eoh0>vOO7Mb-I;+P%AM2!FH*b
zsN{|CAgtuasK7$kFIz&NbX*d!%+bE5xBsh>-zU(AEDd=1o7<~m*vAku+-Wf&O3;Ge
zAo!c1Q$!&(ymGgL=ZYireg!p4M-bq9V|9eJOY3?*O;J;;<ZKt$JU>mfd9v#Y81WiP
zk3Q)?)=|pVVx=cOU!(;#W{>m=1ZS<Wr&K4yAwzK8#eilaNx;BsIjdmus`DdQraH1i
zE`dAb`tZiUhy-HhNfTp*zUj$%vam=WJ|LtF8?9pY@qQqDt;qW99!@Xk3s=I6&0Yj{
zYj>>9U*4@_Tf3$3J!3t-0}V)xNW{xqneJ2p0(R@SKjW0wAMV(@3%Iph7sI(Q(dQ=L
z_^jUsROje!z_(S%meTO^c-giU;uZi*($@i7+CEN{?(*SrZOagl^u|&cG|mZ#^e2iq
z;g=$Wo&?TU%CM&p8+R&zJMROKE||bE=L-Nm204$4k+2Ch?H|K{^MPEzz@9j&Ckj;p
zeS}g%00KwXS(}rDgYXA5qOLAj+p~IAXrwF3K2Q6US8<W*aTXrvRFbM)`9j}R7q6jD
zDOBHFV+l*~$7UO!&`w<}<kags_wZ@&qduC$3j$$pSyB!bs~9xpFAP9h!x`F|Ud#IJ
z#Ld0flQ3!V1w@+ySBZA-afX0)LEt%@wk_wQM3iF*S$M3K`BC))Eb4qwwLRNxZE8kU
zXv~PcFg&8=?qwd-12l*eb;9*%K~(MKG|YxYZ$LdmkSyWbIDWGdL7cXt8VtZolkBCA
z4Kj*Pd9EI)<9$j`OlwB$vn0Bh6#Yy7_dkN{|NO7z{CAG!vn}|JA80`4Hn%!$A513}
zPyk`p)E!|Y+xyqonk<H4V{1Uy;QoC4I>qN5uyw!|+&RaQ@E_c-z4*-d^>TkW(ZT^Y
zdjdtQMFAHfZcir+@Jv$kgiUyJ8M(m75kxp7iqHg7p6}7smKFs5oo0ZK8la~z_GL}%
zM?17WC^B1%((>Avy7f%{f$V%#Q-gc<TD7@8Y1ZeWo3GDcV$^WF*WHzs6<XUhxj<~u
zPeikBC)$8A8=4_3Z@AT`TZ`=4nA-e_CR&~EVzCDlW;RdImY=ct*^fLscIn<5?o&+3
zZ1y#?)MQC7#Ky=k->%}oT53}>zg)i7mDIlL6%4!kRcD2;&{qZ6bmtTew@Lf3>9O)P
ztF}mbe*KyL69FtPz(kwxdC|)HsA@!vT(r0#fS+0gY2)`lRlya?b1;(m2S2*FdS|e$
z6ZS{#2jSp-E6IC*%A=USVE$D~ao9h=NVV^20bgF{sLm#{E!=@UDtze*oI`a8H%6>?
zy)}JukAlnzlaA3WTH63RPxk_H8Gh$Hf$(9A3lG3n#c$vnZ01%tIZ?BorkWlj&IIpJ
z=L`X(jV2dEteO;!fH@!5m9}JOA`Q-{PODWs${l$f$P!bO2ZNSdvRdo|=LEO1@9kZu
zxPG@y2P~}tVUzL`yVKm1bFaGhUv-T8GHo=Gu3!6tD<01Hka4Nacy-9XY(24{D{M1k
ztr(D0b{EsS#3|`;e%(pbkdmDJ^z)~uUpM8~W({fUcYE(dNSralX|3y|qzJ*;IX2Jt
zkLkyF0=LM*Y660}GV2ZqSZ+>XwFUi#R-`|1hC90Q_nftdmnHcv7gC>iis@QtsK9!x
z{o|CI7FX+d@3{`5<RVW#Dk^h;pbJ_m{NuJ;s&E{EZ4kX?xAbGO`{UR8FAI_UZXuxW
z76K&nAD<lvee}QBd(Wt-(xq*9L=goM6cIrQDk4EZvVa7|L=y$N2~ARxP0mPG7(r2x
z)a0D$00=ZWisUFc2gx)+a%jSP_nhaPan9q+nrD4$eZS_<tR86Gd)Kb2yXvZ{tCB){
z0S&eFY^;+{tFS9UVI1~_h!VPO<;7DH_wn*A_;F>O0?V`u-5EW=qQc)&DNjAXd1I6i
ztngjLb6sRYy>bt_n(k7f@=Hi6(W}**702i$^nz_C%ph@-h-Q_K6%!)5!rC!1MtkKu
zD`o3VD~mNC+geQmgJfMR`CW=z(650jW_koI<zl3peovY6`ez2SvXMY5uwnffSUnA1
zxivWdd;v>p;iYY=qwiD)UfF7gVBDT<zL%Hg@W+JwwFl8r3IU2SVXug|`9gU@4Vemp
zffUZ6nSfLXzq~h&85V4<L(isqdhW$p?;0ExMyQnw=;Ry}evabuKMm|oXQLsz#`AFd
z;8|)A*RP&K^Bu<TsTMd)$KdU^(g=HcOBX6~=6$2v>>86reD&J)v(vf|UPmLRdIt%-
z)mm19VGat{zsup#n_GyyN9|gVD~{wIW@~utU$;9F*It{m`mE~Dl<gMWrCvDv>D1ub
zBpF@+OncpstN0<w`_cD<Ok)3NafHn6LeF6R>P>&?`zz(@v}zYN{6@^~ofx8Zl_9;%
z>G!;5%ZoAF&+ip`e=Yj0{;>zj)DKS3riOR8`q~GVt;ZOJ4YVrqH?lpW@tE~!0NgnO
zb~CQ93(JSwe_SfsgaQlMt+?cJnrbsyy`h<znYMt3A(ACnA{J~r98oht!LU(_{hwq2
zed-IZ2ZXI90U51AOKy--1)-qm!Sn_In{g1Sss~oUYI#5*Op(;rdmHBFR#pbkEwGN>
zSF(Q_Aks~MH0fq@7<ULr(3`>J#6e%Df9-oZIk4saz#U#-9#rChk8-Dc=nvLz|C%_6
zGrOrpDK`XYWjMepyblAtf&D<qtODk7V6yWTfEY#UH+%&&QV9|+8-b^3*yhqsM@WD`
z*4P7qK=9km$a|*pNMucR%SZd<YT-<8zzZ#rSvsXnfF#mvZ};_&>Dn&El{S53TN`~=
zCtzYiDbJefS&Ik8-r(A@6du{6LCH?rp01W@Ih@+`Y-~tXZE>tL;0ab;$Zr+V*j$jJ
znW95~LkgGL!lY|ac6)N6q6>#IXp_yDy<B>0=dO@x)W!4?D#@2qT}XlH_dS(S<-TIt
z*KEG>Wz7mc!SLXknD@?8FlHp8YD@c?0ex*lHaxs3>w}?Pg-`Y9ooQI+MLoX0O~;g#
z5a%IS<04jWiutj!BKjEuiuq=F0__Kn!2jJ5jZmRuUeHlks6O(&s_aR$J-O@FV$kwP
zX){1pw2kdE;Kyabu3&*@NiyZv%=)sBYzk3#N?Qs}2AKAsZj?GM1;6L5=<kx)_`+MU
zbDyVlG4~Z72lmaM_!JX6S?3=D5S=gfqB4qYe2E3#-q2E~72)dJSbL;;SI0okvzmPw
zkG=VuqU$XJ2Ly%(Xx;J>&v?ooQ+jJU_GNt}EU6O(brurWh6XAlb=xI*v&~i-p9H~8
zc2G;Y!zm%!eQO^AYx<VQc&J+FEdq1~%HHp%4^&RIGs^PswDZc3*~Mld!;pB=m?5WL
z@mx`d!udRJXkNjsprb>9uNw#3Q_-o<p8LPDvo|^1f(CPob|$GX(mXG5pRxWr-nl9i
z)tFqrTXCz#xpO9TBv;bNH}vDX5CfD@m?kU&UkS^QgJ(F4w&My5HP(mYBiY`4nohO+
zoX9)ZF{z3nhhN7);DeS3_W<pVxtCuTVE7QH2uXLJm-tb~A+tzH{_X1nQ3dra^WFk0
zI4as9ur~F1^7Q9F_XK}*3`T0N^pS;cZfHz@Q|qkejD4i27yukDRM&0wVI+U;cB1g?
z27|CUJKzAV90q%}R6adlwxaI)1OnDr;?!hY*8?sE#3s812M5Pm)p4qb1sFq7F5LGl
zqv2df;u>M4GJ0}QO26tCRhuTJ<ZM}4*|gwZVCDNGS{!(={A_at9|0oP=9bzqgoXV=
zx2&$`fdg1v`0<uTPF0KS?2P&R{5=1Q4wgtkgi02<mR2f0Gd(VtE34@Ka|45ebObFg
zwk*}IbG#ocR-TrsJNaX*KE+Lax*AnxGUw5KR-pLfcgA@MgNV!~wHrM5e6(mIIlqK8
zJ2W}rXPQf!-SpPJCqPM2cG$37KBM$uae|J(R)FJd^T6g1p}kA0a&zD2t>;)=^HzSj
zZ9VUG`J-aW0OY7e`{u{5{;8!R4U_AVeD3Wr*2sMHpt7#sj(<ykS^q}4-C(TBjSN(8
zGVCp4cT}NsnEZKp$F9qOF=^EDzEKLjr#$Y_nqfUxYr%Sb47NGd@eOAuCU~XYtNmy<
zwPolNB%iZ~U^050@9EdWi8d3_!h2+9ZL^I&Q?a&V*%c<01=I7kvLS7Ut0k+eP4xVh
zn^(HF59zmm6{Ng#wT00O`i#U@>_?IO@$LUXORCP@l+FR`ENL*dHey$*IcL?*Ub(|^
zS=c<#VyHm&`SYaA2gty{@hjg-u(Ley0{N|#F<t<^pVq8}DCw5F;4+{0Bt4|a)Gp4&
zZ+cP9`7R6IO+_Z=FQ@?*ecVfN>m^n<b^C2VfN&4)+vMbuOq_04XQ$!r+H`PitVLX+
zX-}0E)JgY2z4>UF=0acg%A)Zf!r`@ZL|Y!!<$@umQAy^yDCod;bkUX*eV!ZGF%3^d
z4R`O|5^Y1BO`W)geIe9EF66H(*?Og~A}D?2D)JlW6PRLw_U0s4nx2fNx46!AT(f!*
zlu*!c0v}bW(UZAoOop~U+VsREbYIj{hRDd$3Emx5bJTkFCOHmAqDbIZy>V4ow=U*u
zU(E6uNYC4B){o3b%&PO8ttf`gRX_T*k-c4GZDy|T8&+I9DNERgW6k*rM-fY^riDT9
zp~ImT&3KcwJt-se&Rceiscj-pRJpW;+`H~O+kJIP%a)53?o40WWjmAFzSGzg$?wr>
zH4`Bq-HV?UY1PK5^d2m^M)+xoJwdxl2zX)^8|C@7-L^MMTZ(IUz4f6s3$_+Ny1gI6
zng5FEUgxqCUoz@E@g)yebA}_n{;?u^AyZoR1X@rnbpi;vjU^-;Us1a8*i*WZDf=oX
z<wen<ntEN%o89IUD|^<pO0c;XS)OASHKOr4^Nni_!&F9(_au+3XUpy3HLCS$W{Xl;
z)oE1f`-@{v0ex*Wro!QeOT1zIbC(3zcBM-;;sqY%-wzwfXMjH1I_9cA2=8NlxlenZ
zmi9&@?8pw5fnU)vJE#}BojSo?ikMrR4zUb<iPjs^6Nfe1dAiSwbc)XN&Ppsxltjm9
z6~?;1d+vHe18SbHed)iR`p^D1;R88XcV3Wl0<9f$3RYaz@dsHLK@wQKpyaU736z%_
z+LovH+X!C4fz6%LvK~&0$uCh0@xzgvH8M77By09;qHQu&$0c6T!3OQ~A`0kN&cG19
zC&NZ{_sd&G3Obn|bSkT?LmZ~El1m`oUlxvSe~p!LWNmzVLzU#S3h;$xKJ}3H868{y
zKIMMj-eESYon}ue#*|}dF6=6ukmS=OtTJ*WfA2dPOj(}GeyQn6L1`<#67LjfrWI$*
zsVqu`87+kR@J8N}?L`axnuaXRUsF%l;*PC(ZxO8z{q)uL+27R=eomr>d?sqhHH~Q!
z8Id3TM<~bZU~(A8;H+$(;UY@&*)FZH+H@JBfcADLM2Ue1rCAZI_A#5)_uJ#PAm0KZ
zeH?J658&4?v-X}kb&HXK)<tdw$1BkKYeCGt^p50OwQ#Lc&r+enCY4leuc4e*hZ6K0
zGm)m6vuaz`il#6hOyTlV@bIQ}>cUVg3D2ec5Q8PF+&HNb@((>&Wd-2DDHxuXm4cw9
zFC6{1gBA&5(9%l`T4<^{=`NN0n2ILIpI&TKq@`>PRin76y{T5urGU%`j^f&Wcjg#n
zIrLo?HGRmli+^yOKSqB4{fp4^#A{vj`_pSRD~4ds`@?p3$j|49m1tcrP8#6&71h)&
z-cG3bq5=KP`7nIjgXH>;xA@;}A%E0v=~FOgR~qU+dwZcVXBrzC#mw7Nj&WH~IAH}U
z?cv^PgM#v@t)n91`**&bXnI)t<i1+*_2pt`{lBR*$4-1c$D%Q<@bS+c^F;=v1}b>s
z8dO>a%8-@xcPmvauU<J3<%a>rdFLF)_I2VPj)bOA>42$*xW#<_P5Ha>1Lrf&>*yw7
zj=uhP?)vBcu&R`ptHA!m{uQN(hYcqKNf28C5|#g)mhz9H{;L;3&IYU~nhxmKO)n_V
zZTlaUQ#z8SA=rE%JXUum?mZdj0SPi`^2Vbixg+oIC;nT3{`9~O%^}|U_@CUm3X9N9
z)lR#!p^YY!iI8+@H#LmfTR*PY5R=}&eT6H=zv(Ur5PxPTE#!+pcW*Uv<h9p(Bbi=b
zdKV1&IxW}!Yb3{y4&zVnpZJS&L?I1%{fV+_zP{BMb}%si0Nu1m9v(pUJ~vI1PfYhY
zYl*#lgytVf6#n9&s9%$uK$mfo|H-SkcqcG~yHWI4bkoMQ$KPuZ8Jv8ay3dnOK_7nS
z=M(yy2Jl*ih4>`bfR6smX*wUnY9oVVuWEK@aju&&%2Hjr{xq0cCjbHs%4csO{hL~q
z(EZzKW&iV6{`iBmsbX5n?3Fvu<HE@#+(=fRep0#0x%^$>mH3a!_gCJEMY-+-a364G
zpt6eKGWv5r!b7jGL!{B_h$7DGH}P*>ESU-niN4~k4+^{yL(2x8zioDR?*Dd`7k_dU
z6_&@gtO7UTXP<-_YGx1gdbFM6sFtCFu{4SCX(h3;acT)dXidr=X&xp2eMchwl>!{~
z#t?u?ywgWgoEiB+V|0hp)c(x{@R$1f!{7Ypd*`@`Z+`9PI{cq+{p>IQ_s^ss5O1>J
z?$6)w|Nj18zDw$_zv(^IPxbyU|MCxA3jez5gM6a5X_on!`2LR%3C#W<k^Mx(e<{X)
zMD~~B`I%|_BeH))_A|XW^^Y(6zj~j4MD~9+rGG^B|4C$-DPGX6%RNR6e@LAEuTe`V
z-)k2Kvx|6|0cRuxdH(&TWa_~;5M03m|2qWyKi}-L)6^L9_t_1KY#P(|HB|tTHq`Y8
z^ysIq=PxcJop>TcW7^;Ur`gtDWtu+=yRT^xVg2c=0M>ty(?sfH`8V^JpJgJi-(Cc{
zy@m77bMT*C{V#sTl0-^OFqnQC`v2_efAzDsFNg_hnD0L#`wNNxQFZ<i*&pTc=g`o9
zzW0yF{v(RNA+6uO@{h>=5!p|5<sbL|SLfM3BK!X-$Vj+w+HiL2iSf*_#-^s=#l;vE
zLAx}+Ur2oASj5C2&!0bM<>7%PB_~1b85%h<bB%@+?b^j~D7okN-<&U(68TqGDNE;x
zT+C6NQhWYkv?LcCLhx*ZAHBP3!}s+(SnE~zDB{Tf9D?U=bfKs1HH(q5R<VtYB<=MM
zrv$p6>ww>V5VMIq{L{!NA@r1?#%t7v4=pPE@U(ZokOZ+SXKBZT=8?c|^uVwKERBts
zGmh`x(WW?uoV?*+w(R{|xGeqUbc(UDT+}A|R>7LhSC#5LXvD>Np1bflsQ-oog@l<^
z`2?o8Q2aLe&u@#Ii&)42{Qy5HWDqX^hG<SfkzNm<`<)6s|GKDO<K4%PTtNfpF`Va&
zExrEd8(Zlnnov}eW9>ju1bgNsX4QlqcJ7Io&v)Sn&Gp~@TS!t)?|qW4?#A5t#h*j_
z(tM`?IO_9L1oyYN`a#hziKtV0ENQ;d92eL#o1p*m?yjq)!yIJgGnC135&ZwEO-!7=
za{B58cm@m70}@TqJ_DcbEU?^i&AXjV3hqZc-tOlCRl+zCQjPpM%1^w9b38dxqC%fd
z8aAk<69mawSwq9;GBP^vILv6DAQ7E+Wi@jOo=P!C#(bE%R&*_#Xz*v_rPYcbyn|$L
z^FgC!)!dLZB0<znZB30q<(ZmS142i#nrNT1*420#EJ8$;7pTjC%yjH{+tVmu41L@&
zB2nt$*2~q!KTkKtb%;8}^`|<;;zimiz<)y^Z^M23wwG)q1Iei?7v8>qkKD1fd3ohE
ziRRE@5GJ<yW7W;spmWmWPpIE!jzXTBGScvUj0z6oo+rz_ZY+6&FKDO#g)BQ=>?{_7
zrf9Dth_;Iell{D8nb1#60Iq|q=}$6~YZ@#!gcNe~?5@4^kp~4g2wK|SK9p6BT~8~$
zy^Ml`8mUAYbOoJDPAtZ;TL7t+-f&%U@q8gzqH_Elc1-jdlY!F0G11OLyU{(RGnpz^
zg_Vvv7e42$dbF+kx8D1CCdBSYOeNl)26aYcoqmrWEtlbZXX?y5F{kBQIMW_m=aOLj
zXsJ^+=pU{b&H=M;wk>=?>sa3#=~c1+r7IAKzNf9J?1&$M<yF-=c4fX#_diKF*g{aO
z@XGL>ENFTEN-gEu#SRGc6K-f$^sPQL?(UTbzq~$0*C0E@O(xt5wBz7B2NLa=dL^>Q
z1bt(Q5yROE4EEQfN6Kfqnyp&jPlRco|GBklgUU*A)d>e03^~asCpj?<+>5W*@W*Ky
zx0a6U(wsk^a?ksu3V5JbhvTuJ{q<3t+nQ{bgvb8N`LD^3zXzTlI|2hGQz;>e{M$<-
zrG;mhCCfBs14BbuhYGF2fm9%%X>YB(FHXYMa3I$xYjQ&jtAz{h?=L%|;_jokuzt+F
z{ljGu#q%^Y(||fZxTvUzWQ1>cox)z=<nKkOP?y&jWaX2+DY}F9b3;k*zg*d$UNJoW
zy5^R2&cbcpUkV>5e4x1Clw*o7h|R6tOXdDbZX;yXnegHLqwkZ`hH`betLMkIa_`=h
z&EZsHI(zMvGzWEuHFPElVVq{8&>oht!|ChLn<^@O;jFgDz0l6Z&v|dw+t_1gX9{Oh
z*E1u8ep;YRRVC)k4%h$H3WpN57@VU2{uKd3smX%*3ZD6)!tCyBJ*mEyj~n_(kGF}S
zE2{1jXaeO2bCKGQsu}e>c2kK{QPm^GTT0?ff}*=qA=6=S%X2#DCy3)@XG4MLBj-O{
z5mm7)-|Qt(;Qn7?fgGb$ozFf_rZ>WL?Xb)@C1&%zPt^p-z8#9xUlFb=7m)giYiw>O
z(H?uX^wE?)r(Ln}^p*a#bi)<JYZ_47sbR3(>}>KY*j)2qv33$#IHX^!p0O_SZRpG|
zPw!aol0JpxQM6xd6Hm5}iyn&#Z%cpv^I~wQBGDLniBN<p>q&Hss!pz<Y}TvxASO(d
zkXe}hd}r-#_tjcD+W{kI&uGlq4F*i^lF;xL7@2)C+ZMZ&RkJq;B;^c78e6aEzMLR+
zo=cQrHdK(64FWr#+OCL$N$`W7mKd5gyxZ)Zg5MoQz};h|V#tb%DF{+7tl`536pQHx
zZV0%UhnbByYH1dYgd%Tfn;+D{6dFF*%R4x6u0cNPmMDGW3G`ViDW`|Oygq-iLADSy
z7{{?aoj!jfYry%2+ji9u5(r>C<bpYGB?|=MI59xJrOQr{ybfQ_{r=(Z@t<qML!vey
zK?lq?`#auHhOJE1^ngfBN5=w;UgfCTGZ)ZLZZuZmo>u9A?_Fz`I(nk59dmR#0O$tH
z49s4IW-j6^hJ?XkxII*40se)NQm1gR3Ga^noDb#YDKH!&)RP^?4WE$`cHgrX1#`pu
z1Ya|Q)+nL1L9=XPyWNW?D3?tc=7ND@yY%jir#13Rfd3*C(UmqGWvn|p%OL;zP^@$$
z-FJqx&hMcG`}ftgY9a8VtLPiis)nrr_5(p~(x{tXAkihXDK?ug-@Oaq@8g~O7|FHO
zlr}=If>w!%87>PB{rH||?uM<uUcn9Mp;q{<)6+@Qdfc3Hn_v314Hg41i&r!Yxpczd
zvva<agWa;X+ov3uV4rj~O9gZ;TFQrYe=tWt)4lRDpt|QL4Hn@Sc6#Ev7MA97ZJbKf
zGO4*XQDGrllo%>l-PBT<Ej%iPxuI=4&ZYHauaFGRzt?3>Y^C2*`Z<<>liZQlRfy?h
z)tK(q2fZGCTEsWL<rbo<a)U3?s~m2uE5I*cG~ma&epi7(C=fzRL$P5VU0@!P(t|f#
zDxo}o+3cVcWoaRrrel_=lB)7LYtqQNuG7X?!)>UnvW(;LQLQ{Nd~163>VTkIEF8|%
zo6gaCEXjI&jUp-3m@bYx#_7@gU6D#5-dLqt%<roCgOg{EB}M_*%OE65uc5~b7TF|s
zqt$u)T3{HBtBm4~8@}knJv{GxN20gqaL^S@XO-r36Vku-V0(;L#^=mx=@f3_3~U4p
zBk<eLbp+OggoI3kX?)P}zUmII%&Gz73-<&3Llt?eQBNYd)_>0m?v#-*1VZQ?ZQ??5
zxSr0V88MwS{A`u%^S#;oQ9c-QhMdl-wsEW8rnqiQV0dMYyU@IYsZOK#7R}3rF?`5$
z=4rEoSf%Y3x9T+}60HYy%{)XtN^U$n6V9Y3lO<m4*dTXUes#bl%^^4vNs#GhynM4s
zhEC9yl7F5)+1N6yk-|w9_V!AM4?1pcRD<*4ZGD`xlFxqpbeXe~ah9lAPNsUen5|+d
zsyJYPQQcqT{F?LP<dzwni&|u-Gi@u&c_cpW#*v5(7SkVfvBPR*PV}Rb*)3X3RaD=j
zoF?>zNf0yLCb>b2;cOX()QE<pwFQd!R9dC&4R=vRDTjtTr>CYi2PUpGWZNB`5iN7=
z%bO0noD~{zY2~Qml=Icc>5R7lP$~V42E5*U@Onpss4;^D7QULzS~xd7MfJcpl(WNS
z%OQHysi3dVXkx$*Pe0t7#R{S*6N*{wLX&p1lvH?G+w`TMdW2IKu*4d89I-fmjZY(0
zwH!<%OizB463*-G19S3&M<+;6!<Ghda)J@56VY2sLvrsga<hsJ63D0uEJrv!4|mfI
zwZ`~ezrDM;$7Q~I)6RMl%npQrVdcif&E*le4;3@h-3R$4p}LRZwSKe*$1=5#ug_hQ
zaLFf5AQ?Zf9>4Xm>x)?qB>R&={n<>-ytE@*t))!BGjQlW>jR_ja?Y3s>@HlJ_&z5l
z$B|xgBbN~*mwFR8tfwLj0)l|I(PAb)ebBlNnzeIXw=L}?V&TQM(+~QDg@m95R%4dS
zSTfM>%MK<n_$E<mna?@3=M^*7TN9|I$oJyFdH>$f$SAVund9^=p>FA@(L(3-na%<W
zxWFuRp}-0SW46JI-^0+_n}K?_Au?(VezrcD_gf#;Xgb!SmFsc569KEcy7iJG2-m1H
zJJ&c2Up0Wn@YrZ*@Zqe`ceQc|nsakk|IMPD_=RpxKm8uNv8<4>zQt{&W^N53=dV2U
zhh4@;Maq{M0$gUku@$3UARcChvth%F(NrThyLa~{QfGOsIEA>FP?lFrV@76sb`R|?
zKM4=3;LXcv?@^CcZ=aBh(a9RBuI8kKO6*j!4wQ&EB{Vw+MbU0XM!oB!GCqenKTzPF
zzSv(3Z_<QjMT?kCP2CDwiY?u0fZ=OUe7*7S;5c)wYug`EqB9N#9WEQ?K{eBpp#JH)
zBU+thh-8w3ayeEBD!bDcSTtzoo_3U19K;9rn2AJ?t1<_;)ppHmO{4l^k7FvihQeoe
z?AjNuZ4cY1#u<>?cAULLjp2ODU~mqk4;1~CE67cK<VkstLqwP+CnYS_qmCmkoIA#D
zy;Ro2bChFQAFAmrtOIwyXi-w|=5+gXA*^lkMzQ6@UHF|@vG_i`qX&;}cFmoi$GoTX
zh{=HrF*yigz$}3HrfjwDvT-kiN@q^+NZAQ={<q+`JP<z;1ds4wyp+Y8j7s?4B~O!%
zx|{KC*TA0Bz!%mH1A?qw;IRLSQfdp+%UJ--En#4t;YRBYVBkf9KK;+mr<I1%<6Kag
zY|svf3NVrR2a0zlPDDz1Rz!9I4v$p1aGqo9m-(LmdgjU<Wx<y-<~XyyFgo3r_bf~1
z*-V_Owy31`SxQb)T)cH^t}hl`KzGyy&rNgJj_C|;rr?cTj2!`x@Pyrrd->V^jo6qd
ztdN2b_s(yvhmtsl-a4FJJi`zPCeW*<H{I7qT~`{xx0yPmh{rA-lP5p+>e%rqu$GPL
zPTSf47{2t^)4!6#oGDd{TkmIQau)?7b=7O2ySUg!vZ=O@upKmu!;1)Z^%xCRt)48F
zy=S?Z@12^DW-PY#(pCmGr(1-f`vl9&D=q!E#t!nh#;uF0QDd-`5V{JA{q?6A`beL*
zE}Bs6B1AR4Fzc4O6N(#p{<&csZIjEUFXf>D-4#^@OL44a)m^E52lNL*&Gy7??mC-o
z&CThZI$DKa%xZhp==q(!KYa~RG*@}bRNMiNc!Yj<P|PzhjP~fU<sbL*=}gcnV}-A~
zd-lR2OTKJBJnPcVS3dZJ6zzq~vlxp<d^R2IOVAP(EmeTdPP|&$>s@VA;MyfD6U>pA
zp-9WEO&Rs__6)AaJ#x1R>wU}NA|AtYBBEHRQSr(c<^Jpp?rBUlN(gp|n5_-s5EEjg
zl(h3jWm=o2&=lFpviSP5vnTW(S5_rMru|gPwV?R-vYaQGg$a5A@vL^U+&L8u*A(MC
z_A3Gn{POHNsRRu7+AE{rceh)-A3AbjHS#=aj5P~ALKX`-<wPvi^rD0jFPyKq=+O?e
zlG`MjbG_JUoYiZVqM(B2<nh`S^?t7Kw5c#QG;H9_o0Zen#>Cj#*7Gy7aJ|!q5>qcW
zHTE_myYj6%|I4l6>vLm_3v|B-nf11)*<?e}VR%tpD)as#P0LEF1bUAiPo7{iSEfDj
z>ar}p!)T7Rwun#0Z%;mA_MGEEc*?^YKOII!Z`8E&@0Tm>ryq?~5vGf_mi7q~=KaTx
zdqF4IZFxveg|ZzZY?tR=!Pxrv+FOvH$B@rz^R9UBd$HHjV>sp7XU<S(y4v`nA+{r*
zoeQknHrEa*nL^^_zQ5f1Y0x2^utRK`%Og(eTzFTF0tv;FXkiP(9u(BL_dOl&*^HSG
zy(cr%;d)_Y%q@iD3JmfLB9_`&5P2=<49}y(HNc5f@^-g`*?r?Fz2J+${=}#<FDL_R
zXNUiY&soMOt_UOMW;~QJKx~0sfc1`fSf8^CCZQVD7AsDuxd#T7sVVsoUF7nG!?y3;
zz_KUfu_fP=DS~d$3b)-?S4}+tDHG`i>B`)oe9WDv3q9yrsSBp9@A)-o+g$5BsOAj0
zpeR<tR<S4gI|zSCP%gyDx}=pGz;98|@dys>{~qPAyS#Qkpn@9Vva@JW`AG2{(`{FG
z9GCjMnKgQ2Em2zSJD=+j8P^>l^F6k_A(SF1y_;-^Hf^S4j@KhS#xo3v8#k~Sq3UqU
zHy@b}pF3n-oj8G35y+eF<!ipt>f%tKT#efH7`R45w<uVnXsIj9bhk2b{leF#rw39>
z{O%0T_o~SGYQ^u%JGqzL7hY);tdB3pWafX;j!}>@Ot<?A8x>ngh7aAL@*N({5tmus
zHB1#vn=NxSK)-TbcwJwqb^X0aY6PECEL5q@^75q^Ef7*O?b_l*M-TcJY`ZudS{yy3
z3YMBfhorQh`OKI5>W<t;-K;wqv$gGG=)8c(rDdz^UZQum!@rue6o1Hw87#G`Y&md$
z-Ez1@C99|ybg?zM0V}d;Us`_p0wRY!yEpeCP4V=jZL_)J%9gmBG?fIt>}CyQplS0%
zo%S{;5_Rh&I;}n8dPv&-mCoyYeE0T-ZE@WwO^K=1;D!A~&#{Jhii^8e>Nto|V`F2G
zgzI)>@dy~#KQu_SkU7$2Z-)5PX;j`LRqr`$C13T=`|LJoS+>QGh<^M%Ctt!TWB20k
znL1VxyPz_(2USt1RF<v0bW_b0@U^8X#Y-lhbzZ)_I-1TuQJQJIA2Goj`RawoO*~<F
z5WY-98I5q=eDk_9Nptd5SDnYMzuWhD^|Y04&sg^3dv8RP2;Us5z){5=e1so+?{;Ka
z__#m{m0I3tCP~sieLS@O+2UGN<E(OyPIN?NE4`7B2JIE5PTx(2lGC%pZei7)cR<=_
zLyB%1%tL+w8>L$Z*&7`wW(Pit_U)GG7OvZ^x-i!LypvRVhZyS96K5g(@<G-QH_z5B
zH|%5`BZG?B&#?e@8TG0~nK$N($Fy|j!60&;(?j$x2qX4`0!{2SdoU!oi&l168iZCH
zY{8E-MmnlG06)OeN*8r^q)8lt<i6D5jzJX}*Qn=_yXrGpvQkpCacdN<@{;Uq7BY^!
zi^+NFoae*jSaBx^z-;d7rLlmZMd=0`+g^6L?KI@8pWI-a`<ABj;-~ukdckprI(m}`
zDrE&QFwJs%3ryEV21ZHT0kPfr^KN5JS?(pm3{{=85h7M`!_Kp@hq$kPFb2n5c!tmz
z2<<kXRT>U_GVpytEgubQiIQ+F7{~%4<|cLq+3E;_z+?EwMJx0sAo>JryOmVAu^{eD
z<Lm=WWQ$aA1TIfq*SWR=XgL-xvOZknLm5IG_VxVm`#k3BB-&H77~9c%GB7O!#B;i5
zja*f<ef>Pf#i;4zu2HS7-Jrn;gY088zpC|+DXHD^ol7l^y!IhR(EJW^jiGJk+u>iE
zAeSADB9^SZpfXrLNLTnWUmpUNS9ba_h*R~Ed177BeFcFf$mYoP7^ygdW9+^qG`q96
z9yMw|`m{o7Xi=d#IC^XyTGfcxjNQKEXd#!WBiiP?t39OGGRDK)K484ZYp$nYDJql$
z31jMLdg@)NX;ODZN9tZ&anZYh0?!uRVs+gDlo0~olNw-;ALst%douJiz7-MO;yi+J
z-6prOl6ZNLks2I4L6PNORFT@95wR^WFZ%EtrjwJ~lUJKF&m)%Ctk0smc@OSUjasGg
z4AjF?hY4eOXi<n-G(M|>wfm}PJQzc!jRXUZEuTKL$m82p8V_wsY}#W*q5_d4nqk0i
z%e$CtXlNqydp+*1W00ITq86YWWHlE*efng(z0@ZcJ6K$kbV&2wrY0)w?%@Wt>O}gZ
zO_c3WtGX<bvjU<uKTn@)w#}3Yzq#)xRl9S_S=Xh%;bV&w1?A;#Wa*wZ^KHl4CL#U>
zeW64TcUR4O2@J>Tn+Fwb$k1L=Q@SeE7iQ^L=EtrBb~$Jo>L7y8U>`Y9Nmv#y9`~Xk
z$EEBM7LXz%*R`CN=Nz$9yXnkp_OY~F>T;EjPey;DT<8fZ)Vmytzgs>-D>7`cC$ulJ
zJXv_4w-;(=eN5~WjP@7&ct_3VA@`2_^_4S=<dtmww6QvxXJKz>IDtibVH5$V_w5u6
z*<-?$Ior9(J^wFjE@W9T;^iSNXPW$z6ZAXLm<NdHeXdlBTDE1Q8_Q#^rvQT?B*Zj_
zf|1nXIWVv)lF06vj+?j`{FRC)#%-<f5F%$)z8MCX^BCJyA9}+X%5uT1^ecSXdYgcO
z7nhOf#{s%XN%xW%K%Hm2O<aziU9sjaXP%+o!|b{L?EYg%(&TYve|H7m?8siSCe!YW
zXCz__k2;mr??v_LL$$P`PM-uTr>nIq0Fsnz*m!>Zs=q?CFsT}R4<H89MBciHN7jMz
zHA;I|X)W3e6vYW7V2<|im++Itf*nR8g+hIk4E(B>Ef~B&KoB+HcxWvyHN5>{6krpb
zIT5f#+bsmk3ScVZ>-xGq3XrPBn5a#Ke$C*ZpsTc;Cp>68t5_U=hc`Z7Y~a<HE_>~R
ziGgCkSWxBJD{c+}4nte#F(sahoSKzfBihfq{jm>g9#pqBK^keTc!fuZc#$`J@C4QB
zis#yp@b1`My;O``K=xIJrYMKoMbLizp3nXqYhQMRW|$aIo%+Fy7szQbC8l4_H?}kd
zftt{6z7zatIOcNYjU^By>sghwNuW@}9*-pQu(Pe=mx?-3idb(j^4a&&e%MsAWI+9E
zO|xD3K^I$O?u$avgUn_BRQDPgJ=SM>0teCs+5)zj16Y--k4DQgaqbOernEfRx>O74
zKA+CwOx`EY#nyHbXWh0xW?ySQm=(T&{YHzD&@ZQht$Z)18zw<i&(c23F|BVKSzAM2
zKM3#b2sj+jAet*5vpa`eSXOA70z(uh<na9kYartVFaVkKjIq=Re)LOAgphhg{C>#1
z>2OBHu+0!|>lue!HA>X(C^VZ*p06ENscV7O>PPm*(=-#}H{%~RPbDkWN4sOSH+No@
z?$<+X4e$kwYh#HkQE=Ut)ta`095=(Jmfj!eI_9A69f-kRE%|6~cbVS*#K#AtPS?&d
zFv2DSgbdwlo>OtVe%sYq7KZ7p?CYu=>#AJutV|}NmYO9xrH=1Bs=M|!@vY&k^K`2h
z(&nX_y>(r>Vo<cH`MIIt!e(u5&Xx_g1vYY-W}9344sK2%oHj1M_#Ec){oow091aD&
zAHenGW;M#|#cthsYmTBw_mhqV532P(ae<GIa&$B)fqAl>p4A>2z?&h+=U%$AxoXQw
zMUNJy^k(Htz*CC)S15J=#4vY=H6a0FP3S^nHHu1dM>?x`CQ5tEZRuigq<~2P$QhHF
z9J-&bfid)1G4+r04pv3g+Y^^es_N;Z#6Toz1Sl}Y?y7g){<^=ru22b+@8p!Pu0{cC
z))RABn95d5ffhXqxI%9$S!_w2B;&0JI38|47R)g4Exmt+a$x!lOvt>y<I){6OE7#a
zcq;8)0V&1B9V&M~oNBv-tDwRnNHfWp-8!z|iCHp0_YQ5^{Na|x4@cemwy&bW>^XF~
zd|TJ9f7icC>!CSdw`l8XDG2BzR|B3J;5`^C&W}O|mS$OGHK$>32ytHt;xcMlNVMCo
z46|F;WE;6Y1AkWz{qOT-2~(sXXUH`%QP1vFhU#*6-vMY~Sr&pBUVdGH=~A?zBV6-d
z@+_~JDKq)Yo>#r)@mc)td#}?Av8cz{3L}?bIS_9}cS#K%SCzaL2V#sFX0B*M37daO
z2}7Wt^1&Wyk2RT-9cdVlz7<qU!^+g0aL#oN8NZrE&_d!Dg5+4ahD4?gbg?)1B%N4V
zonPM@!yu)4_c)o$9iesz4en9r{z?nq&zNg0`~^zlo|Tp#;&2by_NOVHl)F6?uxnQ+
z6<`$-fJgOl^5VFr^`3E#dj&93w(A&3gzO;*V~k6zO*X?8dF<X$3oViG5HZG^7Ft5#
zeWMH(P>X>$s~pq09KKweE|}<He{$;VG+l{;z}O+kShgCs%A1hyL(-Wm+n2WhxXPQ~
zUtthVE1hv`y2+X9%Zts_h`CE>2HRy*Td{YtQZ0e=Qb(pU>%#&SQoMwl>aYAie2}N#
z{}$aFZfWQT%V4lRT1x79;WgBa$eZ#-RE&LGE+rWEp`dTvb+M0d2D3cx@(yq54xpHf
z55C@2hgUqul@ShS)AYE+5Ju^r1t~Y@1z=be(W&`8QUS3?AH#X$3Go95jU2u4g{lhF
zymjPa(|sEh3XaQz2KU*W-z2S3z^0v;C3H1BC7f0&4w8_Sg8Fl?(~9+ouJMVik%dc>
z3v-t>i{fhmx~pk1QqYBp(!F<{1~SuZOvIP5TDylMDV|DBcx>Ux@efQATKQ{51t67u
z3%kzy!gc>hH>mPZ_tx~cZ&P{OzELc3;btF>X2_gPT1<@REMPgg^>2>OIuEM0m$R)O
z?$lqoyw@4RHq2nFe@yK3zfRuqz(=xBZLU8azGr}SUjv8lXADI4q<zy`p6HU?H&Hp;
z5x<3jYt^;8x6FSp@BP^1D!odaS(_n}!Egk7L&c^6fwbC5DyA#9T?+&K1#YJ%GE*M?
zY6?gm4!^(8<L?w-DZ37MN25g_77DRkKymAqX$YJ5>z_ruVWm6*RTPHaPUUbNTKrlw
zZ@7}wK{xYxa);LaJ)YvJ^Yl_4WiQwvQvE?=zGhz8vu9wW%yvV}B9<|8?n^Ug<PkZG
zV0UsM6=|6mm+FWIVTs>7Vr9s2Gujiap1sVBMiwrYtt*PIexX^%*}(0}HSScStj7dg
zJWX;qA4|Qtm^5F=Y&BBSbH(N|%{Rf4-%m_G<%HY7I4!fEabnGld{O^`<atYJp*f~G
zwB%8qw=Z<hekidWecH1K-_hHwyiag1fb=eHK<_fx%hDj!dGGni4^YE$n&{a|a#a=P
zou6~>+B91B=_3_0X1~|6ZCv1tF;u!EbRC{`c^Z8dS_p|Lb5@WeD92@MK^Nu$s^5bG
z)6%j`B?-^sX6LG1C3QH6ak9<I$gmctZ^oH4GFN}y8LA+64_EPbj=w@;!loyaZnToC
ziAGCWW%D>pdl}eff3(xiSh6}A<w!Q(t9Vt77npbOyQY!q`D<fK%c)bB54Qcc?~<ZV
zmVZx!TChEAlU&!cT^>mHaS>E<*Y$!jd#oXEX_pOauMDIU2uD}K^lDKLdqu|-qby0p
zwhRS}>=!s<r#5(E7qedVNw{t`_VZREad_c9v=bsH9on2`yIV_lLXFdw0+xw?9M2TB
z?mQdAW)f>-Tjd@jPI0Ko8UNv6&|YV7^6tFbw@+;~hZdA4%Qwc(8B2w_-ivc;9i&{_
z5@(J!Lp(8S>W<9qM@gq4V{!9i;@aJtw|4tv8CwrgDLDQ$3B9=*`#T=}J+U5y177-V
z+=`s(;mSLYLn-{xPM5izyF<5`htLF>0opS@X_5`T9cS#H`TR}sp&def_Zxb}XgjX_
zQ2a&19Ez(%&U?>cx<1~xu|=~|PAh6<TbwbarzfijgBBh048|o^C+m3<WYQGljqYn~
zeLBJQB^mEohqxJ;b(}1Bs_|a-Ui=7?Nu}ggM=an~Nm_LtLv^Qd7nMY9(SFgZm)h#4
zwo{5N^=a5B7SuKoac9m@kD=|b5vHv4kKgfr(a>sXI*?*>eBOEBP1ZeWS4>}DFgQkI
z<(~RSi#ee731byi!LT&bj)Z$vsp{Ff+@Q87;7)T>G1PLTg!D?g)nm`2qU8cYYYs)5
zgwArw(%!z}Ds!JQ(g&R{@p8qY*EK)yD8kO5p~J~=?}KO>KC*sUU;;L~`q`WY!&$^|
zEZi%4z(n6f?!rE8De>cpAtX*8dS@cYx((+}v8SbSEH-!FJhA0H!CB69#BXolY@uAn
zY$DaqI~V*O6VYgOA{q@?m~b|ek21kcSG5S*^BdHi`K>^Dpf&J>>&ieYx8XXVgKo@g
zmo)Qn2LMAS&P<&Us-0~ym>*=+92V(Oy3h@3(YJWZzI)9_^Begcd0#A6Jo^<?-AI{x
zsVrjLw+5<5;<iOB23bL|L}ZeTl7V$EhSWmW8>&-ce-7J_N?Q;hA^hE28>HT0#dfn%
z@Rfp!bHxxO=hgH?+Q^08O?LyFt`%Sw2Z4aqAx<2?TZX+0faf=qf~TlT?U%fd1KHrX
zumAUP?|K?0WZL~?<GA?XDH#1pkN^0{8$8MvKvMs-R;zNO=d9WQmCBWB)UMffGpOT5
z!e2y~e1OJs^hR!pzFa>|;n*~%R}fL2Hv|hRZCg9ot)@TeQu5e9H0@rJ#E6?-NI|;n
zQF};BQ50-5voOm70bPFAB%<NaSI=d*&ZKv{>g-F>v6fwJ99MngZTw(j6l@|2gwLQ)
z3J$ZBqlpdC$%IICZ=#^?sOOSBsEv}s08O4!m9r6Wx4}~Em)bk$RRb=YIb<yn+$SZ=
zaQ<pJElXQ-MLmbo;Ujblo1tOI>DPA0r81a7-K9`q_to(3S8`7rC)TG2W2{fB?P~tr
z?CA-#S9T@=2-=Z->f8H6Zk$<94rlvf4hhRA7-_PL3fh>GD}rWFbSG|?6rJDMF-|we
z|2kxE(^PIu+;T(jTDE?V$e5DAJ=&x31pk><2D$9ZS*J42q&`b_dh~IV4CSR5WZHxA
ztZ>mYf%ePZ_8s<u#>1;IyPiCP27}C9kFw_H(b9}=60UmQQd0Xn?+4uXR$Y&KS#Dh-
zKx^b8Bgs+}W1~7d$uA6G6WXKmU1C4H+*T#n_w`-QE|(uHKwRa5VS}EADP+J36}gMI
zv!V@qv)7G27pk^WV{fI=*5!-F%GXyjJLW)YtOPt(58S=ii|pX_y|_5%1E1D5%cBCH
zY^I#g>}{NI0}OTdd9GW=BIR|jk5_os;a0u`EKRS;@#O5~8jcHO_t)5#4_2cp>3EPI
zrPfKumn&y4;@x#eqzV!aUA|pcDw~oTvzQDG5r=G3w68Lcmb+%3adua$vfH83x@?+-
z{IU_>Xbsl{L?lLz2T9Bpd#-ZUFBG^^2cS!JALu8u0q>{nVv*Ifw^Ci?gw+{mNR;5(
z;flBV=%pK7XJJ*Y-zF+LGYxzL3*GI$kgXk1Nktoclz5pQGt99;$Nc8*Kxzn>qLF7B
zslH0d37dXRYk#VgC6HwCx%w}dgv4q`BMuE(#TTqGcHVC(^5N%ya|X`O=w|K0zm(AS
z<uNLTm&Ls^_`P8G<0s{OVyf=^Z`@5n!G!t=kvSqa8s3lw;6(oCUrq^_Z!Hekt~D-?
zopf&#oo)Cib@-wV5VFApcREX*tms8;Q|7yV34*Dt4X%;Hda`uj7rC`qg-kCj%W#7-
ze9++mAv*H~4h2dAuCZaBF<p78>56O1r7L?M=Y4#l^BG|B^77J^cJ*d=o=Bw_dfu+p
zJl9eYb`neMnX0TDv8pts%_R1-j0zD={XdcYP&G=q9aWD56xseWH-E1v*_`_IG6qs)
z;Ffh8X%|NXc8dUfOfXNCdLo!$CNn>rAG{uB>`FM4r)l|G737mWTKowqMXlDakAzM=
z6lB3UWb?9Y?oTVELYK&AJa(ZNTUc@DtH3z?8E-_@d;k>{>AR@zx8dq8!tI;dgR6c}
z8+<ses~uw(NOjX-=b2sEcS6kqlWR2JHGv|sjCor}n1DUBhCC{^Ck-W-0r-(LuI6&Q
zcWMmqetoNai3rBk*U>TxoGOouL>lz=pG`vG&_jyr?y?W(1V~(|02X-sw9;7@ZtMF2
z5|k_>ZU>$uUN-}3jzzcW_h3bI=CccuY2OJx5LlWWcz!fe+apmb=W8&y*X~3C!$P!7
zpz3RHd<3oSMtZ_E5@WQI5<___<EFAVl4*?=Q4h6@7T#R7YK|)>v}|tbE@7mDJVfgj
zMLip~Ro(9SoLw4f>Va*tTC`Pl*tOq%u_vgJa_qW=)-;51QA#ALjao{w00lj;fMPp2
zpL)l;uzY!2R!Y8J2CBYTd54+#o3i)ckmrua*RJh`k3~kG^c~2Dbe67oT1w#f3jWOn
z5P)b<_&C%GgoSp(nOh!=QeVFAf4N5lTDu6kd_qb_wXz>k;^iQws1NbCYxS`5E2;oQ
zFFuTtOVu42%<a=cQ(>F*9s3v3@I2wdSog~K{k#{EP$BcO$ic5mT9FV9Ek3z1xs?y}
zW~kix>U5@3kp%LAoFL{%QzJ)O9=q4xQowz^S?!Y(^M?8}^a|KvG?Pm}p=yA9$9*PS
zS7@%0Z2wr5l4Lv!#i8zVWBVRjI$1*U&=VLeY=4VD61fw*vQiv?w+_|bjkhE-(b);l
zy@YW&+?|~cdd$S<Nmbxvwd`4$5q8jy2b*B79qes#QIGq(@4bhGnJH%nlpPEvki_CK
z52l4Qgc9_aMK|?Ej}AL6?w>#p8x9k^Wf;H*tk*|<x?A7enZ;LN)z`h3njkrxF*#4}
z%$_7%w682WE@relP^LlGw@$ZRLc5*E$V125UVG{16=`+`V&mBrVi)EBvm#2pFs=D*
z(vl<0j~x1`sbUDURHVYNTE^<$vRb5#mX=qeL0uUV=dp(nF#r7PX(G+!K>C!6L)&$3
z?$$kOg)(A6IsaN{0qECk1c-My{%&EwxIUD~PIq*8kZan*X$RR}9x>YASv{mODbl%F
zq$gF?13DU1b@0TFoR!KW$(L`_-A!^9fL{npl<{>DYZsmCR#ie0n{~Vkd?Ept-OSy^
zv0ev@j;d|{GSE|*2G;$wdbSiNB8vov(|T$p0meUjRn=KuYVP@OU>&GOeRgl3J6NI`
zrpBmHf}Y!dMFZ5uB;Z&1V#t%|HPeTnu?V!wY`d2<=^4#`=!H(j*||Y8yk@`m7xm;C
z+M(u|tY6bsm^!k%5z)2T^@8T~N(+I$yGL`VPQr!^(r29lwxrM+9Q~MgT`BJ&cFk6^
zJ}T*1N^P{t)THRpeov%*$Jb4osmS-yJN4osG26CV_yV6Ort+MiZmc%Xj&jyP(kU2%
zWii{KG080X7`utaEdZ@$-YT#*@GExGg%&L~YSJ?~9}YRJ5uy&#<j`K_HVSfmrdnIh
zZGFVPD9}Su_8i&@0@g1nDLbR@2eYpxK4vPD;bg)rPhG(eJA&52gX$r5I5b{NqbEM5
z6*PEE;hYQ!0Xi`2o3N9TZsC<A{&8r}HjmBLuWTC0c5dH-D%dpE!)al=-Q?I8UCMqw
zsxeFNvn#^KW{)g5Nf1J876A6)kZKEMPHz{k7i9064MVT*lh6os?5)mxr;@*u0hxxZ
zSsx88S+-}tan=PsOa`(&>}*hVFiIHr%r$pbsajunW$g_W(V)!{%$YF<?S@oac<vso
ze%y$CIg{reZDU(OXEKaJvch22(s>s;7Cv>y+g7SI;(F!2SUW18&H$QQ((`N4qM0eR
zTq_Ro1fNmhi<+Tj(|}&`EH4z$5ZcK+JO&+&IntinH|za=z}P||<I}t>;ffvClql{(
z#m$%}OYPqe<AEDNNwW3JS5_REIJ+GI_#TWM<1H{B;sBlgpwHyEZ2pYSaO<IK!g!^b
z{b-@>bQA0stN2~<&t7W&dgjo_t}n*dXH?uRE3|kPTng56cP+zx^n2<QDvpF3wx0#O
zIyQtIbB)2K(SA#Hrm1R+R?T?Y|3+oCm(E-r<^`2H5|k6X^}MjF{Z8%PQIBbVsdI&o
zon;)|mUYg*%=+&4sH@diues~Z5w6F;hVe5F|LQy`Y2}roD_o!Zamm&1LI3L{I?$%o
zN~GUXO*x4Mhxm0UnrTleWpl`B^SILB@O|NUx3zcLcCA9jEr1`Col0_!Q1GH_Vkam#
z_}aU7@6ytVK)L<AN*+M*UKH=nM7M4MHqfc9p>od%jyoEu&zKKph|VIK%3$sx#kxXa
zo^fk1k4{O1D58f4I|_|}fsi}9Cl*8!JSMRYVUcNl)aouSB}95ze!x{}7YFMYEO&LP
zFw64(cK}a=Q6c@^Qg=yGZ)l`KKb&+6Vl{J2xvWOXCgG&1%5{YrN#VTLDZ#%{@1Is_
zF!=zjqB8l4@6Bl#A{A2+j}h#XWjBFVl~kk77(w6WMhh(3&#wwim4r}1(Vyz&HS^_0
z4-t9g(X)7281>>+F6uBnxdIXeuENwtw3K<E1ni|8Jb7VtZHy~g&N8wJJtAgYER_<b
zUW*!KzO}6$w>Q@-oJOKCjvU_3x7CQJg6)t^IWRK{n$8&SZmsATm%+we4p1|&om*|5
z72*CwD+Sf%%z!-05jN3-?lxPM^htSkRtX6iP=>|c(kdIid%u1%AdHKr^mco_&B-Tg
z3>u}53iDlfP8x<!^>4^wMuvu3J^8vqGWq<SAY(VC+O8Bs({C1J4PX%0KY6P%)VY8F
z`@oY4r!<&@c<&}Me>2au6)AyfQk(|O65;kz>J_;tE(98yS2FBQpkxa*6kFR}ts7c_
zL;VWg!up8t`tFCbceVRx9ZsSxOGZ%}-6-d(H?fJIOyZYUj`9E$%vqWnzHZ#656zg&
zt`vGCY%yx8c-mqAQ@T&YII@DufpN`D6ZWpMKA!2hk7$j?;L{F$=(B@O0IGAUIoz5B
z1#wj+^yhHiS9@)9pK@(`7}gKVCI;n>_bSA5ap7M%OtZJINW}WWxt8^NP(qjGGaxJR
z5gPZRL=fY`$ZL3B5bwxk`v=B*Mw-p+4Mg-QY!-US?}J1oB(s-n3MavrkZmuPDAUlT
zcUf4=BVy~l=vKeCQ&VGX0F`JKODy2DJckiWVYt!>TD=?CD!CWeXl$hdVoMb~9(ygF
zg1rl!{{B?cqhNm&zqML(j-`|LI>)<<ZFz6(vWD_NIV&WQ`FHdB{nP8<-wZA0e+;dH
zSfBfTf6O=Ai|bf1Df)0{l4>3hEIW6Cjtq#3O7O1Z!uVrmNw*>?!5&cJ-CfLUZ=p7M
zD_bKkVA6I*vS%^gu1z$pGkAGUq#r<$#Qq<EBs2mh@Kz0MOi%J-sywWe2Plb)&ZmUz
z6Lu{&KvN??-8mQp2TL5#p}cyMm8$odctKO&WvjBQ?u0F&zLg$y_y-2sou#QQ|Ln3g
z$XDtJVH0TutV#QpyWKWG_*hG_s#`T_%_cs-vF(2PIP&U`q4xhW%Bvbiw8lXuY*|QB
zd<bO*jL#+2#7_3Z$3{{NGEwkU%00{_uI-Ip9Cxbeee<fKt05u{R<Z>7u}Ki?5`5mV
z{d$2jCDl9MuhTpJrflbypk3RmEXq`aNk8MELq3O9OZwG3UcnyF$Z-g&&0Zk^u_n;x
zogIA@f_kT#B#%G>oGSOeX{|G5GYyYY#7+6pl&dQ%wl;*7O6pEfsY`U?f@1mwtpm2o
z7yAhHS!-lHk4Cy7DA+0c+<F};)65i&zP_zm#-&AYI8kYAYr5a2PJf+U2m8*YMp*dB
zxK^EA5%@N1WIbFcWCr#sD`CkRgbGn;*d>=$<he9dfKMn9$#SNoGs!{ejp?f3Ak*HH
zb{LdusnKdM?IHEO5iwlK3ZqCAb@*9Of3t;MUvQ|Q?L--MdH0EL1joc&^VWUYWxp}E
zWd#tkdctv`O?;2=_8q}N_hx!Y+W>~|(#-XCcRv0)$|Si!qgifTPRk=3SWh-g>k=qu
z^(?-Rez<tDz%11!xeE2N%k!}3MEyoVn<>Qiy2d5|=bEE%mp^0<o-BObzOPOsmyK1r
z3*%X`(XDzGyV5dH3HMCTl@X+V0XzcPo68tZOy%g<Sy-$~)4R?kue?Q$NcBQ|7DS8d
z`q=t`MA+F|dXl<>1(wgC8fGTIGQ!W3YGVS$Z_tD1MVE9Jc+fg^LADvP)>J;3ejl%1
z1B~G=Q7TcJZ|<p&*ngxoZw~Wxkkn;b@=Q-(kMSNo7`LMrd6qlxlCXlcok1iX9ey7O
z9}6C+Ja|?|>Adw6F_Ig(&i`g`iviO)HinRVT}j7Cu4<-4NY=VP`Scg@kIGklp3#xi
z8mNO}*l8H4?}N}9vmO-a>}psRy9GK>ihj$0voZpX*KY3DmRklqwjMe2TNjGM{odF6
z+G}Fre<K_I0{THs!KN2;8rDw4HomW2%{7<#YIa~Nh;MJIrtMT*)skXgoeEJJOpolF
zZVrF%<0P1p(n@dNN!3T>SDtB)w+cWAC8M)Sn#_l!1kD`=5fxUY%cJF`ZU>uvGl8J>
z;2Arm)c_VWjqw}4U5O49`i|4DCdmY>?e6`XP#HLqiy*0d(R|z`xcM~*5s4koQG$qX
z*;PV_PS&SZCSB5zB`>;e_k(idL3@H(qFK7dc-8Aei>_w}9aQ&lh;<?teawaF>iSh*
zo`h>pXcpgcZ(VFQv*Lq2SKFxdlQ7NM*8P9%y;oS1+x9)YEm*K%0TB?;jY<cRCS9qD
zbV=w%=_T~uA|Rk3pwhd5v{0oJnqZ;#K!5;IIs}LiItlz&_CCdPj{eTM_%6PSeX*a1
z9eMJ;tToq~bB;OZ7$!HM*N0zR%XojBLH-_Llp*wlqWbwma(6|W>k04(3lBHD)bSBa
ztqGnek(OM$*U7&uR@TuyyVFyaN+;%4P}tA62>S1RQ}OY8EU#|Jc-W2X%<|48_pLoV
z0|h{6M`BTFJBOXKr|dr_wR0)_cR@UU?m?znUO|ceMKStExls|=O6{T+6<sOUqXpkg
z%w<`mArVg@OSgG3_O4|M)-fzc_6RCzdtr1Eo<&w=`j5&~T4t8K@Qgxjb?YN8m?b2W
zP2z@V)w%`yw$F#}_^wx~oC@B%Q?bik-!Phn!q3d>)<&`(S2W7A$P|tWNql$tE|G?j
zE4Lc?GzRZPrhlfu*<W4@_jD(6iIFDRT4PUVSv8lmZWpJnLXH<b_8Z88I3(=cj0Pzx
zW+}vpr*Zx?!~TioFy?}OOJ({BcAemcO(Q~kehf=Fap4_H7s5acbJMB`@ml>H?zKW%
zIf(5xEXx$<5Sa+8j8hesp9+09M@Pmy^x%X6RsK%oIQn)A(~g1|JpJHV00dW9TPc!_
zZVEDw%&8@*$&Ef&a{L(0IyjEqy<9*UG|?XbX@`s7`R>T?)mg2roSqrmci)7A5}g-K
zUw|lT99r&fl5pQ+F2nF(@;G?XjbrH9o^5p!WTw>X#*{{-mU|+^Y?l#=UIoj>gG(aL
z%g-TY8448nx>X!2*nq_)eK2mbjDMLZ%zgbG_E?fY-f4bZl?3TaTvnZcOLfiEL<nra
zhF1(@TiUm)W8PtvsTR`=;b3L-t{$;Z8+XdCrJXZ$s;3h~u2q$Vtkk!a+vsiZ4^(vR
z-Y?<ENA<h4y*k!}$Px-leXMn#O`Nf|L^+-PL2dAbf_}fa3zyi<CZuO~vO|g-$HlXb
z<(DT1*V%WoFTWSss^y8$8<ng<YHSupdyenQL<Z?g6VxMrPF5qxd$)umiM<K&bfEM!
zGzB2h<`sj`u&N~>oKemq#a=QM8gSpfVJBM$$j=zWoSClvfC6eyDg3`jOFvAqLt2e(
zK4*!zMb8c@`zo{J?pQ%uBOk{rr$NhQoagjwg~>{<$;jv|^jsRe0rX@VC;|TcaQSkL
ztF1AhX}kZ5OYgl+vj*eA0E$z#@egrYVD2x(6I7@t??x0V?eqjvNm@ooY-)?iJuU{V
zUE*1gN<<<^1C;?bz@L-sq*$ln*{YDD4q8U7iyHTLJw`$Iv=V-zehLjFI#bUS)r0~K
zmi{ZCSii~B1QgkB36Hx((Se{MrLOH}Qak|Zh6TI4I|uLk7l4UF%%*NPSp+Q502I@+
z3Oi^EI5v{mL62+X8#f@rI85lWyLIqSd5K&{e<vy^X(}aec6AG0vNvAvfMr0K@;6t*
z_ny7qN^@A_dm8djA3MrGaTA!Usyqw(8U5RDG>nIgUD@tOCqJHO{ydwz*LbV%EtA{3
zLU?kCz;xE@(o~X1Vu~4IP%nwGw(3E*oe|ZJOCsGZpHkn3Eqmx~)|Kdkn-o=4r0zON
z<n59ni%6clj+FBhA0oURUK-5mF30f;Gncv?Jr~}vv9jI%x^WZp&fr$O>%`Plr`97*
zg*`=v_lhj9*{5gPYrKoCD-FCUwo2z)oX$dh*W2zBdRo$|_TH)Iin?iwRKs-wAXwE@
z>wPbDpc@?}!%~UCOhxLc>p+CLQ{VFevluDKo;9I%kE*=Ko7p#4CkI2nS#yvkqW)@X
zkzu7AvUlL;UPh|a`@{luUG8s7c3V^TBYbt1(jMfX3@WH@UX#ZloIW(vDzH3;L?9UT
zKfF0<Pu!9q5KkSvFYXq@$qu+>tvef`C#cT)G<T*oeju6$t_a<IG*04fF^&nihc<Ks
zz?AS42wxKd9nuIh^ze)~7=r5A+HMZRjt`iBZr@6}!iyxDixr}bA+Dr~wZ&ukOTh{U
z348<#{>8B3PS!NP#{zF+I4PkdKfJ+MhqcrYXl)r~fHuDbEzJVE5{hO(;woD%Z0v2J
z9S5q&V5U`vKFANq&UKVm4)oMCzl@ZJ=sgY^n#CWn<J?X%8kIH*>mJctxoph3TuE@7
z?UZ7S8|u8`+b?3SOMMvPIh#hxuPB-hI0?NWN7<+nEC3qJgq*ocoG*NqdZJaAki=qz
zeiZ;2ZPAcs$?C-Ug!yt&%jSW$@jRZ-D^WH^T6?oYb5cW_?+c3eDhmvVCZC*t4qoLN
z0Pt$W2e|&^ShEt2k_V0(l^8plRIf#LhR{&XOx7Lg+t$J!-;Eiv*XABbqH`4~d1|^Z
z?62$D*AKF-#}r?ek=Y4==yq?fPK7s1(+4TeM2M~2%1Loc^kv$OlpoT_wGHF0yahlh
zzg(T{-9$>Ll_q;o9`)gNEpq)k^Zds#13v={xJbsXIJI6|F<Z=(N4}W@qiFTD_UR@-
zD<daK3}3KBJ$Gp_at&g+uhE^L5dZ<rD-|_BU}xzj>qk>NDUTmKBAq|5(t3e4R%bj8
zi(!QI563ecRLAN#&&;f?Y(IZd*0sfdX&N?Q-*$WO{-M;ajPqIRB-gDo(A(h}v&7Au
zoms+zosYV_@+`{izh(6!JWZTYZZVmMVD&?k=2@}Ik7AMK)_s$d1T@?9`fMCOEK6Fk
zWu=$h?v{DGzH`&Xsb$>YXvHmGDm}5(S*cY8oT$}Yw|Vgy%x+Y^INTNG;*5sh9NAq)
z>+~hpTc9~$sU*`x&+lFBCD77vsRO)_wT;T~d#Cd2@N0g?N*jSH`dGHBbD^Ex@F&S<
zqVraw4WNA9vMuS+rCfoKNQqT@e#d^(vTwWNofF<mnr6bp^Z7+}(><H!Hz4%fd94=;
zc6XETw%;F=t>1C5FYAg;8m<`#fFNtyX3)ez6;+0l_b&>JcF3sTeK7OPgo@v$xB}@p
znMd2{&HVBfXz3HwG8oNK)PB4&<|%Y1-4p4q$8U}PwB5u(k)c~*Yo*Yj;qdSV_PI`F
z)0=~r3<re^@B^u({DToc&N6@jZLqfV2x|1zZ$T=Z&jOzt%v68`Lfyim_M^pPL&>DM
zDH9n9oh!bV41DCej^-n9#mj6$+7%Apr1?GDBNGRMX=vD7<X9ZWX(%WK7ZaHUTn6$9
z!{-7aNcLVJYW7%U!fy{&)+L0Q?#)$cR6xvE-67r7%AGI!J}qVRB#Ci1#JB6U1QmzC
z!^L%Gzhv_Wi5VX;ZtC8|?_ILaqa#|MU`+MJ_KT&Vh1azq1@U};xYMQJVY4d5%1=D(
zZ%D5FMd=jz*VPq0-bH(sF$ZOF<8Hqlc(nz~v$Sf#8mTnQxq6Nfm)T}6$KEb(JhPKZ
z>(nO9JMhm&iywb_YYuwG%m~-DX&ewZ;~4p<{uB4oGrCWK!&JeTl4sGAnr((+XV)nL
zs$Q92BifyNBrJdm7uNJ5m}R)k5aG34fu6h-MGpf~d9$F$@|H!iV{l)}D;YTg`}awC
zHK*nBqOxw$jwNu0i`pfvW!Z&A`+@X`HJAl2N?!0v@2eO)q2*Nw(+3FBdbuJU82KGB
z4m@K^0uM>ySJaI8LdTKnIZNmK)&KZtEKqpm1AQ%e!8Ogw<cVnKnHa6astGU7oYxU)
zi(6piH`(hTNZv}rL%H%%w$dtV!bMf_K7EHK3iHB>*a=3%Gn9-3P>3G=0F<$`Ce9lW
zw)b=_{VIxAM5aJsR#aQG13FL3b2+lWM7lZXKdUr!|KcX+SE})KWj4v4=kmNWVfFbx
zLK3yQyEVu1Ctk=)?{>VhpJGJLz7^~QK~1Pp+}d<(9BbkM&q+Q5&ku{{nMH-pmvUTt
zBIRFMkJP;wu@0Yc&JHr%zLv?9RBY=7)1xb(tZ?4|GkH&nyjE-oUFAEK)<H9g@!pa8
zE#;QTb>vbU+mgd@edZX~Y%{hPYF68j)bJsBV_3V)L49UxF)8ER=qMwHjO8fpa+G3R
zjBdQ$!^JuIjrwC;q#{3Dx=oTG)b4z-#Sl?0yXWouFXMEiKZ9!C`b#NH;pT(hZI)2V
zhgJgl5DZU>(J3T89N*QbKs1dTsem~<d-vF_uH|&<TXtVwhtzf51~qOoon!g>Cmx^&
z>Dd*pu{4g2ZQ0L)?kj!@@zSID$H0uiY+$5hS^k}arKnCt7___xobg15DHsX%!L(*Z
zH$JRKY%n-$>GZ>WXLNmJygjR*J)E|BJz(JFsMU^cWc$IUc&}~wH{?TIEy=pI#U%52
zn}Z61zT+xgHqeC@X#yux6fLCLI@#^bRM`Xe%dA_B@T{)scGZRO)~voF>Lrb<`7(R$
z>ds>>1`j2_w@#UN#!bOuD)ll=^E55s3|=LR!AW}~=To2yV|`w_xi=2zR!3-O`{0r$
zMnUog90FJ!i}i>|bys4=+LJ)YBY3>IT|KD*wG5pJD?ZI%e8wB2(l|LOrI5)dSk;ri
zmlk}vAQ7}#T8$&uu+rn24;nvj%Qf!QU^~sbldTkFwsLYL@CP5R5|&=2yY(O08ngW9
zW3^n0N^zRa+AMnjQx#otD8u4o_xE#qp61)v4b<)V&EOFVSDc=T5MPnXxGIeq0w5GG
z5CZqf?iX^65^7BQj{VM|+5p+6V<5!7T+rVgcj0#sVqf(!mQKGKTFY~))6m6LW<vNe
zYH)vW!;#Y!+x|Ig{$ecMkC(tda<{v0M?t~3wC{WY<()xS;C$&SpoJ>ODa&*DWkG?b
zYpufq$2Bi>pGAP(A#;Z9PUcw^S9Kob{O`^n=fyxspfN0u#b)rc8?|o8N~}15l`%?^
zi`r179iY|R1-ee{!MKMp(rsC{6pzY#v^;Ojty^A_4jvMUf2F%9@~Cq^zfk(|?n4HN
z!eO&MrhkBNSGjJ@r5@?ZD4sYi+{&Nzpo&o`|50jDzjQ~^L4P<T7W1T-phTE2RwE~n
zHQ$Y<rpy}``r9M8Xtdsmt6#NhS%GO}YZh`)7c7pzqtEPdp$p#c?5*M;26q*ehm2!H
zKc3lHXXWRoyx}WiW+>hsb16?9OaZ#PmbD>j?(r()q-@{x<!ToZ{iZ6-r*aKCEE!s4
z4I}HfWUi>aL4zFfTjFRhGz|`&=rzU(#tG9dmFbEvSF)LIetGjMp;?{YDqpW9*8GWp
zB3cTYV(k~d5eCcu5EG!)=JfHEeP`{I#fUZR;IW?jEu5>h)vRoKVLD4r($-B)l}Ca3
znGR#Y51Sn+VJWMT#hou}!j|ev_pw;Fk{$xdqQ{b&2mUF)yt3oA_QuTc$=QbE%w<V~
zW-$@7^9K^c1=W*l=1l=XvkP;E5i)AtOUS?xU-a^TkW>*N5Yocz9IsO|uIM(J@j0y1
zJt{k%N{Y!!l6fPmaDa`6HpSao+@4K4>w6!GimGy1)P2!7Vi(Jly{ri9T(Z2*4#PfI
z<qUM&e-1@ns@tFS&R{U=to+8_mH9ePQ*zhTlp0C@B#qM{>uXG?)RP#{kv4(NIU_u8
z7a>l(3Yp`+*pO<ud&UD**=J7`!bJ40-3L=Ui4U-<f(LY)v2;5-m&HiJeYd?mI|{n@
zh1QJ+r&Q1K;o;kP8>8MmDV>#i_U5zQNfwe!eC>7HYbD#-OGrYcdGWaWOCuYBN-C-S
z&eS8c$<C!#jHIHs3<%i+e!r_7R8UBZ5hs_Bc9v&R!#9=8^L+vwgXcpSjfZfCJDyo;
z6Hn(Q@?PgtS3mk*gwnt?anv(g^b}ngFEj}myZSf}lWM<j5+U+Me7#quvJEtHnA@Ys
zv%UO4TWbKY7wEx(2z(-NBs|zBOXWaDFX>~1$j8nkVQfL;%IIvi4G-5H)rMm-MhC?U
z-smHaQAf7MKibxI&Gz9F%Q|1h8S*oSZ;z?iTp-D;Zyl<VyY_w(z7<NlA^|u^ADj9l
zp0+wy(0+ne@FPzxr1XZ{gV#&NQEq1hwQs!EXuh7+nMAU@{0Mtkbf(VU)wR=94c$^0
z?aOI4@g&0iQrwd`1@B+P+zr1qA#B}_<{wr$BcV+*yj)r=IhX8gdzBn1KUbLJ*b6s5
z@<Y=(o5`V|x70-lmDNB<`mLD8v4SRqzr8Y_s^4~|lugqdB~-%0cICckdIAXH7Y9Iq
zJJaK1U^XCd0j1;ZCb%4@+Q|Mf!xF_2)YXtETHIde7j(r=sxC=~&&y>7XDLv?e*|=I
zHF8xRVx@iSMA(j`lwi-Dkw>oOSP5{2i^kadRbcI-+-8RvML(AXUzt4S&r09LX*zAL
z6WhcA`#8{3|75~zPNqs^Q=Sef@`4iv)o)53nA;8z?)@%v-)^E@AzZ_CZB-#&2nK!5
z8WI4p{ytsCo8Ue{x?`8$S3w=%U^ZBk()FM|@_D8Gf{1|InDA^v2vdjE+$gTk?&HZm
zA=$m`3m|bwl#ipAFi%cR4BW(a5Z!Rf%LJbT&$;@@uBe{6=;9YT@OnF;+?XptwZkOX
zd=p3beYYO$K9hLtS<k8PA%2A`UQfNPCj7Qo2&gjNmg0?1LAlaR92M+CMg&b(?W}X?
zz$0nTw;s;<?-RESdt^5GlkDpJq3RlW0NRPp8|a*#SIu(8#hNb*B4f+zbu5PF7eGzG
zQ9N{)lC$6y|EO<E1Y;MVOR+?PI-kR9QKO=o1s=@Gm{gjv+vww@00OnOLkHuLPMeRM
z3QVUeB$nT0c1{>xy@lejk!V5`XgtK+Aa^Ikj#7IC8(d5O?y}S@6qJ2^nck^H@lw_^
zMa6`wUPp%koao!BAx!UPA<t&Z$ijP`NImvFXnWoMzPYbq>kXWfWyn85rhnng&H_3O
z?dAYC`YKz(@te%Q5DE$0@u%pU*Pwrl7|t+;49w%>*peZZD9&)(tWBNvOuUkyYTbcM
zY_?;P5O-4iUS!*)f?Zti3-jUm1UExC^$m#Z&JE}LjqR^_k(DqzJNyW@p+W;|u`eK=
zT3vLnY-`f16jrc}lHBcYec;@grK)^u)G+*Tg)Zij`A43@QxUCM6beU<(}lm>xKAy<
z=V>@|U)3&2Ko@l{sY>{`{rgg@J^`<9G3V9eaiKRJ7x`wsE{fPo>z>dw5%5C2ZPjP7
zx)CPdDC%8Y)VCR|zz)5GONh))Xu_)shQ-c0FJ+AKVo}NE1P=4CL1%>rZfDyzXuL>O
znaCu!!jG7Y9UD&V4RkG&06ob(#m**vLV=lnOf&rZJ2n4iIr_rSG(qB(!%M=mA4r>Q
zml6Hq2fnx?gr&w1<cKp<oL*7TLa8Ea*_TCwP9Cv+A^NNw&u$l5^S*frEyI3Ri$p`8
zE8#0^WUwMrt>%U9>?X$U@#gRbe2GoAXhLHD4h%^ru&tA69KlI{&pL3UHbIJMy*3%<
zVKvV%D^+}u2Ahr4&I;Wj(8e>^<Lnh^fmnNwXj?&ff2dbtmC~+XsJgLIrfbdBcqOfc
zu_oJ+2~qPZgUT`%wk+;<@gzp6Z+gyn--D7ck&RD=<`odFHl1mlddXDK4Hhv2@6RIY
z9<21G>>T@+W){g_F69P{Q#<?kWhy}1qs7#b&$E0n(t0_$oS6)wj7><;t@Y!~hZ*q0
zPt`_UU^$glHgPJm<x!DNWuGJCj0VsVv6~o6O$0cg{6%r!G7o%4=i`wX=l#w`L`)H6
z3@bL;)O$_$zh|l@^2%#P_~q<$i<9mQy#LrfJMcQQ3rwg+80PkVZC@TmejaUkLKF-<
z1-1Ib6`njp3)^Gd(u_d7+e)8^EP9v1k~mZeV<^K))+U@m8?^{>FTAe|gqW}@y;LaZ
z4<0hRHPgY{C_vBc_x)@8>*Xt`rsK@E0Nb}1t+K}>)+7y`HVQYLvpod@_N17R5(5^7
z6BP0nY2^++h#ySm&%VB=I^$Dm-JrsVNjlXn&MwM4gzBK@1d?4jO2Gn)Yea58n+}_^
zO9;4lNxn!e$ZFqc-q!EGw#!pC(7mJZ#<dxsGO@4m@72!9Wiq3oR`>UWxab!&_NGE3
ziX)t1F-UQ{tR+2m0<@**)kD|VHt`=D3IBO&)yS$}BV#83JOlnS&ixl<n`4}BpT;P<
zN<*#KC^f925e5E;ax;``iu^NC{Azoj%jOH|`z@@}_XXceP}+01J<;@bbf)DJ!m6a%
ze}pn>*_uP!FZy^*1~PYM+N)OJkPc~solu+E;N&rROU;5de%eGjXE-0Hd<U*S+td2P
zmkL$yWT8D;e%B%Cfw~7QWxBPOvaRyO5-Z;vcC7#eI3=T~Hqf*nG~k!`SRu+OQzT1B
zUp@vfVBCtzAzB8qb|^F@a>+HlXIEGF3^Y~aH#z5yS(bJhSu;?ahHpD2p3!1Q4dkku
zm9Td><(D<;#OfJgG+RuDmPBR&JaoH*7b{AsR;Y<8(z5WCD>Qy!;vT`JUENzADQ(ED
zJAI5Qzf1|9I(inm18~H}ULMNg3WAmqYY)h(VK<fHjj?m%NLNmd%Yr6fda}_cEk>46
z^Xl|+h?`-Ofz*_!xw~a-)fKx4gNzoUKW4Eg%^0%kbW}f7*xA{5?s_QvQ;`S1utNU|
z`dmSO!``)wCjpSGZrm6E&I8yg=nAaw@68^6ZY`#Hqw4Q_8{9qOvk|1f*3}{Ki$Fk!
zyu0FL@a;c$*C^<zG*m}EL-7f!1vq`GeM@NEQf=ahIA8x8Y^9{Q)^psake18nllI2=
z4W*9R8W!Eb5E7d?LkGJyq|<HS(xIb^A$MWN^OKuFSwa~H<sR?wB5W_rWp>HH;mvl%
z(h!@1p^6DxZzmZt%;*7#;LjL*@Ldr!DsH(w4sl=Bz%YE17esVh%4c;lj227Zi{AaJ
z!LtWtXvw*@q$g7IOg!%w%`%Cgh93i(Wgs5_B>7vg^^br4_TWi2(-?bd&Y-+RdAL`B
zYUZOGRMVdpPIb~9Y_~)0(J%_<Zo~YWNvK*huis|Wg4B|C?Rd^oY3PVa;G}$fp1ar;
z7#LmI^*{}qA6<;RYe12|7<vEWxCZSl%lG@tYb)>M`!dMQX=m<%zlNk60GV;?YzG>P
z3_MGEu-w?K+ou=_YZG3TXaAA#{4*u{%|G}CsC8gg$r#P=+B8qo>3{q!zly_Q4PFED
zsw_G+{U8fkbd7Ic4q>8|`zR){HbhO>tWHzLejF0wP8>RTonqce`aHI~CR?V_kv-cf
zfy3us+jrzxPd0{JyOzxY2mnF)r`VToL_j`01pXk`v0>e#=W-jK?v1f%LwrAK%#uOf
z{PX#WBO$$YOM3USzYWof&Yp4a8R7qNMgPG<(XRT`7*c5>{ZkK5UJ*0ERfu>=bv7yZ
z?vZo3VSf~?$d<wI6iS+)pao1+kj6+BJx~Q2p%|NEYC<fT3yzekoeMICC|je)O6k`e
zIpy+RJ!J1NH~i@voMTe~uOP%5067E{<PKd%{1C?e@tPo(1uRxR4#NUR>7SCVGg~Re
z{H6k&BSo~FpD|Oaz4W~Hos}Dp-Wyk5)2^^3>Tn)DfhxTFnYdv7ZTlczzDqC3+-4b4
z#i?3QD0%$(g<1_%2iY)}nj2_bIRu`635xIx9Dd;TFKYLH&%XV=ekbp(KiJow>@D~$
z|J#7K5c1`Ch_cMvLnlyfCDxx>d7Yz$CLB_d(RI0E{zf<9rk7Ni6-p2*tvVMEpWu@5
zmwO~77?vH*7p|q-A+TINa(nE8$)fYqT<Yq-y;qErIjYAK*xYW7mhHa;UH_P;*Z?e!
zkjg3f|8e6$I68dtV%O4$b0IYglpAv~`^o-G%k@~Tli+_oei#KjOlOaB%*tg#l(!=d
z9+e5Y^M~t}=LJ>-YpJIlk^NTBA)cjnE=#hu#6BnzE@PuUA1_=^GK2qpoqn|Vb8Hsm
zODf_lDE?h+Li~1m@ZUXE^m~xb+?Kp!OMm#x-M7FA|DJf;H4(rvSytl+vm@v7v9)i{
z>nFO6-NCD9YHCiWbjt$Ud7Df@jo3Boug!ka#5M5Fz<uD|NBIsPXB>Iy>i$1nx?2`2
z;$<FuDPtYm=iXbLK<W8|?)d~LcU*oIrYBfS^{slQyr;!=?U=Zb7l0Z#`!Ee5C+RbP
zBY9ij>kWGZ6=hq+!P=kLSb+0P9Bt@UFyd26id81;qP1u@!wDkz7hU8(>4#h7?<<(=
zN?ts`(E5`bp8Pv+UsBBSYFl37A!fa-dZjG$oBu9HZ-LIEfeg>GUF43f`^m%fHSIxE
zirS~k$OOY?>}otL5Rqh&Q<suJ#^%Ngr-|fF6cQ>-6z;Aq-WUw>o$~4Se!_qL?=SGL
zFJ%pwbs<8)bN%vk`hTXO0r;7xSzQp=&l4yue`sMWfB31FhMGoO;mbT+YJBiu9Rc6u
zym<c4nq2V)9>;Y5yjgm4J#7YZAqoSgSrtl|mtgJI4{7DFa~9nOnox`;hN0|9$Ia{q
z{`kw}x7^!E>EYx;e-ao}Go$|b(y^T)FWp&?n*Pe}YCZ&5enL?6wL-{W@izNtq5=y<
zFjBq%v3%RRTc6)^QGnljQ@?C8(SUr(*?7lr{n>KnUwSdV*5Q2uEr~?m?$kw}6x(MM
ztAW)Yu4>QJ#YX7GI`g5j<4u@!k8S+BvHy8w)yl}g9hmf>1OlIwAJqO`L*=f-xp*mf
zy3Te7?}qWi5nvo_?*8V=Nr{)Z69?POBT{bl1tZE!hYIx)E70@0tT?k9e?BNW=|jOz
zSZA{w%}k|^AX1_$QQ&q*m8AyiHZJVcUaYq^uEViod~wpyDw-o4D)-MK^N;)Nzjgt*
z-(?S=_42FNJ8wLV@N#-PtaP+p`)!dt!s)1A3F1+RTeiu%!k=II70uE6N@17X%rwo(
z{V}#5`+ml6tiMWB560dij-j^<`gx8yNCO_N9Pv}nPkzV6*B>TBDa#zb@tXH#$eFKB
z2K%<`dAVp0YaVUaee38_MIuLrWMt|~IQ`&4Wp^q+Izn5J(@V1i;hG=oiu8j9|MBFz
zH7B`38+v+-F8k&fl@Ft~iV1yMrw0lim<(j-tQ%y0!e5@5ZEi60o{Ppfc2o{76k4yv
z=M?(`5BuX<{r#Neo+Miv^)C<VPtNwwzUGh5*lhl=T&iDM?mzDRpIg^I!+-LL2eN}4
zm~Yp9<+A?%2mJDFe)xyC1?2LR7*J|F41_Wd-_rc~`18+q_TS$%x`K>ig@pWatAD!A
zKfKKkOX^<={BF$h_g`A<|Mp6MJDfx0!^sHLdVX=s{rnw%zL4!elL%7zQRbJP`QMl2
z|Jd8RI%ELG&Eu!p+|M8X>oxq#$bP*xKi}ZLjO>RK_rICjUq<$qk^SuI{p%+C7a#q<
z_<+CM<^QruKYGs}jck!adqxHI!TdiW?VnlauRiPja1`_&G(fjnXCP4Rbl1Y7oCaP1
z#(X^i0{Q<8;(zruKihh>Hy{{#vu$l_4x)~BBqfvrs`~R(|9@SD!3)Np5Vp2|g=#;K
z*MH*T{|eRq=cW3aSNkg;_=y?)-yZ+}|3(&+%Mtr`E`VP_CqG`Z|LvOlD*^rcsQb?@
z{-1rO_E!S>vt{|eKKska{xY(k-Nk<;p#Qf!`p<v;3+4C&<#?NVqBB(j0|<mgW<e{t
zP@!H`5vyL8`5!8cT%7)7Su--yEOS=GR0nn#C-+~m5o;xK?L_gHsABH%!{o`a<5wJ>
z0u43QPB8xlOXJP&O64;N2JL6UON(fIXJtYXmT0a6qx|!Mtt=%2Dq;!WK87T9@YHsa
zh1jwIL%F9eKM+Ox&%OPZ&)DqAD02iEWqt%o;MqzEPf#PAI)E<9^bclsb@j)wK;6wa
zCqG<hw6)xJq@T;MZn$o(ofE7_10Q_*BeN2w5*8IU{jZ6NTKNZ?;(GHUFxM`YmReg1
zUhFby8SqAL_6?%HOz}1npO6{eGy6h>COk}PyGONEUE|s|v|VSc?HfR=cmj9TSU;fn
z94#nmrW8Vzg8{nB1~za&O1nw#HQoBU$p!}R08Po(ph<30i-trjteUuufmNlX-~mOA
zp!>M1R$oVM_i0h#1N^~$PeH|yZo<|#z{@TOR3Ki{@teQY0SxwF;=|SiYUnw$SkTZe
zK9HkY)$(NW(+hJjhP6qm8!=Bxa03kXR!LAk*r-6})FzNhNfL3My&QyEPbdM5899Q*
z8e5<zD4w@ryICnwpbd-}x7jxA%$kq8q6NX&OJRSd+GoJa+XZx7jMr-;x~aH}k#c*t
ztx;^XMp*bkeV<6q^5~N=ZVlQz5?aJi$*M0SsL%T?Y7KDkB!NvFfsJ|N>y`7Ng|~S%
zT2#{JvTR!bHGpXYajioMhw>`Nwq?M2Z@Z+bric!T;`G_fjfiF(ck+4?)%x&WKzNPU
zBel(9xa6^$iv(;hJIRh-*VMYc8+V>Xei*heRG6fGH@8TBabOOiUzTj)g|`udtnbZ;
z;tEXCYR!geC*bRPbM9DQ3!C)>RJJmMz4go^-(btMfl$fgpiR*xatlmsDerAAcL9wJ
zJGbG-At=Js7Y2I)@(iW{>WuK%IVn{=A=m$!uimZs1J!;;Mzukj?h3Xt0nDIqme2&{
z11$lAvO%a`LY$#jTdqu4`+0>ckN5Yt8fjA#F8#|l-@SYHF#-th{C-QYYP4dY^=ySY
zQKehA!S1fQN)Yb7lPG-*#)-JvlC-x{+tc7d=o0P%P44z-s;S~5E-Pa-xn~;YGr~G6
z(1v;_@wP9nj0GCc?>3%V$78W<Y#Whq;>Y!+5&jw-kzyKsHHL818!n7pZ6SGv^ma(u
z8v;&(Qz3}DKUDg<Zo?_<>ln*@@0FSs;({t%QKhsvQgYWav*$$wqgb}e!TNw|*W(aI
za~U10GwYu23t4fA^5OJZ$`Lr~E1uvDyFU0I2|p}fWH~;U>RsfmgPH>3KXzv&*3}q#
z6}xl4wlKPnJw9T*FA(mLeNKf>?$Ad-7JZ5TVNB%#2@i)|{;aHKsX8a$ka0D-bAPj{
zk&YDXy4J>uF-fpb^%-FD`F_tCC@0L?Tu|Ku0|5EYs@Dz0zkfLLs6J9;_OdgWXHA^#
zN^0q7U7I#K*o_m}{u+2nXdKYM7ixil*Dfzyp;lJ?BJpW#b9nleY)nEXWq9uvAkFv^
zW$3#BDFeOKUy5xAFTC-lB0bb^ozk0t;u~5VuvNPajNL|*r2uy7M$g#<3n%lzy$xVG
zLRto{5S4oGblBilEFibUKt4yp_X%lTK$6qW2$#IGY!7EpojUnn;~TX!AQfXKrb|XV
zHn_Dn$ZP<w5#?f(+V$U?Px(vO+!;h>Is+w(rLzk>4Hbhg%Dz2+&-#NAQD1Uk(F~H$
z>AygIRL#+!WA8~DE^*(msLxD5I>@LUe5Fkt6CqNeMuJ(~qvQ<2vepiq_hc2q84>NQ
z^W)@^N9P0576SzbQ3JH$e|_C-A$343lhW%ZK(q`78@9?K&d!(*?NtCOKgat`gRIOn
zPTM{3eG>)xhbm$-(T|iG{YY;HfrUx;`?1RKQC?*yM%iP_-;#%-BCcPeuUE_zU<BjN
z^7raZ^Xy6#TjYdW+O(!K`h179O~R{nTmvAYc1B<q>Rvucvy8q*+MGNN2Mx;Mr*lkp
zdS$3a&LuV$X#_%m3}gM7g`JMm5~|1YkDZ}6Ju5~0uI8*){I&<Q$U{-{5S>7X-DlBk
zdRN2DrX9d7fdnhq<%%|#6Fw<<u!}2p?mjO_6g-|!%{J)G$<3B1tK^(2=3c}osM67A
zktWG9Am6UY6Ndg_aetmMf+8%rq9yycv%dkT{~5*~i0Yt5a8&SZ8U2(YM}>>R7+ZeK
zh|IOj#{G?AvhR8C?f_*?3O3AEPBI5qxLIvd?NVvja``~-Rs!iynd(1%xDdsgOilJX
z5H_|fPwHl;dj(ts)A10{=Fi}ZR&{&HQ)N6@yz0e;<14_q(Wk$&K^M6R&{I61Mu59m
zu8ywF7&5ObmU_*rbaycy6S3iE@V>{!`x8PsbDJ7W@~*fy@`KwyW1PEwj!dE~mJvY|
z*o~8?*HHIZ2p66x=_%V+$n-UEYP(TcbNB{*&3%@wa(nEA&-bR|o5H6h5VqtgJYe!=
zJ>&2<-xPyf1w_?4V!6WuBor83HHo#M(!#X*4*p4lsmK3l6Bm7L*X;z<PKKZMf^i(!
z(=W_&`iByjB)mQmYFT%e%>g-fWhT5vbR1>g!Ch6J`2Z}5N>g8{{@(OdbI_^qZgmP_
z&2DjmQsz?yzy`OppX@ejW#0Pgn%iiq_llJQM-^|z!F(07?+P^seT5RsX6~5FfbuMe
zf!GBeIv^!68=m+$AP6JR(!V2M)=u4MMXW;^4+3E^yB<|;wY_NGrL`8R{l0P-W~j&;
zux<V^<bT9%ZRkDPGxuD)ynyq!S`ZEtv^RVad$sn73Ticd{oslw;l)K(df#J~rZ=VH
zv*E(-6P|M(FWQV_CU`|vNj)Xij*~Cs%@p^&4X^<ad>tX8&%&cL*`fL5>IoRVLHj{H
zs$viyXh(gETc$Bg)J9}cU;Tqd+T5-_Q1#PRxvScul*a70DuZn6xzxzm^Y0C1|B*HL
zJN;2ho+sCm2O(gp$_wL|0c73W)@~-*K5>aNP%Hvitv;3E58^p$p-)9U@L)!A^><XC
z{-INi)!#Ks4PitzsB%#L?iSu&MRegh{NfS;5IsXi?sCK?d?55l*#i$GRqGcn>fCxQ
zWZD++SLlN1C0ts}Roz-l+Z8YtGK42ihsqmiT$Rbp%bPw0WjFrX%t$H3et9Z#SHNb7
zi{Yx%wV<sDZ(dhT_NtX>lPbIM$*)lXw)AuzyrbP9Zeu$;`A2ZFGA3e|VT=ZMv4s&9
zgcWY4c^*&JWihp%FX;^<rujAk&mU*<cuV#_%1*KzHEpVL=_zC_8_BJMspCECdf|sv
z?Na<|pQKV<xzii*G|SU#bIB_5wN&Gn@UU^<9gi#rl{g*);!V#qoU?}T6gh&m6(a>t
zN`uZQrG#8F%W{P2gHzBQ{JjdT-urvsx_iJyL^)VZ@M;R6AWsOkbt(G#b_t^6AM)0t
zR0d91g4n}dr4}f6j2+w4%)1&P$w@uYp+Pi`Iqc{@=BTh}OAk@;7pI*^iLCGM;agx)
zO&rSi_pXFlXamcN-W^Z`^kWH>cdgg?f})u`z8-@2K~jaSQLRI5c7VYclD$W>?+s;n
z#_kYX%=Vi*h&o1Y_5g+%A{}$0#fPVd<R5d<1kuva8-Phyga8~k`j^e_MQlD*lcAi*
zIC*?}VdZH1vAcrSgXB0U>ZbDKg80wdX?~2l7X!&n4+@~G^+R3*MLz0V)A$+fl;6mK
zwnq<`RcGaQU(w$ib!{eVt1RnhM*O~L`c{RfP`4s<uJ2;kR-XcM0?=3Kt5iRJ170H%
zUQdh6CxTgav$$e0ZqCb<{feBP-2G|R4JR+&9QGVcxW|}}TD>-6)wJ9L;?Q&MOX|l%
zfcz$gN86nf&{(;~#I)Y;U<NVqhFZw`@|jvX*DVW?JWDB*js-aq?yekdgg|vZBWu*l
z#(YZmLF@u+;e%;`>B2zwq9KFg3hZJ57%N;X=d&BTBi0xZvf`IgJQX#R)h)I7HQL1q
z^O5BT$E|ZzKgY7-3`HDuokleWw@cQJ^=<tub$tQk^Uxx>b<$Y)(uGk;%$*sj74I#l
z4sMIl3L6VOpRIBC&10A71?ABcx(c@)($yc2Df76Dzr$}@rEG`QGYvGb<-VP<S%0~K
zHj={Ua*lp2KtE)!O{+o-<K9g-Pv@$vIrUYfo%(dg*#JFV%Y@oUc}cU|+bT`@O#r-h
zO=4#;)t#@uWkzgqQ1V?bcDA_<8lWrebxRaCGv&ie;Yc@>tHID!g$uHH2?~J-@wNMz
zZv!@K?XeAR)YmJzXbaX9qP^Dp6uQ2JFsJI*t;*c}eAL8+X?|2k&R@yb?On_xRf)kd
zFpKT>rdgH#bvq5|%QyK8ipQAs8Ma2=p^;4PnI1MS9JEe-7ICLu)$FY2et1KKylLVZ
z++i_aa6cLZ0dgMi9^8nLp^`wcZD(EBRoeJ?7jTn2Jd+qKG#R61$Vb1RNERG(y!E-F
zXV*KR`%%!hv0O9Jh*C{(=&b4~5g=%E6e|CnGbM>KH<wxzzTVJp5fC9aY7dxW%EHGl
zQH-tob?dr;Gv~d8GHg7vP$sNHJZIFfrR3C5(8SS|gB=!7jOE;~d`FS*hJgw5yUeSh
z#W&QOu2T%Z$%-}}1gTE=ewXHhV;|n&`fRospXh+_;6AF6WktBZcW+`jP?CRRCp+UU
z#7Uq4`0$Zr5FoqlHXe}dfd||ho+BRr@tpiLcg^JmjXAfO^3p82^1c=$n!p4kblzSk
zCilo)IhPa5MktZOujaBT4wIXGDf-T%3XE2hR^Z|;1i1<0B-)NqJtR65<n1Fn<P-`e
zq(1jNG?ztH4%K$UVrM@rgvl#cdU?!gJahB$r|0MW29oDMuIdytTD`e%f@(|ueNmRC
zN)_YR=!;6{vdd>xS7-~JUm2nqRcK7{_5(f(BFh-$G}{+O9w)RbUKX2;HvvyIl#q9y
zDt<1SJPbQsAwuZnciwC&?Br%ehIz@M?y(H2>@m2mJC%KkR6qWy+84Y_(cF)*?q|w*
zvBEt&giV;5BMc>}nW3_^S}F}IMJc3wnwpW#^wyM3S(-xY%(}zY4X`kG0ge0MYb7>D
z?_%>ZyARxid=FG>{d$FDQ_9CPrdoW^ChDy>3>zChZY>US`Yl&>7}$J1r6kTi>&4Dz
z^WDs~IBM*0=2w|+KF7Ta6sjB<C2Br}7s4-0o40xT01$!$HPkgH1?1O8X!?}7oklG@
z&xhZ<z{^`c!8U)fs&BQxj(u}fnDXr>T)2Ek-t%V3RU0_gRhf<gkEqoVA;_`ReZoDL
z{#|5%NQ<0x!<-v`{wa-GDzcf<F$tvcqD8#x*D2kGo$t+U0~Vi4wtj#P=Tpa46{L}(
z8aA*etXb5syI4IA&J&IB0REb8)&BbaL(Y8*S?ae1{nsf^X7SW2e*B$tdVZ68S@<OP
z3b+s=G4t+0PeKp$)Yhsm5xkqhW9aQa8tt#eg<8sHZ&!5VxNgwTaHX<RLT6HLP+s^9
z8}K{jnAWvh_%42OcEAKsK@2fQh4CQSPz8#<)U7Y(qEyo};Pzu)>pJtHd+sWj`Kmq(
z>xRh#u_-C^9?0?2n(P?Lh_ln9i}lc4a<I2rT2UVq+U;9KWV@48RRcd=<^x@*Qmb0Z
zjFd#Smzv?TL-q~wZeOJN@9{F-$!h)63F(N0YuHcQydDkI9VvG^7L$uWw1j2<?0W2k
z1cLvK=)Gsz`4jl*X&)3j9`Gi$ilxmm0#>u68-6cWmh>DXT_>NfJhPi)zX@g*wPTkx
za=J|CD&~vEDXKa|@}^$mew$i+6KRza@&+bdJeX$=K$rIkskwx3tl`{gihmwc|HTv4
z_?Vr;k96&nt4_i4v3)zhK~!}S@tE|T{zX#nGt7Q(W>FCJ{t0FGjlL6=BKhs~1x}26
z<4$iP`*K-CItIg@6vrXBu4ZLK<F0de<EvB0LZ)%$5%YjQ>CrtCgCp`RHScVFt2yXb
z*$h{J8t<#o5;Db3u`kIO($BV|i>~WyRm#H{DVYr!4+7$t%e8VWArxBQD)}Ee{9gU)
z!_fnzLHa2z>Jv^l$UK*(OPxXOp(DqhC1wpNWZrEd-0VSHYUXSUU+_J)K#-m5{r>GE
zXU6La4#~ZxG899_yCOFA1xc#)%N+aroY4st+xN0Tw5^%Ijl-Wru0}Wyb~#+)(pJlF
z;^4*>sz$0x?wEF0;z)DZTT3HlzthKbPkd4kM)Y|`5e-_p3X;B6@2mwqBc2QIZY#(F
z1n10%ftqQu3E}z1ueQR<ntjtJk1Glu0IOy0*|PalEq!$#3q0Yq%4)+jPfDsqUi$aE
zMO$grQyEj~Jx3{jaIQZ$9*`C5^8^?4_7|unQZykxJU3W5staZHg&oVM{;u94<=U&>
zA~F7Y#C6Caa<Mf_tj6Y9{^O6qkZs07)Pe;_gG2<#h+5rg*Wc*GJsduR+|eLi<x0Kx
zRzyxAauMO?!YW)QT3_wDsGcGxNm_p-COyF4BmO9T(+;_!Ta=-qwAi}cEr$OzP_B#^
zNW&gdW<-n;M|pyp0eY&*=eaf=+QQ_`m6|QI_<SnPv_$dP=*^miqP~5Dr{kjKjEhGR
zLimO~JCzWYiU$*B!(DSs<V#r$3uwJGzPTUka|voB{w{{5V_hyn`st<q(2#oW!gqyy
z$_mGg6>ppL-(ndm6eB;!0{*Zs_m25Cx?%C8h_26E{M_1E#*q!hxLJyQ!9a|ZL@LND
zXzUwFl_WbdQZx6`IP1J0@r|H%)(l7T+mh%aI+yzCh5?&Id55)!u0?Ug9hn}IFVCjv
zgQnvLqRQ7Of+)+S0H<eYz1=Ef)IFM@6T}7NG0hXQ*ElF3L^C{acIgK93%3+5DH?j$
z&?%mQLbgVQ!CR;tkm1QQ&&aChB0ThTxhU|^nUF;4+mtj1)q|$h#_RKas|~oVlkoMM
z@J~0xg%~;Lv)W;4@@YKT+bpWA_SdJ5M^jI)VvrjP>MRzlaMre}Gk#CmjCvK)LhK~y
z{W)w_BlDQY90?XX688=%9mq?Rs^u-8&mUXc&`G#rrX)P($ds<&J3H^2%C%cCAntXV
z2L7!4iTo!Ha8KNdZ(R0MLm#-4gJ(xEnDe|uj&l#UYMSak&d8*soq1fbQF%z#aqeC6
zhCSmCm&8A>i+}kkSM@LtZPcZk8Fp5~fEu-!OFL%iw_M>3z^gi?a(VIk+lVWR(^Isr
zNc9|fw2lm+I^!&7QDA5`F5-)yy2X{CfU!Cd&^n0k0KT@DxG2UI)cqzNVL++9GXrM*
zUgiXe+U|a1bzOUSNlHJa?uf%}?HflLTkkWz9ot+`cc)Z|1;G7vyUdN9&uLnWO>aKq
zKV?<2$iKWVlou~(1C0^o_#pym1u|ZcbUbR`X>1D(@DwS_cXOYq4a%xFwps4%Fm{LO
z7~a;7sY?%tjk!Y89{y&gcy20EDx!+h6E=y*>sX}B^u#*L919A5gT)H!24jpQx|4)?
zQyZgkSsvHeRTXPgyynwGCYO~@NwVorV&gwHb`J<h-Oo;Xa6PO@kdy?k+nx+-yV-=^
zuh6obz9FT31CKWJ=EkSN8MWIh>;aR+ke)qcgenEUqTef6*|@?H&aY{D2D+13ZiR|1
z2NG%P9+>j*Ho_fPDwiw0za;?qBH{|wy@(lVnf&U;*EL;ItK9&^YL%-K<0Vy{wPmqZ
zb?zX(dM1R4rmmg7Xcq*wlgop9H#CWFdjK^MgLUj9eB|w{Exm>}_&cClKw1^rO&5|f
z%^-+AT!mxqGjxg7yzF(e(nP#!G%DUwUE8_{Uw5Xk0pKy!m{X~jjR-)PC>3@ZBNwoO
zB=cFtHLM6$S9tZorFu9KySQHC4tN>9?0pA!;LbrqmT&jXGi7y~aAvO00v$-p!2i~A
zZ~|2h(yXj+c|P}U2S6H2jR!5#d}DVF2}h*KXrnblV^pH(c1?e=QDgPMmzud$9KxB2
zr1BhufR^IRKutPgZg6cNR5Xx`-Owyv$x>k{GCc{+yZHIlHJPO}INGM_G~BerG>5Kn
z>e-573X~|8kxx+8UBz1hCSdfOfFq-uGy(B`B^p0!mBjYL&5U~Yl)(U@rmcu`!9EPL
z(o-r?OlPe+dw{%$Q*pbaWf1%3G&HL#Q(b+`YhxRjwx(5fH-7)j4WdmHAZ<{)--`c^
zj|^6C-_VF*{LTR^r=LxuTaiU6izd8zdK8dq6`}`iT#D3A$O%t5EE9JIhGx(^=n6mW
zCi|$<(3*{BOs?EGMRs%p2pIIt*VNHjc6y4-AJV}6rj8gFrRncw>+w?`Ze>3705(um
zO!6$1+$zqaxuwX1W`4n8Q?eLvil?=F7nCPv>T)*x9>zA3mhIn%^Y=e@r`)zIhaI>d
zQHBGwIV$YF?{cJUjG#7z?fMM#opCN^Xu8WlKS?^0@(!}6*7PchY7Yf1;VAdr^=(;B
zV%l3@c(mHe5;=Unjr2NHfSc}8!)&6>r00f6?CHLRt!qHKwDZJczY;~mUE!vKf%}$}
zIqWYN?GFH0?(8;r0K%}jgV@+H=B`}z!SS_q%xgeVv%xRR@~L))nlK-EVrF*0^HJ{h
zArXpnN*Z_?IfAY08h59MsWzP7UgNpWr|z#>1*fEa^uxLT4`}F*8_a+A`rVRHV~AXX
ztWLVsAKtW{d0V|DOj?dnXzZXZtxjgwu6Fs7>O;3zP8}O~O6J8AE<mK=bH^%vZN+_5
zUE$vNHQ}8(e57b?O@^CY?MCjhTFaHjs0^DVpUw*fia=oX%gfN$EDED%c@_m`u!Fjc
zd&EiiSCp>uYxu8M7EjL<vxsoSHsbe@q`7^@C{^)QS@?w?fh{(j55BD2H@RYln#5|Z
z6*)V{&R9=?DgiWC23e`VSQdrm@e3hLBiHJ?0naCqNA~STNT}548~N{!H?SM=QeMGQ
zYsE=gk)YI|?_==pwShkSj8_{sONR*``oX@X24Sv8)qwcy<i$zSYM{EG@ge}SR8zEK
z=qox>;@bL}0{G=Fj`3;U`CSu$FfmTcxa0XQJRypJ$#lvW4w%6>%IlHADtixusiHbM
z0kg1=U$yEi@)*?Ne$&l^I(NKk6;F6WR3!{Cu#;50Jr@`;PS%>t@`O?3yL9hei<`!?
z*~w7PI?ZJ;VLj&<h1vbqkGPNGxw0w)AW^KU5mj3FKvNI4j>^0)P@=oS%Sv}g4^WMe
zpk$;-t96V@0!dm^*cn(|tCHC9MD&=G3^Qj=U%qvfRWr-;RDI)^=*Il<d?MinmQaqJ
zAj0Ryat-{3olv>z`_|6#vMzJ8>^aF7m}@~|EL9zCpA<DfR4*SBsE<1p16ns1wi*-J
z_FG+d4yOvf=ZW?IA8xCs9iOS&dx)bs{7(jpZ9gGQ=VZ6O3_MpVy7&nMI+Ngb0z_*z
zQ^)i5Lmmhh_L`JN1&M~;m{VtPeWE@W4Wy~(Y(u<XgF}4w(PH_W`)^7`s>K9~d};S5
zTU8_=;^CGQOVGA1QFQNf!{~J~MmY-w(Ee~M9X&ect{fBy0*zXD`iE#6z1$SNIXa8v
z^Kks&){^O}STbwQjCTr%N8~vk7#44LY>HK*O-m5&_=(kqJ#gt@8fP6^I65}oG>%*K
z<U6OlQwzid`}ng;0Zvo-3rHP>(aoI}F&E|eo*W@N%v$&oxQwh^3Vq;y9-S!zb`n8M
zB<D6ND0}$@j)Prv<0MJ#xZi=-t(pd(L)_er@j!$8xC7pQ+G|~RZ*q}jf^U9hmw3R2
zQ&a!?*?teyBXWcW=LL!k8tw)Hxl&8?PH044QQ^3gYecZ!%H(ksY2ioe9&J^e)NBKl
zJJ-^Bod#9X`0d1^GHq?VO1JNo0Qx*Z5s?8Ksq4`~UR!{n)@<ZZ`01HW0mT?20jKCB
z=scNQdefq7Z%nwON}uBLhJA{pbARYTO%AqBQ{eYFz3j~{nuD??s`Z^lycrN1rM?;d
zJN{rN-MA2&Hk-P~5?cdXm)aVuyvc0C52CumAyfb<a;-4rET7#hjwfX3a+=)yZw33i
zZ-c@372gvYFtY3U$c*lNJKjUxwuHk-fdjpIbtm4ZF~2OZF{N#D@%|ewK&guSXuq~H
zs#_@<kY|{pI)-cq`{({{O|0X(1bJ5f@B4q(^{Bq~^@qPHe&a+>_(q=X(y~N07VfjL
zEP51u4Q!^|PlJztTck<k&?Fi|8m@+(lAp#=H*f*+(8fi5-Wlh-71w@Hm!>w7nmNV0
z)5LKwdyd{8okHsuLM(@E6jK4dTwM805m!-*vC=5Co1cu7b`0L<`<!DB$+@>Mzc({U
z*rueN>Iyq56L&9&y?>vQ!Xgx4w_-C(wY9zjd?-te71u~6i7`9Kn8U|2d6?|wGZd2o
zldtq*nP}Wjf@QxZfQX*mIKmGK2Nsr&G+~#x5%YujT6KOYE%e;Hnt(TasTu~PZ)CbS
zA|!X`t5c*|g23KI+ebSwUbKkeeU-DZ;JbYM>$)FzCENEI_$BLTi7ihY6KQJ|C~PdP
ztKI4<H1b!kVy<9RTJ50=4+ZhDdneVcnq>{+&PKj&fUUhw7Tg}Cf-WS}^F5L6#sWx~
zvy|vPV;?8a{HSlQl~GHgJAuDt2!}PSS_W`tTHyekcz&VmSpH-}J?nm}zm8v+6Xp#b
zt5&r=dKzlr@h#~6!-k$qRopsESdXc2j|BRfR{{UrvtRs#Vg)T7NAphr`)Ju^%(OQ7
z#37aZ?zd?9vi7Z<h$rc5fTa-v<bg^i0V?oZjJvv<4sGCW&}|E>Wj_Twcv2(94+Zea
zM*c^ogmF*{XR!ZRdIi|ohf09aRV&Z^Fc$1jf8OC9yM#HnUx=Nrk?JX}8vN?wC&OGe
z?XRP>g!vFRY25cl!rZC;?Z*MVrLmBbc9<$3`k`HFdCQ_9>w<1OBQqS8F)a!JeW@pd
zAm(D~DSrKYjYi7&?b&@D#aI(<#S%oc4Hkqw<OER&32Ja<OKv5~@0&QPu2P6ltMsvH
zkn5|3n@3pb&m)m$o$-8*_hsia8qP%z@d3f{VHVi>^(sc)2r*&7MXg*i;OHopVgiUJ
zPYPCS03n8O3>CQZhoSdwSM39pqhpwzi~8E~bFf@XQ<kbRN#EUPi6gtUD@abeB;IGS
z_SgJgbruTaOd1>@1|WNW;)F@YV=I{bw$r5>RoSPfD#w}gBp%-F*4YKzrsW7dVvhuE
zL4T=>__!oH*Sl9qdv%ZMz0(lOrDvg5-sQeKp$)Xvq!AE269g*;h_9z8NtkbuYw`Bc
zVpSSJ$2aUVB#orgYWD93RE;@>CB-QG_xr){#JPgswSkIvn_dN&qu)<Sz=C=`{oYfx
zxtd1e46mcbDOb@o8TFt5NEj_I;2pP`D6du9OX2DOR|EEaUG!N|K{sRVbN{>>0xvjR
z%kyFE9dOfT%rszo$oP&l8JkeBh1u>g`0&BCyn8p^EQy3CZb)d)B+(!Z*D$+159?Ld
z#P&nvudf9{KvBuKZWqYk3N$p-u6|*d+MT}0jZQhT6QScIdEj%}b%_@cYqVDsGZ(be
zzN-OO#gwlqLybsH&yJy%uy#zP62<fwU*GdbgY2bRS9`cwAI{(VMvIojwyOADWfP!J
zl;3vh=;!P8)XgRL7_5qe?i0U~8o2Z2pq5f<DK!L1iL(b(JnQy-@N^V`#PfqLfw7Cx
z07w@wOe<^Ooo{|%g)4jk91In5z5gMn!0+k}eIEgso8rOTFJGXDksQ3C5ZqoR)n*3R
z92P<L9=2r#!lD8Xz$-k3ZaW`Mwrr^bN?-YTeYd$m5Es0eE?7eXmnHAv(lI1NBN_pK
z`Y=pLbC_RJQ{Zu}5y>A@%U^_;<PxMD2r>uXxLX2_3*y=HJ1bWUyHB@8xQASEdcI7|
z>^_?wAtkm{A~V)@FXe$gJ9WXD7y(wlF=SVntk9?ocut8be2bU=HjMpeIs7IC@iohO
z-EhV^h?68RO_SI)&@lzEq>k``7iE?+8PraD4Gclj0wG!YyjeQA-Hpc(-L4wo?w!Py
zsePXV7eW{Y<QU<<O+}bAoW=XGx=~1!UNVS8&e%}DDcAVpz#2(uXTg*>DeHHd1jFee
zig|gUkZa!!Y2>vO3*$!iy^xyJ`hV<wXH=70x2_FQil_)E3Wx<X6dOgUDk9QBNg#xd
z)KH{L--3XmfPnPgF^$kd6A%!QAVoq8p@{U}YbbYRpL6zh-@CtizB|sZJI4OwzzoZq
z^{zG7oX_*jXWnFruy?Og>~-k$?Bl8A$A(n1FgW@EzH<|HMx6>M{-566UX6ny9nXL=
z=gu@sz}C+IVfPCM$5G)#aO-;B%?%klD`KhfQPA5?t7JmTB_%ISp`_VE>&nB~BHPWD
zH#GD1lx-*Dt(D0S6_fN6w882fVvR~W2BSP-ZC~XZH~Xf6(T|n1&$AAei@t#Mw7WHv
z;oI^N1erUeVE42IoMe~BJUawXrEYyyZI7ING@dk|HE4*b>4!mZkx%!G2<+Ntr_G;Y
zcu_uDxwA&uWN-KvHa)+*<kT4;QaJ$*Y4M2dq}$0@5v#{j37zx5tu^weWD?3oB9woI
z9@+x}r(v<-hOn^d&hJ0S7AYY)W&BfKna7?_9lGT>@<?0X0hrv^FHg19HKrdsvCD<c
zQHeVVychKw4i_u3yVyCBR&U$&l_v55w|s05plgQ3dc~^sJZFm+i)cpK0CK0L;XlP_
z9IM{Etovd;$FNwVq#l(LBUU}gt7!|I#}U5Y*IFt7f71M6nC_2=u<t-UL+LRJ{NZnq
zA{!1=`+7GB(D$1<oU7%$qt|e%-p4?~UpcZSyQwqf5`m-ZcX^Aei{NFav)oqO1LYf~
z0H~V2EaxQgWGIBS9Q|<W7NlTsQ(D9j3<r3O^Ny@R75%7@UhiY2On7ydA(XCyA$-2O
z+YGX8slzfLsHcl7HZ96=aQ1(Q^?vfTKFJ9nk+_0gV48P3IazA3V*{{ZuXB)hXrN(~
z*$8^U_u6++@0)i=!fs{{N*6=}{8D;An9IIWd?$TSt<NXuzP@$d?4m+7k@G8QUZ@j5
zV;8L|W*I_`jm-xobDYJryIN5r>UrX3K;`>L4cA7c>}`iTq@}xW4>q@l%BPui$b;;q
z^^R}<t1EC?FyIN-pyaIU>y}NS&_9<IX2AraiX!tnF1zCzz4oDZLNYjZtDoow`5=@9
zB!UvNS`vz!)Rt-VoI`~mC4nG3_1{;ZW;BZ-1RnLhwGh~bp3A;;$Y<A`fQ4r{Q9r*g
zcRv&0qvG6PR#A}a|MvCV-2}IKP5%8fWmc~kZSYswXf)#ITE%=-#p}7pNJE7h2nl#B
zKaclx1iG+zdXPa^z4e2d1GdLC@@K=9ji>1qJH6eS{B$&;?lTE6C)KgJa`(3-rdEu6
z)++|%qJ<FgK;rgQSh8HQEXk+#D1R&%GfElP9Oq>1zbu`6ZEBxMsKnHjiuvzJ9nGrZ
z{Z9i~c<gd=?qGlyG~d*7iyZVUZ5~2;%kkfZD=ze0&hOkofSq-6PX<XHU-_+acc83N
zb=EdxrHh&o*-==QPue%!4U(6nGJuWEPG8Y6J0`R71AK`Kx5ytJ)Ldch$C6cpc?>-!
zFSEK_D9p=H(-{jqYxgP#3?#ndgX0JMIjf6^2pHpX%l_kHU>OiN4Nq1jK#H+IIVrB$
z^NpL4i}hD{z4OFE9)CLiO&Q=0(S@g<JZVxyl<oD)Zl&>J6|MWz<=?1~vQ=k`a_c_Q
zOsOAJT!0|dr$o(wV<V)5VkgN;=V}8L(G9jDWrujr&ATmm*nmTJ3+Nj@+HwTEQ=zFR
z<a@`#@%&f@Ht&p+{>8HCxW|AV!B{HFU+q>b=yr*zs3NUGPq|(P%>6CRi7z0PYnzB~
zkGe8pl76DGPg&BIq$(a_sK9%cHAKm5gon;xMzja~4>mb~?Q43FVN!3)C=FnIynb}A
zyzx2K{&Sf`L0Z9__j);r1!}JMShF8#m?SRYyPZC5sJ{o4xQ=U;8Av7V^n~ZJSK5XR
zVAJ`4_I}ts1}Wd21$Af5=z}5Qiy1dezr<eoWYm}6_Ez)sH=67bQu_AkLH%KBgJv~-
z5pY~33yv524C>exciQMXN1kF0*!Vf=C<(^Ss}6q&X>LoCQ$2O}ZH|1}g+dTYfwd-r
zXr5rpUfos39um!3t>)Pd=2I5#?NS>eoek{qHHR0GNrfP-DAM;mm3!m+5#(ag6{aYX
zSn|82OAImO^>WYZiIVUu=PU;qx43A`c)stc0pezJy`kPIqx|vksq}<~*ef$5>bt&c
za|hLex3-5j<gO`PQ{Z@TqTbKsxa32v86Y^w|BU-y{pG>;+#7_`XX6iL9E~t}eNyy`
zpC~7@>-8S_d-uWzroRvEw%+nA+;+A1sVFS*bo1QU9KBp2IVyf@-pVs(bAWYICS{P{
z(k$nP4nEWtPWWci>_czb&5WdJyLuePkRY8%lmdd8n)!gD0-XhF__N*>Z{zMG*tW~y
zJx2mo>A{Sf@S5aFB!MLbNGG3lji7g`nnN1`7&#7C=Xn6AG-7yWYY*(Y>~nIB;b#W6
zrw#X%c3Zys<T-(2!y>j<mRQ+Jc0avq&^Fe_@VLfeJ+WwdmX@our+HS9=MU5kvSq8B
z8uo`7C@1H*+Ni}|=N;DLOg+WS9z1Qu?kZb2T><;RLEVYf*RB-<H&FiYRYV~bby(iN
z(Z;7D&m6fXskkGj(AYQ=pFikBRRp4CKhI8}TTT8bPI*w}Gb{O0pY>aRC`-jUr8ww6
z3|Rg}4fDHDu!HTz9Vd>%=-vV|MSb{aFI=4wwrFVPe?3kc(RdgAEmPsaLdwqQkPYy&
zH&9l~V>y?pGPgV0Kb5Ov#z>-<BChfVj7YqkPToba+<1@3x>_<>XAd7I1#u8pUvRn+
zepFIpBI?Y@h6T(C(7|?k&4M+a7NqZo+cu*5`4GLJ+-|@U9`bd+qbKg!86^IMfCNm~
zoaMkT^wPV?-=HiE)o&g`PZGQ0c2rKnstSA<`Z2+eN`1;!^kW2IWY@9f<%rg+DJhYd
zR!|`q=^cbN?wpv5$?eW%xE}`Q&2+hop3+R7ZoR!$n7uP&Ic+Q}CtvIZfx&&DJ7n=n
z6X<*B?Qf74%UoXTRVPkZR4{Z%qBIZWlZ=pKqeagwOiJ=f=VwdZ5)Nw@aNnAnKTzuq
zsH-*1a#miXKC(Rl@mj)rYr#p2ZED4*UDkKCQ@hbrY=(cQ6Nly;dz2!&NyZ)+M-!3~
zOMj}$RI5MpWqC3Y40ZJ>qvX}(u0XGq*gEID_OPe6*<{4e>lIm>La`6ESlQ4vh?TJU
zOC|j{7x1D{MXz0Vj;M<0K&`xR2ipaT%;E<jGFH!o%eJ3MryGbqOZb3(@8D_|<ZZbR
zVwO1X5B;qIMBB*afMtbBni8YRj@S^!lQMI$lA+R#@8RDoMStBb@|TW}nS5n}wlJ0P
z{q*^<V~$zahr*ina-V11YxUV_!o#)Y_S&r-J+Q?0H!ESvN}+|HU|N!Z(~Tr~t&uG>
zBi~oB==RFVYtDk?ikaJpv0K`!IB0Gq?{N%8j$KoA59M42dl}4h4{n6)Ewa)qq+<!6
zFicRxRS2o?p`3_CTiw{E;&K>KL@Y`Ahs93$GG!}Bb?>CRBlqAzo-OUrNYYzQQAncb
zD0I)y)sb`O&E(bL`#d|-l+m?kVba?i#|pJQH6HFMxtHyl^}XMm@!t)YbWFI`7p=s4
z{g+0P7w72ujI@M@AnPpBJ?kXBv5<;j_PHa~0u4zG*(7V$#!U>1A*28OHLkvH@V!!=
z8qT?`sK|zqTe*fjsJm?e)br&qKUC2MYWJhohl>_>p}uMi75IIA6}CfSz1O?zY8f<D
z1z2Jb&mm0r1C}W=1$W=gmY_ti$x$o20Miw4N$a$Z7{0~D5@oJ(_T6-A)m+`C?oh6t
zz|tk(WX6*I(0kN_JY|Q@w8I2OGhoe%cIW`|PZ0zM^$uw*1ePV-9ejIK_cdP&X27a;
zwrRA}tDREnFib3#c<h)^yKCd^{o(?4Oy6qjnam)1z7+37^6`D=^Q~9HO1@yFGh~N+
z;I6Lwhjx!%$0Co^_4O-+eb^uG6I(-h2IuwKwfR6;E#>9Fn!F!y8L=p2tQ3lk`d|gk
zH`1jf1C6hO8Y=3mpQ*^qEw5r(jA=Ei(w@JJ9Y3K(ta8=@D+BWZ2~ITCr(v`uX0j5d
zq;6-pHJ^F2IYy>s7yr0aNLN$98|;Dz<<Rv2uNk*T#yqYq9S_e+dpM7*_8+h(_-L+|
zsZ8JT+E^G7vnpOwiG*=lbjyf)o$l>H!z2Z|m0m}UInejqIo)D9ewO(!+~+U#z#lI=
z7kR*##?y~sG~UZgpUvH)zagY*R3BVm^eCo<tNqKujnLnAU2MP8k3Qfz5}7RRsWjb%
z9sb6ya?5E<<$Lu7VJ=D6_dwC7SQp4#*n(zhXcQmxx~Lj25^h`44~rMKH?ZQ~QC>}F
zNqZ%e$`2U9quE#yO=gx{?K}hg1MlN1*=k9gAG@n>pZjRvSL%RIUY+h<$3<<%L%VVM
zm89#x_#wW~J7iZnbojfGmLt2TEEw(cy$$LZTlqbhzs4d##>@Vo$Wy3QuhIS8tFP`t
zeGG_2KfHX^+RrO2I7RQ+n95p^TkSa=Pk0+i>tF)eN5Bw}Rh-{$f#M2_!K=g4ew&CQ
z%b_H(mLphaLC)ACe8r~PJi%eN5K%de;}(X9T-b$^%w=@4d)DtViPM_7XJ*GofrR}O
zs=|8GqA}ufdfJ_QQ#+u9W@kPRZF2NViVvq&&{4^i$D4gPj3`-Y=kra|Kv@(p(M3_X
zu_trSKcT(M$)a(EdYp0{`|L941Y-H-u`+QYQDK1D^<hWAa38#1V#gJznN6w-3kN-m
zK?2uBs1J3MwAaSzo!Jg;_X%TPt&nr0E1rt7JgqWQ<q1lw;N781ZX)ylz1UcS7q|=7
z8c8Dvf*)9?5eNZAJn^DBo_MhChabZOIy6K1K8ar??F<Jdhae@4j5=laP|p&XOOC&(
zY$w?4XS}bPc>BhgWTnAgAS^a4GI6+0tAxUN<pML+A7fK&-Seuptno~qxz(o+D0i0E
zIET_As>ZVyl5?eUxYD1&sfO5eet@*u)WqBi`Y&ww*QooK&+fW_rk!AZ6+ChH!GAvN
zaSY@Nf6||#=u<l9pL~MooqB=N_*t=7PRjv7cYz<|NsON3>$j(G+~)+GM&E|y{KqH4
z)!R!W7U&015?cU<6A!&f0K)W~MlhBwR*z@kKQ4rKszyMOdaqL?VeT`l`g<CrL=k-Z
z_x`cJp0?n}pzZEs|NZ~VlWJxB2K~S(Zl{NT2@o3kJgpqm!-Wg8y(lOxy|@X=Pa|d_
zkz$a2Dk~}~YBUO-v%9De#w`Rq_tmgAjj=aOpMo~4ngU-cWssN^W1uTAU335US3ec~
zDVR-Q<el8Ha8PQC=RV(9Y~WD_U31f25AlS*tmxk@_1yqKV?Pf%Py-2Lt%0yG`7=U*
z|7vQY^ItM3(eu~6x18^6O=Q$_i>((caJxTH14^X93C=S#Or;5kzBvS^K?7S%-7!hb
z!|0~_zgL)3xZnB*zl3s~wfO|z!9{?MTJ-my?mGAD;$aq!8U2?Rz~7anRm(t;`I8I$
zA_WZLq^>gw=YF!vN#X;_`**Y{xvx%KWat(DWmC}JW#?rL0|R0E%GGEoFpc-7`_fZ5
z!6uG2wVrm6wTh-d1?D0o;aZ&_W*Y&dqHv#8v?1MeIncQ`B*z^6ePOE-4&<cx{64#S
z2{?^^1%&Hb{{tiRe|O-F-kdnE!)C9260-!X4VOM$KmF_11z+)n#H9s5C^dnqT>yl@
zJUL`D>i3?{j=)b~<{+;vg%G6%8t%UQg!BCZiv0bn)X)HU{NnASFn8e3>~3`W?ccrR
zfAceq4%$-B0#`b2;Ec<C`tUEg=>M%V{%@b`6wQ0@c}0*>R0F_1=>u#2_D}uynb_}t
zO`hg3I4}oBUN~IP8GT`V{l8t8fBn37HED6B#1kynKTG!Sy_A2J?EiVc{j+5MEZN_O
z-G5@)zZvxZj7|S6**{D6=Wh7rr+<=+f1T(2ee^l<|HYD7Lv+}<bCWxb{wImvCw9KJ
zET<qqoLtXq2Pki`a1PE*4Nokj2ifxfEK`0L1Cra18w_H%K+R;PN{5zuWAQ(E)O`n_
zCsR$JQeyw4-v4%_`=?s@7bpB*ui!sR_Ro_2?S=7AwenB3^7lvMpVa$bhtt13O8XA{
zvt<AOEZN}I7X?tX*??btjhNe1kD5}vxIpmiwHQaZVU?oT*N5cXyo41ecTEhuU-z{~
zdHHHqvPiDBA*a$otIWLB72o3TV$m^8y{qMh;#0eVeo1h{Gn}Hi*Hk&<)P4AD5Vq$u
z%dQo^qe`u3-J<^&Ax1-ohTwt;d;bO;2_DyqWT6NrPZ=dBE5$3$C-+;sP{plZTH9_O
zhHF>l!@5nC4W18sFlQ=Czkzq=<u~h9`b1*B?*$i&+G-ibPx?ZwY!J{6Yu{wAHTT&(
zY2?4y#7ABMkkswe@xKMJ36EZc2x!}cQ|cf7NyeOir<i*0O?2GDTe$nFv3^i=Q#XAY
z#8s{Nh)yXAUiq-I3U9)~9k4Hivm=sSmGdQ!X(djtLQ~)w+r3S!AQBN}ix!{?HDz0z
z(`So$%XRbQ{|1}?*Kc$0(bfz9_v?ko1c|wjV@ZMLpH(89X4<tMby}ZbUHlD!zrE4%
z!Bq09)qvo@Te?IdN(<Xtq$Z}cNUz0EN|yf)J@|pYd0HGtn1Z?pB}OW<T_j+y92@$m
zeIdp>dA)Yx4?6XKqgbz`((vxsKWK`-jKLHF3{fY08G?M}4~6v$K>)TF>|<-3U>;4#
z#CQpXqjdXtR-MV0SK}Ymd8{&4u`9!DuRKrb>^DZ6GiTnDezI5+GCEq|wfb=Hkh}z6
z3xSO4uHT7fao3CSimv(i=NJCVPj}NmM@K#D<-di_ZNkAr5We;ke|e8j0eulgmwV(P
zA`2Cja0JR$gKH~?UJ#lRziK&(f=-Jy_A(~~8!tQR2JtaZD=&YElQXwLsAbB_IwX1<
ztemZ3_?^u7KVrZqH`?62kNThj`wv3T=#RAkueRp`cud>yil~tLf2{CV+9*6mjT3JT
z@~uK_GGWjYGp|2GMB1K1o3>OL2{KJE`**6Nbkn#m5~#eZg<Z{@=6c+e=<uADkhg`c
z(|r%~YyYwof822R`rj#lH~+7D$njweR#(W(44qYEDrsT4TBWaFWzZFEpF0rH=Gk&U
zbxQQT`6}nAlwk*xGOV+IheB{4Gh(B#7dK3=;cciN?d*Z6;U7=&my?G`r)?k4C_tBd
z$o7W<v!C`oxdN4{jh~E@q?|Aj%eGI2=C5mjOHV|VH`P3Gtm66-=m3r`Ms_O!`aBC!
zVh0y@2aVG=Em{(d%4zJqm6cVOJFQ<HUg=TXk!NTKtXI}Cq+9!c2}CZM;GO9AAu+f9
z`0#Gkf%=n}EypQm_n|C@rO^)i0=xDhIr=8!Af^@xeO~_9YNPybq&-a3dy&Wi>B2o3
znZZ%}_o@XZq+YKI<6Y~MmhkG=BJZ}`*VQ(z*w<Q5o=5zaD?DG~^{Jq2ge1QF_uB)I
zcD&$qCqn=e`9zf-EqF;3_<yzbYH>?F`*An!y7B$d6N72Ix6Hr21GY$zo}V;U*9W-x
zS@dtE?5^b8bR79=R1P#%UqNR~mT}!TUrjt9;eV%Axfyjtfyd^wW9%P$3(#=oe1Pf1
z&EDwZ_^;4%H}&{|`r{anp~2x1cV_5lyS0SgYGY>JW0?K84<*|R7s`Srb~lzUg>(YN
zFZ<n8hswk49}R{-dZL>4C)x0xB?!&eWlTtXCA7Y=3xM<fy21Yp7aJ|K-RA}xDgJ{X
zJoWtt=njM8fYpIf2pB8IriCREJnZnqY?|iVY-3^QjKxKrsPLfhKX)_Y6)ny^RVX+^
zcVfeJ(jzWy4^H{u^u(%PWUu<O;X5{JsEY~p#|L%oSF>U60^*N$JTA;8h`+;9M59gJ
ztgrSX#J56U<I8^k7dv@1m}*er>oTzztxk&sgLVr_@__2j5_+=H3VBm+6o#4V$WMAd
z<=aUnX6Z%S>OM(&lRAIkND*#OYie?D$?9d;(sy)~dm-JcsU@E#1)&6G8Sh)y{@77}
z-SHYUF8AjL8a>)+j-SeJ;En`5u6vi@jZ!EYRshUq%@WO(xy!6be6*dfk|3rU3Tz|Y
zr#|GE*xGsEiRN2ChWHs0xXD=qNnxt{laD1_dXa0?`Nc6jj?;3(`nyD2g_plgCn0>L
z>#kgP7xS{0Gj41&I*)wmiHqb+^+V>VM#Ah_<@vRcO!!4#BlEbHTb}R>daM>9)5xg|
z`-bg3lZpyV9!FlJ=(LN%NE@d(hMzLAW@e2Pf8QihjPFvdyNX?6I@XNHzo#pXJg@3P
z25zp-to+w>1h%#@9VFqcXtBoUZ=<H23s+-BQsT<P1Z_+kEb<5;S&D4kHTv_K^TOeK
zUT}6MPM^D;XL>T?BqcU|Dw8j<Z*6)kdcbuE_sWZ`FG;&d6Rb&Bj_kk8|823EvtPE*
zxk3pc@;+J>!jmD;WyjFce6FIoG;j6_)q1G>yoNb1AHp>+*f!rO8`9k6<UiL(@UR)_
z<@WK7liDFO%-dA$m^3A3H`I%ltJ~~3lcu9)StMJQt-A8KoG7lAf|}=Cj|mz?dCG^(
zuEc-;bkg*Ou1vD=`m)QQFhm)XGdsL?ISR~KEWE~X3CA+zMK&nuLaOyG%XTkIQwoMd
z2Xh$-RPx)bvrk_n=Mi>XZF*L3l7wTco>pRXORmnDWM&zt*R`eeE989ZMj}G7Nd_c|
zVvL@#cUJ*(ftTvquwaY#C;iKkd$XlF`L3qN^_&~(z3s;-+firzorGJYpp`zo<!Z1e
z6)c}^&8@OEZNrmG2DS8VeG~c^GjcMwct`K-U<_(l($9N6E`8m!B9FXUQ`OzGN^*-T
zn2xaZ#5J$?XK1Xi>#Zx^ID{6in)&kE4Lc1Yvq^mtfA`KvLX}OY^;Mu`>i;UP4h=+P
zLC`w#0(Se+I%ZMmB`cRZsgXiY>j<MxPfv}1B(J$U;6#!CV$k5A87)&;lc7a4V1{De
znk=MW?!1UO<F9H21W=Bj_R}9aO;c^2^IrL0L$%ohVjP;rF17kFbNXJZEbva&I`ij!
zfxmntlOD}CEw@_ovHUI%U*7hJBfWRqS`59*dmI)byP|Ky&VKwfmN%|D8yBos%<5`&
zS$1X+vh-poKN9v;jx|QUW&G?$k5#{S21;c6t%8O8oWDvE$P3lErLHdXOg~>m-`pfg
zD*M?T8^Aqi;pz~35)(cwxV`+P2)guhgzcWjP`SS(F*GURfm(v?kH{3^m>WET>S}90
z8v8%;GE0ihbCzgCV{qr3@%!4~o<-rjl;}%T6fxm;4TRBP$G!F>S;t-Ub4$4Lnk_#C
zc~{WRb9oxN)Hg0**22K(aH*w&am`wQ{-I4%(-Y#;m5tB4Zz$EO7GgnbwwhMa>f^Z1
zVPl8m!H;;XvN`7ZVQZ6}Qr=o47M@pjci>3B;hz~~<Y+7xf_U|yu7cY1+1n0d)@8HB
z@{Qlwg$wUS28;=wetIwFgo3Nu(Puh33p_l+j7*WYB<#0btS^kulVNrCi#UYq?DL<)
zqc@GeSjSbEm>zF0n46QvDdT;UaQ-D1zX(Mf9mJ{eB(5&chfXFg>gpb8eRdg^H+X4W
z_6Gl%u5-O54_XE?mdfm_>Qa(8TG*#ob*1;*Lfv=A9jh92pT7k<MLpJY!|a@j_Uzw2
z-VIya)sN2(W02V!jC8ut8uInEOKO0?{Oy7#*Lx4Ramb2xi+^z2nCnj<Mh(tuSZ!Z3
zOw3D*nc+PsY0twQy(xotUVXS(ariWUGXh=H_CTkprMNn=r?}nm7BhZd%bQ4T;xviq
zm)dKqaETyIlG@ah)kgMgH0%KpBUNcQ9Vf^Ba(n0On~~+s@5u@?ZTHoBi(R_#cD6o-
zkP){-6*7IRTNm=DT|JNkrOA5eL2CMaO29`Rwy9l%DDTG{{!l`S^)0<9pG2(&3q~ls
z6jk2)zM$-8mQC_GcyDz%`(n~W_kAckj+oQ=V8e2$@AG<5RTAS_hHvZzS4Rj!I`1}o
z`tnVwUZtk32yFtkN6+NoE#7~1Ysk@VjeD%LTO-P-Gm!c0)7|aO8W<4%-^WCBMqE}N
z0iCB&qR6hVX+hkO=6L9?Y_JWjXXFw4H3LDAEEL)lHj6#3_8G1A<68QbB&m&2(gN)i
zS^5>OHAalT!FhlbCx)hE1nwh}Rz25O_h$ho??a>>CeZ(L45b33WP^sU2~{+A(=s5`
z$}($;E&!6V*AxpaJaLO!$FqB$L*F^P65HW;6gD~~VLu>6E_KKdv1)(NTcW<5VoZ=`
z<yU(TE;%}L;CopqVwbqH7hANm0CZDLBaM;%J7vJRRI8UKN(^W6De;ceNF9qTlMLA_
z4w6lFFrxOaxhX38un25*1r7a~35Z_%aTxtYRVdPPpygbzWvZ-<p7f<%{}s_{`3vkt
z_-CK=yz$ac3P07m1UX|);ZVRy3SDqxD=3cVZT0RTqhHWu^W|>($?7&G-fLd@H;*Ki
zrlq3}qtpH9tBjz1^rc}l-S^c7D^;`mlO6O3Mp4pUyK^fuyz%H`Gv_N@-W)@|6fmO5
zE;ZLLWx?Jk*#{hh=@+R>p6QbmJuhldch}AO$`!;})C)|ZXzVDGz;#U(el^eX$2V*N
zJDcUg>WO2rdntvHHFp@Jlh7}&lqkK2N;wKJ!ObF4WN&GYS;~J<X|CmCe@leD9*ew#
z^z%N+R(sVMZ{2ZJ|AK%ATl+1MGDKLRxX33CLhljSsAE;oblf~T0A=TCYusgr<8Hs_
zI;*?sg$*(4^g)Qnyb(=|8xY>^PJDU<;+;sn^8`;cNw_v8x?S^HS%6M%cz}gi<k#)H
zTH)8vh*5&}5bU}i70{uVDt*{5=&XhW(&u>?`0{JtvEZ;%TCna!&$Xq-LLa}iF5dC}
z0I5Oc&L3efD4bW;?3Qw?xOTSB;IM7fmgiXMx>*U2XNr$(Fh!j}^@Oe~>NCUQvd-el
zM{0SLQ*1qYe+Z>xdx{>4>E0n(Tei0BJ^Iq3zAdwz+pd39d(^n^u5Yk4yn1QpR*W#?
z8JS>RTmWkBxs~~Kq93#_h<z^1xZ~-@#Hxe6^63k`z6%47`}d>E3vBDhPP#DNWcnky
z{U!GWpXI93E~gb*2{fgIpQ>CRh?HLIx!4m7_Mi%pxRMvTH>uu;jlXW}2Xu4SH#dQ+
zUBq&Wq&hIwdVh|+Du2@+SW}-LVFf~S#@&}MK7jUSBAd1zFL0A^yxGR4CTa9(-x+C-
zqMm7iypI=h5*?MYtOVaWff}UoM~#0S+0h4Fh98P-6E@xuwGG^}`amCXKK0q}4ZW$f
zF3CoB(ASTg1a0<9P8)n`coYQJ<y#rde+#r>8I=L4o*9rtnov7z*&hK_<Srl0_FMAy
zrVns?b(||34~EVu*#~jC#sZzZ5|G=5%Rn}ye72w8*;yf(5#L|EI;^a$?7w;k2n3%5
zQi6bt^-@2`zAx)nnEMzNKBi~-Gh@G^^y0dX8T3_)kBw`AM3d%@E-_!Sn5kA=d8LLz
zzgwa;u*-MiN<M^VoqI6r@%axrVr{5qsV&WPh6wDm`Z|)|TS6?{QE3123s^@P6<go9
z?^TF$-q+#7=(X<a#2>ad_l);5dd%eVV($~eM1BkfYI%864$iT2<JU6u5sizIB}=Lh
zLYO*Fr0(pnD;C$T%yYiAV`l$WPEmoDR@RjS;8ck+oT!^6v18TY&RTfu7ci}|kq>to
z>4&iGT@I4P5o@|!#L#A6uTnh&l9HY=wb?l9UR1_{lW<-fa6Gn5ohsqP6qxU?<MGW4
znL&3ZDiyUim2Ba6EA6kbqkot*qk=*ts?Z{&?p${0nOvu)Kogc_d+gq9UW1-Of7Ob4
z6fE6OXOaZpcU4cDQFj|E@Li`f2M?cEIGGb48gM6YwoBrAv6&Qglfm7!o%qagGYWRO
z_bL|honLo$YM!(0NXeZ$4)qCo{!sQ;QrMpxBC?3_K)Yaw_x>&NfeS+(y;2;O$B{;1
z<~3eVIIxT@tJj@7tC6f_59QLT)(Qga9)=ml-|U4PCvSdNmb(~a(|!Nj%}TgN-F-Q7
zJhYENU}#myR#2Q-NHs32E!lWHWzwg7Xq0ZK;fE;LScvIB-ARli6#YJQMUDr1rK{r(
zp}ip}WjJ|$Xl1i1dywQh*M8}?j0C~*N}=d0i*cmRe&QM$ic}grCa&Z1VL(7v4C|#<
zK2282qjUYHgUI_Ji~hl$)4w<H7@j$vBs#b{{a(SG&bzlfJLposna<s*r_wPQx*jf~
z(@h675hX|rbd6KHoTJ>kXOSwd-@4#499p<e_JanL`jpo|BnN|dG|CFJw>(@rr&0X^
z82It!9FJ>94;s79B<FO$<+kOtI`8>JV`zz&-`PA=wr&32q|i<eDr8<cU@P=lm=6zU
z4%-zh+y$k)j=UymSubCq(3b<1t)qr;X|G#7qf{PZ|LLQZOZAkYW(w1zs}d#j>!2)$
zsPhYH{-by~)UM}xYNX)adw_miZhmsm6>k1vX~HZ4rmc)2GD8Cdv=Kw70JEm2T{qF6
z%kNj4+G3$MGV=O|JOcBYx-jn%hTadVyG5g&)^6V~FIn_0IXeDfs-Sk$J8un}>$0;Q
z`g#gDN2Nh1fkKyc%qWlhhfux1E3@3z4iD*ex82f1h{fnpO+Eg;p1zw}{yW6Q2Out#
z07x~}m^nqh7P4Ki!&?KF)tg=$&*qE7YVT`;Hn&Wh;!arOWS<e#F?Boy`fiKd>cb~K
z@I1pJ`123o+;_M$_NLm%nay$8y*o!vk|#hrs>;^t^mtssl99O1YL97HBk=X)a0eq5
z{EiCsJ)N(^Ke_EjFoHt$vA%9_^AeN#;Ai<!1{wENc)S)~&=UKbPUb)JgkbTC^v?4G
z(ns#EPLlY|ilCF_psVyrV3sd_=Q+@T^U))qf+Zf&Tmm$KyrY!;pIYcC+}+a{4;BAM
zdmVQpMA4^A*_=S%)$GJcY;JyD;EiA`*}r>Ss_M>pb|~AI1034YDY^U3v7L1ChvqO@
z3b7x*+QkmLk)PU{vYIv?@n!1^X`mxm6vo?V>ri`5*4;#HDa|*bL>V1e;5f?%2RH&+
z2@ipMHu09HL-$!rvZEy2G)7HH*q1*ULv;4Yy4gmZWgdC~Q0YLPHkl&}r8~B5B9U;j
z_%GQd^q;QzI4(P{ecH;Rmc%5H{FLnm%c|Vum=vto@<{Ed=Vklf@OmqacrkNimhg+J
zh>!Vy7ELRXKe$=PQl6=@)ZiAKd8l_L%}X-HTu}Ap+n?tUc0q<#qd2tTqr@1^nu~6|
z3*M*2@>|7`sV#md?FxS+C0#UjiC0jc#mR<MJh?Q0xIM*y?L8^R_<9@Ecl^v|r%*eJ
zl?K=&`wW~k=qCp+7uU+AN!wNm^_fz5xFd%M8!acq7cA~&B3X#Lc-J0_>~6i5b(Niw
zn=O9U;?P6HnbK{4n4ps!uWOY-rkJtOif%u@WX>$BxQ<zOH%yle-_{)ZeR=N=|3sHx
z)J2h*_yNJ=&P#)=)qCV@Z_~2Tg$@matrg7_!^Dq|cO{ISo;_O-Yc4*iPf;>1$aS~v
zktAtb={PO#)Xm+2tuBHT#~%(74hDxEXMd<|LT8L7|HvA>FUC5dUmXK~x4PcoiaT|D
zFDyADV?~cS=gbFEW=Z*q_f?YHOFGWziiyUu#%5~d;W5f&*-0_UIb7F1=hMl>o_YQL
zPPTD#3IXNS<Av(hH+9VJ<#HHs@*Aq{@EI|oRrI~cAvNQAb(*4QF!BEh@43+Ekk#rb
z8)e|IHo?w@Vu;a<96~LU_#1QG8i?Pr669K|r8Y#!)oy#wTy9nwZ1!E*G#ZPk5s~G-
zt)+J68QyKnD`s@I=gjx)NB+>sGzh{B4Ko`;-7mJ`O}HQU1*01k@Tw1%G=%y+S@}7~
z^K0|tU(nI|^ECap!Fk#VZvqLdM-jOGl?%<AM;7W>Vp@_Un}CS_Ds{HR&=HAkC(#Bw
zO!nlPYVc0BD_>I$bixq7gPxU?L@_Y@1@yvx-A{k+{N>A+mp}tr)1C3e$V3@0Q|Nn}
z=M}EAehlz6_ucK!b(%RzuJKY}Hpx)tol4yRVKlJ4O7<jzN+Oc<(GEWa+ALU5?qyKa
zF0hj###toCwOeExL1l1+<6v{70L!$`sp+wF6d90U80pvIqv*Qk%BO`B1TAT;3!oeS
z2HckDXB=bbQ#L~zqHvwj3z!l()fBPg;(;@JM_!)#M@#BNM%Yu(gU&oaktN8|#;3r`
z9J6R<jgFwzlD`4&Qpn}n!@EhY)nO<00z>1c09a@TQ!7Sp|7TMRZ5=!GLH;r-b2oYS
znQf^HtbaJ>8ebJ<zPI>;p7c|v;v<Y?9iz{>PS{J~SAP_02pqqheab3_ML~Q)D+><j
zqi=eIdwYm$sw=ObGv0Bw@4u3@q*iJ-G`(T3-IO$Z5*mQ%?bw@T-T9GYtDu7&X~~eF
zV-u*AL0!}-*5vtFvJgneAz@Yjeqig_$GmvWQf{&VcB@M$Pnd~s8F+}x*ytuS*s|Z=
z$dFM<`T*ClESnoVSYpeqHJd-h4P$QPjwVC{_a^2Fozpol`1EVv!9ckM5rD5UA=i`I
z<a<RZ+dtf{YwS7HIaX4{BM>Zk=hTkm6l)6^@R4G0-NEo_$eO~%ex9w=D%iwEYm8Y<
zrrmR5=q$ch8_BHww(Fg|mQ&p$*`Bhj#E;0)se^L|e~j%>OeGqQi9Zm!W!=-79EXM;
zPj4o6*+$&rN#gouKJ<!SeTp6ax{(_tOU;KDSnL0^DYhlpvLH?$+A;{szFB0?NS2qo
zy4R`U$6OLEq+^zrl7&1uB$crH1l!Kug6zy{p%gBaA&rCa!JQW>L$@FJ-{_LCl#llm
zz0KMw_`s?msCbaOU$J~r^irjM#tR(&W|M(*0^PlmSKH7nn|xWyqAlBg>}Hp!VQX$w
zK7$<0p(Q?v!#JQco(VSUQI%sKl!S%}HO?JW*0zs0#<^4oc>r^VJn@_&u`PY2Z}L+N
zB{?l-zH(ap&JxqensRBktyvLROO_S|`_6gim-|8IWVYf0H)l4K?P1MCTwT{%$0GYy
zQx;sb^cHtg6w_(lckKtF%8Ec%-0<DlqiUX9=zbi}+*+dooI3PnmziNZ^8RMmtUi6~
zt>-*eqU1f<jB~ByPL3<$%rI6Fe`i6eXpo0iU4!bHvxP0vI)^Q&q1V*}3<j26e|pR^
z_Nc{|zy!7In`<pK?-j0$X8X1{%R)MKq*J^fKdC`+>`JR8cWXpZrXJ&`A{7nG(87}I
z6tPjKG}%)UI#E}(*l?bzFVV@=ZLZCoY4w+Hm<*IT#iP!$NGsP>Rz3+-@IEcRda-OX
zDkvi3CMfUpVUE1;fm5b<6yJU5m&cJq7ZC=kfv=|832c#XX8Ae)6(*rV!z5;zfoLxW
zSZeKn*+?uXCU=-B4MCV}zr2{L;ZcvuH*Fw>D{#l%oCe3z?|4K&IHn(XzAQziY+o{q
z2L=c9HE7WAM^}e+B=H8FJNZ$a1qPoW)@s`o66Ha#(sO(lVE-`mT->&ez2KFOYTuvN
zgxBW!5g2PIZWgreA3Y!~W~g-pg7BTJL9wdczPG#4AWID3FgX3q8k+Gtfz<1=T;~AF
z`6?XYE{ILWB?!B+%Vs_3yef!XAk)#VW<Q6#>Rpe8f!+M!&j+l#1hrN{$I~NHcEVo!
zYPrj_pEb-_9=AT|Ye@6u&tIk4v5tazkYTKtsLx*DL`iZRIP<c|rUw|&vT3b3HpE0l
z(WObao&Kdeaf$%47>Tl<_e>be`}Q*I!p|1#$sLC=6Lq%^5?ECAAg276xpfFKbKj@L
zG>1^*GKRb?+t(KH6#)_tt#dE!?BAs0jD7yYSJ})jFta_O*=b`<X!NDNuKeN1<XxKp
zscoP1z2%jmMSm%lu)*anlQZJB(6-96srmZ@m|*bdpSj1533QfHOarxnz5dg-x}=u%
zUE;Wyc0?%xZT%F5Go5zWl0C`NMRD}BHao?b25%C}3#cha#uB|trBaMKRr3TN!S0kT
zQMo!SUhDL<=z=KJ<rxCIfJD8JX523?S~8`q<#O3AnP2qTVvj;o1WQZM@Y-Cb;1PE?
zlodJWFa%p7V-Zivram>N)jsp_bm7qoL*dL=W>YfuCtQEz+Rw{nrhwgg{B<o(=7_Ic
zz5jwH@7t1U_~mNPi<&OAest{D7eq_qztZYS>Pqjq2eCQE;^-fyFN*M$(Q<eQ%1^f^
zY<{(%X4b3?_WH-`0QrHGsM~=QQTr?2l47BW&C&zu_kVM(%qPlsaZcWoQSuKIDhk%&
zrJQEo=y9-^^}-&${Q!L+yTnVHM0KhQ?AH~4&q^&(f}KMFC)a77aW9sVx)wIZDe2Vp
z=<9tPp@rHNfk}&%Vg(sF?Fq;^wA4nPdUO-OpSYcoGOmUW31_=<Lye;70$SP^(xF;~
zL>I!_++b_=t-^(r;)}%x`X{Z}Ci+}LJ?4{R9Q<-Ly$=mpF-umgBgOk-uj)W^r!A^#
zAmVynL9oMxrdLp9oyF;Mikm)$3^8%@H@Me^J)76KYN`atZhXkeZnu)w1#X+c>Mx1y
z{ajJ2-UO;<k6YFHy4RW_kmo)epc)lCh61QXF~!!C2$;-cOw;%4QNN2R;6IZQ-4K`=
z1JqW#9iIK(7WaEnq9F5JelBIf1m8*#LGs3MEnFn073KKE^ltY<NQ%Xdv(|Se=f%HD
z>|`K~fe|JMB0au|-6o8%POV&`jkSc=(<aP^<C^*uf{8=E_k&+LZ2tnp1S`^5@ydIE
z71v6rfwV#{(+`3<9*yTUJn*Q#-Iw;dXJvi7j$;aHfGGnjBY!~Dn?6Mzj|pBHj^Td~
zRypw@Cz)X&haR0Co$oyP*b20M7E}P_Qi~yo>;+~@M&l2VKne3ZB?`YyHm*O5{`xeH
z2MNYNMZ&O;d0aolexsgb!xW^3LkB%T$GYEUpKZzh-@`>$$ytnUrH6~sb>f#i-D1cY
zBZ!btl>71+`9~`JHbl<?omdP?q?Z{Hd9Zv4Q*S?T7Qc5H1wInYwKijAK7IWzFq+!S
z!UQpwc-v7)Yf%Bs(bv?ajGhi#{t00svVQ}m27{P%ugH7Juqiz&(`ti{YCb!}+Nb9~
zA2`CoLOJJ{KP9FuC8-U{0;!o2&-H9hP9^4)QWkB>0pWJ*$Nt5r_Y};{aHu$*zWG-1
ztjGfgQd_$cOWK|ydh{i4HuBii`JLk6P>PK-Pa8z|8cYj|cgUF^(B*;I$0cGkYEXBY
z#4WReHVYo0F&pvHxn7e#33V5$CfkE5SbFFCvR><XYBa1UK9;G7`WV_hC4`tfI9ly3
zeFFCy)e&*i>2nZ(O#3uiKXEtvEwl%4S~s4;1nYQZ-D9=Dg;NZawdNV9Sds8!r#Ht;
z^6#oAjsaIj6?;-?rv+eH9s;&So`@N=j>0rG@cC3tBjRrdVmX_&ITLj<(gJKHMWS)K
znpab-6}ziM4Eb8swJd`fSW2g3v5w6*nV$#?DkqZIzrJBmE<ZbQ_;vvlgHi$s(yES*
zpk3iYXW3pN*P&&bWKG>gjIC~cp#?wo9X&r^ZLDlNO1=Tvd7%Q<+~#f8xkBjPc`u{h
zH%f6P9J8>BZK(}m=iZoptse<3DOinslS7Ho9~TDYox2%y6XQqL*R^WV1xIV?&R`vb
z!JMmn<$3_C(0QwxyT~eJ=Gm=ai9xia&g#p<72Mb(u1VSJX&H&scNN%qYnM;Y29s{!
z0nD_&f!x&nCMgAW4-e|kGkIsk_bgs`iFn$!joKd*V21Fi8Q{fo5A~>_$85XP6rXC4
z^@DQP9sHr1%MY2I@>DguTfM+<npAkke0YKxsHMZ`E$^#(=2Z>Pd(=CSiStLQJx#+u
z?x<e4vWy1Im0I$<p9>b_blndSEru&wX1t$Dg(y2$)MUwX^P6*#@eCjcsGD)dG)^>q
zAeoI+vK)#$C*%C=W^R;Kve%bpL%fc!VZVw}d_y&hwu^fJN+*gNRq*3|asIL_lL1MV
z@@eXbHvGy|DK(Ednp{#8)aUrwy*=H*E)@2G2rO3u&;>598HzMPjwC3c^F4O&)Dw_#
z$U(n6ISVolJJpx3rhXFG{NK#-{5u(k&{dt$!`YbN_t3~-YcN+%^{{7O@M8x*Xje)=
zVr`q2)&?<~)((FOlW1lv$f#RyOYi{>4ouM}pz>GMWHoCb3HD1PjRinsz+Z71%x6k;
zZda_aFa&O|+S7f&+WlMKXa(uz0DEb?q??_R;ZPt3UieVZ*$ivZn%thF&O@6_`5EE@
zuK-wWWYh=0{VlSv7c<ph+|Kn&-QJ_lb%;Oknimomj6f`(`L2#0*UN)C_pL<)zQasC
z_9z7R1E$uT1#Y;s(s%x@QJqhE6uin%Gp_zVU5u2dw%`MkX6>sD+4;|+ifwzvqYKw8
zFII{iD)O4;bNAMbd%J1mw6Uk+{b?IN`@~;h?%+rXmnH;JLeZ=Lg5vDoP6=4T2J-cp
zd+Qh)3jh~^-Ie-LQ*rucOmI8dvxph;^xOAY>UcxbXkpoF`u^s&S|CibBQSN>uTR;H
zGs{U%8GdZlTebXLD&NRpbW!A~W^a00qKrALt#W?o*<gX~bEqFwz=bDy?{ngh4ZQ7c
zB<yejeG%gcO!?I2rU{z|MxJiXX5(`lTGT7*NOaG*bkWlH^%5)YmjN=d#SfEryv&w*
ziWfESF`k`6u030K-&3(kQFWSk(9e`p^nc$tn2@hKw_$I>WkY6M_1bu<_Ve};{vv!o
zzJHtd&9m}cZSjwm<E=tLF|ha<HEH%*Ycp3I<&I%)wDR$<2NagI?QrGS6$NYqy3e5R
zJ4ZXI1x{Nu*!C?y4Os((jr>yenb$#K893Xn`H4m4k<qJWH5b0^3_gMJ`TGnx&feZB
zgEgU)TyBV$nx%c=ndRJD=Pi34IBlI5HoZE!7<RIo$TQRNSgmW;vF?uO2@G-E%dM4_
zk_-@J7Y(6iRE8?)-TV$`=#GcOPYJuB82X|J{jE+CbJ683%Zmy#_)VY1S`GpK^O+%q
zkT<?Ga9K6H{>spQc>z=$*0#V~*JVHW(Slke-`Nw#o{FpTLWm<<r^|cA5QSDG{|2#{
zwkn|!E$q|Lz6k%xSspjZmM%{e-O<_P88JqR?&YdA&Z1xn!x>Dl(+=jfQD=t7fK=Le
zSaI(B)qt%ktyiW}B%k1At{RBHOwPJAvWl7=Qs^0t%@buDgYUbo_Qpvzm_%c2s;DoG
zpox_l%cN5mblBKX5(P!orFC`3qa?o(#LgMy3i)nl>=7s2Qkcs<M>>$JRO9XW17f7l
zaZg52<8zE-)jkt(jyuY}i~|b4Ckky2$M#Ms<5Agi(1%(GaQ0nYf?iEc5jqKPX3zdR
zXCG7>(!gsd3ME~JE(61BFQetk*w9|a8Ax2&Lmx1}`H;TU-uAL17)w>wpY?H`Qj(_<
zck}XT7!1bOoFLAE;wX#C>U$O@>2!J@QESLDuW~Jd<{l9%)QxYc-d(*$V@3Sk4Sjc9
z$iVKYufD-!o)Jd=2F6#s1CyZXcY4HBk|acrI0jJ6F7}}wZ<g!&g2*H7vGNXh!1s=v
z?5$v{UF&mF2QH^>ev1yfo2z-gLfr-l8%?ne*(FvqRT>!#d>vM6asD$8aMAeW2OYF*
zn_$2`GHPb#>G7Xj|5$nZ`T4;wS+Z?AZH@hqfOCDs17bV#p>u*sMeQN0x9qIbAHNGw
z_3>31f3Fd}TCF3;$6>kfC7$k#;Pc_bB{mxZhS81Q^TPQh1&EUD8vh?PLBYO#43_|a
z!^(W4e`~5%i6xR^vv#+fuCx|h%QL*oIP4Ca+wA_~$cug_*YE|>MK;Z-*L_*X<_^xU
zJ)+u{%giHF8+u>wAR3QWd`5qhL<kt`qxOp-yGr2Z)@$3_AHu#daeoolM&CA`jk(qm
zbCvO=aVE7WLOr2KNhWR!18(P}2JcsrgGQacE3v1c4k|rsA-l%f-|x#s#h>j}W+9P3
z!=h%VIL7$p7=g=b->3HT%(nX3_Yzme0&UtGvV6JQa~@#QwS=3!_YFY4z(-40Tz9HD
zUIoNr`hA|}oG*=)QH9ECiynE}M73<;EQ6ze!YLKng{cvU1>P}PSomc1lcvuH1YASC
zP~%>wx$}R#)qj&7>LC8xJ6lbTd5Z86#M1=fb9w0WPLz2g%Ek4|xWQ}|BzepTx`!dJ
zPP53iA;Xf7gGZa`MRt~ZVbj*E?wvDi8u!|(gtfb)(<4IZUIb2w_SzB*XUmP*5-|NP
z&is?OsDXA$P+|91dl8kh1VZzavKw|m<Ow>wEb35Rr?s@Cg4VRdK}FgAyriPG={I?+
z))XCG@zpT(lzB7eg%IwPQiTWlVSST4@ugZ{)RYbx^$ktV&-z@y-#WQM9lIL#O(~gi
za=A1`DARR0E$beepj+v@H?Kd`0ha>AbX}rToYS~zwWNgXKDT}c&3Ox9#5Gx8zD517
zU&5pag*sU>C2UjF$7!JsZvD0E4%HWRQak*zy3$c^dly1HP85DxU|@cTsF-XEZ7(tX
zc-=0Ms@Y~0==-y8aJio!42_%lP4`@sJs$EzgUB_0IJa+zFgaK1bv01hD^gIeOy#gW
z$#B<xkjFB27g@>C9MgjBMHZK0Zym;V+34`+$ZR9wRpwDleb%03n|P;@cbYL^xE&jY
zXaR?kTTG6?Iv?f|G1j+0Rgu>Ms)_+ZuXFy+{eQ2jKmn9N8Mr@6A)_UFn1A>Fc5Ibi
z&s0lIX_4LY0%nk(4R03h3#D`LvIVnRm%z;A!x=Px)_jdHM80*!EP)XvDc{U<_#H|>
z$7Lj3fe0!TewgYsKoFFUUY5tIci;i?!+cikYwA7!5inwx#hgpbCRS>Dq3)zz3^Ty8
zX%WI0PsAQKuj^-L!_W}U6)+wyb|yC?G{Pd;{Y%p2VJeMYei+7`<Pg6S4!mhuP$5|?
z<9{ksKSf{s!3b;qZsZs6p52-af&`~l+RKO3#2CSn2_maaZ?%;fGy1RzHX$%VZDvp+
z_u11FAsd%&%_RT3@4Q_Tps}0y3zi)Qb=uw+P!});)rvmbVdNT{wc`~5mVMFOn5ir_
zG{*4_^c4f;h9uz>y2W8V;f?=2K#>kfRdoaLWCSI2Ld$Apb1yN;x%`R1gVna6O%mlm
zapj}B{arr~W!7#gOnFpqx?IR~eSKJZ4d@zgLzX&GH~Q0gg^~33+84%;DZO;*gIv+<
ztiB+LK0Oi0ha(NwLYT~~?JUjdnUQ_hot-XcdHF$MSws~4<*atOu%tZZ4K=ll%b&$M
zAYo<U#p)v9NnQoOF{39jj_5(1Y8Vy*dAg{L-Cj$F{l=J}>bZo&X8Lx6Xg4j^a^Si#
zwK(t`VS0k4<RyuW_LL%TN=&`%aJrbdRvt6fG``IGLIQ0-fPT(Dqn0p@g!<hby4h!%
z3FHhVRRDbOz38A8<lT!j@pbOnIidf$fw_;o!oDqKyWXX%kIVnoo?3sAN08M0z)Wbm
z$?tU)@xE9!<%?C@baDx6O+Za$0zK5YZ;?DOK4rCt9pa2&MlY2$sN=wh(rNQy9!ad{
z$kVwh3~|$LeAO@NwWs<XPW3Ycnk8P+-Xrf>(izmL+|GYgrW)H&KYt<g&9k2=vx5d}
zQ)I#I*rln%=*JHqc$MB25aHI*OuJ#?Ogv9fAD5PqJi|oI2z+%58oZTsxOo6~Bp#kR
zaRggnxsKnoe!6}D&2&nPaY9!^+=l&~3^rZD__ocsu<A%@5`wNf_nN34)uK{3fcHVg
zK#v1!4jbr2Uf-Go6&uD-tMl%l7wpFLIOij#gKoxIB`cE|_obklRa#$7rM$U@eH3(3
z*$!UwxOt+sNG2VnxuZD$IuF*zY8yXj^{xVac%z`WbUj05=W}KCc!fG>OXy`R78eE=
z!DfogJH5@7-`<~1C5p62oGvDXMeb;=Huo}5kLFhEv3(n;R8@#8^a>ATXEm<Jw;rT2
zwaq8-Pqr#X&AVM3e11PUX+`aN3rfG(wyXUthUf+#+8SBXrPKf-6&j~$8x&^4g%Wt6
z)m?%m=-H&S{mCx=<);@WCu!bA_B3g-tzr!d*lQX9Bep;z<%Uo$0d|cg(Gru+cu{1g
zVkDpZ2~0t-D*N>UfC-i~0_DdL<>lMDTi_Ue36tH`0V9c1W`@Dw=4cQrw8vW2rBcTa
zqnBKY1GGeSiXBIl^7kbazc@%AOgHnB02CsR?LfdWS^@^Zl5jdf(l)R(ws&-o%Qijt
z2l{%qpY0U`j4OR8p<+-s5z}WH#pF|NNIkFe<8YuCV1?Qp>zxvK=G<I<9(qwbiA~8u
ziyt1snITWIkSVv(en!oxHX8C+LtWqjto`ggF2B3b(--nJK9B0ke}(9m@xE07MNz|j
zNEJaYhtKi*!0h9Pi26ihmR5#9vc!NlW{<^EZ)M~hys%2@h_95CpbO%$1a<@eK)R)S
z>O>c2zB;)_s6gUL{YcFlx~~JdM@-6ibLDk;XZYFJY6U;LE*md$XP2ls9fgtoci58)
zf;rf&xBNYHo(bDPnPFtP9oe&z;tPdUp;O&Ak9>Z)Q=SLlgJ=LBoD-*79dCxP$cv)A
z%-C*X>X~6>HKGagQ@mVHwV9RVMHx%UD_w%;jXTYh5ScQWb1*k2fv@tb<HwwMehWh_
zv8q*M9Y$leC||`nUh9j`BswNQZ&r*hv@3Oqg&>-9+^7#7BLjD5KC&cmRkOq5D=wVC
zNw}AEnWVkB-7HNQK76vz#|iwO#*O|(KgsTD^@TvE;fgb7pz5$;a;@Dv9jXu$uEylU
z`N%E_Z-Cl!!+5{P2gnPF#1DM&t<c4sjG)YvpMf1O93muXpKIeSy;e#hQ>PeUl^H{d
z6@j``z?#%7`LiVZ3a%_SCKfNPMz}Z@8H_7&+E?+%ec4fqB@-Iv7@JqNOoS>KNGBwV
z-tqX_I|V#UFi+;D#8~HAn$|n*y5ej|GM=f0$HDAuTuLW^v`{MDmUInPZ%*zPWmFk-
ze4g{w6Y24ae{f!T%pQwscy2P+yf?PRW&ARkhjm3N-@Kva!@=G|QByNMwrMNZIQZ_D
z4xRKGq}DDDA^WJBx4pNJ!T?fSKU#xw-kE3xbY{~>x;I%Eo8pzZPF1CN1^UMs<1OBn
zRW+#VQc>KA1)@hA$W)c#j4x!VG6K1YgLuZ&PBjh-C5>$<a44;wOZc!}{CWM2H(@{#
zCpq%={iIBaxW3O;M}G}od0qD2u|eL&pk*&M^b#CK^mE$K0OwiKApR;lj)Ag})}LiR
zJ|!(vXT~PC@wMx+^n;FkQ%^F`e+^l~CS8<!2))lfoD{qDONZ89IMvQ8|BJn^42ybQ
z`&}x6qKJs7fP?`^D=CdAf}{d7bV+x22?!`4Js>R&GeZwu0wN8PLx*(7z|e3W*4}Hm
z*1KJM@AtaSmvf!<Z3xHV{y%ZYFThNdk_CX1dm^tR$v^`@X`9C6MkcACtK&2jbo(SE
zB(4#DDureFC%x_i-F^l|b=Yn|(2at{e&z#j-&f?(V6uf70p20jqju=?g;9}_pqat-
znE*PoWPAkS1V8kJp_sIabepdkebd66d(Sn7UadKCKeed!?gDb;eroP}Gu1Che-#S+
z^~0@GToWgRrdjNho*QnORH3+M3d#zumDg^+9DmQ4rA25B<kb!vHbkPXh7rhGXtHY1
z$-0-{O|zEW=fLu)o+j1|21lEpf|@@Gk7)G)AaDSrv?a~0%CSl<tF}OG_#B<x2V~oK
z>=g7|0P*?*bjGS|pD_*e!xzdJcSoh22)~BWiO=Kiy__?iZVqJ&YhbUI!St3r-Cgp=
z&CGYFYr`uV;J7F`s{LxIrx0zs&@*7_zWMn|0ne2wmM6N)sU(}<zUb9{4o8VZKuq2n
zgB%%|{FQav^YCFvNcJY0H6by|)p1-=ud(j!9OUhsY2pVSnsSDaiev26!@*!0hBD;`
z^X{Wj=8v1=vAEg1JA)%dwVz7Q;5!^kt=SNqEpsb_1i|I<TUJ`Vu7%HL6EJKjagv%q
zpR~apjVK?a#qWM=o1POo{A8oM+d@FoKv1FlZK>a1!pdsyMUFVYSMf8yTlbJ{zZfK1
z!4-5`bQ_gA>5Q7)`W3l+?^RicdOAd~;A%7{!q_%jgWbl=hj)A>Mvr6!8S_esr>leo
zbgxJy(Mz1KF?ItT2PxYsV=oDRSvt^k4tA=`(%l_S;WP4S=xy;@-QH+fa|nStUj_o7
z8&>CJs~1dnWfKz+B$C$}_3m^$;Tv0t(MF#!;Wlc>swRQ03ZgL+<sPgTd{xDFgPqk<
z6VGvVS78Zy)+h2G)p_sXBCM-^#X^0}B@Nr#MOiBK7USL`IZ=AJf<@n;ed?@li|&fA
zI_M_YC_NfDP^)2`aS6;|9T%M2r>MnF_OZ4}j!CBMU-pAE9z9qdc5B~0PFNEJigJqw
z<Fc`Wj29q-*J)_lQyn_tM?qsXZ+jns|5DCH@+g8?3C3%8oG2J00Pzhz(kVzm5b{E<
z4CtdLFpJwJGX}EbDdPmh<CD)5AFDCy+v9&V8$i91p~8?Wms&?}Eexoy@~n32Qh|m#
zBnq}%if?fNy4Mwnlo(k$lE1DmWrp)^v97q!S5h1Mpz2>(bN}Sd_z;78xibu~!;B>H
zp>DwOmrd*Q8!gEShcy;Zr5ACSe%z1BGn>wQl`;)n1TLhX>YmR4D|do1w0)j2z&W3G
z?4r5MVs2Y~A=+Fn?8IGyz&yU=Ao_FE$sK`+YgYGNfQqWl0hF;?I500!&~RQz)1uIH
znjs-&(-lwKb_1gUT_BN9=zFrLScA_HRRyl-0^kyPzTSCfl{wMlxQxU6_R-CEib$m=
zX>bYn4*+Gc)ESVss}yUvW7}r&zL`m`B+Y0pK5ZQ~rny%Vf3Rz+Tui&Mjun!TCRhL$
zgG-5Am|O88t@_p^2Ec!>q80gZR%Hy9dXU=Rlk5>HuiJgo6p_}9XMHfLGm(Ww$?xUg
z(q>NRE*Z3Y$=~>dA4^`B1&ZwK=hv{LbKAj<CNvqd$3k&hgs{Zz0VMTfZNkSV+h3NS
zAUk_8xQ#t^*US%IAD8Ryw%^>c${-wXB!EgQhg_f>bUhtN3<obWEp*`^hDdPfnAG}v
zv4yiwxWq*2(r7hSv~4dvXjh7HRO*5U9IANZR8xnxZ?7M;PA_yqaVX;WGCx2|UJy9Y
zILi>+)CB|*l0c?X?Ij&%_%*2ki(ThF45pzDr+@XEF+^ZE9hawWfu-x^Yo$92tmTQ>
z-{sP|X1(>E-0DhyA(YTFcL0F;sMo6BSr1epCGi!{6wwlitQ~V|Ucw7UBy36~STl$g
zOaByOrM`MP$r7$vAJc7$O5a+zRMHtloox*6_3S|&<2mDE{Yi;S$|?tawG?_89a(c4
z#d~J1ED7c`1)7FUmL({-(VBaO1mZqTjuUirAr6=j3d}ug<p$$8jJl18bqek;EAA6q
ze2uE}b~V*GTh;_bK64rhd5hQ+mWY#faRn5w`CO!RcTQ~XhIZnroi?EW3o<!r7#zll
z9s``f#WkL_$7LtRbgo7n55Mb}P5XT%2hS_BwZp2RmJl;y58;J?J(C$lRvIrzbe;8D
zyHY$7ch8OB$;tia7kCrF7W%cAKl}1VL|aLjIaG9AW|WGe2Y#Wv^+E4Wn#k>`Rp-G2
zxT{#+9`f#xy2_Jwcyd{LM~VD)MOO+H^Cfs?183)q`!q}EnBvSo4ggs7&19j9TDT0w
z@QbWt#dtHY!Hygj{WfD2k0~uF1}#|2bZe&M=k;0CsSO02RUa;YQLka0yUcsn@uXx&
zBjnNA37w<INweY$G&FYY)jzg*fe4R#=86^!f+&DP%n?~|NW;rMdI5gjE70r~ICQ3G
zalg1PQc`fXE#S}WxZkg61;0~5DEyR9tSXn+!nJX#@Cv{}JOe`@D;HD_r5`y2KE-la
zKzq=&qrEhKnT+GXEp?C~0O!nR0C2jBYz625`cpVz=@3uN*Naf)3}RX-ar2srQ-D%E
z#;Rx!a}oN1f)5HT%M6#E<6gP_;M5l;O*)pV*5IJ=>}#RJNy3KoLhP8!TJuizj=*4^
zw)ZlSE!_mzC%k%(jR4IiU?9r0y_6yN$)T0Gq^VC)lUY_^JL0xY+oM|4q|l9yrLGh)
zU18QZU&SB8fO4ACVE~7gNzGFu9a48;JR>5a*~fd6(NFRkDTUqF@1JNQP81lw4|s2w
z7s6lN+e(_jO}KUqYq`clHiC~hSuU}&$!6*;kRu6wc!7unxxe%lfSHL^bI#MSjAg_x
zk0Qz{$ZB0K4Guir?gxCF50_UecnrfW@>)i*9n9n{!N5l-t~f(*V68BJFL775jDLS}
z^AqEx=Sm-`Rc#O<y0OI`Xj)~)H*ej(fUFm$T<0`ZY5%~8dWTYxr}8yn%J^2xtiR-}
z%P<jWLPmvOd9U;tqq04Fyc3D51NsgUG6OWuiKQB#ZP40p8j)yn>k;y*PUB+3fxbu6
z00F1o;y6L`q0G7WP=ZGE@}Ynv0^)Ngyo>CY{6(p1tb@R6V%CM|_-Ypuo`S@hyRneI
zd}HeVV)T;8u>SExqI5Xu?x#Db+TkFOCt^Zs>2n?aTCZLuu_LxfRvV>AdcJEMm_E^D
zQKLgwJ`_^YHwwVr^rKP`jPwpwK7PN%V>L@wCXHBCNIP;p!4?>FJ{w>f*McN<IB>7)
zCW%}EYh~7#j_SzJso=W;*w}z3c3%4``vzpH(4`|fm=^x_*{CdlcG;~+V)P1dRkB6T
zA9)c$b{nfKD00yyR10<;F_7TOiT6CUE)^O<{KYowf=7wDTOX^+zkeL9s(}8|i?2SY
z0`Z0bBHs;OrS0jAR=qa7_bzZZ%{-T8s9AD-PLgO+H7m*YTZCwO*X$ODx0V_%qo243
zvI6>-9u+=0mr9^VPSDTVgYQ4NQJCWUG`A<jFg<eVsA&ZOKTXeHJUWlqH|>#RDO<OV
z0&OMM44EjvZoMjHv-_>qdf<*XyG&wd6VQF|_J=TT_jy48ruk{h-WCPtS|k~Ae>DH5
zWQ~jfquFMjp9MaH{7RpRSef>GG@Dzq8qZEXQLSw~?(O>-tL~O9{C>gJY<h9$gO<<;
zRsdFBEs*2Qsq+KAPlF6-Xeqq7UaXIVlC7t_(yVCVwf$e2H+}jDBnlda$$#DKDtRp;
z97hK`vgRwm8t@BT4!FF~Ul>udY3F?1_Z}JVyqLB5?I|HmM)rzUAAlXw16+>BOCF=i
zI-jvciDr_Hbz0EwEHB+`VVpTNO<iCXP=W;`?BZne;FXo2a8=f7iGk3Z8YJiedPInF
zp?>q4$BBy*P&D_l0w9C%)A7Bd#YrWY3>JXb_l2nJdS6+8B{dK)F(389hXS{=K&5wp
zVpSBw?_|yP%x=W0@%)qoU{e?k7quRL)3Sb2`Q&$y!vhs?`786ygepIISWn5~J{_?d
z+UGUm7n8mJEnZAi=u?#f)t9PM<mx9sfy-3Bf^6r#08K7?@{MTi{($!}_OpjV>vg2_
zlXDy%hzsB1DpgJPYGt~TLc6A-np)+r^$Fy3!3B=u;R37Y79m+mMRJT;O5Yk{e9j`j
zzpQSjbSxG`8}>1n?0}>g3<W1QM=U*AO^KnHd?!lEerB4=tJv^kGSCp%7t*Ie^Hc>(
zCAvX8M;Hu?1?(>uw_Lr8A2sP~kL}i3GDy&2l*wy>Q>zQw=d@`?XU6G!q7a13nL=|u
zl9-xu!s^6IRYn29lye&9pY9C{0;U7LljZBX_e&je^{p4&yXK@zp*f=I_*`5^@2moJ
z>q_1)LZiL3w8yQyg(tUG5fvI%#r5zfRlB0!_c=eg6iUD{>#8-6;8Mq19bpqwNo1e+
zCA}leZM<1ZZfh_MqhzzY4SLGaf|uSMW9R2hGzZq&Pn4;t+GP|x_L|4cW)6lU-lkYP
ze^}b<o`!ASB!EHF)XT?b*Ns4dDiXhD-cVe@d7<~kIlvZB&10yP9dHef?-y{xPR~j8
zl+9`1VStuZ+aHz7J`EXUA!m=wxp~P~Wmq*=y&B)<pNOq=8(>1>s{P<$X$@h|fy)<>
z#w92BjD)rR?+W9E3-D`TD!9Lp;Ae%P8+3kNWF_A^4cda}^W+{qNfc=ojgF8R{0+CP
ztBs`<>X4(L2`tg}SQXxvEaPafo7MFpYilQ+V{X4ZepTdh%VVLc&^GNRiRhUwS)zus
z{_0;?9*CYfBPx77>n^@O2g%E;=aHWVM0-uv{3X^dbU)!`ax0q?(5|~5J1A8gs-B2Z
z=L%;(a-eO_aX5CeBR3)qcf0`oK*}c?nXRP9!=XkZY16;dU-qFFnZTb%+*<tIXmI&D
zQl-?Wh<|;oFmk7vaV-=VW=xZ^x{JM_TxM4l2hH&htSk=L6R<(Hsn@U#T5C|yT)F|{
zUR$<c5cpcnnrpVd5)1^eDVN?~P>gR{fA!qgua_N>F#O*B72jWt`L4<WP~qVRTp%o%
zv3vvB-4h2|<plChaRn>=Z$9{b9MO&@CPfbA>-a@HAlk)lYg9SYT;ff$WeJ@HvJDba
zQV~6}Lh8^Q{^OI%%fK#FP;Lpnluo0Rwq!E%AbVm)A+fu9J-rW!GKTrikC+|qZggkK
z(>W*>7!k-CJw`nLKxUr+t!+sZ^04F~&|2Vp`eVe<w0{<mW&AGsBL}Sp627r3M!~}G
zDwypW*(C=a+Q+KT-j-K?fiQc^jS=`|v#CvbcJ{L{EVfXVf!ZNaU9G&j<c`vNiKonD
z<`*q24$I`n;;Al3pp2A8#zrWr+j5RP;m{$fth#r6aaQ_1huw2w(-3Zs7~Ancg3Yxt
z;fJ*RsS*7kn6Z3X-ztpgZHV<YF?}<rg%7iPHe#hc0uP6e4_y~1qt_*=A5Yq8<TR|L
zRu~6C?~wOaO6}go?qP(?!!4lqhm2}S6b^9_?rN|H?;Gp1h#bs$Gd>ExA->gP)oH-Q
zVfzUkR8hw0YS@4xqE$$PWgl`l{32X`KHMCBE58MT@|P2n`kcL%p(+Il7H%LVn4Blr
zD-(d{`B23k?DuMY-i@SHBI4Q_mVUS~R&tI+|E~Jfs+qA*aB)wN;_Qa=N;$eKBt;`p
zMz8dyITKa>HJC<}N_+D~(R79O=E3T5>X5?9gD$fvI;A4r)+Y-)MxPiIBwz|#`}^}s
z6RA@t5={-9B2Q&j_cUOQhm|`#a|L4xd(IO_AFx>(8LY8ddJ?etxb3?F``aU^gS<9&
z$XR(~NiM1o3n;F}T%W{DsH6!ld@COEs3uE>*pZ^lTc}IKAruRv%yp<rw{Wt{9<B7X
z=2W_sWuzqY)Mn@|1i85E985J{P#M8*AGB&#hTsu}heeIm!ZT{d7;3UF;*eAcPK`8X
z^eov^My^uf<YYvAO+|~vO8JC;o?F#vCzkRlo4RvnXYRl)-G9obFHF(uwgLaPbC3O6
z8O?N9Oj0f}-@RqO1GggMX8z*u@&kA8$oA|XM{Cr=h0rTebT#}MlPjSCk^$9M4!KG)
z&@Sc@YorTyA1Z>mIcx5fqJueB+-3Va+oLRUK7L<g$lBw##>Pf=I*dM7`FbBn*{`<9
z2fbhl&WD!!>kZQxpYG`)H|kd^)!pNAW25u<W!p%}u>7&dWi`t~i4WSBIM@Kj=RQTc
z5Hq60OrkhW(T^A@(Oz9yyig*f;RSK7jHbxpeKna9c!e-a56WNSX!+mm<u>32$w^Ol
z8vqw*yMzN0vA~8++#8o*IT;X;VZhxiwG>!UwWb2shs|xYCLW{00=`OD=2O2b-Px+#
z&CxxF9?j~^^z<*RXYfbVh&A?_iawqqb_xK&RaMy-Xuzy0*DiehK#qraVB~|W^Et=8
zj&t)u?8nDe$pS1ZP$~l6w6uk?;9HOC%wGem5$mIEbVg|znC?SaD%a~K*vOb#V!8K9
zpc!8w+>1B}<36|^Lgc)|bWA2VVjhm9LEv?<xS#j2D~xNPhiA#7{=CEq5SLm$d!9?v
zs-5O;oo55K$OY*7wrKWkqdXFNxi7vsz#a2mgFne7?9!LhN&)mC!X;n~gO9AdEbd&|
z!1<k<O5J+#aV<PoYTMVU5zgH!(Zm?6Nx5J0zWKHIoI`&r*6juMb`_jYiW6qT@iA2z
z!71S2=0vX5MZPNLcJqSX0zr9-R72D{!~Iob`Ou&zj86#mT_x9Ntq7Q<%4oLIU8?eT
z#!Aou@;>y3xHbYT4r%@|X_%G}Mv+cV0WV0;+-lf@%~=ns1uH=#?5lhw%2BsGiifo@
zqH%NB9_`g6ZhJJd!{PJY2@!pf6S7i+{S6y3)352pq$!5dj1E~@#aHI8N3|M@9`m)i
zg_kL6vAAlwdqXCdM4eZ!2s`>X2y&7*(NZ9qQnUlK6(d6>v=c&$S5|ElX}h%&q4w5(
zF(X&XH5`3tDf}|3_Z9VXM=iKjs}0S`@4vg@UwEm)y_6C5Rx!KVEszcUMHX>xG9bP0
zl0*ik5^-LvB2vAAAUf{w;L4uktBIj+=osJC%O>JBc+4`)v9h>ak{6<>7T%9jzf83o
z<=!{|uGbTih=|A1<AqylBhuq|Tl>~^+V#?gThn>p<~xqWQm6PDy%Q(b%*bXPzu~AB
z)8cx4+=<1Pol|^&SW>*|(zY`^eNc1mOgePiUjo5?SCPhsDg$k+!e3vqS6G(5b@W^n
zGvt%1p7J?rurx{%FgL20bB%;@9WwR<&F^)W!gG1~q!A%ToNNv@HDXQ>VOzy1o^b`2
z3L)f>sxvO4_#<^Lu5;0X!2~01YVsX9p>}nrym7sY*3JV4J{3bcslNpJmT~l^Nee}B
zURJ35yzz2zDBiD))BO<l*oyYu?AsMN-fAT;$il{PG-WLVK?9c4Q;JS$sL1L?m#`ia
zvw*v%M6k&S&us5;&;*j|xODAhSmowHht@ZlIS00+-gNDx-t}#{1E&be#I=7U30X63
zoz<awt%`VziarO=omUk~7W>QWQU{gGS^3T*Y^mcuDI`_y={d(fp$+jk6mVSiCF#a^
zTiI9gCVIrHDVF5lmf?MU;zaPBlXW}4(44n0You#}4a27<BX7m^a`aKZo6}0Yg$Mt6
z#MVc4b~U@Zbz;#(lyZ$od-IL&$$wckP$z)0VUPTje;^Z00Y-L#mzVnA1VLYS|Dw<y
z!<m8`$F?k-Y+Cv%<@qKM9C!~^-v=j43X|J+gG56#uo-EFLlCA-%y;hWx0?rj^qsS<
zS{W{p1p75jt<1Uu`7RhpB9yeg^;^HoB1QLO3>SIT(hCwZvo?<}V<bvUfD^$Ip^7@&
zYT~gR((ZD$)=NBzPGE3ds|9o$6zXxJ;;_gvqT>o3Pj5CKo90ZDRv(3Z<-)0uEMCjQ
zS@UdMTcd1|<c2p;Grs$pOvB`t#UBsH*&EOpu<d3Zd~-AEiEXpsugdIY??YUP?d`KL
z!Qy#q@(OiJAFOJ@5|&73QWOhHXHj?Wz;1KA>)#%og5=w3qGR+pJ|&wq-;fvhs_@>r
zjx6-7hW!)F)2Ccy*S^`yZH&yO??!l7lw69TQZX|uxtL-U`wi}ueO52=?a|99zVQnR
z59M;v<_O*P`Wu&=7Oya0e#pIV((tLb*zn0EhX=wtN!+!5c!qU5@h=~j^b#V33l7J<
zyA5V%Cz74r)D68Po!ZWGc}%(Q?IpU^#;({Ut!u$>E4FYgGe&hq*vaI?v--FoI`D`K
z1ifYFo|Wg|^0H(?n-o?g!j$z70=V$t+6zjCqKw&NGkqiWD)G{Y=shDcxn<KF*$g?Q
zvb$w7v+Myw>xodIeci6rkf~cX>P|1#Ur{hIKcOxONCa`23lOp>S-aH1vt+U?#lA{*
zO;r!RQ)v#L;F(j(6%lmW3TyIUtw2B*id7OczNq!=>80d<6f`h+_!6#N-ZksiiYP;T
zSlE^3$gL1@s%q>s;gj)D;g2_a9Gs7f*eb{1>+lZuiV@I1hg;5Td=*%!*01u4P>~iF
zl0{`rK{Bp~O3+@7a(wurniEnI=Wo?vuNu<{k8NM-8a?JpB&`w>Ja$T6%ikBwh9OXL
zeJ<&|$u4}dnh+?1Ulp{6U1=sK&u)g^N0bq|XGRr^p3)_@wHoTnxDo0L+iZP;856Lm
zKeMOxgt`rhsjrXe;9d0>RJpj;&mJ&{K9IvGr#{i5Gqe?ruPbgzE!2<*&c{J?PaUym
z*TUOffU{ou#2V4Q%R80yUewS?ns#4B_tZ|>R_WLHDVdeE3myCWyO9^YI@N2&tLJ!X
zxF2K4qw&)O?kPO5o8=2$MHi2ErfluI%C>&|BAM4>6^L%EdVin`Qq=hhDKCc!zN#Rh
zit`9}<*IKAgK@e}ixC3KlqO^SIBJ(#!`e@p>ZxiTxDc*JRhHSbZuNV&-IRNF5??-e
zNnoXTC~j2EJl8|{f{XJSqwW+@!WY#%3BpH(b&zNZ!4~9t2$_DGO#t1^qLjZH>TTQ?
z&TAPr1oL~#meteIUJzmx$d|MLf{sye7HI4h@5`xCP~&<3=sF5>T?5<MS%Qq;>F}iZ
zV=TJp_{nrSgb8IW?N~%#^{Q&gh1{E)X-Rt3xv-+b$S2)=&Fq5jb&g(ZO(o8R^*7!w
zN8&wX9dNC>E34^ZLdT6}o3M*4X}#tgjTw_4*JrOleL6AD$A{Z9&+7SC(>+miff>Z&
zHk~%Ii5h~5{39sTUiw~BpX92CM~dmg;co1ktVkOT{66crm2$?;-HSQ|j~aOlj?Pp#
z*GNjXF1)JKjV48QGw_k&zfUs~7V*9|Y4){JeREbbl#$twm7Ef3t@z=hX8%$dF3)Nv
zl?s7UlpFdj@7Tkn#0V8si@3+fiRPEY!d>aPlG$v;lBx#qUjD6(*$ES_?s78YvKlM;
zE`K3+6%{YxEO1x8+0Z6V=vop;OTTl+Eq5KC$4Hd1sw2)=H?%nIPWhSHD%Q&HFc)P9
z*yHTgWQaz0clUSF>T#vhyWd5iW@qG@^$Vr-FDA+>4t}haUJ$aEOPi}3o#EocJtjRD
z&v8DylQK3dz)@**OR?UeOGS)b=B8NY*KiGRZ@~?}^%=2_C}~KPGCb!wq8BJ1x2cNk
z`J9ETe$Oq^umO3dkgK(3whLi2fI87jYnMJcu6y%iou8;yD{Ac0?{8mSC8qxzA2}Xn
zdjPWLrD8b@pI6SDdAwAgAl>}R){>oVaF)H3_O^&j)SQm7P;fT}BT%FhMgn@5P-HQd
z6QPK`?H!nq@6^gQsC#V0sF3+a0dZU95m(ht;;0v7k^OtD(dNSUDNX7qMgtiP&yC%)
zIPv2L-&Nb^jLyXe4$0v|7g`p|at-l_gKHTCX4@_(>gn%3V6T6=7zOEI9#iWL`jgez
z4>;(BFX6w`GI*o_YE1p9h1BKIKm3e3g!%jkc)urAXAaA#ikn9W4!pUuO=`xpTynBh
zEQ8D53u>-TpZQdsXdaoSdKPBCHM>lw5)nEr`JO;{Yk%I6Bvg!rh1sBt;gZpVMM)bB
zW_sKKhp~PBxX1{Siv1wbRGL_PekZN=Ji)_f#^bRqkn;HWgWz#gW-E*f=3pz3yZ)^)
z06VaK*Q^I&F+wntrtsEZknGTLSfO&ybYV<u`+)(u3g@(h{CiPG<C%AF^=|a~GX%R{
z%PdH(y^{TAst8%A?&jKv^KOjy26eZ@Gv;<dIpft|{1W|XRu^@=r3R)WbYP`&Lw@K=
zbJ~y$m?uiQs_1pWlF62X>Wm*G|2zWqedybbW^YJ&a3Ykhg|TMk0`4KIGs{0kCldxi
z8NGaZj$Fn@@fVx@WC0Be1}Y=HkK)pdn}#8lqaB~i_*xa1qs7YOG}(+vK6xgZh5E#v
z)qd=z?yCr~Dvs)&0-50SwvavTr8{sxsN&LLO&C$GNv@f@4*a5k#h4IkRIB6YMzBpV
z>iF;j-gJIv$$+v73~8d{LGlPC_a4`9?9jxZ0R6GrLS3`uUG|Ne^rqL`Z?AQX>zO-`
zg)a|fYUaPO70i8W@KCZu#~-hGB{!F#+9IedC(e*24~0TG`mUkXNxv>}QfhEMbR`c>
z$k?L1ZM0{Y>tH}Za8~+I&n3?q)|0yyyYCLIckQ_RF!zkv{@8A}G)bJO2qmX2_Xc_;
zok4s8(<~sLyJ7#q-=(^Lq!B(G3{C2&GTTA%i7%Aw2fMf#?E699vo*M;n~mSxk4|s2
zi!bX)foOJH7UH(Mt5&d1V<6J8XcnfDUdGuaOal+4gHLh9n2p`umgC8YMNmyqR!$}}
zr*^jmbQw11Aq8$;%BRL2n%#CqX^or-L*qne#Vijqa4B~_`dgAI<f`4x%^pi%t9Q@c
z>vgA0+nIAQ{(67R8$t#rW4AA$K;CF)jbMyXcXXX#vofApw5#=pln?jFW``!ZbOzNj
zoR8(2W5hVrau?`~Z{TO@`CpF`W2vq`jF)dH$s$IUBf4g+hn1tAtFcyLNvx)FIvfe0
z3wM0|5XMoA)KxKbx%SJv@gHf~*<H6*xP|<E-^KM$*J1A8Ns7R5j8YZ0lr_XkmJ{NT
zKl{CT`$Gfg^i?;2jI>ZugVxlkKiosxKl;N77hk_X2rZMf#w64y!!lbwN=VU2i^jE?
zJNFbrU0RGp#GDIr6^o(`8`HSMb2<B*P)0?hLT3UDho#zGtLW7bI7W7Haz56QMmmdh
z_hB(^`7*X=s?N9^<vg7o>R`S|Bx2Q75+W!$zrEfW^fYW(ZJsWANj`U{&74f8AlCsC
z!)U~?5b?<K6S3tjBf*s_+FKI}4m~^B$?0+s;~`2LGh~lRz0zC7WXX1{65aOM{rzu?
z9`F6aQVpxs<dT#YbEFB%%-PP!5D?#JO>Bj#Z#}s7ao@W=m2;a{G5oWE4yC*{16C2?
z>s(Aj$(5Mx<mzX@wy;$&ZQi|kAm^+;W#q}u8qBnpkl4+0KoJhA{XV3IXt|wve0P#x
zTR@Z+tl~9f@NJmf*TdGP$k1ANnhSReyGLh%pNCyE`wX0In{89!uDPl=B-Y*{yoILq
z#qo&KJ(h5dc+#p|$1BjRBtA8mx)+3$0xnlVOoH^^9vP{HE1~-^fkmP=@9kWeeh3Br
zK12K!O`wZ9Jw@xlY~j@I?(??~Kd$~?&JM~^r)fco`L$*6f3L-VIdd;WxfcFNC!?tV
zz+uaL5wDFpoJV;}LSy<E8w-rfSu41$60b8TQID38SJ%eBICyr>gS1a@h+pg!lzR+o
z%~U_6D@Npxz2@n$7ck|%Gu~!Mme-v=3EwjA65(2KGnZ+A2O<?_26TT-XBvaWejg70
z;ZuO`QEU8K;aoheaKIm+HUB47Wm9^9U{bxpNcTg3@v10w;jcZPS6Ar2FDo&si;jrj
zSR9E*X$I*Uq8Kh|f7wWi8LE)GZ*a^(q3!G!+->{tQBK_8WXdf<R_OqPIUC7KQXEkz
z(^$J7x}txENCsX7G8D2vsMqh*F!NUVAAgTp75^%-C9=Nd#g7E-8Br4w91CB6)R3Y)
z9DKuB=6%^VCPD!Qv3l2nDI>haf^}mt%{g>o++r;BAMaVj$OLOaVs_a~XAI9IBl*pZ
zo&?N>MVb||{9cFs@i|_g4k0@28=uOmS^|s2Gf%ny_<OpNK<sPKT8W4L_dt6-I1BP9
zf9nTULM|5H1?d&?gwt<l_`*5VL<20&5I~Gd0o9Wc&o<e|^l=GFjdY{T9Q7!;Gi5gO
zPvQ9ec}>(Xou;1iK%wuy{s1_L<X<RatA0x@VqeO&eDok43~G5b7>yFT=TKYR^W>9K
z$6;9gAuIET^;areZ04i?49Bbg>*4svrxCE2+zdG{D^&En2@~j;OoBjJlQ0XON6EpU
zNC}hHmNW5&cgQ=KvlYb-v#HG5rq<r^-2FYMzenTr0Nu?6I=`C^=TDRI|MrpmGa}a8
zyn_`EiEfdkBnVqEvHLIV=_nrC<M4lp6%LKtyB{?zh0!JwlwjBPHKkU0^MEl}RpoPX
zS*qSJ@~_|ox^GWUfm1laPfr2BK`y=x{lg(Z?GNAw4}^0DV@piKMSSqZlf2HWRgv<Q
ztpVn-<(B2w)wkJ=Od+gd=JX-=WZRYi%=Nd$B7QHS=pgxnQ@<cz5apjD^80O4kn(G0
z2S7SM&+Gs)x>b87^~Xv}25QOvXRqTGI?%0f_aTD5)`nVMU<i@476<X@A<&ttt`Cbi
z@5gO$CG_=q>x}u&Wob>}Gy40a7$yg~+kaurr0W89#j)?lpKj&<c?Eh(U3+}@MFHKy
zFI{k{O&KF@TFLu9HnZ%L@Hl$r8$Fd@ykA&PSjtH)eW|b8v!09aa+0^782PT9+P!w`
zFwkj#<pcANGvUuLuZ4SH=Oo_y>9zXjO%6`>=m(a&hGEMBpe!J64quUY3h}X?4j<u>
zyFyH(`beTNG(}7gU48FWq<_tz=%wi}H6DeA3M=z5E@i8r#7CX}a}AIFcy0f9e_`wm
zaIjgp0!6@6-`Y1x<UfCQzdn>>`Liy>JI(3L!=UhWlgpM6{q+Dztbyi8Nbx=p%T$Lg
zV9W0NU2lu#R%e8i$-W*>x<6=ftOtt}l9i#?I^Hvii=|52)ufGl6ns)RdEt+z=#S7(
z)cm8K{rREt=O|t{%)o)>Xc#<&ICuNtlY|(<7!&d^;|^OPw;wz2zFj$~DV}oWv6l3_
z?ZkG7+PVGsu3ymY_VuGwJ3J@rnGo>M8c?Ji%(OYBs*gE!C>`i(&;0y>efEI9(Sp?^
z(J9SLo;p+en*V(N|GL_DWiOU`L-dFxBuFu9&$zNR(k9{HtdDD|Z|Xnjh`kqOn8^^e
zi)f3WytSb*O3w@lcwDkoD#GRg29%gKAr<VqA5Z8{ukPOjGW{d><p^ux;tc7*|56|Q
zISHU%PrNn|TiOXl4(U(=J*P}9&(g;yDb@;CD5S&ct)B&bY`l-*KQ^IkIIrIHWcp#J
zwZxTX*u4zH2!>#%Htl1FyF*}M&3wMYo+H-g__bDRmg6#rT7;`pFP#}}-0=I-<k#Z{
z&OuJgE(QdD5e{lMAk(&ox&PmU?e~-7#}V+SSDvN6E><wX{Vx{lpZ?`f7BzLw=?5b}
z^*#RAEaNA?|6_gr<kdTqUk?>9_WenI@RQ&Fw}0t(mD80r2~ev4d8Pf^Hv%E}J7j;c
zF8}(W{2j8tL-zCi|M$lHPsh!_#O;3>vbe_rBEM+?{M%Ld_a^<f;rW;6@b^{lzh1ik
zUxq9~xt3v0Wc%^uKXo|%`m+4lLOX*~5G}lCoyNWu7*{C~de?`|R!G@x3RI!bL;h37
z`acrbfBn)3a8+Tn)wZh9;H~uZfeEj@?4P<G|D!(m&tGN%6JD6msR{4jdEkF{sQjHe
z|9sj1o08-2ko_I9pPr(BCo=!tne&I>{T;HuL-zC2<bPRh{M#`8y~_S=cz*T({vQn)
znBOgn4@EI|28939hSW2V_(4LU@K>`q=AXCC|J0OC1!Ar+A;F&}ke>fzTq*2(IxBps
z!SzG^;9qmxe;{7|AAj2koQtl&*RH^M+j!wyQvF3<ug~V=t{CZN7-JO5xNq?-B_5yH
zZ>M^<Ds`k*U)=eVmfn&Z=Lxkt4w>!CHAdflo-#^XnTqF5yr$-R@t^Cl$sNo*3&uZM
zKmQ{#=x0$3ar<?UEcyGB2~wT_;#FZ^zC3G=Vog*7T=z%0RJn|82?DBI<|BrLxqucI
zMkkwanXfnWo>+@Fq2L39I4fU(ZKtcpP8rk##(d~n^??kKxnVtrdpQKyb?qyE(EBa#
z^DMo&PK;a}JmIqvQE->dEV`&jl(&g!u>Qvf)nx`vVr7%c$14A6XYE>C1oK1gvD3jF
z8=q1d%#q7t%rtm5LS81c&gYWLZPHO?=})GE1-1D=eb2DBejIRgk?IxwEQ&?O5PEgq
zb+eODDA3^|G$WxSI53=VLbN9eX<}D~4Gg$}sjROj&=O|^e@V`D1_kj`57Lj`ugW_B
zIl&b0t4DdWUM6{=S9^MejJod|p>yI#zp6Wo(g5Od!6C3Mvj*m*y2I*)`X7**HDg$G
zmb{oh31g&bH1K1S*k0@l-#%Dz1je1I4r^of8^9q7H{&R$^PfSWej{9opL!kHy{I6s
zMgo_!xq^d~OZm$Cj}Uz+5w65R0B#mDyMfz1fJO7i?@!+Iu@)`7l)}>Z$Km$R>pEd5
z7?8|Z;GB-L^z8E_&fN>AlPwlwH|b~U!WTv@-?<8)=~*4A2Dv1mfcbojNTgm0#sI<Z
zz~Gx1{nD&1eM+g2OBE+tK<6g%135(dql?6};s@9j@8M1MP|{j>L%_`dT!Nw^<30%u
zAe7h~&sQ?t6k6YT=egP}P*95`6x^l$&R-J`_?b0<r0ic=j)4cosolhs10?cyR@Hat
zXGSGh3<E@iPC3`y>$1o4+1$ab)suxKs{4vLan=)`Yjua4v>5^u)Mlo&PMZ4|@G_!>
zsS%f$lu>H-D??_oDem>`ZA;XOP$8Nip)2RH%VUfIH&}|qpgFF}JPXr-d#_=S`R%SW
z`w8>oAoSg_A6#FHK=L{2Ao+&*O#dm6x{%Xx#&e+K?I&-K4{Zng!}l`j>&`7eEscs~
zR&|cE!!8B+*#vVcZ3A99t~c+g2c9c1ry#<cg(+%;R;*R?J(gumpt*k^Cy|fXX08L~
zyuCP>VUXxnJdZ81TN_gcoHM-)KLT=ELV>N2_<pMQ@84Sk;roF(fQzoIQ+<wyz^;v3
zP;BkCM$q3om90(|4H&9_+*QkveGJ_6m{paf>djP$nB?q`mh1_?AJZF5S1FM(g%g?!
zgKNW=d8Q}5W5ug_Dj5sE7W5E~?+M>HDHFy<k5gT`!9>09b8e~MA}@BJa!>O>Df8u%
z1EoG3WD5jNZC3FGn|8J<$Y7~|rNDSbXtPsj>AuJDp&VSnif0C;GJA=DE&bZYW}1g&
zch~)cv~zuM7rcgIi{U#$t~-e99CIGEK67tfC%q2hI5_g%kDd=h3Un{h$G_|r;QPKM
zgh0PP?x4(CSX<I-r4{dbEqb>-ot5G|<>K+jw#1SF^Nn^=)|i^;?vofk>*;q$&5{>D
zn&+M>mqk%hj4>x%yg95PCE>+$bvisk$}ot>iOx=9&s#c^UL@JJlC5XGUvN{4PM_%(
zZ{K#^N%aWIDu79~Tn>CXBMqIhXPre7eG*};nu3}K;zmhdzPJ_Gw>uB!xfdQ*=pn8@
znu3(uzThb`H^YpDVplRyYpAwZK7%Cwk$dY6Oz80e5nkKNhdW*<({Q`O;M2wRH8B1f
zQUOxvOp>Kse^6*OxY<{$cTrI<aVdoT2O;?9?KjURaF*Y#c)N2AiGPy^%MXYZf`{u*
z%VuLtmZJ$M`IP|kXvwO7Fqe<AL!e))uhtvysrdk}<;0t5plCWcF#@E=+02GeS~W5z
zkc@RMtMAXiW#hfFI$BY3nS!@hCRd|M1&9kWgV}Jw9Yh#S@Hl^&*)W$4yCHo=oMI_s
z%CD~5VPH!Q>U=YDcqdh_t@56+a>0p3t@NAy&V1L?Qzf)@(PgK;9Cbcr4<toThHO-<
zd3kdVb~;?P1(-G7UZPd{9r5sv(Q{p^PmjB;>D$zS>+{X=zSpBkzHmX;gL6hoCrr^B
zwT<@MF`V!h+i=J;kKF!oQf`YqMGh@Ux|9*Ua&qbNNR=wkNTh|B>|T1EYAZGFaS#wl
zfhkxX$Y=ciI*QZc?v9-aqZ5Ya#7*!!z928>w6z_E&s(x%cV4ek_-j)}W9wYu*~!wz
z1V?c)E?)N11efol4uYW<r!<PxOUB%*Mw}crYZymbmu&qioSVvvJbzK$<)16VMJ*<1
zh;?K-z&R|sIF#QsC<it6UeeXgTl|#u%g*K(?wKP8p%0F4!0`u@jO7gFS~15WBVe!4
z?|n(vD)*`<tg3c5+2s~eH*4oKfDh7s)Ycj%B3}KIu)EXJ=uI=>SA5u2>4?dvjV-J~
zM?_ZJ7*@mkgo3@VY^#)Fap7Z$8(C6rdgXI)?osD#6j!bQfq#Q4&>MIyri%^|D6kyc
ze23SyK2jdWC%gI%)7`zdL})`pPftHc3s=a!Kf~}AH)ZOMQeRP{4p!+1H*MqzQ_a%-
z`cLP6mZtvcdrfCg5mW@%e#2oXBl#F{5fQtat*lWX8&EbQATmm$ci^*~4<Wd)!o}^w
zEB#cQEE(T|OuTy$I@J60+^a4XunWjI45>X1H~g|Mr)g&aB8@1YsS^<F(F2!*Jx|RX
znOzFyB}1CGz`}G$rx!4ApxK*tft0Z+zvC?)Po7=Xf^;5_H^=R%vTc1_?2`_e3|0?G
zcN=jUrI2e;P-0Lm4s<=J?<`h<-6p|!h^0N>hRd}n@G~33pYw40<*Jux9FLYuvsiR7
zNkb4EmTVh7=;;(f!C>b@1J1|l`vlJ4*blGUog=z&Yj?h9bBWbsh)4FrJgZ%2X1FQ+
zk=r&F8t;{qyQHddhk}=aP`6Cc(R$r*Z#7oa6g@%bBI#Xtj>KZL^{wo|#kNwkk^P=%
zcacj4@g^VU#O*l#aI1a|YdM6fYF1E#&kLfM1mb~eRFMhSJB^zju@a_TLuGTEA!EVz
z7x%ob8pH=yf-H)Zw&sMlaaE#mdv-X-#(rt<@%OBa%?1O{yh*!RPOHv*^jqA-eXP6O
z4Oai#8dh9N2zyRaT@n8V|MPHqJ^+tj9Swg#XuEKe^Ihg}>HK$$lp`WMI|A0tr4!A)
z(14Z}EtlpR*cGoaC-PS9(zu6%cuhpegwPDbY=!Hrgv0w}B8OEos+|w9W)-@VBYH%H
z-{UY#dg6JDjTXljT+@A5imdzm<+7~HLdKA{kln=8Y9wrd{QvP(Gi5kM#eF`7<@sl5
z^?|%gZ@k(KD-Lk<T2#cu#CoeEWd-`}WITJ*;b}7Qyt7{uUf(e&)UL;MA^rkvV(4~8
zZ|>3>WY4o(P6$`1MYHL7jknz{NOnqIItFB};)6i;ju3wmAOWdgbH*K`U!ewcAks3+
ztX>80%q4n60wIavH!nTUo)_WD#YC}cntMN(X@P|UQx}Q%*Jwl{Uo1517YYe*5!^J&
z6J-?fDd|n97_%&U-GFZr8xlh8yb88C;kfIUIbe-da3>ZB$TtB^M;5SZi@2E@RPrUb
zb4Wq}%Ts3u14N}HfXJ)}7Pz?yiBEm~@O0mnpWA%o<Fe`mLNS+xQ85SAdJJ4TYb6w%
z2^R8=8P&^C+5R(XCgo~X&YrRKoE%%Nte&w<+hjfXil@}$O&j$gSjyop5R~=SE>MCa
z)3}t<#`kMX2icVKv^=wPUw#d8*<GUVzC%bQs0PvsJp;GRW;*Kz62<$fQn_}VjGBV`
zB^h+8(N})Uv#E*C$7%I}(xUk~hLv4qDOUCo#6adnUk>FOyV7xtfLI4oQPF;Ng!$49
z=6p{Eg6lk!4B0RH@{Xger<=4@Kj;VVQ8>28*jabKAeo82`8?gYro7uGg|3;7%AH8<
zq@OP*YM-Dpqy@&<46-A=g)kDfy|faqB--qutuH-p{3plw=1p^7_<97xqNJ2WhDTQ{
zLZKx%4A(0ZHLHw2*cy-X4M6hcoTArT*lXuH-a3yuO7mg3=iG-mS4J<&m5NU|xEn-^
z2d{pX8uuJ+AGd8hp%k#4&)cgohB0ZBGTj>JHjBg5>?gPG?{&WwKaes@^qtU`B2?hO
z;3ucq57RkU1zvzs@H>hRl`OEFm=Eg9$}(~ktvUJ`W@f6DvCVR#G;S~}F%W;ngU2n1
zkWt@eTMpH|P3jcyis_SOGi@rgPt-t{9K7L}w?2Y7;8i>ic2hI%hwCQ_b(_3v+q3bE
z@4qVLC*xe*x8flm&212Rv5B9`^+V}7<=PKv4>y!f45sI(42EfX3#Q!6Qlat2vlg8=
z#EwG`S|gFD$PSa2-o{5%OQCf)bYkts1qkuZSyOeykZo+=T;UYSW8kt;2V!Fa)|l;`
z0g@u)@oxtEU#mlPOaR7edy$H;d$uY1DLx6ytsZ-@B3>V>LW16%;oI@WF3WHvrp;ou
zlwySpqW72t?heu`rDe=sQM6kcd2S5NU5;Z5{!caJ8{y(p=&!}C(~_bASO-&RbxlZu
zDq*HiF?jrQYQ{@YEjaBjWXu4)q#}dVr1W)R`Q0oaaTwK&GU^F2C-{akA61EDQ77xp
z)eZ-~P!g??N#l73fSdUu<@tx@0#Ly{<YrujZA>-dq3sk^yWcdY1Pd|%*7T(g2U@_$
zrU5BOiRX<B*29et++!hrl+NO(`fY3ol_KMA!1L1DeNZ$fsMm76g1~{~!Dy&2Lc?W+
zll+%UgB$sDytE)a%J2I$g0Yhtb6#RDTgs_;R<AX*ES<3G!=GMru*zrDo%%lBrAL~3
zaHaGn#Y3$({MZ4V;-w(I)e9PgWW_x%qk1?DXK<Wl1hy5(Z(GkU?3YuR0Xlf~sX7f8
zGA)TYm&@=Q^}={fP5eqV%S~pL`=<s|lzxToyLJm(VlK<QS@P?=-EfFOyd4w;Sv~|*
zDKe#HkfRwoGFL8?%6@!!$I;EN6Fnyx$&{b;JiZz`WFq=Ba25N7Sa!ff<AAN)E7GM#
z>h~l+iwKa{qDCLy<3waQ$9EcxT*Z`ARbxD*+^zh9r?zUx!8lKW{tB;ho@IU&UZp}-
zm>l9cXV*(eSQ))q4Zrru@wr*rozY~?%lWPRv@zr7hEW#G(yTT2XWdQ;o#SmyZ(cwz
zwRrn(g%x(bI6i<w56fyWDYXy3hGgtFDQ_=*t*jAeG|WtEJUX|6e6Bx!uKm&5lAW<=
zde)#=vhJfzL`s@z+1rq6g7h%yivCfvL|lmk4=cka*Ic^Q&uxgFuM*8+p*11j8`nI-
z8}TR!^PQZWR_FxwQ+%Fx>rl}dlamr5_veo~b(afs2jm$Ps{{E3w}`S{KH9q(GjBJr
zGnrIt;yUt0TdoXX&aZ=Q`W7#3YpBm;0CBWFn#-p9?E&8~#h0OSyNZjBxYdE_wjwWx
zQMc|ks6Tn4{)ACkV1RSIB+o@X*Nx|BxOgRm&wO#2A9hpI{W(K?#GxcN^r-5&vn}~m
z)NMiIPjM<GP|GTm)K#QJfW{)aJrn2_gZp;j(^kz>Go=#I{@lU)cvo(-E#cP5ky$d!
zp+b5y)s;7AI?3%~Yg~mI-F@{-wE6(2pxwm1K;Yz`WS3igUgv*noBSys`(vHpiTno;
z6aZ5#{n3C+8y6QMllt@o*dtE2Fy?Y_Pc4UgotHoE9|Acy5F9pmsv26nv}JTFL$k)c
zL%wUG7u4Ovu9Sk4IEdpzjBFP8_U^K7rvWg022|-w3uuckD}#j@fn+45XBc$Tm)=7i
zoewt}&C-xc9qJZ2y;{AXx?LSo*=#;FIKWq1<xzRGd}=Ov<CzWXR05V9+1(;5qxXOU
z14x!-+&YLCM(-r%+>ZC=Y8U11i3LUAQ94qWB7L1W9;N|PCUZ96NIg-xbs2h|d-2hv
zS`=krxSh!id({S{lU0r+N0;&T(mNWZZO}VtwL_~LAi|x@WDgnxNyEP{C4&;Bb_0!8
zKR(>^j_ol~ZWN34J$W8@izu!U=eK(Ps>N9{<fdviT)*fVc0DS4gmQz!*1a80GaY`S
zN@`VIQK&JBLwY=Lel_QM2B*UIers+lez9MB)QjmT{U~)N3uzC<Yu6+s<A*rY6q>Jv
zF&eP&ygmyd=Q0lyO%H=~C5xs$+jw2z?!EWj(^}806fRtQHVdx8nK^E`H<KZ>{AkQc
zk+I7dqG8tGmaDtPPQ1Kql3Sy;T9sRbPA)Lm(U3Q?FLFc5ZQrNYOfoGnMs>8PyqYh+
zVYV#K`SJMpi*BD7<;qd&A&*N!p}(8!r#XS{<;?(*{Sk;qPEEd#?L*l6Lyj6x($W6Z
zixy487H)>zE)B4olIYcy6%?)xcKH$Hl@y~~YF<`ytXQ$>v0^0ikt+TT25N%@82`KU
zCuMdf+%2H`mdO7uY8I0IGHKf5U~xQ@&wjaJ*xhP5LTd)85j;X?5a$Fh+Q#?Z8}%D?
zd`qQ5q~9*I^sL@)hA|?)alS-CkqPa&%9{qt(Q|k+R5rK!q|QfzR^ao;-P7u1B9&E;
z46V;%jM<`Ocn0n0^vZktvcqN$W7H0)vaV=7s-7v{i-TGN;g9aowqzu_8oAtC8Luim
z<zS>`j|!B$XpPM&=vn;?k;q*rb`Yc{=Qb@~s?@K0OT%CH*4|S`Xsb$OoE>G<P<+PQ
zg)%n$P}}RGNVUn?&>?e+(e7i(>WBf$)<uYk-ch+UcAs}pp`{0C+bld@9VK@(8?{jk
zo^Y(*9J<vE<BOVZja9_I-nMqYc}=o`;mCriE2xtPS~W&^o8K@ol7VDbZO~+l_*i2v
zILo)X$MuyIDNmO5`P0@Zcsi(DV&Zp$MJ6SNyR!A>`x>{h2SY+HhA(0RNcgbFldm?K
zk0|B7xoSKf9tRBwB*#I&mW7Z1%(Bpqd%Vq%9s|8`rgSVW_PHSUfXvbX<oGaYPRAg1
zy<R<^AyNzGF4GZTHQ*ai#hqCH79kT^FeB;0`g#^{uO+-+{@NRqf;=;mfo0_goYfS(
zZt~b)3#K=X_uEGJSvUCfd%8NOjV)Y2%<_}31eA8mqOcAiWn!jxmjG+nK#_ertz8{v
z*awGThX;Xk7&N@w9(b7y+1ZuL(Nyixu4kicX4^v9JNe}+%z73TRXl+!lE5a&js1Ni
z<BBaOMR;Z+<d=KIYvIG@71AAiYy7H@5TXG$<jQT0vXt^)KfIbw@)2bX(w06wpt!(w
zIjs+lig&{fav}8+Zy#*T##*!h(Pgsb?nRN)mKs5x;p4Wf?zBsWKu59>97>E<qYj!A
z!&yaj-9V1rR7r}_)F=%erQzJXs#>+>NWs3+Ypf7XhgUraMfYg|J+B0l(J`kv3RTgz
z9M@&PaV;22&MCVER;<?=`Qif^=kgY?iObFq1kSlB+4rG2YCKEBl}<K%zX~Tbt~Apn
zqGbDazmf-!Pu~F9(;1d*-eS9@eyucG0&d_%Cu>j68%gHeJ)5JH)_J56Rc<O_22|ta
zlAlfZGGu?{v@@PBS<XP2Gu1LU%)ekv2W}BkWL%~X77^&UptPQ?Lp!y5oY~YFNzcqy
zt-9w_lx1?oID6q*8pGf8jDE|_KEJ>5O$(N23}I%;qTQEOjS|#+#=kt5P}++H?OfT?
z7K=Ux0zld1WxjRoTSza@2eOzJg%@GN3gb;i$3}y2J6d5*i?OqVrA`62rFj_);+@Lx
z$Bf%Vv1rokwca1F>`S`mmnNBOE?4xt@7>(hEctqTZZ$gx%YO2;z!L5`Jia>G<Iw_X
zmGPkl><#WapU~;Sk~bn%9(!a3lJeBz`1Jc^Gh07JFs4Zl$F>n1CM8`|Uk}xIs@sux
zX_<Et=7ptMjfzC0iZC4lxt{9g<JCvjpgq`h?`XB;s3UlzQ#z7xELJZOOTP8#aP82y
z19_cF=VIF-wl$G$qAOzs+hJ^3ewh^eF5Z1-MOL?NS8>HQcr1Q;icqiw<{3xfvDvV}
zTJtR=1Q!*jV;9*amMz!2QhP<NLS|d5WGM5M#L7{0_)}AzQL)`(ht&~1Z(E_0$9%4l
z9Ht7LxGmtkr-{v=$f~+>N>!KXGLdbpdfv{!rawYVv_n3&hfc(#$>x48AcHz>%uF`t
zDDUu^94oU{QC-F%V~7==2$vOFOkiHHihpbRaJl)=DZs2$s)ADs(;X2?6s%a!!mU1j
zrxY8(olvNKbHx!;<e;}7>p3x=a*i?t)Jzvx<`U)&;5O~YZaFJ4hhGb6+en?5MweVq
zR#-Q`=%kpTeWXw5s;E{L6DZgO4oY~iWay5s(j6~u4D|}nL_}pY2QE<gAv0t<Ok9ik
zzfDontEGm-&t0jcQ5~@D6{rd#FyC|guzL~OVC~xRsO;RQa3I%KpLm<`k~9qmV2XAG
zsSk;V2OQI>Xs<<UPlYk3BxPWC##o|aC-j4E^Nb+yGEUYoYr4xHqr4NTIxf4NIA(Ub
zHN&%+)eA%@OIg<&L>!7Ll;P;i*E=gXT=CoFAD7Zv&#id%{o*nv^l)&4r*$#Kmyi?Z
zmZYR~p2W#P&zev>F~v=@2LGF(ZwqMBbdBWOH^jr{xfHXNOc)W|k4wx8EH!pF8lL7E
z&l-$3(a|c*nByQu$bMwMzio>@4IxkGA<cl%K*RmM7x;pP`7Z>3jLFyK2CK$xq<*Sj
zjoX1ey>fx>x)f-uQ*D}6ufj#W@dzWU-41Z0`Ys-EnG<ZB4vdODhEPTzRY!#AB{<EJ
zs&Y#30dGn2%j7<I2wP3EQY&r(H%{Z;Ci{4g<2^2>>FO@gn)Xs47M1MD48&#3F5#Nk
zCO~mi%GlPWcS0Fd+<@W~D1_uIa(rt!#Ai{4b2(3vftke6qIh|bZx+Y;3`Z4_Xi3&^
z*DOwnt#fl2ja-HdMLf!EtkOxY#9VzY%dIyAdTP<_26PTM_`&#!x*`YH_S86H0_AIm
zI+evfwZ)dqkcrm?!gj^7-mhdDa!xg|8tq2Q?c|a~&Q}B;zq^jK)?d68!9Y^_Lh7lh
zrrS1*opE>m3N&rD{IdB2QxOWz)U<5HT#e0Md08Lk$)jG2yv3<tp(`30Wbl2^z-X7Y
zx_F12QqZ+@w8q|;dJzoE0v)~kiDmh<y}ioS97!Ip^q_S>V`oLkP3Fg-2Qo3peH=n>
z!7Q<{K9U6QA~pz+&u_V?!gGfqTglGj0M}mCy$({3#~tdNk*3D{l$&e6Ike#Q0>0}1
zVedVoqDr@}(KexohzU@#A|P3mAXz0zR-lR;6v;VDECm5Y$rd0{LJ_LSP~;#WA{mMt
z3nUgf=Yso`-S+9XzwY<+`TpE-?>Ijg11;F>{p=^qHP>2m<{5#QcbbIWTpn=6Ou-qw
zVO_%t)z)~TU5hr6fn2i!Vl}1#B!nunECqKe-(dXNz;kctV5}`9OVvVth-=X*A%Pxs
zsK*#5yixRyUucHo+PxI@?jAAxj{Ja$7Ym`krw1MBd!V<|Rv0{qpbYl+zhR{y!9(>z
z?$+hG^{=Sqrf&7rA;^+IV$w9{aoA<Eh8*#u>nHY!kdvlx<Un;RA9;*d5xIJ5rND#X
zp76q?0H{spRvEDuIrozmC7Jz;@&?mnm!)wQ4_OE2;+(W@dn6wVeal@jUCIuG?(8Ov
zuMNW_SMF6pJ67uX`uK_qMvh(2nHs4<b}!Ubj*vI24>U<qrLLQ6p^ax(sv6mbQ>KJg
z&O*%|qh?N=@bSOId2*IxXCO_#IenaaFfD`l<-H+0I)JY1ipX(Kj=owuXsg=|%ZQ3=
znD>Ys3RD)fMKY`19X@GaXm-JPrQ<%+brY{b8T>M{%W$`##yD=GUH{$A_R}5b!df`A
z%zp5V34ORwTDNWdp4Tvlq&8sBH3D*ukw%EFs?k&5UI(4`S(~Ia7vlO}-OC9z1#Q{E
z?E?wI409W<qD58ZaMI6a8XYJzTg4NWOR4ZQ-uIiEk>X|L;fiEl`Nh2V%Jp(#jo-;J
zmGVI2ePJUi9a0{h^$2m4#SZl5*dwz-N#~D~_afC$H_4T`VismMHyysIq0i>Lh_HOn
zbrJM`@ucp3Qq4dbZ?dTrNE?+V4ft-^W@wO`b<h4j`TjP*k_4Sk<!1?PRP`3QY$~~r
zlxt`|5$8l-=F}-PsPQ&nNcY0;tpU=GrToDo8_7<#hd^?kBCDm)qK}K6k}fmg3JoSC
zh$}4%S&Dn&qcYw~`^GLIS(w*pz$mg2<oGD6ke;KT9-P<(3uvKGSmVm#u>OnjQ`(!d
z>KkWQTjGTKh^ig0Wfg7qYTMvavTQe2>R!d<l>u3M;5C<vU!tE2y=&5Dpnfx9tR?p?
zch%0rjaanP(y(Sc?9f#>>lms}pKRD8W8%|9;?sN(qK&q>9Gs`QXMl1uGXa@dOEhQs
z=RA7cwM_dh+-Q|jnxn2C_q>RUe|(|6765E<nosCQ`a**|UwmsHcnMXB5p+oP+yl8y
zd5~v})2wM&d5m2cD3H>p2TvB?HD?53xAXe1XMS$H_aiR6p~#eDRht6a2eS_3*9@+A
zx)Qr$y1D7meJN<xceMgzrwqL;WTpT)(ztD}RxMk|oE?fw7S?cDm7@GsE7brrJQzvU
zA(@Z$ghV<zU3%EEBsTz2wqU2{se2dKJ;fy)7fnwx%^j*ocCzZxgFYLl<{tY8;SN@i
zP=q|RiDa6{o`oZ+Cy37d#)Vn?Exzp>-!<FzhQ+StXo1kBN+F?w=fe&;-~5+P9Xey0
zL|}LxWoZ$-cii%M=bOw+;nX?A9v5FjS)y0u#)iGA<(}S%_}ntDYVr*gjxEx*0PKF!
zQ*NtJZ%7}yqE;;^<2iev+2%E?B_zLFtd;OE8=nQ_F5J1exmX{6Yq{$3&WK*5Q=2j@
z!R4TktuH6lJc55@``V@w8kPoUbr;Eui1zF!ji%q*wr_AIYb--kTSh{s%*~L2W~W#d
zV|W%P#t!*(_;xo<d|(b~n?Kh1W|qGK6KiDzmsPJMoyY9X<~WT@N<#*>a-@L5DHf{{
z_fhspUAi-zl3KmW`ffTbom&%CRn`@|=I)-ab0)I+$yq%vS9$C>WI3md(^zq4SE-c^
zWBENo-?VR5AKUP<%{4XROfy5@ApM1c6Z!=gu(vZg*2zq>`%YI$LS#|FDRphCxhbr^
zc?y3mfv6bPSwHh}PF`1mX-;yW(jr)Qly<>wb;?Ac<Zk4y&8b~WC-&-}`+(p$Q2rX^
zFP+s<-L3fGx|k`jY!oh4XSU=#XNI0^E7y`8SR>xz6EngTj_t}I&+UX}yiS873(bsx
zaMKceka@W1=?L@g+)-7e=H2R|^$oP3*<8B84xdV{T*H#(WhAKP$T?WuuP~?=9l3wh
z;PwW3W;o9?ZPy!qV!AqJ@jSEwGlAJ=wh~%8MM9C=<poPgeby6<JupK)VUn$Rcxp1U
zKzXyAy?yHYbq%=63pRvnJd2SrhjyM8$mUv7nspx38a!r4I7RvYA0XrBBKY~ibEY4)
z0`GncscKQ@1^sg%p}b>>iat-Mc<r?cZ99dRD;NbvUnJ{RC?|-;KZu~VE_uK^oAM)4
z$kgDWjuM)Qb+Al0T)9kxp&l+&`4Io^at8))Zp3aybqT}vWRO`Y_7<&>;~AxLl=wiK
zp*RJn*7M>tWpr&A^bCe#ak$)Ro*9T%XX--h9uR5_;+&5<COB17-!Ebe0*NdOM*ur?
z=V|RpVLZ^u9Y9KN$@Y`EIB|)Kwau9)e;p(+o1MSJ(!GPSbiLGGpKhH3KZaf(fi%ay
zj1t~R_2aI(y3=b{?!6lt4~{3D$Tqvz;z85`ZA6WQSl#O!9;J`k@kFSm2u}7G0h^*k
zUeZIsKKUJf|MRqL!6IvK7QKLt#$<%HHL<?r@Ppe~w|lE$N6(u(Uj06Zr(SJ&iiZoX
zpCFH`4enD;Z_;egO>DB6VymuU8)+!0lWtznKdz5_T<s;Ap_Y+EnlX8MU5sZO8AvTK
z@DeVp(UY=Tn(sIeU{KFCqk&S-x*;&^=A(nTvEoalRNXgGZUehi5nA;tz3>pV>6S$~
znggRWWx7IIX<FX?nm3#G)p3`uju4`p*vB;!skKU;s%8ylZWD*3>VUp9XSjbtP07O3
zf|B}Py4K=z*TecmAX^GGbFfes);>X8JbH0Q#ZM5%b%B)Mw0thQImMy)^OmK|2YRm)
zcgNw$bW1}$Cs~e@8`b(ixD~Il0wRTUVBLoK0w0KPK&}Gm7ffexsKiE<|GxZtIP`>@
zamyzITUp9(q(&LH)vr0qdwQ-K`<Sv|?&=*qKQdZW%q3C?>DA%8DaYR*(h7W2yAWf=
z=3?gVd~jK%Qkr~!+d(VmM2-P`By=|sB&kggik?cu!)>be8oB87Y8saLhno=%PTxoM
zQgEBh3|&=<F2eFBIC7Mzsn<@iP&t-nLDI&Mcg5TUnJ??=v-d3aU)=HjNXab9$r7i-
zQ&MSqxy-A$Etts1t8I-csv;fdYQMBgs(Nm)guTiv-Ms&e*L6q}+6`OjvVD#Y`=yal
z5mGpj!{`DjBQsGX&Cr;kkuU6fBv*qhq)8wg35Y<%OkG@@M1Js|*o&Fg?Nj?3q6WiX
z(k$<_;JPo2>lV9^#2<AR#|w~`$oCJJW3!!H?2tOX)eW=md45K)UDlP47$B2Sx|4tZ
zn}CQ0-#4{e-H+iw(%8pW{Y95u>F(bBH)?gU5(&gvbjzbkg*ZUL4;_xMzMJMQj>*zY
z3;4jQ&Nj%E)W)Jg4uA6xsM(S$gsg}L0Yey}4IrRGY6=mlmv3^}B6kiLMMMGs;rd8&
zDP9~_73(}`cD)8!WHm$-d>x}DesoZf1!^2nInvRz3l67Ig*Uo^=KVrNyZDg~S0(R;
zaow04-Q`Yi5Yh9K`qhi@U&JhC_fF}#0Gayfp`>Pij(HJTt6aH0o9^@{w`~C(0oAN{
zkrxXB66Y@9a2Y%7f?cJ4AI)oa1M9gR2eR!Tt)O{BsM@0Mb8EP2ni5=isiaQu=6)2Y
z=lYP{9O7dq+G&6ptMRdFXG!q5p{`@+Yhm3K?&S?}-&z3qz>zTFTa;$aca2-lKntku
z*?u~A^)|!6GpaM)c9`BgLzzy4tE4|k>~8_bfsk9y;~qRM)g!>XO8Tf#eZmx3PC0i@
zMdB-UrIpWkTz{2d3*o3iwu|p6=*4VAk6<-T;;y@{Plc;6$@eq(j@~@#i*>zYGJ0HA
zPA>mQj)I#Dtzd-OC821HuXJB@+hgP-M~(8rJyN3r#0HmOxjvw1qg$zA&#*CR3R7vp
z5CXHG3gEvrc356BFdCUE*S2B^u`j$70F|^WKHbVs5o2ZMP<s-D@hsa#i$?o^I8@n4
zC<<D1Yb2B=5e3IKv38BV(ARUtaSDs~vWbDbV~)&HxC-J#-%IO-mBczw)v2YKX9)+D
zg=TKqhF?W5o&&1V5G`Nho!M7yNi_|Jo_>wX)opq0^t3B4V_^@*T$aa<8$V>1#;xAF
zUdS`y_b4zL;`2_DBrwH^e#y3L<;jVu?lQFZzBBXicox5vO<0Ugxe{hV$aZ-j6hp~%
zCi%wcrp|R*@vN2B5SWdSMazMM9Lu4iyD9Cipk~uL16rBC-Yo{yye{QG2xbvoroTl(
z$$@rApyRu*gwhr+nQRF@RF0=5-&tmgEH2R~6YUqf$36H3)F)1c#!Gk)^#({$eR_*t
z9H>-JRf?y}yh&MA<riRm8`4&bcPwQ&9n8~%^eRG~^QcJU6%ue|nhG90Qur#iAD}CZ
zGBcZENi%ZHW#ep^IS&nl;mkU>->mdzsnTm&kIEO8`Xm-jfD@-a)1+np8|yS)GRA$u
zhW9~#5%UG=Q3Ao59$G}gC8AD;>uXi=KaCRG{q8ihd^mnS%}?D=7zjr}*n6AG_+l0k
z50||QZklArF4ZaZ@YW#J^71bIJJOTEw)ThA!Er(z>=6QpQmuuZmdRhz_u8%ZlO2YH
z3b`y<`lvQi@Y4ce=ps;@%l141`icz{BH~kx(zM`QW9Olz!HSV){kc!S@h6GCrN|V*
zrG!6U97K2WU%rFQ5JJ@C`;t%&y6$f;lkI*r-9EcSeKXE!WL-7d`E;{!TP*8b_Az=Z
zLKPnspLxF-eia1Svdg2Di|b&~HbCiOfJc>QmB+4qhMwq#UkOk!EA{bOvZ#rF1db4I
zh`DO1{g|;hsg>D_W|Sweqq46#^~wgdbyg7%C<{!9onbjKX?`Fmx3qBB_&rN#$7#Fe
z^eQ)OpP}+0L`kD5LkV#m0E$%m-fN<EMWkASLk_3&94lA0cHdLimWw1{9pv2wU#x`0
zx=!QrE$gwVms+Z)Nr=pwGMvl@<fLG&aop?E+#!qr@h5A6DqCdA!NL5pv%4<|d43}D
zJ5xX-0?3YaHFK{HEAO0h$wg{!Z`tp{DgC*>&zB0{?#Yv<E}br$zS!6GxB;zRn77^p
z=VlB~4LYl7y_Qlunbn6a_VhgM9Jx-Fz)4>rApccdU|`GarJRr2px(!wR0a3-6T<l3
za_(qu>RTKq6q(ZX6{T(oAE9|vQZ3Dd7iav1Z%>%GX0>&dE331rl^EFCfqTGL77rQ7
z+D_-a9kO09W$(OlD?}dz?AM>6X>}b3sp+Fa`eU54Rzfri4Io<EoojPNMK^+=@@`gp
zB_ZaT4N7%-IUokfQ*Nf3IZNIw>!x%18VIXStHrLr@Y=Y!yHm#<n|3`|NP5}h9%~A>
zXm)rAshh~|LRXGa_sV^^v8O0*zR7H<qeqodu|B^`f;~d8*;jlHyKE?}5JJGV1%+B4
z{EjNv==^i&al1$03|rxc@6$KHA~ByPuRbjOSUPTRb{~)Eyoxv{_2|hNRtct?*OO{4
zJTwA{0M?XFTfQf$3a9OIT<IRN?&V+$w3`R_7iJcmz7{!%x3in%Y-XBdZ7ytU?K`%)
zE-oM9x5bC1n%fUK9mMupP`Q)zX+4um=3eEofP>d7#y+ld7&zP#u!$+pwO%B`;U#A!
z%&4#seXZisA)w(aK}Cm&xJZt|+!2T6&XJ~JG#<tek5-JF$|9N};&m6tr>i-zc}Vde
zZP$98aQ_BZKWaYLx$L_q`XmO5XV+yuSiUg`TkDoB-EVU)n>~5wUGz#C*S-%V6mra|
zoS)QTv@hwMX0}RJeg@P88p{nc$~7M`pE-J0z8$kH)z|%q>WjlnRG5r6gthb8zb)cr
zxF8Nn+q`v2yde~6gk|q%$NM395l~s%Y#SP;3dKaSg>I^#BNwW?*C4J`ZD$5tpfUMI
z@|_0oA%ZQGve<5l=BB?{VORu_RiP(HjH(nED;Cgf$Y&b#0PEN5SlCgeU@X)LNXXmd
z`}Yb6ltKy|xwNF@0S`Dd879y5w#-J$8$$23lh~c3kEK!fd2F7%&Z$>XVmVyGv*00q
zu;P>PIVJ8gi_!;BvDpm10@t&36P4MvmM`SoUcFTE%P-smvXT$fYS=2zyTMGUg`G1C
zt%iEV7oSJ^oJ0lD3Ns7F33QpGK)pH#kdEKjH$5E>wh~@5%oj@xn^vXUrraIN>6VY6
zvN%!T7(gEDNe-WW7x*zrx^EBku}-mVmztHxv8$P_1CDc~TCop}Fv&IlGWIloBW5`+
zVWz2(2oP2#%VL1fP*uq^eZs1hl1t1)bI<lsl}7F@4h<laf0mqs!9SQL)Xim>ZIf!0
zDq81r&LQ%)bx-2UazD}n-(PBp@TK3$I9m>8H*?7xHP#mI;JWT^l*eiZBDN=do`ag9
zOV=c|@;uNYqkJ3XaKGHb<Istr!KnKooV*vT#H<rwde-`r$$m9*a4zPlSO$5~G;gJ?
zg@HQ19UqADhF5<Eg({Qf{^~^a8^4Ic-4kR_eGYXrD`tgp*lnqT>6~r^ZR05v#w{pW
zoId<(aWT)#ruvDyv^-TQ4W1#u*<qafePn5YxWL_DXT>`=G|1=0-qx7%TS%odlS)(z
z?=9m;%D0*-TP4WfY=|Y?bCT>H(=K#Sh!c@WRq*Ju#CZBw4vU+wunbn^?G+})6D?AB
ztip*&ah|h9LsY#Hr|Hk)l@`d<%Z3a^_fTB8{`Z+0@ZQ~1#L&un&)<8jtsY-5lnJEf
zka~v~C9Zj%7B&{6B=x}R5M%<|yOup4#E8?(l0l{XQimrN2TNtNu<N;+fi&ytM1)Fk
zZvXRiJa8J6u6kpfbu=9@6!A7V?yt3_em0x{YV1|D0uVsE?e^R9=y^?iIR#|4q#sHs
z1KPMC{pRBNOPOv{aCJ!(-qanmvPhwBOBI1yzUC+%Lxo~-jj4p8+0Nw33CSfJ?O^iE
zvh7iK#WS+oM|<-*2s!wQz}i3%3a^zYKa*kw%JcMkZgh?Bhk-U1K)K)4uj)wq+J}TR
zzi!^>02M$XH9isv(u?tO*eJNLi}j3ZXz-&tKT@d^;)7a+rq{!n747|9gIB3CqXD4S
zf#Ele<BM*GZ{NH@;e8V2NC`vaPa*?%0}J=mpZD;IMjRdXGC)CfQDMyQGP|*M$F1C2
z!>3SNH$N6@zmgM>geKabmLWn7du{VT(~-}15AGD|r>mrwE87Rh^xAxQ;2H0PRD*xm
zq~>p|s@zx1o%^8rlsQuMt!$m@sW{k7ynFV-aH;lrTA^E~&(np;bF<z&O-6gipN>y(
zV_(L8=IwCNM){N;B&tm5ar#7EVu$i%iN-vm9?h~^Cb6&j0R)k>I73FK;NkFkvK_Wp
z$8hlUQda8vLWiE-1>AIWUt_Z9!)kw=9sbyvICuPzx!gX#XbY=NhEtpf2EWm7y8dPX
ztk=Rz3ZovxqamOfMn1lxG>(k-o^D*z(5&_w^31^k_nbm=inH~m^(e0s669{4{woxG
zDVWOUE@RQP!JCwsa`S=*HF4hzd<6uXAG!^n#sNWn{qX(4QO>|<Ke5?5&$D}4T^&h7
zO7S90!Hx@7P<-MQ7k9T|mZiLBqGAHJDIUAK&+b}&b`V9VOs(Bn9~rn~-EyVNMHwZH
z$&{Lv;CV)Ck-ff0vs9sk#;s%e%tDiV4HqMji&SkfLat>kv0@EFuy69pvZZTAUtlm-
zYC{ekT}0RhZN~^T9KgQ9w)P`@D>RRdvj!RA;^N3gwY1IQ&Czn`h`csU1|1n3qri0t
zZn)e%;`t5?ww>XJu+?A4Q3sUG`LQK-@6OTlby{X=qx`x-Y5twC|4p*&*Sedr77*5v
zFO&h7?|XReQz+iYYFS!*jEV4&-b_tKLC}oAmYhhNr8ZT>P=h>8@6n+~hw-$8q#cYi
z!g9@5zt`IXbCBpR+yrRW7*_Qc9d+zdT-%*V6kwjC;Vv0FULXnu3H;|&Dwx#kfW(E3
zaL9P=f<n)!FK;i~AMU1Muimrlzm3Bn-d)@Ke1a_MrQ)O)=*Rj{&?eM8e^}?5Y$B&!
zYCrXSb8bahqj$!wj#S{L;0Gv;JNUD;dkulqELMZB#U6}Q*U(eB0i1|<;6pSz4a#BN
zd&+qyH|i<%UknZVYTHyo#P((x3(Qgdh#60iJZg<%l8*o++Pj{@OX?s8)tU>=mZmos
z8J{hFw<4p;#GF;NUQv)Rp%Qy%=~l`25&@|$%+e`UX^P~g7gRV10*!5fI^aUGU;oAF
z#1bDbGJv;<LQ9%}qf--vte6;o?%sZZV$x9(`U5CFxT=Mon@wa4ORquVPfLoMj&)~<
zKRm{6B4`tTlF$oq^B%oeuHlT5;OY?Z0Br12ENs*j1B`o16SovQQ^PE=plTVoqR6yF
zttpYG&gd<KFT5DJXT9-!cXuY)Sf_z&JH}kgMj@IDq|C90Ba?GTc&mLO_n|@4z5{bK
z9zSuA_?9JM?#79DuSUxts8zat!pzisy?h+m^KVSs;{7`D^fY^)-pG`T-x3hExuq<-
z-fqz(oP1L`ewcM&<o%}qi=@_V@DkyEn-8D*J*(#qk8C)fA8$B*U^6*j;`ecpQ(GXS
zJX&DmEAy`_jXZ~Ucq>e`=a#8_FaYH~5Uj^$rO1eTy6f4{@e0#+dDu*rKKsVLTBZTS
zd^y~7Ca`xVXAFvJ+g!8lJ6((93ryHa(y=#tWm@jHiL;Q@XSa6mB!<9CMK*+yLzEk<
zE8_{R+bLix5QNDS<AD*tvOH)ws3_HsZslCE;&8!sJw6zh9r@G~^$dM-2Cb3w{E1D}
zk^7g-U>24PnzR$)?t!z;u=;Ypz&W`g=WSD$=$XjQ8f4p|dz0UnR^#jux@Cq^dnOoZ
zzA&u1^L~8MT|o^r>uPnrq4uoJwZ86jni9Df*Y6SBYMJ?e(%k(sZTh2s?Mo@p+ccnj
zV*sybWe2P6b#e`(mDV+Lz-v5h*OHK+dZC&3%oo=epaQxLFL+J_SDT?T;ziv9#CNXT
z)Yu$$Xm2zO_7&3<(Rys$^nvwhO$4qh?H!SRAufh7r)-XGmyoyIi?OL<bs2Gr)O4;k
z?MH%wX=5}Yy;F0Vz9dGWpRIJJ%BY!wRjV*vK+i{m>grmtVM9=(==Lz9_~A~n>r$k?
zSLr}Sm#c$u;zQqx#8A*$Ah`*=2wfprjt1u55CXwjv7s{C8oJbI35h6trUFi@;iuD2
zW^{`z2Xe)9S5JH2@PX{bg3=kYt<KyyzqlLP(!lj3Fi=bLzIL3D({li0Leq+}Pm@CN
z``Du`w)f;*IvNxl8VsODW<3bihkMHszk>8;5+H*`Spll)>Go?nTTp|`95O?8(~afX
zv7hYA8^%|Y-VmYI$yx~Dj~)P3$b|?+?nsKZ>JPkNBXc@<u9;BMsn#L5*}yt8lf6DU
zxy%wL(5`<A@Xtl-CrWm?)k@9PXBDRxg~g+gkKt{KFc<U3<p_b+)yw*}-c+Y5H^2FE
z#uU3j61mvzGv2#8y}1VBU*z5XjBEg{Pe(V#Db~VH^H9ffA9l1Od`TKhh|}ummab-f
zO@;vRYe*UsmP?@7rky6{=C|>jT8GvnU8Z-Go+e*|Jn^oq2islMLs4y4_3tohAXHb>
zW8YG6IHU<Wt)2ULXH~a=>KZ11oJw|HFq+St(E7y>4@?E78jZ`CB^pLhS0?so*`TNQ
zXes2hmdj?U5Uw>ej2lL0BWiy=9t=t(g(Cf0wl5LAFnZoBRi{YD?3z%f&E!USX3nl%
zrK9K0#=Wes(A}o9vR_Z(I<V~XBbZ@oq4ngxxMlg77xSSchqeZrR1nE!L#rh`qPfW6
zgLMJ={W&O3u<K6s`}5GsmEo(qj-$sV!Z9z0Khk6lRvISU%pS6gcNu_1e0W_!`Ejby
zLr~Qlf{?ocZ=+Q@f(i9Hq&|aiTrc`PWdF-m!tnC*M=l`x+)sW}!^o~l4)`QEU*Wjw
zR*>K)T<F~)MX7s}>H;P}Wbgo<=%{-_POAn7YBc%CGkG&7p*x+QT0!4~0#hnbFejDT
zWhXat`UDE61#O&#ZY6lEy){j5z}{fzX#IFsX0A7Dp0qQhcT<U+DGP~MCv=e&E6%*w
zUo3W?e-OV97(%JK=hj^es(|^36R3}4Aut-CLG(pUHi&rKdWsz@+N698t=$RTufXyu
zA5fF)6~h5aOIzKbc)_$c{R!jt1p;5;3d+hVoQ`ToE8UquU!h*4o{dw`xklVeFn!A^
z6+Yg{_rkmBUddW;0su7H+-M2ik`4@B+F?t{GQob3vt5ft6ucUUeF3Y%ZikAU@9z*G
zvobB#^EsAi=iqCRZFH3#_x0-!hUKh7d#T=Z?aP7y6tf@kI~x3g`g{OCf?HQg*xWB}
z?WD-Ycv)FXAwRrEI#z>Qb*vWCbrb4IcNVV6ps|N;6-@4MS4WYVbR={EC^U5-oKY8x
zh1oZ@?>QjW?;fT%8Y<|USHGtdd|+HD(7xcMT{pNkCb1=8TfO<!{SI!kqkU<+(EMhr
z)@!l*&nEm@^~NM5*mIPxQJ@1_V#&nAFLGC!w?QhUAuOhyf{lfYsQKAnwE42)gq@o`
zIm=$tN}$eF?$@ALvrWS^YmkSY`Wwd$M(8ZK1x8gwEf33*UKK~UIPt!s(xn&m%Duw6
z=c3EY3C(58nwiD#Fld%N_Z95>d|h-(AO4Ws=1`>4RRe9GWqL*~X7se1_^<H~TU-K^
za7qu(Vf9o8T`KxGWcHJC@?K<UAlBVI4`S{tW@#EDsicRCocuMHFpI}BH22*KEce$E
zIEN-fgDRzfyVbjMvjbc5+11MJHG2Ja02Ef5KkD3a-CopO8!QoMWv(tiy4nbd>|#hg
zjQgU0QHLx794>_|+@J}u3%mPRk5;%RYE)%j$Th`XxPWF?YS|Dk_MNOMuCay<ACi;<
z_Ja6n`mm6h8?4&boyhwRlve37sl?2~Zdwmpre=;KKk&L#x6x|JW?Yg|$!9nG_YqJD
z=$0m5xI{pEMt~p?lY%|2_iPHio&ucdq5_~xTc*KO_dCtSndJROKU}=2fv}mK9YkA%
zA>})Ray;XNT_T>=`T1ITjr&rz@YD)1Lca#nb8Cs-%CC1@+M8w+o$1drWOO0b?n7#T
z7GP46T^b?BZztn;87NW^%phtG;T@YUdV84#v_t^X1&V?yRvqqH+&ut=lOJ5Lq@L#G
z<<<LF*)@8AS>-jsI~%NfOJX1)XpzXt=mP;Jd2p~oW7a)(#{E@t^h672=H=zQ38{#?
za13urq>ie%)BE0o?P|XTB2ua={0n~6)*+yY9kYS6xSv4zJ7xby{gqEzP&21X%Ns#a
zSP9awT{$_3UU0>@E9U{bfF-%pSVCMv%b8O_VbqtchSKO;!#7cVjcfGKsJUG0PjU@q
ziEO%Up%a#b!q{%>$HF~5$c=l0=NH6pwZ=G}$-1XMB+{?5WE#6M10hW{y<cy|sP765
z*dNWsPa3v2k;$t^x3+4JvhKBGL5nWyNNkg!7O`wh)?ic33I7z$iLFE3@GS2sGD(~g
zpLIHOu;>7*<q-q>;e>*#$p_HwApFhxsiCpL{v+Ovlvavonw932j`Ntl_njA_q1V|o
zR-P4P>u<PZ66aJ+`I;4)t5?5D3}{^XB*3gliBDTx)r*@fn@5$#v>0l&k5~61ny*BH
z!eY5LlD6%(RnVl;_}QzjA{UeU1dmX|J-*75wfz8)CZ43AK!UraIY#Xc2|xtV!#(%4
z3ax4Q4z?$dPJ{q!+LQ_tBQ}rDWlU@EyyX1(D!aJVUNG?`sq-;gqdU14mr6aC<MEhM
zPvzy!-i&6v%1rO$spW5ZteV@{iBgA|FiPpIcW$E2mRKe?ZquD7fHx493#88BX+F~1
z$vXF9kEtNDp`%GV6u#!XILufX`!WF<Kfk5npF4xZ%0PwTC54J!7AcdhkqsRC)nD8K
zGc~HT=#~eu3*b?7&4!lfY_@-0dgU&QaQB#m^C?@4SjFsYt$~<wu37ABKM`TM!dim_
zuiz#uHwhlklm)1w`WkOvu82Nn|LmvzjVH2c`e7Q-oJYLLIhBV2_uaGf@@jUEdamCs
z(y3Po6TYtAjaNF@i<#^=8_c6saT;|1PkSZ;PmfX6!m-UgnEgA$jenKxe18lWirjY(
zbDO?@7^p$=TMb6ZsR+d>i{sU-%WxaiFA9%`YxkIef?K^!)}!vBVjFI%_n1`jBsK_g
z63Zcu-v}pkNaq9h$s8E4f5hZIm9WvJ1hJgqafQ&Qm$N)lW@bSHM27R!(qxV_;z8_q
zoqu^un27mid}p$ZJ0!&MB@vpSc0taj76OU_qdh@ZfI~i#OEJHiNUadr0n{k!ip*xE
zPw;{KzM)2S`K66g3ny05DlrxqyG}_i&Ss<xoq?IcrZ(>}m$Jmas6AOwXdgPX;cB{>
z1&ENQOw9rXbXuLigiU~B!%5E#*!PX!$iuuPA%oAq;CfJz17gp<oB;*OhTVCGcAd5I
z4Z-vRi9E2LEH2%$Z|}IPOoJlnwvD>q3dSAE8G@tv?slM6W_2|%)l4mm*dnMG%ynl>
zU}K+aO2FLo&B=><Q0neOn_hi$DpWTdBwmk7W4-l;(h|;BzO@Cv&ir|Hh=U+@vD!D0
zu?iY7X0R=HekNHisDl=Zxn7e*4t+GsbOo;te5dP}?64!loJN)gqP1wGTGbo{*$uu}
zn)#F+rd@0t_o1}n{Rb}Xuh_V`DKi_-F}1I*%|q34=qCGmIC;wbnuC1zZ82G$V%h0d
zJZ5OLaKH*PSCu+i#wAH~KilQu6{?-aINMMl0`P>nYOhFLaOP{wk#d=+mrx72GlNMz
zy<VqP@>kM`q<STF%eCNbbsNlK5E+)mY2M%4_Ruab0zcF84aA`nAS7$9-AyD5?l5=@
z^<cxD4CkHPnwoi6X(i;`f|8ibzmX;$^>Ckpdrzs54PF$62#}jEYMuO&!;-QFKl)J6
ze*V;1jQx317c)fiW}A~s`;(j+PWz9SJNnDFUsi}422omemf~neB6{~fg9MTDLP??7
z?i=E>QY0~@GsU7xUY^kvyI&P-90u$Wh&ev>M{iZ?K|7=8=}A<*yp#l=bywf#yFPR-
z>aB)=V0n7_T<-Urj+DAhbWa^I+rVIFazl#6OqwJ+)U4|l{mFSgdu+8JZBI_l+=zJS
z(1=rId;A>V7h>4qtn<e{ZA8=5lsAce(|Db@@XQDs)n|KlBQr!+q_o&&il8-hsjgpQ
zpdwwiqc%!#1fP=WT;2AJYhvz_vdB$=VaF^NV51d(bGbd%qSq$dHEwu8&3X@CjE&o`
z_7-67wYXUdtUYd`*PCa-xN@%TJJku#e<N3iIMzxEKJWU<xrS?4H<I{nOv{FzAH5Yv
zZ)F(K1vmtso#mr_dQ)aZ>=**7#Gxs)A#{i3><SYfV7I?wJ<%97yDPgfSE@2!PI8CH
zw6(j&6Q|G#yXo*VS;Oo6gC6|`qnU)mUjU2e$(fcI?zhxMFW{&!&xbH;N0heHQpcTd
zwqO5R8s%rH3E@+dSVG(x`JNDW7WhCS%u+0hs|MsHq_r|+eCVjI3eIO1B*jadU;)H_
z#EH}Aqs(PN9npIsF1|Q7FVP}DpR?p_AHGW*ELGUu;^FD6xR~OI!}QLKiQCG>?}PJP
zVMm@c;0o&{iks{7ckMOX^Xw+1XIdXOASB;jdJ50F(GV{?4^rzqee<ynZ9Lm8Kvd>%
za`U|h9T0Vh%ur2>c88pJrS+77F~;vZzhys&xu?Ru*S~uw-a@fh;TE@fI8^3@BHjc!
z8<S4Ik9{G7MiJWGvK?=KKI6#?pkJVf0fIVC!?hC94Mm;x@IFViv%0|jyq{#^86AFf
zKSnOR+~%E-H6SZuJ34aHhlZ6%twaZt<JKKkPg$#nHFPqve9PRP{^&(YSIJ{lxH&Vh
z9GQ6=ZZ+&vA>tfzh2868In_=l{nc+^68I_mop;lW@F*7<*cIJXqbx1j160rg$Rum=
z3G1T2(ymNz@U$(vC$e#wi8i#wl}~*X<Bs|q>wfS}Cd;^|80K<0ejQXFdK!>Gvvl&L
z>D)K2E%Oqh#0Akw(hW`zk%rQSgkaC$c`kVNPTI!Y{u|TT1}tVmY?Yq-+uG@6PYy$A
zr47F=ms-8U3!%m1?Y^M#{#$a~o}_bw4w)O)!gd~~Ct=jngysp(@M8RWPC+G9j@_Je
zPJEbTcHn&XPWB$AtaapR3?=8zS2cxo7ipq{XO+^=PN7tUt3lNR&VPIse|sjm9e+|b
zqWNf@Ug`D<PbU_OM#$tg9aRp9CK8no7TJtv6S*mXGIuhM$(1LXXiI#;II<&S!-jTm
zn;q61DgL180|}&aeS1H${j~ucR>kq}0zdFVUjq%NQ{|V>Ks96YpXD~Kso|s<xK4or
zu$y2P7jRftZwiQPJb&$uWZ}bzBG9H609{G?SB5A5C3R->!4}oW$%E$i5f^)qcMM0D
z1o^G|IczFd;}2#}GM}eAm!pIt_p&Ze4pPf`Qcp{_X}4b#N8oWmg#%hWPx`d^$^%r|
zu(OPn#iJ(CF>mf_`-hZ_E#~+k3%UKE?J{s)9s<rEldETub5!T5dQ-c|a@4Kk6b$ky
zV>##|sUxDWQrs}R;*NRPKr2OneQ?Hum)oiB7fJU^;J%JAL{HcbP#~?<S4*6H#nzw2
zRp&=;XuUM|@SAJeCXKl;4(+1Alm>z!_ZiGt$(~qq<yP$xoG*VxAdD+zOKjz|>gY#7
zC9aa&X@cKZ4XeLNkcn{#k!A7rr0Ms4Qzg>ER#`<Ve7vW~>oEyaT56+8FDtMUwXg;9
z375BZ9?+x1G}oDFE5-}N;yDHiOtyO&DGML!MEbkQfXNeF0Sg;?u$*P2)Pr=v#xsd?
z=ze^j4sA5=PtSI3mGSEut^ousZ_cY=W6$VGEmPBFv9wDuRTN3+jBt~CeXF`Qs?T%f
z1a59qbv};r+bQHT*TM>_zjz_PuX<M;hG2(vJPDpDdfFcBq_?df-D66QbF8BdPmO_<
zS(0Epw_C~XxYqLK2*HDTQny-{N+ql_bQu@K210hi9j%X2u62!VX<@Pr*$Wnq@=e;s
z%$!_Ux|{&1VpQvUxTuw9X;A%iEz7~Wcx34$itbwq2%*=%yv086+B<5hsyrQs203cz
z0=rgzuFis5en3y#h5;l=HBLbrgiy~!A^(<`_~p2!908&=%L0f7Y(b6#2d0m=I(~#J
z_9=oBb3Ldjpd`}%rC>-I4T`7jP$hh37|BtueXD(gqTe@alQ&?RVsOs$1&<?g2E!BY
z=4gmjpIf9ni!qsfdj~hRzeQ_1T2h5Q>3Qjrz5B7qPicK)zC`MPqqau&^w*L<2#$m|
zn3<aHZ^bD=`qxto65kmTwd;_OdRY#Yb)D?LbcxHp_T(0_Btz8SJ)2R+D?(Rz`_bXM
zbvH=fuvMdI>Wt^7hQa06@7JakA1!@&RZNTDjWRXL#=^u|1s&pT4(uoI39lTUJ4Zb0
zSz@z%Ob}=f#JVpDe(lT(yVCt=S-FyeDuBaL_874}E$Dn#pE<-nMN*Q3QUiNk$ERUk
zh)KS%=O+3x=F>Anq7szovu@wU$qaM0?WF}Od-w47eH5sEQN(R-sb{ijC#v;3I<V+m
zopm3hPdl_dJX(8qV1EE$&oE8cy7zk6$Z|&wBRE8QGlxx=;%?M)!E2>zQG+vW&U*c^
zcgzv0eUD3Wth1<8(u@N?r*%H=S$UGk=FB=Gup)c)?`&0me-UTCWc*-c{lLix+$T=~
zmzO(F#&%XG>;VlE;D-#L<mP%u$sKY0)I!3;glnn<d8Y16O;tkJ$_n6arbgbwOP4S+
zfdL<RU~RvbclMt=s9~dZXr{euDba;E3cu!((rkC{%&(YIQ}Z)@W`IY$y1wd@wl+KH
zbC>8o%Jw5M4vi_g+jKwaGOaSzfZa#AY|Ix={3|~A>+cvyfCbfAXFFoBWrA%J_@^<1
zpW;=60BN|+`&|%qT_!A;f6VO+2acpvydgm4=3`q<)m~Ezr^iW)pA6jRkE|E2WojKx
z=;3<ZANYxUOl;R-A#WZ)oih3+D|qYITQ~XiIkZm3Xb~Cs#Q0DkLkAK2ygi<?si@G2
zQ#)VUOL$c~%;yU0lm3hiI7_B@0UMN*o=^6YfHnV2uPsC_x?F$ed{&Cu+Z(I{@VuXY
z_~#k^uXpm>cb~6u5=g))MnD4I&@g(HNd2n%z5z(pCcR31Rv*wfT<UP-eJxfDG&XWh
zfv6w^NU_}qfsmuy3HhHF|9p)LJe7TdQn46`(JoSS$vm2lJ))gkVjrU1#nXT7Hy-)B
z48c(Dut_z;b&EC25gzT3OZGDW_`B9p2GD#>D7Ux>^2xv`kpg(c?YujAo=)TzI1WOA
zK;EI$-7|5ZiyIvVBvwwHy|N=eQ`7j9qj|MKkqansk#MXYV|Xmg%#1TekBc)F#`{zB
zQ0Vwa@=TRH!S!kR?|z(mQ%HsYYbO+7dx);JUHz$Z@`vp9Pe%OLydHx*5EMM?EcmY}
z@rNIM#lae)liTE3n?bDc1kuzpaq-75zsh6@`B;O@Ol!FNn=I!4yyhRSaO~tA;En{j
zt^coQ|3e=?gZx<_$XBYYa{@XTaa1C(QDPqK+I;~&R44?gx8EIx(ET<F3?u|`Om9kf
z+Uvia1;2fuDNWdR<^Qnl{(QyY2cFBm`T!&%Z~mhE)89}9*wnGrKVSIUm-qVz&!Y(&
z0H8oQfEql<pWH4ZKz0<)#LfQObzhw$2mem2prQF+M&{Qw`Utq%A`LwLe{k7<_h$a^
z9)2v`FKEJ(M*?f4pF8Sb?^^$3I{nR${1BKWUs$^U2una({*x5j|FMnye*YKxeymrp
z!~R^af0(oX<Zk}>(h17L00v0>3kLjo9RB`BexG~4{m6ZtAN#i}0rLL3fB&a<^M~R4
z;Y?M-MOMT14mekm{7*aOKmX<5$L4Q7u={lfzW)0T{Kp~q!yo-81NlP{|5Q1UPWy|M
z_U~@w&x8BlN%rRv`FGRpzmx25=J?+a<bNmG-;d2-Pq+V0vj0x9zr?2hJud%pSpJtI
z^#2pbr4cl@sqzVD*QeiAP5%iJ_!GKect?DNEs9$rAv8w4bfq@-np^x`{1|`<>Y!Gg
z5Rv~cqx7ds{rR7-ctIE>cUiw|Q6abK;YZ+g)r`aa(OvvM#xo3%<7$~_ze@iX_x*XS
z|86LMPUIu9Uw%0{3Vz4*<fq}^!pP|gy><NQ6@5RByf6mo&YN<XTAT=D;zYIGn4Vs1
zR`Wu%3o9h)mRuGz%RJfn86^TrZLao(xriY@d>>ZDBC4F=?$BPz(iI-Fy}ap?;7~Q=
z(!0MsTg{uWZ?%n^<sog1k{$!Cz0KzG8%unxJg1JIJad8J{>xvE{b%27vfW-=+%AyO
zHh8r=zj<-~d+8uCl&|`{H>9;Z{nG!%1y7#oE(QTa>E^{uHrq>?Y%iZM|L1oFo+aJl
zSPjy?nNb5Wc2fiLOR~a${Ah#$dE5tD#ik-;a*>~9bCJJDfBa9!=f|ji%06`x)x-%5
z?O%l(K#sk?^B)fKudn95F3A}vT$`>2d7K4&T{Zg8-qf!b`Q=p^#f40^Vi9l1DJAfA
zyXm+8{||4;iIYJCV(oeobv71!8GIoAznMHI=d|wUB8S(`K*{eBL&-niy8M4PVbFvL
zGxgsI^QTw&-wE?KtF`;T6Xq`$+J7g^|63F0vj}TPM+hc`6<*COkkWL7V1+L>`SZjb
zUu0V!Dpt;rFiJL@l4)piF26<fr&azpw|pVWmvD65KJ^znbX3|&X7%H0mznueh{I<x
z`r?zhhcYDO;)IIiY1yu``~2M{|1@a|9)jIFHtDZUwe|O(OWu;29i+HUJBe>oE)Me`
zxYo_|H%qx+pZ?QT{`zq`h)xoY%)h+2l^#QxT42^|<oB+qg5#ZNqy>`>!o4Tf$wlBF
z9f?+ogi|Nr>|dNZ9jT{oC~OYw_;q)rV)Lu?x!j<wSj`e-m3m{>#eZ_+={5w|G5=Sv
z<9-bJ1tc;7L7t6FK(E~V>*xLx)|r+jTn@$j7bpf??y4?MjeMLfS?r`xp>l>h!U6u^
zpP`&rIC202SpNF5SFQ@=T@Os?X4bdL_R46ZRh_$&VB4cp`Gzk3pG=I;GYkM4oYw`A
z$xP`KYSeRkgrIPtw0;E`5Gg5(tV)`jnm!sScTr}~saWH6NXl(uL#1Tvmh-zS*liJm
zf^Vh~P-%t(>i){0=+aZ`d8m{zw$*qYF227|;0UV4Q=cSDBaWRQN@0rBvFFF;Z8nQ<
zcB|rEou+%FZCz?K2a5mZS)zU)ircEkI}vPUkZYT)7j#ic?*Dj@@(Bwlg#dA;)pE@{
zK0UzY)}3d65zyNlEV`wk1v;&?6HLEykY5#YG#z~Qjx*n4sc6U=7YsX?;HW%|t?0M$
zT90uYdv)5l7&OQllr0twO;0YSmG;Tddwu}=$Duux+Ln16K<P9!h?c!N75n=Hi?TXy
z$ifR2r^(Qi?hEEqLQan|EYdW)(B?aD)Vtm>>dDsW$L^7c`KcEfa$sFbGZOF-ig>o6
z=51a6q3wUReqWWU5|%+30A4@9R}145_ULdM_m$eFWpoRu5-5UZF`JEPAdT221d-x7
z4s{u}lS!U%=xU3sKA5^fo3wUOw<JQ(4d>w!0h4Aax*fP0x9q{P2nH!|X%!SMr+|`v
zbqm9<?>pgH$frN=>h}C8Hbwg`mI+5x^k#m+Rse~!S>#}=WD(nONHJNd_|yaB9p&O4
z3Tniw6Z~v<duaaAnm#$FKzJH&0+ejcFz5j@Cl1^i!YuwqEfZlHp$|c$4y4#Z015;T
zyMc_^VA!H2!%BF<0gz|t)f|8?RUaJ|j{8ybmzlrz^uo{Ur=7WupOq1p1Jl$VJa%(i
zxU$&CUM-6(>0o!Da-YT+bT8?N6?BPES86t7Rou$u+QgccVi+vy9Nnz%)C0j~moLcy
z!6%0RE-j*;`1<q0<tPoD8eb|VuPNQ;l{GvFvJMeaS6nt_eGGTWXv!JTnUyPH>syum
zCrjC2=@J3W>k-hr1DgiKc7Fqi?<49dv^j(;2F+0jP?b)u2uUD4o^=XkT*oOMDNpA%
zn}`F&W@e7dVxD^`l=>cdYeOq0-}}Y|%AQTc-Kjx-HR)&kxerCf9XDi8L=wYo;ZLx~
z<Jc0B*>KyQjrV6DaqcznK&7|0dp^stAgA`ZhSKAgzX);%y<i%F;;bRU=f%eMeP_Dc
z3KajzgS@=&d4>?(oCc9iS}Cgr`A9gh#e!GL2GfbE09Or+MNVY|9k7)t?086mu<@9n
z4ji=y!oRp4b$!J;e==pzsinxCRj4x8m!m(|k+`c5({slIF;0T12%_XGP`!!-l6kuv
zzic76Jy|*PzFZ1i>KayZ{2tKJ2D%{OH$GpEi~sJbO-)KlY6h%o21@M$UyOp@ejX=~
zs79+6OxPVZb63a4d+p&`o`WV!C9s9rI9gY90f(=cp7Vl}AscDpc-EnyCD|Cud|3+K
zCTyPbk~az0y;ih2w}|y{$;LA5NVps(;_?D$&z3sNB`*ex?cLIjyv0>I88(oo;gc5c
z#x@^<Zn@L^e3{Nd_%36w*J?eba)Q^MSrG;HU|N8nVjQEpW&_*T9yIVFmD3j+KHSWK
zAwZ#FYHr{>KW&~@-g!d#aqkp+&@#9&9Iy>&NtF)C1;aDo>}Vfz$4G9vyTGJ96S@I}
zxJJKu`!51~p?|m*i85|&O&D0V7g2ppGqEoQ1OfzHNcetRe4lk#Zo7F%M2i?@yDw-S
zezvI=7OGr7jA{~Jc6@~2M;~AxnC!O7>*Px8e<*X|qR%v^LYi|v?ipqr7TY+KKE^(d
zoc_@Lj~IsTG(t4zM2P01W4s|i!^~L-$gvg(l&&?gcllE4MbWuVhR(%EMKMXge&uzv
zk4;Ms5<*fjAeE4o2MZ?R@@a9-gS^L3gYz<D)8qd1N-{Kdl8YJO@x_IJCUrDv?7@uq
zQR9;Ei<L36Hf_*B-UVKBs4pT_P=j?Cc+Rj2JrV_WG+i{nB_gZ9CE&iM1LNp!zhST<
zrH<_b3I=4{Iy}dNDbDWeHBD2txoyyV$a}qTa5s<kdd3;45f`jy&-!`cg<Qv8O%uMj
z=o>2qK#(ovx`dyCgJq0Wk!&@7(I$p8S?V(mh(5Nqy$$JkaGLhRjbVr|g@(Z^$LWtI
zsq_b9r_ocm!78vJVSxQaRNVS{!jXto)$X(z*sdD4wg)Y89C3)qBDYG5>{90a(J$q_
zL1$X)x5q)Va7)v8uhto^1IEw%PitSBuVf;ut-w0B6Iv>nNZsX<xzFC~1dgzD&lF2{
z<Lc&%D(`3B69l)5u6}P~-u-!SMv<HpyEYV(dU&}`XC=2_6?7&!Ym`mrw5Le9JInXQ
zR*zU#biLOVx&a|^=A_RQnq3J;2@E1JiRNQ31Cje(1=n@>M75^>5ebw|Prx}A*8$Gq
z6*z^u(S5llIq6~za>rtO#6?+M-_xnHFq7_80<i4JesU%iJ>REyyH@j}c?K<z$$Vsy
znfH~qCUsEo;uR`z7HfePPm5;O+Phi4{x`lj^y#`FxV={21-23Natg*Czy72}B{1Ts
z8n9ipzf|639Anjs>BiI`U&JpKW2<^xz#zwTNmKJ3o(MwMAkPp_=@v%2=K^TKBvoQ5
z{S~Th1t)0kE_Bb{pa|-GG7r?gn#}282X+D0I<0|?;VdTDQinFdw9>ks!A=?axEqD!
zHAw4`GRS<Z)dy0jR9{Br_NcHfzz?musapF>F4ZxfFmvIg))p7RGCQf_A`i(&w&ja+
z%VfjT?K9!Ofv(5Uu?e|cWY&9Gc&~Oii-4M!ret|HkCq7EHBQ=`Z39R}(?cd72>NOI
zM`Fm72fFWFoBC<`mCAz<<$rjBsu51m+8-zAVhvK_yx`5O{3bRt&`xUx)WcfK$fUMY
zu3mf=@EHRzLhN9%O~Q{evr9=B!em{(Sj1~P_Ib{$>$Y4heH^T63!Q@i^PZy|YUPp)
zJVa9oXrLWy-^_{9jrm^25^MWV%er(5L&9AV;#5+$-X>g7s#tzm6o5Q4P-2#?$5Qrm
zF~6CMwN_dgh!Rp{zqR;sZ|xgn7vWvb4fprMj__Te<MBfe0fQ`j>;qOWyr5s0<HLHh
z{$ail40v;zeKd+_EK`tL9rGc}b`A`1AwdC=h7_YnU4G#-L=dFYh;7;voaF<<XRM^Q
zQ^}zk*XxDxbL!Pdx7S9F?nu(xJw&MQ$H(ozzhy}U<zjr5puAPHIJbe$ouhn9jy>xG
zP=@|!>F(zB#p%1Jp=3iYPy)C;biVG4M19FZelsTCed(i>0RCcPDzFVjYl$satlvpK
z!y|Pc$$ySg7jt8B1GslQ$2L&gROAgl<(yl!=6M!)qoiA_0Xd6wZsBQoKJz7b_JDl6
z@C=#sJ+9?2@`faoy49>LShk&_3kU1%?Y%b-t2AGX`%dux#25zI6sGbu$jj|s45B;z
z^Ee9&PPo#p?1a9-g?HVU)uKz8NYV%7zCdd51>cC+<RP!e7xuuaa-M2^rh8})Y{t>B
zs{6_?iI;vHY~>i%##w36W9T16D`z~a2$1=J5OYpX8$cZC30OQ?07W`4De&u|9dv|K
zh9Uh>LHEADaRei;9xOnb%v<U8y7;@>Mg9Q0<;rd2>oNUw;$9w2!bDPUW_`%S9<8?u
z=+iVw(*%z_rV9xO=~R*DgwwuT=>?m6yp_yVcCs-A(YuJ^Q8$#3ODkWW0wKuox+N8v
zIa_sw(Ocu9WRs8NZVG^Jf+Vi>hlDfq25)%qnTap%4R3yF1-)=l^i5*gXQ5Kx*p~;<
zz^?!SFy9>~;56vwb<+O^0|jmHGaC1WJk8G>36IO67x~?QuSpje`~-TXi^FrEKgdbE
z>;X{aEiKbGX6)TgPY!BI)w6G8VkH}?JXmYioI&2ZFj7b7wKHzUB>+r@IBrI`6j9xI
z{)p<f!Tn@cv>0};w^-$M20+whMI+8bmIAf*tB2@hgaPFBR)mgy<J<-i*%rw{_iFXv
z`*%QRc)V}@+IN60!#z(wgBe#f?{3~u&?u*K9bx$mXc}0Po4%_-I`wL>#qAY*H-I=a
z49Nix!#d?`FY<Qb`JFlEswdPHO%{scF(gV-SLcUGvRhK;w0hK9#C~Gc|1I2mwRf3-
zJehwWPm5e+(f;E_6n=vK=-Y9@Cqn=d7c9x68?fLwHQz}w`;^N6Ud0g~t|XK}<xvKP
zq>IjdAyilF;Vpoo+KU*+2q7ZW2fB-AG+hU#Hpb<h*E2vL?|}2klJ7ZJJI#<lk9@#+
zF?iOLT=&y6N&oZ%J#=EmtnCN?H|FgG=`&TJW?X<tjj@h)5^f4^H_c^xD1)xa8~mi<
zwYc+sTMHE9q7a0=d897sF?FUnSK$?hDgd6+fQi&CepSbzCW+^oiE#Rhuiv@P)TEy&
z?;%3pklX^N>2r1Bp+o#WK*v_5Y*q50+0x2U1pD@L7a<;4{JQ-K*x3whwVXsH4fQF*
z_PQ2?z%}mcI2eMt+$LmQp9jtY7W__wcv~vi;Y&;R(|<AvgWjKKE&`|0#u8rV;goLo
z&Rta??=HvVb;r%ax$T+gMC`P3qp%7eWo*D*Eg?OA4L+}fl#N3f!>;deljZ(I&vmjp
zF-Q_8&KIjkqdEKsYTa4LqII>CDdsXj#^}~Ph`Y7JIBL*h;Gd;X#?}d}zzjFx5H2P{
z-FOk^;>z{{op}JPFH!`s9(Sb#63(2E>NkGJS@bO^s}LiH`)CrM5wAxr{dP$nyFa>(
zY*-5vKNu(L+57as2Xoz@CX8NAAMB?EK~J8%>FDKYpb2*>Y?64~^ES)!J*_amR729N
z8o6%tGs#>Q`itkA>(sHkZ7vvq>Embvf|S`ab03Ojb(%N|P~A0F2(Z=y%{WS%{qMoO
zWqxoWu^7zAa9cgHmW)gTE8*@CLHYzkS+(M8S<bIPZlN}m$XYFJWt(1_t+-n;Eyl<T
zcNrVBYoP4{)B@I2>*NIR*2>AGcvW~NwI>LRUvl|z%*o}^wqu50ES1jWFKf^Yy_g6@
z>6RM<s$_rk;-HpcAYXL3Q*t(h@R&c)Xlo1r%>@FgH-8J6TBeSJNR0delG@r`43CSL
z!9?X<zKaI>{qp$zO*!|a3N5X?<!*hq$ISzP^5b+NRqn&?=}_&q&CUs0WEDvYnFga(
zgMG`@4qc7q2ED4q)pIo6y)5-%<HcQc{v#?c4!9#1LMRqS1<@3lZgZtBUB0jvcSvEo
zb#t6h&8M9kJ|lgZ6?KK}dU3oY0$L={9_M7XvtsqJ<J?uz5zEDvRQEpFspnJ-L7wCy
z6>Kdis<P#O&dC2Aq2Int*xpxuFe1HRYkGczqiguhZOF;wBp>C`tn^Y>&Qqv>Y*-IO
z9kJ}ST|O`sO@snIpAm$Z+sv9=HwoyUrWJw>4gvIMJfbI_yirmD{DM;TZmW%oqnx=}
zHxVkJj0x@NwU~DeAf@e8kx$NFF3O~UOl9R(eqd4ZJC#v8+*0|n()h(>g<SIl&n;PC
z`C`Toa|6(4Jf#|}=pV6ocKFc_*hi4GnMutWjw8s$TBpfSnbf;&_ZVa7YI0lohd9L1
z-7{d-noImY?7e4H6xh}+3J8cKMafY?Q8Gx*C<2lt6gdf!iYz&U5kWvya*icb0Y%PG
zpn#Hd&PXbv<jmXEr~7>8p0B@i`@UaqyxTt<gW+&s)edW~HP@VT`2c$;B_giUCnX2(
zQD(r4vBaXxcnJCu!oO|oxNjBu``Z^>Wn>1Ju&nBij}^}6rgponr?>~i_N?h(AjlT`
zNOXy=Bwg;CW(v$SfKTdqrE{+g-*rr(+!PEP+pZZNVuY45H0CAmGfjNasnKH9bN9bP
z?D31~Lf_XQbNv(PG;e;xeqT7W!~zCPWE~W8ce=#tcUc~pq4#e^qXt8Ci(Nyjjhh>X
znsi6;PXCD%{l_0>T&XZI8W$6z9k}%NMy*q`RfR^g#zffz*D=LEFi^3=&RNDHx6ru^
zpGyEr&*x$QN`pU5`!X0IdsR|^XmtSJYwi#jq$B}Ar*<sY7StSSWQSn1ux#c*E@q2h
z1h~yMA*Qa<$rkc2AprYg>IeIiGPw>=BFkg&+8cN+E#p#5)|g|4<k`j=d;BQ3wnnly
zxtBf7aws2V1@*OHjnjJM7`G0lbPe4wJQ@M+n|%P?`?xLz2JqQ}d);+4`Zy`x3^M8-
z&TW6>$yPrP694Zhs>r;7>+z5NfiQGf;J7mD?agEs!fsra{P1I=svo*?QEtHJjvlxr
zDSrCWt!Xq+Ia7);HpbW|-EAe_P<PL%z%B21FFVrmWcs85(yunXmO2L6Pw_flcRSS&
zY)2;+G#H5;qxSNalDzgWtu(fp6ylb~D8bGVF2Xr+Ae+jFfbi4_v9Ei6a~PGJtA4wA
zFj%_v!nltpx(fokSe)H$`L3?{s<uEfutq6%Xn)W;o`KHtB}9$^Nc(cexOI<y#XQva
z_OkQYh%z1i<MICAASSMAAX85Q$0S(G5OcjnFcpv1tALD8>L>eJ7c-`AZ_q#^oWm#n
z0wTHtOASb1^xJB51LhqtP(X3lfvV>yy%bbAu;s(gVBPhIIFT~dn0yr!q?7jucEg?g
zSTIK6qimo6D)e8sTZvL&{DF4q1}+0jv0QtinT>hN649Q{p-&(pRN*g4#qME-pp4Ff
zK?%|hU`+Jr{u;54u}d?BEpQ>`^vSYXeHzftRiPcp06@eQP=0%tOF#SmLBI?Zgf6;I
z$A1HHd_3Hcg2ATNgn&!pQw-{xP`7|VW?~GWxoabsl4AqZP4<S!JbiAtf0Q(4j8t(q
z8uQu<=wb@$f5odDcfmbX*T>`@LD7{v!Lj``R1!(+MxKooTHSKhIehc1ImV=weBm_W
zd?X`C_2bd=)y4jj?uLo;RJX>>)bHhmxwr|G>!V!bj%*?nH^7riju4wG_2qb45H%`!
zzP0M0)k=Cnq)t-!3cfFW9I-al%2*pPc4*gbHD0o+VAq&Ov%(skdZU~EX>PEgz4j4j
zK%|5o#f~ANS+mO@_~#$U+MnOt;BIxy-q!uLw;&^J%~{qY$Ic|UR|mFh)OsD>oofbJ
zmz=KxrF=x`ppGG=9TZvi=;?;Q@&-^t!D?MKU)c^BZU#2IlahYgh)2~i#j$Vq5(3g!
zg=&DHl-L5zyqke#G-O*#$-m16i7p#9QEulJ-@AGX436Lh!FgcXetJTc<?$Zsl2)Ky
zAmRt`uZ&ksOm55@Gt->lY;x}m2g5saYG3Np2ZA%zKNrT6qMA=)Z49cAmABHTPhDg0
zAv#r%=*!ZF52}G9ONkxuxBSZX@I_}hIC?y*J(R7a5?d(fFn?p-V(IU&P_VZ#CcHY<
zcs>$4nG1Y2AU$=$VGCD1hKTj3k?1x{Q>n!9ii!{AYPBjYvu7{8X-Fj%3qbQ2SI(4j
z^~ctaWcJ>#J2|(ut$2B!Fc{$7kz?Bl@v$D~!h@MVRBlZq(os#B_)tD_masN<66lm)
z`V~b{ygtTM!{}w<v-y(G_F!FC(RZ!VU_D*GUK0Ki@>QWWp{vdeEiLQ-xuQ)%kJNy7
zbLtJUM_u_##Sj|P9h<n1DW}Uo9`7)+#9?}*<g?qW0P|iQ6D=vW7z8sJKQVV)pVw_T
zhJ+%u`&}?)CdiT5I4<@p8dSmBnwFov=JC5#_p60&bRSqOVv3IG<$=RXao(-@A|Q_y
zn}5&W2QFuPr}XTr8=4cDD<O9BJ)H8m?=wE>NLdN!30k&&F5PM((*0_Jfk}aJcsq~b
znI8a|@}3rYy@`}QuRJz9vDQVRr7w=u4ZxKxv0esaR($~S2tPnb>2<cGzhz7?KQkw$
z6}ZRn{QIrZeN3MKdJ~>&C^Xw34Xt@M=s}VQVzb*}sG2DsCaJ<8Q|AYc;nGl9@3L7Q
z04b~O|B+hU;su%@ra&<%2Cs<^0^7;GG(HstJK1}~CSv)zM|SIjF^`RF-0VxKWj6xZ
zlD&HeNK4ywA3}`9gryiir3Rc&t|fgvFuY4Lk>ylAsp-tlTIyC?Wj2`T6qrySxZF8f
zHs6}Z!L2jdCA_^fvbJifqHw-!=j~nYS5Ap&lU48aM$cTT*G1DfGWi73p3lLvm%6`8
zDoKVY{-s?d=+ML<RY|`+scd?J0M;D<az=DwJt%5ys}^G57)<2E7K8IeO5ESO${nzx
zY^p@o^rN-omBvQ(Y5^whTE}AG+dkkd_DRgc{`4*L0eG6BGK(O{sbEUM;v-BW3sWGL
zGbF=3CR|!iqcBtM`kuaJ&{=;(ei>TB9!@V>JciBwLYWL7I#!0JYB-b=J6_H#u}cAB
zaJCnZjzZFO8C$BscEGN@8uWM+y7c|4h08gZ(3cV+hW@gq*;|GNrSD@P8*ArDX6~Wb
zq^9KSlGy1We^B7pQD8QR$=21x*Gt!gfEE0640gC}D0D)DT?^VJcg1z+%EPwwaCf&O
zbcT&wRmT9PLTk+O5Lz_FH&^2hM(9E!TYVLl*;|0|S}J$t%nNkUNF49ehiD*90|;8#
zAaLOLn%61~J~Dzu54X(x+kpit2zzk8$OSwU&ko+N>zxoR$yt|B^Y0jUaX&dC3%q!=
zT)1)|BE9hkB*t5DrQ@9$B+hTEcf@UQCJ>gmNiRjxOKO-Ow?FB=*B00cO=UPaBT<J<
zUmUI2E(+=%Hg4GEFjS-*6X6;Vsx?<}F*tGS?R5t>BnSAQ2QH?jChF|$RuM(oAg{~!
z^vjd9_NizG5K#3}vis?-N&Ud-OHygkL}AI<d`&8$cmJtC{$~*#tj`V_q7ho4A({*F
z<2i~7fH3S1H=GOlj$;}%XBf;{nWxUp2V8$mT#N0lCw#Y>FpgY`Lc#$ZD%5u#8oM+|
z5Znk(A~^K>6=tfkS%2bq4DjG2?&{?XbRF}xK`@la{sR0;_cCQoa%SAJV>BE_W#V<q
zHx@uu2p<!B34l@$MyM1q&E^n@HivkIrfDZJH6~-y0n9T!T69RZ*)X7~3^};ij%~<d
z@EEx@ZVK`>EjJXcxQ9LE+`ArifGGhtq%44vr9){q>5XGD47DXJYIPZvLIpz#bd0Or
za;JPfaN*1$l$%tGe4%2t5T=Y`GKR*v_^;yfxSQK)g8*PnDF=Ni1fw(t0V)M?4Gb$2
zv%FP4)-wc5#Y#3!rH+z4r*aEi5Xx@J1~%!hH80N3N>G~MKd+ScGiCk|9a*V6A)a!8
zDFVpi+FLP&Mkz3yU8>>VGmZ$e2goej)ZP02q8MN%`^9AZpQxB4MVwY+-h}m9rJ{aC
zuEN`Jl>^CBDDB>_%C#N?ICoT+h|eeclQ)K`>Qu&i&&vH5`4V+-bQ!k$VMj*hMH{)g
zk+}_zGqPv2lScY}Exv$U(ENIE+*_m-IQsR#(}*j-zHhF7LYjxOr%ubjapm>)<mmRO
z0g}C1eNyP>`Pvk~V$VwbrY#NqBW77lR56V*68avWdz_0Ypp!N#STSavsku~ojK%ub
zsC2xB7=}a<hQ&};W;O^aq-3FS`w}QJXQm9kFt(u%lB!T5shtjfTW}j4_NG+DndCe(
zme+OxrlFk*&kiTBmD{?*MCN?lcs1ZdK{YzBR-n@w*Ea(`1RkV8`Bng^mLd2xGtDjU
zzEBL~uEyX=B1^e2V9k5JU(pYa?7;5z!Lwyz%1MNdvHKvDOUMc^C4~seK%C2Y%M?)A
zD;eeit#M*-Mq#fAHyo+DL*0%r%^dhir-J~A(1I(oSIp(|Z39LWluM7|RuO^LLVDHd
zX-+CQwf2-bt39)Ufdrla-kNWXbRrK5<2LFIZ~r54>RA6R-5*O#&0^D{?PDhLR3zf!
zEfcq`lv_XLNPR3!l1#hUfF2&tnTk#u$h`33VDNA8r&({dwvRsMEO9QM9E*&3q2=QE
zTXNtpWMzIlG!@w9=(}ZNsyOag?`IduYZzHU3D8oh=#_hdbq^3L$<l^=MoE9|+EW73
zr@_x$Msh@+rohx;?MsaP_fs_R71)2$`)e6=1{_X<1bxerlbOGK@-)bc|L9N;5;V3Z
zKC<Fm1~L;`0h=d7kl%Vlq>}(Pw_VMz=qhhFx&RNXYRyKqozO+?PM0zmtZcT<)rZNH
zBY;gM=j}m(CncCS20IQ66)Wr&ExIxLg<$j1<=onF%>i8yddUyGfrB}GHf1?sz-VL<
zv?w2AT2duQtt2`YF;WsR(j)nK8yn^|Ylo@^4!nulw&-<W>k3B>W3bZb%oAO=Qm9zQ
z>M$npa9_yt-xmo4O*bX*$6!bizT#ar*$fr;8te*-Q1yltE(esg(Ao_!rdaucY5?J}
zOc-{yKkk$u+DTyoV7UR9dg|JfS3Q`1FK8;5CetR@Y`f=Ea?t&n6kS7pEtWBMkerTK
zmG3DO@}jh(e_9IKomR<(=8kSeVFl36a4^G!CE2Y{QU7lK*gP41m=D6KpRZ(k0mKne
zW6<8yuc#pC<|_Wqtm^bM_4mEw9mYHzg9VqT;-*f_RK}jwS@!c?&Y%9iTty}Q_%efV
z8OOkig2Trl6Nh)Z=Wi|gxut27I_)-+M79pKSo$+0YqBk4k4<C0NQji}$HqQ}F^QI)
zK-N1A#HNgp>|K-dNW(rl7U>@w?#-j)SzXEJR1=Z&g}M=Sd;80!U9`$A8}<yKB|o>g
zWU_T4P}>*GE^lWHhc3me$hh~+-nAYMX97=-pZh<<*Z-y@+`Eh6<Emny8L3S(NTWsP
z$LDURG*W(E2@>AVG3ck(QrE>v_^*<m`1wY+#Wdv7a(oXqFbxt#;~Ec#h4;B{S*R(O
zfT_1I7kI6+yK<AsZ{-7&hOZNt#g7U?BPkr-LU0@9BN>w^P5pjZ)#y<q8yZH+41wN7
z6yEbWF$agA)46Znydh7n1eQl5XpWW%0zJ%3N_`Xpj2qAHvh$fGFkg6DS9t*7;bFHn
z&dJCR7`TNFufuAE#OVDWTk{rg@evX&99^LOa`RAq-|FpVg&GKsQqdPugWTba{I^J|
zfA+dvuoPOh7Bo1Y3}p5VvbWsPz2GqR+$kB|_b~KhTQBN|=K5Bst@QWa=$pJ+_pz&C
z?$_FgWy7(RfmLqqg`aaTL_LSj(O=4aRm}8QHv41{XU9_sbozlcnW`!m0}r9j*?g)~
zwnc!qsYftGM^Avk1vT7vJ-WbP{;rDJ*A)M|XQvZyG1y*zl(Yel!~Whv&XkSN8Rrc|
zLP`OI?_mGdfwj80b69xawtp;_-}aaz#PXruYpUn}o1OdvZ4zb1WDWYiWeu0%geLm`
z!aWc6euAl$qz-ND#n8JaeaeOY+7uCvTD{HeOyW)@nq!_7gFBM~RukWL`%|Yso%7GV
zggVT=uFle6iiB@CRi8g!`NHJSMWinGE2W_!K}~!!9sO%0BnX0=ZVuAvdwLX0$-YPP
zD>>;r->ifZq+0uwIpey-y=4s2d|`fV_DA4bhSI4!-OU?f1cvE?w_5)a|9c=6)7lsO
zGop5y>TjuB5GD*)AEE<u6fX93GG!pR2oK<bYdgd0U&5_ZRtfr^S#}(N#WfCbNMnDY
z>brirP`VH(Zo07a?esx|ufU|sbV%*z0{T)_gS-Qr(E#OEo`&<>-PXnnwO<mTXKlQ9
z>NnrmI`uf#RGPEyxTV#b?c}}8h~s#E(&DC&uQ;rwvke~(t<h=r=I?)+C!|d=EVhZ5
zpa1&DtMi{9=d`ZhnEoIBj1%dgWCr+f&|azYXMR2xnS3CjaI{Uw6B}k^pE!TEd$>ER
zFt6FoXxxvpQ!zn<#+=;o&G4>*I=#XpSe2DsD@-&!hZoZU*gr|lKC1ChlB8NOSc!qS
zItw|)kmxj9bl6w2cQyEbKZ{<i)%1tIym}a5P`_C`=uh|8YMX&V%>I=95BuYHzx<Y9
zX|6Cdk>|!yK3<KQX(-&blKokRFQlQqodQ2Afk?aA`ynLV>_4y3@8>_x7n8r_NB<8?
zwR`wRz*{NNCtK*~KEoJnpl)Xu5B@x4{Owe#Bit<&Di%|Si-0OPc;?kIy5j3J>4`xW
zn5F*GG3;Q#z}Q1T(DC0y9l=6(cs(A<Ch%6N)@dgC#j7!BqQ`7oUO=!l$qU$<u76?w
zsB!l{BRK!a`*}ToqcdTI8vjkKG4>htP3a3%<&Kf%K!r>N__1E85^B}DMOK(YrBM6v
zO~WD7Bezx=GF1mX3TV#>h~|cfX?G$@cmC4X`<Eu{ze_W0v~WnGRR-_Q<HFJY8dPh2
z++~Ts-az)weNrO-T2iCW38E6I_Ma}@UEcD(BIrXvL)AzHRI%i|Y8^2hn!k4RuHEAR
zzgP_r9R6fa?(%voDP^{<8bAt(#_L>b2GafOq>`7I|H?+lq%mTyWPa$Mo-<7_S?-NM
z0NCoXs^e@iPnFzuziLS5VA%5PUt4QZ%u(w3Gm^CphMLS?txL0a>zZ+1hT&hPo&G0o
zE=9<bLF;H|h-{+&*Q%vvW;MaUI~WS^UjrAhar%E-WtBf&Wv-h>dq+HAUfWUwe#&2Z
zq)-#wVACA&{`Bkb;E)y2iWl8#hVfbBWynH?kKFPSO3)kff8|%FtzW^g0YSa?->=Ui
zO|T2#ARa32bgTw!@QhViC>gV-|K%m%|7{7L{MizCE8VQtQH>k;z^al0Gx3e6w}+9k
zxud@*57Ntd^8Y0kje`*e^}`|homBg;iY8ulLIHs+f!yoG2?ABOAm==)x%RqJ?^nn}
z0<_o1VFT&Ky+zxZ7M3;1tdRa(8?k=^2><bie6UbutO9$Le|EnA;@typ+uzcU{~`YU
ztrhz7*Zl7T^Y?-IA6DS+1M}xA@INfq-x21|m+SxH2$R|I;NBlz0RK7d`2Y3c=}#im
zSuh=V(fZ`C5!n7cv$V0m!MGb3PT%W>b0SfvC3{k?C(R&R)dA_>|64J?Sq`XMtwNn*
zk~#GtGNLfh39QilfA{%r^2*|f=|o%H_}l8>kM8h4GS>f#um1nV*ZpsAjDM~4{`SWB
zUt_`_+0)-<D*yh>{SHn4ePI4RFn_)Re;=6tVFmttx&A*MVLD1tfPLK$FRV}42V&Fs
z>LHA{xu9-;%nh{lVL;&4F;JHDf9`kXpn!oc4KRd~PQbPy@K#9@;d9@dl5{BTmB(Xl
z+o?u@anF5#CfL0TsP#EOaL2WW9^}BVJ8YxmDC6(iU<kV8_+T2E8sNW;5;yE%WFUaE
z7K34Y3D}PyY3kLIytaSbh22mSx#du|H?)!mFHiy!z%3Qy?jL_0uKfKm=n?v@hm;Ah
zPfV?VAvWtTCFDf%d2j#R1=8m%(2nNZDg~?x;pC6&g+R@iYd2ib$;e@74`yZxxns!e
zg$?IEqy1wYwFE?}U|f2_!IdzeB;$Y=R?damroX04uu{Wl(5LJDVYwA$O+Xp;QE0^M
z<u2gr3HX$evB+luCcQvj*<dozG)Od07xK+*w$so6p1b}SP(PJu9RTI9+tEU7g-<-7
zDe+(!38S@K<s-~{tHXspT^KG6l=}G$DtINv&`}Y{u?rb1{?Oq5wXP%PbnoQ+CYz?h
z$ff~oUhAvcXi;hquvXOC2lyhB=-L?8j@8Dz(=)^S>|*6W|B#jFSPcYJiC+Rii{2JY
z{&gbHGcXIr>%;KH=k#8+FTUn0Y0O(n4V2p3oR-e~O*w;6=3tup%*MEt%mW8aL_E)S
zgeKkk-GEG2SZt{~@Z9yd;o_tL;Q<EHz<`3FwAV%a|9D$@H-AI_U4KXa<An4m5m0Xp
zFy}L=92oZ7Yq|;20dAy$ZFaPQR4xf)a=h7KrOSMu*ec>viVr%sbi_O?8_e&5;ZYeO
zA=&VPYIgsFn(6$mumbIhNe@GJ>FE(*G13p1&xz~uuo}T(BYx?hf3OPwQdjA>fU@`i
z!vziF#t5cB9SB4V9>8)UHpe^EbIKb=YxVBsRmt5RU~zIS`4yPFIkZ+(+$^C-o*oZI
z1=p?FI#^9*MoJ~Hf@9ZtvW8LX0~Tl}8W5+vGWWjUJy;v%&qp>99yunSN}#`F_F<@-
zb>kSV{_eU{V2x_MwH=QjKcK&J*Kn?bn>Wg3jv?6CuY0ha^P7Pa*DdyP;ZxWP2=G}^
zI-a9yh*QM~^ZG&b*wOO)6J7SbJG{`g5zQTyKRRo#P)+MKFK+fM;^wHte`Hm+eGEKY
z6oEs+#mQ=e(^$baO<+Cq1zh&+ey;4v#d?M4HJ;zK82^NHI`%LfvKUOi1!D(8=$Hx&
zD(Vm=s`RG6lR!gry4?ItuIf-=GkT0XwFN#aqqAU8uc-e{;xuQ%Sk5Y-OFD!eME(Li
z^BgcJt$gKx%cm;-iVj8&xdOClDyGMMvBgM}x1<cAj#~M{9_ejia)7FK{!ep{f#s0F
zLeqv*fz&@aiv~dT295rX`;W>iO&&x+{I82fT-UJk2sBmS$w2PtLEdRWa3Emr1z^@B
z%AxW;7KC0XN2h{D+{r-wb!2E7<a~*TP!00mV1Nz{%n6zJO(f}xM1$>ad!hH6z5)1y
zl-yJ~X>0h-L3`9N!hzP?!^rG_med;Ni5_4Bkrh6w3`oBBffdO`TZA07eQtIP)WgK>
ztq-_tB^E^7m1bz5sV-+Q_MAKIN*1?H|FAsNKNeyghE#Vu3tb8&H35Ou*$x(skq$ym
zq<(S#QY*p-Ly8~M3OgE&0ZN(Ha6x#Wg&}?9QiLavc6efB0e#G2oSKJ5y>&L*KYzrl
zy8Q_K1>`?jU|=0{I1NAR-b(-7d=MJhhG5xz0jGx@>>CWz@3z<tV3?>`Gr*c?|Iq{p
z0qn)AeHV5x1~&shEMV(MWp{n`5O9HE(Yhw0hV2<QHAH{{a8G!a8(49SI-Q1cKkb&-
zQNaiqDA|+9roFxtPq*gqT<d1K^#%C-SOWI%-7m<5UbDgZNa>XN?dZa16{5h-p|7Zw
zaeOzXe+{E7$Iz~SpviKo0ly4B4zBvRz)t2CFyvv$2ZXuNA{Ic&KEqrDD-&FydEXn;
z6o1k<mB|N@H2;mm@8>}f?BLKV`a;iO0&TfCs3v7z9-z2Bj=qzZbMa&Rq9P1(y4l76
z3@!-t7XnEwjtduw|GkDsAuw85YqsCq4e;R@l}jmzW0njq3H85;nAIfr1~}vTclFMB
zb`ywn<gl#I_J#}b(=jRuw<+%>!Rkl2V)X}gn~<-<M~wtiM$V0Rwr?3czAKL|0l%4;
z`s2Yut8ond4kJ+PJ7~B#LrZS|0E;gN7{XzFU}<7w^HRyai=OTF_wxiEwL`h4LkeUt
z<{D$b<YK3f*dH)R2J6*D0zu#&bzKq;=hb9HT<Nxm5M{-@SVyyHYl(x@^IaIHiZ<7|
zCyQxjr|`4{|D;33q~=70$D>L#nC_!a=UDmFL3BLAxeu5kBm^Ayr{(~;NonsdJs8u)
zVe1M|M(3TkPj0P)bDrs~>N$5(4oo&6?PT9VH>dL}rVR2I=vo;(jl_VMfxRIe?gGnM
z#);`}01vyCn{At{XHftdZvx|V<@9a<(~k9f&xp;ZQ^_2KJV+GI3Lw`jV`MISqd7~a
zUp4^`e{fS4w|wqosxL%ln2-bUVUlAAux&Sfyzq2UQ)YnYXb1Qjyy|b_NfCXhO{Uq=
z3cRXfnQv3ghp<F^KR^EwdGv><^Pl1D8Zft75dZy&P>BpO8{D;tH*~@w`x1KL@7|a7
z!&Y;_RVN}M`a;zYS_y@spgJbwWgyS&8Ny{A5DS=iCGd3an}Ew)mePp(bLf{->(U2l
zqQM@~GtW;iMvoR(<HUg29X*k)73y5_&n%#)7#zuVsUwZXJfn;sOB0j`u;BsGudNbl
z<ufNS&ld@!ga}tj$Ng}$w++k|i3Sqa?ic({wZG(rexqh$ba`~{Y+}IHr60JB3@rPo
zda6ks{UmQp@O#u_gYgvcG(3GTqv;lqw_XV}*31$E0(t|x4*`q(>GAB<z>!iTp9Xtm
zUfIEqmyiqKprVC%U}y3D!!29D+7HiJup@6K=oBDP7*q=Ya{YcF8PYdYD%<Q^mg!W(
zeal^cIM*ia*A?qN0hqpfz>dKxy{7WprK=Jj@J0=M3J8=YoxhUgf^nLIHADFDyygqX
zpN)CN^)6%Y{g~!!4-1^iN3Hr_U7FW(weWcX>22gRV!pixNTj-7?K+Kxp_l2MWkNR{
z-*1I(8Pul$mc98o2wFxYQkcia7C7BRJQvD%If!xNa3}=AWqn=b1>^QV*Z04k{F|!k
zNazUvCQRDszzB$T8m8OJ8*1A!w4`-6qWuFrm(B-8h5k`C1ef2rsW(_Y<m%DTdE+AB
zuJQBr{=xBY0q@In^lN*U>T3`Q>)l;Uzuq3+RYTzB&0XD$U4H^O;y?e@Fskcg5baYM
z2Sir^o?DmemEQpkBdV5_w`iLvqxC&a?3rL;UClvq84gfqDE=DuV-W8eBdVeO9Un>~
z`7J+E`NJy-JC;OfB<+~BH{1$b9u*8#n^H>b=LcC$#t0~PT+~|+AZ7*D6Ka$uK43s`
z@oI}VSzF$E5I@MsOMz5CcheVRI^*QOYG}K=+`9q{XTH1<F>eCCHHpUusmIb8!c?C{
z&kyHI%+x9zC;LDGq2(6P)(Q-S;*5o-rT@?%t;@&e5TqjjlUyH`!ckDkoD8JzM+3W<
zun(lBItMW8OriJW#_ySN2f)ZG|BOs+T=Qy=^#qJ0U;wULSc*{~h%?GP<`UE015DI#
zYCh&OaMrr3A<cU%DwM+rh9laAG7;%&S-Hm>7$&;!MwPXoz58<dTPuc|?W#av2L#9d
z^2OL=)KY)O>iL2x`7{_XuK(d~sxM%{XJhoH<NhEuDhZ6L?Ukp4G)R-BwaH4E9yU=G
zU(<10#t5L`uFPo^*r^2Ma+OP2pVaagYkq!I?vpxM`!vnX-zlym$5;OnP~&wmR#OJx
zsVlK&n;!=X41vt))=DRd9q_`@B<edmfK0{~SlM;fw+Ei@q-yz9*eQ$#HZo4aDD|I3
ztqp+MP4W!ftS@yP0^@-v<I|d6tsxDub2ZY>e}2#Nb`883GPy05((K71@5U2$(5B$0
z&WxbE(B~~l|9YALsBVXW`vo{MQ1}&f7m<lsXHr-tIgd$NWlas0rzeLdeW+m=IU$!^
zs9}`m#N^orkf80<)y4WIDi1kcwZnJ(B+>ozPE9<}^~d0IlIYPQ1<Y(weL>mS%9sB2
zFHlRF*t$Uw<CD$XS2CXOb<puvw&Cbi<#EB2{_CF}x(RHtU4pZ!8p|wk8+quDGK^uE
zE}v?Qrr4>of_40bKjCWNWs6POX>bs|rbH2{Knml@@az@}9%Mb{h1CY^B;c6fhLrtu
z?)ZpZ&T&Rte~v(<k_p-CSq%`h20!BxBB={NSYSTcc@6DW;Biul^wl2nYeMvK=S`v3
ztSPZwDTM}dc1zMQ>_fZR8v5yZtj7%&i;8SgQc-L^0!-dE4qX5K9mz@bQ0#Ivq#j&m
z(eIv1QJ7H>dte1U-p>JJH#Jv>^4Gi2i=Bx$Uhco<<f00!AARJ>x~{jk+{=Ppi+$~q
zW||E4Lk6bQwAib=L_=Rd@)UNTLkDrqjN9efA)n)f2pVvSMR4@2x{^fAO|O1F0udQ+
zMmC>_w+j_~N$&bScI`(Tp}SZwZoa+BlmkXcw{sTZIV<d!*^l1O(=W*}u7_Vv!GXV*
z(W{gK)hwB@Y%110#X6Q>Tngqt5(ME`X|so*#G$=;xfQC9wS<z&%5j*ijs|1dA~NO-
zE~T+p0uwWEr+8dMfZ>Q4u|*gqSH|()YM5UKL&q%$7BNs4PCxocMn^gF9gFy7sok)e
zh066Sr`Rn;en;EyWU*$!2hS`@$$bxr3&ffUj#8#L^W*Dtdc4Tea>*?2GcXj>SnP;j
zNFTv@KU8X~#nlNhqZn)Zcqi=3aK521t)x%s(3^mz<}fOpoA)-gu+p$vTrcZozu??E
zAUS^dbQTo9I9ssIX|eJ@KX?Cf5D%T~P-IBLHEkmDH|**Hme>f1-ULYNf1OpoTH3?U
z!I1SDVh`n_Ppx?QkQ&G@X(Q@2ZT{HNQxXZt%L;5Avpk=(ga?qd)tNRQo;Fmk^v#<=
zU8&M{{a8X{?<wYL=3KYiyEyO0bEe?eeNA%X4f7*2XNpZjbIhe!q8;)4#WoqRoxpB+
zz*$+mBpE0rXuVM>*UbMdW8fFF|A$XL?Kk6E)l=@<%^3Cu9umx6YJ@$N`tF5LllCV;
znGy%B2p3L|ERw&Bw`d7z39x-CefFuO>)-C%j2z}j4u7`AhO6xE=3>G3H>Y`mAR^)K
zY51=P(LWvGg;DV?2-x(<+*W3#*O$j}!?G6z;6pUGvB4!3Z1Q4<aUt;!SJBBLE)OrI
zg8hF9hOXIM-hDt5B!U{+*<I1Xj`?+PpipdP(UvG&IMVtys#g<_P|$wl1M1P8Y_rA}
zV~1GhIEK;eJ=j4eA2Q^^G>goe2kc`HB=K};lCK77etgXi^rWA`v}v>XCnx-u8q%*5
zS41(7(urcVMWHIdc)%Ofty#p>yg~R^%ehFYu{Tk?_>{blK`F6Lo&8~vSP##N-N=GK
zM#e0%Pq_>_NYJ5vjiNFO2VQPJYVMW4i(+Rvd-F^xkJ!eioX4ASS*xz_eap@EJVT_5
zVh%sjL@_PhKz`$3W6}_7(OJU(*bO>boc;Yd=45?C>EI2qEC07xHqnm?ZdYIF?pI$%
ze~sOp88r+gmm<Cc>`ePuLsZ;%TBuq#$_~9h*Kf~I82j!jC3VEsYuuCn>73g7?yR+Y
zZX|qZ_x22f`2Mv8Ws2nK)r)z;BDLv%oW2Vek~nO*#M9jST9!i{ziifK9$Jku!Zs(%
z4M#SwX+P#MMb=5^hdwiSUaU<y{wjyqZt2qy*4n_^b20WIJ*3nJKG!kzV?RV=U@dK>
z_dMxjWq=kjufy>GIg9*mq$hId`xG2s%F=AGib&U{Z{Ub~1#Z8>tevAx7Tad<+Magn
zRd$<-rzrp3v=v$9ILn$OQjaj<wVuczSiyY=NOL!*(t*08Z>+50N&J1w*H<6TeXC#l
ze%9hhGHTDuTk(pBDx#_6Q$@3pWlpxb@Y%#9R`tA->vDIz1iPG-?{+IQ7IWP~71N!E
z)NN6m=+^t3ku62LD9Pia9{*5^JM^87aV?ob=c~~;CKt+ki%Dcq8&gg`|77kKU&s$T
z{CWw$H6A^zudhgCqnPENy~&GQ3h*v$LyGNG<4@I{#G2Im$X#sj6Pav<Fz}1LO!(?s
z#{_@yZ|@H*51UADVJx~N2*T=ftQ`blH){(Cf1EPK5#as7j2?+^T<QG4$~Nd8797j#
zBNp}N@e=E+cOHL`;o$Imf^SAcfOX3%C<;tJBrv0FlMFbGqcSuf!G`xN0om>chr4F$
zipgSSk2y^1CFt0Op+{z>I7ByaZ)O1F%qv@=WN8ZUpN$cOZuiX<KdM&aoJLtLP~sZ~
zrJ}IzU|aWOK4Ua2u_D37x-0i$+Swi--RNHJdr<HtBL;h%9HpU&Rhnm9Q+}&bIYy%*
zA_!99G@S$HKEIo*a$TbAu!0&_0YkcJyO{zKIw53Z)%)+7!4P?Sy?Z}H17z<r8J5~S
zD6#6iK0jLHS%|Mqex>a#$FK|=w+Bo$QQl#!l<b6vlCvkSad!b#8^dp{7DX)2&l{n5
zGgchMK4F2y{}7C(zCA{EdFbtbJ=B;-euiZbC2lf+r?+$ps-3=P#Uo^F?x){Bi&)|M
zOdm!FZ=Ng22Gl9tb*$$d9GbIQAr1yy)#=`BU!Ik|v)ET2eim{!laxQ|k*SW~Z>wCt
zNa&g(O{0r6)!G&zWAksiM?T)l7qoI-BJ6gM>o7a@Mb+OxPrfTlnOZ+}ZP)8~->`J$
zr-ep=Lj3K|cVA2PBQo(#>W_4jv}$c;*?h8kBCiviNnSz9)w&53gv>ToQpDdFrmWsy
zI6A6&-2QrLS?UtOEvp^F6pqC)xs;`0#`~xUr=Bc{*0VV|4>1Kxe|zknnx?d7x=53-
zst@m%s+gvCBIwngEFG<SLitG#_*y5b4z}p4o1+}R{xY{~qHY<cB-MpE)qObECOwIb
zzmlootS>BqE9N>rB$eX7azoC0vs*@V<AbAdul3^-8UGS%rd_JLP_NMTKrG^FmXr?l
zGXEs;q+I97iFs=|zm!Xd+$efaOHQvAqlId!O}rk-dY&6Qe&0MFY>PyxtY&ued*Tc{
ztt^e)r0mcD(P~*R?XnJoq)Te`{&+giV)T5GETPtric4MJP<6E3%I@^tdov5lq1Q!=
zk*QOa-pZx^2OIuHd%xZ>m$T8BMe{0}L;DKib&us)kj+!o-m%;!l`5W&(-w4I0-;pW
z1z1(Du5S9@O^M|(?H%M8Za&OZh?Ku_qghxomS~Bm|Hr&Fo5tMXXAX6t{^tjJ>Hz8{
zJE~W_?sAPMvA%=-CbPhp&Uz1Y6xp%%;kGSv==X@{F|ShakzG$_=?rD+KIeYyy~^*f
z$~v_{wyHc_FqPF#Rd{{TlyHLsg8oT<Cv^TGv?mFSMLrBWAz7jogla3T(fKj7Kfc<X
zA_W68)x!|qPir41aJnGPm%5EJ=!PA8zrKxRvqDgR9^=6~VpaUEmU=5N*87{oRHaLz
zBj1yim454tvqyecVeK=p{42P0JqjO?&t};T1TL)kKAyj<>CruMSfycV>_Ob}Gb8b9
zL$QBx>>I#yi)d(Ic!!twJS%y|`)$PZt)RSzvRDN;-`j39I#G%kHJHm2l}z&-duVXm
z$2r%=T)gT^l2jG<KJ!=|;$nWn=65rclB>l7XFLp69f5FCV9Zo`WYvomf{NZQp30T+
z#a*K$IDN)?b;Pk`uj582Egx~TnNY&k({R(!Gf`C6UTgV`qKkjiP7VAZurML~m#ZpM
z^*K93)v;01R0um8y~$n3W#pa9$jM#y@%oQQ$x)hRZqDvtH`2wRvGR#RvGva*cu45e
zez*HapT-NskAoK1t2kPcS>mtmvBh?D3E|Qyso)#M|LAg6_d1&;v7E2A9Z|Djr5f2k
zLa#S4i(eXFBzuJ(g@d{1m*@`Wshm{T-$E1nxV@5xrH~$JvDQiW;^eqOu9+uK>ZYC(
z-`hm{`+jox8F|U!XYQQ*^;KFV%btn9KB6@(|9qM?6QSsjq(kH6<ei)v9tKLhaX#gI
zPtW#qGZfgcQDF^JpPH<NPovWdaN#cxGJ>%Jto_@k53qEb!x{R`3w(GCD#VKZHSd$c
z`z`Y+_=tzN-`fwvL7@9#S4o(pjFMgx>hXzjA#W#x`tg}$;CT{NoqbrQ)teffd;_we
zTk`kamY;w^EL9`McI?-DE1Oo1iiZr1q>YkJz2DLO;L$4?JeRfzP<O!@{M_73xn_Xn
zJIf>chS<Y9h29GX0qx7W(izX+T3X|Ovfq1E`cwww$@jTl5~~M66hE<MuMRs9q4OS4
zpHRoP9lw^sQi5w_zBz19m2SvQZv;sxRvNS1L|9KwF<%uC;(k9SJ=W_)wc%HJ@8sZ<
z-vBY&C-n<(_rM)rpKg#Q0mIp|5+_rgL_X>l7*!Fh*<I_fb3d=Xgm~yLswNq9-8<&r
z3Na~GlBB0tWR%IK&YvIEeG8|J!2hhyjiqy3+as1zw<>hzu@*Jt*F-(b=DqfKm**k{
z|H;zqP6duv2E|OWZf#ukD;CT1<8E0&{qgS4B7|k^AHT17r=2}mEg*Qqng4u74eb@>
zl`fLYCOhz+p<+4mh7jsgeZlCjwxNv%9`Kc#%msH};2C*`kNYKugj$E#3UL-@Tewi~
zw8x_wpXrC~c7<L+(J!`?mqgOsCVSVSQ&9&O%RjtA?u@7R`t`|???#V~)pP!jeevdm
zLc*ybixD}_%yHXGTw>N(SdH#qE+BsFCzkfJh_ubjy}2DXVP15hRQIw7-X)Ee!N-=L
zv$Go&&3o%>)=*oTydJk$8cf~Lnti$)nH#7d*;8x$(2xCRN~7~3JI@V15FsS|Qe)N{
zU=;57&-)1jZi{cA`{};wq$*miXFs*hOsJaE^tekFFMD6wa{6+iL}qT_)WG5=l~y6r
zKv>zCSdpwkbSJS<a@7uHQK~6#qo+CSdj02MY)>ETn-%MGM90rytyLl~JPL~ylVeWe
z2qor1THZ#c2+?cKo{HX+5MS^zEMFJ9m&CKTp0lH@rfB3gGdz4Y61fK&1`wUs=numA
zdDrLmvGWWLb`09$S?KajYJxS?9@(C1YCx^BaeOI~DmJESy0LRNN+boin<FSbrAYWI
ztyjCJeGa&Fq850t!N3K)Xt6|iKYov5(U`=C<SOkwmj?-Fvbb-QSosPE+PdR&Op6-5
z&6v*Ub@$R*3b?h#fK7{<>&xTt>@(l1Va2iv`&sl=#Ws8IJs9~3;A(qA^7<aOSSQbB
z_$cpvep|fs-9FZu;g!*)bP|M*^TjQHX%AKgF`E+ORR!W}CY@sxUvT-Ws1<FxJ{gPe
z_ir`ckgMPmy?&HIp=FH2dM4t_c2;Vi{N=LqHJOK+1xEGqEN@iIXXZ%apH<`!BWVW<
zboEOb$1TM~v6i3zXo@bi&Ex}O)1G1nS$0i<)K4)|D&=^HV_u)wI+HrLPmU%PqMzCY
z?19&p%;?TD?N7DEOj~nz7$l#a)^HeZ5YvC>|4w$Sby?@ZQ%v#qrQ*l@v3SST&W@d>
z?l8d)VAc3;&wUs4Hcd4^H2CuD$HzB~8nUhu1*OR~edfBM-bRasg6@)eL{Fm4;B(VX
z1)(H*6ftKUT>#;_ywaDg?6$i+Z7x}FKl*&2(&dIy45w(FkHaN}?}7#j>u)VsA+<GF
zMhl@>xEdDnJ!h36FQww~U^FcrLtleuQn<7I*aFeZZ;T%gF+GbhPgHAfdPm%@|E|Ce
zrDX=mWa{qIy3`Y%nKD_n8bFH5YqxJ$EuQ=Mgvg%dCHrlQo_VUQu7&&Y78)fFuaH3A
z%IN1)B@b_RxP57urW8<AMtVA0pyqz&3zr=itZ8@B#G-$`Q;^g#>61|@80e3UvVgSC
ze1DTW)avt9df4H?Ph|Z~ns%&ftCedn2+AqmjSl7v?qx1Vb*@)K6K{<+T+Hy*Jw=99
z$Uvx-yU#P1+sfz$@-2wkqB?!1iGS=JO`w&WDe7J4Tdtf5=60(F4juh3fhrY-&uJEI
zH#~@=6Tb|~OdSAYd<4)3TUQg=I4L2(rIIr5IZ#*@n$#&_&B@Ty9CeIo>jyky;r3gb
zZb${?p~YncPU6)dc^?;C#KTb#t$RMRY1s^X(V!pP%&o8HW#uucjhh2-0%!LiE(p$6
zOE0B><(PGzNnN$^0hVyEEm4&C9YYF2P><0ETXqCNY_1X^zyNd>BqW$bg~yEaWFgk{
zo<aouF=wL(-VjGf3WQLs0N9Em#Uie^L@+2DSC3F~OycRpuL$4XAv2S{(&zg_!=W?d
zOWwgdIEtNOE4v{_Qvsw;IgFA%A+lIS$NOcXa^L;1;2-a*bCZTqaL9v}L(Pc7H-;b3
zJMD8~?e{8e`*X7SttVVhKdtK-{;!3NjE$X)F@eA;(K+6k$o9`z#rMh5ooMfmq&?a@
zcuS>u49d52nrzK&T1TEr<BPXk<1F<s2++WKyGDp6#iEVZnC>R0c0X-#rR`ABm+#sw
zX5(~@fJgOxF#c(ANvHA0#Yv|y3AVr{5vYt`XOV`NgZcyO#@UasMY;&d(o1_;KbKQ3
z?wC<5o_TU`kLl&T|4bc+&)YwO&Ls}ksBAFc5?gYP$c!h{x6t}}dgaC5oT?cGmL}Fa
z#eKmteg(BF=~oc<aa#P?QS9n_x#-D$e*h8|uQ%CdYPHU_q*Z<BQs2dXG8jTK{LC|F
zyngMQIqo*?Nvr#q@2yG)<>?P-T$Y{pi;*3!rS4fb6!xT^G15DeGD%vByvlg}{4F68
z+MjwtoH+_pOn$G)Dx9MA<`VIPIj2B-s<JapSeifw>5Z`r9C-Eqw4y@f<zOk<%uPi6
zeD6r(>xTnwXG(kb)Ye8m^FHt!tM@JR=rn8CQBMA7-V*YlH{<wPoa@bDr-`hStBifZ
zmddX~%FyR^Zv}h~$;ARVzxNKVJ%SDtJPuD75@`1jXD}-woE{iP=j%&HG9z8<OdRjC
zsFl1)E_=owL$jP`@H&V5+Lq?$vz6FUH5#}PUWZNcj@sL<&gI1C%>!8n<<g#u*Gco-
z6%em?(ZjdmjQ8qDzO^&FW<{cBf*bI@Kkgz@kaZf#!XHFvvFSyDOxdhAPb<Gn$f?y&
zI_SQoM@Lgol}Rjia3l?aXhj^!zrYh`xOPcpu*z6EUoy&OOXJOwb0TTD>ZL&%ZL&4T
zb;CWOHo};p9DkPMa`RlXl@wMPbqjeFia~5Q+>!prNs}y;$hOCJ5&d1Mb&uL(5M-}I
zDS2*U<wV%UEt!b8MmtUuo+s0D8;P_T^1{94uDYfiNy9SVhBr(<|M}xlROX{TgL8U-
zNX5HS71%6gO?xvnH17J(d4X7|4O6=&V_=GJ*8!k#R%vNz|Dns`_*xXy@P}F`J-kJB
zPu%W{VW%lRBsyPt@CoA!!Qm6)9_hnjY%!O)%0o%-4-Xu%44$r+`|QyUAfK`{CWLOI
z4em#D-j<lIA!~Z;UgdX?%0q^eAoG5TC@O+%IK?{w^@`YKw`<t5lLCi`GK=F9ayuRi
z`3QUU>m3rmdu9{`^AAbsaoHLh5uw>vNf{3Zf+1#+4`t#NI>_-1H`d<R#zlAH<A}NJ
z;O$*B@1O2lwiGIsY0{Y#?$MvxZEU1j-xv$AL^<M7Zl`eYgb7{yX(fLqU_KpPM(p3p
z#E&GjXy(W3rX)Z?WjXFpouu#0b|Z?qQ!hWEHrf5<(&V$+MGb<Y_}KAgwEsDC(D}k^
zVW!mY<de6*cLb_)4AB_=E9QP-`Hu{^{*MfpR>b)x39Z26q-H=JA&{Zq*PwxGW4(j^
z1PLnbLPxxo#TNF=BJhMGPo#oDu&?0;U3=W0qnZna%r{e)sWra9yRyzC;vBTS*vV1c
z5p=%`+)rapdPWJa51^BC)u8HmcFXZgzxNDg1>fG?XrFU*sJnu|LEZ5`PJ6rzhPI^R
zlh6_j-4ngX8yOr-oN;;fyWLMVq|$!yI>5(qQKT|?s)<6m`lXiblsH}r6bkPlfX+0$
zNWaVVAOPxr7SQsZMlkI|MG)jxd}Ov#bl+~;<%nF1*kLT&zO;fxx^*6-$|pwFKOYEp
zCJI+@<P>X+T2?v-9rXdoy5=JQt_Cyuqd9aV0?zhyYy4LK4JqB?v%w-GBMaB!-qr1(
zOk}r=RPJSYO@Vl_L%oYUsqO3~;bhW7oicyE9I$m?y!pb)HMF})rT}~4lju6xypiW_
z`n}6DH)LeJHRUs%>A7}J>#!0^U$ZFj8{W8WsL6yraM%)>h4p^KzI!!glwKUAHkdH3
zc%6eedGYlxP=?xQDEE3qI(-b;AGk`P2T2KL6HVqVc{TehSh3w$;{mZ`+wF7-whTPG
zhvAIu{C9SAm82>P`&-hydYjr2PsWD`-EKFUpA4_8VLyk$dcC>^JLybSuiwlQ?J&Vl
zdlhv$90ZYOs^-aPcu0jMUjB3_8K+}ymxraGoS$QKExAGvMV^6dvX$ZSk9)A@cJn3m
z#tQeHPfrZ2uKTpjlu=yX9OY{!Dg5}N&n1PO9f=mV`rK5~6!mDH0M0gtD|-B+*lWMk
z(A@Rg2iv$ym75=3k81rQvz2Y8D>z{|aOZ{tfl4Y%{VG**ew^lTv|l}(RI_*khJ_$}
zC$-@H<{4b-6Fa}S-jK|-4Z4&>PwJVfoumc^S7Vz_^)pX{nA;kMqA786J0+yk*jjPT
zO81v%;{^&`44UXa7B9V!4nLWHBl1mhs8R-p{Ts^U(WCm~ndp!Zzm@vVVA8#r(@goh
zt)45lJ}pJB$vQ4=)aUz8zelv)Og?PcF^;(yDQ8ErI~DMh&CdFgq|tcd?mxnX_g+Ty
zR$#X>4dT0PeOI(X`m|!f4lW^ZzCgdWtdAkZN^PmpGwfFo29>AeTr&*^w@9E?X~(Ba
z?}*nWU!6<2eJ-~8p>lq%zVa=Xe@(mXVv9xj^n$6`{7v43Xffep9u<#C5C3^h3t9dr
z*1c>Oepau({J6{c2_7)IVW)S;W;xKIV(#qrnY(&LSUn;EYvi4YB}R4)^7(`VU-Y@w
zMY6=td?PbnUXBR0YEh-Xr<cC#;HXy-pQDllzY}Pfo`v<w=1Q<Q20V#Ttqx^r5MZ<E
zE1f-NZj6ASh~qqtNshY;Kt{{6ycQp}doVliF;kMmg?=(fyJ$!45$^RX%^@tsZDkJ9
zJ69b}G>Oyf<w9-Z#9kT%(d9OU4Ru!A%{SM6F@ZB@?<+q5RGM@mVi^$>v2_FD+?c}x
zw}5cn`^8bXH)-yZT!Av^@DsYo-Yx(Ofq_%O%tQz4ebM~)9=_Vbu^D{Rt&39-8h!6E
z1$%6cHnEL=(@g}!_(3niHmsBtA`=s1Q@r!OL3ylnxiR9X+_Uu=afibMLg<cq{Hu)P
z!yZekA5H!l_ovJ3`-9kZj#{$h4nC$z`O6D(R9uTLe%ASzrFBox9yKayjtwUsT;wI=
z3^Kd)O2Eb_89JE1hOEt0xq=A2b_>Vydy*0dE%!qa@%?*TUmLr|g`L>!MOuSMgQ83&
zh<XgL+q-`RcD<YLrqIhyUQ;OUFR@l9Ga~=mIOg;2`kilMVgU{2{!~Hi1Sp8_{#yD#
zZg?YZMvw1tT-h3Rr_p}5?@GR0KIcHKPLFtSi5j+2t3&`5L8+&X$>Q51X5y1u^l6~?
z)eCH^U-@4T)+{utdw4PL*=<ziiZO3zlRb80zIj7$b8zq3XhZ-VB?98d^k!aK7x(=*
zJW}GC9EVkyEXnrhc=3ny7q^{>eJ@W*?=?wB<u1P0O5j>j;GXa3%5eHBMp}UFgatP<
ze8bfkwY**}J}UGUOZS6Q$u~+NJpVIw2EDS4<x2?_t@w;~--JGG`=w}_-3VsTYb&N)
z!8=r9Z0ADhVm(z1K4Xv(022rfE*T()hjd-=bIaJE7Oq;skjjb<>dnFZEaNT0agWnW
z_T_<sf$b};O&+fWf@;MmuWs~bnK-!<N4${D^^fDz`Eehb#)NolW_()!Hw_FDW(v#6
z<o(hHX^~Q}@cz+wiQB05p{#;BS@Zp@oy<4xc~7>VH4dxquA@wX4(`z)^-`G(T0!nl
zxye}Ir~btP<u#fA^0+XrQJne0!!PxPD{f|9%?sCWo9ei+`#C}R+juYGH(lmier`@V
zPuWjF+yATAhbcR@e%PXLbgDdlfampH3h3NM)8-S(z`%$VniMk1aDT5T{0!@24bvu4
zCMgxOEjG<80?d@7&xLwL%=spDV;hzZQ?=eIPSbinFWnv}gFDPZZi^gku_BeG2Uq%G
zSLP*s_YvRk<CH9~#xeNb&=a(1A%+g-MK43Yg^=OCtTZvGa8v~zsZ>8e7OZ*Vzq?Ep
zytf8;v)6xw_~BEsL+G*LptYzD8n0x{?Vs6X>4fZ`z{MsHD3R=-w3w*}Wx=~5FfQT~
z7M8&EJt?v-8u{05wqRBU46u<6vPfy}-=?M;1U6^)T&=qA{YWkYY-Mp^<W=nWXej;P
z(EP7<W=Ez6)G98f#91OdX6C(mJZN+4yH=4eK6%@;Dd9(QiaM*iX(Tq@8YD*DIzGSS
zb$Nw_niwZ7ggqqV%Hr)GkM>;Q#HVW6F*h}-9%0Ko)b2#C-Q-^2tLTOHdXu~os`7v;
zb(oPrw9Oz(*Xy-;Row)~?M~Q38VU69oF61MFRdt|#Cu^z&jOg<Tc8zRC?Z;j$6r*N
zo<0`HgDMG*uhbJhmwAfCfc5BPsoLS!Spz---DD4m9mU2n|Ms(dVZb7xx^q!GB}pIN
zGEDG%TQ<4EPZEl6a+O{k-cGvIyPo_A>*mA_f*jnQ;s^D(_wwEmB94p5#7}vh+iqZI
ze!%URt<Fe&zV@EXtu?+P4+lQ8hUFY4{A~W6f`Du5x|ym!Au8{~GXKaG-w$b0pQ@wP
z9-3wolJ09KJ7J*{X{c@WJeI<byw{FhX)8DKY_9v8MZmjVc6*_--emeTuXiKZRTq;7
zQxdVdaUQ`5(G_O$a!2-pKIeH0o%_F%2kh%RX@-_f1mOpK*>F^zX7hHHpumVrfk}g^
zZoy<m?Ap)9FLWAAq;z~1kFwvdXlea?OqN_;<-TN!YyI;o9-;|Lmd@x-Fysy#@jUOU
z6Xi&0Ug&sdzF}3&Vz<%Fk+$unb^xqTr`@=#9@b8GSIu52k(Hv^>Inr3<=lg9M}*RK
zPTLMV{%nGa`{b(?$(Lo}=E)7;`8U$GbBFpFCQXli*)D%K`8+awenJ#q<H?xz^kx0<
z*oF5x{R@_O;h!)|yOq|__D5QshJ%@HgKhYBl%!|QYq8gbP3#Sj1B+g){m98;+q>a(
zmL-uo7Cl-w@TEm>Q1H$t-X`lz5bi2%L#%|^>~%lzn9t^bX}zaT-$@*_zt$zgVzno=
zzuSYO^K{Dm{NeUu`-4f}3Kp!W-R)JLz@C90JCE*f>muSUmx!sxc76`LD;db1m+3#3
zd$Y~w-{xmfW0m=s%`}(1%yIbf+U7)k>Sz^f=vm?RQkK*uvC-tq_XAAoBNn?1*xM>`
z=C0!%Sqw*<3HTxN9k2%EBUY^s=||3&OlSo=th(QFQ*ot2TM2KEyL#GT!zTvg4%*)0
zBMDtu6sA-hNv<~-7Z_K`c{)m7Lz(H*bbWIfX%xsdz23-pt3SNlsWSXhjf2@#H;Eoz
zPM)IH5?yk6j83^58M{_qh{vgv$898`-Lal8uwp+n?yvXvO%QX>qizHEQ5h<E)56}$
z|7XFohI)IQF2j|;{M=PdEiWpsul5ipQ5l>d^)B3nBG&hT6`K<|lb}rtI1$a8KQ4+k
zW|y4j7fGy4yt!W(2kfZQki8nZ%ihqQ?oIWc*hX5SAq;R6vN$s8J()#1mZ6Of#_c0h
z$69H1kaF8+3bp6U6z)bI8sxun{AKr#OecLV=?P}mrz&InXfs?;1wpt*>Lb#gAqBfF
zYtqccsPdjT#LC9Gv$2%$<l@vQCF{ck=_I$G--%SJYh#6ky*qolTG%%W?{2P#TI)I-
z7Q9G!Ay}aNWc-mCa=-b-CHMe4)LXZ82DJ7m4;JlRU;KQ$`1QS4<E5{;7F%u??=JZ9
zD{8a0=zDH{yqreo-(cNsn$gI@O8dgHfqR!i(Dn%nbr60~YN}45HS6vTx7BhIiOaqZ
z5(e15K(p_E9uPjHjjlIUk0_k1lxx>LSGu5=Zl0DC3NoG$DOw(P3e_koB*LYGt<AS|
zj_<B+8m|2Oe;7N<sHop|`_Itb-7O3tCEZFl(mixbcMTvRB}g~Y?T`ux3?d;70uoZv
z-68q^{+@H5b<TNS{nz3hZ<txE`@XKd_h;X`Uf$Qs$SHZep{CV0t{mS)bAI$N5A2K|
z2JPIJak@PDvmLNj>9AGY2Y6}yuwt~v7T)(7Ze41Qy8Ak|9p{zst=r(i@KfL4`?HM^
zC;idq4<PiBY<_F0bZ)&gCp}KLO!6t@Iq=HY(B5Nc3cJEZC8O(DwcG#APTiCWLcukr
z9l^l5EvH$C1>XY%+caiHJP$G`PP_Lmk)klxo3}dQl7ddtMVrHs#kN#n1;7z_X%YID
zRdQ3_ZtyK8aiva$h82A`bd}}bT>$hTv&~_9FDp<ykzq0c$EeZ-TCt-tCMFz9`?J$*
zEk_QZhKVK8OPdSTxc0Qa9W+ZeZgC<+*cZeKhwFiOz#FLZUp$z@S(SPAd``&VSa`^x
zp`pb!|9H~-<?s9B`GF`0nY>5-{lmjy^cIF;+4~J7D0S9kf}AwIR=){wjE)Qdw~~`r
zhkQKQ+aP(KScTeUgL<Tz=cZqZc2_WVE&yhsqV_fKYz<6Vw6MwM$4ltbYum+ESKVd@
z?UWb32Zno7W$`(#hyQ2y%|MgF!mVU@XM{VY<x;qM%wvCqqIIm7+2`MMUTkh*t9`sX
z?1w^t&*J%(mn7Xta%2N=m#6%UFPQU}kb&gEcow%JRvtcF1hXntn2vN7+y;t$oozqy
zM%6bh<~y#<3=w+!dpb^@$-f;u@_XNnt5As3jW+;+ta&iaO!e>UuIV0HwakNVRZjdx
zvhkr{%J>{owMrq`Wi<Vs0hAFP^5f1@6daf`El=Y_6P6XP=Yav(3q%fLDQ|3?!(He@
z1`Q*;FQO+MDbSfh#LhJX5WmXhS6hB$ic$G+Z%U|?iP2!zMwF<`^H`q?zGE}&-MI86
zH;fvrg4VV5Cvmz3(2HH#D)9RigM(@kn}RLEf1n?zf%IW!xU1cF;R%ik&;lwIlJ!Cg
zno2)&=n6`;)I*vUBSK}^gde7*&Az4mxsc}_iNJQD&dAs-AcknOA&X1n*gnJ1o3@Xx
zKve(yY@t;+(<(L5I{8p}RkebT3r)xBO87R;FHv|B97$n@{gCC3!>~3J^9dtCfsZN1
zy1YJ?WB@gTtA$%abNux8m%9txvRG>6X2!yFCs7~i(p%ldZ&C$6z9_D)lJc2Ss8BE?
zv98@o7JoY^{Zt~A3aGD@I(}D_hvL@SKfV71uq~eT-^)$A%i+hs8gNGp1C53dX7FxV
z-7T&iy7kEKPy_?b+XS0UOSGq>&*5P;Td}<>I;V+oqH4LrYQg*OC5dd?Pp;KNBaf+L
zaD!2@fnc0@cfcz^!mEIR7OxxDs!qs5%Dt-wg&VAwLU9m~1nCz&dLaF_A^mhVJ+6;q
zUgWM`s-H|YDwHYXg<Kj$-|U^wtpAr{STFt;q}#GF!1~P*U1O_Eg`{Lt`cwIr(?74H
zn;iii(eRrxP11mSj#!_XK0K&Di8S)fa=ZFFA~u56>OmY&&&(DquPVm}4XUQm%F~CP
zVJ^z)pAC!j;+_!KrLU@`qSkHTl2O*Ac3g1}6}zE#y?6$8#r($`JXyIDt&mUi0hO=Y
z6r4WH75-fpQTZ^v?5Jk@uq*uq8*KPT?KgM?k+IOAPA?XA)acNP9_bxNGR$+;vlXed
zkUZDms=fZnyiEhDrjj#~`MMnI==XI_esMkT@c5z0HA)dKj*P-&zeQJYpT;<k+#)xX
z&tw7eIhiJr3wP`?tzgdk!Czrt7Gk;zB>E-VMsSSq=_IUXOGwgU3wf#^EHVTZ+6D0Q
zz%>ODr_Y|AjT>er(F)FZ<N-$0Cj$#^$G$zI^1zoL>v3Gfet@10!Y4a9f|814td?`0
z6?;VDkJOdpik+LnL&*2<3~FF?rFNTJ3ldqp0dQ#cD@sy#TVGA-FHgyPznq@sc%!lD
z-sMYL^VQutb}Bh7=g21O4Oh?m-T^B%Gw-r&^!r`)`9}2J*W9s{`{d)jMrRzXss(bt
z(Qkd|1Kj>f2dIF^UV`fLcx_|nuK&qJ)Gsq1@#?qnOHGP~Nd(>)f@l#mWZcHODG7I5
zM3H9hqeORXEGsOSk>I7HhDeSf86q|nhM~4^_Ypy8<C(d_N3nNAx35+dB3gi#QeDQA
zDfqJTbAFjO=%Zvv-}fbu<_}~j1^NCEqB|3{d~>uEl3cEFtIZOo(@HVpYN&S*xjDY%
zaQ~rU$P7B8^R(@Kf82ybz%)>?Vs&IQnq5$QlZ6~6Z2+Aqt-{{<9W@-7PC*xj;XX54
zXTo99>LM`^F=w=~3g4oVY#)t&3wjT@92FzC3?>Hi)nEVK@!4;oya=frrAJIEW5XWy
zKS$%;B<*!>tvtKCIxN$9rg_q|+U6cQAb^sf_sh+cyeLG1oQOpU0oDuBnXNUNcNCA?
z8Av}4hU?4QK+_-py1pnkaC@?a#vU#awr1LLM=aWRts_LB{n};Pk2ktf&NPDW9!37f
z+PQRdPsQ;z1;@x_(0naa$wfh0SY5goT1?hh!75@W>_xGzf1>{kqNZ^n0@<_JnvlB?
z*&Uz4EsAJRK$LShVE>*ho+fo<UyyWbU-pc_0J;hP0U4Y%uY2GM=SesXlALJj_L+#5
zDj4w`M?6~^JvO3_$MGPx$Hg3NM((8M+z<I}9S>z855><Ojfbvqy{WCv^#fvVL&GBy
z?JCEjCBr?8ZRmHy%Ph(?ch`>wD~5#4=e%O}f}^yZf148bNk8Mi!)AM4@PhoWv4xe1
z<=GcPGpk8`*J!&0)AQ@!A6pdZ<3gP_lN4vX`bh82)^}RAU)=nvIn#3S7|r1CNO$U$
zQ+N=y-$5Pc9L!U2WM^AkU?_m)$jPJAJLS@28Ah%7JnVjeb6QzQ+S3HR0y%Vg4Yand
z^>z!I25gD$k#p&V#3cNTW7%2>=POn$Y1)47H2xRMR#oe8kF=Q|^i2K6vfe+#`P~p+
z!GM`~Ymti)KctFrMKbh^3zwRhWR4~H#+~X5R$aw9l=mUX7o$8iKJ(KQVr^wHT~G06
zTDUc99GPzFcen8}=}%=o)U9)6HRxrkB;^V|HC4)t3*F=0^8@My@|k}h%&@$x8eajU
zyzxw&txfB0>va*I_q&zTCi_vjCGnOQ+}p}%q39A}bPUyON(3>5m$%|8srq$d|2q{9
zD+|}uK?a7KmVLW_hgErlVctTn3oK(c0Lu!z>;vj(67xICgRZp&{c8P!LZAZd+%5c5
zU(lhmK=iKp0stblqp)Oo^6svWD<lHWVuLC0ytYP^0Yv4!h{8rKkibI?+C>)E0V<-E
zQL&;>3{fXE6Data`IfuG3dyq$aU=enY32uzV<8j^M_iG)Q#Lr3ixp7)PtZvTcA4fY
znHWmvtWrsbEbMFuBE{lDX_=LCUR1?qMM;p}Afo|uw_iLY>lu+Z+af6TxqKYS9|9R#
zID6F}48tf-S~2g5tQ5fZ<>;?R+SRf<-x_@@F)|wZaO)Vau#BW1Wh1rRH9AIuBbHih
zUl;Kl7<6hHj6dd8TNsTy)I`imSYEu$1&E2_@9$i(SH>0$zqm6B0`XlOR4$vD>UnAf
z(8f2b_`oiO_13BX$gO^?0%J~tlA(;^ZPb`#Ez|<>=qPF$($l9u<ErAz9IOK+rO)_4
z26cDajH8Poiqnxldr00eOObgPvAK0tfve;qu<5H`Ns&e2n}x7B^_^mB?h;XnGgN6a
zqU$LsWQQEm3eQBT3Lr4@C>EZ#b|S+>9o_pjd`m9b;7+9C$H+EpMy)oAsP}WH@jhSH
zYq>EZ=?qcr<NBowW@vbM6%uB2M1RQSo`(INpfI-)r+8K7;!!CSi8YeZy-G6aJY%a}
z7CbvQ%^rqiv{c5Orvxfa@j^}4WylAdR1r3iQo|LyBI@V5fyK+hOe04sc%<sLoqn*2
z)*Q7fC`~Y&^5d07pwlmDyjAEq=gKoX1SFKS*a^$Q2{p1jL2miy;9XmbBz*7tC^-t6
zn3CNJ`-{qmhkN;3RNu-SI*hJwoiDz6VzD^?0S29+xJ^u6))z3ny>qa(r~Tm<+d%FY
zwkSskQQL3j`&6kpIrwn<m_J<_$Fd{)4Z($A-7<2ys)u?TB5{Hb#%!gxX|7AwyuaSx
z=LzK$epy+2p(AM^5$6Jedjk4m1p4J<dncbXxxkH&9>Yz`vcYMUr*9B7>6o6ayl#Fl
z$m;MPPd}z)5K-NvzN^MpCBMc%9X(xE!oB6z+h+g02?NjNrt2?B2!;e$zbCXQ<eCvl
z1_?<^y%@!V!~Cn^1&?&zant%arLUU(D}2(C%zRqv(ZU~<PYs|N-i!$(1F+#HmWkf{
zpDK*7WZzEV__{~yp%Wq|Oa#OLp;zCi57uq5TEoJnNr|Pc>KaN_<<*JWj8U9}uf09Q
z167A5(N-+_9Zx>ZISMGY@}M>$=FiDFWbgfvOfR>VOq_nzAvgJyPUEj!+zhU*PgmTz
zrxa#@16H1Rr<=L>eO(q+nPW7_Y*o@AYAZf&q_y{M`=6)2(Hl5Gxs5<$*XlXH%85qO
zK9ZA)pehEzEtRSHhpN}P^oxtoj+_=7Fw;5RI)oZWw{XPTJsvVdywlZ(Xc0J6j~-XA
zZyo2wCKXG{1*;Se<E+A<g?!%7C&C74D>eF_x$~QbLt*=Zuk((p@Hb5O^dK5_8sStt
z+U7cC2g<L=`ej%7x$|HeG9E+a8-dgji}H#|;@d^rj>Q-=Td6PZkBt;1C@DXJO_@z&
zw(9nCBSa*!(c$q1H~n__Xc&hv+03??7vqzu(@pWNq57Zn3aEr@>NZ6ev@gpW#j<DS
zzj}1^Z|K&)RIXkus@9)2IhS*ufZEUh5p0GX(_<hwX}g^5wBmMn$8)<RU2nk@c3bbQ
zTY}0p-xGS@mU0_Q8!iPGqlIOLzgqrWw)d{JM_1U-l7KqjGA8`p&+?HHALmB`#jFzB
zAyNVEB(M3lkitQ?-?e0$L#d<nTp-2Nf$`ZRO2H=I&Y_prQ$~8IU#m7ZLOY{pzBf(H
z1bqk8Q1SI%5#9W)k@TqQ87{YLoMda%p9V3<IjI&oX@BO0>~7Ma<Eo}Qra=NloT1pz
z0;S|!7itrjj<}B_A&v}2xg_tA>`5(xCZ*PviSMMubB15H+XEL5N}+wfRjJ$hF^ASA
zY-6q~jn$+dx|>7<{O5vA10CpR?;Z!jEVS-X8aOn*W+4$oe+}}Zo4Ty=qtGIK*SPH~
zQ2?kYn^>yp^OqQPD^R-!Q5D6a;U;_6R)OD|d&eNf%a_dKq^;ExHxD~l&NI|#j$LcV
zs_-l^;;+(gafvhX=T|1w?aCHz?%XaCva6Dlw)Z<^pffG|zfiCt&(5!K)45HOa)cbe
zL7k-6w2p>aFnTeHPH;xB=*J|WX=2M7!#q=hXne8=!>Cok*98Jfl|815rb?*{{OGD!
z1jk_tJ<k12i4J}Y&LR|^pdA?38jQi;FX{z%77S{D3RNCbX}wkgQ{SkyTEgU&cqj}C
zJ(cB8$OVt*aP5N3gY;NtwqPtg=G`S0kFDXB)1Dx7pEU+$P*-JRGICDs8iFnPpX8)q
z*otuTyUHH5>03|w*5t`<3-VU>Y_`w-D{u7KQy39gKhd|p0tsm&)5UL(vCikh$o>q>
z)ulzv!L+6+3UQJ%di@Ym2m4uIMTFW$R06w>D@J5ODYw>aOk$^(vV|RY<4nq~=l;88
z=zioV{#1?H>sDDaa>NUoTvUsf1&}ZLQ+6mpA5(B2F&1}X>OcP#p`0JHKm4lRO&`XR
zGy36s%y#0T*zPg2pkb!eO`=n#M>@BPBz{Rq%P2mu#U2Je7Iav}3VIEcQMtsN17&z$
ziwAHn@Q266cqyZF?Zz!Mph^)Jhsy>0wo1%b^j<RW%#jtHy9w>pDV4R6kuhO?j=xKd
zNTkhaoPISjmT6?G1@q8YUR6h_8vN{4eE)ZzKALQVihg88{l!raI^qV`#G7yhQ&~hy
zrYX9GoqLhC0RCL)&AhC0XiF#ki%OlSp|pGB{WVN<4Tr_H!b<cB!_2Eu3=@<D@cGPR
zWLSJ7Gn#J&2@Qh`7DXYOS~fFY4~bs64Wafi2XbV^xRIKOfzr0Gx|v-H5h+bDOu5Fn
z(6U%=-|lj5>q9mZFZ14R6S>38!U`sWfAA!HiQV?B)M{mCec>{9y0h?55?7`PXZJoK
zE{gpS6<sP|pc~!F6aE$ud!j43Ya0JUs@Iu?q1JjH?inE<#F8N@2nZ~f099EfU(5%i
zRyQ{JZKZO^?ZsqP1%Uo5f-EYT5`zMvq(k0^3+erdP4f3LQnzuW!(<%92imAuBojFh
zfLQ?aquAh(5Y)(-g%)Q=pfrGq9#$k^KNcJNh7qj)kq_1hx{dh$p1u&Y{PKG}5CWg7
zH|ux-B0kf`Tcy?fo{OjkUWLPE$e}@pS(K?}Zjs*&Ady@T^K=h#HRKCAlL0@?Aofow
z&k)rBP+b7xP33o(U;x+00c2*rM8Ip%3L*{#EI=d!trkJn2ga^gAPiMM+R*Iy^EF`j
zumc|mWnv0=RRq&I8HqV8=Y<e*43G(MSp4}nwjI=2wT%m+K*UU7*N*~hnzkCTLAYLJ
z(Q_9G`*rc+^fu-rP>s{CdUYViMLfE0j=G;mq9@I)nAF^%X+!Dk{C_n!3|Cx+YTI5!
zRHz)%Ls$7Iqro9L4pS@>M@gv_V+f^Ua#{pNg_+2QVsADC6CYW;o@}#@oKt$S7#71Q
zF?1$^%@G%D+KB%^7XKR%{C{S>wi8x+)lmGliL?B9!9JLykzwp}f5Oi{1Zr9W`-`Ef
z!@+Lg8r>_d`PO-T{My%-`32#8z5XAm<0rSX>abTCx^GfYR8u=u-+JsrL&3-i%;BjR
zFsImpn#@k}dsIV|U3Dy$qL(95zU!x)f#0B=HWJ&WmYq|dcb~(tpll=3yn3QUa@+aF
z!altA#M7q=)L&LW{9ZzMq6*9zrFQ4zj-byCGdgkXU5yg0z$1>43@P}t4duVlP`1T0
zOFH*H<+j5t*aVsyNmbZ~hVcP6(P>nI+Zzi$1~47+x;Ap1A#W>(BzRUQ)?&+kECOR0
zUr#pXhZtF3$u8wTX_9Jt>okfAbYG9E$z%=6_djPnZBk^}u%JJeE^DCvgssR~5?l&~
zAy=e-AE7DBOx`0t{D+Sd<LX#-$6-gW$hJ&>je?BShE$7$tUq8YyMh`xE9f>dPP<(&
z@qJX7Pj~183l=VWq3J;ledJA`@&N6_xem8|t8~nKxe!XDdJB7AvWk7<{N~8e{!j23
ziZfX$BQk_@hbd!!IIMP{092y^M3@Xdt&mlu&GLwr@j_j~6VYq+$7J*zHmm{HLE_`u
zoOr;lr7`@TBuAKZhQs&I!7CQZ8kPwa;M7!_XfV>4OyXRv{%_nu{Vtu7SW&GA`=An8
z=Eu*9adyDTO@ruRts#(Oe(ejpO-_~!?9AqOd~>8v>IdnQ-nA3tOZem*@lIed_2@YY
zl$Wp_MjXH!>6;F3eR6kW-g(LUp6icD>D1L4X{X@LW~l?|wYvuEzUi!-WLS~f%KLof
z#i!q#XQNV}L2#wacs0@l4niQA(raL$foL?p?QN*}Y0Y4+ls%5P)+I6Y1t=K}XBRSc
z3Z|W{{r!@rqxakTbEw_p@6G1mccW;_aAjNoyZ*4FgR1`yW%CuPKA2s|8{v<uRYCI8
z7i^A1po+w)3rp5lnx90jk=T9ZnDqF&F}FYAMphlGwNP?9Gr|nVI-Tf4z$%7ei`6dA
z3%4=PNnFEDUVKx+blXv4Q0zj?=dE`O<)QR0dg@v7cu1YkO$2+BdvLB7=)2vBH$jFd
zu>-W=SK7mDtwHFuZ=il&@~v+cl&uxjiRHnAIlQ*K==cdoDtaCK1Ml<8!JUfYU(wyi
zFX$$eB{-Lb;X_NOYa6=I^ratEG^-1L0<dA3%-~hrKz&r$r^ikOKIT<D!TC4zKG6c}
zImYA+T)atbOj(*)29TYZ+Ja}->A(@yd#8yqmdV5Joa9X+*d9_uo^X7a`}teA2#$Fg
z&EPgl?QLRrsxU9ZwAxgu##&n6-Yd8PWg>Yf2&3Amxywygs(H%PvIeVe<vp|($t#^X
z;O}0dyOy7=E4eL#{d)Bgd7;yuJl}Q&4I`^+)%$&r<<nz`_j*5WXpFxrvPr|aM3#WK
z->n8pZ{jG}vZtRTyxz{bcR_j~frRg?5n+dSdej%$t{dGHWPIg$pRqzVm)3a-0=ex^
z!{Zp?a_-JNt_90u%O4j4>;#owL4_i?)`}Q8kt3rAeP`-W^s8z|ox0lblgBEnISvmn
zA#fFL=VpBI?+*3!*^4Pa8qy|bzSVtUXF3IWYzGyTN7!xV<q!i4aljC$s%hoqbq;r2
zV&_fl!l#K5gU7kn`5?`IO1xFf0VsyuEMf(4Q8GFol3zfzFsY%fv*gZCJ!m@4mQ6oz
z6q#jEhRf=$56Z@{=z9s%MIa2vY{YBAc$1ix@3Qh&YNAUgIWht4z$T9>8}bGLnK?=f
z!k2ybl|%Esa5A2phr{YSM$fXn<ZgxawJeH^X8DC<rQ7=}U-in>;?TUzlwl=Nzel1n
zE1C2H!He5Olj*u+3~e<F#o0@nplHfwgc$1XWLr8dHCdOlvG)!)MRQ|Fc1mFIFO_|(
zU(1m+T-M<tkCyiYgbYe{T~_*gLiu+@GA}{&;J2ki1tBr)u#hcK?Q2x7&)niygvu7=
zw{a_udzJHmCh`NuLvM$K?wkdI7Pv0gKkKx~RqXR*t<o1f_v6Xq854gl;Hya|uH@S9
ze238pdXNWvk^v_ihD&36{a61XhrBoZmmCsr{VzF$16<>d1+4&Q4W)o?UbrnwBrP}`
z8#2p^D?}Si{Ej@u0C6jA4yB_qr_>7k1F<f(x0Jj=y}?XS{>P9pRRY`^X1zM&^wu{^
zd+-$ib(wF#5#@48-UU*)WU+vOWQESlzw=rZ340m{@3mN0xdD;r9cr0pq#~t)wFm#8
zzd%cutd!JMJSPzRb3lR#nG*kqD}UkqxrRTJu{Re1Y2N-3EY}GHt+jxuL2ygBRFudd
z;kfY;csLpriaXH#c*_ao?=<Y%ntgypx6yjdm`==lu>OJZRkRlHB%{1>2A9!X&qk$L
zm(PC`2l&%dX~|M35V8<T5^1wsA_0H0GyoTWTKa%(oHpDlPpsW=!6z>S;&9E(`&C>{
z#a$jrxUVdurK=~Be~gtdYb<GC3Q1mAp2QuYQ?_cO`+<ku4ubTgfUUgil?+NotH*E#
zbx`Ab9f;#s0%sY3n+@+wWX+HP)kS5ZLi0PXcUC^$ENw{TE|u*C0){*i{UVMz_GMhz
zdq#?a$F|3pG{g7_v@XwqB>3bnI0B=j(%@aTMV#lxZ{A>VlIM#_dcT!fvZqm|iTdr>
zb}!O${>~;)zc!nfO9XKoGeaVcaO)mY6K8^+6N@fP$Cy-E&PbFALc`}y*A$SXx>`i3
znkc-GH405wLF%Cp!ROuGfHM4v|MfH#9<S*LWNegXzXK=i2cr=HRe3h_{XJblG%vN$
z?@FNx`kgZRChZ>>{qD;gZlF2XIi`#n!AM;aE0HrEM2Q}L73XU<;6A;nt1@jnjR}M?
zec(!j&zNkXLV|icJIF`_u}OWzIwDC_b>wbH01X?dgI=KLUq5Q2SiU2nscXkt;vCKg
zcEBvk$&&^(^<c69v?i15<qE!o=4unp=D;r{`5%At^uSq_ec!xt#`w^k-KjyLNONLd
z1FpDg_9ROS)VJULPx87RHWDeQ5Si-OY$OQDuuvg4@jJO(KX#bIylr>$XIoKZ{j~t3
zR-qBUSV9N<UB>)E&?FLX!ak<s2uz6ARe9e1fN^x*N0H`R8_swj49ARAj&49O^N?Cp
zRMZK3oHju-G=|IJ!&u!TZOcQ~Ij~>4F0^WboQnC+l^!KzWve7;?*`CnzXkYHn{MJ5
zZVqzjqv{7B)eq%}(k0TG4(@KY4Hi|WJh&!lx?8EIvI&-Hq<;Whn^)bgzgZ|yp&fUb
zPmcq>lYZfd>Ob<>lkZYx5fE<__jI>Ea?@XRI5UlE?9@$^Y78FP`sX{s6d{HppMLV?
zk{Wi|;Eon{yc|Z$#g&nzc$#D$aNOGnFgE{5=2Pi}dk3<DM2`3^887geD3d{8D4-V<
z(t%>GkJd2`$C)cz&WO}kVYFqTI3lnw-!xdT&SE-X*+=>4#4z&YdP!rQh7YaIb?Ewi
ziR8H|A?Jdu8hJ3I$Y2y=QiLP!e)BI7D=0><-Z&#Tm94nO;LQXCEm@h26UIaK{3)Ea
zoJru-Ja*tvQZNDL*Ph1_`hkW>Z^NGF#HrZ_3<Xz=kn@53#p_Cs&ZM(si2kDjZ0ApZ
zqWV9`WwwMH2o$k;FXqz{KJQNRulpaB;0H{q1P~3x?I4^r))2r8IWr5g+Y<FLw;3&v
zE+F!H>!aCca{k@uY44uu`)d1d9NyRR_`ccQHbi~#^ak92yu-d_?E-YqA>H0&g(N9Q
z&bT8jiU0S5*iov`icyOnat1g1!6f0dYG#CR>=uXL@}{b3JVx!jdaI(*0gvM=&m2#`
zr5l?oqFH7<H_`oFQi-lOq~Ut^?#;yY&5y{wQ17JKB>Tjg>)6|`;7XiTevX0!e4j*^
zp8st4DCU9YGtE3(v@b@D)UMce{CU=Z`TUpCJ)bSHu&m*qL8ir?x{k|N0VjJ<4SFX}
zm4%kuTB`~bm+-okcxa3(*+rMi?RuV3*na({VrB-p<|Np$r`Bs%pnOf{{imJlOB086
zx5ehOcmuUE!v^cPZLoKT-?ePwDb_lYDh0~8DD1^=Lcegm@xsocZu|lwvl}*bC63p3
z?LW=njfL3oA<9auXHo%quC#R_<cpm|YLwxa^i-xkz%XHF*#bs_`*u5}TTgtP5AbJR
zqJ%?Ugh?amqPnLuWBUI!mT+@%bJ=3`Sc$gY`e{F2-~pfeNi*T~8Cv-gx3)*>^tu9g
z*6~zeokB9C|9}$*@si*tPZvh-_zn4irgki_OudT2CMQ#4_jFyURWzgnb;Z&AXgNlL
z%O%c1o0fK6l_513&F!IYp%7?HG|mP>&f<1q_HhPg05=$Q&eKopi6MknYvt^GQ|Ohh
zh)O&HknrjBNHgW04!0i(BX0+;-eS|3Vy-@S{KQ_s$ky^#EQL!2*kTX7F6T9}vIn9)
z4kh;8>?<Nd^iex^!u8;m4DL#CA}JWMdZCt!Wmv&fLm;ZT7o~`LWD}g_M8*lrmb}xq
zhvx+QzI{D+#szd=&|3YfG^e@mY`JbBdfumR9)uU^5Laa?4#+hV<Pq$a8gBM??`)`s
zGp1v5;I61d(#HOy8P6$e<j}$p8V}q}F02W3;bUGWbaMu!54vuO`0tj1)`_{7h>?xq
zRoW40lwMDkEL98@H1N-9*x3)Y_|F!Bve;aL4f>GLq)!XpmZ=B*;fYS;&8QX;iS9Iu
zqotL;Y(911zl8u1u>CBuyGNr6?aM23CDc}$`y|A%KCfDgF4gBfHiTH4rwyTthEovK
z-f6NcQ^{$e2rZr6SZh@1_rURFySl3^6{21Diws?_=Mme{TnMau)SRW7J4cd{qR9Ch
zzSj<-rvydjdbMlCakK<)FGA1R;i=xZ{kKu)8|FI0mV)B5j<ebyLLIRHRdXn8LzCa_
zFAw)sr;$WxYk%4dmp$Nr(jU)!hVJ9AGzd5Q+9YfZA}jUi+|#Z8;+30h`AUOm<@D82
zUp%Na@~t%})0K8onUr(!KcbgLPXCHt8vRq6Qy}#Mz6X@hki;-k$$D;&se_nBQ@ysw
zFi*x>T^C<mF--r+;$s$cTh0T`^2H^w;0D<h<qv1_5W^@m3#CY3f!0a0K9%N)`KVmn
zExNU$+Gf*n8@~Xz?=5u*E3RVmCsZD&1HsJ-0L1+PS-1iejx?_9Q4uQ}f@rYU&cw%N
zk97sy3s%lZK1aZELSkP(`t#NWc@bzb{0TJG%1uS%Qdg>F^E<V+9uNH;{04oKBjidI
z-lB|U_}TsW#HoQr2<wMS1Vuoi`y2bQxnk=dx1PCTK2Giar^O;~PYrlLGu%dvEEN72
zzc3Lsz$bcrv2%r2>hQ`I0~wi=sfZFYt0wU3KpCXD3)cS<4f0iX&#$$pdd=E{5oHaE
zC1S(rQrb@nolNRDC-h-(6A|OP;Pu*4bFF8l{e^^Mm8AofiR`+c_dluz-b7av=g~xj
zPLxfH${2y{DSu>eo1hR=o&gm*uYi8g2F_Nu6)8dv+-p9BIq25tU#&F%qb~WcP-&5`
z>cI(Ve)cf6Tt^({BRjiz%92}~PD$jWeNVR5r^V6=B~sM+9swUxAkCyKC<lxrvJbXq
z55A8D;>{W4tBki%Iw3|S>(pPf9-c+&t|CGs$<N;}`F|Ac=}n<ap<A;l%ACYeSQsy2
zQ38lWlvPCwH0(`7nhYl9??cxAKoI18P0s}1e<9B#pK0)~BPU%2ZG%8Gy5PCu?P}Ep
zL160yhBBG+tKWJxSx3EVNHWZwUn3%WBfO|EicNM|4oac)yC-LnnbWpWqv6Qdo$jDX
zWRhv;s^eFZ3Md*djfo@yZSplUu>Oxehvs<aPxkjc!Mg<h>Z4?}uNKf?kx;eN;%+;o
zU&xe+2no>Hg?UIeEw_1Gx%($sbb{aGXHux~6f}wn&6rn>cq3FS`3CNz1lhBNv@9&=
zGz&Eu0?%j0h)Foe90^DbXWHI=a_@p~qCBY)3S04_@sdtZevJ;nnyXPb3)tCC$Etm4
z?pIKl#M0zOqO)4CcT(E83n(40^8<pd=b1$I2da_wx-8M)TViPNk3f1Z1xU}GsM^OV
zb7L*8y#Jz6N0$F9?_+e6)YR!^`XAg7DVuWmR&e*LRW)RI%A@&j?=wR2>p56!U<Kc_
z4z2mB7HeSx==EwFN4OF@_I7cB?FY1d<N#o<azLKUje!(tB|LLHz>w&+aApupqaM_d
zv1k-X7Uz%7?z`e6Ad0YODo8vU>?eMYVu<IHP;h+IeED&>9lN&O?}?E1?{+hV?-ovI
znuzwvc6`V71s}kG;4PyV2=3pZ(@MTMreMF^h|{U%s^Qmd8#3L5z_CKq=mb;n4yC!;
zhf|n2|K75Z$+*mE0Z`qD#-U#XxCV>#CT=Xhy9mgQH<W8+M^sPOzw8^%NK?l93?Xnp
zLME9yy+4zq<DV-wPZTnqQPzn`u~<l3;Pchst1MC-2sd8%P*_0>BYgd6ccORvrnip~
zh6Z>lY*%hx(>rXJE@PH@)tM!BI7}eU*-Fb)`9~mlgJYB*c)70>754>=#0#Cbg#Vc(
z=sZ)y&i+KiimO@*ER@A(&n3UbK2?4H-;lBr(#c0`<fdt*br5+Xjac^8!L4dqmDy+h
z88=fi*NBDIovMbJ+Qlyu^-@^T&F|l>+c|;a7cRd%DO^27@>PTkn<L$W-TUJNo4!-L
z6vGEH-|pt_Bq+>@H6Xg_D&wwqXh_CwzHi|B;r#V+fO69GC?s$<a>FMe$HxrC1wDV2
zb&7*D3%4u@d>3LMopgS!e0_`-|0k=$i(G?bRl;DuP$V?E-G_>#Rs{4~K5na`c3uEA
zH`Qq^O8QYwmHZQ#vI0m6v<8Ze1gVKSFN@Skrl&twolSV*X=<UZ@w9e82cWcP-ob&;
znbox=4ub+0-&egMlHRK*+;uO@rlzaSUL8`1g9xqe2{746(eFKOR;8yuZ!39VXpt6#
zfnF+whZ+kVRfC)C#tRY9my1+cbcTZVJt!*Qi!?b5WA<l!vifN-mR=6LzB-mv0|0Z<
z7~Gp|-S|TFg18Pu^?Ajo6Th{PNwZ}nBMutzlxR6AbZ9zf5ky4T&*7&`<xu+B@;&a>
z(PdALGtfFBCs^BL-TClJxuz?3cfx}@R#7^7;t?={;Cu22&eIMpX`zmFgsl(!vsst-
zyCfPZHT&^=QUnBL`#aSQGv56zfDpI)UP2_pdR(+{YU5})h{6T{7c=T4s?xB5Xr|IA
z^#iN=P=dZ2a&~4S7i;S>p%S~wMv?u8r7Umszz!4_k=HgdY+vKY-eg6;x$7=(jdyMR
z?&-3f3Z)i=0};W=O6RJgYgI|O3Tnk*D2U+$16|1~>vcgF;T1~S`(B~>?8~2n)jcph
zg)4r+FZeDf*tz9Dm)8OKpEdZAa9)ZT^@?*&+@|Q+%uxb=^}}?mhZ1UNPX=}_GZKGQ
zkIF<+%EJ}XqB@xA!ygVf*3~P@5vA6$H$6Lb5u?c!ja=ZJXedvhcDP=jXtKUDo>uvo
zijVmYWxT`;b$=034YVW2Xytvli{)jnfTaE<mJFGTgIxrJezylg2;%?>kC6=(e@sR;
zoiEVL7nvYNm{v=gw?tK6o$g-Vv(qh3mH|dmDR^g7$(Vo9{~JY*>xmO>i@N=GOrTQ$
zjW{*(kkXa+!8J!_8aS$dAI<4RxWtEI`datRN=Omv*Aywug4U?Ol77vK?)Uj5pzKrT
zTYe=r_Ai8I;Ego`P7<CsG;w>xsLFWqwi!sP?4hec)x9duZKV8fVi$ZU8C3QtYm(W)
zR=9h*ANg6k$u>_W>yF*qL)V2i?N;af4qcD0joFTABz@x)k_y>Akd4q(psHyPQyk*c
zpCi+X2Sne$X02d+Xr~}Oby^U&^KzLh#{NWmlB3ycJW`y#0uR9?L5^I{b1X5lN)>h)
zRAvhOEWM6Ewm9*Uv<%MW{`UVd<_y^wK4)Do1A(Yv(o?0%y_1jxi)1sWk;IpVC}0fi
zet8QE3tY873dD4zAwRtPLFpf#Hh!d@|2Z3=xBSx+iT=_6$jxpI`d?|N(Q))7s`$T)
z>Ow+75;?QC>S5o)WsVj@fxWA@=+*!V*NA?}neFHgM{RXgoD*J;1M~XZP>_B+QD0k6
z-+aJyorwW#0W|cjlTx@oXp%R-<^4S{8U1Xu9hTFERU{k*nR?yt8tt1pu0X8+uS0SY
zjg|n@bBED4A7M2ib&{GPFhP^L==Gh|qNTaqJEOJ=1()Fo5+F*bN5F4-VL5RSEZ9Oo
zq_S^ELYFrQ&{xg2@8xy%Ll)hUvc}^3`IxE2`KqvsLF9-kkO>D!<iga)2)PhSXzY_G
zBkB`wGApo1C5l&x;NEfZ5D4<+ou8eSc5_UzzGR>!9SlDcIc^VF=gVTO28}}rO(M3E
zKcPD@sLwFU5Il6Xpf1Q1Kp^a82J@w9@swG*l;b#p9mteHMLZ&;u!ilVC+eehOta7v
z6;AWWl9kyF(RH=osQTd?=rRo_wG*Zs2LsRUUiZ9o5A6ABz*_2BnS|{AmBL&!YT;`u
z{#G%1_;taaS`q0gEl5|FOhgd>&OPIA4<_vNir9D0GDB1#+**;^_kfp3&p_d?6IC%I
zGo%qx9T}?@gG?~gu!2jwp)?k&#)UdgD5sz=?*o1PbM$J|Fe=GBNFy?=6H>i9Ut|i_
zull8$C{~yBik5Rr3iS3hV)mDR0rv#<5xxl4TIkHMK3d!(;#xuuzyCB^>eL090+T3)
za$*XC;7%E&2amkaa~q@dpkVei%vofw8zC|QblJ?0;s^oKa|?WT-S{Y*&>`QG-#zC8
zYVB!fW%pu2a!rl=X0{#Qe7=2+vpfr7+OIUZK@-~Ce|Y;z97RKI;<^HIgj6$@*ZtC<
zewn1gBrlw4IX2<G0jWm!*=n-6g#a`?TgPQ!OO!)>$Pk5r6r`K%MNUsRRM>G5%Qn`?
zSKWbB4^-{7?EaE=IQ`vMEDfq*l8Z%L)f=`JS-C8VdtOk8)8tQ3)L1ojif{{<&`Nv6
z6-b6X2X+MF{^|m=XeW&efvu#n(jOzV_svN-zWV&bQ+e5{a!G_*GWvf*57chguU-GZ
zS;d14YR?i!iecnDRZdZCe+*HH@4G@d)pK}FO7ZD`<~G`nbIBn4RJRa0LQX3G$yIDj
z@TGJ?cS(9mneg(0D`Au*Gm(P4t?}gb6Uu05N<tiIoI3Rs;n}KjShZAq<?lgRgAy*5
z!_O_+yE2;H=SkvvxwHb?fCfHs7oXV=zub(u^73pWm?xB!?k1WT>uxU<ds><AG8WsK
zGN#6dT|o_eEBHlf**~?Fw!?w1?O-wA^`F9(Kh#2tTa_6IaR9xvZY}ub^r4kL(kPji
zyv*OZVDM_BHP+j_(`w?Yap$9=_{m5tV`^4|Lt*7|oq-9&_$$mvr)R21VYWN~AJ;|5
z#oKMDfY}S~IYv}((IF2cLw+6!w@83eSyjjxL5zAQrCcQuODvopMp736rl(>_96z?#
zu}M+;j6}Kb@eZUPASNXVA9Cml52y+(D{^+e$orO~(SoJk;#?Z>Y{psI-N9h!To12`
z-}MeaavX5NAsx9`wL@7P+==-jS~bjm|H{uq?qnlNvj6~t#k1YMbI@Zbj%M4reM;}8
z|D7nPCXY`mJG?Y+CKbnkj`LS!9L8X*Ook!0+6R_*7+aL0o?5&(_&GS*qyo^HyMJOG
z@IBEdww{g@<{mE;7d?D>$<oNM2YH|Zl?kOM<l+R}q`OoxfK&N$!a(9Pf((rwhqoj`
zk`$^=f7ORLe#d3h_!=mUta3^p`o6qaY@z6U;!k}&2_B+N)M<IIv>M~&tk<KVj<kZ>
zBZWuC8SC`qqQ}D6q&^?o&8!KW4z$$1be#+$cyk{a;Esc!XHKH?JX2(Ryb%7#GzN$}
z=D;mNTWNh*26wAqGUEBA{UTJqmGC9tNl{|Rw|Eqf#bxZa6bTF3<xNE(XLnLx8--+R
ztl-J$QH>_-VPJVDWN)L_H_dw_xDXffhE=YzYKH4IayJ3IjiR2qW9H#=_|RZK9yKl^
zfMAYJx1UM#GP)I@>Ui*ct?iiQjhM9$x%520Tbg)HxT%HwMW*@ULW0g4Sy?1oE2;!v
z0t{+YxN6J5Fv1)jGHb=gi2?HgT~-y(Y6FMQB|r&mP7950H5+Ske=6^2KgKW=eCwJX
z)-+0Fg;MR^f?wjf?ECw7qbvSsLARPWX%w>l^fm(r>iMQG=T11yb_?}qhn<}t_iAAZ
z^IaoKl3h)mJj3_NZ^Qw#@bmG4%UDZwdd2HLEX>@#Qb*~jwUTEj`_pez9u7cIVo|r1
zaON~AS0}288f!QsjdVapbYeEslp@}q#*b7~uuUW>o*KbwxsW8vPlMe*QB~TVPImI0
zACml<8dB{h9qp)r0T7~2F{#O$u}eMR=hoCJxg(EIwIk=0QKz0Jkq<R*3V*ZGrr1(r
zP$c5AeVP$GBvrIL6+V;nKRfWh`imF4$E6JtjS-MkPUnY8A?<{8mw&FnMXI?LXL3@A
zuF~}WbQQ6B76FOn<Y7M!1eOSdD1w<P0MX(_=vVIBa#?N8AOE3v$O;xczhd@u*i~zA
z_>)1s@J&dDKVS70t2GNS;Y9(Tm1Od=A|3^ev~!R>?bf@*dZqyZ<Ox1<j_&}735pVO
z{A4wvD(nSMU~h^n4}~-hUID)sJ_;y3(4w!Rw1Fwk%eeWtz8rajT2$yQ36Lpd!Kz5q
zppCyPu7MUuP+TCYEolg^+!>JZ5LCnzgCC_W(v{Wd1<CTOet{<SuqzS?U2v4<e7E>A
zJ2}s&Hs5P*HZ3Sp1Yhmty9XjnYqGeL%vf|qra%dw83_{58RqZV03^}cmj$>AE?mR2
zF>6Jjy8-Atgk*BB(_!WGdkb^37njr4ev4W?Z)oG63C&ap@Z!&H+&+2ATi1TeVj)np
zMTvNY3zJ$C*()(8;AmUa%zQCGv0+`XbDUm1VyHKOX`SBX`p`fKcY2V<cLa(wcIFje
z5;KIT+Z77(3iJ>|<&}y_;MZ8tj*M_Mt*juO`3B`gxq|~^=$>wFsERlG!>(+`o(O0)
zu+Q6SQiO=NK9PiUE^6D=B-Noi>yz2v9N7yQMYkQDB*izUT*3E$xR=&Lds^9Sr`?1q
zD3~kAF0<cmt4pBrUc@d&yh?}MZfA^O@7~LaL(`C&(jXM)*l01zJ%Z@Y8AjevBaJuU
zdYW=L^m23X+q^mx_ORIPVFC6d)trcMq{QS?1sCv5JzAC*F8a}7K;?fFTLf%QKVc)P
zf2X@ZS@kUKG#ZGwSm&!ijS(O<)_t|S5G7EZO%Q|t`|_gEQI9m_!>&iX@#xOwzHl1%
zVy5@eH`cX_oac%3wu8y~aD#`3aSt)y`_kCtgG@+StWD=JLUz(zm!2M69Y@KDmJThi
zE?yxKK2$8U#IL35ML^b9G;RZLtx0(W18&__4l`d`$kEi)>e&uwGKf6XOjWsBhz0eR
ztNw5h{PHBS03hN{CQX)I?zM`vMnbmLHW$4kDZWLl@DmVxwR#6EP(O`aRAXM^<O_R7
zYS`lb7oX%=Qs?^gp~*;>UU#a)W6iy2)zj+pa<eK1zI0M-Qee-0xiBDz=F#dhrI#=q
z%dLzD6fGM(U+m&}U7?{dN%@v!Du7@C0g;r!-HzA?=Tj=D6#uPMEM%A^aT_Hr>AG;V
zR@5k~%k_J=0ic}P;V%QeKgN@Tk-V9QKba12nI62|jVpSdRgQ>7sWPqO5_HoWPp^))
zU6t^^pL1MjcdY1lFDLu{MU3|Zjv>&b9Ps_T{0&0~Ek$N@(gADJL94U=g90=?qH;tN
zs4&C&aRUruYr(p!8H6`jwj1ZTchV31xxq-3SUJLbFNNzDk<hqI1a*R?ixMFA8if_1
zoeJ+t_gaQ@*6mvQy0B`Ibj(jbv<lL-Jg?uJ(-xYAk=5<%lvUd{9{_2%Tjz1<KjKr*
zoJfW;I3tDFH2tJ}py>ivRgE|<TmT@dH7<&V`fBRLYr#m;q>UkiQ=2bM+I>a0QY(D+
zlLb$paih&UjIR_!OJXjMubx8hoz=}^)`R*Hkb!SJrCfyH6iYjUt|tI6WM^lxJ3D_5
zQ*sO1IPsT!q%@qN*gt7ybF~<x4^~1YEUI;1Lm33Z^w{LjUp}DY5Xm|`J*;#ytq^{J
zR8u1$my(A3&`%=%?=zlky?z@Y!_}7h!5=gv$*l7h*%L9QJ|dZgR`#~CM`<gf>g(AO
zsM4Y{kWI3OA;vrkUCpkutFVMHVuRlgJksE?u=E%};6oS;Z_fw>WA(A^9>NbPfb@Z}
zmsUPedy!Z%L72CpZ}=OD#(Ct@PF$fRGVJkqCXe|mvGPEO(eF1M_n(3ymT2Gci^L6G
znTrO|SblD)A@MI-XaGv4d+11qpXF(vGaag0&_^t(lFk%tVp*pX7U3R(by*IB8`YF9
zqJ?JuvW3Hx{Pc9un#xg$-B$}&dq{0e;ON46LHaZ*AR5CFr*SdvS=!g`s~<hW!(*V<
zuJ<K%wJ0z0zx;hUCp`&Ed62_*np*7K6xkq?X|!oz9(vVVw@^+KW7&g{YmxYnmk72!
z@+{)x07|o*WLlPK2DvJpCuh6#rn)+aycsis=LtQvnNVx^+ih_fv{Qs-hN(}M$j?kA
z`XW($|LHd<f+uk%2MW|;vnZgMZV!;e8Xxy`i+lQM|6=Qo()+Ra@H6T{(s$_ZOq}V_
z<gxedz7BLa?#&+OzB!-$StDQeP9!MzwyZQ)-bH8U<hJf=+?b(J3N(|mp0<Rs#o{at
z)OUuR-aWlc5p$6-P)TRXu7B%?2hbg(+kr;b5$gH;lz_xPmxg+P_*nA7a)@T~?_2GM
zEM-W+oZC{{CkN{r#G5q!wriK{4E##J`lgw<|9y*|I65=D2rUd-pyH$J1j>kJu@wUv
z<u{blc<YrhIp_cDa;$eQ0{Svv*v5^Dt^s@Q!3N=3AJ+w5WN0`ND#mKHZq@6_6lO({
zGga?j=yvJN|GVmw3-_xcE}%Aqd{(DW(@C0-Dy_txQkZ;UD+<$F;F9{p{m8VG-lt?l
zZ$dh~jtN(B#g1<^Ovvv;Q0~sXM_ro7UE8S1Xg+-EP0@_u=jE7qV(<sEvI0UZl`do3
z2di;IRA^j5k1{t+F8Q_|1Nzx4T}Tl)9pofStxzoHwgbl6d)elFF!32YA*X{jEDPc_
zoSb^RK7q9u?A#=h-#X#FSG5I%T5NF(30>-*%N`MyEL=4qsJABzkU0Y#7<z4hUG1Kc
zNy3y?GQBS*Dq>0#WogvOy|DQkov>7hS8izX!vhEoNwqB)q4&GSkati}?`dBUkK^z1
zeeb(>t|`m0gooVw)YpyE*9KL^+QUrm*u{|Xz$8c~$VKA2UoBA*UNiF}lSH-KMer%u
z@}@vk@qU-2$GB)Hpgt61pOokDT<e)7tPOsz65($kAvHurBv6**a2*fa&aNCoFo;%V
zMZQ)RU%7p!Lj!3o_L0kx&M?Zk_Rc>#6{Lb(+L_&_lPBx6$Ek1A9<1@|#5`A$CN;LI
zOzaU5N=w7K$h$X>%i<RUn7Pc91>#NArDZ$!5*dGhf`oKtUq5p?6ucg<W+rhHuuW_L
zu3}LkiNXs5rYCb~=Y_G4@}0T+mJG|dVz+DeMZ}dPONs0LaIne%aDU>_iT)tmF2pE@
z@ahM=lF|o8>fVTF+XsVu`nE+MT#-#tqam?awci?YVyypxl~WbfO98%9KtP5~3?Dl4
zfd0)xP;ZEY$w`0$1*qRs3p<*V2b5?oJpjaH2(t@dH`p|R82mNi6Ecw2)u;F&w&7&f
zl1GUl!yOqynq~Dpi{I^v-?+i0t`bcs!$q{KRK=D$&Kjf&;!Q!C=qvs!9sdfx4BGkG
zrRU~h+CK7Yx<M7&XnI$lHnZd#$fHa-Hx3l{t<W6cA@S(%V{Wf#II62)=po`F1*g48
zx3-tZOseCdn;3?qQ&Nu$VQ<kcD4B2T%sv5HvaZ=d#~C4TB~l@((OMQKffmlblSIUu
zkKkHQAx+cCvOrqwQ?G6VX_L3t0Jk|&xhB*RT;<kPu3=`DyFI~OUt{AvoGL7SNqwL1
zUh8KoF*fuy_;1|f!jrJ;lNbKs{AH%uX%~P=Jw~+2FPw&H=m0YE;-<K`!%7uL`rp<s
z>|_f7xScQ#yw5OqMJIhl4if>bCv0?FJ?vg^<o^7MqTd;C9u3K8ki<{iqbMVVoRN;_
z<1wkC>RU=#n(v}QrC_%V^u%zd<0NLQLw1D`hcr<W;|KVX)FbfdLOrZx!;J%0&8D7z
z+!|^V@|iPG%W@8GIsMtqLc2*LU#!`E?IpE!1-ffM%}~ta1BEA))H&ji_~!77+mjT4
zr?a}QTs@Pt&-m#uS&aFBB!SxFg`Hrji3~)bOrk8euYt@mQJ3%sR#lCa3?9wHML!Y*
zWE%O)kO=}J=pWr2;%nrg4R2b{_j5dFh-O0xr|MeEp%8ZQ!GP*ImnXLTU^k4%s`W%M
zwGw!b5!k$Sj7|kp_O?2)M5}!blzYqovZxXY^UJ_Kmxd~!U8Fb`=<py69z*~8n-O{F
zSqYbNun0w3$SP6F?gn!BCs66@aPuUWeu%(_3IwEtK~f`H8Q{Re8&no}Sb=hvz}_!<
zK@EUXmM#8fvR@`Q38h_hD#pnGIqL+1Zk6g{-7>GQquvmp8ia{d96n0xn`?_x8~K7W
z4K`%c`gy*ph>iKKqQoP6v&wboZoZalYUZpyNj5(dxQD9iKCyB-t1kV!3!rH}{q@`d
zP2!LAuM?iXe}Az>uQR^ufabm)&~DY$wri-aWt%^=_!^vki$mp{iI%MM6HRbX*yCl#
zMKay0I25<Z^^;+Xl%dX#)Z5p;lDI`c3D4n!OF`3Z0|eSqtO66QuI3hSFZ#zjin>L3
zRK01($Ck@=z#OV9W2HE_xsxvQHABbX)vu>9s#LwRLo555s{6_D8R48lYsPnB#u=Mj
z>|4PP%aQ#Ptah)^u<!nHt>yn^gWHqARdn99{HHdVgZ6U&y6qR*P09-!AVc^3EpYez
zdw)};!oa{NGHvrDl+gpp9L_hz5V621BPE@ZIeRF60$r`RaGzBKcqo6db#>1%S6}i!
zt2UihZ%YiOJ&cl(#cm^dgTu^s9;Jh}!4&e7eW!|4n1XL*b~;sgB2W+5$x4;9<z&IK
zy1MY-N{l&dGA(Tx8E{{8XQT>g@-m}0Mkh-+OKH#bGEGo+$HDSpx(vosg^izm#i5)1
zwXZ$!R*~5aV?o}BDVnD4P(gU;^OOj4&C@_ZH`PV~hu`^v=@{QBS8Z9dzClXZ|59*A
z@T^mepgmH1^sUd<bRT+T%fG&QhhB5UJv`xGV5>iJz+Cfu*8ku(&fC^?Med5Jk)R<e
zONzJ_YvR$LNMG`D6t6<D<g@?Pc(nv}Wj5}kOO4K3fhcL?eI&|<_0LAeO>j;_mUEFH
zk@Fe33pRnVxBx0HtBw5{I3z{#NMh*lHvuu_-$6uraa2GlcJ5l8%IxS{z3?r@<!HG<
zhxG1+o-psDBP%*Wv>_Q}zHC9iKawrVXf!(+BfoZFj;9)yX?F<&w<BGGMwKjo@ctiT
zR~gmT)@|G3g%*e6E!qZmiWe<jBq6xFI|OSB6m4-U5Zv7zTHGn_P~4#j5-jj?@27v>
z8*hv=_>+*4vvc;Ed(Ao5T3&j?Pq@sof|l{c+dDb-DP;`6{Q1$PTzz7kwGI?7OtAG%
zEI6%bR@%}jY<eP7@O~2#kNePf@hFpn5&=YgQiF?q9D2i}SX0(lWf=fR3uv{ca^pd>
z<uIL)81!4Z`-qTm2E}_{LITXlD`}habHQ(-l-htUwBV9OfL?UoIJi92S62`-^@Ypl
zpPKMVD>MOkQhwd1*Y_-z`YiX@rCOMGyCIpLQ-I6gOtZPbvX;V<XZOTWs1E6szI&Y+
z-`?qg4Cl^o?GF!n_XpDe6u^Oc(U^pH(KR2238+?Q8Nb}<pZKnQ8k;kEWmqwkvHQp<
z1Xw!jSRl=Y7xOL(W5Enqg$2L#y~NjTALGtame~G+1;BAbNLlo_k%K7K`zF(hN))<z
z&Uf}2<lHNVkM$ZRN*N5ZQI>;=r1GWxJsp!7n-k7>os!{d?-D<KortK295k%w8aduH
zzjcaPL9Z)k^FQJj`0v$IBd|3k?mu_j-T9KTL4A6pqa_L=waY}S-gj&~TW_H9Eu|ky
z<W!0;Y~R#K=Q!98*gc*u^O3$;Bjzj?ik5&qG8i`$!Xuve6o%iEcT)VOnC~PbdZr;!
zkgR@cE4sDH_AYNu-!vpt{zGaFw{1+#@bkuJPF*FPyKH%ahCW95ErCA_rt4el2~Hx%
zJ95>S1B*9WGO5(MN+gGWO(E#q1wBq6wM*){PMC|&;ZorI%=pH>uLY0`yJqT--g}C>
zI<wCrt)gw@MBqEsLu;O<3EMVr<`hq9gEDyYs5U5(-i9=1Z2XRsKQskwGtXP2O*mz~
zV6nkSE{3SaH4^X*W!uPdWapEeWBQ`gq=t3gzh;J(_5`JSQ%x=<C-rRFc49%)lN}q2
zgnZb`p5_I#RF#<K!}(keUQBJmwZR^HzX=bfhF`_;jLtKDKzC;_f=C@V$Akct$Sc+#
z*QIKed8^w_=0FEyZ^*QMg#dZ75V2UNE>hJDeXeplq=@sI4&w^7?|k7mh||iN1RQdd
z4@)IB_AT*e^jbC}IOWxmy>7>eaRuY<#&xx9x6sX>-b1&<a;&_nen2RjB0j&7#29VK
z<<Ua-D#qO8XN)r&<W2ouTJk%Sqh6W&LI1;-zGcEba7K&T7{!KdBX@Vc`c4@0c6o{V
zrktWNQx2OG^XaXu|CPgp*m2lyz87RVuT^5TEW!qq|60sfiPS0<uKLC>tY=G1ONL3!
zuU*<faJOmP+J)&?1*-X~1hMt{Y`QpD!S38^5cUE|NpuojW&3y+DUkfi)1ciN@`tiN
zSkW^Cc>2&DeZQEHH%Vnmja)H0u7dUdS<FYgmFPW%C-W%rPGPWJ1Hl%vji%I*sZ{_1
z$2g~~u97!L{`V}GQk()?!l6PR9Kd%I?HteSjACa`)$)zzgm11__tk^)B*wVf#S}Wr
z@)83`xNC7-?g;rQEOgi}L`QG#R;Ko0LF{EikxmS9$TQd91){Z_M)j&VWinZ2^E28F
z1z0Di7WOS{OrtJjN0Hv1b5MUihaEPiF``QC$|ye`>y485y9(r@-ezKBNsWc#6fs*)
z+*-WE{dcu9G7g{zQKc3>{(*G4o`6U3=FrUHzQ?7zh2@uiRs|8H*<8nC#1;JZ{7%WK
zRCoZ^eztf<(rws!HYC%NI3%^%j)S$gyLO+WvTVh0`3nv4i_}54g{0N$R2%|-+m8;A
zUU1VMw)~oY`|J~0Fi@2d{P;1!qkmkVvIqx;ch9nbJap#hCW*ZYAFGC*;C+7g2>p)v
zWljmIbiPWyjacy!lT?x9QHIxQc0aAJvIRG)XAbo7@w#M<wC=w?=`q28+mn5r!u^Wy
zZ}|5bU?g02Z~u9st4~U-|B6HnR2Fzi)gbUmmO|o4KwzfEv=|$bh9RDP!eORwx^2HT
z)89S5pgA^YCAN*qYk8K6S(Ju_RMMX3l{~)KR+1~i@3@iIG;7cji<S%lN}ORG4Blny
zmRXhZOqW}fLEGI{;;R%fMF)OhaeFy|#_+ti7fwAV<nD{ucQ^ugE$0*cH(*TPqSw-Z
z=BF|<X8v?CdA|E`n~9s3<{eK<-PPl#PgjSBG`b^XeVhYT-?Y3KRR)t<({fgm*O9i;
zn8qcyR%ur>6{UC8^P>XF0u_<XoqlN1Y0Hgh%C>F4F&TTa?#$Ac)(^*D*ASB%$Iqj+
z`#zE(&TGo&y8X$PP+$3m-(9m?W4g2a`Y3l}M$yum)GaeZ;DbpbH*v+#a;OB)hlAYJ
z=Y+|t&n>vZ@SehE&Ob5mpl-?3yEcc-)fSYW!mG>WU65y`X+$<o3B6gIdGpR7tzRQw
z<86>W%9*$+SmHX0`LK697ViwqoX``!37_Nb{yZV>d-k$HtHUeO-_?j_YK`~psxPyX
zy35En+2h|5C!ZD9dA5YtdUNB}c-Kz0*5dgR>siDBT^R6wZIhXTtBg9|=uKMYE`VBX
z&ysA+nkWcEPm77VEErfbzVsW+YLe((K{+|TUc8t5c1htrHMOz}Feu#y%4f{T@+Jh)
zh^Sgk{|1FxJ))4&`fe3i0j$MLjNp*{tGPnd2;QZ6(tBC3{Y<&GV9QRy;Yi5_xBca*
z+kUwqbx`_A2jY24sTX-P48_B%P89~^W3D7s63C1BdVpY|&nOhAW<^e(83l-_KMN2X
zem@xrmQhB3MUOWzYQU%77@%@vyAur<s!Kgp-=BYB<xU87Kb_8;oK&57CfK049(XUV
z#?Imo7XTJn8x0iWmWtxgr-$g3?d6d3p1v;yRphR#wUueC{md!31?yW_Y_6p#N(3N6
z7m+u53`HiJkg*~t>P(W9?W=g;GI#8L>MxeQ4bj7?quC0nvYnLYeUHv$da@x}yQ$Nd
zBnA)@&^?ATqN09AN}?TEfv+>w<$2I_4$!Qn_E3_Pzd;#KC4+l5$trn}SUk6~^G+c@
z9@2Sza;8<2huCFC2oLgm!Sgm#ML+j`fd=c)gM9ZsttV8?!Imx-^~Tk6`z{trf#2l$
z-hPp%Jrf`HODst&vQOV^A4Afv2jFub9PLxa3bpjN66S^qi~YjTkZ4w0TfBD!VyGQ=
z8=1@u62F;luayp_4~Yu6RsbdyO5~g76kC?t0)|4^%5<yU#qz6D@|@SZrr|YTpwAa(
zJ8*Tt7k@tVBL|m0t&T`-JwJBq86a9C{{%D?P2Tr_q6#!Uju(L#gIiyflGw86!DshW
zVk^zyMk0{Hf)Db}S{|JEJ!#A^w@s;Z%m39IZgm`3yc**a%uL><H)6Za_QH0t*0+%|
zm=kRwnp&)6W6;TYf3kWyPl32)BZ9S9b)|(ZjJ>auoJr@(s6T0sJ$RUnX#0lt=r}!G
z+ZpD}!AzU5YV|HG#Wyf2SWL{0rT0vRlSgMvY+3LE_C)?6GnL#yq^rbej>gPM<C|!Y
z^sMCN`vBQdA}uiUm$!C2>I1ZwM{GOMRR_uS{plCew;C7sc(rC?dTsDYrqz}nIghfO
zn@#uXq_7{sX@aFckv`i^P8z4Yms*bRNI)1}Dp#0*vdJYWrxVT79{)qA{X5Y}xTT1U
zPa_{dHqtBo1My|bMYsLVecbx86FswGmjn_Ka}b?uXR-4!-3y!a)5D&>iKncJoNj48
zboZJJ)ZV?k!z)ouE)2}ayc=Z(dsbjNMzEBS8`2bt(kQGLQ6c$&#ri)FO$J(FLD6D`
zlLjjd&%~TFFK!FwM(VIn)vglA?pl?75+JwryRUV9lL^!(N}c?RZkV^cEbdx4)nTTx
z_0uv`f=<9EW&DQ%E)sIg{7$anL@fRn$K$Hiv#pg9r*VD$n=3F)YuIEW;Hr1`i^eD=
za3yzZp#gi|(Ayzh_*;s`#QD8m#kd(}rm5dDabL&LQEj}t*NULb3~pD6sEF9W3v|gx
ze_y}pnVl=3<DBk21R$OCci5$DKVG6<eEISTYW`BeHyRNQQ~}U_<5~dj>&n4+mMPRo
zGBs3l(?Y}c5vvuPqDPFF|A8>kmoIDchsuiKkMAR~4n*3k_hk3!G1Z=YmZ5#m<$MDw
zw8Fo>vhlvQ4piV1`!#kO>iS0e;XMc4T;(=}x>&0Blep+sQ}z<FLIM5}E7pu!?${pb
zC@|K2*3zk>+q=*RV>rv<IYr!K;xD_o(U7^EdDC?cZZuL*xuqIM?m}*4N+EuCOW02X
zQKk)U!r1VYnU*M`_eIYdC0Zoq#5IPmd6YAO=j(Q?uTS;+#9N0~M4h{ZIFrwQeCtcp
zmv~Qky|=qGm4(gF!C_69J)L&sFfi1knK}XofOr52%vH&ST*RL;SxkUj@RXLlm&m5Y
z2{~B;rmokhqmIf6ZE1(Gnwk-ZNKV|!ps8T$%KXT=_li!@tTb^6MUXe+N~uBVHeA_i
ztFYg<*bP{s&9RHtvFdmS1Lylfh`4tnMJ0cXoZIcE>H##}RFw19;{SSS{LT*408H^N
zPjd!=nYw?R2(j|T+3lX)U+DKhKt6lxEd%dGUBj(7jM!g@CRc|RYR^x_&s*?EPE}nd
zDwh)CnaoUPu<X?vAxiG_s;X?8m{GeSqw{#GD3|2VXx2?Z|Eo`{8-pGX^T|sYP~0?-
z=ZHWBE)P4e*U~FP0=nI{o-OfnZePf7^HPg!$43EwQV`RTgv_C!uw}o)Y94KG%@5`e
z!zdtbqij1=05jc*KKsT`3|b%sDy$;Ti^iYOA0EEnXiD=g|IY0~iCfwL%gSTCJPFVZ
zFQ}=lDV7O0B~b?lFS=r}=V3O|3VFY`;NFYHx+4NAY+M`)Oc6(a)3^>BFc~`cdc!w8
zlbgHfb2(lqG3o+2+n=sSd-h^l@0bE{$#`?I+d18ms{N87n!i-=*Oau8R$8Nnty&Q6
zf!UEO$Fq0A-p$4O`A-~7@TKZ)wR5XCX+ASr$r$<|w-I}pon*1oVqY-Oi3EjP(ETqj
zLLq#Whr5bkkE>sVEr<$vEq`6Z#o!P^HJw?N9x-}2p&PjkMU?qkbf=ozTdPk=sC4*d
z<uK*0<QV9%7dZa*fYrjMR&wc`A$DoN!-W&XYeWWk0RXa2UMW<HV6~*us09##jyF;d
zurA!{2w|e`3#9D(D~;6slZVg>#)r0r#<e>s;(j&liLFI%L=gGH?e}Z9s>ZekhZO~U
zeCmoEetWHG!$9BQenz^e3@HiZpTY=U?*V`JVTZZ+)s8j;G|SZ8`YJ%o&31j2qW6m&
zHXX0dOQw-{gMqFRmBWT=mVO!WHYs<V)`AA~5GYu`s0&~etlkHU{80i@3Ggc4_jaPb
z{aHxT=}=g`<eI8IZmIEmT;f5warNNOJQ!tR|1RhRz3H>oNp)-MMjiJ`;*!Us(I5f^
z_hN2s`YAM!#bP`r=VTTsH8M&fMfqsjzs5{fhXE1+RmqyoYUP$DGl9cNlRGMDd#GLr
zenzSv=Cnedk}hak<F@R4w|n2?2!p}ch7`@6fWW<j(#iq?{P9o?d>?t-^~V?Lv8ya(
zlZRrSW8&XinG`S-=n~h<{aiB_@9xP9<nvGGrQ5ONdJd8z=?UY*Qhm}I8OkVONRC47
z%w4Ba)5TLu<pic}FixrM*_K45XEC$7YwC%G;pw<5A*ed*@CI`SsUIY<q=*&A1MHBK
zD8X)*`NOnRZloqVdA}F`+z0-;9C1rR5)J(1OdR~_X({MPT!9mLv?tP1?}8Wp@>l$z
zIX^<}tG0TN8$$Jjim<i8P=Rc!`Ki5(-GbR?GYvuHVoXQMu48%5<bI$#VM5`(o7mSz
z53%tx_Oi)Jhs_okD6sW5=&iGxT35hg;BNxi;84w}zGtpLlQ}3l1kz&%xPywcRvF(M
z=(~(OS)~*Vzt^k&(*Aav>``iOBeA8oK}*4k1z*-_Msr-5v6`M!o5;J6G#~e&#E)n^
zI=_|>pG-v6XKY$d4p^^f>Oyt+NChlzw9os~uWgYNKM~vT2#Zv%Fp-_R+8Abkc*u}T
zSCh7Wj~N2bI~_H=OQvf>Ww>fe6gQbV)1>A!_MN|hs4m5=pMfb}QDqMS-M?TZ>m?EP
z&Y91<Ei-E3U?3(=BNJ`O%12{j6tY;O=b0G@?^ux4O0t2k(KWF0F#Zi8kBxBlc#|Xg
zNeNY()5NcgWRx}>x>vT)io!G-Xv9&Z;?SzL`IkW~D|-*fJJ{AM`EfP!#d$)|eyy%R
z893NV(gUw);w-_Vb%PAy-gjB}K$~}}{kDgje^_Sn&})nAe9ttdzoPQJ_AG}9V`Kfa
ztTesn?N&z%N&YCGo%zNfYa+)O(Zrw(8F6#u<8S%q>JMr(bd95yPm%sem+xGs9|09l
zd~+z5YAq{7qguiSddt4ygj1Xk?0$Q9{*{$9d)J9qg0sbojc_4szAt`1s_oeia3^Qt
zmRTLR7Vz98*mrf=-R5_lx3KFZ4EAfq4230EcA7bEv!)cvTwlbRn$xB?11>2O5|YY2
zn{i9e4}ZmD%R5nZFKU}-E2~nGm}Fz)^@`%`oJ<|8pIoq@vK9`lcu13PPaGGwfw{o_
ziLO?I_qQ<a4<<8GmwQRy*MA?qW=E_QM?R081}bAll00Y4!;~FtALa7@7}NS=B8*{U
z(lB12_%^GR>q62M^BHu#Np1`B@aJTaM3ZlKvpzPIjfrjoy~Xz)7jv9K>G?z%sXWld
zlGkGRo4I2$Dt{U|f@VjGiTRjMVr5*Iu3M2`Mp=Nl77JG$w^ptCG&>*m4F{qi=CxrU
zOT|^l0L&LuYR}j{-Tb}y_0;=Ko9jg<Uz<1MBW#wvbDB4IE#ulIiFlvW#k}6w*^X5e
z0lr%yE>x<_`d)Qnm%?3tpDfq=TF<+kjXYnYu;dp4b@k#!YjuQ`FlI<}0Tcu`Cf048
zf#&8WPjPYcHAOeiZOFhD)lC3B%<ZcF7u+xbHy$QgoJ#SOowTs`7S5N^TP*Y$E3MSE
z*%Bgf?v}eD5QHT8;z0~XRBqU87!qFi0w&DF3{C9mjsxGORTRjFKKpQZ5@_gS!iK8!
z1Y=0_NJXaUSg$*xqIIrQ=k*NJ{7~AgQQ%mipb^z65#qp(vydfJVvA_UVN)Nc)V%LN
zM0mBb&0Zm+Ow{gpu{jxo|G5(%J=g6`XtY6(<UbOb$h5p~M*f1~VxX;nj`X*iA~)_s
z$wVQB5Pu>3KF1f%BEN<!40E5hORNJE178MeXigQaiABSHJNK7eJoq|d*SD9{TO?hh
z&^Xc0{Fn10WvAwhcH2t|+AL;e3Y6W&7wT<xvi2}($N5#$CZDGL>^@Sltmw(z6$2vs
zo8X0K!QFwcBbBUM<1>aXH?>a1;pB4lv~GF4Y}TcE5Ta_yab&Q2$|Wq6-m4OfBGBS|
zb2=|X$h%4iyNz-!l(bn3prTdb{Z(OM*vYqjsI&z&I4M=2%%v@GuE-!{NSn=!kGC_4
zJgBO~bJUjO31HJ_xI##2QUd;4EC6<quy=dfS%?ybieGPF*r0}tGj5dJnGes=FcNC}
z)U-hY>KMv|6QRYJHp8dwEb+(<17}oQy*j_^z=R)9N(9Q6K9uWvyxx}~VmG|wM0U|P
z0$H`;PTp=U?V47$GY1;N0e3?F0%nxudW}hrP1#~AZsYAF+8p0hGhD-j%S3k-o4f(x
zZ0S>o-^Bra9X@O&kmO!qi-N>=?=N10?U^I<R{Rr*G^lMy`+b$u>mi#!fH^o8{&yN~
zZ%X7Nn8XvMP<t*eVgR<_e-|k}7?uFLkc9q<yya(HJE42qgCKHbW{Y>`h6x$eIgjPx
zpm>!Ud24xz%ySjLA!NacKQvA?Q#n5iyY$IAv+@&C(6Ja)Roc=qxlB|Qvw%JwnTz10
zT;FKc7foqh8ty!L)!mv}ttQ&KvRYSHy{~^jU-bEP86@R)3gOb(lH#%=gfIRh5iRsv
zjnzJ{R@7Q_*-5Bp<kive>3+Y_ZqeQpOZzd8&X?H!41bz<eK5}VDDNBBNfut4F^R~g
zZ?ZP@xF1Cq-UL{ZMAud4o3Z8Q7g~MD{M0=i!1_rWg4u5pn=qfTBCOG$=GM7enql=|
zUNZ-PJz_F-V&&A9yW8jO%+Cyb&~u2u;(+yRmmZ6-8snPB<>U`*Pc5DLmqn081L^g7
z%T9l=q_6fyag}Zpkb&x(>r!VN_1583fpBvG>BiWJtA(4<W&_VV#{V!}uOFemEUWP%
zdR12Q8^xAkyg(0ng#GcqFI0Nt{xft0`<e%zc1}fnQJl+xmBz|R%k*T`E~=?zugKf{
zbvS`kj{v=~_n}(9q&5W`R}vOk0_(cZr8bJWhkr5>b)vX*O}5oaw$htn54Rdj*yO@Q
z^S-gJER4TEQ=mA%JVM`n>5CJ;Su}vgw9JkQ##;zH{Jk}I&sp7Tp*tbmy7PBWZt${+
z)|7u`<BBi0g9d**eajMgwH%f@N&<<);t2EN2$~x`T0iVy9crGIo{R`P%s29k4^#P~
zuRYOwn0R!GgjteR3H7{T@VQ);b2Kb<S9?1tZZ0X47apSw=NTb4NxYvhYI~~E(kMVW
zg=sz@1jRW+Owk<@e?6M{O-_Ms2IhjlxB4{JuGt{u^SrHudgWJEf_kv-!Li|!WfU3a
zGJNmlJDa7LuOAX~b5u{%Zvf6QI;C%kKh#2KG27fPJEx1M`$~coDz=OL4~slD)v{2;
zlGWrL+WBG2CP0aB<u6K^{AY|fTD5ohO<21OY@VtR15oB_xn&|tzSoqA%aAG_BYkj<
z8Ogq4l?NTGRSz7l)rj=49)Q9ZlX&Aw^Rd07bV_7@@Wx?;sf!A|Z<J=?*+-FvC2mYz
z>RxI-pWr0pu5_G2MG<_rG%>e7&)7cjS&}E&X{GG#sDPOe8Ah|zxr4YgsOl82O0A#P
znPzpqX*0ho=5+Szw#t4D8sxpc@JqxxV_WjjD0%P78FO}U+>uA0cK3E<S5@?F#GsfX
z<=W;`-{$`Pg}bJk*T{k89G`--)};g>Z%n1i`)r#B+8km(L&vS#_l1`EGi7_4Ddl)=
zHrj>gD{eaJP!(v|Eubt;u?*ZE%a{R<EO=JruB=dhaxahBP6C2{T}CuH?qZ?%#eunc
z%b!b%q8W06?y1}S(*Djz(%qw2lO2c}GvgTSa=hxq!l;MzncgYKVgK5|`yc_Qd1X6L
zg$d0H1(OuPyF^qmMBGJKm~+I}ulZ@ht6PnYfI)ftg-IZv>DA%4XZN@N;Gmj&eKlD|
z^Ej>Uvo^v}hUHUcVXVLm(bz6%3a#hUFNS^>HnyuZ)x2stIxXH9U;QpstRS#1t-P>9
z-ohjOy5ABIm#rlL6t;Wpl3VPE)a@&9^Euyhxx^EgZ)Ru3mza$fUUn^4N@@J+##9yu
z@w>jp=eyWUEm7R4-c8-5+qM(fO=bMr>z*qg<??j?gwC1V<M`yykqLEw)hh;@Zb+!H
z*Ww7G$i3`PvPp6{<$MB<i115_HwENRYzGG#Ry2)Lo;;R>lKgWz1{+*nD}R}F(J4sQ
z@sG4B#rXjVnCedCsLA8i7b+ij74$E9t=1-3;%PotmsT`KK_NRPR_Z@(S;p`j%I?mQ
zbmu>tiaEFsVf8Pe>!J%KiHFu##GE3zVTC1&9=1Y_NCVWUNvb;cLB+&2ok%%8)ALP^
z<GBH^?Ff(ak@&aUf$#-zVPP5m+HG*a)rprC?YQ^@nB#F`tYMq$ijSAoHij%wm~qh=
zyFYNzb$fVn%jUGm10k_m5j$QmnzNtjS04BEg;>I({%Tih$Ujgr<ScnoDVMsRjdozw
z&x;XQw0Gm@_veQRBuUnRzK!Z~I!M*T9JR*?XCj(F$|txRAtOdh4L*W2^MT+MiSLaa
zJs^R|-Aawlpbf%8i!?bBT0+b391IMaNV)GPqEz15PfL#=X+)ernnk1hZvp{n(vl|L
zWx|<VB|5d1>ZnOEz;;SLYso<51$l4pHqx!Ju)(;#5?Dw9YE57Ff!$rLd9|ls>y?|=
z3;^5w(s%CV)R@O(U!f)^deqv@sqTo$hZmrF=E|e|s=s|@EQWr6`h#_OTnIlJwMF%P
zITy@~UvRUWLKRtqKg@)-c%8~!9M0sr(>|i>qOB6u!Nxy%j*q(;2;FSn%~o4BIXawd
z<GZjmn4Ndmxm@qaCN8YWFaZ(EETE3`#H9PHd5muR<D@^6&xa`s5QKxi+XHl-RIS$M
z$H4u#rxm7V?UmX-MjgrRoSDbz6CuF3@bg9miFlLA%-6^leZfrH?;i?w^7U?*zP13j
zal#CL!#y4+ZZQxi49GA|CcCaBZcm%@PTJ;m?(8iL#<uVrwl0Goej;`0GLGls{KoRD
z6i;{SzNe26_@}DqGF*^O$-1@djT$+|S)qQR_J@@v8Ep;dyvTB<xP*A&GsXFl#}}>_
zvWi#sP;6UKHSGMQw3QOpN=rye*&)&eLmkYt_BOatr?X51*QhaHO%BSiB_^OHT=Jx<
z_o3X}sYX-lxisB==5XZ1Wk&0Ms`@v??mOg3fv2{9$;J@x?(<7~y;`{${rusMS8Crj
zI&wDw9eK4pZywt5CDct<zC1hl#j7T2PMU}*A^y4DmSyrEYS=hZul{X-$XCAwSk%pi
zo3zTIr8$Q`DA&+mn<gmOW8a&><Ipd%ddcFgM;}VxKJoz^q0+j&8l|+>BSgb1QJEk0
z;q5_@IMQm$4GwFv{3Y5hJ_!DytG!K%^YPD2L(-R5jYfQ*#W-Y}m~&XGljX(V&6I*J
zU#y*|?lZ*U$n>BkDR-cw{X56|6q)!a7<f4*8Vn>$N1^zmAmjf4`#;n$?2jL@m3rJ_
zU!@bNDX-`yW%C@-Fu&r?*pj}^-ckmBUij#{u+DMrLdW)Sl8*kpu@^>IZy)Z=q>n>9
z$4XX!t9;~L7H5C{4q3yFHkzjWra-*qR1^|Xz$t!oE<RP~st!4s1rUu+Z*_0acV4PL
z8Si-$G;N{Rc+VEq6fSX)ro$BsgoRG-?K^o2*OFKF&Uh$k2;u*T`-K1CsJ4UuWo)IO
z3$S9B*h2!7Y!zlAMI)@UU(PJyi8(Fgsp>MoqZc9n^BWfyV4mW~m;4iNTT$*;09ji3
zLfQs3`YRU{X)X1Pm5e_J1$|EnY^5TW()vCO+xGepj8f>1?spn(6QsX4_j;V7B)9m5
zgA0E7%4lpk!%9L<iHwIJkGJvJTSLOqyFRw41}Bp2@gJ-vKL@1Y*N|(%8^3)M9U$|r
zOt2*dO8@K3U`Z+5On-4Z+9P^%RPK7RrR#vIYuplE{ju8Ip&Ky2AfO9ml~eO_M$W(a
zocHrccI;0Clc;%>TCWD7=&wDz(MUCoAmS+Dl==%}>{4@r31p_d%Pg?X+ryDeN%m=I
z(I?(ON7NiANlV^^9n?{z?ip;zYMJ5dC9u>!p=CB;<FYfNH`LU%L*~~$$Cr3dp}n#{
zavOs`zMqs2#c;hHOrJfg2T1X5ichy&uwDE{wqOjoA*$UWN0G;4Y}-(VE{SH9Q&HE5
z`(HzX^!sSOjLMx@!z11NSB)~tFT$JNpBVK0V8J1;-a(3TDK;9{jnn9_nHU{ATk56B
zHe`5vn!)s$&{jJPe0ttiDbau3H_XrxIRGrhlU40Gl}n$qEQzJo<C(+E;Y+U(^t@B;
z&MSYrI2;3iZ%@Rh@_oek`DO4WKSfzV<h}XYm0|r}dnY2+dyaR+{zG~-Cs-*k7|7#o
zb<(vh8WtDW<1J%&0U#~%(=Yq}W+A2AQ}a$$c+61eJAbjfg<{&nEM>oQ1<EZ@<#mLW
z`J%U$JlJ>e#nvGn9y|iO^vl;2wbHrmy8tlht01#YFY3ap<F^jrXja<Np0dkB7vu#f
ze|Np3BcvD9;;`D38Y1UWtcs?cT|nEP?6FcCl}Btc$@KN0__3KU;t16uSm13hNloBZ
zWcS{rKt<5^fNK|lcEpMKLb-Ae!N$Y^-b15pFNBQ5-{~mlmGte@SDFeJ$3xbBow}*g
z+n}+RgePHE)D+52mMsY81&M%3JFWWfhfYm8!eVUT&lCpk^j+1H%yZe;(l-c-5*Y=J
zP+<?d5B;iw8cZDph@(~cweg#o{p{Bb%29AzCMn?+ama(_&Hd7v)~}1>rHKo{hFrD|
z`4^@QC_jkL`&Zg^?Fowp{;9%Hu~uTR_j$+^n$~UwP0>Tv>evCs<a1G+Qh}Nn`@NXh
z5>#_3h(;rnCc^@v7wfx);)h)$CKv;jN*6y6lNE!CLE)3$9~NIh{ZUPV?z7p`+ybUf
z4+B|NCN>4EE``ZqwEQTS$8JZPE}@#9*9!M9rrTH1XBTd@*B1<gjc3TqY^?iTWrlu;
zO`7GHLoI3QM8}0i#ax|E8=C0S?I!+LXJ}xvxa^g7tE$ISGnbW#Zh6$OHV4MzA6#Ca
zzPCP7179}PG8mzeDpWkw+X+m1eV=Pl$ZXrDr;R)8|Fg{0)xGHVj5ItVM^_)KyUl<B
zmGIxsss&^^Ih?*|J1F)axK20&9CciC??P>+4U(cIL_Z5SxQq5T`C?9;&c%g#pA%1{
zW3z7w6LLe>vya0co)y?tv`Sgf6jdoYJ!qWdcGDV1Tc~R_+sXno`x;Z>NJ0=3jl{b{
zkO+Eyc6PQ_Jp=<_(2zi+j^n$~nTVn1N@p`skS*^r69OoMc<))ar-Cc=e9~M4$!bSF
zdV#ms-+V3fm$>_bwi0lAJoZ|%KzZGB^Tu#zd62bSw>}3|RebPn*WExA6ut{^A{*J2
z7g;UI6Q5k2;;osM^me+4AA9Z-plHHb_?MUzg1e&$@+32A?M-n?m)7qcXBtjI%9m<a
z7NFX=z>u3l{0@uhnBspP@jJ{$RpxgciCskPzjSN&g9&M*U_^t)?I8LH53lM3@22E?
zATL!v@+<vQ?va)FT0%#8@I`N6=>D*Ud=%pyEuBhzvxF%=!s@=2ePKU!B`mA+p#`@z
zZ+xRbNl|@ssP`(sPdD5o3P*vl-S;7;wMua{&B=yD`eI0a;@ydS(mg@yT|XD>cfOiw
z!U&QESr_n1VXa)2Eqp*xbf|LCZBjPo%rlx&i>dF`me*;e{ZD^_WLG0IflRA?{Fy`c
z?OWEexDN1&Z;K1ti4v^HT)8g?_c(a}qvtkiI{Az#t_TYyt_+wIyAkC_a9xJz2_81O
zTji={G29*`b4pE~+FFK-7B3-12a`>@P9q;b=d_Ybsh$o25;6N*tSa9e<duU{p@r$U
zp_S#vq`;6v*l|Rw9I|P6;o)|KJ#nTH7a?^Xz^>M|JhiZ*swh7AIZ4x&hYI1v*Xr{E
zMid{n|B8&w;>_Owod@moP&T>2eyFQld9lfY^()mw_!REsm6u_j^`$O*P9C`-mC};u
z5eS-gv+R$x=F6a!M8A>B=fTXb-=^=77G57!V{zS6%Q>|gj5d~~EhnxpQvz~D#gh0!
zf7!r$ej|)${!MiC_E6sNp$;V0e#l&Z@vhq2Z))O{W;bcCpw&Ag1~L-J%Vc;QQ)>8!
z!wz5H*CrK)(6Ye0eR96r(-6Q__$#y`pQ$e=>TQmZ9}X7C_16~gl1{=UkbY#yn|_Ii
zpIl@uiQin#9}l)}(YftROjE2CF&<aiDfyqC>_C^@^$?e&$|i}*j4yr2-w-J<DS?fW
z3lgPX{)aChdHI9@v>=j-Qb3(iEpYx}yZNU+`VW=#rQ{R(EtF@{vC!&O?NJX^B;K?q
zLV$@bN)~L4cXR4vLvis+f1DvhVgMgnJ^IENcIh%nXOcM51E33g77c)0-?U)U^(-Zv
z)W2WjJfzo%!S6jG8^-(6P$}cF+-9;5`~0db?ykdxaLnpEwmfII|H_D2Voz%Q2KFd;
z!{_Ct+0nDZp+%<UT6f1*{7L7NU!W~%1h1fWHZvQTmv<#7Y9RoJ*yOYKh6@5}PPT@^
z;yf?%`_%0>{l;N4H}zl59_vIY)fsQSnj5g|JkCyRrIDgaexfWeg84e#)MT20x3L*p
zOF6DaK9>tcZWk0=Q4>-Q)tgdR>OfEy#VxZQ+%Hv%a3Yh{NQu)+aP)Jwj{RNcj@Y_u
zSum3aq5903C|4JOwn9p(&a;%5CM6v(VwMhP?6wH??}rlrQ274HC03UvJne7Y^d?1T
zw!q{hD97C-(dG&JhX6F%mV(cFwyru^$C^CT?G@VqNnB@?b;fhw@UpImR@;JLMl5-o
zmT&)FFK7Ju33qp`$i+`SB6B=IOPbi@q4pnK*A8U&^ymW0n2&IF+xSqptU*W7b4G`&
zmC$rxkAdrA7W0X=r8kjXMTK&9BFMEo)6OJOOR|lz$7w~DW<FlZFtQ|1ln@lY0MpH<
z$J~$ZTrK&m)n>FX@FQJ;P8Bt~^J>cOCfSfqb@cl#?KC58eSymL(EiL2AXmiKqred1
zc_H)%M6SC0BPY8b>P(un=cAOGIerDg7&LyU47{3mf0+#J^EV*J^CpsMDs)?GU?_{@
z6KOatAcqD<iZxKXj(0V)Ul2HfW=eL+!r4<AgAHks6}%N?S|%>tp>&<=c(`?VFz@rO
zu*P)5fpiKxR{9@Q=gvk?r`j~p|3*mh%zJi~w3|dgJLD_i{61K_{=2skX?3c1&LoBi
zRKw%Yhw9?kt57MyxSlv!*}*;xtF||i8jX?ZCV5RY&$M@RjmG>z(CA)<PVGt=<dDXB
z9I*RM4E5MC6?*q;zIw({EX~<|->Gj{K3ln@%vo(EEd9tlF|<|iO}OBFd-3_ES6~yP
z3;C5#s~ifi8O;I@yefi$8*ff#$opHcF$|2;SDc-?QGywx9&*(_;d;5Kf4_!Rmolv(
z3FW<I+(hDp+W6i%CiBSjWJ{0_j_G=oXy{`czT3b+QK^q6d(}PL4Jd3Z-a3w8`}1a9
zpqge(VbS>+i$tRUcw)s%Bsijh7~^dYO(pOr+vK-KKyDiz8OQ?emV7Jnv3jjJ!3*8T
zWvdtEU_ccTgw%N)f|%+eOyAkUh?v0B?Rq$+mrRVW9|N!9q<cTH=<--A+u{`E<ZJs&
zrwlVorJAC+$V9({hC;p`mZdf1Abb@%XLpZc`?ox_^TBOM^mf>-p_MISusDjwGZ;u;
zLs*HpY0ZjVwJ+{uLE+BG29*iDoX<glA_uf@B?Ks^Uu)rX*}+C^+?*DcWq9ooJ=YQQ
zY7Y1zUY25id(`D_?bc?jAYH*H%HL8cFa&7nlN#bbu=?BLGf%fWES9jK7GDO;bbUR{
z{-Ub{CCa!2o~e6)qpPua_C?OkA#@cztq(&&Q0xBsaiCfy;_d8a$40WS_LP^%oQHZm
z@2}yAL~S<)6oNE5k;lnJ)1jhcz;R@<AncM%SxHH$uqTh0Wav~v_G*RqgI<$2MLS}m
zkhXT;-Ol%5;sQh}F9XgDxO|4|PfgE)6SX}kx<%`EHNed@8CP{;;FvwuxbnI*Nx*NK
zO0`m*$Y$%0e6iy(WdTgBAa4@4@>~9jFQOR9ou5-|KDeQ{%+LkkCY--_nm2CA3vj4+
zxQm6TWZaYbnix5uzj?L55OlKxpR|w>^4`N1yP38&Ls@iZ)YUX*06U+nt{g;API0H^
zyocY%<V9NUC*qxfJDi{{J`*-(Vl|T8!2W2Kw-}CJsb+Ic*x*F?Up?6}#H25Mj8h^g
zl}&&EUzagU{G<uL=Q%mlIXWU2@2LNih`zS|n_-swKNw~L?14vrs*iLO+pzaP<5Cd3
zq@%@x<E4dkOS>lWrAz#F694_;oYhd(@K|@n{m)0dB)XgJ=T;CkdNkx_+x_}N>b$9J
zpWa<FOvt~_l>RO4%9c=zKs1mJ-X89yT3|KR9^d$ylZl6_WF$$qR+*&U;;}{%mYSXh
z^yJvw`ZmJdN992xfMa99f`wCPk0ejwo~NqAEPj$vs!`#Lh7LI*dh=eNn-D$Rn10=R
z?4vIZ`6+;hD;vJBV8}Ew<VmAah=0Ez&of};L`BqT(n~*t7Ma*c#xRZn8!VwcS<N<=
zTjUs3DmCNTfao36b`IhF;32LOB*r(`nAnz#>%RR?*r`A0yv=X5w64i_Ru(gQVCKyQ
zkNHVAwSb%MJv13YxRGzog{yMEkUp?ls#<d3KU-O`&!5~&FGctxY;Tl+kFuYEcPrvb
z&JyQx8WcZSV~y$S!b=rQpHp`4fSUZleYQZ471%H{=wiDjY}kJN!h=_j_Wf8E;(k$0
z?|DH>9lOn%|3dA!1=(D5)gk}j`nAl4>fZ6q&!sXpqwe#~yE2K)$f{+81cTaJe7f2~
z28x&40jGqgD#)covueGumsAWH9SM)siFb|*E&T3R#!E*I{8%DE?JH_`+ixyn8s1u&
z(W{u?yFr!`{9QAK*@jQg_|2D3SK4tDR|1Wk#EKLa6TP)tb7d(?2KqM#pV(x|b-1p@
z2|Ebi-kJvw!-*>7B`!s+M?A|<d8r=dp9<=o4k4;q=g-nw_cvx|XCkNKMF~d9<K5_?
zJyALxy_;)d$-ULa0#+~M>z)zf4vSf!cy@qqbLG$v4zoUcqoH%Aiq0;;8)-~S`{lNv
z=QMA}zN&rW>o@P)60R@N2yvaIeH1mnD-E_t@UKYvQf0eHPPMOj@5RB!*#^vrgiu+G
zWVQwe+-`H~Hv5$mZs|9mq(b;A15{mf0sa7*ic;%zf#`8>%$6D{`GC0F02J$%!-$2m
znQ<$zRXjTG;0pV>MYiux^%^~i#jfYA>sR5E%zQW7g>0L;$M1K3x`?%kXL+{bCX`L4
zgd9Fep)d-NL>U-IbBe39F5~ztHg@Zr?={F>6x`i$Y<)eb4&02?A~q<B%9Y8#yr-^(
zVCnW{2gzG^UD=d~<-vZlcW>z%_CsqNn~xz3ujeK+J!5)<x>3CMp8#N~CqJdgy@gfB
zM*D6mixEhwG64TPhhxRj<>bu5qPK?syt}cJwetN9w*oEwNNdeXeo2P5<*C96S()bs
zw6gIykeowPN;I5>c5Kz>K{i^U19?OKeLzaVXrv73t;or{|G;ZS=zlh&R_CiNRZ--6
z52*>O8Qo@QlTFy5upP=9SNJw=VC-?7SiaYB?^Rt`(xmTW_2=k_o=v~SJm1ZT<uYAB
z@+_TMMAU$R*UC>mQ}tRSpYCFkc)G-c*UGRjqVj_HQ#ZTdxyGOvtZjEJG@)PE#tB4Q
z`sEqLK8dOVb$DqS_6u3Y*9Zl#PX%>^CUYrbHT##yvbDWjd~x7A`b82o_Y(ocY2bc+
za$oW9cla0COTzVD;q<h_UnF2PN~z=D{Gzt}u1)WsmgYqfE3oM3*N4i|7dy(5ZTMQ6
zlxTJe<Kjm)9lNcxeFy=53d=o$wDP>)&tYR=i^;F-DhYf*CNI|65WkOoT$mx`#;%gm
z%>3K$$lQ2NFEKXx&d?GrVfLqy(6J%GSMz-~0h9M)s~0}blK(A{x1?thq>`X|1_ja!
zXBNzftVYm^<{e$iKR+Y^hHXtls*}Sq&!NhgQ=zp3lH|I+5vLt$ZOYNRgB(3&HwjUE
zkiaj&{`^%Pa59G@!K51*`IFN%Icgon0JGgAO=KX%=(D$Iz@P8%gA6dU6H#l0VcpYs
z4+HQ_ft<@FA5i8Zav%8^uIj_!TYWG}9Nt7ced{R8R(tX5&81)F)?_1t$DXfjy1Yr)
zc}UcQm4up9LMx{Xvq>C|`m$J{60$eIyb^5Wx(2qD8|z`v*lpDrU|NmtacfIq!8Zkb
zzAU8kRdzjXo%T$tP~9_#ytQ$=@sruRoE8+(KgdToQFQ@)ypjX>d8b(XT@WugV952$
z^Rf(*KrR*1T|=u{;gpbl{~FKRw^5skcjBfX=uQ8*LSRpjw;-;X*4ak<-pa!5NQpHC
z^AjdQfKKYUL8sUfOxfGOzXQ~C?8DRk96tJ69ojaM*8XP-m5$sJHhx#rusoL^Lg1#l
z4{JVDG{Q$NBe6PzuxK`fV9Wc_$>In<?V8`#iz7}p5)xMXpd_)+s|)1}^)`vOZ#`zd
zKjRDORScciD{~|r>Yq4nT$Vhp7(k{M_Q!h+Zq_$SX#I4hdob^MK~$LqVqR5e34~*?
z>(!6#yC`lbE*>0lLq0sLE|Vv=20Eb}OAz>iwpIfW0L-$hY>BF9DkCLjwMDjhZtZbH
zyyxF1_AO<;q3d`T8#3A}3m3Vj_AOhic8eY=AoX2@q>DM~EPRp<-S;PJQSd_wf`ZMH
z8y!`>JUUknopPX!9Ayw>NMSJ#U0@b7@zcCKp%Ymbm;7tNUr2K1Uqmsq|MDI^Lg%3V
zJE7D5KN7kD^q#Y!i3H^cR>F7OvfZE4Z<_}>LVDG2<ETw@nl=cvK8pdbO?gH{I{hXI
zv*n~rg%dd_Pk7KuIQtobSUu^K3c1L>gr^KeijVNwnYhM;aKQ=Ntz}*(vJ<MRGn<M`
z^;n_F)-j{uZRJ*BKk-vJeS>O)9_9Ipc5KMC^-rNc76X3qVK#B9d%Dh3EDGiIXoaQu
z@niiCi3q{BMrW~ZkaKh9LA)Az>XHvUU0NgCYAb#U-D~H-TapQIzJ@*)K0UJ$T#U{o
z|7&DSwYA9(#qnBw(m+=unxEmeaI8*rZmwS|KGu*XCgI@e$2wM<OsMGHHq)kYom%rO
zKD;^%T*~McwRsDw!ph%bLL1bRF@;kx2TkI|yCtM2l?QjqrPPVN1rer0ai>CnqiNG#
zZ)#AgrXCu<>e;n|iHV%8E~Tuj99+3YR<u9_nleI5lV>4hPa3Iij(M}lU-|)6HKR!|
zN`UI|`HYGiHNIOUy)bkk&x8Wv=DsA#zNv4)5oAq#Nt>m~R`8|^4XW5Lw+k2AEa%|a
z6Evwbiz)N&hIv($H@ZIU3V;PO8d{qU_k3_KUaqy$quDIh+>fZntB8nXm1gqpvt>PN
z#AE2}7Pa%{@g0qKqoA-6cODHZ<qTSQF7tsQXexqSki6<}dr?OMaxO%(O)+gDnK$yD
zwm(P9DX9N=%eT6hFxrd0OKEd0cY`TH-QM0Nv(hWqKZ2#A#-+LevzVEQY3e6hs88Rm
zGt&=%Jx|tTvR%)V&skvr6pp*oQ8%s0_?g9~f19-@HmvMyatraUiG?N8_@{P)>8TAt
zg^mH93Gl`ErBUHK537U^P@H@j1>d>Gk;%-VerPOIK{irWJuh_OX4_{MeXSEO{&sTb
zVrj<mOo`Kluv#uuhGGJ~@)w!ViG^yDM}GY49uOE$p5l&{nV~W~_m+8kur$bag6o^O
z9}JRNlYGd<pxFb|5zoiP$1NmfO`0m1Dc$??s^8yip~j*PrQmH}mwOxv@SVd<wCZ(%
zL&ArI!(*p8-X~#yrt}ikuwwdS^E;2xJIRO4nO9dgJxmf$2IW^X@-yFjxqUfoYnZZJ
zT7g@NS^a1mLY5OY7|cm;TQY!r)p4n=5SV)|lJwgP0biD|Xgt-psegVZp}=s8y#BdW
z4jc>plQ5V7NCu=^`4ir|o+VGczFh3EbOO-f7l(h#sqc6icqSu^^*HrPNi;GXMa0Xg
zSnkXdFL!Pz=tJLiU8l0vILrLvNmk%Kp*u=pG{0Noj8kq}AKgl|M699<qgt2Fl+;*>
z;&;79wB3Ji4P#c#DE{o!)<JWz?-A-tGJG7*qG^q)1sl=>=`VnXz5BiyJzRzA))W;h
zm(}<4GdNZy!_(dv)|=}T=UDyBRBz~63H-yQb|2G&v`BPQaW(D{p&Ld~`sstGMzY>S
zNpW{482_zlrT(pHiU04K)<5gK{+7XnLeWv&hi|pE(E^VertHHt!jwOzr@bu_MW^)p
zODF4`gwjnPOIUf}*ai&X{WGpTrGG39-VU(mdC{b@RB-b1u~Vk9YW57PK<bX$E1c4e
z#^ao7IzLkg_0Q+jf|fE>wQa^{b~83|&{<^XDK+%Ok6i{mXv3d9vUkQ)88bZeOE5eS
zuei>&_vv4C_P*3_73^lq3cgYaYHTvA6d_jH_xmo7_et>Q$=)T>r~_XZHExtE2FH@e
z>)@0g@l+9k7F43W$vHmF_-a`5`5F?{9v1I+i7mS6ouM?CEE;)gL(g8~X61$ia^{>_
z26-ajtZak~#>KrC0vQcZQy}hZ?~30g8I3#;IrH<nBhhV}UVrSloR*vLeyEw4^*Zk3
z-DTt>HMS&{PC^sje=P!vmE*AdJGkHe@4@{aoZUa`8>orin{wi_&e@LvbMOq?YE(2c
zEh)wl!)1STK9py>Ll<UO4yH>KN#~W6-tn!NB~q^)T*&|BF@$e@So6!K;cxD_RUY-x
z5aRi#P4yFQm}J*UP@R*LBd27ndhB$OPDU1;f~_KDxe<-icc;yriy~+9Z;j!1N7ahY
zf6qzmOmcRP^NS@JV|3{yvMRv9OwdwzSC3|*cNx52<~0*q*_4hx)1l`Gf%frQXC|tl
zPidPryKd75pZiwi<<kD;SVoZyEY9{rCyjby&l_sm0vQa?jiutv5F)Iu65MU&?QzJr
zYu-;}4l1BT-&#G75?WuLd>Nd7^#X7dwc1sq{8>D+am=!ZDvK)_fz)$I8+_kAZuNnO
zlPIq5MiP)El3BO_tBw#0ZVS>*%qz?Hl$l~bZgfNM@gJfw8s1Fjsry52VDCDZ<?qfU
zCEI2*cTjbXvbk3XVW$wU-Ss~o82`hkUMWB70{9M~wB7&3ob}&Etw-1-LQhV*0Gp3O
z{}#b$1O(7@1#G}yR;gD6vP5J4U8(XikYM1n3lJ2CUAED9l7mYAzh-?*s<#7a?u#sY
zlg?D=@MpC>wKXNw4j%x#U^WF10x@h0)iSe3%It?sPv3av0qM)0;^3I5X{RPsd2zCX
zxiSOpuUT5|;H*W`q0hA{1N`|3gL+_=Awp6we1`~}fUjQFc(_mm1Ig#EpI=TCSV0Tk
z@iu5^=n9aAV`rm$Q+X*le?&Jqtza4#sN)})L{Y0zp9E!YrOb$Ijq|1_AOB>+#`QIV
z?a1k3T&cyZKi>M!=6G?9{PVzsgV_of!-G#!$HebN5><7USG$_qdy~F3WD;<rYCiu-
zK4(25MwNlC4u(_>eMZ@+$&3l`p1geYzh56v)46a;w<HVwt7FBt13%4+i5+M<-DCYb
zP`!SE&Ou@V{F&vyPSe|yYG>0m!v7fPCpq3X-D#Ek5&nxf)3RDiPA&<~W6|%H*n@-n
zEPr}hYq80O0g0S5a+kiPDh_DBL77g*46AAe(-3bK=!P~*v1yn6xg$z~C4zwv)}9s#
zba(C#_SIZBMP3epHO+fd>B{2;0hv9TmX{Pv8dP4|DiPm=1?lVA$Qo$hCcU=;Z$Yxd
zOJ$5(QH7IC4Gs%z-kl2M{y`%QkG>R@5a6bondO`<r|HnrVAlM{D*h?!ueG7oKvgUW
zy#rf3#{Btzt<0k*7~ej!m?XMX-D8*i&L7GOW%}pyO2UQ;C!}R(soL_J(LVrS!;+D2
z3ZmK;RphvYvI{VMV3>b%*be{$Z$@0a>W5;D{CPCY$P(2h0-y_qlun8VcVx*H^%2UY
zNxVz<p)eO%zu|7T`J&ztG5-0={Kjq5g|yvwn8#fqgx)ir-taMf)uFYp*h4o5V05*l
z&povNWuPki+WlTdcv=z4!a%uF4Ui>&E0_bwt)QStb!X$&2``nBl73y|Y|<eQLEKp7
z^%J3s5)N1j+80hv?elTUYLOBfe5MDZKl}HujDi|x0@UIdDxv=Te;*u_i=G0D{RwOJ
z%we=p(&6*c{IDWC;!`aZj&Oc~YV?2EH(nc~crk!63tu$8JUYk}<;->0i3l6wf~n>^
zQLX<pjMyz18L=NCav`l;s+OWI{*X-|?7vf&u{RW-=-v7hAGh6F47l(l<o(OvXrEAa
zADci8%$e{=_$$(!1N7M=m26BlRXnrx!D}v<e&PWAj51kML^whs^orz3>6wf8Q>j$c
zmIi&^S0+0N52+0u*o*63FD`kRu1}5juK*<Z0Y?&SfzR^)!{SGup2+_oHvxVU@unvD
z*GGIDN8Kfyf`Vv^;mJm`BBq&DwG}QQc!7JnedtSOX;lmXf0jsa@~d5iHsf7y0<6C_
z>=^l{E#fx`adA6r;t8@v^m3$}fv#(8T6=fco#~`qiXBWZKU-fvBOi~4-)4-Oigibj
zea%4)#Gy<BfBvt4_!sXuY3vO~?fECq|9^X45)AyU`sO+IKf?w*0d*Gfi6BqSM0?Wr
z+y1Y3sOYeCZoF+MM)){*K!Ok$B8(0sz--d&68P(ew+IGChH|E-H4ltbU(ZVZ@Opv*
z>bN`90rE_YTjM{j+8?q~f5mkc$}Rw|Dhho+zT^7Wdi~e;|Ihm+KQTP|YhCk&UjCC;
z9neJWwe2^C<^j)f!m<E*;icYhp0Hk@;%R?;_#gJ(GAgcU*%ofxHMj?Nhu{$0y>WL9
z5Zv9}U4lCV4=%wixI=Jv3;vqp_kHKy@4Wx_4}-D0_vpQ3SIwHMYSvKiSP~N^mU6fX
z=A{Xy$2>2PI<lOkl$9)m`TcHYD*KG{#={a;YBIJ&R<`;i?0mM9cvxs~Gf4RF5^R@W
zu!xAn(Ka_#xmbnaGRL<_{{=A!k%WR~gqxnP3S=lg!+;*28TOxLi+|tQ{|eBk?caB~
zeF+8(<ln5VyEFh)IoTgMHVFZSra=>riE@DbE%|#@iuo~F04<t4?whD2=15?BzY6BR
z{_;OeIRNsC3=Fp7BpdTTHCX?%Is4a7A2Qy-r##AkxZ(fZfd6&y|NP(IOYVKeOWvpK
zKUwjAyAA&BMWIegfMIgS3<M~7o9gdHr~fip|K;@c|LHo3{$G6Nq5pqq`u+!Z`hR^C
zSMzRH&Tl|}df@(pP4v%s{QsNrp#{)(t8?}EPZ85U-?4u?x&Lx;$NDc|ng2fn%l|JE
zeZ}#Y?M(E)+Zi<7|GS<4b+iBPcK%=M{Pz&%|1v56fpzvlmE_Cblb|L4hd5448k}gT
zsP0&3tT7D8l=|nPb2)~Dy_K-FqvI({?t0U1v!C+1M9iN{7bAhlh=m?io}{$T!)2OD
z$=+K1;jjor2S%H!0+a#e$#lX<6&NMZ&o#2cu<!`ZJBi+ph`|`NqR)aSAR&au8_R^I
zxN%#F<@D<fP0DFL_%at#+alE9kdV?Qiy+;f2lfa5Tw42exZj#*?YZEp|8<a8QSa{f
zm+*h@CIn%HG<IRw|2{(h$Slwu*zOSBo1ii#$Y{T?@}%!|yX*-1F}Xv9&TaC)9@nTW
z_IucQvXbPfX6k4d$TFwd6zWSyK1Rf|lX}3RAbcCTK#ia!5biJNEz>FMRjv0zYb~^L
zXblom6XVj^!Zj7r-xYFTdB(g<f-Ni5HLb6W&_+fm|1%^83Y~-+Q7CG+?)u+?LxL1x
zBVR-<c5NiEEYbco*hJ+6cS}JalG*t?Ao}Y(Jp7gSdIzfiO)mFEAZTnpLL%sY!+<SA
zATR11{|P`K0J58ku%IH^j}A1V;Z$tNX;!y)Cd;jY!FNOgVuRdco7v^RmfWO2Y%9CO
zn2n&7Fh^F7B!O_FX{2IygjktWG`eb=uo9MTF!v0uWfqtQjUuE8YIRsy;c1v_;0$SD
z!oXfAcY8LbkpmFc^Rr`EB}wfS1bM<gy{DfXXi)WV@KgT<ZshsB2T$waLH|91@Ol3R
ziiITj-_Rj8H^><>UP1fyfi@^?n%~Frkue?-n3$58Bf{aE$&3Q>-f~%xEcGJp9hoY%
z1dg$VNftOwql_0QV_Gv+mDC5#4p?=ZlHY`6T>8<oCV~OCM=z8hCoIcS7ru8OSY8Mc
zNLoBHGEz*h2R+j(EHW8UK>%v&vlrd|uTM@uWOGR$n(`OevY+ZFE1%#)8_3GaM#IJy
zNyRW+%=TOj3KH4CgBM4eZ&HIoLzP6`xG-a)NYV?Tq2EW+`93TnhX3BB|Aqn64+2&!
z5P!4Ow{c3T^H?)%TnDlGgI5U}jVEgboovWz|9B#JBG9B<opbAUo{`99{g~JMyo6;v
z#XMoU)MZZA7%d3;!TlUR*a8B*ps+gv`2zhE!hAtBf^XYYtfF{g-}tCSWVgZ;#kV3A
zN33*0PEylPDUf+Fm1U%Iy<L7QG`5gB$yC%iiPUS*0{L`y_b)`rzZ*aW`!%GF$zrJv
z=P_AgxSZIme07t*&JkKpGwxQThK6?^495A#8~l(Z<m2HxP_H9kM_)<=+Kv8Hap}oo
zWo0F^UEsd8T-|&WiiMKo!(A7(1m~CTS|qHX)ouCx7Zix`Kfd0eVEX;o0}(BGjr7dW
z0TWWq#quNQ7yg3GbU@uxDo1?xt$)|o52GqARjv8uM8kp8wKbrkfVA_4!t*o)C?<mL
z2&4*zyUxGuY9~^2@UPHhjZ6siv61DfO_b!z1l8lv2E>q?D&h@J$z8!4egu9WVx|R>
z1|Spgi&3f6m!gJ>1=Xv6R5H4JYnLi=f5SvFDm_O^E^~`lOh%Gv%rZTCFnZ}FBLQzm
z%#q^N76o!vFtL3xH~HEoEmyGBAE|;fSxrxbF3Pt%Y+^?}IY7{JDKZfO;O`$4K)p!r
zUPKWn0x@v5RGvFMo@FlM<xSgUq<<UVPV>Dv-{?2F_o%k}fg;X}G+0@AIx86#=|k-J
zx1%-nb<d6tD&7x9yZK}!A6ACWTW$u2L_aN^d|s^uQHmh0Gk<_G<$aY5q(I?^3_Bw)
zN#)m`_<AryATmOw|G&W7_X!osg9K%q{p6i1$q1$O9SP_jA-0l)_}h#5kO{Ir5Btwy
zuH|rS3y`WGVJpFVLw}MOWd7|Pg`*G1cpfCuswYcN5Jhz6Om({B!XUyD-ZCwBA5WN#
zdJ_x6&Q~xyFG6aQr=E)X=7|QTrfNdnSPD$=Xs8f+iY=Of$Fh{ldE)X#TNJg|Guj$1
zmmThP(tJ^Nx^Kj!X|-rkaWhS-BHfyVk`QXgH!-O#jSy3E;R8w$;F6@Iq=;)b56tui
zBOJCK+vVZSS(o-0l}s+8symP&ngaDjAtNiIpxt}oMS`#C{6j-y?#isT2cj-$1W5l{
z@v74fdA0q-mb1&aeiug8bpc0CZuX1*PT=LD5tH#bkXu25*>K&bHRg%NDkYqciDSqJ
zP1a}{?(Q|KXapq|R**M5tbl2^T@^l9?-!&=FJAf|N;a~YsbV+fjDrNebfm~zgTJhV
z7-%KvSgSWt)qY&rfBCGjE9#H=H;euc=m#=<$+aWIOhC0{%jsIg4(`^fxi4LPZ!hK_
zC*ufv1BY0@?ka`#Rj5{MA=W5E)MN7+8tev8)w*x1Ny`g-iz#p)9k7~jM|jP%2Ry`d
zOXU<fY=<zE>+OyVD(%w#5z0E3pLVZA4Fc|?b*eQ8*4tPQ>#Aw9M-`yxx35zm;)5Qv
zhm0g2lu*`qB9J96$jB|)Mb9f*R^mpft;Sh~`$dx)Q<pDGYc|GA2?%GUSi}XSB@}y#
z&CPG_T9dD6qN?CSr24E$T1iVFovM#6BEq9){vC0uTEw#9%RU@Mtyaf2<bH1dX3SEu
z2)7~P{zjE8RBO2sVzTMCWE>|J_&%ry2{W;Y9e)E&P0c2LATAmTA&(>i)>sL#&z~F~
zr<Qb38U$Xs;x|$hz=-Pk(z;(52@^eiRIuN-3!Pmgth*;s5}y@Dyr&+jrs-9$ZQ$&;
z7huyCDf(YttnPj}62VTvZOyZ-FNyBXH=zn9(|du)le~>1;>z52dRh85paxY*{pZYL
zq{5}{$wm)FT0V2eOVx=tk9MAJ0SNh0_w&WdV!h8J`$qCfDGnKDuWt3iBwGy?$0>Xz
zT&x;@zS6U#|IBoRofQ9|*~08=9hi5Nl@kQ6qrtgBAYW86W2uLg@Y-^K&c`k11}0!c
zfCqZ}NZvzN36%eyA^7vTTUVpe;{^@xZk12)>s8LqIQFtqqKr|8L<8FPpq)>iT*bV~
za+!)MIjuC3sO)01ei5J3L6{a6gO(^mMSXX<P7%D*hRBP}j*Z~RRKcL-{@q%GCy1pI
z7gs)<o>F~F;8AUNTlYd;ZZ(A&KG|e-s}h&9{<e5&9R8kfMB6*KaaTT%LG)!^i7r3f
z`w6)eA|{+h?7OK^JJIu*E}T<DdZy+_qIg_v^$_WcG40xRii;iN0?V~!x$?O5dP>D`
z^d39MrKP0?rcDx%YC|Y8F;BTD2Zt4~AT7<J1}0VgR8+v}boIM-GE@GDR%3-{RitQ~
zCQP&4O4*h)Z?aR}?CEd+K8!9?UP8f?LbI4e<0`cdbj-b2OMfjZE4<US`q;a3UQtlN
zYtfchr;)L7>F2&yuX9+wH=$$mWS{XPq??;x*mGwSuB);yFzdFMn48!iLB4h3TuLA0
zTZi*%+nL{4z7cialms!D1VW>G_$f3D!d-Wv@Uf%Jq`fqxCNmpyOk|Xa?qD)db^lok
zdASN_1Rjv~=-5!F;c}*4ex|7}#+(oBbe3-4E#?kd6k61lo7X_bNAozDY3rulq>#U-
z_Z#S_?|?Zs6OpmRES<WX5L=3(qXCVq<LT>Qyh>8aa3H#ygl=`oN7k>g=1tzz+=(%T
zTxL-mD@><Ne9ig`C6M)LouMqW6b3va3&YR1gBI|f71Cx3KqJ<?1Y+A#)$jIJE2Zp>
zc4{HC*Uk<Rv5ri{=d^c1w}V%GBM8X_CQ6o=TdpKnO|=%~(2iY=&IEJSib=F7F{<a{
znIDu7T;=PXR7i_zTcnA+cOE20%9M*?Z+~>6BeX~>f0rC=Ji4>kp&mFrU*A4Vq8Dav
zTK0+#c3jGlT@Go8SDa}7@`HM`RN{y2iJ6_Y=R>D`z&S$EVy2py01BvBuaU2dYNp<D
z<(o?ROEM#t_^vb$G=j7yri_>(3s%;HbuTc6BS*~YDUo&dg+2y`jI&H<_L${KWluoh
zOjO{Ex)Vih|N6^<XcQHM^RzpqiDt7gIukoNs57f%{<t>h)U*5bK~2}5;#@hfOeU3)
zzPdHVSv}_Z=(XJ@rRyinSUuC|Z#Ldb3KZ^zudhG(8p$l*d>x+Tc6(eF7GjGnBK;$l
zRtKW|3wT6mL`D+4&>ytemcwWlw_*`_qG|AouM)l1<jy{_DgrC5Yz${y)B-w&fV9cJ
zxtD9PG+kd}Uw*4Z2tFa310}-BD~Cu3{t~?jQN<B&<QDn3r8s6$RG4$W5E!j}0vD{>
zydMvS0p{nVrhNOtaN?cFww}8CLZ6j;E+gvhTXNMXSaSR)x?GR6GQ-7JcLSN8xIg7J
zk*aI`o0Vz;cXUTRWtTZ7>0u3O;w!RyNn;(T0^VYL9pm=QgIl58$aH#=^2OE&Xhd*M
ze3eo6AXJ{gWK5N+K0d%(co~y_zjkOUo%>U~I?;r7zqmE{o_gC0|6D6Ug1)OOmBH{8
zNtvn7?L4^_PiJ4!=Pmiz_fIpgC0*A_WOPeogvYrWzWcL8CobWpT^VUP{I=_IDT!AJ
zw>zttoT_r2sDo@s+Ti}V@QA>vDvzl{S9Dl~(ZdrhpSrH3If^rszoW!E8(R6_rv&>E
zLxMyV-mCj181E9Fxho=HhOk(~RByKz1QjFq<PKMeeU!3a8m;H@GES1EgRoh(@4xj)
zNJ6Tajt(fxmRU&iI0O)RY@wCwRkVs#-vwfiX$!w=e1-ERrl+sj8}s5l4|!uKEk5>z
zYw{=<l79VhI<P)LUGI}&L^I^}6peB?xv^i?QlRgX0Maa*O_$eyxXaYH*!puwdoZDw
zUFN#+<?+kR?W=c)a_{;}@l%u#n#H@C7~UsKp-<~x(WhW8;vV!JABJQMf#M#}a_Q`e
zoo{!aW+FtdE3Foq?IiBkH~Ox&74;fFpt0SZu`FuVz^M!<7LDv?uc*<Drc~#HRA4|E
zvH7Hjk#<zn{`ruFg@x0ZH9kTzueydA&k;?j)7uKj<Wl<;;dw_-nq5;3W%`<wpjv}d
zClq~8QjAeMXv4V&ezM_kD$Bm*s^VmerQ&aozpY!@{JM(}7A}7K<e1Hkm(Nv-?$Wj(
z_kzL|q-pMToA)$_l=sqguL<AfEs>kGkpkMaHQN#8eX}C|y^j!7CM4mD2P+lR6qqM)
z?tEq=yfEX7(yTa=HnR6es?lPU%;%7z)XerC6a4#CXB?$gmgl{GVk-%jW5jUffb>~c
z@h%Vf&2UNdfw%hHJsVl}D!;M4=Vx1BDJu%{RsW;xk}&B!`ctVZLxd?yg0AP&B&1gD
z+%xX_kVuTkvK&7axU(H_K$Xkz=dCFXL`cwZfb*cmeEv&A#8Pk_v(yc<COsG3Xkc}<
zoo2|{k79JOpx|HY1tk`TDWViH%LAk|^3^|;4Eaz+ph<?CV7Go+C%2=D)h^_P%tcO(
zGmI)H;!)6q{2;Fjvw3D}vw+JD+)*VW7<{Nh7BBh{zP;vQscEHJ)lwda2!3rQ(zPnj
z8(UmqVYjN3ZKZ+O#CpX7JwAN*DewrtXQBwPGNbMSP_>x7g*c-w+Ty&C>@eH;nTB7Z
z>aCtTeBh;#NxcP)B&ys2ztewaIr~;?V#<Wb@6Sr>wm2uFj3s_{MoMv;R;n``iiyaC
z-bTG`E9JFU_K#%_G$4%~@VVMzfuOfsak<WvjX}RN%H?G7GpGVEAJoZcdi>Ldu=mrt
z1h8DS=mv4ny@@OZetUoMqJE2(_txzwlW@Y{QNg)XH1#V!d;MRPe+S!2vP9B*R>wHc
z6pGBdR*GDP{W>o@tje72Y=6?%RP!C&FcNu{H|y5B<@Elf>$cWC&6VJ<sam=JRn7ln
zqnV71>>y%(@BG%oLw`Z#kGJWiueDsFu8-vhADFAtSDOqafIkWf;VH{)3kw<FnV>pv
z5sKB-&TxaziwAJ0RH=ZPXZb0Jyr)!OS{nZ4dQz~#?b0ZN*Ojqr;|j1Afmvp|(llG6
zFGvfdy?>eMST)%B?)&Bgd<EfsOHe-6NWIrMs6H6fU(RWe&{aeJPr-s|UkDPr@2gh=
zpIVLHcp?^NNvrembjSU=%;|FDOhHEVsAp6mCRV~^wQif+RW6s+Y6}Yz0au*W+}Bln
z*$=r$h|rM+J7780=9ZuvZbq59O0V&Vi528BIf1rYcPn-!(#f<x#5tGXp%uth#xp<7
z=(?_n1;U^d=kR+f$CKWz8@}T%kXo$L!eBYDVz!ZH!7`K6wiMLS$E&LmD-YlFScXP_
z`8n@%pep{ty}Nd5E6zRr!%K}`2M-6R(f1k~NFDHufg38ZWT7_z<0A;Nj(*$JoNx%J
z%GnKYdSn{0dB#**a@Ti(c@!=wpY@}9thF9+yaOpkC4}P>?R1tDHrUWkB+^R0h09Ll
zHSd0<=sSFAtIXv`MDDef-ryncrDB`e$j)i`j^0?Nqyty==!<8EwZ=N;w(txpfPeJ(
zVQeHlIz;5sKD6H^kZbp%dwiuuVR3+j$zS;O1n+j65i7B%JlgzA*~yItC12>+s<?!_
zSy?Btdu~11(Y01yDy&2dr7~rtZU9Aj!d4E^C0^Gg#jg({(2Cc^NFB3)HYQ5&kQV7j
zc_a4(HJo>B-tvCrlpXfK83f$Zf&KSKLxQjez2$~vdoxGQp)W)IJ_(daqrWl>R+beE
z(Cb}G+RB_{5tAe7WE`<ykF&D1p~L6OHM8?&QVO^FBY0p!&*c^+Bw~mPGQWHwj$5Eb
z%aVPxfPT5@%cX4miexpPkH-J$$U){Z(b~pSn=IEoFojXGjI`@@9@c8HMXx%jH&4C!
zv;36$U+by~KBwgTPR3p@dT>lF&BNAnkI-tc%0K7SZ6-^b`q0#MXyx(e`x65cm&d9>
z&E$ilz)PEb`pDh-Q)~So#W}HSfNp5}2vbcE(9<0?w;_`7Bz!!x@kcup|LvGaF;Vta
zU3L`CD;|S(s}@jU!aBB%$Gw8K<MuI>{VCR+R*$Na5<07cQuNQwiAv3{;%IJ&;c?aq
zm1gK@qj;m?g!y`j))E=+bm>@un=JK@`Gswd%cGj@9Mq+3b8<NsxSoZ)r9sheo@Zz(
zn<>rKkiE3`^+(>k{QTMLZo3ee-$C_nvmhbO^$(gqx&9(O#_}e){un{&PFktO?izgk
z30R{xcZ6A{JonWDRrds>KKzze;Wk^Y8ExfxL3#+zAc?<KCT+GlA@d;?xb<TMdz7iS
z{HgehQlNI>85ytIH}R88XtUVv+8P%wbM?+DDa6|!t8M#r*uLv>bdwQA%kzw%WA)D6
z*3rKY@p6jE7Vz*u?=4nPDCvO&{XD{`3f0?G)dLG}?0pwdYOxEM_D&0kv4{(0vHC%T
z<DsfJXL4kC;c;d^Et9esLg>`=AJIq4;m?n*eGby5HN1xOVF~-suviGX%8guW4yNuD
z85xcCf~N*b;chiN<4^UP7QhJpGo4ZQwdHd9Ia>Xsm^zEIz+Bhq{M*6geUK>lPmL+Q
z3a3~X%+llJU2581FVxg02WS-yie70njb)a4&G}n@o%Ji!&An~DU!x=2@rBr*_YhWd
z#7=g{zgVEkLDXC^p53R!o}_AyNW2`l-C=FU>7u1Ighq|ofJ*L`Xa*jh7}uj>FUZM9
zU$sX_<D8GO-IuO*r7b8xsK)ttf;2>6gss8EMnZ$)vUjQCtEgLP)t_7jZqbcOdsqiM
zTLKa98s@Hr_MiKGsB6RY7l}`^@%dkuKJhVMuo00^7w6*ZFNeh+g4CF87u&P%>J|)K
z6MK9XnrwH82rgWducWl<#&k5C#WIUk8^Y`$ULdODq@XWX2=ciTK`p9r$10IWA0Ba;
z4FFXd@oY*G!ouLdQUgXv_R+qL+5(AK<xph8gRZw%wsGMgDN;rBsi0&iG8FE+iki-h
zLHjIb2Js*=($}jUB#)!nGWwGf>kK_`&@Iw-oe#ykK4{JSe|`tDJ8X%La&7p&@jIU^
zPJQ)d)_^2Kxp3ka^L@_kr~p)M9ke!cL83s0lJpcQR%*~x_pcE~Xgj#N(wu1(wy41O
z7xgfp!uG5+zMQ9z+w66m)bBw3c{~q3nTR=GTk__uzhA94hDm1BU1nuH7#bY~2~_Nf
z0WNI9d2h<**NSAYGnfqn!dl%f^Vgc<;f(7+8m#O-&u)!)k@mw06qakP&O4i%tL?jY
zrz_w>;nGJ7H42f~OiiVe^F1rgc2GEo_W=x+zw*Gwa|Ji{c&giOEh~u6qTaOjC->TP
zE`Uw9jM!Oyh(F5xnV>4ch0HD}ZNETJ5sbT6TQZ<4-gF^W;<asK5nj!#d#Xx&Hn6U~
zJr;XOO68a|7@9zK*@>a6K78Q8Qjiv#9-N9b^(*mGwVsDEbDlQB;*?_|=<;(u>VmB7
zT`EH~0DJ-K#>}~T?x%B+ya*w!y~l8!aF;azy6H8(y|ivF?hto=<LAp)InkKtxPLj%
zZFGk&hL%O*ssQ_-v71#aYmkh@pWaQ2AHh-}hm?lL%wb^FJ?mEnrULQ)wf76C@JNyd
zb6d&S7HDtY$d(#(AL=Je;DIV4o+#hC6#gj3oM;|CTw}jC=DeGnc)Ljc{QQ>M;WJRg
z_v7ou;IYEZ<E^#FurJsN1-)2=3HzD)>9(r{UM`O%k?m5843k!g59UZRFK>}_auyMv
zn`kQ2!&L7NI%mZX8kr%nhgEFb2T&ro8ueBm#!YJ>3#G1?RSR4s1LN>t!Dd07o;!j~
zh7*6CKyBX`<N9@$zs*Lix4YBjt5s#nv1Dru0m0b3VO-2~VSF$AT|Ws5`nI~gMj$T=
z?>=-+iVfkj<U2xV*2NmGK|nUU+?pvxGmvO$to%{l?Ss&OYHHq#=BfX-YwVz9U}3f1
zDgdUM#PuC}L!|kz_s1x^=N|e?0~iSbXL+g*J;Wxr{M{+PXhDb^n%olJMji1Y#DQ{=
zSFQhi;i1Sdl{a2|k@~&ij;HiBEi$TXBq!HK!<PHkfqQTWlj6hsF!&+m<7P~vRbK)^
z0XJcCk<_Xc&iotP8RkemVQ9X!B03v(INcFXRH4S#z_#V`iQPX<44y}TAJHq=`0Ktg
zXK0|+tXp16yP%jWpH{|zwB8tU@Yby%FAajP9EqpHk$gg8i*WntwEls<yzkr)l5sx_
z_jDJ5b7Jt^GA`@3qn9X2FdnWl0dMLK0JL4|RERyfa4eWKTjcfZ$IWQmYFKx1gVvg#
zkY}(mcWe!>fzoge`3#S*AV`@jI#tHQ7VEWrgPVry${J?A*V!hFcG24I*Fm}R0Y`2w
z(@|=YlpmYSsHexXVM^Vz1Td;F+ABpZ0gnP^^TX}F(E!im=X%)3JHQ9hz_|h4?(({&
zEhT|q8W=>yPeffsj{Y@=s@*bcZg9~07ed+0Dc55fYP$0%u326}_&ChYkB^RE<>1|L
zLM6&S&{;KTS&Af4v*rKr7dgY6P2;{{-&~zafT{MdJu^U5=6_x9UE(`TwX!_897SRG
zm;>@SN2k|t@uSl{5(~ib^=~`sUl+#8a72)Qo7H1Eu=`?n>d$+Ft#3?;jcyzGquf5_
zk7|*S(MUSypKQJJN)U6`UA{lYH6MaI%^X640|8hll*7q3x>~$$dkcx#aI@?o0J6D)
zm-izYDXacM9H_X7dpUX$94o&~!Hr)($P-NJ;mR5z>gzzPCQB>NU}(>0`}Wa}(CiwV
zgw7$0+Ucc7`!RFyXGk7P^kam1gp43I5^syu&lG?|wS|hQmk9nHWY?)d#iL0#yJd||
zkR2(r_J9)j6AS?0CJvtDu)T-$n0gz>t3YJ6P|a^TlJ>baAFOsCv4xgYqauxi0sW0T
zp?<8J)1Xf-9;wo3`_F3~)@p1cCYf;IWM%Heg@7u5E`*SJ9DlKhO*C4(g>hm~`gV7K
z>)D;PgP^8)W-Xl}%sDuu`fN9V)#XM~p5;|@A=((OGGgRpVZ#go8eY^;D68T`srQLT
zAH{P4#fFM$@naB168G>m$<P9LWrFw9^4(+(KN+)%lwa_2*CbdacrCaAVlCfiR7RCz
zL@=)J4%^~A%Rz3nlYad)S`8Ll4XCcO{;gnV33=sa;~C+cHM(t-ex!>cJWdBfiIj46
z7Wzc8**wY1&2~)4V9*dkBP%P~wNI6r_2M=7n;^VCV)Xdh7m6}lYbc`i-6%LrCRd;X
zkm<)^vp<n7Oe`t11`<~#Wwz9e<aOGN;gJPNo2Rd}xvGFD&IuxBPUhksJPxxlocN`6
zXXj9XIik(ZR2!%M2u!k@$s7`2kmifU)7>el_E)oo-iO}=IehM<etrf~0T}ceinHb@
ze$=d2W<zlwXS;lT9bjFWgoELS$um7GAp#ApLCh8@$}&Wv_SVmEcZP*n@mM0cD<3E~
zo7I*$>*2HclJSXFmQCv%!OZioJ=n|hZ94YIY&+%9tDreUP@>7X=0dOR@MFLMDa}b(
zwF)_+C)4X;Wa#kj*qy!c)E+^zak&~&nh!O%4@}hvOQWUW&l!#jnH@}|@R7S2oeqaK
z+zdfz26ZanN46$QR}+r{_8N87b+JS3A6YB>V_~%+Dt^U~#XBZRw8t3i$nKy8HmZtS
zXgiM_S4}kbj%ZLkRfErWf5}-Ba%HvCxU-kPy4X}v5<_$$M?*`zWFFCeh2C{Ng+?Oe
z2hJwZi11jcHq#bK<6gCDeG1;N0DRws+;xP%0hkL``!r*2Z2c&>+e;VU_qRjT30pAh
zt+p$8jNV%RUavY<B|`Qm+r`YgFS)fx70x_14iat)9)_bj>C<%v$X#7*%=^Jrem#54
z0C_bJR(~KThOv0&zjJH`RwNjBaoyz!z=e=}r-R579sFsWUL{-n1)IF!daO%uM{?Q=
zZvprgOv(KTeGJauIXRa!9SV36lX<i_7`;NUe(-)ZwbU<J{QI3g*CBWuc9McAG-st{
zsE42IAeE2J)^7iRcxsg#FYa4oT)?)%VD8g_LAYUor^<wmrs>zTJ3yn;DVO4GeCi6(
zkaum$t##9MC2k}`{ytN>XgE3y{zuYFWVR)C>qX5Sh&+?!%6KeO8^Th*bc%{%mFGVL
z#0$toT;d`y(1D9Khofq|XJM|8cn%Wy`sFbf05#i3Zy34UI-xA(Epk0}Cle;=40@$7
zm7iQED~^Q%1LkA6VrA_r8aoJ+4n{~xy^H-gO%%STg3^7^au~z3sK-+UREQTgbXy<D
zqZATLPzqY$6;a^~>W-#6eZ%TVdnfiTw@XyJ_CTc-n%9F$R~R3W>|SbM6c>;ooOENd
zx#C#O8|{8ps~?dVfL9PuQ)eagA!q<=4_p~<afrFjAqDbQK&_&hFCbEb)A{j}*}6H@
zY*3_AKVphS@BJy*iihaj`ZNov26uaiZ*72yE`Z%atFT+-At)g6d-2gj{?m0Mpd#z6
zHk~C1y3${ntb&CsGu5^!fgd|}x}n2Wlz(2R655ez${M;wC<@Uir~Q@MkAoOT12TP%
zgwUNetq0cuySDr^R;pA(eA`tMN9I<;F<Y~!;T3b=OVIJPb_ju!HM8TC^2Pm*1*E&I
zXIx=atI7y%rb?F<bj6BF8;4Yab%L0uqMnPO2>cng0s9+)Pj%2(q<l8qSP>0c4M-Ok
zv~Is7=J{pH-!b+O*|Xi}{*0LOkt7EOEztIrLcy$>Hi1E4jv*r|pM`9$S_Q>ot*32g
zvYV3tf;lnbvwBgN4E0s5cccjDIi(4CnNcC^8O&zGJ}z(c2-WHbcKg&iXG}(k5q*Bh
zV%Z5;u&yQI_w0k_qX$U$6tpxxzuuE+IURI{LC1Y@!?cq|6D)V;RDOyUJ!Ih%6{jN8
zyX3IpI<Fggfrt%6J}Fzp?KyvjF{^kS3Xy7wiGh4Dyb1DkJzp#8LO!9w`D#4z%=AXc
z?~w#<2U9nArk+HtL<()5MBzuqXEZRa_c03xzf_R5%Um?PH}IGL@6K|5y2Zq&ay48i
zE=2|x|MbPj>aK6%O4q&NWj6C}SPoo5x>tJH3yY!t9$Lg%xMUw`9Z^{<T}fWtAAStY
zrQ<%rv#8|qih)-c{R|Tiz6#Z`t6fO3ciQre{Ic<bN$8f<E{QsRIC7sCciNqo9nWhL
zkSus-T{)?brvX)5K0JdxGQ+%@O7{Yh%y1iMs0DI`zajhvU!Im7A-ZG8r4pF0GhGCI
zkqt2YL=%e4E`ImCw_8Qn7H9tCFNH8&t;?IiD&{Dke?(E~Y*59ZS!dEp1YiYQ6ot>>
zw=f392c%Y@o-e8$9?t3XcYq<2u{5P1Fdi^_GSiVH4<bK>ZZ`^NPtZ3|yGz}#_rlGw
z;FFp3^#Br}(R^C~W5)EOk2_hak2KHWaHFVf6<RZ_>YJr%u%H1T8p;Y)`a6S2r;;Cz
z`w<NwneSi#cdJNl{#R2r+hukK!H@8WD#>)}YRV$exdPs_-Le2R5E~et!l-N2BMl{F
zG?g#rJiuFPhsmhJWg;exIRDc=_V+^~x1*U^E?-IEGV<0ssC5Jyu6?e}Vr@_F<;Z9%
z6OBX+0Z$7&iQKIK9E$hyS=Ezr=lnzc1EaZnv~9<z<{oRT&XgaoAMkE(wCVBc4NQZ>
z_S`lHTi^q2no=yG>(3^g!R~hSYnd>UK1`SqXlo?(b8BQ2G$ey%WwYkG6b5smnN<k9
zOol8Tzs>hv=amaamB;pXIM(drOG~iidQp<>CGmHeh812Gds?(%bqWs{Npz;Nkw<ga
zBgxZ&k4Y##R1HHo0}!=$ojxxqq}O~jTGXFESz$BkcgP1y$g(<lC^y*qSS{C@!2*x~
zf)xw4W+hnr2NSxs^8R)!0+t<RTDx^gq?(KKxwEfjoBJmiUtWp{8|>Z;U-hb^dvH!L
zY9+sUsTK*-L=a{!01zQ3z!q#42V&%z5MZM0FVNYFVUnq};%L?B#gqzge9c=h-9mjf
z+7t5%o=&nb5+Vrm%*GS^t$+-~j0SZGsnydNx7vq~(Ex`Sz}KR^^VA=XrX{%}$+c;0
zxLM_49s@2=w!HTRIvZxD62-Sm!%~t|m`x)*5x%1fuMoUHer5^E+l+d4D`~Q=fkH9=
zw<c&%nC7^!0I9b0D-o`;?i&u<@_&ud{t>i&`vvd=PSgP(3a6sds&zb#7SX4@l?MwL
z+G=o%E8@B9C=0&_p8C?OT|=lg+Pt!Ik~~pkvB)G-i_`gNOTc{~&y&UV8e;R|i|C$r
zVMgu~zJW5U3viI}f|g$GbWBYkmnZKAPAx%bT4+>2-{ONbh_f+tt$wvY`&W&m*le_>
zQbuPoB+vnAM5>lK8<LatI^Ft-tL(x$T#qo4$Sp}T5!wte%5|#aOA!!$RQTo^U!oDf
zd3!|VsZdR5G%S>9%g_RgOU1HA9#x7wxUG7|L?^=P{cvYF?C!ok+U|-g*)Co6mwNB-
zks^}$rGD1?ZrmR+Jm4CC*z*$Vw0q?ov5A)5IgX1S7IKW|cFefe?hv{4Gn&DVortI>
zgf-u2z594+rX=IrO66gs(_ZCS$FlOB9UH>hGI${ON{G#<2MUTA*e3|M->u|Q9iqh9
zw|9FZTtaPke!z2g!&l0CGPz~dj{~93xx1Gu&F7_h(VRTpFtXO-3!nG&TP=__QIwlM
z1IsstrnyE4w?&&w8*=%4kZo7$B*<|aYf`{U;eXRg)~7g^X^q2^R)SZbtj);bJLR|8
zWWj2V81%Yvb_bD){DPi@=VK!=u)$|8)K-)pTC;%`t~M4TFVyR^+F~+cWJdNb#Ai-I
zY^NGfmo^*e>nMP)-mXy37<@>HZaZ3V?3o_Mi0_!&hER8UHP}Ak--0(zW_wBW?sxOO
zf9>G9xtaA**Slofd~D1-X?(!Nr|?jUP?chca*NYkrLr-A>!$Da1&nZCD<MGB0TT0H
zxf}v=h&gd`XU$>x)J7i9*Sv)mT5JKHiIg(*uR9Mzots%Xg4?lQ#;~Bl4D5PmKaxi6
z0~;(pA~lHRM@Nrn?84W=cO{l6=$P2up4-eu9oXUMBqyL#NEuL}fMQNowOF)Tc<w%Y
zo!!c2Ti4DS?^F)7aRRMg4N$|GGjKI9RB&T>SU;>O+#P_w#M<cnx?+;#hT@f*5={}<
z0oX$ho8Q*jpzohgx#uFhLWB)y7k>!(4eUCG)4q|*^;%$XB+O$S#giWQIe?qBZd!@J
zw!?NAqQ<)hSYYrEsnlm2QUp@PA%~x%(LnkEYGK`wI)`6AcPU>y`1eDdh>GVQ!HTmp
z_dX1HK;R6$ZEE+_CL-?}7qly7vwqo`2k`8@DHEg^0z?p?Sr-!oj?>C+s`o4#tr!)`
zQzvCi`hPU&cmacK-OI$c(oUNXE*h~(bLqsjb0IW><p~Y!XM(c*^L^(-<e7N_rqY^A
zt_LvpzqIFRB353R-cfS}p!T*En<^^~XPrR$_hrUzl$au}{uw&&H29W~mM+RidBxgt
z+~(v!t&5J*BZ(Og^U(NIlm2o9McDS7)T1%^$9q%1M>2T%2Ykdhw348@tk{Nml*B!b
zS7ZEA-TbR_sy`47a)%Ro!&vfIk%j}JnSO(=0a@$I8dPNfl?{&3=Wcp+s+yt?u#I!Y
z2#m+wr9`HQD(fUEEapf*0D9o~$&l+e)P2r{$edWc9ZNwgafjm2dRD&Bw(U|S>9{E1
zeVjNg!D^grZR_n_>>}I}LgI}`W7_K-Zx$9UMSJzgUHh)dpkQn&_<G+>;7%IHb(0V|
z3fK&82RBF_kCP2!51h>D2=?dbhGWk7I)KlCn3B(0JAx)c`3S{y?q>EmME$lH@#Ii1
zIe5&Ygf-~n_z>Ci+WvXjsj{Hb>@wij5=(y5G4*pJC>4~zEi2t^6Ko~rck9k%Vzd$7
zSb=Feh{xba-@j6Sel~4BIqQOKp#`1m@Tg!2g@K+5+eUU#q!(Y~_W8jvXTf5U$S=N|
z)%bLi$T2SpQ6s^Re9UpybB55l)J8ZOk0T!n0W0iU{gZ(M_#b%X??z%^dx|qK$OP1B
zU8tWx=T)F{sP7r{y?|LsAuOC;K)#X~)P_#GTRf`?tYsSF06iQd?|bWw`!!b&%(Gv?
zyhqHpmJjQZ*6B1Vln&V-0<s1I4$c2Eo7eRVVO-GdhUfj+<um`E=AVR*voLTl7b^$`
z=x3jpn3x=Lw?ECq|6X5dcdrM$;8vlPzd(M#6iT==dAQnDZT_MgZwhJ~!c+Q754R93
z4DN#1WTVqtwNMfbP3;q{=W0Be1hw6IyGPyf<gfK}57S(l3y#U$an~QeKN}qD%4c62
z$pNe(3_75$4?T0Py>cnl!X6l>?Jl!mtYLEa&gDntg^jMgmQoDXBP?<E#)m?=F-9Kw
z-N^P9ahJ-1tFElxR#~V9b$0N0gJFNaQkfT*%(gcfGzb`aGag*a`ILy~et(TmSpfST
zw&e&>vC}%Nl0$Z{v(3~R&VBP!%Tg4l^5@s8pJCtOK?!~CWH`~^L;T!bOk7yEBz30n
z2L{_vmfKk8UF>^mE+63*!&NB4tQN|mPGCkprMZUhONchj^LRn%P5qYpBo>btUVu<S
zSjTr)T2S5l%rNsClmb)(QO4@A!obse?JYToE>#v5d-qxb9``EKO`BCR@`oce+w3RO
z*9?DlS6G6?)wU8aFTOw8g^xZ28IL{6bFM>N9TwB%;W+dkA{q666i+UI?Uku)Q}Ite
zM5<f#Hn<zfS4+@>ja9Tc+emGgO;-L4;s3L9$aXaEnTA{{%u5Tw2~gV(xi@u@m)ZZw
z<aU}Tn7gg}8e&Zjpm(;d@qPl%#O7R>O5k2IEGy1*JUq?&=@H_tnsJ}a@l^-)baR;Z
zz&~CyoobVeXyqC=jo~i3TOwR$kLj&}>if|F>^HV&H%f*?R94z<FmAWf+A?xULn>Ul
z$}{7&@09PGF9#@C%WAu$tQ`r-dFO`v)29B;1OEeK{PhBCFf^d@Ye-eO&Lw-0pk&*6
z8=`gwj}BWqRP6|^eR6#z5CE*wYL|wABj4;le0Fz42>cm_Slk<Gi9-l3<or0MsrTEv
zJE!^0)J}ORXyJ5Jy+(<&29!&8yE!9awa@`kB%iu`K@df1n5EY!{DI%{AtSw)OFy<2
zp3mzd4R79(%IG_6htq8oYKX=Dq+apx2QxNBNw#^_ic+ltJ`Sr9y)n{I_Ae)M-Z&3+
zJs3YTXbzA(H7o8^RN_;*x?M?$`NA<@KN8;_Ehyy<L*V^g3*hJI_*fZ&W#8lJR_#U}
z<BfOED(mpsI%fCScd`--p<I^y&a4g70>c82@Qc=sre7!NGNLWkv78O=eeyks<oN4#
z*6E1oLc#!x;m#vC0)UKCC?f;4$UuV!yAuTAQsPE4W5chi3R{hZmy;z&utHw1iy&w8
z-HA*Qzz90!4Ptyq*smA}?QU8>73MqpwV4OEnH}5=!&Jj<>79*|3FY%MEj>S=**G!2
z(HQL#u8>QnhZ8P+zA_7m{m(Q3E7l*zSsJPq&h~d>VqlCS>;O(jY&qr=CO<BYiiTex
zwp{?|r;GaC=#WRN!>B;=m@V(a?nt)oWC`>m3-3bsc8S<*@2<+we52|p!JlhbBw{`(
z(U*(u``H2oPmU#0udTEiob51rRdRjUUzC94$i15U#)?ncNqwLFh22Y47E&<SQbHwF
z!0bM<I*QKQ;6mAtE_wdMHAtod0T5-dyz3O%!tZ3oGwx=>Do~RX^QU-9@%bAFinA?B
zY{ENW2W9RR9;zY!nN3mNuIH-?GgOlczJezBZa&Y`ZMLvYjiag0r79~vq}tnNjnuY0
zcET&@QIw;;gWE;AC1yPM2A|A6Gzh??V|)6cfPp)S2}4u{_%B_Gn8PkWp;LXKmrkP=
z=vU~riFuwQc7A+XLl3do*qy`!&oW;V{Gef4g?74#RSRFX30M7fV8z9)y@q>KYnRbr
z&fSdW5c{X{l?t*MxvBA!RGZy#9*jE>z;~oY%S~YlO0qjmeS$Nl{)vlg*d6z_Ab9?(
zh(st(i_;-%Xg2XPBdv<uWaFz-Fqm%K)SL=}2t{L*6>Lgu4_+6uMW0r8EBGB|m^0y^
zU3;PCYOVy6pceKATd<vvOQ2qEY&No-_JL-lASUzpK6jDq$~e99{Mv00gXil2i4+!(
z^ECz18UYD%&uV?CCbS4MZd5|X7>bWeMNWo;d_l9NbJCa%epZpk*DtpsMzsCz+3}N5
zm30CV!{v?vlXicwPM>uQ>$L79NNf#%t9HM9GCBh{ZcnnQyq9TgNMZoe^SJENMC&<5
zp9%WV2>}5x;C`6dOGS7|vhw|o<ausH@rNJlb=USB2-vhBr7@WB&dH`8{IJ=*5n|ci
zu%9y}F~XyN8Js}HiMc=<H`1g=OjAaDhGF9S#$x@Pc6vn2xo%*4tzV46QYJN=l(Yfu
znd%|83RQ_W=+_vCs1rClc`gS0iq}O)<_!j6gRC=k#mSHq246TA<)s5QUdekKmO?P^
zcjaa#TlRs^mun=%s$kIoDZy{4-pBSgS#J|(+k{{d?$cS=PS%N7n;lNOMYFC;@|nO>
zw~cLlTI0A+o0YFXtq2Sb(jkDKV~RG)H82c~v@S3K#VJ#>tjTUgnkhXU{*syW2?Mec
z!~~M~J*TPrKL7CtwfImN&)_sQM>-7pm{jG;(D(zEuavYt-rWTHh8JCDA-Z$fu|lsi
zNR=a%Vp01DTGo`AK3KvvNWEdKFnTQyS{3U%>7lX8;1-@A#Bg;Kn#4=;p*~sd(Rik7
z!`lT73DTdO*N_BC>2C42%i%=+oG!xwG#oRX{ReGXP6GPwYZcF{B7fjSt?JT|uUluJ
zW-}Z#A;6hZAx9PjL@<WEA8*hAbOb@4YLCX!*#g|*Y#YC<Wtfen`5VA0eU@3M(WkPr
zv*VBDJrZg&I12!rD7CrRcKC3R_$vVXp&%`~a#=e-{5m8h9qe@6pq5^jPgVUhU<jHy
zoc6o%ASLr#p;ThX^D}#1QASKHJUm!8q!1y^-*C$z15@~7#r>>Z*NZra)t;I8WV=l6
z=ivbfQ+eGYl56z>>PS`ql17gxMI#eu2535#=I_DD{W;ThfgXr*MP-)STs?v7mIsJJ
z$U^@%8cSn2HC>o_r^ER@Zcqo^LNKWng%lD&U1qG$*E>`jER@p8bJz?!Hf~1*RDS=B
zAP?-GZ_8?B1V}*Jhme3#QiD=kXh*WhLrP(hRm{%2WcI&UJD&Ys4hQh`WG#n<Yl3^R
zI`Hq-^%sP<f%g+gGsJQP_@9)Le)QvtXt9<@E@7^JZLi?XR?Hyr`|6P*XZT?iYHfVS
z9d6IN+^-1Rw<5-xBy73eOffK9lZ(ur9vp@YRXr<r$kkQbR;X(n-cnw>aQ*u_bAI_J
zBtz6`k&0W?LTAQwddPzKN<nsyr`_gbL?KVQ@`HX4!nW;{&Iw2%ym>2v@R3p-ItB3Z
zbl$>1R7|emhf(RAE`u1xUFyjt3ER27+@(a%19{$~tE|$DxhzTDCqN(uft1keXm>eM
zXRO8MXWO$cGK0#g-<FKeZjuNKdf*8CL=BU<5!9#81YgnTZeEJ`O@|A|k8`g+_31%K
z9B*KlDG-+Nws83zAx3BNWoicVm+4lBCviGUvvdjep8z9MYYGMxa^Qu2<u7fo!5`pq
zd6DWGbz>6@ep}1pu7j0G27UT1-7zK1{jGV4_1d*-9?R-*+Pc)<EaI!~N^{<cCL4OU
znlJP5+|?Yu==#8IxzZuJ;K43Y{dGI?8gv+sgHQAkuw=GOnK|cDf4RZ=Q<YYQ_c5(r
z1AxQMgfH|Log*t?Fx49-wg?~0Uo~5^OB$0&_<I`g_%7SC!SNhyxydoNw9Mr;Lbc3G
zDzgzBW24<x!DAFzxPlp9eY_mgW)I00e6d%+!FPKgygvqP6@nhYR)6g4JFM~I$72S)
zRJsTtXCR{Rj)IKFEdF^E{$C(akT8TwN^YST9n&I18Q!6MhGPJ^aWbTq6e=bTIuGZY
z{Om4bi`7XSX%boFb}Ub#xGYK6s88>&<NnChBpPFA&a{hSYDB&Omc^<S*P(@b#I+x;
zxnRJzuzoE-MFb{;>^_rDp(kQPfTTUp<4$_6LDvy&e{A5*1Mspc{PZX5lfFD2S7lqD
z(F*4|nz-ynZKF}JG=<cyQLEV;Wd<)D4xfoCt`G}=kK(3ocJhki*y0j={GgC5FhV-@
zNr}nl=0XZ@(Y2BbT4pZXxFr4iVXc9VW}{CNAa8igKo!gr!2}ngYm2o$m2C^&V2?ad
z>5-KhDuK)#i_i<gZzxMYb=gK9yyA@YdNJ;G`_^Zf7I4w8kSr5vf=OaR*9Bh*FNbf{
z;iLWn#fH}H)C5_{K{j}Y)MNi4#lZkU11e9gSsvoHnhP9kB#O7`<@1NZ3G~o!V17d$
zJL@3kWZtwP^rJ;V>#5X{_g2HlBmt3H|4RD$(9aykxELTE7qcPB1w{Sd{MA0=xwj|=
znXZhxDBng>6_?`Xh!E8cS`%1(Mhr&MXtMd7Jl+nbJ{)aWC#`t`y6ZLzJQ4iT*}BVH
zkt&Wzc(e)Q@59Ipk}F;kPs;#GxaQUywNgl6eh?bJQUEQ`fK1vy0BE6EVo&7qsgJ!P
z;x~EcSCIH=daVZ%*(;Xa<*4aZq|@e-WH@Eal$}@xbB%OhPE?9de@?O~xhZ7QhsqZ+
zT<vPLG}&^3hlbEV8%mN+6htObqY;I4Ot`He*W7b3tNH&JiEjbTiE-&`*M|LUmLv?U
zk(oC!0vV=fH?3O@v`j?fX8bY^qW&XLQfeu|J?wykig>z?Y`KkGNY-FM$&{gl2}v5p
z&(b|I3hQN4UAdh9IKV=suzBYu4_>u4RI3Cp<nvUiRT%@oq#P|ZV}TkGb=ZQDDZMM|
zs??!&v_|kg;Q}MtZO%Y$ym@!bIK%UIP8j%*ErF-H3lJ2`_lS#TT&`Tuj%oCT7*B**
z>D*WcI=Q3|R~|d|D<aBDAnij14wBbOn@)#+;3plo&RTE9?b{YWU_#TV$Z7YOG*CZv
z*Aeg~EeDd9T`0CCe^y6ug}k`t4!|KJUb1#i8bYH{DNmcNNkMV1Rr)>AMGQY*_QaP0
z7DfAL3r>5jD=dvAhzC)hGj#w|?{D0uN$A$dBQt0^Qsm}%i5pJ@)3mdMhN$&QU!x_B
zU9f9O*f~LJ7p)GOEfkeBb~*m=mje_*ob5#11M=vfl`9R-C-4@~Ib+A;Kd8?{3|HqP
zqE`ZF)y^-iynGjSpH_1K_AtdXus8?O<_^fH7P|Y+cQMFztEdvcS&!@NHoSlBwYL}&
zh5^*RlO;%?5KrmDp#0jENfm_~Q`qdlJ%<F*=~zN>_r&Yg26R5L0g15_*{$!oNYtGr
zB?kD;JLCB0qNQwFvqQ)pVonL4v-$#rvX&AD^T2FsX`zUYGZ|V)k$aS(`V=3s2uH*l
zn0=D->vA>O!hW!dn|R0Ey@Q0BKHr&&1v|)6+6`CDB@quvGEW_I9YL<*?^OEe8oLKC
zBUDw*B3KnnJ$e+kWdTAU76YnV<hxP7=*%6?7k~!1JzSmllZ%63B*c14LCm{YydM~Z
zXmS&decWQFw<q`qWJmxtCM@`T*2~j<Bs)N8u8|E5w*d?RbFmqe-YWvimzqoL4kKd7
zFvHLWd0+=Uk9>5+^m>o`GdWO#?u^RXHw4#N!=w5nA30QN^=bm!wN~Iye(y(BbIZQ-
z43i3Q8G>r6Lf^Mno+sRxwQmZuWMZc%-HHaTPN9BabhcWy{G+g3rA=U1WzP@Sk)@zy
z-s#2f%XqaJgK9Vi^ut2ImrS?CdxLhb6WP3CNgThX)*e+?kYX<u1bjI+b_u#hxwWw4
zu2s2Y4?89{Hkps~c(`}XQ|N%?-4fAk@Ww<a0MzbRWe^qNd$9#^Yb3#FAksvUMi;&F
zz^Bm!RLV{&y%gW9!PE%u+?tzRe~g;)5^V5L@dwU(e8tiTZls0#4S}C}lq6AA-v=)U
z?{%do8eNgT9B`<W-4#_8pW#vYgV8B&f-XbjDgM^)W1Ho#tf7qLBT(X($B^vTssNl{
zRoVHHYeA+c#TyGJd8}5m)bdr)yjB(4Oo0clff7j+1t_<thKD*RQF0%OCoq9G+YMt`
z5+lhK3p7X&F_la7c2Miz&b%dXQsPZT>S5S`FJ{a4<*XFGzwNAh{G4Y$Sq^ydc-<rc
zbQv-@^z6U^-#N1%Ber8~Giv*0vOMs>$p+*~X3Uu)oc$;qsk92gemCSU6&%f0l26b5
zyhCjD7~1IEs%ML{+=i);GKBBib7wh{ODDAq^AL~8{oHBJh?-U>j`&O=+8V`We}E&G
z*{DG<k;N{{95>AFdb){mPRNTHjYgKS`Mjokns)o1NOsXx^qzFKdi#DTe`5k(VM9F-
z#rgkDID7Z9Le%UasW#I|Np&c-U}&9WGHYQx-j>=vJ$+-vxuMr(BUZ$AFRy9kWp>L0
zPT!&RR@;(`rf8Jow~Ji(O4?UrLmpQF9F5=*K(%xVJ6z+z?6T!NEi)R@nV|elz0t1n
zY_YB}8uIww>XOWC#|%k_Mf5UenSK0o0C4B3$ol5^MvO-T(ncaM^#0d1sr}>m^=$o$
zBAR-g6WY;gM`MnF@e%lPi%%#QG~49HiKWeRntuOx_>=CfueZ4w;cm4b#`W^DGxg%L
z{pkGCO(Pek6N0<Km!*?wqye6vqx^u$70IT1X*&Uyh$n2Q$#c*zHp}_Q4}}UM0LSMa
z_as%?1-Kd{HGEyMCl0y+w%sGnNt*Q}7QCJ@W4&o(k^F8laB}!{^nUnNnJ>cr&1YfM
zwO@h8O)Sh@AHSTIk9#};)ERU*#b9=WoCy}e)%?AWvCR^CHE5N}VVxf++`NW-@K3QP
z_2ov>d*G&jXw%VZ?!gq;$Pa?Z11>9BLj5^wAjWoIYt#s*DP-sO2|I7ZCNe)ql3m)A
zJQu=DEpryWf$LI<)Q^y63^WFG-~eV$&u@-u;)v-#e-Dw7@(S^dr)9%Md8ab!6>Thh
znK@?Cssz+CH5!L>F5CnNA`7b;EL1*hFA6b`;%A9ro~TW%lg0P}tM3&44`Xi?6<5@4
z>lRLMf;&M1sQ|&<Ed;m1r3h{zxVyV2xO?FmoDf`tTd?5nZg=J1=iI&T%RT3X$7-t;
zwdR;(^so2f6vZ>!1>S9xnRra1_GefXXtG3JZ3PvVCh*C5{F9mJWfPSDY(#EXOpdRH
zk$lDDSobeQgExbXE$gZvBR4I-YWwKvN|ke@`+{TngJ*|1tAy;71P=D~=$y5LTc@7U
z>HL-?(;l1PlIl-#7tU=`J8Qu5DL^msZxGxEo8uwQ2}xt@fDrOPcH+OZoWHKVdscW1
z{me=$HYS*A3dvnb?*bdo@UcHiy>ktOk&}c3?>vwKU9l!#!YQIg@*t^F^|WLpxtLq2
zf#cuYmCTslMAi69`%7b>kQ3m;=a;-i!c$4$RoO)jRQT;%tt|#R_2Yq}c4<*)>fsqt
znT?YUB16hRCG^8@e7+W{!y{5(=oz`>Wm!M=<_=jD27u$V-gtU}Q~6kWw;G>PQcdAK
zhkbs6uw>5U?e})_K1mXjS<|u*({e#)v&%7%JqMvVPv5hrzFZqH7fK%^std$=SBH&6
zKK(&(wH!`mpefVp<2@|pFAxhTlhd3pG7;cefVu4?rx_SAHC9_9qZ5**j$6Dm`$3>9
zq_{ouNX9J$7!iSMX#s49N1?t0VV3<R<6+jk*LE#8mlW-$A#5YMG#A0vnuF<R=4S=N
z{vRx_o&}uz;H)VpXkUF@@vIc#jtvc1_^Z|*QJOk)D8#%(A(I~SCm&UhaQuNTYoZjj
z*xab^y|0;u?$2^9yM=Ut4c#89MepH_603N+OSKM3jIjtwYwUARa9x4eI+Qqqii6!$
zi6R|&#uWoct?GgJdN(sf$a4vAM$29yUEX8%qYcxH*&bv$4C}s^nB}Lj5O{TGEDV;D
zsu5YWoAuj#R;k!CQ`4Wl(#_PhDE9hX{$&H}s3T{&_#(ZaX)k=GB!<V1B%?n><%N_U
zZ12VpjnDSF-RmxaMZZM`1^bzvxGW9{8e~46Jq1`qZZr2WJTuIymNB{_NV&kVnW!Vz
zcWGz@V0q{LX?hS<SKQXXPf(W?=tOeI_3cNR<7__C0lD^0Wh@VWAL@$KQ5IT`R%bL1
z19dYOjwph6`_2vAZBEWn1N=uvGiQ^{lI-A3yd?vd?^9zJg2#lNRoz`>%06=WT=_$%
zqmMWO>i%xU^0IqVh3rGyPJh0`Yw%rs;WE|pwWmC4wK|z=RNR;IhY2%O53R0ds}?IV
ztN(5XY{Gca@g+<OcnpdKF%$y(3x8Dl6X@ki!~&7?#{Pxf2BQ&N-p_zQ)EoWQ$Y~6U
z8992*4ts<D1u1X^PW8u9skOPCU2<~8(aRC?`#!gYb?Zc-UCPJPAORe;T(#TX{e4;Q
zWi?t?nR@B#3d2qVCC5;fKPsW6<7;Q(k%_b)vG~33>!D^IW1X6++;%HWeWao;Ah_OW
zGEKS$i-`bW4nbcRFL3$peQQt7W)w-ojcC-JR3u?I9q7928J|`f<0m)$MQiP9wGo1m
zym*m(syJZnsnc#V`W1rM$A#(_A}qY<W!fJ@ae27F0mqv-j(i~db#?6-{s->A%DX>V
z7}-I{{!gSCl248UZWISM<zZ{l0$1-2Fvg$$-zx=hkbwHe6Q%?6r0=E6v7yI$v8xR0
zl5p^>K7l9gjP7kEpDD3t$p*=7d*oqb5akZ0Dgk_XqVzn;2vJ{@wrPrT>QU0mzcGBx
zLpIUR4fk(e(Z`Y{kFEGfeeHI5*z@F6m{mlre)e-leJAr_*s;5(CjU2=nMt?TGuQa5
zLa%?kim;vAGa75033b0fhf^1PC>>kAG`@cAtU#qMlG*!@FIDGyx~A*3W(876xijfp
z)o2HDPzeMJ%&tP9;Vl@lIo3VTcx|(x6{y`i#%~keQZ$(~mpOFd5sTlP<?kHVJAxzZ
zbfEwY6_aK9(hx3@`8IDdv>V{1et=?!E9n!%S-D?Kp#)<}`vV?XVfEERzdkAjJK~m4
z2{`bt%j+uWxDt&>1GIxVckwo%RM-A=t@j7qxpE@~@R{+ONT+;+k&6Q)xSU1KDkUkj
zZLXnh2Xf+qMVCE>p{L2xWGGDa{X)wHwobiGMVJn^U4rn9h}$iq!kx2Gn49+O$s*>y
zfaF65h9AD4>exWqYSX0MLBmPwg;~@(S5V0qKDruZwYBYhZDgjP+wa47v^KLd4L7Vm
z9g-tS+FR->yCu3<VoxriaB^#V8Drh~RA!m~>G}2ltLMl5zw7x&AC9S4>(YpP4*rf2
z?+vkoC6en#AY<^b-+f6ciMu`ViFwVy3!+?Wl4kBo>}tEx5qZ4aP6V$7`2qE5ahOpu
z2dGzt^u_eD*;3iw;p8M0mzx8hr984p9&7FIWiy=Igf+Ua7`m%5<rzWkqKoV@`GN>&
z>TnjQUGHCkiH9%*no}%4qG8;?G%RSa;7~z+va-MUj}X_Wozs#IRjldA28HsZofjib
zK(F_wt7y7AipO3-5wO6I>Ipu_IWr8eDQq&3MzlCSUL7uF`QxodE>`$M0F@wz?h~GN
zy;l^R3c`I9u0046oyqCfKGoMakk2mck7@B|Q|vxKggt-&-BwIG_C!g$&RQCWCV<Dt
z)_A-UfzxHvNrgfbf)L_Vcj|x=H%D!TBk*%XKkgkzsM?~_$`=xpMn6d2n-ypVNOGe*
zij+GT;N|IRbvbT%bwks}fu6r&oY5;C6Dyr(pD6(Z)vmQ_3AQKjV{x{wpNOnn=3J%E
z%n?l4&k~-&aP!IJ2~jP;c=jvRw4wDor|>z>M|d*f2EC1Z*77?i8nGp^$Y<|>Q|Ges
z5;58ZAHaDU!rm@lK96ei`fE=FoX{pGf7!V1ebYvjNBQw4Ob80mx-W)@MI<vyE_*yP
zDajq4k=rQ4DkwwEyQ28=k$B~$;Uxi|7|PQlQB{U?R#qA=rPFG;kvTW&tX5@tHk%tE
z0+Z)v+;#e7#YZx*Ms0P;BB>Tv7zr9&nW~g2a-EsmFXvK-6hb`w2%kg7_Jj)aiOoC&
zI<pZvz6)4<@;tJmRyLF8rxuEAwmJMEeP#B2w?y>IuPUvUU5PSzJ;$ph)}K1Afr+pF
zyc=SlLfMFsL~eyxSGEJd%GZg9Uzq@s5wY$}Rw0~$5n^3bY9WpPIfG2x%I66JiV@C0
ze<Fh#n#gJ7ku^HZM2$u?mYc^>2CLe&+H&zjIrDHiW|AHnQ?9@+4f2_l1_;hPdrTsT
zjrc3q2XZegM)VIO72hpx>KVwiN3GUqVHj}bY27v=r<<^dp>70YeBwhH1PZQf6<$9v
zrPn=v?7x%q!05D;Nrsbx2vV-EF#;d6Q~J=Q6`sXJ8~c!eQxa<@TYGW<*;yOm9gewD
zhG}`r!=sS1Irkg)<@IH9gRw%t@WWsIz8T1Hxq88HANRNrR=XsT!Z&bJ@8{%{Qq_72
zmWxyGY?P?)R^3NCZ$`9w9W$_PQV8EmOM+8o68WE!(pFfht!V?x8Yx<plonuj0*WYd
zb~M}_a>NW^vRdyvGMg~uCvn6d5$>r5HTJq4BWEcj?_Zh9;znL)drGSL-Vi;ZRHH#*
z>aX&rqOKPt`8>&7;b6Z*?7H5Qw(XgPZ95cRLRpOjhc+k@F=qo#R1Tsl1I*Mz>Q}Z@
zf4hz#BCB8?mix!g+O{0r(i-Ns)Nvs*v$Ffsj}y2*ZD*!DEHdW<NmJbyoj#e0nS!6b
zSLqP~|35<!_w%4ER)m2%bES7{+X`la9?UC5`5YH=NhKgnZ`ye=Fr-YL%X;Q>?D)G~
zp*l(<y|dlg1t-KY9NHGgi@3(&%E@JODoOpR{i4Di45whwZ&WC)2}_`!5$F5tUxR<8
zat9lxA~*>$=rQr6#D7au(1s0V{gF_>!u<lFt62%f2^YgPB&**4gLEB2wHde8-|Ze`
z^sS;p0Plq!;L6%G{VU3Tjbrw{<4s)6Jb{kwV!8v@3ACf$7z$kw-C+%<e<m^$7Y?f&
z;J8%|+Im~=toP%qKfC#C2H*VWF^`MwXi(+=x9icORBt5F_fSsHYa6Qt)pU`C&+V!t
z-pZ$3B2{@GV=L!Wstkm58f{W}8_jwWQn_sxB?;bZ;D-XrMgal})&N}%HjG92lhy(2
z6`!&mdUO1}eBxWoySuw^i;*pQ-I;I9x+OLXwSRBW!ncOMGw7KE%0zKFx+tw5-W$M)
zHmRMjuEBfB%&A%=Px6y7w3gwniQimt_zFe4c&H`hqVG;FKI+RXNH&$_2BfP|sw#z|
z>F(~X0@w>sG4#-hSnwA>KlW!U(tGboU;impTF5^A<9l>rexW~h)|$apJ%sw(Cu>LX
zbx$I%qDh(#PiC(!cv~uELuA8Upl31FAMI3SXWzjFJ_!jYHfiEe3w}fz#~PSHI-dWU
zGx!Z)LX!F*h{E3+U66MHC<k$t@)c>ix<E82>Wx0qU+CC$zI;TEt5Zci*M)<HKcr-I
z<-rl(;Qemz1sJ0KjsB`#e>8u;-L3D(^macT;oQ*=5dq!>QtAjT4#Hq5yZtuomaN{x
zIZ83;hX&v4ZZ6-M`2mQzp!8kreP@n}Zo@&O^>kf%5rf}WwHXpz33^nkz?ev`;mtCE
zz4uUYj^4Wl_p+AbnGlMju2<psz=VX?bMDn1R2xW8k!S-$6|Fl?Bf=b<d<Hi6_0UZf
zS0_OxsIZ*~V@Ne+u=BftT0#<HfHAZyxf93h@O+8a`WQ~a5%P?Mo91DXs<L4|xoSQZ
z={|pp>rFz3hmj{i`9jt-|7NH&DUM>O_cH8F<ia1r7KdnLthp7wx6zcM2Cp&=-`8nd
zDvP5dySJNEYc8ltmA>(%(lkBXTyXk3O>)nzYvw{cucM?>`<cSmcXinD(Sp;}L&hBI
zYu9A86j6NV$DP?rTNm3eIhs(~YWF2domz)>8Hm3gcWo<u3l&0FB|8oicHmlzmj9Xw
z0$AAwdZL*0lObB(;ehfa`h#HyA=7zy`ybcn<;72R?ElmP;nx2Un_!;*t3d}a4mTZ^
zX)=yH8DMZ0gpWf5fd`VUl~C`h^nAq=&9ZUq$NXS=a2iK{>I1)x>4Nu>tHH8KjQAox
zf=3b`K8R<X3rTdCkL^W4&K8U<J<J;UJ&)nry$IT%RHS`n1S6YuVI<zv6s`3+lUqLc
zMw&d|S@a6WjvgXEzf+^f6NRI#TJ=n!H$P;Irbm%ygi5LaITH5q2LUpyVqK%6Rx|aj
zVX(Ps(sk^~7H!uSciK3RV8X~d*tZu&^zBOgy~^5Kz>)xvlnLhWwir3Ju{IX2fg<>~
z`ezJ&F$HUS4CBO=fidb(0xgR^MN-DP{fFoFj}vG49e;m}`zfkdf0Y@xIc<!1mcd!v
zB>BadsbtlT^)V;Dx-mB(y-$%`Cbh0;Zs{8wLEB7;r9v5`2|ygkOKhvO1R^or>aoAn
z>TBMVvAmV15GP@`qWWPfgncYh&>x#UC=n^tR#x~aeTZg^VxuQdoD5}|AFJSEhcob+
z4G%^6TRF*PhAz)h(L21Ihz<6w2msU=z2f}nk4+`4T=nJGWy?=3L{K#BJV9vSgTW6S
z^MpDUY-JUQ8DHHj)p;~Ad+I_NRwNBVs7rp^ouf8Uu|nrb&Yl`!m|L}_|J^59Hw0Ms
zqzHi)m*X*UH%GS)fBl|<=AAaYihnK*4RAX#i{99gdFzuUI&E#3>0hltf@94*SG7#H
zi>i7X`Zx_UM8R!D*05bDB-st`$%#f&Y%mLXNazClcIx62=fK%@e8^BER)sxbDa<2k
zkXVnB1R5l%NBc!vI|$EyGn(IVGklor0w-@tTgh|P4-QgCb!-KSy#nrFr&)T2Mjy53
zIlWOgqMkIfaHHy|32Hsj#(Pnf794enqp1aVi<1IK(2Qn4$kI=s^{%Nic(d&INzY6X
z{gwx5@;rsTLK0~j=&t}1+1C;vlpg<D%b^@*OT@+?f0c=5%&-RB@9{CvrG>8stkmTq
z2s{p~e!sL;;IL;+*M&S^ad?TT)4nl3$m;l>>JdQP0A)m?Wf!<j#hGbA2ga@6O}gUo
zQ+^?zb2X2QC@~OEzloj)^^ifBx%{`7n9hyIB}UkLm|7oiFtfk@b(^qIPm~|wCrF-s
zbPgpvX_gvK9ek%6H}RVR8S3Buj+RWr8J6}fp?b%;)3a(1F;)#&0IfP`@H6{tHQ)SX
z?-jzC0mmsAE$Xae!lM)p7Piv%5IV`8uH8<Rs1jd(Hh6RINZNRa*6vZvh9edEI=+qg
zcWr^EVrcP>B9wqMu*n$&QJ>{mc;$DG#zCf>*=B&hN}CWhdsFu2djpD{P~vN4l05Zq
z4Os7qQ_dwXkVPuZtj@17mYg-x>PdR)%>Gs`(NOe-H3y0saHDI{w|P9xS~iyTD^X6_
zBWq*`x(BT8P;t<1)4Ft>#bvSQpkc6_hCQ9GOPDQtv20I5!;r0$KaQjX-DzAO@|Ad8
zk*Zf%5m4%mB=vc-rTrRW`F!inx|G1d9+^7TnC%I!l{FR<Y_%Gl#2_@H7Kp|)c>~V*
zBrFH{nl*&Vh;|Cx2H1gS)M88hue;5M*hOqw1Vc~L%ukNVHT%@#sYY=G^s**k9mXaO
zh56A7;64yTTw>#2K%Sh4q3NPDA03`erUhwsFui}eS?wjUS?$OKk~B>1xuIe3YDr0K
z#(k*OL4tk4<<4s)xbG6Ky<!O76LM_me-7D#e&x#;oi5i-1XjBg^LXB#8V!B_knQ8O
zKm9KACmJ<d2Kwwn0q7Kt8ovvoS`Nnqz1#aOmOg%UwDcWxu8I@|*yso*^UKBF$p9gv
z{~0WNx##kDd2T<}dh7fA2tN|kQ=!|W+U&5^lfvio_~TY6q4N_|9Dz0s-*p$y87_)R
zyQX|8g~yJP%X(Ix(^81VROIjo?rqPH&@}_?W>sAn0j>sF)WP#p1D7di07RFV061V;
zd|x_1zNI5h?E1?nh=|HVNk1JKxGL0&6*-N%5xHcsTjjDng4fA!7yr4!Gq^uA-msWs
zmb0f_!1p*lH*)(b4UN53J!>1%nReyj9a8>D5ANzO@tNjIfD`T~-bE-KD3^^!w@|F;
z=4Uv0dBE)E6Srwsd+t-z`G&%0881Hwikx|bI1&feHj+nQt~-ZCiXGq>!D-}TdVa3p
z(e#H%=a9^}!*2&A@R2^DR;(y%AZc8E&Qbeffc;gfi!r7F6?GQ5Zx;0#%TzxW?TZ?P
zX!%Y9es!UQN0Ne~d%LkVZ{@q*7!MsJzI~O23G->=evulkei24%%yRJzA^VVC!SXJ!
z=Mh=q0)hsn5ek!U9W7xP8kn=Je}>nUtm5Q(gL+i^hqx2MT0Sy{7WmSe5*@{U?3#`G
z6bo<x2JdWtkN{<5RQxjNxRcYEidlY;`X;`*Q=~HkMx~zjc)sp%7=7zvgXe#LZJ|Um
zh2l&0=V9kf8kcXgj4rz-f|quaN^$r#r9o4ll6sBa>CL+Xul*Xt0{UxNQ9NnO6CSG;
zfnV8fqsCiyWR@GV%Xy1N2rVk4b{np_XKLHOYZ8l*axlBN2XgZnkao*uetIPdSxe*Y
z#6(-Z9Ah!3Ij4}`+F5ojcdEQFA0cK(zbZ$Y4VD^sG^$Y!b^rfx0RL^8_h+@FRx-sb
zF96nl$Y=%>(g_fVYT)>lnxuYmR7A~5E>}YOoSV^bsAs)LGR&_JZ1Zd7YxjNe?|9-S
z(?4rv!RThcEy$NoovdTq=DEDtt8=<PbT=aZ#-d<V!{~LpYp)_DkBtpq0{+s*s~(VA
z=EJ0>SF!j-3rWLy_fN)9(g!o1&I(Ba)|nQ4+WS%m%U|UnXLazBOaZ;(U#Sa1T^6km
z8BGZqEK?X3_gIJWNN8KRm<LT$0PiS80xAI&1Tdx41!z>vQ+L0g8_m<I`8+9V7QjCg
zrA*_!XL2r^BpQ^tP~t~oejb=v{PE=4CWT01yb>Ok)>OveNAK}jIp@pOY(V&1e%~l9
zfFpRbgjHLq)8Q}nc`+2-IxdA4XtI||G-^trJ#e~{lQSF`m>6sZ<C*PrV_@6^KFivk
z%@})}EMQQc^V*5eVzI!z-hG3`-J+(SOQ+60ODaR4FI*~^8_UJ!A@FTXCcUb?$a+UY
zUO=U^611<@X3YE2k8Nc0tj_XbRzwm4jfB5dB8?in*Iz*SV-ond>^m_#+Ugua-yk@@
zX*CBM$-)d2i7Vqrbi*3wwQhDg1796*$x6<Z=*OpVR^^+&vin~%fp6?nT5Y%XS3bj_
z`87Jxx_?lp5Qmp`<UJF);3Lsc=8bMV(zv)F-W%wXT=tt=<D9U~(PCd=AUdj|*NC6W
z4(_?fAFaIB3<*Eg9f8$+3OTdKsN=-(RU?1uHN8LN`<P*I=nYk*xr#rPIQ*FjmHxs%
zk-^sc6?EpikD)+gM^+7ck`{4jmkgq+NGB0waIdr=1f$H4Hkn?UD<^<xy>KMNgxUXa
zt4Sj6`>K-xhN98$NPJ)%P|&2~6-?Rj$XMIWSV)P$-K9edCs&Jg(2llwA0AywibSIJ
zDW8&67BWJaO-MeCVbV7zPaD+&y;NriOGcJ92y3E;Qh5wer-ow0x!>$j#VdI5_W7IG
zifM8EtrhkykW1|!F-Q+gY1d)LLvO<ucu(d{wYP)N$I2S|NkvT4dm-Opj5>CReR;)a
zIJKYi#t#`D32G@`QP1x;YQV=es^0}}P}DUd7Blh+Ay5y#M|Tw&7`J%c1!iR{JdIE^
zPBSf<pP-#M_x7(pj1~3hUuz4q5k&s_%IB^ocFdrj?7OTY5__MyOBo}6_>{^--S?Bd
zV>RS}8nKl@*!b>zVQ~O1x@~SbepCgW&FxIJmcu`kpathN0hy^oa(tea>mK3sn|V27
zeO~d#DwZqYZ~iDO^^d2t6?u>}f0y9hPq~3u?lilhi8RWKP_7ycUV7}J?BuXMp#oQ<
z_1Pc)n6-L|?iQN6pCUj$T_-{LUGUR7ONCA7m>vOkh+Z#?Q6D+fw~Jyqp0&Jr@X*AH
z<vSz~0jYWal2!x2H+-9xo0DZcpzT+XI2Dd^HEc`oGx3AO(}*a)zy+po@sn_vvZ;|4
z%SpJXbXnm|eS#+M+f!1vDAFgqq6Yg=Q77NI7Qnq^iDKOg726BIOKFj2vj{k3&t^>f
zxazPT7?PO1s7V1GzGgJ;j2Alw!f?`=1nK6G)8ULg-9v6sDAysldOsGSznAn=xfbQ6
zch;eiZI<?+@NcSz2Ck%lyH3+My-U_P%PRPfC+b_WFI|)~zBmxQv(`7)!iUqpRQODs
z7`pU151|*${ty5NXaF(7Ng{#Ji1WUEFk}HST7CC@y3))fk?m{Ek0IeO`#mo5!c>O%
zqs*|=CrQ}b0}TTMfC%4CYz?Qu)!JPAX?ElvCir{$r_``hxI!zp;=p7)D|4~YRt`GJ
z=eUglhl5NAerJIostf^PA>GP00(dzWToSyD6F>n5374q?0AnsK*BC|1*N+rM!VR$V
z^DQ}p&M0~;kYKlSj~%wCJJe|DhdnK%L|Lpr&g^}ZfZv1qE10m#T)pK~iGHg~o=)|D
z61wc*jme>OsP{V&f*zMLf6zgaVqHT>E-bWgIHXX<O@%B$zPpD9-SWhtRg;fV5Nt|8
z98uO?Y<NN*l5a<iUzT<LxZXZB5xVY9wTzweKmVuv>#>7-PJFIcwx)sW2A(x2c4GeL
z;{)z^>CflKh)hM%?c+{Z6`WR`Djz~Q|KLTEQ96R8zPnogXP1&q8uD4bX8z*LrTPA^
z%Qt#!?@7rnpV7^Vvr`xLSOjJ)T1S*Fe^UN1M;PBBLatB>LIResJdrSo<5_D9H|Zg1
zEVNWY$-c)ZP7CJFkl`1>!_3$v+`Fkm9CGCuxP7o!BKYG74rHKWjSTzuQ->kK-P&Op
zD0vxZ;6!(NwIsA04jrO8WQ~PZMGKfmCE^HL#i*~n4V@8^2H!ryV%y7O;7Yv^@Z*g7
zXqrBY9{L7{Qu@G=sG>mM^JUT#>0{8A91-4#a?PD*xe#E7Wxg_fTL`SEny|)_=on9r
zT&yoqiVq|wo_~KLOA3;X{9aLb)cP_V*&DU@MytG<>USLiz0x;HC5bhF@0$kZ`M7g8
z-(8Y|J9}ZZUl&OK(SBj@=!Emt<bwd1SfW1%N27c6FTLt6AtoXS{B$!aU^(6q==9>>
zXy$kFqauAapL~IxWcKFp4&7?GCRWCJrG${+gN|~L`G~f-@3V8#pJmOd=jBuOl=vd#
zXG3dhL7)8RNHi{>m#-|l`}J9Z&8+@^=HvX2%Yb+;oF^421R1Q&)dhi;1eA1v$zhhf
zAwTf6xJ;+%`0Y38JV(dGHQ~xVZe_fFC?+nZs}{<$U~~dG5we~yf}+5=;#Wo&jyK`R
z-N$Iy0H0iy=j}yA;q*Dbwp(WQ4MRlmz-M$s92(k>B{{*)={pBmI`KER6P=~LClh%o
zCdPYnj&zy4K56CtGR5BGYU7m>QU-q2U4D>!RYy3~S|n1OR9l;ApM?Q&P#}OCC}<N8
zsAiEkL92@+(8~8`s%Yza5k22a3wz0fEMDcoQ%VNSY_Itnb2{a0D?m*5#koDZ%BmaB
zBH9DyO8)3wN}D3o?Psm$3iSE6`a=@?$8&9Uufv{6^%H^o0X|ZOkfFK=L|XMxFtcPi
z|MkhLr%d#LW!5?C7!gbQ=eb+83YUey4fQ7Lb~I?F3;-^O`lvF@OBRCr-p|GNScpzk
zf;dza{2wo=6*52ghiZ|)BCK3)fGi7mitBL_=u8kBhvkmT5$)>bLjHh&^FZuOWa_7{
zd>m*1VnC4P?sm=h9?YwZq@f*HWa52uES&T9N+3ewKoEeWoUiT78r|>3S^0bn>531(
zr2I3zXnBtjU*r`qhadq9+xva?ZW@66Cg5vp8SMgtN~mYu58+^4lGBlJn6n81n0vl5
zR39Hn*f!c8Zn0-FD@d%~MiK?T<@g2EFy}zx>b2(kV)CqMU<9w?+;H+*dAaQsGYFo`
zks(LN{k0C~sEgr9$$8T3%ae@xNX<abKUBjzo14(t_;+-?jcLvhIX7LP`aQQW*Q3Ej
zrESt2|1qDZ@t4<|(Ij2pwwT%3ySB*CC0I1Y-h8YACU;9;_7oO43MM#65Y>&rx|A)L
z5#c4T1Q7PRAaa2=2W`BoNoV=-N_iIQ?|B5w!f*%q<w{~CK(N<R#r6sui685!p#*`j
z6<s)(qy&af#Gt#wT~BU?rE#K?Dz@wh<-!IVF<Ny&?1+tXI?3;6-ixqrN9+8;UbSu~
z?&BLgY;{0%6cnP3tfAj_m2m&z-op=4#{QGZHLePqc$97`UEa=+=^eo+&PPg}YFyxu
zQ-xCpUu5i$E~jNG*o{Q{hmOe3TAe{u^7pS+lHZb(Z8+FIdcm>opT_^HcR3<myy-Xa
z=#?L1Rgdk;0b7D%Zq$gaI-xo6Agq+uH%~`PO^A)DN$=EDkht5vtajvsG;+ziAd_KB
zC98lor(Sh38TNG|_u*1N1n&(k%smks0p|_)0Qv^m)5Wa180~kaDg(1WoDu<n*47BI
z%J3qZuWeV^@<Yt2^Ft_*_OIaXU{*6@Tf89xsOPCS@9tQTlxH^g&@+XxQ&qlw?_Y0z
z`2#q_h5=5k#N?B)grwhxGK~t^L<S|oV$7m!cGICCWq*Nv<y5C~G7t<aiyoR6;P-?g
zN(|{zMC@a{oRC4rrYz^U+8j&_1wm^Gt55M6mHoafqxp<0Uto}NM}3W^Zuhv#TmKab
z8>BhJ(*Kc<rIx)|7~jbOS_1TS(pt!y;t|bqEw;sW&n6A6g%GLi+vrQc>K|o!`-B*%
z6GhB+xj56ZbyAjP!9YE$4u(wjKLXBxQV2|gTMope{m&RE{N)etKQTOu$obPZ9#4S8
z!5MM69Yyg&zcFcX+Cx;f2hupF0dXQeBqAQGsHrC$@8D>_&tr^T@i?=2)pX@_<-h0P
zXyp!wpZSJCbbd!ltCPfEY@(}vgMhe9lo@T{uyJr!#OlKFlc<#WR=^hY3!7jUs97#k
zd;Od*Ri1g_zu{qv>~Sz+gcdzqKzP|d(?L&xQNPwAAZ*Xgs)mP6UqvMx7UXjY98@!a
zjoHcBH$PFR8EOut@bY8A{#FoW4=dU?BJ%YDX&;$iTc!joj?fPKpnMuqz*$gN1iRCF
z6$(^IJEk&k;`%e>)nZb$^!BS9(~;@M5RxTo@KU{wrp2#y(|WAx$wka1#HFOgCWk^F
z6G9l+DoN@#?L}dq!=hYDuLxtWMEh4-5|ib?s!?QAF7K(3qrY@alM}z6RafIog9Q3e
z#zcRfM%!xr@$|<GqH`y!xv0rvIR(wi`>A7Z---47;>$<IYyorbr+G%d`+K&yk&}A`
zm%o3-INoAl6109-S)R2Il$Otn{NB)DTma}SiLyi=#38<Dd<^3JTCH6xNZXZn9R0hB
zIQ?vqGxlaR09^Mw;oU!BJE$1B`+x^5`0z--&ka<s`Y-<{<nDLd3D&vL1GVHQ0I)=~
zCIqK0kZRFyY^~syfIrR#ak_jpN?l%mCjAf)b0`wfzFL$Ixb`L_kTq(gh{;@@<W3)x
zQ+}#_dhM=KzdLbfd?VyBgiLmNnapJQ8dn-&ifG(vKE^o&uiwjABgFv&-)c?;;Yn-9
z(Miy>o7}8?qU${vmZZW*;8y+h4qrBfHRVbSDbY{Cyl1|HAE#8ZlxBMC`>aPY7zFQK
zrB#aGVEG&=^Fg}>)%ln*L-T_PLk>Kw3vnZrdj7pz5GwAw4s*TpQ&ett*0Leo>U|&}
zV7jCdIRb8DW^G+4sti!LOPx+QWr8ZIqW|f?OTha%+l7{%i7ETFpZ6<IwQT!a1>Nb~
z{RXg3Mqhqt?A~Caxd(aF4S&-CLkvVYVq`7Gp60-zo=V6I{8Y1(Gr(=*WH*%h{(Z%R
zE&6Cyvt-YVoqFazcgcPUX?#cY$@rjGw)j_rA4+QOWMr^Nd82tyMw87MsZP_|c{iJp
z9=IfWYh=~_?{x~Bqu&#eu?{NDv6X-adnguOwPDi;M$($8Ruu5KU8|`?H;31CVa8if
zheCq0Whcie(t;SD0h2RJRy$ym5ylNMeQOK}8{VEp)x_{$p80yv(Yo8CJ<2FuapBnZ
zzy0;%wzI6{lu?jIj3o7qx0-&CUEU!ULAUWZ5|lk4cd)2Y<ZYo0292r|*P3BBlMZw~
z{_x%8tzkgR>;7<gKw!*I?x*}+wvombhKo1mhJ5#EigXUAHAriP_>-4zq2YHd@V0}f
z;p0$gg!Cd27<kGi<YH?F-&MIXsbcC4nMN|C1Z9*S|6QJ&HebdRvet?+27F%uZ0ds}
zL#<4P4#f2IVI<lo#R3Q-*MfB0%-QpCEby^aCL=UlMV4=6aRk5>e|*!w9b*<~+6l8)
z)2Gy+tqHWb{xo)GGHZ+&H)z;!c=_BLCT}lD6R*UMJ+y)MUG;60A`fL-ZanO1ckxKm
zriZe}tC!*Qcv&PV0J8~H4juz_)$thoUZdCC-CBwbSOn`Ng>4crpfT@dO|9>Rpcp4t
zNFxw4aocNB--&oI)PhdAn^ZjPqjA>JEJBJS)xEco+DqLJ352l@@Yo$!DHh$IOHrGi
z-_-P`;KYAfDapDko{^IaH`WdC&#*iu;LtdG$49S}l8fdSSU2+Mu-4_n?|O_88-5cI
zk5;bEO4`{U1%aa6^{k<gZ+!Uj=ZAWk6Uk4FWM)rpxax$%H`k<niBrEm^?|3S5>gSV
zkl0?a*ra6v=<yh63>!c7ByfwFL#MiG@C@Z`v((5X<X{fn%Z}AA>Y{S3ZT9aFaSe<0
z!L2od2Ji{Q;alUjt6`(Fe5GfA06diDJe2CndgWC<46{7O@_hv`KX4ezfNu-W?=`C+
z!3P69P>Jk!Gih_PEbRuXWZoGd6;myNt`E8ExC9|e{8qvclm*`fPaOjUIitrRcacj+
ziJ$Yg`8??)Nl^&69Om4fZ5%keu_AcSmTOCCu%alWvP%)x&962C8S)TN<sA?e{V$hB
zy;6@aHx@9xqj~3a?a#nUJ+Af%O}G62S2)}2LWOh<P#WlU&xsb0`-r4FbANSE`Z_Ry
znwW=}3WqhD*`Q4;sDdYVhM~)cSONzWD;-5_q;mD4^O0sg6K9VJNT#R(Ah+3v2!82k
zQd5<xD}O=Pp1|DEDGs-2;?9d7hSY#$Vu2Us0(}U`5cW>1HLZIbb$h&J<FZ@H0LIk}
z=bYBFQQIREv;C4mwXZ6Klfm6Ww+;Us^L+g$4&dsc*%lD;B&Ev$tL+IzBwMiSuauGd
z$h$!PVl2$+{jFA|X^X7B4%DK3ZA{MJ{&ij8d;kyQH=VE-K(WM=&IjzGx+DIw{}7Ex
z;+Mvk4<Oj7VrR<gUUU!Yf2v_LPz}|U$!4R0yil`gXCW+WA*~C4=+PV3GA+)})_%NS
zR9SH$&{@ZK`)=JjgYUC`eK68+lL45K61_%Xr1DUO0IN1@`l+eAgpJvS&0kBuZdo7W
z>W}A}O#p%&JTEp#i$o9(eXK~E;W&IfB<Oyx$1B#1`!$`gO6xsfKWQgrJ0)rgfDtm?
zDO5vpkFjji;#`MJ0xYeEW7;p*5vs6jl0K+K?a!6jOw5JGQmWku)9x~JSm>a4X(U)$
zPp@Squ}i5QFcJ2{X20Y)levcdpv=^rYFgmXEoi*}DPkJ7`$)K+2;~?vcw6=#Kjq!$
z1z)Jaib$dQjVKHpqf6KLJ6dIKMlNNV5^pEg;uH6}3t?}oW#__3{)L%Rw{hZRb*ik-
z?0itE`j?&K{15Z`|83!b(V6<zfYuz~1RjA<r28^>)S2FJb!W%_Kr0ugfL3^19U^)5
zd`39$SK2i+x-E1c?F;>^H13wfVoMr9#6$VB<nL4H&1H&q`DfPoGU;~GOXJkP()u-I
zt^%i&Tz1pin}b74^7#yxP3ctOb>>WF8=RwZpIa42gIr;Sk+V3@)c;FV46mM$Mk;#j
zaLzrZklTic;dvuF<rxLOji94#%>DV)Kd~OjFwe`v&1DUV?TeliOmN;?iI7ct7Sq_9
zHaMC~fK1(Oc<U7pm8PoW#H#qNp22%3pDRelPg|-^)@#$w{3Tp}I?VO#iTgxTX_QE+
z-fBP~v`kqIF1Ia-(gZarm}t<N_fl+hEq9gChAK|x_@tQ&T7S)&a9@{@=$*urOaMl@
z7X9HWt<v`3K;6AssZ!&)Z-h1qj)aOi1%t0i2pYnE2?cmc4Iv^!Ob3z_DO>6RHHMyS
z=8?ATssHouVxd%C7s8|Y>(GJ89DB?%wNA9swNG?@(Sz|l8=h={y;~^#K5G7lw>|1M
zuSvaYEVaIA8%(vGyum`BYQpH)5YSlvBdb>3Ms~Oy+|`{*Gh*4;(A281f!yN&Q1O4;
zv39Yb$(Mg@H|jGZxJh79Gn)e?Jc9GMHY6drp#WC3%~UOmgsy%+o463K@g3gse`f)-
zMG+9=zZa9?CD-92Fa@;E0$yWL0zxQ6`NF2;Jlty`|7zX(18NrV8Cnth;W~Y`m)?@-
zSXMV$vFwAvVpF&*DAd!c$U0&^#<4BK3w11r1|c8qI;AvEIvWOPU%S^`9U7Y@PIfu4
z-Uc*n1dK@ICm$qET5fT{|3G|A3Z41J5o>u2R}l^76Dsxbd6<)Ie1C)Tly$JiwnyK5
z*Zm$*sW0wR!_>bh98;I{2VJEVmG6)_L=b%HK5M$Bv)L6|1z;=N`hr05aYxOlOT}Y!
z1Irk54NnPq8pAfpf08anEIoF)m>vV*uXdTGUXdaQHso5^*n9(41rDa#@Ap0N;1BHC
z%@2UV{U0MPG2QJc2rg=JAqGBkMu8c)op%$j%)~r<ql`;Xy2^Pla)!RW#hQ7SmgG<z
zDG~ZXB=-zfHKB`a2q%KtSFVmRk~Xn2*)_ZCrEXmBPoSpSxS7UQr(%#igSj_3#Vh(5
zDj6tgl>ZT%+oPWTRCUE;5CUI^D|uyg1empqt2fYW6(b&OAuxH5#IlK84(Lym55lN#
zd3kSShDMB7BOEnOli={k$NHBzz<?8{Zy}HH&Y;tsLDYjV9vQ`r$nE;F^eZ=zlkDhm
zev6w4NUP6gvk`vjJi%v#ZEPZ5mol3Ou&82lcsOZBt!kXY@i>1V+pd7u{x7PiWWB`%
zhE7dXM3-$}*zs*MwVVPVlnW}^V`#9GOGIH<Xj1rg`OSpVwCk3daJqz=m85VKqFga&
ztM<UiH2cDI#ti<I*(c{syN(z;MxFW+^#Z@6D<sdIf+BB4DCD6saHhyMWcVyiYC-ke
z0b$Ha@AOdjM!S54VMr%_wQQqZJ4)O;6`G^Fr1zRE{Pur?oC!nwk4ua<`l2tVltjWC
zJuY{}Xg@9*tk%rrepzn8)$*X$ZM4Y+Jl2atRzN2Bd%sWAphOS%=4-{xf4yVOi_$%l
zY60reY86Qr{94cf)^!=6TZT6f>dE=d)9qFQ=`x%imll!&%rTb>MG9o_>G+6ipC2j9
z^4JUDK*(_Ucz$Y)h&F0?Z{=|Y0grb+5K2c{IX7?)N-mTqc_d?4ir=%M!U=V%w$g8L
z`ec?1?65%FW|s8Z!djD}g#&SD*FtkZvkUs#nqLc)^0|M#Keo>Pmu%WoK775pm7z`a
z<0lp|>v)nX*LQ~GQPOO6!hIx+-}A(Xzfm!(!EqFIPN<)U6-O`FdFA~}M2YinG!_{C
zRZgsEFMVyIn4T$Gc2lT1Ne5h&#c5GGO>4W$4Byxs5Jm;A1~YjCc274Sj@<7tz7b%y
zmzu7L6LQBORc1?G{yTf9PlDHrGcv-+8Mt(#y4X+NJa!oQd6bT5+?JZb&T5sAVOCZG
zs;#-ziB%pDm<#|Ek!qCP2f?X<v*-|tAnwQJsM(*ATqc|N6j7TPyQn)sCov+f#|%Rx
zaDL*RD=1hL8z<$FQfD2V_4!PxlLwG>f$L2Y^xYBnqvc%9x$JkI8gl*gH}fRhfI~Y^
zt$3Vm;NcaJ+#7SgIi!d^e^-hqJDScGl6TQI{q1nUHO}mV)|&*f+0r4$w!FsL5V^;b
zbl1s<Rqluua|IHyniMv<p=@7@LK47{{VP2GUX7+|jcXXNdMCa_>jGsGJpAWhI4aH;
z(px>COuE2lmwx_NAt(Ni=I3iaNXb}MO(kyikhU_x{udw^oNG-)6R{j3Xa2zqnoNaI
zl=bQqUQ{hx*e7q^{<CTl<LNDCVuRiM4@OeY{7DSxl9L4iSef7+8KEwFh*MH|AR~B#
zq$FO8GGu-gFpJfR7s@9`nT=7<o*x=(WU7o*B3RDWvOr+kV!)LSyvv|{PS-Y1j&U95
z{<9B3gA!FMGluGlU_JT3?5y8MjyiOxTP;VKlHYADWkA6CnO8Q8CLC3u^^Uv?d?{s`
z!3O_r@R>!o?b|n|M+I`7z<P3j>F!18<^75UnX_gnx6ac8`Es?y_2?{MNd8v?b>Un~
zOcN_Tz7sKL%f5QuHy2xhV2D?Z=4}a(!amF(FChP}Y1d(!Y0vVoz<+ib+um#akLms*
z8!y%Tyu;QQB~3O5?kT%ghe<U`H!!?an=WY-VJuzi>K56gjWP}+H$+{6mwq$)EeJp=
zZ9@uu*D=dUMLgafEuIxCN5eqP|0>#(K<w@iy|4XBYF%NzTh=#eLz<txfI7{tks@Tg
za>~BaU``xj5VG^2GrYJ^DrMX67invr{rm9AHF(ks81=<N+NI_#F5;u5t)4tolvJZ-
zGuUz*P^x9^G7#Jx1q=Mb;><=_op0_uty-tCKdCbrlP|j7rLua65o2iL%mlKF%1{3K
zYLq=cT^dwaqyDmLhciaN?gs~6zyyK00_U~j`U$ItvMTL`zUotp5GjcFax^1{h1z2a
zN+F;kvJS-!txS7Xbe1U9I)oz#kP$yR>8*dPT798);6u=>QOlIMH$>9lB7fjn_Pmc-
zX?sD$!0&|?m3-lvWZzIH=l8iHshB5{={TI>=SRpSPVc4+e91)|p@Yz9ii7*))ru>H
ziiL_PC#B5f5K4d^D$Xi6LHX(L;5(1aFiwwXDvI{Ypwuc(D8Y&x4ojxM8whhsP(roX
z>@41m<wT5b&?Iy$VjM$jL9M??>?#n`TCx{8J^s+>A>~CbUiDv)cQQk+7z^{h4Isi)
zi*ekmMQ^h#drLt50_md3f{Ug<y$3Q!jGL=M9}U7bTkc+~Ht41KN4^I@3|4gH@Lw>u
zgVEByaF8s^=h=cVjVNaiGb|v)WZ<~HV!Ht=+l+N5Cpt}0+)-)hex=R(gI3|`VJ!o0
zs><y|eyGz%A13l@TT#KtCI+pgA+iRAfKL+K77@}#?@^a1+xJgtoFsvxo%vM0k1DJq
zfCV9VwI&-a@HkH@QZ*<H_lS!D6o^Y)LLfxCy*W0Rt(i4Zpx-2AMhr9Xz10X3_%1IU
zJlWe=f@ry{VMt{EBZgQm?jNj8vr79vd&MX3?bpjFYVSojWgp|__V`LGE*|s%4CF+$
z@gCU^(o(;&naG_y!0vue)AD!6?tLpImBERb2ZES?)hn%FbCG#Z0M32u(PTbOX>X`|
zv#?Slun%%15Y?Zn)W^%g_x1J7)b2M}vLY4bEJ1+3e$T4X46ZX91p@tb!aoNhW9B_S
zJ+!I^|EK?Z?%cy$D+op>($Rwf;Lg9@a96z5u`}h`YUF`~7{JjH!EuimI0Yz+nH8#=
z>HN;%2HU0CYWYr|CyQO>Q8qlk&z(=#=^!x@Gpq=pIc>RBX#C#Kh-s{d=BEy=3FL+6
zH5*I_9?KT_aK6&+sfl6{fhs^|erZ|!V=1xY`d>!sM|e7u6aBGNXSl2Ow#lZmg=RUK
zP?Y?pWg1>d{~%;7=jj)u=tU2?qz_#uMf!IX1VH|&I0r+O&_UkuA5#b{%4LTt?`O`a
zx6AqO5DFzxP$S%KpNx9(hZh2%=jN#QkXQg3ylR$!>o@;}Zy${t$1Cv{{q&G+BaTN5
zOdIkF5mco!=G`t}OYJ4Mv2ILpe>nj3hxS8F7oAN-4SQG83KYbZTmjdUI<@qHkP$f^
zc=%HD7nQ%STjA+QMNF|cm@<oQ&;Cx<p9OB=yqfaaEqUj3{FgwsE9O&i6a{`><=n{O
zbh#}yu3-Vx;JHIzM3OQ;Y$dP{XTG`ZwZ~+^1VU78*pGY$FUxNAqs%h5iGag_`fsCc
z>&c+6TE&!U!UFY{@~b;D+r$=jmpz7iNhf?0oW$+w@iqow5<1~j=w~+vYd0!fRqu@e
z-HpID)m;Je@#VLlfN%cuFe%`M;I6FvKk07%-sbQnx}73N-|9`vBi+JG3LKEsgB@}K
z8cOd)vAs8dtBw6*1b+NVEm4(k3dJ^UAWYc%KJ<k%cH91MPto@(gIA4Zdy(dO7A2;A
z(@6F9?b{P|s>$rrWwsLO&J|iMS%jm8^pgiXWr{ETEAAj^m3q5J`t~^FPpDj%1_iGI
zwBo=Nk~oq`HP8=?&&*yC^SvQdG}MInKLe1+ya)?EowR?)mw^uoy6k@O-l-klcJOTa
z#KP9aA?xD0IQHyv{l(QT%UwFUrrkuyZ7q!D7H49pKfCkbtHz|E?|ooVr?KbYpQFVw
zrh2!MfsVsvXS%@D^x5!RL{gsZcyZ^j;om$WKI-ME9}5G{Uu!6MKileqxa}tq_gCt4
zbFYU(P*=W?-TA$q9=JwvG|1m=X)uK#X?B-Q9&a=k8x%&9HI{m}KlV*INiBUt^6aRd
zukpqXN0kk@MA*YV-bFbk)cEw!QzM%Jqr)Kn6Zux~Yp9OvWiibwSb;ay_+3JWLA4ea
zkb+&qc4qYyAMUDFB|KN^Tqn{W(>IxqEm&-ZkR*5wFI49+_Lo8ADUHR&YwxPqnTPJ9
zX@~ZYl<l!+ReF+UvV*VNEDYlExJirSG<vhZ!_`-n2SZkUuJF7$hq=S5%}=a%Cm4>M
zgABYi2X?|#Ze7^WVJ113BEwCmHCe^g;5XB4&Jv;h`WXNQNIu0*hN1Tj!IkHj_Y*ts
zh&ChafeY4McEm*N)*;GD9Vp$=Hth8^&OR=QJkg#yo^8|yc{>3WMp&*iZC*yXR7iSd
zVW4ip85%6pNr)ORNlee8)R%)9!Pcj6Y#6#YjWwNroZ4iF={G^^CS|tK5wTnnC59;X
zw~uz+(WUKt=O;%WwZt2{duS7->D%%Ij5NHstW?dYJjQUImH?8AW}WOa%{F0}LtJ+8
zF}cZG6V_RVN@(mk#@}K$(YT;WL7bzS0Dp@<uU`F5tzgKwSIc)7N`=DBdh%zi+GdUD
z&p-8FVrJC;V83MKoM>j|fVP=d544%2VSNaV$c7YBzbeZV&BwNW^Ss~K16Iu)4yE_Q
zlMueGnVMEu2KsEQ_@uOWxpCi`*z3NGjZ3fd&peEKA8CG*t~Oy^eW4QDOTD{1qhhP~
zl6xI#0)A(d{KF{R&DthbhefH^{Dtl}wyt8S*EKx-L$@?hYe>A$<s$3S;qi6%kdpR*
z`a-z%%*LP4m{Xg}*HJ9S8d4mqUu5&{tnse46<V7qTcz&ymK-YnTrK$U55sf5`kUsY
zkLPG#JMrllh<aCh*zHc#*(DIrnh3HyC*eC8d%Jl6xovS(?lDp~BfNQY4C)h`ieZ;+
ziEYBB5FAi6Bb!rWLNDQW-IvEC<1VTzHMbm1^WFWP?OVjmq-QbQ9V`|Ys@xx=Iho2~
zZt+ZXVbLFRbZ9dX`K9&9rHl{~&CX%F^YghwZK<gz65(5R)z!jkFPxIF?$NKEk^bz=
zg~PzJIyJdEkz$>;8R5LGrrL6g?y>^4!Fo&BQEQ%dqKEp@AR?<qOcf0pjFhWHS4OmO
z*)DZCc7dum$#+-y;)dt?POe3t)F@fcF;@7V@#(CeiY_li)4)9#fLnC)iUv6R!$JYm
zYTi(!n}l9g1l}K&kHEIPXmY-U9!r^SGP^dhzk-kq>c3;h%dLsq13)<>1vV?G*_Y*H
z-*Hp|85(6#yjY*~fBp<U8O(s}Vi6vfY&dM*0iEFlkm_+cHPz<sxCo?ryn)+eZu%pR
zPROL}F8PCqf}&!_wefRu@sA9^g{zIDqG?s8P@Q{qg+;-y?Dj(e@e9+<w3^a{b=3m0
zCN>FsP{-r>u=oj0lza5S-rk-fQn16Hzvc8|J)ue>Pn^LaA*#R%jVr6D7>MhtH;?!2
zdZ<U*lPsPK>`#+jcEmUDhYJ(4$^b}K<-WbShm@~RUwg(8pO(N*%<)!v8<AVIl-gfm
z=JoKEh7!jo>IzwJzL8UT{nth_k%w3f!TNc07(3zg(uDF%M)(?^bnLSSO>056;{NuB
zeoIx(1f@kXajwYcBVA1k;4riEqEw<4yhm4cgowX`yobMnK42+}%f>`>Bn3g}x873A
zzAsPU=QR4>Ms{anV;t^48a0lkBV9LW7Ikc<W58ivE~l?$>h$Afd&SJ-W$s6knLEuo
ze&&uVDEU1K{+&?akE^kleH5L?1FEw59mf@yTip|8W82On1K&}IV9h%7Hy5^@DWuE(
z+L=FnqG_XJvSR^%%p-olq_3<LV|P>t@iU=DD(M=dyQTd$H<;H~!n|i9hi2X(I-ItW
z<BA@?g_{SizZ<^Dh&+Gx)MR#+U5@Dv8C|km^sIxZHnC77TMQp&2IQZ=Ceoya;u&du
zl0fbpC+1my1$oS}&zB+pS$~R*4&x?3h1K%{vrFsN)00iw(FEq+;np<AoypSIO8a;O
z+PBMfg=lfF5JlG#=s-rv4O3`F$*&ktVe(znr2pA(3;OTBvZB;{B7q)Q`kS={_SMG-
zN&=Mg56{Cw>OwU2lRX+^;OEu6gwg%WhjBT}lgjpb+Y4^46nRNXnv#T^@G_I-{(jx3
zlx1^h_Ul&2C!yD48Hz;{JgeqQYn>Y>BnlFtH&aaw1h_?EqEhH5zPD&IA5v7b|7N9L
zqS>ze(5H{>uq7T8F%F9q62qhNF(5)uZLXlJ)150>4>t4@aQw-RmS^HSXW&bq;L&$A
zY;U||vaB_}V>r6D5E6+c+xWq_vwim<`;(;7>k&z&R+q#4@L0jB^DtBey|BDInwiGO
zc%t!auX<6UsW9ugr0)!Sd$s4i=Bs7Cwa?Ra*ppmy`t&dl#v|dVofiAV`^!mdB{k|7
z>ipo03~~?mq1G0yy=4-$Qk9K+aC7}rS8BCvrGHP4TCkg?twUqIYekFurYI?g%a31F
zK`zJha!P`q(-#yaJyuz=bW5yUFB8QHTIPAZc8SB|286wyo-)LDdW40-&0T#hx~J~1
zuGeT?Rac*R=FQ(<H`c_4h9FPro+#P73IE+tEE`9}6_HK3yhL!ay<xHPo{4b2oJ2n<
zaW0j}XgbV1SIm+rFxOsV7<0s9Sk~Ot+Hy1@60rZ2(zNDXMrv@0;-NV=&{)w5{0xiB
z_(T3U(JnimR9NXhClz^{GMCHprb@a-H9lFqv-S4bmu#tZ6wsatM4eo5GX;8?was_2
zDo6ZW5FN{4h;;wYlK+RjuZ)UoTh<MPpb755-AS<E+CXq^T!TY!_h7+-yEZP3y9Esr
zAh>&iJHZ{^V()#<J?Fl$&%5vc9is;{%|h1fnpIzY_06i?7!KFW1EO6%mfnGs3Hn;A
zH0vz;nZ0>!h9;{8n1?prl9PJ#i4f6mL}-LRHeu!jap48TG&b;Ca{a!}lj-+SFJdj&
zS01!XXj%iah3g+~$A(>s3;Ulz7B&y3GD1O4<npo?U4FCcA3b&#zIn7+5h9%a7^}BZ
zWT;^SR8w6HYqArov6Sq53oYYcPX_Jh?atD9X>LW-F?p=q`I+ZZO2;>%C}C0>ffD0f
z@9!5Vg~ro{MsLEz_cN?O+sB8b_O)S4;k9pW>m^jFN4cz^_hjYt0XfCu5h#~r%9}O5
z^3~5aYZ*vZkNP9kBV;)6O?*Y+Ar+KRk~LBS5LH0v5C0#VOk0{*-QPcDZQV%5VNsIR
zK*PG#;S9m>;hE#J?oe)a+7W$Rnf8zGv(`dW>dlfDPbWVwK@X4c<m$fN?;ITzZkLG%
zzYmmTvy+Fvb#tH%H$`YPli<kHO5ako<T~K-iM;5^r~jq8a6>*>BtbUflBvMxno*D<
zM4bPn)QdWKU@M#rvRBkgkwY8InRW3>)O;el=4}35@b-GK>~OBEO_Aoo07tzU@$TZ}
zxp(XFd>j`0b{LeO{VvGU>A*Pj`C^)kQQZ(l&9~PGb>iyhU{vLcnGozmzgRW{Wt2za
zq2~wz*3S`iLrvFtwVD}IKyQkJmYGF&4y~Y8X*Uja8AeO&_m(Oxyy7oZ*b}Qp?HUf)
zJI2l{)VB@913xzm)h(sX`5y9oKjdHtrp4|zv~Nt;HxtQB;b(9!GFu0R3ywm3AF@Fz
zN=iz=c@W38;8HnYuDlZkOD41?4eaH`f8R6A)&6+Q2NV(GUw~aJvA)|`PS?_#9M?o3
z@EP!+tbW=&*ywpo->RuFTBN;oGEB=0bxdf4=S7x4V3$fdt^7?w@^Oo-rbKWxD`b#v
z?dNw%O?-DwKFntJ{dv!j4<8h&142o4m*!F{H%B)1CaKt0ab4t+Ty_OQa=A>7n=Zhp
zE0N09_8Zit)w^8OEMRX>-4eov$Dc}dlSCy%OHn+$)!`x<)T=M;m&g1OKVf2FF^96$
zvQ=aI^#IMi3&T_LGN($^RR$B8Bj(b}0c9*8z&YOPvmPjxcA@c4KHr;ZaoQXsq>0n_
zdbr-=aM{;j4m)h#W5L{_FA)hO0V<c(EXFYor<+46@_K4}b_hV9E&HaEcvnl{7fl7p
ztP*hoDxUkZgXLE3bLLR=cLggxw{i-O^~zeAz0KmI9FCi^IMgdmk^bF6$K6;Qz*vz4
zCL0HUHF&FlZQ4@ds#?Hp5A^g<AC6Vt%y3=K4kq=PH9UrYMYw%v575H-yHnxIX!loZ
zQ5@!@WMIAYRW6&w?MfD-JU(~AJ?B0TaUUSE>p*?NhW?1_$$cZsD|q~#ub1*_2Yi?8
zQz0+pEz`tl6yJoEe;IDn@{`-gz8fFutCM5nwNAQ7xf>DaKhw|b2KhH)w)&_DK)<1?
z_L7b0t)6K!&!%M_s7v}jJRIrUpKXyWw6qu8EpJ@=jX_b%_Q`#gy;jq{&C?_lR!RpN
zuwnSa<yuuO<Liwzrsd1%tr;UrjA>ak5<o=Emgl1>{7V(!v+Gvqt~9^P8|ks=+2KPZ
zYk7%U+hb}$E|e_|9TBpFd*)rFQZ17~;2xYxi?5|jCLfUP$&e9$s~>5X#=jk`F}*kS
zaP945xIPX(%t5u*#u@O~{{Gfu^TmQ~&+0R3c|}anOCWD}wJV7?P?0Ziw~iwHbA5nE
znkcy&gE7u`3lX(k*0$~J<%=r(L8U9ZLocoR4-pQX9=`J^;vfy>zN=fBVk8|KlKH65
zFSieh2n7ynSn<XxWRi*x;LmqQC;KC572oiJ&-a%jXrB?6&lsABYqWm1(e}I`R-My*
z8ydkUVwg?7dpAGR?lB~h`tYle!DF+9Rq4H5v^Q?>LMom0y4-Vf#r90pQ|x!jz3d?}
z$=n7(>dyBp<&Ec*LWrL_dZd7f?p9l`x)`wJ(bZBuiEuoP^ZnOH{HITdB{cGSBHFH0
z%}mSz&X=TuVz+1+_Q~o*B~;1zuTc^v%LX)p?{5TgwF$m0FL@SA)zC~fx?>qRh0e6=
z{iftwn>7_pkml8$ikx>fAF6ScRD>OIs)rzmFyC9J=skug1#Dl~Q=VCCR^ffp>7zi#
zxC{IoG}_jRurm>byF1LY<f$Wv1!=BObYJ_d^p)b6-Lzf8d2fo#bZjQ#P!99D<J;PH
zFO0yMQwd|QcVd2}^!({S_|aHc`%F<mXeEdULI{i)2iXih=#&*oeNG{56>-jCeL0ZW
zIK?;<*QhLIK3l{R(Q1WlVrHV!f?9SJRCf?uGrlhdFBvj1CMb9`FL?86ALt=&sjNIs
zaAP=D(OfA$Ph&kPYH{lafC0VUsP+RTYHSB8u89lV`t-}=nX?VN6`+NVHb=p*?z~EX
z#JTDsL1xt<Wa@Q7k;EX?Oh<SHE-q(NF2wv?TbGbHHSdd#wnDXHKT}?Q{=^#EeK3%W
z`y*cMSE%1sCvfL1IA@$c7(vRdWrS`=YHUZRhxqE~oLlRxXOxFHl4BhrFJFsMbPO2u
z2_UW3o)6!$;$lh?=#GIpXd=xhhU5HdTQoV&C(vY^m1eOXU4?Xg#niohNgpoRZ+`JD
zbmWk<mS>afFUAiF5!SDr=D$#%31K%(m{c0SNT>rA)AZ3@z*s}ya;553c&OJlI@-XU
zcmIl$!6Qb$w71Q^JemNPURjcw26Y1dZ9Agg>#E;upUm8CW@lZ9i-|R_R4@$_($~%(
zKdK9jp4hoV!G(n4swJW@eh-%Dz8+fe#Pg(L^kynRXYkM1YMk8`GGwI=UnJo#+TMM;
z5G!4$LsLrFmn14N-n3Tl%(%2tTY}bd&4tr<F?uTDxmd=EoKWD-VL?O&FCiuvA=W>$
z5q*rG#VDnJFnN}sv}owm72|@B(Cp=efb#ObRrR#m;nd=Xq^EoIr?R^7`mqd(V&3r5
z?zbicXtG+`Zx-s-lQ|2>!DTvbSwm`>#U98b8f8I|&WsZ(-Y6@c#3p7LeY1v=D6c5)
zCf`~v%sY_tnS0lfOD*JO?q^NWjYA?K{S?2FRezr3nY<ZZwH6AIfzLg+z>p}@B#Zmj
z*Yv?xI@_qJL>v3u!lFfCW|whze7Sh=<Fv6+MsG?hwa-hwPuFh!?~2{c`-X*5&3pOr
zVw5zfhecyp;6b6=r6zI<KVusn@njfL;H)GrDa~$c6c&09KeA#s)}$bX?+<>jZv+qB
z9N=5?rRNa!7~ffcsz4BUQ%T}%trjFtWj2QA+cUbdkJzJ?3~P^#R=Y+pQ1KB{dTBuw
zOi?7P&ni7Q0Df)=>&4%sLsPbtChPlAKF5eDFs?)fj%78h$LP$w`<&CFBZ1BH?bx_n
zD2HqR+XNPCWP`$@lGM**Vgb8K$-2HtPLjWJ6KJ=S4)8J&#6fe3;_o@HwPIoPTGl2k
zhO$utsMEk`S$Oc%^i;<2RvP742Q|VscD9G#<Z@tDg{0Q!rZ#Fi+~n#@>CbiW-He6a
zADCu}==mciW4bBMU(7l!;mEIAoeKA;2TwCoIK*=xNmS*2)YoJU$*VwMqiibgNjM@y
zQ=SyH7v~hR<&$$%pA-D1zv;qZ*r_8G@RDU<U>F>bsWaV4EC=__Vt<|Kd9iw#j!2Vx
z6E?m^3I%1!TsN3M#PZwc^IGRUH4-Q9=p)vVQ5^N!T+gGXU|sixYQ?@J;vDhcTX%%G
z4Gj9EtaU<32W-Y};T1Bu(UW5xYRtFD52)^2m)zDWq0%OHIk^VYl0+L*tAr<8mF#%c
zVRWUuLviIFXTQo2`xh3{a#|_|L&epUC>VAaW7{0j^liN$vt=^cg{x42>JzxS!hY2>
zk)J|0@SyiYliJjon{kanPDiJ^zZbvTUYaO@%IkbeT{SHzTx)x_D)$?bOs$jT%=G71
zub(E?YvE4he@#L^{)Ry6CG5C0JaroC7!eW&&<nYJDP@4jIK^P~a>ci>Vc8>GJl%J<
z1v5LT5&QxU8~4*5!Ar)~#q%ZCl`$FC*1Yg)D$PK~)#|m7xa>wP0k5k{OvTpg&9r8+
zLV&yH0GexUY#KpUd=`kA7L^d(=7)dyKAe&+c?12xe9mt6D&n{qq#&g1Kn7k4l-nsV
z@#t!PqGm?!)>D+Ga#+M#HmE(^9<{qNKmiq4(x9unmTq+|L#fAM)0R2#-$IK*h*!KX
zb)VGB&0JWRn3G#QYf(bw>dZ5%KRW}?t=FVAk2wy%5%1w#UlUw9lpj5D4zrFF8JX9I
zMa#P72DCeo&H;1@5CpE1K>Aw+(`}1t3M|p@r)jtxeo^(zt4!{_Xve2HW&5zDa;g+N
z7b6dcZZz)%eZQZM{;dB+B}(t^N-;w6xF$tWyG6ameoybh*5<hkQ#Pj>ryJ?Xg_cX^
zV}n8CfL59iCrgb3$T{7LFR^bTW!2U*qWG;WI<LM8*6M-<3!YI|$8L!t5ncjhWS*B)
zQ<InmX9PrB4ezVMo3t-t^F=Ri9jUk6JC}xJY16BGFDZ@&*E3?h-yoMz$$8?|kC-i@
zZeH4YYvX3P$qgDgVJ12XZCyxc#eT~_)*Otf98=21!zInPe!Iia{{_O`6w00gx5K{L
zb~tR8=$j;^FtU#H(o2>$ud=y)y@vj*!zgabu?f-mkoa9{`M%u?A=i!3LvIB08w3c$
zSlr}gC!Y#E2UT+Qm1{1ZzGoCFiC_Uy++pK6&Hc4(x16J(rf`YIGpf!Q4H;_eyKApb
z*R#{u_Ol}G&uDpm?=D6gA{ZrRihR7A<JJ?lT#-)r<~-SjvaR_piVoftJdjR7HB~=l
z3}SsP)oc&-xj9$h^;o<}(^}frI_v&+S!qzRZTs@EbOCha{W}!uD7^C8d~zsY(!>6N
zh~Ftb)7xGvn}TpqH0EoS%Qsw)t#-$2SA3yN>=P2p`9{A?ldZ%1v-t(mBD2+^?{*%y
zb^RWxB?;B&Y9?k|MQvnQ(7;MMRG23UB=A`vc=`q=5KNO!R>}qwV2=I_=HDK4FfbTu
zQkAP(VE<jY@OS|4)OI;YYn%+~pB-w~=pG(K@=1;kHE{bVeO*1OV<PmJu^^_H_t@|E
zq^J9Sm%oc}<SQE9t`FVC_%(*7?`yz2YCQ4TdSFgsVaM03Rr-9lg~T9tV<u6eQ&<zF
z1mtzHS@M|wYOmh1#kJ9EQz%Mt#-@I5`3nK2dvE=Mq=4}k<vo2LzBth<$(Km^OMRhO
zNN20-4e<u@;O(DLjhX^N=Sb9<>@-OQq{&Dnz>ovEI1*2#m7%U9Q=S7c4~cIBvHDF>
z3XV&C`R^Al%C_gWNU1UI@dNm7LaPKB_k?`f15Mi=i!+@W!dt&kPzYojn2a1gKbsAh
z_7xr*&_1|437A9~X_MlsU+{?@AK=qMZr@?oXIXtu9jR3z@2!Bh&BMTG|4kA#t7^@b
zKK`r2wbn+m>6co(tEOfN9i$TJ`L+{uwSKhZaZ;cA>#i(8N)+o>lad0am+5&U@JFbI
z3CA^>3sHzIhpBHQ7HVsmLIE9vyqr`nu{JPAqvT^ttVjr3#|VBGrQ0*l@SENuiam5S
z9FZK!5Sgxr=aR*&eDvnSNFE;u$~97)7cyEJcGXN4w^(q&vW8=!_GD3Sb+z%TrcRma
zi+%+7e(4-|1_kz_F)5p4&5x^nsP(1Z>wI_`f(7cm)lZIt`vPBU^ZDoFmZaT&CwRX>
zrD97n<fdkiLhvId=fP$C)p^MI9t6VNN3iE%WQFyU^0vgmtm7U$qB|&g6<TX|{{mwc
ztJO+r>t@)@WeQ$~2Rgzu3?1$NK2yqK^fhF_m@E~}6|rQqx^jC9)-WakMp8>#nccyH
z3#9}YguPQZ=ROc1l*aBpst<|e?>K_eK}Vhs*H>>_PP0nRO)-d_zq1D$>B3zfJC8>r
z;BcB8>v*~}?RJTlzQk2$Uhqlf+LtNtu40;JLBIb#o6PU>?Zjvd>?ru?dLB{W!Gx<h
z;va9T)-wT*Yk2MGO%Y%Gnn1X9L2|Tc&ywL+!nB(DU=I`KO`b5-I+HD{eaNoblHn4C
za;#Oy)H&U`WRTlL?XPo`(3~&No6_q<#zC{R0dyHV{va=&`w?zju7YN0B+Yr5xcW)f
z&}!iA7HJli*_?NPct%YxH))<}{_;m$wT()ZvinQVnCg>zR)pbj$1UZ#R#O~eZaZP5
zvOCQyVr(MWz9?dqE@<Pd#uO`5y&_x3w!H1e5*g_g_;9ow?$tP?Rbz7P;Gn<7k)@;B
zHn;Ip=<8(MWnxW;Wsoj@dU4O-36VZ~10J_;{{^$U#HieXbq?<w*XPwUjIu@WD}VD3
z6<YJAF(%>w?MxZfm;STUGZ>{#9nP7}ZUH~_ok=|>lpq(mOr66pVVXOadjPtSpr)2M
zQ7Fe{ljz~SGoC*{-e)O}fJTycb3Sy`A}(BKF;O5o6*@{zL6M`Fe*d{qN8n=C2pbDa
zg-$9^N<r{CPv!WtS_iQ+|LG5Q4(}T$-S1S+;o8%9`d%W>;a`rrm^5Q&&wr1hv^ZYv
z2|B3-=6c{VX>_1^4k7pO&CgaD1v{`~nlTwgdzk%57BMt5>@^SGJ2U{MS$CXv?O<H8
z*|T89WNEqqut2I?#x%Q@e`q(sjj@Yih<-p*pqB#!0njzi;BPqTmix+m-}zA`y?785
zx0$|Cs%$1&SG~SdDn~6>@_l5aF{vg4T;s{Zc=TeOOZ{-j_yY!`NaoT8fgXw)M04Ze
zek%Li3BiK?DAMc%E>m{(g$q%l8JyWKco*EZqnj=Ygj~nCn(A0JWy6FLkGeCY8E_%V
z5DRxXevhOUNv=^vZ);u`G}gf}xN=~YwdI}3<<6d!d9ZmiM_aqOI&E~O;pN+!-{dWM
ztju;&co@^7xQ09)wbgiPDN|-&Tzj=oz}SXUcXdc-2L&q7ov7pU`KeC6cWd@It^$;l
z;j!*rZxviLabe^wzCk%(Z{MQ{Icg34d}uZAu6$rnAQ6Iib3JNn-Si>1%DPRxIcLg9
zcG3#1rRof`np6+>$vMJZ@F7iP`v!lWod&-`S0e8J^<DB%PFZ{6WA6B!mp6SF?Ms}(
zv*cMf@Ag~`JI)UIbZUR7I|^=bHJfHIuCXuhlbqfUq@G7u&6To@Yvw!V5UsX*gs9Q=
zVq1$eOP;j@yaYyY_WNb@;7auZ?~WsZan;zNS79p|CZ@Y_SOZ7ftb(`PEubbJuF+jq
z6hkntLVa?dj+mJLRRg&1NU-+a2nm+V?i&45<-mN?=gNUVEFgjzpud78d-iV+YO*Y(
zl1=7CImmJQ38Kj_H89D+^o9NJ4h*f|J(sm{FR=RigM1sYf*~Sex5^Dxd=_)WENdSW
zfZ11&iF)Q1r#`}dx-JBJ1p<!Rs2voGvaXH62g9)*r#c=3JJ!_S9mHD7G5J4ec=J{?
z1Re_WA$XoN_Vgc}UZg$_$;RT1^}G^dx`_}>H@vOtl*P`UqG!Epf4oq~tcu!X0!D^{
zEWE`XoA;LAGD*B8#jiJ9!cDz9+tYHkv{*SDKNOqw;ksnpSa+fj6j@2)M%V4JQOLC=
zEePj2>-JBGy?CDcW~1cDRAqxK4Mhxoq~7&WKq019EWLn6!F|yuDX|{7k?}2vj~s;{
z8%dm+1|0a?=Sy}RmZ#kNwz?Ucwg#wE6q@OOHO`#S?Cc>wjJbtOoNDV<9SIE&NUh9w
zm4jE9bY#=s*|5ffb*cdlJ-2!DpvOYXl;DnHreh@Bm(_s<RQoP6V|HE34tsM%yL;>S
zwLrg~1~t-fIR-{hXoy0W93}kkHstUIsy3<vc3xeAph#s1?s5iKc*U)W<wOi+29?+G
zT*EG;G!1EIx?)N8RPb8MwJ`Q8X5f91cChk@;0*3AEy4w9K`;$}?#WA{#k523pDuMa
zcX7#XVK(g>A~;hUyOGj5=CXKw)k%e4W%k@wwD5m)L0bl;fWhtYnrLVTeDZ~{vF_oL
zsrdff7gN?6;S_WI17N^*aI#MnAgu;`Lt2$(Ixado4Gc!PAf~eyXrE_C4tWaq)01*a
zZj||48e(8nDG003dNm78o&~+kt3;z!uHJcIMTMH%54yX**A*C~L_r%np3t<sU8{<q
zpRK60V~ol8xLL|A;^}^|s|p;S52!teWSN@H@4aZXl%1G{XgPr(*EiwEa>z&mwfqv2
zkV_kjtaPthjx{!RTFCM(Wh56dpZa?piVwsD+;v+Zc<+`m8gn+(0yflDOg|MB+(jmh
zB#rMGeIpBEJkKJ2X*Pu`bJcg9H{UZ2>Mu=9{%T^M&U=-}*4w1@F03zoqYlzDr>Q5^
zQU%6ea<7vEIx;;jyQ<+-H4EL|xOUH{4}uKdeKGq<(lczP7QiiW-*}PdP=-k^t>!`^
zUi}Fa2!757R`D+sFIlrd3ZDb%P^Ti=Lk6}wS%9W>{;;jvpX)Ksx<_x~yJtH0R*3TI
zJco;%Yz4P4^S-dQ1aOvXrog*K<XCB|<;U%RK0jb^N!9X=Wve-LAC;%(6fV(5X~WyW
z6t{jo3-VNp5<BT<`Ylw|vHMJaYe%OL_iK|)3iuYDL}w-g0frZa0(xUj%NPGqI;Vyp
zs6vvSHUM8zmq2QU1C^ewq@i)8)yj@#{DSiNXt#B_9#{xEa?seUR7p+CQFeF4baEZ^
z!fI97gw(iqAK*YHf6QH24A)1c53Hw5S?A!H*~kv>Rw~4G%JJMOz?(K9J1FdSa+y=O
zg@y9SKi-|9_4M?d2xsaX2Fyu+bUs;^a(OqDU9>y3bF<env2^*Jij?a(Io_2zF?O!J
z)!i-??~&04J-7-9qMz*ixPUY)j@>)*%<NF#)Vo{r_D7p*EgMA}R%c>hpXZcn`4_EJ
zzQmT<S3I8~J;s~6C43FcY6)z@c4*-x%F5Qy`_H<(mY+AZsSUkWvg>rr%`|OL)&s;O
zA-Sc^x)#Bv*d`YC`MS938q^;oFw~P@*n8~G)f8qju?PU|DZaK@*Hh%=YTHx^<T@YB
zgL$rA67x>xlMQM>fPtK0GC<ZW0Td|;0PWCk&)0jyUa40gLD%k3^T{G5rzx<yrjM<O
z(*Xv?!a>7|Jf*}J#Y2hSHRt-nr;_}0eiR5bhPuH0*~HmSAtV+NwQjW0-pB)}lP92S
zgge$cAt*?mOQ%=aT$ejx*R~zd4JoC|Vy<m$Y|!-^rh^R=)HKo$HiyzAf!e`D&LkTf
zo3gGWMLK4ZK#c+aW-K7Hb50WX`h$K?x3+7WYfVqMgw=v*cG!%zA8@N|U+ZN`Nw|E;
zlGw-OyAIA}D7lA2m}f6Rls9IJy}S|}xq1-IWSsxq;@9UfP2oFi^zzVyCaGV$ZQbme
z`cBr^t02}pbnrrVMzs)?U-NS=83p80L&MamC6P;ihFewOxdqGM$sJp5##$)i{vM|w
z>q23Q^@2ilY|lv9$XmzU1>1K%G@g0E2TPH?0wF6?UR_5YiC);ho^j*$;G#o%x7I==
ziMkOv|BFuE6W5+vb$p<$ib}%OsopGqV=OW4dTDeL5>+CX@@0GI*LiK8=%BHSZu{xP
zebB0oHTN2`$;b)l&6;4<6utM67+#zoKBVr;){G|Km*LI0+nH>xeKs@FS|q7;!bDe_
z$mQ4bN%X_@vTqzu^5hzE@V9NR^(N*7xonsEyK;|aE!Mld!`7p|6hYIod0m-qbQ(++
zSZ=OPE9m`v&E9+_oGKa1@)6icEf=Sa<=Bin|MG*05U9Qj+~hyX=G{2&Z7)Qsb^qFJ
zcx2AaQ!zuPR*wp!!r*o`pJ`V7`tiHK@WCa2`C_L3obFC@37-m3pRbguJ{?KmJMxSL
z39mD7J8s5a5|30FP5q**-^-zFII2SEOH-pS*C+LER%}uy5I3O6v05&DyTopT4Mu(W
zhWUt21WRp+*8%Z-&$~63sV6M1UtxTlO*O@G3JR4<3IoHi1w2F4sfHsft#+{_FJ=1$
z2h{rULBNau%H@9&MnW|2VxZ@>KS7>vrmTXi(_kGhFoA33$xl0n#o^zg_kr;aGsDDE
z0%>RzvDj73e{`p3?n*d2d%2-zL{na=wUVE%01~ser*(@?5kk9K6X}X9*mHa)97tNl
zAK(h#-i?NWV))kY8s#zeP;9~4a+inKog#*UqGY#RLo2l=pYPUh(m7RJ0v!H!FSVvV
zKSPGrelwQz?)kMO!mq8hwS!W`aU%3+A2)`bml*<SqCP%tVY#e;VmF=aUS&AwhoF9j
zS!#m=3EMS7{cN%uiE)O)6jWUC&4|AlX_#ZgY!atUQl5A3iAfVnK-EX0VaAK`q(R>A
zO^GAVG1x+%)i!P|Y->z?bv85$AFU*lf%viQ8S`GI$!11O%!~xXGT!nryK?c=MW6N@
z9w2~MLd(_TEX5Z<NQ4cFXnW78>)14!gF9MB9^_xUraLK^(A3r1YDSpK9~j1JeKp5G
z>!}_c2=5_xhF&?4GU;7c|6ndxsxqsl`;_6G<KNofAe^k6c*{|u-ECgH->u9(Sr`(Y
z<V~<f#**6-_A)S3C~b({!c)Z<y{+V+smW0rKHQ}Gn^H*oxnD)~Bi7;yE=yD{=}fxu
zTirH7;h4_*O6Pk6!tR{5Om$F^DT@w)q>QGHb29NyemCKmmo%}RM$1ge%}`Bz0k$GR
z>gr0%8?<1HKBY|Sl!*-z#S>Lt{ZOrGl$-~q$>u6CDwN`rZJFh**jGqS@h^fN_&+fx
zy^zaZRFKe73HV&K{R2|rHx5^J1m57Kl%Bopek*NirLc8@JoCPdX2Wr91^G){WYv3>
zdCGv%F3nPE|DM>u6yLsyN0-pq6!Sykh_EGFq63v-SC`0;5|$tM2Xqkc^oFE&d}|-`
zn6(=eDbN&?ZU+E`*XUTT<fN-lp?t>9aUYGc(~|iiEtez{<B0AuKjLB`oDKNmpk=Xv
z(=Z{a0k6)KJRTQRNmHY#jdZe@*o!KhqRE4;%G0qUyMICy?RAl^SGLG*yHurM?Rwz#
z0;PIj)29MZ612wj=rqMFiQir{*C*!>2;Dwu$AFTn^d}r*V(VfUWm8~;GSvqLvo2<{
zgr;27>z8x&)~{a?uyx0>$LC&zOvE8pfeh3Zw`j`Ro~Tohfy+jMI<NQU*vSIxQfC*j
z^QXf5l%`5%8+o7~aSkAfKDm8$DwW6*|FhqCaa1VcT$f?*#J%13(I?ELVE}OYDiMU`
zy6Wq*tP+_x=T8jgVS8%qhI=xkWWybFxTO0+?xzv<cMWe}CESs9i#tKGNXVAJb-vWl
z8`4asZ}T;h@Cpv(Bh2J5CwkxdrVNv`o4LvQZ;>#*Pj2>uq;Hrupq<nkn^3))v!i#A
z9Cxdau&IxG+G)I#&P-nHj8SfmuoS&mW^a+6&#Nk7k)~|1xDU+5JMMZny?gB4*xGBe
zlJHq;J$;aZ8j^k$m>SQEKiPL-qEX|KoQg1QaCh;mCj=Z~Hf^T*oH+jZG~<XCGn7Vy
z$Ac-+D@6q8<8+k~dpeRfW%W)8<c1R~#W=wC{nA9|PU?KPL~Up{(bbpcx|D(TLtW+Q
zssfF%yJXLg<o>vmjo*20Y$?)+C{ySFO(!f&3CNfvx~?&SYNg=cRx5#mNslM0uByLQ
zDc<!;PWCiACGB5cP^SRyOBaJDoVtsJ*s@^H>mRoI!MO)hzP1chrQ;{U8u>9r+=Gz;
z?Q|2prH?*NDbrB{GLju1(bab>#doS{$Z}|>cSi?^3#D|5>xpE4iLi5Z#(xh^oi3Mc
zIR3azOc<!lvZdP|l@X`$vd(md0QdcRjp7VVC9>%ZbUp?qen>P=gTyU9F{K0!%)@kn
zya5xqwD4Iaim|KMgd_ZoTX6eF=`7o%K1Kv4w9GD@T4{>X-ETQ15Bu;_P#bjLi?{_d
ze-^7uJeB)Z2dV(%*Wx!5v*pw9{@Ofk{J2~FOh1}%bxQIC38L3`e)ZQ#6i#f)rI`;V
z4mlkz^5B9#<}bCls_b!DoBt>?DsrvRWBNX*)CI?w!@x>%M{NVnWD^$@Eq;m*x6&Yu
zse8hin#6@9$2#T!<QW^f-BQMl0cDLkKnUSs+gn(kx|MjgGeOgmPofI@N49Bqj9FCl
z#2MVW-o{fJCQRY}N?BwmmSJ7t!R?5+H6|4bzzSWsDqSEfHrtmudO!FWLgV9|j7mF4
z6luCVU)dd3-)Pw+D<2zgoOT7Gv3J^X+%Iz#?DD3Bn9BJE(KgZTe&2vv_eecjT?=vS
zt+9e*kk)ML)*Zm<H!(B!aO<A>aBi4g-^8v3!ft(6?0rj=C=oviyJG+;4xt60dgB(+
zFoA_1`)|oHnIbIgMHjS;FV1|`aZpAvZjZvY&Fxj4h2bIYdNcg`UreyyV1TftG~vOV
z{b*;WT8>MGR^z#(zBR2j*S;D%4NwVWYZhU4xq;?bL#c^Mkblu#zOpZkO=%dU2vJGk
zRwGx{fyM6z+mA%lBvz?O^VDa2C@jX|Q<&(JiBdrxS!EUhsrv|$OlEmJd-WAc=xj+;
z5GenazsOvFpXbI*f$e}lR=PM{p9b?nQC^;6V0BD~2zv5k{opmciX;oIGwArs&td}i
zv%YDn8)seE9>}oj2L^iDjXe<DD6xR0(yau!>f8udbS_0xe{nz;X%ZZWj{3P{wT2G$
zo|->Rd013bAu%6t`V=}<qDCJ)1k8pR%OVe;=cWUlGXn<FzczR%&4xcD?ZasOHT{%`
z2UqfBL@>lrwa<llKUb#Jn}s=p>*Ml9Wu`o_R@FD%V<Hz~HDk={z47*)Bx>KZyk^>)
z5B4PvBV#$Ze-i8Luzz|vQ?pX9Rq|2>(&404y@&O!)5iy#3RECTjM*<&Jy+)c;UG}J
z8LYe$LH*VelFKJP3b13hd=Ao<g!%a<m12#-+PWS|cMtDcL^ehvTFYruh;o^}wUBzr
zT1{J<&M@nzvafL_m8+P{;Z9md2or`wPp*mO4YGvVUFo%dWz^x4;{i4zPVpp<tbqX_
z)8EP?JM=X2!EgV>O-c()Q`K^Vh#rp84a!q~UH>#GoM51mfU~9((kKld+C&+WEDZu9
z;y|8Wd?ezr%r5W*yg(l&yZP}v+{XKaVRpUny7;{C6$LDp^4)R%FXiUwqJU0JYO(a9
zw_r?CCUPuuZ7Y5+VLidEcyOjK?i7AP!==SikvV$2+F@t3|K)t+BU9O;dsrl`F@s1_
z2$cU?KY`4aaJdX#cL9nl{&^OJg${oEBb;NshK`l?U6h0Sv^C>6!wx%1Y58D(fA(xL
zzE+dNi~GA%g~@yw_1%RAR!-~bFV)r6U=sEBd1xNTF9%oEOt5a782p^j>7<3>)Nav;
z@&OhLTaHOYHW%I*T-?@LkuUKoM@I2^*q>Na2MWiqddhyd@zA;qZ#dQ7_n<s`YSrE|
z+Wf6}SMh;83$?ENMGQ!4q@+<*?&ji+!eQr;SkB!}KDqPMZDj1US)I;!vGK;UgC4A)
z_>DkJwFQ+$FIRyp-+kc>2{D9=f?r}cI1St<N$h?AFdx{Evj5uD9;E(?d8^gP6?iZ3
zp2HxPlx9%>$31V_#ZYXy+_iK@@W?3FXboZ~{Py@qkoiLt%R&r`t_Dtb<niouNv$)`
zE+%xk{66h8^Ia_;`aEbb3V261`sSBBF-5RtiZl=%Ge0PpjO)0R&AV`myOziLCCu?$
zt5PmTm7C*>5?|@x7d>-<JIQiw6Ov6sO9!tKM8Q(4M*eWx+mgyi3mUsxc8<@TT26MX
zwb5srNs}&|BOZ(jQjg7`{ZN32tE}7OZhN2?C;GfqYU-N>MYKqx8`8RC-@x!Nm_>ym
z-2sOxDyfh*zp!xPP@rX}Lg+Csv(-bTreNs%LSLG0<%v$SLMUGXElRDIn<6?0TpmJ6
z{14%8Rt|bm$e&Kz10fLnh<YhwQjv1E_|S0|;PhEHe?!x=cl$H8-rTJ+&sPV&NJsv$
zA6E*OD)P(j$Od>vJGq34MeRf2meSWTgIMuY8S(|EcO;u1u+^;>s)E^Ss*Av<H0wu4
z>eG#izVwLZIZ$c-IVHD*Q8rh0MsXD-Y(Sf=|D;XkyaK|xoqy#3+{+x1e~~3WMg1%|
zxOAkF+FfaiN`ILI2{f6%N^^~8h{77+<6#Ra_>j(g=xT-}BXbx}oOq3Tx}qlEG;orv
ztVDzUGe1t?Cz|qst-0hVT9eU5>OKofl!ERiX~)O`o&s`|fAj+QF`#av3KsJ!a(6;U
z$?-B52+x;KA0Ceq?N($%oLCqPu#~(~S&-<gWu=L@s3`$kdXTt#sC{_Hc-&EqR0xH?
zRh-!b&(1-)Uc7L_?N%SZET;Iql|yZSwNcd=CazST4<4swC>Bi2h!Y3IF7!-HU(Do9
zmB4K;lyFo|j16%?U_5JAk#B$9{LgAy#j#9?J*)bI?nzKj-{fh0h#|?oUarQg4tDn{
zJKgFOacqwBt+iSRac(>QO5mNFD0bi~hJhSbL~3g=ML?^?K!-W<D>_o8gz16(eInkB
z^qg)mNon-y>G_74Zn|UyT4FwBbYC2K=oK?0i2@46B$O58Pk9CV1eLg-93mxy_!?O$
z!vLs9`0oOzS|C`fj-oQQ(%CH5x`|SWSsaxA!oJXQf<kAZ8}lDV_7f9$i@`kt#lYFp
zu3lnVl)o-xv#~nX@PCFFj|PLG9!e*j*av7;lU^a!I;mi0NDZmw;46^Wk+0$t7^IA_
zzhjgnGpkpQO<{}^kt%ilbyx2v?2g%)ZBzGbcjj%ZNByh9N;2CzefyH}Kph6G2c0vx
zJcW(*b*1u<k~~LE#PKo)@X61%Z_+|2BI(fXgMo!XEO{`l8#&59GGyT%8pW7D*1YN#
zSqlL+67jpyjA`a#o^HlKWGsf6Uk6tvS%G`Rvy;_JvPTK@EvRwkM=Dxc^#eVfbnCbf
zVS{tq^e7oa$TfeQGS_7x5$>VXZ_~n~(P%Pmur4w!Uf(lVllM<@JG=jwpkqsF0A*$+
zxPM!|DQY)m`}crz+mIH9H>j!&b8r}$Kyo2p@Zb(gwB{4nM$1=39WiC>EQ)v=mR0K}
zAU|bd)kYZB?F)K_^>a@oBQ;Q|ArV|;l0k-Sw#7(KX(R5Tsr~k@6@*ClmIQ6Je?yQ8
zmXT4UNu8b^a=NI;G<&M-&wv&JP0tl&_{RzXZ&k>%!wu=cS3!Sl%t<(9<q0}wX0eLC
zIEc52GKRfXV!zEgF$yeTL1b79-!B`uLk2yQ`EmCw$lr`Y`~zU?fUp7V>5h27gBF-0
zQv*8~u`lQq(AK@OgYdup&YyuKJ`uPopE~5^uK;Uz4S>1b6TU6(4}cH2#2W1eQ#eZt
zCW-My<ue#g`CV~@N&U!UCrZ-($(zrEZjr-K#yLMrVjUe-k%SP0;Hi@F{h6f>d-VJy
zT7d*7EdBQt8Ae#81o_o*oiX@xAZVLPt1Vm*_pN5jv}3xm+l!o@)FMG^+f1vFje(ie
z{}ct#!NV*L;ylN#28{R9r`Jg9>zm3R9tAgBy_QN-Chy6}I-=Gg4KqQm_DSUML~H=U
zcni2HlUKO^QDJ~sBK_=@_|w7ykDqL`&kUzbmSOC!fSb3W%-Yj+J26W6bs=ksdcd6u
z1*u8On<}o(G4UqFND|Ds$0ty-fc721itpiAmYMQSPA|xOT?&y;E(?m@=vyiZe9{6T
zD51C%W6m(>BIYha7pI+6RXdU13-zn4GU$bMNIw|4vR_l8NQw+~4&8@6st=oHG8M(n
zH3?{{=3i1uzQ92EmzvT~HQ2@^M@D&7_@@^Wk=9Sy9o0;^Ot#hmcv|j2&a3}sCt^c7
z`nZ~0F?1y*q$Q=H0q@$)Gp+&>m729#4b0zu0fTOb@)V~H1OHRy3UC}qS=oqxS%%Ig
zKyWqx;CqHj3fNE?9BBW;L`yoY0!cJEIXfR@Ro-lTIG4V5&yA2+AVnUje=a_jCBWkZ
zOhU@4fLyjOH&t?_xK#AavR@RsdB;l89gN^SyW79kDYVK>B}x!D829NVAb@jhVhtIU
zUQio^r5YCiap&J-ktdvq+e1bFX#l{Jt4l=lOB)CMD9<L}BYuOCzfAPc%A2Cv6A>qY
z`}eBae`DqT8%g&cz7!6kd4j4F&;K5({$)Uan$iFKW0ok^Qyp=~@9*D@f4jwhFERe7
zZz*OY0mgrD27Ks30#@Wr2>ie7rGH)1|KI0Dqkr(79)M`)Z}`stu$2GtTdL*&{?p_W
z_<L0HKVR8@zmkFD4{%EI_u%w@zOw&*B~B{fEvMzt{@%&_|E}*}*ZU#MJw>fTg#R^X
zV8#E}od4Cs{I5Cx3uyUY@BFVG=6~v)KN0(#ZiQa?@{TZOk|d~Fnz{(~WDMtJNUE66
z9CPq`uw`Jz*3eT6BsrY^-;rFCHYD}5Jp`Tf<fL{gF3C5Op8-tqK>CY~CK>`!7{@zl
zJbEuQ@rd&#=1@uM9BYR$;rqmd*tt0KA)7?77y`^7T<j@3)0Vizf1x|X^WO+?|Mlg+
z-qO=^KV<nQZ%B*y|MG_Th#^JNFVyPSYkqJ1iQ1$AoH`y8M-cDE6+UdTt|Z|?VzRMb
zQ#3#m7Q;s2aeQ$?CS;3ta(SLb=4%^<e3}nG^}I;j3BArB2K=l~M$npcRDDiS2h~@c
zpIVe*N8O#NbT#vvKZBqHhFZ!q#d|TN(njB7-%Jvc_0A7M7+O2`-}9JqM1DFvVabi<
z=XQ60#c4%;AiUv3;W_;G`rto<Vn@5k(_K#feWvo~rNV$RwrQ4%C4uf*ClXV|S|DB&
zVReFz=55@tUHVW4R9QqYKa{@v$lr7zu`fwn4Wm;~m6q)j;mpfCuJeFmr3hhMUH6@h
zS~d?jH5PhUiXzOn31`Ii&;dO11gCmTxU>aLYFu^qN|aPN;}?ElB;lOzCcu9N9bDyD
zBl{~^?yv@6fWvEPRk(kFsQ(@tO(dS~#{B<vH_xy}L13Pyt)1=^run}zD~i$qLlN0*
zyG-vu23_=Cb3y`Lvi#U?s}OZ$ree??g$?*0xfOMbdQk9H<zDnq=zCUebIIApS)`CG
z>2B4gCinP38CQ5#g%Mc$1UZ9^;btW~L>=TOFpE7*5&4G*8SttDfAUI%p0NJ}NPgil
zpJbC05>n*mczELD;s&uSHpbk29>br(UcfQ9tFF3UX09I`hzl++ukUS%u~`uQk-$H}
z%TJz9Nk;_b-{S!~BUqq}nKy@0zvmfajdY-`##sB+%9yb(LI^OF4F%yqB`!SjoV8Gb
zv%$}BTFvyK!+ECR9AW&|l5db=B?H-F^#hen+XJMUxiO_kxNwwZ=ppLADXo?)VJ0h#
zsLnsWmNyhxh6<)(#jJ}qsv^Gk?e8}fNx17^$>@@%+t%jV;+T1n7d7XTb>59uQ*KY*
zXCjfs{U;d@P;<Q5Wqg=Z9%+df^(NtVbwunrDVYe2|Ad-JxB!x3DLW0#g@Hk*BZm1p
z!9pw)4`9p2TEu^3WUdy(1d#>&NN{jhF?XjICk!J?AN2qF4R%tPPl(qd=<gA)3Fzmt
znJ=vz$ix}XHR_`rx`t+ckQdoc5?E=to)h}FSiG6>B92K!g%JqD${uQ&Ea?M-d?PiA
zn~bN$qXxFPV%Lh}a~}tO^7oQCyH`d-t08znFK$OeRZ^T-1d<r+)1%(CActaxKW@oE
z2X=JR)U&GutW*>~6+%DfYuyM&oPW4qr6hy>`Z2SPLjeTFO=GP|Gu^UlmmbN=$|5@f
z(!ZVq>28%_|2&VA{UpKkm0V%CZ6={{;hzrV2I3l=09`!}QdMhO>|JF*EG-=u75vMu
zHM$|{0P?U)Q!j~IG?J>9x7oKgg#d}myd?>ELchV_XUi7)f?I@=$gpGv5yF4c?b|5=
zt^89U^%Ft0<(_5_*Al$$0TXdy8m+h$#Pv&<6gOtp%Pw0fKfecTB5XI!<Bra!{P@Wd
zTb?q22)e(wL_2mE`@%nnR?8q@iu{!#J{;3udyzg-T+uO!q|iE8WxF&a8`-k|Lm#;<
zD;j1}vCAvbBId`_<8lz>fkdn&vVdXiOMxc_Okz8Pw$2t`l(M{7<hZcL94ovwZ<xDW
zAC5~<Ckf8JIt=kRza%witZd0j**vR(<?HxG8QbcJxTJ78w7N!9wI_#;Q63yCsZ$7O
zaJD=A?rSZl7@D&s6`=YRZ8wI3k6&K^B2!TXwe#z%%0}tEXgp#b4t%&pnWxqOi^YQM
z+^Px2Bj_3lfrJBpC3?a=)OJ8O8xk)s>8cKS2v?KFbqoQJ=8w~Ua-C0l;OWHx)(SgH
zm<7c!cBDWVRUwnQbD^)r-~;2r?fvT1=fxyGm=s|-nh%5h!%B2t-D7J<(KB@-f;<ra
zxgUA}FQ33^`u8bIM+BTSTW;ap;X*^H1bgAd8yN|HfSaI40^*c^h*l)E>F6q;rUkaT
z^vHV3bIrLtQ*7gGRrBa~b+*_8IZy*jJ=zdU@Oj}Cd&=2`Yq0rXHa0le6f+)>7V9hQ
zj^`i?@K=(An}kHt7>`C$7E2q{o!c?YKn9QNQ<wyr3~<VQ-5Lm;tV<ZM`$ZX%MtkU9
z;%$(o1hEDCI*kks)$Ob1o5;TBmSR*d&jOAs19Rb8W6IkfJfKRsG><=1ztupRA3F8m
z-1YSInBZ!M5<Qe)LAfHpUHt%>e%KeYS*Zc8;%qbC#<ZV0^3iOL!FkEd%nYwM7t@zy
zvRGR(szQa-28;J)sm>(a`m)v9P1!C9)0;QZsSO{!lt|GC_3e?mdouH8lewoldgWd#
zzJG7mW6h+cRu0EvYB==}Ai2{@0MS}?HafB@wym&Y-VmpG+A9GaJ-_8|E7}u}*<)!H
zj8)DEq?S`AOI&|775UuXB=v=|^GG*U=+*eJXKabw0S!i!_Y#L>9ViIlh_GgBj>s|u
zy(Oq!fU`I4R%Z_B$C!~rrpJRj>)36P!*K{B(VJU)GMQ{DfM1V~71q-eG%+<%5@coU
zKN8FC<kw7frMD8d|HrPrd-C`P>0*DMX}?3CZCs=3M;kT40Mv^VC99u*q<itk#}|hM
z-FPZRD3TU}(+z_&uWIT^3v&Ivi=?wWeV7J+x-czxCf>CQZ0|~RuIJM$rq{!ViW;o+
zzZ}>gJ*1jMyQCB{HK!(${gGF?=#{|P9LD;hdbAHeZ<x7nVjB)}6#qpB+T%{BeoD)8
zM2&<*&l4YSnr2erlFa&|3OIpe$HEvDSyd9J8SSGIyg&;}<%%G}2wR{+KUe!<%i<<^
z395X>8%?%~KUNh8z9_IMgDO|lW2mN$`01#>_0qLAM1bbM#!5g*DARSwWH=T!z^$(|
zhx(j9+g&Lp<b-0p=PbD?hUxM&nlML7(rlnj83!t#x8>cw#zM{%u-lO&bs8Nwq6zmO
zXEJf@r*>*}csmc0$YvUK_J&12I&fudII?8JkVaKVLB@w=exxu-%MN852o_?92u>Eb
zWHl!eABedf3dG2J${W+c17|~3xp*8gm`G5}67!Lywj9ib^syx6O^U6^{r9ZEjGshx
zh#aLZQht0{O-=|jRf0(jvSG6m_rV`pO`$bel8*MuB+-kHbx6E8To7YSWGxf|Mlj{%
z=2~ozW;2!V4mUGuKPEk_GQ20z&pc4}*=~r{-^Hp&^2(&1MEvE0ZLl1rwl6dYA?9%s
z&k(l6-l-VizA?HZ8ppTv27M>`wO7P)DWWcNqsRQ96VsMVkt5k+7r7Sc0Es5MXJTtK
z7m6E+qPZiW71>*;CK+b2k35k{efwTNT97=O8`9IuTlsK=UWun>y_5pNf@tf}M7W>!
zSQW{I+ciwKUM-MXj3j2n$D~NXJUr~4QgN~9O=Uz!=Oz02!B}cWy--uCvm9+i=xs4s
zQ4aND>FJ{$%?^;<UJnJ~62U2fj2khV+&uAGd!<{}e*9qKb>WZzV-XR7l%^=<O8DJ=
zA|A|FML}mm@=(?F3{zQScrth#)$(Ub!5JKSrZ0@A4T=}`YZl^kUsz3*%eV1IBWLd;
zhS0eiKo%xZf$>LTk3j#Tlzpafgg3-OxRR2n#FRU}&hGl>uR$uppRO-cIr5lp`{!!t
zcRk|nf!6dXmXoy?cdjg)5v!~6@86zmjfBrTTNXL5L7v~Dsq7!Sk>IDuW*d@EW*O>2
zH5tQ>a7tHdUhlD&Lw@lZ87V08qa-M+j1=FLoN_MaX^K&!a&DHr-#gu6&KVK9m*BKG
ziSH|ROuE1U&if9wzyJ9GR}HEDkC=RYyP)~0Xn=q?&#z-cGK->Z!o>-<?ZFhodhV;Z
z0OgAlfwZp;ju&54OI(;ewmWZ$!Qj=#Je9(oXW<%AM0~?G=RVkab;xy=bMgKG3~AH!
zCTgWxlCNG*=BqKMrfxdAilVNl>n~U}LhH#Dx{v45T^C!!KTP3ay&ky?v#7uL-CD#L
zGYs><f)z~W-Z0gu<UQdn)oOoCE0ws)giWFsv^!NMcb;RFmMHa}zh~?CO_EF&Z=IDQ
z`iiH_@ALC)EzXi8>BZ=8Sd_$q4(WSBqV!wCN>dDmswEQ6mh*Xj8?H{{iKV3<d7ZA3
zOL38cqlj|PzQ~@JS6g7UZI!PpQ7N1ky+=05maypRE-W11<$MjsSz%5VpQ50YR#_5P
zSG!Tc6xs_Z8VFyhxw%a^)D<RacZ@a@bT7p0{vZj5jt)z3CrFVbv<K3`(WAy525;m3
z6(<#CpP0Sp@J|Hl0ePKAyr<71=iICRtLpf(nrhVkH=c>d;$Azc?*2_fO~~3cskKl?
zT@i+`3cNU9+1lPKsagZ?oB{SyT`=KPzn5akMA$y2kPeB0j4Msa>_T~1o`||?-JqWw
zJFKhM*C=I_KsZ;Y&^#Dxof@pMAB_qZd*C+yJQmK-<~Q%pE|>Z_%zBUp49%!-$*@=i
zoy6ptn+=bB+`Mmnt7=a^4K?jN?3Jio7Gz(5(`>@GZEhg-bE|Uf_WmKCL3f<d1R!<h
zCA5@zpOdR#rR++FJ`1f{-pnVN66wD6YLO0Zf%u7_r&CDQLV1O_pdJafBSYNufsEQ}
zQGl0s=zEY83k5FrSlY+%EIFMLHx1sT<GjRkhKUGbiekBYbZD1omN9OY_wPX^t-&pF
zYJp$`%#f=f)fB<>ipPYQNkE^3wofDTq1xRFbNhCvaFTp!o+tKmt@E;E=EEUkID}2r
z=UO&;1l|aJtY7_(=l7}0!k4^W4(nF4Q^n@n)ZM#pt++<oVc+-4M_A5UyNVt7K@?xD
zNOe;_v#Z;hT2tTki`Hrm5?^Z4uSC8O#PXbC!wJ=#3--=@m)Jd;Dpm{~Iz9X-+UAv6
z3WouvZ-9QyfhDUs;WA911x80D0WC~~gV9I}$^fOItnAArHzOfJJ{O{?Vk|k$Ij-Yq
zoT_-dlJl=9-C)yO&R*XpmYB9Vb1bVfYXXV27IA{Ob7u^FxvRTRZTAO(rZ>&@;^k#&
zLW{YQ-dyEXm~PFxlpZkO!Vu5&+KWk^6b;1hD?@``^(U&=)e{OiHvcwTS`)BpE?o=i
zk+jg3Z63IkZJ%G<`hg&q0(SXq*0@xA4vS^fX4PD)vNedm6?tyL_>L|c;;k!3C~;~)
zZuR`)U{LSl0w7b$6vIo{A-}U78&#fR&4Ko;+`T_o&=py^zY6!tP|W>&UJQfwIWA?+
z#7;r<17>IkLu`*cxJz{Bqa}mD?`|>G3d2_A1EDCPmbSY)KFm(P+@D8BlDW38C4dfH
zj`2FHjrX^xW8W?XN(SE9jwLU9UAj*++w8xUR=C}5nN#KYe*7s9FViz_`k_W@BjaXQ
zWwKn%sx>_~!5G&tf>5wiNjaMv<CbHM%jLj@8t6_@tw_ivt&jzDc`S^TpWw3{&H*}6
z@_Z}}`7N=?7VS|P7oMw_cyGLMQg;S4xS6ssL0<>DdR0=%-nb1Xot^vlK+{74Kva1_
zx%@?^33w|;zdn@Wg3aCc4&IG1H=xo_lPQ$JV(1P-E}8Fb`yH5}qso!LGH-1Qtt#4~
zieBP#K)G;50ILtRPf15sG)Ch4r_FkGE>=wa`H(MXvh&Sj$KJCz#Az`Q!>s)tmQqYL
zG(o{0`f5Pe#wW)**xlI3t<`8pE_C!Ue<<x8W5d$L!GcO(Byq9p(emA*V`oea(*n73
zg<fmw=5U4#pX;IOh~D|`R4yR*90%r~6aynC6J6VZZhookW|7b>Krg2XNFgmJ3SKQa
z&*)Az*R9<~0mlJB#O+fVUmtGvZ17zB`uZkHDzxz4TyBpAz`w*-%<E@28_olidw8J@
zQReft^m55Ruk;3qosEr+NBv)*m`@bQ)f#?-&upX;&lr)<;2o=*(UTb;3B$TLT$0I^
zh{yp>)k7pAiTYRfx{l=2r>IBH9Aw8Mf!+Ye0-jX;$5Hri{ckRhY<F&#H17}POG1un
z52BPnV13_vW+BSD4YNE5@L7P<f<j1!v$mpqcER_)H5H;{I+kL*(EaKH=WK5&gGSIH
z3UhO|aOu8-YQD+}683NscS+wIx#x<0;T&(=l7m!2lED!)T^*1Z$hz4k!zL0^Gn#*k
zF5rF+S=rf}AE+m8vFI%wF<(IKTRD=`_;UUu4vj%1O-(|(?f!x2=KnDERY7g`Z=1o3
z7cEkxKyh~{?(PXeiWY}bDDF~daS8-?C&As_-HQ~r;#S-?@BZc6lik^a{4$edCI@*Y
z&wXF&g?B?6Pn}!3t4cogBMnuM^|W|lF+s;`>p0~v!wr#qj^&l@-`>2NX~@yzr}syT
z-U0op9^Fcy@1B&+j;v9wHrYMAu%AgSmCXA()%Z6}(mL-)-A`8KwT=C=a&JY)mn)vU
zZ_Gdw;ujDq1XaWLrx!gi{g;nrkNQ7E1OK(e!Z)~osJE~G59&=x5xziva+|2e+JuL8
z0Q=C1WWiVCr&YCP9jY!o$+A@D;Kx9dsLnms)Vp#CUhTAxX{)4~YZhHu^;MVC%m)5g
z=QsIH?!5COKZ*~6E%*m8MW?%l7s}^~{STROwBE`?zE>(O*ZlYj*H9HxD=2fETp+is
zvl>#$i<b)xnbr6ZV*+zWk3_<uoARPdp)7Ao;F%u!4dN+&`rdKRi>{&5dOq8IQsj8O
zx0TsYIIy_l;_CW7Rlk-w6K5a-kcW?1w$Sz?1Y~-IJfCrRu*MZf2ExtPW>rf$zr@pT
zyNq-$j}w-OBpN;u`e(K7DUYV{r?SIAJRt;y{W$I7z&$V%vtl)<(VpdbIv{k;W{I|@
zkEHkscL49qo-;<QbQQi3$-lf+ah)fG(3`a+fn^wRtO~F<tKARN+n{84q++&`9<(V1
z;-B`mt15?g?YE&6sVw26I;p)hVc3Vi&P`e=hOy0i`lFPr-<Jb>zOSh?toeOUh3FmB
z(v-&ea6eSUG!zv)e%P9}xxke#AeqCu%(;={*EqcP_uHLFYC_54h~tN+CD83niyf&C
zW*4=K=H~XWcu##dCo8%7#}GWOEDL^*#Le&EDzbid|CwS$27J}gF)!${W;2_OGqGwY
z7Ti>OS<L4D@xDRdVIiBH&&)l!8b{7_u6KyV`Vc2AptbaR`Cpa_gAyne&n+l(t{FoX
z7?Izh`;?a@eK%^okWCp9`mJ~|s!vE>O2z)|5bGa!j1G|b7c{?j=I{N;=}h!-G+H4k
z?!m4B>J){0G^ZTI_9MKI<{@(G@b-C6eegTlujTK8ZoQ=b4|!g-DI<}U%{J>930*ZF
z%D4C5h1e-zr5KifGcJdvW1@@1o|?(?h8=uQO7D)eT(o@qU)H|j0vi#U-=k<Ic0=JY
z1B^d^&U2*KonJc%%)rB#B0e#V_|dTI=Y3AizF8Jny~C}uUd&e@kHnk)C0|3$nbOyS
zpXvLodEo3SU&n3+m8bGht5BB}zMV;WIP=AgVoUUfG`5I(oX+6bvXHs11-om!NVbL3
zCveIMww(`S0rkH{(_Fg{8h)gG4HC-T6*=i_@2NF;zG0rZ5^w<`YVW-t)y6#$m1Ee9
z@MG{kf3horEhoQWH63nB;9Y7SI=?Y!VKIpH56CjQETArp3tpUvX12@`Iq5pOVaw9}
zC+SS|VvzO-ym@=a&dB(~?|z@5c{kPWD5AynLp+6~EaPPlu6XkN2g^~CIU}oazfC2Y
z%@TOV>1=H#JY!8WiTz`Eehj5(>h46AG2JTb=G&G`WK?0|_%w(U5r<jv?pPTnX_oJ`
zp4WNbn+P2ishli-{x^))C?}0uIDI<H{OrmG1H%xO{qYZ{IyCg=ZT(m7tDfH}{ccUo
z6K1XkD7_<B{T>`3Ruh?`v-x3{r=QBIOSFrozfOo2IS}iGFP!|7$nxXI4;q^nIT=~s
zB8LgH&Q8<eI|gPb*;Cu}J&)FlpRdx6{`+#t87n`j2*2C8c179x3j4LtQ@$)MHBf)=
zlsQ#yk9-WQc=5DDjxE*LL)~t4@8n8Z4}8_5uDoB@Aoe9p<+rtLr`ajtt`gXy^!CIl
z@6Y^C>5S&VAA^T4^c|MWtvvHL_sZ%sbGnNszoO2s;UNo)1Waqkgl@XZ$|Kac&+nw(
zUi`*`WAA8v$_>%Af3b%5)(R1ko)%H2+HQQ3*!kX){+k_p4cA_mz4^Z@00OmMC;!`m
zO2`N1@cOsdG7(b;Zt)JQS*-mco$LIUbdf7a>M;VRyTL~zNw1%PY0>574cb-S^A{Cq
z469$XRvT3nI8#&F{8njcOW$YMbeB-=>_xnyjh_3irP~vzTx5xw>zx?GOb!`8aE%$K
zNu)&=>;os-%kY5cwQl9V-<R5w?8`ThrB5&92jlB~qsxs^9T+FVe@vL=lN0X@f)u3T
z@5>Xb{FAOE1El$apQByjhR2#1p1ZX1TzhW9?b~pH>>wVew8#B*j@lBp-fs9)AcSM@
zcpl0uDpV?#0hcOO_`3%1Q<?3tsNHN*8DB0o$w%iY#R|B7TJ2ffFERQAaM*Za(<fDj
zfs6ZgrEJ$W4d=>aiO8nkhcEHJs&a((IJjfLGWA`)U1yDIJm4WLC&Qqcmj?)hL`SMz
zR@F8FnEksI%GA$M>LGGR)Yk`-&Gp#Nb{wgmei9Ur#2&0@r!0}=1jR$#B4TG{?^a#a
zgK27TMNi|!y(3p`;-y`VdxXY;4oC7qRq&KzJHL+iJpI8{7;Mo%;8(-Zw}Lsljz`x4
z(wzhPa}MmV!a~h?%R*w)fJWdB(GLo^D{%R`c)N>7uObgVb<e;rYH*x<t>2TEu-6e|
zhLszI$MrQDrAKTkpF^(UluV_Stl<t*Iq)cTx9`Oe#i^29=&;*l2E|>#bx^Zc*ICro
zwA*#AM7~DDLEHGba);3OT0Ll~J&@w)#GK&+x}~qo`_xDD-BT>Q@u59^j1L!!-^CZE
zR0vMtYs3b*?Sj>YU1{9O__d=Dh%^M4A#8Zdo>Y$lWM9SIr4cz>zhrqyM<IPh6AZ4a
zG`(bZs~k3$oavw~#n+tUP=20ImBw9h_fCm`@tV%HhP3SSJnK?!)Z>j=W4*8_Cg1;!
zsI}Mv+0Hb-pQz3n<{>-XIeq=CKAv~~A`((14IFTDNcal$@)FM2@*jv9&^lh?vswCH
z-<8$3((pIJ`_w1S%-nv{&Z&^hf5O^!x-`eR4?nO!`nY939-eszToZAoUg7e~Z~wRi
z8B*_%BcFEw&Z&6cc<x|W81HdJ_!r%*Wx(Wbs1~%*rT+d1f@}?J{>gMAm;?35x$d{&
z8r4r|eOhKr#w*I$Gx8|a$gHh(S!%d>?XXyz7khg&-XcF$nfCBz*npD!X6=cPLd-?w
z*!Dcmvk$*7LH+?AzFmzEq7cQGCg>M05m3JGJNp@2EZNhn)8q`G_=M0c>?ZiI(X#ee
zB)S)9v7(;uuPmO#`Q?ja^G)FL)wQ7hVx2iv3#~{++;;QR#WL>Dz;_BQJ!@AgstWqX
zgViltGQoU-IV;ISJvD>p8?w}=u01b^oMa-UO|^4$hrvmUH-1F7I_#}0xcGzHBOBqz
z3S!`{<cs{md*yP1yvr5Qn-#g>&}*)eDvzm>l0EC**cM>UyhG{?Y$nqc90;>R?q>eJ
zkS-UFncaw>)aY>Zg-qx^DE`|_5Dq@vI2IFw%V(!&Jh8E}1soJrQvXsNmlm&_>C<s|
z^bGDD+~2dG5YmGDt~p(*H=gq<!GNVxKj_94s;0>iFf6sF^|kHora6MjHE0SS;67lC
zut*sf=N@c<1jP?KnQ+CwvF{ZG+F|#r+~u_GMoUMB(ErU_I;T)!mp`#e1g257%bKxX
z{ZZudn<DRX;L%x+qt^k>zlGh7lAXKZYqqCTpYyB$yg*%T(`AR1Bt(~n8FJW{@s6KA
zG1KRw+dVI@SyqD%M+3ii#dbPhQMQ^?R+A>32NOQf7Z|m938}EFQoz5vU_9f);Z-=J
znjy5irw6#alWr^d&6MW#SEBJuQRSSR`n})qwDB4E&2j_!L+MQt^B6?={tjMGT%wsL
zN2g|4V>M9-#~rnI;;-2a>PL^+KP8gc4C?$`vmsAaR2RKsby#RzJd3QAZ?obNqYaC2
ze5iN0r7)z7c!wcQ>&xq1Sk-J+7J)S79+C9NqCdJxPY7qO!XQoU0$Hf#=52P$SFv9x
zd=C12MK^_Q+4Rj*7!GSq--%x?K7<8NPfGey_|aQ?t~9mkgaBKvkBZK3KHeTRZ#0+l
zell@{j<9QA_;$Rk<K6Exi0{W(z+BR))cgx#8;2Q7n{CdbW-miOGdo@^5(<0#Vf+wz
z4FA{SKiJu6eZDz<L(v`_79p-E5Y?_bu^gLG=t%BMz-Kodn{o2^PmO%7{hc@z*E(g@
z=Z^GXx+%DR|4YhH)&t!1;Fjz*5&Tj#5TU_BC#bMC53<#XG2=3ux^dNShV1MdfZzX8
z)6%MzqT8F)Hi}E)?#)ujc5HtM0aeub7Kw?NvVQEE;Pz{8XSX8`ENW~{w2GbhWltRY
zka)H#eP01FXPGc}zG>eUO>NCf3LE>4cX5lB<U*{g_zD--)u8Rfn*88Da;$Kbf5>dB
z|A!naAxL7N%Qzv|<vgPN#jkcp3ciR~G<6OBi4D+X<O`S8>H)J_5XXTRzD~3vd0mVe
zkZU1hdeOBu@yfYBlg^hjM{&POrW1`pdHXWZof;gLQhoPwl!4+gr|>3pg1x-J!=SZq
zWu>jL<ze$gBYpG4=(mNFyL*u!8zECc<H_@08t?w^Wf+m$qIi+IW88VVigWyL&%L~8
zEU5%D>TY68j!Nij7}6DQ9u6{5j?v*syz#ogR6cTP5D$j}%0ME2s?ufjyQsSs%9)>b
z75i5$72*0sJz7oELK<b=Y6&rtjK-nkiATOtZ%*5ZG=TXE9q4B$Uw+ayyyKG==p!kG
z0tdsyoK`K+eEuw4{rVdTsciSTi^w6~q`D@0p*Puqn(1w6_u#V=W)PKJfAmpIQ@fp#
z?uaoX7w<3l^atv5B13~M!D2^jWCC$oL&!!>?pv4?zjyS>?gC0P7iAv}5i!byT5ih3
z$SCXQ^Ngzn9(`3uE&TkzBu*%2#p&=4Mrq2lj1*ewRfb6^F&X?IYkES}kGfEJbN`_4
zogD<>01hIc^xv^Mxa;}G_>j^e<s-?`8(@hG`kU85PbI~n`Xj-ANld<rckKDOJT7Qn
zz-zvPC7yS2zV42aUico2AO(qO#L+1hONE4+p`L)NJl9CdUuR4zy=N3x%2yBpOw?0(
zcylM*alRUUt0`I#aInqXe#w`+@o11*ftSQ!VSjL%X{bg&FYn-A8ko8=(x~yXcDSmh
zAm$t6s8Rry5=7xtB11U@8MaNc{Wq~($T`z=nR1GV3WX7qZI&q*xT8dr5Yf;a{d}=7
z03Vb+`z7{t2lK*2k|o76rR|3kx*%44IG*ifZ+zDO=yk7e`D21Zu4Q=*3xa?acAt6O
z<iCABT>;OWTr@Z=C@Jr;5gb^AVC)t#h_$;sq2iKl_he8@`X~(`opYMJ?qo-eG!0-|
zX9-|*)Vtf*DpH><b=79p>v|3xY;k{^UlP9?!O!5Tq(VDz&0v*8_wIV*c8Z7Bc7c%1
z=V?B~tTLJSbtuFY)-b(^0+U5|SQ02Ct6Pyy2t{}zS*XzOmN~asgpwW<*8lFfVO0H_
z&Q@>7^LI9GgTam-iHChC-TFB$%(7-Qt0tYlY%Qm+Vu|zn+qY7F@;2x+CVgbQ_z1w~
z1R7d+b7+U`OUMpKa>PB>9~r>U$m0n%Z|nKL?`cTR?F1$S0_JI&vwpYwefM&^;xy>^
z5i7Pk3RW@@U<vkx>2SzX2=l$ElE=-m?E6+?)+UkjoA-;gK=6}9?>*nL_0%JfCW`HK
zlENU>Ky-THR1c&Yp*Si-aADhZ{j4i~TgbL~5Y?F7m}f+SNP%r)wEzdScvy9&OoeAc
zbT3!_m~w1OcVdw#;w3kcb%$wUIEF>EfGqNgtImKshdnzqP2X>ed;G1g$?6Lk7^MJe
zQ<Ipw<iIxC=Hmnfmp9fw@qhrqNKk|$#LixDnH3!2n$4C(no59&WlV<?;a!#=!|x=B
zE|RhkW?(KHVI{*#_|C0!eYD8eh;aa#Qo-_)Ylr6)gk2-HF1C8|NIEI={qD$P6;g?+
zu|OXj85>ijL%HSiu6H&zS6)3+nQ3;lgTrn)j29a{-;rf4%(ZhE8R3ri(sbQ^n^K4G
zbyxs14QeFL?^_JZ@F|mtLmh-zz}u+?-==s3cb)ZJeRoGw5EFW?;WzAJc%86qLf`w$
z72{TqcL#wqB<sS9p9;8(?GcV17>?H-)eNpiny<)hPJV|>^Gs{|$u%>H(l%*5df=GR
zV5m5oACQ)OOatjunR(VJq$O#j1T7`l?wTYIhz!Y&;I!2toNEtwYZ!ql?u(8)FhHuQ
z{Kf$0Gsh_Aof4}Cw@u&jBga<b3~t}RL>yZ)?c2s;`e0yQ=yhRSA7+W>(#2VoHm}(c
z?{VYx$-EK3P(LV}C`L2hX5yLF3{y!59w5bem(JxdPov-Fm!^=!ri_}(;}Gej$?rJA
zY~9k}aqg~apLV$vfA&IDisAE+8S`Kj-c10K!KI!2b~s(T7_mRv6uTBv<r!B%nW2yV
zYT~x>cdKs_+^NYldm>hiFF-$`G$vt{X}DMn^-g((z{_R2@GL#>M;(>G_zvv{y=)kM
zO0~t1f~%cQF5wVchhrb#*Tvx|#8<t3d1GpiekGu}a2;x6wcwA)tn*ftS6>0~p^@ZM
z;=iwNCa1JfD@!Hwg7}9a>~fIdBwnJvcpjf3cvE80#|NCthsGNkY(TXXinI3d0nyOU
zj+kyUkG+TELjgZH@7?*SH~p8XO;)DvO~47l3Q{wg3+^MiXm&8Lo`Q&?lzWTepMyjc
z{6BC1p_~-W_Llh93psxS%6PmBRks*z&)O><sZ9+jHfIXm@+lr5dQMSWJIBBE;wIC7
zT5MC-9B!b4OgTk5(-?pH=XpqmYdey}HeMYO_*$;_^>Hy5D7{|E??&HT^L>7|L>eO*
z!iZIvTz!L8aLXBa@pnu&#}*Pj_XS`@LJml~0SyNaPhmd0JO8lNa@`-f=>Xr!*bp3W
zh6-!!8I(&qs3U?tJFC78-b}TQSrYRPO<j<c>Uy>B0X!OMOUjbD(`c(oFlHO@Xo{Ho
zx=VFM(4|O`J2@IUyiT^|vS8%@OjIU(sU=gOMv_54t628luKhOJ?JcNYjbo`q7PaiC
z<vi4q%8$MtPzA88>hnVdhqz@=)ah@Q@!43?>VmYjEbSk=pEePsHTL6rx2b09=!kX8
z#l7S&N#LG}15J`*_Q*GEEObTHLVEiVzZ$Z<C0TABrrpnj*BzNBBoyD~X^NpvIJXGJ
zrfIY0C=i87CO&Y8Ro~Bj5cb}~?g0mitUozY*5*}m8Y1`Yd|i)WW-2j3mG>Hd@+F5^
zIEb7Kn9QB#PV`0+EB3mUB&K$;p@i4e5^SJ=D6VkwnI1C3q1kVD^;jBDNq&h#o}9MF
z4e$)PB53Q_Q*}z0F~&M)p7=$wTQ~@RRJ>);tYg{zq@ile)UE}Rw;eh#-L*fo@Yna+
z4Ee#{{Z!u)^)#>Jscz(-^Vu%Ju8J>KbDV?vdqtz#g=BqCyWi6=4<su;O`!a;vjx|T
zUkQu(yBQ>=B8G(Uo8E6O37ByQf>|thG?`0Qw9ryapqxzHOx_$`nqG}}!6tg1UT@^b
z79P-Sk|7fMdT)n;%KA1d1{>OW<wFEBAkA`CC0;FzF(xu*wa)}StX9^=km#6MNTU`!
zN0<;<{t)#&A@kh~B(#jG5KWmWdiQ3p*D{`ZbL|x<=OZ4vE<$NFu#8#c^jEc&q6|Uk
zo4%99PXSO6yU|d<t~=K&m|==mt>qKFQZnN^3zeiqt5i3_;9jS)E|mcRy&()F*R2o2
zlW<UIJApSW0A_Y(KYR@Z<v7;aPOECypQrOCS6lK_H1e4qu?kn7CNFT<F$-wadUo>o
zZFxabA<p=88Yf|@Lb9M$CLKDC9Q(!g3qbq<By~j6%y)G&EP=IY!~I9;J<lf(bwse)
z*b#yyC%E~L3TeOmMq1O}IMgLPNegvLa%>ONc-izk*z%SC<KXw~<OGor%mTG|soo(f
zW6$+bTF~9O_q7(lK?APRG_lVT_s8QoqiuD#%v^Fc9SXORDnqGJ9Ei^A9PjsZDC-f-
zYL4=|h$X6i^b7!!{nFX){Y7rj{ylar)6WFE6k}U&dkwYS%2=OrwxFI|`Siohod*g`
zyL5$jtu!mP{Y|i{0Lho2C^CTn=iOnN`Exv@CmEJWYZPA?aOULqn}i3lt^1vAl3P%P
z9C;a)N~V}$@#woKEW?x!MNh_Uh4fb+!f496zB#vH?v`gq9o9!=^HY!nl@j3x>C7}Z
z&ZT90pplFE0d@vSkCgea6O&UOo>$}%iB*4crwHOko_?JDdg!qJ0TKKP$xz6%|5X(w
z3rMBvn-a?Cl8{-98HDYa0CFMUc_?7E>x_k{gVwa!>e*R|8J$w2tmUkj$cy~v`l6si
zA=o)i_&wgfy(UGUQ1Ic1_S)WN>$ew;2Bsd9%bQc87eT?^4RmT6OipxW|J#^7lBDI`
z{EscO+(wsTIgXhke$key2CP9WjY+w3W42+g#g7Qr^#eM6%-&s4cSrHbI%Ric6Z>+p
zzZpkOJQ|~5uF>~+YYi{5m9|Tz7E&cWN72f7FUW>hQKxoOr=!09gsfnVV!;hcG^O^!
zcFcm0ujZghNpJWZmUOn^(a@YkEFe}HAs)-oZ1@@)@um3P&PdV(HTL*-5zmWPd~~&Q
z%gY8L6{K_+Td1?u^y-<cN=?piWMeFqFY^6T76l-#rsl%eph%5Eb!Vh8zfww*k)zaN
zJy}8s@o6MMQV7Eq$SGpCb(_NT+fmvAW7q;vm3?GUZrFsC@9yeKB)OYV#ctHfn6MOU
z-Te)Hw#G`m=?7dq=ICF9Z3Tep*IL^QTG65M@)WAGv{%r`YqgJLiuy|m+>)XXi;^sS
zevBj}n}doW$<I{9TlG2F%;X|SmJO#%{<IzamO|64Hl{S&rftW@l>O!Ej{2Q?^1J0j
zK)d6**!QQ-8>W**NAI<~Jq{zyX#12wLD37;R&>I3#1jPWe0PF)$3Y9|A-q{v;bFbY
z{KE5K;FKs%%NFF%?Jgd8krPff81Iw6y+>|P=DoJza(^WI)2A=DBtaNBxJT1eDpg=>
zoyLG;KRusTe<J68M@mp{eeJP<#HOVmc%R@MWvM?Hm;vKMp@28sfBHtF2NU;-;LbLz
zowrL2>~Q3IL@ZXT6I}*X2Em-wp`j(pokl?0y2;tG`ZD9Uwz4IYLBK!8H&i0IMUQIl
zNTYdzg%jKD$^wCmxbdyUp*O^Z?OWoUhS*nS0zOo@bq$}`)hySvp?k<n1<X!46)ToI
z93r?MJ}_+fC9!tT`g}>x6u)`XLKt!SJ}OIb*0;`8$Zgslexq6A1PGpa0<v!We4=~K
zR^7&Hr}R6zni@@pY=xa4BY)`544$UdSSn4#JJq7sr6zzXYlAKj@K>+fD?)M|oZEu$
zU2;cBrPXpnu?EyL@<_iX*?1y++IS*nmF2d&c$*{AQG%XrJ(ufy)|3aIZOgY0LrVNC
zn9J%o8DE#LG_IIcgH#W-QsQK#@+H&IJR;wmZqF(#$|HHX)4ffrBx%PL^SPx9SBRsN
zd}YncYH{f4iu<48qSJp4Nf>Og{By30na6J$end|N|Ige1omKw%{A(rL1@4+6?|t5H
z{@@~n2bFnVa~D!PoXTP1#$nJL^b8qhI|lLt1O;K6q~VD)KF@jY4B)vInQ@aKX1~)7
zU$Bh@vy1G?e<)|x(EG(buESauEGYtDsL-C+?<|uD{$daCvhA4+E!C;nJyO>9R=Ybd
z(R`NC;Yr$9_utlDj<~|6kix-P?F38@Qv-$?u>yzyDdplo)QlXgxk<`mNWR73@WQMx
zk8mHIJE~;i(d7<R7M3<b<b_GG9PlT1BwyQA*v7YhET&@qns+@iSdl5!I4mdA5e;iH
zI^Xftbm;SP1yLHy_Gt<t>9A;29ka2nIoY?M6KEF;g#iS2+5<UaL~*1HTuo0koy<C`
z^CM}G!S|WaMC30ObJHKX*RC1$%0#x6Kaiw*U2Mh!3IVu<CV+BvHr?S=Zk&uOKj|(0
z-$idKxOnL7FrQGbN;;V2W))`h?YWsVMBfSZhf7s}j}Mqwo_eF7KOpH&d6K4l7V(s?
zaTCc+!(9vW`AI4v>3`crwMf!`u$~!bNQ(Hui6@}nv2nmw*Pls(<kwFwPkUQUeiWig
zNiNpb`=1%c|H%UAgd#PpPL2j+=p^;Mr^kk+PH$Jqtq*xS+H6$q(X_|fy~XybMoSI6
z0A^j`)(V3-kBShZ0~p9TUY%TOL<M;z2uWwjuYFHJ@*Umb!x?D8O~#`~lI-7)Z0I<b
z(0jZsL-6WH&v(GO5C7{;_Z)afE@}aUuC%yKdxHw41pO*sx^_$|e-UIcNQH$4d)`I;
zUSZLMC9-)+w4~jdE+<k!{P+CGL(r0B!|Z)45BmmAZMLr&atl&2%%{(6LwzN#RqH=h
zfxGsD6+V=^**dEdmfj-_);h#GXG%vZ)E0Z5#hhIK#T&99)_oa)Z-~7cTYG)$%z_B7
zqqO6`iS%^PKK1>I(-oP#<Hwa5Kq*z|N(Z3<9}T*gj|^nGfB=}iCM^8N1D^p91^|{_
z>BGA4)I_q|CE7(cz3`c)Pes6@)s12%U)CY8Umk#Q<@>ab2<M$aW}V}c-)-uO_zd`8
z<{GHhO0-YeOXq)*eXbi~H)@oFvzx>=GhEpM7P|@&chPT!70u<<-q;K$u*iwt*W&*4
z+q*{EuJb5EwJSmA1Xo(5q3VP}xFc0ji#R7KZNV3=YM-r2xMg`8VdlRQbxOjWIm!|j
zLvv`2sdhe$f%urb14w6UJi3_m8@$qrt36>}It`M1RVQ3uL^6bYHA`bi#WfhOP1fJB
z8b7CRb1{3Iy$;ALA=sO``>HF``iKB57+*0U2jH+II#55R)v)UEOg0WlW91%~^-%LT
z{%(2DsMQP^ob`B1`}R9OMQSpI3u&sK33_R>^BwBdVaeYK;VYO%#60%wF4%C`FCLgN
zYO&PtP+7RGQ(~(Jml-A|^0wZGfwIFOb1eKb++zMF0lLk9tsQ8Hrch1<g72e<oB~XD
z*)p>;c#s~Va|{F$hF)bK5VN=qB4m=(0-FrYe^M#AMzjXa{ZRpt5DI$t<1f{F#w<ut
zm4QnV7Pl9Y^1iEw-4d4_YG?WgVND|nri$4Fx{VM1#3uXox?LBIXSg#hUG1ae@6!54
z(2`g50wQQ}Myyu)+U7)LvDmGR8TA*SuI#go_PLXTH2jI6++j<8;+0cdFIQic09vyd
zHOqY%MpKD}Il5q-!9@K#fE44gq!Vta9m@R=s6IVnu$b*ER6$jLw%|``XqXqYMIb&;
zx-=$(^GEg0AR*0fEeY#RW~@R{{{!JSBLV}FR}5<SS@?9}3;~?IZ9dPbK9u5C+04Q_
zqjpWAFMNH>20GADikKhGXgs=E1!v8!htu$f3_jzHnN-+Wz0+2|=32Y2Y!$rfsz@pX
zBcxag#3Jl*Mh#)q?54)nNparRD7Vs3y7>E-_XqBwoP-3x|AplYWw!GAbd74BMjGP3
zP-(iovGMMLQq(IUoRG<^I{lwPgjZykbFneIQ?JHS6Rrj7ODr*G-dm}&djlf}5=xr)
zM{c02VW9<&*z8<s7pdW`ODz1E$}54FcskdD(ddepZM!-E?axdP4IMM6I(7Do7{ONg
zkDixj0)W+`Z$5H}Kfaxsew|Qwy1&k?{rs7~<$(Y;2XVt~|Mk1dsRWQUN^};4uzzr+
zA7LHv(f>2JbS264k8o^PI62Mdy<H13)*t{8rP9PfuPYeOa$9gm2-E4KaBcRzE7T0Q
zu!<yav-`W?Tl1%{8+!v@bug`CvJ>Y@4|!m#AqC!UBK><dgVz^ExNDbR-;`wo?HWk7
z`{d4P?rbDZ)yNpj=^MZ7ler#nf$jM}Ys5cW&&WhoH)6rTT)&y<(mzi+vvp?Yya<6Q
zFp@9nRMPI1Lt7%eu|uFrj5}1^EQtqPiUH=j&qi7L{ACRD=Uo2h%=)7f7n}w@T&BZ@
zOO38c3gX4;R?ZbB&tm#?+?S>t;1DsSGj){ZZL^%}xdwT(`1ouvA`Fn?a>`?PxcsL_
zV<ViNNu=$<f9#;X=1*_Qr8C5gBHIjRc_kH~d?17XsWK{+<9FGn3-XG$|8t4-;AVNt
zS@ZTS`(c)tFCG9)=NCg3pXJ$OmVB1u%CPf+?rUi6Y*rV!VTZ}GJ5~M;Od#y)!XjMr
zQm(E~nBI(}*Y^aEWkV7H{Xo$Pym+u*vsZhw&b3r`Q>mca;YI`nm6U>UV{l0YZKtzQ
ziC7Y1IGy^g(pGuByPOfvP{Fo~t%~oU-hUUq-(yoSbWh<nKTk;k%01Nmj(YW+RWrE1
zEfKA{n`MnIriZW~OQZ;DBBly|E^hkd_8s<+!s{eO#$VYo^w{{q%hwgMmoMZJR<R=(
z>R`a1pBr)!e%Q(ZZ?Y+0G2>gnryr>ic#UBp-bmHE6~<}S`@_=FO|<PlNXj3|+m6cs
zI7a9;=vp}(ndJgM%>SDF3ugJxsPo@h=36&X{pb-B?sP`;x=2YlklDIGN=HNC&ysM1
zbqL!RB0^ZUp~V;tVyRSyNWTCwCtZWZX958wMy6x<Z<YOa&SI|Zb!?&`<-EnMA}TjG
zU6f>=Z9caG`v9$(*~+Yxs<ImIml^5iof}1DRcKl$AhPT8*9Aayjb+;iLmr~dCJCK(
z7jv)#0Xaate^y0SBcXau?$kqSkE-p>kll`&g2pr#zcJ`OhyxfeNyIn0<UI1;U*ApZ
zuB*vt^_z}>`k<Ez<eaAq>V^d>(a6F8k+STAk(_3INgDt1OV%;3_vnTacG5qpLNLw(
zzL|}i$#rI6ePmm?{Dy}0!cOSf{&Jg^D;Fk1s@-4Mbv3QUih6u)<n>;s$f)w3Friv$
zTS0-ynSmzhc8YWqBj3sH6ay&m_<6VwGq@U<bWl>_F^`P($+vJ3%jBb_D@@_HfZvu>
zT-CinieXr>Y|1BF?J@Qq%u?<XaY~@J1}F(^dB{g(%E3zu)7nT6P@+%~`;Kq~_+4e0
z#&J&&z}o3pM^evQ6lqoRHo!HC<j;Noz#^HUrQ!G<#~Sj{H?dD+v8ZrCbjL-}7DMz@
z#&Ux!@n}#Kl@-_I<==g6Gs~ljwRYx8qKWpXMg11{L&=?CNZu_v{twcaxvu`*1LTAN
z?mT&(GDGS;q=2xe?_K^dy)dQvdF3{y^(}Wifm|;o5QR5mZjL=l2+Q23D;{$cF7JmQ
z`h^8M{-mYNu6qc$Bo_oNS>tT)3%GM8gPxIrER1vD8h;*eNWFY-=juL;eX^QQfUTK6
z_v9CSB%|CS&-ZT~QRF<Xqo0}wYB-P>yX<#KdGd>RZM4pBR0*A)A4GiRk~oatk9J3Q
z1>K^7flwLEOvn@QgypjqVM#Y|-y`&Q;xyKN{}rjD<63=;rP@cjpygVttCXdaenqVM
z9I_hs817_-c5@Nc67;a_P;QHE5n-RRd`ZeJY=BSzMx>P_8ZVLuD!=;_G7>OX_7XIG
zU*{j*D1<q1$$A#tC!q{bke2_8zi}IYdpKv!Qh%(uQS~NSuh|;AOs@n>!hXJ*ea;U2
z@gH7<M&drUi@B4K_Pg3NYJ}2IEwED=P^D8Th5D^lW;&b;Oq42|zxikVd5hO?R7Hrf
z*K7Q@UPv>^5>y|2ANan~_87`m`)Pwr6I-Wk64#zf&w`B?@WW8v<BFh3Wy`e~SoeuY
zh~%-^Ys)a6XK2fCx#lod0nG&Ob&M!#NUj?j<SQEVvxa+3AI_1e5`l<SL_VOJeu6{|
z2gk`_$ToI&Y0iMxrBg6s4=|pBAl(vX*EfL*J940MQ$vMexy|>YMzfVS09si|0|ajM
z_yNY!_ukbs>*hiWCKR4>HJhpFZ(b7<4%l=3W%$cN>cyAD!Mg{v?u23%RiIrZtucC+
z|0VqJdC&@S>O&Rvu(ftR-5vCl)CtXa%xDb`)cBe>&j$e#!ThD#h8x>7$emqWwolL9
zbsE2z{=<Gd#eG@qM<#|M&J}CsS$75?yc_PjoL_D8mc5N<P-oQR?%8uDZRJL@3Spd$
z4p5Azw^5Q?u6H1q{7JFc^L}3*^hPn2w?vQ<jwIw>?n&c>>#|_rGBS${Yb=}F>Qxwt
zsyZD$J=}<ZMYgY`$M#N6)ZmI;!ZbfWKYrLx$tYnm*w4;U1Sde<tXPBFv3?N#g1Bi%
z_lIN6y#8vbsD=$5En7c1GoW0nfcG%cBF6;}em3b9DLTPQ0{>-X0@GJHIA5GMcG5l&
zuAmAgMF$m2d`{)`ik)jUXgDp1$r1|-yyk-eX9->H5nw7r@S^O6j{TaX$yDrRmG?8<
zsa(l{UC#&GgaKr%fxrMGugdTQ=yN_1T^Yb6Mc9-?=u)c=E(@Q0i^^uAQIGihQ$)xc
zFrU{W*8SH#Kh5{+6`GX3z3v@s4jMBHNT4C8PO;<YnaP6lWaYWb`Wd?BQMcaKo!+Wy
zS@-sZ7%V75$X~Hn(v{77K9YV$53?4nRM`8O`-<v-iO_5eg2`8Yo`<S6ew2b8my87C
z)YR$dGT+}$!K4u-gp*+h_}Nl(0D|iy@oBR*!3H_+zkD7X*+D=?wBsP>QlaJM&pC=f
zfv@`x=(uoJ;_#6bz_oQlRKJ}xlWw}Eo>`@V9JS$>8V<3rIQ(tL*tYrL^^Mku?}(>c
zn@(4UcJ2!+5QTM1#5r}c6qk}q(-8AZx%ykt$?PA}^6KXgDG(a_?qUR~IW;xT@QEQi
zfs<Efw&Mw!n~g)~*X12n)Mcu#W9Jj+5S58ptR3+zXJ974;ca$aHxJ{Q{YYBMY79?*
zTog)}W`W3@g+=!dZa{@GxJuM=^bgi1nVJcyrt87Z!GFnwK;y;#z41@Y{C{lx7`WgE
zyrpUCkEEp-*oG*@7+)ZK5sZ}>S5jm7&eyjI33D+g)k_oUJrleOP;hhOY+Y@{yoj<1
z5jAC}2q&YFE9<_>=de5i)V0&b`_yQ!4s7-!PyO&W!9a4s{H|65M88gt5}*S&r(h?q
zY%JS{yYvyCvd`R~eg=^3;!;NTchqP<c?!sSYZmFk{?e3T0jU8G3;8ByO1mUcJ|wAn
zUYjT@KG&N0sw5w{#~k87r7)^~6JQ@}w3H2t?e^OKbo@>2#b0H<k_Gt*{gOHdJC*<_
zK(}j@iF+s@O4L@{b|pYjpS?+%O79&eDv)K*V;=2*_ILsj_UR1iN^Oh3`3rdm=j&;U
zI>bLaDtHm7K&3!y*t|>kd#~qROyB4G;Ab<zcNp%)YI9neQ={mAqEEf`-T#tOZ26Hy
zJWvE=R2Zrog4CGP`NUky;!+_s?bE|g?SJ?7_sq^#*Zf~()zHl}xS}UU!*y}9{B!3@
z!>>|&!yj+I`&x#SrS_#4+dk7_S;-bgF=S5l(@wnlL`)dE$&;MS=4wbbFPIV6)m`NC
zoBWM}3ZFB5Wo#<4;H!YwsIoMFzmklz1bC{GPHLAS-fReCUG&vt6BiWrO&eKT&gWRw
zzU-1~ek-kX+g77iU3t;@_Qp9vS#$)|SY5^h**D$feR-I-kL-Tox}x%&-~H$pN)t5Y
zFhQKxDxW}ET_)wr4USV`1Op*bMAfF$UhB&Ze=l~Fo87LM+q_@Y0AP~zt7XTIONr?i
z5oHfe+sW*AaO_lNRIC&ynM;?g`7LTv|BuhhO~3UHkhBkr@P3IWJcR>`mpoU9=GO10
z)8>w555F*@YBO+WL&@54uU9pq?FQo1bd<D=Y8qmSE%f!Dle(a7-__6q==oWq2#1qa
z;>hj89~y#z3t?xWu+l&vo@Ym*s4`6|XKV4C`PZx*Xq9yT4;KLAOrh)hU%VxKM{OV6
zPl<kE8-6$wy%I3C@<R>;7AO-J90~+=F%tqBhx-=8mR#%{Yi#Ep7maFddek&u0^WTr
zQK)(}6Xm6{1AQ(mh?uw4%dtdae0AL6b51sv+Ab4eH&_2|4r-vc+#g;_J(K7D0m*^|
z7=jTCkO)@X+MR3{m6v&D`;cV2K6F=;WW$Ms#%VAcCL{G+`6hXP##hi7<`{O=cJG$0
zWdSjFzyiHjA<P;EGD?n*KW0qus3IXFrO%g|T46Ivf}`|Lw&Q+>QHoy_L}A62FoOa(
zTIWXzgX1~3u0BxyLDB9aFP$(D(Ht$ta!v6lwMWBrprGOL7rF6PWFvD23Y6$aVIbxz
zCv%FeT=_{{Hm(5xL8dRwSGKSMY-RCEWDo)ksqmM#k|8hx7Dy906T}9aQ-6Od1>*Uc
zdCe3vQH{nbDPNAsehsU_&#X+Y$sgOik(~ocu9~!mU0GKxPe$ahUX<VS@$FKJfzbDR
zoFkP!<t2U-wtzW&1A)VwD`Q|-IXEnc5SW^?s%4PPK3gxV?!@}D-2To?2l7CIs&3Te
z5)ATinA~jU{-(FumM<v(^YnPxeYR}NL{sD-lh?Nq95ce>wWV)<C`4oI2!J54YqRkl
zOB-p!J=v}rU%T%-x9%xG0cjPWJhmK_P~S)b27Y5CAM2(3yVM{eiCLqk=gDa^i_sq?
zrO0mj-z04+fh}^#bv?@sC)0^hEwy&qVOk-@69H=aM&^|mzmn=pg_GWC>-&k_Nww6U
z7Oi~1wb|D#&5(^g-wHcK@bSL56;eINI1W-G!TKen^4cV35fkL=@$!>BqlF3jMKLo$
zt10yOZoLB$q!$cbuiPj2{;I?Eq$HiitfzNC98Qu!$pmA8l)(vE#2iK{aBq&l)Nm!*
z5a5lHbcU$c-^qK<gU>_EU6pWM0s%FHdHg#HV`Jlso0}rINDkeCDFEyN3T`Gad8Z7B
zacWxVH*pOx<S=SAnH0lbY5FQJLXfIN{?iom4SPPkC@X@wwY9Yv4kuW`;&X~=<)dHE
zmaQkjTe!5Ra%GuhF%D0yy7REUV*jo*MVc!wGptDEvy)R!WaUaq$eME04#gTqrd3Vl
zHSNo{pgEo?Qb&JHp~K1y<Q7lXKOsL`thJdz=KLY0mL;YN*Pas%5Lc4bAGf)sIy7eB
z{WE=hzye~EZNIx#@ssn~y-9aF!nljf?*w9j^gQGaR`Vjppg{SUteo~>h*j;<+)9aj
z62F_5kYJOj39z1(wD=WEADznjV5O|{aO^nbnnF-cT25^i<7lc0o8_wo9_R2~gznJS
zX?wQM3NPh4IrivP4%nq}IoXl>E5+ImyNJn+PM0{+hW@rnG8&`ju?ZhfR{a&)NRk6F
zv>g3TN;T_RK^+B<Gep?<$404-Bnq0?4lj8Q+QUO)cOQMvp>nBuOGqGJlgV299l2b(
z0Lw$r=#&x!p~&HoI7P>I8vpxNxZ&vuo6$R+zF8>ezCskL1D_!JfzH*Tj;YB&2&IUR
z6pLPo3b3l%_cpN(lQA)$*aoAt`-V{`Und(YT<U94%#J%=*947*kKJTxd|^4L#D@vm
zLybWgJ8AWX%^<Ju>hKN?2uVo#REhDR*(_rU1vRC6{BnwUpwwB>S-^m*etgzwubK13
zIlO?pkaKMiJtCl-SCZ)L5_^^r$f}&bHCv}e9=8A%N)M=AegaQfpQoSm1M6&8KugW$
zRQ?0~xpy-Vy98CzGCJFtCh-o~vqZI5Vk%1P8*0vlFYUzn5W;CER(;namd$LJ9i#Gm
zFz(1eKU<6S$}R=stbT82F4I-<WFnP*rES+VAM%cHaq?J-u#)!+;gTD8_-1RsI5$T6
z9jj@OM`GN8(?3dx|E%Z$ZwWM*{UIuxk?2?d=iu_H{GT2F|Byp8qe*Q9UI$-K-Puj3
z?$%nwmZxfhimQQ52U(~vrAz8N91*bC4?MgU=aUU@vKnm!f4~-CSaS>?JZFCF>$UwN
zOGojMmZ-oAg?X``Q^kc{p`=9GiGev@@s7*1o03Y{^E5*NV<$mHjjPVyp{<qF<F4F+
zA(}kIQUD{9>jI~T{YgNK@SGdjEjXv7D~&4bEFVYHT25LZ*caJj&N4*+#qa*zH0$S|
z(VNv~KW(|eb9J>mM9ObOlxe2{!(@ayV)Z%QNPLtASe)SakcN;8yy+2U16w}{P1|Li
z_Y8dFi92xw6E@2hC<-G#MToJ>?S0Q8^iL)Lu<XzLpGIg=@5CZ(w<=Gau(thP_2rUi
z+P_TITuk!(Js-gh!Y3Mi2O=b!W~8uCqD;Fs_LOD8xt*34`#hCfWd`R}U!q202zc;`
z#^VB-fvT!mB!f%+8gu0}9DlG`?f_>&aHhy(it(p3FG%BFGKNG%W-SoCG2GyBW5#_r
zYv?DWDxJ~%LeS-Jv-sG;MXY2>2QnCCf!QLLgtz4@=;y?=yhk9g7-<r-lMG;AE%~ub
z2Ni9q$Xp)t<kFd}bQyDO5X0s~kD>&KXOVq5%)?>RbElhon~EjJAJ?g{CEW9se2-yV
zyO^)+lZo~wUm57~eC7>;C|IS~1qoq8)aNV!j;%|$x1PSLWQIpwAR;0%u8)ypVEIVH
z8}R6{Rs*Vmk$<K<v$@xyYhb+YKqwHV=IYshOgI$Jb9D3ZFU!eCOIUwrTryW~N>map
z@!PAsj9-W{8fm$T=wB%8_v(Jtt`}cq{3?s&AyPe**mAp@+(#RB1%n0;8!y=JQ2Yq)
zc6r_MWSnw;xcUtGA}=q-^>ufbLMD#j!Pt|6PT)@F1dB3kg|B^kNW|T!ASJaXtp#y&
zMpP@q#!{?T?7GAE>sLt?h<`RA2D#&`q$?hwe@uXt*@X*jw?v)HM>-zez%sPsoRMEf
zsegeoYZZ$apd6<e(W2?QnKv>YzU~aGv9pIe(~LhHx7?g(U+=x^gyx1|#@?)Wr<y^U
z<I795HOEl-N@~6J_y#w%Py^|CvSTwJ46Kj%dWfSAQE{KM`0WUr3X~l*W>rHm;Nrc>
zZcuraG=Ns8rT1(uU^TCgULu%XGy$Q_&#!cSrZMeRg<cVUo#hVz6r7n?7{NKA7_15v
zzM}dK2`8SYAa-=J!R4f7VaS;*fE8-fP->vYKcO#}oOGiT23wIOI-CaqYd>G{;~}5r
zFa+y0uEJ0ot&axxT{ai=@Mg0$v2CZjHKwx7;mw}<WA!UWsCPe^N?lbl1l5sP$#{3~
z)5zy>`_jjc?=f$YzVt7RUCNSoFX6&B$^{Or)DW7eG63$yEOc5cIDp^&BjKh8byOL#
z(NnL!?*rJ^a{9K3CWWaIHDKfwNF-R2&pyG*zv}bh0N=CU{)~B}LbPA=pdIuh(tNpb
z%NUZ)_mE<o0G;!=5JvCu(RcUx=?iw}!uoY)@vpd1BoMzLy+%V)5%M3BDHG9yup3;f
z@VaeM{~W*Vf$JX7OEDZCBD<g)c@G-@&=IMjmtOe;pV&%muP$cWwRs%KSpr^7`6Xk-
zhhslCemTLwJ`e!eBSO2c)PV|;)Q>aevK-i>`jsx+J>L{%yv!?YH>!uWdnb!*1B&i%
z$O@Ryx*N`_Y>U*5vQ2{-evB3Rs6r=x6;7tMnar&i#N4)Mc!~`g3x1H@4GcA{dO-wR
zVCtaMLD~IziOQ?r`+BSf>wORdfB}gf-rh6tDFR(dtFqnqVS1rTiK+o4XT5cEx~9%&
zJNw#Jg^|{2vv)RE7BfhAYPvvKwhB-V7adw?p`c6>Qj;&hYdlGxIejS*b&z*xz1N|x
zhx3{%&91VG@KFHXaU&ddm30?rr`I1ziZV;Yp!OC4QFhNt>uaHu=I$oK4~O54KdY@K
zKC_1fOx8QDedb?H<enY%s9$Y%Wnm!`Er0_f({Q)33}N&@rl>cG3ttCEz<!}h3e7aF
zV;~|*Z?li#moi=}+*={4*S}Ew=5?`SO`tj@gFQXc$a59OS@7bS0cx4Id_(HS&lsn*
z8wp(I{g<v%P5jmq3X&YQZYQe~NPjXhi}eGc*+&loL>yWHYc<J!a<&VVl)+9!4i`7J
zp>GPuj991LY}X>m=F2{7i)n}1qrk{6c?=)sqp;VhC0MW0-00S<h98odwnDYqMc_(;
zH|!tt)I<sYv|4ZYYzs*>anvG%GKAd2ny)lZb^!Ea>D*eK6t)j*7f;BY$pHd^G}dLm
zSe14+^W`GEoqdwzYVe@){qUhfV?LZO&1Tnd$1BQ#WHyc&$S7-}M4aPdGs75YDRzti
z(~wCS#^y`jn=G$GwC$<O{<5E{k3Deh$SdfkFN0jVfB_myJ(V5Nbs%H|Pzy8~zd6n%
z3;aVX9jcz)gLTuHDo{?VGtrCcPZA6a!+)P&MPO+gZW<6nJdvU>6pwO)y`3>|03Y@$
z2>Ox{2`XxuHPh65WkpQt=0+@SkK?+S(+MbU(_<MRh{<zJMHlI@qIUGDW3kE}scV@2
z4ned{tCO=EBg0;8sHkmgj0Wipx+NAGqiF(;OaUD=xo5~I7k3u1gVxf(#Njj+a&Zo(
zQ{~9GZ?<2_V4ISGtfcBv+|d>9F4|!MB!EiUngP;Y&o%GC^&)uUzt09?=Hr>WrZ_#a
z)~{om*X5pNAFlHzMDD<l@PfM~gR#sb&`c<CX}6e}F|0W$2h|lC?sc|;BtFz$y#ye~
zUthY&WPk(+n@{%+d()Fw?<@Y#+|l_`h6d*h>ZL1!ftHW?@Z)VB+Tnj8lYi?q|23sh
z6H;>C(AG9dHh)~+F03t~K&K`GFel$U0i?W6(GYlDpFQy`F%7TOgMlo|`9;>H-E?WC
zbjXaRuFF{ZweKsHC<7cZc$;r7c#d00sfUL%XmEBE3$QH3`;|cPH+SJ*82?I?pzYpV
zv$z^Msh3JeDFKaBmwTh|t1({NuQch_-XAGfvBRd3xsRN;_T}+TMom<dK&D*vC8cUE
z+tInX@AqVdNlTX|-{m=hszehvYHF}@x}cStx|dR2NQ*MrA-JR-oa5eEPqW@nNI%IR
z+9H9Cel;42P6<cqD*dlsvq{EwM9!ox;c!$k3rlN?4wH?GJ>T~TAY!?npQB-zcqsCb
z-fQ$6eM~%Z*TQP;T*o{&hnTxu*#G<qEXth<-I^FY48U!(D99X?e0oAd0#7wYk&;0F
z0B0cS;IX6C%NUo{53!W(CPe6{@rZY8;%6)<tq=WAr)aV$e~4T-ZyWfl?)OKGw-4|m
z$RI8`W_p`5J7|tJvr3NlXDG3wj)bDNbV^6BA&EERHm*tC1f^0Ij-+qX{YPWeeq)0o
z;>i*IlpC$eB(N)D34u#TCb2pj-ea}vaqGcbFZB$39)+Gfcj^Y05`bIKogcSUcsunY
zu}KBjBTiIee)W1~2d<rV!UITX9EO7G6~-Nf0l%J0wXVWfIW<t`m>)SG4(3=upFCJ*
zZ8$&hppN!$l6IUUeXX}&^sEF?K!G)=?!{}eZHa!pvNsVHyv4?!TUz}>C7IxM3KNu%
zTN)M4L%sKv4lyL`TIDe#`h|I5tc4+ocrVd!7ax5=gx`k3184%oKZ(Ok6BAu8=<@G>
zud$~5j>g}oDE`W1r96ba<iM4aGMI$|T4{gyK`H9Ttgo5c6<ax;5E0}@1i!kF?RPmB
z-rD1o-jm+g!F5^QFTbT(h|69-gh&R%jZg)*=M<2xR*~Y(%^jGC`K_yJ6|-NfhX{BS
zQvR_+@l@Pr@)3`$59%i>ZyWq)k3CglNE<Bny>>Vf#9ui)-R;RDTg;>(p(+L^9hTr=
z{et~Ka2sr{G+S<pp*?XPx};@4!r4`RjAp&GjY8w|_ZA_6)`}Pbo40hu=-bfxRA;;S
zpUpcMjSt+SAf+g4559{HB&FjE<(sU3xS^cFMpe?`W6FntO9&-Xl=(<Y$$0#-0V=bC
ztWFdaTJ2%P+jU;3?@fpp&AksE(t&}^c3sOi<(wpy=ICVTb`<@#3gj<_tg~*l{m5mk
zsU6|-6^r!s{pzGjDK+^;mDfmia03jv{h}MkjD~W(dDgUi9l*%5x2DeDaz{~nx06}n
zPXshXS6p+1r{SBhUWRSglkLoPAL`j?GTsch>QBPpYKy--vtDy$Q?ArE>8PU^eqX)?
z``Jc>1RmYQ*ZZX?w<2&}!HRWiTtG-PV2FDsf<QunG*f40urduAp5I?GqS;e8d7fw0
zyL*I^nZONnu6pL_gihAu-h6?K@PXU|RjvdWIp#_zee6{~7I7w*yUl@?xZ*Yx?-slx
zk7VyKwx<uYb)SD%%WJ<%m|OW&$*jHW!fOiso+@il4z3S8!{q_tJTi3sFT&n3s_L%c
z_NKeLK|)}Y(jC$%wKrYTARr)}(jn5_DX~du>F(~7mX>aK|JQx4`+3i&=ZwJs`Q{KD
zYppqdbI!6TE62$J?3`YSz1EOgn-k2FVSj+cEtasrimy%n0B%C7aI_!e_qqE_CiJC5
z@?t1~5k2;gRmq)%?r>(jMx(<Tiv2sQgP9-1lW`Q-Bxs$4vth6o2F=bg(kV>pfo><u
z7N0RwE=jBQM^ZinjdGsLinQ-PE+LVOuB{nr34dDTB;%4M?R2Q51O(ajR?j||d(9t-
zXUseBtw^!#;4-bZQK&Iovw_%DBJxFwNgDipc%ShDn3c6Yj>DLjzJ%t_-d_%T>lGT;
zS>x8*&MBJLBS7AC0U<)^=Zlx9Z%=V-`h4oA6MwdCvx<`eS;4-}d!^x|?(?Qb4Z4SH
zWcP$TDt@o_X+)aiFOU1kn{UBqCUPtj@;6KnSTtA)IBv)+?pHS-;JBn*|EUT?<UGa2
zlf>cfmd>><^?iO`zwSt(vF$AC1YTGhU49r(hd0%ftfZ>5KZZ;`1bq+p=wbi~@-0ok
zz8$4jE=`eL$_V>IHQH{rkW1WK)vR(!D`&$}-IH=578`JthFI{2xN)QEGH}@Xm&+SN
z^}gb{%a9A4?B>X1@a$h0l9Na79hcD6;=cxsh|u_zu$Da8Bqr0r+j6n?i4uo|->4eq
z5~Czgy*3B(@-*fN|HXYlO}T^&yE2?#Z-cB?<~fQHpaHg@;6?kVy66~X{$7M=GOHXC
zd^AKV*9un|NB>={)%QS)!nt-6t+expvnuSia~0x$l?OODQEr5TDG537tDal*EB@FT
z?kKs_>DMdPE91|!*0YmFiEop(xOr7{lJ`k;G$(EehB9>xn_yW=f9%*DtE3C~wyT}n
z4oavKB1M_^yvuC#NK%_5<1Hk%U#v}FH*D)VtJ^@|ZDUQF*4*}*3(-r<oLGIpg`j7)
znKXxIi+UCgSt+=9+M{ZBftV^_S6jLwJ5m=}Da$`wjKs(N6`KY+{ESZY_y`X3<vwH<
z0kxih`zJV(1X2`e-?VtRTmO4eX!QNR`oNR82TkkQ#!I=_KgNa}q~rX5%~Sl9SU(*8
ztu0s%9ONL@qB2d`+CbQ1jZ0<2&qe_dTTia=5TAZGHy66?T$~kcU-8%h$S$J4<$fwp
ztKKk<%?=EyKv^H?9VSB(iGJ=IjN*Y@uT%^oUAS^fN-x<*$97y#7<1mil<>%=zIwE4
zACsiK;;7SbADG<S-v}$f136TcWpZ{B#B9CDXYrartT;-OaItOL5sf{RAxXJ7JdY6p
z3s59#q!(85dq8~$HA(DOHgnz-ZAn|5{xYqGyFcCAw>-9w`09}MS*H?5L_|FtScq8e
zF=7Zu>btty0Lj!WZ9<qal9pNxR#>AWd<2U(73Y4sBQbZtE%Q?;x($pfOfE_};fZe`
zvbn_bZ^vwzbAH8a0i<Zhq=>ElaOHBW$LV3I_N!f%iRwY$gaLjuCbSU}j3geb--T+S
zcTiQrBw7~{G&G;rq^EVCJYkGKhE3%1R*oIGkvi6lKPEATA*xWgxjHSbvRGl<HJ^*@
zP_MOO38aBZs;eOcr~K(dzc<K=wjl@=!TdT!$*+^I+$Zf+63C8-w)^#DVHWqJ=Or?m
zh40rCFjMkKx5dhe<5IYAG-*^Q;4<M8y2{>Ss6ebdxbp2!np5ibpj_xLJdjnF&28J5
zwtd*!WR+$<*=W3It1&T2WUS*KBPkp;LSUM<O<0$Y$x7LC_>l}GCD&W`F0c?&8Uzee
z5+B4t5Fb3GFOu-b8>z6GvS{@3#cB<*0sX-8k1HsUwtYLhpSgDB{|7e|%4?c8d0{ic
zE803b>CHVlS(y+o>HD}V1cg&sXg-tD#Y#?*T=XMMlAHt%^Bu83P9`+H+T~_Eje~D*
zkWB_Xcl-()q`vbTrOeQc>ygLq^{qJSpgiiD%n?Fv&b?1LzS}LuBhDW7)IIqll)oH2
z*0+({E&Gfv&pWCZclZ@h2-aRGH(?`uP7|vjXF)2&=QcKOagMGu`qj0+WxSL8ww^@G
z<8V|^-S1eZ#^bX#ZRGwR2@9RlGV_pWz6CoJNVHY;aNl05^Lx_NbTKQQ=9Z%Pf_hio
z`r$T3((YXUr50BTX?F*fTj8?&xxa7l4`xv<J|FE-D)n`G?WoTbt0n|mj+5KLut|m>
zcLr8iVvH`vV@qgn@6}^gc5vzJ)?2=1kpFG1mbk$U*#LqX!GuhS8CED~HaHxPgR!a5
z$Pk|7&a&$H^WeO3H#YBx;#3VKjTIEvGC6GD-r{mQ#mEsH4V_0x=^$`_02x`#Hf&B>
z?G^*N#>UsI`jWqgjCx;*AaB2A$spfQ;xi**oydkn?cpC$i~HeCMyI>>@If{|&T;Bv
zc;@jS%FydXFQ3j9`*Na~E0H>rt@<1M@`?g*f->gJp>u0(VkGRSpIjNXu&a(_h@~r%
zPBuF_Gq(B}{HOFKie2WrKf;m9yQjqf0R1=y!yzrODpt0w-PCt28FAU9mv78FzG{LS
zVdgOUQW-?Ix(6E=^ynSQ<9eu_M^r%`?n(*`)G#`zm62(B`f4WF<<fv+yOM_rt^%t^
zy#R;wPsYmdvq7C2GmY;er1g9uZoAsZ<<Qa(&D@JRH3m+bRF0v6rZ)FN_G~%v>^i%O
z=HGH-fDQ^gtpMP0EPH!~+;KUa$c!(}LYYgia7_K>lbt54IBYyH?V2&DQKU#{Z^%{v
zI0QU?PafyTMWLl5O-|dkw%RB`Uf{g<T?@@IA`*?jnVw#j<kYJ7{T%NA#;Ob2W!Uct
zsBrchzuc>srWY1cGPAPSh_J(t0oj0n+fq3Ylvp--eSM^DyVk<%>FF8q6fW$%6FyW6
zxCZqmv+qngVe(LXxBD@9b(o|jYZSqG)3kvQV1KrhIasn8YBN);hj*n-flt!@IJ(s6
zxMAHJj=M!|Gn~veGVz=ea+s3-<MU>B-KQn4K(qyMi`Ogec($`T@WyP#%HVI(gSioH
zk*;8Ji!CeqR-0cw*JOs9R`fo|zb?2nXpyRvMd`qmJF0{%$=Xr%El-S{W%$T^A=V4?
zC*GdjVY;-f{#D=K<RbC*^vH=_T_klZjwaDXc{G}%LIcs}&2oOwK97%$D6fAo=r~Xj
zeZVBP$)&iG%Xn++nx_}auM;Bs`~H4$=x3eTEv%3eh$K{t9HrCt^J`_|o2+s&`sABH
zFxOxqoFZ4#l_NrVcI~k4iR`d6eQkW&SGqvHmg}2bZlLOdjgX=z6az9>4weZj!{K*-
zAQ?^<goj{`=A2!Z&pN#6&J9IM;?+cwu$!u_r?uT$?9$@Qxxg|&Dp$_JA5<%~bWu?m
zGa%D+UB)9?hj#(GDXs6M^EwOXbFw8f)4?p9gZR__wq&l&Ayu%*SUI`G97&ht36MI+
zrSMuS%*W?yy|5O9S%h4IvrLm3vw@Gh^cJ)^4wU*DesuLBh39(p5pKtVOfV&98~)Y@
zxIgr!dr@s>C)a&)aHKG~e)YO`pY^c}_e2_q_Nd1xRj47B&)RPnLFJ43H}#h5RIqCz
z?1n0YZ)cf;7;?+;WP0|WE5zCtI_n=o|9e*dp{oA#^>4fXPn{(Wic;XYjg{@U{lBaI
zuu9_ZN6@rvrvl1z)esZ9K%YjO7DJySO~3_+ji|$5PJJNuBf{Bnbm&bm2okIn?Ej`5
zqQh2X9_o>p4ojdppYWz241>H2!b!t0`&|G7M&sgc%386FXV!U$QoX@0{||x;Yo`W?
zCN`PSy?<Vr;bMe(fkb}gb63usZXhAej)&_Si9{_T)azl7#nq_j>5dlO)HZECnG&)(
zhjbTHkrX-2g%bRRQiXVZezy7e>-*flbN1K1n3<)?bYi@0)~_(dIj|50*YNia5g*lx
zKAo$SG3Z`qmEPf)5Z*>auyLzH|45n;_JEC}J3;DLJs)ZWRVwSS5@&eXi(J3UDCq8v
z#+fovSxRk?a{4?xpi{OSeqh1=OuFGmg3<Ew@XVo@P9wx?T3tpP1a9<MpNX}2Wv^De
zCeGpd64Av06Kh4?j{iBD3>l^NS0U$HDei^<a1;s3Dis34@UY9#L`Oc@ia=u8NKMT?
zqfO~rFV9H$c+8O!x`nrt0#l%xB_>18?~vOQhBb{0Nsqv1{H|7{j%;lzF&Rb7@rRNH
zVw#I&Qocdj^6+%eZQAJx(8Z-(*e^$`&E+uVvDlx%9s%IRGdH7kGKrQFPd%^E1+5qw
zdBVSTC#$Hux4*qYkJ7zbEhHLUr|7lf2$#$OtAEgQtYRcLvCRbh=Cnt&NbFN3mTt|F
z)mQL7`+DvI>{p*Be?}%qNZ2#TBuOwNWb*EJPP_3>WN7-SVA6O_dnfmjRq-#Fat{-V
z@iQJk6dxuS>b<6;`HeYo=ralfg;U#2<Uwuoz5R|%0xnkM1+DCYbO~j_l(ppnxxITd
zFx$1}oPCKOhvN~;ZB7m=Xvt@FoOgy5=hiYJ>;o8Jl(pc$)c72D)u7Ii2Z&{@VB@Up
zvLxqLimsF?RIu;5=_+D`v)H%rATXi5_FG~?TmIF2%@e*NZ#!3uy6<r<*V?3nb3r<4
z5g;M;-+%t#n4bK)Ez<_z>$z{oj>28_#Q>!n;81OsbMf1}N|{X41J{6WYv(_FIxq5}
zh`P9yc<nNjY3M;#jor6KBxBXiLvTH^&=(JLbTR<TH2U1TO#j{#?ez_1JE=+DyWHpa
za&yH1pn?cl0&ep(_cSr5S|##ExNaxIY=<*aq=j~|gWa<G4izOIEf7hft*b$-CqD_H
zfy?WFfQN{K%sHNT{YNC&VXc)VU#l7o{-zwPRT)-%k&4Em*9vo+#ZIe;R6dzAS@jK*
zlR8&yu>%z<<hcX*LT5M}SQbNZ<4sF$j<3TeNo=1Jy*Lm{fFxd#+oRl=qkF%aWheI(
za5$lWAk|+ErcuGv%1pTHNP~#Kak3j>8jjc7GFDetdkcxk`99?WCFC|Z7+bKy3@Yif
zxulhqm1GzVK%sq^aYwtP2w(1aA)JU>helo|4r&ohi4iPc5MY9bO&6=M^u1()VN{oX
zS`jDl+DuEsNSKzAZiqI!?9UUl{#8cjwe)6XwfNnFidZA$8hB>GZrD<IQm~9=(6Q+#
z;pZWCdwGeUn@WbQqX<6L$XS^aaE(yV1ZkB>lxYwqc2q~-z-vjpLbhY~C-bDVT0NY2
zA3qqr%mA;>05E{j?_VCUiqlzaS`|LZPRIl0oYYA<85@&t{AA&D5M@{bz`zLxv}x*`
z|7tN5OP)(#uD6vQBb#er>BwA!^no-32BG&xbv{XO=^rT1Bt3!K8iX4evf0XH)LvQ9
z7yhM4iJ%x4DvM7Pg;K5P5YyogLn-DK>2@M2z2LAKS77}dDToA;1pY1ojfz?*Hw#m3
zNA-_Zx@ihn{3RlAeCCsOw?rK64k1tNA}*(Ru1DO;vksWw5}x1rZhaok;w~R#1g>Mh
z-mvHoIi*w@{19)!j1PiV-X5$Ql|;SCV>1C?dsXmG4$gX-)xSqarTu7f>Vg!~3USQ8
zgrYI%`wVzM!xz5B{}LGLLOSZ{SLTKB-0F{3*;OLOH%XT4{=6t59QG}pezy2ql-+s>
zQ4$CKg|Hn)P!2$V;|<ZB|2is58rGP4?-`;uXLB0Fz0draH<z_jH~F}q&5>+V(2$-~
zu<3`|Xl<exkCWOSK;IMheH>)LzP&VOAK!Tu3fLSCy806V+-OK*y}EI1bGn9wDd<02
zxbiZ&!+ylX@KH*zWGzI-&IxbT6bVC-5w5`v#rE}aB+2|?HTQ22|LdzTwsi0FivLsu
z;7;$A9P%6e?@F<?xHWZF$Bl@zD)=iJZa+xN_M=&~BBplAd~VsliT&9f%M{!^9YXHI
zvz<9m+mMhHJS2~XsSu`c(doJ#wk{6>2V?VjmjGc=vB5Rd$`!|FDhI4S{f=NJP!gmg
zMfGGHh5R~VtE;46OqUbD0ifq}as7#S<6re1t@k7?kUqzSi{};+3hU8BcxW;CBn*H|
ziZ13`$>Twust8|r3qIp3MkazTkhxPKpG?AZv=z0@UrUReOkE2rq4JZ(kB+34M-6XD
zY!e8BJ`HjFKm}CcH;;uMLUx>|2%;W=f?ajb8?B(<pO=`H&gkKp{kdB&_=8wF;?Sjh
zw)HIwgPjVd(hEM=^hp{&{5=qUHKBs)AWr^4R=S0mj_MhPoNr6#dDIlBWu~eRzJZu4
z9^pk@6i3T3lfZdjUEoI>y2qS~KX(S%1SVEB?Hac~$qXg*<CuVLAR51J{!n5XpQ@aR
z`x8$?rV3>9d$H7QJkK&Ax7_&z<;q|T9Oo$~aUtjZ3L??qiLv7$vj}_dJW^fJN_|o*
z&~Pr<@lIPKk7>+>nWZ1Z?Z_;wHiM~i99!3-)bPAei#?$rivh>iqz`mT#-|Izq9y8i
z5ll!`IbCBWckpmszRK8+CIc$bFjZS{fk3@pUqqjOOX@84`?q?Wml)imy{`b-H9+C2
zyK_10LNytaqa(pgc0|VTx0m%e^W~Z7hWmEk%EFON2>+(pI=^Nt4T5(<#7zMrF3<dX
zmkq9^Bef)z-HkC~IUuBr!OIxEZZJbaZY9>|gKj2w?Kq^q6y!Ml7jv@?Zy7^e-Pd&-
zz#{Dlidg$IzV^67jR4v72C-u&Dh~fm)Qs;X5S7KCI=;_bmpDIFp=lNnj&MyB9<lr0
zyfqfeq1zNXU%5=Xl{X3>l0BJ<QI)D`BH0WhTb}4hTPA;)m`dcS@~%WR)a#J1L{`wn
zBJZV5E`mqYtFeF!+MP$13*U*%S@*mh7Q^E^{JzFsHCjeG{f-l<+>+xjk33-rvi(~{
z3S$@tBwV2Pt+OoXF=poO9k)y+#GYKEqGeCAiI;_cW?E*Lb-jO}A5VvHUTEjZUWf<i
zwONh6nSQd=d4xrx)~=Y;(#i$JrB#hJkld##r;BBBnSbFPL<y<nFispI!`U2*w6PVh
zE!H7i_WL*q!%Z%roj!ZS1VcfuzDefk->*s`y;N((rTP9dC(_ps=7h9hSad~ovwrM+
z61P=qgcM8PlhQMnbWz`TSyr()NV_1WK}mc0Q{#Ch4UIa7g>c*XQhGjGGANqT<L3?t
z5Kx;^O)*#H0Sw`UUnF|fhkcjYv#oJ(3Tdp1(ljtaG3sqHqg5Dy59k-di6i2csgo$$
zc)j$j($r1!rvnR8<jSj+Rg2gkPidZM{5@*$8t`M$I?-H@7i)s%EI^@lt^#tf!dar;
zkVN!wCOe45-zL4OqlK!FVc;mskj6=@AY#?Ym5pN1DuOZSVwL3c@C$-H)cpmy7bAv!
zD+avQ7-2Z10jV|O1z1DJFQpYjLDNJh2Hk2{jc4YydJ;16vGTf~uBKUzss;Q8;4roE
z%=rx$k_F;<F2I^qO=4lWH3--Tj9fD{L>eY{_g%jMEgv9g6dXv(l_tD5xPMT(D&8H&
zrcZ`NGaxz+5M(xge|P0OzyvQ;8vgWhw3(dzynIKvZd3ltYyUexKz-p}eftuV69;!k
z@>dwIy%AP<Yji?h;f|CU2`FSX3(0PDgb#_2e)?AD+^115kdg9Z++cP#-ByeFLmTN6
zO2rZ!q*;I=&lTg9gnYIvR}WF2$6Lh01d&F6j6!Gk_K9KclL>ih)jaq=r24X$j_g=D
zI~^HR<EZOmHH2knsQq$R3>KaV!9<>yls+(Cb!aPOwghKHc>T82^H(<QDw~R;UIWeD
zef_^$EpDUd7@T4zlVtc4F0Ki>PQCYrDH)%hjopCTSc!Vup=Czxmp-rbU!Oz5sl`ed
zlbFHMP<^;^p+-kl%tHveda;3HxI8zkvo1)-;xtnNw}VWl=+q6SqhqQ42&TtB?A{&G
z!nvDCopy#PlqiAG1(HC@D(?F*dX_0(lmDzF<h{vtvgEJTD@BS5qvo+xldx|+9=Mxt
z=xPVauPut4KG)p;Gm-UpKqwW(xk`<7ycPj_P@-4QbvO4@i5!;2Ca$&C`Gjb>-$LTq
zR;)Zzw>Ay~Y-rUqoK_WvFNa;1$g{fLUOjA?BWZ?E9d_x15M&6Xc3;DhqSdmGs;OOy
zzs>$uEW95*!_#}6(!Luf8P*u7b}x-Nt6wnl^7?PQ>dyb>KiR9R|75SO$T|ME3^^Kh
z>LV_hj4nCU4htIS3|^RTma%g??)Y%WZ_xm}o>^lfHwz<NXHr3`=m~EMg*@>zo?9d8
z1i;bEw4I=OyZ}%@@VJP_fJvV)+TERDG@h*%NnuVbEYV!9@>~#MnaM8qK!FxU->B#@
zV}ljnm!d+9VvmkHX`pF^z%)xq5T77Dw**deCLHr6c0@{N%m6ibS<xrdLQCIyOVIuo
zbku{Ita>;l$*={186p{B_daXZc8ZS;p7g?|xmUk1<o$v(<S^aoH#012Ks{@wG?P#S
zCOWkm(NXiM*gtSkDVOj7eM}j%6eb4{XRs*u`W9mNlcnq*HY={H-4O!<E2hv1voL6R
zz^pQzTK9a6t~YLyl=Etp4SVaZ&hB^lZ9G?-OU!LZ$LSFFmc#h_Yj3U=4^|AtJwNPM
z@K8?h>SfIZG4>V7&ljq!j^|J@&ctA67)#%e0U$dvWLvfFw2LOe$x>lho`{$MtI#T#
zSjl%R3_-d-g~_olxawV4K6K!q*@c%U)4{TQXW&axM%N?^#o?^=QXKw6pxN8D+1@us
zcrDDyX*u-YP?`eB!nH72CO*>DJ1_0w(!s{oCgJV@Asp`}c&@#rLVes`-?Xdr(U(;D
z@y!MNI6RI`xys@;U8P_EV@kc&?AfQW^5Vz4gD8^40*4I!_h8W9F>+X`R^QuXIHSjz
z5cK^6yot=0opZB1lMqrd<NL>`FC;!mG?MS%6}WA7%P<)}T!}CV@(BtEgr@-u1u+hl
zAhsv>N^VOGsZNC`o*L)TM>du9eU^`(eLkG?F1<dxbGbfuoZLnreez<OZUDsxCujM*
z`Of^*(PAHpQ?#-o_nyFn_BYUOwRYhrACn`3?`_av4jUC|{&w{v*Po3_9l~`r!b}q^
z=zD{I_$zcso{Cz<1J2#|R#?b6wAufXc*6Lp4;CzhfutJS8MkUM6Kf_SM<sCgjS#mZ
zl62YZLZVwJ`cQ2Mtw{ZwVT0qXX*!Qz<={+{uD$JIVR7G6Dyq+YylcLw>bOFQUjZ4d
zZ&fALm+cm~rm8g_V+=ojFwO-$(N|a$SQ6TdcRX=o1uPZ%Z7THVdZIyi^xvu&kUcaS
zy~w*w3Tk(wBL24hiV5EhEJ_$!>T@GhC56@^NLwdm=*Hy{YaYs{up1S?wrLNTtNgbM
zKrU*vp0vz%=yQ@_hNu~;{YtBxbW8?MaIHCdd!-&+dAD8|G!fWU;I*Bv&2D}hih^w?
z9*zRAoU4Qgxd@gR`yq?4SWRw8gh?&f#OnX(xL5d^*Xd{pgsWcHk3r7+W3rgG^~4JJ
zZzDe_L6q^!l8Y~fO{4ZI3a{;wBp<AAgG;6Ejc6+~dy8E&T>y;<$0iTQ6m=91I$yd5
zb8)TSJ|e=1Sqxp`sx1Ro(~{lfDc#OPj#T5gNEuY))e5=WWl4;sX1iIl=;Y~G)-g%f
zH8pe5l^%hE+3WQbey(Clc1?y%tR<$w!J+S+pNO-o5<|YfMfG8K+R;@6Fx5D%k{zf!
zdQv&I324;-#p3K++wk)ggI1fB7=w<kO*8;3y_%wHcL^NFC7+gR0f4NjPtVWp-2H5Q
zPAgXpXk{CAhdQ+bUL=}@2`|Nd0~E{Pmz#ZH3*p;lj}cJM9;?G@)75uEnV%LTvTDP%
z<^aG=!=&Gp>!4MvOsX_QM~`)zJU%|2f7~5{eo0R=&|Q=*=(494hD9l@3rvB{HaVI7
z8o{(96~Gdp;_Unw&~GmFsD_L&Ksd2ddw+LloiP;8fPbV`W4qqkOq5NpfTwbTvGG;C
z00~=U0q<PV%da?$mUJ}HD>*#;cZ~67R>Lt|2?P<T{oU&~f{nQ8mgWm{9;~NtJ63<c
z%@#UIh4PGy^exq$Za;oI<hz$D9Lwg#AIlaRwr#ihNpvn)waR#XFl7|9*9`|5)31w9
zW;JF!%;s`n+BKUa{^#Hg@h-iXOSkS*rYP_9(+h}5LV!XO*zL*i-!&i)#f}>wvDR8*
z`8B*_M@+y@f|5L8<d@;Sp_uTiPK65K^V$+@Lzi#NAUUNQ(1ZqG>jgcwHc^wgaZzNO
z-bI`IOf={sx48s=#b{jiOz<=&oTW0^I2vE_#`gO$o5yi@T5%IzC5aSBL<Auq(RW%H
zdSMba!-8QexvUb3$9`OAxQGAI#faW9A+%5R8Lc*KmG^@n3P*!YFReT@_LL81Rcb`K
zI901)hwtGgp^hJRMY!b6>*9ngoE6ih?<o&EfRODk%y6r|bhf(N05}DUvBc~RT&6Sm
zS)RRQeUdtZHX~1Qu9%4e0gQ*>IiuFAAC;1amUB8zWqv0hy|^Z1y+#{k`xnh-t1_)T
z0^Verw$h)(KNWw=#QDvA+!dMPx*QG}S+IUe^rW?BH<sJ(kEWBeJDPYhQj2+^>vJ1u
zP$`w~646_o&{KcI+37H{r!rlJs53A4$DrG(`<#ofj`C3r`dRF7a{1+vV*6tD4DUzb
zFn6_6YkS3iyW{>LtP%bps{?&aZB&rUM?K{JU*>2)5p|w=W>Hs5aVJPW50tpp;KygH
zxp9H*D!)&Bmn2l#8U{8!TDGb~8NbrI4WMe(@XI__Ta6etkNja-1n8VLNr)99<|ch+
zM`nSFSfh#ES^(yJu)WYh(iEwzKoSY7YzajuDjrIsO=dbejhfiOp~GXdb-3%<cnb;A
zqbfuKv&s1&X}!nlr)(SvQ{^^?LC4f_-P;ttSS`gEL}8QW0VwF29P1#tIf8#|P)yaY
zAmZ72R#KRTE(4?h6q4LuHT4=Ri1{QbujPSY6-I;neaH66A64QAS_BD6`CfBQ7Jbaf
zLhk&r5bB$v5%&!Z45X}7l}+90=Bjtq+HZl9;yy)9;<Jt-cw*zJih(mkEkrO#r-D{>
zw&@F3BrXG9^vdU$@l`C7T^2-W_i?`tM-C(I9P6>PD)i;&<rBJI|7UDxDM1!7_~0dt
zfg;mr%*PU@)jwtn^)TuFvmb(sE#?|(cr{6jP}ZNu2in(H_4PWB`yCQf2^(Rw=CWNh
z(T%%0sX9en8qW5}(|zSh>CrjS1BgbctYt$@VR$M&C48kt9*T$k0{^9G*&L#v_@<P;
zbo21yWn|(Xu&c)Aa1}C>rsub1w(QYmk4w1hf|n-l`vRhYcPo;K0%}?=ZvAC|s?(3*
zhjiEmE_nBxlczva)|bb5Hh}gd6urJCgfGg<GSsOELDo-XRj`>ZeB<co7+Skttp`Q}
zsplg+Qw?3*W3?W;Bh`PD<`*p)(K3Twsz-wpaPsvS#9@H~-1ni52C4OrJ*kaS{<F6e
z!$a`BIw2};mB9Z-ZYE5!3{l@+fvRTvW{!XASp%%u(lXcQ&BQ*f(6ww8FgamD6EmHQ
z!tG1Z5}c}@HvR^{?TWBym*o!eIOm@IB>wVTd_kGb;*F#@D50WrvVj4Snf+}DWDlQ6
z<8JL#jx5Xrm<kNTFw4L!d*0`{UEUbVh!@xQ97uF#)n04ZQ~`Jy`H^W~or><GVIU8p
z{%?lQCW{P9azW<pekXj_r+mtZ@Pnr37o|u)&mvI{%=U90d3kdV>p>bTSSr%TS3~I5
zK!MB0wM0;?UT@L}e~Ix2i%#XF!`%|8AA7cm4O(AON>=GVY%06!NDi{ugVOoD>yl*+
zN%_5yD1|-;PTt&M;Lz9uDxuBpgP<*5MzT0M)a!nWkk@WerjGeT`!R;>74M2zr)YqW
zNq=neAziQi%8AA2(QZBD*-$<Hqwo2p*5`1u{?*e)xF)-F&}SOj&N3jFG(8(}DKny3
z_$6-%y`K~#mVdp-A7AJC&n7-qYS9%g6E-1hW>~SR#!Zp>j9#$6U4u;zR=T)%vwWzF
z*&#Fz+D_C0t9N@URyclw99~;%J|?mK7Q0608EO-CFj3(xlm6XMU!w?QaYx12<gY7?
ztV~EXWdhb&CY}QR>GR4AP1o*L<x&|Qle)_E7jiW&Lfy~!K{~8qO&#@hRr6bZ;Ob#2
zPQ`0j7#98oEhty427*dP{kPULQLTb8cDlp$(N7^1Z-PEFl!)kpMzkm-$}V;ZJK+v>
z)Udg%(zvaP0UsjVT3lQl(yNfqkTjR@<oW*F-FZ-+BQI_znJXT~Y_r`0J1?jgFS6g3
zRP9|$-$XFiAR(<30wM-E-!~Bv5$OZ9#qM_~*yQ4VB9iB*4GwEUaH*D6A#$XkJ9D(~
zgrt^F_T*YkLT*|}-Trrfzs?CHTJ-`h>D2w@{umLR)EAg5+j*!BpS`rq6Mz`+`i9xg
ztu~|U%-vFLW>Y4p!j#>gN9V**+>t7D@(%9^0kZCGW!8H{aGnFHV)sqD#ZMjee$?`}
zCtW=Qvn3YVxXAM6AqXVFh|uM(Lq56z72;i>JvG}_tDX`s;kHZ1rc`5W@BI=wBK6v@
z_20VhwTNJ;Yabwu-z!QSDuylXn*Fx1>JJK6;YWsLj`-|<49yUS`&48s{76<gN@Ih^
zbtS7`&?;}$u^CQEvNi!8S!($Qi}ta_igN`n<Yk6EhKXOXbq|Kxd=$uL7cN|8esAJi
zzvgYzzNT*al4^l+lPo48*-Yjxi8)GTpBwTQ1Mi*V7y?vJ3-lM*c5Xim-=<?gcpVMG
zmTTWnk2WijqAjxyBMKlQaxi@=e=8L+e+a%D9C=043E2;HA+CxvR7wCf?`e7(%SGo%
zE;Ln<2Z=b7ZC~#{iRI~UY|=I<h3z3whs`ydF3Oe9+Y|PU=DbV(I1oviFV8f7@3iKT
zohhp8nG+<fq;vA=ww*39lChg)JI`lfB#m0!Q_(k!=~ll$)C<2drWhmACX8e`YCM67
zHFZ}Z^~<r<3Q&J%vnRr#enJu2NfAiHX`qzRaPX!Z`SwIPjjIrIs_q>$)_r%GZFsOO
zQ0hUq9V>Y76RiaGhFv$aSM2|9Uvh54{->|Czy$c>9Ntp8;Zd4Bneu;Unf|A4<PR0f
zFXVA!Z`Hdu%kgRC(5TO;W%3r-S|L8bkD~u`HwhB^^g9pJ;cqj;ihS}w!|@zA2b(8Z
zl0m0^wuV&88Gy~gFla5DA{2UbzzPjEk2%wu!e5<nz(Z6y>BMMMS6orBvCkNRgOKFB
znj4Imp}isduX;pK_j_|K8kIrPD=l#v6`<1q*I%qy=|kd@(h*5%V4kx6u|SYm!p%cu
zp;NxxbSJk9O^{RCw)^8`>Eo~;oP37HMAFCVWeuHUZNzdU_BNFT>b3%Y>h`G^nz^!2
z3xg8pb$Z%QBMRcnKC3YwYjfUJ9{`FkP^qeMO{-7}kz_>kc#WQ?_LdbMZ~aZ`<j+YX
zwKJ-ySsx_?#MC1WDB(d=ET@z9IkyzA#4?tI)EHsNxpOTa(Lg!ExV}$M#BA$lQgZBV
zALaM>sp#)A)Oz4r=kmXC;nx<K1zirBt(e6j1WbdF5@``(75nea359zr?1?iWNGy*K
zW!Za;kmFZdPa_N(2TL5>w?WJe@45MP(;O!E<ZPX01C!=KR+@fw+VG6d)Z$&fl#pIF
zc2^Gai-+9eq@<lyUDHxRYHEEIq#0RGnq+4Au95jC+m;FACTu5U7y+vx9PE%V?^~Ur
z<0st<i-0nT7r33h<nM4Bh|{H-j5Y%|CtnV>WRS|7)$0#=J!DUOg1g*Uv^}Qk?X*3K
zZk=cAY`7KUc~E^{pb{VUkk;Q&h|9{w5cO&NeBWDd;2Z`=3X@pT;q5$}z~xaLOvcEP
zT577M8Wfmbv$QPt?NWC+S+evMPbWl@<Pj?eci0`k919GVPT;>N-yd(FL1cD1*Lt*b
z)T+AVl$)i{qe>p@Cj-FNv#}2Fy~>SK1#)KA{CK{5q|NU<{tEYi#Zx~9f5gDB<v#Po
zVeBl|HFA;Gu@+OKqRASFN%W4Aq*^Ogi)*!vI^6IkFl_fQ?3H3hD%0d-Vv#gOg;c&r
zJ)Bn}?PY)~jCn^_JT=wxLt35@iEWj%j<ezZXPfm*Xckh}-fZ2!<sIaOZ0cn=*QAp}
zG^5M?K+68FsM;@E7W-mXmtnmass~QB0t{t1lLo(|_d$~L{~?6l^r-w@X&FP;VSBgp
zyX>DLvD!Yn5IebO^3Dx?-R@QFofgd>3SICSqu5@JZpw3aG1TJfN5yNT%8*l*2kg_~
zP8~m9q27xP1Rz9ZD1?#wYaLrgIFGLgBr&Eh5*N?F?~{!iQ5e&M{2_k7<bW38*?M?1
z4i1tSzgQo6q&A0!rX2C@sNwSl=exhEY+pWi)O>kaC9DxNk=F)kuy!<sf|;oeLW`aQ
z-pAE|AONq_^ft7?R~#Nn#?_fHp4H6iW2^901*{Zzh6_AFLBFr{Tb%mzkKNPjm<NX#
z;+DtW*FX8glux%5bHS9%KC<a=vhJK+$jzwT^Vg*{T)L?34i8Is2MA<mXA?y|+?~^@
zq;h_phw4fpq7mTy#hMKmO~Y`gw_iz?jBehGCo4hA%O>&ZC`w;dbwN{BlOE17zOOu(
z1x6urDh;CMxONy4%V1VIfsl-x{c>GgfxX_qH8Pqauun~3tHe|V7^{4{GPK8Lzzj!7
zH)N|f0u@a~J%8~Q!=|zpxE10`uq^^eFtc&H&t7~wCbk_ZSF0tOPYcj=Dp@+3Iai^t
zeTQ@|><+pu@x0i{3q}o+v>;p!%%1~NJ)?v&T&a!zuYMqKS>jS1F5x*#>kQxeE#R?+
zdB}DPllVAhc+2WFe=K!+=Vm_w5_7eMJWzY@!;;9HH=Gk|pr9h4ya`@^&yg2SAcKpD
zAeN327%-SqnNO>Nh^wwez?vIy#h&{`8Wug0rtNmpTPYwo7Hi{iye6Y<<iuizrjuLI
z&3$?N#m()^!9ClvWP^N7Wn?1rlKYv{zEaVh;E6<rrGq`I2zx$dbSOgp=2Tp|?V<h0
zVTDF1g$l)Enx6a9Oyeu(vY&SE`2dIbh3LqLD#acX^zij`;A$h8vMfC>=s`o%EzgNa
zT8IABZYwx@o^yYok0+ZEH;!gpE+^V!p>CL(n7zOW->T$_@o2V?Lv}g%`4PMJ_u+LH
z$jC$a?nd+1hI~Jonb~&9%jL;c38A=(Ce|dLsf><mhJT~)-8qRN3Ikk~;7ot5ckvIS
zAL_02aU(>kc|I=+IUx$^0`{US&>(18ZWg1xFoO~>Vs7JKut$0SLRC~|B;YMV$ewuB
z7^F_X6xaupO&=;pcb73-GOE7>_>>v9z1-k1pu|TW)ksb3`>@xaWjd?O+odw)W{F=4
zgY<guxeaYHj%P^Xf4!x5EKg}kXkt~ETpgX26?$s+5KPSKIjh#0*B39I)ne($5W4;I
zBa+YYfwgV5!6M$4h}}p*2?A9=*VLKZIdo5g2t?+<zgA61)GtMaI9wmi&Btf5S8bqZ
z<KvO^IesU#`ul8mP5s(L;GvQxm{S!JeMowlS-SBD{M6z`IhNk2lazJelS)4-{fR!G
z4)rIae?_*_LC9I<V6WNQM)ex@a-C1M(WklDcTpqu%^xE4wc_3*X3d|~R=+t<ne(5@
zyjPliH=cb_zgE*aeM#w;ga08*xURT3I{RH>Z3Py^19O(Bdz>DR?{}d(`#5@02HXpg
z{k<{$#E^|M1SEluoWeq}9YomwOq72O%Yq38&yRBkgWqP-K)GOptpA-Z|99I27Dt}p
zYkI{e4rN0^eyn-lZQuR(&@-`mOeVs-q_+*u;Qjd`N<)T~BGSJ1>#W)Lwf3lJ=2nbm
z;g)e>O*E8d3&g0Nt!p;UDbpgvUp`JE$Y=~4JB%ZjeKB7kE>-Hz7mI-J{PE%)2RUgg
z-rDf0q!I0Nkic{3r&mj{k(+IKN_()i8O~ZW+(=F`UW&FFHssI#F?{zH*Ej-4@%t2s
zm}Ae+cgXbZi7W2x@nYutEM}kg1U|kcni_s?;rO=Vtgxb0$;1_Ij7~<k<kt)lv(*%J
z3JB>vG0~=TN|_GaBPz7lH;g=*97(`t4kIy3>zepUQXJe&B732_?Q%Y{=JF;V>bRVu
z+`X#vWA1vC28zd6skG^&#o6fl>gI}ZIiFPkUSXdhJ$<~G2EBQ~LUeicY14fN+RDj#
zStnOCW)oBGHt5G0i~{pRI0((YZpEeqmT>N)Mu!(kSvgF{UB)R2fGf<|L57oIhP@6m
z9mw6*Tf>?Jgf9B1#XChe_LX%0MjT|b#RPLqNl|VT9g+opVyY>Nc`9$s5}y+};)7cF
zSQYC>cHQQDlKR2ZEHj_R?eX4JN>cN2C@!rwb4dxfizcrdet9q0s!+Fm&Et4!p;y;)
zqp=)>Xk=W^a*(*YWcTiBeG5qNh~}Ub_7h%~i0a~wQJARDp%4W|q-wr5VaI-`l!_H{
zAauI@z!Wv_H7-^rS6`Z)QdJJ)tFNz1?Hts8FX{x7$O2mm>2LCJd3h(~&Ng2fmG#cp
z`N-+1+rY9q@$v{HFFumaP)_#bayYB-a5*8KXsw7;lf+^C6<MA*Z*ftl#p4Bz(1gDn
zF!Cmi{a+M1UeATI#C#(Wfd~R1PnP;LI}_j&5BT<v&7Ep>Tz+<E#3r&Tr1!ae6x5^s
zNFGp`l(F$MQ`1VgASf-_oyUJZ@$c<4-*r)vSiV(5(?vB}`Oe?IO~uSg`dJ`7dGWyD
zw^uUw%m3rYk0(gCBs1TR($sZ|FfVu;xJ4JLHooVFa<Hm441c?8Z*V(DA39yo4c+k9
zl?ubAC>9mIT@=eW#Ue^<<&sxG=i>f_vFFp?cUkIIK7F{{U_p%O{fcg%AnSV#3$Bd6
zGgMVdeP<!Ymf2xoKWx$#qQrRgGh^dhxH)5SdyC1Rgo%x!!x->XWZ7=Aim>(F<dm1E
zlc_U>JVONe>zZN?#;e}$%!`kx140rTb)o&?$mFEmF@~iJ`Xue+&5^1~x*#=0$*z;Z
zI*V!2vHNDsh)w_OeHrT3BKJ;D<2~7UF~0)RS~LltEOE8#(LGnajTO0dr3KmF`OiYt
z8#kg}H&16wRUJ9Wg~>K+1Bujo@!_2G;UklFj&AkjIs`;+S?hkjOonZE#Yhh0#!o?H
z0a^2Yv6<D1i-Y1$j7kc3L5Ln^7;qxmTV;rs$<w1Y4Y0pIh--!+VIP#Af!ZD-jPgQ~
zl1Any@0_@gos+liBr`V+LJWm(ryk+O=YEE3f)BVDu1{twF{m#XfH8GVLZI`63zPi(
zyW#8H;aam9H703d(`(vg|Dmcben*DFNJ{1W5y^vT2R$69qP5A{_0Md2$IN2;N~B4N
z>(9!vPbObs()om)OmZ3=b>F&2k7l%`?u|a_5|Z-ei_cZ+OL1f`->jjV&V^p<Tkps<
zm?e{L%lQjuq7k9ZuCTKJhC^N+t1bTKT0mFTLHA%CTDi0q%a$IhvoQ{F?QE!7*oT=u
zbnV&a0<Vh5<g%qYzmx}x#P+{BC&N3NHm}DL<<dwRE2~O%sf8oRU>%D&dqsn?bRI7~
zN{_)BP1{mI$Qp-f5{kC83H?^ikDP}3F%Qd~WumU=orG$j<jm`|dH<VkJoH1BP*Sgr
zJo=EJltMdzLQkD<4=5N!VNr`IBcjn$ngjbu&bCXnMP>78D2(6z!*<6qv{CJ)C$ATb
z{SQvH^z?yoGl|Rn6|p0RHsD&M7r&-)i1%h3XnhA~?A+$W#Kag<v5@1xRnA>7@*ZP9
zYOr4^k&W*4&M?gH35_d4S>_324*R6QClkwXYHZl@<qa;GU}%<zX*g#hO(0vEPH&cf
z4w;nR5ehoG=JW3*s~j*!UDtEJZ}`vIyYq&xYt%k}VWUajb*E+?djXcaHE<UL<vbO;
z6Mgd>eW()9)~+<rCAJyzoJirYf3I$3UxRl`BQnEB1<Z7oTfe@**O~3JD|N)_)ql#i
zZ3NkO<URQ|-bXc@QQ$2!-j>hiWu2_&?#2~0Wnz%U-(^`5MIrYxtD)QALWW#=9omp5
zH)FTUT5zQvXIwC|XUiZXYu?xzIgOvX=?YMWlFa5>{9g)g!&dxWcZaf+P#Y*Ho25%8
z9Vg`!3Am5j8g;DWJsjiDwrL}WGT^N2ORL64+O8Tp<_ox85B~<XS5$mju1#3?<Uc2)
zygv6<Y^6KsH;X^1%vy;<S)!=&ZdUD6v7N5-jF0ZswK)i6wl#dAXN1O^WpHiFrN3UH
zwT(6!WBo|y4ZOCum+AdTOO~Kk_gRwcb}pQL3xw;3;p1P(?x&=xQ#@zi@Xw5H?ayXI
z{L{##-X-AoH7JoT7E+ZtAjyg{CGF{Wb^4y8(XNOgf!j2R-l+9Uh>)wd60yCYP;5kb
zYEzVgM`oJu!_;s3j>kra4HZXB3e~li*23|E8^c#W^zt3jOrH;l`vezQG;Dci0oeCx
z>%1Tw5{Uv`iW15K$bR_50EnNbx#4Y$5`jv#uz%c6%a;eJ`HUOcK&2_(w@O95tp43m
z&!|6*_5S50Zmd}LYppf!bd8DQb{A2(XK%2NXLr08N);wLS*WWA|Nc4G)T&fweuzCo
z*2CF^P`kM%(9n)W?kd?S*b3S_#9R??IHJ{ZI*tC2I-ahJ?i=yj9x{L|U2unGhI&UQ
z4}4<&ZoKuxAeq@A>n9M42vO)*vDu|_kkxQ=^G{LuMiJ!p%|a=qaPzFgJ_RahOK2AN
zd;gfv3WMvbQjQ-VQqbddaTypylAzhj{?W7<dFXslS|5c5n7sJUM<uF+&Te{4GMZ_U
zY_}<@X%alnr@;R+HT^%ICCE_2&5}kh(hOp|THY{Lst=yqss4;KOG5bh#q3SF16VKZ
zlC_xR?h@7TFMS{?E_{Sb(kP#2d>;jQOo-;6F%PixIx(h=USePreLHIsf(lP!b~mWh
zofBR3yHNvbOQAibZmd@N3egB$%Gz;nLGzaUy5BMVmAQ?v?wk|`db5$GWC~HMNbU6M
zsYSg?ed0T8N}cdRRKXpR{hIQaUqR&)c~OnlgLo^sbj(axYP?JJjDd(ID<9ShW0e|6
zsp^L*DRp^d^;!h(XIZm@oIRT_YgP*_es$N;6TUhm&_1{+YWF{TW=kvQBAPM|*zal4
z-$Ra33rNZF9?JzD2?lpd!JA)nGedA86h7a&LAZMnbgAXB96ykGn^?%WB5A*!%2f^v
z7e~lfJ&xi4-1q34d@L5p)v~wGZs|9fC{}sPlvJ6LJ6UWjZBzLOqU!50>_#zp&Hh<M
z9qu6)tX~VILHQZyCR5Yf7A~4Wzgra%b`!?3XwA0fqI?`b@Us)EWMCWr5O*^wnn@{0
zR7w(1k6<Cn0eKyyy`OzLe^OMgvm78yZ+NIH(_cQ$8jC(m9FcNtV3qWA_RtZ;c!;Um
zoU$7~@a&6#IxrhEe8N><%tKed!bXp+v!l^=<A2!d!`pEzF|I7?VoepoCn{Lbj0*9J
zaiYH274ykjYg9FgF6Kq9JjfTr-H$#}i!^8MVoHxYaXTJ<`zEw%pM^D1sC!{??$<3@
zM9Pt?`O!zM%n-}*Zs;rfrK=gfw}O{iKuXKoq75UAn4%uyg4z1gB-cIZA4P)t!!_+~
zoqPgCzGFW0?9Qc_T(Nv_`HY$&4Eo6KJf3M(L#o_dsg6AzN6cbxvXLiue|K5l+i!uW
zzSP*SK$hFQ`LUmb``O7CN^Iv2XMbsPl<8HFVH1t@WAV}6ZDZ}yhU<g*sJ<NDU98LC
zCSC349bG*e6JLGWT^dr##K;OcYTPO%H}=<y^*#>F-UYwTZ`Bp)Qcq21vH3Q4@RjcD
zvnuqFp1r|NFiWDy#Mry@?r|eJuCY#=aE-`EES2!{=XI&XAc!Yb#tz9Ww0pwq(EBVn
zoHCkQ{Ky84|Jr6YFflt}Asba@E=LO`<NPFgvhFSeunB<KYphhEpQO7&|AG=#@on>O
zR}U)>NXY`U=zsQZPhqHKN>_F`g0uAFuCp!Y#1i+u%|^CVOX~aSFn_K9sw#VOCYBXE
zNX1=N`y)`%74#ZO@}8pN4nNuLWN{)e-@<EI|Jhq@`|ZS^mHs3<k?<O`U%g#jv|D&q
z6hFPwrrHz^(>N^%2wAdg&vXwMQr|_YN(=0Ls?NipIy<-ZXHbm4NoLlM*Q>Kt4!I{2
zcX<$D(|;;IRols#i0PdhR;T~lbNkbJDSo3+Ky={`vsdN0Cc(rlhRSI2yf2C8pjdXv
zt$--F<GWBc_m7F1zt&$*Vdh#?@DHbc{502m!}i>nRDDQ;KJ?JRYj9FvcY8D2;ETS3
z#rBlsz1P_&KHX=nQMf)+&zve#E)zvu%tY1nCC!S__;E!@$a(Q*P2%FIN)FlUylAhs
zEHEyrNlqpEovhMubrHs_*L~l*+jYk^ma(`>ma%yJxxj|w#-HnKBiZlQ=gV_f_Es!h
zxm6I#N4sU+_9zjin=Jm&gMH)554bN$?3#hAOKbFrRx#pV{-m~0TkldL+J1)<F}>Fa
zBl5u{plyD+Jr$H!!mM=FwDhxJq>4Y11AyyIQ=9hC-ZqZ#mE4e>N?h&kve||+Bb4%;
zyKlF4n;hT$XwwtA`kk}FNj|t(li#f$U5)<yz{F}p2qAs!IKDlBZM%E4a|3BWanRv4
z_%gg~gTefjGL!9Ve3GRZ8RUd4>aiC{JL<P`rW^-yy44J~ab)!@49$+VzEa89Wz}Vl
zuekj^oQC`^8O~4amU^&^sdJlU-*nT%L(qs=OBkbYe#k@-5l~P--zEX1Ul`uSpvL=z
zw<_`mdGU`GGl0vc*T8!ID<m-*pbpN41<mJdaMZ^bbA0lr{~_cz{2ti=eJG{l%!9>g
zCR5O*1SpXAT4GR2jy)cD*ZO$+tEB+)({k+3&k3>Z2(ICBA@k>7XP<(6fI{4I1c>E^
z=|7|A*#ZSwWk!dIwWX+(!fsj);QrdJ;Om=}8~C8;gXI<j@#z~nxlaoVNi5pOnW=R?
z<H@v^4+)HLahyQV9gnE{8c@FKEXT+gzQnuGZVpiUe>u!gnirB5DZZw}?TzS!lD%3c
z`{Cf><)_-x^5fRnueE@iT}owjpUenU(ooBHJY-fGC4;@YUqgtEa)Ife5<listt|+H
zg9+Zl^^x2^L%Dh#)c#b#R?Cnk3W3j)>??ljl{$GMw>^ak(u)>#O{QOT<7sIPfToBt
zJVl_^1ROyNd3gvk(ogx$p;6^<gP&g{qr*TL^+%GTxQ^yy;bB+OY_7Lc-E^;1Jo~uh
zhZ^!k1mF%fRiillh)E@x(Ri8&zRsxfPPx&l{KR}s%6!eP_rM}<S1s!O5-Wogo#U;y
z%iCg|7Ez!j%jjP`rq>zBknu+=UdH4~=Nj}xid)hSPbEO`J}PC!Z(H6g=*Q8toYck?
z<7I49bVftX?}4{h$tQSyk!l$bl@gSw^es<Xy!*<BiBPtO8inkxv#Y%1*9Cb9m=mo$
zc<hzeQ}x-h&515>+_*{FZn15EM2P!Rj1|F!s8^-lH--NTgf`r!A27{_k(f=#<6`ma
z{CX@I6yq*vFCI?IW3pQ01j{#cGr_<Ozh$}OqUH2dD|-b{)A}L_iW7cJOm@q#xK3r)
z*=-)9x^3i)27{-IugM!Hf9FNy=xPr54<$$-mhPb?%u{+DcC+ASwp}=rgCKRBA)$r^
zS-);)0%aod>k)tUU*5Ci4zD|!&PD&tSUt7o^^Dtg{5;o5@RTOD&v>eI1dcfDB2+lV
zzV~>ah|a34-{2g5_#<AY%0VUGPN93x{@0>~2ia@G`PN2NTVkvN!{3}|WGU;}1^iiF
zGLqjPjAO`(85nejo6nZLbE!Bc!YB<>>!fkdzx+BvV9d{lb-XU5a5s$D6%I5=h|+nY
z-z01&O6Mu7ny(k{5xZAxE_`^{%T=dtQ{uW0LMYG&AMHh#tfAi|^vP4DiIhAZoyFHR
zI#e7gc7o0!J%2xROg&a7de)Ac9S^=l&TJ8L80Wp|>Cn3UCCM5vji7VU%sz0(y>UtZ
z#dae-owwn&g3|eze#lAD`t_rW?GiLkkNE3TN!8nFzjk-j?V)3lw;c)7c;@jaX%ZtV
zD^ZkKV;wWa7Sv4W|K9Vk@nKQQp;;;@<;nt*Iu>w9Q~z@X{Pz#BNN^C#J7uYBg~;OG
z3Pl!H_@yvbQH7MHu>mm7)a-!B=k>HfNqo$r#%d6)&{r{&M%IGV9$j*o-|xaH(=tQc
zbuscIvdI$78uP61kdLkJqq}n=5!-B}M+)I!{leaFyu{5G$&~jv-P5E0c;IC%l(YMG
z_5ZQ=mQitSZPsXn1PBQZ2|<IWumpE4JUE3*aCi4$2@U}Yf)m``HNm~G!YzfnyWO4B
z=bX3uyZ5~P^{@M<8H^em3To`V<k30jLWzMk(Ys&X1Y)nOFIz`bT$*CVHnpx~rH+K8
z8~%`^*+4=wP{b~JmJ;S!JkG=@y4Y&zF>Q`3sy3gt%uh7`Bd7dYoe}w*rJK2e_^1B&
zUizY|FY`TZQ*KfnpGW9N-CK+wR2Sh$P(5xo;|MLGE=KUXQ%MDvf}5ycBQxO(J}IBd
zB5IU|e~d3|pzjFLw}Uq{>s9UcIC0zWQKz(QKkD9x#}dZ93@riS_6zYP;$~v+6x2XF
zWd&^N1ZUL(pefrp-#;8aurb%7AZ^xajZ)GJsa%fY6sMuB^d#pcT*#nZUApCZij@~k
z2t{FzK_gEkn6IJ4JMGUgal#$kK$TVLcwe}#^n{itv{35_mP+ssQ2j9ZRAj^WV44<t
z<4Nz%=X1hFgygq2MlawbQ0X8eJqS@NCOe^N_9O!bAr|-$u{MY@Q)l;>n9p4qwYcIq
zeJQ!6g}3ak3R@**ouD~e7nfFE{spGTQ7_F~)xEhJ#HDk^;}_WijmPOq7#OvN$6Hp7
zjrPz$+vevHdh@9Rax!#Dp-EQ*d<8yTu?CY>UyDO|RPt+-M#Zb1X?g8QkSz19=;5gJ
z9`>e36w^z5{rOxYN+>7dmflBD=UIueSU<witu+ubN^2*H!sQ;4SQg{Amb_F|zKQ#`
z4TP$qRXA!EUywN70LeBXRMd!nzVMCN4!u~bg?&1MqSZC608$!Dnf5#+f$x@P9uAWH
z+=xZYU6T``J@f5ZHf53m=SY;O$nDb^H0dy>etw_iMzClvSzKDYoXnvYjP{j8=*O;*
zGO5?@hzql;i}uo~^3EF;*_k)iDxK1}?@3BD?$6T(Pd0;Wb`hZ!b$W<#rqjBrJrSZv
zev&ijo^Xz;r5e^lowOG1U1LvKX#rcRqAR;0>_on0n(A|Gs?gE%7=Df_%1a1VQZNow
zp=`N8dG>5D-{KtIS$(uHZ3<$pCqgv9ZZ%i3u2pBqyxOywX~R=OuTdABBU>>zy#LL(
zCMDY2=ct3gx&3v1sLQ}s?8P&@{^1^`1!;tNwGRMP?;UbXe9%*bF3$0`m*ZC>L6!dI
z>qhd3N3DN^7odDjw%r)m*1g5JWOYBD99CbiUH`55NQjwp_jjwNF_%}w+^))2A!Xz1
zdrM-$n7MT@0Rjse-0?nw_y{k~Vj%6Bb+wr|JN+rXFP}m~GRDrpphQs=9m15{DBLX~
zJG(1_MAx-18U0E*=hZ5cDZg1;J7dx41A<NkmHCpYiV7kQ<8O8>GTT1)x3$=q!6K1`
z!$1QS`<zlvZZhVF1Tn&!&GMTUVK!48wqdVHEJ|Znn553DM%P1qfOuX#wieQFyFQd+
z_Ny&Wc8p39%uas8+@Q#9j33X4btS=Rhd{z(($Ol;J&9D<$cD1v1e$Hm90ApxY=Asb
zFbMGHM==C$(y6E#wHh4XHiB9+c-|%8edF_B@2z*jAJzC$Cm392+5Y*(P{AZHH~GT$
zMPgsmQojv^;ORk?^>F*@3yzx47nB|eu>4FZtk_IA1L`lbuw@x5?S3D1>9ojluGIR1
zOqX+6DPF`kn%~1^b0^n7tzg_>0C%3<f8m;v$l)a$3DhZ^5;_ms`ALd9Fx=nJ(2=i<
zf=Q!!z0QOa2N+qglTmAw{Xzv=Z_bc?II4o>v<)*=d8)Jbw0ZJOsv|BZ?&?$do9OIq
zKRC?o4c9z5-5rB7&d?TBNZU@)b};gYJUur;P7FbRdzPds(!Sx3wZqwT{>jU)J#PGb
zev(w_?o$;PTpdrPcQ2AeKyu&ffGfq|=QnlCUt>ML{PS=_2f}_r%cPFNm-#O#&Sg-^
z2NL;K3Gw4*0>}_qXLnyR9e*bDt*k_jeEkr;4_I>$=yOTskD+klaPVAg9NA=g(1TSC
z7Bq6<*LMrEb2OHVngHHfCM`VS2P~8VSo#)NtqwsE6FwZ036ayyLyMg&Qb%67O6T6r
zjkk7JYK>OQpM$VyJ|tvjfXS4zB!n8;W2%EcDTC#(!9)}L;d{=lw^TYrHJ|P8Cyyk3
zqW2|V))yhYrO{_FS%igM6L+=^XEZIwBFT(rL+z-FX8L3Bye<bZq`pyKuHHO-cOJTP
zR#<(TPeYQ+@5$tXpEIB(=u=ebH5nx-dE}5L;C0qiAonf!0i?wvmu*g;ras^TsV{|&
z=3eK6=YI5ry8;Q4;Dg`aBr1<ERn&PZF;x<5{mS}~o@WUC@%#UH_xCH=3nXgTqIAsK
zzNE;DiO`(!;yyJ8*2a;61;>Q5)X*%4$sJJ~gtd}yr<nHEO70wW+anoP${|*k25!>2
zdABXS20RPGi{?Bz#6UU=yG{mPW4p2gIEd1Z(g5>iiWwo}D7teXbHlU*$+Yg5?&A@M
zRfnX8_XL42+wYk2XXC~z!?*7&;RNd0D@c!yYjqU#(XhPCgowU(jEK!ueJ;oR;D?e$
z?ZjAYRPJ#4dVsvFd<T@x<ts^zm4Wo~?7Pcr{G1(neQAr~q2Tdjszwax!1|TZBAGKI
zkF)BAfzu+nx7+qK`0$&0eYsC^ZfoS+J84;L-FLOQ_T14(c8XVL=f@y9K4(ggq?BI8
z*W~J$;~ql_@cR`auRCG8en^nP_|af|tOXQBL0=z-mQ0SFs>ob{t`(b?VZqf`#ilW%
z1Cn8dd7eLeWB)#`v@n@I%A-bu|Mi8iWJ4dLl<tjZ7&~c0&M4nr$mgsN?C12#Ir8Y{
zr(iNZ?YB(Y`W!`~bNi}R&EOHw`8o&E<$0y%5byB@YcdEOwEyV6DS;>^o6E7$Grf3v
zgT<H=eYZ-5(+sZh)0MvIuxkFQQ!rAmlPzfc453`88;4*%^?}^vLEuf2SLK-wU(1v0
z4Dk$1K%2Rd<#iv3qKZDZ@8ENU?o*8VuuU=)7X_VYs2;1Hqc9BhDH8Q@SInl2ulI%b
zN@;7Px_WOCbl+pI1km7s0aU8h@JjX(Ku+Fhy}!#mUWXlqj=ApnmrGeXZH`holLlx0
zc=Ti=!Q{0(Os5$>FsWD_>vASMQ>W>czy0&^!?{acbH789W07?-o-ZujS7GOFs(ZR6
zS3w3TGc|=U;@)E$2~MxuYcA-m`dyK0vG>E`yfGv5JucExUYW+Bsi$n;yoNaE6W$z|
zZ#d1AU#Ewdji*Pvp}K@@;sCVR^nO)!6xudkkthPkek8n1Ki^)Af!^nBAd#{C-U8~P
z#O5WkL4?maxnY1NyxFw2Ci2wBCTCIQR+6W7AD(ey)SPSa_MF5{%nq-{W?sg@gke<l
zp~iy!s()-{$XY>GCy%B#Y)G}W>~UPc`Ilx<IetjLIy+vi&HkI$<2C^rK0AjWUmtFM
z9BVR0{l)8A;FY8UnpQ|RROwQ0Qh31P^2@bv*<=s#mPJG^?S{fityPqilFF%1FyH;u
zVyy7qLT=hEPQUUa?q>-SlU><uen#B}sTk@3mD@KV$QPzUL#vfLvG5`{#F7kyjAl*_
zX^)9n=(<&<6Ec)>=&^(Vyg=#JtS4O#I$Y>c8gU{#YwWHerQ&QkE7Bidq*5XQ6tKC$
z8%HZjk%itm0rN3LBJQU+-R?27cQ)<pR2?y%2-~y4^Rznpij{Q;YeHc3ThyVe$igFL
zp7RC)_R)+qmC;S58knAeH<!<@I#|8Y`h^l!Hm8V8+7U(XA=k5_Eq?VF;&vV5+=81f
zbGSP_Y>A<*jUmZp%dB{ct2p;3mkhR+HpTHeW48L3m0wV#7<yJ>b-|{S8Qoi}G*1DG
ziLy-4UdTEf@q#>p7AP(}w0SWZs6^fp-PA?qPbEr8doC&Nn{$Gtry58+9i}&pSlsw>
zSg9Nv#NHV^^#0~{(udW2g%fXnJzO>4tx(Kaz2gbu);Dct*J0zpn{u6w>P>YUXj;4@
zJc+)9J2RPQ_dFqRKVdrW!zDI7uj8%evJjq1wkVMid{@fA9M{Oq&P@CB=g%O8u@K-~
zvC5e8764!JweCf5Xe6XuQdv3HK5=x*?G&zRcI7zP_81U=F&mTU;NPAo9?KYKCL{Z_
zHJ&db^7;AqL^kbn3#`Y|EpEqan~Y!$BY<roA0f)m&#$2zy;^NCnFqWfg-JQ2QUcbH
ze8vL?Y7b&uHfGim<XhN3qvPXmo7=yCo56hp|Ka->$|*$@Bl;;enygh*bPCX&12rCl
zN@PyACv&am8}c2t3x=vD-mD`+nOf2TEb7*f=FHuS>uXk1K~nFFH$L6W_c}SNE;Usk
zpy@z<aCOwr1dWMbo5+U0-QAd}F3j)w(C<<jhtbEf>(SW`_l^i4%1v<a$<g*er^E_T
z&R33@sWvN_gC@gAenU-K#?EHVPb;Py4!}p|<k(o`18Jwtl?eB_2<_|G^j?J~rCR3~
zTf;R}@H`cD7#-bF^HshWQvs*l_k=qUMWKApv~NJSM5E7|A)<}Yj>Elql1{m~z^nNh
zgXnwh(-*4NU@wnWDdL&xs@YQL3$8e5p*M|PEAyV}Tq<z#o8Sw=@ysi^dT(p{TQN=s
zowLG}$~e2lQ#G<f^X{64(CGJrv?$D79v&vSQmg&)`HG$S%7+=_O9?ct`V1CrPxZJ=
z?y#@c7YF-#2g(<W!wG4BrLc$_80gS#mpb}ry8O_n)Gyg%G*n?fnqWwLXU2Ye3iENk
zRdp56yhp`WNGEDEcy;sBWT&QDRFvu7420%(vr`ddo9D84ezJ_GmxgjvMK%Okrh%z^
zU_EDHkeTb#*@sgFJH$gRGOW56+*_wF*0GEG9M$_)RN@(@1LP3{=D^9<(?g<Ur!41V
zi}yE^dv4_?g;IF^qZR`ThaN3Ko;ejk;&X*7JcamR6lLFQlhXU<<Q=YfW|nn^jKzt&
z;*kDR-ko`l>Vjm(^TTSs>+Vh|dcy%S7)`3tdEHA*Ha4-@;!wiz$>p3GDD-TiKs~&{
z$xX7JYZ|Yv@x8$itSXThAyu|~kxPp17}sf(JQpMG#iy|Pb$u!AIiX-@C>}e50|l>e
z{Y~%z?BZsDNzQteh}v4Yq^+%!4j!P8h$(%9Pp25v0WZ<N>^Ki7*|LRF;~;^>#PaC@
zaIzDK-U&it_Gc1)K#TpUtZzpBOIcq44ggR2i235r1pe=I-HdYBV`IO{EA6t#$E-*P
zuT<f!fXvNG{Yjow{a!M9sNPFll25(XEab2I=-*J^v8NdQiVq@rwsNH0R&Wik+1@dB
z^bG`E+Pl}`;+pP`fl<U<@UW^<mbvHDgD8qbIsK#FBY`b2UlW*YY7uDK9%?*ixLD_9
zSab{)Wv_*!71H9vA#XRO8KxiR>%l!i*M2^*vDf&jDRs7?6-R6o2+GY|68diiO8gkj
z^A(iZdV26WBO24ix2e<7V@9^wE4}tKXb}C$>U)FlDr4P`)FhyS0!RF+HjN*0)mURw
zo&+4yAN1}n3o-FQqGosrdNQ)dgY~Kmq$68stXi?L#3!vg>4czKG2}%JX+kp&f%CB)
zn;;u>j3XoGeAIhlwA>L3OaD*EtRS$H)HE8ul2UH+{uC#cDpku#jbh}NM&#Y8@)YOY
z1yNPkr!H=0tyZ(_+)i6riC(QL#WUmgDG!y4T;K1}u!|S1fFTvS7%nbH9|AR@P<9Hr
zKGau%5V${1XSbq~PODb$vsKD86mAOjAiGfHug2>_(OeF$jr1<z^Y604@SV#qz;i=V
z@gOOxsp&NZl*BTr2&W%qr&S({(C2(ROH!AnCqeE64Ury@`nj>8lxB$$`kX`K+}NhO
zdTnk-PK)^GYdkJzep1-yapTYUQsB2`oxwQKb;B3y$C-0(_Uimi8yl}W)t)Y`z|tZ;
z-Bb)Jqh`EJPqlv$<hD<X$_-`5$5%i6tjNxH?Tca#wk#M7D5++s{*9!-b!YqFbylFB
ztDa@P%EDfK?V;8myqpqr0A7h2<3PT=UY9vMEjg95Lp<x*w=u(9enBGd5p446{NO<T
z5xq&tySMdXS}AGcRWOLxW&*wwU80Fbt=AWN`F8?5x2{<xr;=OIFyvn(LyvJftsosX
z);rOO(dnp#bC=iV3D2lbGOT$CgKZd-#(YW4D#%&t7ZC=L;lUJXMAN<fond=Nw={nH
zx*Ac}qrYyu;l`)kbTh$f4kj|(WomRTt?~I-D%mxIGSk{sl9{<mn!MBYs--&Fz?o_>
zOpT{11<I1z-M#qsJwQQN*r+dd#K5Q`WTx6;dsamS97S=OY>>P33=fpmHz;xDaEK6{
zskI>m&L0ewif2qAe;64Qvf|M6KrZiV9Oj@kK9BQGIuVyWZO&VQ=Zr+?M4VCj3Qz-&
zK>u-^SFa?1f2(w4lH2Ddr=Wl=V%LT(Eq(N|$L_wJ3$?;(BIft}mLd=$4}68}L(en9
zF=hY{@{_XOD~M+V?{0xnKd6Z}SlHc*NyfTWqXETr=)k6k=OzuMLh*{A2)<kwi%Kx0
z+mwZb3Doj!FTKdu_FU{2lPCBqiO-GZ&`k~ppWKm9&=Uvpba|Fc*oZACE(WgXY;~Vr
zT&~ua`XMEJ5*+$E_vNVUqeyb#=r(UX;v*Hq&WzJ)IwiUiId#3N&}`{Rg5ceJVl*tz
z11@GIfFNR8e9w2mQ?1G_$G|Nky_tkKsfh@5fzYX@12y9s<usJhp~_h`A!i<(H(F9{
zlZ$fM471LK<c}BkdWRIC^my_6S0*s+C6mYz<uDq;au8!|-zrZ{m1^p(L{c$Q!VYCf
zn#D!-5?4_90t$Yq_L>Ra6SSl2SX|y*Oq%yt_joAJZ9(*`d+m1GSI2DLpOxz5A9~Bi
z@q2;Kum;a3IPa`>2XS^*5R34CHL!beK9zyo#G)U!fpBDjRPK`yE6S(8Ti1VFWIYDJ
zd}}!(3~LZeZS$nd8D3<?J&uPafIXb2-dSXOh=m@!vb5->M_HoWsAjp`mGPG9GvdNt
z)P9(5=iQlF{v0mMt(K%-wovVP_2v&Y?-8dYWS?mym6jb12<49?ef3wa5!z7l%w-6%
z9eq*%AR_H4B2O8f2EtqZIn>k+;b9!h@L{AyE-K=6jbc-iQaj}hExFr2d{Cgpo6DSS
zw@SZy)f1IS<g0rYF!Gdt5kbjbrLI5~AYBp$btI^ITN&JSjOIWmq@&Vk<g^?QuQjE?
z@SCl+pn<jc#GLI+%OGQrWPx}wiyU%?#_JR)@K-wXe=evz^=v#|Qn4$H{+W-G;QvWM
zZFMT+N{)ZcemL5|yKvUxekKbkHR6&KDBRncUbN|p6Kys$1GukE4N}nKzo3#|KT#Li
z^Rg2-YBlOWx;I#D7N19E&GVph6|W0ns{|79hyra+M|Yx4VlL}}vXc_#`R%0l20(8A
zHKbG9ydOWQP^@7e1<&t?i0lJc73mR9SUd395?But-feHew+q5J-LfYu;n{SP!+xT4
z`TUJer(1D{`&aH|N#8h)FDnF15F8ZmeI-KNe>TJD_i@2Xpr2_p?9r%Wn13hg(KHYA
zAV*=8$o~e=iTntmMpfx)493g_*%b-*%ps8#_06q!t8aJoh-!5RPn((F-n~m~S$iH>
z$rFQwrRwHpoUQnzDPJ_@M!E1gjIr-oUZra0W>0<6$>R6zs(V8uQCn~JR|p?1tYF%H
z>b&0VZAmsi&wT3m816^MhM7TmNLL2ukSnKtqXta;;tpj+*}j*9>oTSMs^83GheWxW
zESZLuY;$BgAD@Z`C?1ise(r=+SW}rI3IH_V0sXoM)C1lH#B)Wv44O4ramAWnZHBZ8
zY}BzJlBt#?dt05Y&>NMRAYL;XTYqh0=RL0EEOIV!xrvg#bvh$i3`vkZ_Tl0LA0>+<
z&u3<#&OEZl3f^ZwH`J)Q8$IqJuMd6-5ZG^I3V4V3(OsEH%;(|$RTrUtv@WZgacmOP
z;O$X<Exu|Vj1Jy(8mJ}DG`-)$%!Nbpbs{R<sD@b65{L^|9(ZdXa};ab){YrSmiB}>
z7fO{nJ8w^f0~NcR0?j(xHvrO|y}3Y)kL*AK>j%rO_?F}HN1)O|kBJf)lqGR@M~jnj
zSyl()YwJ}qF@xQSC>Ma=7pS#3x+|M$h?`Eaxo6&g0o_6YX?rv?udybH9wH=ib!Dfd
z#kUt1hU@1K_!BY}OrQL@>3JUj^IG8?4ZwPTA?ZO;UxEGqt1<W_$c>F@2W^UyjU>|t
zVL{&Tz5@Qk{oPPZIW%!kG=L$u6g(0#7!Rd@7k@(<>atcT3dL$otJu+k)C!XnXn<bg
z9m0l=-e$C~lbdaAjX7=%$gH|kxl!qC^{s7oxq0Q&HEKiq_C>zFKXklN#I?ex7rNiW
z$YzPpgr-Y_A><QB{hLBo+jv>Ibk_=kC6-#DG6&fz2kX8Rwn?IHc893AFqUMEuPTyh
zy?t8^b#<KFE@$*a&g&+BX#w0`@4H{E#zU2B_i)CuBym8hElt?n5~(YGCqgc%BZ_kc
zminzLQe?zPB-W22+CaOe$j>$98qc*y*vG1#m&8VjMdrolaLd2?bG`-1958!!+Cbsa
zC`G~%sTolQG}U>m4ASwSl0FWz8&)VIgkHvJzOYR+1owO8&GlO{GC>ADUfw-;NjWK|
zD=q3$!kLJhhMhbRqUKYQ4ISI@+Qsq6=|JcE&zkt5kojZ%d&?<doScDQ=jiHYTNg~U
znl&AgNPBJuW$lKjV9{=Q-g7pLJ&QXx2bv^Og1@&lHh@in_O!uY1KZm1A8^_xk7CyM
zvn7wuv+^fWcMIhs&!A(<$j=rvf!f}@=E7z*2Nt+IASCde%Z8RItBk>90Uu49(>e&N
zx1(!5$L~%@nT_@(U)R0VQ};>=d6g^UP1G5;lh4>N!)6O6JQ@}>_j-lhBey({<&3_O
zt%K>Ls?{E+5)Qw%DdPUnK-K6Jn&vD|`mBO>Hy$=xaJ?6=1iamhJW9yb7Ikhd0*{ce
zR4WI}3Dt_?-P=)f+@4_IcHJPmJzY;5FH<l8>6Y-ixw@C3sXRI-m~0jvT@9?KX$=U>
z192fFe3VhX0nO_R6DCfH$_rhMHaaF~?$8a!!@s6&=@;1npaxBXK9esHGCVAQbY9C9
z81b4d<mrpou~&Wa*hqqcG@ndnxStgP4v`mugm4=zD%6|YL~kW@9qxc2)SPxY%=%*b
z<E4<Ht{pJLHGWSSWoRJH;_-R^AWlxb(caTcr@y*`y(ofeM!NyPOB*WSYTpGt{SOcE
z_p9%7@~Fi45!?K}^cXvgf?Ly0Gwk<)KIj-*v*}BGQxwi$b&$a4<cNaV+TbCr@C>s;
z*swGH2LLOUV-y@wUp$w0w04yBtkb@NtS_dfLTyW5Eo|ZW*JcUQ16!Ds=#f#bdA8SP
z&$PrdJ=MY>O;mut6*ymHSt1h6QCdpFr|>f}r8q=h)@D|^lAb<)^ekUB42m56NhY=%
z0m2uhVk*XduZ<7y)?e1Ay%9rN?Tz_jQedb6w?fMRQLl8h(FYZf^pyCCnUFnHZ39`=
z=3}Y-%$CahLiLwn(fVyBY=?5~QQ}ZRQ{^1>lC&hrnZnXS!1e*m+JGI&@H5N@zSq)Z
z?CcS3C12?5AS$VE2I(}}z3<FDYJ7Y&KQ{|(AYr@Ow`_cS)i5ZH1-V>3qmoP2dhz#^
zk{SKBUR`Ma9LpHKd+0{Mpm*IO?JSL@U?wz|A2zGO8wbqN`R7kTg<xE&eiqdXQ+Q23
zfC+;%;A0hn-&^1KNq4*_kE>6y?OsD!=@XP-b}&j#(XGQ?uWfdei9$i|JoZqkOnf+A
zmME~=yZQZ$&KiOVdCQA2NV=(HXNQW*gaB=7;rlrj(yLe4FY0Bd1(Nxrbnf=~n^XlT
zL7#l=Ig-FCBQF~L6!b%?ZSPjqs^3d>ToJ6Sf$37P6vFO;#DFgS7sbN&%NKxsfdQ-U
z_zEn`tds|-X1OVE%mM0!YZ+>g1KcU~0UaZw4sj52sIDcBrqIXJk7?7_V^_1hmAdrj
z*_`;hk_QL2xpVdQZTVYw$>=+He{6`QH)Id=pw%%bfYGM`y4*j=UjMaG{%ckL+ouhk
zj(QN|9lCZCzDT27z*qy{_o{1G&d$RfU+l1%SD7eMp_9wX+65@rn08A7<ev_Q;-Kcx
zL6K9?r9yTFS8rNMY1Z@P0?Q(ju2!kAZYG)KdW_&7eNys!5UIX(?phwSvpHxwhz<-X
zQFwETMHPju2d4-@`SN!v|MB;&K76Y3pZg8Cz6U`PAz@*oW_5?hY6%;C;rG2@Ra@Bj
z$j44WL28W{m&d3#vVsd}lx6aAX#D)sy&SobHNk%^&rgD&-y8JBZ(I2foR<F}x70}s
z;;06XZ(a>@&iHT(qZUT!1Z7pKW^BIh?p$<A86^s0Re(NKz)>}0Qm(8wq4Lqi0KHz4
zF?x0>Z!4+$o3deV>@pcbYX@!dg?@?nbcPM-fH1RU&p7XJ;zw#+LF<x&(GnYzWaP6?
z*+L;?gebhszjuzIEF1b?5yogBumU#yu%Q16)PIPGlQHtATF-~5+><o;w?CX`d9<*g
zLwV0ThqL%%zB0u?{7*}C5QX)-M1mUl&n1%o_{*n{8WsXmvJAz3T432#?JEahtEV*K
zimF<73=ifZg@nkYf8(@!qn}pT7zkcM{1gT;MHa=T%;(!1pQr!eoz7E!Xj7m@PXjTG
z2iX;m2EOYn?kjUB;vYxKN~5H;!($TtNOfP{m~itou=0mCcxNc~LN>W*PEDSQ<$FVU
zp47hh&@*y$B*9N)MZz@yA{L<nI1EK$G`D}v{n7~F`O}uWz}<?LT11_lopdxAJT5f)
z9w(+tLE2b7ZLovR>4En46ka}FT0mYc@!cSVAj|i!utp6CexYnC|J=p;kLCZv_fwFz
zrF%RNy`jP=en>>K%zAr<*?qn(w=H$FtagKFd}+7h1%sQfyC!^Tb5E?^!BzgDfE<Wq
zLk6lQ0r9<G?O*L>8nHa3JP1{>BSPF`ktjSOFH<C^+e0I-8m)mJG2(2JkSCAc1xHC;
zWpF~?0F$dm@%!Fnd!GDN#QF&Q0?+-?|Cyovy$%e$|LDny|94OGU$^w%5yQW^U}pOR
z07LT60GPiZ(SNS9|LY$U5`VMFWHJ7`o%i<|_`kjI{UGz84P=pv{Lk*-?}7WDT?pn-
z|2CFmkN-Pk`ELgF|NAX6B_JQ~o7wdJ?{??^bd<@W@_}&BX!qowBapvCk^kXE&-ibz
z>+Jr|Im2Ij?SD4P4^Rxv|5(m^|GS)lDf!>!{GUzA|1RhMY(W0kI{zn^`2VYQ&L^|I
zbyfyReMkB0j(%i*Aaj}6i9GtXJoT@r<==Z?GMV2d^)tpld#)@$z-#7z`b_>;SQi91
zjxDVH2b`XNWeWe^jQg_wjssuw|Fc7ndInhE>_@Ld{xsV^C}bbB6^J)IUOM={d=5Zu
z9&o@H|Lhq4h`OQAOlcqe8R0~70$~QpA^N9w<bSw**N>=kEe>DwGYsCcGe#f~2!Pw-
zyEoTz{DTDJb*dc_Al@XrXKlUm>z8aQ2}$f=e@umOZ?qi`c<}F$`i}tk-}DIc$$sY?
zKq6*#=I4K<<GkOPG2u_QTFF3nRcN#x-?!~n_SX%Q9UK53xAluBmy`Ve9C+7PsFsT^
z!2kxTkTlU!I#1zk>wJayb)Pw*&+pB<q(_bUl2oqNTC~sy<Jb-{#T@skw)SPO0EWwX
z*gTf`pCjNa{^^eZiTR%cB#9>v=>T*?`$P<NMnyxYs+!glUnoSQ2l>xY#lZhPszt|v
z6aV6-{qPt5xO1V7Yrm7Vy4G^3@e-t6@NM;`2jvmj!3O3A--*j8SXm{q!Q>i*^w)<S
zq+|UqI`;I?HcwmcS@#9^gwF$VS#%2cb(ou$WziB#=#5G9#vGMM&TKd)l>l;#Z={=s
z=W^|2q_+I;5sR|_?bQvQ{&Vo8C<KsPq~`LC35W_575IccLSLKHKK}Dz5|V)7NVvX9
z|EsnFxP^ms?2TC;a7ZFQP(;UF6*mUl<(ITibxJactu!*o&wL??2jAbJd=jLlz=R2Z
z+vXsr1#;x-f%Y+fUcNc?4^Xz4YTQ9LOq976uO$6?rq0f;=_{P`Y#>XH=0Q9CSE*bP
z*a9F6fYbkv<x$Y@vXkPnqEXHDpFK+B-u#GroB5~q4*gQ^-<L~n^|Ubsgy1t3biZT>
zo(^?-rRKJTO2qFP+tyAoZl~;1^h_7oRqymi+V}_82OMrs$NZ5a^5UN0_sEHc;12{8
zgJbqy0`s}|@^YYY5h=C)EFJ(|A3IW}poV@=dXE}Q0T5sMmL=IjR@3o+y0O?Sv(y=R
zz(hyG^N<j|Y5B5}x~UJj{au2#Sdt&OxXd{6CL1R3G!jBU0n-UAMBL85$Fm0$h08gl
zD<aKo(>00RI}sow&nW5`J_4!?tSDJs*?nOj!lf?F5Hzp^s$A~7($<OcZ$HEJ4PyAm
z@V|-#V+X^^rQ_%mwr+W!Kk1}08k<OQ{DOSA-t$WY0)qOyLPzVi#Xu$EwhwD-E6L}Z
z@GJtk)io}*H=9IgcUD|b?YML5io4L#waOj$#mO|Q_7fG0(2*EELPf28%T4{+`j{C_
z;N+-(S2~q`M&$2&K!V_Rj&cZq5&x<ApHH?#TQt*r4|)NdoT5A)>-lwrR6z76-faxb
z^i6k&X#eK$&@C<=vCP84w4_c2z+M%CHhEqaXk1;m78;@At3APIl(_fEYz#~+HbH&S
zEJhQVmNS+M`x+nr5@1s&^{LW}0J5fKI+D-qN%-vjkZl&$)EDRS4f8u*?nFSe&>Ce4
zCv4u>@ZY)1O_F0^tTQo#S?%s_L?Lr9CXCDVV}~M8@7bo(I&ESC51P7btnJ;+Wly|G
zj!2K%Bmb-LbT1E#{FDJ*-e6C!u~rxrCFSs?L;S{gFN@=<eI7PE_Blw_+q*u7uP$th
z<_P;@C3wvIo_Uxu&oS6=mYl#)Y-qV#wxDTLE<2e%{MTqF9j^Tfr#4#ScVm@U0|uRp
zcSg%E2hCmpCTRqq&26?__B)<R(XOr>ukP=Q<AI>79^y0Gau(MEef!g1pB8rSgQcu*
z^_8|p8e`N|It2Uxuhno*!$-ZxPTcxhMx04p!Enb4lmH9$J2IjXNb?Yo*tj`WdtI}G
ztKDdnbUF1^_P0{R-6~nPX|)#@uPkx*W|`^H%0vFZ+X{uZ{BgVs6Okfd?OgQ%rwx7F
z`7qgZ=F7@LpJ_gASd%A+_470pr&WBVgf0^YD4AyUd{?JZWMfN)FsXk2a$)~hgLaqK
zm*YdNk1awEbyleRik_p3Gm0uS<poBgdV6|5a&V)Lp?j|$LBaoP$ZIn#xLBgKS^^)v
zg?YE+VoLOW;*8d77x(<oVNzf6N@1jF`XbplcL)F4@8l4(WkR&dl?uR>d-CPe>e4BG
zQLl}vblqrUkh-%pFQ$C9;;v+m5xjOi%(a&WU`6tlrHbC#F@)^P(Fmv9drJ%$wW^FR
z_8&QslgrlMQC+w;D7-hmPJc?rJGMMEu;&E`)B~TaMsIq1N4F~}bMMHDUY`@86Ol7E
zdC@Yk9q3?^iMX4lUv$VOO<sY4FSWvg8%0DfuA+`cbFoN1JOX-(8BvX`zXl>6WPn(h
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
Gp$PyLoEgXf

literal 0
HcmV?d00001

diff --git a/playground/docs/images/otterscan-tx-trace.png b/playground/docs/images/otterscan-tx-trace.png
new file mode 100644
index 0000000000000000000000000000000000000000..f993f1c400978b5a74f01af931e48ad39e194da5
GIT binary patch
literal 639438
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%0DTa~(PAyUQq?GfrtOb`BI
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
Cx{6K!

literal 0
HcmV?d00001


From cb58b605bb31ed12477e1160fbcbb11d22397230 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Thu, 26 Feb 2026 18:09:20 +0100
Subject: [PATCH 110/219] Add v1/orders POST endpoint to get orders in batches
 (#4048)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Aave wants to track specific orders in bulk, knowing their ids.

# Changes
Adds POST handler for `v1/orders/lookup` endpoint that requires a list
of order uids and responds with a vector of their data. Has a hardcoded
limit of 128 orders per request (to fit the MAX_JSON_BODY_PAYLOAD size).

## How to test
Test on staging, query multiple orders using this API.

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
Co-authored-by: ilya <ilya@cow.fi>
---
 crates/database/src/jit_orders.rs             |  10 ++
 crates/database/src/orders.rs                 |  40 ++++--
 crates/e2e/tests/e2e/malformed_requests.rs    |  27 ++++
 crates/model/src/order.rs                     |   4 +-
 crates/orderbook/openapi.yml                  |  56 +++++++-
 crates/orderbook/src/api.rs                   |   6 +
 crates/orderbook/src/api/get_orders_by_uid.rs | 122 ++++++++++++++++++
 crates/orderbook/src/database/orders.rs       |  49 ++++++-
 crates/orderbook/src/orderbook.rs             |   4 +
 9 files changed, 301 insertions(+), 17 deletions(-)
 create mode 100644 crates/orderbook/src/api/get_orders_by_uid.rs

diff --git a/crates/database/src/jit_orders.rs b/crates/database/src/jit_orders.rs
index 69a48a8a76..82b87fd981 100644
--- a/crates/database/src/jit_orders.rs
+++ b/crates/database/src/jit_orders.rs
@@ -54,6 +54,16 @@ SELECT,
     sqlx::query_as(QUERY).bind(uid).fetch_optional(ex).await
 }
 
+#[instrument(skip_all)]
+pub async fn get_many_by_uid<'a>(
+    ex: &'a mut PgConnection,
+    order_uids: &'a [OrderUid],
+) -> Result<Vec<orders::FullOrder>, sqlx::Error> {
+    const QUERY: &str =
+        const_format::concatcp!("SELECT ", SELECT, " FROM ", FROM, " WHERE o.uid = ANY($1)");
+    sqlx::query_as(QUERY).bind(order_uids).fetch_all(ex).await
+}
+
 #[instrument(skip_all)]
 pub async fn get_by_tx(
     ex: &mut PgConnection,
diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index b7a8e5abe4..1c85af975a 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -644,6 +644,21 @@ COALESCE((SELECT executed_fee_token FROM order_execution oe WHERE oe.order_uid =
 "#;
 
 pub const FROM: &str = "orders o";
+const FULL_ORDER_WITH_QUOTE: &str = const_format::concatcp!(
+    "SELECT ",
+    SELECT,
+    ", o_quotes.sell_amount as quote_sell_amount",
+    ", o_quotes.buy_amount as quote_buy_amount",
+    ", o_quotes.gas_amount as quote_gas_amount",
+    ", o_quotes.gas_price as quote_gas_price",
+    ", o_quotes.sell_token_price as quote_sell_token_price",
+    ", o_quotes.verified as quote_verified",
+    ", o_quotes.metadata as quote_metadata",
+    ", o_quotes.solver as solver",
+    " FROM ",
+    FROM,
+    " LEFT JOIN order_quotes o_quotes ON o.uid = o_quotes.order_uid",
+);
 
 #[instrument(skip_all)]
 pub async fn single_full_order_with_quote(
@@ -652,22 +667,21 @@ pub async fn single_full_order_with_quote(
 ) -> Result<Option<FullOrderWithQuote>, sqlx::Error> {
     #[rustfmt::skip]
     const QUERY: &str = const_format::concatcp!(
-        "SELECT ", SELECT,
-        ", o_quotes.sell_amount as quote_sell_amount",
-        ", o_quotes.buy_amount as quote_buy_amount",
-        ", o_quotes.gas_amount as quote_gas_amount",
-        ", o_quotes.gas_price as quote_gas_price",
-        ", o_quotes.sell_token_price as quote_sell_token_price",
-        ", o_quotes.verified as quote_verified",
-        ", o_quotes.metadata as quote_metadata",
-        ", o_quotes.solver as solver",
-        " FROM ", FROM,
-        " LEFT JOIN order_quotes o_quotes ON o.uid = o_quotes.order_uid",
-        " WHERE o.uid = $1",
-        );
+        FULL_ORDER_WITH_QUOTE,
+        " WHERE o.uid = $1"
+    );
     sqlx::query_as(QUERY).bind(uid).fetch_optional(ex).await
 }
 
+#[instrument(skip_all)]
+pub async fn many_full_orders_with_quotes<'a>(
+    ex: &'a mut PgConnection,
+    order_ids: &'a [OrderUid],
+) -> Result<Vec<FullOrderWithQuote>, sqlx::Error> {
+    const QUERY: &str = const_format::concatcp!(FULL_ORDER_WITH_QUOTE, " WHERE o.uid = ANY($1)");
+    sqlx::query_as(QUERY).bind(order_ids).fetch_all(ex).await
+}
+
 // Partial query for getting the log indices of events of a single settlement.
 //
 // This will fail if we ever have multiple settlements in the same transaction
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 44b10fe02c..278568e020 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -3,6 +3,7 @@
 
 use {
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
+    model::order::{ORDER_UID_LIMIT, OrderUid},
     orderbook::api::Error,
     reqwest::StatusCode,
     serde_json::json,
@@ -306,4 +307,30 @@ async fn http_validation(web3: Web3) {
         !error.description.is_empty(),
         "Error response should have non-empty 'description' field"
     );
+
+    // /api/v1/orders/by_uids requires Json body
+    let response = client
+        .post(format!("{API_HOST}/api/v1/orders/by_uids"))
+        .header("Content-Type", "application/json")
+        .body("Not json")
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+
+    // Querying for more than ORDER_UID_LIMIT orders should fail
+    let response = client
+        .post(format!("{API_HOST}/api/v1/orders/by_uids"))
+        .header("Content-Type", "application/json")
+        .json(&json!(
+            (0..ORDER_UID_LIMIT + 1)
+                .map(|_| OrderUid::default())
+                .collect::<Vec<_>>()
+        ))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 }
diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index cd4085a9fd..d83c3003d9 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -731,7 +731,9 @@ pub struct OrderMetadata {
     pub quote: Option<OrderQuote>,
 }
 
-pub const ORDER_UID_LIMIT: usize = 1024;
+/// OrderUid is 56 bytes. When hex encoded as 0x prefixes Json string it is 116.
+/// Chosen to be under the MAX_JSON_BODY_PAYLOAD size of 1024 * 16
+pub const ORDER_UID_LIMIT: usize = 128;
 
 // uid as 56 bytes: 32 for orderDigest, 20 for ownerAddress and 4 for validTo
 #[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 1d6a9eefc3..d46306eb75 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -129,6 +129,60 @@ paths:
           description: One or more orders were not found and no orders were cancelled.
         "422":
           description: Unable to parse request body as valid JSON.
+  "/api/v1/orders/by_uids":
+    post:
+      operationId: getOrders
+      summary: Get existing orders from the list of UIDs.
+      description: |
+        Returns an array where each element is an object with either
+        an "order" key containing the full order, or an "error" key
+        containing the UID and a description of what went wrong.
+      requestBody:
+        description: The list of up to 128 order uids to fetch
+        required: true
+        content:
+          application/json:
+            schema:
+              type: array
+              items:
+                $ref: "#/components/schemas/UID"
+      responses:
+        "200":
+          description: |
+            The resulting full order data based on the request. Each element of the array is
+            an object of the following format:
+            - `{"order": <Order>}` for successfully fetched orders
+            - `{"error": {"uid": "<UID>", "description": "<message>"}}` for orders that failed conversion
+            The result ordering is not guaranteed and might differ from the order of requested UIDs.
+            Orders that do not exist in the database will be missing from the response.
+          content:
+            application/json:
+              schema:
+                oneOf:
+                  - type: object
+                    properties:
+                      order:
+                        $ref: "#/components/schemas/Order"
+                    required:
+                      - order
+                  - type: object
+                    properties:
+                      error:
+                        type: object
+                        properties:
+                          uid:
+                            $ref: "#/components/schemas/UID"
+                          description:
+                            type: string
+                        required:
+                          - uid
+                          - description
+                    required:
+                      - error
+        "400":
+          description: Request array size larger than 128 or unable to parse request body as valid JSON.
+        "422":
+          description: Could not decode array values as order UID.
   "/api/v1/orders/{UID}":
     get:
       operationId: getOrder
@@ -1510,7 +1564,7 @@ components:
       properties:
         orderUids:
           type: array
-          description: UIDs of orders to cancel.
+          description: Up to 128 UIDs of orders to cancel.
           items:
             $ref: "#/components/schemas/UID"
         signature:
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 8b6f88a107..1fb9e12ce9 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -35,6 +35,7 @@ mod get_native_price;
 mod get_order_by_uid;
 mod get_order_status;
 mod get_orders_by_tx;
+mod get_orders_by_uid;
 mod get_solver_competition;
 mod get_solver_competition_v2;
 mod get_token_metadata;
@@ -190,6 +191,11 @@ pub fn handle_all_routes(
             "/api/v1/orders",
             post(post_order::post_order_handler),
         ),
+        (
+            "POST",
+            "/api/v1/orders/by_uids",
+            post(get_orders_by_uid::get_orders_by_uid_handler),
+        ),
         (
             "DELETE",
             "/api/v1/orders",
diff --git a/crates/orderbook/src/api/get_orders_by_uid.rs b/crates/orderbook/src/api/get_orders_by_uid.rs
new file mode 100644
index 0000000000..fd0831ec97
--- /dev/null
+++ b/crates/orderbook/src/api/get_orders_by_uid.rs
@@ -0,0 +1,122 @@
+use {
+    crate::api::AppState,
+    anyhow::Result,
+    axum::{
+        extract::State,
+        http::StatusCode,
+        response::{IntoResponse, Response},
+    },
+    model::order::{ORDER_UID_LIMIT, Order, OrderUid},
+    serde::Serialize,
+    std::sync::Arc,
+};
+
+#[expect(clippy::large_enum_variant)]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+enum OrderResultEntry {
+    Order(Order),
+    Error(OrderError),
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct OrderError {
+    uid: OrderUid,
+    description: String,
+}
+
+pub async fn get_orders_by_uid_handler(
+    State(state): State<Arc<AppState>>,
+    axum::Json(orders): axum::Json<Vec<OrderUid>>,
+) -> Response {
+    if orders.len() > ORDER_UID_LIMIT {
+        return (
+            StatusCode::BAD_REQUEST,
+            format!("Request exceeds maximum number of order UIDs of {ORDER_UID_LIMIT}"),
+        )
+            .into_response();
+    }
+
+    get_orders_by_uid_response(state.orderbook.get_orders(&orders).await)
+}
+
+fn get_orders_by_uid_response(result: Result<Vec<(OrderUid, Result<Order>)>>) -> Response {
+    match result {
+        Ok(orders) => axum::Json(
+            orders
+                .into_iter()
+                .map(|(uid, order)| match order {
+                    Ok(order) => OrderResultEntry::Order(order),
+                    Err(err) => {
+                        tracing::warn!(?err, "Error converting into model order");
+                        OrderResultEntry::Error(OrderError {
+                            uid,
+                            description: "Internal server error encountered when retrieving the \
+                                          order"
+                                .to_string(),
+                        })
+                    }
+                })
+                .collect::<Vec<OrderResultEntry>>(),
+        )
+        .into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_orders_by_uid_response");
+            crate::api::internal_error_reply()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::api::response_body};
+
+    #[tokio::test]
+    async fn get_orders_by_uid_ok() {
+        let order = Order::default();
+        let uid = order.metadata.uid;
+        let result = vec![(uid, Ok(order.clone()))];
+        let response = get_orders_by_uid_response(Ok(result));
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = response_body(response).await;
+        let entries: Vec<serde_json::Value> = serde_json::from_slice(&body).unwrap();
+        assert_eq!(entries.len(), 1);
+
+        let order_entry: Order =
+            serde_json::from_value(entries[0].get("order").expect("key order exists").clone())
+                .expect("value is a correct Order");
+        assert_eq!(order_entry, order);
+    }
+
+    #[tokio::test]
+    async fn get_orders_by_uid_conversion_error() {
+        let uid = OrderUid([1u8; 56]);
+        let result = vec![(uid, Err(anyhow::anyhow!("bad data")))];
+        let response = get_orders_by_uid_response(Ok(result));
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = response_body(response).await;
+        let entries: Vec<serde_json::Value> = serde_json::from_slice(&body).unwrap();
+        assert_eq!(entries.len(), 1);
+
+        let error = entries[0].get("error").expect("error key exists");
+        let error_uid: OrderUid = error.get("uid").unwrap().as_str().unwrap().parse().unwrap();
+        assert_eq!(error_uid, uid);
+        assert_eq!(
+            error
+                .get("description")
+                .expect("key description exists")
+                .as_str()
+                .expect("description is a string"),
+            "Internal server error encountered when retrieving the order"
+        );
+    }
+
+    #[tokio::test]
+    async fn get_orders_by_uid_err() {
+        let response = get_orders_by_uid_response(Err(anyhow::anyhow!("error")));
+        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+}
diff --git a/crates/orderbook/src/database/orders.rs b/crates/orderbook/src/database/orders.rs
index 067f444a66..e07fe8e15c 100644
--- a/crates/orderbook/src/database/orders.rs
+++ b/crates/orderbook/src/database/orders.rs
@@ -1,7 +1,7 @@
 use {
     super::Postgres,
     crate::dto::TokenMetadata,
-    alloy::primitives::{Address, B256},
+    alloy::primitives::{Address, B256, map::HashSet},
     anyhow::{Context as _, Result},
     app_data::AppDataHash,
     async_trait::async_trait,
@@ -12,7 +12,7 @@ use {
         order_events::{OrderEvent, OrderEventLabel, insert_order_event},
         orders::{self, FullOrder, OrderKind as DbOrderKind},
     },
-    futures::{FutureExt, StreamExt, stream::TryStreamExt},
+    futures::{FutureExt, StreamExt, stream::TryStreamExt, try_join},
     model::{
         order::{
             EthflowData,
@@ -75,6 +75,7 @@ pub trait OrderStoring: Send + Sync {
     ) -> Result<Vec<Order>>;
     async fn latest_order_event(&self, order_uid: &OrderUid) -> Result<Option<OrderEvent>>;
     async fn single_order(&self, uid: &OrderUid) -> Result<Option<Order>>;
+    async fn many_orders(&self, uids: &[OrderUid]) -> Result<Vec<(OrderUid, Result<Order>)>>;
 }
 
 #[derive(Debug)]
@@ -313,6 +314,50 @@ impl OrderStoring for Postgres {
         .transpose()
     }
 
+    async fn many_orders(&self, uids: &[OrderUid]) -> Result<Vec<(OrderUid, Result<Order>)>> {
+        let _timer = super::Metrics::get()
+            .database_queries
+            .with_label_values(&["many_orders"])
+            .start_timer();
+        // Deduplicate order UIDs
+        let uids = uids
+            .iter()
+            .map(|uid| ByteArray(uid.0))
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        let mut ex_orders = self.pool.acquire().await?;
+        let mut ex_jit_orders = self.pool.acquire().await?;
+
+        let (orders, jit_orders) = try_join!(
+            database::orders::many_full_orders_with_quotes(&mut ex_orders, &uids),
+            // JIT orders are fetched without quotes as they are created by solvers at settlement
+            // time
+            database::jit_orders::get_many_by_uid(&mut ex_jit_orders, &uids)
+        )?;
+        Ok(orders
+            .into_iter()
+            .map(|order| {
+                let (order, quote) = order.into_order_and_quote();
+                let uid = OrderUid(order.uid.0);
+                let result =
+                    full_order_with_quote_into_model_order(order, quote.as_ref()).map_err(|err| {
+                        tracing::warn!(?err, "Error converting into model order");
+                        err.context("Error converting into model order")
+                    });
+                (uid, result)
+            })
+            .chain(jit_orders.into_iter().map(|order| {
+                let uid = OrderUid(order.uid.0);
+                let result = full_order_into_model_order(order).map_err(|err| {
+                    tracing::warn!(?err, "Error converting Jit order into model order");
+                    err.context("Error converting Jit order into model order")
+                });
+                (uid, result)
+            }))
+            .collect())
+    }
+
     async fn orders_for_tx(&self, tx_hash: &B256) -> Result<Vec<Order>> {
         tokio::try_join!(
             self.user_order_for_tx(tx_hash),
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index 2b91f941b1..9cc13f356e 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -494,6 +494,10 @@ impl Orderbook {
         self.database_replica.single_order(uid).await
     }
 
+    pub async fn get_orders(&self, uids: &[OrderUid]) -> Result<Vec<(OrderUid, Result<Order>)>> {
+        self.database_replica.many_orders(uids).await
+    }
+
     pub async fn get_orders_for_tx(&self, hash: &B256) -> Result<Vec<Order>> {
         self.database_replica.orders_for_tx(hash).await
     }

From 013b198b4a2a418248342a8961ea3cee0ee30c89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 2 Mar 2026 09:45:11 +0000
Subject: [PATCH 111/219] Migrate the playground config (#4214)

# Description
The playground was left behind amidst the config changes. This PR brings
the playground back up to speed.

# Changes

* Remove unused variables
* Migrate the orderbook migration
* Migrate the autopilot migration

## How to test
Run the playground and execute a trade
---
 configs/local/autopilot.toml                  |  9 ++++
 configs/local/orderbook.toml                  |  1 +
 playground/autopilot.toml                     |  9 ++++
 playground/docker-compose.fork.yml            | 43 ++++++++++---------
 playground/docker-compose.non-interactive.yml | 20 +++------
 playground/orderbook.toml                     |  1 +
 6 files changed, 48 insertions(+), 35 deletions(-)
 create mode 100644 configs/local/autopilot.toml
 create mode 100644 configs/local/orderbook.toml
 create mode 100644 playground/autopilot.toml
 create mode 100644 playground/orderbook.toml

diff --git a/configs/local/autopilot.toml b/configs/local/autopilot.toml
new file mode 100644
index 0000000000..2afa93f908
--- /dev/null
+++ b/configs/local/autopilot.toml
@@ -0,0 +1,9 @@
+[[drivers]]
+name = "baseline"
+url = "http://driver/baseline"
+submission-account.address = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720"
+
+[fee-policies]
+
+[native-price-estimation]
+estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
diff --git a/configs/local/orderbook.toml b/configs/local/orderbook.toml
new file mode 100644
index 0000000000..da5cd3f553
--- /dev/null
+++ b/configs/local/orderbook.toml
@@ -0,0 +1 @@
+eip1271-skip-creation-validation = true
diff --git a/playground/autopilot.toml b/playground/autopilot.toml
new file mode 100644
index 0000000000..2afa93f908
--- /dev/null
+++ b/playground/autopilot.toml
@@ -0,0 +1,9 @@
+[[drivers]]
+name = "baseline"
+url = "http://driver/baseline"
+submission-account.address = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720"
+
+[fee-policies]
+
+[native-price-estimation]
+estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
diff --git a/playground/docker-compose.fork.yml b/playground/docker-compose.fork.yml
index b0c89b63f0..d7c49b5bc6 100644
--- a/playground/docker-compose.fork.yml
+++ b/playground/docker-compose.fork.yml
@@ -15,16 +15,19 @@ services:
       # with simple bytecode that always returns a solidity `true` value, alleviating
       # the requirement to register a solver's private key for the sake of testing on
       # a fork.
-      test: [ "CMD-SHELL", "
+      test: [
+          "CMD-SHELL",
+          "
           response=$$(wget -qO- --header='Content-Type: application/json' --post-data='{\"jsonrpc\":\"2.0\", \"method\":\"eth_blockNumber\", \"params\":[], \"id\":1}' http://127.0.0.1:8545);
           block=$$(echo $$response | sed -n 's/.*\"result\":\"\\([^\"\\]*\\)\".*/\\1/p');
           if [ -n \"$$block\" ] && [ \"$$block\" != \"0x0\" ] && [ \"$$block\" != \"null\" ]; then
-            /usr/local/bin/cast rpc -r http://127.0.0.1:8545 anvil_setCode 0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE 0x600160005260206000F3;
-            exit 0;
+          /usr/local/bin/cast rpc -r http://127.0.0.1:8545 anvil_setCode 0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE 0x600160005260206000F3;
+          exit 0;
           else
-            exit 1;
+          exit 1;
           fi;
-        " ]
+          ",
+        ]
       interval: 5s
       timeout: 30s
       retries: 5
@@ -68,23 +71,24 @@ services:
       target: localdev
       dockerfile: ./playground/Dockerfile
     restart: always
-    command: ["cargo", "watch", "-x", "run --bin orderbook"]
+    command:
+      [
+        "cargo",
+        "watch",
+        "-x",
+        "run --bin orderbook -- --config configs/${ENV}/orderbook.toml",
+      ]
     environment:
       - NODE_URL=http://chain:8545
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - ACCOUNT_BALANCES_SIMULATION=true
-      - ACCOUNT_BALANCES_SIMULATOR=Web3
       - SIMULATION_NODE_URL=http://chain:8545
-      - EIP1271_SKIP_CREATION_VALIDATION=true
       - ENABLE_EIP1271_ORDERS=true
-      - PRICE_ESTIMATORS=None
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
       - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
       - DRIVERS=baseline|http://driver/baseline
       - BIND_ADDRESS=0.0.0.0:80
       - CHAIN_ID=$CHAIN
-      - BASELINE_SOURCES=None
       - RUST_BACKTRACE=1
       - TOML_TRACE_ERROR=1
       - TRACING_COLLECTOR_ENDPOINT=http://tempo:4317
@@ -106,25 +110,24 @@ services:
       target: localdev
       dockerfile: ./playground/Dockerfile
     restart: always
-    command: ["cargo", "watch", "-x", "run --bin autopilot"]
+    command:
+      [
+        "cargo",
+        "watch",
+        "-x",
+        "run --bin autopilot -- --config configs/${ENV}/autopilot.toml",
+      ]
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - LOG_FILTER=warn,autopilot=debug,shared=info,shared::price_estimation=info
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
-      - SETTLE_INTERVAL=15s
-      - GAS_ESTIMATORS=Web3
-      - PRICE_ESTIMATORS=None
+      - GAS_ESTIMATORS=Web3,Alloy
       - BLOCK_STREAM_POLL_INTERVAL=1s
-      - NATIVE_PRICE_CACHE_MAX_UPDATE_SIZE=100
       - NATIVE_PRICE_CACHE_MAX_AGE=20m
-      - SOLVER_TIME_LIMIT=5
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
-      - DRIVERS=baseline|http://driver/baseline|0xa0Ee7A142d267C1f36714E4a8F75612F20a79720
       - SKIP_EVENT_SYNC=true
-      - BASELINE_SOURCES=None
       - RUST_BACKTRACE=1
       - TOML_TRACE_ERROR=1
       - ETHFLOW_CONTRACTS
diff --git a/playground/docker-compose.non-interactive.yml b/playground/docker-compose.non-interactive.yml
index 356fc8652b..498176cb78 100644
--- a/playground/docker-compose.non-interactive.yml
+++ b/playground/docker-compose.non-interactive.yml
@@ -71,23 +71,19 @@ services:
       target: orderbook
       dockerfile: ./Dockerfile
     restart: always
+    command: ["--config", "/orderbook.toml"]
     environment:
       - NODE_URL=http://chain:8545
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - ACCOUNT_BALANCES_SIMULATION=true
-      - ACCOUNT_BALANCES_SIMULATOR=Web3
       - SIMULATION_NODE_URL=http://chain:8545
-      - EIP1271_SKIP_CREATION_VALIDATION=true
       - ENABLE_EIP1271_ORDERS=true
-      - PRICE_ESTIMATORS=None
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
       - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
       - DRIVERS=baseline|http://driver/baseline
       - BIND_ADDRESS=0.0.0.0:80
       - CHAIN_ID=$CHAIN
-      - BASELINE_SOURCES=None
-      - RUST_BACKTRACE=1
+      - RUST_BACKTRACE=0
       - TOML_TRACE_ERROR=1
       - TRACING_COLLECTOR_ENDPOINT=http://tempo:4317
       - TOKIO_CONSOLE=true
@@ -95,6 +91,7 @@ services:
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
     volumes:
       - ../:/src
+      - ./orderbook.toml:/orderbook.toml
     depends_on:
       - db-migrations
     ports:
@@ -108,25 +105,18 @@ services:
       target: autopilot
       dockerfile: ./Dockerfile
     restart: always
+    command: ["--config", "/autopilot.toml"]
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - LOG_FILTER=warn,autopilot=info,shared=info,shared::price_estimation=info
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
-      - SETTLE_INTERVAL=15s
       - GAS_ESTIMATORS=Web3,Alloy
-      - PRICE_ESTIMATORS=None
-      - NATIVE_PRICE_ESTIMATORS=baseline
       - BLOCK_STREAM_POLL_INTERVAL=1s
-      - NATIVE_PRICE_CACHE_MAX_UPDATE_SIZE=100
       - NATIVE_PRICE_CACHE_MAX_AGE=20m
-      - SOLVER_TIME_LIMIT=5
       - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
-      - DRIVERS=baseline|http://driver/baseline|0xa0Ee7A142d267C1f36714E4a8F75612F20a79720
       - SKIP_EVENT_SYNC=true
-      - BASELINE_SOURCES=None
       - RUST_BACKTRACE=1
       - TOML_TRACE_ERROR=1
       - ETHFLOW_CONTRACTS
@@ -135,7 +125,7 @@ services:
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
     volumes:
-      - ../:/src
+      - ./autopilot.toml:/autopilot.toml
     depends_on:
       orderbook:
         condition: service_started
diff --git a/playground/orderbook.toml b/playground/orderbook.toml
new file mode 100644
index 0000000000..da5cd3f553
--- /dev/null
+++ b/playground/orderbook.toml
@@ -0,0 +1 @@
+eip1271-skip-creation-validation = true

From 74118ee983f21cf6aa3d24b9af38bf9ccfccd6b9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 2 Mar 2026 09:46:21 +0000
Subject: [PATCH 112/219] Compile only used packages in main Dockerfile (#4220)

# Description
The Dockerfile was compiling the whole workspace which is wasteful for
deployment (it was compiling e2e for example). This PR only compiles the
used packages.

# Changes

* Compiling workspace -> autopilot, driver, orderbook, refunder, solvers
only

## How to test
Build the dockerfile
---
 Dockerfile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index 40a74e5626..0205d3eda8 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -18,7 +18,9 @@ RUN rustup install stable && rustup default stable
 # Copy and Build Code
 COPY . .
 RUN --mount=type=cache,target=/usr/local/cargo/registry --mount=type=cache,target=/src/target \
-    CARGO_PROFILE_RELEASE_DEBUG=1 RUSTFLAGS="${RUSTFLAGS}" cargo build --release ${CARGO_BUILD_FEATURES} && \
+    CARGO_PROFILE_RELEASE_DEBUG=1 RUSTFLAGS="${RUSTFLAGS}" cargo build --release \
+    -p autopilot -p driver -p orderbook -p refunder -p solvers \
+    ${CARGO_BUILD_FEATURES} && \
     cp target/release/autopilot / && \
     cp target/release/driver / && \
     cp target/release/orderbook / && \

From 5cd893e85313ba0e8e10d1724aadea064f8f2482 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 2 Mar 2026 09:52:47 +0000
Subject: [PATCH 113/219] Replace full alloy import with specific alloy crates
 (#4219)

# Description
Based on @MartinquaXD's comment on Slack, I figured that there would be
places where we can import the specific alloy crate, unlocking earlier
and more parallel compilation. These changes alone seem to save ~5s on a
clean build in my laptop; going down from ~1m to 55s.

There's more gains to take from this, but for that we need to separate
shared further and then split those dependencies.
https://github.com/cowprotocol/services/pull/4217 would also help a
bunch.

# Changes

* app-data
  * replace alloy with alloy-primitives
* since alloy uses tiny-keccak, replace the tiny-keccak with alloy's
keccak
* chain
  * manually implement thiserror (less 1 dep)
  * replace alloy with alloy-primitives
* model
* replace alloy with alloy-primives, alloy-signer, alloy-signer-local,
alloy-sol-types
* number
  * replace alloy with alloy-primitives
* order-validation
  * replace alloy with alloy-primitives and alloy-contract
  * remove thiserror wrapper (less 1 dep)
* serde-ext
  * replace alloy with alloy-primitives
* testlib
  * replace alloy with alloy-primitives
* winner-selection
  * replace alloy with alloy-primitives


## How to test
Compiler + existing tests
---
 Cargo.lock                                | 23 +++++----
 Cargo.toml                                |  7 +--
 crates/app-data/Cargo.toml                |  3 +-
 crates/app-data/src/app_data.rs           |  2 +-
 crates/app-data/src/app_data_hash.rs      |  7 +--
 crates/app-data/src/hooks.rs              |  2 +-
 crates/chain/Cargo.toml                   |  3 +-
 crates/chain/src/lib.rs                   | 16 ++++--
 crates/model/Cargo.toml                   |  5 +-
 crates/model/src/fee_policy.rs            |  2 +-
 crates/model/src/interaction.rs           |  2 +-
 crates/model/src/lib.rs                   |  9 ++--
 crates/model/src/order.rs                 | 62 +++++++++++------------
 crates/model/src/quote.rs                 |  2 +-
 crates/model/src/signature.rs             | 17 +++----
 crates/model/src/solver_competition.rs    |  8 +--
 crates/model/src/solver_competition_v2.rs |  2 +-
 crates/model/src/trade.rs                 |  4 +-
 crates/number/Cargo.toml                  |  6 +--
 crates/number/src/conversions.rs          |  8 +--
 crates/number/src/nonzero.rs              |  2 +-
 crates/number/src/ratio_ext.rs            |  2 +-
 crates/number/src/serialization.rs        |  4 +-
 crates/number/src/testing.rs              |  2 +-
 crates/number/src/u256_ext.rs             |  2 +-
 crates/number/src/units.rs                |  2 +-
 crates/order-validation/Cargo.toml        |  6 +--
 crates/order-validation/src/banned.rs     | 12 ++---
 crates/serde-ext/Cargo.toml               |  4 +-
 crates/serde-ext/src/u256.rs              | 18 ++++---
 crates/testlib/Cargo.toml                 |  7 ++-
 crates/testlib/src/protocol.rs            |  2 +-
 crates/testlib/src/tokens.rs              |  2 +-
 crates/winner-selection/Cargo.toml        |  6 +--
 crates/winner-selection/src/arbitrator.rs |  4 +-
 crates/winner-selection/src/auction.rs    |  2 +-
 crates/winner-selection/src/primitives.rs |  2 +-
 crates/winner-selection/src/solution.rs   |  2 +-
 38 files changed, 137 insertions(+), 134 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d2186bc261..37a8e30dab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -836,7 +836,7 @@ checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 name = "app-data"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "anyhow",
  "bytes-hex",
  "const-hex",
@@ -846,7 +846,6 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_with",
- "tiny-keccak",
 ]
 
 [[package]]
@@ -2072,10 +2071,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 name = "chain"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "serde",
  "serde_json",
- "thiserror 1.0.69",
 ]
 
 [[package]]
@@ -4341,7 +4339,10 @@ dependencies = [
 name = "model"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
+ "alloy-signer",
+ "alloy-signer-local",
+ "alloy-sol-types",
  "anyhow",
  "app-data",
  "bigdecimal",
@@ -4568,7 +4569,7 @@ dependencies = [
 name = "number"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "anyhow",
  "bigdecimal",
  "num",
@@ -4768,11 +4769,11 @@ dependencies = [
 name = "order-validation"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-contract",
+ "alloy-primitives",
  "contracts",
  "futures",
  "moka",
- "thiserror 1.0.69",
  "tokio",
  "tracing",
 ]
@@ -6172,7 +6173,7 @@ dependencies = [
 name = "serde-ext"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "const-hex",
  "serde",
  "serde_with",
@@ -6933,7 +6934,7 @@ checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
 name = "testlib"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "anyhow",
  "maplit",
  "serde_json",
@@ -8253,7 +8254,7 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 name = "winner-selection"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "anyhow",
  "itertools 0.14.0",
  "number",
diff --git a/Cargo.toml b/Cargo.toml
index 850c47dc49..79f6822180 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,9 +4,11 @@ members = ["crates/*"]
 
 [workspace.dependencies]
 alloy = { version = "1.7.3", default-features = false }
-# alloy-signer was added because eip712 on the regular alloy crate brings way too much stuff with it
-# as such, this is a workaround to force feature unification over alloy to the feature set we want
+alloy-contract = { version = "1.7.3", default-features = false }
+alloy-primitives = { version = "1.5.2", default-features = false }
 alloy-signer = { version = "1.7.3", default-features = false}
+alloy-signer-local = { version = "1.7.3", default-features = false}
+alloy-sol-types = { version = "1.5.2" }
 anyhow = "1.0.100"
 async-trait = "0.1.80"
 axum = "0.8"
@@ -93,7 +95,6 @@ solvers-dto = { path = "crates/solvers-dto" }
 testlib = { path = "crates/testlib" }
 winner-selection = { path = "crates/winner-selection" }
 time = "0.3.47"
-tiny-keccak = "2.0.2"
 tower = "0.5"
 tower-http = "0.6"
 tracing-opentelemetry = "0.32.1"
diff --git a/crates/app-data/Cargo.toml b/crates/app-data/Cargo.toml
index 7265a009b4..1658ab82e8 100644
--- a/crates/app-data/Cargo.toml
+++ b/crates/app-data/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true, features = ["serde"] }
+alloy-primitives = { workspace = true, features = ["serde"] }
 anyhow = { workspace = true }
 bytes-hex = { workspace = true }
 const-hex = { workspace = true }
@@ -15,7 +15,6 @@ number = { path = "../number" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
-tiny-keccak = { workspace = true, features = ["keccak"] }
 
 [dev-dependencies]
 hex-literal = { workspace = true }
diff --git a/crates/app-data/src/app_data.rs b/crates/app-data/src/app_data.rs
index ac5b49fe50..e1dae79ed9 100644
--- a/crates/app-data/src/app_data.rs
+++ b/crates/app-data/src/app_data.rs
@@ -1,6 +1,6 @@
 use {
     crate::{AppDataHash, Hooks, app_data_hash::hash_full_app_data},
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     anyhow::{Context, Result, anyhow},
     bytes_hex::BytesHex,
     moka::sync::Cache,
diff --git a/crates/app-data/src/app_data_hash.rs b/crates/app-data/src/app_data_hash.rs
index 91e673e84b..b51b94e27e 100644
--- a/crates/app-data/src/app_data_hash.rs
+++ b/crates/app-data/src/app_data_hash.rs
@@ -28,7 +28,6 @@ use {
         fmt::{self, Debug, Formatter},
         str::FromStr,
     },
-    tiny_keccak::{Hasher, Keccak},
 };
 
 /// A JSON object used to represent app data documents for uploading and
@@ -107,11 +106,7 @@ impl PartialEq<[u8; 32]> for AppDataHash {
 /// Hash full app data to get the bytes expected to be set as the contract level
 /// app data.
 pub fn hash_full_app_data(app_data: &[u8]) -> [u8; 32] {
-    let mut hasher = Keccak::v256();
-    hasher.update(app_data);
-    let mut hash = [0u8; 32];
-    hasher.finalize(&mut hash);
-    hash
+    alloy_primitives::keccak256(app_data).0
 }
 
 /// Create an IPFS CIDv1 from a hash created by `hash_full_app_data`.
diff --git a/crates/app-data/src/hooks.rs b/crates/app-data/src/hooks.rs
index a37a0ba3a2..c61e971761 100644
--- a/crates/app-data/src/hooks.rs
+++ b/crates/app-data/src/hooks.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::Address,
+    alloy_primitives::Address,
     bytes_hex::BytesHex,
     serde::{Deserialize, Serialize},
     serde_with::{DisplayFromStr, serde_as},
diff --git a/crates/chain/Cargo.toml b/crates/chain/Cargo.toml
index e14810e979..4bbdb1d21d 100644
--- a/crates/chain/Cargo.toml
+++ b/crates/chain/Cargo.toml
@@ -6,9 +6,8 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-primitives = { workspace = true }
 serde = { workspace = true }
-thiserror = { workspace = true }
 
 [dev-dependencies]
 serde_json = { workspace = true }
diff --git a/crates/chain/src/lib.rs b/crates/chain/src/lib.rs
index d9f04dfeae..0321b30b53 100644
--- a/crates/chain/src/lib.rs
+++ b/crates/chain/src/lib.rs
@@ -1,8 +1,7 @@
 use {
-    alloy::primitives::U256,
+    alloy_primitives::U256,
     serde::{Deserialize, Deserializer, de},
-    std::time::Duration,
-    thiserror::Error,
+    std::{error::Error, fmt::Display, time::Duration},
 };
 
 /// Represents each available chain
@@ -177,10 +176,17 @@ impl<'de> Deserialize<'de> for Chain {
     }
 }
 
-#[derive(Error, Debug)]
-#[error("chain id not supported")]
+#[derive(Debug)]
 pub struct ChainIdNotSupported;
 
+impl Display for ChainIdNotSupported {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "chain id not supported")
+    }
+}
+
+impl Error for ChainIdNotSupported {}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml
index 2db4cc3f15..2df366e60c 100644
--- a/crates/model/Cargo.toml
+++ b/crates/model/Cargo.toml
@@ -9,7 +9,10 @@ license = "MIT OR Apache-2.0"
 doctest = false
 
 [dependencies]
-alloy = { workspace = true, features = ["sol-types", "signers", "signer-local", "rand"] }
+alloy-primitives = { workspace = true }
+alloy-signer = { workspace = true }
+alloy-signer-local = { workspace = true }
+alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 bigdecimal = { workspace = true }
diff --git a/crates/model/src/fee_policy.rs b/crates/model/src/fee_policy.rs
index 68f1f6fa45..72c5c5c1d5 100644
--- a/crates/model/src/fee_policy.rs
+++ b/crates/model/src/fee_policy.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     number::serialization::HexOrDecimalU256,
     serde::Serialize,
     serde_with::serde_as,
diff --git a/crates/model/src/interaction.rs b/crates/model/src/interaction.rs
index 67a6d0f449..1cdbd7c021 100644
--- a/crates/model/src/interaction.rs
+++ b/crates/model/src/interaction.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
diff --git a/crates/model/src/lib.rs b/crates/model/src/lib.rs
index 662e45a3d2..4f3919f717 100644
--- a/crates/model/src/lib.rs
+++ b/crates/model/src/lib.rs
@@ -11,7 +11,8 @@ pub mod time;
 pub mod trade;
 
 use {
-    alloy::primitives::Address,
+    alloy_primitives::{Address, U256},
+    alloy_sol_types::Eip712Domain,
     const_hex::{FromHex, FromHexError},
     std::fmt,
 };
@@ -112,10 +113,10 @@ impl std::fmt::Debug for DomainSeparator {
 
 impl DomainSeparator {
     pub fn new(chain_id: u64, contract_address: Address) -> Self {
-        let domain = alloy::sol_types::Eip712Domain {
+        let domain = Eip712Domain {
             name: Some("Gnosis Protocol".into()),
             version: Some("v2".into()),
-            chain_id: Some(alloy::primitives::U256::from(chain_id)),
+            chain_id: Some(U256::from(chain_id)),
             verifying_contract: Some(contract_address),
             salt: None,
         };
@@ -128,7 +129,7 @@ impl DomainSeparator {
 mod tests {
     use {
         super::*,
-        alloy::primitives::address,
+        alloy_primitives::address,
         hex_literal::hex,
         std::{cmp::Ordering, str::FromStr},
     };
diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index d83c3003d9..f4b76b1b80 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -9,10 +9,8 @@ use {
         quote::QuoteId,
         signature::{self, EcdsaSignature, EcdsaSigningScheme, Signature},
     },
-    alloy::{
-        primitives::{Address, B256, U256, U512, b256, keccak256},
-        signers::local::PrivateKeySigner,
-    },
+    alloy_primitives::{Address, B256, U256, U512, b256, keccak256},
+    alloy_signer_local::PrivateKeySigner,
     anyhow::{Result, anyhow},
     app_data::{AppDataHash, hash_full_app_data},
     bigdecimal::BigDecimal,
@@ -100,12 +98,12 @@ impl OrderBuilder {
         self
     }
 
-    pub fn with_sell_amount(mut self, sell_amount: alloy::primitives::U256) -> Self {
+    pub fn with_sell_amount(mut self, sell_amount: U256) -> Self {
         self.0.data.sell_amount = sell_amount;
         self
     }
 
-    pub fn with_buy_amount(mut self, buy_amount: alloy::primitives::U256) -> Self {
+    pub fn with_buy_amount(mut self, buy_amount: U256) -> Self {
         self.0.data.buy_amount = buy_amount;
         self
     }
@@ -125,7 +123,7 @@ impl OrderBuilder {
         self
     }
 
-    pub fn with_fee_amount(mut self, fee_amount: alloy::primitives::U256) -> Self {
+    pub fn with_fee_amount(mut self, fee_amount: U256) -> Self {
         self.0.data.fee_amount = fee_amount;
         self
     }
@@ -206,9 +204,9 @@ pub struct OrderData {
     #[serde(default)]
     pub receiver: Option<Address>,
     #[serde_as(as = "HexOrDecimalU256")]
-    pub sell_amount: alloy::primitives::U256,
+    pub sell_amount: U256,
     #[serde_as(as = "HexOrDecimalU256")]
-    pub buy_amount: alloy::primitives::U256,
+    pub buy_amount: U256,
     pub valid_to: u32,
     pub app_data: AppDataHash,
     /// Fees that will be taken in terms of `sell_token`.
@@ -217,7 +215,7 @@ pub struct OrderData {
     /// and should not be settled on their own.
     /// This is 0 for limit orders as their fee gets taken from the surplus.
     #[serde_as(as = "HexOrDecimalU256")]
-    pub fee_amount: alloy::primitives::U256,
+    pub fee_amount: U256,
     pub kind: OrderKind,
     pub partially_fillable: bool,
     #[serde(default)]
@@ -283,9 +281,9 @@ impl OrderData {
 /// sell token and buy `buy` amount of buy token. Additionally, `fee``
 /// denominated in the sell token needs to be payed.
 pub struct QuoteAmounts {
-    pub sell: alloy::primitives::U256,
-    pub buy: alloy::primitives::U256,
-    pub fee: alloy::primitives::U256,
+    pub sell: U256,
+    pub buy: U256,
+    pub fee: U256,
 }
 
 /// An order as provided to the POST order endpoint.
@@ -304,10 +302,10 @@ pub struct OrderCreation {
     pub receiver: Option<Address>,
     /// The *maximum* amount of `sell_token`s that may be sold.
     #[serde_as(as = "HexOrDecimalU256")]
-    pub sell_amount: alloy::primitives::U256,
+    pub sell_amount: U256,
     /// The *minimum* amount of `buy_token`s that should be bought.
     #[serde_as(as = "HexOrDecimalU256")]
-    pub buy_amount: alloy::primitives::U256,
+    pub buy_amount: U256,
     /// The block timestamp when the order can no longer be settled (UNIX
     /// timestamp in seconds).
     pub valid_to: u32,
@@ -317,7 +315,7 @@ pub struct OrderCreation {
     ///
     /// Deprecation note: orders with a non-zero `fee_amount` should be rejected
     /// by the API.
-    pub fee_amount: alloy::primitives::U256,
+    pub fee_amount: U256,
     /// The kind of order (i.e. sell or buy).
     pub kind: OrderKind,
     /// Whether the order can be carried out in multiple smaller trades, or it
@@ -1066,7 +1064,7 @@ mod tests {
     use {
         super::*,
         crate::signature::{EcdsaSigningScheme, SigningScheme},
-        alloy::primitives::{address, b256},
+        alloy_primitives::{address, b256},
         chrono::TimeZone,
         hex_literal::hex,
         maplit::hashset,
@@ -1140,13 +1138,13 @@ mod tests {
                 sell_token: Address::with_last_byte(10),
                 buy_token: Address::with_last_byte(9),
                 receiver: Some(Address::with_last_byte(11)),
-                sell_amount: alloy::primitives::U256::ONE,
-                buy_amount: alloy::primitives::U256::ZERO,
+                sell_amount: U256::ONE,
+                buy_amount: U256::ZERO,
                 valid_to: u32::MAX,
                 app_data: AppDataHash(hex!(
                     "6000000000000000000000000000000000000000000000000000000000000007"
                 )),
-                fee_amount: alloy::primitives::U256::MAX,
+                fee_amount: U256::MAX,
                 kind: OrderKind::Buy,
                 partially_fillable: false,
                 sell_token_balance: SellTokenSource::External,
@@ -1217,13 +1215,13 @@ mod tests {
             sell_token: Address::repeat_byte(0x11),
             buy_token: Address::repeat_byte(0x22),
             receiver: Some(Address::repeat_byte(0x33)),
-            sell_amount: alloy::primitives::U256::from(123),
-            buy_amount: alloy::primitives::U256::from(456),
+            sell_amount: U256::from(123),
+            buy_amount: U256::from(456),
             valid_to: 1337,
             app_data: OrderCreationAppData::Hash {
                 hash: AppDataHash([0x44; 32]),
             },
-            fee_amount: alloy::primitives::U256::from(789),
+            fee_amount: U256::from(789),
             kind: OrderKind::Sell,
             partially_fillable: false,
             sell_token_balance: SellTokenSource::Erc20,
@@ -1390,13 +1388,13 @@ mod tests {
                 sell_token: hex!("0101010101010101010101010101010101010101").into(),
                 buy_token: hex!("0202020202020202020202020202020202020202").into(),
                 receiver: Some(hex!("0303030303030303030303030303030303030303").into()),
-                sell_amount: alloy::primitives::U256::from(0x0246ddf97976680000_u128),
-                buy_amount: alloy::primitives::U256::from(0xb98bc829a6f90000_u128),
+                sell_amount: U256::from(0x0246ddf97976680000_u128),
+                buy_amount: U256::from(0xb98bc829a6f90000_u128),
                 valid_to: 0xffffffff,
                 app_data: AppDataHash(hex!(
                     "0000000000000000000000000000000000000000000000000000000000000000"
                 )),
-                fee_amount: alloy::primitives::U256::from(0x0de0b6b3a7640000_u128),
+                fee_amount: U256::from(0x0de0b6b3a7640000_u128),
                 kind: OrderKind::Sell,
                 partially_fillable: false,
                 sell_token_balance: SellTokenSource::Erc20,
@@ -1424,13 +1422,13 @@ mod tests {
             sell_token: hex!("0101010101010101010101010101010101010101").into(),
             buy_token: hex!("0202020202020202020202020202020202020202").into(),
             receiver: Some(hex!("0303030303030303030303030303030303030303").into()),
-            sell_amount: alloy::primitives::U256::from(0x0246ddf97976680000_u128),
-            buy_amount: alloy::primitives::U256::from(0xb98bc829a6f90000_u128),
+            sell_amount: U256::from(0x0246ddf97976680000_u128),
+            buy_amount: U256::from(0xb98bc829a6f90000_u128),
             valid_to: 0xffffffff,
             app_data: AppDataHash(hex!(
                 "0000000000000000000000000000000000000000000000000000000000000000"
             )),
-            fee_amount: alloy::primitives::U256::from(0x0de0b6b3a7640000_u128),
+            fee_amount: U256::from(0x0de0b6b3a7640000_u128),
             kind: OrderKind::Sell,
             partially_fillable: false,
             sell_token_balance: SellTokenSource::Erc20,
@@ -1512,12 +1510,12 @@ mod tests {
 
         let order = OrderBuilder::default()
             .with_sell_token(Address::ZERO)
-            .with_sell_amount(alloy::primitives::U256::from(100))
+            .with_sell_amount(U256::from(100))
             .with_buy_token(Address::ZERO)
-            .with_buy_amount(alloy::primitives::U256::from(80))
+            .with_buy_amount(U256::from(80))
             .with_valid_to(u32::MAX)
             .with_app_data([1u8; 32])
-            .with_fee_amount(alloy::primitives::U256::from(1337))
+            .with_fee_amount(U256::from(1337))
             .with_partially_fillable(true)
             .with_sell_token_balance(SellTokenSource::External)
             .with_buy_token_balance(BuyTokenDestination::Internal)
diff --git a/crates/model/src/quote.rs b/crates/model/src/quote.rs
index 7af5f4471c..9d5f83e946 100644
--- a/crates/model/src/quote.rs
+++ b/crates/model/src/quote.rs
@@ -4,7 +4,7 @@ use {
         signature::SigningScheme,
         time,
     },
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     anyhow::bail,
     app_data::AppDataHash,
     bigdecimal::BigDecimal,
diff --git a/crates/model/src/signature.rs b/crates/model/src/signature.rs
index 70da569597..b95db03916 100644
--- a/crates/model/src/signature.rs
+++ b/crates/model/src/signature.rs
@@ -1,9 +1,8 @@
 use {
     crate::{DomainSeparator, quote::QuoteSigningScheme},
-    alloy::{
-        primitives::{Address, B256},
-        signers::{SignerSync, local::PrivateKeySigner},
-    },
+    alloy_primitives::{Address, B256, keccak256},
+    alloy_signer::SignerSync,
+    alloy_signer_local::PrivateKeySigner,
     anyhow::{Context as _, Result, ensure},
     serde::{Deserialize, Serialize, de},
     std::{
@@ -275,14 +274,14 @@ pub fn hashed_eip712_message(domain_separator: &DomainSeparator, struct_hash: &[
     message[0..2].copy_from_slice(&[0x19, 0x01]);
     message[2..34].copy_from_slice(&domain_separator.0);
     message[34..66].copy_from_slice(struct_hash);
-    alloy::primitives::keccak256(message)
+    keccak256(message)
 }
 
 fn hashed_ethsign_message(domain_separator: &DomainSeparator, struct_hash: &[u8; 32]) -> B256 {
     let mut message = [0u8; 60];
     message[..28].copy_from_slice(b"\x19Ethereum Signed Message:\n32");
     message[28..].copy_from_slice(hashed_eip712_message(domain_separator, struct_hash).as_slice());
-    alloy::primitives::keccak256(message)
+    keccak256(message)
 }
 
 /// Orders are always hashed into 32 bytes according to EIP-712.
@@ -340,7 +339,7 @@ impl EcdsaSignature {
         struct_hash: &[u8; 32],
     ) -> Result<Recovered> {
         let message = hashed_signing_message(signing_scheme, domain_separator, struct_hash);
-        let signature = alloy::primitives::Signature::from_raw(&self.to_bytes())?;
+        let signature = alloy_primitives::Signature::from_raw(&self.to_bytes())?;
         let signer = signature.recover_address_from_prehash(&message)?;
 
         Ok(Recovered { message, signer })
@@ -427,7 +426,7 @@ impl<'de> Deserialize<'de> for EcdsaSignature {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, serde_json::json, testlib::assert_json_matches};
+    use {super::*, alloy_primitives::U256, serde_json::json, testlib::assert_json_matches};
 
     #[test]
     fn onchain_signatures_cannot_recover_owners() {
@@ -634,7 +633,7 @@ mod tests {
 
     #[test]
     fn test_ecdsa_signature_recovery() {
-        let private_key = alloy::primitives::U256::from(1u64);
+        let private_key = U256::from(1u64);
         let signer = PrivateKeySigner::from_bytes(&private_key.to_be_bytes().into()).unwrap();
         let signer_address = signer.address();
 
diff --git a/crates/model/src/solver_competition.rs b/crates/model/src/solver_competition.rs
index e2532459a8..20b9dd934b 100644
--- a/crates/model/src/solver_competition.rs
+++ b/crates/model/src/solver_competition.rs
@@ -1,6 +1,6 @@
 use {
     crate::{AuctionId, order::OrderUid},
-    alloy::primitives::{Address, B256, U256},
+    alloy_primitives::{Address, B256, U256},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
@@ -105,16 +105,16 @@ pub enum Order {
         id: OrderUid,
         /// The effective amount that left the user's wallet including all fees.
         #[serde_as(as = "HexOrDecimalU256")]
-        sell_amount: alloy::primitives::U256,
+        sell_amount: U256,
         /// The effective amount the user received after all fees.
         #[serde_as(as = "HexOrDecimalU256")]
-        buy_amount: alloy::primitives::U256,
+        buy_amount: U256,
     },
     #[serde(rename_all = "camelCase")]
     Legacy {
         id: OrderUid,
         #[serde_as(as = "HexOrDecimalU256")]
-        executed_amount: alloy::primitives::U256,
+        executed_amount: U256,
     },
 }
 
diff --git a/crates/model/src/solver_competition_v2.rs b/crates/model/src/solver_competition_v2.rs
index e9a0ff372a..f36447f506 100644
--- a/crates/model/src/solver_competition_v2.rs
+++ b/crates/model/src/solver_competition_v2.rs
@@ -1,6 +1,6 @@
 use {
     crate::{AuctionId, order::OrderUid},
-    alloy::primitives::{Address, B256, U256},
+    alloy_primitives::{Address, B256, U256},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
diff --git a/crates/model/src/trade.rs b/crates/model/src/trade.rs
index cba1d470a9..586c2afa74 100644
--- a/crates/model/src/trade.rs
+++ b/crates/model/src/trade.rs
@@ -3,7 +3,7 @@
 
 use {
     crate::{fee_policy::ExecutedProtocolFee, order::OrderUid},
-    alloy::primitives::{Address, B256},
+    alloy_primitives::{Address, B256},
     num::BigUint,
     serde::Serialize,
     serde_with::{DisplayFromStr, serde_as},
@@ -37,7 +37,7 @@ mod tests {
     use {
         super::*,
         crate::fee_policy::{FeePolicy, Quote},
-        alloy::primitives::U256,
+        alloy_primitives::U256,
         serde_json::json,
         testlib::assert_json_matches,
     };
diff --git a/crates/number/Cargo.toml b/crates/number/Cargo.toml
index cd89b4d159..1f2a11e921 100644
--- a/crates/number/Cargo.toml
+++ b/crates/number/Cargo.toml
@@ -6,13 +6,13 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+alloy-primitives = { workspace = true, features = ["serde"] }
 anyhow = { workspace = true }
-alloy = { workspace = true, features = ["serde"] }
-ruint = { workspace = true, features = ["num-bigint"] }
 bigdecimal = { workspace = true }
 num = { workspace = true }
-serde_with = { workspace = true }
+ruint = { workspace = true, features = ["num-bigint"] }
 serde = { workspace = true }
+serde_with = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/number/src/conversions.rs b/crates/number/src/conversions.rs
index 0cb508916e..efccde0a16 100644
--- a/crates/number/src/conversions.rs
+++ b/crates/number/src/conversions.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{U256, aliases::I512},
+    alloy_primitives::{U256, aliases::I512},
     anyhow::{Result, ensure},
     bigdecimal::{BigDecimal, num_bigint::ToBigInt},
     num::{BigInt, BigRational, BigUint, Zero, bigint::Sign, rational::Ratio},
@@ -80,8 +80,8 @@ pub fn u256_to_big_decimal(u256: &U256) -> BigDecimal {
 pub fn i512_to_big_int(i512: &I512) -> BigInt {
     BigInt::from_bytes_be(
         match i512.sign() {
-            alloy::primitives::Sign::Positive => Sign::Plus,
-            alloy::primitives::Sign::Negative => Sign::Minus,
+            alloy_primitives::Sign::Positive => Sign::Plus,
+            alloy_primitives::Sign::Negative => Sign::Minus,
         },
         &i512.abs().to_be_bytes::<64>(),
     )
@@ -95,7 +95,7 @@ pub fn i512_to_big_rational(input: &I512) -> BigRational {
 pub fn i512_to_u256(input: &I512) -> Result<U256> {
     anyhow::ensure!(input >= &I512::ZERO, "Negative input value");
     anyhow::ensure!(input < &I512::from(U256::MAX), "Input exceeds U256::MAX");
-    Ok(alloy::primitives::U256::from_be_slice(
+    Ok(alloy_primitives::U256::from_be_slice(
         &input.to_be_bytes::<64>()[32..],
     ))
 }
diff --git a/crates/number/src/nonzero.rs b/crates/number/src/nonzero.rs
index 92daf2b1d2..da0ce46f0b 100644
--- a/crates/number/src/nonzero.rs
+++ b/crates/number/src/nonzero.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::U256,
+    alloy_primitives::U256,
     anyhow::Context,
     serde::{Deserialize, Deserializer, Serialize, Serializer},
     std::fmt::{self, Display, Formatter},
diff --git a/crates/number/src/ratio_ext.rs b/crates/number/src/ratio_ext.rs
index d27c74ee9b..aa70c2faec 100644
--- a/crates/number/src/ratio_ext.rs
+++ b/crates/number/src/ratio_ext.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{U256, U512, ruint::UintTryFrom},
+    alloy_primitives::{U256, U512, ruint::UintTryFrom},
     num::rational::Ratio,
 };
 
diff --git a/crates/number/src/serialization.rs b/crates/number/src/serialization.rs
index 7e4cdb6aef..801e1e8ad0 100644
--- a/crates/number/src/serialization.rs
+++ b/crates/number/src/serialization.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::U256,
+    alloy_primitives::U256,
     serde::{Deserialize, Deserializer, Serializer},
     serde_with::{DeserializeAs, SerializeAs},
 };
@@ -22,7 +22,7 @@ impl SerializeAs<U256> for HexOrDecimalU256 {
     where
         S: Serializer,
     {
-        // alloy::primitives::U256 serializes as hex, this gives us decimals instead
+        // alloy_primitives::U256 serializes as hex, this gives us decimals instead
         serializer.serialize_str(&source.to_string())
     }
 }
diff --git a/crates/number/src/testing.rs b/crates/number/src/testing.rs
index 49da2ffc37..17c71853ba 100644
--- a/crates/number/src/testing.rs
+++ b/crates/number/src/testing.rs
@@ -53,7 +53,7 @@ where
 
 #[cfg(test)]
 mod test {
-    use {super::*, alloy::primitives::U256};
+    use {super::*, alloy_primitives::U256};
 
     #[test]
     fn u64_identical_values() {
diff --git a/crates/number/src/u256_ext.rs b/crates/number/src/u256_ext.rs
index 7a9f87fe88..f54b072b7f 100644
--- a/crates/number/src/u256_ext.rs
+++ b/crates/number/src/u256_ext.rs
@@ -1,7 +1,7 @@
 //! Extension trait for U256 arithmetic operations.
 
 use {
-    alloy::primitives::U256,
+    alloy_primitives::U256,
     num::{BigInt, BigRational, BigUint, One},
 };
 
diff --git a/crates/number/src/units.rs b/crates/number/src/units.rs
index fde77ce0d4..ed9e6c7a2f 100644
--- a/crates/number/src/units.rs
+++ b/crates/number/src/units.rs
@@ -1,4 +1,4 @@
-use alloy::primitives::{U256, utils::Unit};
+use alloy_primitives::{U256, utils::Unit};
 
 pub trait EthUnit: std::marker::Sized {
     /// Converts this value to wei.
diff --git a/crates/order-validation/Cargo.toml b/crates/order-validation/Cargo.toml
index 88196cfdd0..1f6686b5d0 100644
--- a/crates/order-validation/Cargo.toml
+++ b/crates/order-validation/Cargo.toml
@@ -6,13 +6,13 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
 contracts = { workspace = true }
+futures = { workspace = true }
 moka = { workspace = true, features = ["sync"] }
-thiserror = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
-futures = {workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/order-validation/src/banned.rs b/crates/order-validation/src/banned.rs
index f7c27eb8d7..d281b85206 100644
--- a/crates/order-validation/src/banned.rs
+++ b/crates/order-validation/src/banned.rs
@@ -5,7 +5,7 @@
 //! expiry, LRU eviction) with background refresh every 60 seconds.
 
 use {
-    alloy::primitives::Address,
+    alloy_primitives::Address,
     contracts::alloy::ChainalysisOracle,
     futures::future::join_all,
     moka::sync::Cache,
@@ -221,13 +221,7 @@ impl Users {
 }
 
 impl Onchain {
-    async fn fetch(&self, address: Address) -> Result<bool, Error> {
-        Ok(self.contract.isSanctioned(address).call().await?)
+    async fn fetch(&self, address: Address) -> Result<bool, alloy_contract::Error> {
+        self.contract.isSanctioned(address).call().await
     }
 }
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("failed to fetch banned users from onchain")]
-    Onchain(#[from] alloy::contract::Error),
-}
diff --git a/crates/serde-ext/Cargo.toml b/crates/serde-ext/Cargo.toml
index e45beaa60a..f3720ab8f5 100644
--- a/crates/serde-ext/Cargo.toml
+++ b/crates/serde-ext/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-primitives = { workspace = true }
 const-hex = { workspace = true }
 serde = { workspace = true }
-serde_with = { workspace = true }
\ No newline at end of file
+serde_with = { workspace = true }
diff --git a/crates/serde-ext/src/u256.rs b/crates/serde-ext/src/u256.rs
index a0a5e0e9a0..68dc258054 100644
--- a/crates/serde-ext/src/u256.rs
+++ b/crates/serde-ext/src/u256.rs
@@ -1,5 +1,4 @@
 use {
-    alloy::primitives as alloy,
     serde::{Deserializer, Serializer, de},
     serde_with::{DeserializeAs, SerializeAs},
 };
@@ -10,12 +9,14 @@ use {
 #[derive(Debug)]
 pub struct U256;
 
-impl<'de> DeserializeAs<'de, alloy::U256> for U256 {
-    fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<alloy::U256, D::Error> {
+impl<'de> DeserializeAs<'de, alloy_primitives::U256> for U256 {
+    fn deserialize_as<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<alloy_primitives::U256, D::Error> {
         struct Visitor;
 
         impl de::Visitor<'_> for Visitor {
-            type Value = alloy::U256;
+            type Value = alloy_primitives::U256;
 
             fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                 write!(formatter, "a 256-bit decimal string")
@@ -25,7 +26,7 @@ impl<'de> DeserializeAs<'de, alloy::U256> for U256 {
             where
                 E: de::Error,
             {
-                alloy::U256::from_str_radix(s, 10).map_err(|err| {
+                alloy_primitives::U256::from_str_radix(s, 10).map_err(|err| {
                     de::Error::custom(format!("failed to decode {s:?} as a 256-bit number: {err}"))
                 })
             }
@@ -35,8 +36,11 @@ impl<'de> DeserializeAs<'de, alloy::U256> for U256 {
     }
 }
 
-impl SerializeAs<alloy::U256> for U256 {
-    fn serialize_as<S: Serializer>(source: &alloy::U256, serializer: S) -> Result<S::Ok, S::Error> {
+impl SerializeAs<alloy_primitives::U256> for U256 {
+    fn serialize_as<S: Serializer>(
+        source: &alloy_primitives::U256,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
         serializer.serialize_str(&source.to_string())
     }
 }
diff --git a/crates/testlib/Cargo.toml b/crates/testlib/Cargo.toml
index ce872726da..9962c65591 100644
--- a/crates/testlib/Cargo.toml
+++ b/crates/testlib/Cargo.toml
@@ -1,12 +1,15 @@
 [package]
 name = "testlib"
 version = "0.1.0"
-authors = ["Gnosis Developers <developers@gnosis.io>", "Cow Protocol Developers <dev@cow.fi>"]
+authors = [
+  "Gnosis Developers <developers@gnosis.io>",
+  "Cow Protocol Developers <dev@cow.fi>"
+]
 edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = {workspace = true}
+alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
 serde_json = { workspace = true }
 
diff --git a/crates/testlib/src/protocol.rs b/crates/testlib/src/protocol.rs
index 73b2f51cb1..75fc245fbb 100644
--- a/crates/testlib/src/protocol.rs
+++ b/crates/testlib/src/protocol.rs
@@ -1,6 +1,6 @@
 //! Mainnet addresses of protocol contracts.
 
-use alloy::primitives::{Address, address};
+use alloy_primitives::{Address, address};
 
 /// Address for the settlement contract.
 pub const SETTLEMENT: Address = address!("9008D19f58AAbD9eD0D60971565AA8510560ab41");
diff --git a/crates/testlib/src/tokens.rs b/crates/testlib/src/tokens.rs
index 51a5ed2410..bd7493e604 100644
--- a/crates/testlib/src/tokens.rs
+++ b/crates/testlib/src/tokens.rs
@@ -1,6 +1,6 @@
 //! Mainnet addresses of commonly used tokens.
 
-use alloy::primitives::{Address, address};
+use alloy_primitives::{Address, address};
 
 /// Address for the `WETH` token.
 pub const WETH: Address = address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
diff --git a/crates/winner-selection/Cargo.toml b/crates/winner-selection/Cargo.toml
index 3897310c3e..d8e3f9f559 100644
--- a/crates/winner-selection/Cargo.toml
+++ b/crates/winner-selection/Cargo.toml
@@ -4,9 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-alloy = { workspace = true }
-itertools = { workspace = true }
+alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
+itertools = { workspace = true }
+number = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-number = { path = "../number" }
diff --git a/crates/winner-selection/src/arbitrator.rs b/crates/winner-selection/src/arbitrator.rs
index b15c4cdc3a..446df78572 100644
--- a/crates/winner-selection/src/arbitrator.rs
+++ b/crates/winner-selection/src/arbitrator.rs
@@ -11,7 +11,7 @@ use {
         solution::{Order, RankType, Ranked, Scored, Solution, Unscored},
         state::{RankedItem, ScoredItem, UnscoredItem},
     },
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     anyhow::{Context, Result},
     itertools::{Either, Itertools},
     number::u256_ext::U256Ext,
@@ -248,7 +248,7 @@ impl Arbitrator {
                 // to avoid loss of precision because we work with integers we first multiply
                 // and then divide:
                 // buy_amount = surplus * buy_price / sell_price
-                use alloy::primitives::{U512, ruint::UintTryFrom};
+                use alloy_primitives::{U512, ruint::UintTryFrom};
 
                 let surplus_in_buy_tokens = surplus_in_surplus_token
                     .widening_mul(order.buy_amount)
diff --git a/crates/winner-selection/src/auction.rs b/crates/winner-selection/src/auction.rs
index 926c4a5476..d60ad9c6d3 100644
--- a/crates/winner-selection/src/auction.rs
+++ b/crates/winner-selection/src/auction.rs
@@ -6,7 +6,7 @@
 
 use {
     crate::primitives::{FeePolicy, OrderUid},
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     std::collections::{HashMap, HashSet},
 };
 
diff --git a/crates/winner-selection/src/primitives.rs b/crates/winner-selection/src/primitives.rs
index 59a23a12a3..c7aa78ef25 100644
--- a/crates/winner-selection/src/primitives.rs
+++ b/crates/winner-selection/src/primitives.rs
@@ -1,6 +1,6 @@
 //! Primitive types for winner selection.
 
-pub use alloy::primitives::{Address, U256};
+pub use alloy_primitives::{Address, U256};
 
 /// Native token constant.
 pub const NATIVE_TOKEN: Address = Address::repeat_byte(0xee);
diff --git a/crates/winner-selection/src/solution.rs b/crates/winner-selection/src/solution.rs
index ecf5bb6638..4996335d86 100644
--- a/crates/winner-selection/src/solution.rs
+++ b/crates/winner-selection/src/solution.rs
@@ -9,7 +9,7 @@ use {
         primitives::{OrderUid, Side},
         state,
     },
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     std::collections::HashMap,
 };
 pub type Scored = state::Scored<U256>;

From 8842809bbe43c12b1440be5d0fc0450ed10d3159 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 2 Mar 2026 11:13:56 +0000
Subject: [PATCH 114/219] Enhance error handling and reporting for app data
 deserialization (#4213)

# Description
When users provide app data with wrong partner fees, we get less than
good error reporting, for example:
```
{"errorType":"AppDataInvalid","description":"app data has the wrong format: data did not match any variant of untagged enum Helper at line 1 column 232"}
```
This is, not only a pain for us to debug but also for the user:
* For us because the special deserializers are all named Helper
* For the user because of the bad error message

This PR changes the deserialization mechanism in a "non-obvious" way to
provide proper error messages, as untagged enums stand very much against
them.

For example floating point bps are unsupported, they returned the
previous error; after this PR they return:
```
{"errorType":"AppDataInvalid","description":"app data has the wrong format: invalid type: floating point `99.0`, expected u64 at line 1 column 128"}
```

# Changes

* Rename the deserializers
* Refactor the deserializers into weird structs (but better for error
reporting)

## How to test
Unit tests to ensure nothing broke + playground to test the error
```
curl 'http://localhost:8000/api/v1/app_data \
  -X 'PUT' \
  -H 'accept: application/json' \
  -H 'content-type: application/json' \
  --data-raw '{"fullAppData":"{\"appCode\":\"YOUR_APP_CODE\",\"metadata\":{\"partnerFee\":[{\"recipient\":\"0x28c716bC23ed77CAEc27f476A366318ad5F12d58\",\"volumeBps\":99.5},{\"priceImprovementBps\":9900,\"recipient\":\"0x28c716bC23ed77CAEc27f476A366318ad5F12d58\",\"volumeBps\":100}]},\"version\":\"1.14.0\"}"}'
  ```
---
 crates/app-data/src/app_data.rs               | 110 +++++++++++-------
 .../src/domain/competition/order/app_data.rs  |   3 +-
 2 files changed, 72 insertions(+), 41 deletions(-)

diff --git a/crates/app-data/src/app_data.rs b/crates/app-data/src/app_data.rs
index e1dae79ed9..8296705b2c 100644
--- a/crates/app-data/src/app_data.rs
+++ b/crates/app-data/src/app_data.rs
@@ -1,7 +1,7 @@
 use {
     crate::{AppDataHash, Hooks, app_data_hash::hash_full_app_data},
     alloy_primitives::{Address, U256},
-    anyhow::{Context, Result, anyhow},
+    anyhow::{Result, anyhow},
     bytes_hex::BytesHex,
     moka::sync::Cache,
     number::serialization::HexOrDecimalU256,
@@ -138,45 +138,58 @@ impl<'de> Deserialize<'de> for FeePolicy {
     where
         D: Deserializer<'de>,
     {
+        // The untagged enum does not provide enough information when deserialization
+        // fails since it thinks that any unknown or mismatched fields are just
+        // an issue with the enum variant which the error will reflect —
+        // something among the lines of "did not match any variant of the untagged enum"
+        // This is an hacky way of ensuring we get proper behavior when failing to
+        // deserialize numbers, for example, when users send bps as floats
         #[derive(Deserialize)]
-        #[serde(untagged)]
-        enum Helper {
-            #[serde(rename_all = "camelCase")]
-            Surplus {
-                surplus_bps: u64,
-                max_volume_bps: u64,
-            },
-            #[serde(rename_all = "camelCase")]
-            PriceImprovement {
-                price_improvement_bps: u64,
-                max_volume_bps: u64,
-            },
-            #[serde(rename_all = "camelCase")]
-            Volume { volume_bps: u64 },
-            // Originally only volume fees were allowed and they used the field `bps`.
-            // To stay backwards compatible with old appdata we still support this old
-            // format.
-            #[serde(rename_all = "camelCase")]
-            VolumeOld { bps: u64 },
+        #[serde(rename_all = "camelCase")]
+        struct FeePolicyDeserializer {
+            surplus_bps: Option<u64>,
+            max_volume_bps: Option<u64>,
+            price_improvement_bps: Option<u64>,
+            volume_bps: Option<u64>,
+            bps: Option<u64>,
         }
 
-        match Helper::deserialize(deserializer)? {
-            Helper::Surplus {
-                surplus_bps,
-                max_volume_bps,
+        match FeePolicyDeserializer::deserialize(deserializer)? {
+            FeePolicyDeserializer {
+                surplus_bps: Some(surplus_bps),
+                max_volume_bps: Some(max_volume_bps),
+                price_improvement_bps: None,
+                volume_bps: None,
+                bps: None,
             } => Ok(FeePolicy::Surplus {
                 bps: surplus_bps,
                 max_volume_bps,
             }),
-            Helper::PriceImprovement {
-                price_improvement_bps,
-                max_volume_bps,
+            FeePolicyDeserializer {
+                surplus_bps: None,
+                max_volume_bps: Some(max_volume_bps),
+                price_improvement_bps: Some(price_improvement_bps),
+                volume_bps: None,
+                bps: None,
             } => Ok(FeePolicy::PriceImprovement {
                 bps: price_improvement_bps,
                 max_volume_bps,
             }),
-            Helper::Volume { volume_bps } => Ok(FeePolicy::Volume { bps: volume_bps }),
-            Helper::VolumeOld { bps } => Ok(FeePolicy::Volume { bps }),
+            FeePolicyDeserializer {
+                surplus_bps: None,
+                max_volume_bps: None,
+                price_improvement_bps: None,
+                volume_bps: Some(volume_bps),
+                bps: None,
+            } => Ok(FeePolicy::Volume { bps: volume_bps }),
+            FeePolicyDeserializer {
+                surplus_bps: None,
+                max_volume_bps: None,
+                price_improvement_bps: None,
+                volume_bps: None,
+                bps: Some(bps),
+            } => Ok(FeePolicy::Volume { bps }),
+            _ => Err(serde::de::Error::custom("unknown fee policy format")),
         }
     }
 }
@@ -275,8 +288,8 @@ impl Validator {
     }
 }
 
-pub fn parse(full_app_data: &[u8]) -> Result<ProtocolAppData> {
-    let root = serde_json::from_slice::<Root>(full_app_data).context("invalid app data json")?;
+pub fn parse(full_app_data: &[u8]) -> Result<ProtocolAppData, serde_json::Error> {
+    let root = serde_json::from_slice::<Root>(full_app_data)?;
     let parsed = root
         .metadata
         .or_else(|| root.backend.map(ProtocolAppData::from))
@@ -463,17 +476,34 @@ impl<'de> Deserialize<'de> for PartnerFees {
     where
         D: Deserializer<'de>,
     {
-        #[derive(Deserialize)]
-        #[serde(untagged)]
-        enum Helper {
-            Single(PartnerFee),
-            Multiple(Vec<PartnerFee>),
-        }
+        struct PartnerFeesVisitor;
+
+        impl<'de> de::Visitor<'de> for PartnerFeesVisitor {
+            type Value = PartnerFees;
 
-        match Helper::deserialize(deserializer)? {
-            Helper::Single(fee) => Ok(PartnerFees(vec![fee])),
-            Helper::Multiple(fees) => Ok(PartnerFees(fees)),
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a single partner fee object or an array of partner fees")
+            }
+
+            fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                let fee = PartnerFee::deserialize(de::value::MapAccessDeserializer::new(map))?;
+                Ok(PartnerFees(vec![fee]))
+            }
+
+            fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                let fees =
+                    Vec::<PartnerFee>::deserialize(de::value::SeqAccessDeserializer::new(seq))?;
+                Ok(PartnerFees(fees))
+            }
         }
+
+        deserializer.deserialize_any(PartnerFeesVisitor)
     }
 }
 
diff --git a/crates/driver/src/domain/competition/order/app_data.rs b/crates/driver/src/domain/competition/order/app_data.rs
index d9c927457c..513bef8d8e 100644
--- a/crates/driver/src/domain/competition/order/app_data.rs
+++ b/crates/driver/src/domain/competition/order/app_data.rs
@@ -81,7 +81,8 @@ impl AppDataRetriever {
                         true => None, // empty app data
                         false => Some(Arc::new(app_data::ValidatedAppData {
                             hash: app_data::AppDataHash(app_data.0.0),
-                            protocol: app_data::parse(appdata.full_app_data.as_bytes())?,
+                            protocol: app_data::parse(appdata.full_app_data.as_bytes())
+                                .context("invalid app data json")?,
                             document: appdata.full_app_data,
                         })),
                     }

From 213ae8128197538ae458aa71495bc2852dcd94ce Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Mon, 2 Mar 2026 15:22:55 +0100
Subject: [PATCH 115/219] Optimize batching for CoinGecko (#4215)

# Description

I have run a bunch of experiment goal of which was to make CoinGecko
batches bigger (fetch price for more tokens at once) to save on costs.
In a previous experiment I increased `concurrent_requests` on the
`CachingNativePriceEstimator` to 500 and that totally worked and
CoinGecko debounces all these requests nicely, but also means we would
be spamming solvers with a lot of requests at once when we start the
service.

The first issue at hand is that before this PR we would create futures
that would hit the cache and return immediately, which was bad, because
they take up a slot in the queue when using buffered() so fewer useful
futures that actually issue a native price request would get to run. I
changed this to buffered_unordered() and that helped a little bit, but
then the queue gets full and after that new futures get in only as
previous futures finishe, so the execution is spread out in time and our
CoinGecko debouncing can't gather enough tokens to form a full batch.

This PR introduces a solution where we omit non-expired tokens
altogether which solves the issue of futures that hit the cache taking
up a spot in the queue _and_ we just run batches of 19 sequentially. We
wait for each batch to finish (max ~3s, limited by QUERY_TIMEOUT) and
only then issues a new batch. As a tradeoff we get a slower cache warm
up/refresh, but we get to save a lot of money on CoinGecko.

In addition to this change I set the refresh rate to 30s from 1s, so we
can gather more expired tokens at once.

<img width="2103" height="480" alt="Screenshot 2026-03-02 at 11 30 33"
src="https://github.com/user-attachments/assets/190bbefe-ac26-4837-b2c2-05a7c63ebbcb"
/>


# Changes

* [x] Don't try to fetch non-expired prices
* [x] Run batches sequentially
* [x] NATIVE_PRICE_CACHE_REFRESH set to 30s instead of 1s in service
config

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 .../price_estimation/native_price_cache.rs    | 39 +++++++++++++++----
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/crates/shared/src/price_estimation/native_price_cache.rs b/crates/shared/src/price_estimation/native_price_cache.rs
index ccc206ad63..da3bd6dda0 100644
--- a/crates/shared/src/price_estimation/native_price_cache.rs
+++ b/crates/shared/src/price_estimation/native_price_cache.rs
@@ -485,15 +485,40 @@ impl NativePriceUpdater {
 
         let max_age = cache.max_age().saturating_sub(prefetch_time);
         let timeout = self.estimator.0.quote_timeout;
-        self.estimator
-            .estimate_prices_and_update_cache(tokens_to_update.iter().copied(), max_age, timeout)
-            // Drive the stream to completion. Results are written to the cache as
-            // a side effect, so we don't need to inspect them here.
-            .for_each(|_| async {})
-            .await;
+
+        // Pre-filter to only tokens whose cache entries have expired.
+        let now = Instant::now();
+        let expired_tokens: Vec<_> = tokens_to_update
+            .iter()
+            .copied()
+            .filter(|token| Cache::get_cached_price(*token, now, &cache.0.data, &max_age).is_none())
+            .collect();
+
+        // Process expired tokens in chunks, waiting for each chunk to complete
+        // before starting the next. This ensures all tokens in a chunk reach
+        // the BufferedRequest channel simultaneously, producing full CoinGecko
+        // API batches instead of trickling tokens one-by-one. Normally it's
+        // better to just pass the whole vector to `estimate_prices_and_update_cache`
+        // and let it handle the chunking, but in this case we want to ensure that all
+        // tokens go in in chunks of 19 to fetch as many tokens from CoinGecko as is
+        // allowed. We debounce request to CoinGecko to happen once every 100ms
+        // to build the batches and if we use buffer_unordered deeper in the stack the
+        // execution will happen faster, but we will build more smaller batches that we
+        // send to CoinGecko. This happens because we also use estimations from solvers
+        // which vary in time, so as requests in the buffer_unorderd() stream
+        // finish, new ones start immediately, tokens "trickle in" and we build smaller
+        // batches.
+        let chunk_size = self.estimator.0.concurrent_requests;
+        for chunk in expired_tokens.chunks(chunk_size) {
+            self.estimator
+                .estimate_prices_and_update_cache(chunk.iter().copied(), max_age, timeout)
+                .for_each(|_| async {})
+                .await;
+        }
+
         metrics
             .native_price_cache_background_updates
-            .inc_by(tokens_to_update.len() as u64);
+            .inc_by(expired_tokens.len() as u64);
     }
 }
 

From 32fe75abf3cb5d9622dacb834e47e91ec551fcc2 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 2 Mar 2026 16:19:18 +0000
Subject: [PATCH 116/219] Compress `/solve` requests (#4212)

# Description
Our current `/solve` request can be heavy on certain chains, and given
the fact that it is expected to eventually switch to a cross-chain
auction, the data will be growing significantly. While it is expected to
implement a delta-sync approach with event-based auction updates, this
is quite involved, and as a first step, we can look into compressing the
request to reduce its size and reduce network latency/delays.

The tests showed that `brotli` with compression level 1 outperforms
`gzip`
https://github.com/cowprotocol/services/pull/4212#discussion_r2857437463

# Changes

##Autopilot
- New `--compress-solve-request` boolean CLI flag threaded through
`run_loop::Config`
- `solve::Request` gains a `compressed()` method that br-compresses the
body on a blocking task (CPU-intensive, like the existing serialization)
- On compression failure, falls back to sending the uncompressed body
with an error log
- Compression time is tracked via the existing `auction_overhead` metric
- Sets the `Content-Encoding: br` header only when the body is actually
compressed
- Add a `runloop_solve_request_body_size` histogram metric that records
the size (in bytes) of the JSON body sent in each `/solve` request to
drivers.

## Driver
- Adds `RequestDecompressionLayer` to the axum middleware stack, which
automatically decompresses br-encoded request bodies based on the
`Content-Encoding` header

## How to test
New unit and e2e tests. Deploy manually with disabled compression to
collect some metrics and then with compression enabled.

## Related issues

Fixes #4206
---
 Cargo.lock                                    |  38 +++++
 Cargo.toml                                    |   1 +
 crates/autopilot/Cargo.toml                   |   1 +
 crates/autopilot/src/arguments.rs             |   6 +
 .../autopilot/src/infra/solvers/dto/solve.rs  | 141 +++++++++++++++++-
 crates/autopilot/src/run.rs                   |   2 +
 crates/autopilot/src/run_loop.rs              |  13 ++
 crates/autopilot/src/shadow.rs                |  12 +-
 crates/driver/Cargo.toml                      |   2 +-
 crates/driver/src/infra/api/mod.rs            |   1 +
 crates/e2e/src/setup/proxy.rs                 |  35 ++++-
 crates/e2e/tests/e2e/limit_orders.rs          |  59 +++++++-
 12 files changed, 295 insertions(+), 16 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 37a8e30dab..071d2948a0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,6 +26,21 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
 [[package]]
 name = "allocator-api2"
 version = "0.2.21"
@@ -1164,6 +1179,7 @@ dependencies = [
  "async-trait",
  "axum 0.8.8",
  "bigdecimal",
+ "brotli",
  "bytes",
  "bytes-hex",
  "chain",
@@ -1953,6 +1969,27 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
 [[package]]
 name = "bs58"
 version = "0.5.1"
@@ -2210,6 +2247,7 @@ version = "0.4.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "00828ba6fd27b45a448e57dbfe84f1029d4c9f26b368157e9a448a5f49a2ec2a"
 dependencies = [
+ "brotli",
  "compression-core",
  "flate2",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index 79f6822180..87304a8dd4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ derive_more = { version = "1.0.0", features = ["full"] }
 mimalloc = "0.1.43"
 tikv-jemallocator = { version = "0.6", features = ["unprefixed_malloc_on_supported_platforms", "profiling"] }
 jemalloc_pprof = { version = "0.8", features = ["symbolize"] }
+brotli = "8"
 flate2 = "1.0.30"
 futures = "0.3.30"
 const-hex = "1.17.0"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index f5cf28d197..77ad511d0d 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -32,6 +32,7 @@ dashmap = { workspace = true }
 database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
+brotli = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
 const-hex = { workspace = true }
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 0e88364672..846cc95468 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -170,6 +170,10 @@ pub struct CliArguments {
     #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
     pub enable_leader_lock: bool,
 
+    /// Enables brotli compression of `/solve` request bodies sent to drivers.
+    #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
+    pub compress_solve_request: bool,
+
     /// Limits the amount of time the autopilot may spend running the
     /// maintenance logic between 2 auctions. When this times out we prefer
     /// running a not fully updated auction over stalling the protocol any
@@ -209,6 +213,7 @@ impl std::fmt::Display for CliArguments {
             max_solutions_per_solver,
             disable_order_balance_filter,
             enable_leader_lock,
+            compress_solve_request,
             max_maintenance_timeout,
         } = self;
         write!(f, "{}", config.display())?;
@@ -251,6 +256,7 @@ impl std::fmt::Display for CliArguments {
             "disable_order_balance_filter: {disable_order_balance_filter}"
         )?;
         writeln!(f, "enable_leader_lock: {enable_leader_lock}")?;
+        writeln!(f, "compress_solve_request: {compress_solve_request}")?;
         writeln!(f, "max_maintenance_timeout: {max_maintenance_timeout:?}")?;
         Ok(())
     }
diff --git a/crates/autopilot/src/infra/solvers/dto/solve.rs b/crates/autopilot/src/infra/solvers/dto/solve.rs
index 0746ed0faa..3e86a69c4b 100644
--- a/crates/autopilot/src/infra/solvers/dto/solve.rs
+++ b/crates/autopilot/src/infra/solvers/dto/solve.rs
@@ -8,16 +8,18 @@ use {
         },
     },
     alloy::primitives::{Address, U256},
+    brotli::enc::writer::CompressorWriter,
     bytes::Bytes,
     chrono::{DateTime, Utc},
     itertools::Itertools,
     number::serialization::HexOrDecimalU256,
-    reqwest::RequestBuilder,
+    reqwest::{RequestBuilder, header::HeaderValue},
     serde::{Deserialize, Serialize},
     serde_with::{DisplayFromStr, serde_as},
     std::{
         borrow::Cow,
         collections::{HashMap, HashSet},
+        io::Write,
         time::Duration,
     },
 };
@@ -30,6 +32,7 @@ use {
 pub struct Request {
     auction_id: i64,
     body: bytes::Bytes,
+    content_encoding: Option<HeaderValue>,
 }
 
 impl Request {
@@ -37,6 +40,7 @@ impl Request {
         auction: &domain::Auction,
         trusted_tokens: &HashSet<Address>,
         time_limit: Duration,
+        compress: bool,
     ) -> Self {
         let _timer =
             observe::metrics::metrics().on_auction_overhead_start("autopilot", "serialize_request");
@@ -68,21 +72,60 @@ impl Request {
         };
         let auction_id = auction.id;
 
-        let body = tokio::task::spawn_blocking(move || {
+        let (body, content_encoding) = tokio::task::spawn_blocking(move || {
             let serialized = serde_json::to_vec(&helper).expect("type should be JSON serializable");
-            Bytes::from(serialized)
+
+            if !compress {
+                return (Bytes::from(serialized), None);
+            }
+
+            // quality 1: fastest brotli level. Already beats gzip-3 on both
+            // ratio and speed for our JSON payloads.
+            //
+            // lgwin 22: LZ77 window = 2^22 - 16 ≈ 4 MB. How far back the
+            // compressor looks for repeated patterns. The decompressor must
+            // allocate up to this much memory. Aligns with our current auction size
+            // (~3-4mb).
+            //
+            // 4096: internal I/O buffer for flushing to the output Vec.
+            // Doesn't affect compression ratio. Tested 512 B to 256 KB with
+            // no meaningful difference; 4 KB is a standard default.
+            let mut encoder = CompressorWriter::new(Vec::new(), 4096, 1, 22);
+            match encoder.write_all(&serialized).and_then(|_| encoder.flush()) {
+                Ok(()) => (
+                    Bytes::from(encoder.into_inner()),
+                    Some(HeaderValue::from_static("br")),
+                ),
+                Err(err) => {
+                    tracing::error!(
+                        ?err,
+                        "brotli compression failed, falling back to uncompressed"
+                    );
+                    (Bytes::from(serialized), None)
+                }
+            }
         })
         .await
         .expect("inner task should not panic as serialization should work for the given type");
 
-        Self { body, auction_id }
+        Self {
+            body,
+            auction_id,
+            content_encoding,
+        }
+    }
+
+    pub fn body_size(&self) -> usize {
+        self.body.len()
     }
 }
 
 impl InjectIntoHttpRequest for Request {
     fn inject(&self, request: RequestBuilder) -> RequestBuilder {
-        request
-            .body(reqwest::Body::wrap_stream(ByteStream::new(self.body.clone())))
+        let request = request
+            .body(reqwest::Body::wrap_stream(ByteStream::new(
+                self.body.clone(),
+            )))
             // announce which auction this request is for in the
             // headers to help the driver detect duplicated
             // `/solve` requests before streaming the body
@@ -91,11 +134,19 @@ impl InjectIntoHttpRequest for Request {
             // we can't use `request.json(self)`
             .header(
                 reqwest::header::CONTENT_TYPE,
-                reqwest::header::HeaderValue::from_static("application/json")
-            )
+                reqwest::header::HeaderValue::from_static("application/json"),
+            );
+        if let Some(encoding) = &self.content_encoding {
+            request.header(reqwest::header::CONTENT_ENCODING, encoding)
+        } else {
+            request
+        }
     }
 
     fn body_to_string(&self) -> Cow<'_, str> {
+        if self.content_encoding.is_some() {
+            return Cow::Borrowed("<compressed>");
+        }
         let string = str::from_utf8(self.body.as_ref()).unwrap();
         Cow::Borrowed(string)
     }
@@ -229,3 +280,77 @@ pub struct Solution {
 pub struct Response {
     pub solutions: Vec<Solution>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_test_json() -> Vec<u8> {
+        let json_value = serde_json::json!({
+            "id": "1",
+            "tokens": (0..100).map(|i| {
+                serde_json::json!({
+                    "address": format!("0x{:040x}", i),
+                    "price": format!("{}", i * 1000),
+                    "trusted": i % 2 == 0
+                })
+            }).collect::<Vec<_>>(),
+            "orders": [],
+            "deadline": "2025-01-01T00:00:00Z",
+            "surplusCapturingJitOrderOwners": []
+        });
+        serde_json::to_vec(&json_value).unwrap()
+    }
+
+    fn uncompressed_request(json: Vec<u8>) -> Request {
+        Request {
+            auction_id: 1,
+            body: Bytes::from(json),
+            content_encoding: None,
+        }
+    }
+
+    fn compressed_request(json: &[u8]) -> Request {
+        use brotli::enc::writer::CompressorWriter;
+
+        let mut encoder = CompressorWriter::new(Vec::new(), 4096, 1, 22);
+        encoder.write_all(json).unwrap();
+        encoder.flush().unwrap();
+        let compressed = encoder.into_inner();
+        Request {
+            auction_id: 1,
+            body: Bytes::from(compressed),
+            content_encoding: Some(HeaderValue::from_static("br")),
+        }
+    }
+
+    #[test]
+    fn compressed_request_round_trips() {
+        let json = make_test_json();
+
+        let request = compressed_request(&json);
+        assert_eq!(
+            request.content_encoding.as_ref().map(|v| v.as_bytes()),
+            Some("br".as_bytes())
+        );
+        assert!(
+            request.body.len() < json.len(),
+            "compressed body {} should be smaller than original {}",
+            request.body.len(),
+            json.len(),
+        );
+
+        let mut decompressed = Vec::new();
+        brotli::BrotliDecompress(&mut request.body.as_ref(), &mut decompressed).unwrap();
+        assert_eq!(decompressed, json);
+    }
+
+    #[test]
+    fn uncompressed_request_preserves_json() {
+        let json = make_test_json();
+        let request = uncompressed_request(json.clone());
+
+        assert_eq!(request.content_encoding, None);
+        assert_eq!(request.body.as_ref(), json.as_slice());
+    }
+}
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 9d9777b385..4c41095b25 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -588,6 +588,7 @@ pub async fn run(
         max_winners_per_auction: args.max_winners_per_auction,
         max_solutions_per_solver: args.max_solutions_per_solver,
         enable_leader_lock: args.enable_leader_lock,
+        compress_solve_request: args.compress_solve_request,
     };
 
     let drivers_futures = config
@@ -713,6 +714,7 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
         drivers,
         trusted_tokens,
         args.solve_deadline,
+        args.compress_solve_request,
         liveness.clone(),
         current_block,
         args.max_winners_per_auction,
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 43ebbaed7a..254fff49be 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -65,6 +65,7 @@ pub struct Config {
     pub max_winners_per_auction: NonZeroUsize,
     pub max_solutions_per_solver: NonZeroUsize,
     pub enable_leader_lock: bool,
+    pub compress_solve_request: bool,
 }
 
 pub struct Probes {
@@ -561,8 +562,10 @@ impl RunLoop {
             auction,
             &self.trusted_tokens.all(),
             self.config.solve_deadline,
+            self.config.compress_solve_request,
         )
         .await;
+        Metrics::solve_request_body_size(request.body_size());
 
         let mut bids = futures::future::join_all(
             self.drivers
@@ -984,6 +987,12 @@ struct Metrics {
     /// function is started.
     #[metric(buckets(0, 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 4, 5, 6))]
     current_block_delay: prometheus::Histogram,
+
+    /// Tracks the size of the `/solve` request body in bytes.
+    #[metric(buckets(
+        1_000, 5_000, 10_000, 50_000, 100_000, 500_000, 1_000_000, 2_000_000, 3_000_000, 4_000_000
+    ))]
+    solve_request_body_size: prometheus::Histogram,
 }
 
 impl Metrics {
@@ -1078,6 +1087,10 @@ impl Metrics {
             .current_block_delay
             .observe(init_block_timestamp.elapsed().as_secs_f64())
     }
+
+    fn solve_request_body_size(size: usize) {
+        Self::get().solve_request_body_size.observe(size as f64)
+    }
 }
 
 pub mod observe {
diff --git a/crates/autopilot/src/shadow.rs b/crates/autopilot/src/shadow.rs
index de6072f4ef..991bacf6e5 100644
--- a/crates/autopilot/src/shadow.rs
+++ b/crates/autopilot/src/shadow.rs
@@ -39,6 +39,7 @@ pub struct RunLoop {
     auction: domain::auction::Id,
     block: u64,
     solve_deadline: Duration,
+    compress_solve_request: bool,
     liveness: Arc<Liveness>,
     current_block: CurrentBlockWatcher,
     winner_selection: winner_selection::Arbitrator,
@@ -51,6 +52,7 @@ impl RunLoop {
         drivers: Vec<Arc<infra::Driver>>,
         trusted_tokens: AutoUpdatingTokenList,
         solve_deadline: Duration,
+        compress_solve_request: bool,
         liveness: Arc<Liveness>,
         current_block: CurrentBlockWatcher,
         max_winners_per_auction: NonZeroUsize,
@@ -67,6 +69,7 @@ impl RunLoop {
             auction: 0,
             block: 0,
             solve_deadline,
+            compress_solve_request,
             liveness,
             current_block,
         }
@@ -179,8 +182,13 @@ impl RunLoop {
     /// Runs the solver competition, making all configured drivers participate.
     #[instrument(skip_all)]
     async fn competition(&self, auction: &domain::Auction) -> Vec<Bid<Unscored>> {
-        let request =
-            solve::Request::new(auction, &self.trusted_tokens.all(), self.solve_deadline).await;
+        let request = solve::Request::new(
+            auction,
+            &self.trusted_tokens.all(),
+            self.solve_deadline,
+            self.compress_solve_request,
+        )
+        .await;
 
         futures::future::join_all(
             self.drivers
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index a3ceb59a24..a1c0f6d304 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -52,7 +52,7 @@ thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "time"] }
 toml = { workspace = true }
 tower = { workspace = true }
-tower-http = { workspace = true, features = ["limit", "trace"] }
+tower-http = { workspace = true, features = ["decompression-br", "limit", "trace"] }
 url = { workspace = true, features = ["serde"] }
 
 # These still use { workspace = true } because they're used at
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index c909704f9d..d64dca38ca 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -138,6 +138,7 @@ impl Api {
             // axum's default body limit is 2MB too low for solvers, 20MB is still too low
             // so instead of constantly guessing and updating, we disable the limit altogether
             .layer(axum::extract::DefaultBodyLimit::disable())
+            .layer(tower_http::decompression::RequestDecompressionLayer::new())
             .layer(
                 tower::ServiceBuilder::new()
                     .layer(tower_http::trace::TraceLayer::new_for_http().make_span_with(make_span))
diff --git a/crates/e2e/src/setup/proxy.rs b/crates/e2e/src/setup/proxy.rs
index 6c8ca9962f..726b0cf90c 100644
--- a/crates/e2e/src/setup/proxy.rs
+++ b/crates/e2e/src/setup/proxy.rs
@@ -23,6 +23,8 @@ use {
     url::Url,
 };
 
+pub type OnRequest = Arc<dyn Fn(&axum::http::request::Parts, &[u8]) + Send + Sync>;
+
 /// HTTP reverse proxy with automatic failover that permanently switches
 /// to the fallback backend when the current backend fails.
 ///
@@ -35,6 +37,7 @@ pub struct ReverseProxy {
 #[derive(Clone)]
 struct ProxyState {
     backends: Arc<RwLock<VecDeque<Url>>>,
+    on_request: Option<OnRequest>,
 }
 
 impl ProxyState {
@@ -71,6 +74,27 @@ impl ReverseProxy {
     /// # Panics
     /// Panics if `backends` is empty. At least one backend URL is required.
     pub fn start(listen_addr: SocketAddr, backends: &[Url]) -> Self {
+        Self::start_inner(listen_addr, backends, None)
+    }
+
+    /// Start a new proxy server with a callback invoked on each request
+    /// before it is forwarded to the backend.
+    ///
+    /// # Panics
+    /// Panics if `backends` is empty. At least one backend URL is required.
+    pub fn start_with_callback(
+        listen_addr: SocketAddr,
+        backends: &[Url],
+        on_request: OnRequest,
+    ) -> Self {
+        Self::start_inner(listen_addr, backends, Some(on_request))
+    }
+
+    fn start_inner(
+        listen_addr: SocketAddr,
+        backends: &[Url],
+        on_request: Option<OnRequest>,
+    ) -> Self {
         assert!(
             !backends.is_empty(),
             "At least one backend URL is required for the proxy"
@@ -80,6 +104,7 @@ impl ReverseProxy {
 
         let state = ProxyState {
             backends: Arc::new(RwLock::new(backends_queue)),
+            on_request,
         };
 
         let backends_log: Vec<Url> = backends.to_vec();
@@ -127,6 +152,10 @@ async fn handle_request(
         }
     };
 
+    if let Some(on_request) = &state.on_request {
+        on_request(&parts, &body_bytes);
+    }
+
     let backend_count = state.backend_count().await;
 
     for attempt in 0..backend_count {
@@ -160,8 +189,10 @@ async fn try_backend(
         .map(|pq| pq.as_str())
         .unwrap_or("");
 
-    // Build the full URL by combining backend and path
-    let url = format!("{}{}", backend, path);
+    // Build the full URL by combining backend and path.
+    // Url Display always includes a trailing slash, so trim it to avoid
+    // double slashes (e.g. "http://host:port//path").
+    let url = format!("{}{}", backend.as_str().trim_end_matches('/'), path);
     // Build a reqwest request with the same method
     let mut backend_req = client.request(parts.method.clone(), &url);
     // Forward all headers from the original request
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 625da8ec6e..308d369c9e 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -13,7 +13,10 @@ use {
     contracts::alloy::ERC20,
     database::byte_array::ByteArray,
     driver::domain::eth::NonZeroU256,
-    e2e::setup::*,
+    e2e::setup::{
+        proxy::{OnRequest, ReverseProxy},
+        *,
+    },
     ethrpc::alloy::CallBuilderExt,
     model::{
         order::{OrderClass, OrderCreation, OrderKind},
@@ -23,7 +26,15 @@ use {
     number::{conversions::big_decimal_to_big_uint, units::EthUnit},
     orderbook::config::order_validation::OrderValidationConfig,
     shared::web3::Web3,
-    std::{collections::HashMap, ops::DerefMut, str::FromStr},
+    std::{
+        collections::HashMap,
+        ops::DerefMut,
+        str::FromStr,
+        sync::{
+            Arc,
+            atomic::{AtomicBool, Ordering},
+        },
+    },
     url::Url,
 };
 
@@ -317,7 +328,44 @@ async fn two_limit_orders_test(web3: Web3) {
 
     // Place Orders
     let services = Services::new(&onchain).await;
-    services.start_protocol(solver).await;
+
+    // Start a reverse proxy between autopilot and the driver to inspect
+    // requests and assert that /solve requests are brotli-compressed.
+    let saw_compressed_solve = Arc::new(AtomicBool::new(false));
+    let flag = saw_compressed_solve.clone();
+    let on_request: OnRequest = Arc::new(move |parts, _body| {
+        let path = parts.uri.path();
+        let has_br = parts
+            .headers
+            .get("content-encoding")
+            .and_then(|v: &axum::http::HeaderValue| v.to_str().ok())
+            .is_some_and(|v| v == "br");
+        if path.contains("/solve") && has_br {
+            flag.store(true, Ordering::Release);
+        }
+    });
+    let proxy_addr: std::net::SocketAddr = "0.0.0.0:11089".parse().unwrap();
+    let backend: Url = "http://0.0.0.0:11088".parse().unwrap();
+    let _proxy = ReverseProxy::start_with_callback(proxy_addr, &[backend], on_request);
+
+    let config = Configuration {
+        drivers: vec![Solver::new(
+            "test_solver".to_string(),
+            "http://localhost:11089/test_solver".parse().unwrap(),
+            Account::Address(solver.address()),
+        )],
+        ..Default::default()
+    };
+    let (_config_file, config_arg) = config.to_cli_args();
+    services
+        .start_protocol_with_args(
+            ExtraServiceArgs {
+                autopilot: vec![config_arg, "--compress-solve-request=true".to_string()],
+                ..Default::default()
+            },
+            solver,
+        )
+        .await;
 
     let order_a = OrderCreation {
         sell_token: *token_a.address(),
@@ -373,6 +421,11 @@ async fn two_limit_orders_test(web3: Web3) {
     })
     .await
     .unwrap();
+
+    assert!(
+        saw_compressed_solve.load(Ordering::Acquire),
+        "expected /solve requests to be brotli-compressed"
+    );
 }
 
 async fn two_limit_orders_multiple_winners_test(web3: Web3) {

From 0684d7cf58c69c60604d6e1f1421f1f63682e32d Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 3 Mar 2026 13:24:32 +0100
Subject: [PATCH 117/219] split off new crates from `shared` (#4223)

# Description
`shared` is a big ball of spaghetti where dependencies are extremely
unclear.
This PR untangles this somewhat

# Changes
- moves some code out of shared to the only location where it's used
    - `trace_many` into `bad_token::trace_call`
    - `CodeFetching` into `trade_verifier`
    - `BlockRetrieving` into `event-indexing`
    - `tenderly_api` into `trade_verifier`
    - `subgraph` into `sources`
    - `RecentBlockCache` into `sources`
- create separate crates for `balance-overrides`, `event-indexing`,
`account-balances`, `request-sharing`, `token-info`, `liquidity-sources`
- moved `BaseTokens` and `BaselineSolvable` into `liquidity-sources` as
that made the most sense to me

Some of the new crates are super tiny but are necessary to later move
`price-estimation` into a separate crate as well.

This already cut the compilation time of `shard` in half which are gains
we'll often see in incremental builds

<img width="296" height="240" alt="Screenshot 2026-03-03 at 10 31 50"
src="https://github.com/user-attachments/assets/6e69a751-5e7a-435b-b74b-4d51fb5dc1ee"
/>
<img width="277" height="353" alt="Screenshot 2026-03-03 at 10 31 55"
src="https://github.com/user-attachments/assets/2026624c-d3aa-464c-af71-408f2e51c3f1"
/>


## How to test
compiler
---
 Cargo.lock                                    | 238 +++++++++++++++-
 Cargo.toml                                    |   6 +
 crates/account-balances/Cargo.toml            |  30 +++
 crates/account-balances/LICENSE-APACHE        |   1 +
 crates/account-balances/LICENSE-MIT           |   1 +
 .../src}/cached.rs                            |   4 +-
 .../mod.rs => account-balances/src/lib.rs}    |  13 +-
 .../src}/simulation.rs                        |   4 +-
 crates/autopilot/Cargo.toml                   |   3 +
 .../src/boundary/events/settlement.rs         |   7 +-
 .../ethflow_events/event_retriever.rs         |   3 +-
 .../database/ethflow_events/event_storing.rs  |   3 +-
 .../onchain_order_events/event_retriever.rs   |   3 +-
 .../src/database/onchain_order_events/mod.rs  |   7 +-
 crates/autopilot/src/database/quotes.rs       |  22 +-
 crates/autopilot/src/event_updater.rs         |   7 +-
 crates/autopilot/src/maintenance.rs           |   4 +-
 crates/autopilot/src/run.rs                   |  12 +-
 crates/autopilot/src/solvable_orders.rs       |   2 +-
 crates/balance-overrides/Cargo.toml           |  28 ++
 crates/balance-overrides/LICENSE-APACHE       |   1 +
 crates/balance-overrides/LICENSE-MIT          |   1 +
 .../src}/detector.rs                          |  10 +-
 .../mod.rs => balance-overrides/src/lib.rs}   |   0
 crates/cow-amm/Cargo.toml                     |   1 +
 crates/cow-amm/src/cache.rs                   |   3 +-
 crates/cow-amm/src/factory.rs                 |   2 +-
 crates/cow-amm/src/maintainers.rs             |   2 +-
 crates/cow-amm/src/registry.rs                |  10 +-
 crates/driver/Cargo.toml                      |   6 +
 .../src/boundary/liquidity/balancer/v2/mod.rs |  15 +-
 .../liquidity/balancer/v2/weighted.rs         |   2 +-
 crates/driver/src/boundary/liquidity/mod.rs   |   8 +-
 crates/driver/src/boundary/liquidity/swapr.rs |   2 +-
 .../src/boundary/liquidity/uniswap/v2.rs      |  12 +-
 .../src/boundary/liquidity/uniswap/v3.rs      |  10 +-
 .../src/domain/competition/pre_processing.rs  |   8 +-
 .../risk_detector/bad_tokens/simulation.rs    |   6 +-
 crates/driver/src/infra/api/mod.rs            |   1 -
 crates/driver/src/infra/blockchain/mod.rs     |  12 +-
 crates/driver/src/infra/liquidity/config.rs   |   4 +-
 crates/driver/src/infra/tokens.rs             |   2 +-
 crates/e2e/Cargo.toml                         |   2 +
 crates/e2e/src/setup/deploy.rs                |   4 +-
 crates/e2e/tests/e2e/quote_verification.rs    |  15 +-
 crates/ethrpc/src/block_stream.rs             | 254 +-----------------
 crates/event-indexing/Cargo.toml              |  27 ++
 crates/event-indexing/LICENSE-APACHE          |   1 +
 crates/event-indexing/LICENSE-MIT             |   1 +
 crates/event-indexing/src/block_retriever.rs  | 180 +++++++++++++
 .../src/event_handler.rs}                     |   7 +-
 crates/event-indexing/src/lib.rs              |   3 +
 .../src/maintenance.rs                        |   0
 crates/liquidity-sources/Cargo.toml           |  50 ++++
 crates/liquidity-sources/LICENSE-APACHE       |   1 +
 crates/liquidity-sources/LICENSE-MIT          |   1 +
 .../src}/balancer_v2/graph_api.rs             |   5 +-
 .../src}/balancer_v2/mod.rs                   |   0
 .../balancer_v2/pool_fetching/aggregate.rs    |   2 +-
 .../src}/balancer_v2/pool_fetching/cache.rs   |   2 +-
 .../balancer_v2/pool_fetching/internal.rs     |   2 +-
 .../src}/balancer_v2/pool_fetching/mod.rs     |  13 +-
 .../balancer_v2/pool_fetching/pool_storage.rs |   9 +-
 .../balancer_v2/pool_fetching/registry.rs     |  16 +-
 .../src}/balancer_v2/pool_init.rs             |   0
 .../src}/balancer_v2/pools/common.rs          |  15 +-
 .../balancer_v2/pools/composable_stable.rs    |   4 +-
 .../pools/liquidity_bootstrapping.rs          |   4 +-
 .../src}/balancer_v2/pools/mod.rs             |   0
 .../src}/balancer_v2/pools/stable.rs          |   4 +-
 .../src}/balancer_v2/pools/weighted.rs        |   4 +-
 .../src}/balancer_v2/swap/error.rs            |   0
 .../src}/balancer_v2/swap/fixed_point.rs      |   0
 .../swap/fixed_point/logexpmath.rs            |   0
 .../src}/balancer_v2/swap/math.rs             |   0
 .../src}/balancer_v2/swap/mod.rs              |   9 +-
 .../src}/balancer_v2/swap/stable_math.rs      |   4 +-
 .../src}/balancer_v2/swap/weighted_math.rs    |   0
 crates/liquidity-sources/src/base_tokens.rs   | 253 +++++++++++++++++
 .../src/baseline_solvable.rs                  |  29 ++
 .../mod.rs => liquidity-sources/src/lib.rs}   |   5 +
 crates/liquidity-sources/src/macros.rs        |  20 ++
 .../src/recent_block_cache.rs                 |   2 +-
 .../src/subgraph.rs                           |   1 +
 .../src}/swapr.rs                             |  10 +-
 .../src}/uniswap_v2/mod.rs                    |   7 +-
 .../src}/uniswap_v2/pair_provider.rs          |   0
 .../src}/uniswap_v2/pool_cache.rs             |   2 +-
 .../src}/uniswap_v2/pool_fetching.rs          |   4 +-
 .../src}/uniswap_v3/event_fetching.rs         |   6 +-
 .../src}/uniswap_v3/graph_api.rs              |   3 +-
 .../src}/uniswap_v3/mod.rs                    |   0
 .../src}/uniswap_v3/pool_fetching.rs          |  16 +-
 .../src}/uniswap_v3_pair_provider.rs          |   0
 crates/orderbook/Cargo.toml                   |   2 +
 crates/orderbook/src/run.rs                   |   6 +-
 crates/request-sharing/Cargo.toml             |  16 ++
 crates/request-sharing/LICENSE-APACHE         |   1 +
 crates/request-sharing/LICENSE-MIT            |   1 +
 .../src/lib.rs}                               |   0
 crates/shared/Cargo.toml                      |   8 +-
 crates/shared/src/arguments.rs                |   6 +-
 crates/shared/src/bad_token/trace_call.rs     |  23 +-
 crates/shared/src/lib.rs                      |  18 --
 crates/shared/src/macros.rs                   |  21 --
 crates/shared/src/order_quoting.rs            |   4 +-
 crates/shared/src/order_validation.rs         |  10 +-
 crates/shared/src/price_estimation/factory.rs |  11 +-
 crates/shared/src/price_estimation/mod.rs     |   2 +-
 .../src/price_estimation/native/coingecko.rs  |  12 +-
 .../src/price_estimation/native/oneinch.rs    |   9 +-
 .../trade_verifier}/code_fetching.rs          |   0
 .../price_estimation/trade_verifier/mod.rs    |  13 +-
 .../trade_verifier}/tenderly_api.rs           |  18 --
 crates/shared/src/signature_validator/mod.rs  |   5 +-
 .../src/signature_validator/simulation.rs     |  10 +-
 crates/shared/src/trace_many.rs               |  99 -------
 crates/shared/src/trade_finding/external.rs   |   2 +-
 crates/solver/Cargo.toml                      |   2 +
 crates/solver/src/liquidity/balancer_v2.rs    |  26 +-
 crates/solver/src/liquidity/mod.rs            |  30 +--
 crates/solver/src/liquidity/uniswap_v2.rs     |   7 +-
 crates/solver/src/liquidity/uniswap_v3.rs     |   7 +-
 crates/solver/src/liquidity/zeroex.rs         |   8 +-
 crates/solver/src/liquidity_collector.rs      |   4 +-
 crates/solver/src/solver.rs                   |   7 +-
 crates/solvers/Cargo.toml                     |   2 +
 crates/solvers/src/boundary/baseline.rs       |  25 +-
 .../src/boundary/liquidity/concentrated.rs    |   2 +-
 .../boundary/liquidity/constant_product.rs    |   2 +-
 .../src/boundary/liquidity/limit_order.rs     |   3 +-
 .../solvers/src/boundary/liquidity/stable.rs  |   4 +-
 .../boundary/liquidity/weighted_product.rs    |   4 +-
 crates/solvers/src/boundary/mod.rs            |   1 +
 .../src/boundary/routing.rs}                  | 149 +---------
 crates/token-info/Cargo.toml                  |  29 ++
 crates/token-info/LICENSE-APACHE              |   1 +
 crates/token-info/LICENSE-MIT                 |   1 +
 .../token_info.rs => token-info/src/lib.rs}   |   0
 139 files changed, 1242 insertions(+), 882 deletions(-)
 create mode 100644 crates/account-balances/Cargo.toml
 create mode 120000 crates/account-balances/LICENSE-APACHE
 create mode 120000 crates/account-balances/LICENSE-MIT
 rename crates/{shared/src/account_balances => account-balances/src}/cached.rs (98%)
 rename crates/{shared/src/account_balances/mod.rs => account-balances/src/lib.rs} (94%)
 rename crates/{shared/src/account_balances => account-balances/src}/simulation.rs (98%)
 create mode 100644 crates/balance-overrides/Cargo.toml
 create mode 120000 crates/balance-overrides/LICENSE-APACHE
 create mode 120000 crates/balance-overrides/LICENSE-MIT
 rename crates/{shared/src/price_estimation/trade_verifier/balance_overrides => balance-overrides/src}/detector.rs (98%)
 rename crates/{shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs => balance-overrides/src/lib.rs} (100%)
 create mode 100644 crates/event-indexing/Cargo.toml
 create mode 120000 crates/event-indexing/LICENSE-APACHE
 create mode 120000 crates/event-indexing/LICENSE-MIT
 create mode 100644 crates/event-indexing/src/block_retriever.rs
 rename crates/{shared/src/event_handling.rs => event-indexing/src/event_handler.rs} (99%)
 create mode 100644 crates/event-indexing/src/lib.rs
 rename crates/{shared => event-indexing}/src/maintenance.rs (100%)
 create mode 100644 crates/liquidity-sources/Cargo.toml
 create mode 120000 crates/liquidity-sources/LICENSE-APACHE
 create mode 120000 crates/liquidity-sources/LICENSE-MIT
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/graph_api.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/mod.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_fetching/aggregate.rs (94%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_fetching/cache.rs (98%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_fetching/internal.rs (91%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_fetching/mod.rs (98%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_fetching/pool_storage.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_fetching/registry.rs (95%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pool_init.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pools/common.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pools/composable_stable.rs (97%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pools/liquidity_bootstrapping.rs (97%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pools/mod.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pools/stable.rs (97%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/pools/weighted.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/error.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/fixed_point.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/fixed_point/logexpmath.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/math.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/mod.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/stable_math.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/balancer_v2/swap/weighted_math.rs (100%)
 create mode 100644 crates/liquidity-sources/src/base_tokens.rs
 create mode 100644 crates/liquidity-sources/src/baseline_solvable.rs
 rename crates/{shared/src/sources/mod.rs => liquidity-sources/src/lib.rs} (95%)
 create mode 100644 crates/liquidity-sources/src/macros.rs
 rename crates/{shared => liquidity-sources}/src/recent_block_cache.rs (99%)
 rename crates/{shared => liquidity-sources}/src/subgraph.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/swapr.rs (93%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v2/mod.rs (98%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v2/pair_provider.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v2/pool_cache.rs (95%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v2/pool_fetching.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v3/event_fetching.rs (98%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v3/graph_api.rs (99%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v3/mod.rs (100%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v3/pool_fetching.rs (98%)
 rename crates/{shared/src/sources => liquidity-sources/src}/uniswap_v3_pair_provider.rs (100%)
 create mode 100644 crates/request-sharing/Cargo.toml
 create mode 120000 crates/request-sharing/LICENSE-APACHE
 create mode 120000 crates/request-sharing/LICENSE-MIT
 rename crates/{shared/src/request_sharing.rs => request-sharing/src/lib.rs} (100%)
 rename crates/shared/src/{ => price_estimation/trade_verifier}/code_fetching.rs (100%)
 rename crates/shared/src/{ => price_estimation/trade_verifier}/tenderly_api.rs (97%)
 delete mode 100644 crates/shared/src/trace_many.rs
 rename crates/{shared/src/baseline_solver.rs => solvers/src/boundary/routing.rs} (72%)
 create mode 100644 crates/token-info/Cargo.toml
 create mode 120000 crates/token-info/LICENSE-APACHE
 create mode 120000 crates/token-info/LICENSE-MIT
 rename crates/{shared/src/token_info.rs => token-info/src/lib.rs} (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 071d2948a0..e395671b02 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,25 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "account-balances"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-trait",
+ "balance-overrides",
+ "contracts",
+ "ethrpc",
+ "futures",
+ "itertools 0.14.0",
+ "mockall",
+ "model",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "addr2line"
 version = "0.25.1"
@@ -17,6 +36,18 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -776,7 +807,7 @@ version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fa0c53e8c1e1ef4d01066b01c737fb62fc9397ab52c6e7bb5669f97d281b9bc"
 dependencies = [
- "darling",
+ "darling 0.21.3",
  "proc-macro2",
  "quote",
  "syn 2.0.114",
@@ -1173,6 +1204,7 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 name = "autopilot"
 version = "0.1.0"
 dependencies = [
+ "account-balances",
  "alloy",
  "anyhow",
  "app-data",
@@ -1192,6 +1224,7 @@ dependencies = [
  "database",
  "derive_more 1.0.0",
  "ethrpc",
+ "event-indexing",
  "futures",
  "hex-literal",
  "humantime",
@@ -1221,6 +1254,7 @@ dependencies = [
  "tempfile",
  "thiserror 1.0.69",
  "tikv-jemallocator",
+ "token-info",
  "tokio",
  "tokio-stream",
  "toml",
@@ -1791,6 +1825,23 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "balance-overrides"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-trait",
+ "cached",
+ "clap",
+ "contracts",
+ "ethrpc",
+ "maplit",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "base-x"
 version = "0.2.11"
@@ -2068,12 +2119,33 @@ version = "0.49.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e8e463fceca5674287f32d252fb1d94083758b8709c160efae66d263e5f4eba"
 dependencies = [
+ "ahash",
+ "cached_proc_macro",
+ "cached_proc_macro_types",
  "hashbrown 0.14.5",
  "instant",
  "once_cell",
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "cached_proc_macro"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad9f16c0d84de31a2ab7fdf5f7783c14631f7075cf464eb3bb43119f61c9cb2a"
+dependencies = [
+ "darling 0.14.4",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "cached_proc_macro_types"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ade8366b8bd5ba243f0a58f036cc0ca8a2f069cff1a2351ef1cac6b083e16fc0"
+
 [[package]]
 name = "cc"
 version = "1.2.52"
@@ -2144,7 +2216,7 @@ dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim",
+ "strsim 0.11.1",
 ]
 
 [[package]]
@@ -2455,6 +2527,7 @@ dependencies = [
  "contracts",
  "database",
  "ethrpc",
+ "event-indexing",
  "futures",
  "model",
  "observe",
@@ -2573,14 +2646,38 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "darling"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
+dependencies = [
+ "darling_core 0.14.4",
+ "darling_macro 0.14.4",
+]
+
 [[package]]
 name = "darling"
 version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
 dependencies = [
- "darling_core",
- "darling_macro",
+ "darling_core 0.21.3",
+ "darling_macro 0.21.3",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim 0.10.0",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -2594,17 +2691,28 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "strsim",
+ "strsim 0.11.1",
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "darling_macro"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
+dependencies = [
+ "darling_core 0.14.4",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "darling_macro"
 version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
- "darling_core",
+ "darling_core 0.21.3",
  "quote",
  "syn 2.0.114",
 ]
@@ -2800,11 +2908,13 @@ checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"
 name = "driver"
 version = "0.1.0"
 dependencies = [
+ "account-balances",
  "alloy",
  "anyhow",
  "app-data",
  "async-trait",
  "axum 0.8.8",
+ "balance-overrides",
  "bigdecimal",
  "bytes-hex",
  "chain",
@@ -2816,11 +2926,13 @@ dependencies = [
  "dashmap",
  "derive_more 1.0.0",
  "ethrpc",
+ "event-indexing",
  "futures",
  "hex-literal",
  "humantime",
  "humantime-serde",
  "itertools 0.14.0",
+ "liquidity-sources",
  "maplit",
  "mimalloc",
  "model",
@@ -2831,6 +2943,7 @@ dependencies = [
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
+ "request-sharing",
  "reqwest 0.13.2",
  "s3",
  "serde",
@@ -2843,6 +2956,7 @@ dependencies = [
  "tempfile",
  "thiserror 1.0.69",
  "tikv-jemallocator",
+ "token-info",
  "tokio",
  "toml",
  "tower 0.5.3",
@@ -2874,6 +2988,7 @@ dependencies = [
  "app-data",
  "autopilot",
  "axum 0.8.8",
+ "balance-overrides",
  "bigdecimal",
  "chrono",
  "clap",
@@ -2886,6 +3001,7 @@ dependencies = [
  "futures",
  "hex-literal",
  "itertools 0.14.0",
+ "liquidity-sources",
  "model",
  "number",
  "observe",
@@ -3045,6 +3161,26 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "event-indexing"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-stream",
+ "async-trait",
+ "contracts",
+ "ethrpc",
+ "futures",
+ "mockall",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "tokio",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "event-listener"
 version = "5.4.1"
@@ -3425,6 +3561,10 @@ name = "hashbrown"
 version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
 
 [[package]]
 name = "hashbrown"
@@ -4175,6 +4315,44 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
+[[package]]
+name = "liquidity-sources"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-trait",
+ "cached",
+ "chain",
+ "clap",
+ "contracts",
+ "ethrpc",
+ "event-indexing",
+ "futures",
+ "hex-literal",
+ "itertools 0.14.0",
+ "maplit",
+ "mockall",
+ "model",
+ "num",
+ "number",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "regex",
+ "request-sharing",
+ "reqwest 0.13.2",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "strum",
+ "testlib",
+ "thiserror 1.0.69",
+ "token-info",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "litemap"
 version = "0.8.1"
@@ -4820,6 +4998,7 @@ dependencies = [
 name = "orderbook"
 version = "0.1.0"
 dependencies = [
+ "account-balances",
  "alloy",
  "anyhow",
  "app-data",
@@ -4858,6 +5037,7 @@ dependencies = [
  "tempfile",
  "thiserror 1.0.69",
  "tikv-jemallocator",
+ "token-info",
  "tokio",
  "toml",
  "tower 0.5.3",
@@ -5629,6 +5809,17 @@ version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 
+[[package]]
+name = "request-sharing"
+version = "0.1.0"
+dependencies = [
+ "futures",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "tokio",
+]
+
 [[package]]
 name = "reqwest"
 version = "0.12.28"
@@ -6307,7 +6498,7 @@ version = "3.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c"
 dependencies = [
- "darling",
+ "darling 0.21.3",
  "proc-macro2",
  "quote",
  "syn 2.0.114",
@@ -6378,12 +6569,14 @@ dependencies = [
 name = "shared"
 version = "0.1.0"
 dependencies = [
+ "account-balances",
  "alloy",
  "anyhow",
  "app-data",
  "arc-swap",
  "async-stream",
  "async-trait",
+ "balance-overrides",
  "bigdecimal",
  "bytes-hex",
  "cached",
@@ -6396,11 +6589,13 @@ dependencies = [
  "database",
  "derive_more 1.0.0",
  "ethrpc",
+ "event-indexing",
  "futures",
  "hex-literal",
  "humantime",
  "indexmap 2.13.0",
  "itertools 0.14.0",
+ "liquidity-sources",
  "maplit",
  "mockall",
  "model",
@@ -6414,6 +6609,7 @@ dependencies = [
  "rand 0.8.5",
  "rate-limit",
  "regex",
+ "request-sharing",
  "reqwest 0.13.2",
  "rust_decimal",
  "serde",
@@ -6422,6 +6618,7 @@ dependencies = [
  "strum",
  "testlib",
  "thiserror 1.0.69",
+ "token-info",
  "tokio",
  "toml",
  "tracing",
@@ -6510,6 +6707,7 @@ dependencies = [
  "futures",
  "hex-literal",
  "itertools 0.14.0",
+ "liquidity-sources",
  "maplit",
  "mockall",
  "model",
@@ -6543,6 +6741,8 @@ dependencies = [
  "ethrpc",
  "futures",
  "itertools 0.14.0",
+ "liquidity-sources",
+ "maplit",
  "mimalloc",
  "model",
  "num",
@@ -6823,6 +7023,12 @@ dependencies = [
  "unicode-properties",
 ]
 
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -7134,6 +7340,24 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
+[[package]]
+name = "token-info"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-trait",
+ "contracts",
+ "ethrpc",
+ "futures",
+ "maplit",
+ "mockall",
+ "model",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "tokio"
 version = "1.49.0"
diff --git a/Cargo.toml b/Cargo.toml
index 87304a8dd4..618d9cefe7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ alloy-primitives = { version = "1.5.2", default-features = false }
 alloy-signer = { version = "1.7.3", default-features = false}
 alloy-signer-local = { version = "1.7.3", default-features = false}
 alloy-sol-types = { version = "1.5.2" }
+account-balances = { path = "crates/account-balances" }
 anyhow = "1.0.100"
 async-trait = "0.1.80"
 axum = "0.8"
@@ -18,6 +19,7 @@ chrono = { version = "0.4.38", default-features = false }
 clap = { version = "4.5.6", features = ["derive", "env"] }
 dashmap = "6.1.0"
 derive_more = { version = "1.0.0", features = ["full"] }
+event-indexing = { path = "crates/event-indexing" }
 mimalloc = "0.1.43"
 tikv-jemallocator = { version = "0.6", features = ["unprefixed_malloc_on_supported_platforms", "profiling"] }
 jemalloc_pprof = { version = "0.8", features = ["symbolize"] }
@@ -39,6 +41,7 @@ prometheus = "0.14"
 prometheus-metric-storage = "0.6"
 rand = "0.8.5"
 regex = "1.10.4"
+request-sharing = { path = "crates/request-sharing" }
 reqwest = "0.13"
 rstest = "0.26"
 ruint = { version = "1.17.2", default-features = false }
@@ -50,12 +53,14 @@ strum = { version = "0.27.2", features = ["derive"] }
 tempfile = "3.10.1"
 thiserror = "1.0.61"
 toml = "0.8.14"
+token-info = { path = "crates/token-info" }
 tokio = { version = "1.38.0", features = ["tracing"] }
 tokio-stream = { version = "0.1.15", features = ["sync"] }
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", features = ["json"] }
 url = "2.5.0"
 app-data = { path = "crates/app-data" }
+balance-overrides = { path = "crates/balance-overrides" }
 arc-swap = "1.7.1"
 async-stream = "0.3.5"
 autopilot = { path = "crates/autopilot" }
@@ -109,6 +114,7 @@ alloy-sol-macro-input = "1.4.1"
 alloy-sol-macro-expander = "1.4.1"
 jsonrpc-core = "18.0.0"
 serde-ext = { path = "crates/serde-ext" }
+liquidity-sources = { path = "crates/liquidity-sources" }
 
 [workspace.lints]
 clippy.cast_possible_wrap = "deny"
diff --git a/crates/account-balances/Cargo.toml b/crates/account-balances/Cargo.toml
new file mode 100644
index 0000000000..6a1de685d6
--- /dev/null
+++ b/crates/account-balances/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "account-balances"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+balance-overrides = { workspace = true }
+contracts = { workspace = true }
+ethrpc = { workspace = true }
+futures = { workspace = true }
+itertools = { workspace = true }
+mockall = { workspace = true, optional = true }
+model = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+
+[dev-dependencies]
+mockall = { workspace = true }
+
+[features]
+test-util = ["dep:mockall"]
+
+[lints]
+workspace = true
diff --git a/crates/account-balances/LICENSE-APACHE b/crates/account-balances/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/account-balances/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/account-balances/LICENSE-MIT b/crates/account-balances/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/account-balances/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/account_balances/cached.rs b/crates/account-balances/src/cached.rs
similarity index 98%
rename from crates/shared/src/account_balances/cached.rs
rename to crates/account-balances/src/cached.rs
index e04adcdc33..366f0db3f6 100644
--- a/crates/shared/src/account_balances/cached.rs
+++ b/crates/account-balances/src/cached.rs
@@ -1,5 +1,5 @@
 use {
-    crate::account_balances::{BalanceFetching, Query, TransferSimulationError},
+    crate::{BalanceFetching, Query, TransferSimulationError},
     alloy::primitives::U256,
     anyhow::Result,
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
@@ -201,7 +201,7 @@ impl BalanceFetching for Balances {
 mod tests {
     use {
         super::*,
-        crate::account_balances::MockBalanceFetching,
+        crate::MockBalanceFetching,
         alloy::primitives::Address,
         ethrpc::block_stream::BlockInfo,
         model::order::SellTokenSource,
diff --git a/crates/shared/src/account_balances/mod.rs b/crates/account-balances/src/lib.rs
similarity index 94%
rename from crates/shared/src/account_balances/mod.rs
rename to crates/account-balances/src/lib.rs
index 03b853d41e..c1ff5091fc 100644
--- a/crates/shared/src/account_balances/mod.rs
+++ b/crates/account-balances/src/lib.rs
@@ -1,20 +1,17 @@
 use {
-    crate::price_estimation::trade_verifier::balance_overrides::{
-        BalanceOverrideRequest,
-        BalanceOverriding,
-    },
     alloy::{
         primitives::{Address, U256},
         rpc::types::state::StateOverride,
         sol_types::{SolCall, SolType, sol_data},
     },
+    balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     contracts::alloy::{GPv2Settlement, support::Balances},
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     model::{
         interaction::InteractionData,
         order::{Order, SellTokenSource},
     },
-    std::sync::Arc,
+    std::sync::{Arc, LazyLock},
     thiserror::Error,
 };
 
@@ -178,7 +175,7 @@ impl BalanceSimulator {
             .simulateDelegatecall(*self.balances.address(), balance_call.abi_encode().into())
             .with_cloned_provider()
             .state(overrides)
-            .from(*crate::SIMULATION_ACCOUNT)
+            .from(*SIMULATION_ACCOUNT)
             .call()
             .await?;
 
@@ -227,3 +224,7 @@ pub enum SimulationError {
     #[error("method error: {0:?}")]
     Method(#[from] alloy::contract::Error),
 }
+
+// ZKSync-based chains don't use the default 0x0 account when `tx.from` is not
+// specified, so we need to use a random account when sending a simulation tx.
+static SIMULATION_ACCOUNT: LazyLock<Address> = LazyLock::new(|| Address::random());
diff --git a/crates/shared/src/account_balances/simulation.rs b/crates/account-balances/src/simulation.rs
similarity index 98%
rename from crates/shared/src/account_balances/simulation.rs
rename to crates/account-balances/src/simulation.rs
index 6842373d01..ebaa6c92cb 100644
--- a/crates/shared/src/account_balances/simulation.rs
+++ b/crates/account-balances/src/simulation.rs
@@ -4,7 +4,7 @@
 
 use {
     super::{BalanceFetching, Query, TransferSimulationError},
-    crate::account_balances::BalanceSimulator,
+    crate::BalanceSimulator,
     alloy::primitives::{Address, U256},
     anyhow::Result,
     contracts::alloy::{BalancerV2Vault::BalancerV2Vault, ERC20},
@@ -167,8 +167,8 @@ impl BalanceFetching for Balances {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::trade_verifier::balance_overrides::DummyOverrider,
         alloy::primitives::address,
+        balance_overrides::DummyOverrider,
         contracts::alloy::GPv2Settlement,
         ethrpc::Web3,
         model::order::SellTokenSource,
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 77ad511d0d..ff615396be 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -15,6 +15,7 @@ name = "autopilot"
 path = "src/main.rs"
 
 [dependencies]
+account-balances = { workspace = true }
 alloy = { workspace = true, features = ["rand", "provider-debug-api", "provider-trace-api"] }
 app-data = { workspace = true }
 axum = { workspace = true }
@@ -32,6 +33,7 @@ dashmap = { workspace = true }
 database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
+event-indexing = { workspace = true }
 brotli = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
@@ -60,6 +62,7 @@ sqlx = { workspace = true }
 strum = { workspace = true }
 tikv-jemallocator = { workspace = true }
 thiserror = { workspace = true }
+token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
 tokio-stream = { workspace = true }
 tower = { workspace = true }
diff --git a/crates/autopilot/src/boundary/events/settlement.rs b/crates/autopilot/src/boundary/events/settlement.rs
index d097c06ba7..15f2cd5df6 100644
--- a/crates/autopilot/src/boundary/events/settlement.rs
+++ b/crates/autopilot/src/boundary/events/settlement.rs
@@ -6,8 +6,11 @@ use {
     },
     anyhow::Result,
     contracts::alloy::GPv2Settlement::GPv2Settlement::GPv2SettlementEvents,
-    ethrpc::{AlloyProvider, block_stream::RangeInclusive},
-    shared::event_handling::{AlloyEventRetrieving, EventStoring},
+    ethrpc::AlloyProvider,
+    event_indexing::{
+        block_retriever::RangeInclusive,
+        event_handler::{AlloyEventRetrieving, EventStoring},
+    },
 };
 
 pub struct GPv2SettlementContract {
diff --git a/crates/autopilot/src/database/ethflow_events/event_retriever.rs b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
index dfc159471a..01e5178eb2 100644
--- a/crates/autopilot/src/database/ethflow_events/event_retriever.rs
+++ b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
@@ -8,7 +8,8 @@ use {
         sol_types::SolEvent,
     },
     contracts::alloy::CoWSwapEthFlow::CoWSwapEthFlow,
-    shared::{event_handling::AlloyEventRetrieving, web3::Web3},
+    ethrpc::Web3,
+    event_indexing::event_handler::AlloyEventRetrieving,
 };
 
 pub struct EthFlowRefundRetriever {
diff --git a/crates/autopilot/src/database/ethflow_events/event_storing.rs b/crates/autopilot/src/database/ethflow_events/event_storing.rs
index d9046a9e3d..adb2baa805 100644
--- a/crates/autopilot/src/database/ethflow_events/event_storing.rs
+++ b/crates/autopilot/src/database/ethflow_events/event_storing.rs
@@ -6,8 +6,7 @@ use {
     anyhow::Result,
     contracts::alloy::CoWSwapEthFlow::CoWSwapEthFlow::CoWSwapEthFlowEvents,
     database::ethflow_orders::Refund,
-    ethrpc::block_stream::RangeInclusive,
-    shared::event_handling::EventStoring,
+    event_indexing::{block_retriever::RangeInclusive, event_handler::EventStoring},
 };
 
 fn get_refunds(events: Vec<(CoWSwapEthFlowEvents, Log)>) -> Result<Vec<Refund>> {
diff --git a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
index d321885e4a..b5e93f14fd 100644
--- a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
+++ b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
@@ -5,7 +5,8 @@ use {
         sol_types::SolEvent,
     },
     contracts::alloy::CoWSwapOnchainOrders,
-    shared::{event_handling::AlloyEventRetrieving, web3::Web3},
+    ethrpc::Web3,
+    event_indexing::event_handler::AlloyEventRetrieving,
 };
 
 // Note: we use a custom implementation of `EventRetrieving` rather than using
diff --git a/crates/autopilot/src/database/onchain_order_events/mod.rs b/crates/autopilot/src/database/onchain_order_events/mod.rs
index dfa02e5700..24a19fd77f 100644
--- a/crates/autopilot/src/database/onchain_order_events/mod.rs
+++ b/crates/autopilot/src/database/onchain_order_events/mod.rs
@@ -27,10 +27,8 @@ use {
         onchain_broadcasted_orders::{OnchainOrderPlacement, OnchainOrderPlacementError},
         orders::{Order, OrderClass, insert_quotes},
     },
-    ethrpc::{
-        Web3,
-        block_stream::{RangeInclusive, timestamp_of_block_in_seconds},
-    },
+    ethrpc::{Web3, block_stream::timestamp_of_block_in_seconds},
+    event_indexing::{block_retriever::RangeInclusive, event_handler::EventStoring},
     futures::{StreamExt, stream},
     itertools::{izip, multiunzip},
     model::{
@@ -53,7 +51,6 @@ use {
             sell_token_source_into,
             signing_scheme_into,
         },
-        event_handling::EventStoring,
         order_quoting::{OrderQuoting, Quote, QuoteSearchParameters},
         order_validation::{
             ValidationError,
diff --git a/crates/autopilot/src/database/quotes.rs b/crates/autopilot/src/database/quotes.rs
index 4205f51780..23360505a2 100644
--- a/crates/autopilot/src/database/quotes.rs
+++ b/crates/autopilot/src/database/quotes.rs
@@ -4,22 +4,21 @@ use {
         domain::{self},
         infra::persistence::dto,
     },
-    anyhow::{Context, Result},
+    anyhow::Result,
     database::byte_array::ByteArray,
-    shared::maintenance::Maintaining,
-    sqlx::types::chrono::{DateTime, Utc},
+    sqlx::types::chrono::Utc,
     std::collections::HashMap,
 };
 
 impl Postgres {
-    pub async fn remove_expired_quotes(&self, max_expiry: DateTime<Utc>) -> Result<()> {
+    pub async fn remove_expired_quotes(&self) -> Result<()> {
         let _timer = super::Metrics::get()
             .database_queries
             .with_label_values(&["remove_expired_quotes"])
             .start_timer();
 
         let mut ex = self.pool.acquire().await?;
-        database::quotes::remove_expired_quotes(&mut ex, max_expiry).await?;
+        database::quotes::remove_expired_quotes(&mut ex, Utc::now()).await?;
         Ok(())
     }
 
@@ -61,16 +60,3 @@ impl Postgres {
         Ok(quotes)
     }
 }
-
-#[async_trait::async_trait]
-impl Maintaining for Postgres {
-    async fn run_maintenance(&self) -> Result<()> {
-        self.remove_expired_quotes(Utc::now())
-            .await
-            .context("fee measurement maintenance error")
-    }
-
-    fn name(&self) -> &str {
-        "Postgres"
-    }
-}
diff --git a/crates/autopilot/src/event_updater.rs b/crates/autopilot/src/event_updater.rs
index 1a2117be45..6a926a6a79 100644
--- a/crates/autopilot/src/event_updater.rs
+++ b/crates/autopilot/src/event_updater.rs
@@ -1,8 +1,9 @@
 use {
     anyhow::Result,
-    ethrpc::block_stream::{BlockNumberHash, BlockRetrieving},
-    shared::{
-        event_handling::{EventHandler, EventRetrieving, EventStoring},
+    ethrpc::block_stream::BlockNumberHash,
+    event_indexing::{
+        block_retriever::BlockRetrieving,
+        event_handler::{EventHandler, EventRetrieving, EventStoring},
         maintenance::Maintaining,
     },
     std::sync::Arc,
diff --git a/crates/autopilot/src/maintenance.rs b/crates/autopilot/src/maintenance.rs
index 326f196495..4ba4148b04 100644
--- a/crates/autopilot/src/maintenance.rs
+++ b/crates/autopilot/src/maintenance.rs
@@ -15,13 +15,13 @@ use {
     },
     anyhow::Result,
     ethrpc::block_stream::{BlockInfo, CurrentBlockWatcher, into_stream},
+    event_indexing::maintenance::Maintaining,
     futures::{FutureExt, StreamExt},
     prometheus::{
         HistogramVec,
         IntCounterVec,
         core::{AtomicU64, GenericGauge},
     },
-    shared::maintenance::Maintaining,
     std::{
         future::Future,
         sync::Arc,
@@ -235,7 +235,7 @@ impl Maintenance {
         let _timer = observe::metrics::metrics()
             .on_auction_overhead_start("autopilot", "maintenance_optional");
         tokio::try_join!(
-            Self::timed_future("db_cleanup", self.db_cleanup.run_maintenance()),
+            Self::timed_future("db_cleanup", self.db_cleanup.remove_expired_quotes()),
             Self::timed_future(
                 "ethflow_refund_indexer",
                 futures::future::try_join_all(
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 4c41095b25..a201146db6 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -25,35 +25,33 @@ use {
         shutdown_controller::ShutdownController,
         solvable_orders::SolvableOrdersCache,
     },
+    account_balances::{self, BalanceSimulator},
     alloy::{eips::BlockNumberOrTag, primitives::Address, providers::Provider},
     chain::Chain,
     clap::Parser,
     contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
-    ethrpc::{
-        Web3,
-        block_stream::{BlockRetriever, block_number_to_block_number_hash},
-    },
+    ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
+    event_indexing::block_retriever::BlockRetriever,
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::LivenessChecking,
     shared::{
-        account_balances::{self, BalanceSimulator},
         arguments::tracing_config,
         bad_token::list_based::DenyListedTokens,
-        code_fetching::CachedCodeFetcher,
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
         price_estimation::{
             factory::{self, PriceEstimatorFactory},
             native::NativePriceEstimating,
+            trade_verifier::code_fetching::CachedCodeFetcher,
         },
-        token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
         token_list::{AutoUpdatingTokenList, TokenListConfiguration},
     },
     std::{
         sync::{Arc, RwLock, atomic::AtomicBool},
         time::{Duration, Instant},
     },
+    token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     tracing::{Instrument, info_span, instrument},
     url::Url,
 };
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index dc3c7b29fd..6782b6304e 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -4,6 +4,7 @@ use {
         domain::{self, auction::Price, eth},
         infra::{self, banned},
     },
+    account_balances::{BalanceFetching, Query},
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result},
     database::order_events::OrderEventLabel,
@@ -16,7 +17,6 @@ use {
     },
     prometheus::{Histogram, HistogramVec, IntCounter, IntCounterVec, IntGauge, IntGaugeVec},
     shared::{
-        account_balances::{BalanceFetching, Query},
         bad_token::list_based::DenyListedTokens,
         price_estimation::{
             native::{NativePriceEstimating, to_normalized_price},
diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
new file mode 100644
index 0000000000..3401050223
--- /dev/null
+++ b/crates/balance-overrides/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "balance-overrides"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy = { workspace = true, features = ["sol-types", "provider-debug-api"] }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+cached = { workspace = true, features = ["default"] }
+clap = { workspace = true }
+contracts = { workspace = true }
+ethrpc = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+[dev-dependencies]
+ethrpc = { workspace = true, features = ["test-util"] }
+maplit = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+
+[lints]
+workspace = true
diff --git a/crates/balance-overrides/LICENSE-APACHE b/crates/balance-overrides/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/balance-overrides/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/balance-overrides/LICENSE-MIT b/crates/balance-overrides/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/balance-overrides/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs b/crates/balance-overrides/src/detector.rs
similarity index 98%
rename from crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs
rename to crates/balance-overrides/src/detector.rs
index 909c0ff107..46b667daa9 100644
--- a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/detector.rs
+++ b/crates/balance-overrides/src/detector.rs
@@ -1,6 +1,5 @@
 use {
     super::Strategy,
-    crate::tenderly_api::SimulationError,
     alloy::{
         eips::BlockId,
         primitives::{Address, B256, TxKind, U256},
@@ -28,6 +27,15 @@ const SOLADY_MAGIC_BYTES: &[u8] = &[
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0xa2, 0x11, 0xa2,
 ];
 
+/// Error that occurs when verifying a balance override strategy.
+#[derive(Debug, Error)]
+pub enum SimulationError {
+    #[error("simulation reverted {0:?}")]
+    Revert(Option<String>),
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+}
+
 /// A heuristic balance override detector based on `eth_call` simulations.
 ///
 /// This has the exact same node requirements as trade verification.
diff --git a/crates/shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs b/crates/balance-overrides/src/lib.rs
similarity index 100%
rename from crates/shared/src/price_estimation/trade_verifier/balance_overrides/mod.rs
rename to crates/balance-overrides/src/lib.rs
diff --git a/crates/cow-amm/Cargo.toml b/crates/cow-amm/Cargo.toml
index ca176ff86b..c6af01ce65 100644
--- a/crates/cow-amm/Cargo.toml
+++ b/crates/cow-amm/Cargo.toml
@@ -10,6 +10,7 @@ app-data = { workspace = true }
 async-trait = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
+event-indexing = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 model = { workspace = true }
diff --git a/crates/cow-amm/src/cache.rs b/crates/cow-amm/src/cache.rs
index 02c1ebe709..81854368d9 100644
--- a/crates/cow-amm/src/cache.rs
+++ b/crates/cow-amm/src/cache.rs
@@ -7,8 +7,7 @@ use {
         CowAmmLegacyHelper::CowAmmLegacyHelper::CowAmmLegacyHelperEvents as CowAmmEvent,
     },
     database::byte_array::ByteArray,
-    ethrpc::block_stream::RangeInclusive,
-    shared::event_handling::EventStoring,
+    event_indexing::{block_retriever::RangeInclusive, event_handler::EventStoring},
     sqlx::PgPool,
     std::{collections::HashMap, sync::Arc},
     tokio::sync::RwLock,
diff --git a/crates/cow-amm/src/factory.rs b/crates/cow-amm/src/factory.rs
index 713351b30f..69873fe730 100644
--- a/crates/cow-amm/src/factory.rs
+++ b/crates/cow-amm/src/factory.rs
@@ -10,7 +10,7 @@ use {
         CowAmmLegacyHelperEvents as CowAmmEvent,
     },
     ethrpc::AlloyProvider,
-    shared::event_handling::AlloyEventRetrieving,
+    event_indexing::event_handler::AlloyEventRetrieving,
 };
 
 pub(crate) struct Factory {
diff --git a/crates/cow-amm/src/maintainers.rs b/crates/cow-amm/src/maintainers.rs
index 4751eaae7a..7a8852d903 100644
--- a/crates/cow-amm/src/maintainers.rs
+++ b/crates/cow-amm/src/maintainers.rs
@@ -2,11 +2,11 @@ use {
     crate::{Amm, cache::Storage},
     contracts::alloy::ERC20,
     ethrpc::AlloyProvider,
+    event_indexing::maintenance::Maintaining,
     futures::{
         future::{join_all, select_ok},
         stream::{FuturesUnordered, StreamExt},
     },
-    shared::maintenance::Maintaining,
     std::sync::Arc,
     tokio::sync::RwLock,
 };
diff --git a/crates/cow-amm/src/registry.rs b/crates/cow-amm/src/registry.rs
index 66b3146515..e80795eee0 100644
--- a/crates/cow-amm/src/registry.rs
+++ b/crates/cow-amm/src/registry.rs
@@ -2,12 +2,10 @@ use {
     crate::{Amm, cache::Storage, factory::Factory, maintainers::EmptyPoolRemoval},
     alloy::primitives::Address,
     contracts::alloy::cow_amm::CowAmmLegacyHelper,
-    ethrpc::{
-        AlloyProvider,
-        block_stream::{BlockRetriever, CurrentBlockWatcher},
-    },
-    shared::{
-        event_handling::EventHandler,
+    ethrpc::{AlloyProvider, block_stream::CurrentBlockWatcher},
+    event_indexing::{
+        block_retriever::BlockRetriever,
+        event_handler::EventHandler,
         maintenance::{Maintaining, ServiceMaintenance},
     },
     sqlx::PgPool,
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index a1c0f6d304..2e81d3fef0 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -15,10 +15,12 @@ name = "driver"
 path = "src/main.rs"
 
 [dependencies]
+account-balances = { workspace = true }
 alloy = { workspace = true, features = ["sol-types", "provider-txpool-api", "rand", "provider-anvil-api", "json-rpc", "rpc-types"] }
 app-data = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
+balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
 bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
 chain = { workspace = true }
@@ -27,12 +29,14 @@ cow-amm = { workspace = true }
 dashmap = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
+event-indexing = { workspace = true }
 futures = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 itertools = { workspace = true }
+liquidity-sources = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 tikv-jemallocator = { workspace = true }
 moka = { workspace = true, features = ["future"] }
@@ -41,6 +45,7 @@ number = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
+request-sharing = { workspace = true }
 reqwest = { workspace = true, features = ["query"] }
 s3 = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -49,6 +54,7 @@ serde_json = { workspace = true }
 serde_with = { workspace = true }
 solvers-dto = { path = "../solvers-dto" }
 thiserror = { workspace = true }
+token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "time"] }
 toml = { workspace = true }
 tower = { workspace = true }
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
index 3ef3baeac6..c99023c533 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
@@ -16,20 +16,19 @@ use {
         BalancerV2WeightedPoolFactory,
         BalancerV2WeightedPoolFactoryV3,
     },
-    ethrpc::block_stream::{BlockRetrieving, CurrentBlockWatcher},
-    shared::{
-        http_solver::model::TokenAmount,
-        sources::balancer_v2::{
-            BalancerPoolFetcher,
-            pool_fetching::{BalancerContracts, BalancerFactoryInstance},
-        },
-        token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
+    ethrpc::block_stream::CurrentBlockWatcher,
+    event_indexing::block_retriever::BlockRetrieving,
+    liquidity_sources::balancer_v2::{
+        BalancerPoolFetcher,
+        pool_fetching::{BalancerContracts, BalancerFactoryInstance},
     },
+    shared::http_solver::model::TokenAmount,
     solver::{
         liquidity::balancer_v2::{self, BalancerV2Liquidity},
         liquidity_collector::{BackgroundInitLiquiditySource, LiquidityCollecting},
     },
     std::sync::Arc,
+    token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
 };
 
 pub mod stable;
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs b/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs
index f64fc7f2fa..48954e80c2 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs
@@ -6,7 +6,7 @@ use {
             liquidity::{self, balancer},
         },
     },
-    shared::sources::balancer_v2::pool_fetching::WeightedPoolVersion,
+    liquidity_sources::balancer_v2::pool_fetching::WeightedPoolVersion,
     solver::liquidity::{WeightedProductOrder, balancer_v2},
 };
 
diff --git a/crates/driver/src/boundary/liquidity/mod.rs b/crates/driver/src/boundary/liquidity/mod.rs
index 0c91256ae9..face9b1efc 100644
--- a/crates/driver/src/boundary/liquidity/mod.rs
+++ b/crates/driver/src/boundary/liquidity/mod.rs
@@ -6,12 +6,12 @@ use {
     anyhow::Result,
     ethrpc::block_stream::CurrentBlockWatcher,
     futures::future,
-    model::TokenPair,
-    shared::{
-        baseline_solver::BaseTokens,
-        http_client::HttpClientFactory,
+    liquidity_sources::{
+        base_tokens::BaseTokens,
         recent_block_cache::{self, CacheConfig},
     },
+    model::TokenPair,
+    shared::http_client::HttpClientFactory,
     solver::{
         liquidity::Liquidity,
         liquidity_collector::{LiquidityCollecting, LiquidityCollector},
diff --git a/crates/driver/src/boundary/liquidity/swapr.rs b/crates/driver/src/boundary/liquidity/swapr.rs
index 843404d032..779ec79748 100644
--- a/crates/driver/src/boundary/liquidity/swapr.rs
+++ b/crates/driver/src/boundary/liquidity/swapr.rs
@@ -5,7 +5,7 @@ use {
         infra::{self, blockchain::Ethereum},
     },
     ethrpc::block_stream::CurrentBlockWatcher,
-    shared::sources::{swapr::SwaprPoolReader, uniswap_v2::pool_fetching::DefaultPoolReader},
+    liquidity_sources::{swapr::SwaprPoolReader, uniswap_v2::pool_fetching::DefaultPoolReader},
     solver::{liquidity::ConstantProductOrder, liquidity_collector::LiquidityCollecting},
 };
 
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v2.rs b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
index 19e3040835..ed9e003029 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v2.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
@@ -9,14 +9,12 @@ use {
     },
     contracts::alloy::IUniswapLikeRouter,
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
-    shared::{
-        http_solver::model::TokenAmount,
-        sources::uniswap_v2::{
-            pair_provider::PairProvider,
-            pool_cache::PoolCache,
-            pool_fetching::{DefaultPoolReader, PoolFetcher, PoolReading},
-        },
+    liquidity_sources::uniswap_v2::{
+        pair_provider::PairProvider,
+        pool_cache::PoolCache,
+        pool_fetching::{DefaultPoolReader, PoolFetcher, PoolReading},
     },
+    shared::http_solver::model::TokenAmount,
     solver::{
         liquidity::{
             ConstantProductOrder,
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v3.rs b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
index 7e5e58f531..e07afd2235 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v3.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
@@ -11,13 +11,9 @@ use {
         infra::{self, blockchain::Ethereum},
     },
     anyhow::Context,
-    ethrpc::block_stream::BlockRetrieving,
-    shared::{
-        http_solver::model::TokenAmount,
-        interaction::Interaction,
-        maintenance::ServiceMaintenance,
-        sources::uniswap_v3::pool_fetching::UniswapV3PoolFetcher,
-    },
+    event_indexing::{block_retriever::BlockRetrieving, maintenance::ServiceMaintenance},
+    liquidity_sources::uniswap_v3::pool_fetching::UniswapV3PoolFetcher,
+    shared::{http_solver::model::TokenAmount, interaction::Interaction},
     solver::{
         liquidity::{
             ConcentratedLiquidity,
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index 1b82c13246..bf164c1ee6 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -9,12 +9,14 @@ use {
         },
         infra::{self, api::routes::solve::dto::SolveRequest, observe::metrics, tokens},
     },
+    account_balances::{BalanceFetching, Query},
     alloy::primitives::{Bytes, FixedBytes},
     anyhow::{Context, Result},
     axum::{
         body::{self, Body},
         http::Request,
     },
+    balance_overrides::BalanceOverrideRequest,
     chrono::Utc,
     futures::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered},
     itertools::Itertools,
@@ -23,11 +25,7 @@ use {
         order::{OrderKind, SellTokenSource},
         signature::Signature,
     },
-    shared::{
-        account_balances::{BalanceFetching, Query},
-        price_estimation::trade_verifier::balance_overrides::BalanceOverrideRequest,
-        signature_validator::SignatureValidating,
-    },
+    shared::signature_validator::SignatureValidating,
     std::{
         collections::HashMap,
         future::Future,
diff --git a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
index f041b7c417..3f7a03f94d 100644
--- a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
+++ b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
@@ -6,10 +6,8 @@ use {
     },
     futures::FutureExt,
     model::interaction::InteractionData,
-    shared::{
-        bad_token::{TokenQuality, trace_call::TraceCallDetectorRaw},
-        request_sharing::BoxRequestSharing,
-    },
+    request_sharing::BoxRequestSharing,
+    shared::bad_token::{TokenQuality, trace_call::TraceCallDetectorRaw},
     std::{
         sync::Arc,
         time::{Duration, Instant},
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index d64dca38ca..eda13eb057 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -23,7 +23,6 @@ use {
     error::Error,
     futures::Future,
     observe::tracing::distributed::axum::{make_span, record_trace_id},
-    shared::account_balances,
     std::{net::SocketAddr, sync::Arc},
     tokio::sync::oneshot,
 };
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 1244567c6e..9cb9e87cfd 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -3,6 +3,7 @@ use {
         boundary,
         domain::{eth, eth::U256},
     },
+    account_balances::{BalanceSimulator, SimulationError},
     alloy::{
         eips::eip1559::Eip1559Estimation,
         network::TransactionBuilder,
@@ -11,17 +12,10 @@ use {
         transports::TransportErrorKind,
     },
     anyhow::anyhow,
+    balance_overrides::{BalanceOverrides, BalanceOverriding},
     chain::Chain,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
-    shared::{
-        account_balances::{BalanceSimulator, SimulationError},
-        gas_price_estimation::Eip1559EstimationExt,
-        price_estimation::trade_verifier::balance_overrides::{
-            BalanceOverrides,
-            BalanceOverriding,
-        },
-        web3,
-    },
+    shared::{gas_price_estimation::Eip1559EstimationExt, web3},
     std::{fmt, sync::Arc},
     thiserror::Error,
     tracing::{Level, instrument},
diff --git a/crates/driver/src/infra/liquidity/config.rs b/crates/driver/src/infra/liquidity/config.rs
index afc2b8f92e..7cab7f8fcf 100644
--- a/crates/driver/src/infra/liquidity/config.rs
+++ b/crates/driver/src/infra/liquidity/config.rs
@@ -5,8 +5,7 @@ use {
     contracts::alloy::BalancerV2Vault,
     derive_more::Debug,
     hex_literal::hex,
-    reqwest::Url,
-    shared::sources::uniswap_v2::{
+    liquidity_sources::uniswap_v2::{
         BAOSWAP_INIT,
         HONEYSWAP_INIT,
         SUSHISWAP_INIT,
@@ -14,6 +13,7 @@ use {
         TESTNET_UNISWAP_INIT,
         UNISWAP_INIT,
     },
+    reqwest::Url,
     std::{collections::HashSet, time::Duration},
 };
 
diff --git a/crates/driver/src/infra/tokens.rs b/crates/driver/src/infra/tokens.rs
index 8eecd71d70..3125b52101 100644
--- a/crates/driver/src/infra/tokens.rs
+++ b/crates/driver/src/infra/tokens.rs
@@ -8,7 +8,7 @@ use {
     futures::{FutureExt, StreamExt},
     itertools::Itertools,
     model::order::BUY_ETH_ADDRESS,
-    shared::request_sharing::BoxRequestSharing,
+    request_sharing::BoxRequestSharing,
     std::{
         collections::HashMap,
         sync::{Arc, RwLock},
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 72d88bf701..c42b8b30d3 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -15,6 +15,7 @@ anyhow = { workspace = true }
 app-data = { workspace = true }
 autopilot = { workspace = true, features = ["test-util"] }
 axum = { workspace = true }
+balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
@@ -39,6 +40,7 @@ solvers = { workspace = true }
 solvers-dto = { workspace = true }
 sqlx = { workspace = true }
 tempfile = { workspace = true }
+liquidity-sources = { workspace = true }
 tokio = { workspace = true, features = ["macros", "process"] }
 toml = { workspace = true }
 tracing = { workspace = true }
diff --git a/crates/e2e/src/setup/deploy.rs b/crates/e2e/src/setup/deploy.rs
index 83e3c1589a..18426b92e9 100644
--- a/crates/e2e/src/setup/deploy.rs
+++ b/crates/e2e/src/setup/deploy.rs
@@ -258,8 +258,8 @@ impl Contracts {
 
     pub fn default_pool_code(&self) -> B256 {
         match self.chain_id {
-            100 => B256::new(shared::sources::uniswap_v2::HONEYSWAP_INIT),
-            _ => B256::new(shared::sources::uniswap_v2::UNISWAP_INIT),
+            100 => B256::new(liquidity_sources::uniswap_v2::HONEYSWAP_INIT),
+            _ => B256::new(liquidity_sources::uniswap_v2::UNISWAP_INIT),
         }
     }
 }
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 846c30ee49..151229efc9 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -4,6 +4,7 @@ use {
         providers::Provider,
     },
     autopilot::config::Configuration,
+    balance_overrides::{BalanceOverrides, BalanceOverriding, Strategy},
     bigdecimal::{BigDecimal, Zero},
     e2e::setup::*,
     ethrpc::{Web3, alloy::CallBuilderExt},
@@ -18,12 +19,7 @@ use {
         price_estimation::{
             Estimate,
             Verification,
-            trade_verifier::{
-                PriceQuery,
-                TradeVerifier,
-                TradeVerifying,
-                balance_overrides::{BalanceOverrides, BalanceOverriding, Strategy},
-            },
+            trade_verifier::{PriceQuery, TradeVerifier, TradeVerifying},
         },
         trade_finding::{Interaction, LegacyTrade, QuoteExecution, TradeKind},
     },
@@ -555,7 +551,7 @@ async fn usdt_quote_verification(web3: Web3) {
 /// This test verifies the trace-based detection strategy that's similar to
 /// Foundry's `deal`.
 async fn trace_based_balance_detection(web3: Web3) {
-    use shared::price_estimation::trade_verifier::balance_overrides::detector::Detector;
+    use balance_overrides::detector::Detector;
 
     tracing::info!("Setting up chain state.");
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
@@ -678,10 +674,7 @@ async fn trace_based_balance_detection(web3: Web3) {
         test_account: Address,
         test_balance: U256,
     ) {
-        use {
-            shared::price_estimation::trade_verifier::balance_overrides::BalanceOverrideRequest,
-            std::collections::HashMap,
-        };
+        use {balance_overrides::BalanceOverrideRequest, std::collections::HashMap};
 
         let balance_overrides = BalanceOverrides {
             hardcoded: HashMap::from([(token, strategy)]),
diff --git a/crates/ethrpc/src/block_stream.rs b/crates/ethrpc/src/block_stream.rs
index 2e93c7ddf3..077023a666 100644
--- a/crates/ethrpc/src/block_stream.rs
+++ b/crates/ethrpc/src/block_stream.rs
@@ -7,11 +7,10 @@ use {
         rpc::types::Block,
         transports::ws::WsConnect,
     },
-    anyhow::{Context as _, Result, anyhow, ensure},
-    futures::{StreamExt, TryStreamExt, stream::FuturesUnordered},
+    anyhow::{Context as _, Result, anyhow},
+    futures::StreamExt,
     std::{
         fmt::Debug,
-        num::NonZeroU64,
         time::{Duration, Instant},
     },
     tokio::sync::watch,
@@ -22,31 +21,6 @@ use {
 
 pub type BlockNumberHash = (u64, B256);
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RangeInclusive<T: Ord> {
-    start: T,
-    end: T,
-}
-
-impl<T: Ord> RangeInclusive<T> {
-    pub fn try_new(start: T, end: T) -> Result<Self> {
-        ensure!(end >= start, "end has to be bigger or equal to start");
-        Ok(Self { start, end })
-    }
-
-    pub fn start(&self) -> &T {
-        &self.start
-    }
-
-    pub fn end(&self) -> &T {
-        &self.end
-    }
-
-    pub fn into_inner(self) -> (T, T) {
-        (self.start, self.end)
-    }
-}
-
 /// Block information.
 #[derive(Clone, Copy, Debug, Eq)]
 pub struct BlockInfo {
@@ -288,48 +262,6 @@ pub async fn current_block_stream(
     Ok(receiver)
 }
 
-/// Returns a stream that is synchronized to the passed in stream by only yields
-/// every nth update of the original stream.
-pub fn throttle(blocks: CurrentBlockWatcher, updates_to_skip: NonZeroU64) -> CurrentBlockWatcher {
-    let first_block = *blocks.borrow();
-
-    // `receiver` yields `first_block` immediately.
-    let (sender, receiver) = watch::channel(first_block);
-
-    let update_future = async move {
-        let mut skipped_updates = 0;
-
-        // The `block_stream` would yield `first_block` immediately and since `receiver`
-        // is already guaranteed to yield that block by construction we skip 1
-        // update right away to avoid yielding `first_block` twice from the
-        // throttled stream.
-        let mut block_stream = into_stream(blocks).skip(1);
-
-        while let Some(block) = block_stream.next().await {
-            if skipped_updates == updates_to_skip.get() {
-                // reset counter
-                skipped_updates = 0;
-            } else {
-                // Don't update the throttled stream because we didn't skip enough updates yet.
-                skipped_updates += 1;
-                continue;
-            }
-
-            if let Err(err) = sender.send(block) {
-                tracing::error!(
-                    ?err,
-                    "failed to send block to stream, aborting polling loop"
-                );
-                panic!("polling loop terminated due to sender failure");
-            }
-        }
-    };
-    tokio::task::spawn(
-        update_future.instrument(tracing::info_span!("current_block_stream_throttled")),
-    );
-    receiver
-}
-
 /// A method for creating a block stream with an initial value that never
 /// observes any new blocks. This is useful for testing and creating "mock"
 /// components.
@@ -346,108 +278,7 @@ pub fn into_stream(receiver: CurrentBlockWatcher) -> WatchStream<BlockInfo> {
     WatchStream::new(receiver)
 }
 
-/// Trait for abstracting the retrieval of the block information such as the
-/// latest block number.
-#[async_trait::async_trait]
-pub trait BlockRetrieving: Debug + Send + Sync + 'static {
-    async fn current_block(&self) -> Result<BlockInfo>;
-    async fn block(&self, number: u64) -> Result<BlockNumberHash>;
-    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>>;
-}
-
-#[async_trait::async_trait]
-impl BlockRetrieving for AlloyProvider {
-    #[instrument(skip_all)]
-    async fn current_block(&self) -> Result<BlockInfo> {
-        get_block_at_id(&self, BlockId::latest()).await
-    }
-
-    #[instrument(skip_all)]
-    async fn block(&self, number: u64) -> Result<BlockNumberHash> {
-        let block = get_block_at_id(&self, BlockId::number(number)).await?;
-        Ok((block.number, block.hash))
-    }
-
-    /// Gets all blocks requested in the range. For successful results it's
-    /// enforced that all the blocks are present, in the correct order and that
-    /// there are no reorgs in the block range.
-    #[instrument(skip_all)]
-    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>> {
-        let (start, end) = range.into_inner();
-
-        // Uses FuturesUnordered instead of try_join_all, since the latter
-        // starts using FuturesOrdered once the number of futures exceeds 30, which
-        // doesn't support fail-fast behavior.
-        let futures = FuturesUnordered::new();
-        for block_num in start..=end {
-            let block_id = BlockNumberOrTag::Number(block_num).into();
-            let provider = self.clone();
-            futures.push(async move {
-                provider
-                    .get_block(block_id)
-                    .await
-                    .with_context(|| format!("failed to fetch block {block_num}"))?
-                    .with_context(|| format!("missing block {block_num}"))
-            });
-        }
-
-        let mut blocks: Vec<Block> = futures.try_collect().await?;
-
-        // Sort the same way as the requested range
-        blocks.sort_by_key(|block| block.number());
-
-        let mut prev_hash = None;
-        let mut result = Vec::with_capacity(blocks.len());
-
-        for block in blocks {
-            let current_hash: B256 = block.header.hash;
-            if prev_hash.is_some_and(|prev| prev != block.header.parent_hash) {
-                tracing::debug!(
-                    start,
-                    end,
-                    ?prev_hash,
-                    parent_hash = ?block.header.parent_hash,
-                    block_number = ?block.number(),
-                    "inconsistent parent in block range"
-                );
-                return Err(anyhow!("inconsistent block range"));
-            }
-            prev_hash = Some(current_hash);
-
-            result.push((block.number(), current_hash));
-        }
-
-        Ok(result)
-    }
-}
-
-/// Version of [`BlockRetrieving`] that's optimized for the usage
-/// in the event indexing logic.
-#[derive(Debug, Clone)]
-pub struct BlockRetriever {
-    pub provider: AlloyProvider,
-    pub block_stream: watch::Receiver<BlockInfo>,
-}
-
-#[async_trait::async_trait]
-impl BlockRetrieving for BlockRetriever {
-    #[instrument(skip_all)]
-    async fn current_block(&self) -> Result<BlockInfo> {
-        Ok(*self.block_stream.borrow())
-    }
-
-    #[instrument(skip_all)]
-    async fn block(&self, number: u64) -> Result<BlockNumberHash> {
-        self.provider.block(number).await
-    }
-
-    #[instrument(skip_all)]
-    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>> {
-        self.provider.blocks(range).await
-    }
-}
-
-async fn get_block_at_id(provider: &AlloyProvider, id: BlockId) -> Result<BlockInfo> {
+pub async fn get_block_at_id(provider: &AlloyProvider, id: BlockId) -> Result<BlockInfo> {
     let block = provider
         .get_block(id)
         .await
@@ -568,85 +399,6 @@ mod tests {
         }
     }
 
-    #[tokio::test]
-    #[ignore]
-    async fn current_blocks_test() {
-        let web3 = Web3::new_from_env();
-
-        // single block
-        let range = RangeInclusive::try_new(5, 5).unwrap();
-        let blocks = web3.provider.blocks(range).await.unwrap();
-        assert_eq!(blocks.len(), 1);
-        assert_eq!(blocks.last().unwrap().0, 5);
-
-        // multiple blocks
-        let range = RangeInclusive::try_new(5, 8).unwrap();
-        let blocks = web3.provider.blocks(range).await.unwrap();
-        assert_eq!(blocks.len(), 4);
-        assert_eq!(blocks.last().unwrap().0, 8);
-        assert_eq!(blocks.first().unwrap().0, 5);
-
-        // shortened blocks
-        let current_block_number = 5u64;
-        let length = 25u64;
-        let range = RangeInclusive::try_new(
-            current_block_number.saturating_sub(length),
-            current_block_number,
-        )
-        .unwrap();
-        let blocks = web3.provider.blocks(range).await.unwrap();
-        assert_eq!(blocks.len(), 6);
-        assert_eq!(blocks.last().unwrap().0, 5);
-        assert_eq!(blocks.first().unwrap().0, 0);
-    }
-
-    // Tests that a throttled block stream indeed skips the configured
-    // number of updates.
-    // Always awaits the next block on a timer to not get the test stuck
-    // when we want to assert that no new block is coming.
-    #[tokio::test]
-    async fn throttled_skips_blocks_test() {
-        let (sender, receiver) = watch::channel(new_block(0));
-        const TIMEOUT: Duration = Duration::from_millis(10);
-
-        // stream that yields every other block
-        let throttled = throttle(receiver, 1.try_into().unwrap());
-        let mut stream = into_stream(throttled);
-
-        // Initial block of the original stream gets yielded immediately.
-        // which is consistent with an unthrottled stream.
-        let block = timeout(TIMEOUT, stream.next()).await.unwrap().unwrap();
-        assert_eq!(block.number, 0);
-
-        // Doesn't yield the first block twice
-        let block = timeout(TIMEOUT, stream.next()).await;
-        assert!(block.is_err());
-
-        sender.send(new_block(1)).unwrap();
-
-        // first update gets skipped
-        let block = timeout(TIMEOUT, stream.next()).await;
-        assert!(block.is_err());
-
-        sender.send(new_block(2)).unwrap();
-
-        // second update gets forwarded
-        let block = timeout(TIMEOUT, stream.next()).await.unwrap().unwrap();
-        assert_eq!(block.number, 2);
-
-        sender.send(new_block(3)).unwrap();
-
-        // third update getes skipped again
-        let block = timeout(TIMEOUT, stream.next()).await;
-        assert!(block.is_err());
-
-        sender.send(new_block(4)).unwrap();
-
-        // fourth update gets forwarded again
-        let block = timeout(TIMEOUT, stream.next()).await.unwrap().unwrap();
-        assert_eq!(block.number, 4);
-    }
-
     #[tokio::test]
     async fn test_next_block() {
         let (sender, receiver) = watch::channel(new_block(0));
diff --git a/crates/event-indexing/Cargo.toml b/crates/event-indexing/Cargo.toml
new file mode 100644
index 0000000000..fa5b8a1d61
--- /dev/null
+++ b/crates/event-indexing/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "event-indexing"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+async-stream = { workspace = true }
+anyhow = { workspace = true }
+contracts = { workspace = true }
+futures = { workspace = true }
+tracing = { workspace = true }
+ethrpc = { workspace = true }
+observe = { workspace = true }
+tokio = { workspace = true }
+async-trait = { workspace = true }
+prometheus = { workspace = true }
+prometheus-metric-storage = { workspace = true }
+
+[dev-dependencies]
+tracing-subscriber = { workspace = true }
+mockall = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/event-indexing/LICENSE-APACHE b/crates/event-indexing/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/event-indexing/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/event-indexing/LICENSE-MIT b/crates/event-indexing/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/event-indexing/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/event-indexing/src/block_retriever.rs b/crates/event-indexing/src/block_retriever.rs
new file mode 100644
index 0000000000..c4a5881c6c
--- /dev/null
+++ b/crates/event-indexing/src/block_retriever.rs
@@ -0,0 +1,180 @@
+use {
+    alloy::{
+        eips::{BlockId, BlockNumberOrTag},
+        primitives::B256,
+        providers::Provider,
+        rpc::types::Block,
+    },
+    anyhow::{Context, Result, anyhow, ensure},
+    ethrpc::{
+        AlloyProvider,
+        block_stream::{BlockInfo, BlockNumberHash, get_block_at_id},
+    },
+    futures::{TryStreamExt, stream::FuturesUnordered},
+    std::fmt::Debug,
+    tokio::sync::watch,
+    tracing::instrument,
+};
+
+/// Trait for abstracting the retrieval of the block information such as the
+/// latest block number.
+#[async_trait::async_trait]
+pub trait BlockRetrieving: Debug + Send + Sync + 'static {
+    async fn current_block(&self) -> Result<BlockInfo>;
+    async fn block(&self, number: u64) -> Result<BlockNumberHash>;
+    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>>;
+}
+
+#[async_trait::async_trait]
+impl BlockRetrieving for AlloyProvider {
+    #[instrument(skip_all)]
+    async fn current_block(&self) -> Result<BlockInfo> {
+        get_block_at_id(&self, BlockId::latest()).await
+    }
+
+    #[instrument(skip_all)]
+    async fn block(&self, number: u64) -> Result<BlockNumberHash> {
+        let block = get_block_at_id(&self, BlockId::number(number)).await?;
+        Ok((block.number, block.hash))
+    }
+
+    /// Gets all blocks requested in the range. For successful results it's
+    /// enforced that all the blocks are present, in the correct order and that
+    /// there are no reorgs in the block range.
+    #[instrument(skip_all)]
+    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>> {
+        let (start, end) = range.into_inner();
+
+        // Uses FuturesUnordered instead of try_join_all, since the latter
+        // starts using FuturesOrdered once the number of futures exceeds 30, which
+        // doesn't support fail-fast behavior.
+        let futures = FuturesUnordered::new();
+        for block_num in start..=end {
+            let block_id = BlockNumberOrTag::Number(block_num).into();
+            let provider = self.clone();
+            futures.push(async move {
+                provider
+                    .get_block(block_id)
+                    .await
+                    .with_context(|| format!("failed to fetch block {block_num}"))?
+                    .with_context(|| format!("missing block {block_num}"))
+            });
+        }
+
+        let mut blocks: Vec<Block> = futures.try_collect().await?;
+
+        // Sort the same way as the requested range
+        blocks.sort_by_key(|block| block.number());
+
+        let mut prev_hash = None;
+        let mut result = Vec::with_capacity(blocks.len());
+
+        for block in blocks {
+            let current_hash: B256 = block.header.hash;
+            if prev_hash.is_some_and(|prev| prev != block.header.parent_hash) {
+                tracing::debug!(
+                    start,
+                    end,
+                    ?prev_hash,
+                    parent_hash = ?block.header.parent_hash,
+                    block_number = ?block.number(),
+                    "inconsistent parent in block range"
+                );
+                return Err(anyhow!("inconsistent block range"));
+            }
+            prev_hash = Some(current_hash);
+
+            result.push((block.number(), current_hash));
+        }
+
+        Ok(result)
+    }
+}
+
+/// Version of [`BlockRetrieving`] that's optimized for the usage
+/// in the event indexing logic.
+#[derive(Debug, Clone)]
+pub struct BlockRetriever {
+    pub provider: AlloyProvider,
+    pub block_stream: watch::Receiver<BlockInfo>,
+}
+
+#[async_trait::async_trait]
+impl BlockRetrieving for BlockRetriever {
+    #[instrument(skip_all)]
+    async fn current_block(&self) -> Result<BlockInfo> {
+        Ok(*self.block_stream.borrow())
+    }
+
+    #[instrument(skip_all)]
+    async fn block(&self, number: u64) -> Result<BlockNumberHash> {
+        self.provider.block(number).await
+    }
+
+    #[instrument(skip_all)]
+    async fn blocks(&self, range: RangeInclusive<u64>) -> Result<Vec<BlockNumberHash>> {
+        self.provider.blocks(range).await
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RangeInclusive<T: Ord> {
+    start: T,
+    end: T,
+}
+
+impl<T: Ord> RangeInclusive<T> {
+    pub fn try_new(start: T, end: T) -> Result<Self> {
+        ensure!(end >= start, "end has to be bigger or equal to start");
+        Ok(Self { start, end })
+    }
+
+    pub fn start(&self) -> &T {
+        &self.start
+    }
+
+    pub fn end(&self) -> &T {
+        &self.end
+    }
+
+    pub fn into_inner(self) -> (T, T) {
+        (self.start, self.end)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, ethrpc::Web3};
+
+    #[tokio::test]
+    #[ignore]
+    async fn current_blocks_test() {
+        let web3 = Web3::new_from_env();
+
+        // single block
+        let range = RangeInclusive::try_new(5, 5).unwrap();
+        let blocks = web3.provider.blocks(range).await.unwrap();
+        assert_eq!(blocks.len(), 1);
+        assert_eq!(blocks.last().unwrap().0, 5);
+
+        // multiple blocks
+        let range = RangeInclusive::try_new(5, 8).unwrap();
+        let blocks = web3.provider.blocks(range).await.unwrap();
+        assert_eq!(blocks.len(), 4);
+        assert_eq!(blocks.last().unwrap().0, 8);
+        assert_eq!(blocks.first().unwrap().0, 5);
+
+        // shortened blocks
+        let current_block_number = 5u64;
+        let length = 25u64;
+        let range = RangeInclusive::try_new(
+            current_block_number.saturating_sub(length),
+            current_block_number,
+        )
+        .unwrap();
+        let blocks = web3.provider.blocks(range).await.unwrap();
+        assert_eq!(blocks.len(), 6);
+        assert_eq!(blocks.last().unwrap().0, 5);
+        assert_eq!(blocks.first().unwrap().0, 0);
+    }
+}
diff --git a/crates/shared/src/event_handling.rs b/crates/event-indexing/src/event_handler.rs
similarity index 99%
rename from crates/shared/src/event_handling.rs
rename to crates/event-indexing/src/event_handler.rs
index 4e3fb6c980..7e64d20bc4 100644
--- a/crates/shared/src/event_handling.rs
+++ b/crates/event-indexing/src/event_handler.rs
@@ -1,5 +1,8 @@
 use {
-    crate::maintenance::Maintaining,
+    crate::{
+        block_retriever::{BlockRetrieving, RangeInclusive},
+        maintenance::Maintaining,
+    },
     alloy::{
         primitives::{Address, B256},
         providers::{DynProvider, Provider},
@@ -7,7 +10,7 @@ use {
         sol_types::SolEventInterface,
     },
     anyhow::{Context, Result},
-    ethrpc::block_stream::{BlockNumberHash, BlockRetrieving, RangeInclusive},
+    ethrpc::block_stream::BlockNumberHash,
     futures::{Stream, StreamExt},
     std::{pin::Pin, sync::Arc},
     tokio::sync::Mutex,
diff --git a/crates/event-indexing/src/lib.rs b/crates/event-indexing/src/lib.rs
new file mode 100644
index 0000000000..11793d1db6
--- /dev/null
+++ b/crates/event-indexing/src/lib.rs
@@ -0,0 +1,3 @@
+pub mod block_retriever;
+pub mod event_handler;
+pub mod maintenance;
diff --git a/crates/shared/src/maintenance.rs b/crates/event-indexing/src/maintenance.rs
similarity index 100%
rename from crates/shared/src/maintenance.rs
rename to crates/event-indexing/src/maintenance.rs
diff --git a/crates/liquidity-sources/Cargo.toml b/crates/liquidity-sources/Cargo.toml
new file mode 100644
index 0000000000..2262fb2a50
--- /dev/null
+++ b/crates/liquidity-sources/Cargo.toml
@@ -0,0 +1,50 @@
+[package]
+name = "liquidity-sources"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+cached = { workspace = true }
+chain = { workspace = true }
+clap = { workspace = true }
+contracts = { workspace = true }
+ethrpc = { workspace = true }
+event-indexing = { workspace = true }
+hex-literal = { workspace = true }
+itertools = { workspace = true }
+futures = { workspace = true }
+model = { workspace = true }
+mockall = { workspace = true, optional = true }
+num = { workspace = true }
+number = { workspace = true }
+observe = { workspace = true }
+prometheus = { workspace = true }
+prometheus-metric-storage = { workspace = true }
+regex = { workspace = true }
+request-sharing = { workspace = true }
+reqwest = { workspace = true }
+serde = { workspace = true }
+serde_with = { workspace = true }
+serde_json = { workspace = true }
+strum = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+token-info = { workspace = true }
+tokio = { workspace = true }
+
+[dev-dependencies]
+mockall = { workspace = true }
+maplit = { workspace = true }
+testlib = { workspace = true }
+token-info = { workspace = true, features = ["test-util"] }
+
+[features]
+test-util = ["dep:mockall"]
+
+[lints]
+workspace = true
diff --git a/crates/liquidity-sources/LICENSE-APACHE b/crates/liquidity-sources/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/liquidity-sources/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/liquidity-sources/LICENSE-MIT b/crates/liquidity-sources/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/liquidity-sources/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/sources/balancer_v2/graph_api.rs b/crates/liquidity-sources/src/balancer_v2/graph_api.rs
similarity index 99%
rename from crates/shared/src/sources/balancer_v2/graph_api.rs
rename to crates/liquidity-sources/src/balancer_v2/graph_api.rs
index 515dbdd36d..45bc8601b1 100644
--- a/crates/shared/src/sources/balancer_v2/graph_api.rs
+++ b/crates/liquidity-sources/src/balancer_v2/graph_api.rs
@@ -10,9 +10,10 @@
 
 use {
     super::swap::fixed_point::Bfp,
-    crate::{event_handling::MAX_REORG_BLOCK_COUNT, subgraph::SubgraphClient},
+    crate::{json_map, subgraph::SubgraphClient},
     alloy::primitives::{Address, B256},
     anyhow::Result,
+    event_indexing::event_handler::MAX_REORG_BLOCK_COUNT,
     reqwest::{Client, Url},
     serde::Deserialize,
     serde_json::json,
@@ -243,7 +244,7 @@ mod block_number_query {
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::swap::fixed_point::Bfp,
+        crate::balancer_v2::swap::fixed_point::Bfp,
         alloy::primitives::U256,
         maplit::hashmap,
     };
diff --git a/crates/shared/src/sources/balancer_v2/mod.rs b/crates/liquidity-sources/src/balancer_v2/mod.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/mod.rs
rename to crates/liquidity-sources/src/balancer_v2/mod.rs
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/aggregate.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/aggregate.rs
similarity index 94%
rename from crates/shared/src/sources/balancer_v2/pool_fetching/aggregate.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_fetching/aggregate.rs
index cfa35d273a..6e6f87d843 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/aggregate.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/aggregate.rs
@@ -3,7 +3,7 @@
 
 use {
     super::internal::InternalPoolFetching,
-    crate::{recent_block_cache::Block, sources::balancer_v2::pools::Pool},
+    crate::{balancer_v2::pools::Pool, recent_block_cache::Block},
     alloy::primitives::B256,
     anyhow::Result,
     futures::future,
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/cache.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/cache.rs
similarity index 98%
rename from crates/shared/src/sources/balancer_v2/pool_fetching/cache.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_fetching/cache.rs
index 92cd6f9a95..ef47caed83 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/cache.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/cache.rs
@@ -6,8 +6,8 @@
 use {
     super::internal::InternalPoolFetching,
     crate::{
+        balancer_v2::pools::Pool,
         recent_block_cache::{Block, CacheConfig, CacheFetching, CacheKey, RecentBlockCache},
-        sources::balancer_v2::pools::Pool,
     },
     alloy::primitives::B256,
     anyhow::Result,
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/internal.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/internal.rs
similarity index 91%
rename from crates/shared/src/sources/balancer_v2/pool_fetching/internal.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_fetching/internal.rs
index 6413b4c8b1..c0c6688dc9 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/internal.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/internal.rs
@@ -2,7 +2,7 @@
 //! strategies.
 
 use {
-    crate::{recent_block_cache::Block, sources::balancer_v2::pools::Pool},
+    crate::{balancer_v2::pools::Pool, recent_block_cache::Block},
     alloy::primitives::B256,
     anyhow::Result,
     model::TokenPair,
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs
similarity index 98%
rename from crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs
index dae2f87569..fd792b1ff1 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/mod.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs
@@ -25,11 +25,7 @@ use {
         },
         swap::fixed_point::Bfp,
     },
-    crate::{
-        recent_block_cache::{Block, CacheConfig},
-        token_info::TokenInfoFetching,
-        web3::Web3,
-    },
+    crate::recent_block_cache::{Block, CacheConfig},
     alloy::{
         eips::BlockNumberOrTag,
         primitives::{Address, B256},
@@ -51,16 +47,15 @@ use {
         BalancerV2WeightedPoolFactoryV3,
         BalancerV2WeightedPoolFactoryV4,
     },
-    ethrpc::{
-        alloy::ProviderLabelingExt,
-        block_stream::{BlockRetrieving, CurrentBlockWatcher},
-    },
+    ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
+    event_indexing::block_retriever::BlockRetrieving,
     model::TokenPair,
     reqwest::{Client, Url},
     std::{
         collections::{BTreeMap, HashSet},
         sync::Arc,
     },
+    token_info::TokenInfoFetching,
     tracing::instrument,
 };
 pub use {
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/pool_storage.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs
similarity index 99%
rename from crates/shared/src/sources/balancer_v2/pool_fetching/pool_storage.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs
index 203289a30f..3e57bae018 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/pool_storage.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs
@@ -16,10 +16,7 @@
 //!    efficient lookup searching for pools based on token pairs.
 
 use {
-    crate::{
-        event_handling::EventStoring,
-        sources::balancer_v2::pools::{FactoryIndexing, PoolIndexing, common},
-    },
+    crate::balancer_v2::pools::{FactoryIndexing, PoolIndexing, common},
     alloy::{
         primitives::{Address, B256},
         rpc::types::Log,
@@ -29,7 +26,7 @@ use {
         BalancerV2BasePoolFactoryEvents,
         PoolCreated,
     },
-    ethrpc::block_stream::RangeInclusive,
+    event_indexing::{block_retriever::RangeInclusive, event_handler::EventStoring},
     model::TokenPair,
     std::{
         cmp,
@@ -231,7 +228,7 @@ where
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::{
+        crate::balancer_v2::{
             pools::{MockFactoryIndexing, common::MockPoolInfoFetching, weighted},
             swap::fixed_point::Bfp,
         },
diff --git a/crates/shared/src/sources/balancer_v2/pool_fetching/registry.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs
similarity index 95%
rename from crates/shared/src/sources/balancer_v2/pool_fetching/registry.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs
index ae2449c971..3a64978195 100644
--- a/crates/shared/src/sources/balancer_v2/pool_fetching/registry.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs
@@ -4,13 +4,11 @@
 use {
     super::{internal::InternalPoolFetching, pool_storage::PoolStorage},
     crate::{
-        event_handling::{AlloyEventRetrieving, EventHandler},
-        maintenance::Maintaining,
-        recent_block_cache::Block,
-        sources::balancer_v2::{
+        balancer_v2::{
             pool_fetching::BalancerFactoryInstance,
             pools::{FactoryIndexing, Pool, PoolStatus, common::PoolInfoFetching},
         },
+        recent_block_cache::Block,
     },
     BalancerV2BasePoolFactory::BalancerV2BasePoolFactory::BalancerV2BasePoolFactoryEvents,
     alloy::{
@@ -21,9 +19,11 @@ use {
     },
     anyhow::Result,
     contracts::alloy::BalancerV2BasePoolFactory::{self, BalancerV2BasePoolFactory::PoolCreated},
-    ethrpc::{
-        alloy::errors::ContractErrorExt,
-        block_stream::{BlockNumberHash, BlockRetrieving},
+    ethrpc::{alloy::errors::ContractErrorExt, block_stream::BlockNumberHash},
+    event_indexing::{
+        block_retriever::BlockRetrieving,
+        event_handler::{AlloyEventRetrieving, EventHandler},
+        maintenance::Maintaining,
     },
     futures::future,
     model::TokenPair,
@@ -159,7 +159,7 @@ fn collect_pool_results(pools: Vec<Result<PoolStatus>>) -> Result<Vec<Pool>> {
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::{
+        crate::balancer_v2::{
             pools::{PoolKind, weighted},
             swap::fixed_point::Bfp,
         },
diff --git a/crates/shared/src/sources/balancer_v2/pool_init.rs b/crates/liquidity-sources/src/balancer_v2/pool_init.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/pool_init.rs
rename to crates/liquidity-sources/src/balancer_v2/pool_init.rs
diff --git a/crates/shared/src/sources/balancer_v2/pools/common.rs b/crates/liquidity-sources/src/balancer_v2/pools/common.rs
similarity index 99%
rename from crates/shared/src/sources/balancer_v2/pools/common.rs
rename to crates/liquidity-sources/src/balancer_v2/pools/common.rs
index d1dcae8438..b2c4a08a4f 100644
--- a/crates/shared/src/sources/balancer_v2/pools/common.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/common.rs
@@ -2,12 +2,9 @@
 
 use {
     super::{FactoryIndexing, Pool, PoolIndexing as _, PoolStatus},
-    crate::{
-        sources::balancer_v2::{
-            graph_api::{PoolData, PoolType},
-            swap::fixed_point::Bfp,
-        },
-        token_info::TokenInfoFetching,
+    crate::balancer_v2::{
+        graph_api::{PoolData, PoolType},
+        swap::fixed_point::Bfp,
     },
     alloy::{
         eips::BlockId,
@@ -17,6 +14,7 @@ use {
     contracts::alloy::{BalancerV2BasePool, BalancerV2Vault},
     futures::{FutureExt as _, future::BoxFuture},
     std::{collections::BTreeMap, future::Future, sync::Arc},
+    token_info::TokenInfoFetching,
     tokio::sync::oneshot,
 };
 
@@ -357,12 +355,12 @@ mod tests {
     use {
         super::*,
         crate::{
-            sources::balancer_v2::{
+            balancer_v2::{
                 PoolKind,
                 graph_api::{PoolType, Token},
                 pools::{MockFactoryIndexing, weighted},
             },
-            token_info::{MockTokenInfoFetching, TokenInfo},
+            bfp,
         },
         alloy::{
             providers::{Provider, ProviderBuilder},
@@ -374,6 +372,7 @@ mod tests {
         maplit::{btreemap, hashmap},
         mockall::predicate,
         std::future,
+        token_info::{MockTokenInfoFetching, TokenInfo},
     };
 
     #[tokio::test]
diff --git a/crates/shared/src/sources/balancer_v2/pools/composable_stable.rs b/crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs
similarity index 97%
rename from crates/shared/src/sources/balancer_v2/pools/composable_stable.rs
rename to crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs
index d680183ab5..8a1fd2d12e 100644
--- a/crates/shared/src/sources/balancer_v2/pools/composable_stable.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs
@@ -2,7 +2,7 @@
 
 use {
     super::{FactoryIndexing, PoolIndexing, common},
-    crate::sources::balancer_v2::{
+    crate::balancer_v2::{
         graph_api::{PoolData, PoolType},
         swap::fixed_point::Bfp,
     },
@@ -112,7 +112,7 @@ impl FactoryIndexing for BalancerV2ComposableStablePoolFactory::Instance {
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::graph_api::Token,
+        crate::balancer_v2::graph_api::Token,
         alloy::primitives::{Address, B256},
     };
 
diff --git a/crates/shared/src/sources/balancer_v2/pools/liquidity_bootstrapping.rs b/crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs
similarity index 97%
rename from crates/shared/src/sources/balancer_v2/pools/liquidity_bootstrapping.rs
rename to crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs
index c194ee573d..930416afc8 100644
--- a/crates/shared/src/sources/balancer_v2/pools/liquidity_bootstrapping.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs
@@ -2,7 +2,7 @@
 
 use {
     super::{FactoryIndexing, PoolIndexing, common},
-    crate::sources::balancer_v2::{
+    crate::balancer_v2::{
         graph_api::{PoolData, PoolType},
         swap::fixed_point::Bfp,
     },
@@ -118,7 +118,7 @@ impl FactoryIndexing for BalancerV2LiquidityBootstrappingPoolFactory::Instance {
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::graph_api::Token,
+        crate::balancer_v2::graph_api::Token,
         alloy::primitives::{Address, B256},
     };
 
diff --git a/crates/shared/src/sources/balancer_v2/pools/mod.rs b/crates/liquidity-sources/src/balancer_v2/pools/mod.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/pools/mod.rs
rename to crates/liquidity-sources/src/balancer_v2/pools/mod.rs
diff --git a/crates/shared/src/sources/balancer_v2/pools/stable.rs b/crates/liquidity-sources/src/balancer_v2/pools/stable.rs
similarity index 97%
rename from crates/shared/src/sources/balancer_v2/pools/stable.rs
rename to crates/liquidity-sources/src/balancer_v2/pools/stable.rs
index f917f4bbda..cf8669aead 100644
--- a/crates/shared/src/sources/balancer_v2/pools/stable.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/stable.rs
@@ -2,7 +2,7 @@
 
 use {
     super::{FactoryIndexing, PoolIndexing, common},
-    crate::sources::balancer_v2::{
+    crate::balancer_v2::{
         graph_api::{PoolData, PoolType},
         swap::fixed_point::Bfp,
     },
@@ -127,7 +127,7 @@ impl FactoryIndexing for BalancerV2StablePoolFactoryV2::Instance {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::sources::balancer_v2::graph_api::Token, alloy::primitives::B256};
+    use {super::*, crate::balancer_v2::graph_api::Token, alloy::primitives::B256};
 
     #[test]
     fn errors_when_converting_wrong_pool_type() {
diff --git a/crates/shared/src/sources/balancer_v2/pools/weighted.rs b/crates/liquidity-sources/src/balancer_v2/pools/weighted.rs
similarity index 99%
rename from crates/shared/src/sources/balancer_v2/pools/weighted.rs
rename to crates/liquidity-sources/src/balancer_v2/pools/weighted.rs
index fc0f6debc5..08dae4e147 100644
--- a/crates/shared/src/sources/balancer_v2/pools/weighted.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/weighted.rs
@@ -2,7 +2,7 @@
 
 use {
     super::{FactoryIndexing, PoolIndexing, common},
-    crate::sources::balancer_v2::{
+    crate::balancer_v2::{
         graph_api::{PoolData, PoolType},
         swap::fixed_point::Bfp,
     },
@@ -145,7 +145,7 @@ fn pool_state(
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::graph_api::Token,
+        crate::{balancer_v2::graph_api::Token, bfp},
         alloy::{
             primitives::{Address, B256, U256},
             providers::{Provider, ProviderBuilder, mock::Asserter},
diff --git a/crates/shared/src/sources/balancer_v2/swap/error.rs b/crates/liquidity-sources/src/balancer_v2/swap/error.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/swap/error.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/error.rs
diff --git a/crates/shared/src/sources/balancer_v2/swap/fixed_point.rs b/crates/liquidity-sources/src/balancer_v2/swap/fixed_point.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/swap/fixed_point.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/fixed_point.rs
diff --git a/crates/shared/src/sources/balancer_v2/swap/fixed_point/logexpmath.rs b/crates/liquidity-sources/src/balancer_v2/swap/fixed_point/logexpmath.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/swap/fixed_point/logexpmath.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/fixed_point/logexpmath.rs
diff --git a/crates/shared/src/sources/balancer_v2/swap/math.rs b/crates/liquidity-sources/src/balancer_v2/swap/math.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/swap/math.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/math.rs
diff --git a/crates/shared/src/sources/balancer_v2/swap/mod.rs b/crates/liquidity-sources/src/balancer_v2/swap/mod.rs
similarity index 99%
rename from crates/shared/src/sources/balancer_v2/swap/mod.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/mod.rs
index 209238c979..8d5f107892 100644
--- a/crates/shared/src/sources/balancer_v2/swap/mod.rs
+++ b/crates/liquidity-sources/src/balancer_v2/swap/mod.rs
@@ -1,7 +1,6 @@
 use {
     crate::{
-        baseline_solver::BaselineSolvable,
-        sources::balancer_v2::pool_fetching::{
+        balancer_v2::pool_fetching::{
             AmplificationParameter,
             StablePool,
             TokenState,
@@ -9,6 +8,7 @@ use {
             WeightedPoolVersion,
             WeightedTokenState,
         },
+        baseline_solvable::BaselineSolvable,
     },
     alloy::primitives::{Address, U256},
     error::Error,
@@ -437,7 +437,10 @@ impl BaselineSolvable for StablePool {
 mod tests {
     use {
         super::*,
-        crate::sources::balancer_v2::pool_fetching::{AmplificationParameter, CommonPoolState},
+        crate::{
+            balancer_v2::pool_fetching::{AmplificationParameter, CommonPoolState},
+            bfp,
+        },
         alloy::primitives::Address,
     };
 
diff --git a/crates/shared/src/sources/balancer_v2/swap/stable_math.rs b/crates/liquidity-sources/src/balancer_v2/swap/stable_math.rs
similarity index 99%
rename from crates/shared/src/sources/balancer_v2/swap/stable_math.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/stable_math.rs
index 72c77856db..3d18199851 100644
--- a/crates/shared/src/sources/balancer_v2/swap/stable_math.rs
+++ b/crates/liquidity-sources/src/balancer_v2/swap/stable_math.rs
@@ -4,7 +4,7 @@
 
 use {
     super::error::Error,
-    crate::sources::balancer_v2::swap::{fixed_point::Bfp, math::BalU256},
+    crate::balancer_v2::swap::{fixed_point::Bfp, math::BalU256},
     alloy::primitives::U256,
     std::sync::LazyLock,
 };
@@ -221,7 +221,7 @@ fn convergence_criteria(curr_value: U256, prev_value: U256) -> Option<U256> {
 /// Cross-reference to the TS code: https://github.com/balancer-labs/balancer-v2-monorepo/blob/stable-deployment/pvt/helpers/src/models/pools/stable/math.ts
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::sources::balancer_v2::swap::fixed_point::Bfp, std::str::FromStr};
+    use {super::*, crate::balancer_v2::swap::fixed_point::Bfp, std::str::FromStr};
 
     // interpreted from
     // https://github.com/balancer-labs/balancer-v2-monorepo/blob/stable-deployment/pvt/helpers/src/models/pools/stable/math.ts#L53
diff --git a/crates/shared/src/sources/balancer_v2/swap/weighted_math.rs b/crates/liquidity-sources/src/balancer_v2/swap/weighted_math.rs
similarity index 100%
rename from crates/shared/src/sources/balancer_v2/swap/weighted_math.rs
rename to crates/liquidity-sources/src/balancer_v2/swap/weighted_math.rs
diff --git a/crates/liquidity-sources/src/base_tokens.rs b/crates/liquidity-sources/src/base_tokens.rs
new file mode 100644
index 0000000000..6e1c66287e
--- /dev/null
+++ b/crates/liquidity-sources/src/base_tokens.rs
@@ -0,0 +1,253 @@
+use {alloy::primitives::Address, model::TokenPair, std::collections::HashSet};
+
+/// The maximum number of hops to use when trading with AMMs along a path.
+const DEFAULT_MAX_HOPS: usize = 2;
+
+type PathCandidate = Vec<Address>;
+
+pub struct BaseTokens {
+    /// The base tokens used to determine potential paths in the baseline
+    /// solver.
+    ///
+    /// Always includes the native token.
+    tokens: HashSet<Address>,
+    /// All pairs of above.
+    pairs: HashSet<TokenPair>,
+}
+
+impl BaseTokens {
+    pub fn new(native_token: Address, base_tokens: &[Address]) -> Self {
+        let mut tokens = base_tokens.to_vec();
+        tokens.push(native_token);
+        tokens.sort();
+        tokens.dedup();
+        let pairs = base_token_pairs(&tokens).collect();
+        Self {
+            tokens: tokens.into_iter().collect(),
+            pairs,
+        }
+    }
+
+    pub fn tokens(&self) -> &HashSet<Address> {
+        &self.tokens
+    }
+
+    /// All pool token pairs that could be used along a path candidate for these
+    /// token pairs.
+    pub fn relevant_pairs(&self, pairs: impl Iterator<Item = TokenPair>) -> HashSet<TokenPair> {
+        let mut result = HashSet::new();
+        for pair in pairs {
+            result.insert(pair);
+            for token in pair {
+                result.extend(
+                    self.tokens
+                        .iter()
+                        .filter_map(move |base_token| TokenPair::new(*base_token, token)),
+                );
+            }
+        }
+        // Could be empty if the input pairs are empty. Just like path_candidates we
+        // return empty set in this case.
+        if !result.is_empty() {
+            result.extend(self.pairs.iter().copied());
+        }
+        result
+    }
+
+    // Returns possible paths from sell_token to buy token, given a list of
+    // potential intermediate base tokens and a maximum number of intermediate
+    // steps. Can contain token pairs between base tokens or a base token and
+    // the sell or buy token.
+    pub fn path_candidates(
+        &self,
+        sell_token: Address,
+        buy_token: Address,
+    ) -> HashSet<PathCandidate> {
+        self.path_candidates_with_hops(sell_token, buy_token, DEFAULT_MAX_HOPS)
+    }
+
+    /// Returns possible path candidates with the specified number of maximum
+    /// hops.
+    pub fn path_candidates_with_hops(
+        &self,
+        sell_token: Address,
+        buy_token: Address,
+        max_hops: usize,
+    ) -> HashSet<PathCandidate> {
+        path_candidates(sell_token, buy_token, &self.tokens, max_hops)
+    }
+}
+
+fn path_candidates(
+    sell_token: Address,
+    buy_token: Address,
+    base_tokens: &HashSet<Address>,
+    max_hops: usize,
+) -> HashSet<PathCandidate> {
+    if sell_token == buy_token {
+        return HashSet::new();
+    }
+
+    let mut candidates = HashSet::new();
+
+    // Start with just the sell token (yields the direct pair candidate in the 0th
+    // iteration)
+    let mut path_prefixes = vec![vec![sell_token]];
+    for _ in 0..(max_hops + 1) {
+        let mut next_round_path_prefixes = vec![];
+        for path_prefix in &path_prefixes {
+            // For this round, add the buy token and path to the candidates
+            let mut full_path = path_prefix.clone();
+            full_path.push(buy_token);
+            candidates.insert(full_path);
+
+            // For the next round, amend current prefix with all base tokens that are not
+            // yet on the path
+            for base_token in base_tokens {
+                if base_token != &buy_token && !path_prefix.contains(base_token) {
+                    let mut next_round_path_prefix = path_prefix.clone();
+                    next_round_path_prefix.push(*base_token);
+                    next_round_path_prefixes.push(next_round_path_prefix);
+                }
+            }
+        }
+        path_prefixes = next_round_path_prefixes;
+    }
+    candidates
+}
+
+/// All token pairs between base tokens.
+fn base_token_pairs(base_tokens: &[Address]) -> impl Iterator<Item = TokenPair> + '_ {
+    base_tokens
+        .iter()
+        .copied()
+        .enumerate()
+        .flat_map(move |(index, token)| {
+            base_tokens
+                .iter()
+                .copied()
+                .skip(index)
+                .filter_map(move |token_| TokenPair::new(token, token_))
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, maplit::hashset, model::TokenPair};
+
+    #[test]
+    fn path_candidates_empty_when_same_token() {
+        let base = BaseTokens::new(Address::with_last_byte(0), &[Address::with_last_byte(1)]);
+        let sell_token = Address::with_last_byte(2);
+        let buy_token = Address::with_last_byte(2);
+
+        assert!(base.path_candidates(sell_token, buy_token).is_empty());
+    }
+
+    #[test]
+    fn test_path_candidates() {
+        let base_tokens = [
+            Address::with_last_byte(0),
+            Address::with_last_byte(1),
+            Address::with_last_byte(2),
+        ];
+        let base_token_set: HashSet<Address> = base_tokens.iter().copied().collect();
+
+        let sell_token = Address::with_last_byte(4);
+        let buy_token = Address::with_last_byte(5);
+
+        // 0 hops
+        assert_eq!(
+            path_candidates(sell_token, buy_token, &base_token_set, 0),
+            hashset! {vec![sell_token, buy_token]}
+        );
+
+        // 1 hop with all permutations
+        assert_eq!(
+            path_candidates(sell_token, buy_token, &base_token_set, 1),
+            hashset! {
+                vec![sell_token, buy_token],
+                vec![sell_token, base_tokens[0], buy_token],
+                vec![sell_token, base_tokens[1], buy_token],
+                vec![sell_token, base_tokens[2], buy_token],
+
+            }
+        );
+
+        // 2 & 3 hops check count
+        assert_eq!(
+            path_candidates(sell_token, buy_token, &base_token_set, 2).len(),
+            10
+        );
+        assert_eq!(
+            path_candidates(sell_token, buy_token, &base_token_set, 3).len(),
+            16
+        );
+
+        // 4 hops should not yield any more permutations since we used all base tokens
+        assert_eq!(
+            path_candidates(sell_token, buy_token, &base_token_set, 4).len(),
+            16
+        );
+
+        // Ignores base token if part of buy or sell
+        assert_eq!(
+            path_candidates(base_tokens[0], buy_token, &base_token_set, 1),
+            hashset! {
+                vec![base_tokens[0], buy_token],
+                vec![base_tokens[0], base_tokens[1], buy_token],
+                vec![base_tokens[0], base_tokens[2], buy_token],
+
+            }
+        );
+        assert_eq!(
+            path_candidates(sell_token, base_tokens[0], &base_token_set, 1),
+            hashset! {
+                vec![sell_token, base_tokens[0]],
+                vec![sell_token, base_tokens[1], base_tokens[0]],
+                vec![sell_token, base_tokens[2], base_tokens[0]],
+
+            }
+        );
+    }
+
+    #[test]
+    fn base_token_pairs_() {
+        let base_tokens: Vec<Address> = [0, 1, 2]
+            .iter()
+            .copied()
+            .map(Address::with_last_byte)
+            .collect();
+        let pairs: Vec<TokenPair> = base_token_pairs(&base_tokens).collect();
+        assert_eq!(pairs.len(), 3);
+        assert!(pairs.contains(&TokenPair::new(base_tokens[0], base_tokens[1]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(base_tokens[0], base_tokens[2]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(base_tokens[1], base_tokens[2]).unwrap()));
+    }
+
+    #[test]
+    fn relevant_pairs() {
+        let tokens: Vec<Address> = [0, 1, 2, 3, 4]
+            .iter()
+            .copied()
+            .map(Address::with_last_byte)
+            .collect();
+        let base = BaseTokens::new(tokens[0], &tokens[1..2]);
+
+        let pairs = base.relevant_pairs(&mut std::iter::empty());
+        assert!(pairs.is_empty());
+
+        let pairs = base.relevant_pairs(&mut TokenPair::new(tokens[0], tokens[1]).into_iter());
+        assert_eq!(pairs.len(), 1);
+        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[1]).unwrap()));
+
+        let pairs = base.relevant_pairs(&mut TokenPair::new(tokens[3], tokens[4]).into_iter());
+        assert_eq!(pairs.len(), 6);
+        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[1]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[3]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[4]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(tokens[1], tokens[3]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(tokens[1], tokens[4]).unwrap()));
+        assert!(pairs.contains(&TokenPair::new(tokens[3], tokens[4]).unwrap()));
+    }
+}
diff --git a/crates/liquidity-sources/src/baseline_solvable.rs b/crates/liquidity-sources/src/baseline_solvable.rs
new file mode 100644
index 0000000000..96ab390eb1
--- /dev/null
+++ b/crates/liquidity-sources/src/baseline_solvable.rs
@@ -0,0 +1,29 @@
+use alloy::primitives::{Address, U256};
+
+/// Note that get_amount_out and get_amount_in are not always symmetrical. That
+/// is for some AMMs it is possible that get_amount_out returns an amount for
+/// which get_amount_in returns None when trying to go the reverse direction. Or
+/// that the resulting amount is different from the original. This situation is
+/// rare and resulting amounts should usually be identical or very close but it
+/// can occur.
+pub trait BaselineSolvable {
+    /// Given the desired output token, the amount and token input, return the
+    /// expected amount of output token.
+    fn get_amount_out(
+        &self,
+        out_token: Address,
+        input: (U256, Address),
+    ) -> impl Future<Output = Option<U256>> + Send;
+
+    /// Given the input token, the amount and token we want output, return the
+    /// required amount of input token that needs to be provided.
+    fn get_amount_in(
+        &self,
+        in_token: Address,
+        out: (U256, Address),
+    ) -> impl Future<Output = Option<U256>> + Send;
+
+    /// Returns the approximate amount of gas that using this piece of liquidity
+    /// would incur
+    fn gas_cost(&self) -> impl Future<Output = usize> + Send;
+}
diff --git a/crates/shared/src/sources/mod.rs b/crates/liquidity-sources/src/lib.rs
similarity index 95%
rename from crates/shared/src/sources/mod.rs
rename to crates/liquidity-sources/src/lib.rs
index 1099d03704..aba36476e0 100644
--- a/crates/shared/src/sources/mod.rs
+++ b/crates/liquidity-sources/src/lib.rs
@@ -1,6 +1,11 @@
 //! Top-level module organizing all baseline liquidity sources.
 
 pub mod balancer_v2;
+pub mod base_tokens;
+pub mod baseline_solvable;
+mod macros;
+pub mod recent_block_cache;
+pub mod subgraph;
 pub mod swapr;
 pub mod uniswap_v2;
 pub mod uniswap_v3;
diff --git a/crates/liquidity-sources/src/macros.rs b/crates/liquidity-sources/src/macros.rs
new file mode 100644
index 0000000000..c9fbf51f3a
--- /dev/null
+++ b/crates/liquidity-sources/src/macros.rs
@@ -0,0 +1,20 @@
+#[macro_export]
+macro_rules! bfp {
+    ($val:literal) => {
+        ($val)
+            .parse::<$crate::balancer_v2::swap::fixed_point::Bfp>()
+            .unwrap()
+    };
+}
+
+#[macro_export]
+macro_rules! json_map {
+    ($($key:expr_2021 => $value:expr_2021),* $(,)?) => {{
+        #[allow(unused_mut)]
+        let mut map = ::serde_json::Map::<String, ::serde_json::Value>::new();
+        $(
+            map.insert(($key).into(), ($value).into());
+        )*
+        map
+    }}
+}
diff --git a/crates/shared/src/recent_block_cache.rs b/crates/liquidity-sources/src/recent_block_cache.rs
similarity index 99%
rename from crates/shared/src/recent_block_cache.rs
rename to crates/liquidity-sources/src/recent_block_cache.rs
index 5c771837f4..c77376799a 100644
--- a/crates/shared/src/recent_block_cache.rs
+++ b/crates/liquidity-sources/src/recent_block_cache.rs
@@ -25,7 +25,6 @@
 //! could simplify this module if it was only used by by the former.
 
 use {
-    crate::request_sharing::BoxRequestSharing,
     alloy::eips::BlockId,
     anyhow::{Context, Result},
     cached::{Cached, SizedCache},
@@ -33,6 +32,7 @@ use {
     futures::{FutureExt, StreamExt},
     itertools::Itertools,
     prometheus::IntCounterVec,
+    request_sharing::BoxRequestSharing,
     std::{
         cmp,
         collections::{BTreeMap, HashMap, HashSet, hash_map::Entry},
diff --git a/crates/shared/src/subgraph.rs b/crates/liquidity-sources/src/subgraph.rs
similarity index 99%
rename from crates/shared/src/subgraph.rs
rename to crates/liquidity-sources/src/subgraph.rs
index afa43a5aa4..2c87b245b7 100644
--- a/crates/shared/src/subgraph.rs
+++ b/crates/liquidity-sources/src/subgraph.rs
@@ -1,6 +1,7 @@
 //! A module implementing a client for querying subgraphs.
 
 use {
+    crate::json_map,
     anyhow::{Result, bail},
     reqwest::{Client, Url},
     serde::{Deserialize, Serialize, de::DeserializeOwned},
diff --git a/crates/shared/src/sources/swapr.rs b/crates/liquidity-sources/src/swapr.rs
similarity index 93%
rename from crates/shared/src/sources/swapr.rs
rename to crates/liquidity-sources/src/swapr.rs
index bb2d3a6d73..ffa67bddf0 100644
--- a/crates/shared/src/sources/swapr.rs
+++ b/crates/liquidity-sources/src/swapr.rs
@@ -1,7 +1,7 @@
 //! A pool state reading implementation specific to Swapr.
 
 use {
-    crate::sources::uniswap_v2::pool_fetching::{DefaultPoolReader, Pool, PoolReading},
+    crate::uniswap_v2::pool_fetching::{DefaultPoolReader, Pool, PoolReading},
     alloy::eips::BlockId,
     anyhow::Result,
     contracts::alloy::ISwaprPair,
@@ -54,16 +54,12 @@ fn handle_results(
 mod tests {
     use {
         super::*,
-        crate::{
-            recent_block_cache::Block,
-            sources::{BaselineSource, uniswap_v2},
-            web3::Web3,
-        },
+        crate::{BaselineSource, recent_block_cache::Block, uniswap_v2},
         alloy::{
             primitives::{Address, address},
             providers::Provider,
         },
-        ethrpc::alloy::errors::testing_alloy_contract_error,
+        ethrpc::{Web3, alloy::errors::testing_alloy_contract_error},
         maplit::hashset,
     };
 
diff --git a/crates/shared/src/sources/uniswap_v2/mod.rs b/crates/liquidity-sources/src/uniswap_v2/mod.rs
similarity index 98%
rename from crates/shared/src/sources/uniswap_v2/mod.rs
rename to crates/liquidity-sources/src/uniswap_v2/mod.rs
index 8d6025909d..c371d6a98c 100644
--- a/crates/shared/src/sources/uniswap_v2/mod.rs
+++ b/crates/liquidity-sources/src/uniswap_v2/mod.rs
@@ -9,14 +9,11 @@ use {
         pair_provider::PairProvider,
         pool_fetching::{DefaultPoolReader, PoolFetching, PoolReading},
     },
-    crate::{
-        sources::{BaselineSource, swapr::SwaprPoolReader},
-        web3::Web3,
-    },
+    crate::{BaselineSource, swapr::SwaprPoolReader},
     alloy::primitives::{Address, B256},
     anyhow::{Context, Result},
     contracts::alloy::IUniswapLikeRouter,
-    ethrpc::alloy::ProviderLabelingExt,
+    ethrpc::{Web3, alloy::ProviderLabelingExt},
     hex_literal::hex,
     std::{fmt::Display, str::FromStr, sync::Arc},
 };
diff --git a/crates/shared/src/sources/uniswap_v2/pair_provider.rs b/crates/liquidity-sources/src/uniswap_v2/pair_provider.rs
similarity index 100%
rename from crates/shared/src/sources/uniswap_v2/pair_provider.rs
rename to crates/liquidity-sources/src/uniswap_v2/pair_provider.rs
diff --git a/crates/shared/src/sources/uniswap_v2/pool_cache.rs b/crates/liquidity-sources/src/uniswap_v2/pool_cache.rs
similarity index 95%
rename from crates/shared/src/sources/uniswap_v2/pool_cache.rs
rename to crates/liquidity-sources/src/uniswap_v2/pool_cache.rs
index 7f4257b5bb..5992425331 100644
--- a/crates/shared/src/sources/uniswap_v2/pool_cache.rs
+++ b/crates/liquidity-sources/src/uniswap_v2/pool_cache.rs
@@ -1,7 +1,7 @@
 use {
     crate::{
         recent_block_cache::{Block, CacheConfig, CacheFetching, CacheKey, RecentBlockCache},
-        sources::uniswap_v2::pool_fetching::{Pool, PoolFetching},
+        uniswap_v2::pool_fetching::{Pool, PoolFetching},
     },
     anyhow::Result,
     ethrpc::block_stream::CurrentBlockWatcher,
diff --git a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs b/crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs
similarity index 99%
rename from crates/shared/src/sources/uniswap_v2/pool_fetching.rs
rename to crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs
index 623df6eadf..0720448e8d 100644
--- a/crates/shared/src/sources/uniswap_v2/pool_fetching.rs
+++ b/crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs
@@ -1,6 +1,6 @@
 use {
     super::pair_provider::PairProvider,
-    crate::{baseline_solver::BaselineSolvable, recent_block_cache::Block, web3::Web3},
+    crate::{baseline_solvable::BaselineSolvable, recent_block_cache::Block},
     alloy::{
         eips::BlockId,
         primitives::{Address, U256},
@@ -11,7 +11,7 @@ use {
         ERC20,
         IUniswapLikePair::{self, IUniswapLikePair::getReservesReturn},
     },
-    ethrpc::alloy::errors::ignore_non_node_error,
+    ethrpc::{Web3, alloy::errors::ignore_non_node_error},
     futures::{
         FutureExt as _,
         future::{self, BoxFuture},
diff --git a/crates/shared/src/sources/uniswap_v3/event_fetching.rs b/crates/liquidity-sources/src/uniswap_v3/event_fetching.rs
similarity index 98%
rename from crates/shared/src/sources/uniswap_v3/event_fetching.rs
rename to crates/liquidity-sources/src/uniswap_v3/event_fetching.rs
index f7e4db3461..69827b6fc1 100644
--- a/crates/shared/src/sources/uniswap_v3/event_fetching.rs
+++ b/crates/liquidity-sources/src/uniswap_v3/event_fetching.rs
@@ -1,5 +1,4 @@
 use {
-    crate::event_handling::{AlloyEventRetrieving, EventStoring},
     UniswapV3Pool::UniswapV3Pool::UniswapV3PoolEvents as AlloyUniswapV3PoolEvents,
     alloy::{
         primitives::Address,
@@ -12,7 +11,10 @@ use {
         UniswapV3Pool,
         UniswapV3Pool::UniswapV3Pool::{Burn, Mint, Swap, UniswapV3PoolEvents},
     },
-    ethrpc::block_stream::RangeInclusive,
+    event_indexing::{
+        block_retriever::RangeInclusive,
+        event_handler::{AlloyEventRetrieving, EventStoring},
+    },
     std::collections::BTreeMap,
 };
 
diff --git a/crates/shared/src/sources/uniswap_v3/graph_api.rs b/crates/liquidity-sources/src/uniswap_v3/graph_api.rs
similarity index 99%
rename from crates/shared/src/sources/uniswap_v3/graph_api.rs
rename to crates/liquidity-sources/src/uniswap_v3/graph_api.rs
index ebb79f38c8..5eb93d38ea 100644
--- a/crates/shared/src/sources/uniswap_v3/graph_api.rs
+++ b/crates/liquidity-sources/src/uniswap_v3/graph_api.rs
@@ -3,11 +3,12 @@
 
 use {
     crate::{
-        event_handling::MAX_REORG_BLOCK_COUNT,
+        json_map,
         subgraph::{ContainsId, SubgraphClient},
     },
     alloy::primitives::{Address, U256},
     anyhow::Result,
+    event_indexing::event_handler::MAX_REORG_BLOCK_COUNT,
     num::BigInt,
     number::serialization::HexOrDecimalU256,
     reqwest::{Client, Url},
diff --git a/crates/shared/src/sources/uniswap_v3/mod.rs b/crates/liquidity-sources/src/uniswap_v3/mod.rs
similarity index 100%
rename from crates/shared/src/sources/uniswap_v3/mod.rs
rename to crates/liquidity-sources/src/uniswap_v3/mod.rs
diff --git a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs b/crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs
similarity index 98%
rename from crates/shared/src/sources/uniswap_v3/pool_fetching.rs
rename to crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs
index 5ebc461074..34e24647b5 100644
--- a/crates/shared/src/sources/uniswap_v3/pool_fetching.rs
+++ b/crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs
@@ -3,12 +3,7 @@ use {
         event_fetching::{RecentEventsCache, UniswapV3PoolEventFetcher},
         graph_api::{PoolData, Token, UniV3SubgraphClient},
     },
-    crate::{
-        event_handling::{EventHandler, EventStoring, MAX_REORG_BLOCK_COUNT},
-        maintenance::Maintaining,
-        recent_block_cache::Block,
-        sources::uniswap_v3::event_fetching::WithAddress,
-    },
+    crate::{recent_block_cache::Block, uniswap_v3::event_fetching::WithAddress},
     alloy::{
         primitives::{Address, U256},
         rpc::types::Log,
@@ -18,10 +13,11 @@ use {
         UniswapV3PoolEvents as AlloyUniswapV3PoolEvents,
         UniswapV3PoolEvents,
     },
-    ethrpc::{
-        Web3,
-        alloy::ProviderLabelingExt,
-        block_stream::{BlockRetrieving, RangeInclusive},
+    ethrpc::{Web3, alloy::ProviderLabelingExt},
+    event_indexing::{
+        block_retriever::{BlockRetrieving, RangeInclusive},
+        event_handler::{EventHandler, EventStoring, MAX_REORG_BLOCK_COUNT},
+        maintenance::Maintaining,
     },
     model::TokenPair,
     num::{BigInt, Zero, rational::Ratio},
diff --git a/crates/shared/src/sources/uniswap_v3_pair_provider.rs b/crates/liquidity-sources/src/uniswap_v3_pair_provider.rs
similarity index 100%
rename from crates/shared/src/sources/uniswap_v3_pair_provider.rs
rename to crates/liquidity-sources/src/uniswap_v3_pair_provider.rs
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index d0d9026405..7a47ff6df0 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -16,6 +16,7 @@ name = "orderbook"
 path = "src/main.rs"
 
 [dependencies]
+account-balances = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 app-data = { workspace = true }
@@ -53,6 +54,7 @@ strum = { workspace = true }
 sqlx = { workspace = true }
 thiserror = { workspace = true }
 tempfile = { workspace = true, optional = true }
+token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
 toml = { workspace = true }
 tower = { workspace = true }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 7f7aee98b8..73c099d14e 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -9,6 +9,7 @@ use {
         orderbook::Orderbook,
         quoter::QuoteHandler,
     },
+    account_balances::{self, BalanceSimulator},
     alloy::providers::Provider,
     anyhow::{Context, Result, anyhow},
     app_data::Validator,
@@ -27,10 +28,8 @@ use {
     observe::metrics::{DEFAULT_METRICS_PORT, serve_metrics},
     order_validation,
     shared::{
-        account_balances::{self, BalanceSimulator},
         arguments::tracing_config,
         bad_token::list_based::DenyListedTokens,
-        code_fetching::CachedCodeFetcher,
         gas_price::InstrumentedGasEstimator,
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
@@ -40,11 +39,12 @@ use {
             QuoteVerificationMode,
             factory::{self, PriceEstimatorFactory},
             native::{FallbackNativePriceEstimator, NativePriceEstimating},
+            trade_verifier::code_fetching::CachedCodeFetcher,
         },
         signature_validator,
-        token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     },
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
+    token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     tokio::task::{self, JoinHandle},
 };
 
diff --git a/crates/request-sharing/Cargo.toml b/crates/request-sharing/Cargo.toml
new file mode 100644
index 0000000000..cd6d16c09c
--- /dev/null
+++ b/crates/request-sharing/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "request-sharing"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+futures = { workspace = true }
+observe = { workspace = true }
+prometheus = { workspace = true }
+prometheus-metric-storage = { workspace = true }
+tokio = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/request-sharing/LICENSE-APACHE b/crates/request-sharing/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/request-sharing/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/request-sharing/LICENSE-MIT b/crates/request-sharing/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/request-sharing/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/request_sharing.rs b/crates/request-sharing/src/lib.rs
similarity index 100%
rename from crates/shared/src/request_sharing.rs
rename to crates/request-sharing/src/lib.rs
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index c08c343b6b..4ecac4cf58 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -9,10 +9,12 @@ license = "MIT OR Apache-2.0"
 doctest = false
 
 [dependencies]
+account-balances = { workspace = true }
 alloy = { workspace = true, features = ["sol-types", "signer-local", "rand", "provider-trace-api"] }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 arc-swap = { workspace = true }
+balance-overrides = { workspace = true }
 bytes-hex = { workspace = true }
 async-trait = { workspace = true }
 bigdecimal = { workspace = true }
@@ -25,6 +27,7 @@ dashmap = { workspace = true }
 database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
+event-indexing = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
 const-hex = { workspace = true }
@@ -40,6 +43,7 @@ prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
 rate-limit = { workspace = true }
+request-sharing = { workspace = true }
 reqwest = { workspace = true, features = ["cookies", "gzip", "json", "query"] }
 rust_decimal = { workspace = true, features = ["maths"] }
 serde = { workspace = true }
@@ -47,15 +51,17 @@ serde_json = { workspace = true }
 serde_with = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
+token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "time", "signal"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 url = { workspace = true }
-
 moka = { workspace = true, features = ["sync"] }
 mockall = { workspace = true, optional = true }
+liquidity-sources = { workspace = true }
 
 [dev-dependencies]
+account-balances = { workspace = true, features = ["test-util"] }
 alloy = { workspace = true, features = ["rand"] }
 app-data = { workspace = true, features = ["test_helpers"] }
 async-stream = { workspace = true }
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 63781d8b7f..36416ba219 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -2,7 +2,11 @@
 //! the binaries.
 
 use {
-    crate::{fee_factor::FeeFactor, gas_price_estimation::GasEstimatorType, tenderly_api},
+    crate::{
+        fee_factor::FeeFactor,
+        gas_price_estimation::GasEstimatorType,
+        price_estimation::trade_verifier::tenderly_api,
+    },
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
     observe::TracingConfig,
diff --git a/crates/shared/src/bad_token/trace_call.rs b/crates/shared/src/bad_token/trace_call.rs
index 67c6633a1f..0ef7a7c5c6 100644
--- a/crates/shared/src/bad_token/trace_call.rs
+++ b/crates/shared/src/bad_token/trace_call.rs
@@ -1,13 +1,13 @@
 use {
     super::TokenQuality,
-    crate::{trace_many, web3::Web3},
     alloy::{
         primitives::{Address, U256, keccak256},
+        providers::ext::TraceApi,
         rpc::{
             json_rpc::ErrorPayload,
             types::{
                 TransactionRequest,
-                trace::parity::{TraceOutput, TraceResults},
+                trace::parity::{TraceOutput, TraceResults, TraceType},
             },
         },
         signers::local::PrivateKeySigner,
@@ -16,6 +16,7 @@ use {
     },
     anyhow::{Context, Result, bail, ensure},
     contracts::alloy::ERC20,
+    ethrpc::Web3,
     model::interaction::InteractionData,
 };
 
@@ -59,7 +60,7 @@ impl TraceCallDetectorRaw {
         // implementation sending to an address that does not have any balance
         // yet (implicitly 0) causes an allocation.
         request.append(&mut self.create_trace_request(token, amount, take_from));
-        let traces = match trace_many::trace_many(&self.web3, request).await {
+        let traces = match trace_many(&self.web3, request).await {
             Ok(result) => result,
             Err(RpcError::UnsupportedFeature(err)) => {
                 tracing::warn!(error = ?err, "node does not support trace_callMany");
@@ -329,6 +330,22 @@ fn u256_from_be_bytes_strict(b: &[u8]) -> Option<U256> {
     U256::try_from_be_slice(b)
 }
 
+/// Use the trace_callMany API (<https://openethereum.github.io/JSONRPC-trace-module#trace_callmany>)
+/// to simulate these call requests applied together one after another.
+///
+/// Returns `Err` if communication with the node failed.
+async fn trace_many(
+    web3: &Web3,
+    requests: Vec<TransactionRequest>,
+) -> Result<Vec<TraceResults>, RpcError<TransportErrorKind>> {
+    let r: Vec<_> = requests
+        .into_iter()
+        .zip(std::iter::repeat([TraceType::Trace].as_slice()))
+        .collect();
+
+    web3.provider.trace_call_many(r.as_slice()).latest().await
+}
+
 #[cfg(test)]
 mod tests {
     use {
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index ce416c2951..4e06f02f94 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -1,17 +1,11 @@
-use {alloy::primitives::Address, std::sync::LazyLock};
-
 #[macro_use]
 pub mod macros;
 
-pub mod account_balances;
 pub mod arguments;
 pub mod bad_token;
-pub mod baseline_solver;
-pub mod code_fetching;
 pub mod current_block;
 pub mod db_order_conversions;
 pub mod encoded_settlement;
-pub mod event_handling;
 pub mod event_storing_helpers;
 pub mod external_prices;
 pub mod fee;
@@ -21,20 +15,12 @@ pub mod gas_price_estimation;
 pub mod http_client;
 pub mod http_solver;
 pub mod interaction;
-pub mod maintenance;
 pub mod order_quoting;
 pub mod order_validation;
 pub mod price_estimation;
-pub mod recent_block_cache;
 pub mod remaining_amounts;
-pub mod request_sharing;
 pub mod signature_validator;
-pub mod sources;
-pub mod subgraph;
-pub mod tenderly_api;
-pub mod token_info;
 pub mod token_list;
-pub mod trace_many;
 pub mod trade_finding;
 pub mod url;
 pub mod web3;
@@ -46,7 +32,3 @@ pub mod zeroex_api;
 pub fn clone_anyhow_error(err: &anyhow::Error) -> anyhow::Error {
     anyhow::anyhow!("{:#}", err)
 }
-
-// ZKSync-based chains don't use the default 0x0 account when `tx.from` is not
-// specified, so we need to use a random account when sending a simulation tx.
-pub static SIMULATION_ACCOUNT: LazyLock<Address> = LazyLock::new(|| Address::random());
diff --git a/crates/shared/src/macros.rs b/crates/shared/src/macros.rs
index 171e07c91a..5465d2747d 100644
--- a/crates/shared/src/macros.rs
+++ b/crates/shared/src/macros.rs
@@ -1,24 +1,3 @@
-#[macro_export]
-macro_rules! bfp {
-    ($val:literal) => {
-        ($val)
-            .parse::<$crate::sources::balancer_v2::swap::fixed_point::Bfp>()
-            .unwrap()
-    };
-}
-
-#[macro_export]
-macro_rules! json_map {
-    ($($key:expr_2021 => $value:expr_2021),* $(,)?) => {{
-        #[allow(unused_mut)]
-        let mut map = ::serde_json::Map::<String, ::serde_json::Value>::new();
-        $(
-            map.insert(($key).into(), ($value).into());
-        )*
-        map
-    }}
-}
-
 #[macro_export]
 macro_rules! externalprices {
     (native_token: $nt:expr_2021 $(, $($t:tt)*)?) => {
diff --git a/crates/shared/src/order_quoting.rs b/crates/shared/src/order_quoting.rs
index dd47e3f9d0..94bfa05629 100644
--- a/crates/shared/src/order_quoting.rs
+++ b/crates/shared/src/order_quoting.rs
@@ -6,7 +6,6 @@ use {
         native::NativePriceEstimating,
     },
     crate::{
-        account_balances::{BalanceFetching, Query},
         db_order_conversions::order_kind_from,
         fee::FeeParameters,
         gas_price_estimation::GasPriceEstimating,
@@ -14,6 +13,7 @@ use {
         price_estimation::{Estimate, QuoteVerificationMode, Verification},
         trade_finding::external::dto,
     },
+    account_balances::{BalanceFetching, Query},
     alloy::primitives::{Address, U256, U512, ruint::UintTryFrom},
     anyhow::{Context, Result},
     chrono::{DateTime, Duration, Utc},
@@ -785,7 +785,6 @@ mod tests {
     use {
         super::*,
         crate::{
-            account_balances::MockBalanceFetching,
             gas_price_estimation::FakeGasPriceEstimator,
             price_estimation::{
                 HEALTHY_PRICE_ESTIMATION_TIME,
@@ -795,6 +794,7 @@ mod tests {
         },
         Address,
         U256 as AlloyU256,
+        account_balances::MockBalanceFetching,
         alloy::eips::eip1559::Eip1559Estimation,
         chrono::Utc,
         futures::FutureExt,
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 39b5018077..9520aa89d5 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -1,8 +1,6 @@
 use {
     crate::{
-        account_balances::{self, BalanceFetching, TransferSimulationError},
         bad_token::list_based::DenyListedTokens,
-        code_fetching::CodeFetching,
         order_quoting::{
             CalculateQuoteError,
             OrderQuoting,
@@ -13,15 +11,17 @@ use {
         price_estimation::{
             PriceEstimationError,
             Verification,
-            trade_verifier::balance_overrides::BalanceOverrideRequest,
+            trade_verifier::code_fetching::CodeFetching,
         },
         signature_validator::{SignatureCheck, SignatureValidating, SignatureValidationError},
         trade_finding,
     },
+    account_balances::{self, BalanceFetching, TransferSimulationError},
     alloy::primitives::{Address, B256, U256},
     anyhow::{Result, anyhow},
     app_data::{AppDataHash, Hook, Hooks, ValidatedAppData, Validator},
     async_trait::async_trait,
+    balance_overrides::BalanceOverrideRequest,
     contracts::alloy::{HooksTrampoline, WETH9},
     model::{
         DomainSeparator,
@@ -1037,11 +1037,11 @@ mod tests {
     use {
         super::*,
         crate::{
-            account_balances::MockBalanceFetching,
-            code_fetching::MockCodeFetching,
             order_quoting::{FindQuoteError, MockOrderQuoting},
+            price_estimation::trade_verifier::code_fetching::MockCodeFetching,
             signature_validator::MockSignatureValidating,
         },
+        account_balances::MockBalanceFetching,
         alloy::{
             primitives::{Address, U160, address, b256},
             providers::{Provider, ProviderBuilder, mock::Asserter},
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/shared/src/price_estimation/factory.rs
index 8c805e11ab..bf4922d7bf 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/shared/src/price_estimation/factory.rs
@@ -14,26 +14,27 @@ use {
     crate::{
         arguments,
         bad_token::list_based::DenyListedTokens,
-        code_fetching::CachedCodeFetcher,
         gas_price_estimation::GasPriceEstimating,
         http_client::HttpClientFactory,
         price_estimation::{
             ExternalSolver,
             buffered::{self, BufferedRequest, NativePriceBatchFetching},
             competition::PriceRanking,
+            trade_verifier::{
+                code_fetching::CachedCodeFetcher,
+                tenderly_api::TenderlyCodeSimulator,
+            },
         },
-        tenderly_api::TenderlyCodeSimulator,
-        token_info::TokenInfoFetching,
-        web3::Web3,
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
     contracts::alloy::WETH9,
-    ethrpc::{alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
+    ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     number::nonzero::NonZeroU256,
     rate_limit::RateLimiter,
     reqwest::Url,
     std::{collections::HashMap, num::NonZeroUsize, sync::Arc},
+    token_info::TokenInfoFetching,
 };
 
 /// A factory for initializing shared price estimators.
diff --git a/crates/shared/src/price_estimation/mod.rs b/crates/shared/src/price_estimation/mod.rs
index 9e83a0050e..63cc5743aa 100644
--- a/crates/shared/src/price_estimation/mod.rs
+++ b/crates/shared/src/price_estimation/mod.rs
@@ -1,11 +1,11 @@
 use {
-    self::trade_verifier::balance_overrides,
     crate::{
         arguments::{self, display_option, display_secret_option},
         trade_finding::{Interaction, QuoteExecution},
     },
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result, ensure},
+    balance_overrides,
     bigdecimal::BigDecimal,
     futures::future::BoxFuture,
     itertools::Itertools,
diff --git a/crates/shared/src/price_estimation/native/coingecko.rs b/crates/shared/src/price_estimation/native/coingecko.rs
index 24672f0465..2234f5cecd 100644
--- a/crates/shared/src/price_estimation/native/coingecko.rs
+++ b/crates/shared/src/price_estimation/native/coingecko.rs
@@ -1,9 +1,6 @@
 use {
     super::{NativePriceEstimateResult, NativePriceEstimating},
-    crate::{
-        price_estimation::{PriceEstimationError, buffered::NativePriceBatchFetching},
-        token_info::{TokenInfo, TokenInfoFetching},
-    },
+    crate::price_estimation::{PriceEstimationError, buffered::NativePriceBatchFetching},
     alloy::primitives::Address,
     anyhow::{Context, Result, anyhow},
     chain::Chain,
@@ -16,6 +13,7 @@ use {
         sync::Arc,
         time::Duration,
     },
+    token_info::{TokenInfo, TokenInfoFetching},
     tracing::instrument,
     url::Url,
 };
@@ -319,12 +317,10 @@ mod metrics {
 mod tests {
     use {
         super::*,
-        crate::{
-            price_estimation::HEALTHY_PRICE_ESTIMATION_TIME,
-            token_info::{MockTokenInfoFetching, TokenInfo},
-        },
+        crate::price_estimation::HEALTHY_PRICE_ESTIMATION_TIME,
         alloy::primitives::address,
         std::env,
+        token_info::{MockTokenInfoFetching, TokenInfo},
     };
 
     impl CoinGecko {
diff --git a/crates/shared/src/price_estimation/native/oneinch.rs b/crates/shared/src/price_estimation/native/oneinch.rs
index 19826ca29b..d6776ea45c 100644
--- a/crates/shared/src/price_estimation/native/oneinch.rs
+++ b/crates/shared/src/price_estimation/native/oneinch.rs
@@ -1,6 +1,6 @@
 use {
     super::{NativePrice, NativePriceEstimateResult, NativePriceEstimating},
-    crate::{price_estimation::PriceEstimationError, token_info::TokenInfoFetching},
+    crate::price_estimation::PriceEstimationError,
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result, anyhow},
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
@@ -15,6 +15,7 @@ use {
         sync::{Arc, Mutex},
         time::Duration,
     },
+    token_info::TokenInfoFetching,
     tracing::instrument,
     url::Url,
 };
@@ -161,12 +162,10 @@ async fn get_current_prices(
 mod tests {
     use {
         super::*,
-        crate::{
-            price_estimation::HEALTHY_PRICE_ESTIMATION_TIME,
-            token_info::{MockTokenInfoFetching, TokenInfo},
-        },
+        crate::price_estimation::HEALTHY_PRICE_ESTIMATION_TIME,
         alloy::primitives::address,
         std::env,
+        token_info::{MockTokenInfoFetching, TokenInfo},
     };
 
     const BASE_URL: &str = "https://api.1inch.dev/";
diff --git a/crates/shared/src/code_fetching.rs b/crates/shared/src/price_estimation/trade_verifier/code_fetching.rs
similarity index 100%
rename from crates/shared/src/code_fetching.rs
rename to crates/shared/src/price_estimation/trade_verifier/code_fetching.rs
diff --git a/crates/shared/src/price_estimation/trade_verifier/mod.rs b/crates/shared/src/price_estimation/trade_verifier/mod.rs
index 85b42835f7..bdc138622b 100644
--- a/crates/shared/src/price_estimation/trade_verifier/mod.rs
+++ b/crates/shared/src/price_estimation/trade_verifier/mod.rs
@@ -1,13 +1,12 @@
-pub mod balance_overrides;
-
 use {
-    self::balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     super::{Estimate, Verification},
     crate::{
-        code_fetching::CodeFetching,
         encoded_settlement::{EncodedSettlement, EncodedTrade, encode_trade},
         interaction::EncodedInteraction,
-        tenderly_api::TenderlyCodeSimulator,
+        price_estimation::trade_verifier::{
+            code_fetching::CodeFetching,
+            tenderly_api::TenderlyCodeSimulator,
+        },
         trade_finding::{
             Interaction,
             QuoteExecution,
@@ -22,6 +21,7 @@ use {
         rpc::types::{eth::state::StateOverride, state::AccountOverride},
     },
     anyhow::{Context, Result, anyhow},
+    balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     bigdecimal::BigDecimal,
     contracts::alloy::{
         GPv2Settlement,
@@ -52,6 +52,9 @@ use {
     tracing::instrument,
 };
 
+pub mod code_fetching;
+pub mod tenderly_api;
+
 #[async_trait::async_trait]
 pub trait TradeVerifying: Send + Sync + 'static {
     /// Verifies if the proposed [`TradeKind`] actually fulfills the
diff --git a/crates/shared/src/tenderly_api.rs b/crates/shared/src/price_estimation/trade_verifier/tenderly_api.rs
similarity index 97%
rename from crates/shared/src/tenderly_api.rs
rename to crates/shared/src/price_estimation/trade_verifier/tenderly_api.rs
index c32c5988c1..23c2cd841c 100644
--- a/crates/shared/src/tenderly_api.rs
+++ b/crates/shared/src/price_estimation/trade_verifier/tenderly_api.rs
@@ -23,7 +23,6 @@ use {
         fmt::{self, Display, Formatter},
         sync::Arc,
     },
-    thiserror::Error,
     tracing::instrument,
 };
 /// Trait for abstracting Tenderly API.
@@ -328,23 +327,6 @@ impl Metrics {
     }
 }
 
-#[derive(Debug, Error)]
-pub enum SimulationError {
-    #[error("simulation reverted {0:?}")]
-    Revert(Option<String>),
-    #[error(transparent)]
-    Other(#[from] anyhow::Error),
-}
-
-impl Clone for SimulationError {
-    fn clone(&self) -> Self {
-        match self {
-            Self::Revert(message) => Self::Revert(message.clone()),
-            Self::Other(err) => Self::Other(crate::clone_anyhow_error(err)),
-        }
-    }
-}
-
 pub struct TenderlyCodeSimulator {
     tenderly: Arc<dyn TenderlyApi>,
     network_id: String,
diff --git a/crates/shared/src/signature_validator/mod.rs b/crates/shared/src/signature_validator/mod.rs
index 39f48e01ef..b1f5a5c0f1 100644
--- a/crates/shared/src/signature_validator/mod.rs
+++ b/crates/shared/src/signature_validator/mod.rs
@@ -1,9 +1,6 @@
 use {
-    crate::price_estimation::trade_verifier::balance_overrides::{
-        BalanceOverrideRequest,
-        BalanceOverriding,
-    },
     alloy::primitives::{Address, FixedBytes},
+    balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     contracts::alloy::GPv2Settlement,
     ethrpc::Web3,
     hex_literal::hex,
diff --git a/crates/shared/src/signature_validator/simulation.rs b/crates/shared/src/signature_validator/simulation.rs
index b284464a52..20613dccb6 100644
--- a/crates/shared/src/signature_validator/simulation.rs
+++ b/crates/shared/src/signature_validator/simulation.rs
@@ -5,7 +5,6 @@
 
 use {
     super::{SignatureCheck, SignatureValidating, SignatureValidationError},
-    crate::price_estimation::trade_verifier::balance_overrides::BalanceOverriding,
     alloy::{
         dyn_abi::SolType,
         primitives::{Address, U256},
@@ -14,13 +13,14 @@ use {
         transports::RpcError,
     },
     anyhow::{Context, Result},
+    balance_overrides::BalanceOverriding,
     contracts::alloy::{
         ERC1271SignatureValidator::ERC1271SignatureValidator,
         GPv2Settlement,
         support::Signatures,
     },
     ethrpc::{Web3, alloy::ProviderLabelingExt},
-    std::sync::Arc,
+    std::sync::{Arc, LazyLock},
     tracing::instrument,
 };
 
@@ -127,11 +127,15 @@ impl Validator {
                 })
                 .collect(),
         };
+
+        // ZKSync-based chains don't use the default 0x0 account when `tx.from` is not
+        // specified, so we need to use a random account when sending a simulation tx.
+        static SIMULATION_ACCOUNT: LazyLock<Address> = LazyLock::new(|| Address::random());
         let simulation = self
             .settlement
             .simulateDelegatecall(self.signatures_address, validate_call.abi_encode().into())
             .state(overrides.clone())
-            .from(*crate::SIMULATION_ACCOUNT);
+            .from(*SIMULATION_ACCOUNT);
 
         let result = simulation.clone().call().await;
 
diff --git a/crates/shared/src/trace_many.rs b/crates/shared/src/trace_many.rs
deleted file mode 100644
index 96c9ddc473..0000000000
--- a/crates/shared/src/trace_many.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use {
-    crate::web3::Web3,
-    alloy::{
-        providers::ext::TraceApi,
-        rpc::types::{
-            TransactionRequest,
-            trace::parity::{TraceResults, TraceType},
-        },
-        transports::{RpcError, TransportErrorKind},
-    },
-    anyhow::{Context, Result},
-};
-
-/// Use the trace_callMany API (<https://openethereum.github.io/JSONRPC-trace-module#trace_callmany>)
-/// to simulate these call requests applied together one after another.
-///
-/// Returns `Err` if communication with the node failed.
-pub async fn trace_many(
-    web3: &Web3,
-    requests: Vec<TransactionRequest>,
-) -> Result<Vec<TraceResults>, RpcError<TransportErrorKind>> {
-    let r: Vec<_> = requests
-        .into_iter()
-        .zip(std::iter::repeat([TraceType::Trace].as_slice()))
-        .collect();
-
-    web3.provider.trace_call_many(r.as_slice()).latest().await
-}
-
-/// Check the return value of `trace_many` for whether all top level
-/// transactions succeeded (did not revert).
-///
-/// * `Err` if the response is missing trace data.
-/// * `Ok(true)` if transactions simulate without reverting
-/// * `Ok(false)` if transactions simulate with at least one revert.
-pub fn all_calls_succeeded(traces: &[TraceResults]) -> Result<bool> {
-    for trace in traces {
-        let first = trace.trace.first().context("expected at least one trace")?;
-        if first.error.is_some() {
-            return Ok(false);
-        }
-    }
-    Ok(true)
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, serde_json::json};
-
-    #[test]
-    fn ok_true() {
-        let response: Vec<TraceResults> = serde_json::from_value(json!(
-        [{
-            "output": "0x",
-            "trace": [{
-              "traceAddress": [],
-              "subtraces": 0,
-              "action": {
-                "callType": "call",
-                "from": "0x0000000000000000000000000000000000000000",
-                "gas": "0x00",
-                "input": "0x",
-                "to": "0x0000000000000000000000000000000000000000",
-                "value": "0x00"
-              },
-              "type": "call"
-            }],
-          }]))
-        .unwrap();
-        let result = all_calls_succeeded(&response);
-        assert!(result.unwrap());
-    }
-
-    #[test]
-    fn ok_false() {
-        let response: Vec<TraceResults> = serde_json::from_value(json!(
-        [{
-            "output": "0x",
-            "trace": [{
-              "traceAddress": [],
-              "subtraces": 0,
-              "action": {
-                "callType": "call",
-                "from": "0x0000000000000000000000000000000000000000",
-                "gas": "0x00",
-                "input": "0x",
-                "to": "0x0000000000000000000000000000000000000000",
-                "value": "0x00"
-              },
-              "type": "call",
-              "error": "Reverted"
-            }],
-          }]))
-        .unwrap();
-
-        let result = all_calls_succeeded(&response);
-        assert!(!result.unwrap());
-    }
-}
diff --git a/crates/shared/src/trade_finding/external.rs b/crates/shared/src/trade_finding/external.rs
index 86e04bb4a3..83ff09086e 100644
--- a/crates/shared/src/trade_finding/external.rs
+++ b/crates/shared/src/trade_finding/external.rs
@@ -3,7 +3,6 @@
 use {
     crate::{
         price_estimation::{PriceEstimationError, Query},
-        request_sharing::{BoxRequestSharing, RequestSharing},
         trade_finding::{
             Interaction,
             LegacyTrade,
@@ -20,6 +19,7 @@ use {
     ethrpc::block_stream::CurrentBlockWatcher,
     futures::FutureExt,
     observe::tracing::distributed::headers::tracing_headers,
+    request_sharing::{BoxRequestSharing, RequestSharing},
     reqwest::{Client, header},
     tracing::instrument,
     url::Url,
diff --git a/crates/solver/Cargo.toml b/crates/solver/Cargo.toml
index 38c48ae415..615292c87a 100644
--- a/crates/solver/Cargo.toml
+++ b/crates/solver/Cargo.toml
@@ -19,6 +19,7 @@ contracts = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
+liquidity-sources = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 itertools = { workspace = true }
@@ -40,6 +41,7 @@ testlib = { workspace = true }
 mockall = { workspace = true }
 shared = { workspace = true, features = ["test-util"] }
 ethrpc = {workspace = true, features = ["test-util"]}
+liquidity-sources = { workspace = true, features = [ "test-util" ] }
 
 [lints]
 workspace = true
diff --git a/crates/solver/src/liquidity/balancer_v2.rs b/crates/solver/src/liquidity/balancer_v2.rs
index 13344f87be..a01c1de4c8 100644
--- a/crates/solver/src/liquidity/balancer_v2.rs
+++ b/crates/solver/src/liquidity/balancer_v2.rs
@@ -15,12 +15,12 @@ use {
     },
     alloy::primitives::{Address, B256},
     anyhow::Result,
-    model::TokenPair,
-    shared::{
-        http_solver::model::TokenAmount,
+    liquidity_sources::{
+        balancer_v2::pool_fetching::BalancerPoolFetching,
         recent_block_cache::Block,
-        sources::balancer_v2::pool_fetching::BalancerPoolFetching,
     },
+    model::TokenPair,
+    shared::http_solver::model::TokenAmount,
     std::{collections::HashSet, sync::Arc},
     tracing::instrument,
 };
@@ -196,14 +196,8 @@ mod tests {
         super::*,
         alloy::primitives::U256,
         contracts::alloy::BalancerV2Vault,
-        maplit::{btreemap, hashset},
-        mockall::predicate::*,
-        model::TokenPair,
-        shared::{
-            baseline_solver::BaseTokens,
-            http_solver::model::{InternalizationStrategy, TokenAmount},
-            interaction::Interaction,
-            sources::balancer_v2::{
+        liquidity_sources::{
+            balancer_v2::{
                 pool_fetching::{
                     AmplificationParameter,
                     CommonPoolState,
@@ -217,6 +211,14 @@ mod tests {
                 },
                 swap::fixed_point::Bfp,
             },
+            base_tokens::BaseTokens,
+        },
+        maplit::{btreemap, hashset},
+        mockall::predicate::*,
+        model::TokenPair,
+        shared::{
+            http_solver::model::{InternalizationStrategy, TokenAmount},
+            interaction::Interaction,
         },
     };
 
diff --git a/crates/solver/src/liquidity/mod.rs b/crates/solver/src/liquidity/mod.rs
index b4dcc4cc96..140cce6df3 100644
--- a/crates/solver/src/liquidity/mod.rs
+++ b/crates/solver/src/liquidity/mod.rs
@@ -8,27 +8,25 @@ use {
     crate::settlement::SettlementEncoder,
     alloy::primitives::{Address, U256},
     anyhow::Result,
+    liquidity_sources::{
+        balancer_v2::{
+            pool_fetching::{
+                AmplificationParameter,
+                TokenState,
+                WeightedPoolVersion,
+                WeightedTokenState,
+            },
+            swap::fixed_point::Bfp,
+        },
+        uniswap_v2::pool_fetching::Pool,
+        uniswap_v3::pool_fetching::PoolInfo,
+    },
     model::{
         TokenPair,
         order::{Order, OrderKind, OrderUid},
     },
     num::rational::Ratio,
-    shared::{
-        http_solver::model::TokenAmount,
-        sources::{
-            balancer_v2::{
-                pool_fetching::{
-                    AmplificationParameter,
-                    TokenState,
-                    WeightedPoolVersion,
-                    WeightedTokenState,
-                },
-                swap::fixed_point::Bfp,
-            },
-            uniswap_v2::pool_fetching::Pool,
-            uniswap_v3::pool_fetching::PoolInfo,
-        },
-    },
+    shared::http_solver::model::TokenAmount,
     std::{collections::BTreeMap, sync::Arc},
     strum::IntoStaticStr,
 };
diff --git a/crates/solver/src/liquidity/uniswap_v2.rs b/crates/solver/src/liquidity/uniswap_v2.rs
index 6a79ff3d75..88ba3fa375 100644
--- a/crates/solver/src/liquidity/uniswap_v2.rs
+++ b/crates/solver/src/liquidity/uniswap_v2.rs
@@ -8,12 +8,9 @@ use {
     },
     alloy::primitives::Address,
     anyhow::Result,
+    liquidity_sources::{recent_block_cache::Block, uniswap_v2::pool_fetching::PoolFetching},
     model::TokenPair,
-    shared::{
-        http_solver::model::TokenAmount,
-        recent_block_cache::Block,
-        sources::uniswap_v2::pool_fetching::PoolFetching,
-    },
+    shared::http_solver::model::TokenAmount,
     std::{collections::HashSet, sync::Arc},
     tracing::instrument,
 };
diff --git a/crates/solver/src/liquidity/uniswap_v3.rs b/crates/solver/src/liquidity/uniswap_v3.rs
index 179a240e0c..b13216252d 100644
--- a/crates/solver/src/liquidity/uniswap_v3.rs
+++ b/crates/solver/src/liquidity/uniswap_v3.rs
@@ -9,13 +9,10 @@ use {
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
     contracts::alloy::UniswapV3SwapRouterV2::IV3SwapRouter::ExactOutputSingleParams,
+    liquidity_sources::{recent_block_cache::Block, uniswap_v3::pool_fetching::PoolFetching},
     model::TokenPair,
     num::{CheckedMul, rational::Ratio},
-    shared::{
-        http_solver::model::TokenAmount,
-        recent_block_cache::Block,
-        sources::uniswap_v3::pool_fetching::PoolFetching,
-    },
+    shared::http_solver::model::TokenAmount,
     std::{collections::HashSet, sync::Arc},
     tracing::instrument,
 };
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index 542aa152e9..4f08ea2096 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -13,11 +13,9 @@ use {
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
     futures::StreamExt,
     itertools::Itertools,
+    liquidity_sources::recent_block_cache::Block,
     model::{TokenPair, order::OrderKind},
-    shared::{
-        recent_block_cache::Block,
-        zeroex_api::{OrderRecord, OrdersQuery, ZeroExApi},
-    },
+    shared::zeroex_api::{OrderRecord, OrdersQuery, ZeroExApi},
     std::{
         collections::{HashMap, HashSet},
         sync::Arc,
@@ -217,8 +215,8 @@ impl SettlementHandling<LimitOrder> for OrderSettlementHandler {
 pub mod tests {
     use {
         super::*,
+        liquidity_sources::base_tokens::BaseTokens,
         shared::{
-            baseline_solver::BaseTokens,
             http_solver::model::InternalizationStrategy,
             interaction::Interaction,
             zeroex_api::{self, OrderMetadata},
diff --git a/crates/solver/src/liquidity_collector.rs b/crates/solver/src/liquidity_collector.rs
index 8dc5fc1c53..1be0b58f69 100644
--- a/crates/solver/src/liquidity_collector.rs
+++ b/crates/solver/src/liquidity_collector.rs
@@ -1,8 +1,8 @@
 use {
     crate::liquidity::Liquidity,
     anyhow::Result,
+    liquidity_sources::{base_tokens::BaseTokens, recent_block_cache::Block},
     model::TokenPair,
-    shared::{baseline_solver::BaseTokens, recent_block_cache::Block},
     std::{collections::HashSet, future::Future, sync::Arc, time::Duration},
     tokio::sync::RwLock,
     tracing::{Instrument, instrument},
@@ -146,7 +146,7 @@ mod test {
     use {
         super::*,
         futures::FutureExt,
-        shared::recent_block_cache::Block,
+        liquidity_sources::recent_block_cache::Block,
         std::sync::atomic::{AtomicUsize, Ordering},
     };
 
diff --git a/crates/solver/src/solver.rs b/crates/solver/src/solver.rs
index aaa642c1f7..6c7091efdc 100644
--- a/crates/solver/src/solver.rs
+++ b/crates/solver/src/solver.rs
@@ -2,9 +2,10 @@ use {
     crate::liquidity::{ConstantProductOrder, WeightedProductOrder},
     alloy::primitives::{Address, U256},
     anyhow::anyhow,
-    shared::{
-        baseline_solver::BaselineSolvable,
-        sources::{balancer_v2::swap::WeightedPoolRef, uniswap_v2::pool_fetching::Pool},
+    liquidity_sources::{
+        balancer_v2::swap::WeightedPoolRef,
+        baseline_solvable::BaselineSolvable,
+        uniswap_v2::pool_fetching::Pool,
     },
     std::{fmt::Debug, str::FromStr},
 };
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index fba01b7051..98b2987b0c 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -24,6 +24,7 @@ derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 itertools = { workspace = true }
+liquidity-sources = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 num = { workspace = true }
 number = { workspace = true }
@@ -53,6 +54,7 @@ tracing = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
+maplit = { workspace = true }
 
 [build-dependencies]
 anyhow = { workspace = true }
diff --git a/crates/solvers/src/boundary/baseline.rs b/crates/solvers/src/boundary/baseline.rs
index 69b4282a30..12b113885b 100644
--- a/crates/solvers/src/boundary/baseline.rs
+++ b/crates/solvers/src/boundary/baseline.rs
@@ -2,13 +2,16 @@
 
 use {
     crate::{
-        boundary,
+        boundary::{
+            self,
+            routing::{estimate_buy_amount, estimate_sell_amount},
+        },
         domain::{eth, liquidity, order, solver},
     },
     alloy::primitives::{Address, U256},
     contracts::alloy::UniswapV3QuoterV2,
+    liquidity_sources::{base_tokens::BaseTokens, baseline_solvable::BaselineSolvable},
     model::TokenPair,
-    shared::baseline_solver::{self, BaseTokens, BaselineSolvable},
     std::{
         collections::{HashMap, HashSet},
         sync::Arc,
@@ -52,12 +55,9 @@ impl<'a> Solver<'a> {
         let (segments, _) = match request.side {
             order::Side::Buy => {
                 let futures = candidates.iter().map(|path| async {
-                    let sell = baseline_solver::estimate_sell_amount(
-                        request.buy.amount,
-                        path,
-                        &self.onchain_liquidity,
-                    )
-                    .await?;
+                    let sell =
+                        estimate_sell_amount(request.buy.amount, path, &self.onchain_liquidity)
+                            .await?;
 
                     let segments = self
                         .traverse_path(&sell.path, request.sell.token.0, sell.value)
@@ -83,12 +83,9 @@ impl<'a> Solver<'a> {
             }
             order::Side::Sell => {
                 let futures = candidates.iter().map(|path| async {
-                    let buy = baseline_solver::estimate_buy_amount(
-                        request.sell.amount,
-                        path,
-                        &self.onchain_liquidity,
-                    )
-                    .await?;
+                    let buy =
+                        estimate_buy_amount(request.sell.amount, path, &self.onchain_liquidity)
+                            .await?;
 
                     let segments = self
                         .traverse_path(&buy.path, request.sell.token.0, request.sell.amount)
diff --git a/crates/solvers/src/boundary/liquidity/concentrated.rs b/crates/solvers/src/boundary/liquidity/concentrated.rs
index c20777c044..cfff21a7c9 100644
--- a/crates/solvers/src/boundary/liquidity/concentrated.rs
+++ b/crates/solvers/src/boundary/liquidity/concentrated.rs
@@ -4,8 +4,8 @@ use {
         QuoteExactInputSingleParams,
         QuoteExactOutputSingleParams,
     },
+    liquidity_sources::baseline_solvable::BaselineSolvable,
     model::TokenPair,
-    shared::baseline_solver::BaselineSolvable,
     std::sync::Arc,
 };
 
diff --git a/crates/solvers/src/boundary/liquidity/constant_product.rs b/crates/solvers/src/boundary/liquidity/constant_product.rs
index dd68f4ef49..4d4dbecf6b 100644
--- a/crates/solvers/src/boundary/liquidity/constant_product.rs
+++ b/crates/solvers/src/boundary/liquidity/constant_product.rs
@@ -1,4 +1,4 @@
-pub use shared::sources::uniswap_v2::pool_fetching::Pool;
+pub use liquidity_sources::uniswap_v2::pool_fetching::Pool;
 use {crate::domain::liquidity, alloy::primitives::Address, model::TokenPair};
 
 /// Converts a domain pool into a [`shared`] Uniswap V2 pool. Returns `None` if
diff --git a/crates/solvers/src/boundary/liquidity/limit_order.rs b/crates/solvers/src/boundary/liquidity/limit_order.rs
index 6ccf01bd2f..708261dd2b 100644
--- a/crates/solvers/src/boundary/liquidity/limit_order.rs
+++ b/crates/solvers/src/boundary/liquidity/limit_order.rs
@@ -1,7 +1,8 @@
 use {
     crate::domain::liquidity::limit_order::LimitOrder,
     alloy::primitives::{Address, U256},
-    shared::{baseline_solver::BaselineSolvable, price_estimation::gas::GAS_PER_ZEROEX_ORDER},
+    liquidity_sources::baseline_solvable::BaselineSolvable,
+    shared::price_estimation::gas::GAS_PER_ZEROEX_ORDER,
 };
 
 // Follows 0x's contract implementation: <https://github.com/0xProject/protocol/blob/%400x/contracts-utils%404.8.52/contracts/utils/contracts/src/v06/LibMathV06.sol#L71-L83>
diff --git a/crates/solvers/src/boundary/liquidity/stable.rs b/crates/solvers/src/boundary/liquidity/stable.rs
index 2376605f97..db404fea1b 100644
--- a/crates/solvers/src/boundary/liquidity/stable.rs
+++ b/crates/solvers/src/boundary/liquidity/stable.rs
@@ -1,8 +1,8 @@
-pub use shared::sources::balancer_v2::pool_fetching::StablePool as Pool;
+pub use liquidity_sources::balancer_v2::pool_fetching::StablePool as Pool;
 use {
     crate::domain::{eth, liquidity},
     alloy::primitives::{Address, B256, U256},
-    shared::sources::balancer_v2::{
+    liquidity_sources::balancer_v2::{
         pool_fetching::{AmplificationParameter, CommonPoolState, TokenState},
         swap::fixed_point::Bfp,
     },
diff --git a/crates/solvers/src/boundary/liquidity/weighted_product.rs b/crates/solvers/src/boundary/liquidity/weighted_product.rs
index 7dc28818d9..bceb8633c3 100644
--- a/crates/solvers/src/boundary/liquidity/weighted_product.rs
+++ b/crates/solvers/src/boundary/liquidity/weighted_product.rs
@@ -1,8 +1,8 @@
-pub use shared::sources::balancer_v2::pool_fetching::WeightedPool as Pool;
+pub use liquidity_sources::balancer_v2::pool_fetching::WeightedPool as Pool;
 use {
     crate::domain::{eth, liquidity},
     alloy::primitives::{Address, B256, U256},
-    shared::sources::balancer_v2::{
+    liquidity_sources::balancer_v2::{
         pool_fetching::{CommonPoolState, TokenState, WeightedPoolVersion, WeightedTokenState},
         swap::fixed_point::Bfp,
     },
diff --git a/crates/solvers/src/boundary/mod.rs b/crates/solvers/src/boundary/mod.rs
index 3be2864e8d..4878e80991 100644
--- a/crates/solvers/src/boundary/mod.rs
+++ b/crates/solvers/src/boundary/mod.rs
@@ -3,5 +3,6 @@
 
 pub mod baseline;
 pub mod liquidity;
+pub mod routing;
 
 pub type Result<T> = anyhow::Result<T>;
diff --git a/crates/shared/src/baseline_solver.rs b/crates/solvers/src/boundary/routing.rs
similarity index 72%
rename from crates/shared/src/baseline_solver.rs
rename to crates/solvers/src/boundary/routing.rs
index 546203bac7..02ac3faf42 100644
--- a/crates/shared/src/baseline_solver.rs
+++ b/crates/solvers/src/boundary/routing.rs
@@ -3,6 +3,7 @@
 
 use {
     alloy::primitives::{Address, U256},
+    liquidity_sources::baseline_solvable::BaselineSolvable,
     model::TokenPair,
     std::collections::{HashMap, HashSet},
 };
@@ -12,34 +13,6 @@ const DEFAULT_MAX_HOPS: usize = 2;
 
 type PathCandidate = Vec<Address>;
 
-/// Note that get_amount_out and get_amount_in are not always symmetrical. That
-/// is for some AMMs it is possible that get_amount_out returns an amount for
-/// which get_amount_in returns None when trying to go the reverse direction. Or
-/// that the resulting amount is different from the original. This situation is
-/// rare and resulting amounts should usually be identical or very close but it
-/// can occur.
-pub trait BaselineSolvable {
-    /// Given the desired output token, the amount and token input, return the
-    /// expected amount of output token.
-    fn get_amount_out(
-        &self,
-        out_token: Address,
-        input: (U256, Address),
-    ) -> impl Future<Output = Option<U256>> + Send;
-
-    /// Given the input token, the amount and token we want output, return the
-    /// required amount of input token that needs to be provided.
-    fn get_amount_in(
-        &self,
-        in_token: Address,
-        out: (U256, Address),
-    ) -> impl Future<Output = Option<U256>> + Send;
-
-    /// Returns the approximate amount of gas that using this piece of liquidity
-    /// would incur
-    fn gas_cost(&self) -> impl Future<Output = usize> + Send;
-}
-
 pub struct Estimate<'a, V, L> {
     // The result amount of the estimate
     pub value: V,
@@ -266,87 +239,11 @@ fn base_token_pairs(base_tokens: &[Address]) -> impl Iterator<Item = TokenPair>
 mod tests {
     use {
         super::*,
-        crate::sources::uniswap_v2::pool_fetching::Pool,
-        maplit::{hashmap, hashset},
+        liquidity_sources::uniswap_v2::pool_fetching::Pool,
+        maplit::hashmap,
         model::TokenPair,
     };
 
-    #[test]
-    fn path_candidates_empty_when_same_token() {
-        let base = BaseTokens::new(Address::with_last_byte(0), &[Address::with_last_byte(1)]);
-        let sell_token = Address::with_last_byte(2);
-        let buy_token = Address::with_last_byte(2);
-
-        assert!(base.path_candidates(sell_token, buy_token).is_empty());
-    }
-
-    #[test]
-    fn test_path_candidates() {
-        let base_tokens = [
-            Address::with_last_byte(0),
-            Address::with_last_byte(1),
-            Address::with_last_byte(2),
-        ];
-        let base_token_set: HashSet<Address> = base_tokens.iter().copied().collect();
-
-        let sell_token = Address::with_last_byte(4);
-        let buy_token = Address::with_last_byte(5);
-
-        // 0 hops
-        assert_eq!(
-            path_candidates(sell_token, buy_token, &base_token_set, 0),
-            hashset! {vec![sell_token, buy_token]}
-        );
-
-        // 1 hop with all permutations
-        assert_eq!(
-            path_candidates(sell_token, buy_token, &base_token_set, 1),
-            hashset! {
-                vec![sell_token, buy_token],
-                vec![sell_token, base_tokens[0], buy_token],
-                vec![sell_token, base_tokens[1], buy_token],
-                vec![sell_token, base_tokens[2], buy_token],
-
-            }
-        );
-
-        // 2 & 3 hops check count
-        assert_eq!(
-            path_candidates(sell_token, buy_token, &base_token_set, 2).len(),
-            10
-        );
-        assert_eq!(
-            path_candidates(sell_token, buy_token, &base_token_set, 3).len(),
-            16
-        );
-
-        // 4 hops should not yield any more permutations since we used all base tokens
-        assert_eq!(
-            path_candidates(sell_token, buy_token, &base_token_set, 4).len(),
-            16
-        );
-
-        // Ignores base token if part of buy or sell
-        assert_eq!(
-            path_candidates(base_tokens[0], buy_token, &base_token_set, 1),
-            hashset! {
-                vec![base_tokens[0], buy_token],
-                vec![base_tokens[0], base_tokens[1], buy_token],
-                vec![base_tokens[0], base_tokens[2], buy_token],
-
-            }
-        );
-        assert_eq!(
-            path_candidates(sell_token, base_tokens[0], &base_token_set, 1),
-            hashset! {
-                vec![sell_token, base_tokens[0]],
-                vec![sell_token, base_tokens[1], base_tokens[0]],
-                vec![sell_token, base_tokens[2], base_tokens[0]],
-
-            }
-        );
-    }
-
     #[tokio::test]
     async fn test_estimate_amount_returns_none_if_it_contains_pair_without_pool() {
         let sell_token = Address::with_last_byte(1);
@@ -532,44 +429,4 @@ mod tests {
             .unwrap();
         assert_eq!(sell_estimate.path, [&valid_pool]);
     }
-
-    #[test]
-    fn base_token_pairs_() {
-        let base_tokens: Vec<Address> = [0, 1, 2]
-            .iter()
-            .copied()
-            .map(Address::with_last_byte)
-            .collect();
-        let pairs: Vec<TokenPair> = base_token_pairs(&base_tokens).collect();
-        assert_eq!(pairs.len(), 3);
-        assert!(pairs.contains(&TokenPair::new(base_tokens[0], base_tokens[1]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(base_tokens[0], base_tokens[2]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(base_tokens[1], base_tokens[2]).unwrap()));
-    }
-
-    #[test]
-    fn relevant_pairs() {
-        let tokens: Vec<Address> = [0, 1, 2, 3, 4]
-            .iter()
-            .copied()
-            .map(Address::with_last_byte)
-            .collect();
-        let base = BaseTokens::new(tokens[0], &tokens[1..2]);
-
-        let pairs = base.relevant_pairs(&mut std::iter::empty());
-        assert!(pairs.is_empty());
-
-        let pairs = base.relevant_pairs(&mut TokenPair::new(tokens[0], tokens[1]).into_iter());
-        assert_eq!(pairs.len(), 1);
-        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[1]).unwrap()));
-
-        let pairs = base.relevant_pairs(&mut TokenPair::new(tokens[3], tokens[4]).into_iter());
-        assert_eq!(pairs.len(), 6);
-        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[1]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[3]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(tokens[0], tokens[4]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(tokens[1], tokens[3]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(tokens[1], tokens[4]).unwrap()));
-        assert!(pairs.contains(&TokenPair::new(tokens[3], tokens[4]).unwrap()));
-    }
 }
diff --git a/crates/token-info/Cargo.toml b/crates/token-info/Cargo.toml
new file mode 100644
index 0000000000..a01b18cfbf
--- /dev/null
+++ b/crates/token-info/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "token-info"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+contracts = { workspace = true }
+ethrpc = { workspace = true }
+futures = { workspace = true }
+mockall = { workspace = true, optional = true }
+model = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+[dev-dependencies]
+mockall = { workspace = true }
+maplit = { workspace = true }
+tokio = { workspace = true }
+
+[features]
+test-util = ["dep:mockall"]
+
+[lints]
+workspace = true
diff --git a/crates/token-info/LICENSE-APACHE b/crates/token-info/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/token-info/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/token-info/LICENSE-MIT b/crates/token-info/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/token-info/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/token_info.rs b/crates/token-info/src/lib.rs
similarity index 100%
rename from crates/shared/src/token_info.rs
rename to crates/token-info/src/lib.rs

From b79d81204e70e5fe3cc453b15e29337ffde09f5b Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 4 Mar 2026 09:26:22 +0100
Subject: [PATCH 118/219] Allow multiple parallel settlements from one solver
 (#4167)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Resolves https://github.com/cowprotocol/services/issues/3966.

Enable parallel settlement submission from a single solver by using
EIP-7702 delegation. When a solver wins multiple solutions in
overlapping auctions, each settlement can now be submitted concurrently
through independent submission EOAs instead of waiting in a sequential
queue.

The solver EOA delegates its code to a CowSettlementForwarder contract
via EIP-7702. Approved submission EOAs call forward(target, data) on the
solver EOA, which forwards to the actual target (settlement contract,
wrapper, or flashloan router) with msg.sender = solver EOA — preserving
the existing whitelisting.

# Changes

- [x] `CowSettlementForwarder.sol` — New forwarder contract with caller
whitelist. Supports forwarding to any target (settlement contract,
wrappers, flashloan router) via `forward(address target, bytes data)`
- [x] `SubmissionAccountPool` type: a channel-based pool that lends
submission accounts for the duration of a settlement and reclaims them
afterward. In EIP-7702 mode, settle requests are spawned as concurrent
tasks instead of processed sequentially
- [x] `submission_accounts` config that allows specifying accounts that
are whitelisted to submit settlements. If omitted we fallback to
non-delegated submissions directly from the solver EOA

# Requirements before deployment

* Deploy & verify the CowSettlementForwarder contract
* Set up EIP7022 delegation to whitelisted solver EOAs to the newly
deployed contract
* Create new submissions accounts and fund them with eth (or other base
token) & monitor their eth balance
* Whitelist the submissions accounts on the solver EOA
(CowSettlementForwarder code)

Only then can the submissions accounts be configured and deployed.

## How to test

cargo nextest run -p e2e local_node_parallel_settlement --test-threads 1
--run-ignored ignored-only

<!--
## Related Issues

Fixes #
-->
---
 .../artifacts/CowSettlementForwarder.json     |  91 +++++
 crates/contracts/build.rs                     |   1 +
 .../solidity/CowSettlementForwarder.sol       |  41 +++
 crates/contracts/solidity/Makefile            |   1 +
 crates/driver/src/domain/competition/mod.rs   | 290 +++++++++++++---
 crates/driver/src/domain/mempools.rs          |  91 +++--
 crates/driver/src/infra/config/file/load.rs   |  45 +--
 crates/driver/src/infra/config/file/mod.rs    |  10 +
 crates/driver/src/infra/mempool/mod.rs        |  15 +-
 crates/driver/src/infra/solver/eip7702.rs     | 271 +++++++++++++++
 crates/driver/src/infra/solver/mod.rs         |  37 ++
 crates/driver/src/run.rs                      |  16 +-
 crates/e2e/src/setup/colocation.rs            |  52 ++-
 crates/e2e/src/setup/services.rs              |   2 +
 crates/e2e/tests/e2e/cow_amm.rs               |   6 +
 crates/e2e/tests/e2e/jit_orders.rs            |   2 +
 .../e2e/liquidity_source_notification.rs      |   2 +
 crates/e2e/tests/e2e/main.rs                  |   1 +
 crates/e2e/tests/e2e/parallel_settlement.rs   | 323 ++++++++++++++++++
 crates/e2e/tests/e2e/quoting.rs               |   4 +
 crates/e2e/tests/e2e/solver_competition.rs    |   4 +
 21 files changed, 1187 insertions(+), 118 deletions(-)
 create mode 100644 crates/contracts/artifacts/CowSettlementForwarder.json
 create mode 100644 crates/contracts/solidity/CowSettlementForwarder.sol
 create mode 100644 crates/driver/src/infra/solver/eip7702.rs
 create mode 100644 crates/e2e/tests/e2e/parallel_settlement.rs

diff --git a/crates/contracts/artifacts/CowSettlementForwarder.json b/crates/contracts/artifacts/CowSettlementForwarder.json
new file mode 100644
index 0000000000..7d4171a687
--- /dev/null
+++ b/crates/contracts/artifacts/CowSettlementForwarder.json
@@ -0,0 +1,91 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "Unauthorized",
+      "type": "error"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "bool",
+          "name": "approved",
+          "type": "bool"
+        }
+      ],
+      "name": "ApprovedCallerSet",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "target",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "forward",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "isApprovedCaller",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "callers",
+          "type": "address[]"
+        },
+        {
+          "internalType": "bool",
+          "name": "approved",
+          "type": "bool"
+        }
+      ],
+      "name": "setApprovedCallers",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "deployedBytecode": "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",
+  "devdoc": {
+    "methods": {}
+  },
+  "userdoc": {
+    "methods": {}
+  }
+}
diff --git a/crates/contracts/build.rs b/crates/contracts/build.rs
index 837f8a596c..b9f470e354 100644
--- a/crates/contracts/build.rs
+++ b/crates/contracts/build.rs
@@ -638,6 +638,7 @@ fn main() {
             AVALANCHE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
         ]))
         .add_contract(Contract::new("ICowWrapper"))
+        .add_contract(Contract::new("CowSettlementForwarder"))
         .add_contract(Contract::new("ChainalysisOracle").with_networks(networks![
             MAINNET => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
             ARBITRUM_ONE => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
diff --git a/crates/contracts/solidity/CowSettlementForwarder.sol b/crates/contracts/solidity/CowSettlementForwarder.sol
new file mode 100644
index 0000000000..3769bcaf9c
--- /dev/null
+++ b/crates/contracts/solidity/CowSettlementForwarder.sol
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.28;
+
+/// @title EIP-7702 Settlement Forwarder for CoW Protocol
+/// @notice When used with EIP-7702, the solver EOA delegates its code to this
+/// contract. Approved submission EOAs call `forward(target, data)` to execute
+/// settlement transactions through the solver EOA, preserving
+/// `msg.sender = solver EOA` from the target's perspective.
+///
+/// Storage lives in the solver EOA's account (EIP-7702 semantics). The contract
+/// is deployed once and shared across all solver EOAs — each gets its own
+/// independent `isApprovedCaller` mapping in its own storage.
+contract CowSettlementForwarder {
+    mapping(address => bool) public isApprovedCaller;
+
+    event ApprovedCallerSet(address indexed caller, bool approved);
+
+    error Unauthorized();
+
+    /// @notice Forward `data` to `target` via CALL.
+    /// @dev Only approved callers can invoke this. In EIP-7702 context,
+    /// `address(this)` = solver EOA, so `target` sees `msg.sender = solver EOA`.
+    function forward(address target, bytes calldata data) external payable {
+        if (!isApprovedCaller[msg.sender]) revert Unauthorized();
+        (bool success, bytes memory result) = target.call{value: msg.value}(data);
+        assembly {
+            switch success
+            case 0 { revert(add(result, 32), mload(result)) }
+            default { return(add(result, 32), mload(result)) }
+        }
+    }
+
+    /// @notice Set approved callers.
+    function setApprovedCallers(address[] calldata callers, bool approved) external {
+        if (msg.sender != address(this)) revert Unauthorized();
+        for (uint256 i = 0; i < callers.length; i++) {
+            isApprovedCaller[callers[i]] = approved;
+            emit ApprovedCallerSet(callers[i], approved);
+        }
+    }
+}
diff --git a/crates/contracts/solidity/Makefile b/crates/contracts/solidity/Makefile
index d51de344d8..af5933bd9d 100644
--- a/crates/contracts/solidity/Makefile
+++ b/crates/contracts/solidity/Makefile
@@ -10,6 +10,7 @@ ARTIFACTDIR := ../artifacts
 CONTRACTS := \
 	AnyoneAuthenticator.sol \
 	Balances.sol \
+	CowSettlementForwarder.sol \
 	Signatures.sol \
 	Solver.sol \
 	Spardose.sol \
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 392ea46051..398f287a01 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -2,6 +2,7 @@ use {
     self::solution::settlement,
     super::{
         Mempools,
+        mempools::SubmissionMode,
         time::{self, Remaining},
     },
     crate::{
@@ -17,13 +18,14 @@ use {
             notify,
             observe::{self, metrics},
             simulator::{RevertError, SimulatorError},
-            solver::{self, SolutionMerging, Solver},
+            solver::{self, Account, SolutionMerging, Solver},
         },
         util::math,
     },
-    alloy::primitives::Bytes,
+    alloy::{network::TxSigner as _, primitives::Bytes},
+    anyhow::Context as _,
     axum::{body::Body, http::Request},
-    futures::{StreamExt, future::Either, stream::FuturesUnordered},
+    futures::{FutureExt, StreamExt, future::Either, stream::FuturesUnordered},
     itertools::Itertools,
     std::{
         cmp::Reverse,
@@ -57,6 +59,161 @@ type Balances = HashMap<BalanceGroup, order::SellAmount>;
 /// driver, and allows them to be executed onchain when requested later. The
 /// solutions expire after a certain amount of time, at which point trying to
 /// use them will return an `[Error::InvalidSolutionId]`.
+/// Unified pool of submission slots. Contains one "direct" slot (solver EOA,
+/// no forwarding overhead) and zero or more "delegated" slots (EIP-7702
+/// submission accounts). The direct slot is preferred; delegated slots are
+/// used only when the solver EOA is already busy with an in-flight settlement.
+#[derive(Debug)]
+struct SubmitterPool {
+    /// 1-permit semaphore for the solver EOA (direct submission).
+    direct_slot: Arc<tokio::sync::Semaphore>,
+    /// EIP-7702 submission accounts. `None` in legacy single-EOA mode.
+    delegated: Option<DelegatedSlots>,
+    solver_address: eth::Address,
+}
+
+#[derive(Debug)]
+struct DelegatedSlots {
+    release: mpsc::Sender<Account>,
+    acquire: tokio::sync::Mutex<mpsc::Receiver<Account>>,
+}
+
+impl SubmitterPool {
+    fn new(solver_address: eth::Address, submission_accounts: Vec<Account>) -> Self {
+        let delegated = if submission_accounts.is_empty() {
+            None
+        } else {
+            let (tx, rx) = mpsc::channel(submission_accounts.len());
+            for account in submission_accounts {
+                tx.try_send(account)
+                    .expect("channel has sufficient capacity");
+            }
+            Some(DelegatedSlots {
+                release: tx,
+                acquire: tokio::sync::Mutex::new(rx),
+            })
+        };
+        Self {
+            direct_slot: Arc::new(tokio::sync::Semaphore::new(1)),
+            delegated,
+            solver_address,
+        }
+    }
+
+    /// Acquire a submission slot. Prefers the direct solver EOA slot
+    /// (cheaper, no forwarding). Falls back to a delegated EIP-7702 account
+    /// when the direct slot is busy. Blocks if all slots are in use.
+    async fn acquire(&self) -> Option<SubmitterGuard> {
+        // Try the direct slot first (non-blocking).
+        if let Ok(permit) = Arc::clone(&self.direct_slot).try_acquire_owned() {
+            tracing::debug!("submitting directly from solver EOA");
+            return Some(SubmitterGuard {
+                inner: GuardInner::Direct(permit),
+                solver_address: self.solver_address,
+            });
+        }
+
+        // Direct slot busy — race it against delegated accounts. select_ok
+        // ensures that if one future errors the other is still awaited.
+        let fetch_direct_slot = async {
+            let permit = Arc::clone(&self.direct_slot)
+                .acquire_owned()
+                .await
+                .context("semaphore closed")?;
+            tracing::debug!("submitting directly from solver EOA");
+            Ok(GuardInner::Direct(permit))
+        }
+        .boxed();
+
+        let fetch_eip7702_slot = async {
+            let Some(ref delegated) = self.delegated else {
+                return Err(anyhow::anyhow!("no EIP-7702 accounts configured"));
+            };
+            let mut channel = delegated.acquire.lock().await;
+            let account = channel.recv().await.context("channel closed")?;
+            tracing::debug!(submitter = ?account.address(), "using EIP-7702 submission account");
+            Ok(GuardInner::Delegated {
+                account,
+                release: delegated.release.clone(),
+            })
+        }
+        .boxed();
+
+        let (inner, _remaining) =
+            futures::future::select_ok([fetch_direct_slot, fetch_eip7702_slot])
+                .await
+                .inspect_err(|err| tracing::error!(?err, "could not acquire submission account"))
+                .ok()?;
+
+        Some(SubmitterGuard {
+            inner,
+            solver_address: self.solver_address,
+        })
+    }
+
+    fn total_slots(&self) -> usize {
+        // 1 slot for solver EOA + number of delegated EIP7702 accounts (if any)
+        1 + self
+            .delegated
+            .as_ref()
+            .map_or(0, |d| d.release.max_capacity())
+    }
+
+    fn has_capacity(&self) -> bool {
+        if self.direct_slot.available_permits() > 0 {
+            return true;
+        }
+        self.delegated
+            .as_ref()
+            .is_some_and(|d| d.release.capacity() < d.release.max_capacity())
+    }
+}
+
+/// RAII guard for a submission slot. Dropping returns the slot to the pool.
+struct SubmitterGuard {
+    inner: GuardInner,
+    solver_address: eth::Address,
+}
+
+enum GuardInner {
+    /// Solver EOA submits directly. Permit released on drop.
+    Direct(#[expect(dead_code)] tokio::sync::OwnedSemaphorePermit),
+    /// Delegated EIP-7702 submission. Account returned to channel on drop.
+    Delegated {
+        account: Account,
+        release: mpsc::Sender<Account>,
+    },
+    /// Sentinel used during `Drop` to move data out of `self`.
+    Dropped,
+}
+
+impl SubmitterGuard {
+    fn submission_mode(&self) -> SubmissionMode {
+        match &self.inner {
+            GuardInner::Direct(_) => SubmissionMode::Direct(self.solver_address),
+            GuardInner::Delegated { account, .. } => SubmissionMode::Delegated {
+                submitter_eoa: account.address(),
+                solver_eoa: self.solver_address,
+            },
+            GuardInner::Dropped => unreachable!(),
+        }
+    }
+}
+
+impl Drop for SubmitterGuard {
+    fn drop(&mut self) {
+        let inner = std::mem::replace(&mut self.inner, GuardInner::Dropped);
+        if let GuardInner::Delegated { account, release } = inner {
+            tokio::spawn(async move {
+                if release.send(account).await.is_err() {
+                    tracing::error!("failed to return submission account to pool: channel closed");
+                }
+            });
+        }
+        // Direct: OwnedSemaphorePermit drops here, releasing the permit.
+    }
+}
+
 #[derive(Debug)]
 pub struct Competition {
     pub solver: Solver,
@@ -72,6 +229,7 @@ pub struct Competition {
     fetcher: Arc<pre_processing::DataAggregator>,
     settle_queue: mpsc::Sender<SettleRequest>,
     order_sorting_strategies: Vec<Arc<dyn sorting::SortingStrategy>>,
+    submitter_pool: SubmitterPool,
 }
 
 impl Competition {
@@ -87,7 +245,16 @@ impl Competition {
         fetcher: Arc<DataAggregator>,
         order_sorting_strategies: Vec<Arc<dyn sorting::SortingStrategy>>,
     ) -> Arc<Self> {
-        let (settle_sender, settle_receiver) = mpsc::channel(solver.settle_queue_size());
+        let submission_accounts = solver.submission_accounts().to_vec();
+        if !submission_accounts.is_empty() {
+            tracing::info!(
+                count = submission_accounts.len(),
+                "EIP-7702 parallel submission enabled"
+            );
+        }
+        let submitter_pool = SubmitterPool::new(solver.address(), submission_accounts);
+        let queue_size = submitter_pool.total_slots().max(solver.settle_queue_size());
+        let (settle_sender, settle_receiver) = mpsc::channel(queue_size);
 
         let competition = Arc::new(Self {
             solver,
@@ -101,6 +268,7 @@ impl Competition {
             risk_detector,
             fetcher,
             order_sorting_strategies,
+            submitter_pool,
         });
 
         let competition_clone = Arc::clone(&competition);
@@ -605,8 +773,8 @@ impl Competition {
     }
 
     pub fn ensure_settle_queue_capacity(&self) -> Result<(), Error> {
-        if self.settle_queue.capacity() == 0 {
-            tracing::warn!("settlement queue is full; auction is rejected");
+        if !self.submitter_pool.has_capacity() {
+            tracing::warn!("no idle submission slots; auction is rejected");
             Err(Error::TooManyPendingSettlements)
         } else {
             Ok(())
@@ -618,54 +786,61 @@ impl Competition {
         mut settle_receiver: mpsc::Receiver<SettleRequest>,
     ) {
         while let Some(request) = settle_receiver.recv().await {
-            let SettleRequest {
-                auction_id,
-                solution_id,
-                submission_deadline,
-                mut response_sender,
-                tracing_span,
-            } = request;
-            async {
-                if self.eth.current_block().borrow().number >= submission_deadline {
-                    if let Err(err) = response_sender.send(Err(DeadlineExceeded.into())) {
-                        tracing::error!(
-                            ?err,
-                            "settle deadline exceeded. unable to return a response"
-                        );
-                    }
-                    return;
-                }
+            // When only the direct solver EOA slot exists and no delegated accounts are set
+            // up, the pool's acquire() blocks until the slot is free,  serializing
+            // settlements.
+            let this = Arc::clone(&self);
+            tokio::spawn(async move {
+                this.handle_settle_request(request).await;
+            });
+        }
+    }
 
-                observe::settling();
-                let settle_fut = Box::pin(self.process_settle_request(
-                    auction_id,
-                    solution_id,
-                    submission_deadline,
-                ));
-                let closed_fut = Box::pin(response_sender.closed());
-                let result = match futures::future::select(closed_fut, settle_fut).await {
-                    // Cancel the settlement task if the sender is closed (client likely
-                    // disconnected). This is a fallback to recover from issues
-                    // like a stuck driver (e.g., stalled block stream).
-                    Either::Left((_closed, settle_fut)) => {
-                        tracing::debug!("autopilot terminated settle call");
-                        // Add a grace period to give driver the last chance to cancel the
-                        // tx if needed.
-                        tokio::time::timeout(Duration::from_secs(1), settle_fut)
-                            .await
-                            .unwrap_or_else(|_| {
-                                tracing::error!("didn't finish tx submission within grace period");
-                                Err(DeadlineExceeded.into())
-                            })
-                    }
-                    Either::Right((res, _)) => res,
-                };
-                observe::settled(self.solver.name(), &result);
-                let _ = response_sender.send(result);
+    async fn handle_settle_request(self: &Arc<Self>, request: SettleRequest) {
+        let SettleRequest {
+            auction_id,
+            solution_id,
+            submission_deadline,
+            mut response_sender,
+            tracing_span,
+        } = request;
+        async {
+            if self.eth.current_block().borrow().number >= submission_deadline {
+                if let Err(err) = response_sender.send(Err(DeadlineExceeded.into())) {
+                    tracing::error!(
+                        ?err,
+                        "settle deadline exceeded. unable to return a response"
+                    );
+                }
+                return;
             }
-            .instrument(tracing_span)
-            .await
+
+            observe::settling();
+            let settle_fut =
+                Box::pin(self.process_settle_request(auction_id, solution_id, submission_deadline));
+            let closed_fut = Box::pin(response_sender.closed());
+            let result = match futures::future::select(closed_fut, settle_fut).await {
+                // Cancel the settlement task if the sender is closed (client likely
+                // disconnected). This is a fallback to recover from issues
+                // like a stuck driver (e.g., stalled block stream).
+                Either::Left((_closed, settle_fut)) => {
+                    tracing::debug!("autopilot terminated settle call");
+                    // Add a grace period to give driver the last chance to cancel the
+                    // tx if needed.
+                    tokio::time::timeout(Duration::from_secs(1), settle_fut)
+                        .await
+                        .unwrap_or_else(|_| {
+                            tracing::error!("didn't finish tx submission within grace period");
+                            Err(DeadlineExceeded.into())
+                        })
+                }
+                Either::Right((res, _)) => res,
+            };
+            observe::settled(self.solver.name(), &result);
+            let _ = response_sender.send(result);
         }
+        .instrument(tracing_span)
+        .await
     }
 
     async fn process_settle_request(
@@ -702,10 +877,21 @@ impl Competition {
             });
         }
 
+        // Acquire a submission slot. The pool prefers the direct solver EOA
+        // (no forwarding overhead); falls back to a delegated EIP-7702
+        // submission account when the solver EOA is busy.
+        let guard = self
+            .submitter_pool
+            .acquire()
+            .await
+            .ok_or(Error::SubmissionError)?;
+        let mode = guard.submission_mode();
+
         let executed = self
             .mempools
-            .execute(&self.solver, &settlement, submission_deadline)
+            .execute(&settlement, submission_deadline, &mode)
             .await;
+
         notify::executed(
             &self.solver,
             settlement.auction_id,
diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index fb606842c8..2b85a8f88e 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -6,10 +6,11 @@ use {
             competition::solution::Settlement,
             eth::{TxId, TxStatus},
         },
-        infra::{self, Ethereum, observe, solver::Solver},
+        infra::{self, Ethereum, observe},
     },
-    alloy::{consensus::Transaction, eips::eip1559::Eip1559Estimation},
+    alloy::{consensus::Transaction, eips::eip1559::Eip1559Estimation, sol_types::SolCall},
     anyhow::Context,
+    contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
     ethrpc::block_stream::into_stream,
     futures::{FutureExt, StreamExt, future::select_ok},
     thiserror::Error,
@@ -25,6 +26,23 @@ const GAS_PRICE_BUMP_PCT: u64 = 13;
 /// The gas amount required to cancel a transaction.
 const CANCELLATION_GAS_AMOUNT: u64 = 21000;
 
+/// How the settlement transaction should be submitted on-chain.
+#[derive(Debug, Clone)]
+pub enum SubmissionMode {
+    /// Solver EOA signs and submits directly to the settlement contract.
+    Direct(eth::Address),
+    /// A dedicated submission EOA signs and pays for the tx while routing it
+    /// through the solver's EIP-7702 delegated forwarder contract.
+    Delegated {
+        /// The address that signs the transaction and whose nonce is used.
+        submitter_eoa: eth::Address,
+        /// The solver EOA address. In EIP-7702 mode tx.to is set to this
+        /// address (which delegates to a forwarder contract), instead of the
+        /// settlement contract.
+        solver_eoa: eth::Address,
+    },
+}
+
 /// The mempools used to execute settlements.
 #[derive(Debug, Clone)]
 pub struct Mempools {
@@ -41,17 +59,16 @@ impl Mempools {
         }
     }
 
-    /// Publish a settlement to the mempools.
     pub async fn execute(
         &self,
-        solver: &Solver,
         settlement: &Settlement,
         submission_deadline: BlockNo,
+        mode: &SubmissionMode,
     ) -> Result<eth::TxId, Error> {
         let (submission, _remaining_futures) = select_ok(self.mempools.iter().map(|mempool| {
             async move {
                 let result = self
-                    .submit(mempool, solver, settlement, submission_deadline)
+                    .submit(mempool, settlement, submission_deadline, mode)
                     .instrument(tracing::info_span!("mempool", kind = mempool.to_string()))
                     .await;
                 observe::mempool_executed(mempool, settlement, &result);
@@ -80,9 +97,9 @@ impl Mempools {
     async fn submit(
         &self,
         mempool: &infra::mempool::Mempool,
-        solver: &Solver,
         settlement: &Settlement,
         submission_deadline: BlockNo,
+        mode: &SubmissionMode,
     ) -> Result<SubmissionSuccess, Error> {
         // Don't submit risky transactions if revert protection is
         // enabled and the settlement may revert in this mempool.
@@ -94,6 +111,8 @@ impl Mempools {
         }
 
         let tx = settlement.transaction(settlement::Internalization::Enable);
+        let tx = prepare_submission(tx, mode);
+        let signer = tx.from;
 
         // Instantiate block stream and skip the current block before we submit the
         // settlement. This way we only run iterations in blocks that can potentially
@@ -127,10 +146,8 @@ impl Mempools {
             tracing::trace!("skipping tx simulation because mempool does not mine reverting txs");
         }
 
-        // Fetch the nonce to avoid race conditions between concurrent
-        // transactions (e.g., settlement tx and cancellation tx) from the same
-        // solver address.
-        let nonce = mempool.get_nonce(solver.address()).await?;
+        // Fetch the nonce for the signing account (not the solver in 7702 mode).
+        let nonce = mempool.get_nonce(signer).await?;
 
         // estimate the gas price such that the tx should still be included
         // even if the gas price increases the maximum amount until the submission
@@ -146,7 +163,7 @@ impl Mempools {
         // if there is still a tx pending we also have to make sure we outbid that one
         // enough to make the node replace it in the mempool
         let replacement_gas_price = self
-            .minimum_replacement_gas_price(mempool, solver, nonce)
+            .minimum_replacement_gas_price(mempool, signer, nonce)
             .await;
         let final_gas_price = match &replacement_gas_price {
             Some(replacement_gas_price)
@@ -163,6 +180,7 @@ impl Mempools {
             ?replacement_gas_price,
             ?current_gas_price,
             ?final_gas_price,
+            ?signer,
             "submitting settlement tx"
         );
         let hash = mempool
@@ -170,7 +188,7 @@ impl Mempools {
                 tx.clone(),
                 final_gas_price,
                 settlement.gas.limit,
-                solver,
+                signer,
                 nonce,
             )
             .await?;
@@ -210,7 +228,7 @@ impl Mempools {
                                 "exceeded submission deadline, cancelling"
                             );
                             let _ = self
-                                .cancel(mempool, final_gas_price, solver, nonce)
+                                .cancel(mempool, final_gas_price, signer, nonce)
                                 .await;
                             return Err(Error::Expired {
                                 tx_id: hash.clone(),
@@ -227,7 +245,7 @@ impl Mempools {
                                     "tx started failing in mempool, cancelling"
                                 );
                                 let _ = self
-                                    .cancel(mempool, final_gas_price, solver, nonce)
+                                    .cancel(mempool, final_gas_price, signer, nonce)
                                     .await;
                                 return Err(Error::SimulationRevert {
                                     submitted_at_block: submission_block,
@@ -273,12 +291,12 @@ impl Mempools {
         &self,
         mempool: &infra::mempool::Mempool,
         original_tx_gas_price: Eip1559Estimation,
-        solver: &Solver,
+        signer: eth::Address,
         nonce: u64,
     ) -> Result<TxId, Error> {
         let fallback_gas_price = original_tx_gas_price.scaled_by_pct(GAS_PRICE_BUMP_PCT);
         let replacement_gas_price = self
-            .minimum_replacement_gas_price(mempool, solver, nonce)
+            .minimum_replacement_gas_price(mempool, signer, nonce)
             .await;
 
         // the node is the ultimate source of truth to compute the minimum
@@ -290,8 +308,8 @@ impl Mempools {
         };
 
         let cancellation = eth::Tx {
-            from: solver.address(),
-            to: solver.address(),
+            from: signer,
+            to: signer,
             value: 0.into(),
             input: Default::default(),
             access_list: Default::default(),
@@ -309,7 +327,7 @@ impl Mempools {
                 cancellation,
                 final_gas_price,
                 CANCELLATION_GAS_AMOUNT.into(),
-                solver,
+                signer,
                 nonce,
             )
             .await
@@ -322,10 +340,10 @@ impl Mempools {
     async fn minimum_replacement_gas_price(
         &self,
         mempool: &infra::Mempool,
-        solver: &Solver,
+        signer: eth::Address,
         next_nonce: u64,
     ) -> Option<Eip1559Estimation> {
-        if let Some(last_submission) = mempool.last_submission(solver.address()) {
+        if let Some(last_submission) = mempool.last_submission(signer) {
             if last_submission.nonce == next_nonce {
                 Some(last_submission.gas_price.scaled_by_pct(GAS_PRICE_BUMP_PCT))
             } else {
@@ -337,7 +355,7 @@ impl Mempools {
             // This is only done as a backup since it can incur significant latency and
             // is generally not very widely supported.
             let pending_tx = mempool
-                .find_pending_tx_in_mempool(solver.address(), next_nonce)
+                .find_pending_tx_in_mempool(signer, next_nonce)
                 .await
                 .inspect_err(|err| tracing::debug!(?err, "could not inspect tx mempool"))
                 .ok()??;
@@ -355,6 +373,35 @@ impl Mempools {
     }
 }
 
+/// In EIP-7702 mode, reroute the tx through the solver EOA's delegated
+/// forwarder contract. The original target and calldata are wrapped in a
+/// `forward()` call. `from` is set to the submission EOA so that simulations
+/// see the correct `msg.sender` for the forwarder's caller whitelist.
+fn prepare_submission(tx: &eth::Tx, mode: &SubmissionMode) -> eth::Tx {
+    let mut tx = tx.clone();
+    match mode {
+        SubmissionMode::Direct(solver_eoa) => {
+            tx.from = *solver_eoa;
+            tx
+        }
+        SubmissionMode::Delegated {
+            submitter_eoa,
+            solver_eoa,
+        } => {
+            let original_target = tx.to;
+            tx.from = *submitter_eoa;
+            tx.to = *solver_eoa;
+            tx.input = CowSettlementForwarder::forwardCall {
+                target: original_target,
+                data: tx.input.clone(),
+            }
+            .abi_encode()
+            .into();
+            tx
+        }
+    }
+}
+
 pub struct SubmissionSuccess {
     pub tx_hash: eth::TxId,
     /// At which block we started to submit the transaction.
diff --git a/crates/driver/src/infra/config/file/load.rs b/crates/driver/src/infra/config/file/load.rs
index 188ba0480a..849a1a20cb 100644
--- a/crates/driver/src/infra/config/file/load.rs
+++ b/crates/driver/src/infra/config/file/load.rs
@@ -52,25 +52,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
     );
     infra::Config {
         solvers: join_all(config.solvers.into_iter().map(|solver_config| async move {
-            let account: Account = match solver_config.account {
-                file::Account::PrivateKey(private_key) => {
-                    PrivateKeySigner::from_bytes(&private_key)
-                        .expect(
-                            "private key should
-                                            be valid",
-                        )
-                        .into()
-                }
-                file::Account::Kms(arn) => {
-                    let sdk_config = alloy::signers::aws::aws_config::load_from_env().await;
-                    let client = alloy::signers::aws::aws_sdk_kms::Client::new(&sdk_config);
-                    AwsSigner::new(client, arn.0, config.chain_id)
-                        .await
-                        .expect("unable to load kms account {arn:?}")
-                        .into()
-                }
-                file::Account::Address(address) => Account::Address(address),
-            };
+            let account = load_account(solver_config.account, config.chain_id).await;
             solver::Config {
                 endpoint: solver_config.endpoint,
                 name: solver_config.name.into(),
@@ -154,6 +136,14 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                     file::AtBlock::Finalized => liquidity::AtBlock::Finalized,
                 },
                 haircut_bps: solver_config.haircut_bps,
+                submission_accounts: join_all(
+                    solver_config
+                        .submission_accounts
+                        .into_iter()
+                        .map(|acc| load_account(acc, config.chain_id)),
+                )
+                .await,
+                forwarder_contract: solver_config.forwarder_contract,
             }
         }))
         .await,
@@ -393,3 +383,20 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
         tx_gas_limit: config.tx_gas_limit,
     }
 }
+
+async fn load_account(account: file::Account, chain_id: Option<u64>) -> Account {
+    match account {
+        file::Account::PrivateKey(pk) => PrivateKeySigner::from_bytes(&pk)
+            .expect("invalid private key")
+            .into(),
+        file::Account::Kms(arn) => {
+            let sdk_config = alloy::signers::aws::aws_config::load_from_env().await;
+            let client = alloy::signers::aws::aws_sdk_kms::Client::new(&sdk_config);
+            AwsSigner::new(client, arn.0, chain_id)
+                .await
+                .expect("unable to load kms account")
+                .into()
+        }
+        file::Account::Address(address) => Account::Address(address),
+    }
+}
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index 8f94ba854e..aec38d605f 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -313,6 +313,16 @@ struct SolverConfig {
     /// Default: 0 (no haircut).
     #[serde(default)]
     haircut_bps: u32,
+
+    /// Additional EOAs that submit settlement txs on behalf of the solver
+    /// via EIP-7702 delegation. When non-empty, enables parallel submission
+    /// with one lane per account.
+    #[serde(default)]
+    submission_accounts: Vec<Account>,
+
+    /// Address of the deployed CowSettlementForwarder contract for EIP-7702
+    /// delegation. Required when `submission_accounts` is non-empty.
+    forwarder_contract: Option<eth::Address>,
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]
diff --git a/crates/driver/src/infra/mempool/mod.rs b/crates/driver/src/infra/mempool/mod.rs
index 8b7b39646e..dc580dcc52 100644
--- a/crates/driver/src/infra/mempool/mod.rs
+++ b/crates/driver/src/infra/mempool/mod.rs
@@ -116,13 +116,14 @@ impl Mempool {
     }
 
     /// Submits a transaction to the mempool. Returns optimistically as soon as
-    /// the transaction is pending.
+    /// the transaction is pending. `signer` is the address that signs and pays
+    /// for gas (may differ from the solver address in EIP-7702 mode).
     pub async fn submit(
         &self,
         tx: eth::Tx,
         gas_price: Eip1559Estimation,
         gas_limit: eth::Gas,
-        solver: &infra::Solver,
+        signer: eth::Address,
         nonce: u64,
     ) -> Result<eth::TxId, mempools::Error> {
         let max_fee_per_gas = gas_price.max_fee_per_gas;
@@ -130,7 +131,7 @@ impl Mempool {
         let gas_limit = gas_limit.0.try_into().map_err(anyhow::Error::from)?;
 
         let tx_request = TransactionRequest::default()
-            .from(solver.address())
+            .from(signer)
             .to(tx.to)
             .nonce(nonce)
             .max_fee_per_gas(max_fee_per_gas)
@@ -153,16 +154,16 @@ impl Mempool {
                     ?nonce,
                     ?gas_price,
                     ?gas_limit,
-                    solver = ?solver.address(),
+                    ?signer,
                     "successfully submitted tx to mempool"
                 );
                 self.last_submissions
-                    .insert(solver.address(), Submission { nonce, gas_price });
+                    .insert(signer, Submission { nonce, gas_price });
                 Ok(eth::TxId(*tx.tx_hash()))
             }
             Err(err) => {
                 // log pending tx in case we failed to replace a pending tx
-                let last_submission = self.last_submission(solver.address());
+                let last_submission = self.last_submission(signer);
 
                 tracing::debug!(
                     ?err,
@@ -170,7 +171,7 @@ impl Mempool {
                     ?nonce,
                     ?last_submission,
                     ?gas_limit,
-                    solver = ?solver.address(),
+                    ?signer,
                     "failed to submit tx to mempool"
                 );
                 Err(mempools::Error::Other(err))
diff --git a/crates/driver/src/infra/solver/eip7702.rs b/crates/driver/src/infra/solver/eip7702.rs
new file mode 100644
index 0000000000..a6fa8771f5
--- /dev/null
+++ b/crates/driver/src/infra/solver/eip7702.rs
@@ -0,0 +1,271 @@
+use {
+    super::{Config, Solver},
+    crate::infra::blockchain::Ethereum,
+    alloy::{
+        eips::eip7702::Authorization,
+        network::{TransactionBuilder7702, TxSigner},
+        primitives::{Address, U256},
+        providers::Provider,
+        rpc::types::TransactionRequest,
+        sol_types::SolCall,
+    },
+    anyhow::Context,
+    contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
+    futures::future::try_join_all,
+    std::time::Duration,
+    tracing::instrument,
+};
+
+/// EIP-7702 delegation prefix stored as account code prefix. If you call
+/// eth_getCode on a delegated EOA, instead of getting empty bytes (normal EOA),
+/// you get 0xef0100<20-byte contract address>.
+const DELEGATION_PREFIX: [u8; 3] = [0xef, 0x01, 0x00];
+
+/// Ensure EIP-7702 delegation and caller approval are set up for all solvers
+/// with parallel submission accounts. Called once at driver startup.
+#[instrument(name = "setup_eip7702", skip_all)]
+pub async fn setup(solvers: &[Solver], eth: &Ethereum) -> anyhow::Result<()> {
+    for solver in solvers {
+        let config = solver.config();
+        if config.submission_accounts.is_empty() {
+            continue;
+        }
+        if matches!(config.account, super::Account::Address(_)) {
+            tracing::debug!(solver = %config.name, "read-only mode, skipping EIP-7702 setup");
+            continue;
+        }
+        let forwarder = config.forwarder_contract.ok_or_else(|| {
+            anyhow::anyhow!(
+                "solver {}: submission_accounts configured but forwarder_contract missing",
+                config.name
+            )
+        })?;
+
+        // Register solver + submission accounts with the main wallet so we can
+        // send transactions via the provider during setup.
+        let web3 = eth.web3();
+        web3.wallet.register_signer(config.account.clone());
+        for acc in &config.submission_accounts {
+            web3.wallet.register_signer(acc.clone());
+        }
+
+        setup_solver(config, forwarder, eth).await?;
+    }
+    Ok(())
+}
+
+#[instrument(skip_all)]
+async fn setup_solver(config: &Config, forwarder: Address, eth: &Ethereum) -> anyhow::Result<()> {
+    let solver_address: Address = config.account.address();
+    let provider = &eth.web3().provider;
+
+    // Check delegation status.
+    let code = provider.get_code_at(solver_address).await?;
+    let needs_delegation = !is_delegated_to(&code, forwarder);
+
+    let submission_addresses: Vec<Address> = config
+        .submission_accounts
+        .iter()
+        .map(TxSigner::address)
+        .collect();
+
+    if needs_delegation {
+        setup_delegation_and_approve(config, forwarder, &submission_addresses, eth).await?;
+    } else {
+        // Skip delegation, but make sure submission accounts are approved callers.
+        let unapproved =
+            check_unapproved_callers(eth, solver_address, &submission_addresses).await?;
+        approve_submitters(config, &unapproved, eth).await?;
+    }
+
+    Ok(())
+}
+
+/// Check whether the account's code is an EIP-7702 delegation to
+/// `expected_forwarder`.
+fn is_delegated_to(code: &[u8], expected_forwarder: Address) -> bool {
+    // EIP-7702 delegation designator: 0xef0100 || 20-byte address
+    code.len() == 23 && code.starts_with(&DELEGATION_PREFIX) && code[3..] == expected_forwarder.0.0
+}
+
+/// Check which submission accounts are already approved callers on the
+/// solver's delegated forwarder. Uses `join_all` which auto-batches through
+/// ethrpc's batching layer.
+#[instrument(skip_all)]
+async fn check_unapproved_callers(
+    eth: &Ethereum,
+    solver: Address,
+    callers: &[Address],
+) -> anyhow::Result<Vec<Address>> {
+    let provider = &eth.web3().provider;
+
+    let unapproved: Vec<Address> =
+        try_join_all(callers.iter().copied().map(move |caller| async move {
+            let forwarder = CowSettlementForwarder::new(solver, provider);
+            let approved = forwarder.isApprovedCaller(caller).call().await?;
+            Ok::<_, anyhow::Error>((!approved).then_some(caller))
+        }))
+        .await?
+        .into_iter()
+        .flatten()
+        .collect();
+
+    Ok(unapproved)
+}
+
+/// Set up EIP-7702 delegation and approve callers in a single transaction.
+/// The solver signs the authorization and self-calls `setApprovedCallers`.
+#[instrument(skip_all)]
+async fn setup_delegation_and_approve(
+    config: &Config,
+    forwarder: Address,
+    unapproved: &[Address],
+    eth: &Ethereum,
+) -> anyhow::Result<()> {
+    let provider = &eth.web3().provider;
+    let chain_id = provider.get_chain_id().await?;
+    let solver_address: Address = config.account.address();
+
+    // Wait for any pending solver txs to clear (e.g. in-flight settlements
+    // from a pre-7702 deployment). Submitting at the same nonce would replace
+    // the pending tx, silently dropping a valid settlement.
+    let solver_nonce = wait_for_pending_txs(provider, solver_address).await?;
+
+    tracing::info!(
+        ?forwarder,
+        solver_nonce,
+        auth_nonce = solver_nonce + 1,
+        unapproved_callers = unapproved.len(),
+        "setting up EIP-7702 delegation"
+    );
+
+    // The auth nonce must be solver_nonce + 1: in EIP-7702 the sender's nonce
+    // is incremented before the authorization list is processed. Since the
+    // solver is both sender and authority, the nonce will already be
+    // solver_nonce + 1 by the time the auth is checked.
+    let auth = Authorization {
+        chain_id: U256::from(chain_id),
+        address: forwarder,
+        nonce: solver_nonce + 1,
+    };
+    let sig = config
+        .account
+        .sign_hash(&auth.signature_hash())
+        .await
+        .context("failed to sign EIP-7702 authorization")?;
+    let signed_auth = auth.into_signed(sig);
+
+    // Explicitly set the tx nonce to `solver_nonce` so the provider's nonce
+    // filler cannot assign a different value.
+    let mut tx = TransactionRequest::default()
+        .from(solver_address)
+        .to(solver_address)
+        .nonce(solver_nonce)
+        .with_authorization_list(vec![signed_auth]);
+
+    if !unapproved.is_empty() {
+        let calldata = CowSettlementForwarder::setApprovedCallersCall {
+            callers: unapproved.to_vec(),
+            approved: true,
+        }
+        .abi_encode();
+        tx = tx.input(calldata.into());
+    }
+
+    let pending = provider.send_transaction(tx).await?;
+    let receipt = pending.get_receipt().await?;
+    tracing::info!(
+        tx_hash = ?receipt.transaction_hash,
+        block = ?receipt.block_number,
+        "EIP-7702 delegation tx confirmed"
+    );
+
+    // Verify the delegation was actually applied (EIP-7702 silently skips
+    // authorizations with mismatched nonces).
+    let code = provider.get_code_at(solver_address).await?;
+    if !is_delegated_to(&code, forwarder) {
+        anyhow::bail!(
+            "EIP-7702 delegation not applied after tx {:?}. Expected auth_nonce={} \
+             (solver_nonce={} + 1). Check that no pending txs changed the nonce between query and \
+             submission.",
+            receipt.transaction_hash,
+            solver_nonce + 1,
+            solver_nonce,
+        );
+    }
+
+    Ok(())
+}
+
+/// Approve callers via a solver self-call (delegation already active).
+#[instrument(skip_all)]
+async fn approve_submitters(
+    config: &Config,
+    unapproved: &[Address],
+    eth: &Ethereum,
+) -> anyhow::Result<()> {
+    if unapproved.is_empty() {
+        tracing::info!("no sumitters to approve, skipping");
+        return Ok(());
+    }
+    tracing::info!(
+        unapproved_callers = unapproved.len(),
+        "approving new submission callers"
+    );
+    let provider = &eth.web3().provider;
+    let solver_address: Address = config.account.address();
+
+    let calldata = CowSettlementForwarder::setApprovedCallersCall {
+        callers: unapproved.to_vec(),
+        approved: true,
+    }
+    .abi_encode();
+
+    let tx = TransactionRequest::default()
+        .from(solver_address)
+        .to(solver_address)
+        .input(calldata.into());
+
+    let pending = provider.send_transaction(tx).await?;
+    let receipt = pending.get_receipt().await?;
+    tracing::info!(
+        tx_hash = ?receipt.transaction_hash,
+        block = ?receipt.block_number,
+        "setApprovedCallers tx confirmed"
+    );
+
+    Ok(())
+}
+
+/// Wait until the solver has no pending transactions in the mempool.
+/// Returns the confirmed nonce (safe to use for the next tx).
+#[instrument(skip_all)]
+async fn wait_for_pending_txs(provider: &impl Provider, address: Address) -> anyhow::Result<u64> {
+    const POLL_INTERVAL: Duration = Duration::from_secs(3);
+    const MAX_WAIT: Duration = Duration::from_secs(90);
+
+    let deadline = tokio::time::Instant::now() + MAX_WAIT;
+    loop {
+        // only counts txs in mined blocks
+        let latest = provider.get_transaction_count(address).await?;
+        // also count txs in the mempool
+        let pending = provider.get_transaction_count(address).pending().await?;
+        if pending <= latest {
+            return Ok(latest);
+        }
+        if tokio::time::Instant::now() > deadline {
+            anyhow::bail!(
+                "timed out waiting for {} pending solver txs to clear (latest nonce: {latest}, \
+                 pending nonce: {pending})",
+                pending - latest,
+            );
+        }
+        tracing::info!(
+            latest_nonce = latest,
+            pending_nonce = pending,
+            pending_txs = pending - latest,
+            "waiting for pending solver txs to clear before delegation setup"
+        );
+        tokio::time::sleep(POLL_INTERVAL).await;
+    }
+}
diff --git a/crates/driver/src/infra/solver/mod.rs b/crates/driver/src/infra/solver/mod.rs
index 93edc3165f..ec3bcc25ab 100644
--- a/crates/driver/src/infra/solver/mod.rs
+++ b/crates/driver/src/infra/solver/mod.rs
@@ -40,6 +40,7 @@ use {
 };
 
 pub mod dto;
+pub mod eip7702;
 
 // TODO At some point I should be checking that the names are unique, I don't
 // think I'm doing that.
@@ -138,6 +139,25 @@ impl TxSigner<Signature> for Account {
     }
 }
 
+impl Account {
+    /// Sign a hash using the underlying signer. Needed for EIP-7702
+    /// authorization signing which requires `Signer::sign_hash` rather than
+    /// `TxSigner::sign_transaction`.
+    pub async fn sign_hash(
+        &self,
+        hash: &alloy::primitives::B256,
+    ) -> alloy::signers::Result<Signature> {
+        use alloy::signers::Signer;
+        match self {
+            Account::PrivateKey(signer) => signer.sign_hash(hash).await,
+            Account::Kms(signer) => signer.sign_hash(hash).await,
+            Account::Address(_) => Err(alloy::signers::Error::UnsupportedOperation(
+                alloy::signers::UnsupportedSignerOperation::SignHash,
+            )),
+        }
+    }
+}
+
 impl From<PrivateKeySigner> for Account {
     fn from(value: PrivateKeySigner) -> Self {
         Self::PrivateKey(value)
@@ -191,6 +211,13 @@ pub struct Config {
     /// economics to make competition bids more conservative. Does not modify
     /// interaction calldata. Default: 0 (no haircut).
     pub haircut_bps: u32,
+    /// Additional EOAs for parallel settlement submission via EIP-7702.
+    /// When non-empty, these accounts submit txs to the solver EOA (which
+    /// delegates to a forwarder contract), enabling concurrent submissions.
+    pub submission_accounts: Vec<Account>,
+    /// Address of the deployed CowSettlementForwarder contract for EIP-7702
+    /// delegation. Required when `submission_accounts` is non-empty.
+    pub forwarder_contract: Option<eth::Address>,
 }
 
 impl Solver {
@@ -287,6 +314,16 @@ impl Solver {
         self.config.haircut_bps
     }
 
+    /// Additional submission accounts for EIP-7702 parallel settlement.
+    pub fn submission_accounts(&self) -> &[Account] {
+        &self.config.submission_accounts
+    }
+
+    /// Address of the CowSettlementForwarder contract for EIP-7702 delegation.
+    pub fn forwarder_contract(&self) -> Option<eth::Address> {
+        self.config.forwarder_contract
+    }
+
     /// Make a POST request instructing the solver to solve an auction.
     /// Allocates at most `timeout` time for the solving.
     #[instrument(name = "solver_engine", skip_all)]
diff --git a/crates/driver/src/run.rs b/crates/driver/src/run.rs
index 0d1535ed26..dd70e07d30 100644
--- a/crates/driver/src/run.rs
+++ b/crates/driver/src/run.rs
@@ -70,8 +70,17 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
         } => Some(AppDataRetriever::new(orderbook_url.clone(), *cache_size)),
         config::file::AppDataFetching::Disabled => None,
     };
+    let solvers = solvers(&config, &eth).await;
+
+    // Set up EIP-7702 delegation and caller approval for solvers with
+    // parallel submission accounts. Must happen before the HTTP server
+    // starts accepting /settle requests.
+    infra::solver::eip7702::setup(&solvers, &eth)
+        .await
+        .expect("EIP-7702 setup failed");
+
     let serve = Api {
-        solvers: solvers(&config, &eth).await,
+        solvers,
         liquidity: liquidity(&config, &eth).await,
         liquidity_sources_notifier: liquidity_sources_notifier(&config, &eth),
         simulator: simulator(&config, &eth),
@@ -85,7 +94,10 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
                         config
                             .solvers
                             .iter()
-                            .map(|config| config.account.clone())
+                            .flat_map(|config| {
+                                std::iter::once(config.account.clone())
+                                    .chain(config.submission_accounts.iter().cloned())
+                            })
                             .collect(),
                     )
                 })
diff --git a/crates/e2e/src/setup/colocation.rs b/crates/e2e/src/setup/colocation.rs
index 86aa366ba1..54ccde72c2 100644
--- a/crates/e2e/src/setup/colocation.rs
+++ b/crates/e2e/src/setup/colocation.rs
@@ -16,6 +16,11 @@ pub struct SolverEngine {
     pub merge_solutions: bool,
     /// Haircut in basis points (0-10000) for conservative bidding.
     pub haircut_bps: u32,
+    /// Additional EOAs that can submit settlement txs on behalf of the solver
+    /// via EIP-7702 delegation. When non-empty, enables parallel submission.
+    pub submission_keys: Vec<TestAccount>,
+    /// Address of the deployed CowSettlementForwarder contract for EIP-7702.
+    pub forwarder_contract: Option<Address>,
 }
 
 pub async fn start_baseline_solver(
@@ -67,6 +72,8 @@ uni-v3-node-url = "http://localhost:8545"
         base_tokens,
         merge_solutions,
         haircut_bps,
+        submission_keys: vec![],
+        forwarder_contract: None,
     }
 }
 
@@ -157,18 +164,32 @@ pub fn start_driver_with_config_override(
         .collect();
     let solvers = solvers
         .iter()
-        .map(
-            |SolverEngine {
-                 name,
-                 account,
-                 endpoint,
-                 base_tokens: _,
-                 merge_solutions,
-                 haircut_bps,
-             }| {
-                let account = account.signer.to_bytes();
-                format!(
-                    r#"
+        .map(|solver| {
+            let SolverEngine {
+                name,
+                account,
+                endpoint,
+                merge_solutions,
+                haircut_bps,
+                ..
+            } = solver;
+            let account = account.signer.to_bytes();
+            let submission_accounts_line = if solver.submission_keys.is_empty() {
+                String::new()
+            } else {
+                let keys: Vec<String> = solver
+                    .submission_keys
+                    .iter()
+                    .map(|k| format!("\"{}\"", k.signer.to_bytes()))
+                    .collect();
+                let mut line = format!("submission-accounts = [{}]\n", keys.join(", "));
+                if let Some(addr) = solver.forwarder_contract {
+                    line.push_str(&format!("forwarder-contract = \"{addr:?}\"\n"));
+                }
+                line
+            };
+            format!(
+                r#"
 [[solver]]
 name = "{name}"
 endpoint = "{endpoint}"
@@ -181,10 +202,9 @@ enable-metrics-bad-order-detection = true
 http-time-buffer = "100ms"
 solving-share-of-deadline = 1.0
 haircut-bps = {haircut_bps}
-"#
-                )
-            },
-        )
+{submission_accounts_line}"#
+            )
+        })
         .collect::<Vec<String>>()
         .join("\n");
     let liquidity = liquidity.to_string(contracts);
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 723f22b688..d2da87c34c 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -381,6 +381,8 @@ impl<'a> Services<'a> {
             base_tokens: vec![],
             merge_solutions: true,
             haircut_bps: 0,
+            submission_keys: vec![],
+            forwarder_contract: None,
         }];
 
         // Create TOML config files
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index ddf5f2b5c2..60370ee0e8 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -174,6 +174,8 @@ async fn cow_amm_jit(web3: Web3) {
                 base_tokens: vec![],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
@@ -542,6 +544,8 @@ async fn cow_amm_driver_support(web3: Web3) {
                 base_tokens: vec![],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
@@ -823,6 +827,8 @@ async fn cow_amm_opposite_direction(web3: Web3) {
                 base_tokens: vec![],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index fdcb6fef9c..b905ac0fbb 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -80,6 +80,8 @@ async fn single_limit_order_test(web3: Web3) {
                 base_tokens: vec![*token.address()],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index 0461ca5c2f..d2ece2ed7a 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -185,6 +185,8 @@ async fn liquidity_source_notification(web3: Web3) {
                 base_tokens: vec![],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
diff --git a/crates/e2e/tests/e2e/main.rs b/crates/e2e/tests/e2e/main.rs
index 738e30317b..4d5eeb15da 100644
--- a/crates/e2e/tests/e2e/main.rs
+++ b/crates/e2e/tests/e2e/main.rs
@@ -24,6 +24,7 @@ mod liquidity;
 mod liquidity_source_notification;
 mod malformed_requests;
 mod order_cancellation;
+mod parallel_settlement;
 mod partial_fill;
 mod partially_fillable_balance;
 mod partially_fillable_pool;
diff --git a/crates/e2e/tests/e2e/parallel_settlement.rs b/crates/e2e/tests/e2e/parallel_settlement.rs
new file mode 100644
index 0000000000..9e54cc9ee0
--- /dev/null
+++ b/crates/e2e/tests/e2e/parallel_settlement.rs
@@ -0,0 +1,323 @@
+use {
+    ::alloy::{
+        consensus::Transaction as _,
+        primitives::{Address, U256},
+        providers::{Provider, ext::TxPoolApi},
+    },
+    contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
+    e2e::setup::{colocation, *},
+    ethrpc::{
+        Web3,
+        alloy::{CallBuilderExt, EvmProviderExt},
+    },
+    model::{
+        order::{OrderCreation, OrderKind},
+        signature::EcdsaSigningScheme,
+    },
+    number::units::EthUnit,
+    std::time::Duration,
+};
+
+/// Tests that the driver can process two settlement requests concurrently,
+/// resulting in both settlement transactions being pending in the mempool
+/// simultaneously.
+///
+/// Bypasses the autopilot (which settles one solution per auction) and sends
+/// two /solve + /settle requests directly to the driver.
+///
+/// Uses EIP-7702 delegation: a forwarder contract is deployed and the
+/// solver EOA delegates its code to it. Two whitelisted submission accounts
+/// send settlement txs through the solver EOA in parallel, each using their own
+/// nonce.
+#[tokio::test]
+#[ignore]
+async fn local_node_parallel_settlement_submission() {
+    run_test(test_parallel_settlement_submission).await;
+}
+
+async fn test_parallel_settlement_submission(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    // Two submission accounts for parallel settlement via EIP-7702.
+    let [submitter_a, submitter_b] = onchain.make_accounts(10u64.eth()).await;
+
+    // Deploy two independent token pairs so settlements don't conflict on the
+    // same Uniswap pool when mined in the same block.
+    let [token_a, token_b] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    // Fund trader with WETH and approve the vault relayer.
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(5u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 5u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Deploy the settlement forwarder. The driver handles EIP-7702
+    // delegation and caller approval automatically at startup.
+    let forwarder_addr = deploy_forwarder(onchain.web3(), &submitter_a).await;
+
+    // Start driver + baseline solver. Each /solve call is a separate auction
+    // so solutions are independent regardless of merge_solutions.
+    let mut solver_engine = colocation::start_baseline_solver(
+        "test_solver".into(),
+        solver.clone(),
+        *onchain.contracts().weth.address(),
+        vec![],
+        1,
+        false,
+    )
+    .await;
+    solver_engine.submission_keys = vec![submitter_a.clone(), submitter_b.clone()];
+    solver_engine.forwarder_contract = Some(forwarder_addr);
+
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![solver_engine],
+        colocation::LiquidityProvider::UniswapV2,
+        false,
+    );
+
+    // Wait for the driver to become available.
+    let driver_url = "http://localhost:11088/test_solver";
+    wait_for_condition(TIMEOUT, || async {
+        reqwest::get(format!("{driver_url}/healthz")).await.is_ok()
+    })
+    .await
+    .expect("driver did not start in time");
+
+    let valid_to = model::time::now_in_epoch_seconds() + 300;
+    let make_buy_order = |buy_token: Address| {
+        OrderCreation {
+            sell_token: *onchain.contracts().weth.address(),
+            sell_amount: 2u64.eth(),
+            buy_token,
+            buy_amount: 1u64.eth(),
+            valid_to,
+            kind: OrderKind::Buy,
+            ..Default::default()
+        }
+        .sign(
+            EcdsaSigningScheme::Eip712,
+            &onchain.contracts().domain_separator,
+            &trader.signer,
+        )
+    };
+    let order_a = make_buy_order(*token_a.address());
+    let order_b = make_buy_order(*token_b.address());
+
+    onchain.mint_block().await;
+
+    let block_number = web3.provider.get_block_number().await.unwrap();
+    let http = reqwest::Client::builder()
+        .timeout(Duration::from_secs(30))
+        .build()
+        .unwrap();
+
+    // Send /solve for each order as a separate auction. The driver caches
+    // the resulting settlement for each, keyed by (auction_id, solution_id).
+    let solution_id_a =
+        solve_order(&http, driver_url, 1, &order_a, trader.address(), &onchain).await;
+    let solution_id_b =
+        solve_order(&http, driver_url, 2, &order_b, trader.address(), &onchain).await;
+
+    // Disable automine so settlement txs stay pending in the mempool.
+    web3.provider
+        .evm_set_automine(false)
+        .await
+        .expect("Must be able to disable automine");
+
+    // Send both /settle requests concurrently. With parallel submission, both
+    // submission accounts send txs to the solver EOA simultaneously.
+    let submission_deadline = block_number + 100;
+    let settle_url = format!("{driver_url}/settle");
+    let spawn_settle = |auction_id: &'static str, solution_id: u64| {
+        let http = http.clone();
+        let settle_url = settle_url.clone();
+        tokio::spawn(async move {
+            http.post(&settle_url)
+                .json(&serde_json::json!({
+                    "solutionId": solution_id,
+                    "submissionDeadlineLatestBlock": submission_deadline,
+                    "auctionId": auction_id
+                }))
+                .send()
+                .await
+        })
+    };
+    let settle_a = spawn_settle("1", solution_id_a);
+    let settle_b = spawn_settle("2", solution_id_b);
+
+    // Assert that TWO settlement txs are pending simultaneously: one direct
+    // (solver EOA → settlement contract) and one delegated (submission EOA →
+    // solver EOA via EIP-7702 forwarding). The driver uses the direct slot
+    // when no settlement is in flight (cheaper), and falls back to 7702 for
+    // concurrent submissions.
+    let solver_address = solver.address();
+    let settlement_address = *onchain.contracts().gp_settlement.address();
+    let parallel_txs_observed = wait_for_condition(Duration::from_secs(15), || {
+        let web3 = web3.clone();
+        async move {
+            let txpool = web3
+                .provider
+                .txpool_content()
+                .await
+                .expect("must be able to inspect mempool");
+            let pending: Vec<_> = txpool
+                .pending
+                .values()
+                .flat_map(|nonce_map| nonce_map.values())
+                .collect();
+
+            let direct = pending
+                .iter()
+                .filter(|tx| tx.inner.to() == Some(settlement_address))
+                .count();
+            let delegated = pending
+                .iter()
+                .filter(|tx| tx.inner.to() == Some(solver_address))
+                .count();
+
+            tracing::debug!(direct, delegated, "checking for parallel pending txs");
+            direct == 1 && delegated == 1
+        }
+    })
+    .await;
+
+    assert!(
+        parallel_txs_observed.is_ok(),
+        "Expected one direct settlement tx (to settlement contract) and one delegated tx (to \
+         solver EOA via EIP-7702) pending simultaneously."
+    );
+
+    // Re-enable automine and verify both orders get settled.
+    web3.provider
+        .evm_set_automine(true)
+        .await
+        .expect("Must be able to enable automine");
+
+    // Wait for the /settle HTTP calls to complete (they block until mined).
+    assert_settle_success(settle_a.await, "1").await;
+    assert_settle_success(settle_b.await, "2").await;
+
+    for token in [&token_a, &token_b] {
+        wait_for_condition(TIMEOUT, || async {
+            let balance = token.balanceOf(trader.address()).call().await.unwrap();
+            balance > U256::ZERO
+        })
+        .await
+        .unwrap();
+    }
+}
+
+/// Sends a /solve request to the driver for a single order and returns the
+/// solution_id from the response.
+async fn solve_order(
+    http: &reqwest::Client,
+    driver_url: &str,
+    auction_id: i64,
+    order: &OrderCreation,
+    owner: Address,
+    onchain: &OnchainComponents,
+) -> u64 {
+    let weth = onchain.contracts().weth.address();
+    let uid = order
+        .data()
+        .uid(&onchain.contracts().domain_separator, owner);
+    let sig_bytes = order.signature.to_bytes();
+    let deadline = (chrono::Utc::now() + chrono::Duration::seconds(3)).to_rfc3339();
+
+    let response = http
+        .post(format!("{driver_url}/solve"))
+        .header("X-Auction-Id", auction_id.to_string())
+        .json(&serde_json::json!({
+            "id": auction_id.to_string(),
+            "tokens": [
+                {"address": format!("{weth:?}"), "price": "1000000000000000000", "trusted": true},
+                {"address": format!("{:?}", order.buy_token), "price": "1000000000000000000", "trusted": false},
+            ],
+            "orders": [{
+                "uid": format!("{uid}"),
+                "sellToken": format!("{:?}", order.sell_token),
+                "buyToken": format!("{:?}", order.buy_token),
+                "sellAmount": order.sell_amount.to_string(),
+                "buyAmount": order.buy_amount.to_string(),
+                "protocolFees": [],
+                "created": model::time::now_in_epoch_seconds(),
+                "validTo": order.valid_to,
+                "kind": "buy",
+                "receiver": null,
+                "owner": format!("{owner:?}"),
+                "partiallyFillable": false,
+                "executed": "0",
+                "preInteractions": [],
+                "postInteractions": [],
+                "class": "market",
+                "appData": format!("0x{}", const_hex::encode([0u8; 32])),
+                "signingScheme": "eip712",
+                "signature": format!("0x{}", const_hex::encode(&sig_bytes)),
+            }],
+            "deadline": deadline,
+        }))
+        .send()
+        .await
+        .expect("failed to send /solve request");
+
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .expect("failed to read /solve response");
+    assert!(status.is_success(), "/solve failed ({status}): {text}");
+
+    let body: serde_json::Value = serde_json::from_str(&text).expect("invalid JSON from /solve");
+
+    let solution_id = body["solutions"][0]["solutionId"]
+        .as_u64()
+        .unwrap_or_else(|| panic!("no solutionId in /solve response: {text}"));
+
+    tracing::info!(auction_id, solution_id, "solve succeeded");
+    solution_id
+}
+
+async fn assert_settle_success(
+    settle_result: Result<reqwest::Result<reqwest::Response>, tokio::task::JoinError>,
+    auction_id: &str,
+) {
+    let response = settle_result
+        .unwrap_or_else(|err| panic!("/settle task for auction {auction_id} panicked: {err}"))
+        .unwrap_or_else(|err| panic!("/settle request for auction {auction_id} failed: {err}"));
+    let status = response.status();
+    let body = response.text().await.unwrap_or_else(|err| {
+        panic!("failed to read /settle response for auction {auction_id}: {err}")
+    });
+    assert!(
+        status.is_success(),
+        "/settle failed for auction {auction_id} ({status}): {body}"
+    );
+}
+
+/// Deploy the CowSettlementForwarder contract (target-agnostic, with caller
+/// whitelist). No constructor arguments — storage lives in the delegating EOA.
+async fn deploy_forwarder(web3: &Web3, deployer: &TestAccount) -> Address {
+    CowSettlementForwarder::deploy_builder(web3.provider.clone())
+        .from(deployer.address())
+        .deploy()
+        .await
+        .expect("failed to deploy CowSettlementForwarder")
+}
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index c3892c59d4..5444d2d112 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -295,6 +295,8 @@ async fn quote_timeout(web3: Web3) {
                 base_tokens: vec![*sell_token.address()],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
             SolverEngine {
                 name: "test_quoter".into(),
@@ -303,6 +305,8 @@ async fn quote_timeout(web3: Web3) {
                 base_tokens: vec![*sell_token.address()],
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 3d63df23f5..abf2312a54 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -387,6 +387,8 @@ async fn store_filtered_solutions(web3: Web3) {
                 base_tokens: base_tokens.clone(),
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
             SolverEngine {
                 name: "bad_solver".into(),
@@ -395,6 +397,8 @@ async fn store_filtered_solutions(web3: Web3) {
                 base_tokens,
                 merge_solutions: true,
                 haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,

From 209ddc489ee1219b82cca1fe31dcc3a35065f390 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Wed, 4 Mar 2026 12:51:05 +0100
Subject: [PATCH 119/219] Move price estimation into separate crate (#4225)

# Description
Further untangles the `shared` crate.

# Changes
* deletes `bytes.rs` which was forgotten in an old PR
* moved `trade_finding` into `price-estimation`
* move `tenderly_api` arguments from `shared::Arguments` to
`price_estimation::Arguments`
* removed a few dependencies
* downgraded a few dependencies to `dev-dependencies`

new crates split off of `shared`:
	* `gas-price-estimation`
	* `price-estimation`
	* `bad-tokens`

Unfortunately `price-estimation` is relying on a few utils which didn't
make much sense to move into a new crate so I duplicated a few things in
`price_estimation::utils` but I think this does not outweigh the
structure and compile time gained by this PR.

This PR does again not migrate the catch all `alloy` imports to the more
specific sub-crates (e.g. `alloy_primitives`)

## How to test
compiler
---
 Cargo.lock                                    | 117 +++++++++++++++---
 Cargo.toml                                    |   3 +
 crates/autopilot/Cargo.toml                   |   3 +
 crates/autopilot/src/arguments.rs             |   1 -
 crates/autopilot/src/config/mod.rs            |   2 +-
 crates/autopilot/src/config/native_price.rs   |   2 +-
 crates/autopilot/src/infra/api.rs             |   2 +-
 crates/autopilot/src/run.rs                   |  30 +++--
 crates/autopilot/src/solvable_orders.rs       |  36 +++---
 crates/bad-tokens/Cargo.toml                  |  17 +++
 crates/bad-tokens/LICENSE-APACHE              |   1 +
 crates/bad-tokens/LICENSE-MIT                 |   1 +
 .../mod.rs => bad-tokens/src/lib.rs}          |   0
 .../src}/list_based.rs                        |   0
 .../src}/trace_call.rs                        |   0
 crates/driver/Cargo.toml                      |   3 +
 .../driver/src/boundary/liquidity/zeroex.rs   |   7 +-
 .../risk_detector/bad_tokens/simulation.rs    |   2 +-
 crates/driver/src/infra/blockchain/gas.rs     |   2 +-
 crates/driver/src/infra/blockchain/mod.rs     |   3 +-
 crates/driver/src/infra/config/file/mod.rs    |   5 +-
 crates/driver/src/tests/setup/solver.rs       |   2 +-
 crates/e2e/Cargo.toml                         |   1 +
 crates/e2e/src/setup/services.rs              |   6 +-
 crates/e2e/tests/e2e/quote_verification.rs    |  12 +-
 crates/ethrpc/Cargo.toml                      |   7 +-
 crates/event-indexing/Cargo.toml              |   2 +-
 crates/gas-price-estimation/Cargo.toml        |  26 ++++
 crates/gas-price-estimation/LICENSE-APACHE    |   1 +
 crates/gas-price-estimation/LICENSE-MIT       |   1 +
 .../src}/configurable_alloy.rs                |   2 +-
 .../src}/driver.rs                            |   2 +-
 .../src}/eth_node.rs                          |   2 +-
 .../src}/fake.rs                              |   6 +-
 .../src/gas_price.rs                          |   2 +-
 .../src/lib.rs}                               |  24 ++--
 .../src}/priority.rs                          |   8 +-
 crates/liquidity-sources/Cargo.toml           |   2 +-
 crates/orderbook/Cargo.toml                   |   3 +
 crates/orderbook/src/api.rs                   |   2 +-
 crates/orderbook/src/arguments.rs             |   7 +-
 crates/orderbook/src/quoter.rs                |   3 +-
 crates/orderbook/src/run.rs                   |  39 +++---
 crates/price-estimation/Cargo.toml            |  63 ++++++++++
 crates/price-estimation/LICENSE-APACHE        |   1 +
 crates/price-estimation/LICENSE-MIT           |   1 +
 .../src}/buffered.rs                          |   7 +-
 .../src}/competition/mod.rs                   |   5 +-
 .../src}/competition/native.rs                |   4 +-
 .../src}/competition/quote.rs                 |  12 +-
 .../src}/external.rs                          |   5 +-
 .../src}/factory.rs                           |  29 ++---
 .../src}/gas.rs                               |   0
 .../src}/instrumented.rs                      |   4 +-
 .../mod.rs => price-estimation/src/lib.rs}    |  29 ++---
 .../src}/native/coingecko.rs                  |   6 +-
 .../src}/native/fallback.rs                   |  12 +-
 .../src}/native/forwarder.rs                  |   2 +-
 .../src}/native/mod.rs                        |   4 +-
 .../src}/native/oneinch.rs                    |   6 +-
 .../src}/native_price_cache.rs                |   8 +-
 .../src}/sanitized.rs                         |  16 ++-
 .../src/trade_finding/external.rs             |   7 +-
 .../src/trade_finding/mod.rs                  |   9 +-
 .../src/trade_finding/trade_estimator.rs}     |   4 +-
 .../src}/trade_verifier/code_fetching.rs      |   2 +-
 .../src}/trade_verifier/mod.rs                |   8 +-
 .../src}/trade_verifier/tenderly_api.rs       |  13 +-
 crates/price-estimation/src/utils/encoding.rs |  89 +++++++++++++
 .../src/utils/http_client_factory.rs          |  52 ++++++++
 crates/price-estimation/src/utils/mod.rs      |  50 ++++++++
 crates/refunder/Cargo.toml                    |   1 +
 crates/refunder/src/refund_service.rs         |   7 +-
 crates/refunder/src/submitter.rs              |   6 +-
 crates/shared/Cargo.toml                      |   6 +-
 crates/shared/src/arguments.rs                |  12 +-
 crates/shared/src/bytes.rs                    |  30 -----
 crates/shared/src/http_client.rs              |   2 +-
 crates/shared/src/lib.rs                      |   5 -
 crates/shared/src/order_quoting.rs            |  34 ++---
 crates/shared/src/order_validation.rs         |  16 +--
 crates/solvers/Cargo.toml                     |   1 +
 .../src/boundary/liquidity/limit_order.rs     |   2 +-
 crates/solvers/src/infra/config.rs            |   2 +-
 playground/docker-compose.fork.yml            |   2 +-
 playground/docker-compose.non-interactive.yml |   2 +-
 86 files changed, 636 insertions(+), 337 deletions(-)
 create mode 100644 crates/bad-tokens/Cargo.toml
 create mode 120000 crates/bad-tokens/LICENSE-APACHE
 create mode 120000 crates/bad-tokens/LICENSE-MIT
 rename crates/{shared/src/bad_token/mod.rs => bad-tokens/src/lib.rs} (100%)
 rename crates/{shared/src/bad_token => bad-tokens/src}/list_based.rs (100%)
 rename crates/{shared/src/bad_token => bad-tokens/src}/trace_call.rs (100%)
 create mode 100644 crates/gas-price-estimation/Cargo.toml
 create mode 120000 crates/gas-price-estimation/LICENSE-APACHE
 create mode 120000 crates/gas-price-estimation/LICENSE-MIT
 rename crates/{shared/src/gas_price_estimation => gas-price-estimation/src}/configurable_alloy.rs (98%)
 rename crates/{shared/src/gas_price_estimation => gas-price-estimation/src}/driver.rs (98%)
 rename crates/{shared/src/gas_price_estimation => gas-price-estimation/src}/eth_node.rs (96%)
 rename crates/{shared/src/gas_price_estimation => gas-price-estimation/src}/fake.rs (83%)
 rename crates/{shared => gas-price-estimation}/src/gas_price.rs (97%)
 rename crates/{shared/src/gas_price_estimation/mod.rs => gas-price-estimation/src/lib.rs} (89%)
 rename crates/{shared/src/gas_price_estimation => gas-price-estimation/src}/priority.rs (95%)
 create mode 100644 crates/price-estimation/Cargo.toml
 create mode 120000 crates/price-estimation/LICENSE-APACHE
 create mode 120000 crates/price-estimation/LICENSE-MIT
 rename crates/{shared/src/price_estimation => price-estimation/src}/buffered.rs (99%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/competition/mod.rs (99%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/competition/native.rs (99%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/competition/quote.rs (97%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/external.rs (90%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/factory.rs (95%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/gas.rs (100%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/instrumented.rs (99%)
 rename crates/{shared/src/price_estimation/mod.rs => price-estimation/src/lib.rs} (98%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/native/coingecko.rs (98%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/native/fallback.rs (98%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/native/forwarder.rs (98%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/native/mod.rs (97%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/native/oneinch.rs (97%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/native_price_cache.rs (99%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/sanitized.rs (98%)
 rename crates/{shared => price-estimation}/src/trade_finding/external.rs (98%)
 rename crates/{shared => price-estimation}/src/trade_finding/mod.rs (98%)
 rename crates/{shared/src/price_estimation/trade_finder.rs => price-estimation/src/trade_finding/trade_estimator.rs} (97%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/trade_verifier/code_fetching.rs (99%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/trade_verifier/mod.rs (99%)
 rename crates/{shared/src/price_estimation => price-estimation/src}/trade_verifier/tenderly_api.rs (97%)
 create mode 100644 crates/price-estimation/src/utils/encoding.rs
 create mode 100644 crates/price-estimation/src/utils/http_client_factory.rs
 create mode 100644 crates/price-estimation/src/utils/mod.rs
 delete mode 100644 crates/shared/src/bytes.rs

diff --git a/Cargo.lock b/Cargo.lock
index e395671b02..32cdcbbdc4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1210,6 +1210,7 @@ dependencies = [
  "app-data",
  "async-trait",
  "axum 0.8.8",
+ "bad-tokens",
  "bigdecimal",
  "brotli",
  "bytes",
@@ -1226,6 +1227,7 @@ dependencies = [
  "ethrpc",
  "event-indexing",
  "futures",
+ "gas-price-estimation",
  "hex-literal",
  "humantime",
  "humantime-serde",
@@ -1239,6 +1241,7 @@ dependencies = [
  "number",
  "observe",
  "order-validation",
+ "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
@@ -1825,6 +1828,18 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "bad-tokens"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "contracts",
+ "ethrpc",
+ "model",
+ "tracing",
+]
+
 [[package]]
 name = "balance-overrides"
 version = "0.1.0"
@@ -2914,6 +2929,7 @@ dependencies = [
  "app-data",
  "async-trait",
  "axum 0.8.8",
+ "bad-tokens",
  "balance-overrides",
  "bigdecimal",
  "bytes-hex",
@@ -2928,6 +2944,7 @@ dependencies = [
  "ethrpc",
  "event-indexing",
  "futures",
+ "gas-price-estimation",
  "hex-literal",
  "humantime",
  "humantime-serde",
@@ -2940,6 +2957,7 @@ dependencies = [
  "num",
  "number",
  "observe",
+ "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
@@ -3006,6 +3024,7 @@ dependencies = [
  "number",
  "observe",
  "orderbook",
+ "price-estimation",
  "refunder",
  "reqwest 0.13.2",
  "rstest",
@@ -3144,8 +3163,6 @@ dependencies = [
  "const-hex",
  "futures",
  "itertools 0.14.0",
- "jsonrpc-core",
- "mockall",
  "observe",
  "prometheus",
  "prometheus-metric-storage",
@@ -3451,6 +3468,25 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"
 
+[[package]]
+name = "gas-price-estimation"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-trait",
+ "ethrpc",
+ "futures",
+ "mockall",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "reqwest 0.13.2",
+ "tokio",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -4208,21 +4244,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "jsonrpc-core"
-version = "18.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
-dependencies = [
- "futures",
- "futures-executor",
- "futures-util",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
-]
-
 [[package]]
 name = "k256"
 version = "0.13.4"
@@ -5004,6 +5025,7 @@ dependencies = [
  "app-data",
  "async-trait",
  "axum 0.8.8",
+ "bad-tokens",
  "bigdecimal",
  "cached",
  "chain",
@@ -5014,6 +5036,7 @@ dependencies = [
  "database",
  "ethrpc",
  "futures",
+ "gas-price-estimation",
  "hex-literal",
  "humantime",
  "humantime-serde",
@@ -5025,6 +5048,7 @@ dependencies = [
  "number",
  "observe",
  "order-validation",
+ "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
  "reqwest 0.13.2",
@@ -5300,6 +5324,58 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "price-estimation"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "app-data",
+ "arc-swap",
+ "async-trait",
+ "bad-tokens",
+ "balance-overrides",
+ "bigdecimal",
+ "bytes-hex",
+ "cached",
+ "chain",
+ "chrono",
+ "clap",
+ "const-hex",
+ "contracts",
+ "derive_more 1.0.0",
+ "ethrpc",
+ "futures",
+ "gas-price-estimation",
+ "hex-literal",
+ "humantime",
+ "itertools 0.14.0",
+ "maplit",
+ "mockall",
+ "model",
+ "moka",
+ "num",
+ "number",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "rand 0.8.5",
+ "rate-limit",
+ "request-sharing",
+ "reqwest 0.13.2",
+ "rust_decimal",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "testlib",
+ "thiserror 1.0.69",
+ "token-info",
+ "tokio",
+ "toml",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "primitive-types"
 version = "0.12.2"
@@ -5751,6 +5827,7 @@ dependencies = [
  "database",
  "ethrpc",
  "futures",
+ "gas-price-estimation",
  "humantime",
  "mimalloc",
  "mockall",
@@ -6576,6 +6653,7 @@ dependencies = [
  "arc-swap",
  "async-stream",
  "async-trait",
+ "bad-tokens",
  "balance-overrides",
  "bigdecimal",
  "bytes-hex",
@@ -6589,13 +6667,12 @@ dependencies = [
  "database",
  "derive_more 1.0.0",
  "ethrpc",
- "event-indexing",
  "futures",
+ "gas-price-estimation",
  "hex-literal",
  "humantime",
  "indexmap 2.13.0",
  "itertools 0.14.0",
- "liquidity-sources",
  "maplit",
  "mockall",
  "model",
@@ -6604,6 +6681,7 @@ dependencies = [
  "number",
  "observe",
  "order-validation",
+ "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
  "rand 0.8.5",
@@ -6748,6 +6826,7 @@ dependencies = [
  "num",
  "number",
  "observe",
+ "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
  "reqwest 0.13.2",
diff --git a/Cargo.toml b/Cargo.toml
index 618d9cefe7..4333f567d2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,7 @@ account-balances = { path = "crates/account-balances" }
 anyhow = "1.0.100"
 async-trait = "0.1.80"
 axum = "0.8"
+bad-tokens = { path = "crates/bad-tokens" }
 bigdecimal = "0.4"
 cached = { version = "0.49.3", default-features = false }
 chrono = { version = "0.4.38", default-features = false }
@@ -27,6 +28,7 @@ brotli = "8"
 flate2 = "1.0.30"
 futures = "0.3.30"
 const-hex = "1.17.0"
+gas-price-estimation = { path = "crates/gas-price-estimation" }
 hex-literal = "0.4.1"
 http-body = "1"
 http-body-util = "0.1"
@@ -37,6 +39,7 @@ itertools = "0.14"
 maplit = "1.0.2"
 mockall = "0.12.1"
 num = "0.4.3"
+price-estimation = { path = "crates/price-estimation" }
 prometheus = "0.14"
 prometheus-metric-storage = "0.6"
 rand = "0.8.5"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index ff615396be..81157318b3 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -24,6 +24,7 @@ bytes = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 bigdecimal = { workspace = true }
+bad-tokens = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
@@ -34,6 +35,7 @@ database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
+gas-price-estimation = { workspace = true }
 brotli = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
@@ -48,6 +50,7 @@ model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
 order-validation = { workspace = true }
+price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 846cc95468..a429dc4500 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -5,7 +5,6 @@ use {
     shared::{
         arguments::{display_option, display_secret_option},
         http_client,
-        price_estimation::{self},
     },
     std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf, str::FromStr, time::Duration},
     url::Url,
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index 8edce0979c..c13b353458 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -242,7 +242,7 @@ mod tests {
         assert_eq!(s3.bucket, "my-bucket");
         assert_eq!(s3.filename_prefix, "staging/mainnet/");
 
-        use shared::price_estimation::{ExternalSolver, NativePriceEstimator};
+        use price_estimation::{ExternalSolver, NativePriceEstimator};
         assert_eq!(
             config.native_price_estimation.estimators.as_slice(),
             vec![
diff --git a/crates/autopilot/src/config/native_price.rs b/crates/autopilot/src/config/native_price.rs
index 3713d97320..690da03596 100644
--- a/crates/autopilot/src/config/native_price.rs
+++ b/crates/autopilot/src/config/native_price.rs
@@ -1,6 +1,6 @@
 use {
+    price_estimation::NativePriceEstimators,
     serde::{Deserialize, Serialize},
-    shared::price_estimation::NativePriceEstimators,
     std::{num::NonZeroUsize, time::Duration},
 };
 
diff --git a/crates/autopilot/src/infra/api.rs b/crates/autopilot/src/infra/api.rs
index a0651eac99..fd37e6dce9 100644
--- a/crates/autopilot/src/infra/api.rs
+++ b/crates/autopilot/src/infra/api.rs
@@ -9,8 +9,8 @@ use {
     },
     model::quote::NativeTokenPrice,
     observe::tracing::distributed::axum::{make_span, record_trace_id},
+    price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     serde::Deserialize,
-    shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     std::{
         net::SocketAddr,
         ops::RangeInclusive,
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index a201146db6..b3884bc6e5 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -27,6 +27,7 @@ use {
     },
     account_balances::{self, BalanceSimulator},
     alloy::{eips::BlockNumberOrTag, primitives::Address, providers::Provider},
+    bad_tokens::list_based::DenyListedTokens,
     chain::Chain,
     clap::Parser,
     contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
@@ -35,16 +36,15 @@ use {
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::LivenessChecking,
+    price_estimation::{
+        factory::{self, PriceEstimatorFactory},
+        native::NativePriceEstimating,
+        trade_verifier::code_fetching::CachedCodeFetcher,
+    },
     shared::{
         arguments::tracing_config,
-        bad_token::list_based::DenyListedTokens,
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
-        price_estimation::{
-            factory::{self, PriceEstimatorFactory},
-            native::NativePriceEstimating,
-            trade_verifier::code_fetching::CachedCodeFetcher,
-        },
         token_list::{AutoUpdatingTokenList, TokenListConfiguration},
     },
     std::{
@@ -258,8 +258,8 @@ pub async fn run(
     );
 
     let gas_price_estimator = Arc::new(
-        shared::gas_price_estimation::create_priority_estimator(
-            &http_factory,
+        gas_price_estimation::create_priority_estimator(
+            http_factory.create(),
             &web3,
             args.shared.gas_estimators.as_slice(),
         )
@@ -281,7 +281,6 @@ pub async fn run(
 
     let mut price_estimator_factory = PriceEstimatorFactory::new(
         &args.price_estimation,
-        &args.shared,
         factory::Network {
             web3: web3.clone(),
             simulation_web3,
@@ -298,7 +297,9 @@ pub async fn run(
             block_stream: eth.current_block().clone(),
         },
         factory::Components {
-            http_factory: http_factory.clone(),
+            http_factory: price_estimation::utils::http_client_factory::HttpClientFactory::new(
+                http_factory.timeout,
+            ),
             deny_listed_tokens: deny_listed_tokens.clone(),
             tokens: token_info_fetcher.clone(),
             code_fetcher: code_fetcher.clone(),
@@ -310,7 +311,7 @@ pub async fn run(
 
     let weth = eth.contracts().weth().clone();
     let prices = db_write.fetch_latest_prices().await.unwrap();
-    let shared_cache = shared::price_estimation::native_price_cache::Cache::new(
+    let shared_cache = price_estimation::native_price_cache::Cache::new(
         args.price_estimation.native_price_cache_max_age,
         prices,
     );
@@ -341,7 +342,7 @@ pub async fn run(
             )
             .instrument(info_span!("competition_native_price_updater"))
             .await;
-        shared::price_estimation::native_price_cache::NativePriceUpdater::new(
+        price_estimation::native_price_cache::NativePriceUpdater::new(
             caching,
             config.native_price_estimation.cache_refresh_interval,
             config.native_price_estimation.prefetch_time,
@@ -354,7 +355,10 @@ pub async fn run(
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
-                .map(|price_estimator_driver| price_estimator_driver.clone().into())
+                .map(|price_estimator_driver| price_estimation::ExternalSolver {
+                    name: price_estimator_driver.name.clone(),
+                    url: price_estimator_driver.url.clone(),
+                })
                 .collect::<Vec<_>>(),
             api_native_price_estimator.clone(),
             gas_price_estimator.clone(),
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 6782b6304e..f66c86a8ec 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -7,6 +7,7 @@ use {
     account_balances::{BalanceFetching, Query},
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result},
+    bad_tokens::list_based::DenyListedTokens,
     database::order_events::OrderEventLabel,
     futures::FutureExt,
     itertools::Itertools,
@@ -15,15 +16,12 @@ use {
         signature::Signature,
         time::now_in_epoch_seconds,
     },
-    prometheus::{Histogram, HistogramVec, IntCounter, IntCounterVec, IntGauge, IntGaugeVec},
-    shared::{
-        bad_token::list_based::DenyListedTokens,
-        price_estimation::{
-            native::{NativePriceEstimating, to_normalized_price},
-            native_price_cache::NativePriceUpdater,
-        },
-        remaining_amounts,
+    price_estimation::{
+        native::{NativePriceEstimating, to_normalized_price},
+        native_price_cache::NativePriceUpdater,
     },
+    prometheus::{Histogram, HistogramVec, IntCounter, IntCounterVec, IntGauge, IntGaugeVec},
+    shared::remaining_amounts,
     std::{
         collections::{BTreeMap, HashMap, HashSet, btree_map::Entry},
         future::Future,
@@ -691,21 +689,19 @@ mod tests {
     use {
         super::*,
         alloy::primitives::{Address, B256},
+        bad_tokens::list_based::DenyListedTokens,
         futures::FutureExt,
         maplit::{btreemap, hashset},
         model::order::{OrderBuilder, OrderData, OrderMetadata, OrderUid},
-        shared::{
-            bad_token::list_based::DenyListedTokens,
-            price_estimation::{
-                HEALTHY_PRICE_ESTIMATION_TIME,
-                PriceEstimationError,
-                native::MockNativePriceEstimating,
-                native_price_cache::{
-                    ApproximationToken,
-                    Cache,
-                    CachingNativePriceEstimator,
-                    NativePriceUpdater,
-                },
+        price_estimation::{
+            HEALTHY_PRICE_ESTIMATION_TIME,
+            PriceEstimationError,
+            native::MockNativePriceEstimating,
+            native_price_cache::{
+                ApproximationToken,
+                Cache,
+                CachingNativePriceEstimator,
+                NativePriceUpdater,
             },
         },
     };
diff --git a/crates/bad-tokens/Cargo.toml b/crates/bad-tokens/Cargo.toml
new file mode 100644
index 0000000000..eb7932022a
--- /dev/null
+++ b/crates/bad-tokens/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "bad-tokens"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+contracts = { workspace = true }
+ethrpc = { workspace = true }
+model = { workspace = true }
+tracing = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/bad-tokens/LICENSE-APACHE b/crates/bad-tokens/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/bad-tokens/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/bad-tokens/LICENSE-MIT b/crates/bad-tokens/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/bad-tokens/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/bad_token/mod.rs b/crates/bad-tokens/src/lib.rs
similarity index 100%
rename from crates/shared/src/bad_token/mod.rs
rename to crates/bad-tokens/src/lib.rs
diff --git a/crates/shared/src/bad_token/list_based.rs b/crates/bad-tokens/src/list_based.rs
similarity index 100%
rename from crates/shared/src/bad_token/list_based.rs
rename to crates/bad-tokens/src/list_based.rs
diff --git a/crates/shared/src/bad_token/trace_call.rs b/crates/bad-tokens/src/trace_call.rs
similarity index 100%
rename from crates/shared/src/bad_token/trace_call.rs
rename to crates/bad-tokens/src/trace_call.rs
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 2e81d3fef0..d68f96f266 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -21,6 +21,7 @@ app-data = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
 balance-overrides = { workspace = true }
+bad-tokens = { workspace = true }
 bigdecimal = { workspace = true }
 bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
 chain = { workspace = true }
@@ -32,6 +33,7 @@ ethrpc = { workspace = true }
 event-indexing = { workspace = true }
 futures = { workspace = true }
 const-hex = { workspace = true }
+gas-price-estimation = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
@@ -42,6 +44,7 @@ tikv-jemallocator = { workspace = true }
 moka = { workspace = true, features = ["future"] }
 num = { workspace = true }
 number = { workspace = true }
+price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
diff --git a/crates/driver/src/boundary/liquidity/zeroex.rs b/crates/driver/src/boundary/liquidity/zeroex.rs
index 0c4b1c240a..0f98e1207e 100644
--- a/crates/driver/src/boundary/liquidity/zeroex.rs
+++ b/crates/driver/src/boundary/liquidity/zeroex.rs
@@ -8,11 +8,8 @@ use {
     },
     anyhow::anyhow,
     ethrpc::block_stream::CurrentBlockWatcher,
-    shared::{
-        http_client::HttpClientFactory,
-        price_estimation::gas::GAS_PER_ZEROEX_ORDER,
-        zeroex_api::DefaultZeroExApi,
-    },
+    price_estimation::gas::GAS_PER_ZEROEX_ORDER,
+    shared::{http_client::HttpClientFactory, zeroex_api::DefaultZeroExApi},
     solver::{
         liquidity::{LimitOrder, zeroex::ZeroExLiquidity},
         liquidity_collector::LiquidityCollecting,
diff --git a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
index 3f7a03f94d..bca8962520 100644
--- a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
+++ b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
@@ -4,10 +4,10 @@ use {
         domain::competition::{Order, order, risk_detector::Quality},
         infra::{self, observe::metrics},
     },
+    bad_tokens::{TokenQuality, trace_call::TraceCallDetectorRaw},
     futures::FutureExt,
     model::interaction::InteractionData,
     request_sharing::BoxRequestSharing,
-    shared::bad_token::{TokenQuality, trace_call::TraceCallDetectorRaw},
     std::{
         sync::Arc,
         time::{Duration, Instant},
diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index a4d9a48ce3..9fcb40ffd3 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -11,7 +11,7 @@ use {
     alloy::eips::eip1559::Eip1559Estimation,
     anyhow::anyhow,
     ethrpc::Web3,
-    shared::gas_price_estimation::{
+    gas_price_estimation::{
         GasPriceEstimating,
         configurable_alloy::{ConfigurableGasPriceEstimator, EstimatorConfig},
         eth_node::NodeGasPriceEstimator,
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 9cb9e87cfd..5ff65d2dec 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -15,7 +15,8 @@ use {
     balance_overrides::{BalanceOverrides, BalanceOverriding},
     chain::Chain,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
-    shared::{gas_price_estimation::Eip1559EstimationExt, web3},
+    gas_price_estimation::Eip1559EstimationExt,
+    shared::web3,
     std::{fmt, sync::Arc},
     thiserror::Error,
     tracing::{Level, instrument},
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index aec38d605f..79f1428f7b 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -2,14 +2,11 @@ pub use load::load;
 use {
     crate::{domain::eth, infra},
     alloy::{eips::BlockNumberOrTag, primitives::Address},
+    gas_price_estimation::configurable_alloy::{default_past_blocks, default_reward_percentile},
     number::serialization::HexOrDecimalU256,
     reqwest::Url,
     serde::{Deserialize, Deserializer, Serialize},
     serde_with::serde_as,
-    shared::gas_price_estimation::configurable_alloy::{
-        default_past_blocks,
-        default_reward_percentile,
-    },
     solver::solver::Arn,
     std::{collections::HashMap, time::Duration},
 };
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index 99537e8f9d..a9c4061975 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -16,11 +16,11 @@ use {
     alloy::{primitives::Address, signers::local::PrivateKeySigner},
     const_hex::ToHexExt,
     contracts::alloy::ERC20,
+    gas_price_estimation::Eip1559EstimationExt,
     itertools::Itertools,
     number::testing::ApproxEq,
     serde_json::{Value, json},
     serde_with::{DisplayFromStr, serde_as},
-    shared::gas_price_estimation::Eip1559EstimationExt,
     solvers_dto::auction::FlashloanHint,
     std::{
         collections::{HashMap, HashSet},
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index c42b8b30d3..67959b93cf 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -32,6 +32,7 @@ model = { workspace = true, features = ["e2e"] }
 number = { workspace = true }
 observe = { workspace = true }
 orderbook = { workspace = true, features = ["e2e", "test-util"] }
+price-estimation = { workspace = true }
 reqwest = { workspace = true, features = ["blocking", "query"] }
 serde_json = { workspace = true }
 shared = { workspace = true }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index d2da87c34c..2add964cd1 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -20,6 +20,7 @@ use {
         infra::persistence::dto,
     },
     clap::Parser,
+    ethrpc::Web3,
     model::{
         AuctionId,
         order::{CancellationPayload, Order, OrderCreation, OrderUid},
@@ -28,11 +29,8 @@ use {
         solver_competition_v2,
         trade::Trade,
     },
+    price_estimation::{NativePriceEstimator, NativePriceEstimators},
     reqwest::{Client, StatusCode, Url},
-    shared::{
-        price_estimation::{NativePriceEstimator, NativePriceEstimators},
-        web3::Web3,
-    },
     sqlx::Connection,
     std::{
         collections::{HashMap, hash_map::Entry},
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 151229efc9..f0fc867e8a 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -14,15 +14,13 @@ use {
         quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
-    serde_json::json,
-    shared::{
-        price_estimation::{
-            Estimate,
-            Verification,
-            trade_verifier::{PriceQuery, TradeVerifier, TradeVerifying},
-        },
+    price_estimation::{
+        Estimate,
+        Verification,
         trade_finding::{Interaction, LegacyTrade, QuoteExecution, TradeKind},
+        trade_verifier::{PriceQuery, TradeVerifier, TradeVerifying},
     },
+    serde_json::json,
     std::sync::Arc,
 };
 
diff --git a/crates/ethrpc/Cargo.toml b/crates/ethrpc/Cargo.toml
index f500517f1e..4e33cf9ffe 100644
--- a/crates/ethrpc/Cargo.toml
+++ b/crates/ethrpc/Cargo.toml
@@ -17,8 +17,6 @@ async-trait = { workspace = true }
 const-hex = { workspace = true }
 futures = { workspace = true }
 itertools = { workspace = true }
-jsonrpc-core.workspace = true
-mockall = { workspace = true, optional = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
@@ -33,11 +31,8 @@ tower = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
 
-[dev-dependencies]
-mockall = { workspace = true }
-
 [features]
-test-util = ["dep:mockall"]
+test-util = []
 
 [lints]
 workspace = true
diff --git a/crates/event-indexing/Cargo.toml b/crates/event-indexing/Cargo.toml
index fa5b8a1d61..4cc02e0482 100644
--- a/crates/event-indexing/Cargo.toml
+++ b/crates/event-indexing/Cargo.toml
@@ -9,7 +9,6 @@ license = "MIT OR Apache-2.0"
 alloy = { workspace = true }
 async-stream = { workspace = true }
 anyhow = { workspace = true }
-contracts = { workspace = true }
 futures = { workspace = true }
 tracing = { workspace = true }
 ethrpc = { workspace = true }
@@ -22,6 +21,7 @@ prometheus-metric-storage = { workspace = true }
 [dev-dependencies]
 tracing-subscriber = { workspace = true }
 mockall = { workspace = true }
+contracts = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/gas-price-estimation/Cargo.toml b/crates/gas-price-estimation/Cargo.toml
new file mode 100644
index 0000000000..9cfe9521e9
--- /dev/null
+++ b/crates/gas-price-estimation/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "gas-price-estimation"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+ethrpc = { workspace = true }
+futures = { workspace = true }
+reqwest = { workspace = true }
+observe = { workspace = true }
+prometheus = { workspace = true }
+prometheus-metric-storage = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+url = { workspace = true }
+
+[dev-dependencies]
+mockall = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/gas-price-estimation/LICENSE-APACHE b/crates/gas-price-estimation/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/gas-price-estimation/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/gas-price-estimation/LICENSE-MIT b/crates/gas-price-estimation/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/gas-price-estimation/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/gas_price_estimation/configurable_alloy.rs b/crates/gas-price-estimation/src/configurable_alloy.rs
similarity index 98%
rename from crates/shared/src/gas_price_estimation/configurable_alloy.rs
rename to crates/gas-price-estimation/src/configurable_alloy.rs
index 5a0840b257..69bd3877e5 100644
--- a/crates/shared/src/gas_price_estimation/configurable_alloy.rs
+++ b/crates/gas-price-estimation/src/configurable_alloy.rs
@@ -6,7 +6,7 @@
 //! - Reward percentile to use
 
 use {
-    crate::gas_price_estimation::GasPriceEstimating,
+    crate::GasPriceEstimating,
     alloy::{
         eips::{BlockId, BlockNumberOrTag, eip1559::Eip1559Estimation},
         providers::{Provider, utils::eip1559_default_estimator},
diff --git a/crates/shared/src/gas_price_estimation/driver.rs b/crates/gas-price-estimation/src/driver.rs
similarity index 98%
rename from crates/shared/src/gas_price_estimation/driver.rs
rename to crates/gas-price-estimation/src/driver.rs
index 5e1d7b1c16..a2002b9a31 100644
--- a/crates/shared/src/gas_price_estimation/driver.rs
+++ b/crates/gas-price-estimation/src/driver.rs
@@ -1,5 +1,5 @@
 use {
-    crate::gas_price_estimation::GasPriceEstimating,
+    crate::GasPriceEstimating,
     alloy::{
         eips::{BlockId, eip1559::Eip1559Estimation},
         providers::{DynProvider, Provider},
diff --git a/crates/shared/src/gas_price_estimation/eth_node.rs b/crates/gas-price-estimation/src/eth_node.rs
similarity index 96%
rename from crates/shared/src/gas_price_estimation/eth_node.rs
rename to crates/gas-price-estimation/src/eth_node.rs
index fa7fad9508..ff1e4cd780 100644
--- a/crates/shared/src/gas_price_estimation/eth_node.rs
+++ b/crates/gas-price-estimation/src/eth_node.rs
@@ -4,7 +4,7 @@
 //! This approach is ported from the [`cowprotocol/gas-estimation`](https://github.com/cowprotocol/gas-estimation/tree/v0.7.3) crate's legacy estimation.
 
 use {
-    crate::gas_price_estimation::GasPriceEstimating,
+    crate::GasPriceEstimating,
     alloy::{
         eips::{BlockId, eip1559::Eip1559Estimation},
         providers::Provider,
diff --git a/crates/shared/src/gas_price_estimation/fake.rs b/crates/gas-price-estimation/src/fake.rs
similarity index 83%
rename from crates/shared/src/gas_price_estimation/fake.rs
rename to crates/gas-price-estimation/src/fake.rs
index d19facce0f..f93b03bdc2 100644
--- a/crates/shared/src/gas_price_estimation/fake.rs
+++ b/crates/gas-price-estimation/src/fake.rs
@@ -1,8 +1,4 @@
-use {
-    crate::gas_price_estimation::GasPriceEstimating,
-    alloy::eips::eip1559::Eip1559Estimation,
-    anyhow::Result,
-};
+use {crate::GasPriceEstimating, alloy::eips::eip1559::Eip1559Estimation, anyhow::Result};
 
 pub struct FakeGasPriceEstimator(pub Eip1559Estimation);
 
diff --git a/crates/shared/src/gas_price.rs b/crates/gas-price-estimation/src/gas_price.rs
similarity index 97%
rename from crates/shared/src/gas_price.rs
rename to crates/gas-price-estimation/src/gas_price.rs
index 69ec87eaa2..3fb18a20f1 100644
--- a/crates/shared/src/gas_price.rs
+++ b/crates/gas-price-estimation/src/gas_price.rs
@@ -5,7 +5,7 @@
 //! anomalies.
 
 use {
-    crate::gas_price_estimation::GasPriceEstimating,
+    crate::GasPriceEstimating,
     alloy::eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
     anyhow::Result,
 };
diff --git a/crates/shared/src/gas_price_estimation/mod.rs b/crates/gas-price-estimation/src/lib.rs
similarity index 89%
rename from crates/shared/src/gas_price_estimation/mod.rs
rename to crates/gas-price-estimation/src/lib.rs
index e4dcdc772c..81c8d5bdd3 100644
--- a/crates/shared/src/gas_price_estimation/mod.rs
+++ b/crates/gas-price-estimation/src/lib.rs
@@ -2,28 +2,26 @@ pub mod configurable_alloy;
 pub mod driver;
 pub mod eth_node;
 pub mod fake;
+pub mod gas_price;
 pub mod priority;
 
 use {
     crate::{
-        gas_price_estimation::{
-            configurable_alloy::{
-                ConfigurableGasPriceEstimator,
-                EstimatorConfig,
-                default_past_blocks,
-                default_reward_percentile,
-            },
-            eth_node::NodeGasPriceEstimator,
-            priority::PriorityGasPriceEstimating,
+        configurable_alloy::{
+            ConfigurableGasPriceEstimator,
+            EstimatorConfig,
+            default_past_blocks,
+            default_reward_percentile,
         },
-        http_client::HttpClientFactory,
-        web3::Web3,
+        eth_node::NodeGasPriceEstimator,
+        priority::PriorityGasPriceEstimating,
     },
     ::alloy::{
         eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
         providers::Provider,
     },
     anyhow::Result,
+    ethrpc::Web3,
     std::str::FromStr,
     tracing::instrument,
     url::Url,
@@ -72,7 +70,7 @@ impl FromStr for GasEstimatorType {
 
 #[instrument(skip_all)]
 pub async fn create_priority_estimator(
-    http_factory: &HttpClientFactory,
+    http_client: reqwest::Client,
     web3: &Web3,
     estimator_types: &[GasEstimatorType],
 ) -> Result<impl GasPriceEstimating + use<>> {
@@ -84,7 +82,7 @@ pub async fn create_priority_estimator(
         match estimator_type {
             GasEstimatorType::Driver(url) => {
                 estimators.push(Box::new(DriverGasEstimator::new(
-                    http_factory.create(),
+                    http_client.clone(),
                     url.clone(),
                     web3.provider.clone(),
                 )));
diff --git a/crates/shared/src/gas_price_estimation/priority.rs b/crates/gas-price-estimation/src/priority.rs
similarity index 95%
rename from crates/shared/src/gas_price_estimation/priority.rs
rename to crates/gas-price-estimation/src/priority.rs
index c6ad5fca19..d9b89c87dc 100644
--- a/crates/shared/src/gas_price_estimation/priority.rs
+++ b/crates/gas-price-estimation/src/priority.rs
@@ -1,5 +1,5 @@
 use {
-    crate::gas_price_estimation::GasPriceEstimating,
+    crate::GasPriceEstimating,
     alloy::eips::eip1559::Eip1559Estimation,
     anyhow::{Result, anyhow},
     std::{
@@ -75,11 +75,7 @@ impl GasPriceEstimating for PriorityGasPriceEstimating {
 #[cfg(test)]
 mod tests {
     use {
-        crate::gas_price_estimation::{
-            GasPriceEstimating,
-            MockGasPriceEstimating,
-            priority::PriorityGasPriceEstimating,
-        },
+        crate::{GasPriceEstimating, MockGasPriceEstimating, priority::PriorityGasPriceEstimating},
         alloy::eips::eip1559::Eip1559Estimation,
         anyhow::anyhow,
         futures::future::FutureExt,
diff --git a/crates/liquidity-sources/Cargo.toml b/crates/liquidity-sources/Cargo.toml
index 2262fb2a50..b1df3247cf 100644
--- a/crates/liquidity-sources/Cargo.toml
+++ b/crates/liquidity-sources/Cargo.toml
@@ -25,7 +25,6 @@ number = { workspace = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
-regex = { workspace = true }
 request-sharing = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
@@ -40,6 +39,7 @@ tokio = { workspace = true }
 [dev-dependencies]
 mockall = { workspace = true }
 maplit = { workspace = true }
+regex = { workspace = true }
 testlib = { workspace = true }
 token-info = { workspace = true, features = ["test-util"] }
 
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 7a47ff6df0..b839d8f8ae 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -23,6 +23,7 @@ app-data = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
 bigdecimal = { workspace = true }
+bad-tokens = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, features = ["clock"] }
@@ -33,6 +34,7 @@ ethrpc = { workspace = true }
 futures = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
+gas-price-estimation = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 mimalloc = { workspace = true, optional = true }
@@ -43,6 +45,7 @@ num = { workspace = true }
 number = { workspace = true }
 order-validation = { workspace = true }
 observe = { workspace = true }
+price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 1fb9e12ce9..86bbd429ed 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -15,8 +15,8 @@ use {
         routing::{delete, get, post, put},
     },
     observe::tracing::distributed::axum::{make_span, record_trace_id},
+    price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     serde::{Deserialize, Serialize},
-    shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     std::{
         borrow::Cow,
         fmt::Debug,
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index d064b29a23..9cca5bc85a 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,10 +1,7 @@
 use {
+    price_estimation::{self, NativePriceEstimators},
     reqwest::Url,
-    shared::{
-        arguments::display_secret_option,
-        http_client,
-        price_estimation::{self, NativePriceEstimators},
-    },
+    shared::{arguments::display_secret_option, http_client},
     std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf},
 };
 
diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs
index 4201f5a4a6..2e225d1651 100644
--- a/crates/orderbook/src/quoter.rs
+++ b/crates/orderbook/src/quoter.rs
@@ -7,6 +7,7 @@ use {
         order::OrderCreationAppData,
         quote::{OrderQuote, OrderQuoteRequest, OrderQuoteResponse, OrderQuoteSide, PriceQuality},
     },
+    price_estimation::{Verification, trade_finding},
     shared::{
         arguments::TokenBucketFeeOverride,
         fee::VolumeFeePolicy,
@@ -18,8 +19,6 @@ use {
             PartialValidationError,
             PreOrderData,
         },
-        price_estimation::Verification,
-        trade_finding,
     },
     std::sync::Arc,
     thiserror::Error,
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 73c099d14e..7a0e900b25 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -13,6 +13,7 @@ use {
     alloy::providers::Provider,
     anyhow::{Context, Result, anyhow},
     app_data::Validator,
+    bad_tokens::list_based::DenyListedTokens,
     chain::Chain,
     clap::Parser,
     contracts::alloy::{
@@ -23,24 +24,23 @@ use {
         WETH9,
         support::Balances,
     },
+    gas_price_estimation::gas_price::InstrumentedGasEstimator,
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::{DEFAULT_METRICS_PORT, serve_metrics},
     order_validation,
+    price_estimation::{
+        PriceEstimating,
+        QuoteVerificationMode,
+        factory::{self, PriceEstimatorFactory},
+        native::{FallbackNativePriceEstimator, NativePriceEstimating},
+        trade_verifier::code_fetching::CachedCodeFetcher,
+    },
     shared::{
         arguments::tracing_config,
-        bad_token::list_based::DenyListedTokens,
-        gas_price::InstrumentedGasEstimator,
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
         order_validation::{OrderValidPeriodConfiguration, OrderValidator},
-        price_estimation::{
-            PriceEstimating,
-            QuoteVerificationMode,
-            factory::{self, PriceEstimatorFactory},
-            native::{FallbackNativePriceEstimator, NativePriceEstimating},
-            trade_verifier::code_fetching::CachedCodeFetcher,
-        },
         signature_validator,
     },
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
@@ -187,8 +187,8 @@ pub async fn run(args: Arguments, config: Configuration) {
     );
 
     let gas_price_estimator = Arc::new(InstrumentedGasEstimator::new(
-        shared::gas_price_estimation::create_priority_estimator(
-            &http_factory,
+        gas_price_estimation::create_priority_estimator(
+            http_factory.create(),
             &web3,
             args.shared.gas_estimators.as_slice(),
         )
@@ -213,7 +213,6 @@ pub async fn run(args: Arguments, config: Configuration) {
 
     let mut price_estimator_factory = PriceEstimatorFactory::new(
         &args.price_estimation,
-        &args.shared,
         factory::Network {
             web3: web3.clone(),
             simulation_web3,
@@ -228,7 +227,9 @@ pub async fn run(args: Arguments, config: Configuration) {
             block_stream: current_block_stream.clone(),
         },
         factory::Components {
-            http_factory: http_factory.clone(),
+            http_factory: price_estimation::utils::http_client_factory::HttpClientFactory::new(
+                http_factory.timeout,
+            ),
             deny_listed_tokens: deny_listed_tokens.clone(),
             tokens: token_info_fetcher.clone(),
             code_fetcher: code_fetcher.clone(),
@@ -238,7 +239,7 @@ pub async fn run(args: Arguments, config: Configuration) {
     .expect("failed to initialize price estimator factory");
 
     let prices = postgres_write.fetch_latest_prices().await.unwrap();
-    let cache = shared::price_estimation::native_price_cache::Cache::new(
+    let cache = price_estimation::native_price_cache::Cache::new(
         args.price_estimation.native_price_cache_max_age,
         prices,
     );
@@ -278,7 +279,10 @@ pub async fn run(args: Arguments, config: Configuration) {
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
-                .map(|price_estimator| price_estimator.clone().into())
+                .map(|price_estimator_driver| price_estimation::ExternalSolver {
+                    name: price_estimator_driver.name.clone(),
+                    url: price_estimator_driver.url.clone(),
+                })
                 .collect::<Vec<_>>(),
             native_price_estimator.clone(),
             gas_price_estimator.clone(),
@@ -290,7 +294,10 @@ pub async fn run(args: Arguments, config: Configuration) {
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
-                .map(|price_estimator| price_estimator.clone().into())
+                .map(|price_estimator_driver| price_estimation::ExternalSolver {
+                    name: price_estimator_driver.name.clone(),
+                    url: price_estimator_driver.url.clone(),
+                })
                 .collect::<Vec<_>>(),
             args.fast_price_estimation_results_required,
             native_price_estimator.clone(),
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
new file mode 100644
index 0000000000..0dbaa1a305
--- /dev/null
+++ b/crates/price-estimation/Cargo.toml
@@ -0,0 +1,63 @@
+[package]
+name = "price-estimation"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+app-data = { workspace = true }
+anyhow = { workspace = true }
+arc-swap = { workspace = true }
+async-trait = { workspace = true }
+bad-tokens = { workspace = true }
+balance-overrides = { workspace = true }
+bigdecimal = { workspace = true }
+bytes-hex = { workspace = true }
+const-hex = { workspace = true }
+contracts = { workspace = true }
+cached = { workspace = true }
+chain = { workspace = true }
+chrono = { workspace = true }
+clap = { workspace = true }
+derive_more = { workspace = true }
+ethrpc = { workspace = true }
+futures = { workspace = true }
+gas-price-estimation = { workspace = true }
+humantime = { workspace = true }
+itertools = { workspace = true }
+mockall = { workspace = true, optional = true }
+model = { workspace = true }
+moka = { workspace = true }
+num = { workspace = true }
+number = { workspace = true }
+observe = { workspace = true }
+prometheus = { workspace = true }
+prometheus-metric-storage = { workspace = true }
+rand = { workspace = true }
+rate-limit = { workspace = true }
+reqwest = { workspace = true }
+request-sharing = { workspace = true }
+rust_decimal = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+serde_with = { workspace = true }
+thiserror = { workspace = true }
+token-info = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+url = { workspace = true }
+
+[dev-dependencies]
+hex-literal = { workspace = true }
+maplit = { workspace = true }
+mockall = { workspace = true }
+testlib = { workspace = true }
+toml = { workspace = true }
+
+[features]
+test-util = ["dep:mockall"]
+
+[lints]
+workspace = true
diff --git a/crates/price-estimation/LICENSE-APACHE b/crates/price-estimation/LICENSE-APACHE
new file mode 120000
index 0000000000..6b579aae20
--- /dev/null
+++ b/crates/price-estimation/LICENSE-APACHE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/price-estimation/LICENSE-MIT b/crates/price-estimation/LICENSE-MIT
new file mode 120000
index 0000000000..7f9a88ec80
--- /dev/null
+++ b/crates/price-estimation/LICENSE-MIT
@@ -0,0 +1 @@
+LICENSE-MIT
\ No newline at end of file
diff --git a/crates/shared/src/price_estimation/buffered.rs b/crates/price-estimation/src/buffered.rs
similarity index 99%
rename from crates/shared/src/price_estimation/buffered.rs
rename to crates/price-estimation/src/buffered.rs
index 62fe21cd15..6cebf2e974 100644
--- a/crates/shared/src/price_estimation/buffered.rs
+++ b/crates/price-estimation/src/buffered.rs
@@ -2,7 +2,7 @@
 //! requests into batches.
 
 use {
-    crate::price_estimation::{
+    crate::{
         PriceEstimationError,
         native::{NativePriceEstimateResult, NativePriceEstimating},
     },
@@ -250,10 +250,7 @@ where
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{
-            HEALTHY_PRICE_ESTIMATION_TIME,
-            native::MockNativePriceEstimating,
-        },
+        crate::{HEALTHY_PRICE_ESTIMATION_TIME, native::MockNativePriceEstimating},
         futures::future::try_join_all,
         num::ToPrimitive,
         tokio::time::sleep,
diff --git a/crates/shared/src/price_estimation/competition/mod.rs b/crates/price-estimation/src/competition/mod.rs
similarity index 99%
rename from crates/shared/src/price_estimation/competition/mod.rs
rename to crates/price-estimation/src/competition/mod.rs
index a8e4d1f32c..949345f043 100644
--- a/crates/shared/src/price_estimation/competition/mod.rs
+++ b/crates/price-estimation/src/competition/mod.rs
@@ -1,10 +1,11 @@
 use {
     super::{QuoteVerificationMode, native::NativePriceEstimating},
-    crate::{gas_price_estimation::GasPriceEstimating, price_estimation::PriceEstimationError},
+    crate::PriceEstimationError,
     futures::{
         future::{BoxFuture, FutureExt},
         stream::{FuturesUnordered, StreamExt},
     },
+    gas_price_estimation::GasPriceEstimating,
     model::order::OrderKind,
     std::{
         cmp::Ordering,
@@ -240,7 +241,7 @@ pub enum PriceRanking {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{
+        crate::{
             Estimate,
             HEALTHY_PRICE_ESTIMATION_TIME,
             MockPriceEstimating,
diff --git a/crates/shared/src/price_estimation/competition/native.rs b/crates/price-estimation/src/competition/native.rs
similarity index 99%
rename from crates/shared/src/price_estimation/competition/native.rs
rename to crates/price-estimation/src/competition/native.rs
index 2c987362c0..8292199a61 100644
--- a/crates/shared/src/price_estimation/competition/native.rs
+++ b/crates/price-estimation/src/competition/native.rs
@@ -1,6 +1,6 @@
 use {
     super::{CompetitionEstimator, compare_error},
-    crate::price_estimation::{
+    crate::{
         PriceEstimationError,
         native::{NativePriceEstimateResult, NativePriceEstimating, is_price_malformed},
     },
@@ -76,7 +76,7 @@ fn compare_native_result(
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{
+        crate::{
             HEALTHY_PRICE_ESTIMATION_TIME,
             competition::PriceRanking,
             native::MockNativePriceEstimating,
diff --git a/crates/shared/src/price_estimation/competition/quote.rs b/crates/price-estimation/src/competition/quote.rs
similarity index 97%
rename from crates/shared/src/price_estimation/competition/quote.rs
rename to crates/price-estimation/src/competition/quote.rs
index 2caa30c786..9657b5c096 100644
--- a/crates/shared/src/price_estimation/competition/quote.rs
+++ b/crates/price-estimation/src/competition/quote.rs
@@ -1,6 +1,6 @@
 use {
     super::{CompetitionEstimator, PriceRanking, compare_error},
-    crate::price_estimation::{
+    crate::{
         Estimate,
         PriceEstimateResult,
         PriceEstimating,
@@ -160,15 +160,9 @@ impl RankingContext {
 mod tests {
     use {
         super::*,
-        crate::{
-            gas_price_estimation::FakeGasPriceEstimator,
-            price_estimation::{
-                MockPriceEstimating,
-                QuoteVerificationMode,
-                native::MockNativePriceEstimating,
-            },
-        },
+        crate::{MockPriceEstimating, QuoteVerificationMode, native::MockNativePriceEstimating},
         alloy::{eips::eip1559::Eip1559Estimation, primitives::U256},
+        gas_price_estimation::FakeGasPriceEstimator,
         model::order::OrderKind,
     };
 
diff --git a/crates/shared/src/price_estimation/external.rs b/crates/price-estimation/src/external.rs
similarity index 90%
rename from crates/shared/src/price_estimation/external.rs
rename to crates/price-estimation/src/external.rs
index 1fe216d4c9..cbb00d38d5 100644
--- a/crates/shared/src/price_estimation/external.rs
+++ b/crates/price-estimation/src/external.rs
@@ -1,12 +1,11 @@
 use {
-    super::{
+    crate::{
         PriceEstimateResult,
         PriceEstimating,
         Query,
-        trade_finder::TradeEstimator,
+        trade_finding::{external::ExternalTradeFinder, trade_estimator::TradeEstimator},
         trade_verifier::TradeVerifying,
     },
-    crate::trade_finding::external::ExternalTradeFinder,
     ethrpc::block_stream::CurrentBlockWatcher,
     rate_limit::RateLimiter,
     reqwest::{Client, Url},
diff --git a/crates/shared/src/price_estimation/factory.rs b/crates/price-estimation/src/factory.rs
similarity index 95%
rename from crates/shared/src/price_estimation/factory.rs
rename to crates/price-estimation/src/factory.rs
index bf4922d7bf..e618b17b6b 100644
--- a/crates/shared/src/price_estimation/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -12,24 +12,18 @@ use {
         trade_verifier::{TradeVerifier, TradeVerifying},
     },
     crate::{
-        arguments,
-        bad_token::list_based::DenyListedTokens,
-        gas_price_estimation::GasPriceEstimating,
-        http_client::HttpClientFactory,
-        price_estimation::{
-            ExternalSolver,
-            buffered::{self, BufferedRequest, NativePriceBatchFetching},
-            competition::PriceRanking,
-            trade_verifier::{
-                code_fetching::CachedCodeFetcher,
-                tenderly_api::TenderlyCodeSimulator,
-            },
-        },
+        ExternalSolver,
+        buffered::{self, BufferedRequest, NativePriceBatchFetching},
+        competition::PriceRanking,
+        trade_verifier::{code_fetching::CachedCodeFetcher, tenderly_api::TenderlyCodeSimulator},
+        utils::http_client_factory::HttpClientFactory,
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
+    bad_tokens::list_based::DenyListedTokens,
     contracts::alloy::WETH9,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
+    gas_price_estimation::GasPriceEstimating,
     number::nonzero::NonZeroU256,
     rate_limit::RateLimiter,
     reqwest::Url,
@@ -75,12 +69,11 @@ pub struct Components {
 impl<'a> PriceEstimatorFactory<'a> {
     pub async fn new(
         args: &'a Arguments,
-        shared_args: &'a arguments::Arguments,
         network: Network,
         components: Components,
     ) -> Result<Self> {
         Ok(Self {
-            trade_verifier: Self::trade_verifier(args, shared_args, &network, &components).await?,
+            trade_verifier: Self::trade_verifier(args, &network, &components).await?,
             args,
             network,
             components,
@@ -90,7 +83,6 @@ impl<'a> PriceEstimatorFactory<'a> {
 
     async fn trade_verifier(
         args: &'a Arguments,
-        shared_args: &arguments::Arguments,
         network: &Network,
         components: &Components,
     ) -> Result<Option<Arc<dyn TradeVerifying>>> {
@@ -99,7 +91,7 @@ impl<'a> PriceEstimatorFactory<'a> {
         };
         let web3 = web3.labeled("simulator");
 
-        let tenderly = shared_args
+        let tenderly = args
             .tenderly
             .get_api_instance(&components.http_factory, "price_estimation".to_owned())
             .unwrap()
@@ -225,7 +217,8 @@ impl<'a> PriceEstimatorFactory<'a> {
             NativePriceEstimatorSource::CoinGecko => {
                 anyhow::ensure!(
                     self.args.coin_gecko.coin_gecko_api_key.is_some(),
-                    "coin_gecko_api_key must be set when CoinGecko is used as native price                     estimator"
+                    "coin_gecko_api_key must be set when CoinGecko is used as native price \
+                     estimator"
                 );
 
                 let name = "CoinGecko".to_string();
diff --git a/crates/shared/src/price_estimation/gas.rs b/crates/price-estimation/src/gas.rs
similarity index 100%
rename from crates/shared/src/price_estimation/gas.rs
rename to crates/price-estimation/src/gas.rs
diff --git a/crates/shared/src/price_estimation/instrumented.rs b/crates/price-estimation/src/instrumented.rs
similarity index 99%
rename from crates/shared/src/price_estimation/instrumented.rs
rename to crates/price-estimation/src/instrumented.rs
index 6a23c4cd22..0729a9ba2e 100644
--- a/crates/shared/src/price_estimation/instrumented.rs
+++ b/crates/price-estimation/src/instrumented.rs
@@ -1,5 +1,5 @@
 use {
-    crate::price_estimation::{
+    crate::{
         PriceEstimating,
         PriceEstimationError,
         Query,
@@ -122,7 +122,7 @@ struct Metrics {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{
+        crate::{
             Estimate,
             HEALTHY_PRICE_ESTIMATION_TIME,
             MockPriceEstimating,
diff --git a/crates/shared/src/price_estimation/mod.rs b/crates/price-estimation/src/lib.rs
similarity index 98%
rename from crates/shared/src/price_estimation/mod.rs
rename to crates/price-estimation/src/lib.rs
index 63cc5743aa..32c5ebafc5 100644
--- a/crates/shared/src/price_estimation/mod.rs
+++ b/crates/price-estimation/src/lib.rs
@@ -1,11 +1,11 @@
 use {
     crate::{
-        arguments::{self, display_option, display_secret_option},
         trade_finding::{Interaction, QuoteExecution},
+        trade_verifier::tenderly_api,
+        utils::{display_option, display_secret_option},
     },
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result, ensure},
-    balance_overrides,
     bigdecimal::BigDecimal,
     futures::future::BoxFuture,
     itertools::Itertools,
@@ -36,8 +36,9 @@ pub mod instrumented;
 pub mod native;
 pub mod native_price_cache;
 pub mod sanitized;
-pub mod trade_finder;
+pub mod trade_finding;
 pub mod trade_verifier;
+pub mod utils;
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
@@ -54,15 +55,6 @@ pub struct ExternalSolver {
     pub url: Url,
 }
 
-impl From<arguments::ExternalSolver> for ExternalSolver {
-    fn from(value: arguments::ExternalSolver) -> Self {
-        Self {
-            name: value.name,
-            url: value.url,
-        }
-    }
-}
-
 impl FromStr for ExternalSolver {
     type Err = anyhow::Error;
 
@@ -172,6 +164,9 @@ impl FromStr for NativePriceEstimator {
 #[derive(clap::Parser)]
 #[group(skip)]
 pub struct Arguments {
+    #[clap(flatten)]
+    pub tenderly: tenderly_api::Arguments,
+
     /// Configures the back off strategy for price estimators when requests take
     /// too long. Requests issued while back off is active get dropped
     /// entirely. Needs to be passed as
@@ -345,6 +340,7 @@ pub enum QuoteVerificationMode {
 impl Display for Arguments {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         let Self {
+            tenderly,
             price_estimation_rate_limiter,
             native_price_cache_max_age,
             native_price_cache_concurrent_requests,
@@ -361,6 +357,7 @@ impl Display for Arguments {
             tokens_without_verification,
         } = self;
 
+        write!(f, "{tenderly}")?;
         display_option(
             f,
             "price_estimation_rate_limites",
@@ -469,8 +466,12 @@ impl Clone for PriceEstimationError {
                 Self::UnsupportedOrderType(order_type.clone())
             }
             Self::RateLimited => Self::RateLimited,
-            Self::EstimatorInternal(err) => Self::EstimatorInternal(crate::clone_anyhow_error(err)),
-            Self::ProtocolInternal(err) => Self::ProtocolInternal(crate::clone_anyhow_error(err)),
+            Self::EstimatorInternal(err) => {
+                Self::EstimatorInternal(crate::utils::clone_anyhow_error(err))
+            }
+            Self::ProtocolInternal(err) => {
+                Self::ProtocolInternal(crate::utils::clone_anyhow_error(err))
+            }
         }
     }
 }
diff --git a/crates/shared/src/price_estimation/native/coingecko.rs b/crates/price-estimation/src/native/coingecko.rs
similarity index 98%
rename from crates/shared/src/price_estimation/native/coingecko.rs
rename to crates/price-estimation/src/native/coingecko.rs
index 2234f5cecd..40019f47d7 100644
--- a/crates/shared/src/price_estimation/native/coingecko.rs
+++ b/crates/price-estimation/src/native/coingecko.rs
@@ -1,6 +1,6 @@
 use {
     super::{NativePriceEstimateResult, NativePriceEstimating},
-    crate::price_estimation::{PriceEstimationError, buffered::NativePriceBatchFetching},
+    crate::{PriceEstimationError, buffered::NativePriceBatchFetching},
     alloy::primitives::Address,
     anyhow::{Context, Result, anyhow},
     chain::Chain,
@@ -101,7 +101,7 @@ impl CoinGecko {
         tokens: &HashSet<Token>,
         timeout: Duration,
     ) -> Result<HashMap<Token, f64>, PriceEstimationError> {
-        let mut url = crate::url::join(&self.base_url, &self.chain);
+        let mut url = crate::utils::join_url(&self.base_url, &self.chain);
         metrics::batch_size(tokens.len());
         // Sort to make the token order deterministic for better caching on CoinGecko
         // egress proxy which needs the URL to be the same for cache to be hit
@@ -317,7 +317,7 @@ mod metrics {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::HEALTHY_PRICE_ESTIMATION_TIME,
+        crate::HEALTHY_PRICE_ESTIMATION_TIME,
         alloy::primitives::address,
         std::env,
         token_info::{MockTokenInfoFetching, TokenInfo},
diff --git a/crates/shared/src/price_estimation/native/fallback.rs b/crates/price-estimation/src/native/fallback.rs
similarity index 98%
rename from crates/shared/src/price_estimation/native/fallback.rs
rename to crates/price-estimation/src/native/fallback.rs
index 0e83aa7727..d67e5aba9f 100644
--- a/crates/shared/src/price_estimation/native/fallback.rs
+++ b/crates/price-estimation/src/native/fallback.rs
@@ -30,8 +30,10 @@
 //! the switch. Domain errors like `NoLiquidity` do not affect the state.
 
 use {
-    super::{NativePriceEstimateResult, NativePriceEstimating},
-    crate::price_estimation::PriceEstimationError,
+    crate::{
+        PriceEstimationError,
+        native::{NativePriceEstimateResult, NativePriceEstimating},
+    },
     alloy::primitives::Address,
     futures::{FutureExt, future::BoxFuture},
     std::{
@@ -224,11 +226,7 @@ impl NativePriceEstimating for FallbackNativePriceEstimator {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::price_estimation::native::MockNativePriceEstimating,
-        futures::FutureExt,
-    };
+    use {super::*, crate::native::MockNativePriceEstimating, futures::FutureExt};
 
     const TOKEN: Address = Address::with_last_byte(1);
     const TIMEOUT: Duration = Duration::from_secs(5);
diff --git a/crates/shared/src/price_estimation/native/forwarder.rs b/crates/price-estimation/src/native/forwarder.rs
similarity index 98%
rename from crates/shared/src/price_estimation/native/forwarder.rs
rename to crates/price-estimation/src/native/forwarder.rs
index b3f0d71bb3..99198eb2c9 100644
--- a/crates/shared/src/price_estimation/native/forwarder.rs
+++ b/crates/price-estimation/src/native/forwarder.rs
@@ -6,7 +6,7 @@
 
 use {
     super::{NativePriceEstimateResult, NativePriceEstimating},
-    crate::price_estimation::PriceEstimationError,
+    crate::PriceEstimationError,
     alloy::primitives::Address,
     anyhow::Context,
     futures::{FutureExt, future::BoxFuture},
diff --git a/crates/shared/src/price_estimation/native/mod.rs b/crates/price-estimation/src/native/mod.rs
similarity index 97%
rename from crates/shared/src/price_estimation/native/mod.rs
rename to crates/price-estimation/src/native/mod.rs
index b70e45ee8b..f39dd7666c 100644
--- a/crates/shared/src/price_estimation/native/mod.rs
+++ b/crates/price-estimation/src/native/mod.rs
@@ -1,5 +1,5 @@
 use {
-    crate::price_estimation::{PriceEstimating, PriceEstimationError, Query},
+    crate::{PriceEstimating, PriceEstimationError, Query},
     alloy::primitives::Address,
     bigdecimal::{BigDecimal, ToPrimitive},
     futures::FutureExt,
@@ -135,7 +135,7 @@ pub(crate) fn is_price_malformed(price: f64) -> bool {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{Estimate, HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
+        crate::{Estimate, HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
         alloy::primitives::{Address, U256},
         std::str::FromStr,
     };
diff --git a/crates/shared/src/price_estimation/native/oneinch.rs b/crates/price-estimation/src/native/oneinch.rs
similarity index 97%
rename from crates/shared/src/price_estimation/native/oneinch.rs
rename to crates/price-estimation/src/native/oneinch.rs
index d6776ea45c..155d77c0e3 100644
--- a/crates/shared/src/price_estimation/native/oneinch.rs
+++ b/crates/price-estimation/src/native/oneinch.rs
@@ -1,6 +1,6 @@
 use {
     super::{NativePrice, NativePriceEstimateResult, NativePriceEstimating},
-    crate::price_estimation::PriceEstimationError,
+    crate::PriceEstimationError,
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result, anyhow},
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
@@ -115,7 +115,7 @@ async fn get_current_prices(
     chain: u64,
     token_info: &dyn TokenInfoFetching,
 ) -> Result<HashMap<Token, f64>> {
-    let url = crate::url::join(&base_url, &format!("/price/v1.1/{chain}"));
+    let url = crate::utils::join_url(&base_url, &format!("/price/v1.1/{chain}"));
     let mut builder = client.get(url);
     if let Some(api_key) = api_key {
         builder = builder.header(AUTHORIZATION, api_key)
@@ -162,7 +162,7 @@ async fn get_current_prices(
 mod tests {
     use {
         super::*,
-        crate::price_estimation::HEALTHY_PRICE_ESTIMATION_TIME,
+        crate::HEALTHY_PRICE_ESTIMATION_TIME,
         alloy::primitives::address,
         std::env,
         token_info::{MockTokenInfoFetching, TokenInfo},
diff --git a/crates/shared/src/price_estimation/native_price_cache.rs b/crates/price-estimation/src/native_price_cache.rs
similarity index 99%
rename from crates/shared/src/price_estimation/native_price_cache.rs
rename to crates/price-estimation/src/native_price_cache.rs
index da3bd6dda0..b06758cb5c 100644
--- a/crates/shared/src/price_estimation/native_price_cache.rs
+++ b/crates/price-estimation/src/native_price_cache.rs
@@ -1,10 +1,6 @@
 use {
     super::PriceEstimationError,
-    crate::price_estimation::native::{
-        NativePriceEstimateResult,
-        NativePriceEstimating,
-        from_normalized_price,
-    },
+    crate::native::{NativePriceEstimateResult, NativePriceEstimating, from_normalized_price},
     alloy::primitives::Address,
     arc_swap::ArcSwap,
     bigdecimal::BigDecimal,
@@ -536,7 +532,7 @@ impl NativePriceEstimating for NativePriceUpdater {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{
+        crate::{
             HEALTHY_PRICE_ESTIMATION_TIME,
             PriceEstimationError,
             native::{MockNativePriceEstimating, NativePriceEstimating},
diff --git a/crates/shared/src/price_estimation/sanitized.rs b/crates/price-estimation/src/sanitized.rs
similarity index 98%
rename from crates/shared/src/price_estimation/sanitized.rs
rename to crates/price-estimation/src/sanitized.rs
index 48ecfd70aa..6cf787c4f0 100644
--- a/crates/shared/src/price_estimation/sanitized.rs
+++ b/crates/price-estimation/src/sanitized.rs
@@ -1,16 +1,14 @@
 use {
     crate::{
-        bad_token::list_based::DenyListedTokens,
-        price_estimation::{
-            Estimate,
-            PriceEstimating,
-            PriceEstimationError,
-            Query,
-            gas::{GAS_PER_WETH_UNWRAP, GAS_PER_WETH_WRAP},
-        },
+        Estimate,
+        PriceEstimating,
+        PriceEstimationError,
+        Query,
+        gas::{GAS_PER_WETH_UNWRAP, GAS_PER_WETH_WRAP},
     },
     alloy::primitives::Address,
     anyhow::anyhow,
+    bad_tokens::list_based::DenyListedTokens,
     futures::FutureExt,
     model::order::BUY_ETH_ADDRESS,
     std::sync::Arc,
@@ -152,7 +150,7 @@ impl PriceEstimating for SanitizedPriceEstimator {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::{HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
+        crate::{HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
         alloy::primitives::{Address, U256 as AlloyU256},
         model::order::OrderKind,
         number::nonzero::NonZeroU256,
diff --git a/crates/shared/src/trade_finding/external.rs b/crates/price-estimation/src/trade_finding/external.rs
similarity index 98%
rename from crates/shared/src/trade_finding/external.rs
rename to crates/price-estimation/src/trade_finding/external.rs
index 83ff09086e..5be81eb3c1 100644
--- a/crates/shared/src/trade_finding/external.rs
+++ b/crates/price-estimation/src/trade_finding/external.rs
@@ -2,7 +2,8 @@
 
 use {
     crate::{
-        price_estimation::{PriceEstimationError, Query},
+        PriceEstimationError,
+        Query,
         trade_finding::{
             Interaction,
             LegacyTrade,
@@ -44,7 +45,7 @@ pub struct ExternalTradeFinder {
 impl ExternalTradeFinder {
     pub fn new(driver: Url, client: Client, block_stream: CurrentBlockWatcher) -> Self {
         Self {
-            quote_endpoint: crate::url::join(&driver, "quote"),
+            quote_endpoint: crate::utils::join_url(&driver, "quote"),
             sharing: RequestSharing::labelled(format!("tradefinder_{driver}")),
             client,
             block_stream,
@@ -232,7 +233,7 @@ impl TradeFinding for ExternalTradeFinder {
     }
 }
 
-pub(crate) mod dto {
+pub mod dto {
     use {
         alloy::primitives::{Address, U256},
         app_data::AppDataHash,
diff --git a/crates/shared/src/trade_finding/mod.rs b/crates/price-estimation/src/trade_finding/mod.rs
similarity index 98%
rename from crates/shared/src/trade_finding/mod.rs
rename to crates/price-estimation/src/trade_finding/mod.rs
index 812e53141e..f9f0c490a0 100644
--- a/crates/shared/src/trade_finding/mod.rs
+++ b/crates/price-estimation/src/trade_finding/mod.rs
@@ -2,15 +2,14 @@
 //! for a specified token pair and amount.
 
 pub mod external;
+pub mod trade_estimator;
 
 use {
-    crate::{
-        price_estimation::{PriceEstimationError, Query},
-        trade_finding::external::dto,
-    },
+    crate::{PriceEstimationError, Query},
     alloy::primitives::{Address, Bytes, U256},
     anyhow::{Context, Result},
     derive_more::Debug,
+    external::dto,
     model::{interaction::InteractionData, order::OrderKind},
     num::CheckedDiv,
     number::{conversions::big_rational_to_u256, u256_ext::U256Ext},
@@ -281,7 +280,7 @@ impl Clone for TradeError {
             }
             Self::DeadlineExceeded => Self::DeadlineExceeded,
             Self::RateLimited => Self::RateLimited,
-            Self::Other(err) => Self::Other(crate::clone_anyhow_error(err)),
+            Self::Other(err) => Self::Other(crate::utils::clone_anyhow_error(err)),
         }
     }
 }
diff --git a/crates/shared/src/price_estimation/trade_finder.rs b/crates/price-estimation/src/trade_finding/trade_estimator.rs
similarity index 97%
rename from crates/shared/src/price_estimation/trade_finder.rs
rename to crates/price-estimation/src/trade_finding/trade_estimator.rs
index d1bd4f1003..f80cdf1a72 100644
--- a/crates/shared/src/price_estimation/trade_finder.rs
+++ b/crates/price-estimation/src/trade_finding/trade_estimator.rs
@@ -2,16 +2,16 @@
 //! from an inner `TradeFinding`.
 
 use {
-    super::{
+    crate::{
         Estimate,
         PriceEstimateResult,
         PriceEstimating,
         PriceEstimationError,
         Query,
         rate_limited,
+        trade_finding::{TradeError, TradeFinding},
         trade_verifier::{PriceQuery, TradeVerifying},
     },
-    crate::trade_finding::{TradeError, TradeFinding},
     anyhow::{Result, anyhow},
     futures::future::FutureExt,
     rate_limit::RateLimiter,
diff --git a/crates/shared/src/price_estimation/trade_verifier/code_fetching.rs b/crates/price-estimation/src/trade_verifier/code_fetching.rs
similarity index 99%
rename from crates/shared/src/price_estimation/trade_verifier/code_fetching.rs
rename to crates/price-estimation/src/trade_verifier/code_fetching.rs
index a1083f5ebc..5a9e897969 100644
--- a/crates/shared/src/price_estimation/trade_verifier/code_fetching.rs
+++ b/crates/price-estimation/src/trade_verifier/code_fetching.rs
@@ -2,13 +2,13 @@
 //! more easily be tested with mocked versions of these behaviours.
 
 use {
-    crate::web3::Web3,
     alloy::{
         primitives::{Address, Bytes},
         providers::Provider,
     },
     anyhow::Result,
     cached::{Cached, SizedCache},
+    ethrpc::Web3,
     std::sync::{Arc, Mutex},
     tracing::instrument,
 };
diff --git a/crates/shared/src/price_estimation/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
similarity index 99%
rename from crates/shared/src/price_estimation/trade_verifier/mod.rs
rename to crates/price-estimation/src/trade_verifier/mod.rs
index bdc138622b..e49e429c66 100644
--- a/crates/shared/src/price_estimation/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -1,12 +1,6 @@
 use {
     super::{Estimate, Verification},
     crate::{
-        encoded_settlement::{EncodedSettlement, EncodedTrade, encode_trade},
-        interaction::EncodedInteraction,
-        price_estimation::trade_verifier::{
-            code_fetching::CodeFetching,
-            tenderly_api::TenderlyCodeSimulator,
-        },
         trade_finding::{
             Interaction,
             QuoteExecution,
@@ -14,6 +8,8 @@ use {
             external::dto::{self, JitOrder},
             map_interactions_data,
         },
+        trade_verifier::{code_fetching::CodeFetching, tenderly_api::TenderlyCodeSimulator},
+        utils::encoding::{EncodedInteraction, EncodedSettlement, EncodedTrade, encode_trade},
     },
     ::alloy::sol_types::SolCall,
     alloy::{
diff --git a/crates/shared/src/price_estimation/trade_verifier/tenderly_api.rs b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
similarity index 97%
rename from crates/shared/src/price_estimation/trade_verifier/tenderly_api.rs
rename to crates/price-estimation/src/trade_verifier/tenderly_api.rs
index 23c2cd841c..d835c5303f 100644
--- a/crates/shared/src/price_estimation/trade_verifier/tenderly_api.rs
+++ b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
@@ -1,10 +1,7 @@
 //! Module containing Tenderly API implementation.
 
 use {
-    crate::{
-        arguments::{display_option, display_secret_option},
-        http_client::HttpClientFactory,
-    },
+    crate::utils::{display_option, display_secret_option, http_client_factory::HttpClientFactory},
     alloy::{
         primitives::{Address, B256, TxKind, U256, map::B256Map},
         rpc::types::{TransactionRequest, state::StateOverride as AlloyStateOverride},
@@ -84,7 +81,7 @@ impl TenderlyHttpApi {
 impl TenderlyApi for TenderlyHttpApi {
     #[instrument(skip_all)]
     async fn simulate(&self, simulation: SimulationRequest) -> Result<SimulationResponse> {
-        let url = crate::url::join(&self.api, "simulate");
+        let url = crate::utils::join_url(&self.api, "simulate");
         let body = serde_json::to_string(&simulation)?;
 
         let response = self
@@ -107,9 +104,9 @@ impl TenderlyApi for TenderlyHttpApi {
     }
 
     fn log(&self, simulation: SimulationRequest) -> Result<()> {
-        let request_url = crate::url::join(&self.api, "simulate");
+        let request_url = crate::utils::join_url(&self.api, "simulate");
         let simulation_url =
-            crate::url::join(&self.dashboard, "simulator/$SIMULATION_ID").to_string();
+            crate::utils::join_url(&self.dashboard, "simulator/$SIMULATION_ID").to_string();
         let body = serde_json::to_string(&simulation)?;
 
         #[rustfmt::skip]
@@ -126,7 +123,7 @@ impl TenderlyApi for TenderlyHttpApi {
     }
 
     fn simulation_url(&self, id: &str) -> Url {
-        crate::url::join(&self.dashboard, &format!("simulator/{id}"))
+        crate::utils::join_url(&self.dashboard, &format!("simulator/{id}"))
     }
 }
 
diff --git a/crates/price-estimation/src/utils/encoding.rs b/crates/price-estimation/src/utils/encoding.rs
new file mode 100644
index 0000000000..2f18e367a5
--- /dev/null
+++ b/crates/price-estimation/src/utils/encoding.rs
@@ -0,0 +1,89 @@
+use {
+    alloy::primitives::{Address, B256, Bytes, U256},
+    model::{
+        order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
+        signature::{Signature, SigningScheme},
+    },
+};
+
+pub type EncodedTrade = (
+    U256,    // sellTokenIndex
+    U256,    // buyTokenIndex
+    Address, // receiver
+    U256,    // sellAmount
+    U256,    // buyAmount
+    u32,     // validTo
+    B256,    // appData
+    U256,    // feeAmount
+    U256,    // flags
+    U256,    // executedAmount
+    Bytes,   // signature
+);
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct EncodedSettlement {
+    pub tokens: Vec<Address>,
+    pub clearing_prices: Vec<alloy::primitives::U256>,
+    pub trades: Vec<EncodedTrade>,
+    pub interactions: [Vec<EncodedInteraction>; 3],
+}
+
+pub type EncodedInteraction = (
+    Address, // target
+    U256,    // value
+    Bytes,   // callData
+);
+
+/// Creates the data which the smart contract's `decodeTrade` expects.
+pub fn encode_trade(
+    order: &OrderData,
+    signature: &Signature,
+    owner: Address,
+    sell_token_index: usize,
+    buy_token_index: usize,
+    executed_amount: U256,
+) -> EncodedTrade {
+    (
+        U256::from(sell_token_index),
+        U256::from(buy_token_index),
+        order.receiver.unwrap_or(Address::ZERO),
+        order.sell_amount,
+        order.buy_amount,
+        order.valid_to,
+        B256::new(order.app_data.0),
+        order.fee_amount,
+        order_flags(order, signature),
+        executed_amount,
+        Bytes::from(signature.encode_for_settlement(owner)),
+    )
+}
+
+fn order_flags(order: &OrderData, signature: &Signature) -> U256 {
+    let mut result = 0u8;
+    // The kind is encoded as 1 bit in position 0.
+    result |= match order.kind {
+        OrderKind::Sell => 0b0,
+        OrderKind::Buy => 0b1,
+    };
+    // The order fill kind is encoded as 1 bit in position 1.
+    result |= (order.partially_fillable as u8) << 1;
+    // The order sell token balance is encoded as 2 bits in position 2.
+    result |= match order.sell_token_balance {
+        SellTokenSource::Erc20 => 0b00,
+        SellTokenSource::External => 0b10,
+        SellTokenSource::Internal => 0b11,
+    } << 2;
+    // The order buy token balance is encoded as 1 bit in position 4.
+    result |= match order.buy_token_balance {
+        BuyTokenDestination::Erc20 => 0b0,
+        BuyTokenDestination::Internal => 0b1,
+    } << 4;
+    // The signing scheme is encoded as a 2 bits in position 5.
+    result |= match signature.scheme() {
+        SigningScheme::Eip712 => 0b00,
+        SigningScheme::EthSign => 0b01,
+        SigningScheme::Eip1271 => 0b10,
+        SigningScheme::PreSign => 0b11,
+    } << 5;
+    U256::from(result)
+}
diff --git a/crates/price-estimation/src/utils/http_client_factory.rs b/crates/price-estimation/src/utils/http_client_factory.rs
new file mode 100644
index 0000000000..4771a8d48c
--- /dev/null
+++ b/crates/price-estimation/src/utils/http_client_factory.rs
@@ -0,0 +1,52 @@
+use {
+    reqwest::{Client, ClientBuilder},
+    std::time::Duration,
+};
+
+/// An HTTP client factory.
+///
+/// This ensures a common configuration for all our HTTP clients used in various
+/// places, while allowing for separate configurations, connection pools, and
+/// cookie stores (for things like sessions and default headers) across
+/// different APIs.
+#[derive(Clone, Debug)]
+pub struct HttpClientFactory {
+    timeout: Duration,
+}
+
+impl HttpClientFactory {
+    pub fn new(timeout: Duration) -> Self {
+        Self { timeout }
+    }
+
+    /// Creates a new HTTP client with the default settings.
+    pub fn create(&self) -> Client {
+        self.builder()
+            .build()
+            .expect("builder config is not malformed")
+    }
+
+    /// Creates a new HTTP client, allowing for additional configuration.
+    pub fn configure(&self, config: impl FnOnce(ClientBuilder) -> ClientBuilder) -> Client {
+        config(self.builder())
+            .build()
+            .expect("builder config is not malformed")
+    }
+
+    /// Returns a `ClientBuilder` with the default settings.
+    pub fn builder(&self) -> ClientBuilder {
+        const USER_AGENT: &str = "cowprotocol-services/2.0.0";
+        ClientBuilder::new()
+            .timeout(self.timeout)
+            .tcp_keepalive(Duration::from_secs(60))
+            .user_agent(USER_AGENT)
+    }
+}
+
+impl Default for HttpClientFactory {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(10),
+        }
+    }
+}
diff --git a/crates/price-estimation/src/utils/mod.rs b/crates/price-estimation/src/utils/mod.rs
new file mode 100644
index 0000000000..bd4c6c2ade
--- /dev/null
+++ b/crates/price-estimation/src/utils/mod.rs
@@ -0,0 +1,50 @@
+//! Module with a few functions duplicated from `shared` in order
+//! to break cyclical dependencies and break off this crate.
+
+use {
+    std::fmt::{Display, Formatter},
+    url::Url,
+};
+
+pub mod encoding;
+pub mod http_client_factory;
+
+/// Join a path with a URL, ensuring that there is only one slash between them.
+/// It doesn't matter if the URL ends with a slash or the path starts with one.
+pub fn join_url(url: &Url, mut path: &str) -> Url {
+    let mut url = url.to_string();
+    while url.ends_with('/') {
+        url.pop();
+    }
+    while path.starts_with('/') {
+        path = &path[1..]
+    }
+    Url::parse(&format!("{url}/{path}")).expect("\"path\" contains a valid path segement")
+}
+
+/// anyhow errors are not clonable natively. This is a workaround that creates a
+/// new anyhow error based on formatting the error with its inner sources
+/// without backtrace.
+pub fn clone_anyhow_error(err: &anyhow::Error) -> anyhow::Error {
+    anyhow::anyhow!("{:#}", err)
+}
+
+pub fn display_secret_option<T>(
+    f: &mut Formatter<'_>,
+    name: &str,
+    option: Option<&T>,
+) -> std::fmt::Result {
+    display_option(f, name, &option.as_ref().map(|_| "SECRET"))
+}
+
+pub fn display_option(
+    f: &mut Formatter<'_>,
+    name: &str,
+    option: &Option<impl Display>,
+) -> std::fmt::Result {
+    write!(f, "{name}: ")?;
+    match option {
+        Some(display) => writeln!(f, "{display}"),
+        None => writeln!(f, "None"),
+    }
+}
diff --git a/crates/refunder/Cargo.toml b/crates/refunder/Cargo.toml
index f6d1d7bac3..21524a7f78 100644
--- a/crates/refunder/Cargo.toml
+++ b/crates/refunder/Cargo.toml
@@ -15,6 +15,7 @@ database = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 const-hex = { workspace = true }
+gas-price-estimation = { workspace = true }
 humantime = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 tikv-jemallocator = { workspace = true }
diff --git a/crates/refunder/src/refund_service.rs b/crates/refunder/src/refund_service.rs
index 0ef475d1a0..5d24e5220d 100644
--- a/crates/refunder/src/refund_service.rs
+++ b/crates/refunder/src/refund_service.rs
@@ -10,6 +10,7 @@ use {
     anyhow::Result,
     database::{OrderUid, ethflow_orders::EthOrderPlacement},
     futures::{StreamExt, stream},
+    gas_price_estimation::eth_node::NodeGasPriceEstimator,
     std::collections::HashMap,
 };
 
@@ -254,11 +255,7 @@ impl RefundService<Postgres, AlloyChain, Submitter> {
         web3.wallet.register_signer(signer);
 
         // Transaction submitter
-        let gas_estimator = Box::new(
-            shared::gas_price_estimation::eth_node::NodeGasPriceEstimator::new(
-                web3.provider.clone(),
-            ),
-        );
+        let gas_estimator = Box::new(NodeGasPriceEstimator::new(web3.provider.clone()));
         let submitter = Submitter {
             web3,
             signer_address,
diff --git a/crates/refunder/src/submitter.rs b/crates/refunder/src/submitter.rs
index 54764091c5..5f7cbb85b5 100644
--- a/crates/refunder/src/submitter.rs
+++ b/crates/refunder/src/submitter.rs
@@ -11,10 +11,8 @@ use {
     anyhow::{Context, Result},
     contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
     database::OrderUid,
-    shared::{
-        gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
-        web3::Web3,
-    },
+    ethrpc::Web3,
+    gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
     std::time::Duration,
 };
 
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 4ecac4cf58..927874c7f0 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -15,6 +15,7 @@ anyhow = { workspace = true }
 app-data = { workspace = true }
 arc-swap = { workspace = true }
 balance-overrides = { workspace = true }
+bad-tokens = { workspace = true }
 bytes-hex = { workspace = true }
 async-trait = { workspace = true }
 bigdecimal = { workspace = true }
@@ -27,8 +28,8 @@ dashmap = { workspace = true }
 database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
-event-indexing = { workspace = true }
 futures = { workspace = true }
+gas-price-estimation = { workspace = true }
 observe = { workspace = true }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
@@ -39,6 +40,7 @@ model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
 order-validation = { workspace = true }
+price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
@@ -58,7 +60,6 @@ tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"
 url = { workspace = true }
 moka = { workspace = true, features = ["sync"] }
 mockall = { workspace = true, optional = true }
-liquidity-sources = { workspace = true }
 
 [dev-dependencies]
 account-balances = { workspace = true, features = ["test-util"] }
@@ -68,6 +69,7 @@ async-stream = { workspace = true }
 ethrpc = { workspace = true, features = ["test-util"] }
 maplit = { workspace = true }
 mockall = { workspace = true }
+price-estimation = { workspace = true, features = ["test-util"] }
 regex = { workspace = true }
 testlib = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 36416ba219..bc572447e8 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -2,13 +2,10 @@
 //! the binaries.
 
 use {
-    crate::{
-        fee_factor::FeeFactor,
-        gas_price_estimation::GasEstimatorType,
-        price_estimation::trade_verifier::tenderly_api,
-    },
+    crate::fee_factor::FeeFactor,
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
+    gas_price_estimation::GasEstimatorType,
     observe::TracingConfig,
     std::{
         collections::HashSet,
@@ -152,9 +149,6 @@ pub struct Arguments {
     #[clap(flatten)]
     pub current_block: crate::current_block::Arguments,
 
-    #[clap(flatten)]
-    pub tenderly: tenderly_api::Arguments,
-
     #[clap(flatten)]
     pub logging: LoggingArguments,
 
@@ -307,7 +301,6 @@ impl Display for Arguments {
         let Self {
             ethrpc,
             current_block,
-            tenderly,
             logging,
             node_url,
             chain_id,
@@ -327,7 +320,6 @@ impl Display for Arguments {
 
         write!(f, "{ethrpc}")?;
         write!(f, "{current_block}")?;
-        write!(f, "{tenderly}")?;
         write!(f, "{logging}")?;
         writeln!(f, "node_url: {node_url}")?;
         display_option(f, "chain_id", chain_id)?;
diff --git a/crates/shared/src/bytes.rs b/crates/shared/src/bytes.rs
deleted file mode 100644
index 7e3ade9e18..0000000000
--- a/crates/shared/src/bytes.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-/// A thin wrapper around a collection of bytes. Provides hex debug formatting.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
-pub struct Bytes<T>(pub T);
-
-impl<T> std::fmt::Debug for Bytes<T>
-where
-    T: AsRef<[u8]>,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", const_hex::encode_prefixed(&self.0))
-    }
-}
-
-impl<T> From<T> for Bytes<T> {
-    fn from(value: T) -> Self {
-        Self(value)
-    }
-}
-
-impl From<Bytes<Vec<u8>>> for Vec<u8> {
-    fn from(value: Bytes<Vec<u8>>) -> Self {
-        value.0
-    }
-}
-
-impl<const N: usize> From<Bytes<[u8; N]>> for [u8; N] {
-    fn from(value: Bytes<[u8; N]>) -> Self {
-        value.0
-    }
-}
diff --git a/crates/shared/src/http_client.rs b/crates/shared/src/http_client.rs
index b542fb6a12..82586cc0d9 100644
--- a/crates/shared/src/http_client.rs
+++ b/crates/shared/src/http_client.rs
@@ -16,7 +16,7 @@ const USER_AGENT: &str = "cowprotocol-services/2.0.0";
 /// different APIs.
 #[derive(Clone, Debug)]
 pub struct HttpClientFactory {
-    timeout: Duration,
+    pub timeout: Duration,
 }
 
 impl HttpClientFactory {
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 4e06f02f94..49500cfff4 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -2,7 +2,6 @@
 pub mod macros;
 
 pub mod arguments;
-pub mod bad_token;
 pub mod current_block;
 pub mod db_order_conversions;
 pub mod encoded_settlement;
@@ -10,18 +9,14 @@ pub mod event_storing_helpers;
 pub mod external_prices;
 pub mod fee;
 pub mod fee_factor;
-pub mod gas_price;
-pub mod gas_price_estimation;
 pub mod http_client;
 pub mod http_solver;
 pub mod interaction;
 pub mod order_quoting;
 pub mod order_validation;
-pub mod price_estimation;
 pub mod remaining_amounts;
 pub mod signature_validator;
 pub mod token_list;
-pub mod trade_finding;
 pub mod url;
 pub mod web3;
 pub mod zeroex_api;
diff --git a/crates/shared/src/order_quoting.rs b/crates/shared/src/order_quoting.rs
index 94bfa05629..64dbddc26a 100644
--- a/crates/shared/src/order_quoting.rs
+++ b/crates/shared/src/order_quoting.rs
@@ -1,17 +1,8 @@
 use {
-    super::price_estimation::{
-        self,
-        PriceEstimating,
-        PriceEstimationError,
-        native::NativePriceEstimating,
-    },
     crate::{
         db_order_conversions::order_kind_from,
         fee::FeeParameters,
-        gas_price_estimation::GasPriceEstimating,
         order_validation::PreOrderData,
-        price_estimation::{Estimate, QuoteVerificationMode, Verification},
-        trade_finding::external::dto,
     },
     account_balances::{BalanceFetching, Query},
     alloy::primitives::{Address, U256, U512, ruint::UintTryFrom},
@@ -19,6 +10,7 @@ use {
     chrono::{DateTime, Duration, Utc},
     database::quotes::{Quote as QuoteRow, QuoteKind},
     futures::TryFutureExt,
+    gas_price_estimation::GasPriceEstimating,
     model::{
         interaction::InteractionData,
         order::{OrderClass, OrderKind},
@@ -26,6 +18,16 @@ use {
     },
     num::FromPrimitive,
     number::conversions::big_decimal_to_u256,
+    price_estimation::{
+        self,
+        Estimate,
+        PriceEstimating,
+        PriceEstimationError,
+        QuoteVerificationMode,
+        Verification,
+        native::NativePriceEstimating,
+        trade_finding::external::dto,
+    },
     std::sync::Arc,
     thiserror::Error,
     tracing::instrument,
@@ -784,23 +786,21 @@ pub struct QuoteMetadataV1 {
 mod tests {
     use {
         super::*,
-        crate::{
-            gas_price_estimation::FakeGasPriceEstimator,
-            price_estimation::{
-                HEALTHY_PRICE_ESTIMATION_TIME,
-                MockPriceEstimating,
-                native::MockNativePriceEstimating,
-            },
-        },
         Address,
         U256 as AlloyU256,
         account_balances::MockBalanceFetching,
         alloy::eips::eip1559::Eip1559Estimation,
         chrono::Utc,
         futures::FutureExt,
+        gas_price_estimation::FakeGasPriceEstimator,
         mockall::{Sequence, predicate::eq},
         model::time,
         number::nonzero::NonZeroU256,
+        price_estimation::{
+            HEALTHY_PRICE_ESTIMATION_TIME,
+            MockPriceEstimating,
+            native::MockNativePriceEstimating,
+        },
     };
 
     fn mock_balance_fetcher() -> Arc<dyn BalanceFetching> {
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 9520aa89d5..09e48a0e72 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -1,6 +1,5 @@
 use {
     crate::{
-        bad_token::list_based::DenyListedTokens,
         order_quoting::{
             CalculateQuoteError,
             OrderQuoting,
@@ -8,19 +7,14 @@ use {
             QuoteParameters,
             QuoteSearchParameters,
         },
-        price_estimation::{
-            PriceEstimationError,
-            Verification,
-            trade_verifier::code_fetching::CodeFetching,
-        },
         signature_validator::{SignatureCheck, SignatureValidating, SignatureValidationError},
-        trade_finding,
     },
     account_balances::{self, BalanceFetching, TransferSimulationError},
     alloy::primitives::{Address, B256, U256},
     anyhow::{Result, anyhow},
     app_data::{AppDataHash, Hook, Hooks, ValidatedAppData, Validator},
     async_trait::async_trait,
+    bad_tokens::list_based::DenyListedTokens,
     balance_overrides::BalanceOverrideRequest,
     contracts::alloy::{HooksTrampoline, WETH9},
     model::{
@@ -45,6 +39,12 @@ use {
         signature::{self, Signature, SigningScheme, hashed_eip712_message},
         time,
     },
+    price_estimation::{
+        PriceEstimationError,
+        Verification,
+        trade_finding,
+        trade_verifier::code_fetching::CodeFetching,
+    },
     std::{sync::Arc, time::Duration},
     tracing::instrument,
 };
@@ -1038,7 +1038,6 @@ mod tests {
         super::*,
         crate::{
             order_quoting::{FindQuoteError, MockOrderQuoting},
-            price_estimation::trade_verifier::code_fetching::MockCodeFetching,
             signature_validator::MockSignatureValidating,
         },
         account_balances::MockBalanceFetching,
@@ -1055,6 +1054,7 @@ mod tests {
             signature::{EcdsaSignature, EcdsaSigningScheme},
         },
         number::nonzero::NonZeroU256,
+        price_estimation::trade_verifier::code_fetching::MockCodeFetching,
         serde_json::json,
     };
 
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index 98b2987b0c..7a196a69db 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -28,6 +28,7 @@ liquidity-sources = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 num = { workspace = true }
 number = { workspace = true }
+price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 reqwest = { workspace = true }
diff --git a/crates/solvers/src/boundary/liquidity/limit_order.rs b/crates/solvers/src/boundary/liquidity/limit_order.rs
index 708261dd2b..5d2e5d25cb 100644
--- a/crates/solvers/src/boundary/liquidity/limit_order.rs
+++ b/crates/solvers/src/boundary/liquidity/limit_order.rs
@@ -2,7 +2,7 @@ use {
     crate::domain::liquidity::limit_order::LimitOrder,
     alloy::primitives::{Address, U256},
     liquidity_sources::baseline_solvable::BaselineSolvable,
-    shared::price_estimation::gas::GAS_PER_ZEROEX_ORDER,
+    price_estimation::gas::GAS_PER_ZEROEX_ORDER,
 };
 
 // Follows 0x's contract implementation: <https://github.com/0xProject/protocol/blob/%400x/contracts-utils%404.8.52/contracts/utils/contracts/src/v06/LibMathV06.sol#L71-L83>
diff --git a/crates/solvers/src/infra/config.rs b/crates/solvers/src/infra/config.rs
index 373debe69c..08f61feae3 100644
--- a/crates/solvers/src/infra/config.rs
+++ b/crates/solvers/src/infra/config.rs
@@ -4,9 +4,9 @@ use {
         infra::contracts,
     },
     chain::Chain,
+    price_estimation::gas::SETTLEMENT_OVERHEAD,
     reqwest::Url,
     serde::Deserialize,
-    shared::price_estimation::gas::SETTLEMENT_OVERHEAD,
     std::{fmt::Debug, path::Path},
     tokio::fs,
 };
diff --git a/playground/docker-compose.fork.yml b/playground/docker-compose.fork.yml
index d7c49b5bc6..b8655dbbf7 100644
--- a/playground/docker-compose.fork.yml
+++ b/playground/docker-compose.fork.yml
@@ -120,7 +120,7 @@ services:
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - LOG_FILTER=warn,autopilot=debug,shared=info,shared::price_estimation=info
+      - LOG_FILTER=warn,autopilot=debug,shared=info,price_estimation=info
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
       - GAS_ESTIMATORS=Web3,Alloy
diff --git a/playground/docker-compose.non-interactive.yml b/playground/docker-compose.non-interactive.yml
index 498176cb78..1288112adb 100644
--- a/playground/docker-compose.non-interactive.yml
+++ b/playground/docker-compose.non-interactive.yml
@@ -109,7 +109,7 @@ services:
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - LOG_FILTER=warn,autopilot=info,shared=info,shared::price_estimation=info
+      - LOG_FILTER=warn,autopilot=info,shared=info,price_estimation=info
       - NODE_URL=http://chain:8545
       - SIMULATION_NODE_URL=http://chain:8545
       - GAS_ESTIMATORS=Web3,Alloy

From a08b1a5f2b401cb9c1ebc2d5ef428c1029dfcc09 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 4 Mar 2026 12:58:50 +0000
Subject: [PATCH 120/219] Migrate shared native price estimation config from
 CLI to config file (#4216)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Move native price cache, concurrent requests, approximation tokens, and
balancer SOR URL settings from CLI arguments into the TOML config file.
Introduce a shared NativePriceConfig in the shared crate that both
autopilot and orderbook embed via serde flatten. Also migrate
orderbook's native price estimator selection and results_required from
CLI to config.

# Changes
* Moves shared native price settings (cache max-age, concurrent
requests, approximation tokens) into a new
`shared::price_estimation::config::native_price` module, used by both
autopilot and orderbook via `#[serde(flatten)]`
* Moves orderbook-specific settings (native price estimators, fallback
estimators, results-required) from CLI args to the orderbook TOML config
* Removes `--balancer-sor-url` (unused)
* Adds unit tests for (de)serialization of the new config structs

## Migrated settings

### Shared (autopilot + orderbook)

These settings were in `shared::price_estimation::Arguments` (CLI) and
now live in the `[native-price-estimation]` section of each service's
TOML config, flattened from the shared `NativePriceConfig`.

| Old CLI Argument | TOML Key |
|---|---|
| `--native-price-cache-max-age` |
`native-price-estimation.cache.max-age` |
| `--native-price-cache-concurrent-requests` |
`native-price-estimation.cache.concurrent-requests` |
| `--native-price-approximation-tokens` |
`native-price-estimation.approximation-tokens` |
| `--balancer-sor-url` | **removed** |

### Orderbook-only

These settings were in `orderbook::arguments::Arguments` (CLI) and now
live in the `[native-price-estimation]` section of the orderbook TOML
config.

| Old CLI Argument | TOML Key |
|---|---|
| `--native-price-estimators` | `native-price-estimation.estimators` |
| `--native-price-estimators-fallback` |
`native-price-estimation.fallback-estimators` |
| `--fast-price-estimation-results-required` |
`native-price-estimation.results-required` |

## Example

### Orderbook

Before:

```bash
orderbook \
  --native-price-cache-max-age=5m \
  --native-price-cache-concurrent-requests=4 \
  --native-price-approximation-tokens="0xaaa...111|0xbbb...222,0xccc...333|0xddd...444" \
  --native-price-estimators="[[{type = \"CoinGecko\"}, {type = \"OneInchSpotPriceApi\"}]]" \
  --native-price-estimators-fallback="[[{type = \"CoinGecko\"}]]" \
  --fast-price-estimation-results-required=3 \
  --config=/path/to/orderbook.toml \
  --bind-address=0.0.0.0:8080
```

After — add to `orderbook.toml`:

```toml
[native-price-estimation]
estimators = [[{ type = "CoinGecko" }, { type = "OneInchSpotPriceApi" }]]
fallback-estimators = [[{ type = "CoinGecko" }]]
results-required = 3
approximation-tokens = [
    ["0xaaa...111", "0xbbb...222"],
    ["0xccc...333", "0xddd...444"],
]

[native-price-estimation.cache]
max-age = "5m"
concurrent-requests = 4
```

### Autopilot

Before:

```bash
autopilot \
  --native-price-cache-max-age=10m \
  --native-price-cache-concurrent-requests=2 \
  --native-price-approximation-tokens="0xaaa...111|0xbbb...222" \
  --config=/path/to/autopilot.toml
```

After — add to `autopilot.toml` (inside the existing
`[native-price-estimation]` section):

```toml
[native-price-estimation]
# ... existing autopilot-specific settings (estimators, etc.) ...
approximation-tokens = [
    ["0xaaa...111", "0xbbb...222"],
]

[native-price-estimation.cache]
max-age = "10m"
concurrent-requests = 2
```

## How to test
Staging

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 Cargo.lock                                    |   1 +
 crates/autopilot/Cargo.toml                   |   2 +-
 crates/autopilot/src/config/mod.rs            |  35 +++-
 crates/autopilot/src/config/native_price.rs   |  65 +++---
 crates/autopilot/src/run.rs                   |   8 +-
 crates/e2e/src/setup/services.rs              | 109 +++++-----
 crates/e2e/tests/e2e/autopilot_leader.rs      |  37 ++--
 crates/e2e/tests/e2e/banned_users.rs          |  11 +-
 crates/e2e/tests/e2e/buffers.rs               |  40 ++--
 crates/e2e/tests/e2e/cors.rs                  |  30 +--
 crates/e2e/tests/e2e/cow_amm.rs               |  66 +++---
 crates/e2e/tests/e2e/jit_orders.rs            |  19 +-
 crates/e2e/tests/e2e/limit_orders.rs          | 190 +++++++++---------
 crates/e2e/tests/e2e/liquidity.rs             |  17 +-
 .../e2e/liquidity_source_notification.rs      |  17 +-
 crates/e2e/tests/e2e/malformed_requests.rs    |  15 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |  28 ++-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  40 ++--
 crates/e2e/tests/e2e/protocol_fee.rs          | 159 +++++++--------
 crates/e2e/tests/e2e/quote_verification.rs    |  10 +-
 crates/e2e/tests/e2e/quoting.rs               | 103 +++++-----
 crates/e2e/tests/e2e/replace_order.rs         |   6 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |  20 +-
 crates/e2e/tests/e2e/solver_competition.rs    | 103 +++++-----
 crates/e2e/tests/e2e/submission.rs            |  42 ++--
 crates/orderbook/Cargo.toml                   |   2 +-
 crates/orderbook/src/arguments.rs             |  35 +---
 crates/orderbook/src/config/mod.rs            |  53 +++--
 crates/orderbook/src/config/native_price.rs   |  98 +++++++++
 crates/orderbook/src/run.rs                   |  14 +-
 crates/price-estimation/Cargo.toml            |   1 +
 crates/price-estimation/src/config/mod.rs     |   1 +
 .../src/config/native_price.rs                | 155 ++++++++++++++
 crates/price-estimation/src/factory.rs        |  26 ++-
 crates/price-estimation/src/lib.rs            | 166 ++++-----------
 35 files changed, 955 insertions(+), 769 deletions(-)
 create mode 100644 crates/orderbook/src/config/native_price.rs
 create mode 100644 crates/price-estimation/src/config/mod.rs
 create mode 100644 crates/price-estimation/src/config/native_price.rs

diff --git a/Cargo.lock b/Cargo.lock
index 32cdcbbdc4..99d576c92f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5349,6 +5349,7 @@ dependencies = [
  "gas-price-estimation",
  "hex-literal",
  "humantime",
+ "humantime-serde",
  "itertools 0.14.0",
  "maplit",
  "mockall",
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 81157318b3..94949846ed 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -93,4 +93,4 @@ workspace = true
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
 tokio-console = ["observe/tokio-console"]
-test-util = ["dep:tempfile"]
+test-util = ["dep:tempfile", "price-estimation/test-util"]
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index c13b353458..ff3282c830 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -21,7 +21,10 @@ pub mod s3;
 pub mod solver;
 pub mod trusted_tokens;
 
-#[derive(Debug, Default, Deserialize, Serialize)]
+// Does not implement Default because `native_price_estimation` *cannot* have
+// empty `estimators`, as such, we cannot provide a proper default value for
+// this structure.
+#[derive(Debug, Deserialize, Serialize)]
 // NOTE: cannot add deny_unknown_fields during the config migration
 // as new ones get added in the config will fail parsing if extra fields are present
 #[serde(rename_all = "kebab-case", /* deny_unknown_fields */)]
@@ -85,10 +88,30 @@ impl Configuration {
 
 #[cfg(any(test, feature = "test-util"))]
 impl Configuration {
+    /// This function *does not* return a valid configuration!
+    /// It is rather useful for tests where drivers are setup separately or not
+    /// actually used (like the `order_cancellation` test).
+    pub fn test_no_drivers() -> Self {
+        Self {
+            drivers: vec![],
+            fee_policies: Default::default(),
+            trusted_tokens: Default::default(),
+            order_events_cleanup: Default::default(),
+            banned_users: Default::default(),
+            s3: Default::default(),
+            native_price_estimation: NativePriceConfig::test_default(),
+        }
+    }
+
     pub fn test(name: &str, solver_address: alloy::primitives::Address) -> Self {
         Self {
             drivers: vec![Solver::test(name, solver_address)],
-            ..Default::default()
+            fee_policies: Default::default(),
+            trusted_tokens: Default::default(),
+            order_events_cleanup: Default::default(),
+            banned_users: Default::default(),
+            s3: Default::default(),
+            native_price_estimation: NativePriceConfig::test_default(),
         }
     }
 
@@ -272,12 +295,16 @@ mod tests {
         [fee-policies]
 
         [native-price-estimation]
-        estimators = []
+        estimators = [[{type = "CoinGecko"}]]
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
 
         assert_eq!(config.drivers.len(), 1);
+        assert_eq!(
+            config.native_price_estimation.estimators.as_slice().len(),
+            1
+        );
         assert!(config.fee_policies.policies.is_empty());
         assert_eq!(config.fee_policies.max_partner_fee.get(), 0.01);
         assert!(config.fee_policies.upcoming_policies.policies.is_empty());
@@ -329,7 +356,7 @@ mod tests {
                 max_partner_fee: 0.02.try_into().unwrap(),
                 upcoming_policies: UpcomingFeePolicies::default(),
             },
-            ..Default::default()
+            ..Configuration::test_no_drivers()
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/autopilot/src/config/native_price.rs b/crates/autopilot/src/config/native_price.rs
index 690da03596..849be21e12 100644
--- a/crates/autopilot/src/config/native_price.rs
+++ b/crates/autopilot/src/config/native_price.rs
@@ -1,13 +1,9 @@
 use {
     price_estimation::NativePriceEstimators,
     serde::{Deserialize, Serialize},
-    std::{num::NonZeroUsize, time::Duration},
+    std::time::Duration,
 };
 
-const fn default_native_price_estimation_results_required() -> NonZeroUsize {
-    NonZeroUsize::new(2).expect("value should not be zero")
-}
-
 const fn default_native_price_cache_refresh() -> Duration {
     Duration::from_secs(1)
 }
@@ -16,6 +12,8 @@ const fn default_native_price_prefetch_time() -> Duration {
     Duration::from_secs(80)
 }
 
+// Does not implement Default because `estimators` *cannot* be empty,
+// as such, we cannot provide a proper default value for this structure.
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct NativePriceConfig {
@@ -29,13 +27,6 @@ pub struct NativePriceConfig {
     /// `--native-price-estimators` if unset.
     pub api_estimators: Option<NativePriceEstimators>,
 
-    /// How many successful price estimates for each order will cause a native
-    /// price estimation to return its result early. It's possible to pass
-    /// values greater than the total number of enabled estimators but that
-    /// will not have any further effect.
-    #[serde(default = "default_native_price_estimation_results_required")]
-    pub results_required: NonZeroUsize,
-
     /// How often the native price estimator should check for prices that need
     /// to be udpated.
     #[serde(
@@ -52,16 +43,29 @@ pub struct NativePriceConfig {
         default = "default_native_price_prefetch_time"
     )]
     pub prefetch_time: Duration,
+
+    #[serde(flatten)]
+    pub shared: price_estimation::config::native_price::NativePriceConfig,
 }
 
-impl Default for NativePriceConfig {
-    fn default() -> Self {
+#[cfg(any(test, feature = "test-util"))]
+impl NativePriceConfig {
+    /// Test configuration for [`NativePriceConfig`], must always be able to do
+    /// a serialization/deserialization roundtrip, as otherwise it may not
+    /// be loadable in end-to-end tests.
+    pub fn test_default() -> Self {
         Self {
-            estimators: Default::default(),
+            estimators: NativePriceEstimators::test_default(),
             api_estimators: Default::default(),
-            results_required: default_native_price_estimation_results_required(),
             cache_refresh_interval: default_native_price_cache_refresh(),
-            prefetch_time: default_native_price_prefetch_time(),
+            prefetch_time: Duration::from_millis(500),
+            shared: price_estimation::config::native_price::NativePriceConfig {
+                cache: price_estimation::config::native_price::CacheConfig {
+                    max_age: Duration::from_secs(2),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
         }
     }
 }
@@ -70,32 +74,17 @@ impl Default for NativePriceConfig {
 mod tests {
     use super::*;
 
-    #[test]
-    fn deserialize_defaults() {
-        let toml = r#"
-        estimators = []
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert!(config.estimators.as_slice().is_empty());
-        assert!(config.api_estimators.is_none());
-        assert_eq!(config.results_required.get(), 2);
-        assert_eq!(config.cache_refresh_interval, Duration::from_secs(1));
-        assert_eq!(config.prefetch_time, Duration::from_secs(80));
-    }
-
     #[test]
     fn deserialize_full() {
         let toml = r#"
         estimators = [[{type = "CoinGecko"}]]
         api-estimators = [[{type = "OneInchSpotPriceApi"}]]
-        results-required = 3
         cache-refresh-interval = "30s"
         prefetch-time = "2m"
         "#;
         let config: NativePriceConfig = toml::from_str(toml).unwrap();
         assert_eq!(config.estimators.as_slice().len(), 1);
         assert!(config.api_estimators.is_some());
-        assert_eq!(config.results_required.get(), 3);
         assert_eq!(config.cache_refresh_interval, Duration::from_secs(30));
         assert_eq!(config.prefetch_time, Duration::from_secs(120));
     }
@@ -106,13 +95,11 @@ mod tests {
         assert!(toml::from_str::<NativePriceConfig>(toml).is_err());
     }
 
+    // This test keeps the sanity of `test_default` upon which other tests rely!
     #[test]
-    fn default_impl() {
-        let config = NativePriceConfig::default();
-        assert!(config.estimators.as_slice().is_empty());
-        assert!(config.api_estimators.is_none());
-        assert_eq!(config.results_required.get(), 2);
-        assert_eq!(config.cache_refresh_interval, Duration::from_secs(1));
-        assert_eq!(config.prefetch_time, Duration::from_secs(80));
+    fn test_default_roundtrip() {
+        let config = NativePriceConfig::test_default();
+        let serialized = toml::to_string(&config).unwrap();
+        let _: NativePriceConfig = toml::from_str(&serialized).unwrap();
     }
 }
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index b3884bc6e5..d824bb03a1 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -147,6 +147,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
     let commit_hash = option_env!("VERGEN_GIT_SHA").unwrap_or("COMMIT_INFO_NOT_FOUND");
 
     tracing::info!(%commit_hash, "running autopilot with validated arguments:\n{}", args);
+    tracing::info!("file configuration:\n{:#?}", config);
 
     observe::metrics::setup_registry(Some("gp_v2_autopilot".into()), None);
 
@@ -281,6 +282,7 @@ pub async fn run(
 
     let mut price_estimator_factory = PriceEstimatorFactory::new(
         &args.price_estimation,
+        &config.native_price_estimation.shared,
         factory::Network {
             web3: web3.clone(),
             simulation_web3,
@@ -312,7 +314,7 @@ pub async fn run(
     let weth = eth.contracts().weth().clone();
     let prices = db_write.fetch_latest_prices().await.unwrap();
     let shared_cache = price_estimation::native_price_cache::Cache::new(
-        args.price_estimation.native_price_cache_max_age,
+        config.native_price_estimation.shared.cache.max_age,
         prices,
     );
     let api_sources = config
@@ -324,7 +326,7 @@ pub async fn run(
         price_estimator_factory
             .caching_native_price_estimator(
                 api_sources.as_slice(),
-                config.native_price_estimation.results_required,
+                config.native_price_estimation.shared.results_required,
                 &weth,
                 shared_cache.clone(),
             )
@@ -336,7 +338,7 @@ pub async fn run(
         let caching = price_estimator_factory
             .caching_native_price_estimator(
                 config.native_price_estimation.estimators.as_slice(),
-                config.native_price_estimation.results_required,
+                config.native_price_estimation.shared.results_required,
                 &weth,
                 shared_cache.clone(),
             )
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 2add964cd1..5dec08c4b2 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -140,7 +140,6 @@ impl<'a> Services<'a> {
             "--block-stream-poll-interval=1s".to_string(),
             format!("--node-ws-url={NODE_WS_HOST}"),
             "--simulation-node-url=http://localhost:8545".to_string(),
-            "--native-price-cache-max-age=2s".to_string(),
             format!(
                 "--hooks-contract-address={:?}",
                 self.contracts.hooks.address()
@@ -188,6 +187,7 @@ impl<'a> Services<'a> {
         &self,
         solve_deadline: Option<Duration>,
         extra_args: Vec<String>,
+        config: autopilot::config::Configuration,
         control: autopilot::shutdown_controller::ShutdownController,
     ) -> JoinHandle<()> {
         let solve_deadline = solve_deadline.unwrap_or(Duration::from_secs(2));
@@ -199,6 +199,8 @@ impl<'a> Services<'a> {
             .collect::<Vec<_>>()
             .join(",");
 
+        let (_autopilot_config_file, autopilot_config_arg) = config.to_cli_args();
+
         let args = [
             "autopilot".to_string(),
             "--max-run-loop-delay=100ms".to_string(),
@@ -207,6 +209,7 @@ impl<'a> Services<'a> {
             "--skip-event-sync=true".to_string(),
             "--api-address=0.0.0.0:12088".to_string(),
             format!("--solve-deadline={solve_deadline:?}"),
+            autopilot_config_arg,
         ]
         .into_iter()
         .chain(self.api_autopilot_solver_arguments())
@@ -218,18 +221,6 @@ impl<'a> Services<'a> {
         let args = autopilot::arguments::CliArguments::try_parse_from(args)
             .map_err(|err| err.to_string())
             .unwrap();
-        let config = Configuration {
-            native_price_estimation: NativePriceConfig {
-                estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
-                    "test_quoter".to_string(),
-                    Url::from_str("http://localhost:11088/test_solver").unwrap(),
-                )]]),
-                prefetch_time: Duration::from_millis(500),
-                ..Default::default()
-            },
-            ..Configuration::from_path(&args.config).await.unwrap()
-        };
-        tracing::info!("Loaded config: {:?}", config);
         let join_handle = tokio::task::spawn(autopilot::run(args, config, control));
         self.wait_until_autopilot_ready().await;
 
@@ -245,10 +236,12 @@ impl<'a> Services<'a> {
         &self,
         solve_deadline: Option<Duration>,
         extra_args: Vec<String>,
+        config: autopilot::config::Configuration,
     ) -> JoinHandle<()> {
         self.start_autopilot_with_shutdown_controller(
             solve_deadline,
             extra_args,
+            config,
             autopilot::shutdown_controller::ShutdownController::default(),
         )
         .await
@@ -256,13 +249,18 @@ impl<'a> Services<'a> {
 
     /// Start the api service in a background tasks.
     /// Wait until the service is responsive.
-    pub async fn start_api(&self, extra_args: Vec<String>) {
+    pub async fn start_api(
+        &self,
+        extra_args: Vec<String>,
+        config: orderbook::config::Configuration,
+    ) {
+        let (_config_file, config_arg) = config.to_cli_args();
         let args: Vec<_> = [
             "orderbook".to_string(),
             "--quote-timeout=10s".to_string(),
             "--quote-verification=enforce-when-possible".to_string(),
-            "--native-price-estimators=Forwarder|http://localhost:12088".to_string(),
             format!("--db-read-url={}", &*LOCAL_READ_ONLY_DB_URL),
+            config_arg,
         ]
         .into_iter()
         .chain(self.api_autopilot_solver_arguments())
@@ -272,9 +270,6 @@ impl<'a> Services<'a> {
         let args = ignore_overwritten_cli_params(args);
 
         let args = orderbook::arguments::Arguments::try_parse_from(args).unwrap();
-        let config = orderbook::config::Configuration::from_path(&args.config)
-            .await
-            .unwrap();
         tokio::task::spawn(orderbook::run(args, config));
 
         Self::wait_for_api_to_come_up().await;
@@ -282,26 +277,37 @@ impl<'a> Services<'a> {
 
     /// Starts a basic version of the protocol with a single baseline solver.
     pub async fn start_protocol(&self, solver: TestAccount) {
-        let (_autopilot_config_file, autopilot_cli_arg) =
-            Configuration::test("test_solver", solver.address()).to_cli_args();
         self.start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![autopilot_cli_arg],
-                ..Default::default()
-            },
+            Default::default(),
+            autopilot::config::Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
     }
 
-    pub async fn start_protocol_with_args(&self, args: ExtraServiceArgs, solver: TestAccount) {
-        self.start_protocol_with_args_and_haircut(args, solver, 0)
-            .await;
+    pub async fn start_protocol_with_args(
+        &self,
+        args: ExtraServiceArgs,
+        autopilot_config: autopilot::config::Configuration,
+        orderbook_config: orderbook::config::Configuration,
+        solver: TestAccount,
+    ) {
+        self.start_protocol_with_args_and_haircut(
+            args,
+            autopilot_config,
+            orderbook_config,
+            solver,
+            0,
+        )
+        .await;
     }
 
     pub async fn start_protocol_with_args_and_haircut(
         &self,
         args: ExtraServiceArgs,
+        autopilot_config: autopilot::config::Configuration,
+        orderbook_config: orderbook::config::Configuration,
         solver: TestAccount,
         haircut_bps: u32,
     ) {
@@ -334,19 +340,10 @@ impl<'a> Services<'a> {
                 args.autopilot,
             ]
             .concat(),
+            autopilot_config,
         )
         .await;
 
-        let has_ob_config = args.api.iter().any(|a| a.starts_with("--config="));
-        let (_default_ob_config_file, api_args) = if has_ob_config {
-            (None, args.api)
-        } else {
-            let (file, arg) = orderbook::config::Configuration::default().to_cli_args();
-            let mut api = args.api;
-            api.push(arg);
-            (Some(file), api)
-        };
-
         self.start_api(
             [
                 vec![
@@ -354,9 +351,10 @@ impl<'a> Services<'a> {
                         .to_string(),
                     "--gas-estimators=http://localhost:11088/gasprice".to_string(),
                 ],
-                api_args,
+                args.api,
             ]
             .concat(),
+            orderbook_config,
         )
         .await;
     }
@@ -383,8 +381,17 @@ impl<'a> Services<'a> {
             forwarder_contract: None,
         }];
 
+        let shared_native_price_config =
+            price_estimation::config::native_price::NativePriceConfig {
+                cache: price_estimation::config::native_price::CacheConfig {
+                    max_age: Duration::from_secs(2),
+                    ..Default::default()
+                },
+                ..Default::default()
+            };
+
         // Create TOML config files
-        let (_autopilot_config_file, autopilot_config_arg) = Configuration {
+        let autopilot_config = Configuration {
             native_price_estimation: {
                 if run_baseline {
                     NativePriceConfig {
@@ -398,7 +405,8 @@ impl<'a> Services<'a> {
                                 Url::from_str("http://localhost:11088/test_solver").unwrap(),
                             ),
                         ]]),
-                        ..Default::default()
+                        shared: shared_native_price_config.clone(),
+                        ..NativePriceConfig::test_default()
                     }
                 } else {
                     NativePriceConfig {
@@ -408,15 +416,13 @@ impl<'a> Services<'a> {
                                 Url::from_str("http://localhost:11088/test_solver").unwrap(),
                             ),
                         ]]),
-                        ..Default::default()
+                        shared: shared_native_price_config,
+                        ..NativePriceConfig::test_default()
                     }
                 }
             },
             ..Configuration::test("test_solver", solver.address())
-        }
-        .to_cli_args();
-        let (_orderbook_config_file, orderbook_config_arg) =
-            orderbook::config::Configuration::default().to_cli_args();
+        };
 
         let (autopilot_args, api_args) = if run_baseline {
             solvers.push(
@@ -434,23 +440,19 @@ impl<'a> Services<'a> {
             // Here we call the baseline_solver "test_quoter" to make the native price
             // estimation use the baseline_solver instead of the test_quoter
             let autopilot_args = vec![
-                autopilot_config_arg.clone(),
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
             ];
             let api_args = vec![
-                orderbook_config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
             ];
             (autopilot_args, api_args)
         } else {
             let autopilot_args = vec![
-                autopilot_config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ];
 
             let api_args = vec![
-                orderbook_config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ];
@@ -464,9 +466,14 @@ impl<'a> Services<'a> {
             false,
         );
 
-        self.start_autopilot(Some(Duration::from_secs(11)), autopilot_args)
+        self.start_autopilot(
+            Some(Duration::from_secs(11)),
+            autopilot_args,
+            autopilot_config,
+        )
+        .await;
+        self.start_api(api_args, orderbook::config::Configuration::test_default())
             .await;
-        self.start_api(api_args).await;
     }
 
     async fn wait_for_api_to_come_up() {
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index b4439d3677..12f4594824 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -85,15 +85,10 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
         ],
     );
 
-    // Configure autopilot-leader only with test_solver
-    let (_config_file_leader, config_arg_leader) =
-        Configuration::test("test_solver", solver1.address()).to_cli_args();
-
     let autopilot_leader = services
         .start_autopilot_with_shutdown_controller(
             None,
             vec![
-                config_arg_leader,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
@@ -101,19 +96,16 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
                 "--api-address=0.0.0.0:12088".to_string(),
                 "--enable-leader-lock=true".to_string(),
             ],
+            // Configure autopilot-leader only with test_solver
+            Configuration::test("test_solver", solver1.address()),
             control,
         )
         .await;
 
-    // Configure autopilot-backup only with test_solver2
-    let (_config_file_follower, config_arg_follower) =
-        Configuration::test("test_solver2", solver2.address()).to_cli_args();
-
     let _autopilot_follower = services
         .start_autopilot(
             None,
             vec![
-                config_arg_follower,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
@@ -121,17 +113,28 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
                 "--api-address=0.0.0.0:12089".to_string(),
                 "--enable-leader-lock=true".to_string(),
             ],
+            // Configure autopilot-backup only with test_solver2
+            Configuration::test("test_solver2", solver2.address()),
         )
         .await;
 
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver1,test_solver2|http://localhost:11088/test_solver2".to_string(),
-            "--native-price-estimators=Forwarder|http://0.0.0.0:9588".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver1,test_solver2|http://localhost:11088/test_solver2".to_string(),
+            ],
+            orderbook::config::Configuration {
+                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+                    estimators: price_estimation::NativePriceEstimators::new(vec![vec![
+                        price_estimation::NativePriceEstimator::forwarder(
+                            "http://0.0.0.0:9588".parse().unwrap(),
+                        ),
+                    ]]),
+                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                },
+                ..orderbook::config::Configuration::test_default()
+            },
+        )
         .await;
 
     let order = || {
diff --git a/crates/e2e/tests/e2e/banned_users.rs b/crates/e2e/tests/e2e/banned_users.rs
index 4171cea0dd..e317134fdc 100644
--- a/crates/e2e/tests/e2e/banned_users.rs
+++ b/crates/e2e/tests/e2e/banned_users.rs
@@ -95,5 +95,14 @@ async fn forked_mainnet_onchain_banned_user_test(web3: Web3) {
             ..Default::default()
         })
         .await;
-    assert!(matches!(result, Err((StatusCode::FORBIDDEN, _))));
+
+    match result {
+        Err((StatusCode::FORBIDDEN, _)) => { /* passed! */ }
+        Err((status_code, _)) => panic!(
+            "expected status_code to be {}; got {}",
+            StatusCode::FORBIDDEN,
+            status_code
+        ),
+        Ok(result) => panic!("expected error, got {:?}", result),
+    }
 }
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index f92f31222f..0591151efc 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,6 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::{Configuration, trusted_tokens::TrustedTokensConfig},
+    autopilot::config::trusted_tokens::TrustedTokensConfig,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -61,36 +61,34 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
         false,
     );
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) = Configuration {
-        trusted_tokens: TrustedTokensConfig {
-            tokens: vec![
-                *onchain.contracts().weth.address(),
-                *token_a.address(),
-                *token_b.address(),
-            ],
-            ..Default::default()
-        },
-        ..Configuration::test("test_solver", solver.address())
-    }
-    .to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
+            autopilot::config::Configuration {
+                trusted_tokens: TrustedTokensConfig {
+                    tokens: vec![
+                        *onchain.contracts().weth.address(),
+                        *token_a.address(),
+                        *token_b.address(),
+                    ],
+                    ..Default::default()
+                },
+                ..autopilot::config::Configuration::test("test_solver", solver.address())
+            },
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Place Order
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index d3c33feaf1..036f7ce100 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -18,14 +18,15 @@ async fn cors_preflight(web3: Web3) {
     let services = Services::new(&onchain).await;
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-            "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
     let client = services.client();
 
@@ -78,14 +79,15 @@ async fn cors_headers_on_error(web3: Web3) {
     let services = Services::new(&onchain).await;
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-            "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
     let client = services.client();
 
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 60370ee0e8..b336c4341d 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -183,26 +183,24 @@ async fn cow_amm_jit(web3: Web3) {
     );
     let services = Services::new(&onchain).await;
 
-    let (_config_file, config_arg) =
-        Configuration::test("mock_solver", solver.address()).to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
+            Configuration::test("mock_solver", solver.address()),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Derive the order's valid_to from the blockchain because the cow amm enforces
@@ -560,34 +558,32 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
     );
     let services = Services::new(&onchain).await;
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![
-            Solver::test("test_solver", solver.address()),
-            Solver::test("mock_solver", solver.address()),
-        ],
-        ..Default::default()
-    }
-    .to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
                 // it uses an older helper contract that was deployed before the desired cow amm
                 "--cow-amm-configs=0xf76c421bAb7df8548604E60deCCcE50477C10462|0x3FF0041A614A9E6Bf392cbB961C97DA214E9CB31|20476672".to_string()
             ],
+            Configuration {
+                drivers: vec![
+                    Solver::test("test_solver", solver.address()),
+                    Solver::test("mock_solver", solver.address()),
+                ],
+                ..Configuration::test_no_drivers()
+            }
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     onchain.mint_block().await;
@@ -836,26 +832,24 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     );
     let services = Services::new(&onchain).await;
 
-    let (_config_file, config_arg) =
-        Configuration::test("mock_solver", solver.address()).to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
                     .to_string(),
             ],
+            Configuration::test("mock_solver", solver.address()),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Get the current block timestamp
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index b905ac0fbb..03cb77f8bb 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -90,27 +90,24 @@ async fn single_limit_order_test(web3: Web3) {
 
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
-
-    let (_config_file, config_arg) =
-        Configuration::test("mock_solver", solver.address()).to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
+            Configuration::test("mock_solver", solver.address()),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Place order
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 308d369c9e..4750d41e0a 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -354,15 +354,16 @@ async fn two_limit_orders_test(web3: Web3) {
             "http://localhost:11089/test_solver".parse().unwrap(),
             Account::Address(solver.address()),
         )],
-        ..Default::default()
+        ..Configuration::test_no_drivers()
     };
-    let (_config_file, config_arg) = config.to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: vec![config_arg, "--compress-solve-request=true".to_string()],
+                autopilot: vec!["--compress-solve-request=true".to_string()],
                 ..Default::default()
             },
+            config,
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -499,15 +500,24 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
     );
 
     let services = Services::new(&onchain).await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-            "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
-                .to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
+            ],
+            orderbook::config::Configuration {
+                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+                    estimators: price_estimation::NativePriceEstimators::new(vec![vec![
+                        price_estimation::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_solver".parse().unwrap(),
+                        ),
+                    ]]),
+                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                },
+                ..orderbook::config::Configuration::test_default()
+            },
+        )
         .await;
 
     // Place Orders
@@ -545,27 +555,24 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
 
     // Start autopilot only once all the orders are created.
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![
-            Solver::new(
-                "solver1".to_string(),
-                Url::from_str("http://localhost:11088/test_solver").unwrap(),
-                Account::Address(solver_a.address()),
-            ),
-            Solver::test("solver2", solver_b.address()),
-        ],
-        ..Default::default()
-    }
-    .to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
                 "--max-winners-per-auction=2".to_string(),
             ],
+            Configuration {
+                drivers: vec![
+                    Solver::new(
+                        "solver1".to_string(),
+                        Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                        Account::Address(solver_a.address()),
+                    ),
+                    Solver::test("solver2", solver_b.address()),
+                ],
+                ..Configuration::test_no_drivers()
+            },
         )
         .await;
 
@@ -729,32 +736,30 @@ async fn too_many_limit_orders_test(web3: Web3) {
         false,
     );
 
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver_address).to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
+            Configuration::test("test_solver", solver_address),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        order_validation: OrderValidationConfig {
-            max_limit_orders_per_user: 1,
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration {
+                order_validation: OrderValidationConfig {
+                    max_limit_orders_per_user: 1,
+                    ..Default::default()
+                },
+                ..orderbook::config::Configuration::test_default()
+            },
+        )
         .await;
 
     let order = OrderCreation {
@@ -834,32 +839,30 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
         false,
     );
 
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver_address).to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
+            Configuration::test("test_solver", solver_address),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        order_validation: OrderValidationConfig {
-            max_limit_orders_per_user: 1,
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration {
+                order_validation: OrderValidationConfig {
+                    max_limit_orders_per_user: 1,
+                    ..Default::default()
+                },
+                ..orderbook::config::Configuration::test_default()
+            },
+        )
         .await;
 
     let quote_request = OrderQuoteRequest {
@@ -1159,42 +1162,37 @@ async fn no_liquidity_limit_order(web3: Web3) {
 
     // Setup services
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![Solver::test("test_solver", solver.address())],
-        fee_policies: FeePoliciesConfig {
-            policies: vec![
-                FeePolicy {
-                    kind: FeePolicyKind::Surplus {
-                        factor: 0.5.try_into().unwrap(),
-                        max_volume_factor: 0.01.try_into().unwrap(),
-                    },
-                    order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Limit,
-                },
-                FeePolicy {
-                    kind: FeePolicyKind::PriceImprovement {
-                        factor: 0.5.try_into().unwrap(),
-                        max_volume_factor: 0.01.try_into().unwrap(),
-                    },
-                    order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Market,
-                },
-            ],
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: [
-                    config_arg,
-                    format!("--unsupported-tokens={:#x}", unsupported.address()),
-                ]
-                .to_vec(),
+                autopilot: vec![format!("--unsupported-tokens={:#x}", unsupported.address())],
                 ..Default::default()
             },
+            Configuration {
+                drivers: vec![Solver::test("test_solver", solver.address())],
+                fee_policies: FeePoliciesConfig {
+                    policies: vec![
+                        FeePolicy {
+                            kind: FeePolicyKind::Surplus {
+                                factor: 0.5.try_into().unwrap(),
+                                max_volume_factor: 0.01.try_into().unwrap(),
+                            },
+                            order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Limit,
+                        },
+                        FeePolicy {
+                            kind: FeePolicyKind::PriceImprovement {
+                                factor: 0.5.try_into().unwrap(),
+                                max_volume_factor: 0.01.try_into().unwrap(),
+                            },
+                            order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Market,
+                        },
+                    ],
+                    ..Default::default()
+                },
+                ..Configuration::test_no_drivers()
+            },
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -1360,15 +1358,12 @@ async fn sell_order_with_haircut_test(web3: Web3) {
     // Place Orders
     let services = Services::new(&onchain).await;
 
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
     // Start protocol with 500 bps (5%) haircut
     services
         .start_protocol_with_args_and_haircut(
-            ExtraServiceArgs {
-                api: vec![],
-                autopilot: vec![config_arg],
-            },
+            Default::default(),
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
             solver,
             500,
         )
@@ -1564,15 +1559,12 @@ async fn buy_order_with_haircut_test(web3: Web3) {
     // Start protocol with 500 bps (5%) haircut
     let services = Services::new(&onchain).await;
 
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
     // Start protocol with 500 bps (5%) haircut
     services
         .start_protocol_with_args_and_haircut(
-            ExtraServiceArgs {
-                api: vec![],
-                autopilot: vec![config_arg],
-            },
+            Default::default(),
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
             solver,
             500,
         )
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 82e498932e..3f726cb2b5 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -190,8 +190,6 @@ async fn zero_ex_liquidity(web3: Web3) {
         },
         false,
     );
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
@@ -199,17 +197,18 @@ async fn zero_ex_liquidity(web3: Web3) {
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                config_arg,
             ],
+            Configuration::test("test_solver", solver.address()),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Drive solution
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index d2ece2ed7a..f87914bf8d 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -202,8 +202,6 @@ http-timeout = "10s"
             liquorice_api.port
         )),
     );
-    let (_config_file, config_arg) =
-        Configuration::test("liquorice_solver", solver.address()).to_cli_args();
 
     services
         .start_autopilot(
@@ -211,17 +209,18 @@ http-timeout = "10s"
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
-                config_arg,
             ],
+            Configuration::test("liquorice_solver", solver.address()),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Create CoW order
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 278568e020..dccd198dad 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -26,14 +26,15 @@ async fn http_validation(web3: Web3) {
     let services = Services::new(&onchain).await;
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-            "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
     let client = services.client();
 
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index ca1ab85c17..6cd57f1197 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -66,24 +66,27 @@ async fn order_cancellation(web3: Web3) {
         colocation::LiquidityProvider::UniswapV2,
         false,
     );
-    let (_config_file, config_arg) = Configuration::default().to_cli_args();
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
+            // Empty drivers to prevent settlement — this test places multiple
+            // orders and asserts exact auction counts, which would race with the
+            // solver settling them.
+            Configuration::test_no_drivers(),
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     onchain.mint_block().await;
@@ -190,7 +193,14 @@ async fn order_cancellation(web3: Web3) {
     ];
     onchain.mint_block().await;
     wait_for_condition(TIMEOUT, || async {
-        services.get_auction().await.auction.orders.len() == 3
+        const WAIT_FOR_N_ORDERS: usize = 3;
+        let n_orders = services.get_auction().await.auction.orders.len();
+        tracing::debug!(
+            "received number of orders: {}, waiting for {}",
+            n_orders,
+            WAIT_FOR_N_ORDERS
+        );
+        n_orders == WAIT_FOR_N_ORDERS
     })
     .await
     .unwrap();
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index cd5474c78b..b7933fe2c5 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -218,32 +218,46 @@ async fn fallback_native_price_estimator(web3: Web3) {
     );
 
     let (manual_shutdown, control) = ShutdownController::new_manual_shutdown();
-    let (_autopilot_config_file, cli_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
     let autopilot_handle = services
         .start_autopilot_with_shutdown_controller(
             None,
             vec![
-                cli_arg,
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
             ],
+            Configuration::test("test_solver", solver.address()),
             control,
         )
         .await;
 
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver".to_string(),
-            "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            "--native-price-estimators-fallback=Driver|test_quoter|http://localhost:11088/test_solver"
-                .to_string(),
-            "--native-price-cache-max-age=2s".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
+                    .to_string(),
+                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
+            ],
+            orderbook::config::Configuration {
+                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+                    fallback_estimators: Some(price_estimation::NativePriceEstimators::new(vec![
+                        vec![price_estimation::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_solver".parse().unwrap(),
+                        )],
+                    ])),
+                    shared: price_estimation::config::native_price::NativePriceConfig {
+                        cache: price_estimation::config::native_price::CacheConfig {
+                            max_age: std::time::Duration::from_secs(2),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    },
+                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                },
+                ..orderbook::config::Configuration::test_default()
+            },
+        )
         .await;
 
     tracing::info!("Quoting with autopilot running");
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 6234fba1d0..339cd4b3ec 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -160,24 +160,20 @@ async fn combined_protocol_fees(web3: Web3) {
         .await
         .unwrap();
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![Solver::test("test_solver", solver.address())],
-        fee_policies: FeePoliciesConfig {
-            policies: vec![limit_surplus_policy, market_price_improvement_policy],
-            max_partner_fee: 0.02.try_into().unwrap(),
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![config_arg],
-                ..Default::default()
+            Default::default(),
+            Configuration {
+                drivers: vec![Solver::test("test_solver", solver.address())],
+                fee_policies: FeePoliciesConfig {
+                    policies: vec![limit_surplus_policy, market_price_improvement_policy],
+                    max_partner_fee: 0.02.try_into().unwrap(),
+                    ..Default::default()
+                },
+                ..Configuration::test_no_drivers()
             },
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -516,23 +512,19 @@ async fn surplus_partner_fee(web3: Web3) {
         .await
         .unwrap();
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![Solver::test("test_solver", solver.address())],
-        fee_policies: FeePoliciesConfig {
-            max_partner_fee: MAX_PARTNER_VOLUME_FEE.try_into().unwrap(),
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![config_arg],
-                ..Default::default()
+            Default::default(),
+            Configuration {
+                drivers: vec![Solver::test("test_solver", solver.address())],
+                fee_policies: FeePoliciesConfig {
+                    max_partner_fee: MAX_PARTNER_VOLUME_FEE.try_into().unwrap(),
+                    ..Default::default()
+                },
+                ..Configuration::test_no_drivers()
             },
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -759,29 +751,27 @@ async fn volume_fee_buy_order_test(web3: Web3) {
     // Place Orders
     // Protocol fee set twice to test that only one policy will apply if the
     // autopilot is not configured to support multiple fees
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![Solver::test("test_solver", solver.address())],
-        fee_policies: FeePoliciesConfig {
-            policies: vec![outdated_fee_policy.clone(), outdated_fee_policy],
-            upcoming_policies: UpcomingFeePolicies {
-                policies: vec![fee_policy.clone(), fee_policy],
-                // Set the effective time to 10 minutes ago to make sure the new policy
-                // is applied
-                effective_from_timestamp: Some(chrono::Utc::now() - chrono::Duration::minutes(10)),
-            },
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![config_arg],
-                ..Default::default()
+            Default::default(),
+            Configuration {
+                drivers: vec![Solver::test("test_solver", solver.address())],
+                fee_policies: FeePoliciesConfig {
+                    policies: vec![outdated_fee_policy.clone(), outdated_fee_policy],
+                    upcoming_policies: UpcomingFeePolicies {
+                        policies: vec![fee_policy.clone(), fee_policy],
+                        // Set the effective time to 10 minutes ago to make sure the new policy
+                        // is applied
+                        effective_from_timestamp: Some(
+                            chrono::Utc::now() - chrono::Duration::minutes(10),
+                        ),
+                    },
+                    ..Default::default()
+                },
+                ..Configuration::test_no_drivers()
             },
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -924,29 +914,27 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) {
     // Place Orders
     // Protocol fee set twice to test that only one policy will apply if the
     // autopilot is not configured to support multiple fees
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![Solver::test("test_solver", solver.address())],
-        fee_policies: FeePoliciesConfig {
-            policies: vec![fee_policy.clone(), fee_policy],
-            upcoming_policies: UpcomingFeePolicies {
-                policies: vec![future_fee_policy.clone(), future_fee_policy],
-                // Set the effective time to far in the future to make sure the new policy
-                // is NOT applied
-                effective_from_timestamp: Some(chrono::Utc::now() + chrono::Duration::days(1)),
-            },
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![config_arg],
-                ..Default::default()
+            Default::default(),
+            Configuration {
+                drivers: vec![Solver::test("test_solver", solver.address())],
+                fee_policies: FeePoliciesConfig {
+                    policies: vec![fee_policy.clone(), fee_policy],
+                    upcoming_policies: UpcomingFeePolicies {
+                        policies: vec![future_fee_policy.clone(), future_fee_policy],
+                        // Set the effective time to far in the future to make sure the new policy
+                        // is NOT applied
+                        effective_from_timestamp: Some(
+                            chrono::Utc::now() + chrono::Duration::days(1),
+                        ),
+                    },
+                    ..Default::default()
+                },
+                ..Configuration::test_no_drivers()
             },
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -1095,34 +1083,27 @@ async fn volume_fee_overrides(web3: Web3) {
         token_usdt.address()
     );
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![Solver::test("test_solver", solver.address())],
-        fee_policies: FeePoliciesConfig {
-            policies: vec![default_volume_fee],
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
-
-    // Orderbook (API) also needs the same bucket overrides for accurate quote
-    // generation
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        volume_fee: Some(orderbook::config::VolumeFeeConfig {
-            factor: Some(FeeFactor::new(0.01)), // Default 1% volume fee
-            effective_from_timestamp: None,
-        }),
-        ..Default::default()
-    }
-    .to_cli_args();
-    let api_config = vec![ob_config_arg, volume_fee_bucket_config.clone()];
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
-                autopilot: vec![config_arg, volume_fee_bucket_config],
-                api: api_config,
+                autopilot: vec![volume_fee_bucket_config.clone()],
+                api: vec![volume_fee_bucket_config],
+            },
+            Configuration {
+                drivers: vec![Solver::test("test_solver", solver.address())],
+                fee_policies: FeePoliciesConfig {
+                    policies: vec![default_volume_fee],
+                    ..Default::default()
+                },
+                ..Configuration::test_no_drivers()
+            },
+            orderbook::config::Configuration {
+                volume_fee: Some(orderbook::config::VolumeFeeConfig {
+                    factor: Some(FeeFactor::new(0.01)), // Default 1% volume fee
+                    effective_from_timestamp: None,
+                }),
+                ..orderbook::config::Configuration::test_default()
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index f0fc867e8a..3ea3f2e283 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -367,7 +367,6 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) = Configuration::default().to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
@@ -379,8 +378,10 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
                     // auto-detection for balance overrides.
                     "--quote-autodetect-token-balance-overrides=true".to_string(),
                 ],
-                autopilot: vec![config_arg],
+                ..Default::default()
             },
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
@@ -518,13 +519,14 @@ async fn usdt_quote_verification(web3: Web3) {
 
     // Place Orders
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
                 api: vec!["--quote-autodetect-token-balance-overrides=true".to_string()],
-                autopilot: vec![config_arg],
+                ..Default::default()
             },
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
             solver,
         )
         .await;
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 5444d2d112..a088caa583 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -1,4 +1,5 @@
 use {
+    autopilot::config::Configuration,
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     futures::FutureExt,
@@ -73,22 +74,22 @@ async fn test(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     // Start API with 0.02% (2 bps) volume fee
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        volume_fee: Some(orderbook::config::VolumeFeeConfig {
-            factor: Some(FeeFactor::new(0.0002)),
-            // Set a far future effective timestamp to ensure the fee is not applied
-            effective_from_timestamp: Some("2099-01-01T10:00:00Z".parse().unwrap()),
-        }),
-        ..Default::default()
-    }
-    .to_cli_args();
-    let args = ExtraServiceArgs {
-        api: vec![ob_config_arg],
-        autopilot: vec![config_arg],
-    };
-    services.start_protocol_with_args(args, solver).await;
+    services
+        .start_protocol_with_args(
+            Default::default(),
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration {
+                volume_fee: Some(orderbook::config::VolumeFeeConfig {
+                    factor: Some(FeeFactor::new(0.0002)),
+                    // Set a far future effective timestamp to ensure the fee is not applied
+                    effective_from_timestamp: Some("2099-01-01T10:00:00Z".parse().unwrap()),
+                }),
+                ..orderbook::config::Configuration::test_default()
+            },
+            solver,
+        )
+        .await;
 
     tracing::info!("Quoting order");
     let request = OrderQuoteRequest {
@@ -317,16 +318,26 @@ async fn quote_timeout(web3: Web3) {
     /// (configurable but always 500ms in e2e tests)
     const MAX_QUOTE_TIME_MS: u64 = 500;
 
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_quoter".to_string(),
-            "--native-price-estimators=Driver|test_quoter|http://localhost:11088/test_solver"
-                .to_string(),
-            format!("--quote-timeout={MAX_QUOTE_TIME_MS}ms"),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_quoter"
+                    .to_string(),
+                format!("--quote-timeout={MAX_QUOTE_TIME_MS}ms"),
+            ],
+            orderbook::config::Configuration {
+                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+                    estimators: price_estimation::NativePriceEstimators::new(vec![vec![
+                        price_estimation::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_solver".parse().unwrap(),
+                        ),
+                    ]]),
+                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                },
+                ..orderbook::config::Configuration::test_default()
+            },
+        )
         .await;
 
     mock_solver.configure_solution_async(Arc::new(|| {
@@ -459,31 +470,31 @@ async fn volume_fee(web3: Web3) {
 
     tracing::info!("Starting services with volume fee.");
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
     // Start API with 0.02% (2 bps) default volume fee
     // Bucket override: WETH<->override_token pair gets 5 bps (both tokens must be
     // in bucket)
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        volume_fee: Some(orderbook::config::VolumeFeeConfig {
-            factor: Some(FeeFactor::new(0.0002)),
-            // Set a past effective timestamp to ensure the fee is applied
-            effective_from_timestamp: Some("2000-01-01T10:00:00Z".parse().unwrap()),
-        }),
-        ..Default::default()
-    }
-    .to_cli_args();
-    let args = ExtraServiceArgs {
-        api: vec![
-            ob_config_arg,
-            format!(
-                "--volume-fee-bucket-overrides=0.0005:{};{}",
-                onchain.contracts().weth.address(),
-                override_token.address()
-            ),
-        ],
-        autopilot: vec![config_arg],
-    };
-    services.start_protocol_with_args(args, solver).await;
+    services
+        .start_protocol_with_args(
+            ExtraServiceArgs {
+                api: vec![format!(
+                    "--volume-fee-bucket-overrides=0.0005:{};{}",
+                    onchain.contracts().weth.address(),
+                    override_token.address()
+                )],
+                ..Default::default()
+            },
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration {
+                volume_fee: Some(orderbook::config::VolumeFeeConfig {
+                    factor: Some(FeeFactor::new(0.0002)),
+                    // Set a past effective timestamp to ensure the fee is applied
+                    effective_from_timestamp: Some("2000-01-01T10:00:00Z".parse().unwrap()),
+                }),
+                ..orderbook::config::Configuration::test_default()
+            },
+            solver,
+        )
+        .await;
 
     tracing::info!("Testing SELL quote with volume fee");
     let sell_request = OrderQuoteRequest {
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index d6ee8da953..0295f44574 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -467,8 +467,6 @@ async fn single_replace_order_test(web3: Web3) {
     onchain.set_solver_allowed(solver.address(), false).await;
 
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) =
-        autopilot::config::Configuration::test("test_solver", solver.address()).to_cli_args();
     services
         .start_protocol_with_args(
             ExtraServiceArgs {
@@ -476,8 +474,10 @@ async fn single_replace_order_test(web3: Web3) {
                 // with the solver being banned. To allow us to still create
                 // orders we override the quote verification to be disabled.
                 api: vec!["--quote-verification=prefer".into()],
-                autopilot: vec![config_arg],
+                ..Default::default()
             },
+            autopilot::config::Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
             solver.clone(),
         )
         .await;
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 60c1527387..c2da63e3f9 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -174,20 +174,16 @@ async fn erc1271_gas_limit(web3: Web3) {
         .unwrap();
 
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) = autopilot::config::Configuration::default().to_cli_args();
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        order_validation: OrderValidationConfig {
-            max_gas_per_order: 1_000_000,
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                api: vec![ob_config_arg],
-                autopilot: vec![config_arg],
+            Default::default(),
+            autopilot::config::Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration {
+                order_validation: OrderValidationConfig {
+                    max_gas_per_order: 1_000_000,
+                    ..Default::default()
+                },
+                ..orderbook::config::Configuration::test_default()
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index abf2312a54..df2e67fc0d 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -86,28 +86,27 @@ async fn solver_competition(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![
-            Solver::test("test_solver", solver.address()),
-            Solver::test("solver2", solver.address()),
-        ],
-        ..Default::default()
-    }
-    .to_cli_args();
-
     services.start_autopilot(
         None,
         vec![
-            config_arg,
             "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
         ],
+        Configuration {
+            drivers: vec![
+                Solver::test("test_solver", solver.address()),
+                Solver::test("solver2", solver.address()),
+            ],
+            ..Configuration::test_no_drivers()
+        }
     ).await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
-    services.start_api(vec![
-        ob_config_arg,
-        "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
-    ]).await;
+    services
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
+        .await;
 
     // Place Order
     let order = OrderCreation {
@@ -238,37 +237,34 @@ async fn wrong_solution_submission_address(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
-    // Solver 1 has a wrong submission address, meaning that the solutions should be
-    // discarded from solver1
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![
-            Solver::new(
-                "solver1".to_string(),
-                Url::from_str("http://localhost:11088/test_solver").unwrap(),
-                Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
-            ),
-            Solver::test("solver2", solver.address()),
-        ],
-        ..Default::default()
-    }
-    .to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
             ],
+            Configuration {
+                drivers: vec![
+                    // Solver 1 has a wrong submission address, meaning that the solutions should
+                    // be discarded from solver1
+                    Solver::new(
+                        "solver1".to_string(),
+                        Url::from_str("http://localhost:11088/test_solver").unwrap(),
+                        Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
+                    ),
+                    Solver::test("solver2", solver.address()),
+                ],
+                ..Configuration::test_no_drivers()
+            },
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Place Orders
@@ -407,34 +403,31 @@ async fn store_filtered_solutions(web3: Web3) {
 
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
-
-    let (_config_file, config_arg) = Configuration {
-        drivers: vec![
-            Solver::test("good_solver", good_solver_account.address()),
-            Solver::test("bad_solver", bad_solver_account.address()),
-        ],
-        ..Default::default()
-    }
-    .to_cli_args();
-
     services
         .start_autopilot(
             None,
             vec![
-                config_arg,
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
                 "--max-winners-per-auction=10".to_string(),
             ],
+            Configuration {
+                drivers: vec![
+                    Solver::test("good_solver", good_solver_account.address()),
+                    Solver::test("bad_solver", bad_solver_account.address()),
+                ],
+                ..Configuration::test_no_drivers()
+            },
         )
         .await;
-    let (_ob_config_file, ob_config_arg) =
-        orderbook::config::Configuration::default().to_cli_args();
     services
-        .start_api(vec![
-            ob_config_arg,
-            "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver".to_string(),
-        ])
+        .start_api(
+            vec![
+                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
+                    .to_string(),
+            ],
+            orderbook::config::Configuration::test_default(),
+        )
         .await;
 
     // Place order
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 016158eb80..9fc2d8f421 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -158,21 +158,16 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        order_validation: OrderValidationConfig {
-            same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                api: vec![ob_config_arg],
-                autopilot: vec![config_arg],
+            Default::default(),
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration {
+                order_validation: OrderValidationConfig {
+                    same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
+                    ..Default::default()
+                },
+                ..orderbook::config::Configuration::test_default()
             },
             solver.clone(),
         )
@@ -279,21 +274,16 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
-    let (_config_file, config_arg) =
-        Configuration::test("test_solver", solver.address()).to_cli_args();
-    let (_ob_config_file, ob_config_arg) = orderbook::config::Configuration {
-        order_validation: OrderValidationConfig {
-            same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
-            ..Default::default()
-        },
-        ..Default::default()
-    }
-    .to_cli_args();
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                api: vec![ob_config_arg],
-                autopilot: vec![config_arg],
+            Default::default(),
+            Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration {
+                order_validation: OrderValidationConfig {
+                    same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
+                    ..Default::default()
+                },
+                ..orderbook::config::Configuration::test_default()
             },
             solver.clone(),
         )
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index b839d8f8ae..9d31f7ed7a 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -81,5 +81,5 @@ workspace = true
 [features]
 e2e = []
 mimalloc-allocator = ["dep:mimalloc"]
-test-util = ["dep:tempfile"]
+test-util = ["dep:tempfile", "shared/test-util"]
 tokio-console = ["observe/tokio-console"]
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index 9cca5bc85a..da32dc747b 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,8 +1,8 @@
 use {
-    price_estimation::{self, NativePriceEstimators},
+    price_estimation,
     reqwest::Url,
     shared::{arguments::display_secret_option, http_client},
-    std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf},
+    std::{net::SocketAddr, path::PathBuf},
 };
 
 #[derive(clap::Parser)]
@@ -38,25 +38,6 @@ pub struct Arguments {
     /// db_write_url
     #[clap(long, env)]
     pub db_read_url: Option<Url>,
-
-    /// Which estimators to use to estimate token prices in terms of the chain's
-    /// native token.
-    #[clap(long, env)]
-    pub native_price_estimators: NativePriceEstimators,
-
-    /// Fallback native price estimators to use when all primary estimators
-    /// are down.
-    #[clap(long, env)]
-    pub native_price_estimators_fallback: Option<NativePriceEstimators>,
-
-    /// How many successful price estimates for each order will cause a fast
-    /// or native price estimation to return its result early.
-    /// The bigger the value the more the fast price estimation performs like
-    /// the optimal price estimation.
-    /// It's possible to pass values greater than the total number of enabled
-    /// estimators but that will not have any further effect.
-    #[clap(long, env, default_value = "2")]
-    pub fast_price_estimation_results_required: NonZeroUsize,
 }
 
 impl std::fmt::Display for Arguments {
@@ -69,9 +50,6 @@ impl std::fmt::Display for Arguments {
             database_pool,
             config,
             bind_address,
-            native_price_estimators,
-            native_price_estimators_fallback,
-            fast_price_estimation_results_required,
             db_write_url: db_url,
             db_read_url,
         } = self;
@@ -86,15 +64,6 @@ impl std::fmt::Display for Arguments {
         let _intentionally_ignored = db_url;
         writeln!(f, "db_url: SECRET")?;
         display_secret_option(f, "db_read_url", db_read_url.as_ref())?;
-        writeln!(f, "native_price_estimators: {native_price_estimators}")?;
-        writeln!(
-            f,
-            "native_price_estimators_fallback: {native_price_estimators_fallback:?}"
-        )?;
-        writeln!(
-            f,
-            "fast_price_estimation_results_required: {fast_price_estimation_results_required}"
-        )?;
 
         Ok(())
     }
diff --git a/crates/orderbook/src/config/mod.rs b/crates/orderbook/src/config/mod.rs
index 2817820ef9..a496786541 100644
--- a/crates/orderbook/src/config/mod.rs
+++ b/crates/orderbook/src/config/mod.rs
@@ -2,6 +2,7 @@ use {
     crate::config::{
         banned_users::BannedUsersConfig,
         ipfs::IpfsConfig,
+        native_price::NativePriceConfig,
         order_validation::OrderValidationConfig,
     },
     alloy::primitives::Address,
@@ -14,6 +15,7 @@ use {
 
 pub mod banned_users;
 pub mod ipfs;
+pub mod native_price;
 pub mod order_validation;
 
 const fn default_app_data_size_limit() -> usize {
@@ -64,21 +66,9 @@ pub struct Configuration {
     /// Whether to skip EIP-1271 signature validation.
     #[serde(default)]
     pub eip1271_skip_creation_validation: bool,
-}
 
-impl Default for Configuration {
-    fn default() -> Self {
-        Self {
-            order_validation: Default::default(),
-            ipfs: Default::default(),
-            app_data_size_limit: default_app_data_size_limit(),
-            active_order_competition_threshold: default_active_order_competition_threshold(),
-            volume_fee: None,
-            unsupported_tokens: Default::default(),
-            banned_users: Default::default(),
-            eip1271_skip_creation_validation: false,
-        }
-    }
+    /// Configuration for the native price estimation mechanism.
+    pub native_price_estimation: NativePriceConfig,
 }
 
 impl Configuration {
@@ -121,11 +111,30 @@ impl Configuration {
         let cli_arg = format!("--config={}", named_temp_file.path().display());
         (named_temp_file, cli_arg)
     }
+
+    pub fn test_default() -> Self {
+        Self {
+            order_validation: Default::default(),
+            banned_users: Default::default(),
+            ipfs: Default::default(),
+            volume_fee: Default::default(),
+            app_data_size_limit: default_app_data_size_limit(),
+            active_order_competition_threshold: default_active_order_competition_threshold(),
+            unsupported_tokens: Default::default(),
+            eip1271_skip_creation_validation: Default::default(),
+            native_price_estimation: NativePriceConfig::test_default(),
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use {super::*, shared::order_validation::SameTokensPolicy, std::time::Duration};
+    use {
+        super::*,
+        price_estimation::{NativePriceEstimator, NativePriceEstimators},
+        shared::order_validation::SameTokensPolicy,
+        std::time::Duration,
+    };
 
     #[test]
     fn deserialize_full_configuration() {
@@ -153,6 +162,9 @@ mod tests {
         [volume-fee]
         factor = 0.0002
         effective-from-timestamp = "2025-06-01T00:00:00Z"
+
+        [native-price-estimation]
+        estimators = [[{type = "CoinGecko"}]]
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -193,7 +205,11 @@ mod tests {
 
     #[test]
     fn deserialize_configuration_defaults() {
-        let config: Configuration = toml::from_str("").unwrap();
+        let toml = r#"
+        [native-price-estimation]
+        estimators = [[{type = "CoinGecko"}]]
+        "#;
+        let config: Configuration = toml::from_str(toml).unwrap();
 
         assert_eq!(config.app_data_size_limit, 8192);
         assert_eq!(config.active_order_competition_threshold, 5);
@@ -246,6 +262,11 @@ mod tests {
             ],
             banned_users: Default::default(),
             eip1271_skip_creation_validation: true,
+            native_price_estimation: NativePriceConfig {
+                estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
+                fallback_estimators: None,
+                ..NativePriceConfig::test_default()
+            },
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/orderbook/src/config/native_price.rs b/crates/orderbook/src/config/native_price.rs
new file mode 100644
index 0000000000..bd7dc80158
--- /dev/null
+++ b/crates/orderbook/src/config/native_price.rs
@@ -0,0 +1,98 @@
+use {
+    price_estimation::{
+        NativePriceEstimators,
+        config::native_price::NativePriceConfig as SharedNativePriceConfig,
+    },
+    serde::{Deserialize, Serialize},
+    std::str::FromStr,
+};
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct NativePriceConfig {
+    /// Which estimators to use to estimate token prices in terms of the chain's
+    /// native token.
+    pub estimators: NativePriceEstimators,
+
+    /// Fallback native price estimators to use when all primary estimators
+    /// are down.
+    pub fallback_estimators: Option<NativePriceEstimators>,
+
+    #[serde(flatten)]
+    pub shared: SharedNativePriceConfig,
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl NativePriceConfig {
+    /// The orderbook forwards native price requests to the autopilot.
+    pub fn test_default() -> Self {
+        use price_estimation::NativePriceEstimator;
+        Self {
+            estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::forwarder(
+                reqwest::Url::from_str("http://localhost:12088").unwrap(),
+            )]]),
+            fallback_estimators: Default::default(),
+            shared: Default::default(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let config: NativePriceConfig =
+            toml::from_str(r#"estimators = [[{type = "CoinGecko"}]]"#).unwrap();
+        assert_eq!(config.estimators.as_slice().len(), 1);
+        assert!(config.fallback_estimators.is_none());
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+            estimators = [[{ type = "CoinGecko" }, { type = "OneInchSpotPriceApi" }]]
+            fallback-estimators = [[{ type = "CoinGecko" }]]
+            results-required = 3
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert!(config.fallback_estimators.is_some());
+    }
+
+    #[test]
+    fn deserialize_driver_estimator() {
+        let toml = r#"
+            estimators = [[{ type = "Driver", name = "test", url = "http://localhost:8080" }]]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert!(!config.estimators.as_slice().is_empty());
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        use price_estimation::NativePriceEstimator;
+
+        let config = NativePriceConfig {
+            estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
+            fallback_estimators: Some(NativePriceEstimators::new(vec![vec![
+                NativePriceEstimator::OneInchSpotPriceApi,
+            ]])),
+            shared: Default::default(),
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
+        assert_eq!(
+            deserialized.estimators.as_slice(),
+            config.estimators.as_slice(),
+        );
+        assert_eq!(
+            deserialized
+                .fallback_estimators
+                .as_ref()
+                .map(|e| e.as_slice()),
+            config.fallback_estimators.as_ref().map(|e| e.as_slice()),
+        );
+    }
+}
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 7a0e900b25..801d46c358 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -65,6 +65,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
     let config = Configuration::from_path(&args.config)
         .await
         .expect("failed to load configuration file");
+    tracing::info!("file configuration:\n{:#?}", config);
     run(args, config).await;
 }
 
@@ -213,6 +214,7 @@ pub async fn run(args: Arguments, config: Configuration) {
 
     let mut price_estimator_factory = PriceEstimatorFactory::new(
         &args.price_estimation,
+        &config.native_price_estimation.shared,
         factory::Network {
             web3: web3.clone(),
             simulation_web3,
@@ -240,24 +242,24 @@ pub async fn run(args: Arguments, config: Configuration) {
 
     let prices = postgres_write.fetch_latest_prices().await.unwrap();
     let cache = price_estimation::native_price_cache::Cache::new(
-        args.price_estimation.native_price_cache_max_age,
+        config.native_price_estimation.shared.cache.max_age,
         prices,
     );
     let primary = price_estimator_factory
         .native_price_estimator(
-            args.native_price_estimators.as_slice(),
-            args.fast_price_estimation_results_required,
+            config.native_price_estimation.estimators.as_slice(),
+            config.native_price_estimation.shared.results_required,
             &native_token,
         )
         .await
         .expect("failed to build primary native price estimator");
 
     let inner: Box<dyn NativePriceEstimating> =
-        if let Some(ref fallback_config) = args.native_price_estimators_fallback {
+        if let Some(ref fallback_config) = config.native_price_estimation.fallback_estimators {
             let fallback = price_estimator_factory
                 .native_price_estimator(
                     fallback_config.as_slice(),
-                    args.fast_price_estimation_results_required,
+                    config.native_price_estimation.shared.results_required,
                     &native_token,
                 )
                 .await
@@ -299,7 +301,7 @@ pub async fn run(args: Arguments, config: Configuration) {
                     url: price_estimator_driver.url.clone(),
                 })
                 .collect::<Vec<_>>(),
-            args.fast_price_estimation_results_required,
+            config.native_price_estimation.shared.results_required,
             native_price_estimator.clone(),
             gas_price_estimator.clone(),
         )
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index 0dbaa1a305..cbc15b8a6a 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -26,6 +26,7 @@ ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
 humantime = { workspace = true }
+humantime-serde = { workspace = true }
 itertools = { workspace = true }
 mockall = { workspace = true, optional = true }
 model = { workspace = true }
diff --git a/crates/price-estimation/src/config/mod.rs b/crates/price-estimation/src/config/mod.rs
new file mode 100644
index 0000000000..63c215df15
--- /dev/null
+++ b/crates/price-estimation/src/config/mod.rs
@@ -0,0 +1 @@
+pub mod native_price;
diff --git a/crates/price-estimation/src/config/native_price.rs b/crates/price-estimation/src/config/native_price.rs
new file mode 100644
index 0000000000..8ae411d1fa
--- /dev/null
+++ b/crates/price-estimation/src/config/native_price.rs
@@ -0,0 +1,155 @@
+use {
+    alloy::primitives::Address,
+    serde::{Deserialize, Serialize},
+    std::{num::NonZeroUsize, time::Duration},
+};
+
+const fn default_cache_max_age() -> Duration {
+    Duration::from_mins(10)
+}
+
+const fn default_cache_concurrent_requests() -> NonZeroUsize {
+    NonZeroUsize::new(1).expect("value should be greater than 0")
+}
+
+const fn default_results_required() -> NonZeroUsize {
+    NonZeroUsize::new(2).expect("value should not be zero")
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct NativePriceConfig {
+    /// List of mappings of native price tokens substitutions with approximated:
+    /// - the first is a token address for which we get the native token price
+    /// - the second is a token address used for the price approximation
+    #[serde(default)]
+    pub approximation_tokens: Vec<(Address, Address)>,
+
+    /// Configuration for the native price caching mechanism.
+    #[serde(default)]
+    pub cache: CacheConfig,
+
+    /// How many successful price estimates for each order will cause a native
+    /// price estimation to return its result early.
+    ///
+    /// As this value increases, the fast estimator behavior will approximate
+    /// the behavior of the optimal estimator.
+    ///
+    /// It's possible to pass values greater than the total number of enabled
+    /// estimators but that will not have any further effect.
+    #[serde(default = "default_results_required")]
+    pub results_required: NonZeroUsize,
+}
+
+impl Default for NativePriceConfig {
+    fn default() -> Self {
+        Self {
+            approximation_tokens: Default::default(),
+            cache: Default::default(),
+            results_required: default_results_required(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct CacheConfig {
+    /// How long cached native prices stay valid.
+    #[serde(default = "default_cache_max_age", with = "humantime_serde")]
+    pub max_age: Duration,
+
+    /// How many price estimation requests can be executed concurrently in the
+    /// maintenance task.
+    #[serde(default = "default_cache_concurrent_requests")]
+    pub concurrent_requests: NonZeroUsize,
+}
+
+impl Default for CacheConfig {
+    fn default() -> Self {
+        Self {
+            max_age: default_cache_max_age(),
+            concurrent_requests: default_cache_concurrent_requests(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+            approximation-tokens = [
+                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
+            ]
+
+            [cache]
+            max-age = "5m"
+            concurrent-requests = 4
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.approximation_tokens.len(), 1);
+        assert_eq!(config.cache.max_age, Duration::from_secs(300));
+        assert_eq!(
+            config.cache.concurrent_requests,
+            NonZeroUsize::new(4).unwrap()
+        );
+    }
+
+    #[test]
+    fn cache_defaults() {
+        let toml = r#"
+            approximation-tokens = []
+            [cache]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.cache.max_age, Duration::from_mins(10));
+        assert_eq!(
+            config.cache.concurrent_requests,
+            NonZeroUsize::new(1).unwrap()
+        );
+    }
+
+    #[test]
+    fn multiple_approximation_tokens() {
+        let toml = r#"
+            approximation-tokens = [
+                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
+                ["0x0000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000004"],
+            ]
+            [cache]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.approximation_tokens.len(), 2);
+        assert_eq!(
+            config.approximation_tokens[0].0,
+            Address::from_slice(&[0; 19].into_iter().chain([1]).collect::<Vec<_>>()),
+        );
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = NativePriceConfig {
+            approximation_tokens: vec![(Address::repeat_byte(1), Address::repeat_byte(2))],
+            cache: CacheConfig {
+                max_age: Duration::from_secs(120),
+                concurrent_requests: NonZeroUsize::new(8).unwrap(),
+            },
+            results_required: default_results_required(),
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(
+            config.approximation_tokens,
+            deserialized.approximation_tokens,
+        );
+        assert_eq!(config.cache.max_age, deserialized.cache.max_age);
+        assert_eq!(
+            config.cache.concurrent_requests,
+            deserialized.cache.concurrent_requests,
+        );
+    }
+}
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index e618b17b6b..79c78381d1 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -15,6 +15,7 @@ use {
         ExternalSolver,
         buffered::{self, BufferedRequest, NativePriceBatchFetching},
         competition::PriceRanking,
+        config::native_price::NativePriceConfig,
         trade_verifier::{code_fetching::CachedCodeFetcher, tenderly_api::TenderlyCodeSimulator},
         utils::http_client_factory::HttpClientFactory,
     },
@@ -31,15 +32,6 @@ use {
     token_info::TokenInfoFetching,
 };
 
-/// A factory for initializing shared price estimators.
-pub struct PriceEstimatorFactory<'a> {
-    args: &'a Arguments,
-    network: Network,
-    components: Components,
-    trade_verifier: Option<Arc<dyn TradeVerifying>>,
-    estimators: HashMap<String, EstimatorEntry>,
-}
-
 #[derive(Clone)]
 struct EstimatorEntry {
     optimal: Arc<dyn PriceEstimating>,
@@ -66,15 +58,27 @@ pub struct Components {
     pub code_fetcher: Arc<CachedCodeFetcher>,
 }
 
+/// A factory for initializing shared price estimators.
+pub struct PriceEstimatorFactory<'a> {
+    args: &'a Arguments,
+    config: &'a NativePriceConfig,
+    network: Network,
+    components: Components,
+    trade_verifier: Option<Arc<dyn TradeVerifying>>,
+    estimators: HashMap<String, EstimatorEntry>,
+}
+
 impl<'a> PriceEstimatorFactory<'a> {
     pub async fn new(
         args: &'a Arguments,
+        config: &'a NativePriceConfig,
         network: Network,
         components: Components,
     ) -> Result<Self> {
         Ok(Self {
             trade_verifier: Self::trade_verifier(args, &network, &components).await?,
             args,
+            config,
             network,
             components,
             estimators: HashMap::new(),
@@ -405,7 +409,7 @@ impl<'a> PriceEstimatorFactory<'a> {
         native_price_cache::CachingNativePriceEstimator::new(
             inner,
             cache,
-            self.args.native_price_cache_concurrent_requests,
+            self.config.cache.concurrent_requests.get(),
             approximation_tokens,
             self.args.quote_timeout,
         )
@@ -414,7 +418,7 @@ impl<'a> PriceEstimatorFactory<'a> {
     /// Builds the approximation tokens mapping with normalization factors based
     /// on decimal differences between token pairs.
     async fn build_approximation_tokens(&self) -> Result<HashMap<Address, ApproximationToken>> {
-        let pairs = &self.args.native_price_approximation_tokens;
+        let pairs = &self.config.approximation_tokens;
         if pairs.is_empty() {
             return Ok(HashMap::new());
         }
diff --git a/crates/price-estimation/src/lib.rs b/crates/price-estimation/src/lib.rs
index 32c5ebafc5..6428f4b30d 100644
--- a/crates/price-estimation/src/lib.rs
+++ b/crates/price-estimation/src/lib.rs
@@ -16,7 +16,6 @@ use {
     serde::{Deserialize, Serialize},
     std::{
         cmp::{Eq, PartialEq},
-        error::Error,
         fmt::{self, Display, Formatter},
         future::Future,
         hash::Hash,
@@ -29,6 +28,7 @@ use {
 
 mod buffered;
 pub mod competition;
+pub mod config;
 pub mod external;
 pub mod factory;
 pub mod gas;
@@ -40,15 +40,52 @@ pub mod trade_finding;
 pub mod trade_verifier;
 pub mod utils;
 
-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default, Serialize)]
 pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
 
+impl<'de> Deserialize<'de> for NativePriceEstimators {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let estimators = <Vec<Vec<NativePriceEstimator>>>::deserialize(deserializer)?;
+        if estimators.is_empty() {
+            return Err(serde::de::Error::invalid_length(
+                0,
+                &"expected native price estimator stages to be configured",
+            ));
+        }
+        match estimators
+            .iter()
+            .enumerate()
+            .find_map(|(n, stage)| stage.is_empty().then_some(n))
+        {
+            Some(n) => Err(serde::de::Error::invalid_length(
+                0,
+                &format!("stage {} is empty, all stages must not be empty", n).as_str(),
+            )),
+            None => Ok(Self(estimators)),
+        }
+    }
+}
+
 impl NativePriceEstimators {
     pub fn new(estimators: Vec<Vec<NativePriceEstimator>>) -> Self {
         Self(estimators)
     }
 }
 
+#[cfg(any(test, feature = "test-util"))]
+impl NativePriceEstimators {
+    /// Returns a list with a single stage, said stage contains a Driver estimator named `test_quoter` with URL `http://localhost:11088/test_solver`.
+    pub fn test_default() -> Self {
+        NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
+            "test_quoter".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+        )]])
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct ExternalSolver {
     pub name: String,
@@ -177,30 +214,12 @@ pub struct Arguments {
     #[clap(long, env, verbatim_doc_comment)]
     pub price_estimation_rate_limiter: Option<Strategy>,
 
-    /// How long cached native prices stay valid.
-    #[clap(
-        long,
-        env,
-        default_value = "10m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub native_price_cache_max_age: Duration,
-
-    /// How many price estimation requests can be executed concurrently in the
-    /// maintenance task.
-    #[clap(long, env, default_value = "1")]
-    pub native_price_cache_concurrent_requests: usize,
-
     /// The amount in native tokens atoms to use for price estimation. Should be
     /// reasonably large so that small pools do not influence the prices. If
     /// not set a reasonable default is used based on network id.
     #[clap(long, env)]
     pub amount_to_estimate_prices_with: Option<alloy::primitives::U256>,
 
-    /// The API endpoint for the Balancer SOR API for solving.
-    #[clap(long, env)]
-    pub balancer_sor_url: Option<Url>,
-
     /// The API key for the 1Inch API.
     #[clap(long, env)]
     pub one_inch_api_key: Option<String>,
@@ -242,19 +261,6 @@ pub struct Arguments {
     #[clap(flatten)]
     pub balance_overrides: balance_overrides::Arguments,
 
-    /// List of mappings of native price tokens substitutions with approximated
-    /// value from other token:
-    /// "<token1>|<approx_token1>,<token2>|<approx_token2>"
-    /// - token1 is a token address for which we get the native token price
-    /// - approx_token1 is a token address used for the price approximation
-    #[clap(
-        long,
-        env,
-        value_delimiter = ',',
-        value_parser = parse_tuple::<Address, Address>
-    )]
-    pub native_price_approximation_tokens: Vec<(Address, Address)>,
-
     /// Tokens for which quote verification should not be attempted. This is an
     /// escape hatch when there is a very bad but verifiable liquidity source
     /// that would win against a very good but unverifiable liquidity source
@@ -263,25 +269,6 @@ pub struct Arguments {
     pub tokens_without_verification: Vec<Address>,
 }
 
-/// Custom Clap parser for tuple pair
-fn parse_tuple<T, U>(input: &str) -> Result<(T, U), Box<dyn Error + Send + Sync + 'static>>
-where
-    T: std::str::FromStr,
-    T::Err: Error + Send + Sync + 'static,
-    U: std::str::FromStr,
-    U::Err: Error + Send + Sync + 'static,
-{
-    let pos = input.find('|').ok_or_else(|| {
-        format!(
-            "invalid pair values delimiter character, expected: 'value1|value2', got: '{input}'"
-        )
-    })?;
-    Ok((
-        input[..pos].trim().parse()?,
-        input[pos + 1..].trim().parse()?,
-    ))
-}
-
 #[derive(clap::Parser)]
 pub struct CoinGecko {
     /// The API key for the CoinGecko API.
@@ -342,10 +329,7 @@ impl Display for Arguments {
         let Self {
             tenderly,
             price_estimation_rate_limiter,
-            native_price_cache_max_age,
-            native_price_cache_concurrent_requests,
             amount_to_estimate_prices_with,
-            balancer_sor_url,
             one_inch_api_key,
             one_inch_url,
             coin_gecko,
@@ -353,7 +337,6 @@ impl Display for Arguments {
             quote_verification,
             quote_timeout,
             balance_overrides,
-            native_price_approximation_tokens,
             tokens_without_verification,
         } = self;
 
@@ -363,20 +346,11 @@ impl Display for Arguments {
             "price_estimation_rate_limites",
             price_estimation_rate_limiter,
         )?;
-        writeln!(
-            f,
-            "native_price_cache_max_age: {native_price_cache_max_age:?}"
-        )?;
-        writeln!(
-            f,
-            "native_price_cache_concurrent_requests: {native_price_cache_concurrent_requests}"
-        )?;
         display_option(
             f,
             "amount_to_estimate_prices_with: {}",
             amount_to_estimate_prices_with,
         )?;
-        display_option(f, "balancer_sor_url", balancer_sor_url)?;
         display_secret_option(
             f,
             "one_inch_spot_price_api_key: {:?}",
@@ -409,10 +383,6 @@ impl Display for Arguments {
         writeln!(f, "quote_verification: {quote_verification:?}")?;
         writeln!(f, "quote_timeout: {quote_timeout:?}")?;
         write!(f, "{balance_overrides}")?;
-        writeln!(
-            f,
-            "native_price_approximation_tokens: {native_price_approximation_tokens:?}"
-        )?;
         writeln!(
             f,
             "tokens_without_verification: {tokens_without_verification:?}"
@@ -601,7 +571,7 @@ pub mod mocks {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, alloy::primitives::address, clap::Parser};
+    use {super::*, clap::Parser};
 
     #[test]
     fn string_repr_round_trip_native_price_estimators() {
@@ -639,15 +609,13 @@ mod tests {
 
     #[test]
     fn toml_deserialize_estimators_empty() {
-        let toml = "estimators = []";
-
         #[derive(Deserialize)]
         struct Helper {
-            estimators: NativePriceEstimators,
+            _estimators: NativePriceEstimators,
         }
 
-        let parsed: Helper = toml::from_str(toml).unwrap();
-        assert!(parsed.estimators.as_slice().is_empty());
+        assert!(toml::from_str::<Helper>("estimators = []").is_err());
+        assert!(toml::from_str::<Helper>("estimators = [[]]").is_err());
     }
 
     #[test]
@@ -766,52 +734,4 @@ mod tests {
 
         assert!(result.is_err());
     }
-
-    #[test]
-    fn test_parse_tuple() {
-        let result = parse_tuple::<Address, Address>(
-            "0102030405060708091011121314151617181920|a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0",
-        )
-        .unwrap();
-        assert_eq!(
-            result.0,
-            address!("0102030405060708091011121314151617181920")
-        );
-        assert_eq!(
-            result.1,
-            address!("a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0")
-        );
-
-        let result = parse_tuple::<Address, Address>(
-            "0102030405060708091011121314151617181920 a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0",
-        );
-        assert!(result.is_err());
-
-        // test parsing with delimiter
-        #[derive(Parser)]
-        struct Cli {
-            #[arg(value_delimiter = ',', value_parser = parse_tuple::<Address, Address>)]
-            param: Vec<(Address, Address)>,
-        }
-        let cli = Cli::parse_from(vec![
-            "",
-            r#"0102030405060708091011121314151617181920|a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0,
-            f102030405060708091011121314151617181920|f1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0"#,
-        ]);
-
-        assert_eq!(
-            cli.param[0],
-            (
-                address!("0102030405060708091011121314151617181920"),
-                address!("a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0")
-            )
-        );
-        assert_eq!(
-            cli.param[1],
-            (
-                address!("f102030405060708091011121314151617181920"),
-                address!("f1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0")
-            )
-        );
-    }
 }

From 594a1afd33b014d13b96cde25d1a43c840e4d14b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 4 Mar 2026 13:35:38 +0000
Subject: [PATCH 121/219] Accept hex params with and without 0x prefix (#4228)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
During the Axum migration we (unknowingly) stopped supporting unprefixed
hex values — this was due to Axum using the JSON deserialization (which
for OrderUids for example, was rejecting non-prefixed hex) while warp
used FromStr which had a more lenient implementation.

This PR unifies the FromStr and serde impls and adds tests to the
endpoints to ensure

# Changes

We notified downstream partners but this single path was forgotten in
the respective migration
* Refactor cancel_order handler to use Axum typed extractors
(Path<OrderUid>, Json<CancellationPayload>) instead of manual parsing
* Change solver_competition_v2 auction_id to u64 so negative values
return BAD_REQUEST

* Update OrderUid deserialization and FromStr to delegate 0x handling to
const_hex (which strips the prefix internally)
* Add extraction tests across all orderbook API endpoints verifying hex
params (OrderUid, Address, B256, AppDataHash) accept both prefixed and
non-prefixed input

## How to test
Run tests

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 crates/model/src/order.rs                     |  11 +-
 crates/orderbook/src/api.rs                   | 384 +++++++++++++++++-
 crates/orderbook/src/api/cancel_order.rs      |  16 +-
 .../src/api/get_solver_competition_v2.rs      |  12 +-
 4 files changed, 399 insertions(+), 24 deletions(-)

diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index f4b76b1b80..25fa288d97 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -733,7 +733,8 @@ pub struct OrderMetadata {
 /// Chosen to be under the MAX_JSON_BODY_PAYLOAD size of 1024 * 16
 pub const ORDER_UID_LIMIT: usize = 128;
 
-// uid as 56 bytes: 32 for orderDigest, 20 for ownerAddress and 4 for validTo
+/// Uid as 56 bytes: 32 for orderDigest, 20 for ownerAddress and 4 for validTo
+/// Should be readable from prefixed and non-prefixed hex!
 #[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct OrderUid(pub [u8; 56]);
 
@@ -769,8 +770,7 @@ impl FromStr for OrderUid {
 
     fn from_str(s: &str) -> Result<OrderUid, const_hex::FromHexError> {
         let mut value = [0u8; 56];
-        let s_without_prefix = s.strip_prefix("0x").unwrap_or(s);
-        const_hex::decode_to_slice(s_without_prefix, value.as_mut())?;
+        const_hex::decode_to_slice(s, value.as_mut())?;
         Ok(OrderUid(value))
     }
 }
@@ -825,11 +825,6 @@ impl<'de> Deserialize<'de> for OrderUid {
             where
                 E: de::Error,
             {
-                let s = s.strip_prefix("0x").ok_or_else(|| {
-                    de::Error::custom(format!(
-                        "{s:?} can't be decoded as hex uid because it does not start with '0x'"
-                    ))
-                })?;
                 let mut value = [0u8; 56];
                 const_hex::decode_to_slice(s, value.as_mut()).map_err(|err| {
                     de::Error::custom(format!("failed to decode {s:?} as hex uid: {err}"))
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 86bbd429ed..9e74855b83 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -476,7 +476,23 @@ pub async fn response_body(response: axum::http::Response<axum::body::Body>) ->
 
 #[cfg(test)]
 mod tests {
-    use {super::*, serde::ser, serde_json::json};
+    use {
+        crate::api::{Error, rich_error},
+        alloy::primitives::{Address, B256},
+        app_data::AppDataHash,
+        axum::{
+            Router,
+            body::Body,
+            extract::{Path, Query},
+            http::{Request, StatusCode},
+            response::IntoResponse,
+            routing::get,
+        },
+        model::order::OrderUid,
+        serde::{Deserialize, Serialize, ser},
+        serde_json::json,
+        tower::ServiceExt as _,
+    };
 
     #[test]
     fn rich_errors_skip_unset_data_field() {
@@ -533,4 +549,370 @@ mod tests {
             })
         );
     }
+
+    // Tests for Axum extractor type parsing.
+    //
+    // Since the parsing behavior depends on the type, not the endpoint,
+    // we test each type once here rather than duplicating across handlers.
+
+    async fn get_request(router: Router, path: &str) -> axum::response::Response<Body> {
+        router
+            .oneshot(Request::get(path).body(Body::empty()).unwrap())
+            .await
+            .unwrap()
+    }
+
+    mod path_order_uid {
+        use super::*;
+
+        async fn handler(Path(_uid): Path<OrderUid>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/orders/{uid}", get(handler))
+        }
+
+        async fn request(uid: &str) -> axum::response::Response<Body> {
+            get_request(router(), &format!("/orders/{uid}")).await
+        }
+
+        #[tokio::test]
+        async fn with_0x_prefix() {
+            let uid = format!("0x{}", "01".repeat(56));
+            assert_eq!(request(&uid).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn without_0x_prefix() {
+            let uid = "01".repeat(56);
+            assert_eq!(request(&uid).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_with_0x() {
+            let uid = format!("0x{}", "01".repeat(56).strip_suffix('1').unwrap());
+            assert_eq!(request(&uid).await.status(), StatusCode::BAD_REQUEST);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_without_0x() {
+            let uid = "01".repeat(56);
+            let uid = uid.strip_suffix('1').unwrap();
+            assert_eq!(request(uid).await.status(), StatusCode::BAD_REQUEST);
+        }
+    }
+
+    mod path_address {
+        use super::*;
+
+        async fn handler(Path(_addr): Path<Address>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/token/{addr}", get(handler))
+        }
+
+        async fn request(addr: &str) -> axum::response::Response<Body> {
+            get_request(router(), &format!("/token/{addr}")).await
+        }
+
+        #[tokio::test]
+        async fn with_0x_prefix() {
+            let addr = format!("0x{}", "01".repeat(20));
+            assert_eq!(request(&addr).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn without_0x_prefix() {
+            let addr = "01".repeat(20);
+            assert_eq!(request(&addr).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_with_0x() {
+            let addr = format!("0x{}", "01".repeat(20).strip_suffix('1').unwrap());
+            assert_eq!(request(&addr).await.status(), StatusCode::BAD_REQUEST);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_without_0x() {
+            let addr = "01".repeat(20);
+            let addr = addr.strip_suffix('1').unwrap();
+            assert_eq!(request(addr).await.status(), StatusCode::BAD_REQUEST);
+        }
+
+        #[tokio::test]
+        async fn too_short() {
+            assert_eq!(request("0x0101").await.status(), StatusCode::BAD_REQUEST);
+        }
+
+        #[tokio::test]
+        async fn invalid_hex_chars() {
+            let addr = format!("0x{}", "GG".repeat(20));
+            assert_eq!(request(&addr).await.status(), StatusCode::BAD_REQUEST);
+        }
+    }
+
+    mod path_b256 {
+        use super::*;
+
+        async fn handler(Path(_hash): Path<B256>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/tx/{hash}", get(handler))
+        }
+
+        async fn request(hash: &str) -> axum::response::Response<Body> {
+            get_request(router(), &format!("/tx/{hash}")).await
+        }
+
+        #[tokio::test]
+        async fn with_0x_prefix() {
+            let hash = format!("0x{}", "01".repeat(32));
+            assert_eq!(request(&hash).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn without_0x_prefix() {
+            let hash = "01".repeat(32);
+            assert_eq!(request(&hash).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_with_0x() {
+            let hash = format!("0x{}", "01".repeat(32).strip_suffix('1').unwrap());
+            assert_eq!(request(&hash).await.status(), StatusCode::BAD_REQUEST);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_without_0x() {
+            let hash = "01".repeat(32);
+            let hash = hash.strip_suffix('1').unwrap();
+            assert_eq!(request(hash).await.status(), StatusCode::BAD_REQUEST);
+        }
+    }
+
+    mod path_app_data_hash {
+        use super::*;
+
+        async fn handler(Path(_hash): Path<AppDataHash>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/app_data/{hash}", get(handler))
+        }
+
+        async fn request(hash: &str) -> axum::response::Response<Body> {
+            get_request(router(), &format!("/app_data/{hash}")).await
+        }
+
+        #[tokio::test]
+        async fn with_0x_prefix() {
+            let hash = format!("0x{}", "01".repeat(32));
+            assert_eq!(request(&hash).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn without_0x_prefix() {
+            let hash = "01".repeat(32);
+            assert_eq!(request(&hash).await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_with_0x() {
+            let hash = format!("0x{}", "01".repeat(32).strip_suffix('1').unwrap());
+            assert_eq!(request(&hash).await.status(), StatusCode::BAD_REQUEST);
+        }
+
+        #[tokio::test]
+        async fn odd_hex_chars_without_0x() {
+            let hash = "01".repeat(32);
+            let hash = hash.strip_suffix('1').unwrap();
+            assert_eq!(request(hash).await.status(), StatusCode::BAD_REQUEST);
+        }
+    }
+
+    mod path_u64 {
+        use super::*;
+
+        async fn handler(Path(_id): Path<u64>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/resource/{id}", get(handler))
+        }
+
+        async fn request(path: &str) -> axum::response::Response<Body> {
+            get_request(router(), path).await
+        }
+
+        #[tokio::test]
+        async fn valid() {
+            assert_eq!(request("/resource/123").await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn invalid_string() {
+            assert_eq!(
+                request("/resource/abc").await.status(),
+                StatusCode::BAD_REQUEST
+            );
+        }
+
+        #[tokio::test]
+        async fn negative() {
+            assert_eq!(
+                request("/resource/-1").await.status(),
+                StatusCode::BAD_REQUEST
+            );
+        }
+    }
+
+    mod query_hex_types {
+        use super::*;
+
+        #[derive(Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        struct Params {
+            #[allow(unused)]
+            order_uid: Option<OrderUid>,
+            #[allow(unused)]
+            owner: Option<Address>,
+        }
+
+        async fn handler(Query(_q): Query<Params>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/trades", get(handler))
+        }
+
+        async fn request(query: &str) -> axum::response::Response<Body> {
+            get_request(router(), &format!("/trades?{query}")).await
+        }
+
+        #[tokio::test]
+        async fn order_uid_with_0x_prefix() {
+            let uid = format!("0x{}", "01".repeat(56));
+            assert_eq!(
+                request(&format!("orderUid={uid}")).await.status(),
+                StatusCode::OK
+            );
+        }
+
+        #[tokio::test]
+        async fn order_uid_without_0x_prefix() {
+            let uid = "01".repeat(56);
+            assert_eq!(
+                request(&format!("orderUid={uid}")).await.status(),
+                StatusCode::OK
+            );
+        }
+
+        #[tokio::test]
+        async fn order_uid_odd_hex_chars() {
+            let uid = format!("0x{}", "01".repeat(56).strip_suffix('1').unwrap());
+            assert_eq!(
+                request(&format!("orderUid={uid}")).await.status(),
+                StatusCode::BAD_REQUEST
+            );
+        }
+
+        #[tokio::test]
+        async fn owner_with_0x_prefix() {
+            let owner = format!("0x{}", "01".repeat(20));
+            assert_eq!(
+                request(&format!("owner={owner}")).await.status(),
+                StatusCode::OK
+            );
+        }
+
+        #[tokio::test]
+        async fn owner_without_0x_prefix() {
+            let owner = "01".repeat(20);
+            assert_eq!(
+                request(&format!("owner={owner}")).await.status(),
+                StatusCode::OK
+            );
+        }
+
+        #[tokio::test]
+        async fn owner_odd_hex_chars() {
+            let owner = format!("0x{}", "01".repeat(20).strip_suffix('1').unwrap());
+            assert_eq!(
+                request(&format!("owner={owner}")).await.status(),
+                StatusCode::BAD_REQUEST
+            );
+        }
+    }
+
+    mod query_numeric_types {
+        use super::*;
+
+        #[derive(Deserialize)]
+        struct Params {
+            #[allow(unused)]
+            offset: Option<u64>,
+            #[allow(unused)]
+            limit: Option<u64>,
+        }
+
+        async fn handler(Query(_q): Query<Params>) -> StatusCode {
+            StatusCode::OK
+        }
+
+        fn router() -> Router {
+            Router::new().route("/items", get(handler))
+        }
+
+        async fn request(path: &str) -> axum::response::Response<Body> {
+            get_request(router(), path).await
+        }
+
+        #[tokio::test]
+        async fn no_params() {
+            assert_eq!(request("/items").await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn only_offset() {
+            assert_eq!(request("/items?offset=5").await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn only_limit() {
+            assert_eq!(request("/items?limit=20").await.status(), StatusCode::OK);
+        }
+
+        #[tokio::test]
+        async fn both_params() {
+            assert_eq!(
+                request("/items?offset=5&limit=20").await.status(),
+                StatusCode::OK
+            );
+        }
+
+        #[tokio::test]
+        async fn invalid_offset() {
+            assert_eq!(
+                request("/items?offset=abc").await.status(),
+                StatusCode::BAD_REQUEST
+            );
+        }
+
+        #[tokio::test]
+        async fn invalid_limit() {
+            assert_eq!(
+                request("/items?limit=abc").await.status(),
+                StatusCode::BAD_REQUEST
+            );
+        }
+    }
 }
diff --git a/crates/orderbook/src/api/cancel_order.rs b/crates/orderbook/src/api/cancel_order.rs
index a0c331c3e9..db82862d11 100644
--- a/crates/orderbook/src/api/cancel_order.rs
+++ b/crates/orderbook/src/api/cancel_order.rs
@@ -2,29 +2,19 @@ use {
     crate::{api::AppState, orderbook::OrderCancellationError},
     axum::{
         Json,
-        body,
         extract::{Path, State},
         http::StatusCode,
         response::{IntoResponse, Response},
     },
     model::order::{CancellationPayload, OrderCancellation, OrderUid},
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
 };
 
 pub async fn cancel_order_handler(
     State(state): State<Arc<AppState>>,
-    Path(uid): Path<String>,
-    body: body::Bytes,
+    Path(uid): Path<OrderUid>,
+    Json(payload): Json<CancellationPayload>,
 ) -> Response {
-    // TODO: remove after all downstream callers have been notified of the status
-    // code changes
-    let Ok(uid) = OrderUid::from_str(&uid) else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-    let Ok(payload) = serde_json::from_slice::<CancellationPayload>(&body) else {
-        return StatusCode::BAD_REQUEST.into_response();
-    };
-
     let order_cancellation = OrderCancellation {
         order_uid: uid,
         signature: payload.signature,
diff --git a/crates/orderbook/src/api/get_solver_competition_v2.rs b/crates/orderbook/src/api/get_solver_competition_v2.rs
index 71e7c48354..daa7d8a71a 100644
--- a/crates/orderbook/src/api/get_solver_competition_v2.rs
+++ b/crates/orderbook/src/api/get_solver_competition_v2.rs
@@ -11,11 +11,19 @@ use {
 
 pub async fn get_solver_competition_by_id_handler(
     State(state): State<Arc<AppState>>,
-    Path(auction_id): Path<AuctionId>,
+    Path(auction_id): Path<u64>,
 ) -> Response {
+    // We use u64 to ensure that negative numbers are returned as BAD_REQUEST
+    // however, there's a gap between u64::MAX and i64::MAX, numbers beyond i64::MAX
+    // will be marked as NOT_FOUND as they're positive (and as such, valid) but
+    // they are not covered by our system
+    if auction_id > AuctionId::MAX.cast_unsigned() {
+        return LoadSolverCompetitionError::NotFound.into_response();
+    }
+
     state
         .database_read
-        .load_competition_by_id(auction_id)
+        .load_competition_by_id(auction_id.cast_signed())
         .await
         .map(Json)
         .into_response()

From 1d4e32ab26fc3eeb8975d2d9579da520055a78df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 4 Mar 2026 13:53:11 +0000
Subject: [PATCH 122/219] Add TOML formatting support (#4226)

# Description
It's really annoying not to have a standard TOML formatting utility,
without it we'll bikeshed on something generally not worth losing time
over.

This PR addresses that issue by introducing
[Tombi](https://github.com/tombi-toml/tombi) in several forms:
* CLI
* VSCode (extension recommendation to ensure the right extension +
extension config)
* Zed

Note: Tombi also does linting and is aware of the deprecation of
package.authors in Cargo.toml, however, the book doesn't mention much of
an alternative because in reality it's not just the package submitter
etc, see https://github.com/rust-lang/cargo/issues/16458 for more info.

# Changes

* New recipe for the Justfile
* Editor configs
* Add tombi to CI too
* Formatted all *.toml

## How to test
* Test it in your respective editor
* Run `just tombi-fmt` (add `--check` for check)
---
 .cargo/audit.toml                           |  54 ++++----
 .clippy.toml                                |   5 +-
 .github/workflows/pull-request.yaml         |  18 +--
 .tombi.toml                                 |   5 +
 .vscode/extensions.json                     |   5 +
 .vscode/settings.json                       |   6 +
 .zed/settings.json                          |  13 ++
 Cargo.lock                                  |   1 +
 Cargo.toml                                  | 130 +++++++++++---------
 Justfile                                    |   5 +
 README.md                                   |  18 +++
 configs/local/baseline.toml                 |  20 +--
 configs/local/driver.toml                   |  26 ++--
 crates/autopilot/Cargo.toml                 |  38 +++---
 crates/balance-overrides/Cargo.toml         |   2 +-
 crates/bytes-hex/Cargo.toml                 |   2 +-
 crates/contracts/Cargo.toml                 |  28 ++---
 crates/cow-amm/Cargo.toml                   |   6 +-
 crates/database/Cargo.toml                  |   4 +-
 crates/driver/Cargo.toml                    |  35 +++---
 crates/driver/example.toml                  |  20 +--
 crates/e2e/Cargo.toml                       |  24 +++-
 crates/ethrpc/Cargo.toml                    |  20 ++-
 crates/event-indexing/Cargo.toml            |  15 +--
 crates/gas-price-estimation/Cargo.toml      |   2 +-
 crates/liquidity-sources/Cargo.toml         |  10 +-
 crates/model/Cargo.toml                     |   2 +-
 crates/observe/Cargo.toml                   |  14 +--
 crates/orderbook/Cargo.toml                 |  24 ++--
 crates/price-estimation/Cargo.toml          |   8 +-
 crates/refunder/Cargo.toml                  |  12 +-
 crates/s3/Cargo.toml                        |   4 +-
 crates/shared/Cargo.toml                    |  19 +--
 crates/solver/Cargo.toml                    |  16 +--
 crates/solvers-dto/Cargo.toml               |   4 +-
 crates/solvers/Cargo.toml                   |  12 +-
 crates/solvers/config/example.baseline.toml |   2 +-
 crates/testlib/Cargo.toml                   |   5 +-
 crates/token-info/Cargo.toml                |   2 +-
 playground/baseline.toml                    |  20 +--
 playground/driver.toml                      |  26 ++--
 41 files changed, 383 insertions(+), 299 deletions(-)
 create mode 100644 .tombi.toml
 create mode 100644 .vscode/extensions.json
 create mode 100644 .vscode/settings.json
 create mode 100644 .zed/settings.json

diff --git a/.cargo/audit.toml b/.cargo/audit.toml
index 7a70e26a46..76d2d8df83 100644
--- a/.cargo/audit.toml
+++ b/.cargo/audit.toml
@@ -5,43 +5,31 @@
 [advisories]
 # Known vulnerabilities that are tracked in https://github.com/cowprotocol/services/issues/3338
 ignore = [
-    # alloy-dyn-abi - DoS vulnerability (RUSTSEC-2025-0073)
-    # Needs upgrade to 1.4.1+ (part of alloy migration)
-    "RUSTSEC-2025-0073",
+  # idna - Punycode label vulnerability (RUSTSEC-2024-0421)
+  # Needs upgrade to 1.0.0+ (transitive dependency)
+  "RUSTSEC-2024-0421",
 
-    # idna - Punycode label vulnerability (RUSTSEC-2024-0421)
-    # Needs upgrade to 1.0.0+ (transitive dependency)
-    "RUSTSEC-2024-0421",
+  # protobuf - Uncontrolled recursion (RUSTSEC-2024-0437)
+  # Needs upgrade to 3.7.2+ (transitive dependency)
+  "RUSTSEC-2024-0437",
 
-    # protobuf - Uncontrolled recursion (RUSTSEC-2024-0437)
-    # Needs upgrade to 3.7.2+ (transitive dependency)
-    "RUSTSEC-2024-0437",
+  # rsa - Marvin Attack timing sidechannel (RUSTSEC-2023-0071)
+  # No patch available yet (cryptography vulnerability)
+  "RUSTSEC-2023-0071",
 
-    # rsa - Marvin Attack timing sidechannel (RUSTSEC-2023-0071)
-    # No patch available yet (cryptography vulnerability)
-    "RUSTSEC-2023-0071",
+  # derivative - Unmaintained (RUSTSEC-2024-0388)
+  # Evaluate alternatives (tracked in #3338)
+  "RUSTSEC-2024-0388",
 
-    # tracing-subscriber - ANSI escape injection (RUSTSEC-2025-0055)
-    # Needs upgrade to 0.3.20+ (minimal risk in current usage)
-    "RUSTSEC-2025-0055",
+  # instant - Unmaintained (RUSTSEC-2024-0384)
+  # Use web-time instead (tracked in #3338)
+  "RUSTSEC-2024-0384",
 
-    # derivative - Unmaintained (RUSTSEC-2024-0388)
-    # Evaluate alternatives (tracked in #3338)
-    "RUSTSEC-2024-0388",
+  # paste - Unmaintained (RUSTSEC-2024-0436)
+  # Archived upstream (tracked in #3338)
+  "RUSTSEC-2024-0436",
 
-    # instant - Unmaintained (RUSTSEC-2024-0384)
-    # Use web-time instead (tracked in #3338)
-    "RUSTSEC-2024-0384",
-
-    # paste - Unmaintained (RUSTSEC-2024-0436)
-    # Archived upstream (tracked in #3338)
-    "RUSTSEC-2024-0436",
-
-    # proc-macro-error - Unmaintained (RUSTSEC-2024-0370)
-    # Transitive dependency (tracked in #3338)
-    "RUSTSEC-2024-0370",
-
-    # model crate - data race in Shared (RUSTSEC-2020-0140)
-    # Internal crate issue (tracked in #3338)
-    "RUSTSEC-2020-0140",
+  # model crate - data race in Shared (RUSTSEC-2020-0140)
+  # Internal crate issue (tracked in #3338)
+  "RUSTSEC-2020-0140",
 ]
diff --git a/.clippy.toml b/.clippy.toml
index df1ed0d00a..5d402a93d8 100644
--- a/.clippy.toml
+++ b/.clippy.toml
@@ -1,7 +1,6 @@
 disallowed-methods = [
-    { path = "web3::api::Net::version", reason = "Calling `eth().chain_id().await?.to_string()` is equivalent and is better supported." },
-    { path = "alloy::rpc::client::RpcClient::new_batch", reason = "There is no need to manually send batched requests because the alloy transport layer batches requests automatically under the hood." },
-    { path = "alloy::rpc::client::BatchRequest::new", reason = "There is no need to manually send batched requests because the alloy transport layer batches requests automatically under the hood." },
+  { path = "alloy::rpc::client::RpcClient::new_batch", reason = "There is no need to manually send batched requests because the alloy transport layer batches requests automatically under the hood." },
+  { path = "alloy::rpc::client::BatchRequest::new", reason = "There is no need to manually send batched requests because the alloy transport layer batches requests automatically under the hood." },
 ]
 await-holding-invalid-types = [
   "tracing::span::Entered",
diff --git a/.github/workflows/pull-request.yaml b/.github/workflows/pull-request.yaml
index 5a7a894bae..2ab6e1932f 100644
--- a/.github/workflows/pull-request.yaml
+++ b/.github/workflows/pull-request.yaml
@@ -5,7 +5,7 @@ on:
   # We require PRs to be up to date before merging so technically it is not needed run the rust job
   # on main. However for the cache to be usable in PRs we do need the job on main.
   push:
-    branches: [ main ]
+    branches: [main]
 jobs:
   lint:
     timeout-minutes: 60
@@ -24,15 +24,18 @@ jobs:
       - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
         with:
           just-version: 1.39.0
+      - uses: tombi-toml/setup-tombi@cebfd308ba02edadfcee148b7473536990950c92 # v1.0.8
       - run: |
           rustup --version
           rustup show
           cargo --version
           cargo +nightly fmt --version
           cargo clippy --version
+          tombi --version
       - run: just fmt --check
-      - run: just clippy 
-  
+      - run: just clippy
+      - run: just fmt-toml --check
+
   trivy:
     runs-on: ubuntu-latest
     steps:
@@ -43,14 +46,14 @@ jobs:
       - name: Run Trivy
         uses: aquasecurity/trivy-action@dc5a429b52fcf669ce959baa2c2dd26090d2a6c4 # v0.32.0
         with:
-          scan-type: 'fs'
-          format: 'sarif'
-          output: 'trivy-results.sarif'
+          scan-type: "fs"
+          format: "sarif"
+          output: "trivy-results.sarif"
 
       - name: Upload Trivy scan results to GitHub Security
         uses: github/codeql-action/upload-sarif@51f77329afa6477de8c49fc9c7046c15b9a4e79d # v3.29.5
         with:
-          sarif_file: 'trivy-results.sarif'
+          sarif_file: "trivy-results.sarif"
 
   cargo-audit:
     runs-on: ubuntu-latest
@@ -262,7 +265,6 @@ jobs:
             exit 1
           fi
 
-
   openapi:
     timeout-minutes: 60
     runs-on: ubuntu-latest
diff --git a/.tombi.toml b/.tombi.toml
new file mode 100644
index 0000000000..1d08999629
--- /dev/null
+++ b/.tombi.toml
@@ -0,0 +1,5 @@
+[files]
+include = ["**/*.toml"]
+
+[format.rules]
+line-width = 120
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 0000000000..190f74c481
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "tombi-toml.tombi"
+    ]
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000..261e70eca7
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,6 @@
+{
+    "[toml]": {
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "tombi-toml.tombi"
+    }
+}
diff --git a/.zed/settings.json b/.zed/settings.json
new file mode 100644
index 0000000000..921c386044
--- /dev/null
+++ b/.zed/settings.json
@@ -0,0 +1,13 @@
+{
+    "languages": {
+        "TOML": {
+            "language_servers": ["tombi"],
+            "formatter": {
+                "language_server": {
+                    "name": "tombi",
+                },
+            },
+            "format_on_save": "on",
+        },
+    },
+}
diff --git a/Cargo.lock b/Cargo.lock
index 99d576c92f..427c93be26 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6674,6 +6674,7 @@ dependencies = [
  "humantime",
  "indexmap 2.13.0",
  "itertools 0.14.0",
+ "liquidity-sources",
  "maplit",
  "mockall",
  "model",
diff --git a/Cargo.toml b/Cargo.toml
index 4333f567d2..cdf02e0130 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,31 +3,47 @@ resolver = "3"
 members = ["crates/*"]
 
 [workspace.dependencies]
+account-balances = { path = "crates/account-balances" }
 alloy = { version = "1.7.3", default-features = false }
 alloy-contract = { version = "1.7.3", default-features = false }
 alloy-primitives = { version = "1.5.2", default-features = false }
-alloy-signer = { version = "1.7.3", default-features = false}
-alloy-signer-local = { version = "1.7.3", default-features = false}
+alloy-signer = { version = "1.7.3", default-features = false }
+alloy-signer-local = { version = "1.7.3", default-features = false }
+alloy-sol-macro-expander = "1.4.1"
+alloy-sol-macro-input = "1.4.1"
 alloy-sol-types = { version = "1.5.2" }
-account-balances = { path = "crates/account-balances" }
 anyhow = "1.0.100"
+app-data = { path = "crates/app-data" }
+arc-swap = "1.7.1"
+async-stream = "0.3.5"
 async-trait = "0.1.80"
+autopilot = { path = "crates/autopilot" }
+aws-config = "1.5.1"
+aws-sdk-s3 = { version = "1.34.0", default-features = false }
 axum = "0.8"
 bad-tokens = { path = "crates/bad-tokens" }
+balance-overrides = { path = "crates/balance-overrides" }
 bigdecimal = "0.4"
+brotli = "8"
+bytes = "1.11.1"
+bytes-hex = { path = "crates/bytes-hex" }
 cached = { version = "0.49.3", default-features = false }
+chain = { path = "crates/chain" }
 chrono = { version = "0.4.38", default-features = false }
 clap = { version = "4.5.6", features = ["derive", "env"] }
+console-subscriber = "0.3.0"
+const_format = "0.2.32"
+const-hex = "1.17.0"
+contracts = { path = "crates/contracts" }
+cow-amm = { path = "crates/cow-amm" }
 dashmap = "6.1.0"
+database = { path = "crates/database" }
 derive_more = { version = "1.0.0", features = ["full"] }
+driver = { path = "crates/driver" }
+ethrpc = { path = "crates/ethrpc" }
 event-indexing = { path = "crates/event-indexing" }
-mimalloc = "0.1.43"
-tikv-jemallocator = { version = "0.6", features = ["unprefixed_malloc_on_supported_platforms", "profiling"] }
-jemalloc_pprof = { version = "0.8", features = ["symbolize"] }
-brotli = "8"
 flate2 = "1.0.30"
 futures = "0.3.30"
-const-hex = "1.17.0"
 gas-price-estimation = { path = "crates/gas-price-estimation" }
 hex-literal = "0.4.1"
 http-body = "1"
@@ -36,88 +52,80 @@ humantime = "2.1.0"
 humantime-serde = "1.1.1"
 indexmap = "2.2.6"
 itertools = "0.14"
+jemalloc_pprof = { version = "0.8", features = ["symbolize"] }
+jsonrpc-core = "18.0.0"
+liquidity-sources = { path = "crates/liquidity-sources" }
 maplit = "1.0.2"
+mimalloc = "0.1.43"
 mockall = "0.12.1"
-num = "0.4.3"
-price-estimation = { path = "crates/price-estimation" }
-prometheus = "0.14"
-prometheus-metric-storage = "0.6"
-rand = "0.8.5"
-regex = "1.10.4"
-request-sharing = { path = "crates/request-sharing" }
-reqwest = "0.13"
-rstest = "0.26"
-ruint = { version = "1.17.2", default-features = false }
-serde = { version = "1.0.203", features = ["derive"] }
-serde_json = "1.0.117"
-serde_with = "3.8.1"
-sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "tls-native-tls", "bigdecimal", "chrono", "postgres", "macros", "derive"] }
-strum = { version = "0.27.2", features = ["derive"] }
-tempfile = "3.10.1"
-thiserror = "1.0.61"
-toml = "0.8.14"
-token-info = { path = "crates/token-info" }
-tokio = { version = "1.38.0", features = ["tracing"] }
-tokio-stream = { version = "0.1.15", features = ["sync"] }
-tracing = "0.1.41"
-tracing-subscriber = { version = "0.3.19", features = ["json"] }
-url = "2.5.0"
-app-data = { path = "crates/app-data" }
-balance-overrides = { path = "crates/balance-overrides" }
-arc-swap = "1.7.1"
-async-stream = "0.3.5"
-autopilot = { path = "crates/autopilot" }
-aws-config = "1.5.1"
-aws-sdk-s3 = { version = "1.34.0", default-features = false }
-bytes-hex = { path = "crates/bytes-hex" }
-bytes = "1.11.1"
-chain = { path = "crates/chain" }
-console-subscriber = "0.3.0"
-const_format = "0.2.32"
-contracts = { path = "crates/contracts" }
-cow-amm = { path = "crates/cow-amm" }
-database = { path = "crates/database" }
-driver = { path = "crates/driver" }
-ethrpc = { path = "crates/ethrpc" }
 model = { path = "crates/model" }
 moka = "0.12.10"
 multibase = "0.9"
+num = "0.4.3"
 number = { path = "crates/number" }
 observe = { path = "crates/observe" }
-order-validation = { path = "crates/order-validation" }
 opentelemetry = { version = "0.31", features = ["tracing"] }
+opentelemetry-http = { version = "0.31", default-features = false }  # disable internal-logging
 opentelemetry-otlp = "0.31"
 opentelemetry_sdk = "0.31"
-opentelemetry-http = { version = "0.31", default-features = false } # disable internal-logging
+order-validation = { path = "crates/order-validation" }
 orderbook = { path = "crates/orderbook" }
 paste = "1.0"
 pin-project-lite = "0.2.14"
+prettyplease = "0.2.37"
+price-estimation = { path = "crates/price-estimation" }
+proc-macro2 = "1.0.103"
+prometheus = "0.14"
+prometheus-metric-storage = "0.6"
+quote = "1.0.41"
+rand = "0.8.5"
 rate-limit = { path = "crates/rate-limit" }
 refunder = { path = "crates/refunder" }
+regex = "1.10.4"
+request-sharing = { path = "crates/request-sharing" }
+reqwest = "0.13"
+rstest = "0.26"
+ruint = { version = "1.17.2", default-features = false }
 rust_decimal = { version = "1.35.0", default-features = false }
 s3 = { path = "crates/s3" }
 scopeguard = "1.2.0"
+serde = { version = "1.0.203", features = ["derive"] }
+serde-ext = { path = "crates/serde-ext" }
+serde_json = "1.0.117"
+serde_with = "3.8.1"
 shared = { path = "crates/shared" }
 solver = { path = "crates/solver" }
 solvers = { path = "crates/solvers" }
 solvers-dto = { path = "crates/solvers-dto" }
+sqlx = { version = "0.8", default-features = false, features = [
+  "bigdecimal",
+  "chrono",
+  "derive",
+  "macros",
+  "postgres",
+  "runtime-tokio",
+  "tls-native-tls"
+] }
+strum = { version = "0.27.2", features = ["derive"] }
+syn = "2.0.108"
+tempfile = "3.10.1"
 testlib = { path = "crates/testlib" }
-winner-selection = { path = "crates/winner-selection" }
+thiserror = "1.0.61"
+tikv-jemallocator = { version = "0.6", features = ["profiling", "unprefixed_malloc_on_supported_platforms"] }
 time = "0.3.47"
+token-info = { path = "crates/token-info" }
+tokio = { version = "1.38.0", features = ["tracing"] }
+tokio-stream = { version = "0.1.15", features = ["sync"] }
+toml = "0.8.14"
 tower = "0.5"
 tower-http = "0.6"
+tracing = "0.1.41"
 tracing-opentelemetry = "0.32.1"
 tracing-serde = "0.2"
+tracing-subscriber = { version = "0.3.22", features = ["json"] }
+url = "2.5.0"
 vergen = "8"
-quote = "1.0.41"
-syn = "2.0.108"
-prettyplease = "0.2.37"
-proc-macro2 = "1.0.103"
-alloy-sol-macro-input = "1.4.1"
-alloy-sol-macro-expander = "1.4.1"
-jsonrpc-core = "18.0.0"
-serde-ext = { path = "crates/serde-ext" }
-liquidity-sources = { path = "crates/liquidity-sources" }
+winner-selection = { path = "crates/winner-selection" }
 
 [workspace.lints]
 clippy.cast_possible_wrap = "deny"
diff --git a/Justfile b/Justfile
index 763a7552f4..6bf98a1e48 100644
--- a/Justfile
+++ b/Justfile
@@ -36,6 +36,11 @@ clippy:
 fmt *extra:
     cargo +nightly fmt --all -- {{extra}}
 
+# Format .toml files in the repository
+fmt-toml *extra:
+    tombi format {{extra}}
+
+
 # Start database for E2E tests
 start-db:
     docker compose up -d
diff --git a/README.md b/README.md
index 4d5268fce2..84316c85fd 100644
--- a/README.md
+++ b/README.md
@@ -160,3 +160,21 @@ Each process opens a UNIX socket at `/tmp/log_filter_override_<program_name>_<pi
 You can also reset the log filter to the filter the program was initially started with by entering `reset`.
 
 See [here](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives) for documentation on the supported log filter format.
+
+## Formatting
+
+Rust code is formatted with `rustfmt` (nightly) and TOML files are formatted with [Tombi](https://tombi-toml.github.io/tombi/).
+
+```bash
+# Format Rust code
+just fmt
+
+# Format TOML files
+just fmt-toml
+
+# Check formatting without modifying files
+just fmt --check
+just fmt-toml --check
+```
+
+Editor extensions are available for [VS Code](https://marketplace.visualstudio.com/items?itemName=tombi-toml.tombi), [Zed](https://tombi-toml.github.io/tombi/docs/editors/zed-extension), and [JetBrains](https://plugins.jetbrains.com/plugin/28017-tombi).
diff --git a/configs/local/baseline.toml b/configs/local/baseline.toml
index c62d9d91eb..43e24b9983 100644
--- a/configs/local/baseline.toml
+++ b/configs/local/baseline.toml
@@ -1,14 +1,14 @@
-chain-id = "1" # Ethereum mainnet
+chain-id = "1"  # Ethereum mainnet
 base-tokens = [
-    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", # WETH
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F", # DAI 
-    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", # USDC
-    "0xdAC17F958D2ee523a2206206994597C13D831ec7", # USDT
-    "0xc00e94Cb662C3520282E6f5717214004A7f26888", # COMP
-    "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2", # MKR
-    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", # WBTC
-    "0x6810e776880C02933D47DB1b9fc05908e5386b96", # GNO
+  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",  # WETH
+  "0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
+  "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
+  "0xc00e94Cb662C3520282E6f5717214004A7f26888",  # COMP
+  "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",  # MKR
+  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",  # WBTC
+  "0x6810e776880C02933D47DB1b9fc05908e5386b96",  # GNO
 ]
 max-hops = 2
 max-partial-attempts = 5
-native-token-price-estimation-amount = "100000000000000000" # 0.1 ETH
+native-token-price-estimation-amount = "100000000000000000"  # 0.1 ETH
diff --git a/configs/local/driver.toml b/configs/local/driver.toml
index d9b25f55a5..de231abfb9 100644
--- a/configs/local/driver.toml
+++ b/configs/local/driver.toml
@@ -3,11 +3,11 @@ orderbook-url = "http://orderbook"
 tx-gas-limit = "45000000"
 
 [[solver]]
-name = "baseline" # Arbitrary name given to this solver, must be unique
+name = "baseline"  # Arbitrary name given to this solver, must be unique
 endpoint = "http://baseline"
-absolute-slippage = "40000000000000000" # Denominated in wei, optional
-relative-slippage = "0.1" # Percentage in the [0, 1] range
-account = "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6" # Known test private key
+absolute-slippage = "40000000000000000"  # Denominated in wei, optional
+relative-slippage = "0.1"  # Percentage in the [0, 1] range
+account = "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6"  # Known test private key
 
 [submission]
 gas-price-cap = "1000000000000"
@@ -17,15 +17,15 @@ url = "http://chain:8545"
 
 [liquidity]
 base-tokens = [
-    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", # WETH
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F", # DAI
-    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", # USDC
-    "0xdAC17F958D2ee523a2206206994597C13D831ec7", # USDT
-    "0xc00e94Cb662C3520282E6f5717214004A7f26888", # COMP
-    "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2", # MKR
-    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", # WBTC
-    "0x6810e776880C02933D47DB1b9fc05908e5386b96", # GNO
+  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",  # WETH
+  "0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
+  "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
+  "0xc00e94Cb662C3520282E6f5717214004A7f26888",  # COMP
+  "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",  # MKR
+  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",  # WBTC
+  "0x6810e776880C02933D47DB1b9fc05908e5386b96",  # GNO
 ]
 
-[[liquidity.uniswap-v2]] # Uniswap V2 configuration
+[[liquidity.uniswap-v2]]  # Uniswap V2 configuration
 preset = "uniswap-v2"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 94949846ed..b24730e8f6 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -6,9 +6,9 @@ edition = "2024"
 license = "GPL-3.0-or-later"
 
 [lib]
+doctest = false
 name = "autopilot"
 path = "src/lib.rs"
-doctest = false
 
 [[bin]]
 name = "autopilot"
@@ -16,18 +16,20 @@ path = "src/main.rs"
 
 [dependencies]
 account-balances = { workspace = true }
-alloy = { workspace = true, features = ["rand", "provider-debug-api", "provider-trace-api"] }
-app-data = { workspace = true }
-axum = { workspace = true }
-bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
-bytes = { workspace = true }
+alloy = { workspace = true, features = ["provider-debug-api", "provider-trace-api", "rand"] }
 anyhow = { workspace = true }
+app-data = { workspace = true }
 async-trait = { workspace = true }
-bigdecimal = { workspace = true }
+axum = { workspace = true }
 bad-tokens = { workspace = true }
+bigdecimal = { workspace = true }
+brotli = { workspace = true }
+bytes = { workspace = true }
+bytes-hex = { workspace = true }  # may get marked as unused but it's used with serde
 chain = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 cow-amm = { workspace = true }
 dashmap = { workspace = true }
@@ -35,11 +37,8 @@ database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
-gas-price-estimation = { workspace = true }
-brotli = { workspace = true }
 futures = { workspace = true }
-observe = { workspace = true }
-const-hex = { workspace = true }
+gas-price-estimation = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
@@ -49,6 +48,7 @@ mimalloc = { workspace = true, optional = true }
 model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
+observe = { workspace = true }
 order-validation = { workspace = true }
 price-estimation = { workspace = true }
 prometheus = { workspace = true }
@@ -63,34 +63,34 @@ serde_with = { workspace = true }
 shared = { workspace = true }
 sqlx = { workspace = true }
 strum = { workspace = true }
-tikv-jemallocator = { workspace = true }
+tempfile = { workspace = true, optional = true }
 thiserror = { workspace = true }
+tikv-jemallocator = { workspace = true }
 token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
 tokio-stream = { workspace = true }
+toml = { workspace = true }
 tower = { workspace = true }
 tower-http = { workspace = true, features = ["trace"] }
 tracing = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 winner-selection = { workspace = true }
-toml = { workspace = true }
-tempfile = { workspace = true, optional = true }
 
 [dev-dependencies]
 maplit = { workspace = true }
 mockall = { workspace = true }
-tokio = { workspace = true, features = ["test-util"] }
 shared = { workspace = true, features = ["test-util"] }
 tempfile = { workspace = true }
+tokio = { workspace = true, features = ["test-util"] }
 
 [build-dependencies]
 anyhow = { workspace = true }
 vergen = { workspace = true, features = ["git", "gitcl"] }
 
-[lints]
-workspace = true
-
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
-tokio-console = ["observe/tokio-console"]
 test-util = ["dep:tempfile", "price-estimation/test-util"]
+tokio-console = ["observe/tokio-console"]
+
+[lints]
+workspace = true
diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
index 3401050223..b506e0d7a8 100644
--- a/crates/balance-overrides/Cargo.toml
+++ b/crates/balance-overrides/Cargo.toml
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 doctest = false
 
 [dependencies]
-alloy = { workspace = true, features = ["sol-types", "provider-debug-api"] }
+alloy = { workspace = true, features = ["provider-debug-api", "sol-types"] }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 cached = { workspace = true, features = ["default"] }
diff --git a/crates/bytes-hex/Cargo.toml b/crates/bytes-hex/Cargo.toml
index 1ea61a7cbd..65e36a7902 100644
--- a/crates/bytes-hex/Cargo.toml
+++ b/crates/bytes-hex/Cargo.toml
@@ -8,9 +8,9 @@ license = "MIT OR Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+const-hex = { workspace = true }
 serde = { workspace = true }
 serde_with = { workspace = true }
-const-hex = { workspace = true }
 
 [dev-dependencies]
 serde_json = { workspace = true }
diff --git a/crates/contracts/Cargo.toml b/crates/contracts/Cargo.toml
index 61e46b4f02..587f83ffd0 100644
--- a/crates/contracts/Cargo.toml
+++ b/crates/contracts/Cargo.toml
@@ -12,34 +12,30 @@ doctest = false
 name = "vendor"
 required-features = ["bin"]
 
-[features]
-default = []
-bin = [
-    "tracing",
-    "tracing-subscriber",
-    "reqwest"
-]
-
 [dependencies]
+alloy = { workspace = true, features = ["contract", "json", "json-abi", "sol-types"] }
 anyhow = { workspace = true }
-alloy = { workspace = true, features = ["sol-types", "json", "contract", "json-abi"] }
 paste = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 
+reqwest = { workspace = true, features = ["blocking", "json"], optional = true }
 # [bin-dependencies]
 tracing = { workspace = true, optional = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"], optional = true }
-reqwest = { workspace = true, optional = true, features = ["blocking", "json"] }
 
 [build-dependencies]
+alloy-sol-macro-expander = { workspace = true }
+alloy-sol-macro-input = { workspace = true, features = ["json"] }
 anyhow = { workspace = true }
-alloy-sol-macro-expander = {workspace = true}
-alloy-sol-macro-input = {workspace = true, features = ["json"]}
-prettyplease = {workspace = true}
-proc-macro2 = {workspace = true}
-quote = {workspace = true}
-syn = {workspace = true}
+prettyplease = { workspace = true }
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn = { workspace = true }
+
+[features]
+default = []
+bin = ["reqwest", "tracing", "tracing-subscriber"]
 
 [lints]
 workspace = true
diff --git a/crates/cow-amm/Cargo.toml b/crates/cow-amm/Cargo.toml
index c6af01ce65..41e75b77bf 100644
--- a/crates/cow-amm/Cargo.toml
+++ b/crates/cow-amm/Cargo.toml
@@ -4,14 +4,15 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-anyhow = { workspace = true }
 alloy = { workspace = true }
+anyhow = { workspace = true }
 app-data = { workspace = true }
 async-trait = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
-event-indexing = { workspace = true }
 ethrpc = { workspace = true }
+event-indexing = { workspace = true }
 futures = { workspace = true }
 model = { workspace = true }
 observe = { workspace = true }
@@ -21,7 +22,6 @@ shared = { workspace = true }
 sqlx = { workspace = true }
 tokio = { workspace = true, features = [] }
 tracing = { workspace = true }
-const-hex = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/database/Cargo.toml b/crates/database/Cargo.toml
index 13ee6bc92f..6c81a9b390 100644
--- a/crates/database/Cargo.toml
+++ b/crates/database/Cargo.toml
@@ -9,11 +9,11 @@ license = "MIT OR Apache-2.0"
 bigdecimal = { workspace = true }
 chrono = { workspace = true, features = ["clock"] }
 const_format = { workspace = true }
-futures = { workspace = true }
 const-hex = { workspace = true }
+futures = { workspace = true }
+serde_json = { workspace = true }
 sqlx = { workspace = true }
 strum = { workspace = true }
-serde_json = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index d68f96f266..98d77373d6 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -6,9 +6,9 @@ edition = "2024"
 license = "GPL-3.0-or-later"
 
 [lib]
+doctest = false
 name = "driver"
 path = "src/lib.rs"
-doctest = false
 
 [[bin]]
 name = "driver"
@@ -16,23 +16,30 @@ path = "src/main.rs"
 
 [dependencies]
 account-balances = { workspace = true }
-alloy = { workspace = true, features = ["sol-types", "provider-txpool-api", "rand", "provider-anvil-api", "json-rpc", "rpc-types"] }
+alloy = { workspace = true, features = [
+  "json-rpc",
+  "provider-anvil-api",
+  "provider-txpool-api",
+  "rand",
+  "rpc-types",
+  "sol-types"
+] }
 app-data = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
-balance-overrides = { workspace = true }
 bad-tokens = { workspace = true }
+balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
-bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
+bytes-hex = { workspace = true }  # may get marked as unused but it's used with serde
 chain = { workspace = true }
-chrono = { workspace = true, features = ["clock"], default-features = false }
+chrono = { workspace = true, default-features = false, features = ["clock"] }
+const-hex = { workspace = true }
 cow-amm = { workspace = true }
 dashmap = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
 futures = { workspace = true }
-const-hex = { workspace = true }
 gas-price-estimation = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
@@ -40,7 +47,6 @@ humantime-serde = { workspace = true }
 itertools = { workspace = true }
 liquidity-sources = { workspace = true }
 mimalloc = { workspace = true, optional = true }
-tikv-jemallocator = { workspace = true }
 moka = { workspace = true, features = ["future"] }
 num = { workspace = true }
 number = { workspace = true }
@@ -57,6 +63,7 @@ serde_json = { workspace = true }
 serde_with = { workspace = true }
 solvers-dto = { path = "../solvers-dto" }
 thiserror = { workspace = true }
+tikv-jemallocator = { workspace = true }
 token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "time"] }
 toml = { workspace = true }
@@ -79,21 +86,21 @@ solver = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
+alloy = { workspace = true, features = ["signer-mnemonic"] }
 app-data = { workspace = true, features = ["test_helpers"] }
+contracts = { workspace = true }
+ethrpc = { workspace = true, features = ["test-util"] }
 maplit = { workspace = true }
-tokio = { workspace = true, features = ["test-util", "process"] }
 tempfile = { workspace = true }
-ethrpc = { workspace = true, features = ["test-util"] }
-contracts = { workspace = true }
-alloy = { workspace = true, features = ["signer-mnemonic"] }
+tokio = { workspace = true, features = ["process", "test-util"] }
 
 [build-dependencies]
 anyhow = { workspace = true }
 vergen = { workspace = true, features = ["git", "gitcl"] }
 
-[lints]
-workspace = true
-
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
 tokio-console = ["observe/tokio-console"]
+
+[lints]
+workspace = true
diff --git a/crates/driver/example.toml b/crates/driver/example.toml
index 126973f2e5..66dcd40217 100644
--- a/crates/driver/example.toml
+++ b/crates/driver/example.toml
@@ -1,15 +1,16 @@
 tx-gas-limit = "45000000"
+
 [[solver]]
-name = "mysolver" # Arbitrary name given to this solver, must be unique
+name = "mysolver"  # Arbitrary name given to this solver, must be unique
 endpoint = "http://0.0.0.0:7872"
-absolute-slippage = "40000000000000000" # Denominated in wei, optional
-relative-slippage = "0.1" # Percentage in the [0, 1] range
-account = "0x0000000000000000000000000000000000000000000000000000000000000001" # The private key of the solver
-merge-solutions = true # Multiple solutions proposed by the solver may be combined into one by the driver
+absolute-slippage = "40000000000000000"  # Denominated in wei, optional
+relative-slippage = "0.1"  # Percentage in the [0, 1] range
+account = "0x0000000000000000000000000000000000000000000000000000000000000001"  # The private key of the solver
+merge-solutions = true  # Multiple solutions proposed by the solver may be combined into one by the driver
 response-size-limit-max-bytes = 30000000
 
 [solver.request-headers]
-fake-header-one = "FAKE-HEADER-VALUE" # For instance an authorization token which must be provided on each request
+fake-header-one = "FAKE-HEADER-VALUE"  # For instance an authorization token which must be provided on each request
 
 # [[solver]] # And so on, specify as many solvers as needed
 # name = "othersolver"
@@ -28,7 +29,7 @@ max-additional-tip = "5000000000"
 additional-tip-percentage = 0.05
 mines-reverting-txs = true
 
-[contracts] # Optionally override the contract addresses, necessary on less popular blockchains
+[contracts]  # Optionally override the contract addresses, necessary on less popular blockchains
 gp-v2-settlement = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
 weth = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 balances = "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"
@@ -43,8 +44,8 @@ helper = "0x86f3df416979136cb4fdea2c0886301b911c163b"
 
 [liquidity]
 base-tokens = [
-    "0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB",
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+  "0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB",
+  "0x6B175474E89094C44Da98b954EedeAC495271d0F",
 ]
 
 [[order-priority]]
@@ -108,4 +109,3 @@ max-order-age = "1m"
 # base-url = "https://api.liquorice.tech/"
 # api-key = "..."
 # http_timeout = "10s"
-
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 67959b93cf..a2ae35a455 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -2,15 +2,29 @@
 name = "e2e"
 version = "1.0.0"
 authors = [
-    "Gnosis Developers <developers@gnosis.io>",
-    "Cow Protocol Developers <dev@cow.fi>",
+  "Gnosis Developers <developers@gnosis.io>",
+  "Cow Protocol Developers <dev@cow.fi>",
 ]
 edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true, default-features = false, features = ["json-rpc", "providers", "provider-txpool-api", "rpc-client", "rpc-types", "transports", "reqwest", "signers", "signer-local", "signer-mnemonic", "provider-anvil-api", "provider-debug-api", "sol-types"] }
-alloy-signer = {workspace = true, default-features = false, features = ["eip712"]}
+alloy = { workspace = true, default-features = false, features = [
+  "json-rpc",
+  "provider-anvil-api",
+  "provider-debug-api",
+  "provider-txpool-api",
+  "providers",
+  "reqwest",
+  "rpc-client",
+  "rpc-types",
+  "signer-local",
+  "signer-mnemonic",
+  "signers",
+  "sol-types",
+  "transports"
+] }
+alloy-signer = { workspace = true, default-features = false, features = ["eip712"] }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 autopilot = { workspace = true, features = ["test-util"] }
@@ -28,6 +42,7 @@ ethrpc = { workspace = true, features = ["test-util"] }
 futures = { workspace = true }
 hex-literal = { workspace = true }
 itertools = { workspace = true }
+liquidity-sources = { workspace = true }
 model = { workspace = true, features = ["e2e"] }
 number = { workspace = true }
 observe = { workspace = true }
@@ -41,7 +56,6 @@ solvers = { workspace = true }
 solvers-dto = { workspace = true }
 sqlx = { workspace = true }
 tempfile = { workspace = true }
-liquidity-sources = { workspace = true }
 tokio = { workspace = true, features = ["macros", "process"] }
 toml = { workspace = true }
 tracing = { workspace = true }
diff --git a/crates/ethrpc/Cargo.toml b/crates/ethrpc/Cargo.toml
index 4e33cf9ffe..e78c0a519f 100644
--- a/crates/ethrpc/Cargo.toml
+++ b/crates/ethrpc/Cargo.toml
@@ -11,7 +11,25 @@ name = "ethrpc"
 path = "src/lib.rs"
 
 [dependencies]
-alloy = { workspace = true, default-features = false, features = ["json-rpc", "providers", "rpc-client", "rpc-types", "rpc-types-trace", "transports", "transport-ws", "provider-ws", "provider-debug-api", "reqwest", "signers", "signer-aws", "signer-local", "eips", "reqwest-default-tls", "pubsub", "contract"] }
+alloy = { workspace = true, default-features = false, features = [
+  "reqwest-default-tls",
+  "contract",
+  "eips",
+  "json-rpc",
+  "provider-debug-api",
+  "provider-ws",
+  "providers",
+  "pubsub",
+  "reqwest",
+  "rpc-client",
+  "rpc-types",
+  "rpc-types-trace",
+  "signer-aws",
+  "signer-local",
+  "signers",
+  "transport-ws",
+  "transports"
+] }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 const-hex = { workspace = true }
diff --git a/crates/event-indexing/Cargo.toml b/crates/event-indexing/Cargo.toml
index 4cc02e0482..1e0c703330 100644
--- a/crates/event-indexing/Cargo.toml
+++ b/crates/event-indexing/Cargo.toml
@@ -7,21 +7,22 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 alloy = { workspace = true }
-async-stream = { workspace = true }
 anyhow = { workspace = true }
-futures = { workspace = true }
-tracing = { workspace = true }
+async-stream = { workspace = true }
+async-trait = { workspace = true }
+contracts = { workspace = true }
 ethrpc = { workspace = true }
+futures = { workspace = true }
 observe = { workspace = true }
-tokio = { workspace = true }
-async-trait = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
 
 [dev-dependencies]
-tracing-subscriber = { workspace = true }
-mockall = { workspace = true }
 contracts = { workspace = true }
+mockall = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/gas-price-estimation/Cargo.toml b/crates/gas-price-estimation/Cargo.toml
index 9cfe9521e9..a152283108 100644
--- a/crates/gas-price-estimation/Cargo.toml
+++ b/crates/gas-price-estimation/Cargo.toml
@@ -11,10 +11,10 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-reqwest = { workspace = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
+reqwest = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
diff --git a/crates/liquidity-sources/Cargo.toml b/crates/liquidity-sources/Cargo.toml
index b1df3247cf..9406a849ce 100644
--- a/crates/liquidity-sources/Cargo.toml
+++ b/crates/liquidity-sources/Cargo.toml
@@ -15,11 +15,11 @@ clap = { workspace = true }
 contracts = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
+futures = { workspace = true }
 hex-literal = { workspace = true }
 itertools = { workspace = true }
-futures = { workspace = true }
-model = { workspace = true }
 mockall = { workspace = true, optional = true }
+model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
 observe = { workspace = true }
@@ -28,17 +28,17 @@ prometheus-metric-storage = { workspace = true }
 request-sharing = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
-serde_with = { workspace = true }
 serde_json = { workspace = true }
+serde_with = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
-tracing = { workspace = true }
 token-info = { workspace = true }
 tokio = { workspace = true }
+tracing = { workspace = true }
 
 [dev-dependencies]
-mockall = { workspace = true }
 maplit = { workspace = true }
+mockall = { workspace = true }
 regex = { workspace = true }
 testlib = { workspace = true }
 token-info = { workspace = true, features = ["test-util"] }
diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml
index 2df366e60c..2f742e0acf 100644
--- a/crates/model/Cargo.toml
+++ b/crates/model/Cargo.toml
@@ -17,7 +17,7 @@ anyhow = { workspace = true }
 app-data = { workspace = true }
 bigdecimal = { workspace = true }
 bytes-hex = { workspace = true }
-chrono = { workspace = true, features = ["serde", "clock"] }
+chrono = { workspace = true, features = ["clock", "serde"] }
 const-hex = { workspace = true }
 derive_more = { workspace = true }
 hex-literal = { workspace = true }
diff --git a/crates/observe/Cargo.toml b/crates/observe/Cargo.toml
index 02b8bdc1a1..5e109fdd3a 100644
--- a/crates/observe/Cargo.toml
+++ b/crates/observe/Cargo.toml
@@ -6,12 +6,14 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-axum = { workspace = true }
 async-trait = { workspace = true }
+axum = { workspace = true }
 chrono = { workspace = true, features = ["now"] }
 console-subscriber = { workspace = true, optional = true }
 futures = { workspace = true }
+jemalloc_pprof = { workspace = true }
 opentelemetry = { workspace = true }
+opentelemetry-http = { workspace = true }
 opentelemetry-otlp = { workspace = true, features = ["grpc-tonic"] }
 opentelemetry_sdk = { workspace = true }
 pin-project-lite = { workspace = true }
@@ -24,14 +26,12 @@ time = { workspace = true, features = ["macros"] }
 tokio = { workspace = true, features = ["fs"] }
 tracing = { workspace = true }
 tracing-opentelemetry = { workspace = true }
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 tracing-serde = { workspace = true }
-jemalloc_pprof = { workspace = true }
-opentelemetry-http = { workspace = true }
-
-[lints]
-workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 
 [features]
 default = []
 tokio-console = ["dep:console-subscriber"]
+
+[lints]
+workspace = true
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 9d31f7ed7a..e65b2474a3 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -7,9 +7,9 @@ license = "GPL-3.0-or-later"
 build = "build.rs"
 
 [lib]
+doctest = false
 name = "orderbook"
 path = "src/lib.rs"
-doctest = false
 
 [[bin]]
 name = "orderbook"
@@ -22,29 +22,28 @@ anyhow = { workspace = true }
 app-data = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
-bigdecimal = { workspace = true }
 bad-tokens = { workspace = true }
+bigdecimal = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, features = ["clock"] }
 clap = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-const-hex = { workspace = true }
-hex-literal = { workspace = true }
 gas-price-estimation = { workspace = true }
+hex-literal = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 mimalloc = { workspace = true, optional = true }
-tikv-jemallocator = { workspace = true }
 model = { workspace = true }
 multibase = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
-order-validation = { workspace = true }
 observe = { workspace = true }
+order-validation = { workspace = true }
 price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
@@ -53,10 +52,11 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 shared = { workspace = true }
-strum = { workspace = true }
 sqlx = { workspace = true }
-thiserror = { workspace = true }
+strum = { workspace = true }
 tempfile = { workspace = true, optional = true }
+thiserror = { workspace = true }
+tikv-jemallocator = { workspace = true }
 token-info = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
 toml = { workspace = true }
@@ -67,19 +67,19 @@ url = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }
+shared = { workspace = true, features = ["test-util"] }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["test-util"] }
-shared = { workspace = true, features = ["test-util"] }
 
 [build-dependencies]
 anyhow = { workspace = true }
 vergen = { workspace = true, features = ["git", "gitcl"] }
 
-[lints]
-workspace = true
-
 [features]
 e2e = []
 mimalloc-allocator = ["dep:mimalloc"]
 test-util = ["dep:tempfile", "shared/test-util"]
 tokio-console = ["observe/tokio-console"]
+
+[lints]
+workspace = true
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index cbc15b8a6a..a6300bf8d8 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -7,20 +7,20 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 alloy = { workspace = true }
-app-data = { workspace = true }
 anyhow = { workspace = true }
+app-data = { workspace = true }
 arc-swap = { workspace = true }
 async-trait = { workspace = true }
 bad-tokens = { workspace = true }
 balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
 bytes-hex = { workspace = true }
-const-hex = { workspace = true }
-contracts = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
+const-hex = { workspace = true }
+contracts = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
@@ -38,8 +38,8 @@ prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
 rate-limit = { workspace = true }
-reqwest = { workspace = true }
 request-sharing = { workspace = true }
+reqwest = { workspace = true }
 rust_decimal = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/refunder/Cargo.toml b/crates/refunder/Cargo.toml
index 21524a7f78..174774350f 100644
--- a/crates/refunder/Cargo.toml
+++ b/crates/refunder/Cargo.toml
@@ -10,22 +10,22 @@ alloy = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 clap = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-const-hex = { workspace = true }
 gas-price-estimation = { workspace = true }
 humantime = { workspace = true }
 mimalloc = { workspace = true, optional = true }
-tikv-jemallocator = { workspace = true }
 number = { workspace = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 shared = { workspace = true }
 sqlx = { workspace = true }
-tokio = { workspace = true, features = ["macros", "time", "rt-multi-thread"] }
+tikv-jemallocator = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 tracing = { workspace = true }
 url = { workspace = true }
 
@@ -34,9 +34,9 @@ mockall = { workspace = true }
 rand = { workspace = true }
 rstest = { workspace = true }
 
-[lints]
-workspace = true
-
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
 tokio-console = ["observe/tokio-console"]
+
+[lints]
+workspace = true
diff --git a/crates/s3/Cargo.toml b/crates/s3/Cargo.toml
index ce6ecb3883..821b76c1d2 100644
--- a/crates/s3/Cargo.toml
+++ b/crates/s3/Cargo.toml
@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 anyhow = { workspace = true }
 aws-config = { workspace = true, features = ["behavior-version-latest"] }
-aws-sdk-s3 = { workspace = true, features = ["rustls", "rt-tokio"] }
+aws-sdk-s3 = { workspace = true, features = ["rt-tokio", "rustls"] }
 flate2 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
@@ -16,7 +16,7 @@ tokio = { workspace = true }
 
 [dev-dependencies]
 chrono = { workspace = true, features = ["clock"] }
-tokio = { workspace = true, features = ["test-util", "macros"] }
+tokio = { workspace = true, features = ["macros", "test-util"] }
 
 [lints]
 workspace = true
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 927874c7f0..19950c5473 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -10,19 +10,20 @@ doctest = false
 
 [dependencies]
 account-balances = { workspace = true }
-alloy = { workspace = true, features = ["sol-types", "signer-local", "rand", "provider-trace-api"] }
+alloy = { workspace = true, features = ["provider-trace-api", "rand", "signer-local", "sol-types"] }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 arc-swap = { workspace = true }
-balance-overrides = { workspace = true }
-bad-tokens = { workspace = true }
-bytes-hex = { workspace = true }
 async-trait = { workspace = true }
+bad-tokens = { workspace = true }
+balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
+bytes-hex = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, features = ["clock"] }
 clap = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 dashmap = { workspace = true }
 database = { workspace = true }
@@ -30,15 +31,17 @@ derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
-observe = { workspace = true }
-const-hex = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
+liquidity-sources = { workspace = true }
+mockall = { workspace = true, optional = true }
 model = { workspace = true }
+moka = { workspace = true, features = ["sync"] }
 num = { workspace = true }
 number = { workspace = true }
+observe = { workspace = true }
 order-validation = { workspace = true }
 price-estimation = { workspace = true }
 prometheus = { workspace = true }
@@ -54,12 +57,10 @@ serde_with = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
 token-info = { workspace = true }
-tokio = { workspace = true, features = ["macros", "time", "signal"] }
+tokio = { workspace = true, features = ["macros", "signal", "time"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 url = { workspace = true }
-moka = { workspace = true, features = ["sync"] }
-mockall = { workspace = true, optional = true }
 
 [dev-dependencies]
 account-balances = { workspace = true, features = ["test-util"] }
diff --git a/crates/solver/Cargo.toml b/crates/solver/Cargo.toml
index 615292c87a..b75434b4af 100644
--- a/crates/solver/Cargo.toml
+++ b/crates/solver/Cargo.toml
@@ -6,26 +6,26 @@ edition = "2024"
 license = "GPL-3.0-or-later"
 
 [lib]
+doctest = false
 name = "solver"
 path = "src/lib.rs"
-doctest = false
 
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
 arc-swap = { workspace = true }
 async-trait = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-observe = { workspace = true }
-liquidity-sources = { workspace = true }
-const-hex = { workspace = true }
 hex-literal = { workspace = true }
 itertools = { workspace = true }
+liquidity-sources = { workspace = true }
 model = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
+observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 serde_json = { workspace = true }
@@ -35,13 +35,13 @@ tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 tracing = { workspace = true }
 
 [dev-dependencies]
+ethrpc = { workspace = true, features = ["test-util"] }
+liquidity-sources = { workspace = true, features = ["test-util"] }
 maplit = { workspace = true }
-tokio = { workspace = true, features = ["test-util"] }
-testlib = { workspace = true }
 mockall = { workspace = true }
 shared = { workspace = true, features = ["test-util"] }
-ethrpc = {workspace = true, features = ["test-util"]}
-liquidity-sources = { workspace = true, features = [ "test-util" ] }
+testlib = { workspace = true }
+tokio = { workspace = true, features = ["test-util"] }
 
 [lints]
 workspace = true
diff --git a/crates/solvers-dto/Cargo.toml b/crates/solvers-dto/Cargo.toml
index 3ac3c8df92..cff3154b4b 100644
--- a/crates/solvers-dto/Cargo.toml
+++ b/crates/solvers-dto/Cargo.toml
@@ -6,10 +6,10 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = {workspace = true, features = ["rpc"]}
+alloy = { workspace = true, features = ["rpc"] }
 app-data = { workspace = true }
 bigdecimal = { workspace = true, features = ["serde"] }
-bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
+bytes-hex = { workspace = true }  # may get marked as unused but it's used with serde
 chrono = { workspace = true, features = ["serde"] }
 const-hex = { workspace = true }
 number = { workspace = true }
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index 7a196a69db..2b62c6f628 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -4,9 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [lib]
+doctest = false
 name = "solvers"
 path = "src/lib.rs"
-doctest = false
 
 [[bin]]
 name = "solvers"
@@ -17,7 +17,7 @@ alloy = { workspace = true }
 axum = { workspace = true }
 bigdecimal = { workspace = true, features = ["serde"] }
 chain = { workspace = true }
-chrono = { workspace = true, features = ["serde"], default-features = false }
+chrono = { workspace = true, default-features = false, features = ["serde"] }
 clap = { workspace = true, features = ["derive", "env"] }
 const-hex = { workspace = true }
 derive_more = { workspace = true }
@@ -54,16 +54,16 @@ solver = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
-tempfile = { workspace = true }
 maplit = { workspace = true }
+tempfile = { workspace = true }
 
 [build-dependencies]
 anyhow = { workspace = true }
 vergen = { workspace = true, features = ["git", "gitcl"] }
 
-[lints]
-workspace = true
-
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
 tokio-console = ["observe/tokio-console"]
+
+[lints]
+workspace = true
diff --git a/crates/solvers/config/example.baseline.toml b/crates/solvers/config/example.baseline.toml
index cf4197a0c0..c67b622866 100644
--- a/crates/solvers/config/example.baseline.toml
+++ b/crates/solvers/config/example.baseline.toml
@@ -1,6 +1,6 @@
 chain-id = "1"
 # Alternatively, you can manually specify a WETH contract address:
-#weth = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+# weth = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 base-tokens = []
 max-hops = 0
 max-partial-attempts = 5
diff --git a/crates/testlib/Cargo.toml b/crates/testlib/Cargo.toml
index 9962c65591..a2d47fe248 100644
--- a/crates/testlib/Cargo.toml
+++ b/crates/testlib/Cargo.toml
@@ -1,10 +1,7 @@
 [package]
 name = "testlib"
 version = "0.1.0"
-authors = [
-  "Gnosis Developers <developers@gnosis.io>",
-  "Cow Protocol Developers <dev@cow.fi>"
-]
+authors = ["Gnosis Developers <developers@gnosis.io>", "Cow Protocol Developers <dev@cow.fi>"]
 edition = "2024"
 license = "MIT OR Apache-2.0"
 
diff --git a/crates/token-info/Cargo.toml b/crates/token-info/Cargo.toml
index a01b18cfbf..de4d76a9f3 100644
--- a/crates/token-info/Cargo.toml
+++ b/crates/token-info/Cargo.toml
@@ -18,8 +18,8 @@ thiserror = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
-mockall = { workspace = true }
 maplit = { workspace = true }
+mockall = { workspace = true }
 tokio = { workspace = true }
 
 [features]
diff --git a/playground/baseline.toml b/playground/baseline.toml
index c62d9d91eb..43e24b9983 100644
--- a/playground/baseline.toml
+++ b/playground/baseline.toml
@@ -1,14 +1,14 @@
-chain-id = "1" # Ethereum mainnet
+chain-id = "1"  # Ethereum mainnet
 base-tokens = [
-    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", # WETH
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F", # DAI 
-    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", # USDC
-    "0xdAC17F958D2ee523a2206206994597C13D831ec7", # USDT
-    "0xc00e94Cb662C3520282E6f5717214004A7f26888", # COMP
-    "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2", # MKR
-    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", # WBTC
-    "0x6810e776880C02933D47DB1b9fc05908e5386b96", # GNO
+  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",  # WETH
+  "0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
+  "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
+  "0xc00e94Cb662C3520282E6f5717214004A7f26888",  # COMP
+  "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",  # MKR
+  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",  # WBTC
+  "0x6810e776880C02933D47DB1b9fc05908e5386b96",  # GNO
 ]
 max-hops = 2
 max-partial-attempts = 5
-native-token-price-estimation-amount = "100000000000000000" # 0.1 ETH
+native-token-price-estimation-amount = "100000000000000000"  # 0.1 ETH
diff --git a/playground/driver.toml b/playground/driver.toml
index 9099b173ae..2e382e12ff 100644
--- a/playground/driver.toml
+++ b/playground/driver.toml
@@ -1,11 +1,11 @@
 tx-gas-limit = "45000000"
 
 [[solver]]
-name = "baseline" # Arbitrary name given to this solver, must be unique
+name = "baseline"  # Arbitrary name given to this solver, must be unique
 endpoint = "http://baseline"
-absolute-slippage = "40000000000000000" # Denominated in wei, optional
-relative-slippage = "0.1" # Percentage in the [0, 1] range
-account = "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6" # Known test private key
+absolute-slippage = "40000000000000000"  # Denominated in wei, optional
+relative-slippage = "0.1"  # Percentage in the [0, 1] range
+account = "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6"  # Known test private key
 
 [submission]
 gas-price-cap = "1000000000000"
@@ -15,15 +15,15 @@ url = "http://chain:8545"
 
 [liquidity]
 base-tokens = [
-    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", # WETH
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F", # DAI
-    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", # USDC
-    "0xdAC17F958D2ee523a2206206994597C13D831ec7", # USDT
-    "0xc00e94Cb662C3520282E6f5717214004A7f26888", # COMP
-    "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2", # MKR
-    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", # WBTC
-    "0x6810e776880C02933D47DB1b9fc05908e5386b96", # GNO
+  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",  # WETH
+  "0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
+  "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
+  "0xc00e94Cb662C3520282E6f5717214004A7f26888",  # COMP
+  "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",  # MKR
+  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",  # WBTC
+  "0x6810e776880C02933D47DB1b9fc05908e5386b96",  # GNO
 ]
 
-[[liquidity.uniswap-v2]] # Uniswap V2 configuration
+[[liquidity.uniswap-v2]]  # Uniswap V2 configuration
 preset = "uniswap-v2"

From 82d3e7c5d72410f3438009a7a595c21f25382395 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 4 Mar 2026 16:12:31 +0000
Subject: [PATCH 123/219] Extract `signature-validator` and `zeroex-api` crates
  (#4224)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
While fixing my config I got Claude to address my own comments on
https://github.com/cowprotocol/services/pull/4223

Move `signature_validator` and `zeroex_api` modules into their own
workspace crates and update all dependents to import from the new
crates. This continues the effort to reduce the `shared` crate's surface
area.

# Changes
* Extract zeroex-api from shared — this one was a freebie and doesn't
make a lot of sense being in shared as it so specific
* Extract signature-validator — this one allows us to compile cow-amm
without shared (see image below)
* Remove thiserror in crates that had errors with a single variant or
similar, in favor of manual implementation

Left is after, right is before
<img width="1760" height="891" alt="Screenshot 2026-03-03 at 14 10 09"
src="https://github.com/user-attachments/assets/27aef0e7-d5d8-4d1c-a9d2-a912ea43bc91"
/>

## How to test
Compiler + tests

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: MartinquaXD <martin.beckmann@protonmail.com>
---
 Cargo.lock                                    | 31 ++++++++++++++++---
 Cargo.toml                                    |  1 +
 crates/account-balances/Cargo.toml            |  1 -
 crates/account-balances/src/lib.rs            | 22 ++++++++++---
 crates/cow-amm/Cargo.toml                     |  2 +-
 crates/cow-amm/src/amm.rs                     |  2 +-
 crates/driver/Cargo.toml                      |  1 +
 .../driver/src/boundary/liquidity/zeroex.rs   |  3 +-
 .../src/domain/competition/pre_processing.rs  |  6 ++--
 crates/e2e/Cargo.toml                         |  1 +
 crates/e2e/src/api/zeroex.rs                  |  6 ++--
 crates/e2e/tests/e2e/ethflow.rs               |  2 +-
 crates/e2e/tests/e2e/liquidity.rs             |  7 +++--
 crates/liquidity-sources/Cargo.toml           |  3 ++
 crates/liquidity-sources/src/lib.rs           |  1 +
 .../src/zeroex.rs}                            | 14 ++++++++-
 crates/orderbook/Cargo.toml                   |  1 +
 crates/orderbook/src/run.rs                   |  1 -
 crates/shared/Cargo.toml                      |  2 ++
 crates/shared/src/lib.rs                      |  2 --
 crates/shared/src/order_validation.rs         | 22 ++++++-------
 crates/signature-validator/Cargo.toml         | 26 ++++++++++++++++
 .../mod.rs => signature-validator/src/lib.rs} |  0
 .../src}/simulation.rs                        |  0
 crates/solver/src/interactions/zeroex.rs      |  6 ++--
 crates/solver/src/liquidity/zeroex.rs         | 23 +++++++-------
 crates/token-info/Cargo.toml                  |  3 +-
 crates/token-info/src/lib.rs                  | 14 ++++++---
 28 files changed, 143 insertions(+), 60 deletions(-)
 rename crates/{shared/src/zeroex_api.rs => liquidity-sources/src/zeroex.rs} (98%)
 create mode 100644 crates/signature-validator/Cargo.toml
 rename crates/{shared/src/signature_validator/mod.rs => signature-validator/src/lib.rs} (100%)
 rename crates/{shared/src/signature_validator => signature-validator/src}/simulation.rs (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 427c93be26..d9dc175285 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -16,7 +16,6 @@ dependencies = [
  "itertools 0.14.0",
  "mockall",
  "model",
- "thiserror 1.0.69",
  "tokio",
  "tracing",
 ]
@@ -2548,7 +2547,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "shared",
+ "signature-validator",
  "sqlx",
  "tokio",
  "tracing",
@@ -2969,6 +2968,7 @@ dependencies = [
  "serde_json",
  "serde_with",
  "shared",
+ "signature-validator",
  "solver",
  "solvers-dto",
  "tempfile",
@@ -3030,6 +3030,7 @@ dependencies = [
  "rstest",
  "serde_json",
  "shared",
+ "signature-validator",
  "solver",
  "solvers",
  "solvers-dto",
@@ -4343,9 +4344,12 @@ dependencies = [
  "alloy",
  "anyhow",
  "async-trait",
+ "bytes-hex",
  "cached",
  "chain",
+ "chrono",
  "clap",
+ "const-hex",
  "contracts",
  "ethrpc",
  "event-indexing",
@@ -5056,6 +5060,7 @@ dependencies = [
  "serde_json",
  "serde_with",
  "shared",
+ "signature-validator",
  "sqlx",
  "strum",
  "tempfile",
@@ -6695,6 +6700,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_with",
+ "signature-validator",
  "strum",
  "testlib",
  "thiserror 1.0.69",
@@ -6732,6 +6738,24 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "signature-validator"
+version = "0.1.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "async-trait",
+ "balance-overrides",
+ "const-hex",
+ "contracts",
+ "ethrpc",
+ "hex-literal",
+ "mockall",
+ "model",
+ "thiserror 1.0.69",
+ "tracing",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.8"
@@ -7425,7 +7449,7 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 name = "token-info"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
  "anyhow",
  "async-trait",
  "contracts",
@@ -7434,7 +7458,6 @@ dependencies = [
  "maplit",
  "mockall",
  "model",
- "thiserror 1.0.69",
  "tokio",
  "tracing",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index cdf02e0130..4c76a47f09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -94,6 +94,7 @@ serde-ext = { path = "crates/serde-ext" }
 serde_json = "1.0.117"
 serde_with = "3.8.1"
 shared = { path = "crates/shared" }
+signature-validator = { path = "crates/signature-validator" }
 solver = { path = "crates/solver" }
 solvers = { path = "crates/solvers" }
 solvers-dto = { path = "crates/solvers-dto" }
diff --git a/crates/account-balances/Cargo.toml b/crates/account-balances/Cargo.toml
index 6a1de685d6..10929cc9a5 100644
--- a/crates/account-balances/Cargo.toml
+++ b/crates/account-balances/Cargo.toml
@@ -16,7 +16,6 @@ futures = { workspace = true }
 itertools = { workspace = true }
 mockall = { workspace = true, optional = true }
 model = { workspace = true }
-thiserror = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 
diff --git a/crates/account-balances/src/lib.rs b/crates/account-balances/src/lib.rs
index c1ff5091fc..7febfa8e3c 100644
--- a/crates/account-balances/src/lib.rs
+++ b/crates/account-balances/src/lib.rs
@@ -12,7 +12,6 @@ use {
         order::{Order, SellTokenSource},
     },
     std::sync::{Arc, LazyLock},
-    thiserror::Error,
 };
 
 mod cached;
@@ -219,10 +218,25 @@ pub struct Simulation {
     pub can_transfer: bool,
 }
 
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum SimulationError {
-    #[error("method error: {0:?}")]
-    Method(#[from] alloy::contract::Error),
+    Method(alloy::contract::Error),
+}
+
+impl std::fmt::Display for SimulationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Method(err) => write!(f, "method error: {err:?}"),
+        }
+    }
+}
+
+impl std::error::Error for SimulationError {}
+
+impl From<alloy::contract::Error> for SimulationError {
+    fn from(err: alloy::contract::Error) -> Self {
+        Self::Method(err)
+    }
 }
 
 // ZKSync-based chains don't use the default 0x0 account when `tx.from` is not
diff --git a/crates/cow-amm/Cargo.toml b/crates/cow-amm/Cargo.toml
index 41e75b77bf..bcdee4ac87 100644
--- a/crates/cow-amm/Cargo.toml
+++ b/crates/cow-amm/Cargo.toml
@@ -18,7 +18,7 @@ model = { workspace = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
-shared = { workspace = true }
+signature-validator = { workspace = true }
 sqlx = { workspace = true }
 tokio = { workspace = true, features = [] }
 tracing = { workspace = true }
diff --git a/crates/cow-amm/src/amm.rs b/crates/cow-amm/src/amm.rs
index 0bd42aa195..9d6d8f2d91 100644
--- a/crates/cow-amm/src/amm.rs
+++ b/crates/cow-amm/src/amm.rs
@@ -13,7 +13,7 @@ use {
         order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
         signature::{Signature, hashed_eip712_message},
     },
-    shared::signature_validator::{SignatureCheck, SignatureValidating},
+    signature_validator::{SignatureCheck, SignatureValidating},
 };
 
 #[derive(Clone, Debug)]
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 98d77373d6..9df0326a89 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -82,6 +82,7 @@ contracts = { workspace = true }
 model = { workspace = true }
 observe = { workspace = true }
 shared = { workspace = true }
+signature-validator = { workspace = true }
 solver = { workspace = true }
 tracing = { workspace = true }
 
diff --git a/crates/driver/src/boundary/liquidity/zeroex.rs b/crates/driver/src/boundary/liquidity/zeroex.rs
index 0f98e1207e..3abf62dada 100644
--- a/crates/driver/src/boundary/liquidity/zeroex.rs
+++ b/crates/driver/src/boundary/liquidity/zeroex.rs
@@ -8,8 +8,9 @@ use {
     },
     anyhow::anyhow,
     ethrpc::block_stream::CurrentBlockWatcher,
+    liquidity_sources::zeroex::DefaultZeroExApi,
     price_estimation::gas::GAS_PER_ZEROEX_ORDER,
-    shared::{http_client::HttpClientFactory, zeroex_api::DefaultZeroExApi},
+    shared::http_client::HttpClientFactory,
     solver::{
         liquidity::{LimitOrder, zeroex::ZeroExLiquidity},
         liquidity_collector::LiquidityCollecting,
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index bf164c1ee6..585a87e6da 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -25,7 +25,7 @@ use {
         order::{OrderKind, SellTokenSource},
         signature::Signature,
     },
-    shared::signature_validator::SignatureValidating,
+    signature_validator::SignatureValidating,
     std::{
         collections::HashMap,
         future::Future,
@@ -137,9 +137,9 @@ impl DataAggregator {
         tokens: tokens::Fetcher,
         balance_fetcher: Arc<dyn BalanceFetching>,
     ) -> Self {
-        let signature_validator = shared::signature_validator::validator(
+        let signature_validator = signature_validator::validator(
             eth.web3(),
-            shared::signature_validator::Contracts {
+            signature_validator::Contracts {
                 settlement: eth.contracts().settlement().clone(),
                 vault_relayer: eth.contracts().vault_relayer().0,
                 signatures: eth.contracts().signatures().clone(),
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index a2ae35a455..fd0032b6d9 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -51,6 +51,7 @@ price-estimation = { workspace = true }
 reqwest = { workspace = true, features = ["blocking", "query"] }
 serde_json = { workspace = true }
 shared = { workspace = true }
+signature-validator = { workspace = true }
 solver = { workspace = true }
 solvers = { workspace = true }
 solvers-dto = { workspace = true }
diff --git a/crates/e2e/src/api/zeroex.rs b/crates/e2e/src/api/zeroex.rs
index 9ee37560de..f305302cc4 100644
--- a/crates/e2e/src/api/zeroex.rs
+++ b/crates/e2e/src/api/zeroex.rs
@@ -4,8 +4,8 @@ use {
     axum::Json,
     chrono::{DateTime, NaiveDateTime, Utc},
     hex_literal::hex,
+    liquidity_sources::zeroex::{self, Order, OrderMetadata, OrderRecord, ZeroExSignature},
     model::DomainSeparator,
-    shared::zeroex_api::{self, Order, OrderMetadata, OrderRecord, ZeroExSignature},
     std::{
         net::{Ipv4Addr, SocketAddr},
         sync::Arc,
@@ -63,8 +63,8 @@ impl ZeroExApi {
 
 async fn orders_handler(
     axum::extract::State(state): axum::extract::State<State>,
-) -> Json<zeroex_api::OrdersResponse> {
-    Json(zeroex_api::OrdersResponse {
+) -> Json<zeroex::OrdersResponse> {
+    Json(zeroex::OrdersResponse {
         total: state.orders.len() as u64,
         page: MOCK_PAGE,
         per_page: MOCK_PER_PAGE,
diff --git a/crates/e2e/tests/e2e/ethflow.rs b/crates/e2e/tests/e2e/ethflow.rs
index 3cf2406a5e..8b8c5d70dc 100644
--- a/crates/e2e/tests/e2e/ethflow.rs
+++ b/crates/e2e/tests/e2e/ethflow.rs
@@ -48,7 +48,7 @@ use {
     number::{nonzero::NonZeroU256, units::EthUnit},
     refunder::RefundStatus,
     reqwest::Client,
-    shared::signature_validator::check_erc1271_result,
+    signature_validator::check_erc1271_result,
     std::ops::DerefMut,
 };
 
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 3f726cb2b5..8b77ff037e 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -23,6 +23,7 @@ use {
         },
     },
     ethrpc::{Web3, alloy::CallBuilderExt},
+    liquidity_sources::zeroex,
     model::{
         order::{OrderCreation, OrderKind},
         signature::EcdsaSigningScheme,
@@ -295,7 +296,7 @@ fn create_zeroex_liquidity_orders(
     zeroex_addr: Address,
     chain_id: u64,
     weth_address: Address,
-) -> [shared::zeroex_api::OrderRecord; 3] {
+) -> [zeroex::OrderRecord; 3] {
     let typed_order = Eip712TypedZeroExOrder {
         maker_token: order_creation.buy_token,
         taker_token: order_creation.sell_token,
@@ -365,7 +366,7 @@ struct ZeroExOrderAmounts {
 
 async fn get_zeroex_order_amounts(
     zeroex: &IZeroex::Instance,
-    zeroex_order: &shared::zeroex_api::OrderRecord,
+    zeroex_order: &zeroex::OrderRecord,
 ) -> anyhow::Result<ZeroExOrderAmounts> {
     Ok(zeroex
         .getLimitOrderRelevantState(
@@ -400,7 +401,7 @@ async fn get_zeroex_order_amounts(
 
 async fn fill_or_kill_zeroex_limit_order(
     zeroex: &IZeroex::Instance,
-    zeroex_order: &shared::zeroex_api::OrderRecord,
+    zeroex_order: &zeroex::OrderRecord,
     from: Address,
 ) -> anyhow::Result<B256> {
     let order = zeroex_order.order();
diff --git a/crates/liquidity-sources/Cargo.toml b/crates/liquidity-sources/Cargo.toml
index 9406a849ce..ce39c4990c 100644
--- a/crates/liquidity-sources/Cargo.toml
+++ b/crates/liquidity-sources/Cargo.toml
@@ -9,9 +9,12 @@ license = "MIT OR Apache-2.0"
 alloy = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+bytes-hex = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
+chrono = { workspace = true }
 clap = { workspace = true }
+const-hex = { workspace = true }
 contracts = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
diff --git a/crates/liquidity-sources/src/lib.rs b/crates/liquidity-sources/src/lib.rs
index aba36476e0..bf3ef43fc8 100644
--- a/crates/liquidity-sources/src/lib.rs
+++ b/crates/liquidity-sources/src/lib.rs
@@ -10,6 +10,7 @@ pub mod swapr;
 pub mod uniswap_v2;
 pub mod uniswap_v3;
 pub mod uniswap_v3_pair_provider;
+pub mod zeroex;
 
 use {chain::Chain, core::panic};
 
diff --git a/crates/shared/src/zeroex_api.rs b/crates/liquidity-sources/src/zeroex.rs
similarity index 98%
rename from crates/shared/src/zeroex_api.rs
rename to crates/liquidity-sources/src/zeroex.rs
index d29eacbea1..663fe5baea 100644
--- a/crates/shared/src/zeroex_api.rs
+++ b/crates/liquidity-sources/src/zeroex.rs
@@ -29,6 +29,18 @@ use {
 
 const ORDERS_MAX_PAGE_SIZE: usize = 1_000;
 
+/// Join a path with a URL, ensuring that there is only one slash between them.
+fn join_url(url: &Url, mut path: &str) -> Url {
+    let mut url = url.to_string();
+    while url.ends_with('/') {
+        url.pop();
+    }
+    while path.starts_with('/') {
+        path = &path[1..]
+    }
+    Url::parse(&format!("{url}/{path}")).unwrap()
+}
+
 /// 0x API orders query parameters.
 ///
 /// These parameters are currently incomplete, and missing parameters can be
@@ -51,7 +63,7 @@ pub struct OrdersQuery {
 impl OrdersQuery {
     /// Encodes the orders query as a url with parameters.
     fn format_url(&self, base_url: &Url) -> Url {
-        let mut url = crate::url::join(base_url, "/orderbook/v1/orders");
+        let mut url = join_url(base_url, "/orderbook/v1/orders");
 
         if let Some(taker) = self.taker {
             url.query_pairs_mut()
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index e65b2474a3..227074147c 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -52,6 +52,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 shared = { workspace = true }
+signature-validator = { workspace = true }
 sqlx = { workspace = true }
 strum = { workspace = true }
 tempfile = { workspace = true, optional = true }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 801d46c358..f5dda9424f 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -41,7 +41,6 @@ use {
         http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
         order_validation::{OrderValidPeriodConfiguration, OrderValidator},
-        signature_validator,
     },
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
     token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 19950c5473..258f1237c8 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -54,6 +54,7 @@ rust_decimal = { workspace = true, features = ["maths"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
+signature-validator = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
 token-info = { workspace = true }
@@ -72,6 +73,7 @@ maplit = { workspace = true }
 mockall = { workspace = true }
 price-estimation = { workspace = true, features = ["test-util"] }
 regex = { workspace = true }
+signature-validator = { workspace = true, features = ["test-util"] }
 testlib = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
 toml = { workspace = true }
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 49500cfff4..97631bb594 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -15,11 +15,9 @@ pub mod interaction;
 pub mod order_quoting;
 pub mod order_validation;
 pub mod remaining_amounts;
-pub mod signature_validator;
 pub mod token_list;
 pub mod url;
 pub mod web3;
-pub mod zeroex_api;
 
 /// anyhow errors are not clonable natively. This is a workaround that creates a
 /// new anyhow error based on formatting the error with its inner sources
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 09e48a0e72..05f3cebca2 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -1,13 +1,10 @@
 use {
-    crate::{
-        order_quoting::{
-            CalculateQuoteError,
-            OrderQuoting,
-            Quote,
-            QuoteParameters,
-            QuoteSearchParameters,
-        },
-        signature_validator::{SignatureCheck, SignatureValidating, SignatureValidationError},
+    crate::order_quoting::{
+        CalculateQuoteError,
+        OrderQuoting,
+        Quote,
+        QuoteParameters,
+        QuoteSearchParameters,
     },
     account_balances::{self, BalanceFetching, TransferSimulationError},
     alloy::primitives::{Address, B256, U256},
@@ -45,6 +42,7 @@ use {
         trade_finding,
         trade_verifier::code_fetching::CodeFetching,
     },
+    signature_validator::{SignatureCheck, SignatureValidating, SignatureValidationError},
     std::{sync::Arc, time::Duration},
     tracing::instrument,
 };
@@ -1036,10 +1034,7 @@ pub fn convert_signing_scheme_into_quote_signing_scheme(
 mod tests {
     use {
         super::*,
-        crate::{
-            order_quoting::{FindQuoteError, MockOrderQuoting},
-            signature_validator::MockSignatureValidating,
-        },
+        crate::order_quoting::{FindQuoteError, MockOrderQuoting},
         account_balances::MockBalanceFetching,
         alloy::{
             primitives::{Address, U160, address, b256},
@@ -1056,6 +1051,7 @@ mod tests {
         number::nonzero::NonZeroU256,
         price_estimation::trade_verifier::code_fetching::MockCodeFetching,
         serde_json::json,
+        signature_validator::MockSignatureValidating,
     };
 
     #[tokio::test]
diff --git a/crates/signature-validator/Cargo.toml b/crates/signature-validator/Cargo.toml
new file mode 100644
index 0000000000..f2cdc623ee
--- /dev/null
+++ b/crates/signature-validator/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "signature-validator"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+balance-overrides = { workspace = true }
+const-hex = { workspace = true }
+contracts = { workspace = true }
+ethrpc = { workspace = true }
+hex-literal = { workspace = true }
+mockall = { workspace = true, optional = true }
+model = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+[features]
+test-util = ["dep:mockall"]
+
+[lints]
+workspace = true
diff --git a/crates/shared/src/signature_validator/mod.rs b/crates/signature-validator/src/lib.rs
similarity index 100%
rename from crates/shared/src/signature_validator/mod.rs
rename to crates/signature-validator/src/lib.rs
diff --git a/crates/shared/src/signature_validator/simulation.rs b/crates/signature-validator/src/simulation.rs
similarity index 100%
rename from crates/shared/src/signature_validator/simulation.rs
rename to crates/signature-validator/src/simulation.rs
diff --git a/crates/solver/src/interactions/zeroex.rs b/crates/solver/src/interactions/zeroex.rs
index 00f7e4216b..b4735026fa 100644
--- a/crates/solver/src/interactions/zeroex.rs
+++ b/crates/solver/src/interactions/zeroex.rs
@@ -1,9 +1,7 @@
 use {
     contracts::alloy::IZeroex,
-    shared::{
-        interaction::{EncodedInteraction, Interaction},
-        zeroex_api::Order,
-    },
+    liquidity_sources::zeroex::Order,
+    shared::interaction::{EncodedInteraction, Interaction},
     std::sync::Arc,
 };
 
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index 4f08ea2096..16020a0f8c 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -13,9 +13,11 @@ use {
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
     futures::StreamExt,
     itertools::Itertools,
-    liquidity_sources::recent_block_cache::Block,
+    liquidity_sources::{
+        recent_block_cache::Block,
+        zeroex::{OrderRecord, OrdersQuery, ZeroExApi},
+    },
     model::{TokenPair, order::OrderKind},
-    shared::zeroex_api::{OrderRecord, OrdersQuery, ZeroExApi},
     std::{
         collections::{HashMap, HashSet},
         sync::Arc,
@@ -215,12 +217,11 @@ impl SettlementHandling<LimitOrder> for OrderSettlementHandler {
 pub mod tests {
     use {
         super::*,
-        liquidity_sources::base_tokens::BaseTokens,
-        shared::{
-            http_solver::model::InternalizationStrategy,
-            interaction::Interaction,
-            zeroex_api::{self, OrderMetadata},
+        liquidity_sources::{
+            base_tokens::BaseTokens,
+            zeroex::{self, OrderMetadata},
         },
+        shared::{http_solver::model::InternalizationStrategy, interaction::Interaction},
     };
 
     fn get_relevant_pairs(token_a: Address, token_b: Address) -> HashSet<TokenPair> {
@@ -231,7 +232,7 @@ pub mod tests {
 
     fn order_with_tokens(token_a: Address, token_b: Address) -> OrderRecord {
         OrderRecord::new(
-            zeroex_api::Order {
+            zeroex::Order {
                 taker_token: token_a,
                 maker_token: token_b,
                 ..Default::default()
@@ -275,7 +276,7 @@ pub mod tests {
         let relevant_pairs = get_relevant_pairs(token_a, token_b);
         let order_with_fillable_amount = |remaining_fillable_taker_amount| {
             OrderRecord::new(
-                zeroex_api::Order {
+                zeroex::Order {
                     taker_token: token_a,
                     maker_token: token_b,
                     taker_amount: 100_000_000,
@@ -315,7 +316,7 @@ pub mod tests {
         let relevant_pairs = get_relevant_pairs(token_a, token_b);
         let order_with_amount = |taker_amount, remaining_fillable_taker_amount| {
             OrderRecord::new(
-                zeroex_api::Order {
+                zeroex::Order {
                     taker_token: token_a,
                     maker_token: token_b,
                     taker_amount,
@@ -350,7 +351,7 @@ pub mod tests {
             ethrpc::mock::web3().provider,
         ));
         let order_record = OrderRecord::new(
-            zeroex_api::Order {
+            zeroex::Order {
                 taker_amount: 100,
                 taker_token: sell_token,
                 ..Default::default()
diff --git a/crates/token-info/Cargo.toml b/crates/token-info/Cargo.toml
index de4d76a9f3..5d6205af45 100644
--- a/crates/token-info/Cargo.toml
+++ b/crates/token-info/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 contracts = { workspace = true }
@@ -14,7 +14,6 @@ ethrpc = { workspace = true }
 futures = { workspace = true }
 mockall = { workspace = true, optional = true }
 model = { workspace = true }
-thiserror = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
diff --git a/crates/token-info/src/lib.rs b/crates/token-info/src/lib.rs
index 44fc73aa75..71891f5638 100644
--- a/crates/token-info/src/lib.rs
+++ b/crates/token-info/src/lib.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::Address,
+    alloy_primitives::Address,
     anyhow::Result,
     async_trait::async_trait,
     contracts::alloy::ERC20,
@@ -13,7 +13,6 @@ use {
         collections::HashMap,
         sync::{Arc, Mutex},
     },
-    thiserror::Error,
 };
 
 #[cfg_attr(test, derive(Eq, PartialEq))]
@@ -23,10 +22,17 @@ pub struct TokenInfo {
     pub symbol: Option<String>,
 }
 
-#[derive(Clone, Debug, Error)]
-#[error("error fetching token info: {0}")]
+#[derive(Clone, Debug)]
 pub struct Error(String);
 
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "error fetching token info: {}", self.0)
+    }
+}
+
+impl std::error::Error for Error {}
+
 #[cfg_attr(any(test, feature = "test-util"), mockall::automock)]
 #[async_trait]
 pub trait TokenInfoFetching: Send + Sync {

From c9db01a626a04460cb2aadeebfbb036f1163673c Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 5 Mar 2026 10:07:42 +0100
Subject: [PATCH 124/219] Increase override amount (#4231)

# Description

We got a report about failing simulations on Polygon. It turns out that
when we put in this change we had 1 ETH in mind which is fine on ETH
chains, but it also translates to 1 POL which is worth about $0.9 and
leads to simulation failures due to insufficient gas.
---
 crates/price-estimation/src/trade_verifier/mod.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index e49e429c66..9337666272 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -39,7 +39,6 @@ use {
             u256_to_big_rational,
         },
         nonzero::NonZeroU256,
-        units::EthUnit,
     },
     std::{
         collections::{HashMap, HashSet},
@@ -422,7 +421,10 @@ impl TradeVerifier {
         let solver_override = AccountOverride {
             code: Some(Solver::Solver::DEPLOYED_BYTECODE.clone()),
             // Allow solver simulations to proceed even if the real account holds no ETH.
-            balance: Some(1u64.eth()),
+            // The number is obscenely large, but not max to avoid potential overflows.
+            // We had this set to eth(1), but some simulations require more than that on non-ETH
+            // netowrks e.g. polygon so it led to reverts.
+            balance: Some(U256::MAX / U256::from(2)),
             ..Default::default()
         };
 

From 5131860d21c0f25f8a6cc12230a83e3ee585a512 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Thu, 5 Mar 2026 10:28:50 +0100
Subject: [PATCH 125/219] replace `alloy` dependencies with specific
 sub-dependencies (#4230)

# Description
While depending on `alloy` is convenient because it bundles everything
inside 1 dependency it also hides what parts are actually needed and can
delay the compilation of crates unnecessarily.

# Changes
replace `alloy` dependency with the actually used sub-crates like
`alloy-primitives` and `alloy-provider`

this PR mostly focuses on the smaller "leaf" dependency crates as they
are manageable in size and allowing them to compile earlier is more
important than optimizing crates like `driver`, and `autopilot`.

So far this PR only improves the compile time very slightly by making
sure `contracts` does not indirectly depend on `aws-sdk-kms` as that is
insanely slow to compile.
The effects of this change will be more pronounced when we change the
`contracts` crate to be compiled as individual `crates`.
But I think even without huge compile time gains being explicit about
our dependencies still makes sense.

## How to test
compiler
---
 Cargo.lock                                    | 326 +++++++++++++-----
 Cargo.toml                                    |  11 +
 crates/account-balances/Cargo.toml            |   6 +-
 crates/account-balances/src/cached.rs         |   4 +-
 crates/account-balances/src/lib.rs            |  16 +-
 crates/account-balances/src/simulation.rs     |  10 +-
 crates/autopilot/Cargo.toml                   |   2 +-
 crates/bad-tokens/Cargo.toml                  |   7 +-
 crates/bad-tokens/src/list_based.rs           |   2 +-
 crates/bad-tokens/src/trace_call.rs           |  43 +--
 crates/balance-overrides/Cargo.toml           |   7 +-
 crates/balance-overrides/src/detector.rs      |  36 +-
 crates/balance-overrides/src/lib.rs           |   8 +-
 crates/contracts/Cargo.toml                   |   9 +-
 crates/contracts/build.rs                     |  28 +-
 crates/contracts/src/lib.rs                   |   2 -
 crates/contracts/src/vault.rs                 |  64 ----
 crates/cow-amm/Cargo.toml                     |   6 +-
 crates/cow-amm/src/amm.rs                     |   4 +-
 crates/cow-amm/src/cache.rs                   |   9 +-
 crates/cow-amm/src/factory.rs                 |  10 +-
 crates/cow-amm/src/lib.rs                     |  10 +-
 crates/cow-amm/src/registry.rs                |   2 +-
 crates/driver/Cargo.toml                      |   1 +
 crates/e2e/src/setup/deploy.rs                |  41 ++-
 crates/ethrpc/Cargo.toml                      |  31 +-
 crates/ethrpc/src/alloy/buffering.rs          |   6 +-
 crates/ethrpc/src/alloy/errors.rs             |  12 +-
 crates/ethrpc/src/alloy/evm_ext.rs            |   8 +-
 crates/ethrpc/src/alloy/instrumentation.rs    |  12 +-
 crates/ethrpc/src/alloy/mod.rs                |  18 +-
 crates/ethrpc/src/alloy/wallet.rs             |  14 +-
 crates/ethrpc/src/block_stream.rs             |  16 +-
 crates/ethrpc/src/lib.rs                      |   2 +-
 crates/ethrpc/src/mock.rs                     |   2 +-
 crates/event-indexing/Cargo.toml              |   7 +-
 crates/event-indexing/src/block_retriever.rs  |  10 +-
 crates/event-indexing/src/event_handler.rs    |  27 +-
 crates/gas-price-estimation/Cargo.toml        |   3 +-
 .../src/configurable_alloy.rs                 |   6 +-
 crates/gas-price-estimation/src/driver.rs     |   6 +-
 crates/gas-price-estimation/src/eth_node.rs   |   6 +-
 crates/gas-price-estimation/src/fake.rs       |   2 +-
 crates/gas-price-estimation/src/gas_price.rs  |   2 +-
 crates/gas-price-estimation/src/lib.rs        |   6 +-
 crates/gas-price-estimation/src/priority.rs   |   4 +-
 crates/liquidity-sources/Cargo.toml           |   2 +-
 crates/signature-validator/Cargo.toml         |   7 +-
 crates/signature-validator/src/lib.rs         |   2 +-
 crates/signature-validator/src/simulation.rs  |  14 +-
 crates/solvers-dto/Cargo.toml                 |   3 +-
 crates/solvers-dto/src/auction.rs             |   2 +-
 crates/solvers-dto/src/notification.rs        |   6 +-
 crates/solvers-dto/src/solution.rs            |   2 +-
 54 files changed, 510 insertions(+), 392 deletions(-)
 delete mode 100644 crates/contracts/src/vault.rs

diff --git a/Cargo.lock b/Cargo.lock
index d9dc175285..ac5b4aacc5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6,7 +6,11 @@ version = 4
 name = "account-balances"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-contract",
+ "alloy-dyn-abi",
+ "alloy-primitives",
+ "alloy-rpc-types",
+ "alloy-sol-types",
  "anyhow",
  "async-trait",
  "balance-overrides",
@@ -90,7 +94,6 @@ dependencies = [
  "alloy-json-rpc",
  "alloy-network",
  "alloy-provider",
- "alloy-pubsub",
  "alloy-rpc-client",
  "alloy-rpc-types",
  "alloy-serde",
@@ -99,7 +102,6 @@ dependencies = [
  "alloy-signer-local",
  "alloy-transport",
  "alloy-transport-http",
- "alloy-transport-ws",
  "alloy-trie",
 ]
 
@@ -168,7 +170,6 @@ dependencies = [
  "alloy-network-primitives",
  "alloy-primitives",
  "alloy-provider",
- "alloy-pubsub",
  "alloy-rpc-types-eth",
  "alloy-sol-types",
  "alloy-transport",
@@ -193,9 +194,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-dyn-abi"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "369f5707b958927176265e8a58627fc6195e5dfa5c55689396e68b241b3a72e6"
+checksum = "cc2db5c583aaef0255aa63a4fe827f826090142528bba48d1bf4119b62780cad"
 dependencies = [
  "alloy-json-abi",
  "alloy-primitives",
@@ -284,9 +285,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-json-abi"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84e3cf01219c966f95a460c95f1d4c30e12f6c18150c21a30b768af2a2a29142"
+checksum = "e9dbe713da0c737d9e5e387b0ba790eb98b14dd207fe53eef50e19a5a8ec3dac"
 dependencies = [
  "alloy-primitives",
  "alloy-sol-type-parser",
@@ -350,9 +351,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-primitives"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6a0fb18dd5fb43ec5f0f6a20be1ce0287c79825827de5744afaa6c957737c33"
+checksum = "de3b431b4e72cd8bd0ec7a50b4be18e73dab74de0dba180eef171055e5d5926e"
 dependencies = [
  "alloy-rlp",
  "bytes",
@@ -360,7 +361,7 @@ dependencies = [
  "const-hex",
  "derive_more 2.1.1",
  "foldhash 0.2.0",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "hashbrown 0.16.1",
  "indexmap 2.13.0",
  "itoa",
@@ -374,7 +375,6 @@ dependencies = [
  "rustc-hash",
  "serde",
  "sha3",
- "tiny-keccak",
 ]
 
 [[package]]
@@ -657,9 +657,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09eb18ce0df92b4277291bbaa0ed70545d78b02948df756bbd3d6214bf39a218"
+checksum = "ab81bab693da9bb79f7a95b64b394718259fdd7e41dceeced4cad57cb71c4f6a"
 dependencies = [
  "alloy-sol-macro-expander",
  "alloy-sol-macro-input",
@@ -671,9 +671,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro-expander"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95d9fa2daf21f59aa546d549943f10b5cce1ae59986774019fbedae834ffe01b"
+checksum = "489f1620bb7e2483fb5819ed01ab6edc1d2f93939dce35a5695085a1afd1d699"
 dependencies = [
  "alloy-json-abi",
  "alloy-sol-macro-input",
@@ -683,16 +683,16 @@ dependencies = [
  "proc-macro-error2",
  "proc-macro2",
  "quote",
+ "sha3",
  "syn 2.0.114",
  "syn-solidity",
- "tiny-keccak",
 ]
 
 [[package]]
 name = "alloy-sol-macro-input"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9396007fe69c26ee118a19f4dee1f5d1d6be186ea75b3881adf16d87f8444686"
+checksum = "56cef806ad22d4392c5fc83cf8f2089f988eb99c7067b4e0c6f1971fc1cca318"
 dependencies = [
  "alloy-json-abi",
  "const-hex",
@@ -708,9 +708,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-type-parser"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af67a0b0dcebe14244fc92002cd8d96ecbf65db4639d479f5fcd5805755a4c27"
+checksum = "a6df77fea9d6a2a75c0ef8d2acbdfd92286cc599983d3175ccdc170d3433d249"
 dependencies = [
  "serde",
  "winnow",
@@ -718,9 +718,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-types"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09aeea64f09a7483bdcd4193634c7e5cf9fd7775ee767585270cd8ce2d69dc95"
+checksum = "64612d29379782a5dde6f4b6570d9c756d734d760c0c94c254d361e678a6591f"
 dependencies = [
  "alloy-json-abi",
  "alloy-primitives",
@@ -1831,7 +1831,12 @@ dependencies = [
 name = "bad-tokens"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-json-rpc",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types",
+ "alloy-sol-types",
+ "alloy-transport",
  "anyhow",
  "contracts",
  "ethrpc",
@@ -1843,7 +1848,12 @@ dependencies = [
 name = "balance-overrides"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types",
+ "alloy-sol-types",
+ "alloy-transport",
  "anyhow",
  "async-trait",
  "cached",
@@ -2440,9 +2450,12 @@ dependencies = [
 name = "contracts"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
  "alloy-sol-macro-expander",
  "alloy-sol-macro-input",
+ "alloy-sol-types",
  "anyhow",
  "paste",
  "prettyplease",
@@ -2533,7 +2546,11 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 name = "cow-amm"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types",
+ "alloy-sol-types",
  "anyhow",
  "app-data",
  "async-trait",
@@ -3158,7 +3175,18 @@ dependencies = [
 name = "ethrpc"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-consensus",
+ "alloy-contract",
+ "alloy-eips",
+ "alloy-json-rpc",
+ "alloy-network",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-client",
+ "alloy-rpc-types",
+ "alloy-signer",
+ "alloy-transport",
+ "alloy-transport-ws",
  "anyhow",
  "async-trait",
  "const-hex",
@@ -3183,7 +3211,11 @@ dependencies = [
 name = "event-indexing"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types",
+ "alloy-sol-types",
  "anyhow",
  "async-stream",
  "async-trait",
@@ -3473,7 +3505,8 @@ checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"
 name = "gas-price-estimation"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-eips",
+ "alloy-provider",
  "anyhow",
  "async-trait",
  "ethrpc",
@@ -3521,11 +3554,24 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
 [[package]]
 name = "gimli"
 version = "0.32.3"
@@ -3896,22 +3942,6 @@ dependencies = [
  "tower-service",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes",
- "http-body-util",
- "hyper 1.8.1",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
-]
-
 [[package]]
 name = "hyper-util"
 version = "0.1.19"
@@ -4043,6 +4073,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -4271,9 +4307,9 @@ dependencies = [
 
 [[package]]
 name = "keccak-asm"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6"
+checksum = "b646a74e746cd25045aa0fd42f4f7f78aa6d119380182c7e63a5593c4ab8df6f"
 dependencies = [
  "digest 0.10.7",
  "sha3-asm",
@@ -4288,6 +4324,12 @@ dependencies = [
  "spin",
 ]
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "libc"
 version = "0.2.180"
@@ -5679,6 +5721,12 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "radium"
 version = "0.7.0"
@@ -5918,20 +5966,16 @@ dependencies = [
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.8.1",
- "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
- "native-tls",
  "percent-encoding",
  "pin-project-lite",
- "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper 1.0.2",
  "tokio",
- "tokio-native-tls",
  "tower 0.5.3",
  "tower-http",
  "tower-service",
@@ -6631,9 +6675,9 @@ dependencies = [
 
 [[package]]
 name = "sha3-asm"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46"
+checksum = "b31139435f327c93c6038ed350ae4588e2c70a13d50599509fee6349967ba35a"
 dependencies = [
  "cc",
  "cfg-if",
@@ -6742,7 +6786,12 @@ dependencies = [
 name = "signature-validator"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-contract",
+ "alloy-dyn-abi",
+ "alloy-primitives",
+ "alloy-rpc-types",
+ "alloy-sol-types",
+ "alloy-transport",
  "anyhow",
  "async-trait",
  "balance-overrides",
@@ -6877,7 +6926,8 @@ dependencies = [
 name = "solvers-dto"
 version = "0.1.0"
 dependencies = [
- "alloy",
+ "alloy-primitives",
+ "alloy-rpc-types",
  "app-data",
  "bigdecimal",
  "bytes-hex",
@@ -7191,9 +7241,9 @@ dependencies = [
 
 [[package]]
 name = "syn-solidity"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f92d01b5de07eaf324f7fca61cc6bd3d82bbc1de5b6c963e6fe79e86f36580d"
+checksum = "53f425ae0b12e2f5ae65542e00898d500d4d318b4baf09f40fd0d410454e9947"
 dependencies = [
  "paste",
  "proc-macro2",
@@ -7411,15 +7461,6 @@ dependencies = [
  "time-core",
 ]
 
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
 [[package]]
 name = "tinystr"
 version = "0.8.2"
@@ -7500,16 +7541,6 @@ dependencies = [
  "syn 2.0.114",
 ]
 
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.24.1"
@@ -8097,7 +8128,16 @@ version = "1.0.1+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
 dependencies = [
- "wit-bindgen",
+ "wit-bindgen 0.46.0",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
 ]
 
 [[package]]
@@ -8165,6 +8205,28 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.13.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
 [[package]]
 name = "wasm-streams"
 version = "0.5.0"
@@ -8178,6 +8240,18 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.10.0",
+ "hashbrown 0.15.5",
+ "indexmap 2.13.0",
+ "semver 1.0.27",
+]
+
 [[package]]
 name = "wasmtimer"
 version = "0.4.3"
@@ -8227,14 +8301,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -8643,6 +8717,94 @@ version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap 2.13.0",
+ "prettyplease",
+ "syn 2.0.114",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.10.0",
+ "indexmap 2.13.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.13.0",
+ "log",
+ "semver 1.0.27",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.2"
diff --git a/Cargo.toml b/Cargo.toml
index 4c76a47f09..88a811deb8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,13 +5,24 @@ members = ["crates/*"]
 [workspace.dependencies]
 account-balances = { path = "crates/account-balances" }
 alloy = { version = "1.7.3", default-features = false }
+alloy-consensus = { version = "1.7.3", default-features = false }
 alloy-contract = { version = "1.7.3", default-features = false }
+alloy-dyn-abi = { version = "1.5.7", default-features = false }
+alloy-eips = { version = "1.7.3", default-features = false }
+alloy-json-abi = { version = "1.5.7", default-features = false }
+alloy-json-rpc = { version = "1.7.3", default-features = false }
+alloy-network = { version = "1.7.3", default-features = false }
 alloy-primitives = { version = "1.5.2", default-features = false }
+alloy-provider = { version = "1.7.3", default-features = false }
+alloy-rpc-client = { version = "1.7.3", default-features = false }
+alloy-rpc-types = { version = "1.7.3", default-features = false }
 alloy-signer = { version = "1.7.3", default-features = false }
 alloy-signer-local = { version = "1.7.3", default-features = false }
 alloy-sol-macro-expander = "1.4.1"
 alloy-sol-macro-input = "1.4.1"
 alloy-sol-types = { version = "1.5.2" }
+alloy-transport = { version = "1.7.3", default-features = false }
+alloy-transport-ws = { version = "1.7.3", default-features = false }
 anyhow = "1.0.100"
 app-data = { path = "crates/app-data" }
 arc-swap = "1.7.1"
diff --git a/crates/account-balances/Cargo.toml b/crates/account-balances/Cargo.toml
index 10929cc9a5..33bc1d3422 100644
--- a/crates/account-balances/Cargo.toml
+++ b/crates/account-balances/Cargo.toml
@@ -6,7 +6,11 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-contract = { workspace = true }
+alloy-dyn-abi = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 balance-overrides = { workspace = true }
diff --git a/crates/account-balances/src/cached.rs b/crates/account-balances/src/cached.rs
index 366f0db3f6..f06362a29e 100644
--- a/crates/account-balances/src/cached.rs
+++ b/crates/account-balances/src/cached.rs
@@ -1,6 +1,6 @@
 use {
     crate::{BalanceFetching, Query, TransferSimulationError},
-    alloy::primitives::U256,
+    alloy_primitives::U256,
     anyhow::Result,
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
     futures::StreamExt,
@@ -202,7 +202,7 @@ mod tests {
     use {
         super::*,
         crate::MockBalanceFetching,
-        alloy::primitives::Address,
+        alloy_primitives::Address,
         ethrpc::block_stream::BlockInfo,
         model::order::SellTokenSource,
     };
diff --git a/crates/account-balances/src/lib.rs b/crates/account-balances/src/lib.rs
index 7febfa8e3c..37dff5bc77 100644
--- a/crates/account-balances/src/lib.rs
+++ b/crates/account-balances/src/lib.rs
@@ -1,9 +1,7 @@
 use {
-    alloy::{
-        primitives::{Address, U256},
-        rpc::types::state::StateOverride,
-        sol_types::{SolCall, SolType, sol_data},
-    },
+    alloy_primitives::{Address, U256},
+    alloy_rpc_types::state::StateOverride,
+    alloy_sol_types::{SolCall, SolType, sol_data},
     balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     contracts::alloy::{GPv2Settlement, support::Balances},
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
@@ -187,7 +185,7 @@ impl BalanceSimulator {
             )>::abi_decode(&response.0)
             .map_err(|err| {
                 tracing::error!(?err, "failed to decode balance response");
-                alloy::contract::Error::AbiError(alloy::dyn_abi::Error::SolTypes(err))
+                alloy_contract::Error::AbiError(alloy_dyn_abi::Error::SolTypes(err))
             })?;
 
         let simulation = Simulation {
@@ -220,7 +218,7 @@ pub struct Simulation {
 
 #[derive(Debug)]
 pub enum SimulationError {
-    Method(alloy::contract::Error),
+    Method(alloy_contract::Error),
 }
 
 impl std::fmt::Display for SimulationError {
@@ -233,8 +231,8 @@ impl std::fmt::Display for SimulationError {
 
 impl std::error::Error for SimulationError {}
 
-impl From<alloy::contract::Error> for SimulationError {
-    fn from(err: alloy::contract::Error) -> Self {
+impl From<alloy_contract::Error> for SimulationError {
+    fn from(err: alloy_contract::Error) -> Self {
         Self::Method(err)
     }
 }
diff --git a/crates/account-balances/src/simulation.rs b/crates/account-balances/src/simulation.rs
index ebaa6c92cb..1587598e78 100644
--- a/crates/account-balances/src/simulation.rs
+++ b/crates/account-balances/src/simulation.rs
@@ -5,7 +5,7 @@
 use {
     super::{BalanceFetching, Query, TransferSimulationError},
     crate::BalanceSimulator,
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     anyhow::Result,
     contracts::alloy::{BalancerV2Vault::BalancerV2Vault, ERC20},
     ethrpc::{Web3, alloy::ProviderLabelingExt},
@@ -90,7 +90,7 @@ impl Balances {
                 )?;
                 match approved {
                     true => std::cmp::min(balance, allowance),
-                    false => alloy::primitives::U256::ZERO,
+                    false => U256::ZERO,
                 }
             }
             SellTokenSource::Internal => {
@@ -103,7 +103,7 @@ impl Balances {
                 )?;
                 match approved {
                     true => balance[0], // internal approvals are always U256::MAX
-                    false => alloy::primitives::U256::ZERO,
+                    false => U256::ZERO,
                 }
             }
         };
@@ -167,7 +167,7 @@ impl BalanceFetching for Balances {
 mod tests {
     use {
         super::*,
-        alloy::primitives::address,
+        alloy_primitives::address,
         balance_overrides::DummyOverrider,
         contracts::alloy::GPv2Settlement,
         ethrpc::Web3,
@@ -180,7 +180,7 @@ mod tests {
     async fn test_for_user() {
         let web3 = Web3::new_from_env();
         let settlement = GPv2Settlement::GPv2Settlement::new(
-            alloy::primitives::address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+            address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
             web3.provider.clone(),
         );
         let balances = contracts::alloy::support::Balances::Instance::new(
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index b24730e8f6..3cd5fc25f0 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -16,7 +16,7 @@ path = "src/main.rs"
 
 [dependencies]
 account-balances = { workspace = true }
-alloy = { workspace = true, features = ["provider-debug-api", "provider-trace-api", "rand"] }
+alloy = { workspace = true, features = ["provider-debug-api", "provider-trace-api", "rand", "signer-aws"] }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 async-trait = { workspace = true }
diff --git a/crates/bad-tokens/Cargo.toml b/crates/bad-tokens/Cargo.toml
index eb7932022a..92c50bef27 100644
--- a/crates/bad-tokens/Cargo.toml
+++ b/crates/bad-tokens/Cargo.toml
@@ -6,7 +6,12 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-json-rpc = { workspace = true }
+alloy-primitives = { workspace = true, features = ["rand"] }
+alloy-provider = { workspace = true }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
+alloy-transport = { workspace = true }
 anyhow = { workspace = true }
 contracts = { workspace = true }
 ethrpc = { workspace = true }
diff --git a/crates/bad-tokens/src/list_based.rs b/crates/bad-tokens/src/list_based.rs
index 27bd55a3c5..297e33c42c 100644
--- a/crates/bad-tokens/src/list_based.rs
+++ b/crates/bad-tokens/src/list_based.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::Address,
+    alloy_primitives::Address,
     std::{collections::HashSet, sync::Arc},
 };
 
diff --git a/crates/bad-tokens/src/trace_call.rs b/crates/bad-tokens/src/trace_call.rs
index 0ef7a7c5c6..d202f91c47 100644
--- a/crates/bad-tokens/src/trace_call.rs
+++ b/crates/bad-tokens/src/trace_call.rs
@@ -1,19 +1,14 @@
 use {
     super::TokenQuality,
-    alloy::{
-        primitives::{Address, U256, keccak256},
-        providers::ext::TraceApi,
-        rpc::{
-            json_rpc::ErrorPayload,
-            types::{
-                TransactionRequest,
-                trace::parity::{TraceOutput, TraceResults, TraceType},
-            },
-        },
-        signers::local::PrivateKeySigner,
-        sol_types::SolCall,
-        transports::{RpcError, TransportErrorKind},
+    alloy_json_rpc::ErrorPayload,
+    alloy_primitives::{Address, U256},
+    alloy_provider::ext::TraceApi,
+    alloy_rpc_types::{
+        TransactionRequest,
+        trace::parity::{TraceOutput, TraceResults, TraceType},
     },
+    alloy_sol_types::SolCall,
+    alloy_transport::{RpcError, TransportErrorKind},
     anyhow::{Context, Result, bail, ensure},
     contracts::alloy::ERC20,
     ethrpc::Web3,
@@ -93,9 +88,7 @@ impl TraceCallDetectorRaw {
     // tokens that usually apply fees but not if the the sender or receiver is
     // specifically exempt like their own uniswap pools.
     fn arbitrary_recipient() -> Address {
-        PrivateKeySigner::from_bytes(&keccak256(b"moo"))
-            .unwrap()
-            .address()
+        Address::random()
     }
 
     fn create_trace_request(
@@ -176,7 +169,7 @@ impl TraceCallDetectorRaw {
         // 7
         let calldata = ERC20::ERC20::approveCall {
             spender: recipient,
-            amount: alloy::primitives::U256::MAX,
+            amount: U256::MAX,
         }
         .abi_encode();
         requests.push(
@@ -350,15 +343,13 @@ async fn trace_many(
 mod tests {
     use {
         super::*,
-        alloy::{
-            primitives::Bytes,
-            rpc::types::trace::parity::{
-                Action,
-                CallAction,
-                CallOutput,
-                CallType,
-                TransactionTrace,
-            },
+        alloy_primitives::Bytes,
+        alloy_rpc_types::trace::parity::{
+            Action,
+            CallAction,
+            CallOutput,
+            CallType,
+            TransactionTrace,
         },
     };
 
diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
index b506e0d7a8..98b5f43b57 100644
--- a/crates/balance-overrides/Cargo.toml
+++ b/crates/balance-overrides/Cargo.toml
@@ -9,7 +9,12 @@ license = "MIT OR Apache-2.0"
 doctest = false
 
 [dependencies]
-alloy = { workspace = true, features = ["provider-debug-api", "sol-types"] }
+alloy-eips = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true, features = ["debug-api"] }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
+alloy-transport = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 cached = { workspace = true, features = ["default"] }
diff --git a/crates/balance-overrides/src/detector.rs b/crates/balance-overrides/src/detector.rs
index 46b667daa9..a7e139269b 100644
--- a/crates/balance-overrides/src/detector.rs
+++ b/crates/balance-overrides/src/detector.rs
@@ -1,17 +1,15 @@
 use {
     super::Strategy,
-    alloy::{
-        eips::BlockId,
-        primitives::{Address, B256, TxKind, U256},
-        providers::ext::DebugApi,
-        rpc::types::{
-            TransactionInput,
-            TransactionRequest,
-            trace::geth::{GethDebugTracingCallOptions, GethTrace},
-        },
-        sol_types::SolCall,
-        transports::{RpcError, TransportErrorKind},
+    alloy_eips::BlockId,
+    alloy_primitives::{Address, B256, TxKind, U256, keccak256},
+    alloy_provider::ext::DebugApi,
+    alloy_rpc_types::{
+        TransactionInput,
+        TransactionRequest,
+        trace::geth::{GethDebugTracingCallOptions, GethTrace},
     },
+    alloy_sol_types::SolCall,
+    alloy_transport::{RpcError, TransportErrorKind},
     contracts::alloy::ERC20,
     std::{
         collections::HashMap,
@@ -75,13 +73,13 @@ fn create_strategies_from_slots(
     buf[12..32].copy_from_slice(holder.as_slice());
     for i in 0..heuristic_depth {
         buf[32..64].copy_from_slice(&U256::from(i).to_be_bytes::<32>());
-        let slot_hash = alloy::primitives::keccak256(buf);
+        let slot_hash = keccak256(buf);
         solidity_mapping_slot_to_index.insert(slot_hash, i);
     }
 
     buf[0..20].copy_from_slice(holder.as_slice());
     buf[20..32].copy_from_slice(SOLADY_MAGIC_BYTES);
-    let solady_slot = alloy::primitives::keccak256(&buf[0..32]);
+    let solady_slot = keccak256(&buf[0..32]);
 
     // We separate heuristic and non-heuristic in a single pass,
     // iterating in reverse so "most recently accessed" come first.
@@ -295,7 +293,7 @@ impl Detector {
         strategy: &Strategy,
     ) -> Result<(), DetectionError<TransportErrorKind>> {
         // Use a unique test value to verify this strategy works
-        let test_balance = alloy::primitives::U256::from(0x1337_1337_1337_1337_u64);
+        let test_balance = U256::from(0x1337_1337_1337_1337_u64);
 
         // Create state override using the strategy
         let overrides = strategy.state_override(&holder, &test_balance);
@@ -345,7 +343,7 @@ pub enum DetectionError<E> {
 mod tests {
     use {
         super::*,
-        alloy::primitives::{B256, address, b256},
+        alloy_primitives::{B256, U256, address, b256},
         ethrpc::Web3,
     };
 
@@ -487,12 +485,12 @@ mod tests {
         let mut buf = [0u8; 64];
         buf[12..32].copy_from_slice(holder.as_slice());
         buf[32..64].copy_from_slice(&U256::ZERO.to_be_bytes::<32>());
-        let heuristic_slot1 = alloy::primitives::keccak256(buf);
+        let heuristic_slot1 = keccak256(buf);
         buf[32..64].copy_from_slice(&U256::from(5).to_be_bytes::<32>());
-        let heuristic_slot2 = alloy::primitives::keccak256(buf);
+        let heuristic_slot2 = keccak256(buf);
         buf[0..20].copy_from_slice(holder.as_slice());
         buf[20..32].copy_from_slice(SOLADY_MAGIC_BYTES);
-        let heuristic_slot3 = alloy::primitives::keccak256(&buf[0..32]);
+        let heuristic_slot3 = keccak256(&buf[0..32]);
 
         // Create non-heuristic slots
         let slot1 = B256::with_last_byte(0xe7);
@@ -556,7 +554,7 @@ mod tests {
         let mut buf = [0u8; 64];
         buf[12..32].copy_from_slice(holder.as_slice());
         buf[32..64].copy_from_slice(&U256::ZERO.to_be_bytes::<32>());
-        let heuristic_slot = alloy::primitives::keccak256(buf);
+        let heuristic_slot = keccak256(buf);
 
         let slots = vec![
             (contract, slot1),
diff --git a/crates/balance-overrides/src/lib.rs b/crates/balance-overrides/src/lib.rs
index 3462f18802..97dabe763f 100644
--- a/crates/balance-overrides/src/lib.rs
+++ b/crates/balance-overrides/src/lib.rs
@@ -2,10 +2,8 @@ pub mod detector;
 
 use {
     self::detector::{DetectionError, Detector},
-    alloy::{
-        primitives::{Address, B256, U256, keccak256, map::AddressMap},
-        rpc::types::state::AccountOverride,
-    },
+    alloy_primitives::{Address, B256, U256, keccak256, map::AddressMap},
+    alloy_rpc_types::state::AccountOverride,
     anyhow::Context as _,
     cached::{Cached, SizedCache},
     std::{
@@ -378,7 +376,7 @@ impl BalanceOverriding for DummyOverrider {
 mod tests {
     use {
         super::*,
-        alloy::primitives::{address, b256},
+        alloy_primitives::{address, b256},
         ethrpc::mock,
         maplit::hashmap,
     };
diff --git a/crates/contracts/Cargo.toml b/crates/contracts/Cargo.toml
index 587f83ffd0..31b2560420 100644
--- a/crates/contracts/Cargo.toml
+++ b/crates/contracts/Cargo.toml
@@ -13,14 +13,15 @@ name = "vendor"
 required-features = ["bin"]
 
 [dependencies]
-alloy = { workspace = true, features = ["contract", "json", "json-abi", "sol-types"] }
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true, features = ["json"] }
 anyhow = { workspace = true }
 paste = { workspace = true }
+reqwest = { workspace = true, features = ["blocking", "json"], optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-
-reqwest = { workspace = true, features = ["blocking", "json"], optional = true }
-# [bin-dependencies]
 tracing = { workspace = true, optional = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"], optional = true }
 
diff --git a/crates/contracts/build.rs b/crates/contracts/build.rs
index b9f470e354..1bc4994c36 100644
--- a/crates/contracts/build.rs
+++ b/crates/contracts/build.rs
@@ -995,7 +995,7 @@ impl Contract {
         let module_name_ident = format_ident!("{}", self.name);
         let instance_name_ident = format_ident!("{}Instance", self.name);
         let instance = quote::quote! {
-            pub type Instance = #module_name_ident :: #instance_name_ident<::alloy::providers::DynProvider>;
+            pub type Instance = #module_name_ident :: #instance_name_ident<::alloy_provider::DynProvider>;
         };
         expansion.extend(instance);
 
@@ -1011,10 +1011,8 @@ impl Contract {
                         collections::HashMap
                     },
                     anyhow::{Result, Context},
-                    alloy::{
-                        providers::{Provider, DynProvider},
-                        primitives::{address, Address},
-                    },
+                    alloy_provider::{Provider, DynProvider},
+                    alloy_primitives::{address, Address},
                 };
 
                 pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
@@ -1025,7 +1023,7 @@ impl Contract {
                 }
 
                 /// Returns the contract's deployment address (if one exists) for the given chain.
-                pub const fn deployment_address(chain_id: &u64) -> Option<::alloy::primitives::Address> {
+                pub const fn deployment_address(chain_id: &u64) -> Option<alloy_primitives::Address> {
                     match deployment_info(*chain_id) {
                         Some((address, _)) => Some(address),
                         None => None,
@@ -1105,13 +1103,15 @@ fn generate_binding(instance: &mut SolMacroGen, all_derives: bool) -> anyhow::Re
         SolInputKind::Sol(mut file) => {
             let sol_attr: syn::Attribute = if all_derives {
                 syn::parse_quote! {
-                        #[sol(rpc, alloy_sol_types = alloy::sol_types, alloy_contract =
-                alloy::contract, all_derives = true, extra_derives(serde::Serialize,
-                serde::Deserialize))]     }
+                    #[sol(
+                        rpc,
+                        all_derives = true,
+                        extra_derives(serde::Serialize,
+                        serde::Deserialize)
+                    )]
+                }
             } else {
-                syn::parse_quote! {
-                        #[sol(rpc, alloy_sol_types = alloy::sol_types, alloy_contract =
-                alloy::contract)]     }
+                syn::parse_quote! { #[sol(rpc)] }
             };
             file.attrs.push(sol_attr);
             expand(file)?
@@ -1147,7 +1147,7 @@ fn write_mod_name(contents: &mut String, name: &str) -> anyhow::Result<()> {
 /// quote::quote! {
 ///     pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
 ///         match chain_id {
-///             #(#chain_id => Some((::alloy::primitives::address!(#address), #block_number)),)*
+///             #(#chain_id => Some((alloy_primitives::address!(#address), #block_number)),)*
 ///             _ => None
 ///         }
 ///     }
@@ -1178,7 +1178,7 @@ impl ToTokens for NetworkArm {
             None => quote::quote! {None},
         };
         tokens.extend(quote::quote! {
-           #chain_id => Some((::alloy::primitives::address!(#address), #block_number))
+           #chain_id => Some((alloy_primitives::address!(#address), #block_number))
         });
     }
 }
diff --git a/crates/contracts/src/lib.rs b/crates/contracts/src/lib.rs
index 381bbc2b6f..01f758308e 100644
--- a/crates/contracts/src/lib.rs
+++ b/crates/contracts/src/lib.rs
@@ -3,5 +3,3 @@
 // This module get's auto-generated by the contracts build.rs
 #[rustfmt::skip]
 pub mod alloy;
-
-pub mod vault;
diff --git a/crates/contracts/src/vault.rs b/crates/contracts/src/vault.rs
deleted file mode 100644
index af5c3d8f52..0000000000
--- a/crates/contracts/src/vault.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-//! Module containing utilities for interfacing with the Balancer V2 Vault
-//! contract.
-
-use {
-    crate::alloy::BalancerV2Authorizer,
-    alloy::{primitives::Address, sol_types::SolCall},
-};
-
-fn role_id<Call: SolCall>(vault: Address) -> alloy::primitives::B256 {
-    let mut data = [0u8; 36];
-    data[12..32].copy_from_slice(vault.as_slice());
-    data[32..36].copy_from_slice(&Call::SELECTOR);
-    alloy::primitives::keccak256(data)
-}
-
-pub async fn grant_required_roles(
-    authorizer: &BalancerV2Authorizer::Instance,
-    vault: Address,
-    vault_relayer: Address,
-) -> Result<(), alloy::contract::Error> {
-    use crate::alloy::BalancerV2Vault::BalancerV2Vault::batchSwapCall;
-    use crate::alloy::BalancerV2Vault::BalancerV2Vault::manageUserBalanceCall;
-
-    authorizer
-        .grantRoles(
-            vec![
-                role_id::<manageUserBalanceCall>(vault).0.into(),
-                role_id::<batchSwapCall>(vault).0.into(),
-            ],
-            vault_relayer,
-        )
-        .send()
-        .await?
-        .watch()
-        .await?;
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use alloy::primitives::b256;
-
-    use super::*;
-    use crate::alloy::BalancerV2Vault;
-    use crate::alloy::BalancerV2Vault::BalancerV2Vault::batchSwapCall;
-    use crate::alloy::BalancerV2Vault::BalancerV2Vault::manageUserBalanceCall;
-
-    #[test]
-    fn role_ids() {
-        // These roles were generated by simulating `manageUserBalance` and
-        // `batchSwap` transactions in Tenderly and then inspecting the `role`
-        // value that was passed to the authenticator contract.
-
-        let vault = BalancerV2Vault::deployment_address(&1).unwrap();
-        assert_eq!(
-            role_id::<manageUserBalanceCall>(vault),
-            b256!("0xeba777d811cd36c06d540d7ff2ed18ed042fd67bbf7c9afcf88c818c7ee6b498")
-        );
-        assert_eq!(
-            role_id::<batchSwapCall>(vault),
-            b256!("0x1282ab709b2b70070f829c46bc36f76b32ad4989fecb2fcb09a1b3ce00bbfc30")
-        );
-    }
-}
diff --git a/crates/cow-amm/Cargo.toml b/crates/cow-amm/Cargo.toml
index bcdee4ac87..77992a730c 100644
--- a/crates/cow-amm/Cargo.toml
+++ b/crates/cow-amm/Cargo.toml
@@ -4,7 +4,11 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 async-trait = { workspace = true }
diff --git a/crates/cow-amm/src/amm.rs b/crates/cow-amm/src/amm.rs
index 9d6d8f2d91..32c2b88129 100644
--- a/crates/cow-amm/src/amm.rs
+++ b/crates/cow-amm/src/amm.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{Address, TxHash, U256},
+    alloy_primitives::{Address, TxHash, U256},
     anyhow::{Context, Result},
     app_data::AppDataHash,
     contracts::alloy::cow_amm::{
@@ -27,7 +27,7 @@ impl Amm {
     pub async fn new(
         address: Address,
         helper: &CowAmmLegacyHelper::Instance,
-    ) -> alloy::contract::Result<Self> {
+    ) -> alloy_contract::Result<Self> {
         let tradeable_tokens = helper.tokens(address).call().await?;
 
         Ok(Self {
diff --git a/crates/cow-amm/src/cache.rs b/crates/cow-amm/src/cache.rs
index 81854368d9..3b2eb064c3 100644
--- a/crates/cow-amm/src/cache.rs
+++ b/crates/cow-amm/src/cache.rs
@@ -1,6 +1,7 @@
 use {
     crate::{Amm, Metrics},
-    alloy::{primitives::Address, rpc::types::Log},
+    alloy_primitives::Address,
+    alloy_rpc_types::Log,
     anyhow::Context,
     contracts::alloy::cow_amm::{
         CowAmmLegacyHelper,
@@ -60,7 +61,7 @@ impl Storage {
         }
 
         let amm_process_tasks = db_amms.into_iter().map(|db_amm| async move {
-            let amm_address = alloy::primitives::Address::from_slice(&db_amm.address.0);
+            let amm_address = Address::from_slice(&db_amm.address.0);
             let amm = Amm::new(amm_address, &self.0.helper).await?;
             let block_number = u64::try_from(db_amm.block_number).context(format!(
                 "db stored cow amm {:?} block number is not u64",
@@ -97,7 +98,7 @@ impl Storage {
             .collect()
     }
 
-    pub(crate) async fn remove_amms(&self, amm_addresses: &[alloy::primitives::Address]) {
+    pub(crate) async fn remove_amms(&self, amm_addresses: &[Address]) {
         let mut lock = self.0.cache.write().await;
         for (_, amms) in lock.iter_mut() {
             amms.retain(|amm| !amm_addresses.contains(amm.address()))
@@ -168,7 +169,7 @@ impl EventStoring<(CowAmmEvent, Log)> for Storage {
             let cow_amm = cow_amm.amm;
             match Amm::new(cow_amm, &self.0.helper).await {
                 Ok(amm) => processed_events.push((block_number, tx_hash, Arc::new(amm))),
-                Err(err) if matches!(&err, alloy::contract::Error::TransportError(_)) => {
+                Err(err) if matches!(&err, alloy_contract::Error::TransportError(_)) => {
                     // Abort completely to later try the entire block range again.
                     // That keeps the cache in a consistent state and avoids indexing
                     // the same event multiple times which would result in duplicate amms.
diff --git a/crates/cow-amm/src/factory.rs b/crates/cow-amm/src/factory.rs
index 69873fe730..306de409b6 100644
--- a/crates/cow-amm/src/factory.rs
+++ b/crates/cow-amm/src/factory.rs
@@ -1,10 +1,8 @@
 use {
-    alloy::{
-        primitives::Address,
-        providers::DynProvider,
-        rpc::types::{Filter, FilterSet},
-        sol_types::SolEvent,
-    },
+    alloy_primitives::Address,
+    alloy_provider::DynProvider,
+    alloy_rpc_types::{Filter, FilterSet},
+    alloy_sol_types::SolEvent,
     contracts::alloy::cow_amm::CowAmmLegacyHelper::CowAmmLegacyHelper::{
         self,
         CowAmmLegacyHelperEvents as CowAmmEvent,
diff --git a/crates/cow-amm/src/lib.rs b/crates/cow-amm/src/lib.rs
index 31925d167c..f157c28009 100644
--- a/crates/cow-amm/src/lib.rs
+++ b/crates/cow-amm/src/lib.rs
@@ -32,10 +32,8 @@ impl Metrics {
 /// See: <https://github.com/cowprotocol/contracts/blob/v1.1.2/src/contracts/libraries/GPv2Order.sol#L26-L48>
 pub mod gpv2_order {
     use {
-        alloy::{
-            primitives::{B256, Keccak256},
-            sol_types::{SolStruct, SolValue},
-        },
+        alloy_primitives::{Address, B256, Keccak256},
+        alloy_sol_types::{SolStruct, SolValue},
         contracts::alloy::cow_amm::CowAmm,
         model::{DomainSeparator, interaction::InteractionData, signature::hashed_eip712_message},
     };
@@ -51,7 +49,7 @@ pub mod gpv2_order {
     /// Note the use of `string` for kind, sellTokenBalance, and buyTokenBalance
     /// instead of `bytes32`.
     const TYPE_HASH: [u8; 32] =
-        alloy::hex!("d5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e489");
+        alloy_primitives::hex!("d5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e489");
 
     /// Computes the correct EIP-712 hash for a GPv2Order.
     fn eip712_hash_struct(order: &CowAmm::GPv2Order::Data) -> B256 {
@@ -73,7 +71,7 @@ pub mod gpv2_order {
     pub fn generate_eip1271_signature(
         order: &CowAmm::GPv2Order::Data,
         trading_params: &CowAmm::ConstantProduct::TradingParams,
-        amm_address: alloy::primitives::Address,
+        amm_address: Address,
     ) -> Vec<u8> {
         // Encode the order and trading params
         let signature_data = (order.clone(), trading_params.clone()).abi_encode_sequence();
diff --git a/crates/cow-amm/src/registry.rs b/crates/cow-amm/src/registry.rs
index e80795eee0..7a1d329322 100644
--- a/crates/cow-amm/src/registry.rs
+++ b/crates/cow-amm/src/registry.rs
@@ -1,6 +1,6 @@
 use {
     crate::{Amm, cache::Storage, factory::Factory, maintainers::EmptyPoolRemoval},
-    alloy::primitives::Address,
+    alloy_primitives::Address,
     contracts::alloy::cow_amm::CowAmmLegacyHelper,
     ethrpc::{AlloyProvider, block_stream::CurrentBlockWatcher},
     event_indexing::{
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 9df0326a89..9990225c22 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -22,6 +22,7 @@ alloy = { workspace = true, features = [
   "provider-txpool-api",
   "rand",
   "rpc-types",
+  "signer-aws",
   "sol-types"
 ] }
 app-data = { workspace = true }
diff --git a/crates/e2e/src/setup/deploy.rs b/crates/e2e/src/setup/deploy.rs
index 18426b92e9..1cba658b81 100644
--- a/crates/e2e/src/setup/deploy.rs
+++ b/crates/e2e/src/setup/deploy.rs
@@ -1,7 +1,8 @@
 use {
     alloy::{
-        primitives::{Address, B256, U256},
+        primitives::{Address, B256, U256, keccak256},
         providers::Provider,
+        sol_types::SolCall,
     },
     contracts::alloy::{
         BalancerV2Authorizer,
@@ -186,7 +187,7 @@ impl Contracts {
             .await
             .unwrap();
 
-        contracts::vault::grant_required_roles(
+        grant_required_roles(
             &balancer_authorizer,
             *balancer_vault.address(),
             gp_settlement
@@ -195,8 +196,7 @@ impl Contracts {
                 .await
                 .expect("failed to retrieve Vault relayer contract address"),
         )
-        .await
-        .expect("failed to authorize Vault relayer");
+        .await;
 
         let allowance = gp_settlement
             .vaultRelayer()
@@ -263,3 +263,36 @@ impl Contracts {
         }
     }
 }
+
+fn role_id<Call: SolCall>(vault: Address) -> B256 {
+    let mut data = [0u8; 36];
+    data[12..32].copy_from_slice(vault.as_slice());
+    data[32..36].copy_from_slice(&Call::SELECTOR);
+    keccak256(data)
+}
+
+async fn grant_required_roles(
+    authorizer: &BalancerV2Authorizer::Instance,
+    vault: Address,
+    vault_relayer: Address,
+) {
+    use contracts::alloy::BalancerV2Vault::BalancerV2Vault::{
+        batchSwapCall,
+        manageUserBalanceCall,
+    };
+
+    authorizer
+        .grantRoles(
+            vec![
+                role_id::<manageUserBalanceCall>(vault).0.into(),
+                role_id::<batchSwapCall>(vault).0.into(),
+            ],
+            vault_relayer,
+        )
+        .send()
+        .await
+        .unwrap()
+        .watch()
+        .await
+        .unwrap();
+}
diff --git a/crates/ethrpc/Cargo.toml b/crates/ethrpc/Cargo.toml
index e78c0a519f..77cdf38176 100644
--- a/crates/ethrpc/Cargo.toml
+++ b/crates/ethrpc/Cargo.toml
@@ -11,25 +11,18 @@ name = "ethrpc"
 path = "src/lib.rs"
 
 [dependencies]
-alloy = { workspace = true, default-features = false, features = [
-  "reqwest-default-tls",
-  "contract",
-  "eips",
-  "json-rpc",
-  "provider-debug-api",
-  "provider-ws",
-  "providers",
-  "pubsub",
-  "reqwest",
-  "rpc-client",
-  "rpc-types",
-  "rpc-types-trace",
-  "signer-aws",
-  "signer-local",
-  "signers",
-  "transport-ws",
-  "transports"
-] }
+alloy-consensus = { workspace = true }
+alloy-contract = { workspace = true }
+alloy-eips = { workspace = true }
+alloy-json-rpc = { workspace = true }
+alloy-network = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true, features = ["ws"] }
+alloy-rpc-client = { workspace = true, features = ["reqwest"] }
+alloy-rpc-types = { workspace = true }
+alloy-signer = { workspace = true }
+alloy-transport = { workspace = true }
+alloy-transport-ws = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 const-hex = { workspace = true }
diff --git a/crates/ethrpc/src/alloy/buffering.rs b/crates/ethrpc/src/alloy/buffering.rs
index 36a697c85c..dcff520a64 100644
--- a/crates/ethrpc/src/alloy/buffering.rs
+++ b/crates/ethrpc/src/alloy/buffering.rs
@@ -12,10 +12,8 @@
 //! another channel.
 use {
     crate::Config,
-    alloy::{
-        rpc::json_rpc::{RequestPacket, Response, ResponsePacket, SerializedRequest},
-        transports::{RpcError, TransportError, TransportErrorKind},
-    },
+    alloy_json_rpc::{RequestPacket, Response, ResponsePacket, SerializedRequest},
+    alloy_transport::{RpcError, TransportError, TransportErrorKind},
     futures::{
         channel::{mpsc, oneshot},
         stream::StreamExt as _,
diff --git a/crates/ethrpc/src/alloy/errors.rs b/crates/ethrpc/src/alloy/errors.rs
index e3f917196f..a469049983 100644
--- a/crates/ethrpc/src/alloy/errors.rs
+++ b/crates/ethrpc/src/alloy/errors.rs
@@ -1,4 +1,4 @@
-use alloy::{contract::Error as ContractError, transports::RpcError};
+use {alloy_contract::Error as ContractError, alloy_transport::RpcError};
 
 /// Bubbles up node errors, ignoring all other errors.
 pub fn ignore_non_node_error<T>(result: Result<T, ContractError>) -> anyhow::Result<Option<T>> {
@@ -55,16 +55,16 @@ impl ContractErrorExt for ContractError {
 /// Create an arbitrary alloy error that will convert into a "contract" error.
 /// Useful for testing.
 #[cfg(any(test, feature = "test-util"))]
-pub fn testing_alloy_contract_error() -> alloy::contract::Error {
-    alloy::contract::Error::NotADeploymentTransaction
+pub fn testing_alloy_contract_error() -> alloy_contract::Error {
+    alloy_contract::Error::NotADeploymentTransaction
 }
 
 /// Create an arbitrary alloy error that will convert into a "node" error.
 /// Useful for testing.
 #[cfg(any(test, feature = "test-util"))]
-pub fn testing_alloy_node_error() -> alloy::contract::Error {
-    alloy::contract::Error::TransportError(alloy::transports::TransportError::ErrorResp(
-        alloy::rpc::json_rpc::ErrorPayload::internal_error(),
+pub fn testing_alloy_node_error() -> alloy_contract::Error {
+    alloy_contract::Error::TransportError(alloy_transport::TransportError::ErrorResp(
+        alloy_json_rpc::ErrorPayload::internal_error(),
     ))
 }
 
diff --git a/crates/ethrpc/src/alloy/evm_ext.rs b/crates/ethrpc/src/alloy/evm_ext.rs
index 9bdd96f5bf..e07ef24378 100644
--- a/crates/ethrpc/src/alloy/evm_ext.rs
+++ b/crates/ethrpc/src/alloy/evm_ext.rs
@@ -1,10 +1,10 @@
 //! This module contains extensions specific to `evm_` RPC calls that alloy does
 //! not provide (even though `anvil_` versions may exist).
 
-use alloy::{
-    primitives::BlockTimestamp,
-    providers::Provider,
-    transports::{RpcError, TransportErrorKind},
+use {
+    alloy_primitives::BlockTimestamp,
+    alloy_provider::Provider,
+    alloy_transport::{RpcError, TransportErrorKind},
 };
 
 /// Transport extensions based on the `evm_` namespace.
diff --git a/crates/ethrpc/src/alloy/instrumentation.rs b/crates/ethrpc/src/alloy/instrumentation.rs
index 02dbfa5eaa..f7b8879dd2 100644
--- a/crates/ethrpc/src/alloy/instrumentation.rs
+++ b/crates/ethrpc/src/alloy/instrumentation.rs
@@ -10,14 +10,10 @@
 //! [`LabelingLayer`].
 use {
     crate::{Web3, alloy::RpcClientRandomIdExt},
-    alloy::{
-        providers::{Provider, ProviderBuilder},
-        rpc::{
-            client::RpcClient,
-            json_rpc::{RequestPacket, ResponsePacket, SerializedRequest},
-        },
-        transports::TransportError,
-    },
+    alloy_json_rpc::{RequestPacket, ResponsePacket, SerializedRequest},
+    alloy_provider::{Provider, ProviderBuilder},
+    alloy_rpc_client::RpcClient,
+    alloy_transport::TransportError,
     std::{
         fmt::Debug,
         pin::Pin,
diff --git a/crates/ethrpc/src/alloy/mod.rs b/crates/ethrpc/src/alloy/mod.rs
index 1e2679bd53..f28fdd869d 100644
--- a/crates/ethrpc/src/alloy/mod.rs
+++ b/crates/ethrpc/src/alloy/mod.rs
@@ -6,10 +6,8 @@ mod wallet;
 
 use {
     crate::{AlloyProvider, Config},
-    alloy::{
-        providers::{Provider, ProviderBuilder},
-        rpc::client::{ClientBuilder, RpcClient},
-    },
+    alloy_provider::{Provider, ProviderBuilder},
+    alloy_rpc_client::{ClientBuilder, RpcClient},
     buffering::BatchCallLayer,
     instrumentation::{InstrumentationLayer, LabelingLayer},
 };
@@ -122,12 +120,10 @@ impl ProviderSignerExt for AlloyProvider {
 mod test_util {
     use {
         super::*,
-        alloy::{
-            contract::{CallBuilder, CallDecoder},
-            primitives::TxHash,
-            providers::Network,
-            rpc::types::TransactionRequest,
-        },
+        alloy_contract::{CallBuilder, CallDecoder},
+        alloy_primitives::TxHash,
+        alloy_provider::Network,
+        alloy_rpc_types::TransactionRequest,
         std::time::Duration,
         tokio::time::timeout,
     };
@@ -171,6 +167,6 @@ mod test_util {
     }
 }
 
-use alloy::{rpc::client::RpcClientInner, transports::IntoBoxTransport};
 #[cfg(feature = "test-util")]
 pub use test_util::{CallBuilderExt, ProviderExt};
+use {alloy_rpc_client::RpcClientInner, alloy_transport::IntoBoxTransport};
diff --git a/crates/ethrpc/src/alloy/wallet.rs b/crates/ethrpc/src/alloy/wallet.rs
index 69ee7a6d0c..054b55cb6e 100644
--- a/crates/ethrpc/src/alloy/wallet.rs
+++ b/crates/ethrpc/src/alloy/wallet.rs
@@ -1,11 +1,9 @@
 use {
-    alloy::{
-        consensus::{TxEnvelope, TypedTransaction},
-        network::{Ethereum, EthereumWallet, Network, NetworkWallet, TxSigner},
-        primitives::Address,
-        signers::Signature,
-        transports::impl_future,
-    },
+    alloy_consensus::{TxEnvelope, TypedTransaction},
+    alloy_network::{Ethereum, EthereumWallet, Network, NetworkWallet, TxSigner},
+    alloy_primitives::Address,
+    alloy_signer::Signature,
+    alloy_transport::impl_future,
     std::{sync::Arc, thread},
     tokio::sync::RwLock,
 };
@@ -126,7 +124,7 @@ where
         &self,
         sender: Address,
         tx: N::UnsignedTx,
-    ) -> impl_future!(<Output = alloy::signers::Result<N::TxEnvelope>>) {
+    ) -> impl_future!(<Output = alloy_signer::Result<N::TxEnvelope>>) {
         async move {
             let r_lock = self.0.read().await;
             <EthereumWallet as NetworkWallet<N>>::sign_transaction_from(&r_lock, sender, tx).await
diff --git a/crates/ethrpc/src/block_stream.rs b/crates/ethrpc/src/block_stream.rs
index 077023a666..f515bd2bb3 100644
--- a/crates/ethrpc/src/block_stream.rs
+++ b/crates/ethrpc/src/block_stream.rs
@@ -1,12 +1,10 @@
 use {
     crate::AlloyProvider,
-    alloy::{
-        eips::{BlockId, BlockNumberOrTag},
-        primitives::{B256, U256},
-        providers::{Provider, ProviderBuilder},
-        rpc::types::Block,
-        transports::ws::WsConnect,
-    },
+    alloy_eips::{BlockId, BlockNumberOrTag},
+    alloy_primitives::{B256, U256},
+    alloy_provider::{Provider, ProviderBuilder},
+    alloy_rpc_types::Block,
+    alloy_transport_ws::WsConnect,
     anyhow::{Context as _, Result, anyhow},
     futures::StreamExt,
     std::{
@@ -69,10 +67,10 @@ impl TryFrom<Block> for BlockInfo {
     }
 }
 
-impl TryFrom<alloy::rpc::types::Header> for BlockInfo {
+impl TryFrom<alloy_rpc_types::Header> for BlockInfo {
     type Error = anyhow::Error;
 
-    fn try_from(value: alloy::rpc::types::Header) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: alloy_rpc_types::Header) -> std::result::Result<Self, Self::Error> {
         Ok(Self {
             number: value.number,
             hash: value.hash,
diff --git a/crates/ethrpc/src/lib.rs b/crates/ethrpc/src/lib.rs
index c11eac9386..ab78b684a5 100644
--- a/crates/ethrpc/src/lib.rs
+++ b/crates/ethrpc/src/lib.rs
@@ -3,7 +3,7 @@ pub mod block_stream;
 #[cfg(any(test, feature = "test-util"))]
 pub mod mock;
 
-use {crate::alloy::MutWallet, ::alloy::providers::DynProvider, reqwest::Url, std::time::Duration};
+use {crate::alloy::MutWallet, alloy_provider::DynProvider, reqwest::Url, std::time::Duration};
 
 pub const MAX_BATCH_SIZE: usize = 100;
 
diff --git a/crates/ethrpc/src/mock.rs b/crates/ethrpc/src/mock.rs
index 53dd3aeb3f..82d381b7c7 100644
--- a/crates/ethrpc/src/mock.rs
+++ b/crates/ethrpc/src/mock.rs
@@ -2,7 +2,7 @@
 
 use {
     crate::{Web3, alloy::MutWallet},
-    alloy::providers::{Provider, ProviderBuilder, mock::Asserter},
+    alloy_provider::{Provider, ProviderBuilder, mock::Asserter},
 };
 
 impl Web3 {
diff --git a/crates/event-indexing/Cargo.toml b/crates/event-indexing/Cargo.toml
index 1e0c703330..a847906d9e 100644
--- a/crates/event-indexing/Cargo.toml
+++ b/crates/event-indexing/Cargo.toml
@@ -6,7 +6,11 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-eips = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
 anyhow = { workspace = true }
 async-stream = { workspace = true }
 async-trait = { workspace = true }
@@ -20,6 +24,7 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
+alloy-provider = { workspace = true }
 contracts = { workspace = true }
 mockall = { workspace = true }
 tracing-subscriber = { workspace = true }
diff --git a/crates/event-indexing/src/block_retriever.rs b/crates/event-indexing/src/block_retriever.rs
index c4a5881c6c..77c4fddf13 100644
--- a/crates/event-indexing/src/block_retriever.rs
+++ b/crates/event-indexing/src/block_retriever.rs
@@ -1,10 +1,8 @@
 use {
-    alloy::{
-        eips::{BlockId, BlockNumberOrTag},
-        primitives::B256,
-        providers::Provider,
-        rpc::types::Block,
-    },
+    alloy_eips::{BlockId, BlockNumberOrTag},
+    alloy_primitives::B256,
+    alloy_provider::Provider,
+    alloy_rpc_types::Block,
     anyhow::{Context, Result, anyhow, ensure},
     ethrpc::{
         AlloyProvider,
diff --git a/crates/event-indexing/src/event_handler.rs b/crates/event-indexing/src/event_handler.rs
index 7e64d20bc4..54841fcaa8 100644
--- a/crates/event-indexing/src/event_handler.rs
+++ b/crates/event-indexing/src/event_handler.rs
@@ -3,12 +3,10 @@ use {
         block_retriever::{BlockRetrieving, RangeInclusive},
         maintenance::Maintaining,
     },
-    alloy::{
-        primitives::{Address, B256},
-        providers::{DynProvider, Provider},
-        rpc::types::{Filter, Log},
-        sol_types::SolEventInterface,
-    },
+    alloy_primitives::{Address, B256},
+    alloy_provider::{DynProvider, Provider},
+    alloy_rpc_types::{Filter, Log},
+    alloy_sol_types::SolEventInterface,
     anyhow::{Context, Result},
     ethrpc::block_stream::BlockNumberHash,
     futures::{Stream, StreamExt},
@@ -684,7 +682,8 @@ fn track_block_range(range: &str) {
 mod tests {
     use {
         super::*,
-        alloy::{eips::BlockNumberOrTag, primitives::b256},
+        alloy_eips::BlockNumberOrTag,
+        alloy_primitives::b256,
         contracts::alloy::GPv2Settlement,
         ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
     };
@@ -692,28 +691,28 @@ mod tests {
     impl AlloyEventRetrieving for GPv2Settlement::Instance {
         type Event = GPv2Settlement::GPv2Settlement::GPv2SettlementEvents;
 
-        fn filter(&self) -> alloy::rpc::types::Filter {
+        fn filter(&self) -> alloy_rpc_types::Filter {
             Filter::new().address(*self.address())
         }
 
-        fn provider(&self) -> &alloy::providers::DynProvider {
+        fn provider(&self) -> &alloy_provider::DynProvider {
             self.provider()
         }
     }
 
     /// Simple event storage for testing purposes of EventHandler
     struct EventStorage<T> {
-        pub events: Vec<(T, alloy::rpc::types::Log)>,
+        pub events: Vec<(T, alloy_rpc_types::Log)>,
     }
 
     #[async_trait::async_trait]
-    impl<T> EventStoring<(T, alloy::rpc::types::Log)> for EventStorage<T>
+    impl<T> EventStoring<(T, alloy_rpc_types::Log)> for EventStorage<T>
     where
         T: Send + Sync,
     {
         async fn replace_events(
             &mut self,
-            events: Vec<(T, alloy::rpc::types::Log)>,
+            events: Vec<(T, alloy_rpc_types::Log)>,
             range: RangeInclusive<u64>,
         ) -> Result<()> {
             self.events
@@ -722,7 +721,7 @@ mod tests {
             Ok(())
         }
 
-        async fn append_events(&mut self, events: Vec<(T, alloy::rpc::types::Log)>) -> Result<()> {
+        async fn append_events(&mut self, events: Vec<(T, alloy_rpc_types::Log)>) -> Result<()> {
             self.events.extend(events);
             Ok(())
         }
@@ -957,7 +956,7 @@ mod tests {
         // disregard them.
         let remove_events_after_test_start = |v: Vec<(
             GPv2Settlement::GPv2Settlement::GPv2SettlementEvents,
-            alloy::rpc::types::Log,
+            alloy_rpc_types::Log,
         )>| {
             v.into_iter()
                 .filter(|(_, log)| {
diff --git a/crates/gas-price-estimation/Cargo.toml b/crates/gas-price-estimation/Cargo.toml
index a152283108..1124669153 100644
--- a/crates/gas-price-estimation/Cargo.toml
+++ b/crates/gas-price-estimation/Cargo.toml
@@ -6,7 +6,8 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-eips = { workspace = true }
+alloy-provider = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 ethrpc = { workspace = true }
diff --git a/crates/gas-price-estimation/src/configurable_alloy.rs b/crates/gas-price-estimation/src/configurable_alloy.rs
index 69bd3877e5..7136247035 100644
--- a/crates/gas-price-estimation/src/configurable_alloy.rs
+++ b/crates/gas-price-estimation/src/configurable_alloy.rs
@@ -7,10 +7,8 @@
 
 use {
     crate::GasPriceEstimating,
-    alloy::{
-        eips::{BlockId, BlockNumberOrTag, eip1559::Eip1559Estimation},
-        providers::{Provider, utils::eip1559_default_estimator},
-    },
+    alloy_eips::{BlockId, BlockNumberOrTag, eip1559::Eip1559Estimation},
+    alloy_provider::{Provider, utils::eip1559_default_estimator},
     anyhow::{Context, Result},
     ethrpc::AlloyProvider,
     tracing::instrument,
diff --git a/crates/gas-price-estimation/src/driver.rs b/crates/gas-price-estimation/src/driver.rs
index a2002b9a31..c470150a58 100644
--- a/crates/gas-price-estimation/src/driver.rs
+++ b/crates/gas-price-estimation/src/driver.rs
@@ -1,9 +1,7 @@
 use {
     crate::GasPriceEstimating,
-    alloy::{
-        eips::{BlockId, eip1559::Eip1559Estimation},
-        providers::{DynProvider, Provider},
-    },
+    alloy_eips::{BlockId, eip1559::Eip1559Estimation},
+    alloy_provider::{DynProvider, Provider},
     anyhow::{Context, Result, anyhow},
     reqwest::Url,
     std::{
diff --git a/crates/gas-price-estimation/src/eth_node.rs b/crates/gas-price-estimation/src/eth_node.rs
index ff1e4cd780..9fd26c2078 100644
--- a/crates/gas-price-estimation/src/eth_node.rs
+++ b/crates/gas-price-estimation/src/eth_node.rs
@@ -5,10 +5,8 @@
 
 use {
     crate::GasPriceEstimating,
-    alloy::{
-        eips::{BlockId, eip1559::Eip1559Estimation},
-        providers::Provider,
-    },
+    alloy_eips::{BlockId, eip1559::Eip1559Estimation},
+    alloy_provider::Provider,
     anyhow::{Context, Result, anyhow},
     ethrpc::AlloyProvider,
 };
diff --git a/crates/gas-price-estimation/src/fake.rs b/crates/gas-price-estimation/src/fake.rs
index f93b03bdc2..d4382e89fd 100644
--- a/crates/gas-price-estimation/src/fake.rs
+++ b/crates/gas-price-estimation/src/fake.rs
@@ -1,4 +1,4 @@
-use {crate::GasPriceEstimating, alloy::eips::eip1559::Eip1559Estimation, anyhow::Result};
+use {crate::GasPriceEstimating, alloy_eips::eip1559::Eip1559Estimation, anyhow::Result};
 
 pub struct FakeGasPriceEstimator(pub Eip1559Estimation);
 
diff --git a/crates/gas-price-estimation/src/gas_price.rs b/crates/gas-price-estimation/src/gas_price.rs
index 3fb18a20f1..fb8da8b5a6 100644
--- a/crates/gas-price-estimation/src/gas_price.rs
+++ b/crates/gas-price-estimation/src/gas_price.rs
@@ -6,7 +6,7 @@
 
 use {
     crate::GasPriceEstimating,
-    alloy::eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
+    alloy_eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
     anyhow::Result,
 };
 
diff --git a/crates/gas-price-estimation/src/lib.rs b/crates/gas-price-estimation/src/lib.rs
index 81c8d5bdd3..40cbb58b39 100644
--- a/crates/gas-price-estimation/src/lib.rs
+++ b/crates/gas-price-estimation/src/lib.rs
@@ -16,10 +16,8 @@ use {
         eth_node::NodeGasPriceEstimator,
         priority::PriorityGasPriceEstimating,
     },
-    ::alloy::{
-        eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
-        providers::Provider,
-    },
+    alloy_eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
+    alloy_provider::Provider,
     anyhow::Result,
     ethrpc::Web3,
     std::str::FromStr,
diff --git a/crates/gas-price-estimation/src/priority.rs b/crates/gas-price-estimation/src/priority.rs
index d9b89c87dc..9df8664dca 100644
--- a/crates/gas-price-estimation/src/priority.rs
+++ b/crates/gas-price-estimation/src/priority.rs
@@ -1,6 +1,6 @@
 use {
     crate::GasPriceEstimating,
-    alloy::eips::eip1559::Eip1559Estimation,
+    alloy_eips::eip1559::Eip1559Estimation,
     anyhow::{Result, anyhow},
     std::{
         future::Future,
@@ -76,7 +76,7 @@ impl GasPriceEstimating for PriorityGasPriceEstimating {
 mod tests {
     use {
         crate::{GasPriceEstimating, MockGasPriceEstimating, priority::PriorityGasPriceEstimating},
-        alloy::eips::eip1559::Eip1559Estimation,
+        alloy_eips::eip1559::Eip1559Estimation,
         anyhow::anyhow,
         futures::future::FutureExt,
     };
diff --git a/crates/liquidity-sources/Cargo.toml b/crates/liquidity-sources/Cargo.toml
index ce39c4990c..90c3aa951a 100644
--- a/crates/liquidity-sources/Cargo.toml
+++ b/crates/liquidity-sources/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy = { workspace = true, features = ["contract"] }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 bytes-hex = { workspace = true }
diff --git a/crates/signature-validator/Cargo.toml b/crates/signature-validator/Cargo.toml
index f2cdc623ee..629c3885d4 100644
--- a/crates/signature-validator/Cargo.toml
+++ b/crates/signature-validator/Cargo.toml
@@ -6,7 +6,12 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy-contract = { workspace = true }
+alloy-dyn-abi = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
+alloy-transport = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 balance-overrides = { workspace = true }
diff --git a/crates/signature-validator/src/lib.rs b/crates/signature-validator/src/lib.rs
index b1f5a5c0f1..69d5c01eb7 100644
--- a/crates/signature-validator/src/lib.rs
+++ b/crates/signature-validator/src/lib.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{Address, FixedBytes},
+    alloy_primitives::{Address, FixedBytes},
     balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     contracts::alloy::GPv2Settlement,
     ethrpc::Web3,
diff --git a/crates/signature-validator/src/simulation.rs b/crates/signature-validator/src/simulation.rs
index 20613dccb6..3a99a25efa 100644
--- a/crates/signature-validator/src/simulation.rs
+++ b/crates/signature-validator/src/simulation.rs
@@ -5,13 +5,11 @@
 
 use {
     super::{SignatureCheck, SignatureValidating, SignatureValidationError},
-    alloy::{
-        dyn_abi::SolType,
-        primitives::{Address, U256},
-        rpc::types::state::StateOverride,
-        sol_types::{SolCall, sol_data},
-        transports::RpcError,
-    },
+    alloy_dyn_abi::SolType,
+    alloy_primitives::{Address, U256},
+    alloy_rpc_types::state::StateOverride,
+    alloy_sol_types::{SolCall, sol_data},
+    alloy_transport::RpcError,
     anyhow::{Context, Result},
     balance_overrides::BalanceOverriding,
     contracts::alloy::{
@@ -70,7 +68,7 @@ impl Validator {
             .await
             .map(|value| const_hex::encode(value.0))
             .map_err(|err| match err {
-                alloy::contract::Error::TransportError(RpcError::ErrorResp(err)) => {
+                alloy_contract::Error::TransportError(RpcError::ErrorResp(err)) => {
                     tracing::error!(?err, "failed to call isValidSignature");
                     SignatureValidationError::Invalid
                 }
diff --git a/crates/solvers-dto/Cargo.toml b/crates/solvers-dto/Cargo.toml
index cff3154b4b..b9febd9f94 100644
--- a/crates/solvers-dto/Cargo.toml
+++ b/crates/solvers-dto/Cargo.toml
@@ -6,7 +6,8 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true, features = ["rpc"] }
+alloy-primitives = { workspace = true }
+alloy-rpc-types = { workspace = true }
 app-data = { workspace = true }
 bigdecimal = { workspace = true, features = ["serde"] }
 bytes-hex = { workspace = true }  # may get marked as unused but it's used with serde
diff --git a/crates/solvers-dto/src/auction.rs b/crates/solvers-dto/src/auction.rs
index f0d244de8d..632ce71b6c 100644
--- a/crates/solvers-dto/src/auction.rs
+++ b/crates/solvers-dto/src/auction.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{Address, B256, U256},
+    alloy_primitives::{Address, B256, U256},
     app_data::AppDataHash,
     bigdecimal::BigDecimal,
     number::serialization::HexOrDecimalU256,
diff --git a/crates/solvers-dto/src/notification.rs b/crates/solvers-dto/src/notification.rs
index 2a12552b61..43e5bdf16e 100644
--- a/crates/solvers-dto/src/notification.rs
+++ b/crates/solvers-dto/src/notification.rs
@@ -1,8 +1,6 @@
 use {
-    alloy::{
-        primitives::{Address, B256, U256},
-        rpc::types::AccessList,
-    },
+    alloy_primitives::{Address, B256, U256},
+    alloy_rpc_types::AccessList,
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::{DisplayFromStr, serde_as},
diff --git a/crates/solvers-dto/src/solution.rs b/crates/solvers-dto/src/solution.rs
index 0f457cd424..b5ef27439a 100644
--- a/crates/solvers-dto/src/solution.rs
+++ b/crates/solvers-dto/src/solution.rs
@@ -1,5 +1,5 @@
 use {
-    alloy::primitives::{Address, U256},
+    alloy_primitives::{Address, U256},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,

From bbfa48f35d748f3031dd1a19b335efba3134d4b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 5 Mar 2026 12:28:55 +0000
Subject: [PATCH 126/219] Migrate the database shared configuration to a file
 (#4218)

# Description
This PR moves the DB CLI arguments to a configuration file.
Additionally, this PR introduces the configs/ crate to ease mix and
matching parts of the config and to have one more "compilation caching"
place, to reduce the size of the shared crate.

# Changes

* Create configs/ crate
* Migrate & unify the db arguments from shared, orderbook and autopilot
in configs/database

# Migration Guide

Database connection settings move from CLI args to the TOML config file
(`[database]` section) for both autopilot and orderbook.

## CLI args -> TOML

| CLI arg / env var | TOML replacement (`[database]`) |
|---|---|
| `--db-write-url` / `DB_WRITE_URL` | `write-url` |
| `--db-read-url` / `DB_READ_URL` (orderbook) | `read-url` |
| `--db-max-connections` / `DB_MAX_CONNECTIONS` | `max-connections` |
| `--insert-batch-size` / `INSERT_BATCH_SIZE` (autopilot) |
`insert-batch-size` |

Keeping removed args in your startup command will cause an error.

## TOML example

```toml
[database]
write-url = "postgresql://user:password@host:5432/dbname"
read-url = "postgresql://readonly:password@replica:5432/dbname"  # orderbook only, optional
max-connections = 10
insert-batch-size = 500  # autopilot only
```

All fields have defaults matching the old CLI defaults (`write-url =
"postgresql://"`, `max-connections = 10`, `insert-batch-size = 500`,
`read-url` falls back to `write-url`). Omitting `[database]` entirely
preserves previous behavior.

## How to test
E2E tests + staging

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 Cargo.lock                                    |  14 ++
 Cargo.toml                                    |   1 +
 crates/autopilot/Cargo.toml                   |   4 +-
 crates/autopilot/src/arguments.rs             |  24 +--
 crates/autopilot/src/config/mod.rs            |  20 ++-
 crates/autopilot/src/run.rs                   |   6 +-
 crates/configs/Cargo.toml                     |  19 ++
 crates/configs/src/database.rs                | 102 +++++++++++
 crates/configs/src/deserialize_env.rs         | 169 ++++++++++++++++++
 crates/configs/src/lib.rs                     |  18 ++
 crates/e2e/Cargo.toml                         |   1 +
 crates/e2e/src/setup/services.rs              |   9 +-
 crates/e2e/tests/e2e/autopilot_leader.rs      |   1 +
 crates/e2e/tests/e2e/buffers.rs               |   1 +
 crates/e2e/tests/e2e/cors.rs                  |   1 +
 crates/e2e/tests/e2e/cow_amm.rs               |   1 +
 crates/e2e/tests/e2e/jit_orders.rs            |   1 +
 crates/e2e/tests/e2e/limit_orders.rs          |   1 +
 crates/e2e/tests/e2e/liquidity.rs             |   1 +
 .../e2e/liquidity_source_notification.rs      |   1 +
 crates/e2e/tests/e2e/malformed_requests.rs    |   1 +
 crates/e2e/tests/e2e/order_cancellation.rs    |   1 +
 .../e2e/tests/e2e/place_order_with_quote.rs   |   1 +
 crates/e2e/tests/e2e/protocol_fee.rs          |   1 +
 crates/e2e/tests/e2e/quote_verification.rs    |   1 +
 crates/e2e/tests/e2e/quoting.rs               |   1 +
 crates/e2e/tests/e2e/replace_order.rs         |   1 +
 crates/e2e/tests/e2e/smart_contract_orders.rs |   1 +
 crates/e2e/tests/e2e/solver_competition.rs    |   1 +
 crates/e2e/tests/e2e/submission.rs            |   1 +
 crates/orderbook/Cargo.toml                   |   2 +
 crates/orderbook/src/arguments.rs             |  23 +--
 crates/orderbook/src/config/mod.rs            |  92 ++++++----
 crates/orderbook/src/run.rs                   |   8 +-
 34 files changed, 431 insertions(+), 99 deletions(-)
 create mode 100644 crates/configs/Cargo.toml
 create mode 100644 crates/configs/src/database.rs
 create mode 100644 crates/configs/src/deserialize_env.rs
 create mode 100644 crates/configs/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index ac5b4aacc5..a1dcdac38a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1217,6 +1217,7 @@ dependencies = [
  "chain",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "cow-amm",
@@ -2364,6 +2365,17 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "configs"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "console-api"
 version = "0.7.0"
@@ -3027,6 +3039,7 @@ dependencies = [
  "bigdecimal",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "cow-amm",
@@ -5077,6 +5090,7 @@ dependencies = [
  "chain",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "database",
diff --git a/Cargo.toml b/Cargo.toml
index 88a811deb8..3139af15c1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,6 +42,7 @@ cached = { version = "0.49.3", default-features = false }
 chain = { path = "crates/chain" }
 chrono = { version = "0.4.38", default-features = false }
 clap = { version = "4.5.6", features = ["derive", "env"] }
+configs = { path = "crates/configs/" }
 console-subscriber = "0.3.0"
 const_format = "0.2.32"
 const-hex = "1.17.0"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 3cd5fc25f0..a90519489c 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -29,6 +29,7 @@ bytes-hex = { workspace = true }  # may get marked as unused but it's used with
 chain = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
+configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 cow-amm = { workspace = true }
@@ -77,6 +78,7 @@ url = { workspace = true, features = ["serde"] }
 winner-selection = { workspace = true }
 
 [dev-dependencies]
+configs = { workspace = true, features = ["test-util"] }
 maplit = { workspace = true }
 mockall = { workspace = true }
 shared = { workspace = true, features = ["test-util"] }
@@ -89,7 +91,7 @@ vergen = { workspace = true, features = ["git", "gitcl"] }
 
 [features]
 mimalloc-allocator = ["dep:mimalloc"]
-test-util = ["dep:tempfile", "price-estimation/test-util"]
+test-util = ["configs/test-util", "dep:tempfile", "price-estimation/test-util"]
 tokio-console = ["observe/tokio-console"]
 
 [lints]
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index a429dc4500..a5103885c1 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -1,11 +1,7 @@
 use {
-    crate::database::INSERT_BATCH_SIZE_DEFAULT,
     alloy::primitives::Address,
     anyhow::Context,
-    shared::{
-        arguments::{display_option, display_secret_option},
-        http_client,
-    },
+    shared::{arguments::display_option, http_client},
     std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf, str::FromStr, time::Duration},
     url::Url,
 };
@@ -27,9 +23,6 @@ pub struct CliArguments {
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
-    #[clap(flatten)]
-    pub database_pool: shared::arguments::DatabasePoolConfig,
-
     /// Address of the ethflow contracts. If not specified, eth-flow orders are
     /// disabled.
     /// In general, one contract is sufficient for the service to function.
@@ -51,15 +44,6 @@ pub struct CliArguments {
     #[clap(long, env, default_value = "0.0.0.0:12088")]
     pub api_address: SocketAddr,
 
-    /// Url of the Postgres database. By default connects to locally running
-    /// postgres.
-    #[clap(long, env, default_value = "postgresql://")]
-    pub db_write_url: Url,
-
-    /// The number of order events to insert in a single batch.
-    #[clap(long, env, default_value_t = INSERT_BATCH_SIZE_DEFAULT)]
-    pub insert_batch_size: NonZeroUsize,
-
     /// Skip syncing past events (useful for local deployments)
     #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
     pub skip_event_sync: bool,
@@ -189,7 +173,6 @@ impl std::fmt::Display for CliArguments {
             order_quoting,
             http_client,
             price_estimation,
-            database_pool,
             ethflow_contracts,
             ethflow_indexing_start,
             metrics_address,
@@ -201,8 +184,6 @@ impl std::fmt::Display for CliArguments {
             submission_deadline,
             shadow,
             solve_deadline,
-            db_write_url,
-            insert_batch_size,
             max_settlement_transaction_wait,
             cow_amm_configs,
             max_run_loop_delay,
@@ -220,12 +201,10 @@ impl std::fmt::Display for CliArguments {
         write!(f, "{order_quoting}")?;
         write!(f, "{http_client}")?;
         write!(f, "{price_estimation}")?;
-        write!(f, "{database_pool}")?;
         writeln!(f, "ethflow_contracts: {ethflow_contracts:?}")?;
         writeln!(f, "ethflow_indexing_start: {ethflow_indexing_start:?}")?;
         writeln!(f, "metrics_address: {metrics_address}")?;
         writeln!(f, "api_address: {api_address}")?;
-        display_secret_option(f, "db_write_url", Some(&db_write_url))?;
         writeln!(f, "skip_event_sync: {skip_event_sync}")?;
         writeln!(f, "unsupported_tokens: {unsupported_tokens:?}")?;
         writeln!(
@@ -236,7 +215,6 @@ impl std::fmt::Display for CliArguments {
         writeln!(f, "submission_deadline: {submission_deadline}")?;
         display_option(f, "shadow", shadow)?;
         writeln!(f, "solve_deadline: {solve_deadline:?}")?;
-        writeln!(f, "insert_batch_size: {insert_batch_size}")?;
         writeln!(
             f,
             "max_settlement_transaction_wait: {max_settlement_transaction_wait:?}"
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index ff3282c830..a96a51ceb7 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -9,7 +9,8 @@ use {
         trusted_tokens::TrustedTokensConfig,
     },
     anyhow::{anyhow, ensure},
-    serde::{Deserialize, Serialize},
+    configs::database::DatabasePoolConfig,
+    serde::Deserialize,
     std::path::Path,
 };
 
@@ -24,7 +25,8 @@ pub mod trusted_tokens;
 // Does not implement Default because `native_price_estimation` *cannot* have
 // empty `estimators`, as such, we cannot provide a proper default value for
 // this structure.
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 // NOTE: cannot add deny_unknown_fields during the config migration
 // as new ones get added in the config will fail parsing if extra fields are present
 #[serde(rename_all = "kebab-case", /* deny_unknown_fields */)]
@@ -52,6 +54,9 @@ pub struct Configuration {
     pub s3: Option<S3Config>,
 
     pub native_price_estimation: NativePriceConfig,
+
+    #[serde(default)]
+    pub database: DatabasePoolConfig,
 }
 
 impl Configuration {
@@ -70,10 +75,6 @@ impl Configuration {
         }
     }
 
-    pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
-        Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
-    }
-
     // Note for reviewers: if this and other validations are always applied,
     // we should instead move them to the deserialization stage
     // https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
@@ -92,6 +93,8 @@ impl Configuration {
     /// It is rather useful for tests where drivers are setup separately or not
     /// actually used (like the `order_cancellation` test).
     pub fn test_no_drivers() -> Self {
+        use configs::test_util::TestDefault;
+
         Self {
             drivers: vec![],
             fee_policies: Default::default(),
@@ -100,10 +103,13 @@ impl Configuration {
             banned_users: Default::default(),
             s3: Default::default(),
             native_price_estimation: NativePriceConfig::test_default(),
+            database: DatabasePoolConfig::test_default(),
         }
     }
 
     pub fn test(name: &str, solver_address: alloy::primitives::Address) -> Self {
+        use configs::test_util::TestDefault;
+
         Self {
             drivers: vec![Solver::test(name, solver_address)],
             fee_policies: Default::default(),
@@ -112,11 +118,13 @@ impl Configuration {
             banned_users: Default::default(),
             s3: Default::default(),
             native_price_estimation: NativePriceConfig::test_default(),
+            database: DatabasePoolConfig::test_default(),
         }
     }
 
     pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
         use std::io::Write;
+
         let mut file = tempfile::NamedTempFile::new().expect("temp file creation should not fail");
         file.write_all(
             toml::to_string_pretty(self)
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index d824bb03a1..3f8a43c838 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -166,10 +166,10 @@ pub async fn run(
 ) {
     assert!(args.shadow.is_none(), "cannot run in shadow mode");
     let db_write = Postgres::new(
-        args.db_write_url.as_str(),
+        config.database.write_url.as_str(),
         crate::database::Config {
-            insert_batch_size: args.insert_batch_size,
-            max_pool_size: args.database_pool.db_max_connections,
+            insert_batch_size: config.database.insert_batch_size,
+            max_pool_size: config.database.max_connections,
         },
     )
     .await
diff --git a/crates/configs/Cargo.toml b/crates/configs/Cargo.toml
new file mode 100644
index 0000000000..85f959e725
--- /dev/null
+++ b/crates/configs/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "configs"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+serde = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+url = { workspace = true, features = ["serde"] }
+
+[dev-dependencies]
+serde_json = { workspace = true }
+
+[features]
+test-util = []
+
+[lints]
+workspace = true
diff --git a/crates/configs/src/database.rs b/crates/configs/src/database.rs
new file mode 100644
index 0000000000..424125c3cf
--- /dev/null
+++ b/crates/configs/src/database.rs
@@ -0,0 +1,102 @@
+use {
+    std::{
+        fmt::Debug,
+        num::{NonZeroU32, NonZeroUsize},
+        str::FromStr,
+    },
+    url::Url,
+};
+
+const fn default_db_max_connections() -> NonZeroU32 {
+    // Matches SQLx default connection pool size.
+    NonZeroU32::new(10).expect("value should be greater than 0")
+}
+
+fn default_db_write_url() -> Url {
+    Url::from_str("postgresql://").expect("url should be valid")
+}
+
+const fn default_insert_batch_size() -> NonZeroUsize {
+    NonZeroUsize::new(500).expect("value should be greater than 0")
+}
+
+#[derive(serde::Deserialize)]
+#[cfg_attr(feature = "test-util", derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct DatabasePoolConfig {
+    /// Url of the Postgres database. By default connects to `postgresql://`.
+    /// Supports reading from an environment variable by prefixing the
+    /// environment variable name with '%', for example — `%DB_WRITE_URL` —
+    /// will read the environment variable named `DB_WRITE_URL`.
+    #[serde(
+        default = "default_db_write_url",
+        deserialize_with = "crate::deserialize_env::deserialize_url_from_env"
+    )]
+    pub write_url: Url,
+
+    /// Url of the Postgres database replica. If not provided, the URL from
+    /// `write_url` will be used. Supports reading from an environment
+    /// variable by prefixing the environment variable name with '%',
+    /// for example — `%DB_READ_URL` — will read the environment variable named
+    /// `DB_READ_URL`.
+    #[serde(
+        default,
+        deserialize_with = "crate::deserialize_env::deserialize_optional_url_from_env"
+    )]
+    pub read_url: Option<Url>,
+
+    /// Maximum number of connections in the database connection pool.
+    #[serde(default = "default_db_max_connections")]
+    pub max_connections: NonZeroU32,
+
+    /// The number of order events to insert in a single batch.
+    #[serde(default = "default_insert_batch_size")]
+    pub insert_batch_size: NonZeroUsize,
+}
+
+impl Default for DatabasePoolConfig {
+    fn default() -> Self {
+        Self {
+            write_url: default_db_write_url(),
+            read_url: Default::default(),
+            max_connections: default_db_max_connections(),
+            insert_batch_size: default_insert_batch_size(),
+        }
+    }
+}
+
+impl Debug for DatabasePoolConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DatabasePoolConfig")
+            .field("write_url", &"REDACTED")
+            .field("read_url", &"REDACTED")
+            .field("max_connections", &self.max_connections)
+            .field("insert_batch_size", &self.insert_batch_size)
+            .finish()
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+pub mod test_util {
+    use {
+        crate::{database::DatabasePoolConfig, test_util::TestDefault},
+        std::str::FromStr,
+        url::Url,
+    };
+
+    impl TestDefault for DatabasePoolConfig {
+        fn test_default() -> Self {
+            Self {
+                write_url: Url::from_str("postgresql://").unwrap(),
+                read_url: Some(
+                    Url::from_str(&format!(
+                        "postgresql://readonly@localhost/{db}",
+                        db = std::env::var("USER").unwrap()
+                    ))
+                    .unwrap(),
+                ),
+                ..Self::default()
+            }
+        }
+    }
+}
diff --git a/crates/configs/src/deserialize_env.rs b/crates/configs/src/deserialize_env.rs
new file mode 100644
index 0000000000..9b5b230dae
--- /dev/null
+++ b/crates/configs/src/deserialize_env.rs
@@ -0,0 +1,169 @@
+//! Some variables are injected by 1Password directly into the Pod's
+//! environment, completely bypassing Pulumi and making it unusable in the
+//! configuration file. Since the token does not contain `%` this is a
+//! workaround to allow the token to be read from the environment.
+//!
+//! Due to handling several kinds of types
+
+use {
+    serde::{Deserialize, Deserializer},
+    std::str::FromStr,
+    url::{ParseError, Url},
+};
+
+const ENV_VAR_PREFIX: char = '%';
+
+/// Returns a deserialization error mentioning that the target environment
+/// variable could not be found.
+fn invalid_value_env_var_missing<E: serde::de::Error>(var_name: &str) -> E {
+    serde::de::Error::invalid_value(
+        serde::de::Unexpected::Str(var_name),
+        &"expected environment variable to be available",
+    )
+}
+
+/// Returns a deserialization error mentioning that either the environment
+/// variable contents or the field value is not a valid URL.
+fn invalid_value_unable_to_parse_url<E: serde::de::Error>(err: ParseError) -> E {
+    serde::de::Error::invalid_value(
+        serde::de::Unexpected::Other(err.to_string().as_str()),
+        &"expected environment variable contents or passed field value to be a valid URL",
+    )
+}
+
+/// Deserializes an URL from *either* an environment variable — with the format
+/// `%<ENV_VAR_NAME>` — or interpreting a String as a URL.
+pub(crate) fn deserialize_url_from_env<'de, D>(deserializer: D) -> Result<Url, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let env_var_name = String::deserialize(deserializer)?;
+
+    let raw_url = match env_var_name.strip_prefix(ENV_VAR_PREFIX) {
+        Some(env_var_name) => std::env::var(env_var_name)
+            .inspect_err(|err| {
+                tracing::error!(%err, %env_var_name, "failed to load env var");
+            })
+            .map_err(|_| invalid_value_env_var_missing(env_var_name))?,
+        None => env_var_name,
+    };
+
+    Url::from_str(&raw_url).map_err(invalid_value_unable_to_parse_url)
+}
+
+/// Deserializes an optional URL from *either* an environment variable — with
+/// the format `%<ENV_VAR_NAME>` — or interpreting a String as a URL.
+pub(crate) fn deserialize_optional_url_from_env<'de, D>(
+    deserializer: D,
+) -> Result<Option<Url>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let Some(env_var_name) = Option::<String>::deserialize(deserializer)? else {
+        return Ok(None);
+    };
+    let raw_url = match env_var_name.strip_prefix(ENV_VAR_PREFIX) {
+        // In the case of optional variables, we assume a missing env var as empty
+        Some(env_var_name) => match std::env::var(env_var_name).ok() {
+            Some(raw_url) => raw_url,
+            None => return Ok(None),
+        },
+
+        None => env_var_name,
+    };
+
+    Ok(Some(
+        Url::from_str(raw_url.as_str()).map_err(invalid_value_unable_to_parse_url)?,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use {serde::Deserialize, url::Url};
+
+    #[derive(Deserialize)]
+    struct Required {
+        #[serde(deserialize_with = "super::deserialize_url_from_env")]
+        url: Url,
+    }
+
+    #[derive(Deserialize)]
+    struct Optional {
+        #[serde(default, deserialize_with = "super::deserialize_optional_url_from_env")]
+        url: Option<Url>,
+    }
+
+    #[test]
+    fn required_direct_url() {
+        let json = r#"{"url": "http://localhost:8080"}"#;
+        let parsed: Required = serde_json::from_str(json).unwrap();
+        assert_eq!(parsed.url.as_str(), "http://localhost:8080/");
+    }
+
+    #[test]
+    fn required_from_env_var() {
+        let var = "TEST_DESER_REQ_FROM_ENV";
+        // Safety: test-only, using unique env var names to avoid conflicts
+        unsafe { std::env::set_var(var, "http://example.com") };
+        let json = format!(r#"{{"url": "%{var}"}}"#);
+        let parsed: Required = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.url.as_str(), "http://example.com/");
+        unsafe { std::env::remove_var(var) };
+    }
+
+    #[test]
+    fn required_missing_env_var_is_error() {
+        let json = r#"{"url": "%NONEXISTENT_TEST_VAR_12345"}"#;
+        assert!(serde_json::from_str::<Required>(json).is_err());
+    }
+
+    #[test]
+    fn required_invalid_url_is_error() {
+        let json = r#"{"url": "not a url"}"#;
+        assert!(serde_json::from_str::<Required>(json).is_err());
+    }
+
+    #[test]
+    fn optional_none_when_absent() {
+        let json = r#"{}"#;
+        let parsed: Optional = serde_json::from_str(json).unwrap();
+        assert!(parsed.url.is_none());
+    }
+
+    #[test]
+    fn optional_none_when_null() {
+        let json = r#"{"url": null}"#;
+        let parsed: Optional = serde_json::from_str(json).unwrap();
+        assert!(parsed.url.is_none());
+    }
+
+    #[test]
+    fn optional_direct_url() {
+        let json = r#"{"url": "http://localhost:9090"}"#;
+        let parsed: Optional = serde_json::from_str(json).unwrap();
+        assert_eq!(parsed.url.unwrap().as_str(), "http://localhost:9090/");
+    }
+
+    #[test]
+    fn optional_from_env_var() {
+        let var = "TEST_DESER_OPT_FROM_ENV";
+        unsafe { std::env::set_var(var, "http://opt.example.com") };
+        let json = format!(r#"{{"url": "%{var}"}}"#);
+        let parsed: Optional = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.url.unwrap().as_str(), "http://opt.example.com/");
+        unsafe { std::env::remove_var(var) };
+    }
+
+    #[test]
+    fn optional_missing_env_var_returns_none() {
+        let json = r#"{"url": "%NONEXISTENT_OPT_TEST_VAR_12345"}"#;
+        let parsed: Optional = serde_json::from_str(json).unwrap();
+        assert!(parsed.url.is_none());
+    }
+
+    #[test]
+    fn optional_invalid_url_is_error() {
+        let json = r#"{"url": "not a url"}"#;
+        assert!(serde_json::from_str::<Optional>(json).is_err());
+    }
+}
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
new file mode 100644
index 0000000000..5679dfea89
--- /dev/null
+++ b/crates/configs/src/lib.rs
@@ -0,0 +1,18 @@
+pub mod database;
+pub(crate) mod deserialize_env;
+
+#[cfg(any(test, feature = "test-util"))]
+pub mod test_util {
+    /// Provides standard test defaults while keeping separate from the regular
+    /// `Default` trait.
+    pub trait TestDefault {
+        /// Returns a test specific default.
+        ///
+        /// For example, when providing a default for a database connection for
+        /// tests, this can return a `localhost` connection.
+        fn test_default() -> Self;
+    }
+
+    // No blanket implementation due to lack of specialization features:
+    // https://github.com/rust-lang/rfcs/blob/master/text/1210-impl-specialization.md
+}
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index fd0032b6d9..5016481608 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -33,6 +33,7 @@ balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
+configs = { workspace = true, features = ["test-util"] }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 cow-amm = { workspace = true }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 5dec08c4b2..307e7261a9 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -20,6 +20,7 @@ use {
         infra::persistence::dto,
     },
     clap::Parser,
+    configs::test_util::TestDefault,
     ethrpc::Web3,
     model::{
         AuctionId,
@@ -36,7 +37,6 @@ use {
         collections::{HashMap, hash_map::Entry},
         ops::DerefMut,
         str::FromStr,
-        sync::LazyLock,
         time::Duration,
     },
     tokio::task::JoinHandle,
@@ -51,12 +51,6 @@ pub const TRADES_ENDPOINT: &str = "/api/v1/trades";
 pub const VERSION_ENDPOINT: &str = "/api/v1/version";
 pub const SOLVER_COMPETITION_ENDPOINT: &str = "/api/v2/solver_competition";
 const LOCAL_DB_URL: &str = "postgresql://";
-static LOCAL_READ_ONLY_DB_URL: LazyLock<String> = LazyLock::new(|| {
-    format!(
-        "postgresql://readonly@localhost/{db}",
-        db = std::env::var("USER").unwrap()
-    )
-});
 
 fn order_status_endpoint(uid: &OrderUid) -> String {
     format!("/api/v1/orders/{uid}/status")
@@ -259,7 +253,6 @@ impl<'a> Services<'a> {
             "orderbook".to_string(),
             "--quote-timeout=10s".to_string(),
             "--quote-verification=enforce-when-possible".to_string(),
-            format!("--db-read-url={}", &*LOCAL_READ_ONLY_DB_URL),
             config_arg,
         ]
         .into_iter()
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 12f4594824..beabd3a31f 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -1,5 +1,6 @@
 use {
     autopilot::{config::Configuration, shutdown_controller::ShutdownController},
+    configs::test_util::TestDefault,
     e2e::setup::{
         OnchainComponents,
         Services,
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 0591151efc..5dbf4e3504 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,6 +1,7 @@
 use {
     ::alloy::primitives::U256,
     autopilot::config::trusted_tokens::TrustedTokensConfig,
+    configs::test_util::TestDefault,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index 036f7ce100..323dd0629f 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -2,6 +2,7 @@
 //! headers.
 
 use {
+    configs::test_util::TestDefault,
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     reqwest::{Method, StatusCode},
     shared::web3::Web3,
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index b336c4341d..0ea1f12a94 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -7,6 +7,7 @@ use {
         },
     },
     autopilot::config::{Configuration, solver::Solver},
+    configs::test_util::TestDefault,
     contracts::alloy::{
         ERC20,
         support::{Balances, Signatures},
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index 03cb77f8bb..101224c110 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -1,6 +1,7 @@
 use {
     ::alloy::primitives::U256,
     autopilot::config::Configuration,
+    configs::test_util::TestDefault,
     e2e::setup::{colocation::SolverEngine, mock::Mock, solution::JitOrder, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 4750d41e0a..a73c1d47ad 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -10,6 +10,7 @@ use {
         solver::{Account, Solver},
     },
     bigdecimal::BigDecimal,
+    configs::test_util::TestDefault,
     contracts::alloy::ERC20,
     database::byte_array::ByteArray,
     driver::domain::eth::NonZeroU256,
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 8b77ff037e..06a37bc693 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -8,6 +8,7 @@ use {
     },
     autopilot::config::Configuration,
     chrono::{NaiveDateTime, Utc},
+    configs::test_util::TestDefault,
     contracts::alloy::{ERC20, IZeroex},
     e2e::{
         api::zeroex::{Eip712TypedZeroExOrder, ZeroExApi},
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index f87914bf8d..fb3f8c2eaf 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -6,6 +6,7 @@ use {
     },
     autopilot::config::Configuration,
     chrono::Utc,
+    configs::test_util::TestDefault,
     contracts::alloy::{ERC20, LiquoriceSettlement},
     driver::infra,
     e2e::{
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index dccd198dad..07222c2995 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -2,6 +2,7 @@
 //! responses are preserved.
 
 use {
+    configs::test_util::TestDefault,
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     model::order::{ORDER_UID_LIMIT, OrderUid},
     orderbook::api::Error,
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index 6cd57f1197..7275094760 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -1,6 +1,7 @@
 use {
     ::alloy::primitives::U256,
     autopilot::config::Configuration,
+    configs::test_util::TestDefault,
     database::order_events::OrderEventLabel,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index b7933fe2c5..82cfb002e2 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -1,6 +1,7 @@
 use {
     ::alloy::primitives::U256,
     autopilot::{config::Configuration, shutdown_controller::ShutdownController},
+    configs::test_util::TestDefault,
     driver::domain::eth::NonZeroU256,
     e2e::setup::{colocation, wait_for_condition, *},
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 339cd4b3ec..fd1690c788 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -11,6 +11,7 @@ use {
         },
         solver::Solver,
     },
+    configs::test_util::TestDefault,
     driver::domain::eth::NonZeroU256,
     e2e::{assert_approximately_eq, setup::*},
     ethrpc::alloy::CallBuilderExt,
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 3ea3f2e283..4dd8954421 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -6,6 +6,7 @@ use {
     autopilot::config::Configuration,
     balance_overrides::{BalanceOverrides, BalanceOverriding, Strategy},
     bigdecimal::{BigDecimal, Zero},
+    configs::test_util::TestDefault,
     e2e::setup::*,
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::{
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index a088caa583..7f9e0eb6d0 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -1,5 +1,6 @@
 use {
     autopilot::config::Configuration,
+    configs::test_util::TestDefault,
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     futures::FutureExt,
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index 0295f44574..9c0672a64f 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -1,5 +1,6 @@
 use {
     ::alloy::primitives::U256,
+    configs::test_util::TestDefault,
     e2e::setup::*,
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     model::{
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index c2da63e3f9..820bd68240 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -1,5 +1,6 @@
 use {
     ::alloy::primitives::{Address, U256},
+    configs::test_util::TestDefault,
     e2e::setup::{safe::Safe, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index df2e67fc0d..a880f1482c 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -4,6 +4,7 @@ use {
         Configuration,
         solver::{Account, Solver},
     },
+    configs::test_util::TestDefault,
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 9fc2d8f421..0bc39abc7b 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -8,6 +8,7 @@ use {
         },
     },
     autopilot::config::Configuration,
+    configs::test_util::TestDefault,
     e2e::setup::*,
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     futures::StreamExt,
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 227074147c..a48e571953 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -28,6 +28,7 @@ cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, features = ["clock"] }
 clap = { workspace = true }
+configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
@@ -67,6 +68,7 @@ tracing = { workspace = true }
 url = { workspace = true }
 
 [dev-dependencies]
+configs = { workspace = true, features = ["test-util"] }
 mockall = { workspace = true }
 shared = { workspace = true, features = ["test-util"] }
 tempfile = { workspace = true }
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index da32dc747b..adb8eb9584 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,7 +1,6 @@
 use {
     price_estimation,
-    reqwest::Url,
-    shared::{arguments::display_secret_option, http_client},
+    shared::http_client,
     std::{net::SocketAddr, path::PathBuf},
 };
 
@@ -19,25 +18,12 @@ pub struct Arguments {
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
-    #[clap(flatten)]
-    pub database_pool: shared::arguments::DatabasePoolConfig,
-
     /// Path to the TOML configuration file.
     #[clap(long, env)]
     pub config: PathBuf,
 
     #[clap(long, env, default_value = "0.0.0.0:8080")]
     pub bind_address: SocketAddr,
-
-    /// Url of the Postgres database. By default connects to locally running
-    /// postgres.
-    #[clap(long, env, default_value = "postgresql://")]
-    pub db_write_url: Url,
-
-    /// Url of the Postgres database replica. By default it's the same as
-    /// db_write_url
-    #[clap(long, env)]
-    pub db_read_url: Option<Url>,
 }
 
 impl std::fmt::Display for Arguments {
@@ -47,23 +33,16 @@ impl std::fmt::Display for Arguments {
             order_quoting,
             http_client,
             price_estimation,
-            database_pool,
             config,
             bind_address,
-            db_write_url: db_url,
-            db_read_url,
         } = self;
 
         write!(f, "{shared}")?;
         write!(f, "{order_quoting}")?;
         write!(f, "{http_client}")?;
         write!(f, "{price_estimation}")?;
-        write!(f, "{database_pool}")?;
         writeln!(f, "config: {}", config.display())?;
         writeln!(f, "bind_address: {bind_address}")?;
-        let _intentionally_ignored = db_url;
-        writeln!(f, "db_url: SECRET")?;
-        display_secret_option(f, "db_read_url", db_read_url.as_ref())?;
 
         Ok(())
     }
diff --git a/crates/orderbook/src/config/mod.rs b/crates/orderbook/src/config/mod.rs
index a496786541..3a438dc29d 100644
--- a/crates/orderbook/src/config/mod.rs
+++ b/crates/orderbook/src/config/mod.rs
@@ -8,6 +8,7 @@ use {
     alloy::primitives::Address,
     anyhow::anyhow,
     chrono::{DateTime, Utc},
+    configs::database::DatabasePoolConfig,
     serde::{Deserialize, Serialize},
     shared::fee_factor::FeeFactor,
     std::path::Path,
@@ -34,8 +35,9 @@ pub struct VolumeFeeConfig {
 }
 
 // NOTE: cannot add deny_unknown_fields during the config migration
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "kebab-case" /* deny_unknown_fields */)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 pub struct Configuration {
     /// Configuration for the order validation system.
     #[serde(default)]
@@ -69,6 +71,9 @@ pub struct Configuration {
 
     /// Configuration for the native price estimation mechanism.
     pub native_price_estimation: NativePriceConfig,
+
+    #[serde(default)]
+    pub database: DatabasePoolConfig,
 }
 
 impl Configuration {
@@ -86,43 +91,64 @@ impl Configuration {
             )),
         }
     }
-
-    pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
-        Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
-    }
 }
 
 #[cfg(any(test, feature = "test-util"))]
-impl Configuration {
-    pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
-        use std::io::Write;
-        let mut file = tempfile::NamedTempFile::new().expect("temp file creation should not fail");
-        file.write_all(
-            toml::to_string_pretty(self)
-                .expect("serialization should not fail")
-                .as_bytes(),
-        )
-        .expect("writing to temp file should not fail");
-        file
-    }
+pub mod test_util {
+    use {
+        crate::config::{
+            Configuration,
+            default_active_order_competition_threshold,
+            default_app_data_size_limit,
+            native_price::NativePriceConfig,
+        },
+        configs::test_util::TestDefault,
+        std::path::Path,
+    };
+
+    impl Configuration {
+        pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
+            Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
+        }
 
-    pub fn to_cli_args(&self) -> (tempfile::NamedTempFile, String) {
-        let named_temp_file = self.to_temp_path();
-        let cli_arg = format!("--config={}", named_temp_file.path().display());
-        (named_temp_file, cli_arg)
+        pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
+            use std::io::Write;
+            let mut file =
+                tempfile::NamedTempFile::new().expect("temp file creation should not fail");
+            file.write_all(
+                toml::to_string_pretty(self)
+                    .expect("serialization should not fail")
+                    .as_bytes(),
+            )
+            .expect("writing to temp file should not fail");
+            file
+        }
+
+        pub fn to_cli_args(&self) -> (tempfile::NamedTempFile, String) {
+            let named_temp_file = self.to_temp_path();
+            let cli_arg = format!("--config={}", named_temp_file.path().display());
+            (named_temp_file, cli_arg)
+        }
     }
 
-    pub fn test_default() -> Self {
-        Self {
-            order_validation: Default::default(),
-            banned_users: Default::default(),
-            ipfs: Default::default(),
-            volume_fee: Default::default(),
-            app_data_size_limit: default_app_data_size_limit(),
-            active_order_competition_threshold: default_active_order_competition_threshold(),
-            unsupported_tokens: Default::default(),
-            eip1271_skip_creation_validation: Default::default(),
-            native_price_estimation: NativePriceConfig::test_default(),
+    impl TestDefault for Configuration {
+        fn test_default() -> Self {
+            use configs::test_util::TestDefault;
+
+            Self {
+                order_validation: Default::default(),
+                banned_users: Default::default(),
+                ipfs: Default::default(),
+                volume_fee: Default::default(),
+                app_data_size_limit: default_app_data_size_limit(),
+                active_order_competition_threshold: default_active_order_competition_threshold(),
+                unsupported_tokens: Default::default(),
+                eip1271_skip_creation_validation: Default::default(),
+                // NOTE: NativePriceConfig needs to be moved to the config crate and then it can
+                // have the test_default trait impl
+                native_price_estimation: NativePriceConfig::test_default(),
+                database: TestDefault::test_default(),
+            }
         }
     }
 }
@@ -131,6 +157,7 @@ impl Configuration {
 mod tests {
     use {
         super::*,
+        configs::test_util::TestDefault,
         price_estimation::{NativePriceEstimator, NativePriceEstimators},
         shared::order_validation::SameTokensPolicy,
         std::time::Duration,
@@ -267,6 +294,7 @@ mod tests {
                 fallback_estimators: None,
                 ..NativePriceConfig::test_default()
             },
+            database: TestDefault::test_default(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index f5dda9424f..982af41bfd 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -161,13 +161,13 @@ pub async fn run(args: Arguments, config: Configuration) {
         .expect("Deployed contract constants don't match the ones in this binary");
     let domain_separator = DomainSeparator::new(chain_id, *settlement_contract.address());
     let db_config = crate::database::Config {
-        max_pool_size: args.database_pool.db_max_connections.get(),
+        max_pool_size: config.database.max_connections.get(),
     };
-    let postgres_write = Postgres::try_new(args.db_write_url.as_str(), db_config.clone())
+    let postgres_write = Postgres::try_new(config.database.write_url.as_str(), db_config.clone())
         .expect("failed to create database");
 
-    let postgres_read = if let Some(db_read_url) = args.db_read_url
-        && args.db_write_url != db_read_url
+    let postgres_read = if let Some(db_read_url) = config.database.read_url
+        && config.database.write_url != db_read_url
     {
         Postgres::try_new(db_read_url.as_str(), db_config)
             .expect("failed to create read replica database")

From ae83cf7a4847ec689d972df51cef9210d311545d Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 6 Mar 2026 10:11:25 +0100
Subject: [PATCH 127/219] reenable https support (#4238)

# Description
When replacing the `alloy` dependency with its sub-depdencies I let
compilation errors guide me which features need to be enabled. However,
this was not enough since `https` support needs to be enabled via a
feature and if that's missing we'll only encounter runtime errors but
not compile time errors.
`reqwest` will throw errors like `invalid URL, scheme is not http`.

# Changes
Enabled `https` on the workspace level to avoid feature unification
causing us to miss `https` support in future edge cases
Added a unit test to ensure that `https` requests succeed.

## How to test
new unit test
---
 Cargo.lock               | 30 ++++++++++++++++++++++++++++++
 Cargo.toml               |  5 ++++-
 crates/ethrpc/src/lib.rs | 22 ++++++++++++++++++++++
 3 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index a1dcdac38a..f10b9c5f51 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3955,6 +3955,22 @@ dependencies = [
  "tower-service",
 ]
 
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes",
+ "http-body-util",
+ "hyper 1.8.1",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
 [[package]]
 name = "hyper-util"
 version = "0.1.19"
@@ -5980,16 +5996,20 @@ dependencies = [
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.8.1",
+ "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
+ "native-tls",
  "percent-encoding",
  "pin-project-lite",
+ "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper 1.0.2",
  "tokio",
+ "tokio-native-tls",
  "tower 0.5.3",
  "tower-http",
  "tower-service",
@@ -7555,6 +7575,16 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-rustls"
 version = "0.24.1"
diff --git a/Cargo.toml b/Cargo.toml
index 3139af15c1..2106e23010 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,10 @@ alloy-json-abi = { version = "1.5.7", default-features = false }
 alloy-json-rpc = { version = "1.7.3", default-features = false }
 alloy-network = { version = "1.7.3", default-features = false }
 alloy-primitives = { version = "1.5.2", default-features = false }
-alloy-provider = { version = "1.7.3", default-features = false }
+# enabling `reqwest-default-tls` on the workspace level because missing this feature
+# leads to runtime errors instead of compile time errors. Also feature unification
+# is error prone and we must never lack https support.
+alloy-provider = { version = "1.7.3", default-features = false, features = ["reqwest-default-tls"] }
 alloy-rpc-client = { version = "1.7.3", default-features = false }
 alloy-rpc-types = { version = "1.7.3", default-features = false }
 alloy-signer = { version = "1.7.3", default-features = false }
diff --git a/crates/ethrpc/src/lib.rs b/crates/ethrpc/src/lib.rs
index ab78b684a5..506131524b 100644
--- a/crates/ethrpc/src/lib.rs
+++ b/crates/ethrpc/src/lib.rs
@@ -77,3 +77,25 @@ pub fn web3(args: Config, url: &Url, label: Option<&str>) -> Web3 {
         wallet,
     }
 }
+
+#[cfg(test)]
+mod test {
+    use {super::*, alloy_eips::BlockId, alloy_provider::Provider};
+
+    #[tokio::test]
+    async fn test_https() {
+        let provider = Web3::new_from_url("https://rpc.mevblocker.io");
+        let response = provider.provider.get_block(BlockId::latest()).await;
+
+        if let Err(err) = response {
+            // only fail the CI if we are sure the error is due to missing
+            // `https` support
+            if err.to_string().contains("scheme is not http") {
+                eprintln!("{err:?}");
+                panic!("https support is not enabled");
+            } else {
+                eprintln!("mevblocker error unrelated to https support: {err:?}");
+            }
+        }
+    }
+}

From fb96d591a8e1578174fee123477d40249828cf0c Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Fri, 6 Mar 2026 11:08:15 +0100
Subject: [PATCH 128/219] Fix log instructions for claude (#4237)

# Description

Log format has changed so I updated instructions how to use it for
Claude.
---
 CLAUDE.md                     | 14 +++++-----
 docs/COW_ORDER_DEBUG_SKILL.md | 52 +++++++++++++++--------------------
 2 files changed, 29 insertions(+), 37 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index a8b983984f..a03abd0c06 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -183,25 +183,25 @@ Use `$ETH_MAINNET_RPC` from `.env.claude` for mainnet. Use `cast` or whatever to
 
 ## Grafana Logs Access
 
-Use the `scripts/vlogs` wrapper to query Victoria Logs:
+Use the `scripts/vlogs` wrapper to query Victoria Logs.
+
+**IMPORTANT**: When running `scripts/vlogs`, do NOT use bash comments before the command (e.g., `# comment\nscripts/vlogs ...`) as this causes unnecessary permission prompts. Just run the command directly.
+
+**IMPORTANT**: Order UIDs and other structured fields (like `quote_id`, `auction_id`) live inside the `all` field in Victoria Logs. You MUST prefix them with `all:` to match. Plain text terms (like `order created`, `filtered`) match the log message directly and don't need the prefix.
 
 ```bash
-# Basic usage
 scripts/vlogs "<expr>" [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]
 
-# Examples
-scripts/vlogs "NOT container:controller order created 0xabc..." --from now-24h
+scripts/vlogs "NOT container:controller order created all:0xabc..." --from now-24h
 scripts/vlogs "NOT container:controller network:mainnet settlement failed" --from now-6h --max 50
 scripts/vlogs "error" --env staging --from now-1h
-scripts/vlogs "NOT container:controller 0xabc..." --raw  # full JSON with labels
+scripts/vlogs "NOT container:controller all:0xabc..." --raw
 ```
 
 Defaults: `--from now-12h`, `--to now`, `--max 100`, `--env prod`
 
 Datasource UIDs (hardcoded in script): `vm-auth-prod` (production), `vm-auth-staging` (staging)
 
-With `--raw`, each log entry has an `all` field containing the full unparsed JSON log message (with timestamp, level, fields, spans, trace_id). Useful for extracting structured data like `order_uid`, `quote_id`, `request_id`, etc.
-
 ## Etherscan API (V2)
 
 Use MCP `mcp__fetch__fetch` tool. API Key in `.env.claude` as `$ETHERSCAN_API_KEY`.
diff --git a/docs/COW_ORDER_DEBUG_SKILL.md b/docs/COW_ORDER_DEBUG_SKILL.md
index 4f9e719653..46f8706420 100644
--- a/docs/COW_ORDER_DEBUG_SKILL.md
+++ b/docs/COW_ORDER_DEBUG_SKILL.md
@@ -7,7 +7,7 @@ Debug why CoW Protocol orders fail to match. Requires DB access + Victoria Logs
 Run through these in order:
 
 1. [ ] **Order status** — Check API status first (cancelled/expired/fulfilled/open)
-2. [ ] **User cancellation** — If cancelled, search logs for `order cancelled ORDER_UID` FIRST
+2. [ ] **User cancellation** — If cancelled, search logs for `order cancelled all:ORDER_UID` FIRST
 3. [ ] **Order in auction** — Was order in autopilot auction? When?
 4. [ ] **Solver bids** — Did any solver bid? What happened to their solution?
 5. [ ] **Settlement outcome** — Did settlement succeed/fail/timeout?
@@ -87,42 +87,37 @@ Logs are stored in Victoria Logs and accessible via Grafana API.
 
 **Query using `scripts/vlogs`:**
 ```bash
-# Basic: search by order UID (use full UID with 0x prefix)
-scripts/vlogs "NOT container:controller ORDER_UID"
+scripts/vlogs "NOT container:controller all:ORDER_UID"
 
-# Filter by network
-scripts/vlogs "NOT container:controller network:bnb ORDER_UID"
+scripts/vlogs "NOT container:controller network:bnb all:ORDER_UID"
 
-# Search by auction ID
-scripts/vlogs "NOT container:controller 22788649"
+scripts/vlogs "NOT container:controller all:22788649"
 
-# Search by solver name + auction
-scripts/vlogs "NOT container:controller baseline 22788649"
+scripts/vlogs "NOT container:controller baseline all:22788649"
 
-# Custom time range and max lines
-scripts/vlogs "NOT container:controller ORDER_UID" --from now-24h --max 200
+scripts/vlogs "NOT container:controller all:ORDER_UID" --from now-24h --max 200
 
-# Full JSON output (includes labels like network, pod, parsed fields)
-scripts/vlogs "NOT container:controller ORDER_UID" --raw
+scripts/vlogs "NOT container:controller all:ORDER_UID" --raw
 ```
 
 **Useful filters (part of the expr):**
 - `NOT container:controller` — excludes nginx access logs (REQUIRED for order UID searches)
 - `network:$NETWORK` — filter by chain (mainnet, bnb, arbitrum-one, base, etc)
+- `all:` — prefix for searching structured fields (order UIDs, auction IDs, quote IDs). Without a field prefix, Victoria Logs only searches the log message text, not structured fields. You can also use specific field names (e.g., `order_uid:0x...`) but `all:` works universally.
 
-**Note:** Victoria Logs uses simple text matching. Always use the **full order UID with 0x prefix** for reliable matching.
+**Note:** Always use the **full order UID with 0x prefix** and the `all:` field prefix for reliable matching.
 
 **IMPORTANT - Run targeted lifecycle queries in parallel** (use FULL order UID with 0x):
 
 ```bash
-scripts/vlogs "NOT container:controller order created ORDER_UID"
-scripts/vlogs "NOT container:controller order cancelled ORDER_UID"
-scripts/vlogs "NOT container:controller proposed solution ORDER_UID"
-scripts/vlogs "NOT container:controller settlement failed ORDER_UID"
-scripts/vlogs "NOT container:controller filtered ORDER_UID"
+scripts/vlogs "NOT container:controller order created all:ORDER_UID"
+scripts/vlogs "NOT container:controller order cancelled all:ORDER_UID"
+scripts/vlogs "NOT container:controller proposed solution all:ORDER_UID"
+scripts/vlogs "NOT container:controller settlement failed all:ORDER_UID"
+scripts/vlogs "NOT container:controller filtered all:ORDER_UID"
 
 # Find discarded solutions where order appears in calldata (use order UID bytes without 0x prefix)
-scripts/vlogs "discarded .*ORDER_UID_WITHOUT_0X.*"
+scripts/vlogs "discarded all:ORDER_UID_WITHOUT_0X"
 ```
 
 **What to look for:**
@@ -199,7 +194,7 @@ WHERE oq.order_uid = '\x$ORDER_UID_HEX';
 Find the quote_id from the "order created" log:
 
 ```bash
-"expr": "NOT container:controller order created ORDER_UID | sort by (_time) asc"
+scripts/vlogs "NOT container:controller order created all:ORDER_UID"
 ```
 
 **Example log line:**
@@ -209,7 +204,7 @@ orderbook::api::post_order: order created order_uid=0x... quote_id=Some(2720468)
 
 Then search for quote details by ID:
 ```bash
-"expr": "NOT container:controller $QUOTE_ID | sort by (_time) asc"
+scripts/vlogs "NOT container:controller all:$QUOTE_ID"
 ```
 
 ---
@@ -303,13 +298,12 @@ surplusFeeTimestamp is within last 10 minutes
 
 **If missing/stale, check surplus fee computation logs:**
 ```bash
-# Victoria Logs query
-"expr": "surplus_fee $ORDER_UID | sort by (_time) asc"
+scripts/vlogs "surplus_fee all:ORDER_UID"
 ```
 
 **Surplus fee error logs:**
 ```bash
-"expr": "surplus_fee error | sort by (_time) asc"
+scripts/vlogs "surplus_fee error"
 ```
 
 ### 9.2 Auction Filtering Check
@@ -321,8 +315,7 @@ curl -s "https://api.cow.fi/$NETWORK/api/v1/auction" | jq '.orders[] | select(.u
 
 If not present, order is filtered. Check filter logs:
 ```bash
-# Victoria Logs query
-"expr": "filtered $ORDER_UID | sort by (_time) asc"
+scripts/vlogs "filtered all:ORDER_UID"
 ```
 
 **Common filter reasons:**
@@ -411,13 +404,12 @@ Order is in auction but still not matching?
 
 **Auction orders log:**
 ```bash
-# Victoria Logs query (just the auction ID number)
-"expr": "$AUCTION_ID | sort by (_time) asc"
+scripts/vlogs "all:$AUCTION_ID"
 ```
 
 **Specific auction run:**
 ```bash
-"expr": "$RUN_ID | sort by (_time) asc"
+scripts/vlogs "all:$RUN_ID"
 ```
 
 ### JIT Orders & CoW AMMs

From 4b1a8f1813abf10ec79da3ac1da65d396aee7a57 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 6 Mar 2026 13:34:02 +0100
Subject: [PATCH 129/219] Dont rely on feature unification (#4240)

# Description
Follow up to #4238.
While that PR correctly identified the issue that `https` was not
enabled when is should have been it did not resolve it correctly. It
incorrectly added the tls feature on the workspace toml assuming this
will cause the feature to always be enabled but that's actually not
correct.
The driver still did not support https. I was able to reproduce that by
copying the new `test_https` unit test to the driver main and running it
from there.
`cargo test -- test_https` passed while `cargo test -p driver --
test_https` did not. This indicates that `https` support was only
enabled when the whole workspace gets compiled as one. When we only
compiled the `driver` feature unification was not there to pull in the
necessary features.

This PR addresses this by explicitly enabling all the necessary features
such that every crate can be compiled and tested individually without
complaints.

# Changes
Add a bunch of features that were previously assumed to not be needed
because feature unification pulled them in without our knowledge.

Since `alloy` likes to follow the pattern of using feature flags to
enable compilation of sub-crates I avoided the use of feature flags by
depending on the underlying sub-crate whenever possible. For example
this caused me to introduce `alloy_rpc_types_eth` and
`alloy_rpc_types_trace` on the workspace level.

This PR only fixes the symptom but doesn't prevent us from relying on
feature unification without our knowledge again. This should be
addressed in a follow up PR.

## How to test
After that was done I repeated the test with `cargo -p driver --
test_https` and it passed. Indicating that the `ethrpc` crate now
correctly causes https to be supported in any crate that depends on it.
---
 Cargo.lock                             | 2 ++
 Cargo.toml                             | 7 +++----
 crates/autopilot/Cargo.toml            | 2 +-
 crates/bad-tokens/Cargo.toml           | 3 ++-
 crates/bad-tokens/src/trace_call.rs    | 8 +++-----
 crates/balance-overrides/Cargo.toml    | 6 +++---
 crates/ethrpc/Cargo.toml               | 4 ++--
 crates/ethrpc/src/lib.rs               | 2 +-
 crates/gas-price-estimation/Cargo.toml | 2 +-
 crates/liquidity-sources/Cargo.toml    | 5 +++--
 crates/model/Cargo.toml                | 2 +-
 crates/observe/Cargo.toml              | 3 +++
 crates/price-estimation/Cargo.toml     | 7 ++++---
 crates/signature-validator/Cargo.toml  | 3 +++
 crates/solvers-dto/Cargo.toml          | 1 +
 crates/solvers-dto/src/notification.rs | 2 +-
 16 files changed, 34 insertions(+), 25 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f10b9c5f51..2a0e6d2759 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1836,6 +1836,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-provider",
  "alloy-rpc-types",
+ "alloy-rpc-types-trace",
  "alloy-sol-types",
  "alloy-transport",
  "anyhow",
@@ -6962,6 +6963,7 @@ version = "0.1.0"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types",
+ "alloy-rpc-types-eth",
  "app-data",
  "bigdecimal",
  "bytes-hex",
diff --git a/Cargo.toml b/Cargo.toml
index 2106e23010..485b842094 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,12 +13,11 @@ alloy-json-abi = { version = "1.5.7", default-features = false }
 alloy-json-rpc = { version = "1.7.3", default-features = false }
 alloy-network = { version = "1.7.3", default-features = false }
 alloy-primitives = { version = "1.5.2", default-features = false }
-# enabling `reqwest-default-tls` on the workspace level because missing this feature
-# leads to runtime errors instead of compile time errors. Also feature unification
-# is error prone and we must never lack https support.
-alloy-provider = { version = "1.7.3", default-features = false, features = ["reqwest-default-tls"] }
+alloy-provider = { version = "1.7.3", default-features = false }
 alloy-rpc-client = { version = "1.7.3", default-features = false }
 alloy-rpc-types = { version = "1.7.3", default-features = false }
+alloy-rpc-types-eth = { version = "1.7.3", default-features = false }
+alloy-rpc-types-trace = { version = "1.7.3", default-features = false }
 alloy-signer = { version = "1.7.3", default-features = false }
 alloy-signer-local = { version = "1.7.3", default-features = false }
 alloy-sol-macro-expander = "1.4.1"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index a90519489c..90d1359e76 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -51,7 +51,7 @@ num = { workspace = true }
 number = { workspace = true }
 observe = { workspace = true }
 order-validation = { workspace = true }
-price-estimation = { workspace = true }
+price-estimation = { workspace = true, features = ["test-util"] }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
diff --git a/crates/bad-tokens/Cargo.toml b/crates/bad-tokens/Cargo.toml
index 92c50bef27..e40391f8f6 100644
--- a/crates/bad-tokens/Cargo.toml
+++ b/crates/bad-tokens/Cargo.toml
@@ -8,8 +8,9 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 alloy-json-rpc = { workspace = true }
 alloy-primitives = { workspace = true, features = ["rand"] }
-alloy-provider = { workspace = true }
+alloy-provider = { workspace = true, features = ["trace-api"] }
 alloy-rpc-types = { workspace = true }
+alloy-rpc-types-trace = { workspace = true }
 alloy-sol-types = { workspace = true }
 alloy-transport = { workspace = true }
 anyhow = { workspace = true }
diff --git a/crates/bad-tokens/src/trace_call.rs b/crates/bad-tokens/src/trace_call.rs
index d202f91c47..67b02d173d 100644
--- a/crates/bad-tokens/src/trace_call.rs
+++ b/crates/bad-tokens/src/trace_call.rs
@@ -3,10 +3,8 @@ use {
     alloy_json_rpc::ErrorPayload,
     alloy_primitives::{Address, U256},
     alloy_provider::ext::TraceApi,
-    alloy_rpc_types::{
-        TransactionRequest,
-        trace::parity::{TraceOutput, TraceResults, TraceType},
-    },
+    alloy_rpc_types::TransactionRequest,
+    alloy_rpc_types_trace::parity::{TraceOutput, TraceResults, TraceType},
     alloy_sol_types::SolCall,
     alloy_transport::{RpcError, TransportErrorKind},
     anyhow::{Context, Result, bail, ensure},
@@ -344,7 +342,7 @@ mod tests {
     use {
         super::*,
         alloy_primitives::Bytes,
-        alloy_rpc_types::trace::parity::{
+        alloy_rpc_types_trace::parity::{
             Action,
             CallAction,
             CallOutput,
diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
index 98b5f43b57..c4fa9b999b 100644
--- a/crates/balance-overrides/Cargo.toml
+++ b/crates/balance-overrides/Cargo.toml
@@ -10,9 +10,9 @@ doctest = false
 
 [dependencies]
 alloy-eips = { workspace = true }
-alloy-primitives = { workspace = true }
-alloy-provider = { workspace = true, features = ["debug-api"] }
-alloy-rpc-types = { workspace = true }
+alloy-primitives = { workspace = true, features = ["rand"] }
+alloy-provider = { workspace = true, features = ["debug-api", "trace-api"] }
+alloy-rpc-types = { workspace = true, features = ["trace"] }
 alloy-sol-types = { workspace = true }
 alloy-transport = { workspace = true }
 anyhow = { workspace = true }
diff --git a/crates/ethrpc/Cargo.toml b/crates/ethrpc/Cargo.toml
index 77cdf38176..92b21b3cf8 100644
--- a/crates/ethrpc/Cargo.toml
+++ b/crates/ethrpc/Cargo.toml
@@ -17,9 +17,9 @@ alloy-eips = { workspace = true }
 alloy-json-rpc = { workspace = true }
 alloy-network = { workspace = true }
 alloy-primitives = { workspace = true }
-alloy-provider = { workspace = true, features = ["ws"] }
+alloy-provider = { workspace = true, features = ["reqwest-default-tls", "reqwest", "ws"] }
 alloy-rpc-client = { workspace = true, features = ["reqwest"] }
-alloy-rpc-types = { workspace = true }
+alloy-rpc-types = { workspace = true, features = ["eth"] }
 alloy-signer = { workspace = true }
 alloy-transport = { workspace = true }
 alloy-transport-ws = { workspace = true }
diff --git a/crates/ethrpc/src/lib.rs b/crates/ethrpc/src/lib.rs
index 506131524b..b6c5f79f66 100644
--- a/crates/ethrpc/src/lib.rs
+++ b/crates/ethrpc/src/lib.rs
@@ -80,7 +80,7 @@ pub fn web3(args: Config, url: &Url, label: Option<&str>) -> Web3 {
 
 #[cfg(test)]
 mod test {
-    use {super::*, alloy_eips::BlockId, alloy_provider::Provider};
+    use {crate::Web3, alloy_eips::BlockId, alloy_provider::Provider};
 
     #[tokio::test]
     async fn test_https() {
diff --git a/crates/gas-price-estimation/Cargo.toml b/crates/gas-price-estimation/Cargo.toml
index 1124669153..86037c8240 100644
--- a/crates/gas-price-estimation/Cargo.toml
+++ b/crates/gas-price-estimation/Cargo.toml
@@ -15,7 +15,7 @@ futures = { workspace = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
-reqwest = { workspace = true }
+reqwest = { workspace = true, features = ["json"] }
 tokio = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
diff --git a/crates/liquidity-sources/Cargo.toml b/crates/liquidity-sources/Cargo.toml
index 90c3aa951a..f4b0b87547 100644
--- a/crates/liquidity-sources/Cargo.toml
+++ b/crates/liquidity-sources/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true, features = ["contract"] }
+alloy = { workspace = true, features = ["contract", "rand", "rpc-types"] }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 bytes-hex = { workspace = true }
@@ -29,7 +29,7 @@ observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 request-sharing = { workspace = true }
-reqwest = { workspace = true }
+reqwest = { workspace = true, features = ["json"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
@@ -40,6 +40,7 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
+ethrpc = { workspace = true, features = ["test-util"] }
 maplit = { workspace = true }
 mockall = { workspace = true }
 regex = { workspace = true }
diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml
index 2f742e0acf..9596e78ec2 100644
--- a/crates/model/Cargo.toml
+++ b/crates/model/Cargo.toml
@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 doctest = false
 
 [dependencies]
-alloy-primitives = { workspace = true }
+alloy-primitives = { workspace = true, features = ["rand"] }
 alloy-signer = { workspace = true }
 alloy-signer-local = { workspace = true }
 alloy-sol-types = { workspace = true }
diff --git a/crates/observe/Cargo.toml b/crates/observe/Cargo.toml
index 5e109fdd3a..213a6d3d5e 100644
--- a/crates/observe/Cargo.toml
+++ b/crates/observe/Cargo.toml
@@ -29,6 +29,9 @@ tracing-opentelemetry = { workspace = true }
 tracing-serde = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter", "fmt", "time"] }
 
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread"] }
+
 [features]
 default = []
 tokio-console = ["dep:console-subscriber"]
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index a6300bf8d8..5ee9cf737b 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-alloy = { workspace = true }
+alloy = { workspace = true, features = ["providers", "rpc", "rpc-types", "sol-types"] }
 anyhow = { workspace = true }
 app-data = { workspace = true }
 arc-swap = { workspace = true }
@@ -39,8 +39,8 @@ prometheus-metric-storage = { workspace = true }
 rand = { workspace = true }
 rate-limit = { workspace = true }
 request-sharing = { workspace = true }
-reqwest = { workspace = true }
-rust_decimal = { workspace = true }
+reqwest = { workspace = true, features = ["query"] }
+rust_decimal = { workspace = true, features = ["maths"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
@@ -55,6 +55,7 @@ hex-literal = { workspace = true }
 maplit = { workspace = true }
 mockall = { workspace = true }
 testlib = { workspace = true }
+token-info = { workspace = true, features = ["test-util"] }
 toml = { workspace = true }
 
 [features]
diff --git a/crates/signature-validator/Cargo.toml b/crates/signature-validator/Cargo.toml
index 629c3885d4..d65e31ec2c 100644
--- a/crates/signature-validator/Cargo.toml
+++ b/crates/signature-validator/Cargo.toml
@@ -24,6 +24,9 @@ model = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 
+[dev-dependencies]
+mockall = { workspace = true }
+
 [features]
 test-util = ["dep:mockall"]
 
diff --git a/crates/solvers-dto/Cargo.toml b/crates/solvers-dto/Cargo.toml
index b9febd9f94..4d75afac0c 100644
--- a/crates/solvers-dto/Cargo.toml
+++ b/crates/solvers-dto/Cargo.toml
@@ -8,6 +8,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 alloy-primitives = { workspace = true }
 alloy-rpc-types = { workspace = true }
+alloy-rpc-types-eth = { workspace = true }
 app-data = { workspace = true }
 bigdecimal = { workspace = true, features = ["serde"] }
 bytes-hex = { workspace = true }  # may get marked as unused but it's used with serde
diff --git a/crates/solvers-dto/src/notification.rs b/crates/solvers-dto/src/notification.rs
index 43e5bdf16e..c0acc7e2ee 100644
--- a/crates/solvers-dto/src/notification.rs
+++ b/crates/solvers-dto/src/notification.rs
@@ -1,6 +1,6 @@
 use {
     alloy_primitives::{Address, B256, U256},
-    alloy_rpc_types::AccessList,
+    alloy_rpc_types_eth::AccessList,
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::{DisplayFromStr, serde_as},

From 540bc76ddc8a53e22e8591905fb01e9920078d7e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 10 Mar 2026 10:36:40 +0000
Subject: [PATCH 130/219] Extract autopilot config groups (ethflow, cow_amm,
 run_loop) to TOML (#4235)

# Description
Move ethflow, cow_amm, and run_loop configurations from CLI arguments to
dedicated TOML config file modules. Add TestDefault impls for ethflow
and run_loop configs so E2E tests use appropriate values
(skip_event_sync, shorter timeouts) without manual overrides in test
setup code.

# Changes

* Move ethflow to the config
* Move cow_amm to the config
* Move run_loop to the config
* Move other loose arguments to the config

## How to test
Tested in staging

# Migration Guide

The following autopilot CLI arguments have moved to the TOML config
file.

## Ethflow (`[ethflow]`)

| CLI arg / env var | TOML key (`[ethflow]`) |
|---|---|
| `--ethflow-contracts` / `ETHFLOW_CONTRACTS` | `contracts` |
| `--ethflow-indexing-start` / `ETHFLOW_INDEXING_START` |
`indexing-start` |
| `--skip-event-sync` / `SKIP_EVENT_SYNC` | `skip-event-sync` |

## CoW AMM (`[cow-amm]`)

| CLI arg / env var | TOML key (`[cow-amm]`) |
|---|---|
| `--cow-amm-configs` / `COW_AMM_CONFIGS` | `[[cow-amm.contracts]]` (see
below) |
| `--archive-node-url` / `ARCHIVE_NODE_URL` | `archive-node-url` |

The `--cow-amm-configs` pipe-separated format
(`<factory>\|<helper>\|<block>`) is replaced by TOML tables:

```toml
[cow-amm]
archive-node-url = "https://archive.example.com"

[[cow-amm.contracts]]
factory = "0x..."
helper = "0x..."
index-start = 12345678
```

## Run loop (`[run-loop]`)

| CLI arg / env var | TOML key (`[run-loop]`) |
|---|---|
| `--max-run-loop-delay` / `MAX_RUN_LOOP_DELAY` | `max-delay` |
| `--max-winners-per-auction` / `MAX_WINNERS_PER_AUCTION` |
`max-winners-per-auction` |
| `--max-solutions-per-solver` / `MAX_SOLUTIONS_PER_SOLVER` |
`max-solutions-per-solver` |
| `--enable-leader-lock` / `ENABLE_LEADER_LOCK` | `enable-leader-lock` |
| `--compress-solve-request` / `COMPRESS_SOLVE_REQUEST` |
`compress-solve-request` |
| `--submission-deadline` / `SUBMISSION_DEADLINE` |
`submission-deadline` |
| `--max-settlement-transaction-wait` /
`MAX_SETTLEMENT_TRANSACTION_WAIT` | `max-settlement-transaction-wait` |
| `--solve-deadline` / `SOLVE_DEADLINE` | `solve-deadline` |

## Standalone fields

| CLI arg / env var | TOML key |
|---|---|
| `--metrics-address` / `METRICS_ADDRESS` | `metrics-address` |
| `--api-address` / `API_ADDRESS` | `api-address` |
| `--shadow` / `SHADOW` | `shadow` |
| `--disable-order-balance-filter` / `DISABLE_ORDER_BALANCE_FILTER` |
`disable-order-balance-filter` |
| `--max-maintenance-timeout` / `MAX_MAINTENANCE_TIMEOUT` |
`max-maintenance-timeout` |
| `--run-loop-native-price-timeout` / `RUN_LOOP_NATIVE_PRICE_TIMEOUT` |
`native-price-timeout` |
| `--unsupported-tokens` / `UNSUPPORTED_TOKENS` | `unsupported-tokens` |
| `--min-order-validity-period` / `MIN_ORDER_VALIDITY_PERIOD` |
`min-order-validity-period` |
| `--max-auction-age` / `MAX_AUCTION_AGE` | `max-auction-age` |

All defaults remain unchanged.
---
 crates/autopilot/src/arguments.rs          | 248 +--------------------
 crates/autopilot/src/config/cow_amm.rs     |  75 +++++++
 crates/autopilot/src/config/ethflow.rs     |  58 +++++
 crates/autopilot/src/config/mod.rs         | 133 ++++++++++-
 crates/autopilot/src/config/run_loop.rs    | 120 ++++++++++
 crates/autopilot/src/run.rs                |  73 +++---
 crates/autopilot/src/run_loop.rs           |  15 ++
 crates/e2e/src/setup/services.rs           |  45 ++--
 crates/e2e/tests/e2e/autopilot_leader.rs   |  39 +++-
 crates/e2e/tests/e2e/cow_amm.rs            |  12 +-
 crates/e2e/tests/e2e/limit_orders.rs       |  27 ++-
 crates/e2e/tests/e2e/solver_competition.rs |   9 +-
 12 files changed, 521 insertions(+), 333 deletions(-)
 create mode 100644 crates/autopilot/src/config/cow_amm.rs
 create mode 100644 crates/autopilot/src/config/ethflow.rs
 create mode 100644 crates/autopilot/src/config/run_loop.rs

diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index a5103885c1..7700ee5bff 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -1,10 +1,4 @@
-use {
-    alloy::primitives::Address,
-    anyhow::Context,
-    shared::{arguments::display_option, http_client},
-    std::{net::SocketAddr, num::NonZeroUsize, path::PathBuf, str::FromStr, time::Duration},
-    url::Url,
-};
+use {shared::http_client, std::path::PathBuf};
 
 #[derive(clap::Parser)]
 pub struct CliArguments {
@@ -22,147 +16,6 @@ pub struct CliArguments {
 
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
-
-    /// Address of the ethflow contracts. If not specified, eth-flow orders are
-    /// disabled.
-    /// In general, one contract is sufficient for the service to function.
-    /// Support for multiple contract was added to support transition period for
-    /// integrators when the migration of the eth-flow contract happens.
-    #[clap(long, env, use_value_delimiter = true)]
-    pub ethflow_contracts: Vec<Address>,
-
-    /// Timestamp at which we should start indexing eth-flow contract events.
-    /// If there are already events in the database for a date later than this,
-    /// then this date is ignored and can be omitted.
-    #[clap(long, env)]
-    pub ethflow_indexing_start: Option<u64>,
-
-    #[clap(long, env, default_value = "0.0.0.0:9589")]
-    pub metrics_address: SocketAddr,
-
-    /// Address to bind the HTTP API server
-    #[clap(long, env, default_value = "0.0.0.0:12088")]
-    pub api_address: SocketAddr,
-
-    /// Skip syncing past events (useful for local deployments)
-    #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]
-    pub skip_event_sync: bool,
-
-    /// List of token addresses to be ignored throughout service
-    #[clap(long, env, use_value_delimiter = true)]
-    pub unsupported_tokens: Vec<Address>,
-
-    /// The minimum amount of time an order has to be valid for.
-    #[clap(
-        long,
-        env,
-        default_value = "1m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub min_order_validity_period: Duration,
-
-    /// If the auction hasn't been updated in this amount of time the pod fails
-    /// the liveness check. Expects a value in seconds.
-    #[clap(
-        long,
-        env,
-        default_value = "5m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub max_auction_age: Duration,
-
-    /// The maximum number of blocks to wait for a settlement to appear on
-    /// chain.
-    #[clap(long, env, default_value = "5")]
-    pub submission_deadline: usize,
-
-    /// The amount of time that the autopilot waits looking for a settlement
-    /// transaction onchain after the driver acknowledges the receipt of a
-    /// settlement.
-    #[clap(
-        long,
-        env,
-        default_value = "1m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub max_settlement_transaction_wait: Duration,
-
-    /// Run the autopilot in a shadow mode by specifying an upstream CoW
-    /// protocol deployment to pull auctions from. This will cause the autopilot
-    /// to start a run loop where it performs solver competition on driver,
-    /// and report and log the winner **without** requesting that any driver
-    /// actually executes any settlements. Note that many of the `autopilot`'s
-    /// typical features will be disabled in this mode, making many options
-    /// ignored. This assumes co-location is enabled and does not require it
-    /// being specified separately.
-    #[clap(long, env)]
-    pub shadow: Option<Url>,
-
-    /// Time solvers have to compute a score per auction.
-    #[clap(
-        long,
-        env,
-        default_value = "15s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub solve_deadline: Duration,
-
-    /// Configurations for indexing CoW AMMs. Supplied in the form of:
-    /// "<factory1>|<helper1>|<block1>,<factory2>|<helper2>,<block2>"
-    /// - factory is contract address emmiting CoW AMM deployment events.
-    /// - helper is a contract address to interface with pools deployed by the
-    ///   factory
-    /// - block is the block at which indexing should start (should be 1 block
-    ///   before the deployment of the factory)
-    #[clap(long, env, use_value_delimiter = true)]
-    pub cow_amm_configs: Vec<CowAmmConfig>,
-
-    /// If a new run loop would start more than this amount of time after the
-    /// system noticed the latest block, wait for the next block to appear
-    /// before continuing the run loop.
-    #[clap(long, env, default_value = "2s", value_parser = humantime::parse_duration)]
-    pub max_run_loop_delay: Duration,
-
-    /// Maximum timeout for fetching the native prices in the run loop
-    /// If the value is 0, the native prices are fetched from the cache
-    #[clap(long, env, default_value = "0s", value_parser = humantime::parse_duration)]
-    pub run_loop_native_price_timeout: Duration,
-
-    #[clap(long, env, default_value = "20")]
-    /// The maximum number of winners per auction. Each winner will be allowed
-    /// to settle their winning orders at the same time.
-    pub max_winners_per_auction: NonZeroUsize,
-
-    #[clap(long, env, default_value = "3")]
-    /// The maximum allowed number of solutions to be proposed from a single
-    /// solver, per auction.
-    pub max_solutions_per_solver: NonZeroUsize,
-
-    /// Archive node URL used to index CoW AMM
-    #[clap(long, env)]
-    pub archive_node_url: Option<Url>,
-
-    /// Configures whether the autopilot filters out orders with insufficient
-    /// balances.
-    #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub disable_order_balance_filter: bool,
-
-    /// Enables the usage of leader lock in the database
-    /// The second instance of autopilot will act as a follower
-    /// and not cut any auctions.
-    #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub enable_leader_lock: bool,
-
-    /// Enables brotli compression of `/solve` request bodies sent to drivers.
-    #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub compress_solve_request: bool,
-
-    /// Limits the amount of time the autopilot may spend running the
-    /// maintenance logic between 2 auctions. When this times out we prefer
-    /// running a not fully updated auction over stalling the protocol any
-    /// further.
-    #[clap(long, env, default_value = "5s", value_parser = humantime::parse_duration)]
-    pub max_maintenance_timeout: Duration,
 }
 
 impl std::fmt::Display for CliArguments {
@@ -173,111 +26,12 @@ impl std::fmt::Display for CliArguments {
             order_quoting,
             http_client,
             price_estimation,
-            ethflow_contracts,
-            ethflow_indexing_start,
-            metrics_address,
-            api_address,
-            skip_event_sync,
-            unsupported_tokens,
-            min_order_validity_period,
-            max_auction_age,
-            submission_deadline,
-            shadow,
-            solve_deadline,
-            max_settlement_transaction_wait,
-            cow_amm_configs,
-            max_run_loop_delay,
-            run_loop_native_price_timeout,
-            max_winners_per_auction,
-            archive_node_url,
-            max_solutions_per_solver,
-            disable_order_balance_filter,
-            enable_leader_lock,
-            compress_solve_request,
-            max_maintenance_timeout,
         } = self;
         write!(f, "{}", config.display())?;
         write!(f, "{shared}")?;
         write!(f, "{order_quoting}")?;
         write!(f, "{http_client}")?;
         write!(f, "{price_estimation}")?;
-        writeln!(f, "ethflow_contracts: {ethflow_contracts:?}")?;
-        writeln!(f, "ethflow_indexing_start: {ethflow_indexing_start:?}")?;
-        writeln!(f, "metrics_address: {metrics_address}")?;
-        writeln!(f, "api_address: {api_address}")?;
-        writeln!(f, "skip_event_sync: {skip_event_sync}")?;
-        writeln!(f, "unsupported_tokens: {unsupported_tokens:?}")?;
-        writeln!(
-            f,
-            "min_order_validity_period: {min_order_validity_period:?}"
-        )?;
-        writeln!(f, "max_auction_age: {max_auction_age:?}")?;
-        writeln!(f, "submission_deadline: {submission_deadline}")?;
-        display_option(f, "shadow", shadow)?;
-        writeln!(f, "solve_deadline: {solve_deadline:?}")?;
-        writeln!(
-            f,
-            "max_settlement_transaction_wait: {max_settlement_transaction_wait:?}"
-        )?;
-        writeln!(f, "cow_amm_configs: {cow_amm_configs:?}")?;
-        writeln!(f, "max_run_loop_delay: {max_run_loop_delay:?}")?;
-        writeln!(
-            f,
-            "run_loop_native_price_timeout: {run_loop_native_price_timeout:?}"
-        )?;
-        writeln!(f, "max_winners_per_auction: {max_winners_per_auction:?}")?;
-        writeln!(f, "archive_node_url: {archive_node_url:?}")?;
-        writeln!(f, "max_solutions_per_solver: {max_solutions_per_solver:?}")?;
-        writeln!(
-            f,
-            "disable_order_balance_filter: {disable_order_balance_filter}"
-        )?;
-        writeln!(f, "enable_leader_lock: {enable_leader_lock}")?;
-        writeln!(f, "compress_solve_request: {compress_solve_request}")?;
-        writeln!(f, "max_maintenance_timeout: {max_maintenance_timeout:?}")?;
         Ok(())
     }
 }
-
-#[derive(Debug, Clone)]
-pub struct CowAmmConfig {
-    /// Which contract to index for CoW AMM deployment events.
-    pub factory: Address,
-    /// Which helper contract to use for interfacing with the indexed CoW AMMs.
-    pub helper: Address,
-    /// At which block indexing should start on the factory.
-    pub index_start: u64,
-}
-
-impl FromStr for CowAmmConfig {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parts = s.split('|');
-        let factory = parts
-            .next()
-            .context("config is missing factory")?
-            .parse()
-            .context("could not parse factory as Address")?;
-        let helper = parts
-            .next()
-            .context("config is missing helper")?
-            .parse()
-            .context("could not parse helper as Address")?;
-        let index_start = parts
-            .next()
-            .context("config is missing index_start")?
-            .parse()
-            .context("could not parse index_start as u64")?;
-        anyhow::ensure!(
-            parts.next().is_none(),
-            "supplied too many arguments for cow amm config"
-        );
-
-        Ok(Self {
-            factory,
-            helper,
-            index_start,
-        })
-    }
-}
diff --git a/crates/autopilot/src/config/cow_amm.rs b/crates/autopilot/src/config/cow_amm.rs
new file mode 100644
index 0000000000..11da3cfd1d
--- /dev/null
+++ b/crates/autopilot/src/config/cow_amm.rs
@@ -0,0 +1,75 @@
+use {
+    alloy::primitives::Address,
+    serde::{Deserialize, Serialize},
+    url::Url,
+};
+
+/// Configuration for indexing CoW AMMs.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct CowAmmGroupConfig {
+    /// List of CoW AMM factory/helper/start-block configurations.
+    #[serde(default)]
+    pub contracts: Vec<CowAmmConfig>,
+
+    /// Archive node URL used to index CoW AMMs.
+    #[serde(default)]
+    pub archive_node_url: Option<Url>,
+}
+
+/// A single CoW AMM factory configuration.
+#[derive(Debug, Clone, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct CowAmmConfig {
+    /// Contract address emitting CoW AMM deployment events.
+    pub factory: Address,
+
+    /// Contract address to interface with pools deployed by the factory.
+    pub helper: Address,
+
+    /// Block at which indexing should start (1 block before factory
+    /// deployment).
+    pub index_start: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, alloy::primitives::address};
+
+    #[test]
+    fn deserialize_defaults() {
+        let config: CowAmmGroupConfig = toml::from_str("").unwrap();
+        assert!(config.contracts.is_empty());
+        assert!(config.archive_node_url.is_none());
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        archive-node-url = "http://archive.example.com"
+
+        [[contracts]]
+        factory = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        helper = "0xdAC17F958D2ee523a2206206994597C13D831ec7"
+        index-start = 12345678
+
+        [[contracts]]
+        factory = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+        helper = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        index-start = 99999999
+        "#;
+        let config: CowAmmGroupConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.contracts.len(), 2);
+        assert_eq!(
+            config.contracts[0].factory,
+            address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")
+        );
+        assert_eq!(config.contracts[0].index_start, 12345678);
+        assert_eq!(
+            config.archive_node_url.unwrap().as_str(),
+            "http://archive.example.com/"
+        );
+    }
+}
diff --git a/crates/autopilot/src/config/ethflow.rs b/crates/autopilot/src/config/ethflow.rs
new file mode 100644
index 0000000000..9f442caebf
--- /dev/null
+++ b/crates/autopilot/src/config/ethflow.rs
@@ -0,0 +1,58 @@
+use {alloy::primitives::Address, serde::Deserialize};
+
+#[derive(Debug, Clone, Default, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct EthflowConfig {
+    /// Address of the ethflow contracts. If empty, eth-flow orders are
+    /// disabled. Multiple contracts supported for migration transition
+    /// periods.
+    #[serde(default)]
+    pub contracts: Vec<Address>,
+
+    /// Timestamp at which we should start indexing eth-flow contract events.
+    /// Ignored if events already exist in the database for a later date.
+    #[serde(default)]
+    pub indexing_start: Option<u64>,
+
+    /// Skip syncing past events (useful for local deployments).
+    #[serde(default)]
+    pub skip_event_sync: bool,
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl configs::test_util::TestDefault for EthflowConfig {
+    fn test_default() -> Self {
+        Self {
+            skip_event_sync: true,
+            // In E2E tests the contracts are added later
+            ..Default::default()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let config: EthflowConfig = toml::from_str("").unwrap();
+        assert!(config.contracts.is_empty());
+        assert!(config.indexing_start.is_none());
+        assert!(!config.skip_event_sync);
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        contracts = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        indexing-start = 12345678
+        skip-event-sync = true
+        "#;
+        let config: EthflowConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.contracts.len(), 1);
+        assert_eq!(config.indexing_start, Some(12345678));
+        assert!(config.skip_event_sync);
+    }
+}
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index a96a51ceb7..283e401c64 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -1,27 +1,55 @@
 use {
     crate::config::{
         banned_users::BannedUsersConfig,
+        cow_amm::CowAmmGroupConfig,
+        ethflow::EthflowConfig,
         fee_policy::FeePoliciesConfig,
         native_price::NativePriceConfig,
         order_events_cleanup::OrderEventsCleanupConfig,
+        run_loop::RunLoopConfig,
         s3::S3Config,
         solver::Solver,
         trusted_tokens::TrustedTokensConfig,
     },
+    alloy::primitives::Address,
     anyhow::{anyhow, ensure},
     configs::database::DatabasePoolConfig,
     serde::Deserialize,
-    std::path::Path,
+    std::{net::SocketAddr, path::Path, time::Duration},
+    url::Url,
 };
 
 pub mod banned_users;
+pub mod cow_amm;
+pub mod ethflow;
 pub mod fee_policy;
 pub mod native_price;
 pub mod order_events_cleanup;
+pub mod run_loop;
 pub mod s3;
 pub mod solver;
 pub mod trusted_tokens;
 
+fn default_metrics_address() -> SocketAddr {
+    "0.0.0.0:9589".parse().unwrap()
+}
+
+fn default_api_address() -> SocketAddr {
+    "0.0.0.0:12088".parse().unwrap()
+}
+
+const fn default_max_maintenance_timeout() -> Duration {
+    Duration::from_secs(5)
+}
+
+const fn default_min_order_validity_period() -> Duration {
+    Duration::from_mins(1)
+}
+
+const fn default_max_auction_age() -> Duration {
+    Duration::from_mins(5)
+}
+
 // Does not implement Default because `native_price_estimation` *cannot* have
 // empty `estimators`, as such, we cannot provide a proper default value for
 // this structure.
@@ -53,10 +81,69 @@ pub struct Configuration {
     /// If absent, S3 uploads are disabled.
     pub s3: Option<S3Config>,
 
+    /// Configuration for native token price estimation strategies.
     pub native_price_estimation: NativePriceConfig,
 
+    /// Database connection pool settings.
     #[serde(default)]
     pub database: DatabasePoolConfig,
+
+    /// Configuration for eth-flow order indexing and processing.
+    #[serde(default)]
+    pub ethflow: EthflowConfig,
+
+    /// Run the autopilot in shadow mode by specifying an upstream CoW protocol
+    /// deployment to pull auctions from. The autopilot performs solver
+    /// competition and logs the winner without executing settlements.
+    #[serde(default)]
+    pub shadow: Option<Url>,
+
+    /// Address to bind the metrics server.
+    #[serde(default = "default_metrics_address")]
+    pub metrics_address: SocketAddr,
+
+    /// Address to bind the HTTP API server.
+    #[serde(default = "default_api_address")]
+    pub api_address: SocketAddr,
+
+    /// Configuration for CoW AMM indexing and archive node access.
+    #[serde(default)]
+    pub cow_amm: CowAmmGroupConfig,
+
+    /// Configuration for the autopilot's main auction run loop.
+    #[serde(default)]
+    pub run_loop: RunLoopConfig,
+
+    /// Maximum timeout for fetching native prices in the run loop.
+    /// If 0, native prices are fetched from cache.
+    #[serde(with = "humantime_serde", default)]
+    pub native_price_timeout: Duration,
+
+    /// Whether to skip filtering out orders with insufficient balances.
+    #[serde(default)]
+    pub disable_order_balance_filter: bool,
+
+    /// Maximum time the autopilot may spend on maintenance logic between
+    /// two auctions. When exceeded, a not-fully-updated auction runs instead
+    /// of stalling.
+    #[serde(with = "humantime_serde", default = "default_max_maintenance_timeout")]
+    pub max_maintenance_timeout: Duration,
+
+    /// List of token addresses to be ignored throughout service
+    #[serde(default)]
+    pub unsupported_tokens: Vec<Address>,
+
+    /// The minimum amount of time an order has to be valid for.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_min_order_validity_period"
+    )]
+    pub min_order_validity_period: Duration,
+
+    /// If the auction hasn't been updated in this amount of time the pod fails
+    /// the liveness check. Expects a value in seconds.
+    #[serde(with = "humantime_serde", default = "default_max_auction_age")]
+    pub max_auction_age: Duration,
 }
 
 impl Configuration {
@@ -104,6 +191,18 @@ impl Configuration {
             s3: Default::default(),
             native_price_estimation: NativePriceConfig::test_default(),
             database: DatabasePoolConfig::test_default(),
+            ethflow: TestDefault::test_default(),
+            shadow: Default::default(),
+            metrics_address: default_metrics_address(),
+            api_address: default_api_address(),
+            cow_amm: Default::default(),
+            run_loop: TestDefault::test_default(),
+            disable_order_balance_filter: false,
+            max_maintenance_timeout: default_max_maintenance_timeout(),
+            native_price_timeout: Duration::from_millis(500),
+            unsupported_tokens: Default::default(),
+            min_order_validity_period: default_min_order_validity_period(),
+            max_auction_age: default_max_auction_age(),
         }
     }
 
@@ -119,6 +218,18 @@ impl Configuration {
             s3: Default::default(),
             native_price_estimation: NativePriceConfig::test_default(),
             database: DatabasePoolConfig::test_default(),
+            ethflow: TestDefault::test_default(),
+            shadow: Default::default(),
+            metrics_address: default_metrics_address(),
+            api_address: default_api_address(),
+            cow_amm: Default::default(),
+            run_loop: TestDefault::test_default(),
+            disable_order_balance_filter: false,
+            max_maintenance_timeout: default_max_maintenance_timeout(),
+            native_price_timeout: Duration::from_millis(500),
+            unsupported_tokens: Default::default(),
+            min_order_validity_period: default_min_order_validity_period(),
+            max_auction_age: default_max_auction_age(),
         }
     }
 
@@ -159,6 +270,11 @@ mod tests {
     #[test]
     fn deserialize_full_configuration() {
         let toml = r#"
+        unsupported-tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        min-order-validity-period = "2m"
+        max-auction-age = "10m"
+        native-price-timeout = "3s"
+
         [[drivers]]
         name = "solver1"
         url = "http://localhost:8080"
@@ -210,6 +326,7 @@ mod tests {
             [{type = "Driver", name = "solver1", url = "http://localhost:8080"}],
             [{type = "Forwarder", url = "http://localhost:12088"}],
         ]
+
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -290,6 +407,15 @@ mod tests {
                 }],
             ]
         );
+
+        assert_eq!(config.unsupported_tokens.len(), 1);
+        assert_eq!(
+            config.unsupported_tokens[0],
+            address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")
+        );
+        assert_eq!(config.min_order_validity_period, Duration::from_secs(120));
+        assert_eq!(config.max_auction_age, Duration::from_secs(600));
+        assert_eq!(config.native_price_timeout, Duration::from_secs(3));
     }
 
     #[test]
@@ -344,6 +470,11 @@ mod tests {
         assert_eq!(config.banned_users.max_cache_size.get(), 10000);
 
         assert!(config.s3.is_none());
+
+        assert!(config.unsupported_tokens.is_empty());
+        assert_eq!(config.min_order_validity_period, Duration::from_secs(60));
+        assert_eq!(config.max_auction_age, Duration::from_secs(300));
+        assert_eq!(config.native_price_timeout, Duration::ZERO);
     }
 
     #[test]
diff --git a/crates/autopilot/src/config/run_loop.rs b/crates/autopilot/src/config/run_loop.rs
new file mode 100644
index 0000000000..da9183a378
--- /dev/null
+++ b/crates/autopilot/src/config/run_loop.rs
@@ -0,0 +1,120 @@
+use {
+    serde::Deserialize,
+    std::{num::NonZeroUsize, time::Duration},
+};
+
+const fn default_max_delay() -> Duration {
+    Duration::from_secs(2)
+}
+
+const fn default_max_winners_per_auction() -> NonZeroUsize {
+    NonZeroUsize::new(20).unwrap()
+}
+
+const fn default_max_solutions_per_solver() -> NonZeroUsize {
+    NonZeroUsize::new(3).unwrap()
+}
+
+const fn default_submission_deadline() -> u64 {
+    5
+}
+
+const fn default_max_settlement_transaction_wait() -> Duration {
+    Duration::from_mins(1)
+}
+
+const fn default_solve_deadline() -> Duration {
+    Duration::from_mins(15)
+}
+
+/// Configuration for the autopilot run loop timing.
+#[derive(Debug, Clone, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct RunLoopConfig {
+    /// If a new run loop iteration would start more than this duration after
+    /// the latest block was noticed, wait for the next block before continuing.
+    #[serde(with = "humantime_serde", default = "default_max_delay")]
+    pub max_delay: Duration,
+
+    /// Maximum number of winners per auction. Each winner settles their
+    /// winning orders concurrently.
+    #[serde(default = "default_max_winners_per_auction")]
+    pub max_winners_per_auction: NonZeroUsize,
+
+    /// Maximum number of solutions a single solver may propose per auction.
+    #[serde(default = "default_max_solutions_per_solver")]
+    pub max_solutions_per_solver: NonZeroUsize,
+
+    /// Enable leader lock in the database; the follower instance will not
+    /// cut auctions.
+    #[serde(default)]
+    pub enable_leader_lock: bool,
+
+    /// Enable brotli compression of `/solve` request bodies sent to drivers.
+    #[serde(default)]
+    pub compress_solve_request: bool,
+
+    /// The maximum number of blocks to wait for a settlement to appear on
+    /// chain.
+    #[serde(default = "default_submission_deadline")]
+    pub submission_deadline: u64,
+
+    /// The amount of time that the autopilot waits looking for a settlement
+    /// transaction onchain after the driver acknowledges the receipt of a
+    /// settlement.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_max_settlement_transaction_wait"
+    )]
+    pub max_settlement_transaction_wait: Duration,
+
+    /// Time solvers have to compute a score per auction.
+    #[serde(with = "humantime_serde", default = "default_solve_deadline")]
+    pub solve_deadline: Duration,
+}
+
+impl Default for RunLoopConfig {
+    fn default() -> Self {
+        Self {
+            max_delay: default_max_delay(),
+            max_winners_per_auction: default_max_winners_per_auction(),
+            max_solutions_per_solver: default_max_solutions_per_solver(),
+            enable_leader_lock: false,
+            compress_solve_request: false,
+            submission_deadline: default_submission_deadline(),
+            max_settlement_transaction_wait: default_max_settlement_transaction_wait(),
+            solve_deadline: default_solve_deadline(),
+        }
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl configs::test_util::TestDefault for RunLoopConfig {
+    fn test_default() -> Self {
+        Self {
+            max_delay: Duration::from_millis(100),
+            ..Default::default()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let config: RunLoopConfig = toml::from_str("").unwrap();
+        assert_eq!(config.max_delay, Duration::from_secs(2));
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        max-delay = "5s"
+        "#;
+        let config: RunLoopConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.max_delay, Duration::from_secs(5));
+    }
+}
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 3f8a43c838..00e84586b5 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -151,7 +151,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
 
     observe::metrics::setup_registry(Some("gp_v2_autopilot".into()), None);
 
-    if args.shadow.is_some() {
+    if config.shadow.is_some() {
         shadow_mode(args, config).await;
     } else {
         run(args, config, ShutdownController::default()).await;
@@ -164,7 +164,7 @@ pub async fn run(
     config: Configuration,
     shutdown_controller: ShutdownController,
 ) {
-    assert!(args.shadow.is_none(), "cannot run in shadow mode");
+    assert!(config.shadow.is_none(), "cannot run in shadow mode");
     let db_write = Postgres::new(
         config.database.write_url.as_str(),
         crate::database::Config {
@@ -268,7 +268,7 @@ pub async fn run(
         .expect("failed to create gas price estimator"),
     );
 
-    let deny_listed_tokens = DenyListedTokens::new(args.unsupported_tokens.clone());
+    let deny_listed_tokens = DenyListedTokens::new(config.unsupported_tokens.clone());
 
     let token_info_fetcher = Arc::new(CachedTokenInfoFetcher::new(Arc::new(TokenInfoFetcher {
         web3: web3.clone(),
@@ -367,7 +367,7 @@ pub async fn run(
         )
         .unwrap();
 
-    let skip_event_sync_start = if args.skip_event_sync {
+    let skip_event_sync_start = if config.ethflow.skip_event_sync {
         Some(
             block_number_to_block_number_hash(&web3.provider, BlockNumberOrTag::Latest)
                 .await
@@ -408,20 +408,24 @@ pub async fn run(
         skip_event_sync_start,
     );
 
-    let archive_node_web3 = args.archive_node_url.as_ref().map_or(web3.clone(), |url| {
-        boundary::web3_client(url, &args.shared.ethrpc)
-    });
+    let archive_node_web3 = config
+        .cow_amm
+        .archive_node_url
+        .as_ref()
+        .map_or(web3.clone(), |url| {
+            boundary::web3_client(url, &args.shared.ethrpc)
+        });
 
     let mut cow_amm_registry = cow_amm::Registry::new(Arc::new(BlockRetriever {
         provider: archive_node_web3.provider,
         block_stream: eth.current_block().clone(),
     }));
-    for config in &args.cow_amm_configs {
+    for cow_amm_config in &config.cow_amm.contracts {
         cow_amm_registry
             .add_listener(
-                config.index_start,
-                config.factory,
-                config.helper,
+                cow_amm_config.index_start,
+                cow_amm_config.factory,
+                cow_amm_config.helper,
                 db_write.pool.clone(),
             )
             .await;
@@ -452,7 +456,7 @@ pub async fn run(
     ));
 
     let solvable_orders_cache = SolvableOrdersCache::new(
-        args.min_order_validity_period,
+        config.min_order_validity_period,
         persistence.clone(),
         infra::banned::Users::new(
             eth.contracts().chainalysis_oracle().clone(),
@@ -469,17 +473,17 @@ pub async fn run(
             args.shared.enable_sell_equals_buy_volume_fee,
         ),
         cow_amm_registry.clone(),
-        args.run_loop_native_price_timeout,
+        config.native_price_timeout,
         *eth.contracts().settlement().address(),
-        args.disable_order_balance_filter,
+        config.disable_order_balance_filter,
     );
 
-    let liveness = Arc::new(Liveness::new(args.max_auction_age));
+    let liveness = Arc::new(Liveness::new(config.max_auction_age));
     let startup = Arc::new(Some(AtomicBool::new(false)));
 
     let (api_shutdown_sender, api_shutdown_receiver) = tokio::sync::oneshot::channel();
     let api_task = tokio::spawn(infra::api::serve(
-        args.api_address,
+        config.api_address,
         api_native_price_estimator,
         args.price_estimation.quote_timeout,
         api_shutdown_receiver,
@@ -487,7 +491,7 @@ pub async fn run(
 
     observe::metrics::serve_metrics(
         liveness.clone(),
-        args.metrics_address,
+        config.metrics_address,
         Default::default(),
         startup.clone(),
     );
@@ -527,10 +531,10 @@ pub async fn run(
     );
     maintenance.add_cow_amm_indexer(&cow_amm_registry);
 
-    if !args.ethflow_contracts.is_empty() {
+    if !config.ethflow.contracts.is_empty() {
         let ethflow_refund_start_block = determine_ethflow_refund_indexing_start(
             &skip_event_sync_start,
-            args.ethflow_indexing_start,
+            config.ethflow.indexing_start,
             &web3,
             chain_id,
             db_write.clone(),
@@ -540,7 +544,7 @@ pub async fn run(
         let refund_event_handler = EventUpdater::new_skip_blocks_before(
             // This cares only about ethflow refund events because all the other ethflow
             // events are already indexed by the OnchainOrderParser.
-            EthFlowRefundRetriever::new(web3.clone(), args.ethflow_contracts.clone()),
+            EthFlowRefundRetriever::new(web3.clone(), config.ethflow.contracts.clone()),
             db_write.clone(),
             block_retriever.clone(),
             ethflow_refund_start_block,
@@ -562,7 +566,7 @@ pub async fn run(
 
         let ethflow_start_block = determine_ethflow_indexing_start(
             &skip_event_sync_start,
-            args.ethflow_indexing_start,
+            config.ethflow.indexing_start,
             &web3,
             chain_id,
             &db_write,
@@ -572,7 +576,7 @@ pub async fn run(
         let onchain_order_indexer = EventUpdater::new_skip_blocks_before(
             // The events from the ethflow contract are read with the more generic contract
             // interface called CoWSwapOnchainOrders.
-            CoWSwapOnchainOrdersContract::new(web3.clone(), args.ethflow_contracts),
+            CoWSwapOnchainOrdersContract::new(web3.clone(), config.ethflow.contracts),
             onchain_order_event_parser,
             block_retriever,
             ethflow_start_block,
@@ -584,16 +588,7 @@ pub async fn run(
         maintenance.add_ethflow_indexing(onchain_order_indexer, refund_event_handler);
     }
 
-    let run_loop_config = run_loop::Config {
-        submission_deadline: args.submission_deadline as u64,
-        max_settlement_transaction_wait: args.max_settlement_transaction_wait,
-        solve_deadline: args.solve_deadline,
-        max_run_loop_delay: args.max_run_loop_delay,
-        max_winners_per_auction: args.max_winners_per_auction,
-        max_solutions_per_solver: args.max_solutions_per_solver,
-        enable_leader_lock: args.enable_leader_lock,
-        compress_solve_request: args.compress_solve_request,
-    };
+    let run_loop_config = run_loop::Config::from(config.run_loop);
 
     let drivers_futures = config
         .drivers
@@ -613,7 +608,7 @@ pub async fn run(
         .collect();
 
     let awaiter = maintenance
-        .spawn_maintenance_task(eth.current_block().clone(), args.max_maintenance_timeout);
+        .spawn_maintenance_task(eth.current_block().clone(), config.max_maintenance_timeout);
 
     let run = RunLoop::new(
         run_loop_config,
@@ -639,7 +634,7 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
 
     let orderbook = infra::shadow::Orderbook::new(
         http_factory.create(),
-        args.shadow.expect("missing shadow mode configuration"),
+        config.shadow.expect("missing shadow mode configuration"),
     );
 
     let drivers_futures = config
@@ -698,10 +693,10 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
         .await
     };
 
-    let liveness = Arc::new(Liveness::new(args.max_auction_age));
+    let liveness = Arc::new(Liveness::new(config.max_auction_age));
     observe::metrics::serve_metrics(
         liveness.clone(),
-        args.metrics_address,
+        config.metrics_address,
         Default::default(),
         Default::default(),
     );
@@ -717,11 +712,11 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
         orderbook,
         drivers,
         trusted_tokens,
-        args.solve_deadline,
-        args.compress_solve_request,
+        config.run_loop.solve_deadline,
+        config.run_loop.compress_solve_request,
         liveness.clone(),
         current_block,
-        args.max_winners_per_auction,
+        config.run_loop.max_winners_per_auction,
         (*weth.address()).into(),
     );
     shadow.run_forever().await;
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 254fff49be..d2ebd01f16 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -68,6 +68,21 @@ pub struct Config {
     pub compress_solve_request: bool,
 }
 
+impl From<crate::config::run_loop::RunLoopConfig> for Config {
+    fn from(value: crate::config::run_loop::RunLoopConfig) -> Self {
+        Self {
+            submission_deadline: value.submission_deadline,
+            max_settlement_transaction_wait: value.max_settlement_transaction_wait,
+            solve_deadline: value.solve_deadline,
+            max_run_loop_delay: value.max_delay,
+            max_winners_per_auction: value.max_winners_per_auction,
+            max_solutions_per_solver: value.max_solutions_per_solver,
+            enable_leader_lock: value.enable_leader_lock,
+            compress_solve_request: value.compress_solve_request,
+        }
+    }
+}
+
 pub struct Probes {
     pub liveness: Arc<Liveness>,
     pub startup: Arc<Option<AtomicBool>>,
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 307e7261a9..8a1bdbd033 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -16,7 +16,12 @@ use {
     },
     app_data::{AppDataDocument, AppDataHash},
     autopilot::{
-        config::{Configuration, native_price::NativePriceConfig},
+        config::{
+            Configuration,
+            ethflow::EthflowConfig,
+            native_price::NativePriceConfig,
+            run_loop::RunLoopConfig,
+        },
         infra::persistence::dto,
     },
     clap::Parser,
@@ -189,27 +194,29 @@ impl<'a> Services<'a> {
             .contracts
             .ethflows
             .iter()
-            .map(|c| format!("{:?}", c.address()))
-            .collect::<Vec<_>>()
-            .join(",");
+            .map(|c| *c.address())
+            .collect::<Vec<_>>();
+
+        let config = autopilot::config::Configuration {
+            ethflow: EthflowConfig {
+                contracts: ethflow_contracts,
+                ..config.ethflow
+            },
+            run_loop: RunLoopConfig {
+                solve_deadline,
+                ..config.run_loop
+            },
+            ..config
+        };
 
         let (_autopilot_config_file, autopilot_config_arg) = config.to_cli_args();
 
-        let args = [
-            "autopilot".to_string(),
-            "--max-run-loop-delay=100ms".to_string(),
-            "--run-loop-native-price-timeout=500ms".to_string(),
-            format!("--ethflow-contracts={ethflow_contracts}"),
-            "--skip-event-sync=true".to_string(),
-            "--api-address=0.0.0.0:12088".to_string(),
-            format!("--solve-deadline={solve_deadline:?}"),
-            autopilot_config_arg,
-        ]
-        .into_iter()
-        .chain(self.api_autopilot_solver_arguments())
-        .chain(self.autopilot_arguments())
-        .chain(extra_args)
-        .collect();
+        let args = ["autopilot".to_string(), autopilot_config_arg]
+            .into_iter()
+            .chain(self.api_autopilot_solver_arguments())
+            .chain(self.autopilot_arguments())
+            .chain(extra_args)
+            .collect();
         let args = ignore_overwritten_cli_params(args);
 
         let args = autopilot::arguments::CliArguments::try_parse_from(args)
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index beabd3a31f..98c09858c3 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -1,5 +1,8 @@
 use {
-    autopilot::{config::Configuration, shutdown_controller::ShutdownController},
+    autopilot::{
+        config::{Configuration, run_loop::RunLoopConfig},
+        shutdown_controller::ShutdownController,
+    },
     configs::test_util::TestDefault,
     e2e::setup::{
         OnchainComponents,
@@ -86,6 +89,17 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
         ],
     );
 
+    let leader_config = Configuration::test("test_solver", solver1.address());
+    let leader_config = Configuration {
+        metrics_address: "0.0.0.0:9590".parse().unwrap(),
+        api_address: "0.0.0.0:12088".parse().unwrap(),
+        run_loop: RunLoopConfig {
+            enable_leader_lock: true,
+            ..leader_config.run_loop
+        },
+        ..leader_config
+    };
+
     let autopilot_leader = services
         .start_autopilot_with_shutdown_controller(
             None,
@@ -93,16 +107,23 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-                "--metrics-address=0.0.0.0:9590".to_string(),
-                "--api-address=0.0.0.0:12088".to_string(),
-                "--enable-leader-lock=true".to_string(),
             ],
-            // Configure autopilot-leader only with test_solver
-            Configuration::test("test_solver", solver1.address()),
+            leader_config,
             control,
         )
         .await;
 
+    let follower_config = Configuration::test("test_solver2", solver2.address());
+    let follower_config = Configuration {
+        metrics_address: "0.0.0.0:9591".parse().unwrap(),
+        api_address: "0.0.0.0:12089".parse().unwrap(),
+        run_loop: RunLoopConfig {
+            enable_leader_lock: true,
+            ..follower_config.run_loop
+        },
+        ..follower_config
+    };
+
     let _autopilot_follower = services
         .start_autopilot(
             None,
@@ -110,12 +131,8 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2"
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-                "--metrics-address=0.0.0.0:9591".to_string(),
-                "--api-address=0.0.0.0:12089".to_string(),
-                "--enable-leader-lock=true".to_string(),
             ],
-            // Configure autopilot-backup only with test_solver2
-            Configuration::test("test_solver2", solver2.address()),
+            follower_config,
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 0ea1f12a94..b750748832 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -565,16 +565,22 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
             vec![
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
-                // it uses an older helper contract that was deployed before the desired cow amm
-                "--cow-amm-configs=0xf76c421bAb7df8548604E60deCCcE50477C10462|0x3FF0041A614A9E6Bf392cbB961C97DA214E9CB31|20476672".to_string()
             ],
             Configuration {
                 drivers: vec![
                     Solver::test("test_solver", solver.address()),
                     Solver::test("mock_solver", solver.address()),
                 ],
+                cow_amm: autopilot::config::cow_amm::CowAmmGroupConfig {
+                    contracts: vec![autopilot::config::cow_amm::CowAmmConfig {
+                        factory: address!("f76c421bAb7df8548604E60deCCcE50477C10462"),
+                        helper: address!("3FF0041A614A9E6Bf392cbB961C97DA214E9CB31"),
+                        index_start: 20476672,
+                    }],
+                    ..Default::default()
+                },
                 ..Configuration::test_no_drivers()
-            }
+            },
         )
         .await;
     services
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index a73c1d47ad..e99da742b6 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -7,6 +7,7 @@ use {
     autopilot::config::{
         Configuration,
         fee_policy::{FeePoliciesConfig, FeePolicy, FeePolicyKind},
+        run_loop::RunLoopConfig,
         solver::{Account, Solver},
     },
     bigdecimal::BigDecimal,
@@ -349,20 +350,22 @@ async fn two_limit_orders_test(web3: Web3) {
     let backend: Url = "http://0.0.0.0:11088".parse().unwrap();
     let _proxy = ReverseProxy::start_with_callback(proxy_addr, &[backend], on_request);
 
+    let config = Configuration::test_no_drivers();
     let config = Configuration {
         drivers: vec![Solver::new(
             "test_solver".to_string(),
             "http://localhost:11089/test_solver".parse().unwrap(),
             Account::Address(solver.address()),
         )],
-        ..Configuration::test_no_drivers()
+        run_loop: RunLoopConfig {
+            compress_solve_request: true,
+            ..config.run_loop
+        },
+        ..config
     };
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec!["--compress-solve-request=true".to_string()],
-                ..Default::default()
-            },
+            ExtraServiceArgs::default(),
             config,
             orderbook::config::Configuration::test_default(),
             solver,
@@ -556,12 +559,12 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
 
     // Start autopilot only once all the orders are created.
 
+    let config = Configuration::test_no_drivers();
     services
         .start_autopilot(
             None,
             vec![
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-                "--max-winners-per-auction=2".to_string(),
             ],
             Configuration {
                 drivers: vec![
@@ -572,7 +575,11 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
                     ),
                     Solver::test("solver2", solver_b.address()),
                 ],
-                ..Configuration::test_no_drivers()
+                run_loop: RunLoopConfig {
+                    max_winners_per_auction: std::num::NonZeroUsize::new(2).unwrap(),
+                    ..config.run_loop
+                },
+                ..config
             },
         )
         .await;
@@ -1166,12 +1173,10 @@ async fn no_liquidity_limit_order(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![format!("--unsupported-tokens={:#x}", unsupported.address())],
-                ..Default::default()
-            },
+            ExtraServiceArgs::default(),
             Configuration {
                 drivers: vec![Solver::test("test_solver", solver.address())],
+                unsupported_tokens: vec![*unsupported.address()],
                 fee_policies: FeePoliciesConfig {
                     policies: vec![
                         FeePolicy {
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index a880f1482c..2f0913a655 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -2,6 +2,7 @@ use {
     ::alloy::primitives::{U256, address},
     autopilot::config::{
         Configuration,
+        run_loop::RunLoopConfig,
         solver::{Account, Solver},
     },
     configs::test_util::TestDefault,
@@ -404,20 +405,24 @@ async fn store_filtered_solutions(web3: Web3) {
 
     // We start the quoter as the baseline solver, and the mock solver as the one
     // returning the solution
+    let config = Configuration::test_no_drivers();
     services
         .start_autopilot(
             None,
             vec![
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
-                "--max-winners-per-auction=10".to_string(),
             ],
             Configuration {
                 drivers: vec![
                     Solver::test("good_solver", good_solver_account.address()),
                     Solver::test("bad_solver", bad_solver_account.address()),
                 ],
-                ..Configuration::test_no_drivers()
+                run_loop: RunLoopConfig {
+                    max_winners_per_auction: std::num::NonZeroUsize::new(10).unwrap(),
+                    ..config.run_loop
+                },
+                ..config
             },
         )
         .await;

From cd9c49b3dbdb1b950e17fc7105f7a3d447468d90 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Tue, 10 Mar 2026 12:40:48 +0100
Subject: [PATCH 131/219] Don't consider inflight orders invalid (#4241)

# Description

When I was working on another feature (the debug endpoint) I noticed
that there is a race condition where we sometimes insert "invalid" order
event to the DB.

From logs
```
09:19:13.717  stored order events label=Executing count=1
09:19:13.733  filtered orders reason=insufficient_balance count=1 orders=[0x060a...]
09:19:13.737  stored order events label=Invalid count=1
09:19:13.756  stored order events label=Traded count=1
```

Order is in `executing` state, then settles onchain. If the indexing
runs now and we set the order to `traded` all is well. However if the in
cache update runs first it's possible the wallet no longer has the
necessary balance as it was traded away in the just executed swap and we
consider it invalid and we insert the invalid event for an order that
went through perfectly well.

# Changes

* [x] Don't consider in-flight orders invalid
* [x] Move in-flight filtering logic from run loop to solvable_orders
(move upstream)

## How to test

I had an e2e test to reproduce this which failed 6/10 times. After the
fix it fails 0/10.

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 Cargo.lock                              |  6 +--
 crates/autopilot/src/run_loop.rs        | 31 -------------
 crates/autopilot/src/solvable_orders.rs | 61 ++++++++++++++++++++++---
 3 files changed, 58 insertions(+), 40 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2a0e6d2759..af97bdb6f6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2798,7 +2798,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ab67060fc6b8ef687992d439ca0fa36e7ed17e9a0b16b25b601e8757df720de"
 dependencies = [
  "data-encoding",
- "syn 2.0.114",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -5703,9 +5703,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.13"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
  "aws-lc-rs",
  "bytes",
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index d2ebd01f16..a0651475f4 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -281,7 +281,6 @@ impl RunLoop {
             tracing::debug!("no current auction");
             return None;
         };
-        let auction = self.remove_in_flight_orders(auction).await;
         let id = self
             .persistence
             .get_next_auction_id()
@@ -886,36 +885,6 @@ impl RunLoop {
         }
         Err(SettleError::Timeout)
     }
-
-    /// Removes orders that are currently being settled to avoid solver
-    /// solutions conflicting with each other.
-    #[instrument(skip_all)]
-    async fn remove_in_flight_orders(
-        &self,
-        mut auction: domain::RawAuctionData,
-    ) -> domain::RawAuctionData {
-        let in_flight = self
-            .persistence
-            .fetch_in_flight_orders(auction.block)
-            .await
-            .inspect_err(|err| tracing::warn!(?err, "failed to fetch in-flight orders"))
-            .unwrap_or_default();
-
-        if in_flight.is_empty() {
-            return auction;
-        };
-
-        auction.orders.retain(|o| !in_flight.contains(&o.uid));
-        auction
-            .surplus_capturing_jit_order_owners
-            .retain(|owner| !in_flight.iter().any(|i| i.owner() == *owner));
-        tracing::debug!(
-            orders = ?in_flight,
-            "filtered out in-flight orders and surplus_capturing_jit_order_owners"
-        );
-
-        auction
-    }
 }
 
 #[derive(Debug, thiserror::Error)]
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index f66c86a8ec..3167033aa2 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -202,11 +202,11 @@ impl SolvableOrdersCache {
         let db_solvable_orders = self.get_solvable_orders().await?;
         tracing::trace!("fetched solvable orders from db");
 
-        let orders = db_solvable_orders
+        let orders: Vec<&Order> = db_solvable_orders
             .orders
             .values()
             .map(|order| order.as_ref())
-            .collect::<Vec<_>>();
+            .collect();
 
         let mut invalid_order_uids = HashSet::new();
         let mut filtered_order_events = Vec::new();
@@ -222,7 +222,7 @@ impl SolvableOrdersCache {
             .map(|order| order.metadata.uid)
             .collect();
 
-        let (balances, orders, cow_amms) = {
+        let (balances, orders, cow_amms, in_flight) = {
             let queries = orders
                 .iter()
                 .map(|o| Query::from_order(o))
@@ -231,9 +231,18 @@ impl SolvableOrdersCache {
                 self.fetch_balances(queries),
                 self.filter_invalid_orders(orders, &mut invalid_order_uids),
                 self.timed_future("cow_amm_registry", self.cow_amm_registry.amms()),
+                self.fetch_in_flight_orders(block),
             )
         };
 
+        // Remove in-flight orders - already won a previous auction, being settled
+        // on-chain.
+        let (orders, removed) = filter_out_in_flight_orders(orders, &in_flight);
+        Metrics::track_filtered_orders("in_flight", &removed);
+        // It's possible that some orders got marked as invalid due to missing balance
+        // or so, but the order is perfectly fine if it's in-flight
+        invalid_order_uids.retain(|uid| !in_flight.contains(uid));
+
         let orders = if self.disable_order_balance_filter {
             orders
         } else {
@@ -306,9 +315,23 @@ impl SolvableOrdersCache {
             );
         }
 
-        let surplus_capturing_jit_order_owners = cow_amms
+        let in_flight_owners: HashSet<_> = in_flight
+            .iter()
+            .map(|uid| domain::OrderUid(uid.0).owner())
+            .collect();
+        let surplus_capturing_jit_order_owners: Vec<_> = cow_amms
             .iter()
             .filter(|cow_amm| {
+                // Orders rebalancing cow amms revert when the cow amm does not have exactly the
+                // state the order was crafted for so having multiple orders in-flight for the
+                // same cow amm is an issue. Additionally an amm can be rebalanced in many
+                // different ways which would all result in different order UIDs so filtering
+                // based on that is not sufficient. That's way we check if there is any order
+                // in-flight for that amm based on the owner of the order (i.e. the cow amm) and
+                // then discard that amm altogether for that auction.
+                if in_flight_owners.contains(cow_amm.address()) {
+                    return false;
+                }
                 cow_amm.traded_tokens().iter().all(|token| {
                     let price_exist = prices.contains_key(token);
                     if !price_exist {
@@ -322,7 +345,7 @@ impl SolvableOrdersCache {
                 })
             })
             .map(|cow_amm| *cow_amm.address())
-            .collect::<Vec<_>>();
+            .collect();
         let auction = domain::RawAuctionData {
             block,
             orders: tracing::info_span!("assemble_orders").in_scope(|| {
@@ -359,7 +382,17 @@ impl SolvableOrdersCache {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    async fn fetch_in_flight_orders(&self, block: u64) -> HashSet<OrderUid> {
+        self.persistence
+            .fetch_in_flight_orders(block)
+            .await
+            .inspect_err(|err| tracing::warn!(?err, "failed to fetch in-flight orders"))
+            .unwrap_or_default()
+            .into_iter()
+            .map(|uid| OrderUid(uid.0))
+            .collect()
+    }
+
     async fn fetch_balances(&self, queries: Vec<Query>) -> HashMap<Query, U256> {
         let fetched_balances = self
             .timed_future(
@@ -684,6 +717,22 @@ fn find_unsupported_tokens(
         .collect()
 }
 
+fn filter_out_in_flight_orders<'a>(
+    mut orders: Vec<&'a Order>,
+    in_flight: &HashSet<OrderUid>,
+) -> (Vec<&'a Order>, Vec<OrderUid>) {
+    let mut removed = vec![];
+    orders.retain(|order| {
+        if in_flight.contains(&order.metadata.uid) {
+            removed.push(order.metadata.uid);
+            false
+        } else {
+            true
+        }
+    });
+    (orders, removed)
+}
+
 #[cfg(test)]
 mod tests {
     use {

From f6afe62f9ba5d6a783d4206106ec8dc15f1d9291 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 10 Mar 2026 13:47:40 +0000
Subject: [PATCH 132/219] Upgrade quinn-proto to 0.11.14 (#4245)

# Description
Cargo audit started flagging version 0.11.13, this PR upgrades it to
solve the audit issue

# Changes

* Upgrade quinn-proto to 0.11.14

## How to test
cargo-audit

From 1e76a4901e13a1d73d5accd766f34a6623552b15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 10 Mar 2026 16:11:39 +0000
Subject: [PATCH 133/219] Update trivy action (#4248)

# Description
Updates the failing trivy action

# Changes

* Bump trivy to 0.35

## How to test
CI
---
 .github/workflows/pull-request.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/pull-request.yaml b/.github/workflows/pull-request.yaml
index 2ab6e1932f..fae8ae9a88 100644
--- a/.github/workflows/pull-request.yaml
+++ b/.github/workflows/pull-request.yaml
@@ -44,7 +44,7 @@ jobs:
           persist-credentials: false
 
       - name: Run Trivy
-        uses: aquasecurity/trivy-action@dc5a429b52fcf669ce959baa2c2dd26090d2a6c4 # v0.32.0
+        uses: aquasecurity/trivy-action@57a97c7e7821a5776cebc9bb87c984fa69cba8f1 # v0.35.0
         with:
           scan-type: "fs"
           format: "sarif"

From cfce4f9e3cef257166c3f23b7691a2e1dbcdb1e4 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 10 Mar 2026 16:50:59 +0000
Subject: [PATCH 134/219] Migrate OKX solver (#4236)

# Description
Migrates the OKX solver from the https://github.com/gnosis/solvers repo
as per #4234.

## How to test
Migrated tests.

## How to migrate
1 line config change in the infra, which basically replaces the image.
---
 Cargo.lock                                    |   11 +
 Cargo.toml                                    |    4 +
 crates/solvers/Cargo.toml                     |   11 +
 crates/solvers/config/example.okx.toml        |   51 +
 .../solvers/src/domain/dex/minimum_surplus.rs |  141 +++
 crates/solvers/src/domain/dex/mod.rs          |  202 ++++
 crates/solvers/src/domain/dex/shared.rs       |   53 +
 crates/solvers/src/domain/dex/slippage.rs     |  263 ++++
 crates/solvers/src/domain/eth/chain.rs        |  197 +++
 crates/solvers/src/domain/eth/mod.rs          |   15 +-
 crates/solvers/src/domain/mod.rs              |    1 +
 crates/solvers/src/domain/order.rs            |    9 +-
 crates/solvers/src/domain/solution.rs         |  103 +-
 .../domain/{solver.rs => solver/baseline.rs}  |    0
 crates/solvers/src/domain/solver/dex/fills.rs |  179 +++
 crates/solvers/src/domain/solver/dex/mod.rs   |  231 ++++
 crates/solvers/src/domain/solver/mod.rs       |   22 +
 crates/solvers/src/infra/blockchain.rs        |    4 +
 crates/solvers/src/infra/cli.rs               |    5 +
 .../infra/{config.rs => config/baseline.rs}   |   22 +-
 crates/solvers/src/infra/config/dex/file.rs   |  208 ++++
 crates/solvers/src/infra/config/dex/mod.rs    |   32 +
 .../solvers/src/infra/config/dex/okx/file.rs  |  115 ++
 .../solvers/src/infra/config/dex/okx/mod.rs   |    6 +
 crates/solvers/src/infra/config/mod.rs        |   22 +
 crates/solvers/src/infra/contracts.rs         |   30 +-
 crates/solvers/src/infra/dex/mod.rs           |  106 ++
 crates/solvers/src/infra/dex/okx/dto.rs       |  312 +++++
 crates/solvers/src/infra/dex/okx/mod.rs       |  514 ++++++++
 crates/solvers/src/infra/dex/simulator.rs     |  120 ++
 crates/solvers/src/infra/metrics.rs           |   11 +
 crates/solvers/src/infra/mod.rs               |    2 +
 crates/solvers/src/run.rs                     |   17 +-
 crates/solvers/src/tests/mock/http.rs         |  278 +++++
 crates/solvers/src/tests/mock/mod.rs          |    1 +
 crates/solvers/src/tests/mod.rs               |    2 +
 crates/solvers/src/tests/okx/api_calls.rs     |  262 ++++
 crates/solvers/src/tests/okx/market_order.rs  | 1067 +++++++++++++++++
 crates/solvers/src/tests/okx/mod.rs           |   22 +
 crates/solvers/src/tests/okx/not_found.rs     |  287 +++++
 crates/solvers/src/tests/okx/out_of_price.rs  |  205 ++++
 crates/solvers/src/util/conv.rs               |   18 +-
 crates/solvers/src/util/http.rs               |  152 +++
 crates/solvers/src/util/mod.rs                |    1 +
 44 files changed, 5284 insertions(+), 30 deletions(-)
 create mode 100644 crates/solvers/config/example.okx.toml
 create mode 100644 crates/solvers/src/domain/dex/minimum_surplus.rs
 create mode 100644 crates/solvers/src/domain/dex/mod.rs
 create mode 100644 crates/solvers/src/domain/dex/shared.rs
 create mode 100644 crates/solvers/src/domain/dex/slippage.rs
 create mode 100644 crates/solvers/src/domain/eth/chain.rs
 rename crates/solvers/src/domain/{solver.rs => solver/baseline.rs} (100%)
 create mode 100644 crates/solvers/src/domain/solver/dex/fills.rs
 create mode 100644 crates/solvers/src/domain/solver/dex/mod.rs
 create mode 100644 crates/solvers/src/domain/solver/mod.rs
 create mode 100644 crates/solvers/src/infra/blockchain.rs
 rename crates/solvers/src/infra/{config.rs => config/baseline.rs} (83%)
 create mode 100644 crates/solvers/src/infra/config/dex/file.rs
 create mode 100644 crates/solvers/src/infra/config/dex/mod.rs
 create mode 100644 crates/solvers/src/infra/config/dex/okx/file.rs
 create mode 100644 crates/solvers/src/infra/config/dex/okx/mod.rs
 create mode 100644 crates/solvers/src/infra/config/mod.rs
 create mode 100644 crates/solvers/src/infra/dex/mod.rs
 create mode 100644 crates/solvers/src/infra/dex/okx/dto.rs
 create mode 100644 crates/solvers/src/infra/dex/okx/mod.rs
 create mode 100644 crates/solvers/src/infra/dex/simulator.rs
 create mode 100644 crates/solvers/src/tests/mock/http.rs
 create mode 100644 crates/solvers/src/tests/mock/mod.rs
 create mode 100644 crates/solvers/src/tests/okx/api_calls.rs
 create mode 100644 crates/solvers/src/tests/okx/market_order.rs
 create mode 100644 crates/solvers/src/tests/okx/mod.rs
 create mode 100644 crates/solvers/src/tests/okx/not_found.rs
 create mode 100644 crates/solvers/src/tests/okx/out_of_price.rs
 create mode 100644 crates/solvers/src/util/http.rs

diff --git a/Cargo.lock b/Cargo.lock
index af97bdb6f6..b1039f8ea1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6919,7 +6919,9 @@ dependencies = [
  "alloy",
  "anyhow",
  "axum 0.8.8",
+ "base64 0.22.1",
  "bigdecimal",
+ "bytes-hex",
  "chain",
  "chrono",
  "clap",
@@ -6928,25 +6930,34 @@ dependencies = [
  "derive_more 1.0.0",
  "ethrpc",
  "futures",
+ "glob",
+ "hex",
+ "hmac",
+ "humantime-serde",
  "itertools 0.14.0",
  "liquidity-sources",
  "maplit",
  "mimalloc",
  "model",
+ "moka",
  "num",
  "number",
  "observe",
  "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
+ "rate-limit",
  "reqwest 0.13.2",
  "serde",
  "serde_json",
  "serde_with",
+ "sha2",
  "shared",
  "solver",
  "solvers-dto",
  "tempfile",
+ "testlib",
+ "thiserror 1.0.69",
  "tikv-jemallocator",
  "tokio",
  "toml",
diff --git a/Cargo.toml b/Cargo.toml
index 485b842094..61b67a1750 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,6 +36,7 @@ aws-sdk-s3 = { version = "1.34.0", default-features = false }
 axum = "0.8"
 bad-tokens = { path = "crates/bad-tokens" }
 balance-overrides = { path = "crates/balance-overrides" }
+base64 = "0.22.1"
 bigdecimal = "0.4"
 brotli = "8"
 bytes = "1.11.1"
@@ -59,7 +60,9 @@ event-indexing = { path = "crates/event-indexing" }
 flate2 = "1.0.30"
 futures = "0.3.30"
 gas-price-estimation = { path = "crates/gas-price-estimation" }
+hex = "0.4.3"
 hex-literal = "0.4.1"
+hmac = "0.12.1"
 http-body = "1"
 http-body-util = "0.1"
 humantime = "2.1.0"
@@ -107,6 +110,7 @@ serde = { version = "1.0.203", features = ["derive"] }
 serde-ext = { path = "crates/serde-ext" }
 serde_json = "1.0.117"
 serde_with = "3.8.1"
+sha2 = "0.10"
 shared = { path = "crates/shared" }
 signature-validator = { path = "crates/signature-validator" }
 solver = { path = "crates/solver" }
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index 2b62c6f628..87892bf9bc 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -15,7 +15,9 @@ path = "src/main.rs"
 [dependencies]
 alloy = { workspace = true }
 axum = { workspace = true }
+base64 = { workspace = true }
 bigdecimal = { workspace = true, features = ["serde"] }
+bytes-hex = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, default-features = false, features = ["serde"] }
 clap = { workspace = true, features = ["derive", "env"] }
@@ -23,19 +25,26 @@ const-hex = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
+hex = { workspace = true }
+hmac = { workspace = true }
+humantime-serde = { workspace = true }
 itertools = { workspace = true }
 liquidity-sources = { workspace = true }
 mimalloc = { workspace = true, optional = true }
+moka = { workspace = true, features = ["future"] }
 num = { workspace = true }
 number = { workspace = true }
 price-estimation = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
+rate-limit = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
+sha2 = { workspace = true }
 solvers-dto = { workspace = true }
+thiserror = { workspace = true }
 tikv-jemallocator = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "time"] }
 toml = { workspace = true }
@@ -54,8 +63,10 @@ solver = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
+glob = "0.3"
 maplit = { workspace = true }
 tempfile = { workspace = true }
+testlib = { workspace = true }
 
 [build-dependencies]
 anyhow = { workspace = true }
diff --git a/crates/solvers/config/example.okx.toml b/crates/solvers/config/example.okx.toml
new file mode 100644
index 0000000000..a0236d7ece
--- /dev/null
+++ b/crates/solvers/config/example.okx.toml
@@ -0,0 +1,51 @@
+node-url = "http://localhost:8545"
+
+[dex]
+# Specify which chain to use, 1 for Ethereum.
+# More info here: https://www.okx.com/en-au/web3/build/docs/waas/walletapi-resources-supported-networks
+chain-id = "1"
+
+# Optionally specify custom OKX Swap API endpoints
+# Sell orders endpoint (exactIn mode, uses V6 API by default)
+# sell-orders-endpoint = "https://web3.okx.com/api/v6/dex/aggregator/"
+
+# Buy orders endpoint (exactOut mode, uses V5 API, only supports Ethereum, Base, BSC, and Arbitrum chains and only Uni v2 and v3 protocols)
+# If not specified, buy orders will be ignored.
+# buy-orders-endpoint = "https://www.okx.com/api/v5/dex/aggregator/"
+
+# Optional: When using a proxy, specify the original OKX API URLs for signature generation
+# These URLs are used only for generating the request signature, while the actual requests
+# are sent to the endpoints configured above (sell-orders-endpoint and buy-orders-endpoint).
+# If not specified, the signature is generated using the endpoint URLs.
+#
+# Example proxy configuration:
+# sell-orders-endpoint = "https://your-proxy.example.com/okx/v6/"
+# sell-orders-signature-base-url = "https://web3.okx.com/api/v6/dex/aggregator/"
+# buy-orders-endpoint = "https://your-proxy.example.com/okx/v5/"
+# buy-orders-signature-base-url = "https://www.okx.com/api/v5/dex/aggregator/"
+
+# OKX Project ID. Instruction on how to create a project:
+# https://www.okx.com/en-au/web3/build/docs/waas/introduction-to-developer-portal-interface#create-project
+api-project-id = "$OKX_PROJECT_ID"
+
+# OKX API Key. Instruction on how to generate an API key:
+# https://www.okx.com/en-au/web3/build/docs/waas/introduction-to-developer-portal-interface#generate-api-keys
+api-key = "$OKX_API_KEY"
+
+# OKX Secret key used for signing request. Instruction on how to get a security token:
+# https://www.okx.com/en-au/web3/build/docs/waas/introduction-to-developer-portal-interface#view-the-secret-key
+api-secret-key = "$OKX_SECRET_KEY"
+
+# OKX Secret key passphrase. Instruction on how to get a passphrase:
+# https://www.okx.com/en-au/web3/build/docs/waas/introduction-to-developer-portal-interface#generate-api-keys
+api-passphrase = "$OKX_PASSPHRASE"
+
+# Optional: Price impact protection percentage (between 0.0 - 1.0).
+# OKX API documentation: https://web3.okx.com/build/dev-docs/wallet-api/dex-swap
+#
+# When set to 1.0 (100%), the feature is disabled - all trades are allowed.
+# Note: If this field is omitted entirely, OKX API defaults to 0.9 (90% protection),
+# but this config defaults to 1.0 to disable the feature by default.
+#
+# Examples:
+# price-impact-protection-percent = 1.0   # Disabled (default) - allow all trades
diff --git a/crates/solvers/src/domain/dex/minimum_surplus.rs b/crates/solvers/src/domain/dex/minimum_surplus.rs
new file mode 100644
index 0000000000..0e7de404f5
--- /dev/null
+++ b/crates/solvers/src/domain/dex/minimum_surplus.rs
@@ -0,0 +1,141 @@
+//! Minimum surplus requirements for DEX swaps.
+
+use {
+    crate::domain::{auction, dex::shared, eth},
+    alloy::primitives::U256,
+    bigdecimal::{BigDecimal, Zero},
+    std::cmp,
+};
+
+/// DEX swap minimum surplus limits.
+#[derive(Clone, Debug)]
+pub struct MinimumSurplusLimits {
+    /// The relative minimum surplus (percent) required for swaps.
+    relative: BigDecimal,
+    /// The absolute minimum surplus required for swaps.
+    absolute: Option<eth::Ether>,
+}
+
+impl MinimumSurplusLimits {
+    /// Creates a new minimum surplus limits configuration.
+    pub fn new(relative: BigDecimal, absolute: Option<eth::Ether>) -> Result<Self, anyhow::Error> {
+        anyhow::ensure!(
+            relative >= BigDecimal::zero(),
+            "minimum surplus relative tolerance must be non-negative"
+        );
+        Ok(Self { relative, absolute })
+    }
+
+    /// Returns the minimum surplus for the specified token amount.
+    pub fn relative(&self, asset: &eth::Asset, tokens: &auction::Tokens) -> MinimumSurplus {
+        let absolute_as_relative = shared::absolute_to_relative(self.absolute, asset, tokens);
+
+        MinimumSurplus::new(cmp::max(
+            self.relative.clone(),
+            absolute_as_relative.unwrap_or(BigDecimal::zero()),
+        ))
+    }
+}
+
+/// A relative minimum surplus requirement.
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub struct MinimumSurplus(BigDecimal);
+
+impl MinimumSurplus {
+    /// Creates a new minimum surplus from a decimal value.
+    fn new(value: BigDecimal) -> Self {
+        Self(value)
+    }
+
+    /// Adds minimum surplus to the specified amount.
+    pub fn add(&self, amount: U256) -> U256 {
+        let tolerance_amount = shared::compute_absolute_tolerance(amount, &self.0);
+        amount.saturating_add(tolerance_amount)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        crate::{
+            domain::{auction, eth},
+            util::conv,
+        },
+    };
+
+    #[test]
+    fn minimum_surplus_requirement() {
+        let token = |t: &str| eth::TokenAddress(t.parse().unwrap());
+        let ether = |e: &str| conv::decimal_to_ether(&e.parse().unwrap()).unwrap();
+        let price = |e: &str| auction::Token {
+            decimals: Default::default(),
+            symbol: Default::default(),
+            reference_price: Some(auction::Price(ether(e))),
+            available_balance: Default::default(),
+            trusted: Default::default(),
+        };
+
+        let tokens = auction::Tokens(
+            [
+                // WETH
+                (
+                    token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                    price("1.0"),
+                ),
+                // USDC
+                (
+                    token("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+                    price("589783000.0"),
+                ),
+            ]
+            .into_iter()
+            .collect(),
+        );
+        let minimum_surplus = MinimumSurplusLimits::new(
+            "0.01".parse().unwrap(), // 1%
+            Some(ether("0.02")),
+        )
+        .unwrap();
+
+        for (asset, relative, min_buy) in [
+            // Small amount: absolute minimum surplus dominates
+            // 0.5 WETH * 0.02/0.5 = 0.02 WETH absolute = 4% > 1% relative
+            (
+                eth::Asset {
+                    token: token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                    amount: U256::from(500_000_000_000_000_000_u128), // 0.5 WETH
+                },
+                "0.04",
+                520_000_000_000_000_000_u128,
+            ),
+            // Medium amount: relative minimum surplus dominates
+            // 5 WETH * 1% = 0.05 WETH > 0.02 WETH absolute
+            (
+                eth::Asset {
+                    token: token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                    amount: U256::from(5_000_000_000_000_000_000_u128), // 5 WETH
+                },
+                "0.01",
+                5_050_000_000_000_000_000_u128,
+            ),
+            // For USDC: relative dominates for this amount
+            (
+                eth::Asset {
+                    token: token("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+                    amount: U256::from(10_000_000_000_u128), // 10K USDC
+                },
+                "0.01",
+                10_100_000_000_u128,
+            ),
+        ] {
+            let relative = MinimumSurplus::new(relative.parse().unwrap());
+            let min_buy = U256::from(min_buy);
+
+            let computed = minimum_surplus.relative(&asset, &tokens);
+
+            assert_eq!(computed, relative);
+            assert_eq!(computed.add(asset.amount), min_buy);
+        }
+    }
+}
diff --git a/crates/solvers/src/domain/dex/mod.rs b/crates/solvers/src/domain/dex/mod.rs
new file mode 100644
index 0000000000..429fac691b
--- /dev/null
+++ b/crates/solvers/src/domain/dex/mod.rs
@@ -0,0 +1,202 @@
+//! Various solver implementations rely on quoting APIs from DEXs and DEX
+//! aggregators. This domain module models the various types around quoting
+//! single orders with DEXs and turning swaps into single order solutions.
+
+use {
+    crate::{
+        domain::{self, auction, eth, order, solution},
+        infra,
+        util,
+    },
+    alloy::primitives::{Address, U256},
+    std::fmt::{self, Debug, Formatter},
+};
+
+pub mod minimum_surplus;
+mod shared;
+pub mod slippage;
+
+pub use self::slippage::Slippage;
+
+/// An order for quoting with an external DEX or DEX aggregator. This is a
+/// simplified representation of a CoW Protocol order.
+#[derive(Debug)]
+pub struct Order {
+    pub sell: eth::TokenAddress,
+    pub buy: eth::TokenAddress,
+    pub side: order::Side,
+    pub amount: Amount,
+    pub owner: eth::Address,
+}
+
+impl Order {
+    pub fn new(order: &order::Order) -> Self {
+        Self {
+            sell: order.sell.token,
+            buy: order.buy.token,
+            side: order.side,
+            amount: Amount(match order.side {
+                order::Side::Buy => order.buy.amount,
+                order::Side::Sell => order.sell.amount,
+            }),
+            owner: order.owner(),
+        }
+    }
+
+    /// Returns the order swapped amount as an asset. The token associated with
+    /// the asset is dependent on the side of the DEX order.
+    pub fn amount(&self) -> eth::Asset {
+        eth::Asset {
+            token: match self.side {
+                order::Side::Buy => self.buy,
+                order::Side::Sell => self.sell,
+            },
+            amount: self.amount.0,
+        }
+    }
+}
+
+/// An on-chain Ethereum call for executing a DEX swap.
+pub struct Call {
+    /// The address that gets called on-chain.
+    pub to: Address,
+    /// The associated calldata for the on-chain call.
+    pub calldata: Vec<u8>,
+}
+
+impl Debug for Call {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.debug_struct("Call")
+            .field("to", &self.to)
+            .field("calldata", &util::fmt::Hex(&self.calldata))
+            .finish()
+    }
+}
+
+/// A DEX swap.
+#[derive(Debug)]
+pub struct Swap {
+    /// The Ethereum calls for executing the swap.
+    pub calls: Vec<Call>,
+    /// The expected input asset for the swap. The executed input may end up
+    /// being different because of slippage.
+    pub input: eth::Asset,
+    /// The expected output asset for the swap. The executed output may end up
+    /// being different because of slippage.
+    pub output: eth::Asset,
+    /// The minimum allowance that is required for executing the swap.
+    pub allowance: Allowance,
+    /// The gas guesstimate in gas units for the swap.
+    ///
+    /// This estimate is **not** expected to be accurate, and is purely
+    /// indicative.
+    pub gas: eth::Gas,
+}
+
+impl Swap {
+    pub fn allowance(&self) -> solution::Allowance {
+        solution::Allowance {
+            spender: self.allowance.spender,
+            asset: eth::Asset {
+                token: self.input.token,
+                amount: self.allowance.amount.0,
+            },
+        }
+    }
+
+    /// Constructs a single order `solution::Solution` for this swap. Returns
+    /// `None` if the swap is not valid for the specified order.
+    pub async fn into_solution(
+        self,
+        order: order::Order,
+        gas_price: auction::GasPrice,
+        sell_token: Option<auction::Price>,
+        simulator: &infra::dex::Simulator,
+        gas_offset: eth::Gas,
+    ) -> Option<solution::Solution> {
+        let gas = if order.class == order::Class::Limit {
+            match simulator.gas(order.owner(), &self).await {
+                Ok(value) => value,
+                Err(infra::dex::simulator::Error::SettlementContractIsOwner) => self.gas,
+                Err(err) => {
+                    tracing::warn!(?err, "gas simulation failed");
+                    return None;
+                }
+            }
+        } else {
+            // We are fine with just using heuristic gas for market orders,
+            // since it doesn't really play a role in the final solution.
+            self.gas
+        };
+
+        let allowance = self.allowance();
+        let interactions = self
+            .calls
+            .into_iter()
+            .map(|call| {
+                solution::Interaction::Custom(solution::CustomInteraction {
+                    target: call.to,
+                    value: eth::Ether::default(),
+                    calldata: call.calldata,
+                    inputs: vec![self.input],
+                    outputs: vec![self.output],
+                    internalize: false,
+                    allowances: vec![allowance.clone()],
+                })
+            })
+            .collect();
+
+        solution::Single {
+            order,
+            input: self.input,
+            output: self.output,
+            interactions,
+            gas,
+            wrappers: vec![],
+        }
+        .into_dex_solution(gas_price, sell_token, gas_offset)
+    }
+
+    pub fn satisfies(&self, order: &domain::order::Order) -> bool {
+        self.output
+            .amount
+            .widening_mul::<_, _, 512, 8>(order.sell.amount)
+            >= self.input.amount.widening_mul(order.buy.amount)
+    }
+
+    pub fn satisfies_with_minimum_surplus(
+        &self,
+        order: &domain::order::Order,
+        minimum_surplus: &minimum_surplus::MinimumSurplus,
+    ) -> bool {
+        let required_buy_amount = minimum_surplus.add(order.buy.amount);
+        self.output
+            .amount
+            .widening_mul::<_, _, 512, 8>(order.sell.amount)
+            >= self.input.amount.widening_mul(required_buy_amount)
+    }
+}
+
+/// A swap allowance.
+#[derive(Debug)]
+pub struct Allowance {
+    /// The spender address that requires an allowance in order to execute a
+    /// swap.
+    pub spender: Address,
+    /// The amount, in tokens, of the required allowance.
+    pub amount: Amount,
+}
+
+/// A token amount.
+#[derive(Debug)]
+pub struct Amount(U256);
+
+impl Amount {
+    pub fn new(value: U256) -> Self {
+        Self(value)
+    }
+
+    pub fn get(&self) -> U256 {
+        self.0
+    }
+}
diff --git a/crates/solvers/src/domain/dex/shared.rs b/crates/solvers/src/domain/dex/shared.rs
new file mode 100644
index 0000000000..6e8877e53f
--- /dev/null
+++ b/crates/solvers/src/domain/dex/shared.rs
@@ -0,0 +1,53 @@
+//! Shared mathematical functions for slippage and minimum surplus calculations.
+
+use {
+    crate::{
+        domain::{auction, eth},
+        util::conv,
+    },
+    alloy::primitives::U256,
+    bigdecimal::{BigDecimal, Zero},
+    num::{BigUint, Integer},
+};
+
+/// Computes the absolute tolerance amount from a relative factor.
+pub fn compute_absolute_tolerance(amount: U256, factor: &BigDecimal) -> U256 {
+    let amount = conv::u256_to_biguint(&amount);
+    let (int, exp) = factor.as_bigint_and_exponent();
+
+    let numer = amount * int.to_biguint().expect("positive by construction");
+    let denom = BigUint::from(10_u8).pow(exp.unsigned_abs().try_into().unwrap_or(u32::MAX));
+
+    let abs = numer.div_ceil(&denom);
+    conv::biguint_to_u256(&abs).unwrap_or(U256::MAX)
+}
+
+/// Converts an absolute slippage value to a relative slippage value based on
+/// the amount and asset's price.
+pub fn absolute_to_relative(
+    absolute: Option<eth::Ether>,
+    asset: &eth::Asset,
+    tokens: &auction::Tokens,
+) -> Option<BigDecimal> {
+    let price = tokens.reference_price(&asset.token)?;
+    if price.0.0.is_zero() {
+        return None;
+    }
+
+    // Convert absolute slippage and asset value to ETH using BigDecimal
+    let absolute = conv::ether_to_decimal(&absolute?);
+    let amount_in_token = conv::ether_to_decimal(&eth::Ether(asset.amount));
+    let price_in_eth = conv::ether_to_decimal(&price.0);
+
+    // Calculate asset value in ETH: amount * price
+    let amount_in_eth = amount_in_token * price_in_eth;
+
+    // Check if amount_in_eth is zero to prevent division by zero
+    if amount_in_eth.is_zero() {
+        return None;
+    }
+
+    // Calculate absolute as relative: absolute_eth / asset_value_in_eth
+    let absolute_as_relative = absolute / amount_in_eth;
+    Some(absolute_as_relative)
+}
diff --git a/crates/solvers/src/domain/dex/slippage.rs b/crates/solvers/src/domain/dex/slippage.rs
new file mode 100644
index 0000000000..fe98be450f
--- /dev/null
+++ b/crates/solvers/src/domain/dex/slippage.rs
@@ -0,0 +1,263 @@
+//! Slippage tolerance computation for DEX swaps.
+
+use {
+    crate::domain::{auction, dex::shared, eth},
+    alloy::primitives::U256,
+    bigdecimal::{BigDecimal, One, ToPrimitive, Zero},
+    std::cmp,
+};
+
+/// DEX swap slippage limits.
+#[derive(Clone, Debug)]
+pub struct SlippageLimits {
+    /// The relative slippage (percent) allowed for swaps.
+    relative: BigDecimal,
+    /// The maximum absolute slippage allowed for swaps.
+    absolute: Option<eth::Ether>,
+}
+
+impl SlippageLimits {
+    /// Creates a new slippage limits configuration.
+    pub fn new(relative: BigDecimal, absolute: Option<eth::Ether>) -> Result<Self, anyhow::Error> {
+        anyhow::ensure!(
+            relative >= BigDecimal::zero() && relative <= BigDecimal::one(),
+            "slippage relative tolerance must be in the range [0, 1]"
+        );
+        Ok(Self { relative, absolute })
+    }
+
+    /// Returns the slippage for the specified token amount.
+    pub fn relative(&self, asset: &eth::Asset, tokens: &auction::Tokens) -> Slippage {
+        let absolute_as_relative = shared::absolute_to_relative(self.absolute, asset, tokens);
+
+        Slippage::new(cmp::min(
+            self.relative.clone(),
+            absolute_as_relative.unwrap_or(BigDecimal::one()),
+        ))
+    }
+}
+
+/// A relative slippage tolerance.
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub struct Slippage(BigDecimal);
+
+impl Slippage {
+    /// Creates a new slippage from a decimal value.
+    fn new(value: BigDecimal) -> Self {
+        Self(value)
+    }
+
+    /// Returns 1% slippage.
+    #[cfg(test)]
+    pub fn one_percent() -> Self {
+        Self::new("0.01".parse().unwrap())
+    }
+
+    /// Returns a zero slippage.
+    pub fn zero() -> Self {
+        Self::new(BigDecimal::zero())
+    }
+
+    /// Adds slippage to the specified amount.
+    pub fn add(&self, amount: U256) -> U256 {
+        let tolerance_amount = shared::compute_absolute_tolerance(amount, &self.0);
+        amount.saturating_add(tolerance_amount)
+    }
+
+    /// Subtracts slippage from the specified amount.
+    pub fn sub(&self, amount: U256) -> U256 {
+        let tolerance_amount = shared::compute_absolute_tolerance(amount, &self.0);
+        amount.saturating_sub(tolerance_amount)
+    }
+
+    /// Returns the slippage as a decimal factor.
+    pub fn as_factor(&self) -> &BigDecimal {
+        &self.0
+    }
+
+    /// Converts the slippage to basis points.
+    pub fn as_bps(&self) -> Option<u16> {
+        let bps = &self.0 * BigDecimal::from(10_000);
+        bps.to_u32().and_then(|v| v.try_into().ok())
+    }
+
+    /// Rounds the slippage to the specified number of decimal places.
+    pub fn round(&self, decimals: i64) -> Self {
+        Self(self.0.round(decimals))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        crate::{
+            domain::{auction, eth},
+            util::conv,
+        },
+    };
+
+    #[test]
+    fn slippage_tolerance() {
+        let token = |t: &str| eth::TokenAddress(t.parse().unwrap());
+        let ether = |e: &str| conv::decimal_to_ether(&e.parse().unwrap()).unwrap();
+        let price = |e: &str| auction::Token {
+            decimals: Default::default(),
+            symbol: Default::default(),
+            reference_price: Some(auction::Price(ether(e))),
+            available_balance: Default::default(),
+            trusted: Default::default(),
+        };
+
+        let tokens = auction::Tokens(
+            [
+                // WETH
+                (
+                    token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                    price("1.0"),
+                ),
+                // USDC
+                (
+                    token("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+                    price("589783000.0"),
+                ),
+                // COW
+                (
+                    token("0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB"),
+                    price("0.000057"),
+                ),
+            ]
+            .into_iter()
+            .collect(),
+        );
+        let slippage = SlippageLimits::new(
+            "0.01".parse().unwrap(), // 1%
+            Some(ether("0.02")),
+        )
+        .unwrap();
+
+        for (asset, relative, min, max) in [
+            // tolerance defined by relative slippage
+            (
+                eth::Asset {
+                    token: token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                    amount: U256::from(1_000_000_000_000_000_000_u128),
+                },
+                "0.01",
+                990_000_000_000_000_000_u128,
+                1_010_000_000_000_000_000_u128,
+            ),
+            // tolerance capped by absolute slippage
+            (
+                eth::Asset {
+                    token: token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                    amount: U256::from(100_000_000_000_000_000_000_u128),
+                },
+                "0.0002",
+                99_980_000_000_000_000_000_u128,
+                100_020_000_000_000_000_000_u128,
+            ),
+            // tolerance defined by relative slippage
+            (
+                eth::Asset {
+                    token: token("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+                    amount: U256::from(1_000_000_000_u128), // 1K USDC
+                },
+                "0.01",
+                990_000_000_u128,
+                1_010_000_000_u128,
+            ),
+            // tolerance capped by absolute slippage
+            // 0.02 WETH <=> 33.91 USDC, and ~0.0033910778% of 1M
+            (
+                eth::Asset {
+                    token: token("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+                    amount: U256::from(1_000_000_000_000_u128), // 1M USDC
+                },
+                "0.000033911",
+                999_966_089_222_u128,
+                1_000_033_910_778_u128,
+            ),
+            // tolerance defined by relative slippage
+            (
+                eth::Asset {
+                    token: token("0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB"),
+                    amount: U256::from(1_000_000_000_000_000_000_000_u128), // 1K COW
+                },
+                "0.01",
+                990_000_000_000_000_000_000_u128,
+                1_010_000_000_000_000_000_000_u128,
+            ),
+            // tolerance capped by absolute slippage
+            // 0.02 WETH <=> 350.88 COW, and ~0.0350877192982456140351% of 1M
+            (
+                eth::Asset {
+                    token: token("0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB"),
+                    amount: U256::from(1_000_000_000_000_000_000_000_000_u128), // 1M COW
+                },
+                "0.000350877",
+                999_649_122_807_017_543_859_649_u128,
+                1_000_350_877_192_982_456_140_351_u128,
+            ),
+        ] {
+            let relative = Slippage::new(relative.parse().unwrap());
+            let min = U256::from(min);
+            let max = U256::from(max);
+
+            let computed = slippage.relative(&asset, &tokens);
+
+            assert_eq!(computed.round(9), relative);
+            assert_eq!(computed.sub(asset.amount), min);
+            assert_eq!(computed.add(asset.amount), max);
+        }
+    }
+
+    #[test]
+    fn round_does_not_panic() {
+        let slippage = Slippage::new(
+            "42.115792089237316195423570985008687907853269984665640564039457584007913129639935"
+                .parse()
+                .unwrap(),
+        );
+
+        assert_eq!(slippage.round(4), Slippage::new("42.1158".parse().unwrap()));
+    }
+
+    #[test]
+    fn handles_zero_amount_without_panic() {
+        let token = |t: &str| eth::TokenAddress(t.parse().unwrap());
+        let ether = |e: &str| conv::decimal_to_ether(&e.parse().unwrap()).unwrap();
+        let price = |e: &str| auction::Token {
+            decimals: Default::default(),
+            symbol: Default::default(),
+            reference_price: Some(auction::Price(ether(e))),
+            available_balance: Default::default(),
+            trusted: Default::default(),
+        };
+
+        let tokens = auction::Tokens(
+            [(
+                token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+                price("1.0"),
+            )]
+            .into_iter()
+            .collect(),
+        );
+
+        let slippage = SlippageLimits::new(
+            "0.01".parse().unwrap(), // 1%
+            Some(ether("0.02")),
+        )
+        .unwrap();
+
+        // Test with zero amount - should not panic and use relative slippage fallback
+        let asset_with_zero_amount = eth::Asset {
+            token: token("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+            amount: U256::ZERO, // Zero amount
+        };
+
+        // This should not panic and should return the relative slippage (1%)
+        let computed = slippage.relative(&asset_with_zero_amount, &tokens);
+        assert_eq!(computed.as_factor(), &"0.01".parse::<BigDecimal>().unwrap());
+    }
+}
diff --git a/crates/solvers/src/domain/eth/chain.rs b/crates/solvers/src/domain/eth/chain.rs
new file mode 100644
index 0000000000..65c042e64b
--- /dev/null
+++ b/crates/solvers/src/domain/eth/chain.rs
@@ -0,0 +1,197 @@
+use {serde::Deserialize, std::str::FromStr};
+
+/// A supported Ethereum Chain ID.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ChainId {
+    Mainnet = 1,
+    Goerli = 5,
+    Gnosis = 100,
+    Base = 8453,
+    ArbitrumOne = 42161,
+    Bnb = 56,
+    Avalanche = 43114,
+    Optimism = 10,
+    Polygon = 137,
+    Linea = 59144,
+    Plasma = 9745,
+    Ink = 57073,
+}
+
+impl ChainId {
+    pub fn new(value: u64) -> Result<Self, UnsupportedChain> {
+        match value {
+            1 => Ok(Self::Mainnet),
+            5 => Ok(Self::Goerli),
+            100 => Ok(Self::Gnosis),
+            8453 => Ok(Self::Base),
+            42161 => Ok(Self::ArbitrumOne),
+            56 => Ok(Self::Bnb),
+            43114 => Ok(Self::Avalanche),
+            10 => Ok(Self::Optimism),
+            137 => Ok(Self::Polygon),
+            59144 => Ok(Self::Linea),
+            9745 => Ok(Self::Plasma),
+            57073 => Ok(Self::Ink),
+            _ => Err(UnsupportedChain),
+        }
+    }
+
+    /// Returns the network ID for the chain.
+    pub fn network_id(self) -> &'static str {
+        match self {
+            ChainId::Mainnet => "1",
+            ChainId::Goerli => "5",
+            ChainId::Gnosis => "100",
+            ChainId::Base => "8453",
+            ChainId::ArbitrumOne => "42161",
+            ChainId::Bnb => "56",
+            ChainId::Avalanche => "43114",
+            ChainId::Optimism => "10",
+            ChainId::Polygon => "137",
+            ChainId::Linea => "59144",
+            ChainId::Plasma => "9745",
+            ChainId::Ink => "57073",
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ChainId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct ChainIdVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for ChainIdVisitor {
+            type Value = ChainId;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a chain ID as a string or number")
+            }
+
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                let chain_id = u64::from_str(v).map_err(E::custom)?;
+                ChainId::new(chain_id).map_err(E::custom)
+            }
+
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                ChainId::new(v).map_err(E::custom)
+            }
+        }
+
+        deserializer.deserialize_any(ChainIdVisitor)
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("unsupported chain")]
+pub struct UnsupportedChain;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn supported_chains_number() {
+        assert_eq!(
+            serde_json::from_value::<ChainId>(1.into()).unwrap(),
+            ChainId::Mainnet
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(5.into()).unwrap(),
+            ChainId::Goerli
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(100.into()).unwrap(),
+            ChainId::Gnosis
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(8453.into()).unwrap(),
+            ChainId::Base
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(42161.into()).unwrap(),
+            ChainId::ArbitrumOne
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(56.into()).unwrap(),
+            ChainId::Bnb
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(43114.into()).unwrap(),
+            ChainId::Avalanche
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(10.into()).unwrap(),
+            ChainId::Optimism
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(137.into()).unwrap(),
+            ChainId::Polygon
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(59144.into()).unwrap(),
+            ChainId::Linea
+        );
+        assert_eq!(
+            serde_json::from_value::<ChainId>(9745.into()).unwrap(),
+            ChainId::Plasma
+        );
+    }
+
+    #[test]
+    fn supported_chains_str() {
+        assert_eq!(
+            serde_json::from_str::<ChainId>("1").unwrap(),
+            ChainId::Mainnet
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("5").unwrap(),
+            ChainId::Goerli
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("100").unwrap(),
+            ChainId::Gnosis
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("8453").unwrap(),
+            ChainId::Base
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("42161").unwrap(),
+            ChainId::ArbitrumOne
+        );
+        assert_eq!(serde_json::from_str::<ChainId>("56").unwrap(), ChainId::Bnb);
+        assert_eq!(
+            serde_json::from_str::<ChainId>("43114").unwrap(),
+            ChainId::Avalanche
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("10").unwrap(),
+            ChainId::Optimism
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("137").unwrap(),
+            ChainId::Polygon
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("59144").unwrap(),
+            ChainId::Linea
+        );
+        assert_eq!(
+            serde_json::from_str::<ChainId>("9745").unwrap(),
+            ChainId::Plasma
+        );
+    }
+
+    #[test]
+    fn unsupported_chains() {
+        serde_json::from_str::<ChainId>("0").unwrap_err();
+    }
+}
diff --git a/crates/solvers/src/domain/eth/mod.rs b/crates/solvers/src/domain/eth/mod.rs
index 677e2a2076..f3c1500308 100644
--- a/crates/solvers/src/domain/eth/mod.rs
+++ b/crates/solvers/src/domain/eth/mod.rs
@@ -1,5 +1,10 @@
-pub use alloy::primitives::{Address, B256, U256};
+pub mod chain;
+
 use {crate::util::bytes::Bytes, alloy::rpc::types::AccessList, derive_more::From};
+pub use {
+    alloy::primitives::{Address, B256, U256},
+    chain::ChainId,
+};
 
 /// A contract address.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -51,6 +56,14 @@ impl From<i64> for SignedGas {
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Gas(pub U256);
 
+impl std::ops::Add<Gas> for Gas {
+    type Output = Self;
+
+    fn add(self, rhs: Gas) -> Self::Output {
+        Self(self.0.saturating_add(rhs.0))
+    }
+}
+
 impl std::ops::Add<SignedGas> for Gas {
     type Output = Self;
 
diff --git a/crates/solvers/src/domain/mod.rs b/crates/solvers/src/domain/mod.rs
index afd4300eed..414298a9de 100644
--- a/crates/solvers/src/domain/mod.rs
+++ b/crates/solvers/src/domain/mod.rs
@@ -1,6 +1,7 @@
 //! Core solver engine logic.
 
 pub mod auction;
+pub mod dex;
 pub mod eth;
 pub mod liquidity;
 pub mod notification;
diff --git a/crates/solvers/src/domain/order.rs b/crates/solvers/src/domain/order.rs
index 738d8b6483..73c25316db 100644
--- a/crates/solvers/src/domain/order.rs
+++ b/crates/solvers/src/domain/order.rs
@@ -25,6 +25,13 @@ impl Order {
     pub fn solver_determines_fee(&self) -> bool {
         self.class == Class::Limit
     }
+
+    /// Returns the owner address of the order extracted from the UID.
+    pub fn owner(&self) -> eth::Address {
+        let mut bytes = [0u8; 20];
+        bytes.copy_from_slice(&self.uid.0[32..52]);
+        eth::Address::from(bytes)
+    }
 }
 
 /// UID of an order.
@@ -46,7 +53,7 @@ impl Display for Uid {
 }
 
 /// The trading side of an order.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub enum Side {
     /// An order with a fixed buy amount and maximum sell amount.
     Buy,
diff --git a/crates/solvers/src/domain/solution.rs b/crates/solvers/src/domain/solution.rs
index 7dcdb35d67..373563b33a 100644
--- a/crates/solvers/src/domain/solution.rs
+++ b/crates/solvers/src/domain/solution.rs
@@ -1,6 +1,7 @@
 use {
     crate::domain::{auction, eth, liquidity, order},
     eth::{Address, U256},
+    number::u256_ext::U256Ext,
     std::{collections::HashMap, slice},
 };
 
@@ -199,6 +200,106 @@ impl Single {
                 .collect(),
         })
     }
+
+    /// Creates a full solution for a single order solution given gas and sell
+    /// token prices. Computes the fee internally from the gas parameters.
+    pub fn into_dex_solution(
+        self,
+        gas_price: auction::GasPrice,
+        sell_token: Option<auction::Price>,
+        gas_offset: eth::Gas,
+    ) -> Option<Solution> {
+        let Self {
+            order,
+            input,
+            output,
+            interactions,
+            gas: swap,
+            wrappers,
+        } = self;
+
+        if (order.sell.token, order.buy.token) != (input.token, output.token) {
+            tracing::debug!(
+                swap = ?(input.token, output.token),
+                order = ?(order.sell.token, order.buy.token),
+                "input/output tokens do not match",
+            );
+            return None;
+        }
+
+        let fee = if order.solver_determines_fee() {
+            // TODO: If the order has signed `fee` amount already, we should
+            // discount it from the surplus fee. ATM, users would pay both a
+            // full order fee as well as a solver computed fee. Note that this
+            // is fine for now, since there is no way to create limit orders
+            // with non-zero fees.
+            Fee::Surplus(eth::SellTokenAmount(
+                sell_token?.ether_value(eth::Ether(
+                    swap.0
+                        .checked_add(gas_offset.0)?
+                        .checked_mul(gas_price.0.0)?,
+                ))?,
+            ))
+        } else {
+            Fee::Protocol
+        };
+        let surplus_fee = fee.surplus().unwrap_or_default();
+
+        // Compute total executed sell and buy amounts accounting for solver
+        // fees. That is, the total amount of sell tokens transferred into the
+        // contract and the total buy tokens transferred out of the contract.
+        let (sell, buy) = match order.side {
+            order::Side::Buy => (input.amount.checked_add(surplus_fee)?, output.amount),
+            order::Side::Sell => {
+                // We want to collect fees in the sell token, so we need to sell
+                // `fee` more than the DEX swap. However, we don't allow
+                // transferring more than `order.sell.amount` (guaranteed by the
+                // Smart Contract), so we need to cap our executed amount to the
+                // order's limit sell amount and compute the executed buy amount
+                // accordingly.
+                let sell = input
+                    .amount
+                    .checked_add(surplus_fee)?
+                    .min(order.sell.amount);
+                let buy = sell
+                    .checked_sub(surplus_fee)?
+                    .checked_mul(output.amount)?
+                    .checked_ceil_div(&input.amount)?;
+                (sell, buy)
+            }
+        };
+
+        // Check order's limit price is satisfied accounting for solver
+        // specified fees.
+        if order.sell.amount.checked_mul(buy)? < order.buy.amount.checked_mul(sell)? {
+            tracing::debug!(?buy, ?sell, ?order, "order limit price not satisfied",);
+            return None;
+        }
+
+        let executed = match order.side {
+            order::Side::Buy => buy,
+            order::Side::Sell => sell.checked_sub(surplus_fee)?,
+        };
+        Some(Solution {
+            id: Default::default(),
+            prices: ClearingPrices::new([
+                (order.sell.token, buy),
+                (order.buy.token, sell.checked_sub(surplus_fee)?),
+            ]),
+            pre_interactions: Default::default(),
+            interactions,
+            post_interactions: Default::default(),
+            gas: Some(gas_offset + swap),
+            trades: vec![Trade::Fulfillment(Fulfillment::new(order, executed, fee)?)],
+            wrappers: wrappers
+                .iter()
+                .map(|w| WrapperCall {
+                    target: w.address,
+                    data: w.data.clone(),
+                })
+                .collect(),
+        })
+    }
 }
 
 /// A set of uniform clearing prices. They are represented as a mapping of token
@@ -367,7 +468,7 @@ pub struct CustomInteraction {
 }
 
 /// Approval required to make some `[CustomInteraction]` possible.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Allowance {
     pub spender: Address,
     pub asset: eth::Asset,
diff --git a/crates/solvers/src/domain/solver.rs b/crates/solvers/src/domain/solver/baseline.rs
similarity index 100%
rename from crates/solvers/src/domain/solver.rs
rename to crates/solvers/src/domain/solver/baseline.rs
diff --git a/crates/solvers/src/domain/solver/dex/fills.rs b/crates/solvers/src/domain/solver/dex/fills.rs
new file mode 100644
index 0000000000..7817f80c2a
--- /dev/null
+++ b/crates/solvers/src/domain/solver/dex/fills.rs
@@ -0,0 +1,179 @@
+use {
+    crate::{
+        domain::{auction, dex, eth, order},
+        util::conv,
+    },
+    alloy::primitives::{U256, U512, ruint::UintTryFrom},
+    bigdecimal::BigDecimal,
+    std::{
+        collections::HashMap,
+        sync::Mutex,
+        time::{Duration, Instant},
+    },
+};
+
+/// Manages the search for a fillable amount for all order types but
+/// specifically for partially fillable orders.
+#[derive(Debug)]
+pub struct Fills {
+    /// Maps which fill amount should be tried next for a given order. For sell
+    /// orders the amount refers to the `sell` asset and for buy orders it
+    /// refers to the `buy` asset.
+    amounts: Mutex<HashMap<order::Uid, CacheEntry>>,
+    /// The smallest value in ETH we consider trying a partially fillable order
+    /// with. If we move below this threshold we'll restart from 100% fill
+    /// amount to not eventually converge at 0.
+    smallest_fill: BigDecimal,
+}
+
+const ETH: eth::TokenAddress = eth::TokenAddress(eth::Address::repeat_byte(0xee));
+
+impl Fills {
+    pub fn new(smallest_fill: eth::Ether) -> Self {
+        Self {
+            amounts: Default::default(),
+            smallest_fill: conv::u256_to_bigdecimal(&smallest_fill.0),
+        }
+    }
+
+    /// Returns which dex query should be tried for the given order. Takes
+    /// information of previous partial fill attempts into account.
+    pub fn dex_order(&self, order: &order::Order, tokens: &auction::Tokens) -> Option<dex::Order> {
+        // Do not attempt solving for same sell and buy token
+        if order.sell.token == order.buy.token {
+            return None;
+        }
+        if !order.partially_fillable {
+            return Some(dex::Order::new(order));
+        }
+
+        let (token, total_amount) = match order.side {
+            order::Side::Buy => (order.buy.token, order.buy.amount),
+            order::Side::Sell => (order.sell.token, order.sell.amount),
+        };
+
+        let smallest_fill = self.smallest_fill.clone()
+            * conv::ether_to_decimal(&tokens.reference_price(&ETH)?.0)
+            / conv::ether_to_decimal(&tokens.reference_price(&token)?.0);
+        let smallest_fill = conv::bigdecimal_to_u256(&smallest_fill)?;
+
+        let now = Instant::now();
+
+        let amount = match self.amounts.lock().unwrap().entry(order.uid) {
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                entry.insert(CacheEntry {
+                    next_amount: total_amount,
+                    last_requested: now,
+                    total_amount,
+                });
+                total_amount
+            }
+            std::collections::hash_map::Entry::Occupied(mut entry) => {
+                let entry = entry.get_mut();
+                entry.last_requested = now;
+                entry.total_amount = total_amount;
+
+                if entry.next_amount < smallest_fill {
+                    tracing::trace!(
+                        ?smallest_fill,
+                        target =? entry.next_amount,
+                        "target fill got too small; starting over"
+                    );
+                    entry.next_amount = total_amount;
+                } else if entry.next_amount > total_amount {
+                    tracing::trace!("partially filled; adjusting to new total amount");
+                    entry.next_amount = total_amount;
+                }
+
+                entry.next_amount
+            }
+        };
+
+        if amount < smallest_fill || amount.is_zero() {
+            tracing::trace!(?amount, "order no longer worth filling");
+            return None;
+        }
+
+        // Scale amounts according to the limit price and the chosen fill.
+        let (sell_amount, buy_amount) = match order.side {
+            order::Side::Buy => {
+                let sell_amount = U256::uint_try_from(
+                    order
+                        .sell
+                        .amount
+                        .widening_mul(amount)
+                        .checked_div(U512::from(order.buy.amount))?,
+                )
+                .unwrap();
+                (sell_amount, amount)
+            }
+            order::Side::Sell => {
+                let buy_amount = U256::uint_try_from(
+                    order
+                        .buy
+                        .amount
+                        .widening_mul(amount)
+                        .checked_div(U512::from(order.sell.amount))?,
+                )
+                .unwrap();
+                (amount, buy_amount)
+            }
+        };
+
+        tracing::trace!(?amount, "trying to partially fill order");
+        Some(dex::Order::new(&order::Order {
+            sell: eth::Asset {
+                token: order.sell.token,
+                amount: sell_amount,
+            },
+            buy: eth::Asset {
+                token: order.buy.token,
+                amount: buy_amount,
+            },
+            ..order.clone()
+        }))
+    }
+
+    /// Adjusts the next fill amount that should be tried. Always halves the
+    /// last tried amount.
+    pub fn reduce_next_try(&self, uid: order::Uid) {
+        self.amounts.lock().unwrap().entry(uid).and_modify(|entry| {
+            entry.next_amount /= U256::from(2);
+            tracing::trace!(next_try =? entry.next_amount, "reduced next fill amount");
+        });
+    }
+
+    /// Adjusts the next fill amount that should be tried. Doubles the amount to
+    /// try. This is useful in case the onchain liquidity changed and now
+    /// allows for bigger fills.
+    pub fn increase_next_try(&self, uid: order::Uid) {
+        self.amounts.lock().unwrap().entry(uid).and_modify(|entry| {
+            entry.next_amount = entry
+                .next_amount
+                .checked_mul(U256::from(2))
+                .unwrap_or(entry.total_amount)
+                .min(entry.total_amount);
+            tracing::trace!(next_try =? entry.next_amount, "increased next fill amount");
+        });
+    }
+
+    /// Removes entries that have not been requested for a long time. This
+    /// allows us to remove orders that got settled by other solvers which
+    /// we are not able to notice.
+    pub fn collect_garbage(&self) {
+        const MAX_AGE: Duration = Duration::from_secs(60 * 10);
+        let now = Instant::now();
+
+        self.amounts
+            .lock()
+            .unwrap()
+            .retain(|_, entry| now.duration_since(entry.last_requested) < MAX_AGE)
+    }
+}
+
+#[derive(Debug)]
+struct CacheEntry {
+    next_amount: eth::U256,
+    total_amount: eth::U256,
+    last_requested: Instant,
+}
diff --git a/crates/solvers/src/domain/solver/dex/mod.rs b/crates/solvers/src/domain/solver/dex/mod.rs
new file mode 100644
index 0000000000..775c375151
--- /dev/null
+++ b/crates/solvers/src/domain/solver/dex/mod.rs
@@ -0,0 +1,231 @@
+//! A simple solver that matches orders directly with swaps from the external
+//! DEX and DEX aggregator APIs.
+
+use {
+    crate::{
+        domain::{
+            auction,
+            dex::{self, minimum_surplus::MinimumSurplusLimits, slippage::SlippageLimits},
+            eth,
+            order::{self, Order},
+            solution,
+            solver::dex::fills::Fills,
+        },
+        infra,
+    },
+    futures::{FutureExt, StreamExt, future, stream},
+    std::num::NonZeroUsize,
+    tracing::Instrument,
+};
+
+mod fills;
+
+pub struct Dex {
+    /// The DEX API client.
+    dex: infra::dex::Dex,
+
+    /// A DEX swap gas simulator for computing limit order fees.
+    simulator: infra::dex::Simulator,
+
+    /// The slippage configuration to use for the solver.
+    slippage: SlippageLimits,
+
+    /// The minimum surplus configuration to use for the solver.
+    minimum_surplus: MinimumSurplusLimits,
+
+    /// The number of concurrent requests to make.
+    concurrent_requests: NonZeroUsize,
+
+    /// Helps to manage the strategy to fill orders (especially partially
+    /// fillable orders).
+    fills: Fills,
+
+    /// Handles 429 Too Many Requests error with a retry mechanism
+    rate_limiter: rate_limit::RateLimiter,
+
+    /// Amount of gas that gets added to each swap to tweak the cost coverage of
+    /// the solver.
+    gas_offset: eth::Gas,
+
+    /// Whether to internalize the solution interactions using the Settlement
+    /// contract buffer.
+    internalize_interactions: bool,
+}
+
+/// The amount of time we aim the solver to finish before the final deadline is
+/// reached.
+const DEADLINE_SLACK: chrono::Duration = chrono::Duration::milliseconds(500);
+
+impl Dex {
+    pub fn new(dex: infra::dex::Dex, config: infra::config::dex::Config) -> Self {
+        let rate_limiter = rate_limit::RateLimiter::from_strategy(
+            config.rate_limiting_strategy,
+            "dex_api".to_string(),
+        );
+        Self {
+            dex,
+            simulator: infra::dex::Simulator::new(
+                &config.node_url,
+                config.contracts.settlement,
+                config.contracts.authenticator,
+            ),
+            slippage: config.slippage,
+            minimum_surplus: config.minimum_surplus,
+            concurrent_requests: config.concurrent_requests,
+            fills: Fills::new(config.smallest_partial_fill),
+            rate_limiter,
+            gas_offset: config.gas_offset,
+            internalize_interactions: config.internalize_interactions,
+        }
+    }
+
+    pub async fn solve(&self, auction: auction::Auction) -> Vec<solution::Solution> {
+        let mut solutions = Vec::new();
+        let solve_orders = async {
+            let mut stream = self.solution_stream(&auction);
+            while let Some(solution) = stream.next().await {
+                solutions.push(solution);
+            }
+        };
+
+        let deadline = auction
+            .deadline
+            .clone()
+            .reduce(DEADLINE_SLACK)
+            .remaining()
+            .unwrap_or_default();
+        if tokio::time::timeout(deadline, solve_orders).await.is_err() {
+            tracing::debug!("reached deadline; stopping to solve");
+        }
+
+        self.fills.collect_garbage();
+
+        solutions
+    }
+
+    fn solution_stream<'a>(
+        &'a self,
+        auction: &'a auction::Auction,
+    ) -> impl stream::Stream<Item = solution::Solution> + 'a {
+        stream::iter(auction.orders.iter())
+            .enumerate()
+            .map(|(i, order)| {
+                let span = tracing::info_span!("solve", order = %order.uid);
+                self.solve_order(order, &auction.tokens, auction.gas_price)
+                    .map(move |solution| solution.map(|s| s.with_id(solution::Id(i as u64))))
+                    .instrument(span)
+            })
+            .buffer_unordered(self.concurrent_requests.get())
+            .filter_map(future::ready)
+    }
+
+    async fn try_solve(
+        &self,
+        order: &Order,
+        dex_order: &dex::Order,
+        tokens: &auction::Tokens,
+    ) -> Option<dex::Swap> {
+        let dex_err_handler = |err: infra::dex::Error| {
+            infra::metrics::solve_error(err.format_variant());
+            match &err {
+                err @ infra::dex::Error::NotFound => {
+                    if order.partially_fillable {
+                        // Only adjust the amount to try next if we are sure the API
+                        // worked correctly yet still wasn't able to provide a swap.
+                        self.fills.reduce_next_try(order.uid);
+                    } else {
+                        tracing::debug!(?err, "skipping order");
+                    }
+                }
+                err @ infra::dex::Error::OrderNotSupported => {
+                    tracing::debug!(?err, "skipping order")
+                }
+                err @ infra::dex::Error::BadRequest => {
+                    tracing::warn!(?err, "bad request")
+                }
+                err @ infra::dex::Error::RateLimited => {
+                    tracing::debug!(?err, "encountered rate limit")
+                }
+                err @ infra::dex::Error::UnavailableForLegalReasons => {
+                    tracing::debug!(?err, "unavailable for legal reasons")
+                }
+                infra::dex::Error::Other(err) => {
+                    tracing::warn!(?err, "failed to get swap")
+                }
+            }
+            err
+        };
+        let swap = async {
+            let slippage = self.slippage.relative(&dex_order.amount(), tokens);
+            self.dex
+                .swap(dex_order, &slippage, tokens)
+                .await
+                .inspect(|_| infra::metrics::request_sent())
+                .map_err(dex_err_handler)
+        };
+        self.rate_limiter
+            .execute_with_back_off(swap, |result| {
+                matches!(result, Err(infra::dex::Error::RateLimited))
+            })
+            .await
+            .map_err(|err| match err {
+                rate_limit::Error::RateLimited => infra::dex::Error::RateLimited,
+            })
+            .and_then(|result| result)
+            .ok()
+            .filter(|swap| {
+                if !swap.satisfies(order) {
+                    tracing::debug!("swap does not satisfy order");
+                    if order.partially_fillable {
+                        self.fills.reduce_next_try(order.uid);
+                    }
+                    return false;
+                }
+
+                // Check minimum surplus requirement
+                let minimum_surplus = self.minimum_surplus.relative(&dex_order.amount(), tokens);
+                let valid_surplus = swap.satisfies_with_minimum_surplus(order, &minimum_surplus);
+                if !valid_surplus {
+                    tracing::debug!("swap does not meet minimum surplus requirement");
+                    if order.partially_fillable {
+                        self.fills.reduce_next_try(order.uid);
+                    }
+                }
+                valid_surplus
+            })
+    }
+
+    async fn solve_order(
+        &self,
+        order: &order::Order,
+        tokens: &auction::Tokens,
+        gas_price: auction::GasPrice,
+    ) -> Option<solution::Solution> {
+        let dex_order = self.fills.dex_order(order, tokens)?;
+        let swap = self.try_solve(order, &dex_order, tokens).await?;
+        let sell = tokens.reference_price(&order.sell.token);
+        let Some(solution) = swap
+            .into_solution(
+                order.clone(),
+                gas_price,
+                sell,
+                &self.simulator,
+                self.gas_offset,
+            )
+            .await
+        else {
+            tracing::debug!("no solution for swap");
+            return None;
+        };
+
+        tracing::debug!("solved");
+        // Maybe some liquidity appeared that enables a bigger fill.
+        self.fills.increase_next_try(order.uid);
+
+        if self.internalize_interactions {
+            Some(solution.with_buffers_internalizations(tokens))
+        } else {
+            Some(solution)
+        }
+    }
+}
diff --git a/crates/solvers/src/domain/solver/mod.rs b/crates/solvers/src/domain/solver/mod.rs
new file mode 100644
index 0000000000..6df8177037
--- /dev/null
+++ b/crates/solvers/src/domain/solver/mod.rs
@@ -0,0 +1,22 @@
+pub mod baseline;
+pub mod dex;
+
+pub use self::{
+    baseline::{Config, Request, Route, Segment, Solver as Baseline},
+    dex::Dex,
+};
+use crate::domain::{auction, solution};
+
+pub enum Solver {
+    Baseline(Baseline),
+    Dex(Box<Dex>),
+}
+
+impl Solver {
+    pub async fn solve(&self, auction: auction::Auction) -> Vec<solution::Solution> {
+        match self {
+            Solver::Baseline(s) => s.solve(auction).await,
+            Solver::Dex(s) => s.solve(auction).await,
+        }
+    }
+}
diff --git a/crates/solvers/src/infra/blockchain.rs b/crates/solvers/src/infra/blockchain.rs
new file mode 100644
index 0000000000..c90bfed091
--- /dev/null
+++ b/crates/solvers/src/infra/blockchain.rs
@@ -0,0 +1,4 @@
+/// Creates a node RPC instance.
+pub fn rpc(url: &reqwest::Url) -> ethrpc::Web3 {
+    ethrpc::web3(Default::default(), url, Some("base"))
+}
diff --git a/crates/solvers/src/infra/cli.rs b/crates/solvers/src/infra/cli.rs
index 49a13a1fbe..39efd1175a 100644
--- a/crates/solvers/src/infra/cli.rs
+++ b/crates/solvers/src/infra/cli.rs
@@ -43,4 +43,9 @@ pub enum Command {
         #[clap(long, env)]
         config: PathBuf,
     },
+    /// solve individual orders via the OKX DEX aggregator API
+    Okx {
+        #[clap(long, env)]
+        config: PathBuf,
+    },
 }
diff --git a/crates/solvers/src/infra/config.rs b/crates/solvers/src/infra/config/baseline.rs
similarity index 83%
rename from crates/solvers/src/infra/config.rs
rename to crates/solvers/src/infra/config/baseline.rs
index 08f61feae3..f2ce0053b0 100644
--- a/crates/solvers/src/infra/config.rs
+++ b/crates/solvers/src/infra/config/baseline.rs
@@ -7,7 +7,7 @@ use {
     price_estimation::gas::SETTLEMENT_OVERHEAD,
     reqwest::Url,
     serde::Deserialize,
-    std::{fmt::Debug, path::Path},
+    std::path::Path,
     tokio::fs,
 };
 
@@ -60,7 +60,7 @@ pub async fn load(path: &Path) -> solver::Config {
         .await
         .unwrap_or_else(|e| panic!("I/O error while reading {path:?}: {e:?}"));
     // Not printing detailed error because it could potentially leak secrets.
-    let config = unwrap_or_log(toml::de::from_str::<Config>(&data), &path);
+    let config = super::unwrap_or_log(toml::de::from_str::<Config>(&data), &path);
     let weth = match (config.chain_id, config.weth) {
         (Some(chain_id), None) => contracts::Contracts::for_chain(chain_id).weth,
         (None, Some(weth)) => eth::WethAddress(weth),
@@ -88,24 +88,6 @@ pub async fn load(path: &Path) -> solver::Config {
     }
 }
 
-/// Unwraps result or logs a `TOML` parsing error.
-fn unwrap_or_log<T, E, P>(result: Result<T, E>, path: &P) -> T
-where
-    E: Debug,
-    P: Debug,
-{
-    result.unwrap_or_else(|err| {
-        if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") {
-            panic!("failed to parse TOML config at {path:?}: {err:#?}")
-        } else {
-            panic!(
-                "failed to parse TOML config at: {path:?}. Set TOML_TRACE_ERROR=1 to print \
-                 parsing error but this may leak secrets."
-            )
-        }
-    })
-}
-
 /// Returns minimum gas used for settling a single order.
 /// (not accounting for the cost of additional interactions)
 fn default_gas_offset() -> i64 {
diff --git a/crates/solvers/src/infra/config/dex/file.rs b/crates/solvers/src/infra/config/dex/file.rs
new file mode 100644
index 0000000000..e36748cd66
--- /dev/null
+++ b/crates/solvers/src/infra/config/dex/file.rs
@@ -0,0 +1,208 @@
+//! Configuration parameters that get shared across all dex solvers.
+
+use {
+    crate::{
+        domain::{
+            dex::{minimum_surplus::MinimumSurplusLimits, slippage::SlippageLimits},
+            eth,
+        },
+        infra::{blockchain, config::unwrap_or_log, contracts},
+    },
+    bigdecimal::{BigDecimal, Zero},
+    number::serialization::HexOrDecimalU256,
+    serde::{Deserialize, de::DeserializeOwned},
+    serde_with::serde_as,
+    std::{num::NonZeroUsize, path::Path, time::Duration},
+    tokio::fs,
+};
+
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct Config {
+    /// The node URL to use for simulations.
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    node_url: reqwest::Url,
+
+    /// Optional CoW Protocol Settlement contract address. If not specified,
+    /// the default Settlement contract address will be used.
+    settlement: Option<eth::Address>,
+
+    /// The relative slippage allowed by the solver.
+    #[serde(default = "default_relative_slippage")]
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    relative_slippage: BigDecimal,
+
+    /// The absolute slippage allowed by the solver.
+    #[serde_as(as = "Option<HexOrDecimalU256>")]
+    absolute_slippage: Option<eth::U256>,
+
+    /// The relative minimum surplus required by the solver.
+    #[serde(default = "default_relative_minimum_surplus")]
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    relative_minimum_surplus: BigDecimal,
+
+    /// The absolute minimum surplus required by the solver.
+    #[serde_as(as = "Option<HexOrDecimalU256>")]
+    absolute_minimum_surplus: Option<eth::U256>,
+
+    /// The number of concurrent requests to make to the DEX aggregator API.
+    #[serde(default = "default_concurrent_requests")]
+    concurrent_requests: NonZeroUsize,
+
+    /// The amount of Ether a partially fillable order should be filled for at
+    /// least.
+    #[serde(default = "default_smallest_partial_fill")]
+    #[serde_as(as = "HexOrDecimalU256")]
+    smallest_partial_fill: eth::U256,
+
+    /// Back-off growth factor for rate limiting.
+    #[serde(default = "default_back_off_growth_factor")]
+    back_off_growth_factor: f64,
+
+    /// Minimum back-off time in seconds for rate limiting.
+    #[serde(with = "humantime_serde", default = "default_min_back_off")]
+    min_back_off: Duration,
+
+    /// Maximum back-off time in seconds for rate limiting.
+    #[serde(with = "humantime_serde", default = "default_max_back_off")]
+    max_back_off: Duration,
+
+    /// Settings specific to the wrapped dex API.
+    dex: toml::Value,
+
+    /// Amount of gas that gets added to each swap to adjust the cost coverage
+    /// of the solver.
+    #[serde(default = "default_gas_offset")]
+    #[serde_as(as = "HexOrDecimalU256")]
+    gas_offset: eth::U256,
+
+    /// How often the solver should poll the current block. If this value
+    /// is set each request will also have the `X-CURRENT-BLOCK-HASH` header set
+    /// updated based on the configured polling interval.
+    /// This is useful for caching requests on an egress proxy.
+    #[serde(with = "humantime_serde", default)]
+    current_block_poll_interval: Option<Duration>,
+
+    /// Whether to internalize the solution interactions using the Settlement
+    /// contract buffers.
+    #[serde(default = "default_internalize_interactions")]
+    internalize_interactions: bool,
+}
+
+fn default_relative_slippage() -> BigDecimal {
+    BigDecimal::new(1.into(), 2) // 1%
+}
+
+fn default_relative_minimum_surplus() -> BigDecimal {
+    BigDecimal::zero() // 0%
+}
+
+fn default_concurrent_requests() -> NonZeroUsize {
+    NonZeroUsize::new(1).unwrap()
+}
+
+fn default_smallest_partial_fill() -> eth::U256 {
+    eth::U256::from(10).pow(eth::U256::from(16)) // 0.01 ETH
+}
+
+fn default_back_off_growth_factor() -> f64 {
+    2.0
+}
+
+fn default_min_back_off() -> Duration {
+    Duration::from_secs(1)
+}
+
+fn default_max_back_off() -> Duration {
+    Duration::from_secs(8)
+}
+
+fn default_gas_offset() -> eth::U256 {
+    // Rough estimation of the gas overhead of settling a single
+    // trade via the settlement contract.
+    eth::U256::from(106_391)
+}
+
+fn default_internalize_interactions() -> bool {
+    true
+}
+
+/// Loads the base solver configuration from a TOML file.
+///
+/// # Panics
+///
+/// This method panics if the config is invalid or on I/O errors.
+pub async fn load<T: DeserializeOwned>(path: &Path) -> (super::Config, T) {
+    let data = fs::read_to_string(path)
+        .await
+        .unwrap_or_else(|e| panic!("I/O error while reading {path:?}: {e:?}"));
+
+    // Not printing detailed error because it could potentially leak secrets.
+    let config = unwrap_or_log(toml::de::from_str::<Config>(&data), &path);
+
+    let dex: T = unwrap_or_log(config.dex.try_into(), &path);
+
+    // Take advantage of the fact that deterministic deployment means that all
+    // CoW Protocol contracts have the same address.
+    let default_contracts = contracts::Contracts::for_chain_id(eth::ChainId::Mainnet);
+    let (settlement, authenticator) = if let Some(settlement) = config.settlement {
+        let authenticator =
+            {
+                let web3 = blockchain::rpc(&config.node_url);
+                let settlement = ::contracts::alloy::GPv2Settlement::Instance::new(
+                    settlement,
+                    web3.provider.clone(),
+                );
+                settlement.authenticator().call().await.unwrap_or_else(|e| {
+                    panic!("error reading authenticator contract address: {e:?}")
+                })
+            };
+        (settlement, authenticator)
+    } else {
+        (
+            default_contracts.settlement,
+            default_contracts.authenticator,
+        )
+    };
+
+    let block_stream = match config.current_block_poll_interval {
+        Some(interval) => Some(
+            #[allow(deprecated)]
+            ethrpc::block_stream::current_block_stream(config.node_url.clone(), interval)
+                .await
+                .unwrap(),
+        ),
+        None => None,
+    };
+
+    let config = super::Config {
+        node_url: config.node_url,
+        contracts: super::Contracts {
+            settlement,
+            authenticator,
+        },
+        slippage: SlippageLimits::new(
+            config.relative_slippage,
+            config.absolute_slippage.map(eth::Ether),
+        )
+        .expect("invalid slippage limits"),
+        minimum_surplus: MinimumSurplusLimits::new(
+            config.relative_minimum_surplus,
+            config.absolute_minimum_surplus.map(eth::Ether),
+        )
+        .expect("invalid minimum surplus limits"),
+        concurrent_requests: config.concurrent_requests,
+        smallest_partial_fill: eth::Ether(config.smallest_partial_fill),
+        rate_limiting_strategy: rate_limit::Strategy::try_new(
+            config.back_off_growth_factor,
+            config.min_back_off,
+            config.max_back_off,
+        )
+        .unwrap(),
+        gas_offset: eth::Gas(config.gas_offset),
+        block_stream,
+        internalize_interactions: config.internalize_interactions,
+    };
+    (config, dex)
+}
diff --git a/crates/solvers/src/infra/config/dex/mod.rs b/crates/solvers/src/infra/config/dex/mod.rs
new file mode 100644
index 0000000000..a51226eaeb
--- /dev/null
+++ b/crates/solvers/src/infra/config/dex/mod.rs
@@ -0,0 +1,32 @@
+pub mod file;
+pub mod okx;
+
+use {
+    crate::domain::{
+        dex::{minimum_surplus::MinimumSurplusLimits, slippage::SlippageLimits},
+        eth,
+    },
+    alloy::primitives::Address,
+    ethrpc::block_stream::CurrentBlockWatcher,
+    std::num::NonZeroUsize,
+};
+
+#[derive(Clone)]
+pub struct Contracts {
+    pub settlement: Address,
+    pub authenticator: Address,
+}
+
+#[derive(Clone)]
+pub struct Config {
+    pub node_url: reqwest::Url,
+    pub contracts: Contracts,
+    pub slippage: SlippageLimits,
+    pub minimum_surplus: MinimumSurplusLimits,
+    pub concurrent_requests: NonZeroUsize,
+    pub smallest_partial_fill: eth::Ether,
+    pub rate_limiting_strategy: rate_limit::Strategy,
+    pub gas_offset: eth::Gas,
+    pub block_stream: Option<CurrentBlockWatcher>,
+    pub internalize_interactions: bool,
+}
diff --git a/crates/solvers/src/infra/config/dex/okx/file.rs b/crates/solvers/src/infra/config/dex/okx/file.rs
new file mode 100644
index 0000000000..5e96a860b9
--- /dev/null
+++ b/crates/solvers/src/infra/config/dex/okx/file.rs
@@ -0,0 +1,115 @@
+use {
+    crate::{
+        domain::eth,
+        infra::{config::dex::file, dex::okx},
+    },
+    serde::Deserialize,
+    serde_with::serde_as,
+    std::path::Path,
+};
+
+#[serde_as]
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct Config {
+    /// The URL endpoint for the OKX swap API for sell orders (exactIn mode).
+    /// Uses V6 API by default.
+    #[serde(default = "default_sell_orders_endpoint")]
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    sell_orders_endpoint: reqwest::Url,
+
+    /// The URL endpoint for the OKX swap API for buy orders (exactOut mode).
+    /// If specified, the URL must point to the V5 API. Otherwise, buy orders
+    /// will be ignored.
+    #[serde(default)]
+    #[serde_as(as = "Option<serde_with::DisplayFromStr>")]
+    buy_orders_endpoint: Option<reqwest::Url>,
+
+    /// Optional base URL to use for signature generation for sell orders.
+    /// This is useful when requests go through a proxy but signatures must be
+    /// generated using the original OKX API URL path.
+    /// If not specified, uses sell_orders_endpoint for signature generation.
+    #[serde(default)]
+    #[serde_as(as = "Option<serde_with::DisplayFromStr>")]
+    sell_orders_signature_base_url: Option<reqwest::Url>,
+
+    /// Optional base URL to use for signature generation for buy orders.
+    /// This is useful when requests go through a proxy but signatures must be
+    /// generated using the original OKX API URL path.
+    /// If not specified, uses buy_orders_endpoint for signature generation.
+    #[serde(default)]
+    #[serde_as(as = "Option<serde_with::DisplayFromStr>")]
+    buy_orders_signature_base_url: Option<reqwest::Url>,
+
+    /// Chain ID used to automatically determine contract addresses.
+    chain_id: eth::ChainId,
+
+    /// OKX API credentials
+    #[serde(flatten)]
+    okx_credentials: OkxCredentialsConfig,
+
+    /// The percentage of the price impact allowed.
+    /// When set to 100%, the feature is disabled (default).
+    /// Note: OKX API default is 90% if this parameter is NOT sent.
+    #[serde(default = "default_price_impact_protection_percent")]
+    price_impact_protection_percent: f64,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct OkxCredentialsConfig {
+    /// OKX Project ID.
+    api_project_id: String,
+
+    /// OKX API Key.
+    api_key: String,
+
+    /// OKX Secret key used for signing request.
+    api_secret_key: String,
+
+    /// OKX Secret key passphrase.
+    api_passphrase: String,
+}
+
+impl From<OkxCredentialsConfig> for okx::OkxCredentialsConfig {
+    fn from(value: OkxCredentialsConfig) -> Self {
+        Self {
+            project_id: value.api_project_id,
+            api_key: value.api_key,
+            api_secret_key: value.api_secret_key,
+            api_passphrase: value.api_passphrase,
+        }
+    }
+}
+
+fn default_sell_orders_endpoint() -> reqwest::Url {
+    okx::DEFAULT_SELL_ORDERS_ENDPOINT.parse().unwrap()
+}
+
+fn default_price_impact_protection_percent() -> f64 {
+    1.0 // 100% - feature disabled by default
+}
+
+/// Load the OKX solver configuration from a TOML file.
+///
+/// # Panics
+///
+/// This method panics if the config is invalid or on I/O errors.
+pub async fn load(path: &Path) -> super::Config {
+    let (base, config) = file::load::<Config>(path).await;
+
+    super::Config {
+        okx: okx::Config {
+            sell_orders_endpoint: config.sell_orders_endpoint,
+            buy_orders_endpoint: config.buy_orders_endpoint,
+            sell_orders_signature_base_url: config.sell_orders_signature_base_url,
+            buy_orders_signature_base_url: config.buy_orders_signature_base_url,
+            chain_id: config.chain_id,
+            okx_credentials: config.okx_credentials.into(),
+            block_stream: base.block_stream.clone(),
+            settlement_contract: base.contracts.settlement,
+            price_impact_protection_percent: config.price_impact_protection_percent,
+        },
+        base,
+    }
+}
diff --git a/crates/solvers/src/infra/config/dex/okx/mod.rs b/crates/solvers/src/infra/config/dex/okx/mod.rs
new file mode 100644
index 0000000000..df781cf15e
--- /dev/null
+++ b/crates/solvers/src/infra/config/dex/okx/mod.rs
@@ -0,0 +1,6 @@
+pub mod file;
+
+pub struct Config {
+    pub okx: crate::infra::dex::okx::Config,
+    pub base: super::Config,
+}
diff --git a/crates/solvers/src/infra/config/mod.rs b/crates/solvers/src/infra/config/mod.rs
new file mode 100644
index 0000000000..18c0e2dc40
--- /dev/null
+++ b/crates/solvers/src/infra/config/mod.rs
@@ -0,0 +1,22 @@
+pub mod baseline;
+pub mod dex;
+
+use std::fmt::Debug;
+
+/// Unwraps result or logs a `TOML` parsing error.
+pub(crate) fn unwrap_or_log<T, E, P>(result: Result<T, E>, path: &P) -> T
+where
+    E: Debug,
+    P: Debug,
+{
+    result.unwrap_or_else(|err| {
+        if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") {
+            panic!("failed to parse TOML config at {path:?}: {err:#?}")
+        } else {
+            panic!(
+                "failed to parse TOML config at: {path:?}. Set TOML_TRACE_ERROR=1 to print \
+                 parsing error but this may leak secrets."
+            )
+        }
+    })
+}
diff --git a/crates/solvers/src/infra/contracts.rs b/crates/solvers/src/infra/contracts.rs
index f57e5559e3..0df89afe11 100644
--- a/crates/solvers/src/infra/contracts.rs
+++ b/crates/solvers/src/infra/contracts.rs
@@ -1,17 +1,43 @@
-use {crate::domain::eth, chain::Chain, contracts::alloy::WETH9};
+use {
+    crate::domain::eth,
+    alloy::primitives::Address,
+    chain::Chain,
+    contracts::alloy::{GPv2AllowListAuthentication, GPv2Settlement, WETH9},
+};
 
 #[derive(Clone, Debug)]
 pub struct Contracts {
     pub weth: eth::WethAddress,
+    pub settlement: Address,
+    pub authenticator: Address,
 }
 
 impl Contracts {
     pub fn for_chain(chain: Chain) -> Self {
+        let chain_id = chain.id();
         Self {
             weth: eth::WethAddress(
-                WETH9::deployment_address(&chain.id())
+                WETH9::deployment_address(&chain_id)
                     .expect("there should be a contract address for all supported chains"),
             ),
+            settlement: GPv2Settlement::deployment_address(&chain_id)
+                .expect("there should be a contract address for all supported chains"),
+            authenticator: GPv2AllowListAuthentication::deployment_address(&chain_id)
+                .expect("there should be a contract address for all supported chains"),
+        }
+    }
+
+    pub fn for_chain_id(chain_id: eth::ChainId) -> Self {
+        let id = chain_id as u64;
+        Self {
+            weth: eth::WethAddress(
+                WETH9::deployment_address(&id)
+                    .expect("there should be a contract address for all supported chains"),
+            ),
+            settlement: GPv2Settlement::deployment_address(&id)
+                .expect("there should be a contract address for all supported chains"),
+            authenticator: GPv2AllowListAuthentication::deployment_address(&id)
+                .expect("there should be a contract address for all supported chains"),
         }
     }
 }
diff --git a/crates/solvers/src/infra/dex/mod.rs b/crates/solvers/src/infra/dex/mod.rs
new file mode 100644
index 0000000000..1825f2a2f8
--- /dev/null
+++ b/crates/solvers/src/infra/dex/mod.rs
@@ -0,0 +1,106 @@
+use {
+    crate::domain::{auction, dex},
+    ethrpc::block_stream::CurrentBlockWatcher,
+    reqwest::RequestBuilder,
+};
+
+pub mod okx;
+pub mod simulator;
+
+pub use self::simulator::Simulator;
+
+/// A supported external DEX/DEX aggregator API.
+pub enum Dex {
+    Okx(Box<okx::Okx>),
+}
+
+impl Dex {
+    /// Computes a swap (including calldata, estimated input and output amounts
+    /// and the required allowance) for the specified order.
+    ///
+    /// These computed swaps can be used to generate single order solutions.
+    pub async fn swap(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+        _tokens: &auction::Tokens,
+    ) -> Result<dex::Swap, Error> {
+        let swap = match self {
+            Dex::Okx(okx) => okx.swap(order, slippage).await?,
+        };
+        Ok(swap)
+    }
+}
+
+/// A categorized error that occurred building a swap with an external DEX/DEX
+/// aggregator.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("order type is not supported")]
+    OrderNotSupported,
+    #[error("no valid swap interaction could be found")]
+    NotFound,
+    #[error("invalid request")]
+    BadRequest,
+    #[error("rate limited")]
+    RateLimited,
+    #[error("unavailable for legal reasons, banned tokens or similar")]
+    UnavailableForLegalReasons,
+    #[error(transparent)]
+    Other(Box<dyn std::error::Error + Send + Sync>),
+}
+
+/// A wrapper around [`reqwest::Client`] to pre-set commonly used headers
+/// and other properties on each request.
+pub(crate) struct Client {
+    /// Client to send requests.
+    client: reqwest::Client,
+
+    /// Block stream to read the current block.
+    block_stream: Option<CurrentBlockWatcher>,
+}
+
+impl Client {
+    pub fn new(client: reqwest::Client, block_stream: Option<CurrentBlockWatcher>) -> Self {
+        Self {
+            client,
+            block_stream,
+        }
+    }
+
+    /// Prepares a request builder which already has additional headers set.
+    pub fn request(&self, method: reqwest::Method, url: reqwest::Url) -> RequestBuilder {
+        let request = self.client.request(method, url);
+        if let Some(stream) = &self.block_stream {
+            // Set this header to easily support caching in an egress proxy.
+            request.header("X-CURRENT-BLOCK-HASH", stream.borrow().hash.to_string())
+        } else {
+            request
+        }
+    }
+}
+
+impl Error {
+    /// for instrumentization purposes
+    pub fn format_variant(&self) -> &'static str {
+        match self {
+            Self::OrderNotSupported => "OrderNotSupported",
+            Self::NotFound => "NotFound",
+            Self::BadRequest => "BadRequest",
+            Self::RateLimited => "RateLimited",
+            Self::UnavailableForLegalReasons => "UnavailableForLegalReasons",
+            Self::Other(_) => "Other",
+        }
+    }
+}
+
+impl From<okx::Error> for Error {
+    fn from(err: okx::Error) -> Self {
+        match err {
+            okx::Error::OrderNotSupported => Self::OrderNotSupported,
+            okx::Error::NotFound => Self::NotFound,
+            okx::Error::RateLimited => Self::RateLimited,
+            _ => Self::Other(Box::new(err)),
+        }
+    }
+}
diff --git a/crates/solvers/src/infra/dex/okx/dto.rs b/crates/solvers/src/infra/dex/okx/dto.rs
new file mode 100644
index 0000000000..6a72481069
--- /dev/null
+++ b/crates/solvers/src/infra/dex/okx/dto.rs
@@ -0,0 +1,312 @@
+//! DTOs for the OKX swap API. Full documentation for the API can be found
+//! [here](https://web3.okx.com/build/dev-docs/wallet-api/dex-swap).
+
+use {
+    crate::domain::{
+        dex,
+        eth::{self, TokenAddress},
+        order,
+    },
+    alloy::primitives::U256,
+    bigdecimal::BigDecimal,
+    bytes_hex::BytesHex,
+    number::serialization::HexOrDecimalU256,
+    serde::{Deserialize, Serialize},
+    serde_with::serde_as,
+};
+
+/// A OKX API swap request parameters (only mandatory fields).
+/// OKX v6 supports both sell orders (exactIn) and buy orders (exactOut).
+///
+/// See [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-swap)
+/// documentation for more detailed information on each parameter.
+#[serde_as]
+#[derive(Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapRequest {
+    /// Chain ID
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub chain_index: u64,
+
+    /// Input amount of a token to be sold or bought set in minimal divisible
+    /// units.
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub amount: U256,
+
+    /// Contract address of a token to be sent
+    pub from_token_address: eth::Address,
+
+    /// Contract address of a token to be received
+    pub to_token_address: eth::Address,
+
+    /// Limit of price slippage you are willing to accept
+    pub slippage_percent: Slippage,
+
+    /// User's wallet address. Where the sell tokens will be taken from.
+    pub user_wallet_address: eth::Address,
+
+    /// Where the buy tokens get sent to.
+    pub swap_receiver_address: eth::Address,
+
+    /// Swap mode: "exactIn" for sell orders (default), "exactOut" for buy
+    /// orders
+    pub swap_mode: SwapMode,
+
+    /// The percentage of the price impact allowed.
+    /// When set to 100%, the feature is disabled.
+    /// OKX API default is 90% if this parameter is not sent.
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub price_impact_protection_percent: BigDecimal,
+}
+
+/// A OKX slippage amount.
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct Slippage(BigDecimal);
+
+/// A OKX swap mode.
+#[derive(Clone, Debug, Serialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub enum SwapMode {
+    #[default]
+    ExactIn,
+    ExactOut,
+}
+
+impl SwapRequest {
+    pub fn with_domain(self, order: &dex::Order, slippage: &dex::Slippage) -> Self {
+        let swap_mode = match order.side {
+            order::Side::Sell => SwapMode::ExactIn,
+            order::Side::Buy => SwapMode::ExactOut,
+        };
+
+        Self {
+            from_token_address: order.sell.0,
+            to_token_address: order.buy.0,
+            amount: order.amount.get(),
+            slippage_percent: Slippage(slippage.as_factor().clone()),
+            swap_mode,
+            ..self
+        }
+    }
+}
+
+/// A OKX API V5 swap request parameters (only mandatory fields).
+/// Currently, only V5 API supports buy orders.
+#[serde_as]
+#[derive(Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapRequestV5 {
+    /// Chain ID (V5 uses chainId instead of chainIndex)
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub chain_id: u64,
+
+    /// Input amount of a token to be sold or bought set in minimal divisible
+    /// units.
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub amount: U256,
+
+    /// Contract address of a token to be sent
+    pub from_token_address: eth::Address,
+
+    /// Contract address of a token to be received
+    pub to_token_address: eth::Address,
+
+    /// Limit of price slippage you are willing to accept (V5 uses slippage
+    /// instead of slippagePercent)
+    pub slippage: Slippage,
+
+    /// User's wallet address. Where the sell tokens will be taken from.
+    pub user_wallet_address: eth::Address,
+
+    /// Where the buy tokens get sent to.
+    pub swap_receiver_address: eth::Address,
+
+    /// Swap mode: "exactIn" for sell orders (default), "exactOut" for buy
+    /// orders
+    pub swap_mode: SwapMode,
+
+    /// The percentage of the price impact allowed.
+    /// When set to 100%, the feature is disabled.
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub price_impact_protection_percent: BigDecimal,
+}
+
+impl From<&SwapRequest> for SwapRequestV5 {
+    fn from(v6_request: &SwapRequest) -> Self {
+        Self {
+            chain_id: v6_request.chain_index,
+            amount: v6_request.amount,
+            from_token_address: v6_request.from_token_address,
+            to_token_address: v6_request.to_token_address,
+            slippage: v6_request.slippage_percent.clone(),
+            user_wallet_address: v6_request.user_wallet_address,
+            swap_receiver_address: v6_request.swap_receiver_address,
+            swap_mode: v6_request.swap_mode.clone(),
+            price_impact_protection_percent: v6_request.price_impact_protection_percent.clone(),
+        }
+    }
+}
+
+/// A OKX API swap response.
+///
+/// See [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-swap)
+/// documentation for more detailed information on each parameter.
+#[serde_as]
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapResponse {
+    /// Quote execution path.
+    pub router_result: SwapResponseRouterResult,
+
+    /// Contract related response.
+    pub tx: SwapResponseTx,
+}
+
+/// A OKX API swap response - quote execution path.
+/// Deserializing fields which are only used by the implementation.
+/// For all possible fields look into the documentation:
+/// [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-swap)
+#[serde_as]
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapResponseRouterResult {
+    /// The information of a token to be sold.
+    pub from_token: SwapResponseFromToToken,
+
+    /// The information of a token to be bought.
+    pub to_token: SwapResponseFromToToken,
+
+    /// The input amount of a token to be sold.
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub from_token_amount: U256,
+
+    /// The resulting amount of a token to be bought.
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub to_token_amount: U256,
+}
+
+/// A OKX API swap response - token information.
+/// Deserializing fields which are only used by the implementation.
+/// For all possible fields look into the documentation:
+/// [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-swap)
+#[serde_as]
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapResponseFromToToken {
+    /// Address of the token smart contract.
+    pub token_contract_address: eth::Address,
+}
+
+/// A OKX API swap response - contract related information.
+/// Deserializing fields which are only used by the implementation.
+/// For all possible fields look into the documentation:
+/// [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-swap)
+#[serde_as]
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapResponseTx {
+    /// Estimated amount of the gas limit.
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub gas: U256,
+
+    /// The contract address of OKX DEX router.
+    pub to: eth::Address,
+
+    /// Call data.
+    #[serde_as(as = "BytesHex")]
+    pub data: Vec<u8>,
+}
+
+/// A OKX API approve transaction request.
+///
+/// See [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-approve-transaction)
+/// documentation for more detailed information on each parameter.
+#[serde_as]
+#[derive(Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApproveTransactionRequest {
+    /// Chain ID
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub chain_index: u64,
+
+    /// Contract address of a token to be permitted.
+    pub token_contract_address: eth::Address,
+
+    /// The amount of token that needs to be permitted (in minimal divisible
+    /// units).
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub approve_amount: U256,
+}
+
+impl ApproveTransactionRequest {
+    pub fn new(chain_index: u64, token: TokenAddress, amount: U256) -> Self {
+        Self {
+            chain_index,
+            token_contract_address: token.0,
+            approve_amount: amount,
+        }
+    }
+}
+
+/// A OKX API V5 approve transaction request.
+#[serde_as]
+#[derive(Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApproveTransactionRequestV5 {
+    /// Chain ID (V5 uses chainId instead of chainIndex)
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub chain_id: u64,
+
+    /// Contract address of a token to be permitted.
+    pub token_contract_address: eth::Address,
+
+    /// The amount of token that needs to be permitted (in minimal divisible
+    /// units).
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub approve_amount: U256,
+}
+
+impl From<&ApproveTransactionRequest> for ApproveTransactionRequestV5 {
+    fn from(v6_request: &ApproveTransactionRequest) -> Self {
+        Self {
+            chain_id: v6_request.chain_index,
+            token_contract_address: v6_request.token_contract_address,
+            approve_amount: v6_request.approve_amount,
+        }
+    }
+}
+
+/// A OKX API approve transaction response.
+/// Deserializing fields which are only used by the implementation.
+/// See [API](https://web3.okx.com/build/dev-docs/wallet-api/dex-approve-transaction)
+/// documentation for more detailed information on each parameter.
+#[serde_as]
+#[derive(Clone, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApproveTransactionResponse {
+    /// The contract address of OKX DEX approve.
+    pub dex_contract_address: eth::Address,
+}
+
+/// A OKX API response - generic wrapper for success and failure cases.
+#[serde_as]
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Response<T> {
+    /// Error code, 0 for success, otherwise one of:
+    /// [error codes](https://web3.okx.com/build/dev-docs/wallet-api/dex-error-code)
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub code: i64,
+
+    /// Response data.
+    pub data: Vec<T>,
+
+    /// Error code text message.
+    pub msg: String,
+}
+
+#[derive(Deserialize)]
+pub struct Error {
+    pub code: i64,
+    pub reason: String,
+}
diff --git a/crates/solvers/src/infra/dex/okx/mod.rs b/crates/solvers/src/infra/dex/okx/mod.rs
new file mode 100644
index 0000000000..e71d04ba82
--- /dev/null
+++ b/crates/solvers/src/infra/dex/okx/mod.rs
@@ -0,0 +1,514 @@
+use {
+    crate::{
+        domain::{dex, eth, order},
+        util,
+    },
+    alloy::primitives::{Address, U256},
+    base64::prelude::*,
+    bigdecimal::FromPrimitive,
+    chrono::SecondsFormat,
+    ethrpc::block_stream::CurrentBlockWatcher,
+    hmac::{Hmac, Mac},
+    moka::future::Cache,
+    reqwest::{StatusCode, header::HeaderValue},
+    serde::{Serialize, de::DeserializeOwned},
+    sha2::Sha256,
+    std::sync::atomic::{self, AtomicU64},
+    tracing::Instrument,
+};
+
+mod dto;
+
+/// Default OKX v6 DEX aggregator API endpoint (for sell orders - exactIn).
+pub const DEFAULT_SELL_ORDERS_ENDPOINT: &str = "https://web3.okx.com/api/v6/dex/aggregator/";
+
+const DEFAULT_DEX_APPROVED_ADDRESSES_CACHE_SIZE: u64 = 100;
+
+/// Cache key for OKX DEX approve contract addresses.
+/// V5 and V6 APIs may return different contract addresses for the same token,
+/// so we need to cache separately by order side.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+struct ApprovalCacheKey {
+    token: eth::TokenAddress,
+    side: order::Side,
+}
+
+/// Bindings to the OKX swap API.
+pub struct Okx {
+    client: super::Client,
+    sell_orders_endpoint: reqwest::Url,
+    buy_orders_endpoint: Option<reqwest::Url>,
+    sell_orders_signature_base_url: reqwest::Url,
+    buy_orders_signature_base_url: Option<reqwest::Url>,
+    api_secret_key: String,
+    defaults: dto::SwapRequest,
+    /// Cache which stores a map of (Token Address, Order Side) to contract
+    /// address of OKX DEX approve contract. Separate caching by side is
+    /// needed because V5 API (buy orders) and V6 API (sell orders) return
+    /// different addresses.
+    dex_approved_addresses: Cache<ApprovalCacheKey, eth::ContractAddress>,
+}
+
+pub struct Config {
+    /// The URL for the OKX swap API for sell orders (exactIn mode).
+    /// Uses V6 API by default.
+    pub sell_orders_endpoint: reqwest::Url,
+
+    /// The URL for the OKX swap API for buy orders (exactOut mode).
+    /// If specified, the URL must point to the V5 API. Otherwise, buy orders
+    /// will be ignored.
+    pub buy_orders_endpoint: Option<reqwest::Url>,
+
+    /// Optional base URL to use for signature generation for sell orders.
+    /// This is useful when requests go through a proxy but signatures must be
+    /// generated using the original OKX API URL path.
+    /// If not specified, uses sell_orders_endpoint for signature generation.
+    pub sell_orders_signature_base_url: Option<reqwest::Url>,
+
+    /// Optional base URL to use for signature generation for buy orders.
+    /// This is useful when requests go through a proxy but signatures must be
+    /// generated using the original OKX API URL path.
+    /// If not specified, uses buy_orders_endpoint for signature generation.
+    pub buy_orders_signature_base_url: Option<reqwest::Url>,
+
+    pub chain_id: eth::ChainId,
+
+    pub settlement_contract: Address,
+
+    /// Credentials used to access OKX API.
+    pub okx_credentials: OkxCredentialsConfig,
+
+    /// The stream that yields every new block.
+    pub block_stream: Option<CurrentBlockWatcher>,
+
+    /// The percentage of the price impact allowed.
+    /// When set to 100%, the feature is disabled.
+    pub price_impact_protection_percent: f64,
+}
+
+pub struct OkxCredentialsConfig {
+    /// OKX project ID to use.
+    pub project_id: String,
+
+    /// OKX API key.
+    pub api_key: String,
+
+    /// OKX API key additional security token.
+    pub api_secret_key: String,
+
+    /// OKX API key passphrase used to encrypt secret key.
+    pub api_passphrase: String,
+}
+
+impl Okx {
+    pub fn try_new(config: Config) -> Result<Self, CreationError> {
+        let client = {
+            let mut api_key =
+                reqwest::header::HeaderValue::from_str(&config.okx_credentials.api_key)?;
+            api_key.set_sensitive(true);
+            let mut api_passphrase =
+                reqwest::header::HeaderValue::from_str(&config.okx_credentials.api_passphrase)?;
+            api_passphrase.set_sensitive(true);
+
+            let mut headers = reqwest::header::HeaderMap::new();
+            headers.insert(
+                "OK-ACCESS-PROJECT",
+                reqwest::header::HeaderValue::from_str(&config.okx_credentials.project_id)?,
+            );
+            headers.insert("OK-ACCESS-KEY", api_key);
+            headers.insert("OK-ACCESS-PASSPHRASE", api_passphrase);
+
+            let client = reqwest::Client::builder()
+                .default_headers(headers)
+                .build()?;
+            super::Client::new(client, config.block_stream)
+        };
+
+        if config.price_impact_protection_percent < 0.0
+            || config.price_impact_protection_percent > 100.0
+        {
+            return Err(CreationError::InvalidPriceImpactProtection(
+                config.price_impact_protection_percent,
+            ));
+        }
+        let price_impact_protection =
+            bigdecimal::BigDecimal::from_f64(config.price_impact_protection_percent)
+                .ok_or_else(|| {
+                    CreationError::InvalidPriceImpactProtection(
+                        config.price_impact_protection_percent,
+                    )
+                })?
+                .normalized();
+
+        let defaults = dto::SwapRequest {
+            chain_index: config.chain_id as u64,
+            // Funds first get moved in and out of the settlement contract so we
+            // have use that address here to generate the correct calldata.
+            swap_receiver_address: config.settlement_contract,
+            user_wallet_address: config.settlement_contract,
+            price_impact_protection_percent: price_impact_protection,
+            ..Default::default()
+        };
+
+        Ok(Self {
+            client,
+            sell_orders_endpoint: config.sell_orders_endpoint.clone(),
+            buy_orders_endpoint: config.buy_orders_endpoint.clone(),
+            sell_orders_signature_base_url: config
+                .sell_orders_signature_base_url
+                .unwrap_or(config.sell_orders_endpoint),
+            buy_orders_signature_base_url: config
+                .buy_orders_signature_base_url
+                .or(config.buy_orders_endpoint),
+            api_secret_key: config.okx_credentials.api_secret_key,
+            defaults,
+            dex_approved_addresses: Cache::new(DEFAULT_DEX_APPROVED_ADDRESSES_CACHE_SIZE),
+        })
+    }
+
+    pub async fn swap(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+    ) -> Result<dex::Swap, Error> {
+        // Set up a tracing span to make debugging of API requests easier.
+        static ID: AtomicU64 = AtomicU64::new(0);
+        let id = ID.fetch_add(1, atomic::Ordering::Relaxed);
+
+        let (swap_response, dex_contract_address) = self
+            .handle_api_requests(order, slippage)
+            .instrument(tracing::trace_span!("swap", id = %id))
+            .await?;
+
+        // Increasing returned gas by 50% according to the documentation:
+        // https://web3.okx.com/build/dev-docs/wallet-api/dex-swap (gas field description in Response param)
+        let gas = swap_response
+            .tx
+            .gas
+            .checked_add(swap_response.tx.gas / U256::from(2))
+            .ok_or(Error::GasCalculationFailed)?;
+
+        // For buy orders (ExactOut mode), the slippage is on the input token,
+        // so we need to use U256::MAX allowance to cover the maximum possible
+        // input.
+        let allowance_amount =
+            if self.buy_orders_endpoint.is_some() && order.side == order::Side::Buy {
+                eth::U256::MAX
+            } else {
+                swap_response.router_result.from_token_amount
+            };
+
+        Ok(dex::Swap {
+            calls: vec![dex::Call {
+                to: swap_response.tx.to,
+                calldata: swap_response.tx.data.clone(),
+            }],
+            input: eth::Asset {
+                token: swap_response
+                    .router_result
+                    .from_token
+                    .token_contract_address
+                    .into(),
+                amount: swap_response.router_result.from_token_amount,
+            },
+            output: eth::Asset {
+                token: swap_response
+                    .router_result
+                    .to_token
+                    .token_contract_address
+                    .into(),
+                amount: swap_response.router_result.to_token_amount,
+            },
+            allowance: dex::Allowance {
+                spender: dex_contract_address.0,
+                amount: dex::Amount::new(allowance_amount),
+            },
+            gas: eth::Gas(gas),
+        })
+    }
+
+    /// Routes API requests based on order side.
+    ///
+    /// - Sell orders: Parallel execution of /swap and /approve-transaction
+    /// - Buy orders: Sequential execution (swap first, then approval with exact
+    ///   amount)
+    async fn handle_api_requests(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+    ) -> Result<(dto::SwapResponse, eth::ContractAddress), Error> {
+        match order.side {
+            order::Side::Sell => self.handle_sell_order(order, slippage).await,
+            order::Side::Buy => self.handle_buy_order(order, slippage).await,
+        }
+    }
+
+    /// Handle sell orders with parallel API requests.
+    ///
+    /// Since the approval amount is known upfront from `order.amount`,
+    /// we can execute `/swap` and `/approve-transaction` in parallel for better
+    /// performance.
+    async fn handle_sell_order(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+    ) -> Result<(dto::SwapResponse, eth::ContractAddress), Error> {
+        let swap_future = async {
+            let swap_request = self.defaults.clone().with_domain(order, slippage);
+            self.send_get_request(
+                &self.sell_orders_endpoint,
+                &self.sell_orders_signature_base_url,
+                "swap",
+                &swap_request,
+            )
+            .await
+        };
+
+        let approve_future = async {
+            let approve_request = dto::ApproveTransactionRequest::new(
+                self.defaults.chain_index,
+                order.sell,
+                order.amount.get(),
+            );
+
+            let approve_tx: dto::ApproveTransactionResponse = self
+                .send_get_request(
+                    &self.sell_orders_endpoint,
+                    &self.sell_orders_signature_base_url,
+                    "approve-transaction",
+                    &approve_request,
+                )
+                .await?;
+
+            Ok(eth::ContractAddress(approve_tx.dex_contract_address))
+        };
+
+        tokio::try_join!(
+            swap_future,
+            self.cache_approval_address(order, approve_future)
+        )
+    }
+
+    /// Handle buy orders with sequential API requests.
+    ///
+    /// Since the approval amount depends on the swap response
+    /// (`from_token_amount`), we must execute `/swap` first, then
+    /// `/approve-transaction`.
+    async fn handle_buy_order(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+    ) -> Result<(dto::SwapResponse, eth::ContractAddress), Error> {
+        let endpoint = self
+            .buy_orders_endpoint
+            .as_ref()
+            .ok_or(Error::OrderNotSupported)?;
+
+        let signature_base_url = self
+            .buy_orders_signature_base_url
+            .as_ref()
+            .ok_or(Error::OrderNotSupported)?;
+
+        let swap_request_v6 = self.defaults.clone().with_domain(order, slippage);
+        let swap_request_v5: dto::SwapRequestV5 = (&swap_request_v6).into();
+        let swap_response: dto::SwapResponse = self
+            .send_get_request(endpoint, signature_base_url, "swap", &swap_request_v5)
+            .await?;
+
+        let approve_future = async {
+            let approve_request = dto::ApproveTransactionRequest::new(
+                self.defaults.chain_index,
+                order.sell,
+                swap_response.router_result.from_token_amount,
+            );
+            let approve_request_v5: dto::ApproveTransactionRequestV5 = (&approve_request).into();
+
+            let approve_tx: dto::ApproveTransactionResponse = self
+                .send_get_request(
+                    endpoint,
+                    signature_base_url,
+                    "approve-transaction",
+                    &approve_request_v5,
+                )
+                .await?;
+
+            Ok(eth::ContractAddress(approve_tx.dex_contract_address))
+        };
+
+        let dex_approved_address = self.cache_approval_address(order, approve_future).await?;
+
+        Ok((swap_response, dex_approved_address))
+    }
+
+    /// Helper to cache approval addresses.
+    async fn cache_approval_address<F>(
+        &self,
+        order: &dex::Order,
+        future: F,
+    ) -> Result<eth::ContractAddress, Error>
+    where
+        F: Future<Output = Result<eth::ContractAddress, Error>>,
+    {
+        self.dex_approved_addresses
+            .try_get_with(
+                ApprovalCacheKey {
+                    token: order.sell,
+                    side: order.side,
+                },
+                future,
+            )
+            .await
+            .map_err(|_: std::sync::Arc<Error>| Error::ApproveTransactionRequestFailed(order.sell))
+    }
+
+    /// OKX requires signature of the request to be added as dedicated HTTP
+    /// Header. More information on generating the signature can be found in
+    /// OKX documentation: https://web3.okx.com/build/dev-docs/wallet-api/rest-authentication
+    fn generate_signature(
+        &self,
+        request: &reqwest::Request,
+        signature_base_url: &reqwest::Url,
+        timestamp: &str,
+    ) -> Result<String, Error> {
+        let mut data = String::new();
+        data.push_str(timestamp);
+        data.push_str(request.method().as_str());
+        data.push_str(signature_base_url.path());
+        data.push('?');
+        data.push_str(request.url().query().ok_or(Error::SignRequestFailed)?);
+
+        let mut mac = Hmac::<Sha256>::new_from_slice(self.api_secret_key.as_bytes())
+            .map_err(|_| Error::SignRequestFailed)?;
+        mac.update(data.as_bytes());
+        let signature = mac.finalize().into_bytes();
+
+        Ok(BASE64_STANDARD.encode(signature))
+    }
+
+    /// OKX Error codes: [link](https://web3.okx.com/build/dev-docs/wallet-api/dex-error-code)
+    fn handle_api_error(code: i64, message: &str) -> Result<(), Error> {
+        Err(match code {
+            0 => return Ok(()),
+            82000 => Error::NotFound, // Insufficient liquidity
+            82104 => Error::NotFound, // Token not supported
+            82112 => Error::NotFound, // Internal OKX risk validation failed
+            50011 => Error::RateLimited,
+            _ => Error::Api {
+                code,
+                reason: message.to_string(),
+            },
+        })
+    }
+
+    async fn send_get_request<T, U>(
+        &self,
+        base_url: &reqwest::Url,
+        signature_base_url: &reqwest::Url,
+        endpoint: &str,
+        query: &T,
+    ) -> Result<U, Error>
+    where
+        T: Serialize,
+        U: DeserializeOwned + Clone,
+    {
+        let mut request_builder = self
+            .client
+            .request(
+                reqwest::Method::GET,
+                base_url
+                    .join(endpoint)
+                    .map_err(|_| Error::RequestBuildFailed)?,
+            )
+            .query(query);
+
+        let request = request_builder
+            .try_clone()
+            .ok_or(Error::RequestBuildFailed)?
+            .build()
+            .map_err(|_| Error::RequestBuildFailed)?;
+
+        let signature_url = signature_base_url
+            .join(endpoint)
+            .map_err(|_| Error::RequestBuildFailed)?;
+
+        let timestamp = &chrono::Utc::now()
+            .to_rfc3339_opts(SecondsFormat::Millis, true)
+            .to_string();
+        let signature = self.generate_signature(&request, &signature_url, timestamp)?;
+
+        request_builder = request_builder.header(
+            "OK-ACCESS-TIMESTAMP",
+            reqwest::header::HeaderValue::from_str(timestamp)
+                .map_err(|_| Error::RequestBuildFailed)?,
+        );
+        request_builder = request_builder.header(
+            "OK-ACCESS-SIGN",
+            HeaderValue::from_str(&signature).map_err(|_| Error::RequestBuildFailed)?,
+        );
+
+        let response = util::http::roundtrip!(
+            <dto::Response<U>, dto::Error>;
+            request_builder
+        )
+        .await?;
+
+        Self::handle_api_error(response.code, &response.msg)?;
+        response.data.first().cloned().ok_or(Error::NotFound)
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum CreationError {
+    #[error(transparent)]
+    Header(#[from] reqwest::header::InvalidHeaderValue),
+    #[error(transparent)]
+    Client(#[from] reqwest::Error),
+    #[error("invalid price impact protection percent {0}, must be between 0.0 and 1.0")]
+    InvalidPriceImpactProtection(f64),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("failed to build the request")]
+    RequestBuildFailed,
+    #[error("failed to sign the request")]
+    SignRequestFailed,
+    #[error("calculating output gas failed")]
+    GasCalculationFailed,
+    #[error("unable to find a quote")]
+    NotFound,
+    #[error("order type is not supported")]
+    OrderNotSupported,
+    #[error("rate limited")]
+    RateLimited,
+    #[error("failed to get approve-transaction response for token address: {0:?}")]
+    ApproveTransactionRequestFailed(eth::TokenAddress),
+    #[error("api error code {code}: {reason}")]
+    Api { code: i64, reason: String },
+    #[error(transparent)]
+    Http(util::http::Error),
+}
+
+impl From<util::http::RoundtripError<dto::Error>> for Error {
+    fn from(err: util::http::RoundtripError<dto::Error>) -> Self {
+        match err {
+            util::http::RoundtripError::Http(err) => {
+                if let util::http::Error::Status(code, _) = err {
+                    match code {
+                        StatusCode::TOO_MANY_REQUESTS => Self::RateLimited,
+                        _ => Self::Http(err),
+                    }
+                } else {
+                    Self::Http(err)
+                }
+            }
+            util::http::RoundtripError::Api(err) => match err.code {
+                429 => Self::RateLimited,
+                _ => Self::Api {
+                    code: err.code,
+                    reason: err.reason,
+                },
+            },
+        }
+    }
+}
diff --git a/crates/solvers/src/infra/dex/simulator.rs b/crates/solvers/src/infra/dex/simulator.rs
new file mode 100644
index 0000000000..d154744728
--- /dev/null
+++ b/crates/solvers/src/infra/dex/simulator.rs
@@ -0,0 +1,120 @@
+use {
+    crate::{
+        domain::{dex, eth},
+        infra::blockchain,
+    },
+    alloy::{
+        primitives::{Address, U256},
+        providers::DynProvider,
+        rpc::types::state::{AccountOverride, StateOverridesBuilder},
+    },
+    contracts::alloy::support::{
+        AnyoneAuthenticator,
+        Swapper::{
+            self,
+            Swapper::{Allowance, Asset, Interaction},
+        },
+    },
+};
+
+/// A DEX swap simulator.
+#[derive(Debug, Clone)]
+pub struct Simulator {
+    web3: DynProvider,
+    settlement: Address,
+    authenticator: Address,
+}
+
+impl Simulator {
+    /// Create a new simulator for computing DEX swap gas usage.
+    pub fn new(url: &reqwest::Url, settlement: Address, authenticator: Address) -> Self {
+        Self {
+            web3: blockchain::rpc(url).provider,
+            settlement,
+            authenticator,
+        }
+    }
+
+    /// Simulate the gas needed by a single order DEX swap.
+    ///
+    /// This will return a `None` if the gas simulation is unavailable.
+    pub async fn gas(&self, owner: Address, swap: &dex::Swap) -> Result<eth::Gas, Error> {
+        if owner == self.settlement {
+            // we can't have both the settlement and swapper contracts at the
+            // same address
+            return Err(Error::SettlementContractIsOwner);
+        }
+
+        let swapper = Swapper::Instance::new(owner, self.web3.clone());
+        let overrides = StateOverridesBuilder::with_capacity(2)
+            // Setup up our trader code that actually executes the settlement
+            .append(
+                *swapper.address(),
+                AccountOverride {
+                    code: Some(Swapper::Swapper::DEPLOYED_BYTECODE.clone()),
+                    ..Default::default()
+                },
+            )
+            // Override the CoW protocol solver authenticator with one that
+            // allows any address to solve
+            .append(
+                self.authenticator,
+                AccountOverride {
+                    code: Some(
+                        AnyoneAuthenticator::AnyoneAuthenticator::DEPLOYED_BYTECODE.clone(),
+                    ),
+                    ..Default::default()
+                },
+            );
+
+        let swapper_calls_arg = swap
+            .calls
+            .iter()
+            .map(|call| Interaction {
+                target: call.to,
+                value: U256::ZERO,
+                callData: alloy::primitives::Bytes::copy_from_slice(&call.calldata),
+            })
+            .collect();
+        let sell = Asset {
+            token: swap.input.token.0,
+            amount: swap.input.amount,
+        };
+        let buy = Asset {
+            token: swap.output.token.0,
+            amount: swap.output.amount,
+        };
+        let allowance = Allowance {
+            spender: swap.allowance.spender,
+            amount: swap.allowance.amount.get(),
+        };
+        let gas = swapper
+            .swap(self.settlement, sell, buy, allowance, swapper_calls_arg)
+            .call()
+            .overrides(overrides)
+            .await?;
+
+        // `gas == 0` means that the simulation is not possible. See
+        // `Swapper.sol` contract for more details. In this case, use the
+        // heuristic gas amount from the swap.
+        Ok(if gas.is_zero() {
+            tracing::info!(
+                gas = ?swap.gas,
+                "could not simulate dex swap to get gas used; fall back to gas estimate provided \
+                 by dex API"
+            );
+            swap.gas
+        } else {
+            eth::Gas(gas)
+        })
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("contract call error: {0:?}")]
+    ContractCall(#[from] alloy::contract::Error),
+
+    #[error("can't simulate gas for an order for which the settlement contract is the owner")]
+    SettlementContractIsOwner,
+}
diff --git a/crates/solvers/src/infra/metrics.rs b/crates/solvers/src/infra/metrics.rs
index 509c8893a0..fc7027509f 100644
--- a/crates/solvers/src/infra/metrics.rs
+++ b/crates/solvers/src/infra/metrics.rs
@@ -12,6 +12,9 @@ struct Metrics {
     #[metric(buckets(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))]
     remaining_time: prometheus::Histogram,
 
+    /// Total number of requests that got sent to the DEX API.
+    solve_requests: prometheus::IntCounter,
+
     /// Errors that occurred during solving.
     #[metric(labels("reason"))]
     solve_errors: prometheus::IntCounterVec,
@@ -42,6 +45,14 @@ pub fn solved(deadline: &auction::Deadline, solutions: &[solution::Solution]) {
     get().solutions.inc_by(solutions.len() as u64);
 }
 
+pub fn solve_error(reason: &str) {
+    get().solve_errors.with_label_values(&[reason]).inc();
+}
+
+pub fn request_sent() {
+    get().solve_requests.inc();
+}
+
 /// Get the metrics instance.
 fn get() -> &'static Metrics {
     Metrics::instance(observe::metrics::get_storage_registry())
diff --git a/crates/solvers/src/infra/mod.rs b/crates/solvers/src/infra/mod.rs
index 792a13c703..e3585bfc7e 100644
--- a/crates/solvers/src/infra/mod.rs
+++ b/crates/solvers/src/infra/mod.rs
@@ -1,4 +1,6 @@
+pub mod blockchain;
 pub mod cli;
 pub mod config;
 pub mod contracts;
+pub mod dex;
 pub mod metrics;
diff --git a/crates/solvers/src/run.rs b/crates/solvers/src/run.rs
index 272336f126..5377479659 100644
--- a/crates/solvers/src/run.rs
+++ b/crates/solvers/src/run.rs
@@ -3,7 +3,7 @@ use tokio::signal::unix::{self, SignalKind};
 use {
     crate::{
         domain::solver,
-        infra::{cli, config},
+        infra::{cli, config, dex},
     },
     clap::Parser,
     shared::arguments::tracing_config,
@@ -41,9 +41,18 @@ async fn run_with(args: cli::Args, bind: Option<oneshot::Sender<SocketAddr>>) {
     tracing::info!(%commit_hash, "running solver engine with {args:#?}");
 
     let solver = match args.command {
-        cli::Command::Baseline { config } => {
-            let config = config::load(&config).await;
-            solver::Solver::new(config).await
+        cli::Command::Baseline { config: path } => {
+            let config = config::baseline::load(&path).await;
+            solver::Solver::Baseline(solver::Baseline::new(config).await)
+        }
+        cli::Command::Okx { config: path } => {
+            let config = config::dex::okx::file::load(&path).await;
+            solver::Solver::Dex(Box::new(solver::Dex::new(
+                dex::Dex::Okx(Box::new(
+                    dex::okx::Okx::try_new(config.okx).expect("invalid OKX configuration"),
+                )),
+                config.base,
+            )))
         }
     };
 
diff --git a/crates/solvers/src/tests/mock/http.rs b/crates/solvers/src/tests/mock/http.rs
new file mode 100644
index 0000000000..238afe9158
--- /dev/null
+++ b/crates/solvers/src/tests/mock/http.rs
@@ -0,0 +1,278 @@
+use {
+    std::{
+        fmt::{self, Debug, Formatter},
+        net::SocketAddr,
+        sync::{
+            Arc,
+            Mutex,
+            atomic::{AtomicBool, Ordering},
+        },
+    },
+    testlib::assert_json_matches_excluding,
+    tokio::task::JoinHandle,
+};
+
+#[derive(Clone)]
+pub enum Path {
+    Any,
+    Exact(String),
+    Glob(glob::Pattern),
+}
+
+impl Path {
+    pub fn exact(s: impl ToString) -> Self {
+        Self::Exact(s.to_string())
+    }
+
+    #[allow(dead_code)]
+    pub fn glob(s: impl AsRef<str>) -> Self {
+        Self::Glob(glob::Pattern::new(s.as_ref()).unwrap())
+    }
+}
+
+impl PartialEq<Path> for String {
+    fn eq(&self, path: &Path) -> bool {
+        match path {
+            Path::Any => true,
+            Path::Exact(exact) => exact == self,
+            Path::Glob(glob) => glob.matches(self),
+        }
+    }
+}
+
+impl Debug for Path {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Path::Any => f.debug_tuple("Any").finish(),
+            Path::Exact(exact) => f
+                .debug_tuple("Exact")
+                .field(&format_args!("{exact}"))
+                .finish(),
+            Path::Glob(glob) => f
+                .debug_tuple("Glob")
+                .field(&format_args!("{}", glob.as_str()))
+                .finish(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum Expectation {
+    Get {
+        path: Path,
+        res: serde_json::Value,
+    },
+    #[allow(dead_code)]
+    Post {
+        path: Path,
+        req: RequestBody,
+        res: serde_json::Value,
+    },
+}
+
+#[derive(Clone, Debug)]
+pub enum RequestBody {
+    /// The received `[RequestBody]` has to match the provided value exactly.
+    #[allow(dead_code)]
+    Exact(serde_json::Value),
+    /// The received `[RequestBody]` has to match the provided value partially
+    /// excluding the specified paths which are represented as dot-separated
+    /// strings.
+    #[allow(dead_code)]
+    Partial(serde_json::Value, Vec<&'static str>),
+    /// Any `[RequestBody]` will be accepted.
+    #[allow(dead_code)]
+    Any,
+}
+
+/// Drop handle that will verify that the server task didn't panic throughout
+/// the test and that all the expectations have been met.
+pub struct ServerHandle {
+    /// The address that handles requests to this server.
+    pub address: SocketAddr,
+    /// Handle to shut down the server task on drop.
+    handle: JoinHandle<()>,
+    /// Expectations that are left over after the test.
+    expectations: Arc<Mutex<Vec<Expectation>>>,
+    /// Indicates if some assertion failed.
+    assert_failed: Arc<AtomicBool>,
+}
+
+impl Drop for ServerHandle {
+    fn drop(&mut self) {
+        // Don't cause mass hysteria!
+        if std::thread::panicking() {
+            return;
+        }
+
+        let server_panicked = self.assert_failed.load(std::sync::atomic::Ordering::SeqCst);
+        // Panics happening in the server task might not cause the test to fail
+        // and only show up if some assertion fails in the main task.
+        assert!(!server_panicked);
+
+        assert!(
+            !self.handle.is_finished(),
+            "mock http server terminated before test ended"
+        );
+        assert_eq!(
+            self.expectations.lock().unwrap().len(),
+            0,
+            "mock server did not receive enough requests"
+        );
+        self.handle.abort();
+    }
+}
+
+/// Set up a mock external HTTP API.
+pub async fn setup(mut expectations: Vec<Expectation>) -> ServerHandle {
+    // Reverse expectations so test can specify them in natural order while
+    // allowing us to simply `.pop()` the last element.
+    expectations.reverse();
+
+    let expectations = Arc::new(Mutex::new(expectations));
+    let failed_assert = Arc::new(AtomicBool::new(false));
+
+    let app = axum::Router::new()
+        .route(
+            "/{*path}",
+            axum::routing::get(
+                |axum::extract::State(state),
+                 axum::extract::Path(path): axum::extract::Path<String>,
+                 axum::extract::RawQuery(query)| async move {
+                    axum::response::Json(get(state, Some(path), query))
+                },
+            )
+            .post(
+                |axum::extract::State(state),
+                 axum::extract::Path(path): axum::extract::Path<String>,
+                 axum::extract::RawQuery(query),
+                 axum::extract::Json(req)| async move {
+                    axum::response::Json(post(state, Some(path), query, req))
+                },
+            ),
+        )
+        // Annoying, but `axum` doesn't seem to match `/` with the above route,
+        // so explicitly mount `/`.
+        .route(
+            "/",
+            axum::routing::get(
+                |axum::extract::State(state), axum::extract::RawQuery(query)| async move {
+                    axum::response::Json(get(state, None, query))
+                },
+            )
+            .post(
+                |axum::extract::State(state),
+                 axum::extract::RawQuery(query),
+                 axum::extract::Json(req)| async move {
+                    axum::response::Json(post(state, None, query, req))
+                },
+            ),
+        )
+        .with_state(State {
+            expectations: expectations.clone(),
+            failed_assert: failed_assert.clone(),
+        });
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
+    let address = listener.local_addr().unwrap();
+    let handle = tokio::spawn(async move {
+        axum::serve(listener, app).await.unwrap();
+    });
+
+    ServerHandle {
+        handle,
+        expectations,
+        address,
+        assert_failed: failed_assert,
+    }
+}
+
+#[derive(Clone)]
+struct State {
+    /// Endpoint handler reads from here which request to expect and what to
+    /// respond.
+    expectations: Arc<Mutex<Vec<Expectation>>>,
+    /// Request handler notifies test about failed assert via this mutex.
+    failed_assert: Arc<AtomicBool>,
+}
+
+/// Runs the given closure and updates a flag if it panics.
+fn assert_and_propagate_panics<F, R>(assertions: F, flag: &AtomicBool) -> R
+where
+    F: FnOnce() -> R + std::panic::UnwindSafe + 'static,
+{
+    std::panic::catch_unwind(assertions)
+        .map_err(|_| {
+            flag.store(true, Ordering::SeqCst);
+        })
+        .expect("ignore this panic; it was caused by the previous panic")
+}
+
+fn get(state: State, path: Option<String>, query: Option<String>) -> serde_json::Value {
+    let expectation = state.expectations.lock().unwrap().pop();
+    let assertions = || {
+        let (expected_path, res) = match expectation {
+            Some(Expectation::Get { path, res }) => (path, res),
+            Some(other) => panic!("expected GET request but got {other:?}"),
+            None => panic!("got another GET request, but didn't expect any more"),
+        };
+
+        let full_path = full_path(path, query);
+        assert_eq!(full_path, expected_path, "GET request has unexpected path");
+        res
+    };
+    assert_and_propagate_panics(assertions, &state.failed_assert)
+}
+
+fn post(
+    state: State,
+    path: Option<String>,
+    query: Option<String>,
+    req: serde_json::Value,
+) -> serde_json::Value {
+    let expectation = state.expectations.lock().unwrap().pop();
+
+    let assertions = move || {
+        let (expected_path, expected_req, mut res) = match expectation {
+            Some(Expectation::Post { path, req, res }) => (path, req, res),
+            Some(other) => panic!("expected POST request but got {other:?}"),
+            None => panic!("got another POST request, but didn't expect any more"),
+        };
+
+        let full_path = full_path(path, query);
+        assert_eq!(full_path, expected_path, "POST request has unexpected path");
+        match expected_req {
+            RequestBody::Exact(value) => {
+                assert_eq!(req, value, "POST request has unexpected body")
+            }
+            RequestBody::Partial(value, exclude_paths) => {
+                let exclude_paths = exclude_paths
+                    .iter()
+                    .map(AsRef::as_ref)
+                    .collect::<Vec<&str>>();
+                assert_json_matches_excluding!(req, value, &exclude_paths)
+            }
+            RequestBody::Any => (),
+        }
+
+        // If this is a JSON-RPC request, echo the request ID back in the
+        // response
+        if let Some(req_id) = req.get("id")
+            && let Some(res_obj) = res.as_object_mut()
+        {
+            res_obj.insert("id".to_string(), req_id.clone());
+        }
+
+        res
+    };
+
+    assert_and_propagate_panics(assertions, &state.failed_assert)
+}
+
+fn full_path(path: Option<String>, query: Option<String>) -> String {
+    let path = path.unwrap_or_default();
+    match query {
+        Some(query) => format!("{path}?{query}"),
+        None => path,
+    }
+}
diff --git a/crates/solvers/src/tests/mock/mod.rs b/crates/solvers/src/tests/mock/mod.rs
new file mode 100644
index 0000000000..3883215fcb
--- /dev/null
+++ b/crates/solvers/src/tests/mock/mod.rs
@@ -0,0 +1 @@
+pub mod http;
diff --git a/crates/solvers/src/tests/mod.rs b/crates/solvers/src/tests/mod.rs
index fcf64af0e0..76fe4ec9ba 100644
--- a/crates/solvers/src/tests/mod.rs
+++ b/crates/solvers/src/tests/mod.rs
@@ -11,6 +11,8 @@ use {
 };
 
 mod cases;
+mod mock;
+mod okx;
 
 /// A solver engine handle for E2E testing.
 pub struct SolverEngine {
diff --git a/crates/solvers/src/tests/okx/api_calls.rs b/crates/solvers/src/tests/okx/api_calls.rs
new file mode 100644
index 0000000000..b522f36fd4
--- /dev/null
+++ b/crates/solvers/src/tests/okx/api_calls.rs
@@ -0,0 +1,262 @@
+use {
+    crate::{
+        domain::{dex::*, eth::*},
+        infra::dex::okx as okx_dex,
+    },
+    alloy::primitives::address,
+    std::env,
+};
+
+const DEFAULT_BUY_ORDERS_ENDPOINT: &str = "https://web3.okx.com/api/v5/dex/aggregator/";
+
+#[ignore]
+#[tokio::test]
+// To run this test, set the following environment variables accordingly to your
+// OKX setup: OKX_PROJECT_ID, OKX_API_KEY, OKX_SECRET_KEY, OKX_PASSPHRASE
+async fn swap_sell_regular() {
+    let okx_config = okx_dex::Config {
+        sell_orders_endpoint: reqwest::Url::parse(okx_dex::DEFAULT_SELL_ORDERS_ENDPOINT).unwrap(),
+        buy_orders_endpoint: None,
+        sell_orders_signature_base_url: None,
+        buy_orders_signature_base_url: None,
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        okx_credentials: okx_dex::OkxCredentialsConfig {
+            project_id: env::var("OKX_PROJECT_ID").unwrap(),
+            api_key: env::var("OKX_API_KEY").unwrap(),
+            api_secret_key: env::var("OKX_SECRET_KEY").unwrap(),
+            api_passphrase: env::var("OKX_PASSPHRASE").unwrap(),
+        },
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+        price_impact_protection_percent: 1.0,
+    };
+
+    let order = Order {
+        sell: TokenAddress::from(address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Sell,
+        amount: Amount::new(U256::from(100000000000000000_u128)),
+        owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let okx = crate::infra::dex::okx::Okx::try_new(okx_config).unwrap();
+    let swap_response = okx.swap(&order, &slippage).await;
+    let swap = swap_response.unwrap();
+
+    assert_eq!(swap.input.token, order.amount().token);
+    assert_eq!(swap.input.amount, order.amount().amount);
+    assert_eq!(swap.output.token, order.buy);
+    assert_eq!(
+        swap.allowance.spender,
+        address!("0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f")
+    );
+}
+
+#[tokio::test]
+async fn swap_buy_disabled() {
+    let okx_config = okx_dex::Config {
+        sell_orders_endpoint: reqwest::Url::parse(okx_dex::DEFAULT_SELL_ORDERS_ENDPOINT).unwrap(),
+        buy_orders_endpoint: None,
+        sell_orders_signature_base_url: None,
+        buy_orders_signature_base_url: None,
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        okx_credentials: okx_dex::OkxCredentialsConfig {
+            project_id: String::new(),
+            api_key: String::new(),
+            api_secret_key: String::new(),
+            api_passphrase: String::new(),
+        },
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+        price_impact_protection_percent: 1.0,
+    };
+
+    let order = Order {
+        buy: TokenAddress::from(address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+        sell: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Buy,
+        amount: Amount::new(U256::from(1000000000_u128)),
+        owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let okx = crate::infra::dex::okx::Okx::try_new(okx_config).unwrap();
+    let swap_response = okx.swap(&order, &slippage).await;
+    assert!(matches!(
+        swap_response.unwrap_err(),
+        crate::infra::dex::okx::Error::OrderNotSupported
+    ));
+}
+
+#[ignore]
+#[tokio::test]
+// To run this test, set the following environment variables accordingly to your
+// OKX setup: OKX_PROJECT_ID, OKX_API_KEY, OKX_SECRET_KEY, OKX_PASSPHRASE
+async fn swap_buy_enabled() {
+    let okx_config = okx_dex::Config {
+        sell_orders_endpoint: reqwest::Url::parse(okx_dex::DEFAULT_SELL_ORDERS_ENDPOINT).unwrap(),
+        buy_orders_endpoint: Some(reqwest::Url::parse(DEFAULT_BUY_ORDERS_ENDPOINT).unwrap()),
+        sell_orders_signature_base_url: None,
+        buy_orders_signature_base_url: None,
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        okx_credentials: okx_dex::OkxCredentialsConfig {
+            project_id: env::var("OKX_PROJECT_ID").unwrap(),
+            api_key: env::var("OKX_API_KEY").unwrap(),
+            api_secret_key: env::var("OKX_SECRET_KEY").unwrap(),
+            api_passphrase: env::var("OKX_PASSPHRASE").unwrap(),
+        },
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+        price_impact_protection_percent: 1.0,
+    };
+
+    let order = Order {
+        sell: TokenAddress::from(address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Buy,
+        amount: Amount::new(U256::from(1000000000_u128)),
+        owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let okx = crate::infra::dex::okx::Okx::try_new(okx_config).unwrap();
+    let swap_response = okx.swap(&order, &slippage).await;
+    let swap = swap_response.unwrap();
+
+    assert_eq!(swap.output.token, order.amount().token);
+    assert_eq!(swap.output.amount, order.amount().amount);
+    assert_eq!(swap.input.token, order.sell);
+    assert_eq!(
+        swap.allowance.spender,
+        address!("0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f")
+    );
+    // For buy orders, allowance should be U256::MAX
+    assert_eq!(swap.allowance.amount.get(), U256::MAX);
+}
+
+#[ignore]
+#[tokio::test]
+// To run this test, set the following environment variables accordingly to your
+// OKX setup: OKX_PROJECT_ID, OKX_API_KEY, OKX_SECRET_KEY, OKX_PASSPHRASE
+async fn swap_api_error() {
+    let okx_config = okx_dex::Config {
+        sell_orders_endpoint: reqwest::Url::parse(okx_dex::DEFAULT_SELL_ORDERS_ENDPOINT).unwrap(),
+        buy_orders_endpoint: None,
+        sell_orders_signature_base_url: None,
+        buy_orders_signature_base_url: None,
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        okx_credentials: okx_dex::OkxCredentialsConfig {
+            project_id: env::var("OKX_PROJECT_ID").unwrap(),
+            api_key: env::var("OKX_API_KEY").unwrap(),
+            api_secret_key: env::var("OKX_SECRET_KEY").unwrap(),
+            api_passphrase: env::var("OKX_PASSPHRASE").unwrap(),
+        },
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+        price_impact_protection_percent: 1.0,
+    };
+
+    let order = Order {
+        sell: TokenAddress::from(address!("0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")),
+        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Sell,
+        amount: Amount::new(U256::ZERO),
+        owner: address!("6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let okx = crate::infra::dex::okx::Okx::try_new(okx_config).unwrap();
+    let swap_response = okx.swap(&order, &slippage).await;
+
+    assert!(matches!(
+        swap_response.unwrap_err(),
+        crate::infra::dex::okx::Error::Api { .. }
+    ));
+}
+
+#[ignore]
+#[tokio::test]
+// To run this test, set the following environment variables accordingly to your
+// OKX setup: OKX_PROJECT_ID, OKX_API_KEY, OKX_SECRET_KEY, OKX_PASSPHRASE
+async fn swap_sell_insufficient_liquidity() {
+    let okx_config = okx_dex::Config {
+        sell_orders_endpoint: reqwest::Url::parse(okx_dex::DEFAULT_SELL_ORDERS_ENDPOINT).unwrap(),
+        buy_orders_endpoint: None,
+        sell_orders_signature_base_url: None,
+        buy_orders_signature_base_url: None,
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        okx_credentials: okx_dex::OkxCredentialsConfig {
+            project_id: env::var("OKX_PROJECT_ID").unwrap(),
+            api_key: env::var("OKX_API_KEY").unwrap(),
+            api_secret_key: env::var("OKX_SECRET_KEY").unwrap(),
+            api_passphrase: env::var("OKX_PASSPHRASE").unwrap(),
+        },
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+        price_impact_protection_percent: 1.0,
+    };
+
+    let order = Order {
+        sell: TokenAddress::from(address!("0xC8CD2BE653759aed7B0996315821AAe71e1FEAdF")),
+        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Sell,
+        amount: Amount::new(U256::from(10000000000000_u128)),
+        owner: address!("6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let okx = crate::infra::dex::okx::Okx::try_new(okx_config).unwrap();
+    let swap_response = okx.swap(&order, &slippage).await;
+
+    assert!(matches!(
+        swap_response.unwrap_err(),
+        crate::infra::dex::okx::Error::NotFound
+    ));
+}
+
+#[ignore]
+#[tokio::test]
+// To run this test, set the following environment variables accordingly to your
+// OKX setup: OKX_PROJECT_ID, OKX_API_KEY, OKX_SECRET_KEY, OKX_PASSPHRASE
+async fn swap_buy_insufficient_liquidity() {
+    let okx_config = okx_dex::Config {
+        sell_orders_endpoint: reqwest::Url::parse(okx_dex::DEFAULT_SELL_ORDERS_ENDPOINT).unwrap(),
+        buy_orders_endpoint: Some(reqwest::Url::parse(DEFAULT_BUY_ORDERS_ENDPOINT).unwrap()),
+        sell_orders_signature_base_url: None,
+        buy_orders_signature_base_url: None,
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        okx_credentials: okx_dex::OkxCredentialsConfig {
+            project_id: env::var("OKX_PROJECT_ID").unwrap(),
+            api_key: env::var("OKX_API_KEY").unwrap(),
+            api_secret_key: env::var("OKX_SECRET_KEY").unwrap(),
+            api_passphrase: env::var("OKX_PASSPHRASE").unwrap(),
+        },
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+        price_impact_protection_percent: 1.0,
+    };
+
+    let order = Order {
+        sell: TokenAddress::from(address!("0xC8CD2BE653759aed7B0996315821AAe71e1FEAdF")),
+        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Buy,
+        amount: Amount::new(U256::from(10000000000000_u128)),
+        owner: address!("6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let okx = crate::infra::dex::okx::Okx::try_new(okx_config).unwrap();
+    let swap_response = okx.swap(&order, &slippage).await;
+
+    assert!(matches!(
+        swap_response.unwrap_err(),
+        crate::infra::dex::okx::Error::NotFound
+    ));
+}
diff --git a/crates/solvers/src/tests/okx/market_order.rs b/crates/solvers/src/tests/okx/market_order.rs
new file mode 100644
index 0000000000..50ab660f1b
--- /dev/null
+++ b/crates/solvers/src/tests/okx/market_order.rs
@@ -0,0 +1,1067 @@
+//! This test ensures that the OKX solver properly handles market sell
+//! orders, turning OKX swap responses into CoW Protocol solutions.
+
+use {
+    crate::tests::{self, mock},
+    serde_json::json,
+};
+
+#[tokio::test]
+async fn sell() {
+    let api = mock::http::setup(vec![
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "swap?chainIndex=1\
+                &amount=1000000000000000000\
+                &fromTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+                &toTokenAddress=0xe41d2489571d322189246dafa5ebde1f4699f498\
+                &slippagePercent=0.01\
+                &userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapMode=exactIn\
+                &priceImpactProtectionPercent=1"
+            ),
+            res: json!(
+              {
+                "code":"0",
+                "data":[
+                   {
+                      "routerResult":{
+                         "chainId":"1",
+                         "dexRouterList":[
+                            {
+                               "router":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2--0xe41d2489571d322189246dafa5ebde1f4699f498",
+                               "routerPercent":"100",
+                               "subRouterList":[
+                                  {
+                                     "dexProtocol":[
+                                        {
+                                           "dexName":"Uniswap V3",
+                                           "percent":"100"
+                                        }
+                                     ],
+                                     "fromToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                        "tokenSymbol":"WETH",
+                                        "tokenUnitPrice":"3315.553196726842565048"
+                                     },
+                                     "toToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                                        "tokenSymbol":"ZRX",
+                                        "tokenUnitPrice":"0.504455838152300152"
+                                     }
+                                  }
+                               ]
+                            }
+                         ],
+                         "estimateGasFee":"135000",
+                         "fromToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                            "tokenSymbol":"WETH",
+                            "tokenUnitPrice":"3315.553196726842565048"
+                         },
+                         "fromTokenAmount":"1000000000000000000",
+                         "priceImpactPercentage":"-0.25",
+                         "quoteCompareList":[
+                            {
+                               "amountOut":"6556.259156432631386442",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V3",
+                               "tradeFee":"2.3554356342513966"
+                            },
+                            {
+                               "amountOut":"6375.198002761542738881",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V2",
+                               "tradeFee":"3.34995290204643072"
+                            },
+                            {
+                               "amountOut":"4456.799978982369793812",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V1",
+                               "tradeFee":"4.64638467513839940864"
+                            },
+                            {
+                               "amountOut":"2771.072269036022134969",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/SUSHI.png",
+                               "dexName":"SushiSwap",
+                               "tradeFee":"3.34995290204643072"
+                            }
+                         ],
+                         "toToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                            "tokenSymbol":"ZRX",
+                            "tokenUnitPrice":"0.504455838152300152"
+                         },
+                         "toTokenAmount":"6556259156432631386442",
+                         "tradeFee":"2.3554356342513966"
+                      },
+                      "tx":{
+                         "data":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                         "from":"0x9008d19f58aabd9ed0d60971565aa8510560ab41",
+                         "gas":"202500",
+                         "gasPrice":"6756286873",
+                         "maxPriorityFeePerGas":"1000000000",
+                         "minReceiveAmount":"6490696564868305072578",
+                         "signatureData":[
+                            ""
+                         ],
+                         "slippage":"0.01",
+                         "to":"0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                         "value":"0"
+                      }
+                   }
+                ],
+                "msg":""
+             }),
+        },
+        mock::http::Expectation::Get {
+         path: mock::http::Path::exact(
+             "approve-transaction?chainIndex=1\
+             &tokenContractAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+             &approveAmount=1000000000000000000"
+         ),
+         res: json!(
+           {
+             "code":"0",
+             "data":[{"data":"0x095ea7b300000000000000000000000040aa958dd87fc8305b97f2ba922cddca374bcd7f000000000000000000000000000000000000000000000000000009184e72a000","dexContractAddress":"0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f","gasLimit":"70000","gasPrice":"7424402761"}],
+             "msg":""
+           }
+         )
+      },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(
+        solution,
+        json!({
+           "solutions":[
+              {
+                 "gas":410141,
+                 "id":0,
+                 "interactions":[
+                    {
+                       "allowances":[
+                          {
+                             "amount":"1000000000000000000",
+                             "spender":"0x40aa958dd87fc8305b97f2ba922cddca374bcd7f",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "callData":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                       "inputs":[
+                          {
+                             "amount":"1000000000000000000",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "internalize":false,
+                       "kind":"custom",
+                       "outputs":[
+                          {
+                             "amount":"6556259156432631386442",
+                             "token":"0xe41d2489571d322189246dafa5ebde1f4699f498"
+                          }
+                       ],
+                       "target":"0x7d0ccaa3fac1e5a943c5168b6ced828691b46b36",
+                       "value":"0"
+                    }
+                 ],
+                 "postInteractions":[],
+                 "preInteractions":[],
+                 "prices":{
+                    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2":"6556259156432631386442",
+                    "0xe41d2489571d322189246dafa5ebde1f4699f498":"1000000000000000000"
+                 },
+                 "trades":[
+                    {
+                       "executedAmount":"1000000000000000000",
+                       "kind":"fulfillment",
+                       "order":"0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"
+                    }
+                 ]
+              }
+           ]
+        }),
+    );
+}
+
+#[tokio::test]
+async fn buy_disabled() {
+    let api = mock::http::setup(vec![]).await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "buy",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    // Buy order is not supported when enable-buy-orders is false (default).
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
+
+#[tokio::test]
+async fn buy_enabled() {
+    /// Config with buy orders enabled.
+    fn config_with_buy_orders(solver_addr: &std::net::SocketAddr) -> tests::Config {
+        tests::Config::String(format!(
+            r"
+node-url = 'http://localhost:8545'
+[dex]
+chain-id = '1'
+sell-orders-endpoint = 'http://{solver_addr}/'
+buy-orders-endpoint = 'http://{solver_addr}/'
+api-project-id = '1'
+api-key = '1234'
+api-secret-key = '1234567890123456'
+api-passphrase = 'pass'
+",
+        ))
+    }
+
+    let api = mock::http::setup(vec![
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "swap?chainId=1\
+                &amount=200000000000000000000\
+                &fromTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+                &toTokenAddress=0xe41d2489571d322189246dafa5ebde1f4699f498\
+                &slippage=0.01\
+                &userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapMode=exactOut\
+                &priceImpactProtectionPercent=1"
+            ),
+            res: json!(
+              {
+                "code":"0",
+                "data":[
+                   {
+                      "routerResult":{
+                         "chainId":"1",
+                         "dexRouterList":[
+                            {
+                               "router":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2--0xe41d2489571d322189246dafa5ebde1f4699f498",
+                               "routerPercent":"100",
+                               "subRouterList":[
+                                  {
+                                     "dexProtocol":[
+                                        {
+                                           "dexName":"Uniswap V3",
+                                           "percent":"100"
+                                        }
+                                     ],
+                                     "fromToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                        "tokenSymbol":"WETH",
+                                        "tokenUnitPrice":"3315.553196726842565048"
+                                     },
+                                     "toToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                                        "tokenSymbol":"ZRX",
+                                        "tokenUnitPrice":"0.504455838152300152"
+                                     }
+                                  }
+                               ]
+                            }
+                         ],
+                         "estimateGasFee":"135000",
+                         "fromToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                            "tokenSymbol":"WETH",
+                            "tokenUnitPrice":"3315.553196726842565048"
+                         },
+                         "fromTokenAmount":"30500000000000000",
+                         "priceImpactPercentage":"-0.25",
+                         "quoteCompareList":[
+                            {
+                               "amountOut":"200000000000000000000",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V3",
+                               "tradeFee":"2.3554356342513966"
+                            }
+                         ],
+                         "toToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                            "tokenSymbol":"ZRX",
+                            "tokenUnitPrice":"0.504455838152300152"
+                         },
+                         "toTokenAmount":"200000000000000000000",
+                         "tradeFee":"2.3554356342513966"
+                      },
+                      "tx":{
+                         "data":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                         "from":"0x9008d19f58aabd9ed0d60971565aa8510560ab41",
+                         "gas":"202500",
+                         "gasPrice":"6756286873",
+                         "maxPriorityFeePerGas":"1000000000",
+                         "minReceiveAmount":"6490696564868305072578",
+                         "signatureData":[
+                            ""
+                         ],
+                         "slippage":"0.01",
+                         "to":"0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                         "value":"0"
+                      }
+                   }
+                ],
+                "msg":""
+             }),
+        },
+        mock::http::Expectation::Get {
+         path: mock::http::Path::exact(
+             "approve-transaction?chainId=1\
+             &tokenContractAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+             &approveAmount=30500000000000000"
+         ),
+         res: json!(
+           {
+             "code":"0",
+             "data":[{"data":"0x095ea7b300000000000000000000000040aa958dd87fc8305b97f2ba922cddca374bcd7f000000000000000000000000000000000000000000000000000009184e72a000","dexContractAddress":"0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f","gasLimit":"70000","gasPrice":"7424402761"}],
+             "msg":""
+           }
+         )
+      },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("okx", config_with_buy_orders(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "buy",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(
+        solution,
+        json!({
+           "solutions":[
+              {
+                 "gas":410141,
+                 "id":0,
+                 "interactions":[
+                    {
+                       "allowances":[
+                          {
+                             "amount":"115792089237316195423570985008687907853269984665640564039457584007913129639935",
+                             "spender":"0x40aa958dd87fc8305b97f2ba922cddca374bcd7f",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "callData":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                       "inputs":[
+                          {
+                             "amount":"30500000000000000",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "internalize":true,
+                       "kind":"custom",
+                       "outputs":[
+                          {
+                             "amount":"200000000000000000000",
+                             "token":"0xe41d2489571d322189246dafa5ebde1f4699f498"
+                          }
+                       ],
+                       "target":"0x7d0ccaa3fac1e5a943c5168b6ced828691b46b36",
+                       "value":"0"
+                    }
+                 ],
+                 "postInteractions":[],
+                 "preInteractions":[],
+                 "prices":{
+                    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2":"200000000000000000000",
+                    "0xe41d2489571d322189246dafa5ebde1f4699f498":"30500000000000000"
+                 },
+                 "trades":[
+                    {
+                       "executedAmount":"200000000000000000000",
+                       "kind":"fulfillment",
+                       "order":"0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"
+                    }
+                 ]
+              }
+           ]
+        }),
+    );
+}
+
+#[tokio::test]
+async fn sell_twice() {
+    let mut http_requests = vec![
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "swap?chainIndex=1&amount=1000000000000000000&\
+                 fromTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&\
+                 toTokenAddress=0xe41d2489571d322189246dafa5ebde1f4699f498&slippagePercent=0.01&\
+                 userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41&\
+                 swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41&swapMode=exactIn&\
+                 priceImpactProtectionPercent=1",
+            ),
+            res: json!(
+             {
+               "code":"0",
+               "data":[
+                  {
+                     "routerResult":{
+                        "chainId":"1",
+                        "dexRouterList":[
+                           {
+                              "router":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2--0xe41d2489571d322189246dafa5ebde1f4699f498",
+                              "routerPercent":"100",
+                              "subRouterList":[
+                                 {
+                                    "dexProtocol":[
+                                       {
+                                          "dexName":"Uniswap V3",
+                                          "percent":"100"
+                                       }
+                                    ],
+                                    "fromToken":{
+                                       "decimal":"18",
+                                       "isHoneyPot":false,
+                                       "taxRate":"0",
+                                       "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                       "tokenSymbol":"WETH",
+                                       "tokenUnitPrice":"3315.553196726842565048"
+                                    },
+                                    "toToken":{
+                                       "decimal":"18",
+                                       "isHoneyPot":false,
+                                       "taxRate":"0",
+                                       "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                                       "tokenSymbol":"ZRX",
+                                       "tokenUnitPrice":"0.504455838152300152"
+                                    }
+                                 }
+                              ]
+                           }
+                        ],
+                        "estimateGasFee":"135000",
+                        "fromToken":{
+                           "decimal":"18",
+                           "isHoneyPot":false,
+                           "taxRate":"0",
+                           "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                           "tokenSymbol":"WETH",
+                           "tokenUnitPrice":"3315.553196726842565048"
+                        },
+                        "fromTokenAmount":"1000000000000000000",
+                        "priceImpactPercentage":"-0.25",
+                        "quoteCompareList":[
+                           {
+                              "amountOut":"6556.259156432631386442",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                              "dexName":"Uniswap V3",
+                              "tradeFee":"2.3554356342513966"
+                           },
+                           {
+                              "amountOut":"6375.198002761542738881",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                              "dexName":"Uniswap V2",
+                              "tradeFee":"3.34995290204643072"
+                           },
+                           {
+                              "amountOut":"4456.799978982369793812",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                              "dexName":"Uniswap V1",
+                              "tradeFee":"4.64638467513839940864"
+                           },
+                           {
+                              "amountOut":"2771.072269036022134969",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/SUSHI.png",
+                              "dexName":"SushiSwap",
+                              "tradeFee":"3.34995290204643072"
+                           }
+                        ],
+                        "toToken":{
+                           "decimal":"18",
+                           "isHoneyPot":false,
+                           "taxRate":"0",
+                           "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                           "tokenSymbol":"ZRX",
+                           "tokenUnitPrice":"0.504455838152300152"
+                        },
+                        "toTokenAmount":"6556259156432631386442",
+                        "tradeFee":"2.3554356342513966"
+                     },
+                     "tx":{
+                        "data":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                        "from":"0x9008d19f58aabd9ed0d60971565aa8510560ab41",
+                        "gas":"202500",
+                        "gasPrice":"6756286873",
+                        "maxPriorityFeePerGas":"1000000000",
+                        "minReceiveAmount":"6490696564868305072578",
+                        "signatureData":[
+                           ""
+                        ],
+                        "slippage":"0.01",
+                        "to":"0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                        "value":"0"
+                     }
+                  }
+               ],
+               "msg":""
+            }),
+        },
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "approve-transaction?chainIndex=1&\
+                 tokenContractAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&\
+                 approveAmount=1000000000000000000",
+            ),
+            res: json!(
+              {
+                "code":"0",
+                "data":[{"data":"0x095ea7b300000000000000000000000040aa958dd87fc8305b97f2ba922cddca374bcd7f000000000000000000000000000000000000000000000000000009184e72a000","dexContractAddress":"0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f","gasLimit":"70000","gasPrice":"7424402761"}],
+                "msg":""
+              }
+            ),
+        },
+    ];
+
+    // Prepare response for the 2nd swap request, only /swap is expected,
+    // /approve-transaction should not be sent instead cache should be used.
+    http_requests.push(http_requests[0].clone());
+
+    let api = mock::http::setup(http_requests).await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let auction = json!({
+        "id": "1",
+        "tokens": {
+            "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                "decimals": 18,
+                "symbol": "ZRX",
+                "referencePrice": "4327903683155778",
+                "availableBalance": "1583034704488033979459",
+                "trusted": true,
+            },
+            "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                "decimals": 18,
+                "symbol": "WETH",
+                "referencePrice": "1000000000000000000",
+                "availableBalance": "482725140468789680",
+                "trusted": true,
+            },
+        },
+        "orders": [
+            {
+                "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                          2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                          2a2a2a2a",
+                "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                "sellAmount": "1000000000000000000",
+                "buyAmount": "200000000000000000000",
+                "fullSellAmount": "1000000000000000000",
+                "fullBuyAmount": "200000000000000000000",
+                "kind": "sell",
+                "partiallyFillable": false,
+                "class": "market",
+                "sellTokenSource": "erc20",
+                "buyTokenDestination": "erc20",
+                "preInteractions": [],
+                "postInteractions": [],
+                "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                "validTo": 0,
+                "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "signingScheme": "presign",
+                "signature": "0x",
+            }
+        ],
+        "liquidity": [],
+        "effectiveGasPrice": "15000000000",
+        "deadline": "2106-01-01T00:00:00.000Z",
+        "surplusCapturingJitOrderOwners": []
+    });
+
+    let solution = engine.solve(auction.clone()).await;
+
+    assert_eq!(
+        solution,
+        json!({
+           "solutions":[
+              {
+                 "gas":410141,
+                 "id":0,
+                 "interactions":[
+                    {
+                       "allowances":[
+                          {
+                             "amount":"1000000000000000000",
+                             "spender":"0x40aa958dd87fc8305b97f2ba922cddca374bcd7f",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "callData":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                       "inputs":[
+                          {
+                             "amount":"1000000000000000000",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "internalize":false,
+                       "kind":"custom",
+                       "outputs":[
+                          {
+                             "amount":"6556259156432631386442",
+                             "token":"0xe41d2489571d322189246dafa5ebde1f4699f498"
+                          }
+                       ],
+                       "target":"0x7d0ccaa3fac1e5a943c5168b6ced828691b46b36",
+                       "value":"0"
+                    }
+                 ],
+                 "postInteractions":[],
+                 "preInteractions":[],
+                 "prices":{
+                    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2":"6556259156432631386442",
+                    "0xe41d2489571d322189246dafa5ebde1f4699f498":"1000000000000000000"
+                 },
+                 "trades":[
+                    {
+                       "executedAmount":"1000000000000000000",
+                       "kind":"fulfillment",
+                       "order":"0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"
+                    }
+                 ]
+              }
+           ]
+        }),
+    );
+
+    // Make a second call to ensure cache is used (no http request is sent).
+    let solution = engine.solve(auction).await;
+
+    let solutions_array = solution.as_object().unwrap().get("solutions").unwrap();
+
+    assert_eq!(solutions_array.as_array().unwrap().len(), 1);
+}
+
+#[tokio::test]
+async fn sell_twice_parallel() {
+    let mut http_requests = vec![
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "swap?chainIndex=1&amount=1000000000000000000&\
+                 fromTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&\
+                 toTokenAddress=0xe41d2489571d322189246dafa5ebde1f4699f498&slippagePercent=0.01&\
+                 userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41&\
+                 swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41&swapMode=exactIn&\
+                 priceImpactProtectionPercent=1",
+            ),
+            res: json!(
+             {
+               "code":"0",
+               "data":[
+                  {
+                     "routerResult":{
+                        "chainId":"1",
+                        "dexRouterList":[
+                           {
+                              "router":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2--0xe41d2489571d322189246dafa5ebde1f4699f498",
+                              "routerPercent":"100",
+                              "subRouterList":[
+                                 {
+                                    "dexProtocol":[
+                                       {
+                                          "dexName":"Uniswap V3",
+                                          "percent":"100"
+                                       }
+                                    ],
+                                    "fromToken":{
+                                       "decimal":"18",
+                                       "isHoneyPot":false,
+                                       "taxRate":"0",
+                                       "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                       "tokenSymbol":"WETH",
+                                       "tokenUnitPrice":"3315.553196726842565048"
+                                    },
+                                    "toToken":{
+                                       "decimal":"18",
+                                       "isHoneyPot":false,
+                                       "taxRate":"0",
+                                       "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                                       "tokenSymbol":"ZRX",
+                                       "tokenUnitPrice":"0.504455838152300152"
+                                    }
+                                 }
+                              ]
+                           }
+                        ],
+                        "estimateGasFee":"135000",
+                        "fromToken":{
+                           "decimal":"18",
+                           "isHoneyPot":false,
+                           "taxRate":"0",
+                           "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                           "tokenSymbol":"WETH",
+                           "tokenUnitPrice":"3315.553196726842565048"
+                        },
+                        "fromTokenAmount":"1000000000000000000",
+                        "priceImpactPercentage":"-0.25",
+                        "quoteCompareList":[
+                           {
+                              "amountOut":"6556.259156432631386442",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                              "dexName":"Uniswap V3",
+                              "tradeFee":"2.3554356342513966"
+                           },
+                           {
+                              "amountOut":"6375.198002761542738881",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                              "dexName":"Uniswap V2",
+                              "tradeFee":"3.34995290204643072"
+                           },
+                           {
+                              "amountOut":"4456.799978982369793812",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                              "dexName":"Uniswap V1",
+                              "tradeFee":"4.64638467513839940864"
+                           },
+                           {
+                              "amountOut":"2771.072269036022134969",
+                              "dexLogo":"https://static.okx.com/cdn/wallet/logo/SUSHI.png",
+                              "dexName":"SushiSwap",
+                              "tradeFee":"3.34995290204643072"
+                           }
+                        ],
+                        "toToken":{
+                           "decimal":"18",
+                           "isHoneyPot":false,
+                           "taxRate":"0",
+                           "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                           "tokenSymbol":"ZRX",
+                           "tokenUnitPrice":"0.504455838152300152"
+                        },
+                        "toTokenAmount":"6556259156432631386442",
+                        "tradeFee":"2.3554356342513966"
+                     },
+                     "tx":{
+                        "data":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                        "from":"0x9008d19f58aabd9ed0d60971565aa8510560ab41",
+                        "gas":"202500",
+                        "gasPrice":"6756286873",
+                        "maxPriorityFeePerGas":"1000000000",
+                        "minReceiveAmount":"6490696564868305072578",
+                        "signatureData":[
+                           ""
+                        ],
+                        "slippage":"0.01",
+                        "to":"0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                        "value":"0"
+                     }
+                  }
+               ],
+               "msg":""
+            }),
+        },
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "approve-transaction?chainIndex=1&\
+                 tokenContractAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&\
+                 approveAmount=1000000000000000000",
+            ),
+            res: json!(
+              {
+                "code":"0",
+                "data":[{"data":"0x095ea7b300000000000000000000000040aa958dd87fc8305b97f2ba922cddca374bcd7f000000000000000000000000000000000000000000000000000009184e72a000","dexContractAddress":"0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f","gasLimit":"70000","gasPrice":"7424402761"}],
+                "msg":""
+              }
+            ),
+        },
+    ];
+
+    // Prepare response for the 2nd swap request, only /swap is expected,
+    // /approve-transaction should not be sent instead cache should be used.
+    http_requests.push(http_requests[0].clone());
+
+    let api = mock::http::setup(http_requests).await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let auction = json!({
+        "id": "1",
+        "tokens": {
+            "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                "decimals": 18,
+                "symbol": "ZRX",
+                "referencePrice": "4327903683155778",
+                "availableBalance": "1583034704488033979459",
+                "trusted": true,
+            },
+            "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                "decimals": 18,
+                "symbol": "WETH",
+                "referencePrice": "1000000000000000000",
+                "availableBalance": "482725140468789680",
+                "trusted": true,
+            },
+        },
+        "orders": [
+            {
+                "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                          2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                          2a2a2a2a",
+                "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                "sellAmount": "1000000000000000000",
+                "buyAmount": "200000000000000000000",
+                "fullSellAmount": "1000000000000000000",
+                "fullBuyAmount": "200000000000000000000",
+                "kind": "sell",
+                "partiallyFillable": false,
+                "class": "market",
+                "sellTokenSource": "erc20",
+                "buyTokenDestination": "erc20",
+                "preInteractions": [],
+                "postInteractions": [],
+                "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                "validTo": 0,
+                "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "signingScheme": "presign",
+                "signature": "0x",
+            }
+        ],
+        "liquidity": [],
+        "effectiveGasPrice": "15000000000",
+        "deadline": "2106-01-01T00:00:00.000Z",
+        "surplusCapturingJitOrderOwners": []
+    });
+
+    // Making two auction solve calls in parallel
+    // - 1st solve call will invoke okx /swap and /approve-transaction requests
+    // - 2nd solve call will also invoke okx /swap but should not invoke
+    //   /approve-transaction instead it should wait for the 1st execution to finish
+    //   (due to use of moka concurrent calls on the same key feature)
+    let (solution1, solution2) = tokio::join!(engine.solve(auction.clone()), engine.solve(auction));
+
+    assert_eq!(
+        solution1,
+        json!({
+           "solutions":[
+              {
+                 "gas":410141,
+                 "id":0,
+                 "interactions":[
+                    {
+                       "allowances":[
+                          {
+                             "amount":"1000000000000000000",
+                             "spender":"0x40aa958dd87fc8305b97f2ba922cddca374bcd7f",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "callData":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                       "inputs":[
+                          {
+                             "amount":"1000000000000000000",
+                             "token":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "internalize":false,
+                       "kind":"custom",
+                       "outputs":[
+                          {
+                             "amount":"6556259156432631386442",
+                             "token":"0xe41d2489571d322189246dafa5ebde1f4699f498"
+                          }
+                       ],
+                       "target":"0x7d0ccaa3fac1e5a943c5168b6ced828691b46b36",
+                       "value":"0"
+                    }
+                 ],
+                 "postInteractions":[],
+                 "preInteractions":[],
+                 "prices":{
+                    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2":"6556259156432631386442",
+                    "0xe41d2489571d322189246dafa5ebde1f4699f498":"1000000000000000000"
+                 },
+                 "trades":[
+                    {
+                       "executedAmount":"1000000000000000000",
+                       "kind":"fulfillment",
+                       "order":"0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"
+                    }
+                 ]
+              }
+           ]
+        }),
+    );
+
+    let solutions_array = solution2.as_object().unwrap().get("solutions").unwrap();
+
+    assert_eq!(solutions_array.as_array().unwrap().len(), 1);
+}
diff --git a/crates/solvers/src/tests/okx/mod.rs b/crates/solvers/src/tests/okx/mod.rs
new file mode 100644
index 0000000000..e132d7ee5c
--- /dev/null
+++ b/crates/solvers/src/tests/okx/mod.rs
@@ -0,0 +1,22 @@
+use {crate::tests, std::net::SocketAddr};
+
+mod api_calls;
+mod market_order;
+mod not_found;
+mod out_of_price;
+
+/// Creates a temporary file containing the config of the given solver.
+pub fn config(solver_addr: &SocketAddr) -> tests::Config {
+    tests::Config::String(format!(
+        r"
+node-url = 'http://localhost:8545'
+[dex]
+chain-id = '1'
+sell-orders-endpoint = 'http://{solver_addr}/'
+api-project-id = '1'
+api-key = '1234'
+api-secret-key = '1234567890123456'
+api-passphrase = 'pass'
+",
+    ))
+}
diff --git a/crates/solvers/src/tests/okx/not_found.rs b/crates/solvers/src/tests/okx/not_found.rs
new file mode 100644
index 0000000000..ffe11f6607
--- /dev/null
+++ b/crates/solvers/src/tests/okx/not_found.rs
@@ -0,0 +1,287 @@
+//! This test ensures that the OKX solver properly handles cases where no swap
+//! was found for the specified order.
+
+use {
+    crate::tests::{self, mock},
+    serde_json::json,
+};
+
+#[tokio::test]
+async fn sell() {
+    let api = mock::http::setup(vec![mock::http::Expectation::Get {
+        path: mock::http::Path::exact(
+            "swap?chainIndex=1&amount=1000000000000000000&\
+             fromTokenAddress=0xc8cd2be653759aed7b0996315821aae71e1feadf&\
+             toTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&slippagePercent=0.01&\
+             userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41&\
+             swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41&\
+             swapMode=exactIn&priceImpactProtectionPercent=1",
+        ),
+        res: json!({"code":"82000","data":[],"msg":"Insufficient liquidity."}),
+    },
+    mock::http::Expectation::Get {
+        path: mock::http::Path::exact(
+            "approve-transaction?chainIndex=1\
+            &tokenContractAddress=0xc8cd2be653759aed7b0996315821aae71e1feadf\
+            &approveAmount=1000000000000000000"
+        ),
+        res: json!(
+          {
+            "code":"0",
+            "data":[{"data":"0x095ea7b300000000000000000000000040aa958dd87fc8305b97f2ba922cddca374bcd7f000000000000000000000000000000000000000000000000000009184e72a000","dexContractAddress":"0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f","gasLimit":"70000","gasPrice":"7424402761"}],
+            "msg":""
+          }
+        )
+     }
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xC8CD2BE653759aed7B0996315821AAe71e1FEAdF": {
+                    "decimals": 18,
+                    "symbol": "TETH",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC8CD2BE653759aed7B0996315821AAe71e1FEAdF",
+                    "buyToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
+
+#[tokio::test]
+async fn sell_no_approve_transaction() {
+    let api = mock::http::setup(vec![
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "swap?chainIndex=1\
+                &amount=1000000000000000000\
+                &fromTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+                &toTokenAddress=0xe41d2489571d322189246dafa5ebde1f4699f498\
+                &slippagePercent=0.01\
+                &userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapMode=exactIn\
+                &priceImpactProtectionPercent=1"
+            ),
+            res: json!(
+              {
+                "code":"0",
+                "data":[
+                   {
+                      "routerResult":{
+                         "chainId":"1",
+                         "dexRouterList":[
+                            {
+                               "router":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2--0xe41d2489571d322189246dafa5ebde1f4699f498",
+                               "routerPercent":"100",
+                               "subRouterList":[
+                                  {
+                                     "dexProtocol":[
+                                        {
+                                           "dexName":"Uniswap V3",
+                                           "percent":"100"
+                                        }
+                                     ],
+                                     "fromToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                        "tokenSymbol":"WETH",
+                                        "tokenUnitPrice":"3315.553196726842565048"
+                                     },
+                                     "toToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                                        "tokenSymbol":"ZRX",
+                                        "tokenUnitPrice":"0.504455838152300152"
+                                     }
+                                  }
+                               ]
+                            }
+                         ],
+                         "estimateGasFee":"135000",
+                         "fromToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                            "tokenSymbol":"WETH",
+                            "tokenUnitPrice":"3315.553196726842565048"
+                         },
+                         "fromTokenAmount":"1000000000000000000",
+                         "priceImpactPercentage":"-0.25",
+                         "quoteCompareList":[
+                            {
+                               "amountOut":"6556.259156432631386442",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V3",
+                               "tradeFee":"2.3554356342513966"
+                            },
+                            {
+                               "amountOut":"6375.198002761542738881",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V2",
+                               "tradeFee":"3.34995290204643072"
+                            },
+                            {
+                               "amountOut":"4456.799978982369793812",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V1",
+                               "tradeFee":"4.64638467513839940864"
+                            },
+                            {
+                               "amountOut":"2771.072269036022134969",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/SUSHI.png",
+                               "dexName":"SushiSwap",
+                               "tradeFee":"3.34995290204643072"
+                            }
+                         ],
+                         "toToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                            "tokenSymbol":"ZRX",
+                            "tokenUnitPrice":"0.504455838152300152"
+                         },
+                         "toTokenAmount":"6556259156432631386442",
+                         "tradeFee":"2.3554356342513966"
+                      },
+                      "tx":{
+                         "data":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                         "from":"0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a",
+                         "gas":"202500",
+                         "gasPrice":"6756286873",
+                         "maxPriorityFeePerGas":"1000000000",
+                         "minReceiveAmount":"6490696564868305072578",
+                         "signatureData":[
+                            ""
+                         ],
+                         "slippage":"0.01",
+                         "to":"0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                         "value":"0"
+                      }
+                   }
+                ],
+                "msg":""
+             }),
+        },
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "approve-transaction?chainIndex=1\
+                &tokenContractAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+                &approveAmount=1000000000000000000"
+            ),
+            res: json!(
+              {
+                "code":"50011",
+                "data":[],
+                "msg":"Rate limit reached"
+              }
+            )
+         },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
diff --git a/crates/solvers/src/tests/okx/out_of_price.rs b/crates/solvers/src/tests/okx/out_of_price.rs
new file mode 100644
index 0000000000..9ec12a33c1
--- /dev/null
+++ b/crates/solvers/src/tests/okx/out_of_price.rs
@@ -0,0 +1,205 @@
+//! This test verifies that the OKX solver does not generate solutions when
+//! the swap returned from the API does not satisfy an order's limit price.
+//!
+//! The actual test case is a modified version of the [`super::market_order`]
+//! test with an exuberant buy amount.
+
+use {
+    crate::tests::{self, mock},
+    serde_json::json,
+};
+
+#[tokio::test]
+async fn sell() {
+    let api = mock::http::setup(vec![
+        mock::http::Expectation::Get {
+            path: mock::http::Path::exact(
+                "swap?chainIndex=1\
+                &amount=1000000000000000000\
+                &fromTokenAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+                &toTokenAddress=0xe41d2489571d322189246dafa5ebde1f4699f498\
+                &slippagePercent=0.01\
+                &userWalletAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapReceiverAddress=0x9008d19f58aabd9ed0d60971565aa8510560ab41\
+                &swapMode=exactIn\
+                &priceImpactProtectionPercent=1"
+            ),
+            res: json!(
+              {
+                "code":"0",
+                "data":[
+                   {
+                      "routerResult":{
+                         "chainId":"1",
+                         "dexRouterList":[
+                            {
+                               "router":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2--0xe41d2489571d322189246dafa5ebde1f4699f498",
+                               "routerPercent":"100",
+                               "subRouterList":[
+                                  {
+                                     "dexProtocol":[
+                                        {
+                                           "dexName":"Uniswap V3",
+                                           "percent":"100"
+                                        }
+                                     ],
+                                     "fromToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                                        "tokenSymbol":"WETH",
+                                        "tokenUnitPrice":"3315.553196726842565048"
+                                     },
+                                     "toToken":{
+                                        "decimal":"18",
+                                        "isHoneyPot":false,
+                                        "taxRate":"0",
+                                        "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                                        "tokenSymbol":"ZRX",
+                                        "tokenUnitPrice":"0.504455838152300152"
+                                     }
+                                  }
+                               ]
+                            }
+                         ],
+                         "estimateGasFee":"135000",
+                         "fromToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                            "tokenSymbol":"WETH",
+                            "tokenUnitPrice":"3315.553196726842565048"
+                         },
+                         "fromTokenAmount":"1000000000000000000",
+                         "priceImpactPercentage":"-0.25",
+                         "quoteCompareList":[
+                            {
+                               "amountOut":"6556.259156432631386442",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V3",
+                               "tradeFee":"2.3554356342513966"
+                            },
+                            {
+                               "amountOut":"6375.198002761542738881",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V2",
+                               "tradeFee":"3.34995290204643072"
+                            },
+                            {
+                               "amountOut":"4456.799978982369793812",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/UNI.png",
+                               "dexName":"Uniswap V1",
+                               "tradeFee":"4.64638467513839940864"
+                            },
+                            {
+                               "amountOut":"2771.072269036022134969",
+                               "dexLogo":"https://static.okx.com/cdn/wallet/logo/SUSHI.png",
+                               "dexName":"SushiSwap",
+                               "tradeFee":"3.34995290204643072"
+                            }
+                         ],
+                         "toToken":{
+                            "decimal":"18",
+                            "isHoneyPot":false,
+                            "taxRate":"0",
+                            "tokenContractAddress":"0xe41d2489571d322189246dafa5ebde1f4699f498",
+                            "tokenSymbol":"ZRX",
+                            "tokenUnitPrice":"0.504455838152300152"
+                         },
+                         "toTokenAmount":"6556259156432631386442",
+                         "tradeFee":"2.3554356342513966"
+                      },
+                      "tx":{
+                         "data":"0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                         "from":"0x9008d19f58aabd9ed0d60971565aa8510560ab41",
+                         "gas":"202500",
+                         "gasPrice":"6756286873",
+                         "maxPriorityFeePerGas":"1000000000",
+                         "minReceiveAmount":"6490696564868305072578",
+                         "signatureData":[
+                            ""
+                         ],
+                         "slippage":"0.01",
+                         "to":"0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                         "value":"0"
+                      }
+                   }
+                ],
+                "msg":""
+             }),
+        },
+        mock::http::Expectation::Get {
+         path: mock::http::Path::exact(
+             "approve-transaction?chainIndex=1\
+             &tokenContractAddress=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\
+             &approveAmount=1000000000000000000"
+         ),
+         res: json!(
+           {
+             "code":"0",
+             "data":[{"data":"0x095ea7b300000000000000000000000040aa958dd87fc8305b97f2ba922cddca374bcd7f000000000000000000000000000000000000000000000000000009184e72a000","dexContractAddress":"0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f","gasLimit":"70000","gasPrice":"7424402761"}],
+             "msg":""
+           }
+         )
+      },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("okx", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    // Way too much...
+                    "buyAmount": "1000000000000000000000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "1000000000000000000000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
diff --git a/crates/solvers/src/util/conv.rs b/crates/solvers/src/util/conv.rs
index 616e0420f9..7563762360 100644
--- a/crates/solvers/src/util/conv.rs
+++ b/crates/solvers/src/util/conv.rs
@@ -3,7 +3,7 @@
 use {
     crate::domain::eth,
     alloy::primitives::U256,
-    bigdecimal::BigDecimal,
+    bigdecimal::{BigDecimal, num_bigint::ToBigInt},
     num::{BigInt, BigUint, One, rational::Ratio},
 };
 
@@ -43,6 +43,22 @@ pub fn u256_to_biguint(i: &U256) -> BigUint {
     BigUint::from_bytes_be(i.to_be_bytes::<32>().as_slice())
 }
 
+pub fn u256_to_bigdecimal(i: &U256) -> BigDecimal {
+    BigDecimal::new(u256_to_biguint(i).into(), 0)
+}
+
+pub fn bigint_to_u256(i: &BigInt) -> Option<U256> {
+    if i.sign() == num::bigint::Sign::Minus {
+        return None;
+    }
+    biguint_to_u256(i.magnitude())
+}
+
+pub fn bigdecimal_to_u256(d: &BigDecimal) -> Option<U256> {
+    let d = d.to_bigint()?;
+    bigint_to_u256(&d)
+}
+
 /// Converts a `BigDecimal` amount in Ether units to wei.
 pub fn decimal_to_ether(d: &BigDecimal) -> Option<eth::Ether> {
     let scaled = d * BigDecimal::new(BigInt::one(), -18);
diff --git a/crates/solvers/src/util/http.rs b/crates/solvers/src/util/http.rs
new file mode 100644
index 0000000000..e214d7c738
--- /dev/null
+++ b/crates/solvers/src/util/http.rs
@@ -0,0 +1,152 @@
+//! Module containing utilities for round-tripping HTTP requests.
+//!
+//! Note that this helper is implemented as a macro. This is needed in order to
+//! ensure that we preserve the module path in the log event from the original
+//! callsite instead of all HTTP requests appearing as they are made from this
+//! module.
+
+use {
+    reqwest::{Method, RequestBuilder, StatusCode, Url},
+    serde::de::DeserializeOwned,
+    std::str,
+};
+
+/// Roundtrip an HTTP request. This will `TRACE` log the request and responses.
+///
+/// This is a thin macro wrapper around [`roundtrip_internal`] that ensures that
+/// logs are attributed from the callsite and not from this module. This allows
+/// log filtering to be done in a more fine-grained manner and based on where
+/// the HTTP roundtripping is happening.
+macro_rules! roundtrip {
+    (<$t:ty, $e:ty>; $request:expr) => {
+        $crate::util::http::roundtrip_internal::<$t, $e>(
+            $request,
+            |method, url, body, message| {
+                if let Some(body) = body {
+                    tracing::trace!(%method, %url, %body, "{message}");
+                } else {
+                    tracing::trace!(%method, %url, "{message}");
+                }
+            },
+            |status, body, message| {
+                tracing::trace!(%status, %body, "{message}");
+            },
+        )
+    };
+    ($request:expr) => {
+        $crate::util::http::roundtrip!(<_, _>; $request)
+    };
+}
+
+pub(crate) use roundtrip;
+
+#[doc(hidden)]
+pub async fn roundtrip_internal<T, E>(
+    mut request: RequestBuilder,
+    log_request: impl FnOnce(&Method, &Url, Option<&str>, &str),
+    log_response: impl FnOnce(StatusCode, &str, &str),
+) -> Result<T, RoundtripError<E>>
+where
+    T: DeserializeOwned,
+    E: DeserializeOwned,
+{
+    if let Some(id) = observe::request_id::from_current_span() {
+        request = request.header("X-REQUEST-ID", id);
+    }
+    let (client, request) = request.build_split();
+    let request = request.map_err(Error::from)?;
+
+    let body = request
+        .body()
+        .and_then(|body| str::from_utf8(body.as_bytes()?).ok());
+
+    log_request(
+        request.method(),
+        request.url(),
+        body,
+        "sending HTTP request",
+    );
+    let response = client.execute(request).await.map_err(Error::from)?;
+
+    let status = response.status();
+    let body = response.text().await.map_err(Error::from)?;
+    log_response(status, &body, "received HTTP response");
+
+    match serde_json::from_str::<T>(&body) {
+        Ok(data) => Ok(data),
+        // We failed to parse the body into the expected data, try to get an
+        // as accurate error as possible:
+        // 1. If the API returned a well-formed error that we can parse, then use that
+        // 2. Otherwise, if it returned a 2xx status code, then this means that we are unable to
+        //    parse a successful response, so return a JSON error
+        // 3. Otherwise, return an HTTP status error with the raw body string.
+        Err(err) => Err(serde_json::from_str(&body)
+            .map(RoundtripError::Api)
+            .unwrap_or_else(|_| {
+                RoundtripError::Http(if status.is_success() {
+                    Error::Json(err)
+                } else {
+                    Error::Status(status, body)
+                })
+            })),
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    /// An error occurred when parsing the JSON body from the HTTP response
+    /// into the expected result type.
+    #[error(transparent)]
+    Json(#[from] serde_json::Error),
+    /// A general HTTP error when sending a request or receiving a response.
+    ///
+    /// This is a protocol-level error, and can indicate a networking issue or
+    /// a misbehaving HTTP server.
+    #[error(transparent)]
+    Http(#[from] reqwest::Error),
+    /// An error indicating that the HTTP response contained a non-200 status
+    /// code indicating an application-level error.
+    #[error("HTTP {0}: {1}")]
+    Status(StatusCode, String),
+}
+
+impl From<RoundtripError<Never>> for Error {
+    fn from(value: RoundtripError<Never>) -> Self {
+        let RoundtripError::Http(err) = value else {
+            unreachable!();
+        };
+        err
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum RoundtripError<E> {
+    #[error(transparent)]
+    Http(#[from] Error),
+    #[error("API error")]
+    Api(E),
+}
+
+/// A type that never deserializes or serializes.
+///
+/// This can be used in situations where a generic type that implements `serde`
+/// traits is required, but you don't want it to actually represent any data.
+pub struct Never;
+
+impl<'de> serde::Deserialize<'de> for Never {
+    fn deserialize<D>(_: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Err(serde::de::Error::custom("neva eva eva"))
+    }
+}
+
+impl serde::Serialize for Never {
+    fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        Err(serde::ser::Error::custom("neva eva eva"))
+    }
+}
diff --git a/crates/solvers/src/util/mod.rs b/crates/solvers/src/util/mod.rs
index 6dc666de3d..b27613cb8e 100644
--- a/crates/solvers/src/util/mod.rs
+++ b/crates/solvers/src/util/mod.rs
@@ -1,3 +1,4 @@
 pub mod bytes;
 pub mod conv;
 pub mod fmt;
+pub mod http;

From 2fdd0836dec73aed80189ec05e2a1582caa42060 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 11 Mar 2026 10:20:35 +0100
Subject: [PATCH 135/219] Debug endpoint (#4233)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Add a debug endpoint for order investigation. Given an order UID, it
returns the full lifecycle: order data, events
(created/ready/executing/traded), auction participation, proposed
solutions, executions, trades, settlement attempts, and fee policies.
Protected by a configurable auth token header.

# Changes

* New `GET /api/v1/debug/order/{uid}` endpoint behind `x-auth-token`
header auth
* `DebugReport` DB layer aggregates data from various tables (see data
sources)
* New `auction_orders` junction table (V106) to efficiently look up all
auctions an order participated in, replacing indirect derivation through
proposed_solutions/executions
* `save_auction()` now populates the junction table alongside
`competition_auctions`
* Configurable auth tokens via `debug_route_auth_tokens` in orderbook
config
* E2E test covering the full happy path + auth failure cases


## Queried tables

* orders (via single_order)
* order_events (via get_all)
* proposed_trade_executions + proposed_solutions (via
find_solutions_for_order — that's a JOIN)
* order_execution (via read_by_order_uid)
* trades (via trades)
* auction_orders (via fetch_auction_ids_by_order_uid)
* competition_auctions (via fetch_multiple)
* settlement_executions (via read_by_auction_ids)
* fee_policies (via fetch_by_order_uid)

## How to test

`cargo nextest run -p e2e debug_order --test-threads 1 --run-ignored
ignored-only`

Test will be flaky until we get
https://github.com/cowprotocol/services/pull/4239 in.

# Follow up

Include a concrete reason why an order was filtered out of an auction if
it was filtered out.
---
 Cargo.lock                                    |   1 +
 crates/autopilot/src/infra/persistence/mod.rs |  14 +-
 crates/database/src/auction.rs                |  36 +++
 crates/database/src/byte_array.rs             |   8 +-
 crates/database/src/fee_policies.rs           |   9 +
 crates/database/src/lib.rs                    |   1 +
 crates/database/src/order_events.rs           |  12 +
 crates/database/src/order_execution.rs        |  27 ++
 crates/database/src/settlement_executions.rs  |  55 ++--
 crates/database/src/solver_competition_v2.rs  |  30 +++
 crates/e2e/Cargo.toml                         |   1 +
 crates/e2e/tests/e2e/debug_order.rs           | 154 +++++++++++
 crates/e2e/tests/e2e/main.rs                  |   1 +
 crates/model/src/debug_report.rs              | 146 +++++++++++
 crates/model/src/lib.rs                       |   1 +
 crates/orderbook/openapi.yml                  | 242 ++++++++++++++++++
 crates/orderbook/src/api.rs                   |   6 +
 crates/orderbook/src/api/debug_order.rs       |  28 ++
 crates/orderbook/src/database/debug_report.rs | 239 +++++++++++++++++
 crates/orderbook/src/database/mod.rs          |   1 +
 ...proposed_trade_executions_by_order_uid.sql |   2 +
 database/sql/V106__create_auction_orders.sql  |   8 +
 22 files changed, 996 insertions(+), 26 deletions(-)
 create mode 100644 crates/e2e/tests/e2e/debug_order.rs
 create mode 100644 crates/model/src/debug_report.rs
 create mode 100644 crates/orderbook/src/api/debug_order.rs
 create mode 100644 crates/orderbook/src/database/debug_report.rs
 create mode 100644 database/sql/V105__index_proposed_trade_executions_by_order_uid.sql
 create mode 100644 database/sql/V106__create_auction_orders.sql

diff --git a/Cargo.lock b/Cargo.lock
index b1039f8ea1..5ade1df648 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3059,6 +3059,7 @@ dependencies = [
  "refunder",
  "reqwest 0.13.2",
  "rstest",
+ "serde",
  "serde_json",
  "shared",
  "signature-validator",
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index faba2186a3..cfc547619f 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -392,17 +392,19 @@ impl Persistence {
 
         let mut ex = self.postgres.pool.acquire().await?;
 
+        let order_uids: Vec<_> = auction
+            .orders
+            .iter()
+            .map(|order| ByteArray(order.uid.0))
+            .collect();
+
         database::auction::save(
             &mut ex,
             database::auction::Auction {
                 id: auction.id,
                 block: i64::try_from(auction.block).context("block overflow")?,
                 deadline: i64::try_from(deadline).context("deadline overflow")?,
-                order_uids: auction
-                    .orders
-                    .iter()
-                    .map(|order| ByteArray(order.uid.0))
-                    .collect(),
+                order_uids: order_uids.clone(),
                 price_tokens: auction
                     .prices
                     .keys()
@@ -422,6 +424,8 @@ impl Persistence {
         )
         .await?;
 
+        database::auction::save_auction_orders(&mut ex, auction.id, &order_uids).await?;
+
         Ok(())
     }
 
diff --git a/crates/database/src/auction.rs b/crates/database/src/auction.rs
index 5659c97b05..5cfcf426e7 100644
--- a/crates/database/src/auction.rs
+++ b/crates/database/src/auction.rs
@@ -80,6 +80,14 @@ pub async fn fetch(ex: &mut PgConnection, id: AuctionId) -> Result<Option<Auctio
     sqlx::query_as(QUERY).bind(id).fetch_optional(ex).await
 }
 
+pub async fn fetch_multiple(
+    ex: &mut PgConnection,
+    ids: &[AuctionId],
+) -> Result<Vec<Auction>, sqlx::Error> {
+    const QUERY: &str = r#"SELECT * FROM competition_auctions WHERE id = ANY($1) ORDER BY id"#;
+    sqlx::query_as(QUERY).bind(ids).fetch_all(ex).await
+}
+
 pub async fn get_order_uids(
     ex: &mut PgConnection,
     auction_id: AuctionId,
@@ -92,6 +100,34 @@ pub async fn get_order_uids(
     Ok(record.map(|(order_uids,)| order_uids))
 }
 
+pub async fn save_auction_orders(
+    ex: &mut PgConnection,
+    auction_id: AuctionId,
+    order_uids: &[OrderUid],
+) -> Result<(), sqlx::Error> {
+    const QUERY: &str = r#"
+INSERT INTO auction_orders (auction_id, order_uid)
+SELECT $1, unnest($2::bytea[])
+ON CONFLICT DO NOTHING
+    "#;
+    sqlx::query(QUERY)
+        .bind(auction_id)
+        .bind(order_uids)
+        .execute(ex)
+        .await?;
+    Ok(())
+}
+
+pub async fn fetch_auction_ids_by_order_uid(
+    ex: &mut PgConnection,
+    order_uid: &OrderUid,
+) -> Result<Vec<AuctionId>, sqlx::Error> {
+    const QUERY: &str =
+        "SELECT auction_id FROM auction_orders WHERE order_uid = $1 ORDER BY auction_id";
+    let rows: Vec<(AuctionId,)> = sqlx::query_as(QUERY).bind(order_uid).fetch_all(ex).await?;
+    Ok(rows.into_iter().map(|(id,)| id).collect())
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, crate::byte_array::ByteArray, sqlx::Connection};
diff --git a/crates/database/src/byte_array.rs b/crates/database/src/byte_array.rs
index 0bca4af378..a4af65b8e4 100644
--- a/crates/database/src/byte_array.rs
+++ b/crates/database/src/byte_array.rs
@@ -8,7 +8,7 @@ use {
         error::BoxDynError,
         postgres::{PgArgumentBuffer, PgHasArrayType, PgTypeInfo, PgValueFormat, PgValueRef},
     },
-    std::fmt::{self, Debug, Formatter},
+    std::fmt::{self, Debug, Display, Formatter},
 };
 
 /// Wrapper type for fixed size byte arrays compatible with sqlx's Postgres
@@ -22,6 +22,12 @@ impl<const N: usize> Debug for ByteArray<N> {
     }
 }
 
+impl<const N: usize> Display for ByteArray<N> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "{}", const_hex::encode_prefixed(self.0))
+    }
+}
+
 impl<const N: usize> Default for ByteArray<N> {
     fn default() -> Self {
         Self([0; N])
diff --git a/crates/database/src/fee_policies.rs b/crates/database/src/fee_policies.rs
index 2dbfb378a2..4fe72c7eee 100644
--- a/crates/database/src/fee_policies.rs
+++ b/crates/database/src/fee_policies.rs
@@ -94,6 +94,15 @@ pub async fn fetch_all(
     Ok(result)
 }
 
+pub async fn fetch_by_order_uid(
+    ex: &mut PgConnection,
+    order_uid: &OrderUid,
+) -> Result<Vec<FeePolicy>, sqlx::Error> {
+    const QUERY: &str =
+        "SELECT * FROM fee_policies WHERE order_uid = $1 ORDER BY auction_id, application_order";
+    sqlx::query_as(QUERY).bind(order_uid).fetch_all(ex).await
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, crate::byte_array::ByteArray, sqlx::Connection};
diff --git a/crates/database/src/lib.rs b/crates/database/src/lib.rs
index 6cdfb9c9a0..97dad43556 100644
--- a/crates/database/src/lib.rs
+++ b/crates/database/src/lib.rs
@@ -75,6 +75,7 @@ pub const TABLES: &[&str] = &[
 
 /// The names of potentially big volume tables we use in the db.
 pub const LARGE_TABLES: &[&str] = &[
+    "auction_orders",
     "auction_prices",
     "competition_auctions",
     "fee_policies",
diff --git a/crates/database/src/order_events.rs b/crates/database/src/order_events.rs
index ebcd658fc2..d180c51912 100644
--- a/crates/database/src/order_events.rs
+++ b/crates/database/src/order_events.rs
@@ -118,6 +118,18 @@ pub async fn get_latest(
         .await
 }
 
+#[instrument(skip_all)]
+pub async fn get_all(
+    ex: &mut PgConnection,
+    order: &OrderUid,
+) -> Result<Vec<OrderEvent>, sqlx::Error> {
+    const QUERY: &str = r#"SELECT * FROM order_events WHERE order_uid = $1 ORDER BY timestamp ASC"#;
+    sqlx::query_as(QUERY)
+        .bind(ByteArray(order.0))
+        .fetch_all(ex)
+        .await
+}
+
 #[cfg(test)]
 mod tests {
     use {
diff --git a/crates/database/src/order_execution.rs b/crates/database/src/order_execution.rs
index e9d38bd8cb..3e0de10c96 100644
--- a/crates/database/src/order_execution.rs
+++ b/crates/database/src/order_execution.rs
@@ -8,6 +8,18 @@ use {
 
 type Execution = (AuctionId, OrderUid);
 
+#[derive(Clone, Debug, PartialEq, sqlx::FromRow)]
+pub struct OrderExecution {
+    pub order_uid: OrderUid,
+    pub auction_id: AuctionId,
+    pub reward: f64,
+    pub executed_fee: BigDecimal,
+    pub executed_fee_token: Address,
+    pub block_number: i64,
+    pub protocol_fee_tokens: Vec<Address>,
+    pub protocol_fee_amounts: Vec<BigDecimal>,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Asset {
     pub amount: BigDecimal,
@@ -48,6 +60,21 @@ DO UPDATE SET reward = $3, executed_fee = $4, executed_fee_token = $5, block_num
     Ok(())
 }
 
+#[instrument(skip_all)]
+pub async fn read_by_order_uid(
+    ex: &mut PgConnection,
+    order_uid: &OrderUid,
+) -> Result<Vec<OrderExecution>, sqlx::Error> {
+    const QUERY: &str = r#"
+SELECT order_uid, auction_id, reward, executed_fee, executed_fee_token,
+       block_number, protocol_fee_tokens, protocol_fee_amounts
+FROM order_execution
+WHERE order_uid = $1
+ORDER BY auction_id
+    "#;
+    sqlx::query_as(QUERY).bind(order_uid).fetch_all(ex).await
+}
+
 /// Fetch protocol fees for all keys in the filter
 #[instrument(skip_all)]
 pub async fn executed_protocol_fees(
diff --git a/crates/database/src/settlement_executions.rs b/crates/database/src/settlement_executions.rs
index a709688539..78e6b465db 100644
--- a/crates/database/src/settlement_executions.rs
+++ b/crates/database/src/settlement_executions.rs
@@ -5,6 +5,19 @@ use {
     tracing::instrument,
 };
 
+#[derive(Clone, Debug, Eq, PartialEq, sqlx::FromRow)]
+pub struct SettlementExecution {
+    pub auction_id: AuctionId,
+    pub solver: Address,
+    pub solution_uid: i64,
+    pub start_timestamp: DateTime<Utc>,
+    pub end_timestamp: Option<DateTime<Utc>>,
+    pub start_block: i64,
+    pub end_block: Option<i64>,
+    pub deadline_block: i64,
+    pub outcome: Option<String>,
+}
+
 #[instrument(skip_all)]
 pub async fn insert(
     ex: &mut PgConnection,
@@ -62,6 +75,21 @@ WHERE auction_id = $1 AND solver = $2 AND solution_uid = $3
     Ok(())
 }
 
+#[instrument(skip_all)]
+pub async fn read_by_auction_ids(
+    ex: &mut PgConnection,
+    auction_ids: &[AuctionId],
+) -> Result<Vec<SettlementExecution>, sqlx::Error> {
+    const QUERY: &str = r#"
+SELECT auction_id, solver, solution_uid, start_timestamp, end_timestamp,
+       start_block, end_block, deadline_block, outcome
+FROM settlement_executions
+WHERE auction_id = ANY($1)
+ORDER BY auction_id, start_timestamp
+    "#;
+    sqlx::query_as(QUERY).bind(auction_ids).fetch_all(ex).await
+}
+
 #[cfg(test)]
 mod tests {
     use {
@@ -122,7 +150,7 @@ mod tests {
 
         let output = fetch(&mut db, auction_id).await.unwrap();
         assert_eq!(output.len(), 3);
-        let expected_a = ExecutionRow {
+        let expected_a = SettlementExecution {
             auction_id,
             solver: solver_a,
             solution_uid: 1,
@@ -133,7 +161,7 @@ mod tests {
             deadline_block,
             outcome: None,
         };
-        let expected_b = ExecutionRow {
+        let expected_b = SettlementExecution {
             auction_id,
             solver: solver_a,
             solution_uid: 2,
@@ -144,7 +172,7 @@ mod tests {
             deadline_block,
             outcome: None,
         };
-        let expected_c = ExecutionRow {
+        let expected_c = SettlementExecution {
             auction_id,
             solver: solver_b,
             solution_uid: 1,
@@ -202,7 +230,7 @@ mod tests {
 
         let output = fetch(&mut db, auction_id).await.unwrap();
         assert_eq!(output.len(), 3);
-        let expected_a = ExecutionRow {
+        let expected_a = SettlementExecution {
             auction_id,
             solver: solver_a,
             solution_uid: 1,
@@ -213,7 +241,7 @@ mod tests {
             deadline_block,
             outcome: Some(success_outcome.clone()),
         };
-        let expected_b = ExecutionRow {
+        let expected_b = SettlementExecution {
             auction_id,
             solver: solver_a,
             solution_uid: 2,
@@ -224,7 +252,7 @@ mod tests {
             deadline_block,
             outcome: Some(failure_outcome),
         };
-        let expected_c = ExecutionRow {
+        let expected_c = SettlementExecution {
             auction_id,
             solver: solver_b,
             solution_uid: 1,
@@ -240,23 +268,10 @@ mod tests {
         assert!(output.contains(&expected_c));
     }
 
-    #[derive(Debug, Clone, Eq, PartialEq, sqlx::FromRow)]
-    struct ExecutionRow {
-        pub auction_id: AuctionId,
-        pub solver: Address,
-        pub solution_uid: i64,
-        pub start_timestamp: DateTime<Utc>,
-        pub end_timestamp: Option<DateTime<Utc>>,
-        pub start_block: i64,
-        pub end_block: Option<i64>,
-        pub deadline_block: i64,
-        pub outcome: Option<String>,
-    }
-
     async fn fetch(
         ex: &mut PgConnection,
         auction_id: AuctionId,
-    ) -> Result<Vec<ExecutionRow>, sqlx::Error> {
+    ) -> Result<Vec<super::SettlementExecution>, sqlx::Error> {
         const QUERY: &str = r#"SELECT * FROM settlement_executions WHERE auction_id = $1;"#;
 
         sqlx::query_as(QUERY).bind(auction_id).fetch_all(ex).await
diff --git a/crates/database/src/solver_competition_v2.rs b/crates/database/src/solver_competition_v2.rs
index 046090b1e9..cf9f5a277b 100644
--- a/crates/database/src/solver_competition_v2.rs
+++ b/crates/database/src/solver_competition_v2.rs
@@ -483,6 +483,36 @@ pub async fn fetch_in_flight_orders(
         .await
 }
 
+#[derive(Clone, Debug, sqlx::FromRow)]
+pub struct OrderProposedSolution {
+    pub auction_id: AuctionId,
+    pub solution_uid: i64,
+    pub solver: Address,
+    pub is_winner: bool,
+    pub filtered_out: bool,
+    pub score: BigDecimal,
+    pub executed_sell: BigDecimal,
+    pub executed_buy: BigDecimal,
+}
+
+#[instrument(skip_all)]
+pub async fn find_solutions_for_order(
+    ex: &mut PgConnection,
+    order_uid: &OrderUid,
+) -> Result<Vec<OrderProposedSolution>, sqlx::Error> {
+    const QUERY: &str = r#"
+SELECT ps.auction_id, ps.uid AS solution_uid,
+       ps.solver, ps.is_winner, ps.filtered_out, ps.score,
+       pte.executed_sell, pte.executed_buy
+FROM proposed_trade_executions pte
+JOIN proposed_solutions ps
+    ON ps.auction_id = pte.auction_id AND ps.uid = pte.solution_uid
+WHERE pte.order_uid = $1
+ORDER BY ps.auction_id DESC, ps.uid
+    "#;
+    sqlx::query_as(QUERY).bind(order_uid).fetch_all(ex).await
+}
+
 #[cfg(test)]
 mod tests {
     use {
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 5016481608..5b8454b016 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -50,6 +50,7 @@ observe = { workspace = true }
 orderbook = { workspace = true, features = ["e2e", "test-util"] }
 price-estimation = { workspace = true }
 reqwest = { workspace = true, features = ["blocking", "query"] }
+serde = { workspace = true }
 serde_json = { workspace = true }
 shared = { workspace = true }
 signature-validator = { workspace = true }
diff --git a/crates/e2e/tests/e2e/debug_order.rs b/crates/e2e/tests/e2e/debug_order.rs
new file mode 100644
index 0000000000..a666449ee9
--- /dev/null
+++ b/crates/e2e/tests/e2e/debug_order.rs
@@ -0,0 +1,154 @@
+use {
+    configs::test_util::TestDefault,
+    e2e::setup::*,
+    ethrpc::alloy::CallBuilderExt,
+    model::{
+        debug_report::DebugReport,
+        order::{OrderCreation, OrderKind},
+        signature::EcdsaSigningScheme,
+    },
+    number::units::EthUnit,
+    reqwest::StatusCode,
+    shared::web3::Web3,
+};
+
+#[tokio::test]
+#[ignore]
+async fn local_node_debug_order() {
+    run_test(debug_order).await;
+}
+
+async fn debug_order(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            ExtraServiceArgs::default(),
+            autopilot::config::Configuration::test("test_solver", solver.address()),
+            orderbook::config::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    let order = OrderCreation {
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: 2u64.eth(),
+        buy_token: *token.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Buy,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let uid = services.create_order(&order).await.unwrap();
+    onchain.mint_block().await;
+
+    tracing::info!("Waiting for trade.");
+    let trade_happened = || async {
+        onchain.mint_block().await;
+        !token
+            .balanceOf(trader.address())
+            .call()
+            .await
+            .unwrap()
+            .is_zero()
+    };
+    wait_for_condition(TIMEOUT, trade_happened).await.unwrap();
+
+    let client = services.client();
+
+    // Helper to fetch the debug report.
+    let fetch_debug_report = || async {
+        let response = client
+            .get(format!("{API_HOST}/api/v1/debug/order/{uid}"))
+            .send()
+            .await
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+        response.json::<DebugReport>().await.unwrap()
+    };
+
+    // Wait until the debug report is fully populated (settlement data is
+    // written asynchronously, so we poll until trades appear).
+    let report_populated = || async {
+        let report = fetch_debug_report().await;
+        !report.trades.is_empty()
+    };
+    wait_for_condition(TIMEOUT, report_populated).await.unwrap();
+
+    // Deserializing into DebugOrderResponse validates all field names and types.
+    let report = fetch_debug_report().await;
+
+    assert_eq!(report.order_uid, uid);
+    assert_eq!(report.order.data.kind, OrderKind::Buy);
+
+    assert_eq!(
+        report.events.len(),
+        4,
+        "expected exactly created+ready+executing+traded events, got {:?}",
+        report.events
+    );
+    assert_eq!(report.events[0].label, "created");
+    assert_eq!(report.events[1].label, "ready");
+    assert_eq!(report.events[2].label, "executing");
+    assert_eq!(report.events[3].label, "traded");
+
+    assert!(!report.trades.is_empty(), "expected at least one trade");
+    assert!(!report.auctions.is_empty(), "expected at least one auction");
+
+    let auction = &report.auctions[0];
+    assert!(
+        !auction.native_prices.is_empty(),
+        "expected native prices for sell/buy tokens"
+    );
+    assert!(
+        !auction.proposed_solutions.is_empty(),
+        "expected at least one proposed solution"
+    );
+    assert!(
+        !auction.executions.is_empty(),
+        "expected at least one execution"
+    );
+    assert!(
+        !auction.settlement_attempts.is_empty(),
+        "expected at least one settlement attempt"
+    );
+
+    // Non-existent order -> 404.
+    let fake_uid = "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/order/{fake_uid}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+}
diff --git a/crates/e2e/tests/e2e/main.rs b/crates/e2e/tests/e2e/main.rs
index 4d5eeb15da..b7e1668b67 100644
--- a/crates/e2e/tests/e2e/main.rs
+++ b/crates/e2e/tests/e2e/main.rs
@@ -13,6 +13,7 @@ mod buffers;
 mod cors;
 mod cow_amm;
 mod database;
+mod debug_order;
 mod deprecated_endpoints;
 mod eth_integration;
 mod eth_safe;
diff --git a/crates/model/src/debug_report.rs b/crates/model/src/debug_report.rs
new file mode 100644
index 0000000000..c21ed66e1d
--- /dev/null
+++ b/crates/model/src/debug_report.rs
@@ -0,0 +1,146 @@
+use {
+    crate::order::{Order, OrderUid},
+    alloy_primitives::{Address, B256},
+    bigdecimal::BigDecimal,
+    chrono::{DateTime, Utc},
+    serde::Serialize,
+    serde_with::{DisplayFromStr, serde_as},
+    std::collections::HashMap,
+};
+
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct DebugReport {
+    pub order_uid: OrderUid,
+    pub order: Order,
+    pub events: Vec<Event>,
+    pub auctions: Vec<Auction>,
+    pub trades: Vec<Trade>,
+}
+
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+    pub label: String,
+    pub timestamp: DateTime<Utc>,
+}
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct Auction {
+    pub id: i64,
+    pub block: i64,
+    pub deadline: i64,
+    #[serde_as(as = "HashMap<_, DisplayFromStr>")]
+    pub native_prices: HashMap<Address, BigDecimal>,
+    pub proposed_solutions: Vec<ProposedSolution>,
+    pub executions: Vec<Execution>,
+    pub settlement_attempts: Vec<SettlementAttempt>,
+    pub fee_policies: Vec<FeePolicy>,
+}
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct ProposedSolution {
+    pub solution_uid: i64,
+    pub ranking: i64,
+    pub solver: Address,
+    pub is_winner: bool,
+    pub filtered_out: bool,
+    #[serde_as(as = "DisplayFromStr")]
+    pub score: BigDecimal,
+    #[serde_as(as = "DisplayFromStr")]
+    pub executed_sell: BigDecimal,
+    #[serde_as(as = "DisplayFromStr")]
+    pub executed_buy: BigDecimal,
+}
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct Execution {
+    #[serde_as(as = "DisplayFromStr")]
+    pub executed_fee: BigDecimal,
+    pub executed_fee_token: Address,
+    pub block_number: i64,
+    pub protocol_fees: Vec<ProtocolFee>,
+}
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct ProtocolFee {
+    pub token: Address,
+    #[serde_as(as = "DisplayFromStr")]
+    pub amount: BigDecimal,
+}
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct Trade {
+    pub block_number: i64,
+    pub log_index: i64,
+    #[serde_as(as = "DisplayFromStr")]
+    pub buy_amount: BigDecimal,
+    #[serde_as(as = "DisplayFromStr")]
+    pub sell_amount: BigDecimal,
+    #[serde_as(as = "DisplayFromStr")]
+    pub sell_amount_before_fees: BigDecimal,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tx_hash: Option<B256>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auction_id: Option<i64>,
+}
+
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct SettlementAttempt {
+    pub solver: Address,
+    pub solution_uid: i64,
+    pub start_timestamp: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end_timestamp: Option<DateTime<Utc>>,
+    pub start_block: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end_block: Option<i64>,
+    pub deadline_block: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub outcome: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct FeePolicy {
+    pub kind: FeePolicyKind,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub surplus_factor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub surplus_max_volume_factor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub volume_factor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub price_improvement_factor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub price_improvement_max_volume_factor: Option<f64>,
+}
+
+#[derive(Debug, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub enum FeePolicyKind {
+    Surplus,
+    Volume,
+    PriceImprovement,
+}
diff --git a/crates/model/src/lib.rs b/crates/model/src/lib.rs
index 4f3919f717..d62f1b9c67 100644
--- a/crates/model/src/lib.rs
+++ b/crates/model/src/lib.rs
@@ -1,5 +1,6 @@
 //! Contains models that are shared between the orderbook and the solver.
 
+pub mod debug_report;
 pub mod fee_policy;
 pub mod interaction;
 pub mod order;
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index d46306eb75..93d6fe6dd9 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -769,6 +769,33 @@ paths:
                 $ref: "#/components/schemas/TotalSurplus"
         "400":
           description: Invalid address.
+  "/api/v1/debug/order/{uid}":
+    get:
+      operationId: debugOrder
+      summary: Debug an order's lifecycle.
+      description: >
+        Returns a comprehensive debug report for the given order, including
+        order details, lifecycle events, auction participation, proposed
+        solutions, executions, trades, and settlement attempts.
+      parameters:
+        - in: path
+          name: uid
+          schema:
+            $ref: "#/components/schemas/UID"
+          required: true
+      responses:
+        "200":
+          description: Debug report returned.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/DebugOrderResponse"
+        "400":
+          description: Invalid order UID (malformed hex or wrong length).
+        "404":
+          description: Order not found.
+        "500":
+          description: Internal error.
 components:
   schemas:
     TransactionHash:
@@ -2271,3 +2298,218 @@ components:
           allOf:
             - description: The token in which the fee is taken
             - $ref: "#/components/schemas/Address"
+    DebugOrderResponse:
+      type: object
+      required:
+        - orderUid
+        - order
+        - events
+        - auctions
+        - trades
+      properties:
+        orderUid:
+          description: The UID of the order being debugged.
+          allOf:
+            - $ref: "#/components/schemas/UID"
+        order:
+          $ref: "#/components/schemas/Order"
+        events:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugEvent"
+        auctions:
+          description: >
+            Auctions this order participated in, sorted by ID. Each auction
+            groups all related data: native prices, proposed solutions,
+            executions, settlement attempts, and fee policies.
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugAuction"
+        trades:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugTrade"
+    DebugEvent:
+      type: object
+      required:
+        - label
+        - timestamp
+      properties:
+        label:
+          type: string
+          description: Event type (e.g. created, ready, filtered, traded).
+        timestamp:
+          type: string
+          format: date-time
+    DebugAuction:
+      type: object
+      required:
+        - id
+        - block
+        - deadline
+        - nativePrices
+        - proposedSolutions
+        - executions
+        - settlementAttempts
+        - feePolicies
+      properties:
+        id:
+          type: integer
+          description: Auction ID.
+        block:
+          type: integer
+          description: Block number of the auction.
+        deadline:
+          type: integer
+          description: Deadline block for the auction.
+        nativePrices:
+          type: object
+          additionalProperties:
+            type: string
+          description: >
+            Native prices for the order's sell and buy tokens in this auction.
+            Keys are hex-encoded token addresses, values are decimal price
+            strings.
+        proposedSolutions:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugProposedSolution"
+        executions:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugExecution"
+        settlementAttempts:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugSettlementAttempt"
+        feePolicies:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugFeePolicy"
+    DebugProposedSolution:
+      type: object
+      required:
+        - solutionUid
+        - ranking
+        - solver
+        - isWinner
+        - filteredOut
+        - score
+        - executedSell
+        - executedBuy
+      properties:
+        solutionUid:
+          type: integer
+        ranking:
+          type: integer
+        solver:
+          $ref: "#/components/schemas/Address"
+        isWinner:
+          type: boolean
+        filteredOut:
+          type: boolean
+        score:
+          type: string
+          description: Decimal-encoded score.
+        executedSell:
+          $ref: "#/components/schemas/TokenAmount"
+        executedBuy:
+          $ref: "#/components/schemas/TokenAmount"
+    DebugExecution:
+      type: object
+      required:
+        - executedFee
+        - executedFeeToken
+        - blockNumber
+        - protocolFees
+      properties:
+        executedFee:
+          $ref: "#/components/schemas/TokenAmount"
+        executedFeeToken:
+          $ref: "#/components/schemas/Address"
+        blockNumber:
+          type: integer
+        protocolFees:
+          type: array
+          items:
+            $ref: "#/components/schemas/DebugProtocolFee"
+    DebugProtocolFee:
+      type: object
+      required:
+        - token
+        - amount
+      properties:
+        token:
+          $ref: "#/components/schemas/Address"
+        amount:
+          $ref: "#/components/schemas/TokenAmount"
+    DebugTrade:
+      type: object
+      required:
+        - blockNumber
+        - logIndex
+        - buyAmount
+        - sellAmount
+        - sellAmountBeforeFees
+      properties:
+        blockNumber:
+          type: integer
+        logIndex:
+          type: integer
+        buyAmount:
+          $ref: "#/components/schemas/TokenAmount"
+        sellAmount:
+          $ref: "#/components/schemas/TokenAmount"
+        sellAmountBeforeFees:
+          $ref: "#/components/schemas/TokenAmount"
+        txHash:
+          $ref: "#/components/schemas/TransactionHash"
+        auctionId:
+          type: integer
+    DebugSettlementAttempt:
+      type: object
+      required:
+        - solver
+        - solutionUid
+        - startTimestamp
+        - startBlock
+        - deadlineBlock
+      properties:
+        solver:
+          $ref: "#/components/schemas/Address"
+        solutionUid:
+          type: integer
+        startTimestamp:
+          type: string
+          format: date-time
+        endTimestamp:
+          type: string
+          format: date-time
+        startBlock:
+          type: integer
+        endBlock:
+          type: integer
+        deadlineBlock:
+          type: integer
+        outcome:
+          type: string
+          description: Settlement outcome (e.g. "success", "revert").
+    DebugFeePolicy:
+      type: object
+      description: Fee policy applied to this order in this auction.
+      required:
+        - kind
+      properties:
+        kind:
+          type: string
+          enum: [surplus, volume, priceImprovement]
+        surplusFactor:
+          type: number
+        surplusMaxVolumeFactor:
+          type: number
+        volumeFactor:
+          type: number
+        priceImprovementFactor:
+          type: number
+        priceImprovementMaxVolumeFactor:
+          type: number
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 9e74855b83..977bfce7d4 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -29,6 +29,7 @@ use {
 
 mod cancel_order;
 mod cancel_orders;
+mod debug_order;
 mod get_app_data;
 mod get_auction;
 mod get_native_price;
@@ -259,6 +260,11 @@ pub fn handle_all_routes(
             get(get_total_surplus::get_total_surplus_handler),
         ),
         ("GET", "/api/v1/version", get(version::version_handler)),
+        (
+            "GET",
+            "/api/v1/debug/order/{uid}",
+            get(debug_order::debug_order_handler),
+        ),
         // V2 routes
         // /solver_competition routes (specific before parameterized)
         (
diff --git a/crates/orderbook/src/api/debug_order.rs b/crates/orderbook/src/api/debug_order.rs
new file mode 100644
index 0000000000..bcae471f99
--- /dev/null
+++ b/crates/orderbook/src/api/debug_order.rs
@@ -0,0 +1,28 @@
+use {
+    crate::api::AppState,
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    model::order::OrderUid,
+    std::sync::Arc,
+};
+
+pub async fn debug_order_handler(
+    State(state): State<Arc<AppState>>,
+    Path(uid): Path<OrderUid>,
+) -> Response {
+    match state.database_read.fetch_debug_report(&uid).await {
+        Ok(Some(report)) => (StatusCode::OK, Json(report)).into_response(),
+        Ok(None) => (
+            StatusCode::NOT_FOUND,
+            super::error("NotFound", "order not found"),
+        )
+            .into_response(),
+        Err(err) => {
+            tracing::error!(?err, "failed to fetch debug report");
+            crate::api::internal_error_reply()
+        }
+    }
+}
diff --git a/crates/orderbook/src/database/debug_report.rs b/crates/orderbook/src/database/debug_report.rs
new file mode 100644
index 0000000000..8fd1d3b091
--- /dev/null
+++ b/crates/orderbook/src/database/debug_report.rs
@@ -0,0 +1,239 @@
+use {
+    super::Postgres,
+    crate::database::orders::OrderStoring,
+    alloy::primitives::{Address, B256},
+    anyhow::{Context, Result},
+    database::{
+        auction::{self, Auction as DbAuction, AuctionId},
+        byte_array::ByteArray,
+        fee_policies::{self, FeePolicy as DbFeePolicy, FeePolicyKind as DbFeePolicyKind},
+        order_events,
+        order_execution::{self, OrderExecution as DbOrderExecution},
+        settlement_executions::{self, SettlementExecution as DbSettlementExecution},
+        solver_competition_v2::{self, OrderProposedSolution as DbProposedSolution},
+        trades::{self, TradesQueryRow as DbTradesQueryRow},
+    },
+    futures::TryStreamExt,
+    model::{
+        debug_report::{
+            Auction,
+            DebugReport,
+            Event,
+            Execution,
+            FeePolicy,
+            FeePolicyKind,
+            ProposedSolution,
+            ProtocolFee,
+            SettlementAttempt,
+            Trade,
+        },
+        order::OrderUid,
+    },
+    std::collections::HashMap,
+};
+
+impl Postgres {
+    pub async fn fetch_debug_report(&self, uid: &OrderUid) -> Result<Option<DebugReport>> {
+        let _timer = super::Metrics::get()
+            .database_queries
+            .with_label_values(&["fetch_debug_report"])
+            .start_timer();
+
+        let db_uid = ByteArray(uid.0);
+        let order = match self.single_order(uid).await? {
+            Some(order) => order,
+            None => return Ok(None),
+        };
+
+        let mut conn = self.pool.acquire().await?;
+
+        let events: Vec<Event> = order_events::get_all(&mut conn, &db_uid)
+            .await?
+            .into_iter()
+            .map(|e| Event {
+                label: format!("{:?}", e.label).to_lowercase(),
+                timestamp: e.timestamp,
+            })
+            .collect();
+
+        let proposed_solutions =
+            solver_competition_v2::find_solutions_for_order(&mut conn, &db_uid).await?;
+        let executions = order_execution::read_by_order_uid(&mut conn, &db_uid).await?;
+        let trades: Vec<DbTradesQueryRow> = trades::trades(&mut conn, None, Some(&db_uid), 0, 100)
+            .into_inner()
+            .try_collect()
+            .await
+            .context("failed to fetch trades")?;
+
+        let auction_ids: Vec<AuctionId> =
+            auction::fetch_auction_ids_by_order_uid(&mut conn, &db_uid).await?;
+
+        let db_auctions = auction::fetch_multiple(&mut conn, &auction_ids).await?;
+        let settlement_execs =
+            settlement_executions::read_by_auction_ids(&mut conn, &auction_ids).await?;
+        let fee_policies = fee_policies::fetch_by_order_uid(&mut conn, &db_uid).await?;
+
+        let sell_token = order.data.sell_token;
+        let buy_token = order.data.buy_token;
+        let auctions = build_auctions(
+            db_auctions,
+            proposed_solutions,
+            executions,
+            settlement_execs,
+            fee_policies,
+            sell_token,
+            buy_token,
+        );
+
+        Ok(Some(DebugReport {
+            order_uid: *uid,
+            order,
+            events,
+            auctions,
+            trades: trades.into_iter().map(convert_trade).collect(),
+        }))
+    }
+}
+
+fn build_auctions(
+    db_auctions: Vec<DbAuction>,
+    db_solutions: Vec<DbProposedSolution>,
+    db_executions: Vec<DbOrderExecution>,
+    db_settlements: Vec<DbSettlementExecution>,
+    db_fees: Vec<DbFeePolicy>,
+    sell_token: Address,
+    buy_token: Address,
+) -> Vec<Auction> {
+    let sell = ByteArray(sell_token.0.0);
+    let buy = ByteArray(buy_token.0.0);
+
+    let mut solutions_by_auction: HashMap<i64, Vec<ProposedSolution>> = HashMap::new();
+    for s in db_solutions {
+        solutions_by_auction
+            .entry(s.auction_id)
+            .or_default()
+            .push(convert_solution(s));
+    }
+
+    let mut executions_by_auction: HashMap<i64, Vec<Execution>> = HashMap::new();
+    for e in db_executions {
+        executions_by_auction
+            .entry(e.auction_id)
+            .or_default()
+            .push(convert_execution(e));
+    }
+
+    let mut settlements_by_auction: HashMap<i64, Vec<SettlementAttempt>> = HashMap::new();
+    for s in db_settlements {
+        settlements_by_auction
+            .entry(s.auction_id)
+            .or_default()
+            .push(convert_settlement(s));
+    }
+
+    let mut fees_by_auction: HashMap<i64, Vec<FeePolicy>> = HashMap::new();
+    for f in db_fees {
+        fees_by_auction
+            .entry(f.auction_id)
+            .or_default()
+            .push(convert_fee_policy(f));
+    }
+
+    let mut auctions: Vec<Auction> = db_auctions
+        .into_iter()
+        .map(|a| {
+            let native_prices = a
+                .price_tokens
+                .iter()
+                .zip(&a.price_values)
+                .filter(|(token, _)| **token == sell || **token == buy)
+                .map(|(token, price)| (Address::from(token.0), price.clone()))
+                .collect();
+            let id = a.id;
+            Auction {
+                id,
+                block: a.block,
+                deadline: a.deadline,
+                native_prices,
+                proposed_solutions: solutions_by_auction.remove(&id).unwrap_or_default(),
+                executions: executions_by_auction.remove(&id).unwrap_or_default(),
+                settlement_attempts: settlements_by_auction.remove(&id).unwrap_or_default(),
+                fee_policies: fees_by_auction.remove(&id).unwrap_or_default(),
+            }
+        })
+        .collect();
+
+    auctions.sort_by_key(|a| a.id);
+    auctions
+}
+
+fn convert_solution(s: DbProposedSolution) -> ProposedSolution {
+    ProposedSolution {
+        solution_uid: s.solution_uid,
+        ranking: s.solution_uid + 1,
+        solver: Address::from(s.solver.0),
+        is_winner: s.is_winner,
+        filtered_out: s.filtered_out,
+        score: s.score,
+        executed_sell: s.executed_sell,
+        executed_buy: s.executed_buy,
+    }
+}
+
+fn convert_execution(e: DbOrderExecution) -> Execution {
+    let protocol_fees = e
+        .protocol_fee_tokens
+        .iter()
+        .zip(e.protocol_fee_amounts.iter())
+        .map(|(token, amount)| ProtocolFee {
+            token: Address::from(token.0),
+            amount: amount.clone(),
+        })
+        .collect();
+    Execution {
+        executed_fee: e.executed_fee,
+        executed_fee_token: Address::from(e.executed_fee_token.0),
+        block_number: e.block_number,
+        protocol_fees,
+    }
+}
+
+fn convert_trade(t: DbTradesQueryRow) -> Trade {
+    Trade {
+        block_number: t.block_number,
+        log_index: t.log_index,
+        buy_amount: t.buy_amount,
+        sell_amount: t.sell_amount,
+        sell_amount_before_fees: t.sell_amount_before_fees,
+        tx_hash: t.tx_hash.map(|h| B256::from(h.0)),
+        auction_id: t.auction_id,
+    }
+}
+
+fn convert_settlement(s: DbSettlementExecution) -> SettlementAttempt {
+    SettlementAttempt {
+        solver: Address::from(s.solver.0),
+        solution_uid: s.solution_uid,
+        start_timestamp: s.start_timestamp,
+        end_timestamp: s.end_timestamp,
+        start_block: s.start_block,
+        end_block: s.end_block,
+        deadline_block: s.deadline_block,
+        outcome: s.outcome,
+    }
+}
+
+fn convert_fee_policy(f: DbFeePolicy) -> FeePolicy {
+    FeePolicy {
+        kind: match f.kind {
+            DbFeePolicyKind::Surplus => FeePolicyKind::Surplus,
+            DbFeePolicyKind::Volume => FeePolicyKind::Volume,
+            DbFeePolicyKind::PriceImprovement => FeePolicyKind::PriceImprovement,
+        },
+        surplus_factor: f.surplus_factor,
+        surplus_max_volume_factor: f.surplus_max_volume_factor,
+        volume_factor: f.volume_factor,
+        price_improvement_factor: f.price_improvement_factor,
+        price_improvement_max_volume_factor: f.price_improvement_max_volume_factor,
+    }
+}
diff --git a/crates/orderbook/src/database/mod.rs b/crates/orderbook/src/database/mod.rs
index 76a44ad7cc..8cb125334c 100644
--- a/crates/orderbook/src/database/mod.rs
+++ b/crates/orderbook/src/database/mod.rs
@@ -1,6 +1,7 @@
 pub mod app_data;
 pub mod auction_prices;
 pub mod auctions;
+pub mod debug_report;
 mod fee_policies;
 pub mod orders;
 pub mod quotes;
diff --git a/database/sql/V105__index_proposed_trade_executions_by_order_uid.sql b/database/sql/V105__index_proposed_trade_executions_by_order_uid.sql
new file mode 100644
index 0000000000..f79842c6ef
--- /dev/null
+++ b/database/sql/V105__index_proposed_trade_executions_by_order_uid.sql
@@ -0,0 +1,2 @@
+CREATE INDEX CONCURRENTLY IF NOT EXISTS proposed_trade_executions_by_order_uid
+ON proposed_trade_executions (order_uid);
diff --git a/database/sql/V106__create_auction_orders.sql b/database/sql/V106__create_auction_orders.sql
new file mode 100644
index 0000000000..01fa889fab
--- /dev/null
+++ b/database/sql/V106__create_auction_orders.sql
@@ -0,0 +1,8 @@
+-- Junction table mapping orders to auctions they participated in.
+CREATE TABLE auction_orders (
+    auction_id bigint NOT NULL,
+    order_uid  bytea  NOT NULL,
+    PRIMARY KEY (auction_id, order_uid)
+);
+
+CREATE INDEX auction_orders_by_order_uid ON auction_orders (order_uid);

From e287d6c92c71787b4c016996f6add6e97e313833 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Wed, 11 Mar 2026 10:24:08 +0100
Subject: [PATCH 136/219] [TRIVIAL] Log order uids with encoding errors (#4250)

# Description
Currently it's quite annoying to figure out when a solver provided a
solution for a given order that fails to encode.

# Changes
This PR adjusts the log to also mention the order uids of the solution
that failed to encode.
---
 crates/driver/src/domain/competition/mod.rs | 31 +++++++++++++--------
 crates/driver/src/infra/observe/mod.rs      |  2 ++
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 398f287a01..2026655e11 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -403,14 +403,9 @@ impl Competition {
         let encoded = all_solutions
             .into_iter()
             .map(|solution| async move {
-                let id = solution.id().clone();
-                let orders: Vec<_> = solution
-                    .user_trades()
-                    .map(|trade| trade.order().uid)
-                    .collect();
-                let has_haircut = solution.has_haircut();
-                observe::encoding(&id);
+                observe::encoding(solution.id());
                 let settlement = solution
+                    .clone()
                     .encode(
                         auction,
                         &self.eth,
@@ -418,20 +413,32 @@ impl Competition {
                         self.solver.solver_native_token(),
                     )
                     .await;
-                (id, orders, has_haircut, settlement)
+                (solution, settlement)
             })
             .collect::<FuturesUnordered<_>>()
-            .filter_map(|(id, orders, has_haircut, result)| async move {
+            .filter_map(|(solution, result)| async move {
+                let id = solution.id().clone();
+                let orders: Vec<_> = solution
+                    .user_trades()
+                    .map(|trade| trade.order().uid)
+                    .collect();
+                let has_haircut = solution.has_haircut();
                 match result {
-                    Ok(solution) => {
+                    Ok(encoded) => {
                         self.risk_detector.encoding_succeeded(&orders);
-                        Some(solution)
+                        Some(encoded)
                     }
                     // don't report on errors coming from solution merging
                     Err(_err) if id.solutions().len() > 1 => None,
                     Err(err) => {
                         self.risk_detector.encoding_failed(&orders);
-                        observe::encoding_failed(self.solver.name(), &id, &err, has_haircut);
+                        observe::encoding_failed(
+                            self.solver.name(),
+                            &id,
+                            &err,
+                            has_haircut,
+                            &orders,
+                        );
                         // don't notify on errors for solutions with haircut
                         if !has_haircut {
                             notify::encoding_failed(&self.solver, auction.id(), &id, &err);
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index ff2d315648..589275fc31 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -127,9 +127,11 @@ pub fn encoding_failed(
     id: &solution::Id,
     err: &solution::Error,
     has_haircut: bool,
+    orders: &[competition::order::Uid],
 ) {
     tracing::info!(
         ?id,
+        ?orders,
         ?err,
         has_haircut,
         "discarded solution: settlement encoding"

From 10f71cbd7d290a21ac299d2457d0790490bc726c Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 11 Mar 2026 10:15:23 +0000
Subject: [PATCH 137/219] Inline submission account config (#4242)

# Description
While testing a feature, I noticed that the driver's submission account
is currently rendered in our infra as follows:
```toml
[[drivers]]
name = "okx-solve"
url = "http://mainnet-driver-staging-.../"

[drivers.submission-account]
kms = "arn:aws:kms:eu-central-...."
```
, where the submission-account is separated, which is not really
convenient when manually editing configs.

This PR flattens the submission account config, so it will be rendered
as:
```toml
[[drivers]]
name = "okx-solve"
url = "http://mainnet-driver-staging-.../"
kms = "arn:aws:kms:eu-central-...."
```
---
 crates/autopilot/src/config/mod.rs    |  6 +++---
 crates/autopilot/src/config/solver.rs | 11 +++++------
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
index 283e401c64..368957e9f6 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/autopilot/src/config/mod.rs
@@ -278,12 +278,12 @@ mod tests {
         [[drivers]]
         name = "solver1"
         url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 
         [[drivers]]
         name = "solver2"
         url = "http://localhost:8081"
-        submission-account.kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
+        kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
 
         [fee-policies]
         max-partner-fee = 0.005
@@ -424,7 +424,7 @@ mod tests {
         [[drivers]]
         name = "solver1"
         url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 
         [fee-policies]
 
diff --git a/crates/autopilot/src/config/solver.rs b/crates/autopilot/src/config/solver.rs
index e00c06b810..2211a2b127 100644
--- a/crates/autopilot/src/config/solver.rs
+++ b/crates/autopilot/src/config/solver.rs
@@ -8,10 +8,11 @@ use {
 
 /// External solver driver configuration
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+#[serde(rename_all = "kebab-case")]
 pub struct Solver {
     pub name: String,
     pub url: Url,
+    #[serde(flatten)]
     pub submission_account: Account,
 }
 
@@ -80,7 +81,7 @@ mod test {
         let toml = r#"
         name = "name1"
         url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
         "#;
         let driver = toml::from_str::<Solver>(toml).unwrap();
 
@@ -97,7 +98,7 @@ mod test {
         let toml = r#"
         name = "name1"
         url = "http://localhost:8080"
-        submission-account.kms = "arn:aws:kms:supersecretstuff"
+        kms = "arn:aws:kms:supersecretstuff"
         "#;
         let driver = toml::from_str::<Solver>(toml).unwrap();
 
@@ -156,13 +157,11 @@ mod test {
         [[drivers]]
         name = "solver1"
         url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+        address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
 
         [[drivers]]
         name = "solver2"
         url = "http://localhost:8081"
-        # test the format used in the infra repo
-        [drivers.submission-account]
         kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
         "#;
 

From a1cb98b3b36450519d5572a58abb20b8a9ffc1af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 11 Mar 2026 11:14:34 +0000
Subject: [PATCH 138/219] Extract autopilot config to configs crate (#4246)

# Description
Addresses
https://github.com/cowprotocol/services/pull/4235#discussion_r2910627059

# Changes

* Moves autopilot configs to configs crate
* Moves fee factor to configs crate

## How to test
Compilation + tests
---
 Cargo.lock                                    | 10 ++++++
 .../domain/competition/winner_selection.rs    |  2 +-
 crates/autopilot/src/domain/fee/mod.rs        | 21 +++++++-----
 crates/autopilot/src/domain/fee/policy.rs     |  4 +--
 .../src/infra/persistence/dto/order.rs        |  2 +-
 crates/autopilot/src/infra/solvers/mod.rs     |  3 +-
 crates/autopilot/src/lib.rs                   |  1 -
 crates/autopilot/src/run.rs                   |  2 +-
 crates/autopilot/src/run_loop.rs              |  4 +--
 crates/configs/Cargo.toml                     | 13 +++++++-
 .../src/autopilot}/banned_users.rs            |  0
 .../src/autopilot}/cow_amm.rs                 | 10 ++----
 .../src/autopilot}/ethflow.rs                 |  2 +-
 .../src/autopilot}/fee_policy.rs              |  2 +-
 .../config => configs/src/autopilot}/mod.rs   | 32 ++++++++++---------
 .../src/autopilot}/native_price.rs            |  0
 .../src/autopilot}/order_events_cleanup.rs    |  0
 .../src/autopilot}/run_loop.rs                |  2 +-
 .../config => configs/src/autopilot}/s3.rs    |  0
 .../src/autopilot}/solver.rs                  |  0
 .../src/autopilot}/trusted_tokens.rs          |  0
 crates/configs/src/database.rs                |  2 +-
 crates/{shared => configs}/src/fee_factor.rs  |  0
 crates/configs/src/lib.rs                     |  2 ++
 crates/e2e/src/setup/services.rs              | 22 ++++++-------
 crates/e2e/tests/e2e/autopilot_leader.rs      |  8 ++---
 crates/e2e/tests/e2e/buffers.rs               |  7 ++--
 crates/e2e/tests/e2e/cow_amm.rs               | 10 +++---
 crates/e2e/tests/e2e/debug_order.rs           |  2 +-
 crates/e2e/tests/e2e/jit_orders.rs            |  3 +-
 crates/e2e/tests/e2e/limit_orders.rs          | 21 ++++++------
 crates/e2e/tests/e2e/liquidity.rs             |  3 +-
 .../e2e/liquidity_source_notification.rs      |  3 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |  3 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  4 +--
 crates/e2e/tests/e2e/protocol_fee.rs          | 25 ++++++++-------
 crates/e2e/tests/e2e/quote_verification.rs    |  3 +-
 crates/e2e/tests/e2e/quoting.rs               |  5 ++-
 crates/e2e/tests/e2e/replace_order.rs         |  2 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |  2 +-
 crates/e2e/tests/e2e/solver_competition.rs    | 12 ++++---
 crates/e2e/tests/e2e/submission.rs            |  3 +-
 crates/orderbook/src/config/mod.rs            |  3 +-
 crates/orderbook/src/quoter.rs                |  4 +--
 crates/shared/Cargo.toml                      |  1 +
 crates/shared/src/arguments.rs                |  2 +-
 crates/shared/src/fee.rs                      |  3 +-
 crates/shared/src/lib.rs                      |  1 -
 48 files changed, 147 insertions(+), 119 deletions(-)
 rename crates/{autopilot/src/config => configs/src/autopilot}/banned_users.rs (100%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/cow_amm.rs (90%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/ethflow.rs (96%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/fee_policy.rs (99%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/mod.rs (96%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/native_price.rs (100%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/order_events_cleanup.rs (100%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/run_loop.rs (98%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/s3.rs (100%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/solver.rs (100%)
 rename crates/{autopilot/src/config => configs/src/autopilot}/trusted_tokens.rs (100%)
 rename crates/{shared => configs}/src/fee_factor.rs (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 5ade1df648..e7bfe364da 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2370,9 +2370,18 @@ dependencies = [
 name = "configs"
 version = "0.1.0"
 dependencies = [
+ "alloy",
+ "anyhow",
+ "chrono",
+ "humantime-serde",
+ "price-estimation",
+ "s3",
  "serde",
  "serde_json",
+ "tempfile",
  "thiserror 1.0.69",
+ "tokio",
+ "toml",
  "tracing",
  "url",
 ]
@@ -6747,6 +6756,7 @@ dependencies = [
  "chain",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "dashmap",
diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 911cb63350..4d4ef0ff5c 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -283,7 +283,6 @@ impl Ranking {
 mod tests {
     use {
         crate::{
-            config::solver::Account,
             domain::{
                 Auction,
                 Order,
@@ -298,6 +297,7 @@ mod tests {
             infra::Driver,
         },
         alloy::primitives::{Address, U160, U256, address},
+        configs::autopilot::solver::Account,
         hex_literal::hex,
         number::serialization::HexOrDecimalU256,
         serde::Deserialize,
diff --git a/crates/autopilot/src/domain/fee/mod.rs b/crates/autopilot/src/domain/fee/mod.rs
index 6d38c6c2f6..8979f1d46b 100644
--- a/crates/autopilot/src/domain/fee/mod.rs
+++ b/crates/autopilot/src/domain/fee/mod.rs
@@ -9,18 +9,21 @@ mod policy;
 use {
     crate::{
         boundary::{self},
-        config::fee_policy::{
+        domain::{self, eth},
+    },
+    alloy::primitives::{Address, U256},
+    chrono::{DateTime, Utc},
+    configs::{
+        autopilot::fee_policy::{
             FeePoliciesConfig,
             FeePolicy,
             FeePolicyOrderClass,
             UpcomingFeePolicies,
         },
-        domain::{self, eth},
+        fee_factor::FeeFactor,
     },
-    alloy::primitives::{Address, U256},
-    chrono::{DateTime, Utc},
     rust_decimal::Decimal,
-    shared::{arguments::TokenBucketFeeOverride, fee::VolumeFeePolicy, fee_factor::FeeFactor},
+    shared::{arguments::TokenBucketFeeOverride, fee::VolumeFeePolicy},
     std::collections::HashSet,
 };
 
@@ -61,8 +64,8 @@ pub struct UpcomingProtocolFees {
     effective_from_timestamp: DateTime<Utc>,
 }
 
-impl From<UpcomingFeePolicies> for Option<UpcomingProtocolFees> {
-    fn from(value: UpcomingFeePolicies) -> Self {
+impl UpcomingProtocolFees {
+    fn from_config(value: UpcomingFeePolicies) -> Option<Self> {
         value
             // both config fields must be non-empty
             .effective_from_timestamp
@@ -106,7 +109,9 @@ impl ProtocolFees {
                 .map(ProtocolFee::from)
                 .collect(),
             max_partner_fee: config.max_partner_fee,
-            upcoming_fee_policies: config.upcoming_policies.clone().into(),
+            upcoming_fee_policies: UpcomingProtocolFees::from_config(
+                config.upcoming_policies.clone(),
+            ),
             volume_fee_policy,
         }
     }
diff --git a/crates/autopilot/src/domain/fee/policy.rs b/crates/autopilot/src/domain/fee/policy.rs
index 8902fc7fb9..f95feddf8d 100644
--- a/crates/autopilot/src/domain/fee/policy.rs
+++ b/crates/autopilot/src/domain/fee/policy.rs
@@ -1,10 +1,10 @@
 use {
     crate::{
         boundary,
-        config::fee_policy::FeePolicyKind,
         domain::{self, fee::Quote},
     },
-    shared::{fee::VolumeFeePolicy, fee_factor::FeeFactor},
+    configs::{autopilot::fee_policy::FeePolicyKind, fee_factor::FeeFactor},
+    shared::fee::VolumeFeePolicy,
 };
 
 pub enum Policy {
diff --git a/crates/autopilot/src/infra/persistence/dto/order.rs b/crates/autopilot/src/infra/persistence/dto/order.rs
index 6c0e3d6bbb..04013049f2 100644
--- a/crates/autopilot/src/infra/persistence/dto/order.rs
+++ b/crates/autopilot/src/infra/persistence/dto/order.rs
@@ -5,10 +5,10 @@ use {
     },
     alloy::primitives::{Address, U256},
     app_data::AppDataHash,
+    configs::fee_factor::FeeFactor,
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
-    shared::fee_factor::FeeFactor,
 };
 
 #[serde_as]
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index e5dd00263a..bd4f3c609a 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -1,8 +1,9 @@
 use {
     self::dto::{reveal, settle, solve},
-    crate::{config::solver::Account, domain::eth, util},
+    crate::{domain::eth, util},
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
+    configs::autopilot::solver::Account,
     observe::tracing::{distributed::headers::tracing_headers, lazy::Lazy},
     reqwest::{Client, RequestBuilder, StatusCode},
     std::{borrow::Cow, time::Duration},
diff --git a/crates/autopilot/src/lib.rs b/crates/autopilot/src/lib.rs
index d4da505be8..a7742f2cb0 100644
--- a/crates/autopilot/src/lib.rs
+++ b/crates/autopilot/src/lib.rs
@@ -1,6 +1,5 @@
 pub mod arguments;
 pub mod boundary;
-pub mod config;
 pub mod database;
 pub mod domain;
 pub mod event_updater;
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 00e84586b5..b460eeda61 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -2,7 +2,6 @@ use {
     crate::{
         arguments::CliArguments,
         boundary,
-        config::{Configuration, solver::Account},
         database::{
             Postgres,
             ethflow_events::event_retriever::EthFlowRefundRetriever,
@@ -30,6 +29,7 @@ use {
     bad_tokens::list_based::DenyListedTokens,
     chain::Chain,
     clap::Parser,
+    configs::autopilot::{Configuration, solver::Account},
     contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
     ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
     event_indexing::block_retriever::BlockRetriever,
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index a0651475f4..4ad635a9f8 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -68,8 +68,8 @@ pub struct Config {
     pub compress_solve_request: bool,
 }
 
-impl From<crate::config::run_loop::RunLoopConfig> for Config {
-    fn from(value: crate::config::run_loop::RunLoopConfig) -> Self {
+impl From<configs::autopilot::run_loop::RunLoopConfig> for Config {
+    fn from(value: configs::autopilot::run_loop::RunLoopConfig) -> Self {
         Self {
             submission_deadline: value.submission_deadline,
             max_settlement_transaction_wait: value.max_settlement_transaction_wait,
diff --git a/crates/configs/Cargo.toml b/crates/configs/Cargo.toml
index 85f959e725..d2766149c9 100644
--- a/crates/configs/Cargo.toml
+++ b/crates/configs/Cargo.toml
@@ -4,16 +4,27 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+alloy = { workspace = true, features = ["signer-aws"] }
+anyhow = { workspace = true }
+chrono = { workspace = true }
+humantime-serde = { workspace = true }
+price-estimation = { workspace = true }
+s3 = { workspace = true }
 serde = { workspace = true }
+tempfile = { workspace = true, optional = true }
 thiserror = { workspace = true }
+tokio = { workspace = true }
+toml = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 
 [dev-dependencies]
+price-estimation = { workspace = true, features = ["test-util"] }
 serde_json = { workspace = true }
+tempfile = { workspace = true }
 
 [features]
-test-util = []
+test-util = ["dep:tempfile", "price-estimation/test-util"]
 
 [lints]
 workspace = true
diff --git a/crates/autopilot/src/config/banned_users.rs b/crates/configs/src/autopilot/banned_users.rs
similarity index 100%
rename from crates/autopilot/src/config/banned_users.rs
rename to crates/configs/src/autopilot/banned_users.rs
diff --git a/crates/autopilot/src/config/cow_amm.rs b/crates/configs/src/autopilot/cow_amm.rs
similarity index 90%
rename from crates/autopilot/src/config/cow_amm.rs
rename to crates/configs/src/autopilot/cow_amm.rs
index 11da3cfd1d..89ec357bd1 100644
--- a/crates/autopilot/src/config/cow_amm.rs
+++ b/crates/configs/src/autopilot/cow_amm.rs
@@ -1,12 +1,8 @@
-use {
-    alloy::primitives::Address,
-    serde::{Deserialize, Serialize},
-    url::Url,
-};
+use {alloy::primitives::Address, serde::Deserialize, url::Url};
 
 /// Configuration for indexing CoW AMMs.
 #[derive(Debug, Clone, Default, Deserialize)]
-#[cfg_attr(any(test, feature = "test-util"), derive(Serialize))]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct CowAmmGroupConfig {
     /// List of CoW AMM factory/helper/start-block configurations.
@@ -20,7 +16,7 @@ pub struct CowAmmGroupConfig {
 
 /// A single CoW AMM factory configuration.
 #[derive(Debug, Clone, Deserialize)]
-#[cfg_attr(any(test, feature = "test-util"), derive(Serialize))]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct CowAmmConfig {
     /// Contract address emitting CoW AMM deployment events.
diff --git a/crates/autopilot/src/config/ethflow.rs b/crates/configs/src/autopilot/ethflow.rs
similarity index 96%
rename from crates/autopilot/src/config/ethflow.rs
rename to crates/configs/src/autopilot/ethflow.rs
index 9f442caebf..f8b8f50364 100644
--- a/crates/autopilot/src/config/ethflow.rs
+++ b/crates/configs/src/autopilot/ethflow.rs
@@ -21,7 +21,7 @@ pub struct EthflowConfig {
 }
 
 #[cfg(any(test, feature = "test-util"))]
-impl configs::test_util::TestDefault for EthflowConfig {
+impl crate::test_util::TestDefault for EthflowConfig {
     fn test_default() -> Self {
         Self {
             skip_event_sync: true,
diff --git a/crates/autopilot/src/config/fee_policy.rs b/crates/configs/src/autopilot/fee_policy.rs
similarity index 99%
rename from crates/autopilot/src/config/fee_policy.rs
rename to crates/configs/src/autopilot/fee_policy.rs
index 5597f4ba07..7797b4be1f 100644
--- a/crates/autopilot/src/config/fee_policy.rs
+++ b/crates/configs/src/autopilot/fee_policy.rs
@@ -1,7 +1,7 @@
 use {
+    crate::fee_factor::FeeFactor,
     chrono::{DateTime, Utc},
     serde::{Deserialize, Serialize},
-    shared::fee_factor::FeeFactor,
 };
 
 pub const fn default_max_partner_fee() -> FeeFactor {
diff --git a/crates/autopilot/src/config/mod.rs b/crates/configs/src/autopilot/mod.rs
similarity index 96%
rename from crates/autopilot/src/config/mod.rs
rename to crates/configs/src/autopilot/mod.rs
index 368957e9f6..cf512fc293 100644
--- a/crates/autopilot/src/config/mod.rs
+++ b/crates/configs/src/autopilot/mod.rs
@@ -1,19 +1,21 @@
 use {
-    crate::config::{
-        banned_users::BannedUsersConfig,
-        cow_amm::CowAmmGroupConfig,
-        ethflow::EthflowConfig,
-        fee_policy::FeePoliciesConfig,
-        native_price::NativePriceConfig,
-        order_events_cleanup::OrderEventsCleanupConfig,
-        run_loop::RunLoopConfig,
-        s3::S3Config,
-        solver::Solver,
-        trusted_tokens::TrustedTokensConfig,
+    crate::{
+        autopilot::{
+            banned_users::BannedUsersConfig,
+            cow_amm::CowAmmGroupConfig,
+            ethflow::EthflowConfig,
+            fee_policy::FeePoliciesConfig,
+            native_price::NativePriceConfig,
+            order_events_cleanup::OrderEventsCleanupConfig,
+            run_loop::RunLoopConfig,
+            s3::S3Config,
+            solver::Solver,
+            trusted_tokens::TrustedTokensConfig,
+        },
+        database::DatabasePoolConfig,
     },
     alloy::primitives::Address,
     anyhow::{anyhow, ensure},
-    configs::database::DatabasePoolConfig,
     serde::Deserialize,
     std::{net::SocketAddr, path::Path, time::Duration},
     url::Url,
@@ -180,7 +182,7 @@ impl Configuration {
     /// It is rather useful for tests where drivers are setup separately or not
     /// actually used (like the `order_cancellation` test).
     pub fn test_no_drivers() -> Self {
-        use configs::test_util::TestDefault;
+        use crate::test_util::TestDefault;
 
         Self {
             drivers: vec![],
@@ -207,7 +209,7 @@ impl Configuration {
     }
 
     pub fn test(name: &str, solver_address: alloy::primitives::Address) -> Self {
-        use configs::test_util::TestDefault;
+        use crate::test_util::TestDefault;
 
         Self {
             drivers: vec![Solver::test(name, solver_address)],
@@ -259,7 +261,7 @@ impl Configuration {
 mod tests {
     use {
         super::*,
-        crate::config::{
+        crate::autopilot::{
             fee_policy::{FeePolicy, FeePolicyKind, FeePolicyOrderClass, UpcomingFeePolicies},
             solver::Account,
         },
diff --git a/crates/autopilot/src/config/native_price.rs b/crates/configs/src/autopilot/native_price.rs
similarity index 100%
rename from crates/autopilot/src/config/native_price.rs
rename to crates/configs/src/autopilot/native_price.rs
diff --git a/crates/autopilot/src/config/order_events_cleanup.rs b/crates/configs/src/autopilot/order_events_cleanup.rs
similarity index 100%
rename from crates/autopilot/src/config/order_events_cleanup.rs
rename to crates/configs/src/autopilot/order_events_cleanup.rs
diff --git a/crates/autopilot/src/config/run_loop.rs b/crates/configs/src/autopilot/run_loop.rs
similarity index 98%
rename from crates/autopilot/src/config/run_loop.rs
rename to crates/configs/src/autopilot/run_loop.rs
index da9183a378..3c66569b2e 100644
--- a/crates/autopilot/src/config/run_loop.rs
+++ b/crates/configs/src/autopilot/run_loop.rs
@@ -90,7 +90,7 @@ impl Default for RunLoopConfig {
 }
 
 #[cfg(any(test, feature = "test-util"))]
-impl configs::test_util::TestDefault for RunLoopConfig {
+impl crate::test_util::TestDefault for RunLoopConfig {
     fn test_default() -> Self {
         Self {
             max_delay: Duration::from_millis(100),
diff --git a/crates/autopilot/src/config/s3.rs b/crates/configs/src/autopilot/s3.rs
similarity index 100%
rename from crates/autopilot/src/config/s3.rs
rename to crates/configs/src/autopilot/s3.rs
diff --git a/crates/autopilot/src/config/solver.rs b/crates/configs/src/autopilot/solver.rs
similarity index 100%
rename from crates/autopilot/src/config/solver.rs
rename to crates/configs/src/autopilot/solver.rs
diff --git a/crates/autopilot/src/config/trusted_tokens.rs b/crates/configs/src/autopilot/trusted_tokens.rs
similarity index 100%
rename from crates/autopilot/src/config/trusted_tokens.rs
rename to crates/configs/src/autopilot/trusted_tokens.rs
diff --git a/crates/configs/src/database.rs b/crates/configs/src/database.rs
index 424125c3cf..c5f5882cf4 100644
--- a/crates/configs/src/database.rs
+++ b/crates/configs/src/database.rs
@@ -21,7 +21,7 @@ const fn default_insert_batch_size() -> NonZeroUsize {
 }
 
 #[derive(serde::Deserialize)]
-#[cfg_attr(feature = "test-util", derive(serde::Serialize))]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct DatabasePoolConfig {
     /// Url of the Postgres database. By default connects to `postgresql://`.
diff --git a/crates/shared/src/fee_factor.rs b/crates/configs/src/fee_factor.rs
similarity index 100%
rename from crates/shared/src/fee_factor.rs
rename to crates/configs/src/fee_factor.rs
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index 5679dfea89..885deeb015 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -1,5 +1,7 @@
+pub mod autopilot;
 pub mod database;
 pub(crate) mod deserialize_env;
+pub mod fee_factor;
 
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 8a1bdbd033..8df7254bc1 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -15,17 +15,17 @@ use {
         providers::ext::AnvilApi,
     },
     app_data::{AppDataDocument, AppDataHash},
-    autopilot::{
-        config::{
+    autopilot::infra::persistence::dto,
+    clap::Parser,
+    configs::{
+        autopilot::{
             Configuration,
             ethflow::EthflowConfig,
             native_price::NativePriceConfig,
             run_loop::RunLoopConfig,
         },
-        infra::persistence::dto,
+        test_util::TestDefault,
     },
-    clap::Parser,
-    configs::test_util::TestDefault,
     ethrpc::Web3,
     model::{
         AuctionId,
@@ -186,7 +186,7 @@ impl<'a> Services<'a> {
         &self,
         solve_deadline: Option<Duration>,
         extra_args: Vec<String>,
-        config: autopilot::config::Configuration,
+        config: configs::autopilot::Configuration,
         control: autopilot::shutdown_controller::ShutdownController,
     ) -> JoinHandle<()> {
         let solve_deadline = solve_deadline.unwrap_or(Duration::from_secs(2));
@@ -197,7 +197,7 @@ impl<'a> Services<'a> {
             .map(|c| *c.address())
             .collect::<Vec<_>>();
 
-        let config = autopilot::config::Configuration {
+        let config = configs::autopilot::Configuration {
             ethflow: EthflowConfig {
                 contracts: ethflow_contracts,
                 ..config.ethflow
@@ -237,7 +237,7 @@ impl<'a> Services<'a> {
         &self,
         solve_deadline: Option<Duration>,
         extra_args: Vec<String>,
-        config: autopilot::config::Configuration,
+        config: configs::autopilot::Configuration,
     ) -> JoinHandle<()> {
         self.start_autopilot_with_shutdown_controller(
             solve_deadline,
@@ -279,7 +279,7 @@ impl<'a> Services<'a> {
     pub async fn start_protocol(&self, solver: TestAccount) {
         self.start_protocol_with_args(
             Default::default(),
-            autopilot::config::Configuration::test("test_solver", solver.address()),
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
             orderbook::config::Configuration::test_default(),
             solver,
         )
@@ -289,7 +289,7 @@ impl<'a> Services<'a> {
     pub async fn start_protocol_with_args(
         &self,
         args: ExtraServiceArgs,
-        autopilot_config: autopilot::config::Configuration,
+        autopilot_config: configs::autopilot::Configuration,
         orderbook_config: orderbook::config::Configuration,
         solver: TestAccount,
     ) {
@@ -306,7 +306,7 @@ impl<'a> Services<'a> {
     pub async fn start_protocol_with_args_and_haircut(
         &self,
         args: ExtraServiceArgs,
-        autopilot_config: autopilot::config::Configuration,
+        autopilot_config: configs::autopilot::Configuration,
         orderbook_config: orderbook::config::Configuration,
         solver: TestAccount,
         haircut_bps: u32,
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 98c09858c3..7b18db5ff8 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -1,9 +1,9 @@
 use {
-    autopilot::{
-        config::{Configuration, run_loop::RunLoopConfig},
-        shutdown_controller::ShutdownController,
+    autopilot::shutdown_controller::ShutdownController,
+    configs::{
+        autopilot::{Configuration, run_loop::RunLoopConfig},
+        test_util::TestDefault,
     },
-    configs::test_util::TestDefault,
     e2e::setup::{
         OnchainComponents,
         Services,
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 5dbf4e3504..81587938e5 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,7 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::trusted_tokens::TrustedTokensConfig,
-    configs::test_util::TestDefault,
+    configs::{autopilot::trusted_tokens::TrustedTokensConfig, test_util::TestDefault},
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -69,7 +68,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            autopilot::config::Configuration {
+            configs::autopilot::Configuration {
                 trusted_tokens: TrustedTokensConfig {
                     tokens: vec![
                         *onchain.contracts().weth.address(),
@@ -78,7 +77,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
                     ],
                     ..Default::default()
                 },
-                ..autopilot::config::Configuration::test("test_solver", solver.address())
+                ..configs::autopilot::Configuration::test("test_solver", solver.address())
             },
         )
         .await;
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index b750748832..0d27cf7ffb 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -6,8 +6,10 @@ use {
             ext::{AnvilApi, ImpersonateConfig},
         },
     },
-    autopilot::config::{Configuration, solver::Solver},
-    configs::test_util::TestDefault,
+    configs::{
+        autopilot::{Configuration, solver::Solver},
+        test_util::TestDefault,
+    },
     contracts::alloy::{
         ERC20,
         support::{Balances, Signatures},
@@ -571,8 +573,8 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
                     Solver::test("test_solver", solver.address()),
                     Solver::test("mock_solver", solver.address()),
                 ],
-                cow_amm: autopilot::config::cow_amm::CowAmmGroupConfig {
-                    contracts: vec![autopilot::config::cow_amm::CowAmmConfig {
+                cow_amm: configs::autopilot::cow_amm::CowAmmGroupConfig {
+                    contracts: vec![configs::autopilot::cow_amm::CowAmmConfig {
                         factory: address!("f76c421bAb7df8548604E60deCCcE50477C10462"),
                         helper: address!("3FF0041A614A9E6Bf392cbB961C97DA214E9CB31"),
                         index_start: 20476672,
diff --git a/crates/e2e/tests/e2e/debug_order.rs b/crates/e2e/tests/e2e/debug_order.rs
index a666449ee9..d6090db3e5 100644
--- a/crates/e2e/tests/e2e/debug_order.rs
+++ b/crates/e2e/tests/e2e/debug_order.rs
@@ -49,7 +49,7 @@ async fn debug_order(web3: Web3) {
     services
         .start_protocol_with_args(
             ExtraServiceArgs::default(),
-            autopilot::config::Configuration::test("test_solver", solver.address()),
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
             orderbook::config::Configuration::test_default(),
             solver,
         )
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index 101224c110..aa21e1c392 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -1,7 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::Configuration,
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     e2e::setup::{colocation::SolverEngine, mock::Mock, solution::JitOrder, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index e99da742b6..134be0b253 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -4,14 +4,16 @@ use {
         primitives::{Address, U256, address},
         providers::ext::{AnvilApi, ImpersonateConfig},
     },
-    autopilot::config::{
-        Configuration,
-        fee_policy::{FeePoliciesConfig, FeePolicy, FeePolicyKind},
-        run_loop::RunLoopConfig,
-        solver::{Account, Solver},
-    },
     bigdecimal::BigDecimal,
-    configs::test_util::TestDefault,
+    configs::{
+        autopilot::{
+            Configuration,
+            fee_policy::{FeePoliciesConfig, FeePolicy, FeePolicyKind},
+            run_loop::RunLoopConfig,
+            solver::{Account, Solver},
+        },
+        test_util::TestDefault,
+    },
     contracts::alloy::ERC20,
     database::byte_array::ByteArray,
     driver::domain::eth::NonZeroU256,
@@ -1184,14 +1186,15 @@ async fn no_liquidity_limit_order(web3: Web3) {
                                 factor: 0.5.try_into().unwrap(),
                                 max_volume_factor: 0.01.try_into().unwrap(),
                             },
-                            order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Limit,
+                            order_class: configs::autopilot::fee_policy::FeePolicyOrderClass::Limit,
                         },
                         FeePolicy {
                             kind: FeePolicyKind::PriceImprovement {
                                 factor: 0.5.try_into().unwrap(),
                                 max_volume_factor: 0.01.try_into().unwrap(),
                             },
-                            order_class: autopilot::config::fee_policy::FeePolicyOrderClass::Market,
+                            order_class:
+                                configs::autopilot::fee_policy::FeePolicyOrderClass::Market,
                         },
                     ],
                     ..Default::default()
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 06a37bc693..2cd9ca6e3a 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -6,9 +6,8 @@ use {
             ext::{AnvilApi, ImpersonateConfig},
         },
     },
-    autopilot::config::Configuration,
     chrono::{NaiveDateTime, Utc},
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     contracts::alloy::{ERC20, IZeroex},
     e2e::{
         api::zeroex::{Eip712TypedZeroExOrder, ZeroExApi},
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index fb3f8c2eaf..59099210fa 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -4,9 +4,8 @@ use {
         providers::ext::{AnvilApi, ImpersonateConfig},
         signers::SignerSync,
     },
-    autopilot::config::Configuration,
     chrono::Utc,
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     contracts::alloy::{ERC20, LiquoriceSettlement},
     driver::infra,
     e2e::{
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index 7275094760..b9ffeb588e 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -1,7 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::config::Configuration,
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     database::order_events::OrderEventLabel,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 82cfb002e2..8c7e0632fe 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -1,7 +1,7 @@
 use {
     ::alloy::primitives::U256,
-    autopilot::{config::Configuration, shutdown_controller::ShutdownController},
-    configs::test_util::TestDefault,
+    autopilot::shutdown_controller::ShutdownController,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     driver::domain::eth::NonZeroU256,
     e2e::setup::{colocation, wait_for_condition, *},
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index fd1690c788..3e21376633 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -1,17 +1,20 @@
 use {
     ::alloy::primitives::{Address, U256},
-    autopilot::config::{
-        Configuration,
-        fee_policy::{
-            FeePoliciesConfig,
-            FeePolicy as ConfigFeePolicy,
-            FeePolicyKind as ConfigFeePolicyKind,
-            FeePolicyOrderClass as ConfigFeePolicyOrderClass,
-            UpcomingFeePolicies,
+    configs::{
+        autopilot::{
+            Configuration,
+            fee_policy::{
+                FeePoliciesConfig,
+                FeePolicy as ConfigFeePolicy,
+                FeePolicyKind as ConfigFeePolicyKind,
+                FeePolicyOrderClass as ConfigFeePolicyOrderClass,
+                UpcomingFeePolicies,
+            },
+            solver::Solver,
         },
-        solver::Solver,
+        fee_factor::FeeFactor,
+        test_util::TestDefault,
     },
-    configs::test_util::TestDefault,
     driver::domain::eth::NonZeroU256,
     e2e::{assert_approximately_eq, setup::*},
     ethrpc::alloy::CallBuilderExt,
@@ -31,7 +34,7 @@ use {
     number::units::EthUnit,
     reqwest::StatusCode,
     serde_json::json,
-    shared::{fee_factor::FeeFactor, web3::Web3},
+    shared::web3::Web3,
 };
 
 #[tokio::test]
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 4dd8954421..bf8b4d6ad9 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -3,10 +3,9 @@ use {
         primitives::{Address, U256, address, map::AddressMap},
         providers::Provider,
     },
-    autopilot::config::Configuration,
     balance_overrides::{BalanceOverrides, BalanceOverriding, Strategy},
     bigdecimal::{BigDecimal, Zero},
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     e2e::setup::*,
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::{
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 7f9e0eb6d0..9760b74fe7 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -1,6 +1,5 @@
 use {
-    autopilot::config::Configuration,
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, fee_factor::FeeFactor, test_util::TestDefault},
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     futures::FutureExt,
@@ -11,7 +10,7 @@ use {
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
     serde_json::json,
-    shared::{fee_factor::FeeFactor, web3::Web3},
+    shared::web3::Web3,
     std::{
         sync::Arc,
         time::{Duration, Instant},
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index 9c0672a64f..ea1e2213c4 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -477,7 +477,7 @@ async fn single_replace_order_test(web3: Web3) {
                 api: vec!["--quote-verification=prefer".into()],
                 ..Default::default()
             },
-            autopilot::config::Configuration::test("test_solver", solver.address()),
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
             orderbook::config::Configuration::test_default(),
             solver.clone(),
         )
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 820bd68240..8fedb26ca0 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -178,7 +178,7 @@ async fn erc1271_gas_limit(web3: Web3) {
     services
         .start_protocol_with_args(
             Default::default(),
-            autopilot::config::Configuration::test("test_solver", solver.address()),
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
             orderbook::config::Configuration {
                 order_validation: OrderValidationConfig {
                     max_gas_per_order: 1_000_000,
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 2f0913a655..38c681fdc8 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -1,11 +1,13 @@
 use {
     ::alloy::primitives::{U256, address},
-    autopilot::config::{
-        Configuration,
-        run_loop::RunLoopConfig,
-        solver::{Account, Solver},
+    configs::{
+        autopilot::{
+            Configuration,
+            run_loop::RunLoopConfig,
+            solver::{Account, Solver},
+        },
+        test_util::TestDefault,
     },
-    configs::test_util::TestDefault,
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 0bc39abc7b..75fb1b2d06 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -7,8 +7,7 @@ use {
             types::{Transaction, TransactionReceipt},
         },
     },
-    autopilot::config::Configuration,
-    configs::test_util::TestDefault,
+    configs::{autopilot::Configuration, test_util::TestDefault},
     e2e::setup::*,
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     futures::StreamExt,
diff --git a/crates/orderbook/src/config/mod.rs b/crates/orderbook/src/config/mod.rs
index 3a438dc29d..19162cc160 100644
--- a/crates/orderbook/src/config/mod.rs
+++ b/crates/orderbook/src/config/mod.rs
@@ -8,9 +8,8 @@ use {
     alloy::primitives::Address,
     anyhow::anyhow,
     chrono::{DateTime, Utc},
-    configs::database::DatabasePoolConfig,
+    configs::{database::DatabasePoolConfig, fee_factor::FeeFactor},
     serde::{Deserialize, Serialize},
-    shared::fee_factor::FeeFactor,
     std::path::Path,
 };
 
diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs
index 2e225d1651..4d7b8eee5b 100644
--- a/crates/orderbook/src/quoter.rs
+++ b/crates/orderbook/src/quoter.rs
@@ -3,6 +3,7 @@ use {
     alloy::primitives::{U256, U512, Uint, ruint::UintTryFrom},
     bigdecimal::{BigDecimal, FromPrimitive},
     chrono::{TimeZone, Utc},
+    configs::fee_factor::FeeFactor,
     model::{
         order::OrderCreationAppData,
         quote::{OrderQuote, OrderQuoteRequest, OrderQuoteResponse, OrderQuoteSide, PriceQuality},
@@ -11,7 +12,6 @@ use {
     shared::{
         arguments::TokenBucketFeeOverride,
         fee::VolumeFeePolicy,
-        fee_factor::FeeFactor,
         order_quoting::{CalculateQuoteError, OrderQuoting, Quote, QuoteParameters},
         order_validation::{
             AppDataValidationError,
@@ -305,11 +305,11 @@ mod tests {
     use {
         super::*,
         alloy::primitives::U256,
+        configs::fee_factor::FeeFactor,
         model::quote::OrderQuoteSide,
         number::units::EthUnit,
         shared::{
             fee::VolumeFeePolicy,
-            fee_factor::FeeFactor,
             order_quoting::{Quote, QuoteData},
         },
     };
diff --git a/crates/shared/Cargo.toml b/crates/shared/Cargo.toml
index 258f1237c8..ab8b09f759 100644
--- a/crates/shared/Cargo.toml
+++ b/crates/shared/Cargo.toml
@@ -23,6 +23,7 @@ cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, features = ["clock"] }
 clap = { workspace = true }
+configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 dashmap = { workspace = true }
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index bc572447e8..3c280cdad8 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -2,9 +2,9 @@
 //! the binaries.
 
 use {
-    crate::fee_factor::FeeFactor,
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
+    configs::fee_factor::FeeFactor,
     gas_price_estimation::GasEstimatorType,
     observe::TracingConfig,
     std::{
diff --git a/crates/shared/src/fee.rs b/crates/shared/src/fee.rs
index dbbf67e734..9160d2d4ce 100644
--- a/crates/shared/src/fee.rs
+++ b/crates/shared/src/fee.rs
@@ -1,6 +1,7 @@
 use {
-    crate::{arguments::TokenBucketFeeOverride, fee_factor::FeeFactor},
+    crate::arguments::TokenBucketFeeOverride,
     alloy::primitives::{Address, U256},
+    configs::fee_factor::FeeFactor,
 };
 
 /// Everything required to compute the fee amount in sell token
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 97631bb594..4bbeb6f3ec 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -8,7 +8,6 @@ pub mod encoded_settlement;
 pub mod event_storing_helpers;
 pub mod external_prices;
 pub mod fee;
-pub mod fee_factor;
 pub mod http_client;
 pub mod http_solver;
 pub mod interaction;

From b7643dd1c67e40d1b6a6e057015e93b857d0e514 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 11 Mar 2026 11:19:30 +0000
Subject: [PATCH 139/219] BitGet solver (#4249)

This effectively replicates https://github.com/gnosis/solvers/pull/203

# Summary
- Add a new solver that integrates with the
https://web3.bitget.com/en/docs/swap/ API to find swap routes, following
existing patterns
- ~~The Bitget API uses a two-step POST flow: `quote` (to get the
optimal routing market and output amount) followed by `swap` (to get the
on-chain calldata)~~ The BitGet team suggested using the
`request_mod="rich"` param in the `/swap` API, which makes the response
contain much more data, including the `outAmount`.
- ~~To mitigate the race condition between `quote` and `swap` calls,
slippage is applied to the quoted output and passed as `toMinAmount` to
the swap endpoint, ensuring consistency between what the calldata
enforces on-chain and what the solver reports~~ Not needed anymore
because of the previous point
- Only sell orders are supported - the Bitget API has no `exactOut` mode

# Changes

- Bitget API client and DTOs with HMAC-SHA256 request signing, base64
calldata decoding, typed ChainName enum, and serialize::U256 for amount
fields
- TOML config loading (endpoint, chain-id, api-key, api-secret)
- E2E tests: market sell order, buy order rejection, insufficient
liquidity, and out-of-price limit order
- `config/example.bitget.toml` - Example configuration

# How to test
New unit and manual e2e tests (ignored by default).
---
 crates/solvers/config/example.bitget.toml     |  19 ++
 crates/solvers/src/infra/cli.rs               |   5 +
 .../src/infra/config/dex/bitget/file.rs       |  78 +++++
 .../src/infra/config/dex/bitget/mod.rs        |   6 +
 crates/solvers/src/infra/config/dex/mod.rs    |   1 +
 crates/solvers/src/infra/dex/bitget/dto.rs    | 159 ++++++++++
 crates/solvers/src/infra/dex/bitget/mod.rs    | 299 ++++++++++++++++++
 crates/solvers/src/infra/dex/mod.rs           |  17 +-
 crates/solvers/src/run.rs                     |  10 +
 crates/solvers/src/tests/bitget/api_calls.rs  | 100 ++++++
 .../solvers/src/tests/bitget/market_order.rs  | 217 +++++++++++++
 crates/solvers/src/tests/bitget/mod.rs        |  21 ++
 crates/solvers/src/tests/bitget/not_found.rs  |  78 +++++
 .../solvers/src/tests/bitget/out_of_price.rs  |  96 ++++++
 crates/solvers/src/tests/mod.rs               |   1 +
 15 files changed, 1106 insertions(+), 1 deletion(-)
 create mode 100644 crates/solvers/config/example.bitget.toml
 create mode 100644 crates/solvers/src/infra/config/dex/bitget/file.rs
 create mode 100644 crates/solvers/src/infra/config/dex/bitget/mod.rs
 create mode 100644 crates/solvers/src/infra/dex/bitget/dto.rs
 create mode 100644 crates/solvers/src/infra/dex/bitget/mod.rs
 create mode 100644 crates/solvers/src/tests/bitget/api_calls.rs
 create mode 100644 crates/solvers/src/tests/bitget/market_order.rs
 create mode 100644 crates/solvers/src/tests/bitget/mod.rs
 create mode 100644 crates/solvers/src/tests/bitget/not_found.rs
 create mode 100644 crates/solvers/src/tests/bitget/out_of_price.rs

diff --git a/crates/solvers/config/example.bitget.toml b/crates/solvers/config/example.bitget.toml
new file mode 100644
index 0000000000..3e400a0fd7
--- /dev/null
+++ b/crates/solvers/config/example.bitget.toml
@@ -0,0 +1,19 @@
+node-url = "http://localhost:8545"
+
+[dex]
+# Specify which chain to use, 1 for Ethereum.
+# Supported chains: eth (1), bsc (56), base (8453)
+chain-id = "1"
+
+# Optionally specify a custom Bitget swap API endpoint
+# endpoint = "https://bopenapi.bgwapi.io/bgw-pro/swapx/pro/"
+
+[dex.credentials]
+# Bitget API key (obtain from Bitget integration team)
+api-key = "$BITGET_API_KEY"
+
+# Bitget API secret for signing requests
+api-secret = "$BITGET_API_SECRET"
+
+# Partner code sent in the Partner-Code header (defaults to "cowswap")
+# partner-code = "cowswap"
diff --git a/crates/solvers/src/infra/cli.rs b/crates/solvers/src/infra/cli.rs
index 39efd1175a..e439cdc14e 100644
--- a/crates/solvers/src/infra/cli.rs
+++ b/crates/solvers/src/infra/cli.rs
@@ -48,4 +48,9 @@ pub enum Command {
         #[clap(long, env)]
         config: PathBuf,
     },
+    /// solve individual orders using Bitget API
+    Bitget {
+        #[clap(long, env)]
+        config: PathBuf,
+    },
 }
diff --git a/crates/solvers/src/infra/config/dex/bitget/file.rs b/crates/solvers/src/infra/config/dex/bitget/file.rs
new file mode 100644
index 0000000000..b60368122c
--- /dev/null
+++ b/crates/solvers/src/infra/config/dex/bitget/file.rs
@@ -0,0 +1,78 @@
+use {
+    crate::{
+        domain::eth,
+        infra::{config::dex::file, dex::bitget},
+    },
+    serde::Deserialize,
+    serde_with::serde_as,
+    std::path::Path,
+};
+
+#[serde_as]
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct Config {
+    /// The base URL for the Bitget swap API.
+    #[serde(default = "default_endpoint")]
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    endpoint: reqwest::Url,
+
+    /// Chain ID used to automatically determine contract addresses.
+    chain_id: eth::ChainId,
+
+    /// Bitget API credentials.
+    credentials: BitgetCredentialsConfig,
+
+    /// Partner code sent in the `Partner-Code` header.
+    #[serde(default = "default_partner_code")]
+    partner_code: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct BitgetCredentialsConfig {
+    /// Bitget API key.
+    api_key: String,
+
+    /// Bitget API secret for signing requests.
+    api_secret: String,
+}
+
+#[allow(clippy::from_over_into)]
+impl Into<bitget::BitgetCredentialsConfig> for BitgetCredentialsConfig {
+    fn into(self) -> bitget::BitgetCredentialsConfig {
+        bitget::BitgetCredentialsConfig {
+            api_key: self.api_key,
+            api_secret: self.api_secret,
+        }
+    }
+}
+
+fn default_partner_code() -> String {
+    "cowswap".to_string()
+}
+
+fn default_endpoint() -> reqwest::Url {
+    bitget::DEFAULT_ENDPOINT.parse().unwrap()
+}
+
+/// Load the Bitget solver configuration from a TOML file.
+///
+/// # Panics
+///
+/// This method panics if the config is invalid or on I/O errors.
+pub async fn load(path: &Path) -> super::Config {
+    let (base, config) = file::load::<Config>(path).await;
+
+    super::Config {
+        bitget: bitget::Config {
+            endpoint: config.endpoint,
+            chain_id: config.chain_id,
+            credentials: config.credentials.into(),
+            partner_code: config.partner_code,
+            block_stream: base.block_stream.clone(),
+            settlement_contract: base.contracts.settlement,
+        },
+        base,
+    }
+}
diff --git a/crates/solvers/src/infra/config/dex/bitget/mod.rs b/crates/solvers/src/infra/config/dex/bitget/mod.rs
new file mode 100644
index 0000000000..5d630fac91
--- /dev/null
+++ b/crates/solvers/src/infra/config/dex/bitget/mod.rs
@@ -0,0 +1,6 @@
+pub mod file;
+
+pub struct Config {
+    pub bitget: crate::infra::dex::bitget::Config,
+    pub base: super::Config,
+}
diff --git a/crates/solvers/src/infra/config/dex/mod.rs b/crates/solvers/src/infra/config/dex/mod.rs
index a51226eaeb..d8e619b9aa 100644
--- a/crates/solvers/src/infra/config/dex/mod.rs
+++ b/crates/solvers/src/infra/config/dex/mod.rs
@@ -1,3 +1,4 @@
+pub mod bitget;
 pub mod file;
 pub mod okx;
 
diff --git a/crates/solvers/src/infra/dex/bitget/dto.rs b/crates/solvers/src/infra/dex/bitget/dto.rs
new file mode 100644
index 0000000000..50d8c4f135
--- /dev/null
+++ b/crates/solvers/src/infra/dex/bitget/dto.rs
@@ -0,0 +1,159 @@
+//! DTOs for the Bitget swap API.
+//! Full documentation: https://web3.bitget.com/en/docs/swap/
+
+use {
+    crate::domain::{dex, eth},
+    bigdecimal::{BigDecimal, ToPrimitive},
+    serde::{Deserialize, Serialize},
+    serde_with::serde_as,
+};
+
+/// Bitget chain name used in API requests.
+#[derive(Clone, Copy, Serialize)]
+pub enum ChainName {
+    #[serde(rename = "eth")]
+    Mainnet,
+    #[serde(rename = "bsc")]
+    Bnb,
+    #[serde(rename = "base")]
+    Base,
+    #[serde(rename = "polygon")]
+    Polygon,
+    #[serde(rename = "arb")]
+    ArbitrumOne,
+}
+
+impl ChainName {
+    pub fn new(chain_id: eth::ChainId) -> Self {
+        match chain_id {
+            eth::ChainId::Mainnet => Self::Mainnet,
+            eth::ChainId::Bnb => Self::Bnb,
+            eth::ChainId::Base => Self::Base,
+            eth::ChainId::Polygon => Self::Polygon,
+            eth::ChainId::ArbitrumOne => Self::ArbitrumOne,
+            _ => panic!("unsupported Bitget chain: {chain_id:?}"),
+        }
+    }
+}
+
+/// A Bitget API swap request with enriched response (`requestMod = "rich"`).
+///
+/// See [API](https://web3.bitget.com/en/docs/swap/)
+/// documentation for more detailed information on each parameter.
+#[serde_as]
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapRequest {
+    /// Source token contract address.
+    pub from_contract: eth::Address,
+
+    /// Input amount in human-readable decimal units (e.g. "1" for 1 WETH).
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub from_amount: BigDecimal,
+
+    /// Source chain name.
+    pub from_chain: ChainName,
+
+    /// Target token contract address.
+    pub to_contract: eth::Address,
+
+    /// Target chain name.
+    pub to_chain: ChainName,
+
+    /// Debit address.
+    pub from_address: eth::Address,
+
+    /// Recipient address.
+    pub to_address: eth::Address,
+
+    /// Optimal channel - hardcoded to "bgwevmaggregator" for EVM chains.
+    pub market: String,
+
+    /// Slippage tolerance as a percentage (e.g. 1.0 for 1%).
+    pub slippage: f64,
+
+    /// Request mode - "rich" returns quote data alongside swap calldata.
+    pub request_mod: String,
+
+    /// Fee rate in per mille. 0 for no fee.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fee_rate: Option<f64>,
+}
+
+impl SwapRequest {
+    pub fn from_order(
+        order: &dex::Order,
+        chain_name: ChainName,
+        settlement_contract: eth::Address,
+        slippage: &dex::Slippage,
+        sell_decimals: u8,
+    ) -> Self {
+        Self {
+            from_contract: order.sell.0,
+            from_amount: super::wei_to_decimal(order.amount.get(), sell_decimals),
+            from_chain: chain_name,
+            to_contract: order.buy.0,
+            to_chain: chain_name,
+            from_address: settlement_contract,
+            to_address: settlement_contract,
+            // as per a suggestion by the BitGet team for the best routes on EVM chains
+            market: "bgwevmaggregator".to_string(),
+            slippage: slippage.as_factor().to_f64().unwrap_or_default() * 100.0,
+            request_mod: "rich".to_string(),
+            fee_rate: Some(0.0),
+        }
+    }
+}
+
+/// A Bitget API enriched swap response (returned when `requestMod = "rich"`).
+#[serde_as]
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct SwapResponse {
+    /// Output amount in decimal units.
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub out_amount: BigDecimal,
+
+    /// Gas fee information.
+    pub gas_fee: GasFee,
+
+    /// Transaction data for the swap.
+    pub swap_transaction: SwapTransaction,
+}
+
+#[serde_as]
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct GasFee {
+    #[serde_as(as = "serde_with::DisplayFromStr")]
+    pub gas_limit: u64,
+}
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct SwapTransaction {
+    /// Contract address (router/spender).
+    pub to: eth::Address,
+    /// Hex-encoded calldata with "0x" prefix.
+    pub data: String,
+}
+
+impl SwapTransaction {
+    /// Decode the hex-encoded calldata (with "0x" prefix) to bytes.
+    pub fn decode_calldata(&self) -> Result<Vec<u8>, hex::FromHexError> {
+        let hex_str = self.data.strip_prefix("0x").unwrap_or(&self.data);
+        hex::decode(hex_str)
+    }
+}
+
+/// A Bitget API response wrapper.
+///
+/// On success `status` is 0 and `data` contains the result.
+/// On error `status` is non-zero and `data` is null.
+#[derive(Deserialize, Clone, Debug)]
+pub struct Response<T> {
+    /// Response status code (0 = success).
+    pub status: i64,
+
+    /// Response data — `None` when the API returns an error.
+    pub data: Option<T>,
+}
diff --git a/crates/solvers/src/infra/dex/bitget/mod.rs b/crates/solvers/src/infra/dex/bitget/mod.rs
new file mode 100644
index 0000000000..cd16f6b065
--- /dev/null
+++ b/crates/solvers/src/infra/dex/bitget/mod.rs
@@ -0,0 +1,299 @@
+use {
+    crate::{
+        domain::{auction, dex, eth, order},
+        util,
+    },
+    alloy::primitives::{Address, U256},
+    base64::prelude::*,
+    bigdecimal::BigDecimal,
+    ethrpc::block_stream::CurrentBlockWatcher,
+    hmac::{Hmac, Mac},
+    sha2::Sha256,
+    std::{
+        collections::BTreeMap,
+        sync::atomic::{self, AtomicU64},
+    },
+    tracing::Instrument,
+};
+
+/// Convert a U256 wei amount to a decimal string using the token's decimals.
+/// e.g., 1000000000000000000 with 18 decimals → "1"
+fn wei_to_decimal(amount: U256, decimals: u8) -> BigDecimal {
+    BigDecimal::new(
+        util::conv::u256_to_biguint(&amount).into(),
+        i64::from(decimals),
+    )
+    .normalized()
+}
+
+/// Convert a decimal amount (from API response) to U256 wei.
+/// e.g., "1964.365496" with 6 decimals → 1964365496
+fn decimal_to_wei(amount: &BigDecimal, decimals: u8) -> Result<U256, Error> {
+    let scaled = amount * BigDecimal::new(1.into(), -i64::from(decimals));
+    util::conv::bigdecimal_to_u256(&scaled).ok_or(Error::AmountConversionFailed)
+}
+
+mod dto;
+
+/// Default Bitget swap API base endpoint.
+pub const DEFAULT_ENDPOINT: &str = "https://bopenapi.bgwapi.io/bgw-pro/swapx/pro/";
+
+/// Bitget API path for getting swap calldata.
+const SWAP_PATH: &str = "swap";
+
+/// Bindings to the Bitget swap API.
+pub struct Bitget {
+    client: super::Client,
+    endpoint: reqwest::Url,
+    api_key: String,
+    api_secret: String,
+    partner_code: String,
+    chain_name: dto::ChainName,
+    settlement_contract: Address,
+}
+
+pub struct Config {
+    /// The base URL for the Bitget swap API.
+    pub endpoint: reqwest::Url,
+
+    pub chain_id: eth::ChainId,
+
+    pub settlement_contract: Address,
+
+    /// Credentials used to access Bitget API.
+    pub credentials: BitgetCredentialsConfig,
+
+    /// Partner code sent in the `Partner-Code` header.
+    pub partner_code: String,
+
+    /// The stream that yields every new block.
+    pub block_stream: Option<CurrentBlockWatcher>,
+}
+
+pub struct BitgetCredentialsConfig {
+    /// Bitget API key.
+    pub api_key: String,
+
+    /// Bitget API secret for signing requests.
+    pub api_secret: String,
+}
+
+impl Bitget {
+    pub fn try_new(config: Config) -> Result<Self, CreationError> {
+        let client = {
+            let client = reqwest::Client::builder().build()?;
+            super::Client::new(client, config.block_stream)
+        };
+
+        let chain_name = dto::ChainName::new(config.chain_id);
+
+        Ok(Self {
+            client,
+            endpoint: config.endpoint,
+            api_key: config.credentials.api_key,
+            api_secret: config.credentials.api_secret,
+            partner_code: config.partner_code,
+            chain_name,
+            settlement_contract: config.settlement_contract,
+        })
+    }
+
+    pub async fn swap(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+        tokens: &auction::Tokens,
+    ) -> Result<dex::Swap, Error> {
+        // Bitget only supports sell orders (exactIn).
+        if order.side == order::Side::Buy {
+            return Err(Error::OrderNotSupported);
+        }
+
+        let sell_decimals = tokens
+            .get(&order.sell)
+            .and_then(|t| t.decimals)
+            .ok_or(Error::MissingDecimals)?;
+        let buy_decimals = tokens
+            .get(&order.buy)
+            .and_then(|t| t.decimals)
+            .ok_or(Error::MissingDecimals)?;
+
+        // Set up a tracing span to make debugging of API requests easier.
+        static ID: AtomicU64 = AtomicU64::new(0);
+        let id = ID.fetch_add(1, atomic::Ordering::Relaxed);
+
+        let response = self
+            .handle_sell_order(order, slippage, sell_decimals)
+            .instrument(tracing::trace_span!("swap", id = %id))
+            .await?;
+
+        let calldata = response
+            .swap_transaction
+            .decode_calldata()
+            .map_err(|_| Error::InvalidCalldata)?;
+
+        let contract = response.swap_transaction.to;
+
+        // Increase gas estimate by 50% for safety margin, similar to OKX.
+        let gas_limit = U256::from(response.gas_fee.gas_limit);
+        let gas = gas_limit
+            .checked_add(gas_limit / U256::from(2))
+            .ok_or(Error::GasCalculationFailed)?;
+
+        let output_amount = decimal_to_wei(&response.out_amount, buy_decimals)?;
+
+        Ok(dex::Swap {
+            calls: vec![dex::Call {
+                to: contract,
+                calldata,
+            }],
+            input: eth::Asset {
+                token: order.sell,
+                amount: order.amount.get(),
+            },
+            output: eth::Asset {
+                token: order.buy,
+                amount: output_amount,
+            },
+            allowance: dex::Allowance {
+                spender: contract,
+                amount: dex::Amount::new(order.amount.get()),
+            },
+            gas: eth::Gas(gas),
+        })
+    }
+
+    /// Handle sell orders with a single enriched swap API call.
+    ///
+    /// Uses `requestMod = "rich"` so the swap endpoint returns both quote
+    /// data (output amount, gas) and calldata in a single response,
+    /// eliminating the race condition window of the previous two-call flow.
+    async fn handle_sell_order(
+        &self,
+        order: &dex::Order,
+        slippage: &dex::Slippage,
+        sell_decimals: u8,
+    ) -> Result<dto::SwapResponse, Error> {
+        let swap_request = dto::SwapRequest::from_order(
+            order,
+            self.chain_name,
+            self.settlement_contract,
+            slippage,
+            sell_decimals,
+        );
+
+        self.send_post_request(SWAP_PATH, &swap_request).await
+    }
+
+    /// Generate HMAC-SHA256 signature for the Bitget API.
+    ///
+    /// The signature is computed over a JSON object with alphabetically sorted
+    /// keys containing: the API path, body, API key, and timestamp.
+    pub(crate) fn generate_signature(
+        &self,
+        api_path: &str,
+        body: &str,
+        timestamp: &str,
+    ) -> Result<String, Error> {
+        // Use `BTreeMap` for alphabetical ordering required by API (see <https://web3.bitget.com/en/docs/authentication/#signature-algorithm>).
+        let mut content = BTreeMap::new();
+        content.insert("apiPath", api_path);
+        content.insert("body", body);
+        content.insert("x-api-key", &self.api_key);
+        content.insert("x-api-timestamp", timestamp);
+
+        let content_str = serde_json::to_string(&content).map_err(|_| Error::SignRequestFailed)?;
+
+        let mut mac = Hmac::<Sha256>::new_from_slice(self.api_secret.as_bytes())
+            .map_err(|_| Error::SignRequestFailed)?;
+        mac.update(content_str.as_bytes());
+        let signature = mac.finalize().into_bytes();
+
+        Ok(BASE64_STANDARD.encode(signature))
+    }
+
+    /// Bitget error handling based on status codes.
+    fn handle_api_error(status: i64, body: String) -> Result<(), Error> {
+        Err(match status {
+            0 => return Ok(()),
+            429 => Error::RateLimited,
+            404 => Error::NotFound,
+            _ => Error::Api { status, body },
+        })
+    }
+
+    async fn send_post_request<T, U>(&self, endpoint: &str, body: &T) -> Result<U, Error>
+    where
+        T: serde::Serialize,
+        U: serde::de::DeserializeOwned,
+    {
+        let url = self
+            .endpoint
+            .join(endpoint)
+            .map_err(|_| Error::RequestBuildFailed)?;
+
+        let body_str = serde_json::to_string(body).map_err(|_| Error::RequestBuildFailed)?;
+        let timestamp = chrono::Utc::now().timestamp_millis().to_string();
+        let api_path = url.path();
+        let signature = self.generate_signature(api_path, &body_str, &timestamp)?;
+
+        let request_builder = self
+            .client
+            .request(reqwest::Method::POST, url.clone())
+            .header("Content-Type", "application/json")
+            .header("Partner-Code", &self.partner_code)
+            .header("x-api-key", &self.api_key)
+            .header("x-api-timestamp", &timestamp)
+            .header("x-api-signature", &signature)
+            .body(body_str);
+
+        let response = request_builder
+            .send()
+            .await
+            .map_err(util::http::Error::from)?;
+        let status = response.status();
+        let body = response.text().await.map_err(util::http::Error::from)?;
+
+        if !status.is_success() {
+            return Err(util::http::Error::Status(status, body).into());
+        }
+
+        let response: dto::Response<U> =
+            serde_json::from_str(&body).map_err(util::http::Error::from)?;
+
+        Self::handle_api_error(response.status, body)?;
+        response.data.ok_or(Error::NotFound)
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum CreationError {
+    #[error(transparent)]
+    Client(#[from] reqwest::Error),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("failed to build the request")]
+    RequestBuildFailed,
+    #[error("failed to sign the request")]
+    SignRequestFailed,
+    #[error("calculating output gas failed")]
+    GasCalculationFailed,
+    #[error("unable to find a quote")]
+    NotFound,
+    #[error("order type is not supported")]
+    OrderNotSupported,
+    #[error("rate limited")]
+    RateLimited,
+    #[error("invalid calldata in response")]
+    InvalidCalldata,
+    #[error("failed to convert amount between decimal and U256")]
+    AmountConversionFailed,
+    #[error("decimals are missing for the swapped tokens")]
+    MissingDecimals,
+    #[error("api error status {status}: {body}")]
+    Api { status: i64, body: String },
+    #[error(transparent)]
+    Http(#[from] util::http::Error),
+}
diff --git a/crates/solvers/src/infra/dex/mod.rs b/crates/solvers/src/infra/dex/mod.rs
index 1825f2a2f8..7050be1436 100644
--- a/crates/solvers/src/infra/dex/mod.rs
+++ b/crates/solvers/src/infra/dex/mod.rs
@@ -4,6 +4,7 @@ use {
     reqwest::RequestBuilder,
 };
 
+pub mod bitget;
 pub mod okx;
 pub mod simulator;
 
@@ -11,6 +12,7 @@ pub use self::simulator::Simulator;
 
 /// A supported external DEX/DEX aggregator API.
 pub enum Dex {
+    Bitget(bitget::Bitget),
     Okx(Box<okx::Okx>),
 }
 
@@ -23,9 +25,10 @@ impl Dex {
         &self,
         order: &dex::Order,
         slippage: &dex::Slippage,
-        _tokens: &auction::Tokens,
+        tokens: &auction::Tokens,
     ) -> Result<dex::Swap, Error> {
         let swap = match self {
+            Dex::Bitget(bitget) => bitget.swap(order, slippage, tokens).await?,
             Dex::Okx(okx) => okx.swap(order, slippage).await?,
         };
         Ok(swap)
@@ -104,3 +107,15 @@ impl From<okx::Error> for Error {
         }
     }
 }
+
+impl From<bitget::Error> for Error {
+    fn from(err: bitget::Error) -> Self {
+        match err {
+            bitget::Error::OrderNotSupported => Self::OrderNotSupported,
+            bitget::Error::NotFound => Self::NotFound,
+            bitget::Error::MissingDecimals => Self::BadRequest,
+            bitget::Error::RateLimited => Self::RateLimited,
+            _ => Self::Other(Box::new(err)),
+        }
+    }
+}
diff --git a/crates/solvers/src/run.rs b/crates/solvers/src/run.rs
index 5377479659..861f055715 100644
--- a/crates/solvers/src/run.rs
+++ b/crates/solvers/src/run.rs
@@ -54,6 +54,16 @@ async fn run_with(args: cli::Args, bind: Option<oneshot::Sender<SocketAddr>>) {
                 config.base,
             )))
         }
+        cli::Command::Bitget { config: path } => {
+            let config = config::dex::bitget::file::load(&path).await;
+            solver::Solver::Dex(Box::new(solver::Dex::new(
+                dex::Dex::Bitget(
+                    dex::bitget::Bitget::try_new(config.bitget)
+                        .expect("invalid Bitget configuration"),
+                ),
+                config.base,
+            )))
+        }
     };
 
     crate::api::Api {
diff --git a/crates/solvers/src/tests/bitget/api_calls.rs b/crates/solvers/src/tests/bitget/api_calls.rs
new file mode 100644
index 0000000000..722a1b969b
--- /dev/null
+++ b/crates/solvers/src/tests/bitget/api_calls.rs
@@ -0,0 +1,100 @@
+use {
+    crate::{
+        domain::{auction, dex::*, eth::*},
+        infra::dex::bitget as bitget_dex,
+    },
+    alloy::primitives::address,
+    std::{collections::HashMap, env},
+};
+
+#[ignore]
+#[tokio::test]
+// To run this test, set the following environment variables accordingly to your
+// Bitget setup: BITGET_API_KEY, BITGET_API_SECRET
+async fn swap_sell_regular() {
+    let config = bitget_dex::Config {
+        endpoint: reqwest::Url::parse(bitget_dex::DEFAULT_ENDPOINT).unwrap(),
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        credentials: bitget_dex::BitgetCredentialsConfig {
+            api_key: env::var("BITGET_API_KEY").unwrap(),
+            api_secret: env::var("BITGET_API_SECRET").unwrap(),
+        },
+        partner_code: "cowswap".to_string(),
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+    };
+
+    let order = Order {
+        sell: TokenAddress::from(address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Sell,
+        amount: Amount::new(U256::from(1_000_000_000_000_000_000_u128)),
+        owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+
+    let mut token_map = HashMap::new();
+    token_map.insert(
+        order.sell,
+        auction::Token {
+            decimals: Some(18),
+            symbol: None,
+            reference_price: None,
+            available_balance: U256::ZERO,
+            trusted: false,
+        },
+    );
+    token_map.insert(
+        order.buy,
+        auction::Token {
+            decimals: Some(6),
+            symbol: None,
+            reference_price: None,
+            available_balance: U256::ZERO,
+            trusted: false,
+        },
+    );
+    let tokens = auction::Tokens(token_map);
+
+    let bitget = bitget_dex::Bitget::try_new(config).unwrap();
+    let swap_response = bitget.swap(&order, &slippage, &tokens).await;
+    let swap = swap_response.unwrap();
+
+    assert_eq!(swap.input.token, order.amount().token);
+    assert_eq!(swap.input.amount, order.amount().amount);
+    assert_eq!(swap.output.token, order.buy);
+}
+
+#[tokio::test]
+async fn swap_buy_not_supported() {
+    let config = bitget_dex::Config {
+        endpoint: reqwest::Url::parse(bitget_dex::DEFAULT_ENDPOINT).unwrap(),
+        chain_id: crate::domain::eth::ChainId::Mainnet,
+        credentials: bitget_dex::BitgetCredentialsConfig {
+            api_key: String::new(),
+            api_secret: String::new(),
+        },
+        partner_code: "cowswap".to_string(),
+        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+        block_stream: None,
+    };
+
+    let order = Order {
+        buy: TokenAddress::from(address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+        sell: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+        side: crate::domain::order::Side::Buy,
+        amount: Amount::new(U256::from(1000000000_u128)),
+        owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+    };
+
+    let slippage = Slippage::one_percent();
+    let tokens = auction::Tokens(HashMap::new());
+
+    let bitget = bitget_dex::Bitget::try_new(config).unwrap();
+    let swap_response = bitget.swap(&order, &slippage, &tokens).await;
+    assert!(matches!(
+        swap_response.unwrap_err(),
+        bitget_dex::Error::OrderNotSupported
+    ));
+}
diff --git a/crates/solvers/src/tests/bitget/market_order.rs b/crates/solvers/src/tests/bitget/market_order.rs
new file mode 100644
index 0000000000..9c690c49a2
--- /dev/null
+++ b/crates/solvers/src/tests/bitget/market_order.rs
@@ -0,0 +1,217 @@
+//! This test ensures that the Bitget solver properly handles market sell
+//! orders, turning Bitget swap responses into CoW Protocol solutions.
+
+use {
+    crate::tests::{self, mock},
+    serde_json::json,
+};
+
+#[tokio::test]
+async fn sell() {
+    let api = mock::http::setup(vec![
+        mock::http::Expectation::Post {
+            path: mock::http::Path::exact("bgw-pro/swapx/pro/swap"),
+            req: mock::http::RequestBody::Partial(
+                json!({
+                    "fromContract": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                    "fromAmount": "1",
+                    "fromChain": "eth",
+                    "toContract": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "toChain": "eth",
+                    "market": "bgwevmaggregator",
+                    "slippage": 1.0,
+                    "requestMod": "rich",
+                    "feeRate": 0.0
+                }),
+                vec!["fromAddress", "toAddress"],
+            ),
+            res: json!({
+                "status": 0,
+                "data": {
+                    "outAmount": "6556.259156432631386442",
+                    "minAmount": "6490.696564868305072577",
+                    "gasFee": {
+                        "gasLimit": "202500"
+                    },
+                    "swapTransaction": {
+                        "to": "0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                        "data": "0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                             0000000000000000000000000000000000000000000000000de0b6b3a7640000\
+                             00000000000000000000000000000000000000000000015fdc8278903f7f31c1\
+                             0000000000000000000000000000000000000000000000000000000000000080\
+                             0000000000000000000000000000000000000000000000000000000000000001\
+                             00000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539"
+                    }
+                }
+            }),
+        },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("bitget", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(
+        solution,
+        json!({
+           "solutions":[
+              {
+                 "gas": 410141,
+                 "id": 0,
+                 "interactions":[
+                    {
+                       "allowances":[
+                          {
+                             "amount": "1000000000000000000",
+                             "spender": "0x7d0ccaa3fac1e5a943c5168b6ced828691b46b36",
+                             "token": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "callData": "0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a0000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000015fdc8278903f7f31c10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539",
+                       "inputs":[
+                          {
+                             "amount": "1000000000000000000",
+                             "token": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+                          }
+                       ],
+                       "internalize": false,
+                       "kind": "custom",
+                       "outputs":[
+                          {
+                             "amount": "6556259156432631386442",
+                             "token": "0xe41d2489571d322189246dafa5ebde1f4699f498"
+                          }
+                       ],
+                       "target": "0x7d0ccaa3fac1e5a943c5168b6ced828691b46b36",
+                       "value": "0"
+                    }
+                 ],
+                 "postInteractions": [],
+                 "preInteractions": [],
+                 "prices":{
+                    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2": "6556259156432631386442",
+                    "0xe41d2489571d322189246dafa5ebde1f4699f498": "1000000000000000000"
+                 },
+                 "trades":[
+                    {
+                       "executedAmount": "1000000000000000000",
+                       "kind": "fulfillment",
+                       "order": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a"
+                    }
+                 ]
+              }
+           ]
+        }),
+    );
+}
+
+#[tokio::test]
+async fn buy_not_supported() {
+    let api = mock::http::setup(vec![]).await;
+
+    let engine = tests::SolverEngine::new("bitget", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "buy",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    // Buy orders are not supported by Bitget.
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
diff --git a/crates/solvers/src/tests/bitget/mod.rs b/crates/solvers/src/tests/bitget/mod.rs
new file mode 100644
index 0000000000..25a6297217
--- /dev/null
+++ b/crates/solvers/src/tests/bitget/mod.rs
@@ -0,0 +1,21 @@
+use {crate::tests, std::net::SocketAddr};
+
+mod api_calls;
+mod market_order;
+mod not_found;
+mod out_of_price;
+
+/// Creates a temporary file containing the config of the given solver.
+pub fn config(solver_addr: &SocketAddr) -> tests::Config {
+    tests::Config::String(format!(
+        r"
+node-url = 'http://localhost:8545'
+[dex]
+chain-id = '1'
+endpoint = 'http://{solver_addr}/bgw-pro/swapx/pro/'
+[dex.credentials]
+api-key = 'test-api-key'
+api-secret = 'test-api-secret-1234'
+",
+    ))
+}
diff --git a/crates/solvers/src/tests/bitget/not_found.rs b/crates/solvers/src/tests/bitget/not_found.rs
new file mode 100644
index 0000000000..9c538e42ee
--- /dev/null
+++ b/crates/solvers/src/tests/bitget/not_found.rs
@@ -0,0 +1,78 @@
+//! This test ensures that the Bitget solver properly handles cases where no
+//! swap was found for the specified order.
+
+use {
+    crate::tests::{self, mock},
+    serde_json::json,
+};
+
+#[tokio::test]
+async fn sell_no_liquidity() {
+    let api = mock::http::setup(vec![
+        // Swap request returns an error status.
+        mock::http::Expectation::Post {
+            path: mock::http::Path::exact("bgw-pro/swapx/pro/swap"),
+            req: mock::http::RequestBody::Any,
+            res: json!({
+                "status": 404,
+                "data": {}
+            }),
+        },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("bitget", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xC8CD2BE653759aed7B0996315821AAe71e1FEAdF": {
+                    "decimals": 18,
+                    "symbol": "TETH",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC8CD2BE653759aed7B0996315821AAe71e1FEAdF",
+                    "buyToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "sellAmount": "1000000000000000000",
+                    "buyAmount": "200000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "200000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
diff --git a/crates/solvers/src/tests/bitget/out_of_price.rs b/crates/solvers/src/tests/bitget/out_of_price.rs
new file mode 100644
index 0000000000..041149dfb0
--- /dev/null
+++ b/crates/solvers/src/tests/bitget/out_of_price.rs
@@ -0,0 +1,96 @@
+//! This test verifies that the Bitget solver does not generate solutions when
+//! the swap returned from the API does not satisfy an order's limit price.
+//!
+//! The actual test case is a modified version of the [`super::market_order`]
+//! test with an exuberant buy amount.
+
+use {
+    crate::tests::{self, mock},
+    serde_json::json,
+};
+
+#[tokio::test]
+async fn sell() {
+    let api = mock::http::setup(vec![
+        mock::http::Expectation::Post {
+            path: mock::http::Path::exact("bgw-pro/swapx/pro/swap"),
+            req: mock::http::RequestBody::Any,
+            res: json!({
+                "status": 0,
+                "data": {
+                    "outAmount": "6556.259156432631386442",
+                    "minAmount": "6490.696564868305072577",
+                    "gasFee": {
+                        "gasLimit": "202500"
+                    },
+                    "swapTransaction": {
+                        "to": "0x7D0CcAa3Fac1e5A943c5168b6CEd828691b46B36",
+                        "data": "0x0d5f0e3b00000000000000000001a0cf2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                             0000000000000000000000000000000000000000000000000de0b6b3a7640000\
+                             00000000000000000000000000000000000000000000015fdc8278903f7f31c1\
+                             0000000000000000000000000000000000000000000000000000000000000080\
+                             0000000000000000000000000000000000000000000000000000000000000001\
+                             00000000000000000000000014424eeecbff345b38187d0b8b749e56faa68539"
+                    }
+                }
+            }),
+        },
+    ])
+    .await;
+
+    let engine = tests::SolverEngine::new("bitget", super::config(&api.address)).await;
+
+    let solution = engine
+        .solve(json!({
+            "id": "1",
+            "tokens": {
+                "0xe41d2489571d322189246dafa5ebde1f4699f498": {
+                    "decimals": 18,
+                    "symbol": "ZRX",
+                    "referencePrice": "4327903683155778",
+                    "availableBalance": "1583034704488033979459",
+                    "trusted": true,
+                },
+                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+                    "decimals": 18,
+                    "symbol": "WETH",
+                    "referencePrice": "1000000000000000000",
+                    "availableBalance": "482725140468789680",
+                    "trusted": true,
+                },
+            },
+            "orders": [
+                {
+                    "uid": "0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a\
+                              2a2a2a2a",
+                    "sellToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+                    "buyToken": "0xe41d2489571d322189246dafa5ebde1f4699f498",
+                    "sellAmount": "1000000000000000000",
+                    // Way too much...
+                    "buyAmount": "1000000000000000000000000000000000000",
+                    "fullSellAmount": "1000000000000000000",
+                    "fullBuyAmount": "1000000000000000000000000000000000000",
+                    "kind": "sell",
+                    "partiallyFillable": false,
+                    "class": "market",
+                    "sellTokenSource": "erc20",
+                    "buyTokenDestination": "erc20",
+                    "preInteractions": [],
+                    "postInteractions": [],
+                    "owner": "0x5b1e2c2762667331bc91648052f646d1b0d35984",
+                    "validTo": 0,
+                    "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "signingScheme": "presign",
+                    "signature": "0x",
+                }
+            ],
+            "liquidity": [],
+            "effectiveGasPrice": "15000000000",
+            "deadline": "2106-01-01T00:00:00.000Z",
+            "surplusCapturingJitOrderOwners": []
+        }))
+        .await;
+
+    assert_eq!(solution, json!({ "solutions": [] }),);
+}
diff --git a/crates/solvers/src/tests/mod.rs b/crates/solvers/src/tests/mod.rs
index 76fe4ec9ba..4fbf32c519 100644
--- a/crates/solvers/src/tests/mod.rs
+++ b/crates/solvers/src/tests/mod.rs
@@ -10,6 +10,7 @@ use {
     tokio::{sync::oneshot, task::JoinHandle},
 };
 
+mod bitget;
 mod cases;
 mod mock;
 mod okx;

From 41e27b59eec464a6d12ef17286fee11b046fe2b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 11 Mar 2026 13:39:21 +0000
Subject: [PATCH 140/219] Extract orderbook config to configs crate (#4247)

# Description
Essentially the same as
https://github.com/cowprotocol/services/pull/4246 but for the orderbook

# Changes

* Move orderbook configs to the configs crate
* Extract SameTokensPolicy

## How to test
Compilation + tests
---
 crates/configs/src/lib.rs                     |  1 +
 .../src/orderbook}/banned_users.rs            |  0
 .../config => configs/src/orderbook}/ipfs.rs  |  0
 .../config => configs/src/orderbook}/mod.rs   | 34 ++++++------
 .../src/orderbook}/native_price.rs            |  3 +-
 .../src/orderbook}/order_validation.rs        | 11 +++-
 crates/e2e/src/setup/services.rs              | 10 ++--
 crates/e2e/tests/e2e/autopilot_leader.rs      |  8 +--
 crates/e2e/tests/e2e/buffers.rs               |  2 +-
 crates/e2e/tests/e2e/cors.rs                  |  4 +-
 crates/e2e/tests/e2e/cow_amm.rs               |  6 +--
 crates/e2e/tests/e2e/debug_order.rs           |  2 +-
 crates/e2e/tests/e2e/jit_orders.rs            |  2 +-
 crates/e2e/tests/e2e/limit_orders.rs          | 26 +++++-----
 crates/e2e/tests/e2e/liquidity.rs             |  2 +-
 .../e2e/liquidity_source_notification.rs      |  2 +-
 crates/e2e/tests/e2e/malformed_requests.rs    |  2 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |  2 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  8 +--
 crates/e2e/tests/e2e/protocol_fee.rs          | 14 ++---
 crates/e2e/tests/e2e/quote_verification.rs    |  4 +-
 crates/e2e/tests/e2e/quoting.rs               | 20 +++----
 crates/e2e/tests/e2e/replace_order.rs         |  2 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |  7 ++-
 crates/e2e/tests/e2e/solver_competition.rs    |  6 +--
 crates/e2e/tests/e2e/submission.rs            | 15 +++---
 crates/orderbook/src/lib.rs                   |  1 -
 crates/orderbook/src/quoter.rs                |  4 +-
 crates/orderbook/src/run.rs                   |  2 +-
 crates/shared/src/order_validation.rs         | 52 ++++++++-----------
 30 files changed, 130 insertions(+), 122 deletions(-)
 rename crates/{orderbook/src/config => configs/src/orderbook}/banned_users.rs (100%)
 rename crates/{orderbook/src/config => configs/src/orderbook}/ipfs.rs (100%)
 rename crates/{orderbook/src/config => configs/src/orderbook}/mod.rs (94%)
 rename crates/{orderbook/src/config => configs/src/orderbook}/native_price.rs (96%)
 rename crates/{orderbook/src/config => configs/src/orderbook}/order_validation.rs (94%)

diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index 885deeb015..cc93195d0f 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -2,6 +2,7 @@ pub mod autopilot;
 pub mod database;
 pub(crate) mod deserialize_env;
 pub mod fee_factor;
+pub mod orderbook;
 
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
diff --git a/crates/orderbook/src/config/banned_users.rs b/crates/configs/src/orderbook/banned_users.rs
similarity index 100%
rename from crates/orderbook/src/config/banned_users.rs
rename to crates/configs/src/orderbook/banned_users.rs
diff --git a/crates/orderbook/src/config/ipfs.rs b/crates/configs/src/orderbook/ipfs.rs
similarity index 100%
rename from crates/orderbook/src/config/ipfs.rs
rename to crates/configs/src/orderbook/ipfs.rs
diff --git a/crates/orderbook/src/config/mod.rs b/crates/configs/src/orderbook/mod.rs
similarity index 94%
rename from crates/orderbook/src/config/mod.rs
rename to crates/configs/src/orderbook/mod.rs
index 19162cc160..73e4c46560 100644
--- a/crates/orderbook/src/config/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -1,14 +1,17 @@
 use {
-    crate::config::{
-        banned_users::BannedUsersConfig,
-        ipfs::IpfsConfig,
-        native_price::NativePriceConfig,
-        order_validation::OrderValidationConfig,
+    crate::{
+        database::DatabasePoolConfig,
+        fee_factor::FeeFactor,
+        orderbook::{
+            banned_users::BannedUsersConfig,
+            ipfs::IpfsConfig,
+            native_price::NativePriceConfig,
+            order_validation::OrderValidationConfig,
+        },
     },
     alloy::primitives::Address,
     anyhow::anyhow,
     chrono::{DateTime, Utc},
-    configs::{database::DatabasePoolConfig, fee_factor::FeeFactor},
     serde::{Deserialize, Serialize},
     std::path::Path,
 };
@@ -95,13 +98,15 @@ impl Configuration {
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
     use {
-        crate::config::{
-            Configuration,
-            default_active_order_competition_threshold,
-            default_app_data_size_limit,
-            native_price::NativePriceConfig,
+        crate::{
+            orderbook::{
+                Configuration,
+                default_active_order_competition_threshold,
+                default_app_data_size_limit,
+                native_price::NativePriceConfig,
+            },
+            test_util::TestDefault,
         },
-        configs::test_util::TestDefault,
         std::path::Path,
     };
 
@@ -132,7 +137,7 @@ pub mod test_util {
 
     impl TestDefault for Configuration {
         fn test_default() -> Self {
-            use configs::test_util::TestDefault;
+            use crate::test_util::TestDefault;
 
             Self {
                 order_validation: Default::default(),
@@ -156,9 +161,8 @@ pub mod test_util {
 mod tests {
     use {
         super::*,
-        configs::test_util::TestDefault,
+        crate::{orderbook::order_validation::SameTokensPolicy, test_util::TestDefault},
         price_estimation::{NativePriceEstimator, NativePriceEstimators},
-        shared::order_validation::SameTokensPolicy,
         std::time::Duration,
     };
 
diff --git a/crates/orderbook/src/config/native_price.rs b/crates/configs/src/orderbook/native_price.rs
similarity index 96%
rename from crates/orderbook/src/config/native_price.rs
rename to crates/configs/src/orderbook/native_price.rs
index bd7dc80158..57e461d05a 100644
--- a/crates/orderbook/src/config/native_price.rs
+++ b/crates/configs/src/orderbook/native_price.rs
@@ -4,7 +4,6 @@ use {
         config::native_price::NativePriceConfig as SharedNativePriceConfig,
     },
     serde::{Deserialize, Serialize},
-    std::str::FromStr,
 };
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -29,7 +28,7 @@ impl NativePriceConfig {
         use price_estimation::NativePriceEstimator;
         Self {
             estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::forwarder(
-                reqwest::Url::from_str("http://localhost:12088").unwrap(),
+                "http://localhost:12088".parse().unwrap(),
             )]]),
             fallback_estimators: Default::default(),
             shared: Default::default(),
diff --git a/crates/orderbook/src/config/order_validation.rs b/crates/configs/src/orderbook/order_validation.rs
similarity index 94%
rename from crates/orderbook/src/config/order_validation.rs
rename to crates/configs/src/orderbook/order_validation.rs
index f6e882ad43..58adebb3f4 100644
--- a/crates/orderbook/src/config/order_validation.rs
+++ b/crates/configs/src/orderbook/order_validation.rs
@@ -1,9 +1,18 @@
 use {
     serde::{Deserialize, Serialize},
-    shared::order_validation::SameTokensPolicy,
     std::time::Duration,
 };
 
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum SameTokensPolicy {
+    #[default]
+    Disallow,
+    AllowSell,
+    // Allow, TODO: Allow sell and buy orders with the same tokens
+    // (https://github.com/cowprotocol/services/issues/3963)
+}
+
 const fn default_min_order_validity_period() -> Duration {
     Duration::from_secs(60) // 1m
 }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 8df7254bc1..e2d2972220 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -253,7 +253,7 @@ impl<'a> Services<'a> {
     pub async fn start_api(
         &self,
         extra_args: Vec<String>,
-        config: orderbook::config::Configuration,
+        config: configs::orderbook::Configuration,
     ) {
         let (_config_file, config_arg) = config.to_cli_args();
         let args: Vec<_> = [
@@ -280,7 +280,7 @@ impl<'a> Services<'a> {
         self.start_protocol_with_args(
             Default::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -290,7 +290,7 @@ impl<'a> Services<'a> {
         &self,
         args: ExtraServiceArgs,
         autopilot_config: configs::autopilot::Configuration,
-        orderbook_config: orderbook::config::Configuration,
+        orderbook_config: configs::orderbook::Configuration,
         solver: TestAccount,
     ) {
         self.start_protocol_with_args_and_haircut(
@@ -307,7 +307,7 @@ impl<'a> Services<'a> {
         &self,
         args: ExtraServiceArgs,
         autopilot_config: configs::autopilot::Configuration,
-        orderbook_config: orderbook::config::Configuration,
+        orderbook_config: configs::orderbook::Configuration,
         solver: TestAccount,
         haircut_bps: u32,
     ) {
@@ -472,7 +472,7 @@ impl<'a> Services<'a> {
             autopilot_config,
         )
         .await;
-        self.start_api(api_args, orderbook::config::Configuration::test_default())
+        self.start_api(api_args, configs::orderbook::Configuration::test_default())
             .await;
     }
 
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 7b18db5ff8..835195557c 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -141,16 +141,16 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver1,test_solver2|http://localhost:11088/test_solver2".to_string(),
             ],
-            orderbook::config::Configuration {
-                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+            configs::orderbook::Configuration {
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     estimators: price_estimation::NativePriceEstimators::new(vec![vec![
                         price_estimation::NativePriceEstimator::forwarder(
                             "http://0.0.0.0:9588".parse().unwrap(),
                         ),
                     ]]),
-                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
         )
         .await;
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 81587938e5..99aa97af55 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -87,7 +87,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index 323dd0629f..12b01a28ee 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -26,7 +26,7 @@ async fn cors_preflight(web3: Web3) {
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
     let client = services.client();
@@ -87,7 +87,7 @@ async fn cors_headers_on_error(web3: Web3) {
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
     let client = services.client();
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 0d27cf7ffb..4880e20ec9 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -202,7 +202,7 @@ async fn cow_amm_jit(web3: Web3) {
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
@@ -591,7 +591,7 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
@@ -857,7 +857,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
                 "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/debug_order.rs b/crates/e2e/tests/e2e/debug_order.rs
index d6090db3e5..d4c0570c18 100644
--- a/crates/e2e/tests/e2e/debug_order.rs
+++ b/crates/e2e/tests/e2e/debug_order.rs
@@ -50,7 +50,7 @@ async fn debug_order(web3: Web3) {
         .start_protocol_with_args(
             ExtraServiceArgs::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index aa21e1c392..dfa50c55eb 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -106,7 +106,7 @@ async fn single_limit_order_test(web3: Web3) {
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 134be0b253..24e8c180ac 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -12,6 +12,7 @@ use {
             run_loop::RunLoopConfig,
             solver::{Account, Solver},
         },
+        orderbook::order_validation::OrderValidationConfig,
         test_util::TestDefault,
     },
     contracts::alloy::ERC20,
@@ -28,7 +29,6 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{conversions::big_decimal_to_big_uint, units::EthUnit},
-    orderbook::config::order_validation::OrderValidationConfig,
     shared::web3::Web3,
     std::{
         collections::HashMap,
@@ -369,7 +369,7 @@ async fn two_limit_orders_test(web3: Web3) {
         .start_protocol_with_args(
             ExtraServiceArgs::default(),
             config,
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -511,17 +511,17 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
             vec![
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
             ],
-            orderbook::config::Configuration {
-                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+            configs::orderbook::Configuration {
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     estimators: price_estimation::NativePriceEstimators::new(vec![vec![
                         price_estimation::NativePriceEstimator::driver(
                             "test_quoter".to_string(),
                             "http://localhost:11088/test_solver".parse().unwrap(),
                         ),
                     ]]),
-                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
         )
         .await;
@@ -762,12 +762,12 @@ async fn too_many_limit_orders_test(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration {
+            configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
                     max_limit_orders_per_user: 1,
                     ..Default::default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
         )
         .await;
@@ -865,12 +865,12 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration {
+            configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
                     max_limit_orders_per_user: 1,
                     ..Default::default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
         )
         .await;
@@ -1201,7 +1201,7 @@ async fn no_liquidity_limit_order(web3: Web3) {
                 },
                 ..Configuration::test_no_drivers()
             },
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -1372,7 +1372,7 @@ async fn sell_order_with_haircut_test(web3: Web3) {
         .start_protocol_with_args_and_haircut(
             Default::default(),
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
             500,
         )
@@ -1573,7 +1573,7 @@ async fn buy_order_with_haircut_test(web3: Web3) {
         .start_protocol_with_args_and_haircut(
             Default::default(),
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
             500,
         )
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 2cd9ca6e3a..d62113bb3e 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -208,7 +208,7 @@ async fn zero_ex_liquidity(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index 59099210fa..ad77d10afe 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -219,7 +219,7 @@ http-timeout = "10s"
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 07222c2995..f658025c38 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -34,7 +34,7 @@ async fn http_validation(web3: Web3) {
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
     let client = services.client();
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index b9ffeb588e..4934444914 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -85,7 +85,7 @@ async fn order_cancellation(web3: Web3) {
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 8c7e0632fe..3699107a72 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -239,8 +239,8 @@ async fn fallback_native_price_estimator(web3: Web3) {
                     .to_string(),
                 "--gas-estimators=http://localhost:11088/gasprice".to_string(),
             ],
-            orderbook::config::Configuration {
-                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+            configs::orderbook::Configuration {
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     fallback_estimators: Some(price_estimation::NativePriceEstimators::new(vec![
                         vec![price_estimation::NativePriceEstimator::driver(
                             "test_quoter".to_string(),
@@ -254,9 +254,9 @@ async fn fallback_native_price_estimator(web3: Web3) {
                         },
                         ..Default::default()
                     },
-                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
         )
         .await;
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 3e21376633..23f2bc302e 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -177,7 +177,7 @@ async fn combined_protocol_fees(web3: Web3) {
                 },
                 ..Configuration::test_no_drivers()
             },
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -528,7 +528,7 @@ async fn surplus_partner_fee(web3: Web3) {
                 },
                 ..Configuration::test_no_drivers()
             },
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -775,7 +775,7 @@ async fn volume_fee_buy_order_test(web3: Web3) {
                 },
                 ..Configuration::test_no_drivers()
             },
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -938,7 +938,7 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) {
                 },
                 ..Configuration::test_no_drivers()
             },
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -1102,12 +1102,12 @@ async fn volume_fee_overrides(web3: Web3) {
                 },
                 ..Configuration::test_no_drivers()
             },
-            orderbook::config::Configuration {
-                volume_fee: Some(orderbook::config::VolumeFeeConfig {
+            configs::orderbook::Configuration {
+                volume_fee: Some(configs::orderbook::VolumeFeeConfig {
                     factor: Some(FeeFactor::new(0.01)), // Default 1% volume fee
                     effective_from_timestamp: None,
                 }),
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index bf8b4d6ad9..8013e903a5 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -381,7 +381,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
                 ..Default::default()
             },
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
@@ -526,7 +526,7 @@ async fn usdt_quote_verification(web3: Web3) {
                 ..Default::default()
             },
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver,
         )
         .await;
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 9760b74fe7..b145205d1b 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -79,13 +79,13 @@ async fn test(web3: Web3) {
         .start_protocol_with_args(
             Default::default(),
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration {
-                volume_fee: Some(orderbook::config::VolumeFeeConfig {
+            configs::orderbook::Configuration {
+                volume_fee: Some(configs::orderbook::VolumeFeeConfig {
                     factor: Some(FeeFactor::new(0.0002)),
                     // Set a far future effective timestamp to ensure the fee is not applied
                     effective_from_timestamp: Some("2099-01-01T10:00:00Z".parse().unwrap()),
                 }),
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
             solver,
         )
@@ -325,17 +325,17 @@ async fn quote_timeout(web3: Web3) {
                     .to_string(),
                 format!("--quote-timeout={MAX_QUOTE_TIME_MS}ms"),
             ],
-            orderbook::config::Configuration {
-                native_price_estimation: orderbook::config::native_price::NativePriceConfig {
+            configs::orderbook::Configuration {
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     estimators: price_estimation::NativePriceEstimators::new(vec![vec![
                         price_estimation::NativePriceEstimator::driver(
                             "test_quoter".to_string(),
                             "http://localhost:11088/test_solver".parse().unwrap(),
                         ),
                     ]]),
-                    ..orderbook::config::native_price::NativePriceConfig::test_default()
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
         )
         .await;
@@ -484,13 +484,13 @@ async fn volume_fee(web3: Web3) {
                 ..Default::default()
             },
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration {
-                volume_fee: Some(orderbook::config::VolumeFeeConfig {
+            configs::orderbook::Configuration {
+                volume_fee: Some(configs::orderbook::VolumeFeeConfig {
                     factor: Some(FeeFactor::new(0.0002)),
                     // Set a past effective timestamp to ensure the fee is applied
                     effective_from_timestamp: Some("2000-01-01T10:00:00Z".parse().unwrap()),
                 }),
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index ea1e2213c4..38e6e644d1 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -478,7 +478,7 @@ async fn single_replace_order_test(web3: Web3) {
                 ..Default::default()
             },
             configs::autopilot::Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
             solver.clone(),
         )
         .await;
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 8fedb26ca0..88c2cfe323 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -1,6 +1,6 @@
 use {
     ::alloy::primitives::{Address, U256},
-    configs::test_util::TestDefault,
+    configs::{orderbook::order_validation::OrderValidationConfig, test_util::TestDefault},
     e2e::setup::{safe::Safe, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -8,7 +8,6 @@ use {
         signature::Signature,
     },
     number::units::EthUnit,
-    orderbook::config::order_validation::OrderValidationConfig,
     reqwest::StatusCode,
     shared::web3::Web3,
 };
@@ -179,12 +178,12 @@ async fn erc1271_gas_limit(web3: Web3) {
         .start_protocol_with_args(
             Default::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration {
+            configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
                     max_gas_per_order: 1_000_000,
                     ..Default::default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
             solver,
         )
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 38c681fdc8..7059e59b9b 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -108,7 +108,7 @@ async fn solver_competition(web3: Web3) {
             vec![
                 "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
@@ -267,7 +267,7 @@ async fn wrong_solution_submission_address(web3: Web3) {
             vec![
                 "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
@@ -434,7 +434,7 @@ async fn store_filtered_solutions(web3: Web3) {
                 "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
                     .to_string(),
             ],
-            orderbook::config::Configuration::test_default(),
+            configs::orderbook::Configuration::test_default(),
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 75fb1b2d06..0774b073ab 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -7,7 +7,11 @@ use {
             types::{Transaction, TransactionReceipt},
         },
     },
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        orderbook::order_validation::OrderValidationConfig,
+        test_util::TestDefault,
+    },
     e2e::setup::*,
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     futures::StreamExt,
@@ -17,7 +21,6 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{nonzero::NonZeroU256, testing::ApproxEq, units::EthUnit},
-    orderbook::config::order_validation::OrderValidationConfig,
     shared::web3::Web3,
     std::time::Duration,
 };
@@ -162,12 +165,12 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
         .start_protocol_with_args(
             Default::default(),
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration {
+            configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
                     same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
                     ..Default::default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
             solver.clone(),
         )
@@ -278,12 +281,12 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
         .start_protocol_with_args(
             Default::default(),
             Configuration::test("test_solver", solver.address()),
-            orderbook::config::Configuration {
+            configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
                     same_tokens_policy: shared::order_validation::SameTokensPolicy::AllowSell,
                     ..Default::default()
                 },
-                ..orderbook::config::Configuration::test_default()
+                ..configs::orderbook::Configuration::test_default()
             },
             solver.clone(),
         )
diff --git a/crates/orderbook/src/lib.rs b/crates/orderbook/src/lib.rs
index 5b71b41d52..2b380334fa 100644
--- a/crates/orderbook/src/lib.rs
+++ b/crates/orderbook/src/lib.rs
@@ -1,7 +1,6 @@
 pub mod api;
 pub mod app_data;
 pub mod arguments;
-pub mod config;
 pub mod database;
 pub mod dto;
 mod ipfs;
diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs
index 4d7b8eee5b..7c82e4742a 100644
--- a/crates/orderbook/src/quoter.rs
+++ b/crates/orderbook/src/quoter.rs
@@ -1,9 +1,9 @@
 use {
-    crate::{app_data, config::VolumeFeeConfig},
+    crate::app_data,
     alloy::primitives::{U256, U512, Uint, ruint::UintTryFrom},
     bigdecimal::{BigDecimal, FromPrimitive},
     chrono::{TimeZone, Utc},
-    configs::fee_factor::FeeFactor,
+    configs::{fee_factor::FeeFactor, orderbook::VolumeFeeConfig},
     model::{
         order::OrderCreationAppData,
         quote::{OrderQuote, OrderQuoteRequest, OrderQuoteResponse, OrderQuoteSide, PriceQuality},
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 982af41bfd..1ef345df07 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -2,7 +2,6 @@ use {
     crate::{
         api,
         arguments::Arguments,
-        config::Configuration,
         database::Postgres,
         ipfs::Ipfs,
         ipfs_app_data::IpfsAppData,
@@ -16,6 +15,7 @@ use {
     bad_tokens::list_based::DenyListedTokens,
     chain::Chain,
     clap::Parser,
+    configs::orderbook::Configuration,
     contracts::alloy::{
         BalancerV2Vault,
         ChainalysisOracle,
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 05f3cebca2..cde4d9eb78 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -210,35 +210,26 @@ pub trait LimitOrderCounting: Send + Sync {
     async fn count(&self, owner: Address) -> Result<u64>;
 }
 
-#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum SameTokensPolicy {
-    #[default]
-    Disallow,
-    AllowSell,
-    // Allow, TODO: Allow sell and buy orders with the same tokens (https://github.com/cowprotocol/services/issues/3963)
-}
-
-impl SameTokensPolicy {
-    fn validate_same_sell_and_buy_token(
-        &self,
-        order: &PreOrderData,
-        native_token: &Address,
-    ) -> Result<(), PartialValidationError> {
-        // Check for orders selling wrapped native token for native token.
-        if &order.sell_token == native_token && order.buy_token == BUY_ETH_ADDRESS {
-            return Err(PartialValidationError::SameBuyAndSellToken);
-        }
+pub use configs::orderbook::order_validation::SameTokensPolicy;
+
+fn validate_same_sell_and_buy_token(
+    policy: &SameTokensPolicy,
+    order: &PreOrderData,
+    native_token: &Address,
+) -> Result<(), PartialValidationError> {
+    // Check for orders selling wrapped native token for native token.
+    if &order.sell_token == native_token && order.buy_token == BUY_ETH_ADDRESS {
+        return Err(PartialValidationError::SameBuyAndSellToken);
+    }
 
-        if order.sell_token != order.buy_token {
-            return Ok(());
-        }
+    if order.sell_token != order.buy_token {
+        return Ok(());
+    }
 
-        match (self, order.kind) {
-            // (Self::Allow, _) | To be implemented in https://github.com/cowprotocol/services/issues/3963
-            (Self::AllowSell, OrderKind::Sell) => Ok(()),
-            _ => Err(PartialValidationError::SameBuyAndSellToken),
-        }
+    match (policy, order.kind) {
+        // (SameTokensPolicy::Allow, _) | To be implemented in https://github.com/cowprotocol/services/issues/3963
+        (SameTokensPolicy::AllowSell, OrderKind::Sell) => Ok(()),
+        _ => Err(PartialValidationError::SameBuyAndSellToken),
     }
 }
 
@@ -518,8 +509,11 @@ impl OrderValidating for OrderValidator {
         }
 
         self.validity_configuration.validate_period(&order)?;
-        self.same_tokens_policy
-            .validate_same_sell_and_buy_token(&order, self.native_token.address())?;
+        validate_same_sell_and_buy_token(
+            &self.same_tokens_policy,
+            &order,
+            self.native_token.address(),
+        )?;
 
         if order.sell_token == BUY_ETH_ADDRESS {
             return Err(PartialValidationError::InvalidNativeSellToken);

From f8ff3cb21fce130d0a764b7e1bd5d397c6db7c0c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Wed, 11 Mar 2026 18:29:46 +0000
Subject: [PATCH 141/219] Extract order_quoting, banned_users, http_client
 configs to configs crate (#4253)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Extract shared configuration types (`OrderQuoting`, `BannedUsersConfig`,
`HttpClient`) from CLI arguments into the `configs` crate as
TOML-deserialized structs. This continues the migration of runtime
configuration from clap CLI args to structured TOML config files.

# Changes

* Move `OrderQuotingArguments` and `ExternalSolver` from
`shared::arguments` (clap) to `configs::order_quoting` (serde/TOML),
renaming to `OrderQuoting`
* Deduplicate `BannedUsersConfig` — was duplicated in
`configs::autopilot::banned_users` and
`configs::orderbook::banned_users`, now a single `configs::banned_users`
module shared by both
* Move `HttpClient` config to `configs::http_client`
* Add `TestDefault` impl for `OrderQuoting` and test helpers
(`ExternalSolver::new`, `OrderQuoting::test_with_drivers`)
* Update all e2e tests to pass `price-estimation-drivers` via config
structs instead of the removed CLI arg
* Add deserialization and roundtrip tests for `OrderQuoting`

## How to test

Existing tests

# Migration Guide

The following CLI arguments have moved to TOML config files. This
applies to **both autopilot and orderbook** services.

## Order Quoting (`[order-quoting]`)

| CLI arg / env var | TOML key (`[order-quoting]`) |
|---|---|
| `--price-estimation-drivers` / `PRICE_ESTIMATION_DRIVERS` |
`[[price-estimation-drivers]]` (see below) |
| `--eip1271-onchain-quote-validity` / `EIP1271_ONCHAIN_QUOTE_VALIDITY`
| `eip1271-onchain-quote-validity` |
| `--presign-onchain-quote-validity` / `PRESIGN_ONCHAIN_QUOTE_VALIDITY`
| `presign-onchain-quote-validity` |
| `--standard-offchain-quote-validity` /
`STANDARD_OFFCHAIN_QUOTE_VALIDITY` | `standard-offchain-quote-validity`
|

The `--price-estimation-drivers` pipe/comma-separated format
(`name|url,name2|url2`) is replaced by TOML tables:

```toml
[order-quoting]
eip1271-onchain-quote-validity = "10m"
presign-onchain-quote-validity = "10m"
standard-offchain-quote-validity = "1m"

[[order-quoting.price-estimation-drivers]]
name = "solver1"
url = "http://solver1:8080"

[[order-quoting.price-estimation-drivers]]
name = "solver2"
url = "http://solver2:8080"
```

## Banned Users

`BannedUsersConfig` is now shared between autopilot and orderbook
(previously duplicated). No config format changes — the `[banned-users]`
TOML section remains the same.

## HTTP Client (`[http-client]`)

| CLI arg / env var | TOML key (`[http-client]`) |
|---|---|
| `--http-timeout` / `HTTP_TIMEOUT` | `http-timeout` |

All defaults remain unchanged.
---
 Cargo.lock                                    |   1 +
 crates/autopilot/src/arguments.rs             |  12 +-
 crates/autopilot/src/run.rs                   |  12 +-
 crates/configs/src/autopilot/mod.rs           |  21 +-
 .../src/{autopilot => }/banned_users.rs       |   2 +
 crates/configs/src/http_client.rs             |  21 ++
 crates/configs/src/lib.rs                     |   3 +
 crates/configs/src/order_quoting.rs           | 195 ++++++++++++++++++
 crates/configs/src/orderbook/banned_users.rs  |  28 ---
 crates/configs/src/orderbook/mod.rs           |  23 ++-
 crates/driver/Cargo.toml                      |   1 +
 crates/e2e/src/setup/services.rs              |  69 +++----
 crates/e2e/tests/e2e/autopilot_leader.rs      |  35 ++--
 crates/e2e/tests/e2e/buffers.rs               |  28 ++-
 crates/e2e/tests/e2e/cors.rs                  |  33 +--
 crates/e2e/tests/e2e/cow_amm.rs               |  75 ++++---
 crates/e2e/tests/e2e/jit_orders.rs            |  32 ++-
 crates/e2e/tests/e2e/limit_orders.rs          |  61 +++---
 crates/e2e/tests/e2e/liquidity.rs             |  32 ++-
 .../e2e/liquidity_source_notification.rs      |  32 ++-
 crates/e2e/tests/e2e/malformed_requests.rs    |  19 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |  32 ++-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  30 +--
 crates/e2e/tests/e2e/quoting.rs               |  17 +-
 crates/e2e/tests/e2e/solver_competition.rs    |  85 +++++---
 crates/orderbook/src/arguments.rs             |  11 -
 crates/orderbook/src/run.rs                   |  12 +-
 crates/shared/src/arguments.rs                | 110 ----------
 crates/shared/src/http_client.rs              |   8 +
 29 files changed, 638 insertions(+), 402 deletions(-)
 rename crates/configs/src/{autopilot => }/banned_users.rs (91%)
 create mode 100644 crates/configs/src/http_client.rs
 create mode 100644 crates/configs/src/order_quoting.rs
 delete mode 100644 crates/configs/src/orderbook/banned_users.rs

diff --git a/Cargo.lock b/Cargo.lock
index e7bfe364da..984b05e5c0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2974,6 +2974,7 @@ dependencies = [
  "chain",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "cow-amm",
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 7700ee5bff..701fb4b145 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -1,4 +1,4 @@
-use {shared::http_client, std::path::PathBuf};
+use std::path::PathBuf;
 
 #[derive(clap::Parser)]
 pub struct CliArguments {
@@ -8,12 +8,6 @@ pub struct CliArguments {
     #[clap(flatten)]
     pub shared: shared::arguments::Arguments,
 
-    #[clap(flatten)]
-    pub order_quoting: shared::arguments::OrderQuotingArguments,
-
-    #[clap(flatten)]
-    pub http_client: http_client::Arguments,
-
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 }
@@ -23,14 +17,10 @@ impl std::fmt::Display for CliArguments {
         let Self {
             config,
             shared,
-            order_quoting,
-            http_client,
             price_estimation,
         } = self;
         write!(f, "{}", config.display())?;
         write!(f, "{shared}")?;
-        write!(f, "{order_quoting}")?;
-        write!(f, "{http_client}")?;
         write!(f, "{price_estimation}")?;
         Ok(())
     }
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index b460eeda61..eee4e38ea3 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -179,7 +179,7 @@ pub async fn run(
     // trigger and error https://www.postgresql.org/docs/current/hot-standby.html
     crate::database::run_database_metrics_work(db_write.clone());
 
-    let http_factory = HttpClientFactory::new(&args.http_client);
+    let http_factory = HttpClientFactory::from(config.http_client);
     let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
     let simulation_web3 = args
         .shared
@@ -353,7 +353,7 @@ pub async fn run(
 
     let price_estimator = price_estimator_factory
         .price_estimator(
-            &args
+            &config
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
@@ -438,15 +438,15 @@ pub async fn run(
         Arc::new(db_write.clone()),
         order_quoting::Validity {
             eip1271_onchain_quote: chrono::Duration::from_std(
-                args.order_quoting.eip1271_onchain_quote_validity,
+                config.order_quoting.eip1271_onchain_quote_validity,
             )
             .unwrap(),
             presign_onchain_quote: chrono::Duration::from_std(
-                args.order_quoting.presign_onchain_quote_validity,
+                config.order_quoting.presign_onchain_quote_validity,
             )
             .unwrap(),
             standard_quote: chrono::Duration::from_std(
-                args.order_quoting.standard_offchain_quote_validity,
+                config.order_quoting.standard_offchain_quote_validity,
             )
             .unwrap(),
         },
@@ -630,7 +630,7 @@ pub async fn run(
 }
 
 async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
-    let http_factory = HttpClientFactory::new(&args.http_client);
+    let http_factory = HttpClientFactory::from(config.http_client);
 
     let orderbook = infra::shadow::Orderbook::new(
         http_factory.create(),
diff --git a/crates/configs/src/autopilot/mod.rs b/crates/configs/src/autopilot/mod.rs
index cf512fc293..8a4855ac62 100644
--- a/crates/configs/src/autopilot/mod.rs
+++ b/crates/configs/src/autopilot/mod.rs
@@ -1,7 +1,6 @@
 use {
     crate::{
         autopilot::{
-            banned_users::BannedUsersConfig,
             cow_amm::CowAmmGroupConfig,
             ethflow::EthflowConfig,
             fee_policy::FeePoliciesConfig,
@@ -12,7 +11,10 @@ use {
             solver::Solver,
             trusted_tokens::TrustedTokensConfig,
         },
+        banned_users::BannedUsersConfig,
         database::DatabasePoolConfig,
+        http_client::HttpClient,
+        order_quoting::OrderQuoting,
     },
     alloy::primitives::Address,
     anyhow::{anyhow, ensure},
@@ -21,7 +23,6 @@ use {
     url::Url,
 };
 
-pub mod banned_users;
 pub mod cow_amm;
 pub mod ethflow;
 pub mod fee_policy;
@@ -146,6 +147,13 @@ pub struct Configuration {
     /// the liveness check. Expects a value in seconds.
     #[serde(with = "humantime_serde", default = "default_max_auction_age")]
     pub max_auction_age: Duration,
+
+    /// Configurations for the HTTP client (e.g. HTTP timeout).
+    #[serde(default)]
+    pub http_client: HttpClient,
+
+    // Configurations for the order creation process.
+    pub order_quoting: OrderQuoting,
 }
 
 impl Configuration {
@@ -205,6 +213,8 @@ impl Configuration {
             unsupported_tokens: Default::default(),
             min_order_validity_period: default_min_order_validity_period(),
             max_auction_age: default_max_auction_age(),
+            http_client: Default::default(),
+            order_quoting: TestDefault::test_default(),
         }
     }
 
@@ -232,6 +242,8 @@ impl Configuration {
             unsupported_tokens: Default::default(),
             min_order_validity_period: default_min_order_validity_period(),
             max_auction_age: default_max_auction_age(),
+            http_client: Default::default(),
+            order_quoting: TestDefault::test_default(),
         }
     }
 
@@ -329,6 +341,8 @@ mod tests {
             [{type = "Forwarder", url = "http://localhost:12088"}],
         ]
 
+        [order-quoting]
+        price-estimation-drivers = []
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -432,6 +446,9 @@ mod tests {
 
         [native-price-estimation]
         estimators = [[{type = "CoinGecko"}]]
+
+        [order-quoting]
+        price-estimation-drivers = []
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
diff --git a/crates/configs/src/autopilot/banned_users.rs b/crates/configs/src/banned_users.rs
similarity index 91%
rename from crates/configs/src/autopilot/banned_users.rs
rename to crates/configs/src/banned_users.rs
index 7a2ef3fc6e..8763f290c0 100644
--- a/crates/configs/src/autopilot/banned_users.rs
+++ b/crates/configs/src/banned_users.rs
@@ -5,6 +5,8 @@ use {
 };
 
 fn default_max_cache_size() -> NonZeroUsize {
+    // Note that this default value does not apply to both the orderbook and
+    // autopilot! Remember to explicitly change it in the infra repo.
     NonZeroUsize::new(10000).unwrap()
 }
 
diff --git a/crates/configs/src/http_client.rs b/crates/configs/src/http_client.rs
new file mode 100644
index 0000000000..be9b87fe53
--- /dev/null
+++ b/crates/configs/src/http_client.rs
@@ -0,0 +1,21 @@
+use {serde::Deserialize, std::time::Duration};
+
+const fn default_timeout() -> Duration {
+    Duration::from_secs(10)
+}
+
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case")]
+pub struct HttpClient {
+    #[serde(with = "humantime_serde", default = "default_timeout")]
+    pub timeout: Duration,
+}
+
+impl Default for HttpClient {
+    fn default() -> Self {
+        Self {
+            timeout: default_timeout(),
+        }
+    }
+}
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index cc93195d0f..8cf859f50e 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -1,7 +1,10 @@
 pub mod autopilot;
+pub mod banned_users;
 pub mod database;
 pub(crate) mod deserialize_env;
 pub mod fee_factor;
+pub mod http_client;
+pub mod order_quoting;
 pub mod orderbook;
 
 #[cfg(any(test, feature = "test-util"))]
diff --git a/crates/configs/src/order_quoting.rs b/crates/configs/src/order_quoting.rs
new file mode 100644
index 0000000000..8175c9ef31
--- /dev/null
+++ b/crates/configs/src/order_quoting.rs
@@ -0,0 +1,195 @@
+use {serde::Deserialize, std::time::Duration, url::Url};
+
+const fn default_eip1271_onchain_quote_validity() -> Duration {
+    Duration::from_mins(10)
+}
+const fn default_presign_onchain_quote_validity() -> Duration {
+    Duration::from_mins(10)
+}
+const fn default_standard_offchain_quote_validity() -> Duration {
+    Duration::from_mins(1)
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case")]
+pub struct ExternalSolver {
+    pub name: String,
+    pub url: Url,
+}
+
+// The following arguments are used to configure the order creation process.
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case")]
+pub struct OrderQuoting {
+    /// A list of external drivers used for price estimation.
+    pub price_estimation_drivers: Vec<ExternalSolver>,
+
+    /// The time period an EIP1271-quote request is valid.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_eip1271_onchain_quote_validity"
+    )]
+    pub eip1271_onchain_quote_validity: Duration,
+
+    /// The time period an PRESIGN-quote request is valid.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_presign_onchain_quote_validity"
+    )]
+    pub presign_onchain_quote_validity: Duration,
+
+    /// The time period a regular offchain-quote request (ethsign/eip712) is
+    /// valid.
+    #[serde(
+        with = "humantime_serde",
+        default = "default_standard_offchain_quote_validity"
+    )]
+    pub standard_offchain_quote_validity: Duration,
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl ExternalSolver {
+    pub fn new(name: &str, url: &str) -> Self {
+        Self {
+            name: name.to_string(),
+            url: url.parse().unwrap(),
+        }
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl OrderQuoting {
+    pub fn test_with_drivers(drivers: Vec<ExternalSolver>) -> Self {
+        Self {
+            price_estimation_drivers: drivers,
+            ..crate::test_util::TestDefault::test_default()
+        }
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl crate::test_util::TestDefault for OrderQuoting {
+    fn test_default() -> Self {
+        Self {
+            price_estimation_drivers: vec![],
+            eip1271_onchain_quote_validity: default_eip1271_onchain_quote_validity(),
+            presign_onchain_quote_validity: default_presign_onchain_quote_validity(),
+            standard_offchain_quote_validity: default_standard_offchain_quote_validity(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_defaults() {
+        let toml = r#"
+        price-estimation-drivers = []
+        "#;
+        let config: OrderQuoting = toml::from_str(toml).unwrap();
+        assert!(config.price_estimation_drivers.is_empty());
+        assert_eq!(
+            config.eip1271_onchain_quote_validity,
+            Duration::from_mins(10)
+        );
+        assert_eq!(
+            config.presign_onchain_quote_validity,
+            Duration::from_mins(10)
+        );
+        assert_eq!(
+            config.standard_offchain_quote_validity,
+            Duration::from_mins(1)
+        );
+    }
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+        eip1271-onchain-quote-validity = "5m"
+        presign-onchain-quote-validity = "20m"
+        standard-offchain-quote-validity = "30s"
+
+        [[price-estimation-drivers]]
+        name = "test-solver"
+        url = "http://localhost:8080"
+        "#;
+        let config: OrderQuoting = toml::from_str(toml).unwrap();
+        assert_eq!(config.price_estimation_drivers.len(), 1);
+        assert_eq!(config.price_estimation_drivers[0].name, "test-solver");
+        assert_eq!(
+            config.price_estimation_drivers[0].url.as_str(),
+            "http://localhost:8080/"
+        );
+        assert_eq!(
+            config.eip1271_onchain_quote_validity,
+            Duration::from_mins(5)
+        );
+        assert_eq!(
+            config.presign_onchain_quote_validity,
+            Duration::from_mins(20)
+        );
+        assert_eq!(
+            config.standard_offchain_quote_validity,
+            Duration::from_secs(30)
+        );
+    }
+
+    #[test]
+    fn deserialize_multiple_drivers() {
+        let toml = r#"
+        [[price-estimation-drivers]]
+        name = "solver-a"
+        url = "http://solver-a:8080"
+
+        [[price-estimation-drivers]]
+        name = "solver-b"
+        url = "http://solver-b:9090"
+        "#;
+        let config: OrderQuoting = toml::from_str(toml).unwrap();
+        assert_eq!(config.price_estimation_drivers.len(), 2);
+        assert_eq!(config.price_estimation_drivers[0].name, "solver-a");
+        assert_eq!(config.price_estimation_drivers[1].name, "solver-b");
+    }
+
+    #[test]
+    fn deserialize_missing_required_field() {
+        let toml = "";
+        let result = toml::from_str::<OrderQuoting>(toml);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = OrderQuoting {
+            price_estimation_drivers: vec![ExternalSolver {
+                name: "test".to_string(),
+                url: "http://localhost:1234".parse().unwrap(),
+            }],
+            eip1271_onchain_quote_validity: Duration::from_secs(300),
+            presign_onchain_quote_validity: Duration::from_secs(600),
+            standard_offchain_quote_validity: Duration::from_secs(60),
+        };
+        let serialized = toml::to_string(&config).unwrap();
+        let deserialized: OrderQuoting = toml::from_str(&serialized).unwrap();
+        assert_eq!(
+            config.eip1271_onchain_quote_validity,
+            deserialized.eip1271_onchain_quote_validity
+        );
+        assert_eq!(
+            config.presign_onchain_quote_validity,
+            deserialized.presign_onchain_quote_validity
+        );
+        assert_eq!(
+            config.standard_offchain_quote_validity,
+            deserialized.standard_offchain_quote_validity
+        );
+        assert_eq!(
+            config.price_estimation_drivers.len(),
+            deserialized.price_estimation_drivers.len()
+        );
+    }
+}
diff --git a/crates/configs/src/orderbook/banned_users.rs b/crates/configs/src/orderbook/banned_users.rs
deleted file mode 100644
index e970795915..0000000000
--- a/crates/configs/src/orderbook/banned_users.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use {
-    alloy::primitives::Address,
-    serde::{Deserialize, Serialize},
-    std::num::NonZeroUsize,
-};
-
-const fn default_max_cache_size() -> NonZeroUsize {
-    NonZeroUsize::new(100).expect("value should be non-zero")
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct BannedUsersConfig {
-    #[serde(default)]
-    pub addresses: Vec<Address>,
-
-    /// Maximum number of entries to keep in the banned users cache.
-    #[serde(default = "default_max_cache_size")]
-    pub max_cache_size: NonZeroUsize,
-}
-
-impl Default for BannedUsersConfig {
-    fn default() -> Self {
-        Self {
-            addresses: Default::default(),
-            max_cache_size: default_max_cache_size(),
-        }
-    }
-}
diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index 73e4c46560..9e2ae0a167 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -1,9 +1,11 @@
 use {
     crate::{
+        banned_users::BannedUsersConfig,
         database::DatabasePoolConfig,
         fee_factor::FeeFactor,
+        http_client::HttpClient,
+        order_quoting::OrderQuoting,
         orderbook::{
-            banned_users::BannedUsersConfig,
             ipfs::IpfsConfig,
             native_price::NativePriceConfig,
             order_validation::OrderValidationConfig,
@@ -16,7 +18,6 @@ use {
     std::path::Path,
 };
 
-pub mod banned_users;
 pub mod ipfs;
 pub mod native_price;
 pub mod order_validation;
@@ -76,6 +77,13 @@ pub struct Configuration {
 
     #[serde(default)]
     pub database: DatabasePoolConfig,
+
+    /// Configurations for the HTTP client (e.g. HTTP timeout).
+    #[serde(default)]
+    pub http_client: HttpClient,
+
+    // Configurations for the order creation process.
+    pub order_quoting: OrderQuoting,
 }
 
 impl Configuration {
@@ -152,6 +160,8 @@ pub mod test_util {
                 // have the test_default trait impl
                 native_price_estimation: NativePriceConfig::test_default(),
                 database: TestDefault::test_default(),
+                http_client: Default::default(),
+                order_quoting: TestDefault::test_default(),
             }
         }
     }
@@ -195,6 +205,9 @@ mod tests {
 
         [native-price-estimation]
         estimators = [[{type = "CoinGecko"}]]
+
+        [order-quoting]
+        price-estimation-drivers = []
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -238,6 +251,9 @@ mod tests {
         let toml = r#"
         [native-price-estimation]
         estimators = [[{type = "CoinGecko"}]]
+
+        [order-quoting]
+        price-estimation-drivers = []
         "#;
         let config: Configuration = toml::from_str(toml).unwrap();
 
@@ -297,7 +313,9 @@ mod tests {
                 fallback_estimators: None,
                 ..NativePriceConfig::test_default()
             },
+            order_quoting: TestDefault::test_default(),
             database: TestDefault::test_default(),
+            http_client: Default::default(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
@@ -328,5 +346,6 @@ mod tests {
             config.eip1271_skip_creation_validation,
             deserialized.eip1271_skip_creation_validation
         );
+        assert_eq!(config.http_client.timeout, deserialized.http_client.timeout)
     }
 }
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 9990225c22..783480f443 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -34,6 +34,7 @@ bigdecimal = { workspace = true }
 bytes-hex = { workspace = true }  # may get marked as unused but it's used with serde
 chain = { workspace = true }
 chrono = { workspace = true, default-features = false, features = ["clock"] }
+configs = { workspace = true }
 const-hex = { workspace = true }
 cow-amm = { workspace = true }
 dashmap = { workspace = true }
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index e2d2972220..9b1025437d 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -24,6 +24,7 @@ use {
             native_price::NativePriceConfig,
             run_loop::RunLoopConfig,
         },
+        order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
     ethrpc::Web3,
@@ -329,14 +330,21 @@ impl<'a> Services<'a> {
             false,
         );
 
+        let test_quoter = ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver");
+
+        let autopilot_config = Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![test_quoter.clone()]),
+            ..autopilot_config
+        };
+        let orderbook_config = configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![test_quoter]),
+            ..orderbook_config
+        };
+
         self.start_autopilot(
             None,
             [
-                vec![
-                    "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                        .to_string(),
-                    "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-                ],
+                vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
                 args.autopilot,
             ]
             .concat(),
@@ -346,11 +354,7 @@ impl<'a> Services<'a> {
 
         self.start_api(
             [
-                vec![
-                    "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                        .to_string(),
-                    "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-                ],
+                vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
                 args.api,
             ]
             .concat(),
@@ -424,7 +428,7 @@ impl<'a> Services<'a> {
             ..Configuration::test("test_solver", solver.address())
         };
 
-        let (autopilot_args, api_args) = if run_baseline {
+        let drivers = if run_baseline {
             solvers.push(
                 colocation::start_baseline_solver(
                     "baseline_solver".into(),
@@ -439,24 +443,24 @@ impl<'a> Services<'a> {
 
             // Here we call the baseline_solver "test_quoter" to make the native price
             // estimation use the baseline_solver instead of the test_quoter
-            let autopilot_args = vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
-            ];
-            let api_args = vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/baseline_solver,test_solver|http://localhost:11088/test_solver".to_string(),
-            ];
-            (autopilot_args, api_args)
+            vec![
+                ExternalSolver::new("test_quoter", "http://localhost:11088/baseline_solver"),
+                ExternalSolver::new("test_solver", "http://localhost:11088/test_solver"),
+            ]
         } else {
-            let autopilot_args = vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ];
-
-            let api_args = vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ];
-            (autopilot_args, api_args)
+            vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]
+        };
+
+        let autopilot_config = Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(drivers.clone()),
+            ..autopilot_config
+        };
+        let orderbook_config = configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(drivers),
+            ..configs::orderbook::Configuration::test_default()
         };
 
         colocation::start_driver(
@@ -466,14 +470,9 @@ impl<'a> Services<'a> {
             false,
         );
 
-        self.start_autopilot(
-            Some(Duration::from_secs(11)),
-            autopilot_args,
-            autopilot_config,
-        )
-        .await;
-        self.start_api(api_args, configs::orderbook::Configuration::test_default())
+        self.start_autopilot(Some(Duration::from_secs(11)), vec![], autopilot_config)
             .await;
+        self.start_api(vec![], orderbook_config).await;
     }
 
     async fn wait_for_api_to_come_up() {
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 835195557c..6d2aacd9fa 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -2,6 +2,7 @@ use {
     autopilot::shutdown_controller::ShutdownController,
     configs::{
         autopilot::{Configuration, run_loop::RunLoopConfig},
+        order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
     e2e::setup::{
@@ -100,14 +101,17 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
         ..leader_config
     };
 
+    let leader_config = Configuration {
+        order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+            "test_quoter",
+            "http://localhost:11088/test_solver",
+        )]),
+        ..leader_config
+    };
     let autopilot_leader = services
         .start_autopilot_with_shutdown_controller(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
             leader_config,
             control,
         )
@@ -124,24 +128,29 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
         ..follower_config
     };
 
+    let follower_config = Configuration {
+        order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+            "test_quoter",
+            "http://localhost:11088/test_solver2",
+        )]),
+        ..follower_config
+    };
     let _autopilot_follower = services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver2"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
             follower_config,
         )
         .await;
 
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver1,test_solver2|http://localhost:11088/test_solver2".to_string(),
-            ],
+            vec![],
             configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![
+                    ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver1"),
+                    ExternalSolver::new("test_solver2", "http://localhost:11088/test_solver2"),
+                ]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     estimators: price_estimation::NativePriceEstimators::new(vec![vec![
                         price_estimation::NativePriceEstimator::forwarder(
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index 99aa97af55..df61247fd5 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -1,6 +1,10 @@
 use {
     ::alloy::primitives::U256,
-    configs::{autopilot::trusted_tokens::TrustedTokensConfig, test_util::TestDefault},
+    configs::{
+        autopilot::trusted_tokens::TrustedTokensConfig,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -64,10 +68,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
+            vec![],
             configs::autopilot::Configuration {
                 trusted_tokens: TrustedTokensConfig {
                     tokens: vec![
@@ -77,17 +78,24 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
                     ],
                     ..Default::default()
                 },
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
                 ..configs::autopilot::Configuration::test("test_solver", solver.address())
             },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index 12b01a28ee..2c7d4e76a3 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -2,7 +2,10 @@
 //! headers.
 
 use {
-    configs::test_util::TestDefault,
+    configs::{
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     reqwest::{Method, StatusCode},
     shared::web3::Web3,
@@ -21,12 +24,14 @@ async fn cors_preflight(web3: Web3) {
     // we don't really need the rest of the protocol
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
     let client = services.client();
@@ -82,12 +87,14 @@ async fn cors_headers_on_error(web3: Web3) {
     // we don't really need the rest of the protocol
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
     let client = services.client();
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 4880e20ec9..e910a3a74a 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -8,6 +8,7 @@ use {
     },
     configs::{
         autopilot::{Configuration, solver::Solver},
+        order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
     contracts::alloy::{
@@ -189,20 +190,26 @@ async fn cow_amm_jit(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            Configuration::test("mock_solver", solver.address()),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("mock_solver", solver.address())
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
@@ -564,10 +571,7 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
+            vec![],
             Configuration {
                 drivers: vec![
                     Solver::test("test_solver", solver.address()),
@@ -581,17 +585,24 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
                     }],
                     ..Default::default()
                 },
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
                 ..Configuration::test_no_drivers()
             },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
@@ -844,20 +855,26 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
-                    .to_string(),
-            ],
-            Configuration::test("mock_solver", solver.address()),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "mock_solver",
+                    "http://localhost:11088/mock_solver",
+                )]),
+                ..Configuration::test("mock_solver", solver.address())
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=mock_solver|http://localhost:11088/mock_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "mock_solver",
+                    "http://localhost:11088/mock_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index dfa50c55eb..a8241a3d3a 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -1,6 +1,10 @@
 use {
     ::alloy::primitives::U256,
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     e2e::setup::{colocation::SolverEngine, mock::Mock, solution::JitOrder, *},
     ethrpc::alloy::CallBuilderExt,
     model::{
@@ -93,20 +97,26 @@ async fn single_limit_order_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            Configuration::test("mock_solver", solver.address()),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("mock_solver", solver.address())
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 24e8c180ac..b083ba9196 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -12,6 +12,7 @@ use {
             run_loop::RunLoopConfig,
             solver::{Account, Solver},
         },
+        order_quoting::{ExternalSolver, OrderQuoting},
         orderbook::order_validation::OrderValidationConfig,
         test_util::TestDefault,
     },
@@ -508,10 +509,12 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-            ],
+            vec![],
             configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "solver1",
+                    "http://localhost:11088/test_solver",
+                )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     estimators: price_estimation::NativePriceEstimators::new(vec![vec![
                         price_estimation::NativePriceEstimator::driver(
@@ -565,9 +568,7 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-            ],
+            vec![],
             Configuration {
                 drivers: vec![
                     Solver::new(
@@ -577,6 +578,10 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
                     ),
                     Solver::test("solver2", solver_b.address()),
                 ],
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "solver1",
+                    "http://localhost:11088/test_solver",
+                )]),
                 run_loop: RunLoopConfig {
                     max_winners_per_auction: std::num::NonZeroUsize::new(2).unwrap(),
                     ..config.run_loop
@@ -749,20 +754,24 @@ async fn too_many_limit_orders_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            Configuration::test("test_solver", solver_address),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("test_solver", solver_address)
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
+            vec![],
             configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
                 order_validation: OrderValidationConfig {
                     max_limit_orders_per_user: 1,
                     ..Default::default()
@@ -852,20 +861,24 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            Configuration::test("test_solver", solver_address),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("test_solver", solver_address)
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
+            vec![],
             configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
                 order_validation: OrderValidationConfig {
                     max_limit_orders_per_user: 1,
                     ..Default::default()
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index d62113bb3e..a18adbbd43 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -7,7 +7,11 @@ use {
         },
     },
     chrono::{NaiveDateTime, Utc},
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     contracts::alloy::{ERC20, IZeroex},
     e2e::{
         api::zeroex::{Eip712TypedZeroExOrder, ZeroExApi},
@@ -195,20 +199,26 @@ async fn zero_ex_liquidity(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            Configuration::test("test_solver", solver.address()),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("test_solver", solver.address())
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index ad77d10afe..79b1eb1438 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -5,7 +5,11 @@ use {
         signers::SignerSync,
     },
     chrono::Utc,
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     contracts::alloy::{ERC20, LiquoriceSettlement},
     driver::infra,
     e2e::{
@@ -206,20 +210,26 @@ http-timeout = "10s"
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            Configuration::test("liquorice_solver", solver.address()),
+            vec![],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("liquorice_solver", solver.address())
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index f658025c38..4e32290aa6 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -2,7 +2,10 @@
 //! responses are preserved.
 
 use {
-    configs::test_util::TestDefault,
+    configs::{
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     model::order::{ORDER_UID_LIMIT, OrderUid},
     orderbook::api::Error,
@@ -29,12 +32,14 @@ async fn http_validation(web3: Web3) {
     // we don't really need the rest of the protocol
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
     let client = services.client();
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index 4934444914..18faeb7ecf 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -1,6 +1,10 @@
 use {
     ::alloy::primitives::U256,
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     database::order_events::OrderEventLabel,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
@@ -69,23 +73,29 @@ async fn order_cancellation(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
+            vec![],
             // Empty drivers to prevent settlement — this test places multiple
             // orders and asserts exact auction counts, which would race with the
             // solver settling them.
-            Configuration::test_no_drivers(),
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test_no_drivers()
+            },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 3699107a72..8830ae3258 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -1,7 +1,11 @@
 use {
     ::alloy::primitives::U256,
     autopilot::shutdown_controller::ShutdownController,
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     driver::domain::eth::NonZeroU256,
     e2e::setup::{colocation, wait_for_condition, *},
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
@@ -222,24 +226,26 @@ async fn fallback_native_price_estimator(web3: Web3) {
     let autopilot_handle = services
         .start_autopilot_with_shutdown_controller(
             None,
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
-            Configuration::test("test_solver", solver.address()),
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
+            Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..Configuration::test("test_solver", solver.address())
+            },
             control,
         )
         .await;
 
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver"
-                    .to_string(),
-                "--gas-estimators=http://localhost:11088/gasprice".to_string(),
-            ],
+            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
             configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_solver",
+                )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     fallback_estimators: Some(price_estimation::NativePriceEstimators::new(vec![
                         vec![price_estimation::NativePriceEstimator::driver(
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index b145205d1b..2c8f29aaa1 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -1,5 +1,10 @@
 use {
-    configs::{autopilot::Configuration, fee_factor::FeeFactor, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        fee_factor::FeeFactor,
+        order_quoting::{ExternalSolver, OrderQuoting},
+        test_util::TestDefault,
+    },
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
     ethrpc::alloy::CallBuilderExt,
     futures::FutureExt,
@@ -320,12 +325,12 @@ async fn quote_timeout(web3: Web3) {
 
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_quoter"
-                    .to_string(),
-                format!("--quote-timeout={MAX_QUOTE_TIME_MS}ms"),
-            ],
+            vec![format!("--quote-timeout={MAX_QUOTE_TIME_MS}ms")],
             configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_quoter",
+                )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     estimators: price_estimation::NativePriceEstimators::new(vec![vec![
                         price_estimation::NativePriceEstimator::driver(
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 7059e59b9b..60d2684732 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -6,6 +6,7 @@ use {
             run_loop::RunLoopConfig,
             solver::{Account, Solver},
         },
+        order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
     e2e::setup::{colocation::SolverEngine, mock::Mock, *},
@@ -90,25 +91,33 @@ async fn solver_competition(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
-    services.start_autopilot(
-        None,
-        vec![
-            "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
-        ],
-        Configuration {
-            drivers: vec![
-                Solver::test("test_solver", solver.address()),
-                Solver::test("solver2", solver.address()),
-            ],
-            ..Configuration::test_no_drivers()
-        }
-    ).await;
+    services
+        .start_autopilot(
+            None,
+            vec![],
+            Configuration {
+                drivers: vec![
+                    Solver::test("test_solver", solver.address()),
+                    Solver::test("solver2", solver.address()),
+                ],
+                order_quoting: OrderQuoting::test_with_drivers(vec![
+                    ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver"),
+                    ExternalSolver::new("solver2", "http://localhost:11088/solver2"),
+                ]),
+                ..Configuration::test_no_drivers()
+            },
+        )
+        .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_quoter|http://localhost:11088/test_solver,solver2|http://localhost:11088/solver2".to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![
+                    ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver"),
+                    ExternalSolver::new("solver2", "http://localhost:11088/solver2"),
+                ]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
@@ -244,9 +253,7 @@ async fn wrong_solution_submission_address(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-            ],
+            vec![],
             Configuration {
                 drivers: vec![
                     // Solver 1 has a wrong submission address, meaning that the solutions should
@@ -258,16 +265,24 @@ async fn wrong_solution_submission_address(web3: Web3) {
                     ),
                     Solver::test("solver2", solver.address()),
                 ],
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "solver1",
+                    "http://localhost:11088/test_solver",
+                )]),
                 ..Configuration::test_no_drivers()
             },
         )
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=solver1|http://localhost:11088/test_solver".to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "solver1",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
@@ -411,15 +426,16 @@ async fn store_filtered_solutions(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
+            vec![],
             Configuration {
                 drivers: vec![
                     Solver::test("good_solver", good_solver_account.address()),
                     Solver::test("bad_solver", bad_solver_account.address()),
                 ],
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
                 run_loop: RunLoopConfig {
                     max_winners_per_auction: std::num::NonZeroUsize::new(10).unwrap(),
                     ..config.run_loop
@@ -430,11 +446,14 @@ async fn store_filtered_solutions(web3: Web3) {
         .await;
     services
         .start_api(
-            vec![
-                "--price-estimation-drivers=test_solver|http://localhost:11088/test_solver"
-                    .to_string(),
-            ],
-            configs::orderbook::Configuration::test_default(),
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_solver",
+                    "http://localhost:11088/test_solver",
+                )]),
+                ..configs::orderbook::Configuration::test_default()
+            },
         )
         .await;
 
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index adb8eb9584..fd49c96a34 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,6 +1,5 @@
 use {
     price_estimation,
-    shared::http_client,
     std::{net::SocketAddr, path::PathBuf},
 };
 
@@ -9,12 +8,6 @@ pub struct Arguments {
     #[clap(flatten)]
     pub shared: shared::arguments::Arguments,
 
-    #[clap(flatten)]
-    pub order_quoting: shared::arguments::OrderQuotingArguments,
-
-    #[clap(flatten)]
-    pub http_client: http_client::Arguments,
-
     #[clap(flatten)]
     pub price_estimation: price_estimation::Arguments,
 
@@ -30,16 +23,12 @@ impl std::fmt::Display for Arguments {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let Arguments {
             shared,
-            order_quoting,
-            http_client,
             price_estimation,
             config,
             bind_address,
         } = self;
 
         write!(f, "{shared}")?;
-        write!(f, "{order_quoting}")?;
-        write!(f, "{http_client}")?;
         write!(f, "{price_estimation}")?;
         writeln!(f, "config: {}", config.display())?;
         writeln!(f, "bind_address: {bind_address}")?;
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 1ef345df07..b01915d4de 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -69,7 +69,7 @@ pub async fn start(args: impl Iterator<Item = String>) {
 }
 
 pub async fn run(args: Arguments, config: Configuration) {
-    let http_factory = HttpClientFactory::new(&args.http_client);
+    let http_factory = HttpClientFactory::from(config.http_client);
 
     let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
     let simulation_web3 = args
@@ -276,7 +276,7 @@ pub async fn run(args: Arguments, config: Configuration) {
 
     let price_estimator = price_estimator_factory
         .price_estimator(
-            &args
+            &config
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
@@ -291,7 +291,7 @@ pub async fn run(args: Arguments, config: Configuration) {
         .unwrap();
     let fast_price_estimator = price_estimator_factory
         .fast_price_estimator(
-            &args
+            &config
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
@@ -321,15 +321,15 @@ pub async fn run(args: Arguments, config: Configuration) {
             Arc::new(postgres_write.clone()),
             order_quoting::Validity {
                 eip1271_onchain_quote: chrono::Duration::from_std(
-                    args.order_quoting.eip1271_onchain_quote_validity,
+                    config.order_quoting.eip1271_onchain_quote_validity,
                 )
                 .unwrap(),
                 presign_onchain_quote: chrono::Duration::from_std(
-                    args.order_quoting.presign_onchain_quote_validity,
+                    config.order_quoting.presign_onchain_quote_validity,
                 )
                 .unwrap(),
                 standard_quote: chrono::Duration::from_std(
-                    args.order_quoting.standard_offchain_quote_validity,
+                    config.order_quoting.standard_offchain_quote_validity,
                 )
                 .unwrap(),
             },
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 3c280cdad8..da0e8f2493 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -49,51 +49,6 @@ macro_rules! logging_args_with_default_filter {
     };
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExternalSolver {
-    pub name: String,
-    pub url: Url,
-}
-
-// The following arguments are used to configure the order creation process
-// The arguments are shared between the orderbook crate and the autopilot crate,
-// as both crates can create orders
-#[derive(clap::Parser)]
-pub struct OrderQuotingArguments {
-    /// A list of external drivers used for price estimation in the following
-    /// format: `<NAME>|<URL>,<NAME>|<URL>`
-    #[clap(long, env, use_value_delimiter = true)]
-    pub price_estimation_drivers: Vec<ExternalSolver>,
-
-    /// The time period an EIP1271-quote request is valid.
-    #[clap(
-        long,
-        env,
-        default_value = "10m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub eip1271_onchain_quote_validity: Duration,
-
-    /// The time period an PRESIGN-quote request is valid.
-    #[clap(
-        long,
-        env,
-        default_value = "10m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub presign_onchain_quote_validity: Duration,
-
-    /// The time period a regular offchain-quote request (ethsign/eip712) is
-    /// valid.
-    #[clap(
-        long,
-        env,
-        default_value = "1m",
-        value_parser = humantime::parse_duration,
-    )]
-    pub standard_offchain_quote_validity: Duration,
-}
-
 logging_args_with_default_filter!(
     LoggingArguments,
     "info,autopilot=debug,driver=debug,observe=info,orderbook=debug,solver=debug,shared=debug,\
@@ -269,31 +224,6 @@ where
     Ok(())
 }
 
-impl Display for OrderQuotingArguments {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let Self {
-            eip1271_onchain_quote_validity,
-            presign_onchain_quote_validity,
-            price_estimation_drivers,
-            standard_offchain_quote_validity,
-        } = self;
-
-        writeln!(
-            f,
-            "eip1271_onchain_quote_validity_second: {eip1271_onchain_quote_validity:?}"
-        )?;
-        writeln!(
-            f,
-            "presign_onchain_quote_validity_second: {presign_onchain_quote_validity:?}"
-        )?;
-        display_list(f, "price_estimation_drivers", price_estimation_drivers)?;
-        writeln!(
-            f,
-            "standard_offchain_quote_validity: {standard_offchain_quote_validity:?}"
-        )?;
-        Ok(())
-    }
-}
 // We have a custom Display implementation so that we can log the arguments on
 // start up without leaking any potentially secret values.
 impl Display for Arguments {
@@ -373,31 +303,6 @@ impl Display for Arguments {
     }
 }
 
-impl Display for ExternalSolver {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}({})", self.name, self.url)
-    }
-}
-
-impl FromStr for ExternalSolver {
-    type Err = anyhow::Error;
-
-    fn from_str(solver: &str) -> Result<Self> {
-        let parts: Vec<&str> = solver.split('|').collect();
-        ensure!(
-            parts.len() == 2,
-            "wrong number of arguments for external solver"
-        );
-        let (name, url) = (parts[0], parts[1]);
-        let url: Url = url.parse()?;
-
-        Ok(Self {
-            name: name.to_owned(),
-            url,
-        })
-    }
-}
-
 /// Helper type for parsing token bucket fee overrides from strings
 #[derive(Debug, Clone)]
 pub struct TokenBucketFeeOverride {
@@ -443,21 +348,6 @@ impl FromStr for TokenBucketFeeOverride {
 mod test {
     use {super::*, alloy::primitives::address};
 
-    #[test]
-    fn parse_drivers_wrong_arguments() {
-        // too few arguments
-        assert!(ExternalSolver::from_str("").is_err());
-        assert!(ExternalSolver::from_str("name").is_err());
-
-        // broken URL
-        assert!(ExternalSolver::from_str("name1|sdfsdfds").is_err());
-
-        // too many arguments
-        assert!(
-            ExternalSolver::from_str("name1|http://localhost:8080|additional_argument").is_err()
-        );
-    }
-
     #[test]
     fn parse_token_bucket_fee_override() {
         // Valid inputs with 2 tokens (minimum required)
diff --git a/crates/shared/src/http_client.rs b/crates/shared/src/http_client.rs
index 82586cc0d9..570a289fcb 100644
--- a/crates/shared/src/http_client.rs
+++ b/crates/shared/src/http_client.rs
@@ -53,6 +53,14 @@ impl Default for HttpClientFactory {
     }
 }
 
+impl From<configs::http_client::HttpClient> for HttpClientFactory {
+    fn from(value: configs::http_client::HttpClient) -> Self {
+        Self {
+            timeout: value.timeout,
+        }
+    }
+}
+
 /// Command line arguments for the common HTTP factory.
 #[derive(clap::Parser)]
 #[group(skip)]

From 64466d108693c788eab22b5744de7693a7ed0ff5 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 12 Mar 2026 09:38:22 +0000
Subject: [PATCH 142/219] Fix Bitget API signature when using proxy endpoint
 (#4256)

# Description

- Use the canonical Bitget API path (/bgw-pro/swapx/pro/) for HMAC
signature computation instead of deriving it from the configured
endpoint URL
- When a proxy is configured, the request URL path differs from what
Bitget expects in the signature, causing authentication failures
- The HTTP request still goes to the configured (possibly proxied) URL -
only the signature computation changes
- I think it was in one of the original PR comments, but I forgot about
it somehow

## How to test
Existing tests. Staging.
---
 crates/solvers/src/infra/dex/bitget/mod.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/solvers/src/infra/dex/bitget/mod.rs b/crates/solvers/src/infra/dex/bitget/mod.rs
index cd16f6b065..ab8ae42d65 100644
--- a/crates/solvers/src/infra/dex/bitget/mod.rs
+++ b/crates/solvers/src/infra/dex/bitget/mod.rs
@@ -38,6 +38,11 @@ mod dto;
 /// Default Bitget swap API base endpoint.
 pub const DEFAULT_ENDPOINT: &str = "https://bopenapi.bgwapi.io/bgw-pro/swapx/pro/";
 
+/// Default API path used for signature computation. When a proxy endpoint is
+/// configured, the request URL differs from the canonical path that Bitget
+/// expects in the signature.
+const SIGNATURE_API_PATH: &str = "/bgw-pro/swapx/pro/";
+
 /// Bitget API path for getting swap calldata.
 const SWAP_PATH: &str = "swap";
 
@@ -234,8 +239,8 @@ impl Bitget {
 
         let body_str = serde_json::to_string(body).map_err(|_| Error::RequestBuildFailed)?;
         let timestamp = chrono::Utc::now().timestamp_millis().to_string();
-        let api_path = url.path();
-        let signature = self.generate_signature(api_path, &body_str, &timestamp)?;
+        let signature_path = format!("{SIGNATURE_API_PATH}{endpoint}");
+        let signature = self.generate_signature(&signature_path, &body_str, &timestamp)?;
 
         let request_builder = self
             .client

From 73f1ecde3fcbf78fb8ee9dce7581fdc6bc32c4e7 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 12 Mar 2026 15:31:18 +0100
Subject: [PATCH 143/219] Store reasons why an order was removed from auction
 (#4251)

# Description

When orders get filtered from an auction or marked invalid, we now
record why it happened. This PR adds a reason column to the order_events
table so we can distinguish between e.g. insufficient_balance,
banned_user, missing_price etc.

Currently these reasons are only visible in the DB / metrics.

# Changes
<!-- List of detailed changes (how the change is accomplished) -->

[x] New migration (V107): adds OrderFilterReason enum type and reason
column to order_events
[x] `solvable_orders` tracks the specific OrderFilterReason alongside
each filtered/invalid order UID
[x] Added a new filter reason when we filter an order out because it's
already in-flight (= being submitted)
[x] Added to order debug endopint

## How to test

```
cargo nextest run -p e2e local_node_debug_order --test-threads 1 --run-ignored ignored-only
```
---
 crates/autopilot/src/database/order_events.rs |   5 +-
 crates/autopilot/src/infra/persistence/mod.rs |   8 +-
 crates/autopilot/src/periodic_db_cleanup.rs   |   3 +
 crates/autopilot/src/solvable_orders.rs       |  97 ++++++++-----
 crates/database/src/onchain_invalidations.rs  |   1 +
 crates/database/src/order_events.rs           |  96 +++++++++++--
 crates/database/src/orders.rs                 |   1 +
 crates/e2e/tests/e2e/debug_order.rs           | 133 +++++++++++++++++-
 crates/model/src/debug_report.rs              |   2 +
 crates/orderbook/openapi.yml                  |   6 +
 crates/orderbook/src/database/debug_report.rs |   1 +
 crates/orderbook/src/database/orders.rs       |   2 +
 database/README.md                            |  23 ++-
 .../sql/V107__add_reason_to_order_events.sql  |  11 ++
 14 files changed, 326 insertions(+), 63 deletions(-)
 create mode 100644 database/sql/V107__add_reason_to_order_events.sql

diff --git a/crates/autopilot/src/database/order_events.rs b/crates/autopilot/src/database/order_events.rs
index 79523a6585..52c7878378 100644
--- a/crates/autopilot/src/database/order_events.rs
+++ b/crates/autopilot/src/database/order_events.rs
@@ -1,4 +1,4 @@
-pub use database::order_events::OrderEventLabel;
+pub use database::order_events::{OrderEventLabel, OrderFilterReason};
 use {
     crate::domain,
     anyhow::Result,
@@ -19,6 +19,7 @@ pub async fn store_order_events(
     ex: &mut PgConnection,
     order_uids: Vec<domain::OrderUid>,
     label: OrderEventLabel,
+    reason: Option<OrderFilterReason>,
     timestamp: DateTime<Utc>,
 ) {
     let start = Instant::now();
@@ -28,7 +29,7 @@ pub async fn store_order_events(
     let insert = async move {
         let mut ex = ex.begin().await?;
         for chunk in order_uids.chunks(1000) {
-            order_events::insert_order_events(&mut ex, chunk, timestamp, label).await?;
+            order_events::insert_order_events(&mut ex, chunk, timestamp, label, reason).await?;
         }
         ex.commit().await
     };
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index cfc547619f..7542ee5e13 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -14,7 +14,7 @@ use {
     database::{
         events::EventIndex,
         leader_pg_lock::LeaderLock,
-        order_events::OrderEventLabel,
+        order_events::{OrderEventLabel, OrderFilterReason},
         order_execution::Asset,
         orders::{
             BuyTokenDestination as DbBuyTokenDestination,
@@ -295,7 +295,7 @@ impl Persistence {
         label: boundary::OrderEventLabel,
     ) {
         let order_uids: Vec<_> = order_uids.into_iter().collect();
-        self.store_order_events_owned(order_uids, std::convert::identity, label);
+        self.store_order_events_owned(order_uids, std::convert::identity, label, None);
     }
 
     /// A variants of [`store_order_events`] where [`items`] is already an owned
@@ -307,6 +307,7 @@ impl Persistence {
         items: I,
         convert: F,
         label: boundary::OrderEventLabel,
+        reason: Option<OrderFilterReason>,
     ) where
         I: IntoIterator + Send + 'static,
         I::Item: Send,
@@ -318,7 +319,7 @@ impl Persistence {
                 let order_uids = items.into_iter().map(convert).collect();
                 match db.pool.acquire().await {
                     Ok(mut tx) => {
-                        store_order_events(&mut tx, order_uids, label, Utc::now()).await;
+                        store_order_events(&mut tx, order_uids, label, reason, Utc::now()).await;
                     }
                     Err(err) => {
                         tracing::error!(
@@ -824,6 +825,7 @@ impl Persistence {
                 &mut ex,
                 fee_breakdown.keys().cloned().collect(),
                 OrderEventLabel::Traded,
+                None,
                 Utc::now(),
             )
             .await;
diff --git a/crates/autopilot/src/periodic_db_cleanup.rs b/crates/autopilot/src/periodic_db_cleanup.rs
index a2c76b86ea..f6810f9ed3 100644
--- a/crates/autopilot/src/periodic_db_cleanup.rs
+++ b/crates/autopilot/src/periodic_db_cleanup.rs
@@ -93,6 +93,7 @@ mod tests {
             order_uid: ByteArray([1; 56]),
             timestamp: now - chrono::Duration::milliseconds(300),
             label: OrderEventLabel::Created,
+            reason: None,
         };
         database::order_events::insert_order_event(&mut ex, &event_a)
             .await
@@ -101,6 +102,7 @@ mod tests {
             order_uid: ByteArray([2; 56]),
             timestamp: now - chrono::Duration::milliseconds(100),
             label: OrderEventLabel::Created,
+            reason: None,
         };
         database::order_events::insert_order_event(&mut ex, &event_b)
             .await
@@ -109,6 +111,7 @@ mod tests {
             order_uid: ByteArray([3; 56]),
             timestamp: now,
             label: OrderEventLabel::Created,
+            reason: None,
         };
         database::order_events::insert_order_event(&mut ex, &event_c)
             .await
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 3167033aa2..960de22216 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -8,7 +8,19 @@ use {
     alloy::primitives::{Address, U256},
     anyhow::{Context, Result},
     bad_tokens::list_based::DenyListedTokens,
-    database::order_events::OrderEventLabel,
+    database::order_events::{
+        OrderEventLabel,
+        OrderFilterReason::{
+            self,
+            BannedUser,
+            DustOrder,
+            InFlight,
+            InsufficientBalance,
+            InvalidSignature,
+            MissingNativePrice,
+            UnsupportedToken,
+        },
+    },
     futures::FutureExt,
     itertools::Itertools,
     model::{
@@ -32,7 +44,6 @@ use {
     tokio::sync::Mutex,
     tracing::instrument,
 };
-
 #[derive(prometheus_metric_storage::MetricStorage)]
 pub struct Metrics {
     /// Tracks success and failure of the solvable orders cache update task.
@@ -79,14 +90,14 @@ impl Metrics {
     }
 
     #[instrument(skip_all)]
-    fn track_filtered_orders(reason: &'static str, invalid_orders: &[OrderUid]) {
+    fn track_filtered_orders(reason: OrderFilterReason, invalid_orders: &[OrderUid]) {
         if invalid_orders.is_empty() {
             return;
         }
 
         Metrics::get()
             .auction_filtered_orders
-            .with_label_values(&[reason])
+            .with_label_values(&[reason.as_str()])
             .set(i64::try_from(invalid_orders.len()).unwrap_or(i64::MAX));
 
         tracing::debug!(
@@ -208,8 +219,8 @@ impl SolvableOrdersCache {
             .map(|order| order.as_ref())
             .collect();
 
-        let mut invalid_order_uids = HashSet::new();
-        let mut filtered_order_events = Vec::new();
+        let mut invalid_order_uids = HashMap::new();
+        let mut filtered_order_events: Vec<(OrderUid, OrderFilterReason)> = Vec::new();
 
         let balance_filter_exempt_orders: HashSet<_> = orders
             .iter()
@@ -238,10 +249,11 @@ impl SolvableOrdersCache {
         // Remove in-flight orders - already won a previous auction, being settled
         // on-chain.
         let (orders, removed) = filter_out_in_flight_orders(orders, &in_flight);
-        Metrics::track_filtered_orders("in_flight", &removed);
+        Metrics::track_filtered_orders(InFlight, &removed);
+        filtered_order_events.extend(removed.into_iter().map(|uid| (uid, InFlight)));
         // It's possible that some orders got marked as invalid due to missing balance
         // or so, but the order is perfectly fine if it's in-flight
-        invalid_order_uids.retain(|uid| !in_flight.contains(uid));
+        invalid_order_uids.retain(|uid, _| !in_flight.contains(uid));
 
         let orders = if self.disable_order_balance_filter {
             orders
@@ -252,12 +264,12 @@ impl SolvableOrdersCache {
                 self.settlement_contract,
                 &balance_filter_exempt_orders,
             );
-            Metrics::track_filtered_orders("insufficient_balance", &removed);
-            invalid_order_uids.extend(removed);
+            Metrics::track_filtered_orders(InsufficientBalance, &removed);
+            invalid_order_uids.extend(removed.into_iter().map(|uid| (uid, InsufficientBalance)));
 
             let (orders, removed) = filter_dust_orders(orders, &balances);
-            Metrics::track_filtered_orders("dust_order", &removed);
-            filtered_order_events.extend(removed);
+            Metrics::track_filtered_orders(DustOrder, &removed);
+            filtered_order_events.extend(removed.into_iter().map(|uid| (uid, DustOrder)));
 
             orders
         };
@@ -295,24 +307,14 @@ impl SolvableOrdersCache {
 
             entry.insert(weth_price);
         }
-        Metrics::track_filtered_orders("missing_price", &removed);
-        filtered_order_events.extend(removed);
+        Metrics::track_filtered_orders(MissingNativePrice, &removed);
+        filtered_order_events.extend(removed.into_iter().map(|uid| (uid, MissingNativePrice)));
 
         Metrics::track_orders_in_final_auction(&orders);
 
         if store_events {
-            // spawning a background task since `order_events` table insert operation takes
-            // a while and the result is ignored.
-            self.persistence.store_order_events_owned(
-                invalid_order_uids,
-                |uid| domain::OrderUid(uid.0),
-                OrderEventLabel::Invalid,
-            );
-            self.persistence.store_order_events_owned(
-                filtered_order_events,
-                |uid| domain::OrderUid(uid.0),
-                OrderEventLabel::Filtered,
-            );
+            self.store_events_by_reason(invalid_order_uids, OrderEventLabel::Invalid);
+            self.store_events_by_reason(filtered_order_events, OrderEventLabel::Filtered);
         }
 
         let in_flight_owners: HashSet<_> = in_flight
@@ -464,7 +466,7 @@ impl SolvableOrdersCache {
     async fn filter_invalid_orders<'a>(
         &self,
         mut orders: Vec<&'a Order>,
-        invalid_order_uids: &mut HashSet<OrderUid>,
+        invalid_order_uids: &mut HashMap<OrderUid, OrderFilterReason>,
     ) -> Vec<&'a Order> {
         let presignature_pending_orders = find_presignature_pending_orders(&orders);
 
@@ -477,14 +479,22 @@ impl SolvableOrdersCache {
             .await;
         tracing::trace!("filtered invalid orders");
 
-        Metrics::track_filtered_orders("banned_user", &banned_user_orders);
-        Metrics::track_filtered_orders("invalid_signature", &presignature_pending_orders);
-        Metrics::track_filtered_orders("unsupported_token", &unsupported_token_orders);
-        invalid_order_uids.extend(banned_user_orders);
-        invalid_order_uids.extend(presignature_pending_orders);
-        invalid_order_uids.extend(unsupported_token_orders);
+        Metrics::track_filtered_orders(BannedUser, &banned_user_orders);
+        Metrics::track_filtered_orders(InvalidSignature, &presignature_pending_orders);
+        Metrics::track_filtered_orders(UnsupportedToken, &unsupported_token_orders);
+        invalid_order_uids.extend(banned_user_orders.into_iter().map(|uid| (uid, BannedUser)));
+        invalid_order_uids.extend(
+            presignature_pending_orders
+                .into_iter()
+                .map(|uid| (uid, InvalidSignature)),
+        );
+        invalid_order_uids.extend(
+            unsupported_token_orders
+                .into_iter()
+                .map(|uid| (uid, UnsupportedToken)),
+        );
 
-        orders.retain(|order| !invalid_order_uids.contains(&order.metadata.uid));
+        orders.retain(|order| !invalid_order_uids.contains_key(&order.metadata.uid));
         orders
     }
 
@@ -503,6 +513,25 @@ impl SolvableOrdersCache {
             .start_timer();
         fut.await
     }
+
+    fn store_events_by_reason(
+        &self,
+        orders: impl IntoIterator<Item = (OrderUid, OrderFilterReason)>,
+        label: OrderEventLabel,
+    ) {
+        let mut by_reason: HashMap<OrderFilterReason, Vec<OrderUid>> = HashMap::new();
+        for (uid, reason) in orders {
+            by_reason.entry(reason).or_default().push(uid);
+        }
+        for (reason, uids) in by_reason {
+            self.persistence.store_order_events_owned(
+                uids,
+                |uid| domain::OrderUid(uid.0),
+                label,
+                Some(reason),
+            );
+        }
+    }
 }
 
 /// Finds all orders whose owners or receivers are in the set of "banned"
diff --git a/crates/database/src/onchain_invalidations.rs b/crates/database/src/onchain_invalidations.rs
index 548d24d648..dd0b3a34bf 100644
--- a/crates/database/src/onchain_invalidations.rs
+++ b/crates/database/src/onchain_invalidations.rs
@@ -32,6 +32,7 @@ pub async fn insert_onchain_invalidations(
                 // this is more involved, and now() should be good enough.
                 timestamp: Utc::now(),
                 order_uid: *event,
+                reason: None,
             },
         )
         .await?;
diff --git a/crates/database/src/order_events.rs b/crates/database/src/order_events.rs
index d180c51912..930c18ebb0 100644
--- a/crates/database/src/order_events.rs
+++ b/crates/database/src/order_events.rs
@@ -5,6 +5,7 @@ use {
     crate::{OrderUid, byte_array::ByteArray},
     chrono::Utc,
     sqlx::{PgConnection, PgPool, types::chrono::DateTime},
+    std::fmt::Display,
     tracing::instrument,
 };
 
@@ -33,9 +34,43 @@ pub enum OrderEventLabel {
     Cancelled,
 }
 
+/// Why an order was filtered or marked invalid.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, sqlx::Type)]
+#[sqlx(type_name = "OrderFilterReason")]
+#[sqlx(rename_all = "snake_case")]
+pub enum OrderFilterReason {
+    InFlight,
+    BannedUser,
+    InvalidSignature,
+    UnsupportedToken,
+    InsufficientBalance,
+    DustOrder,
+    MissingNativePrice,
+}
+
+impl OrderFilterReason {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::InFlight => "in_flight",
+            Self::BannedUser => "banned_user",
+            Self::InvalidSignature => "invalid_signature",
+            Self::UnsupportedToken => "unsupported_token",
+            Self::InsufficientBalance => "insufficient_balance",
+            Self::DustOrder => "dust_order",
+            Self::MissingNativePrice => "missing_native_price",
+        }
+    }
+}
+
+impl Display for OrderFilterReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
 /// Contains a single event of the life cycle of an order and when it was
 /// registered.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, sqlx::Type, sqlx::FromRow)]
+#[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, sqlx::FromRow)]
 pub struct OrderEvent {
     /// Which order this event belongs to
     pub order_uid: OrderUid,
@@ -44,15 +79,25 @@ pub struct OrderEvent {
     pub timestamp: DateTime<Utc>,
     /// What kind of event happened
     pub label: OrderEventLabel,
+    /// Why the order was filtered/invalidated (only set for Filtered/Invalid
+    /// labels)
+    pub reason: Option<OrderFilterReason>,
 }
 
 /// Inserts a row into the `order_events` table only if the latest event for the
-/// corresponding order UID has a different label than the provided event..
+/// corresponding order UID has a different label than the provided event.
 pub async fn insert_order_event(
     ex: &mut PgConnection,
     event: &OrderEvent,
 ) -> Result<(), sqlx::Error> {
-    insert_order_events(ex, &[event.order_uid], event.timestamp, event.label).await
+    insert_order_events(
+        ex,
+        &[event.order_uid],
+        event.timestamp,
+        event.label,
+        event.reason,
+    )
+    .await
 }
 
 pub async fn insert_order_events(
@@ -60,29 +105,32 @@ pub async fn insert_order_events(
     orders: &[OrderUid],
     timestamp: DateTime<Utc>,
     label: OrderEventLabel,
+    reason: Option<OrderFilterReason>,
 ) -> Result<(), sqlx::Error> {
     const QUERY: &str = r#"
     WITH latest_events AS (
-        SELECT DISTINCT ON (order_uid) order_uid, label
+        SELECT DISTINCT ON (order_uid) order_uid, label, reason
         FROM order_events
         WHERE order_uid = ANY($1)
         ORDER BY order_uid, timestamp DESC
     ),
     incoming AS (
-        SELECT t.order_uid, $2 AS timestamp, $3 AS label
+        SELECT t.order_uid, $2 AS timestamp, $3 AS label, $4 AS reason
         FROM unnest($1) AS t(order_uid)
     )
-    INSERT INTO order_events (order_uid, timestamp, label)
-    SELECT DISTINCT i.order_uid, i.timestamp, i.label
+    INSERT INTO order_events (order_uid, timestamp, label, reason)
+    SELECT DISTINCT i.order_uid, i.timestamp, i.label, i.reason
     FROM incoming i
     LEFT JOIN latest_events le ON le.order_uid = i.order_uid
     WHERE le.label IS DISTINCT FROM i.label
+       OR le.reason IS DISTINCT FROM i.reason
     "#;
 
     sqlx::query(QUERY)
         .bind(orders)
         .bind(timestamp)
         .bind(label)
+        .bind(reason)
         .execute(ex)
         .await?;
     Ok(())
@@ -156,24 +204,28 @@ mod tests {
             order_uid: uid_a,
             timestamp: now - chrono::Duration::milliseconds(300),
             label: OrderEventLabel::Created,
+            reason: None,
         };
         insert_order_event(&mut ex, &event_a).await.unwrap();
         let event_b = OrderEvent {
             order_uid: uid_a,
             timestamp: now - chrono::Duration::milliseconds(200),
             label: OrderEventLabel::Invalid,
+            reason: None,
         };
         insert_order_event(&mut ex, &event_b).await.unwrap();
         let event_c = OrderEvent {
             order_uid: uid_b,
             timestamp: now - chrono::Duration::milliseconds(100),
             label: OrderEventLabel::Invalid,
+            reason: None,
         };
         insert_order_event(&mut ex, &event_c).await.unwrap();
         let event_d = OrderEvent {
             order_uid: uid_a,
             timestamp: now,
             label: OrderEventLabel::Invalid,
+            reason: None,
         };
         insert_order_event(&mut ex, &event_d).await.unwrap();
 
@@ -225,19 +277,27 @@ mod tests {
             order_uid: uid_a,
             timestamp: early,
             label: OrderEventLabel::Created,
+            reason: None,
         };
         insert_order_event(&mut ex, &event_a).await.unwrap();
         let event_b = OrderEvent {
             order_uid: uid_b,
             timestamp: early,
             label: OrderEventLabel::Invalid,
+            reason: None,
         };
         insert_order_event(&mut ex, &event_b).await.unwrap();
 
         let later = Utc.with_ymd_and_hms(2027, 2, 19, 0, 0, 0).unwrap();
-        insert_order_events(&mut ex, &[uid_a, uid_b], later, OrderEventLabel::Invalid)
-            .await
-            .unwrap();
+        insert_order_events(
+            &mut ex,
+            &[uid_a, uid_b],
+            later,
+            OrderEventLabel::Invalid,
+            None,
+        )
+        .await
+        .unwrap();
 
         let a = get_latest(&mut ex, &uid_a).await.unwrap();
         assert_eq!(
@@ -247,6 +307,7 @@ mod tests {
                 // new latest event was added
                 timestamp: later,
                 label: OrderEventLabel::Invalid,
+                reason: None,
             })
         );
 
@@ -258,7 +319,8 @@ mod tests {
                 // since the latest event was already `Invalid`
                 // no new entry was created
                 timestamp: early,
-                label: OrderEventLabel::Invalid
+                label: OrderEventLabel::Invalid,
+                reason: None,
             })
         );
     }
@@ -270,9 +332,15 @@ mod tests {
         let mut ex = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut ex).await.unwrap();
         let uid = ByteArray([1; 56]);
-        insert_order_events(&mut ex, &[uid, uid], Utc::now(), OrderEventLabel::Invalid)
-            .await
-            .unwrap();
+        insert_order_events(
+            &mut ex,
+            &[uid, uid],
+            Utc::now(),
+            OrderEventLabel::Invalid,
+            None,
+        )
+        .await
+        .unwrap();
         let events = all_order_events(&mut ex).await;
         // query didn't insert 2 identical events for the same uid
         assert_eq!(events.len(), 1);
diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index 1c85af975a..cc8feeb08c 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -116,6 +116,7 @@ pub async fn insert_orders_and_ignore_conflicts(
                     label: OrderEventLabel::Created,
                     timestamp: order.creation_timestamp,
                     order_uid: order.uid,
+                    reason: None,
                 },
             )
             .await?;
diff --git a/crates/e2e/tests/e2e/debug_order.rs b/crates/e2e/tests/e2e/debug_order.rs
index d4c0570c18..be8967d4b5 100644
--- a/crates/e2e/tests/e2e/debug_order.rs
+++ b/crates/e2e/tests/e2e/debug_order.rs
@@ -111,16 +111,22 @@ async fn debug_order(web3: Web3) {
     assert_eq!(report.order_uid, uid);
     assert_eq!(report.order.data.kind, OrderKind::Buy);
 
-    assert_eq!(
-        report.events.len(),
-        4,
-        "expected exactly created+ready+executing+traded events, got {:?}",
+    assert!(
+        report.events.len() == 4 || report.events.len() == 5,
+        "got {:?}",
         report.events
     );
     assert_eq!(report.events[0].label, "created");
     assert_eq!(report.events[1].label, "ready");
     assert_eq!(report.events[2].label, "executing");
-    assert_eq!(report.events[3].label, "traded");
+    // The in_flight filtered event may or may not sneak in before traded
+    // depending on timing.
+    let last = report.events.last().unwrap();
+    assert!(
+        last.label == "traded" || last.label == "filtered",
+        "unexpected last event: {:?}",
+        last
+    );
 
     assert!(!report.trades.is_empty(), "expected at least one trade");
     assert!(!report.auctions.is_empty(), "expected at least one auction");
@@ -152,3 +158,120 @@ async fn debug_order(web3: Web3) {
         .unwrap();
     assert_eq!(response.status(), StatusCode::NOT_FOUND);
 }
+
+#[tokio::test]
+#[ignore]
+async fn local_node_debug_order_filter_reason() {
+    run_test(debug_order_filter_reason).await;
+}
+
+async fn debug_order_filter_reason(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            ExtraServiceArgs::default(),
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
+            configs::orderbook::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    let order = OrderCreation {
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: 2u64.eth(),
+        buy_token: *token.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Buy,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let uid = services.create_order(&order).await.unwrap();
+
+    // Withdraw WETH so the order becomes invalid due to insufficient balance.
+    onchain
+        .contracts()
+        .weth
+        .withdraw(3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let client = services.client();
+
+    // Wait for the autopilot to pick up the order and mark it invalid.
+    let has_invalid_event = || async {
+        onchain.mint_block().await;
+        let response = client
+            .get(format!("{API_HOST}/api/v1/debug/order/{uid}"))
+            .send()
+            .await
+            .unwrap();
+        let report = response.json::<DebugReport>().await.unwrap();
+        report
+            .events
+            .iter()
+            .any(|e| e.label == "invalid" && e.reason.is_some())
+    };
+    wait_for_condition(TIMEOUT, has_invalid_event)
+        .await
+        .unwrap();
+
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/order/{uid}"))
+        .send()
+        .await
+        .unwrap();
+    let report = response.json::<DebugReport>().await.unwrap();
+
+    let invalid_event = report
+        .events
+        .iter()
+        .find(|e| e.label == "invalid")
+        .expect("expected an invalid event");
+    assert_eq!(
+        invalid_event.reason.as_deref(),
+        Some("insufficient_balance"),
+        "expected insufficient_balance reason, got {:?}",
+        invalid_event.reason
+    );
+
+    // Non-invalid events should have no reason.
+    let created = report
+        .events
+        .iter()
+        .find(|e| e.label == "created")
+        .expect("expected a created event");
+    assert_eq!(created.reason, None);
+}
diff --git a/crates/model/src/debug_report.rs b/crates/model/src/debug_report.rs
index c21ed66e1d..21c9cabd61 100644
--- a/crates/model/src/debug_report.rs
+++ b/crates/model/src/debug_report.rs
@@ -25,6 +25,8 @@ pub struct DebugReport {
 pub struct Event {
     pub label: String,
     pub timestamp: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<String>,
 }
 
 #[serde_as]
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 93d6fe6dd9..1b3b175361 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -2341,6 +2341,12 @@ components:
         timestamp:
           type: string
           format: date-time
+        reason:
+          type: string
+          nullable: true
+          description: >
+            Why the order was filtered or marked invalid. Only present for
+            "filtered" and "invalid" events.
     DebugAuction:
       type: object
       required:
diff --git a/crates/orderbook/src/database/debug_report.rs b/crates/orderbook/src/database/debug_report.rs
index 8fd1d3b091..67922fc351 100644
--- a/crates/orderbook/src/database/debug_report.rs
+++ b/crates/orderbook/src/database/debug_report.rs
@@ -53,6 +53,7 @@ impl Postgres {
             .map(|e| Event {
                 label: format!("{:?}", e.label).to_lowercase(),
                 timestamp: e.timestamp,
+                reason: e.reason.map(|r| r.to_string()),
             })
             .collect();
 
diff --git a/crates/orderbook/src/database/orders.rs b/crates/orderbook/src/database/orders.rs
index e07fe8e15c..94b8f5ac52 100644
--- a/crates/orderbook/src/database/orders.rs
+++ b/crates/orderbook/src/database/orders.rs
@@ -106,6 +106,7 @@ async fn cancel_order(
             order_uid: uid,
             timestamp: now,
             label: OrderEventLabel::Cancelled,
+            reason: None,
         },
     )
     .await?;
@@ -121,6 +122,7 @@ async fn insert_order(order: &Order, ex: &mut PgConnection) -> Result<(), Insert
             order_uid,
             timestamp: Utc::now(),
             label: OrderEventLabel::Created,
+            reason: None,
         },
     )
     .await?;
diff --git a/database/README.md b/database/README.md
index 6a15f205d0..bbf0502438 100644
--- a/database/README.md
+++ b/database/README.md
@@ -183,11 +183,12 @@ Indexes:
 
 Stores timestamped events throughout an order's life cycle. This information is used to get detailed metrics on a per order basis.
 
- Column           | Type                     | Nullable | Details
-------------------|--------------------------|----------|--------
- order\_uid       | bytea                    | not null | order this event belongs to
- timestamp        | timestamptz              | not null | when the event was registered
- label            | [enum](#ordereventlabel) | not null | which event happened exactly
+ Column           | Type                       | Nullable | Details
+------------------|----------------------------|----------|--------
+ order\_uid       | bytea                      | not null | order this event belongs to
+ timestamp        | timestamptz                | not null | when the event was registered
+ label            | [enum](#ordereventlabel)   | not null | which event happened exactly
+ reason           | [enum](#orderfilterreason) | nullable | why the order was filtered or marked invalid (only set for `filtered` and `invalid` labels)
 
 Indexes:
 - order\_events\_by\_uid: btree(`order_uid`, `timestamp`)
@@ -582,6 +583,18 @@ Indexes:
  traded     | order was traded on-chain
  cancelled  | user cancelled the order
 
+#### orderfilterreason
+
+ Value                  | Meaning
+------------------------|--------
+ in\_flight             | order already won a previous auction and is being settled on-chain
+ banned\_user           | order owner is on the ban list
+ invalid\_signature     | presign or EIP-1271 signature is not yet valid
+ unsupported\_token     | sell or buy token is on the deny list
+ insufficient\_balance  | owner does not have enough sell token balance or allowance
+ dust\_order            | order value is too small to be worth settling
+ missing\_native\_price | no native price available for the order's tokens
+
 #### orderkind
 
  Value | Meaning
diff --git a/database/sql/V107__add_reason_to_order_events.sql b/database/sql/V107__add_reason_to_order_events.sql
new file mode 100644
index 0000000000..d7bf65ea61
--- /dev/null
+++ b/database/sql/V107__add_reason_to_order_events.sql
@@ -0,0 +1,11 @@
+CREATE TYPE OrderFilterReason AS ENUM (
+  'in_flight',
+  'banned_user',
+  'invalid_signature',
+  'unsupported_token',
+  'insufficient_balance',
+  'dust_order',
+  'missing_native_price'
+);
+
+ALTER TABLE order_events ADD COLUMN reason OrderFilterReason;

From 911ae991cb8effef74f3d01ee37093ace81c386d Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Thu, 12 Mar 2026 16:07:22 +0100
Subject: [PATCH 144/219] Move price-estimation config structs into configs
 (#4259)

# Description
Simulator refactor requires to move out a couple of dependencies out of
shared and reuse them elsewhere. One of them is price_estimation (#4258
with http-client refactor). As both the price_estimation and http-client
have their respective configs - having `price_estimation` depend on
`http-client` would cause cyclic dependencies on `configs`.

# Changes
This removes the dependency of configs on price_estimation making it
possible to refactor further common types.

It also does make sense for other crates to depend on configs, instead
of configs depending on other crates.

## How to test
E2E tests, no code changes, just moving code around.
---
 Cargo.lock                                    |   2 +
 crates/autopilot/src/run.rs                   |  10 +-
 crates/configs/Cargo.toml                     |   2 +-
 crates/configs/src/autopilot/mod.rs           |  10 +-
 crates/configs/src/autopilot/native_price.rs  |   8 +-
 crates/configs/src/lib.rs                     |   1 +
 crates/configs/src/orderbook/mod.rs           |   7 +-
 crates/configs/src/orderbook/native_price.rs  |   8 +-
 crates/configs/src/price_estimation.rs        | 320 ++++++++++++++++++
 crates/e2e/src/setup/services.rs              |  15 +-
 crates/e2e/tests/e2e/autopilot_leader.rs      |   4 +-
 crates/e2e/tests/e2e/limit_orders.rs          |   4 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  18 +-
 crates/e2e/tests/e2e/quoting.rs               |   4 +-
 .../tracing/distributed/trace_id_format.rs    |   2 +-
 crates/orderbook/src/run.rs                   |  20 +-
 crates/price-estimation/Cargo.toml            |   1 +
 crates/price-estimation/src/config/mod.rs     |   1 -
 .../src/config/native_price.rs                | 155 ---------
 crates/price-estimation/src/factory.rs        |   8 +-
 crates/price-estimation/src/lib.rs            | 169 +--------
 21 files changed, 398 insertions(+), 371 deletions(-)
 create mode 100644 crates/configs/src/price_estimation.rs
 delete mode 100644 crates/price-estimation/src/config/mod.rs
 delete mode 100644 crates/price-estimation/src/config/native_price.rs

diff --git a/Cargo.lock b/Cargo.lock
index 984b05e5c0..c102e85750 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2374,6 +2374,7 @@ dependencies = [
  "anyhow",
  "chrono",
  "humantime-serde",
+ "itertools 0.14.0",
  "price-estimation",
  "s3",
  "serde",
@@ -5430,6 +5431,7 @@ dependencies = [
  "chain",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "derive_more 1.0.0",
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index eee4e38ea3..99fe02662a 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -357,10 +357,12 @@ pub async fn run(
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
-                .map(|price_estimator_driver| price_estimation::ExternalSolver {
-                    name: price_estimator_driver.name.clone(),
-                    url: price_estimator_driver.url.clone(),
-                })
+                .map(
+                    |price_estimator_driver| configs::price_estimation::ExternalSolver {
+                        name: price_estimator_driver.name.clone(),
+                        url: price_estimator_driver.url.clone(),
+                    },
+                )
                 .collect::<Vec<_>>(),
             api_native_price_estimator.clone(),
             gas_price_estimator.clone(),
diff --git a/crates/configs/Cargo.toml b/crates/configs/Cargo.toml
index d2766149c9..4e2f7174d1 100644
--- a/crates/configs/Cargo.toml
+++ b/crates/configs/Cargo.toml
@@ -8,7 +8,7 @@ alloy = { workspace = true, features = ["signer-aws"] }
 anyhow = { workspace = true }
 chrono = { workspace = true }
 humantime-serde = { workspace = true }
-price-estimation = { workspace = true }
+itertools = { workspace = true }
 s3 = { workspace = true }
 serde = { workspace = true }
 tempfile = { workspace = true, optional = true }
diff --git a/crates/configs/src/autopilot/mod.rs b/crates/configs/src/autopilot/mod.rs
index 8a4855ac62..fe0aaf0f51 100644
--- a/crates/configs/src/autopilot/mod.rs
+++ b/crates/configs/src/autopilot/mod.rs
@@ -273,9 +273,12 @@ impl Configuration {
 mod tests {
     use {
         super::*,
-        crate::autopilot::{
-            fee_policy::{FeePolicy, FeePolicyKind, FeePolicyOrderClass, UpcomingFeePolicies},
-            solver::Account,
+        crate::{
+            autopilot::{
+                fee_policy::{FeePolicy, FeePolicyKind, FeePolicyOrderClass, UpcomingFeePolicies},
+                solver::Account,
+            },
+            price_estimation::{ExternalSolver, NativePriceEstimator},
         },
         alloy::primitives::address,
         std::time::Duration,
@@ -406,7 +409,6 @@ mod tests {
         assert_eq!(s3.bucket, "my-bucket");
         assert_eq!(s3.filename_prefix, "staging/mainnet/");
 
-        use price_estimation::{ExternalSolver, NativePriceEstimator};
         assert_eq!(
             config.native_price_estimation.estimators.as_slice(),
             vec![
diff --git a/crates/configs/src/autopilot/native_price.rs b/crates/configs/src/autopilot/native_price.rs
index 849be21e12..c532262222 100644
--- a/crates/configs/src/autopilot/native_price.rs
+++ b/crates/configs/src/autopilot/native_price.rs
@@ -1,5 +1,5 @@
 use {
-    price_estimation::NativePriceEstimators,
+    crate::price_estimation::NativePriceEstimators,
     serde::{Deserialize, Serialize},
     std::time::Duration,
 };
@@ -45,7 +45,7 @@ pub struct NativePriceConfig {
     pub prefetch_time: Duration,
 
     #[serde(flatten)]
-    pub shared: price_estimation::config::native_price::NativePriceConfig,
+    pub shared: crate::price_estimation::NativePriceConfig,
 }
 
 #[cfg(any(test, feature = "test-util"))]
@@ -59,8 +59,8 @@ impl NativePriceConfig {
             api_estimators: Default::default(),
             cache_refresh_interval: default_native_price_cache_refresh(),
             prefetch_time: Duration::from_millis(500),
-            shared: price_estimation::config::native_price::NativePriceConfig {
-                cache: price_estimation::config::native_price::CacheConfig {
+            shared: crate::price_estimation::NativePriceConfig {
+                cache: crate::price_estimation::CacheConfig {
                     max_age: Duration::from_secs(2),
                     ..Default::default()
                 },
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index 8cf859f50e..2402a32c0e 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -6,6 +6,7 @@ pub mod fee_factor;
 pub mod http_client;
 pub mod order_quoting;
 pub mod orderbook;
+pub mod price_estimation;
 
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index 9e2ae0a167..12b16511ea 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -171,8 +171,11 @@ pub mod test_util {
 mod tests {
     use {
         super::*,
-        crate::{orderbook::order_validation::SameTokensPolicy, test_util::TestDefault},
-        price_estimation::{NativePriceEstimator, NativePriceEstimators},
+        crate::{
+            orderbook::order_validation::SameTokensPolicy,
+            price_estimation::{NativePriceEstimator, NativePriceEstimators},
+            test_util::TestDefault,
+        },
         std::time::Duration,
     };
 
diff --git a/crates/configs/src/orderbook/native_price.rs b/crates/configs/src/orderbook/native_price.rs
index 57e461d05a..6349ffdeee 100644
--- a/crates/configs/src/orderbook/native_price.rs
+++ b/crates/configs/src/orderbook/native_price.rs
@@ -1,7 +1,7 @@
 use {
-    price_estimation::{
+    crate::price_estimation::{
+        NativePriceConfig as SharedNativePriceConfig,
         NativePriceEstimators,
-        config::native_price::NativePriceConfig as SharedNativePriceConfig,
     },
     serde::{Deserialize, Serialize},
 };
@@ -25,7 +25,7 @@ pub struct NativePriceConfig {
 impl NativePriceConfig {
     /// The orderbook forwards native price requests to the autopilot.
     pub fn test_default() -> Self {
-        use price_estimation::NativePriceEstimator;
+        use crate::price_estimation::NativePriceEstimator;
         Self {
             estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::forwarder(
                 "http://localhost:12088".parse().unwrap(),
@@ -70,7 +70,7 @@ mod tests {
 
     #[test]
     fn roundtrip_serialization() {
-        use price_estimation::NativePriceEstimator;
+        use crate::price_estimation::NativePriceEstimator;
 
         let config = NativePriceConfig {
             estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
new file mode 100644
index 0000000000..752a304363
--- /dev/null
+++ b/crates/configs/src/price_estimation.rs
@@ -0,0 +1,320 @@
+use {
+    alloy::primitives::Address,
+    anyhow::{Context, Result, ensure},
+    itertools::Itertools,
+    serde::{Deserialize, Serialize},
+    std::{
+        fmt::{self, Display, Formatter},
+        num::NonZeroUsize,
+        str::FromStr,
+        time::Duration,
+    },
+    url::Url,
+};
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
+
+impl<'de> Deserialize<'de> for NativePriceEstimators {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let estimators = <Vec<Vec<NativePriceEstimator>>>::deserialize(deserializer)?;
+        if estimators.is_empty() {
+            return Err(serde::de::Error::invalid_length(
+                0,
+                &"expected native price estimator stages to be configured",
+            ));
+        }
+        match estimators
+            .iter()
+            .enumerate()
+            .find_map(|(n, stage)| stage.is_empty().then_some(n))
+        {
+            Some(n) => Err(serde::de::Error::invalid_length(
+                0,
+                &format!("stage {} is empty, all stages must not be empty", n).as_str(),
+            )),
+            None => Ok(Self(estimators)),
+        }
+    }
+}
+
+impl NativePriceEstimators {
+    pub fn new(estimators: Vec<Vec<NativePriceEstimator>>) -> Self {
+        Self(estimators)
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl NativePriceEstimators {
+    /// Returns a list with a single stage, said stage contains a Driver estimator named `test_quoter` with URL `http://localhost:11088/test_solver`.
+    pub fn test_default() -> Self {
+        NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
+            "test_quoter".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+        )]])
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(tag = "type")]
+pub enum NativePriceEstimator {
+    Driver(ExternalSolver),
+    Forwarder { url: Url },
+    OneInchSpotPriceApi,
+    CoinGecko,
+}
+
+impl NativePriceEstimator {
+    pub const fn driver(name: String, url: Url) -> Self {
+        Self::Driver(ExternalSolver { name, url })
+    }
+
+    pub const fn forwarder(url: Url) -> Self {
+        Self::Forwarder { url }
+    }
+}
+
+impl Display for NativePriceEstimator {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let formatter = match self {
+            NativePriceEstimator::Driver(s) => format!("Driver|{}|{}", &s.name, s.url),
+            NativePriceEstimator::Forwarder { url } => format!("Forwarder|{}", url),
+            NativePriceEstimator::OneInchSpotPriceApi => "OneInchSpotPriceApi".into(),
+            NativePriceEstimator::CoinGecko => "CoinGecko".into(),
+        };
+        write!(f, "{formatter}")
+    }
+}
+
+impl NativePriceEstimators {
+    pub fn as_slice(&self) -> &[Vec<NativePriceEstimator>] {
+        &self.0
+    }
+}
+
+impl Display for NativePriceEstimators {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let formatter = self
+            .as_slice()
+            .iter()
+            .map(|stage| {
+                stage
+                    .iter()
+                    .format_with(",", |estimator, f| f(&format_args!("{estimator}")))
+            })
+            .format(";");
+        write!(f, "{formatter}")
+    }
+}
+
+impl FromStr for NativePriceEstimators {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(
+            s.split(';')
+                .map(|sub_list| {
+                    sub_list
+                        .split(',')
+                        .map(NativePriceEstimator::from_str)
+                        .collect::<Result<Vec<NativePriceEstimator>>>()
+                })
+                .collect::<Result<Vec<Vec<NativePriceEstimator>>>>()?,
+        ))
+    }
+}
+
+impl FromStr for NativePriceEstimator {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (variant, args) = s.split_once('|').unwrap_or((s, ""));
+        match variant {
+            "OneInchSpotPriceApi" => Ok(NativePriceEstimator::OneInchSpotPriceApi),
+            "CoinGecko" => Ok(NativePriceEstimator::CoinGecko),
+            "Driver" => Ok(NativePriceEstimator::Driver(ExternalSolver::from_str(
+                args,
+            )?)),
+            "Forwarder" => Ok(NativePriceEstimator::Forwarder {
+                url: args
+                    .parse()
+                    .context("Forwarder price estimator invalid URL")?,
+            }),
+            _ => Err(anyhow::anyhow!("unsupported native price estimator: {}", s)),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+pub struct ExternalSolver {
+    pub name: String,
+    pub url: Url,
+}
+
+impl FromStr for ExternalSolver {
+    type Err = anyhow::Error;
+
+    fn from_str(solver: &str) -> Result<Self> {
+        let parts: Vec<&str> = solver.split('|').collect();
+        ensure!(parts.len() >= 2, "not enough arguments for external solver");
+        let (name, url) = (parts[0], parts[1]);
+        let url: Url = url.parse()?;
+        Ok(Self {
+            name: name.to_owned(),
+            url,
+        })
+    }
+}
+
+const fn default_cache_max_age() -> Duration {
+    Duration::from_mins(10)
+}
+
+const fn default_cache_concurrent_requests() -> NonZeroUsize {
+    NonZeroUsize::new(1).expect("value should be greater than 0")
+}
+
+const fn default_results_required() -> NonZeroUsize {
+    NonZeroUsize::new(2).expect("value should not be zero")
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct NativePriceConfig {
+    /// List of mappings of native price tokens substitutions with approximated:
+    /// - the first is a token address for which we get the native token price
+    /// - the second is a token address used for the price approximation
+    #[serde(default)]
+    pub approximation_tokens: Vec<(Address, Address)>,
+
+    /// Configuration for the native price caching mechanism.
+    #[serde(default)]
+    pub cache: CacheConfig,
+
+    /// How many successful price estimates for each order will cause a native
+    /// price estimation to return its result early.
+    ///
+    /// As this value increases, the fast estimator behavior will approximate
+    /// the behavior of the optimal estimator.
+    ///
+    /// It's possible to pass values greater than the total number of enabled
+    /// estimators but that will not have any further effect.
+    #[serde(default = "default_results_required")]
+    pub results_required: NonZeroUsize,
+}
+
+impl Default for NativePriceConfig {
+    fn default() -> Self {
+        Self {
+            approximation_tokens: Default::default(),
+            cache: Default::default(),
+            results_required: default_results_required(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct CacheConfig {
+    /// How long cached native prices stay valid.
+    #[serde(default = "default_cache_max_age", with = "humantime_serde")]
+    pub max_age: Duration,
+
+    /// How many price estimation requests can be executed concurrently in the
+    /// maintenance task.
+    #[serde(default = "default_cache_concurrent_requests")]
+    pub concurrent_requests: NonZeroUsize,
+}
+
+impl Default for CacheConfig {
+    fn default() -> Self {
+        Self {
+            max_age: default_cache_max_age(),
+            concurrent_requests: default_cache_concurrent_requests(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+            approximation-tokens = [
+                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
+            ]
+
+            [cache]
+            max-age = "5m"
+            concurrent-requests = 4
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.approximation_tokens.len(), 1);
+        assert_eq!(config.cache.max_age, Duration::from_secs(300));
+        assert_eq!(
+            config.cache.concurrent_requests,
+            NonZeroUsize::new(4).unwrap()
+        );
+    }
+
+    #[test]
+    fn cache_defaults() {
+        let toml = r#"
+            approximation-tokens = []
+            [cache]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.cache.max_age, Duration::from_mins(10));
+        assert_eq!(
+            config.cache.concurrent_requests,
+            NonZeroUsize::new(1).unwrap()
+        );
+    }
+
+    #[test]
+    fn multiple_approximation_tokens() {
+        let toml = r#"
+            approximation-tokens = [
+                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
+                ["0x0000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000004"],
+            ]
+            [cache]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.approximation_tokens.len(), 2);
+        assert_eq!(
+            config.approximation_tokens[0].0,
+            Address::from_slice(&[0; 19].into_iter().chain([1]).collect::<Vec<_>>()),
+        );
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = NativePriceConfig {
+            approximation_tokens: vec![(Address::repeat_byte(1), Address::repeat_byte(2))],
+            cache: CacheConfig {
+                max_age: Duration::from_secs(120),
+                concurrent_requests: NonZeroUsize::new(8).unwrap(),
+            },
+            results_required: default_results_required(),
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(
+            config.approximation_tokens,
+            deserialized.approximation_tokens,
+        );
+        assert_eq!(config.cache.max_age, deserialized.cache.max_age);
+        assert_eq!(
+            config.cache.concurrent_requests,
+            deserialized.cache.concurrent_requests,
+        );
+    }
+}
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 9b1025437d..aa7c63a528 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -25,6 +25,7 @@ use {
             run_loop::RunLoopConfig,
         },
         order_quoting::{ExternalSolver, OrderQuoting},
+        price_estimation::{NativePriceEstimator, NativePriceEstimators},
         test_util::TestDefault,
     },
     ethrpc::Web3,
@@ -36,7 +37,6 @@ use {
         solver_competition_v2,
         trade::Trade,
     },
-    price_estimation::{NativePriceEstimator, NativePriceEstimators},
     reqwest::{Client, StatusCode, Url},
     sqlx::Connection,
     std::{
@@ -385,14 +385,13 @@ impl<'a> Services<'a> {
             forwarder_contract: None,
         }];
 
-        let shared_native_price_config =
-            price_estimation::config::native_price::NativePriceConfig {
-                cache: price_estimation::config::native_price::CacheConfig {
-                    max_age: Duration::from_secs(2),
-                    ..Default::default()
-                },
+        let shared_native_price_config = configs::price_estimation::NativePriceConfig {
+            cache: configs::price_estimation::CacheConfig {
+                max_age: Duration::from_secs(2),
                 ..Default::default()
-            };
+            },
+            ..Default::default()
+        };
 
         // Create TOML config files
         let autopilot_config = Configuration {
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 6d2aacd9fa..546e1c9ee5 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -152,8 +152,8 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
                     ExternalSolver::new("test_solver2", "http://localhost:11088/test_solver2"),
                 ]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: price_estimation::NativePriceEstimators::new(vec![vec![
-                        price_estimation::NativePriceEstimator::forwarder(
+                    estimators: configs::price_estimation::NativePriceEstimators::new(vec![vec![
+                        configs::price_estimation::NativePriceEstimator::forwarder(
                             "http://0.0.0.0:9588".parse().unwrap(),
                         ),
                     ]]),
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index b083ba9196..177b49b091 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -516,8 +516,8 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
                     "http://localhost:11088/test_solver",
                 )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: price_estimation::NativePriceEstimators::new(vec![vec![
-                        price_estimation::NativePriceEstimator::driver(
+                    estimators: configs::price_estimation::NativePriceEstimators::new(vec![vec![
+                        configs::price_estimation::NativePriceEstimator::driver(
                             "test_quoter".to_string(),
                             "http://localhost:11088/test_solver".parse().unwrap(),
                         ),
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 8830ae3258..0e04b70590 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -247,14 +247,16 @@ async fn fallback_native_price_estimator(web3: Web3) {
                     "http://localhost:11088/test_solver",
                 )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    fallback_estimators: Some(price_estimation::NativePriceEstimators::new(vec![
-                        vec![price_estimation::NativePriceEstimator::driver(
-                            "test_quoter".to_string(),
-                            "http://localhost:11088/test_solver".parse().unwrap(),
-                        )],
-                    ])),
-                    shared: price_estimation::config::native_price::NativePriceConfig {
-                        cache: price_estimation::config::native_price::CacheConfig {
+                    fallback_estimators: Some(
+                        configs::price_estimation::NativePriceEstimators::new(vec![vec![
+                            configs::price_estimation::NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                "http://localhost:11088/test_solver".parse().unwrap(),
+                            ),
+                        ]]),
+                    ),
+                    shared: configs::price_estimation::NativePriceConfig {
+                        cache: configs::price_estimation::CacheConfig {
                             max_age: std::time::Duration::from_secs(2),
                             ..Default::default()
                         },
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 2c8f29aaa1..258b34173b 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -332,8 +332,8 @@ async fn quote_timeout(web3: Web3) {
                     "http://localhost:11088/test_quoter",
                 )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: price_estimation::NativePriceEstimators::new(vec![vec![
-                        price_estimation::NativePriceEstimator::driver(
+                    estimators: configs::price_estimation::NativePriceEstimators::new(vec![vec![
+                        configs::price_estimation::NativePriceEstimator::driver(
                             "test_quoter".to_string(),
                             "http://localhost:11088/test_solver".parse().unwrap(),
                         ),
diff --git a/crates/observe/src/tracing/distributed/trace_id_format.rs b/crates/observe/src/tracing/distributed/trace_id_format.rs
index 7bc18b910c..2d11f16e38 100644
--- a/crates/observe/src/tracing/distributed/trace_id_format.rs
+++ b/crates/observe/src/tracing/distributed/trace_id_format.rs
@@ -120,7 +120,7 @@ where
                                 .get_mut()
                                 .as_object_mut()
                                 .expect("fields get initialized with an object")
-                                .extend(current_span_fields.into_iter())
+                                .extend(current_span_fields)
                         }
                     }
                 }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index b01915d4de..18a27661e2 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -280,10 +280,12 @@ pub async fn run(args: Arguments, config: Configuration) {
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
-                .map(|price_estimator_driver| price_estimation::ExternalSolver {
-                    name: price_estimator_driver.name.clone(),
-                    url: price_estimator_driver.url.clone(),
-                })
+                .map(
+                    |price_estimator_driver| configs::price_estimation::ExternalSolver {
+                        name: price_estimator_driver.name.clone(),
+                        url: price_estimator_driver.url.clone(),
+                    },
+                )
                 .collect::<Vec<_>>(),
             native_price_estimator.clone(),
             gas_price_estimator.clone(),
@@ -295,10 +297,12 @@ pub async fn run(args: Arguments, config: Configuration) {
                 .order_quoting
                 .price_estimation_drivers
                 .iter()
-                .map(|price_estimator_driver| price_estimation::ExternalSolver {
-                    name: price_estimator_driver.name.clone(),
-                    url: price_estimator_driver.url.clone(),
-                })
+                .map(
+                    |price_estimator_driver| configs::price_estimation::ExternalSolver {
+                        name: price_estimator_driver.name.clone(),
+                        url: price_estimator_driver.url.clone(),
+                    },
+                )
                 .collect::<Vec<_>>(),
             config.native_price_estimation.shared.results_required,
             native_price_estimator.clone(),
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index 5ee9cf737b..c27a6b3ece 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -19,6 +19,7 @@ cached = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
+configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 derive_more = { workspace = true }
diff --git a/crates/price-estimation/src/config/mod.rs b/crates/price-estimation/src/config/mod.rs
deleted file mode 100644
index 63c215df15..0000000000
--- a/crates/price-estimation/src/config/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod native_price;
diff --git a/crates/price-estimation/src/config/native_price.rs b/crates/price-estimation/src/config/native_price.rs
deleted file mode 100644
index 8ae411d1fa..0000000000
--- a/crates/price-estimation/src/config/native_price.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use {
-    alloy::primitives::Address,
-    serde::{Deserialize, Serialize},
-    std::{num::NonZeroUsize, time::Duration},
-};
-
-const fn default_cache_max_age() -> Duration {
-    Duration::from_mins(10)
-}
-
-const fn default_cache_concurrent_requests() -> NonZeroUsize {
-    NonZeroUsize::new(1).expect("value should be greater than 0")
-}
-
-const fn default_results_required() -> NonZeroUsize {
-    NonZeroUsize::new(2).expect("value should not be zero")
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct NativePriceConfig {
-    /// List of mappings of native price tokens substitutions with approximated:
-    /// - the first is a token address for which we get the native token price
-    /// - the second is a token address used for the price approximation
-    #[serde(default)]
-    pub approximation_tokens: Vec<(Address, Address)>,
-
-    /// Configuration for the native price caching mechanism.
-    #[serde(default)]
-    pub cache: CacheConfig,
-
-    /// How many successful price estimates for each order will cause a native
-    /// price estimation to return its result early.
-    ///
-    /// As this value increases, the fast estimator behavior will approximate
-    /// the behavior of the optimal estimator.
-    ///
-    /// It's possible to pass values greater than the total number of enabled
-    /// estimators but that will not have any further effect.
-    #[serde(default = "default_results_required")]
-    pub results_required: NonZeroUsize,
-}
-
-impl Default for NativePriceConfig {
-    fn default() -> Self {
-        Self {
-            approximation_tokens: Default::default(),
-            cache: Default::default(),
-            results_required: default_results_required(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct CacheConfig {
-    /// How long cached native prices stay valid.
-    #[serde(default = "default_cache_max_age", with = "humantime_serde")]
-    pub max_age: Duration,
-
-    /// How many price estimation requests can be executed concurrently in the
-    /// maintenance task.
-    #[serde(default = "default_cache_concurrent_requests")]
-    pub concurrent_requests: NonZeroUsize,
-}
-
-impl Default for CacheConfig {
-    fn default() -> Self {
-        Self {
-            max_age: default_cache_max_age(),
-            concurrent_requests: default_cache_concurrent_requests(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-            approximation-tokens = [
-                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
-            ]
-
-            [cache]
-            max-age = "5m"
-            concurrent-requests = 4
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.approximation_tokens.len(), 1);
-        assert_eq!(config.cache.max_age, Duration::from_secs(300));
-        assert_eq!(
-            config.cache.concurrent_requests,
-            NonZeroUsize::new(4).unwrap()
-        );
-    }
-
-    #[test]
-    fn cache_defaults() {
-        let toml = r#"
-            approximation-tokens = []
-            [cache]
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.cache.max_age, Duration::from_mins(10));
-        assert_eq!(
-            config.cache.concurrent_requests,
-            NonZeroUsize::new(1).unwrap()
-        );
-    }
-
-    #[test]
-    fn multiple_approximation_tokens() {
-        let toml = r#"
-            approximation-tokens = [
-                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
-                ["0x0000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000004"],
-            ]
-            [cache]
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.approximation_tokens.len(), 2);
-        assert_eq!(
-            config.approximation_tokens[0].0,
-            Address::from_slice(&[0; 19].into_iter().chain([1]).collect::<Vec<_>>()),
-        );
-    }
-
-    #[test]
-    fn roundtrip_serialization() {
-        let config = NativePriceConfig {
-            approximation_tokens: vec![(Address::repeat_byte(1), Address::repeat_byte(2))],
-            cache: CacheConfig {
-                max_age: Duration::from_secs(120),
-                concurrent_requests: NonZeroUsize::new(8).unwrap(),
-            },
-            results_required: default_results_required(),
-        };
-
-        let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
-
-        assert_eq!(
-            config.approximation_tokens,
-            deserialized.approximation_tokens,
-        );
-        assert_eq!(config.cache.max_age, deserialized.cache.max_age);
-        assert_eq!(
-            config.cache.concurrent_requests,
-            deserialized.cache.concurrent_requests,
-        );
-    }
-}
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index 79c78381d1..8b86ef7754 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -1,7 +1,6 @@
 use {
     super::{
         Arguments,
-        NativePriceEstimator as NativePriceEstimatorSource,
         PriceEstimating,
         competition::CompetitionEstimator,
         external::ExternalPriceEstimator,
@@ -12,16 +11,19 @@ use {
         trade_verifier::{TradeVerifier, TradeVerifying},
     },
     crate::{
-        ExternalSolver,
         buffered::{self, BufferedRequest, NativePriceBatchFetching},
         competition::PriceRanking,
-        config::native_price::NativePriceConfig,
         trade_verifier::{code_fetching::CachedCodeFetcher, tenderly_api::TenderlyCodeSimulator},
         utils::http_client_factory::HttpClientFactory,
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
     bad_tokens::list_based::DenyListedTokens,
+    configs::price_estimation::{
+        ExternalSolver,
+        NativePriceConfig,
+        NativePriceEstimator as NativePriceEstimatorSource,
+    },
     contracts::alloy::WETH9,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     gas_price_estimation::GasPriceEstimating,
diff --git a/crates/price-estimation/src/lib.rs b/crates/price-estimation/src/lib.rs
index 6428f4b30d..b5bd54ae1a 100644
--- a/crates/price-estimation/src/lib.rs
+++ b/crates/price-estimation/src/lib.rs
@@ -5,10 +5,9 @@ use {
         utils::{display_option, display_secret_option},
     },
     alloy::primitives::{Address, U256},
-    anyhow::{Context, Result, ensure},
+    anyhow::Result,
     bigdecimal::BigDecimal,
     futures::future::BoxFuture,
-    itertools::Itertools,
     model::order::{BuyTokenDestination, OrderKind, SellTokenSource},
     number::nonzero::NonZeroU256,
     rate_limit::{RateLimiter, Strategy},
@@ -19,7 +18,6 @@ use {
         fmt::{self, Display, Formatter},
         future::Future,
         hash::Hash,
-        str::FromStr,
         sync::Arc,
         time::{Duration, Instant},
     },
@@ -28,7 +26,6 @@ use {
 
 mod buffered;
 pub mod competition;
-pub mod config;
 pub mod external;
 pub mod factory;
 pub mod gas;
@@ -40,163 +37,6 @@ pub mod trade_finding;
 pub mod trade_verifier;
 pub mod utils;
 
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
-
-impl<'de> Deserialize<'de> for NativePriceEstimators {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let estimators = <Vec<Vec<NativePriceEstimator>>>::deserialize(deserializer)?;
-        if estimators.is_empty() {
-            return Err(serde::de::Error::invalid_length(
-                0,
-                &"expected native price estimator stages to be configured",
-            ));
-        }
-        match estimators
-            .iter()
-            .enumerate()
-            .find_map(|(n, stage)| stage.is_empty().then_some(n))
-        {
-            Some(n) => Err(serde::de::Error::invalid_length(
-                0,
-                &format!("stage {} is empty, all stages must not be empty", n).as_str(),
-            )),
-            None => Ok(Self(estimators)),
-        }
-    }
-}
-
-impl NativePriceEstimators {
-    pub fn new(estimators: Vec<Vec<NativePriceEstimator>>) -> Self {
-        Self(estimators)
-    }
-}
-
-#[cfg(any(test, feature = "test-util"))]
-impl NativePriceEstimators {
-    /// Returns a list with a single stage, said stage contains a Driver estimator named `test_quoter` with URL `http://localhost:11088/test_solver`.
-    pub fn test_default() -> Self {
-        NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
-            "test_quoter".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-        )]])
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
-pub struct ExternalSolver {
-    pub name: String,
-    pub url: Url,
-}
-
-impl FromStr for ExternalSolver {
-    type Err = anyhow::Error;
-
-    fn from_str(solver: &str) -> Result<Self> {
-        let parts: Vec<&str> = solver.split('|').collect();
-        ensure!(parts.len() >= 2, "not enough arguments for external solver");
-        let (name, url) = (parts[0], parts[1]);
-        let url: Url = url.parse()?;
-        Ok(Self {
-            name: name.to_owned(),
-            url,
-        })
-    }
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize, Serialize)]
-#[serde(tag = "type")]
-pub enum NativePriceEstimator {
-    Driver(ExternalSolver),
-    Forwarder { url: Url },
-    OneInchSpotPriceApi,
-    CoinGecko,
-}
-
-impl NativePriceEstimator {
-    pub const fn driver(name: String, url: Url) -> Self {
-        Self::Driver(ExternalSolver { name, url })
-    }
-
-    pub const fn forwarder(url: Url) -> Self {
-        Self::Forwarder { url }
-    }
-}
-
-impl Display for NativePriceEstimator {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let formatter = match self {
-            NativePriceEstimator::Driver(s) => format!("Driver|{}|{}", &s.name, s.url),
-            NativePriceEstimator::Forwarder { url } => format!("Forwarder|{}", url),
-            NativePriceEstimator::OneInchSpotPriceApi => "OneInchSpotPriceApi".into(),
-            NativePriceEstimator::CoinGecko => "CoinGecko".into(),
-        };
-        write!(f, "{formatter}")
-    }
-}
-
-impl NativePriceEstimators {
-    pub fn as_slice(&self) -> &[Vec<NativePriceEstimator>] {
-        &self.0
-    }
-}
-
-impl Display for NativePriceEstimators {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let formatter = self
-            .as_slice()
-            .iter()
-            .map(|stage| {
-                stage
-                    .iter()
-                    .format_with(",", |estimator, f| f(&format_args!("{estimator}")))
-            })
-            .format(";");
-        write!(f, "{formatter}")
-    }
-}
-
-impl FromStr for NativePriceEstimators {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Self(
-            s.split(';')
-                .map(|sub_list| {
-                    sub_list
-                        .split(',')
-                        .map(NativePriceEstimator::from_str)
-                        .collect::<Result<Vec<NativePriceEstimator>>>()
-                })
-                .collect::<Result<Vec<Vec<NativePriceEstimator>>>>()?,
-        ))
-    }
-}
-
-impl FromStr for NativePriceEstimator {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (variant, args) = s.split_once('|').unwrap_or((s, ""));
-        match variant {
-            "OneInchSpotPriceApi" => Ok(NativePriceEstimator::OneInchSpotPriceApi),
-            "CoinGecko" => Ok(NativePriceEstimator::CoinGecko),
-            "Driver" => Ok(NativePriceEstimator::Driver(ExternalSolver::from_str(
-                args,
-            )?)),
-            "Forwarder" => Ok(NativePriceEstimator::Forwarder {
-                url: args
-                    .parse()
-                    .context("Forwarder price estimator invalid URL")?,
-            }),
-            _ => Err(anyhow::anyhow!("unsupported native price estimator: {}", s)),
-        }
-    }
-}
-
 /// Shared price estimation configuration arguments.
 #[derive(clap::Parser)]
 #[group(skip)]
@@ -571,7 +411,12 @@ pub mod mocks {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, clap::Parser};
+    use {
+        super::*,
+        clap::Parser,
+        configs::price_estimation::{ExternalSolver, NativePriceEstimator, NativePriceEstimators},
+        std::str::FromStr,
+    };
 
     #[test]
     fn string_repr_round_trip_native_price_estimators() {

From 5dc4b2a8b508020e7b1cbd63c5474619bedfbe09 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 12 Mar 2026 17:44:38 +0000
Subject: [PATCH 145/219] [TRIVIAL] Update BitGet solver chain names (#4257)

Some BitGet chain names were inconsistent and don't align with [the
official docs](https://web3.bitget.com/en/docs/swap/). This PR fixes it.

Tested on staging on each chain.
---
 crates/solvers/src/infra/dex/bitget/dto.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/solvers/src/infra/dex/bitget/dto.rs b/crates/solvers/src/infra/dex/bitget/dto.rs
index 50d8c4f135..30a743d3a4 100644
--- a/crates/solvers/src/infra/dex/bitget/dto.rs
+++ b/crates/solvers/src/infra/dex/bitget/dto.rs
@@ -13,13 +13,13 @@ use {
 pub enum ChainName {
     #[serde(rename = "eth")]
     Mainnet,
-    #[serde(rename = "bsc")]
+    #[serde(rename = "bnb")]
     Bnb,
     #[serde(rename = "base")]
     Base,
-    #[serde(rename = "polygon")]
+    #[serde(rename = "matic")]
     Polygon,
-    #[serde(rename = "arb")]
+    #[serde(rename = "arbitrum")]
     ArbitrumOne,
 }
 

From a7a875a3eca6c6d015a7a914c61254e95b3c991c Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 12 Mar 2026 17:47:00 +0000
Subject: [PATCH 146/219] Clean up solvers util (#4254)

# Changes

- Remove unused bytes.rs module and empty url.rs from
`crates/solvers/src/util/`
- Remove `fmt/hex.rs` module, replacing `Hex<'a>` wrapper with inline
`const_hex::encode_prefixed` calls (already a dependency)
- Replace `Bytes<Vec<u8>>` in `eth::Tx` with `alloy::primitives::Bytes`
which provides hex debug formatting out of the box
- Use `const_hex::decode` in Bitget DTO instead of manually stripping 0x
prefix + `hex::decode`
- Drop the `hex` crate dependency from solvers (no longer needed after
switching to `const_hex`)

## How to test
Existing tests
---
 Cargo.lock                                    |  1 -
 crates/solvers/Cargo.toml                     |  1 -
 crates/solvers/src/domain/dex/mod.rs          |  6 +-
 crates/solvers/src/domain/dex/shared.rs       |  5 +-
 crates/solvers/src/domain/eth/mod.rs          |  4 +-
 crates/solvers/src/domain/order.rs            |  8 +--
 crates/solvers/src/domain/solver/dex/fills.rs |  5 +-
 crates/solvers/src/infra/dex/bitget/dto.rs    |  6 +-
 crates/solvers/src/infra/dex/bitget/mod.rs    |  9 +--
 crates/solvers/src/util/bytes.rs              | 12 ----
 crates/solvers/src/util/conv.rs               | 58 +++----------------
 crates/solvers/src/util/fmt/hex.rs            | 15 -----
 crates/solvers/src/util/fmt/mod.rs            |  3 -
 crates/solvers/src/util/mod.rs                |  2 -
 crates/solvers/src/util/url.rs                |  0
 15 files changed, 29 insertions(+), 106 deletions(-)
 delete mode 100644 crates/solvers/src/util/bytes.rs
 delete mode 100644 crates/solvers/src/util/fmt/hex.rs
 delete mode 100644 crates/solvers/src/util/fmt/mod.rs
 delete mode 100644 crates/solvers/src/util/url.rs

diff --git a/Cargo.lock b/Cargo.lock
index c102e85750..faba1286c3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6945,7 +6945,6 @@ dependencies = [
  "ethrpc",
  "futures",
  "glob",
- "hex",
  "hmac",
  "humantime-serde",
  "itertools 0.14.0",
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index 87892bf9bc..cef7bc412d 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -25,7 +25,6 @@ const-hex = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-hex = { workspace = true }
 hmac = { workspace = true }
 humantime-serde = { workspace = true }
 itertools = { workspace = true }
diff --git a/crates/solvers/src/domain/dex/mod.rs b/crates/solvers/src/domain/dex/mod.rs
index 429fac691b..a5e34c63aa 100644
--- a/crates/solvers/src/domain/dex/mod.rs
+++ b/crates/solvers/src/domain/dex/mod.rs
@@ -6,7 +6,6 @@ use {
     crate::{
         domain::{self, auction, eth, order, solution},
         infra,
-        util,
     },
     alloy::primitives::{Address, U256},
     std::fmt::{self, Debug, Formatter},
@@ -68,7 +67,10 @@ impl Debug for Call {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.debug_struct("Call")
             .field("to", &self.to)
-            .field("calldata", &util::fmt::Hex(&self.calldata))
+            .field(
+                "calldata",
+                &format_args!("{}", const_hex::encode_prefixed(&self.calldata)),
+            )
             .finish()
     }
 }
diff --git a/crates/solvers/src/domain/dex/shared.rs b/crates/solvers/src/domain/dex/shared.rs
index 6e8877e53f..7604a40c62 100644
--- a/crates/solvers/src/domain/dex/shared.rs
+++ b/crates/solvers/src/domain/dex/shared.rs
@@ -8,18 +8,19 @@ use {
     alloy::primitives::U256,
     bigdecimal::{BigDecimal, Zero},
     num::{BigUint, Integer},
+    number::conversions::{big_uint_to_u256, u256_to_big_uint},
 };
 
 /// Computes the absolute tolerance amount from a relative factor.
 pub fn compute_absolute_tolerance(amount: U256, factor: &BigDecimal) -> U256 {
-    let amount = conv::u256_to_biguint(&amount);
+    let amount = u256_to_big_uint(&amount);
     let (int, exp) = factor.as_bigint_and_exponent();
 
     let numer = amount * int.to_biguint().expect("positive by construction");
     let denom = BigUint::from(10_u8).pow(exp.unsigned_abs().try_into().unwrap_or(u32::MAX));
 
     let abs = numer.div_ceil(&denom);
-    conv::biguint_to_u256(&abs).unwrap_or(U256::MAX)
+    big_uint_to_u256(&abs).unwrap_or(U256::MAX)
 }
 
 /// Converts an absolute slippage value to a relative slippage value based on
diff --git a/crates/solvers/src/domain/eth/mod.rs b/crates/solvers/src/domain/eth/mod.rs
index f3c1500308..8b976fd0bb 100644
--- a/crates/solvers/src/domain/eth/mod.rs
+++ b/crates/solvers/src/domain/eth/mod.rs
@@ -1,10 +1,10 @@
 pub mod chain;
 
-use {crate::util::bytes::Bytes, alloy::rpc::types::AccessList, derive_more::From};
 pub use {
     alloy::primitives::{Address, B256, U256},
     chain::ChainId,
 };
+use {alloy::rpc::types::AccessList, derive_more::From};
 
 /// A contract address.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -85,7 +85,7 @@ pub struct Tx {
     pub from: Address,
     pub to: Address,
     pub value: Ether,
-    pub input: Bytes<Vec<u8>>,
+    pub input: alloy::primitives::Bytes,
     pub access_list: AccessList,
 }
 
diff --git a/crates/solvers/src/domain/order.rs b/crates/solvers/src/domain/order.rs
index 73c25316db..97b78c961c 100644
--- a/crates/solvers/src/domain/order.rs
+++ b/crates/solvers/src/domain/order.rs
@@ -1,7 +1,7 @@
 //! The domain object representing a CoW Protocol order.
 
 use {
-    crate::{domain::eth, util},
+    crate::domain::eth,
     alloy::primitives::B256,
     eth::Address,
     std::fmt::{self, Debug, Display, Formatter},
@@ -41,14 +41,14 @@ pub struct Uid(pub [u8; 56]);
 impl Debug for Uid {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.debug_tuple("Uid")
-            .field(&util::fmt::Hex(&self.0))
+            .field(&format_args!("{}", const_hex::encode_prefixed(self.0)))
             .finish()
     }
 }
 
 impl Display for Uid {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        Display::fmt(&util::fmt::Hex(&self.0), f)
+        f.write_str(&const_hex::encode_prefixed(self.0))
     }
 }
 
@@ -139,7 +139,7 @@ pub struct AppData(pub [u8; 32]);
 impl Debug for AppData {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_tuple("AppData")
-            .field(&util::fmt::Hex(&self.0))
+            .field(&format_args!("{}", const_hex::encode_prefixed(self.0)))
             .finish()
     }
 }
diff --git a/crates/solvers/src/domain/solver/dex/fills.rs b/crates/solvers/src/domain/solver/dex/fills.rs
index 7817f80c2a..c9ad659dcc 100644
--- a/crates/solvers/src/domain/solver/dex/fills.rs
+++ b/crates/solvers/src/domain/solver/dex/fills.rs
@@ -5,6 +5,7 @@ use {
     },
     alloy::primitives::{U256, U512, ruint::UintTryFrom},
     bigdecimal::BigDecimal,
+    number::conversions::{big_decimal_to_u256, u256_to_big_decimal},
     std::{
         collections::HashMap,
         sync::Mutex,
@@ -32,7 +33,7 @@ impl Fills {
     pub fn new(smallest_fill: eth::Ether) -> Self {
         Self {
             amounts: Default::default(),
-            smallest_fill: conv::u256_to_bigdecimal(&smallest_fill.0),
+            smallest_fill: u256_to_big_decimal(&smallest_fill.0),
         }
     }
 
@@ -55,7 +56,7 @@ impl Fills {
         let smallest_fill = self.smallest_fill.clone()
             * conv::ether_to_decimal(&tokens.reference_price(&ETH)?.0)
             / conv::ether_to_decimal(&tokens.reference_price(&token)?.0);
-        let smallest_fill = conv::bigdecimal_to_u256(&smallest_fill)?;
+        let smallest_fill = big_decimal_to_u256(&smallest_fill)?;
 
         let now = Instant::now();
 
diff --git a/crates/solvers/src/infra/dex/bitget/dto.rs b/crates/solvers/src/infra/dex/bitget/dto.rs
index 30a743d3a4..93122a3393 100644
--- a/crates/solvers/src/infra/dex/bitget/dto.rs
+++ b/crates/solvers/src/infra/dex/bitget/dto.rs
@@ -138,10 +138,8 @@ pub struct SwapTransaction {
 }
 
 impl SwapTransaction {
-    /// Decode the hex-encoded calldata (with "0x" prefix) to bytes.
-    pub fn decode_calldata(&self) -> Result<Vec<u8>, hex::FromHexError> {
-        let hex_str = self.data.strip_prefix("0x").unwrap_or(&self.data);
-        hex::decode(hex_str)
+    pub fn decode_calldata(&self) -> Result<Vec<u8>, const_hex::FromHexError> {
+        const_hex::decode(&self.data)
     }
 }
 
diff --git a/crates/solvers/src/infra/dex/bitget/mod.rs b/crates/solvers/src/infra/dex/bitget/mod.rs
index ab8ae42d65..0967053575 100644
--- a/crates/solvers/src/infra/dex/bitget/mod.rs
+++ b/crates/solvers/src/infra/dex/bitget/mod.rs
@@ -8,6 +8,7 @@ use {
     bigdecimal::BigDecimal,
     ethrpc::block_stream::CurrentBlockWatcher,
     hmac::{Hmac, Mac},
+    number::conversions::{big_decimal_to_u256, u256_to_big_uint},
     sha2::Sha256,
     std::{
         collections::BTreeMap,
@@ -19,18 +20,14 @@ use {
 /// Convert a U256 wei amount to a decimal string using the token's decimals.
 /// e.g., 1000000000000000000 with 18 decimals → "1"
 fn wei_to_decimal(amount: U256, decimals: u8) -> BigDecimal {
-    BigDecimal::new(
-        util::conv::u256_to_biguint(&amount).into(),
-        i64::from(decimals),
-    )
-    .normalized()
+    BigDecimal::new(u256_to_big_uint(&amount).into(), i64::from(decimals)).normalized()
 }
 
 /// Convert a decimal amount (from API response) to U256 wei.
 /// e.g., "1964.365496" with 6 decimals → 1964365496
 fn decimal_to_wei(amount: &BigDecimal, decimals: u8) -> Result<U256, Error> {
     let scaled = amount * BigDecimal::new(1.into(), -i64::from(decimals));
-    util::conv::bigdecimal_to_u256(&scaled).ok_or(Error::AmountConversionFailed)
+    big_decimal_to_u256(&scaled).ok_or(Error::AmountConversionFailed)
 }
 
 mod dto;
diff --git a/crates/solvers/src/util/bytes.rs b/crates/solvers/src/util/bytes.rs
deleted file mode 100644
index b6e52c8a07..0000000000
--- a/crates/solvers/src/util/bytes.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-/// A thin wrapper around a collection of bytes. Provides hex debug formatting.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
-pub struct Bytes<T>(pub T);
-
-impl<T> std::fmt::Debug for Bytes<T>
-where
-    T: AsRef<[u8]>,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", const_hex::encode_prefixed(&self.0))
-    }
-}
diff --git a/crates/solvers/src/util/conv.rs b/crates/solvers/src/util/conv.rs
index 7563762360..dba3233a90 100644
--- a/crates/solvers/src/util/conv.rs
+++ b/crates/solvers/src/util/conv.rs
@@ -1,64 +1,22 @@
-//! Conversion utilities.
+//! Conversion utilities for `eth::Ether` and `eth::Rational`.
 
 use {
     crate::domain::eth,
-    alloy::primitives::U256,
-    bigdecimal::{BigDecimal, num_bigint::ToBigInt},
-    num::{BigInt, BigUint, One, rational::Ratio},
+    bigdecimal::BigDecimal,
+    num::{BigInt, One},
+    number::conversions::{big_decimal_to_big_rational, big_int_to_u256, u256_to_big_uint},
 };
 
 /// Converts a `BigDecimal` value to a `eth::Rational` value. Returns `None` if
 /// the specified decimal value cannot be represented as a rational of `U256`
 /// integers.
 pub fn decimal_to_rational(d: &BigDecimal) -> Option<eth::Rational> {
-    let (int, exp) = d.as_bigint_and_exponent();
-
-    // First convert to a `Ratio<BigUint>`. This ensures that the ratio is
-    // normalized (i.e. GCD of numerator and denomninator is 1) before trying to
-    // convert the components to `U256`s. This allows values like `1.00...000`
-    // that would otherwise overflow a `U256` numerator.
-    let uint = int.to_biguint()?;
-    let factor = BigUint::from(10_u8).pow(exp.unsigned_abs().try_into().ok()?);
-    let ratio = if exp >= 0 {
-        Ratio::new(uint, factor)
-    } else {
-        Ratio::new(uint * factor, num::one())
-    };
-
-    let numer = biguint_to_u256(ratio.numer())?;
-    let denom = biguint_to_u256(ratio.denom())?;
-
+    let ratio = big_decimal_to_big_rational(d);
+    let numer = big_int_to_u256(ratio.numer()).ok()?;
+    let denom = big_int_to_u256(ratio.denom()).ok()?;
     Some(eth::Rational::new_raw(numer, denom))
 }
 
-pub fn biguint_to_u256(i: &BigUint) -> Option<U256> {
-    let bytes = i.to_bytes_be();
-    if bytes.len() > 32 {
-        return None;
-    }
-    Some(U256::from_be_slice(&bytes))
-}
-
-pub fn u256_to_biguint(i: &U256) -> BigUint {
-    BigUint::from_bytes_be(i.to_be_bytes::<32>().as_slice())
-}
-
-pub fn u256_to_bigdecimal(i: &U256) -> BigDecimal {
-    BigDecimal::new(u256_to_biguint(i).into(), 0)
-}
-
-pub fn bigint_to_u256(i: &BigInt) -> Option<U256> {
-    if i.sign() == num::bigint::Sign::Minus {
-        return None;
-    }
-    biguint_to_u256(i.magnitude())
-}
-
-pub fn bigdecimal_to_u256(d: &BigDecimal) -> Option<U256> {
-    let d = d.to_bigint()?;
-    bigint_to_u256(&d)
-}
-
 /// Converts a `BigDecimal` amount in Ether units to wei.
 pub fn decimal_to_ether(d: &BigDecimal) -> Option<eth::Ether> {
     let scaled = d * BigDecimal::new(BigInt::one(), -18);
@@ -68,7 +26,7 @@ pub fn decimal_to_ether(d: &BigDecimal) -> Option<eth::Ether> {
 
 /// Converts an `eth::Ether` amount into a `BigDecimal` representation.
 pub fn ether_to_decimal(e: &eth::Ether) -> BigDecimal {
-    BigDecimal::new(u256_to_biguint(&e.0).into(), 18)
+    BigDecimal::new(u256_to_big_uint(&e.0).into(), 18)
 }
 
 #[cfg(test)]
diff --git a/crates/solvers/src/util/fmt/hex.rs b/crates/solvers/src/util/fmt/hex.rs
deleted file mode 100644
index 7d63c34b2b..0000000000
--- a/crates/solvers/src/util/fmt/hex.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use std::fmt::{self, Debug, Display, Formatter};
-
-pub struct Hex<'a>(pub &'a [u8]);
-
-impl Debug for Hex<'_> {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{self}")
-    }
-}
-
-impl Display for Hex<'_> {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_str(&const_hex::encode_prefixed(self.0))
-    }
-}
diff --git a/crates/solvers/src/util/fmt/mod.rs b/crates/solvers/src/util/fmt/mod.rs
deleted file mode 100644
index 876b089b6e..0000000000
--- a/crates/solvers/src/util/fmt/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod hex;
-
-pub use self::hex::Hex;
diff --git a/crates/solvers/src/util/mod.rs b/crates/solvers/src/util/mod.rs
index b27613cb8e..5a8b2816e3 100644
--- a/crates/solvers/src/util/mod.rs
+++ b/crates/solvers/src/util/mod.rs
@@ -1,4 +1,2 @@
-pub mod bytes;
 pub mod conv;
-pub mod fmt;
 pub mod http;
diff --git a/crates/solvers/src/util/url.rs b/crates/solvers/src/util/url.rs
deleted file mode 100644
index e69de29bb2..0000000000

From 275f5f3fe93cb7659c29c8259c0d66cc2c7339ec Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Thu, 12 Mar 2026 19:40:18 +0100
Subject: [PATCH 147/219] Refactor http-client to separate crate (#4258)

# Description
During the simulator crate refactor I had to move a couple of types out
of shared to avoid cyclic dependency. It also makes sense since
price_estimation essentially duplicated http-client logic.

# Changes
Creates a new crate `http-client` where the previously
`shared::http_client` is present. Updated imports.
De-duplicated `price-estimation` http client,.

## How to test
E2E tests should pass. Logic is the same.

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 Cargo.lock                                    | 15 +++++++++
 Cargo.toml                                    |  1 +
 crates/autopilot/Cargo.toml                   |  1 +
 crates/autopilot/src/run.rs                   |  8 ++---
 crates/driver/Cargo.toml                      |  1 +
 crates/driver/src/boundary/liquidity/mod.rs   |  2 +-
 .../driver/src/boundary/liquidity/zeroex.rs   |  6 ++--
 crates/http-client/Cargo.toml                 | 12 +++++++
 .../http_client.rs => http-client/src/lib.rs} | 31 ++-----------------
 crates/orderbook/Cargo.toml                   |  1 +
 crates/orderbook/src/run.rs                   |  8 ++---
 crates/price-estimation/Cargo.toml            |  1 +
 crates/price-estimation/src/factory.rs        |  2 +-
 .../src/trade_verifier/tenderly_api.rs        |  3 +-
 crates/price-estimation/src/utils/mod.rs      |  1 -
 crates/refunder/Cargo.toml                    |  1 +
 crates/refunder/src/arguments.rs              | 31 +++++++++++++++++--
 crates/shared/src/lib.rs                      |  1 -
 18 files changed, 79 insertions(+), 47 deletions(-)
 create mode 100644 crates/http-client/Cargo.toml
 rename crates/{shared/src/http_client.rs => http-client/src/lib.rs} (68%)

diff --git a/Cargo.lock b/Cargo.lock
index faba1286c3..48e9dc234c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1229,6 +1229,7 @@ dependencies = [
  "futures",
  "gas-price-estimation",
  "hex-literal",
+ "http-client",
  "humantime",
  "humantime-serde",
  "indexmap 2.13.0",
@@ -2986,6 +2987,7 @@ dependencies = [
  "futures",
  "gas-price-estimation",
  "hex-literal",
+ "http-client",
  "humantime",
  "humantime-serde",
  "itertools 0.14.0",
@@ -3836,6 +3838,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "http-client"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "configs",
+ "humantime",
+ "reqwest 0.13.2",
+]
+
 [[package]]
 name = "httparse"
 version = "1.10.1"
@@ -5127,6 +5139,7 @@ dependencies = [
  "futures",
  "gas-price-estimation",
  "hex-literal",
+ "http-client",
  "humantime",
  "humantime-serde",
  "mimalloc",
@@ -5439,6 +5452,7 @@ dependencies = [
  "futures",
  "gas-price-estimation",
  "hex-literal",
+ "http-client",
  "humantime",
  "humantime-serde",
  "itertools 0.14.0",
@@ -5926,6 +5940,7 @@ dependencies = [
  "ethrpc",
  "futures",
  "gas-price-estimation",
+ "http-client",
  "humantime",
  "mimalloc",
  "mockall",
diff --git a/Cargo.toml b/Cargo.toml
index 61b67a1750..ea187a408e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -65,6 +65,7 @@ hex-literal = "0.4.1"
 hmac = "0.12.1"
 http-body = "1"
 http-body-util = "0.1"
+http-client = { path = "crates/http-client" }
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
 indexmap = "2.2.6"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 90d1359e76..41198568ac 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -41,6 +41,7 @@ event-indexing = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
 hex-literal = { workspace = true }
+http-client = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 indexmap = { workspace = true }
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 99fe02662a..2e328407f5 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -33,6 +33,7 @@ use {
     contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
     ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
     event_indexing::block_retriever::BlockRetriever,
+    http_client::HttpClientFactory,
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::LivenessChecking,
@@ -43,7 +44,6 @@ use {
     },
     shared::{
         arguments::tracing_config,
-        http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
         token_list::{AutoUpdatingTokenList, TokenListConfiguration},
     },
@@ -299,9 +299,9 @@ pub async fn run(
             block_stream: eth.current_block().clone(),
         },
         factory::Components {
-            http_factory: price_estimation::utils::http_client_factory::HttpClientFactory::new(
-                http_factory.timeout,
-            ),
+            http_factory: http_client::HttpClientFactory::new(&configs::http_client::HttpClient {
+                timeout: http_factory.timeout,
+            }),
             deny_listed_tokens: deny_listed_tokens.clone(),
             tokens: token_info_fetcher.clone(),
             code_fetcher: code_fetcher.clone(),
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 783480f443..764544f466 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -44,6 +44,7 @@ event-indexing = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
 hex-literal = { workspace = true }
+http-client = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 itertools = { workspace = true }
diff --git a/crates/driver/src/boundary/liquidity/mod.rs b/crates/driver/src/boundary/liquidity/mod.rs
index face9b1efc..d55243f029 100644
--- a/crates/driver/src/boundary/liquidity/mod.rs
+++ b/crates/driver/src/boundary/liquidity/mod.rs
@@ -6,12 +6,12 @@ use {
     anyhow::Result,
     ethrpc::block_stream::CurrentBlockWatcher,
     futures::future,
+    http_client::HttpClientFactory,
     liquidity_sources::{
         base_tokens::BaseTokens,
         recent_block_cache::{self, CacheConfig},
     },
     model::TokenPair,
-    shared::http_client::HttpClientFactory,
     solver::{
         liquidity::Liquidity,
         liquidity_collector::{LiquidityCollecting, LiquidityCollector},
diff --git a/crates/driver/src/boundary/liquidity/zeroex.rs b/crates/driver/src/boundary/liquidity/zeroex.rs
index 3abf62dada..7e4e449547 100644
--- a/crates/driver/src/boundary/liquidity/zeroex.rs
+++ b/crates/driver/src/boundary/liquidity/zeroex.rs
@@ -8,9 +8,9 @@ use {
     },
     anyhow::anyhow,
     ethrpc::block_stream::CurrentBlockWatcher,
+    http_client::HttpClientFactory,
     liquidity_sources::zeroex::DefaultZeroExApi,
     price_estimation::gas::GAS_PER_ZEROEX_ORDER,
-    shared::http_client::HttpClientFactory,
     solver::{
         liquidity::{LimitOrder, zeroex::ZeroExLiquidity},
         liquidity_collector::LiquidityCollecting,
@@ -86,8 +86,8 @@ pub async fn collector(
     let settlement = *eth.contracts().settlement().address();
     let web3 = eth.web3().clone();
     let contract = contracts::alloy::IZeroex::Instance::deployed(&web3.provider).await?;
-    let http_client_factory = &HttpClientFactory::new(&shared::http_client::Arguments {
-        http_timeout: config.http_timeout,
+    let http_client_factory = &HttpClientFactory::new(&configs::http_client::HttpClient {
+        timeout: config.http_timeout,
     });
     let api = Arc::new(DefaultZeroExApi::new(
         http_client_factory.builder(),
diff --git a/crates/http-client/Cargo.toml b/crates/http-client/Cargo.toml
new file mode 100644
index 0000000000..1c03aea2d2
--- /dev/null
+++ b/crates/http-client/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "http-client"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "GPL-3.0-or-later"
+
+[dependencies]
+clap = { workspace = true }
+configs = { workspace = true }
+humantime = { workspace = true }
+reqwest = { workspace = true, features = ["cookies", "gzip", "json", "query"] }
diff --git a/crates/shared/src/http_client.rs b/crates/http-client/src/lib.rs
similarity index 68%
rename from crates/shared/src/http_client.rs
rename to crates/http-client/src/lib.rs
index 570a289fcb..1c8a086140 100644
--- a/crates/shared/src/http_client.rs
+++ b/crates/http-client/src/lib.rs
@@ -1,9 +1,6 @@
 use {
     reqwest::{Client, ClientBuilder},
-    std::{
-        fmt::{self, Display, Formatter},
-        time::Duration,
-    },
+    std::time::Duration,
 };
 
 const USER_AGENT: &str = "cowprotocol-services/2.0.0";
@@ -20,9 +17,9 @@ pub struct HttpClientFactory {
 }
 
 impl HttpClientFactory {
-    pub fn new(args: &Arguments) -> Self {
+    pub fn new(args: &configs::http_client::HttpClient) -> Self {
         Self {
-            timeout: args.http_timeout,
+            timeout: args.timeout,
         }
     }
 
@@ -60,25 +57,3 @@ impl From<configs::http_client::HttpClient> for HttpClientFactory {
         }
     }
 }
-
-/// Command line arguments for the common HTTP factory.
-#[derive(clap::Parser)]
-#[group(skip)]
-pub struct Arguments {
-    /// Default timeout in seconds for http requests.
-    #[clap(
-        long,
-        env,
-        default_value = "10s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub http_timeout: Duration,
-}
-
-impl Display for Arguments {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let Self { http_timeout } = self;
-
-        writeln!(f, "http_timeout: {http_timeout:?}")
-    }
-}
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index a48e571953..04ffa83848 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -36,6 +36,7 @@ ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
 hex-literal = { workspace = true }
+http-client = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 mimalloc = { workspace = true, optional = true }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 18a27661e2..de92028e1e 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -25,6 +25,7 @@ use {
         support::Balances,
     },
     gas_price_estimation::gas_price::InstrumentedGasEstimator,
+    http_client::HttpClientFactory,
     model::DomainSeparator,
     num::ToPrimitive,
     observe::metrics::{DEFAULT_METRICS_PORT, serve_metrics},
@@ -38,7 +39,6 @@ use {
     },
     shared::{
         arguments::tracing_config,
-        http_client::HttpClientFactory,
         order_quoting::{self, OrderQuoter},
         order_validation::{OrderValidPeriodConfiguration, OrderValidator},
     },
@@ -228,9 +228,9 @@ pub async fn run(args: Arguments, config: Configuration) {
             block_stream: current_block_stream.clone(),
         },
         factory::Components {
-            http_factory: price_estimation::utils::http_client_factory::HttpClientFactory::new(
-                http_factory.timeout,
-            ),
+            http_factory: http_client::HttpClientFactory::new(&configs::http_client::HttpClient {
+                timeout: http_factory.timeout,
+            }),
             deny_listed_tokens: deny_listed_tokens.clone(),
             tokens: token_info_fetcher.clone(),
             code_fetcher: code_fetcher.clone(),
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index c27a6b3ece..6cbc0a4280 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -26,6 +26,7 @@ derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
+http-client = { workspace = true }
 humantime = { workspace = true }
 humantime-serde = { workspace = true }
 itertools = { workspace = true }
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index 8b86ef7754..e8f8eb9567 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -14,7 +14,6 @@ use {
         buffered::{self, BufferedRequest, NativePriceBatchFetching},
         competition::PriceRanking,
         trade_verifier::{code_fetching::CachedCodeFetcher, tenderly_api::TenderlyCodeSimulator},
-        utils::http_client_factory::HttpClientFactory,
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
@@ -27,6 +26,7 @@ use {
     contracts::alloy::WETH9,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     gas_price_estimation::GasPriceEstimating,
+    http_client::HttpClientFactory,
     number::nonzero::NonZeroU256,
     rate_limit::RateLimiter,
     reqwest::Url,
diff --git a/crates/price-estimation/src/trade_verifier/tenderly_api.rs b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
index d835c5303f..b05025da43 100644
--- a/crates/price-estimation/src/trade_verifier/tenderly_api.rs
+++ b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
@@ -1,7 +1,7 @@
 //! Module containing Tenderly API implementation.
 
 use {
-    crate::utils::{display_option, display_secret_option, http_client_factory::HttpClientFactory},
+    crate::utils::{display_option, display_secret_option},
     alloy::{
         primitives::{Address, B256, TxKind, U256, map::B256Map},
         rpc::types::{TransactionRequest, state::StateOverride as AlloyStateOverride},
@@ -9,6 +9,7 @@ use {
     anyhow::{Result, ensure},
     bytes_hex::BytesHex,
     clap::Parser,
+    http_client::HttpClientFactory,
     prometheus::IntGaugeVec,
     reqwest::{
         Url,
diff --git a/crates/price-estimation/src/utils/mod.rs b/crates/price-estimation/src/utils/mod.rs
index bd4c6c2ade..3dbb8bc13d 100644
--- a/crates/price-estimation/src/utils/mod.rs
+++ b/crates/price-estimation/src/utils/mod.rs
@@ -7,7 +7,6 @@ use {
 };
 
 pub mod encoding;
-pub mod http_client_factory;
 
 /// Join a path with a URL, ensuring that there is only one slash between them.
 /// It doesn't matter if the URL ends with a slash or the path starts with one.
diff --git a/crates/refunder/Cargo.toml b/crates/refunder/Cargo.toml
index 174774350f..a08f32eeba 100644
--- a/crates/refunder/Cargo.toml
+++ b/crates/refunder/Cargo.toml
@@ -16,6 +16,7 @@ database = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
+http-client = { workspace = true }
 humantime = { workspace = true }
 mimalloc = { workspace = true, optional = true }
 number = { workspace = true }
diff --git a/crates/refunder/src/arguments.rs b/crates/refunder/src/arguments.rs
index 36fab7d1d0..6eb2bba00a 100644
--- a/crates/refunder/src/arguments.rs
+++ b/crates/refunder/src/arguments.rs
@@ -1,17 +1,42 @@
 use {
     alloy::primitives::Address,
     clap::Parser,
-    shared::{arguments::display_option, http_client, logging_args_with_default_filter, web3},
-    std::time::Duration,
+    shared::{arguments::display_option, logging_args_with_default_filter, web3},
+    std::{
+        fmt::{self, Display, Formatter},
+        time::Duration,
+    },
     url::Url,
 };
 
 logging_args_with_default_filter!(LoggingArguments, "warn,refunder=debug,shared=debug");
 
+/// Command line arguments for the common HTTP factory.
+/// TODO: will be removed after refunder is migrated to `configs` crate.
+#[derive(clap::Parser)]
+#[group(skip)]
+pub struct HttpClientArguments {
+    /// Default timeout in seconds for http requests.
+    #[clap(
+        long,
+        env,
+        default_value = "10s",
+        value_parser = humantime::parse_duration,
+    )]
+    pub http_timeout: Duration,
+}
+
+impl Display for HttpClientArguments {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let Self { http_timeout } = self;
+        writeln!(f, "http_timeout: {http_timeout:?}")
+    }
+}
+
 #[derive(Parser)]
 pub struct Arguments {
     #[clap(flatten)]
-    pub http_client: http_client::Arguments,
+    pub http_client: HttpClientArguments,
 
     #[clap(flatten)]
     pub ethrpc: web3::Arguments,
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 4bbeb6f3ec..7c036790cc 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -8,7 +8,6 @@ pub mod encoded_settlement;
 pub mod event_storing_helpers;
 pub mod external_prices;
 pub mod fee;
-pub mod http_client;
 pub mod http_solver;
 pub mod interaction;
 pub mod order_quoting;

From e20bca04a91a029813c8004d2f453974e76b6816 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Mar 2026 09:48:03 +0100
Subject: [PATCH 148/219] Increase quote verification gas limit (#4261)

# Description
Some insanely complicated quotes exceed the hardcoded 12M gas limit on
the simulation. I'm not sure why originally picked the very big but not
the highest possible value of 8M which we later bumped to 12M.

# Changes
This PR now makes this value configurable and sets the default to
ethereum's maximum amount of gas a single tx may consume.
Any quote that needs more gas than this can definitely not be included
in an ethereum block.
---
 crates/e2e/tests/e2e/quote_verification.rs        | 1 +
 crates/price-estimation/src/factory.rs            | 1 +
 crates/price-estimation/src/lib.rs                | 9 +++++++++
 crates/price-estimation/src/trade_verifier/mod.rs | 6 ++++--
 4 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 8013e903a5..1ffb976a61 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -153,6 +153,7 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
         *onchain.contracts().weth.address(),
         BigDecimal::zero(),
         Default::default(),
+        12_000_000,
     )
     .await
     .unwrap();
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index e8f8eb9567..d548d88d15 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -115,6 +115,7 @@ impl<'a> PriceEstimatorFactory<'a> {
             network.native_token,
             args.quote_inaccuracy_limit.clone(),
             args.tokens_without_verification.iter().cloned().collect(),
+            args.max_gas_per_tx,
         )
         .await?;
         Ok(Some(Arc::new(verifier)))
diff --git a/crates/price-estimation/src/lib.rs b/crates/price-estimation/src/lib.rs
index b5bd54ae1a..d87ee49a62 100644
--- a/crates/price-estimation/src/lib.rs
+++ b/crates/price-estimation/src/lib.rs
@@ -107,6 +107,13 @@ pub struct Arguments {
     /// (e.g. private liquidity that exists but can't be verified).
     #[clap(long, env, value_delimiter = ',')]
     pub tokens_without_verification: Vec<Address>,
+
+    /// How much gas a single tx may consume at most. Any quote using more than
+    /// this will fail during the verification.
+    /// Defaults to the maximum transaction gas limit of ethereum introduced
+    /// in the Fusaka hardfork.
+    #[clap(long, env, default_value_t = 16777215)]
+    pub max_gas_per_tx: u64,
 }
 
 #[derive(clap::Parser)]
@@ -178,6 +185,7 @@ impl Display for Arguments {
             quote_timeout,
             balance_overrides,
             tokens_without_verification,
+            max_gas_per_tx,
         } = self;
 
         write!(f, "{tenderly}")?;
@@ -227,6 +235,7 @@ impl Display for Arguments {
             f,
             "tokens_without_verification: {tokens_without_verification:?}"
         )?;
+        writeln!(f, "max_gas_per_tx: {max_gas_per_tx}")?;
 
         Ok(())
     }
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index 9337666272..dadbb086cc 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -76,10 +76,10 @@ pub struct TradeVerifier {
     quote_inaccuracy_limit: BigRational,
     domain_separator: DomainSeparator,
     tokens_without_verification: HashSet<Address>,
+    gas_limit: u64,
 }
 
 impl TradeVerifier {
-    const DEFAULT_GAS: u64 = 12_000_000;
     const SPARDOSE: Address = address!("0000000000000000000000000000000000020000");
     const TRADER_IMPL: Address = address!("0000000000000000000000000000000000010000");
 
@@ -94,6 +94,7 @@ impl TradeVerifier {
         native_token: Address,
         quote_inaccuracy_limit: BigDecimal,
         tokens_without_verification: HashSet<Address>,
+        gas_limit: u64,
     ) -> Result<Self> {
         let settlement_contract =
             GPv2Settlement::GPv2Settlement::new(settlement, web3.provider.clone());
@@ -110,6 +111,7 @@ impl TradeVerifier {
             web3,
             domain_separator,
             tokens_without_verification,
+            gas_limit,
         })
     }
 
@@ -176,7 +178,7 @@ impl TradeVerifier {
             // Initiate tx as solver so gas doesn't get deducted from user's ETH.
             .from(solver_address)
             .to(solver_address)
-            .gas(Self::DEFAULT_GAS)
+            .gas(self.gas_limit)
             // Use a high enough non-zero gas price to catch tokens with special logic
             // for gas_price == 0 but also avoid reverts due to too low gas price.
             // The exact price is not important since we are only interested in the used

From c99b5d09a9f8d2b9e899c07c5184614894f322de Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 13 Mar 2026 09:48:39 +0100
Subject: [PATCH 149/219] Use write DB for latency sensitive queries (#4262)

# Description
Whenever the circuit breaker sees a new settlement onchain it asks the
API for the competition data on it to determine whether the tx was
allowed to be executed. Because the solver is supposed to be runnable by
anyone it fetches the necessary data from the public API instead of a DB
directly.
Yesterday a solver got wrongly deny-listed because the API did not
return the competition data for a given auction id. This was very
strange because we have logs confirming that the necessary data was
fully written to the DB at `2026-03-13 03:12:19` but the request coming
in at `2026-03-13 03:12:21` still returned no data.
In order to relieve strain on the primary DB we migrated all queries
that only read data to use the read replica instead.
Since the query is dirt simple and does not apply any complicated
filters or joins which could cause us to not return any data the most
likely culprit is the delay introduced by the replication process.


# Changes
Adjust the API to fetch latency sensitive competition data from the main
DB instead of the read replica.
In order to not comment multiple times why we use the write DB when only
read data I introduced private helper functions which return the
appropriate DB and commented why this is necessary.
---
 .../src/api/get_solver_competition.rs         | 17 +++++++++-----
 .../src/api/get_solver_competition_v2.rs      | 22 ++++++++++---------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/crates/orderbook/src/api/get_solver_competition.rs b/crates/orderbook/src/api/get_solver_competition.rs
index b94574b0bf..c1addf4873 100644
--- a/crates/orderbook/src/api/get_solver_competition.rs
+++ b/crates/orderbook/src/api/get_solver_competition.rs
@@ -24,8 +24,7 @@ pub async fn get_solver_competition_by_id_handler(
         return crate::solver_competition::LoadSolverCompetitionError::NotFound.into_response();
     }
 
-    let handler: &dyn SolverCompetitionStoring = &state.database_read;
-    handler
+    db(&state)
         .load_competition(Identifier::Id(auction_id.cast_signed()))
         .await
         .map(Json)
@@ -36,8 +35,7 @@ pub async fn get_solver_competition_by_hash_handler(
     State(state): State<Arc<AppState>>,
     Path(tx_hash): Path<B256>,
 ) -> Response {
-    let handler: &dyn SolverCompetitionStoring = &state.database_read;
-    handler
+    db(&state)
         .load_competition(Identifier::Transaction(tx_hash))
         .await
         .map(Json)
@@ -47,8 +45,15 @@ pub async fn get_solver_competition_by_hash_handler(
 pub async fn get_solver_competition_latest_handler(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<SolverCompetitionAPI>, crate::solver_competition::LoadSolverCompetitionError> {
-    let handler: &dyn SolverCompetitionStoring = &state.database_read;
-    handler.load_latest_competition().await.map(Json)
+    db(&state).load_latest_competition().await.map(Json)
+}
+
+fn db(state: &AppState) -> &dyn SolverCompetitionStoring {
+    // While these queries actually don't write to the DB
+    // the latency incurred by the DB replication process
+    // is not acceptable in some cases (e.g. when the circuit
+    // breaker needs to decide whether an tx was out of competition).
+    &state.database_write
 }
 
 #[cfg(test)]
diff --git a/crates/orderbook/src/api/get_solver_competition_v2.rs b/crates/orderbook/src/api/get_solver_competition_v2.rs
index daa7d8a71a..eab9dc3a2a 100644
--- a/crates/orderbook/src/api/get_solver_competition_v2.rs
+++ b/crates/orderbook/src/api/get_solver_competition_v2.rs
@@ -1,5 +1,5 @@
 use {
-    crate::{api::AppState, solver_competition::LoadSolverCompetitionError},
+    crate::{api::AppState, database::Postgres, solver_competition::LoadSolverCompetitionError},
     alloy::primitives::B256,
     axum::{
         extract::{Path, State},
@@ -21,8 +21,7 @@ pub async fn get_solver_competition_by_id_handler(
         return LoadSolverCompetitionError::NotFound.into_response();
     }
 
-    state
-        .database_read
+    db(&state)
         .load_competition_by_id(auction_id.cast_signed())
         .await
         .map(Json)
@@ -33,8 +32,7 @@ pub async fn get_solver_competition_by_hash_handler(
     State(state): State<Arc<AppState>>,
     Path(tx_hash): Path<B256>,
 ) -> Response {
-    state
-        .database_read
+    db(&state)
         .load_competition_by_tx_hash(tx_hash)
         .await
         .map(Json)
@@ -44,9 +42,13 @@ pub async fn get_solver_competition_by_hash_handler(
 pub async fn get_solver_competition_latest_handler(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<CompetitionResponse>, LoadSolverCompetitionError> {
-    state
-        .database_read
-        .load_latest_competition()
-        .await
-        .map(Json)
+    db(&state).load_latest_competition().await.map(Json)
+}
+
+fn db(state: &AppState) -> &Postgres {
+    // While these queries actually don't write to the DB
+    // the latency incurred by the DB replication process
+    // is not acceptable in some cases (e.g. when the circuit
+    // breaker needs to decide whether an tx was out of competition).
+    &state.database_write
 }

From 96d9eb08dbf09da62a04b0ddbeccb7f37f802ea6 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Fri, 13 Mar 2026 10:07:45 +0100
Subject: [PATCH 150/219] Allow full balance and allowance checking during
 order creation (#4229)

# Description
Most recently We have had an order that has passed our balance and
allowance checks, but ultimately the account did not have enough
allowance (up to the sell token amount) for it to be settled.

There are various balance checks in place (testing 1, 10, 100 transfer
amounts). Always checking the full sell amount would be a breaking
change, so it is introduced as additional parameter to the OrderCreation
request.

# Changes
Adds additional parameter to the OrderCreation request: fullBalanceCheck
(`full_balance_check`) which defaults to false. If set to true, the
order validation will attempt transfer of full sell token amount in
order to verify the account has enough balance and proper allowance.

This is an opt-in behavior for our partners to use for additional
robustness when placing simple orders (Flashloan orders or these using
wrappers still follow the old logic, of disabling the balance/allowance
checks since they can come from the additional interactions).

* Added `full_balance_check` to `OrderCreation` struct
* Sets the transfer amount to `sell_token_amount` for balance checks
* Added e2e test case covering the new behavior
* Updated the OpenAPI spec for order creation

## How to test
Test order creation when the account has not enough allowance or
balance, while enabling the fullBalanceCheck (it needs to have at least
1 atom of balance and allowance) - the order should not get created.

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/e2e/tests/e2e/uncovered_order.rs | 118 +++++++++++++++++++++
 crates/model/src/order.rs               |   8 ++
 crates/orderbook/openapi.yml            |   8 ++
 crates/shared/src/order_validation.rs   | 132 ++++++++++++++----------
 4 files changed, 212 insertions(+), 54 deletions(-)

diff --git a/crates/e2e/tests/e2e/uncovered_order.rs b/crates/e2e/tests/e2e/uncovered_order.rs
index a49e54243c..127cab8c51 100644
--- a/crates/e2e/tests/e2e/uncovered_order.rs
+++ b/crates/e2e/tests/e2e/uncovered_order.rs
@@ -15,6 +15,12 @@ async fn local_node_uncovered_order() {
     run_test(test).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_full_balance_check() {
+    run_test(test_full_balance_check).await;
+}
+
 /// Tests that a user can already create an order if they only have
 /// 1 wei of the sell token and later fund their account to get the
 /// order executed.
@@ -87,3 +93,115 @@ async fn test(web3: Web3) {
     .await
     .unwrap();
 }
+
+/// Tests that when order is placed with full balance checks, it would not be
+/// possible to place it, unless the account has both - sufficient allowance and
+/// balance.
+///
+/// It compares and asserts on the behaviour when the full balance check is
+/// disabled and enabled.
+async fn test_full_balance_check(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+    let weth = &onchain.contracts().weth;
+
+    // Initial allowance is enough to pass basic checks, but not enough to execute
+    // the order
+    weth.approve(onchain.contracts().allowance, 1u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Initial balance is enough to pass basic checks, but not enough to execute the
+    // order
+    weth.deposit()
+        .from(trader.address())
+        .value(1u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+    services.start_protocol(solver).await;
+
+    let order = OrderCreation {
+        sell_token: *weth.address(),
+        sell_amount: 2u64.eth(),
+        fee_amount: ::alloy::primitives::U256::ZERO,
+        buy_token: *token.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Sell,
+        partially_fillable: false,
+        ..Default::default()
+    };
+    let unchecked_order = order.clone().sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+
+    let order = OrderCreation {
+        full_balance_check: true,
+        // different valid_to for orders to be considered distinct
+        valid_to: model::time::now_in_epoch_seconds() + 301,
+        ..order
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+
+    // This order can be created because full balance checks are not enabled.
+    // The account has 1 WEI of the token and allowance for this amount.
+    services.create_order(&unchecked_order).await.unwrap();
+
+    // This order can not be created, because despite the token being transferrable
+    // The account does not have enough sell token balance to cover the order.
+    assert!(
+        services
+            .create_order(&order)
+            .await
+            .unwrap_err()
+            .1
+            .contains("InsufficientBalance")
+    );
+
+    // Add the missing balance for the balance checkE
+    weth.deposit()
+        .from(trader.address())
+        .value(1u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // This order can not be created, because the account does not have enough
+    // sell token allowance.
+    assert!(
+        services
+            .create_order(&order)
+            .await
+            .unwrap_err()
+            .1
+            .contains("InsufficientAllowance")
+    );
+
+    // Set allowance to the full amount
+    weth.approve(onchain.contracts().allowance, 2u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // This order can be created now, because account has correct balance and
+    // allowance
+    services.create_order(&order).await.unwrap();
+}
diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index 25fa288d97..5243118a99 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -342,6 +342,10 @@ pub struct OrderCreation {
     /// The order's AppData (can be an hash, the JSON body or both).
     #[serde(flatten)]
     pub app_data: OrderCreationAppData,
+    /// Should a transfer of the order's full balance be verified before
+    /// placement.
+    #[serde(default)]
+    pub full_balance_check: bool,
 }
 
 impl OrderCreation {
@@ -1224,6 +1228,7 @@ mod tests {
             from: Some(owner),
             signature: Signature::PreSign,
             quote_id: Some(42),
+            full_balance_check: false,
         };
 
         // Test PreSign round-trip (no signature normalization needed)
@@ -1245,6 +1250,7 @@ mod tests {
             "signingScheme": "presign",
             "signature": "0x",
             "from": owner,
+            "fullBalanceCheck": false
         });
         assert_json_matches!(json!(presign_order), presign_json);
         assert_eq!(presign_order, serde_json::from_value(presign_json).unwrap());
@@ -1270,6 +1276,7 @@ mod tests {
                           0000000000000000000000000000000000000000000000000000000000000000\
                           00",
             "from": owner,
+            "fullBalanceCheck": false,
         });
         let expected_order = OrderCreation {
             signature: Signature::Eip712(EcdsaSignature {
@@ -1304,6 +1311,7 @@ mod tests {
                           0000000000000000000000000000000000000000000000000000000000000000\
                           1b",
             "from": owner,
+            "fullBalanceCheck": false,
         });
         assert_json_matches!(json!(expected_order), output_json_v27);
     }
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 1b3b175361..5e16973189 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -1176,6 +1176,14 @@ components:
           allOf:
             - $ref: "#/components/schemas/AppDataHash"
           nullable: true
+        fullBalanceCheck:
+          description: >
+            If set to true, full sell amount will be checked during allowance and balance checking.
+            This will ensure the account has correct allowance and available balance for the order
+            to be created.
+
+          type: boolean
+          default: false
       required:
         - sellToken
         - buyToken
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index cde4d9eb78..0c7f2a90fe 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -395,6 +395,33 @@ impl OrderValidator {
         }
     }
 
+    async fn simulate_token_transfer(
+        &self,
+        order: &OrderCreation,
+        owner: Address,
+        app_data: &OrderAppData,
+        transfer_amount: U256,
+    ) -> Result<(), TransferSimulationError> {
+        self.balance_fetcher
+            .can_transfer(
+                &account_balances::Query {
+                    token: order.data().sell_token,
+                    owner,
+                    source: order.data().sell_token_balance,
+                    interactions: app_data.interactions.pre.clone(),
+                    balance_override: app_data.inner.protocol.flashloan.as_ref().map(|loan| {
+                        BalanceOverrideRequest {
+                            token: loan.token,
+                            holder: loan.receiver,
+                            amount: loan.amount,
+                        }
+                    }),
+                },
+                transfer_amount,
+            )
+            .await
+    }
+
     /// Verifies that tokens can actually be transferred from the user account
     /// to the settlement contract (takes pre-hooks into account).
     async fn ensure_token_is_transferable(
@@ -403,77 +430,74 @@ impl OrderValidator {
         owner: Address,
         app_data: &OrderAppData,
     ) -> Result<(), ValidationError> {
-        let mut res = Ok(());
-        let has_wrappers = !app_data.inner.protocol.wrappers.is_empty();
-
-        // Simulate transferring a small token balance into the settlement contract.
-        // As a spam protection we require that an account must have at least 1 atom
-        // of the sell_token. However, some tokens (e.g. rebasing tokens) actually run
-        // into numerical issues with such small amounts. But there are also tokens
-        // where a single atom is already quite expensive (tokenized stocks).
-        // To cover both cases we simulate multiple small transfers. As soon as one
-        // passes we consider the token transferable. If all transfers fail we return
-        // the last error.
-        for transfer_amount in [1, 10, 100].into_iter().map(U256::from) {
-            match self
-                .balance_fetcher
-                .can_transfer(
-                    &account_balances::Query {
-                        token: order.data().sell_token,
-                        owner,
-                        source: order.data().sell_token_balance,
-                        interactions: app_data.interactions.pre.clone(),
-                        balance_override: app_data.inner.protocol.flashloan.as_ref().map(|loan| {
-                            BalanceOverrideRequest {
-                                token: loan.token,
-                                holder: loan.receiver,
-                                amount: loan.amount,
-                            }
-                        }),
-                    },
-                    transfer_amount,
-                )
-                .await
-            {
-                Ok(_) => return Ok(()),
-                Err(
+        let simulate_transfers = async |transfer_amounts: &[U256]| {
+            let mut res = Ok(());
+            let has_wrappers = !app_data.inner.protocol.wrappers.is_empty();
+
+            for transfer_amount in transfer_amounts {
+                let Err(err) = self
+                    .simulate_token_transfer(order, owner, app_data, *transfer_amount)
+                    .await
+                else {
+                    return Ok(());
+                };
+
+                res = match err {
                     TransferSimulationError::InsufficientAllowance
                     | TransferSimulationError::InsufficientBalance
-                    | TransferSimulationError::TransferFailed,
-                ) if order.signature == Signature::PreSign || has_wrappers => {
-                    // Pre-sign orders do not require sufficient balance or allowance.
-                    // The idea is that this allows smart contracts to place orders bundled with
-                    // other transactions that either produce the required balance or set the
-                    // allowance. This would, for example, allow a Gnosis Safe to bundle the
-                    // pre-signature transaction with a WETH wrap and WETH approval to the vault
-                    // relayer contract.
-                    //
-                    // Similarly, orders with wrappers may produce the required balance or
-                    // allowance as part of the wrapper execution.
-                    return Ok(());
-                }
-                Err(err) => match err {
+                    | TransferSimulationError::TransferFailed
+                        if order.signature == Signature::PreSign || has_wrappers =>
+                    {
+                        // Pre-sign orders do not require sufficient balance or allowance.
+                        // The idea is that this allows smart contracts to place orders bundled with
+                        // other transactions that either produce the required balance or set the
+                        // allowance. This would, for example, allow a Gnosis Safe to bundle the
+                        // pre-signature transaction with a WETH wrap and WETH approval to the vault
+                        // relayer contract.
+                        //
+                        // Similarly, orders with wrappers may produce the required balance or
+                        // allowance as part of the wrapper execution.
+                        return Ok(());
+                    }
                     TransferSimulationError::InsufficientAllowance => {
                         // This error will be triggered regardless of the amount
                         return Err(ValidationError::InsufficientAllowance);
                     }
                     TransferSimulationError::InsufficientBalance => {
-                        // Since the amount starts at 1 atom, if this error is triggered then it
+                        // Since the amount either starts at 1 atom, or is set to the full sell
+                        // token amount if this error is triggered then it
                         // will be triggered for the other amounts too
                         return Err(ValidationError::InsufficientBalance);
                     }
                     TransferSimulationError::TransferFailed => {
-                        res = Err(ValidationError::TransferSimulationFailed);
+                        Err(ValidationError::TransferSimulationFailed)
                     }
                     TransferSimulationError::Other(err) => {
                         tracing::warn!("TransferSimulation failed: {:?}", err);
-                        res = Err(ValidationError::TransferSimulationFailed);
+                        Err(ValidationError::TransferSimulationFailed)
                     }
-                },
+                };
             }
-        }
+            res
+        };
 
-        res
+        if order.full_balance_check {
+            // If requested at order creation, simulate transferring full sell_amount
+            // into the settlement contract.
+            // This will ensure the account has enough allowance and balance for
+            // the transfer at the order creation time.
+            simulate_transfers([order.data().sell_amount].as_slice()).await
+        } else {
+            // Simulate transferring a small token balance into the settlement contract.
+            // As a spam protection we require that an account must have at least 1 atom
+            // of the sell_token. However, some tokens (e.g. rebasing tokens) actually run
+            // into numerical issues with such small amounts. But there are also tokens
+            // where a single atom is already quite expensive (tokenized stocks).
+            // To cover both cases we simulate multiple small transfers. As soon as one
+            // passes we consider the token transferable. If all transfers fail we return
+            // the last error.
+            simulate_transfers([1, 10, 100].map(U256::from).as_slice()).await
+        }
     }
 }
 

From f59d9b43066ee0f667a2b3c2dfac24ad312f603e Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Mon, 16 Mar 2026 13:46:32 +0100
Subject: [PATCH 151/219] Move common eth domain types to separate crate
 (#4260)

# Description
Many crates duplicate eth specific domain types. The incoming simulator
crate would also have to have its own, with tedious conversions between
them.

Instead of doing that, the eth domain types are moved into a new crate
`eth-domain-types`. This PR migrates autopilot to use it.

There will be follow-up PRs migrating rest of the services.

# Changes
Moved autopilot's eth domain types into separate crate, changed the
imports.

## How to test
E2E tests should pass, it's a drop-in replacement.

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 Cargo.lock                                    |  13 +
 Cargo.toml                                    |   1 +
 crates/autopilot/Cargo.toml                   |   1 +
 crates/autopilot/src/boundary/order.rs        |   5 +-
 crates/autopilot/src/domain/auction/mod.rs    |   5 +-
 crates/autopilot/src/domain/auction/order.rs  |   3 +-
 crates/autopilot/src/domain/blockchain.rs     |  47 +++
 .../autopilot/src/domain/competition/mod.rs   |   3 +-
 .../domain/competition/winner_selection.rs    |  16 +-
 crates/autopilot/src/domain/eth/mod.rs        | 366 ------------------
 crates/autopilot/src/domain/fee/mod.rs        |   3 +-
 crates/autopilot/src/domain/mod.rs            |   2 +-
 crates/autopilot/src/domain/quote/mod.rs      |   3 +-
 .../src/domain/settlement/auction.rs          |   7 +-
 crates/autopilot/src/domain/settlement/mod.rs |  71 ++--
 .../src/domain/settlement/observer.rs         |   8 +-
 .../src/domain/settlement/trade/math.rs       |   4 +-
 .../src/domain/settlement/trade/mod.rs        |  10 +-
 .../src/domain/settlement/transaction/mod.rs  |  11 +-
 .../settlement/transaction/tokenized.rs       |   3 +-
 .../src/infra/blockchain/contracts.rs         |  10 +-
 crates/autopilot/src/infra/blockchain/mod.rs  |  23 +-
 .../src/infra/persistence/dto/auction.rs      |   7 +-
 .../src/infra/persistence/dto/order.rs        |   3 +-
 crates/autopilot/src/infra/persistence/mod.rs |  40 +-
 .../autopilot/src/infra/solvers/dto/solve.rs  |   7 +-
 crates/autopilot/src/infra/solvers/mod.rs     |   3 +-
 crates/autopilot/src/run_loop.rs              |   8 +-
 crates/autopilot/src/shadow.rs                |   2 +-
 crates/autopilot/src/solvable_orders.rs       |   6 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |   3 +-
 crates/eth-domain-types/Cargo.toml            |  14 +
 crates/eth-domain-types/src/access_list.rs    |  94 +++++
 crates/eth-domain-types/src/allowance.rs      |  63 +++
 crates/eth-domain-types/src/eip712.rs         |   9 +
 crates/eth-domain-types/src/ether.rs          |  60 +++
 crates/eth-domain-types/src/gas.rs            | 150 +++++++
 crates/eth-domain-types/src/lib.rs            | 138 +++++++
 crates/eth-domain-types/src/token_amount.rs   | 125 ++++++
 39 files changed, 854 insertions(+), 493 deletions(-)
 create mode 100644 crates/autopilot/src/domain/blockchain.rs
 delete mode 100644 crates/autopilot/src/domain/eth/mod.rs
 create mode 100644 crates/eth-domain-types/Cargo.toml
 create mode 100644 crates/eth-domain-types/src/access_list.rs
 create mode 100644 crates/eth-domain-types/src/allowance.rs
 create mode 100644 crates/eth-domain-types/src/eip712.rs
 create mode 100644 crates/eth-domain-types/src/ether.rs
 create mode 100644 crates/eth-domain-types/src/gas.rs
 create mode 100644 crates/eth-domain-types/src/lib.rs
 create mode 100644 crates/eth-domain-types/src/token_amount.rs

diff --git a/Cargo.lock b/Cargo.lock
index 48e9dc234c..bb5d7969be 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1224,6 +1224,7 @@ dependencies = [
  "dashmap",
  "database",
  "derive_more 1.0.0",
+ "eth-domain-types",
  "ethrpc",
  "event-indexing",
  "futures",
@@ -3199,6 +3200,18 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "eth-domain-types"
+version = "0.1.0"
+dependencies = [
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rpc-types",
+ "derive_more 1.0.0",
+ "num",
+ "number",
+]
+
 [[package]]
 name = "ethrpc"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index ea187a408e..29c18c43bf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -55,6 +55,7 @@ dashmap = "6.1.0"
 database = { path = "crates/database" }
 derive_more = { version = "1.0.0", features = ["full"] }
 driver = { path = "crates/driver" }
+eth-domain-types = { path = "crates/eth-domain-types" }
 ethrpc = { path = "crates/ethrpc" }
 event-indexing = { path = "crates/event-indexing" }
 flate2 = "1.0.30"
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 41198568ac..7dcd7080b6 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -36,6 +36,7 @@ cow-amm = { workspace = true }
 dashmap = { workspace = true }
 database = { workspace = true }
 derive_more = { workspace = true }
+eth-domain-types = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
 futures = { workspace = true }
diff --git a/crates/autopilot/src/boundary/order.rs b/crates/autopilot/src/boundary/order.rs
index 04d43fb5bf..6c8bf827f7 100644
--- a/crates/autopilot/src/boundary/order.rs
+++ b/crates/autopilot/src/boundary/order.rs
@@ -1,7 +1,4 @@
-use {
-    crate::domain::{self, eth},
-    shared::remaining_amounts,
-};
+use {crate::domain, eth_domain_types as eth, shared::remaining_amounts};
 
 pub fn to_domain(
     order: &model::order::Order,
diff --git a/crates/autopilot/src/domain/auction/mod.rs b/crates/autopilot/src/domain/auction/mod.rs
index 3580bebe64..c6a4ef36ec 100644
--- a/crates/autopilot/src/domain/auction/mod.rs
+++ b/crates/autopilot/src/domain/auction/mod.rs
@@ -1,6 +1,7 @@
 use {
-    super::{Order, eth},
+    super::Order,
     alloy::primitives::{Address, U256},
+    eth_domain_types as eth,
     std::collections::HashMap,
 };
 
@@ -68,7 +69,7 @@ impl Price {
     /// Converting 1 ETH expressed in `eth::TokenAmount` into `eth::Ether`
     ///
     /// ```
-    /// use autopilot::domain::{auction::Price, eth};
+    /// use {autopilot::domain::auction::Price, eth_domain_types as eth};
     ///
     /// let amount = eth::TokenAmount::from(eth::U256::from(10).pow(eth::U256::from(18)));
     /// let price = Price::try_new(eth::Ether::from(
diff --git a/crates/autopilot/src/domain/auction/order.rs b/crates/autopilot/src/domain/auction/order.rs
index 83715810f2..602411ec31 100644
--- a/crates/autopilot/src/domain/auction/order.rs
+++ b/crates/autopilot/src/domain/auction/order.rs
@@ -1,6 +1,7 @@
 use {
-    crate::domain::{self, eth, fee},
+    crate::domain::{self, fee},
     alloy::primitives::{Address, B256, U256},
+    eth_domain_types as eth,
     std::fmt::{self, Debug, Display, Formatter},
 };
 
diff --git a/crates/autopilot/src/domain/blockchain.rs b/crates/autopilot/src/domain/blockchain.rs
new file mode 100644
index 0000000000..05f3d709e2
--- /dev/null
+++ b/crates/autopilot/src/domain/blockchain.rs
@@ -0,0 +1,47 @@
+use eth_domain_types as eth;
+
+/// Originated from the blockchain transaction input data.
+pub type Calldata = alloy::primitives::Bytes;
+
+/// Call frames of a transaction.
+#[derive(Clone, Debug, Default)]
+pub struct CallFrame {
+    /// The address of the call initiator.
+    pub from: eth::Address,
+    /// The address of the contract that was called.
+    pub to: Option<eth::Address>,
+    /// Calldata input.
+    pub input: Calldata,
+    /// Recorded child calls.
+    pub calls: Vec<CallFrame>,
+}
+
+impl From<alloy::rpc::types::trace::geth::CallFrame> for CallFrame {
+    fn from(value: alloy::rpc::types::trace::geth::CallFrame) -> Self {
+        Self {
+            from: value.from,
+            to: value.to,
+            input: value.input,
+            calls: value.calls.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+/// Any type of on-chain transaction.
+#[derive(Debug, Clone, Default)]
+pub struct Transaction {
+    /// The hash of the transaction.
+    pub hash: eth::TxId,
+    /// The address of the sender of the transaction.
+    pub from: eth::Address,
+    /// The block number of the block that contains the transaction.
+    pub block: eth::BlockNo,
+    /// The timestamp of the block that contains the transaction.
+    pub timestamp: u32,
+    /// The gas used by the transaction.
+    pub gas: eth::Gas,
+    /// The effective gas price of the transaction.
+    pub gas_price: eth::EffectiveGasPrice,
+    /// Traces of all Calls contained in the transaction.
+    pub trace_calls: CallFrame,
+}
diff --git a/crates/autopilot/src/domain/competition/mod.rs b/crates/autopilot/src/domain/competition/mod.rs
index 0a3a25e51a..2900ddec47 100644
--- a/crates/autopilot/src/domain/competition/mod.rs
+++ b/crates/autopilot/src/domain/competition/mod.rs
@@ -1,8 +1,9 @@
 use {
     super::auction::order,
-    crate::domain::{self, auction, eth},
+    crate::domain::{self, auction},
     alloy::primitives::Address,
     derive_more::Display,
+    eth_domain_types as eth,
     num::Saturating,
     std::collections::HashMap,
 };
diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 4d4ef0ff5c..6fcf605c86 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -29,10 +29,10 @@ use {
         self,
         auction::order,
         competition::{Bid, RankType, Ranked, Score, Solution, TradedOrder, Unscored},
-        eth::{self, WrappedNativeToken},
         fee,
     },
     ::winner_selection::state::{HasState, RankedItem, ScoredItem, UnscoredItem},
+    eth_domain_types::{self as eth, Address, WrappedNativeToken},
     std::collections::HashMap,
     tracing::instrument,
     winner_selection::{self as winsel},
@@ -49,10 +49,10 @@ pub struct Arbitrator(winsel::Arbitrator);
 /// changing the ordering or the `bids`.
 impl Arbitrator {
     pub fn new(max_winners: usize, wrapped_native_token: WrappedNativeToken) -> Self {
-        let token: eth::TokenAddress = wrapped_native_token.into();
+        let token: eth::TokenAddress = *wrapped_native_token;
         Self(winsel::Arbitrator {
             max_winners,
-            weth: token.0,
+            weth: *token,
         })
     }
 
@@ -139,7 +139,7 @@ impl From<&domain::Auction> for winsel::AuctionContext {
             native_prices: auction
                 .prices
                 .iter()
-                .map(|(token, price)| (token.0, price.get().0))
+                .map(|(token, price)| (Address::from(*token), price.get().0))
                 .collect(),
         }
     }
@@ -158,7 +158,7 @@ impl From<&Solution> for winsel::Solution<winsel::Unscored> {
             solution
                 .prices()
                 .iter()
-                .map(|(token, price)| (token.0, price.get().0))
+                .map(|(token, price)| (Address::from(*token), price.get().0))
                 .collect(),
         )
     }
@@ -167,8 +167,8 @@ impl From<&Solution> for winsel::Solution<winsel::Unscored> {
 fn to_winsel_order(uid: domain::OrderUid, order: &TradedOrder) -> winsel::Order {
     winsel::Order {
         uid: winsel::OrderUid(uid.0),
-        sell_token: order.sell.token.0,
-        buy_token: order.buy.token.0,
+        sell_token: *order.sell.token,
+        buy_token: *order.buy.token,
         sell_amount: order.sell.amount.0,
         buy_amount: order.buy.amount.0,
         executed_sell: order.executed_sell.0,
@@ -292,12 +292,12 @@ mod tests {
                     order::{self, AppDataHash},
                 },
                 competition::{Bid, Solution, TradedOrder, Unscored},
-                eth::{self, TokenAddress},
             },
             infra::Driver,
         },
         alloy::primitives::{Address, U160, U256, address},
         configs::autopilot::solver::Account,
+        eth_domain_types::{self as eth, TokenAddress},
         hex_literal::hex,
         number::serialization::HexOrDecimalU256,
         serde::Deserialize,
diff --git a/crates/autopilot/src/domain/eth/mod.rs b/crates/autopilot/src/domain/eth/mod.rs
deleted file mode 100644
index e274e747c3..0000000000
--- a/crates/autopilot/src/domain/eth/mod.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-pub use alloy::primitives::{Address, B256, U256};
-use {
-    crate::domain,
-    derive_more::{Display, From, Into},
-    number::u256_ext::U256Ext,
-};
-
-/// ERC20 token address for ETH. In reality, ETH is not an ERC20 token because
-/// it does not implement the ERC20 interface, but this address is used by
-/// convention across the Ethereum ecosystem whenever ETH is treated like an
-/// ERC20 token.
-/// Same address is also used for XDAI on Gnosis Chain.
-pub const NATIVE_TOKEN: TokenAddress = TokenAddress(Address::repeat_byte(0xee));
-
-/// Block number.
-#[derive(Debug, Copy, Clone, From, PartialEq, PartialOrd, Default)]
-pub struct BlockNo(pub u64);
-
-/// Adding blocks to a block number.
-impl std::ops::Add<u64> for BlockNo {
-    type Output = BlockNo;
-
-    fn add(self, rhs: u64) -> Self::Output {
-        Self(self.0 + rhs)
-    }
-}
-
-/// A transaction ID, AKA transaction hash.
-#[derive(Debug, Copy, Clone, From, Default)]
-pub struct TxId(pub B256);
-
-/// An ERC20 token address.
-///
-/// https://eips.ethereum.org/EIPS/eip-20
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
-pub struct TokenAddress(pub Address);
-
-impl TokenAddress {
-    /// If the token is ETH/XDAI, return WETH/WXDAI, thereby converting it to
-    /// erc20.
-    pub fn as_erc20(self, wrapped: WrappedNativeToken) -> Self {
-        if self == NATIVE_TOKEN {
-            wrapped.into()
-        } else {
-            self
-        }
-    }
-}
-
-/// ERC20 representation of the chain's native token (e.g. WETH on mainnet,
-/// WXDAI on Gnosis Chain).
-#[derive(Debug, Clone, Copy, From, Into)]
-pub struct WrappedNativeToken(TokenAddress);
-
-impl From<Address> for WrappedNativeToken {
-    fn from(value: Address) -> Self {
-        WrappedNativeToken(value.into())
-    }
-}
-
-/// An ERC20 token amount.
-///
-/// https://eips.ethereum.org/EIPS/eip-20
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
-pub struct TokenAmount(pub U256);
-
-impl TokenAmount {
-    /// Applies a factor to the token amount.
-    pub fn apply_factor(&self, factor: f64) -> Option<Self> {
-        Some(self.0.checked_mul_f64(factor)?.into())
-    }
-}
-
-/// A value denominated in an order's surplus token (buy token for
-/// sell orders and sell token for buy orders).
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
-pub struct SurplusTokenAmount(pub U256);
-
-/// An ERC20 sell token amount.
-///
-/// https://eips.ethereum.org/EIPS/eip-20
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
-pub struct SellTokenAmount(pub U256);
-
-impl From<TokenAmount> for SellTokenAmount {
-    fn from(value: TokenAmount) -> Self {
-        Self(value.0)
-    }
-}
-
-impl From<SellTokenAmount> for TokenAmount {
-    fn from(value: SellTokenAmount) -> Self {
-        Self(value.0)
-    }
-}
-
-impl std::ops::Add for SellTokenAmount {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl num::Zero for SellTokenAmount {
-    fn zero() -> Self {
-        Self(U256::ZERO)
-    }
-
-    fn is_zero(&self) -> bool {
-        self.0.is_zero()
-    }
-}
-
-impl std::iter::Sum for SellTokenAmount {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        iter.fold(num::Zero::zero(), std::ops::Add::add)
-    }
-}
-
-impl std::ops::Sub<Self> for SellTokenAmount {
-    type Output = SellTokenAmount;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        self.0.sub(rhs.0).into()
-    }
-}
-
-impl num::CheckedSub for SellTokenAmount {
-    fn checked_sub(&self, other: &Self) -> Option<Self> {
-        self.0.checked_sub(other.0).map(Into::into)
-    }
-}
-
-impl num::Saturating for SellTokenAmount {
-    fn saturating_add(self, v: Self) -> Self {
-        self.0.saturating_add(v.0).into()
-    }
-
-    fn saturating_sub(self, v: Self) -> Self {
-        self.0.saturating_sub(v.0).into()
-    }
-}
-
-/// Gas amount in gas units.
-///
-/// The amount of Ether that is paid in transaction fees is proportional to this
-/// amount as well as the transaction's [`EffectiveGasPrice`].
-#[derive(Debug, Default, Display, Clone, Copy, Ord, Eq, PartialOrd, PartialEq, From, Into)]
-pub struct Gas(pub U256);
-
-impl From<u64> for Gas {
-    fn from(value: u64) -> Self {
-        Self(U256::from(value))
-    }
-}
-
-/// The `effective_gas_price` as defined by EIP-1559.
-///
-/// https://eips.ethereum.org/EIPS/eip-1559#specification
-#[derive(Debug, Clone, Copy, Display, Default)]
-pub struct EffectiveGasPrice(pub Ether);
-
-impl From<u128> for EffectiveGasPrice {
-    fn from(value: u128) -> Self {
-        Self(U256::from(value).into())
-    }
-}
-
-impl From<U256> for EffectiveGasPrice {
-    fn from(value: U256) -> Self {
-        Self(value.into())
-    }
-}
-
-impl From<EffectiveGasPrice> for U256 {
-    fn from(value: EffectiveGasPrice) -> Self {
-        value.0.into()
-    }
-}
-impl std::ops::Sub<Self> for TokenAmount {
-    type Output = TokenAmount;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        self.0.sub(rhs.0).into()
-    }
-}
-
-impl num::CheckedSub for TokenAmount {
-    fn checked_sub(&self, other: &Self) -> Option<Self> {
-        self.0.checked_sub(other.0).map(Into::into)
-    }
-}
-
-impl std::ops::Add for TokenAmount {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl num::CheckedAdd for TokenAmount {
-    fn checked_add(&self, other: &Self) -> Option<Self> {
-        self.0.checked_add(other.0).map(Into::into)
-    }
-}
-
-impl std::ops::Mul<Self> for TokenAmount {
-    type Output = TokenAmount;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        self.0.mul(rhs.0).into()
-    }
-}
-
-impl num::CheckedMul for TokenAmount {
-    fn checked_mul(&self, other: &Self) -> Option<Self> {
-        self.0.checked_mul(other.0).map(Into::into)
-    }
-}
-
-impl std::ops::Div<Self> for TokenAmount {
-    type Output = TokenAmount;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        self.0.div(rhs.0).into()
-    }
-}
-
-impl num::CheckedDiv for TokenAmount {
-    fn checked_div(&self, other: &Self) -> Option<Self> {
-        self.0.checked_div(other.0).map(Into::into)
-    }
-}
-
-impl std::ops::AddAssign for TokenAmount {
-    fn add_assign(&mut self, rhs: Self) {
-        self.0 += rhs.0;
-    }
-}
-
-impl num::Zero for TokenAmount {
-    fn zero() -> Self {
-        Self(U256::ZERO)
-    }
-
-    fn is_zero(&self) -> bool {
-        self.0.is_zero()
-    }
-}
-
-/// An asset on the Ethereum blockchain. Represents a particular amount of a
-/// particular token.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub struct Asset {
-    pub amount: TokenAmount,
-    pub token: TokenAddress,
-}
-
-/// An amount of native Ether tokens denominated in wei.
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    Eq,
-    Ord,
-    PartialEq,
-    PartialOrd,
-    From,
-    Into,
-    Display,
-    Default,
-    derive_more::Add,
-    derive_more::Sub,
-)]
-pub struct Ether(pub U256);
-
-impl num::Saturating for Ether {
-    fn saturating_add(self, v: Self) -> Self {
-        Self(self.0.saturating_add(v.0))
-    }
-
-    fn saturating_sub(self, v: Self) -> Self {
-        Self(self.0.saturating_sub(v.0))
-    }
-}
-
-impl num::CheckedSub for Ether {
-    fn checked_sub(&self, v: &Self) -> Option<Self> {
-        self.0.checked_sub(v.0).map(Ether)
-    }
-}
-
-impl num::Zero for Ether {
-    fn zero() -> Self {
-        Self(U256::ZERO)
-    }
-
-    fn is_zero(&self) -> bool {
-        self.0.is_zero()
-    }
-}
-
-impl std::iter::Sum for Ether {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        iter.fold(num::Zero::zero(), num::Saturating::saturating_add)
-    }
-}
-
-/// Domain separator used for signing.
-///
-/// https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator
-#[derive(Debug, Clone, Copy)]
-pub struct DomainSeparator(pub [u8; 32]);
-
-/// Originated from the blockchain transaction input data.
-pub type Calldata = alloy::primitives::Bytes;
-
-/// A settlement event emitted by a settlement smart contract.
-#[derive(Debug, Clone, Copy)]
-pub struct SettlementEvent {
-    pub block: BlockNo,
-    pub log_index: u64,
-    pub transaction: TxId,
-}
-
-/// A trade event emitted by a settlement smart contract.
-#[derive(Debug, Clone, Copy)]
-pub struct TradeEvent {
-    pub block: BlockNo,
-    pub log_index: u64,
-    pub order_uid: domain::OrderUid,
-}
-
-/// Call frames of a transaction.
-#[derive(Clone, Debug, Default)]
-pub struct CallFrame {
-    /// The address of the call initiator.
-    pub from: Address,
-    /// The address of the contract that was called.
-    pub to: Option<Address>,
-    /// Calldata input.
-    pub input: Calldata,
-    /// Recorded child calls.
-    pub calls: Vec<CallFrame>,
-}
-
-/// Any type of on-chain transaction.
-#[derive(Debug, Clone, Default)]
-pub struct Transaction {
-    /// The hash of the transaction.
-    pub hash: TxId,
-    /// The address of the sender of the transaction.
-    pub from: Address,
-    /// The block number of the block that contains the transaction.
-    pub block: BlockNo,
-    /// The timestamp of the block that contains the transaction.
-    pub timestamp: u32,
-    /// The gas used by the transaction.
-    pub gas: Gas,
-    /// The effective gas price of the transaction.
-    pub gas_price: EffectiveGasPrice,
-    /// Traces of all Calls contained in the transaction.
-    pub trace_calls: CallFrame,
-}
diff --git a/crates/autopilot/src/domain/fee/mod.rs b/crates/autopilot/src/domain/fee/mod.rs
index 8979f1d46b..1ea60e7968 100644
--- a/crates/autopilot/src/domain/fee/mod.rs
+++ b/crates/autopilot/src/domain/fee/mod.rs
@@ -9,7 +9,7 @@ mod policy;
 use {
     crate::{
         boundary::{self},
-        domain::{self, eth},
+        domain,
     },
     alloy::primitives::{Address, U256},
     chrono::{DateTime, Utc},
@@ -22,6 +22,7 @@ use {
         },
         fee_factor::FeeFactor,
     },
+    eth_domain_types as eth,
     rust_decimal::Decimal,
     shared::{arguments::TokenBucketFeeOverride, fee::VolumeFeePolicy},
     std::collections::HashSet,
diff --git a/crates/autopilot/src/domain/mod.rs b/crates/autopilot/src/domain/mod.rs
index deb7d0da9c..ed1eb17793 100644
--- a/crates/autopilot/src/domain/mod.rs
+++ b/crates/autopilot/src/domain/mod.rs
@@ -1,6 +1,6 @@
 pub mod auction;
+pub mod blockchain;
 pub mod competition;
-pub mod eth;
 pub mod fee;
 pub mod quote;
 pub mod settlement;
diff --git a/crates/autopilot/src/domain/quote/mod.rs b/crates/autopilot/src/domain/quote/mod.rs
index 9f8aa301e9..603e431f55 100644
--- a/crates/autopilot/src/domain/quote/mod.rs
+++ b/crates/autopilot/src/domain/quote/mod.rs
@@ -1,7 +1,8 @@
 use {
     super::OrderUid,
-    crate::{boundary::Amounts, domain::eth},
+    crate::boundary::Amounts,
     alloy::primitives::Address,
+    eth_domain_types as eth,
 };
 
 #[derive(Clone, Debug, PartialEq)]
diff --git a/crates/autopilot/src/domain/settlement/auction.rs b/crates/autopilot/src/domain/settlement/auction.rs
index a1ce9ad618..abfeb95da4 100644
--- a/crates/autopilot/src/domain/settlement/auction.rs
+++ b/crates/autopilot/src/domain/settlement/auction.rs
@@ -1,7 +1,8 @@
 //! Auction data related to the specific settlement.
 
 use {
-    crate::domain::{self},
+    crate::domain,
+    eth_domain_types as eth,
     std::collections::{HashMap, HashSet},
 };
 
@@ -13,7 +14,7 @@ use {
 pub struct Auction {
     pub id: domain::auction::Id,
     /// The block on top of which the auction was created.
-    pub block: domain::eth::BlockNo,
+    pub block: eth::BlockNo,
     /// All orders from a competition auction. Some of them may contain fee
     /// policies.
     pub orders: HashMap<domain::OrderUid, Vec<domain::fee::Policy>>,
@@ -21,5 +22,5 @@ pub struct Auction {
     pub prices: domain::auction::Prices,
     /// JIT orders with surplus capturing JIT order owners should capture
     /// surplus if settled.
-    pub surplus_capturing_jit_order_owners: HashSet<domain::eth::Address>,
+    pub surplus_capturing_jit_order_owners: HashSet<eth::Address>,
 }
diff --git a/crates/autopilot/src/domain/settlement/mod.rs b/crates/autopilot/src/domain/settlement/mod.rs
index 6272c51569..1cddcf3b0b 100644
--- a/crates/autopilot/src/domain/settlement/mod.rs
+++ b/crates/autopilot/src/domain/settlement/mod.rs
@@ -5,19 +5,13 @@
 
 use {
     crate::{
-        domain::{
-            self,
-            Metrics,
-            OrderUid,
-            auction::order,
-            eth,
-            settlement::transaction::EncodedTrade,
-        },
+        domain::{self, Metrics, OrderUid, auction::order, settlement::transaction::EncodedTrade},
         infra::{self, persistence::dto::AuctionId},
     },
     chain::Chain,
     chrono::{DateTime, Utc},
     database::{orders::OrderKind, solver_competition_v2::Solution},
+    eth_domain_types as eth,
     futures::TryFutureExt,
     number::conversions::big_decimal_to_u256,
     std::collections::{HashMap, HashSet},
@@ -30,7 +24,7 @@ pub mod transaction;
 pub use {
     auction::Auction,
     observer::Observer,
-    trade::{Trade, math},
+    trade::{Trade, TradeEvent, math},
     transaction::Transaction,
 };
 
@@ -207,6 +201,14 @@ impl Settlement {
     }
 }
 
+/// A settlement event emitted by a settlement smart contract.
+#[derive(Debug, Clone, Copy)]
+pub struct SettlementEvent {
+    pub block: eth::BlockNo,
+    pub log_index: u64,
+    pub transaction: eth::TxId,
+}
+
 #[derive(Debug, Hash, Eq, PartialEq)]
 struct OrderMatchKey {
     uid: OrderUid,
@@ -351,10 +353,11 @@ mod tests {
         crate::domain::{
             self,
             auction,
-            eth,
+            blockchain,
             settlement::{OrderMatchKey, trade_to_key},
         },
         alloy::{eips::BlockId, primitives::address},
+        eth_domain_types::{self as eth, Address},
         hex_literal::hex,
         number::u256_ext::U256Ext,
         std::collections::{HashMap, HashSet},
@@ -417,8 +420,8 @@ mod tests {
 
         ws::Order {
             uid: ws::OrderUid(trade.uid.0),
-            sell_token: trade.sell.token.0,
-            buy_token: trade.buy.token.0,
+            sell_token: *trade.sell.token,
+            buy_token: *trade.buy.token,
             sell_amount: trade.sell.amount.0,
             buy_amount: trade.buy.amount.0,
             executed_sell,
@@ -455,7 +458,7 @@ mod tests {
         auction
             .prices
             .iter()
-            .map(|(token, price)| (token.0, price.get().0))
+            .map(|(token, price)| (Address::from(*token), price.get().0))
             .collect()
     }
 
@@ -702,8 +705,8 @@ mod tests {
         let settlement_contract = address!("9008d19f58aabd9ed0d60971565aa8510560ab41");
 
         let transaction = super::transaction::Transaction::try_new(
-            &domain::eth::Transaction {
-                trace_calls: domain::eth::CallFrame {
+            &blockchain::Transaction {
+                trace_calls: blockchain::CallFrame {
                     to: Some(settlement_contract),
                     input: calldata.into(),
                     ..Default::default()
@@ -809,8 +812,8 @@ mod tests {
         ));
         let settlement_contract = address!("9008d19f58aabd9ed0d60971565aa8510560ab41");
         let transaction = super::transaction::Transaction::try_new(
-            &domain::eth::Transaction {
-                trace_calls: domain::eth::CallFrame {
+            &blockchain::Transaction {
+                trace_calls: blockchain::CallFrame {
                     to: Some(settlement_contract),
                     input: calldata.into(),
                     ..Default::default()
@@ -831,12 +834,12 @@ mod tests {
             // prices read from https://solver-instances.s3.eu-central-1.amazonaws.com/prod/mainnet/legacy/8655372.json
             prices: auction::Prices::from([
                 (
-                    eth::TokenAddress(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+                    eth::TokenAddress::from(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
                     auction::Price::try_new(eth::U256::from(1000000000000000000u128).into())
                         .unwrap(),
                 ),
                 (
-                    eth::TokenAddress(address!("c52fafdc900cb92ae01e6e4f8979af7f436e2eb2")),
+                    eth::TokenAddress::from(address!("c52fafdc900cb92ae01e6e4f8979af7f436e2eb2")),
                     auction::Price::try_new(eth::U256::from(537359915436704u128).into()).unwrap(),
                 ),
             ]),
@@ -949,8 +952,8 @@ mod tests {
         ));
         let settlement_contract = address!("9008d19f58aabd9ed0d60971565aa8510560ab41");
         let transaction = super::transaction::Transaction::try_new(
-            &domain::eth::Transaction {
-                trace_calls: domain::eth::CallFrame {
+            &blockchain::Transaction {
+                trace_calls: blockchain::CallFrame {
                     to: Some(settlement_contract),
                     input: calldata.into(),
                     ..Default::default()
@@ -966,12 +969,12 @@ mod tests {
 
         let prices: auction::Prices = From::from([
             (
-                eth::TokenAddress(address!("dac17f958d2ee523a2206206994597c13d831ec7")),
+                eth::TokenAddress::from(address!("dac17f958d2ee523a2206206994597c13d831ec7")),
                 auction::Price::try_new(eth::U256::from(321341140475275961528483840u128).into())
                     .unwrap(),
             ),
             (
-                eth::TokenAddress(address!("056fd409e1d7a124bd7017459dfea2f387b6d5cd")),
+                eth::TokenAddress::from(address!("056fd409e1d7a124bd7017459dfea2f387b6d5cd")),
                 auction::Price::try_new(
                     eth::U256::from(3177764302250520038326415654912u128).into(),
                 )
@@ -1122,8 +1125,8 @@ mod tests {
         let settlement_contract =
             eth::Address::from_slice(&hex!("9008d19f58aabd9ed0d60971565aa8510560ab41"));
         let transaction = super::transaction::Transaction::try_new(
-            &domain::eth::Transaction {
-                trace_calls: domain::eth::CallFrame {
+            &blockchain::Transaction {
+                trace_calls: blockchain::CallFrame {
                     to: Some(settlement_contract),
                     input: calldata.into(),
                     ..Default::default()
@@ -1139,12 +1142,12 @@ mod tests {
 
         let prices: auction::Prices = From::from([
             (
-                eth::TokenAddress(address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
+                eth::TokenAddress::from(address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
                 auction::Price::try_new(eth::U256::from(374263465721452989998170112u128).into())
                     .unwrap(),
             ),
             (
-                eth::TokenAddress(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+                eth::TokenAddress::from(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
                 auction::Price::try_new(eth::U256::from(1000000000000000000u128).into()).unwrap(),
             ),
         ]);
@@ -1300,8 +1303,8 @@ mod tests {
         ));
         let settlement_contract = address!("9008d19f58aabd9ed0d60971565aa8510560ab41");
         let transaction = super::transaction::Transaction::try_new(
-            &domain::eth::Transaction {
-                trace_calls: domain::eth::CallFrame {
+            &blockchain::Transaction {
+                trace_calls: blockchain::CallFrame {
                     to: Some(settlement_contract),
                     input: calldata.into(),
                     ..Default::default()
@@ -1317,15 +1320,15 @@ mod tests {
 
         let prices: auction::Prices = From::from([
             (
-                eth::TokenAddress(address!("812Ba41e071C7b7fA4EBcFB62dF5F45f6fA853Ee")),
+                eth::TokenAddress::from(address!("812Ba41e071C7b7fA4EBcFB62dF5F45f6fA853Ee")),
                 auction::Price::try_new(eth::U256::from(400373909534592401408u128).into()).unwrap(),
             ),
             (
-                eth::TokenAddress(address!("a21Af1050F7B26e0cfF45ee51548254C41ED6b5c")),
+                eth::TokenAddress::from(address!("a21Af1050F7B26e0cfF45ee51548254C41ED6b5c")),
                 auction::Price::try_new(eth::U256::from(127910593u128).into()).unwrap(),
             ),
             (
-                eth::TokenAddress(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
+                eth::TokenAddress::from(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
                 auction::Price::try_new(eth::U256::from(1000000000000000000u128).into()).unwrap(),
             ),
         ]);
@@ -1525,8 +1528,8 @@ mod tests {
         ));
         let settlement_contract = address!("9008d19f58aabd9ed0d60971565aa8510560ab41");
         let transaction = super::transaction::Transaction::try_new(
-            &domain::eth::Transaction {
-                trace_calls: domain::eth::CallFrame {
+            &blockchain::Transaction {
+                trace_calls: blockchain::CallFrame {
                     to: Some(settlement_contract),
                     input: calldata.into(),
                     ..Default::default()
diff --git a/crates/autopilot/src/domain/settlement/observer.rs b/crates/autopilot/src/domain/settlement/observer.rs
index a58a42ad2c..97c0ef1c3e 100644
--- a/crates/autopilot/src/domain/settlement/observer.rs
+++ b/crates/autopilot/src/domain/settlement/observer.rs
@@ -12,13 +12,11 @@
 
 use {
     crate::{
-        domain::{
-            eth,
-            settlement::{self, Settlement},
-        },
+        domain::settlement::{self, Settlement},
         infra,
     },
     anyhow::{Context, Result, anyhow},
+    eth_domain_types as eth,
     futures::StreamExt,
     rand::Rng,
     std::time::Duration,
@@ -84,7 +82,7 @@ impl Observer {
             .await;
     }
 
-    async fn post_process_settlement(&self, settlement: eth::SettlementEvent) -> Result<()> {
+    async fn post_process_settlement(&self, settlement: super::SettlementEvent) -> Result<()> {
         let settlement_data = self
             .fetch_auction_data_for_transaction(settlement.transaction)
             .await?;
diff --git a/crates/autopilot/src/domain/settlement/trade/math.rs b/crates/autopilot/src/domain/settlement/trade/math.rs
index b51ce09bb3..bf2311c495 100644
--- a/crates/autopilot/src/domain/settlement/trade/math.rs
+++ b/crates/autopilot/src/domain/settlement/trade/math.rs
@@ -5,11 +5,11 @@ use {
         self,
         OrderUid,
         auction::{self, order},
-        eth,
         fee,
         settlement::transaction::{ClearingPrices, Prices},
     },
     error::Math,
+    eth_domain_types as eth,
     num::{CheckedAdd, CheckedDiv, CheckedMul, CheckedSub},
     number::u256_ext::U256Ext,
     std::collections::HashMap,
@@ -530,7 +530,7 @@ impl From<&super::Trade> for Trade {
     }
 }
 pub mod error {
-    use crate::domain::eth;
+    use eth_domain_types as eth;
 
     #[derive(Debug, thiserror::Error)]
     pub enum Error {
diff --git a/crates/autopilot/src/domain/settlement/trade/mod.rs b/crates/autopilot/src/domain/settlement/trade/mod.rs
index 5cad3671a1..bc6ac7827f 100644
--- a/crates/autopilot/src/domain/settlement/trade/mod.rs
+++ b/crates/autopilot/src/domain/settlement/trade/mod.rs
@@ -3,10 +3,10 @@ use {
     crate::domain::{
         self,
         auction::{self, order},
-        eth,
         fee,
     },
     bigdecimal::Zero,
+    eth_domain_types as eth,
 };
 
 pub mod math;
@@ -132,6 +132,14 @@ impl Trade {
     }
 }
 
+/// A trade event emitted by a settlement smart contract.
+#[derive(Debug, Clone, Copy)]
+pub struct TradeEvent {
+    pub block: eth::BlockNo,
+    pub log_index: u64,
+    pub order_uid: model::order::OrderUid,
+}
+
 /// A trade filling an order that was part of the auction.
 #[derive(Debug, Clone)]
 pub struct Fulfillment {
diff --git a/crates/autopilot/src/domain/settlement/transaction/mod.rs b/crates/autopilot/src/domain/settlement/transaction/mod.rs
index 1065152de4..a24a1b02fd 100644
--- a/crates/autopilot/src/domain/settlement/transaction/mod.rs
+++ b/crates/autopilot/src/domain/settlement/transaction/mod.rs
@@ -1,10 +1,11 @@
 use {
     crate::{
         boundary,
-        domain::{self, auction::order, eth},
+        domain::{self, auction::order, blockchain},
     },
     alloy::{eips::BlockId, sol_types::SolCall},
     contracts::alloy::{GPv2AllowListAuthentication, GPv2Settlement},
+    eth_domain_types as eth,
     std::collections::HashSet,
 };
 
@@ -66,7 +67,7 @@ pub struct Transaction {
 
 impl Transaction {
     pub async fn try_new(
-        transaction: &eth::Transaction,
+        transaction: &blockchain::Transaction,
         domain_separator: &eth::DomainSeparator,
         settlement_contract: eth::Address,
         authenticator: &impl Authenticator,
@@ -177,9 +178,9 @@ impl Transaction {
 }
 
 fn find_settlement_trace_and_callers(
-    call_frame: &eth::CallFrame,
+    call_frame: &blockchain::CallFrame,
     settlement_contract: eth::Address,
-) -> Option<(&eth::CallFrame, Vec<eth::Address>)> {
+) -> Option<(&blockchain::CallFrame, Vec<eth::Address>)> {
     // Use a queue (VecDeque) to keep track of frames to process
     let mut queue = std::collections::VecDeque::new();
     queue.push_back((call_frame, vec![call_frame.from]));
@@ -199,7 +200,7 @@ fn find_settlement_trace_and_callers(
     None
 }
 
-fn is_settlement_trace(trace: &eth::CallFrame, settlement_contract: eth::Address) -> bool {
+fn is_settlement_trace(trace: &blockchain::CallFrame, settlement_contract: eth::Address) -> bool {
     let settle_selector = &GPv2Settlement::GPv2Settlement::settleCall::SELECTOR;
     trace.to.unwrap_or_default() == settlement_contract
         && trace.input.0.starts_with(settle_selector)
diff --git a/crates/autopilot/src/domain/settlement/transaction/tokenized.rs b/crates/autopilot/src/domain/settlement/transaction/tokenized.rs
index c66787b32c..8b3656a1f3 100644
--- a/crates/autopilot/src/domain/settlement/transaction/tokenized.rs
+++ b/crates/autopilot/src/domain/settlement/transaction/tokenized.rs
@@ -1,11 +1,12 @@
 use {
     crate::{
         boundary,
-        domain::{self, auction::order, eth},
+        domain::{self, auction::order},
     },
     alloy::primitives::U256,
     app_data::AppDataHash,
     contracts::alloy::GPv2Settlement,
+    eth_domain_types as eth,
 };
 
 /// Recover order uid from order data and signature
diff --git a/crates/autopilot/src/infra/blockchain/contracts.rs b/crates/autopilot/src/infra/blockchain/contracts.rs
index 3409a444d2..3b95903938 100644
--- a/crates/autopilot/src/infra/blockchain/contracts.rs
+++ b/crates/autopilot/src/infra/blockchain/contracts.rs
@@ -1,5 +1,4 @@
 use {
-    crate::domain,
     alloy::primitives::Address,
     chain::Chain,
     contracts::alloy::{
@@ -10,6 +9,7 @@ use {
         WETH9,
         support::Balances,
     },
+    eth_domain_types as eth,
     ethrpc::Web3,
 };
 
@@ -26,7 +26,7 @@ pub struct Contracts {
     /// submit settlements.
     authenticator: GPv2AllowListAuthentication::Instance,
     /// The domain separator for settlement contract used for signing orders.
-    settlement_domain_separator: domain::eth::DomainSeparator,
+    settlement_domain_separator: eth::DomainSeparator,
 }
 
 #[derive(Debug, Clone)]
@@ -84,7 +84,7 @@ impl Contracts {
             .await
             .ok();
 
-        let settlement_domain_separator = domain::eth::DomainSeparator(
+        let settlement_domain_separator = eth::DomainSeparator(
             settlement
                 .domainSeparator()
                 .call()
@@ -130,7 +130,7 @@ impl Contracts {
         &self.trampoline
     }
 
-    pub fn settlement_domain_separator(&self) -> &domain::eth::DomainSeparator {
+    pub fn settlement_domain_separator(&self) -> &eth::DomainSeparator {
         &self.settlement_domain_separator
     }
 
@@ -144,7 +144,7 @@ impl Contracts {
 
     /// Wrapped version of the native token (e.g. WETH for Ethereum, WXDAI for
     /// Gnosis Chain)
-    pub fn wrapped_native_token(&self) -> domain::eth::WrappedNativeToken {
+    pub fn wrapped_native_token(&self) -> eth::WrappedNativeToken {
         (*self.weth.address()).into()
     }
 
diff --git a/crates/autopilot/src/infra/blockchain/mod.rs b/crates/autopilot/src/infra/blockchain/mod.rs
index f5a0f5df08..1ffa89525d 100644
--- a/crates/autopilot/src/infra/blockchain/mod.rs
+++ b/crates/autopilot/src/infra/blockchain/mod.rs
@@ -1,6 +1,6 @@
 use {
     self::contracts::Contracts,
-    crate::{boundary, domain::eth},
+    crate::{boundary, domain},
     alloy::{
         providers::{Provider, ext::DebugApi},
         rpc::types::{
@@ -10,6 +10,7 @@ use {
     },
     anyhow::bail,
     chain::Chain,
+    eth_domain_types as eth,
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     thiserror::Error,
     url::Url,
@@ -108,7 +109,10 @@ impl Ethereum {
         &self.contracts
     }
 
-    pub async fn transaction(&self, hash: eth::TxId) -> Result<eth::Transaction, Error> {
+    pub async fn transaction(
+        &self,
+        hash: eth::TxId,
+    ) -> Result<domain::blockchain::Transaction, Error> {
         let (receipt, traces): (Option<TransactionReceipt>, GethTrace) = tokio::try_join!(
             self.web3.provider.get_transaction_receipt(hash.0),
             // Use unbuffered transport for the Debug API since not all providers support
@@ -142,13 +146,13 @@ fn into_domain(
     receipt: TransactionReceipt,
     trace: GethTrace,
     timestamp: u64,
-) -> anyhow::Result<eth::Transaction> {
+) -> anyhow::Result<domain::blockchain::Transaction> {
     let trace_calls = match trace {
         GethTrace::CallTracer(call_frame) => call_frame.into(),
         trace => bail!("unsupported trace call {trace:?}"),
     };
 
-    Ok(eth::Transaction {
+    Ok(domain::blockchain::Transaction {
         hash: receipt.transaction_hash.into(),
         from: receipt.from,
         block: receipt
@@ -162,17 +166,6 @@ fn into_domain(
     })
 }
 
-impl From<alloy::rpc::types::trace::geth::CallFrame> for eth::CallFrame {
-    fn from(value: alloy::rpc::types::trace::geth::CallFrame) -> Self {
-        Self {
-            from: value.from,
-            to: value.to,
-            input: value.input,
-            calls: value.calls.into_iter().map(Into::into).collect(),
-        }
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("alloy transport error: {0:?}")]
diff --git a/crates/autopilot/src/infra/persistence/dto/auction.rs b/crates/autopilot/src/infra/persistence/dto/auction.rs
index 87acc09d5d..8629ce6fd3 100644
--- a/crates/autopilot/src/infra/persistence/dto/auction.rs
+++ b/crates/autopilot/src/infra/persistence/dto/auction.rs
@@ -1,7 +1,8 @@
 use {
     super::order::Order,
-    crate::domain::{self, auction::Price, eth},
+    crate::domain::{self, auction::Price},
     alloy::primitives::{Address, U256},
+    eth_domain_types as eth,
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
@@ -19,7 +20,7 @@ pub fn from_domain(auction: domain::RawAuctionData) -> RawAuctionData {
         prices: auction
             .prices
             .into_iter()
-            .map(|(key, value)| (key.0, value.get().0))
+            .map(|(key, value)| (*key, value.get().0))
             .collect(),
         surplus_capturing_jit_order_owners: auction
             .surplus_capturing_jit_order_owners
@@ -66,7 +67,7 @@ impl Auction {
                 .prices
                 .into_iter()
                 .map(|(key, value)| {
-                    Price::try_new(value.into()).map(|price| (eth::TokenAddress(key), price))
+                    Price::try_new(value.into()).map(|price| (eth::TokenAddress::from(key), price))
                 })
                 .collect::<Result<_, _>>()?,
             surplus_capturing_jit_order_owners: self
diff --git a/crates/autopilot/src/infra/persistence/dto/order.rs b/crates/autopilot/src/infra/persistence/dto/order.rs
index 04013049f2..78fd5e00e5 100644
--- a/crates/autopilot/src/infra/persistence/dto/order.rs
+++ b/crates/autopilot/src/infra/persistence/dto/order.rs
@@ -1,11 +1,12 @@
 use {
     crate::{
         boundary::{self},
-        domain::{self, OrderUid, eth},
+        domain::{self, OrderUid},
     },
     alloy::primitives::{Address, U256},
     app_data::AppDataHash,
     configs::fee_factor::FeeFactor,
+    eth_domain_types as eth,
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
diff --git a/crates/autopilot/src/infra/persistence/mod.rs b/crates/autopilot/src/infra/persistence/mod.rs
index 7542ee5e13..07266a6182 100644
--- a/crates/autopilot/src/infra/persistence/mod.rs
+++ b/crates/autopilot/src/infra/persistence/mod.rs
@@ -2,7 +2,10 @@ use {
     crate::{
         boundary,
         database::{Postgres, order_events::store_order_events},
-        domain::{self, eth, settlement::transaction::EncodedTrade},
+        domain::{
+            self,
+            settlement::{SettlementEvent, TradeEvent, transaction::EncodedTrade},
+        },
         infra::persistence::dto::{AuctionId, RawAuctionData},
     },
     ::winner_selection::state::RankedItem,
@@ -28,6 +31,7 @@ use {
         SellTokenSource as DomainSellTokenSource,
         SigningScheme as DomainSigningScheme,
     },
+    eth_domain_types as eth,
     futures::{StreamExt, TryStreamExt},
     number::conversions::{big_decimal_to_u256, u256_to_big_decimal, u256_to_big_uint},
     shared::db_order_conversions::full_order_into_model_order,
@@ -235,8 +239,8 @@ impl Persistence {
                             .iter()
                             .map(|(order_uid, order)| Order {
                                 uid: ByteArray(order_uid.0),
-                                sell_token: ByteArray(order.sell.token.0.0.0),
-                                buy_token: ByteArray(order.buy.token.0.0.0),
+                                sell_token: ByteArray(order.sell.token.into_array()),
+                                buy_token: ByteArray(order.buy.token.into_array()),
                                 limit_sell: u256_to_big_decimal(&order.sell.amount.0),
                                 limit_buy: u256_to_big_decimal(&order.buy.amount.0),
                                 executed_sell: u256_to_big_decimal(&order.executed_sell.0),
@@ -248,7 +252,7 @@ impl Persistence {
                             .solution()
                             .prices()
                             .keys()
-                            .map(|token| ByteArray(token.0.0.0))
+                            .map(|token| ByteArray(token.into_array()))
                             .collect(),
                         price_values: bid
                             .solution()
@@ -270,7 +274,7 @@ impl Persistence {
     pub async fn save_surplus_capturing_jit_order_owners(
         &self,
         auction_id: AuctionId,
-        surplus_capturing_jit_order_owners: &[domain::eth::Address],
+        surplus_capturing_jit_order_owners: &[eth::Address],
     ) -> Result<(), DatabaseError> {
         self.postgres
             .save_surplus_capturing_jit_order_owners(
@@ -409,7 +413,7 @@ impl Persistence {
                 price_tokens: auction
                     .prices
                     .keys()
-                    .map(|token| ByteArray(token.0.0.0))
+                    .map(|token| ByteArray(token.into_array()))
                     .collect(),
                 price_values: auction
                     .prices
@@ -708,7 +712,7 @@ impl Persistence {
     /// not yet populated in the database.
     pub async fn get_settlements_without_auction(
         &self,
-    ) -> Result<Vec<domain::eth::SettlementEvent>, DatabaseError> {
+    ) -> Result<Vec<SettlementEvent>, DatabaseError> {
         let _timer = Metrics::get()
             .database_queries
             .with_label_values(&["get_settlement_without_auction"])
@@ -719,7 +723,7 @@ impl Persistence {
             .await?
             .into_iter()
             .map(|event| {
-                let event = domain::eth::SettlementEvent {
+                let event = SettlementEvent {
                     block: u64::try_from(event.block_number)
                         .context("negative block")?
                         .into(),
@@ -735,8 +739,8 @@ impl Persistence {
     /// Returns the trade events that are associated with the settlement event
     pub async fn get_trades_for_settlement(
         &self,
-        settlement: &domain::eth::SettlementEvent,
-    ) -> Result<Vec<domain::eth::TradeEvent>, DatabaseError> {
+        settlement: &SettlementEvent,
+    ) -> Result<Vec<TradeEvent>, DatabaseError> {
         let _timer = Metrics::get()
             .database_queries
             .with_label_values(&["get_trades_for_settlement"])
@@ -753,12 +757,12 @@ impl Persistence {
         .await?
         .into_iter()
         .map(|event| {
-            let event = domain::eth::TradeEvent {
+            let event = TradeEvent {
                 block: u64::try_from(event.block_number)
                     .context("negative block")?
                     .into(),
                 log_index: u64::try_from(event.log_index).context("negative log index")?,
-                order_uid: domain::OrderUid(event.order_uid.0),
+                order_uid: domain::OrderUid(event.order_uid.0).into(),
             };
             Ok::<_, DatabaseError>(event)
         })
@@ -767,7 +771,7 @@ impl Persistence {
 
     pub async fn save_settlement(
         &self,
-        event: domain::eth::SettlementEvent,
+        event: SettlementEvent,
         settlement: Option<&domain::settlement::Settlement>,
     ) -> Result<(), DatabaseError> {
         let _timer = Metrics::get()
@@ -837,14 +841,14 @@ impl Persistence {
                     auction_id,
                     block_number,
                     Asset {
-                        token: ByteArray(order_fee.total.token.0.0.0),
+                        token: ByteArray(order_fee.total.token.into_array()),
                         amount: u256_to_big_decimal(&order_fee.total.amount.0),
                     },
                     &order_fee
                         .protocol
                         .into_iter()
                         .map(|executed| Asset {
-                            token: ByteArray(executed.fee.token.0.0.0),
+                            token: ByteArray(executed.fee.token.into_array()),
                             amount: u256_to_big_decimal(&executed.fee.amount.0),
                         })
                         .collect::<Vec<_>>(),
@@ -865,7 +869,7 @@ impl Persistence {
                     &mut ex,
                     &jit_orders
                         .into_iter()
-                        .filter_map(|jit_order| match trade_events.get(&jit_order.uid) {
+                        .filter_map(|jit_order| match trade_events.get(&jit_order.uid.into()) {
                             Some((block_number, log_index)) => {
                                 Some(database::jit_orders::JitOrder {
                                     block_number: i64::try_from(block_number.0).ok()?,
@@ -877,8 +881,8 @@ impl Persistence {
                                         0,
                                     )
                                         .unwrap_or_default(),
-                                    sell_token: ByteArray(jit_order.sell.token.0.0.0),
-                                    buy_token: ByteArray(jit_order.buy.token.0.0.0),
+                                    sell_token: ByteArray(jit_order.sell.token.into_array()),
+                                    buy_token: ByteArray(jit_order.buy.token.into_array()),
                                     sell_amount: u256_to_big_decimal(&jit_order.sell.amount.0),
                                     buy_amount: u256_to_big_decimal(&jit_order.buy.amount.0),
                                     valid_to: i64::from(jit_order.valid_to),
diff --git a/crates/autopilot/src/infra/solvers/dto/solve.rs b/crates/autopilot/src/infra/solvers/dto/solve.rs
index 3e86a69c4b..8cff19b66c 100644
--- a/crates/autopilot/src/infra/solvers/dto/solve.rs
+++ b/crates/autopilot/src/infra/solvers/dto/solve.rs
@@ -1,7 +1,7 @@
 use {
     crate::{
         boundary,
-        domain::{self, eth},
+        domain,
         infra::{
             persistence::dto::{self, order::Order},
             solvers::{InjectIntoHttpRequest, byte_stream::ByteStream},
@@ -11,6 +11,7 @@ use {
     brotli::enc::writer::CompressorWriter,
     bytes::Bytes,
     chrono::{DateTime, Utc},
+    eth_domain_types as eth,
     itertools::Itertools,
     number::serialization::HexOrDecimalU256,
     reqwest::{RequestBuilder, header::HeaderValue},
@@ -56,9 +57,9 @@ impl Request {
                 .prices
                 .iter()
                 .map(|(address, price)| Token {
-                    address: address.to_owned().0,
+                    address: *address.to_owned(),
                     price: Some(price.get().0),
-                    trusted: trusted_tokens.contains(&(address.0)),
+                    trusted: trusted_tokens.contains(&Address::from(*address)),
                 })
                 .chain(trusted_tokens.iter().map(|&address| Token {
                     address,
diff --git a/crates/autopilot/src/infra/solvers/mod.rs b/crates/autopilot/src/infra/solvers/mod.rs
index bd4f3c609a..6efb9bfd4f 100644
--- a/crates/autopilot/src/infra/solvers/mod.rs
+++ b/crates/autopilot/src/infra/solvers/mod.rs
@@ -1,9 +1,10 @@
 use {
     self::dto::{reveal, settle, solve},
-    crate::{domain::eth, util},
+    crate::util,
     alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
     configs::autopilot::solver::Account,
+    eth_domain_types as eth,
     observe::tracing::{distributed::headers::tracing_headers, lazy::Lazy},
     reqwest::{Client, RequestBuilder, StatusCode},
     std::{borrow::Cow, time::Duration},
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index 4ad635a9f8..e983feb808 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -11,7 +11,6 @@ use {
                 Unscored,
                 winner_selection::{self, Ranking},
             },
-            eth::{self, TxId},
             settlement::{ExecutionEnded, ExecutionStarted},
         },
         infra::{
@@ -29,6 +28,7 @@ use {
     alloy::primitives::B256,
     anyhow::{Context, Result},
     database::order_events::OrderEventLabel,
+    eth_domain_types::{self as eth, Address, TxId},
     ethrpc::block_stream::BlockInfo,
     futures::{FutureExt, TryFutureExt},
     itertools::Itertools,
@@ -496,7 +496,7 @@ impl RunLoop {
                     .solution()
                     .prices()
                     .iter()
-                    .map(|(token, price)| (token.0, price.get().0))
+                    .map(|(token, price)| (Address::from(*token), price.get().0))
                     .collect(),
                 is_winner: bid.is_winner(),
                 filtered_out: bid.is_filtered_out(),
@@ -518,7 +518,7 @@ impl RunLoop {
                 prices: auction
                     .prices
                     .iter()
-                    .map(|(key, value)| (key.0, value.get().0))
+                    .map(|(key, value)| (Address::from(*key), value.get().0))
                     .collect(),
             },
             solutions,
@@ -531,7 +531,7 @@ impl RunLoop {
                 .prices
                 .clone()
                 .into_iter()
-                .map(|(key, value)| (key.0, value.get().0))
+                .map(|(key, value)| (*key, value.get().0))
                 .collect(),
             block_deadline,
             competition_simulation_block,
diff --git a/crates/autopilot/src/shadow.rs b/crates/autopilot/src/shadow.rs
index 991bacf6e5..7ec6833fcb 100644
--- a/crates/autopilot/src/shadow.rs
+++ b/crates/autopilot/src/shadow.rs
@@ -12,7 +12,6 @@ use {
         domain::{
             self,
             competition::{Bid, Score, Unscored, winner_selection},
-            eth::WrappedNativeToken,
         },
         infra::{
             self,
@@ -24,6 +23,7 @@ use {
     ::observe::metrics,
     ::winner_selection::state::RankedItem,
     anyhow::Context,
+    eth_domain_types::WrappedNativeToken,
     ethrpc::block_stream::CurrentBlockWatcher,
     itertools::Itertools,
     num::{CheckedSub, Saturating},
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index 960de22216..ee1c0cd603 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -1,7 +1,7 @@
 use {
     crate::{
         boundary::{self, SolvableOrders},
-        domain::{self, auction::Price, eth},
+        domain::{self, auction::Price},
         infra::{self, banned},
     },
     account_balances::{BalanceFetching, Query},
@@ -365,9 +365,7 @@ impl SolvableOrdersCache {
             }),
             prices: prices
                 .into_iter()
-                .map(|(key, value)| {
-                    Price::try_new(value.into()).map(|price| (eth::TokenAddress(key), price))
-                })
+                .map(|(key, value)| Price::try_new(value.into()).map(|price| (key.into(), price)))
                 .collect::<Result<_, _>>()?,
             surplus_capturing_jit_order_owners,
         };
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 0e04b70590..d9b706267c 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -6,7 +6,6 @@ use {
         order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
-    driver::domain::eth::NonZeroU256,
     e2e::setup::{colocation, wait_for_condition, *},
     ethrpc::alloy::{CallBuilderExt, EvmProviderExt},
     model::{
@@ -14,7 +13,7 @@ use {
         quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
         signature::EcdsaSigningScheme,
     },
-    number::units::EthUnit,
+    number::{nonzero::NonZeroU256, units::EthUnit},
     shared::web3::Web3,
     std::ops::DerefMut,
 };
diff --git a/crates/eth-domain-types/Cargo.toml b/crates/eth-domain-types/Cargo.toml
new file mode 100644
index 0000000000..9b5e27952d
--- /dev/null
+++ b/crates/eth-domain-types/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "eth-domain-types"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy-eips = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-rpc-types = { workspace = true }
+derive_more = { workspace = true }
+num = { workspace = true }
+number = { workspace = true }
diff --git a/crates/eth-domain-types/src/access_list.rs b/crates/eth-domain-types/src/access_list.rs
new file mode 100644
index 0000000000..40925fe6be
--- /dev/null
+++ b/crates/eth-domain-types/src/access_list.rs
@@ -0,0 +1,94 @@
+use {
+    alloy_primitives::{Address, B256},
+    derive_more::{From, Into},
+    std::collections::{HashMap, HashSet},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Into, From)]
+pub struct StorageKey(pub B256);
+
+/// An EIP-2930 access list. This type ensures that the addresses and storage
+/// keys are not repeated, and that the ordering is deterministic.
+///
+/// https://eips.ethereum.org/EIPS/eip-2930
+#[derive(Debug, Clone, Default)]
+pub struct AccessList(HashMap<Address, HashSet<StorageKey>>);
+
+impl AccessList {
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl AccessList {
+    /// Merge two access lists together.
+    pub fn merge(mut self, other: Self) -> Self {
+        for (address, storage_keys) in other.0.into_iter() {
+            self.0.entry(address).or_default().extend(storage_keys);
+        }
+        self
+    }
+}
+
+impl IntoIterator for AccessList {
+    type IntoIter = std::collections::hash_map::IntoIter<Address, HashSet<StorageKey>>;
+    type Item = (Address, HashSet<StorageKey>);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl<I> FromIterator<(Address, I)> for AccessList
+where
+    I: IntoIterator<Item = B256>,
+{
+    fn from_iter<T: IntoIterator<Item = (Address, I)>>(iter: T) -> Self {
+        Self(
+            iter.into_iter()
+                .map(|(address, i)| {
+                    (
+                        address,
+                        i.into_iter().map(StorageKey).collect::<HashSet<_>>(),
+                    )
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<alloy_eips::eip2930::AccessList> for AccessList {
+    fn from(value: alloy_eips::eip2930::AccessList) -> Self {
+        Self(
+            value
+                .0
+                .into_iter()
+                .map(|item| {
+                    (
+                        item.address,
+                        item.storage_keys
+                            .into_iter()
+                            .map(StorageKey)
+                            .collect::<HashSet<_>>(),
+                    )
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<AccessList> for alloy_eips::eip2930::AccessList {
+    fn from(value: AccessList) -> Self {
+        Self(
+            value
+                .into_iter()
+                .map(
+                    |(address, storage_keys)| alloy_eips::eip2930::AccessListItem {
+                        address,
+                        storage_keys: storage_keys.into_iter().map(|k| k.0).collect(),
+                    },
+                )
+                .collect(),
+        )
+    }
+}
diff --git a/crates/eth-domain-types/src/allowance.rs b/crates/eth-domain-types/src/allowance.rs
new file mode 100644
index 0000000000..91222566df
--- /dev/null
+++ b/crates/eth-domain-types/src/allowance.rs
@@ -0,0 +1,63 @@
+use {
+    super::{Address, TokenAddress},
+    alloy_primitives::U256,
+    derive_more::{From, Into},
+};
+
+/// An ERC20 allowance.
+///
+/// https://eips.ethereum.org/EIPS/eip-20
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Allowance {
+    /// The token for the allowance.
+    pub token: TokenAddress,
+    /// The spender address.
+    pub spender: Address,
+    /// The amount for the allowance.
+    pub amount: U256,
+}
+
+/// An allowance that's already in effect, this essentially models the result of
+/// the allowance() method, see https://eips.ethereum.org/EIPS/eip-20#methods.
+#[derive(Debug, Clone, Copy, Into, From)]
+pub struct Existing(pub Allowance);
+
+/// An allowance that is required for some action.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Into, From)]
+pub struct Required(pub Allowance);
+
+impl Required {
+    /// Check if this allowance needs to be approved, and if so, return the
+    /// appropriate [`Approval`].
+    pub fn approval(&self, existing: &Existing) -> Option<Approval> {
+        if self.0.spender != existing.0.spender || self.0.amount <= existing.0.amount {
+            None
+        } else {
+            Some(Approval(self.0))
+        }
+    }
+}
+
+/// An approval which needs to be made with an approve() call, see
+/// https://eips.ethereum.org/EIPS/eip-20#methods.
+#[derive(Debug, Clone, Copy)]
+pub struct Approval(pub Allowance);
+
+impl Approval {
+    /// Approve the maximal amount possible, i.e. set the approved amount to
+    /// [`U256::max_value`].
+    pub fn max(self) -> Self {
+        Self(Allowance {
+            amount: U256::MAX,
+            ..self.0
+        })
+    }
+
+    /// Revoke the approval, i.e. set the approved amount to [`U256::zero`].
+    pub fn revoke(self) -> Self {
+        Self(Allowance {
+            amount: U256::ZERO,
+            ..self.0
+        })
+    }
+}
diff --git a/crates/eth-domain-types/src/eip712.rs b/crates/eth-domain-types/src/eip712.rs
new file mode 100644
index 0000000000..6bbc086c13
--- /dev/null
+++ b/crates/eth-domain-types/src/eip712.rs
@@ -0,0 +1,9 @@
+//! Types and procedures defined by EIP-712.
+//!
+//! https://eips.ethereum.org/EIPS/eip-712
+
+/// domainSeparator as defined by EIP-712.
+///
+/// https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator
+#[derive(Debug, Clone, Copy)]
+pub struct DomainSeparator(pub [u8; 32]);
diff --git a/crates/eth-domain-types/src/ether.rs b/crates/eth-domain-types/src/ether.rs
new file mode 100644
index 0000000000..b836fe0ed5
--- /dev/null
+++ b/crates/eth-domain-types/src/ether.rs
@@ -0,0 +1,60 @@
+use {
+    alloy_primitives::U256,
+    derive_more::derive::{Display, From, Into},
+};
+
+/// An amount of native Ether tokens denominated in wei.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    From,
+    Into,
+    Display,
+    Default,
+    derive_more::Add,
+    derive_more::Sub,
+)]
+pub struct Ether(pub U256);
+
+impl From<Ether> for num::BigInt {
+    fn from(value: Ether) -> Self {
+        num::BigUint::from_bytes_be(value.0.to_be_bytes::<32>().as_slice()).into()
+    }
+}
+
+impl num::Saturating for Ether {
+    fn saturating_add(self, v: Self) -> Self {
+        Self(self.0.saturating_add(v.0))
+    }
+
+    fn saturating_sub(self, v: Self) -> Self {
+        Self(self.0.saturating_sub(v.0))
+    }
+}
+
+impl num::CheckedSub for Ether {
+    fn checked_sub(&self, v: &Self) -> Option<Self> {
+        self.0.checked_sub(v.0).map(Ether)
+    }
+}
+
+impl num::Zero for Ether {
+    fn zero() -> Self {
+        Self(U256::ZERO)
+    }
+
+    fn is_zero(&self) -> bool {
+        self.0.is_zero()
+    }
+}
+
+impl std::iter::Sum for Ether {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(num::Zero::zero(), std::ops::Add::add)
+    }
+}
diff --git a/crates/eth-domain-types/src/gas.rs b/crates/eth-domain-types/src/gas.rs
new file mode 100644
index 0000000000..0b565c2a04
--- /dev/null
+++ b/crates/eth-domain-types/src/gas.rs
@@ -0,0 +1,150 @@
+use {
+    crate::Ether,
+    alloy_eips::eip1559::calc_effective_gas_price,
+    alloy_primitives::U256,
+    derive_more::{Display, From, Into},
+};
+
+/// Gas amount in gas units.
+///
+/// The amount of Ether that is paid in transaction fees is proportional to this
+/// amount as well as the transaction's [`EffectiveGasPrice`].
+#[derive(Debug, Default, Display, Clone, Copy, Ord, Eq, PartialOrd, PartialEq, From, Into)]
+pub struct Gas(pub U256);
+
+impl From<u64> for Gas {
+    fn from(value: u64) -> Self {
+        Self(U256::from(value))
+    }
+}
+
+impl std::ops::Add for Gas {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+/// An EIP-1559 gas price estimate.
+///
+/// https://eips.ethereum.org/EIPS/eip-1559#specification
+#[derive(Debug, Clone, Copy)]
+pub struct GasPrice {
+    /// The maximum total fee that should be charged.
+    max: FeePerGas,
+    /// The maximum priority fee (i.e. the tip to the block proposer) that
+    /// can be charged.
+    tip: FeePerGas,
+    /// The current base gas price that will be charged to all accounts on the
+    /// next block.
+    base: u64,
+}
+
+impl GasPrice {
+    /// Returns the estimated [`EffectiveGasPrice`] for the gas price estimate.
+    pub fn effective(&self) -> EffectiveGasPrice {
+        U256::from(calc_effective_gas_price(
+            u128::try_from(self.max.0.0).expect("max fee per gas should fit in a u128"),
+            u128::try_from(self.tip.0.0).expect("max priority fee per gas should fit in a u128"),
+            Some(self.base),
+        ))
+        .into()
+    }
+
+    pub fn max(&self) -> FeePerGas {
+        self.max
+    }
+
+    pub fn tip(&self) -> FeePerGas {
+        self.tip
+    }
+
+    pub fn base(&self) -> u64 {
+        self.base
+    }
+
+    pub fn new(max: FeePerGas, tip: FeePerGas, base: u64) -> Self {
+        Self { max, tip, base }
+    }
+}
+
+/// Implements multiplication of a gas price by a floating point number.
+/// This is equivalent to multiplying the `tip` and `max`
+impl std::ops::Mul<f64> for GasPrice {
+    type Output = Self;
+
+    fn mul(self, rhs: f64) -> Self::Output {
+        Self {
+            max: self.max.mul_ceil(rhs),
+            tip: self.tip.mul_ceil(rhs),
+            base: self.base,
+        }
+    }
+}
+
+/// The amount of ETH to pay as fees for a single unit of gas. This is
+/// `{max,max_priority,base}_fee_per_gas` as defined by EIP-1559.
+///
+/// https://eips.ethereum.org/EIPS/eip-1559#specification
+#[derive(Debug, Clone, Copy, Ord, Eq, PartialEq, PartialOrd)]
+pub struct FeePerGas(pub Ether);
+
+impl FeePerGas {
+    /// Multiplies this fee by the given floating point number, rounding up.
+    fn mul_ceil(self, rhs: f64) -> Self {
+        U256::from((f64::from(self.0.0) * rhs).ceil()).into()
+    }
+}
+
+impl From<U256> for FeePerGas {
+    fn from(value: U256) -> Self {
+        Self(value.into())
+    }
+}
+
+impl std::ops::Add<FeePerGas> for FeePerGas {
+    type Output = FeePerGas;
+
+    fn add(self, rhs: FeePerGas) -> Self::Output {
+        FeePerGas(self.0 + rhs.0)
+    }
+}
+
+impl From<FeePerGas> for U256 {
+    fn from(value: FeePerGas) -> Self {
+        value.0.into()
+    }
+}
+
+impl std::ops::Mul<FeePerGas> for Gas {
+    type Output = Ether;
+
+    fn mul(self, rhs: FeePerGas) -> Self::Output {
+        (self.0 * rhs.0.0).into()
+    }
+}
+
+/// The `effective_gas_price` as defined by EIP-1559.
+///
+/// https://eips.ethereum.org/EIPS/eip-1559#specification
+#[derive(Debug, Clone, Copy, Display, Default)]
+pub struct EffectiveGasPrice(pub Ether);
+
+impl From<u128> for EffectiveGasPrice {
+    fn from(value: u128) -> Self {
+        Self(U256::from(value).into())
+    }
+}
+
+impl From<U256> for EffectiveGasPrice {
+    fn from(value: U256) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<EffectiveGasPrice> for U256 {
+    fn from(value: EffectiveGasPrice) -> Self {
+        value.0.into()
+    }
+}
diff --git a/crates/eth-domain-types/src/lib.rs b/crates/eth-domain-types/src/lib.rs
new file mode 100644
index 0000000000..4343e1f4aa
--- /dev/null
+++ b/crates/eth-domain-types/src/lib.rs
@@ -0,0 +1,138 @@
+pub use {
+    access_list::{AccessList, StorageKey},
+    allowance::Allowance,
+    alloy_primitives::{Address, B256, U256, U512},
+    eip712::DomainSeparator,
+    ether::Ether,
+    gas::{EffectiveGasPrice, FeePerGas, Gas, GasPrice},
+    number::nonzero::NonZeroU256,
+    token_amount::{SellTokenAmount, SurplusTokenAmount, TokenAmount},
+};
+use {
+    alloy_primitives::Bytes,
+    alloy_rpc_types::TransactionRequest,
+    derive_more::{From, Into, derive::Deref},
+};
+
+mod access_list;
+pub mod allowance;
+mod eip712;
+mod ether;
+mod gas;
+mod token_amount;
+
+/// ERC20 token address for ETH. In reality, ETH is not an ERC20 token because
+/// it does not implement the ERC20 interface, but this address is used by
+/// convention across the Ethereum ecosystem whenever ETH is treated like an
+/// ERC20 token.
+pub const ETH_TOKEN: TokenAddress = TokenAddress(Address::repeat_byte(0xee));
+
+// TODO This type should probably use Ethereum::is_contract to verify during
+// construction that it does indeed point to a contract
+/// A smart contract address.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Deref)]
+pub struct ContractAddress(Address);
+
+/// An ERC20 token address.
+///
+/// https://eips.ethereum.org/EIPS/eip-20
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Deref)]
+pub struct TokenAddress(Address);
+
+impl TokenAddress {
+    /// If the token is ETH, return WETH, thereby converting it to erc20.
+    pub fn as_erc20(self, weth: WrappedNativeToken) -> Self {
+        if self == ETH_TOKEN { *weth } else { self }
+    }
+}
+
+/// ERC20 representation of the chain's native token (e.g. WETH on mainnet,
+/// WXDAI on Gnosis Chain).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Deref)]
+pub struct WrappedNativeToken(TokenAddress);
+
+impl From<Address> for WrappedNativeToken {
+    fn from(value: Address) -> Self {
+        WrappedNativeToken(value.into())
+    }
+}
+
+impl From<Address> for TokenAddress {
+    fn from(value: Address) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Address> for ContractAddress {
+    fn from(value: Address) -> Self {
+        Self(value)
+    }
+}
+
+impl From<TokenAddress> for Address {
+    fn from(value: TokenAddress) -> Self {
+        value.0
+    }
+}
+
+impl From<ContractAddress> for Address {
+    fn from(value: ContractAddress) -> Self {
+        value.0
+    }
+}
+
+/// An asset on the Ethereum blockchain. Represents a particular amount of a
+/// particular token.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Asset {
+    pub amount: TokenAmount,
+    pub token: TokenAddress,
+}
+
+/// Block number.
+#[derive(Debug, Copy, Clone, From, PartialEq, PartialOrd, Default)]
+pub struct BlockNo(pub u64);
+
+/// Adding blocks to a block number.
+impl std::ops::Add<u64> for BlockNo {
+    type Output = BlockNo;
+
+    fn add(self, rhs: u64) -> Self::Output {
+        Self(self.0 + rhs)
+    }
+}
+
+/// A transaction ID, AKA transaction hash.
+#[derive(Debug, Copy, Clone, From, Default)]
+pub struct TxId(pub B256);
+
+/// An onchain transaction.
+#[derive(derive_more::Debug, Clone)]
+pub struct Tx {
+    pub from: Address,
+    pub to: Address,
+    pub value: Ether,
+    pub input: Bytes,
+    #[debug(ignore)]
+    pub access_list: AccessList,
+}
+
+impl Tx {
+    pub fn set_access_list(self, access_list: AccessList) -> Self {
+        Self {
+            access_list,
+            ..self
+        }
+    }
+}
+
+impl From<Tx> for TransactionRequest {
+    fn from(value: Tx) -> Self {
+        TransactionRequest::default()
+            .from(value.from)
+            .to(value.to)
+            .value(value.value.0)
+            .input(value.input.into())
+            .access_list(value.access_list.into())
+    }
+}
diff --git a/crates/eth-domain-types/src/token_amount.rs b/crates/eth-domain-types/src/token_amount.rs
new file mode 100644
index 0000000000..b11a0edf49
--- /dev/null
+++ b/crates/eth-domain-types/src/token_amount.rs
@@ -0,0 +1,125 @@
+use {
+    alloy_primitives::U256,
+    derive_more::{From, Into},
+    number::u256_ext::U256Ext,
+};
+
+/// An ERC20 token amount.
+///
+/// https://eips.ethereum.org/EIPS/eip-20
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
+pub struct TokenAmount(pub U256);
+
+impl TokenAmount {
+    /// Applies a factor to the token amount.
+    pub fn apply_factor(&self, factor: f64) -> Option<Self> {
+        Some(self.0.checked_mul_f64(factor)?.into())
+    }
+}
+
+/// A value denominated in an order's surplus token (buy token for
+/// sell orders and sell token for buy orders).
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
+pub struct SurplusTokenAmount(pub U256);
+
+/// An ERC20 sell token amount.
+///
+/// https://eips.ethereum.org/EIPS/eip-20
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
+pub struct SellTokenAmount(pub U256);
+
+impl From<TokenAmount> for SellTokenAmount {
+    fn from(value: TokenAmount) -> Self {
+        Self(value.0)
+    }
+}
+
+impl From<SellTokenAmount> for TokenAmount {
+    fn from(value: SellTokenAmount) -> Self {
+        Self(value.0)
+    }
+}
+
+impl std::ops::Sub<Self> for TokenAmount {
+    type Output = TokenAmount;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        self.0.sub(rhs.0).into()
+    }
+}
+
+impl num::CheckedSub for TokenAmount {
+    fn checked_sub(&self, other: &Self) -> Option<Self> {
+        self.0.checked_sub(other.0).map(Into::into)
+    }
+}
+
+impl std::ops::Mul<Self> for TokenAmount {
+    type Output = TokenAmount;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        self.0.mul(rhs.0).into()
+    }
+}
+
+impl num::CheckedMul for TokenAmount {
+    fn checked_mul(&self, other: &Self) -> Option<Self> {
+        self.0.checked_mul(other.0).map(Into::into)
+    }
+}
+
+impl num::CheckedAdd for TokenAmount {
+    fn checked_add(&self, other: &Self) -> Option<Self> {
+        self.0.checked_add(other.0).map(Into::into)
+    }
+}
+
+impl std::ops::Div<Self> for TokenAmount {
+    type Output = TokenAmount;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        self.0.div(rhs.0).into()
+    }
+}
+
+impl num::CheckedDiv for TokenAmount {
+    fn checked_div(&self, other: &Self) -> Option<Self> {
+        self.0.checked_div(other.0).map(Into::into)
+    }
+}
+
+impl From<u128> for TokenAmount {
+    fn from(value: u128) -> Self {
+        Self(U256::from(value))
+    }
+}
+
+impl std::ops::Add for TokenAmount {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl std::ops::AddAssign for TokenAmount {
+    fn add_assign(&mut self, rhs: Self) {
+        self.0 += rhs.0;
+    }
+}
+
+impl num::Zero for TokenAmount {
+    fn zero() -> Self {
+        Self(U256::ZERO)
+    }
+
+    fn is_zero(&self) -> bool {
+        self.0.is_zero()
+    }
+}
+
+impl std::fmt::Display for TokenAmount {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}

From d9464bd13aad6026e51ad17ffc36931f6e186888 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 16 Mar 2026 14:05:38 +0000
Subject: [PATCH 152/219] Extract price estimation config to configs crate
 (#4255)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Extract `price_estimation::Arguments` (CLI/clap) into the `configs`
crate as TOML-deserialized structs. This continues the migration of
runtime configuration from clap CLI args to structured TOML config
files.

# Changes

* Remove `price_estimation::Arguments` struct and all its nested CLI
argument structs (`CoinGecko`, `CoinGeckoBuffered`,
`QuoteVerificationMode`, `tenderly_api::Arguments`,
`balance_overrides::Arguments`)
* Create `configs::price_estimation::PriceEstimation` with TOML
deserialization for: Tenderly, rate limiter, 1Inch, CoinGecko (including
optional buffered config), quote settings, balance overrides, and token
verification bypass list
* Extract `configs::native_price::NativePriceConfig` and
`configs::native_price_estimators::NativePriceEstimators` into their own
modules (previously lived in `configs::price_estimation`)
* Add `configs::deserialize_env` module with
`deserialize_optional_string_from_env()` to support `%ENV_VAR_NAME`
references in TOML files for secrets
* Add `serde::Deserialize` / `serde::Serialize` derives to
`rate_limit::Strategy` (replacing `FromStr` comma-separated parsing with
structured TOML table)
* Add `serde::Deserialize` / `serde::Serialize` impls to
`balance_overrides::TokenConfiguration` for TOML round-tripping
* Add `PriceEstimation` field to both autopilot and orderbook
`Configuration` structs
* Update all affected e2e tests to pass price estimation config via TOML
structs instead of removed CLI args

## How to test

Existing tests — unit tests cover deserialization defaults, full
deserialization, roundtrip serialization, and secret redaction in debug
output.

# Migration Guide

The following CLI arguments have moved to TOML config files. This
applies to **both autopilot and orderbook** services.

## Price Estimation (`[price-estimation]`)

### Tenderly (`[price-estimation.tenderly]`)

| CLI arg / env var | TOML key |
|---|---|
| `--tenderly-user` / `TENDERLY_USER` | `[price-estimation.tenderly]` →
`user` |
| `--tenderly-project` / `TENDERLY_PROJECT` |
`[price-estimation.tenderly]` → `project` |
| `--tenderly-api-key` / `TENDERLY_API_KEY` |
`[price-estimation.tenderly]` → `api-key` |

```toml
[price-estimation.tenderly]
user = "my-user"
project = "my-project"
api-key = "my-tenderly-key"
```

### Rate Limiter (`[price-estimation.price-estimation-rate-limiter]`)

| CLI arg / env var | TOML key |
|---|---|
| `--price-estimation-rate-limiter` / `PRICE_ESTIMATION_RATE_LIMITER` |
`[price-estimation.price-estimation-rate-limiter]` (see below) |

The old comma-separated format (`"2.0,1s,30s"`) is replaced by a TOML
table:

```toml
[price-estimation.price-estimation-rate-limiter]
back-off-growth-factor = 2.0
min-back-off = "1s"
max-back-off = "30s"
```

### Quote Settings

| CLI arg / env var | TOML key (`[price-estimation]`) | Default |
|---|---|---|
| `--amount-to-estimate-prices-with` / `AMOUNT_TO_ESTIMATE_PRICES_WITH`
| `amount-to-estimate-prices-with` | *(network-dependent)* |
| `--quote-inaccuracy-limit` / `QUOTE_INACCURACY_LIMIT` |
`quote-inaccuracy-limit` | `1` |
| `--quote-verification` / `QUOTE_VERIFICATION` | `quote-verification` |
`"unverified"` |
| `--quote-timeout` / `QUOTE_TIMEOUT` | `quote-timeout` | `"5s"` |
| `--tokens-without-verification` / `TOKENS_WITHOUT_VERIFICATION` |
`tokens-without-verification` | `[]` |
| `--max-gas-per-tx` / `MAX_GAS_PER_TX` | `max-gas-per-tx` | `16777215`
|

The `--tokens-without-verification` comma-separated format is replaced
by a TOML array:

```toml
[price-estimation]
quote-inaccuracy-limit = "0.01"
quote-verification = "enforce-when-possible"
quote-timeout = "10s"
amount-to-estimate-prices-with = "1000000000000000000"
max-gas-per-tx = 16777215
tokens-without-verification = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
```

### 1Inch API (`[price-estimation.one-inch]`)

| CLI arg / env var | TOML key | Default |
|---|---|---|
| `--one-inch-api-key` / `ONE_INCH_API_KEY` |
`[price-estimation.one-inch]` → `api-key` | *(none)* |
| `--one-inch-url` / `ONE_INCH_URL` | `[price-estimation.one-inch]` →
`url` | `"https://api.1inch.dev/"` |

```toml
[price-estimation.one-inch]
api-key = "my-key"
url = "https://api.1inch.dev/"
```

### CoinGecko (`[price-estimation.coin-gecko]`)

| CLI arg / env var | TOML key | Default |
|---|---|---|
| `--coin-gecko-api-key` / `COIN_GECKO_API_KEY` |
`[price-estimation.coin-gecko]` → `api-key` | *(none)* |
| `--coin-gecko-url` / `COIN_GECKO_URL` |
`[price-estimation.coin-gecko]` → `url` |
`"https://api.coingecko.com/api/v3/simple/token_price"` |
| `--coin-gecko-debouncing-time` / `COIN_GECKO_DEBOUNCING_TIME` |
`[price-estimation.coin-gecko.buffered]` → `debouncing-time` | *(none)*
|
| `--coin-gecko-broadcast-channel-capacity` /
`COIN_GECKO_BROADCAST_CHANNEL_CAPACITY` |
`[price-estimation.coin-gecko.buffered]` → `broadcast-channel-capacity`
| *(none)* |

The two buffered flags (which had to be provided together) are now an
optional nested table:

```toml
[price-estimation.coin-gecko]
api-key = "my-cg-key"
url = "https://pro-api.coingecko.com/api/v3/simple/token_price"

[price-estimation.coin-gecko.buffered]
debouncing-time = "500ms"
broadcast-channel-capacity = 100
```

### Balance Overrides (`[price-estimation.balance-overrides]`)

| CLI arg / env var | TOML key (`[price-estimation.balance-overrides]`)
| Default |
|---|---|---|
| `--quote-token-balance-overrides` / `QUOTE_TOKEN_BALANCE_OVERRIDES` |
`token-overrides` | `""` |
| `--quote-autodetect-token-balance-overrides` /
`QUOTE_AUTODETECT_TOKEN_BALANCE_OVERRIDES` | `autodetect` | `false` |
| `--quote-autodetect-token-balance-overrides-probing-depth` /
`QUOTE_AUTODETECT_TOKEN_BALANCE_OVERRIDES_PROBING_DEPTH` |
`probing-depth` | `60` |
| `--quote-autodetect-token-balance-overrides-cache-size` /
`QUOTE_AUTODETECT_TOKEN_BALANCE_OVERRIDES_CACHE_SIZE` | `cache-size` |
`1000` |

The `token-overrides` field uses the same `ADDR@SLOT` comma-separated
format as before:

```toml
[price-estimation.balance-overrides]
token-overrides = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2@3"
autodetect = true
probing-depth = 30
cache-size = 500
```

All defaults remain unchanged.

---------

Co-authored-by: Marcin Szymczak <mail@marszy.com>
---
 Cargo.lock                                    |  13 +-
 crates/autopilot/src/arguments.rs             |  10 +-
 crates/autopilot/src/run.rs                   |  13 +-
 crates/balance-overrides/Cargo.toml           |   3 +
 crates/balance-overrides/src/detector.rs      |   1 +
 crates/balance-overrides/src/lib.rs           | 196 +-----
 crates/configs/Cargo.toml                     |   8 +-
 crates/configs/src/autopilot/mod.rs           |  10 +-
 crates/configs/src/autopilot/native_price.rs  |  13 +-
 crates/configs/src/balance_overrides.rs       | 204 ++++++
 crates/configs/src/deserialize_env.rs         |  17 +
 crates/configs/src/lib.rs                     |   4 +
 crates/configs/src/native_price.rs            | 157 +++++
 crates/configs/src/native_price_estimators.rs | 112 ++++
 crates/configs/src/orderbook/mod.rs           |  10 +-
 crates/configs/src/orderbook/native_price.rs  |  17 +-
 crates/configs/src/price_estimation.rs        | 593 +++++++++++-------
 crates/configs/src/rate_limit.rs              |  73 +++
 crates/e2e/src/setup/services.rs              |  25 +-
 crates/e2e/tests/e2e/autopilot_leader.rs      |  12 +-
 crates/e2e/tests/e2e/limit_orders.rs          |  14 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |   8 +-
 crates/e2e/tests/e2e/quote_verification.rs    |  65 +-
 crates/e2e/tests/e2e/quoting.rs               |  20 +-
 crates/e2e/tests/e2e/replace_order.rs         |  20 +-
 crates/orderbook/src/arguments.rs             |  10 +-
 crates/orderbook/src/run.rs                   |  15 +-
 crates/price-estimation/src/config/mod.rs     |   2 +
 .../src/config/native_price.rs                |   1 +
 .../src/config/price_estimation.rs            |  45 ++
 crates/price-estimation/src/factory.rs        |  68 +-
 crates/price-estimation/src/lib.rs            | 320 +---------
 .../src/trade_verifier/tenderly_api.rs        |   4 +-
 crates/rate-limit/Cargo.toml                  |  10 +-
 crates/rate-limit/src/lib.rs                  | 112 +---
 crates/solvers/Cargo.toml                     |   1 +
 crates/solvers/src/infra/config/dex/file.rs   |   2 +-
 crates/solvers/src/infra/config/dex/mod.rs    |   2 +-
 38 files changed, 1243 insertions(+), 967 deletions(-)
 create mode 100644 crates/configs/src/balance_overrides.rs
 create mode 100644 crates/configs/src/native_price.rs
 create mode 100644 crates/configs/src/native_price_estimators.rs
 create mode 100644 crates/configs/src/rate_limit.rs
 create mode 100644 crates/price-estimation/src/config/mod.rs
 create mode 100644 crates/price-estimation/src/config/native_price.rs
 create mode 100644 crates/price-estimation/src/config/price_estimation.rs

diff --git a/Cargo.lock b/Cargo.lock
index bb5d7969be..e3b621d7e3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1862,9 +1862,12 @@ dependencies = [
  "async-trait",
  "cached",
  "clap",
+ "configs",
  "contracts",
  "ethrpc",
  "maplit",
+ "serde",
+ "serde_json",
  "thiserror 1.0.69",
  "tokio",
  "tracing",
@@ -2374,10 +2377,10 @@ version = "0.1.0"
 dependencies = [
  "alloy",
  "anyhow",
+ "bigdecimal",
  "chrono",
  "humantime-serde",
- "itertools 0.14.0",
- "price-estimation",
+ "rate-limit",
  "s3",
  "serde",
  "serde_json",
@@ -5890,12 +5893,15 @@ name = "rate-limit"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "configs",
  "futures",
- "humantime",
+ "humantime-serde",
  "observe",
  "prometheus",
  "prometheus-metric-storage",
  "reqwest 0.13.2",
+ "serde",
+ "serde_json",
  "thiserror 1.0.69",
  "tokio",
  "tracing",
@@ -6967,6 +6973,7 @@ dependencies = [
  "chain",
  "chrono",
  "clap",
+ "configs",
  "const-hex",
  "contracts",
  "derive_more 1.0.0",
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 701fb4b145..2265bedda2 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -7,21 +7,13 @@ pub struct CliArguments {
 
     #[clap(flatten)]
     pub shared: shared::arguments::Arguments,
-
-    #[clap(flatten)]
-    pub price_estimation: price_estimation::Arguments,
 }
 
 impl std::fmt::Display for CliArguments {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self {
-            config,
-            shared,
-            price_estimation,
-        } = self;
+        let Self { config, shared } = self;
         write!(f, "{}", config.display())?;
         write!(f, "{shared}")?;
-        write!(f, "{price_estimation}")?;
         Ok(())
     }
 }
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 2e328407f5..f6685fb46e 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -38,6 +38,7 @@ use {
     num::ToPrimitive,
     observe::metrics::LivenessChecking,
     price_estimation::{
+        config::price_estimation::BalanceOverridesConfigExt,
         factory::{self, PriceEstimatorFactory},
         native::NativePriceEstimating,
         trade_verifier::code_fetching::CachedCodeFetcher,
@@ -244,7 +245,7 @@ pub async fn run(
 
     let chain = Chain::try_from(chain_id).expect("incorrect chain ID");
 
-    let balance_overrider = args.price_estimation.balance_overrides.init(web3.clone());
+    let balance_overrider = config.price_estimation.balance_overrides.init(web3.clone());
 
     let balance_fetcher = account_balances::cached(
         &web3,
@@ -281,7 +282,7 @@ pub async fn run(
     let code_fetcher = Arc::new(CachedCodeFetcher::new(Arc::new(web3.clone())));
 
     let mut price_estimator_factory = PriceEstimatorFactory::new(
-        &args.price_estimation,
+        &config.price_estimation,
         &config.native_price_estimation.shared,
         factory::Network {
             web3: web3.clone(),
@@ -358,7 +359,7 @@ pub async fn run(
                 .price_estimation_drivers
                 .iter()
                 .map(
-                    |price_estimator_driver| configs::price_estimation::ExternalSolver {
+                    |price_estimator_driver| configs::native_price_estimators::ExternalSolver {
                         name: price_estimator_driver.name.clone(),
                         url: price_estimator_driver.url.clone(),
                     },
@@ -453,8 +454,8 @@ pub async fn run(
             .unwrap(),
         },
         balance_fetcher.clone(),
-        args.price_estimation.quote_verification,
-        args.price_estimation.quote_timeout,
+        config.price_estimation.quote_verification,
+        config.price_estimation.quote_timeout,
     ));
 
     let solvable_orders_cache = SolvableOrdersCache::new(
@@ -487,7 +488,7 @@ pub async fn run(
     let api_task = tokio::spawn(infra::api::serve(
         config.api_address,
         api_native_price_estimator,
-        args.price_estimation.quote_timeout,
+        config.price_estimation.quote_timeout,
         api_shutdown_receiver,
     ));
 
diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
index c4fa9b999b..127187e892 100644
--- a/crates/balance-overrides/Cargo.toml
+++ b/crates/balance-overrides/Cargo.toml
@@ -19,14 +19,17 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 cached = { workspace = true, features = ["default"] }
 clap = { workspace = true }
+configs = { workspace = true }
 contracts = { workspace = true }
 ethrpc = { workspace = true }
+serde = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
 ethrpc = { workspace = true, features = ["test-util"] }
 maplit = { workspace = true }
+serde_json = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 
 [lints]
diff --git a/crates/balance-overrides/src/detector.rs b/crates/balance-overrides/src/detector.rs
index a7e139269b..920f617173 100644
--- a/crates/balance-overrides/src/detector.rs
+++ b/crates/balance-overrides/src/detector.rs
@@ -1,5 +1,6 @@
 use {
     super::Strategy,
+    crate::StrategyExt,
     alloy_eips::BlockId,
     alloy_primitives::{Address, B256, TxKind, U256, keccak256},
     alloy_provider::ext::DebugApi,
diff --git a/crates/balance-overrides/src/lib.rs b/crates/balance-overrides/src/lib.rs
index 97dabe763f..c6c3077334 100644
--- a/crates/balance-overrides/src/lib.rs
+++ b/crates/balance-overrides/src/lib.rs
@@ -4,166 +4,21 @@ use {
     self::detector::{DetectionError, Detector},
     alloy_primitives::{Address, B256, U256, keccak256, map::AddressMap},
     alloy_rpc_types::state::AccountOverride,
-    anyhow::Context as _,
     cached::{Cached, SizedCache},
-    std::{
-        collections::HashMap,
-        fmt::{self, Display, Formatter},
-        iter,
-        str::FromStr,
-        sync::{Arc, Mutex},
-    },
+    configs::balance_overrides::Strategy,
+    std::{collections::HashMap, iter, sync::Mutex},
 };
-
-/// Balance override configuration arguments.
-#[derive(clap::Parser)]
-#[group(skip)]
-pub struct Arguments {
-    /// Token configuration for simulated balances on verified quotes. This
-    /// allows the quote verification system to produce verified quotes for
-    /// traders without sufficient balance for the configured token pairs.
-    ///
-    /// The expected format is a comma separated list of `${ADDR}@${SLOT}`,
-    /// where `ADDR` is the token address and `SLOT` is the Solidity storage
-    /// slot for the balances mapping. For example for WETH:
-    /// `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2@3`.
-    #[clap(long, env, default_value_t)]
-    pub quote_token_balance_overrides: TokenConfiguration,
-
-    /// Enable automatic detection of token balance overrides. Note that
-    /// pre-configured values with the `--quote-token-balance-overrides` flag
-    /// will take precedence.
-    #[clap(long, env, action = clap::ArgAction::Set, default_value_t)]
-    pub quote_autodetect_token_balance_overrides: bool,
-
-    /// Controls how many storage slots get probed per storage entry point
-    /// for automatically detecting how to override the balances of a token.
-    #[clap(long, env, action = clap::ArgAction::Set, default_value = "60")]
-    pub quote_autodetect_token_balance_overrides_probing_depth: u8,
-
-    /// Controls for how many tokens we store the result of the automatic
-    /// balance override detection before evicting less used entries.
-    #[clap(long, env, action = clap::ArgAction::Set, default_value = "1000")]
-    pub quote_autodetect_token_balance_overrides_cache_size: usize,
-}
-
-impl Arguments {
-    /// Creates a balance overrides instance from the current configuration.
-    pub fn init(&self, web3: ethrpc::Web3) -> Arc<dyn BalanceOverriding> {
-        Arc::new(BalanceOverrides {
-            hardcoded: self.quote_token_balance_overrides.0.clone(),
-            detector: self.quote_autodetect_token_balance_overrides.then(|| {
-                (
-                    Detector::new(
-                        web3,
-                        self.quote_autodetect_token_balance_overrides_probing_depth,
-                    ),
-                    Mutex::new(SizedCache::with_size(
-                        self.quote_autodetect_token_balance_overrides_cache_size,
-                    )),
-                )
-            }),
-        })
-    }
-}
-
-impl Display for Arguments {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let Self {
-            quote_token_balance_overrides,
-            quote_autodetect_token_balance_overrides,
-            quote_autodetect_token_balance_overrides_probing_depth,
-            quote_autodetect_token_balance_overrides_cache_size,
-        } = self;
-
-        writeln!(
-            f,
-            "quote_token_balance_overrides: {quote_token_balance_overrides:?}"
-        )?;
-        writeln!(
-            f,
-            "quote_autodetect_token_balance_overrides: \
-             {quote_autodetect_token_balance_overrides:?}"
-        )?;
-        writeln!(
-            f,
-            "quote_autodetect_token_balance_overrides_probing_depth: \
-             {quote_autodetect_token_balance_overrides_probing_depth:?}"
-        )?;
-        writeln!(
-            f,
-            "quote_autodetect_token_balance_overrides_cache_size: \
-             {quote_autodetect_token_balance_overrides_cache_size:?}"
-        )?;
-
-        Ok(())
-    }
-}
-
 /// Token configurations for the `BalanceOverriding` component.
 #[derive(Clone, Debug, Default)]
 pub struct TokenConfiguration(HashMap<Address, Strategy>);
 
-impl Display for TokenConfiguration {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let format_entry =
-            |f: &mut Formatter, (addr, strategy): (&Address, &Strategy)| match strategy {
-                Strategy::SolidityMapping {
-                    target_contract,
-                    map_slot,
-                } => write!(
-                    f,
-                    "SolidityMapping({addr:?}: {target_contract:?}@{map_slot})"
-                ),
-                Strategy::SoladyMapping { target_contract } => {
-                    write!(f, "SoladyMapping({addr:?}: {target_contract})")
-                }
-                Strategy::DirectSlot {
-                    target_contract,
-                    slot,
-                } => write!(f, "DirectSlot({addr:?}: {target_contract:?}@{slot})"),
-            };
-
-        let mut entries = self.0.iter();
-
-        let Some(first) = entries.next() else {
-            return Ok(());
-        };
-        format_entry(f, first)?;
-
-        for entry in entries {
-            f.write_str(",")?;
-            format_entry(f, entry)?;
-        }
-
-        Ok(())
+impl TokenConfiguration {
+    pub fn new(configuration: HashMap<Address, Strategy>) -> Self {
+        Self(configuration)
     }
-}
 
-impl FromStr for TokenConfiguration {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.is_empty() {
-            return Ok(Self::default());
-        }
-
-        let entries = s
-            .split(',')
-            .map(|part| -> Result<_, Self::Err> {
-                let (addr, slot) = part
-                    .split_once('@')
-                    .context("expected {addr}@{slot} format")?;
-                Ok((
-                    addr.parse()?,
-                    Strategy::SolidityMapping {
-                        target_contract: addr.parse()?,
-                        map_slot: slot.parse()?,
-                    },
-                ))
-            })
-            .collect::<Result<_, _>>()?;
-        Ok(Self(entries))
+    pub fn into_inner(self) -> HashMap<Address, Strategy> {
+        self.0
     }
 }
 
@@ -190,38 +45,15 @@ pub struct BalanceOverrideRequest {
     pub amount: U256,
 }
 
-/// Balance override strategy for a token.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Strategy {
-    /// Balance override strategy for tokens whose balances are stored in a
-    /// direct Solidity mapping from token holder to balance amount in the
-    /// form `mapping(address holder => uint256 amount)`.
-    ///
-    /// The strategy is configured with the storage slot [^1] of the mapping.
-    ///
-    /// [^1]: <https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html#mappings-and-dynamic-arrays>
-    SolidityMapping {
-        target_contract: Address,
-        map_slot: U256,
-    },
-    /// Strategy computing storage slot for balances based on the Solady library
-    /// [^1].
-    ///
-    /// [^1]: <https://github.com/Vectorized/solady/blob/6122858a3aed96ee9493b99f70a245237681a95f/src/tokens/ERC20.sol#L75-L81>
-    SoladyMapping { target_contract: Address },
-    /// Strategy that directly uses the storage slot discovered via
-    /// debug_traceCall. This is similar to Foundry's `deal` approach where
-    /// we trace a balanceOf call to find which storage slot is accessed for
-    /// a given account.
-    DirectSlot {
-        target_contract: Address,
-        slot: B256,
-    },
-}
-
-impl Strategy {
+trait StrategyExt {
     /// Computes the storage slot and value to override for a particular token
     /// holder and amount.
+    fn state_override(&self, holder: &Address, amount: &U256) -> AddressMap<AccountOverride>;
+
+    fn is_valid_for_all_holders(&self) -> bool;
+}
+
+impl StrategyExt for Strategy {
     fn state_override(&self, holder: &Address, amount: &U256) -> AddressMap<AccountOverride> {
         let (target_contract, key) = match self {
             Self::SolidityMapping {
diff --git a/crates/configs/Cargo.toml b/crates/configs/Cargo.toml
index 4e2f7174d1..1e363b8d99 100644
--- a/crates/configs/Cargo.toml
+++ b/crates/configs/Cargo.toml
@@ -6,9 +6,9 @@ edition = "2024"
 [dependencies]
 alloy = { workspace = true, features = ["signer-aws"] }
 anyhow = { workspace = true }
-chrono = { workspace = true }
+bigdecimal = { workspace = true, features = ["serde"] }
+chrono = { workspace = true, features = ["serde"] }
 humantime-serde = { workspace = true }
-itertools = { workspace = true }
 s3 = { workspace = true }
 serde = { workspace = true }
 tempfile = { workspace = true, optional = true }
@@ -19,12 +19,12 @@ tracing = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 
 [dev-dependencies]
-price-estimation = { workspace = true, features = ["test-util"] }
+rate-limit = { workspace = true, features = ["test-util"] }
 serde_json = { workspace = true }
 tempfile = { workspace = true }
 
 [features]
-test-util = ["dep:tempfile", "price-estimation/test-util"]
+test-util = ["dep:tempfile", "rate-limit/test-util"]
 
 [lints]
 workspace = true
diff --git a/crates/configs/src/autopilot/mod.rs b/crates/configs/src/autopilot/mod.rs
index fe0aaf0f51..ba1a6c242d 100644
--- a/crates/configs/src/autopilot/mod.rs
+++ b/crates/configs/src/autopilot/mod.rs
@@ -15,6 +15,7 @@ use {
         database::DatabasePoolConfig,
         http_client::HttpClient,
         order_quoting::OrderQuoting,
+        price_estimation::PriceEstimation,
     },
     alloy::primitives::Address,
     anyhow::{anyhow, ensure},
@@ -154,6 +155,11 @@ pub struct Configuration {
 
     // Configurations for the order creation process.
     pub order_quoting: OrderQuoting,
+
+    /// Configurations for price estimation (tenderly, rate limiting, CoinGecko,
+    /// 1inch, quote verification, balance overrides, etc.).
+    #[serde(default)]
+    pub price_estimation: PriceEstimation,
 }
 
 impl Configuration {
@@ -215,6 +221,7 @@ impl Configuration {
             max_auction_age: default_max_auction_age(),
             http_client: Default::default(),
             order_quoting: TestDefault::test_default(),
+            price_estimation: TestDefault::test_default(),
         }
     }
 
@@ -244,6 +251,7 @@ impl Configuration {
             max_auction_age: default_max_auction_age(),
             http_client: Default::default(),
             order_quoting: TestDefault::test_default(),
+            price_estimation: TestDefault::test_default(),
         }
     }
 
@@ -278,7 +286,7 @@ mod tests {
                 fee_policy::{FeePolicy, FeePolicyKind, FeePolicyOrderClass, UpcomingFeePolicies},
                 solver::Account,
             },
-            price_estimation::{ExternalSolver, NativePriceEstimator},
+            native_price_estimators::{ExternalSolver, NativePriceEstimator},
         },
         alloy::primitives::address,
         std::time::Duration,
diff --git a/crates/configs/src/autopilot/native_price.rs b/crates/configs/src/autopilot/native_price.rs
index c532262222..b8be0dc1fb 100644
--- a/crates/configs/src/autopilot/native_price.rs
+++ b/crates/configs/src/autopilot/native_price.rs
@@ -1,6 +1,6 @@
 use {
-    crate::price_estimation::NativePriceEstimators,
-    serde::{Deserialize, Serialize},
+    crate::native_price_estimators::NativePriceEstimators,
+    serde::Deserialize,
     std::time::Duration,
 };
 
@@ -14,7 +14,8 @@ const fn default_native_price_prefetch_time() -> Duration {
 
 // Does not implement Default because `estimators` *cannot* be empty,
 // as such, we cannot provide a proper default value for this structure.
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
 pub struct NativePriceConfig {
     /// Which estimators to use to estimate token prices in terms of the chain's
@@ -45,7 +46,7 @@ pub struct NativePriceConfig {
     pub prefetch_time: Duration,
 
     #[serde(flatten)]
-    pub shared: crate::price_estimation::NativePriceConfig,
+    pub shared: crate::native_price::NativePriceConfig,
 }
 
 #[cfg(any(test, feature = "test-util"))]
@@ -59,8 +60,8 @@ impl NativePriceConfig {
             api_estimators: Default::default(),
             cache_refresh_interval: default_native_price_cache_refresh(),
             prefetch_time: Duration::from_millis(500),
-            shared: crate::price_estimation::NativePriceConfig {
-                cache: crate::price_estimation::CacheConfig {
+            shared: crate::native_price::NativePriceConfig {
+                cache: crate::native_price::CacheConfig {
                     max_age: Duration::from_secs(2),
                     ..Default::default()
                 },
diff --git a/crates/configs/src/balance_overrides.rs b/crates/configs/src/balance_overrides.rs
new file mode 100644
index 0000000000..d8c78b62fa
--- /dev/null
+++ b/crates/configs/src/balance_overrides.rs
@@ -0,0 +1,204 @@
+use {
+    alloy::primitives::{Address, B256, U256},
+    serde::Deserialize,
+    std::{
+        collections::HashMap,
+        fmt::{self, Formatter},
+    },
+};
+
+/// Balance override strategy for a token.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(tag = "type")]
+pub enum Strategy {
+    /// Balance override strategy for tokens whose balances are stored in a
+    /// direct Solidity mapping from token holder to balance amount in the
+    /// form `mapping(address holder => uint256 amount)`.
+    ///
+    /// The strategy is configured with the storage slot [^1] of the mapping.
+    ///
+    /// [^1]: <https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html#mappings-and-dynamic-arrays>
+    SolidityMapping {
+        target_contract: Address,
+        map_slot: U256,
+    },
+    /// Strategy computing storage slot for balances based on the Solady library
+    /// [^1].
+    ///
+    /// [^1]: <https://github.com/Vectorized/solady/blob/6122858a3aed96ee9493b99f70a245237681a95f/src/tokens/ERC20.sol#L75-L81>
+    SoladyMapping { target_contract: Address },
+    /// Strategy that directly uses the storage slot discovered via
+    /// debug_traceCall. This is similar to Foundry's `deal` approach where
+    /// we trace a balanceOf call to find which storage slot is accessed for
+    /// a given account.
+    DirectSlot {
+        target_contract: Address,
+        slot: B256,
+    },
+}
+
+/// Token configurations for the `BalanceOverriding` component.
+#[derive(Clone, Debug, Default, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct TokenConfiguration(HashMap<Address, Strategy>);
+
+impl TokenConfiguration {
+    pub fn inner(&self) -> &HashMap<Address, Strategy> {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for TokenConfiguration {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let format_entry =
+            |f: &mut Formatter, (addr, strategy): (&Address, &Strategy)| match strategy {
+                Strategy::SolidityMapping {
+                    target_contract,
+                    map_slot,
+                } => write!(
+                    f,
+                    "SolidityMapping({addr:?}: {target_contract:?}@{map_slot})"
+                ),
+                Strategy::SoladyMapping { target_contract } => {
+                    write!(f, "SoladyMapping({addr:?}: {target_contract})")
+                }
+                Strategy::DirectSlot {
+                    target_contract,
+                    slot,
+                } => write!(f, "DirectSlot({addr:?}: {target_contract:?}@{slot})"),
+            };
+
+        let mut entries = self.0.iter();
+
+        let Some(first) = entries.next() else {
+            return Ok(());
+        };
+        format_entry(f, first)?;
+
+        for entry in entries {
+            f.write_str(",")?;
+            format_entry(f, entry)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_solidity_mapping() {
+        let input = r#"
+[0x0000000000000000000000000000000000000001]
+type = "SolidityMapping"
+target_contract = "0x0000000000000000000000000000000000000002"
+map_slot = "0x3"
+"#;
+        let config: TokenConfiguration = toml::from_str(input).unwrap();
+        let strategy = config
+            .0
+            .get(&Address::from_word(U256::from(1).into()))
+            .unwrap();
+        assert_eq!(
+            *strategy,
+            Strategy::SolidityMapping {
+                target_contract: Address::from_word(U256::from(2).into()),
+                map_slot: U256::from(3),
+            }
+        );
+    }
+
+    #[test]
+    fn deserialize_solady_mapping() {
+        let input = r#"
+[0x0000000000000000000000000000000000000001]
+type = "SoladyMapping"
+target_contract = "0x0000000000000000000000000000000000000002"
+"#;
+        let config: TokenConfiguration = toml::from_str(input).unwrap();
+        let strategy = config
+            .0
+            .get(&Address::from_word(U256::from(1).into()))
+            .unwrap();
+        assert_eq!(
+            *strategy,
+            Strategy::SoladyMapping {
+                target_contract: Address::from_word(U256::from(2).into()),
+            }
+        );
+    }
+
+    #[test]
+    fn deserialize_direct_slot() {
+        let input = r#"
+[0x0000000000000000000000000000000000000001]
+type = "DirectSlot"
+target_contract = "0x0000000000000000000000000000000000000002"
+slot = "0x0000000000000000000000000000000000000000000000000000000000000005"
+"#;
+        let config: TokenConfiguration = toml::from_str(input).unwrap();
+        let strategy = config
+            .0
+            .get(&Address::from_word(U256::from(1).into()))
+            .unwrap();
+        assert_eq!(
+            *strategy,
+            Strategy::DirectSlot {
+                target_contract: Address::from_word(U256::from(2).into()),
+                slot: B256::from(U256::from(5)),
+            }
+        );
+    }
+
+    #[test]
+    fn serialize_roundtrip() {
+        let mut map = HashMap::default();
+        let addr = Address::from_word(U256::from(1).into());
+        map.insert(
+            addr,
+            Strategy::SolidityMapping {
+                target_contract: Address::from_word(U256::from(2).into()),
+                map_slot: U256::from(3),
+            },
+        );
+        let config = TokenConfiguration(map);
+        let serialized = toml::to_string(&config).unwrap();
+        let deserialized: TokenConfiguration = toml::from_str(&serialized).unwrap();
+        assert_eq!(config.0, deserialized.0);
+    }
+
+    #[test]
+    fn deserialize_multiple_tokens() {
+        let input = r#"
+[0x0000000000000000000000000000000000000001]
+type = "SolidityMapping"
+target_contract = "0x0000000000000000000000000000000000000002"
+map_slot = "0x3"
+
+[0x0000000000000000000000000000000000000004]
+type = "SoladyMapping"
+target_contract = "0x0000000000000000000000000000000000000005"
+"#;
+        let config: TokenConfiguration = toml::from_str(input).unwrap();
+        assert_eq!(config.0.len(), 2);
+    }
+
+    #[test]
+    fn deserialize_empty_config() {
+        let config: TokenConfiguration = toml::from_str("").unwrap();
+        assert!(config.0.is_empty());
+    }
+
+    #[test]
+    fn deserialize_unknown_type_fails() {
+        let input = r#"
+[0x0000000000000000000000000000000000000001]
+type = "UnknownStrategy"
+target_contract = "0x0000000000000000000000000000000000000002"
+"#;
+        assert!(toml::from_str::<TokenConfiguration>(input).is_err());
+    }
+}
diff --git a/crates/configs/src/deserialize_env.rs b/crates/configs/src/deserialize_env.rs
index 9b5b230dae..798c99e681 100644
--- a/crates/configs/src/deserialize_env.rs
+++ b/crates/configs/src/deserialize_env.rs
@@ -51,6 +51,23 @@ where
     Url::from_str(&raw_url).map_err(invalid_value_unable_to_parse_url)
 }
 
+/// Deserializes an optional String from *either* an environment variable —
+/// with the format `%<ENV_VAR_NAME>` — or directly from the field value.
+pub(crate) fn deserialize_string_from_env<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = String::deserialize(deserializer)?;
+    match value.strip_prefix(ENV_VAR_PREFIX) {
+        Some(env_var_name) => Ok(std::env::var(env_var_name)
+            .inspect_err(|err| {
+                tracing::error!(%err, %env_var_name, "failed to load env var");
+            })
+            .map_err(|_| invalid_value_env_var_missing(env_var_name))?),
+        None => Ok(value),
+    }
+}
+
 /// Deserializes an optional URL from *either* an environment variable — with
 /// the format `%<ENV_VAR_NAME>` — or interpreting a String as a URL.
 pub(crate) fn deserialize_optional_url_from_env<'de, D>(
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index 2402a32c0e..33d41702ce 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -1,12 +1,16 @@
 pub mod autopilot;
+pub mod balance_overrides;
 pub mod banned_users;
 pub mod database;
 pub(crate) mod deserialize_env;
 pub mod fee_factor;
 pub mod http_client;
+pub mod native_price;
+pub mod native_price_estimators;
 pub mod order_quoting;
 pub mod orderbook;
 pub mod price_estimation;
+pub mod rate_limit;
 
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
diff --git a/crates/configs/src/native_price.rs b/crates/configs/src/native_price.rs
new file mode 100644
index 0000000000..427cbefed6
--- /dev/null
+++ b/crates/configs/src/native_price.rs
@@ -0,0 +1,157 @@
+use {
+    alloy::primitives::Address,
+    serde::Deserialize,
+    std::{num::NonZeroUsize, time::Duration},
+};
+
+const fn default_cache_max_age() -> Duration {
+    Duration::from_mins(10)
+}
+
+const fn default_cache_concurrent_requests() -> NonZeroUsize {
+    NonZeroUsize::new(1).expect("value should be greater than 0")
+}
+
+const fn default_results_required() -> NonZeroUsize {
+    NonZeroUsize::new(2).expect("value should not be zero")
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct NativePriceConfig {
+    /// List of mappings of native price tokens substitutions with approximated:
+    /// - the first is a token address for which we get the native token price
+    /// - the second is a token address used for the price approximation
+    #[serde(default)]
+    pub approximation_tokens: Vec<(Address, Address)>,
+
+    /// Configuration for the native price caching mechanism.
+    #[serde(default)]
+    pub cache: CacheConfig,
+
+    /// How many successful price estimates for each order will cause a native
+    /// price estimation to return its result early.
+    ///
+    /// As this value increases, the fast estimator behavior will approximate
+    /// the behavior of the optimal estimator.
+    ///
+    /// It's possible to pass values greater than the total number of enabled
+    /// estimators but that will not have any further effect.
+    #[serde(default = "default_results_required")]
+    pub results_required: NonZeroUsize,
+}
+
+impl Default for NativePriceConfig {
+    fn default() -> Self {
+        Self {
+            approximation_tokens: Default::default(),
+            cache: Default::default(),
+            results_required: default_results_required(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct CacheConfig {
+    /// How long cached native prices stay valid.
+    #[serde(default = "default_cache_max_age", with = "humantime_serde")]
+    pub max_age: Duration,
+
+    /// How many price estimation requests can be executed concurrently in the
+    /// maintenance task.
+    #[serde(default = "default_cache_concurrent_requests")]
+    pub concurrent_requests: NonZeroUsize,
+}
+
+impl Default for CacheConfig {
+    fn default() -> Self {
+        Self {
+            max_age: default_cache_max_age(),
+            concurrent_requests: default_cache_concurrent_requests(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_full() {
+        let toml = r#"
+            approximation-tokens = [
+                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
+            ]
+
+            [cache]
+            max-age = "5m"
+            concurrent-requests = 4
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.approximation_tokens.len(), 1);
+        assert_eq!(config.cache.max_age, Duration::from_secs(300));
+        assert_eq!(
+            config.cache.concurrent_requests,
+            NonZeroUsize::new(4).unwrap()
+        );
+    }
+
+    #[test]
+    fn cache_defaults() {
+        let toml = r#"
+            approximation-tokens = []
+            [cache]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.cache.max_age, Duration::from_mins(10));
+        assert_eq!(
+            config.cache.concurrent_requests,
+            NonZeroUsize::new(1).unwrap()
+        );
+    }
+
+    #[test]
+    fn multiple_approximation_tokens() {
+        let toml = r#"
+            approximation-tokens = [
+                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
+                ["0x0000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000004"],
+            ]
+            [cache]
+        "#;
+        let config: NativePriceConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.approximation_tokens.len(), 2);
+        assert_eq!(
+            config.approximation_tokens[0].0,
+            Address::from_slice(&[0; 19].into_iter().chain([1]).collect::<Vec<_>>()),
+        );
+    }
+
+    #[test]
+    fn roundtrip_serialization() {
+        let config = NativePriceConfig {
+            approximation_tokens: vec![(Address::repeat_byte(1), Address::repeat_byte(2))],
+            cache: CacheConfig {
+                max_age: Duration::from_secs(120),
+                concurrent_requests: NonZeroUsize::new(8).unwrap(),
+            },
+            results_required: default_results_required(),
+        };
+
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
+
+        assert_eq!(
+            config.approximation_tokens,
+            deserialized.approximation_tokens,
+        );
+        assert_eq!(config.cache.max_age, deserialized.cache.max_age);
+        assert_eq!(
+            config.cache.concurrent_requests,
+            deserialized.cache.concurrent_requests,
+        );
+    }
+}
diff --git a/crates/configs/src/native_price_estimators.rs b/crates/configs/src/native_price_estimators.rs
new file mode 100644
index 0000000000..cb2948883a
--- /dev/null
+++ b/crates/configs/src/native_price_estimators.rs
@@ -0,0 +1,112 @@
+use {
+    serde::Deserialize,
+    std::fmt::{self, Display, Formatter},
+    url::Url,
+};
+
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
+
+impl<'de> Deserialize<'de> for NativePriceEstimators {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let estimators = <Vec<Vec<NativePriceEstimator>>>::deserialize(deserializer)?;
+        if estimators.is_empty() {
+            return Err(serde::de::Error::invalid_length(
+                0,
+                &"expected native price estimator stages to be configured",
+            ));
+        }
+        match estimators
+            .iter()
+            .enumerate()
+            .find_map(|(n, stage)| stage.is_empty().then_some(n))
+        {
+            Some(n) => Err(serde::de::Error::invalid_length(
+                0,
+                &format!("stage {} is empty, all stages must not be empty", n).as_str(),
+            )),
+            None => Ok(Self(estimators)),
+        }
+    }
+}
+
+impl NativePriceEstimators {
+    pub fn new(estimators: Vec<Vec<NativePriceEstimator>>) -> Self {
+        Self(estimators)
+    }
+
+    pub fn as_slice(&self) -> &[Vec<NativePriceEstimator>] {
+        &self.0
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl NativePriceEstimators {
+    pub fn test_default() -> Self {
+        use std::str::FromStr;
+        NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
+            "test_quoter".to_string(),
+            Url::from_str("http://localhost:11088/test_solver").unwrap(),
+        )]])
+    }
+}
+
+impl Display for NativePriceEstimators {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        for (i, stage) in self.as_slice().iter().enumerate() {
+            if i > 0 {
+                write!(f, ";")?;
+            }
+            for (j, estimator) in stage.iter().enumerate() {
+                if j > 0 {
+                    write!(f, ",")?;
+                }
+                write!(f, "{estimator}")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(deny_unknown_fields)]
+pub struct ExternalSolver {
+    pub name: String,
+    pub url: Url,
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(tag = "type")]
+pub enum NativePriceEstimator {
+    Driver(ExternalSolver),
+    Forwarder { url: Url },
+    OneInchSpotPriceApi,
+    CoinGecko,
+}
+
+impl NativePriceEstimator {
+    pub const fn driver(name: String, url: Url) -> Self {
+        Self::Driver(ExternalSolver { name, url })
+    }
+
+    pub const fn forwarder(url: Url) -> Self {
+        Self::Forwarder { url }
+    }
+}
+
+impl Display for NativePriceEstimator {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            NativePriceEstimator::Driver(s) => write!(f, "Driver|{}|{}", &s.name, s.url),
+            NativePriceEstimator::Forwarder { url } => write!(f, "Forwarder|{}", url),
+            NativePriceEstimator::OneInchSpotPriceApi => write!(f, "OneInchSpotPriceApi"),
+            NativePriceEstimator::CoinGecko => write!(f, "CoinGecko"),
+        }
+    }
+}
diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index 12b16511ea..fd74da2c6f 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -10,6 +10,7 @@ use {
             native_price::NativePriceConfig,
             order_validation::OrderValidationConfig,
         },
+        price_estimation::PriceEstimation,
     },
     alloy::primitives::Address,
     anyhow::anyhow,
@@ -84,6 +85,11 @@ pub struct Configuration {
 
     // Configurations for the order creation process.
     pub order_quoting: OrderQuoting,
+
+    /// Configurations for price estimation (tenderly, rate limiting, CoinGecko,
+    /// 1inch, quote verification, balance overrides, etc.).
+    #[serde(default)]
+    pub price_estimation: PriceEstimation,
 }
 
 impl Configuration {
@@ -162,6 +168,7 @@ pub mod test_util {
                 database: TestDefault::test_default(),
                 http_client: Default::default(),
                 order_quoting: TestDefault::test_default(),
+                price_estimation: TestDefault::test_default(),
             }
         }
     }
@@ -172,8 +179,8 @@ mod tests {
     use {
         super::*,
         crate::{
+            native_price_estimators::{NativePriceEstimator, NativePriceEstimators},
             orderbook::order_validation::SameTokensPolicy,
-            price_estimation::{NativePriceEstimator, NativePriceEstimators},
             test_util::TestDefault,
         },
         std::time::Duration,
@@ -319,6 +326,7 @@ mod tests {
             order_quoting: TestDefault::test_default(),
             database: TestDefault::test_default(),
             http_client: Default::default(),
+            price_estimation: Default::default(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/configs/src/orderbook/native_price.rs b/crates/configs/src/orderbook/native_price.rs
index 6349ffdeee..c51fafedb4 100644
--- a/crates/configs/src/orderbook/native_price.rs
+++ b/crates/configs/src/orderbook/native_price.rs
@@ -1,12 +1,13 @@
 use {
-    crate::price_estimation::{
-        NativePriceConfig as SharedNativePriceConfig,
-        NativePriceEstimators,
+    crate::{
+        native_price::NativePriceConfig as SharedNativePriceConfig,
+        native_price_estimators::NativePriceEstimators,
     },
-    serde::{Deserialize, Serialize},
+    serde::Deserialize,
 };
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
 pub struct NativePriceConfig {
     /// Which estimators to use to estimate token prices in terms of the chain's
@@ -25,7 +26,7 @@ pub struct NativePriceConfig {
 impl NativePriceConfig {
     /// The orderbook forwards native price requests to the autopilot.
     pub fn test_default() -> Self {
-        use crate::price_estimation::NativePriceEstimator;
+        use crate::native_price_estimators::NativePriceEstimator;
         Self {
             estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::forwarder(
                 "http://localhost:12088".parse().unwrap(),
@@ -38,7 +39,7 @@ impl NativePriceConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use {super::*, crate::native_price_estimators::NativePriceEstimator};
 
     #[test]
     fn deserialize_defaults() {
@@ -70,8 +71,6 @@ mod tests {
 
     #[test]
     fn roundtrip_serialization() {
-        use crate::price_estimation::NativePriceEstimator;
-
         let config = NativePriceConfig {
             estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
             fallback_estimators: Some(NativePriceEstimators::new(vec![vec![
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index 752a304363..690a7e0949 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -1,320 +1,443 @@
 use {
-    alloy::primitives::Address,
-    anyhow::{Context, Result, ensure},
-    itertools::Itertools,
-    serde::{Deserialize, Serialize},
-    std::{
-        fmt::{self, Display, Formatter},
-        num::NonZeroUsize,
-        str::FromStr,
-        time::Duration,
-    },
+    crate::{balance_overrides, rate_limit::Strategy},
+    alloy::primitives::{Address, U256, map::HashSet},
+    bigdecimal::BigDecimal,
+    serde::Deserialize,
+    std::{str::FromStr, time::Duration},
     url::Url,
 };
 
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
-
-impl<'de> Deserialize<'de> for NativePriceEstimators {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let estimators = <Vec<Vec<NativePriceEstimator>>>::deserialize(deserializer)?;
-        if estimators.is_empty() {
-            return Err(serde::de::Error::invalid_length(
-                0,
-                &"expected native price estimator stages to be configured",
-            ));
-        }
-        match estimators
-            .iter()
-            .enumerate()
-            .find_map(|(n, stage)| stage.is_empty().then_some(n))
-        {
-            Some(n) => Err(serde::de::Error::invalid_length(
-                0,
-                &format!("stage {} is empty, all stages must not be empty", n).as_str(),
-            )),
-            None => Ok(Self(estimators)),
-        }
-    }
+/// Controls which level of quote verification gets applied.
+#[derive(Copy, Clone, Debug, Default, serde::Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case")]
+pub enum QuoteVerificationMode {
+    /// Quotes do not get verified.
+    #[default]
+    Unverified,
+    /// Quotes get verified whenever possible and verified
+    /// quotes are preferred over unverified ones.
+    Prefer,
+    /// Quotes get discarded if they can't be verified.
+    /// Some scenarios like missing sell token balance are exempt.
+    EnforceWhenPossible,
 }
 
-impl NativePriceEstimators {
-    pub fn new(estimators: Vec<Vec<NativePriceEstimator>>) -> Self {
-        Self(estimators)
-    }
+const fn default_quote_timeout() -> Duration {
+    Duration::from_secs(5)
 }
 
-#[cfg(any(test, feature = "test-util"))]
-impl NativePriceEstimators {
-    /// Returns a list with a single stage, said stage contains a Driver estimator named `test_quoter` with URL `http://localhost:11088/test_solver`.
-    pub fn test_default() -> Self {
-        NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
-            "test_quoter".to_string(),
-            Url::from_str("http://localhost:11088/test_solver").unwrap(),
-        )]])
-    }
+fn default_quote_inaccuracy_limit() -> BigDecimal {
+    BigDecimal::from(1)
 }
 
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize, Serialize)]
-#[serde(tag = "type")]
-pub enum NativePriceEstimator {
-    Driver(ExternalSolver),
-    Forwarder { url: Url },
-    OneInchSpotPriceApi,
-    CoinGecko,
+const fn default_max_gas_per_tx() -> u64 {
+    16777215
 }
 
-impl NativePriceEstimator {
-    pub const fn driver(name: String, url: Url) -> Self {
-        Self::Driver(ExternalSolver { name, url })
-    }
+#[derive(Deserialize, Debug)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct PriceEstimation {
+    /// Configures the back off strategy for price estimators when requests take
+    /// too long. Requests issued while back off is active get dropped
+    /// entirely.
+    #[serde(default)]
+    pub price_estimation_rate_limiter: Option<Strategy>,
 
-    pub const fn forwarder(url: Url) -> Self {
-        Self::Forwarder { url }
-    }
+    /// The amount in native token atoms to use for price estimation. Should be
+    /// reasonably large so that small pools do not influence the prices. If
+    /// not set, a reasonable default is used based on network id.
+    #[serde(default)]
+    pub amount_to_estimate_prices_with: Option<U256>,
+
+    /// How inaccurate a quote must be before it gets discarded, provided as a
+    /// factor. E.g. a value of `0.01` means at most 1 percent of the sell or
+    /// buy tokens can be paid out of the settlement contract buffers.
+    #[serde(default = "default_quote_inaccuracy_limit")]
+    pub quote_inaccuracy_limit: BigDecimal,
+
+    /// How strict quote verification should be.
+    #[serde(default)]
+    pub quote_verification: QuoteVerificationMode,
+
+    /// Default timeout for quote requests.
+    #[serde(with = "humantime_serde", default = "default_quote_timeout")]
+    pub quote_timeout: Duration,
+
+    #[serde(default)]
+    pub balance_overrides: BalanceOverridesConfig,
+
+    /// Tokens for which quote verification should not be attempted. This is an
+    /// escape hatch when there is a very bad but verifiable liquidity source
+    /// that would win against a very good but unverifiable liquidity source
+    /// (e.g. private liquidity that exists but can't be verified).
+    #[serde(default)]
+    pub tokens_without_verification: HashSet<Address>,
+
+    /// How much gas a single tx may consume at most. Any quote using more than
+    /// this will fail during the verification.
+    /// Defaults to the maximum transaction gas limit Ethereum introduced in the
+    /// Fusaka hardfork.
+    #[serde(default = "default_max_gas_per_tx")]
+    pub max_gas_per_tx: u64,
+
+    /// Tenderly configuration (URL, project & API key).
+    #[serde(default)]
+    pub tenderly: Option<TenderlyConfig>,
+
+    /// The CoinGecko native price configuration.
+    #[serde(default)]
+    pub coin_gecko: Option<CoinGeckoConfig>,
+
+    /// 1-inch API connection settings (URL & key).
+    #[serde(default)]
+    pub one_inch: Option<OneInchApi>,
 }
 
-impl Display for NativePriceEstimator {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let formatter = match self {
-            NativePriceEstimator::Driver(s) => format!("Driver|{}|{}", &s.name, s.url),
-            NativePriceEstimator::Forwarder { url } => format!("Forwarder|{}", url),
-            NativePriceEstimator::OneInchSpotPriceApi => "OneInchSpotPriceApi".into(),
-            NativePriceEstimator::CoinGecko => "CoinGecko".into(),
-        };
-        write!(f, "{formatter}")
+impl Default for PriceEstimation {
+    fn default() -> Self {
+        Self {
+            tenderly: Default::default(),
+            price_estimation_rate_limiter: None,
+            amount_to_estimate_prices_with: None,
+            one_inch: Default::default(),
+            coin_gecko: Default::default(),
+            quote_inaccuracy_limit: default_quote_inaccuracy_limit(),
+            quote_verification: Default::default(),
+            quote_timeout: default_quote_timeout(),
+            balance_overrides: Default::default(),
+            tokens_without_verification: Default::default(),
+            max_gas_per_tx: default_max_gas_per_tx(),
+        }
     }
 }
 
-impl NativePriceEstimators {
-    pub fn as_slice(&self) -> &[Vec<NativePriceEstimator>] {
-        &self.0
+#[cfg(any(test, feature = "test-util"))]
+impl crate::test_util::TestDefault for PriceEstimation {
+    fn test_default() -> Self {
+        Self {
+            amount_to_estimate_prices_with: Some(alloy::primitives::U256::from(
+                1_000_000_000_000_000_000u64,
+            )),
+            quote_timeout: Duration::from_secs(10),
+            quote_verification: QuoteVerificationMode::EnforceWhenPossible,
+            ..Default::default()
+        }
     }
 }
 
-impl Display for NativePriceEstimators {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let formatter = self
-            .as_slice()
-            .iter()
-            .map(|stage| {
-                stage
-                    .iter()
-                    .format_with(",", |estimator, f| f(&format_args!("{estimator}")))
-            })
-            .format(";");
-        write!(f, "{formatter}")
-    }
+#[derive(Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct TenderlyConfig {
+    /// The Tenderly user associated with the API key.
+    #[serde(default)]
+    pub user: String,
+
+    /// The Tenderly project associated with the API key.
+    #[serde(default)]
+    pub project: String,
+
+    /// Tenderly requires an API key to work. Optional since Tenderly could be
+    /// skipped in access lists estimators.
+    #[serde(default)]
+    pub api_key: String,
 }
 
-impl FromStr for NativePriceEstimators {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Self(
-            s.split(';')
-                .map(|sub_list| {
-                    sub_list
-                        .split(',')
-                        .map(NativePriceEstimator::from_str)
-                        .collect::<Result<Vec<NativePriceEstimator>>>()
-                })
-                .collect::<Result<Vec<Vec<NativePriceEstimator>>>>()?,
-        ))
+impl std::fmt::Debug for TenderlyConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TenderlyConfig")
+            .field("user", &self.user)
+            .field("project", &self.project)
+            .field("api_key", &"<REDACTED>")
+            .finish()
     }
 }
 
-impl FromStr for NativePriceEstimator {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (variant, args) = s.split_once('|').unwrap_or((s, ""));
-        match variant {
-            "OneInchSpotPriceApi" => Ok(NativePriceEstimator::OneInchSpotPriceApi),
-            "CoinGecko" => Ok(NativePriceEstimator::CoinGecko),
-            "Driver" => Ok(NativePriceEstimator::Driver(ExternalSolver::from_str(
-                args,
-            )?)),
-            "Forwarder" => Ok(NativePriceEstimator::Forwarder {
-                url: args
-                    .parse()
-                    .context("Forwarder price estimator invalid URL")?,
-            }),
-            _ => Err(anyhow::anyhow!("unsupported native price estimator: {}", s)),
+#[cfg(any(test, feature = "test-util"))]
+impl crate::test_util::TestDefault for TenderlyConfig {
+    fn test_default() -> Self {
+        Self {
+            user: "test-user".to_string(),
+            project: "test-project".to_string(),
+            api_key: "test-api-key".to_string(),
         }
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
-pub struct ExternalSolver {
-    pub name: String,
+fn default_coin_gecko_url() -> Url {
+    Url::from_str("https://api.coingecko.com/api/v3/simple/token_price")
+        .expect("url should be valid")
+}
+
+#[derive(Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct CoinGeckoConfig {
+    /// The API key for the CoinGecko API.
+    #[serde(
+        default,
+        deserialize_with = "crate::deserialize_env::deserialize_string_from_env"
+    )]
+    pub api_key: String,
+
+    /// The base URL for the CoinGecko API.
+    #[serde(default = "default_coin_gecko_url")]
     pub url: Url,
+
+    #[serde(default)]
+    pub buffered: Option<CoinGeckoBufferedConfig>,
+}
+
+impl std::fmt::Debug for CoinGeckoConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CoinGeckoConfig")
+            .field("api_key", &"<REDACTED>")
+            .field("url", &self.url)
+            .field("buffered", &self.buffered)
+            .finish()
+    }
 }
 
-impl FromStr for ExternalSolver {
-    type Err = anyhow::Error;
-
-    fn from_str(solver: &str) -> Result<Self> {
-        let parts: Vec<&str> = solver.split('|').collect();
-        ensure!(parts.len() >= 2, "not enough arguments for external solver");
-        let (name, url) = (parts[0], parts[1]);
-        let url: Url = url.parse()?;
-        Ok(Self {
-            name: name.to_owned(),
-            url,
-        })
+#[cfg(any(test, feature = "test-util"))]
+impl crate::test_util::TestDefault for CoinGeckoConfig {
+    fn test_default() -> Self {
+        Self {
+            api_key: "test-api-key".to_string(),
+            url: default_coin_gecko_url(),
+            buffered: None,
+        }
     }
 }
 
-const fn default_cache_max_age() -> Duration {
-    Duration::from_mins(10)
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct CoinGeckoBufferedConfig {
+    /// An additional minimum delay to wait for collecting CoinGecko requests.
+    ///
+    /// The delay to start counting after receiving the first request.
+    #[serde(with = "humantime_serde")]
+    pub debouncing_time: Duration,
+
+    /// Maximum capacity of the broadcast channel to store the CoinGecko native
+    /// prices results
+    pub broadcast_channel_capacity: usize,
 }
 
-const fn default_cache_concurrent_requests() -> NonZeroUsize {
-    NonZeroUsize::new(1).expect("value should be greater than 0")
+const fn default_probing_depth() -> u8 {
+    60
 }
 
-const fn default_results_required() -> NonZeroUsize {
-    NonZeroUsize::new(2).expect("value should not be zero")
+const fn default_cache_size() -> usize {
+    1000
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct NativePriceConfig {
-    /// List of mappings of native price tokens substitutions with approximated:
-    /// - the first is a token address for which we get the native token price
-    /// - the second is a token address used for the price approximation
+pub struct BalanceOverridesConfig {
+    /// Token configuration for simulated balances on verified quotes. This
+    /// allows the quote verification system to produce verified quotes for
+    /// traders without sufficient balance for the configured token pairs.
     #[serde(default)]
-    pub approximation_tokens: Vec<(Address, Address)>,
+    pub token_overrides: balance_overrides::TokenConfiguration,
 
-    /// Configuration for the native price caching mechanism.
+    /// Enable automatic detection of token balance overrides. Pre-configured
+    /// values in `token_overrides` take precedence.
     #[serde(default)]
-    pub cache: CacheConfig,
+    pub autodetect: bool,
 
-    /// How many successful price estimates for each order will cause a native
-    /// price estimation to return its result early.
-    ///
-    /// As this value increases, the fast estimator behavior will approximate
-    /// the behavior of the optimal estimator.
-    ///
-    /// It's possible to pass values greater than the total number of enabled
-    /// estimators but that will not have any further effect.
-    #[serde(default = "default_results_required")]
-    pub results_required: NonZeroUsize,
+    /// Controls how many storage slots get probed per storage entry point
+    /// for automatically detecting how to override the balances of a token.
+    #[serde(default = "default_probing_depth")]
+    pub probing_depth: u8,
+
+    /// Controls for how many tokens we store the result of the automatic
+    /// balance override detection before evicting less used entries.
+    #[serde(default = "default_cache_size")]
+    pub cache_size: usize,
 }
 
-impl Default for NativePriceConfig {
+impl Default for BalanceOverridesConfig {
     fn default() -> Self {
         Self {
-            approximation_tokens: Default::default(),
-            cache: Default::default(),
-            results_required: default_results_required(),
+            token_overrides: Default::default(),
+            autodetect: false,
+            probing_depth: default_probing_depth(),
+            cache_size: default_cache_size(),
         }
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+fn default_one_inch_url() -> Url {
+    Url::from_str("https://api.1inch.dev/").expect("url should be valid")
+}
+
+#[derive(Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
-pub struct CacheConfig {
-    /// How long cached native prices stay valid.
-    #[serde(default = "default_cache_max_age", with = "humantime_serde")]
-    pub max_age: Duration,
-
-    /// How many price estimation requests can be executed concurrently in the
-    /// maintenance task.
-    #[serde(default = "default_cache_concurrent_requests")]
-    pub concurrent_requests: NonZeroUsize,
+pub struct OneInchApi {
+    /// The base URL for the 1Inch API.
+    #[serde(default = "default_one_inch_url")]
+    pub url: Url,
+
+    /// The API key for the 1Inch API.
+    #[serde(default)]
+    pub api_key: String,
 }
 
-impl Default for CacheConfig {
-    fn default() -> Self {
+impl std::fmt::Debug for OneInchApi {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OneInchApi")
+            .field("url", &self.url)
+            .field("api_key", &"<REDACTED>")
+            .finish()
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl crate::test_util::TestDefault for OneInchApi {
+    fn test_default() -> Self {
         Self {
-            max_age: default_cache_max_age(),
-            concurrent_requests: default_cache_concurrent_requests(),
+            url: default_one_inch_url(),
+            api_key: "test-api-key".to_string(),
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use {super::*, crate::test_util::TestDefault};
 
     #[test]
-    fn deserialize_full() {
-        let toml = r#"
-            approximation-tokens = [
-                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
-            ]
-
-            [cache]
-            max-age = "5m"
-            concurrent-requests = 4
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.approximation_tokens.len(), 1);
-        assert_eq!(config.cache.max_age, Duration::from_secs(300));
-        assert_eq!(
-            config.cache.concurrent_requests,
-            NonZeroUsize::new(4).unwrap()
-        );
+    fn deserialize_defaults() {
+        let toml = "";
+        let config: PriceEstimation = toml::from_str(toml).unwrap();
+        assert!(config.tenderly.is_none());
+        assert!(config.price_estimation_rate_limiter.is_none());
+        assert!(config.amount_to_estimate_prices_with.is_none());
+        assert!(config.one_inch.is_none());
+        assert!(config.coin_gecko.is_none());
+        assert_eq!(config.quote_inaccuracy_limit, BigDecimal::from(1));
+        assert!(matches!(
+            config.quote_verification,
+            QuoteVerificationMode::Unverified
+        ));
+        assert_eq!(config.quote_timeout, Duration::from_secs(5));
+        assert!(!config.balance_overrides.autodetect);
+        assert_eq!(config.balance_overrides.probing_depth, 60);
+        assert_eq!(config.balance_overrides.cache_size, 1000);
+        assert!(config.tokens_without_verification.is_empty());
     }
 
     #[test]
-    fn cache_defaults() {
+    fn deserialize_full() {
         let toml = r#"
-            approximation-tokens = []
-            [cache]
+        quote-inaccuracy-limit = "0.01"
+        quote-verification = "enforce-when-possible"
+        quote-timeout = "10s"
+        tokens-without-verification = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
+        amount-to-estimate-prices-with = "1000000000000000000"
+
+        [price-estimation-rate-limiter]
+        back-off-growth-factor = 2.0
+        min-back-off = "1s"
+        max-back-off = "30s"
+
+        [tenderly]
+        user = "my-user"
+        project = "my-project"
+        api-key = "my-tenderly-key"
+
+        [one-inch]
+        api-key = "my-1inch-key"
+        url = "https://custom.1inch.dev/"
+
+        [coin-gecko]
+        api-key = "my-cg-key"
+        url = "https://pro-api.coingecko.com/api/v3/simple/token_price"
+
+        [coin-gecko.buffered]
+        debouncing-time = "500ms"
+        broadcast-channel-capacity = 100
+
+        [balance-overrides]
+        autodetect = true
+        probing-depth = 30
+        cache-size = 500
         "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.cache.max_age, Duration::from_mins(10));
+        let config: PriceEstimation = toml::from_str(toml).unwrap();
+
+        let tenderly = config.tenderly.as_ref().unwrap();
+        assert_eq!(tenderly.user, "my-user");
+        assert_eq!(tenderly.project, "my-project");
+        assert_eq!(tenderly.api_key, "my-tenderly-key");
+        assert!(config.price_estimation_rate_limiter.is_some());
         assert_eq!(
-            config.cache.concurrent_requests,
-            NonZeroUsize::new(1).unwrap()
+            config.amount_to_estimate_prices_with,
+            Some(alloy::primitives::U256::from(1_000_000_000_000_000_000u64))
         );
-    }
-
-    #[test]
-    fn multiple_approximation_tokens() {
-        let toml = r#"
-            approximation-tokens = [
-                ["0x0000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000002"],
-                ["0x0000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000004"],
-            ]
-            [cache]
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.approximation_tokens.len(), 2);
+        let one_inch = config.one_inch.as_ref().unwrap();
+        assert_eq!(one_inch.api_key, "my-1inch-key");
+        assert_eq!(one_inch.url.as_str(), "https://custom.1inch.dev/");
+        let coin_gecko = config.coin_gecko.as_ref().unwrap();
+        assert_eq!(coin_gecko.api_key, "my-cg-key");
         assert_eq!(
-            config.approximation_tokens[0].0,
-            Address::from_slice(&[0; 19].into_iter().chain([1]).collect::<Vec<_>>()),
+            coin_gecko.url.as_str(),
+            "https://pro-api.coingecko.com/api/v3/simple/token_price"
         );
+        let buffered = coin_gecko.buffered.as_ref().unwrap();
+        assert_eq!(buffered.debouncing_time, Duration::from_millis(500));
+        assert_eq!(buffered.broadcast_channel_capacity, 100);
+        assert_eq!(config.quote_inaccuracy_limit.to_string(), "0.01");
+        assert!(matches!(
+            config.quote_verification,
+            QuoteVerificationMode::EnforceWhenPossible
+        ));
+        assert_eq!(config.quote_timeout, Duration::from_secs(10));
+        assert!(config.balance_overrides.autodetect);
+        assert_eq!(config.balance_overrides.probing_depth, 30);
+        assert_eq!(config.balance_overrides.cache_size, 500);
+        assert_eq!(config.tokens_without_verification.len(), 1);
     }
 
     #[test]
     fn roundtrip_serialization() {
-        let config = NativePriceConfig {
-            approximation_tokens: vec![(Address::repeat_byte(1), Address::repeat_byte(2))],
-            cache: CacheConfig {
-                max_age: Duration::from_secs(120),
-                concurrent_requests: NonZeroUsize::new(8).unwrap(),
-            },
-            results_required: default_results_required(),
+        let config = PriceEstimation {
+            quote_timeout: Duration::from_secs(10),
+            quote_verification: QuoteVerificationMode::Prefer,
+            ..Default::default()
         };
-
         let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
+        let deserialized: PriceEstimation = toml::from_str(&serialized).unwrap();
+        assert_eq!(config.quote_timeout, deserialized.quote_timeout);
+        assert!(matches!(
+            deserialized.quote_verification,
+            QuoteVerificationMode::Prefer
+        ));
+    }
 
-        assert_eq!(
-            config.approximation_tokens,
-            deserialized.approximation_tokens,
-        );
-        assert_eq!(config.cache.max_age, deserialized.cache.max_age);
-        assert_eq!(
-            config.cache.concurrent_requests,
-            deserialized.cache.concurrent_requests,
-        );
+    #[test]
+    fn debug_redacts_secrets() {
+        let config = PriceEstimation {
+            one_inch: Some(OneInchApi {
+                api_key: "secret".to_string(),
+                ..TestDefault::test_default()
+            }),
+            coin_gecko: Some(CoinGeckoConfig {
+                api_key: "secret".to_string(),
+                ..TestDefault::test_default()
+            }),
+            tenderly: Some(TenderlyConfig {
+                api_key: "secret".to_string(),
+                ..TestDefault::test_default()
+            }),
+            ..Default::default()
+        };
+        let debug = format!("{config:?}");
+        assert!(!debug.contains("secret"));
+        assert!(debug.contains("<REDACTED>"));
     }
 }
diff --git a/crates/configs/src/rate_limit.rs b/crates/configs/src/rate_limit.rs
new file mode 100644
index 0000000000..96ac208b37
--- /dev/null
+++ b/crates/configs/src/rate_limit.rs
@@ -0,0 +1,73 @@
+use {
+    anyhow::ensure,
+    std::{
+        fmt::{Display, Formatter},
+        time::{Duration, Instant},
+    },
+};
+
+#[derive(Debug, Clone, serde::Deserialize)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case")]
+pub struct Strategy {
+    /// Point in time until which incoming requests are dropped due to
+    /// active rate limiting.
+    #[serde(skip, default = "Instant::now")]
+    pub drop_requests_until: Instant,
+    /// How many requests got rate limited in a row.
+    #[serde(skip)]
+    pub times_rate_limited: u64,
+    /// Multiplier applied to the back-off duration after each successive
+    /// rate-limited response. Must be >= 1.0.
+    pub back_off_growth_factor: f64,
+    /// Initial back-off duration used after the first rate-limited response.
+    #[serde(with = "humantime_serde")]
+    pub min_back_off: Duration,
+    /// Upper bound for the back-off duration regardless of growth factor.
+    #[serde(with = "humantime_serde")]
+    pub max_back_off: Duration,
+}
+
+impl Strategy {
+    pub fn try_new(
+        back_off_growth_factor: f64,
+        min_back_off: Duration,
+        max_back_off: Duration,
+    ) -> anyhow::Result<Self> {
+        ensure!(
+            back_off_growth_factor.is_normal(),
+            "back_off_growth_factor must be a normal f64"
+        );
+        ensure!(
+            back_off_growth_factor >= 1.0,
+            "back_off_growth_factor needs to be at least 1.0"
+        );
+        ensure!(
+            min_back_off <= max_back_off,
+            "min_back_off needs to be <= max_back_off"
+        );
+        Ok(Self {
+            drop_requests_until: Instant::now(),
+            times_rate_limited: 0,
+            back_off_growth_factor,
+            min_back_off,
+            max_back_off,
+        })
+    }
+}
+
+impl Default for Strategy {
+    fn default() -> Self {
+        Self::try_new(1.0, Duration::default(), Duration::default()).unwrap()
+    }
+}
+
+impl Display for Strategy {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "RateLimitingStrategy{{ min_back_off: {:?}, max_back_off: {:?}, growth_factor: {:?} }}",
+            self.min_back_off, self.max_back_off, self.back_off_growth_factor
+        )
+    }
+}
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index aa7c63a528..1e55e508a4 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -24,8 +24,8 @@ use {
             native_price::NativePriceConfig,
             run_loop::RunLoopConfig,
         },
+        native_price_estimators::{NativePriceEstimator, NativePriceEstimators},
         order_quoting::{ExternalSolver, OrderQuoting},
-        price_estimation::{NativePriceEstimator, NativePriceEstimators},
         test_util::TestDefault,
     },
     ethrpc::Web3,
@@ -136,7 +136,6 @@ impl<'a> Services<'a> {
 
     fn api_autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
         [
-            "--amount-to-estimate-prices-with=1000000000000000000".to_string(),
             "--block-stream-poll-interval=1s".to_string(),
             format!("--node-ws-url={NODE_WS_HOST}"),
             "--simulation-node-url=http://localhost:8545".to_string(),
@@ -150,7 +149,6 @@ impl<'a> Services<'a> {
 
     fn autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
         self.api_autopilot_arguments()
-            .chain(["--quote-timeout=10s".to_string()])
     }
 
     fn api_autopilot_solver_arguments(&self) -> impl Iterator<Item = String> + use<> {
@@ -257,17 +255,12 @@ impl<'a> Services<'a> {
         config: configs::orderbook::Configuration,
     ) {
         let (_config_file, config_arg) = config.to_cli_args();
-        let args: Vec<_> = [
-            "orderbook".to_string(),
-            "--quote-timeout=10s".to_string(),
-            "--quote-verification=enforce-when-possible".to_string(),
-            config_arg,
-        ]
-        .into_iter()
-        .chain(self.api_autopilot_solver_arguments())
-        .chain(self.api_autopilot_arguments())
-        .chain(extra_args)
-        .collect();
+        let args: Vec<_> = ["orderbook".to_string(), config_arg]
+            .into_iter()
+            .chain(self.api_autopilot_solver_arguments())
+            .chain(self.api_autopilot_arguments())
+            .chain(extra_args)
+            .collect();
         let args = ignore_overwritten_cli_params(args);
 
         let args = orderbook::arguments::Arguments::try_parse_from(args).unwrap();
@@ -385,8 +378,8 @@ impl<'a> Services<'a> {
             forwarder_contract: None,
         }];
 
-        let shared_native_price_config = configs::price_estimation::NativePriceConfig {
-            cache: configs::price_estimation::CacheConfig {
+        let shared_native_price_config = configs::native_price::NativePriceConfig {
+            cache: configs::native_price::CacheConfig {
                 max_age: Duration::from_secs(2),
                 ..Default::default()
             },
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 546e1c9ee5..42109ad0ad 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -152,11 +152,13 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
                     ExternalSolver::new("test_solver2", "http://localhost:11088/test_solver2"),
                 ]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::price_estimation::NativePriceEstimators::new(vec![vec![
-                        configs::price_estimation::NativePriceEstimator::forwarder(
-                            "http://0.0.0.0:9588".parse().unwrap(),
-                        ),
-                    ]]),
+                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                        vec![
+                            configs::native_price_estimators::NativePriceEstimator::forwarder(
+                                "http://0.0.0.0:9588".parse().unwrap(),
+                            ),
+                        ],
+                    ]),
                     ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
                 ..configs::orderbook::Configuration::test_default()
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 177b49b091..c861bbc346 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -516,12 +516,14 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
                     "http://localhost:11088/test_solver",
                 )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::price_estimation::NativePriceEstimators::new(vec![vec![
-                        configs::price_estimation::NativePriceEstimator::driver(
-                            "test_quoter".to_string(),
-                            "http://localhost:11088/test_solver".parse().unwrap(),
-                        ),
-                    ]]),
+                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                        vec![
+                            configs::native_price_estimators::NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                "http://localhost:11088/test_solver".parse().unwrap(),
+                            ),
+                        ],
+                    ]),
                     ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
                 ..configs::orderbook::Configuration::test_default()
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index d9b706267c..06eb9dadbf 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -247,15 +247,15 @@ async fn fallback_native_price_estimator(web3: Web3) {
                 )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
                     fallback_estimators: Some(
-                        configs::price_estimation::NativePriceEstimators::new(vec![vec![
-                            configs::price_estimation::NativePriceEstimator::driver(
+                        configs::native_price_estimators::NativePriceEstimators::new(vec![vec![
+                            configs::native_price_estimators::NativePriceEstimator::driver(
                                 "test_quoter".to_string(),
                                 "http://localhost:11088/test_solver".parse().unwrap(),
                             ),
                         ]]),
                     ),
-                    shared: configs::price_estimation::NativePriceConfig {
-                        cache: configs::price_estimation::CacheConfig {
+                    shared: configs::native_price::NativePriceConfig {
+                        cache: configs::native_price::CacheConfig {
                             max_age: std::time::Duration::from_secs(2),
                             ..Default::default()
                         },
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 1ffb976a61..6b35e93f51 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -3,9 +3,14 @@ use {
         primitives::{Address, U256, address, map::AddressMap},
         providers::Provider,
     },
-    balance_overrides::{BalanceOverrides, BalanceOverriding, Strategy},
+    balance_overrides::{BalanceOverrides, BalanceOverriding},
     bigdecimal::{BigDecimal, Zero},
-    configs::{autopilot::Configuration, test_util::TestDefault},
+    configs::{
+        autopilot::Configuration,
+        balance_overrides::Strategy,
+        price_estimation::BalanceOverridesConfig,
+        test_util::TestDefault,
+    },
     e2e::setup::*,
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::{
@@ -368,21 +373,37 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
 
     tracing::info!("Starting services.");
     let services = Services::new(&onchain).await;
-    services
-        .start_protocol_with_args(
-            ExtraServiceArgs {
-                api: vec![
-                    // The OpenZeppelin `ERC20Mintable` token uses a mapping in
-                    // the first (0'th) storage slot for balances.
-                    format!("--quote-token-balance-overrides={:?}@0", token.address()),
-                    // We don't configure the WETH token and instead rely on
-                    // auto-detection for balance overrides.
-                    "--quote-autodetect-token-balance-overrides=true".to_string(),
-                ],
+    // The OpenZeppelin `ERC20Mintable` token uses a mapping in
+    // the first (0'th) storage slot for balances.
+    let token_overrides: configs::balance_overrides::TokenConfiguration = toml::from_str(&format!(
+        r#"
+    [{:?}]
+    type = "SolidityMapping"
+    target_contract = "{:?}"
+    map_slot = "0x0"
+    "#,
+        token.address(),
+        token.address()
+    ))
+    .unwrap();
+    let orderbook_config = configs::orderbook::Configuration {
+        price_estimation: configs::price_estimation::PriceEstimation {
+            balance_overrides: BalanceOverridesConfig {
+                token_overrides,
+                // We don't configure the WETH token and instead rely on
+                // auto-detection for balance overrides.
+                autodetect: true,
                 ..Default::default()
             },
+            ..configs::orderbook::Configuration::test_default().price_estimation
+        },
+        ..configs::orderbook::Configuration::test_default()
+    };
+    services
+        .start_protocol_with_args(
+            ExtraServiceArgs::default(),
             Configuration::test("test_solver", solver.address()),
-            configs::orderbook::Configuration::test_default(),
+            orderbook_config,
             solver,
         )
         .await;
@@ -522,12 +543,18 @@ async fn usdt_quote_verification(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                api: vec!["--quote-autodetect-token-balance-overrides=true".to_string()],
-                ..Default::default()
-            },
+            ExtraServiceArgs::default(),
             Configuration::test("test_solver", solver.address()),
-            configs::orderbook::Configuration::test_default(),
+            configs::orderbook::Configuration {
+                price_estimation: configs::price_estimation::PriceEstimation {
+                    balance_overrides: BalanceOverridesConfig {
+                        autodetect: true,
+                        ..Default::default()
+                    },
+                    ..configs::orderbook::Configuration::test_default().price_estimation
+                },
+                ..configs::orderbook::Configuration::test_default()
+            },
             solver,
         )
         .await;
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 258b34173b..7dcd13b76e 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -325,21 +325,27 @@ async fn quote_timeout(web3: Web3) {
 
     services
         .start_api(
-            vec![format!("--quote-timeout={MAX_QUOTE_TIME_MS}ms")],
+            vec![],
             configs::orderbook::Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_quoter",
                     "http://localhost:11088/test_quoter",
                 )]),
                 native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::price_estimation::NativePriceEstimators::new(vec![vec![
-                        configs::price_estimation::NativePriceEstimator::driver(
-                            "test_quoter".to_string(),
-                            "http://localhost:11088/test_solver".parse().unwrap(),
-                        ),
-                    ]]),
+                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                        vec![
+                            configs::native_price_estimators::NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                "http://localhost:11088/test_solver".parse().unwrap(),
+                            ),
+                        ],
+                    ]),
                     ..configs::orderbook::native_price::NativePriceConfig::test_default()
                 },
+                price_estimation: configs::price_estimation::PriceEstimation {
+                    quote_timeout: Duration::from_millis(MAX_QUOTE_TIME_MS),
+                    ..configs::orderbook::Configuration::test_default().price_estimation
+                },
                 ..configs::orderbook::Configuration::test_default()
             },
         )
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index 38e6e644d1..cd3adb19c8 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -468,17 +468,21 @@ async fn single_replace_order_test(web3: Web3) {
     onchain.set_solver_allowed(solver.address(), false).await;
 
     let services = Services::new(&onchain).await;
+    // To avoid race conditions we have to start the protocol
+    // with the solver being banned. To allow us to still create
+    // orders we override the quote verification to prefer mode.
+    let orderbook_config = configs::orderbook::Configuration {
+        price_estimation: configs::price_estimation::PriceEstimation {
+            quote_verification: configs::price_estimation::QuoteVerificationMode::Prefer,
+            ..configs::orderbook::Configuration::test_default().price_estimation
+        },
+        ..configs::orderbook::Configuration::test_default()
+    };
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                // To avoid race conditions we have to start the protocol
-                // with the solver being banned. To allow us to still create
-                // orders we override the quote verification to be disabled.
-                api: vec!["--quote-verification=prefer".into()],
-                ..Default::default()
-            },
+            ExtraServiceArgs::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
-            configs::orderbook::Configuration::test_default(),
+            orderbook_config,
             solver.clone(),
         )
         .await;
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index fd49c96a34..e694c5efa8 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,16 +1,10 @@
-use {
-    price_estimation,
-    std::{net::SocketAddr, path::PathBuf},
-};
+use std::{net::SocketAddr, path::PathBuf};
 
 #[derive(clap::Parser)]
 pub struct Arguments {
     #[clap(flatten)]
     pub shared: shared::arguments::Arguments,
 
-    #[clap(flatten)]
-    pub price_estimation: price_estimation::Arguments,
-
     /// Path to the TOML configuration file.
     #[clap(long, env)]
     pub config: PathBuf,
@@ -23,13 +17,11 @@ impl std::fmt::Display for Arguments {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let Arguments {
             shared,
-            price_estimation,
             config,
             bind_address,
         } = self;
 
         write!(f, "{shared}")?;
-        write!(f, "{price_estimation}")?;
         writeln!(f, "config: {}", config.display())?;
         writeln!(f, "bind_address: {bind_address}")?;
 
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index de92028e1e..fb056c9f66 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -33,6 +33,7 @@ use {
     price_estimation::{
         PriceEstimating,
         QuoteVerificationMode,
+        config::price_estimation::BalanceOverridesConfigExt,
         factory::{self, PriceEstimatorFactory},
         native::{FallbackNativePriceEstimator, NativePriceEstimating},
         trade_verifier::code_fetching::CachedCodeFetcher,
@@ -124,7 +125,7 @@ pub async fn run(args: Arguments, config: Configuration) {
 
     let chain = Chain::try_from(chain_id).expect("incorrect chain ID");
 
-    let balance_overrider = args.price_estimation.balance_overrides.init(web3.clone());
+    let balance_overrider = config.price_estimation.balance_overrides.init(web3.clone());
     let signature_validator = signature_validator::validator(
         &web3,
         signature_validator::Contracts {
@@ -212,7 +213,7 @@ pub async fn run(args: Arguments, config: Configuration) {
     let code_fetcher = Arc::new(CachedCodeFetcher::new(Arc::new(web3.clone())));
 
     let mut price_estimator_factory = PriceEstimatorFactory::new(
-        &args.price_estimation,
+        &config.price_estimation,
         &config.native_price_estimation.shared,
         factory::Network {
             web3: web3.clone(),
@@ -281,7 +282,7 @@ pub async fn run(args: Arguments, config: Configuration) {
                 .price_estimation_drivers
                 .iter()
                 .map(
-                    |price_estimator_driver| configs::price_estimation::ExternalSolver {
+                    |price_estimator_driver| configs::native_price_estimators::ExternalSolver {
                         name: price_estimator_driver.name.clone(),
                         url: price_estimator_driver.url.clone(),
                     },
@@ -298,7 +299,7 @@ pub async fn run(args: Arguments, config: Configuration) {
                 .price_estimation_drivers
                 .iter()
                 .map(
-                    |price_estimator_driver| configs::price_estimation::ExternalSolver {
+                    |price_estimator_driver| configs::native_price_estimators::ExternalSolver {
                         name: price_estimator_driver.name.clone(),
                         url: price_estimator_driver.url.clone(),
                     },
@@ -339,10 +340,10 @@ pub async fn run(args: Arguments, config: Configuration) {
             },
             balance_fetcher.clone(),
             verification,
-            args.price_estimation.quote_timeout,
+            config.price_estimation.quote_timeout,
         ))
     };
-    let optimal_quoter = create_quoter(price_estimator, args.price_estimation.quote_verification);
+    let optimal_quoter = create_quoter(price_estimator, config.price_estimation.quote_verification);
     // Fast quoting is able to return early and if none of the produced quotes are
     // verifiable we are left with no quote at all. Since fast estimates don't
     // make any promises on correctness we can just skip quote verification for
@@ -421,7 +422,7 @@ pub async fn run(args: Arguments, config: Configuration) {
             let _ = shutdown_receiver.await;
         },
         native_price_estimator,
-        args.price_estimation.quote_timeout,
+        config.price_estimation.quote_timeout,
     );
 
     let mut metrics_address = args.bind_address;
diff --git a/crates/price-estimation/src/config/mod.rs b/crates/price-estimation/src/config/mod.rs
new file mode 100644
index 0000000000..cfbcaeb995
--- /dev/null
+++ b/crates/price-estimation/src/config/mod.rs
@@ -0,0 +1,2 @@
+pub mod native_price;
+pub mod price_estimation;
diff --git a/crates/price-estimation/src/config/native_price.rs b/crates/price-estimation/src/config/native_price.rs
new file mode 100644
index 0000000000..ff2b425281
--- /dev/null
+++ b/crates/price-estimation/src/config/native_price.rs
@@ -0,0 +1 @@
+pub use configs::native_price::{CacheConfig, NativePriceConfig};
diff --git a/crates/price-estimation/src/config/price_estimation.rs b/crates/price-estimation/src/config/price_estimation.rs
new file mode 100644
index 0000000000..b7e4ed61e0
--- /dev/null
+++ b/crates/price-estimation/src/config/price_estimation.rs
@@ -0,0 +1,45 @@
+use {
+    crate::trade_verifier::tenderly_api::{Instrumented, TenderlyApi, TenderlyHttpApi},
+    anyhow::Result,
+    balance_overrides::BalanceOverriding,
+    configs::price_estimation::{BalanceOverridesConfig, TenderlyConfig},
+    http_client::HttpClientFactory,
+    std::sync::Arc,
+};
+
+pub trait BalanceOverridesConfigExt {
+    fn init(&self, web3: ethrpc::Web3) -> Arc<dyn BalanceOverriding>;
+}
+
+impl BalanceOverridesConfigExt for BalanceOverridesConfig {
+    fn init(&self, web3: ethrpc::Web3) -> Arc<dyn BalanceOverriding> {
+        Arc::new(balance_overrides::BalanceOverrides {
+            hardcoded: self.token_overrides.inner().clone(),
+            detector: self.autodetect.then(|| {
+                (
+                    balance_overrides::detector::Detector::new(web3, self.probing_depth),
+                    std::sync::Mutex::new(cached::SizedCache::with_size(self.cache_size)),
+                )
+            }),
+        })
+    }
+}
+
+pub trait TenderlyConfigExt {
+    fn get_api_instance(
+        &self,
+        http_factory: &HttpClientFactory,
+        name: String,
+    ) -> Result<Arc<dyn TenderlyApi>>;
+}
+
+impl TenderlyConfigExt for TenderlyConfig {
+    fn get_api_instance(
+        &self,
+        http_factory: &HttpClientFactory,
+        name: String,
+    ) -> Result<Arc<dyn TenderlyApi>> {
+        TenderlyHttpApi::new(http_factory, &self.user, &self.project, &self.api_key)
+            .map(|inner| Arc::new(Instrumented { inner, name }) as _)
+    }
+}
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index d548d88d15..1603c5e744 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -1,6 +1,6 @@
 use {
     super::{
-        Arguments,
+        NativePriceEstimator as NativePriceEstimatorSource,
         PriceEstimating,
         competition::CompetitionEstimator,
         external::ExternalPriceEstimator,
@@ -11,18 +11,19 @@ use {
         trade_verifier::{TradeVerifier, TradeVerifying},
     },
     crate::{
+        ExternalSolver,
         buffered::{self, BufferedRequest, NativePriceBatchFetching},
         competition::PriceRanking,
+        config::{
+            native_price::NativePriceConfig,
+            price_estimation::{BalanceOverridesConfigExt, TenderlyConfigExt},
+        },
         trade_verifier::{code_fetching::CachedCodeFetcher, tenderly_api::TenderlyCodeSimulator},
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
     bad_tokens::list_based::DenyListedTokens,
-    configs::price_estimation::{
-        ExternalSolver,
-        NativePriceConfig,
-        NativePriceEstimator as NativePriceEstimatorSource,
-    },
+    configs::price_estimation::PriceEstimation,
     contracts::alloy::WETH9,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     gas_price_estimation::GasPriceEstimating,
@@ -62,7 +63,7 @@ pub struct Components {
 
 /// A factory for initializing shared price estimators.
 pub struct PriceEstimatorFactory<'a> {
-    args: &'a Arguments,
+    args: &'a PriceEstimation,
     config: &'a NativePriceConfig,
     network: Network,
     components: Components,
@@ -72,7 +73,7 @@ pub struct PriceEstimatorFactory<'a> {
 
 impl<'a> PriceEstimatorFactory<'a> {
     pub async fn new(
-        args: &'a Arguments,
+        args: &'a PriceEstimation,
         config: &'a NativePriceConfig,
         network: Network,
         components: Components,
@@ -88,7 +89,7 @@ impl<'a> PriceEstimatorFactory<'a> {
     }
 
     async fn trade_verifier(
-        args: &'a Arguments,
+        args: &'a PriceEstimation,
         network: &Network,
         components: &Components,
     ) -> Result<Option<Arc<dyn TradeVerifying>>> {
@@ -97,11 +98,15 @@ impl<'a> PriceEstimatorFactory<'a> {
         };
         let web3 = web3.labeled("simulator");
 
-        let tenderly = args
-            .tenderly
-            .get_api_instance(&components.http_factory, "price_estimation".to_owned())
-            .unwrap()
-            .map(|t| Arc::new(TenderlyCodeSimulator::new(t, network.chain.id())));
+        let tenderly = if let Some(tenderly) = &args.tenderly {
+            tenderly
+                .get_api_instance(&components.http_factory, "price_estimation".to_owned())
+                .map(|tenderly| Arc::new(TenderlyCodeSimulator::new(tenderly, network.chain.id())))
+                .inspect_err(|err| tracing::error!(%err, "failed to setup tenderly api"))
+                .ok()
+        } else {
+            None
+        };
 
         let balance_overrides = args.balance_overrides.init(web3.clone());
 
@@ -205,14 +210,19 @@ impl<'a> PriceEstimatorFactory<'a> {
                 ))
             }
             NativePriceEstimatorSource::OneInchSpotPriceApi => {
+                let one_inch = self
+                    .args
+                    .one_inch
+                    .as_ref()
+                    .context("one-inch config must be set when OneInchSpotPriceApi is used")?;
                 let name = "OneInchSpotPriceApi".to_string();
                 Ok((
                     name.clone(),
                     Arc::new(InstrumentedPriceEstimator::new(
                         native::OneInch::new(
                             self.components.http_factory.create(),
-                            self.args.one_inch_url.clone(),
-                            self.args.one_inch_api_key.clone(),
+                            one_inch.url.clone(),
+                            Some(one_inch.api_key.clone()),
                             self.network.chain.id(),
                             self.network.block_stream.clone(),
                             self.components.tokens.clone(),
@@ -222,17 +232,17 @@ impl<'a> PriceEstimatorFactory<'a> {
                 ))
             }
             NativePriceEstimatorSource::CoinGecko => {
-                anyhow::ensure!(
-                    self.args.coin_gecko.coin_gecko_api_key.is_some(),
-                    "coin_gecko_api_key must be set when CoinGecko is used as native price \
-                     estimator"
-                );
+                let coin_gecko_config = self
+                    .args
+                    .coin_gecko
+                    .as_ref()
+                    .context("coin-gecko config must be set when CoinGecko is used")?;
 
                 let name = "CoinGecko".to_string();
                 let coin_gecko = native::CoinGecko::new(
                     self.components.http_factory.create(),
-                    self.args.coin_gecko.coin_gecko_url.clone(),
-                    self.args.coin_gecko.coin_gecko_api_key.clone(),
+                    coin_gecko_config.url.clone(),
+                    Some(coin_gecko_config.api_key.clone()),
                     &self.network.chain,
                     *weth.address(),
                     self.components.tokens.clone(),
@@ -240,9 +250,7 @@ impl<'a> PriceEstimatorFactory<'a> {
                 .await?;
 
                 let coin_gecko: Arc<dyn NativePriceEstimating> =
-                    if let Some(coin_gecko_buffered_configuration) =
-                        &self.args.coin_gecko.coin_gecko_buffered
-                    {
+                    if let Some(buffered_config) = &coin_gecko_config.buffered {
                         let configuration = buffered::Configuration {
                             max_concurrent_requests: Some(
                                 coin_gecko
@@ -250,13 +258,9 @@ impl<'a> PriceEstimatorFactory<'a> {
                                     .try_into()
                                     .context("invalid CoinGecko max batch size")?,
                             ),
-                            debouncing_time: coin_gecko_buffered_configuration
-                                .coin_gecko_debouncing_time
-                                .unwrap(),
+                            debouncing_time: buffered_config.debouncing_time,
                             result_ready_timeout: self.args.quote_timeout,
-                            broadcast_channel_capacity: coin_gecko_buffered_configuration
-                                .coin_gecko_broadcast_channel_capacity
-                                .unwrap(),
+                            broadcast_channel_capacity: buffered_config.broadcast_channel_capacity,
                         };
 
                         Arc::new(InstrumentedPriceEstimator::new(
diff --git a/crates/price-estimation/src/lib.rs b/crates/price-estimation/src/lib.rs
index d87ee49a62..992e945153 100644
--- a/crates/price-estimation/src/lib.rs
+++ b/crates/price-estimation/src/lib.rs
@@ -1,23 +1,19 @@
+pub use configs::{
+    native_price_estimators::{ExternalSolver, NativePriceEstimator, NativePriceEstimators},
+    price_estimation::QuoteVerificationMode,
+};
 use {
-    crate::{
-        trade_finding::{Interaction, QuoteExecution},
-        trade_verifier::tenderly_api,
-        utils::{display_option, display_secret_option},
-    },
+    crate::trade_finding::{Interaction, QuoteExecution},
     alloy::primitives::{Address, U256},
     anyhow::Result,
-    bigdecimal::BigDecimal,
     futures::future::BoxFuture,
     model::order::{BuyTokenDestination, OrderKind, SellTokenSource},
     number::nonzero::NonZeroU256,
-    rate_limit::{RateLimiter, Strategy},
-    reqwest::Url,
+    rate_limit::RateLimiter,
     serde::{Deserialize, Serialize},
     std::{
         cmp::{Eq, PartialEq},
-        fmt::{self, Display, Formatter},
         future::Future,
-        hash::Hash,
         sync::Arc,
         time::{Duration, Instant},
     },
@@ -26,6 +22,7 @@ use {
 
 mod buffered;
 pub mod competition;
+pub mod config;
 pub mod external;
 pub mod factory;
 pub mod gas;
@@ -37,210 +34,6 @@ pub mod trade_finding;
 pub mod trade_verifier;
 pub mod utils;
 
-/// Shared price estimation configuration arguments.
-#[derive(clap::Parser)]
-#[group(skip)]
-pub struct Arguments {
-    #[clap(flatten)]
-    pub tenderly: tenderly_api::Arguments,
-
-    /// Configures the back off strategy for price estimators when requests take
-    /// too long. Requests issued while back off is active get dropped
-    /// entirely. Needs to be passed as
-    /// "<back_off_growth_factor>,<min_back_off>,<max_back_off>".
-    /// back_off_growth_factor: f64 >= 1.0
-    /// min_back_off: Duration
-    /// max_back_off: Duration
-    #[clap(long, env, verbatim_doc_comment)]
-    pub price_estimation_rate_limiter: Option<Strategy>,
-
-    /// The amount in native tokens atoms to use for price estimation. Should be
-    /// reasonably large so that small pools do not influence the prices. If
-    /// not set a reasonable default is used based on network id.
-    #[clap(long, env)]
-    pub amount_to_estimate_prices_with: Option<alloy::primitives::U256>,
-
-    /// The API key for the 1Inch API.
-    #[clap(long, env)]
-    pub one_inch_api_key: Option<String>,
-
-    /// The base URL for the 1Inch API.
-    #[clap(long, env, default_value = "https://api.1inch.dev/")]
-    pub one_inch_url: Url,
-
-    /// The CoinGecko native price configuration
-    #[clap(flatten)]
-    pub coin_gecko: CoinGecko,
-
-    /// How inaccurate a quote must be before it gets discarded provided as a
-    /// factor.
-    /// E.g. a value of `0.01` means at most 1 percent of the sell or buy tokens
-    /// can be paid out of the settlement contract buffers.
-    #[clap(long, env, default_value = "1.")]
-    pub quote_inaccuracy_limit: BigDecimal,
-
-    /// How strict quote verification should be.
-    #[clap(
-        long,
-        env,
-        default_value = "unverified",
-        value_enum,
-        verbatim_doc_comment
-    )]
-    pub quote_verification: QuoteVerificationMode,
-
-    /// Default timeout for quote requests.
-    #[clap(
-        long,
-        env,
-        default_value = "5s",
-        value_parser = humantime::parse_duration,
-    )]
-    pub quote_timeout: Duration,
-
-    #[clap(flatten)]
-    pub balance_overrides: balance_overrides::Arguments,
-
-    /// Tokens for which quote verification should not be attempted. This is an
-    /// escape hatch when there is a very bad but verifiable liquidity source
-    /// that would win against a very good but unverifiable liquidity source
-    /// (e.g. private liquidity that exists but can't be verified).
-    #[clap(long, env, value_delimiter = ',')]
-    pub tokens_without_verification: Vec<Address>,
-
-    /// How much gas a single tx may consume at most. Any quote using more than
-    /// this will fail during the verification.
-    /// Defaults to the maximum transaction gas limit of ethereum introduced
-    /// in the Fusaka hardfork.
-    #[clap(long, env, default_value_t = 16777215)]
-    pub max_gas_per_tx: u64,
-}
-
-#[derive(clap::Parser)]
-pub struct CoinGecko {
-    /// The API key for the CoinGecko API.
-    #[clap(long, env)]
-    pub coin_gecko_api_key: Option<String>,
-
-    /// The base URL for the CoinGecko API.
-    #[clap(
-        long,
-        env,
-        default_value = "https://api.coingecko.com/api/v3/simple/token_price"
-    )]
-    pub coin_gecko_url: Url,
-
-    #[clap(flatten)]
-    pub coin_gecko_buffered: Option<CoinGeckoBuffered>,
-}
-
-#[derive(clap::Parser)]
-#[clap(group(
-    clap::ArgGroup::new("coin_gecko_buffered")
-    .requires_all(&[
-        "coin_gecko_debouncing_time",
-        "coin_gecko_broadcast_channel_capacity"
-    ])
-    .multiple(true)
-    .required(false),
-))]
-pub struct CoinGeckoBuffered {
-    /// An additional minimum delay to wait for collecting CoinGecko requests.
-    ///
-    /// The delay to start counting after receiving the first request.
-    #[clap(long, env, value_parser = humantime::parse_duration, group = "coin_gecko_buffered")]
-    pub coin_gecko_debouncing_time: Option<Duration>,
-
-    /// Maximum capacity of the broadcast channel to store the CoinGecko native
-    /// prices results
-    #[clap(long, env, group = "coin_gecko_buffered")]
-    pub coin_gecko_broadcast_channel_capacity: Option<usize>,
-}
-
-/// Controls which level of quote verification gets applied.
-#[derive(Copy, Clone, Debug, clap::ValueEnum)]
-#[clap(rename_all = "kebab-case")]
-pub enum QuoteVerificationMode {
-    /// Quotes do not get verified.
-    Unverified,
-    /// Quotes get verified whenever possible and verified
-    /// quotes are preferred over unverified ones.
-    Prefer,
-    /// Quotes get discarded if they can't be verified.
-    /// Some scenarios like missing sell token balance are exempt.
-    EnforceWhenPossible,
-}
-
-impl Display for Arguments {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let Self {
-            tenderly,
-            price_estimation_rate_limiter,
-            amount_to_estimate_prices_with,
-            one_inch_api_key,
-            one_inch_url,
-            coin_gecko,
-            quote_inaccuracy_limit,
-            quote_verification,
-            quote_timeout,
-            balance_overrides,
-            tokens_without_verification,
-            max_gas_per_tx,
-        } = self;
-
-        write!(f, "{tenderly}")?;
-        display_option(
-            f,
-            "price_estimation_rate_limites",
-            price_estimation_rate_limiter,
-        )?;
-        display_option(
-            f,
-            "amount_to_estimate_prices_with: {}",
-            amount_to_estimate_prices_with,
-        )?;
-        display_secret_option(
-            f,
-            "one_inch_spot_price_api_key: {:?}",
-            one_inch_api_key.as_ref(),
-        )?;
-        writeln!(f, "one_inch_spot_price_api_url: {one_inch_url}")?;
-        display_secret_option(
-            f,
-            "coin_gecko_api_key: {:?}",
-            coin_gecko.coin_gecko_api_key.as_ref(),
-        )?;
-        writeln!(f, "coin_gecko_api_url: {}", coin_gecko.coin_gecko_url)?;
-        writeln!(f, "coin_gecko_api_url: {}", coin_gecko.coin_gecko_url)?;
-        writeln!(
-            f,
-            "coin_gecko_debouncing_time: {:?}",
-            coin_gecko
-                .coin_gecko_buffered
-                .as_ref()
-                .map(|coin_gecko_buffered| coin_gecko_buffered.coin_gecko_debouncing_time),
-        )?;
-        writeln!(
-            f,
-            "coin_gecko_broadcast_channel_capacity: {:?}",
-            coin_gecko.coin_gecko_buffered.as_ref().map(
-                |coin_gecko_buffered| coin_gecko_buffered.coin_gecko_broadcast_channel_capacity
-            ),
-        )?;
-        writeln!(f, "quote_inaccuracy_limit: {quote_inaccuracy_limit}")?;
-        writeln!(f, "quote_verification: {quote_verification:?}")?;
-        writeln!(f, "quote_timeout: {quote_timeout:?}")?;
-        write!(f, "{balance_overrides}")?;
-        writeln!(
-            f,
-            "tokens_without_verification: {tokens_without_verification:?}"
-        )?;
-        writeln!(f, "max_gas_per_tx: {max_gas_per_tx}")?;
-
-        Ok(())
-    }
-}
-
 #[derive(Error, Debug)]
 pub enum PriceEstimationError {
     #[error("token {token:?} is not supported: {reason:}")]
@@ -420,46 +213,7 @@ pub mod mocks {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        clap::Parser,
-        configs::price_estimation::{ExternalSolver, NativePriceEstimator, NativePriceEstimators},
-        std::str::FromStr,
-    };
-
-    #[test]
-    fn string_repr_round_trip_native_price_estimators() {
-        // We use NativePriceEstimators as one of the types used in an Arguments object
-        // that derives clap::Parser. Clap parsing of an argument using
-        // default_value_t requires that std::fmt::Display roundtrips correctly with the
-        // Arg::value_parser or #[arg(value_enum)]:
-        // https://docs.rs/clap/latest/clap/_derive/index.html#arg-attributes
-
-        let parsed = |arg: &str| NativePriceEstimators::from_str(arg);
-        let stringified = |arg: &NativePriceEstimators| format!("{arg}");
-
-        for repr in [
-            &NativePriceEstimator::Driver(
-                ExternalSolver::from_str(
-                    "baseline|http://localhost:1234/|0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-                )
-                .unwrap(),
-            )
-            .to_string(),
-            &NativePriceEstimator::OneInchSpotPriceApi.to_string(),
-            &NativePriceEstimator::Forwarder {
-                url: "http://localhost:9588".parse().unwrap(),
-            }
-            .to_string(),
-            "Driver|one|http://localhost:1111/,Driver|two|http://localhost:2222/;Driver|three|http://localhost:3333/,Driver|four|http://localhost:4444/",
-            &format!(
-                "Driver|one|http://localhost:1111/,Driver|two|http://localhost:2222/;{},Driver|four|http://localhost:4444/",
-                NativePriceEstimator::OneInchSpotPriceApi
-            ),
-        ] {
-            assert_eq!(stringified(&parsed(repr).unwrap()), repr);
-        }
-    }
+    use super::*;
 
     #[test]
     fn toml_deserialize_estimators_empty() {
@@ -530,62 +284,4 @@ mod tests {
         let estimators = NativePriceEstimators::default();
         assert!(estimators.as_slice().is_empty());
     }
-
-    #[test]
-    fn enable_coin_gecko_buffered() {
-        let args = vec![
-            "test", // Program name
-            "--coin-gecko-api-key",
-            "someapikey",
-            "--coin-gecko-url",
-            "https://api.coingecko.com/api/v3/simple/token_price",
-            "--coin-gecko-debouncing-time",
-            "300ms",
-            "--coin-gecko-broadcast-channel-capacity",
-            "50",
-        ];
-
-        let coin_gecko = CoinGecko::parse_from(args);
-
-        assert!(coin_gecko.coin_gecko_buffered.is_some());
-
-        let buffered = coin_gecko.coin_gecko_buffered.unwrap();
-        assert_eq!(
-            buffered.coin_gecko_debouncing_time.unwrap(),
-            Duration::from_millis(300)
-        );
-        assert_eq!(buffered.coin_gecko_broadcast_channel_capacity.unwrap(), 50);
-    }
-
-    #[test]
-    fn test_without_buffered_present() {
-        let args = vec![
-            "test", // Program name
-            "--coin-gecko-api-key",
-            "someapikey",
-            "--coin-gecko-url",
-            "https://api.coingecko.com/api/v3/simple/token_price",
-        ];
-
-        let coin_gecko = CoinGecko::parse_from(args);
-
-        assert!(coin_gecko.coin_gecko_buffered.is_none());
-    }
-
-    #[test]
-    fn test_invalid_partial_buffered_present() {
-        let args = vec![
-            "test", // Program name
-            "--coin-gecko-api-key",
-            "someapikey",
-            "--coin-gecko-url",
-            "https://api.coingecko.com/api/v3/simple/token_price",
-            "--coin-gecko-debouncing-time",
-            "300ms",
-        ];
-
-        let result = CoinGecko::try_parse_from(args);
-
-        assert!(result.is_err());
-    }
 }
diff --git a/crates/price-estimation/src/trade_verifier/tenderly_api.rs b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
index b05025da43..410c5ca7e8 100644
--- a/crates/price-estimation/src/trade_verifier/tenderly_api.rs
+++ b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
@@ -130,8 +130,8 @@ impl TenderlyApi for TenderlyHttpApi {
 
 /// Instrumented Tenderly HTTP API.
 pub struct Instrumented {
-    inner: TenderlyHttpApi,
-    name: String,
+    pub(crate) inner: TenderlyHttpApi,
+    pub(crate) name: String,
 }
 
 #[async_trait::async_trait]
diff --git a/crates/rate-limit/Cargo.toml b/crates/rate-limit/Cargo.toml
index bea4f42014..ac59c53469 100644
--- a/crates/rate-limit/Cargo.toml
+++ b/crates/rate-limit/Cargo.toml
@@ -7,15 +7,23 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 anyhow = { workspace = true }
+configs = { workspace = true }
 futures = { workspace = true }
-humantime = { workspace = true }
+humantime-serde = { workspace = true }
 observe = { workspace = true }
 prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
+serde = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = [] }
 tracing = { workspace = true }
 
+[dev-dependencies]
+serde_json = { workspace = true }
+
+[features]
+test-util = []
+
 [lints]
 workspace = true
diff --git a/crates/rate-limit/src/lib.rs b/crates/rate-limit/src/lib.rs
index 8534f9e46e..6171bdcac1 100644
--- a/crates/rate-limit/src/lib.rs
+++ b/crates/rate-limit/src/lib.rs
@@ -1,9 +1,8 @@
 use {
-    anyhow::{Context, Result, ensure},
+    anyhow::Result,
+    configs::rate_limit::Strategy,
     std::{
-        fmt::{Display, Formatter},
         future::Future,
-        str::FromStr,
         sync::{Arc, Mutex, MutexGuard},
         time::{Duration, Instant},
     },
@@ -29,84 +28,25 @@ fn metrics() -> &'static Metrics {
         .expect("unexpected error getting metrics instance")
 }
 
-#[derive(Debug, Clone)]
-pub struct Strategy {
-    drop_requests_until: Instant,
-    /// How many requests got rate limited in a row.
-    times_rate_limited: u64,
-    back_off_growth_factor: f64,
-    min_back_off: Duration,
-    max_back_off: Duration,
-}
+trait StrategyExt {
+    /// Resets back off and stops rate limiting requests.
+    fn response_ok(&mut self, name: &str);
 
-impl Default for Strategy {
-    fn default() -> Self {
-        Self::try_new(1.0, Duration::default(), Duration::default()).unwrap()
-    }
-}
+    /// Calculates back off based on how often we got rate limited in a row.
+    fn get_current_back_off(&self) -> Duration;
 
-impl Display for Strategy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "RateLimitingStrategy{{ min_back_off: {:?}, max_back_off: {:?}, growth_factor: {:?} }}",
-            self.min_back_off, self.max_back_off, self.back_off_growth_factor
-        )
-    }
-}
+    /// Returns updated back off if no other thread increased it in the mean
+    /// time.
+    fn response_rate_limited(&mut self, previous_rate_limits: u64, name: &str) -> Option<Duration>;
 
-impl FromStr for Strategy {
-    type Err = anyhow::Error;
-
-    fn from_str(config: &str) -> Result<Self> {
-        let mut parts = config.split(',');
-        let back_off_growth_factor = parts.next().context("missing back_off_growth_factor")?;
-        let min_back_off = parts.next().context("missing min_back_off")?;
-        let max_back_off = parts.next().context("missing max_back_off")?;
-        ensure!(
-            parts.next().is_none(),
-            "extraneous rate limiting parameters"
-        );
-        let back_off_growth_factor: f64 = back_off_growth_factor
-            .parse()
-            .context("parsing back_off_growth_factor")?;
-        let min_back_off =
-            humantime::parse_duration(min_back_off).context("parsing min_back_off")?;
-        let max_back_off =
-            humantime::parse_duration(max_back_off).context("parsing max_back_off")?;
-        Self::try_new(back_off_growth_factor, min_back_off, max_back_off)
-    }
+    /// Returns number of times we got rate limited in a row if we are currently
+    /// allowing requests.
+    fn times_rate_limited(&self, now: Instant, name: &str) -> Option<u64>;
 }
 
-impl Strategy {
-    pub fn try_new(
-        back_off_growth_factor: f64,
-        min_back_off: Duration,
-        max_back_off: Duration,
-    ) -> Result<Self> {
-        ensure!(
-            back_off_growth_factor.is_normal(),
-            "back_off_growth_factor must be a normal f64"
-        );
-        ensure!(
-            back_off_growth_factor >= 1.0,
-            "back_off_growth_factor needs to be at least 1.0"
-        );
-        ensure!(
-            min_back_off <= max_back_off,
-            "min_back_off needs to be <= max_back_off"
-        );
-        Ok(Self {
-            drop_requests_until: Instant::now(),
-            times_rate_limited: 0,
-            back_off_growth_factor,
-            min_back_off,
-            max_back_off,
-        })
-    }
-
+impl StrategyExt for Strategy {
     /// Resets back off and stops rate limiting requests.
-    pub fn response_ok(&mut self, name: &str) {
+    fn response_ok(&mut self, name: &str) {
         metrics()
             .successful_requests
             .with_label_values(&[name])
@@ -129,11 +69,7 @@ impl Strategy {
 
     /// Returns updated back off if no other thread increased it in the mean
     /// time.
-    pub fn response_rate_limited(
-        &mut self,
-        previous_rate_limits: u64,
-        name: &str,
-    ) -> Option<Duration> {
+    fn response_rate_limited(&mut self, previous_rate_limits: u64, name: &str) -> Option<Duration> {
         metrics()
             .rate_limited_requests
             .with_label_values(&[name])
@@ -151,7 +87,7 @@ impl Strategy {
 
     /// Returns number of times we got rate limited in a row if we are currently
     /// allowing requests.
-    pub fn times_rate_limited(&self, now: Instant, name: &str) -> Option<u64> {
+    fn times_rate_limited(&self, now: Instant, name: &str) -> Option<u64> {
         if self.drop_requests_until > now {
             metrics().requests_dropped.with_label_values(&[name]).inc();
             return None;
@@ -286,6 +222,20 @@ pub mod back_off {
 mod tests {
     use {super::*, futures::FutureExt, std::ops::Add, tokio::time::sleep};
 
+    #[test]
+    fn serde_roundtrip() {
+        let strategy =
+            Strategy::try_new(2.0, Duration::from_millis(100), Duration::from_secs(30)).unwrap();
+        let serialized = serde_json::to_string(&strategy).unwrap();
+        let deserialized: Strategy = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(
+            strategy.back_off_growth_factor,
+            deserialized.back_off_growth_factor,
+        );
+        assert_eq!(strategy.min_back_off, deserialized.min_back_off);
+        assert_eq!(strategy.max_back_off, deserialized.max_back_off);
+    }
+
     #[test]
     fn current_back_off_does_not_panic() {
         let max = Duration::from_secs(60);
diff --git a/crates/solvers/Cargo.toml b/crates/solvers/Cargo.toml
index cef7bc412d..513a8fb8e2 100644
--- a/crates/solvers/Cargo.toml
+++ b/crates/solvers/Cargo.toml
@@ -21,6 +21,7 @@ bytes-hex = { workspace = true }
 chain = { workspace = true }
 chrono = { workspace = true, default-features = false, features = ["serde"] }
 clap = { workspace = true, features = ["derive", "env"] }
+configs = { workspace = true }
 const-hex = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
diff --git a/crates/solvers/src/infra/config/dex/file.rs b/crates/solvers/src/infra/config/dex/file.rs
index e36748cd66..7e9bbb1dce 100644
--- a/crates/solvers/src/infra/config/dex/file.rs
+++ b/crates/solvers/src/infra/config/dex/file.rs
@@ -194,7 +194,7 @@ pub async fn load<T: DeserializeOwned>(path: &Path) -> (super::Config, T) {
         .expect("invalid minimum surplus limits"),
         concurrent_requests: config.concurrent_requests,
         smallest_partial_fill: eth::Ether(config.smallest_partial_fill),
-        rate_limiting_strategy: rate_limit::Strategy::try_new(
+        rate_limiting_strategy: configs::rate_limit::Strategy::try_new(
             config.back_off_growth_factor,
             config.min_back_off,
             config.max_back_off,
diff --git a/crates/solvers/src/infra/config/dex/mod.rs b/crates/solvers/src/infra/config/dex/mod.rs
index d8e619b9aa..be5ad1b97c 100644
--- a/crates/solvers/src/infra/config/dex/mod.rs
+++ b/crates/solvers/src/infra/config/dex/mod.rs
@@ -26,7 +26,7 @@ pub struct Config {
     pub minimum_surplus: MinimumSurplusLimits,
     pub concurrent_requests: NonZeroUsize,
     pub smallest_partial_fill: eth::Ether,
-    pub rate_limiting_strategy: rate_limit::Strategy,
+    pub rate_limiting_strategy: configs::rate_limit::Strategy,
     pub gas_offset: eth::Gas,
     pub block_stream: Option<CurrentBlockWatcher>,
     pub internalize_interactions: bool,

From 0441cea0dcdfc582648239005b34571a2766d8b4 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Mon, 16 Mar 2026 16:36:24 +0100
Subject: [PATCH 153/219] Eth domain types driver (#4263)

# Description
Based on #4260 continues the effort of unifying eth domain types in
driver.

# Changes
- Use eth-domain-types in driver
- Hides the internals of ContractAddress and TokenAddress and derives
Deref on them.

## How to test
E2E tests
---
 Cargo.lock                                    |   2 +
 crates/driver/Cargo.toml                      |   1 +
 .../src/boundary/liquidity/balancer/v2/mod.rs |  15 +-
 .../boundary/liquidity/balancer/v2/stable.rs  |   5 +-
 .../liquidity/balancer/v2/weighted.rs         |   5 +-
 crates/driver/src/boundary/liquidity/mod.rs   |   5 +-
 .../src/boundary/liquidity/uniswap/v2.rs      |  15 +-
 .../src/boundary/liquidity/uniswap/v3.rs      |  11 +-
 crates/driver/src/domain/blockchain.rs        |  83 ++++
 .../driver/src/domain/competition/auction.rs  |   6 +-
 crates/driver/src/domain/competition/mod.rs   |  10 +-
 .../src/domain/competition/order/mod.rs       |   7 +-
 .../src/domain/competition/order/signature.rs |   2 +-
 .../src/domain/competition/pre_processing.rs  |  10 +-
 .../risk_detector/bad_tokens/cache.rs         |   3 +-
 .../risk_detector/bad_tokens/simulation.rs    |   2 +-
 .../domain/competition/risk_detector/mod.rs   |   6 +-
 .../domain/competition/solution/encoding.rs   |  28 +-
 .../src/domain/competition/solution/fee.rs    |  12 +-
 .../competition/solution/interaction.rs       |   3 +-
 .../src/domain/competition/solution/mod.rs    |  26 +-
 .../domain/competition/solution/scoring.rs    |  18 +-
 .../domain/competition/solution/settlement.rs |   7 +-
 .../domain/competition/solution/slippage.rs   |   4 +-
 .../src/domain/competition/solution/trade.rs  |  12 +-
 .../driver/src/domain/competition/sorting.rs  |   6 +-
 crates/driver/src/domain/cow_amm.rs           |   2 +-
 crates/driver/src/domain/eth/allowance.rs     |  63 ---
 crates/driver/src/domain/eth/eip712.rs        |   9 -
 crates/driver/src/domain/eth/gas.rs           | 144 ------
 crates/driver/src/domain/eth/mod.rs           | 459 ------------------
 crates/driver/src/domain/flashloan.rs         |  51 ++
 crates/driver/src/domain/interaction.rs       |  32 ++
 .../src/domain/liquidity/balancer/v2/mod.rs   |   2 +-
 .../domain/liquidity/balancer/v2/stable.rs    |   5 +-
 .../domain/liquidity/balancer/v2/weighted.rs  |   5 +-
 crates/driver/src/domain/liquidity/mod.rs     |   2 +-
 crates/driver/src/domain/liquidity/swapr.rs   |  11 +-
 .../driver/src/domain/liquidity/uniswap/v2.rs |   5 +-
 .../driver/src/domain/liquidity/uniswap/v3.rs |   5 +-
 crates/driver/src/domain/liquidity/zeroex.rs  |   9 +-
 crates/driver/src/domain/mempools.rs          |  38 +-
 crates/driver/src/domain/mod.rs               |   8 +-
 crates/driver/src/domain/quote.rs             |  22 +-
 .../src/infra/api/routes/quote/dto/order.rs   |   3 +-
 .../src/infra/api/routes/quote/dto/quote.rs   |   7 +-
 .../driver/src/infra/api/routes/settle/mod.rs |   2 +-
 .../api/routes/solve/dto/solve_request.rs     |   7 +-
 .../api/routes/solve/dto/solve_response.rs    |   3 +-
 .../driver/src/infra/blockchain/contracts.rs  |  10 +-
 crates/driver/src/infra/blockchain/gas.rs     |   6 +-
 crates/driver/src/infra/blockchain/mod.rs     |  16 +-
 crates/driver/src/infra/blockchain/token.rs   |   4 +-
 crates/driver/src/infra/config/file/load.rs   |   5 +-
 crates/driver/src/infra/config/file/mod.rs    |   3 +-
 crates/driver/src/infra/config/mod.rs         |  20 +-
 crates/driver/src/infra/liquidity/config.rs   |   9 +-
 crates/driver/src/infra/mempool/mod.rs        |   3 +-
 .../liquidity_sources/liquorice/notifier.rs   |  14 +-
 crates/driver/src/infra/notify/mod.rs         |   9 +-
 .../driver/src/infra/notify/notification.rs   |   6 +-
 crates/driver/src/infra/observe/mod.rs        |   7 +-
 crates/driver/src/infra/simulator/enso/dto.rs |   2 +-
 crates/driver/src/infra/simulator/enso/mod.rs |   2 +-
 crates/driver/src/infra/simulator/mod.rs      |   8 +-
 .../src/infra/simulator/tenderly/dto.rs       |   2 +-
 .../src/infra/simulator/tenderly/mod.rs       |   5 +-
 crates/driver/src/infra/solver/dto/auction.rs |  24 +-
 .../src/infra/solver/dto/notification.rs      |   4 +-
 .../driver/src/infra/solver/dto/solution.rs   |  15 +-
 crates/driver/src/infra/solver/mod.rs         |  10 +-
 crates/driver/src/infra/tokens.rs             |   6 +-
 crates/driver/src/tests/cases/fees.rs         |  15 +-
 crates/driver/src/tests/cases/haircut.rs      |   3 +-
 crates/driver/src/tests/cases/jit_orders.rs   |  32 +-
 crates/driver/src/tests/cases/mod.rs          |   2 +-
 .../driver/src/tests/cases/protocol_fees.rs   |  33 +-
 crates/driver/src/tests/cases/quote.rs        |   3 +-
 .../driver/src/tests/cases/solver_balance.rs  |   6 +-
 crates/driver/src/tests/setup/blockchain.rs   |   5 +-
 crates/driver/src/tests/setup/fee.rs          |   2 +-
 crates/driver/src/tests/setup/mod.rs          |   2 +-
 crates/driver/src/tests/setup/solver.rs       |   2 +-
 crates/e2e/Cargo.toml                         |   1 +
 crates/e2e/tests/e2e/cow_amm.rs               |   2 +-
 crates/e2e/tests/e2e/limit_orders.rs          |   2 +-
 crates/e2e/tests/e2e/protocol_fee.rs          |   2 +-
 crates/eth-domain-types/src/ether.rs          |   6 +
 crates/eth-domain-types/src/lib.rs            |  16 +
 89 files changed, 530 insertions(+), 992 deletions(-)
 create mode 100644 crates/driver/src/domain/blockchain.rs
 delete mode 100644 crates/driver/src/domain/eth/allowance.rs
 delete mode 100644 crates/driver/src/domain/eth/eip712.rs
 delete mode 100644 crates/driver/src/domain/eth/gas.rs
 delete mode 100644 crates/driver/src/domain/eth/mod.rs
 create mode 100644 crates/driver/src/domain/flashloan.rs
 create mode 100644 crates/driver/src/domain/interaction.rs

diff --git a/Cargo.lock b/Cargo.lock
index e3b621d7e3..a1a58b7002 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2986,6 +2986,7 @@ dependencies = [
  "cow-amm",
  "dashmap",
  "derive_more 1.0.0",
+ "eth-domain-types",
  "ethrpc",
  "event-indexing",
  "futures",
@@ -3063,6 +3064,7 @@ dependencies = [
  "cow-amm",
  "database",
  "driver",
+ "eth-domain-types",
  "ethrpc",
  "futures",
  "hex-literal",
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index 764544f466..cd5f884b8c 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -39,6 +39,7 @@ const-hex = { workspace = true }
 cow-amm = { workspace = true }
 dashmap = { workspace = true }
 derive_more = { workspace = true }
+eth-domain-types = { workspace = true }
 ethrpc = { workspace = true }
 event-indexing = { workspace = true }
 futures = { workspace = true }
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
index c99023c533..f641c1ca5f 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
@@ -2,7 +2,7 @@ use {
     crate::{
         boundary,
         domain::{
-            eth,
+            self,
             liquidity::{self, balancer},
         },
         infra::{self, blockchain::Ethereum},
@@ -16,6 +16,7 @@ use {
         BalancerV2WeightedPoolFactory,
         BalancerV2WeightedPoolFactoryV3,
     },
+    eth_domain_types as eth,
     ethrpc::block_stream::CurrentBlockWatcher,
     event_indexing::block_retriever::BlockRetrieving,
     liquidity_sources::balancer_v2::{
@@ -44,24 +45,24 @@ fn to_interaction(
     input: &liquidity::MaxInput,
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
-) -> eth::Interaction {
+) -> domain::Interaction {
     let handler = balancer_v2::SettlementHandler::new(
         pool.id.0,
         // Note that this code assumes `receiver == sender`. This assumption is
         // also baked into the Balancer V2 logic in the `shared` crate, so to
         // change this assumption, we would need to change it there as well.
         *receiver,
-        pool.vault.0,
+        *pool.vault,
     );
 
     let interaction = handler.swap(
-        TokenAmount::new(input.0.token.0.0, input.0.amount.0),
-        TokenAmount::new(output.0.token.0.0, output.0.amount.0),
+        TokenAmount::new(*input.0.token, input.0.amount.0),
+        TokenAmount::new(*output.0.token, output.0.amount.0),
     );
 
     let (target, value, call_data) = interaction.encode_swap();
 
-    eth::Interaction {
+    domain::Interaction {
         target,
         value: value.into(),
         call_data: call_data.0.to_vec().into(),
@@ -101,7 +102,7 @@ async fn init_liquidity(
 ) -> Result<impl LiquidityCollecting + use<>> {
     let web3 = eth.web3().clone();
     let contracts = BalancerContracts {
-        vault: BalancerV2Vault::Instance::new(config.vault.0, web3.provider.clone()),
+        vault: BalancerV2Vault::Instance::new(*config.vault, web3.provider.clone()),
         factories: [
             config
                 .weighted
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/stable.rs b/crates/driver/src/boundary/liquidity/balancer/v2/stable.rs
index cee05abfff..c74039e887 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/stable.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/stable.rs
@@ -2,10 +2,11 @@ use {
     crate::{
         boundary::Result,
         domain::{
-            eth,
+            self,
             liquidity::{self, balancer},
         },
     },
+    eth_domain_types as eth,
     solver::liquidity::{StablePoolOrder, balancer_v2},
 };
 
@@ -69,7 +70,7 @@ pub fn to_interaction(
     input: &liquidity::MaxInput,
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
-) -> eth::Interaction {
+) -> domain::Interaction {
     super::to_interaction(
         &super::Pool {
             vault: pool.vault,
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs b/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs
index 48954e80c2..caa03290db 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/weighted.rs
@@ -2,10 +2,11 @@ use {
     crate::{
         boundary::Result,
         domain::{
-            eth,
+            self,
             liquidity::{self, balancer},
         },
     },
+    eth_domain_types as eth,
     liquidity_sources::balancer_v2::pool_fetching::WeightedPoolVersion,
     solver::liquidity::{WeightedProductOrder, balancer_v2},
 };
@@ -73,7 +74,7 @@ pub fn to_interaction(
     input: &liquidity::MaxInput,
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
-) -> eth::Interaction {
+) -> domain::Interaction {
     super::to_interaction(
         &super::Pool {
             vault: pool.vault,
diff --git a/crates/driver/src/boundary/liquidity/mod.rs b/crates/driver/src/boundary/liquidity/mod.rs
index d55243f029..ceb8ec56b7 100644
--- a/crates/driver/src/boundary/liquidity/mod.rs
+++ b/crates/driver/src/boundary/liquidity/mod.rs
@@ -1,9 +1,10 @@
 use {
     crate::{
-        domain::{eth, liquidity},
+        domain::liquidity,
         infra::{self, blockchain::Ethereum},
     },
     anyhow::Result,
+    eth_domain_types as eth,
     ethrpc::block_stream::CurrentBlockWatcher,
     futures::future,
     http_client::HttpClientFactory,
@@ -136,7 +137,7 @@ impl Fetcher {
             .iter()
             .map(|pair| {
                 let (a, b) = pair.get();
-                TokenPair::new(a.0.0, b.0.0).expect("a != b")
+                TokenPair::new(*a, *b).expect("a != b")
             })
             .collect();
 
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v2.rs b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
index ed9e003029..ab7e32a88b 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v2.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
@@ -2,12 +2,13 @@ use {
     crate::{
         boundary::{self, Result},
         domain::{
-            eth,
+            self,
             liquidity::{self, uniswap},
         },
         infra::{self, blockchain::Ethereum},
     },
     contracts::alloy::IUniswapLikeRouter,
+    eth_domain_types as eth,
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     liquidity_sources::uniswap_v2::{
         pair_provider::PairProvider,
@@ -85,17 +86,17 @@ pub fn to_interaction(
     input: &liquidity::MaxInput,
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
-) -> eth::Interaction {
-    let handler = uniswap_v2::Inner::new(pool.router.0, *receiver);
+) -> domain::Interaction {
+    let handler = uniswap_v2::Inner::new(*pool.router, *receiver);
 
     let interaction = handler.settle(
-        TokenAmount::new(input.0.token.into(), input.0.amount),
-        TokenAmount::new(output.0.token.into(), output.0.amount),
+        TokenAmount::new(*input.0.token, input.0.amount),
+        TokenAmount::new(*output.0.token, output.0.amount),
     );
 
     let (target, value, call_data) = interaction.encode_swap();
 
-    eth::Interaction {
+    domain::Interaction {
         target,
         value: value.into(),
         call_data: call_data.0.to_vec().into(),
@@ -121,7 +122,7 @@ where
     R: PoolReading + Send + Sync + 'static,
     F: FnOnce(Web3, PairProvider) -> R,
 {
-    let router = IUniswapLikeRouter::Instance::new(config.router.0, eth.web3().provider.clone());
+    let router = IUniswapLikeRouter::Instance::new(*config.router, eth.web3().provider.clone());
     let settlement = eth.contracts().settlement().clone();
     let pool_fetcher = {
         let factory = router.factory().call().await?;
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v3.rs b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
index e07afd2235..3dfab84338 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v3.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v3.rs
@@ -2,7 +2,7 @@ use {
     crate::{
         boundary::{self, Result},
         domain::{
-            eth,
+            self,
             liquidity::{
                 self,
                 uniswap::v3::{Fee, Liquidity, LiquidityNet, Pool, SqrtPrice, Tick},
@@ -11,6 +11,7 @@ use {
         infra::{self, blockchain::Ethereum},
     },
     anyhow::Context,
+    eth_domain_types as eth,
     event_indexing::{block_retriever::BlockRetrieving, maintenance::ServiceMaintenance},
     liquidity_sources::uniswap_v3::pool_fetching::UniswapV3PoolFetcher,
     shared::{http_solver::model::TokenAmount, interaction::Interaction},
@@ -68,8 +69,8 @@ pub fn to_interaction(
     input: &liquidity::MaxInput,
     output: &liquidity::ExactOutput,
     receiver: &eth::Address,
-) -> eth::Interaction {
-    let handler = UniswapV3SettlementHandler::new(pool.router.into(), *receiver, pool.fee.0);
+) -> domain::Interaction {
+    let handler = UniswapV3SettlementHandler::new(*pool.router, *receiver, pool.fee.0);
 
     let interaction = handler.settle(
         TokenAmount::new(input.0.token.into(), input.0.amount),
@@ -77,7 +78,7 @@ pub fn to_interaction(
     );
 
     let encoded = interaction.encode();
-    eth::Interaction {
+    domain::Interaction {
         target: encoded.0,
         value: encoded.1.into(),
         call_data: encoded.2,
@@ -132,7 +133,7 @@ async fn init_liquidity(
     tokio::task::spawn(update_task);
 
     Ok(UniswapV3Liquidity::new(
-        config.router.into(),
+        *config.router,
         *eth.contracts().settlement().address(),
         pool_fetcher,
     ))
diff --git a/crates/driver/src/domain/blockchain.rs b/crates/driver/src/domain/blockchain.rs
new file mode 100644
index 0000000000..36c33839e9
--- /dev/null
+++ b/crates/driver/src/domain/blockchain.rs
@@ -0,0 +1,83 @@
+use {
+    alloy::{
+        primitives::{B256, Bytes},
+        rpc::types::TransactionRequest,
+    },
+    derive_more::derive::{From, Into},
+    eth_domain_types::{AccessList, Address, BlockNo, Ether},
+};
+
+/// A transaction ID, AKA transaction hash.
+#[derive(Clone, Debug, From, Into)]
+pub struct TxId(pub B256);
+
+pub enum TxStatus {
+    /// The transaction has been included and executed successfully.
+    Executed { block_number: BlockNo },
+    /// The transaction has been included but execution failed.
+    Reverted { block_number: BlockNo },
+    /// The transaction has not been included yet.
+    Pending,
+}
+
+/// An onchain transaction.
+#[derive(derive_more::Debug, Clone)]
+pub struct Tx {
+    pub from: Address,
+    pub to: Address,
+    pub value: Ether,
+    pub input: Bytes,
+    #[debug(ignore)]
+    pub access_list: AccessList,
+}
+
+impl From<Tx> for TransactionRequest {
+    fn from(value: Tx) -> Self {
+        TransactionRequest::default()
+            .from(value.from)
+            .to(value.to)
+            .value(value.value.0)
+            .input(value.input.into())
+            .access_list(value.access_list.into())
+    }
+}
+
+impl Tx {
+    pub fn set_access_list(self, access_list: AccessList) -> Self {
+        Self {
+            access_list,
+            ..self
+        }
+    }
+}
+
+/// The Keccak-256 hash of a contract's initialization code.
+///
+/// This value is meaningful in the context of the EVM `CREATE2` opcode in that
+/// it influences the deterministic address that the contract ends up on.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct CodeDigest(pub B256);
+
+impl From<B256> for CodeDigest {
+    fn from(value: B256) -> Self {
+        Self(value)
+    }
+}
+
+impl From<CodeDigest> for B256 {
+    fn from(value: CodeDigest) -> Self {
+        value.0
+    }
+}
+
+impl From<[u8; 32]> for CodeDigest {
+    fn from(value: [u8; 32]) -> Self {
+        Self(B256::from(value))
+    }
+}
+
+impl From<CodeDigest> for [u8; 32] {
+    fn from(value: CodeDigest) -> Self {
+        value.0.into()
+    }
+}
diff --git a/crates/driver/src/domain/competition/auction.rs b/crates/driver/src/domain/competition/auction.rs
index 10bc830db7..c4ddc6e498 100644
--- a/crates/driver/src/domain/competition/auction.rs
+++ b/crates/driver/src/domain/competition/auction.rs
@@ -2,13 +2,13 @@ use {
     crate::{
         domain::{
             competition::{self},
-            eth::{self, GasPrice},
             liquidity,
             time,
         },
         infra::{Ethereum, blockchain, solver::Timeouts},
     },
     alloy::primitives::U256,
+    eth_domain_types::{self as eth, GasPrice},
     std::collections::{HashMap, HashSet},
     thiserror::Error,
 };
@@ -180,7 +180,7 @@ impl Price {
     /// Converting 1 ETH expressed in `eth::TokenAmount` into `eth::Ether`
     ///
     /// ```
-    /// use driver::domain::{competition::auction::Price, eth};
+    /// use {driver::domain::competition::auction::Price, eth_domain_types as eth};
     ///
     /// let amount = eth::TokenAmount::from(eth::U256::from(10).pow(eth::U256::from(18)));
     /// let price = Price::try_new(eth::Ether::from(
@@ -204,7 +204,7 @@ impl Price {
     ///
     /// # Examples
     /// ```
-    /// use driver::domain::{competition::auction::Price, eth};
+    /// use {driver::domain::competition::auction::Price, eth_domain_types as eth};
     ///
     /// let amount = eth::Ether::from(eth::U256::from(10).pow(eth::U256::from(18)));
     /// let price = Price::try_new(eth::Ether::from(
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 2026655e11..9127316f98 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -8,7 +8,6 @@ use {
     crate::{
         domain::{
             competition::{solution::Settlement, sorting::SortingStrategy},
-            eth,
             time::DeadlineExceeded,
         },
         infra::{
@@ -25,6 +24,7 @@ use {
     alloy::{network::TxSigner as _, primitives::Bytes},
     anyhow::Context as _,
     axum::{body::Body, http::Request},
+    eth_domain_types as eth,
     futures::{FutureExt, StreamExt, future::Either, stream::FuturesUnordered},
     itertools::Itertools,
     std::{
@@ -47,10 +47,12 @@ pub mod risk_detector;
 pub mod solution;
 pub mod sorting;
 
+use {
+    crate::infra::notify::liquidity_sources::LiquiditySourceNotifying,
+    eth_domain_types::BlockNo,
+};
 pub use {auction::Auction, order::Order, pre_processing::DataAggregator, solution::Solution};
 
-use crate::{domain::BlockNo, infra::notify::liquidity_sources::LiquiditySourceNotifying};
-
 type BalanceGroup = (order::Trader, eth::TokenAddress, order::SellTokenBalance);
 type Balances = HashMap<BalanceGroup, order::SellAmount>;
 
@@ -812,7 +814,7 @@ impl Competition {
             tracing_span,
         } = request;
         async {
-            if self.eth.current_block().borrow().number >= submission_deadline {
+            if self.eth.current_block().borrow().number >= submission_deadline.0 {
                 if let Err(err) = response_sender.send(Err(DeadlineExceeded.into())) {
                     tracing::error!(
                         ?err,
diff --git a/crates/driver/src/domain/competition/order/mod.rs b/crates/driver/src/domain/competition/order/mod.rs
index 3a7c6e1b59..8f9daed123 100644
--- a/crates/driver/src/domain/competition/order/mod.rs
+++ b/crates/driver/src/domain/competition/order/mod.rs
@@ -1,11 +1,12 @@
 use {
     crate::{
-        domain::eth,
+        domain,
         infra::{Ethereum, blockchain},
         util,
     },
     alloy::primitives::FixedBytes,
     derive_more::{From, Into},
+    eth_domain_types as eth,
     model::order::{BuyTokenDestination, SellTokenSource},
 };
 pub use {fees::FeePolicy, signature::Signature};
@@ -33,11 +34,11 @@ pub struct Order {
     /// The onchain calls to run before sending user funds to the settlement
     /// contract.
     /// These are set by the user and included in the settlement transaction.
-    pub pre_interactions: Vec<eth::Interaction>,
+    pub pre_interactions: Vec<domain::Interaction>,
     /// The onchain calls to run after sending tokens from the settlement
     /// contract to the user.
     /// These are set by the user and included in the settlement transaction.
-    pub post_interactions: Vec<eth::Interaction>,
+    pub post_interactions: Vec<domain::Interaction>,
     pub sell_token_balance: SellTokenBalance,
     pub buy_token_balance: BuyTokenBalance,
     pub signature: Signature,
diff --git a/crates/driver/src/domain/competition/order/signature.rs b/crates/driver/src/domain/competition/order/signature.rs
index acddc8a30e..cb50a19098 100644
--- a/crates/driver/src/domain/competition/order/signature.rs
+++ b/crates/driver/src/domain/competition/order/signature.rs
@@ -1,4 +1,4 @@
-use {crate::domain::eth, alloy::primitives::Bytes, model::signature::EcdsaSignature};
+use {alloy::primitives::Bytes, eth_domain_types as eth, model::signature::EcdsaSignature};
 
 /// Signature over the order data.
 #[derive(Debug, Clone)]
diff --git a/crates/driver/src/domain/competition/pre_processing.rs b/crates/driver/src/domain/competition/pre_processing.rs
index 585a87e6da..44f3effee5 100644
--- a/crates/driver/src/domain/competition/pre_processing.rs
+++ b/crates/driver/src/domain/competition/pre_processing.rs
@@ -4,7 +4,6 @@ use {
         domain::{
             competition::order::{SellTokenBalance, app_data::AppData},
             cow_amm,
-            eth,
             liquidity,
         },
         infra::{self, api::routes::solve::dto::SolveRequest, observe::metrics, tokens},
@@ -18,6 +17,7 @@ use {
     },
     balance_overrides::BalanceOverrideRequest,
     chrono::Utc,
+    eth_domain_types::{self as eth, Address, TokenAddress},
     futures::{FutureExt, StreamExt, future::BoxFuture, stream::FuturesUnordered},
     itertools::Itertools,
     model::{
@@ -141,7 +141,7 @@ impl DataAggregator {
             eth.web3(),
             signature_validator::Contracts {
                 settlement: eth.contracts().settlement().clone(),
-                vault_relayer: eth.contracts().vault_relayer().0,
+                vault_relayer: *eth.contracts().vault_relayer(),
                 signatures: eth.contracts().signatures().clone(),
             },
             eth.balance_overrider(),
@@ -151,7 +151,7 @@ impl DataAggregator {
             .contracts()
             .cow_amm_helper_by_factory()
             .iter()
-            .map(|(factory, helper)| (factory.0, helper.0))
+            .map(|(factory, helper)| (Address::from(*factory), Address::from(*helper)))
             .collect();
         let cow_amm_cache =
             cow_amm::Cache::new(eth.web3().provider.clone(), cow_amm_helper_by_factory);
@@ -290,7 +290,7 @@ impl Utilities {
                 });
                 Query {
                     owner: trader.0,
-                    token: token.0.0,
+                    token: *token,
                     source: match source {
                         SellTokenBalance::Erc20 => SellTokenSource::Erc20,
                         SellTokenBalance::Internal => SellTokenSource::Internal,
@@ -436,7 +436,7 @@ impl Utilities {
                         .iter()
                         .map(|t| {
                             auction.tokens
-                                .get(&eth::TokenAddress(eth::ContractAddress(*t)))
+                                .get(&TokenAddress::from(*t))
                                 .and_then(|token| token.price)
                                 .map(|price| price.0.0)
                         })
diff --git a/crates/driver/src/domain/competition/risk_detector/bad_tokens/cache.rs b/crates/driver/src/domain/competition/risk_detector/bad_tokens/cache.rs
index c6473045a8..9bd9dd6418 100644
--- a/crates/driver/src/domain/competition/risk_detector/bad_tokens/cache.rs
+++ b/crates/driver/src/domain/competition/risk_detector/bad_tokens/cache.rs
@@ -1,6 +1,7 @@
 use {
-    crate::domain::{competition::risk_detector::Quality, eth},
+    crate::domain::competition::risk_detector::Quality,
     dashmap::DashMap,
+    eth_domain_types as eth,
     std::{
         sync::Arc,
         time::{Duration, Instant},
diff --git a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
index bca8962520..a6018e6035 100644
--- a/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
+++ b/crates/driver/src/domain/competition/risk_detector/bad_tokens/simulation.rs
@@ -77,7 +77,7 @@ impl Detector {
                 async move {
                     let result = inner
                         .detector
-                        .test_transfer(trader, sell_token.0.0, sell_amount, &pre_interactions)
+                        .test_transfer(trader, *sell_token, sell_amount, &pre_interactions)
                         .await;
                     match result {
                         Err(err) => {
diff --git a/crates/driver/src/domain/competition/risk_detector/mod.rs b/crates/driver/src/domain/competition/risk_detector/mod.rs
index 052f4bec36..357f0b6e04 100644
--- a/crates/driver/src/domain/competition/risk_detector/mod.rs
+++ b/crates/driver/src/domain/competition/risk_detector/mod.rs
@@ -16,10 +16,8 @@
 //! we were not able to predict issues with orders and pre-emptively
 //! filter them out of the auction.
 use {
-    crate::domain::{
-        competition::{Auction, order::Uid},
-        eth,
-    },
+    crate::domain::competition::{Auction, order::Uid},
+    eth_domain_types as eth,
     futures::{StreamExt, stream::FuturesUnordered},
     std::{collections::HashMap, fmt, time::Instant},
 };
diff --git a/crates/driver/src/domain/competition/solution/encoding.rs b/crates/driver/src/domain/competition/solution/encoding.rs
index 55e1128940..f952690d35 100644
--- a/crates/driver/src/domain/competition/solution/encoding.rs
+++ b/crates/driver/src/domain/competition/solution/encoding.rs
@@ -2,11 +2,11 @@ use {
     super::{error::Math, interaction::Liquidity, settlement, slippage, trade::ClearingPrices},
     crate::{
         domain::{
+            self,
             competition::{
                 self,
                 order::{self, Partial},
             },
-            eth::{self, Ether, allowance},
             liquidity,
         },
         infra::{self, solver::ManageNativeToken},
@@ -17,6 +17,7 @@ use {
         sol_types::SolCall,
     },
     contracts::alloy::{FlashLoanRouter::LoanRequest, WETH9},
+    eth_domain_types::{self as eth, Ether, allowance},
     itertools::Itertools,
     num::Zero,
 };
@@ -192,7 +193,7 @@ pub fn tx(
         }
 
         interactions.push(match interaction {
-            competition::solution::Interaction::Custom(interaction) => eth::Interaction {
+            competition::solution::Interaction::Custom(interaction) => domain::Interaction {
                 value: interaction.value,
                 target: interaction.target.into(),
                 call_data: interaction.call_data.clone(),
@@ -270,10 +271,10 @@ fn encode_flashloan_settlement(
         .flashloans
         .values()
         .map(|flashloan| LoanRequest::Data {
-            amount: flashloan.amount.0,
-            borrower: flashloan.protocol_adapter.0,
-            lender: flashloan.liquidity_provider.0,
-            token: flashloan.token.0.0,
+            amount: flashloan.amount,
+            borrower: flashloan.protocol_adapter,
+            lender: flashloan.liquidity_provider,
+            token: flashloan.token,
         })
         .collect();
 
@@ -342,7 +343,7 @@ pub fn liquidity_interaction(
     liquidity: &Liquidity,
     slippage: &slippage::Parameters,
     settlement_contract: &Address,
-) -> Result<eth::Interaction, Error> {
+) -> Result<domain::Interaction, Error> {
     let (input, output) = slippage.apply_to(&slippage::Interaction {
         input: liquidity.input,
         output: liquidity.output,
@@ -365,10 +366,10 @@ pub fn liquidity_interaction(
     )))
 }
 
-pub fn approve(allowance: &Allowance) -> eth::Interaction {
+pub fn approve(allowance: &Allowance) -> domain::Interaction {
     let selector = hex_literal::hex!("095ea7b3");
     let amount: [_; 32] = allowance.amount.to_be_bytes();
-    eth::Interaction {
+    domain::Interaction {
         target: allowance.token.0.into(),
         value: Ether::zero(),
         // selector (4 bytes) + spender (20 byte address padded to 32 bytes) + amount (32 bytes)
@@ -383,8 +384,8 @@ pub fn approve(allowance: &Allowance) -> eth::Interaction {
     }
 }
 
-fn unwrap(amount: eth::TokenAmount, weth: &WETH9::Instance) -> eth::Interaction {
-    eth::Interaction {
+fn unwrap(amount: eth::TokenAmount, weth: &WETH9::Instance) -> domain::Interaction {
+    domain::Interaction {
         target: *weth.address(),
         value: Ether::zero(),
         call_data: weth.withdraw(amount.0).calldata().to_vec().into(),
@@ -422,9 +423,10 @@ struct Flags {
 
 pub mod codec {
     use {
-        crate::domain::{competition::order, eth},
+        crate::domain::{self, competition::order},
         alloy::primitives::{Bytes, U256},
         contracts::alloy::GPv2Settlement,
+        eth_domain_types as eth,
     };
 
     pub(super) fn trade(trade: &super::Trade) -> GPv2Settlement::GPv2Trade::Data {
@@ -475,7 +477,7 @@ pub mod codec {
     }
 
     pub(super) fn interaction(
-        interaction: &eth::Interaction,
+        interaction: &domain::Interaction,
     ) -> GPv2Settlement::GPv2Interaction::Data {
         GPv2Settlement::GPv2Interaction::Data {
             target: interaction.target,
diff --git a/crates/driver/src/domain/competition/solution/fee.rs b/crates/driver/src/domain/competition/solution/fee.rs
index af41148fa8..b2cda84535 100644
--- a/crates/driver/src/domain/competition/solution/fee.rs
+++ b/crates/driver/src/domain/competition/solution/fee.rs
@@ -27,15 +27,13 @@ use {
         error::Math,
         trade::{ClearingPrices, Fee, Fulfillment},
     },
-    crate::domain::{
-        competition::{
-            PriceLimits,
-            order::{self, FeePolicy, Side},
-            solution::error::Trade,
-        },
-        eth::{self},
+    crate::domain::competition::{
+        PriceLimits,
+        order::{self, FeePolicy, Side},
+        solution::error::Trade,
     },
     bigdecimal::Zero,
+    eth_domain_types as eth,
 };
 
 impl Fulfillment {
diff --git a/crates/driver/src/domain/competition/solution/interaction.rs b/crates/driver/src/domain/competition/solution/interaction.rs
index 25468f39b0..50d48e4719 100644
--- a/crates/driver/src/domain/competition/solution/interaction.rs
+++ b/crates/driver/src/domain/competition/solution/interaction.rs
@@ -1,6 +1,7 @@
 use {
-    crate::domain::{self, eth, liquidity},
+    crate::domain::{self, liquidity},
     alloy::primitives::Bytes,
+    eth_domain_types as eth,
 };
 
 /// Interaction with a smart contract which is needed to execute this solution
diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index 35f9b64615..a83ae5fe55 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -4,8 +4,8 @@ use {
     crate::{
         boundary,
         domain::{
+            self,
             competition::{self, order},
-            eth::{self, Flashloan, TokenAddress},
         },
         infra::{
             Simulator,
@@ -17,10 +17,12 @@ use {
     },
     alloy::network::TxSigner,
     chrono::Utc,
+    eth_domain_types::{self as eth, TokenAddress},
     futures::future::try_join_all,
     itertools::Itertools,
     num::{BigRational, One},
     number::conversions::{big_rational_to_u256, u256_to_big_int, u256_to_big_rational},
+    solvers_dto::solution::Flashloan,
     std::{
         collections::{BTreeSet, HashMap, HashSet, hash_map::Entry},
         sync::atomic::{AtomicU64, Ordering},
@@ -57,15 +59,15 @@ pub struct Solution {
     trades: Vec<Trade>,
     prices: Prices,
     #[debug(ignore)]
-    pre_interactions: Vec<eth::Interaction>,
+    pre_interactions: Vec<domain::Interaction>,
     #[debug(ignore)]
     interactions: Vec<Interaction>,
     #[debug(ignore)]
-    post_interactions: Vec<eth::Interaction>,
+    post_interactions: Vec<domain::Interaction>,
     #[debug("{}", solver.name())]
     solver: Solver,
     #[debug(ignore)]
-    weth: eth::WethAddress,
+    weth: eth::WrappedNativeToken,
     gas: Option<eth::Gas>,
     flashloans: HashMap<order::Uid, Flashloan>,
     #[debug(ignore)]
@@ -78,11 +80,11 @@ impl Solution {
         id: Id,
         mut trades: Vec<Trade>,
         prices: Prices,
-        pre_interactions: Vec<eth::Interaction>,
+        pre_interactions: Vec<domain::Interaction>,
         interactions: Vec<Interaction>,
-        post_interactions: Vec<eth::Interaction>,
+        post_interactions: Vec<domain::Interaction>,
         solver: Solver,
-        weth: eth::WethAddress,
+        weth: eth::WrappedNativeToken,
         gas: Option<eth::Gas>,
         fee_handler: FeeHandler,
         surplus_capturing_jit_order_owners: &HashSet<eth::Address>,
@@ -214,11 +216,11 @@ impl Solution {
         &self.interactions
     }
 
-    pub fn pre_interactions(&self) -> &[eth::Interaction] {
+    pub fn pre_interactions(&self) -> &[domain::Interaction] {
         &self.pre_interactions
     }
 
-    pub fn post_interactions(&self) -> &[eth::Interaction] {
+    pub fn post_interactions(&self) -> &[domain::Interaction] {
         &self.post_interactions
     }
 
@@ -479,18 +481,18 @@ impl Solution {
             // price is needed. Remove the unneeded WETH price, which slightly reduces
             // gas used by the settlement.
             let mut prices: Prices = if self.user_trades().all(|trade| {
-                trade.order().sell.token != self.weth.0 && trade.order().buy.token != self.weth.0
+                trade.order().sell.token != *self.weth && trade.order().buy.token != *self.weth
             }) {
                 prices
                     .into_iter()
-                    .filter(|(token, _price)| *token != self.weth.0)
+                    .filter(|(token, _price)| *token != *self.weth)
                     .collect()
             } else {
                 prices
             };
 
             // Add a clearing price for ETH equal to WETH.
-            prices.insert(eth::ETH_TOKEN, self.prices[&self.weth.into()].to_owned());
+            prices.insert(eth::ETH_TOKEN, self.prices[&self.weth].to_owned());
 
             return prices;
         }
diff --git a/crates/driver/src/domain/competition/solution/scoring.rs b/crates/driver/src/domain/competition/solution/scoring.rs
index f5eaa99752..c3517951f7 100644
--- a/crates/driver/src/domain/competition/solution/scoring.rs
+++ b/crates/driver/src/domain/competition/solution/scoring.rs
@@ -12,19 +12,17 @@ use {
         order::{self, Side},
         trade::CustomClearingPrices,
     },
-    crate::domain::{
-        competition::{
-            PriceLimits,
-            auction,
-            order::FeePolicy,
-            solution::{
-                error,
-                fee::{self, adjust_quote_to_order_limits},
-            },
+    crate::domain::competition::{
+        PriceLimits,
+        auction,
+        order::FeePolicy,
+        solution::{
+            error,
+            fee::{self, adjust_quote_to_order_limits},
         },
-        eth,
     },
     alloy::primitives::ruint::UintTryFrom,
+    eth_domain_types as eth,
     number::u256_ext::U256Ext,
 };
 
diff --git a/crates/driver/src/domain/competition/solution/settlement.rs b/crates/driver/src/domain/competition/solution/settlement.rs
index c7ad4a33d7..bbc99d4f62 100644
--- a/crates/driver/src/domain/competition/solution/settlement.rs
+++ b/crates/driver/src/domain/competition/solution/settlement.rs
@@ -2,17 +2,18 @@ use {
     super::{Error, Solution, encoding, trade::ClearingPrices},
     crate::{
         domain::{
+            self,
             competition::{
                 self,
                 auction,
                 order::{self},
                 solution::{self, Interaction, Trade, error},
             },
-            eth,
         },
         infra::{Simulator, blockchain::Ethereum, observe, solver::ManageNativeToken},
     },
     alloy::primitives::U256,
+    eth_domain_types as eth,
     futures::future::try_join_all,
     std::collections::{BTreeSet, HashMap, HashSet},
     tracing::instrument,
@@ -270,7 +271,7 @@ impl Settlement {
     }
 
     /// Solution's pre interactions
-    pub fn pre_interactions(&self) -> &[eth::Interaction] {
+    pub fn pre_interactions(&self) -> &[domain::Interaction] {
         self.solution.pre_interactions()
     }
 
@@ -280,7 +281,7 @@ impl Settlement {
     }
 
     /// Solution's post interactions
-    pub fn post_interactions(&self) -> &[eth::Interaction] {
+    pub fn post_interactions(&self) -> &[domain::Interaction] {
         self.solution.post_interactions()
     }
 
diff --git a/crates/driver/src/domain/competition/solution/slippage.rs b/crates/driver/src/domain/competition/solution/slippage.rs
index 458a22648d..7d5a2f6a0d 100644
--- a/crates/driver/src/domain/competition/solution/slippage.rs
+++ b/crates/driver/src/domain/competition/solution/slippage.rs
@@ -1,9 +1,9 @@
 use {
     crate::domain::{
         competition::auction::Prices,
-        eth,
         liquidity::{ExactOutput, MaxInput},
     },
+    eth_domain_types as eth,
     num::{BigRational, CheckedDiv, CheckedMul},
     number::{conversions::big_rational_to_u256, u256_ext::U256Ext},
 };
@@ -111,7 +111,7 @@ impl Parameters {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::domain::eth::Asset, alloy::primitives::address, num::rational::Ratio};
+    use {super::*, alloy::primitives::address, eth_domain_types::Asset, num::rational::Ratio};
 
     const GNO: eth::Address = address!("6810e776880c02933d47db1b9fc05908e5386b96");
     const USDC: eth::Address = address!("A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
diff --git a/crates/driver/src/domain/competition/solution/trade.rs b/crates/driver/src/domain/competition/solution/trade.rs
index f89f2a8549..c742a2dd07 100644
--- a/crates/driver/src/domain/competition/solution/trade.rs
+++ b/crates/driver/src/domain/competition/solution/trade.rs
@@ -1,12 +1,10 @@
 use {
-    crate::domain::{
-        competition::{
-            self,
-            order::{self, FeePolicy, SellAmount, Side, TargetAmount, Uid},
-            solution::error::{self, Math},
-        },
-        eth::{self, Asset},
+    crate::domain::competition::{
+        self,
+        order::{self, FeePolicy, SellAmount, Side, TargetAmount, Uid},
+        solution::error::{self, Math},
     },
+    eth_domain_types::{self as eth, Asset},
     number::u256_ext::U256Ext,
 };
 
diff --git a/crates/driver/src/domain/competition/sorting.rs b/crates/driver/src/domain/competition/sorting.rs
index c06b95fd2d..40182dcbc9 100644
--- a/crates/driver/src/domain/competition/sorting.rs
+++ b/crates/driver/src/domain/competition/sorting.rs
@@ -1,12 +1,10 @@
 use {
     crate::{
-        domain::{
-            competition::{auction::Tokens, order},
-            eth,
-        },
+        domain::competition::{auction::Tokens, order},
         util,
     },
     chrono::Duration,
+    eth_domain_types as eth,
     std::{fmt::Debug, sync::Arc},
 };
 
diff --git a/crates/driver/src/domain/cow_amm.rs b/crates/driver/src/domain/cow_amm.rs
index f28eb97ee0..adca1186cf 100644
--- a/crates/driver/src/domain/cow_amm.rs
+++ b/crates/driver/src/domain/cow_amm.rs
@@ -1,8 +1,8 @@
 use {
-    crate::domain::eth,
     alloy::{primitives::Address, providers::DynProvider},
     contracts::alloy::cow_amm::CowAmmLegacyHelper,
     cow_amm::Amm,
+    eth_domain_types as eth,
     itertools::{
         Either::{Left, Right},
         Itertools,
diff --git a/crates/driver/src/domain/eth/allowance.rs b/crates/driver/src/domain/eth/allowance.rs
deleted file mode 100644
index e56cac7544..0000000000
--- a/crates/driver/src/domain/eth/allowance.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use {
-    super::{Address, TokenAddress},
-    alloy::primitives::U256,
-    derive_more::{From, Into},
-};
-
-/// An ERC20 allowance.
-///
-/// https://eips.ethereum.org/EIPS/eip-20
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Allowance {
-    /// The token for the allowance.
-    pub token: TokenAddress,
-    /// The spender address.
-    pub spender: Address,
-    /// The amount for the allowance.
-    pub amount: U256,
-}
-
-/// An allowance that's already in effect, this essentially models the result of
-/// the allowance() method, see https://eips.ethereum.org/EIPS/eip-20#methods.
-#[derive(Debug, Clone, Copy, Into, From)]
-pub struct Existing(pub Allowance);
-
-/// An allowance that is required for some action.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Into, From)]
-pub struct Required(pub Allowance);
-
-impl Required {
-    /// Check if this allowance needs to be approved, and if so, return the
-    /// appropriate [`Approval`].
-    pub fn approval(&self, existing: &Existing) -> Option<Approval> {
-        if self.0.spender != existing.0.spender || self.0.amount <= existing.0.amount {
-            None
-        } else {
-            Some(Approval(self.0))
-        }
-    }
-}
-
-/// An approval which needs to be made with an approve() call, see
-/// https://eips.ethereum.org/EIPS/eip-20#methods.
-#[derive(Debug, Clone, Copy)]
-pub struct Approval(pub Allowance);
-
-impl Approval {
-    /// Approve the maximal amount possible, i.e. set the approved amount to
-    /// [`U256::max_value`].
-    pub fn max(self) -> Self {
-        Self(Allowance {
-            amount: U256::MAX,
-            ..self.0
-        })
-    }
-
-    /// Revoke the approval, i.e. set the approved amount to [`U256::zero`].
-    pub fn revoke(self) -> Self {
-        Self(Allowance {
-            amount: U256::ZERO,
-            ..self.0
-        })
-    }
-}
diff --git a/crates/driver/src/domain/eth/eip712.rs b/crates/driver/src/domain/eth/eip712.rs
deleted file mode 100644
index 6bbc086c13..0000000000
--- a/crates/driver/src/domain/eth/eip712.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! Types and procedures defined by EIP-712.
-//!
-//! https://eips.ethereum.org/EIPS/eip-712
-
-/// domainSeparator as defined by EIP-712.
-///
-/// https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator
-#[derive(Debug, Clone, Copy)]
-pub struct DomainSeparator(pub [u8; 32]);
diff --git a/crates/driver/src/domain/eth/gas.rs b/crates/driver/src/domain/eth/gas.rs
deleted file mode 100644
index efb72ef7ae..0000000000
--- a/crates/driver/src/domain/eth/gas.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-use {
-    super::{Ether, U256},
-    alloy::eips::eip1559::calc_effective_gas_price,
-    derive_more::{Display, From, Into},
-    std::ops::{self, Add},
-};
-
-/// Gas amount in gas units.
-///
-/// The amount of Ether that is paid in transaction fees is proportional to this
-/// amount as well as the transaction's [`EffectiveGasPrice`].
-#[derive(Debug, Default, Display, Clone, Copy, Ord, Eq, PartialOrd, PartialEq, From, Into)]
-pub struct Gas(pub U256);
-
-impl From<u64> for Gas {
-    fn from(value: u64) -> Self {
-        Self(U256::from(value))
-    }
-}
-
-impl Add for Gas {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-/// An EIP-1559 gas price estimate.
-///
-/// https://eips.ethereum.org/EIPS/eip-1559#specification
-#[derive(Debug, Clone, Copy)]
-pub struct GasPrice {
-    /// The maximum total fee that should be charged.
-    max: FeePerGas,
-    /// The maximum priority fee (i.e. the tip to the block proposer) that
-    /// can be charged.
-    tip: FeePerGas,
-    /// The current base gas price that will be charged to all accounts on the
-    /// next block.
-    base: u64,
-}
-
-impl GasPrice {
-    /// Returns the estimated [`EffectiveGasPrice`] for the gas price estimate.
-    pub fn effective(&self) -> EffectiveGasPrice {
-        U256::from(calc_effective_gas_price(
-            u128::try_from(self.max.0.0).expect("max fee per gas should fit in a u128"),
-            u128::try_from(self.tip.0.0).expect("max priority fee per gas should fit in a u128"),
-            Some(self.base),
-        ))
-        .into()
-    }
-
-    pub fn max(&self) -> FeePerGas {
-        self.max
-    }
-
-    pub fn tip(&self) -> FeePerGas {
-        self.tip
-    }
-
-    pub fn base(&self) -> u64 {
-        self.base
-    }
-
-    pub fn new(max: FeePerGas, tip: FeePerGas, base: u64) -> Self {
-        Self { max, tip, base }
-    }
-}
-
-/// Implements multiplication of a gas price by a floating point number.
-/// This is equivalent to multiplying the `tip` and `max`
-impl std::ops::Mul<f64> for GasPrice {
-    type Output = Self;
-
-    fn mul(self, rhs: f64) -> Self::Output {
-        Self {
-            max: self.max.mul_ceil(rhs),
-            tip: self.tip.mul_ceil(rhs),
-            base: self.base,
-        }
-    }
-}
-
-/// The amount of ETH to pay as fees for a single unit of gas. This is
-/// `{max,max_priority,base}_fee_per_gas` as defined by EIP-1559.
-///
-/// https://eips.ethereum.org/EIPS/eip-1559#specification
-#[derive(Debug, Clone, Copy, Ord, Eq, PartialEq, PartialOrd)]
-pub struct FeePerGas(pub Ether);
-
-impl FeePerGas {
-    /// Multiplies this fee by the given floating point number, rounding up.
-    fn mul_ceil(self, rhs: f64) -> Self {
-        U256::from((f64::from(self.0.0) * rhs).ceil()).into()
-    }
-}
-
-impl From<U256> for FeePerGas {
-    fn from(value: U256) -> Self {
-        Self(value.into())
-    }
-}
-
-impl ops::Add<FeePerGas> for FeePerGas {
-    type Output = FeePerGas;
-
-    fn add(self, rhs: FeePerGas) -> Self::Output {
-        FeePerGas(self.0 + rhs.0)
-    }
-}
-
-impl From<FeePerGas> for U256 {
-    fn from(value: FeePerGas) -> Self {
-        value.0.into()
-    }
-}
-
-impl ops::Mul<FeePerGas> for Gas {
-    type Output = Ether;
-
-    fn mul(self, rhs: FeePerGas) -> Self::Output {
-        (self.0 * rhs.0.0).into()
-    }
-}
-
-/// The `effective_gas_price` as defined by EIP-1559.
-///
-/// https://eips.ethereum.org/EIPS/eip-1559#specification
-#[derive(Debug, Clone, Copy)]
-pub struct EffectiveGasPrice(pub Ether);
-
-impl From<U256> for EffectiveGasPrice {
-    fn from(value: U256) -> Self {
-        Self(value.into())
-    }
-}
-
-impl From<EffectiveGasPrice> for U256 {
-    fn from(value: EffectiveGasPrice) -> Self {
-        value.0.into()
-    }
-}
diff --git a/crates/driver/src/domain/eth/mod.rs b/crates/driver/src/domain/eth/mod.rs
deleted file mode 100644
index c2f4f85756..0000000000
--- a/crates/driver/src/domain/eth/mod.rs
+++ /dev/null
@@ -1,459 +0,0 @@
-use {
-    alloy::{primitives::Bytes, rpc::types::TransactionRequest},
-    derive_more::{From, Into},
-    number::u256_ext::U256Ext,
-    solvers_dto::auction::FlashloanHint,
-    std::{
-        collections::{HashMap, HashSet},
-        ops::{Div, Mul, Sub},
-    },
-};
-
-pub mod allowance;
-mod eip712;
-mod gas;
-
-pub use {
-    allowance::Allowance,
-    alloy::primitives::{Address, B256, U256, U512},
-    eip712::DomainSeparator,
-    gas::{EffectiveGasPrice, FeePerGas, Gas, GasPrice},
-    number::nonzero::NonZeroU256,
-};
-
-// TODO This module is getting a little hectic with all kinds of different
-// types, I wonder if there could be meaningful submodules?
-
-/// ERC20 token address for ETH. In reality, ETH is not an ERC20 token because
-/// it does not implement the ERC20 interface, but this address is used by
-/// convention across the Ethereum ecosystem whenever ETH is treated like an
-/// ERC20 token.
-pub const ETH_TOKEN: TokenAddress = TokenAddress(ContractAddress(Address::repeat_byte(0xee)));
-
-/// An EIP-2930 access list. This type ensures that the addresses and storage
-/// keys are not repeated, and that the ordering is deterministic.
-///
-/// https://eips.ethereum.org/EIPS/eip-2930
-#[derive(Debug, Clone, Default)]
-pub struct AccessList(HashMap<Address, HashSet<StorageKey>>);
-
-impl AccessList {
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl AccessList {
-    /// Merge two access lists together.
-    pub fn merge(mut self, other: Self) -> Self {
-        for (address, storage_keys) in other.0.into_iter() {
-            self.0.entry(address).or_default().extend(storage_keys);
-        }
-        self
-    }
-}
-
-impl IntoIterator for AccessList {
-    type IntoIter = std::collections::hash_map::IntoIter<Address, HashSet<StorageKey>>;
-    type Item = (Address, HashSet<StorageKey>);
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-impl<I> FromIterator<(Address, I)> for AccessList
-where
-    I: IntoIterator<Item = B256>,
-{
-    fn from_iter<T: IntoIterator<Item = (Address, I)>>(iter: T) -> Self {
-        Self(
-            iter.into_iter()
-                .map(|(address, i)| {
-                    (
-                        address,
-                        i.into_iter().map(StorageKey).collect::<HashSet<_>>(),
-                    )
-                })
-                .collect(),
-        )
-    }
-}
-
-impl From<alloy::eips::eip2930::AccessList> for AccessList {
-    fn from(value: alloy::eips::eip2930::AccessList) -> Self {
-        Self(
-            value
-                .0
-                .into_iter()
-                .map(|item| {
-                    (
-                        item.address,
-                        item.storage_keys
-                            .into_iter()
-                            .map(StorageKey)
-                            .collect::<HashSet<_>>(),
-                    )
-                })
-                .collect(),
-        )
-    }
-}
-
-impl From<AccessList> for alloy::eips::eip2930::AccessList {
-    fn from(value: AccessList) -> Self {
-        Self(
-            value
-                .into_iter()
-                .map(
-                    |(address, storage_keys)| alloy::eips::eip2930::AccessListItem {
-                        address,
-                        storage_keys: storage_keys.into_iter().map(|k| k.0).collect(),
-                    },
-                )
-                .collect(),
-        )
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Into, From)]
-pub struct StorageKey(pub B256);
-
-// TODO This type should probably use Ethereum::is_contract to verify during
-// construction that it does indeed point to a contract
-/// A smart contract address.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Into, From)]
-pub struct ContractAddress(pub Address);
-
-/// An ERC20 token address.
-///
-/// https://eips.ethereum.org/EIPS/eip-20
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct TokenAddress(pub ContractAddress);
-
-impl TokenAddress {
-    /// If the token is ETH, return WETH, thereby converting it to erc20.
-    pub fn as_erc20(self, weth: WethAddress) -> Self {
-        if self == ETH_TOKEN { weth.into() } else { self }
-    }
-}
-
-/// An ERC20 token amount.
-///
-/// https://eips.ethereum.org/EIPS/eip-20
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
-pub struct TokenAmount(pub U256);
-
-impl TokenAmount {
-    /// Applies a factor to the token amount.
-    pub fn apply_factor(&self, factor: f64) -> Option<Self> {
-        Some(self.0.checked_mul_f64(factor)?.into())
-    }
-}
-
-/// A value denominated in an order's surplus token (buy token for
-/// sell orders and sell token for buy orders).
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, From, Into)]
-pub struct SurplusTokenAmount(pub U256);
-
-impl Sub<Self> for TokenAmount {
-    type Output = TokenAmount;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        self.0.sub(rhs.0).into()
-    }
-}
-
-impl num::CheckedSub for TokenAmount {
-    fn checked_sub(&self, other: &Self) -> Option<Self> {
-        self.0.checked_sub(other.0).map(Into::into)
-    }
-}
-
-impl Mul<Self> for TokenAmount {
-    type Output = TokenAmount;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        self.0.mul(rhs.0).into()
-    }
-}
-
-impl num::CheckedMul for TokenAmount {
-    fn checked_mul(&self, other: &Self) -> Option<Self> {
-        self.0.checked_mul(other.0).map(Into::into)
-    }
-}
-
-impl num::CheckedAdd for TokenAmount {
-    fn checked_add(&self, other: &Self) -> Option<Self> {
-        self.0.checked_add(other.0).map(Into::into)
-    }
-}
-
-impl Div<Self> for TokenAmount {
-    type Output = TokenAmount;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        self.0.div(rhs.0).into()
-    }
-}
-
-impl num::CheckedDiv for TokenAmount {
-    fn checked_div(&self, other: &Self) -> Option<Self> {
-        self.0.checked_div(other.0).map(Into::into)
-    }
-}
-
-impl From<u128> for TokenAmount {
-    fn from(value: u128) -> Self {
-        Self(U256::from(value))
-    }
-}
-
-impl std::ops::Add for TokenAmount {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl std::ops::AddAssign for TokenAmount {
-    fn add_assign(&mut self, rhs: Self) {
-        self.0 += rhs.0;
-    }
-}
-
-impl num::Zero for TokenAmount {
-    fn zero() -> Self {
-        Self(U256::ZERO)
-    }
-
-    fn is_zero(&self) -> bool {
-        self.0.is_zero()
-    }
-}
-
-impl std::fmt::Display for TokenAmount {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-/// The address of the WETH contract.
-#[derive(Debug, Clone, Copy, From, Into)]
-pub struct WethAddress(pub TokenAddress);
-
-impl From<Address> for WethAddress {
-    fn from(value: Address) -> Self {
-        WethAddress(value.into())
-    }
-}
-
-impl From<Address> for TokenAddress {
-    fn from(value: Address) -> Self {
-        Self(value.into())
-    }
-}
-
-impl From<TokenAddress> for Address {
-    fn from(value: TokenAddress) -> Self {
-        value.0.into()
-    }
-}
-
-impl From<TokenAddress> for ContractAddress {
-    fn from(value: TokenAddress) -> Self {
-        value.0
-    }
-}
-
-/// An asset on the Ethereum blockchain. Represents a particular amount of a
-/// particular token.
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct Asset {
-    pub amount: TokenAmount,
-    pub token: TokenAddress,
-}
-
-/// An amount of native Ether tokens denominated in wei.
-#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, From, Into)]
-pub struct Ether(pub U256);
-
-impl From<Ether> for num::BigInt {
-    fn from(value: Ether) -> Self {
-        num::BigUint::from_bytes_be(value.0.to_be_bytes::<32>().as_slice()).into()
-    }
-}
-
-// TODO: check if actually needed
-impl From<i32> for Ether {
-    fn from(value: i32) -> Self {
-        Self(U256::from(value))
-    }
-}
-
-impl std::ops::Add for Ether {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl num::Zero for Ether {
-    fn zero() -> Self {
-        Self(U256::ZERO)
-    }
-
-    fn is_zero(&self) -> bool {
-        self.0.is_zero()
-    }
-}
-
-impl std::iter::Sum for Ether {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        iter.fold(num::Zero::zero(), std::ops::Add::add)
-    }
-}
-
-/// Block number.
-#[derive(Debug, Clone, Copy, From, Into)]
-pub struct BlockNo(pub u64);
-
-/// An onchain transaction which interacts with a smart contract.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Interaction {
-    pub target: Address,
-    pub value: Ether,
-    pub call_data: Bytes,
-}
-
-impl From<Interaction> for model::interaction::InteractionData {
-    fn from(interaction: Interaction) -> Self {
-        Self {
-            target: interaction.target,
-            value: interaction.value.0,
-            call_data: interaction.call_data.to_vec(),
-        }
-    }
-}
-
-impl From<model::interaction::InteractionData> for Interaction {
-    fn from(interaction: model::interaction::InteractionData) -> Self {
-        Self {
-            target: interaction.target,
-            value: interaction.value.into(),
-            call_data: interaction.call_data.into(),
-        }
-    }
-}
-
-/// A transaction ID, AKA transaction hash.
-#[derive(Clone, Debug, From, Into)]
-pub struct TxId(pub B256);
-
-pub enum TxStatus {
-    /// The transaction has been included and executed successfully.
-    Executed { block_number: BlockNo },
-    /// The transaction has been included but execution failed.
-    Reverted { block_number: BlockNo },
-    /// The transaction has not been included yet.
-    Pending,
-}
-
-/// An onchain transaction.
-#[derive(derive_more::Debug, Clone)]
-pub struct Tx {
-    pub from: Address,
-    pub to: Address,
-    pub value: Ether,
-    pub input: Bytes,
-    #[debug(ignore)]
-    pub access_list: AccessList,
-}
-
-impl From<Tx> for TransactionRequest {
-    fn from(value: Tx) -> Self {
-        TransactionRequest::default()
-            .from(value.from)
-            .to(value.to)
-            .value(value.value.0)
-            .input(value.input.into())
-            .access_list(value.access_list.into())
-    }
-}
-
-impl Tx {
-    pub fn set_access_list(self, access_list: AccessList) -> Self {
-        Self {
-            access_list,
-            ..self
-        }
-    }
-}
-
-/// The Keccak-256 hash of a contract's initialization code.
-///
-/// This value is meaningful in the context of the EVM `CREATE2` opcode in that
-/// it influences the deterministic address that the contract ends up on.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub struct CodeDigest(pub B256);
-
-impl From<B256> for CodeDigest {
-    fn from(value: B256) -> Self {
-        Self(value)
-    }
-}
-
-impl From<CodeDigest> for B256 {
-    fn from(value: CodeDigest) -> Self {
-        value.0
-    }
-}
-
-impl From<[u8; 32]> for CodeDigest {
-    fn from(value: [u8; 32]) -> Self {
-        Self(B256::new(value))
-    }
-}
-
-impl From<CodeDigest> for [u8; 32] {
-    fn from(value: CodeDigest) -> Self {
-        value.0.0
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Flashloan {
-    pub liquidity_provider: ContractAddress,
-    pub protocol_adapter: ContractAddress,
-    pub receiver: Address,
-    pub token: TokenAddress,
-    pub amount: TokenAmount,
-}
-
-impl From<&solvers_dto::solution::Flashloan> for Flashloan {
-    fn from(value: &solvers_dto::solution::Flashloan) -> Self {
-        Self {
-            liquidity_provider: value.liquidity_provider.into(),
-            protocol_adapter: value.protocol_adapter.into(),
-            receiver: value.receiver,
-            token: value.token.into(),
-            amount: value.amount.into(),
-        }
-    }
-}
-
-#[expect(clippy::from_over_into)]
-impl Into<FlashloanHint> for &Flashloan {
-    fn into(self) -> FlashloanHint {
-        FlashloanHint {
-            liquidity_provider: self.liquidity_provider.into(),
-            protocol_adapter: self.protocol_adapter.into(),
-            receiver: self.receiver,
-            token: self.token.0.into(),
-            amount: self.amount.into(),
-        }
-    }
-}
diff --git a/crates/driver/src/domain/flashloan.rs b/crates/driver/src/domain/flashloan.rs
new file mode 100644
index 0000000000..8329d29599
--- /dev/null
+++ b/crates/driver/src/domain/flashloan.rs
@@ -0,0 +1,51 @@
+use {
+    eth_domain_types::{Address, ContractAddress, TokenAddress, TokenAmount},
+    solvers_dto::auction::FlashloanHint,
+};
+
+#[derive(Debug, Clone)]
+pub struct Flashloan {
+    pub liquidity_provider: ContractAddress,
+    pub protocol_adapter: ContractAddress,
+    pub receiver: Address,
+    pub token: TokenAddress,
+    pub amount: TokenAmount,
+}
+
+impl From<&solvers_dto::solution::Flashloan> for Flashloan {
+    fn from(value: &solvers_dto::solution::Flashloan) -> Self {
+        Self {
+            liquidity_provider: value.liquidity_provider.into(),
+            protocol_adapter: value.protocol_adapter.into(),
+            receiver: value.receiver,
+            token: value.token.into(),
+            amount: value.amount.into(),
+        }
+    }
+}
+
+#[expect(clippy::from_over_into)]
+impl Into<solvers_dto::solution::Flashloan> for &Flashloan {
+    fn into(self) -> solvers_dto::solution::Flashloan {
+        solvers_dto::solution::Flashloan {
+            liquidity_provider: self.liquidity_provider.into(),
+            protocol_adapter: self.protocol_adapter.into(),
+            receiver: self.receiver,
+            token: self.token.0.into(),
+            amount: self.amount.into(),
+        }
+    }
+}
+
+#[expect(clippy::from_over_into)]
+impl Into<FlashloanHint> for &Flashloan {
+    fn into(self) -> FlashloanHint {
+        FlashloanHint {
+            liquidity_provider: self.liquidity_provider.into(),
+            protocol_adapter: self.protocol_adapter.into(),
+            receiver: self.receiver,
+            token: self.token.0.into(),
+            amount: self.amount.into(),
+        }
+    }
+}
diff --git a/crates/driver/src/domain/interaction.rs b/crates/driver/src/domain/interaction.rs
new file mode 100644
index 0000000000..a1d24c9dcf
--- /dev/null
+++ b/crates/driver/src/domain/interaction.rs
@@ -0,0 +1,32 @@
+use {
+    alloy::primitives::Bytes,
+    eth_domain_types::{Address, Ether},
+};
+
+/// An onchain transaction which interacts with a smart contract.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Interaction {
+    pub target: Address,
+    pub value: Ether,
+    pub call_data: Bytes,
+}
+
+impl From<Interaction> for model::interaction::InteractionData {
+    fn from(interaction: Interaction) -> Self {
+        Self {
+            target: interaction.target,
+            value: interaction.value.0,
+            call_data: interaction.call_data.to_vec(),
+        }
+    }
+}
+
+impl From<model::interaction::InteractionData> for Interaction {
+    fn from(interaction: model::interaction::InteractionData) -> Self {
+        Self {
+            target: interaction.target,
+            value: interaction.value.into(),
+            call_data: interaction.call_data.into(),
+        }
+    }
+}
diff --git a/crates/driver/src/domain/liquidity/balancer/v2/mod.rs b/crates/driver/src/domain/liquidity/balancer/v2/mod.rs
index 0792e49d56..fc82db96a2 100644
--- a/crates/driver/src/domain/liquidity/balancer/v2/mod.rs
+++ b/crates/driver/src/domain/liquidity/balancer/v2/mod.rs
@@ -1,6 +1,6 @@
 use {
-    crate::domain::eth,
     derive_more::{From, Into},
+    eth_domain_types as eth,
 };
 
 pub mod stable;
diff --git a/crates/driver/src/domain/liquidity/balancer/v2/stable.rs b/crates/driver/src/domain/liquidity/balancer/v2/stable.rs
index fbcdbbdb6d..c2013c2274 100644
--- a/crates/driver/src/domain/liquidity/balancer/v2/stable.rs
+++ b/crates/driver/src/domain/liquidity/balancer/v2/stable.rs
@@ -2,8 +2,9 @@ use {
     super::{Fee, Id, ScalingFactor},
     crate::{
         boundary,
-        domain::{eth, liquidity},
+        domain::{self, liquidity},
     },
+    eth_domain_types as eth,
     itertools::Itertools,
 };
 
@@ -32,7 +33,7 @@ impl Pool {
         input: &liquidity::MaxInput,
         output: &liquidity::ExactOutput,
         receiver: &eth::Address,
-    ) -> Result<eth::Interaction, liquidity::InvalidSwap> {
+    ) -> Result<domain::Interaction, liquidity::InvalidSwap> {
         if !self.reserves.has_tokens(&input.0.token, &output.0.token) {
             return Err(liquidity::InvalidSwap);
         }
diff --git a/crates/driver/src/domain/liquidity/balancer/v2/weighted.rs b/crates/driver/src/domain/liquidity/balancer/v2/weighted.rs
index 24f4fa55ca..df0a5debc8 100644
--- a/crates/driver/src/domain/liquidity/balancer/v2/weighted.rs
+++ b/crates/driver/src/domain/liquidity/balancer/v2/weighted.rs
@@ -2,8 +2,9 @@ use {
     super::{Fee, Id, ScalingFactor},
     crate::{
         boundary,
-        domain::{eth, liquidity},
+        domain::{self, liquidity},
     },
+    eth_domain_types as eth,
     itertools::Itertools,
 };
 
@@ -37,7 +38,7 @@ impl Pool {
         input: &liquidity::MaxInput,
         output: &liquidity::ExactOutput,
         receiver: &eth::Address,
-    ) -> Result<eth::Interaction, liquidity::InvalidSwap> {
+    ) -> Result<domain::Interaction, liquidity::InvalidSwap> {
         if !self.reserves.has_tokens(&input.0.token, &output.0.token) {
             return Err(liquidity::InvalidSwap);
         }
diff --git a/crates/driver/src/domain/liquidity/mod.rs b/crates/driver/src/domain/liquidity/mod.rs
index 2544958ec0..f72e51e8bc 100644
--- a/crates/driver/src/domain/liquidity/mod.rs
+++ b/crates/driver/src/domain/liquidity/mod.rs
@@ -2,8 +2,8 @@
 #![allow(dead_code)]
 
 use {
-    crate::domain::eth,
     derive_more::{From, Into},
+    eth_domain_types as eth,
     std::cmp::Ordering,
 };
 
diff --git a/crates/driver/src/domain/liquidity/swapr.rs b/crates/driver/src/domain/liquidity/swapr.rs
index fd96d584af..41e5210449 100644
--- a/crates/driver/src/domain/liquidity/swapr.rs
+++ b/crates/driver/src/domain/liquidity/swapr.rs
@@ -1,6 +1,9 @@
-use crate::domain::{
-    eth,
-    liquidity::{self, uniswap},
+use {
+    crate::domain::{
+        self,
+        liquidity::{self, uniswap},
+    },
+    eth_domain_types as eth,
 };
 
 /// The famous Uniswap V2 constant product pool with a twist of lemon,
@@ -26,7 +29,7 @@ impl Pool {
         input: &liquidity::MaxInput,
         output: &liquidity::ExactOutput,
         receiver: &eth::Address,
-    ) -> Result<eth::Interaction, liquidity::InvalidSwap> {
+    ) -> Result<domain::Interaction, liquidity::InvalidSwap> {
         // Note that swap interactions are identical in Swapr and Uniswap V2
         // pools. The only difference is the input/output computation uses
         // different fees.
diff --git a/crates/driver/src/domain/liquidity/uniswap/v2.rs b/crates/driver/src/domain/liquidity/uniswap/v2.rs
index 07ee2e2667..d5f6a8d136 100644
--- a/crates/driver/src/domain/liquidity/uniswap/v2.rs
+++ b/crates/driver/src/domain/liquidity/uniswap/v2.rs
@@ -1,8 +1,9 @@
 use {
     crate::{
         boundary,
-        domain::{eth, liquidity},
+        domain::{self, liquidity},
     },
+    eth_domain_types as eth,
     std::cmp::Ordering,
 };
 
@@ -31,7 +32,7 @@ impl Pool {
         input: &liquidity::MaxInput,
         output: &liquidity::ExactOutput,
         receiver: &eth::Address,
-    ) -> Result<eth::Interaction, liquidity::InvalidSwap> {
+    ) -> Result<domain::Interaction, liquidity::InvalidSwap> {
         if !self.reserves.has_tokens(&input.0.token, &output.0.token) {
             return Err(liquidity::InvalidSwap);
         }
diff --git a/crates/driver/src/domain/liquidity/uniswap/v3.rs b/crates/driver/src/domain/liquidity/uniswap/v3.rs
index 8325db95a5..bd1de68744 100644
--- a/crates/driver/src/domain/liquidity/uniswap/v3.rs
+++ b/crates/driver/src/domain/liquidity/uniswap/v3.rs
@@ -2,11 +2,12 @@ use {
     crate::{
         boundary,
         domain::{
-            eth,
+            self,
             liquidity::{self, InvalidSwap},
         },
     },
     derive_more::Debug,
+    eth_domain_types as eth,
     std::collections::BTreeMap,
 };
 
@@ -66,7 +67,7 @@ impl Pool {
         input: &liquidity::MaxInput,
         output: &liquidity::ExactOutput,
         receiver: &eth::Address,
-    ) -> Result<eth::Interaction, InvalidSwap> {
+    ) -> Result<domain::Interaction, InvalidSwap> {
         let tokens_match = (input.0.token == self.tokens.0 && output.0.token == self.tokens.1)
             || (input.0.token == self.tokens.1 && output.0.token == self.tokens.0);
 
diff --git a/crates/driver/src/domain/liquidity/zeroex.rs b/crates/driver/src/domain/liquidity/zeroex.rs
index d74bac5fa6..ff112eabd7 100644
--- a/crates/driver/src/domain/liquidity/zeroex.rs
+++ b/crates/driver/src/domain/liquidity/zeroex.rs
@@ -1,5 +1,5 @@
 use {
-    crate::domain::{eth, liquidity},
+    crate::domain::{self, liquidity},
     alloy::primitives::{Address, B256, U256},
     anyhow::anyhow,
     contracts::alloy::IZeroex,
@@ -47,7 +47,10 @@ pub struct ZeroExSignature {
 }
 
 impl LimitOrder {
-    pub fn to_interaction(&self, input: &liquidity::MaxInput) -> anyhow::Result<eth::Interaction> {
+    pub fn to_interaction(
+        &self,
+        input: &liquidity::MaxInput,
+    ) -> anyhow::Result<domain::Interaction> {
         let method = self.zeroex.fillOrKillLimitOrder(
             IZeroex::LibNativeOrder::LimitOrder {
                 makerToken: self.order.maker_token,
@@ -78,7 +81,7 @@ impl LimitOrder {
         );
         let calldata = method.calldata();
 
-        Ok(eth::Interaction {
+        Ok(domain::Interaction {
             target: *self.zeroex.address(),
             value: 0.into(),
             call_data: calldata.to_vec().into(),
diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index 2b85a8f88e..314a4c6b04 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -1,18 +1,16 @@
 use {
-    super::{competition::solution::settlement, eth},
+    super::competition::solution::settlement,
     crate::{
-        domain::{
-            BlockNo,
-            competition::solution::Settlement,
-            eth::{TxId, TxStatus},
-        },
+        domain::{blockchain::TxStatus, competition::solution::Settlement},
         infra::{self, Ethereum, observe},
     },
     alloy::{consensus::Transaction, eips::eip1559::Eip1559Estimation, sol_types::SolCall},
     anyhow::Context,
     contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
+    eth_domain_types::{self as eth, BlockNo, TxId},
     ethrpc::block_stream::into_stream,
     futures::{FutureExt, StreamExt, future::select_ok},
+    num::Saturating,
     thiserror::Error,
     tracing::Instrument,
 };
@@ -132,8 +130,8 @@ impl Mempools {
                         "settlement tx simulation reverted before submitting to the mempool"
                     );
                     return Err(Error::SimulationRevert {
-                        submitted_at_block: current_block,
-                        reverted_at_block: current_block,
+                        submitted_at_block: current_block.into(),
+                        reverted_at_block: current_block.into(),
                     });
                 } else {
                     tracing::warn!(
@@ -157,7 +155,7 @@ impl Mempools {
             .gas_price()
             .await
             .context("failed to compute current gas price")?;
-        let submission_block = self.ethereum.current_block().borrow().number;
+        let submission_block = self.ethereum.current_block().borrow().number.into();
         let blocks_until_deadline = submission_deadline.saturating_sub(submission_block);
 
         // if there is still a tx pending we also have to make sure we outbid that one
@@ -175,8 +173,8 @@ impl Mempools {
         };
 
         tracing::debug!(
-            submission_block,
-            blocks_until_deadline,
+            ?submission_block,
+            ?blocks_until_deadline,
             ?replacement_gas_price,
             ?current_gas_price,
             ?final_gas_price,
@@ -207,22 +205,22 @@ impl Mempools {
                     });
                 match receipt {
                     TxStatus::Executed { block_number } => return Ok(SubmissionSuccess {
-                        tx_hash: hash.clone(),
-                        submitted_at_block: submission_block.into(),
+                        tx_hash: hash,
+                        submitted_at_block: submission_block,
                         included_in_block: block_number,
                     }),
                     TxStatus::Reverted { block_number } => {
                         return Err(Error::Revert {
-                            tx_id: hash.clone(),
+                            tx_id: hash,
                             submitted_at_block: submission_block,
-                            reverted_at_block: block_number.into(),
+                            reverted_at_block: block_number,
                         })
                     }
                     TxStatus::Pending => {
                         // Check if the current block reached the submission deadline block number
-                        if block.number >= submission_deadline {
+                        if BlockNo(block.number) >= submission_deadline {
                             tracing::debug!(
-                                submission_deadline,
+                                submission_deadline = submission_deadline.0,
                                 current_block = block.number,
                                 settle_tx_hash = ?hash,
                                 "exceeded submission deadline, cancelling"
@@ -231,7 +229,7 @@ impl Mempools {
                                 .cancel(mempool, final_gas_price, signer, nonce)
                                 .await;
                             return Err(Error::Expired {
-                                tx_id: hash.clone(),
+                                tx_id: hash,
                                 submitted_at_block: submission_block,
                                 submission_deadline,
                             });
@@ -249,7 +247,7 @@ impl Mempools {
                                     .await;
                                 return Err(Error::SimulationRevert {
                                     submitted_at_block: submission_block,
-                                    reverted_at_block: block.number,
+                                    reverted_at_block: block.number.into(),
                                 });
                             } else {
                                 tracing::warn!(?hash, ?err, "couldn't re-simulate tx");
@@ -278,7 +276,7 @@ impl Mempools {
                 return Ok(SubmissionSuccess {
                     tx_hash: hash,
                     included_in_block: block_number,
-                    submitted_at_block: submission_block.into(),
+                    submitted_at_block: submission_block,
                 });
             }
         }
diff --git a/crates/driver/src/domain/mod.rs b/crates/driver/src/domain/mod.rs
index cc7bb1bc7d..29590c611a 100644
--- a/crates/driver/src/domain/mod.rs
+++ b/crates/driver/src/domain/mod.rs
@@ -1,6 +1,8 @@
+pub mod blockchain;
 pub mod competition;
 pub mod cow_amm;
-pub mod eth;
+pub mod flashloan;
+pub mod interaction;
 pub mod liquidity;
 pub mod mempools;
 pub mod quote;
@@ -8,8 +10,8 @@ pub mod time;
 
 pub use {
     competition::Competition,
+    flashloan::Flashloan,
+    interaction::Interaction,
     liquidity::Liquidity,
     mempools::{Mempools, RevertProtection},
 };
-
-pub type BlockNo = u64;
diff --git a/crates/driver/src/domain/quote.rs b/crates/driver/src/domain/quote.rs
index ee25380a40..769f7f3f4b 100644
--- a/crates/driver/src/domain/quote.rs
+++ b/crates/driver/src/domain/quote.rs
@@ -3,8 +3,8 @@ use {
     crate::{
         boundary,
         domain::{
+            self,
             competition::{self, order},
-            eth,
             liquidity,
             time,
         },
@@ -16,6 +16,7 @@ use {
         util,
     },
     chrono::Utc,
+    eth_domain_types as eth,
     std::collections::{HashMap, HashSet},
 };
 
@@ -24,9 +25,9 @@ use {
 pub struct Quote {
     pub clearing_prices: HashMap<eth::Address, eth::U256>,
     #[debug(ignore)]
-    pub pre_interactions: Vec<eth::Interaction>,
+    pub pre_interactions: Vec<domain::Interaction>,
     #[debug(ignore)]
-    pub interactions: Vec<eth::Interaction>,
+    pub interactions: Vec<domain::Interaction>,
     pub solver: eth::Address,
     pub gas: Option<eth::Gas>,
     /// Which `tx.origin` is required to make the quote simulation pass.
@@ -298,14 +299,9 @@ impl Tokens {
 
 mod encode {
     use {
-        crate::domain::{
-            competition::solution,
-            eth::{
-                self,
-                allowance::{Approval, Required},
-            },
-        },
+        crate::domain::{self, competition::solution},
         alloy::primitives::Address,
+        eth_domain_types::allowance::{Approval, Required},
         num::rational::Ratio,
     };
 
@@ -314,7 +310,7 @@ mod encode {
     pub(super) fn interaction(
         interaction: &solution::Interaction,
         settlement: &Address,
-    ) -> Result<Vec<eth::Interaction>, solution::encoding::Error> {
+    ) -> Result<Vec<domain::Interaction>, solution::encoding::Error> {
         let slippage = solution::slippage::Parameters {
             relative: Ratio::new_raw(DEFAULT_QUOTE_SLIPPAGE_BPS.into(), 10_000.into()),
             max: None,
@@ -323,9 +319,9 @@ mod encode {
         };
 
         let encoded = match interaction {
-            solution::Interaction::Custom(interaction) => eth::Interaction {
+            solution::Interaction::Custom(interaction) => domain::Interaction {
                 value: interaction.value,
-                target: interaction.target.0,
+                target: *interaction.target,
                 call_data: interaction.call_data.clone(),
             },
             solution::Interaction::Liquidity(liquidity) => {
diff --git a/crates/driver/src/infra/api/routes/quote/dto/order.rs b/crates/driver/src/infra/api/routes/quote/dto/order.rs
index be8ef90319..64449b6a4b 100644
--- a/crates/driver/src/infra/api/routes/quote/dto/order.rs
+++ b/crates/driver/src/infra/api/routes/quote/dto/order.rs
@@ -1,5 +1,6 @@
 use {
-    crate::domain::{competition, eth, quote},
+    crate::domain::{competition, quote},
+    eth_domain_types as eth,
     serde::Deserialize,
     serde_with::serde_as,
 };
diff --git a/crates/driver/src/infra/api/routes/quote/dto/quote.rs b/crates/driver/src/infra/api/routes/quote/dto/quote.rs
index 2b5b1038de..ceabcf48d4 100644
--- a/crates/driver/src/infra/api/routes/quote/dto/quote.rs
+++ b/crates/driver/src/infra/api/routes/quote/dto/quote.rs
@@ -1,5 +1,6 @@
 use {
-    crate::domain::{self, competition::solution::encoding::codec, eth, quote},
+    crate::domain::{self, competition::solution::encoding::codec, quote},
+    eth_domain_types as eth,
     model::{
         order::{BuyTokenDestination, SellTokenSource},
         signature::SigningScheme,
@@ -54,8 +55,8 @@ struct Interaction {
     call_data: Vec<u8>,
 }
 
-impl From<eth::Interaction> for Interaction {
-    fn from(interaction: eth::Interaction) -> Self {
+impl From<domain::Interaction> for Interaction {
+    fn from(interaction: domain::Interaction) -> Self {
         Self {
             target: interaction.target,
             value: interaction.value.into(),
diff --git a/crates/driver/src/infra/api/routes/settle/mod.rs b/crates/driver/src/infra/api/routes/settle/mod.rs
index fe3634da69..047b062e01 100644
--- a/crates/driver/src/infra/api/routes/settle/mod.rs
+++ b/crates/driver/src/infra/api/routes/settle/mod.rs
@@ -30,7 +30,7 @@ async fn route(
             .settle(
                 auction_id,
                 req.solution_id,
-                req.submission_deadline_latest_block,
+                req.submission_deadline_latest_block.into(),
             )
             .await;
         result.map(|_| ()).map_err(Into::into)
diff --git a/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs b/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs
index 4818112e88..875e6b3e83 100644
--- a/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs
+++ b/crates/driver/src/infra/api/routes/solve/dto/solve_request.rs
@@ -1,6 +1,7 @@
 use {
     crate::{
         domain::{
+            self,
             competition::{
                 self,
                 auction,
@@ -9,10 +10,10 @@ use {
                     app_data::{AppData, AppDataHash},
                 },
             },
-            eth,
         },
         infra::{Ethereum, tokens},
     },
+    eth_domain_types as eth,
     serde::Deserialize,
     serde_with::serde_as,
     std::{
@@ -81,7 +82,7 @@ impl SolveRequest {
                     pre_interactions: order
                         .pre_interactions
                         .into_iter()
-                        .map(|interaction| eth::Interaction {
+                        .map(|interaction| domain::Interaction {
                             target: interaction.target,
                             value: interaction.value.into(),
                             call_data: interaction.call_data.into(),
@@ -90,7 +91,7 @@ impl SolveRequest {
                     post_interactions: order
                         .post_interactions
                         .into_iter()
-                        .map(|interaction| eth::Interaction {
+                        .map(|interaction| domain::Interaction {
                             target: interaction.target,
                             value: interaction.value.into(),
                             call_data: interaction.call_data.into(),
diff --git a/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs b/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
index c7777f950e..4b8f1e66b2 100644
--- a/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
+++ b/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
@@ -1,8 +1,9 @@
 use {
     crate::{
-        domain::{competition, competition::order, eth},
+        domain::{competition, competition::order},
         infra::Solver,
     },
+    eth_domain_types as eth,
     serde::Serialize,
     serde_with::serde_as,
     std::collections::HashMap,
diff --git a/crates/driver/src/infra/blockchain/contracts.rs b/crates/driver/src/infra/blockchain/contracts.rs
index 4b19cc1226..a5f58e3960 100644
--- a/crates/driver/src/infra/blockchain/contracts.rs
+++ b/crates/driver/src/infra/blockchain/contracts.rs
@@ -1,5 +1,4 @@
 use {
-    crate::domain::eth,
     chain::Chain,
     contracts::alloy::{
         BalancerV2Vault,
@@ -8,6 +7,7 @@ use {
         WETH9,
         support::Balances,
     },
+    eth_domain_types as eth,
     ethrpc::Web3,
     std::collections::HashMap,
 };
@@ -100,8 +100,10 @@ impl Contracts {
         // TODO: use `address_for()` once contracts are deployed
         let flashloan_router = addresses
             .flashloan_router
-            .or_else(|| FlashLoanRouter::deployment_address(&chain.id()).map(eth::ContractAddress))
-            .map(|address| FlashLoanRouter::Instance::new(address.0, web3.provider.clone()));
+            .or_else(|| {
+                FlashLoanRouter::deployment_address(&chain.id()).map(eth::ContractAddress::from)
+            })
+            .map(|address| FlashLoanRouter::Instance::new(*address, web3.provider.clone()));
 
         Ok(Self {
             settlement,
@@ -137,7 +139,7 @@ impl Contracts {
         &self.weth
     }
 
-    pub fn weth_address(&self) -> eth::WethAddress {
+    pub fn weth_address(&self) -> eth::WrappedNativeToken {
         (*self.weth.address()).into()
     }
 
diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index 9fcb40ffd3..27759ae1e0 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -4,12 +4,10 @@
 /// private submission networks are used.
 use {
     super::Error,
-    crate::{
-        domain::eth,
-        infra::{config::file::GasEstimatorType, mempool},
-    },
+    crate::infra::{config::file::GasEstimatorType, mempool},
     alloy::eips::eip1559::Eip1559Estimation,
     anyhow::anyhow,
+    eth_domain_types as eth,
     ethrpc::Web3,
     gas_price_estimation::{
         GasPriceEstimating,
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 5ff65d2dec..9bdc9b9803 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -1,8 +1,5 @@
 use {
-    crate::{
-        boundary,
-        domain::{eth, eth::U256},
-    },
+    crate::{boundary, domain::blockchain::TxStatus},
     account_balances::{BalanceSimulator, SimulationError},
     alloy::{
         eips::eip1559::Eip1559Estimation,
@@ -14,6 +11,7 @@ use {
     anyhow::anyhow,
     balance_overrides::{BalanceOverrides, BalanceOverriding},
     chain::Chain,
+    eth_domain_types::{self as eth, U256},
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     gas_price_estimation::Eip1559EstimationExt,
     shared::web3,
@@ -123,7 +121,7 @@ impl Ethereum {
         let balance_simulator = BalanceSimulator::new(
             contracts.settlement().clone(),
             contracts.balance_helper().clone(),
-            contracts.vault_relayer().0,
+            *contracts.vault_relayer(),
             Some(*contracts.vault().address()),
             balance_overrider.clone(),
         );
@@ -259,7 +257,7 @@ impl Ethereum {
     }
 
     /// Returns the transaction's on-chain inclusion status.
-    pub async fn transaction_status(&self, tx_hash: &eth::TxId) -> Result<eth::TxStatus, Error> {
+    pub async fn transaction_status(&self, tx_hash: &eth::TxId) -> Result<TxStatus, Error> {
         self.web3
             .provider
             .get_transaction_receipt(tx_hash.0)
@@ -272,15 +270,15 @@ impl Ethereum {
                     },
                 ) = result
                 else {
-                    return eth::TxStatus::Pending;
+                    return TxStatus::Pending;
                 };
 
                 if receipt.status() {
-                    eth::TxStatus::Executed {
+                    TxStatus::Executed {
                         block_number: eth::BlockNo(block_number),
                     }
                 } else {
-                    eth::TxStatus::Reverted {
+                    TxStatus::Reverted {
                         block_number: eth::BlockNo(block_number),
                     }
                 }
diff --git a/crates/driver/src/infra/blockchain/token.rs b/crates/driver/src/infra/blockchain/token.rs
index 1f4aa4227c..e95af850ef 100644
--- a/crates/driver/src/infra/blockchain/token.rs
+++ b/crates/driver/src/infra/blockchain/token.rs
@@ -1,6 +1,6 @@
 use {
     super::{Error, Ethereum},
-    crate::domain::eth,
+    eth_domain_types as eth,
     ethrpc::alloy::errors::ContractErrorExt,
 };
 
@@ -14,7 +14,7 @@ pub struct Erc20 {
 impl Erc20 {
     pub(super) fn new(eth: &Ethereum, address: eth::TokenAddress) -> Self {
         Self {
-            token: contracts::alloy::ERC20::Instance::new(address.0.0, eth.web3.provider.clone()),
+            token: contracts::alloy::ERC20::Instance::new(*address, eth.web3.provider.clone()),
         }
     }
 
diff --git a/crates/driver/src/infra/config/file/load.rs b/crates/driver/src/infra/config/file/load.rs
index 849a1a20cb..cf4534f4d9 100644
--- a/crates/driver/src/infra/config/file/load.rs
+++ b/crates/driver/src/infra/config/file/load.rs
@@ -1,6 +1,6 @@
 use {
     crate::{
-        domain::{competition::risk_detector, eth},
+        domain::competition::risk_detector,
         infra::{
             self,
             blockchain,
@@ -14,6 +14,7 @@ use {
     },
     alloy::signers::{aws::AwsSigner, local::PrivateKeySigner},
     chain::Chain,
+    eth_domain_types as eth,
     futures::future::join_all,
     number::conversions::big_decimal_to_big_rational,
     std::path::Path,
@@ -96,7 +97,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                         .iter()
                         .map(|(token, supported)| {
                             (
-                                eth::TokenAddress(eth::ContractAddress(*token)),
+                                eth::TokenAddress::from(*token),
                                 match supported {
                                     true => risk_detector::Quality::Supported,
                                     false => risk_detector::Quality::Unsupported,
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index 79f1428f7b..3b0da7cec4 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -1,7 +1,8 @@
 pub use load::load;
 use {
-    crate::{domain::eth, infra},
+    crate::infra,
     alloy::{eips::BlockNumberOrTag, primitives::Address},
+    eth_domain_types as eth,
     gas_price_estimation::configurable_alloy::{default_past_blocks, default_reward_percentile},
     number::serialization::HexOrDecimalU256,
     reqwest::Url,
diff --git a/crates/driver/src/infra/config/mod.rs b/crates/driver/src/infra/config/mod.rs
index 26e0b84c72..43332eaffd 100644
--- a/crates/driver/src/infra/config/mod.rs
+++ b/crates/driver/src/infra/config/mod.rs
@@ -1,16 +1,14 @@
 use {
-    crate::{
-        domain::eth,
-        infra::{
-            blockchain,
-            config::file::{AppDataFetching, GasEstimatorType, OrderPriorityStrategy},
-            liquidity,
-            mempool,
-            notify,
-            simulator,
-            solver,
-        },
+    crate::infra::{
+        blockchain,
+        config::file::{AppDataFetching, GasEstimatorType, OrderPriorityStrategy},
+        liquidity,
+        mempool,
+        notify,
+        simulator,
+        solver,
     },
+    eth_domain_types as eth,
     std::time::Duration,
 };
 
diff --git a/crates/driver/src/infra/liquidity/config.rs b/crates/driver/src/infra/liquidity/config.rs
index 7cab7f8fcf..4540268a01 100644
--- a/crates/driver/src/infra/liquidity/config.rs
+++ b/crates/driver/src/infra/liquidity/config.rs
@@ -1,9 +1,10 @@
 use {
-    crate::domain::eth::{self, ContractAddress},
+    crate::domain::blockchain::CodeDigest,
     alloy::primitives::Address,
     chain::Chain,
     contracts::alloy::BalancerV2Vault,
     derive_more::Debug,
+    eth_domain_types::{self as eth, ContractAddress},
     hex_literal::hex,
     liquidity_sources::uniswap_v2::{
         BAOSWAP_INIT,
@@ -51,7 +52,7 @@ pub struct UniswapV2 {
     pub router: eth::ContractAddress,
     /// The digest of the pool initialization code. This digest is used for
     /// computing the deterministic pool addresses per token pair.
-    pub pool_code: eth::CodeDigest,
+    pub pool_code: CodeDigest,
     /// How long liquidity should not be fetched for a token pair that didn't
     /// return useful liquidity before allowing to fetch it again.
     pub missing_pool_cache_time: Duration,
@@ -139,7 +140,7 @@ pub struct Swapr {
     pub router: eth::ContractAddress,
     /// The digest of the pool initialization code. This digest is used for
     /// computing the deterministic pool addresses per token pair.
-    pub pool_code: eth::CodeDigest,
+    pub pool_code: CodeDigest,
     /// How long liquidity should not be fetched for a token pair that didn't
     /// return useful liquidity before allowing to fetch it again.
     pub missing_pool_cache_time: Duration,
@@ -252,7 +253,7 @@ impl BalancerV2 {
         }
 
         Some(Self {
-            vault: ContractAddress(BalancerV2Vault::deployment_address(&chain.id())?),
+            vault: ContractAddress::from(BalancerV2Vault::deployment_address(&chain.id())?),
             weighted: address_for!(
                 chain,
                 [
diff --git a/crates/driver/src/infra/mempool/mod.rs b/crates/driver/src/infra/mempool/mod.rs
index dc580dcc52..5b7d3c9884 100644
--- a/crates/driver/src/infra/mempool/mod.rs
+++ b/crates/driver/src/infra/mempool/mod.rs
@@ -1,7 +1,7 @@
 use {
     crate::{
         boundary::{Web3, unbuffered_web3},
-        domain::{eth, mempools},
+        domain::mempools,
         infra::{self, solver::Account},
     },
     alloy::{
@@ -13,6 +13,7 @@ use {
     },
     anyhow::Context,
     dashmap::DashMap,
+    eth_domain_types as eth,
     std::sync::Arc,
     url::Url,
 };
diff --git a/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs b/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
index 9ea3292280..53de34df80 100644
--- a/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
+++ b/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
@@ -85,8 +85,8 @@ impl LiquiditySourceNotifying for Notifier {
 mod utils {
     use {
         crate::domain::{
+            self,
             competition::solution::{self, Settlement},
-            eth,
         },
         alloy::{primitives::Address, sol_types::SolCall},
         contracts::alloy::LiquoriceSettlement,
@@ -112,7 +112,7 @@ mod utils {
                     .iter()
                     .filter_map(|interaction| match interaction {
                         solution::Interaction::Custom(custom) => extract_rfq_id_from_interaction(
-                            &eth::Interaction {
+                            &domain::Interaction {
                                 target: custom.target.into(),
                                 value: custom.value,
                                 call_data: custom.call_data.clone(),
@@ -141,7 +141,7 @@ mod utils {
     /// `settleSingle` function of the LiquoriceSettlement contract
     /// <https://etherscan.io/address/0x0448633eb8b0a42efed924c42069e0dcf08fb552#code#F8#L83>
     pub fn extract_rfq_id_from_interaction(
-        interaction: &eth::Interaction,
+        interaction: &domain::Interaction,
         liquorice_settlement_contract_address: Address,
     ) -> Option<String> {
         if interaction.target != liquorice_settlement_contract_address {
@@ -161,7 +161,7 @@ mod utils {
     mod tests {
         use {
             crate::{
-                domain::eth,
+                domain,
                 infra::notify::liquidity_sources::liquorice::notifier::utils::extract_rfq_id_from_interaction,
             },
             alloy::primitives::{Address, Bytes},
@@ -173,7 +173,7 @@ mod utils {
 
             let liquorice_settlement_address = Address::random();
             let rfq_id = extract_rfq_id_from_interaction(
-                &eth::Interaction {
+                &domain::Interaction {
                     target: liquorice_settlement_address,
                     call_data: calldata.into(),
                     value: 0.into(),
@@ -188,7 +188,7 @@ mod utils {
         fn test_returns_none_for_arbitrary_call() {
             let liquorice_settlement_address = Address::random();
             let rfq_id = extract_rfq_id_from_interaction(
-                &eth::Interaction {
+                &domain::Interaction {
                     target: liquorice_settlement_address,
                     call_data: Bytes::new(),
                     value: 0.into(),
@@ -202,7 +202,7 @@ mod utils {
         #[test]
         fn test_returns_none_for_different_target() {
             let rfq_id = extract_rfq_id_from_interaction(
-                &eth::Interaction {
+                &domain::Interaction {
                     target: Address::random(),
                     call_data: Bytes::new(),
                     value: 0.into(),
diff --git a/crates/driver/src/infra/notify/mod.rs b/crates/driver/src/infra/notify/mod.rs
index 321335d8c8..a64fed2e3d 100644
--- a/crates/driver/src/infra/notify/mod.rs
+++ b/crates/driver/src/infra/notify/mod.rs
@@ -7,10 +7,7 @@ pub mod liquidity_sources;
 mod notification;
 
 pub use notification::{Kind, Notification, ScoreKind, Settlement, SimulationSucceededAtLeastOnce};
-use {
-    super::simulator,
-    crate::domain::{eth, mempools::Error},
-};
+use {super::simulator, crate::domain::mempools::Error, eth_domain_types as eth};
 
 pub fn solver_timeout(solver: &Solver, auction_id: Option<auction::Id>) {
     solver.notify(auction_id, None, notification::Kind::Timeout);
@@ -105,8 +102,8 @@ pub fn executed(
     res: &Result<eth::TxId, Error>,
 ) {
     let kind = match res {
-        Ok(hash) => notification::Settlement::Success(hash.clone()),
-        Err(Error::Revert { tx_id: hash, .. }) => notification::Settlement::Revert(hash.clone()),
+        Ok(hash) => notification::Settlement::Success(*hash),
+        Err(Error::Revert { tx_id: hash, .. }) => notification::Settlement::Revert(*hash),
         Err(Error::SimulationRevert { .. }) => notification::Settlement::SimulationRevert,
         Err(Error::Expired { .. }) => notification::Settlement::Expired,
         Err(Error::Other(_) | Error::Disabled) => notification::Settlement::Fail,
diff --git a/crates/driver/src/infra/notify/notification.rs b/crates/driver/src/infra/notify/notification.rs
index c8d4e48f21..ab680ad34c 100644
--- a/crates/driver/src/infra/notify/notification.rs
+++ b/crates/driver/src/infra/notify/notification.rs
@@ -1,8 +1,6 @@
 use {
-    crate::domain::{
-        competition::{auction, solution},
-        eth::{self, Ether, TokenAddress},
-    },
+    crate::domain::competition::{auction, solution},
+    eth_domain_types::{self as eth, Ether, TokenAddress},
     std::collections::BTreeSet,
 };
 
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 589275fc31..c257c8f9bb 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -15,7 +15,6 @@ use {
                 Solved,
                 solution::{self, Settlement},
             },
-            eth::{self, Gas},
             mempools::{self, SubmissionSuccess},
             quote::{self, Quote},
             time::{Deadline, Remaining},
@@ -23,7 +22,9 @@ use {
         infra::solver,
         util::http,
     },
+    eth_domain_types::{self as eth, Gas},
     ethrpc::block_stream::BlockInfo,
+    num::Saturating,
     std::{
         collections::{BTreeMap, HashSet},
         time::Duration,
@@ -404,7 +405,7 @@ pub fn mempool_executed(
             submitted_at_block,
             included_in_block,
             ..
-        }) => Some(("Success", &submitted_at_block.0, &included_in_block.0)),
+        }) => Some(("Success", submitted_at_block, included_in_block)),
         Err(mempools::Error::Revert {
             tx_id: _,
             submitted_at_block,
@@ -428,7 +429,7 @@ pub fn mempool_executed(
         metrics::get()
             .mempool_submission_results_blocks_passed
             .with_label_values(&[mempool.to_string().as_str(), label])
-            .inc_by(blocks_passed);
+            .inc_by(blocks_passed.0);
     }
 }
 
diff --git a/crates/driver/src/infra/simulator/enso/dto.rs b/crates/driver/src/infra/simulator/enso/dto.rs
index 4edf5bc511..bad005260c 100644
--- a/crates/driver/src/infra/simulator/enso/dto.rs
+++ b/crates/driver/src/infra/simulator/enso/dto.rs
@@ -1,8 +1,8 @@
 //! Data transfer objects for interacting with the Enso Trade Simulator API.
 
 use {
-    crate::domain::eth,
     alloy::rpc::types::AccessList,
+    eth_domain_types as eth,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
 };
diff --git a/crates/driver/src/infra/simulator/enso/mod.rs b/crates/driver/src/infra/simulator/enso/mod.rs
index 29dcc2d2db..c60d6cb553 100644
--- a/crates/driver/src/infra/simulator/enso/mod.rs
+++ b/crates/driver/src/infra/simulator/enso/mod.rs
@@ -1,6 +1,6 @@
 use {
-    crate::domain::eth,
     chain::Chain,
+    eth_domain_types as eth,
     ethrpc::block_stream::CurrentBlockWatcher,
     reqwest::ClientBuilder,
     std::time::Duration,
diff --git a/crates/driver/src/infra/simulator/mod.rs b/crates/driver/src/infra/simulator/mod.rs
index 8efaf2f9fe..d03988fece 100644
--- a/crates/driver/src/infra/simulator/mod.rs
+++ b/crates/driver/src/infra/simulator/mod.rs
@@ -1,8 +1,6 @@
 use {
-    crate::{
-        domain::eth,
-        infra::blockchain::{self, Ethereum},
-    },
+    crate::infra::blockchain::{self, Ethereum},
+    eth_domain_types as eth,
     observe::future::Measure,
 };
 
@@ -157,7 +155,7 @@ pub enum SimulatorError {
 }
 
 #[derive(Debug, thiserror::Error)]
-#[error("block: {block:?},  err: {err:?}, tx: {tx:?}")]
+#[error("block: {block},  err: {err:?}, tx: {tx:?}")]
 pub struct RevertError {
     pub err: SimulatorError,
     pub tx: eth::Tx,
diff --git a/crates/driver/src/infra/simulator/tenderly/dto.rs b/crates/driver/src/infra/simulator/tenderly/dto.rs
index d697bd2809..5c565edad9 100644
--- a/crates/driver/src/infra/simulator/tenderly/dto.rs
+++ b/crates/driver/src/infra/simulator/tenderly/dto.rs
@@ -1,7 +1,7 @@
 //! Data transfer objects for interacting with the Tenderly API.
 
 use {
-    crate::domain::eth,
+    eth_domain_types as eth,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
 };
diff --git a/crates/driver/src/infra/simulator/tenderly/mod.rs b/crates/driver/src/infra/simulator/tenderly/mod.rs
index 601ec876d1..16cf6fe838 100644
--- a/crates/driver/src/infra/simulator/tenderly/mod.rs
+++ b/crates/driver/src/infra/simulator/tenderly/mod.rs
@@ -1,7 +1,4 @@
-use {
-    crate::{domain::eth, infra::Ethereum},
-    thiserror::Error,
-};
+use {crate::infra::Ethereum, eth_domain_types as eth, thiserror::Error};
 
 mod dto;
 
diff --git a/crates/driver/src/infra/solver/dto/auction.rs b/crates/driver/src/infra/solver/dto/auction.rs
index 6bc212740c..e225a5cdd1 100644
--- a/crates/driver/src/infra/solver/dto/auction.rs
+++ b/crates/driver/src/infra/solver/dto/auction.rs
@@ -1,16 +1,18 @@
 use {
     crate::{
         domain::{
+            self,
+            Flashloan,
             competition::{
                 self,
                 order::{self, Side, fees, signature::Scheme},
             },
-            eth::{self},
             liquidity,
         },
         infra::{config::file::FeeHandler, solver::ManageNativeToken},
     },
     app_data::AppDataHash,
+    eth_domain_types as eth,
     model::order::{BuyTokenDestination, SellTokenSource},
     number::conversions::rational_to_big_decimal,
     std::collections::HashMap,
@@ -22,10 +24,10 @@ pub type WrapperCalls = HashMap<order::Uid, Vec<solvers_dto::auction::WrapperCal
 pub fn new(
     auction: &competition::Auction,
     liquidity: &[liquidity::Liquidity],
-    weth: eth::WethAddress,
+    weth: eth::WrappedNativeToken,
     fee_handler: FeeHandler,
     solver_native_token: ManageNativeToken,
-    flashloan_hints: &HashMap<order::Uid, eth::Flashloan>,
+    flashloan_hints: &HashMap<order::Uid, Flashloan>,
     wrappers: &WrapperCalls,
     deadline: chrono::DateTime<chrono::Utc>,
 ) -> solvers_dto::auction::Auction {
@@ -112,8 +114,8 @@ pub fn new(
                 }
                 solvers_dto::auction::Order {
                     uid: order.uid.into(),
-                    sell_token: available.sell.token.0.0,
-                    buy_token: available.buy.token.0.0,
+                    sell_token: *available.sell.token,
+                    buy_token: *available.buy.token,
                     sell_amount: available.sell.amount.into(),
                     buy_amount: available.buy.amount.into(),
                     full_sell_amount: order.sell.amount.into(),
@@ -182,14 +184,14 @@ pub fn new(
                         solvers_dto::auction::ConstantProductPool {
                             id: liquidity.id.0.to_string(),
                             address: pool.address,
-                            router: pool.router.0,
+                            router: *pool.router,
                             gas_estimate: liquidity.gas.into(),
                             tokens: pool
                                 .reserves
                                 .iter()
                                 .map(|asset| {
                                     (
-                                        asset.token.0.0,
+                                        *asset.token,
                                         solvers_dto::auction::ConstantProductReserve {
                                             balance: asset.amount.into(),
                                         },
@@ -204,10 +206,10 @@ pub fn new(
                     solvers_dto::auction::Liquidity::ConcentratedLiquidity(
                         solvers_dto::auction::ConcentratedLiquidityPool {
                             id: liquidity.id.0.to_string(),
-                            address: pool.address.0,
-                            router: pool.router.0,
+                            address: *pool.address,
+                            router: *pool.router,
                             gas_estimate: liquidity.gas.0,
-                            tokens: vec![pool.tokens.get().0.0.0, pool.tokens.get().1.0.0],
+                            tokens: vec![*pool.tokens.get().0, *pool.tokens.get().1],
                             sqrt_price: pool.sqrt_price.0,
                             liquidity: pool.liquidity.0,
                             tick: pool.tick.0,
@@ -357,7 +359,7 @@ fn fee_policy_from_domain(value: fees::FeePolicy) -> solvers_dto::auction::FeePo
     }
 }
 
-fn interaction_from_domain(value: eth::Interaction) -> solvers_dto::auction::InteractionData {
+fn interaction_from_domain(value: domain::Interaction) -> solvers_dto::auction::InteractionData {
     solvers_dto::auction::InteractionData {
         target: value.target,
         value: value.value.0,
diff --git a/crates/driver/src/infra/solver/dto/notification.rs b/crates/driver/src/infra/solver/dto/notification.rs
index e06a344024..83c5b8fe0a 100644
--- a/crates/driver/src/infra/solver/dto/notification.rs
+++ b/crates/driver/src/infra/solver/dto/notification.rs
@@ -30,7 +30,7 @@ pub fn new(
             notify::Kind::ScoringFailed(scoring) => scoring.into(),
             notify::Kind::NonBufferableTokensUsed(tokens) => {
                 solvers_dto::notification::Kind::NonBufferableTokensUsed {
-                    tokens: tokens.into_iter().map(|token| token.0.0).collect(),
+                    tokens: tokens.into_iter().map(|token| *token).collect(),
                 }
             }
             notify::Kind::SolverAccountInsufficientBalance(required) => {
@@ -83,7 +83,7 @@ impl From<notify::ScoreKind> for solvers_dto::notification::Kind {
             }
             notify::ScoreKind::MissingPrice(token_address) => {
                 solvers_dto::notification::Kind::MissingPrice {
-                    token_address: token_address.0.0,
+                    token_address: *token_address,
                 }
             }
         }
diff --git a/crates/driver/src/infra/solver/dto/solution.rs b/crates/driver/src/infra/solver/dto/solution.rs
index 7b8f627fbd..9973a6b8a3 100644
--- a/crates/driver/src/infra/solver/dto/solution.rs
+++ b/crates/driver/src/infra/solver/dto/solution.rs
@@ -1,14 +1,15 @@
 use {
     crate::{
         domain::{
+            self,
             competition::{self, solution::WrapperCall},
-            eth,
             liquidity,
         },
         infra::Solver,
     },
     alloy::primitives::Bytes,
     app_data::AppDataHash,
+    eth_domain_types as eth,
     itertools::Itertools,
     model::{
         DomainSeparator,
@@ -27,9 +28,9 @@ impl Solutions {
         self,
         auction: &competition::Auction,
         liquidity: &[liquidity::Liquidity],
-        weth: eth::WethAddress,
+        weth: eth::WrappedNativeToken,
         solver: Solver,
-        flashloan_hints: &HashMap<competition::order::Uid, eth::Flashloan>,
+        flashloan_hints: &HashMap<competition::order::Uid, domain::flashloan::Flashloan>,
     ) -> Result<Vec<competition::Solution>, super::Error> {
         let haircut_bps = solver.haircut_bps();
 
@@ -147,7 +148,7 @@ impl Solutions {
                     solution
                         .pre_interactions
                         .into_iter()
-                        .map(|interaction| eth::Interaction {
+                        .map(|interaction| domain::Interaction {
                             target: interaction.target,
                             value: interaction.value.into(),
                             call_data: Bytes::from(interaction.calldata),
@@ -224,7 +225,7 @@ impl Solutions {
                     solution
                         .post_interactions
                         .into_iter()
-                        .map(|interaction| eth::Interaction {
+                        .map(|interaction| domain::Interaction {
                             target: interaction.target,
                             value: interaction.value.into(),
                             call_data: interaction.calldata.into(),
@@ -237,7 +238,7 @@ impl Solutions {
                     auction.surplus_capturing_jit_order_owners(),
                     solution.flashloans
                         // convert the flashloan info provided by the solver
-                        .map(|f| f.iter().map(|(order, loan)| (order.into(), loan.into())).collect())
+                        .map(|f| f.iter().map(|(order, loan)| (order.into(), loan.clone())).collect())
                         // or copy over the relevant flashloan hints from the solve request
                         .unwrap_or_else(|| solution.trades.iter()
                             .filter_map(|t| {
@@ -248,7 +249,7 @@ impl Solutions {
                                 let uid = competition::order::Uid::from(&trade.order);
                                 Some((
                                     uid,
-                                    flashloan_hints.get(&uid).cloned()?,
+                                    flashloan_hints.get(&uid)?.into(),
                                 ))
                             }).collect()),
                     solution.wrappers.iter().cloned().map(|w| WrapperCall {
diff --git a/crates/driver/src/infra/solver/mod.rs b/crates/driver/src/infra/solver/mod.rs
index ec3bcc25ab..0935b9af56 100644
--- a/crates/driver/src/infra/solver/mod.rs
+++ b/crates/driver/src/infra/solver/mod.rs
@@ -2,13 +2,13 @@ use {
     super::notify,
     crate::{
         domain::{
+            self,
             competition::{
                 auction::{self, Auction},
                 order,
                 risk_detector,
                 solution::{self, Solution},
             },
-            eth,
             liquidity,
             time::Remaining,
         },
@@ -28,6 +28,7 @@ use {
     },
     anyhow::Result,
     derive_more::{From, Into},
+    eth_domain_types as eth,
     num::BigRational,
     observe::tracing::distributed::headers::tracing_headers,
     reqwest::header::HeaderName,
@@ -424,7 +425,10 @@ impl Solver {
         Ok(solutions)
     }
 
-    fn assemble_flashloan_hints(&self, auction: &Auction) -> HashMap<order::Uid, eth::Flashloan> {
+    fn assemble_flashloan_hints(
+        &self,
+        auction: &Auction,
+    ) -> HashMap<order::Uid, domain::flashloan::Flashloan> {
         if !self.config.flashloans_enabled {
             return Default::default();
         }
@@ -434,7 +438,7 @@ impl Solver {
             .iter()
             .flat_map(|order| {
                 let hint = order.app_data.flashloan()?;
-                let flashloan = eth::Flashloan {
+                let flashloan = domain::flashloan::Flashloan {
                     liquidity_provider: hint.liquidity_provider.into(),
                     protocol_adapter: hint.protocol_adapter.into(),
                     receiver: hint.receiver,
diff --git a/crates/driver/src/infra/tokens.rs b/crates/driver/src/infra/tokens.rs
index 3125b52101..cf91c35ab1 100644
--- a/crates/driver/src/infra/tokens.rs
+++ b/crates/driver/src/infra/tokens.rs
@@ -1,9 +1,7 @@
 use {
-    crate::{
-        domain::eth,
-        infra::{Ethereum, blockchain},
-    },
+    crate::infra::{Ethereum, blockchain},
     anyhow::Result,
+    eth_domain_types as eth,
     ethrpc::block_stream::{self, CurrentBlockWatcher},
     futures::{FutureExt, StreamExt},
     itertools::Itertools,
diff --git a/crates/driver/src/tests/cases/fees.rs b/crates/driver/src/tests/cases/fees.rs
index fe9b3d7cff..dd4c9829d8 100644
--- a/crates/driver/src/tests/cases/fees.rs
+++ b/crates/driver/src/tests/cases/fees.rs
@@ -1,10 +1,13 @@
-use crate::{
-    domain::{competition::order, eth},
-    infra::config::file::FeeHandler,
-    tests::{
-        self,
-        setup::{ab_order, ab_pool, ab_solution, test_solver},
+use {
+    crate::{
+        domain::competition::order,
+        infra::config::file::FeeHandler,
+        tests::{
+            self,
+            setup::{ab_order, ab_pool, ab_solution, test_solver},
+        },
     },
+    eth_domain_types as eth,
 };
 
 #[tokio::test]
diff --git a/crates/driver/src/tests/cases/haircut.rs b/crates/driver/src/tests/cases/haircut.rs
index a4b6a60fbf..6485ff408b 100644
--- a/crates/driver/src/tests/cases/haircut.rs
+++ b/crates/driver/src/tests/cases/haircut.rs
@@ -3,13 +3,14 @@
 
 use {
     crate::{
-        domain::{competition::order, eth},
+        domain::competition::order,
         tests::{
             self,
             cases::EtherExt,
             setup::{ab_order, ab_pool, ab_solution},
         },
     },
+    eth_domain_types as eth,
     number::{testing::ApproxEq, units::EthUnit},
 };
 
diff --git a/crates/driver/src/tests/cases/jit_orders.rs b/crates/driver/src/tests/cases/jit_orders.rs
index 3f354e75ec..bfa8d4e46d 100644
--- a/crates/driver/src/tests/cases/jit_orders.rs
+++ b/crates/driver/src/tests/cases/jit_orders.rs
@@ -1,22 +1,22 @@
-use crate::{
-    domain::{
-        competition::{order, order::Side},
-        eth,
-    },
-    tests::{
-        self,
-        cases::EtherExt,
-        setup::{
+use {
+    crate::{
+        domain::competition::{order, order::Side},
+        tests::{
             self,
-            ExpectedOrderAmounts,
-            Test,
-            ab_adjusted_pool,
-            ab_liquidity_quote,
-            ab_order,
-            ab_solution,
-            test_solver,
+            cases::EtherExt,
+            setup::{
+                self,
+                ExpectedOrderAmounts,
+                Test,
+                ab_adjusted_pool,
+                ab_liquidity_quote,
+                ab_order,
+                ab_solution,
+                test_solver,
+            },
         },
     },
+    eth_domain_types as eth,
 };
 
 struct Amounts {
diff --git a/crates/driver/src/tests/cases/mod.rs b/crates/driver/src/tests/cases/mod.rs
index 755aaf592a..7b0ac592f2 100644
--- a/crates/driver/src/tests/cases/mod.rs
+++ b/crates/driver/src/tests/cases/mod.rs
@@ -1,8 +1,8 @@
 //! Test cases.
 
 use {
-    crate::domain::eth,
     bigdecimal::{BigDecimal, FromPrimitive, Signed, num_traits::CheckedMul},
+    eth_domain_types as eth,
     num::BigRational,
     number::{conversions::big_decimal_to_big_rational, u256_ext::U256Ext},
     std::str::FromStr,
diff --git a/crates/driver/src/tests/cases/protocol_fees.rs b/crates/driver/src/tests/cases/protocol_fees.rs
index cef17e8ed6..2612528223 100644
--- a/crates/driver/src/tests/cases/protocol_fees.rs
+++ b/crates/driver/src/tests/cases/protocol_fees.rs
@@ -1,20 +1,23 @@
-use crate::{
-    domain::{competition::order, eth},
-    infra::config::file::FeeHandler,
-    tests::{
-        self,
-        cases::EtherExt,
-        setup::{
-            ExpectedOrderAmounts,
-            Test,
-            ab_adjusted_pool,
-            ab_liquidity_quote,
-            ab_order,
-            ab_solution,
-            fee::{Policy, Quote},
-            test_solver,
+use {
+    crate::{
+        domain::competition::order,
+        infra::config::file::FeeHandler,
+        tests::{
+            self,
+            cases::EtherExt,
+            setup::{
+                ExpectedOrderAmounts,
+                Test,
+                ab_adjusted_pool,
+                ab_liquidity_quote,
+                ab_order,
+                ab_solution,
+                fee::{Policy, Quote},
+                test_solver,
+            },
         },
     },
+    eth_domain_types as eth,
 };
 
 struct Amounts {
diff --git a/crates/driver/src/tests/cases/quote.rs b/crates/driver/src/tests/cases/quote.rs
index 5940c4f15e..53b3ee76c5 100644
--- a/crates/driver/src/tests/cases/quote.rs
+++ b/crates/driver/src/tests/cases/quote.rs
@@ -1,12 +1,13 @@
 use {
     crate::{
-        domain::{competition::order, eth},
+        domain::competition::order,
         tests::{
             self,
             cases::EtherExt,
             setup::{self, ab_order, ab_pool, ab_solution},
         },
     },
+    eth_domain_types as eth,
     number::testing::ApproxEq,
 };
 
diff --git a/crates/driver/src/tests/cases/solver_balance.rs b/crates/driver/src/tests/cases/solver_balance.rs
index 7bf57129a6..f4f3d2d2a9 100644
--- a/crates/driver/src/tests/cases/solver_balance.rs
+++ b/crates/driver/src/tests/cases/solver_balance.rs
@@ -1,9 +1,9 @@
-use crate::{
-    domain::eth,
-    tests::{
+use {
+    crate::tests::{
         setup,
         setup::{ab_order, ab_pool, ab_solution, test_solver},
     },
+    eth_domain_types as eth,
 };
 
 /// Test that the `/solve` request errors when solver balance is too low.
diff --git a/crates/driver/src/tests/setup/blockchain.rs b/crates/driver/src/tests/setup/blockchain.rs
index 984e4ed58f..d6096eaf23 100644
--- a/crates/driver/src/tests/setup/blockchain.rs
+++ b/crates/driver/src/tests/setup/blockchain.rs
@@ -1,7 +1,7 @@
 use {
     super::{Asset, Order, Partial},
     crate::{
-        domain::{competition::order, eth},
+        domain::competition::order,
         tests::{self, boundary, cases::EtherExt},
     },
     alloy::{
@@ -22,6 +22,7 @@ use {
         WETH9,
         support::{Balances, Signatures},
     },
+    eth_domain_types as eth,
     ethrpc::{
         Web3,
         alloy::{CallBuilderExt, EvmProviderExt, ProviderExt},
@@ -852,7 +853,7 @@ impl Blockchain {
     pub fn get_token(&self, token: &str) -> Address {
         match token {
             "WETH" => *self.weth.address(),
-            "ETH" => eth::ETH_TOKEN.0.0,
+            "ETH" => *eth::ETH_TOKEN,
             _ => *self.tokens.get(token).unwrap().address(),
         }
     }
diff --git a/crates/driver/src/tests/setup/fee.rs b/crates/driver/src/tests/setup/fee.rs
index 72f8c3aa86..5a7a90d298 100644
--- a/crates/driver/src/tests/setup/fee.rs
+++ b/crates/driver/src/tests/setup/fee.rs
@@ -1,5 +1,5 @@
 use {
-    crate::domain::eth,
+    eth_domain_types as eth,
     number::serialization::HexOrDecimalU256,
     serde_json::json,
     serde_with::serde_as,
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 0be37f3482..d4eb634ddb 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -5,7 +5,6 @@ use {
     crate::{
         domain::{
             competition::order::{self, app_data::AppData},
-            eth,
             time,
         },
         infra::{
@@ -43,6 +42,7 @@ use {
     },
     axum::http::StatusCode,
     bigdecimal::{BigDecimal, FromPrimitive},
+    eth_domain_types as eth,
     ethrpc::Web3,
     futures::future::join_all,
     model::order::{BuyTokenDestination, SellTokenSource},
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index a9c4061975..f67c3819ed 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -7,7 +7,6 @@ use {
     crate::{
         domain::{
             competition::order,
-            eth,
             time::{self},
         },
         infra::{self, Ethereum, blockchain::contracts::Addresses, config::file::FeeHandler},
@@ -16,6 +15,7 @@ use {
     alloy::{primitives::Address, signers::local::PrivateKeySigner},
     const_hex::ToHexExt,
     contracts::alloy::ERC20,
+    eth_domain_types as eth,
     gas_price_estimation::Eip1559EstimationExt,
     itertools::Itertools,
     number::testing::ApproxEq,
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 5b8454b016..4d2d337f3f 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -39,6 +39,7 @@ contracts = { workspace = true }
 cow-amm = { workspace = true }
 database = { workspace = true }
 driver = { workspace = true }
+eth-domain-types = { workspace = true }
 ethrpc = { workspace = true, features = ["test-util"] }
 futures = { workspace = true }
 hex-literal = { workspace = true }
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index e910a3a74a..8370044a4b 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -15,7 +15,6 @@ use {
         ERC20,
         support::{Balances, Signatures},
     },
-    driver::domain::eth::NonZeroU256,
     e2e::setup::{
         DeployedContracts,
         OnchainComponents,
@@ -27,6 +26,7 @@ use {
         run_test,
         wait_for_condition,
     },
+    eth_domain_types::NonZeroU256,
     ethrpc::alloy::CallBuilderExt,
     model::{
         order::{OrderClass, OrderCreation, OrderKind, OrderUid},
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index c861bbc346..a6efffc491 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -18,11 +18,11 @@ use {
     },
     contracts::alloy::ERC20,
     database::byte_array::ByteArray,
-    driver::domain::eth::NonZeroU256,
     e2e::setup::{
         proxy::{OnRequest, ReverseProxy},
         *,
     },
+    eth_domain_types::NonZeroU256,
     ethrpc::alloy::CallBuilderExt,
     model::{
         order::{OrderClass, OrderCreation, OrderKind},
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 23f2bc302e..46a139982b 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -15,8 +15,8 @@ use {
         fee_factor::FeeFactor,
         test_util::TestDefault,
     },
-    driver::domain::eth::NonZeroU256,
     e2e::{assert_approximately_eq, setup::*},
+    eth_domain_types::NonZeroU256,
     ethrpc::alloy::CallBuilderExt,
     model::{
         fee_policy::FeePolicy,
diff --git a/crates/eth-domain-types/src/ether.rs b/crates/eth-domain-types/src/ether.rs
index b836fe0ed5..7bf129f54b 100644
--- a/crates/eth-domain-types/src/ether.rs
+++ b/crates/eth-domain-types/src/ether.rs
@@ -21,6 +21,12 @@ use {
 )]
 pub struct Ether(pub U256);
 
+impl From<i32> for Ether {
+    fn from(value: i32) -> Self {
+        Self(U256::from(value))
+    }
+}
+
 impl From<Ether> for num::BigInt {
     fn from(value: Ether) -> Self {
         num::BigUint::from_bytes_be(value.0.to_be_bytes::<32>().as_slice()).into()
diff --git a/crates/eth-domain-types/src/lib.rs b/crates/eth-domain-types/src/lib.rs
index 4343e1f4aa..238383e10f 100644
--- a/crates/eth-domain-types/src/lib.rs
+++ b/crates/eth-domain-types/src/lib.rs
@@ -93,6 +93,12 @@ pub struct Asset {
 #[derive(Debug, Copy, Clone, From, PartialEq, PartialOrd, Default)]
 pub struct BlockNo(pub u64);
 
+impl std::fmt::Display for BlockNo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Adding blocks to a block number.
 impl std::ops::Add<u64> for BlockNo {
     type Output = BlockNo;
@@ -102,6 +108,16 @@ impl std::ops::Add<u64> for BlockNo {
     }
 }
 
+impl num::Saturating for BlockNo {
+    fn saturating_add(self, v: Self) -> Self {
+        Self(self.0.saturating_add(v.0))
+    }
+
+    fn saturating_sub(self, v: Self) -> Self {
+        Self(self.0.saturating_sub(v.0))
+    }
+}
+
 /// A transaction ID, AKA transaction hash.
 #[derive(Debug, Copy, Clone, From, Default)]
 pub struct TxId(pub B256);

From 01b3ede597fb734e627c9a3ab3af2a14bf8a4abc Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 18 Mar 2026 13:33:23 +0100
Subject: [PATCH 154/219] Add custom solver errors (#4268)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Takes over from #4232 by @ashleychandy.

My changes over the @ashleychandy's PR:
* make enum not tagged for backwards compatibility
* merge in main
* lint

Closes #4232



---

Desc of the original PR:

# Description

Fixes #4222

Previously, when solvers couldn't compute quotes for RWA tokens, they
returned a generic `QuotingFailed` error. This made it difficult for the
frontend to provide helpful feedback.

This change adds support for custom solver errors that can be returned
when quoting fails. Solvers can now indicate specific reasons like:
- `TradingOutsideAllowedWindow`
- `TokenTemporarilySuspended`
- `InsufficientLiquidity`
- `UnauthorizedTrader`
- `Other`

When a solver returns a custom error, the driver propagates it through
the API response so the frontend can display an appropriate error
message.

# Changes

- Added `SolverError` enum with 5 variants in `solvers-dto`
- Added optional `error` field to `Solutions` DTO
- Updated driver to detect and propagate custom solver errors
- Added 5 new error kinds to the API error handler
- Updated observability to track `SolverCustomError` metric
- Updated mock solver in e2e tests

---------

Co-authored-by: ashleychandy <ashleychandy777@gmail.com>
Co-authored-by: Ashley Chandy <76095880+ashleychandy@users.noreply.github.com>
Co-authored-by: José Duarte <duarte.gmj@gmail.com>
---
 Cargo.lock                                    |   1 +
 crates/autopilot/src/infra/api.rs             |  55 +++
 crates/driver/src/infra/api/error.rs          | 113 +++++-
 crates/driver/src/infra/observe/mod.rs        |   2 +
 .../driver/src/infra/solver/dto/solution.rs   |   4 +-
 crates/driver/src/infra/solver/mod.rs         |  38 +-
 crates/e2e/src/setup/solver/mock.rs           |  57 ++-
 crates/e2e/tests/e2e/quoting.rs               | 372 ++++++++++++++++++
 crates/orderbook/src/api.rs                   |  68 +++-
 .../price-estimation/src/competition/mod.rs   |  41 ++
 crates/price-estimation/src/instrumented.rs   |  26 +-
 crates/price-estimation/src/lib.rs            |  57 +++
 .../src/native_price_cache.rs                 |  46 ++-
 .../src/trade_finding/external.rs             | 102 +++++
 .../price-estimation/src/trade_finding/mod.rs | 127 +++++-
 .../src/trade_finding/trade_estimator.rs      |  76 ++++
 crates/solvers-dto/Cargo.toml                 |   1 +
 crates/solvers-dto/src/solution.rs            | 100 ++++-
 .../solvers/src/api/routes/solve/dto/mod.rs   |   2 +-
 .../src/api/routes/solve/dto/solution.rs      |   4 +-
 crates/solvers/src/api/routes/solve/mod.rs    |   2 +-
 21 files changed, 1253 insertions(+), 41 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a1a58b7002..4aea6ce68a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7033,6 +7033,7 @@ dependencies = [
  "number",
  "serde",
  "serde-ext",
+ "serde_json",
  "serde_with",
 ]
 
diff --git a/crates/autopilot/src/infra/api.rs b/crates/autopilot/src/infra/api.rs
index fd37e6dce9..2c3a1127b2 100644
--- a/crates/autopilot/src/infra/api.rs
+++ b/crates/autopilot/src/infra/api.rs
@@ -111,6 +111,12 @@ fn error_to_response(err: PriceEstimationError) -> Response {
         PriceEstimationError::RateLimited => {
             (StatusCode::TOO_MANY_REQUESTS, "Rate limited").into_response()
         }
+        PriceEstimationError::TradingOutsideAllowedWindow { message }
+        | PriceEstimationError::TokenTemporarilySuspended { message }
+        | PriceEstimationError::InsufficientLiquidity { message }
+        | PriceEstimationError::CustomSolverError { message } => {
+            (StatusCode::BAD_REQUEST, message).into_response()
+        }
         PriceEstimationError::UnsupportedOrderType(reason) => (
             StatusCode::BAD_REQUEST,
             format!("Unsupported order type, reason: {reason}"),
@@ -121,3 +127,52 @@ fn error_to_response(err: PriceEstimationError) -> Response {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    async fn assert_bad_request_message(err: PriceEstimationError, expected_message: &str) {
+        let response = error_to_response(err);
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+
+        let body = response.into_body();
+        let body = axum::body::to_bytes(body, usize::MAX).await.unwrap();
+        assert_eq!(std::str::from_utf8(&body).unwrap(), expected_message);
+    }
+
+    #[tokio::test]
+    async fn maps_custom_solver_errors_to_bad_request_with_message() {
+        assert_bad_request_message(
+            PriceEstimationError::TradingOutsideAllowedWindow {
+                message: "outside window".to_string(),
+            },
+            "outside window",
+        )
+        .await;
+
+        assert_bad_request_message(
+            PriceEstimationError::TokenTemporarilySuspended {
+                message: "token suspended".to_string(),
+            },
+            "token suspended",
+        )
+        .await;
+
+        assert_bad_request_message(
+            PriceEstimationError::InsufficientLiquidity {
+                message: "insufficient".to_string(),
+            },
+            "insufficient",
+        )
+        .await;
+
+        assert_bad_request_message(
+            PriceEstimationError::CustomSolverError {
+                message: "custom".to_string(),
+            },
+            "custom",
+        )
+        .await;
+    }
+}
diff --git a/crates/driver/src/infra/api/error.rs b/crates/driver/src/infra/api/error.rs
index b7720c480c..10eb6b0808 100644
--- a/crates/driver/src/infra/api/error.rs
+++ b/crates/driver/src/infra/api/error.rs
@@ -4,9 +4,11 @@ use {
         infra::{api, blockchain},
     },
     serde::Serialize,
+    solvers_dto,
+    std::borrow::Cow,
 };
 
-#[derive(Debug, Clone, Copy, Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize)]
 #[serde(rename_all = "PascalCase")]
 enum Kind {
     QuotingFailed,
@@ -23,13 +25,17 @@ enum Kind {
     FailedToSubmit,
     NoValidOrders,
     MalformedRequest,
+    TradingOutsideAllowedWindow,
+    TokenTemporarilySuspended,
+    InsufficientLiquidity,
+    CustomSolverError,
 }
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Error {
     kind: Kind,
-    description: &'static str,
+    description: Cow<'static, str>,
 }
 
 impl From<Kind> for (axum::http::StatusCode, axum::Json<Error>) {
@@ -57,19 +63,66 @@ impl From<Kind> for (axum::http::StatusCode, axum::Json<Error>) {
             Kind::TooManyPendingSettlements => "Settlement queue is full",
             Kind::NoValidOrders => "No valid orders found in the auction",
             Kind::MalformedRequest => "Could not parse the request",
+            Kind::TradingOutsideAllowedWindow => {
+                "Token can only be traded during specific time windows"
+            }
+            Kind::TokenTemporarilySuspended => "Token is temporarily suspended from trading",
+            Kind::InsufficientLiquidity => "Insufficient liquidity for the requested trade size",
+            Kind::CustomSolverError => "Solver returned a custom error",
         };
         (
             axum::http::StatusCode::BAD_REQUEST,
             axum::Json(Error {
                 kind: value,
-                description,
+                description: description.into(),
             }),
         )
     }
 }
 
+fn map_custom_solver_error(custom_err: &solvers_dto::solution::SolverError) -> (Kind, String) {
+    let (kind, default_message) = match custom_err.code {
+        solvers_dto::solution::SolverErrorCode::TradingOutsideAllowedWindow => (
+            Kind::TradingOutsideAllowedWindow,
+            "Token can only be traded during specific time windows",
+        ),
+        solvers_dto::solution::SolverErrorCode::TokenTemporarilySuspended => (
+            Kind::TokenTemporarilySuspended,
+            "Token is temporarily suspended from trading",
+        ),
+        solvers_dto::solution::SolverErrorCode::InsufficientLiquidity => (
+            Kind::InsufficientLiquidity,
+            "Insufficient liquidity for the requested trade size",
+        ),
+        solvers_dto::solution::SolverErrorCode::Other => {
+            (Kind::CustomSolverError, "Solver returned a custom error")
+        }
+    };
+
+    let message = custom_err
+        .message
+        .clone()
+        .unwrap_or_else(|| default_message.to_string());
+
+    (kind, message)
+}
+
 impl From<quote::Error> for (axum::http::StatusCode, axum::Json<Error>) {
     fn from(value: quote::Error) -> Self {
+        // Check if this is a custom solver error
+        if let quote::Error::Solver(ref solver_err) = value
+            && let Some(custom_err) = solver_err.custom_error()
+        {
+            let (kind, description) = map_custom_solver_error(custom_err);
+            return (
+                axum::http::StatusCode::BAD_REQUEST,
+                axum::Json(Error {
+                    kind,
+                    description: description.into(),
+                }),
+            );
+        }
+
         let error = match value {
             quote::Error::QuotingFailed(_) => Kind::QuotingFailed,
             quote::Error::DeadlineExceeded(_) => Kind::DeadlineExceeded,
@@ -124,3 +177,57 @@ impl From<api::routes::OrderError> for (axum::http::StatusCode, axum::Json<Error
         error.into()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn maps_custom_solver_error_codes_to_kinds_and_default_messages() {
+        let cases = [
+            (
+                solvers_dto::solution::SolverErrorCode::TradingOutsideAllowedWindow,
+                Kind::TradingOutsideAllowedWindow,
+                "Token can only be traded during specific time windows",
+            ),
+            (
+                solvers_dto::solution::SolverErrorCode::TokenTemporarilySuspended,
+                Kind::TokenTemporarilySuspended,
+                "Token is temporarily suspended from trading",
+            ),
+            (
+                solvers_dto::solution::SolverErrorCode::InsufficientLiquidity,
+                Kind::InsufficientLiquidity,
+                "Insufficient liquidity for the requested trade size",
+            ),
+            (
+                solvers_dto::solution::SolverErrorCode::Other,
+                Kind::CustomSolverError,
+                "Solver returned a custom error",
+            ),
+        ];
+
+        for (code, expected_kind, expected_message) in cases {
+            let custom_err = solvers_dto::solution::SolverError {
+                code,
+                message: None,
+            };
+
+            let (kind, message) = map_custom_solver_error(&custom_err);
+            assert_eq!(kind, expected_kind);
+            assert_eq!(message, expected_message);
+        }
+    }
+
+    #[test]
+    fn preserves_custom_solver_error_message_when_provided() {
+        let custom_err = solvers_dto::solution::SolverError {
+            code: solvers_dto::solution::SolverErrorCode::Other,
+            message: Some("downstream solver reason".to_string()),
+        };
+
+        let (kind, message) = map_custom_solver_error(&custom_err);
+        assert!(matches!(kind, Kind::CustomSolverError));
+        assert_eq!(message, "downstream solver reason");
+    }
+}
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index c257c8f9bb..c6acaaa4bc 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -314,6 +314,7 @@ pub fn quoted(solver: &solver::Name, order: &quote::Order, result: &Result<Quote
                             "SolverDeserializeError"
                         }
                         quote::Error::Solver(solver::Error::Dto(_)) => "SolverDtoError",
+                        quote::Error::Solver(solver::Error::CustomError(_)) => "SolverCustomError",
                         quote::Error::Boundary(_) => "Unknown",
                         quote::Error::Encoding(_) => "Encoding",
                     },
@@ -450,6 +451,7 @@ fn competition_error(err: &competition::Error) -> &'static str {
         competition::Error::Solver(solver::Error::Http(_)) => "SolverHttpError",
         competition::Error::Solver(solver::Error::Deserialize(_)) => "SolverDeserializeError",
         competition::Error::Solver(solver::Error::Dto(_)) => "SolverDtoError",
+        competition::Error::Solver(solver::Error::CustomError(_)) => "SolverCustomError",
         competition::Error::SubmissionError => "SubmissionError",
         competition::Error::TooManyPendingSettlements => "TooManyPendingSettlements",
         competition::Error::NoValidOrdersFound => "NoValidOrdersFound",
diff --git a/crates/driver/src/infra/solver/dto/solution.rs b/crates/driver/src/infra/solver/dto/solution.rs
index 9973a6b8a3..8876aa225b 100644
--- a/crates/driver/src/infra/solver/dto/solution.rs
+++ b/crates/driver/src/infra/solver/dto/solution.rs
@@ -19,7 +19,7 @@ use {
 };
 
 #[derive(derive_more::From)]
-pub struct Solutions(solvers_dto::solution::Solutions);
+pub struct Solutions(Vec<solvers_dto::solution::Solution>);
 
 impl Solutions {
     const MAX_BASE_POINT: u32 = 10000;
@@ -34,7 +34,7 @@ impl Solutions {
     ) -> Result<Vec<competition::Solution>, super::Error> {
         let haircut_bps = solver.haircut_bps();
 
-        self.0.solutions
+        self.0
             .into_iter()
             .map(|solution| {
                 competition::Solution::new(
diff --git a/crates/driver/src/infra/solver/mod.rs b/crates/driver/src/infra/solver/mod.rs
index 0935b9af56..ae1ff46b8a 100644
--- a/crates/driver/src/infra/solver/mod.rs
+++ b/crates/driver/src/infra/solver/mod.rs
@@ -404,7 +404,7 @@ impl Solver {
             auction.id().is_none(),
         );
         let res = res?;
-        let res: solvers_dto::solution::Solutions =
+        let res: solvers_dto::solution::SolverResponse =
             serde_json::from_str(&res).inspect_err(|err| {
                 tracing::warn!(res, ?err, "failed to parse solver response");
                 self.notify(
@@ -413,16 +413,25 @@ impl Solver {
                     notify::Kind::DeserializationError(format!("Request format invalid: {err}")),
                 );
             })?;
-        let solutions = dto::Solutions::from(res).into_domain(
-            auction,
-            liquidity,
-            weth,
-            self.clone(),
-            &flashloan_hints,
-        )?;
 
-        super::observe::solutions(&solutions, auction.surplus_capturing_jit_order_owners());
-        Ok(solutions)
+        match res {
+            solvers_dto::solution::SolverResponse::Error { error } => {
+                tracing::debug!(?error, "solver returned custom error");
+                return Err(Error::CustomError(error));
+            }
+            solvers_dto::solution::SolverResponse::Solutions { solutions } => {
+                let solutions = dto::Solutions::from(solutions).into_domain(
+                    auction,
+                    liquidity,
+                    weth,
+                    self.clone(),
+                    &flashloan_hints,
+                )?;
+
+                super::observe::solutions(&solutions, auction.surplus_capturing_jit_order_owners());
+                Ok(solutions)
+            }
+        }
     }
 
     fn assemble_flashloan_hints(
@@ -521,6 +530,8 @@ pub enum Error {
     Deserialize(#[from] serde_json::Error),
     #[error("solver dto error: {0}")]
     Dto(#[from] dto::Error),
+    #[error("solver returned custom error: {0:?}")]
+    CustomError(solvers_dto::solution::SolverError),
 }
 
 impl Error {
@@ -530,6 +541,13 @@ impl Error {
             _ => false,
         }
     }
+
+    pub fn custom_error(&self) -> Option<&solvers_dto::solution::SolverError> {
+        match self {
+            Self::CustomError(err) => Some(err),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
diff --git a/crates/e2e/src/setup/solver/mock.rs b/crates/e2e/src/setup/solver/mock.rs
index e98bf214f9..749e6ed3e3 100644
--- a/crates/e2e/src/setup/solver/mock.rs
+++ b/crates/e2e/src/setup/solver/mock.rs
@@ -7,7 +7,7 @@ use {
     reqwest::Url,
     solvers_dto::{
         auction::Auction,
-        solution::{Solution, Solutions},
+        solution::{Solution, SolverResponse},
     },
     std::sync::{Arc, Mutex, MutexGuard},
 };
@@ -25,24 +25,45 @@ pub struct Mock {
 pub struct State {
     /// In-memory set of the auctions received by the solver.
     auctions: Arc<Mutex<Vec<Auction>>>,
-    /// The currently configured solution to return.
-    solution: Arc<Mutex<SolutionFuture>>,
+    /// The currently configured response to return.
+    response: Arc<Mutex<ResponseFuture>>,
 }
 
 type SolutionFuture = Arc<dyn Fn() -> BoxFuture<'static, Option<Solution>> + Send + Sync>;
+type ResponseFuture = Arc<dyn Fn() -> BoxFuture<'static, SolverResponse> + Send + Sync>;
 
 impl Mock {
+    /// Instructs the solver to return a new response from now on.
+    pub fn configure_response(&self, response: SolverResponse) {
+        *self.state.response.lock().unwrap() = Arc::new(move || {
+            let response = response.clone();
+            async move { response }.boxed()
+        });
+    }
+
+    /// Instructs the solver to return a new response from now on.
+    pub fn configure_response_async(&self, response: ResponseFuture) {
+        *self.state.response.lock().unwrap() = response;
+    }
+
     /// Instructs the solver to return a new solution from now on.
     pub fn configure_solution(&self, solution: Option<Solution>) {
-        *self.state.solution.lock().unwrap() = Arc::new(move || {
-            let solution = solution.clone();
-            async move { solution }.boxed()
+        self.configure_response(SolverResponse::Solutions {
+            solutions: solution.into_iter().collect(),
         });
     }
 
     /// Instructs the solver to return a new solution from now on.
     pub fn configure_solution_async(&self, solution: SolutionFuture) {
-        *self.state.solution.lock().unwrap() = solution;
+        self.configure_response_async(Arc::new(move || {
+            let solution = solution.clone();
+            async move {
+                SolverResponse::Solutions {
+                    solutions: solution().await.into_iter().collect(),
+                }
+            }
+            .boxed()
+        }));
     }
 
     /// Returns all the auctions received by the solver
@@ -54,7 +75,14 @@ impl Mock {
 impl Mock {
     pub async fn new() -> Self {
         let state = State {
-            solution: Arc::new(Mutex::new(Arc::new(|| async { None }.boxed()))),
+            response: Arc::new(Mutex::new(Arc::new(|| {
+                async {
+                    SolverResponse::Solutions {
+                        solutions: Vec::new(),
+                    }
+                }
+                .boxed()
+            }))),
             auctions: Arc::new(Mutex::new(vec![])),
         };
 
@@ -82,14 +110,13 @@ impl Mock {
 async fn solve(
     state: axum::extract::State<State>,
     Json(auction): Json<Auction>,
-) -> (axum::http::StatusCode, Json<Solutions>) {
+) -> (axum::http::StatusCode, Json<SolverResponse>) {
     let auction_id = auction.id.unwrap_or_default();
     state.auctions.lock().unwrap().push(auction);
-    let solutions: Vec<_> = {
-        let solution_generator = state.solution.lock().unwrap().clone();
-        solution_generator().await.into_iter().collect()
+    let response = {
+        let response_generator = state.response.lock().unwrap().clone();
+        response_generator().await
     };
-    let solutions = Solutions { solutions };
-    tracing::trace!(?auction_id, ?solutions, "/solve");
-    (axum::http::StatusCode::OK, Json(solutions))
+    tracing::trace!(?auction_id, ?response, "/solve");
+    (axum::http::StatusCode::OK, Json(response))
 }
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 7dcd13b76e..2efc435d63 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -14,8 +14,10 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::{nonzero::NonZeroU256, units::EthUnit},
+    reqwest::StatusCode,
     serde_json::json,
     shared::web3::Web3,
+    solvers_dto::solution::{SolverError, SolverErrorCode, SolverResponse},
     std::{
         sync::Arc,
         time::{Duration, Instant},
@@ -46,6 +48,24 @@ async fn local_node_volume_fee() {
     run_test(volume_fee).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_quote_custom_solver_errors() {
+    run_test(quote_custom_solver_errors).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_native_price_custom_solver_errors() {
+    run_test(native_price_custom_solver_errors).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_quote_custom_solver_errors_prioritized() {
+    run_test(quote_custom_solver_errors_prioritized).await;
+}
+
 // Test that quoting works as expected, specifically, that we can quote for a
 // token pair and additional gas from ERC-1271 and hooks are included in the
 // quoted fee amount.
@@ -451,6 +471,358 @@ async fn quote_timeout(web3: Web3) {
     assert_within_variance(start, MAX_QUOTE_TIME_MS);
 }
 
+async fn quote_custom_solver_errors(web3: Web3) {
+    tracing::info!("Setting up chain state.");
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(2u64.eth()).await;
+    let [sell_token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+
+    let mock_solver = Mock::new().await;
+
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![
+            SolverEngine {
+                name: "test_solver".into(),
+                account: solver.clone(),
+                endpoint: mock_solver.url.clone(),
+                base_tokens: vec![*sell_token.address()],
+                merge_solutions: true,
+                haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
+            },
+            SolverEngine {
+                name: "test_quoter".into(),
+                account: solver.clone(),
+                endpoint: mock_solver.url.clone(),
+                base_tokens: vec![*sell_token.address()],
+                merge_solutions: true,
+                haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
+            },
+        ],
+        colocation::LiquidityProvider::UniswapV2,
+        false,
+    );
+
+    services
+        .start_api(
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_quoter",
+                )]),
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                        vec![
+                            configs::native_price_estimators::NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                "http://localhost:11088/test_quoter".parse().unwrap(),
+                            ),
+                        ],
+                    ]),
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
+                },
+                ..configs::orderbook::Configuration::test_default()
+            },
+        )
+        .await;
+
+    let quote_request = OrderQuoteRequest {
+        from: trader.address(),
+        sell_token: *onchain.contracts().weth.address(),
+        buy_token: *sell_token.address(),
+        side: OrderQuoteSide::Sell {
+            sell_amount: SellAmount::BeforeFee {
+                value: NonZeroU256::try_from(1u64.eth()).unwrap(),
+            },
+        },
+        ..Default::default()
+    };
+
+    let cases = vec![
+        (
+            SolverErrorCode::TradingOutsideAllowedWindow,
+            "TradingOutsideAllowedWindow",
+            None,
+            "Token can only be traded during specific time windows",
+        ),
+        (
+            SolverErrorCode::TokenTemporarilySuspended,
+            "TokenTemporarilySuspended",
+            Some("token is suspended"),
+            "token is suspended",
+        ),
+        (
+            SolverErrorCode::InsufficientLiquidity,
+            "InsufficientLiquidity",
+            Some("not enough liquidity"),
+            "not enough liquidity",
+        ),
+        (
+            SolverErrorCode::Other,
+            "CustomSolverError",
+            Some("some solver specific error"),
+            "some solver specific error",
+        ),
+    ];
+
+    for (code, expected_kind, sent_message, expected_message) in cases {
+        mock_solver.configure_response(SolverResponse::Error {
+            error: SolverError {
+                code,
+                message: sent_message.map(str::to_string),
+            },
+        });
+
+        let (status, body) = services.submit_quote(&quote_request).await.unwrap_err();
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert!(
+            body.contains(expected_kind),
+            "response should include error kind {expected_kind}, got {body}"
+        );
+        assert!(
+            body.contains(expected_message),
+            "response should include error message {expected_message}, got {body}"
+        );
+    }
+}
+
+async fn native_price_custom_solver_errors(web3: Web3) {
+    tracing::info!("Setting up chain state.");
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [_trader] = onchain.make_accounts(2u64.eth()).await;
+    let [sell_token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+
+    let mock_solver = Mock::new().await;
+
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![
+            SolverEngine {
+                name: "test_solver".into(),
+                account: solver.clone(),
+                endpoint: mock_solver.url.clone(),
+                base_tokens: vec![*sell_token.address()],
+                merge_solutions: true,
+                haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
+            },
+            SolverEngine {
+                name: "test_quoter".into(),
+                account: solver.clone(),
+                endpoint: mock_solver.url.clone(),
+                base_tokens: vec![*sell_token.address()],
+                merge_solutions: true,
+                haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
+            },
+        ],
+        colocation::LiquidityProvider::UniswapV2,
+        false,
+    );
+
+    services
+        .start_api(
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                    "test_quoter",
+                    "http://localhost:11088/test_quoter",
+                )]),
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                        vec![
+                            configs::native_price_estimators::NativePriceEstimator::driver(
+                                "test_quoter".to_string(),
+                                "http://localhost:11088/test_quoter".parse().unwrap(),
+                            ),
+                        ],
+                    ]),
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
+                },
+                ..configs::orderbook::Configuration::test_default()
+            },
+        )
+        .await;
+
+    let cases = vec![
+        (
+            SolverErrorCode::TradingOutsideAllowedWindow,
+            "TradingOutsideAllowedWindow",
+            "native window closed",
+        ),
+        (
+            SolverErrorCode::TokenTemporarilySuspended,
+            "TokenTemporarilySuspended",
+            "native token suspended",
+        ),
+        (
+            SolverErrorCode::InsufficientLiquidity,
+            "InsufficientLiquidity",
+            "native not enough liquidity",
+        ),
+        (
+            SolverErrorCode::Other,
+            "CustomSolverError",
+            "native custom solver reason",
+        ),
+    ];
+
+    for (code, expected_kind, message) in cases {
+        mock_solver.configure_response(SolverResponse::Error {
+            error: SolverError {
+                code,
+                message: Some(message.to_string()),
+            },
+        });
+
+        let (status, body) = services
+            .get_native_price(sell_token.address())
+            .await
+            .unwrap_err();
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert!(
+            body.contains(expected_kind),
+            "response should include error kind {expected_kind}, got {body}"
+        );
+        assert!(
+            body.contains(message),
+            "response should include error message {message}, got {body}"
+        );
+    }
+}
+
+async fn quote_custom_solver_errors_prioritized(web3: Web3) {
+    tracing::info!("Setting up chain state.");
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(2u64.eth()).await;
+    let [sell_token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    tracing::info!("Starting services.");
+    let services = Services::new(&onchain).await;
+
+    let custom_error_solver = Mock::new().await;
+    let no_liquidity_solver = Mock::new().await;
+
+    colocation::start_driver(
+        onchain.contracts(),
+        vec![
+            SolverEngine {
+                name: "custom_solver".into(),
+                account: solver.clone(),
+                endpoint: custom_error_solver.url.clone(),
+                base_tokens: vec![*sell_token.address()],
+                merge_solutions: true,
+                haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
+            },
+            SolverEngine {
+                name: "no_liquidity_solver".into(),
+                account: solver.clone(),
+                endpoint: no_liquidity_solver.url.clone(),
+                base_tokens: vec![*sell_token.address()],
+                merge_solutions: true,
+                haircut_bps: 0,
+                submission_keys: vec![],
+                forwarder_contract: None,
+            },
+        ],
+        colocation::LiquidityProvider::UniswapV2,
+        false,
+    );
+
+    services
+        .start_api(
+            vec![],
+            configs::orderbook::Configuration {
+                order_quoting: OrderQuoting::test_with_drivers(vec![
+                    ExternalSolver::new("custom_solver", "http://localhost:11088/custom_solver"),
+                    ExternalSolver::new(
+                        "no_liquidity_solver",
+                        "http://localhost:11088/no_liquidity_solver",
+                    ),
+                ]),
+                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                        vec![
+                            configs::native_price_estimators::NativePriceEstimator::driver(
+                                "custom_solver".to_string(),
+                                "http://localhost:11088/custom_solver".parse().unwrap(),
+                            ),
+                            configs::native_price_estimators::NativePriceEstimator::driver(
+                                "no_liquidity_solver".to_string(),
+                                "http://localhost:11088/no_liquidity_solver"
+                                    .parse()
+                                    .unwrap(),
+                            ),
+                        ],
+                    ]),
+                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
+                },
+                ..configs::orderbook::Configuration::test_default()
+            },
+        )
+        .await;
+
+    custom_error_solver.configure_response(SolverResponse::Error {
+        error: SolverError {
+            code: SolverErrorCode::Other,
+            message: Some("priority custom solver error".to_string()),
+        },
+    });
+    no_liquidity_solver.configure_response(SolverResponse::Solutions {
+        solutions: Vec::new(),
+    });
+
+    let quote_request = OrderQuoteRequest {
+        from: trader.address(),
+        sell_token: *onchain.contracts().weth.address(),
+        buy_token: *sell_token.address(),
+        side: OrderQuoteSide::Sell {
+            sell_amount: SellAmount::BeforeFee {
+                value: NonZeroU256::try_from(1u64.eth()).unwrap(),
+            },
+        },
+        ..Default::default()
+    };
+
+    let (status, body) = services.submit_quote(&quote_request).await.unwrap_err();
+    assert_eq!(status, StatusCode::BAD_REQUEST);
+    assert!(
+        body.contains("CustomSolverError"),
+        "response should include custom solver error, got {body}"
+    );
+    assert!(
+        body.contains("priority custom solver error"),
+        "response should include prioritized custom error message, got {body}"
+    );
+}
+
 /// Test that volume fees are correctly applied to quotes.
 async fn volume_fee(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3).await;
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 977bfce7d4..ecd219105d 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -449,6 +449,24 @@ impl IntoResponse for PriceEstimationErrorWrapper {
                 error("NoLiquidity", "no route found"),
             )
                 .into_response(),
+            PriceEstimationError::TradingOutsideAllowedWindow { message } => (
+                StatusCode::BAD_REQUEST,
+                error("TradingOutsideAllowedWindow", message),
+            )
+                .into_response(),
+            PriceEstimationError::TokenTemporarilySuspended { message } => (
+                StatusCode::BAD_REQUEST,
+                error("TokenTemporarilySuspended", message),
+            )
+                .into_response(),
+            PriceEstimationError::InsufficientLiquidity { message } => (
+                StatusCode::BAD_REQUEST,
+                error("InsufficientLiquidity", message),
+            )
+                .into_response(),
+            PriceEstimationError::CustomSolverError { message } => {
+                (StatusCode::BAD_REQUEST, error("CustomSolverError", message)).into_response()
+            }
             PriceEstimationError::ProtocolInternal(err) => {
                 tracing::error!(?err, "PriceEstimationError::Other");
                 internal_error_reply()
@@ -483,7 +501,7 @@ pub async fn response_body(response: axum::http::Response<axum::body::Body>) ->
 #[cfg(test)]
 mod tests {
     use {
-        crate::api::{Error, rich_error},
+        crate::api::{Error, PriceEstimationErrorWrapper, rich_error},
         alloy::primitives::{Address, B256},
         app_data::AppDataHash,
         axum::{
@@ -495,6 +513,7 @@ mod tests {
             routing::get,
         },
         model::order::OrderUid,
+        price_estimation::PriceEstimationError,
         serde::{Deserialize, Serialize, ser},
         serde_json::json,
         tower::ServiceExt as _,
@@ -556,6 +575,53 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn maps_custom_price_estimation_errors_to_bad_request_responses() {
+        let cases = [
+            (
+                PriceEstimationError::TradingOutsideAllowedWindow {
+                    message: "window closed".to_string(),
+                },
+                "TradingOutsideAllowedWindow",
+                "window closed",
+            ),
+            (
+                PriceEstimationError::TokenTemporarilySuspended {
+                    message: "token suspended".to_string(),
+                },
+                "TokenTemporarilySuspended",
+                "token suspended",
+            ),
+            (
+                PriceEstimationError::InsufficientLiquidity {
+                    message: "insufficient liquidity".to_string(),
+                },
+                "InsufficientLiquidity",
+                "insufficient liquidity",
+            ),
+            (
+                PriceEstimationError::CustomSolverError {
+                    message: "custom solver reason".to_string(),
+                },
+                "CustomSolverError",
+                "custom solver reason",
+            ),
+        ];
+
+        for (err, expected_type, expected_description) in cases {
+            let response = PriceEstimationErrorWrapper(err).into_response();
+            assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+
+            let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
+                .await
+                .unwrap();
+            let body: Error = serde_json::from_slice(&bytes).unwrap();
+
+            assert_eq!(body.error_type, expected_type);
+            assert_eq!(body.description.as_ref(), expected_description);
+        }
+    }
+
     // Tests for Axum extractor type parsing.
     //
     // Since the parsing behavior depends on the type, not the endpoint,
diff --git a/crates/price-estimation/src/competition/mod.rs b/crates/price-estimation/src/competition/mod.rs
index 949345f043..80a9119a5b 100644
--- a/crates/price-estimation/src/competition/mod.rs
+++ b/crates/price-estimation/src/competition/mod.rs
@@ -194,6 +194,10 @@ fn compare_error(a: &PriceEstimationError, b: &PriceEstimationError) -> Ordering
     fn error_to_integer_priority(err: &PriceEstimationError) -> u8 {
         match err {
             // highest priority (prefer)
+            PriceEstimationError::TradingOutsideAllowedWindow { .. }
+            | PriceEstimationError::TokenTemporarilySuspended { .. }
+            | PriceEstimationError::InsufficientLiquidity { .. }
+            | PriceEstimationError::CustomSolverError { .. } => 6,
             PriceEstimationError::RateLimited => 5,
             PriceEstimationError::ProtocolInternal(_) => 4,
             PriceEstimationError::EstimatorInternal(_) => 3,
@@ -590,4 +594,41 @@ mod tests {
 
         racing.estimate(query).await.unwrap();
     }
+
+    #[test]
+    fn custom_solver_errors_have_higher_priority_than_generic_errors() {
+        let custom_errors = [
+            PriceEstimationError::TradingOutsideAllowedWindow {
+                message: "window".to_string(),
+            },
+            PriceEstimationError::TokenTemporarilySuspended {
+                message: "suspended".to_string(),
+            },
+            PriceEstimationError::InsufficientLiquidity {
+                message: "insufficient".to_string(),
+            },
+            PriceEstimationError::CustomSolverError {
+                message: "custom".to_string(),
+            },
+        ];
+
+        let generic_errors = [
+            PriceEstimationError::RateLimited,
+            PriceEstimationError::ProtocolInternal(anyhow!("protocol")),
+            PriceEstimationError::EstimatorInternal(anyhow!("estimator")),
+            PriceEstimationError::UnsupportedToken {
+                token: Address::new([0; 20]),
+                reason: "unsupported".to_string(),
+            },
+            PriceEstimationError::NoLiquidity,
+            PriceEstimationError::UnsupportedOrderType("buy".to_string()),
+        ];
+
+        for custom in &custom_errors {
+            for generic in &generic_errors {
+                assert_eq!(compare_error(custom, generic), Ordering::Greater);
+                assert_eq!(compare_error(generic, custom), Ordering::Less);
+            }
+        }
+    }
 }
diff --git a/crates/price-estimation/src/instrumented.rs b/crates/price-estimation/src/instrumented.rs
index 0729a9ba2e..b06225559f 100644
--- a/crates/price-estimation/src/instrumented.rs
+++ b/crates/price-estimation/src/instrumented.rs
@@ -50,6 +50,14 @@ impl<T> InstrumentedPriceEstimator<T> {
             Err(PriceEstimationError::UnsupportedToken { .. }) => "unsupported_token",
             Err(PriceEstimationError::UnsupportedOrderType(_)) => "unsupported_order_type",
             Err(PriceEstimationError::RateLimited) => "rate_limited",
+            Err(PriceEstimationError::TradingOutsideAllowedWindow { .. }) => {
+                "trading_outside_allowed_window"
+            }
+            Err(PriceEstimationError::TokenTemporarilySuspended { .. }) => {
+                "token_temporarily_suspended"
+            }
+            Err(PriceEstimationError::InsufficientLiquidity { .. }) => "insufficient_liquidity",
+            Err(PriceEstimationError::CustomSolverError { .. }) => "custom_solver_error",
             Err(PriceEstimationError::EstimatorInternal(_)) => "estimator_internal_error",
             Err(PriceEstimationError::ProtocolInternal(_)) => "protocol_internal_error",
         }
@@ -156,6 +164,18 @@ mod tests {
             }),
             Err(PriceEstimationError::UnsupportedOrderType("".to_string())),
             Err(PriceEstimationError::RateLimited),
+            Err(PriceEstimationError::TradingOutsideAllowedWindow {
+                message: "window".to_string(),
+            }),
+            Err(PriceEstimationError::TokenTemporarilySuspended {
+                message: "suspended".to_string(),
+            }),
+            Err(PriceEstimationError::InsufficientLiquidity {
+                message: "insufficient".to_string(),
+            }),
+            Err(PriceEstimationError::CustomSolverError {
+                message: "custom".to_string(),
+            }),
             Err(PriceEstimationError::EstimatorInternal(anyhow!(""))),
             Err(PriceEstimationError::ProtocolInternal(anyhow!(""))),
         ];
@@ -184,6 +204,10 @@ mod tests {
             "unsupported_token",
             "unsupported_order_type",
             "rate_limited",
+            "trading_outside_allowed_window",
+            "token_temporarily_suspended",
+            "insufficient_liquidity",
+            "custom_solver_error",
             "estimator_internal_error",
             "protocol_internal_error",
         ] {
@@ -205,6 +229,6 @@ mod tests {
             .price_estimation_times
             .with_label_values(&["foo"])
             .get_sample_count();
-        assert_eq!(observed_count, 7);
+        assert_eq!(observed_count, 11);
     }
 }
diff --git a/crates/price-estimation/src/lib.rs b/crates/price-estimation/src/lib.rs
index 992e945153..0ad735845f 100644
--- a/crates/price-estimation/src/lib.rs
+++ b/crates/price-estimation/src/lib.rs
@@ -48,6 +48,23 @@ pub enum PriceEstimationError {
     #[error("Rate limited")]
     RateLimited,
 
+    /// Token can only be traded during specific time windows (e.g. xStocks/Ondo
+    /// RWA tokens).
+    #[error("{message}")]
+    TradingOutsideAllowedWindow { message: String },
+
+    /// Token is temporarily suspended from trading by the solver.
+    #[error("{message}")]
+    TokenTemporarilySuspended { message: String },
+
+    /// Insufficient liquidity to fill the requested trade size.
+    #[error("{message}")]
+    InsufficientLiquidity { message: String },
+
+    /// Solver returned a custom error that doesn't map to a known variant.
+    #[error("{message}")]
+    CustomSolverError { message: String },
+
     #[error(transparent)]
     EstimatorInternal(anyhow::Error),
 
@@ -78,6 +95,18 @@ impl Clone for PriceEstimationError {
                 Self::UnsupportedOrderType(order_type.clone())
             }
             Self::RateLimited => Self::RateLimited,
+            Self::TradingOutsideAllowedWindow { message } => Self::TradingOutsideAllowedWindow {
+                message: message.clone(),
+            },
+            Self::TokenTemporarilySuspended { message } => Self::TokenTemporarilySuspended {
+                message: message.clone(),
+            },
+            Self::InsufficientLiquidity { message } => Self::InsufficientLiquidity {
+                message: message.clone(),
+            },
+            Self::CustomSolverError { message } => Self::CustomSolverError {
+                message: message.clone(),
+            },
             Self::EstimatorInternal(err) => {
                 Self::EstimatorInternal(crate::utils::clone_anyhow_error(err))
             }
@@ -88,6 +117,34 @@ impl Clone for PriceEstimationError {
     }
 }
 
+#[cfg(test)]
+mod price_estimation_error_tests {
+    use super::PriceEstimationError;
+
+    #[test]
+    fn clone_preserves_custom_solver_error_messages() {
+        let cases = [
+            PriceEstimationError::TradingOutsideAllowedWindow {
+                message: "window".to_string(),
+            },
+            PriceEstimationError::TokenTemporarilySuspended {
+                message: "suspended".to_string(),
+            },
+            PriceEstimationError::InsufficientLiquidity {
+                message: "insufficient".to_string(),
+            },
+            PriceEstimationError::CustomSolverError {
+                message: "custom".to_string(),
+            },
+        ];
+
+        for err in cases {
+            let cloned = err.clone();
+            assert_eq!(cloned.to_string(), err.to_string());
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Default, Serialize)]
 pub struct Query {
     pub sell_token: Address,
diff --git a/crates/price-estimation/src/native_price_cache.rs b/crates/price-estimation/src/native_price_cache.rs
index b06758cb5c..e2e908520f 100644
--- a/crates/price-estimation/src/native_price_cache.rs
+++ b/crates/price-estimation/src/native_price_cache.rs
@@ -140,7 +140,11 @@ fn should_cache(result: &Result<f64, PriceEstimationError>) -> bool {
         Err(PriceEstimationError::ProtocolInternal(_)) | Err(PriceEstimationError::RateLimited) => {
             false
         }
-        Err(PriceEstimationError::UnsupportedOrderType(_)) => {
+        Err(PriceEstimationError::UnsupportedOrderType(_))
+        | Err(PriceEstimationError::TradingOutsideAllowedWindow { .. })
+        | Err(PriceEstimationError::TokenTemporarilySuspended { .. })
+        | Err(PriceEstimationError::InsufficientLiquidity { .. })
+        | Err(PriceEstimationError::CustomSolverError { .. }) => {
             tracing::error!(?result, "Unexpected error in native price cache");
             false
         }
@@ -1099,4 +1103,44 @@ mod tests {
             assert_eq!(price.to_i64().unwrap(), 2);
         }
     }
+
+    #[test]
+    fn should_cache_filters_custom_solver_errors() {
+        let custom_errors = [
+            PriceEstimationError::TradingOutsideAllowedWindow {
+                message: "window".to_string(),
+            },
+            PriceEstimationError::TokenTemporarilySuspended {
+                message: "suspended".to_string(),
+            },
+            PriceEstimationError::InsufficientLiquidity {
+                message: "insufficient".to_string(),
+            },
+            PriceEstimationError::CustomSolverError {
+                message: "custom".to_string(),
+            },
+        ];
+
+        for err in &custom_errors {
+            assert!(!should_cache(&Err(err.clone())));
+        }
+    }
+
+    #[test]
+    fn should_cache_keeps_expected_entries() {
+        assert!(should_cache(&Ok(1.0)));
+        assert!(should_cache(&Err(PriceEstimationError::NoLiquidity)));
+        assert!(should_cache(&Err(PriceEstimationError::UnsupportedToken {
+            token: Address::new([0; 20]),
+            reason: "unsupported".to_string(),
+        })));
+        assert!(should_cache(&Err(PriceEstimationError::EstimatorInternal(
+            anyhow!("estimator")
+        ))));
+
+        assert!(!should_cache(&Err(PriceEstimationError::RateLimited)));
+        assert!(!should_cache(&Err(PriceEstimationError::ProtocolInternal(
+            anyhow!("protocol")
+        ))));
+    }
 }
diff --git a/crates/price-estimation/src/trade_finding/external.rs b/crates/price-estimation/src/trade_finding/external.rs
index 5be81eb3c1..28504441e1 100644
--- a/crates/price-estimation/src/trade_finding/external.rs
+++ b/crates/price-estimation/src/trade_finding/external.rs
@@ -182,6 +182,18 @@ impl From<dto::Error> for PriceEstimationError {
     fn from(value: dto::Error) -> Self {
         match value.kind.as_str() {
             "QuotingFailed" => Self::NoLiquidity,
+            "TradingOutsideAllowedWindow" => Self::TradingOutsideAllowedWindow {
+                message: value.description,
+            },
+            "TokenTemporarilySuspended" => Self::TokenTemporarilySuspended {
+                message: value.description,
+            },
+            "InsufficientLiquidity" => Self::InsufficientLiquidity {
+                message: value.description,
+            },
+            "CustomSolverError" => Self::CustomSolverError {
+                message: value.description,
+            },
             _ => Self::EstimatorInternal(anyhow!("{}", value.description)),
         }
     }
@@ -197,6 +209,96 @@ impl From<dto::Interaction> for Interaction {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn maps_known_custom_error_kinds() {
+        let cases = [
+            (
+                "TradingOutsideAllowedWindow",
+                "window closed",
+                "TradingOutsideAllowedWindow",
+            ),
+            (
+                "TokenTemporarilySuspended",
+                "token suspended",
+                "TokenTemporarilySuspended",
+            ),
+            (
+                "InsufficientLiquidity",
+                "not enough liquidity",
+                "InsufficientLiquidity",
+            ),
+            (
+                "CustomSolverError",
+                "custom solver reason",
+                "CustomSolverError",
+            ),
+            ("QuotingFailed", "ignored", "QuotingFailed"),
+        ];
+
+        for (kind, description, expected) in cases {
+            let error = dto::Error {
+                kind: kind.to_string(),
+                description: description.to_string(),
+            };
+
+            let mapped = PriceEstimationError::from(error);
+            match expected {
+                "TradingOutsideAllowedWindow" => {
+                    assert!(matches!(
+                        mapped,
+                        PriceEstimationError::TradingOutsideAllowedWindow { message }
+                        if message == description
+                    ));
+                }
+                "TokenTemporarilySuspended" => {
+                    assert!(matches!(
+                        mapped,
+                        PriceEstimationError::TokenTemporarilySuspended { message }
+                        if message == description
+                    ));
+                }
+                "InsufficientLiquidity" => {
+                    assert!(matches!(
+                        mapped,
+                        PriceEstimationError::InsufficientLiquidity { message }
+                        if message == description
+                    ));
+                }
+                "CustomSolverError" => {
+                    assert!(matches!(
+                        mapped,
+                        PriceEstimationError::CustomSolverError { message }
+                        if message == description
+                    ));
+                }
+                "QuotingFailed" => {
+                    assert!(matches!(mapped, PriceEstimationError::NoLiquidity));
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[test]
+    fn maps_unknown_error_kind_to_estimator_internal() {
+        let error = dto::Error {
+            kind: "SomeFutureKind".to_string(),
+            description: "driver sent unknown error kind".to_string(),
+        };
+
+        let mapped = PriceEstimationError::from(error);
+        assert!(matches!(
+            mapped,
+            PriceEstimationError::EstimatorInternal(err)
+            if err.to_string() == "driver sent unknown error kind"
+        ));
+    }
+}
+
 #[async_trait::async_trait]
 impl TradeFinding for ExternalTradeFinder {
     #[instrument(skip_all)]
diff --git a/crates/price-estimation/src/trade_finding/mod.rs b/crates/price-estimation/src/trade_finding/mod.rs
index f9f0c490a0..39bfc2501d 100644
--- a/crates/price-estimation/src/trade_finding/mod.rs
+++ b/crates/price-estimation/src/trade_finding/mod.rs
@@ -250,6 +250,23 @@ pub enum TradeError {
     #[error("Rate limited")]
     RateLimited,
 
+    /// Token can only be traded during specific time windows (e.g. xStocks/Ondo
+    /// RWA tokens).
+    #[error("{message}")]
+    TradingOutsideAllowedWindow { message: String },
+
+    /// Token is temporarily suspended from trading by the solver.
+    #[error("{message}")]
+    TokenTemporarilySuspended { message: String },
+
+    /// Insufficient liquidity to fill the requested trade size.
+    #[error("{message}")]
+    InsufficientLiquidity { message: String },
+
+    /// Solver returned a custom error that doesn't map to a known variant.
+    #[error("{message}")]
+    CustomSolverError { message: String },
+
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
@@ -265,6 +282,18 @@ impl From<PriceEstimationError> for TradeError {
                 Self::UnsupportedOrderType(format!("{token:#x}"))
             }
             PriceEstimationError::RateLimited => Self::RateLimited,
+            PriceEstimationError::TradingOutsideAllowedWindow { message } => {
+                Self::TradingOutsideAllowedWindow { message }
+            }
+            PriceEstimationError::TokenTemporarilySuspended { message } => {
+                Self::TokenTemporarilySuspended { message }
+            }
+            PriceEstimationError::InsufficientLiquidity { message } => {
+                Self::InsufficientLiquidity { message }
+            }
+            PriceEstimationError::CustomSolverError { message } => {
+                Self::CustomSolverError { message }
+            }
             PriceEstimationError::EstimatorInternal(err)
             | PriceEstimationError::ProtocolInternal(err) => Self::Other(err),
         }
@@ -280,6 +309,18 @@ impl Clone for TradeError {
             }
             Self::DeadlineExceeded => Self::DeadlineExceeded,
             Self::RateLimited => Self::RateLimited,
+            Self::TradingOutsideAllowedWindow { message } => Self::TradingOutsideAllowedWindow {
+                message: message.clone(),
+            },
+            Self::TokenTemporarilySuspended { message } => Self::TokenTemporarilySuspended {
+                message: message.clone(),
+            },
+            Self::InsufficientLiquidity { message } => Self::InsufficientLiquidity {
+                message: message.clone(),
+            },
+            Self::CustomSolverError { message } => Self::CustomSolverError {
+                message: message.clone(),
+            },
             Self::Other(err) => Self::Other(crate::utils::clone_anyhow_error(err)),
         }
     }
@@ -300,7 +341,7 @@ pub fn map_interactions_data<'a>(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use {super::*, crate::PriceEstimationError};
 
     #[test]
     fn test_debug_interaction() {
@@ -318,4 +359,88 @@ mod tests {
              0x010203040506 }"
         )
     }
+
+    #[test]
+    fn maps_custom_price_estimation_errors_to_trade_errors() {
+        let cases = [
+            (
+                PriceEstimationError::TradingOutsideAllowedWindow {
+                    message: "window".to_string(),
+                },
+                "window",
+                0,
+            ),
+            (
+                PriceEstimationError::TokenTemporarilySuspended {
+                    message: "suspended".to_string(),
+                },
+                "suspended",
+                1,
+            ),
+            (
+                PriceEstimationError::InsufficientLiquidity {
+                    message: "insufficient".to_string(),
+                },
+                "insufficient",
+                2,
+            ),
+            (
+                PriceEstimationError::CustomSolverError {
+                    message: "custom".to_string(),
+                },
+                "custom",
+                3,
+            ),
+        ];
+
+        for (input, expected_message, expected_variant) in cases {
+            let mapped: TradeError = input.into();
+            match expected_variant {
+                0 => assert!(matches!(
+                    mapped,
+                    TradeError::TradingOutsideAllowedWindow { message }
+                    if message == expected_message
+                )),
+                1 => assert!(matches!(
+                    mapped,
+                    TradeError::TokenTemporarilySuspended { message }
+                    if message == expected_message
+                )),
+                2 => assert!(matches!(
+                    mapped,
+                    TradeError::InsufficientLiquidity { message }
+                    if message == expected_message
+                )),
+                3 => assert!(matches!(
+                    mapped,
+                    TradeError::CustomSolverError { message }
+                    if message == expected_message
+                )),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[test]
+    fn clone_preserves_trade_error_custom_messages() {
+        let cases = [
+            TradeError::TradingOutsideAllowedWindow {
+                message: "window".to_string(),
+            },
+            TradeError::TokenTemporarilySuspended {
+                message: "suspended".to_string(),
+            },
+            TradeError::InsufficientLiquidity {
+                message: "insufficient".to_string(),
+            },
+            TradeError::CustomSolverError {
+                message: "custom".to_string(),
+            },
+        ];
+
+        for err in cases {
+            let cloned = err.clone();
+            assert_eq!(cloned.to_string(), err.to_string());
+        }
+    }
 }
diff --git a/crates/price-estimation/src/trade_finding/trade_estimator.rs b/crates/price-estimation/src/trade_finding/trade_estimator.rs
index f80cdf1a72..27bd9593ec 100644
--- a/crates/price-estimation/src/trade_finding/trade_estimator.rs
+++ b/crates/price-estimation/src/trade_finding/trade_estimator.rs
@@ -108,7 +108,83 @@ impl From<TradeError> for PriceEstimationError {
             TradeError::UnsupportedOrderType(order_type) => Self::UnsupportedOrderType(order_type),
             TradeError::DeadlineExceeded => Self::EstimatorInternal(anyhow!("timeout")),
             TradeError::RateLimited => Self::RateLimited,
+            TradeError::TradingOutsideAllowedWindow { message } => {
+                Self::TradingOutsideAllowedWindow { message }
+            }
+            TradeError::TokenTemporarilySuspended { message } => {
+                Self::TokenTemporarilySuspended { message }
+            }
+            TradeError::InsufficientLiquidity { message } => {
+                Self::InsufficientLiquidity { message }
+            }
+            TradeError::CustomSolverError { message } => Self::CustomSolverError { message },
             TradeError::Other(err) => Self::EstimatorInternal(err),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn maps_custom_trade_errors_to_price_estimation_errors() {
+        let cases = [
+            (
+                TradeError::TradingOutsideAllowedWindow {
+                    message: "window".to_string(),
+                },
+                "window",
+                0,
+            ),
+            (
+                TradeError::TokenTemporarilySuspended {
+                    message: "suspended".to_string(),
+                },
+                "suspended",
+                1,
+            ),
+            (
+                TradeError::InsufficientLiquidity {
+                    message: "insufficient".to_string(),
+                },
+                "insufficient",
+                2,
+            ),
+            (
+                TradeError::CustomSolverError {
+                    message: "custom".to_string(),
+                },
+                "custom",
+                3,
+            ),
+        ];
+
+        for (input, expected_message, expected_variant) in cases {
+            let mapped: PriceEstimationError = input.into();
+            match expected_variant {
+                0 => assert!(matches!(
+                    mapped,
+                    PriceEstimationError::TradingOutsideAllowedWindow { message }
+                    if message == expected_message
+                )),
+                1 => assert!(matches!(
+                    mapped,
+                    PriceEstimationError::TokenTemporarilySuspended { message }
+                    if message == expected_message
+                )),
+                2 => assert!(matches!(
+                    mapped,
+                    PriceEstimationError::InsufficientLiquidity { message }
+                    if message == expected_message
+                )),
+                3 => assert!(matches!(
+                    mapped,
+                    PriceEstimationError::CustomSolverError { message }
+                    if message == expected_message
+                )),
+                _ => unreachable!(),
+            }
+        }
+    }
+}
diff --git a/crates/solvers-dto/Cargo.toml b/crates/solvers-dto/Cargo.toml
index 4d75afac0c..d24f0b1ae7 100644
--- a/crates/solvers-dto/Cargo.toml
+++ b/crates/solvers-dto/Cargo.toml
@@ -17,6 +17,7 @@ const-hex = { workspace = true }
 number = { workspace = true }
 serde = { workspace = true }
 serde-ext = { workspace = true }
+serde_json = { workspace = true }
 serde_with = { workspace = true }
 
 [lints]
diff --git a/crates/solvers-dto/src/solution.rs b/crates/solvers-dto/src/solution.rs
index b5ef27439a..df09e8f578 100644
--- a/crates/solvers-dto/src/solution.rs
+++ b/crates/solvers-dto/src/solution.rs
@@ -6,10 +6,40 @@ use {
     std::collections::HashMap,
 };
 
-#[derive(Debug, Serialize, Deserialize, Default)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
-pub struct Solutions {
-    pub solutions: Vec<Solution>,
+pub struct SolverError {
+    pub code: SolverErrorCode,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub enum SolverErrorCode {
+    /// Token can only be traded during specific time windows (e.g., RWA tokens)
+    TradingOutsideAllowedWindow,
+    /// Token is temporarily suspended from trading
+    TokenTemporarilySuspended,
+    /// Insufficient liquidity for the requested trade size
+    InsufficientLiquidity,
+    /// Generic solver error with custom message
+    Other,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum SolverResponse {
+    Solutions { solutions: Vec<Solution> },
+    Error { error: SolverError },
+}
+
+impl Default for SolverResponse {
+    fn default() -> Self {
+        Self::Solutions {
+            solutions: Vec::new(),
+        }
+    }
 }
 
 #[serde_as]
@@ -227,3 +257,67 @@ pub struct WrapperCall {
     #[serde(default)]
     pub data: Vec<u8>,
 }
+
+#[cfg(test)]
+mod tests {
+    use {super::*, serde_json::json};
+
+    #[test]
+    fn serializes_empty_solutions_response() {
+        let response = SolverResponse::default();
+
+        let value = serde_json::to_value(response).unwrap();
+        assert_eq!(
+            value,
+            json!({
+                "solutions": [],
+            })
+        );
+    }
+
+    #[test]
+    fn serializes_and_deserializes_error_responses() {
+        let cases = vec![
+            (
+                SolverErrorCode::TradingOutsideAllowedWindow,
+                "tradingOutsideAllowedWindow",
+            ),
+            (
+                SolverErrorCode::TokenTemporarilySuspended,
+                "tokenTemporarilySuspended",
+            ),
+            (
+                SolverErrorCode::InsufficientLiquidity,
+                "insufficientLiquidity",
+            ),
+            (SolverErrorCode::Other, "other"),
+        ];
+
+        for (code, expected_code) in cases {
+            let response = SolverResponse::Error {
+                error: SolverError {
+                    code: code.clone(),
+                    message: Some("custom message".to_string()),
+                },
+            };
+
+            let value = serde_json::to_value(response).unwrap();
+            assert_eq!(
+                value,
+                json!({
+                    "error": {
+                        "code": expected_code,
+                        "message": "custom message",
+                    },
+                })
+            );
+
+            let decoded: SolverResponse = serde_json::from_value(value).unwrap();
+            assert!(matches!(
+                decoded,
+                SolverResponse::Error { error }
+                if error.code == code && error.message.as_deref() == Some("custom message")
+            ));
+        }
+    }
+}
diff --git a/crates/solvers/src/api/routes/solve/dto/mod.rs b/crates/solvers/src/api/routes/solve/dto/mod.rs
index bbe9069a97..003b32c44e 100644
--- a/crates/solvers/src/api/routes/solve/dto/mod.rs
+++ b/crates/solvers/src/api/routes/solve/dto/mod.rs
@@ -1,4 +1,4 @@
 pub mod auction;
 pub mod solution;
 
-pub use solvers_dto::{auction::Auction, solution::Solutions};
+pub use solvers_dto::{auction::Auction, solution::SolverResponse};
diff --git a/crates/solvers/src/api/routes/solve/dto/solution.rs b/crates/solvers/src/api/routes/solve/dto/solution.rs
index cd323dedae..c86106a580 100644
--- a/crates/solvers/src/api/routes/solve/dto/solution.rs
+++ b/crates/solvers/src/api/routes/solve/dto/solution.rs
@@ -4,8 +4,8 @@ use {
 };
 
 /// Creates a new solution DTO from its domain object.
-pub fn from_domain(solutions: &[solution::Solution]) -> super::Solutions {
-    super::Solutions {
+pub fn from_domain(solutions: &[solution::Solution]) -> super::SolverResponse {
+    SolverResponse::Solutions {
         solutions: solutions
             .iter()
             .map(|solution| Solution {
diff --git a/crates/solvers/src/api/routes/solve/mod.rs b/crates/solvers/src/api/routes/solve/mod.rs
index 97c95369ec..ade4bba955 100644
--- a/crates/solvers/src/api/routes/solve/mod.rs
+++ b/crates/solvers/src/api/routes/solve/mod.rs
@@ -9,7 +9,7 @@ pub async fn solve(
     axum::extract::Json(auction): axum::extract::Json<dto::Auction>,
 ) -> (
     axum::http::StatusCode,
-    axum::response::Json<Response<dto::Solutions>>,
+    axum::response::Json<Response<dto::SolverResponse>>,
 ) {
     let handle_request = async {
         let auction = match dto::auction::into_domain(auction) {

From e2c256216e5fc578c62e9a141281d3f20d9dc579 Mon Sep 17 00:00:00 2001
From: Aryan Godara <65490434+AryanGodara@users.noreply.github.com>
Date: Wed, 18 Mar 2026 18:08:18 +0530
Subject: [PATCH 155/219] Remove lens from the servies (#4269)

# Description
Remove lens (Chain ID 232) from the codebase since it is no longer
supported by the organization.

# Changes
Remove lens from the configs and the chain lists across the services.

## How to test
<!--- Include details of how to test your changes, including any
pre-requisites. If no unit tests are included, please explain why and
how to test manually
1. Run `just test-unit` to execute unit tests and ensure no logic is
broken.
2. Run `just test-e2e-local` to run the active end-to-end test suite.
3. Validate compilation and lints using `cargo clippy --workspace
--all-targets --all-features`.
---
 crates/chain/src/lib.rs                       |  6 +-
 crates/contracts/build.rs                     | 55 +++++++------------
 crates/liquidity-sources/src/lib.rs           |  1 -
 crates/orderbook/openapi.yml                  |  4 --
 .../price-estimation/src/native/coingecko.rs  |  1 -
 5 files changed, 21 insertions(+), 46 deletions(-)

diff --git a/crates/chain/src/lib.rs b/crates/chain/src/lib.rs
index 0321b30b53..3f21cc0d5a 100644
--- a/crates/chain/src/lib.rs
+++ b/crates/chain/src/lib.rs
@@ -19,7 +19,6 @@ pub enum Chain {
     Avalanche = 43114,
     Optimism = 10,
     Polygon = 137,
-    Lens = 232,
     Linea = 59144,
     Plasma = 9745,
     Ink = 57073,
@@ -47,7 +46,6 @@ impl Chain {
             Self::Avalanche => "Avalanche",
             Self::Optimism => "Optimism",
             Self::Polygon => "Polygon",
-            Self::Lens => "Lens",
             Self::Linea => "Linea",
             Self::Plasma => "Plasma",
             Self::Ink => "Ink",
@@ -66,7 +64,7 @@ impl Chain {
             | Self::Linea
             | Self::Optimism
             | Self::Ink => U256::from(10u128.pow(17)),
-            Self::Gnosis | Self::Avalanche | Self::Lens => U256::from(10u128.pow(18)),
+            Self::Gnosis | Self::Avalanche => U256::from(10u128.pow(18)),
             Self::Polygon | Self::Plasma => U256::from(10u128.pow(20)),
             Self::Hardhat => {
                 panic!("unsupported chain for default amount to estimate native prices with")
@@ -88,7 +86,6 @@ impl Chain {
             Self::Avalanche => Duration::from_millis(2_000),
             Self::Optimism => Duration::from_millis(2_000),
             Self::Polygon => Duration::from_millis(2_000),
-            Self::Lens => Duration::from_millis(2_000),
             Self::Linea => Duration::from_millis(2_000),
             Self::Plasma => Duration::from_millis(1_000),
             Self::Ink => Duration::from_millis(1_000),
@@ -120,7 +117,6 @@ impl TryFrom<u64> for Chain {
             x if x == Self::Avalanche as u64 => Self::Avalanche,
             x if x == Self::Optimism as u64 => Self::Optimism,
             x if x == Self::Polygon as u64 => Self::Polygon,
-            x if x == Self::Lens as u64 => Self::Lens,
             x if x == Self::Linea as u64 => Self::Linea,
             x if x == Self::Plasma as u64 => Self::Plasma,
             x if x == Self::Ink as u64 => Self::Ink,
diff --git a/crates/contracts/build.rs b/crates/contracts/build.rs
index 1bc4994c36..5a8716d180 100644
--- a/crates/contracts/build.rs
+++ b/crates/contracts/build.rs
@@ -22,7 +22,6 @@ mod networks {
     pub const AVALANCHE: u64 = 43114;
     pub const BNB: u64 = 56;
     pub const OPTIMISM: u64 = 10;
-    pub const LENS: u64 = 232;
     pub const LINEA: u64 = 59144;
     pub const PLASMA: u64 = 9745;
     pub const INK: u64 = 57073;
@@ -104,7 +103,7 @@ fn main() {
             BNB => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
             OPTIMISM => "0xdef1abe32c034e558cdd535791643c58a13acc10",
             POLYGON => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            // Not available on Lens
+            // Not available on Linea, Plasma and Ink
         ]))
         // Misc
         .add_contract(Contract::new("ERC20"))
@@ -129,7 +128,7 @@ fn main() {
                 MAINNET => ("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9", 12272147),
                 // Not available on Sepolia (only version ≥ 4)
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // Not available on Lens, Linea, Plasma and Ink
+                // Not available on Linea, Plasma and Ink
             ]),
         )
         // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
@@ -149,7 +148,7 @@ fn main() {
                 BNB => ("0x6e4cF292C5349c79cCd66349c3Ed56357dD11B46", 25474982),
                 // Not available on Sepolia (only version ≥ 4)
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // Not available on Lens, Linea, Plasma and Ink
+                // Not available on Linea, Plasma and Ink
             ]),
         )
         .add_contract(
@@ -173,7 +172,7 @@ fn main() {
                 POLYGON => ("0xFc8a407Bba312ac761D8BFe04CE1201904842B76", 40611103),
                 // <https://bscscan.com/tx/0xc7fada60761e3240332c4cbd169633f1828b2a15de23f0148db9d121afebbb4b>
                 BNB => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 26665331),
-                // Not available on Base, Lens, Linea, Plasma and Ink
+                // Not available on Base, Linea, Plasma and Ink
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
             ]),
         )
@@ -187,7 +186,7 @@ fn main() {
                 OPTIMISM => ("0xdAE7e32ADc5d490a43cCba1f0c736033F2b4eFca", 7005512),
                 // <https://polygonscan.com/tx/0xb8ac851249cc95bc0943ef0732d28bbd53b0b36c7dd808372666acd8c5f26e1c>
                 POLYGON => ("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9", 15832998),
-                // Not available on Sepolia, Base, Avalanche, BNB, Lens, Linea, Plasma and Ink
+                // Not available on Sepolia, Base, Avalanche, BNB, Linea, Plasma and Ink
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
             ]),
@@ -204,7 +203,7 @@ fn main() {
                 OPTIMISM => ("0xeb151668006CD04DAdD098AFd0a82e78F77076c3", 11088891),
                 // <https://polygonscan.com/tx/0xa2c41d014791888a29a9491204446c1b9b2f5dee3f3eb31ad03f290259067b44>
                 POLYGON => ("0xcA96C4f198d343E251b1a01F3EBA061ef3DA73C1", 29371951),
-                // Not available on Sepolia, Base, Avalanche, BNB, Lens, Linea, Plasma and Ink
+                // Not available on Sepolia, Base, Avalanche, BNB, Linea, Plasma and Ink
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
             ]),
@@ -217,7 +216,7 @@ fn main() {
                 ARBITRUM_ONE => ("0x142B9666a0a3A30477b052962ddA81547E7029ab", 222870),
                 // <https://polygonscan.com/tx/0xd9b5b9a9e6ea17a87f85574e93577e3646c9c2f9c8f38644f936949e6c853288>
                 POLYGON => ("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE", 17116402),
-                // Not available on Sepolia, Base, Avalanche, BNB, Optimism, Lens, Linea, Plasma and Ink
+                // Not available on Sepolia, Base, Avalanche, BNB, Optimism, Linea, Plasma and Ink
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
             ]),
@@ -245,7 +244,7 @@ fn main() {
                     OPTIMISM => ("0xf302f9F50958c5593770FDf4d4812309fF77414f", 7005915),
                     // <https://polygonscan.com/tx/0x125bc007a86d771f8dc8f5fa1017de6e5a11162a458a72f25814503404bbeb0b>
                     POLYGON => ("0x41B953164995c11C81DA73D212ED8Af25741b7Ac", 22067480),
-                    // Not available on Lens, Linea, Plasma and Ink
+                    // Not available on Linea, Plasma and Ink
                 ]),
         )
         .add_contract(
@@ -259,7 +258,7 @@ fn main() {
                 OPTIMISM => ("0xf145caFB67081895EE80eB7c04A30Cf87f07b745", 22182522),
                 // <https://polygonscan.com/tx/0xe5d908be686056f1519663a407167c088924f60d29c799ec74438b9de891989e>
                 POLYGON => ("0x136FD06Fa01eCF624C7F2B3CB15742c1339dC2c4", 32774224),
-                // Not available on Sepolia, Gnosis Chain, Base, Avalanche, Lens, Linea, Plasma and Ink
+                // Not available on Sepolia, Gnosis Chain, Base, Avalanche, Linea, Plasma and Ink
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
             ]),
@@ -280,7 +279,7 @@ fn main() {
                 // Not available on Sepolia (only version ≥ 4) and on Base (only version ≥ 5)
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-                // Not available on Lens, Linea, Plasma and Ink
+                // Not available on Linea, Plasma and Ink
             ]),
         )
         .add_contract(
@@ -301,7 +300,7 @@ fn main() {
                 OPTIMISM => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 82748180),
                 // <https://polygonscan.com/tx/0x2cea6a0683e67ebdb7d4a1cf1ad303126c5f228f05f8c9e2ccafdb1f5a024376>
                 POLYGON => ("0x6Ab5549bBd766A43aFb687776ad8466F8b42f777", 40613553),
-                // Not available on Base, Lens, Linea, Plasma and Ink
+                // Not available on Base, Linea, Plasma and Ink
                 // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
             ]),
         )
@@ -325,7 +324,7 @@ fn main() {
                 OPTIMISM => ("0x043A2daD730d585C44FB79D2614F295D2d625412", 106752707),
                 // <https://polygonscan.com/tx/0xa3d9a1cf00eaca469d6f9ec2fb836bbbfdfbc3b0eeadc07619bb9e695bfdecb8>
                 POLYGON => ("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b", 44961548),
-                // Not available on Lens, Linea, Plasma and Ink
+                // Not available on Linea, Plasma and Ink
             ]),
         )
         .add_contract(
@@ -348,7 +347,7 @@ fn main() {
                 OPTIMISM => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 116694338),
                 // <https://polygonscan.com/tx/0x7b9678ad538b1cd3f3a03e63455e7d49a1bc716ea42310fbf99df4bf93ecfdfa>
                 POLYGON => ("0xEAedc32a51c510d35ebC11088fD5fF2b47aACF2E", 53996258),
-                // Not available on Lens, Linea, Plasma and Ink
+                // Not available on Linea, Plasma and Ink
             ]),
         )
         // Balancer addresses can be obtained from:
@@ -374,7 +373,7 @@ fn main() {
             POLYGON => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 15832990),
             // <https://explorer.inkonchain.com/address/0xBA12222222228d8Ba445958a75a0704d566BF2C8>
             INK => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 34313901),
-            // Not available on Lens, Linea and Plasma
+            // Not available on Linea and Plasma
         ]))
         .add_contract(
             Contract::new("BalancerV3BatchRouter").with_networks(networks![
@@ -394,7 +393,7 @@ fn main() {
                 OPTIMISM => ("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E", 133969588),
                 // <https://plasmascan.to/tx/0x7368609020622059d1061b4e3cc16aa448315956cace1e089f6876143cf2f90c?chainid=9745>
                 PLASMA => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 782312),
-                // Not available on Lens, Polygon, BNB, Linea and Ink
+                // Not available on Polygon, BNB, Linea and Ink
             ]),
         )
         // UniV2
@@ -433,7 +432,7 @@ fn main() {
             OPTIMISM => "0x2abf469074dc0b54d793850807e6eb5faf2625b1",
             // <https://polygonscan.com/tx/0x3dcf8fc780ae6fbe40b1ae57927a8fb405f54cbe89d0021a781a100d2086e5ba>
             POLYGON => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
-            // Not available on Lens
+            // Not available on Linea, Plasma and Ink
         ]))
         // <https://swapr.gitbook.io/swapr/contracts>
         .add_contract(Contract::new("SwaprRouter").with_networks(networks![
@@ -443,7 +442,7 @@ fn main() {
             GNOSIS => "0xE43e60736b1cb4a75ad25240E2f9a62Bff65c0C0",
             // <https://arbiscan.io/tx/0x09771774fc138775472910f6bb0f2e03ff74e1e32a658e9c3e4d8f59f6431ba8>
             ARBITRUM_ONE => "0x530476d5583724A89c8841eB6Da76E7Af4C0F17E",
-            // Not available on Base and Lens
+            // Not available on Base, Linea, Plasma and Ink
         ]))
         .add_contract(Contract::new("ISwaprPair"))
         .add_contract(
@@ -472,7 +471,7 @@ fn main() {
             OPTIMISM => "0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf",
             // <https://polygonscan.com/tx/0x712ac56155a301fca4b7a761e232233f41a104865a74b1a59293835da355292a>
             POLYGON => "0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C",
-            // Not available on Lens and Ink (no Uniswap V2)
+            // Not available on Ink (no Uniswap V2)
         ]))
         // <https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02>
         .add_contract(Contract::new("UniswapV2Router02").with_networks(networks![
@@ -494,7 +493,7 @@ fn main() {
             OPTIMISM => "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
             // <https://polygonscan.com/tx/0x66186e0cacd2f6b3ad2eae586bd331daafd0572eb80bf71be694181858198025>
             POLYGON => "0xedf6066a2b290C185783862C7F4776A2C8077AD1",
-            // Not available on Lens and Ink (no Uniswap V2)
+            // Not available on Ink (no Uniswap V2)
         ]))
         .add_contract(Contract::new("IUniswapLikeRouter"))
         .add_contract(Contract::new("IUniswapLikePair"))
@@ -508,7 +507,6 @@ fn main() {
             BNB => "0x78D78E420Da98ad378D7799bE8f4AF69033EB077",
             OPTIMISM => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
             POLYGON => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-            LENS => "0x1eEA2B790Dc527c5a4cd3d4f3ae8A2DDB65B2af1",
             LINEA => "0x42bE4D6527829FeFA1493e1fb9F3676d2425C3C1",
             // not official (deployed by oku trade)
             // <https://docs.oku.trade/home/extra-information/deployed-contracts#plasma>
@@ -527,7 +525,6 @@ fn main() {
                 BASE => "0x2626664c2603336E57B271c5C0b26F421741e481",
                 AVALANCHE => "0xbb00FF08d01D300023C629E8fFfFcb65A5a578cE",
                 BNB => "0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2",
-                LENS => "0x6ddD32cd941041D8b61df213B9f515A7D288Dc13",
                 LINEA => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
                 // not official (deployed by oku trade)
                 // <https://docs.oku.trade/home/extra-information/deployed-contracts#plasma>
@@ -547,8 +544,6 @@ fn main() {
             BNB => "0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7",
             OPTIMISM => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
             POLYGON => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            // not official
-            LENS => "0xc3A5b857Ba82a2586A45a8B59ECc3AA50Bc3D0e3",
             LINEA => "0x31FAfd4889FA1269F7a13A66eE0fB458f27D72A9",
             // not official (deployed by oku trade)
             // <https://docs.oku.trade/home/extra-information/deployed-contracts#plasma>
@@ -569,7 +564,6 @@ fn main() {
             BNB => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             OPTIMISM => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             POLYGON => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            LENS => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             LINEA => "0x60bf78233f48ec42ee3f101b9a05ec7878728006",
             PLASMA => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             INK => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
@@ -594,8 +588,6 @@ fn main() {
             OPTIMISM => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 134607215),
             // <https://polygonscan.com/tx/0xc3781c19674d97623d13afc938fca94d53583f4051020512100e84fecd230f91>
             POLYGON => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 71296258),
-            // <https://explorer.lens.xyz/tx/0xc59b5ffadb40158f9390b1d77f19346dbe9214b27f26346dfa2990ad379a1a32>
-            LENS => ("0xFb337f8a725A142f65fb9ff4902d41cc901de222", 3007173),
             // <https://lineascan.build/tx/0x0e20a4e0bbce2e28b89b7dcfc4dd4dfb48f5b0b8473b3b5bdeb1bf9f09943485>
             LINEA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 24522097),
             // <https://plasmascan.to/tx/0xda72b111ac2a7d182bf3c884373882add6f4c78f6d4bdae7efcae143be716b38>
@@ -619,7 +611,7 @@ fn main() {
             POLYGON => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 30988035),
             // <https://snowtrace.io/tx/0xf484e1efde47209bad5f72642bcb8d8e2a4092a5036434724ffa2d039e93a1bf?chainid=43114>
             AVALANCHE => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 26387068),
-            // Not available on Lens, Linea, Plasma and Ink
+            // Not available on Linea, Plasma and Ink
         ]))
         // <https://liquorice.gitbook.io/liquorice-docs/links/smart-contracts>
         .add_contract(
@@ -693,8 +685,6 @@ fn main() {
                 OPTIMISM => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 134254466),
                 // <https://polygonscan.com/tx/0x686e4bbcfd6ebae91f0fcc667407c831953629877ec622457916729de3d461c3>
                 POLYGON => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 45854728),
-                // <https://explorer.lens.xyz/tx/0x0730c21885153dcc9a25ab7abdc38309ec7c7a8db15b763fbbaf574d1e7ec498>
-                LENS => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 2612937),
                 // <https://lineascan.build/tx/0x6e5d2c4381320efdd21ccde1534560ded1b9ab07638776833faa22820c378155>
                 LINEA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 24333100),
                 // <https://plasmascan.to/tx/0xc2ac50ad302e402c4db1e956bd357af7d84e3684ad65e4fdee58abea092ac88c>
@@ -722,8 +712,6 @@ fn main() {
             OPTIMISM => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 134254624),
             // <https://polygonscan.com/tx/0x0e24d3a2a8530eaad5ae62e54e64d57665a77ce3970227d20c1b77da315cbbf6>
             POLYGON => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 45859743),
-            // <https://explorer.lens.xyz/tx/0x01584b767dda7b115394b93dbcfecadfe589862ae3f7957846a2db82f2f5c703>
-            LENS => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 2621745),
             // <https://lineascan.build/tx/0x6e5d2c4381320efdd21ccde1534560ded1b9ab07638776833faa22820c378155>
             LINEA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 24333100),
             // <https://plasmascan.to/tx/0xf16bd6f307dce94ab252d8dd8266ab30091879fb3d631cbcf3d0ffddf9e6ad05?chainid=9745>
@@ -743,7 +731,6 @@ fn main() {
             BNB => "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
             OPTIMISM => "0x4200000000000000000000000000000000000006",
             POLYGON => "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-            LENS => "0x6bDc36E20D267Ff0dd6097799f82e78907105e2F",
             LINEA => "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
             PLASMA => "0x6100E367285b01F48D07953803A2d8dCA5D19873",
             INK => "0x4200000000000000000000000000000000000006",
@@ -805,7 +792,6 @@ fn main() {
                     BNB => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     OPTIMISM => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     POLYGON => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    LENS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     GNOSIS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     SEPOLIA => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     // built with evm=London, because deployment reverts on Linea otherwise
@@ -822,7 +808,6 @@ fn main() {
                     BNB => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
                     OPTIMISM => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
                     POLYGON => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    LENS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
                     GNOSIS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
                     SEPOLIA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
                     PLASMA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
diff --git a/crates/liquidity-sources/src/lib.rs b/crates/liquidity-sources/src/lib.rs
index bf3ef43fc8..62a89b5d10 100644
--- a/crates/liquidity-sources/src/lib.rs
+++ b/crates/liquidity-sources/src/lib.rs
@@ -65,7 +65,6 @@ pub fn defaults_for_network(chain: &Chain) -> Vec<BaselineSource> {
             BaselineSource::ZeroEx,
             BaselineSource::UniswapV3,
         ],
-        Chain::Lens => vec![BaselineSource::UniswapV3],
         Chain::Linea => vec![BaselineSource::UniswapV3],
         Chain::Plasma => vec![BaselineSource::UniswapV3],
         Chain::Ink => vec![BaselineSource::UniswapV3],
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 5e16973189..236f85d68e 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -27,10 +27,6 @@ servers:
     url: "https://api.cow.fi/polygon"
   - description: Polygon (Staging)
     url: "https://barn.api.cow.fi/polygon"
-  - description: Lens (Prod)
-    url: "https://api.cow.fi/lens"
-  - description: Lens (Staging)
-    url: "https://barn.api.cow.fi/lens"
   - description: Linea (Prod)
     url: "https://api.cow.fi/linea"
   - description: Linea (Staging)
diff --git a/crates/price-estimation/src/native/coingecko.rs b/crates/price-estimation/src/native/coingecko.rs
index 40019f47d7..83b2629ba2 100644
--- a/crates/price-estimation/src/native/coingecko.rs
+++ b/crates/price-estimation/src/native/coingecko.rs
@@ -78,7 +78,6 @@ impl CoinGecko {
             Chain::Polygon => "polygon-pos".to_string(),
             Chain::Optimism => "optimistic-ethereum".to_string(),
             Chain::Bnb => "binance-smart-chain".to_string(),
-            Chain::Lens => "lens".to_string(),
             Chain::Linea => "linea".to_string(),
             Chain::Plasma => "plasma".to_string(),
             Chain::Ink => "ink".to_string(),

From d7fa1f953a124fde487e24d5965956316664714c Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 19 Mar 2026 11:01:59 +0000
Subject: [PATCH 156/219] Add knob to ensure gas floor for unverified quotes
 (#4276)

# Description

Some tokens (e.g. Ondo RWA tokens) have high transfer gas costs that
solvers underestimate in unverified quotes. This leads to fees that
don't cover execution gas, making small orders (~$20) unprofitable for
solvers, so they expire unfilled. This is blocking Binance from enabling
their mainnet flow with CoW.

Adds a configurable gas floor for unverified quotes:
min-gas-amount-for-unverified-quotes. When set, any unverified quote
reporting less gas than the floor gets bumped up. Verified quotes (which
get accurate gas from simulation) are unaffected. Defaults to 0
(disabled, preserving current behavior).

## How to test

```
cargo test --package shared --lib -- order_quoting::tests::min_gas_floor_applied_to_unverified_quote --exact --nocapture
```
---
 crates/autopilot/src/run.rs            |   1 +
 crates/configs/src/price_estimation.rs |  14 ++++
 crates/orderbook/src/run.rs            |   1 +
 crates/shared/src/order_quoting.rs     | 111 ++++++++++++++++++++++++-
 4 files changed, 126 insertions(+), 1 deletion(-)

diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index f6685fb46e..a9865ac572 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -456,6 +456,7 @@ pub async fn run(
         balance_fetcher.clone(),
         config.price_estimation.quote_verification,
         config.price_estimation.quote_timeout,
+        config.price_estimation.min_gas_amount_for_unverified_quotes,
     ));
 
     let solvable_orders_cache = SolvableOrdersCache::new(
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index 690a7e0949..e4346efef3 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -82,6 +82,16 @@ pub struct PriceEstimation {
     #[serde(default = "default_max_gas_per_tx")]
     pub max_gas_per_tx: u64,
 
+    /// Minimum gas amount for unverified quotes. When an unverified quote
+    /// reports less gas than this, the floor is used instead. Verified quotes
+    /// are unaffected. Defaults to 0 (disabled).
+    ///
+    /// Some tokens (e.g. Ondo RWA tokens) have high transfer costs that
+    /// solvers underestimate in unverified quotes, leading to fees that don't
+    /// cover execution gas and causing small orders to expire unfilled.
+    #[serde(default)]
+    pub min_gas_amount_for_unverified_quotes: u64,
+
     /// Tenderly configuration (URL, project & API key).
     #[serde(default)]
     pub tenderly: Option<TenderlyConfig>,
@@ -109,6 +119,7 @@ impl Default for PriceEstimation {
             balance_overrides: Default::default(),
             tokens_without_verification: Default::default(),
             max_gas_per_tx: default_max_gas_per_tx(),
+            min_gas_amount_for_unverified_quotes: 0,
         }
     }
 }
@@ -330,6 +341,7 @@ mod tests {
         assert_eq!(config.balance_overrides.probing_depth, 60);
         assert_eq!(config.balance_overrides.cache_size, 1000);
         assert!(config.tokens_without_verification.is_empty());
+        assert_eq!(config.min_gas_amount_for_unverified_quotes, 0);
     }
 
     #[test]
@@ -340,6 +352,7 @@ mod tests {
         quote-timeout = "10s"
         tokens-without-verification = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
         amount-to-estimate-prices-with = "1000000000000000000"
+        min-gas-amount-for-unverified-quotes = 400000
 
         [price-estimation-rate-limiter]
         back-off-growth-factor = 2.0
@@ -401,6 +414,7 @@ mod tests {
         assert_eq!(config.balance_overrides.probing_depth, 30);
         assert_eq!(config.balance_overrides.cache_size, 500);
         assert_eq!(config.tokens_without_verification.len(), 1);
+        assert_eq!(config.min_gas_amount_for_unverified_quotes, 400_000);
     }
 
     #[test]
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index fb056c9f66..f824c1b093 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -341,6 +341,7 @@ pub async fn run(args: Arguments, config: Configuration) {
             balance_fetcher.clone(),
             verification,
             config.price_estimation.quote_timeout,
+            config.price_estimation.min_gas_amount_for_unverified_quotes,
         ))
     };
     let optimal_quoter = create_quoter(price_estimator, config.price_estimation.quote_verification);
diff --git a/crates/shared/src/order_quoting.rs b/crates/shared/src/order_quoting.rs
index 64dbddc26a..5fd780d856 100644
--- a/crates/shared/src/order_quoting.rs
+++ b/crates/shared/src/order_quoting.rs
@@ -421,6 +421,7 @@ pub struct OrderQuoter {
     balance_fetcher: Arc<dyn BalanceFetching>,
     quote_verification: QuoteVerificationMode,
     default_quote_timeout: std::time::Duration,
+    min_gas_amount_for_unverified_quotes: u64,
 }
 
 impl OrderQuoter {
@@ -434,6 +435,7 @@ impl OrderQuoter {
         balance_fetcher: Arc<dyn BalanceFetching>,
         quote_verification: QuoteVerificationMode,
         default_quote_timeout: std::time::Duration,
+        min_gas_amount_for_unverified_quotes: u64,
     ) -> Self {
         Self {
             price_estimator,
@@ -445,6 +447,7 @@ impl OrderQuoter {
             balance_fetcher,
             quote_verification,
             default_quote_timeout,
+            min_gas_amount_for_unverified_quotes,
         }
     }
 
@@ -496,8 +499,21 @@ impl OrderQuoter {
                 buy_amount_after_fee: buy_amount,
             } => (trade_estimate.out_amount, buy_amount.get()),
         };
+        let gas_amount = if !trade_estimate.verified
+            && self.min_gas_amount_for_unverified_quotes > 0
+            && trade_estimate.gas < self.min_gas_amount_for_unverified_quotes
+        {
+            tracing::debug!(
+                original_gas = trade_estimate.gas,
+                floor = self.min_gas_amount_for_unverified_quotes,
+                "applying minimum gas floor to unverified quote"
+            );
+            self.min_gas_amount_for_unverified_quotes
+        } else {
+            trade_estimate.gas
+        };
         let fee_parameters = FeeParameters {
-            gas_amount: trade_estimate.gas as _,
+            gas_amount: gas_amount as _,
             gas_price: effective_gas_price as f64,
             sell_token_price,
         };
@@ -939,6 +955,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1079,6 +1096,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1214,6 +1232,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1312,6 +1331,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1385,6 +1405,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1446,6 +1467,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1529,6 +1551,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1614,6 +1637,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1687,6 +1711,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1718,6 +1743,7 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+            min_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1736,6 +1762,89 @@ mod tests {
         ));
     }
 
+    #[tokio::test]
+    async fn min_gas_floor_applied_to_unverified_quote() {
+        let now = Utc::now();
+        let parameters = QuoteParameters {
+            sell_token: Address::from([1; 20]),
+            buy_token: Address::from([2; 20]),
+            side: OrderQuoteSide::Buy {
+                buy_amount_after_fee: NonZeroU256::try_from(42).unwrap(),
+            },
+            verification: Verification {
+                from: Address::from([3; 20]),
+                ..Default::default()
+            },
+            signing_scheme: QuoteSigningScheme::Eip712,
+            additional_gas: 0,
+            timeout: None,
+        };
+        let gas_price = Eip1559Estimation {
+            max_fee_per_gas: 2,
+            max_priority_fee_per_gas: 1,
+        };
+
+        let mock_estimate = |verified: bool| {
+            let mut price_estimator = MockPriceEstimating::new();
+            price_estimator.expect_estimate().returning(move |_| {
+                async move {
+                    Ok(price_estimation::Estimate {
+                        out_amount: AlloyU256::from(42),
+                        gas: 100_000,
+                        solver: Address::repeat_byte(1),
+                        verified,
+                        execution: Default::default(),
+                    })
+                }
+                .boxed()
+            });
+            price_estimator
+        };
+
+        let mock_native = || {
+            let mut native = MockNativePriceEstimating::new();
+            native
+                .expect_estimate_native_price()
+                .returning(|_, _| async { Ok(0.2) }.boxed());
+            native
+        };
+
+        let quoter = |verified: bool, min_gas_floor: u64| {
+            let mut storage = MockQuoteStoring::new();
+            storage.expect_save().returning(|_| Ok(1));
+            OrderQuoter {
+                price_estimator: Arc::new(mock_estimate(verified)),
+                native_price_estimator: Arc::new(mock_native()),
+                gas_estimator: Arc::new(FakeGasPriceEstimator::new(gas_price)),
+                storage: Arc::new(storage),
+                now: Arc::new(now),
+                validity: Validity::default(),
+                quote_verification: QuoteVerificationMode::Unverified,
+                balance_fetcher: mock_balance_fetcher(),
+                default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
+                min_gas_amount_for_unverified_quotes: min_gas_floor,
+            }
+        };
+
+        // Unverified quote with floor > gas: floor should apply.
+        let quote = quoter(false, 500_000)
+            .calculate_quote(parameters.clone())
+            .await
+            .unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 500_000.);
+
+        // Verified quote with floor > gas: floor should NOT apply.
+        let quote = quoter(true, 500_000)
+            .calculate_quote(parameters.clone())
+            .await
+            .unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
+
+        // Unverified quote with floor = 0: no floor applied.
+        let quote = quoter(false, 0).calculate_quote(parameters).await.unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
+    }
+
     #[test]
     fn check_quote_metadata_format() {
         let q: QuoteMetadata = QuoteMetadataV1 {

From 3c96711a67c25d74572fd2bfc56797d64d4bc9db Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Thu, 19 Mar 2026 13:03:39 +0100
Subject: [PATCH 157/219] More efficient account trades query (#4273)

# Description
Currently the user trades query is very slow on base and xdai. On those
networks the query planner decides to do full scans of the trades table
instead of using existing indexes to speed things up.
This causes those queries to be orders of magnitude slower on xdai and
base compared to mainnet which has by far the biggest tables.


# Changes

This query introduces a few changes to speed things up:
1. new index
So far in order to figure out the owner of an trade we needed to join
the orders table onto the trades table. This is where the query planner
made unreliable decisions (trades table scan, vs orders index scan and
join trades on top). The new approach is to use an index based on an
expression. Since the order uid already contains the owner as a subslice
of the data we can extract it using `substring(order_uid, 33, 20)`
(slice starts at 33rd index due to postgres' 1 based indexing, 20 for 20
bytes of data in an ethereum address). As long as a query uses exactly
this expression the index can be used. In practice I also had to throw
in the `block_number` and `log_index` to convince the query planner to
actually use it for our complicated query

2. join on trades columns
in order to help the query planner as much as possible we don't do
transitive joins.
So instead of:
```
FROM trades t
JOIN orders o ON o.uid = t.order_uid
JOIN onchain_placed_orders opo ON opo.uid = o.uid
```
we now do
```
FROM trades t
JOIN orders o ON o.uid = t.order_uid
JOIN onchain_placed_orders opo ON opo.uid = t.order_uid
```

3. Use regular JOINs whenever possible
Previously the query used left joins when dealing with
`onchain_placed_orders` but this could just be replaced with regular
joins. If the needed row in `onchain_placed_orders` does not exist we'll
not get a result which is actually what we want. These stricter JOINs
help with query planning.

4. JOIN order depending on data distribution
Especially for accounts with many orders it's better to select from
`jit_orders` and then join the `trades` on them. That way we have a very
good filter early on (there are very few `jit_orders` in general and
even fewer where the `owner` and `uid` match). In some cases the query
planner still preferred to do a linear scan so I needed to use a
`MATERIALIZED` CTE to force the query planner's hand to do the
reasonable thing.

The migration should be safe to execute as is. Since it avoids
introducing a new field on the `trades` table by using an expression
index instead we don't have the very expensive table rewrite. When I
manually created the table on the prod DB for the testing purposes the
index was created within 5s on mainnet.

## How to test
I started by testing the new index + query in prod mainnet, base, and
xdai as those are the most relevant chains. This query performed very
well (1-4 ms) for accounts with no orders (problematic for full table
scan) and accounts with many orders (problematic in some other queries I
tried along the way).

Once the performance was deemed acceptable I went ahead and updated the
unit tests to check for correctness.
I had to update the unit tests because they actually populated the DB
with partially non-sensical data as it was not relevant for the previous
query. Specifically order owners and order UIDs where associated with
each other where the `owner` part of the uid didn't match the `owner`
column of the `orders` table.
After that was adjusted all tests passed.

Also here are some performance metrics of the change captured on prod
xdai and base.
The number of slow queries on base dropped to 0 with the first iteration
of this PR. Also it dropped the DB CPU load from ~17% to ~6%
<img width="1825" height="454" alt="Screenshot 2026-03-19 at 10 53 16"
src="https://github.com/user-attachments/assets/a38a1d8e-a2b1-4202-87ef-ff5536bd4b5c"
/>
<img width="507" height="355" alt="Screenshot 2026-03-19 at 10 59 37"
src="https://github.com/user-attachments/assets/bc9fffb9-699c-402b-836f-d1ba61617fbc"
/>

For xdai to perform well in all scenarios I had to tweak the query
slightly. With the new version the slow queries on xdai also dropped to
0 (the 1 blip is me requesting 1000 trades instead of a few). Also this
flattened our the DB CPU usage at a stable ~3.3% with regular traffic.
<img width="1830" height="450" alt="Screenshot 2026-03-19 at 10 57 54"
src="https://github.com/user-attachments/assets/7c459113-cd57-48fa-8af3-093f1676bed8"
/>
<img width="499" height="349" alt="Screenshot 2026-03-19 at 10 57 39"
src="https://github.com/user-attachments/assets/b336044c-2abf-4e7b-a40b-57a56ebbe4d8"
/>
---
 crates/database/src/trades.rs                 | 282 ++++++++++++------
 .../V108__trade_owner_expression_index.sql    |  13 +
 2 files changed, 212 insertions(+), 83 deletions(-)
 create mode 100644 database/sql/V108__trade_owner_expression_index.sql

diff --git a/crates/database/src/trades.rs b/crates/database/src/trades.rs
index 13628a39f9..34ec8f92cb 100644
--- a/crates/database/src/trades.rs
+++ b/crates/database/src/trades.rs
@@ -28,7 +28,7 @@ pub fn trades<'a>(
     offset: i64,
     limit: i64,
 ) -> instrument::Instrumented<BoxStream<'a, Result<TradesQueryRow, sqlx::Error>>> {
-    const COMMON_QUERY: &str = r#"
+    const SELECT: &str = r#"
 SELECT
     t.block_number,
     t.log_index,
@@ -40,8 +40,9 @@ SELECT
     o.buy_token,
     o.sell_token,
     settlement.tx_hash,
-    settlement.auction_id
-FROM trades t
+    settlement.auction_id"#;
+
+    const SETTLEMENT_JOIN: &str = r#"
 LEFT OUTER JOIN LATERAL (
     SELECT tx_hash, auction_id FROM settlements s
     WHERE s.block_number = t.block_number
@@ -52,30 +53,56 @@ LEFT OUTER JOIN LATERAL (
 
     const QUERY: &str = const_format::concatcp!(
         "(",
-        COMMON_QUERY,
+        SELECT,
+        " FROM trades t",
+        SETTLEMENT_JOIN,
         " JOIN orders o ON o.uid = t.order_uid",
-        " WHERE ($1 IS NULL OR o.owner = $1)",
-        " AND ($2 IS NULL OR o.uid = $2)",
+        // the uid already contains the owner address and we have
+        // an index on this expression so this is very efficient
+        " WHERE ($1 IS NULL OR substring(t.order_uid, 33, 20) = $1)",
+        " AND ($2 IS NULL OR t.order_uid = $2)",
         " ORDER BY t.block_number DESC, t.log_index DESC",
         " LIMIT $3 + $4",
         ")",
         " UNION ",
         "(",
-        COMMON_QUERY,
+        SELECT,
+        " FROM trades t",
+        SETTLEMENT_JOIN,
         " JOIN orders o ON o.uid = t.order_uid",
-        " LEFT OUTER JOIN onchain_placed_orders onchain_o",
+        " JOIN onchain_placed_orders onchain_o",
         " ON onchain_o.uid = t.order_uid",
-        " WHERE onchain_o.sender = $1",
-        " AND ($2 IS NULL OR o.uid = $2)",
+        " WHERE ($1 IS NULL OR onchain_o.sender = $1)",
+        " AND ($2 IS NULL OR t.order_uid = $2)",
         " ORDER BY t.block_number DESC, t.log_index DESC",
         " LIMIT $3 + $4",
         ")",
         " UNION ",
+        // Note that we apply 2 tricks here:
+        // 1. we invert the join order (join `trades` onto `jit_orders` instead
+        // of `jit_orders` onto `trades`). For cases where 1 account has MANY
+        // trades joining `jit_orders` onto the trades means fetching data for
+        // MANY `jit_orders`. But given that `jit_orders` are rare inverting the
+        // join order means we only fetch few or no `jit_orders` at all when
+        // looking them up by `owner`.
+        // 2. we explicitly use a MATERIALIZED CTE to force the query planner
+        // to follow this lookup order. Without using `MATERIALIZED` the query
+        // planner can "inline" this sub-query and which can lead to incorrect
+        // optimization decisions.
+        // Specifically NOT using `MATERIALIZED` can lead to the query
+        // planner doing full scans on the `trades` table instead of searching
+        // via the `owner` index on the `jit_orders` table.
         "(",
-        COMMON_QUERY,
-        " JOIN jit_orders o ON o.uid = t.order_uid",
-        " WHERE ($1 IS NULL OR o.owner = $1)",
-        " AND ($2 IS NULL OR o.uid = $2)",
+        " WITH jit AS MATERIALIZED (",
+        "   SELECT uid, owner, buy_token, sell_token",
+        "   FROM jit_orders",
+        "   WHERE ($1 IS NULL OR owner = $1)",
+        "   AND ($2 IS NULL OR uid = $2)",
+        ")",
+        SELECT,
+        " FROM jit o",
+        " JOIN trades t ON o.uid = t.order_uid",
+        SETTLEMENT_JOIN,
         " ORDER BY t.block_number DESC, t.log_index DESC",
         " LIMIT $3 + $4",
         ")",
@@ -169,13 +196,28 @@ mod tests {
         sqlx::Connection,
     };
 
+    /// Generates 1 unique user and the provided number of unique orders
+    /// for that user.
     async fn generate_owners_and_order_ids(
-        num_owners: usize,
-        num_orders: usize,
-    ) -> (Vec<Address>, Vec<OrderUid>) {
-        let owners: Vec<Address> = (0..num_owners).map(|t| ByteArray([t as u8; 20])).collect();
-        let order_ids: Vec<OrderUid> = (0..num_orders).map(|i| ByteArray([i as u8; 56])).collect();
-        (owners, order_ids)
+        orders_for_user: &[usize],
+    ) -> Vec<(Address, Vec<OrderUid>)> {
+        orders_for_user
+            .iter()
+            .enumerate()
+            .map(|(index, num_orders)| {
+                let user = ByteArray([index as u8; 20]);
+                let orders = (0usize..*num_orders)
+                    .map(|index| {
+                        let mut uid_bytes = [index as u8; 56];
+                        // make sure to write the owner bytes correctly into
+                        // the order uid since those are used in some queries
+                        uid_bytes[32..52].copy_from_slice(&user.0);
+                        ByteArray(uid_bytes)
+                    })
+                    .collect();
+                (user, orders)
+            })
+            .collect()
     }
 
     async fn add_trade(
@@ -250,22 +292,37 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(2, 2).await;
+        // 1 user with 2 orders
+        let users_and_orders = generate_owners_and_order_ids(&[2]).await;
         assert_trades(&mut db, None, None, &[]).await;
         let event_index_a = EventIndex {
             block_number: 0,
             log_index: 0,
         };
-        let trade_a =
-            add_order_and_trade(&mut db, owners[0], order_ids[0], event_index_a, None, None).await;
+        let trade_a = add_order_and_trade(
+            &mut db,
+            users_and_orders[0].0,
+            users_and_orders[0].1[0],
+            event_index_a,
+            None,
+            None,
+        )
+        .await;
         assert_trades(&mut db, None, None, std::slice::from_ref(&trade_a)).await;
 
         let event_index_b = EventIndex {
             block_number: 1,
             log_index: 0,
         };
-        let trade_b =
-            add_order_and_trade(&mut db, owners[0], order_ids[1], event_index_b, None, None).await;
+        let trade_b = add_order_and_trade(
+            &mut db,
+            users_and_orders[0].0,
+            users_and_orders[0].1[1],
+            event_index_b,
+            None,
+            None,
+        )
+        .await;
         assert_trades(&mut db, None, None, &[trade_a, trade_b]).await;
     }
 
@@ -324,65 +381,80 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(4, 4).await;
+        let users_and_orders = generate_owners_and_order_ids(&[1, 1, 1, 1, 1]).await;
 
         let event_index_0 = EventIndex {
             block_number: 0,
             log_index: 0,
         };
-        let trade_0 =
-            add_order_and_trade(&mut db, owners[0], order_ids[0], event_index_0, None, None).await;
+        let trade_0 = add_order_and_trade(
+            &mut db,
+            users_and_orders[0].0,
+            users_and_orders[0].1[0],
+            event_index_0,
+            None,
+            None,
+        )
+        .await;
 
         let event_index_1 = EventIndex {
             block_number: 0,
             log_index: 1,
         };
-        let trade_1 =
-            add_order_and_trade(&mut db, owners[1], order_ids[1], event_index_1, None, None).await;
+        let trade_1 = add_order_and_trade(
+            &mut db,
+            users_and_orders[1].0,
+            users_and_orders[1].1[0],
+            event_index_1,
+            None,
+            None,
+        )
+        .await;
 
         assert_trades(
             &mut db,
-            Some(&owners[0]),
+            Some(&users_and_orders[0].0),
             None,
             std::slice::from_ref(&trade_0),
         )
         .await;
         assert_trades(
             &mut db,
-            Some(&owners[1]),
+            Some(&users_and_orders[1].0),
             None,
             std::slice::from_ref(&trade_1),
         )
         .await;
-        assert_trades(&mut db, Some(&owners[2]), None, &[]).await;
+        assert_trades(&mut db, Some(&users_and_orders[2].0), None, &[]).await;
 
         let onchain_order = OnchainOrderPlacement {
-            order_uid: ByteArray(order_ids[0].0),
-            sender: owners[3],
+            order_uid: users_and_orders[3].1[0],
+            sender: users_and_orders[4].0,
             placement_error: None,
         };
-        let event_index = EventIndex::default();
-        insert_onchain_order(&mut db, &event_index, &onchain_order)
+        let event_index_2 = EventIndex {
+            block_number: 0,
+            log_index: 2,
+        };
+        let trade_2 = add_order_and_trade(
+            &mut db,
+            users_and_orders[3].0,
+            users_and_orders[3].1[0],
+            event_index_2,
+            None,
+            None,
+        )
+        .await;
+        insert_onchain_order(&mut db, &event_index_2, &onchain_order)
             .await
             .unwrap();
         assert_trades(
             &mut db,
-            Some(&owners[3]),
+            Some(&users_and_orders[4].0),
             None,
-            std::slice::from_ref(&trade_0),
+            std::slice::from_ref(&trade_2),
         )
         .await;
-
-        add_order_and_trade(&mut db, owners[3], order_ids[3], event_index_1, None, None).await;
-        let onchain_order = OnchainOrderPlacement {
-            order_uid: ByteArray(order_ids[3].0),
-            sender: owners[3],
-            placement_error: None,
-        };
-        insert_onchain_order(&mut db, &event_index_1, &onchain_order)
-            .await
-            .unwrap();
-        assert_trades(&mut db, Some(&owners[3]), None, &[trade_0]).await;
     }
 
     #[tokio::test]
@@ -392,25 +464,40 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(2, 3).await;
+        // 3 users with 1 order each
+        let users_and_orders = generate_owners_and_order_ids(&[1, 1, 1]).await;
 
         let event_index_0 = EventIndex {
             block_number: 0,
             log_index: 0,
         };
-        let trade_0 =
-            add_order_and_trade(&mut db, owners[0], order_ids[0], event_index_0, None, None).await;
+        let trade_0 = add_order_and_trade(
+            &mut db,
+            users_and_orders[0].0,
+            users_and_orders[0].1[0],
+            event_index_0,
+            None,
+            None,
+        )
+        .await;
 
         let event_index_1 = EventIndex {
             block_number: 0,
             log_index: 1,
         };
-        let trade_1 =
-            add_order_and_trade(&mut db, owners[1], order_ids[1], event_index_1, None, None).await;
+        let trade_1 = add_order_and_trade(
+            &mut db,
+            users_and_orders[1].0,
+            users_and_orders[1].1[0],
+            event_index_1,
+            None,
+            None,
+        )
+        .await;
 
-        assert_trades(&mut db, None, Some(&order_ids[0]), &[trade_0]).await;
-        assert_trades(&mut db, None, Some(&order_ids[1]), &[trade_1]).await;
-        assert_trades(&mut db, None, Some(&order_ids[2]), &[]).await;
+        assert_trades(&mut db, None, Some(&users_and_orders[0].1[0]), &[trade_0]).await;
+        assert_trades(&mut db, None, Some(&users_and_orders[1].1[0]), &[trade_1]).await;
+        assert_trades(&mut db, None, Some(&users_and_orders[2].1[0]), &[]).await;
     }
 
     #[tokio::test]
@@ -420,16 +507,25 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(1, 1).await;
+        // 1 user with 1 order
+        let users_and_trades = generate_owners_and_order_ids(&[1]).await;
 
         let event_index = EventIndex {
             block_number: 0,
             log_index: 0,
         };
-        add_trade(&mut db, owners[0], order_ids[0], event_index, None, None).await;
+        add_trade(
+            &mut db,
+            users_and_trades[0].0,
+            users_and_trades[0].1[0],
+            event_index,
+            None,
+            None,
+        )
+        .await;
         // Trade exists in DB but no matching order
-        assert_trades(&mut db, None, Some(&order_ids[0]), &[]).await;
-        assert_trades(&mut db, Some(&owners[0]), None, &[]).await;
+        assert_trades(&mut db, None, Some(&users_and_trades[0].1[0]), &[]).await;
+        assert_trades(&mut db, Some(&users_and_trades[0].0), None, &[]).await;
     }
 
     // Testing Trades with settlements
@@ -465,7 +561,8 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(2, 2).await;
+        // 1 user with 2 orders
+        let users_and_orders = generate_owners_and_order_ids(&[2]).await;
         assert_trades(&mut db, None, None, &[]).await;
 
         let settlement = add_settlement(
@@ -482,8 +579,8 @@ mod tests {
 
         let trade_a = add_order_and_trade(
             &mut db,
-            owners[0],
-            order_ids[0],
+            users_and_orders[0].0,
+            users_and_orders[0].1[0],
             EventIndex {
                 block_number: 0,
                 log_index: 0,
@@ -496,8 +593,8 @@ mod tests {
 
         let trade_b = add_order_and_trade(
             &mut db,
-            owners[0],
-            order_ids[1],
+            users_and_orders[0].0,
+            users_and_orders[0].1[1],
             EventIndex {
                 block_number: 0,
                 log_index: 1,
@@ -516,7 +613,8 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(2, 2).await;
+        // 1 user with 2 orders
+        let users_and_trades = generate_owners_and_order_ids(&[2]).await;
         assert_trades(&mut db, None, None, &[]).await;
 
         let settlement = add_settlement(
@@ -533,8 +631,8 @@ mod tests {
 
         add_trade(
             &mut db,
-            owners[0],
-            order_ids[0],
+            users_and_trades[0].0,
+            users_and_trades[0].1[0],
             EventIndex {
                 block_number: 0,
                 log_index: 0,
@@ -546,8 +644,8 @@ mod tests {
 
         add_trade(
             &mut db,
-            owners[0],
-            order_ids[1],
+            users_and_trades[0].0,
+            users_and_trades[0].1[1],
             EventIndex {
                 block_number: 0,
                 log_index: 1,
@@ -567,7 +665,8 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        let (owners, order_ids) = generate_owners_and_order_ids(2, 2).await;
+        // 1 user with 2 orders
+        let users_and_orders = generate_owners_and_order_ids(&[2]).await;
         assert_trades(&mut db, None, None, &[]).await;
 
         let settlement_a_event = EventIndex {
@@ -598,8 +697,8 @@ mod tests {
 
         let trade_a = add_order_and_trade(
             &mut db,
-            owners[0],
-            order_ids[0],
+            users_and_orders[0].0,
+            users_and_orders[0].1[0],
             EventIndex {
                 block_number: 0,
                 log_index: 0,
@@ -612,8 +711,8 @@ mod tests {
 
         let trade_b = add_order_and_trade(
             &mut db,
-            owners[0],
-            order_ids[1],
+            users_and_orders[0].0,
+            users_and_orders[0].1[1],
             EventIndex {
                 block_number: 0,
                 log_index: 2,
@@ -659,7 +758,8 @@ mod tests {
         let token = Default::default();
         assert_eq!(token_first_trade_block(&mut db, token).await.unwrap(), None);
 
-        let (owners, order_ids) = generate_owners_and_order_ids(2, 2).await;
+        // 2 users with 1 order each
+        let users_and_orders = generate_owners_and_order_ids(&[1, 1]).await;
         let event_index_a = EventIndex {
             block_number: 123,
             log_index: 0,
@@ -668,8 +768,24 @@ mod tests {
             block_number: 124,
             log_index: 0,
         };
-        add_order_and_trade(&mut db, owners[0], order_ids[0], event_index_a, None, None).await;
-        add_order_and_trade(&mut db, owners[1], order_ids[1], event_index_b, None, None).await;
+        add_order_and_trade(
+            &mut db,
+            users_and_orders[0].0,
+            users_and_orders[0].1[0],
+            event_index_a,
+            None,
+            None,
+        )
+        .await;
+        add_order_and_trade(
+            &mut db,
+            users_and_orders[1].0,
+            users_and_orders[1].1[0],
+            event_index_b,
+            None,
+            None,
+        )
+        .await;
         assert_eq!(
             token_first_trade_block(&mut db, token).await.unwrap(),
             Some(123)
@@ -684,11 +800,11 @@ mod tests {
         crate::clear_DANGER_(&mut db).await.unwrap();
 
         // Create 5 trades with the same owner
-        let (owners, order_ids) = generate_owners_and_order_ids(1, 5).await;
-        let owner = owners[0];
+        let users_and_orders = generate_owners_and_order_ids(&[5]).await;
+        let owner = users_and_orders[0].0;
 
         let mut expected_trades = Vec::new();
-        for (i, order_id) in order_ids.iter().enumerate() {
+        for (i, order_id) in users_and_orders[0].1.iter().enumerate() {
             let trade = add_order_and_trade(
                 &mut db,
                 owner,
diff --git a/database/sql/V108__trade_owner_expression_index.sql b/database/sql/V108__trade_owner_expression_index.sql
new file mode 100644
index 0000000000..70c9a738ad
--- /dev/null
+++ b/database/sql/V108__trade_owner_expression_index.sql
@@ -0,0 +1,13 @@
+-- Creates an index optimized for searching trades of a given owner.
+-- Instead of introducing a whole new owner field that would result
+-- in a very expensive table rewrite we use the fact that the uid
+-- already contains the owner address.
+-- Since postgres supports expression based indexes we can just index
+-- the owner slice of the uid.
+-- Indexing the `block_number` and `log_index` is needed for postgres
+-- to actually use this index in the account trades query.
+CREATE INDEX CONCURRENTLY IF NOT EXISTS trades_order_uid_owner ON trades (
+    substring(order_uid, 33, 20),
+    block_number DESC,
+    log_index DESC
+);

From c0da9fc944d868bcd39b58d4af1197e499945037 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 19 Mar 2026 12:45:48 +0000
Subject: [PATCH 158/219] Configs to fix the playground (#4270)

# Description
Fixes the playground config

# Changes
<!-- List of detailed changes (how the change is accomplished) -->

* Playground config update
* configs/local update

## How to test
Run the playground
---
 configs/local/orderbook.toml                  |  1 -
 playground/autopilot.toml                     |  9 ------
 playground/baseline.toml                      | 14 ---------
 .../configs}/autopilot.toml                   |  5 +++-
 .../configs}/baseline.toml                    |  0
 .../local => playground/configs}/driver.toml  |  0
 playground/configs/orderbook.toml             | 11 +++++++
 playground/docker-compose.fork.yml            |  8 ++---
 playground/docker-compose.non-interactive.yml |  8 ++---
 playground/driver.toml                        | 29 -------------------
 playground/orderbook.toml                     |  1 -
 11 files changed, 23 insertions(+), 63 deletions(-)
 delete mode 100644 configs/local/orderbook.toml
 delete mode 100644 playground/autopilot.toml
 delete mode 100644 playground/baseline.toml
 rename {configs/local => playground/configs}/autopilot.toml (55%)
 rename {configs/local => playground/configs}/baseline.toml (100%)
 rename {configs/local => playground/configs}/driver.toml (100%)
 create mode 100644 playground/configs/orderbook.toml
 delete mode 100644 playground/driver.toml
 delete mode 100644 playground/orderbook.toml

diff --git a/configs/local/orderbook.toml b/configs/local/orderbook.toml
deleted file mode 100644
index da5cd3f553..0000000000
--- a/configs/local/orderbook.toml
+++ /dev/null
@@ -1 +0,0 @@
-eip1271-skip-creation-validation = true
diff --git a/playground/autopilot.toml b/playground/autopilot.toml
deleted file mode 100644
index 2afa93f908..0000000000
--- a/playground/autopilot.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-[[drivers]]
-name = "baseline"
-url = "http://driver/baseline"
-submission-account.address = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720"
-
-[fee-policies]
-
-[native-price-estimation]
-estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
diff --git a/playground/baseline.toml b/playground/baseline.toml
deleted file mode 100644
index 43e24b9983..0000000000
--- a/playground/baseline.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-chain-id = "1"  # Ethereum mainnet
-base-tokens = [
-  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",  # WETH
-  "0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
-  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
-  "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
-  "0xc00e94Cb662C3520282E6f5717214004A7f26888",  # COMP
-  "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",  # MKR
-  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",  # WBTC
-  "0x6810e776880C02933D47DB1b9fc05908e5386b96",  # GNO
-]
-max-hops = 2
-max-partial-attempts = 5
-native-token-price-estimation-amount = "100000000000000000"  # 0.1 ETH
diff --git a/configs/local/autopilot.toml b/playground/configs/autopilot.toml
similarity index 55%
rename from configs/local/autopilot.toml
rename to playground/configs/autopilot.toml
index 2afa93f908..c243409570 100644
--- a/configs/local/autopilot.toml
+++ b/playground/configs/autopilot.toml
@@ -1,9 +1,12 @@
 [[drivers]]
 name = "baseline"
 url = "http://driver/baseline"
-submission-account.address = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720"
+address = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720"
 
 [fee-policies]
 
+[order-quoting]
+price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]
+
 [native-price-estimation]
 estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
diff --git a/configs/local/baseline.toml b/playground/configs/baseline.toml
similarity index 100%
rename from configs/local/baseline.toml
rename to playground/configs/baseline.toml
diff --git a/configs/local/driver.toml b/playground/configs/driver.toml
similarity index 100%
rename from configs/local/driver.toml
rename to playground/configs/driver.toml
diff --git a/playground/configs/orderbook.toml b/playground/configs/orderbook.toml
new file mode 100644
index 0000000000..7d8f3c490b
--- /dev/null
+++ b/playground/configs/orderbook.toml
@@ -0,0 +1,11 @@
+eip1271-skip-creation-validation = true
+
+[order-quoting]
+price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]
+
+[native-price-estimation]
+estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
+
+[database]
+write-url = "%DB_WRITE_URL"
+read-url = "%DB_READ_URL"
diff --git a/playground/docker-compose.fork.yml b/playground/docker-compose.fork.yml
index b8655dbbf7..46ee4b596f 100644
--- a/playground/docker-compose.fork.yml
+++ b/playground/docker-compose.fork.yml
@@ -76,7 +76,7 @@ services:
         "cargo",
         "watch",
         "-x",
-        "run --bin orderbook -- --config configs/${ENV}/orderbook.toml",
+        "run --bin orderbook -- --config playground/configs/orderbook.toml",
       ]
     environment:
       - NODE_URL=http://chain:8545
@@ -115,7 +115,7 @@ services:
         "cargo",
         "watch",
         "-x",
-        "run --bin autopilot -- --config configs/${ENV}/autopilot.toml",
+        "run --bin autopilot -- --config playground/configs/autopilot.toml",
       ]
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
@@ -157,7 +157,7 @@ services:
         "cargo",
         "watch",
         "-x",
-        "run --bin driver -- --config configs/${ENV}/driver.toml",
+        "run --bin driver -- --config playground/configs/driver.toml",
       ]
     environment:
       - ETHRPC=http://chain:8545
@@ -189,7 +189,7 @@ services:
         "cargo",
         "watch",
         "-x",
-        "run --bin solvers -- baseline --config configs/${ENV}/baseline.toml",
+        "run --bin solvers -- baseline --config playground/configs/baseline.toml",
       ]
     environment:
       - ADDR=0.0.0.0:80
diff --git a/playground/docker-compose.non-interactive.yml b/playground/docker-compose.non-interactive.yml
index 1288112adb..a6efd62a07 100644
--- a/playground/docker-compose.non-interactive.yml
+++ b/playground/docker-compose.non-interactive.yml
@@ -91,7 +91,7 @@ services:
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
     volumes:
       - ../:/src
-      - ./orderbook.toml:/orderbook.toml
+      - ./configs/orderbook.toml:/orderbook.toml
     depends_on:
       - db-migrations
     ports:
@@ -125,7 +125,7 @@ services:
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
     volumes:
-      - ./autopilot.toml:/autopilot.toml
+      - ./configs/autopilot.toml:/autopilot.toml
     depends_on:
       orderbook:
         condition: service_started
@@ -152,7 +152,7 @@ services:
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
     volumes:
-      - ./driver.toml:/driver.toml
+      - ./configs/driver.toml:/driver.toml
     ports:
       - 9000:80 # API & metrics
       - 6671:6669 # tokio console
@@ -177,7 +177,7 @@ services:
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
     volumes:
-      - ./baseline.toml:/baseline.toml
+      - ./configs/baseline.toml:/baseline.toml
     ports:
       - 9001:80 # API & metrics
       - 6672:6669 # tokio console
diff --git a/playground/driver.toml b/playground/driver.toml
deleted file mode 100644
index 2e382e12ff..0000000000
--- a/playground/driver.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-tx-gas-limit = "45000000"
-
-[[solver]]
-name = "baseline"  # Arbitrary name given to this solver, must be unique
-endpoint = "http://baseline"
-absolute-slippage = "40000000000000000"  # Denominated in wei, optional
-relative-slippage = "0.1"  # Percentage in the [0, 1] range
-account = "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6"  # Known test private key
-
-[submission]
-gas-price-cap = "1000000000000"
-
-[[submission.mempool]]
-url = "http://chain:8545"
-
-[liquidity]
-base-tokens = [
-  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",  # WETH
-  "0x6B175474E89094C44Da98b954EedeAC495271d0F",  # DAI
-  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
-  "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
-  "0xc00e94Cb662C3520282E6f5717214004A7f26888",  # COMP
-  "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",  # MKR
-  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",  # WBTC
-  "0x6810e776880C02933D47DB1b9fc05908e5386b96",  # GNO
-]
-
-[[liquidity.uniswap-v2]]  # Uniswap V2 configuration
-preset = "uniswap-v2"
diff --git a/playground/orderbook.toml b/playground/orderbook.toml
deleted file mode 100644
index da5cd3f553..0000000000
--- a/playground/orderbook.toml
+++ /dev/null
@@ -1 +0,0 @@
-eip1271-skip-creation-validation = true

From bfc4d089789e095f6024a2e9a2850a548911f6ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Thu, 19 Mar 2026 13:24:23 +0000
Subject: [PATCH 159/219] Extract shared CLI arguments to config file-based
 SharedConfig (#4266)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Continues the migration from CLI-based configuration to file-based
configuration by moving shared arguments (node URL, contract addresses,
gas estimators, logging, tracing, ethrpc, current block) from
`clap`-based `shared::arguments::Arguments` to a serde-based
`SharedConfig` in the `configs` crate.

This is the final step in eliminating `CliArguments` from the autopilot
and orderbook `run()` functions, making both services fully driven by
their TOML configuration files.

# Changes

* Add `crates/configs/src/shared.rs` with `SharedConfig` and sub-configs
(`EthRpcConfig`, `CurrentBlockConfig`, `LoggingConfig`, `TracingConfig`,
`ContractAddresses`, `GasEstimatorType`, `TokenBucketFeeOverride`) — all
with serde deserialization, defaults, and tests.
* Remove the `Arguments` struct and related `Display` impl from
`crates/shared/src/arguments.rs`, keeping only types still used
elsewhere.
* Update `autopilot::run()` and `orderbook::run()` to read shared
settings from `config.shared` instead of the `CliArguments` parameter,
removing `CliArguments` from their signatures entirely.
* Add `SharedConfig` field to both `autopilot::Configuration` and
`orderbook::Configuration`.
* Update `configs/local/autopilot.toml`, `configs/local/orderbook.toml`,
and `playground/*.toml` with the new shared config sections, removing
corresponding CLI flags from `playground/docker-compose*.yml`.
* Simplify e2e test setup: replace CLI argument string building and
`ignore_overwritten_cli_params` hack with direct `SharedConfig` struct
construction. Remove `extra_args` / `ExtraServiceArgs` parameters from
`start_autopilot`, `start_api`, `start_protocol`, and related methods.

## How to test

1. `cargo nextest run -p configs` — verifies `SharedConfig`
deserialization (default and full round-trip).
2. `cargo nextest run -p autopilot -p orderbook` — unit tests for both
services.
3. E2E tests: `cargo nextest run -p e2e local_node --test-threads 1
--run-ignored ignored-only` — confirms the simplified test harness works
end-to-end.
4. Playground: `docker compose -f playground/docker-compose.fork.yml up
-d` — verifies updated TOML configs and removed CLI flags work in the
local dev environment.
---
 CLAUDE.md                                     |   1 +
 configs/local/orderbook.toml                  |  19 +
 crates/autopilot/src/arguments.rs             |   6 +-
 crates/autopilot/src/run.rs                   |  95 ++--
 crates/configs/src/autopilot/cow_amm.rs       |   1 -
 crates/configs/src/autopilot/ethflow.rs       |   2 +-
 crates/configs/src/autopilot/fee_policy.rs    |   6 +
 crates/configs/src/autopilot/mod.rs           |  16 +-
 crates/configs/src/autopilot/native_price.rs  |   2 +
 .../src/autopilot/order_events_cleanup.rs     |   1 +
 crates/configs/src/autopilot/s3.rs            |   1 +
 crates/configs/src/autopilot/solver.rs        |  10 +-
 .../configs/src/autopilot/trusted_tokens.rs   |   1 +
 crates/configs/src/banned_users.rs            |   1 +
 crates/configs/src/database.rs                |   1 +
 crates/configs/src/http_client.rs             |   2 +
 crates/configs/src/lib.rs                     |   1 +
 crates/configs/src/native_price_estimators.rs |   8 +
 crates/configs/src/order_quoting.rs           |   3 +-
 crates/configs/src/orderbook/mod.rs           |  33 +-
 crates/configs/src/orderbook/native_price.rs  |   2 +
 .../configs/src/orderbook/order_validation.rs |   5 +
 crates/configs/src/price_estimation.rs        |   6 -
 crates/configs/src/shared.rs                  | 431 ++++++++++++++++++
 crates/e2e/src/setup/services.rs              | 195 +++-----
 crates/e2e/tests/e2e/autopilot_leader.rs      |  68 ++-
 crates/e2e/tests/e2e/buffers.rs               |  18 +-
 crates/e2e/tests/e2e/cors.rs                  |  39 +-
 crates/e2e/tests/e2e/cow_amm.rs               |  54 +--
 crates/e2e/tests/e2e/debug_order.rs           |   2 -
 crates/e2e/tests/e2e/jit_orders.rs            |  18 +-
 crates/e2e/tests/e2e/limit_orders.rs          |  90 ++--
 crates/e2e/tests/e2e/liquidity.rs             |  18 +-
 .../e2e/liquidity_source_notification.rs      |  18 +-
 crates/e2e/tests/e2e/malformed_requests.rs    |  20 +-
 crates/e2e/tests/e2e/order_cancellation.rs    |  18 +-
 .../e2e/tests/e2e/place_order_with_quote.rs   |  55 ++-
 crates/e2e/tests/e2e/protocol_fee.rs          |  44 +-
 crates/e2e/tests/e2e/quote_verification.rs    |   2 -
 crates/e2e/tests/e2e/quoting.rs               | 193 ++++----
 crates/e2e/tests/e2e/replace_order.rs         |   1 -
 crates/e2e/tests/e2e/smart_contract_orders.rs |   1 -
 crates/e2e/tests/e2e/solver_competition.rs    |  54 +--
 crates/e2e/tests/e2e/submission.rs            |   2 -
 crates/gas-price-estimation/src/lib.rs        |  15 -
 crates/orderbook/src/arguments.rs             |  16 +-
 crates/orderbook/src/run.rs                   |  82 ++--
 crates/shared/src/arguments.rs                | 311 +------------
 crates/shared/src/current_block.rs            |   9 +
 crates/shared/src/web3.rs                     |  10 +
 playground/autopilot.toml                     |  37 ++
 playground/configs/autopilot.toml             |  21 +
 playground/docker-compose.fork.yml            |  19 -
 playground/docker-compose.non-interactive.yml |  19 -
 playground/orderbook.toml                     |  19 +
 55 files changed, 1133 insertions(+), 989 deletions(-)
 create mode 100644 configs/local/orderbook.toml
 create mode 100644 crates/configs/src/shared.rs
 create mode 100644 playground/autopilot.toml
 create mode 100644 playground/orderbook.toml

diff --git a/CLAUDE.md b/CLAUDE.md
index a03abd0c06..9ee0767c07 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -105,6 +105,7 @@ User signs order → Orderbook validates → Autopilot includes in auction
 - Spot format: `cargo +nightly fmt -- <path>` (never call stable `cargo fmt`)
 - Lint: `cargo clippy --locked --workspace --all-features --all-targets -- -D warnings`
 - Check format: `cargo +nightly fmt --all -- --check`
+- Only format **after** as a final step! — i.e. after checking compilation, running tests, etc.
 
 ### Local Development Environment
 - Start local PostgreSQL: `docker compose up -d`
diff --git a/configs/local/orderbook.toml b/configs/local/orderbook.toml
new file mode 100644
index 0000000000..f5b1a0e54a
--- /dev/null
+++ b/configs/local/orderbook.toml
@@ -0,0 +1,19 @@
+eip1271-skip-creation-validation = true
+bind-address = "0.0.0.0:80"
+
+[shared]
+node-url = "http://chain:8545"
+simulation-node-url = "http://chain:8545"
+
+[shared.tracing]
+collector-endpoint = "http://tempo:4317"
+
+[database]
+write-url = "%DB_WRITE_URL"
+read-url = "%DB_READ_URL"
+
+[native-price-estimation]
+estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
+
+[order-quoting]
+price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]
diff --git a/crates/autopilot/src/arguments.rs b/crates/autopilot/src/arguments.rs
index 2265bedda2..2030f872d5 100644
--- a/crates/autopilot/src/arguments.rs
+++ b/crates/autopilot/src/arguments.rs
@@ -4,16 +4,12 @@ use std::path::PathBuf;
 pub struct CliArguments {
     #[clap(long, env)]
     pub config: PathBuf,
-
-    #[clap(flatten)]
-    pub shared: shared::arguments::Arguments,
 }
 
 impl std::fmt::Display for CliArguments {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self { config, shared } = self;
+        let Self { config } = self;
         write!(f, "{}", config.display())?;
-        write!(f, "{shared}")?;
         Ok(())
     }
 }
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index a9865ac572..8b36741f1c 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -44,7 +44,6 @@ use {
         trade_verifier::code_fetching::CachedCodeFetcher,
     },
     shared::{
-        arguments::tracing_config,
         order_quoting::{self, OrderQuoter},
         token_list::{AutoUpdatingTokenList, TokenListConfiguration},
     },
@@ -134,11 +133,24 @@ pub async fn start(args: impl Iterator<Item = String>) {
         .validate()
         .expect("failed to validate configuration file");
 
+    let tracing_config = config
+        .shared
+        .tracing
+        .collector_endpoint
+        .as_ref()
+        .map(|endpoint| {
+            observe::TracingConfig::new(
+                endpoint.clone(),
+                "autopilot".into(),
+                config.shared.tracing.exporter_timeout,
+                config.shared.tracing.level,
+            )
+        });
     let obs_config = observe::Config::new(
-        args.shared.logging.log_filter.as_str(),
-        args.shared.logging.log_stderr_threshold,
-        args.shared.logging.use_json_logs,
-        tracing_config(&args.shared.tracing, "autopilot".into()),
+        config.shared.logging.filter.as_str(),
+        config.shared.logging.stderr_threshold,
+        config.shared.logging.use_json,
+        tracing_config,
     );
     observe::tracing::init::initialize(&obs_config);
     observe::panic_hook::install();
@@ -153,18 +165,14 @@ pub async fn start(args: impl Iterator<Item = String>) {
     observe::metrics::setup_registry(Some("gp_v2_autopilot".into()), None);
 
     if config.shadow.is_some() {
-        shadow_mode(args, config).await;
+        shadow_mode(config).await;
     } else {
-        run(args, config, ShutdownController::default()).await;
+        run(config, ShutdownController::default()).await;
     }
 }
 
 /// Assumes tracing and metrics registry have already been set up.
-pub async fn run(
-    args: CliArguments,
-    config: Configuration,
-    shutdown_controller: ShutdownController,
-) {
+pub async fn run(config: Configuration, shutdown_controller: ShutdownController) {
     assert!(config.shadow.is_none(), "cannot run in shadow mode");
     let db_write = Postgres::new(
         config.database.write_url.as_str(),
@@ -181,12 +189,13 @@ pub async fn run(
     crate::database::run_database_metrics_work(db_write.clone());
 
     let http_factory = HttpClientFactory::from(config.http_client);
-    let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
-    let simulation_web3 = args
+    let ethrpc_args = shared::web3::Arguments::from(&config.shared.ethrpc);
+    let web3 = shared::web3::web3(&ethrpc_args, &config.shared.node_url, "base");
+    let simulation_web3 = config
         .shared
         .simulation_node_url
         .as_ref()
-        .map(|node_url| shared::web3::web3(&args.shared.ethrpc, node_url, "simulation"));
+        .map(|node_url| shared::web3::web3(&ethrpc_args, node_url, "simulation"));
 
     let chain_id = web3
         .provider
@@ -194,32 +203,33 @@ pub async fn run(
         .instrument(info_span!("chain_id"))
         .await
         .expect("Could not get chainId");
-    if let Some(expected_chain_id) = args.shared.chain_id {
+    if let Some(expected_chain_id) = config.shared.chain_id {
         assert_eq!(
             chain_id, expected_chain_id,
             "connected to node with incorrect chain ID",
         );
     }
 
-    let unbuffered_ethrpc = unbuffered_ethrpc(&args.shared.node_url).await;
-    let ethrpc = ethrpc(&args.shared.node_url, &args.shared.ethrpc).await;
+    let unbuffered_ethrpc = unbuffered_ethrpc(&config.shared.node_url).await;
+    let ethrpc = ethrpc(&config.shared.node_url, &ethrpc_args).await;
     let chain = ethrpc.chain();
     let web3 = ethrpc.web3().clone();
     let url = ethrpc.url().clone();
     let contracts = infra::blockchain::contracts::Addresses {
-        settlement: args.shared.settlement_contract_address,
-        signatures: args.shared.signatures_contract_address,
-        weth: args.shared.native_token_address,
-        balances: args.shared.balances_contract_address,
-        trampoline: args.shared.hooks_contract_address,
+        settlement: config.shared.contracts.settlement,
+        signatures: config.shared.contracts.signatures,
+        weth: config.shared.contracts.native_token,
+        balances: config.shared.contracts.balances,
+        trampoline: config.shared.contracts.hooks,
     };
+    let current_block_args = shared::current_block::Arguments::from(&config.shared.current_block);
     let eth = ethereum(
         web3.clone(),
         unbuffered_ethrpc.web3().clone(),
         &chain,
         url,
         contracts.clone(),
-        &args.shared.current_block,
+        &current_block_args,
     )
     .await;
 
@@ -231,7 +241,7 @@ pub async fn run(
         .await
         .expect("Couldn't get vault relayer address");
 
-    let vault_address = args.shared.balancer_v2_vault_address.or_else(|| {
+    let vault_address = config.shared.contracts.balancer_v2_vault.or_else(|| {
         let chain_id = chain.id();
         let addr = BalancerV2Vault::deployment_address(&chain_id);
         if addr.is_none() {
@@ -259,11 +269,17 @@ pub async fn run(
         eth.current_block().clone(),
     );
 
+    let gas_estimators: Vec<gas_price_estimation::GasEstimatorType> = config
+        .shared
+        .gas_estimators
+        .iter()
+        .map(shared::arguments::gas_estimator_type_from_config)
+        .collect();
     let gas_price_estimator = Arc::new(
         gas_price_estimation::create_priority_estimator(
             http_factory.create(),
             &web3,
-            args.shared.gas_estimators.as_slice(),
+            &gas_estimators,
         )
         .await
         .expect("failed to create gas price estimator"),
@@ -415,9 +431,7 @@ pub async fn run(
         .cow_amm
         .archive_node_url
         .as_ref()
-        .map_or(web3.clone(), |url| {
-            boundary::web3_client(url, &args.shared.ethrpc)
-        });
+        .map_or(web3.clone(), |url| boundary::web3_client(url, &ethrpc_args));
 
     let mut cow_amm_registry = cow_amm::Registry::new(Arc::new(BlockRetriever {
         provider: archive_node_web3.provider,
@@ -473,8 +487,13 @@ pub async fn run(
         *eth.contracts().weth().address(),
         domain::ProtocolFees::new(
             &config.fee_policies,
-            args.shared.volume_fee_bucket_overrides.clone(),
-            args.shared.enable_sell_equals_buy_volume_fee,
+            config
+                .shared
+                .volume_fee_bucket_overrides
+                .iter()
+                .map(Into::into)
+                .collect(),
+            config.shared.enable_sell_equals_buy_volume_fee,
         ),
         cow_amm_registry.clone(),
         config.native_price_timeout,
@@ -633,7 +652,7 @@ pub async fn run(
     api_task.await.ok();
 }
 
-async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
+async fn shadow_mode(config: Configuration) -> ! {
     let http_factory = HttpClientFactory::from(config.http_client);
 
     let orderbook = infra::shadow::Orderbook::new(
@@ -669,7 +688,8 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
         .into_iter()
         .collect();
 
-    let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
+    let ethrpc_args = shared::web3::Arguments::from(&config.shared.ethrpc);
+    let web3 = shared::web3::web3(&ethrpc_args, &config.shared.node_url, "base");
     let weth = WETH9::Instance::deployed(&web3.provider)
         .await
         .expect("couldn't find deployed WETH contract");
@@ -680,7 +700,7 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
             .get_chain_id()
             .await
             .expect("Could not get chainId");
-        if let Some(expected_chain_id) = args.shared.chain_id {
+        if let Some(expected_chain_id) = config.shared.chain_id {
             assert_eq!(
                 chain_id, expected_chain_id,
                 "connected to node with incorrect chain ID",
@@ -705,10 +725,9 @@ async fn shadow_mode(args: CliArguments, config: Configuration) -> ! {
         Default::default(),
     );
 
-    let current_block = args
-        .shared
-        .current_block
-        .stream(args.shared.node_url, web3.provider.clone())
+    let current_block_args = shared::current_block::Arguments::from(&config.shared.current_block);
+    let current_block = current_block_args
+        .stream(config.shared.node_url, web3.provider.clone())
         .await
         .expect("couldn't initialize current block stream");
 
diff --git a/crates/configs/src/autopilot/cow_amm.rs b/crates/configs/src/autopilot/cow_amm.rs
index 89ec357bd1..009317e570 100644
--- a/crates/configs/src/autopilot/cow_amm.rs
+++ b/crates/configs/src/autopilot/cow_amm.rs
@@ -10,7 +10,6 @@ pub struct CowAmmGroupConfig {
     pub contracts: Vec<CowAmmConfig>,
 
     /// Archive node URL used to index CoW AMMs.
-    #[serde(default)]
     pub archive_node_url: Option<Url>,
 }
 
diff --git a/crates/configs/src/autopilot/ethflow.rs b/crates/configs/src/autopilot/ethflow.rs
index f8b8f50364..9ee9cc10af 100644
--- a/crates/configs/src/autopilot/ethflow.rs
+++ b/crates/configs/src/autopilot/ethflow.rs
@@ -1,5 +1,6 @@
 use {alloy::primitives::Address, serde::Deserialize};
 
+/// Configuration for eth-flow order indexing and processing.
 #[derive(Debug, Clone, Default, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
@@ -12,7 +13,6 @@ pub struct EthflowConfig {
 
     /// Timestamp at which we should start indexing eth-flow contract events.
     /// Ignored if events already exist in the database for a later date.
-    #[serde(default)]
     pub indexing_start: Option<u64>,
 
     /// Skip syncing past events (useful for local deployments).
diff --git a/crates/configs/src/autopilot/fee_policy.rs b/crates/configs/src/autopilot/fee_policy.rs
index 7797b4be1f..d0eb13cc33 100644
--- a/crates/configs/src/autopilot/fee_policy.rs
+++ b/crates/configs/src/autopilot/fee_policy.rs
@@ -8,6 +8,7 @@ pub const fn default_max_partner_fee() -> FeeFactor {
     FeeFactor::new(0.01)
 }
 
+/// Protocol fee configuration: which fee model to apply per order class.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct FeePoliciesConfig {
@@ -39,7 +40,9 @@ impl Default for FeePoliciesConfig {
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct FeePolicy {
+    /// The fee calculation method (surplus, price-improvement, or volume).
     pub kind: FeePolicyKind,
+    /// Which order class this policy applies to.
     pub order_class: FeePolicyOrderClass,
 }
 
@@ -47,6 +50,7 @@ pub struct FeePolicy {
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct UpcomingFeePolicies {
+    /// Policies that will replace the current ones at the effective timestamp.
     #[serde(default)]
     pub policies: Vec<FeePolicy>,
 
@@ -54,6 +58,7 @@ pub struct UpcomingFeePolicies {
     pub effective_from_timestamp: Option<DateTime<Utc>>,
 }
 
+/// Method used to calculate the protocol fee for an order.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum FeePolicyKind {
@@ -75,6 +80,7 @@ pub enum FeePolicyKind {
     Volume { factor: FeeFactor },
 }
 
+/// Which order class a fee policy targets.
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum FeePolicyOrderClass {
diff --git a/crates/configs/src/autopilot/mod.rs b/crates/configs/src/autopilot/mod.rs
index ba1a6c242d..4e4bf43c81 100644
--- a/crates/configs/src/autopilot/mod.rs
+++ b/crates/configs/src/autopilot/mod.rs
@@ -16,6 +16,7 @@ use {
         http_client::HttpClient,
         order_quoting::OrderQuoting,
         price_estimation::PriceEstimation,
+        shared::SharedConfig,
     },
     alloy::primitives::Address,
     anyhow::{anyhow, ensure},
@@ -57,12 +58,16 @@ const fn default_max_auction_age() -> Duration {
 // Does not implement Default because `native_price_estimation` *cannot* have
 // empty `estimators`, as such, we cannot provide a proper default value for
 // this structure.
+/// Top-level autopilot service configuration.
 #[derive(Debug, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
-// NOTE: cannot add deny_unknown_fields during the config migration
-// as new ones get added in the config will fail parsing if extra fields are present
-#[serde(rename_all = "kebab-case", /* deny_unknown_fields */)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct Configuration {
+    /// Shared settings (node URL, gas estimators, logging, etc.).
+    #[serde(flatten)]
+    pub shared: SharedConfig,
+
+    /// Solver drivers to dispatch auctions to.
     pub drivers: Vec<Solver>,
 
     /// Describes how the protocol fees should be calculated.
@@ -99,7 +104,6 @@ pub struct Configuration {
     /// Run the autopilot in shadow mode by specifying an upstream CoW protocol
     /// deployment to pull auctions from. The autopilot performs solver
     /// competition and logs the winner without executing settlements.
-    #[serde(default)]
     pub shadow: Option<Url>,
 
     /// Address to bind the metrics server.
@@ -153,7 +157,7 @@ pub struct Configuration {
     #[serde(default)]
     pub http_client: HttpClient,
 
-    // Configurations for the order creation process.
+    /// Configurations for the order creation process.
     pub order_quoting: OrderQuoting,
 
     /// Configurations for price estimation (tenderly, rate limiting, CoinGecko,
@@ -199,6 +203,7 @@ impl Configuration {
         use crate::test_util::TestDefault;
 
         Self {
+            shared: Default::default(),
             drivers: vec![],
             fee_policies: Default::default(),
             trusted_tokens: Default::default(),
@@ -229,6 +234,7 @@ impl Configuration {
         use crate::test_util::TestDefault;
 
         Self {
+            shared: Default::default(),
             drivers: vec![Solver::test(name, solver_address)],
             fee_policies: Default::default(),
             trusted_tokens: Default::default(),
diff --git a/crates/configs/src/autopilot/native_price.rs b/crates/configs/src/autopilot/native_price.rs
index b8be0dc1fb..74ac52635f 100644
--- a/crates/configs/src/autopilot/native_price.rs
+++ b/crates/configs/src/autopilot/native_price.rs
@@ -14,6 +14,7 @@ const fn default_native_price_prefetch_time() -> Duration {
 
 // Does not implement Default because `estimators` *cannot* be empty,
 // as such, we cannot provide a proper default value for this structure.
+/// Native price estimation configuration.
 #[derive(Debug, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
@@ -45,6 +46,7 @@ pub struct NativePriceConfig {
     )]
     pub prefetch_time: Duration,
 
+    /// Shared native price settings (cache, approximation tokens, etc.).
     #[serde(flatten)]
     pub shared: crate::native_price::NativePriceConfig,
 }
diff --git a/crates/configs/src/autopilot/order_events_cleanup.rs b/crates/configs/src/autopilot/order_events_cleanup.rs
index 5b21ccbf91..2c9d656617 100644
--- a/crates/configs/src/autopilot/order_events_cleanup.rs
+++ b/crates/configs/src/autopilot/order_events_cleanup.rs
@@ -11,6 +11,7 @@ fn default_cleanup_threshold() -> Duration {
     Duration::from_secs(2592000) // 30d
 }
 
+/// Periodic cleanup settings for the `order_events` database table.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct OrderEventsCleanupConfig {
diff --git a/crates/configs/src/autopilot/s3.rs b/crates/configs/src/autopilot/s3.rs
index f6b5329a95..c8a024f5b2 100644
--- a/crates/configs/src/autopilot/s3.rs
+++ b/crates/configs/src/autopilot/s3.rs
@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 
+/// Settings for uploading auction instances to S3.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct S3Config {
diff --git a/crates/configs/src/autopilot/solver.rs b/crates/configs/src/autopilot/solver.rs
index 2211a2b127..bec879e29c 100644
--- a/crates/configs/src/autopilot/solver.rs
+++ b/crates/configs/src/autopilot/solver.rs
@@ -10,8 +10,11 @@ use {
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct Solver {
+    /// Human-readable solver name (used in logs and metrics).
     pub name: String,
+    /// Base URL of the solver's driver API.
     pub url: Url,
+    /// Account used to submit settlement transactions on-chain.
     #[serde(flatten)]
     pub submission_account: Account,
 }
@@ -32,17 +35,18 @@ impl Display for Solver {
     }
 }
 
+/// How the solver's on-chain submission key is specified.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum Account {
-    /// AWS KMS is used to retrieve the solver public key
+    /// AWS KMS is used to retrieve the solver public key.
     #[serde(deserialize_with = "deserialize_arn")]
     Kms(Arn),
-    /// Solver public key
+    /// Solver public key specified directly.
     Address(Address),
 }
 
-// Wrapper type for AWS ARN identifiers
+/// Wrapper type for AWS KMS ARN identifiers.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
 pub struct Arn(pub String);
 
diff --git a/crates/configs/src/autopilot/trusted_tokens.rs b/crates/configs/src/autopilot/trusted_tokens.rs
index 75d7b7849b..8d7907f84e 100644
--- a/crates/configs/src/autopilot/trusted_tokens.rs
+++ b/crates/configs/src/autopilot/trusted_tokens.rs
@@ -9,6 +9,7 @@ fn default_update_interval() -> Duration {
     Duration::from_secs(3600) // 1h
 }
 
+/// Tokens that the settlement contract is allowed to internalize.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct TrustedTokensConfig {
diff --git a/crates/configs/src/banned_users.rs b/crates/configs/src/banned_users.rs
index 8763f290c0..5942acc121 100644
--- a/crates/configs/src/banned_users.rs
+++ b/crates/configs/src/banned_users.rs
@@ -10,6 +10,7 @@ fn default_max_cache_size() -> NonZeroUsize {
     NonZeroUsize::new(10000).unwrap()
 }
 
+/// Addresses banned from creating orders, with a local cache.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct BannedUsersConfig {
diff --git a/crates/configs/src/database.rs b/crates/configs/src/database.rs
index c5f5882cf4..e1b0b55cf2 100644
--- a/crates/configs/src/database.rs
+++ b/crates/configs/src/database.rs
@@ -20,6 +20,7 @@ const fn default_insert_batch_size() -> NonZeroUsize {
     NonZeroUsize::new(500).expect("value should be greater than 0")
 }
 
+/// PostgreSQL connection pool settings.
 #[derive(serde::Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
diff --git a/crates/configs/src/http_client.rs b/crates/configs/src/http_client.rs
index be9b87fe53..d212b21120 100644
--- a/crates/configs/src/http_client.rs
+++ b/crates/configs/src/http_client.rs
@@ -4,10 +4,12 @@ const fn default_timeout() -> Duration {
     Duration::from_secs(10)
 }
 
+/// Global HTTP client settings shared across all outgoing requests.
 #[derive(Debug, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
 pub struct HttpClient {
+    /// Request timeout for outgoing HTTP calls.
     #[serde(with = "humantime_serde", default = "default_timeout")]
     pub timeout: Duration,
 }
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index 33d41702ce..21b6c07d1e 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -11,6 +11,7 @@ pub mod order_quoting;
 pub mod orderbook;
 pub mod price_estimation;
 pub mod rate_limit;
+pub mod shared;
 
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
diff --git a/crates/configs/src/native_price_estimators.rs b/crates/configs/src/native_price_estimators.rs
index cb2948883a..52577ef818 100644
--- a/crates/configs/src/native_price_estimators.rs
+++ b/crates/configs/src/native_price_estimators.rs
@@ -4,6 +4,8 @@ use {
     url::Url,
 };
 
+/// Ordered stages of native-price estimators. Each stage is tried in order;
+/// within a stage estimators run concurrently.
 #[derive(Clone, Debug, Default)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 pub struct NativePriceEstimators(Vec<Vec<NativePriceEstimator>>);
@@ -72,6 +74,7 @@ impl Display for NativePriceEstimators {
     }
 }
 
+/// Reference to an external solver by name and URL.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(deny_unknown_fields)]
@@ -80,13 +83,18 @@ pub struct ExternalSolver {
     pub url: Url,
 }
 
+/// A single native-price estimation backend.
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(tag = "type")]
 pub enum NativePriceEstimator {
+    /// Query an external solver driver for native prices.
     Driver(ExternalSolver),
+    /// Forward requests to another service (e.g. autopilot).
     Forwarder { url: Url },
+    /// Use the 1inch spot-price API.
     OneInchSpotPriceApi,
+    /// Use the CoinGecko API.
     CoinGecko,
 }
 
diff --git a/crates/configs/src/order_quoting.rs b/crates/configs/src/order_quoting.rs
index 8175c9ef31..8fafb7d1fc 100644
--- a/crates/configs/src/order_quoting.rs
+++ b/crates/configs/src/order_quoting.rs
@@ -10,6 +10,7 @@ const fn default_standard_offchain_quote_validity() -> Duration {
     Duration::from_mins(1)
 }
 
+/// Reference to an external solver used for price estimation during quoting.
 #[derive(Debug, Clone, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
@@ -18,7 +19,7 @@ pub struct ExternalSolver {
     pub url: Url,
 }
 
-// The following arguments are used to configure the order creation process.
+/// Configuration for the order quoting / creation process.
 #[derive(Debug, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index fd74da2c6f..f695886573 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -11,18 +11,26 @@ use {
             order_validation::OrderValidationConfig,
         },
         price_estimation::PriceEstimation,
+        shared::SharedConfig,
     },
     alloy::primitives::Address,
     anyhow::anyhow,
     chrono::{DateTime, Utc},
     serde::{Deserialize, Serialize},
-    std::path::Path,
+    std::{
+        net::{Ipv4Addr, SocketAddr, SocketAddrV4},
+        path::Path,
+    },
 };
 
 pub mod ipfs;
 pub mod native_price;
 pub mod order_validation;
 
+const fn default_bind_address() -> SocketAddr {
+    SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 8080))
+}
+
 const fn default_app_data_size_limit() -> usize {
     8192
 }
@@ -31,18 +39,30 @@ const fn default_active_order_competition_threshold() -> u32 {
     5
 }
 
+/// Volume-based protocol fee applied to orders.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct VolumeFeeConfig {
+    /// Fee as a fraction of the order volume (e.g. 0.0002 = 0.02%).
     pub factor: Option<FeeFactor>,
+    /// Timestamp from which this fee configuration becomes effective.
     pub effective_from_timestamp: Option<DateTime<Utc>>,
 }
 
+/// Top-level orderbook service configuration.
 // NOTE: cannot add deny_unknown_fields during the config migration
 #[derive(Debug, Deserialize)]
-#[serde(rename_all = "kebab-case" /* deny_unknown_fields */)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct Configuration {
+    /// Shared settings (node URL, gas estimators, logging, etc.).
+    #[serde(default)]
+    pub shared: SharedConfig,
+
+    /// Bind address for the Orderbook.
+    #[serde(default = "default_bind_address")]
+    pub bind_address: SocketAddr,
+
     /// Configuration for the order validation system.
     #[serde(default)]
     pub order_validation: OrderValidationConfig,
@@ -58,6 +78,7 @@ pub struct Configuration {
     /// Configuration for the volume fee.
     pub volume_fee: Option<VolumeFeeConfig>,
 
+    /// Maximum allowed size (in bytes) for order app-data.
     #[serde(default = "default_app_data_size_limit")]
     pub app_data_size_limit: usize,
 
@@ -76,6 +97,7 @@ pub struct Configuration {
     /// Configuration for the native price estimation mechanism.
     pub native_price_estimation: NativePriceConfig,
 
+    /// Database connection pool settings.
     #[serde(default)]
     pub database: DatabasePoolConfig,
 
@@ -83,7 +105,7 @@ pub struct Configuration {
     #[serde(default)]
     pub http_client: HttpClient,
 
-    // Configurations for the order creation process.
+    /// Configurations for the order creation process.
     pub order_quoting: OrderQuoting,
 
     /// Configurations for price estimation (tenderly, rate limiting, CoinGecko,
@@ -117,6 +139,7 @@ pub mod test_util {
                 Configuration,
                 default_active_order_competition_threshold,
                 default_app_data_size_limit,
+                default_bind_address,
                 native_price::NativePriceConfig,
             },
             test_util::TestDefault,
@@ -154,6 +177,8 @@ pub mod test_util {
             use crate::test_util::TestDefault;
 
             Self {
+                shared: Default::default(),
+                bind_address: default_bind_address(),
                 order_validation: Default::default(),
                 banned_users: Default::default(),
                 ipfs: Default::default(),
@@ -293,6 +318,8 @@ mod tests {
     #[test]
     fn roundtrip_serialization() {
         let config = Configuration {
+            shared: Default::default(),
+            bind_address: default_bind_address(),
             order_validation: OrderValidationConfig {
                 min_order_validity_period: Duration::from_secs(120),
                 max_order_validity_period: Duration::from_secs(7200),
diff --git a/crates/configs/src/orderbook/native_price.rs b/crates/configs/src/orderbook/native_price.rs
index c51fafedb4..a12959e82d 100644
--- a/crates/configs/src/orderbook/native_price.rs
+++ b/crates/configs/src/orderbook/native_price.rs
@@ -6,6 +6,7 @@ use {
     serde::Deserialize,
 };
 
+/// Orderbook-specific native price estimation configuration.
 #[derive(Debug, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
@@ -18,6 +19,7 @@ pub struct NativePriceConfig {
     /// are down.
     pub fallback_estimators: Option<NativePriceEstimators>,
 
+    /// Shared native price settings (cache, approximation tokens, etc.).
     #[serde(flatten)]
     pub shared: SharedNativePriceConfig,
 }
diff --git a/crates/configs/src/orderbook/order_validation.rs b/crates/configs/src/orderbook/order_validation.rs
index 58adebb3f4..c20348d177 100644
--- a/crates/configs/src/orderbook/order_validation.rs
+++ b/crates/configs/src/orderbook/order_validation.rs
@@ -3,11 +3,15 @@ use {
     std::time::Duration,
 };
 
+/// Policy controlling whether orders with identical buy and sell tokens are
+/// accepted.
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum SameTokensPolicy {
+    /// Reject orders where buy token equals sell token.
     #[default]
     Disallow,
+    /// Allow sell orders where buy token equals sell token.
     AllowSell,
     // Allow, TODO: Allow sell and buy orders with the same tokens
     // (https://github.com/cowprotocol/services/issues/3963)
@@ -33,6 +37,7 @@ const fn default_max_gas_per_order() -> u64 {
     8_000_000
 }
 
+/// Rules governing order validity periods, gas limits, and token policies.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct OrderValidationConfig {
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index e4346efef3..e220ca3f8c 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -42,13 +42,11 @@ pub struct PriceEstimation {
     /// Configures the back off strategy for price estimators when requests take
     /// too long. Requests issued while back off is active get dropped
     /// entirely.
-    #[serde(default)]
     pub price_estimation_rate_limiter: Option<Strategy>,
 
     /// The amount in native token atoms to use for price estimation. Should be
     /// reasonably large so that small pools do not influence the prices. If
     /// not set, a reasonable default is used based on network id.
-    #[serde(default)]
     pub amount_to_estimate_prices_with: Option<U256>,
 
     /// How inaccurate a quote must be before it gets discarded, provided as a
@@ -93,15 +91,12 @@ pub struct PriceEstimation {
     pub min_gas_amount_for_unverified_quotes: u64,
 
     /// Tenderly configuration (URL, project & API key).
-    #[serde(default)]
     pub tenderly: Option<TenderlyConfig>,
 
     /// The CoinGecko native price configuration.
-    #[serde(default)]
     pub coin_gecko: Option<CoinGeckoConfig>,
 
     /// 1-inch API connection settings (URL & key).
-    #[serde(default)]
     pub one_inch: Option<OneInchApi>,
 }
 
@@ -197,7 +192,6 @@ pub struct CoinGeckoConfig {
     #[serde(default = "default_coin_gecko_url")]
     pub url: Url,
 
-    #[serde(default)]
     pub buffered: Option<CoinGeckoBufferedConfig>,
 }
 
diff --git a/crates/configs/src/shared.rs b/crates/configs/src/shared.rs
new file mode 100644
index 0000000000..3725a55b66
--- /dev/null
+++ b/crates/configs/src/shared.rs
@@ -0,0 +1,431 @@
+use {
+    crate::fee_factor::FeeFactor,
+    alloy::primitives::Address,
+    serde::{Deserialize, Deserializer, de::Unexpected},
+    std::{collections::HashSet, str::FromStr, time::Duration},
+    tracing::Level,
+    url::Url,
+};
+
+#[cfg(any(test, feature = "test-util"))]
+use crate::test_util::TestDefault;
+
+fn default_node_url() -> Url {
+    "http://localhost:8545".parse().unwrap()
+}
+
+fn default_gas_estimators() -> Vec<GasEstimatorType> {
+    vec![GasEstimatorType::Web3]
+}
+
+const fn default_ethrpc_max_batch_size() -> usize {
+    100
+}
+
+const fn default_ethrpc_max_concurrent_requests() -> usize {
+    10
+}
+
+fn default_log_filter() -> String {
+    String::from(
+        "info,autopilot=debug,driver=debug,observe=info,orderbook=debug,solver=debug,shared=debug,\
+         cow_amm=debug",
+    )
+}
+
+const fn default_tracing_level() -> tracing::Level {
+    tracing::Level::INFO
+}
+
+const fn default_tracing_exporter_timeout() -> Duration {
+    Duration::from_secs(10)
+}
+
+/// Configuration shared across all services (orderbook, autopilot, driver,
+/// etc.). Covers node connectivity, gas estimation, logging, tracing, and
+/// protocol-level fee overrides.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct SharedConfig {
+    /// Tuning parameters for the batching Ethereum RPC layer.
+    #[serde(default)]
+    pub ethrpc: EthRpcConfig,
+
+    /// Configuration for the current-block stream that tracks chain head.
+    #[serde(default)]
+    pub current_block: CurrentBlockConfig,
+
+    /// Log filter, output format, and stderr threshold.
+    #[serde(default)]
+    pub logging: LoggingConfig,
+
+    /// OpenTelemetry tracing export settings.
+    #[serde(default)]
+    pub tracing: TracingConfig,
+
+    /// The Ethereum node URL to connect to.
+    #[serde(default = "default_node_url")]
+    pub node_url: Url,
+
+    /// An Ethereum node URL that supports `eth_call`s with state overrides
+    /// to be used for simulations.
+    pub simulation_node_url: Option<Url>,
+
+    /// The expected chain ID that the services are expected to run against.
+    /// This can be optionally specified in order to check at startup whether
+    /// the connected nodes match to detect misconfigurations.
+    pub chain_id: Option<u64>,
+
+    /// Which gas estimators to use. Multiple estimators are used in sequence
+    /// if a previous one fails. Individual estimators support different
+    /// networks. `Web3` supports every network.
+    #[serde(default = "default_gas_estimators")]
+    pub gas_estimators: Vec<GasEstimatorType>,
+
+    #[serde(default)]
+    pub contracts: ContractAddresses,
+
+    /// Custom volume fee factors for token buckets. Orders where both tokens
+    /// are in the bucket will use the custom fee. Useful for
+    /// stablecoin-to-stablecoin trades or specific token pairs.
+    #[serde(default)]
+    pub volume_fee_bucket_overrides: Vec<TokenBucketFeeOverride>,
+
+    /// Enable volume fees for trades where sell token equals buy token.
+    /// By default, volume fees are NOT applied to same-token trades.
+    #[serde(default)]
+    pub enable_sell_equals_buy_volume_fee: bool,
+}
+
+impl Default for SharedConfig {
+    fn default() -> Self {
+        Self {
+            ethrpc: Default::default(),
+            current_block: Default::default(),
+            logging: Default::default(),
+            tracing: Default::default(),
+            node_url: default_node_url(),
+            simulation_node_url: None,
+            chain_id: None,
+            gas_estimators: default_gas_estimators(),
+            contracts: Default::default(),
+            volume_fee_bucket_overrides: Vec::new(),
+            enable_sell_equals_buy_volume_fee: false,
+        }
+    }
+}
+
+/// Tuning parameters for the batching Ethereum RPC layer.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct EthRpcConfig {
+    /// Maximum number of RPC calls in a single batch request.
+    #[serde(default = "default_ethrpc_max_batch_size")]
+    pub max_batch_size: usize,
+
+    /// Maximum number of concurrent batch requests to the node.
+    #[serde(default = "default_ethrpc_max_concurrent_requests")]
+    pub max_concurrent_requests: usize,
+
+    /// Artificial delay before sending a batch, allowing more calls to be
+    /// grouped together.
+    #[serde(with = "humantime_serde", default)]
+    pub batch_delay: Duration,
+}
+
+impl Default for EthRpcConfig {
+    fn default() -> Self {
+        Self {
+            max_batch_size: default_ethrpc_max_batch_size(),
+            max_concurrent_requests: default_ethrpc_max_concurrent_requests(),
+            batch_delay: Duration::ZERO,
+        }
+    }
+}
+
+/// Configuration for the current-block stream that tracks chain head.
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct CurrentBlockConfig {
+    /// How often to poll the node for the latest block.
+    #[serde(with = "humantime_serde", default)]
+    pub poll_interval: Option<Duration>,
+
+    /// Optional WebSocket URL for block-header subscriptions (faster than
+    /// polling).
+    pub ws_url: Option<Url>,
+}
+
+/// Optional address overrides for protocol contracts. When `None`, the
+/// canonical deployment addresses for the detected chain are used.
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct ContractAddresses {
+    /// The `GPv2Settlement` contract.
+    pub settlement: Option<Address>,
+
+    /// The `BalancerV2VaultRelayer`-style allowance manager contract.
+    pub balances: Option<Address>,
+
+    /// The `SignatureValidator` contract used for EIP-1271 verification.
+    pub signatures: Option<Address>,
+
+    /// The wrapped native token (e.g. WETH) for the target chain.
+    pub native_token: Option<Address>,
+
+    /// The `CowHooks` trampoline contract.
+    pub hooks: Option<Address>,
+
+    /// The Balancer V2 Vault contract used for liquidity sourcing.
+    pub balancer_v2_vault: Option<Address>,
+}
+
+/// Logging configuration (log filter, output format).
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct LoggingConfig {
+    /// `tracing` filter directive (e.g. `"info,shared=debug"`).
+    #[serde(default = "default_log_filter")]
+    pub filter: String,
+
+    #[serde(default, deserialize_with = "deserialize_optional_level")]
+    #[cfg_attr(
+        any(test, feature = "test-util"),
+        serde(
+            skip_serializing_if = "Option::is_none",
+            serialize_with = "serialize_optional_level"
+        )
+    )]
+    pub stderr_threshold: Option<tracing::Level>,
+
+    /// Emit structured JSON logs instead of human-readable text.
+    #[serde(default)]
+    pub use_json: bool,
+}
+
+fn deserialize_optional_level<'de, D>(deserializer: D) -> Result<Option<tracing::Level>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let Some(raw_level) = Option::<String>::deserialize(deserializer)? else {
+        return Ok(None);
+    };
+    Ok(Some(tracing::Level::from_str(&raw_level).map_err(
+        |_| {
+            serde::de::Error::invalid_value(
+                Unexpected::Str(&raw_level),
+                // Since exp must be 'static, this string is copied from ParseLevelError::Display
+                &"error parsing level: expected one of \"error\", \"warn\", \"info\", \"debug\", \
+                  \"trace\", or a number 1-5",
+            )
+        },
+    )?))
+}
+
+#[cfg(any(test, feature = "test-util"))]
+fn serialize_optional_level<S>(
+    level: &Option<tracing::Level>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    match level {
+        Some(level) => serializer.serialize_str(level.as_str()),
+        None => serializer.serialize_none(),
+    }
+}
+
+impl Default for LoggingConfig {
+    fn default() -> Self {
+        Self {
+            filter: default_log_filter(),
+            stderr_threshold: None,
+            use_json: false,
+        }
+    }
+}
+
+/// OpenTelemetry tracing configuration.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct TracingConfig {
+    /// OTLP collector endpoint (e.g. `"http://jaeger:4317"`).
+    pub collector_endpoint: Option<String>,
+
+    /// Minimum span level to export.
+    #[serde(
+        deserialize_with = "deserialize_level",
+        default = "default_tracing_level"
+    )]
+    #[cfg_attr(
+        any(test, feature = "test-util"),
+        serde(serialize_with = "serialize_level")
+    )]
+    pub level: Level,
+
+    /// Timeout for the OTLP exporter when flushing spans.
+    #[serde(with = "humantime_serde", default = "default_tracing_exporter_timeout")]
+    pub exporter_timeout: Duration,
+}
+
+impl Default for TracingConfig {
+    fn default() -> Self {
+        Self {
+            collector_endpoint: None,
+            level: default_tracing_level(),
+            exporter_timeout: default_tracing_exporter_timeout(),
+        }
+    }
+}
+
+fn deserialize_level<'de, D>(deserializer: D) -> Result<tracing::Level, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let raw_level = String::deserialize(deserializer)?;
+    tracing::Level::from_str(&raw_level).map_err(|_| {
+        serde::de::Error::invalid_value(
+            Unexpected::Str(&raw_level),
+            // Since exp must be 'static, this string is copied from ParseLevelError::Display
+            &"error parsing level: expected one of \"error\", \"warn\", \"info\", \"debug\", \
+              \"trace\", or a number 1-5",
+        )
+    })
+}
+
+#[cfg(any(test, feature = "test-util"))]
+fn serialize_level<S>(level: &tracing::Level, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(level.as_str())
+}
+
+/// Gas price estimation strategy.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub enum GasEstimatorType {
+    /// Use the node's `eth_gasPrice` / EIP-1559 fee history RPCs.
+    Web3,
+    /// Fetch gas price from an external driver endpoint.
+    Driver { url: Url },
+    /// Use Alloy's built-in gas estimation.
+    Alloy,
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl TestDefault for GasEstimatorType {
+    fn test_default() -> Self {
+        Self::Driver {
+            url: "http://localhost:11088/gasprice"
+                .parse()
+                .expect("URL should be valid"),
+        }
+    }
+}
+
+/// Overrides the volume fee factor for orders where both tokens belong to
+/// the specified set (e.g. stablecoin-to-stablecoin trades).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
+pub struct TokenBucketFeeOverride {
+    pub tokens: HashSet<Address>,
+    pub factor: FeeFactor,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_shared_config_defaults() {
+        let toml = "";
+        let config: SharedConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.node_url.as_str(), "http://localhost:8545/");
+        assert!(config.chain_id.is_none());
+        assert_eq!(config.gas_estimators.len(), 1);
+        assert!(matches!(config.gas_estimators[0], GasEstimatorType::Web3));
+        assert!(config.volume_fee_bucket_overrides.is_empty());
+        assert!(!config.enable_sell_equals_buy_volume_fee);
+    }
+
+    #[test]
+    fn deserialize_shared_config_full() {
+        let toml = r#"
+        node-url = "http://mainnet.example.com:8545"
+        chain-id = 1
+        enable-sell-equals-buy-volume-fee = true
+
+        [contracts]
+        settlement = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+
+        [ethrpc]
+        max-batch-size = 200
+        max-concurrent-requests = 20
+        batch-delay = "1s"
+
+        [current-block]
+        poll-interval = "2s"
+        ws-url = "ws://localhost:8546"
+
+        [logging]
+        filter = "debug"
+        stderr-threshold = "warn"
+        use-json = true
+
+        [tracing]
+        collector-endpoint = "http://jaeger:4317"
+        level = "debug"
+        exporter-timeout = "5s"
+
+        [[gas-estimators]]
+        type = "Web3"
+
+        [[gas-estimators]]
+        type = "Driver"
+        url = "http://localhost:8080"
+
+        [[volume-fee-bucket-overrides]]
+        factor = 0.5
+        tokens = [
+            "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+            "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        ]
+        "#;
+
+        let config: SharedConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.node_url.as_str(), "http://mainnet.example.com:8545/");
+        assert_eq!(config.chain_id, Some(1));
+        assert_eq!(config.ethrpc.max_batch_size, 200);
+        assert_eq!(config.ethrpc.max_concurrent_requests, 20);
+        assert_eq!(config.ethrpc.batch_delay, Duration::from_secs(1));
+        assert_eq!(
+            config.current_block.poll_interval,
+            Some(Duration::from_secs(2))
+        );
+        assert!(config.current_block.ws_url.is_some());
+        assert_eq!(config.logging.filter, "debug");
+        assert_eq!(config.logging.stderr_threshold, Some(tracing::Level::WARN));
+        assert!(config.logging.use_json);
+        assert_eq!(
+            config.tracing.collector_endpoint.as_deref(),
+            Some("http://jaeger:4317")
+        );
+        assert_eq!(config.tracing.level, tracing::Level::DEBUG);
+        assert_eq!(config.tracing.exporter_timeout, Duration::from_secs(5));
+        assert_eq!(config.gas_estimators.len(), 2);
+        assert!(config.contracts.settlement.is_some());
+        assert!(config.enable_sell_equals_buy_volume_fee);
+        assert_eq!(config.volume_fee_bucket_overrides.len(), 1);
+        assert_eq!(config.volume_fee_bucket_overrides[0].tokens.len(), 2);
+    }
+}
diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 1e55e508a4..7edc2ecf95 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -16,7 +16,6 @@ use {
     },
     app_data::{AppDataDocument, AppDataHash},
     autopilot::infra::persistence::dto,
-    clap::Parser,
     configs::{
         autopilot::{
             Configuration,
@@ -26,6 +25,7 @@ use {
         },
         native_price_estimators::{NativePriceEstimator, NativePriceEstimators},
         order_quoting::{ExternalSolver, OrderQuoting},
+        shared::{GasEstimatorType, SharedConfig},
         test_util::TestDefault,
     },
     ethrpc::Web3,
@@ -39,12 +39,7 @@ use {
     },
     reqwest::{Client, StatusCode, Url},
     sqlx::Connection,
-    std::{
-        collections::{HashMap, hash_map::Entry},
-        ops::DerefMut,
-        str::FromStr,
-        time::Duration,
-    },
+    std::{ops::DerefMut, str::FromStr, time::Duration},
     tokio::task::JoinHandle,
 };
 
@@ -134,45 +129,23 @@ impl<'a> Services<'a> {
         ServicesBuilder::new()
     }
 
-    fn api_autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
-        [
-            "--block-stream-poll-interval=1s".to_string(),
-            format!("--node-ws-url={NODE_WS_HOST}"),
-            "--simulation-node-url=http://localhost:8545".to_string(),
-            format!(
-                "--hooks-contract-address={:?}",
-                self.contracts.hooks.address()
-            ),
-        ]
-        .into_iter()
-    }
-
-    fn autopilot_arguments(&self) -> impl Iterator<Item = String> + use<> {
-        self.api_autopilot_arguments()
-    }
-
-    fn api_autopilot_solver_arguments(&self) -> impl Iterator<Item = String> + use<> {
-        [
-            "--network-block-interval=1s".to_string(),
-            format!(
-                "--settlement-contract-address={:?}",
-                self.contracts.gp_settlement.address()
-            ),
-            format!(
-                "--balances-contract-address={:?}",
-                self.contracts.balances.address()
-            ),
-            format!(
-                "--signatures-contract-address={:?}",
-                self.contracts.signatures.address()
-            ),
-            format!("--native-token-address={:?}", self.contracts.weth.address()),
-            format!(
-                "--balancer-v2-vault-address={:?}",
-                self.contracts.balancer_vault.address()
-            ),
-        ]
-        .into_iter()
+    fn shared_config(&self) -> configs::shared::SharedConfig {
+        configs::shared::SharedConfig {
+            current_block: configs::shared::CurrentBlockConfig {
+                poll_interval: Some(Duration::from_secs(1)),
+                ws_url: Some(NODE_WS_HOST.parse().unwrap()),
+            },
+            simulation_node_url: Some("http://localhost:8545".parse().unwrap()),
+            contracts: configs::shared::ContractAddresses {
+                settlement: Some(*self.contracts.gp_settlement.address()),
+                balances: Some(*self.contracts.balances.address()),
+                signatures: Some(*self.contracts.signatures.address()),
+                native_token: Some(*self.contracts.weth.address()),
+                hooks: Some(*self.contracts.hooks.address()),
+                balancer_v2_vault: Some(*self.contracts.balancer_vault.address()),
+            },
+            ..Default::default()
+        }
     }
 
     /// Start the autopilot service in a background task.
@@ -184,7 +157,6 @@ impl<'a> Services<'a> {
     pub async fn start_autopilot_with_shutdown_controller(
         &self,
         solve_deadline: Option<Duration>,
-        extra_args: Vec<String>,
         config: configs::autopilot::Configuration,
         control: autopilot::shutdown_controller::ShutdownController,
     ) -> JoinHandle<()> {
@@ -197,6 +169,11 @@ impl<'a> Services<'a> {
             .collect::<Vec<_>>();
 
         let config = configs::autopilot::Configuration {
+            shared: configs::shared::SharedConfig {
+                volume_fee_bucket_overrides: config.shared.volume_fee_bucket_overrides.clone(),
+                enable_sell_equals_buy_volume_fee: config.shared.enable_sell_equals_buy_volume_fee,
+                ..self.shared_config()
+            },
             ethflow: EthflowConfig {
                 contracts: ethflow_contracts,
                 ..config.ethflow
@@ -208,20 +185,7 @@ impl<'a> Services<'a> {
             ..config
         };
 
-        let (_autopilot_config_file, autopilot_config_arg) = config.to_cli_args();
-
-        let args = ["autopilot".to_string(), autopilot_config_arg]
-            .into_iter()
-            .chain(self.api_autopilot_solver_arguments())
-            .chain(self.autopilot_arguments())
-            .chain(extra_args)
-            .collect();
-        let args = ignore_overwritten_cli_params(args);
-
-        let args = autopilot::arguments::CliArguments::try_parse_from(args)
-            .map_err(|err| err.to_string())
-            .unwrap();
-        let join_handle = tokio::task::spawn(autopilot::run(args, config, control));
+        let join_handle = tokio::task::spawn(autopilot::run(config, control));
         self.wait_until_autopilot_ready().await;
 
         join_handle
@@ -235,12 +199,10 @@ impl<'a> Services<'a> {
     pub async fn start_autopilot(
         &self,
         solve_deadline: Option<Duration>,
-        extra_args: Vec<String>,
         config: configs::autopilot::Configuration,
     ) -> JoinHandle<()> {
         self.start_autopilot_with_shutdown_controller(
             solve_deadline,
-            extra_args,
             config,
             autopilot::shutdown_controller::ShutdownController::default(),
         )
@@ -249,22 +211,17 @@ impl<'a> Services<'a> {
 
     /// Start the api service in a background tasks.
     /// Wait until the service is responsive.
-    pub async fn start_api(
-        &self,
-        extra_args: Vec<String>,
-        config: configs::orderbook::Configuration,
-    ) {
-        let (_config_file, config_arg) = config.to_cli_args();
-        let args: Vec<_> = ["orderbook".to_string(), config_arg]
-            .into_iter()
-            .chain(self.api_autopilot_solver_arguments())
-            .chain(self.api_autopilot_arguments())
-            .chain(extra_args)
-            .collect();
-        let args = ignore_overwritten_cli_params(args);
-
-        let args = orderbook::arguments::Arguments::try_parse_from(args).unwrap();
-        tokio::task::spawn(orderbook::run(args, config));
+    pub async fn start_api(&self, config: configs::orderbook::Configuration) {
+        let config = configs::orderbook::Configuration {
+            shared: configs::shared::SharedConfig {
+                volume_fee_bucket_overrides: config.shared.volume_fee_bucket_overrides.clone(),
+                enable_sell_equals_buy_volume_fee: config.shared.enable_sell_equals_buy_volume_fee,
+                ..self.shared_config()
+            },
+            ..config
+        };
+
+        tokio::task::spawn(orderbook::run(config));
 
         Self::wait_for_api_to_come_up().await;
     }
@@ -272,7 +229,6 @@ impl<'a> Services<'a> {
     /// Starts a basic version of the protocol with a single baseline solver.
     pub async fn start_protocol(&self, solver: TestAccount) {
         self.start_protocol_with_args(
-            Default::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration::test_default(),
             solver,
@@ -282,24 +238,16 @@ impl<'a> Services<'a> {
 
     pub async fn start_protocol_with_args(
         &self,
-        args: ExtraServiceArgs,
         autopilot_config: configs::autopilot::Configuration,
         orderbook_config: configs::orderbook::Configuration,
         solver: TestAccount,
     ) {
-        self.start_protocol_with_args_and_haircut(
-            args,
-            autopilot_config,
-            orderbook_config,
-            solver,
-            0,
-        )
-        .await;
+        self.start_protocol_with_args_and_haircut(autopilot_config, orderbook_config, solver, 0)
+            .await;
     }
 
     pub async fn start_protocol_with_args_and_haircut(
         &self,
-        args: ExtraServiceArgs,
         autopilot_config: configs::autopilot::Configuration,
         orderbook_config: configs::orderbook::Configuration,
         solver: TestAccount,
@@ -327,33 +275,27 @@ impl<'a> Services<'a> {
 
         let autopilot_config = Configuration {
             order_quoting: OrderQuoting::test_with_drivers(vec![test_quoter.clone()]),
+            shared: SharedConfig {
+                gas_estimators: vec![GasEstimatorType::Driver {
+                    url: Url::from_str("http://localhost:11088/gasprice").unwrap(),
+                }],
+                ..autopilot_config.shared
+            },
             ..autopilot_config
         };
         let orderbook_config = configs::orderbook::Configuration {
             order_quoting: OrderQuoting::test_with_drivers(vec![test_quoter]),
+            shared: SharedConfig {
+                gas_estimators: vec![GasEstimatorType::Driver {
+                    url: Url::from_str("http://localhost:11088/gasprice").unwrap(),
+                }],
+                ..orderbook_config.shared
+            },
             ..orderbook_config
         };
 
-        self.start_autopilot(
-            None,
-            [
-                vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-                args.autopilot,
-            ]
-            .concat(),
-            autopilot_config,
-        )
-        .await;
-
-        self.start_api(
-            [
-                vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-                args.api,
-            ]
-            .concat(),
-            orderbook_config,
-        )
-        .await;
+        self.start_autopilot(None, autopilot_config).await;
+        self.start_api(orderbook_config).await;
     }
 
     /// Starts a basic version of the protocol with a single external solver.
@@ -462,9 +404,9 @@ impl<'a> Services<'a> {
             false,
         );
 
-        self.start_autopilot(Some(Duration::from_secs(11)), vec![], autopilot_config)
+        self.start_autopilot(Some(Duration::from_secs(11)), autopilot_config)
             .await;
-        self.start_api(vec![], orderbook_config).await;
+        self.start_api(orderbook_config).await;
     }
 
     async fn wait_for_api_to_come_up() {
@@ -1074,32 +1016,3 @@ pub async fn ensure_e2e_readonly_user() {
 }
 
 pub type Db = sqlx::Pool<sqlx::Postgres>;
-
-/// Clap does not allow you to overwrite CLI arguments easily. This
-/// function loops over all provided arguments and only keeps the
-/// last one if there are multiples.
-fn ignore_overwritten_cli_params(mut params: Vec<String>) -> Vec<String> {
-    let mut defined_args = HashMap::new();
-    params.reverse(); // reverse to give later params higher priority
-    params.retain(move |param| {
-        let Some((arg, value)) = param.split_once('=') else {
-            return true; // keep anything we can't parse (e.g. program name)
-        };
-        match defined_args.entry(arg.to_string()) {
-            Entry::Occupied(val) => {
-                tracing::info!(
-                    ignored = ?param,
-                    kept = format!("{arg}={}", val.get()),
-                    "ignoring overwritten CLI argument"
-                );
-                false
-            }
-            Entry::Vacant(slot) => {
-                slot.insert(value.to_string());
-                true
-            }
-        }
-    });
-    params.reverse(); // reverse to restore original order again
-    params
-}
diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs
index 42109ad0ad..fc752dc2d5 100644
--- a/crates/e2e/tests/e2e/autopilot_leader.rs
+++ b/crates/e2e/tests/e2e/autopilot_leader.rs
@@ -3,6 +3,7 @@ use {
     configs::{
         autopilot::{Configuration, run_loop::RunLoopConfig},
         order_quoting::{ExternalSolver, OrderQuoting},
+        shared::SharedConfig,
         test_util::TestDefault,
     },
     e2e::setup::{
@@ -98,23 +99,20 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
             enable_leader_lock: true,
             ..leader_config.run_loop
         },
-        ..leader_config
-    };
-
-    let leader_config = Configuration {
+        shared: SharedConfig {
+            gas_estimators: vec![TestDefault::test_default()],
+            ..leader_config.shared
+        },
         order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
             "test_quoter",
             "http://localhost:11088/test_solver",
         )]),
+
         ..leader_config
     };
+
     let autopilot_leader = services
-        .start_autopilot_with_shutdown_controller(
-            None,
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-            leader_config,
-            control,
-        )
+        .start_autopilot_with_shutdown_controller(None, leader_config, control)
         .await;
 
     let follower_config = Configuration::test("test_solver2", solver2.address());
@@ -125,45 +123,37 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
             enable_leader_lock: true,
             ..follower_config.run_loop
         },
-        ..follower_config
-    };
-
-    let follower_config = Configuration {
         order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
             "test_quoter",
             "http://localhost:11088/test_solver2",
         )]),
+        shared: SharedConfig {
+            gas_estimators: vec![TestDefault::test_default()],
+            ..follower_config.shared
+        },
         ..follower_config
     };
-    let _autopilot_follower = services
-        .start_autopilot(
-            None,
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-            follower_config,
-        )
-        .await;
+
+    let _autopilot_follower = services.start_autopilot(None, follower_config).await;
 
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![
-                    ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver1"),
-                    ExternalSolver::new("test_solver2", "http://localhost:11088/test_solver2"),
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![
+                ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver1"),
+                ExternalSolver::new("test_solver2", "http://localhost:11088/test_solver2"),
+            ]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                    vec![
+                        configs::native_price_estimators::NativePriceEstimator::forwarder(
+                            "http://0.0.0.0:9588".parse().unwrap(),
+                        ),
+                    ],
                 ]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
-                        vec![
-                            configs::native_price_estimators::NativePriceEstimator::forwarder(
-                                "http://0.0.0.0:9588".parse().unwrap(),
-                            ),
-                        ],
-                    ]),
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     let order = || {
diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs
index df61247fd5..87f23c1b6e 100644
--- a/crates/e2e/tests/e2e/buffers.rs
+++ b/crates/e2e/tests/e2e/buffers.rs
@@ -68,7 +68,6 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             configs::autopilot::Configuration {
                 trusted_tokens: TrustedTokensConfig {
                     tokens: vec![
@@ -87,16 +86,13 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Place Order
diff --git a/crates/e2e/tests/e2e/cors.rs b/crates/e2e/tests/e2e/cors.rs
index 2c7d4e76a3..fb2475970b 100644
--- a/crates/e2e/tests/e2e/cors.rs
+++ b/crates/e2e/tests/e2e/cors.rs
@@ -4,6 +4,7 @@
 use {
     configs::{
         order_quoting::{ExternalSolver, OrderQuoting},
+        shared::SharedConfig,
         test_util::TestDefault,
     },
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
@@ -23,16 +24,17 @@ async fn cors_preflight(web3: Web3) {
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
     services
-        .start_api(
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            shared: SharedConfig {
+                gas_estimators: vec![TestDefault::test_default()],
+                ..Default::default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
     let client = services.client();
 
@@ -86,16 +88,17 @@ async fn cors_headers_on_error(web3: Web3) {
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
     services
-        .start_api(
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            shared: SharedConfig {
+                gas_estimators: vec![TestDefault::test_default()],
+                ..Default::default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
     let client = services.client();
 
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index 8370044a4b..ca4eb4c232 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -190,7 +190,6 @@ async fn cow_amm_jit(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_solver",
@@ -201,16 +200,13 @@ async fn cow_amm_jit(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_solver",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_solver",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Derive the order's valid_to from the blockchain because the cow amm enforces
@@ -571,7 +567,6 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 drivers: vec![
                     Solver::test("test_solver", solver.address()),
@@ -594,16 +589,13 @@ factory = "0xf76c421bAb7df8548604E60deCCcE50477C10462"
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_solver",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_solver",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     onchain.mint_block().await;
@@ -855,7 +847,6 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "mock_solver",
@@ -866,16 +857,13 @@ async fn cow_amm_opposite_direction(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "mock_solver",
-                    "http://localhost:11088/mock_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "mock_solver",
+                "http://localhost:11088/mock_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Get the current block timestamp
diff --git a/crates/e2e/tests/e2e/debug_order.rs b/crates/e2e/tests/e2e/debug_order.rs
index be8967d4b5..d78d92470e 100644
--- a/crates/e2e/tests/e2e/debug_order.rs
+++ b/crates/e2e/tests/e2e/debug_order.rs
@@ -48,7 +48,6 @@ async fn debug_order(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration::test_default(),
             solver,
@@ -195,7 +194,6 @@ async fn debug_order_filter_reason(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration::test_default(),
             solver,
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index a8241a3d3a..a400a34a4d 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -97,7 +97,6 @@ async fn single_limit_order_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_solver",
@@ -108,16 +107,13 @@ async fn single_limit_order_test(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_solver",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_solver",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Place order
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index a6efffc491..742c2446c1 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -368,7 +368,6 @@ async fn two_limit_orders_test(web3: Web3) {
     };
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             config,
             configs::orderbook::Configuration::test_default(),
             solver,
@@ -508,27 +507,24 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
 
     let services = Services::new(&onchain).await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "solver1",
-                    "http://localhost:11088/test_solver",
-                )]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
-                        vec![
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "test_quoter".to_string(),
-                                "http://localhost:11088/test_solver".parse().unwrap(),
-                            ),
-                        ],
-                    ]),
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "solver1",
+                "http://localhost:11088/test_solver",
+            )]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                    vec![
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_solver".parse().unwrap(),
+                        ),
+                    ],
+                ]),
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Place Orders
@@ -570,7 +566,6 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 drivers: vec![
                     Solver::new(
@@ -756,7 +751,6 @@ async fn too_many_limit_orders_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_quoter",
@@ -767,20 +761,17 @@ async fn too_many_limit_orders_test(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                order_validation: OrderValidationConfig {
-                    max_limit_orders_per_user: 1,
-                    ..Default::default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            order_validation: OrderValidationConfig {
+                max_limit_orders_per_user: 1,
+                ..Default::default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     let order = OrderCreation {
@@ -863,7 +854,6 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_quoter",
@@ -874,20 +864,17 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                order_validation: OrderValidationConfig {
-                    max_limit_orders_per_user: 1,
-                    ..Default::default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            order_validation: OrderValidationConfig {
+                max_limit_orders_per_user: 1,
+                ..Default::default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     let quote_request = OrderQuoteRequest {
@@ -1190,7 +1177,6 @@ async fn no_liquidity_limit_order(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             Configuration {
                 drivers: vec![Solver::test("test_solver", solver.address())],
                 unsupported_tokens: vec![*unsupported.address()],
@@ -1385,7 +1371,6 @@ async fn sell_order_with_haircut_test(web3: Web3) {
     // Start protocol with 500 bps (5%) haircut
     services
         .start_protocol_with_args_and_haircut(
-            Default::default(),
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration::test_default(),
             solver,
@@ -1586,7 +1571,6 @@ async fn buy_order_with_haircut_test(web3: Web3) {
     // Start protocol with 500 bps (5%) haircut
     services
         .start_protocol_with_args_and_haircut(
-            Default::default(),
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration::test_default(),
             solver,
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index a18adbbd43..96f4dd2d7b 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -199,7 +199,6 @@ async fn zero_ex_liquidity(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_quoter",
@@ -210,16 +209,13 @@ async fn zero_ex_liquidity(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Drive solution
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index 79b1eb1438..e290918234 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -210,7 +210,6 @@ http-timeout = "10s"
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_quoter",
@@ -221,16 +220,13 @@ http-timeout = "10s"
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Create CoW order
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 4e32290aa6..052e2e224a 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -4,6 +4,7 @@
 use {
     configs::{
         order_quoting::{ExternalSolver, OrderQuoting},
+        shared::SharedConfig,
         test_util::TestDefault,
     },
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
@@ -31,16 +32,17 @@ async fn http_validation(web3: Web3) {
     // since we're testing malformed paths, etc;
     // we don't really need the rest of the protocol
     services
-        .start_api(
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            shared: SharedConfig {
+                gas_estimators: vec![TestDefault::test_default()],
+                ..Default::default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
     let client = services.client();
 
diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs
index 18faeb7ecf..fdbf0c2c45 100644
--- a/crates/e2e/tests/e2e/order_cancellation.rs
+++ b/crates/e2e/tests/e2e/order_cancellation.rs
@@ -73,7 +73,6 @@ async fn order_cancellation(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             // Empty drivers to prevent settlement — this test places multiple
             // orders and asserts exact auction counts, which would race with the
             // solver settling them.
@@ -87,16 +86,13 @@ async fn order_cancellation(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     onchain.mint_block().await;
diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs
index 06eb9dadbf..63ecc2dfac 100644
--- a/crates/e2e/tests/e2e/place_order_with_quote.rs
+++ b/crates/e2e/tests/e2e/place_order_with_quote.rs
@@ -4,6 +4,7 @@ use {
     configs::{
         autopilot::Configuration,
         order_quoting::{ExternalSolver, OrderQuoting},
+        shared::SharedConfig,
         test_util::TestDefault,
     },
     e2e::setup::{colocation, wait_for_condition, *},
@@ -225,12 +226,15 @@ async fn fallback_native_price_estimator(web3: Web3) {
     let autopilot_handle = services
         .start_autopilot_with_shutdown_controller(
             None,
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
             Configuration {
                 order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
                     "test_quoter",
                     "http://localhost:11088/test_solver",
                 )]),
+                shared: SharedConfig {
+                    gas_estimators: vec![TestDefault::test_default()],
+                    ..Default::default()
+                },
                 ..Configuration::test("test_solver", solver.address())
             },
             control,
@@ -238,34 +242,35 @@ async fn fallback_native_price_estimator(web3: Web3) {
         .await;
 
     services
-        .start_api(
-            vec!["--gas-estimators=http://localhost:11088/gasprice".to_string()],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_solver",
-                )]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    fallback_estimators: Some(
-                        configs::native_price_estimators::NativePriceEstimators::new(vec![vec![
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "test_quoter".to_string(),
-                                "http://localhost:11088/test_solver".parse().unwrap(),
-                            ),
-                        ]]),
-                    ),
-                    shared: configs::native_price::NativePriceConfig {
-                        cache: configs::native_price::CacheConfig {
-                            max_age: std::time::Duration::from_secs(2),
-                            ..Default::default()
-                        },
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                fallback_estimators: Some(
+                    configs::native_price_estimators::NativePriceEstimators::new(vec![vec![
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_solver".parse().unwrap(),
+                        ),
+                    ]]),
+                ),
+                shared: configs::native_price::NativePriceConfig {
+                    cache: configs::native_price::CacheConfig {
+                        max_age: std::time::Duration::from_secs(2),
                         ..Default::default()
                     },
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
+                    ..Default::default()
                 },
-                ..configs::orderbook::Configuration::test_default()
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            shared: SharedConfig {
+                gas_estimators: vec![TestDefault::test_default()],
+                ..Default::default()
+            },
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     tracing::info!("Quoting with autopilot running");
diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs
index 46a139982b..820a604a16 100644
--- a/crates/e2e/tests/e2e/protocol_fee.rs
+++ b/crates/e2e/tests/e2e/protocol_fee.rs
@@ -167,7 +167,6 @@ async fn combined_protocol_fees(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration {
                 drivers: vec![Solver::test("test_solver", solver.address())],
                 fee_policies: FeePoliciesConfig {
@@ -519,7 +518,6 @@ async fn surplus_partner_fee(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration {
                 drivers: vec![Solver::test("test_solver", solver.address())],
                 fee_policies: FeePoliciesConfig {
@@ -758,7 +756,6 @@ async fn volume_fee_buy_order_test(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration {
                 drivers: vec![Solver::test("test_solver", solver.address())],
                 fee_policies: FeePoliciesConfig {
@@ -921,7 +918,6 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration {
                 drivers: vec![Solver::test("test_solver", solver.address())],
                 fee_policies: FeePoliciesConfig {
@@ -1075,26 +1071,36 @@ async fn volume_fee_overrides(web3: Web3) {
         order_class: ConfigFeePolicyOrderClass::Any,
     };
 
-    // Bucket overrides (comma-separated, checked in order, first match wins):
+    // Bucket overrides (checked in order, first match wins):
     // - 2-token pair: USDC-DAI has 0.05% fee (checked first, has precedence)
     // - Stablecoins: USDC, DAI, USDT have 0% fee (checked second)
-    let volume_fee_bucket_config = format!(
-        "--volume-fee-bucket-overrides=0.0005:{};{},0:{};{};{}",
-        token_usdc.address(),
-        token_dai.address(),
-        token_usdc.address(),
-        token_dai.address(),
-        token_usdt.address()
-    );
+    let volume_fee_bucket_overrides = vec![
+        configs::shared::TokenBucketFeeOverride {
+            tokens: [*token_usdc.address(), *token_dai.address()]
+                .into_iter()
+                .collect(),
+            factor: FeeFactor::new(0.0005),
+        },
+        configs::shared::TokenBucketFeeOverride {
+            tokens: [
+                *token_usdc.address(),
+                *token_dai.address(),
+                *token_usdt.address(),
+            ]
+            .into_iter()
+            .collect(),
+            factor: FeeFactor::new(0.0),
+        },
+    ];
 
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                autopilot: vec![volume_fee_bucket_config.clone()],
-                api: vec![volume_fee_bucket_config],
-            },
             Configuration {
+                shared: configs::shared::SharedConfig {
+                    volume_fee_bucket_overrides: volume_fee_bucket_overrides.clone(),
+                    ..Default::default()
+                },
                 drivers: vec![Solver::test("test_solver", solver.address())],
                 fee_policies: FeePoliciesConfig {
                     policies: vec![default_volume_fee],
@@ -1103,6 +1109,10 @@ async fn volume_fee_overrides(web3: Web3) {
                 ..Configuration::test_no_drivers()
             },
             configs::orderbook::Configuration {
+                shared: configs::shared::SharedConfig {
+                    volume_fee_bucket_overrides,
+                    ..Default::default()
+                },
                 volume_fee: Some(configs::orderbook::VolumeFeeConfig {
                     factor: Some(FeeFactor::new(0.01)), // Default 1% volume fee
                     effective_from_timestamp: None,
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 6b35e93f51..7b3809f5a5 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -401,7 +401,6 @@ async fn verified_quote_with_simulated_balance(web3: Web3) {
     };
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             Configuration::test("test_solver", solver.address()),
             orderbook_config,
             solver,
@@ -543,7 +542,6 @@ async fn usdt_quote_verification(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration {
                 price_estimation: configs::price_estimation::PriceEstimation {
diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs
index 2efc435d63..350ebbad09 100644
--- a/crates/e2e/tests/e2e/quoting.rs
+++ b/crates/e2e/tests/e2e/quoting.rs
@@ -102,7 +102,6 @@ async fn test(web3: Web3) {
     // Start API with 0.02% (2 bps) volume fee
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration {
                 volume_fee: Some(configs::orderbook::VolumeFeeConfig {
@@ -344,31 +343,28 @@ async fn quote_timeout(web3: Web3) {
     const MAX_QUOTE_TIME_MS: u64 = 500;
 
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_quoter",
-                )]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
-                        vec![
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "test_quoter".to_string(),
-                                "http://localhost:11088/test_solver".parse().unwrap(),
-                            ),
-                        ],
-                    ]),
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
-                },
-                price_estimation: configs::price_estimation::PriceEstimation {
-                    quote_timeout: Duration::from_millis(MAX_QUOTE_TIME_MS),
-                    ..configs::orderbook::Configuration::test_default().price_estimation
-                },
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_quoter",
+            )]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                    vec![
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_solver".parse().unwrap(),
+                        ),
+                    ],
+                ]),
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            price_estimation: configs::price_estimation::PriceEstimation {
+                quote_timeout: Duration::from_millis(MAX_QUOTE_TIME_MS),
+                ..configs::orderbook::Configuration::test_default().price_estimation
+            },
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     mock_solver.configure_solution_async(Arc::new(|| {
@@ -515,27 +511,24 @@ async fn quote_custom_solver_errors(web3: Web3) {
     );
 
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_quoter",
-                )]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
-                        vec![
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "test_quoter".to_string(),
-                                "http://localhost:11088/test_quoter".parse().unwrap(),
-                            ),
-                        ],
-                    ]),
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_quoter",
+            )]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                    vec![
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_quoter".parse().unwrap(),
+                        ),
+                    ],
+                ]),
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     let quote_request = OrderQuoteRequest {
@@ -642,27 +635,24 @@ async fn native_price_custom_solver_errors(web3: Web3) {
     );
 
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_quoter",
-                    "http://localhost:11088/test_quoter",
-                )]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
-                        vec![
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "test_quoter".to_string(),
-                                "http://localhost:11088/test_quoter".parse().unwrap(),
-                            ),
-                        ],
-                    ]),
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_quoter",
+            )]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                    vec![
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "test_quoter".to_string(),
+                            "http://localhost:11088/test_quoter".parse().unwrap(),
+                        ),
+                    ],
+                ]),
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     let cases = vec![
@@ -757,36 +747,33 @@ async fn quote_custom_solver_errors_prioritized(web3: Web3) {
     );
 
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![
-                    ExternalSolver::new("custom_solver", "http://localhost:11088/custom_solver"),
-                    ExternalSolver::new(
-                        "no_liquidity_solver",
-                        "http://localhost:11088/no_liquidity_solver",
-                    ),
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![
+                ExternalSolver::new("custom_solver", "http://localhost:11088/custom_solver"),
+                ExternalSolver::new(
+                    "no_liquidity_solver",
+                    "http://localhost:11088/no_liquidity_solver",
+                ),
+            ]),
+            native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
+                estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
+                    vec![
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "custom_solver".to_string(),
+                            "http://localhost:11088/custom_solver".parse().unwrap(),
+                        ),
+                        configs::native_price_estimators::NativePriceEstimator::driver(
+                            "no_liquidity_solver".to_string(),
+                            "http://localhost:11088/no_liquidity_solver"
+                                .parse()
+                                .unwrap(),
+                        ),
+                    ],
                 ]),
-                native_price_estimation: configs::orderbook::native_price::NativePriceConfig {
-                    estimators: configs::native_price_estimators::NativePriceEstimators::new(vec![
-                        vec![
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "custom_solver".to_string(),
-                                "http://localhost:11088/custom_solver".parse().unwrap(),
-                            ),
-                            configs::native_price_estimators::NativePriceEstimator::driver(
-                                "no_liquidity_solver".to_string(),
-                                "http://localhost:11088/no_liquidity_solver"
-                                    .parse()
-                                    .unwrap(),
-                            ),
-                        ],
-                    ]),
-                    ..configs::orderbook::native_price::NativePriceConfig::test_default()
-                },
-                ..configs::orderbook::Configuration::test_default()
+                ..configs::orderbook::native_price::NativePriceConfig::test_default()
             },
-        )
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     custom_error_solver.configure_response(SolverResponse::Error {
@@ -858,16 +845,20 @@ async fn volume_fee(web3: Web3) {
     // in bucket)
     services
         .start_protocol_with_args(
-            ExtraServiceArgs {
-                api: vec![format!(
-                    "--volume-fee-bucket-overrides=0.0005:{};{}",
-                    onchain.contracts().weth.address(),
-                    override_token.address()
-                )],
-                ..Default::default()
-            },
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration {
+                shared: configs::shared::SharedConfig {
+                    volume_fee_bucket_overrides: vec![configs::shared::TokenBucketFeeOverride {
+                        tokens: [
+                            *onchain.contracts().weth.address(),
+                            *override_token.address(),
+                        ]
+                        .into_iter()
+                        .collect(),
+                        factor: FeeFactor::new(0.0005),
+                    }],
+                    ..Default::default()
+                },
                 volume_fee: Some(configs::orderbook::VolumeFeeConfig {
                     factor: Some(FeeFactor::new(0.0002)),
                     // Set a past effective timestamp to ensure the fee is applied
diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs
index cd3adb19c8..2856a67123 100644
--- a/crates/e2e/tests/e2e/replace_order.rs
+++ b/crates/e2e/tests/e2e/replace_order.rs
@@ -480,7 +480,6 @@ async fn single_replace_order_test(web3: Web3) {
     };
     services
         .start_protocol_with_args(
-            ExtraServiceArgs::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
             orderbook_config,
             solver.clone(),
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index 88c2cfe323..cf17e3baec 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -176,7 +176,6 @@ async fn erc1271_gas_limit(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             configs::autopilot::Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index 60d2684732..f50249e4d9 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -94,7 +94,6 @@ async fn solver_competition(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 drivers: vec![
                     Solver::test("test_solver", solver.address()),
@@ -109,16 +108,13 @@ async fn solver_competition(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![
-                    ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver"),
-                    ExternalSolver::new("solver2", "http://localhost:11088/solver2"),
-                ]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![
+                ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver"),
+                ExternalSolver::new("solver2", "http://localhost:11088/solver2"),
+            ]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Place Order
@@ -253,7 +249,6 @@ async fn wrong_solution_submission_address(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 drivers: vec![
                     // Solver 1 has a wrong submission address, meaning that the solutions should
@@ -274,16 +269,13 @@ async fn wrong_solution_submission_address(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "solver1",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "solver1",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Place Orders
@@ -426,7 +418,6 @@ async fn store_filtered_solutions(web3: Web3) {
     services
         .start_autopilot(
             None,
-            vec![],
             Configuration {
                 drivers: vec![
                     Solver::test("good_solver", good_solver_account.address()),
@@ -445,16 +436,13 @@ async fn store_filtered_solutions(web3: Web3) {
         )
         .await;
     services
-        .start_api(
-            vec![],
-            configs::orderbook::Configuration {
-                order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
-                    "test_solver",
-                    "http://localhost:11088/test_solver",
-                )]),
-                ..configs::orderbook::Configuration::test_default()
-            },
-        )
+        .start_api(configs::orderbook::Configuration {
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_solver",
+                "http://localhost:11088/test_solver",
+            )]),
+            ..configs::orderbook::Configuration::test_default()
+        })
         .await;
 
     // Place order
diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs
index 0774b073ab..4ed090cc66 100644
--- a/crates/e2e/tests/e2e/submission.rs
+++ b/crates/e2e/tests/e2e/submission.rs
@@ -163,7 +163,6 @@ async fn test_submit_same_sell_and_buy_token_order_without_quote(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
@@ -279,7 +278,6 @@ async fn test_execute_same_sell_and_buy_token(web3: Web3) {
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
-            Default::default(),
             Configuration::test("test_solver", solver.address()),
             configs::orderbook::Configuration {
                 order_validation: OrderValidationConfig {
diff --git a/crates/gas-price-estimation/src/lib.rs b/crates/gas-price-estimation/src/lib.rs
index 40cbb58b39..83b4db984a 100644
--- a/crates/gas-price-estimation/src/lib.rs
+++ b/crates/gas-price-estimation/src/lib.rs
@@ -20,7 +20,6 @@ use {
     alloy_provider::Provider,
     anyhow::Result,
     ethrpc::Web3,
-    std::str::FromStr,
     tracing::instrument,
     url::Url,
 };
@@ -52,20 +51,6 @@ pub enum GasEstimatorType {
     Alloy,
 }
 
-impl FromStr for GasEstimatorType {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_ascii_lowercase().as_str() {
-            "web3" => Ok(GasEstimatorType::Web3),
-            "alloy" => Ok(GasEstimatorType::Alloy),
-            _ => Url::parse(s).map(GasEstimatorType::Driver).map_err(|e| {
-                format!("expected 'web3', 'alloy', or a valid driver URL; got {s:?}: {e}")
-            }),
-        }
-    }
-}
-
 #[instrument(skip_all)]
 pub async fn create_priority_estimator(
     http_client: reqwest::Client,
diff --git a/crates/orderbook/src/arguments.rs b/crates/orderbook/src/arguments.rs
index e694c5efa8..868697a4cd 100644
--- a/crates/orderbook/src/arguments.rs
+++ b/crates/orderbook/src/arguments.rs
@@ -1,29 +1,17 @@
-use std::{net::SocketAddr, path::PathBuf};
+use std::path::PathBuf;
 
 #[derive(clap::Parser)]
 pub struct Arguments {
-    #[clap(flatten)]
-    pub shared: shared::arguments::Arguments,
-
     /// Path to the TOML configuration file.
     #[clap(long, env)]
     pub config: PathBuf,
-
-    #[clap(long, env, default_value = "0.0.0.0:8080")]
-    pub bind_address: SocketAddr,
 }
 
 impl std::fmt::Display for Arguments {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let Arguments {
-            shared,
-            config,
-            bind_address,
-        } = self;
+        let Arguments { config } = self;
 
-        write!(f, "{shared}")?;
         writeln!(f, "config: {}", config.display())?;
-        writeln!(f, "bind_address: {bind_address}")?;
 
         Ok(())
     }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index f824c1b093..b4ac88d89a 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -39,7 +39,6 @@ use {
         trade_verifier::code_fetching::CachedCodeFetcher,
     },
     shared::{
-        arguments::tracing_config,
         order_quoting::{self, OrderQuoter},
         order_validation::{OrderValidPeriodConfiguration, OrderValidator},
     },
@@ -50,11 +49,27 @@ use {
 
 pub async fn start(args: impl Iterator<Item = String>) {
     let args = Arguments::parse_from(args);
+    let config = Configuration::from_path(&args.config)
+        .await
+        .expect("failed to load configuration file");
+    let tracing_config = config
+        .shared
+        .tracing
+        .collector_endpoint
+        .as_ref()
+        .map(|endpoint| {
+            observe::TracingConfig::new(
+                endpoint.clone(),
+                "orderbook".into(),
+                config.shared.tracing.exporter_timeout,
+                config.shared.tracing.level,
+            )
+        });
     let obs_config = observe::Config::new(
-        args.shared.logging.log_filter.as_str(),
-        args.shared.logging.log_stderr_threshold,
-        args.shared.logging.use_json_logs,
-        tracing_config(&args.shared.tracing, "orderbook".into()),
+        config.shared.logging.filter.as_str(),
+        config.shared.logging.stderr_threshold,
+        config.shared.logging.use_json,
+        tracing_config,
     );
     observe::tracing::init::initialize(&obs_config);
     tracing::info!("running order book with validated arguments:\n{}", args);
@@ -62,42 +77,40 @@ pub async fn start(args: impl Iterator<Item = String>) {
     observe::metrics::setup_registry(Some("gp_v2_api".into()), None);
     #[cfg(unix)]
     observe::heap_dump_handler::spawn_heap_dump_handler();
-    let config = Configuration::from_path(&args.config)
-        .await
-        .expect("failed to load configuration file");
     tracing::info!("file configuration:\n{:#?}", config);
-    run(args, config).await;
+    run(config).await;
 }
 
-pub async fn run(args: Arguments, config: Configuration) {
+pub async fn run(config: Configuration) {
     let http_factory = HttpClientFactory::from(config.http_client);
 
-    let web3 = shared::web3::web3(&args.shared.ethrpc, &args.shared.node_url, "base");
-    let simulation_web3 = args
+    let ethrpc_args = shared::web3::Arguments::from(&config.shared.ethrpc);
+    let web3 = shared::web3::web3(&ethrpc_args, &config.shared.node_url, "base");
+    let simulation_web3 = config
         .shared
         .simulation_node_url
         .as_ref()
-        .map(|node_url| shared::web3::web3(&args.shared.ethrpc, node_url, "simulation"));
+        .map(|node_url| shared::web3::web3(&ethrpc_args, node_url, "simulation"));
 
     let chain_id = web3
         .provider
         .get_chain_id()
         .await
         .expect("Could not get chainId");
-    if let Some(expected_chain_id) = args.shared.chain_id {
+    if let Some(expected_chain_id) = config.shared.chain_id {
         assert_eq!(
             chain_id, expected_chain_id,
             "connected to node with incorrect chain ID",
         );
     }
 
-    let settlement_contract = match args.shared.settlement_contract_address {
+    let settlement_contract = match config.shared.contracts.settlement {
         Some(address) => GPv2Settlement::Instance::new(address, web3.provider.clone()),
         None => GPv2Settlement::Instance::deployed(&web3.provider)
             .await
             .expect("load settlement contract"),
     };
-    let balances_contract = match args.shared.balances_contract_address {
+    let balances_contract = match config.shared.contracts.balances {
         Some(address) => Balances::Instance::new(address, web3.provider.clone()),
         None => Balances::Instance::deployed(&web3.provider.clone())
             .await
@@ -108,7 +121,7 @@ pub async fn run(args: Arguments, config: Configuration) {
         .call()
         .await
         .expect("Couldn't get vault relayer address");
-    let signatures_contract = match args.shared.signatures_contract_address {
+    let signatures_contract = match config.shared.contracts.signatures {
         Some(address) => {
             contracts::alloy::support::Signatures::Instance::new(address, web3.provider.clone())
         }
@@ -116,7 +129,7 @@ pub async fn run(args: Arguments, config: Configuration) {
             .await
             .expect("load signatures contract"),
     };
-    let native_token = match args.shared.native_token_address {
+    let native_token = match config.shared.contracts.native_token {
         Some(address) => WETH9::Instance::new(address, web3.provider.clone()),
         None => WETH9::Instance::deployed(&web3.provider)
             .await
@@ -136,7 +149,7 @@ pub async fn run(args: Arguments, config: Configuration) {
         balance_overrider.clone(),
     );
 
-    let vault_address = args.shared.balancer_v2_vault_address.or_else(|| {
+    let vault_address = config.shared.contracts.balancer_v2_vault.or_else(|| {
         let chain_id = chain.id();
         match BalancerV2Vault::deployment_address(&chain_id) {
             addr @ Some(_) => addr,
@@ -150,7 +163,7 @@ pub async fn run(args: Arguments, config: Configuration) {
         }
     });
 
-    let hooks_contract = match args.shared.hooks_contract_address {
+    let hooks_contract = match config.shared.contracts.hooks {
         Some(address) => HooksTrampoline::Instance::new(address, web3.provider.clone()),
         None => HooksTrampoline::Instance::deployed(&web3.provider)
             .await
@@ -187,11 +200,17 @@ pub async fn run(args: Arguments, config: Configuration) {
         ),
     );
 
+    let gas_estimators: Vec<gas_price_estimation::GasEstimatorType> = config
+        .shared
+        .gas_estimators
+        .iter()
+        .map(shared::arguments::gas_estimator_type_from_config)
+        .collect();
     let gas_price_estimator = Arc::new(InstrumentedGasEstimator::new(
         gas_price_estimation::create_priority_estimator(
             http_factory.create(),
             &web3,
-            args.shared.gas_estimators.as_slice(),
+            &gas_estimators,
         )
         .await
         .expect("failed to create gas price estimator"),
@@ -199,10 +218,9 @@ pub async fn run(args: Arguments, config: Configuration) {
 
     let deny_listed_tokens = DenyListedTokens::new(config.unsupported_tokens);
 
-    let current_block_stream = args
-        .shared
-        .current_block
-        .stream(args.shared.node_url.clone(), web3.provider.clone())
+    let current_block_args = shared::current_block::Arguments::from(&config.shared.current_block);
+    let current_block_stream = current_block_args
+        .stream(config.shared.node_url.clone(), web3.provider.clone())
         .await
         .unwrap();
 
@@ -401,13 +419,19 @@ pub async fn run(args: Arguments, config: Configuration) {
     ));
 
     check_database_connection(orderbook.as_ref()).await;
+    let volume_fee_bucket_overrides: Vec<shared::arguments::TokenBucketFeeOverride> = config
+        .shared
+        .volume_fee_bucket_overrides
+        .iter()
+        .map(Into::into)
+        .collect();
     let quotes = QuoteHandler::new(
         order_validator,
         optimal_quoter,
         app_data.clone(),
         config.volume_fee,
-        args.shared.volume_fee_bucket_overrides.clone(),
-        args.shared.enable_sell_equals_buy_volume_fee,
+        volume_fee_bucket_overrides,
+        config.shared.enable_sell_equals_buy_volume_fee,
     )
     .with_fast_quoter(fast_quoter);
 
@@ -418,7 +442,7 @@ pub async fn run(args: Arguments, config: Configuration) {
         orderbook.clone(),
         quotes,
         app_data,
-        args.bind_address,
+        config.bind_address,
         async {
             let _ = shutdown_receiver.await;
         },
@@ -426,7 +450,7 @@ pub async fn run(args: Arguments, config: Configuration) {
         config.price_estimation.quote_timeout,
     );
 
-    let mut metrics_address = args.bind_address;
+    let mut metrics_address = config.bind_address;
     metrics_address.set_port(DEFAULT_METRICS_PORT);
     tracing::info!(%metrics_address, "serving metrics");
     let metrics_task = serve_metrics(
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index da0e8f2493..623642776c 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -3,7 +3,6 @@
 
 use {
     alloy::primitives::Address,
-    anyhow::{Context, Result, ensure},
     configs::fee_factor::FeeFactor,
     gas_price_estimation::GasEstimatorType,
     observe::TracingConfig,
@@ -11,10 +10,8 @@ use {
         collections::HashSet,
         fmt::{self, Display, Formatter},
         num::NonZeroU32,
-        str::FromStr,
         time::Duration,
     },
-    url::Url,
 };
 
 #[macro_export]
@@ -95,104 +92,6 @@ impl Display for DatabasePoolConfig {
     }
 }
 
-#[derive(clap::Parser)]
-#[group(skip)]
-pub struct Arguments {
-    #[clap(flatten)]
-    pub ethrpc: crate::web3::Arguments,
-
-    #[clap(flatten)]
-    pub current_block: crate::current_block::Arguments,
-
-    #[clap(flatten)]
-    pub logging: LoggingArguments,
-
-    #[clap(flatten)]
-    pub tracing: TracingArguments,
-
-    /// The Ethereum node URL to connect to.
-    #[clap(long, env, default_value = "http://localhost:8545")]
-    pub node_url: Url,
-
-    /// An Ethereum node URL that supports `eth_call`s with state overrides to
-    /// be used for simulations.
-    #[clap(long, env)]
-    pub simulation_node_url: Option<Url>,
-
-    /// The expected chain ID that the services are expected to run against.
-    /// This can be optionally specified in order to check at startup whether
-    /// the connected nodes match to detect misconfigurations.
-    #[clap(long, env)]
-    pub chain_id: Option<u64>,
-
-    /// Which gas estimators to use. Multiple estimators are used in sequence if
-    /// a previous one fails. Individual estimators support different
-    /// networks. `EthGasStation`: supports mainnet.
-    /// `GasNow`: supports mainnet.
-    /// `Web3`: supports every network.
-    /// `Native`: supports every network.
-    #[clap(
-        long,
-        env,
-        default_value = "Web3",
-        use_value_delimiter = true,
-        value_parser = clap::value_parser!(GasEstimatorType)
-    )]
-    pub gas_estimators: Vec<GasEstimatorType>,
-
-    /// The time between new blocks on the network.
-    #[clap(long, env, value_parser = humantime::parse_duration)]
-    pub network_block_interval: Option<Duration>,
-
-    /// Override address of the settlement contract.
-    #[clap(long, env)]
-    pub settlement_contract_address: Option<Address>,
-
-    /// Override address of the Balances contract.
-    #[clap(long, env)]
-    pub balances_contract_address: Option<Address>,
-
-    /// Override address of the Signatures contract.
-    #[clap(long, env)]
-    pub signatures_contract_address: Option<Address>,
-
-    /// Override address of the settlement contract.
-    #[clap(long, env)]
-    pub native_token_address: Option<Address>,
-
-    /// Override the address of the `HooksTrampoline` contract used for
-    /// trampolining custom order interactions. If not specified, the default
-    /// contract deployment for the current network will be used.
-    #[clap(long, env)]
-    pub hooks_contract_address: Option<Address>,
-
-    /// Override address of the balancer vault contract.
-    #[clap(long, env)]
-    pub balancer_v2_vault_address: Option<Address>,
-
-    /// Custom volume fees for token buckets.
-    /// Format: "factor:token1;token2;..." (e.g.,
-    /// "0:0xA0b86...;0x6B175...;0xdAC17...") Orders where BOTH tokens are
-    /// in the bucket will use the custom fee. Useful for
-    /// stablecoin-to-stablecoin trades or specific token pairs (2-token
-    /// buckets). Multiple buckets can be separated by commas.
-    #[clap(long, env, value_delimiter = ',')]
-    pub volume_fee_bucket_overrides: Vec<TokenBucketFeeOverride>,
-
-    /// Enable volume fees for trades where sell token equals buy token.
-    /// By default, volume fees are NOT applied to same-token trades.
-    #[clap(long, env)]
-    pub enable_sell_equals_buy_volume_fee: bool,
-}
-
-pub fn display_secret_option<T>(
-    f: &mut Formatter<'_>,
-    name: &str,
-    option: Option<&T>,
-) -> std::fmt::Result {
-    display_option(f, name, &option.as_ref().map(|_| "SECRET"))
-}
-
 pub fn display_option(
     f: &mut Formatter<'_>,
     name: &str,
@@ -205,104 +104,6 @@ pub fn display_option(
     }
 }
 
-pub fn display_list<T>(
-    f: &mut Formatter<'_>,
-    name: &str,
-    iter: impl IntoIterator<Item = T>,
-) -> std::fmt::Result
-where
-    T: Display,
-{
-    write!(f, "{name}: [")?;
-    for (i, t) in iter.into_iter().enumerate() {
-        if i != 0 {
-            f.write_str(", ")?;
-        }
-        write!(f, "{t}")?;
-    }
-    writeln!(f, "]")?;
-    Ok(())
-}
-
-// We have a custom Display implementation so that we can log the arguments on
-// start up without leaking any potentially secret values.
-impl Display for Arguments {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let Self {
-            ethrpc,
-            current_block,
-            logging,
-            node_url,
-            chain_id,
-            simulation_node_url,
-            gas_estimators,
-            network_block_interval,
-            settlement_contract_address,
-            balances_contract_address,
-            signatures_contract_address,
-            native_token_address,
-            hooks_contract_address,
-            balancer_v2_vault_address,
-            tracing,
-            volume_fee_bucket_overrides,
-            enable_sell_equals_buy_volume_fee,
-        } = self;
-
-        write!(f, "{ethrpc}")?;
-        write!(f, "{current_block}")?;
-        write!(f, "{logging}")?;
-        writeln!(f, "node_url: {node_url}")?;
-        display_option(f, "chain_id", chain_id)?;
-        display_option(f, "simulation_node_url", simulation_node_url)?;
-        writeln!(f, "gas_estimators: {gas_estimators:?}")?;
-        display_option(
-            f,
-            "network_block_interval",
-            &network_block_interval.map(|duration| duration.as_secs_f32()),
-        )?;
-        display_option(
-            f,
-            "settlement_contract_address",
-            &settlement_contract_address.map(|a| format!("{a:?}")),
-        )?;
-        display_option(
-            f,
-            "balances_contract_address",
-            &balances_contract_address.map(|a| format!("{a:?}")),
-        )?;
-        display_option(
-            f,
-            "signatures_contract_address",
-            &signatures_contract_address.map(|a| format!("{a:?}")),
-        )?;
-        display_option(
-            f,
-            "native_token_address",
-            &native_token_address.map(|a| format!("{a:?}")),
-        )?;
-        display_option(
-            f,
-            "hooks_contract_address",
-            &hooks_contract_address.map(|a| format!("{a:?}")),
-        )?;
-        display_option(
-            f,
-            "balancer_v2_vault_address",
-            &balancer_v2_vault_address.map(|a| format!("{a:?}")),
-        )?;
-        write!(f, "{tracing:?}")?;
-        writeln!(
-            f,
-            "volume_fee_bucket_overrides: {volume_fee_bucket_overrides:?}"
-        )?;
-        writeln!(
-            f,
-            "enable_sell_equals_buy_volume_fee: {enable_sell_equals_buy_volume_fee}"
-        )?;
-        Ok(())
-    }
-}
-
 /// Helper type for parsing token bucket fee overrides from strings
 #[derive(Debug, Clone)]
 pub struct TokenBucketFeeOverride {
@@ -310,107 +111,21 @@ pub struct TokenBucketFeeOverride {
     pub factor: FeeFactor,
 }
 
-impl FromStr for TokenBucketFeeOverride {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (factor_str, tokens_str) = s.split_once(':').with_context(|| {
-            format!(
-                "invalid bucket override format: expected 'factor:token1;token2;...', got '{}'",
-                s
-            )
-        })?;
-        let factor = factor_str
-            .parse::<f64>()
-            .context("failed to parse fee factor")?
-            .try_into()
-            .context("fee factor out of range")?;
-        let tokens: HashSet<Address> = tokens_str
-            .split(';')
-            .map(|token| {
-                token
-                    .parse::<Address>()
-                    .with_context(|| format!("failed to parse token address '{}'", token))
-            })
-            .collect::<Result<HashSet<Address>>>()?;
-
-        ensure!(
-            tokens.len() >= 2,
-            "bucket override must contain at least 2 tokens, got {}",
-            tokens.len()
-        );
-
-        Ok(TokenBucketFeeOverride { tokens, factor })
+pub fn gas_estimator_type_from_config(
+    config: &configs::shared::GasEstimatorType,
+) -> GasEstimatorType {
+    match config {
+        configs::shared::GasEstimatorType::Web3 => GasEstimatorType::Web3,
+        configs::shared::GasEstimatorType::Driver { url } => GasEstimatorType::Driver(url.clone()),
+        configs::shared::GasEstimatorType::Alloy => GasEstimatorType::Alloy,
     }
 }
 
-#[cfg(test)]
-mod test {
-    use {super::*, alloy::primitives::address};
-
-    #[test]
-    fn parse_token_bucket_fee_override() {
-        // Valid inputs with 2 tokens (minimum required)
-        let valid_two_tokens = "0.5:0x0000000000000000000000000000000000000001;\
-                                0x0000000000000000000000000000000000000002";
-        let result = TokenBucketFeeOverride::from_str(valid_two_tokens).unwrap();
-        assert_eq!(result.factor.get(), 0.5);
-        assert_eq!(result.tokens.len(), 2);
-        assert!(
-            result
-                .tokens
-                .contains(&address!("0000000000000000000000000000000000000001"))
-        );
-        assert!(
-            result
-                .tokens
-                .contains(&address!("0000000000000000000000000000000000000002"))
-        );
-
-        // Valid inputs with 3 tokens
-        let valid_three_tokens = "0.123:0x0000000000000000000000000000000000000001;\
-                                  0x0000000000000000000000000000000000000002;\
-                                  0x0000000000000000000000000000000000000003";
-        let result = TokenBucketFeeOverride::from_str(valid_three_tokens).unwrap();
-        assert_eq!(result.factor.get(), 0.123);
-        assert_eq!(result.tokens.len(), 3);
-        // Invalid: only 1 token (need at least 2)
-        assert!(
-            TokenBucketFeeOverride::from_str("0.5:0x0000000000000000000000000000000000000001")
-                .is_err()
-        );
-        // Invalid: wrong format (no colon)
-        assert!(
-            TokenBucketFeeOverride::from_str("0.5,0x0000000000000000000000000000000000000001")
-                .is_err()
-        );
-        // Invalid: too many parts
-        assert!(
-            TokenBucketFeeOverride::from_str(
-                "0.5:0x0000000000000000000000000000000000000001:extra"
-            )
-            .is_err()
-        );
-        // Invalid: fee factor out of range
-        assert!(
-            TokenBucketFeeOverride::from_str("1.5:0x0000000000000000000000000000000000000001")
-                .is_err()
-        );
-        assert!(
-            TokenBucketFeeOverride::from_str("-0.1:0x0000000000000000000000000000000000000001")
-                .is_err()
-        );
-        // Invalid: not a number for fee factor
-        assert!(
-            TokenBucketFeeOverride::from_str("abc:0x0000000000000000000000000000000000000001")
-                .is_err()
-        );
-        // Invalid: bad token address
-        assert!(
-            TokenBucketFeeOverride::from_str(
-                "0.5:notanaddress,0x0000000000000000000000000000000000000002"
-            )
-            .is_err()
-        );
+impl From<&configs::shared::TokenBucketFeeOverride> for TokenBucketFeeOverride {
+    fn from(config: &configs::shared::TokenBucketFeeOverride) -> Self {
+        Self {
+            tokens: config.tokens.clone(),
+            factor: config.factor,
+        }
     }
 }
diff --git a/crates/shared/src/current_block.rs b/crates/shared/src/current_block.rs
index 4f68b6d0fa..537724552f 100644
--- a/crates/shared/src/current_block.rs
+++ b/crates/shared/src/current_block.rs
@@ -59,6 +59,15 @@ impl Arguments {
     }
 }
 
+impl From<&configs::shared::CurrentBlockConfig> for Arguments {
+    fn from(config: &configs::shared::CurrentBlockConfig) -> Self {
+        Self {
+            block_stream_poll_interval: config.poll_interval,
+            node_ws_url: config.ws_url.clone(),
+        }
+    }
+}
+
 impl Display for Arguments {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         let Self {
diff --git a/crates/shared/src/web3.rs b/crates/shared/src/web3.rs
index 51e52eb495..d1aaa7c636 100644
--- a/crates/shared/src/web3.rs
+++ b/crates/shared/src/web3.rs
@@ -58,6 +58,16 @@ impl Arguments {
     }
 }
 
+impl From<&configs::shared::EthRpcConfig> for Arguments {
+    fn from(config: &configs::shared::EthRpcConfig) -> Self {
+        Self {
+            ethrpc_max_batch_size: config.max_batch_size,
+            ethrpc_max_concurrent_requests: config.max_concurrent_requests,
+            ethrpc_batch_delay: config.batch_delay,
+        }
+    }
+}
+
 /// Create a Web3 instance with a label for observability.
 pub fn web3(args: &Arguments, url: &Url, name: impl ToString) -> Web3 {
     let label = name.to_string();
diff --git a/playground/autopilot.toml b/playground/autopilot.toml
new file mode 100644
index 0000000000..6566d9f5ac
--- /dev/null
+++ b/playground/autopilot.toml
@@ -0,0 +1,37 @@
+node-url = "http://chain:8545"
+simulation-node-url = "http://chain:8545"
+
+[logging]
+filter = "warn,autopilot=debug,shared=info,price_estimation=info"
+
+[current-block]
+poll-interval = "1s"
+
+[[gas-estimators]]
+type = "Web3"
+
+[[gas-estimators]]
+type = "Alloy"
+
+[[drivers]]
+name = "baseline"
+url = "http://driver/baseline"
+address = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720"
+
+[fee-policies]
+
+[database]
+write-url = "%DB_WRITE_URL"
+read-url = "%DB_READ_URL"
+
+[ethflow]
+skip-event-sync = true
+
+[native-price-estimation]
+estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
+
+[native-price-estimation.cache]
+max-age = "20m"
+
+[order-quoting]
+price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]
diff --git a/playground/configs/autopilot.toml b/playground/configs/autopilot.toml
index c243409570..edf6862265 100644
--- a/playground/configs/autopilot.toml
+++ b/playground/configs/autopilot.toml
@@ -1,3 +1,18 @@
+node-url = "http://chain:8545"
+simulation-node-url = "http://chain:8545"
+
+[logging]
+filter = "warn,autopilot=debug,shared=info,price_estimation=info"
+
+[current-block]
+poll-interval = "1s"
+
+[[gas-estimators]]
+type = "Web3"
+
+[[gas-estimators]]
+type = "Alloy"
+
 [[drivers]]
 name = "baseline"
 url = "http://driver/baseline"
@@ -10,3 +25,9 @@ price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline"
 
 [native-price-estimation]
 estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
+
+[native-price-estimation.cache]
+max-age = "20m"
+
+[order-quoting]
+price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]
diff --git a/playground/docker-compose.fork.yml b/playground/docker-compose.fork.yml
index 46ee4b596f..0820535e60 100644
--- a/playground/docker-compose.fork.yml
+++ b/playground/docker-compose.fork.yml
@@ -79,19 +79,10 @@ services:
         "run --bin orderbook -- --config playground/configs/orderbook.toml",
       ]
     environment:
-      - NODE_URL=http://chain:8545
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - SIMULATION_NODE_URL=http://chain:8545
-      - ENABLE_EIP1271_ORDERS=true
-      - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
-      - DRIVERS=baseline|http://driver/baseline
-      - BIND_ADDRESS=0.0.0.0:80
-      - CHAIN_ID=$CHAIN
       - RUST_BACKTRACE=1
       - TOML_TRACE_ERROR=1
-      - TRACING_COLLECTOR_ENDPOINT=http://tempo:4317
       - TOKIO_CONSOLE=true
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
@@ -120,18 +111,8 @@ services:
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - LOG_FILTER=warn,autopilot=debug,shared=info,price_estimation=info
-      - NODE_URL=http://chain:8545
-      - SIMULATION_NODE_URL=http://chain:8545
-      - GAS_ESTIMATORS=Web3,Alloy
-      - BLOCK_STREAM_POLL_INTERVAL=1s
-      - NATIVE_PRICE_CACHE_MAX_AGE=20m
-      - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - SKIP_EVENT_SYNC=true
       - RUST_BACKTRACE=1
       - TOML_TRACE_ERROR=1
-      - ETHFLOW_CONTRACTS
-      - ETHFLOW_INDEXING_START
       - TOKIO_CONSOLE=true
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
diff --git a/playground/docker-compose.non-interactive.yml b/playground/docker-compose.non-interactive.yml
index a6efd62a07..c0b1ea28e1 100644
--- a/playground/docker-compose.non-interactive.yml
+++ b/playground/docker-compose.non-interactive.yml
@@ -73,19 +73,10 @@ services:
     restart: always
     command: ["--config", "/orderbook.toml"]
     environment:
-      - NODE_URL=http://chain:8545
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - SIMULATION_NODE_URL=http://chain:8545
-      - ENABLE_EIP1271_ORDERS=true
-      - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - NATIVE_PRICE_ESTIMATORS=Driver|baseline|http://driver/baseline
-      - DRIVERS=baseline|http://driver/baseline
-      - BIND_ADDRESS=0.0.0.0:80
-      - CHAIN_ID=$CHAIN
       - RUST_BACKTRACE=0
       - TOML_TRACE_ERROR=1
-      - TRACING_COLLECTOR_ENDPOINT=http://tempo:4317
       - TOKIO_CONSOLE=true
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
@@ -109,18 +100,8 @@ services:
     environment:
       - DB_WRITE_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
       - DB_READ_URL=postgres://db:5432/?user=${POSTGRES_USER}&password=${POSTGRES_PASSWORD}
-      - LOG_FILTER=warn,autopilot=info,shared=info,price_estimation=info
-      - NODE_URL=http://chain:8545
-      - SIMULATION_NODE_URL=http://chain:8545
-      - GAS_ESTIMATORS=Web3,Alloy
-      - BLOCK_STREAM_POLL_INTERVAL=1s
-      - NATIVE_PRICE_CACHE_MAX_AGE=20m
-      - PRICE_ESTIMATION_DRIVERS=baseline|http://driver/baseline
-      - SKIP_EVENT_SYNC=true
       - RUST_BACKTRACE=1
       - TOML_TRACE_ERROR=1
-      - ETHFLOW_CONTRACTS
-      - ETHFLOW_INDEXING_START
       - TOKIO_CONSOLE=true
       - TOKIO_CONSOLE_RETENTION=600sec
       - TOKIO_CONSOLE_BIND=0.0.0.0:6669
diff --git a/playground/orderbook.toml b/playground/orderbook.toml
new file mode 100644
index 0000000000..f5b1a0e54a
--- /dev/null
+++ b/playground/orderbook.toml
@@ -0,0 +1,19 @@
+eip1271-skip-creation-validation = true
+bind-address = "0.0.0.0:80"
+
+[shared]
+node-url = "http://chain:8545"
+simulation-node-url = "http://chain:8545"
+
+[shared.tracing]
+collector-endpoint = "http://tempo:4317"
+
+[database]
+write-url = "%DB_WRITE_URL"
+read-url = "%DB_READ_URL"
+
+[native-price-estimation]
+estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseline" }]]
+
+[order-quoting]
+price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]

From 42b6778db3af32060c26eb3079cb4e0ecbc7bc44 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 19 Mar 2026 17:31:59 +0000
Subject: [PATCH 160/219] Add knob to configure gas ceiling for unverified
 quotes (#4277)

# Description

We have a situation where tsolver, our main solver for RWA tokens, has a
bug where they estimate extreme gas prices. We are introducing this knob
as a hack to set a ceiling before they fix this on their end.

# Changes

* [x] New config option to set a ceiling on gas for unverified quotes

## How to test

Unit tests.
---
 crates/autopilot/src/run.rs            |  1 +
 crates/configs/src/price_estimation.rs | 13 ++++
 crates/orderbook/src/run.rs            |  1 +
 crates/shared/src/order_quoting.rs     | 91 +++++++++++++++++++++-----
 4 files changed, 88 insertions(+), 18 deletions(-)

diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 8b36741f1c..3cd1fb5fd5 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -471,6 +471,7 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
         config.price_estimation.quote_verification,
         config.price_estimation.quote_timeout,
         config.price_estimation.min_gas_amount_for_unverified_quotes,
+        config.price_estimation.max_gas_amount_for_unverified_quotes,
     ));
 
     let solvable_orders_cache = SolvableOrdersCache::new(
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index e220ca3f8c..8c6fd6a302 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -90,6 +90,15 @@ pub struct PriceEstimation {
     #[serde(default)]
     pub min_gas_amount_for_unverified_quotes: u64,
 
+    /// Maximum gas amount for unverified quotes. When an unverified quote
+    /// reports more gas than this, the ceiling is used instead. Verified
+    /// quotes are unaffected. Defaults to 0 (disabled).
+    ///
+    /// This is a hack to alleviate tsolver issues where they report extremely
+    /// high gas for RWA tokens.
+    #[serde(default)]
+    pub max_gas_amount_for_unverified_quotes: u64,
+
     /// Tenderly configuration (URL, project & API key).
     pub tenderly: Option<TenderlyConfig>,
 
@@ -115,6 +124,7 @@ impl Default for PriceEstimation {
             tokens_without_verification: Default::default(),
             max_gas_per_tx: default_max_gas_per_tx(),
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         }
     }
 }
@@ -336,6 +346,7 @@ mod tests {
         assert_eq!(config.balance_overrides.cache_size, 1000);
         assert!(config.tokens_without_verification.is_empty());
         assert_eq!(config.min_gas_amount_for_unverified_quotes, 0);
+        assert_eq!(config.max_gas_amount_for_unverified_quotes, 0);
     }
 
     #[test]
@@ -347,6 +358,7 @@ mod tests {
         tokens-without-verification = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
         amount-to-estimate-prices-with = "1000000000000000000"
         min-gas-amount-for-unverified-quotes = 400000
+        max-gas-amount-for-unverified-quotes = 800000
 
         [price-estimation-rate-limiter]
         back-off-growth-factor = 2.0
@@ -409,6 +421,7 @@ mod tests {
         assert_eq!(config.balance_overrides.cache_size, 500);
         assert_eq!(config.tokens_without_verification.len(), 1);
         assert_eq!(config.min_gas_amount_for_unverified_quotes, 400_000);
+        assert_eq!(config.max_gas_amount_for_unverified_quotes, 800_000);
     }
 
     #[test]
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index b4ac88d89a..ec03de05f5 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -360,6 +360,7 @@ pub async fn run(config: Configuration) {
             verification,
             config.price_estimation.quote_timeout,
             config.price_estimation.min_gas_amount_for_unverified_quotes,
+            config.price_estimation.max_gas_amount_for_unverified_quotes,
         ))
     };
     let optimal_quoter = create_quoter(price_estimator, config.price_estimation.quote_verification);
diff --git a/crates/shared/src/order_quoting.rs b/crates/shared/src/order_quoting.rs
index 5fd780d856..5f2b392cf6 100644
--- a/crates/shared/src/order_quoting.rs
+++ b/crates/shared/src/order_quoting.rs
@@ -422,6 +422,7 @@ pub struct OrderQuoter {
     quote_verification: QuoteVerificationMode,
     default_quote_timeout: std::time::Duration,
     min_gas_amount_for_unverified_quotes: u64,
+    max_gas_amount_for_unverified_quotes: u64,
 }
 
 impl OrderQuoter {
@@ -436,7 +437,14 @@ impl OrderQuoter {
         quote_verification: QuoteVerificationMode,
         default_quote_timeout: std::time::Duration,
         min_gas_amount_for_unverified_quotes: u64,
+        max_gas_amount_for_unverified_quotes: u64,
     ) -> Self {
+        assert!(
+            max_gas_amount_for_unverified_quotes == 0
+                || (min_gas_amount_for_unverified_quotes <= max_gas_amount_for_unverified_quotes),
+            "gas floor ({min_gas_amount_for_unverified_quotes}) exceeds gas ceiling \
+             ({max_gas_amount_for_unverified_quotes}) for unverified quotes"
+        );
         Self {
             price_estimator,
             native_price_estimator,
@@ -448,9 +456,25 @@ impl OrderQuoter {
             quote_verification,
             default_quote_timeout,
             min_gas_amount_for_unverified_quotes,
+            max_gas_amount_for_unverified_quotes,
         }
     }
 
+    fn clamp_gas_for_unverified_quote(&self, gas: u64, verified: bool) -> u64 {
+        if verified {
+            return gas;
+        }
+        let min = self.min_gas_amount_for_unverified_quotes;
+        let max = self.max_gas_amount_for_unverified_quotes;
+        let lower = if min > 0 { min } else { u64::MIN };
+        let upper = if max > 0 { max } else { u64::MAX };
+        let clamped = gas.clamp(lower, upper);
+        if clamped != gas {
+            tracing::debug!(gas, clamped, min, max, "clamped gas for unverified quote");
+        }
+        clamped
+    }
+
     async fn compute_quote_data(
         &self,
         parameters: &QuoteParameters,
@@ -499,19 +523,8 @@ impl OrderQuoter {
                 buy_amount_after_fee: buy_amount,
             } => (trade_estimate.out_amount, buy_amount.get()),
         };
-        let gas_amount = if !trade_estimate.verified
-            && self.min_gas_amount_for_unverified_quotes > 0
-            && trade_estimate.gas < self.min_gas_amount_for_unverified_quotes
-        {
-            tracing::debug!(
-                original_gas = trade_estimate.gas,
-                floor = self.min_gas_amount_for_unverified_quotes,
-                "applying minimum gas floor to unverified quote"
-            );
-            self.min_gas_amount_for_unverified_quotes
-        } else {
-            trade_estimate.gas
-        };
+        let gas_amount =
+            self.clamp_gas_for_unverified_quote(trade_estimate.gas, trade_estimate.verified);
         let fee_parameters = FeeParameters {
             gas_amount: gas_amount as _,
             gas_price: effective_gas_price as f64,
@@ -956,6 +969,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1097,6 +1111,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1233,6 +1248,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1332,6 +1348,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1406,6 +1423,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1468,6 +1486,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1552,6 +1571,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1638,6 +1658,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1712,6 +1733,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1744,6 +1766,7 @@ mod tests {
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             min_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1809,7 +1832,7 @@ mod tests {
             native
         };
 
-        let quoter = |verified: bool, min_gas_floor: u64| {
+        let quoter = |verified: bool, min_gas: u64, max_gas: u64| {
             let mut storage = MockQuoteStoring::new();
             storage.expect_save().returning(|_| Ok(1));
             OrderQuoter {
@@ -1822,27 +1845,59 @@ mod tests {
                 quote_verification: QuoteVerificationMode::Unverified,
                 balance_fetcher: mock_balance_fetcher(),
                 default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-                min_gas_amount_for_unverified_quotes: min_gas_floor,
+                min_gas_amount_for_unverified_quotes: min_gas,
+                max_gas_amount_for_unverified_quotes: max_gas,
             }
         };
 
         // Unverified quote with floor > gas: floor should apply.
-        let quote = quoter(false, 500_000)
+        let quote = quoter(false, 500_000, 0)
             .calculate_quote(parameters.clone())
             .await
             .unwrap();
         assert_eq!(quote.data.fee_parameters.gas_amount, 500_000.);
 
         // Verified quote with floor > gas: floor should NOT apply.
-        let quote = quoter(true, 500_000)
+        let quote = quoter(true, 500_000, 0)
             .calculate_quote(parameters.clone())
             .await
             .unwrap();
         assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
 
         // Unverified quote with floor = 0: no floor applied.
-        let quote = quoter(false, 0).calculate_quote(parameters).await.unwrap();
+        let quote = quoter(false, 0, 0)
+            .calculate_quote(parameters.clone())
+            .await
+            .unwrap();
         assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
+
+        // Unverified quote with ceiling < gas: ceiling should apply.
+        let quote = quoter(false, 0, 50_000)
+            .calculate_quote(parameters.clone())
+            .await
+            .unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 50_000.);
+
+        // Verified quote with ceiling < gas: ceiling should NOT apply.
+        let quote = quoter(true, 0, 50_000)
+            .calculate_quote(parameters.clone())
+            .await
+            .unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
+
+        // Unverified quote with ceiling = 0: no ceiling applied.
+        let quote = quoter(false, 0, 0)
+            .calculate_quote(parameters.clone())
+            .await
+            .unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
+
+        // Both floor and ceiling set: gas gets clamped to range.
+        let quote = quoter(false, 200_000, 300_000)
+            .calculate_quote(parameters)
+            .await
+            .unwrap();
+        assert_eq!(quote.data.fee_parameters.gas_amount, 200_000.);
     }
 
     #[test]

From e6d3d0bc2ad075ac4b2726ab5af7dc3c104d4a91 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Fri, 20 Mar 2026 08:21:57 +0100
Subject: [PATCH 161/219] Simulator crate (#4265)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Transaction simulation machinery is spread throughout our codebase. Due
to how domain-specific and tied to internal types (driver,
price-estimation) they are, it's hard to reuse it for new purposes, such
as simulation endpoint or full transaction gas simulation for solvers.

# Changes
Introduces `simulator` crate which contains all tools related to
simulating a real or fake settlement:
- `Simulator` struct as previously was found in `driver`
- `SwapSimulator` struct which helps to construct fake settlements
- Tenderly API collected and unified into `simulator` crate.

## How to test
- E2E test
- Manual staging deployment for testing.

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
---
 Cargo.lock                                    |  50 ++
 Cargo.toml                                    |   1 +
 LICENSE-APACHE                                |   0
 LICENSE-GPL                                   |   0
 LICENSE-MIT                                   |   0
 crates/autopilot/Cargo.toml                   |   1 +
 crates/configs/src/gas_price_estimation.rs    |  15 +
 crates/configs/src/lib.rs                     |   2 +
 crates/configs/src/price_estimation.rs        |  44 +-
 crates/configs/src/simulator.rs               | 155 ++++++
 crates/driver/Cargo.toml                      |   1 +
 crates/driver/src/domain/competition/mod.rs   |  14 +-
 .../src/domain/competition/solution/mod.rs    |   3 +-
 .../domain/competition/solution/settlement.rs |   3 +-
 crates/driver/src/infra/api/mod.rs            |   2 +-
 crates/driver/src/infra/blockchain/gas.rs     |   6 +-
 crates/driver/src/infra/blockchain/mod.rs     |  85 +--
 crates/driver/src/infra/config/file/load.rs   |  21 +-
 crates/driver/src/infra/config/file/mod.rs    |  49 +-
 crates/driver/src/infra/config/mod.rs         |   4 +-
 crates/driver/src/infra/mod.rs                |  10 +-
 crates/driver/src/infra/notify/mod.rs         |   2 +-
 crates/driver/src/infra/observe/mod.rs        |   2 +-
 .../src/infra/simulator/tenderly/dto.rs       |  80 ---
 .../src/infra/simulator/tenderly/mod.rs       | 141 -----
 crates/driver/src/run.rs                      |  72 +--
 crates/driver/src/tests/setup/solver.rs       |   1 -
 crates/e2e/Cargo.toml                         |   1 +
 crates/e2e/tests/e2e/quote_verification.rs    |  19 +-
 crates/gas-price-estimation/Cargo.toml        |   1 +
 .../src/configurable_alloy.rs                 |  17 +-
 crates/gas-price-estimation/src/lib.rs        |  12 +-
 crates/price-estimation/Cargo.toml            |   1 +
 .../src/config/price_estimation.rs            |  24 +-
 crates/price-estimation/src/factory.rs        |  40 +-
 .../price-estimation/src/trade_finding/mod.rs |  24 +-
 .../src/trade_verifier/mod.rs                 | 524 ++++++------------
 .../src/trade_verifier/tenderly_api.rs        | 464 ----------------
 crates/price-estimation/src/utils/encoding.rs |  88 ---
 crates/shared/src/encoded_settlement.rs       | 218 --------
 crates/shared/src/lib.rs                      |   1 -
 crates/simulator/Cargo.toml                   |  52 ++
 crates/simulator/src/encoding.rs              | 232 ++++++++
 .../simulator => simulator/src}/enso/dto.rs   |   2 +-
 .../simulator => simulator/src}/enso/mod.rs   |  16 +-
 crates/simulator/src/ethereum/contracts.rs    |  33 ++
 crates/simulator/src/ethereum/mod.rs          | 159 ++++++
 .../simulator/mod.rs => simulator/src/lib.rs} |  78 +--
 crates/simulator/src/swap_simulator.rs        | 259 +++++++++
 crates/simulator/src/tenderly/dto.rs          | 180 ++++++
 crates/simulator/src/tenderly/mod.rs          | 323 +++++++++++
 crates/simulator/src/utils/mod.rs             |  14 +
 crates/solver/Cargo.toml                      |   1 +
 crates/solver/src/liquidity/balancer_v2.rs    |   3 +-
 crates/solver/src/liquidity/zeroex.rs         |   3 +-
 crates/solver/src/settlement/mod.rs           |   6 +-
 .../src/settlement/settlement_encoder.rs      |  31 +-
 57 files changed, 1877 insertions(+), 1713 deletions(-)
 mode change 100644 => 100755 LICENSE-APACHE
 mode change 100644 => 100755 LICENSE-GPL
 mode change 100644 => 100755 LICENSE-MIT
 create mode 100644 crates/configs/src/gas_price_estimation.rs
 create mode 100644 crates/configs/src/simulator.rs
 delete mode 100644 crates/driver/src/infra/simulator/tenderly/dto.rs
 delete mode 100644 crates/driver/src/infra/simulator/tenderly/mod.rs
 delete mode 100644 crates/price-estimation/src/trade_verifier/tenderly_api.rs
 delete mode 100644 crates/shared/src/encoded_settlement.rs
 create mode 100644 crates/simulator/Cargo.toml
 create mode 100644 crates/simulator/src/encoding.rs
 rename crates/{driver/src/infra/simulator => simulator/src}/enso/dto.rs (96%)
 rename crates/{driver/src/infra/simulator => simulator/src}/enso/mod.rs (89%)
 create mode 100644 crates/simulator/src/ethereum/contracts.rs
 create mode 100644 crates/simulator/src/ethereum/mod.rs
 rename crates/{driver/src/infra/simulator/mod.rs => simulator/src/lib.rs} (78%)
 create mode 100644 crates/simulator/src/swap_simulator.rs
 create mode 100644 crates/simulator/src/tenderly/dto.rs
 create mode 100644 crates/simulator/src/tenderly/mod.rs
 create mode 100644 crates/simulator/src/utils/mod.rs

diff --git a/Cargo.lock b/Cargo.lock
index 4aea6ce68a..7c92615f7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1254,6 +1254,7 @@ dependencies = [
  "serde_json",
  "serde_with",
  "shared",
+ "simulator",
  "sqlx",
  "strum",
  "tempfile",
@@ -3017,6 +3018,7 @@ dependencies = [
  "serde_with",
  "shared",
  "signature-validator",
+ "simulator",
  "solver",
  "solvers-dto",
  "tempfile",
@@ -3082,6 +3084,7 @@ dependencies = [
  "serde_json",
  "shared",
  "signature-validator",
+ "simulator",
  "solver",
  "solvers",
  "solvers-dto",
@@ -3555,6 +3558,7 @@ dependencies = [
  "alloy-provider",
  "anyhow",
  "async-trait",
+ "configs",
  "ethrpc",
  "futures",
  "mockall",
@@ -5491,6 +5495,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_with",
+ "simulator",
  "testlib",
  "thiserror 1.0.69",
  "token-info",
@@ -6896,6 +6901,50 @@ version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
+[[package]]
+name = "simulator"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types",
+ "alloy-sol-types",
+ "alloy-transport",
+ "anyhow",
+ "app-data",
+ "async-trait",
+ "balance-overrides",
+ "cached",
+ "chain",
+ "configs",
+ "const-hex",
+ "contracts",
+ "derive_more 1.0.0",
+ "eth-domain-types",
+ "ethrpc",
+ "gas-price-estimation",
+ "hex-literal",
+ "http-client",
+ "mockall",
+ "model",
+ "number",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "reqwest 0.13.2",
+ "serde",
+ "serde-ext",
+ "serde_json",
+ "serde_with",
+ "testlib",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.11"
@@ -6956,6 +7005,7 @@ dependencies = [
  "prometheus-metric-storage",
  "serde_json",
  "shared",
+ "simulator",
  "strum",
  "testlib",
  "tokio",
diff --git a/Cargo.toml b/Cargo.toml
index 29c18c43bf..9c31ae436b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -115,6 +115,7 @@ serde_with = "3.8.1"
 sha2 = "0.10"
 shared = { path = "crates/shared" }
 signature-validator = { path = "crates/signature-validator" }
+simulator = { path = "crates/simulator" }
 solver = { path = "crates/solver" }
 solvers = { path = "crates/solvers" }
 solvers-dto = { path = "crates/solvers-dto" }
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
old mode 100644
new mode 100755
diff --git a/LICENSE-GPL b/LICENSE-GPL
old mode 100644
new mode 100755
diff --git a/LICENSE-MIT b/LICENSE-MIT
old mode 100644
new mode 100755
diff --git a/crates/autopilot/Cargo.toml b/crates/autopilot/Cargo.toml
index 7dcd7080b6..528d23b3e0 100644
--- a/crates/autopilot/Cargo.toml
+++ b/crates/autopilot/Cargo.toml
@@ -64,6 +64,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 shared = { workspace = true }
+simulator = { workspace = true }
 sqlx = { workspace = true }
 strum = { workspace = true }
 tempfile = { workspace = true, optional = true }
diff --git a/crates/configs/src/gas_price_estimation.rs b/crates/configs/src/gas_price_estimation.rs
new file mode 100644
index 0000000000..ed5f4dc931
--- /dev/null
+++ b/crates/configs/src/gas_price_estimation.rs
@@ -0,0 +1,15 @@
+#[derive(Debug, Clone, Copy)]
+pub struct EstimatorConfig {
+    /// Number of blocks to look back for fee history
+    pub past_blocks: u64,
+    /// Percentile of rewards to use for priority fee estimation
+    pub reward_percentile: f64,
+}
+
+pub fn default_past_blocks() -> u64 {
+    10
+}
+
+pub fn default_reward_percentile() -> f64 {
+    20.0
+}
diff --git a/crates/configs/src/lib.rs b/crates/configs/src/lib.rs
index 21b6c07d1e..3dd21d4cc0 100644
--- a/crates/configs/src/lib.rs
+++ b/crates/configs/src/lib.rs
@@ -4,6 +4,7 @@ pub mod banned_users;
 pub mod database;
 pub(crate) mod deserialize_env;
 pub mod fee_factor;
+pub mod gas_price_estimation;
 pub mod http_client;
 pub mod native_price;
 pub mod native_price_estimators;
@@ -12,6 +13,7 @@ pub mod orderbook;
 pub mod price_estimation;
 pub mod rate_limit;
 pub mod shared;
+pub mod simulator;
 
 #[cfg(any(test, feature = "test-util"))]
 pub mod test_util {
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index 8c6fd6a302..c607471805 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -100,7 +100,8 @@ pub struct PriceEstimation {
     pub max_gas_amount_for_unverified_quotes: u64,
 
     /// Tenderly configuration (URL, project & API key).
-    pub tenderly: Option<TenderlyConfig>,
+    #[serde(default)]
+    pub tenderly: Option<crate::simulator::TenderlyConfig>,
 
     /// The CoinGecko native price configuration.
     pub coin_gecko: Option<CoinGeckoConfig>,
@@ -143,45 +144,6 @@ impl crate::test_util::TestDefault for PriceEstimation {
     }
 }
 
-#[derive(Deserialize)]
-#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct TenderlyConfig {
-    /// The Tenderly user associated with the API key.
-    #[serde(default)]
-    pub user: String,
-
-    /// The Tenderly project associated with the API key.
-    #[serde(default)]
-    pub project: String,
-
-    /// Tenderly requires an API key to work. Optional since Tenderly could be
-    /// skipped in access lists estimators.
-    #[serde(default)]
-    pub api_key: String,
-}
-
-impl std::fmt::Debug for TenderlyConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TenderlyConfig")
-            .field("user", &self.user)
-            .field("project", &self.project)
-            .field("api_key", &"<REDACTED>")
-            .finish()
-    }
-}
-
-#[cfg(any(test, feature = "test-util"))]
-impl crate::test_util::TestDefault for TenderlyConfig {
-    fn test_default() -> Self {
-        Self {
-            user: "test-user".to_string(),
-            project: "test-project".to_string(),
-            api_key: "test-api-key".to_string(),
-        }
-    }
-}
-
 fn default_coin_gecko_url() -> Url {
     Url::from_str("https://api.coingecko.com/api/v3/simple/token_price")
         .expect("url should be valid")
@@ -451,7 +413,7 @@ mod tests {
                 api_key: "secret".to_string(),
                 ..TestDefault::test_default()
             }),
-            tenderly: Some(TenderlyConfig {
+            tenderly: Some(crate::simulator::TenderlyConfig {
                 api_key: "secret".to_string(),
                 ..TestDefault::test_default()
             }),
diff --git a/crates/configs/src/simulator.rs b/crates/configs/src/simulator.rs
new file mode 100644
index 0000000000..579654457a
--- /dev/null
+++ b/crates/configs/src/simulator.rs
@@ -0,0 +1,155 @@
+use {
+    crate::gas_price_estimation::{default_past_blocks, default_reward_percentile},
+    alloy::primitives::Address,
+    serde::{Deserialize, Serialize},
+    std::time::Duration,
+    url::Url,
+};
+
+#[derive(Debug, Default, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Config {
+    /// Maximum batch size for Ethereum RPC requests. Use '0' to disable
+    /// batching.
+    #[serde(default = "default_ethrpc_max_batch_size")]
+    pub ethrpc_max_batch_size: usize,
+
+    /// Maximum number of concurrent requests to send to the node. Use '0' for
+    /// no limit on concurrency.
+    #[serde(default = "default_ethrpc_max_concurrent_requests")]
+    pub ethrpc_max_concurrent_requests: usize,
+
+    /// Buffering "nagle" delay to wait for additional requests before sending
+    /// out an incomplete batch.
+    // #[clap(long, env, value_parser = humantime::parse_duration, default_value = "0s")]
+    #[serde(with = "humantime_serde", default = "default_ethrpc_batch_delay")]
+    pub ethrpc_batch_delay: Duration,
+
+    /// Kind of simulator that should be used. Can be either of
+    /// - ethereum
+    /// - tenderly (using TenderlyConfig)
+    /// - enso (using EnsoConfig)
+    pub kind: SimulatorKind,
+}
+
+fn default_ethrpc_batch_delay() -> Duration {
+    Duration::from_secs(0)
+}
+fn default_ethrpc_max_batch_size() -> usize {
+    100
+}
+fn default_ethrpc_max_concurrent_requests() -> usize {
+    10
+}
+
+#[derive(Debug, Default, Clone, Deserialize, Serialize)]
+pub enum SimulatorKind {
+    #[default]
+    Ethereum,
+    Tenderly(TenderlyConfig),
+    Enso(EnsoConfig),
+}
+
+/// Tenderly API arguments.
+#[derive(Default, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct TenderlyConfig {
+    /// The Tenderly user associated with the API key.
+    #[serde(default)]
+    pub user: String,
+
+    /// The Tenderly project associated with the API key.
+    #[serde(default)]
+    pub project: String,
+
+    /// Tenderly requires api key to work. Optional since Tenderly could be
+    /// skipped in access lists estimators.
+    #[serde(default)]
+    pub api_key: String,
+
+    /// The URL of the Tenderly API.
+    #[serde(default)]
+    pub url: Option<Url>,
+
+    /// The URL of the Tenderly dashboard
+    #[serde(default)]
+    pub dashboard: Option<Url>,
+
+    /// Save the transaction on Tenderly for later inspection, e.g. via the
+    /// dashboard.
+    #[serde(default)]
+    pub save: bool,
+
+    /// Save the transaction even in the case of failure.
+    #[serde(default)]
+    pub save_if_fails: bool,
+}
+
+impl std::fmt::Debug for TenderlyConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TenderlyConfig")
+            .field("user", &self.user)
+            .field("project", &self.project)
+            .field("api_key", &"<REDACTED>")
+            .field("url", &self.url)
+            .field("dashboard", &self.dashboard)
+            .field("save", &self.save)
+            .field("save_if_fails", &self.save_if_fails)
+            .finish()
+    }
+}
+
+#[cfg(any(test, feature = "test-util"))]
+impl crate::test_util::TestDefault for TenderlyConfig {
+    fn test_default() -> Self {
+        Self {
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct EnsoConfig {
+    /// The URL of the Transaction Simulator API.
+    pub url: Url,
+
+    /// The time between new blocks in the network.
+    #[serde(default)]
+    pub network_block_interval: Option<Duration>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields, tag = "estimator")]
+pub enum GasEstimatorType {
+    Web3,
+    /// EIP-1559 gas estimator using alloy's algorithm.
+    /// Optionally configure the fee history query parameters.
+    #[serde(rename_all = "kebab-case")]
+    Alloy {
+        /// Number of blocks to look back for fee history (default: 10)
+        #[serde(default = "default_past_blocks")]
+        past_blocks: u64,
+        /// Percentile of rewards to use for priority fee estimation (default:
+        /// 20.0). This is what Metamask uses as medium priority:
+        /// https://github.com/MetaMask/core/blob/0fd4b397e7237f104d1c81579a0c4321624d076b/packages/gas-fee-controller/src/fetchGasEstimatesViaEthFeeHistory/calculateGasFeeEstimatesForPriorityLevels.ts#L14-L45
+        #[serde(default = "default_reward_percentile")]
+        reward_percentile: f64,
+    },
+}
+
+impl Default for GasEstimatorType {
+    fn default() -> Self {
+        Self::Alloy {
+            past_blocks: default_past_blocks(),
+            reward_percentile: default_reward_percentile(),
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Addresses {
+    pub settlement: Option<Address>,
+    pub weth: Option<Address>,
+}
diff --git a/crates/driver/Cargo.toml b/crates/driver/Cargo.toml
index cd5f884b8c..470395b1c2 100644
--- a/crates/driver/Cargo.toml
+++ b/crates/driver/Cargo.toml
@@ -65,6 +65,7 @@ serde = { workspace = true, features = ["derive"] }
 serde-ext = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
+simulator = { workspace = true }
 solvers-dto = { path = "../solvers-dto" }
 thiserror = { workspace = true }
 tikv-jemallocator = { workspace = true }
diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 9127316f98..2eddc4f91a 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -12,11 +12,9 @@ use {
         },
         infra::{
             self,
-            Simulator,
             blockchain::Ethereum,
             notify,
             observe::{self, metrics},
-            simulator::{RevertError, SimulatorError},
             solver::{self, Account, SolutionMerging, Solver},
         },
         util::math,
@@ -27,6 +25,7 @@ use {
     eth_domain_types as eth,
     futures::{FutureExt, StreamExt, future::Either, stream::FuturesUnordered},
     itertools::Itertools,
+    simulator::{RevertError, Simulator, SimulatorError},
     std::{
         cmp::Reverse,
         collections::{HashMap, HashSet, VecDeque},
@@ -549,7 +548,7 @@ impl Competition {
                 let mut stream =
                     ethrpc::block_stream::into_stream(self.eth.current_block().clone());
                 while let Some(block) = stream.next().await {
-                    if let Err(infra::simulator::Error::Revert(err)) =
+                    if let Err(simulator::Error::Revert(err)) =
                         self.simulate_settlement(&settlement).await
                     {
                         observe::winner_voided(self.solver.name(), block, &err, has_haircut);
@@ -564,7 +563,7 @@ impl Competition {
                                 &self.solver,
                                 auction.id(),
                                 settlement.solution(),
-                                &infra::simulator::Error::Revert(err),
+                                &simulator::Error::Revert(err),
                                 true,
                             );
                         }
@@ -935,14 +934,11 @@ impl Competition {
     }
 
     /// Returns whether the settlement can be executed or would revert.
-    async fn simulate_settlement(
-        &self,
-        settlement: &Settlement,
-    ) -> Result<(), infra::simulator::Error> {
+    async fn simulate_settlement(&self, settlement: &Settlement) -> Result<(), simulator::Error> {
         let tx = settlement.transaction(settlement::Internalization::Enable);
         let gas_needed_for_tx = self.simulator.gas(tx).await?;
         if gas_needed_for_tx > settlement.gas.limit {
-            return Err(infra::simulator::Error::Revert(RevertError {
+            return Err(simulator::Error::Revert(RevertError {
                 err: SimulatorError::GasExceeded(gas_needed_for_tx, settlement.gas.limit),
                 tx: tx.clone(),
                 block: self.eth.current_block().borrow().number.into(),
diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index a83ae5fe55..2a668954e4 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -8,10 +8,8 @@ use {
             competition::{self, order},
         },
         infra::{
-            Simulator,
             blockchain::{self, Ethereum},
             config::file::FeeHandler,
-            simulator,
             solver::{ManageNativeToken, Solver},
         },
     },
@@ -22,6 +20,7 @@ use {
     itertools::Itertools,
     num::{BigRational, One},
     number::conversions::{big_rational_to_u256, u256_to_big_int, u256_to_big_rational},
+    simulator::{self, Simulator},
     solvers_dto::solution::Flashloan,
     std::{
         collections::{BTreeSet, HashMap, HashSet, hash_map::Entry},
diff --git a/crates/driver/src/domain/competition/solution/settlement.rs b/crates/driver/src/domain/competition/solution/settlement.rs
index bbc99d4f62..20f3a245ff 100644
--- a/crates/driver/src/domain/competition/solution/settlement.rs
+++ b/crates/driver/src/domain/competition/solution/settlement.rs
@@ -10,11 +10,12 @@ use {
                 solution::{self, Interaction, Trade, error},
             },
         },
-        infra::{Simulator, blockchain::Ethereum, observe, solver::ManageNativeToken},
+        infra::{blockchain::Ethereum, observe, solver::ManageNativeToken},
     },
     alloy::primitives::U256,
     eth_domain_types as eth,
     futures::future::try_join_all,
+    simulator::Simulator,
     std::collections::{BTreeSet, HashMap, HashSet},
     tracing::instrument,
 };
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index eda13eb057..45ec0dde24 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -12,7 +12,6 @@ use {
         infra::{
             self,
             Ethereum,
-            Simulator,
             config::file::OrderPriorityStrategy,
             liquidity,
             notify,
@@ -23,6 +22,7 @@ use {
     error::Error,
     futures::Future,
     observe::tracing::distributed::axum::{make_span, record_trace_id},
+    simulator::Simulator,
     std::{net::SocketAddr, sync::Arc},
     tokio::sync::oneshot,
 };
diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index 27759ae1e0..7dfd775aa0 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -11,7 +11,7 @@ use {
     ethrpc::Web3,
     gas_price_estimation::{
         GasPriceEstimating,
-        configurable_alloy::{ConfigurableGasPriceEstimator, EstimatorConfig},
+        configurable_alloy::ConfigurableGasPriceEstimator,
         eth_node::NodeGasPriceEstimator,
     },
     std::sync::Arc,
@@ -22,7 +22,7 @@ type AdditionalTipPercentage = f64;
 type AdditionalTip = (MaxAdditionalTip, AdditionalTipPercentage);
 
 pub struct GasPriceEstimator {
-    gas: Arc<dyn GasPriceEstimating>,
+    pub(super) gas: Arc<dyn GasPriceEstimating>,
     additional_tip: AdditionalTip,
     max_fee_per_gas: eth::U256,
     min_priority_fee: eth::U256,
@@ -41,7 +41,7 @@ impl GasPriceEstimator {
                 reward_percentile,
             } => Arc::new(ConfigurableGasPriceEstimator::new(
                 web3.provider.clone(),
-                EstimatorConfig {
+                configs::gas_price_estimation::EstimatorConfig {
                     past_blocks: *past_blocks,
                     reward_percentile: *reward_percentile,
                 },
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index 9bdc9b9803..a03bd51630 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -8,12 +8,11 @@ use {
         rpc::types::{TransactionReceipt, TransactionRequest},
         transports::TransportErrorKind,
     },
-    anyhow::anyhow,
     balance_overrides::{BalanceOverrides, BalanceOverriding},
     chain::Chain,
-    eth_domain_types::{self as eth, U256},
+    eth_domain_types as eth,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
-    gas_price_estimation::Eip1559EstimationExt,
+    gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
     shared::web3,
     std::{fmt, sync::Arc},
     thiserror::Error,
@@ -27,12 +26,14 @@ pub mod token;
 pub use self::{contracts::Contracts, gas::GasPriceEstimator};
 
 /// An Ethereum RPC connection.
+#[derive(Clone)]
 pub struct Rpc {
     web3: Web3,
     chain: Chain,
     args: RpcArgs,
 }
 
+#[derive(Clone)]
 pub struct RpcArgs {
     pub url: Url,
     pub max_batch_size: usize,
@@ -90,7 +91,6 @@ struct Inner {
     current_block: CurrentBlockWatcher,
     balance_simulator: BalanceSimulator,
     balance_overrider: Arc<dyn BalanceOverriding>,
-    tx_gas_limit: U256,
 }
 
 impl Ethereum {
@@ -104,11 +104,9 @@ impl Ethereum {
         rpc: Rpc,
         addresses: contracts::Addresses,
         gas: Arc<GasPriceEstimator>,
-        tx_gas_limit: U256,
         current_block_args: &shared::current_block::Arguments,
     ) -> Self {
         let Rpc { web3, chain, args } = rpc;
-
         let current_block_stream = current_block_args
             .stream(args.url.clone(), web3.provider.clone())
             .await
@@ -134,7 +132,6 @@ impl Ethereum {
                 gas,
                 balance_simulator,
                 balance_overrider,
-                tx_gas_limit,
             }),
             web3,
         }
@@ -178,30 +175,34 @@ impl Ethereum {
         &self.inner.current_block
     }
 
-    /// Create access list used by a transaction.
-    #[instrument(skip_all)]
-    pub async fn create_access_list<T>(&self, tx: T) -> Result<eth::AccessList, Error>
-    where
-        T: Into<TransactionRequest>,
-    {
-        let tx = tx.into();
-
-        let gas_limit = self.inner.tx_gas_limit.try_into().map_err(|err| {
-            Error::GasPrice(anyhow!("failed to convert gas_limit to u64: {err:?}"))
-        })?;
-        let tx = tx.with_gas_limit(gas_limit);
-        let tx = match self.simulation_gas_price().await {
-            Some(gas_price) => tx.with_gas_price(gas_price),
-            _ => tx,
-        };
+    /// The gas price is determined based on the deadline by which the
+    /// transaction must be included on-chain. A shorter deadline requires a
+    /// higher gas price to increase the likelihood of timely inclusion.
+    pub async fn gas_price(&self) -> Result<Eip1559Estimation, Error> {
+        self.inner.gas.estimate().await
+    }
 
-        let access_list = self.web3.provider.create_access_list(&tx).pending().await?;
+    pub fn gas_estimator(&self) -> Arc<dyn GasPriceEstimating> {
+        Arc::clone(&self.inner.gas.gas)
+    }
 
-        Ok(access_list
-            .ensure_ok()
-            .map_err(Error::AccessList)?
-            .access_list
-            .into())
+    pub fn block_gas_limit(&self) -> eth::Gas {
+        self.inner.current_block.borrow().gas_limit.into()
+    }
+
+    /// Returns the current [`eth::Ether`] balance of the specified account.
+    pub async fn balance(&self, address: eth::Address) -> Result<eth::Ether, Error> {
+        self.web3
+            .provider
+            .get_balance(address)
+            .await
+            .map(Into::into)
+            .map_err(Into::into)
+    }
+
+    /// Returns a [`token::Erc20`] for the specified address.
+    pub fn erc20(&self, address: eth::TokenAddress) -> token::Erc20 {
+        token::Erc20::new(self, address)
     }
 
     /// Estimate gas used by a transaction.
@@ -230,32 +231,6 @@ impl Ethereum {
         Ok(estimated_gas)
     }
 
-    /// The gas price is determined based on the deadline by which the
-    /// transaction must be included on-chain. A shorter deadline requires a
-    /// higher gas price to increase the likelihood of timely inclusion.
-    pub async fn gas_price(&self) -> Result<Eip1559Estimation, Error> {
-        self.inner.gas.estimate().await
-    }
-
-    pub fn block_gas_limit(&self) -> eth::Gas {
-        self.inner.current_block.borrow().gas_limit.into()
-    }
-
-    /// Returns the current [`eth::Ether`] balance of the specified account.
-    pub async fn balance(&self, address: eth::Address) -> Result<eth::Ether, Error> {
-        self.web3
-            .provider
-            .get_balance(address)
-            .await
-            .map(Into::into)
-            .map_err(Into::into)
-    }
-
-    /// Returns a [`token::Erc20`] for the specified address.
-    pub fn erc20(&self, address: eth::TokenAddress) -> token::Erc20 {
-        token::Erc20::new(self, address)
-    }
-
     /// Returns the transaction's on-chain inclusion status.
     pub async fn transaction_status(&self, tx_hash: &eth::TxId) -> Result<TxStatus, Error> {
         self.web3
diff --git a/crates/driver/src/infra/config/file/load.rs b/crates/driver/src/infra/config/file/load.rs
index cf4534f4d9..e8b053f12d 100644
--- a/crates/driver/src/infra/config/file/load.rs
+++ b/crates/driver/src/infra/config/file/load.rs
@@ -8,7 +8,6 @@ use {
             liquidity,
             mempool,
             notify,
-            simulator,
             solver::{self, Account, BadOrderDetection, SolutionMerging},
         },
     },
@@ -344,24 +343,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                 additional_tip_percentage: mempool.additional_tip_percentage,
             })
             .collect(),
-        simulator: match (config.tenderly, config.enso) {
-            (Some(config), None) => {
-                Some(simulator::Config::Tenderly(simulator::tenderly::Config {
-                    url: config.url,
-                    api_key: config.api_key,
-                    user: config.user,
-                    project: config.project,
-                    save: config.save,
-                    save_if_fails: config.save_if_fails,
-                }))
-            }
-            (None, Some(config)) => Some(simulator::Config::Enso(simulator::enso::Config {
-                url: config.url,
-                network_block_interval: config.network_block_interval,
-            })),
-            (None, None) => None,
-            (Some(_), Some(_)) => panic!("Cannot configure both Tenderly and Enso"),
-        },
+        simulator: config.simulator,
         contracts: blockchain::contracts::Addresses {
             settlement: config.contracts.gp_v2_settlement.map(Into::into),
             weth: config.contracts.weth.map(Into::into),
@@ -382,6 +364,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
         simulation_bad_token_max_age: config.simulation_bad_token_max_age,
         app_data_fetching: config.app_data_fetching,
         tx_gas_limit: config.tx_gas_limit,
+        http: config.http,
     }
 }
 
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index 3b0da7cec4..d4e689cb69 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -2,8 +2,8 @@ pub use load::load;
 use {
     crate::infra,
     alloy::{eips::BlockNumberOrTag, primitives::Address},
+    configs::gas_price_estimation::{default_past_blocks, default_reward_percentile},
     eth_domain_types as eth,
-    gas_price_estimation::configurable_alloy::{default_past_blocks, default_reward_percentile},
     number::serialization::HexOrDecimalU256,
     reqwest::Url,
     serde::{Deserialize, Deserializer, Serialize},
@@ -47,12 +47,6 @@ struct Config {
     #[serde(default)]
     contracts: ContractsConfig,
 
-    /// Use Tenderly for transaction simulation.
-    tenderly: Option<TenderlyConfig>,
-
-    /// Use Enso for transaction simulation.
-    enso: Option<EnsoConfig>,
-
     /// Liquidity sources notifier configuration.
     liquidity_sources_notifier: Option<LiquiditySourcesNotifier>,
 
@@ -88,6 +82,13 @@ struct Config {
 
     #[serde_as(as = "HexOrDecimalU256")]
     tx_gas_limit: eth::U256,
+
+    #[serde(default)]
+    simulator: configs::simulator::Config,
+
+    /// Http client factory config
+    #[serde(default)]
+    http: configs::http_client::HttpClient,
 }
 
 #[serde_as]
@@ -422,40 +423,6 @@ pub struct CowAmmConfig {
     pub helper: eth::Address,
 }
 
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-struct TenderlyConfig {
-    /// Optionally override the Tenderly API URL.
-    url: Option<Url>,
-
-    /// Authentication key for the Tenderly API.
-    api_key: String,
-
-    /// The Tenderly user associated with the API key.
-    user: String,
-
-    /// The Tenderly project associated with the API key.
-    project: String,
-
-    /// Save the transaction on Tenderly for later inspection, e.g. via the
-    /// dashboard.
-    save: bool,
-
-    /// Save the transaction even in the case of failure.
-    save_if_fails: bool,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-struct EnsoConfig {
-    /// URL at which the trade simulator is hosted
-    url: Url,
-    /// How often the network produces a new block. If this is not set the
-    /// system assumes an unpredictable network like proof-of-work.
-    #[serde(default, with = "humantime_serde")]
-    network_block_interval: Option<Duration>,
-}
-
 #[derive(Clone, Debug, Default, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 struct LiquidityConfig {
diff --git a/crates/driver/src/infra/config/mod.rs b/crates/driver/src/infra/config/mod.rs
index 43332eaffd..9d23d7780f 100644
--- a/crates/driver/src/infra/config/mod.rs
+++ b/crates/driver/src/infra/config/mod.rs
@@ -5,7 +5,6 @@ use {
         liquidity,
         mempool,
         notify,
-        simulator,
         solver,
     },
     eth_domain_types as eth,
@@ -22,7 +21,7 @@ pub struct Config {
     pub solvers: Vec<solver::Config>,
     pub liquidity: liquidity::Config,
     pub liquidity_sources_notifier: Option<notify::liquidity_sources::Config>,
-    pub simulator: Option<simulator::Config>,
+    pub simulator: configs::simulator::Config,
     pub gas_estimator: GasEstimatorType,
     pub mempools: Vec<mempool::Config>,
     pub contracts: blockchain::contracts::Addresses,
@@ -30,4 +29,5 @@ pub struct Config {
     pub simulation_bad_token_max_age: Duration,
     pub app_data_fetching: AppDataFetching,
     pub tx_gas_limit: eth::U256,
+    pub http: configs::http_client::HttpClient,
 }
diff --git a/crates/driver/src/infra/mod.rs b/crates/driver/src/infra/mod.rs
index b33526f545..929d03119d 100644
--- a/crates/driver/src/infra/mod.rs
+++ b/crates/driver/src/infra/mod.rs
@@ -7,16 +7,8 @@ pub mod mempool;
 pub mod notify;
 pub mod observe;
 pub mod persistence;
-pub mod simulator;
 pub mod solver;
 pub mod time;
 pub mod tokens;
 
-pub use {
-    self::solver::Solver,
-    api::Api,
-    blockchain::Ethereum,
-    config::Config,
-    mempool::Mempool,
-    simulator::Simulator,
-};
+pub use {self::solver::Solver, api::Api, blockchain::Ethereum, config::Config, mempool::Mempool};
diff --git a/crates/driver/src/infra/notify/mod.rs b/crates/driver/src/infra/notify/mod.rs
index a64fed2e3d..1e5a41d0b7 100644
--- a/crates/driver/src/infra/notify/mod.rs
+++ b/crates/driver/src/infra/notify/mod.rs
@@ -7,7 +7,7 @@ pub mod liquidity_sources;
 mod notification;
 
 pub use notification::{Kind, Notification, ScoreKind, Settlement, SimulationSucceededAtLeastOnce};
-use {super::simulator, crate::domain::mempools::Error, eth_domain_types as eth};
+use {crate::domain::mempools::Error, eth_domain_types as eth};
 
 pub fn solver_timeout(solver: &Solver, auction_id: Option<auction::Id>) {
     solver.notify(auction_id, None, notification::Kind::Timeout);
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index c6acaaa4bc..fded86b778 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -4,7 +4,7 @@
 //! and update the metrics, if the event is worth measuring.
 
 use {
-    super::{Ethereum, Mempool, simulator, solver::Timeouts},
+    super::{Ethereum, Mempool, solver::Timeouts},
     crate::{
         boundary,
         domain::{
diff --git a/crates/driver/src/infra/simulator/tenderly/dto.rs b/crates/driver/src/infra/simulator/tenderly/dto.rs
deleted file mode 100644
index 5c565edad9..0000000000
--- a/crates/driver/src/infra/simulator/tenderly/dto.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//! Data transfer objects for interacting with the Tenderly API.
-
-use {
-    eth_domain_types as eth,
-    serde::{Deserialize, Serialize},
-    serde_with::serde_as,
-};
-
-#[serde_as]
-#[derive(Debug, Serialize)]
-pub struct Request {
-    pub network_id: String,
-    pub from: eth::Address,
-    pub to: eth::Address,
-    #[serde_as(as = "serde_ext::Hex")]
-    pub input: Vec<u8>,
-    pub value: eth::U256,
-    pub save: bool,
-    pub save_if_fails: bool,
-    pub generate_access_list: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub access_list: Option<AccessList>,
-    pub gas_price: u64,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct Response {
-    pub transaction: Transaction,
-    pub generated_access_list: Option<AccessList>,
-    pub simulation: Simulation,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct Transaction {
-    pub status: bool,
-    pub gas_used: u64,
-}
-
-/// Tenderly requires access lists to be serialized with `snake_case` instead
-/// of the standard `camelCase`.
-#[derive(Debug, Default, Deserialize, Serialize)]
-#[serde(transparent)]
-pub struct AccessList(Vec<AccessListItem>);
-
-#[derive(Debug, Deserialize, Serialize)]
-struct AccessListItem {
-    address: eth::Address,
-    #[serde(default)]
-    storage_keys: Vec<eth::B256>,
-}
-
-impl From<eth::AccessList> for AccessList {
-    fn from(value: eth::AccessList) -> Self {
-        Self(
-            value
-                .into_iter()
-                .map(|(address, storage_keys)| AccessListItem {
-                    address,
-                    storage_keys: storage_keys.into_iter().map(|k| k.0).collect(),
-                })
-                .collect(),
-        )
-    }
-}
-
-impl From<AccessList> for eth::AccessList {
-    fn from(value: AccessList) -> Self {
-        Self::from_iter(
-            value
-                .0
-                .into_iter()
-                .map(|item| (item.address, item.storage_keys)),
-        )
-    }
-}
-
-#[derive(Debug, Deserialize)]
-pub struct Simulation {
-    pub id: String,
-}
diff --git a/crates/driver/src/infra/simulator/tenderly/mod.rs b/crates/driver/src/infra/simulator/tenderly/mod.rs
deleted file mode 100644
index 16cf6fe838..0000000000
--- a/crates/driver/src/infra/simulator/tenderly/mod.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use {crate::infra::Ethereum, eth_domain_types as eth, thiserror::Error};
-
-mod dto;
-
-const DEFAULT_URL: &str = "https://api.tenderly.co/api";
-
-#[derive(Debug, Clone)]
-pub(super) struct Tenderly {
-    endpoint: reqwest::Url,
-    client: reqwest::Client,
-    config: Config,
-    eth: Ethereum,
-}
-
-#[derive(Debug, Clone)]
-pub struct Config {
-    /// The URL of the Tenderly API.
-    pub url: Option<reqwest::Url>,
-    /// The Tenderly API key.
-    pub api_key: String,
-    /// The user associated with the API key.
-    pub user: String,
-    /// The project to use.
-    pub project: String,
-    /// Save the transaction on Tenderly for later inspection, e.g. via the
-    /// dashboard.
-    pub save: bool,
-    /// Save the transaction as above, even in the case of failure.
-    pub save_if_fails: bool,
-}
-
-impl Tenderly {
-    pub(super) fn new(config: Config, eth: Ethereum) -> Self {
-        let mut headers = reqwest::header::HeaderMap::new();
-        headers.insert(
-            reqwest::header::CONTENT_TYPE,
-            "application/json".parse().unwrap(),
-        );
-        headers.insert(reqwest::header::ACCEPT, "application/json".parse().unwrap());
-        let mut api_key = reqwest::header::HeaderValue::from_str(&config.api_key).unwrap();
-        api_key.set_sensitive(true);
-        headers.insert("x-access-key", api_key);
-        Self {
-            endpoint: reqwest::Url::parse(&format!(
-                "{}/v1/account/{}/project/{}/simulate",
-                config
-                    .url
-                    .as_ref()
-                    .map(|url| url.to_string())
-                    .unwrap_or_else(|| DEFAULT_URL.to_owned()),
-                config.user,
-                config.project
-            ))
-            .unwrap(),
-            client: reqwest::ClientBuilder::new()
-                .default_headers(headers)
-                .build()
-                .unwrap(),
-            config,
-            eth,
-        }
-    }
-
-    pub(super) async fn simulate(
-        &self,
-        tx: &eth::Tx,
-        generate_access_list: GenerateAccessList,
-    ) -> Result<Simulation, Error> {
-        let gas_price = self.eth.simulation_gas_price().await;
-
-        let res: dto::Response = self
-            .client
-            .post(self.endpoint.clone())
-            .json(&dto::Request {
-                network_id: self.eth.chain().id().to_string(),
-                from: tx.from,
-                to: tx.to,
-                input: tx.input.clone().into(),
-                value: tx.value.into(),
-                save: self.config.save,
-                save_if_fails: self.config.save_if_fails,
-                generate_access_list: generate_access_list == GenerateAccessList::Yes,
-                access_list: if tx.access_list.is_empty() {
-                    None
-                } else {
-                    Some(tx.access_list.clone().into())
-                },
-                gas_price: gas_price
-                    .unwrap_or_default()
-                    .try_into()
-                    .expect("value should be lower than u64::MAX"),
-            })
-            .send()
-            .await?
-            .error_for_status()?
-            .json()
-            .await?;
-
-        res.into()
-    }
-}
-
-#[derive(Debug)]
-pub struct Simulation {
-    pub id: SimulationId,
-    pub gas: eth::Gas,
-    pub access_list: eth::AccessList,
-}
-
-// We want the string to be printed together with a simulation so we
-// don't care that it's not used for anything else.
-#[derive(Debug)]
-pub struct SimulationId(#[allow(dead_code, reason = "intended for Debug implementation")] String);
-
-#[derive(Debug, PartialEq, Eq)]
-pub(super) enum GenerateAccessList {
-    Yes,
-    No,
-}
-
-#[derive(Debug, Error)]
-#[error("tenderly error")]
-pub enum Error {
-    Http(#[from] reqwest::Error),
-    Revert(SimulationId),
-}
-
-impl From<dto::Response> for Result<Simulation, Error> {
-    fn from(res: dto::Response) -> Self {
-        let id = SimulationId(res.simulation.id);
-        if res.transaction.status {
-            Ok(Simulation {
-                id,
-                gas: res.transaction.gas_used.into(),
-                access_list: res.generated_access_list.unwrap_or_default().into(),
-            })
-        } else {
-            Err(Error::Revert(id))
-        }
-    }
-}
diff --git a/crates/driver/src/run.rs b/crates/driver/src/run.rs
index dd70e07d30..9fcee0b232 100644
--- a/crates/driver/src/run.rs
+++ b/crates/driver/src/run.rs
@@ -12,13 +12,14 @@ use {
             config,
             liquidity,
             notify,
-            simulator::{self, Simulator},
             solver::Solver,
         },
     },
     clap::Parser,
     futures::future::join_all,
+    http_client::HttpClientFactory,
     shared::arguments::tracing_config,
+    simulator::{self, Simulator},
     std::{net::SocketAddr, sync::Arc, time::Duration},
     tokio::sync::oneshot,
 };
@@ -62,7 +63,18 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
     tracing::info!(%commit_hash, "running driver with {config:#?}");
 
     let (shutdown_sender, shutdown_receiver) = tokio::sync::oneshot::channel();
-    let eth = ethereum(&config, ethrpc, &args.current_block).await;
+    let eth = ethereum(&config, ethrpc.clone(), &args.current_block).await;
+    let simulator_eth = simulator::Ethereum::new(
+        ethrpc.web3().clone(),
+        ethrpc.chain(),
+        configs::simulator::Addresses {
+            settlement: config.contracts.settlement.map(|address| *address),
+            weth: config.contracts.weth.map(|address| *address),
+        },
+        eth.gas_estimator(),
+        eth.current_block().clone(),
+        config.tx_gas_limit,
+    );
     let app_data_retriever = match &config.app_data_fetching {
         config::file::AppDataFetching::Enabled {
             orderbook_url,
@@ -71,7 +83,7 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
         config::file::AppDataFetching::Disabled => None,
     };
     let solvers = solvers(&config, &eth).await;
-
+    let http_factory = HttpClientFactory::new(&config.http);
     // Set up EIP-7702 delegation and caller approval for solvers with
     // parallel submission accounts. Must happen before the HTTP server
     // starts accepting /settle requests.
@@ -83,7 +95,7 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
         solvers,
         liquidity: liquidity(&config, &eth).await,
         liquidity_sources_notifier: liquidity_sources_notifier(&config, &eth),
-        simulator: simulator(&config, &eth),
+        simulator: simulator(&config, simulator_eth, &http_factory),
         mempools: Mempools::try_new(
             config
                 .mempools
@@ -136,34 +148,33 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
     };
 }
 
-fn simulator(config: &infra::Config, eth: &Ethereum) -> Simulator {
+fn simulator(
+    config: &infra::Config,
+    eth: simulator::Ethereum,
+    http_factory: &HttpClientFactory,
+) -> Simulator {
     let mut simulator = match &config.simulator {
-        Some(infra::simulator::Config::Tenderly(tenderly)) => Simulator::tenderly(
-            simulator::tenderly::Config {
-                url: tenderly.url.to_owned(),
-                api_key: tenderly.api_key.to_owned(),
-                user: tenderly.user.to_owned(),
-                project: tenderly.project.to_owned(),
-                save: tenderly.save,
-                save_if_fails: tenderly.save_if_fails,
-            },
-            eth.to_owned(),
-        ),
-        Some(infra::simulator::Config::Enso(enso)) => Simulator::enso(
-            simulator::enso::Config {
-                url: enso.url.to_owned(),
-                network_block_interval: enso.network_block_interval.to_owned(),
-            },
-            eth.to_owned(),
-        ),
-        None => Simulator::ethereum(eth.to_owned()),
+        configs::simulator::Config {
+            kind: configs::simulator::SimulatorKind::Tenderly(config),
+            ..
+        } => Simulator::tenderly(config, eth, http_factory),
+        configs::simulator::Config {
+            kind: configs::simulator::SimulatorKind::Enso(config),
+            ..
+        } => Simulator::enso(config, eth),
+        configs::simulator::Config {
+            kind: configs::simulator::SimulatorKind::Ethereum,
+            ..
+        } => Simulator::ethereum(eth),
     };
+
     if config.disable_access_list_simulation {
-        simulator.disable_access_lists()
+        simulator.disable_access_lists();
     }
     if let Some(gas) = config.disable_gas_simulation {
-        simulator.disable_gas(gas)
+        simulator.disable_gas(gas);
     }
+
     simulator
 }
 
@@ -188,14 +199,7 @@ async fn ethereum(
             .await
             .expect("initialize gas price estimator"),
     );
-    Ethereum::new(
-        ethrpc,
-        config.contracts.clone(),
-        gas,
-        config.tx_gas_limit,
-        current_block_args,
-    )
-    .await
+    Ethereum::new(ethrpc, config.contracts.clone(), gas, current_block_args).await
 }
 
 async fn solvers(config: &config::Config, eth: &Ethereum) -> Vec<Solver> {
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index f67c3819ed..77c93cb4d4 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -471,7 +471,6 @@ impl Solver {
                 flashloan_router: Some((*config.blockchain.flashloan_router.address()).into()),
             },
             gas,
-            eth::U256::from(45_000_000),
             &shared::current_block::Arguments {
                 block_stream_poll_interval: None,
                 node_ws_url: Some(config.blockchain.web3_ws_url.parse().unwrap()),
diff --git a/crates/e2e/Cargo.toml b/crates/e2e/Cargo.toml
index 4d2d337f3f..a66253e7b3 100644
--- a/crates/e2e/Cargo.toml
+++ b/crates/e2e/Cargo.toml
@@ -55,6 +55,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 shared = { workspace = true }
 signature-validator = { workspace = true }
+simulator = { workspace = true }
 solver = { workspace = true }
 solvers = { workspace = true }
 solvers-dto = { workspace = true }
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 7b3809f5a5..0976f32253 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -26,6 +26,7 @@ use {
         trade_verifier::{PriceQuery, TradeVerifier, TradeVerifying},
     },
     serde_json::json,
+    simulator::swap_simulator::SwapSimulator,
     std::sync::Arc,
 };
 
@@ -147,18 +148,28 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
         .await
         .unwrap();
     let onchain = OnchainComponents::deployed(web3.clone()).await;
+    let balance_overrides = Arc::new(BalanceOverrides::default());
+    let gas_limit = 12_000_000;
+    let simulator = SwapSimulator::new(
+        balance_overrides.clone(),
+        *onchain.contracts().gp_settlement.address(),
+        *onchain.contracts().weth.address(),
+        block_stream.clone(),
+        web3.clone(),
+        gas_limit,
+    )
+    .await
+    .unwrap();
 
     let verifier = TradeVerifier::new(
         web3.clone(),
         None,
+        simulator,
         Arc::new(web3.clone()),
-        Arc::new(BalanceOverrides::default()),
-        block_stream,
+        balance_overrides,
         *onchain.contracts().gp_settlement.address(),
-        *onchain.contracts().weth.address(),
         BigDecimal::zero(),
         Default::default(),
-        12_000_000,
     )
     .await
     .unwrap();
diff --git a/crates/gas-price-estimation/Cargo.toml b/crates/gas-price-estimation/Cargo.toml
index 86037c8240..c4957e6c0c 100644
--- a/crates/gas-price-estimation/Cargo.toml
+++ b/crates/gas-price-estimation/Cargo.toml
@@ -10,6 +10,7 @@ alloy-eips = { workspace = true }
 alloy-provider = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+configs = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 observe = { workspace = true }
diff --git a/crates/gas-price-estimation/src/configurable_alloy.rs b/crates/gas-price-estimation/src/configurable_alloy.rs
index 7136247035..aa51556c45 100644
--- a/crates/gas-price-estimation/src/configurable_alloy.rs
+++ b/crates/gas-price-estimation/src/configurable_alloy.rs
@@ -10,26 +10,11 @@ use {
     alloy_eips::{BlockId, BlockNumberOrTag, eip1559::Eip1559Estimation},
     alloy_provider::{Provider, utils::eip1559_default_estimator},
     anyhow::{Context, Result},
+    configs::gas_price_estimation::EstimatorConfig,
     ethrpc::AlloyProvider,
     tracing::instrument,
 };
 
-#[derive(Debug, Clone, Copy)]
-pub struct EstimatorConfig {
-    /// Number of blocks to look back for fee history
-    pub past_blocks: u64,
-    /// Percentile of rewards to use for priority fee estimation
-    pub reward_percentile: f64,
-}
-
-pub fn default_past_blocks() -> u64 {
-    10
-}
-
-pub fn default_reward_percentile() -> f64 {
-    20.0
-}
-
 /// A configurable EIP-1559 gas price estimator.
 ///
 /// Uses alloy's default estimation algorithm but with configurable
diff --git a/crates/gas-price-estimation/src/lib.rs b/crates/gas-price-estimation/src/lib.rs
index 83b4db984a..a2491bc80f 100644
--- a/crates/gas-price-estimation/src/lib.rs
+++ b/crates/gas-price-estimation/src/lib.rs
@@ -7,18 +7,18 @@ pub mod priority;
 
 use {
     crate::{
-        configurable_alloy::{
-            ConfigurableGasPriceEstimator,
-            EstimatorConfig,
-            default_past_blocks,
-            default_reward_percentile,
-        },
+        configurable_alloy::ConfigurableGasPriceEstimator,
         eth_node::NodeGasPriceEstimator,
         priority::PriorityGasPriceEstimating,
     },
     alloy_eips::eip1559::{Eip1559Estimation, calc_effective_gas_price},
     alloy_provider::Provider,
     anyhow::Result,
+    configs::gas_price_estimation::{
+        EstimatorConfig,
+        default_past_blocks,
+        default_reward_percentile,
+    },
     ethrpc::Web3,
     tracing::instrument,
     url::Url,
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index 6cbc0a4280..c2596b132a 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -46,6 +46,7 @@ rust_decimal = { workspace = true, features = ["maths"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
+simulator = { workspace = true }
 thiserror = { workspace = true }
 token-info = { workspace = true }
 tokio = { workspace = true }
diff --git a/crates/price-estimation/src/config/price_estimation.rs b/crates/price-estimation/src/config/price_estimation.rs
index b7e4ed61e0..d54e2c1778 100644
--- a/crates/price-estimation/src/config/price_estimation.rs
+++ b/crates/price-estimation/src/config/price_estimation.rs
@@ -1,9 +1,6 @@
 use {
-    crate::trade_verifier::tenderly_api::{Instrumented, TenderlyApi, TenderlyHttpApi},
-    anyhow::Result,
     balance_overrides::BalanceOverriding,
-    configs::price_estimation::{BalanceOverridesConfig, TenderlyConfig},
-    http_client::HttpClientFactory,
+    configs::price_estimation::BalanceOverridesConfig,
     std::sync::Arc,
 };
 
@@ -24,22 +21,3 @@ impl BalanceOverridesConfigExt for BalanceOverridesConfig {
         })
     }
 }
-
-pub trait TenderlyConfigExt {
-    fn get_api_instance(
-        &self,
-        http_factory: &HttpClientFactory,
-        name: String,
-    ) -> Result<Arc<dyn TenderlyApi>>;
-}
-
-impl TenderlyConfigExt for TenderlyConfig {
-    fn get_api_instance(
-        &self,
-        http_factory: &HttpClientFactory,
-        name: String,
-    ) -> Result<Arc<dyn TenderlyApi>> {
-        TenderlyHttpApi::new(http_factory, &self.user, &self.project, &self.api_key)
-            .map(|inner| Arc::new(Instrumented { inner, name }) as _)
-    }
-}
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index 1603c5e744..51f6c4fbe3 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -14,11 +14,8 @@ use {
         ExternalSolver,
         buffered::{self, BufferedRequest, NativePriceBatchFetching},
         competition::PriceRanking,
-        config::{
-            native_price::NativePriceConfig,
-            price_estimation::{BalanceOverridesConfigExt, TenderlyConfigExt},
-        },
-        trade_verifier::{code_fetching::CachedCodeFetcher, tenderly_api::TenderlyCodeSimulator},
+        config::{native_price::NativePriceConfig, price_estimation::BalanceOverridesConfigExt},
+        trade_verifier::code_fetching::CachedCodeFetcher,
     },
     alloy::primitives::Address,
     anyhow::{Context as _, Result},
@@ -31,6 +28,7 @@ use {
     number::nonzero::NonZeroU256,
     rate_limit::RateLimiter,
     reqwest::Url,
+    simulator::{swap_simulator::SwapSimulator, tenderly},
     std::{collections::HashMap, num::NonZeroUsize, sync::Arc},
     token_info::TokenInfoFetching,
 };
@@ -98,29 +96,35 @@ impl<'a> PriceEstimatorFactory<'a> {
         };
         let web3 = web3.labeled("simulator");
 
-        let tenderly = if let Some(tenderly) = &args.tenderly {
-            tenderly
-                .get_api_instance(&components.http_factory, "price_estimation".to_owned())
-                .map(|tenderly| Arc::new(TenderlyCodeSimulator::new(tenderly, network.chain.id())))
-                .inspect_err(|err| tracing::error!(%err, "failed to setup tenderly api"))
-                .ok()
-        } else {
-            None
-        };
-
         let balance_overrides = args.balance_overrides.init(web3.clone());
 
+        let tenderly = args.tenderly.as_ref().map(|config| {
+            Arc::new(tenderly::TenderlyApi::new_instrumented(
+                "price_estimation".to_string(),
+                config,
+                &components.http_factory,
+                network.chain.id().to_string(),
+            )) as Arc<dyn tenderly::Api>
+        });
+        let simulator = SwapSimulator::new(
+            balance_overrides.clone(),
+            network.settlement,
+            network.native_token,
+            network.block_stream.clone(),
+            web3.clone(),
+            args.max_gas_per_tx,
+        )
+        .await?;
+
         let verifier = TradeVerifier::new(
             web3,
             tenderly,
+            simulator,
             components.code_fetcher.clone(),
             balance_overrides,
-            network.block_stream.clone(),
             network.settlement,
-            network.native_token,
             args.quote_inaccuracy_limit.clone(),
             args.tokens_without_verification.iter().cloned().collect(),
-            args.max_gas_per_tx,
         )
         .await?;
         Ok(Some(Arc::new(verifier)))
diff --git a/crates/price-estimation/src/trade_finding/mod.rs b/crates/price-estimation/src/trade_finding/mod.rs
index 39bfc2501d..0b742fdbf3 100644
--- a/crates/price-estimation/src/trade_finding/mod.rs
+++ b/crates/price-estimation/src/trade_finding/mod.rs
@@ -6,7 +6,7 @@ pub mod trade_estimator;
 
 use {
     crate::{PriceEstimationError, Query},
-    alloy::primitives::{Address, Bytes, U256},
+    alloy::primitives::{Address, U256},
     anyhow::{Context, Result},
     derive_more::Debug,
     external::dto,
@@ -207,14 +207,6 @@ pub struct Interaction {
 }
 
 impl Interaction {
-    pub fn encode(&self) -> EncodedInteraction {
-        (
-            self.target,
-            self.value,
-            Bytes::copy_from_slice(self.data.as_slice()),
-        )
-    }
-
     pub fn to_interaction_data(&self) -> InteractionData {
         InteractionData {
             target: self.target,
@@ -222,6 +214,10 @@ impl Interaction {
             call_data: self.data.clone(),
         }
     }
+
+    pub fn encode(self) -> simulator::encoding::EncodedInteraction {
+        simulator::encoding::Interaction::from(self).encode()
+    }
 }
 
 impl From<InteractionData> for Interaction {
@@ -234,7 +230,15 @@ impl From<InteractionData> for Interaction {
     }
 }
 
-pub type EncodedInteraction = (Address, U256, Bytes);
+impl From<Interaction> for simulator::encoding::Interaction {
+    fn from(interaction: Interaction) -> Self {
+        Self {
+            target: interaction.target,
+            value: interaction.value,
+            data: interaction.data,
+        }
+    }
+}
 
 #[derive(Debug, Error)]
 pub enum TradeError {
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index dadbb086cc..a30666be3d 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -5,29 +5,27 @@ use {
             Interaction,
             QuoteExecution,
             TradeKind,
-            external::dto::{self, JitOrder},
+            external::dto::{self, Side},
             map_interactions_data,
         },
-        trade_verifier::{code_fetching::CodeFetching, tenderly_api::TenderlyCodeSimulator},
-        utils::encoding::{EncodedInteraction, EncodedSettlement, EncodedTrade, encode_trade},
+        trade_verifier::code_fetching::CodeFetching,
     },
     ::alloy::sol_types::SolCall,
     alloy::{
-        primitives::{Address, Bytes, U256, address, aliases::I512, map::AddressMap},
+        primitives::{Address, U256, address, aliases::I512, map::AddressMap},
         rpc::types::{eth::state::StateOverride, state::AccountOverride},
     },
-    anyhow::{Context, Result, anyhow},
+    anyhow::{Context, Result},
     balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     bigdecimal::BigDecimal,
     contracts::alloy::{
         GPv2Settlement,
-        WETH9,
         support::{AnyoneAuthenticator, Solver, Spardose, Trader},
     },
-    ethrpc::{Web3, block_stream::CurrentBlockWatcher},
+    ethrpc::Web3,
     model::{
         DomainSeparator,
-        order::{BUY_ETH_ADDRESS, OrderData, OrderKind},
+        order::{OrderData, OrderKind},
         signature::{Signature, SigningScheme},
     },
     num::BigRational,
@@ -40,6 +38,11 @@ use {
         },
         nonzero::NonZeroU256,
     },
+    simulator::{
+        encoding::{EncodedTrade, encode_trade},
+        swap_simulator::{EncodedSwap, SwapSimulator},
+        tenderly::{self},
+    },
     std::{
         collections::{HashMap, HashSet},
         sync::Arc,
@@ -48,7 +51,6 @@ use {
 };
 
 pub mod code_fetching;
-pub mod tenderly_api;
 
 #[async_trait::async_trait]
 pub trait TradeVerifying: Send + Sync + 'static {
@@ -66,17 +68,13 @@ pub trait TradeVerifying: Send + Sync + 'static {
 /// and determines a price estimate based off of that simulation.
 #[derive(Clone)]
 pub struct TradeVerifier {
-    web3: Web3,
-    simulator: Option<Arc<TenderlyCodeSimulator>>,
+    tenderly: Option<Arc<dyn tenderly::Api>>,
+    simulator: SwapSimulator,
     code_fetcher: Arc<dyn CodeFetching>,
     balance_overrides: Arc<dyn BalanceOverriding>,
-    block_stream: CurrentBlockWatcher,
     settlement: GPv2Settlement::Instance,
-    native_token: Address,
     quote_inaccuracy_limit: BigRational,
-    domain_separator: DomainSeparator,
     tokens_without_verification: HashSet<Address>,
-    gas_limit: u64,
 }
 
 impl TradeVerifier {
@@ -86,32 +84,24 @@ impl TradeVerifier {
     #[expect(clippy::too_many_arguments)]
     pub async fn new(
         web3: Web3,
-        simulator: Option<Arc<TenderlyCodeSimulator>>,
+        tenderly: Option<Arc<dyn tenderly::Api>>,
+        simulator: SwapSimulator,
         code_fetcher: Arc<dyn CodeFetching>,
         balance_overrides: Arc<dyn BalanceOverriding>,
-        block_stream: CurrentBlockWatcher,
         settlement: Address,
-        native_token: Address,
         quote_inaccuracy_limit: BigDecimal,
         tokens_without_verification: HashSet<Address>,
-        gas_limit: u64,
     ) -> Result<Self> {
         let settlement_contract =
             GPv2Settlement::GPv2Settlement::new(settlement, web3.provider.clone());
-        let domain_separator =
-            DomainSeparator(settlement_contract.domainSeparator().call().await?.0);
         Ok(Self {
+            tenderly,
             simulator,
             code_fetcher,
             balance_overrides,
-            block_stream,
             settlement: settlement_contract,
-            native_token,
             quote_inaccuracy_limit: big_decimal_to_big_rational(&quote_inaccuracy_limit),
-            web3,
-            domain_separator,
             tokens_without_verification,
-            gas_limit,
         })
     }
 
@@ -123,14 +113,9 @@ impl TradeVerifier {
         out_amount: &U256,
     ) -> Result<Estimate, Error> {
         let start = std::time::Instant::now();
-
-        // this may change the `verification` parameter (to make more
-        // quotes verifiable) so we do it as the first thing to ensure
-        // that all the following code uses the updated value
         let overrides = self
             .prepare_state_overrides(&mut verification, query, trade)
-            .await
-            .map_err(Error::SimulationFailed)?;
+            .await?;
 
         // Use `tx_origin` if response indicates that a special address is needed for
         // the simulation to pass. Otherwise just use the solver address.
@@ -152,57 +137,81 @@ impl TradeVerifier {
             TradeKind::Regular(trade) => trade.clearing_prices.iter().unzip(),
         };
 
-        let settlement = encode_settlement(
-            query,
-            &verification,
-            trade,
-            &tokens,
-            &clearing_prices,
-            out_amount,
-            self.native_token,
-            &self.domain_separator,
-            *self.settlement.address(),
-        )?;
-        let settlement = add_balance_queries(settlement, query, &verification, solver_address);
-
-        let settle_call = legacy_settlement_to_alloy(settlement).abi_encode();
-        let block = *self.block_stream.borrow();
-
-        let solver = Solver::Instance::new(solver_address, self.web3.provider.clone());
-        let swap_simulation = solver.swap(
-                *self.settlement.address(),
-                tokens.clone(),
-                verification.receiver,
-                settle_call.into(),
-            )
-            // Initiate tx as solver so gas doesn't get deducted from user's ETH.
-            .from(solver_address)
-            .to(solver_address)
-            .gas(self.gas_limit)
-            // Use a high enough non-zero gas price to catch tokens with special logic
-            // for gas_price == 0 but also avoid reverts due to too low gas price.
-            // The exact price is not important since we are only interested in the used
-            // gas units anyway.
-            .gas_price(
-                u128::try_from(block.gas_price.saturating_mul(U256::from(2)))
-                .map_err(|err| anyhow!(err))
-                .context("converting gas price to u128")?
-            );
+        let simulator_query = simulator::swap_simulator::Query {
+            in_token: query.sell_token,
+            out_token: query.buy_token,
+            kind: query.kind,
+            in_amount: query.in_amount,
+            out_amount: *out_amount,
+            receiver: verification.receiver,
+            sell_token_source: verification.sell_token_source,
+            buy_token_destination: verification.buy_token_destination,
+            from: verification.from,
+            tx_origin: trade.tx_origin(),
+            solver: solver_address,
+            tokens: tokens.clone(),
+            clearing_prices,
+        };
 
-        if let Some(tenderly) = &self.simulator
-            && let Err(err) = tenderly.log_simulation_command(
-                swap_simulation.clone().into_transaction_request(),
-                overrides.clone(),
-                Some(block.number),
-            )
+        let mut swap = self
+            .simulator
+            .fake_swap(simulator_query)
+            .await
+            .map_err(Error::SimulationFailed)?;
+
+        swap.overrides.extend(overrides);
+
+        let mut pre_interactions = verification
+                .pre_interactions
+                .iter()
+                // pre_interactions introduced by the solver
+                .chain(trade.pre_interactions())
+                .cloned()
+                .map(Interaction::encode)
+                .collect::<Vec<_>>();
+
+        // Join custom pre_interactions
+        pre_interactions.extend(swap.settlement.interactions.pre);
+        swap.settlement.interactions.pre = pre_interactions;
+
+        // Interactions introduced by the solver
+        let interactions = trade.interactions().cloned().map(Interaction::encode);
+        swap.settlement.interactions.main = interactions
+            .into_iter()
+            .chain(swap.settlement.interactions.main)
+            .collect();
+
+        let post_interactions = verification
+            .post_interactions
+            .iter()
+            .cloned()
+            .map(Interaction::encode);
+        swap.settlement.interactions.post = swap
+            .settlement
+            .interactions
+            .post
+            .into_iter()
+            .chain(post_interactions)
+            .collect();
+
+        add_balance_queries(&mut swap, query, &verification);
+
+        if let TradeKind::Regular(trade) = trade {
+            swap.settlement.trades.extend(encode_jit_orders(
+                &trade.jit_orders,
+                &swap.settlement.tokens,
+                &self.simulator.domain_separator,
+            )?);
+        }
+        let output = self.simulator.simulate_swap(swap).await?;
+
+        if let Some(tenderly) = &self.tenderly
+            && let Err(err) = tenderly.log_simulation_command(output.tx, output.overrides, None)
         {
             tracing::debug!(?err, "could not log tenderly simulation command");
         }
-
-        let output = swap_simulation
-            .call()
-            .overrides(overrides)
-            .await
+        let output = output
+            .result
             .context("failed to simulate quote")
             .map_err(Error::SimulationFailed);
 
@@ -445,55 +454,18 @@ impl TradeVerifier {
             overrides.insert(
                 authenticator,
                 AccountOverride {
-                    code: Some(Bytes::from(
-                        AnyoneAuthenticator::AnyoneAuthenticator::DEPLOYED_BYTECODE.to_vec(),
-                    )),
+                    code: Some(AnyoneAuthenticator::AnyoneAuthenticator::DEPLOYED_BYTECODE.clone()),
                     ..Default::default()
                 },
             );
         }
+
         overrides.insert(trade.tx_origin().unwrap_or(trade.solver()), solver_override);
 
         Ok(overrides)
     }
 }
 
-fn legacy_settlement_to_alloy(
-    settlement: EncodedSettlement,
-) -> GPv2Settlement::GPv2Settlement::settleCall {
-    GPv2Settlement::GPv2Settlement::settleCall {
-        tokens: settlement.tokens,
-        clearingPrices: settlement.clearing_prices,
-        interactions: settlement.interactions.map(|interactions| {
-            interactions
-                .into_iter()
-                .map(|i| GPv2Settlement::GPv2Interaction::Data {
-                    target: i.0,
-                    value: i.1,
-                    callData: i.2.0.into(),
-                })
-                .collect()
-        }),
-        trades: settlement
-            .trades
-            .into_iter()
-            .map(|t| GPv2Settlement::GPv2Trade::Data {
-                sellTokenIndex: t.0,
-                buyTokenIndex: t.1,
-                receiver: t.2,
-                sellAmount: t.3,
-                buyAmount: t.4,
-                validTo: t.5,
-                appData: t.6,
-                feeAmount: t.7,
-                flags: t.8,
-                executedAmount: t.9,
-                signature: t.10,
-            })
-            .collect(),
-    }
-}
-
 #[async_trait::async_trait]
 impl TradeVerifying for TradeVerifier {
     #[instrument(skip_all)]
@@ -572,237 +544,7 @@ impl TradeVerifying for TradeVerifier {
     }
 }
 
-fn encode_interactions<'a>(
-    interactions: impl IntoIterator<Item = &'a Interaction>,
-) -> Vec<EncodedInteraction> {
-    interactions.into_iter().map(|i| i.encode()).collect()
-}
-
-#[expect(clippy::too_many_arguments)]
-fn encode_settlement(
-    query: &PriceQuery,
-    verification: &Verification,
-    trade: &TradeKind,
-    tokens: &[Address],
-    clearing_prices: &[U256],
-    out_amount: &U256,
-    native_token: Address,
-    domain_separator: &DomainSeparator,
-    settlement: Address,
-) -> Result<EncodedSettlement> {
-    let mut trade_interactions = encode_interactions(trade.interactions());
-    if query.buy_token == BUY_ETH_ADDRESS {
-        // Because the `driver` manages `WETH` unwraps under the hood the `TradeFinder`
-        // does not have to emit unwraps to pay out `ETH` in a trade.
-        // However, for the simulation to be successful this has to happen so we do it
-        // ourselves here.
-        let buy_amount = match query.kind {
-            OrderKind::Sell => *out_amount,
-            OrderKind::Buy => query.in_amount.get(),
-        };
-        trade_interactions.push((
-            native_token,
-            U256::ZERO,
-            WETH9::WETH9::withdrawCall { wad: buy_amount }
-                .abi_encode()
-                .into(),
-        ));
-        tracing::trace!("adding unwrap interaction for paying out ETH");
-    }
-
-    let fake_trade = encode_fake_trade(query, verification, out_amount, tokens)?;
-    let mut trades = vec![fake_trade];
-    if let TradeKind::Regular(trade) = trade {
-        trades.extend(encode_jit_orders(
-            &trade.jit_orders,
-            tokens,
-            domain_separator,
-        )?);
-    }
-
-    // Execute interaction to set up trade right before transfering funds.
-    // This interaction does nothing if the user-provided pre-interactions
-    // already set everything up (e.g. approvals, balances). That way we can
-    // correctly verify quotes with or without these user pre-interactions
-    // with helpful error messages.
-    let trade_setup_interaction = {
-        let sell_amount = match query.kind {
-            OrderKind::Sell => query.in_amount.get(),
-            OrderKind::Buy => *out_amount,
-        };
-        let solver_address = trade.solver();
-        let setup_call = Solver::Solver::ensureTradePreconditionsCall {
-            trader: verification.from,
-            settlementContract: settlement,
-            sellToken: query.sell_token,
-            sellAmount: sell_amount,
-            nativeToken: native_token,
-            spardose: TradeVerifier::SPARDOSE,
-        }
-        .abi_encode();
-        Interaction {
-            target: solver_address,
-            value: U256::ZERO,
-            data: setup_call,
-        }
-    };
-
-    let user_interactions = verification.pre_interactions.iter().cloned();
-    let pre_interactions: Vec<_> = user_interactions
-        .chain(trade.pre_interactions().cloned())
-        .chain([trade_setup_interaction])
-        .collect();
-
-    Ok(EncodedSettlement {
-        tokens: tokens.to_vec(),
-        clearing_prices: clearing_prices.to_vec(),
-        trades,
-        interactions: [
-            encode_interactions(&pre_interactions),
-            trade_interactions,
-            encode_interactions(&verification.post_interactions),
-        ],
-    })
-}
-
-fn encode_fake_trade(
-    query: &PriceQuery,
-    verification: &Verification,
-    out_amount: &U256,
-    tokens: &[Address],
-) -> Result<EncodedTrade, Error> {
-    // Configure the most disadvantageous trade possible (while taking possible
-    // overflows into account). Should the trader not receive the amount promised by
-    // the [`Trade`] the simulation will still work and we can compute the actual
-    // [`Trade::out_amount`] afterwards.
-    let (sell_amount, buy_amount) = match query.kind {
-        OrderKind::Sell => (query.in_amount.get(), U256::ZERO),
-        OrderKind::Buy => (
-            (*out_amount).max(U256::from(u128::MAX)),
-            query.in_amount.get(),
-        ),
-    };
-    let fake_order = OrderData {
-        sell_token: query.sell_token,
-        sell_amount,
-        buy_token: query.buy_token,
-        buy_amount,
-        receiver: Some(verification.receiver),
-        valid_to: u32::MAX,
-        app_data: Default::default(),
-        fee_amount: U256::ZERO,
-        kind: query.kind,
-        partially_fillable: false,
-        sell_token_balance: verification.sell_token_source,
-        buy_token_balance: verification.buy_token_destination,
-    };
-
-    let fake_signature = Signature::default_with(SigningScheme::Eip1271);
-    let encoded_trade = encode_trade(
-        &fake_order,
-        &fake_signature,
-        verification.from,
-        // the tokens set length is small so the linear search is acceptable
-        tokens
-            .iter()
-            .position(|token| token == &query.sell_token)
-            .context("missing sell token index")?,
-        tokens
-            .iter()
-            .position(|token| token == &query.buy_token)
-            .context("missing buy token index")?,
-        query.in_amount.get(),
-    );
-
-    Ok(encoded_trade)
-}
-
-fn encode_jit_orders(
-    jit_orders: &[dto::JitOrder],
-    tokens: &[Address],
-    domain_separator: &DomainSeparator,
-) -> Result<Vec<EncodedTrade>, Error> {
-    jit_orders
-        .iter()
-        .map(|jit_order| {
-            let order_data = OrderData {
-                sell_token: jit_order.sell_token,
-                buy_token: jit_order.buy_token,
-                receiver: Some(jit_order.receiver),
-                sell_amount: jit_order.sell_amount,
-                buy_amount: jit_order.buy_amount,
-                valid_to: jit_order.valid_to,
-                app_data: jit_order.app_data,
-                fee_amount: U256::ZERO,
-                kind: match &jit_order.side {
-                    dto::Side::Buy => OrderKind::Buy,
-                    dto::Side::Sell => OrderKind::Sell,
-                },
-                partially_fillable: jit_order.partially_fillable,
-                sell_token_balance: jit_order.sell_token_source,
-                buy_token_balance: jit_order.buy_token_destination,
-            };
-            let (owner, signature) =
-                recover_jit_order_owner(jit_order, &order_data, domain_separator)?;
-
-            Ok(encode_trade(
-                &order_data,
-                &signature,
-                owner,
-                // the tokens set length is small so the linear search is acceptable
-                tokens
-                    .iter()
-                    .position(|token| *token == jit_order.sell_token)
-                    .context("missing jit order sell token index")?,
-                tokens
-                    .iter()
-                    .position(|token| *token == jit_order.buy_token)
-                    .context("missing jit order buy token index")?,
-                jit_order.executed_amount,
-            ))
-        })
-        .collect::<Result<Vec<EncodedTrade>, Error>>()
-}
-
-/// Recovers the owner and signature from a `JitOrder`.
-fn recover_jit_order_owner(
-    jit_order: &JitOrder,
-    order_data: &OrderData,
-    domain_separator: &DomainSeparator,
-) -> Result<(Address, Signature), Error> {
-    let (owner, signature) = match jit_order.signing_scheme {
-        SigningScheme::Eip1271 => {
-            let (owner, signature) = jit_order.signature.split_at(20);
-            let owner = Address::from_slice(owner);
-            let signature = Signature::from_bytes(jit_order.signing_scheme, signature)?;
-            (owner, signature)
-        }
-        SigningScheme::PreSign => {
-            let owner = Address::from_slice(&jit_order.signature);
-            let signature = Signature::from_bytes(jit_order.signing_scheme, Vec::new().as_slice())?;
-            (owner, signature)
-        }
-        _ => {
-            let signature = Signature::from_bytes(jit_order.signing_scheme, &jit_order.signature)?;
-            let owner = signature
-                .recover(domain_separator, &order_data.hash_struct())?
-                .context("could not recover the owner")?
-                .signer;
-            (owner, signature)
-        }
-    };
-    Ok((owner, signature))
-}
-
-/// Adds the interactions that are only needed to query important balances
-/// throughout the simulation.
-/// These balances will get used to compute an accurate price for the trade.
-fn add_balance_queries(
-    mut settlement: EncodedSettlement,
-    query: &PriceQuery,
-    verification: &Verification,
-    solver_address: Address,
-) -> EncodedSettlement {
+fn add_balance_queries(swap: &mut EncodedSwap, query: &PriceQuery, verification: &Verification) {
     let (token, owner) = match query.kind {
         // track how much `buy_token` the `receiver` actually got
         OrderKind::Sell => {
@@ -824,13 +566,12 @@ fn add_balance_queries(
     }
     .abi_encode();
 
-    let interaction = (solver_address, U256::ZERO, query_balance_call.into());
+    let interaction = (swap.solver, U256::ZERO, query_balance_call.into());
 
     // query balance query at the end of pre-interactions
-    settlement.interactions[0].push(interaction.clone());
+    swap.settlement.interactions.pre.push(interaction.clone());
     // query balance right after we payed out all `buy_token`
-    settlement.interactions[2].insert(0, interaction);
-    settlement
+    swap.settlement.interactions.post.insert(0, interaction);
 }
 
 /// Analyzed output of `Solver::settle` smart contract call.
@@ -949,6 +690,83 @@ pub struct PriceQuery {
     pub in_amount: NonZeroU256,
 }
 
+pub fn encode_jit_orders(
+    jit_orders: &[dto::JitOrder],
+    tokens: &[Address],
+    domain_separator: &DomainSeparator,
+) -> Result<Vec<EncodedTrade>> {
+    jit_orders
+        .iter()
+        .map(|jit_order| {
+            let order_data = OrderData {
+                sell_token: jit_order.sell_token,
+                buy_token: jit_order.buy_token,
+                receiver: Some(jit_order.receiver),
+                sell_amount: jit_order.sell_amount,
+                buy_amount: jit_order.buy_amount,
+                valid_to: jit_order.valid_to,
+                app_data: jit_order.app_data,
+                fee_amount: U256::ZERO,
+                kind: match &jit_order.side {
+                    Side::Buy => OrderKind::Buy,
+                    Side::Sell => OrderKind::Sell,
+                },
+                partially_fillable: jit_order.partially_fillable,
+                sell_token_balance: jit_order.sell_token_source,
+                buy_token_balance: jit_order.buy_token_destination,
+            };
+            let (owner, signature) =
+                recover_jit_order_owner(jit_order, &order_data, domain_separator)?;
+
+            Ok(encode_trade(
+                &order_data,
+                &signature,
+                owner,
+                // the tokens set length is small so the linear search is acceptable
+                tokens
+                    .iter()
+                    .position(|token| *token == jit_order.sell_token)
+                    .context("missing jit order sell token index")?,
+                tokens
+                    .iter()
+                    .position(|token| *token == jit_order.buy_token)
+                    .context("missing jit order buy token index")?,
+                jit_order.executed_amount,
+            ))
+        })
+        .collect::<Result<Vec<EncodedTrade>>>()
+}
+
+/// Recovers the owner and signature from a `JitOrder`.
+fn recover_jit_order_owner(
+    jit_order: &dto::JitOrder,
+    order_data: &OrderData,
+    domain_separator: &DomainSeparator,
+) -> Result<(Address, Signature)> {
+    let (owner, signature) = match jit_order.signing_scheme {
+        SigningScheme::Eip1271 => {
+            let (owner, signature) = jit_order.signature.split_at(20);
+            let owner = Address::from_slice(owner);
+            let signature = Signature::from_bytes(jit_order.signing_scheme, signature)?;
+            (owner, signature)
+        }
+        SigningScheme::PreSign => {
+            let owner = Address::from_slice(&jit_order.signature);
+            let signature = Signature::from_bytes(jit_order.signing_scheme, Vec::new().as_slice())?;
+            (owner, signature)
+        }
+        _ => {
+            let signature = Signature::from_bytes(jit_order.signing_scheme, &jit_order.signature)?;
+            let owner = signature
+                .recover(domain_separator, &order_data.hash_struct())?
+                .context("could not recover the owner")?
+                .signer;
+            (owner, signature)
+        }
+    };
+    Ok((owner, signature))
+}
+
 #[derive(thiserror::Error, Debug)]
 enum Error {
     /// Verification logic ran successfully but the quote was deemed too
diff --git a/crates/price-estimation/src/trade_verifier/tenderly_api.rs b/crates/price-estimation/src/trade_verifier/tenderly_api.rs
deleted file mode 100644
index 410c5ca7e8..0000000000
--- a/crates/price-estimation/src/trade_verifier/tenderly_api.rs
+++ /dev/null
@@ -1,464 +0,0 @@
-//! Module containing Tenderly API implementation.
-
-use {
-    crate::utils::{display_option, display_secret_option},
-    alloy::{
-        primitives::{Address, B256, TxKind, U256, map::B256Map},
-        rpc::types::{TransactionRequest, state::StateOverride as AlloyStateOverride},
-    },
-    anyhow::{Result, ensure},
-    bytes_hex::BytesHex,
-    clap::Parser,
-    http_client::HttpClientFactory,
-    prometheus::IntGaugeVec,
-    reqwest::{
-        Url,
-        header::{HeaderMap, HeaderValue},
-    },
-    serde::{Deserialize, Serialize},
-    std::{
-        collections::HashMap,
-        fmt::{self, Display, Formatter},
-        sync::Arc,
-    },
-    tracing::instrument,
-};
-/// Trait for abstracting Tenderly API.
-#[async_trait::async_trait]
-pub trait TenderlyApi: Send + Sync + 'static {
-    async fn simulate(&self, simulation: SimulationRequest) -> Result<SimulationResponse>;
-    fn log(&self, simulation: SimulationRequest) -> Result<()>;
-    fn simulation_url(&self, id: &str) -> Url;
-}
-
-const API_URL: &str = "https://api.tenderly.co";
-const DASHBOARD_URL: &str = "https://dashboard.tenderly.co";
-
-/// Tenderly HTTP API.
-pub struct TenderlyHttpApi {
-    api: Url,
-    dashboard: Url,
-    client: reqwest::Client,
-}
-
-impl TenderlyHttpApi {
-    /// Creates a new Tenderly API
-    pub fn new(
-        http_factory: &HttpClientFactory,
-        user: &str,
-        project: &str,
-        api_key: &str,
-    ) -> Result<Self> {
-        let mut api_key = HeaderValue::from_str(api_key)?;
-        api_key.set_sensitive(true);
-
-        let mut headers = HeaderMap::new();
-        headers.insert("x-access-key", api_key);
-
-        Ok(Self {
-            api: Url::parse(&format!(
-                "{API_URL}/api/v1/account/{user}/project/{project}/"
-            ))?,
-            dashboard: Url::parse(&format!("{DASHBOARD_URL}/{user}/{project}/"))?,
-            client: http_factory.configure(|builder| builder.default_headers(headers)),
-        })
-    }
-
-    /// Creates a Tenderly API from the environment for testing.
-    pub fn test_from_env() -> Arc<dyn TenderlyApi> {
-        Arc::new(
-            Self::new(
-                &HttpClientFactory::default(),
-                &std::env::var("TENDERLY_USER").unwrap(),
-                &std::env::var("TENDERLY_PROJECT").unwrap(),
-                &std::env::var("TENDERLY_API_KEY").unwrap(),
-            )
-            .unwrap(),
-        )
-    }
-}
-
-#[async_trait::async_trait]
-impl TenderlyApi for TenderlyHttpApi {
-    #[instrument(skip_all)]
-    async fn simulate(&self, simulation: SimulationRequest) -> Result<SimulationResponse> {
-        let url = crate::utils::join_url(&self.api, "simulate");
-        let body = serde_json::to_string(&simulation)?;
-
-        let response = self
-            .client
-            .post(url)
-            .header("content-type", "application/json")
-            .body(body)
-            .send()
-            .await?;
-
-        let ok = response.error_for_status_ref().map(|_| ());
-        let status = response.status();
-        let body = response.text().await?;
-        // NOTE: Turn these logs on at your own risk... The Tenderly response
-        // objects are huge (order of ~3M).
-        tracing::trace!(status =% status.as_u16(), %body, "simulated");
-
-        ok?;
-        Ok(serde_json::from_str(&body)?)
-    }
-
-    fn log(&self, simulation: SimulationRequest) -> Result<()> {
-        let request_url = crate::utils::join_url(&self.api, "simulate");
-        let simulation_url =
-            crate::utils::join_url(&self.dashboard, "simulator/$SIMULATION_ID").to_string();
-        let body = serde_json::to_string(&simulation)?;
-
-        #[rustfmt::skip]
-        tracing::debug!(
-            "resimulate by setting TENDERLY_API_KEY environment variable and running: \
-            curl -X POST -H \"X-ACCESS-KEY: $TENDERLY_API_KEY\" -H \"Content-Type: application/json\" --data '{body}' {request_url} \
-            | jq -r \".simulation.id\" \
-            | read SIMULATION_ID; \
-            echo {simulation_url} \
-            | xargs xdg-open",
-        );
-
-        Ok(())
-    }
-
-    fn simulation_url(&self, id: &str) -> Url {
-        crate::utils::join_url(&self.dashboard, &format!("simulator/{id}"))
-    }
-}
-
-/// Instrumented Tenderly HTTP API.
-pub struct Instrumented {
-    pub(crate) inner: TenderlyHttpApi,
-    pub(crate) name: String,
-}
-
-#[async_trait::async_trait]
-impl TenderlyApi for Instrumented {
-    async fn simulate(&self, simulation: SimulationRequest) -> Result<SimulationResponse> {
-        let result = self.inner.simulate(simulation).await;
-
-        Metrics::get()
-            .tenderly_simulations
-            .with_label_values(&[
-                self.name.as_str(),
-                match &result {
-                    Ok(_) => "ok",
-                    Err(_) => "err",
-                },
-            ])
-            .inc();
-
-        result
-    }
-
-    fn log(&self, simulation: SimulationRequest) -> Result<()> {
-        self.inner.log(simulation)
-    }
-
-    fn simulation_url(&self, id: &str) -> Url {
-        self.inner.simulation_url(id)
-    }
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
-pub struct SimulationRequest {
-    pub network_id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub block_number: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub transaction_index: Option<i64>,
-    pub from: Address,
-    pub to: Address,
-    #[serde(with = "bytes_hex")]
-    pub input: Vec<u8>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gas: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gas_price: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub value: Option<U256>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub simulation_kind: Option<SimulationKind>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub save: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub save_if_fails: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub generate_access_list: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state_objects: Option<HashMap<Address, StateObject>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub access_list: Option<Vec<AccessListItem>>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum SimulationKind {
-    Full,
-    Quick,
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
-pub struct StateObject {
-    /// Fake balance to set for the account before executing the call.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub balance: Option<alloy::primitives::U256>,
-
-    /// Fake EVM bytecode to inject into the account before executing the call.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub code: Option<alloy::primitives::Bytes>,
-
-    /// Fake key-value mapping to override **individual** slots in the account
-    /// storage before executing the call.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub storage: Option<B256Map<B256>>,
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
-pub struct SimulationResponse {
-    pub transaction: Transaction,
-    pub generated_access_list: Option<Vec<AccessListItem>>,
-    pub simulation: Simulation,
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
-pub struct Transaction {
-    pub status: bool,
-    pub gas_used: u64,
-    pub call_trace: Vec<CallTrace>,
-}
-
-#[serde_with::serde_as]
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
-pub struct CallTrace {
-    #[serde(default)]
-    #[serde_as(as = "Option<BytesHex>")]
-    pub output: Option<Vec<u8>>,
-    pub error: Option<String>,
-}
-
-// Had to introduce copy of the web3 AccessList because tenderly responds with
-// snake_case fields and tenderly storage_keys field does not exist if empty (it
-// should be empty Vec instead)
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
-pub struct AccessListItem {
-    /// Accessed address
-    pub address: Address,
-    /// Accessed storage keys
-    #[serde(default)]
-    pub storage_keys: Vec<B256>,
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
-pub struct Simulation {
-    pub id: String,
-}
-
-/// Tenderly API arguments.
-#[derive(Debug, Parser)]
-#[group(skip)]
-pub struct Arguments {
-    /// The Tenderly user associated with the API key.
-    #[clap(long, env)]
-    pub tenderly_user: Option<String>,
-
-    /// The Tenderly project associated with the API key.
-    #[clap(long, env)]
-    pub tenderly_project: Option<String>,
-
-    /// Tenderly requires api key to work. Optional since Tenderly could be
-    /// skipped in access lists estimators.
-    #[clap(long, env)]
-    pub tenderly_api_key: Option<String>,
-}
-
-impl Arguments {
-    pub fn get_api_instance(
-        &self,
-        http_factory: &HttpClientFactory,
-        name: String,
-    ) -> Result<Option<Arc<dyn TenderlyApi>>> {
-        Some(())
-            .and_then(|_| {
-                Some(
-                    TenderlyHttpApi::new(
-                        http_factory,
-                        self.tenderly_user.as_deref()?,
-                        self.tenderly_project.as_deref()?,
-                        self.tenderly_api_key.as_deref()?,
-                    )
-                    .map(|inner| Arc::new(Instrumented { inner, name }) as _),
-                )
-            })
-            .transpose()
-    }
-}
-
-impl Display for Arguments {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let Self {
-            tenderly_user,
-            tenderly_project,
-            tenderly_api_key,
-        } = self;
-
-        display_option(f, "tenderly_user", tenderly_user)?;
-        display_option(f, "tenderly_project", tenderly_project)?;
-        display_secret_option(f, "tenderly_api_key", tenderly_api_key.as_ref())?;
-
-        Ok(())
-    }
-}
-
-#[derive(prometheus_metric_storage::MetricStorage)]
-struct Metrics {
-    /// Tenderly simulations.
-    #[metric(labels("name", "result"))]
-    tenderly_simulations: IntGaugeVec,
-}
-
-impl Metrics {
-    fn get() -> &'static Metrics {
-        Metrics::instance(observe::metrics::get_storage_registry()).unwrap()
-    }
-}
-
-pub struct TenderlyCodeSimulator {
-    tenderly: Arc<dyn TenderlyApi>,
-    network_id: String,
-}
-
-impl TenderlyCodeSimulator {
-    pub fn new(tenderly: Arc<dyn TenderlyApi>, network_id: impl ToString) -> Self {
-        Self {
-            tenderly,
-            network_id: network_id.to_string(),
-        }
-    }
-
-    fn prepare_request(
-        &self,
-        tx: TransactionRequest,
-        overrides: AlloyStateOverride,
-        block: Option<u64>,
-    ) -> Result<SimulationRequest> {
-        Ok(SimulationRequest {
-            block_number: block,
-            // By default, tenderly simulates on the top of the specified block, whereas regular
-            // nodes simulate at the end of the specified block. This is to make
-            // simulation results match in case critical state changed within the block.
-            transaction_index: Some(-1),
-            network_id: self.network_id.clone(),
-            from: tx.from.unwrap_or_default(),
-            to: tx.to.and_then(TxKind::into_to).unwrap_or_default(),
-            input: tx.input.into_input().unwrap_or_default().to_vec(),
-            gas: tx.gas,
-            gas_price: tx
-                .gas_price
-                .map(TryInto::try_into)
-                .map(|gas_price| gas_price.unwrap()),
-            value: tx.value,
-            simulation_kind: Some(SimulationKind::Quick),
-            state_objects: Some(
-                overrides
-                    .into_iter()
-                    .map(|(key, value)| Ok((key, value.try_into()?)))
-                    .collect::<Result<_>>()?,
-            ),
-            ..Default::default()
-        })
-    }
-
-    pub fn log_simulation_command(
-        &self,
-        tx: TransactionRequest,
-        overrides: AlloyStateOverride,
-        block: Option<u64>,
-    ) -> Result<()> {
-        let request = SimulationRequest {
-            save: Some(true),
-            save_if_fails: Some(true),
-            ..self.prepare_request(tx, overrides, block)?
-        };
-        self.tenderly.log(request)
-    }
-}
-
-impl TryFrom<alloy::rpc::types::eth::state::AccountOverride> for StateObject {
-    type Error = anyhow::Error;
-
-    fn try_from(
-        value: alloy::rpc::types::eth::state::AccountOverride,
-    ) -> std::result::Result<Self, Self::Error> {
-        ensure!(
-            value.nonce.is_none() && value.state.is_none(),
-            "full state and nonce overrides not supported on Tenderly",
-        );
-
-        Ok(StateObject {
-            balance: value.balance,
-            code: value.code,
-            storage: value.state_diff,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        alloy::primitives::address,
-        hex_literal::hex,
-        serde_json::json,
-        testlib::assert_json_matches,
-    };
-
-    #[test]
-    fn serialize_deserialize_simulation_request() {
-        let request = SimulationRequest {
-            network_id: "1".to_string(),
-            block_number: Some(14122310),
-            from: address!("e92f359e6f05564849afa933ce8f62b8007a1d5d"),
-            input: hex!("13d79a0b00000000000000000000000000000000000000000000").into(),
-            to: address!("9008d19f58aabd9ed0d60971565aa8510560ab41"),
-            generate_access_list: Some(true),
-            transaction_index: None,
-            gas: None,
-            ..Default::default()
-        };
-
-        let json = json!({
-            "network_id": "1",
-            "block_number": 14122310,
-            "from": "0xe92f359e6f05564849afa933ce8f62b8007a1d5d",
-            "input": "0x13d79a0b00000000000000000000000000000000000000000000",
-            "to": "0x9008d19f58aabd9ed0d60971565aa8510560ab41",
-            "generate_access_list": true
-        });
-
-        assert_json_matches!(serde_json::to_value(&request).unwrap(), json);
-        assert_eq!(
-            serde_json::from_value::<SimulationRequest>(json).unwrap(),
-            request
-        );
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn simulate_transaction() {
-        let tenderly = TenderlyHttpApi::test_from_env();
-        let result = tenderly
-            .simulate(SimulationRequest {
-                network_id: "1".to_string(),
-                to: address!("9008d19f58aabd9ed0d60971565aa8510560ab41"),
-                simulation_kind: Some(SimulationKind::Quick),
-                ..Default::default()
-            })
-            .await
-            .unwrap();
-
-        assert!(result.transaction.status);
-    }
-}
diff --git a/crates/price-estimation/src/utils/encoding.rs b/crates/price-estimation/src/utils/encoding.rs
index 2f18e367a5..8b13789179 100644
--- a/crates/price-estimation/src/utils/encoding.rs
+++ b/crates/price-estimation/src/utils/encoding.rs
@@ -1,89 +1 @@
-use {
-    alloy::primitives::{Address, B256, Bytes, U256},
-    model::{
-        order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
-        signature::{Signature, SigningScheme},
-    },
-};
 
-pub type EncodedTrade = (
-    U256,    // sellTokenIndex
-    U256,    // buyTokenIndex
-    Address, // receiver
-    U256,    // sellAmount
-    U256,    // buyAmount
-    u32,     // validTo
-    B256,    // appData
-    U256,    // feeAmount
-    U256,    // flags
-    U256,    // executedAmount
-    Bytes,   // signature
-);
-
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct EncodedSettlement {
-    pub tokens: Vec<Address>,
-    pub clearing_prices: Vec<alloy::primitives::U256>,
-    pub trades: Vec<EncodedTrade>,
-    pub interactions: [Vec<EncodedInteraction>; 3],
-}
-
-pub type EncodedInteraction = (
-    Address, // target
-    U256,    // value
-    Bytes,   // callData
-);
-
-/// Creates the data which the smart contract's `decodeTrade` expects.
-pub fn encode_trade(
-    order: &OrderData,
-    signature: &Signature,
-    owner: Address,
-    sell_token_index: usize,
-    buy_token_index: usize,
-    executed_amount: U256,
-) -> EncodedTrade {
-    (
-        U256::from(sell_token_index),
-        U256::from(buy_token_index),
-        order.receiver.unwrap_or(Address::ZERO),
-        order.sell_amount,
-        order.buy_amount,
-        order.valid_to,
-        B256::new(order.app_data.0),
-        order.fee_amount,
-        order_flags(order, signature),
-        executed_amount,
-        Bytes::from(signature.encode_for_settlement(owner)),
-    )
-}
-
-fn order_flags(order: &OrderData, signature: &Signature) -> U256 {
-    let mut result = 0u8;
-    // The kind is encoded as 1 bit in position 0.
-    result |= match order.kind {
-        OrderKind::Sell => 0b0,
-        OrderKind::Buy => 0b1,
-    };
-    // The order fill kind is encoded as 1 bit in position 1.
-    result |= (order.partially_fillable as u8) << 1;
-    // The order sell token balance is encoded as 2 bits in position 2.
-    result |= match order.sell_token_balance {
-        SellTokenSource::Erc20 => 0b00,
-        SellTokenSource::External => 0b10,
-        SellTokenSource::Internal => 0b11,
-    } << 2;
-    // The order buy token balance is encoded as 1 bit in position 4.
-    result |= match order.buy_token_balance {
-        BuyTokenDestination::Erc20 => 0b0,
-        BuyTokenDestination::Internal => 0b1,
-    } << 4;
-    // The signing scheme is encoded as a 2 bits in position 5.
-    result |= match signature.scheme() {
-        SigningScheme::Eip712 => 0b00,
-        SigningScheme::EthSign => 0b01,
-        SigningScheme::Eip1271 => 0b10,
-        SigningScheme::PreSign => 0b11,
-    } << 5;
-    U256::from(result)
-}
diff --git a/crates/shared/src/encoded_settlement.rs b/crates/shared/src/encoded_settlement.rs
deleted file mode 100644
index ceca3aac28..0000000000
--- a/crates/shared/src/encoded_settlement.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-use {
-    crate::interaction::EncodedInteraction,
-    alloy::primitives::{Address, B256, Bytes, U256},
-    model::{
-        order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
-        signature::{Signature, SigningScheme},
-    },
-};
-
-pub type EncodedTrade = (
-    U256,    // sellTokenIndex
-    U256,    // buyTokenIndex
-    Address, // receiver
-    U256,    // sellAmount
-    U256,    // buyAmount
-    u32,     // validTo
-    B256,    // appData
-    U256,    // feeAmount
-    U256,    // flags
-    U256,    // executedAmount
-    Bytes,   // signature
-);
-
-/// Creates the data which the smart contract's `decodeTrade` expects.
-pub fn encode_trade(
-    order: &OrderData,
-    signature: &Signature,
-    owner: Address,
-    sell_token_index: usize,
-    buy_token_index: usize,
-    executed_amount: U256,
-) -> EncodedTrade {
-    (
-        U256::from(sell_token_index),
-        U256::from(buy_token_index),
-        order.receiver.unwrap_or(Address::ZERO),
-        order.sell_amount,
-        order.buy_amount,
-        order.valid_to,
-        B256::new(order.app_data.0),
-        order.fee_amount,
-        order_flags(order, signature),
-        executed_amount,
-        Bytes::from(signature.encode_for_settlement(owner)),
-    )
-}
-
-fn order_flags(order: &OrderData, signature: &Signature) -> U256 {
-    let mut result = 0u8;
-    // The kind is encoded as 1 bit in position 0.
-    result |= match order.kind {
-        OrderKind::Sell => 0b0,
-        OrderKind::Buy => 0b1,
-    };
-    // The order fill kind is encoded as 1 bit in position 1.
-    result |= (order.partially_fillable as u8) << 1;
-    // The order sell token balance is encoded as 2 bits in position 2.
-    result |= match order.sell_token_balance {
-        SellTokenSource::Erc20 => 0b00,
-        SellTokenSource::External => 0b10,
-        SellTokenSource::Internal => 0b11,
-    } << 2;
-    // The order buy token balance is encoded as 1 bit in position 4.
-    result |= match order.buy_token_balance {
-        BuyTokenDestination::Erc20 => 0b0,
-        BuyTokenDestination::Internal => 0b1,
-    } << 4;
-    // The signing scheme is encoded as a 2 bits in position 5.
-    result |= match signature.scheme() {
-        SigningScheme::Eip712 => 0b00,
-        SigningScheme::EthSign => 0b01,
-        SigningScheme::Eip1271 => 0b10,
-        SigningScheme::PreSign => 0b11,
-    } << 5;
-    U256::from(result)
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct EncodedSettlement {
-    pub tokens: Vec<Address>,
-    pub clearing_prices: Vec<alloy::primitives::U256>,
-    pub trades: Vec<EncodedTrade>,
-    pub interactions: [Vec<EncodedInteraction>; 3],
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, alloy::primitives::B256, hex_literal::hex, model::signature::EcdsaSignature};
-
-    #[test]
-    fn order_flag_permutations() {
-        for (order, scheme, flags) in [
-            (
-                OrderData {
-                    kind: OrderKind::Sell,
-                    partially_fillable: false,
-                    sell_token_balance: SellTokenSource::Erc20,
-                    buy_token_balance: BuyTokenDestination::Erc20,
-                    ..Default::default()
-                },
-                SigningScheme::Eip712,
-                // ......0 - sell order
-                // .....0. - fill-or-kill order
-                // ...00.. - ERC20 sell token balance
-                // ..0.... - ERC20 buy token balance
-                // 00..... - EIP-712 signing scheme
-                0b0000000,
-            ),
-            (
-                OrderData {
-                    kind: OrderKind::Sell,
-                    partially_fillable: true,
-                    sell_token_balance: SellTokenSource::Erc20,
-                    buy_token_balance: BuyTokenDestination::Internal,
-                    ..Default::default()
-                },
-                SigningScheme::Eip1271,
-                // ......0 - sell order
-                // .....1. - partially fillable order
-                // ...00.. - ERC20 sell token balance
-                // ..1.... - Vault-internal buy token balance
-                // 10..... - EIP-712 signing scheme
-                0b1010010,
-            ),
-            (
-                OrderData {
-                    kind: OrderKind::Buy,
-                    partially_fillable: false,
-                    sell_token_balance: SellTokenSource::External,
-                    buy_token_balance: BuyTokenDestination::Erc20,
-                    ..Default::default()
-                },
-                SigningScheme::PreSign,
-                // ......1 - buy order
-                // .....0. - fill-or-kill order
-                // ...10.. - Vault-external sell token balance
-                // ..0.... - ERC20 buy token balance
-                // 11..... - Pre-sign signing scheme
-                0b1101001,
-            ),
-            (
-                OrderData {
-                    kind: OrderKind::Sell,
-                    partially_fillable: false,
-                    sell_token_balance: SellTokenSource::Internal,
-                    buy_token_balance: BuyTokenDestination::Erc20,
-                    ..Default::default()
-                },
-                SigningScheme::EthSign,
-                // ......0 - sell order
-                // .....0. - fill-or-kill order
-                // ...11.. - Vault-internal sell token balance
-                // ..0.... - ERC20 buy token balance
-                // 01..... - Eth-sign signing scheme
-                0b0101100,
-            ),
-            (
-                OrderData {
-                    kind: OrderKind::Buy,
-                    partially_fillable: true,
-                    sell_token_balance: SellTokenSource::Internal,
-                    buy_token_balance: BuyTokenDestination::Internal,
-                    ..Default::default()
-                },
-                SigningScheme::PreSign,
-                // ......1 - buy order
-                // .....1. - partially fillable order
-                // ...11.. - Vault-internal sell token balance
-                // ..1.... - Vault-internal buy token balance
-                // 11..... - Pre-sign signing scheme
-                0b1111111,
-            ),
-        ] {
-            assert_eq!(
-                order_flags(&order, &Signature::default_with(scheme)),
-                U256::from(flags)
-            );
-        }
-    }
-
-    #[test]
-    fn trade_signature_encoding() {
-        let owner = Address::repeat_byte(1);
-        // Default EcdsaSignature has v = 27 (normalized for Solidity ecrecover)
-        let mut default_ecdsa_bytes = vec![0; 65];
-        default_ecdsa_bytes[64] = 27;
-        for (signature, bytes) in [
-            (Signature::Eip712(Default::default()), default_ecdsa_bytes),
-            (
-                Signature::EthSign(EcdsaSignature {
-                    r: B256::repeat_byte(1),
-                    s: B256::repeat_byte(1),
-                    v: 1,
-                }),
-                vec![1; 65],
-            ),
-            (
-                Signature::Eip1271(vec![1, 2, 3, 4]),
-                hex!(
-                    "0101010101010101010101010101010101010101"
-                    "01020304"
-                )
-                .to_vec(),
-            ),
-            (Signature::PreSign, vec![1; 20]),
-        ] {
-            let (.., encoded_signature) = encode_trade(
-                &Default::default(),
-                &signature,
-                owner,
-                Default::default(),
-                Default::default(),
-                Default::default(),
-            );
-            assert_eq!(encoded_signature.0, bytes);
-        }
-    }
-}
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 7c036790cc..aebbb50b83 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -4,7 +4,6 @@ pub mod macros;
 pub mod arguments;
 pub mod current_block;
 pub mod db_order_conversions;
-pub mod encoded_settlement;
 pub mod event_storing_helpers;
 pub mod external_prices;
 pub mod fee;
diff --git a/crates/simulator/Cargo.toml b/crates/simulator/Cargo.toml
new file mode 100644
index 0000000000..1b4777003b
--- /dev/null
+++ b/crates/simulator/Cargo.toml
@@ -0,0 +1,52 @@
+[package]
+name = "simulator"
+version = "0.1.0"
+authors = ["Cow Protocol Developers <dev@cow.fi>"]
+edition = "2024"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-eips = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-rpc-types = { workspace = true }
+alloy-sol-types = { workspace = true }
+alloy-transport = { workspace = true }
+anyhow = { workspace = true }
+app-data = { workspace = true }
+async-trait = { workspace = true }
+balance-overrides = { workspace = true }
+cached = { workspace = true }
+chain = { workspace = true }
+configs = { workspace = true }
+const-hex = { workspace = true }
+contracts = { workspace = true }
+derive_more = { workspace = true }
+eth-domain-types = { workspace = true }
+ethrpc = { workspace = true }
+gas-price-estimation = { workspace = true }
+hex-literal = { workspace = true }
+http-client = { workspace = true }
+mockall = { workspace = true, optional = true }
+model = { workspace = true }
+number = { workspace = true }
+observe = { workspace = true }
+prometheus = { workspace = true }
+prometheus-metric-storage = { workspace = true }
+reqwest = { workspace = true }
+serde = { workspace = true }
+serde-ext = { workspace = true }
+serde_json = { workspace = true }
+serde_with = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+url = { workspace = true }
+
+[dev-dependencies]
+mockall = { workspace = true }
+testlib = { workspace = true }
+tokio = { workspace = true }
+
+[features]
+test-util = ["dep:mockall"]
diff --git a/crates/simulator/src/encoding.rs b/crates/simulator/src/encoding.rs
new file mode 100644
index 0000000000..da4771bfc2
--- /dev/null
+++ b/crates/simulator/src/encoding.rs
@@ -0,0 +1,232 @@
+use {
+    alloy_primitives::{Address, B256, Bytes, U256},
+    alloy_sol_types::SolCall,
+    app_data::AppDataHash,
+    contracts::alloy::GPv2Settlement,
+    derive_more::Debug,
+    model::{
+        interaction::InteractionData,
+        order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
+        signature::{Signature, SigningScheme},
+    },
+    number::serialization::HexOrDecimalU256,
+    serde::{Deserialize, Serialize},
+    serde_with::serde_as,
+};
+
+pub type EncodedTrade = (
+    U256,    // sellTokenIndex
+    U256,    // buyTokenIndex
+    Address, // receiver
+    U256,    // sellAmount
+    U256,    // buyAmount
+    u32,     // validTo
+    B256,    // appData
+    U256,    // feeAmount
+    U256,    // flags
+    U256,    // executedAmount
+    Bytes,   // signature
+);
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Interactions {
+    pub pre: Vec<EncodedInteraction>,
+    pub main: Vec<EncodedInteraction>,
+    pub post: Vec<EncodedInteraction>,
+}
+
+impl Interactions {
+    pub fn into_array(self) -> [Vec<EncodedInteraction>; 3] {
+        [self.pre, self.main, self.post]
+    }
+}
+
+impl IntoIterator for Interactions {
+    type IntoIter = std::array::IntoIter<Vec<EncodedInteraction>, 3>;
+    type Item = Vec<EncodedInteraction>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        [self.pre, self.main, self.post].into_iter()
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct EncodedSettlement {
+    pub tokens: Vec<Address>,
+    pub clearing_prices: Vec<U256>,
+    pub trades: Vec<EncodedTrade>,
+    pub interactions: Interactions,
+}
+
+impl EncodedSettlement {
+    pub fn into_settle_call(&self) -> Bytes {
+        GPv2Settlement::GPv2Settlement::settleCall {
+            tokens: self.tokens.clone(),
+            clearingPrices: self.clearing_prices.clone(),
+            interactions: self.interactions.clone().into_array().map(|interactions| {
+                interactions
+                    .into_iter()
+                    .map(|i| GPv2Settlement::GPv2Interaction::Data {
+                        target: i.0,
+                        value: i.1,
+                        callData: i.2.0.into(),
+                    })
+                    .collect()
+            }),
+            trades: self
+                .trades
+                .iter()
+                .map(|t| GPv2Settlement::GPv2Trade::Data {
+                    sellTokenIndex: t.0,
+                    buyTokenIndex: t.1,
+                    receiver: t.2,
+                    sellAmount: t.3,
+                    buyAmount: t.4,
+                    validTo: t.5,
+                    appData: t.6,
+                    feeAmount: t.7,
+                    flags: t.8,
+                    executedAmount: t.9,
+                    signature: t.10.clone(),
+                })
+                .collect(),
+        }
+        .abi_encode()
+        .into()
+    }
+}
+
+pub type EncodedInteraction = (
+    Address, // target
+    U256,    // value
+    Bytes,   // callData
+);
+
+#[serde_as]
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JitOrder {
+    pub buy_token: Address,
+    pub sell_token: Address,
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub sell_amount: U256,
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub buy_amount: U256,
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub executed_amount: U256,
+    pub receiver: Address,
+    pub valid_to: u32,
+    pub app_data: AppDataHash,
+    pub side: Side,
+    pub partially_fillable: bool,
+    pub sell_token_source: SellTokenSource,
+    pub buy_token_destination: BuyTokenDestination,
+    #[serde_as(as = "serde_ext::Hex")]
+    pub signature: Vec<u8>,
+    pub signing_scheme: SigningScheme,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Side {
+    Buy,
+    Sell,
+}
+
+/// Creates the data which the smart contract's `decodeTrade` expects.
+pub fn encode_trade(
+    order: &OrderData,
+    signature: &Signature,
+    owner: Address,
+    sell_token_index: usize,
+    buy_token_index: usize,
+    executed_amount: U256,
+) -> EncodedTrade {
+    (
+        U256::from(sell_token_index),
+        U256::from(buy_token_index),
+        order.receiver.unwrap_or(Address::ZERO),
+        order.sell_amount,
+        order.buy_amount,
+        order.valid_to,
+        B256::new(order.app_data.0),
+        order.fee_amount,
+        order_flags(order, signature),
+        executed_amount,
+        Bytes::from(signature.encode_for_settlement(owner)),
+    )
+}
+
+fn order_flags(order: &OrderData, signature: &Signature) -> U256 {
+    let mut result = 0u8;
+    // The kind is encoded as 1 bit in position 0.
+    result |= match order.kind {
+        OrderKind::Sell => 0b0,
+        OrderKind::Buy => 0b1,
+    };
+    // The order fill kind is encoded as 1 bit in position 1.
+    result |= (order.partially_fillable as u8) << 1;
+    // The order sell token balance is encoded as 2 bits in position 2.
+    result |= match order.sell_token_balance {
+        SellTokenSource::Erc20 => 0b00,
+        SellTokenSource::External => 0b10,
+        SellTokenSource::Internal => 0b11,
+    } << 2;
+    // The order buy token balance is encoded as 1 bit in position 4.
+    result |= match order.buy_token_balance {
+        BuyTokenDestination::Erc20 => 0b0,
+        BuyTokenDestination::Internal => 0b1,
+    } << 4;
+    // The signing scheme is encoded as a 2 bits in position 5.
+    result |= match signature.scheme() {
+        SigningScheme::Eip712 => 0b00,
+        SigningScheme::EthSign => 0b01,
+        SigningScheme::Eip1271 => 0b10,
+        SigningScheme::PreSign => 0b11,
+    } << 5;
+    U256::from(result)
+}
+
+/// Data for a raw GPv2 interaction.
+#[derive(Clone, PartialEq, Eq, Hash, Default, Serialize, Debug)]
+pub struct Interaction {
+    pub target: Address,
+    pub value: U256,
+    #[debug("{}", const_hex::encode_prefixed::<&[u8]>(data.as_ref()))]
+    pub data: Vec<u8>,
+}
+
+impl Interaction {
+    pub fn encode(&self) -> EncodedInteraction {
+        (
+            self.target,
+            self.value,
+            Bytes::copy_from_slice(self.data.as_slice()),
+        )
+    }
+
+    pub fn to_interaction_data(&self) -> InteractionData {
+        InteractionData {
+            target: self.target,
+            value: self.value,
+            call_data: self.data.clone(),
+        }
+    }
+}
+
+impl From<InteractionData> for Interaction {
+    fn from(interaction: InteractionData) -> Self {
+        Self {
+            target: interaction.target,
+            value: interaction.value,
+            data: interaction.call_data,
+        }
+    }
+}
+
+pub fn encode_interactions<'a>(
+    interactions: impl IntoIterator<Item = &'a Interaction>,
+) -> Vec<EncodedInteraction> {
+    interactions.into_iter().map(|i| i.encode()).collect()
+}
diff --git a/crates/driver/src/infra/simulator/enso/dto.rs b/crates/simulator/src/enso/dto.rs
similarity index 96%
rename from crates/driver/src/infra/simulator/enso/dto.rs
rename to crates/simulator/src/enso/dto.rs
index bad005260c..1a5d2d484e 100644
--- a/crates/driver/src/infra/simulator/enso/dto.rs
+++ b/crates/simulator/src/enso/dto.rs
@@ -1,7 +1,7 @@
 //! Data transfer objects for interacting with the Enso Trade Simulator API.
 
 use {
-    alloy::rpc::types::AccessList,
+    alloy_rpc_types::AccessList,
     eth_domain_types as eth,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
diff --git a/crates/driver/src/infra/simulator/enso/mod.rs b/crates/simulator/src/enso/mod.rs
similarity index 89%
rename from crates/driver/src/infra/simulator/enso/mod.rs
rename to crates/simulator/src/enso/mod.rs
index c60d6cb553..780ccf03d7 100644
--- a/crates/driver/src/infra/simulator/enso/mod.rs
+++ b/crates/simulator/src/enso/mod.rs
@@ -12,23 +12,19 @@ mod dto;
 const GAS_LIMIT: u64 = 30_000_000;
 
 #[derive(Debug, Clone)]
-pub(super) struct Enso {
+pub struct Enso {
     url: reqwest::Url,
     chain: Chain,
     current_block: CurrentBlockWatcher,
     network_block_interval: Option<Duration>,
 }
 
-#[derive(Debug, Clone)]
-pub struct Config {
-    /// The URL of the Transaction Simulator API.
-    pub url: reqwest::Url,
-    /// The time between new blocks in the network.
-    pub network_block_interval: Option<Duration>,
-}
-
 impl Enso {
-    pub(super) fn new(config: Config, chain: Chain, current_block: CurrentBlockWatcher) -> Self {
+    pub(super) fn new(
+        config: &configs::simulator::EnsoConfig,
+        chain: Chain,
+        current_block: CurrentBlockWatcher,
+    ) -> Self {
         Self {
             url: reqwest::Url::parse(&format!("{}api/v1/simulate", config.url)).unwrap(),
             chain,
diff --git a/crates/simulator/src/ethereum/contracts.rs b/crates/simulator/src/ethereum/contracts.rs
new file mode 100644
index 0000000000..8b51f55455
--- /dev/null
+++ b/crates/simulator/src/ethereum/contracts.rs
@@ -0,0 +1,33 @@
+use {
+    chain::Chain,
+    configs::simulator::Addresses,
+    contracts::alloy::{GPv2Settlement, WETH9},
+    ethrpc::Web3,
+};
+
+#[derive(Debug, Clone)]
+pub struct Contracts {
+    pub settlement: GPv2Settlement::Instance,
+    pub weth: WETH9::Instance,
+}
+
+impl Contracts {
+    pub fn new(web3: Web3, chain: Chain, addresses: Addresses) -> Self {
+        let settlement = GPv2Settlement::Instance::new(
+            addresses
+                .settlement
+                .or_else(|| GPv2Settlement::deployment_address(&chain.id()))
+                .unwrap(),
+            web3.provider.clone(),
+        );
+        let weth = WETH9::Instance::new(
+            addresses
+                .weth
+                .or_else(|| WETH9::deployment_address(&chain.id()))
+                .unwrap(),
+            web3.provider.clone(),
+        );
+
+        Self { settlement, weth }
+    }
+}
diff --git a/crates/simulator/src/ethereum/mod.rs b/crates/simulator/src/ethereum/mod.rs
new file mode 100644
index 0000000000..447aafa0ab
--- /dev/null
+++ b/crates/simulator/src/ethereum/mod.rs
@@ -0,0 +1,159 @@
+use {
+    crate::ethereum::contracts::Contracts,
+    alloy_primitives::U256,
+    alloy_provider::{Provider, network::TransactionBuilder},
+    alloy_rpc_types::TransactionRequest,
+    anyhow::{Result, anyhow},
+    chain::Chain,
+    eth_domain_types::AccessList,
+    ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
+    gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
+    std::sync::Arc,
+    thiserror::Error,
+    tracing::{Level, instrument},
+};
+
+pub mod contracts;
+
+#[derive(Clone)]
+pub struct Ethereum {
+    web3: Web3,
+    inner: Arc<Inner>,
+}
+
+struct Inner {
+    chain: Chain,
+    contracts: Contracts,
+    gas: Arc<dyn GasPriceEstimating>,
+    current_block: CurrentBlockWatcher,
+    tx_gas_limit: U256,
+}
+
+impl Ethereum {
+    pub fn new(
+        web3: Web3,
+        chain: Chain,
+        addresses: configs::simulator::Addresses,
+        gas: Arc<dyn GasPriceEstimating>,
+        current_block: CurrentBlockWatcher,
+        tx_gas_limit: U256,
+    ) -> Self {
+        Self {
+            web3: web3.clone(),
+            inner: Arc::new(Inner {
+                chain,
+                contracts: Contracts::new(web3.clone(), chain, addresses),
+                gas,
+                current_block,
+                tx_gas_limit,
+            }),
+        }
+    }
+
+    #[instrument(skip(self), ret(level = Level::DEBUG))]
+    pub(super) async fn simulation_gas_price(&self) -> Option<u128> {
+        let base_fee = self.inner.current_block.borrow().base_fee;
+        // Some nodes don't pick a reasonable default value when you don't specify a gas
+        // price and default to 0. Additionally some sneaky tokens have special code
+        // paths that detect that case to try to behave differently during simulations
+        // than they normally would. To not rely on the node picking a reasonable
+        // default value we estimate the current gas price upfront. But because it's
+        // extremely rare that tokens behave that way we are fine with falling back to
+        // the node specific fallback value instead of failing the whole call.
+        Some(self.inner.gas.estimate().await.ok()?.effective(base_fee))
+    }
+
+    pub fn chain(&self) -> Chain {
+        self.inner.chain
+    }
+
+    pub fn current_block(&self) -> &CurrentBlockWatcher {
+        &self.inner.current_block
+    }
+
+    pub fn web3(&self) -> &Web3 {
+        &self.web3
+    }
+
+    /// Clones self and returns an instance that captures metrics extended with
+    /// the provided label.
+    pub fn with_metric_label(&self, label: String) -> Self {
+        Self {
+            web3: self.web3.labeled(label),
+            ..self.clone()
+        }
+    }
+
+    pub async fn create_access_list<T>(&self, tx: T) -> Result<AccessList, Error>
+    where
+        T: Into<TransactionRequest>,
+    {
+        let gas_limit = self.inner.tx_gas_limit.try_into().map_err(|err| {
+            Error::GasPrice(anyhow!("failed to convert gas_limit to u64: {err:?}"))
+        })?;
+        let tx = tx.into().with_gas_limit(gas_limit);
+        let tx = match self.simulation_gas_price().await {
+            Some(gas_price) => tx.with_gas_price(gas_price),
+            _ => tx,
+        };
+        let access_list = self
+            .web3
+            .provider
+            .create_access_list(&tx)
+            .pending()
+            .await
+            .map_err(Error::Rpc)?;
+        Ok(access_list
+            .ensure_ok()
+            .map_err(Error::AccessList)?
+            .access_list
+            .into())
+    }
+
+    pub async fn estimate_gas<T>(&self, tx: T) -> Result<eth_domain_types::Gas, Error>
+    where
+        T: Into<TransactionRequest>,
+    {
+        let tx = tx.into();
+        let tx = match self.simulation_gas_price().await {
+            Some(gas_price) => tx.with_gas_price(gas_price),
+            _ => tx,
+        };
+
+        let estimated_gas = self
+            .web3
+            .provider
+            .estimate_gas(tx)
+            .pending()
+            .await
+            .map_err(Error::Rpc)?
+            .into();
+
+        Ok(estimated_gas)
+    }
+}
+
+impl std::fmt::Debug for Ethereum {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("Ethereum")
+            .field("web3", &self.web3)
+            .field("chain", &self.inner.chain)
+            .field("contracts", &self.inner.contracts)
+            .field("gas", &"Arc<NativeGasEstimator>")
+            .finish()
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("method error: {0:?}")]
+    ContractRpc(#[from] alloy_contract::Error),
+    #[error("alloy rpc error: {0:?}")]
+    Rpc(#[from] alloy_transport::RpcError<alloy_transport::TransportErrorKind>),
+    #[error("gas price estimation error: {0}")]
+    GasPrice(anyhow::Error),
+    #[error("access list estimation error: {0:?}")]
+    AccessList(String),
+    #[error("other error: {0:?}")]
+    Other(anyhow::Error),
+}
diff --git a/crates/driver/src/infra/simulator/mod.rs b/crates/simulator/src/lib.rs
similarity index 78%
rename from crates/driver/src/infra/simulator/mod.rs
rename to crates/simulator/src/lib.rs
index d03988fece..22726b9096 100644
--- a/crates/driver/src/infra/simulator/mod.rs
+++ b/crates/simulator/src/lib.rs
@@ -1,43 +1,47 @@
+pub mod encoding;
+pub mod enso;
+pub mod ethereum;
+pub mod swap_simulator;
+pub mod tenderly;
+mod utils;
+
+pub use {enso::Enso, ethereum::Ethereum, tenderly::Tenderly};
 use {
-    crate::infra::blockchain::{self, Ethereum},
-    eth_domain_types as eth,
+    eth_domain_types::{self as eth, AccessList, Tx},
+    http_client::HttpClientFactory,
     observe::future::Measure,
 };
 
-pub mod enso;
-pub mod tenderly;
-
-/// Ethereum transaction simulator.
 #[derive(Debug, Clone)]
 pub struct Simulator {
     inner: Inner,
     eth: Ethereum,
     disable_access_lists: bool,
-    /// If this is [`Some`], every gas estimate will return this fixed
-    /// gas value.
     disable_gas: Option<eth::Gas>,
 }
 
-/// Configuration of the transaction simulator.
-#[derive(Debug)]
-pub enum Config {
-    Tenderly(tenderly::Config),
-    Enso(enso::Config),
+#[derive(Debug, Clone)]
+enum Inner {
+    Tenderly(tenderly::Tenderly),
+    Ethereum,
+    Enso(enso::Enso),
 }
 
 impl Simulator {
-    /// Simulate transactions on [Tenderly](https://tenderly.co/).
-    pub fn tenderly(config: tenderly::Config, eth: Ethereum) -> Self {
+    pub fn tenderly(
+        config: &configs::simulator::TenderlyConfig,
+        eth: Ethereum,
+        http_factory: &HttpClientFactory,
+    ) -> Self {
         let eth = eth.with_metric_label("tenderlySimulator".into());
         Self {
-            inner: Inner::Tenderly(tenderly::Tenderly::new(config, eth.clone())),
+            inner: Inner::Tenderly(tenderly::Tenderly::new(config, eth.clone(), http_factory)),
             eth,
             disable_access_lists: false,
             disable_gas: None,
         }
     }
 
-    /// Simulate transactions using the Ethereum RPC API.
     pub fn ethereum(eth: Ethereum) -> Self {
         let eth = eth.with_metric_label("web3Simulator".into());
         Self {
@@ -48,9 +52,7 @@ impl Simulator {
         }
     }
 
-    /// Simulate transactions using the [Enso Simulator](https://github.com/EnsoFinance/transaction-simulator).
-    /// Uses Ethereum RPC API to generate access lists.
-    pub fn enso(config: enso::Config, eth: Ethereum) -> Self {
+    pub fn enso(config: &configs::simulator::EnsoConfig, eth: Ethereum) -> Self {
         let eth = eth.with_metric_label("ensoSimulator".into());
         Self {
             inner: Inner::Enso(enso::Enso::new(
@@ -79,7 +81,7 @@ impl Simulator {
     /// Simulate the access list needed by a transaction. If the transaction
     /// already has an access list, the returned access list will be a
     /// superset of the existing one.
-    pub async fn access_list(&self, tx: &eth::Tx) -> Result<eth::AccessList, Error> {
+    pub async fn access_list(&self, tx: &Tx) -> Result<AccessList, Error> {
         if self.disable_access_lists {
             return Ok(tx.access_list.clone());
         }
@@ -87,7 +89,7 @@ impl Simulator {
         let access_list = match &self.inner {
             Inner::Tenderly(tenderly) => {
                 tenderly
-                    .simulate(tx, tenderly::GenerateAccessList::Yes)
+                    .simulate(tx.clone(), block, tenderly::GenerateAccessList::Yes)
                     .await
                     .map_err(with(tx.clone(), block))?
                     .access_list
@@ -115,7 +117,7 @@ impl Simulator {
         Ok(match &self.inner {
             Inner::Tenderly(tenderly) => {
                 tenderly
-                    .simulate(tx, tenderly::GenerateAccessList::No)
+                    .simulate(tx.clone(), block, tenderly::GenerateAccessList::No)
                     .measure("tenderly_simulate_gas")
                     .await
                     .map_err(with(tx.clone(), block))?
@@ -135,19 +137,12 @@ impl Simulator {
     }
 }
 
-#[derive(Debug, Clone)]
-enum Inner {
-    Tenderly(tenderly::Tenderly),
-    Ethereum,
-    Enso(enso::Enso),
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum SimulatorError {
     #[error("tenderly error: {0:?}")]
     Tenderly(#[from] tenderly::Error),
-    #[error("blockchain error: {0:?}")]
-    Blockchain(#[from] blockchain::Error),
+    #[error("ethereum error: {0:?}")]
+    Ethereum(#[from] ethereum::Error),
     #[error("enso error: {0:?}")]
     Enso(#[from] enso::Error),
     #[error("the simulated gas {0} exceeded the gas limit {1} provided in the solution")]
@@ -158,7 +153,7 @@ pub enum SimulatorError {
 #[error("block: {block},  err: {err:?}, tx: {tx:?}")]
 pub struct RevertError {
     pub err: SimulatorError,
-    pub tx: eth::Tx,
+    pub tx: Tx,
     pub block: eth::BlockNo,
 }
 
@@ -174,7 +169,7 @@ pub enum Error {
     Other(#[from] SimulatorError),
 }
 
-fn with<E>(tx: eth::Tx, block: eth::BlockNo) -> impl FnOnce(E) -> Error
+fn with<E>(tx: Tx, block: eth::BlockNo) -> impl FnOnce(E) -> Error
 where
     E: Into<SimulatorError>,
 {
@@ -182,14 +177,19 @@ where
         let err: SimulatorError = err.into();
         let tx = match &err {
             SimulatorError::Tenderly(tenderly::Error::Http(_)) => None,
-            SimulatorError::Tenderly(tenderly::Error::Revert(_)) => Some(tx),
-            SimulatorError::Blockchain(_) => Some(tx),
+            SimulatorError::Tenderly(tenderly::Error::Revert(_)) => Some(tx.clone()),
+            SimulatorError::Tenderly(tenderly::Error::Other(_)) => None,
+            SimulatorError::Ethereum(_) => Some(tx.clone()),
             SimulatorError::Enso(enso::Error::Http(_)) => None,
-            SimulatorError::Enso(enso::Error::Revert(_)) => Some(tx),
-            SimulatorError::GasExceeded(..) => Some(tx),
+            SimulatorError::Enso(enso::Error::Revert(_)) => Some(tx.clone()),
+            SimulatorError::GasExceeded(..) => Some(tx.clone()),
         };
         match tx {
-            Some(tx) => Error::Revert(RevertError { err, tx, block }),
+            Some(tx) => Error::Revert(RevertError {
+                err,
+                tx: tx.clone(),
+                block,
+            }),
             None => Error::Other(err),
         }
     }
diff --git a/crates/simulator/src/swap_simulator.rs b/crates/simulator/src/swap_simulator.rs
new file mode 100644
index 0000000000..1fdee7fb43
--- /dev/null
+++ b/crates/simulator/src/swap_simulator.rs
@@ -0,0 +1,259 @@
+use {
+    crate::encoding::{EncodedSettlement, EncodedTrade, Interaction, Interactions, encode_trade},
+    alloy_primitives::{Address, U256, address},
+    alloy_rpc_types::{TransactionRequest, state::StateOverride},
+    alloy_sol_types::SolCall,
+    anyhow::{Context, Result, anyhow},
+    balance_overrides::BalanceOverriding,
+    contracts::alloy::{GPv2Settlement, WETH9, support::Solver},
+    eth_domain_types::NonZeroU256,
+    ethrpc::{Web3, block_stream::CurrentBlockWatcher},
+    model::{
+        DomainSeparator,
+        order::{BUY_ETH_ADDRESS, BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
+        signature::{Signature, SigningScheme},
+    },
+    std::sync::Arc,
+};
+
+/// Query for the Swap Simulator to prepare a fake settlement with
+/// Contains the minimum data required to encode a fake settlement
+pub struct Query {
+    /// The input token, transferred into settlement contract
+    pub in_token: Address,
+    pub in_amount: NonZeroU256,
+    /// The output token, transferred out of settlemetn contract
+    pub out_token: Address,
+    pub out_amount: U256,
+    pub kind: OrderKind,
+    pub receiver: Address,
+    pub sell_token_source: SellTokenSource,
+    pub buy_token_destination: BuyTokenDestination,
+    pub from: Address,
+    pub tx_origin: Option<Address>,
+    /// These interactions will be executed before the trade.
+    // pub pre_interactions: Vec<Interaction>,
+    /// Interactions needed to produce the expected trade amount.
+    // pub interactions: Vec<Interaction>,
+    /// These interactions will be executed after the trade.
+    // pub post_interactions: Vec<Interaction>,
+    pub solver: Address,
+    pub tokens: Vec<Address>,
+    pub clearing_prices: Vec<U256>,
+}
+
+#[derive(Clone)]
+pub struct SwapSimulator {
+    pub balance_overrides: Arc<dyn BalanceOverriding>,
+    pub settlement: GPv2Settlement::Instance,
+    pub native_token: Address,
+    pub domain_separator: DomainSeparator,
+    pub current_block: CurrentBlockWatcher,
+    pub web3: Web3,
+    pub gas_limit: u64,
+}
+
+pub struct EncodedSwap {
+    pub settlement: EncodedSettlement,
+    pub overrides: StateOverride,
+    pub solver: Address,
+    pub receiver: Address,
+}
+
+// Look into driver encoding logic for wrappers
+pub struct SwapSimulation {
+    pub tx: TransactionRequest,
+    pub overrides: StateOverride,
+    pub result: Result<Solver::Solver::swapReturn, anyhow::Error>,
+}
+
+impl SwapSimulator {
+    const SPARDOSE: Address = address!("0000000000000000000000000000000000020000");
+
+    pub async fn new(
+        balance_overrides: Arc<dyn BalanceOverriding>,
+        settlement: Address,
+        native_token: Address,
+        current_block: CurrentBlockWatcher,
+        web3: Web3,
+        gas_limit: u64,
+    ) -> Result<Self> {
+        let settlement = GPv2Settlement::GPv2Settlement::new(settlement, web3.provider.clone());
+        let domain_separator = DomainSeparator(settlement.domainSeparator().call().await?.0);
+
+        Ok(Self {
+            balance_overrides,
+            settlement,
+            native_token,
+            current_block,
+            web3,
+            gas_limit,
+            domain_separator,
+        })
+    }
+
+    /// Creates a fake swap based on the provided query
+    /// The result can be further post processed depending on the needs
+    ///
+    /// It can then be simulated with SwapSimulator::simulate_swap
+    pub async fn fake_swap(&self, query: Query) -> Result<EncodedSwap> {
+        let overrides = StateOverride::default();
+
+        let pre_interactions = vec![self.trade_setup_interaction(&query).encode()];
+        let mut interactions = vec![];
+
+        if query.out_token == BUY_ETH_ADDRESS {
+            // Because the `driver` manages `WETH` unwraps under the hood the `TradeFinder`
+            // does not have to emit unwraps to pay out `ETH` in a trade.
+            // However, for the simulation to be successful this has to happen so we do it
+            // ourselves here.
+            let buy_amount = match query.kind {
+                OrderKind::Sell => query.out_amount,
+                OrderKind::Buy => query.in_amount.get(),
+            };
+            interactions.push((
+                self.native_token,
+                U256::ZERO,
+                WETH9::WETH9::withdrawCall { wad: buy_amount }
+                    .abi_encode()
+                    .into(),
+            ));
+            tracing::trace!("adding unwrap interaction for paying out ETH");
+        }
+
+        Ok(EncodedSwap {
+            settlement: EncodedSettlement {
+                tokens: query.tokens.to_vec(),
+                clearing_prices: query.clearing_prices.to_vec(),
+                trades: vec![encode_fake_trade(&query)?],
+                interactions: Interactions {
+                    pre: pre_interactions,
+                    main: interactions,
+                    post: vec![],
+                },
+            },
+            solver: query.tx_origin.unwrap_or(query.solver),
+            receiver: query.receiver,
+            overrides,
+        })
+    }
+
+    /// Simulates a solver call to settlement contract with the provided swap
+    /// data. The swap call result is contained in the returned
+    /// SwapSimulation struct, along with the original TransactionRequest
+    /// and State overrides (if needed to be logged, or processed elsewhere)
+    pub async fn simulate_swap(&self, swap: EncodedSwap) -> Result<SwapSimulation> {
+        let block = *self.current_block.borrow();
+        let solver = Solver::Instance::new(swap.solver, self.web3.provider.clone());
+        let calldata = swap.settlement.into_settle_call();
+        let overrides = swap.overrides;
+
+        let swap = solver
+            .swap(
+                *self.settlement.address(),
+                swap.settlement.tokens.clone(),
+                swap.receiver,
+                calldata,
+            )
+            .from(swap.solver)
+            .to(swap.solver)
+            .gas(self.gas_limit)
+            .gas_price(
+                u128::try_from(block.gas_price.saturating_mul(U256::from(2)))
+                    .map_err(|err| anyhow!(err))
+                    .context("converting gas price to u128")?,
+            );
+
+        // Save the transaction request, so the caller can inspect it.
+        // For example, to create a tenderly API request and provide the ability to
+        // simulate it.
+        let tx = swap.clone().into_transaction_request();
+        let result = swap
+            .call()
+            .overrides(overrides.clone())
+            .await
+            .map_err(|err| anyhow!(err))
+            .context("failed to simulate swap");
+
+        Ok(SwapSimulation {
+            tx,
+            overrides,
+            result,
+        })
+    }
+
+    /// Create interaction that sets up the trade right before transfering
+    /// funds. This interaction does nothing if the user-provided
+    /// pre-interactions already set everything up (e.g. approvals,
+    /// balances). That way we can correctly verify quotes with or without
+    /// these user pre-interactions with helpful error messages.
+    fn trade_setup_interaction(&self, query: &Query) -> Interaction {
+        let sell_amount = match query.kind {
+            OrderKind::Sell => query.in_amount.get(),
+            OrderKind::Buy => query.out_amount,
+        };
+        let setup_call = Solver::Solver::ensureTradePreconditionsCall {
+            trader: query.from,
+            settlementContract: *self.settlement.address(),
+            sellToken: query.in_token,
+            sellAmount: sell_amount,
+            nativeToken: self.native_token,
+            spardose: Self::SPARDOSE,
+        }
+        .abi_encode();
+        Interaction {
+            target: query.solver,
+            value: U256::ZERO,
+            data: setup_call,
+        }
+    }
+}
+
+/// Encodes a trade with the most disadvantageous in and out amounts possible
+/// (while taking possible overflows into account). Should the trader not
+/// receive the amount promised by the [`Trade`] the simulation will still work
+/// and the actual [`Trade::out_amount`] can be computed afterwards.
+fn encode_fake_trade(query: &Query) -> Result<EncodedTrade> {
+    let (sell_amount, buy_amount) = match query.kind {
+        OrderKind::Sell => (query.in_amount.get(), U256::ZERO),
+        OrderKind::Buy => (
+            (query.out_amount).max(U256::from(u128::MAX)),
+            query.in_amount.get(),
+        ),
+    };
+    let fake_order = OrderData {
+        sell_token: query.in_token,
+        sell_amount,
+        buy_token: query.out_token,
+        buy_amount,
+        receiver: Some(query.receiver),
+        valid_to: u32::MAX,
+        app_data: Default::default(),
+        fee_amount: U256::ZERO,
+        kind: query.kind,
+        partially_fillable: false,
+        sell_token_balance: query.sell_token_source,
+        buy_token_balance: query.buy_token_destination,
+    };
+
+    let fake_signature = Signature::default_with(SigningScheme::Eip1271);
+    let encoded_trade = encode_trade(
+        &fake_order,
+        &fake_signature,
+        query.from,
+        // the tokens set length is small so the linear search is acceptable
+        query
+            .tokens
+            .iter()
+            .position(|token| token == &query.in_token)
+            .context("missing sell token index")?,
+        query
+            .tokens
+            .iter()
+            .position(|token| token == &query.out_token)
+            .context("missing buy token index")?,
+        query.in_amount.get(),
+    );
+
+    Ok(encoded_trade)
+}
diff --git a/crates/simulator/src/tenderly/dto.rs b/crates/simulator/src/tenderly/dto.rs
new file mode 100644
index 0000000000..0834d1e51d
--- /dev/null
+++ b/crates/simulator/src/tenderly/dto.rs
@@ -0,0 +1,180 @@
+use {
+    alloy_primitives::{Address, B256, U256, map::B256Map},
+    eth_domain_types as eth,
+    serde::{Deserialize, Serialize},
+    serde_with::serde_as,
+    std::collections::HashMap,
+};
+
+#[serde_as]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct Request {
+    pub network_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub block_number: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub transaction_index: Option<i64>,
+    pub from: Address,
+    pub to: Address,
+    #[serde_as(as = "serde_ext::Hex")]
+    pub input: Vec<u8>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gas: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gas_price: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub value: Option<U256>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub simulation_kind: Option<SimulationKind>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub save: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub save_if_fails: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub generate_access_list: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state_objects: Option<HashMap<Address, StateObject>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub access_list: Option<AccessList>,
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct Response {
+    pub transaction: Transaction,
+    pub generated_access_list: Option<AccessList>,
+    pub simulation: Simulation,
+}
+
+// Tenderly responds with
+// snake_case fields and tenderly storage_keys field does not exist
+// if empty (it should be empty Vec instead)
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct AccessListItem {
+    /// Accessed address
+    pub address: Address,
+    /// Accessed storage keys
+    #[serde(default)]
+    pub storage_keys: Vec<B256>,
+}
+
+/// Tenderly requires access lists to be serialized with `snake_case` instead
+/// of the standard `camelCase`.
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct AccessList(Vec<AccessListItem>);
+
+impl From<&alloy_rpc_types::AccessList> for AccessList {
+    fn from(value: &alloy_rpc_types::AccessList) -> Self {
+        AccessList(
+            value
+                .iter()
+                .map(|item| AccessListItem {
+                    address: item.address,
+                    storage_keys: item.storage_keys.clone(),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<AccessList> for alloy_rpc_types::AccessList {
+    fn from(value: AccessList) -> Self {
+        value
+            .0
+            .iter()
+            .map(|item| alloy_rpc_types::AccessListItem {
+                address: item.address,
+                storage_keys: item.storage_keys.clone(),
+            })
+            .collect::<Vec<_>>()
+            .into()
+    }
+}
+
+impl From<eth::AccessList> for AccessList {
+    fn from(value: eth::AccessList) -> Self {
+        Self(
+            value
+                .into_iter()
+                .map(|(address, storage_keys)| AccessListItem {
+                    address,
+                    storage_keys: storage_keys.into_iter().map(|k| k.0).collect(),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<AccessList> for eth::AccessList {
+    fn from(value: AccessList) -> Self {
+        Self::from_iter(
+            value
+                .0
+                .into_iter()
+                .map(|item| (item.address, item.storage_keys)),
+        )
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
+pub struct StateObject {
+    /// Fake balance to set for the account before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub balance: Option<alloy_primitives::U256>,
+
+    /// Fake EVM bytecode to inject into the account before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub code: Option<alloy_primitives::Bytes>,
+
+    /// Fake key-value mapping to override **individual** slots in the account
+    /// storage before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub storage: Option<B256Map<B256>>,
+}
+
+impl TryFrom<alloy_rpc_types::eth::state::AccountOverride> for StateObject {
+    type Error = anyhow::Error;
+
+    fn try_from(
+        value: alloy_rpc_types::eth::state::AccountOverride,
+    ) -> std::result::Result<Self, Self::Error> {
+        anyhow::ensure!(
+            value.nonce.is_none() && value.state.is_none(),
+            "full state and nonce overrides not supported on Tenderly",
+        );
+
+        Ok(StateObject {
+            balance: value.balance,
+            code: value.code,
+            storage: value.state_diff,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SimulationKind {
+    Full,
+    Quick,
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct Transaction {
+    pub status: bool,
+    pub gas_used: u64,
+    pub call_trace: Vec<CallTrace>,
+}
+
+#[serde_with::serde_as]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct CallTrace {
+    #[serde(default)]
+    #[serde_as(as = "Option<serde_ext::Hex>")]
+    pub output: Option<Vec<u8>>,
+    pub error: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct Simulation {
+    pub id: String,
+}
diff --git a/crates/simulator/src/tenderly/mod.rs b/crates/simulator/src/tenderly/mod.rs
new file mode 100644
index 0000000000..59bbf26557
--- /dev/null
+++ b/crates/simulator/src/tenderly/mod.rs
@@ -0,0 +1,323 @@
+use {
+    crate::ethereum::Ethereum,
+    alloy_primitives::TxKind,
+    alloy_rpc_types::{TransactionRequest, state::StateOverride},
+    anyhow::{Result, anyhow},
+    configs::simulator::TenderlyConfig,
+    eth_domain_types::{AccessList, BlockNo, Gas},
+    http_client::HttpClientFactory,
+    prometheus::IntGaugeVec,
+    reqwest::header::HeaderValue,
+    thiserror::Error,
+    url::Url,
+};
+
+pub mod dto;
+
+const API_URL: &str = "https://api.tenderly.co/api";
+const DASHBOARD_URL: &str = "https://dashboard.tenderly.co";
+// We want the string to be printed together with a simulation so we
+// don't care that it's not used for anything else.
+#[derive(Debug)]
+pub struct SimulationId(#[allow(dead_code, reason = "intended for Debug implementation")] String);
+
+#[derive(Debug, Clone)]
+pub struct Tenderly {
+    api: TenderlyApi,
+    eth: Ethereum,
+    save: bool,
+    save_if_fails: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct TenderlyApi {
+    simulation_endpoint: Url,
+    client: reqwest::Client,
+    dashboard: Url,
+    chain_id: String,
+}
+
+#[async_trait::async_trait]
+pub trait Api: Send + Sync + 'static {
+    fn log_simulation_command(
+        &self,
+        tx: TransactionRequest,
+        overrides: StateOverride,
+        block: Option<BlockNo>,
+    ) -> Result<()>;
+
+    async fn simulate(&self, request: dto::Request) -> Result<dto::Response>;
+}
+
+impl Tenderly {
+    pub fn new(config: &TenderlyConfig, eth: Ethereum, http_factory: &HttpClientFactory) -> Self {
+        Self {
+            api: TenderlyApi::new(config, http_factory, eth.chain().id().to_string()),
+            eth,
+            save_if_fails: config.save_if_fails,
+            save: config.save,
+        }
+    }
+
+    pub async fn simulate<T>(
+        &self,
+        tx: T,
+        block: BlockNo,
+        generate_access_list: GenerateAccessList,
+    ) -> Result<Simulation, Error>
+    where
+        T: Into<TransactionRequest>,
+    {
+        let tx = tx.into();
+        let request = dto::Request {
+            generate_access_list: match generate_access_list {
+                GenerateAccessList::Yes => Some(true),
+                GenerateAccessList::No => None,
+            },
+            save_if_fails: self.save_if_fails.then_some(true),
+            save: self.save.then_some(true),
+            ..prepare_request(
+                self.eth.chain().id().to_string(),
+                &tx,
+                Default::default(),
+                Some(block),
+            )?
+        };
+
+        Ok(self
+            .api
+            .simulate(request)
+            .await
+            .map_err(|err| Error::Other(anyhow!(err)))?
+            .into())
+    }
+}
+
+impl TenderlyApi {
+    pub fn new(
+        config: &configs::simulator::TenderlyConfig,
+        http_factory: &HttpClientFactory,
+        chain_id: String,
+    ) -> Self {
+        let mut headers = reqwest::header::HeaderMap::new();
+        let mut api_key =
+            HeaderValue::from_str(&config.api_key).expect("api key is correct header value");
+        api_key.set_sensitive(true);
+        headers.insert("x-access-key", api_key);
+
+        headers.insert(reqwest::header::ACCEPT, "application/json".parse().unwrap());
+        headers.insert(
+            reqwest::header::CONTENT_TYPE,
+            "application/json".parse().unwrap(),
+        );
+        Self {
+            simulation_endpoint: Url::parse(&format!(
+                "{url}/v1/account/{user}/project/{project}/simulate",
+                url = config
+                    .url
+                    .as_ref()
+                    .map(ToString::to_string)
+                    .unwrap_or_else(|| API_URL.to_owned()),
+                user = config.user,
+                project = config.project
+            ))
+            .expect("api url is valid Url"),
+            dashboard: Url::parse(&format!(
+                "{dashboard}/{user}/{project}/",
+                dashboard = config
+                    .dashboard
+                    .as_ref()
+                    .map(ToString::to_string)
+                    .unwrap_or_else(|| DASHBOARD_URL.to_owned()),
+                user = config.user,
+                project = config.project
+            ))
+            .expect("dashboard url is valid Url"),
+            client: http_factory.configure(|builder| builder.default_headers(headers)),
+            chain_id,
+        }
+    }
+
+    pub fn new_instrumented(
+        name: String,
+        config: &configs::simulator::TenderlyConfig,
+        http_factory: &HttpClientFactory,
+        chain_id: String,
+    ) -> Instrumented {
+        Instrumented {
+            inner: Self::new(config, http_factory, chain_id),
+            name,
+        }
+    }
+
+    fn log(&self, simulation: dto::Request) -> Result<()> {
+        let simulation_url =
+            crate::utils::join_url(&self.dashboard, "simulator/$SIMULATION_ID").to_string();
+        let body = serde_json::to_string(&simulation)?;
+
+        #[rustfmt::skip]
+        tracing::debug!(
+            "resimulate by setting TENDERLY_API_KEY environment variable and running: \
+            curl -X POST -H \"X-ACCESS-KEY: $TENDERLY_API_KEY\" -H \"Content-Type: application/json\" --data '{body}' {simulation_endpoint} \
+            | jq -r \".simulation.id\" \
+            | read SIMULATION_ID; \
+            echo {simulation_url} \
+            | xargs xdg-open",
+            simulation_endpoint = self.simulation_endpoint
+        );
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl Api for TenderlyApi {
+    fn log_simulation_command(
+        &self,
+        tx: TransactionRequest,
+        overrides: StateOverride,
+        block: Option<BlockNo>,
+    ) -> Result<()> {
+        let request = dto::Request {
+            save: Some(true),
+            save_if_fails: Some(true),
+            ..prepare_request(self.chain_id.clone(), &tx, overrides, block)?
+        };
+        self.log(request)
+    }
+
+    async fn simulate(&self, request: dto::Request) -> Result<dto::Response> {
+        let body = serde_json::to_string(&request).map_err(|err| Error::Other(anyhow!(err)))?;
+
+        let response = self
+            .client
+            .post(self.simulation_endpoint.clone())
+            .body(body)
+            .send()
+            .await?;
+
+        let ok = response.error_for_status_ref().map(|_| ());
+        let status = response.status();
+        let body = response.text().await?;
+        // NOTE: Turn these logs on at your own risk... The Tenderly response
+        // objects are huge (order of ~3M).
+        tracing::trace!(status =% status.as_u16(), %body, "simulated");
+
+        ok?;
+
+        Ok(serde_json::from_str::<dto::Response>(&body)?)
+    }
+}
+
+fn prepare_request(
+    chain_id: String,
+    tx: &TransactionRequest,
+    overrides: StateOverride,
+    block: Option<BlockNo>,
+) -> Result<dto::Request, Error> {
+    Ok(dto::Request {
+        block_number: block.map(|block| block.0),
+        // By default, tenderly simulates on the top of the specified block, whereas regular
+        // nodes simulate at the end of the specified block. This is to make
+        // simulation results match in case critical state changed within the block.
+        transaction_index: Some(-1),
+        network_id: chain_id,
+        from: tx.from.unwrap_or_default(),
+        to: tx.to.and_then(TxKind::into_to).unwrap_or_default(),
+        input: tx.input.clone().into_input().unwrap_or_default().to_vec(),
+        gas: tx.gas,
+        gas_price: tx
+            .gas_price
+            .map(TryInto::try_into)
+            .map(|gas_price| gas_price.unwrap()),
+        value: tx.value,
+        simulation_kind: Some(dto::SimulationKind::Quick),
+        state_objects: Some(
+            overrides
+                .into_iter()
+                .map(|(key, value)| Ok((key, value.try_into()?)))
+                .collect::<Result<_>>()?,
+        ),
+        access_list: tx.access_list.as_ref().map(Into::into),
+        ..Default::default()
+    })
+}
+
+#[derive(Debug)]
+pub struct Simulation {
+    pub id: SimulationId,
+    pub gas: Gas,
+    pub access_list: AccessList,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum GenerateAccessList {
+    Yes,
+    No,
+}
+
+impl From<dto::Response> for Simulation {
+    fn from(value: dto::Response) -> Self {
+        Simulation {
+            id: SimulationId(value.simulation.id),
+            gas: value.transaction.gas_used.into(),
+            access_list: value.generated_access_list.unwrap_or_default().into(),
+        }
+    }
+}
+
+/// Instrumented Tenderly HTTP API.
+pub struct Instrumented {
+    inner: TenderlyApi,
+    name: String,
+}
+
+#[async_trait::async_trait]
+impl Api for Instrumented {
+    async fn simulate(&self, simulation: dto::Request) -> Result<dto::Response> {
+        let result = self.inner.simulate(simulation).await;
+
+        Metrics::get()
+            .tenderly_simulations
+            .with_label_values(&[
+                self.name.as_str(),
+                match &result {
+                    Ok(_) => "ok",
+                    Err(_) => "err",
+                },
+            ])
+            .inc();
+
+        result
+    }
+
+    fn log_simulation_command(
+        &self,
+        tx: TransactionRequest,
+        overrides: StateOverride,
+        block: Option<BlockNo>,
+    ) -> Result<()> {
+        self.inner.log_simulation_command(tx, overrides, block)
+    }
+}
+
+#[derive(prometheus_metric_storage::MetricStorage)]
+struct Metrics {
+    /// Tenderly simulations.
+    #[metric(labels("name", "result"))]
+    tenderly_simulations: IntGaugeVec,
+}
+
+impl Metrics {
+    fn get() -> &'static Metrics {
+        Metrics::instance(observe::metrics::get_storage_registry()).unwrap()
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("tenderly error")]
+pub enum Error {
+    Http(#[from] reqwest::Error),
+    Revert(SimulationId),
+    Other(#[from] anyhow::Error),
+}
diff --git a/crates/simulator/src/utils/mod.rs b/crates/simulator/src/utils/mod.rs
new file mode 100644
index 0000000000..43d2b15c96
--- /dev/null
+++ b/crates/simulator/src/utils/mod.rs
@@ -0,0 +1,14 @@
+use url::Url;
+
+/// Join a path with a URL, ensuring that there is only one slash between them.
+/// It doesn't matter if the URL ends with a slash or the path starts with one.
+pub fn join_url(url: &Url, mut path: &str) -> Url {
+    let mut url = url.to_string();
+    while url.ends_with('/') {
+        url.pop();
+    }
+    while path.starts_with('/') {
+        path = &path[1..]
+    }
+    Url::parse(&format!("{url}/{path}")).expect("\"path\" contains a valid path segement")
+}
diff --git a/crates/solver/Cargo.toml b/crates/solver/Cargo.toml
index b75434b4af..89a0ca60af 100644
--- a/crates/solver/Cargo.toml
+++ b/crates/solver/Cargo.toml
@@ -30,6 +30,7 @@ prometheus = { workspace = true }
 prometheus-metric-storage = { workspace = true }
 serde_json = { workspace = true }
 shared = { workspace = true }
+simulator = { workspace = true }
 strum = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 tracing = { workspace = true }
diff --git a/crates/solver/src/liquidity/balancer_v2.rs b/crates/solver/src/liquidity/balancer_v2.rs
index a01c1de4c8..94e8609a95 100644
--- a/crates/solver/src/liquidity/balancer_v2.rs
+++ b/crates/solver/src/liquidity/balancer_v2.rs
@@ -447,7 +447,8 @@ mod tests {
 
         let [_, interactions, _] = encoder
             .finish(InternalizationStrategy::SkipInternalizableInteraction)
-            .interactions;
+            .interactions
+            .into_array();
         assert_eq!(
             interactions,
             [
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index 16020a0f8c..b2df40bfde 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -367,7 +367,8 @@ pub mod tests {
         handler.encode(execution, &mut encoder).unwrap();
         let [_, interactions, _] = encoder
             .finish(InternalizationStrategy::SkipInternalizableInteraction)
-            .interactions;
+            .interactions
+            .into_array();
         assert_eq!(
             interactions,
             [ZeroExInteraction {
diff --git a/crates/solver/src/settlement/mod.rs b/crates/solver/src/settlement/mod.rs
index ece348658e..a7c1439a90 100644
--- a/crates/solver/src/settlement/mod.rs
+++ b/crates/solver/src/settlement/mod.rs
@@ -6,10 +6,8 @@ use {
     anyhow::Result,
     model::order::{Order, OrderKind},
     number::u256_ext::U256Ext,
-    shared::{
-        encoded_settlement::{EncodedSettlement, EncodedTrade, encode_trade},
-        http_solver::model::InternalizationStrategy,
-    },
+    shared::http_solver::model::InternalizationStrategy,
+    simulator::encoding::{EncodedSettlement, EncodedTrade, encode_trade},
     std::collections::HashMap,
 };
 
diff --git a/crates/solver/src/settlement/settlement_encoder.rs b/crates/solver/src/settlement/settlement_encoder.rs
index d3aee36909..e227d6cfc0 100644
--- a/crates/solver/src/settlement/settlement_encoder.rs
+++ b/crates/solver/src/settlement/settlement_encoder.rs
@@ -9,11 +9,8 @@ use {
         order::{Order, OrderClass, OrderKind},
     },
     number::u256_ext::U256Ext,
-    shared::{
-        encoded_settlement::EncodedSettlement,
-        http_solver::model::InternalizationStrategy,
-        interaction::Interaction,
-    },
+    shared::{http_solver::model::InternalizationStrategy, interaction::Interaction},
+    simulator::encoding::{EncodedSettlement, Interactions},
     std::{
         collections::{HashMap, HashSet},
         iter,
@@ -526,12 +523,13 @@ impl SettlementEncoder {
             tokens,
             clearing_prices,
             trades,
-            interactions: [
-                self.pre_interactions
+            interactions: Interactions {
+                pre: self
+                    .pre_interactions
                     .into_iter()
                     .map(|interaction| interaction.encode())
                     .collect(),
-                iter::empty()
+                main: iter::empty()
                     .chain(
                         self.execution_plan
                             .iter()
@@ -551,11 +549,12 @@ impl SettlementEncoder {
                     )
                     .chain(self.unwraps.iter().map(|unwrap| unwrap.encode()))
                     .collect(),
-                self.post_interactions
+                post: self
+                    .post_interactions
                     .into_iter()
                     .map(|interaction| interaction.encode())
                     .collect(),
-            ],
+            },
         }
     }
 }
@@ -642,7 +641,8 @@ pub mod tests {
         assert_eq!(
             encoder
                 .finish(InternalizationStrategy::SkipInternalizableInteraction)
-                .interactions[1],
+                .interactions
+                .main,
             [UnwrapWethInteraction {
                 weth,
                 amount: U256::from(3),
@@ -797,7 +797,8 @@ pub mod tests {
         assert_eq!(
             encoder
                 .finish(InternalizationStrategy::SkipInternalizableInteraction)
-                .interactions[1],
+                .interactions
+                .main,
             [interaction.encode(), unwrap.encode()],
         );
     }
@@ -940,7 +941,7 @@ pub mod tests {
         let i2 = (i2.target, i2.value, i2.call_data.into());
         let encoded = encoder.finish(InternalizationStrategy::EncodeAllInteractions);
         assert_eq!(
-            encoded.interactions,
+            encoded.interactions.into_array(),
             [vec![i1.clone(), i1], vec![], vec![i2.clone(), i2]]
         );
     }
@@ -1016,10 +1017,10 @@ pub mod tests {
         let encoded = encoder
             .clone()
             .finish(InternalizationStrategy::SkipInternalizableInteraction);
-        assert_eq!(encoded.interactions[1].len(), 1);
+        assert_eq!(encoded.interactions.main.len(), 1);
 
         let encoded = encoder.finish(InternalizationStrategy::EncodeAllInteractions);
-        assert_eq!(encoded.interactions[1].len(), 2);
+        assert_eq!(encoded.interactions.main.len(), 2);
     }
 
     #[test]

From 173321ddfdd172da062d499d0aef02280b7e1c63 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 20 Mar 2026 09:50:48 +0100
Subject: [PATCH 162/219] [TRIVIAL] Speed up analytics DB replication job
 (#4279)

# Description
Every 10 minutes after the hour we run a job copying some data from the
main DB to an analytics DB. The heaviest workload is copying the
`order_quotes` based on the `creation_timestamp`.

# Changes
In order to greatly speed things up this PR introduces an index on the
`creation_timestamp`.
With those queries now also being very fast we can significantly reduce
the global DB query limit to further protect it against long running
queries avoiding DoS issues in the future.

## How to test
I manually created the indexes on the prod DB and one sync job already
ran using it. The graph confirms that the CPU load now barely changes
when the job runs.
<img width="495" height="351" alt="Screenshot 2026-03-20 at 08 45 46"
src="https://github.com/user-attachments/assets/676c6b0b-c3c3-4569-95ea-9a08f98ec6ba"
/>
<img width="1879" height="394" alt="Screenshot 2026-03-20 at 08 32 54"
src="https://github.com/user-attachments/assets/bab22b01-069b-4226-b0e9-1d30c20823f6"
/>
---
 database/README.md                                           | 1 +
 database/sql/V109__order_quotes_creation_timestamp_index.sql | 3 +++
 2 files changed, 4 insertions(+)
 create mode 100644 database/sql/V109__order_quotes_creation_timestamp_index.sql

diff --git a/database/README.md b/database/README.md
index bbf0502438..341d37bc3e 100644
--- a/database/README.md
+++ b/database/README.md
@@ -238,6 +238,7 @@ Quotes that an order was created with. These quotes get stored persistently and
 
 Indexes:
 - PRIMARY KEY: btree(`order_uid`)
+- order_quotes_creation_timestamp: btree(`creation_timestamp`)
 
 ### orders
 
diff --git a/database/sql/V109__order_quotes_creation_timestamp_index.sql b/database/sql/V109__order_quotes_creation_timestamp_index.sql
new file mode 100644
index 0000000000..fe5fac3418
--- /dev/null
+++ b/database/sql/V109__order_quotes_creation_timestamp_index.sql
@@ -0,0 +1,3 @@
+-- The job replicating data to the analytics DB fetches quotes based on the creation timestamp.
+-- This query significantly speeds that up.
+CREATE INDEX CONCURRENTLY IF NOT EXISTS order_quotes_creation_timestamp ON order_quotes USING BTREE(creation_timestamp);

From ffe4f5c72f3400a1b816c1a4df26b6d0b3603371 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Fri, 20 Mar 2026 10:50:05 +0000
Subject: [PATCH 163/219] fix: Don't quote unsupported tokens (#4280)

# Description

We got a report from the team that gnosis solvers were still quoting RWA
tokens even though they were configured as unsupported. The reason for
this was the only the /solve path was taking into account whether the
tokens were supported or not, so the gnosis continued quoting even
though they wouldn't solve the orders. I went with reusing
`filter_unsupported_orders_in_auction` even though it's slightly awkward
with the fake auctions to get to use the logging and metrics from the
already existing code.
---
 crates/driver/src/domain/quote.rs               | 11 ++++++++++-
 crates/driver/src/infra/api/routes/quote/mod.rs |  1 +
 crates/driver/src/infra/observe/mod.rs          |  3 +++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/crates/driver/src/domain/quote.rs b/crates/driver/src/domain/quote.rs
index 769f7f3f4b..4acc4946ba 100644
--- a/crates/driver/src/domain/quote.rs
+++ b/crates/driver/src/domain/quote.rs
@@ -1,5 +1,5 @@
 use {
-    super::competition::{auction, solution},
+    super::competition::{auction, risk_detector, solution},
     crate::{
         boundary,
         domain::{
@@ -131,6 +131,7 @@ impl Order {
         solver: &Solver,
         liquidity: &infra::liquidity::Fetcher,
         tokens: &infra::tokens::Fetcher,
+        risk_detector: &risk_detector::Detector,
     ) -> Result<Quote, Error> {
         let liquidity = match solver.liquidity() {
             solver::Liquidity::Fetch => {
@@ -144,6 +145,12 @@ impl Order {
         let auction = self
             .fake_auction(eth, tokens, solver.quote_using_limit_orders())
             .await?;
+        let auction = risk_detector
+            .filter_unsupported_orders_in_auction(auction)
+            .await;
+        if auction.orders.is_empty() {
+            return Err(QuotingFailed::UnsupportedToken.into());
+        }
         let solutions = solver.solve(&auction, &liquidity).await?;
         Quote::try_new(
             eth,
@@ -382,6 +389,8 @@ pub enum QuotingFailed {
     NoSolutions,
     #[error("math error computing custom prices")]
     Math,
+    #[error("token is unsupported by this solver")]
+    UnsupportedToken,
 }
 
 #[derive(Debug, thiserror::Error)]
diff --git a/crates/driver/src/infra/api/routes/quote/mod.rs b/crates/driver/src/infra/api/routes/quote/mod.rs
index d3310c5292..054cbc8819 100644
--- a/crates/driver/src/infra/api/routes/quote/mod.rs
+++ b/crates/driver/src/infra/api/routes/quote/mod.rs
@@ -27,6 +27,7 @@ async fn route(
                 state.solver(),
                 state.liquidity(),
                 state.tokens(),
+                &state.competition().risk_detector,
             )
             .await;
         observe::quoted(state.solver().name(), &order, &quote);
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index fded86b778..6db4cc4de3 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -307,6 +307,9 @@ pub fn quoted(solver: &solver::Name, order: &quote::Order, result: &Result<Quote
                             "NoSolutions"
                         }
                         quote::Error::QuotingFailed(quote::QuotingFailed::Math) => "MathError",
+                        quote::Error::QuotingFailed(quote::QuotingFailed::UnsupportedToken) => {
+                            "UnsupportedToken"
+                        }
                         quote::Error::DeadlineExceeded(_) => "DeadlineExceeded",
                         quote::Error::Blockchain(_) => "BlockchainError",
                         quote::Error::Solver(solver::Error::Http(_)) => "SolverHttpError",

From 0d94cdf9e999d4349e490c8b742eb9a4bf0420a8 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Fri, 20 Mar 2026 17:46:46 +0100
Subject: [PATCH 164/219] Add serde tag to SimulatorKind (#4281)

# Description
Simulator's kind config can not be deserialized without a #[serde(tag)]

# Changes
Adds #[serde(tag)] to SimulatorKind in configs crate and unit tests.
---
 crates/configs/src/simulator.rs | 81 ++++++++++++++++++++++++++++++++-
 1 file changed, 80 insertions(+), 1 deletion(-)

diff --git a/crates/configs/src/simulator.rs b/crates/configs/src/simulator.rs
index 579654457a..97e9942ecc 100644
--- a/crates/configs/src/simulator.rs
+++ b/crates/configs/src/simulator.rs
@@ -29,6 +29,7 @@ pub struct Config {
     /// - ethereum
     /// - tenderly (using TenderlyConfig)
     /// - enso (using EnsoConfig)
+    #[serde(default)]
     pub kind: SimulatorKind,
 }
 
@@ -43,6 +44,7 @@ fn default_ethrpc_max_concurrent_requests() -> usize {
 }
 
 #[derive(Debug, Default, Clone, Deserialize, Serialize)]
+#[serde(tag = "type")]
 pub enum SimulatorKind {
     #[default]
     Ethereum,
@@ -115,7 +117,7 @@ pub struct EnsoConfig {
     pub url: Url,
 
     /// The time between new blocks in the network.
-    #[serde(default)]
+    #[serde(with = "humantime_serde", default)]
     pub network_block_interval: Option<Duration>,
 }
 
@@ -153,3 +155,80 @@ pub struct Addresses {
     pub settlement: Option<Address>,
     pub weth: Option<Address>,
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_empty_config() {
+        let config: Config = toml::from_str("").unwrap();
+        assert!(matches!(config.kind, SimulatorKind::Ethereum));
+    }
+
+    #[test]
+    fn deserialize_simulator_kind() {
+        let toml = r#"
+        [kind]
+        type = "Tenderly"
+        user = "test-user"
+        project = "test-project"
+        api-key = "test-api-key"
+        "#;
+        let config: Config = toml::from_str(toml).unwrap();
+
+        match config.kind {
+            SimulatorKind::Tenderly(tenderly) => {
+                assert_eq!(tenderly.user, "test-user");
+                assert_eq!(tenderly.project, "test-project");
+                assert_eq!(tenderly.api_key, "test-api-key");
+            }
+            _ => panic!("Config should be of type Tenderly"),
+        };
+        let toml = r#"
+        [kind]
+        type = "Enso"
+        url = "http://test-url/"
+        network-block-interval = "5s"
+        "#;
+        let config: Config = toml::from_str(toml).unwrap();
+
+        match config.kind {
+            SimulatorKind::Enso(enso) => {
+                assert_eq!(enso.url.as_str(), "http://test-url/");
+                assert_eq!(enso.network_block_interval, Some(Duration::from_secs(5)));
+            }
+            _ => panic!("Config should be of type Enso"),
+        };
+
+        let toml = r#"
+        [kind]
+        type = "Ethereum"
+        "#;
+        let config: Config = toml::from_str(toml).unwrap();
+        assert!(matches!(config.kind, SimulatorKind::Ethereum))
+    }
+
+    #[derive(Deserialize)]
+    struct TestConfigContainingSimulator {
+        simulator: Config,
+    }
+
+    #[test]
+    fn deserialize_full_config() {
+        let toml = r#"
+        [simulator.kind]
+        type = "Tenderly"
+        user = "test-user"
+        api-key = "test-api-key"
+        "#;
+        let config: TestConfigContainingSimulator = toml::from_str(toml).unwrap();
+
+        match config.simulator.kind {
+            SimulatorKind::Tenderly(tenderly) => {
+                assert_eq!(tenderly.user, "test-user");
+                assert_eq!(tenderly.api_key, "test-api-key");
+            }
+            _ => panic!("Config should be of type Tenderly"),
+        };
+    }
+}

From 10a6e603d4ccdfed81759ced83fae9c252f4aa7c Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 20 Mar 2026 18:19:52 +0100
Subject: [PATCH 165/219] Clamp gas value before declaring a winner (#4282)

# Description
Follow up to https://github.com/cowprotocol/services/pull/4277 and
https://github.com/cowprotocol/services/pull/4276.
Those PRs clamped the gas estimate AFTER we already picked the best
quote but since clamping the gas is also supposed to influence which
quote we pick it has to happen BEFORE picking a winner.

# Changes
This PR moves the clamping logic into the trade verifier.
---
 crates/autopilot/src/run.rs                   |   2 -
 crates/configs/src/price_estimation.rs        |  16 +-
 crates/e2e/tests/e2e/quote_verification.rs    |   2 +
 crates/orderbook/src/run.rs                   |   2 -
 crates/price-estimation/src/factory.rs        |   2 +
 .../src/trade_verifier/mod.rs                 |  38 ++--
 crates/shared/src/order_quoting.rs            | 167 +-----------------
 7 files changed, 44 insertions(+), 185 deletions(-)

diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 3cd1fb5fd5..13ba483655 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -470,8 +470,6 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
         balance_fetcher.clone(),
         config.price_estimation.quote_verification,
         config.price_estimation.quote_timeout,
-        config.price_estimation.min_gas_amount_for_unverified_quotes,
-        config.price_estimation.max_gas_amount_for_unverified_quotes,
     ));
 
     let solvable_orders_cache = SolvableOrdersCache::new(
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index c607471805..773fe73bb2 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -88,16 +88,16 @@ pub struct PriceEstimation {
     /// solvers underestimate in unverified quotes, leading to fees that don't
     /// cover execution gas and causing small orders to expire unfilled.
     #[serde(default)]
-    pub min_gas_amount_for_unverified_quotes: u64,
+    pub min_gas_amount_for_unverified_quotes: u32,
 
     /// Maximum gas amount for unverified quotes. When an unverified quote
     /// reports more gas than this, the ceiling is used instead. Verified
-    /// quotes are unaffected. Defaults to 0 (disabled).
+    /// quotes are unaffected. Defaults to u32::MAX (disabled).
     ///
     /// This is a hack to alleviate tsolver issues where they report extremely
     /// high gas for RWA tokens.
-    #[serde(default)]
-    pub max_gas_amount_for_unverified_quotes: u64,
+    #[serde(default = "default_max_gas_amount_for_unverified_quotes")]
+    pub max_gas_amount_for_unverified_quotes: u32,
 
     /// Tenderly configuration (URL, project & API key).
     #[serde(default)]
@@ -125,7 +125,7 @@ impl Default for PriceEstimation {
             tokens_without_verification: Default::default(),
             max_gas_per_tx: default_max_gas_per_tx(),
             min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
+            max_gas_amount_for_unverified_quotes: u32::MAX,
         }
     }
 }
@@ -252,6 +252,10 @@ fn default_one_inch_url() -> Url {
     Url::from_str("https://api.1inch.dev/").expect("url should be valid")
 }
 
+fn default_max_gas_amount_for_unverified_quotes() -> u32 {
+    u32::MAX
+}
+
 #[derive(Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case")]
@@ -308,7 +312,7 @@ mod tests {
         assert_eq!(config.balance_overrides.cache_size, 1000);
         assert!(config.tokens_without_verification.is_empty());
         assert_eq!(config.min_gas_amount_for_unverified_quotes, 0);
-        assert_eq!(config.max_gas_amount_for_unverified_quotes, 0);
+        assert_eq!(config.max_gas_amount_for_unverified_quotes, u32::MAX);
     }
 
     #[test]
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 0976f32253..45fb7af7e6 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -170,6 +170,8 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
         *onchain.contracts().gp_settlement.address(),
         BigDecimal::zero(),
         Default::default(),
+        0,
+        u32::MAX,
     )
     .await
     .unwrap();
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index ec03de05f5..e2d60445ec 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -359,8 +359,6 @@ pub async fn run(config: Configuration) {
             balance_fetcher.clone(),
             verification,
             config.price_estimation.quote_timeout,
-            config.price_estimation.min_gas_amount_for_unverified_quotes,
-            config.price_estimation.max_gas_amount_for_unverified_quotes,
         ))
     };
     let optimal_quoter = create_quoter(price_estimator, config.price_estimation.quote_verification);
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index 51f6c4fbe3..57225a974e 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -125,6 +125,8 @@ impl<'a> PriceEstimatorFactory<'a> {
             network.settlement,
             args.quote_inaccuracy_limit.clone(),
             args.tokens_without_verification.iter().cloned().collect(),
+            args.min_gas_amount_for_unverified_quotes,
+            args.max_gas_amount_for_unverified_quotes,
         )
         .await?;
         Ok(Some(Arc::new(verifier)))
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index a30666be3d..5642737e35 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -75,6 +75,8 @@ pub struct TradeVerifier {
     settlement: GPv2Settlement::Instance,
     quote_inaccuracy_limit: BigRational,
     tokens_without_verification: HashSet<Address>,
+    min_gas_amount_for_unverified_quotes: u32,
+    max_gas_amount_for_unverified_quotes: u32,
 }
 
 impl TradeVerifier {
@@ -91,7 +93,14 @@ impl TradeVerifier {
         settlement: Address,
         quote_inaccuracy_limit: BigDecimal,
         tokens_without_verification: HashSet<Address>,
+        min_gas_amount_for_unverified_quotes: u32,
+        max_gas_amount_for_unverified_quotes: u32,
     ) -> Result<Self> {
+        assert!(
+            min_gas_amount_for_unverified_quotes <= max_gas_amount_for_unverified_quotes,
+            "gas floor ({min_gas_amount_for_unverified_quotes}) exceeds gas ceiling \
+             ({max_gas_amount_for_unverified_quotes}) for unverified quotes"
+        );
         let settlement_contract =
             GPv2Settlement::GPv2Settlement::new(settlement, web3.provider.clone());
         Ok(Self {
@@ -102,6 +111,8 @@ impl TradeVerifier {
             settlement: settlement_contract,
             quote_inaccuracy_limit: big_decimal_to_big_rational(&quote_inaccuracy_limit),
             tokens_without_verification,
+            min_gas_amount_for_unverified_quotes,
+            max_gas_amount_for_unverified_quotes,
         })
     }
 
@@ -486,16 +497,23 @@ impl TradeVerifying for TradeVerifier {
 
         let unverified_result = trade
             .gas_estimate()
-            .map(|gas| Estimate {
-                out_amount,
-                gas,
-                solver: trade.solver(),
-                verified: false,
-                execution: QuoteExecution {
-                    interactions: map_interactions_data(trade.interactions()),
-                    pre_interactions: map_interactions_data(trade.pre_interactions()),
-                    jit_orders: trade.jit_orders().cloned().collect(),
-                },
+            .map(|gas| {
+                let gas = gas.clamp(
+                    self.min_gas_amount_for_unverified_quotes as u64,
+                    self.max_gas_amount_for_unverified_quotes as u64,
+                );
+
+                Estimate {
+                    out_amount,
+                    gas,
+                    solver: trade.solver(),
+                    verified: false,
+                    execution: QuoteExecution {
+                        interactions: map_interactions_data(trade.interactions()),
+                        pre_interactions: map_interactions_data(trade.pre_interactions()),
+                        jit_orders: trade.jit_orders().cloned().collect(),
+                    },
+                }
             })
             .context("solver provided no gas estimate");
 
diff --git a/crates/shared/src/order_quoting.rs b/crates/shared/src/order_quoting.rs
index 5f2b392cf6..1cf936c550 100644
--- a/crates/shared/src/order_quoting.rs
+++ b/crates/shared/src/order_quoting.rs
@@ -421,8 +421,6 @@ pub struct OrderQuoter {
     balance_fetcher: Arc<dyn BalanceFetching>,
     quote_verification: QuoteVerificationMode,
     default_quote_timeout: std::time::Duration,
-    min_gas_amount_for_unverified_quotes: u64,
-    max_gas_amount_for_unverified_quotes: u64,
 }
 
 impl OrderQuoter {
@@ -436,15 +434,7 @@ impl OrderQuoter {
         balance_fetcher: Arc<dyn BalanceFetching>,
         quote_verification: QuoteVerificationMode,
         default_quote_timeout: std::time::Duration,
-        min_gas_amount_for_unverified_quotes: u64,
-        max_gas_amount_for_unverified_quotes: u64,
     ) -> Self {
-        assert!(
-            max_gas_amount_for_unverified_quotes == 0
-                || (min_gas_amount_for_unverified_quotes <= max_gas_amount_for_unverified_quotes),
-            "gas floor ({min_gas_amount_for_unverified_quotes}) exceeds gas ceiling \
-             ({max_gas_amount_for_unverified_quotes}) for unverified quotes"
-        );
         Self {
             price_estimator,
             native_price_estimator,
@@ -455,24 +445,7 @@ impl OrderQuoter {
             balance_fetcher,
             quote_verification,
             default_quote_timeout,
-            min_gas_amount_for_unverified_quotes,
-            max_gas_amount_for_unverified_quotes,
-        }
-    }
-
-    fn clamp_gas_for_unverified_quote(&self, gas: u64, verified: bool) -> u64 {
-        if verified {
-            return gas;
         }
-        let min = self.min_gas_amount_for_unverified_quotes;
-        let max = self.max_gas_amount_for_unverified_quotes;
-        let lower = if min > 0 { min } else { u64::MIN };
-        let upper = if max > 0 { max } else { u64::MAX };
-        let clamped = gas.clamp(lower, upper);
-        if clamped != gas {
-            tracing::debug!(gas, clamped, min, max, "clamped gas for unverified quote");
-        }
-        clamped
     }
 
     async fn compute_quote_data(
@@ -523,10 +496,9 @@ impl OrderQuoter {
                 buy_amount_after_fee: buy_amount,
             } => (trade_estimate.out_amount, buy_amount.get()),
         };
-        let gas_amount =
-            self.clamp_gas_for_unverified_quote(trade_estimate.gas, trade_estimate.verified);
+
         let fee_parameters = FeeParameters {
-            gas_amount: gas_amount as _,
+            gas_amount: trade_estimate.gas as f64,
             gas_price: effective_gas_price as f64,
             sell_token_price,
         };
@@ -968,8 +940,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1110,8 +1080,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1247,8 +1215,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         let quote = quoter.calculate_quote(parameters).await.unwrap();
@@ -1347,8 +1313,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1422,8 +1386,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1485,8 +1447,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1570,8 +1530,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1657,8 +1615,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert_eq!(
@@ -1732,8 +1688,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1765,8 +1719,6 @@ mod tests {
             quote_verification: QuoteVerificationMode::Unverified,
             balance_fetcher: mock_balance_fetcher(),
             default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-            min_gas_amount_for_unverified_quotes: 0,
-            max_gas_amount_for_unverified_quotes: 0,
         };
 
         assert!(matches!(
@@ -1785,121 +1737,6 @@ mod tests {
         ));
     }
 
-    #[tokio::test]
-    async fn min_gas_floor_applied_to_unverified_quote() {
-        let now = Utc::now();
-        let parameters = QuoteParameters {
-            sell_token: Address::from([1; 20]),
-            buy_token: Address::from([2; 20]),
-            side: OrderQuoteSide::Buy {
-                buy_amount_after_fee: NonZeroU256::try_from(42).unwrap(),
-            },
-            verification: Verification {
-                from: Address::from([3; 20]),
-                ..Default::default()
-            },
-            signing_scheme: QuoteSigningScheme::Eip712,
-            additional_gas: 0,
-            timeout: None,
-        };
-        let gas_price = Eip1559Estimation {
-            max_fee_per_gas: 2,
-            max_priority_fee_per_gas: 1,
-        };
-
-        let mock_estimate = |verified: bool| {
-            let mut price_estimator = MockPriceEstimating::new();
-            price_estimator.expect_estimate().returning(move |_| {
-                async move {
-                    Ok(price_estimation::Estimate {
-                        out_amount: AlloyU256::from(42),
-                        gas: 100_000,
-                        solver: Address::repeat_byte(1),
-                        verified,
-                        execution: Default::default(),
-                    })
-                }
-                .boxed()
-            });
-            price_estimator
-        };
-
-        let mock_native = || {
-            let mut native = MockNativePriceEstimating::new();
-            native
-                .expect_estimate_native_price()
-                .returning(|_, _| async { Ok(0.2) }.boxed());
-            native
-        };
-
-        let quoter = |verified: bool, min_gas: u64, max_gas: u64| {
-            let mut storage = MockQuoteStoring::new();
-            storage.expect_save().returning(|_| Ok(1));
-            OrderQuoter {
-                price_estimator: Arc::new(mock_estimate(verified)),
-                native_price_estimator: Arc::new(mock_native()),
-                gas_estimator: Arc::new(FakeGasPriceEstimator::new(gas_price)),
-                storage: Arc::new(storage),
-                now: Arc::new(now),
-                validity: Validity::default(),
-                quote_verification: QuoteVerificationMode::Unverified,
-                balance_fetcher: mock_balance_fetcher(),
-                default_quote_timeout: HEALTHY_PRICE_ESTIMATION_TIME,
-                min_gas_amount_for_unverified_quotes: min_gas,
-                max_gas_amount_for_unverified_quotes: max_gas,
-            }
-        };
-
-        // Unverified quote with floor > gas: floor should apply.
-        let quote = quoter(false, 500_000, 0)
-            .calculate_quote(parameters.clone())
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 500_000.);
-
-        // Verified quote with floor > gas: floor should NOT apply.
-        let quote = quoter(true, 500_000, 0)
-            .calculate_quote(parameters.clone())
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
-
-        // Unverified quote with floor = 0: no floor applied.
-        let quote = quoter(false, 0, 0)
-            .calculate_quote(parameters.clone())
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
-
-        // Unverified quote with ceiling < gas: ceiling should apply.
-        let quote = quoter(false, 0, 50_000)
-            .calculate_quote(parameters.clone())
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 50_000.);
-
-        // Verified quote with ceiling < gas: ceiling should NOT apply.
-        let quote = quoter(true, 0, 50_000)
-            .calculate_quote(parameters.clone())
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
-
-        // Unverified quote with ceiling = 0: no ceiling applied.
-        let quote = quoter(false, 0, 0)
-            .calculate_quote(parameters.clone())
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 100_000.);
-
-        // Both floor and ceiling set: gas gets clamped to range.
-        let quote = quoter(false, 200_000, 300_000)
-            .calculate_quote(parameters)
-            .await
-            .unwrap();
-        assert_eq!(quote.data.fee_parameters.gas_amount, 200_000.);
-    }
-
     #[test]
     fn check_quote_metadata_format() {
         let q: QuoteMetadata = QuoteMetadataV1 {

From f4769496b3da1ac1d0ca26c840ca2dd776c3963e Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 23 Mar 2026 20:02:47 +0000
Subject: [PATCH 166/219] Fix cargo audit vulnerabilities (aws-lc-sys,
 rustls-webpki) (#4286)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Resolves all 7 `cargo audit` advisories by updating dependencies.

**aws-lc-sys** 0.35.0 → 0.39.0 — fixes 5 crypto-failure advisories
(RUSTSEC-2026-{0044,0045,0046,0047,0048}) including PKCS7 verification
bypasses (CVSS 7.5) and X.509 name constraint bypass. Updated via
`aws-lc-rs` 1.15.2 → 1.16.2.

**rustls-webpki** 0.103.8 → 0.103.10 — fixes CRL distribution point
matching (RUSTSEC-2026-0049). Direct `cargo update`.

**rustls-webpki 0.101.7** (same RUSTSEC-2026-0049) — this old version
was dragged in by `aws-sdk-s3`'s `rustls` feature, which activates the
legacy TLS path (`aws-smithy-runtime/tls-rustls` → `legacy-rustls-ring`
→ `rustls 0.21` → `rustls-webpki 0.101.7`). The 0.101.x line has no
patch. Fixed by switching `aws-sdk-s3` from `features = ["rustls"]` to
`features = ["default-https-client"]`, which uses the modern
`rustls-aws-lc` backend instead. This removes `rustls 0.21` from the
tree entirely.

**recursion_limit** — the AWS SDK update introduced slightly deeper type
nesting that overflows the default compiler recursion limit (needs 130,
default is 128) when building autopilot tests. Added `#![recursion_limit
= "160"]` to `autopilot`.

## Test plan
- [x] `cargo check --workspace` and `cargo check -p autopilot --tests`
pass
- [x] `cargo audit` reports 0 vulnerabilities
---
 Cargo.lock                  | 259 +++++++++++++++++-------------------
 crates/autopilot/src/lib.rs |   2 +
 crates/s3/Cargo.toml        |   2 +-
 3 files changed, 122 insertions(+), 141 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7c92615f7e..026e5572b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1274,9 +1274,9 @@ dependencies = [
 
 [[package]]
 name = "aws-config"
-version = "1.8.12"
+version = "1.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96571e6996817bf3d58f6b569e4b9fd2e9d2fcf9f7424eed07b2ce9bb87535e5"
+checksum = "11493b0bad143270fb8ad284a096dd529ba91924c5409adeac856cc1bf047dbc"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -1284,8 +1284,8 @@ dependencies = [
  "aws-sdk-ssooidc",
  "aws-sdk-sts",
  "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
+ "aws-smithy-http 0.63.6",
+ "aws-smithy-json 0.62.5",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1294,7 +1294,7 @@ dependencies = [
  "fastrand",
  "hex",
  "http 1.4.0",
- "ring",
+ "sha1",
  "time",
  "tokio",
  "tracing",
@@ -1304,9 +1304,9 @@ dependencies = [
 
 [[package]]
 name = "aws-credential-types"
-version = "1.2.11"
+version = "1.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd362783681b15d136480ad555a099e82ecd8e2d10a841e14dfd0078d67fee3"
+checksum = "8f20799b373a1be121fe3005fba0c2090af9411573878f224df44b42727fcaf7"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api",
@@ -1316,9 +1316,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.15.2"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a88aab2464f1f25453baa7a07c84c5b7684e274054ba06817f382357f77a288"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
 dependencies = [
  "aws-lc-sys",
  "zeroize",
@@ -1326,9 +1326,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.35.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b45afffdee1e7c9126814751f88dddc747f41d91da16c9551a0f1e8a11e788a1"
+checksum = "1fa7e52a4c5c547c741610a2c6f123f3881e409b714cd27e6798ef020c514f0a"
 dependencies = [
  "cc",
  "cmake",
@@ -1338,23 +1338,26 @@ dependencies = [
 
 [[package]]
 name = "aws-runtime"
-version = "1.5.17"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d81b5b2898f6798ad58f484856768bca817e3cd9de0974c24ae0f1113fe88f1b"
+checksum = "5fc0651c57e384202e47153c1260b84a9936e19803d747615edf199dc3b98d17"
 dependencies = [
  "aws-credential-types",
  "aws-sigv4",
  "aws-smithy-async",
  "aws-smithy-eventstream",
- "aws-smithy-http",
+ "aws-smithy-http 0.63.6",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
  "bytes",
+ "bytes-utils",
  "fastrand",
  "http 0.2.12",
+ "http 1.4.0",
  "http-body 0.4.6",
+ "http-body 1.0.1",
  "percent-encoding",
  "pin-project-lite",
  "tracing",
@@ -1363,15 +1366,16 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-kms"
-version = "1.97.0"
+version = "1.104.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35a6be02a6fd3618c701a49a4dac4282658d18ccfcdcc8ac3b6c2fb4317e4fa"
+checksum = "c41ae6a33da941457e89075ef8ca5b4870c8009fe4dceeba82fce2f30f313ac6"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
+ "aws-smithy-http 0.63.6",
+ "aws-smithy-json 0.62.5",
+ "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1379,6 +1383,7 @@ dependencies = [
  "bytes",
  "fastrand",
  "http 0.2.12",
+ "http 1.4.0",
  "regex-lite",
  "tracing",
 ]
@@ -1395,8 +1400,8 @@ dependencies = [
  "aws-smithy-async",
  "aws-smithy-checksums",
  "aws-smithy-eventstream",
- "aws-smithy-http",
- "aws-smithy-json",
+ "aws-smithy-http 0.62.6",
+ "aws-smithy-json 0.61.9",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1419,15 +1424,16 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-sso"
-version = "1.91.0"
+version = "1.97.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee6402a36f27b52fe67661c6732d684b2635152b676aa2babbfb5204f99115d"
+checksum = "9aadc669e184501caaa6beafb28c6267fc1baef0810fb58f9b205485ca3f2567"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
+ "aws-smithy-http 0.63.6",
+ "aws-smithy-json 0.62.5",
+ "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1435,21 +1441,23 @@ dependencies = [
  "bytes",
  "fastrand",
  "http 0.2.12",
+ "http 1.4.0",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sdk-ssooidc"
-version = "1.93.0"
+version = "1.99.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a45a7f750bbd170ee3677671ad782d90b894548f4e4ae168302c57ec9de5cb3e"
+checksum = "1342a7db8f358d3de0aed2007a0b54e875458e39848d54cc1d46700b2bfcb0a8"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
+ "aws-smithy-http 0.63.6",
+ "aws-smithy-json 0.62.5",
+ "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1457,21 +1465,23 @@ dependencies = [
  "bytes",
  "fastrand",
  "http 0.2.12",
+ "http 1.4.0",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sdk-sts"
-version = "1.95.0"
+version = "1.101.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55542378e419558e6b1f398ca70adb0b2088077e79ad9f14eb09441f2f7b2164"
+checksum = "ab41ad64e4051ecabeea802d6a17845a91e83287e1dd249e6963ea1ba78c428a"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http",
- "aws-smithy-json",
+ "aws-smithy-http 0.63.6",
+ "aws-smithy-json 0.62.5",
+ "aws-smithy-observability",
  "aws-smithy-query",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
@@ -1480,19 +1490,20 @@ dependencies = [
  "aws-types",
  "fastrand",
  "http 0.2.12",
+ "http 1.4.0",
  "regex-lite",
  "tracing",
 ]
 
 [[package]]
 name = "aws-sigv4"
-version = "1.3.7"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69e523e1c4e8e7e8ff219d732988e22bfeae8a1cafdbe6d9eca1546fa080be7c"
+checksum = "b0b660013a6683ab23797778e21f1f854744fdf05f68204b4cca4c8c04b5d1f4"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-eventstream",
- "aws-smithy-http",
+ "aws-smithy-http 0.63.6",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
@@ -1509,9 +1520,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-async"
-version = "1.2.7"
+version = "1.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ee19095c7c4dda59f1697d028ce704c24b2d33c6718790c7f1d5a3015b4107c"
+checksum = "2ffcaf626bdda484571968400c326a244598634dc75fd451325a54ad1a59acfc"
 dependencies = [
  "futures-util",
  "pin-project-lite",
@@ -1524,7 +1535,7 @@ version = "0.63.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87294a084b43d649d967efe58aa1f9e0adc260e13a6938eb904c0ae9b45824ae"
 dependencies = [
- "aws-smithy-http",
+ "aws-smithy-http 0.62.6",
  "aws-smithy-types",
  "bytes",
  "crc-fast",
@@ -1540,9 +1551,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-eventstream"
-version = "0.60.14"
+version = "0.60.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc12f8b310e38cad85cf3bef45ad236f470717393c613266ce0a89512286b650"
+checksum = "faf09d74e5e32f76b8762da505a3cd59303e367a664ca67295387baa8c1d7548"
 dependencies = [
  "aws-smithy-types",
  "bytes",
@@ -1571,32 +1582,47 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "aws-smithy-http"
+version = "0.63.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1ab2dc1c2c3749ead27180d333c42f11be8b0e934058fb4b2258ee8dbe5231"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "futures-util",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "percent-encoding",
+ "pin-project-lite",
+ "pin-utils",
+ "tracing",
+]
+
 [[package]]
 name = "aws-smithy-http-client"
-version = "1.1.5"
+version = "1.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59e62db736db19c488966c8d787f52e6270be565727236fd5579eaa301e7bc4a"
+checksum = "6a2f165a7feee6f263028b899d0a181987f4fa7179a6411a32a439fba7c5f769"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
- "h2 0.3.27",
  "h2 0.4.13",
- "http 0.2.12",
  "http 1.4.0",
- "http-body 0.4.6",
- "hyper 0.14.32",
  "hyper 1.8.1",
- "hyper-rustls 0.24.2",
- "hyper-rustls 0.27.7",
+ "hyper-rustls",
  "hyper-util",
  "pin-project-lite",
- "rustls 0.21.12",
- "rustls 0.23.36",
+ "rustls",
  "rustls-native-certs",
  "rustls-pki-types",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tower 0.5.3",
  "tracing",
 ]
@@ -1610,20 +1636,29 @@ dependencies = [
  "aws-smithy-types",
 ]
 
+[[package]]
+name = "aws-smithy-json"
+version = "0.62.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9648b0bb82a2eedd844052c6ad2a1a822d1f8e3adee5fbf668366717e428856a"
+dependencies = [
+ "aws-smithy-types",
+]
+
 [[package]]
 name = "aws-smithy-observability"
-version = "0.1.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17f616c3f2260612fe44cede278bafa18e73e6479c4e393e2c4518cf2a9a228a"
+checksum = "a06c2315d173edbf1920da8ba3a7189695827002e4c0fc961973ab1c54abca9c"
 dependencies = [
  "aws-smithy-runtime-api",
 ]
 
 [[package]]
 name = "aws-smithy-query"
-version = "0.60.9"
+version = "0.60.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae5d689cf437eae90460e944a58b5668530d433b4ff85789e69d2f2a556e057d"
+checksum = "1a56d79744fb3edb5d722ef79d86081e121d3b9422cb209eb03aea6aa4f21ebd"
 dependencies = [
  "aws-smithy-types",
  "urlencoding",
@@ -1631,12 +1666,12 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime"
-version = "1.9.5"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a392db6c583ea4a912538afb86b7be7c5d8887d91604f50eb55c262ee1b4a5f5"
+checksum = "028999056d2d2fd58a697232f9eec4a643cf73a71cf327690a7edad1d2af2110"
 dependencies = [
  "aws-smithy-async",
- "aws-smithy-http",
+ "aws-smithy-http 0.63.6",
  "aws-smithy-http-client",
  "aws-smithy-observability",
  "aws-smithy-runtime-api",
@@ -1647,6 +1682,7 @@ dependencies = [
  "http 1.4.0",
  "http-body 0.4.6",
  "http-body 1.0.1",
+ "http-body-util",
  "pin-project-lite",
  "pin-utils",
  "tokio",
@@ -1655,9 +1691,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-runtime-api"
-version = "1.9.3"
+version = "1.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab0d43d899f9e508300e587bf582ba54c27a452dd0a9ea294690669138ae14a2"
+checksum = "876ab3c9c29791ba4ba02b780a3049e21ec63dabda09268b175272c3733a79e6"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-types",
@@ -1672,9 +1708,9 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-types"
-version = "1.3.5"
+version = "1.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "905cb13a9895626d49cf2ced759b062d913834c7482c38e49557eac4e6193f01"
+checksum = "9d73dbfbaa8e4bc57b9045137680b958d274823509a360abfd8e1d514d40c95c"
 dependencies = [
  "base64-simd",
  "bytes",
@@ -1698,18 +1734,18 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-xml"
-version = "0.60.13"
+version = "0.60.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11b2f670422ff42bf7065031e72b45bc52a3508bd089f743ea90731ca2b6ea57"
+checksum = "0ce02add1aa3677d022f8adf81dcbe3046a95f17a1b1e8979c145cd21d3d22b3"
 dependencies = [
  "xmlparser",
 ]
 
 [[package]]
 name = "aws-types"
-version = "1.3.11"
+version = "1.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d980627d2dd7bfc32a3c025685a033eeab8d365cc840c631ef59d1b8f428164"
+checksum = "47c8323699dd9b3c8d5b3c13051ae9cdef58fd179957c882f8374dd8725962d9"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-async",
@@ -3945,21 +3981,6 @@ dependencies = [
  "want",
 ]
 
-[[package]]
-name = "hyper-rustls"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
-dependencies = [
- "futures-util",
- "http 0.2.12",
- "hyper 0.14.32",
- "log",
- "rustls 0.21.12",
- "tokio",
- "tokio-rustls 0.24.1",
-]
-
 [[package]]
 name = "hyper-rustls"
 version = "0.27.7"
@@ -3969,11 +3990,11 @@ dependencies = [
  "http 1.4.0",
  "hyper 1.8.1",
  "hyper-util",
- "rustls 0.23.36",
+ "rustls",
  "rustls-native-certs",
  "rustls-pki-types",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tower-service",
 ]
 
@@ -5743,7 +5764,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls 0.23.36",
+ "rustls",
  "socket2 0.6.1",
  "thiserror 2.0.17",
  "tokio",
@@ -5764,7 +5785,7 @@ dependencies = [
  "rand 0.9.2",
  "ring",
  "rustc-hash",
- "rustls 0.23.36",
+ "rustls",
  "rustls-pki-types",
  "slab",
  "thiserror 2.0.17",
@@ -6093,7 +6114,7 @@ dependencies = [
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.8.1",
- "hyper-rustls 0.27.7",
+ "hyper-rustls",
  "hyper-util",
  "js-sys",
  "log",
@@ -6101,7 +6122,7 @@ dependencies = [
  "percent-encoding",
  "pin-project-lite",
  "quinn",
- "rustls 0.23.36",
+ "rustls",
  "rustls-pki-types",
  "rustls-platform-verifier",
  "serde",
@@ -6109,7 +6130,7 @@ dependencies = [
  "serde_urlencoded",
  "sync_wrapper 1.0.2",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tokio-util",
  "tower 0.5.3",
  "tower-http",
@@ -6309,18 +6330,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "rustls"
-version = "0.21.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
-dependencies = [
- "log",
- "ring",
- "rustls-webpki 0.101.7",
- "sct",
-]
-
 [[package]]
 name = "rustls"
 version = "0.23.36"
@@ -6330,7 +6339,7 @@ dependencies = [
  "aws-lc-rs",
  "once_cell",
  "rustls-pki-types",
- "rustls-webpki 0.103.8",
+ "rustls-webpki",
  "subtle",
  "zeroize",
 ]
@@ -6368,10 +6377,10 @@ dependencies = [
  "jni",
  "log",
  "once_cell",
- "rustls 0.23.36",
+ "rustls",
  "rustls-native-certs",
  "rustls-platform-verifier-android",
- "rustls-webpki 0.103.8",
+ "rustls-webpki",
  "security-framework 3.5.1",
  "security-framework-sys",
  "webpki-root-certs",
@@ -6386,19 +6395,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.7"
+version = "0.103.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
-dependencies = [
- "ring",
- "untrusted",
-]
-
-[[package]]
-name = "rustls-webpki"
-version = "0.103.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
+checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -6492,16 +6491,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
-[[package]]
-name = "sct"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "sec1"
 version = "0.7.3"
@@ -7699,23 +7688,13 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-rustls"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
-dependencies = [
- "rustls 0.21.12",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "rustls 0.23.36",
+ "rustls",
  "tokio",
 ]
 
@@ -7739,10 +7718,10 @@ checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
 dependencies = [
  "futures-util",
  "log",
- "rustls 0.23.36",
+ "rustls",
  "rustls-pki-types",
  "tokio",
- "tokio-rustls 0.26.4",
+ "tokio-rustls",
  "tungstenite",
  "webpki-roots 0.26.11",
 ]
@@ -8080,7 +8059,7 @@ dependencies = [
  "httparse",
  "log",
  "rand 0.9.2",
- "rustls 0.23.36",
+ "rustls",
  "rustls-pki-types",
  "sha1",
  "thiserror 2.0.17",
@@ -8487,7 +8466,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
diff --git a/crates/autopilot/src/lib.rs b/crates/autopilot/src/lib.rs
index a7742f2cb0..fad6e62fab 100644
--- a/crates/autopilot/src/lib.rs
+++ b/crates/autopilot/src/lib.rs
@@ -1,3 +1,5 @@
+#![recursion_limit = "160"]
+
 pub mod arguments;
 pub mod boundary;
 pub mod database;
diff --git a/crates/s3/Cargo.toml b/crates/s3/Cargo.toml
index 821b76c1d2..c7f82eeae8 100644
--- a/crates/s3/Cargo.toml
+++ b/crates/s3/Cargo.toml
@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 anyhow = { workspace = true }
 aws-config = { workspace = true, features = ["behavior-version-latest"] }
-aws-sdk-s3 = { workspace = true, features = ["rt-tokio", "rustls"] }
+aws-sdk-s3 = { workspace = true, features = ["default-https-client", "rt-tokio"] }
 flate2 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

From eb71b5204fa586f19655215f90efed8ad3f372ae Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 23 Mar 2026 23:52:15 +0300
Subject: [PATCH 167/219] Map Bitget API error codes to internal solver errors
 (#4285)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Description
- Parse `error_code` and `message` fields from Bitget API responses
(previously only `status` and `data` were parsed)
- Map Bitget error codes (80000–80010) to appropriate internal error
variants:
- **NotFound**: 80001 (insufficient balance), 80002 (below min), 80003
(above max), 80004 (expired), 80005 (no liquidity), 80008 (reverse
quote), 80009 (token info), 80010 (price info)
  - **BadRequest**: 80006 (illegal request)
- **Api** (logged): 80000 (internal), 80007 (partner invalid), unknown
codes
- Handle HTTP 429 explicitly as `RateLimited` before the generic status
check

Previously all non-zero `status` values except hardcoded 404/429 fell
through to a generic `Api` error, which led to a lot of alert noise. The
old 404/429 mapping in `handle_api_error` didn't match the actual Bitget
API format (which uses `status: 0/1` + `error_code: 80xxx`).

Error code reference:
https://web3.bitget.com/en/docs/swap-order#error-code-list

## How to test
- [x] All 5 existing bitget tests pass (`cargo nextest run -p solvers
bitget`)
- [x] Updated `not_found` test to use the actual Bitget error response
format (`status: 1, error_code: 80005`)
---
 crates/solvers/src/infra/dex/bitget/dto.rs   | 16 ++++++-
 crates/solvers/src/infra/dex/bitget/mod.rs   | 47 +++++++++++++++-----
 crates/solvers/src/infra/dex/mod.rs          |  2 +-
 crates/solvers/src/tests/bitget/not_found.rs |  8 ++--
 4 files changed, 57 insertions(+), 16 deletions(-)

diff --git a/crates/solvers/src/infra/dex/bitget/dto.rs b/crates/solvers/src/infra/dex/bitget/dto.rs
index 93122a3393..fba311354a 100644
--- a/crates/solvers/src/infra/dex/bitget/dto.rs
+++ b/crates/solvers/src/infra/dex/bitget/dto.rs
@@ -146,12 +146,24 @@ impl SwapTransaction {
 /// A Bitget API response wrapper.
 ///
 /// On success `status` is 0 and `data` contains the result.
-/// On error `status` is non-zero and `data` is null.
+/// On error `status` is 1, `error_code` identifies the failure, and `data` is
+/// null.
+///
+/// See <https://web3.bitget.com/en/docs/swap-order#error-code-list>
 #[derive(Deserialize, Clone, Debug)]
 pub struct Response<T> {
-    /// Response status code (0 = success).
+    /// Response status code (0 = success, 1 = failure).
     pub status: i64,
 
+    /// Bitget error code (e.g. 80005 for insufficient liquidity).
+    /// Only present when `status` is non-zero.
+    #[serde(default)]
+    pub error_code: Option<i64>,
+
+    /// Human-readable error description.
+    #[serde(default)]
+    pub message: Option<String>,
+
     /// Response data — `None` when the API returns an error.
     pub data: Option<T>,
 }
diff --git a/crates/solvers/src/infra/dex/bitget/mod.rs b/crates/solvers/src/infra/dex/bitget/mod.rs
index 0967053575..ed05a3dea4 100644
--- a/crates/solvers/src/infra/dex/bitget/mod.rs
+++ b/crates/solvers/src/infra/dex/bitget/mod.rs
@@ -214,13 +214,31 @@ impl Bitget {
         Ok(BASE64_STANDARD.encode(signature))
     }
 
-    /// Bitget error handling based on status codes.
-    fn handle_api_error(status: i64, body: String) -> Result<(), Error> {
-        Err(match status {
-            0 => return Ok(()),
-            429 => Error::RateLimited,
-            404 => Error::NotFound,
-            _ => Error::Api { status, body },
+    /// Bitget error handling based on `error_code`.
+    ///
+    /// See <https://web3.bitget.com/en/docs/swap-order#error-code-list>
+    fn handle_api_error(
+        status: i64,
+        error_code: Option<i64>,
+        message: String,
+    ) -> Result<(), Error> {
+        if status == 0 {
+            return Ok(());
+        }
+
+        Err(match error_code.unwrap_or(80000) {
+            80001 // Insufficient token balance
+            | 80004 // Order expired
+            | 80005 // Insufficient liquidity
+            | 80008 // Reverse quote did not converge
+            | 80009 // Token info not found
+            | 80010 // Price/gas price not found
+            => Error::NotFound,
+            80002 // Amount below minimum
+            | 80003 // Amount above maximum
+            | 80006 // Illegal request
+            => Error::BadRequest,
+            code => Error::Api { code, message },
         })
     }
 
@@ -256,6 +274,9 @@ impl Bitget {
         let status = response.status();
         let body = response.text().await.map_err(util::http::Error::from)?;
 
+        if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
+            return Err(Error::RateLimited);
+        }
         if !status.is_success() {
             return Err(util::http::Error::Status(status, body).into());
         }
@@ -263,7 +284,11 @@ impl Bitget {
         let response: dto::Response<U> =
             serde_json::from_str(&body).map_err(util::http::Error::from)?;
 
-        Self::handle_api_error(response.status, body)?;
+        Self::handle_api_error(
+            response.status,
+            response.error_code,
+            response.message.unwrap_or_default(),
+        )?;
         response.data.ok_or(Error::NotFound)
     }
 }
@@ -294,8 +319,10 @@ pub enum Error {
     AmountConversionFailed,
     #[error("decimals are missing for the swapped tokens")]
     MissingDecimals,
-    #[error("api error status {status}: {body}")]
-    Api { status: i64, body: String },
+    #[error("bad request")]
+    BadRequest,
+    #[error("api error code {code}: {message}")]
+    Api { code: i64, message: String },
     #[error(transparent)]
     Http(#[from] util::http::Error),
 }
diff --git a/crates/solvers/src/infra/dex/mod.rs b/crates/solvers/src/infra/dex/mod.rs
index 7050be1436..22c11a6973 100644
--- a/crates/solvers/src/infra/dex/mod.rs
+++ b/crates/solvers/src/infra/dex/mod.rs
@@ -113,7 +113,7 @@ impl From<bitget::Error> for Error {
         match err {
             bitget::Error::OrderNotSupported => Self::OrderNotSupported,
             bitget::Error::NotFound => Self::NotFound,
-            bitget::Error::MissingDecimals => Self::BadRequest,
+            bitget::Error::MissingDecimals | bitget::Error::BadRequest => Self::BadRequest,
             bitget::Error::RateLimited => Self::RateLimited,
             _ => Self::Other(Box::new(err)),
         }
diff --git a/crates/solvers/src/tests/bitget/not_found.rs b/crates/solvers/src/tests/bitget/not_found.rs
index 9c538e42ee..e99f5005b3 100644
--- a/crates/solvers/src/tests/bitget/not_found.rs
+++ b/crates/solvers/src/tests/bitget/not_found.rs
@@ -9,13 +9,15 @@ use {
 #[tokio::test]
 async fn sell_no_liquidity() {
     let api = mock::http::setup(vec![
-        // Swap request returns an error status.
+        // Swap request returns an error status (insufficient liquidity).
         mock::http::Expectation::Post {
             path: mock::http::Path::exact("bgw-pro/swapx/pro/swap"),
             req: mock::http::RequestBody::Any,
             res: json!({
-                "status": 404,
-                "data": {}
+                "status": 1,
+                "error_code": 80005,
+                "message": "Insufficient liquidity; transaction cannot be completed at this time.",
+                "data": null
             }),
         },
     ])

From 25a01e0731e57cd9d4dd544d958222ea7b474f29 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Mon, 23 Mar 2026 21:08:51 +0000
Subject: [PATCH 168/219] [EASY] Improve BitGet test (#4264)

Improves the ignored by default BitGet API test that covers all the
chain, making it much easier to quickly test any changes in the
request/response structs.
---
 crates/solvers/src/tests/bitget/api_calls.rs | 177 ++++++++++++++-----
 1 file changed, 128 insertions(+), 49 deletions(-)

diff --git a/crates/solvers/src/tests/bitget/api_calls.rs b/crates/solvers/src/tests/bitget/api_calls.rs
index 722a1b969b..c8d06c37be 100644
--- a/crates/solvers/src/tests/bitget/api_calls.rs
+++ b/crates/solvers/src/tests/bitget/api_calls.rs
@@ -3,67 +3,146 @@ use {
         domain::{auction, dex::*, eth::*},
         infra::dex::bitget as bitget_dex,
     },
-    alloy::primitives::address,
+    alloy::primitives::{Address, address},
     std::{collections::HashMap, env},
 };
 
+struct TestCase {
+    name: &'static str,
+    chain_id: ChainId,
+    sell_token: Address,
+    buy_token: Address,
+    sell_amount: u128,
+    sell_decimals: u8,
+    buy_decimals: u8,
+}
+
+const TEST_CASES: &[TestCase] = &[
+    TestCase {
+        name: "Mainnet: 0.1 WETH → USDC",
+        chain_id: ChainId::Mainnet,
+        sell_token: address!("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+        buy_token: address!("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+        sell_amount: 100_000_000_000_000_000,
+        sell_decimals: 18,
+        buy_decimals: 6,
+    },
+    TestCase {
+        name: "Base: 0.1 WETH → USDC",
+        chain_id: ChainId::Base,
+        sell_token: address!("0x4200000000000000000000000000000000000006"),
+        buy_token: address!("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
+        sell_amount: 100_000_000_000_000_000,
+        sell_decimals: 18,
+        buy_decimals: 6,
+    },
+    TestCase {
+        name: "Arbitrum: 0.1 WETH → USDC",
+        chain_id: ChainId::ArbitrumOne,
+        sell_token: address!("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+        buy_token: address!("0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),
+        sell_amount: 100_000_000_000_000_000,
+        sell_decimals: 18,
+        buy_decimals: 6,
+    },
+    TestCase {
+        name: "BNB: 1 WBNB → USDC",
+        chain_id: ChainId::Bnb,
+        sell_token: address!("0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"),
+        buy_token: address!("0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"),
+        sell_amount: 1_000_000_000_000_000_000,
+        sell_decimals: 18,
+        buy_decimals: 18,
+    },
+    TestCase {
+        name: "Polygon: 100 WPOL → USDC",
+        chain_id: ChainId::Polygon,
+        sell_token: address!("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+        buy_token: address!("0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"),
+        sell_amount: 100_000_000_000_000_000_000,
+        sell_decimals: 18,
+        buy_decimals: 6,
+    },
+];
+
 #[ignore]
 #[tokio::test]
 // To run this test, set the following environment variables accordingly to your
 // Bitget setup: BITGET_API_KEY, BITGET_API_SECRET
-async fn swap_sell_regular() {
-    let config = bitget_dex::Config {
-        endpoint: reqwest::Url::parse(bitget_dex::DEFAULT_ENDPOINT).unwrap(),
-        chain_id: crate::domain::eth::ChainId::Mainnet,
-        credentials: bitget_dex::BitgetCredentialsConfig {
-            api_key: env::var("BITGET_API_KEY").unwrap(),
-            api_secret: env::var("BITGET_API_SECRET").unwrap(),
-        },
-        partner_code: "cowswap".to_string(),
-        settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
-        block_stream: None,
-    };
+async fn swap_sell_all_chains() {
+    let api_key = env::var("BITGET_API_KEY").unwrap();
+    let api_secret = env::var("BITGET_API_SECRET").unwrap();
 
-    let order = Order {
-        sell: TokenAddress::from(address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")),
-        buy: TokenAddress::from(address!("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")),
-        side: crate::domain::order::Side::Sell,
-        amount: Amount::new(U256::from(1_000_000_000_000_000_000_u128)),
-        owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
-    };
+    for tc in TEST_CASES {
+        let config = bitget_dex::Config {
+            endpoint: reqwest::Url::parse(bitget_dex::DEFAULT_ENDPOINT).unwrap(),
+            chain_id: tc.chain_id,
+            credentials: bitget_dex::BitgetCredentialsConfig {
+                api_key: api_key.clone(),
+                api_secret: api_secret.clone(),
+            },
+            partner_code: "cowswap".to_string(),
+            settlement_contract: address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
+            block_stream: None,
+        };
 
-    let slippage = Slippage::one_percent();
+        let order = Order {
+            sell: TokenAddress::from(tc.sell_token),
+            buy: TokenAddress::from(tc.buy_token),
+            side: crate::domain::order::Side::Sell,
+            amount: Amount::new(U256::from(tc.sell_amount)),
+            owner: address!("0x6f9ffea7370310cd0f890dfde5e0e061059dcfb8"),
+        };
 
-    let mut token_map = HashMap::new();
-    token_map.insert(
-        order.sell,
-        auction::Token {
-            decimals: Some(18),
-            symbol: None,
-            reference_price: None,
-            available_balance: U256::ZERO,
-            trusted: false,
-        },
-    );
-    token_map.insert(
-        order.buy,
-        auction::Token {
-            decimals: Some(6),
-            symbol: None,
-            reference_price: None,
-            available_balance: U256::ZERO,
-            trusted: false,
-        },
-    );
-    let tokens = auction::Tokens(token_map);
+        let slippage = Slippage::one_percent();
 
-    let bitget = bitget_dex::Bitget::try_new(config).unwrap();
-    let swap_response = bitget.swap(&order, &slippage, &tokens).await;
-    let swap = swap_response.unwrap();
+        let mut token_map = HashMap::new();
+        token_map.insert(
+            order.sell,
+            auction::Token {
+                decimals: Some(tc.sell_decimals),
+                symbol: None,
+                reference_price: None,
+                available_balance: U256::ZERO,
+                trusted: false,
+            },
+        );
+        token_map.insert(
+            order.buy,
+            auction::Token {
+                decimals: Some(tc.buy_decimals),
+                symbol: None,
+                reference_price: None,
+                available_balance: U256::ZERO,
+                trusted: false,
+            },
+        );
+        let tokens = auction::Tokens(token_map);
+
+        let bitget = bitget_dex::Bitget::try_new(config).unwrap();
+        let swap = bitget
+            .swap(&order, &slippage, &tokens)
+            .await
+            .unwrap_or_else(|e| panic!("[{}] swap failed: {e}", tc.name));
 
-    assert_eq!(swap.input.token, order.amount().token);
-    assert_eq!(swap.input.amount, order.amount().amount);
-    assert_eq!(swap.output.token, order.buy);
+        assert_eq!(
+            swap.input.token,
+            order.amount().token,
+            "[{}] input token mismatch",
+            tc.name
+        );
+        assert_eq!(
+            swap.input.amount,
+            order.amount().amount,
+            "[{}] input amount mismatch",
+            tc.name
+        );
+        assert_eq!(
+            swap.output.token, order.buy,
+            "[{}] output token mismatch",
+            tc.name
+        );
+    }
 }
 
 #[tokio::test]

From 38d83834d94c5fe6808f47ecc8afda3436aa745c Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 24 Mar 2026 09:26:09 +0000
Subject: [PATCH 169/219] [EASY] Clean up remaining cargo audit advisories
 (#4287)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Follow-up to #4286. Resolves additional `cargo audit` warnings and
cleans up stale ignore entries.

- **Remove `idna` and `protobuf` from ignore list** — RUSTSEC-2024-0421
and RUSTSEC-2024-0437 are no longer triggered by current dependency
versions
- **Update keccak 0.1.5 → 0.1.6** — fixes RUSTSEC-2026-0012 (unsound
ARMv8 assembly backend) and resolves yanked crate warning
- **Update aws-sdk-s3 1.119.0 → 1.127.0** — removes `lru 0.12.5` from
the tree, fixing RUSTSEC-2026-0002 (unsound `IterMut`)

After this PR, `cargo audit` reports zero vulnerabilities and zero
warnings. The remaining ignore entries are genuinely unfixable:
- `rsa` — no patch available
- `derivative`/`instant`/`paste` — unmaintained, pinned by transitive
deps
- `model` — false positive matching our local crate name

## Test plan
- [x] `cargo check --workspace` passes
- [x] `cargo audit` reports 0 vulnerabilities, 0 warnings
---
 .cargo/audit.toml |   8 ----
 Cargo.lock        | 120 +++++++++++++++++-----------------------------
 2 files changed, 44 insertions(+), 84 deletions(-)

diff --git a/.cargo/audit.toml b/.cargo/audit.toml
index 76d2d8df83..8690df36b1 100644
--- a/.cargo/audit.toml
+++ b/.cargo/audit.toml
@@ -5,14 +5,6 @@
 [advisories]
 # Known vulnerabilities that are tracked in https://github.com/cowprotocol/services/issues/3338
 ignore = [
-  # idna - Punycode label vulnerability (RUSTSEC-2024-0421)
-  # Needs upgrade to 1.0.0+ (transitive dependency)
-  "RUSTSEC-2024-0421",
-
-  # protobuf - Uncontrolled recursion (RUSTSEC-2024-0437)
-  # Needs upgrade to 3.7.2+ (transitive dependency)
-  "RUSTSEC-2024-0437",
-
   # rsa - Marvin Attack timing sidechannel (RUSTSEC-2023-0071)
   # No patch available yet (cryptography vulnerability)
   "RUSTSEC-2023-0071",
diff --git a/Cargo.lock b/Cargo.lock
index 026e5572b6..291f0647f3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -409,7 +409,7 @@ dependencies = [
  "either",
  "futures",
  "futures-utils-wasm",
- "lru 0.16.3",
+ "lru",
  "parking_lot",
  "pin-project",
  "reqwest 0.12.28",
@@ -1284,8 +1284,8 @@ dependencies = [
  "aws-sdk-ssooidc",
  "aws-sdk-sts",
  "aws-smithy-async",
- "aws-smithy-http 0.63.6",
- "aws-smithy-json 0.62.5",
+ "aws-smithy-http",
+ "aws-smithy-json",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1346,7 +1346,7 @@ dependencies = [
  "aws-sigv4",
  "aws-smithy-async",
  "aws-smithy-eventstream",
- "aws-smithy-http 0.63.6",
+ "aws-smithy-http",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1373,8 +1373,8 @@ dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http 0.63.6",
- "aws-smithy-json 0.62.5",
+ "aws-smithy-http",
+ "aws-smithy-json",
  "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
@@ -1390,9 +1390,9 @@ dependencies = [
 
 [[package]]
 name = "aws-sdk-s3"
-version = "1.119.0"
+version = "1.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d65fddc3844f902dfe1864acb8494db5f9342015ee3ab7890270d36fbd2e01c"
+checksum = "151783f64e0dcddeb4965d08e36c276b4400a46caa88805a2e36d497deaf031a"
 dependencies = [
  "aws-credential-types",
  "aws-runtime",
@@ -1400,8 +1400,9 @@ dependencies = [
  "aws-smithy-async",
  "aws-smithy-checksums",
  "aws-smithy-eventstream",
- "aws-smithy-http 0.62.6",
- "aws-smithy-json 0.61.9",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
@@ -1413,8 +1414,8 @@ dependencies = [
  "hmac",
  "http 0.2.12",
  "http 1.4.0",
- "http-body 0.4.6",
- "lru 0.12.5",
+ "http-body 1.0.1",
+ "lru",
  "percent-encoding",
  "regex-lite",
  "sha2",
@@ -1431,8 +1432,8 @@ dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http 0.63.6",
- "aws-smithy-json 0.62.5",
+ "aws-smithy-http",
+ "aws-smithy-json",
  "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
@@ -1455,8 +1456,8 @@ dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http 0.63.6",
- "aws-smithy-json 0.62.5",
+ "aws-smithy-http",
+ "aws-smithy-json",
  "aws-smithy-observability",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
@@ -1479,8 +1480,8 @@ dependencies = [
  "aws-credential-types",
  "aws-runtime",
  "aws-smithy-async",
- "aws-smithy-http 0.63.6",
- "aws-smithy-json 0.62.5",
+ "aws-smithy-http",
+ "aws-smithy-json",
  "aws-smithy-observability",
  "aws-smithy-query",
  "aws-smithy-runtime",
@@ -1503,7 +1504,7 @@ checksum = "b0b660013a6683ab23797778e21f1f854744fdf05f68204b4cca4c8c04b5d1f4"
 dependencies = [
  "aws-credential-types",
  "aws-smithy-eventstream",
- "aws-smithy-http 0.63.6",
+ "aws-smithy-http",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
@@ -1531,17 +1532,18 @@ dependencies = [
 
 [[package]]
 name = "aws-smithy-checksums"
-version = "0.63.12"
+version = "0.64.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87294a084b43d649d967efe58aa1f9e0adc260e13a6938eb904c0ae9b45824ae"
+checksum = "6750f3dd509b0694a4377f0293ed2f9630d710b1cebe281fa8bac8f099f88bc6"
 dependencies = [
- "aws-smithy-http 0.62.6",
+ "aws-smithy-http",
  "aws-smithy-types",
  "bytes",
  "crc-fast",
  "hex",
- "http 0.2.12",
- "http-body 0.4.6",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
  "md-5",
  "pin-project-lite",
  "sha1",
@@ -1560,34 +1562,13 @@ dependencies = [
  "crc32fast",
 ]
 
-[[package]]
-name = "aws-smithy-http"
-version = "0.62.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826141069295752372f8203c17f28e30c464d22899a43a0c9fd9c458d469c88b"
-dependencies = [
- "aws-smithy-eventstream",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
- "bytes",
- "bytes-utils",
- "futures-core",
- "futures-util",
- "http 0.2.12",
- "http 1.4.0",
- "http-body 0.4.6",
- "percent-encoding",
- "pin-project-lite",
- "pin-utils",
- "tracing",
-]
-
 [[package]]
 name = "aws-smithy-http"
 version = "0.63.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba1ab2dc1c2c3749ead27180d333c42f11be8b0e934058fb4b2258ee8dbe5231"
 dependencies = [
+ "aws-smithy-eventstream",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
@@ -1627,15 +1608,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "aws-smithy-json"
-version = "0.61.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49fa1213db31ac95288d981476f78d05d9cbb0353d22cdf3472cc05bb02f6551"
-dependencies = [
- "aws-smithy-types",
-]
-
 [[package]]
 name = "aws-smithy-json"
 version = "0.62.5"
@@ -1671,7 +1643,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "028999056d2d2fd58a697232f9eec4a643cf73a71cf327690a7edad1d2af2110"
 dependencies = [
  "aws-smithy-async",
- "aws-smithy-http 0.63.6",
+ "aws-smithy-http",
  "aws-smithy-http-client",
  "aws-smithy-observability",
  "aws-smithy-runtime-api",
@@ -2646,9 +2618,9 @@ dependencies = [
 
 [[package]]
 name = "crc"
-version = "3.4.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+checksum = "9710d3b3739c2e349eb44fe848ad0b7c8cb1e42bd87ee49371df2f7acaf3e675"
 dependencies = [
  "crc-catalog",
 ]
@@ -2661,15 +2633,14 @@ checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
 
 [[package]]
 name = "crc-fast"
-version = "1.6.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ddc2d09feefeee8bd78101665bd8645637828fa9317f9f292496dbbd8c65ff3"
+checksum = "2fd92aca2c6001b1bf5ba0ff84ee74ec8501b52bbef0cac80bf25a6c1d87a83d"
 dependencies = [
  "crc",
  "digest 0.10.7",
- "rand 0.9.2",
- "regex",
  "rustversion",
+ "spin 0.10.0",
 ]
 
 [[package]]
@@ -3411,7 +3382,7 @@ checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
 dependencies = [
  "futures-core",
  "futures-sink",
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -4057,7 +4028,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.1",
+ "socket2 0.5.10",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -4418,7 +4389,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -4544,15 +4515,6 @@ version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
-[[package]]
-name = "lru"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38"
-dependencies = [
- "hashbrown 0.15.5",
-]
-
 [[package]]
 name = "lru"
 version = "0.16.3"
@@ -5765,7 +5727,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.6.1",
+ "socket2 0.5.10",
  "thiserror 2.0.17",
  "tokio",
  "tracing",
@@ -5803,7 +5765,7 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.1",
+ "socket2 0.5.10",
  "tracing",
  "windows-sys 0.60.2",
 ]
@@ -7085,6 +7047,12 @@ dependencies = [
  "lock_api",
 ]
 
+[[package]]
+name = "spin"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591"
+
 [[package]]
 name = "spki"
 version = "0.7.3"

From 796b6e4ad1e83360d22713b2580e0abb2ad96079 Mon Sep 17 00:00:00 2001
From: extrawurst <776816+extrawurst@users.noreply.github.com>
Date: Tue, 24 Mar 2026 11:19:25 +0100
Subject: [PATCH 170/219] set docker image tag to git-sha aswell (#4289)

We currently only set branch names and git-tags as additional docker
image tags. it would make it easier to find the offending git commit
breaking staging if we had also a docker tag of the git short-sha on the
image
---
 .github/workflows/deploy.yaml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.github/workflows/deploy.yaml b/.github/workflows/deploy.yaml
index 6d2fe8f66c..079c2e2e38 100644
--- a/.github/workflows/deploy.yaml
+++ b/.github/workflows/deploy.yaml
@@ -72,6 +72,10 @@ jobs:
         uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
         with:
           images: ghcr.io/${{ github.repository }}
+          tags: |
+            type=sha
+            type=ref,event=branch
+            type=ref,event=tag
           labels: |
             org.opencontainers.image.licenses=GPL-3.0-or-later
       - name: Services image build
@@ -91,6 +95,10 @@ jobs:
         uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
         with:
           images: ghcr.io/${{ github.repository }}-migration
+          tags: |
+            type=sha
+            type=ref,event=branch
+            type=ref,event=tag
           labels: |
             org.opencontainers.image.licenses=GPL-3.0-or-later
       - name: Migration image build

From 2ed3e04aa8de69c642038a145cb00a9d7225dbc8 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 24 Mar 2026 14:00:07 +0000
Subject: [PATCH 171/219] Map remaining Bitget error codes (80011-80015)
 (#4290)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Follow-up to #4285. The initial error code mapping only covered
80000–80010 but the Bitget API also returns 80011–80015. Unmapped codes
fell through to `Error::Api` causing unnecessary warn-level logs (e.g.
`api { code: 80012, message: "" }`).

New mappings:
- **80011** (failed to generate calldata) → `NotFound`
- **80012** (quote failed, no quote available) → `NotFound`
- **80013** (unsupported chain) → `BadRequest`
- **80014** (order not found) → `NotFound`
- 80015 (order already submitted) → left as `Api` (shouldn't occur in
our flow)

Ref: https://web3.bitget.com/en/docs/swap-order#error-code-list

## Test plan
- [x] All 5 bitget tests pass
---
 crates/solvers/src/infra/dex/bitget/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/solvers/src/infra/dex/bitget/mod.rs b/crates/solvers/src/infra/dex/bitget/mod.rs
index ed05a3dea4..c212df740b 100644
--- a/crates/solvers/src/infra/dex/bitget/mod.rs
+++ b/crates/solvers/src/infra/dex/bitget/mod.rs
@@ -233,10 +233,14 @@ impl Bitget {
             | 80008 // Reverse quote did not converge
             | 80009 // Token info not found
             | 80010 // Price/gas price not found
+            | 80011 // Failed to generate calldata
+            | 80012 // Quote failed
+            | 80014 // Order not found
             => Error::NotFound,
             80002 // Amount below minimum
             | 80003 // Amount above maximum
             | 80006 // Illegal request
+            | 80013 // Unsupported chain
             => Error::BadRequest,
             code => Error::Api { code, message },
         })

From f9627233c18f770f8d8e744b79d8950ad8e1de90 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 25 Mar 2026 09:36:18 +0000
Subject: [PATCH 172/219] Map OKX error code 51005 (honeypot token) to NotFound
 (#4293)

## Description

Map undocumented OKX error code 51005 to `NotFound` instead of the
generic `Api` error.

OKX returns this code for tokens flagged as honeypots or leveraged
tokens (e.g. *"0x.. cannot be traded as it may be a honeypot or
leveraged token"*). This is functionally identical to 82104 (token not
supported) - the token simply can't be traded. Previously, it fell
through to `Error::Api` and produced unnecessary warn-level logs. We've
encountered false-positive alerts for the
[Tornado.Cash](https://etherscan.io/address/0x77777feddddffc19ff86db637967013e6c6a116c#code)
token, which doesn't seem to be a honeypot at all.

Code 51005 is not in the [OKX error code
docs](https://web3.okx.com/build/dev-docs/wallet-api/dex-error-code).

## How to test
Existing tests
---
 crates/solvers/src/infra/dex/okx/mod.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/crates/solvers/src/infra/dex/okx/mod.rs b/crates/solvers/src/infra/dex/okx/mod.rs
index e71d04ba82..90049352bd 100644
--- a/crates/solvers/src/infra/dex/okx/mod.rs
+++ b/crates/solvers/src/infra/dex/okx/mod.rs
@@ -389,9 +389,11 @@ impl Okx {
     fn handle_api_error(code: i64, message: &str) -> Result<(), Error> {
         Err(match code {
             0 => return Ok(()),
-            82000 => Error::NotFound, // Insufficient liquidity
-            82104 => Error::NotFound, // Token not supported
-            82112 => Error::NotFound, // Internal OKX risk validation failed
+            51005 // Honeypot or leveraged token (undocumented)
+            | 82000 // Insufficient liquidity
+            | 82104 // Token not supported
+            | 82112 // Internal OKX risk validation failed
+            => Error::NotFound,
             50011 => Error::RateLimited,
             _ => Error::Api {
                 code,

From 0a42e7c8521b93576932c77a98e9fc69632f6289 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 27 Mar 2026 14:00:51 +0000
Subject: [PATCH 173/219] Fix simulator using raw gas estimator without tip
 adjustments (#4298)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Fixes a regression introduced in #4265 (Simulator crate) that caused
frequent "max fee per gas less than block base fee" errors during
settlement encoding, particularly on Arbitrum.

### Root cause

`Ethereum::gas_estimator()` returns `self.inner.gas.gas` — the **raw**
`dyn GasPriceEstimating` without tip adjustments. Before #4265,
`Ethereum::simulation_gas_price()` called
`GasPriceEstimator::estimate()` which adds a configurable tip buffer
(default 3 Gwei or 5%) on top of the raw estimate. After #4265, the
simulator receives the raw estimator, so simulation gas prices land
right at the base fee with no buffer.

On Arbitrum (~250ms blocks), the base fee changes constantly. The tiny
gap between estimation and `eth_call` execution is enough for the base
fee to tick up past the estimated price.

### Fix

Implement `GasPriceEstimating` for `GasPriceEstimator` and return the
wrapped estimator from `gas_estimator()`, so the simulator gets the same
tip-adjusted estimates the driver used before #4265.

## Test plan
- [x] `cargo check -p driver` passes
- [ ] Deploy to staging and verify "max fee per gas less than block base
fee" errors stop on Arbitrum
---
 crates/driver/src/infra/blockchain/gas.rs | 11 +++++++++++
 crates/driver/src/infra/blockchain/mod.rs |  2 +-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/crates/driver/src/infra/blockchain/gas.rs b/crates/driver/src/infra/blockchain/gas.rs
index 7dfd775aa0..2f02d4c1f8 100644
--- a/crates/driver/src/infra/blockchain/gas.rs
+++ b/crates/driver/src/infra/blockchain/gas.rs
@@ -135,3 +135,14 @@ impl GasPriceEstimator {
         })
     }
 }
+
+#[async_trait::async_trait]
+impl GasPriceEstimating for GasPriceEstimator {
+    async fn estimate(&self) -> ::anyhow::Result<Eip1559Estimation> {
+        GasPriceEstimator::estimate(self).await.map_err(Into::into)
+    }
+
+    async fn base_fee(&self) -> ::anyhow::Result<Option<u64>> {
+        self.gas.base_fee().await
+    }
+}
diff --git a/crates/driver/src/infra/blockchain/mod.rs b/crates/driver/src/infra/blockchain/mod.rs
index a03bd51630..8b3211998f 100644
--- a/crates/driver/src/infra/blockchain/mod.rs
+++ b/crates/driver/src/infra/blockchain/mod.rs
@@ -183,7 +183,7 @@ impl Ethereum {
     }
 
     pub fn gas_estimator(&self) -> Arc<dyn GasPriceEstimating> {
-        Arc::clone(&self.inner.gas.gas)
+        Arc::clone(&self.inner.gas) as _
     }
 
     pub fn block_gas_limit(&self) -> eth::Gas {

From 3dd0844ffb972e6731093f8f7ca8467c716042bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Mon, 30 Mar 2026 18:18:32 +0100
Subject: [PATCH 174/219] Remove Enso's simulator support (#4294)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Remove the Enso Trade Simulator backend. It's unused and adds
unnecessary code to maintain.

# Changes

* Remove the unused Enso simulator backend — deleted the `enso/` module
and cleaned up all references in configs, driver, and simulator crates.

## How to test

```
cargo nextest run -p simulator -p configs -p driver
```
---
 crates/configs/src/simulator.rs  | 31 +---------
 crates/driver/example.toml       |  4 --
 crates/driver/src/run.rs         |  4 --
 crates/simulator/src/enso/dto.rs | 39 -------------
 crates/simulator/src/enso/mod.rs | 99 --------------------------------
 crates/simulator/src/lib.rs      | 40 +++----------
 6 files changed, 8 insertions(+), 209 deletions(-)
 delete mode 100644 crates/simulator/src/enso/dto.rs
 delete mode 100644 crates/simulator/src/enso/mod.rs

diff --git a/crates/configs/src/simulator.rs b/crates/configs/src/simulator.rs
index 97e9942ecc..7ded37a1b5 100644
--- a/crates/configs/src/simulator.rs
+++ b/crates/configs/src/simulator.rs
@@ -28,7 +28,6 @@ pub struct Config {
     /// Kind of simulator that should be used. Can be either of
     /// - ethereum
     /// - tenderly (using TenderlyConfig)
-    /// - enso (using EnsoConfig)
     #[serde(default)]
     pub kind: SimulatorKind,
 }
@@ -48,8 +47,7 @@ fn default_ethrpc_max_concurrent_requests() -> usize {
 pub enum SimulatorKind {
     #[default]
     Ethereum,
-    Tenderly(TenderlyConfig),
-    Enso(EnsoConfig),
+    Tenderly(Box<TenderlyConfig>),
 }
 
 /// Tenderly API arguments.
@@ -110,17 +108,6 @@ impl crate::test_util::TestDefault for TenderlyConfig {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct EnsoConfig {
-    /// The URL of the Transaction Simulator API.
-    pub url: Url,
-
-    /// The time between new blocks in the network.
-    #[serde(with = "humantime_serde", default)]
-    pub network_block_interval: Option<Duration>,
-}
-
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields, tag = "estimator")]
 pub enum GasEstimatorType {
@@ -184,22 +171,6 @@ mod tests {
             }
             _ => panic!("Config should be of type Tenderly"),
         };
-        let toml = r#"
-        [kind]
-        type = "Enso"
-        url = "http://test-url/"
-        network-block-interval = "5s"
-        "#;
-        let config: Config = toml::from_str(toml).unwrap();
-
-        match config.kind {
-            SimulatorKind::Enso(enso) => {
-                assert_eq!(enso.url.as_str(), "http://test-url/");
-                assert_eq!(enso.network_block_interval, Some(Duration::from_secs(5)));
-            }
-            _ => panic!("Config should be of type Enso"),
-        };
-
         let toml = r#"
         [kind]
         type = "Ethereum"
diff --git a/crates/driver/example.toml b/crates/driver/example.toml
index 66dcd40217..47166302cc 100644
--- a/crates/driver/example.toml
+++ b/crates/driver/example.toml
@@ -100,10 +100,6 @@ max-order-age = "1m"
 # router = "0xE592427A0AEce92De3Edee1F18E0157C05861564"
 # max_pools_to_initialize = 100 # how many of the deepest pools to initialise on startup
 
-# [enso]
-# url = "http://localhost:8454"
-# network-block-interval = "12s"
-
 # [liquidity-sources-notifier] # Sends settlement notifications to third party liquidity sources used by solvers
 # [liquidity-sources-notifier.liquorice]
 # base-url = "https://api.liquorice.tech/"
diff --git a/crates/driver/src/run.rs b/crates/driver/src/run.rs
index 9fcee0b232..90f5d6ce50 100644
--- a/crates/driver/src/run.rs
+++ b/crates/driver/src/run.rs
@@ -158,10 +158,6 @@ fn simulator(
             kind: configs::simulator::SimulatorKind::Tenderly(config),
             ..
         } => Simulator::tenderly(config, eth, http_factory),
-        configs::simulator::Config {
-            kind: configs::simulator::SimulatorKind::Enso(config),
-            ..
-        } => Simulator::enso(config, eth),
         configs::simulator::Config {
             kind: configs::simulator::SimulatorKind::Ethereum,
             ..
diff --git a/crates/simulator/src/enso/dto.rs b/crates/simulator/src/enso/dto.rs
deleted file mode 100644
index 1a5d2d484e..0000000000
--- a/crates/simulator/src/enso/dto.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Data transfer objects for interacting with the Enso Trade Simulator API.
-
-use {
-    alloy_rpc_types::AccessList,
-    eth_domain_types as eth,
-    serde::{Deserialize, Serialize},
-    serde_with::serde_as,
-};
-
-#[serde_as]
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Request {
-    pub chain_id: u64,
-    pub from: eth::Address,
-    pub to: eth::Address,
-    #[serde_as(as = "serde_ext::Hex")]
-    pub data: Vec<u8>,
-    pub value: eth::U256,
-    pub gas_limit: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub block_number: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub block_timestamp: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub access_list: Option<AccessList>,
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Response {
-    pub gas_used: u64,
-    pub block_number: u64,
-    pub success: bool,
-    pub exit_reason: String,
-    #[serde_as(as = "serde_ext::Hex")]
-    pub return_data: Vec<u8>,
-}
diff --git a/crates/simulator/src/enso/mod.rs b/crates/simulator/src/enso/mod.rs
deleted file mode 100644
index 780ccf03d7..0000000000
--- a/crates/simulator/src/enso/mod.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use {
-    chain::Chain,
-    eth_domain_types as eth,
-    ethrpc::block_stream::CurrentBlockWatcher,
-    reqwest::ClientBuilder,
-    std::time::Duration,
-    thiserror::Error,
-};
-
-mod dto;
-
-const GAS_LIMIT: u64 = 30_000_000;
-
-#[derive(Debug, Clone)]
-pub struct Enso {
-    url: reqwest::Url,
-    chain: Chain,
-    current_block: CurrentBlockWatcher,
-    network_block_interval: Option<Duration>,
-}
-
-impl Enso {
-    pub(super) fn new(
-        config: &configs::simulator::EnsoConfig,
-        chain: Chain,
-        current_block: CurrentBlockWatcher,
-    ) -> Self {
-        Self {
-            url: reqwest::Url::parse(&format!("{}api/v1/simulate", config.url)).unwrap(),
-            chain,
-            current_block,
-            network_block_interval: config.network_block_interval,
-        }
-    }
-
-    pub(super) async fn simulate(&self, tx: eth::Tx) -> Result<eth::Gas, Error> {
-        let current_block = *self.current_block.borrow();
-
-        let (block_number, block_timestamp) = match self.network_block_interval {
-            None => (None, None), // use default values which result in simulation on `latest`
-            Some(duration) => {
-                // We would like to simulate on the `pending` block instead of the `latest`
-                // block. Unfortunately `enso` does not support that so to get closer to
-                // the actual behavior of the `pending` block we use the block number of
-                // the `latest` block but the timestamp of the `pending` block.
-                let block_number = current_block.number;
-                let next_timestamp = current_block.timestamp + duration.as_secs();
-                (Some(block_number), Some(next_timestamp))
-            }
-        };
-
-        let res: dto::Response = ClientBuilder::new()
-            .build()
-            .unwrap()
-            .post(self.url.clone())
-            .json(&dto::Request {
-                chain_id: self.chain.id(),
-                from: tx.from,
-                to: tx.to,
-                data: tx.input.into(),
-                value: tx.value.into(),
-                gas_limit: GAS_LIMIT,
-                block_number,
-                block_timestamp,
-                access_list: if tx.access_list.is_empty() {
-                    None
-                } else {
-                    Some(tx.access_list.into())
-                },
-            })
-            .send()
-            .await?
-            .error_for_status()?
-            .json()
-            .await?;
-
-        res.into()
-    }
-}
-
-#[derive(Debug, Error)]
-#[error("Enso tx simulation error")]
-pub enum Error {
-    Http(#[from] reqwest::Error),
-    Revert(String),
-}
-
-impl From<dto::Response> for Result<eth::Gas, Error> {
-    fn from(response: dto::Response) -> Self {
-        if !response.success {
-            return Err(Error::Revert(format!(
-                "{}: {}",
-                response.exit_reason,
-                const_hex::encode(&response.return_data)
-            )));
-        }
-        Ok(response.gas_used.into())
-    }
-}
diff --git a/crates/simulator/src/lib.rs b/crates/simulator/src/lib.rs
index 22726b9096..e3f98f0362 100644
--- a/crates/simulator/src/lib.rs
+++ b/crates/simulator/src/lib.rs
@@ -1,16 +1,15 @@
 pub mod encoding;
-pub mod enso;
 pub mod ethereum;
 pub mod swap_simulator;
 pub mod tenderly;
 mod utils;
 
-pub use {enso::Enso, ethereum::Ethereum, tenderly::Tenderly};
 use {
     eth_domain_types::{self as eth, AccessList, Tx},
     http_client::HttpClientFactory,
     observe::future::Measure,
 };
+pub use {ethereum::Ethereum, tenderly::Tenderly};
 
 #[derive(Debug, Clone)]
 pub struct Simulator {
@@ -22,9 +21,8 @@ pub struct Simulator {
 
 #[derive(Debug, Clone)]
 enum Inner {
-    Tenderly(tenderly::Tenderly),
+    Tenderly(Box<tenderly::Tenderly>),
     Ethereum,
-    Enso(enso::Enso),
 }
 
 impl Simulator {
@@ -35,7 +33,11 @@ impl Simulator {
     ) -> Self {
         let eth = eth.with_metric_label("tenderlySimulator".into());
         Self {
-            inner: Inner::Tenderly(tenderly::Tenderly::new(config, eth.clone(), http_factory)),
+            inner: Inner::Tenderly(Box::new(tenderly::Tenderly::new(
+                config,
+                eth.clone(),
+                http_factory,
+            ))),
             eth,
             disable_access_lists: false,
             disable_gas: None,
@@ -52,20 +54,6 @@ impl Simulator {
         }
     }
 
-    pub fn enso(config: &configs::simulator::EnsoConfig, eth: Ethereum) -> Self {
-        let eth = eth.with_metric_label("ensoSimulator".into());
-        Self {
-            inner: Inner::Enso(enso::Enso::new(
-                config,
-                eth.chain(),
-                eth.current_block().clone(),
-            )),
-            eth,
-            disable_access_lists: false,
-            disable_gas: None,
-        }
-    }
-
     /// Disable access list simulation. Some environments, such as less popular
     /// blockchains, don't support access list simulation.
     pub fn disable_access_lists(&mut self) {
@@ -99,11 +87,6 @@ impl Simulator {
                 .create_access_list(tx.clone())
                 .await
                 .map_err(with(tx.clone(), block))?,
-            Inner::Enso(_) => self
-                .eth
-                .create_access_list(tx.clone())
-                .await
-                .map_err(with(tx.clone(), block))?,
         };
         Ok(tx.access_list.clone().merge(access_list))
     }
@@ -128,11 +111,6 @@ impl Simulator {
                 .estimate_gas(tx.clone())
                 .await
                 .map_err(with(tx.clone(), block))?,
-            Inner::Enso(enso) => enso
-                .simulate(tx.clone())
-                .measure("enso_simulate_gas")
-                .await
-                .map_err(with(tx.clone(), block))?,
         })
     }
 }
@@ -143,8 +121,6 @@ pub enum SimulatorError {
     Tenderly(#[from] tenderly::Error),
     #[error("ethereum error: {0:?}")]
     Ethereum(#[from] ethereum::Error),
-    #[error("enso error: {0:?}")]
-    Enso(#[from] enso::Error),
     #[error("the simulated gas {0} exceeded the gas limit {1} provided in the solution")]
     GasExceeded(eth::Gas, eth::Gas),
 }
@@ -180,8 +156,6 @@ where
             SimulatorError::Tenderly(tenderly::Error::Revert(_)) => Some(tx.clone()),
             SimulatorError::Tenderly(tenderly::Error::Other(_)) => None,
             SimulatorError::Ethereum(_) => Some(tx.clone()),
-            SimulatorError::Enso(enso::Error::Http(_)) => None,
-            SimulatorError::Enso(enso::Error::Revert(_)) => Some(tx.clone()),
             SimulatorError::GasExceeded(..) => Some(tx.clone()),
         };
         match tx {

From 9adf10bed9eeffd9a1a50c5d46bef1b23f9986fb Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 31 Mar 2026 09:27:57 +0100
Subject: [PATCH 175/219] Add Claude Code GitHub Workflow (#4292)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Adds Claude Code GitHub integration with two workflows, review
guidelines, and Rust tooling.

### Workflows

1. **`claude.yml`** — Responds to `@claude` mentions in PR/issue
comments. Claude analyzes the context and executes the request.

2. **`claude-code-review.yml`** — Automatic code review when a PR is
marked ready for review. Uses the official `code-review` plugin with
multi-agent verification. Does not run on drafts, pushes, or reopens.
Includes `rust-analyzer-lsp` plugin for real Rust code intelligence
(type checking, diagnostics, go-to-definition) during reviews.

### Review guidelines (`REVIEW.md`)

Controls what Claude flags during reviews:
- Prioritizes correctness, safety, security over style
- Domain-specific checks: token amount conversions, error code mapping,
settlement compatibility
- Explicit false-positive exclusion list (no style nits, no pre-existing
issues, no theoretical concerns)
- Severity levels aligned with the code-review plugin's standard
categories (Normal, Nit)
- Strict output format: file/line, what's wrong, why it matters,
suggested fix

### Security
- API key stored as GitHub Actions secret
- Only repo write-access users can trigger workflows
- All runs visible in GitHub Actions history

## Test plan
- [ ] Merge and verify `@claude` mention triggers in a test PR comment
- [ ] Verify auto-review triggers when a PR is marked ready for review
- [ ] Verify auto-review does NOT trigger on draft PRs or pushes
---
 .github/workflows/claude-code-review.yml | 31 ++++++++++
 .github/workflows/claude.yml             | 50 +++++++++++++++
 REVIEW.md                                | 78 ++++++++++++++++++++++++
 3 files changed, 159 insertions(+)
 create mode 100644 .github/workflows/claude-code-review.yml
 create mode 100644 .github/workflows/claude.yml
 create mode 100644 REVIEW.md

diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml
new file mode 100644
index 0000000000..feff389d73
--- /dev/null
+++ b/.github/workflows/claude-code-review.yml
@@ -0,0 +1,31 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [ready_for_review]
+
+jobs:
+  claude-review:
+    if: ${{ !github.event.pull_request.draft }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
+          plugins: 'code-review@claude-code-plugins'
+          prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}'
+
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
new file mode 100644
index 0000000000..79fe056478
--- /dev/null
+++ b/.github/workflows/claude.yml
@@ -0,0 +1,50 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://code.claude.com/docs/en/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr:*)'
+
diff --git a/REVIEW.md b/REVIEW.md
new file mode 100644
index 0000000000..a4105d181e
--- /dev/null
+++ b/REVIEW.md
@@ -0,0 +1,78 @@
+# Code Review Guidelines
+
+These instructions guide automated code reviews. Focus on real bugs and
+correctness issues. Do not pad reviews with praise or filler.
+
+## Priorities
+
+Review in priority order.
+
+1. **Correctness** — logic errors, wrong return values, off-by-one, missing
+   error propagation, incorrect arithmetic (especially with U256/BigDecimal)
+2. **Safety** — panics in production paths (`unwrap` on fallible operations),
+   unchecked arithmetic overflow, missing bounds checks
+3. **Security** — SQL injection, command injection, secrets in logs,
+   unvalidated external input at system boundaries
+4. **Concurrency** — data races, deadlocks, incorrect `Send`/`Sync` bounds,
+   holding locks across await points
+5. **Backwards compatibility** — API breaking changes, database migration
+   issues, settlement contract interaction changes
+
+## Always check
+
+- Token amount conversions between decimal and wei are correct (scaling
+  direction, precision loss)
+- Error types from external APIs (solvers, DEX aggregators) are mapped to the
+  correct internal variant — wrong mapping produces noisy logs or silently
+  drops valid quotes
+- New `async` code does not block the Tokio runtime (no blocking I/O, no
+  `std::thread::sleep`, no heavy computation without `spawn_blocking`)
+- Database queries that touch large tables have been checked against existing
+  indexes. If a PR adds or modifies a query on a large table, request
+  `EXPLAIN ANALYZE` output (before and after) if not already included in the
+  PR description
+- Settlement-related changes are backward-compatible with in-flight auctions
+- Changes to auction or solver logic preserve existing solver competition
+  fairness
+
+## Do NOT flag
+
+- Style or formatting issues — `cargo fmt` and `clippy` handle these
+- Missing documentation or comments on clear code
+- Suggestions to add more tests unless a specific untested edge case is
+  identified
+- Pre-existing issues not introduced by the PR
+- Theoretical concerns that require specific unlikely conditions
+- `unwrap()` on values that are guaranteed by construction or prior checks
+- Differences in naming conventions that are consistent within the changed
+  file
+
+## Severity
+
+Use the code-review plugin's standard categories:
+
+- **Normal** — a bug or issue that should be fixed before merging
+- **Nit** — a minor improvement, not blocking
+
+Do not flag pre-existing issues not introduced by the PR. If unsure whether
+something is a real issue, ask a clarifying question rather than asserting a
+bug.
+
+## Skip these files
+
+- `Cargo.lock`
+- Generated contract bindings under `crates/contracts/`
+- Database migration files (review schema changes only, not the generated SQL)
+- Test fixture JSON files
+
+## Format
+
+For each finding, include:
+- File path and line number
+- What is wrong (one sentence)
+- Why it matters (one sentence)
+- For small, self-contained fixes, include a committable GitHub suggestion
+  block. For larger fixes, describe the recommended approach in prose.
+
+Do not summarize the PR. Do not list what looks correct. Only report findings.
+If you do not find issues, simply comment: LGTM

From d067d689d70278eaa37c5512547ff98322a23721 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 31 Mar 2026 11:34:40 +0100
Subject: [PATCH 176/219] Log original request ID when reusing shared in-flight
 quote requests (#4300)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Background
Fast and optimal quoters share the same `ExternalTradeFinder` instance
(via `Arc<dyn TradeFinding>`), so `RequestSharing` already deduplicates
identical concurrent requests. However, when a hitchhiker reused an
in-flight request, there was no trace linking it back to the original
HTTP call, making it hard to debug why the optimal quoter failed to
provide solutions, while the fast one succeeded for basically the same
quote competition or vice versa.

## Changes
- Extended `RequestSharing::shared_or_else` to return a `SharedResult`
that indicates whether an existing in-flight request was reused
(`is_shared` flag), improving observability of request deduplication.
- In `ExternalTradeFinder`, the HTTP request ID (`X-REQUEST-ID`) is now
embedded in the shared future's result. When a caller (e.g. the fast or
optimal quoter) reuses an in-flight request instead of sending a new
one, a debug log is emitted with the `original_request_id` — making it
possible to trace which HTTP request produced a given quote result.
- All other `shared_or_else` callers updated to use the new `.future`
field (no behavioral change).

## How to test
Using staging, use the cowswap UI to get some quotes. Search for the new
log.
---
 .../src/recent_block_cache.rs                 |  4 +-
 .../src/trade_finding/external.rs             | 81 ++++++++++++-------
 crates/request-sharing/src/lib.rs             | 60 ++++++++++----
 3 files changed, 98 insertions(+), 47 deletions(-)

diff --git a/crates/liquidity-sources/src/recent_block_cache.rs b/crates/liquidity-sources/src/recent_block_cache.rs
index c77376799a..ba3dee67c7 100644
--- a/crates/liquidity-sources/src/recent_block_cache.rs
+++ b/crates/liquidity-sources/src/recent_block_cache.rs
@@ -265,7 +265,7 @@ where
         let retries = self.maximum_retries;
         let delay = self.delay_between_retries;
         let fetcher = self.fetcher.clone();
-        let fut = self.requests.shared_or_else((key, block), |entry| {
+        let shared = self.requests.shared_or_else((key, block), |entry| {
             let (key, block) = entry.clone();
             async move {
                 for _ in 0..=retries {
@@ -280,7 +280,7 @@ where
             }
             .boxed()
         });
-        fut.await.context("could not fetch liquidity")
+        shared.await.context("could not fetch liquidity")
     }
 
     async fn fetch(&self, keys: impl IntoIterator<Item = K>, block: Block) -> Result<Vec<V>> {
diff --git a/crates/price-estimation/src/trade_finding/external.rs b/crates/price-estimation/src/trade_finding/external.rs
index 28504441e1..e49dd5403d 100644
--- a/crates/price-estimation/src/trade_finding/external.rs
+++ b/crates/price-estimation/src/trade_finding/external.rs
@@ -21,11 +21,20 @@ use {
     futures::FutureExt,
     observe::tracing::distributed::headers::tracing_headers,
     request_sharing::{BoxRequestSharing, RequestSharing},
-    reqwest::{Client, header},
+    reqwest::{Client, StatusCode, header},
     tracing::instrument,
     url::Url,
 };
 
+/// Wraps a trade result with the request ID of the HTTP request that produced
+/// it, so that consumers reusing a shared in-flight request can identify the
+/// original request.
+#[derive(Clone)]
+struct SharedTradeResponse {
+    result: Result<TradeKind, PriceEstimationError>,
+    request_id: Option<String>,
+}
+
 pub struct ExternalTradeFinder {
     /// URL to call to in the driver to get a quote with call data for a trade.
     quote_endpoint: Url,
@@ -33,7 +42,7 @@ pub struct ExternalTradeFinder {
     /// Utility to make sure no 2 identical requests are in-flight at the same
     /// time. Instead of issuing a duplicated request this awaits the
     /// response of the in-flight request.
-    sharing: BoxRequestSharing<Query, Result<TradeKind, PriceEstimationError>>,
+    sharing: BoxRequestSharing<Query, SharedTradeResponse>,
 
     /// Client to issue http requests with.
     client: Client,
@@ -83,39 +92,55 @@ impl ExternalTradeFinder {
                     request = request.header("X-Current-Block-Hash", block_hash.to_string())
                 }
 
-                if let Some(id) = id {
-                    request = request.header("X-REQUEST-ID", id);
+                if let Some(ref id) = id {
+                    request = request.header("X-REQUEST-ID", id.clone());
                 }
 
-                let response = request
-                    .timeout(timeout)
-                    .send()
-                    .await
-                    .map_err(|err| PriceEstimationError::EstimatorInternal(anyhow!(err)))?;
-                if response.status() == 429 {
-                    return Err(PriceEstimationError::RateLimited);
+                let result = async {
+                    let response = request
+                        .timeout(timeout)
+                        .send()
+                        .await
+                        .map_err(|err| PriceEstimationError::EstimatorInternal(anyhow!(err)))?;
+                    if response.status() == StatusCode::TOO_MANY_REQUESTS {
+                        return Err(PriceEstimationError::RateLimited);
+                    }
+                    let text = response
+                        .text()
+                        .await
+                        .map_err(|err| PriceEstimationError::EstimatorInternal(anyhow!(err)))?;
+                    serde_json::from_str::<dto::QuoteKind>(&text)
+                        .map(TradeKind::from)
+                        .map_err(|err| {
+                            serde_json::from_str::<dto::Error>(&text)
+                                .map(PriceEstimationError::from)
+                                .unwrap_or_else(|_| {
+                                    PriceEstimationError::EstimatorInternal(anyhow!(err))
+                                })
+                        })
+                }
+                .await;
+
+                SharedTradeResponse {
+                    result,
+                    request_id: id,
                 }
-                let text = response
-                    .text()
-                    .await
-                    .map_err(|err| PriceEstimationError::EstimatorInternal(anyhow!(err)))?;
-                serde_json::from_str::<dto::QuoteKind>(&text)
-                    .map(TradeKind::from)
-                    .map_err(|err| {
-                        if let Ok(err) = serde_json::from_str::<dto::Error>(&text) {
-                            PriceEstimationError::from(err)
-                        } else {
-                            PriceEstimationError::EstimatorInternal(anyhow!(err))
-                        }
-                    })
             }
             .boxed()
         };
 
-        self.sharing
-            .shared_or_else(query.clone(), fut)
-            .await
-            .map_err(TradeError::from)
+        let shared = self.sharing.shared_or_else(query.clone(), fut);
+        let is_shared = shared.is_shared;
+        let response = shared.await;
+
+        if is_shared {
+            tracing::debug!(
+                original_request_id = ?response.request_id,
+                "reusing in-flight quote request"
+            );
+        }
+
+        response.result.map_err(TradeError::from)
     }
 }
 
diff --git a/crates/request-sharing/src/lib.rs b/crates/request-sharing/src/lib.rs
index 54d618fd52..35083a90b0 100644
--- a/crates/request-sharing/src/lib.rs
+++ b/crates/request-sharing/src/lib.rs
@@ -11,7 +11,9 @@ use {
         collections::HashMap,
         future::Future,
         hash::Hash,
+        pin::Pin,
         sync::{Arc, Mutex},
+        task::{Context, Poll},
         time::Duration,
     },
 };
@@ -39,6 +41,28 @@ pub type BoxRequestSharing<Request, Response> =
 /// A boxed shared future.
 pub type BoxShared<T> = Shared<BoxFuture<'static, T>>;
 
+/// Result of [`RequestSharing::shared_or_else`] indicating whether an
+/// already in-flight future was reused or a new one was created.
+///
+/// Implements [`Future`] so it can be awaited directly.
+pub struct SharedResult<Fut: Future> {
+    future: Shared<Fut>,
+    /// `true` when an existing in-flight request was reused instead of
+    /// starting a new one.
+    pub is_shared: bool,
+}
+
+impl<Fut: Future> Future for SharedResult<Fut>
+where
+    Fut::Output: Clone,
+{
+    type Output = Fut::Output;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.future).poll(cx)
+    }
+}
+
 type Cache<Request, Response> = Arc<Mutex<HashMap<Request, WeakShared<Response>>>>;
 
 impl<Request: Send + 'static, Fut: Future + Send + 'static> RequestSharing<Request, Fut>
@@ -100,7 +124,7 @@ where
 {
     /// Returns an existing in flight future or creates and uses a new future
     /// from the specified closure.
-    pub fn shared_or_else<F>(&self, request: Request, future: F) -> Shared<Fut>
+    pub fn shared_or_else<F>(&self, request: Request, future: F) -> SharedResult<Fut>
     where
         F: FnOnce(&Request) -> Fut,
     {
@@ -113,7 +137,10 @@ where
                 .request_sharing_access
                 .with_label_values(&[self.request_label.as_str(), "hits"])
                 .inc();
-            return existing;
+            return SharedResult {
+                future: existing,
+                is_shared: true,
+            };
         }
 
         Metrics::get()
@@ -129,7 +156,10 @@ where
             .request_sharing_cached_items
             .with_label_values(&[&self.request_label])
             .set(in_flight.len() as u64);
-        shared
+        SharedResult {
+            future: shared,
+            is_shared: false,
+        }
     }
 }
 
@@ -165,30 +195,26 @@ mod tests {
             request_label: label.clone(),
         };
 
-        let shared0 = sharing.shared_or_else(0, |_| futures::future::ready(0).boxed());
-        let shared1 = sharing.shared_or_else(0, |_| async { panic!() }.boxed());
+        let result0 = sharing.shared_or_else(0, |_| futures::future::ready(0).boxed());
+        let result1 = sharing.shared_or_else(0, |_| async { panic!() }.boxed());
 
-        assert!(shared0.ptr_eq(&shared1));
-        assert_eq!(shared0.strong_count().unwrap(), 2);
-        assert_eq!(shared1.strong_count().unwrap(), 2);
-        assert_eq!(shared0.weak_count().unwrap(), 1);
+        assert!(!result0.is_shared);
+        assert!(result1.is_shared);
 
-        // complete first shared
-        assert_eq!(shared0.now_or_never().unwrap(), 0);
-        assert_eq!(shared1.strong_count().unwrap(), 1);
-        assert_eq!(shared1.weak_count().unwrap(), 1);
+        // Complete first shared — result1 still holds a reference.
+        assert_eq!(result0.await, 0);
 
-        // GC does not delete any keys because some tasks still use the future
+        // GC does not delete because result1 still references the future.
         RequestSharing::collect_garbage(&sharing.in_flight, &label);
         assert_eq!(sharing.in_flight.lock().unwrap().len(), 1);
         assert!(sharing.in_flight.lock().unwrap().get(&0).is_some());
 
-        // complete second shared
-        assert_eq!(shared1.now_or_never().unwrap(), 0);
+        // Complete second shared — proves sharing since its factory would panic.
+        assert_eq!(result1.await, 0);
 
         RequestSharing::collect_garbage(&sharing.in_flight, &label);
 
-        // GC deleted all now unused futures
+        // GC deleted all now unused futures.
         assert!(sharing.in_flight.lock().unwrap().is_empty());
     }
 }

From e1ae348530f52c5a003e8bf8c567dcaebc04e0a7 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 31 Mar 2026 11:34:56 +0100
Subject: [PATCH 177/219] Allow solvers to set custom gas fees in their
 solution (#4299)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Adds optional `maxFeePerGas` and `maxPriorityFeePerGas` fields to the
solver Solution response. When provided, these override the driver's
default gas price estimation during settlement submission.

### Behavior
- Both fields must be provided together or both absent
- Solvers can set fees **higher or lower** than the driver default,
since the solver pays from their own balance, so they self-regulate
- When a replacement transaction is pending (same nonce), the solver's
values are raised to at least the replacement minimum (node requirement
to accept the replacement)
- Merged solutions discard gas fee overrides (no meaningful way to merge
per-solution gas preferences)

### Changes
- Add `max_fee_per_gas` and `max_priority_fee_per_gas` to `Solution`
- Add `GasFeeOverride` type, carry through `Solution` → `Settlement`
- Apply override to `final_gas_price` before submission


## How to test
New e2e test

## Related issues

Fixes #4297
---
 .../src/domain/competition/solution/mod.rs    | 21 +++++++
 .../domain/competition/solution/settlement.rs |  5 ++
 crates/driver/src/domain/mempools.rs          | 38 +++++++++++-
 .../driver/src/infra/solver/dto/solution.rs   | 18 ++++++
 .../src/tests/cases/gas_fee_override.rs       | 60 +++++++++++++++++++
 crates/driver/src/tests/cases/mod.rs          |  1 +
 crates/driver/src/tests/setup/blockchain.rs   |  1 +
 crates/driver/src/tests/setup/mod.rs          | 19 ++++--
 crates/driver/src/tests/setup/solver.rs       |  4 ++
 crates/e2e/tests/e2e/cow_amm.rs               |  2 +
 crates/e2e/tests/e2e/jit_orders.rs            |  1 +
 .../e2e/liquidity_source_notification.rs      |  1 +
 crates/e2e/tests/e2e/solver_competition.rs    |  2 +
 crates/solvers-dto/src/solution.rs            | 13 ++++
 crates/solvers/openapi.yml                    | 18 ++++++
 .../src/api/routes/solve/dto/solution.rs      |  1 +
 16 files changed, 200 insertions(+), 5 deletions(-)
 create mode 100644 crates/driver/src/tests/cases/gas_fee_override.rs

diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index 2a668954e4..90aca59ee4 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -68,11 +68,24 @@ pub struct Solution {
     #[debug(ignore)]
     weth: eth::WrappedNativeToken,
     gas: Option<eth::Gas>,
+    gas_fee_override: Option<GasFeeOverride>,
     flashloans: HashMap<order::Uid, Flashloan>,
     #[debug(ignore)]
     wrappers: Vec<WrapperCall>,
 }
 
+/// Gas fee overrides provided by the solver, used instead of the driver's
+/// own gas price estimation during settlement submission.
+///
+/// Note: the driver may raise these values above what the solver specified
+/// if a pending replacement transaction requires a higher gas price (a node
+/// requirement for transaction replacement).
+#[derive(Clone, Copy, Debug)]
+pub struct GasFeeOverride {
+    pub max_fee_per_gas: u128,
+    pub max_priority_fee_per_gas: u128,
+}
+
 impl Solution {
     #[expect(clippy::too_many_arguments)]
     pub fn new(
@@ -85,6 +98,7 @@ impl Solution {
         solver: Solver,
         weth: eth::WrappedNativeToken,
         gas: Option<eth::Gas>,
+        gas_fee_override: Option<GasFeeOverride>,
         fee_handler: FeeHandler,
         surplus_capturing_jit_order_owners: &HashSet<eth::Address>,
         flashloans: HashMap<order::Uid, Flashloan>,
@@ -147,6 +161,7 @@ impl Solution {
             solver,
             weth,
             gas,
+            gas_fee_override,
             flashloans,
             wrappers,
         };
@@ -232,6 +247,10 @@ impl Solution {
         self.gas
     }
 
+    pub fn gas_fee_override(&self) -> Option<GasFeeOverride> {
+        self.gas_fee_override
+    }
+
     fn trade_count_for_scorable(
         &self,
         trade: &Trade,
@@ -397,6 +416,8 @@ impl Solution {
                 (None, Some(gas)) => Some(gas),
                 (None, None) => None,
             },
+            // Gas fee overrides are per-solution; no meaningful way to merge them.
+            gas_fee_override: None,
             flashloans,
             wrappers: self.wrappers.clone(),
         })
diff --git a/crates/driver/src/domain/competition/solution/settlement.rs b/crates/driver/src/domain/competition/solution/settlement.rs
index 20f3a245ff..907713046b 100644
--- a/crates/driver/src/domain/competition/solution/settlement.rs
+++ b/crates/driver/src/domain/competition/solution/settlement.rs
@@ -271,6 +271,11 @@ impl Settlement {
         self.solution.id()
     }
 
+    /// Optional gas fee overrides provided by the solver.
+    pub fn gas_fee_override(&self) -> Option<super::GasFeeOverride> {
+        self.solution.gas_fee_override()
+    }
+
     /// Solution's pre interactions
     pub fn pre_interactions(&self) -> &[domain::Interaction] {
         self.solution.pre_interactions()
diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index 314a4c6b04..7a83ea4160 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -1,5 +1,5 @@
 use {
-    super::competition::solution::settlement,
+    super::competition::solution::{GasFeeOverride, settlement},
     crate::{
         domain::{blockchain::TxStatus, competition::solution::Settlement},
         infra::{self, Ethereum, observe},
@@ -172,6 +172,12 @@ impl Mempools {
             _ => current_gas_price,
         };
 
+        let final_gas_price = apply_gas_fee_override(
+            final_gas_price,
+            settlement.gas_fee_override(),
+            replacement_gas_price.as_ref(),
+        );
+
         tracing::debug!(
             ?submission_block,
             ?blocks_until_deadline,
@@ -371,6 +377,36 @@ impl Mempools {
     }
 }
 
+/// Applies the solver's gas fee override if present. When a replacement
+/// transaction is pending, the solver's values are raised to at least the
+/// replacement minimum (a node requirement).
+fn apply_gas_fee_override(
+    driver_estimate: Eip1559Estimation,
+    solver_override: Option<GasFeeOverride>,
+    replacement_price: Option<&Eip1559Estimation>,
+) -> Eip1559Estimation {
+    let Some(gas_override) = solver_override else {
+        return driver_estimate;
+    };
+    let solver_price = Eip1559Estimation {
+        max_fee_per_gas: gas_override.max_fee_per_gas,
+        max_priority_fee_per_gas: gas_override.max_priority_fee_per_gas,
+    };
+    match replacement_price {
+        Some(replacement) => Eip1559Estimation {
+            max_fee_per_gas: std::cmp::max(
+                solver_price.max_fee_per_gas,
+                replacement.max_fee_per_gas,
+            ),
+            max_priority_fee_per_gas: std::cmp::max(
+                solver_price.max_priority_fee_per_gas,
+                replacement.max_priority_fee_per_gas,
+            ),
+        },
+        None => solver_price,
+    }
+}
+
 /// In EIP-7702 mode, reroute the tx through the solver EOA's delegated
 /// forwarder contract. The original target and calldata are wrapped in a
 /// `forward()` call. `from` is set to the submission EOA so that simulations
diff --git a/crates/driver/src/infra/solver/dto/solution.rs b/crates/driver/src/infra/solver/dto/solution.rs
index 8876aa225b..4b2de3266f 100644
--- a/crates/driver/src/infra/solver/dto/solution.rs
+++ b/crates/driver/src/infra/solver/dto/solution.rs
@@ -234,6 +234,24 @@ impl Solutions {
                     solver.clone(),
                     weth,
                     solution.gas.map(eth::Gas::from),
+                    solution
+                        .gas_fee_override
+                        .map(|o| {
+                            Ok(competition::solution::GasFeeOverride {
+                                max_fee_per_gas: o.max_fee_per_gas.try_into().map_err(|_| {
+                                    super::Error("max_fee_per_gas overflow".to_owned())
+                                })?,
+                                max_priority_fee_per_gas: o
+                                    .max_priority_fee_per_gas
+                                    .try_into()
+                                    .map_err(|_| {
+                                        super::Error(
+                                            "max_priority_fee_per_gas overflow".to_owned(),
+                                        )
+                                    })?,
+                            })
+                        })
+                        .transpose()?,
                     solver.config().fee_handler,
                     auction.surplus_capturing_jit_order_owners(),
                     solution.flashloans
diff --git a/crates/driver/src/tests/cases/gas_fee_override.rs b/crates/driver/src/tests/cases/gas_fee_override.rs
new file mode 100644
index 0000000000..6eb7884b55
--- /dev/null
+++ b/crates/driver/src/tests/cases/gas_fee_override.rs
@@ -0,0 +1,60 @@
+use {
+    crate::tests::{
+        self,
+        setup::{ab_order, ab_pool, ab_solution},
+    },
+    alloy::{consensus::Transaction, providers::Provider},
+};
+
+const MAX_FEE_PER_GAS: u128 = 100_000_000_000;
+const MAX_PRIORITY_FEE_PER_GAS: u128 = 2_000_000_000;
+
+/// Verify that a solution with custom gas fee overrides settles successfully
+/// and the overrides are applied to the on-chain transaction.
+#[tokio::test]
+#[ignore]
+async fn settle_with_gas_fee_override() {
+    let test = tests::setup()
+        .name("gas fee override")
+        .pool(ab_pool())
+        .order(ab_order())
+        .solution(ab_solution().gas_fee_override(MAX_FEE_PER_GAS, MAX_PRIORITY_FEE_PER_GAS))
+        .done()
+        .await;
+
+    let id = test.solve().await.ok().id();
+    test.settle(id)
+        .await
+        .ok()
+        .await
+        .ab_order_executed(&test)
+        .await;
+
+    // Verify the settlement transaction used the solver's gas fee override.
+    let block = test
+        .web3()
+        .provider
+        .get_block_by_number(Default::default())
+        .await
+        .unwrap()
+        .unwrap();
+    let tx_hash = block.transactions.hashes().next().unwrap();
+    let tx = test
+        .web3()
+        .provider
+        .get_transaction_by_hash(tx_hash)
+        .await
+        .unwrap()
+        .unwrap();
+    let consensus_tx: &dyn Transaction = &*tx.inner;
+    assert_eq!(
+        consensus_tx.max_fee_per_gas(),
+        MAX_FEE_PER_GAS,
+        "settlement tx should use the solver's maxFeePerGas override"
+    );
+    assert_eq!(
+        consensus_tx.max_priority_fee_per_gas(),
+        Some(MAX_PRIORITY_FEE_PER_GAS),
+        "settlement tx should use the solver's maxPriorityFeePerGas override"
+    );
+}
diff --git a/crates/driver/src/tests/cases/mod.rs b/crates/driver/src/tests/cases/mod.rs
index 7b0ac592f2..01c113db73 100644
--- a/crates/driver/src/tests/cases/mod.rs
+++ b/crates/driver/src/tests/cases/mod.rs
@@ -12,6 +12,7 @@ pub mod buy_eth;
 pub mod example_config;
 pub mod fees;
 mod flashloan_hints;
+pub mod gas_fee_override;
 pub mod haircut;
 pub mod internalization;
 pub mod jit_orders;
diff --git a/crates/driver/src/tests/setup/blockchain.rs b/crates/driver/src/tests/setup/blockchain.rs
index d6096eaf23..60b5e8a049 100644
--- a/crates/driver/src/tests/setup/blockchain.rs
+++ b/crates/driver/src/tests/setup/blockchain.rs
@@ -112,6 +112,7 @@ impl Pool {
 pub struct Solution {
     pub trades: Vec<Trade>,
     pub flashloans: HashMap<order::Uid, Flashloan>,
+    pub gas_fee_override: Option<(u128, u128)>,
 }
 
 #[derive(Debug, Clone)]
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index d4eb634ddb..602699d5ee 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -562,6 +562,7 @@ pub struct Solution {
     pub calldata: Calldata,
     pub orders: Vec<&'static str>,
     pub flashloans: HashMap<order::Uid, Flashloan>,
+    pub gas_fee_override: Option<(u128, u128)>,
 }
 
 impl Solution {
@@ -607,6 +608,14 @@ impl Solution {
         self.flashloans.insert(order, flashloan);
         self
     }
+
+    /// Set custom gas fee overrides for the solution.
+    pub fn gas_fee_override(self, max_fee_per_gas: u128, max_priority_fee_per_gas: u128) -> Self {
+        Self {
+            gas_fee_override: Some((max_fee_per_gas, max_priority_fee_per_gas)),
+            ..self
+        }
+    }
 }
 
 impl Default for Solution {
@@ -617,6 +626,7 @@ impl Default for Solution {
             },
             orders: Default::default(),
             flashloans: Default::default(),
+            gas_fee_override: None,
         }
     }
 }
@@ -662,7 +672,7 @@ pub fn ab_solution() -> Solution {
             additional_bytes: 0,
         },
         orders: vec!["A-B order"],
-        flashloans: Default::default(),
+        ..Default::default()
     }
 }
 
@@ -694,7 +704,7 @@ pub fn ad_solution() -> Solution {
             additional_bytes: 0,
         },
         orders: vec!["A-D order"],
-        flashloans: Default::default(),
+        ..Default::default()
     }
 }
 
@@ -726,7 +736,7 @@ pub fn cd_solution() -> Solution {
             additional_bytes: 0,
         },
         orders: vec!["C-D order"],
-        flashloans: Default::default(),
+        ..Default::default()
     }
 }
 
@@ -757,7 +767,7 @@ pub fn eth_solution() -> Solution {
             additional_bytes: 0,
         },
         orders: vec!["ETH order"],
-        flashloans: Default::default(),
+        ..Default::default()
     }
 }
 
@@ -952,6 +962,7 @@ impl Setup {
             solutions.push(blockchain::Solution {
                 trades: [fulfillment_trades, jit_trades].concat(),
                 flashloans: solution.flashloans.clone(),
+                gas_fee_override: solution.gas_fee_override,
             });
         }
         let orderbook = Orderbook::start(&orders).await;
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index 77c93cb4d4..1e9b37c4d5 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -388,6 +388,10 @@ impl Solver {
                 "interactions": interactions_json,
                 "preInteractions": pre_interactions_json,
             });
+            if let Some((max_fee, max_priority_fee)) = &solution.gas_fee_override {
+                solution_json["maxFeePerGas"] = json!(max_fee.to_string());
+                solution_json["maxPriorityFeePerGas"] = json!(max_priority_fee.to_string());
+            }
             if !solution.flashloans.is_empty() {
                 solution_json["flashloans"] = serde_json::Value::Object(
                     solution
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index ca4eb4c232..e2dc3ce564 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -355,6 +355,7 @@ async fn cow_amm_jit(web3: Web3) {
         gas: None,
         flashloans: None,
         wrappers: vec![],
+        gas_fee_override: None,
     }));
 
     // Drive solution
@@ -997,6 +998,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
             gas: None,
             flashloans: None,
             wrappers: vec![],
+            gas_fee_override: None,
         }
     };
 
diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs
index a400a34a4d..537b22f2f8 100644
--- a/crates/e2e/tests/e2e/jit_orders.rs
+++ b/crates/e2e/tests/e2e/jit_orders.rs
@@ -187,6 +187,7 @@ async fn single_limit_order_test(web3: Web3) {
         gas: None,
         flashloans: None,
         wrappers: vec![],
+        gas_fee_override: None,
     }));
 
     // Drive solution
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index e290918234..e4815b599c 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -334,6 +334,7 @@ http-timeout = "10s"
         gas: None,
         flashloans: None,
         wrappers: vec![],
+        gas_fee_override: None,
     }));
 
     // Wait for trade
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index f50249e4d9..d6ac28951b 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -508,6 +508,7 @@ async fn store_filtered_solutions(web3: Web3) {
         gas: None,
         flashloans: None,
         wrappers: vec![],
+        gas_fee_override: None,
     }));
 
     // bad solver settles both orders at 2:1. Because it can't beat the
@@ -538,6 +539,7 @@ async fn store_filtered_solutions(web3: Web3) {
         gas: None,
         flashloans: None,
         wrappers: vec![],
+        gas_fee_override: None,
     }));
 
     // Drive solution
diff --git a/crates/solvers-dto/src/solution.rs b/crates/solvers-dto/src/solution.rs
index df09e8f578..0a9d1b5ba7 100644
--- a/crates/solvers-dto/src/solution.rs
+++ b/crates/solvers-dto/src/solution.rs
@@ -57,6 +57,8 @@ pub struct Solution {
     pub post_interactions: Vec<Call>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub gas: Option<u64>,
+    #[serde(flatten)]
+    pub gas_fee_override: Option<GasFeeOverride>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub flashloans: Option<HashMap<OrderUid, Flashloan>>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
@@ -236,6 +238,17 @@ pub enum SigningScheme {
     Eip1271,
 }
 
+/// Solver-provided gas fee overrides for the settlement transaction.
+#[serde_as]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GasFeeOverride {
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub max_fee_per_gas: U256,
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub max_priority_fee_per_gas: U256,
+}
+
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
diff --git a/crates/solvers/openapi.yml b/crates/solvers/openapi.yml
index 24025a7123..98232cf589 100644
--- a/crates/solvers/openapi.yml
+++ b/crates/solvers/openapi.yml
@@ -1014,6 +1014,24 @@ components:
         gas:
           type: integer
           description: How many units of gas this solution is estimated to cost.
+        maxFeePerGas:
+          description: |
+            Optional maximum fee per gas for the settlement transaction.
+            Overrides the driver's default gas price estimation.
+            Must be provided together with maxPriorityFeePerGas.
+            Note: the driver may raise this value if a pending replacement
+            transaction requires a higher gas price.
+          allOf:
+            - $ref: "#/components/schemas/U256"
+        maxPriorityFeePerGas:
+          description: |
+            Optional maximum priority fee (tip) per gas for the settlement
+            transaction. Overrides the driver's default gas price estimation.
+            Must be provided together with maxFeePerGas.
+            Note: the driver may raise this value if a pending replacement
+            transaction requires a higher gas price.
+          allOf:
+            - $ref: "#/components/schemas/U256"
         flashloans:
           description: |
             Flashloans that are provided for this solution, mapping order UIDs to flashloan details.
diff --git a/crates/solvers/src/api/routes/solve/dto/solution.rs b/crates/solvers/src/api/routes/solve/dto/solution.rs
index c86106a580..c4da3dc843 100644
--- a/crates/solvers/src/api/routes/solve/dto/solution.rs
+++ b/crates/solvers/src/api/routes/solve/dto/solution.rs
@@ -118,6 +118,7 @@ pub fn from_domain(solutions: &[solution::Solution]) -> super::SolverResponse {
                 gas: solution
                     .gas
                     .map(|gas| u64::try_from(gas.0).unwrap_or(u64::MAX)),
+                gas_fee_override: None,
                 // rely on driver to fill in the blanks
                 flashloans: None,
                 wrappers: solution

From 62f7d9b8f87a66b156cbb559cdc64fa9a4abf76d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?= <duarte.gmj@gmail.com>
Date: Tue, 31 Mar 2026 15:49:08 +0100
Subject: [PATCH 178/219] Log custom solver errors on quoting (#4301)

# Description
Adds a log for the custom error that the solver returned

Context:
https://nomevlabs.slack.com/archives/C0375NV72SC/p1774966168341339?thread_ts=1774881240.020949&cid=C0375NV72SC

# Changes

* Log custom error

## How to test
NA
---
 crates/driver/src/infra/api/error.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/driver/src/infra/api/error.rs b/crates/driver/src/infra/api/error.rs
index 10eb6b0808..0b6529fa88 100644
--- a/crates/driver/src/infra/api/error.rs
+++ b/crates/driver/src/infra/api/error.rs
@@ -113,6 +113,7 @@ impl From<quote::Error> for (axum::http::StatusCode, axum::Json<Error>) {
         if let quote::Error::Solver(ref solver_err) = value
             && let Some(custom_err) = solver_err.custom_error()
         {
+            tracing::warn!(err=?custom_err, "received custom solver error, mapping to internal errors");
             let (kind, description) = map_custom_solver_error(custom_err);
             return (
                 axum::http::StatusCode::BAD_REQUEST,

From 5b22eceaa10ab98c61bb4619cd2e8b3f87df282d Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Wed, 1 Apr 2026 18:58:45 +0200
Subject: [PATCH 179/219] Simulation endpoint (#4275)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Based on #4265

Adds a /api/v1/debug/simulation/{uid} endpoint to the orderbook that
lets you simulate an order's execution via Tenderly.

# Changes
- debug_simulation.rs — new API handler that accepts an order UID and
returns the Tenderly simulation request + any error
- Orderbook::simulate_order() — fetches the order, encodes it as a swap,
simulates it, and returns the Tenderly request payload
- OrderSimulator struct — wraps SwapSimulator with chain ID context;
handles encoding orders into EncodedSwap and running simulations

### Notice
**Simulation runs against the current block (not a historical replay at
the block the order was filled), and that it uses the original order
amounts — so for partially filled orders, the full amount is simulated
against the trader's current balance.**

### Follow-up PR
- [ ] Add support to simulate on specific block number
https://github.com/cowprotocol/services/pull/4305
- [ ] Add support for partially filled orders.
- [ ] Custom order simulation (not an existing one)
https://github.com/cowprotocol/services/pull/4304

Encoding improvements in simulator:
- InteractionEncoding trait extracted so both Interaction and
InteractionData (from model crate) can be encoded — this allows order
pre/post interactions to be encoded directly without manual conversion
- WrapperCall struct + encode_wrapper_settlement() function added to
handle settlements that go through wrapper contracts
- SwapSimulator::fake_swap() extended to support wrapper contracts in
the query

Supporting changes:

- app-data: added wrappers() accessor to expose wrapper calls from app
data
- configs/orderbook: added config for the new simulator (optional —
order_simulation_gas_limit: None keeps existing behavior)
- price-estimation: refactored to use the new InteractionEncoding trait
- driver/encoding: cleanup — moved some encoding logic to the simulator
crate

The OpenAPI spec has been updated with:

Path `/api/v1/debug/simulation/{uid}` — GET endpoint that takes an order
UID and returns 200 (OrderSimulation), 404 (not found), 501 (not
enabled), or 500 (internal error).

New schemas:

- OrderSimulation — top-level response with tenderly_request and
optional error
- TenderlyRequest — the full Tenderly simulation request structure
- SimulationType — enum full | quick | abi:
- full (default): Detailed decoded output — call trace, function,
inputs/outputs, state diffs, and logs with Solidity types.
  - quick: Raw, minimal output only. Fastest option; no decoding.
- abi: Decoded function inputs/outputs and logs, but no state diffs.
Middle ground between quick and full.
AccessListItem — address + storage_keys
StateObject — balance/code/storage overrides

## How to test
Create order in local playground, query for its simulation. Verify on
tenderly.

Example output:
```json
{
    "tenderly_request": {
        "network_id": "1",
        "from": "0xfcc789354262dd9c2f2ff1b0a5f9067b55af1bfa",
        "to": "0xa513e6e4b8f2a923d98304ec87f64353c4d5c853",
        "input": "0x13d79a0b000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000032000000000000000000000000000000000000000000000000000000000000000020000000000000000000000005fbdb2315678afecb367f032d93f642f64180aa300000000000000000000000068b1d87f95878fe05b998f19b66f4baba5de1aed00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000001bc16d674ec8000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000009315fc8ffae493123b9b6b1c93d50c9b9eef03440000000000000000000000000000000000000000000000001bc16d674ec800000000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000000000000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000410000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000149315fc8ffae493123b9b6b1c93d50c9b9eef03440000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "gas": 16777215,
        "simulation_type": "full",
        "save": true,
        "save_if_fails": true,
        "state_objects": {
            "0x68b1d87f95878fe05b998f19b66f4baba5de1aed": {
                "storage": {
                    "0xd7a1f0b46140686e5b4c405dcbec93c326c8c0e52cb615e05dcf53ad4119c720": "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000"
                }
            },
            "0x9315fc8ffae493123b9b6b1c93d50c9b9eef0344": {
                "code": "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"
            },
            "0xfcc789354262dd9c2f2ff1b0a5f9067b55af1bfa": {
                "balance": "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
            },
            "0x5fc8d32690cc91d4c39d9d3abcbd16989f875707": {
                "code": "0x6080604052348015600e575f5ffd5b50600436106026575f3560e01c806302cc250d14602a575b5f5ffd5b603b6035366004604f565b50600190565b604051901515815260200160405180910390f35b5f60208284031215605e575f5ffd5b813573ffffffffffffffffffffffffffffffffffffffff811681146080575f5ffd5b939250505056fea164736f6c634300081e000a"
            }
        }
    },
    "error": null
}
```

# Migration Guide: simulation-endpoint branch
New field: order-simulation-gas-limit
A new optional top-level field has been added to the orderbook TOML
configuration.

Type: string (decimal integer, interpreted as U256)
Default: omitted / disabled


## Enable the order simulation debug endpoint
`order-simulation-gas-limit = "16777215"`
Effect:

When absent (default): the GET `/api/v1/debug/simulation/{uid}` endpoint
is disabled. Requests return a 501 Not Implemented response.
When present: the endpoint is enabled. The value sets the gas limit used
when simulating the order's settlement call via Tenderly (through the
price estimation driver's balance-override infrastructure).
Recommended value: "16777215" (0xFFFFFF — same as the E2E test default).
Adjust downward if you want to cap simulation gas usage.

No action required if you do not want to expose the simulation endpoint
— omitting the field is the safe default.

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: ilya <ilya@cow.fi>
---
 Cargo.lock                                    |   3 +
 crates/app-data/src/app_data.rs               |   7 +
 crates/configs/src/orderbook/mod.rs           |  35 ++-
 .../domain/competition/solution/encoding.rs   |  73 +-----
 .../src/domain/competition/solution/mod.rs    |   8 +-
 .../driver/src/infra/solver/dto/solution.rs   |   5 +-
 crates/e2e/src/setup/mod.rs                   |   1 +
 crates/e2e/tests/e2e/main.rs                  |   1 +
 crates/e2e/tests/e2e/order_simulation.rs      |  89 ++++++++
 crates/model/Cargo.toml                       |   1 +
 crates/orderbook/Cargo.toml                   |   2 +
 crates/orderbook/openapi.yml                  | 141 ++++++++++++
 crates/orderbook/src/api.rs                   |   6 +
 crates/orderbook/src/api/debug_simulation.rs  |  36 +++
 crates/orderbook/src/dto/mod.rs               |  12 +-
 crates/orderbook/src/lib.rs                   |   1 +
 crates/orderbook/src/order_simulator.rs       | 199 +++++++++++++++++
 crates/orderbook/src/orderbook.rs             |  47 +++-
 crates/orderbook/src/run.rs                   |  29 ++-
 .../price-estimation/src/trade_finding/mod.rs |  13 +-
 .../src/trade_verifier/mod.rs                 |  75 +++++--
 crates/simulator/src/encoding.rs              | 106 ++++++++-
 crates/simulator/src/swap_simulator.rs        | 211 +++++++++++-------
 crates/simulator/src/tenderly/dto.rs          |  41 +++-
 crates/simulator/src/tenderly/mod.rs          |  47 ++--
 25 files changed, 979 insertions(+), 210 deletions(-)
 create mode 100644 crates/e2e/tests/e2e/order_simulation.rs
 create mode 100644 crates/orderbook/src/api/debug_simulation.rs
 create mode 100644 crates/orderbook/src/order_simulator.rs

diff --git a/Cargo.lock b/Cargo.lock
index 291f0647f3..153add894f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4697,6 +4697,7 @@ dependencies = [
  "num",
  "number",
  "serde",
+ "serde-ext",
  "serde_json",
  "serde_with",
  "strum",
@@ -5131,6 +5132,7 @@ dependencies = [
  "async-trait",
  "axum 0.8.8",
  "bad-tokens",
+ "balance-overrides",
  "bigdecimal",
  "cached",
  "chain",
@@ -5164,6 +5166,7 @@ dependencies = [
  "serde_with",
  "shared",
  "signature-validator",
+ "simulator",
  "sqlx",
  "strum",
  "tempfile",
diff --git a/crates/app-data/src/app_data.rs b/crates/app-data/src/app_data.rs
index 8296705b2c..ea27b2563d 100644
--- a/crates/app-data/src/app_data.rs
+++ b/crates/app-data/src/app_data.rs
@@ -355,6 +355,13 @@ impl Root {
             backend: None,
         }
     }
+
+    pub fn wrappers(&self) -> &[WrapperCall] {
+        self.metadata
+            .as_ref()
+            .map(|metadata| metadata.wrappers.as_slice())
+            .unwrap_or_default()
+    }
 }
 
 /// Caches whether a given app data document contains wrappers, keyed by
diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index f695886573..225bd89619 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -13,7 +13,7 @@ use {
         price_estimation::PriceEstimation,
         shared::SharedConfig,
     },
-    alloy::primitives::Address,
+    alloy::primitives::{Address, U256},
     anyhow::anyhow,
     chrono::{DateTime, Utc},
     serde::{Deserialize, Serialize},
@@ -49,6 +49,12 @@ pub struct VolumeFeeConfig {
     pub effective_from_timestamp: Option<DateTime<Utc>>,
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct OrderSimulationConfig {
+    pub gas_limit: U256,
+}
+
 /// Top-level orderbook service configuration.
 // NOTE: cannot add deny_unknown_fields during the config migration
 #[derive(Debug, Deserialize)]
@@ -112,6 +118,10 @@ pub struct Configuration {
     /// 1inch, quote verification, balance overrides, etc.).
     #[serde(default)]
     pub price_estimation: PriceEstimation,
+
+    /// Order simulation configuration. If `None`, the endpoint is disabled.
+    #[serde(default)]
+    pub order_simulation: Option<OrderSimulationConfig>,
 }
 
 impl Configuration {
@@ -137,13 +147,16 @@ pub mod test_util {
         crate::{
             orderbook::{
                 Configuration,
+                OrderSimulationConfig,
                 default_active_order_competition_threshold,
                 default_app_data_size_limit,
                 default_bind_address,
                 native_price::NativePriceConfig,
             },
+            price_estimation::PriceEstimation,
             test_util::TestDefault,
         },
+        alloy::primitives::U256,
         std::path::Path,
     };
 
@@ -193,7 +206,17 @@ pub mod test_util {
                 database: TestDefault::test_default(),
                 http_client: Default::default(),
                 order_quoting: TestDefault::test_default(),
-                price_estimation: TestDefault::test_default(),
+                price_estimation: PriceEstimation {
+                    balance_overrides: crate::price_estimation::BalanceOverridesConfig {
+                        autodetect: true,
+                        ..Default::default()
+                    },
+                    ..TestDefault::test_default()
+                },
+                // Enable order simulation for testing
+                order_simulation: Some(OrderSimulationConfig {
+                    gas_limit: U256::try_from(16777215).expect("u64 can be converted to U256"),
+                }),
             }
         }
     }
@@ -243,6 +266,9 @@ mod tests {
 
         [order-quoting]
         price-estimation-drivers = []
+
+        [order-simulation]
+        gas-limit = "123456789"
         "#;
 
         let config: Configuration = toml::from_str(toml).unwrap();
@@ -252,6 +278,10 @@ mod tests {
         assert_eq!(config.unsupported_tokens.len(), 1);
         assert_eq!(config.banned_users.addresses.len(), 1);
         assert!(config.eip1271_skip_creation_validation);
+        assert_eq!(
+            config.order_simulation.map(|config| config.gas_limit),
+            Some(U256::from(123456789u64))
+        );
 
         assert!(matches!(
             config.order_validation.same_tokens_policy,
@@ -354,6 +384,7 @@ mod tests {
             database: TestDefault::test_default(),
             http_client: Default::default(),
             price_estimation: Default::default(),
+            order_simulation: Default::default(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/driver/src/domain/competition/solution/encoding.rs b/crates/driver/src/domain/competition/solution/encoding.rs
index f952690d35..f656c06113 100644
--- a/crates/driver/src/domain/competition/solution/encoding.rs
+++ b/crates/driver/src/domain/competition/solution/encoding.rs
@@ -12,10 +12,7 @@ use {
         infra::{self, solver::ManageNativeToken},
     },
     allowance::Allowance,
-    alloy::{
-        primitives::{Address, Bytes, FixedBytes, U256},
-        sol_types::SolCall,
-    },
+    alloy::primitives::{Address, Bytes, FixedBytes, U256},
     contracts::alloy::{FlashLoanRouter::LoanRequest, WETH9},
     eth_domain_types::{self as eth, Ether, allowance},
     itertools::Itertools,
@@ -209,9 +206,6 @@ pub fn tx(
         interactions.push(unwrap(native_unwrap, contracts.weth()));
     }
 
-    let has_flashloans = !solution.flashloans.is_empty();
-    let has_wrappers = !solution.wrappers.is_empty();
-
     // Encode the base settlement calldata
     let mut settle_calldata = contracts
         .settlement()
@@ -230,21 +224,24 @@ pub fn tx(
 
     // Append auction ID to settlement calldata
     settle_calldata.extend(auction.id().ok_or(Error::MissingAuctionId)?.to_be_bytes());
+    let has_flashloans = !solution.flashloans.is_empty();
+    let has_wrappers = !solution.wrappers.is_empty();
 
     let (to, calldata) = if has_flashloans && has_wrappers {
         return Err(Error::FlashloanWrappersIncompatible);
     } else if has_flashloans {
         encode_flashloan_settlement(solution, contracts, settle_calldata)?
     } else if has_wrappers {
-        encode_wrapper_settlement(solution, settle_calldata)
+        simulator::encoding::encode_wrapper_settlement(&solution.wrappers, settle_calldata.into())
+            .expect("wrappers is not empty")
     } else {
-        (*contracts.settlement().address(), settle_calldata)
+        (*contracts.settlement().address(), settle_calldata.into())
     };
 
     Ok(eth::Tx {
         from: solution.solver().address(),
         to,
-        input: calldata.into(),
+        input: calldata,
         value: Ether::zero(),
         access_list: Default::default(),
     })
@@ -260,7 +257,7 @@ fn encode_flashloan_settlement(
     solution: &super::Solution,
     contracts: &infra::blockchain::Contracts,
     settle_calldata: Vec<u8>,
-) -> Result<(eth::Address, Vec<u8>), Error> {
+) -> Result<(eth::Address, Bytes), Error> {
     // Get flashloan router contract
     let router = contracts
         .flashloan_router()
@@ -284,59 +281,7 @@ fn encode_flashloan_settlement(
         .calldata()
         .to_vec();
 
-    Ok((*router.address(), calldata))
-}
-
-/// Encodes a settlement transaction that uses wrapper contracts.
-///
-/// Takes the base settlement calldata and wraps it in a wrappedSettleCall
-/// with encoded wrapper metadata. Since wrappers are a chain, the wrapper
-/// address to call is also processed by this function.
-///
-/// Returns (first_wrapper_address, wrapped_calldata)
-fn encode_wrapper_settlement(
-    solution: &super::Solution,
-    settle_calldata: Vec<u8>,
-) -> (eth::Address, Vec<u8>) {
-    // Encode wrapper metadata
-    let wrapper_data = encode_wrapper_data(&solution.wrappers);
-
-    // Create wrappedSettleCall
-    let calldata = contracts::alloy::ICowWrapper::ICowWrapper::wrappedSettleCall {
-        settleData: settle_calldata.into(),
-        wrapperData: wrapper_data.into(),
-    }
-    .abi_encode();
-
-    (solution.wrappers[0].address, calldata)
-}
-
-/// Encodes wrapper metadata for wrapper settlement calls.
-///
-/// The format is:
-/// - For wrappers after the first: 20 bytes (address)
-/// - For each wrapper: 2 bytes (data length as u16 in native endian) + data
-///
-/// More information about wrapper encoding:
-/// https://www.notion.so/cownation/Generalized-Wrapper-2798da5f04ca8095a2d4c56b9d17134e?source=copy_link#2858da5f04ca807980bbf7f845354120
-///
-/// Note: The first wrapper address is omitted from the encoded data since it's
-/// already used as the transaction target.
-fn encode_wrapper_data(wrappers: &[super::WrapperCall]) -> Vec<u8> {
-    let mut wrapper_data = Vec::new();
-
-    for (index, w) in wrappers.iter().enumerate() {
-        // Skip first wrapper's address (it's the transaction target)
-        if index != 0 {
-            wrapper_data.extend(w.address.as_slice());
-        }
-
-        // Encode data length as u16 in native endian, then the data itself
-        wrapper_data.extend((w.data.len() as u16).to_be_bytes().to_vec());
-        wrapper_data.extend(w.data.clone());
-    }
-
-    wrapper_data
+    Ok((*router.address(), calldata.into()))
 }
 
 pub fn liquidity_interaction(
diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index 90aca59ee4..1f5c38c2cd 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -20,7 +20,7 @@ use {
     itertools::Itertools,
     num::{BigRational, One},
     number::conversions::{big_rational_to_u256, u256_to_big_int, u256_to_big_rational},
-    simulator::{self, Simulator},
+    simulator::{self, Simulator, encoding::WrapperCall},
     solvers_dto::solution::Flashloan,
     std::{
         collections::{BTreeSet, HashMap, HashSet, hash_map::Entry},
@@ -41,12 +41,6 @@ pub use {error::Error, interaction::Interaction, settlement::Settlement, trade::
 
 type Prices = HashMap<eth::TokenAddress, eth::U256>;
 
-#[derive(Clone)]
-pub struct WrapperCall {
-    pub address: eth::Address,
-    pub data: Vec<u8>,
-}
-
 // TODO Add a constructor and ensure that the clearing prices are included for
 // each trade
 /// A solution represents a set of orders which the solver has found an optimal
diff --git a/crates/driver/src/infra/solver/dto/solution.rs b/crates/driver/src/infra/solver/dto/solution.rs
index 4b2de3266f..6c7efdba7f 100644
--- a/crates/driver/src/infra/solver/dto/solution.rs
+++ b/crates/driver/src/infra/solver/dto/solution.rs
@@ -2,7 +2,7 @@ use {
     crate::{
         domain::{
             self,
-            competition::{self, solution::WrapperCall},
+            competition::{self},
             liquidity,
         },
         infra::Solver,
@@ -15,6 +15,7 @@ use {
         DomainSeparator,
         order::{BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
     },
+    simulator::encoding::WrapperCall,
     std::{collections::HashMap, str::FromStr},
 };
 
@@ -272,7 +273,7 @@ impl Solutions {
                             }).collect()),
                     solution.wrappers.iter().cloned().map(|w| WrapperCall {
                         address: w.address,
-                        data: w.data,
+                        data: w.data.into(),
                     }).collect(),
                 )
                 .map_err(|err| match err {
diff --git a/crates/e2e/src/setup/mod.rs b/crates/e2e/src/setup/mod.rs
index 7fa2186162..c5277e9a17 100644
--- a/crates/e2e/src/setup/mod.rs
+++ b/crates/e2e/src/setup/mod.rs
@@ -94,6 +94,7 @@ const DEFAULT_FILTERS: &[&str] = &[
     "solver=debug",
     "solvers=debug",
     "orderbook::api::request_summary=off",
+    "simulator=debug",
 ];
 
 fn with_default_filters<T>(custom_filters: impl IntoIterator<Item = T>) -> Vec<String>
diff --git a/crates/e2e/tests/e2e/main.rs b/crates/e2e/tests/e2e/main.rs
index b7e1668b67..7240e75349 100644
--- a/crates/e2e/tests/e2e/main.rs
+++ b/crates/e2e/tests/e2e/main.rs
@@ -25,6 +25,7 @@ mod liquidity;
 mod liquidity_source_notification;
 mod malformed_requests;
 mod order_cancellation;
+mod order_simulation;
 mod parallel_settlement;
 mod partial_fill;
 mod partially_fillable_balance;
diff --git a/crates/e2e/tests/e2e/order_simulation.rs b/crates/e2e/tests/e2e/order_simulation.rs
new file mode 100644
index 0000000000..c5c32a78d8
--- /dev/null
+++ b/crates/e2e/tests/e2e/order_simulation.rs
@@ -0,0 +1,89 @@
+use {
+    configs::test_util::TestDefault,
+    e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
+    ethrpc::{Web3, alloy::CallBuilderExt},
+    model::{
+        order::{OrderCreation, OrderKind},
+        signature::EcdsaSigningScheme,
+    },
+    number::units::EthUnit,
+    orderbook::dto::OrderSimulationResult,
+    reqwest::StatusCode,
+    simulator::tenderly::dto::SimulationType,
+};
+
+#[tokio::test]
+#[ignore]
+async fn local_node_order_simulation() {
+    run_test(order_simulation).await;
+}
+
+async fn order_simulation(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
+            configs::orderbook::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    let order = OrderCreation {
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: 2u64.eth(),
+        buy_token: *token.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Buy,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let uid = services.create_order(&order).await.unwrap();
+
+    let client = services.client();
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let response = response.json::<OrderSimulationResult>().await.unwrap();
+    assert_eq!(response.error, None);
+
+    let tenderly = response.tenderly_request;
+    // check if the fields that are directly derived from the simulation have
+    // correct values in the tenderly request object
+    assert_eq!(tenderly.to, *onchain.contracts().gp_settlement.address());
+    assert_eq!(tenderly.simulation_type, Some(SimulationType::Full));
+    assert_eq!(tenderly.value, None);
+}
diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml
index 9596e78ec2..11a18ef36c 100644
--- a/crates/model/Cargo.toml
+++ b/crates/model/Cargo.toml
@@ -24,6 +24,7 @@ hex-literal = { workspace = true }
 num = { workspace = true }
 number = { workspace = true }
 serde = { workspace = true }
+serde-ext = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
 strum = { workspace = true }
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index 04ffa83848..f76a12bb56 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -23,6 +23,7 @@ app-data = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
 bad-tokens = { workspace = true }
+balance-overrides = { workspace = true }
 bigdecimal = { workspace = true }
 cached = { workspace = true }
 chain = { workspace = true }
@@ -55,6 +56,7 @@ serde_json = { workspace = true }
 serde_with = { workspace = true }
 shared = { workspace = true }
 signature-validator = { workspace = true }
+simulator = { workspace = true }
 sqlx = { workspace = true }
 strum = { workspace = true }
 tempfile = { workspace = true, optional = true }
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 236f85d68e..8c855417ca 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -765,6 +765,34 @@ paths:
                 $ref: "#/components/schemas/TotalSurplus"
         "400":
           description: Invalid address.
+  "/api/v1/debug/simulation/{uid}":
+    get:
+      operationId: debugSimulation
+      summary: Get Tenderly simulation request for an order.
+      description: >
+        Returns the Tenderly simulation request that would be used to simulate
+        the given order, along with any simulation error if applicable.
+      parameters:
+        - in: path
+          name: uid
+          schema:
+            $ref: "#/components/schemas/UID"
+          required: true
+      responses:
+        "200":
+          description: Simulation request returned.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/OrderSimulation"
+        "400":
+          description: Invalid order UID.
+        "404":
+          description: Order not found.
+        "405":
+          description: Order simulation endpoint is not enabled.
+        "500":
+          description: Internal error.
   "/api/v1/debug/order/{uid}":
     get:
       operationId: debugOrder
@@ -2523,3 +2551,116 @@ components:
           type: number
         priceImprovementMaxVolumeFactor:
           type: number
+    SimulationType:
+      description: The kind of Tenderly simulation to run.
+      type: string
+      enum:
+        - full
+        - quick
+    AccessListItem:
+      type: object
+      properties:
+        address:
+          $ref: "#/components/schemas/Address"
+        storage_keys:
+          type: array
+          items:
+            description: 32 byte storage key encoded as hex with `0x` prefix.
+            type: string
+            example: "0x0000000000000000000000000000000000000000000000000000000000000000"
+      required:
+        - address
+        - storage_keys
+    StateObject:
+      description: State overrides for a given account before simulation.
+      type: object
+      properties:
+        balance:
+          description: Fake balance to set for the account (decimal-encoded uint256).
+          type: string
+          example: "1000000000000000000"
+        code:
+          description: Fake EVM bytecode to inject into the account (hex with `0x` prefix).
+          type: string
+          example: "0x6080604052"
+        storage:
+          description: >
+            Fake key-value mapping to override individual storage slots.
+            Keys and values are 32-byte hex strings with `0x` prefix.
+          type: object
+          additionalProperties:
+            type: string
+    TenderlyRequest:
+      description: A Tenderly transaction simulation request.
+      type: object
+      properties:
+        network_id:
+          description: The network identifier (e.g. "1" for mainnet).
+          type: string
+          example: "1"
+        block_number:
+          description: Block number to simulate the transaction at.
+          type: integer
+        transaction_index:
+          description: Transaction index within the block.
+          type: integer
+        from:
+          $ref: "#/components/schemas/Address"
+        to:
+          $ref: "#/components/schemas/Address"
+        input:
+          allOf:
+            - $ref: "#/components/schemas/CallData"
+          description: Transaction calldata encoded as hex with `0x` prefix.
+        gas:
+          description: Gas limit for the transaction.
+          type: integer
+        gas_price:
+          description: Gas price in Wei.
+          type: integer
+        value:
+          description: ETH value to send with the transaction (decimal-encoded uint256).
+          type: string
+          example: "0"
+        simulation_type:
+          $ref: "#/components/schemas/SimulationType"
+        save:
+          description: Whether to save the simulation on Tenderly.
+          type: boolean
+        save_if_fails:
+          description: Whether to save the simulation only if it fails.
+          type: boolean
+        generate_access_list:
+          description: Whether to generate an access list for the transaction.
+          type: boolean
+        state_objects:
+          description: >
+            State overrides applied before simulation. Keys are account
+            addresses (hex with `0x` prefix).
+          type: object
+          additionalProperties:
+            $ref: "#/components/schemas/StateObject"
+        access_list:
+          description: EIP-2930 access list for the transaction.
+          type: array
+          items:
+            $ref: "#/components/schemas/AccessListItem"
+      required:
+        - network_id
+        - from
+        - to
+        - input
+    OrderSimulation:
+      description: >
+        The Tenderly simulation request for an order, along with any
+        simulation error.
+      type: object
+      properties:
+        tenderly_request:
+          $ref: "#/components/schemas/TenderlyRequest"
+        error:
+          description: Simulation error message, if the simulation failed.
+          type: string
+          nullable: true
+      required:
+        - tenderly_request
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index ecd219105d..550fe52de4 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -30,6 +30,7 @@ use {
 mod cancel_order;
 mod cancel_orders;
 mod debug_order;
+mod debug_simulation;
 mod get_app_data;
 mod get_auction;
 mod get_native_price;
@@ -265,6 +266,11 @@ pub fn handle_all_routes(
             "/api/v1/debug/order/{uid}",
             get(debug_order::debug_order_handler),
         ),
+        (
+            "GET",
+            "/api/v1/debug/simulation/{uid}",
+            get(debug_simulation::debug_simulation_handler),
+        ),
         // V2 routes
         // /solver_competition routes (specific before parameterized)
         (
diff --git a/crates/orderbook/src/api/debug_simulation.rs b/crates/orderbook/src/api/debug_simulation.rs
new file mode 100644
index 0000000000..d3beb010f2
--- /dev/null
+++ b/crates/orderbook/src/api/debug_simulation.rs
@@ -0,0 +1,36 @@
+use {
+    crate::{api::AppState, orderbook::OrderSimulationError},
+    axum::{
+        extract::{Path, State},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+    },
+    model::order::OrderUid,
+    std::sync::Arc,
+};
+
+pub async fn debug_simulation_handler(
+    State(state): State<Arc<AppState>>,
+    Path(uid): Path<OrderUid>,
+) -> Response {
+    match state.orderbook.simulate_order(&uid).await {
+        Ok(Some(result)) => (StatusCode::OK, Json(result)).into_response(),
+        Ok(None) => (
+            StatusCode::NOT_FOUND,
+            super::error("NotFound", "order not found"),
+        )
+            .into_response(),
+        Err(OrderSimulationError::NotEnabled) => (
+            StatusCode::METHOD_NOT_ALLOWED,
+            super::error(
+                "MethodNotAllowed",
+                "order simulation endpoint is not enabled",
+            ),
+        )
+            .into_response(),
+        Err(OrderSimulationError::Other(err)) => {
+            tracing::error!(?err, "failed to create simulation for order");
+            crate::api::internal_error_reply()
+        }
+    }
+}
diff --git a/crates/orderbook/src/dto/mod.rs b/crates/orderbook/src/dto/mod.rs
index 312b356638..6e1d2bb1d5 100644
--- a/crates/orderbook/src/dto/mod.rs
+++ b/crates/orderbook/src/dto/mod.rs
@@ -4,14 +4,24 @@ pub mod order;
 use {
     alloy::primitives::U256,
     number::serialization::HexOrDecimalU256,
-    serde::Serialize,
+    serde::{Deserialize, Serialize},
     serde_with::serde_as,
+    simulator::tenderly,
 };
 pub use {
     auction::{Auction, AuctionId, AuctionWithId},
     order::Order,
 };
 
+/// The result of Order simulation, contains the error (if any)
+/// and full Tenderly API request that can be used to resimulate
+/// and debug using Tenderly
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct OrderSimulationResult {
+    pub tenderly_request: tenderly::dto::Request,
+    pub error: Option<String>,
+}
+
 #[serde_as]
 #[derive(Serialize)]
 #[cfg_attr(feature = "e2e", derive(serde::Deserialize))]
diff --git a/crates/orderbook/src/lib.rs b/crates/orderbook/src/lib.rs
index 2b380334fa..c5c92d4a6a 100644
--- a/crates/orderbook/src/lib.rs
+++ b/crates/orderbook/src/lib.rs
@@ -5,6 +5,7 @@ pub mod database;
 pub mod dto;
 mod ipfs;
 mod ipfs_app_data;
+pub mod order_simulator;
 pub mod orderbook;
 mod quoter;
 pub mod run;
diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
new file mode 100644
index 0000000000..95d2500be9
--- /dev/null
+++ b/crates/orderbook/src/order_simulator.rs
@@ -0,0 +1,199 @@
+use {
+    crate::dto::OrderSimulationResult,
+    alloy::{
+        primitives::{Address, U256},
+        rpc::types::state::AccountOverride,
+    },
+    anyhow::{Context, Result},
+    balance_overrides::BalanceOverrideRequest,
+    contracts::alloy::support::{AnyoneAuthenticator, Trader},
+    model::order::Order,
+    simulator::{
+        encoding::InteractionEncoding,
+        swap_simulator::{EncodedSwap, Query, SwapSimulator, TradeEncoding},
+    },
+};
+
+pub struct OrderSimulator {
+    simulator: SwapSimulator,
+    chain_id: String,
+}
+
+impl OrderSimulator {
+    pub fn new(simulator: SwapSimulator, chain_id: String) -> Self {
+        Self {
+            simulator,
+            chain_id,
+        }
+    }
+
+    pub async fn encode_order(&self, order: &Order) -> Result<EncodedSwap> {
+        let Some(app_data) = &order.metadata.full_app_data else {
+            anyhow::bail!("App data is not known for order {}", order.metadata.uid)
+        };
+        let app_data = serde_json::from_str::<app_data::Root>(app_data)?;
+
+        let tokens = vec![order.data.sell_token, order.data.buy_token];
+        // Clearing prices represent the limit price of the order; both order kinds
+        // produce the same ratio: [buy_amount, sell_amount] for [sell_token,
+        // buy_token].
+        let clearing_prices = vec![order.data.buy_amount, order.data.sell_amount];
+
+        let solver = Address::random();
+        // TODO(m-sz): Add support for specifying a partially filled order (current fill
+        // status or custom amount)
+        let query = Query {
+            sell_amount: order.data.sell_amount.try_into()?,
+            sell_token: order.data.sell_token,
+            buy_amount: order.data.buy_amount,
+            buy_token: order.data.buy_token,
+            kind: order.data.kind,
+            receiver: order.data.receiver.unwrap_or(order.metadata.owner),
+            sell_token_source: order.data.sell_token_balance,
+            buy_token_destination: order.data.buy_token_balance,
+            from: order.metadata.owner,
+            tx_origin: None,
+            clearing_prices,
+            solver,
+            tokens,
+            wrappers: app_data
+                .wrappers()
+                .iter()
+                .map(|wrapper| simulator::encoding::WrapperCall {
+                    address: wrapper.address,
+                    data: wrapper.data.clone().into(),
+                })
+                .collect(),
+        };
+
+        let swap = self
+            .simulator
+            .fake_swap(&query, TradeEncoding::Simple)
+            .await?;
+        let swap = add_interactions(swap, order);
+        let swap = self.add_state_overrides(&query, swap).await?;
+
+        Ok(swap)
+    }
+
+    /// Simulates a swap of the provided EncodedSwap.
+    ///
+    /// The result contains the transaction simulation error (if any)
+    /// and a full API request object that can be used to resimulate the swap
+    /// using Tenderly.
+    pub async fn simulate_swap(&self, swap: EncodedSwap) -> Result<OrderSimulationResult> {
+        let result = self.simulator.simulate_settle_call(swap).await?;
+
+        let tenderly_request = simulator::tenderly::dto::Request {
+            transaction_index: None,
+            save: Some(true),
+            save_if_fails: Some(true),
+            ..simulator::tenderly::prepare_request(
+                self.chain_id.clone(),
+                &result.tx,
+                result.overrides,
+                None,
+            )?
+        };
+
+        Ok(OrderSimulationResult {
+            tenderly_request,
+            error: result.result.err().map(|err| err.to_string()),
+        })
+    }
+
+    pub async fn add_state_overrides(
+        &self,
+        query: &Query,
+        mut swap: EncodedSwap,
+    ) -> Result<EncodedSwap> {
+        // Override authenticator with AnyoneAuthenticator so our fake solver is
+        // accepted.
+        let authenticator = self
+            .simulator
+            .settlement
+            .authenticator()
+            .call()
+            .await
+            .context("could not fetch authenticator")?;
+        swap.overrides.insert(
+            authenticator,
+            AccountOverride {
+                code: Some(AnyoneAuthenticator::AnyoneAuthenticator::DEPLOYED_BYTECODE.clone()),
+                ..Default::default()
+            },
+        );
+
+        // Set up fake solver.
+        swap.overrides.insert(
+            query.solver,
+            AccountOverride {
+                // Allow solver simulations to proceed even if the real account holds no ETH.
+                // The number is obscenely large, but not max to avoid potential overflows.
+                // We had this set to eth(1), but some simulations require more than that on non-ETH
+                // networks e.g. polygon so it led to reverts.
+                balance: Some(U256::MAX / U256::from(2)),
+                ..Default::default()
+            },
+        );
+
+        // Override trader address with Trader bytecode so EIP-1271 signature
+        // verification works for EOA traders (settlement calls isValidSignature
+        // on the trader address, which would revert for plain EOAs).
+        swap.overrides.insert(
+            query.from,
+            AccountOverride {
+                code: Some(Trader::Trader::DEPLOYED_BYTECODE.clone()),
+                ..Default::default()
+            },
+        );
+
+        // Fund the settlement contract with enough buy tokens to be paid out
+        match self
+            .simulator
+            .balance_overrides
+            .state_override(BalanceOverrideRequest {
+                token: query.buy_token,
+                holder: *self.simulator.settlement.address(),
+                amount: query.buy_amount,
+            })
+            .await
+        {
+            Some((token, balance_override)) => {
+                swap.overrides.insert(token, balance_override);
+            }
+            None => {
+                tracing::warn!("Could not set state balance override for the settlement contract");
+            }
+        };
+
+        Ok(swap)
+    }
+}
+
+fn add_interactions(mut swap: EncodedSwap, order: &Order) -> EncodedSwap {
+    // Add order pre interactions before encoded swap's pre interactions
+    let pre_interactions = order
+        .interactions
+        .pre
+        .iter()
+        .map(InteractionEncoding::encode)
+        .collect();
+    // Prepend order pre_interactions so they run first
+    let settlement_pre_interactions =
+        std::mem::replace(&mut swap.settlement.interactions.pre, pre_interactions);
+    swap.settlement
+        .interactions
+        .pre
+        .extend(settlement_pre_interactions);
+
+    // Add order post interactions after encoded swap's post interactions
+    let post_interactions = order
+        .interactions
+        .post
+        .iter()
+        .map(InteractionEncoding::encode);
+    swap.settlement.interactions.post.extend(post_interactions);
+
+    swap
+}
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index 9cc13f356e..5c512af88a 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -4,7 +4,8 @@ use {
             orders::{InsertionError, OrderStoring},
             trades::{TradeFilter, TradeRetrieving},
         },
-        dto,
+        dto::{self, OrderSimulationResult},
+        order_simulator::OrderSimulator,
         solver_competition::{Identifier, LoadSolverCompetitionError, SolverCompetitionStoring},
     },
     alloy::primitives::{Address, B256},
@@ -235,9 +236,11 @@ pub struct Orderbook {
     order_validator: Arc<dyn OrderValidating>,
     app_data: Arc<crate::app_data::Registry>,
     active_order_competition_threshold: u32,
+    order_simulator: Option<Arc<OrderSimulator>>,
 }
 
 impl Orderbook {
+    #[expect(clippy::too_many_arguments)]
     pub fn new(
         domain_separator: DomainSeparator,
         settlement_contract: Address,
@@ -246,6 +249,7 @@ impl Orderbook {
         order_validator: Arc<dyn OrderValidating>,
         app_data: Arc<crate::app_data::Registry>,
         active_order_competition_threshold: u32,
+        order_simulator: Option<Arc<OrderSimulator>>,
     ) -> Self {
         Metrics::initialize();
         Self {
@@ -256,6 +260,7 @@ impl Orderbook {
             order_validator,
             app_data,
             active_order_competition_threshold,
+            order_simulator,
         }
     }
 
@@ -603,6 +608,37 @@ impl Orderbook {
         };
         Ok(status)
     }
+
+    /// Simulates an order based on its Uid using the OrderSimulator.
+    ///
+    /// The returned value contains the simulation result and tenderly API
+    /// request object that can be used to debug it.
+    pub async fn simulate_order(
+        &self,
+        uid: &OrderUid,
+    ) -> Result<Option<OrderSimulationResult>, OrderSimulationError> {
+        let Some(order_simulator) = &self.order_simulator else {
+            return Err(OrderSimulationError::NotEnabled);
+        };
+        let Some(order) = self
+            .get_order(uid)
+            .await
+            .map_err(OrderSimulationError::Other)?
+        else {
+            return Ok(None);
+        };
+
+        let swap = order_simulator
+            .encode_order(&order)
+            .await
+            .map_err(OrderSimulationError::Other)?;
+        Ok(Some(
+            order_simulator
+                .simulate_swap(swap)
+                .await
+                .map_err(OrderSimulationError::Other)?,
+        ))
+    }
 }
 
 #[derive(Error, Debug)]
@@ -622,6 +658,14 @@ impl From<LoadSolverCompetitionError> for OrderStatusError {
     }
 }
 
+#[derive(Error, Debug)]
+pub enum OrderSimulationError {
+    #[error("order simulation is not enabled")]
+    NotEnabled,
+    #[error("simulation could not be created for order")]
+    Other(anyhow::Error),
+}
+
 #[async_trait::async_trait]
 impl LivenessChecking for Orderbook {
     async fn is_alive(&self) -> bool {
@@ -707,6 +751,7 @@ mod tests {
             settlement_contract: Address::repeat_byte(0xba),
             app_data,
             active_order_competition_threshold: Default::default(),
+            order_simulator: None,
         };
 
         // Different owner
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index e2d60445ec..cd50094325 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -5,6 +5,7 @@ use {
         database::Postgres,
         ipfs::Ipfs,
         ipfs_app_data::IpfsAppData,
+        order_simulator::OrderSimulator,
         orderbook::Orderbook,
         quoter::QuoteHandler,
     },
@@ -42,6 +43,7 @@ use {
         order_quoting::{self, OrderQuoter},
         order_validation::{OrderValidPeriodConfiguration, OrderValidator},
     },
+    simulator::swap_simulator::SwapSimulator,
     std::{future::Future, net::SocketAddr, sync::Arc, time::Duration},
     token_info::{CachedTokenInfoFetcher, TokenInfoFetcher},
     tokio::task::{self, JoinHandle},
@@ -196,7 +198,7 @@ pub async fn run(config: Configuration) {
             balances_contract.clone(),
             vault_relayer,
             vault_address,
-            balance_overrider,
+            balance_overrider.clone(),
         ),
     );
 
@@ -373,7 +375,7 @@ pub async fn run(config: Configuration) {
         .await
         .ok();
     let order_validator = Arc::new(OrderValidator::new(
-        native_token,
+        native_token.clone(),
         Arc::new(order_validation::banned::Users::new(
             chainalysis_oracle,
             config.banned_users.addresses,
@@ -407,6 +409,28 @@ pub async fn run(config: Configuration) {
         postgres_write.clone(),
         ipfs,
     ));
+
+    let order_simulator = if let Some(config) = config.order_simulation {
+        Some(Arc::new(OrderSimulator::new(
+            SwapSimulator::new(
+                balance_overrider.clone(),
+                *settlement_contract.address(),
+                *native_token.address(),
+                current_block_stream.clone(),
+                web3,
+                config
+                    .gas_limit
+                    .try_into()
+                    .expect("gas_limit must fit in u64"),
+            )
+            .await
+            .expect("failed to create SwapSimulator"),
+            chain.id().to_string(),
+        )))
+    } else {
+        None
+    };
+
     let orderbook = Arc::new(Orderbook::new(
         domain_separator,
         *settlement_contract.address(),
@@ -415,6 +439,7 @@ pub async fn run(config: Configuration) {
         order_validator.clone(),
         app_data.clone(),
         config.active_order_competition_threshold,
+        order_simulator,
     ));
 
     check_database_connection(orderbook.as_ref()).await;
diff --git a/crates/price-estimation/src/trade_finding/mod.rs b/crates/price-estimation/src/trade_finding/mod.rs
index 0b742fdbf3..9a74e3dc51 100644
--- a/crates/price-estimation/src/trade_finding/mod.rs
+++ b/crates/price-estimation/src/trade_finding/mod.rs
@@ -6,7 +6,7 @@ pub mod trade_estimator;
 
 use {
     crate::{PriceEstimationError, Query},
-    alloy::primitives::{Address, U256},
+    alloy::primitives::{Address, Bytes, U256},
     anyhow::{Context, Result},
     derive_more::Debug,
     external::dto,
@@ -14,6 +14,7 @@ use {
     num::CheckedDiv,
     number::{conversions::big_rational_to_u256, u256_ext::U256Ext},
     serde::{Deserialize, Serialize},
+    simulator::encoding::InteractionEncoding,
     std::{collections::HashMap, ops::Mul},
     thiserror::Error,
 };
@@ -214,9 +215,15 @@ impl Interaction {
             call_data: self.data.clone(),
         }
     }
+}
 
-    pub fn encode(self) -> simulator::encoding::EncodedInteraction {
-        simulator::encoding::Interaction::from(self).encode()
+impl InteractionEncoding for Interaction {
+    fn encode(&self) -> simulator::encoding::EncodedInteraction {
+        (
+            self.target,
+            self.value,
+            Bytes::copy_from_slice(self.data.as_slice()),
+        )
     }
 }
 
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index 5642737e35..641e670ab1 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -39,8 +39,8 @@ use {
         nonzero::NonZeroU256,
     },
     simulator::{
-        encoding::{EncodedTrade, encode_trade},
-        swap_simulator::{EncodedSwap, SwapSimulator},
+        encoding::{EncodedTrade, InteractionEncoding, encode_trade},
+        swap_simulator::{EncodedSwap, SwapSimulator, TradeEncoding},
         tenderly::{self},
     },
     std::{
@@ -148,12 +148,19 @@ impl TradeVerifier {
             TradeKind::Regular(trade) => trade.clearing_prices.iter().unzip(),
         };
 
+        let (sell_amount, buy_amount) = match query.kind {
+            OrderKind::Sell => (query.in_amount, *out_amount),
+            OrderKind::Buy => (
+                NonZeroU256::try_from(*out_amount).context("computed sell amount is zero")?,
+                query.in_amount.get(),
+            ),
+        };
         let simulator_query = simulator::swap_simulator::Query {
-            in_token: query.sell_token,
-            out_token: query.buy_token,
+            sell_token: query.sell_token,
+            buy_token: query.buy_token,
             kind: query.kind,
-            in_amount: query.in_amount,
-            out_amount: *out_amount,
+            sell_amount,
+            buy_amount,
             receiver: verification.receiver,
             sell_token_source: verification.sell_token_source,
             buy_token_destination: verification.buy_token_destination,
@@ -162,11 +169,12 @@ impl TradeVerifier {
             solver: solver_address,
             tokens: tokens.clone(),
             clearing_prices,
+            wrappers: Default::default(),
         };
 
         let mut swap = self
             .simulator
-            .fake_swap(simulator_query)
+            .fake_swap(&simulator_query, TradeEncoding::Disadvantageous)
             .await
             .map_err(Error::SimulationFailed)?;
 
@@ -177,26 +185,31 @@ impl TradeVerifier {
                 .iter()
                 // pre_interactions introduced by the solver
                 .chain(trade.pre_interactions())
-                .cloned()
-                .map(Interaction::encode)
+                .map(InteractionEncoding::encode)
                 .collect::<Vec<_>>();
 
-        // Join custom pre_interactions
+        // Join custom pre_interactions in the following order:
+        // pre_interactions, trade setup interaction, encoded swap pre interactions
+        pre_interactions.extend([self
+            .trade_setup_interaction(out_amount, &verification, query, trade)
+            .encode()]);
         pre_interactions.extend(swap.settlement.interactions.pre);
         swap.settlement.interactions.pre = pre_interactions;
 
-        // Interactions introduced by the solver
-        let interactions = trade.interactions().cloned().map(Interaction::encode);
+        // Join interactions introduced by the solver, set up in the following order:
+        // trade interactions, encoded swap interactions
+        let interactions = trade.interactions().map(InteractionEncoding::encode);
         swap.settlement.interactions.main = interactions
             .into_iter()
             .chain(swap.settlement.interactions.main)
             .collect();
 
+        // Join post interactions in the following order:
+        // encoded swap post interactions, verification post interactions,
         let post_interactions = verification
             .post_interactions
             .iter()
-            .cloned()
-            .map(Interaction::encode);
+            .map(InteractionEncoding::encode);
         swap.settlement.interactions.post = swap
             .settlement
             .interactions
@@ -214,7 +227,7 @@ impl TradeVerifier {
                 &self.simulator.domain_separator,
             )?);
         }
-        let output = self.simulator.simulate_swap(swap).await?;
+        let output = self.simulator.simulate_swap_with_solver(swap).await?;
 
         if let Some(tenderly) = &self.tenderly
             && let Err(err) = tenderly.log_simulation_command(output.tx, output.overrides, None)
@@ -475,6 +488,38 @@ impl TradeVerifier {
 
         Ok(overrides)
     }
+
+    /// Create interaction that sets up the trade right before transfering
+    /// funds. This interaction does nothing if the user-provided
+    /// pre-interactions already set everything up (e.g. approvals,
+    /// balances). That way we can correctly verify quotes with or without
+    /// these user pre-interactions with helpful error messages.
+    fn trade_setup_interaction(
+        &self,
+        out_amount: &U256,
+        verification: &Verification,
+        query: &PriceQuery,
+        trade: &TradeKind,
+    ) -> Interaction {
+        let sell_amount = match query.kind {
+            OrderKind::Sell => query.in_amount.get(),
+            OrderKind::Buy => *out_amount,
+        };
+        let setup_call = Solver::Solver::ensureTradePreconditionsCall {
+            trader: verification.from,
+            settlementContract: *self.settlement.address(),
+            sellToken: query.sell_token,
+            sellAmount: sell_amount,
+            nativeToken: self.simulator.native_token,
+            spardose: Self::SPARDOSE,
+        }
+        .abi_encode();
+        Interaction {
+            target: trade.solver(),
+            value: U256::ZERO,
+            data: setup_call,
+        }
+    }
 }
 
 #[async_trait::async_trait]
diff --git a/crates/simulator/src/encoding.rs b/crates/simulator/src/encoding.rs
index da4771bfc2..c82dfc5cc1 100644
--- a/crates/simulator/src/encoding.rs
+++ b/crates/simulator/src/encoding.rs
@@ -197,21 +197,37 @@ pub struct Interaction {
     pub data: Vec<u8>,
 }
 
+pub trait InteractionEncoding {
+    fn encode(&self) -> EncodedInteraction;
+}
+
 impl Interaction {
-    pub fn encode(&self) -> EncodedInteraction {
+    pub fn to_interaction_data(&self) -> InteractionData {
+        InteractionData {
+            target: self.target,
+            value: self.value,
+            call_data: self.data.clone(),
+        }
+    }
+}
+
+impl InteractionEncoding for Interaction {
+    fn encode(&self) -> EncodedInteraction {
         (
             self.target,
             self.value,
             Bytes::copy_from_slice(self.data.as_slice()),
         )
     }
+}
 
-    pub fn to_interaction_data(&self) -> InteractionData {
-        InteractionData {
-            target: self.target,
-            value: self.value,
-            call_data: self.data.clone(),
-        }
+impl InteractionEncoding for InteractionData {
+    fn encode(&self) -> EncodedInteraction {
+        (
+            self.target,
+            self.value,
+            Bytes::copy_from_slice(&self.call_data),
+        )
     }
 }
 
@@ -230,3 +246,79 @@ pub fn encode_interactions<'a>(
 ) -> Vec<EncodedInteraction> {
     interactions.into_iter().map(|i| i.encode()).collect()
 }
+
+#[derive(Clone, Debug)]
+pub struct WrapperCall {
+    pub address: Address,
+    pub data: Bytes,
+}
+
+/// Encodes a settlement transaction that uses wrapper contracts.
+///
+/// Takes the base settlement calldata and wraps it in a wrappedSettleCall
+/// with encoded wrapper metadata. Since wrappers are a chain, the wrapper
+/// address to call is also processed by this function.
+///
+/// Returns (first_wrapper_address, wrapped_calldata)
+pub fn encode_wrapper_settlement(
+    wrappers: &[WrapperCall],
+    settle_calldata: Bytes,
+) -> Option<(Address, Bytes)> {
+    if wrappers.is_empty() {
+        return None;
+    };
+    let wrapper_data = encode_wrapper_data(wrappers);
+
+    // Create wrappedSettleCall
+    let calldata = contracts::alloy::ICowWrapper::ICowWrapper::wrappedSettleCall {
+        settleData: settle_calldata,
+        wrapperData: wrapper_data,
+    }
+    .abi_encode();
+
+    Some((wrappers[0].address, calldata.into()))
+}
+
+/// Encodes wrapper metadata for wrapper settlement calls.
+/// As wrappers are called, each wrapper reads from wrapper calldata and
+/// consumes only their needed portion (however much data that is). Once wrapper
+/// is ready to call the settlement contract (or downstream wrapper) it calls
+/// the _internalSettle function provided in the CowWrapper abstract contract
+///
+/// Generally wrappers are encoded with a pair of Address (20 bytes) and then
+/// calldata (u16 length + data itself).
+///
+/// Since the first wrapper's address is the target of the transaction, it is
+/// not encoded.
+///
+/// The encoding format thus is:
+/// - The calldata of the first wrapper.
+/// - The address and calldata for each subsequent wrapper
+///
+/// Example: Encoding of 2 wrapper calls, the wrappers are named A, B and are
+/// called in the order A -> B
+///
+/// | A calldata length | A calldata | B address | B calldata length | B calldata |
+/// | u16               | &[u8]      | [u8; 20]  | u16               | &[u8]      |
+///
+/// Any additional wrappers will follow the same scheme: (address, length,
+/// calldata)
+///
+/// More information about wrapper encoding:
+/// https://docs.cow.fi/cow-protocol/integrate/wrappers#manual-encoding
+pub fn encode_wrapper_data(wrappers: &[WrapperCall]) -> Bytes {
+    let mut wrapper_data = Vec::new();
+
+    for (index, w) in wrappers.iter().enumerate() {
+        // Skip first wrapper's address (it's the transaction target)
+        if index != 0 {
+            wrapper_data.extend(w.address.as_slice());
+        }
+
+        // Encode data length as u16 in native endian, then the data itself
+        wrapper_data.extend((w.data.len() as u16).to_be_bytes().to_vec());
+        wrapper_data.extend(w.data.clone());
+    }
+
+    wrapper_data.into()
+}
diff --git a/crates/simulator/src/swap_simulator.rs b/crates/simulator/src/swap_simulator.rs
index 1fdee7fb43..24d66a0612 100644
--- a/crates/simulator/src/swap_simulator.rs
+++ b/crates/simulator/src/swap_simulator.rs
@@ -1,11 +1,23 @@
 use {
-    crate::encoding::{EncodedSettlement, EncodedTrade, Interaction, Interactions, encode_trade},
-    alloy_primitives::{Address, U256, address},
+    crate::encoding::{
+        EncodedSettlement,
+        EncodedTrade,
+        Interactions,
+        WrapperCall,
+        encode_trade,
+        encode_wrapper_settlement,
+    },
+    alloy_primitives::{Address, Bytes, U256},
+    alloy_provider::Provider,
     alloy_rpc_types::{TransactionRequest, state::StateOverride},
     alloy_sol_types::SolCall,
     anyhow::{Context, Result, anyhow},
     balance_overrides::BalanceOverriding,
-    contracts::alloy::{GPv2Settlement, WETH9, support::Solver},
+    contracts::alloy::{
+        GPv2Settlement::{self},
+        WETH9,
+        support::Solver::{self, Solver::swapReturn},
+    },
     eth_domain_types::NonZeroU256,
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     model::{
@@ -18,28 +30,35 @@ use {
 
 /// Query for the Swap Simulator to prepare a fake settlement with
 /// Contains the minimum data required to encode a fake settlement
+#[derive(Debug)]
 pub struct Query {
-    /// The input token, transferred into settlement contract
-    pub in_token: Address,
-    pub in_amount: NonZeroU256,
-    /// The output token, transferred out of settlemetn contract
-    pub out_token: Address,
-    pub out_amount: U256,
+    pub sell_token: Address,
+    pub sell_amount: NonZeroU256,
+    pub buy_token: Address,
+    pub buy_amount: U256,
     pub kind: OrderKind,
     pub receiver: Address,
     pub sell_token_source: SellTokenSource,
     pub buy_token_destination: BuyTokenDestination,
     pub from: Address,
     pub tx_origin: Option<Address>,
-    /// These interactions will be executed before the trade.
-    // pub pre_interactions: Vec<Interaction>,
-    /// Interactions needed to produce the expected trade amount.
-    // pub interactions: Vec<Interaction>,
-    /// These interactions will be executed after the trade.
-    // pub post_interactions: Vec<Interaction>,
     pub solver: Address,
     pub tokens: Vec<Address>,
     pub clearing_prices: Vec<U256>,
+    pub wrappers: Vec<WrapperCall>,
+}
+
+/// Controls how the trade is encoded for the provided Query
+#[derive(Clone, Debug)]
+pub enum TradeEncoding {
+    /// Encodes the trade amounts exactly as in the Query
+    Simple,
+    /// Encodes a trade with the most disadvantageous in and out amounts
+    /// possible (while taking possible overflows into account). Should the
+    /// trader not receive the amount promised by the [`Query`] the
+    /// simulation will still work and the actual out amount can be computed
+    /// afterwards.
+    Disadvantageous,
 }
 
 #[derive(Clone)]
@@ -56,20 +75,25 @@ pub struct SwapSimulator {
 pub struct EncodedSwap {
     pub settlement: EncodedSettlement,
     pub overrides: StateOverride,
+    pub wrappers: Vec<WrapperCall>,
     pub solver: Address,
     pub receiver: Address,
 }
 
-// Look into driver encoding logic for wrappers
-pub struct SwapSimulation {
+/// The output of a swap simulation.
+///
+/// Contains the transaction request that was used to perform the simulation
+/// (useful for introspection), The used state overrides and simulation result
+/// The result is of generic type O, and depends on the type of simulation:
+/// - solver swap simulation returns Solver::swapResult
+/// - generic simulation returns Bytes
+pub struct SwapSimulation<O> {
     pub tx: TransactionRequest,
     pub overrides: StateOverride,
-    pub result: Result<Solver::Solver::swapReturn, anyhow::Error>,
+    pub result: Result<O, anyhow::Error>,
 }
 
 impl SwapSimulator {
-    const SPARDOSE: Address = address!("0000000000000000000000000000000000020000");
-
     pub async fn new(
         balance_overrides: Arc<dyn BalanceOverriding>,
         settlement: Address,
@@ -96,27 +120,37 @@ impl SwapSimulator {
     /// The result can be further post processed depending on the needs
     ///
     /// It can then be simulated with SwapSimulator::simulate_swap
-    pub async fn fake_swap(&self, query: Query) -> Result<EncodedSwap> {
+    ///
+    /// The trade_encoding controls if the trade should be encoded as-is,
+    /// based on the Query or if it should be encoded as the most
+    /// disadvantegous trade possible.
+    ///
+    /// The TradeEncoding::Disadvantegous is useful for price verification since
+    /// the resulting out amounts can be calculated later while allowing the
+    /// simulation to pass.
+    pub async fn fake_swap(
+        &self,
+        query: &Query,
+        trade_encoding: TradeEncoding,
+    ) -> Result<EncodedSwap> {
         let overrides = StateOverride::default();
 
-        let pre_interactions = vec![self.trade_setup_interaction(&query).encode()];
-        let mut interactions = vec![];
+        let pre_interactions = Vec::new();
+        let mut interactions = Vec::new();
 
-        if query.out_token == BUY_ETH_ADDRESS {
+        if query.buy_token == BUY_ETH_ADDRESS {
             // Because the `driver` manages `WETH` unwraps under the hood the `TradeFinder`
             // does not have to emit unwraps to pay out `ETH` in a trade.
             // However, for the simulation to be successful this has to happen so we do it
             // ourselves here.
-            let buy_amount = match query.kind {
-                OrderKind::Sell => query.out_amount,
-                OrderKind::Buy => query.in_amount.get(),
-            };
             interactions.push((
                 self.native_token,
                 U256::ZERO,
-                WETH9::WETH9::withdrawCall { wad: buy_amount }
-                    .abi_encode()
-                    .into(),
+                WETH9::WETH9::withdrawCall {
+                    wad: query.buy_amount,
+                }
+                .abi_encode()
+                .into(),
             ));
             tracing::trace!("adding unwrap interaction for paying out ETH");
         }
@@ -125,38 +159,57 @@ impl SwapSimulator {
             settlement: EncodedSettlement {
                 tokens: query.tokens.to_vec(),
                 clearing_prices: query.clearing_prices.to_vec(),
-                trades: vec![encode_fake_trade(&query)?],
+                trades: vec![encode_fake_trade(query, trade_encoding)?],
                 interactions: Interactions {
                     pre: pre_interactions,
                     main: interactions,
-                    post: vec![],
+                    post: Vec::new(),
                 },
             },
             solver: query.tx_origin.unwrap_or(query.solver),
             receiver: query.receiver,
             overrides,
+            wrappers: query.wrappers.clone(),
         })
     }
 
+    /// For wrapped settlements, the Solver contract must call the first wrapper
+    /// (not the settlement directly). The wrapper then chains to the
+    /// settlement. For non-wrapped settlements, the Solver calls the
+    /// settlement contract directly.
+    fn get_target_and_calldata(&self, swap: &EncodedSwap) -> (Address, Bytes) {
+        if !swap.wrappers.is_empty() {
+            encode_wrapper_settlement(&swap.wrappers, swap.settlement.into_settle_call())
+                .expect("wrappers is not empty")
+        } else {
+            (
+                *self.settlement.address(),
+                swap.settlement.into_settle_call(),
+            )
+        }
+    }
+
     /// Simulates a solver call to settlement contract with the provided swap
     /// data. The swap call result is contained in the returned
     /// SwapSimulation struct, along with the original TransactionRequest
     /// and State overrides (if needed to be logged, or processed elsewhere)
-    pub async fn simulate_swap(&self, swap: EncodedSwap) -> Result<SwapSimulation> {
+    pub async fn simulate_swap_with_solver(
+        &self,
+        swap: EncodedSwap,
+    ) -> Result<SwapSimulation<swapReturn>> {
         let block = *self.current_block.borrow();
+        let (settlement_target, calldata) = self.get_target_and_calldata(&swap);
         let solver = Solver::Instance::new(swap.solver, self.web3.provider.clone());
-        let calldata = swap.settlement.into_settle_call();
         let overrides = swap.overrides;
 
         let swap = solver
             .swap(
-                *self.settlement.address(),
+                settlement_target,
                 swap.settlement.tokens.clone(),
                 swap.receiver,
                 calldata,
             )
             .from(swap.solver)
-            .to(swap.solver)
             .gas(self.gas_limit)
             .gas_price(
                 u128::try_from(block.gas_price.saturating_mul(U256::from(2)))
@@ -182,49 +235,52 @@ impl SwapSimulator {
         })
     }
 
-    /// Create interaction that sets up the trade right before transfering
-    /// funds. This interaction does nothing if the user-provided
-    /// pre-interactions already set everything up (e.g. approvals,
-    /// balances). That way we can correctly verify quotes with or without
-    /// these user pre-interactions with helpful error messages.
-    fn trade_setup_interaction(&self, query: &Query) -> Interaction {
-        let sell_amount = match query.kind {
-            OrderKind::Sell => query.in_amount.get(),
-            OrderKind::Buy => query.out_amount,
+    pub async fn simulate_settle_call(&self, swap: EncodedSwap) -> Result<SwapSimulation<Bytes>> {
+        let block = *self.current_block.borrow();
+        let (settlement_target, calldata) = self.get_target_and_calldata(&swap);
+
+        let overrides = swap.overrides;
+        let tx = TransactionRequest {
+            from: Some(swap.solver),
+            to: Some(settlement_target.into()),
+            input: calldata.into(),
+            gas: Some(self.gas_limit),
+            ..Default::default()
         };
-        let setup_call = Solver::Solver::ensureTradePreconditionsCall {
-            trader: query.from,
-            settlementContract: *self.settlement.address(),
-            sellToken: query.in_token,
-            sellAmount: sell_amount,
-            nativeToken: self.native_token,
-            spardose: Self::SPARDOSE,
-        }
-        .abi_encode();
-        Interaction {
-            target: query.solver,
-            value: U256::ZERO,
-            data: setup_call,
-        }
+
+        let result = self
+            .web3
+            .provider
+            .call(tx.clone())
+            .overrides(overrides.clone())
+            .block(block.number.into())
+            .await
+            .map_err(|err| anyhow!(err));
+
+        Ok(SwapSimulation {
+            tx,
+            overrides,
+            result,
+        })
     }
 }
 
-/// Encodes a trade with the most disadvantageous in and out amounts possible
-/// (while taking possible overflows into account). Should the trader not
-/// receive the amount promised by the [`Trade`] the simulation will still work
-/// and the actual [`Trade::out_amount`] can be computed afterwards.
-fn encode_fake_trade(query: &Query) -> Result<EncodedTrade> {
-    let (sell_amount, buy_amount) = match query.kind {
-        OrderKind::Sell => (query.in_amount.get(), U256::ZERO),
-        OrderKind::Buy => (
-            (query.out_amount).max(U256::from(u128::MAX)),
-            query.in_amount.get(),
-        ),
+fn encode_fake_trade(query: &Query, trade_encoding: TradeEncoding) -> Result<EncodedTrade> {
+    let (sell_amount, buy_amount) = match trade_encoding {
+        TradeEncoding::Simple => (query.sell_amount.into(), query.buy_amount),
+        TradeEncoding::Disadvantageous => match query.kind {
+            OrderKind::Sell => (query.sell_amount.get(), U256::ZERO),
+            OrderKind::Buy => (
+                query.sell_amount.get().max(U256::from(u128::MAX)),
+                query.buy_amount,
+            ),
+        },
     };
+
     let fake_order = OrderData {
-        sell_token: query.in_token,
+        sell_token: query.sell_token,
         sell_amount,
-        buy_token: query.out_token,
+        buy_token: query.buy_token,
         buy_amount,
         receiver: Some(query.receiver),
         valid_to: u32::MAX,
@@ -245,14 +301,17 @@ fn encode_fake_trade(query: &Query) -> Result<EncodedTrade> {
         query
             .tokens
             .iter()
-            .position(|token| token == &query.in_token)
+            .position(|token| token == &query.sell_token)
             .context("missing sell token index")?,
         query
             .tokens
             .iter()
-            .position(|token| token == &query.out_token)
+            .position(|token| token == &query.buy_token)
             .context("missing buy token index")?,
-        query.in_amount.get(),
+        match query.kind {
+            OrderKind::Sell => query.sell_amount.get(),
+            OrderKind::Buy => query.buy_amount,
+        },
     );
 
     Ok(encoded_trade)
diff --git a/crates/simulator/src/tenderly/dto.rs b/crates/simulator/src/tenderly/dto.rs
index 0834d1e51d..0800e57281 100644
--- a/crates/simulator/src/tenderly/dto.rs
+++ b/crates/simulator/src/tenderly/dto.rs
@@ -6,34 +6,51 @@ use {
     std::collections::HashMap,
 };
 
+/// Tenderly API simulation request
+/// https://docs.tenderly.co/reference/api#/operations/simulateTransaction#request-body
 #[serde_as]
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Deserialize, Serialize, Debug, Default)]
 pub struct Request {
+    /// ID of the network on which the simulation is being run.
     pub network_id: String,
+    /// Number of the block to be used for the simulation.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub block_number: Option<u64>,
+    /// Index of the transaction within the block.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transaction_index: Option<i64>,
+    /// Address initiating the transaction.
     pub from: Address,
+    /// The recipient address of the transaction.
     pub to: Address,
+    /// Encoded contract method call data.
     #[serde_as(as = "serde_ext::Hex")]
     pub input: Vec<u8>,
+    /// Amount of gas provided for the simulation.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub gas: Option<u64>,
+    /// String representation of a number that represents price of the gas in
+    /// Wei.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub gas_price: Option<u64>,
+    /// Amount of Ether (in Wei) sent along with the transaction.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub value: Option<U256>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub simulation_kind: Option<SimulationKind>,
+    pub simulation_type: Option<SimulationType>,
+    /// Flag indicating whether to save the simulation in dashboard UI.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub save: Option<bool>,
+    /// Flag indicating whether to save failed simulation in dashboard UI.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub save_if_fails: Option<bool>,
+    /// Flag that enables returning the access list in a response.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub generate_access_list: Option<bool>,
+    /// Overrides for a given contract.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub state_objects: Option<HashMap<Address, StateObject>>,
+    /// EIP-2930 access list used by the transaction.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub access_list: Option<AccessList>,
 }
@@ -45,9 +62,8 @@ pub struct Response {
     pub simulation: Simulation,
 }
 
-// Tenderly responds with
-// snake_case fields and tenderly storage_keys field does not exist
-// if empty (it should be empty Vec instead)
+/// EIP-2930 access list used by the transaction.
+/// https://docs.tenderly.co/reference/api#/operations/simulateTransaction#response-body:~:text=0x-,access_list,-array%20or%20null
 #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct AccessListItem {
     /// Accessed address
@@ -115,7 +131,9 @@ impl From<AccessList> for eth::AccessList {
         )
     }
 }
-
+/// Overrides for a given contract. In this mapping, the key is the contract
+/// address, and the value is an object that contains overrides of nonce, code,
+/// balance, or state. https://docs.tenderly.co/reference/api#/operations/simulateTransaction#response-body:~:text=null%2C%22uncles%22%3Anull%7D-,state_objects,-dictionary%5Bstring%2C%20object
 #[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
 pub struct StateObject {
     /// Fake balance to set for the account before executing the call.
@@ -150,12 +168,19 @@ impl TryFrom<alloy_rpc_types::eth::state::AccountOverride> for StateObject {
         })
     }
 }
-
+/// Opt for quick, abi, or full simulation API mode.
+/// https://docs.tenderly.co/reference/api#/operations/simulateTransaction#response-body:~:text=true-,simulation_type,-string
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
-pub enum SimulationKind {
+pub enum SimulationType {
+    /// Detailed decoded output — call trace, function
+    /// inputs/outputs, state diffs, and logs with Solidity types.
     Full,
+    /// Raw, minimal output only. Fastest option; no decoding.
     Quick,
+    /// Decoded function inputs/outputs and logs, but no state diffs. Middle
+    /// ground between quick and full.
+    Abi,
 }
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
diff --git a/crates/simulator/src/tenderly/mod.rs b/crates/simulator/src/tenderly/mod.rs
index 59bbf26557..2ada00ae06 100644
--- a/crates/simulator/src/tenderly/mod.rs
+++ b/crates/simulator/src/tenderly/mod.rs
@@ -149,25 +149,6 @@ impl TenderlyApi {
             name,
         }
     }
-
-    fn log(&self, simulation: dto::Request) -> Result<()> {
-        let simulation_url =
-            crate::utils::join_url(&self.dashboard, "simulator/$SIMULATION_ID").to_string();
-        let body = serde_json::to_string(&simulation)?;
-
-        #[rustfmt::skip]
-        tracing::debug!(
-            "resimulate by setting TENDERLY_API_KEY environment variable and running: \
-            curl -X POST -H \"X-ACCESS-KEY: $TENDERLY_API_KEY\" -H \"Content-Type: application/json\" --data '{body}' {simulation_endpoint} \
-            | jq -r \".simulation.id\" \
-            | read SIMULATION_ID; \
-            echo {simulation_url} \
-            | xargs xdg-open",
-            simulation_endpoint = self.simulation_endpoint
-        );
-
-        Ok(())
-    }
 }
 
 #[async_trait::async_trait]
@@ -183,7 +164,7 @@ impl Api for TenderlyApi {
             save_if_fails: Some(true),
             ..prepare_request(self.chain_id.clone(), &tx, overrides, block)?
         };
-        self.log(request)
+        log_simulation_request(&self.simulation_endpoint, &self.dashboard, request)
     }
 
     async fn simulate(&self, request: dto::Request) -> Result<dto::Response> {
@@ -209,7 +190,7 @@ impl Api for TenderlyApi {
     }
 }
 
-fn prepare_request(
+pub fn prepare_request(
     chain_id: String,
     tx: &TransactionRequest,
     overrides: StateOverride,
@@ -231,7 +212,7 @@ fn prepare_request(
             .map(TryInto::try_into)
             .map(|gas_price| gas_price.unwrap()),
         value: tx.value,
-        simulation_kind: Some(dto::SimulationKind::Quick),
+        simulation_type: Some(dto::SimulationType::Full),
         state_objects: Some(
             overrides
                 .into_iter()
@@ -243,6 +224,28 @@ fn prepare_request(
     })
 }
 
+pub fn log_simulation_request(
+    simulation_endpoint: &Url,
+    dashboard: &Url,
+    simulation: dto::Request,
+) -> Result<()> {
+    let simulation_url = crate::utils::join_url(dashboard, "simulator/$SIMULATION_ID").to_string();
+    let body = serde_json::to_string(&simulation)?;
+
+    #[rustfmt::skip]
+    tracing::debug!(
+        "resimulate by setting TENDERLY_API_KEY environment variable and running: \
+        curl -X POST -H \"X-ACCESS-KEY: $TENDERLY_API_KEY\" -H \"Content-Type: application/json\" --data '{body}' {simulation_endpoint} \
+        | jq -r \".simulation.id\" \
+        | read SIMULATION_ID; \
+        echo {simulation_url} \
+        | xargs xdg-open",
+        simulation_url = simulation_url
+    );
+
+    Ok(())
+}
+
 #[derive(Debug)]
 pub struct Simulation {
     pub id: SimulationId,

From 76446ea426182484cf4e07abf0fc4f9743a73952 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Fri, 3 Apr 2026 17:23:48 +0200
Subject: [PATCH 180/219] Add block number to order simulation (#4305)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
The order simulation endpoint would always run against the latest block.
It is limiting for investigating already filled or partially filled
orders.

# Changes
Add query parameter to the order simulation endpoint to allow specifying
a block number

## How to test
E2E test creates an order, withdraws trader's sell tokens on block A and
funds the account on block B. The order simulation fails for block A and
succeeds for block B.

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: ilya <ilya@cow.fi>
---
 Cargo.lock                                   |   1 +
 crates/e2e/tests/e2e/order_simulation.rs     | 119 +++++++++++++++++++
 crates/orderbook/Cargo.toml                  |   1 +
 crates/orderbook/openapi.yml                 |   9 ++
 crates/orderbook/src/api/debug_simulation.rs |  15 ++-
 crates/orderbook/src/order_simulator.rs      |  16 ++-
 crates/orderbook/src/orderbook.rs            |   3 +-
 crates/simulator/src/swap_simulator.rs       |  10 +-
 8 files changed, 165 insertions(+), 9 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 153add894f..92d30564cc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5142,6 +5142,7 @@ dependencies = [
  "const-hex",
  "contracts",
  "database",
+ "eth-domain-types",
  "ethrpc",
  "futures",
  "gas-price-estimation",
diff --git a/crates/e2e/tests/e2e/order_simulation.rs b/crates/e2e/tests/e2e/order_simulation.rs
index c5c32a78d8..139cbb4799 100644
--- a/crates/e2e/tests/e2e/order_simulation.rs
+++ b/crates/e2e/tests/e2e/order_simulation.rs
@@ -1,4 +1,5 @@
 use {
+    alloy::{primitives::Address, providers::Provider},
     configs::test_util::TestDefault,
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
     ethrpc::{Web3, alloy::CallBuilderExt},
@@ -18,6 +19,12 @@ async fn local_node_order_simulation() {
     run_test(order_simulation).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_order_simulation_block_number() {
+    run_test(order_simulation_block_number).await;
+}
+
 async fn order_simulation(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -87,3 +94,115 @@ async fn order_simulation(web3: Web3) {
     assert_eq!(tenderly.simulation_type, Some(SimulationType::Full));
     assert_eq!(tenderly.value, None);
 }
+
+async fn order_simulation_block_number(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
+        .await;
+
+    // Fund trader so the order passes balance validation at submission time.
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            configs::autopilot::Configuration::test("test_solver", solver.address()),
+            configs::orderbook::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    let order = OrderCreation {
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: 2u64.eth(),
+        buy_token: *token.address(),
+        buy_amount: 1u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Buy,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let uid = services.create_order(&order).await.unwrap();
+
+    // Transfer all WETH away from the trader — now they have no sell-token
+    // balance. The current block becomes the "no funds" snapshot.
+    let burn = Address::from([0x42u8; 20]);
+    onchain
+        .contracts()
+        .weth
+        .transfer(burn, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+    let block_no_funds = web3.provider.get_block_number().await.unwrap();
+
+    // Re-deposit WETH. The current block now has the trader fully funded again.
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    let block_with_funds = web3.provider.get_block_number().await.unwrap();
+
+    let client = services.client();
+
+    // Simulation at the block where the trader had no WETH must fail.
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{uid}?block_number={block_no_funds}"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_some(),
+        "expected simulation failure at block {block_no_funds} (no funds), got success"
+    );
+
+    // Simulation at the block where the trader has WETH must succeed.
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{uid}?block_number={block_with_funds}"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert_eq!(
+        result.error, None,
+        "expected simulation success at block {block_with_funds} (funded), got error: {:?}",
+        result.error
+    );
+}
diff --git a/crates/orderbook/Cargo.toml b/crates/orderbook/Cargo.toml
index f76a12bb56..22737e4cb4 100644
--- a/crates/orderbook/Cargo.toml
+++ b/crates/orderbook/Cargo.toml
@@ -33,6 +33,7 @@ configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
 database = { workspace = true }
+eth-domain-types = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
 gas-price-estimation = { workspace = true }
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 8c855417ca..e03026519b 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -778,6 +778,15 @@ paths:
           schema:
             $ref: "#/components/schemas/UID"
           required: true
+        - in: query
+          name: block_number
+          schema:
+            type: integer
+            format: int64
+          required: false
+          description: >
+            Block number to simulate the order at. If not specified, the
+            simulation uses the latest block.
       responses:
         "200":
           description: Simulation request returned.
diff --git a/crates/orderbook/src/api/debug_simulation.rs b/crates/orderbook/src/api/debug_simulation.rs
index d3beb010f2..e51ad40894 100644
--- a/crates/orderbook/src/api/debug_simulation.rs
+++ b/crates/orderbook/src/api/debug_simulation.rs
@@ -1,19 +1,30 @@
 use {
     crate::{api::AppState, orderbook::OrderSimulationError},
     axum::{
-        extract::{Path, State},
+        extract::{Path, Query, State},
         http::StatusCode,
         response::{IntoResponse, Json, Response},
     },
     model::order::OrderUid,
+    serde::Deserialize,
     std::sync::Arc,
 };
 
+#[derive(Deserialize)]
+pub struct SimulationQuery {
+    pub block_number: Option<u64>,
+}
+
 pub async fn debug_simulation_handler(
     State(state): State<Arc<AppState>>,
     Path(uid): Path<OrderUid>,
+    Query(params): Query<SimulationQuery>,
 ) -> Response {
-    match state.orderbook.simulate_order(&uid).await {
+    match state
+        .orderbook
+        .simulate_order(&uid, params.block_number)
+        .await
+    {
         Ok(Some(result)) => (StatusCode::OK, Json(result)).into_response(),
         Ok(None) => (
             StatusCode::NOT_FOUND,
diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
index 95d2500be9..1a800422d6 100644
--- a/crates/orderbook/src/order_simulator.rs
+++ b/crates/orderbook/src/order_simulator.rs
@@ -7,6 +7,7 @@ use {
     anyhow::{Context, Result},
     balance_overrides::BalanceOverrideRequest,
     contracts::alloy::support::{AnyoneAuthenticator, Trader},
+    eth_domain_types::BlockNo,
     model::order::Order,
     simulator::{
         encoding::InteractionEncoding,
@@ -81,8 +82,17 @@ impl OrderSimulator {
     /// The result contains the transaction simulation error (if any)
     /// and a full API request object that can be used to resimulate the swap
     /// using Tenderly.
-    pub async fn simulate_swap(&self, swap: EncodedSwap) -> Result<OrderSimulationResult> {
-        let result = self.simulator.simulate_settle_call(swap).await?;
+    pub async fn simulate_swap(
+        &self,
+        swap: EncodedSwap,
+        block_number: Option<u64>,
+    ) -> Result<OrderSimulationResult> {
+        let block_number =
+            block_number.unwrap_or_else(|| self.simulator.current_block.borrow().number);
+        let result = self
+            .simulator
+            .simulate_settle_call(swap, Some(block_number))
+            .await?;
 
         let tenderly_request = simulator::tenderly::dto::Request {
             transaction_index: None,
@@ -92,7 +102,7 @@ impl OrderSimulator {
                 self.chain_id.clone(),
                 &result.tx,
                 result.overrides,
-                None,
+                Some(BlockNo(block_number)),
             )?
         };
 
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index 5c512af88a..8f90089586 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -616,6 +616,7 @@ impl Orderbook {
     pub async fn simulate_order(
         &self,
         uid: &OrderUid,
+        block_number: Option<u64>,
     ) -> Result<Option<OrderSimulationResult>, OrderSimulationError> {
         let Some(order_simulator) = &self.order_simulator else {
             return Err(OrderSimulationError::NotEnabled);
@@ -634,7 +635,7 @@ impl Orderbook {
             .map_err(OrderSimulationError::Other)?;
         Ok(Some(
             order_simulator
-                .simulate_swap(swap)
+                .simulate_swap(swap, block_number)
                 .await
                 .map_err(OrderSimulationError::Other)?,
         ))
diff --git a/crates/simulator/src/swap_simulator.rs b/crates/simulator/src/swap_simulator.rs
index 24d66a0612..5e5fcdbfda 100644
--- a/crates/simulator/src/swap_simulator.rs
+++ b/crates/simulator/src/swap_simulator.rs
@@ -235,8 +235,12 @@ impl SwapSimulator {
         })
     }
 
-    pub async fn simulate_settle_call(&self, swap: EncodedSwap) -> Result<SwapSimulation<Bytes>> {
-        let block = *self.current_block.borrow();
+    pub async fn simulate_settle_call(
+        &self,
+        swap: EncodedSwap,
+        block_number: Option<u64>,
+    ) -> Result<SwapSimulation<Bytes>> {
+        let block_number = block_number.unwrap_or_else(|| self.current_block.borrow().number);
         let (settlement_target, calldata) = self.get_target_and_calldata(&swap);
 
         let overrides = swap.overrides;
@@ -253,7 +257,7 @@ impl SwapSimulator {
             .provider
             .call(tx.clone())
             .overrides(overrides.clone())
-            .block(block.number.into())
+            .block(block_number.into())
             .await
             .map_err(|err| anyhow!(err));
 

From 0c9026c02fbae4694dd9025e3e02267d37dc512e Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Tue, 7 Apr 2026 15:05:32 +0200
Subject: [PATCH 181/219] Update GH actions to use pinned commit SHA (#4312)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Most recently we have started to enforce GH actions with pinned commits
to full SHA. This caused our CI jobs to fail since not all of the
actions are pinned.

# Changes
Fixed extractions/setup-just in pull-request.yaml — The old SHA
(e33e0265...) pointed to a version whose action.yaml internally called
extractions/setup-crate@v1 (unpinned). Updated to 53165ef7... (v4.0.0)
which internally pins setup-crate@0551596....

Fixed yu-ichiro/spin-up-docker-compose-action in pull-request.yaml —
This composite action internally used actions/cache@v3 and
docker/setup-buildx-action@v1 (both unpinned), even though those steps
were gated behind bake/registry flags we never set. Replaced all 4
usages with direct docker compose run steps since the action was only
ever used as a thin wrapper around docker compose up.

## How to test
PR checks should pass now.
---
 .github/workflows/pull-request.yaml | 56 +++++++++--------------------
 1 file changed, 16 insertions(+), 40 deletions(-)

diff --git a/.github/workflows/pull-request.yaml b/.github/workflows/pull-request.yaml
index fae8ae9a88..b711a12cee 100644
--- a/.github/workflows/pull-request.yaml
+++ b/.github/workflows/pull-request.yaml
@@ -21,7 +21,7 @@ jobs:
           profile: minimal
           toolchain: nightly
           components: rustfmt
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - uses: tombi-toml/setup-tombi@cebfd308ba02edadfcee148b7473536990950c92 # v1.0.8
@@ -84,7 +84,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           persist-credentials: false
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - run: rustup toolchain install stable --profile minimal
@@ -106,7 +106,7 @@ jobs:
       - run: rustup toolchain install stable --profile minimal
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
       - uses: taiki-e/install-action@e4767ccc6762bc4347ef2275c75ea77f5f36e27f # nextest
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - run: cargo build --tests
@@ -130,15 +130,9 @@ jobs:
       # wait for the build process to be done before proceeding.
       - run: cargo build -p orderbook -p database -p autopilot --tests &
       - uses: taiki-e/install-action@e4767ccc6762bc4347ef2275c75ea77f5f36e27f # nextest
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: -d db
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: migrations --abort-on-container-failure
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - run: docker compose -f docker-compose.yaml up -d db
+      - run: docker compose -f docker-compose.yaml up migrations --abort-on-container-failure
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - run: just test-db
@@ -163,15 +157,9 @@ jobs:
       # wait for the build process to be done before proceeding.
       - run: cargo build -p e2e --tests &
       - uses: taiki-e/install-action@e4767ccc6762bc4347ef2275c75ea77f5f36e27f # nextest
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: -d db
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: migrations --abort-on-container-failure
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - run: docker compose -f docker-compose.yaml up -d db
+      - run: docker compose -f docker-compose.yaml up migrations --abort-on-container-failure
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - run: just test-e2e-local
@@ -206,15 +194,9 @@ jobs:
       # wait for the build process to be done before proceeding.
       - run: cargo build -p e2e --tests &
       - uses: taiki-e/install-action@e4767ccc6762bc4347ef2275c75ea77f5f36e27f # nextest
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: -d db
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: migrations --abort-on-container-failure
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - run: docker compose -f docker-compose.yaml up -d db
+      - run: docker compose -f docker-compose.yaml up migrations --abort-on-container-failure
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - run: just test-e2e-forked
@@ -236,7 +218,7 @@ jobs:
       - uses: foundry-rs/foundry-toolchain@82dee4ba654bd2146511f85f0d013af94670c4de # v1.4.0
       - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
       - uses: taiki-e/install-action@e4767ccc6762bc4347ef2275c75ea77f5f36e27f # nextest
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       # Build the driver's tests.
@@ -304,15 +286,9 @@ jobs:
       # wait for the build process to be done before proceeding.
       - run: cargo build -p e2e --tests &
       - uses: taiki-e/install-action@e4767ccc6762bc4347ef2275c75ea77f5f36e27f # nextest
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: -d db
-      - uses: yu-ichiro/spin-up-docker-compose-action@b7808421e139a485cb455f78e66605ca9dbe4334 # v1.2
-        with:
-          file: docker-compose.yaml
-          up-opts: migrations --abort-on-container-failure
-      - uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff
+      - run: docker compose -f docker-compose.yaml up -d db
+      - run: docker compose -f docker-compose.yaml up migrations --abort-on-container-failure
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
         with:
           just-version: 1.39.0
       - name: Run test in a loop

From b10b826eb697785ed86d294493c687f7af2ea225 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Tue, 7 Apr 2026 16:01:59 +0200
Subject: [PATCH 182/219] Custom order simulation (#4304)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
The order simulation endpoint allows one to simulate a specific,
existing order. It is useful to be able to simulate any, custom order.

# Changes
Implements a POST endpoint `/api/v1/debug/simulation` that allows a
request specifying custom order details to be simulated:
```
pub struct SimulationRequest {
    pub sell_token: Address,
    pub buy_token: Address,
    #[serde_as(as = "HexOrDecimalU256")]
    pub sell_amount: alloy::primitives::U256,
    #[serde_as(as = "HexOrDecimalU256")]
    pub buy_amount: alloy::primitives::U256,
    pub kind: OrderKind,
    pub owner: Address,
    #[serde(default)]
    pub receiver: Option<Address>,
    #[serde(default)]
    pub sell_token_balance: SellTokenSource,
    #[serde(default)]
    pub buy_token_balance: BuyTokenDestination,
    /// Full app data JSON. Defaults to `"{}"` if omitted.
    #[serde(default)]
    pub app_data: Option<String>,
    #[serde(default)]
    pub interactions: Interactions,
}
```

- [ ] Add exhaustive order details in a follow-up PR.

## How to test
E2E test that runs a custom order simulation on a trader with no funds
(it reverts), then account is funded and the same request passes.

<!--
## Related Issues

Fixes #
-->

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: ilya <ilya@cow.fi>
---
 crates/e2e/tests/e2e/malformed_requests.rs   | 227 +++++++++++++++++++
 crates/e2e/tests/e2e/order_simulation.rs     | 114 ++++++----
 crates/orderbook/openapi.yml                 |  99 +++++++-
 crates/orderbook/src/api.rs                  |   5 +
 crates/orderbook/src/api/debug_simulation.rs |  53 +++--
 crates/orderbook/src/dto/mod.rs              |  42 ++++
 crates/orderbook/src/order_simulator.rs      |  51 +++--
 crates/orderbook/src/orderbook.rs            | 106 ++++++++-
 crates/shared/src/order_validation.rs        |   2 +-
 crates/simulator/src/swap_simulator.rs       |  12 +-
 10 files changed, 618 insertions(+), 93 deletions(-)

diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index 052e2e224a..c60d6635dc 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -342,4 +342,231 @@ async fn http_validation(web3: Web3) {
         .unwrap();
 
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+
+    // GET /api/v1/debug/simulation/{uid} error cases
+
+    // Malformed UID → 400
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/simulation/bad_uid"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::BAD_REQUEST,
+        "malformed UID should return 400"
+    );
+
+    // Valid UID but order not found → 404
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{VALID_ORDER_UID}"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::NOT_FOUND,
+        "unknown order UID should return 404"
+    );
+    let body: Error = response.json().await.unwrap();
+    assert!(!body.error_type.is_empty());
+    assert!(!body.description.is_empty());
+
+    // Invalid block_number query param → 400
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{VALID_ORDER_UID}?block_number=notanumber"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::BAD_REQUEST,
+        "non-numeric block_number should return 400"
+    );
+
+    // POST /api/v1/debug/simulation error cases
+
+    // Invalid JSON body → 400
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .header("Content-Type", "application/json")
+        .body("{invalid json}")
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::BAD_REQUEST,
+        "invalid JSON should return 400"
+    );
+
+    // Missing required fields → 422
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&json!({}))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "missing required fields should return 422"
+    );
+
+    // Invalid field type (bad address) → 422
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&json!({
+            "sellToken": "not-an-address",
+            "buyToken": VALID_ADDRESS,
+            "sellAmount": "1000000000000000000",
+            "buyAmount": "1000000000000000000",
+            "kind": "sell",
+            "owner": VALID_ADDRESS,
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "invalid address field should return 422"
+    );
+
+    // Zero sellAmount (NonZeroU256 rejects zero at deserialization) → 422
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&json!({
+            "sellToken": VALID_ADDRESS,
+            "buyToken": VALID_ADDRESS,
+            "sellAmount": "0",
+            "buyAmount": "1000000000000000000",
+            "kind": "sell",
+            "owner": VALID_ADDRESS,
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "zero sellAmount should return 422"
+    );
+
+    // Invalid kind enum value → 422
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&json!({
+            "sellToken": VALID_ADDRESS,
+            "buyToken": VALID_ADDRESS,
+            "sellAmount": "1000000000000000000",
+            "buyAmount": "1000000000000000000",
+            "kind": "unknownKind",
+            "owner": VALID_ADDRESS,
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::UNPROCESSABLE_ENTITY,
+        "invalid kind enum should return 422"
+    );
+
+    // Invalid appData (non-JSON string triggers MalformedInput) → 400
+    let bad_app_data = "not valid json";
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&json!({
+            "sellToken": VALID_ADDRESS,
+            "buyToken": VALID_ADDRESS,
+            "sellAmount": "1000000000000000000",
+            "buyAmount": "1000000000000000000",
+            "kind": "sell",
+            "owner": VALID_ADDRESS,
+            "appData": bad_app_data,
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::BAD_REQUEST,
+        "malformed appData should return 400"
+    );
+    let body: Error = response.json().await.unwrap();
+    assert!(
+        body.description.contains("app_data"),
+        "error description should name the failing field. Got: {}",
+        body.description
+    );
+    assert!(
+        body.description.contains(bad_app_data),
+        "error description should include the bad value. Got: {}",
+        body.description
+    );
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_node_simulation_not_enabled() {
+    run_test(simulation_not_enabled).await;
+}
+
+async fn simulation_not_enabled(web3: Web3) {
+    let onchain = OnchainComponents::deploy(web3).await;
+    let services = Services::new(&onchain).await;
+    services
+        .start_api(configs::orderbook::Configuration {
+            order_simulation: None,
+            order_quoting: OrderQuoting::test_with_drivers(vec![ExternalSolver::new(
+                "test_quoter",
+                "http://localhost:11088/test_solver",
+            )]),
+            shared: SharedConfig {
+                gas_estimators: vec![TestDefault::test_default()],
+                ..Default::default()
+            },
+            ..configs::orderbook::Configuration::test_default()
+        })
+        .await;
+    let client = services.client();
+
+    // GET → 405 when simulation is not enabled
+    let response = client
+        .get(format!(
+            "{API_HOST}/api/v1/debug/simulation/{VALID_ORDER_UID}"
+        ))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::METHOD_NOT_ALLOWED,
+        "GET simulation with disabled endpoint should return 405"
+    );
+
+    // POST → 405 when simulation is not enabled
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&json!({
+            "sellToken": VALID_ADDRESS,
+            "buyToken": VALID_ADDRESS,
+            "sellAmount": "1000000000000000000",
+            "buyAmount": "1000000000000000000",
+            "kind": "sell",
+            "owner": VALID_ADDRESS,
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(
+        response.status(),
+        StatusCode::METHOD_NOT_ALLOWED,
+        "POST simulation with disabled endpoint should return 405"
+    );
 }
diff --git a/crates/e2e/tests/e2e/order_simulation.rs b/crates/e2e/tests/e2e/order_simulation.rs
index 139cbb4799..ece1c56eae 100644
--- a/crates/e2e/tests/e2e/order_simulation.rs
+++ b/crates/e2e/tests/e2e/order_simulation.rs
@@ -21,37 +21,19 @@ async fn local_node_order_simulation() {
 
 #[tokio::test]
 #[ignore]
-async fn local_node_order_simulation_block_number() {
-    run_test(order_simulation_block_number).await;
+async fn local_node_custom_order_simulation() {
+    run_test(custom_order_simulation).await;
 }
 
-async fn order_simulation(web3: Web3) {
+async fn custom_order_simulation(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
     let [solver] = onchain.make_solvers(10u64.eth()).await;
-    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(1u64.eth()).await;
     let [token] = onchain
         .deploy_tokens_with_weth_uni_v2_pools(1_000u64.eth(), 1_000u64.eth())
         .await;
 
-    onchain
-        .contracts()
-        .weth
-        .deposit()
-        .from(trader.address())
-        .value(3u64.eth())
-        .send_and_watch()
-        .await
-        .unwrap();
-    onchain
-        .contracts()
-        .weth
-        .approve(onchain.contracts().allowance, 3u64.eth())
-        .from(trader.address())
-        .send_and_watch()
-        .await
-        .unwrap();
-
     let services = Services::new(&onchain).await;
     services
         .start_protocol_with_args(
@@ -61,41 +43,58 @@ async fn order_simulation(web3: Web3) {
         )
         .await;
 
-    let order = OrderCreation {
-        sell_token: *onchain.contracts().weth.address(),
-        sell_amount: 2u64.eth(),
-        buy_token: *token.address(),
+    let client = services.client();
+    let sell_amount = 1u64.eth();
+    let request = orderbook::dto::OrderSimulationRequest {
+        sell_token: *token.address(),
+        buy_token: *onchain.contracts().weth.address(),
+        sell_amount: sell_amount.try_into().expect("Sell amount is non zero"),
         buy_amount: 1u64.eth(),
-        valid_to: model::time::now_in_epoch_seconds() + 300,
-        kind: OrderKind::Buy,
+        kind: OrderKind::Sell,
+        owner: trader.address(),
         ..Default::default()
-    }
-    .sign(
-        EcdsaSigningScheme::Eip712,
-        &onchain.contracts().domain_separator,
-        &trader.signer,
-    );
-    let uid = services.create_order(&order).await.unwrap();
+    };
 
-    let client = services.client();
+    // Trader has no sell tokens — simulation should revert.
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&request)
         .send()
         .await
         .unwrap();
     assert_eq!(response.status(), StatusCode::OK);
-    let response = response.json::<OrderSimulationResult>().await.unwrap();
-    assert_eq!(response.error, None);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_some(),
+        "expected simulation error when trader has no funds"
+    );
+    assert!(result.error.unwrap().contains("reverted"));
 
-    let tenderly = response.tenderly_request;
-    // check if the fields that are directly derived from the simulation have
-    // correct values in the tenderly request object
-    assert_eq!(tenderly.to, *onchain.contracts().gp_settlement.address());
-    assert_eq!(tenderly.simulation_type, Some(SimulationType::Full));
-    assert_eq!(tenderly.value, None);
+    // Fund the trader and approve the vault relayer.
+    token.mint(trader.address(), sell_amount).await;
+    token
+        .approve(onchain.contracts().allowance, sell_amount)
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Simulation should now succeed.
+    let response = client
+        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .json(&request)
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_none(),
+        "expected simulation to pass after funding the trader"
+    );
 }
 
-async fn order_simulation_block_number(web3: Web3) {
+async fn order_simulation(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
     let [solver] = onchain.make_solvers(10u64.eth()).await;
@@ -189,6 +188,7 @@ async fn order_simulation_block_number(web3: Web3) {
         result.error.is_some(),
         "expected simulation failure at block {block_no_funds} (no funds), got success"
     );
+    assert!(result.error.unwrap().contains("reverted"));
 
     // Simulation at the block where the trader has WETH must succeed.
     let response = client
@@ -205,4 +205,26 @@ async fn order_simulation_block_number(web3: Web3) {
         "expected simulation success at block {block_with_funds} (funded), got error: {:?}",
         result.error
     );
+
+    // Simulation at the latest block (block_number parameter omitted), must
+    // succeed.
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert_eq!(
+        result.error, None,
+        "expected simulation success at block {block_with_funds} (funded), got error: {:?}",
+        result.error
+    );
+
+    let tenderly = result.tenderly_request;
+    // check if the fields that are directly derived from the simulation have
+    // correct values in the tenderly request object
+    assert_eq!(tenderly.to, *onchain.contracts().gp_settlement.address());
+    assert_eq!(tenderly.simulation_type, Some(SimulationType::Full));
+    assert_eq!(tenderly.value, None);
 }
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index e03026519b..836e895e8f 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -765,6 +765,38 @@ paths:
                 $ref: "#/components/schemas/TotalSurplus"
         "400":
           description: Invalid address.
+  "/api/v1/debug/simulation":
+    post:
+      operationId: debugSimulationPost
+      summary: Simulate an arbitrary order.
+      description: >
+        Simulates an arbitrary order specified in the request body and returns
+        the Tenderly simulation request, along with any simulation error if
+        applicable.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/SimulationRequest"
+      responses:
+        "200":
+          description: Simulation request returned.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/OrderSimulation"
+        "400":
+          description: >
+            Invalid JSON body, or `appData` is not valid JSON.
+        "405":
+          description: Order simulation endpoint is not enabled.
+        "422":
+          description: >
+            Request body failed schema validation: missing required field,
+            wrong field type, zero `sellAmount`, or unrecognised `kind` value.
+        "500":
+          description: Internal error.
   "/api/v1/debug/simulation/{uid}":
     get:
       operationId: debugSimulation
@@ -795,7 +827,9 @@ paths:
               schema:
                 $ref: "#/components/schemas/OrderSimulation"
         "400":
-          description: Invalid order UID.
+          description: >
+            Malformed path parameter (invalid order UID format) or invalid
+            `block_number` query parameter.
         "404":
           description: Order not found.
         "405":
@@ -2659,6 +2693,69 @@ components:
         - from
         - to
         - input
+    SimulationRequest:
+      description: >
+        Request body for simulating an arbitrary order without it being stored
+        in the orderbook.
+      type: object
+      properties:
+        sellToken:
+          description: The token being sold.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+        buyToken:
+          description: The token being bought.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+        sellAmount:
+          description: >
+            Amount of sell token (hex- or decimal-encoded uint256). Must be
+            greater than zero.
+          allOf:
+            - $ref: "#/components/schemas/TokenAmount"
+        buyAmount:
+          description: Amount of buy token (hex- or decimal-encoded uint256).
+          allOf:
+            - $ref: "#/components/schemas/TokenAmount"
+        kind:
+          description: Whether this is a sell or buy order.
+          allOf:
+            - $ref: "#/components/schemas/OrderKind"
+        owner:
+          description: The address of the order owner.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+        receiver:
+          description: >
+            The address that will receive the buy tokens. Defaults to the owner
+            if omitted.
+          allOf:
+            - $ref: "#/components/schemas/Address"
+          nullable: true
+        sellTokenBalance:
+          description: Where the sell token should be drawn from.
+          allOf:
+            - $ref: "#/components/schemas/SellTokenSource"
+          default: erc20
+        buyTokenBalance:
+          description: Where the buy token should be transferred to.
+          allOf:
+            - $ref: "#/components/schemas/BuyTokenDestination"
+          default: erc20
+        appData:
+          description: >
+            Full app data JSON string. Defaults to `"{}"` if omitted.
+          type: string
+          nullable: true
+        blockNumber:
+          type: integer
+      required:
+        - sellToken
+        - buyToken
+        - sellAmount
+        - buyAmount
+        - kind
+        - owner
     OrderSimulation:
       description: >
         The Tenderly simulation request for an order, along with any
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 550fe52de4..0977680efa 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -271,6 +271,11 @@ pub fn handle_all_routes(
             "/api/v1/debug/simulation/{uid}",
             get(debug_simulation::debug_simulation_handler),
         ),
+        (
+            "POST",
+            "/api/v1/debug/simulation",
+            post(debug_simulation::debug_simulation_post_handler),
+        ),
         // V2 routes
         // /solver_competition routes (specific before parameterized)
         (
diff --git a/crates/orderbook/src/api/debug_simulation.rs b/crates/orderbook/src/api/debug_simulation.rs
index e51ad40894..7937a58751 100644
--- a/crates/orderbook/src/api/debug_simulation.rs
+++ b/crates/orderbook/src/api/debug_simulation.rs
@@ -1,9 +1,10 @@
 use {
-    crate::{api::AppState, orderbook::OrderSimulationError},
+    crate::{api::AppState, dto::OrderSimulationRequest, orderbook::OrderSimulationError},
     axum::{
+        Json,
         extract::{Path, Query, State},
         http::StatusCode,
-        response::{IntoResponse, Json, Response},
+        response::{IntoResponse, Response},
     },
     model::order::OrderUid,
     serde::Deserialize,
@@ -31,17 +32,43 @@ pub async fn debug_simulation_handler(
             super::error("NotFound", "order not found"),
         )
             .into_response(),
-        Err(OrderSimulationError::NotEnabled) => (
-            StatusCode::METHOD_NOT_ALLOWED,
-            super::error(
-                "MethodNotAllowed",
-                "order simulation endpoint is not enabled",
-            ),
-        )
-            .into_response(),
-        Err(OrderSimulationError::Other(err)) => {
-            tracing::error!(?err, "failed to create simulation for order");
-            crate::api::internal_error_reply()
+        Err(err) => err.into_response(),
+    }
+}
+
+pub async fn debug_simulation_post_handler(
+    State(state): State<Arc<AppState>>,
+    Json(request): Json<OrderSimulationRequest>,
+) -> Response {
+    match state.orderbook.simulate_custom_order(request).await {
+        Ok(result) => (StatusCode::OK, Json(result)).into_response(),
+        Err(err) => err.into_response(),
+    }
+}
+
+impl IntoResponse for OrderSimulationError {
+    fn into_response(self) -> Response {
+        match self {
+            OrderSimulationError::NotEnabled => (
+                StatusCode::METHOD_NOT_ALLOWED,
+                super::error(
+                    "MethodNotAllowed",
+                    "order simulation endpoint is not enabled",
+                ),
+            )
+                .into_response(),
+            OrderSimulationError::MalformedInput(err) => {
+                tracing::warn!(?err, "failed to parse order simulation input");
+                (
+                    StatusCode::BAD_REQUEST,
+                    super::error("BadRequest", format!("malformed input: {err}")),
+                )
+                    .into_response()
+            }
+            OrderSimulationError::Other(err) => {
+                tracing::error!(?err, "failed to create simulation for order");
+                crate::api::internal_error_reply()
+            }
         }
     }
 }
diff --git a/crates/orderbook/src/dto/mod.rs b/crates/orderbook/src/dto/mod.rs
index 6e1d2bb1d5..bb856b87fe 100644
--- a/crates/orderbook/src/dto/mod.rs
+++ b/crates/orderbook/src/dto/mod.rs
@@ -3,6 +3,8 @@ pub mod order;
 
 use {
     alloy::primitives::U256,
+    eth_domain_types::{Address, NonZeroU256},
+    model::order::{BuyTokenDestination, OrderKind, SellTokenSource},
     number::serialization::HexOrDecimalU256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
@@ -13,12 +15,52 @@ pub use {
     order::Order,
 };
 
+/// Request body for the POST /api/v1/debug/simulation endpoint.
+#[serde_as]
+#[derive(Serialize, Deserialize, Debug, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderSimulationRequest {
+    /// The address of the token being sold.
+    pub sell_token: Address,
+    /// The address of the token being bought.
+    pub buy_token: Address,
+    /// The amount of `sell_token`s that may be sold.
+    pub sell_amount: NonZeroU256,
+    /// The amount of `buy_token`s that should be bought.
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub buy_amount: U256,
+    /// The kind of order (i.e. sell or buy).
+    pub kind: OrderKind,
+    /// The address of the order's owner
+    pub owner: Address,
+    /// The receiver of the `buy_token`. When this field is `None`, the receiver
+    /// is the same as the owner.
+    #[serde(default)]
+    pub receiver: Option<Address>,
+    /// Sell token's source — ERC20, internal vault or external vault (at the
+    /// time of writing).
+    #[serde(default)]
+    pub sell_token_balance: SellTokenSource,
+    /// Defines how tokens are transferred back to the user, either as an ERC-20
+    /// token transfer or internal Balancer Vault transfer.
+    #[serde(default)]
+    pub buy_token_balance: BuyTokenDestination,
+    /// Full app data JSON. Defaults to `"{}"` if omitted.
+    #[serde(default)]
+    pub app_data: Option<String>,
+    /// The block number at which the simulation should happen
+    #[serde(default)]
+    pub block_number: Option<u64>,
+}
+
 /// The result of Order simulation, contains the error (if any)
 /// and full Tenderly API request that can be used to resimulate
 /// and debug using Tenderly
 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct OrderSimulationResult {
+    /// Full request object that can be used directly with the Tenderly API
     pub tenderly_request: tenderly::dto::Request,
+    /// Any error that might have been reported during order simulation
     pub error: Option<String>,
 }
 
diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
index 1a800422d6..28ec3b1a5b 100644
--- a/crates/orderbook/src/order_simulator.rs
+++ b/crates/orderbook/src/order_simulator.rs
@@ -4,22 +4,31 @@ use {
         primitives::{Address, U256},
         rpc::types::state::AccountOverride,
     },
-    anyhow::{Context, Result},
+    anyhow::{Context, Result, anyhow},
+    app_data::WrapperCall,
     balance_overrides::BalanceOverrideRequest,
     contracts::alloy::support::{AnyoneAuthenticator, Trader},
-    eth_domain_types::BlockNo,
+    eth_domain_types::{BlockNo, NonZeroU256},
     model::order::Order,
     simulator::{
         encoding::InteractionEncoding,
         swap_simulator::{EncodedSwap, Query, SwapSimulator, TradeEncoding},
     },
+    thiserror::Error,
 };
-
 pub struct OrderSimulator {
     simulator: SwapSimulator,
     chain_id: String,
 }
 
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("simulation could not be created")]
+    Other(anyhow::Error),
+    #[error("malformed input")]
+    MalformedInput(anyhow::Error),
+}
+
 impl OrderSimulator {
     pub fn new(simulator: SwapSimulator, chain_id: String) -> Self {
         Self {
@@ -28,12 +37,11 @@ impl OrderSimulator {
         }
     }
 
-    pub async fn encode_order(&self, order: &Order) -> Result<EncodedSwap> {
-        let Some(app_data) = &order.metadata.full_app_data else {
-            anyhow::bail!("App data is not known for order {}", order.metadata.uid)
-        };
-        let app_data = serde_json::from_str::<app_data::Root>(app_data)?;
-
+    pub async fn encode_order(
+        &self,
+        order: &Order,
+        wrappers: Vec<WrapperCall>,
+    ) -> Result<EncodedSwap, Error> {
         let tokens = vec![order.data.sell_token, order.data.buy_token];
         // Clearing prices represent the limit price of the order; both order kinds
         // produce the same ratio: [buy_amount, sell_amount] for [sell_token,
@@ -44,7 +52,9 @@ impl OrderSimulator {
         // TODO(m-sz): Add support for specifying a partially filled order (current fill
         // status or custom amount)
         let query = Query {
-            sell_amount: order.data.sell_amount.try_into()?,
+            sell_amount: NonZeroU256::try_from(order.data.sell_amount).map_err(|err| {
+                Error::MalformedInput(anyhow!("sell_amount `{}`: {err}", order.data.sell_amount))
+            })?,
             sell_token: order.data.sell_token,
             buy_amount: order.data.buy_amount,
             buy_token: order.data.buy_token,
@@ -57,8 +67,7 @@ impl OrderSimulator {
             clearing_prices,
             solver,
             tokens,
-            wrappers: app_data
-                .wrappers()
+            wrappers: wrappers
                 .iter()
                 .map(|wrapper| simulator::encoding::WrapperCall {
                     address: wrapper.address,
@@ -70,7 +79,8 @@ impl OrderSimulator {
         let swap = self
             .simulator
             .fake_swap(&query, TradeEncoding::Simple)
-            .await?;
+            .await
+            .map_err(Error::Other)?;
         let swap = add_interactions(swap, order);
         let swap = self.add_state_overrides(&query, swap).await?;
 
@@ -86,13 +96,14 @@ impl OrderSimulator {
         &self,
         swap: EncodedSwap,
         block_number: Option<u64>,
-    ) -> Result<OrderSimulationResult> {
+    ) -> Result<OrderSimulationResult, Error> {
         let block_number =
             block_number.unwrap_or_else(|| self.simulator.current_block.borrow().number);
         let result = self
             .simulator
-            .simulate_settle_call(swap, Some(block_number))
-            .await?;
+            .simulate_settle_call(swap, block_number)
+            .await
+            .map_err(Error::Other)?;
 
         let tenderly_request = simulator::tenderly::dto::Request {
             transaction_index: None,
@@ -103,7 +114,8 @@ impl OrderSimulator {
                 &result.tx,
                 result.overrides,
                 Some(BlockNo(block_number)),
-            )?
+            )
+            .map_err(|err| Error::Other(anyhow!(err)))?
         };
 
         Ok(OrderSimulationResult {
@@ -116,7 +128,7 @@ impl OrderSimulator {
         &self,
         query: &Query,
         mut swap: EncodedSwap,
-    ) -> Result<EncodedSwap> {
+    ) -> Result<EncodedSwap, Error> {
         // Override authenticator with AnyoneAuthenticator so our fake solver is
         // accepted.
         let authenticator = self
@@ -125,7 +137,8 @@ impl OrderSimulator {
             .authenticator()
             .call()
             .await
-            .context("could not fetch authenticator")?;
+            .context("could not fetch authenticator")
+            .map_err(Error::Other)?;
         swap.overrides.insert(
             authenticator,
             AccountOverride {
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index 8f90089586..de61486a01 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -4,23 +4,26 @@ use {
             orders::{InsertionError, OrderStoring},
             trades::{TradeFilter, TradeRetrieving},
         },
-        dto::{self, OrderSimulationResult},
-        order_simulator::OrderSimulator,
+        dto::{self, OrderSimulationRequest, OrderSimulationResult},
+        order_simulator::{self, OrderSimulator},
         solver_competition::{Identifier, LoadSolverCompetitionError, SolverCompetitionStoring},
     },
     alloy::primitives::{Address, B256},
-    anyhow::{Context, Result},
-    app_data::{AppDataHash, Validator},
+    anyhow::{Context, Result, anyhow},
+    app_data::{AppDataHash, Validator, WrapperCall},
     bigdecimal::ToPrimitive,
     chrono::Utc,
     database::order_events::OrderEventLabel,
     model::{
         DomainSeparator,
         order::{
+            Interactions,
             Order,
             OrderCancellation,
             OrderCreation,
             OrderCreationAppData,
+            OrderData,
+            OrderMetadata,
             OrderStatus,
             OrderUid,
             SignedOrderCancellations,
@@ -609,6 +612,26 @@ impl Orderbook {
         Ok(status)
     }
 
+    fn parse_interactions_and_wrappers(
+        &self,
+        full_app_data: &str,
+    ) -> Result<(Interactions, Vec<WrapperCall>)> {
+        Ok(if !full_app_data.is_empty() {
+            let app_data = self
+                .order_validator
+                .validate_app_data(
+                    &OrderCreationAppData::Full {
+                        full: full_app_data.to_string(),
+                    },
+                    &None,
+                )
+                .map_err(|err| anyhow::anyhow!("{:?}", err))?;
+            (app_data.interactions, app_data.inner.protocol.wrappers)
+        } else {
+            (Interactions::default(), Vec::default())
+        })
+    }
+
     /// Simulates an order based on its Uid using the OrderSimulator.
     ///
     /// The returned value contains the simulation result and tenderly API
@@ -629,17 +652,67 @@ impl Orderbook {
             return Ok(None);
         };
 
-        let swap = order_simulator
-            .encode_order(&order)
-            .await
+        let (_, wrappers) = self
+            .parse_interactions_and_wrappers(
+                order.metadata.full_app_data.as_deref().unwrap_or_default(),
+            )
             .map_err(OrderSimulationError::Other)?;
+
+        let swap = order_simulator.encode_order(&order, wrappers).await?;
         Ok(Some(
-            order_simulator
-                .simulate_swap(swap, block_number)
-                .await
-                .map_err(OrderSimulationError::Other)?,
+            order_simulator.simulate_swap(swap, block_number).await?,
         ))
     }
+
+    /// Simulates an arbitrary order without requiring it to exist in the
+    /// database.
+    pub async fn simulate_custom_order(
+        &self,
+        request: OrderSimulationRequest,
+    ) -> Result<OrderSimulationResult, OrderSimulationError> {
+        let Some(order_simulator) = &self.order_simulator else {
+            return Err(OrderSimulationError::NotEnabled);
+        };
+        let full_app_data = request.app_data.unwrap_or_default();
+        let (interactions, wrappers) = self
+            .parse_interactions_and_wrappers(&full_app_data)
+            .map_err(|err| {
+                OrderSimulationError::MalformedInput(anyhow!("app_data `{}`: {err}", full_app_data))
+            })?;
+        let order = Order {
+            metadata: OrderMetadata {
+                owner: request.owner,
+                full_app_data: Some(full_app_data),
+                ..Default::default()
+            },
+            data: OrderData {
+                sell_token: request.sell_token,
+                buy_token: request.buy_token,
+                sell_amount: request.sell_amount.into(),
+                buy_amount: request.buy_amount,
+                kind: request.kind,
+                receiver: request.receiver,
+                sell_token_balance: request.sell_token_balance,
+                buy_token_balance: request.buy_token_balance,
+                ..Default::default()
+            },
+            interactions,
+            ..Default::default()
+        };
+
+        let swap = order_simulator
+            .encode_order(&order, wrappers)
+            .await
+            .map_err(|err| match err {
+                order_simulator::Error::Other(err) => OrderSimulationError::Other(err),
+                order_simulator::Error::MalformedInput(err) => {
+                    OrderSimulationError::MalformedInput(err)
+                }
+            })?;
+        Ok(order_simulator
+            .simulate_swap(swap, request.block_number)
+            .await?)
+    }
 }
 
 #[derive(Error, Debug)]
@@ -663,10 +736,21 @@ impl From<LoadSolverCompetitionError> for OrderStatusError {
 pub enum OrderSimulationError {
     #[error("order simulation is not enabled")]
     NotEnabled,
+    #[error("malformed input")]
+    MalformedInput(anyhow::Error),
     #[error("simulation could not be created for order")]
     Other(anyhow::Error),
 }
 
+impl From<order_simulator::Error> for OrderSimulationError {
+    fn from(value: order_simulator::Error) -> Self {
+        match value {
+            order_simulator::Error::Other(err) => Self::Other(err),
+            order_simulator::Error::MalformedInput(err) => Self::MalformedInput(err),
+        }
+    }
+}
+
 #[async_trait::async_trait]
 impl LivenessChecking for Orderbook {
     async fn is_alive(&self) -> bool {
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 0c7f2a90fe..3846be7df8 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -361,7 +361,7 @@ impl OrderValidator {
     ///
     /// This is done by returning the [`HooksTrampoline`] `execute` calldata
     /// with the (pre/post) hooks calldata as the parameter.
-    fn custom_interactions(&self, hooks: &Hooks) -> Interactions {
+    pub fn custom_interactions(&self, hooks: &Hooks) -> Interactions {
         let to_interactions = |hooks: &[Hook]| -> Vec<InteractionData> {
             if hooks.is_empty() {
                 vec![]
diff --git a/crates/simulator/src/swap_simulator.rs b/crates/simulator/src/swap_simulator.rs
index 5e5fcdbfda..fc34cb1b57 100644
--- a/crates/simulator/src/swap_simulator.rs
+++ b/crates/simulator/src/swap_simulator.rs
@@ -235,12 +235,20 @@ impl SwapSimulator {
         })
     }
 
+    /// Simulate settle call on the latest block
+    pub async fn simulate_settle_call_on_latest(
+        &self,
+        swap: EncodedSwap,
+    ) -> Result<SwapSimulation<Bytes>> {
+        let block_number = self.current_block.borrow().number;
+        self.simulate_settle_call(swap, block_number).await
+    }
+
     pub async fn simulate_settle_call(
         &self,
         swap: EncodedSwap,
-        block_number: Option<u64>,
+        block_number: u64,
     ) -> Result<SwapSimulation<Bytes>> {
-        let block_number = block_number.unwrap_or_else(|| self.current_block.borrow().number);
         let (settlement_target, calldata) = self.get_target_and_calldata(&swap);
 
         let overrides = swap.overrides;

From ab948dc54c220f01e9cfd9c23cd08d5d8bc5140d Mon Sep 17 00:00:00 2001
From: filius <felixfariasfueyo@hotmail.com>
Date: Wed, 8 Apr 2026 04:13:16 +1200
Subject: [PATCH 183/219] Skip balance check for flashloan orders (#4278)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary
- Flashloan orders get their sell tokens from the flashloan at
settlement time, so they should not be filtered out due to insufficient
user balance
- Removes the restriction that flashloan orders must have the settlement
contract as receiver
- Flashloan orders now bypass balance allocation entirely, similar to
CoW AMM orders

---------

Co-authored-by: José Duarte <15343819+jmg-duarte@users.noreply.github.com>
---
 crates/driver/src/domain/competition/mod.rs | 26 +++++++--------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index 2eddc4f91a..c9c29f4ecf 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -298,7 +298,6 @@ impl Competition {
             })?;
         let mut auction = Arc::unwrap_or_clone(tasks.auction.await);
 
-        let settlement_contract = *self.eth.contracts().settlement().address();
         let solver_address = self.solver.address();
         let order_sorting_strategies = self.order_sorting_strategies.clone();
 
@@ -306,16 +305,10 @@ impl Competition {
         let cow_amm_orders = tasks.cow_amm_orders.await;
         auction.orders.extend(cow_amm_orders.iter().cloned());
 
-        let settlement = settlement_contract;
         let sort_orders_future = Self::run_blocking_with_timer("sort_orders", move || {
             // Use spawn_blocking() because a lot of CPU bound computations are happening
             // and we don't want to block the runtime for too long.
-            Self::sort_orders(
-                auction,
-                solver_address,
-                order_sorting_strategies,
-                settlement,
-            )
+            Self::sort_orders(auction, solver_address, order_sorting_strategies)
         });
 
         // We can sort the orders and fetch auction data in parallel
@@ -326,7 +319,7 @@ impl Competition {
             // Same as before with sort_orders, we use spawn_blocking() because a lot of CPU
             // bound computations are happening and we want to avoid blocking
             // the runtime.
-            Self::update_orders(auction, balances, app_data, cow_amm_orders, &settlement)
+            Self::update_orders(auction, balances, app_data, cow_amm_orders)
         })
         .await;
 
@@ -583,7 +576,6 @@ impl Competition {
         mut auction: Auction,
         solver: eth::Address,
         order_sorting_strategies: Vec<Arc<dyn SortingStrategy>>,
-        _settlement_contract: eth::Address,
     ) -> Auction {
         sorting::sort_orders(
             &mut auction.orders,
@@ -603,7 +595,6 @@ impl Competition {
         balances: Arc<Balances>,
         app_data: Arc<HashMap<order::app_data::AppDataHash, Arc<app_data::ValidatedAppData>>>,
         cow_amm_orders: Arc<Vec<Order>>,
-        settlement_contract: &eth::Address,
     ) -> Auction {
         // Clone balances since we only aggregate data once but each solver needs
         // to use and modify the data individually.
@@ -631,13 +622,12 @@ impl Competition {
             // Update order app data if it was fetched.
             if let Some(fetched_app_data) = app_data.get(&order.app_data.hash()) {
                 order.app_data = fetched_app_data.clone().into();
-                if order.app_data.flashloan().is_some() {
-                    // If an order requires a flashloan we assume all the necessary
-                    // sell tokens will come from there. But the receiver must be the
-                    // settlement contract because that is how the driver expects
-                    // the flashloan to be repaid for now.
-                    return order.receiver.as_ref() == Some(settlement_contract);
-                }
+            }
+
+            // Flashloan orders get their sell tokens from the flashloan at
+            // settlement time, so skip the balance check.
+            if order.app_data.flashloan().is_some() {
+                return true;
             }
 
             // wrappers can produce the required funds at settlement time

From 7b16a3d7789dff46f95a38944dd680817ed8b2e5 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Wed, 8 Apr 2026 09:11:07 +0200
Subject: [PATCH 184/219] Partially filled orders support in simulation (#4306)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
The order simulation endpoint so far always tried to fill the order with
the original 100% fill amount. This leads to reverts if an order was
already partially filled.

# Changes
Fetches the order's fill amount using an RPC call at the given block and
deducts that from the full order amount. This will cause the simulation
to always fill the remaining executable amount.

## How to test
E2E test simulating a partially filled order.

---------

Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: ilya <ilya@cow.fi>
Co-authored-by: MartinquaXD <martin.beckmann@protonmail.com>
---
 crates/e2e/tests/e2e/order_simulation.rs | 144 ++++++++++++++++++++++-
 crates/orderbook/src/order_simulator.rs  |  74 ++++++++++--
 crates/orderbook/src/orderbook.rs        |  14 ++-
 3 files changed, 217 insertions(+), 15 deletions(-)

diff --git a/crates/e2e/tests/e2e/order_simulation.rs b/crates/e2e/tests/e2e/order_simulation.rs
index ece1c56eae..4d574a6748 100644
--- a/crates/e2e/tests/e2e/order_simulation.rs
+++ b/crates/e2e/tests/e2e/order_simulation.rs
@@ -1,7 +1,7 @@
 use {
     alloy::{primitives::Address, providers::Provider},
     configs::test_util::TestDefault,
-    e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
+    e2e::setup::{API_HOST, OnchainComponents, Services, TIMEOUT, run_test, wait_for_condition},
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::{
         order::{OrderCreation, OrderKind},
@@ -25,6 +25,12 @@ async fn local_node_custom_order_simulation() {
     run_test(custom_order_simulation).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn local_node_order_simulation_partial_fill() {
+    run_test(order_simulation_partial_fill).await;
+}
+
 async fn custom_order_simulation(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
@@ -228,3 +234,139 @@ async fn order_simulation(web3: Web3) {
     assert_eq!(tenderly.simulation_type, Some(SimulationType::Full));
     assert_eq!(tenderly.value, None);
 }
+
+// Uses a shallow pool to force a partial fill (same setup as partial_fill.rs).
+// The test verifies two things:
+//
+// 1. Before any on-chain fill: filledAmount=0, full 4 WETH needed; trader only
+//    has 1 WETH → simulation must fail.
+//
+// 2. After ~2 WETH is settled on-chain (pool depth limits the fill): the
+//    simulator reads filledAmount from the settlement contract and only
+//    simulates the ~2 WETH remaining.  Trader holds ~2 WETH, so simulation must
+//    pass.  If the simulator did NOT read on-chain state it would try to
+//    simulate the full 4 WETH and revert (trader only has ~2 WETH).
+async fn order_simulation_partial_fill(web3: Web3) {
+    let mut onchain = OnchainComponents::deploy(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers(10u64.eth()).await;
+    let [trader] = onchain.make_accounts(10u64.eth()).await;
+    // Shallow pool forces the solver to only partially fill the order
+    // (same pool size as partial_fill.rs).
+    let [token] = onchain
+        .deploy_tokens_with_weth_uni_v2_pools(10u64.eth(), 10u64.eth())
+        .await;
+
+    // Fund with 4 WETH so the order passes balance validation on submission.
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(4u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+    onchain
+        .contracts()
+        .weth
+        .approve(onchain.contracts().allowance, 4u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let services = Services::new(&onchain).await;
+    services.start_protocol(solver.clone()).await;
+
+    // Same order as partial_fill.rs: pool can only fill ~2 WETH at this price.
+    let order = OrderCreation {
+        sell_token: *onchain.contracts().weth.address(),
+        sell_amount: 4u64.eth(),
+        buy_token: *token.address(),
+        buy_amount: 3u64.eth(),
+        valid_to: model::time::now_in_epoch_seconds() + 300,
+        kind: OrderKind::Sell,
+        partially_fillable: true,
+        ..Default::default()
+    }
+    .sign(
+        EcdsaSigningScheme::Eip712,
+        &onchain.contracts().domain_separator,
+        &trader.signer,
+    );
+    let uid = services.create_order(&order).await.unwrap();
+
+    // Before any block is minted the autopilot has not yet processed the order.
+    // Burn 3 WETH so the trader holds only 1 WETH; filledAmount is still 0.
+    let burn = Address::from([0x42u8; 20]);
+    onchain
+        .contracts()
+        .weth
+        .transfer(burn, 3u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let client = services.client();
+
+    // filledAmount=0 on-chain; full 4 WETH needed; trader only has 1 → must fail.
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+    assert!(
+        result.error.is_some(),
+        "expected simulation failure: filledAmount=0 so full 4 WETH is needed, but trader has 1"
+    );
+    assert!(result.error.unwrap().contains("reverted"));
+
+    // Restore 4 WETH so the solver can actually execute the partial fill.
+    onchain
+        .contracts()
+        .weth
+        .deposit()
+        .from(trader.address())
+        .value(3u64.eth())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    // Trigger the autopilot to pick up the order and settle a partial fill.
+    onchain.mint_block().await;
+
+    let trade_happened = || async {
+        !token
+            .balanceOf(trader.address())
+            .call()
+            .await
+            .unwrap()
+            .is_zero()
+    };
+    wait_for_condition(TIMEOUT, trade_happened).await.unwrap();
+
+    // Simulation must pass.  After the ~2 WETH partial fill:
+    //   - filledAmount ≈ 2 WETH on-chain
+    //   - remaining sell ≈ 2 WETH
+    //   - trader WETH balance ≈ 2 WETH  (started with 4, ~2 sold)
+    // Without reading on-chain fill state the simulator would need the full
+    // 4 WETH from the trader (who only holds ~2) and revert.
+    let response = client
+        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    let result = response.json::<OrderSimulationResult>().await.unwrap();
+
+    assert_eq!(
+        result.error, None,
+        "expected simulation success after partial fill (on-chain filledAmount reduces the \
+         simulated sell amount to match trader balance), got error: {:?}",
+        result.error
+    );
+}
diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
index 28ec3b1a5b..92d06ae289 100644
--- a/crates/orderbook/src/order_simulator.rs
+++ b/crates/orderbook/src/order_simulator.rs
@@ -1,7 +1,8 @@
 use {
     crate::dto::OrderSimulationResult,
     alloy::{
-        primitives::{Address, U256},
+        eips::BlockId,
+        primitives::{Address, Bytes, U256},
         rpc::types::state::AccountOverride,
     },
     anyhow::{Context, Result, anyhow},
@@ -10,6 +11,7 @@ use {
     contracts::alloy::support::{AnyoneAuthenticator, Trader},
     eth_domain_types::{BlockNo, NonZeroU256},
     model::order::Order,
+    shared::remaining_amounts,
     simulator::{
         encoding::InteractionEncoding,
         swap_simulator::{EncodedSwap, Query, SwapSimulator, TradeEncoding},
@@ -37,26 +39,80 @@ impl OrderSimulator {
         }
     }
 
+    /// Calculates the remaining sell and buy amounts
+    /// Returns a tuple of (remaining_sell, remaining_buy)
+    async fn remaining_amounts(
+        &self,
+        order: &Order,
+        block: Option<BlockId>,
+    ) -> Result<(U256, U256), Error> {
+        let mut filled_amount_call = self
+            .simulator
+            .settlement
+            .filledAmount(Bytes::from(order.metadata.uid.0));
+
+        if let Some(block) = block {
+            filled_amount_call = filled_amount_call.block(block);
+        }
+        let executed_amount = filled_amount_call
+            .call()
+            .await
+            .map_err(|err| Error::Other(anyhow!(err)))?;
+
+        let remaining_order = remaining_amounts::Order {
+            kind: order.data.kind,
+            buy_amount: order.data.buy_amount,
+            sell_amount: order.data.sell_amount,
+            fee_amount: order.data.fee_amount,
+            executed_amount,
+            partially_fillable: order.data.partially_fillable,
+        };
+        let remaining = remaining_amounts::Remaining::from_order(&remaining_order)
+            .with_context(|| {
+                format!(
+                    "could not compute remaining amounts for order {}",
+                    order.metadata.uid
+                )
+            })
+            .map_err(Error::Other)?;
+        let remaining_sell = remaining
+            .remaining(order.data.sell_amount)
+            .context("overflow computing remaining sell amount")
+            .map_err(Error::Other)?;
+        let remaining_buy = remaining
+            .remaining(order.data.buy_amount)
+            .context("overflow computing remaining buy amount")
+            .map_err(Error::Other)?;
+
+        Ok((remaining_sell, remaining_buy))
+    }
+
+    /// Encodes an order for simulation.
+    ///
+    /// `executed_amount` overrides how much of the order has already been
+    /// filled (in the order's fill token: sell token for sell orders, buy
+    /// token for buy orders). When `None`, the executed amount is taken from
+    /// the order's metadata, which reflects the actual on-chain fill state.
     pub async fn encode_order(
         &self,
         order: &Order,
         wrappers: Vec<WrapperCall>,
+        block: Option<u64>,
     ) -> Result<EncodedSwap, Error> {
         let tokens = vec![order.data.sell_token, order.data.buy_token];
         // Clearing prices represent the limit price of the order; both order kinds
         // produce the same ratio: [buy_amount, sell_amount] for [sell_token,
         // buy_token].
         let clearing_prices = vec![order.data.buy_amount, order.data.sell_amount];
-
         let solver = Address::random();
-        // TODO(m-sz): Add support for specifying a partially filled order (current fill
-        // status or custom amount)
+        let (remaining_sell, remaining_buy) =
+            self.remaining_amounts(order, block.map(Into::into)).await?;
         let query = Query {
-            sell_amount: NonZeroU256::try_from(order.data.sell_amount).map_err(|err| {
+            sell_amount: NonZeroU256::try_from(remaining_sell).map_err(|err| {
                 Error::MalformedInput(anyhow!("sell_amount `{}`: {err}", order.data.sell_amount))
             })?,
             sell_token: order.data.sell_token,
-            buy_amount: order.data.buy_amount,
+            buy_amount: remaining_buy,
             buy_token: order.data.buy_token,
             kind: order.data.kind,
             receiver: order.data.receiver.unwrap_or(order.metadata.owner),
@@ -171,14 +227,16 @@ impl OrderSimulator {
             },
         );
 
-        // Fund the settlement contract with enough buy tokens to be paid out
+        // Fund the settlement contract with enough buy tokens to be paid out.
+        // Add 1 to account for ceiling division in the settlement contract's
+        // executedBuyAmount calculation, which can be 1 unit above remaining_buy.
         match self
             .simulator
             .balance_overrides
             .state_override(BalanceOverrideRequest {
                 token: query.buy_token,
                 holder: *self.simulator.settlement.address(),
-                amount: query.buy_amount,
+                amount: query.buy_amount + U256::ONE,
             })
             .await
         {
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index de61486a01..cdbdc57c8e 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -616,7 +616,7 @@ impl Orderbook {
         &self,
         full_app_data: &str,
     ) -> Result<(Interactions, Vec<WrapperCall>)> {
-        Ok(if !full_app_data.is_empty() {
+        if !full_app_data.is_empty() {
             let app_data = self
                 .order_validator
                 .validate_app_data(
@@ -626,10 +626,10 @@ impl Orderbook {
                     &None,
                 )
                 .map_err(|err| anyhow::anyhow!("{:?}", err))?;
-            (app_data.interactions, app_data.inner.protocol.wrappers)
+            Ok((app_data.interactions, app_data.inner.protocol.wrappers))
         } else {
-            (Interactions::default(), Vec::default())
-        })
+            Ok((Interactions::default(), Vec::default()))
+        }
     }
 
     /// Simulates an order based on its Uid using the OrderSimulator.
@@ -658,7 +658,9 @@ impl Orderbook {
             )
             .map_err(OrderSimulationError::Other)?;
 
-        let swap = order_simulator.encode_order(&order, wrappers).await?;
+        let swap = order_simulator
+            .encode_order(&order, wrappers, block_number)
+            .await?;
         Ok(Some(
             order_simulator.simulate_swap(swap, block_number).await?,
         ))
@@ -701,7 +703,7 @@ impl Orderbook {
         };
 
         let swap = order_simulator
-            .encode_order(&order, wrappers)
+            .encode_order(&order, wrappers, request.block_number)
             .await
             .map_err(|err| match err {
                 order_simulator::Error::Other(err) => OrderSimulationError::Other(err),

From d6a912d54ba7a8b7b2ece792477d411e3363e802 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Wed, 8 Apr 2026 10:51:25 +0100
Subject: [PATCH 185/219] Add global query timeout to SELECT queries (#4272)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Following the issues we faced with RDS, and the fact that [SQLx does not
provide global
timeouts](https://github.com/launchbadge/sqlx/issues/3060), this PR uses
PostgreSQL's native `statement_timeout` to limit the duration of read
queries on the **orderbook's read replica**.

Instead of wrapping every query on the client side, the timeout is set
once per connection via the pool's `after_connect` hook. This means
every query issued through that pool is automatically subject to the
configured timeout — no per-call changes needed.

The timeout is only applied to the **orderbook read replica** pool
(created with `Postgres::try_new_with_timeout`). Write pools and other
services are unaffected.

# Changes

* **`crates/orderbook/src/database/mod.rs`** — Added `statement_timeout`
to `Config` and a new `Postgres::try_new_with_timeout` constructor that
sets `statement_timeout` on every connection via `after_connect`.
Includes a postgres integration test using `pg_sleep`.
* **`crates/orderbook/src/run.rs`** — The read replica pool now uses
`try_new_with_timeout`.
* **`crates/configs/src/database.rs`** — Added `statement_timeout` field
to `DatabasePoolConfig` (defaults to `30s`, deserialized via
`humantime_serde`).
* **`crates/shared/src/arguments.rs`** — Added `--statement-timeout` CLI
flag (used by refunder).
* **`crates/database/src/trades.rs`** — Changed `trades()` from
returning a `BoxStream` to `fetch_all`, since streaming doesn't play
well with connection-level timeouts.
* Minor whitespace cleanups in other `crates/database/src/*.rs` files
and removal of an unrelated stale config section in the playground
autopilot config.

## How to test

Run the integration test against a local postgres (`docker compose up
-d` first):
```
cargo nextest run -p orderbook statement_timeout --test-threads 1 --run-ignored ignored-only
```

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/configs/src/database.rs                | 11 ++++
 crates/database/src/ethflow_orders.rs         |  4 +-
 crates/database/src/jit_orders.rs             |  4 +-
 crates/database/src/orders.rs                 |  4 +-
 crates/database/src/solver_competition_v2.rs  |  8 +--
 crates/database/src/trades.rs                 | 12 +---
 crates/orderbook/src/database/debug_report.rs |  2 -
 crates/orderbook/src/database/mod.rs          | 56 ++++++++++++++++++-
 crates/orderbook/src/database/trades.rs       | 11 ++--
 crates/orderbook/src/run.rs                   |  3 +-
 crates/shared/src/arguments.rs                |  8 ++-
 playground/configs/autopilot.toml             |  3 -
 12 files changed, 91 insertions(+), 35 deletions(-)

diff --git a/crates/configs/src/database.rs b/crates/configs/src/database.rs
index e1b0b55cf2..0c9190e04a 100644
--- a/crates/configs/src/database.rs
+++ b/crates/configs/src/database.rs
@@ -3,6 +3,7 @@ use {
         fmt::Debug,
         num::{NonZeroU32, NonZeroUsize},
         str::FromStr,
+        time::Duration,
     },
     url::Url,
 };
@@ -16,6 +17,10 @@ fn default_db_write_url() -> Url {
     Url::from_str("postgresql://").expect("url should be valid")
 }
 
+const fn default_statement_timeout() -> Duration {
+    Duration::from_secs(30)
+}
+
 const fn default_insert_batch_size() -> NonZeroUsize {
     NonZeroUsize::new(500).expect("value should be greater than 0")
 }
@@ -53,6 +58,10 @@ pub struct DatabasePoolConfig {
     /// The number of order events to insert in a single batch.
     #[serde(default = "default_insert_batch_size")]
     pub insert_batch_size: NonZeroUsize,
+
+    /// Timeout for database read queries. Defaults to 30 seconds.
+    #[serde(default = "default_statement_timeout", with = "humantime_serde")]
+    pub statement_timeout: Duration,
 }
 
 impl Default for DatabasePoolConfig {
@@ -62,6 +71,7 @@ impl Default for DatabasePoolConfig {
             read_url: Default::default(),
             max_connections: default_db_max_connections(),
             insert_batch_size: default_insert_batch_size(),
+            statement_timeout: default_statement_timeout(),
         }
     }
 }
@@ -73,6 +83,7 @@ impl Debug for DatabasePoolConfig {
             .field("read_url", &"REDACTED")
             .field("max_connections", &self.max_connections)
             .field("insert_batch_size", &self.insert_batch_size)
+            .field("statement_timeout", &self.statement_timeout)
             .finish()
     }
 }
diff --git a/crates/database/src/ethflow_orders.rs b/crates/database/src/ethflow_orders.rs
index 146a714af5..2c40d6858d 100644
--- a/crates/database/src/ethflow_orders.rs
+++ b/crates/database/src/ethflow_orders.rs
@@ -112,7 +112,7 @@ pub async fn insert_refund_tx_hash(
     refund: &Refund,
 ) -> Result<(), sqlx::Error> {
     const QUERY: &str = r#"
-        INSERT INTO ethflow_refunds (order_uid, block_number, tx_hash) VALUES($1, $2, $3) 
+        INSERT INTO ethflow_refunds (order_uid, block_number, tx_hash) VALUES($1, $2, $3)
         ON CONFLICT (order_uid) DO UPDATE SET block_number = $2, tx_hash = $3
     "#;
 
@@ -153,7 +153,7 @@ pub async fn refundable_orders(
 
     let query = format!(
         r#"
-SELECT eo.uid, eo.valid_to 
+SELECT eo.uid, eo.valid_to
 FROM ethflow_orders eo
 JOIN orders o ON o.uid = eo.uid
     AND o.partially_fillable = false
diff --git a/crates/database/src/jit_orders.rs b/crates/database/src/jit_orders.rs
index 82b87fd981..b9d1fde168 100644
--- a/crates/database/src/jit_orders.rs
+++ b/crates/database/src/jit_orders.rs
@@ -80,7 +80,7 @@ pub async fn get_by_tx(
         t.block_number = (SELECT block_number FROM settlement) AND
         -- BETWEEN is inclusive
         t.log_index BETWEEN (SELECT * from previous_settlement) AND (SELECT log_index FROM \
-         settlement) 
+         settlement)
         AND NOT EXISTS (
             SELECT 1 FROM orders ord
             WHERE ord.uid = o.uid)
@@ -141,7 +141,7 @@ pub async fn insert(ex: &mut PgConnection, jit_orders: &[JitOrder]) -> Result<()
             signing_scheme,
             sell_token_balance,
             buy_token_balance
-        ) 
+        )
         "#,
     );
 
diff --git a/crates/database/src/orders.rs b/crates/database/src/orders.rs
index cc8feeb08c..23d12ae1db 100644
--- a/crates/database/src/orders.rs
+++ b/crates/database/src/orders.rs
@@ -154,10 +154,10 @@ VALUES (
     -- Ethflow orders are inserted with valid_to set to u32::MAX. Their true validity is stored in
     -- the ethflow_orders table.
     -- If there already exists an Ethflow order with the same uid, take smaller of the two valid_to values
-    CASE 
+    CASE
         WHEN $21 = 4294967295 THEN  -- u32::MAX
             COALESCE((SELECT valid_to FROM ethflow_orders WHERE uid = $1), $21)
-        ELSE 
+        ELSE
             $21
     END
 )
diff --git a/crates/database/src/solver_competition_v2.rs b/crates/database/src/solver_competition_v2.rs
index cf9f5a277b..97f749eb8e 100644
--- a/crates/database/src/solver_competition_v2.rs
+++ b/crates/database/src/solver_competition_v2.rs
@@ -151,7 +151,7 @@ pub async fn load_by_id(
         .await?;
 
     const FETCH_TRADES: &str = r#"
-        SELECT pte.solution_uid, pte.order_uid, executed_sell, executed_buy, 
+        SELECT pte.solution_uid, pte.order_uid, executed_sell, executed_buy,
             COALESCE(o.sell_token, pjo.sell_token) AS sell_token,
             COALESCE(o.buy_token, pjo.buy_token) AS buy_token
         FROM proposed_trade_executions AS pte
@@ -262,7 +262,7 @@ async fn save_solutions(
     solutions: &[Solution],
 ) -> Result<(), sqlx::Error> {
     let mut builder = QueryBuilder::new(
-        r#"INSERT INTO proposed_solutions 
+        r#"INSERT INTO proposed_solutions
         (auction_id, uid, id, solver, is_winner, filtered_out, score, price_tokens, price_values)"#,
     );
 
@@ -290,7 +290,7 @@ async fn save_trade_executions(
     solutions: &[Solution],
 ) -> Result<(), sqlx::Error> {
     let mut builder = QueryBuilder::new(
-        r#"INSERT INTO proposed_trade_executions 
+        r#"INSERT INTO proposed_trade_executions
         (auction_id, solution_uid, order_uid, executed_sell, executed_buy)"#,
     );
 
@@ -326,7 +326,7 @@ async fn save_jit_orders(
             // Order data is saved to `proposed_jit_orders` table only if the order is not
             // already in the `orders` table.
             const QUERY_JIT: &str = r#"
-                INSERT INTO proposed_jit_orders 
+                INSERT INTO proposed_jit_orders
                 (auction_id, solution_uid, order_uid, sell_token, buy_token, limit_sell, limit_buy, side)
                 SELECT $1, $2, $3, $4, $5, $6, $7, $8
                     WHERE NOT EXISTS (SELECT 1 FROM orders WHERE uid = $3)
diff --git a/crates/database/src/trades.rs b/crates/database/src/trades.rs
index 34ec8f92cb..09d6072ae5 100644
--- a/crates/database/src/trades.rs
+++ b/crates/database/src/trades.rs
@@ -1,7 +1,6 @@
 use {
     crate::{Address, OrderUid, TransactionHash, auction::AuctionId, events::EventIndex},
     bigdecimal::BigDecimal,
-    futures::stream::BoxStream,
     sqlx::PgConnection,
     tracing::{Instrument, info_span, instrument},
 };
@@ -27,7 +26,7 @@ pub fn trades<'a>(
     order_uid_filter: Option<&'a OrderUid>,
     offset: i64,
     limit: i64,
-) -> instrument::Instrumented<BoxStream<'a, Result<TradesQueryRow, sqlx::Error>>> {
+) -> instrument::Instrumented<impl Future<Output = Result<Vec<TradesQueryRow>, sqlx::Error>>> {
     const SELECT: &str = r#"
 SELECT
     t.block_number,
@@ -116,7 +115,7 @@ LEFT OUTER JOIN LATERAL (
         .bind(order_uid_filter)
         .bind(limit)
         .bind(offset)
-        .fetch(ex)
+        .fetch_all(ex)
         .instrument(info_span!("trades"))
 }
 
@@ -192,7 +191,6 @@ mod tests {
             onchain_broadcasted_orders::{OnchainOrderPlacement, insert_onchain_order},
             orders::Order,
         },
-        futures::TryStreamExt,
         sqlx::Connection,
     };
 
@@ -277,7 +275,6 @@ mod tests {
         // Use large limit to get all trades
         let mut filtered = trades(db, owner_filter, order_uid_filter, 0, 1000)
             .into_inner()
-            .try_collect::<Vec<_>>()
             .await
             .unwrap();
         filtered.sort_by_key(|t| (t.block_number, t.log_index));
@@ -366,7 +363,6 @@ mod tests {
         let now = std::time::Instant::now();
         trades(&mut db, Some(&ByteArray([2u8; 20])), None, 0, 100)
             .into_inner()
-            .try_collect::<Vec<_>>()
             .await
             .unwrap();
         let elapsed = now.elapsed();
@@ -826,7 +822,6 @@ mod tests {
         // Test limit: get first 2 trades (blocks 4 and 3 in DESC order)
         let result = trades(&mut db, Some(&owner), None, 0, 2)
             .into_inner()
-            .try_collect::<Vec<_>>()
             .await
             .unwrap();
         assert_eq!(result.len(), 2);
@@ -836,7 +831,6 @@ mod tests {
         // Test offset: skip first 2, get next 2 (blocks 2 and 1 in DESC order)
         let result = trades(&mut db, Some(&owner), None, 2, 2)
             .into_inner()
-            .try_collect::<Vec<_>>()
             .await
             .unwrap();
         assert_eq!(result.len(), 2);
@@ -846,7 +840,6 @@ mod tests {
         // Test offset beyond available trades
         let result = trades(&mut db, Some(&owner), None, 10, 2)
             .into_inner()
-            .try_collect::<Vec<_>>()
             .await
             .unwrap();
         assert_eq!(result.len(), 0);
@@ -854,7 +847,6 @@ mod tests {
         // Test large limit returns all available trades in DESC order
         let result = trades(&mut db, Some(&owner), None, 0, 100)
             .into_inner()
-            .try_collect::<Vec<_>>()
             .await
             .unwrap();
         assert_eq!(result.len(), 5);
diff --git a/crates/orderbook/src/database/debug_report.rs b/crates/orderbook/src/database/debug_report.rs
index 67922fc351..797bedf275 100644
--- a/crates/orderbook/src/database/debug_report.rs
+++ b/crates/orderbook/src/database/debug_report.rs
@@ -13,7 +13,6 @@ use {
         solver_competition_v2::{self, OrderProposedSolution as DbProposedSolution},
         trades::{self, TradesQueryRow as DbTradesQueryRow},
     },
-    futures::TryStreamExt,
     model::{
         debug_report::{
             Auction,
@@ -62,7 +61,6 @@ impl Postgres {
         let executions = order_execution::read_by_order_uid(&mut conn, &db_uid).await?;
         let trades: Vec<DbTradesQueryRow> = trades::trades(&mut conn, None, Some(&db_uid), 0, 100)
             .into_inner()
-            .try_collect()
             .await
             .context("failed to fetch trades")?;
 
diff --git a/crates/orderbook/src/database/mod.rs b/crates/orderbook/src/database/mod.rs
index 8cb125334c..b42bacdc11 100644
--- a/crates/orderbook/src/database/mod.rs
+++ b/crates/orderbook/src/database/mod.rs
@@ -16,7 +16,8 @@ use {
     database::byte_array::ByteArray,
     model::order::Order,
     shared::arguments::DB_MAX_CONNECTIONS_DEFAULT,
-    sqlx::{PgConnection, PgPool, postgres::PgPoolOptions},
+    sqlx::{Executor, PgConnection, PgPool, postgres::PgPoolOptions},
+    std::time::Duration,
 };
 
 // TODO: There is remaining optimization potential by implementing sqlx encoding
@@ -26,6 +27,10 @@ use {
 #[derive(Debug, Clone)]
 pub struct Config {
     pub max_pool_size: u32,
+    /// Maps directly to Postgres' `statement_timeout` parameter, applied on a
+    /// per-connection basis, but *only* if the pool was created using
+    /// [`Postgres::try_new_with_timeout`].
+    pub statement_timeout: Duration,
 }
 
 impl Default for Config {
@@ -33,6 +38,7 @@ impl Default for Config {
         Self {
             // Match SQLx default pool size
             max_pool_size: DB_MAX_CONNECTIONS_DEFAULT.get(),
+            statement_timeout: Duration::from_secs(30),
         }
     }
 }
@@ -57,6 +63,27 @@ impl Postgres {
         })
     }
 
+    /// Creates a Postgres connection pool, but applies the [`Config`]'s
+    /// `statement_timeout` to all queries.
+    pub fn try_new_with_timeout(uri: &str, config: Config) -> Result<Self> {
+        let read_query_timeout = config.statement_timeout;
+
+        Ok(Self {
+            pool: PgPoolOptions::new()
+                .max_connections(config.max_pool_size)
+                .after_connect(move |conn, _meta| {
+                    Box::pin(async move {
+                        let timeout_ms = read_query_timeout.as_millis();
+                        conn.execute(format!("SET statement_timeout = {timeout_ms}").as_str())
+                            .await?;
+                        Ok(())
+                    })
+                })
+                .connect_lazy(uri)?,
+            config,
+        })
+    }
+
     async fn insert_order_app_data(
         order: &Order,
         ex: &mut PgConnection,
@@ -87,3 +114,30 @@ impl Metrics {
         Metrics::instance(observe::metrics::get_storage_registry()).unwrap()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use {super::*, sqlx::Executor};
+
+    #[tokio::test]
+    #[ignore]
+    async fn postgres_statement_timeout_cancels_slow_query() {
+        let config = Config {
+            statement_timeout: Duration::from_millis(100),
+            ..Default::default()
+        };
+        let db = Postgres::try_new_with_timeout("postgresql://", config).unwrap();
+        let mut conn = db.pool.acquire().await.unwrap();
+
+        // A fast query should succeed.
+        conn.execute("SELECT 1").await.unwrap();
+
+        // A query exceeding the timeout should fail.
+        let err = conn
+            .execute("SELECT pg_sleep(5)")
+            .await
+            .expect_err("should have timed out");
+        let db_err = err.as_database_error().expect("should be a database error");
+        assert_eq!(db_err.code().as_deref(), Some("57014")); // query_canceled
+    }
+}
diff --git a/crates/orderbook/src/database/trades.rs b/crates/orderbook/src/database/trades.rs
index ba08e5d69b..0b2bf5bd08 100644
--- a/crates/orderbook/src/database/trades.rs
+++ b/crates/orderbook/src/database/trades.rs
@@ -3,7 +3,6 @@ use {
     alloy::primitives::{Address, B256},
     anyhow::{Context, Result},
     database::{byte_array::ByteArray, trades::TradesQueryRow},
-    futures::stream::TryStreamExt,
     model::{fee_policy::ExecutedProtocolFee, order::OrderUid, trade::Trade},
     number::conversions::big_decimal_to_big_uint,
     std::convert::TryInto,
@@ -53,9 +52,8 @@ impl TradeRetrieving for Postgres {
             i64::MAX,
         )
         .into_inner()
-        .map_err(anyhow::Error::from)
-        .try_collect::<Vec<TradesQueryRow>>()
-        .await?;
+        .await
+        .map_err(anyhow::Error::from)?;
         timer.stop_and_record();
 
         let auction_order_uids = trades
@@ -114,9 +112,8 @@ impl TradeRetrievingPaginated for Postgres {
                 .context("limit too large for database")?,
         )
         .into_inner()
-        .map_err(anyhow::Error::from)
-        .try_collect::<Vec<TradesQueryRow>>()
-        .await?;
+        .await
+        .map_err(anyhow::Error::from)?;
         timer.stop_and_record();
 
         let auction_order_uids = trades
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index cd50094325..1950f9865d 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -178,6 +178,7 @@ pub async fn run(config: Configuration) {
     let domain_separator = DomainSeparator::new(chain_id, *settlement_contract.address());
     let db_config = crate::database::Config {
         max_pool_size: config.database.max_connections.get(),
+        statement_timeout: config.database.statement_timeout,
     };
     let postgres_write = Postgres::try_new(config.database.write_url.as_str(), db_config.clone())
         .expect("failed to create database");
@@ -185,7 +186,7 @@ pub async fn run(config: Configuration) {
     let postgres_read = if let Some(db_read_url) = config.database.read_url
         && config.database.write_url != db_read_url
     {
-        Postgres::try_new(db_read_url.as_str(), db_config)
+        Postgres::try_new_with_timeout(db_read_url.as_str(), db_config)
             .expect("failed to create read replica database")
     } else {
         postgres_write.clone()
diff --git a/crates/shared/src/arguments.rs b/crates/shared/src/arguments.rs
index 623642776c..c2727d37e9 100644
--- a/crates/shared/src/arguments.rs
+++ b/crates/shared/src/arguments.rs
@@ -84,11 +84,17 @@ pub struct DatabasePoolConfig {
     /// Maximum number of connections in the database connection pool.
     #[clap(long, env, default_value_t = DB_MAX_CONNECTIONS_DEFAULT)]
     pub db_max_connections: NonZeroU32,
+
+    /// Timeout for database read queries, only applied to read-only connections
+    /// — for example, the Orderbook.
+    #[clap(long, env, default_value = "30s", value_parser = humantime::parse_duration)]
+    pub statement_timeout: Duration,
 }
 
 impl Display for DatabasePoolConfig {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        writeln!(f, "db_max_connections: {}", self.db_max_connections)
+        writeln!(f, "db_max_connections: {}", self.db_max_connections)?;
+        writeln!(f, "statement_timeout: {:?}", self.statement_timeout)
     }
 }
 
diff --git a/playground/configs/autopilot.toml b/playground/configs/autopilot.toml
index edf6862265..93b0664c58 100644
--- a/playground/configs/autopilot.toml
+++ b/playground/configs/autopilot.toml
@@ -28,6 +28,3 @@ estimators = [[{ type = "Driver", name = "baseline", url = "http://driver/baseli
 
 [native-price-estimation.cache]
 max-age = "20m"
-
-[order-quoting]
-price-estimation-drivers = [{ name = "baseline", url = "http://driver/baseline" }]

From 2893987c31abcdd4bd8df9bb384ba338a14b3396 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Wed, 8 Apr 2026 11:31:27 +0100
Subject: [PATCH 186/219] Fix
 BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory Sepolia block number
 (#4316)

# Description
Corrects the block number for the given contract on Sepolia

# Changes

* Change the block number
---
 crates/contracts/build.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/contracts/build.rs b/crates/contracts/build.rs
index 5a8716d180..f4945ac87a 100644
--- a/crates/contracts/build.rs
+++ b/crates/contracts/build.rs
@@ -232,7 +232,7 @@ fn main() {
                     GNOSIS => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 25415236),
                     // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html#ungrouped-active-current-contracts>
                     // <https://sepolia.etherscan.io/tx/0xe0e8feb509a8aa8a1eaa0b0c4b34395ff2fd880fb854fbeeccc0af1826e395c9>
-                    SEPOLIA => ("0x45fFd460cC6642B8D8Fb12373DFd77Ceb0f4932B", 25415236),
+                    SEPOLIA => ("0x45fFd460cC6642B8D8Fb12373DFd77Ceb0f4932B", 3419649),
                     ARBITRUM_ONE => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 4859669),
                     // <https://basescan.org/tx/0x0529de9dbe772f4b4f48da93ae2c2d2c46e3d3221ced9e0c4063a7a5bc47e874>
                     BASE => ("0x0c6052254551EAe3ECac77B01DFcf1025418828f", 1206531),

From d293fd2e25ae5093dbf689116a1d80b6829a895a Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 8 Apr 2026 12:48:45 +0200
Subject: [PATCH 187/219] Advise Claude to use order debug endpoint (#4303)

# Description

We have a new debug endpoint which will cut Claude's investigation time
a lot.
---
 .claude/commands/debug-order.md | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/.claude/commands/debug-order.md b/.claude/commands/debug-order.md
index 92708aadc9..b2816273ef 100644
--- a/.claude/commands/debug-order.md
+++ b/.claude/commands/debug-order.md
@@ -8,11 +8,21 @@ Read and follow the instructions in ./docs/COW_ORDER_DEBUG_SKILL.md to investiga
 
 Key steps:
 1. Parse the order UID and network from arguments (default: mainnet)
-2. Fetch order data from API to get status and details
-3. Check order_events in DB for lifecycle events
-4. Search Victoria Logs for the order UID
+2. **Start with the debug endpoint** — fetch the comprehensive debug report first:
+   ```bash
+   source .env.claude && curl -s -H "X-API-Key: $COW_DEBUG_API_KEY" "https://partners.cow.fi/$NETWORK/api/v1/debug/order/$ORDER_UID" | jq .
+   ```
+   This returns order details, lifecycle events, auction participation, proposed solutions, executions, trades, and settlement attempts — all in one call.
+3. Analyze the debug report — key event meanings:
+   - `ready` = order made it into an auction (was sent to solvers)
+   - `considered` = a solver included this order in a solution but that solution didn't win
+   - `executing` = order is in the winning solution, being submitted on-chain
+   - `traded` = order was settled on-chain
+   - `filtered` / `invalid` = order was excluded (check the `reason` field)
+4. Search Victoria Logs for additional context (filter reasons, error details, solver logs)
    - For finding discarded solutions where the order UID appears in calldata, use regex: `.*ORDER_UID_WITHOUT_0X.*` plus `discarded`
-5. Identify root cause and report findings with evidence
-6. If you haven't found anything go wild and try all SQL / log searches / codebase searches you can think of
+5. Use DB queries or API calls only if the debug report is missing info or you need deeper investigation
+6. Identify root cause and report findings with evidence
+7. If you haven't found anything go wild and try all SQL / log searches / codebase searches you can think of
 
 Always show your evidence (log lines, DB results, API responses) when presenting findings.

From cfbec985dfe476bf7ef42750435f7d5a12223a85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Wed, 8 Apr 2026 13:19:44 +0100
Subject: [PATCH 188/219] =?UTF-8?q?Refactor=20contracts=20crate=20out=20of?=
 =?UTF-8?q?=20the=20main=20folder=20for=20faster=20compilation=20?=
 =?UTF-8?q?=F0=9F=9A=80=20(#4217)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Replace the `crates/contracts` build.rs-based compile-time code
generation with a standalone code-generation tool that produces
pre-generated per-contract crates. This eliminates the slow build.rs
step from the main workspace build and makes contract bindings explicit,
version-controllable, and independently compilable.

# Changes

* Move `crates/contracts` to top-level `contracts/` directory as a
standalone binary
* Replace build.rs code generation with pre-generated Alloy contract
binding crates under `contracts/generated/`
* Add `contracts-facade` crate that re-exports all generated bindings
for easy consumption
* Update all workspace crates to import from the new generated crates
* Add missing contract artifacts (Balancer factory V3-V6, weighted pool
factory V4, NoProtocolFee LBP factory, DEX router variants)

## How to test

1. `cargo check --workspace --all-targets` — workspace compiles against
the new generated bindings
2. `cargo nextest run` — unit tests pass
3. `cd contracts && cargo run -- --help` — codegen tool runs
independently
4. Verify `contracts/generated/` output matches checked-in code by
re-running the codegen

## Charts

Problematic time blocker:
<img width="1576" height="570" alt="Screenshot 2026-04-08 at 11 32 04"
src="https://github.com/user-attachments/assets/fc39468a-c58b-483d-a941-1896d8e1605f"
/>

CPU Graph (notice the 60s):
<img width="1536" height="420" alt="Screenshot 2026-04-08 at 11 32 16"
src="https://github.com/user-attachments/assets/f3f29ae2-2a07-42a3-a6d3-f578e432fcf4"
/>

No more time blocker (doesn't fully fit vertically in my screen):
<img width="677" height="662" alt="Screenshot 2026-04-08 at 11 38 15"
src="https://github.com/user-attachments/assets/43deac97-4594-4781-a35b-2d47ad8d19f9"
/>

New CPU Graph (notice the 45s and much better (higher) CPU usage):
<img width="1574" height="414" alt="Screenshot 2026-04-08 at 11 35 33"
src="https://github.com/user-attachments/assets/ee12843c-c5de-44d1-9dcb-35a436617ca6"
/>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/pull-request.yaml           |     8 +-
 Cargo.lock                                    |  1029 +-
 Cargo.toml                                    |     5 +-
 Justfile                                      |    16 +
 contracts/.gitignore                          |     2 +
 contracts/Cargo.lock                          |  2302 +
 contracts/Cargo.toml                          |    19 +
 .../contracts => contracts}/LICENSE-APACHE    |     0
 {crates/contracts => contracts}/LICENSE-MIT   |     0
 contracts/README.md                           |    60 +
 .../artifacts/AnyoneAuthenticator.json        |     0
 .../artifacts/BalancerQueries.json            |     0
 .../artifacts/BalancerV2Authorizer.json       |     0
 .../artifacts/BalancerV2BasePool.json         |     0
 .../artifacts/BalancerV2BasePoolFactory.json  |     0
 .../BalancerV2ComposableStablePool.json       |     0
 ...BalancerV2ComposableStablePoolFactory.json |     0
 ...lancerV2ComposableStablePoolFactoryV3.json |   280 +
 ...lancerV2ComposableStablePoolFactoryV4.json |   280 +
 ...lancerV2ComposableStablePoolFactoryV5.json |   280 +
 ...lancerV2ComposableStablePoolFactoryV6.json |   280 +
 .../BalancerV2LiquidityBootstrappingPool.json |     0
 ...erV2LiquidityBootstrappingPoolFactory.json |     0
 ...lFeeLiquidityBootstrappingPoolFactory.json |   158 +
 .../artifacts/BalancerV2StablePool.json       |     0
 .../BalancerV2StablePoolFactoryV2.json        |     0
 .../artifacts/BalancerV2Vault.json            |     0
 .../artifacts/BalancerV2WeightedPool.json     |     0
 .../BalancerV2WeightedPool2TokensFactory.json |     0
 .../BalancerV2WeightedPoolFactory.json        |     0
 .../BalancerV2WeightedPoolFactoryV3.json      |     0
 .../BalancerV2WeightedPoolFactoryV4.json      |   270 +
 .../artifacts/BalancerV3BatchRouter.json      |     0
 .../artifacts/Balances.json                   |     0
 .../artifacts/BaoswapRouter.json              |     0
 .../artifacts/ChainalysisOracle.json          |     0
 .../artifacts/CoWSwapEthFlow.json             |     0
 .../artifacts/CoWSwapOnchainOrders.json       |     0
 .../artifacts/Counter.json                    |     0
 .../artifacts/CowAmm.json                     |     0
 .../CowAmmConstantProductFactory.json         |     0
 .../artifacts/CowAmmFactoryGetter.json        |     0
 .../artifacts/CowAmmLegacyHelper.json         |     0
 .../artifacts/CowAmmUniswapV2PriceOracle.json |     0
 .../artifacts/CowProtocolToken.json           |     0
 .../artifacts/CowSettlementForwarder.json     |     0
 .../artifacts/ERC1271SignatureValidator.json  |     0
 .../artifacts/ERC20.json                      |     0
 .../artifacts/ERC20Mintable.json              |     0
 .../artifacts/FlashLoanRouter.json            |     0
 .../GPv2AllowListAuthentication.json          |     0
 .../artifacts/GPv2Settlement.json             |     0
 .../artifacts/GasHog.json                     |     0
 .../artifacts/GnosisSafe.json                 |     0
 ...nosisSafeCompatibilityFallbackHandler.json |     0
 .../artifacts/GnosisSafeProxy.json            |     0
 .../artifacts/GnosisSafeProxyFactory.json     |     0
 contracts/artifacts/HoneyswapRouter.json      |   955 +
 .../artifacts/HooksTrampoline.json            |     0
 .../artifacts/ICowWrapper.json                |     0
 .../artifacts/ISwaprPair.json                 |     0
 .../artifacts/IUniswapLikePair.json           |     0
 contracts/artifacts/IUniswapLikeRouter.json   |   955 +
 .../artifacts/IUniswapV3Factory.json          |     0
 .../artifacts/IZeroex.json                    |     0
 .../artifacts/LiquoriceSettlement.json        |     0
 .../artifacts/NonStandardERC20Balances.json   |     0
 contracts/artifacts/PancakeRouter.json        |   955 +
 .../artifacts/Permit2.json                    |     0
 .../artifacts/RemoteERC20Balances.json        |     0
 .../artifacts/Signatures.json                 |     0
 .../artifacts/Solver.json                     |     0
 .../artifacts/Spardose.json                   |     0
 contracts/artifacts/SushiSwapRouter.json      |   955 +
 .../artifacts/Swapper.json                    |     0
 contracts/artifacts/SwaprRouter.json          |   955 +
 .../artifacts/TestnetUniswapV2Router02.json   |   955 +
 .../artifacts/Trader.json                     |     0
 .../artifacts/UniswapV2Factory.json           |     0
 .../artifacts/UniswapV2Router02.json          |     0
 .../artifacts/UniswapV3Pool.json              |     0
 .../artifacts/UniswapV3QuoterV2.json          |     0
 .../artifacts/UniswapV3SwapRouterV2.json      |     0
 .../artifacts/WETH9.json                      |     0
 {crates/contracts => contracts}/foundry.toml  |     0
 contracts/generated/.gitignore                |     2 +
 contracts/generated/Cargo.lock                |  4495 ++
 contracts/generated/Cargo.toml                |    17 +
 .../generated/contracts-facade/Cargo.toml     |    88 +
 .../generated/contracts-facade/src/lib.rs     |    97 +
 .../anyoneauthenticator/Cargo.toml            |    19 +
 .../anyoneauthenticator/src/lib.rs            |   527 +
 .../balancerqueries/Cargo.toml                |    19 +
 .../balancerqueries/src/lib.rs                |  3464 ++
 .../balancerv2authorizer/Cargo.toml           |    19 +
 .../balancerv2authorizer/src/lib.rs           |  3825 ++
 .../balancerv2basepool/Cargo.toml             |    19 +
 .../balancerv2basepool/src/lib.rs             |  6635 +++
 .../balancerv2basepoolfactory/Cargo.toml      |    19 +
 .../balancerv2basepoolfactory/src/lib.rs      |   880 +
 .../balancerv2composablestablepool/Cargo.toml |    19 +
 .../balancerv2composablestablepool/src/lib.rs | 16090 ++++++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3590 ++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3594 ++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3602 ++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3606 ++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3606 ++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                | 10993 ++++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  1989 +
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  2052 +
 .../balancerv2stablepool/Cargo.toml           |    19 +
 .../balancerv2stablepool/src/lib.rs           | 10242 ++++
 .../balancerv2stablepoolfactoryv2/Cargo.toml  |    19 +
 .../balancerv2stablepoolfactoryv2/src/lib.rs  |  2854 ++
 .../balancerv2vault/Cargo.toml                |    19 +
 .../balancerv2vault/src/lib.rs                | 11577 +++++
 .../balancerv2weightedpool/Cargo.toml         |    19 +
 .../balancerv2weightedpool/src/lib.rs         |  9215 ++++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  1641 +
 .../balancerv2weightedpoolfactory/Cargo.toml  |    19 +
 .../balancerv2weightedpoolfactory/src/lib.rs  |  1605 +
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3547 ++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3559 ++
 .../balancerv3batchrouter/Cargo.toml          |    19 +
 .../balancerv3batchrouter/src/lib.rs          |  8461 ++++
 .../contracts-generated/balances/Cargo.toml   |    19 +
 .../contracts-generated/balances/src/lib.rs   |  1267 +
 .../baoswaprouter/Cargo.toml                  |    19 +
 .../baoswaprouter/src/lib.rs                  |  7537 +++
 .../chainalysisoracle/Cargo.toml              |    19 +
 .../chainalysisoracle/src/lib.rs              |  2800 ++
 .../contracts-generated/counter/Cargo.toml    |    19 +
 .../contracts-generated/counter/src/lib.rs    |   952 +
 .../contracts-generated/cowamm/Cargo.toml     |    19 +
 .../contracts-generated/cowamm/src/lib.rs     |  6641 +++
 .../cowammconstantproductfactory/Cargo.toml   |    19 +
 .../cowammconstantproductfactory/src/lib.rs   |  4729 ++
 .../cowammfactorygetter/Cargo.toml            |    19 +
 .../cowammfactorygetter/src/lib.rs            |   441 +
 .../cowammlegacyhelper/Cargo.toml             |    19 +
 .../cowammlegacyhelper/src/lib.rs             |  3796 ++
 .../cowammuniswapv2priceoracle/Cargo.toml     |    19 +
 .../cowammuniswapv2priceoracle/src/lib.rs     |   604 +
 .../cowprotocoltoken/Cargo.toml               |    19 +
 .../cowprotocoltoken/src/lib.rs               |  6059 +++
 .../cowsettlementforwarder/Cargo.toml         |    19 +
 .../cowsettlementforwarder/src/lib.rs         |  1419 +
 .../cowswapethflow/Cargo.toml                 |    19 +
 .../cowswapethflow/src/lib.rs                 |  5891 +++
 .../cowswaponchainorders/Cargo.toml           |    19 +
 .../cowswaponchainorders/src/lib.rs           |  1815 +
 .../erc1271signaturevalidator/Cargo.toml      |    19 +
 .../erc1271signaturevalidator/src/lib.rs      |   497 +
 .../contracts-generated/erc20/Cargo.toml      |    19 +
 .../contracts-generated/erc20/src/lib.rs      |  3063 ++
 .../erc20mintable/Cargo.toml                  |    19 +
 .../erc20mintable/src/lib.rs                  |  3565 ++
 .../flashloanrouter/Cargo.toml                |    19 +
 .../flashloanrouter/src/lib.rs                |  1729 +
 .../contracts-generated/gashog/Cargo.toml     |    19 +
 .../contracts-generated/gashog/src/lib.rs     |   784 +
 .../contracts-generated/gnosissafe/Cargo.toml |    19 +
 .../contracts-generated/gnosissafe/src/lib.rs | 10361 ++++
 .../Cargo.toml                                |    19 +
 .../src/lib.rs                                |  3390 ++
 .../gnosissafeproxy/Cargo.toml                |    19 +
 .../gnosissafeproxy/src/lib.rs                |   317 +
 .../gnosissafeproxyfactory/Cargo.toml         |    19 +
 .../gnosissafeproxyfactory/src/lib.rs         |  1975 +
 .../gpv2allowlistauthentication/Cargo.toml    |    19 +
 .../gpv2allowlistauthentication/src/lib.rs    |  2815 ++
 .../gpv2settlement/Cargo.toml                 |    19 +
 .../gpv2settlement/src/lib.rs                 |  6224 +++
 .../honeyswaprouter/Cargo.toml                |    19 +
 .../honeyswaprouter/src/lib.rs                |  7545 +++
 .../hookstrampoline/Cargo.toml                |    19 +
 .../hookstrampoline/src/lib.rs                |  1333 +
 .../icowwrapper/Cargo.toml                    |    19 +
 .../icowwrapper/src/lib.rs                    |   682 +
 .../contracts-generated/iswaprpair/Cargo.toml |    19 +
 .../contracts-generated/iswaprpair/src/lib.rs |  7237 +++
 .../iuniswaplikepair/Cargo.toml               |    19 +
 .../iuniswaplikepair/src/lib.rs               |  6888 +++
 .../iuniswaplikerouter/Cargo.toml             |    19 +
 .../iuniswaplikerouter/src/lib.rs             |  7529 +++
 .../iuniswapv3factory/Cargo.toml              |    19 +
 .../iuniswapv3factory/src/lib.rs              |  2239 +
 .../contracts-generated/izeroex/Cargo.toml    |    19 +
 .../contracts-generated/izeroex/src/lib.rs    | 41951 ++++++++++++++++
 .../liquoricesettlement/Cargo.toml            |    19 +
 .../liquoricesettlement/src/lib.rs            | 13331 +++++
 .../nonstandarderc20balances/Cargo.toml       |    19 +
 .../nonstandarderc20balances/src/lib.rs       |  1643 +
 .../pancakerouter/Cargo.toml                  |    19 +
 .../pancakerouter/src/lib.rs                  |  7549 +++
 .../contracts-generated/permit2/Cargo.toml    |    19 +
 .../contracts-generated/permit2/src/lib.rs    |  7518 +++
 .../remoteerc20balances/Cargo.toml            |    19 +
 .../remoteerc20balances/src/lib.rs            |  1909 +
 .../contracts-generated/signatures/Cargo.toml |    19 +
 .../contracts-generated/signatures/src/lib.rs |  1175 +
 .../contracts-generated/solver/Cargo.toml     |    19 +
 .../contracts-generated/solver/src/lib.rs     |  1146 +
 .../contracts-generated/spardose/Cargo.toml   |    19 +
 .../contracts-generated/spardose/src/lib.rs   |   534 +
 .../sushiswaprouter/Cargo.toml                |    19 +
 .../sushiswaprouter/src/lib.rs                |  7573 +++
 .../contracts-generated/swapper/Cargo.toml    |    19 +
 .../contracts-generated/swapper/src/lib.rs    |  1553 +
 .../swaprrouter/Cargo.toml                    |    19 +
 .../swaprrouter/src/lib.rs                    |  7545 +++
 .../testnetuniswapv2router02/Cargo.toml       |    19 +
 .../testnetuniswapv2router02/src/lib.rs       |  7630 +++
 .../contracts-generated/trader/Cargo.toml     |    19 +
 .../contracts-generated/trader/src/lib.rs     |  1082 +
 .../uniswapv2factory/Cargo.toml               |    19 +
 .../uniswapv2factory/src/lib.rs               |  2320 +
 .../uniswapv2router02/Cargo.toml              |    19 +
 .../uniswapv2router02/src/lib.rs              |  7806 +++
 .../uniswapv3pool/Cargo.toml                  |    19 +
 .../uniswapv3pool/src/lib.rs                  |  8255 +++
 .../uniswapv3quoterv2/Cargo.toml              |    19 +
 .../uniswapv3quoterv2/src/lib.rs              |  2960 ++
 .../uniswapv3swaprouterv2/Cargo.toml          |    19 +
 .../uniswapv3swaprouterv2/src/lib.rs          |  1073 +
 .../contracts-generated/weth9/Cargo.toml      |    19 +
 .../contracts-generated/weth9/src/lib.rs      |  3301 ++
 contracts/generated/rustfmt.toml              |    12 +
 .../script/DeployBalances.s.sol               |     0
 .../script/DeploySignatures.s.sol             |     0
 .../solidity/AnyoneAuthenticator.sol          |     0
 .../solidity/Balances.sol                     |     0
 .../solidity/CowSettlementForwarder.sol       |     0
 .../contracts => contracts}/solidity/Makefile |     2 +-
 .../solidity/README.md                        |     0
 .../solidity/Signatures.sol                   |     0
 .../solidity/Solver.sol                       |     0
 .../solidity/Spardose.sol                     |     0
 .../solidity/Swapper.sol                      |     0
 .../solidity/Trader.sol                       |     0
 .../solidity/interfaces/IERC1271.sol          |     0
 .../solidity/interfaces/IERC20.sol            |     0
 .../solidity/interfaces/ISettlement.sol       |     0
 .../interfaces/IStorageAccessible.sol         |     0
 .../solidity/interfaces/IVault.sol            |     0
 .../solidity/interfaces/IVaultRelayer.sol     |     0
 .../solidity/libraries/Caller.sol             |     0
 .../solidity/libraries/Math.sol               |     0
 .../solidity/libraries/SafeERC20.sol          |     0
 .../solidity/tests/Counter.sol                |     0
 .../solidity/tests/GasHog.sol                 |     0
 .../tests/NonStandardERC20Balances.sol        |     0
 .../solidity/tests/RemoteERC20Balances.sol    |     0
 contracts/src/codegen.rs                      |   487 +
 contracts/src/main.rs                         |   564 +
 contracts/src/networks.rs                     |    13 +
 .../src/bin => contracts/src}/vendor.rs       |    51 +-
 crates/account-balances/src/lib.rs            |     2 +-
 crates/account-balances/src/simulation.rs     |     6 +-
 .../src/boundary/events/settlement.rs         |     2 +-
 .../ethflow_events/event_retriever.rs         |     2 +-
 .../database/ethflow_events/event_storing.rs  |     2 +-
 crates/autopilot/src/database/events.rs       |     2 +-
 .../onchain_order_events/ethflow_events.rs    |     4 +-
 .../onchain_order_events/event_retriever.rs   |     2 +-
 .../src/database/onchain_order_events/mod.rs  |    37 +-
 .../src/domain/settlement/transaction/mod.rs  |     2 +-
 .../settlement/transaction/tokenized.rs       |     2 +-
 .../src/infra/blockchain/contracts.rs         |    10 +-
 crates/autopilot/src/run.rs                   |     2 +-
 crates/bad-tokens/src/trace_call.rs           |     2 +-
 crates/balance-overrides/src/detector.rs      |     2 +-
 crates/contracts/.gitignore                   |     2 -
 crates/contracts/Cargo.toml                   |    42 -
 crates/contracts/README.md                    |    14 -
 ...lancerV2ComposableStablePoolFactoryV3.json |     1 -
 ...lancerV2ComposableStablePoolFactoryV4.json |     1 -
 ...lancerV2ComposableStablePoolFactoryV5.json |     1 -
 ...lancerV2ComposableStablePoolFactoryV6.json |     1 -
 ...lFeeLiquidityBootstrappingPoolFactory.json |     1 -
 .../BalancerV2WeightedPoolFactoryV4.json      |     1 -
 crates/contracts/artifacts/BaoswapRouter.json |     1 -
 .../contracts/artifacts/HoneyswapRouter.json  |     1 -
 crates/contracts/artifacts/PancakeRouter.json |     1 -
 .../contracts/artifacts/SushiSwapRouter.json  |     1 -
 crates/contracts/artifacts/SwaprRouter.json   |     1 -
 .../artifacts/TestnetUniswapV2Router02.json   |     1 -
 crates/contracts/build.rs                     |  1208 -
 crates/contracts/rustfmt.toml                 |     2 -
 crates/contracts/src/lib.rs                   |     5 -
 crates/cow-amm/src/amm.rs                     |     5 +-
 crates/cow-amm/src/cache.rs                   |     2 +-
 crates/cow-amm/src/factory.rs                 |     2 +-
 crates/cow-amm/src/lib.rs                     |     4 +-
 crates/cow-amm/src/maintainers.rs             |     2 +-
 crates/cow-amm/src/registry.rs                |     2 +-
 .../src/boundary/liquidity/balancer/v2/mod.rs |     2 +-
 .../src/boundary/liquidity/uniswap/v2.rs      |     2 +-
 .../driver/src/boundary/liquidity/zeroex.rs   |     2 +-
 .../domain/competition/solution/encoding.rs   |     4 +-
 crates/driver/src/domain/cow_amm.rs           |    11 +-
 crates/driver/src/domain/liquidity/zeroex.rs  |     2 +-
 crates/driver/src/domain/mempools.rs          |     2 +-
 .../driver/src/infra/blockchain/contracts.rs  |    16 +-
 crates/driver/src/infra/blockchain/token.rs   |     4 +-
 crates/driver/src/infra/liquidity/config.rs   |    49 +-
 .../liquidity_sources/liquorice/notifier.rs   |     4 +-
 crates/driver/src/infra/solver/eip7702.rs     |     2 +-
 crates/driver/src/tests/setup/blockchain.rs   |    16 +-
 crates/driver/src/tests/setup/solver.rs       |     2 +-
 crates/e2e/src/setup/deploy.rs                |     7 +-
 .../e2e/src/setup/onchain_components/mod.rs   |     4 +-
 .../e2e/src/setup/onchain_components/safe.rs  |     2 +-
 crates/e2e/tests/e2e/banned_users.rs          |     2 +-
 crates/e2e/tests/e2e/cow_amm.rs               |    47 +-
 crates/e2e/tests/e2e/ethflow.rs               |     2 +-
 crates/e2e/tests/e2e/hooks.rs                 |     6 +-
 crates/e2e/tests/e2e/limit_orders.rs          |     2 +-
 crates/e2e/tests/e2e/liquidity.rs             |     2 +-
 .../e2e/liquidity_source_notification.rs      |     2 +-
 crates/e2e/tests/e2e/parallel_settlement.rs   |     2 +-
 crates/e2e/tests/e2e/quote_verification.rs    |    26 +-
 crates/e2e/tests/e2e/refunder.rs              |     2 +-
 crates/e2e/tests/e2e/smart_contract_orders.rs |     2 +-
 crates/e2e/tests/e2e/univ2.rs                 |     2 +-
 crates/e2e/tests/e2e/wrapper.rs               |     2 +-
 crates/event-indexing/src/event_handler.rs    |     2 +-
 .../src/balancer_v2/pool_fetching/mod.rs      |     2 +-
 .../balancer_v2/pool_fetching/pool_storage.rs |     2 +-
 .../src/balancer_v2/pool_fetching/registry.rs |     2 +-
 .../src/balancer_v2/pools/common.rs           |     4 +-
 .../balancer_v2/pools/composable_stable.rs    |     2 +-
 .../pools/liquidity_bootstrapping.rs          |     2 +-
 .../src/balancer_v2/pools/stable.rs           |     2 +-
 .../src/balancer_v2/pools/weighted.rs         |     2 +-
 crates/liquidity-sources/src/swapr.rs         |     2 +-
 .../liquidity-sources/src/uniswap_v2/mod.rs   |    16 +-
 .../src/uniswap_v2/pool_fetching.rs           |     2 +-
 .../src/uniswap_v3/event_fetching.rs          |     2 +-
 .../src/uniswap_v3/pool_fetching.rs           |     4 +-
 crates/order-validation/src/banned.rs         |     2 +-
 crates/orderbook/src/order_simulator.rs       |     2 +-
 crates/orderbook/src/run.rs                   |     6 +-
 crates/price-estimation/src/factory.rs        |     2 +-
 .../src/trade_verifier/mod.rs                 |     2 +-
 crates/refunder/src/infra/chain.rs            |     2 +-
 crates/refunder/src/infra/database.rs         |     2 +-
 crates/refunder/src/refund_service.rs         |     2 +-
 crates/refunder/src/submitter.rs              |     2 +-
 crates/refunder/src/traits.rs                 |     2 +-
 crates/shared/src/order_validation.rs         |     2 +-
 crates/signature-validator/src/lib.rs         |     4 +-
 crates/signature-validator/src/simulation.rs  |     2 +-
 crates/simulator/src/encoding.rs              |     4 +-
 crates/simulator/src/ethereum/contracts.rs    |     2 +-
 crates/simulator/src/swap_simulator.rs        |     2 +-
 crates/solver/src/interactions/balancer_v2.rs |     5 +-
 crates/solver/src/interactions/erc20.rs       |     2 +-
 crates/solver/src/interactions/uniswap_v2.rs  |     2 +-
 crates/solver/src/interactions/uniswap_v3.rs  |     2 +-
 crates/solver/src/interactions/weth.rs        |     2 +-
 crates/solver/src/interactions/zeroex.rs      |     2 +-
 crates/solver/src/liquidity/balancer_v2.rs    |     2 +-
 crates/solver/src/liquidity/uniswap_v3.rs     |     2 +-
 crates/solver/src/liquidity/zeroex.rs         |     2 +-
 .../src/settlement/settlement_encoder.rs      |     2 +-
 crates/solvers/src/boundary/baseline.rs       |     4 +-
 .../src/boundary/liquidity/concentrated.rs    |     4 +-
 crates/solvers/src/domain/solver/baseline.rs  |     4 +-
 crates/solvers/src/infra/config/dex/file.rs   |     6 +-
 crates/solvers/src/infra/contracts.rs         |     2 +-
 crates/solvers/src/infra/dex/simulator.rs     |     2 +-
 crates/token-info/src/lib.rs                  |     2 +-
 384 files changed, 375175 insertions(+), 1654 deletions(-)
 create mode 100644 contracts/.gitignore
 create mode 100644 contracts/Cargo.lock
 create mode 100644 contracts/Cargo.toml
 rename {crates/contracts => contracts}/LICENSE-APACHE (100%)
 rename {crates/contracts => contracts}/LICENSE-MIT (100%)
 create mode 100644 contracts/README.md
 rename {crates/contracts => contracts}/artifacts/AnyoneAuthenticator.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerQueries.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2Authorizer.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2BasePool.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2BasePoolFactory.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2ComposableStablePool.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2ComposableStablePoolFactory.json (100%)
 create mode 100644 contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
 create mode 100644 contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
 create mode 100644 contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
 create mode 100644 contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
 rename {crates/contracts => contracts}/artifacts/BalancerV2LiquidityBootstrappingPool.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json (100%)
 create mode 100644 contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
 rename {crates/contracts => contracts}/artifacts/BalancerV2StablePool.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2StablePoolFactoryV2.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2Vault.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2WeightedPool.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2WeightedPool2TokensFactory.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2WeightedPoolFactory.json (100%)
 rename {crates/contracts => contracts}/artifacts/BalancerV2WeightedPoolFactoryV3.json (100%)
 create mode 100644 contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
 rename {crates/contracts => contracts}/artifacts/BalancerV3BatchRouter.json (100%)
 rename {crates/contracts => contracts}/artifacts/Balances.json (100%)
 rename crates/contracts/artifacts/IUniswapLikeRouter.json => contracts/artifacts/BaoswapRouter.json (100%)
 rename {crates/contracts => contracts}/artifacts/ChainalysisOracle.json (100%)
 rename {crates/contracts => contracts}/artifacts/CoWSwapEthFlow.json (100%)
 rename {crates/contracts => contracts}/artifacts/CoWSwapOnchainOrders.json (100%)
 rename {crates/contracts => contracts}/artifacts/Counter.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowAmm.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowAmmConstantProductFactory.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowAmmFactoryGetter.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowAmmLegacyHelper.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowAmmUniswapV2PriceOracle.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowProtocolToken.json (100%)
 rename {crates/contracts => contracts}/artifacts/CowSettlementForwarder.json (100%)
 rename {crates/contracts => contracts}/artifacts/ERC1271SignatureValidator.json (100%)
 rename {crates/contracts => contracts}/artifacts/ERC20.json (100%)
 rename {crates/contracts => contracts}/artifacts/ERC20Mintable.json (100%)
 rename {crates/contracts => contracts}/artifacts/FlashLoanRouter.json (100%)
 rename {crates/contracts => contracts}/artifacts/GPv2AllowListAuthentication.json (100%)
 rename {crates/contracts => contracts}/artifacts/GPv2Settlement.json (100%)
 rename {crates/contracts => contracts}/artifacts/GasHog.json (100%)
 rename {crates/contracts => contracts}/artifacts/GnosisSafe.json (100%)
 rename {crates/contracts => contracts}/artifacts/GnosisSafeCompatibilityFallbackHandler.json (100%)
 rename {crates/contracts => contracts}/artifacts/GnosisSafeProxy.json (100%)
 rename {crates/contracts => contracts}/artifacts/GnosisSafeProxyFactory.json (100%)
 create mode 100644 contracts/artifacts/HoneyswapRouter.json
 rename {crates/contracts => contracts}/artifacts/HooksTrampoline.json (100%)
 rename {crates/contracts => contracts}/artifacts/ICowWrapper.json (100%)
 rename {crates/contracts => contracts}/artifacts/ISwaprPair.json (100%)
 rename {crates/contracts => contracts}/artifacts/IUniswapLikePair.json (100%)
 create mode 100644 contracts/artifacts/IUniswapLikeRouter.json
 rename {crates/contracts => contracts}/artifacts/IUniswapV3Factory.json (100%)
 rename {crates/contracts => contracts}/artifacts/IZeroex.json (100%)
 rename {crates/contracts => contracts}/artifacts/LiquoriceSettlement.json (100%)
 rename {crates/contracts => contracts}/artifacts/NonStandardERC20Balances.json (100%)
 create mode 100644 contracts/artifacts/PancakeRouter.json
 rename {crates/contracts => contracts}/artifacts/Permit2.json (100%)
 rename {crates/contracts => contracts}/artifacts/RemoteERC20Balances.json (100%)
 rename {crates/contracts => contracts}/artifacts/Signatures.json (100%)
 rename {crates/contracts => contracts}/artifacts/Solver.json (100%)
 rename {crates/contracts => contracts}/artifacts/Spardose.json (100%)
 create mode 100644 contracts/artifacts/SushiSwapRouter.json
 rename {crates/contracts => contracts}/artifacts/Swapper.json (100%)
 create mode 100644 contracts/artifacts/SwaprRouter.json
 create mode 100644 contracts/artifacts/TestnetUniswapV2Router02.json
 rename {crates/contracts => contracts}/artifacts/Trader.json (100%)
 rename {crates/contracts => contracts}/artifacts/UniswapV2Factory.json (100%)
 rename {crates/contracts => contracts}/artifacts/UniswapV2Router02.json (100%)
 rename {crates/contracts => contracts}/artifacts/UniswapV3Pool.json (100%)
 rename {crates/contracts => contracts}/artifacts/UniswapV3QuoterV2.json (100%)
 rename {crates/contracts => contracts}/artifacts/UniswapV3SwapRouterV2.json (100%)
 rename {crates/contracts => contracts}/artifacts/WETH9.json (100%)
 rename {crates/contracts => contracts}/foundry.toml (100%)
 create mode 100644 contracts/generated/.gitignore
 create mode 100644 contracts/generated/Cargo.lock
 create mode 100644 contracts/generated/Cargo.toml
 create mode 100644 contracts/generated/contracts-facade/Cargo.toml
 create mode 100644 contracts/generated/contracts-facade/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/anyoneauthenticator/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/anyoneauthenticator/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerqueries/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerqueries/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2authorizer/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2basepool/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2basepoolfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepool/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2stablepool/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2vault/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2vault/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpool/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpoolfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balancerv3batchrouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/balances/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/balances/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/baoswaprouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/baoswaprouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/chainalysisoracle/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/counter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/counter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowamm/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowamm/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowammconstantproductfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowammfactorygetter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowammfactorygetter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowammlegacyhelper/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowammuniswapv2priceoracle/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowprotocoltoken/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowsettlementforwarder/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowsettlementforwarder/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowswapethflow/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/cowswaponchainorders/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/cowswaponchainorders/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/erc1271signaturevalidator/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/erc1271signaturevalidator/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/erc20/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/erc20/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/erc20mintable/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/erc20mintable/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/flashloanrouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/flashloanrouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gashog/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gashog/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gnosissafe/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gnosissafe/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gnosissafeproxy/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gnosissafeproxy/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gnosissafeproxyfactory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gpv2allowlistauthentication/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/gpv2settlement/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/honeyswaprouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/hookstrampoline/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/hookstrampoline/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/icowwrapper/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/icowwrapper/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/iswaprpair/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/iswaprpair/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/iuniswaplikepair/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/iuniswaplikerouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/iuniswapv3factory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/izeroex/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/izeroex/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/liquoricesettlement/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/nonstandarderc20balances/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/nonstandarderc20balances/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/pancakerouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/pancakerouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/permit2/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/permit2/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/remoteerc20balances/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/remoteerc20balances/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/signatures/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/signatures/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/solver/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/solver/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/spardose/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/spardose/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/sushiswaprouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/swapper/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/swapper/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/swaprrouter/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/swaprrouter/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/testnetuniswapv2router02/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/trader/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/trader/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/uniswapv2factory/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/uniswapv2router02/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/uniswapv3pool/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/uniswapv3quoterv2/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/uniswapv3swaprouterv2/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/weth9/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/weth9/src/lib.rs
 create mode 100644 contracts/generated/rustfmt.toml
 rename {crates/contracts => contracts}/script/DeployBalances.s.sol (100%)
 rename {crates/contracts => contracts}/script/DeploySignatures.s.sol (100%)
 rename {crates/contracts => contracts}/solidity/AnyoneAuthenticator.sol (100%)
 rename {crates/contracts => contracts}/solidity/Balances.sol (100%)
 rename {crates/contracts => contracts}/solidity/CowSettlementForwarder.sol (100%)
 rename {crates/contracts => contracts}/solidity/Makefile (97%)
 rename {crates/contracts => contracts}/solidity/README.md (100%)
 rename {crates/contracts => contracts}/solidity/Signatures.sol (100%)
 rename {crates/contracts => contracts}/solidity/Solver.sol (100%)
 rename {crates/contracts => contracts}/solidity/Spardose.sol (100%)
 rename {crates/contracts => contracts}/solidity/Swapper.sol (100%)
 rename {crates/contracts => contracts}/solidity/Trader.sol (100%)
 rename {crates/contracts => contracts}/solidity/interfaces/IERC1271.sol (100%)
 rename {crates/contracts => contracts}/solidity/interfaces/IERC20.sol (100%)
 rename {crates/contracts => contracts}/solidity/interfaces/ISettlement.sol (100%)
 rename {crates/contracts => contracts}/solidity/interfaces/IStorageAccessible.sol (100%)
 rename {crates/contracts => contracts}/solidity/interfaces/IVault.sol (100%)
 rename {crates/contracts => contracts}/solidity/interfaces/IVaultRelayer.sol (100%)
 rename {crates/contracts => contracts}/solidity/libraries/Caller.sol (100%)
 rename {crates/contracts => contracts}/solidity/libraries/Math.sol (100%)
 rename {crates/contracts => contracts}/solidity/libraries/SafeERC20.sol (100%)
 rename {crates/contracts => contracts}/solidity/tests/Counter.sol (100%)
 rename {crates/contracts => contracts}/solidity/tests/GasHog.sol (100%)
 rename {crates/contracts => contracts}/solidity/tests/NonStandardERC20Balances.sol (100%)
 rename {crates/contracts => contracts}/solidity/tests/RemoteERC20Balances.sol (100%)
 create mode 100644 contracts/src/codegen.rs
 create mode 100644 contracts/src/main.rs
 create mode 100644 contracts/src/networks.rs
 rename {crates/contracts/src/bin => contracts/src}/vendor.rs (87%)
 delete mode 100644 crates/contracts/.gitignore
 delete mode 100644 crates/contracts/Cargo.toml
 delete mode 100644 crates/contracts/README.md
 delete mode 120000 crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
 delete mode 120000 crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
 delete mode 120000 crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
 delete mode 120000 crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
 delete mode 120000 crates/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
 delete mode 120000 crates/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
 delete mode 120000 crates/contracts/artifacts/BaoswapRouter.json
 delete mode 120000 crates/contracts/artifacts/HoneyswapRouter.json
 delete mode 120000 crates/contracts/artifacts/PancakeRouter.json
 delete mode 120000 crates/contracts/artifacts/SushiSwapRouter.json
 delete mode 120000 crates/contracts/artifacts/SwaprRouter.json
 delete mode 120000 crates/contracts/artifacts/TestnetUniswapV2Router02.json
 delete mode 100644 crates/contracts/build.rs
 delete mode 100644 crates/contracts/rustfmt.toml
 delete mode 100644 crates/contracts/src/lib.rs

diff --git a/.github/workflows/pull-request.yaml b/.github/workflows/pull-request.yaml
index b711a12cee..c5dda4d4c0 100644
--- a/.github/workflows/pull-request.yaml
+++ b/.github/workflows/pull-request.yaml
@@ -234,16 +234,16 @@ jobs:
         with:
           persist-credentials: false
       - name: Build Solidity artifacts
-        working-directory: crates/contracts/solidity
+        working-directory: contracts/solidity
         run: make -B artifacts
       - name: Verify no JSON changes
         run: |
-          if git diff --exit-code -- 'crates/contracts/artifacts/*.json'; then
+          if git diff --exit-code -- 'contracts/artifacts/*.json'; then
             echo "✓ Solidity artifacts are up-to-date"
           else
-            echo "✗ Solidity artifacts are out-of-date. Please run 'cd crates/contracts/solidity && make -B artifacts' and commit the changes."
+            echo "✗ Solidity artifacts are out-of-date. Please run 'cd contracts/solidity && make -B artifacts' and commit the changes."
             # run the command again to show exactly what the changes would be
-            git diff --exit-code -- 'crates/contracts/artifacts/*.json'
+            git diff --exit-code -- 'contracts/artifacts/*.json'
             exit 1
           fi
 
diff --git a/Cargo.lock b/Cargo.lock
index 92d30564cc..89b5c56454 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2486,125 +2486,996 @@ dependencies = [
 [[package]]
 name = "contracts"
 version = "0.1.0"
+dependencies = [
+ "cow-contract-anyoneauthenticator",
+ "cow-contract-balancerqueries",
+ "cow-contract-balancerv2authorizer",
+ "cow-contract-balancerv2basepool",
+ "cow-contract-balancerv2basepoolfactory",
+ "cow-contract-balancerv2composablestablepool",
+ "cow-contract-balancerv2composablestablepoolfactory",
+ "cow-contract-balancerv2composablestablepoolfactoryv3",
+ "cow-contract-balancerv2composablestablepoolfactoryv4",
+ "cow-contract-balancerv2composablestablepoolfactoryv5",
+ "cow-contract-balancerv2composablestablepoolfactoryv6",
+ "cow-contract-balancerv2liquiditybootstrappingpool",
+ "cow-contract-balancerv2liquiditybootstrappingpoolfactory",
+ "cow-contract-balancerv2noprotocolfeeliquiditybootstrappingpoolfactory",
+ "cow-contract-balancerv2stablepool",
+ "cow-contract-balancerv2stablepoolfactoryv2",
+ "cow-contract-balancerv2vault",
+ "cow-contract-balancerv2weightedpool",
+ "cow-contract-balancerv2weightedpool2tokensfactory",
+ "cow-contract-balancerv2weightedpoolfactory",
+ "cow-contract-balancerv2weightedpoolfactoryv3",
+ "cow-contract-balancerv2weightedpoolfactoryv4",
+ "cow-contract-balancerv3batchrouter",
+ "cow-contract-balances",
+ "cow-contract-baoswaprouter",
+ "cow-contract-chainalysisoracle",
+ "cow-contract-counter",
+ "cow-contract-cowamm",
+ "cow-contract-cowammconstantproductfactory",
+ "cow-contract-cowammfactorygetter",
+ "cow-contract-cowammlegacyhelper",
+ "cow-contract-cowammuniswapv2priceoracle",
+ "cow-contract-cowprotocoltoken",
+ "cow-contract-cowsettlementforwarder",
+ "cow-contract-cowswapethflow",
+ "cow-contract-cowswaponchainorders",
+ "cow-contract-erc1271signaturevalidator",
+ "cow-contract-erc20",
+ "cow-contract-erc20mintable",
+ "cow-contract-flashloanrouter",
+ "cow-contract-gashog",
+ "cow-contract-gnosissafe",
+ "cow-contract-gnosissafecompatibilityfallbackhandler",
+ "cow-contract-gnosissafeproxy",
+ "cow-contract-gnosissafeproxyfactory",
+ "cow-contract-gpv2allowlistauthentication",
+ "cow-contract-gpv2settlement",
+ "cow-contract-honeyswaprouter",
+ "cow-contract-hookstrampoline",
+ "cow-contract-icowwrapper",
+ "cow-contract-iswaprpair",
+ "cow-contract-iuniswaplikepair",
+ "cow-contract-iuniswaplikerouter",
+ "cow-contract-iuniswapv3factory",
+ "cow-contract-izeroex",
+ "cow-contract-liquoricesettlement",
+ "cow-contract-nonstandarderc20balances",
+ "cow-contract-pancakerouter",
+ "cow-contract-permit2",
+ "cow-contract-remoteerc20balances",
+ "cow-contract-signatures",
+ "cow-contract-solver",
+ "cow-contract-spardose",
+ "cow-contract-sushiswaprouter",
+ "cow-contract-swapper",
+ "cow-contract-swaprrouter",
+ "cow-contract-testnetuniswapv2router02",
+ "cow-contract-trader",
+ "cow-contract-uniswapv2factory",
+ "cow-contract-uniswapv2router02",
+ "cow-contract-uniswapv3pool",
+ "cow-contract-uniswapv3quoterv2",
+ "cow-contract-uniswapv3swaprouterv2",
+ "cow-contract-weth9",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "percent-encoding",
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "cookie_store"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b2c103cf610ec6cae3da84a766285b42fd16aad564758459e6ecf128c75206"
+dependencies = [
+ "cookie",
+ "document-features",
+ "idna",
+ "log",
+ "publicsuffix",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "time",
+ "url",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cow-amm"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types",
+ "alloy-sol-types",
+ "anyhow",
+ "app-data",
+ "async-trait",
+ "const-hex",
+ "contracts",
+ "database",
+ "ethrpc",
+ "event-indexing",
+ "futures",
+ "model",
+ "observe",
+ "prometheus",
+ "prometheus-metric-storage",
+ "signature-validator",
+ "sqlx",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "cow-contract-anyoneauthenticator"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerqueries"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2authorizer"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2basepool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2basepoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv3"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv4"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv5"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv6"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2liquiditybootstrappingpool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2liquiditybootstrappingpoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2noprotocolfeeliquiditybootstrappingpoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2stablepool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2stablepoolfactoryv2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2vault"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpool2tokensfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpoolfactoryv3"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpoolfactoryv4"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv3batchrouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balances"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-baoswaprouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-chainalysisoracle"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-counter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowamm"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammconstantproductfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammfactorygetter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammlegacyhelper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammuniswapv2priceoracle"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowprotocoltoken"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowsettlementforwarder"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowswapethflow"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowswaponchainorders"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-erc1271signaturevalidator"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-erc20"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-erc20mintable"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-flashloanrouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gashog"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafe"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafecompatibilityfallbackhandler"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafeproxy"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafeproxyfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gpv2allowlistauthentication"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gpv2settlement"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-honeyswaprouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-hookstrampoline"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-icowwrapper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iswaprpair"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iuniswaplikepair"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iuniswaplikerouter"
+version = "0.1.0"
 dependencies = [
  "alloy-contract",
  "alloy-primitives",
  "alloy-provider",
- "alloy-sol-macro-expander",
- "alloy-sol-macro-input",
  "alloy-sol-types",
  "anyhow",
- "paste",
- "prettyplease",
- "proc-macro2",
- "quote",
- "reqwest 0.13.2",
- "serde",
- "serde_json",
- "syn 2.0.114",
- "tracing",
- "tracing-subscriber",
 ]
 
 [[package]]
-name = "convert_case"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+name = "cow-contract-iuniswapv3factory"
+version = "0.1.0"
 dependencies = [
- "unicode-segmentation",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
 ]
 
 [[package]]
-name = "convert_case"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+name = "cow-contract-izeroex"
+version = "0.1.0"
 dependencies = [
- "unicode-segmentation",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
 ]
 
 [[package]]
-name = "cookie"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+name = "cow-contract-liquoricesettlement"
+version = "0.1.0"
 dependencies = [
- "percent-encoding",
- "time",
- "version_check",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
 ]
 
 [[package]]
-name = "cookie_store"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15b2c103cf610ec6cae3da84a766285b42fd16aad564758459e6ecf128c75206"
+name = "cow-contract-nonstandarderc20balances"
+version = "0.1.0"
 dependencies = [
- "cookie",
- "document-features",
- "idna",
- "log",
- "publicsuffix",
- "serde",
- "serde_derive",
- "serde_json",
- "time",
- "url",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
 ]
 
 [[package]]
-name = "core-foundation"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+name = "cow-contract-pancakerouter"
+version = "0.1.0"
 dependencies = [
- "core-foundation-sys",
- "libc",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
 ]
 
 [[package]]
-name = "core-foundation"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+name = "cow-contract-permit2"
+version = "0.1.0"
 dependencies = [
- "core-foundation-sys",
- "libc",
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
 ]
 
 [[package]]
-name = "core-foundation-sys"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+name = "cow-contract-remoteerc20balances"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
 
 [[package]]
-name = "cow-amm"
+name = "cow-contract-signatures"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-solver"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-spardose"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-sushiswaprouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-swapper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-swaprrouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-testnetuniswapv2router02"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-trader"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv2factory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv2router02"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv3pool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv3quoterv2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv3swaprouterv2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-weth9"
 version = "0.1.0"
 dependencies = [
  "alloy-contract",
  "alloy-primitives",
  "alloy-provider",
- "alloy-rpc-types",
  "alloy-sol-types",
  "anyhow",
- "app-data",
- "async-trait",
- "const-hex",
- "contracts",
- "database",
- "ethrpc",
- "event-indexing",
- "futures",
- "model",
- "observe",
- "prometheus",
- "prometheus-metric-storage",
- "signature-validator",
- "sqlx",
- "tokio",
- "tracing",
 ]
 
 [[package]]
@@ -4366,9 +5237,9 @@ dependencies = [
 
 [[package]]
 name = "keccak"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
 dependencies = [
  "cpufeatures",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 9c31ae436b..ece4f4e931 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "3"
 members = ["crates/*"]
+exclude = ["contracts/"]
 
 [workspace.dependencies]
 account-balances = { path = "crates/account-balances" }
@@ -20,8 +21,6 @@ alloy-rpc-types-eth = { version = "1.7.3", default-features = false }
 alloy-rpc-types-trace = { version = "1.7.3", default-features = false }
 alloy-signer = { version = "1.7.3", default-features = false }
 alloy-signer-local = { version = "1.7.3", default-features = false }
-alloy-sol-macro-expander = "1.4.1"
-alloy-sol-macro-input = "1.4.1"
 alloy-sol-types = { version = "1.5.2" }
 alloy-transport = { version = "1.7.3", default-features = false }
 alloy-transport-ws = { version = "1.7.3", default-features = false }
@@ -49,7 +48,7 @@ configs = { path = "crates/configs/" }
 console-subscriber = "0.3.0"
 const_format = "0.2.32"
 const-hex = "1.17.0"
-contracts = { path = "crates/contracts" }
+contracts = { path = "contracts/generated/contracts-facade" }
 cow-amm = { path = "crates/cow-amm" }
 dashmap = "6.1.0"
 database = { path = "crates/database" }
diff --git a/Justfile b/Justfile
index 6bf98a1e48..1cebc4e575 100644
--- a/Justfile
+++ b/Justfile
@@ -1,6 +1,21 @@
 help:
     @just --list
 
+# Bootstrap the crate, will vendor contracts, generate the bindings crates and format everything
+setup:
+    cd contracts && \
+    cargo r -r -- vendor && \
+    cargo r -r -- generate && \
+    cargo +nightly fmt --all && \
+    cd generated && cargo +nightly fmt --all && \
+    cd ../.. && \
+    tombi format
+
+# Generate contract bindings
+generate-contracts:
+    cd contracts && \
+    cargo r -r -- generate
+
 # Run unit tests
 test-unit:
     cargo nextest run
@@ -35,6 +50,7 @@ clippy:
 # Format the repository
 fmt *extra:
     cargo +nightly fmt --all -- {{extra}}
+    cd contracts && cargo +nightly fmt --all -- {{extra}}
 
 # Format .toml files in the repository
 fmt-toml *extra:
diff --git a/contracts/.gitignore b/contracts/.gitignore
new file mode 100644
index 0000000000..05923927ff
--- /dev/null
+++ b/contracts/.gitignore
@@ -0,0 +1,2 @@
+/target
+.DS_Store
diff --git a/contracts/Cargo.lock b/contracts/Cargo.lock
new file mode 100644
index 0000000000..26c94d60d8
--- /dev/null
+++ b/contracts/Cargo.lock
@@ -0,0 +1,2302 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "alloy-json-abi"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9dbe713da0c737d9e5e387b0ba790eb98b14dd207fe53eef50e19a5a8ec3dac"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "alloy-primitives"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3b431b4e72cd8bd0ec7a50b4be18e73dab74de0dba180eef171055e5d5926e"
+dependencies = [
+ "bytes",
+ "cfg-if",
+ "const-hex",
+ "derive_more",
+ "hashbrown",
+ "indexmap",
+ "itoa",
+ "paste",
+ "rand 0.9.2",
+ "ruint",
+ "rustc-hash",
+ "serde",
+ "sha3",
+]
+
+[[package]]
+name = "alloy-sol-macro-expander"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "489f1620bb7e2483fb5819ed01ab6edc1d2f93939dce35a5695085a1afd1d699"
+dependencies = [
+ "alloy-sol-macro-input",
+ "const-hex",
+ "heck",
+ "indexmap",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "sha3",
+ "syn",
+ "syn-solidity",
+]
+
+[[package]]
+name = "alloy-sol-macro-input"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56cef806ad22d4392c5fc83cf8f2089f988eb99c7067b4e0c6f1971fc1cca318"
+dependencies = [
+ "alloy-json-abi",
+ "const-hex",
+ "dunce",
+ "heck",
+ "macro-string",
+ "proc-macro2",
+ "quote",
+ "serde_json",
+ "syn",
+ "syn-solidity",
+]
+
+[[package]]
+name = "alloy-sol-type-parser"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6df77fea9d6a2a75c0ef8d2acbdfd92286cc599983d3175ccdc170d3433d249"
+dependencies = [
+ "serde",
+ "winnow",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
+dependencies = [
+ "aws-lc-sys",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.39.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7a4d3ec6524d28a329fc53654bbadc9bdd7b0431f5d65f1a56ffb28a1ee5283"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "cmake"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "const-hex"
+version = "1.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "531185e432bb31db1ecda541e9e7ab21468d4d844ad7505e0546a49b4945d49b"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "proptest",
+ "serde_core",
+]
+
+[[package]]
+name = "contracts-generate"
+version = "0.1.0"
+dependencies = [
+ "alloy-sol-macro-expander",
+ "alloy-sol-macro-input",
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "rayon",
+ "reqwest",
+ "serde_json",
+ "syn",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+ "unicode-xid",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "foldhash",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hyper"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+dependencies = [
+ "http",
+ "hyper",
+ "hyper-util",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "system-configuration",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "windows-registry",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45a8a2b9cb3e0b0c1803dbb0758ffac5de2f425b23c28f518faabd9d805342ff"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
+[[package]]
+name = "iri-string"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e04e2ef80ce82e13552136fabeef8a5ed1f985a96805761cbb9a2c34e7664d9"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.184"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "macro-string"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "proptest"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
+dependencies = [
+ "bitflags",
+ "num-traits",
+ "rand 0.9.2",
+ "rand_chacha",
+ "rand_xorshift",
+ "unarray",
+]
+
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
+dependencies = [
+ "aws-lc-rs",
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand 0.9.2",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core 0.9.5",
+ "serde",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+ "serde",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+dependencies = [
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64",
+ "bytes",
+ "encoding_rs",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "ruint"
+version = "1.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c141e807189ad38a07276942c6623032d3753c8859c146104ac2e4d68865945a"
+dependencies = [
+ "proptest",
+ "rand 0.8.5",
+ "rand 0.9.2",
+ "ruint-macro",
+ "serde_core",
+ "valuable",
+ "zeroize",
+]
+
+[[package]]
+name = "ruint-macro"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
+dependencies = [
+ "aws-lc-rs",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest",
+ "keccak",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn-solidity"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53f425ae0b12e2f5ae65542e00898d500d4d318b4baf09f40fd0d410454e9947"
+dependencies = [
+ "paste",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.51.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f66bf9585cda4b724d3e78ab34b73fb2bbaba9011b9bfdf69dc836382ea13b8c"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "socket2",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03623de6905b7206edd0a75f69f747f134b7f0a2323392d664448bf2d3c5d87e"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd70027e39b12f0849461e08ffc50b9cd7688d942c1c8e3c7b22273236b4dd0a"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/contracts/Cargo.toml b/contracts/Cargo.toml
new file mode 100644
index 0000000000..1276ea0e99
--- /dev/null
+++ b/contracts/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "contracts-generate"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[workspace]
+
+[dependencies]
+alloy-sol-macro-expander = "1.4.1"
+alloy-sol-macro-input = { version = "1.4.1", features = ["json"] }
+anyhow = "1.0.100"
+prettyplease = "0.2.37"
+proc-macro2 = "1.0.103"
+quote = "1.0.41"
+rayon = "1"
+reqwest = { version = "0.13", features = ["blocking", "json"] }
+serde_json = "1.0.117"
+syn = "2.0.108"
diff --git a/crates/contracts/LICENSE-APACHE b/contracts/LICENSE-APACHE
similarity index 100%
rename from crates/contracts/LICENSE-APACHE
rename to contracts/LICENSE-APACHE
diff --git a/crates/contracts/LICENSE-MIT b/contracts/LICENSE-MIT
similarity index 100%
rename from crates/contracts/LICENSE-MIT
rename to contracts/LICENSE-MIT
diff --git a/contracts/README.md b/contracts/README.md
new file mode 100644
index 0000000000..e40fd74958
--- /dev/null
+++ b/contracts/README.md
@@ -0,0 +1,60 @@
+# cow-contracts
+
+Alloy-based Rust contract bindings for the CoW Protocol ecosystem.
+
+Each smart contract gets its own crate for parallel compilation. The `contracts` facade crate re-exports everything under a single API.
+
+## Usage
+
+Add to your `Cargo.toml`:
+
+```toml
+contracts = { git = "https://github.com/cowprotocol/cow-contracts" }
+```
+
+Then use:
+
+```rust
+use contracts::alloy::{GPv2Settlement, ERC20, WETH9};
+```
+
+## Adding a new contract
+
+1. Add the ABI artifact JSON to `artifacts/` (manually or via `cargo run -p contracts-generate -- vendor`)
+2. Add the contract definition to `crates/contracts-generate/src/main.rs`
+3. Run `cargo run -p contracts-generate`
+4. Run `cargo check -p contracts` to verify
+5. Commit and open a PR
+
+## Commands
+
+From the repository root, use `just`:
+
+```bash
+just setup                # Vendor artifacts, generate bindings, and format everything
+just generate-contracts   # Generate bindings from artifacts only
+```
+
+Or use the `contracts-generate` binary directly:
+
+```bash
+cargo run -p contracts-generate              # Generate bindings from artifacts
+cargo run -p contracts-generate -- vendor    # Download/update ABI artifacts
+cargo run -p contracts-generate -- all       # Vendor artifacts then generate bindings
+```
+
+The `generate` command regenerates all per-contract crates in `generated/`, updates the facade module at `crates/contracts/src/alloy/mod.rs`, and updates the dependency section in `crates/contracts/Cargo.toml`.
+
+## Compiling Solidity contracts
+
+Custom support/test contracts live in `solidity/`. To recompile:
+
+```bash
+cd solidity && make artifacts
+```
+
+Requires Docker with the `ethereum/solc:0.8.30` image.
+
+## License
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or [MIT license](LICENSE-MIT) at your option.
diff --git a/crates/contracts/artifacts/AnyoneAuthenticator.json b/contracts/artifacts/AnyoneAuthenticator.json
similarity index 100%
rename from crates/contracts/artifacts/AnyoneAuthenticator.json
rename to contracts/artifacts/AnyoneAuthenticator.json
diff --git a/crates/contracts/artifacts/BalancerQueries.json b/contracts/artifacts/BalancerQueries.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerQueries.json
rename to contracts/artifacts/BalancerQueries.json
diff --git a/crates/contracts/artifacts/BalancerV2Authorizer.json b/contracts/artifacts/BalancerV2Authorizer.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2Authorizer.json
rename to contracts/artifacts/BalancerV2Authorizer.json
diff --git a/crates/contracts/artifacts/BalancerV2BasePool.json b/contracts/artifacts/BalancerV2BasePool.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2BasePool.json
rename to contracts/artifacts/BalancerV2BasePool.json
diff --git a/crates/contracts/artifacts/BalancerV2BasePoolFactory.json b/contracts/artifacts/BalancerV2BasePoolFactory.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2BasePoolFactory.json
rename to contracts/artifacts/BalancerV2BasePoolFactory.json
diff --git a/crates/contracts/artifacts/BalancerV2ComposableStablePool.json b/contracts/artifacts/BalancerV2ComposableStablePool.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2ComposableStablePool.json
rename to contracts/artifacts/BalancerV2ComposableStablePool.json
diff --git a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json
rename to contracts/artifacts/BalancerV2ComposableStablePoolFactory.json
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
new file mode 100644
index 0000000000..699b15575d
--- /dev/null
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
@@ -0,0 +1,280 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "vault",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "protocolFeeProvider",
+          "type": "address"
+        },
+        {
+          "internalType": "string",
+          "name": "factoryVersion",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "poolVersion",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [],
+      "name": "FactoryDisabled",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "PoolCreated",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "symbol",
+          "type": "string"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amplificationParameter",
+          "type": "uint256"
+        },
+        {
+          "internalType": "contract IRateProvider[]",
+          "name": "rateProviders",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "tokenRateCacheDurations",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "exemptFromYieldProtocolFeeFlags",
+          "type": "bool[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "swapFeePercentage",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "create",
+      "outputs": [
+        {
+          "internalType": "contract ComposableStablePool",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "disable",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getAuthorizer",
+      "outputs": [
+        {
+          "internalType": "contract IAuthorizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCode",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCodeContracts",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "contractA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "contractB",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPauseConfiguration",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowDuration",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodDuration",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolVersion",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getProtocolFeePercentagesProvider",
+      "outputs": [
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isDisabled",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "isPoolFromFactory",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
new file mode 100644
index 0000000000..699b15575d
--- /dev/null
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
@@ -0,0 +1,280 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "vault",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "protocolFeeProvider",
+          "type": "address"
+        },
+        {
+          "internalType": "string",
+          "name": "factoryVersion",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "poolVersion",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [],
+      "name": "FactoryDisabled",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "PoolCreated",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "symbol",
+          "type": "string"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amplificationParameter",
+          "type": "uint256"
+        },
+        {
+          "internalType": "contract IRateProvider[]",
+          "name": "rateProviders",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "tokenRateCacheDurations",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "exemptFromYieldProtocolFeeFlags",
+          "type": "bool[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "swapFeePercentage",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "create",
+      "outputs": [
+        {
+          "internalType": "contract ComposableStablePool",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "disable",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getAuthorizer",
+      "outputs": [
+        {
+          "internalType": "contract IAuthorizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCode",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCodeContracts",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "contractA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "contractB",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPauseConfiguration",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowDuration",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodDuration",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolVersion",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getProtocolFeePercentagesProvider",
+      "outputs": [
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isDisabled",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "isPoolFromFactory",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
new file mode 100644
index 0000000000..699b15575d
--- /dev/null
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
@@ -0,0 +1,280 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "vault",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "protocolFeeProvider",
+          "type": "address"
+        },
+        {
+          "internalType": "string",
+          "name": "factoryVersion",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "poolVersion",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [],
+      "name": "FactoryDisabled",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "PoolCreated",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "symbol",
+          "type": "string"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amplificationParameter",
+          "type": "uint256"
+        },
+        {
+          "internalType": "contract IRateProvider[]",
+          "name": "rateProviders",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "tokenRateCacheDurations",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "exemptFromYieldProtocolFeeFlags",
+          "type": "bool[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "swapFeePercentage",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "create",
+      "outputs": [
+        {
+          "internalType": "contract ComposableStablePool",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "disable",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getAuthorizer",
+      "outputs": [
+        {
+          "internalType": "contract IAuthorizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCode",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCodeContracts",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "contractA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "contractB",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPauseConfiguration",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowDuration",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodDuration",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolVersion",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getProtocolFeePercentagesProvider",
+      "outputs": [
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isDisabled",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "isPoolFromFactory",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
new file mode 100644
index 0000000000..699b15575d
--- /dev/null
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
@@ -0,0 +1,280 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "vault",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "protocolFeeProvider",
+          "type": "address"
+        },
+        {
+          "internalType": "string",
+          "name": "factoryVersion",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "poolVersion",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [],
+      "name": "FactoryDisabled",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "PoolCreated",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "symbol",
+          "type": "string"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amplificationParameter",
+          "type": "uint256"
+        },
+        {
+          "internalType": "contract IRateProvider[]",
+          "name": "rateProviders",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "tokenRateCacheDurations",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "exemptFromYieldProtocolFeeFlags",
+          "type": "bool[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "swapFeePercentage",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "create",
+      "outputs": [
+        {
+          "internalType": "contract ComposableStablePool",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "disable",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getAuthorizer",
+      "outputs": [
+        {
+          "internalType": "contract IAuthorizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCode",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCodeContracts",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "contractA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "contractB",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPauseConfiguration",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowDuration",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodDuration",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolVersion",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getProtocolFeePercentagesProvider",
+      "outputs": [
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isDisabled",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "isPoolFromFactory",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json b/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json
rename to contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json
diff --git a/crates/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json b/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json
rename to contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json
diff --git a/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json b/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
new file mode 100644
index 0000000000..91bf462796
--- /dev/null
+++ b/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
@@ -0,0 +1,158 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "vault",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "PoolCreated",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "symbol",
+          "type": "string"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "weights",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "swapFeePercentage",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "internalType": "bool",
+          "name": "swapEnabledOnStart",
+          "type": "bool"
+        }
+      ],
+      "name": "create",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCode",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCodeContracts",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "contractA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "contractB",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPauseConfiguration",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowDuration",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodDuration",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "isPoolFromFactory",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2StablePool.json b/contracts/artifacts/BalancerV2StablePool.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2StablePool.json
rename to contracts/artifacts/BalancerV2StablePool.json
diff --git a/crates/contracts/artifacts/BalancerV2StablePoolFactoryV2.json b/contracts/artifacts/BalancerV2StablePoolFactoryV2.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2StablePoolFactoryV2.json
rename to contracts/artifacts/BalancerV2StablePoolFactoryV2.json
diff --git a/crates/contracts/artifacts/BalancerV2Vault.json b/contracts/artifacts/BalancerV2Vault.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2Vault.json
rename to contracts/artifacts/BalancerV2Vault.json
diff --git a/crates/contracts/artifacts/BalancerV2WeightedPool.json b/contracts/artifacts/BalancerV2WeightedPool.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2WeightedPool.json
rename to contracts/artifacts/BalancerV2WeightedPool.json
diff --git a/crates/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json b/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json
rename to contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json
diff --git a/crates/contracts/artifacts/BalancerV2WeightedPoolFactory.json b/contracts/artifacts/BalancerV2WeightedPoolFactory.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2WeightedPoolFactory.json
rename to contracts/artifacts/BalancerV2WeightedPoolFactory.json
diff --git a/crates/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json b/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json
rename to contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json
diff --git a/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json b/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
new file mode 100644
index 0000000000..17bfe6a1b4
--- /dev/null
+++ b/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
@@ -0,0 +1,270 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "vault",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "protocolFeeProvider",
+          "type": "address"
+        },
+        {
+          "internalType": "string",
+          "name": "factoryVersion",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "poolVersion",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "anonymous": false,
+      "inputs": [],
+      "name": "FactoryDisabled",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "PoolCreated",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "internalType": "string",
+          "name": "symbol",
+          "type": "string"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "normalizedWeights",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "contract IRateProvider[]",
+          "name": "rateProviders",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "swapFeePercentage",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "create",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "disable",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getAuthorizer",
+      "outputs": [
+        {
+          "internalType": "contract IAuthorizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCode",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getCreationCodeContracts",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "contractA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "contractB",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPauseConfiguration",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowDuration",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodDuration",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolVersion",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getProtocolFeePercentagesProvider",
+      "outputs": [
+        {
+          "internalType": "contract IProtocolFeePercentagesProvider",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isDisabled",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "pool",
+          "type": "address"
+        }
+      ],
+      "name": "isPoolFromFactory",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
diff --git a/crates/contracts/artifacts/BalancerV3BatchRouter.json b/contracts/artifacts/BalancerV3BatchRouter.json
similarity index 100%
rename from crates/contracts/artifacts/BalancerV3BatchRouter.json
rename to contracts/artifacts/BalancerV3BatchRouter.json
diff --git a/crates/contracts/artifacts/Balances.json b/contracts/artifacts/Balances.json
similarity index 100%
rename from crates/contracts/artifacts/Balances.json
rename to contracts/artifacts/Balances.json
diff --git a/crates/contracts/artifacts/IUniswapLikeRouter.json b/contracts/artifacts/BaoswapRouter.json
similarity index 100%
rename from crates/contracts/artifacts/IUniswapLikeRouter.json
rename to contracts/artifacts/BaoswapRouter.json
diff --git a/crates/contracts/artifacts/ChainalysisOracle.json b/contracts/artifacts/ChainalysisOracle.json
similarity index 100%
rename from crates/contracts/artifacts/ChainalysisOracle.json
rename to contracts/artifacts/ChainalysisOracle.json
diff --git a/crates/contracts/artifacts/CoWSwapEthFlow.json b/contracts/artifacts/CoWSwapEthFlow.json
similarity index 100%
rename from crates/contracts/artifacts/CoWSwapEthFlow.json
rename to contracts/artifacts/CoWSwapEthFlow.json
diff --git a/crates/contracts/artifacts/CoWSwapOnchainOrders.json b/contracts/artifacts/CoWSwapOnchainOrders.json
similarity index 100%
rename from crates/contracts/artifacts/CoWSwapOnchainOrders.json
rename to contracts/artifacts/CoWSwapOnchainOrders.json
diff --git a/crates/contracts/artifacts/Counter.json b/contracts/artifacts/Counter.json
similarity index 100%
rename from crates/contracts/artifacts/Counter.json
rename to contracts/artifacts/Counter.json
diff --git a/crates/contracts/artifacts/CowAmm.json b/contracts/artifacts/CowAmm.json
similarity index 100%
rename from crates/contracts/artifacts/CowAmm.json
rename to contracts/artifacts/CowAmm.json
diff --git a/crates/contracts/artifacts/CowAmmConstantProductFactory.json b/contracts/artifacts/CowAmmConstantProductFactory.json
similarity index 100%
rename from crates/contracts/artifacts/CowAmmConstantProductFactory.json
rename to contracts/artifacts/CowAmmConstantProductFactory.json
diff --git a/crates/contracts/artifacts/CowAmmFactoryGetter.json b/contracts/artifacts/CowAmmFactoryGetter.json
similarity index 100%
rename from crates/contracts/artifacts/CowAmmFactoryGetter.json
rename to contracts/artifacts/CowAmmFactoryGetter.json
diff --git a/crates/contracts/artifacts/CowAmmLegacyHelper.json b/contracts/artifacts/CowAmmLegacyHelper.json
similarity index 100%
rename from crates/contracts/artifacts/CowAmmLegacyHelper.json
rename to contracts/artifacts/CowAmmLegacyHelper.json
diff --git a/crates/contracts/artifacts/CowAmmUniswapV2PriceOracle.json b/contracts/artifacts/CowAmmUniswapV2PriceOracle.json
similarity index 100%
rename from crates/contracts/artifacts/CowAmmUniswapV2PriceOracle.json
rename to contracts/artifacts/CowAmmUniswapV2PriceOracle.json
diff --git a/crates/contracts/artifacts/CowProtocolToken.json b/contracts/artifacts/CowProtocolToken.json
similarity index 100%
rename from crates/contracts/artifacts/CowProtocolToken.json
rename to contracts/artifacts/CowProtocolToken.json
diff --git a/crates/contracts/artifacts/CowSettlementForwarder.json b/contracts/artifacts/CowSettlementForwarder.json
similarity index 100%
rename from crates/contracts/artifacts/CowSettlementForwarder.json
rename to contracts/artifacts/CowSettlementForwarder.json
diff --git a/crates/contracts/artifacts/ERC1271SignatureValidator.json b/contracts/artifacts/ERC1271SignatureValidator.json
similarity index 100%
rename from crates/contracts/artifacts/ERC1271SignatureValidator.json
rename to contracts/artifacts/ERC1271SignatureValidator.json
diff --git a/crates/contracts/artifacts/ERC20.json b/contracts/artifacts/ERC20.json
similarity index 100%
rename from crates/contracts/artifacts/ERC20.json
rename to contracts/artifacts/ERC20.json
diff --git a/crates/contracts/artifacts/ERC20Mintable.json b/contracts/artifacts/ERC20Mintable.json
similarity index 100%
rename from crates/contracts/artifacts/ERC20Mintable.json
rename to contracts/artifacts/ERC20Mintable.json
diff --git a/crates/contracts/artifacts/FlashLoanRouter.json b/contracts/artifacts/FlashLoanRouter.json
similarity index 100%
rename from crates/contracts/artifacts/FlashLoanRouter.json
rename to contracts/artifacts/FlashLoanRouter.json
diff --git a/crates/contracts/artifacts/GPv2AllowListAuthentication.json b/contracts/artifacts/GPv2AllowListAuthentication.json
similarity index 100%
rename from crates/contracts/artifacts/GPv2AllowListAuthentication.json
rename to contracts/artifacts/GPv2AllowListAuthentication.json
diff --git a/crates/contracts/artifacts/GPv2Settlement.json b/contracts/artifacts/GPv2Settlement.json
similarity index 100%
rename from crates/contracts/artifacts/GPv2Settlement.json
rename to contracts/artifacts/GPv2Settlement.json
diff --git a/crates/contracts/artifacts/GasHog.json b/contracts/artifacts/GasHog.json
similarity index 100%
rename from crates/contracts/artifacts/GasHog.json
rename to contracts/artifacts/GasHog.json
diff --git a/crates/contracts/artifacts/GnosisSafe.json b/contracts/artifacts/GnosisSafe.json
similarity index 100%
rename from crates/contracts/artifacts/GnosisSafe.json
rename to contracts/artifacts/GnosisSafe.json
diff --git a/crates/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json b/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json
similarity index 100%
rename from crates/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json
rename to contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json
diff --git a/crates/contracts/artifacts/GnosisSafeProxy.json b/contracts/artifacts/GnosisSafeProxy.json
similarity index 100%
rename from crates/contracts/artifacts/GnosisSafeProxy.json
rename to contracts/artifacts/GnosisSafeProxy.json
diff --git a/crates/contracts/artifacts/GnosisSafeProxyFactory.json b/contracts/artifacts/GnosisSafeProxyFactory.json
similarity index 100%
rename from crates/contracts/artifacts/GnosisSafeProxyFactory.json
rename to contracts/artifacts/GnosisSafeProxyFactory.json
diff --git a/contracts/artifacts/HoneyswapRouter.json b/contracts/artifacts/HoneyswapRouter.json
new file mode 100644
index 0000000000..1ee16c02cc
--- /dev/null
+++ b/contracts/artifacts/HoneyswapRouter.json
@@ -0,0 +1,955 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "WETH",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountADesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountIn",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountOut",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsIn",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsOut",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapETHForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/HooksTrampoline.json b/contracts/artifacts/HooksTrampoline.json
similarity index 100%
rename from crates/contracts/artifacts/HooksTrampoline.json
rename to contracts/artifacts/HooksTrampoline.json
diff --git a/crates/contracts/artifacts/ICowWrapper.json b/contracts/artifacts/ICowWrapper.json
similarity index 100%
rename from crates/contracts/artifacts/ICowWrapper.json
rename to contracts/artifacts/ICowWrapper.json
diff --git a/crates/contracts/artifacts/ISwaprPair.json b/contracts/artifacts/ISwaprPair.json
similarity index 100%
rename from crates/contracts/artifacts/ISwaprPair.json
rename to contracts/artifacts/ISwaprPair.json
diff --git a/crates/contracts/artifacts/IUniswapLikePair.json b/contracts/artifacts/IUniswapLikePair.json
similarity index 100%
rename from crates/contracts/artifacts/IUniswapLikePair.json
rename to contracts/artifacts/IUniswapLikePair.json
diff --git a/contracts/artifacts/IUniswapLikeRouter.json b/contracts/artifacts/IUniswapLikeRouter.json
new file mode 100644
index 0000000000..1ee16c02cc
--- /dev/null
+++ b/contracts/artifacts/IUniswapLikeRouter.json
@@ -0,0 +1,955 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "WETH",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountADesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountIn",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountOut",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsIn",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsOut",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapETHForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/IUniswapV3Factory.json b/contracts/artifacts/IUniswapV3Factory.json
similarity index 100%
rename from crates/contracts/artifacts/IUniswapV3Factory.json
rename to contracts/artifacts/IUniswapV3Factory.json
diff --git a/crates/contracts/artifacts/IZeroex.json b/contracts/artifacts/IZeroex.json
similarity index 100%
rename from crates/contracts/artifacts/IZeroex.json
rename to contracts/artifacts/IZeroex.json
diff --git a/crates/contracts/artifacts/LiquoriceSettlement.json b/contracts/artifacts/LiquoriceSettlement.json
similarity index 100%
rename from crates/contracts/artifacts/LiquoriceSettlement.json
rename to contracts/artifacts/LiquoriceSettlement.json
diff --git a/crates/contracts/artifacts/NonStandardERC20Balances.json b/contracts/artifacts/NonStandardERC20Balances.json
similarity index 100%
rename from crates/contracts/artifacts/NonStandardERC20Balances.json
rename to contracts/artifacts/NonStandardERC20Balances.json
diff --git a/contracts/artifacts/PancakeRouter.json b/contracts/artifacts/PancakeRouter.json
new file mode 100644
index 0000000000..1ee16c02cc
--- /dev/null
+++ b/contracts/artifacts/PancakeRouter.json
@@ -0,0 +1,955 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "WETH",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountADesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountIn",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountOut",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsIn",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsOut",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapETHForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/Permit2.json b/contracts/artifacts/Permit2.json
similarity index 100%
rename from crates/contracts/artifacts/Permit2.json
rename to contracts/artifacts/Permit2.json
diff --git a/crates/contracts/artifacts/RemoteERC20Balances.json b/contracts/artifacts/RemoteERC20Balances.json
similarity index 100%
rename from crates/contracts/artifacts/RemoteERC20Balances.json
rename to contracts/artifacts/RemoteERC20Balances.json
diff --git a/crates/contracts/artifacts/Signatures.json b/contracts/artifacts/Signatures.json
similarity index 100%
rename from crates/contracts/artifacts/Signatures.json
rename to contracts/artifacts/Signatures.json
diff --git a/crates/contracts/artifacts/Solver.json b/contracts/artifacts/Solver.json
similarity index 100%
rename from crates/contracts/artifacts/Solver.json
rename to contracts/artifacts/Solver.json
diff --git a/crates/contracts/artifacts/Spardose.json b/contracts/artifacts/Spardose.json
similarity index 100%
rename from crates/contracts/artifacts/Spardose.json
rename to contracts/artifacts/Spardose.json
diff --git a/contracts/artifacts/SushiSwapRouter.json b/contracts/artifacts/SushiSwapRouter.json
new file mode 100644
index 0000000000..1ee16c02cc
--- /dev/null
+++ b/contracts/artifacts/SushiSwapRouter.json
@@ -0,0 +1,955 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "WETH",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountADesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountIn",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountOut",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsIn",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsOut",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapETHForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/Swapper.json b/contracts/artifacts/Swapper.json
similarity index 100%
rename from crates/contracts/artifacts/Swapper.json
rename to contracts/artifacts/Swapper.json
diff --git a/contracts/artifacts/SwaprRouter.json b/contracts/artifacts/SwaprRouter.json
new file mode 100644
index 0000000000..1ee16c02cc
--- /dev/null
+++ b/contracts/artifacts/SwaprRouter.json
@@ -0,0 +1,955 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "WETH",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountADesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountIn",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountOut",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsIn",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsOut",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapETHForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/contracts/artifacts/TestnetUniswapV2Router02.json b/contracts/artifacts/TestnetUniswapV2Router02.json
new file mode 100644
index 0000000000..1ee16c02cc
--- /dev/null
+++ b/contracts/artifacts/TestnetUniswapV2Router02.json
@@ -0,0 +1,955 @@
+{
+  "abi": [
+    {
+      "inputs": [],
+      "name": "WETH",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountADesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenDesired",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "addLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountIn",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveOut",
+          "type": "uint256"
+        }
+      ],
+      "name": "getAmountOut",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsIn",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        }
+      ],
+      "name": "getAmountsOut",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidity",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETH",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountToken",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountTokenMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountETHMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountETH",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "tokenB",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "liquidity",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountAMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountBMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "approveMax",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "removeLiquidityWithPermit",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapETHForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountIn",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountOutMin",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactETH",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/contracts/artifacts/Trader.json b/contracts/artifacts/Trader.json
similarity index 100%
rename from crates/contracts/artifacts/Trader.json
rename to contracts/artifacts/Trader.json
diff --git a/crates/contracts/artifacts/UniswapV2Factory.json b/contracts/artifacts/UniswapV2Factory.json
similarity index 100%
rename from crates/contracts/artifacts/UniswapV2Factory.json
rename to contracts/artifacts/UniswapV2Factory.json
diff --git a/crates/contracts/artifacts/UniswapV2Router02.json b/contracts/artifacts/UniswapV2Router02.json
similarity index 100%
rename from crates/contracts/artifacts/UniswapV2Router02.json
rename to contracts/artifacts/UniswapV2Router02.json
diff --git a/crates/contracts/artifacts/UniswapV3Pool.json b/contracts/artifacts/UniswapV3Pool.json
similarity index 100%
rename from crates/contracts/artifacts/UniswapV3Pool.json
rename to contracts/artifacts/UniswapV3Pool.json
diff --git a/crates/contracts/artifacts/UniswapV3QuoterV2.json b/contracts/artifacts/UniswapV3QuoterV2.json
similarity index 100%
rename from crates/contracts/artifacts/UniswapV3QuoterV2.json
rename to contracts/artifacts/UniswapV3QuoterV2.json
diff --git a/crates/contracts/artifacts/UniswapV3SwapRouterV2.json b/contracts/artifacts/UniswapV3SwapRouterV2.json
similarity index 100%
rename from crates/contracts/artifacts/UniswapV3SwapRouterV2.json
rename to contracts/artifacts/UniswapV3SwapRouterV2.json
diff --git a/crates/contracts/artifacts/WETH9.json b/contracts/artifacts/WETH9.json
similarity index 100%
rename from crates/contracts/artifacts/WETH9.json
rename to contracts/artifacts/WETH9.json
diff --git a/crates/contracts/foundry.toml b/contracts/foundry.toml
similarity index 100%
rename from crates/contracts/foundry.toml
rename to contracts/foundry.toml
diff --git a/contracts/generated/.gitignore b/contracts/generated/.gitignore
new file mode 100644
index 0000000000..05923927ff
--- /dev/null
+++ b/contracts/generated/.gitignore
@@ -0,0 +1,2 @@
+/target
+.DS_Store
diff --git a/contracts/generated/Cargo.lock b/contracts/generated/Cargo.lock
new file mode 100644
index 0000000000..fd0489b2d0
--- /dev/null
+++ b/contracts/generated/Cargo.lock
@@ -0,0 +1,4495 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "alloy-chains"
+version = "0.2.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f374d3c6d729268bbe2d0e0ff992bb97898b2df756691a62ee1d5f0506bc39"
+dependencies = [
+ "alloy-primitives",
+ "num_enum",
+ "strum",
+]
+
+[[package]]
+name = "alloy-consensus"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c0dc44157867da82c469c13186015b86abef209bf0e41625e4b68bac61d728"
+dependencies = [
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "alloy-trie",
+ "alloy-tx-macros",
+ "auto_impl",
+ "borsh",
+ "c-kzg",
+ "derive_more",
+ "either",
+ "k256",
+ "once_cell",
+ "rand 0.8.5",
+ "secp256k1",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-consensus-any"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba4cdb42df3871cd6b346d6a938ec2ba69a9a0f49d1f82714bc5c48349268434"
+dependencies = [
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "serde",
+]
+
+[[package]]
+name = "alloy-contract"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca63b7125a981415898ffe2a2a696c83696c9c6bdb1671c8a912946bbd8e49e7"
+dependencies = [
+ "alloy-consensus",
+ "alloy-dyn-abi",
+ "alloy-json-abi",
+ "alloy-network",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-rpc-types-eth",
+ "alloy-sol-types",
+ "alloy-transport",
+ "futures",
+ "futures-util",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-dyn-abi"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc2db5c583aaef0255aa63a4fe827f826090142528bba48d1bf4119b62780cad"
+dependencies = [
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "alloy-sol-types",
+ "itoa",
+ "serde",
+ "serde_json",
+ "winnow",
+]
+
+[[package]]
+name = "alloy-eip2124"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "741bdd7499908b3aa0b159bba11e71c8cddd009a2c2eb7a06e825f1ec87900a5"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "crc",
+ "serde",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-eip2930"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9441120fa82df73e8959ae0e4ab8ade03de2aaae61be313fbf5746277847ce25"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "borsh",
+ "serde",
+]
+
+[[package]]
+name = "alloy-eip7702"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2919c5a56a1007492da313e7a3b6d45ef5edc5d33416fdec63c0d7a2702a0d20"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "borsh",
+ "serde",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-eip7928"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3231de68d5d6e75332b7489cfcc7f4dfabeba94d990a10e4b923af0e6623540"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "borsh",
+ "serde",
+]
+
+[[package]]
+name = "alloy-eips"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f7ef09f21bd1e9cb8a686f168cb4a206646804567f0889eadb8dcc4c9288c8"
+dependencies = [
+ "alloy-eip2124",
+ "alloy-eip2930",
+ "alloy-eip7702",
+ "alloy-eip7928",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "auto_impl",
+ "borsh",
+ "c-kzg",
+ "derive_more",
+ "either",
+ "serde",
+ "serde_with",
+ "sha2",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-json-abi"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9dbe713da0c737d9e5e387b0ba790eb98b14dd207fe53eef50e19a5a8ec3dac"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "alloy-json-rpc"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff42cd777eea61f370c0b10f2648a1c81e0b783066cd7269228aa993afd487f7"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-types",
+ "http",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "alloy-network"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cbca04f9b410fdc51aaaf88433cbac761213905a65fe832058bcf6690585762"
+dependencies = [
+ "alloy-consensus",
+ "alloy-consensus-any",
+ "alloy-eips",
+ "alloy-json-rpc",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rpc-types-any",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "alloy-signer",
+ "alloy-sol-types",
+ "async-trait",
+ "auto_impl",
+ "derive_more",
+ "futures-utils-wasm",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-network-primitives"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d6d15e069a8b11f56bef2eccbad2a873c6dd4d4c81d04dda29710f5ea52f04"
+dependencies = [
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-serde",
+ "serde",
+]
+
+[[package]]
+name = "alloy-primitives"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3b431b4e72cd8bd0ec7a50b4be18e73dab74de0dba180eef171055e5d5926e"
+dependencies = [
+ "alloy-rlp",
+ "bytes",
+ "cfg-if",
+ "const-hex",
+ "derive_more",
+ "foldhash 0.2.0",
+ "hashbrown 0.16.1",
+ "indexmap 2.13.0",
+ "itoa",
+ "k256",
+ "keccak-asm",
+ "paste",
+ "proptest",
+ "rand 0.9.2",
+ "rapidhash",
+ "ruint",
+ "rustc-hash",
+ "serde",
+ "sha3",
+]
+
+[[package]]
+name = "alloy-provider"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d181c8cc7cf4805d7e589bf4074d56d55064fa1a979f005a45a62b047616d870"
+dependencies = [
+ "alloy-chains",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-json-rpc",
+ "alloy-network",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rpc-client",
+ "alloy-rpc-types-eth",
+ "alloy-signer",
+ "alloy-sol-types",
+ "alloy-transport",
+ "async-stream",
+ "async-trait",
+ "auto_impl",
+ "dashmap",
+ "either",
+ "futures",
+ "futures-utils-wasm",
+ "lru",
+ "parking_lot",
+ "pin-project",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "wasmtimer",
+]
+
+[[package]]
+name = "alloy-rlp"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e93e50f64a77ad9c5470bf2ad0ca02f228da70c792a8f06634801e202579f35e"
+dependencies = [
+ "alloy-rlp-derive",
+ "arrayvec",
+ "bytes",
+]
+
+[[package]]
+name = "alloy-rlp-derive"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce8849c74c9ca0f5a03da1c865e3eb6f768df816e67dd3721a398a8a7e398011"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "alloy-rpc-client"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2792758a93ae32a32e9047c843d536e1448044f78422d71bf7d7c05149e103f"
+dependencies = [
+ "alloy-json-rpc",
+ "alloy-primitives",
+ "alloy-transport",
+ "futures",
+ "pin-project",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tower",
+ "tracing",
+ "wasmtimer",
+]
+
+[[package]]
+name = "alloy-rpc-types-any"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd720b63f82b457610f2eaaf1f32edf44efffe03ae25d537632e7d23e7929e1a"
+dependencies = [
+ "alloy-consensus-any",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+]
+
+[[package]]
+name = "alloy-rpc-types-eth"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b2dc411f13092f237d2bf6918caf80977fc2f51485f9b90cb2a2f956912c8c9"
+dependencies = [
+ "alloy-consensus",
+ "alloy-consensus-any",
+ "alloy-eips",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "alloy-sol-types",
+ "itertools 0.14.0",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-serde"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2ce1e0dbf7720eee747700e300c99aac01b1a95bb93f493a01e78ee28bb1a37"
+dependencies = [
+ "alloy-primitives",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "alloy-signer"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2425c6f314522c78e8198979c8cbf6769362be4da381d4152ea8eefce383535d"
+dependencies = [
+ "alloy-primitives",
+ "async-trait",
+ "auto_impl",
+ "either",
+ "elliptic-curve",
+ "k256",
+ "thiserror",
+]
+
+[[package]]
+name = "alloy-sol-macro"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab81bab693da9bb79f7a95b64b394718259fdd7e41dceeced4cad57cb71c4f6a"
+dependencies = [
+ "alloy-sol-macro-expander",
+ "alloy-sol-macro-input",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "alloy-sol-macro-expander"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "489f1620bb7e2483fb5819ed01ab6edc1d2f93939dce35a5695085a1afd1d699"
+dependencies = [
+ "alloy-sol-macro-input",
+ "const-hex",
+ "heck",
+ "indexmap 2.13.0",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "sha3",
+ "syn 2.0.117",
+ "syn-solidity",
+]
+
+[[package]]
+name = "alloy-sol-macro-input"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56cef806ad22d4392c5fc83cf8f2089f988eb99c7067b4e0c6f1971fc1cca318"
+dependencies = [
+ "const-hex",
+ "dunce",
+ "heck",
+ "macro-string",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "syn-solidity",
+]
+
+[[package]]
+name = "alloy-sol-type-parser"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6df77fea9d6a2a75c0ef8d2acbdfd92286cc599983d3175ccdc170d3433d249"
+dependencies = [
+ "serde",
+ "winnow",
+]
+
+[[package]]
+name = "alloy-sol-types"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64612d29379782a5dde6f4b6570d9c756d734d760c0c94c254d361e678a6591f"
+dependencies = [
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-sol-macro",
+ "serde",
+]
+
+[[package]]
+name = "alloy-transport"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa186e560d523d196580c48bf00f1bf62e63041f28ecf276acc22f8b27bb9f53"
+dependencies = [
+ "alloy-json-rpc",
+ "auto_impl",
+ "base64",
+ "derive_more",
+ "futures",
+ "futures-utils-wasm",
+ "parking_lot",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tower",
+ "tracing",
+ "url",
+ "wasmtimer",
+]
+
+[[package]]
+name = "alloy-trie"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d7fd448ab0a017de542de1dcca7a58e7019fe0e7a34ed3f9543ebddf6aceffa"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "arrayvec",
+ "derive_more",
+ "nybbles",
+ "serde",
+ "smallvec",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "alloy-tx-macros"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fa0c53e8c1e1ef4d01066b01c737fb62fc9397ab52c6e7bb5669f97d281b9bc"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "ark-ff"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6"
+dependencies = [
+ "ark-ff-asm 0.3.0",
+ "ark-ff-macros 0.3.0",
+ "ark-serialize 0.3.0",
+ "ark-std 0.3.0",
+ "derivative",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rustc_version 0.3.3",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
+dependencies = [
+ "ark-ff-asm 0.4.2",
+ "ark-ff-macros 0.4.2",
+ "ark-serialize 0.4.2",
+ "ark-std 0.4.0",
+ "derivative",
+ "digest 0.10.7",
+ "itertools 0.10.5",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rustc_version 0.4.1",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a177aba0ed1e0fbb62aa9f6d0502e9b46dad8c2eab04c14258a1212d2557ea70"
+dependencies = [
+ "ark-ff-asm 0.5.0",
+ "ark-ff-macros 0.5.0",
+ "ark-serialize 0.5.0",
+ "ark-std 0.5.0",
+ "arrayvec",
+ "digest 0.10.7",
+ "educe",
+ "itertools 0.13.0",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09be120733ee33f7693ceaa202ca41accd5653b779563608f1234f78ae07c4b3"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671"
+dependencies = [
+ "ark-std 0.3.0",
+ "digest 0.9.0",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
+dependencies = [
+ "ark-std 0.4.0",
+ "digest 0.10.7",
+ "num-bigint",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f4d068aaf107ebcd7dfb52bc748f8030e0fc930ac8e360146ca54c1203088f7"
+dependencies = [
+ "ark-std 0.5.0",
+ "arrayvec",
+ "digest 0.10.7",
+ "num-bigint",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
+dependencies = [
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
+dependencies = [
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "246a225cc6131e9ee4f24619af0f19d67761fff15d7ccc22e42b80846e69449a"
+dependencies = [
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "auto_impl"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
+[[package]]
+name = "bitcoin-io"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dee39a0ee5b4095224a0cfc6bf4cc1baf0f9624b96b367e53b66d974e51d953"
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26ec84b80c482df901772e931a9a681e26a1b9ee2302edeff23cb30328745c8b"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "blst"
+version = "0.3.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcdb4c7013139a150f9fc55d123186dbfaba0d912817466282c73ac49e71fb45"
+dependencies = [
+ "cc",
+ "glob",
+ "threadpool",
+ "zeroize",
+]
+
+[[package]]
+name = "borsh"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f"
+dependencies = [
+ "borsh-derive",
+ "cfg_aliases",
+]
+
+[[package]]
+name = "borsh-derive"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "byte-slice-cast"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "c-kzg"
+version = "2.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a0f582957c24870b7bfd12bf562c40b4734b533cafbaf8ded31d6d85f462c01"
+dependencies = [
+ "blst",
+ "cc",
+ "glob",
+ "hex",
+ "libc",
+ "once_cell",
+ "serde",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-link",
+]
+
+[[package]]
+name = "const-hex"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9a108e542ddf1de36743a6126e94d6659dccda38fc8a77e80b915102ac784a"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "proptest",
+ "serde_core",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const_format"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7faa7469a93a566e9ccc1c73fe783b4a65c274c5ace346038dca9c39fe0030ad"
+dependencies = [
+ "const_format_proc_macros",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "contracts"
+version = "0.1.0"
+dependencies = [
+ "cow-contract-anyoneauthenticator",
+ "cow-contract-balancerqueries",
+ "cow-contract-balancerv2authorizer",
+ "cow-contract-balancerv2basepool",
+ "cow-contract-balancerv2basepoolfactory",
+ "cow-contract-balancerv2composablestablepool",
+ "cow-contract-balancerv2composablestablepoolfactory",
+ "cow-contract-balancerv2composablestablepoolfactoryv3",
+ "cow-contract-balancerv2composablestablepoolfactoryv4",
+ "cow-contract-balancerv2composablestablepoolfactoryv5",
+ "cow-contract-balancerv2composablestablepoolfactoryv6",
+ "cow-contract-balancerv2liquiditybootstrappingpool",
+ "cow-contract-balancerv2liquiditybootstrappingpoolfactory",
+ "cow-contract-balancerv2noprotocolfeeliquiditybootstrappingpoolfactory",
+ "cow-contract-balancerv2stablepool",
+ "cow-contract-balancerv2stablepoolfactoryv2",
+ "cow-contract-balancerv2vault",
+ "cow-contract-balancerv2weightedpool",
+ "cow-contract-balancerv2weightedpool2tokensfactory",
+ "cow-contract-balancerv2weightedpoolfactory",
+ "cow-contract-balancerv2weightedpoolfactoryv3",
+ "cow-contract-balancerv2weightedpoolfactoryv4",
+ "cow-contract-balancerv3batchrouter",
+ "cow-contract-balances",
+ "cow-contract-baoswaprouter",
+ "cow-contract-chainalysisoracle",
+ "cow-contract-counter",
+ "cow-contract-cowamm",
+ "cow-contract-cowammconstantproductfactory",
+ "cow-contract-cowammfactorygetter",
+ "cow-contract-cowammlegacyhelper",
+ "cow-contract-cowammuniswapv2priceoracle",
+ "cow-contract-cowprotocoltoken",
+ "cow-contract-cowswapethflow",
+ "cow-contract-cowswaponchainorders",
+ "cow-contract-erc1271signaturevalidator",
+ "cow-contract-erc20",
+ "cow-contract-erc20mintable",
+ "cow-contract-flashloanrouter",
+ "cow-contract-gashog",
+ "cow-contract-gnosissafe",
+ "cow-contract-gnosissafecompatibilityfallbackhandler",
+ "cow-contract-gnosissafeproxy",
+ "cow-contract-gnosissafeproxyfactory",
+ "cow-contract-gpv2allowlistauthentication",
+ "cow-contract-gpv2settlement",
+ "cow-contract-honeyswaprouter",
+ "cow-contract-hookstrampoline",
+ "cow-contract-icowwrapper",
+ "cow-contract-iswaprpair",
+ "cow-contract-iuniswaplikepair",
+ "cow-contract-iuniswaplikerouter",
+ "cow-contract-iuniswapv3factory",
+ "cow-contract-izeroex",
+ "cow-contract-liquoricesettlement",
+ "cow-contract-nonstandarderc20balances",
+ "cow-contract-pancakerouter",
+ "cow-contract-permit2",
+ "cow-contract-remoteerc20balances",
+ "cow-contract-signatures",
+ "cow-contract-solver",
+ "cow-contract-spardose",
+ "cow-contract-sushiswaprouter",
+ "cow-contract-swapper",
+ "cow-contract-swaprrouter",
+ "cow-contract-testnetuniswapv2router02",
+ "cow-contract-trader",
+ "cow-contract-uniswapv2factory",
+ "cow-contract-uniswapv2router02",
+ "cow-contract-uniswapv3pool",
+ "cow-contract-uniswapv3quoterv2",
+ "cow-contract-uniswapv3swaprouterv2",
+ "cow-contract-weth9",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cow-contract-anyoneauthenticator"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerqueries"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2authorizer"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2basepool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2basepoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv3"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv4"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv5"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2composablestablepoolfactoryv6"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2liquiditybootstrappingpool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2liquiditybootstrappingpoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2noprotocolfeeliquiditybootstrappingpoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2stablepool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2stablepoolfactoryv2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2vault"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpool2tokensfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpoolfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpoolfactoryv3"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv2weightedpoolfactoryv4"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balancerv3batchrouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-balances"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-baoswaprouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-chainalysisoracle"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-counter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowamm"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammconstantproductfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammfactorygetter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammlegacyhelper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowammuniswapv2priceoracle"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowprotocoltoken"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowswapethflow"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-cowswaponchainorders"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-erc1271signaturevalidator"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-erc20"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-erc20mintable"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-flashloanrouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gashog"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafe"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafecompatibilityfallbackhandler"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafeproxy"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gnosissafeproxyfactory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gpv2allowlistauthentication"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-gpv2settlement"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-honeyswaprouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-hookstrampoline"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-icowwrapper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iswaprpair"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iuniswaplikepair"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iuniswaplikerouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-iuniswapv3factory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-izeroex"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-liquoricesettlement"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-nonstandarderc20balances"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-pancakerouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-permit2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-remoteerc20balances"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-signatures"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-solver"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-spardose"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-sushiswaprouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-swapper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-swaprrouter"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-testnetuniswapv2router02"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-trader"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv2factory"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv2router02"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv3pool"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv3quoterv2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-uniswapv3swaprouterv2"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cow-contract-weth9"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "darling"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.4.1",
+ "syn 2.0.117",
+ "unicode-xid",
+]
+
+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest 0.10.7",
+ "elliptic-curve",
+ "rfc6979",
+ "serdect",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "educe"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417"
+dependencies = [
+ "enum-ordinalize",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest 0.10.7",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core 0.6.4",
+ "sec1",
+ "serdect",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "enum-ordinalize"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0"
+dependencies = [
+ "enum-ordinalize-derive",
+]
+
+[[package]]
+name = "enum-ordinalize-derive"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fastrlp"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139834ddba373bbdd213dffe02c8d110508dcf1726c2be27e8d1f7d7e1856418"
+dependencies = [
+ "arrayvec",
+ "auto_impl",
+ "bytes",
+]
+
+[[package]]
+name = "fastrlp"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce8dba4714ef14b8274c371879b175aa55b16b30f269663f19d576f380018dc4"
+dependencies = [
+ "arrayvec",
+ "auto_impl",
+ "bytes",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fixed-hash"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534"
+dependencies = [
+ "byteorder",
+ "rand 0.8.5",
+ "rustc-hex",
+ "static_assertions",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "futures-utils-wasm"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"
+
+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "impl-codec"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f"
+dependencies = [
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "impl-trait-for-tuples"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dc6f6450b3f6d4ed5b16327f38fed626d375a886159ca555bd7822c0c3a5a6"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "serdect",
+ "sha2",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "keccak-asm"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b646a74e746cd25045aa0fd42f4f7f78aa6d119380182c7e63a5593c4ab8df6f"
+dependencies = [
+ "digest 0.10.7",
+ "sha3-asm",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lru"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593"
+dependencies = [
+ "hashbrown 0.16.1",
+]
+
+[[package]]
+name = "macro-string"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "nybbles"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d49ff0c0d00d4a502b39df9af3a525e1efeb14b9dabb5bb83335284c1309210"
+dependencies = [
+ "alloy-rlp",
+ "cfg-if",
+ "proptest",
+ "ruint",
+ "serde",
+ "smallvec",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "parity-scale-codec"
+version = "3.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799781ae679d79a948e13d4824a40970bfa500058d245760dd857301059810fa"
+dependencies = [
+ "arrayvec",
+ "bitvec",
+ "byte-slice-cast",
+ "const_format",
+ "impl-trait-for-tuples",
+ "parity-scale-codec-derive",
+ "rustversion",
+ "serde",
+]
+
+[[package]]
+name = "parity-scale-codec-derive"
+version = "3.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34b4653168b563151153c9e4c08ebed57fb8262bebfa79711552fa983c623e7a"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pest"
+version = "2.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662"
+dependencies = [
+ "memchr",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "primitive-types"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
+dependencies = [
+ "fixed-hash",
+ "impl-codec",
+ "uint",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "proptest"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37566cb3fdacef14c0737f9546df7cfeadbfbc9fef10991038bf5015d0c80532"
+dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags",
+ "num-traits",
+ "rand 0.9.2",
+ "rand_chacha 0.9.0",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+ "serde",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+ "serde",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+ "serde",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+dependencies = [
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rapidhash"
+version = "4.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e48930979c155e2f33aa36ab3119b5ee81332beb6482199a8ecd6029b80b59"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "rlp"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec"
+dependencies = [
+ "bytes",
+ "rustc-hex",
+]
+
+[[package]]
+name = "ruint"
+version = "1.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c141e807189ad38a07276942c6623032d3753c8859c146104ac2e4d68865945a"
+dependencies = [
+ "alloy-rlp",
+ "ark-ff 0.3.0",
+ "ark-ff 0.4.2",
+ "ark-ff 0.5.0",
+ "bytes",
+ "fastrlp 0.3.1",
+ "fastrlp 0.4.0",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "parity-scale-codec",
+ "primitive-types",
+ "proptest",
+ "rand 0.8.5",
+ "rand 0.9.2",
+ "rlp",
+ "ruint-macro",
+ "serde_core",
+ "valuable",
+ "zeroize",
+]
+
+[[package]]
+name = "ruint-macro"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustc-hex"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
+
+[[package]]
+name = "rustc_version"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
+dependencies = [
+ "semver 0.11.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver 1.0.27",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "rusty-fork"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "serdect",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+dependencies = [
+ "bitcoin_hashes",
+ "rand 0.8.5",
+ "secp256k1-sys",
+ "serde",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "semver"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "semver-parser"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2"
+dependencies = [
+ "pest",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9"
+dependencies = [
+ "base64",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.13.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serdect"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177"
+dependencies = [
+ "base16ct",
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest 0.10.7",
+ "keccak",
+]
+
+[[package]]
+name = "sha3-asm"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b31139435f327c93c6038ed350ae4588e2c70a13d50599509fee6349967ba35a"
+dependencies = [
+ "cc",
+ "cfg-if",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn-solidity"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53f425ae0b12e2f5ae65542e00898d500d4d318b4baf09f40fd0d410454e9947"
+dependencies = [
+ "paste",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tempfile"
+version = "3.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.1",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.49.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+dependencies = [
+ "pin-project-lite",
+ "tokio-macros",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.10+spec-1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
+dependencies = [
+ "indexmap 2.13.0",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.9+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
+[[package]]
+name = "uint"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52"
+dependencies = [
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
+]
+
+[[package]]
+name = "unarray"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60722a937f594b7fde9adb894d7c092fc1bb6612897c46368d18e7a20208eff2"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac8c6395094b6b91c4af293f4c79371c163f9a6f56184d2c9a85f5a95f3950"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3fabce6159dc20728033842636887e4877688ae94382766e00b180abac9d60"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de0e091bdb824da87dc01d967388880d017a0a9bc4f3bdc0d86ee9f9336e3bb5"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.13.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap 2.13.0",
+ "semver 1.0.27",
+]
+
+[[package]]
+name = "wasmtimer"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c598d6b99ea013e35844697fc4670d08339d5cda15588f193c6beedd12f644b"
+dependencies = [
+ "futures",
+ "js-sys",
+ "parking_lot",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap 2.13.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap 2.13.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.13.0",
+ "log",
+ "semver 1.0.27",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/contracts/generated/Cargo.toml b/contracts/generated/Cargo.toml
new file mode 100644
index 0000000000..05040e2ae0
--- /dev/null
+++ b/contracts/generated/Cargo.toml
@@ -0,0 +1,17 @@
+# Auto-generated by contracts-generate. Do not edit.
+[workspace]
+resolver = "3"
+members = [
+  "contracts-facade",
+  "contracts-generated/*",
+]
+
+[workspace.dependencies]
+alloy-contract = { version = "1.7.3" }
+alloy-primitives = { version = "1.5.7", default-features = false }
+alloy-provider = { version = "1.7.3", default-features = false }
+alloy-sol-types = { version = "1.5.7", default-features = false }
+anyhow = "1.0.100"
+
+[workspace.lints.clippy]
+all = "warn"
diff --git a/contracts/generated/contracts-facade/Cargo.toml b/contracts/generated/contracts-facade/Cargo.toml
new file mode 100644
index 0000000000..ca824f689c
--- /dev/null
+++ b/contracts/generated/contracts-facade/Cargo.toml
@@ -0,0 +1,88 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "contracts"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+cow-contract-anyoneauthenticator = { path = "../contracts-generated/anyoneauthenticator" }
+cow-contract-balancerqueries = { path = "../contracts-generated/balancerqueries" }
+cow-contract-balancerv2authorizer = { path = "../contracts-generated/balancerv2authorizer" }
+cow-contract-balancerv2basepool = { path = "../contracts-generated/balancerv2basepool" }
+cow-contract-balancerv2basepoolfactory = { path = "../contracts-generated/balancerv2basepoolfactory" }
+cow-contract-balancerv2composablestablepool = { path = "../contracts-generated/balancerv2composablestablepool" }
+cow-contract-balancerv2composablestablepoolfactory = { path = "../contracts-generated/balancerv2composablestablepoolfactory" }
+cow-contract-balancerv2composablestablepoolfactoryv3 = { path = "../contracts-generated/balancerv2composablestablepoolfactoryv3" }
+cow-contract-balancerv2composablestablepoolfactoryv4 = { path = "../contracts-generated/balancerv2composablestablepoolfactoryv4" }
+cow-contract-balancerv2composablestablepoolfactoryv5 = { path = "../contracts-generated/balancerv2composablestablepoolfactoryv5" }
+cow-contract-balancerv2composablestablepoolfactoryv6 = { path = "../contracts-generated/balancerv2composablestablepoolfactoryv6" }
+cow-contract-balancerv2liquiditybootstrappingpool = { path = "../contracts-generated/balancerv2liquiditybootstrappingpool" }
+cow-contract-balancerv2liquiditybootstrappingpoolfactory = { path = "../contracts-generated/balancerv2liquiditybootstrappingpoolfactory" }
+cow-contract-balancerv2noprotocolfeeliquiditybootstrappingpoolfactory = { path = "../contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory" }
+cow-contract-balancerv2stablepool = { path = "../contracts-generated/balancerv2stablepool" }
+cow-contract-balancerv2stablepoolfactoryv2 = { path = "../contracts-generated/balancerv2stablepoolfactoryv2" }
+cow-contract-balancerv2vault = { path = "../contracts-generated/balancerv2vault" }
+cow-contract-balancerv2weightedpool = { path = "../contracts-generated/balancerv2weightedpool" }
+cow-contract-balancerv2weightedpool2tokensfactory = { path = "../contracts-generated/balancerv2weightedpool2tokensfactory" }
+cow-contract-balancerv2weightedpoolfactory = { path = "../contracts-generated/balancerv2weightedpoolfactory" }
+cow-contract-balancerv2weightedpoolfactoryv3 = { path = "../contracts-generated/balancerv2weightedpoolfactoryv3" }
+cow-contract-balancerv2weightedpoolfactoryv4 = { path = "../contracts-generated/balancerv2weightedpoolfactoryv4" }
+cow-contract-balancerv3batchrouter = { path = "../contracts-generated/balancerv3batchrouter" }
+cow-contract-balances = { path = "../contracts-generated/balances" }
+cow-contract-baoswaprouter = { path = "../contracts-generated/baoswaprouter" }
+cow-contract-chainalysisoracle = { path = "../contracts-generated/chainalysisoracle" }
+cow-contract-counter = { path = "../contracts-generated/counter" }
+cow-contract-cowamm = { path = "../contracts-generated/cowamm" }
+cow-contract-cowammconstantproductfactory = { path = "../contracts-generated/cowammconstantproductfactory" }
+cow-contract-cowammfactorygetter = { path = "../contracts-generated/cowammfactorygetter" }
+cow-contract-cowammlegacyhelper = { path = "../contracts-generated/cowammlegacyhelper" }
+cow-contract-cowammuniswapv2priceoracle = { path = "../contracts-generated/cowammuniswapv2priceoracle" }
+cow-contract-cowprotocoltoken = { path = "../contracts-generated/cowprotocoltoken" }
+cow-contract-cowsettlementforwarder = { path = "../contracts-generated/cowsettlementforwarder" }
+cow-contract-cowswapethflow = { path = "../contracts-generated/cowswapethflow" }
+cow-contract-cowswaponchainorders = { path = "../contracts-generated/cowswaponchainorders" }
+cow-contract-erc20 = { path = "../contracts-generated/erc20" }
+cow-contract-erc20mintable = { path = "../contracts-generated/erc20mintable" }
+cow-contract-erc1271signaturevalidator = { path = "../contracts-generated/erc1271signaturevalidator" }
+cow-contract-flashloanrouter = { path = "../contracts-generated/flashloanrouter" }
+cow-contract-gashog = { path = "../contracts-generated/gashog" }
+cow-contract-gnosissafe = { path = "../contracts-generated/gnosissafe" }
+cow-contract-gnosissafecompatibilityfallbackhandler = { path = "../contracts-generated/gnosissafecompatibilityfallbackhandler" }
+cow-contract-gnosissafeproxy = { path = "../contracts-generated/gnosissafeproxy" }
+cow-contract-gnosissafeproxyfactory = { path = "../contracts-generated/gnosissafeproxyfactory" }
+cow-contract-gpv2allowlistauthentication = { path = "../contracts-generated/gpv2allowlistauthentication" }
+cow-contract-gpv2settlement = { path = "../contracts-generated/gpv2settlement" }
+cow-contract-honeyswaprouter = { path = "../contracts-generated/honeyswaprouter" }
+cow-contract-hookstrampoline = { path = "../contracts-generated/hookstrampoline" }
+cow-contract-icowwrapper = { path = "../contracts-generated/icowwrapper" }
+cow-contract-iswaprpair = { path = "../contracts-generated/iswaprpair" }
+cow-contract-iuniswaplikepair = { path = "../contracts-generated/iuniswaplikepair" }
+cow-contract-iuniswaplikerouter = { path = "../contracts-generated/iuniswaplikerouter" }
+cow-contract-iuniswapv3factory = { path = "../contracts-generated/iuniswapv3factory" }
+cow-contract-izeroex = { path = "../contracts-generated/izeroex" }
+cow-contract-liquoricesettlement = { path = "../contracts-generated/liquoricesettlement" }
+cow-contract-nonstandarderc20balances = { path = "../contracts-generated/nonstandarderc20balances" }
+cow-contract-pancakerouter = { path = "../contracts-generated/pancakerouter" }
+cow-contract-permit2 = { path = "../contracts-generated/permit2" }
+cow-contract-remoteerc20balances = { path = "../contracts-generated/remoteerc20balances" }
+cow-contract-signatures = { path = "../contracts-generated/signatures" }
+cow-contract-solver = { path = "../contracts-generated/solver" }
+cow-contract-spardose = { path = "../contracts-generated/spardose" }
+cow-contract-sushiswaprouter = { path = "../contracts-generated/sushiswaprouter" }
+cow-contract-swapper = { path = "../contracts-generated/swapper" }
+cow-contract-swaprrouter = { path = "../contracts-generated/swaprrouter" }
+cow-contract-testnetuniswapv2router02 = { path = "../contracts-generated/testnetuniswapv2router02" }
+cow-contract-trader = { path = "../contracts-generated/trader" }
+cow-contract-uniswapv2factory = { path = "../contracts-generated/uniswapv2factory" }
+cow-contract-uniswapv2router02 = { path = "../contracts-generated/uniswapv2router02" }
+cow-contract-uniswapv3pool = { path = "../contracts-generated/uniswapv3pool" }
+cow-contract-uniswapv3quoterv2 = { path = "../contracts-generated/uniswapv3quoterv2" }
+cow-contract-uniswapv3swaprouterv2 = { path = "../contracts-generated/uniswapv3swaprouterv2" }
+cow-contract-weth9 = { path = "../contracts-generated/weth9" }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-facade/src/lib.rs b/contracts/generated/contracts-facade/src/lib.rs
new file mode 100644
index 0000000000..91abfdf567
--- /dev/null
+++ b/contracts/generated/contracts-facade/src/lib.rs
@@ -0,0 +1,97 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! This crate re-exports per-contract crate bindings.
+//! Auto-generated by contracts-generate. Do not edit.
+pub use {
+    cow_contract_balancerqueries as BalancerQueries,
+    cow_contract_balancerv2authorizer as BalancerV2Authorizer,
+    cow_contract_balancerv2basepool as BalancerV2BasePool,
+    cow_contract_balancerv2basepoolfactory as BalancerV2BasePoolFactory,
+    cow_contract_balancerv2composablestablepool as BalancerV2ComposableStablePool,
+    cow_contract_balancerv2composablestablepoolfactory as BalancerV2ComposableStablePoolFactory,
+    cow_contract_balancerv2composablestablepoolfactoryv3 as BalancerV2ComposableStablePoolFactoryV3,
+    cow_contract_balancerv2composablestablepoolfactoryv4 as BalancerV2ComposableStablePoolFactoryV4,
+    cow_contract_balancerv2composablestablepoolfactoryv5 as BalancerV2ComposableStablePoolFactoryV5,
+    cow_contract_balancerv2composablestablepoolfactoryv6 as BalancerV2ComposableStablePoolFactoryV6,
+    cow_contract_balancerv2liquiditybootstrappingpool as BalancerV2LiquidityBootstrappingPool,
+    cow_contract_balancerv2liquiditybootstrappingpoolfactory as BalancerV2LiquidityBootstrappingPoolFactory,
+    cow_contract_balancerv2noprotocolfeeliquiditybootstrappingpoolfactory as BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory,
+    cow_contract_balancerv2stablepool as BalancerV2StablePool,
+    cow_contract_balancerv2stablepoolfactoryv2 as BalancerV2StablePoolFactoryV2,
+    cow_contract_balancerv2vault as BalancerV2Vault,
+    cow_contract_balancerv2weightedpool as BalancerV2WeightedPool,
+    cow_contract_balancerv2weightedpool2tokensfactory as BalancerV2WeightedPool2TokensFactory,
+    cow_contract_balancerv2weightedpoolfactory as BalancerV2WeightedPoolFactory,
+    cow_contract_balancerv2weightedpoolfactoryv3 as BalancerV2WeightedPoolFactoryV3,
+    cow_contract_balancerv2weightedpoolfactoryv4 as BalancerV2WeightedPoolFactoryV4,
+    cow_contract_balancerv3batchrouter as BalancerV3BatchRouter,
+    cow_contract_baoswaprouter as BaoswapRouter,
+    cow_contract_chainalysisoracle as ChainalysisOracle,
+    cow_contract_cowsettlementforwarder as CowSettlementForwarder,
+    cow_contract_cowswapethflow as CoWSwapEthFlow,
+    cow_contract_cowswaponchainorders as CoWSwapOnchainOrders,
+    cow_contract_erc20 as ERC20,
+    cow_contract_erc20mintable as ERC20Mintable,
+    cow_contract_erc1271signaturevalidator as ERC1271SignatureValidator,
+    cow_contract_flashloanrouter as FlashLoanRouter,
+    cow_contract_gnosissafe as GnosisSafe,
+    cow_contract_gnosissafecompatibilityfallbackhandler as GnosisSafeCompatibilityFallbackHandler,
+    cow_contract_gnosissafeproxy as GnosisSafeProxy,
+    cow_contract_gnosissafeproxyfactory as GnosisSafeProxyFactory,
+    cow_contract_gpv2allowlistauthentication as GPv2AllowListAuthentication,
+    cow_contract_gpv2settlement as GPv2Settlement,
+    cow_contract_honeyswaprouter as HoneyswapRouter,
+    cow_contract_hookstrampoline as HooksTrampoline,
+    cow_contract_icowwrapper as ICowWrapper,
+    cow_contract_iswaprpair as ISwaprPair,
+    cow_contract_iuniswaplikepair as IUniswapLikePair,
+    cow_contract_iuniswaplikerouter as IUniswapLikeRouter,
+    cow_contract_iuniswapv3factory as IUniswapV3Factory,
+    cow_contract_izeroex as IZeroex,
+    cow_contract_liquoricesettlement as LiquoriceSettlement,
+    cow_contract_pancakerouter as PancakeRouter,
+    cow_contract_permit2 as Permit2,
+    cow_contract_sushiswaprouter as SushiSwapRouter,
+    cow_contract_swaprrouter as SwaprRouter,
+    cow_contract_testnetuniswapv2router02 as TestnetUniswapV2Router02,
+    cow_contract_uniswapv2factory as UniswapV2Factory,
+    cow_contract_uniswapv2router02 as UniswapV2Router02,
+    cow_contract_uniswapv3pool as UniswapV3Pool,
+    cow_contract_uniswapv3quoterv2 as UniswapV3QuoterV2,
+    cow_contract_uniswapv3swaprouterv2 as UniswapV3SwapRouterV2,
+    cow_contract_weth9 as WETH9,
+};
+pub mod support {
+    pub use {
+        cow_contract_anyoneauthenticator as AnyoneAuthenticator,
+        cow_contract_balances as Balances,
+        cow_contract_signatures as Signatures,
+        cow_contract_solver as Solver,
+        cow_contract_spardose as Spardose,
+        cow_contract_swapper as Swapper,
+        cow_contract_trader as Trader,
+    };
+}
+pub mod test {
+    pub use {
+        cow_contract_counter as Counter,
+        cow_contract_cowprotocoltoken as CowProtocolToken,
+        cow_contract_gashog as GasHog,
+        cow_contract_nonstandarderc20balances as NonStandardERC20Balances,
+        cow_contract_remoteerc20balances as RemoteERC20Balances,
+    };
+}
+pub mod cow_amm {
+    pub use {
+        cow_contract_cowamm as CowAmm,
+        cow_contract_cowammconstantproductfactory as CowAmmConstantProductFactory,
+        cow_contract_cowammfactorygetter as CowAmmFactoryGetter,
+        cow_contract_cowammlegacyhelper as CowAmmLegacyHelper,
+        cow_contract_cowammuniswapv2priceoracle as CowAmmUniswapV2PriceOracle,
+    };
+}
diff --git a/contracts/generated/contracts-generated/anyoneauthenticator/Cargo.toml b/contracts/generated/contracts-generated/anyoneauthenticator/Cargo.toml
new file mode 100644
index 0000000000..e537b8086d
--- /dev/null
+++ b/contracts/generated/contracts-generated/anyoneauthenticator/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-anyoneauthenticator"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/anyoneauthenticator/src/lib.rs b/contracts/generated/contracts-generated/anyoneauthenticator/src/lib.rs
new file mode 100644
index 0000000000..c4f71c03f3
--- /dev/null
+++ b/contracts/generated/contracts-generated/anyoneauthenticator/src/lib.rs
@@ -0,0 +1,527 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface AnyoneAuthenticator {
+    function isSolver(address) external pure returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "isSolver",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "pure"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod AnyoneAuthenticator {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x6080604052348015600e575f5ffd5b50609480601a5f395ff3fe6080604052348015600e575f5ffd5b50600436106026575f3560e01c806302cc250d14602a575b5f5ffd5b603b6035366004604f565b50600190565b604051901515815260200160405180910390f35b5f60208284031215605e575f5ffd5b813573ffffffffffffffffffffffffffffffffffffffff811681146080575f5ffd5b939250505056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[P`\x94\x80`\x1A_9_\xF3\xFE`\x80`@R4\x80\x15`\x0EW__\xFD[P`\x046\x10`&W_5`\xE0\x1C\x80c\x02\xCC%\r\x14`*W[__\xFD[`;`56`\x04`OV[P`\x01\x90V[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_` \x82\x84\x03\x12\x15`^W__\xFD[\x815s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14`\x80W__\xFD[\x93\x92PPPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x6080604052348015600e575f5ffd5b50600436106026575f3560e01c806302cc250d14602a575b5f5ffd5b603b6035366004604f565b50600190565b604051901515815260200160405180910390f35b5f60208284031215605e575f5ffd5b813573ffffffffffffffffffffffffffffffffffffffff811681146080575f5ffd5b939250505056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[P`\x046\x10`&W_5`\xE0\x1C\x80c\x02\xCC%\r\x14`*W[__\xFD[`;`56`\x04`OV[P`\x01\x90V[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_` \x82\x84\x03\x12\x15`^W__\xFD[\x815s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14`\x80W__\xFD[\x93\x92PPPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isSolver(address)` and selector `0x02cc250d`.
+    ```solidity
+    function isSolver(address) external pure returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSolverCall(pub alloy_sol_types::private::Address);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isSolver(address)`](isSolverCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSolverReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSolverCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isSolverCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSolverCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSolverReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isSolverReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSolverReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isSolverCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 204u8, 37u8, 13u8];
+            const SIGNATURE: &'static str = "isSolver(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isSolverReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isSolverReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`AnyoneAuthenticator`](self) function calls.
+    #[derive(Clone)]
+    pub enum AnyoneAuthenticatorCalls {
+        #[allow(missing_docs)]
+        isSolver(isSolverCall),
+    }
+    impl AnyoneAuthenticatorCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[2u8, 204u8, 37u8, 13u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<isSolverCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(isSolver)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for AnyoneAuthenticatorCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
+        const NAME: &'static str = "AnyoneAuthenticatorCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::isSolver(_) => <isSolverCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<AnyoneAuthenticatorCalls>] = &[{
+                fn isSolver(data: &[u8]) -> alloy_sol_types::Result<AnyoneAuthenticatorCalls> {
+                    <isSolverCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(AnyoneAuthenticatorCalls::isSolver)
+                }
+                isSolver
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                AnyoneAuthenticatorCalls,
+            >] = &[{
+                fn isSolver(data: &[u8]) -> alloy_sol_types::Result<AnyoneAuthenticatorCalls> {
+                    <isSolverCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(AnyoneAuthenticatorCalls::isSolver)
+                }
+                isSolver
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::isSolver(inner) => {
+                    <isSolverCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::isSolver(inner) => {
+                    <isSolverCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`AnyoneAuthenticator`](self) contract instance.
+
+    See the [wrapper's documentation](`AnyoneAuthenticatorInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> AnyoneAuthenticatorInstance<P, N> {
+        AnyoneAuthenticatorInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<AnyoneAuthenticatorInstance<P, N>>>
+    {
+        AnyoneAuthenticatorInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        AnyoneAuthenticatorInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`AnyoneAuthenticator`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`AnyoneAuthenticator`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct AnyoneAuthenticatorInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for AnyoneAuthenticatorInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("AnyoneAuthenticatorInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        AnyoneAuthenticatorInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`AnyoneAuthenticator`](self) contract instance.
+
+        See the [wrapper's documentation](`AnyoneAuthenticatorInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<AnyoneAuthenticatorInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> AnyoneAuthenticatorInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> AnyoneAuthenticatorInstance<P, N> {
+            AnyoneAuthenticatorInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        AnyoneAuthenticatorInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`isSolver`] function.
+        pub fn isSolver(
+            &self,
+            _0: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isSolverCall, N> {
+            self.call_builder(&isSolverCall(_0))
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        AnyoneAuthenticatorInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = AnyoneAuthenticator::AnyoneAuthenticatorInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/balancerqueries/Cargo.toml b/contracts/generated/contracts-generated/balancerqueries/Cargo.toml
new file mode 100644
index 0000000000..c253060b73
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerqueries/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerqueries"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerqueries/src/lib.rs b/contracts/generated/contracts-generated/balancerqueries/src/lib.rs
new file mode 100644
index 0000000000..323bd46d0c
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerqueries/src/lib.rs
@@ -0,0 +1,3464 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    type SwapKind is uint8;
+    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
+    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
+    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
+    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
+    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SwapKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SwapKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SwapKind> for u8 {
+            fn from(value: SwapKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BatchSwapStep {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub assetInIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub assetOutIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<BatchSwapStep> for UnderlyingRustTuple<'_> {
+            fn from(value: BatchSwapStep) -> Self {
+                (
+                    value.poolId,
+                    value.assetInIndex,
+                    value.assetOutIndex,
+                    value.amount,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BatchSwapStep {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    poolId: tuple.0,
+                    assetInIndex: tuple.1,
+                    assetOutIndex: tuple.2,
+                    amount: tuple.3,
+                    userData: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for BatchSwapStep {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for BatchSwapStep {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetInIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetOutIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for BatchSwapStep {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for BatchSwapStep {
+            const NAME: &'static str = "BatchSwapStep";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "BatchSwapStep(bytes32 poolId,uint256 assetInIndex,uint256 \
+                     assetOutIndex,uint256 amount,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetInIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetOutIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for BatchSwapStep {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetInIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetOutIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetInIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetOutIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ExitPoolRequest {
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub minAmountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub toInternalBalance: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            alloy_sol_types::private::Bytes,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ExitPoolRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: ExitPoolRequest) -> Self {
+                (
+                    value.assets,
+                    value.minAmountsOut,
+                    value.userData,
+                    value.toInternalBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExitPoolRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    assets: tuple.0,
+                    minAmountsOut: tuple.1,
+                    userData: tuple.2,
+                    toInternalBalance: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for ExitPoolRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for ExitPoolRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minAmountsOut),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.toInternalBalance,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ExitPoolRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for ExitPoolRequest {
+            const NAME: &'static str = "ExitPoolRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "ExitPoolRequest(address[] assets,uint256[] minAmountsOut,bytes userData,bool \
+                     toInternalBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minAmountsOut)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.toInternalBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ExitPoolRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assets,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minAmountsOut,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toInternalBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assets,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minAmountsOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toInternalBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct FundManagement {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fromInternalBalance: bool,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub toInternalBalance: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            bool,
+            alloy_sol_types::private::Address,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<FundManagement> for UnderlyingRustTuple<'_> {
+            fn from(value: FundManagement) -> Self {
+                (
+                    value.sender,
+                    value.fromInternalBalance,
+                    value.recipient,
+                    value.toInternalBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FundManagement {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sender: tuple.0,
+                    fromInternalBalance: tuple.1,
+                    recipient: tuple.2,
+                    toInternalBalance: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for FundManagement {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for FundManagement {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.fromInternalBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.toInternalBalance,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for FundManagement {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for FundManagement {
+            const NAME: &'static str = "FundManagement";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "FundManagement(address sender,bool fromInternalBalance,address \
+                     recipient,bool toInternalBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.fromInternalBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.toInternalBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for FundManagement {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.fromInternalBalance,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toInternalBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fromInternalBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toInternalBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct JoinPoolRequest {
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub maxAmountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub fromInternalBalance: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            alloy_sol_types::private::Bytes,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<JoinPoolRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: JoinPoolRequest) -> Self {
+                (
+                    value.assets,
+                    value.maxAmountsIn,
+                    value.userData,
+                    value.fromInternalBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for JoinPoolRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    assets: tuple.0,
+                    maxAmountsIn: tuple.1,
+                    userData: tuple.2,
+                    fromInternalBalance: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for JoinPoolRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for JoinPoolRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.maxAmountsIn),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.fromInternalBalance,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for JoinPoolRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for JoinPoolRequest {
+            const NAME: &'static str = "JoinPoolRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "JoinPoolRequest(address[] assets,uint256[] maxAmountsIn,bytes userData,bool \
+                     fromInternalBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxAmountsIn)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.fromInternalBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for JoinPoolRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assets,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maxAmountsIn,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.fromInternalBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assets,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maxAmountsIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fromInternalBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SingleSwap {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub kind: <SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub assetIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub assetOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            SwapKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            <SwapKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SingleSwap> for UnderlyingRustTuple<'_> {
+            fn from(value: SingleSwap) -> Self {
+                (
+                    value.poolId,
+                    value.kind,
+                    value.assetIn,
+                    value.assetOut,
+                    value.amount,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SingleSwap {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    poolId: tuple.0,
+                    kind: tuple.1,
+                    assetIn: tuple.2,
+                    assetOut: tuple.3,
+                    amount: tuple.4,
+                    userData: tuple.5,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SingleSwap {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SingleSwap {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.assetIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.assetOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SingleSwap {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SingleSwap {
+            const NAME: &'static str = "SingleSwap";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SingleSwap(bytes32 poolId,uint8 kind,address assetIn,address \
+                     assetOut,uint256 amount,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <SwapKind as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.assetIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.assetOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SingleSwap {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.kind, out);
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IVault {
+    type SwapKind is uint8;
+    struct BatchSwapStep {
+        bytes32 poolId;
+        uint256 assetInIndex;
+        uint256 assetOutIndex;
+        uint256 amount;
+        bytes userData;
+    }
+    struct ExitPoolRequest {
+        address[] assets;
+        uint256[] minAmountsOut;
+        bytes userData;
+        bool toInternalBalance;
+    }
+    struct FundManagement {
+        address sender;
+        bool fromInternalBalance;
+        address payable recipient;
+        bool toInternalBalance;
+    }
+    struct JoinPoolRequest {
+        address[] assets;
+        uint256[] maxAmountsIn;
+        bytes userData;
+        bool fromInternalBalance;
+    }
+    struct SingleSwap {
+        bytes32 poolId;
+        SwapKind kind;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+        bytes userData;
+    }
+}
+
+interface BalancerQueries {
+    constructor(address _vault);
+
+    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external returns (int256[] memory assetDeltas);
+    function queryExit(bytes32 poolId, address sender, address recipient, IVault.ExitPoolRequest memory request) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    function queryJoin(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    function querySwap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds) external returns (uint256);
+    function vault() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryBatchSwap",
+    "inputs": [
+      {
+        "name": "kind",
+        "type": "uint8",
+        "internalType": "enum IVault.SwapKind"
+      },
+      {
+        "name": "swaps",
+        "type": "tuple[]",
+        "internalType": "struct IVault.BatchSwapStep[]",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "assetInIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assetOutIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "assets",
+        "type": "address[]",
+        "internalType": "contract IAsset[]"
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "assetDeltas",
+        "type": "int256[]",
+        "internalType": "int256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryExit",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IVault.ExitPoolRequest",
+        "components": [
+          {
+            "name": "assets",
+            "type": "address[]",
+            "internalType": "contract IAsset[]"
+          },
+          {
+            "name": "minAmountsOut",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryJoin",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IVault.JoinPoolRequest",
+        "components": [
+          {
+            "name": "assets",
+            "type": "address[]",
+            "internalType": "contract IAsset[]"
+          },
+          {
+            "name": "maxAmountsIn",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "querySwap",
+    "inputs": [
+      {
+        "name": "singleSwap",
+        "type": "tuple",
+        "internalType": "struct IVault.SingleSwap",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "assetIn",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "assetOut",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "vault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerQueries {
+    use {super::*, alloy_sol_types};
+    /**Constructor`.
+    ```solidity
+    constructor(address _vault);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _vault: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._vault,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _vault: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._vault,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool))` and selector `0xf84d066e`.
+    ```solidity
+    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external returns (int256[] memory assetDeltas);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryBatchSwapCall {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub swaps: alloy_sol_types::private::Vec<
+            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],
+    /// address[],(address,bool,address,bool))`](queryBatchSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryBatchSwapReturn {
+        #[allow(missing_docs)]
+        pub assetDeltas:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryBatchSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryBatchSwapCall) -> Self {
+                    (value.kind, value.swaps, value.assets, value.funds)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        kind: tuple.0,
+                        swaps: tuple.1,
+                        assets: tuple.2,
+                        funds: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryBatchSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryBatchSwapReturn) -> Self {
+                    (value.assetDeltas,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        assetDeltas: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryBatchSwapCall {
+            type Parameters<'a> = (
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 77u8, 6u8, 110u8];
+            const SIGNATURE: &'static str = "queryBatchSwap(uint8,(bytes32,uint256,uint256,\
+                                             uint256,bytes)[],address[],(address,bool,address,\
+                                             bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::BatchSwapStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
+                        &self.funds,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Int<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: queryBatchSwapReturn = r.into();
+                        r.assetDeltas
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: queryBatchSwapReturn = r.into();
+                    r.assetDeltas
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryExit(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0xc7b2c52c`.
+    ```solidity
+    function queryExit(bytes32 poolId, address sender, address recipient, IVault.ExitPoolRequest memory request) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryExit(bytes32,address,address,(address[],uint256[],bytes,
+    /// bool))`](queryExitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitReturn {
+        #[allow(missing_docs)]
+        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::ExitPoolRequest,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitCall) -> Self {
+                    (value.poolId, value.sender, value.recipient, value.request)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        request: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitReturn) -> Self {
+                    (value.bptIn, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptIn: tuple.0,
+                        amountsOut: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryExitReturn {
+            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryExitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::ExitPoolRequest,
+            );
+            type Return = queryExitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [199u8, 178u8, 197u8, 44u8];
+            const SIGNATURE: &'static str =
+                "queryExit(bytes32,address,address,(address[],uint256[],bytes,bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <IVault::ExitPoolRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryExitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryJoin(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0x9ebbf05d`.
+    ```solidity
+    function queryJoin(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryJoin(bytes32,address,address,(address[],uint256[],bytes,
+    /// bool))`](queryJoinCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinReturn {
+        #[allow(missing_docs)]
+        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::JoinPoolRequest,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinCall) -> Self {
+                    (value.poolId, value.sender, value.recipient, value.request)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        request: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinReturn) -> Self {
+                    (value.bptOut, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptOut: tuple.0,
+                        amountsIn: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryJoinReturn {
+            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryJoinCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::JoinPoolRequest,
+            );
+            type Return = queryJoinReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [158u8, 187u8, 240u8, 93u8];
+            const SIGNATURE: &'static str =
+                "queryJoin(bytes32,address,address,(address[],uint256[],bytes,bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <IVault::JoinPoolRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryJoinReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `querySwap((bytes32,uint8,address,address,uint256,bytes),(address,bool,address,bool))` and selector `0xe969f6b3`.
+    ```solidity
+    function querySwap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds) external returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapCall {
+        #[allow(missing_docs)]
+        pub singleSwap: <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`querySwap((bytes32,uint8,address,address,uint256,bytes),(address,bool,
+    /// address,bool))`](querySwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IVault::SingleSwap, IVault::FundManagement);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
+                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapCall) -> Self {
+                    (value.singleSwap, value.funds)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        singleSwap: tuple.0,
+                        funds: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for querySwapCall {
+            type Parameters<'a> = (IVault::SingleSwap, IVault::FundManagement);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [233u8, 105u8, 246u8, 179u8];
+            const SIGNATURE: &'static str = "querySwap((bytes32,uint8,address,address,uint256,\
+                                             bytes),(address,bool,address,bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IVault::SingleSwap as alloy_sol_types::SolType>::tokenize(&self.singleSwap),
+                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(&self.funds),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: querySwapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: querySwapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `vault()` and selector `0xfbfa77cf`.
+    ```solidity
+    function vault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct vaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`vault()`](vaultCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct vaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<vaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: vaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for vaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<vaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: vaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for vaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for vaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 250u8, 119u8, 207u8];
+            const SIGNATURE: &'static str = "vault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: vaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: vaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerQueries`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerQueriesCalls {
+        #[allow(missing_docs)]
+        queryBatchSwap(queryBatchSwapCall),
+        #[allow(missing_docs)]
+        queryExit(queryExitCall),
+        #[allow(missing_docs)]
+        queryJoin(queryJoinCall),
+        #[allow(missing_docs)]
+        querySwap(querySwapCall),
+        #[allow(missing_docs)]
+        vault(vaultCall),
+    }
+    impl BalancerQueriesCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [158u8, 187u8, 240u8, 93u8],
+            [199u8, 178u8, 197u8, 44u8],
+            [233u8, 105u8, 246u8, 179u8],
+            [248u8, 77u8, 6u8, 110u8],
+            [251u8, 250u8, 119u8, 207u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <querySwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryBatchSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <vaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(queryJoin),
+            ::core::stringify!(queryExit),
+            ::core::stringify!(querySwap),
+            ::core::stringify!(queryBatchSwap),
+            ::core::stringify!(vault),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerQueriesCalls {
+        const COUNT: usize = 5usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerQueriesCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::queryBatchSwap(_) => {
+                    <queryBatchSwapCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::querySwap(_) => <querySwapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::vault(_) => <vaultCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls>] = &[
+                {
+                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerQueriesCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerQueriesCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn querySwap(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <querySwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerQueriesCalls::querySwap)
+                    }
+                    querySwap
+                },
+                {
+                    fn queryBatchSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerQueriesCalls::queryBatchSwap)
+                    }
+                    queryBatchSwap
+                },
+                {
+                    fn vault(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerQueriesCalls::vault)
+                    }
+                    vault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerQueriesCalls>] = &[
+                {
+                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerQueriesCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerQueriesCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn querySwap(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <querySwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerQueriesCalls::querySwap)
+                    }
+                    querySwap
+                },
+                {
+                    fn queryBatchSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerQueriesCalls::queryBatchSwap)
+                    }
+                    queryBatchSwap
+                },
+                {
+                    fn vault(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                        <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerQueriesCalls::vault)
+                    }
+                    vault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::queryBatchSwap(inner) => {
+                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::querySwap(inner) => {
+                    <querySwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::vault(inner) => {
+                    <vaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::queryBatchSwap(inner) => {
+                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::querySwap(inner) => {
+                    <querySwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::vault(inner) => {
+                    <vaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerQueries`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerQueriesInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerQueriesInstance<P, N> {
+        BalancerQueriesInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerQueries`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerQueries`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerQueriesInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerQueriesInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerQueriesInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerQueriesInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerQueries`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerQueriesInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerQueriesInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerQueriesInstance<P, N> {
+            BalancerQueriesInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerQueriesInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`queryBatchSwap`] function.
+        pub fn queryBatchSwap(
+            &self,
+            kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            swaps: alloy_sol_types::private::Vec<
+                <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+            >,
+            assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, queryBatchSwapCall, N> {
+            self.call_builder(&queryBatchSwapCall {
+                kind,
+                swaps,
+                assets,
+                funds,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryExit`] function.
+        pub fn queryExit(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
+            self.call_builder(&queryExitCall {
+                poolId,
+                sender,
+                recipient,
+                request,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryJoin`] function.
+        pub fn queryJoin(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
+            self.call_builder(&queryJoinCall {
+                poolId,
+                sender,
+                recipient,
+                request,
+            })
+        }
+
+        ///Creates a new call builder for the [`querySwap`] function.
+        pub fn querySwap(
+            &self,
+            singleSwap: <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
+            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, querySwapCall, N> {
+            self.call_builder(&querySwapCall { singleSwap, funds })
+        }
+
+        ///Creates a new call builder for the [`vault`] function.
+        pub fn vault(&self) -> alloy_contract::SolCallBuilder<&P, vaultCall, N> {
+            self.call_builder(&vaultCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerQueriesInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = BalancerQueries::BalancerQueriesInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5"),
+            Some(15188261u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5"),
+            Some(15288107u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e"),
+            Some(24821845u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5"),
+            Some(30988035u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x300Ab2038EAc391f26D9F895dc61F8F66a548833"),
+            Some(1205869u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5"),
+            Some(18238624u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD"),
+            Some(26387068u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2authorizer/Cargo.toml b/contracts/generated/contracts-generated/balancerv2authorizer/Cargo.toml
new file mode 100644
index 0000000000..39bf9bc97b
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2authorizer/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2authorizer"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs b/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs
new file mode 100644
index 0000000000..d7c9243209
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs
@@ -0,0 +1,3825 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2Authorizer {
+    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
+    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
+    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
+
+    constructor(address admin);
+
+    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);
+    function canPerform(bytes32 actionId, address account, address) external view returns (bool);
+    function getRoleAdmin(bytes32 role) external view returns (bytes32);
+    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
+    function getRoleMemberCount(bytes32 role) external view returns (uint256);
+    function grantRole(bytes32 role, address account) external;
+    function grantRoles(bytes32[] memory roles, address account) external;
+    function grantRolesToMany(bytes32[] memory roles, address[] memory accounts) external;
+    function hasRole(bytes32 role, address account) external view returns (bool);
+    function renounceRole(bytes32 role, address account) external;
+    function revokeRole(bytes32 role, address account) external;
+    function revokeRoles(bytes32[] memory roles, address account) external;
+    function revokeRolesFromMany(bytes32[] memory roles, address[] memory accounts) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "admin",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DEFAULT_ADMIN_ROLE",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "canPerform",
+    "inputs": [
+      {
+        "name": "actionId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRoleAdmin",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRoleMember",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRoleMemberCount",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "grantRole",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "grantRoles",
+    "inputs": [
+      {
+        "name": "roles",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "grantRolesToMany",
+    "inputs": [
+      {
+        "name": "roles",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      },
+      {
+        "name": "accounts",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "hasRole",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "renounceRole",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "revokeRole",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "revokeRoles",
+    "inputs": [
+      {
+        "name": "roles",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "revokeRolesFromMany",
+    "inputs": [
+      {
+        "name": "roles",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      },
+      {
+        "name": "accounts",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "RoleAdminChanged",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "previousAdminRole",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "newAdminRole",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RoleGranted",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RoleRevoked",
+    "inputs": [
+      {
+        "name": "role",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "account",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2Authorizer {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x0E\x1D8\x03\x80a\x0E\x1D\x839\x81\x81\x01`@R` \x81\x10\x15a\x003W`\0\x80\xFD[PQa\0@`\0\x82a\0FV[Pa\x01=V[a\0P\x82\x82a\0TV[PPV[`\0\x82\x81R` \x81\x81R`@\x90\x91 a\0v\x91\x83\x90a\x08\x94a\0\xB7\x82\x1B\x17\x90\x1CV[\x15a\0PW`@Q3\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x84\x90\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r\x90`\0\x90\xA4PPV[`\0a\0\xC3\x83\x83a\x01\x1CV[a\x01\x12WP\x81T`\x01\x80\x82\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x86\x16\x90\x81\x17\x90\x91U\x85T\x90\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x01\x16V[P`\0[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x01\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[a\x0C\xD1\x80a\x01L`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xDFW`\x005`\xE0\x1C\x80c\x98\x83`\xA3\x11a\0\x8CW\x80c\xA7<\xB2\xAB\x11a\0fW\x80c\xA7<\xB2\xAB\x14a\x04KW\x80c\xCA\x15\xC8s\x14a\x05rW\x80c\xD5Gt\x1F\x14a\x05\x8FW\x80c\xFC\xD7b~\x14a\x05\xC8Wa\0\xDFV[\x80c\x98\x83`\xA3\x14a\x03GW\x80c\x9B\xE2\xA8\x84\x14a\x04\x02W\x80c\xA2\x17\xFD\xDF\x14a\x04CWa\0\xDFV[\x80c6V\x8A\xBE\x11a\0\xBDW\x80c6V\x8A\xBE\x14a\x02uW\x80c\x90\x10\xD0|\x14a\x02\xAEW\x80c\x91\xD1HT\x14a\x02\xFAWa\0\xDFV[\x80c\x18\xB2\xCD\xE9\x14a\0\xE4W\x80c$\x8A\x9C\xA3\x14a\x02\rW\x80c//\xF1]\x14a\x02<W[`\0\x80\xFD[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\0\xFAW`\0\x80\xFD[\x81\x01\x90` \x81\x01\x815d\x01\0\0\0\0\x81\x11\x15a\x01\x15W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x01'W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x01IW`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95\x94\x93` \x81\x01\x93P5\x91PPd\x01\0\0\0\0\x81\x11\x15a\x01\x99W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x01\xABW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x01\xCDW`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x06\x83\x94PPPPPV[\0[a\x02*`\x04\x806\x03` \x81\x10\x15a\x02#W`\0\x80\xFD[P5a\x06\xD8V[`@\x80Q\x91\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\x02RW`\0\x80\xFD[P\x805\x90` \x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x06\xEDV[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\x02\x8BW`\0\x80\xFD[P\x805\x90` \x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x07#V[a\x02\xD1`\x04\x806\x03`@\x81\x10\x15a\x02\xC4W`\0\x80\xFD[P\x805\x90` \x015a\x07QV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x033`\x04\x806\x03`@\x81\x10\x15a\x03\x10W`\0\x80\xFD[P\x805\x90` \x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x07rV[`@\x80Q\x91\x15\x15\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\x03]W`\0\x80\xFD[\x81\x01\x90` \x81\x01\x815d\x01\0\0\0\0\x81\x11\x15a\x03xW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\x8AW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03\xACW`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95PPP\x905s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91Pa\x07\x8A\x90PV[a\x033`\x04\x806\x03``\x81\x10\x15a\x04\x18W`\0\x80\xFD[P\x805\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x015\x81\x16\x91`@\x015\x16a\x07\xBBV[a\x02*a\x07\xCFV[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\x04aW`\0\x80\xFD[\x81\x01\x90` \x81\x01\x815d\x01\0\0\0\0\x81\x11\x15a\x04|W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x04\x8EW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\xB0W`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95\x94\x93` \x81\x01\x93P5\x91PPd\x01\0\0\0\0\x81\x11\x15a\x05\0W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\x12W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x054W`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x07\xD4\x94PPPPPV[a\x02*`\x04\x806\x03` \x81\x10\x15a\x05\x88W`\0\x80\xFD[P5a\x08$V[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\x05\xA5W`\0\x80\xFD[P\x805\x90` \x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x08;V[a\x02\x0B`\x04\x806\x03`@\x81\x10\x15a\x05\xDEW`\0\x80\xFD[\x81\x01\x90` \x81\x01\x815d\x01\0\0\0\0\x81\x11\x15a\x05\xF9W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\x0BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x06-W`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95PPP\x905s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91Pa\x08c\x90PV[a\x06\x8F\x82Q\x82Qa\t\x1CV[`\0[\x82Q\x81\x10\x15a\x06\xD3Wa\x06\xCB\x83\x82\x81Q\x81\x10a\x06\xAAW\xFE[` \x02` \x01\x01Q\x83\x83\x81Q\x81\x10a\x06\xBEW\xFE[` \x02` \x01\x01Qa\x08;V[`\x01\x01a\x06\x92V[PPPV[`\0\x90\x81R` \x81\x90R`@\x90 `\x02\x01T\x90V[`\0\x82\x81R` \x81\x90R`@\x90 `\x02\x01Ta\x07\x15\x90a\x07\r\x903a\x07rV[a\x01\xA6a\t%V[a\x07\x1F\x82\x82a\t3V[PPV[a\x07Gs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x163\x14a\x01\xA8a\t%V[a\x07\x1F\x82\x82a\t\x99V[`\0\x82\x81R` \x81\x90R`@\x81 a\x07i\x90\x83a\t\xFFV[\x90P[\x92\x91PPV[`\0\x82\x81R` \x81\x90R`@\x81 a\x07i\x90\x83a\n\x1BV[`\0[\x82Q\x81\x10\x15a\x06\xD3Wa\x07\xB3\x83\x82\x81Q\x81\x10a\x07\xA5W\xFE[` \x02` \x01\x01Q\x83a\x08;V[`\x01\x01a\x07\x8DV[`\0a\x07\xC7\x84\x84a\x07rV[\x94\x93PPPPV[`\0\x81V[a\x07\xE0\x82Q\x82Qa\t\x1CV[`\0[\x82Q\x81\x10\x15a\x06\xD3Wa\x08\x1C\x83\x82\x81Q\x81\x10a\x07\xFBW\xFE[` \x02` \x01\x01Q\x83\x83\x81Q\x81\x10a\x08\x0FW\xFE[` \x02` \x01\x01Qa\x06\xEDV[`\x01\x01a\x07\xE3V[`\0\x81\x81R` \x81\x90R`@\x81 a\x07l\x90a\nIV[`\0\x82\x81R` \x81\x90R`@\x90 `\x02\x01Ta\x07G\x90a\x08[\x903a\x07rV[a\x01\xA7a\t%V[`\0[\x82Q\x81\x10\x15a\x06\xD3Wa\x08\x8C\x83\x82\x81Q\x81\x10a\x08~W\xFE[` \x02` \x01\x01Q\x83a\x06\xEDV[`\x01\x01a\x08fV[`\0a\x08\xA0\x83\x83a\n\x1BV[a\t\x14WP\x81T`\x01\x80\x82\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x90\x81\x17\x90\x91U\x85T\x90\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x07lV[P`\0a\x07lV[a\x07\x1F\x81\x83\x14`g[\x81a\x07\x1FWa\x07\x1F\x81a\nMV[`\0\x82\x81R` \x81\x90R`@\x90 a\tK\x90\x82a\x08\x94V[\x15a\x07\x1FW`@Q3\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90\x84\x90\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r\x90`\0\x90\xA4PPV[`\0\x82\x81R` \x81\x90R`@\x90 a\t\xB1\x90\x82a\n\xBAV[\x15a\x07\x1FW`@Q3\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90\x84\x90\x7F\xF69\x1F\\2\xD9\xC6\x9D*G\xEAg\x0BD)t\xB595\xD1\xED\xC7\xFDd\xEB!\xE0G\xA89\x17\x1B\x90`\0\x90\xA4PPV[\x81T`\0\x90a\n\x11\x90\x83\x10`da\t%V[a\x07i\x83\x83a\x0CaV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\0\x90\x81R`\x01\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[T\x90V[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`\0\x90\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0CWW\x83T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x01\x91\x90\x81\x01\x90`\0\x90\x87\x90\x83\x90\x81\x10a\x0B\"W\xFE[`\0\x91\x82R` \x90\x91 \x01T\x87Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x91P\x81\x90\x88\x90\x85\x90\x81\x10a\x0BXW\xFE[`\0\x91\x82R` \x80\x83 \x91\x90\x91\x01\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16\x17\x90U\x91\x83\x16\x81R`\x01\x89\x81\x01\x90\x92R`@\x90 \x90\x84\x01\x90U\x86T\x87\x90\x80a\x0B\xC6W\xFE[`\0\x82\x81R` \x80\x82 \x83\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x01\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90U\x90\x92\x01\x90\x92Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x82R`\x01\x89\x81\x01\x90\x91R`@\x82 \x91\x90\x91U\x94Pa\x07l\x93PPPPV[`\0\x91PPa\x07lV[`\0\x82`\0\x01\x82\x81T\x81\x10a\x0CrW\xFE[`\0\x91\x82R` \x90\x91 \x01Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \xDF\xE7\x15\xD2\xCDD\xC73\x08\x9F,9k\x8B\xA6\xA9\x1C\xA4\xEC[\x90v2\xF3f\xD4\xD8\xA9\x81JS\xD3dsolcC\0\x07\x01\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RoleAdminChanged(bytes32,bytes32,bytes32)` and selector `0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff`.
+    ```solidity
+    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RoleAdminChanged {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub previousAdminRole: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub newAdminRole: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RoleAdminChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RoleAdminChanged(bytes32,bytes32,bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8, 81u8,
+                    66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8, 71u8, 92u8,
+                    58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    role: topics.1,
+                    previousAdminRole: topics.2,
+                    newAdminRole: topics.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.role.clone(),
+                    self.previousAdminRole.clone(),
+                    self.newAdminRole.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
+                out[2usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.previousAdminRole);
+                out[3usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.newAdminRole);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RoleAdminChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RoleAdminChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RoleAdminChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RoleGranted(bytes32,address,address)` and selector `0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d`.
+    ```solidity
+    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RoleGranted {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RoleGranted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RoleGranted(bytes32,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8, 236u8,
+                    121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8, 64u8, 48u8,
+                    69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    role: topics.1,
+                    account: topics.2,
+                    sender: topics.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.role.clone(),
+                    self.account.clone(),
+                    self.sender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.account,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RoleGranted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RoleGranted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RoleGranted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RoleRevoked(bytes32,address,address)` and selector `0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b`.
+    ```solidity
+    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RoleRevoked {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RoleRevoked {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RoleRevoked(bytes32,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8, 103u8,
+                    11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8, 253u8, 100u8,
+                    235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    role: topics.1,
+                    account: topics.2,
+                    sender: topics.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.role.clone(),
+                    self.account.clone(),
+                    self.sender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.account,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RoleRevoked {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RoleRevoked> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RoleRevoked) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address admin);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub admin: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.admin,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { admin: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.admin,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DEFAULT_ADMIN_ROLE()` and selector `0xa217fddf`.
+    ```solidity
+    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DEFAULT_ADMIN_ROLECall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DEFAULT_ADMIN_ROLE()`](DEFAULT_ADMIN_ROLECall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DEFAULT_ADMIN_ROLEReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DEFAULT_ADMIN_ROLECall> for UnderlyingRustTuple<'_> {
+                fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DEFAULT_ADMIN_ROLECall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DEFAULT_ADMIN_ROLEReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
+            const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DEFAULT_ADMIN_ROLEReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DEFAULT_ADMIN_ROLEReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `canPerform(bytes32,address,address)` and selector `0x9be2a884`.
+    ```solidity
+    function canPerform(bytes32 actionId, address account, address) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct canPerformCall {
+        #[allow(missing_docs)]
+        pub actionId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`canPerform(bytes32,address,address)`](canPerformCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct canPerformReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<canPerformCall> for UnderlyingRustTuple<'_> {
+                fn from(value: canPerformCall) -> Self {
+                    (value.actionId, value.account, value._2)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for canPerformCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        actionId: tuple.0,
+                        account: tuple.1,
+                        _2: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<canPerformReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: canPerformReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for canPerformReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for canPerformCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [155u8, 226u8, 168u8, 132u8];
+            const SIGNATURE: &'static str = "canPerform(bytes32,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.actionId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: canPerformReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: canPerformReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRoleAdmin(bytes32)` and selector `0x248a9ca3`.
+    ```solidity
+    function getRoleAdmin(bytes32 role) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRoleAdminCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRoleAdmin(bytes32)`](getRoleAdminCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRoleAdminReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRoleAdminCall) -> Self {
+                    (value.role,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { role: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRoleAdminReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRoleAdminCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
+            const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRoleAdminReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRoleAdminReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRoleMember(bytes32,uint256)` and selector `0x9010d07c`.
+    ```solidity
+    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRoleMemberCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub index: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRoleMember(bytes32,uint256)`](getRoleMemberCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRoleMemberReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRoleMemberCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRoleMemberCall) -> Self {
+                    (value.role, value.index)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        role: tuple.0,
+                        index: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRoleMemberReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRoleMemberReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRoleMemberCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [144u8, 16u8, 208u8, 124u8];
+            const SIGNATURE: &'static str = "getRoleMember(bytes32,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.index),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRoleMemberReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRoleMemberReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRoleMemberCount(bytes32)` and selector `0xca15c873`.
+    ```solidity
+    function getRoleMemberCount(bytes32 role) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRoleMemberCountCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRoleMemberCount(bytes32)`](getRoleMemberCountCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRoleMemberCountReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRoleMemberCountCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRoleMemberCountCall) -> Self {
+                    (value.role,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCountCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { role: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRoleMemberCountReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRoleMemberCountReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCountReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRoleMemberCountCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [202u8, 21u8, 200u8, 115u8];
+            const SIGNATURE: &'static str = "getRoleMemberCount(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRoleMemberCountReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRoleMemberCountReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `grantRole(bytes32,address)` and selector `0x2f2ff15d`.
+    ```solidity
+    function grantRole(bytes32 role, address account) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct grantRoleCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`grantRole(bytes32,address)`](grantRoleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct grantRoleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRoleCall) -> Self {
+                    (value.role, value.account)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        role: tuple.0,
+                        account: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRoleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl grantRoleReturn {
+            fn _tokenize(&self) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for grantRoleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = grantRoleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
+            const SIGNATURE: &'static str = "grantRole(bytes32,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                grantRoleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `grantRoles(bytes32[],address)` and selector `0xfcd7627e`.
+    ```solidity
+    function grantRoles(bytes32[] memory roles, address account) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct grantRolesCall {
+        #[allow(missing_docs)]
+        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`grantRoles(bytes32[],address)`](grantRolesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct grantRolesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<grantRolesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRolesCall) -> Self {
+                    (value.roles, value.account)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        roles: tuple.0,
+                        account: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<grantRolesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRolesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl grantRolesReturn {
+            fn _tokenize(&self) -> <grantRolesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for grantRolesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = grantRolesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [252u8, 215u8, 98u8, 126u8];
+            const SIGNATURE: &'static str = "grantRoles(bytes32[],address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::FixedBytes<32>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                grantRolesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `grantRolesToMany(bytes32[],address[])` and selector `0xa73cb2ab`.
+    ```solidity
+    function grantRolesToMany(bytes32[] memory roles, address[] memory accounts) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct grantRolesToManyCall {
+        #[allow(missing_docs)]
+        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        #[allow(missing_docs)]
+        pub accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    ///Container type for the return parameters of the
+    /// [`grantRolesToMany(bytes32[],address[])`](grantRolesToManyCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct grantRolesToManyReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<grantRolesToManyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRolesToManyCall) -> Self {
+                    (value.roles, value.accounts)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesToManyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        roles: tuple.0,
+                        accounts: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<grantRolesToManyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRolesToManyReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesToManyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl grantRolesToManyReturn {
+            fn _tokenize(
+                &self,
+            ) -> <grantRolesToManyCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for grantRolesToManyCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return = grantRolesToManyReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [167u8, 60u8, 178u8, 171u8];
+            const SIGNATURE: &'static str = "grantRolesToMany(bytes32[],address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::FixedBytes<32>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.accounts),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                grantRolesToManyReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hasRole(bytes32,address)` and selector `0x91d14854`.
+    ```solidity
+    function hasRole(bytes32 role, address account) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hasRoleCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hasRole(bytes32,address)`](hasRoleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hasRoleReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hasRoleCall) -> Self {
+                    (value.role, value.account)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        role: tuple.0,
+                        account: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hasRoleReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hasRoleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
+            const SIGNATURE: &'static str = "hasRole(bytes32,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hasRoleReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hasRoleReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `renounceRole(bytes32,address)` and selector `0x36568abe`.
+    ```solidity
+    function renounceRole(bytes32 role, address account) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct renounceRoleCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`renounceRole(bytes32,address)`](renounceRoleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct renounceRoleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: renounceRoleCall) -> Self {
+                    (value.role, value.account)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        role: tuple.0,
+                        account: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: renounceRoleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl renounceRoleReturn {
+            fn _tokenize(&self) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for renounceRoleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = renounceRoleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
+            const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                renounceRoleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `revokeRole(bytes32,address)` and selector `0xd547741f`.
+    ```solidity
+    function revokeRole(bytes32 role, address account) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct revokeRoleCall {
+        #[allow(missing_docs)]
+        pub role: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`revokeRole(bytes32,address)`](revokeRoleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct revokeRoleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: revokeRoleCall) -> Self {
+                    (value.role, value.account)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        role: tuple.0,
+                        account: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: revokeRoleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl revokeRoleReturn {
+            fn _tokenize(&self) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for revokeRoleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = revokeRoleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
+            const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                revokeRoleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `revokeRoles(bytes32[],address)` and selector `0x988360a3`.
+    ```solidity
+    function revokeRoles(bytes32[] memory roles, address account) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct revokeRolesCall {
+        #[allow(missing_docs)]
+        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`revokeRoles(bytes32[],address)`](revokeRolesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct revokeRolesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<revokeRolesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: revokeRolesCall) -> Self {
+                    (value.roles, value.account)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        roles: tuple.0,
+                        account: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<revokeRolesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: revokeRolesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl revokeRolesReturn {
+            fn _tokenize(&self) -> <revokeRolesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for revokeRolesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = revokeRolesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [152u8, 131u8, 96u8, 163u8];
+            const SIGNATURE: &'static str = "revokeRoles(bytes32[],address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::FixedBytes<32>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                revokeRolesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `revokeRolesFromMany(bytes32[],address[])` and selector `0x18b2cde9`.
+    ```solidity
+    function revokeRolesFromMany(bytes32[] memory roles, address[] memory accounts) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct revokeRolesFromManyCall {
+        #[allow(missing_docs)]
+        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        #[allow(missing_docs)]
+        pub accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    ///Container type for the return parameters of the
+    /// [`revokeRolesFromMany(bytes32[],address[])`](revokeRolesFromManyCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct revokeRolesFromManyReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<revokeRolesFromManyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: revokeRolesFromManyCall) -> Self {
+                    (value.roles, value.accounts)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesFromManyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        roles: tuple.0,
+                        accounts: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<revokeRolesFromManyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: revokeRolesFromManyReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesFromManyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl revokeRolesFromManyReturn {
+            fn _tokenize(
+                &self,
+            ) -> <revokeRolesFromManyCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for revokeRolesFromManyCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return = revokeRolesFromManyReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 178u8, 205u8, 233u8];
+            const SIGNATURE: &'static str = "revokeRolesFromMany(bytes32[],address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::FixedBytes<32>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.accounts),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                revokeRolesFromManyReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2Authorizer`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2AuthorizerCalls {
+        #[allow(missing_docs)]
+        DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
+        #[allow(missing_docs)]
+        canPerform(canPerformCall),
+        #[allow(missing_docs)]
+        getRoleAdmin(getRoleAdminCall),
+        #[allow(missing_docs)]
+        getRoleMember(getRoleMemberCall),
+        #[allow(missing_docs)]
+        getRoleMemberCount(getRoleMemberCountCall),
+        #[allow(missing_docs)]
+        grantRole(grantRoleCall),
+        #[allow(missing_docs)]
+        grantRoles(grantRolesCall),
+        #[allow(missing_docs)]
+        grantRolesToMany(grantRolesToManyCall),
+        #[allow(missing_docs)]
+        hasRole(hasRoleCall),
+        #[allow(missing_docs)]
+        renounceRole(renounceRoleCall),
+        #[allow(missing_docs)]
+        revokeRole(revokeRoleCall),
+        #[allow(missing_docs)]
+        revokeRoles(revokeRolesCall),
+        #[allow(missing_docs)]
+        revokeRolesFromMany(revokeRolesFromManyCall),
+    }
+    impl BalancerV2AuthorizerCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [24u8, 178u8, 205u8, 233u8],
+            [36u8, 138u8, 156u8, 163u8],
+            [47u8, 47u8, 241u8, 93u8],
+            [54u8, 86u8, 138u8, 190u8],
+            [144u8, 16u8, 208u8, 124u8],
+            [145u8, 209u8, 72u8, 84u8],
+            [152u8, 131u8, 96u8, 163u8],
+            [155u8, 226u8, 168u8, 132u8],
+            [162u8, 23u8, 253u8, 223u8],
+            [167u8, 60u8, 178u8, 171u8],
+            [202u8, 21u8, 200u8, 115u8],
+            [213u8, 71u8, 116u8, 31u8],
+            [252u8, 215u8, 98u8, 126u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <revokeRolesFromManyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRoleAdminCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <grantRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <renounceRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRoleMemberCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hasRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <revokeRolesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <canPerformCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SIGNATURE,
+            <grantRolesToManyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRoleMemberCountCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <revokeRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <grantRolesCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(revokeRolesFromMany),
+            ::core::stringify!(getRoleAdmin),
+            ::core::stringify!(grantRole),
+            ::core::stringify!(renounceRole),
+            ::core::stringify!(getRoleMember),
+            ::core::stringify!(hasRole),
+            ::core::stringify!(revokeRoles),
+            ::core::stringify!(canPerform),
+            ::core::stringify!(DEFAULT_ADMIN_ROLE),
+            ::core::stringify!(grantRolesToMany),
+            ::core::stringify!(getRoleMemberCount),
+            ::core::stringify!(revokeRole),
+            ::core::stringify!(grantRoles),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2AuthorizerCalls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2AuthorizerCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DEFAULT_ADMIN_ROLE(_) => {
+                    <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::canPerform(_) => <canPerformCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRoleAdmin(_) => <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRoleMember(_) => <getRoleMemberCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRoleMemberCount(_) => {
+                    <getRoleMemberCountCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::grantRole(_) => <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::grantRoles(_) => <grantRolesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::grantRolesToMany(_) => {
+                    <grantRolesToManyCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::renounceRole(_) => <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::revokeRole(_) => <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::revokeRoles(_) => <revokeRolesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::revokeRolesFromMany(_) => {
+                    <revokeRolesFromManyCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV2AuthorizerCalls>] = &[
+                {
+                    fn revokeRolesFromMany(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::revokeRolesFromMany)
+                    }
+                    revokeRolesFromMany
+                },
+                {
+                    fn getRoleAdmin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::getRoleAdmin)
+                    }
+                    getRoleAdmin
+                },
+                {
+                    fn grantRole(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::grantRole)
+                    }
+                    grantRole
+                },
+                {
+                    fn renounceRole(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::renounceRole)
+                    }
+                    renounceRole
+                },
+                {
+                    fn getRoleMember(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::getRoleMember)
+                    }
+                    getRoleMember
+                },
+                {
+                    fn hasRole(data: &[u8]) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::hasRole)
+                    }
+                    hasRole
+                },
+                {
+                    fn revokeRoles(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <revokeRolesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::revokeRoles)
+                    }
+                    revokeRoles
+                },
+                {
+                    fn canPerform(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <canPerformCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::canPerform)
+                    }
+                    canPerform
+                },
+                {
+                    fn DEFAULT_ADMIN_ROLE(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::DEFAULT_ADMIN_ROLE)
+                    }
+                    DEFAULT_ADMIN_ROLE
+                },
+                {
+                    fn grantRolesToMany(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::grantRolesToMany)
+                    }
+                    grantRolesToMany
+                },
+                {
+                    fn getRoleMemberCount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::getRoleMemberCount)
+                    }
+                    getRoleMemberCount
+                },
+                {
+                    fn revokeRole(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::revokeRole)
+                    }
+                    revokeRole
+                },
+                {
+                    fn grantRoles(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <grantRolesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2AuthorizerCalls::grantRoles)
+                    }
+                    grantRoles
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2AuthorizerCalls,
+            >] = &[
+                {
+                    fn revokeRolesFromMany(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2AuthorizerCalls::revokeRolesFromMany)
+                    }
+                    revokeRolesFromMany
+                },
+                {
+                    fn getRoleAdmin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2AuthorizerCalls::getRoleAdmin)
+                    }
+                    getRoleAdmin
+                },
+                {
+                    fn grantRole(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2AuthorizerCalls::grantRole)
+                    }
+                    grantRole
+                },
+                {
+                    fn renounceRole(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2AuthorizerCalls::renounceRole)
+                    }
+                    renounceRole
+                },
+                {
+                    fn getRoleMember(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2AuthorizerCalls::getRoleMember)
+                    }
+                    getRoleMember
+                },
+                {
+                    fn hasRole(data: &[u8]) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2AuthorizerCalls::hasRole)
+                    }
+                    hasRole
+                },
+                {
+                    fn revokeRoles(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <revokeRolesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2AuthorizerCalls::revokeRoles)
+                    }
+                    revokeRoles
+                },
+                {
+                    fn canPerform(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <canPerformCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2AuthorizerCalls::canPerform)
+                    }
+                    canPerform
+                },
+                {
+                    fn DEFAULT_ADMIN_ROLE(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2AuthorizerCalls::DEFAULT_ADMIN_ROLE)
+                    }
+                    DEFAULT_ADMIN_ROLE
+                },
+                {
+                    fn grantRolesToMany(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2AuthorizerCalls::grantRolesToMany)
+                    }
+                    grantRolesToMany
+                },
+                {
+                    fn getRoleMemberCount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2AuthorizerCalls::getRoleMemberCount)
+                    }
+                    getRoleMemberCount
+                },
+                {
+                    fn revokeRole(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2AuthorizerCalls::revokeRole)
+                    }
+                    revokeRole
+                },
+                {
+                    fn grantRoles(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
+                        <grantRolesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2AuthorizerCalls::grantRoles)
+                    }
+                    grantRoles
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DEFAULT_ADMIN_ROLE(inner) => {
+                    <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::canPerform(inner) => {
+                    <canPerformCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRoleAdmin(inner) => {
+                    <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRoleMember(inner) => {
+                    <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRoleMemberCount(inner) => {
+                    <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::grantRole(inner) => {
+                    <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::grantRoles(inner) => {
+                    <grantRolesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::grantRolesToMany(inner) => {
+                    <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::hasRole(inner) => {
+                    <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::renounceRole(inner) => {
+                    <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::revokeRole(inner) => {
+                    <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::revokeRoles(inner) => {
+                    <revokeRolesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::revokeRolesFromMany(inner) => {
+                    <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DEFAULT_ADMIN_ROLE(inner) => {
+                    <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::canPerform(inner) => {
+                    <canPerformCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getRoleAdmin(inner) => {
+                    <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getRoleMember(inner) => {
+                    <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getRoleMemberCount(inner) => {
+                    <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::grantRole(inner) => {
+                    <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::grantRoles(inner) => {
+                    <grantRolesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::grantRolesToMany(inner) => {
+                    <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::hasRole(inner) => {
+                    <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::renounceRole(inner) => {
+                    <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::revokeRole(inner) => {
+                    <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::revokeRoles(inner) => {
+                    <revokeRolesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::revokeRolesFromMany(inner) => {
+                    <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2Authorizer`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2AuthorizerEvents {
+        #[allow(missing_docs)]
+        RoleAdminChanged(RoleAdminChanged),
+        #[allow(missing_docs)]
+        RoleGranted(RoleGranted),
+        #[allow(missing_docs)]
+        RoleRevoked(RoleRevoked),
+    }
+    impl BalancerV2AuthorizerEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8, 236u8,
+                121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8, 64u8, 48u8,
+                69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
+            ],
+            [
+                189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8, 81u8,
+                66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8, 71u8, 92u8,
+                58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
+            ],
+            [
+                246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8, 103u8, 11u8,
+                68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8, 253u8, 100u8, 235u8,
+                33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(RoleGranted),
+            ::core::stringify!(RoleAdminChanged),
+            ::core::stringify!(RoleRevoked),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2AuthorizerEvents {
+        const COUNT: usize = 3usize;
+        const NAME: &'static str = "BalancerV2AuthorizerEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::RoleAdminChanged)
+                }
+                Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::RoleGranted)
+                }
+                Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::RoleRevoked)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2AuthorizerEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::RoleAdminChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RoleGranted(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RoleRevoked(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::RoleAdminChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RoleGranted(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RoleRevoked(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2Authorizer`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2AuthorizerInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2AuthorizerInstance<P, N> {
+        BalancerV2AuthorizerInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        admin: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<BalancerV2AuthorizerInstance<P, N>>>
+    {
+        BalancerV2AuthorizerInstance::<P, N>::deploy(__provider, admin)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        admin: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        BalancerV2AuthorizerInstance::<P, N>::deploy_builder(__provider, admin)
+    }
+    /**A [`BalancerV2Authorizer`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2Authorizer`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2AuthorizerInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2AuthorizerInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2AuthorizerInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2AuthorizerInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2Authorizer`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2AuthorizerInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            admin: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<BalancerV2AuthorizerInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, admin);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            admin: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { admin })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2AuthorizerInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2AuthorizerInstance<P, N> {
+            BalancerV2AuthorizerInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2AuthorizerInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DEFAULT_ADMIN_ROLE`] function.
+        pub fn DEFAULT_ADMIN_ROLE(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
+            self.call_builder(&DEFAULT_ADMIN_ROLECall)
+        }
+
+        ///Creates a new call builder for the [`canPerform`] function.
+        pub fn canPerform(
+            &self,
+            actionId: alloy_sol_types::private::FixedBytes<32>,
+            account: alloy_sol_types::private::Address,
+            _2: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, canPerformCall, N> {
+            self.call_builder(&canPerformCall {
+                actionId,
+                account,
+                _2,
+            })
+        }
+
+        ///Creates a new call builder for the [`getRoleAdmin`] function.
+        pub fn getRoleAdmin(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
+            self.call_builder(&getRoleAdminCall { role })
+        }
+
+        ///Creates a new call builder for the [`getRoleMember`] function.
+        pub fn getRoleMember(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+            index: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCall, N> {
+            self.call_builder(&getRoleMemberCall { role, index })
+        }
+
+        ///Creates a new call builder for the [`getRoleMemberCount`] function.
+        pub fn getRoleMemberCount(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCountCall, N> {
+            self.call_builder(&getRoleMemberCountCall { role })
+        }
+
+        ///Creates a new call builder for the [`grantRole`] function.
+        pub fn grantRole(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
+            self.call_builder(&grantRoleCall { role, account })
+        }
+
+        ///Creates a new call builder for the [`grantRoles`] function.
+        pub fn grantRoles(
+            &self,
+            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, grantRolesCall, N> {
+            self.call_builder(&grantRolesCall { roles, account })
+        }
+
+        ///Creates a new call builder for the [`grantRolesToMany`] function.
+        pub fn grantRolesToMany(
+            &self,
+            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+            accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, grantRolesToManyCall, N> {
+            self.call_builder(&grantRolesToManyCall { roles, accounts })
+        }
+
+        ///Creates a new call builder for the [`hasRole`] function.
+        pub fn hasRole(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
+            self.call_builder(&hasRoleCall { role, account })
+        }
+
+        ///Creates a new call builder for the [`renounceRole`] function.
+        pub fn renounceRole(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
+            self.call_builder(&renounceRoleCall { role, account })
+        }
+
+        ///Creates a new call builder for the [`revokeRole`] function.
+        pub fn revokeRole(
+            &self,
+            role: alloy_sol_types::private::FixedBytes<32>,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
+            self.call_builder(&revokeRoleCall { role, account })
+        }
+
+        ///Creates a new call builder for the [`revokeRoles`] function.
+        pub fn revokeRoles(
+            &self,
+            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, revokeRolesCall, N> {
+            self.call_builder(&revokeRolesCall { roles, account })
+        }
+
+        ///Creates a new call builder for the [`revokeRolesFromMany`] function.
+        pub fn revokeRolesFromMany(
+            &self,
+            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+            accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, revokeRolesFromManyCall, N> {
+            self.call_builder(&revokeRolesFromManyCall { roles, accounts })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2AuthorizerInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`RoleAdminChanged`] event.
+        pub fn RoleAdminChanged_filter(&self) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
+            self.event_filter::<RoleAdminChanged>()
+        }
+
+        ///Creates a new event filter for the [`RoleGranted`] event.
+        pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
+            self.event_filter::<RoleGranted>()
+        }
+
+        ///Creates a new event filter for the [`RoleRevoked`] event.
+        pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
+            self.event_filter::<RoleRevoked>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2Authorizer::BalancerV2AuthorizerInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/balancerv2basepool/Cargo.toml b/contracts/generated/contracts-generated/balancerv2basepool/Cargo.toml
new file mode 100644
index 0000000000..747e10839f
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2basepool/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2basepool"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs
new file mode 100644
index 0000000000..498db26ba6
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs
@@ -0,0 +1,6635 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2BasePool {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external pure returns (uint8);
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getOwner() external view returns (address);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getSwapFeePercentage() external view returns (uint256);
+    function getVault() external view returns (address);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
+    function setPaused(bool paused) external;
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapFeePercentage",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onExitPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onJoinPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryExit",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "queryJoin",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setPaused",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setSwapFeePercentage",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2BasePool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external pure returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOwner()` and selector `0x893d20e8`.
+    ```solidity
+    function getOwner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOwner()`](getOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOwnerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
+            const SIGNATURE: &'static str = "getOwner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOwnerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOwnerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    ```solidity
+    function getPoolId() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolId()`](getPoolIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    ```solidity
+    function getSwapFeePercentage() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    ```solidity
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onExitPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onExitPoolReturn {
+            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onExitPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onExitPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
+            const SIGNATURE: &'static str =
+                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onExitPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    ```solidity
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onJoinPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onJoinPoolReturn {
+            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onJoinPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onJoinPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
+            const SIGNATURE: &'static str =
+                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onJoinPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    ```solidity
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryExitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitReturn {
+        #[allow(missing_docs)]
+        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitReturn) -> Self {
+                    (value.bptIn, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptIn: tuple.0,
+                        amountsOut: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryExitReturn {
+            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryExitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryExitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
+            const SIGNATURE: &'static str =
+                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryExitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    ```solidity
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryJoinCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinReturn {
+        #[allow(missing_docs)]
+        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinReturn) -> Self {
+                    (value.bptOut, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptOut: tuple.0,
+                        amountsIn: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryJoinReturn {
+            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryJoinCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryJoinReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
+            const SIGNATURE: &'static str =
+                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryJoinReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    ```solidity
+    function setPaused(bool paused) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedCall {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setPaused(bool)`](setPausedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedCall) -> Self {
+                    (value.paused,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { paused: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setPausedReturn {
+            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setPausedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Return = setPausedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
+            const SIGNATURE: &'static str = "setPaused(bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setPausedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    ```solidity
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageCall {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageCall) -> Self {
+                    (value.swapFeePercentage,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapFeePercentage: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapFeePercentageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = setSwapFeePercentageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
+            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapFeePercentageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2BasePool`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2BasePoolCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getOwner(getOwnerCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPoolId(getPoolIdCall),
+        #[allow(missing_docs)]
+        getSwapFeePercentage(getSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        onExitPool(onExitPoolCall),
+        #[allow(missing_docs)]
+        onJoinPool(onJoinPoolCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        queryExit(queryExitCall),
+        #[allow(missing_docs)]
+        queryJoin(queryJoinCall),
+        #[allow(missing_docs)]
+        setPaused(setPausedCall),
+        #[allow(missing_docs)]
+        setSwapFeePercentage(setSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl BalancerV2BasePoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [22u8, 195u8, 139u8, 60u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [56u8, 233u8, 146u8, 46u8],
+            [56u8, 255u8, 242u8, 208u8],
+            [85u8, 198u8, 118u8, 40u8],
+            [96u8, 40u8, 191u8, 212u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 243u8, 176u8, 9u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [135u8, 236u8, 104u8, 23u8],
+            [137u8, 61u8, 32u8, 232u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [170u8, 171u8, 173u8, 197u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [213u8, 192u8, 150u8, 196u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(setPaused),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(setSwapFeePercentage),
+            ::core::stringify!(getPoolId),
+            ::core::stringify!(getSwapFeePercentage),
+            ::core::stringify!(queryExit),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(onExitPool),
+            ::core::stringify!(nonces),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(queryJoin),
+            ::core::stringify!(getOwner),
+            ::core::stringify!(getVault),
+            ::core::stringify!(symbol),
+            ::core::stringify!(transfer),
+            ::core::stringify!(getAuthorizer),
+            ::core::stringify!(permit),
+            ::core::stringify!(onJoinPool),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2BasePoolCalls {
+        const COUNT: usize = 25usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2BasePoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getSwapFeePercentage(_) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setSwapFeePercentage(_) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV2BasePoolCalls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2BasePoolCalls,
+            >] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2BasePoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2BasePoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2BasePoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2BasePoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2BasePoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2BasePoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2BasePool`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2BasePoolEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        PausedStateChanged(PausedStateChanged),
+        #[allow(missing_docs)]
+        SwapFeePercentageChanged(SwapFeePercentageChanged),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl BalancerV2BasePoolEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+            ],
+            [
+                169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8, 118u8,
+                249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(Approval),
+            ::core::stringify!(PausedStateChanged),
+            ::core::stringify!(SwapFeePercentageChanged),
+            ::core::stringify!(Transfer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2BasePoolEvents {
+        const COUNT: usize = 4usize;
+        const NAME: &'static str = "BalancerV2BasePoolEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PausedStateChanged)
+                }
+                Some(<SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::SwapFeePercentageChanged)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2BasePoolEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2BasePool`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2BasePoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2BasePoolInstance<P, N> {
+        BalancerV2BasePoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2BasePool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2BasePool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2BasePoolInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2BasePoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2BasePoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2BasePoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2BasePool`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2BasePoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2BasePoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2BasePoolInstance<P, N> {
+            BalancerV2BasePoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2BasePoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getOwner`] function.
+        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
+            self.call_builder(&getOwnerCall)
+        }
+
+        ///Creates a new call builder for the [`getPausedState`] function.
+        pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
+            self.call_builder(&getPausedStateCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolId`] function.
+        pub fn getPoolId(&self) -> alloy_contract::SolCallBuilder<&P, getPoolIdCall, N> {
+            self.call_builder(&getPoolIdCall)
+        }
+
+        ///Creates a new call builder for the [`getSwapFeePercentage`]
+        /// function.
+        pub fn getSwapFeePercentage(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getSwapFeePercentageCall, N> {
+            self.call_builder(&getSwapFeePercentageCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`onExitPool`] function.
+        pub fn onExitPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
+            self.call_builder(&onExitPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onJoinPool`] function.
+        pub fn onJoinPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
+            self.call_builder(&onJoinPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryExit`] function.
+        pub fn queryExit(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
+            self.call_builder(&queryExitCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryJoin`] function.
+        pub fn queryJoin(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
+            self.call_builder(&queryJoinCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`setPaused`] function.
+        pub fn setPaused(
+            &self,
+            paused: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
+            self.call_builder(&setPausedCall { paused })
+        }
+
+        ///Creates a new call builder for the [`setSwapFeePercentage`]
+        /// function.
+        pub fn setSwapFeePercentage(
+            &self,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
+            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2BasePoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`PausedStateChanged`] event.
+        pub fn PausedStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PausedStateChanged, N> {
+            self.event_filter::<PausedStateChanged>()
+        }
+
+        ///Creates a new event filter for the [`SwapFeePercentageChanged`]
+        /// event.
+        pub fn SwapFeePercentageChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SwapFeePercentageChanged, N> {
+            self.event_filter::<SwapFeePercentageChanged>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = BalancerV2BasePool::BalancerV2BasePoolInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/balancerv2basepoolfactory/Cargo.toml b/contracts/generated/contracts-generated/balancerv2basepoolfactory/Cargo.toml
new file mode 100644
index 0000000000..c1dae90168
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2basepoolfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2basepoolfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs
new file mode 100644
index 0000000000..02353a218f
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs
@@ -0,0 +1,880 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2BasePoolFactory {
+    event PoolCreated(address indexed pool);
+
+    function getVault() external view returns (address);
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2BasePoolFactory {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2BasePoolFactory`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2BasePoolFactoryCalls {
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+    }
+    impl BalancerV2BasePoolFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[102u8, 52u8, 183u8, 83u8], [141u8, 146u8, 138u8, 248u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(getVault),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2BasePoolFactoryCalls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2BasePoolFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2BasePoolFactoryCalls,
+            >] = &[
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolFactoryCalls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2BasePoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2BasePoolFactoryCalls,
+            >] = &[
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2BasePoolFactoryCalls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2BasePoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2BasePoolFactory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2BasePoolFactoryEvents {
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2BasePoolFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8, 73u8,
+            106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8, 188u8,
+            196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(PoolCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2BasePoolFactoryEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "BalancerV2BasePoolFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2BasePoolFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2BasePoolFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2BasePoolFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2BasePoolFactoryInstance<P, N> {
+        BalancerV2BasePoolFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2BasePoolFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2BasePoolFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2BasePoolFactoryInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2BasePoolFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2BasePoolFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2BasePoolFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2BasePoolFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2BasePoolFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2BasePoolFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2BasePoolFactoryInstance<P, N> {
+            BalancerV2BasePoolFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2BasePoolFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2BasePoolFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2BasePoolFactory::BalancerV2BasePoolFactoryInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepool/Cargo.toml b/contracts/generated/contracts-generated/balancerv2composablestablepool/Cargo.toml
new file mode 100644
index 0000000000..199d8fe5ba
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepool/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2composablestablepool"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs
new file mode 100644
index 0000000000..d01e7a3fb9
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs
@@ -0,0 +1,16090 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ComposableStablePool {
+    struct NewPoolParams { address vault; address protocolFeeProvider; string name; string symbol; address[] tokens; address[] rateProviders; uint256[] tokenRateCacheDurations; bool[] exemptFromYieldProtocolFeeFlags; uint256 amplificationParameter; uint256 swapFeePercentage; uint256 pauseWindowDuration; uint256 bufferPeriodDuration; address owner; string version; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ComposableStablePool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct NewPoolParams { address vault; address protocolFeeProvider; string name; string symbol; address[] tokens; address[] rateProviders; uint256[] tokenRateCacheDurations; bool[] exemptFromYieldProtocolFeeFlags; uint256 amplificationParameter; uint256 swapFeePercentage; uint256 pauseWindowDuration; uint256 bufferPeriodDuration; address owner; string version; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NewPoolParams {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub tokenRateCacheDurations:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub version: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::String,
+            alloy_sol_types::sol_data::String,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::String,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::String,
+            alloy_sol_types::private::String,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            alloy_sol_types::private::Vec<bool>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::String,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NewPoolParams> for UnderlyingRustTuple<'_> {
+            fn from(value: NewPoolParams) -> Self {
+                (
+                    value.vault,
+                    value.protocolFeeProvider,
+                    value.name,
+                    value.symbol,
+                    value.tokens,
+                    value.rateProviders,
+                    value.tokenRateCacheDurations,
+                    value.exemptFromYieldProtocolFeeFlags,
+                    value.amplificationParameter,
+                    value.swapFeePercentage,
+                    value.pauseWindowDuration,
+                    value.bufferPeriodDuration,
+                    value.owner,
+                    value.version,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NewPoolParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    vault: tuple.0,
+                    protocolFeeProvider: tuple.1,
+                    name: tuple.2,
+                    symbol: tuple.3,
+                    tokens: tuple.4,
+                    rateProviders: tuple.5,
+                    tokenRateCacheDurations: tuple.6,
+                    exemptFromYieldProtocolFeeFlags: tuple.7,
+                    amplificationParameter: tuple.8,
+                    swapFeePercentage: tuple.9,
+                    pauseWindowDuration: tuple.10,
+                    bufferPeriodDuration: tuple.11,
+                    owner: tuple.12,
+                    version: tuple.13,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for NewPoolParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for NewPoolParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenRateCacheDurations,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.exemptFromYieldProtocolFeeFlags,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.version,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for NewPoolParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for NewPoolParams {
+            const NAME: &'static str = "NewPoolParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "NewPoolParams(address vault,address protocolFeeProvider,string name,string \
+                     symbol,address[] tokens,address[] rateProviders,uint256[] \
+                     tokenRateCacheDurations,bool[] exemptFromYieldProtocolFeeFlags,uint256 \
+                     amplificationParameter,uint256 swapFeePercentage,uint256 \
+                     pauseWindowDuration,uint256 bufferPeriodDuration,address owner,string \
+                     version)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.vault,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.protocolFeeProvider,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.name,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.symbol,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.tokens)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.rateProviders)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenRateCacheDurations,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.exemptFromYieldProtocolFeeFlags,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.amplificationParameter,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.swapFeePercentage,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.pauseWindowDuration,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.bufferPeriodDuration,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.owner,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.version,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for NewPoolParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.vault,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.protocolFeeProvider,
+                    )
+                    + <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.name,
+                    )
+                    + <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.symbol,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokens,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.rateProviders,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenRateCacheDurations,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.exemptFromYieldProtocolFeeFlags,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amplificationParameter,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.swapFeePercentage,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.pauseWindowDuration,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.bufferPeriodDuration,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.owner,
+                    )
+                    + <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.version,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.vault,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.protocolFeeProvider,
+                    out,
+                );
+                <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.name,
+                    out,
+                );
+                <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.symbol,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokens,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.rateProviders,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenRateCacheDurations,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bool,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.exemptFromYieldProtocolFeeFlags,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amplificationParameter,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.swapFeePercentage,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.pauseWindowDuration,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.bufferPeriodDuration,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.owner,
+                    out,
+                );
+                <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.version,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ComposableStablePool`](self) contract instance.
+
+    See the [wrapper's documentation](`ComposableStablePoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ComposableStablePoolInstance<P, N> {
+        ComposableStablePoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ComposableStablePool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ComposableStablePool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ComposableStablePoolInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ComposableStablePoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ComposableStablePoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ComposableStablePoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ComposableStablePool`](self) contract instance.
+
+        See the [wrapper's documentation](`ComposableStablePoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ComposableStablePoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ComposableStablePoolInstance<P, N> {
+            ComposableStablePoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ComposableStablePoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ComposableStablePoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IPoolSwapStructs {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapRequest {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            IVault::SwapKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapRequest) -> Self {
+                (
+                    value.kind,
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.amount,
+                    value.poolId,
+                    value.lastChangeBlock,
+                    value.from,
+                    value.to,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    kind: tuple.0,
+                    tokenIn: tuple.1,
+                    tokenOut: tuple.2,
+                    amount: tuple.3,
+                    poolId: tuple.4,
+                    lastChangeBlock: tuple.5,
+                    from: tuple.6,
+                    to: tuple.7,
+                    userData: tuple.8,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapRequest {
+            const NAME: &'static str = "SwapRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
+                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
+                     userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.lastChangeBlock,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.from,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.to,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.lastChangeBlock,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.from,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.to,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.lastChangeBlock,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.from,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.to,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IPoolSwapStructsInstance<P, N> {
+        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IPoolSwapStructs`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IPoolSwapStructs`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IPoolSwapStructsInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
+            IPoolSwapStructsInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    type SwapKind is uint8;
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SwapKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SwapKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SwapKind> for u8 {
+            fn from(value: SwapKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library ComposableStablePool {
+    struct NewPoolParams {
+        address vault;
+        address protocolFeeProvider;
+        string name;
+        string symbol;
+        address[] tokens;
+        address[] rateProviders;
+        uint256[] tokenRateCacheDurations;
+        bool[] exemptFromYieldProtocolFeeFlags;
+        uint256 amplificationParameter;
+        uint256 swapFeePercentage;
+        uint256 pauseWindowDuration;
+        uint256 bufferPeriodDuration;
+        address owner;
+        string version;
+    }
+}
+
+library IPoolSwapStructs {
+    struct SwapRequest {
+        IVault.SwapKind kind;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+}
+
+library IVault {
+    type SwapKind is uint8;
+}
+
+interface BalancerV2ComposableStablePool {
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    event AmpUpdateStopped(uint256 currentValue);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event ProtocolFeePercentageCacheUpdated(uint256 indexed feeType, uint256 protocolFeePercentage);
+    event RecoveryModeStateChanged(bool enabled);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
+    event TokenRateProviderSet(uint256 indexed tokenIndex, address indexed provider, uint256 cacheDuration);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(ComposableStablePool.NewPoolParams params);
+
+    function DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL() external view returns (uint256);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+    function disableRecoveryMode() external;
+    function enableRecoveryMode() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getActualSupply() external view returns (uint256);
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    function getAuthorizer() external view returns (address);
+    function getBptIndex() external view returns (uint256);
+    function getDomainSeparator() external view returns (bytes32);
+    function getLastJoinExitData() external view returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
+    function getMinimumBpt() external pure returns (uint256);
+    function getNextNonce(address account) external view returns (uint256);
+    function getOwner() external view returns (address);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
+    function getProtocolFeesCollector() external view returns (address);
+    function getProtocolSwapFeeDelegation() external view returns (bool);
+    function getRate() external view returns (uint256);
+    function getRateProviders() external view returns (address[] memory);
+    function getScalingFactors() external view returns (uint256[] memory);
+    function getSwapFeePercentage() external view returns (uint256);
+    function getTokenRate(address token) external view returns (uint256);
+    function getTokenRateCache(address token) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
+    function getVault() external view returns (address);
+    function inRecoveryMode() external view returns (bool);
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function isTokenExemptFromYieldProtocolFee(address token) external view returns (bool);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external returns (uint256);
+    function pause() external;
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function setTokenRateCacheDuration(address token, uint256 duration) external;
+    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
+    function stopAmplificationParameterUpdate() external;
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    function unpause() external;
+    function updateProtocolFeePercentageCache() external;
+    function updateTokenRateCache(address token) external;
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct ComposableStablePool.NewPoolParams",
+        "components": [
+          {
+            "name": "vault",
+            "type": "address",
+            "internalType": "contract IVault"
+          },
+          {
+            "name": "protocolFeeProvider",
+            "type": "address",
+            "internalType": "contract IProtocolFeePercentagesProvider"
+          },
+          {
+            "name": "name",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "symbol",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "tokens",
+            "type": "address[]",
+            "internalType": "contract IERC20[]"
+          },
+          {
+            "name": "rateProviders",
+            "type": "address[]",
+            "internalType": "contract IRateProvider[]"
+          },
+          {
+            "name": "tokenRateCacheDurations",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          },
+          {
+            "name": "exemptFromYieldProtocolFeeFlags",
+            "type": "bool[]",
+            "internalType": "bool[]"
+          },
+          {
+            "name": "amplificationParameter",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "swapFeePercentage",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "pauseWindowDuration",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "bufferPeriodDuration",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "owner",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "version",
+            "type": "string",
+            "internalType": "string"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decreaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disableRecoveryMode",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "enableRecoveryMode",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getActualSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmplificationParameter",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "isUpdating",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "precision",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getBptIndex",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getDomainSeparator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getLastJoinExitData",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "lastJoinExitAmplification",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "lastPostJoinExitInvariant",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getMinimumBpt",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getNextNonce",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentageCache",
+    "inputs": [
+      {
+        "name": "feeType",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeesCollector",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeesCollector"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolSwapFeeDelegation",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRate",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRateProviders",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getScalingFactors",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapFeePercentage",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getTokenRate",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getTokenRateCache",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "rate",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "oldRate",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "duration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "expires",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "inRecoveryMode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "increaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "addedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isTokenExemptFromYieldProtocolFee",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onExitPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onJoinPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onSwap",
+    "inputs": [
+      {
+        "name": "swapRequest",
+        "type": "tuple",
+        "internalType": "struct IPoolSwapStructs.SwapRequest",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "lastChangeBlock",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "from",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "indexIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "indexOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "pause",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryExit",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryJoin",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setAssetManagerPoolConfig",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "poolConfig",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setSwapFeePercentage",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setTokenRateCacheDuration",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "duration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "startAmplificationParameterUpdate",
+    "inputs": [
+      {
+        "name": "rawEndValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "stopAmplificationParameterUpdate",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "unpause",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "updateProtocolFeePercentageCache",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "updateTokenRateCache",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStarted",
+    "inputs": [
+      {
+        "name": "startValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "startTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStopped",
+    "inputs": [
+      {
+        "name": "currentValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProtocolFeePercentageCacheUpdated",
+    "inputs": [
+      {
+        "name": "feeType",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RecoveryModeStateChanged",
+    "inputs": [
+      {
+        "name": "enabled",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokenRateCacheUpdated",
+    "inputs": [
+      {
+        "name": "tokenIndex",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "rate",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokenRateProviderSet",
+    "inputs": [
+      {
+        "name": "tokenIndex",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "provider",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IRateProvider"
+      },
+      {
+        "name": "cacheDuration",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AmpUpdateStarted(uint256,uint256,uint256,uint256)` and selector `0x1835882ee7a34ac194f717a35e09bb1d24c82a3b9d854ab6c9749525b714cdf2`.
+    ```solidity
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AmpUpdateStarted {
+        #[allow(missing_docs)]
+        pub startValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AmpUpdateStarted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStarted(uint256,uint256,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
+                    94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8,
+                    201u8, 116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    startValue: data.0,
+                    endValue: data.1,
+                    startTime: data.2,
+                    endTime: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endTime,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStarted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStarted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStarted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AmpUpdateStopped(uint256)` and selector `0xa0d01593e47e69d07e0ccd87bece09411e07dd1ed40ca8f2e7af2976542a0233`.
+    ```solidity
+    event AmpUpdateStopped(uint256 currentValue);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AmpUpdateStopped {
+        #[allow(missing_docs)]
+        pub currentValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AmpUpdateStopped {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStopped(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8,
+                    135u8, 190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8,
+                    242u8, 231u8, 175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    currentValue: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.currentValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStopped {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStopped> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStopped) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ProtocolFeePercentageCacheUpdated(uint256,uint256)` and selector `0x6bfb689528fa96ec1ad670ad6d6064be1ae96bfd5d2ee35c837fd0fe0c11959a`.
+    ```solidity
+    event ProtocolFeePercentageCacheUpdated(uint256 indexed feeType, uint256 protocolFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ProtocolFeePercentageCacheUpdated {
+        #[allow(missing_docs)]
+        pub feeType: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ProtocolFeePercentageCacheUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ProtocolFeePercentageCacheUpdated(uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    107u8, 251u8, 104u8, 149u8, 40u8, 250u8, 150u8, 236u8, 26u8, 214u8, 112u8,
+                    173u8, 109u8, 96u8, 100u8, 190u8, 26u8, 233u8, 107u8, 253u8, 93u8, 46u8, 227u8,
+                    92u8, 131u8, 127u8, 208u8, 254u8, 12u8, 17u8, 149u8, 154u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    feeType: topics.1,
+                    protocolFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.feeType.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.feeType);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ProtocolFeePercentageCacheUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ProtocolFeePercentageCacheUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ProtocolFeePercentageCacheUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RecoveryModeStateChanged(bool)` and selector `0xeff3d4d215b42bf0960be9c6d5e05c22cba4df6627a3a523e2acee733b5854c8`.
+    ```solidity
+    event RecoveryModeStateChanged(bool enabled);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RecoveryModeStateChanged {
+        #[allow(missing_docs)]
+        pub enabled: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RecoveryModeStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RecoveryModeStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    239u8, 243u8, 212u8, 210u8, 21u8, 180u8, 43u8, 240u8, 150u8, 11u8, 233u8,
+                    198u8, 213u8, 224u8, 92u8, 34u8, 203u8, 164u8, 223u8, 102u8, 39u8, 163u8,
+                    165u8, 35u8, 226u8, 172u8, 238u8, 115u8, 59u8, 88u8, 84u8, 200u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { enabled: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.enabled,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RecoveryModeStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RecoveryModeStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RecoveryModeStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokenRateCacheUpdated(uint256,uint256)` and selector `0xb77a83204ca282e08dc3a65b0a1ca32ea4e6875c38ef0bf5bf75e52a67354fac`.
+    ```solidity
+    event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokenRateCacheUpdated {
+        #[allow(missing_docs)]
+        pub tokenIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rate: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokenRateCacheUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokenRateCacheUpdated(uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    183u8, 122u8, 131u8, 32u8, 76u8, 162u8, 130u8, 224u8, 141u8, 195u8, 166u8,
+                    91u8, 10u8, 28u8, 163u8, 46u8, 164u8, 230u8, 135u8, 92u8, 56u8, 239u8, 11u8,
+                    245u8, 191u8, 117u8, 229u8, 42u8, 103u8, 53u8, 79u8, 172u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    tokenIndex: topics.1,
+                    rate: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.rate,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.tokenIndex.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenIndex);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokenRateCacheUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokenRateCacheUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokenRateCacheUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokenRateProviderSet(uint256,address,uint256)` and selector `0xdd6d1c9badb346de6925b358a472c937b41698d2632696759e43fd6527feeec4`.
+    ```solidity
+    event TokenRateProviderSet(uint256 indexed tokenIndex, address indexed provider, uint256 cacheDuration);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokenRateProviderSet {
+        #[allow(missing_docs)]
+        pub tokenIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub provider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub cacheDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokenRateProviderSet {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokenRateProviderSet(uint256,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 109u8, 28u8, 155u8, 173u8, 179u8, 70u8, 222u8, 105u8, 37u8, 179u8, 88u8,
+                    164u8, 114u8, 201u8, 55u8, 180u8, 22u8, 152u8, 210u8, 99u8, 38u8, 150u8, 117u8,
+                    158u8, 67u8, 253u8, 101u8, 39u8, 254u8, 238u8, 196u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    tokenIndex: topics.1,
+                    provider: topics.2,
+                    cacheDuration: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.cacheDuration,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.tokenIndex.clone(),
+                    self.provider.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenIndex);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.provider,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokenRateProviderSet {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokenRateProviderSet> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokenRateProviderSet) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(ComposableStablePool.NewPoolParams params);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub params: <ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::RustType,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ComposableStablePool::NewPoolParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (ComposableStablePool::NewPoolParams,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL()` and selector `0xddf4627b`.
+    ```solidity
+    function DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL()`](DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 244u8, 98u8, 123u8];
+            const SIGNATURE: &'static str = "DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    ```solidity
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
+            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disableRecoveryMode()` and selector `0xb7b814fc`.
+    ```solidity
+    function disableRecoveryMode() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableRecoveryModeCall;
+    ///Container type for the return parameters of the
+    /// [`disableRecoveryMode()`](disableRecoveryModeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableRecoveryModeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableRecoveryModeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableRecoveryModeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableRecoveryModeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableRecoveryModeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableRecoveryModeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableRecoveryModeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableRecoveryModeReturn {
+            fn _tokenize(
+                &self,
+            ) -> <disableRecoveryModeCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableRecoveryModeCall {
+            type Parameters<'a> = ();
+            type Return = disableRecoveryModeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [183u8, 184u8, 20u8, 252u8];
+            const SIGNATURE: &'static str = "disableRecoveryMode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableRecoveryModeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `enableRecoveryMode()` and selector `0x54a844ba`.
+    ```solidity
+    function enableRecoveryMode() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableRecoveryModeCall;
+    ///Container type for the return parameters of the
+    /// [`enableRecoveryMode()`](enableRecoveryModeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableRecoveryModeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableRecoveryModeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: enableRecoveryModeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableRecoveryModeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableRecoveryModeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: enableRecoveryModeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableRecoveryModeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl enableRecoveryModeReturn {
+            fn _tokenize(
+                &self,
+            ) -> <enableRecoveryModeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for enableRecoveryModeCall {
+            type Parameters<'a> = ();
+            type Return = enableRecoveryModeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 168u8, 68u8, 186u8];
+            const SIGNATURE: &'static str = "enableRecoveryMode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                enableRecoveryModeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActualSupply()` and selector `0x876f303b`.
+    ```solidity
+    function getActualSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActualSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActualSupply()`](getActualSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActualSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActualSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActualSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActualSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActualSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActualSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActualSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActualSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 111u8, 48u8, 59u8];
+            const SIGNATURE: &'static str = "getActualSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActualSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActualSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmplificationParameter()` and selector `0x6daccffa`.
+    ```solidity
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmplificationParameterCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmplificationParameter()`](getAmplificationParameterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmplificationParameterReturn {
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub isUpdating: bool,
+        #[allow(missing_docs)]
+        pub precision: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmplificationParameterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmplificationParameterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterReturn) -> Self {
+                    (value.value, value.isUpdating, value.precision)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        value: tuple.0,
+                        isUpdating: tuple.1,
+                        precision: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getAmplificationParameterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getAmplificationParameterCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isUpdating,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.precision,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmplificationParameterCall {
+            type Parameters<'a> = ();
+            type Return = getAmplificationParameterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [109u8, 172u8, 207u8, 250u8];
+            const SIGNATURE: &'static str = "getAmplificationParameter()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getAmplificationParameterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getBptIndex()` and selector `0x82687a56`.
+    ```solidity
+    function getBptIndex() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getBptIndexCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getBptIndex()`](getBptIndexCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getBptIndexReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getBptIndexCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getBptIndexCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getBptIndexCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getBptIndexReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getBptIndexReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getBptIndexReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getBptIndexCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [130u8, 104u8, 122u8, 86u8];
+            const SIGNATURE: &'static str = "getBptIndex()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getBptIndexReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getBptIndexReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getDomainSeparator()` and selector `0xed24911d`.
+    ```solidity
+    function getDomainSeparator() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getDomainSeparatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getDomainSeparator()`](getDomainSeparatorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getDomainSeparatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getDomainSeparatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getDomainSeparatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getDomainSeparatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getDomainSeparatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getDomainSeparatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [237u8, 36u8, 145u8, 29u8];
+            const SIGNATURE: &'static str = "getDomainSeparator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getDomainSeparatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getDomainSeparatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getLastJoinExitData()` and selector `0x3c975d51`.
+    ```solidity
+    function getLastJoinExitData() external view returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLastJoinExitDataCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getLastJoinExitData()`](getLastJoinExitDataCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLastJoinExitDataReturn {
+        #[allow(missing_docs)]
+        pub lastJoinExitAmplification: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub lastPostJoinExitInvariant: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLastJoinExitDataCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLastJoinExitDataCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastJoinExitDataCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLastJoinExitDataReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLastJoinExitDataReturn) -> Self {
+                    (
+                        value.lastJoinExitAmplification,
+                        value.lastPostJoinExitInvariant,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastJoinExitDataReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        lastJoinExitAmplification: tuple.0,
+                        lastPostJoinExitInvariant: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getLastJoinExitDataReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getLastJoinExitDataCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.lastJoinExitAmplification,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.lastPostJoinExitInvariant,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLastJoinExitDataCall {
+            type Parameters<'a> = ();
+            type Return = getLastJoinExitDataReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [60u8, 151u8, 93u8, 81u8];
+            const SIGNATURE: &'static str = "getLastJoinExitData()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getLastJoinExitDataReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getMinimumBpt()` and selector `0x04842d4c`.
+    ```solidity
+    function getMinimumBpt() external pure returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMinimumBptCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getMinimumBpt()`](getMinimumBptCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMinimumBptReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMinimumBptCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getMinimumBptCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinimumBptCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMinimumBptReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getMinimumBptReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinimumBptReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getMinimumBptCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [4u8, 132u8, 45u8, 76u8];
+            const SIGNATURE: &'static str = "getMinimumBpt()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getMinimumBptReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getMinimumBptReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getNextNonce(address)` and selector `0x90193b7c`.
+    ```solidity
+    function getNextNonce(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNextNonceCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getNextNonce(address)`](getNextNonceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNextNonceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNextNonceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getNextNonceCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNextNonceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getNextNonceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getNextNonceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [144u8, 25u8, 59u8, 124u8];
+            const SIGNATURE: &'static str = "getNextNonce(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getNextNonceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getNextNonceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOwner()` and selector `0x893d20e8`.
+    ```solidity
+    function getOwner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOwner()`](getOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOwnerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
+            const SIGNATURE: &'static str = "getOwner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOwnerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOwnerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    ```solidity
+    function getPoolId() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolId()`](getPoolIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentageCache(uint256)` and selector `0x70464016`.
+    ```solidity
+    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentageCacheCall {
+        #[allow(missing_docs)]
+        pub feeType: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentageCache(uint256)`](getProtocolFeePercentageCacheCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentageCacheReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentageCacheCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentageCacheCall) -> Self {
+                    (value.feeType,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentageCacheCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { feeType: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentageCacheReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentageCacheReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentageCacheReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentageCacheCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 70u8, 64u8, 22u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentageCache(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeType,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentageCacheReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentageCacheReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeesCollector()` and selector `0xd2946c2b`.
+    ```solidity
+    function getProtocolFeesCollector() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeesCollectorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeesCollector()`](getProtocolFeesCollectorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeesCollectorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeesCollectorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeesCollectorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeesCollectorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeesCollectorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeesCollectorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 148u8, 108u8, 43u8];
+            const SIGNATURE: &'static str = "getProtocolFeesCollector()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeesCollectorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeesCollectorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolSwapFeeDelegation()` and selector `0x15b0015b`.
+    ```solidity
+    function getProtocolSwapFeeDelegation() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolSwapFeeDelegationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolSwapFeeDelegation()`](getProtocolSwapFeeDelegationCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolSwapFeeDelegationReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolSwapFeeDelegationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolSwapFeeDelegationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolSwapFeeDelegationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolSwapFeeDelegationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolSwapFeeDelegationReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolSwapFeeDelegationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolSwapFeeDelegationCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [21u8, 176u8, 1u8, 91u8];
+            const SIGNATURE: &'static str = "getProtocolSwapFeeDelegation()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolSwapFeeDelegationReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolSwapFeeDelegationReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRate()` and selector `0x679aefce`.
+    ```solidity
+    function getRate() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRate()`](getRateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRateCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
+            const SIGNATURE: &'static str = "getRate()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRateReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRateReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRateProviders()` and selector `0x238a2d59`.
+    ```solidity
+    function getRateProviders() external view returns (address[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateProvidersCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRateProviders()`](getRateProvidersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateProvidersReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateProvidersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateProvidersCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateProvidersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateProvidersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateProvidersReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateProvidersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRateProvidersCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 138u8, 45u8, 89u8];
+            const SIGNATURE: &'static str = "getRateProviders()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRateProvidersReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRateProvidersReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getScalingFactors()` and selector `0x1dd746ea`.
+    ```solidity
+    function getScalingFactors() external view returns (uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getScalingFactorsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getScalingFactors()`](getScalingFactorsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getScalingFactorsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getScalingFactorsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getScalingFactorsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getScalingFactorsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [29u8, 215u8, 70u8, 234u8];
+            const SIGNATURE: &'static str = "getScalingFactors()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getScalingFactorsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getScalingFactorsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    ```solidity
+    function getSwapFeePercentage() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTokenRate(address)` and selector `0x54dea00a`.
+    ```solidity
+    function getTokenRate(address token) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTokenRateCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTokenRate(address)`](getTokenRateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTokenRateReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTokenRateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTokenRateCall) -> Self {
+                    (value.token,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { token: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTokenRateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTokenRateReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTokenRateCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 222u8, 160u8, 10u8];
+            const SIGNATURE: &'static str = "getTokenRate(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getTokenRateReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getTokenRateReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTokenRateCache(address)` and selector `0x7f1260d1`.
+    ```solidity
+    function getTokenRateCache(address token) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTokenRateCacheCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTokenRateCache(address)`](getTokenRateCacheCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTokenRateCacheReturn {
+        #[allow(missing_docs)]
+        pub rate: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub oldRate: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub duration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub expires: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTokenRateCacheCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTokenRateCacheCall) -> Self {
+                    (value.token,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateCacheCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { token: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTokenRateCacheReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTokenRateCacheReturn) -> Self {
+                    (value.rate, value.oldRate, value.duration, value.expires)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateCacheReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        rate: tuple.0,
+                        oldRate: tuple.1,
+                        duration: tuple.2,
+                        expires: tuple.3,
+                    }
+                }
+            }
+        }
+        impl getTokenRateCacheReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getTokenRateCacheCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.rate,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.oldRate,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.duration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.expires,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTokenRateCacheCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = getTokenRateCacheReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 18u8, 96u8, 209u8];
+            const SIGNATURE: &'static str = "getTokenRateCache(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getTokenRateCacheReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `inRecoveryMode()` and selector `0xb35056b8`.
+    ```solidity
+    function inRecoveryMode() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct inRecoveryModeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`inRecoveryMode()`](inRecoveryModeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct inRecoveryModeReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<inRecoveryModeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: inRecoveryModeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for inRecoveryModeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<inRecoveryModeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: inRecoveryModeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for inRecoveryModeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for inRecoveryModeCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [179u8, 80u8, 86u8, 184u8];
+            const SIGNATURE: &'static str = "inRecoveryMode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: inRecoveryModeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: inRecoveryModeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    ```solidity
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceCall) -> Self {
+                    (value.spender, value.addedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        addedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
+            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.addedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isTokenExemptFromYieldProtocolFee(address)` and selector `0xab7759f1`.
+    ```solidity
+    function isTokenExemptFromYieldProtocolFee(address token) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isTokenExemptFromYieldProtocolFeeCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isTokenExemptFromYieldProtocolFee(address)`](isTokenExemptFromYieldProtocolFeeCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isTokenExemptFromYieldProtocolFeeReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isTokenExemptFromYieldProtocolFeeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isTokenExemptFromYieldProtocolFeeCall) -> Self {
+                    (value.token,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isTokenExemptFromYieldProtocolFeeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { token: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isTokenExemptFromYieldProtocolFeeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isTokenExemptFromYieldProtocolFeeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isTokenExemptFromYieldProtocolFeeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isTokenExemptFromYieldProtocolFeeCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [171u8, 119u8, 89u8, 241u8];
+            const SIGNATURE: &'static str = "isTokenExemptFromYieldProtocolFee(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isTokenExemptFromYieldProtocolFeeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isTokenExemptFromYieldProtocolFeeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    ```solidity
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onExitPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onExitPoolReturn {
+            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onExitPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onExitPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
+            const SIGNATURE: &'static str =
+                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onExitPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    ```solidity
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onJoinPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onJoinPoolReturn {
+            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onJoinPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onJoinPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
+            const SIGNATURE: &'static str =
+                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onJoinPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256[],uint256,uint256)` and selector `0x01ec954a`.
+    ```solidity
+    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwapCall {
+        #[allow(missing_docs)]
+        pub swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub indexIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub indexOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
+    /// bytes),uint256[],uint256,uint256)`](onSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwapCall) -> Self {
+                    (
+                        value.swapRequest,
+                        value.balances,
+                        value.indexIn,
+                        value.indexOut,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapRequest: tuple.0,
+                        balances: tuple.1,
+                        indexIn: tuple.2,
+                        indexOut: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onSwapCall {
+            type Parameters<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [1u8, 236u8, 149u8, 74u8];
+            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
+                                             uint256,address,address,bytes),uint256[],uint256,\
+                                             uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.swapRequest,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.indexIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.indexOut),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onSwapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onSwapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `pause()` and selector `0x8456cb59`.
+    ```solidity
+    function pause() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct pauseCall;
+    ///Container type for the return parameters of the [`pause()`](pauseCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct pauseReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
+                fn from(value: pauseCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: pauseReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl pauseReturn {
+            fn _tokenize(&self) -> <pauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for pauseCall {
+            type Parameters<'a> = ();
+            type Return = pauseReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [132u8, 86u8, 203u8, 89u8];
+            const SIGNATURE: &'static str = "pause()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                pauseReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    ```solidity
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryExitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitReturn {
+        #[allow(missing_docs)]
+        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitReturn) -> Self {
+                    (value.bptIn, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptIn: tuple.0,
+                        amountsOut: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryExitReturn {
+            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryExitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryExitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
+            const SIGNATURE: &'static str =
+                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryExitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    ```solidity
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryJoinCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinReturn {
+        #[allow(missing_docs)]
+        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinReturn) -> Self {
+                    (value.bptOut, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptOut: tuple.0,
+                        amountsIn: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryJoinReturn {
+            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryJoinCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryJoinReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
+            const SIGNATURE: &'static str =
+                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryJoinReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setAssetManagerPoolConfig(address,bytes)` and selector `0x50dd6ed9`.
+    ```solidity
+    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAssetManagerPoolConfigCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub poolConfig: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`setAssetManagerPoolConfig(address,
+    /// bytes)`](setAssetManagerPoolConfigCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAssetManagerPoolConfigReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAssetManagerPoolConfigCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setAssetManagerPoolConfigCall) -> Self {
+                    (value.token, value.poolConfig)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        poolConfig: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAssetManagerPoolConfigReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setAssetManagerPoolConfigReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setAssetManagerPoolConfigReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setAssetManagerPoolConfigCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = setAssetManagerPoolConfigReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [80u8, 221u8, 110u8, 217u8];
+            const SIGNATURE: &'static str = "setAssetManagerPoolConfig(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.poolConfig,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setAssetManagerPoolConfigReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    ```solidity
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageCall {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageCall) -> Self {
+                    (value.swapFeePercentage,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapFeePercentage: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapFeePercentageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = setSwapFeePercentageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
+            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapFeePercentageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setTokenRateCacheDuration(address,uint256)` and selector `0xf4b7964d`.
+    ```solidity
+    function setTokenRateCacheDuration(address token, uint256 duration) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setTokenRateCacheDurationCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub duration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`setTokenRateCacheDuration(address,
+    /// uint256)`](setTokenRateCacheDurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setTokenRateCacheDurationReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setTokenRateCacheDurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setTokenRateCacheDurationCall) -> Self {
+                    (value.token, value.duration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTokenRateCacheDurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        duration: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setTokenRateCacheDurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setTokenRateCacheDurationReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTokenRateCacheDurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setTokenRateCacheDurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setTokenRateCacheDurationCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = setTokenRateCacheDurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [244u8, 183u8, 150u8, 77u8];
+            const SIGNATURE: &'static str = "setTokenRateCacheDuration(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.duration,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setTokenRateCacheDurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `startAmplificationParameterUpdate(uint256,uint256)` and selector `0x2f1a0bc9`.
+    ```solidity
+    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct startAmplificationParameterUpdateCall {
+        #[allow(missing_docs)]
+        pub rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`startAmplificationParameterUpdate(uint256,
+    /// uint256)`](startAmplificationParameterUpdateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct startAmplificationParameterUpdateReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<startAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: startAmplificationParameterUpdateCall) -> Self {
+                    (value.rawEndValue, value.endTime)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        rawEndValue: tuple.0,
+                        endTime: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<startAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: startAmplificationParameterUpdateReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl startAmplificationParameterUpdateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for startAmplificationParameterUpdateCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = startAmplificationParameterUpdateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 26u8, 11u8, 201u8];
+            const SIGNATURE: &'static str = "startAmplificationParameterUpdate(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.rawEndValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endTime,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                startAmplificationParameterUpdateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `stopAmplificationParameterUpdate()` and selector `0xeb0f24d6`.
+    ```solidity
+    function stopAmplificationParameterUpdate() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct stopAmplificationParameterUpdateCall;
+    ///Container type for the return parameters of the
+    /// [`stopAmplificationParameterUpdate()`](stopAmplificationParameterUpdateCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct stopAmplificationParameterUpdateReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<stopAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: stopAmplificationParameterUpdateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<stopAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: stopAmplificationParameterUpdateReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl stopAmplificationParameterUpdateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for stopAmplificationParameterUpdateCall {
+            type Parameters<'a> = ();
+            type Return = stopAmplificationParameterUpdateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [235u8, 15u8, 36u8, 214u8];
+            const SIGNATURE: &'static str = "stopAmplificationParameterUpdate()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                stopAmplificationParameterUpdateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `unpause()` and selector `0x3f4ba83a`.
+    ```solidity
+    function unpause() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct unpauseCall;
+    ///Container type for the return parameters of the
+    /// [`unpause()`](unpauseCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct unpauseReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<unpauseCall> for UnderlyingRustTuple<'_> {
+                fn from(value: unpauseCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<unpauseReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: unpauseReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl unpauseReturn {
+            fn _tokenize(&self) -> <unpauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for unpauseCall {
+            type Parameters<'a> = ();
+            type Return = unpauseReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 75u8, 168u8, 58u8];
+            const SIGNATURE: &'static str = "unpause()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                unpauseReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `updateProtocolFeePercentageCache()` and selector `0x0da0669c`.
+    ```solidity
+    function updateProtocolFeePercentageCache() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateProtocolFeePercentageCacheCall;
+    ///Container type for the return parameters of the
+    /// [`updateProtocolFeePercentageCache()`](updateProtocolFeePercentageCacheCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateProtocolFeePercentageCacheReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateProtocolFeePercentageCacheCall> for UnderlyingRustTuple<'_> {
+                fn from(value: updateProtocolFeePercentageCacheCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateProtocolFeePercentageCacheCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateProtocolFeePercentageCacheReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: updateProtocolFeePercentageCacheReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateProtocolFeePercentageCacheReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl updateProtocolFeePercentageCacheReturn {
+            fn _tokenize(
+                &self,
+            ) -> <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for updateProtocolFeePercentageCacheCall {
+            type Parameters<'a> = ();
+            type Return = updateProtocolFeePercentageCacheReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 160u8, 102u8, 156u8];
+            const SIGNATURE: &'static str = "updateProtocolFeePercentageCache()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                updateProtocolFeePercentageCacheReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `updateTokenRateCache(address)` and selector `0x2df2c7c0`.
+    ```solidity
+    function updateTokenRateCache(address token) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateTokenRateCacheCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`updateTokenRateCache(address)`](updateTokenRateCacheCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateTokenRateCacheReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateTokenRateCacheCall> for UnderlyingRustTuple<'_> {
+                fn from(value: updateTokenRateCacheCall) -> Self {
+                    (value.token,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateTokenRateCacheCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { token: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateTokenRateCacheReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: updateTokenRateCacheReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateTokenRateCacheReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl updateTokenRateCacheReturn {
+            fn _tokenize(
+                &self,
+            ) -> <updateTokenRateCacheCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for updateTokenRateCacheCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = updateTokenRateCacheReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 242u8, 199u8, 192u8];
+            const SIGNATURE: &'static str = "updateTokenRateCache(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                updateTokenRateCacheReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePool`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolCalls {
+        #[allow(missing_docs)]
+        DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall),
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        decreaseAllowance(decreaseAllowanceCall),
+        #[allow(missing_docs)]
+        disableRecoveryMode(disableRecoveryModeCall),
+        #[allow(missing_docs)]
+        enableRecoveryMode(enableRecoveryModeCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getActualSupply(getActualSupplyCall),
+        #[allow(missing_docs)]
+        getAmplificationParameter(getAmplificationParameterCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getBptIndex(getBptIndexCall),
+        #[allow(missing_docs)]
+        getDomainSeparator(getDomainSeparatorCall),
+        #[allow(missing_docs)]
+        getLastJoinExitData(getLastJoinExitDataCall),
+        #[allow(missing_docs)]
+        getMinimumBpt(getMinimumBptCall),
+        #[allow(missing_docs)]
+        getNextNonce(getNextNonceCall),
+        #[allow(missing_docs)]
+        getOwner(getOwnerCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPoolId(getPoolIdCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentageCache(getProtocolFeePercentageCacheCall),
+        #[allow(missing_docs)]
+        getProtocolFeesCollector(getProtocolFeesCollectorCall),
+        #[allow(missing_docs)]
+        getProtocolSwapFeeDelegation(getProtocolSwapFeeDelegationCall),
+        #[allow(missing_docs)]
+        getRate(getRateCall),
+        #[allow(missing_docs)]
+        getRateProviders(getRateProvidersCall),
+        #[allow(missing_docs)]
+        getScalingFactors(getScalingFactorsCall),
+        #[allow(missing_docs)]
+        getSwapFeePercentage(getSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        getTokenRate(getTokenRateCall),
+        #[allow(missing_docs)]
+        getTokenRateCache(getTokenRateCacheCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        inRecoveryMode(inRecoveryModeCall),
+        #[allow(missing_docs)]
+        increaseAllowance(increaseAllowanceCall),
+        #[allow(missing_docs)]
+        isTokenExemptFromYieldProtocolFee(isTokenExemptFromYieldProtocolFeeCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        onExitPool(onExitPoolCall),
+        #[allow(missing_docs)]
+        onJoinPool(onJoinPoolCall),
+        #[allow(missing_docs)]
+        onSwap(onSwapCall),
+        #[allow(missing_docs)]
+        pause(pauseCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        queryExit(queryExitCall),
+        #[allow(missing_docs)]
+        queryJoin(queryJoinCall),
+        #[allow(missing_docs)]
+        setAssetManagerPoolConfig(setAssetManagerPoolConfigCall),
+        #[allow(missing_docs)]
+        setSwapFeePercentage(setSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        setTokenRateCacheDuration(setTokenRateCacheDurationCall),
+        #[allow(missing_docs)]
+        startAmplificationParameterUpdate(startAmplificationParameterUpdateCall),
+        #[allow(missing_docs)]
+        stopAmplificationParameterUpdate(stopAmplificationParameterUpdateCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+        #[allow(missing_docs)]
+        unpause(unpauseCall),
+        #[allow(missing_docs)]
+        updateProtocolFeePercentageCache(updateProtocolFeePercentageCacheCall),
+        #[allow(missing_docs)]
+        updateTokenRateCache(updateTokenRateCacheCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [1u8, 236u8, 149u8, 74u8],
+            [4u8, 132u8, 45u8, 76u8],
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [13u8, 160u8, 102u8, 156u8],
+            [21u8, 176u8, 1u8, 91u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [29u8, 215u8, 70u8, 234u8],
+            [35u8, 138u8, 45u8, 89u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [45u8, 242u8, 199u8, 192u8],
+            [47u8, 26u8, 11u8, 201u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [56u8, 233u8, 146u8, 46u8],
+            [56u8, 255u8, 242u8, 208u8],
+            [57u8, 80u8, 147u8, 81u8],
+            [60u8, 151u8, 93u8, 81u8],
+            [63u8, 75u8, 168u8, 58u8],
+            [80u8, 221u8, 110u8, 217u8],
+            [84u8, 168u8, 68u8, 186u8],
+            [84u8, 222u8, 160u8, 10u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [85u8, 198u8, 118u8, 40u8],
+            [96u8, 40u8, 191u8, 212u8],
+            [103u8, 154u8, 239u8, 206u8],
+            [109u8, 172u8, 207u8, 250u8],
+            [112u8, 70u8, 64u8, 22u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 243u8, 176u8, 9u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [127u8, 18u8, 96u8, 209u8],
+            [130u8, 104u8, 122u8, 86u8],
+            [132u8, 86u8, 203u8, 89u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [135u8, 111u8, 48u8, 59u8],
+            [135u8, 236u8, 104u8, 23u8],
+            [137u8, 61u8, 32u8, 232u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [144u8, 25u8, 59u8, 124u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [164u8, 87u8, 194u8, 215u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [170u8, 171u8, 173u8, 197u8],
+            [171u8, 119u8, 89u8, 241u8],
+            [179u8, 80u8, 86u8, 184u8],
+            [183u8, 184u8, 20u8, 252u8],
+            [210u8, 148u8, 108u8, 43u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [213u8, 192u8, 150u8, 196u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [221u8, 244u8, 98u8, 123u8],
+            [235u8, 15u8, 36u8, 214u8],
+            [237u8, 36u8, 145u8, 29u8],
+            [244u8, 183u8, 150u8, 77u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <onSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getMinimumBptCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getScalingFactorsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRateProvidersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <updateTokenRateCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getLastJoinExitDataCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <unpauseCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <enableRecoveryModeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTokenRateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmplificationParameterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTokenRateCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getBptIndexCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <pauseCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActualSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getNextNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <inRecoveryModeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableRecoveryModeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getDomainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(onSwap),
+            ::core::stringify!(getMinimumBpt),
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(updateProtocolFeePercentageCache),
+            ::core::stringify!(getProtocolSwapFeeDelegation),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(getScalingFactors),
+            ::core::stringify!(getRateProviders),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(updateTokenRateCache),
+            ::core::stringify!(startAmplificationParameterUpdate),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(setSwapFeePercentage),
+            ::core::stringify!(getPoolId),
+            ::core::stringify!(increaseAllowance),
+            ::core::stringify!(getLastJoinExitData),
+            ::core::stringify!(unpause),
+            ::core::stringify!(setAssetManagerPoolConfig),
+            ::core::stringify!(enableRecoveryMode),
+            ::core::stringify!(getTokenRate),
+            ::core::stringify!(version),
+            ::core::stringify!(getSwapFeePercentage),
+            ::core::stringify!(queryExit),
+            ::core::stringify!(getRate),
+            ::core::stringify!(getAmplificationParameter),
+            ::core::stringify!(getProtocolFeePercentageCache),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(onExitPool),
+            ::core::stringify!(nonces),
+            ::core::stringify!(getTokenRateCache),
+            ::core::stringify!(getBptIndex),
+            ::core::stringify!(pause),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getActualSupply),
+            ::core::stringify!(queryJoin),
+            ::core::stringify!(getOwner),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getNextNonce),
+            ::core::stringify!(symbol),
+            ::core::stringify!(decreaseAllowance),
+            ::core::stringify!(transfer),
+            ::core::stringify!(getAuthorizer),
+            ::core::stringify!(isTokenExemptFromYieldProtocolFee),
+            ::core::stringify!(inRecoveryMode),
+            ::core::stringify!(disableRecoveryMode),
+            ::core::stringify!(getProtocolFeesCollector),
+            ::core::stringify!(permit),
+            ::core::stringify!(onJoinPool),
+            ::core::stringify!(allowance),
+            ::core::stringify!(DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL),
+            ::core::stringify!(stopAmplificationParameterUpdate),
+            ::core::stringify!(getDomainSeparator),
+            ::core::stringify!(setTokenRateCacheDuration),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolCalls {
+        const COUNT: usize = 56usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(_) => {
+                    <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseAllowance(_) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::disableRecoveryMode(_) => {
+                    <disableRecoveryModeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::enableRecoveryMode(_) => {
+                    <enableRecoveryModeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActualSupply(_) => {
+                    <getActualSupplyCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmplificationParameter(_) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getBptIndex(_) => <getBptIndexCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getDomainSeparator(_) => {
+                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getLastJoinExitData(_) => {
+                    <getLastJoinExitDataCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getMinimumBpt(_) => <getMinimumBptCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getNextNonce(_) => <getNextNonceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getProtocolFeePercentageCache(_) => {
+                    <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeesCollector(_) => {
+                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolSwapFeeDelegation(_) => {
+                    <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRateProviders(_) => {
+                    <getRateProvidersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getScalingFactors(_) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getSwapFeePercentage(_) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getTokenRate(_) => <getTokenRateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getTokenRateCache(_) => {
+                    <getTokenRateCacheCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::inRecoveryMode(_) => {
+                    <inRecoveryModeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::increaseAllowance(_) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isTokenExemptFromYieldProtocolFee(_) => {
+                    <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onSwap(_) => <onSwapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setAssetManagerPoolConfig(_) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setSwapFeePercentage(_) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setTokenRateCacheDuration(_) => {
+                    <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::startAmplificationParameterUpdate(_) => {
+                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::stopAmplificationParameterUpdate(_) => {
+                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::updateProtocolFeePercentageCache(_) => {
+                    <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::updateTokenRateCache(_) => {
+                    <updateTokenRateCacheCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolCalls,
+            >] = &[
+                {
+                    fn onSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::onSwap)
+                    }
+                    onSwap
+                },
+                {
+                    fn getMinimumBpt(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getMinimumBptCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getMinimumBpt)
+                    }
+                    getMinimumBpt
+                },
+                {
+                    fn name(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn updateProtocolFeePercentageCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::updateProtocolFeePercentageCache,
+                            )
+                    }
+                    updateProtocolFeePercentageCache
+                },
+                {
+                    fn getProtocolSwapFeeDelegation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getProtocolSwapFeeDelegation,
+                            )
+                    }
+                    getProtocolSwapFeeDelegation
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn getScalingFactors(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getScalingFactors)
+                    }
+                    getScalingFactors
+                },
+                {
+                    fn getRateProviders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getRateProvidersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getRateProviders)
+                    }
+                    getRateProviders
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn updateTokenRateCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::updateTokenRateCache)
+                    }
+                    updateTokenRateCache
+                },
+                {
+                    fn startAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::startAmplificationParameterUpdate,
+                            )
+                    }
+                    startAmplificationParameterUpdate
+                },
+                {
+                    fn decimals(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn getLastJoinExitData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getLastJoinExitData)
+                    }
+                    getLastJoinExitData
+                },
+                {
+                    fn unpause(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::unpause)
+                    }
+                    unpause
+                },
+                {
+                    fn setAssetManagerPoolConfig(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::setAssetManagerPoolConfig)
+                    }
+                    setAssetManagerPoolConfig
+                },
+                {
+                    fn enableRecoveryMode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::enableRecoveryMode)
+                    }
+                    enableRecoveryMode
+                },
+                {
+                    fn getTokenRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getTokenRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getTokenRate)
+                    }
+                    getTokenRate
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::version)
+                    }
+                    version
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn getRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn getAmplificationParameter(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getAmplificationParameter)
+                    }
+                    getAmplificationParameter
+                },
+                {
+                    fn getProtocolFeePercentageCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getProtocolFeePercentageCache,
+                            )
+                    }
+                    getProtocolFeePercentageCache
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getTokenRateCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getTokenRateCache)
+                    }
+                    getTokenRateCache
+                },
+                {
+                    fn getBptIndex(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getBptIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getBptIndex)
+                    }
+                    getBptIndex
+                },
+                {
+                    fn pause(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::pause)
+                    }
+                    pause
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getActualSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getActualSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getActualSupply)
+                    }
+                    getActualSupply
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getNextNonce(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getNextNonce)
+                    }
+                    getNextNonce
+                },
+                {
+                    fn symbol(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn isTokenExemptFromYieldProtocolFee(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::isTokenExemptFromYieldProtocolFee,
+                            )
+                    }
+                    isTokenExemptFromYieldProtocolFee
+                },
+                {
+                    fn inRecoveryMode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::inRecoveryMode)
+                    }
+                    inRecoveryMode
+                },
+                {
+                    fn disableRecoveryMode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::disableRecoveryMode)
+                    }
+                    disableRecoveryMode
+                },
+                {
+                    fn getProtocolFeesCollector(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getProtocolFeesCollector)
+                    }
+                    getProtocolFeesCollector
+                },
+                {
+                    fn permit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL,
+                            )
+                    }
+                    DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL
+                },
+                {
+                    fn stopAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::stopAmplificationParameterUpdate,
+                            )
+                    }
+                    stopAmplificationParameterUpdate
+                },
+                {
+                    fn getDomainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getDomainSeparator)
+                    }
+                    getDomainSeparator
+                },
+                {
+                    fn setTokenRateCacheDuration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::setTokenRateCacheDuration)
+                    }
+                    setTokenRateCacheDuration
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolCalls,
+            >] = &[
+                {
+                    fn onSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::onSwap)
+                    }
+                    onSwap
+                },
+                {
+                    fn getMinimumBpt(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getMinimumBptCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getMinimumBpt)
+                    }
+                    getMinimumBpt
+                },
+                {
+                    fn name(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn updateProtocolFeePercentageCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::updateProtocolFeePercentageCache,
+                            )
+                    }
+                    updateProtocolFeePercentageCache
+                },
+                {
+                    fn getProtocolSwapFeeDelegation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getProtocolSwapFeeDelegation,
+                            )
+                    }
+                    getProtocolSwapFeeDelegation
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn getScalingFactors(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::getScalingFactors)
+                    }
+                    getScalingFactors
+                },
+                {
+                    fn getRateProviders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getRateProvidersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getRateProviders)
+                    }
+                    getRateProviders
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn updateTokenRateCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::updateTokenRateCache,
+                            )
+                    }
+                    updateTokenRateCache
+                },
+                {
+                    fn startAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::startAmplificationParameterUpdate,
+                            )
+                    }
+                    startAmplificationParameterUpdate
+                },
+                {
+                    fn decimals(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::setSwapFeePercentage,
+                            )
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn getLastJoinExitData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getLastJoinExitData,
+                            )
+                    }
+                    getLastJoinExitData
+                },
+                {
+                    fn unpause(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::unpause)
+                    }
+                    unpause
+                },
+                {
+                    fn setAssetManagerPoolConfig(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::setAssetManagerPoolConfig,
+                            )
+                    }
+                    setAssetManagerPoolConfig
+                },
+                {
+                    fn enableRecoveryMode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::enableRecoveryMode)
+                    }
+                    enableRecoveryMode
+                },
+                {
+                    fn getTokenRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getTokenRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getTokenRate)
+                    }
+                    getTokenRate
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::version)
+                    }
+                    version
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getSwapFeePercentage,
+                            )
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn getRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn getAmplificationParameter(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getAmplificationParameter,
+                            )
+                    }
+                    getAmplificationParameter
+                },
+                {
+                    fn getProtocolFeePercentageCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getProtocolFeePercentageCache,
+                            )
+                    }
+                    getProtocolFeePercentageCache
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getTokenRateCache(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::getTokenRateCache)
+                    }
+                    getTokenRateCache
+                },
+                {
+                    fn getBptIndex(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getBptIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getBptIndex)
+                    }
+                    getBptIndex
+                },
+                {
+                    fn pause(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::pause)
+                    }
+                    pause
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getActualSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getActualSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getActualSupply)
+                    }
+                    getActualSupply
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getNextNonce(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getNextNonce)
+                    }
+                    getNextNonce
+                },
+                {
+                    fn symbol(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn isTokenExemptFromYieldProtocolFee(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::isTokenExemptFromYieldProtocolFee,
+                            )
+                    }
+                    isTokenExemptFromYieldProtocolFee
+                },
+                {
+                    fn inRecoveryMode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::inRecoveryMode)
+                    }
+                    inRecoveryMode
+                },
+                {
+                    fn disableRecoveryMode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::disableRecoveryMode,
+                            )
+                    }
+                    disableRecoveryMode
+                },
+                {
+                    fn getProtocolFeesCollector(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::getProtocolFeesCollector,
+                            )
+                    }
+                    getProtocolFeesCollector
+                },
+                {
+                    fn permit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL,
+                            )
+                    }
+                    DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL
+                },
+                {
+                    fn stopAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::stopAmplificationParameterUpdate,
+                            )
+                    }
+                    stopAmplificationParameterUpdate
+                },
+                {
+                    fn getDomainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::getDomainSeparator)
+                    }
+                    getDomainSeparator
+                },
+                {
+                    fn setTokenRateCacheDuration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
+                    {
+                        <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolCalls::setTokenRateCacheDuration,
+                            )
+                    }
+                    setTokenRateCacheDuration
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(inner) => {
+                    <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::disableRecoveryMode(inner) => {
+                    <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::enableRecoveryMode(inner) => {
+                    <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getActualSupply(inner) => {
+                    <getActualSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmplificationParameter(inner) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getBptIndex(inner) => {
+                    <getBptIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getDomainSeparator(inner) => {
+                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getLastJoinExitData(inner) => {
+                    <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getMinimumBpt(inner) => {
+                    <getMinimumBptCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getNextNonce(inner) => {
+                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getProtocolFeePercentageCache(inner) => {
+                    <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeesCollector(inner) => {
+                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolSwapFeeDelegation(inner) => {
+                    <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRateProviders(inner) => {
+                    <getRateProvidersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getScalingFactors(inner) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTokenRate(inner) => {
+                    <getTokenRateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTokenRateCache(inner) => {
+                    <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::inRecoveryMode(inner) => {
+                    <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isTokenExemptFromYieldProtocolFee(inner) => {
+                    <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onSwap(inner) => {
+                    <onSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::pause(inner) => {
+                    <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setAssetManagerPoolConfig(inner) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setTokenRateCacheDuration(inner) => {
+                    <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::startAmplificationParameterUpdate(inner) => {
+                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::stopAmplificationParameterUpdate(inner) => {
+                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::unpause(inner) => {
+                    <unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::updateProtocolFeePercentageCache(inner) => {
+                    <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::updateTokenRateCache(inner) => {
+                    <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(inner) => {
+                    <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::disableRecoveryMode(inner) => {
+                    <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::enableRecoveryMode(inner) => {
+                    <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getActualSupply(inner) => {
+                    <getActualSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmplificationParameter(inner) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getBptIndex(inner) => {
+                    <getBptIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getDomainSeparator(inner) => {
+                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getLastJoinExitData(inner) => {
+                    <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getMinimumBpt(inner) => {
+                    <getMinimumBptCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getNextNonce(inner) => {
+                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentageCache(inner) => {
+                    <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeesCollector(inner) => {
+                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolSwapFeeDelegation(inner) => {
+                    <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getRateProviders(inner) => {
+                    <getRateProvidersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getScalingFactors(inner) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getTokenRate(inner) => {
+                    <getTokenRateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getTokenRateCache(inner) => {
+                    <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::inRecoveryMode(inner) => {
+                    <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isTokenExemptFromYieldProtocolFee(inner) => {
+                    <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onSwap(inner) => {
+                    <onSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::pause(inner) => {
+                    <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setAssetManagerPoolConfig(inner) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setTokenRateCacheDuration(inner) => {
+                    <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::startAmplificationParameterUpdate(inner) => {
+                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::stopAmplificationParameterUpdate(inner) => {
+                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::unpause(inner) => {
+                    <unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::updateProtocolFeePercentageCache(inner) => {
+                    <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::updateTokenRateCache(inner) => {
+                    <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2ComposableStablePool`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2ComposableStablePoolEvents {
+        #[allow(missing_docs)]
+        AmpUpdateStarted(AmpUpdateStarted),
+        #[allow(missing_docs)]
+        AmpUpdateStopped(AmpUpdateStopped),
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        PausedStateChanged(PausedStateChanged),
+        #[allow(missing_docs)]
+        ProtocolFeePercentageCacheUpdated(ProtocolFeePercentageCacheUpdated),
+        #[allow(missing_docs)]
+        RecoveryModeStateChanged(RecoveryModeStateChanged),
+        #[allow(missing_docs)]
+        SwapFeePercentageChanged(SwapFeePercentageChanged),
+        #[allow(missing_docs)]
+        TokenRateCacheUpdated(TokenRateCacheUpdated),
+        #[allow(missing_docs)]
+        TokenRateProviderSet(TokenRateProviderSet),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl BalancerV2ComposableStablePoolEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
+                94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8, 201u8,
+                116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
+            ],
+            [
+                107u8, 251u8, 104u8, 149u8, 40u8, 250u8, 150u8, 236u8, 26u8, 214u8, 112u8, 173u8,
+                109u8, 96u8, 100u8, 190u8, 26u8, 233u8, 107u8, 253u8, 93u8, 46u8, 227u8, 92u8,
+                131u8, 127u8, 208u8, 254u8, 12u8, 17u8, 149u8, 154u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+            ],
+            [
+                160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8, 135u8,
+                190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8, 242u8, 231u8,
+                175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
+            ],
+            [
+                169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8, 118u8,
+                249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+            ],
+            [
+                183u8, 122u8, 131u8, 32u8, 76u8, 162u8, 130u8, 224u8, 141u8, 195u8, 166u8, 91u8,
+                10u8, 28u8, 163u8, 46u8, 164u8, 230u8, 135u8, 92u8, 56u8, 239u8, 11u8, 245u8,
+                191u8, 117u8, 229u8, 42u8, 103u8, 53u8, 79u8, 172u8,
+            ],
+            [
+                221u8, 109u8, 28u8, 155u8, 173u8, 179u8, 70u8, 222u8, 105u8, 37u8, 179u8, 88u8,
+                164u8, 114u8, 201u8, 55u8, 180u8, 22u8, 152u8, 210u8, 99u8, 38u8, 150u8, 117u8,
+                158u8, 67u8, 253u8, 101u8, 39u8, 254u8, 238u8, 196u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+            [
+                239u8, 243u8, 212u8, 210u8, 21u8, 180u8, 43u8, 240u8, 150u8, 11u8, 233u8, 198u8,
+                213u8, 224u8, 92u8, 34u8, 203u8, 164u8, 223u8, 102u8, 39u8, 163u8, 165u8, 35u8,
+                226u8, 172u8, 238u8, 115u8, 59u8, 88u8, 84u8, 200u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <AmpUpdateStarted as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ProtocolFeePercentageCacheUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <AmpUpdateStopped as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TokenRateCacheUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TokenRateProviderSet as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RecoveryModeStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(AmpUpdateStarted),
+            ::core::stringify!(ProtocolFeePercentageCacheUpdated),
+            ::core::stringify!(Approval),
+            ::core::stringify!(PausedStateChanged),
+            ::core::stringify!(AmpUpdateStopped),
+            ::core::stringify!(SwapFeePercentageChanged),
+            ::core::stringify!(TokenRateCacheUpdated),
+            ::core::stringify!(TokenRateProviderSet),
+            ::core::stringify!(Transfer),
+            ::core::stringify!(RecoveryModeStateChanged),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2ComposableStablePoolEvents {
+        const COUNT: usize = 10usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<AmpUpdateStarted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <AmpUpdateStarted as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::AmpUpdateStarted)
+                }
+                Some(<AmpUpdateStopped as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <AmpUpdateStopped as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::AmpUpdateStopped)
+                }
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::PausedStateChanged)
+                }
+                Some(
+                    <ProtocolFeePercentageCacheUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <ProtocolFeePercentageCacheUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::ProtocolFeePercentageCacheUpdated)
+                }
+                Some(
+                    <RecoveryModeStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <RecoveryModeStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::RecoveryModeStateChanged)
+                }
+                Some(
+                    <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::SwapFeePercentageChanged)
+                }
+                Some(
+                    <TokenRateCacheUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <TokenRateCacheUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::TokenRateCacheUpdated)
+                }
+                Some(
+                    <TokenRateProviderSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <TokenRateProviderSet as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::TokenRateProviderSet)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => {
+                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                        log: alloy_sol_types::private::Box::new(
+                            alloy_sol_types::private::LogData::new_unchecked(
+                                topics.to_vec(),
+                                data.to_vec().into(),
+                            ),
+                        ),
+                    })
+                }
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2ComposableStablePoolEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AmpUpdateStarted(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::AmpUpdateStopped(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ProtocolFeePercentageCacheUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RecoveryModeStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TokenRateCacheUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TokenRateProviderSet(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AmpUpdateStarted(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::AmpUpdateStopped(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ProtocolFeePercentageCacheUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RecoveryModeStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TokenRateCacheUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TokenRateProviderSet(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePool`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2ComposableStablePoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2ComposableStablePoolInstance<P, N> {
+        BalancerV2ComposableStablePoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2ComposableStablePool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2ComposableStablePool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2ComposableStablePoolInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2ComposableStablePoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2ComposableStablePoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePool`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2ComposableStablePoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2ComposableStablePoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2ComposableStablePoolInstance<P, N> {
+            BalancerV2ComposableStablePoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the
+        /// [`DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL`] function.
+        pub fn DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall, N>
+        {
+            self.call_builder(&DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`decreaseAllowance`] function.
+        pub fn decreaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
+            self.call_builder(&decreaseAllowanceCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`disableRecoveryMode`] function.
+        pub fn disableRecoveryMode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, disableRecoveryModeCall, N> {
+            self.call_builder(&disableRecoveryModeCall)
+        }
+
+        ///Creates a new call builder for the [`enableRecoveryMode`] function.
+        pub fn enableRecoveryMode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, enableRecoveryModeCall, N> {
+            self.call_builder(&enableRecoveryModeCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getActualSupply`] function.
+        pub fn getActualSupply(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getActualSupplyCall, N> {
+            self.call_builder(&getActualSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`getAmplificationParameter`]
+        /// function.
+        pub fn getAmplificationParameter(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmplificationParameterCall, N> {
+            self.call_builder(&getAmplificationParameterCall)
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getBptIndex`] function.
+        pub fn getBptIndex(&self) -> alloy_contract::SolCallBuilder<&P, getBptIndexCall, N> {
+            self.call_builder(&getBptIndexCall)
+        }
+
+        ///Creates a new call builder for the [`getDomainSeparator`] function.
+        pub fn getDomainSeparator(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getDomainSeparatorCall, N> {
+            self.call_builder(&getDomainSeparatorCall)
+        }
+
+        ///Creates a new call builder for the [`getLastJoinExitData`] function.
+        pub fn getLastJoinExitData(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getLastJoinExitDataCall, N> {
+            self.call_builder(&getLastJoinExitDataCall)
+        }
+
+        ///Creates a new call builder for the [`getMinimumBpt`] function.
+        pub fn getMinimumBpt(&self) -> alloy_contract::SolCallBuilder<&P, getMinimumBptCall, N> {
+            self.call_builder(&getMinimumBptCall)
+        }
+
+        ///Creates a new call builder for the [`getNextNonce`] function.
+        pub fn getNextNonce(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getNextNonceCall, N> {
+            self.call_builder(&getNextNonceCall { account })
+        }
+
+        ///Creates a new call builder for the [`getOwner`] function.
+        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
+            self.call_builder(&getOwnerCall)
+        }
+
+        ///Creates a new call builder for the [`getPausedState`] function.
+        pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
+            self.call_builder(&getPausedStateCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolId`] function.
+        pub fn getPoolId(&self) -> alloy_contract::SolCallBuilder<&P, getPoolIdCall, N> {
+            self.call_builder(&getPoolIdCall)
+        }
+
+        ///Creates a new call builder for the [`getProtocolFeePercentageCache`]
+        /// function.
+        pub fn getProtocolFeePercentageCache(
+            &self,
+            feeType: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentageCacheCall, N> {
+            self.call_builder(&getProtocolFeePercentageCacheCall { feeType })
+        }
+
+        ///Creates a new call builder for the [`getProtocolFeesCollector`]
+        /// function.
+        pub fn getProtocolFeesCollector(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeesCollectorCall, N> {
+            self.call_builder(&getProtocolFeesCollectorCall)
+        }
+
+        ///Creates a new call builder for the [`getProtocolSwapFeeDelegation`]
+        /// function.
+        pub fn getProtocolSwapFeeDelegation(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolSwapFeeDelegationCall, N> {
+            self.call_builder(&getProtocolSwapFeeDelegationCall)
+        }
+
+        ///Creates a new call builder for the [`getRate`] function.
+        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
+            self.call_builder(&getRateCall)
+        }
+
+        ///Creates a new call builder for the [`getRateProviders`] function.
+        pub fn getRateProviders(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getRateProvidersCall, N> {
+            self.call_builder(&getRateProvidersCall)
+        }
+
+        ///Creates a new call builder for the [`getScalingFactors`] function.
+        pub fn getScalingFactors(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getScalingFactorsCall, N> {
+            self.call_builder(&getScalingFactorsCall)
+        }
+
+        ///Creates a new call builder for the [`getSwapFeePercentage`]
+        /// function.
+        pub fn getSwapFeePercentage(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getSwapFeePercentageCall, N> {
+            self.call_builder(&getSwapFeePercentageCall)
+        }
+
+        ///Creates a new call builder for the [`getTokenRate`] function.
+        pub fn getTokenRate(
+            &self,
+            token: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getTokenRateCall, N> {
+            self.call_builder(&getTokenRateCall { token })
+        }
+
+        ///Creates a new call builder for the [`getTokenRateCache`] function.
+        pub fn getTokenRateCache(
+            &self,
+            token: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getTokenRateCacheCall, N> {
+            self.call_builder(&getTokenRateCacheCall { token })
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`inRecoveryMode`] function.
+        pub fn inRecoveryMode(&self) -> alloy_contract::SolCallBuilder<&P, inRecoveryModeCall, N> {
+            self.call_builder(&inRecoveryModeCall)
+        }
+
+        ///Creates a new call builder for the [`increaseAllowance`] function.
+        pub fn increaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
+            self.call_builder(&increaseAllowanceCall {
+                spender,
+                addedValue,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`isTokenExemptFromYieldProtocolFee`] function.
+        pub fn isTokenExemptFromYieldProtocolFee(
+            &self,
+            token: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isTokenExemptFromYieldProtocolFeeCall, N> {
+            self.call_builder(&isTokenExemptFromYieldProtocolFeeCall { token })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`onExitPool`] function.
+        pub fn onExitPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
+            self.call_builder(&onExitPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onJoinPool`] function.
+        pub fn onJoinPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
+            self.call_builder(&onJoinPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onSwap`] function.
+        pub fn onSwap(
+            &self,
+            swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            indexIn: alloy_sol_types::private::primitives::aliases::U256,
+            indexOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, onSwapCall, N> {
+            self.call_builder(&onSwapCall {
+                swapRequest,
+                balances,
+                indexIn,
+                indexOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`pause`] function.
+        pub fn pause(&self) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> {
+            self.call_builder(&pauseCall)
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryExit`] function.
+        pub fn queryExit(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
+            self.call_builder(&queryExitCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryJoin`] function.
+        pub fn queryJoin(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
+            self.call_builder(&queryJoinCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`setAssetManagerPoolConfig`]
+        /// function.
+        pub fn setAssetManagerPoolConfig(
+            &self,
+            token: alloy_sol_types::private::Address,
+            poolConfig: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, setAssetManagerPoolConfigCall, N> {
+            self.call_builder(&setAssetManagerPoolConfigCall { token, poolConfig })
+        }
+
+        ///Creates a new call builder for the [`setSwapFeePercentage`]
+        /// function.
+        pub fn setSwapFeePercentage(
+            &self,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
+            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
+        }
+
+        ///Creates a new call builder for the [`setTokenRateCacheDuration`]
+        /// function.
+        pub fn setTokenRateCacheDuration(
+            &self,
+            token: alloy_sol_types::private::Address,
+            duration: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, setTokenRateCacheDurationCall, N> {
+            self.call_builder(&setTokenRateCacheDurationCall { token, duration })
+        }
+
+        ///Creates a new call builder for the
+        /// [`startAmplificationParameterUpdate`] function.
+        pub fn startAmplificationParameterUpdate(
+            &self,
+            rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
+            endTime: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, startAmplificationParameterUpdateCall, N> {
+            self.call_builder(&startAmplificationParameterUpdateCall {
+                rawEndValue,
+                endTime,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`stopAmplificationParameterUpdate`] function.
+        pub fn stopAmplificationParameterUpdate(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, stopAmplificationParameterUpdateCall, N> {
+            self.call_builder(&stopAmplificationParameterUpdateCall)
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+
+        ///Creates a new call builder for the [`unpause`] function.
+        pub fn unpause(&self) -> alloy_contract::SolCallBuilder<&P, unpauseCall, N> {
+            self.call_builder(&unpauseCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`updateProtocolFeePercentageCache`] function.
+        pub fn updateProtocolFeePercentageCache(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, updateProtocolFeePercentageCacheCall, N> {
+            self.call_builder(&updateProtocolFeePercentageCacheCall)
+        }
+
+        ///Creates a new call builder for the [`updateTokenRateCache`]
+        /// function.
+        pub fn updateTokenRateCache(
+            &self,
+            token: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, updateTokenRateCacheCall, N> {
+            self.call_builder(&updateTokenRateCacheCall { token })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`AmpUpdateStarted`] event.
+        pub fn AmpUpdateStarted_filter(&self) -> alloy_contract::Event<&P, AmpUpdateStarted, N> {
+            self.event_filter::<AmpUpdateStarted>()
+        }
+
+        ///Creates a new event filter for the [`AmpUpdateStopped`] event.
+        pub fn AmpUpdateStopped_filter(&self) -> alloy_contract::Event<&P, AmpUpdateStopped, N> {
+            self.event_filter::<AmpUpdateStopped>()
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`PausedStateChanged`] event.
+        pub fn PausedStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PausedStateChanged, N> {
+            self.event_filter::<PausedStateChanged>()
+        }
+
+        ///Creates a new event filter for the
+        /// [`ProtocolFeePercentageCacheUpdated`] event.
+        pub fn ProtocolFeePercentageCacheUpdated_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ProtocolFeePercentageCacheUpdated, N> {
+            self.event_filter::<ProtocolFeePercentageCacheUpdated>()
+        }
+
+        ///Creates a new event filter for the [`RecoveryModeStateChanged`]
+        /// event.
+        pub fn RecoveryModeStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, RecoveryModeStateChanged, N> {
+            self.event_filter::<RecoveryModeStateChanged>()
+        }
+
+        ///Creates a new event filter for the [`SwapFeePercentageChanged`]
+        /// event.
+        pub fn SwapFeePercentageChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SwapFeePercentageChanged, N> {
+            self.event_filter::<SwapFeePercentageChanged>()
+        }
+
+        ///Creates a new event filter for the [`TokenRateCacheUpdated`] event.
+        pub fn TokenRateCacheUpdated_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, TokenRateCacheUpdated, N> {
+            self.event_filter::<TokenRateCacheUpdated>()
+        }
+
+        ///Creates a new event filter for the [`TokenRateProviderSet`] event.
+        pub fn TokenRateProviderSet_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, TokenRateProviderSet, N> {
+            self.event_filter::<TokenRateProviderSet>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = BalancerV2ComposableStablePool::BalancerV2ComposableStablePoolInstance<
+    ::alloy_provider::DynProvider,
+>;
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/Cargo.toml b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/Cargo.toml
new file mode 100644
index 0000000000..144fe8647d
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2composablestablepoolfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs
new file mode 100644
index 0000000000..77caaadb81
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs
@@ -0,0 +1,3590 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2ComposableStablePoolFactory {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "tokenRateCacheDurations",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "exemptFromYieldProtocolFeeFlags",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ComposableStablePool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePoolFactory {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256,address[],uint256[],bool[],uint256,address)` and selector `0x66b59f6c`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub tokenRateCacheDurations:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256,address[],uint256[],bool[],
+    /// uint256,address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<bool>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.rateProviders,
+                        value.tokenRateCacheDurations,
+                        value.exemptFromYieldProtocolFeeFlags,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        amplificationParameter: tuple.3,
+                        rateProviders: tuple.4,
+                        tokenRateCacheDurations: tuple.5,
+                        exemptFromYieldProtocolFeeFlags: tuple.6,
+                        swapFeePercentage: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 181u8, 159u8, 108u8];
+            const SIGNATURE: &'static str = "create(string,string,address[],uint256,address[],\
+                                             uint256[],bool[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenRateCacheDurations,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.exemptFromYieldProtocolFeeFlags,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePoolFactory`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolFactoryCalls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [102u8, 181u8, 159u8, 108u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(create),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryCalls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryCalls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryCalls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryCalls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryCalls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryCalls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryCalls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryCalls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryCalls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryCalls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryCalls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryCalls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2ComposableStablePoolFactory`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2ComposableStablePoolFactoryEvents {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2ComposableStablePoolFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2ComposableStablePoolFactoryEvents {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2ComposableStablePoolFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2ComposableStablePoolFactoryInstance<P, N> {
+        BalancerV2ComposableStablePoolFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2ComposableStablePoolFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2ComposableStablePoolFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2ComposableStablePoolFactoryInstance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2ComposableStablePoolFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2ComposableStablePoolFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2ComposableStablePoolFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2ComposableStablePoolFactoryInstance<P, N> {
+            BalancerV2ComposableStablePoolFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            tokenRateCacheDurations: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                amplificationParameter,
+                rateProviders,
+                tokenRateCacheDurations,
+                exemptFromYieldProtocolFeeFlags,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2ComposableStablePoolFactory::BalancerV2ComposableStablePoolFactoryInstance<
+        ::alloy_provider::DynProvider,
+    >;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xf9ac7B9dF2b3454E841110CcE5550bD5AC6f875F"),
+            Some(15485885u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xf145caFB67081895EE80eB7c04A30Cf87f07b745"),
+            Some(22182522u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xf302f9F50958c5593770FDf4d4812309fF77414f"),
+            Some(22691193u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x136FD06Fa01eCF624C7F2B3CB15742c1339dC2c4"),
+            Some(32774224u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xaEb406b0E430BF5Ea2Dc0B9Fe62E4E53f74B3a33"),
+            Some(23227044u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/Cargo.toml b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/Cargo.toml
new file mode 100644
index 0000000000..f205ae2f71
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2composablestablepoolfactoryv3"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs
new file mode 100644
index 0000000000..1d100bd34e
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs
@@ -0,0 +1,3594 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2ComposableStablePoolFactoryV3 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "tokenRateCacheDurations",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "exemptFromYieldProtocolFeeFlags",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ComposableStablePool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePoolFactoryV3 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256,address[],uint256[],bool[],uint256,address)` and selector `0x66b59f6c`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub tokenRateCacheDurations:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256,address[],uint256[],bool[],
+    /// uint256,address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<bool>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.rateProviders,
+                        value.tokenRateCacheDurations,
+                        value.exemptFromYieldProtocolFeeFlags,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        amplificationParameter: tuple.3,
+                        rateProviders: tuple.4,
+                        tokenRateCacheDurations: tuple.5,
+                        exemptFromYieldProtocolFeeFlags: tuple.6,
+                        swapFeePercentage: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 181u8, 159u8, 108u8];
+            const SIGNATURE: &'static str = "create(string,string,address[],uint256,address[],\
+                                             uint256[],bool[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenRateCacheDurations,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.exemptFromYieldProtocolFeeFlags,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV3`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolFactoryV3Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV3Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [102u8, 181u8, 159u8, 108u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(create),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV3Calls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV3Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV3Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV3Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV3Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV3Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV3Calls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV3Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV3`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2ComposableStablePoolFactoryV3Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV3Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2ComposableStablePoolFactoryV3Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV3Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2ComposableStablePoolFactoryV3Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV3`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV3Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2ComposableStablePoolFactoryV3Instance<P, N> {
+        BalancerV2ComposableStablePoolFactoryV3Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2ComposableStablePoolFactoryV3`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2ComposableStablePoolFactoryV3`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2ComposableStablePoolFactoryV3Instance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2ComposableStablePoolFactoryV3Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2ComposableStablePoolFactoryV3Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV3Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV3`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV3Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2ComposableStablePoolFactoryV3Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2ComposableStablePoolFactoryV3Instance<P, N> {
+            BalancerV2ComposableStablePoolFactoryV3Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV3Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            tokenRateCacheDurations: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                amplificationParameter,
+                rateProviders,
+                tokenRateCacheDurations,
+                exemptFromYieldProtocolFeeFlags,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV3Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2ComposableStablePoolFactoryV3::BalancerV2ComposableStablePoolFactoryV3Instance<
+        ::alloy_provider::DynProvider,
+    >;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xdba127fBc23fb20F5929C546af220A991b5C6e01"),
+            Some(16580899u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xe2E901AB09f37884BA31622dF3Ca7FC19AA443Be"),
+            Some(72832821u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xacAaC3e6D6Df918Bf3c809DFC7d42de0e4a72d4C"),
+            Some(25475700u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD"),
+            Some(26365805u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x7bc6C0E73EDAa66eF3F6E2f27b0EE8661834c6C9"),
+            Some(39037615u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x1c99324EDC771c82A0DCCB780CC7DDA0045E50e7"),
+            Some(58948370u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/Cargo.toml b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/Cargo.toml
new file mode 100644
index 0000000000..c3a2a63457
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2composablestablepoolfactoryv4"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs
new file mode 100644
index 0000000000..41b335c50f
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs
@@ -0,0 +1,3602 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2ComposableStablePoolFactoryV4 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "tokenRateCacheDurations",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "exemptFromYieldProtocolFeeFlags",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ComposableStablePool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePoolFactoryV4 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256,address[],uint256[],bool[],uint256,address)` and selector `0x66b59f6c`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub tokenRateCacheDurations:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256,address[],uint256[],bool[],
+    /// uint256,address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<bool>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.rateProviders,
+                        value.tokenRateCacheDurations,
+                        value.exemptFromYieldProtocolFeeFlags,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        amplificationParameter: tuple.3,
+                        rateProviders: tuple.4,
+                        tokenRateCacheDurations: tuple.5,
+                        exemptFromYieldProtocolFeeFlags: tuple.6,
+                        swapFeePercentage: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 181u8, 159u8, 108u8];
+            const SIGNATURE: &'static str = "create(string,string,address[],uint256,address[],\
+                                             uint256[],bool[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenRateCacheDurations,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.exemptFromYieldProtocolFeeFlags,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV4`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolFactoryV4Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV4Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [102u8, 181u8, 159u8, 108u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(create),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV4Calls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV4Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV4Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV4Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV4Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV4Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV4Calls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV4Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV4`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2ComposableStablePoolFactoryV4Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV4Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2ComposableStablePoolFactoryV4Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV4Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2ComposableStablePoolFactoryV4Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV4`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV4Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2ComposableStablePoolFactoryV4Instance<P, N> {
+        BalancerV2ComposableStablePoolFactoryV4Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2ComposableStablePoolFactoryV4`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2ComposableStablePoolFactoryV4`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2ComposableStablePoolFactoryV4Instance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2ComposableStablePoolFactoryV4Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2ComposableStablePoolFactoryV4Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV4Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV4`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV4Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2ComposableStablePoolFactoryV4Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2ComposableStablePoolFactoryV4Instance<P, N> {
+            BalancerV2ComposableStablePoolFactoryV4Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV4Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            tokenRateCacheDurations: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                amplificationParameter,
+                rateProviders,
+                tokenRateCacheDurations,
+                exemptFromYieldProtocolFeeFlags,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV4Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2ComposableStablePoolFactoryV4::BalancerV2ComposableStablePoolFactoryV4Instance<
+        ::alloy_provider::DynProvider,
+    >;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xfADa0f4547AB2de89D1304A668C39B3E09Aa7c76"),
+            Some(16878679u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x1802953277FD955f9a254B80Aa0582f193cF1d77"),
+            Some(82748180u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x1802953277FD955f9a254B80Aa0582f193cF1d77"),
+            Some(26666380u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xD87F44Df0159DC78029AB9CA7D7e57E7249F5ACD"),
+            Some(27056416u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x6Ab5549bBd766A43aFb687776ad8466F8b42f777"),
+            Some(40613553u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x2498A2B0d6462d2260EAC50aE1C3e03F4829BA95"),
+            Some(72235860u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x3B1eb8EB7b43882b385aB30533D9A2BeF9052a98"),
+            Some(29221425u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xA3fd20E29358c056B727657E83DFd139abBC9924"),
+            Some(3425277u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/Cargo.toml b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/Cargo.toml
new file mode 100644
index 0000000000..6d8761a537
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2composablestablepoolfactoryv5"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs
new file mode 100644
index 0000000000..21d7c8492f
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs
@@ -0,0 +1,3606 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2ComposableStablePoolFactoryV5 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "tokenRateCacheDurations",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "exemptFromYieldProtocolFeeFlags",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ComposableStablePool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePoolFactoryV5 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256,address[],uint256[],bool[],uint256,address)` and selector `0x66b59f6c`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub tokenRateCacheDurations:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256,address[],uint256[],bool[],
+    /// uint256,address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<bool>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.rateProviders,
+                        value.tokenRateCacheDurations,
+                        value.exemptFromYieldProtocolFeeFlags,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        amplificationParameter: tuple.3,
+                        rateProviders: tuple.4,
+                        tokenRateCacheDurations: tuple.5,
+                        exemptFromYieldProtocolFeeFlags: tuple.6,
+                        swapFeePercentage: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 181u8, 159u8, 108u8];
+            const SIGNATURE: &'static str = "create(string,string,address[],uint256,address[],\
+                                             uint256[],bool[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenRateCacheDurations,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.exemptFromYieldProtocolFeeFlags,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV5`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolFactoryV5Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV5Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [102u8, 181u8, 159u8, 108u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(create),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV5Calls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV5Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV5Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV5Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV5Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV5Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV5Calls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV5Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV5`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2ComposableStablePoolFactoryV5Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV5Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2ComposableStablePoolFactoryV5Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV5Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2ComposableStablePoolFactoryV5Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV5`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV5Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2ComposableStablePoolFactoryV5Instance<P, N> {
+        BalancerV2ComposableStablePoolFactoryV5Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2ComposableStablePoolFactoryV5`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2ComposableStablePoolFactoryV5`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2ComposableStablePoolFactoryV5Instance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2ComposableStablePoolFactoryV5Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2ComposableStablePoolFactoryV5Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV5Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV5`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV5Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2ComposableStablePoolFactoryV5Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2ComposableStablePoolFactoryV5Instance<P, N> {
+            BalancerV2ComposableStablePoolFactoryV5Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV5Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            tokenRateCacheDurations: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                amplificationParameter,
+                rateProviders,
+                tokenRateCacheDurations,
+                exemptFromYieldProtocolFeeFlags,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV5Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2ComposableStablePoolFactoryV5::BalancerV2ComposableStablePoolFactoryV5Instance<
+        ::alloy_provider::DynProvider,
+    >;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xDB8d758BCb971e482B2C45f7F8a7740283A1bd3A"),
+            Some(17672478u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x043A2daD730d585C44FB79D2614F295D2d625412"),
+            Some(106752707u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x4fb47126Fa83A8734991E41B942Ac29A3266C968"),
+            Some(29877945u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7"),
+            Some(28900564u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b"),
+            Some(44961548u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x8df317a729fcaA260306d7de28888932cb579b88"),
+            Some(1204710u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xA8920455934Da4D853faac1f94Fe7bEf72943eF1"),
+            Some(110212282u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xE42FFA682A26EF8F25891db4882932711D42e467"),
+            Some(32478827u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xa523f47A933D5020b23629dDf689695AA94612Dc"),
+            Some(3872211u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/Cargo.toml b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/Cargo.toml
new file mode 100644
index 0000000000..fb3f1d1aac
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2composablestablepoolfactoryv6"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs
new file mode 100644
index 0000000000..8d19f3a9c5
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs
@@ -0,0 +1,3606 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2ComposableStablePoolFactoryV6 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "tokenRateCacheDurations",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "exemptFromYieldProtocolFeeFlags",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ComposableStablePool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePoolFactoryV6 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256,address[],uint256[],bool[],uint256,address)` and selector `0x66b59f6c`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub tokenRateCacheDurations:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256,address[],uint256[],bool[],
+    /// uint256,address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<bool>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.rateProviders,
+                        value.tokenRateCacheDurations,
+                        value.exemptFromYieldProtocolFeeFlags,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        amplificationParameter: tuple.3,
+                        rateProviders: tuple.4,
+                        tokenRateCacheDurations: tuple.5,
+                        exemptFromYieldProtocolFeeFlags: tuple.6,
+                        swapFeePercentage: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 181u8, 159u8, 108u8];
+            const SIGNATURE: &'static str = "create(string,string,address[],uint256,address[],\
+                                             uint256[],bool[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenRateCacheDurations,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.exemptFromYieldProtocolFeeFlags,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV6`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolFactoryV6Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV6Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [102u8, 181u8, 159u8, 108u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(create),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV6Calls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV6Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV6Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV6Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolFactoryV6Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV6Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV6Calls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2ComposableStablePoolFactoryV6Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV6`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2ComposableStablePoolFactoryV6Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2ComposableStablePoolFactoryV6Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2ComposableStablePoolFactoryV6Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV6Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2ComposableStablePoolFactoryV6Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV6`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV6Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2ComposableStablePoolFactoryV6Instance<P, N> {
+        BalancerV2ComposableStablePoolFactoryV6Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2ComposableStablePoolFactoryV6`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2ComposableStablePoolFactoryV6`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2ComposableStablePoolFactoryV6Instance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2ComposableStablePoolFactoryV6Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2ComposableStablePoolFactoryV6Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV6Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2ComposableStablePoolFactoryV6`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2ComposableStablePoolFactoryV6Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2ComposableStablePoolFactoryV6Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2ComposableStablePoolFactoryV6Instance<P, N> {
+            BalancerV2ComposableStablePoolFactoryV6Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV6Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            tokenRateCacheDurations: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            exemptFromYieldProtocolFeeFlags: alloy_sol_types::private::Vec<bool>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                amplificationParameter,
+                rateProviders,
+                tokenRateCacheDurations,
+                exemptFromYieldProtocolFeeFlags,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2ComposableStablePoolFactoryV6Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2ComposableStablePoolFactoryV6::BalancerV2ComposableStablePoolFactoryV6Instance<
+        ::alloy_provider::DynProvider,
+    >;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x5B42eC6D40f7B7965BE5308c70e2603c0281C1E9"),
+            Some(19314764u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7"),
+            Some(116694338u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x6B5dA774890Db7B7b96C6f44e6a4b0F657399E2e"),
+            Some(36485719u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x47B489bf5836f83ABD928C316F8e39bC0587B020"),
+            Some(32650879u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xEAedc32a51c510d35ebC11088fD5fF2b47aACF2E"),
+            Some(53996258u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x956CCab09898C0AF2aCa5e6C228c3aD4E93d9288"),
+            Some(11099703u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7"),
+            Some(184805448u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xb9F8AB3ED3F3aCBa64Bc6cd2DcA74B7F38fD7B88"),
+            Some(42186350u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x05503B3aDE04aCA81c8D6F88eCB73Ba156982D2B"),
+            Some(5369821u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/Cargo.toml b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/Cargo.toml
new file mode 100644
index 0000000000..fe895314ac
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2liquiditybootstrappingpool"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs
new file mode 100644
index 0000000000..5f44c0de7f
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs
@@ -0,0 +1,10993 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IPoolSwapStructs {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapRequest {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            IVault::SwapKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapRequest) -> Self {
+                (
+                    value.kind,
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.amount,
+                    value.poolId,
+                    value.lastChangeBlock,
+                    value.from,
+                    value.to,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    kind: tuple.0,
+                    tokenIn: tuple.1,
+                    tokenOut: tuple.2,
+                    amount: tuple.3,
+                    poolId: tuple.4,
+                    lastChangeBlock: tuple.5,
+                    from: tuple.6,
+                    to: tuple.7,
+                    userData: tuple.8,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapRequest {
+            const NAME: &'static str = "SwapRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
+                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
+                     userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.lastChangeBlock,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.from,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.to,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.lastChangeBlock,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.from,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.to,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.lastChangeBlock,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.from,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.to,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IPoolSwapStructsInstance<P, N> {
+        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IPoolSwapStructs`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IPoolSwapStructs`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IPoolSwapStructsInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
+            IPoolSwapStructsInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    type SwapKind is uint8;
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SwapKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SwapKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SwapKind> for u8 {
+            fn from(value: SwapKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest {
+        IVault.SwapKind kind;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+}
+
+library IVault {
+    type SwapKind is uint8;
+}
+
+interface BalancerV2LiquidityBootstrappingPool {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event GradualWeightUpdateScheduled(uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights);
+    event PausedStateChanged(bool paused);
+    event SwapEnabledSet(bool swapEnabled);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner, bool swapEnabledOnStart);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getGradualWeightUpdateParams() external view returns (uint256 startTime, uint256 endTime, uint256[] memory endWeights);
+    function getInvariant() external view returns (uint256);
+    function getLastInvariant() external view returns (uint256);
+    function getNormalizedWeights() external view returns (uint256[] memory);
+    function getOwner() external view returns (address);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getRate() external view returns (uint256);
+    function getScalingFactors() external view returns (uint256[] memory);
+    function getSwapEnabled() external view returns (bool);
+    function getSwapFeePercentage() external view returns (uint256);
+    function getVault() external view returns (address);
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    function setPaused(bool paused) external;
+    function setSwapEnabled(bool swapEnabled) external;
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    function updateWeightsGradually(uint256 startTime, uint256 endTime, uint256[] memory endWeights) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "normalizedWeights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "swapEnabledOnStart",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decreaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getGradualWeightUpdateParams",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "startTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "endWeights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getInvariant",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getLastInvariant",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getNormalizedWeights",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRate",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getScalingFactors",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapEnabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapFeePercentage",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "increaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "addedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onExitPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onJoinPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onSwap",
+    "inputs": [
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IPoolSwapStructs.SwapRequest",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "lastChangeBlock",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "from",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "balanceTokenIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "balanceTokenOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryExit",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryJoin",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setAssetManagerPoolConfig",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "poolConfig",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setPaused",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setSwapEnabled",
+    "inputs": [
+      {
+        "name": "swapEnabled",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setSwapFeePercentage",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "updateWeightsGradually",
+    "inputs": [
+      {
+        "name": "startTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "endWeights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "GradualWeightUpdateScheduled",
+    "inputs": [
+      {
+        "name": "startTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "startWeights",
+        "type": "uint256[]",
+        "indexed": false,
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "endWeights",
+        "type": "uint256[]",
+        "indexed": false,
+        "internalType": "uint256[]"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapEnabledSet",
+    "inputs": [
+      {
+        "name": "swapEnabled",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2LiquidityBootstrappingPool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `GradualWeightUpdateScheduled(uint256,uint256,uint256[],uint256[])` and selector `0x0f3631f9dab08169d1db21c6dc5f32536fb2b0a6b9bb5330d71c52132f968be0`.
+    ```solidity
+    event GradualWeightUpdateScheduled(uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct GradualWeightUpdateScheduled {
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub startWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub endWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for GradualWeightUpdateScheduled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "GradualWeightUpdateScheduled(uint256,uint256,uint256[],uint256[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    15u8, 54u8, 49u8, 249u8, 218u8, 176u8, 129u8, 105u8, 209u8, 219u8, 33u8, 198u8,
+                    220u8, 95u8, 50u8, 83u8, 111u8, 178u8, 176u8, 166u8, 185u8, 187u8, 83u8, 48u8,
+                    215u8, 28u8, 82u8, 19u8, 47u8, 150u8, 139u8, 224u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    startTime: data.0,
+                    endTime: data.1,
+                    startWeights: data.2,
+                    endWeights: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.startWeights),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for GradualWeightUpdateScheduled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&GradualWeightUpdateScheduled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &GradualWeightUpdateScheduled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapEnabledSet(bool)` and selector `0x5a9e84f78f7957cb4ed7478eb0fcad35ee4ecbe2e0f298420b28a3955392573f`.
+    ```solidity
+    event SwapEnabledSet(bool swapEnabled);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapEnabledSet {
+        #[allow(missing_docs)]
+        pub swapEnabled: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapEnabledSet {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapEnabledSet(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    90u8, 158u8, 132u8, 247u8, 143u8, 121u8, 87u8, 203u8, 78u8, 215u8, 71u8, 142u8,
+                    176u8, 252u8, 173u8, 53u8, 238u8, 78u8, 203u8, 226u8, 224u8, 242u8, 152u8,
+                    66u8, 11u8, 40u8, 163u8, 149u8, 83u8, 146u8, 87u8, 63u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapEnabled: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabled,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapEnabledSet {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapEnabledSet> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapEnabledSet) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner, bool swapEnabledOnStart);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub normalizedWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub swapEnabledOnStart: bool,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.normalizedWeights,
+                        value.swapFeePercentage,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                        value.owner,
+                        value.swapEnabledOnStart,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        name: tuple.1,
+                        symbol: tuple.2,
+                        tokens: tuple.3,
+                        normalizedWeights: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        pauseWindowDuration: tuple.6,
+                        bufferPeriodDuration: tuple.7,
+                        owner: tuple.8,
+                        swapEnabledOnStart: tuple.9,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabledOnStart,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    ```solidity
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
+            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getGradualWeightUpdateParams()` and selector `0x7beed220`.
+    ```solidity
+    function getGradualWeightUpdateParams() external view returns (uint256 startTime, uint256 endTime, uint256[] memory endWeights);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getGradualWeightUpdateParamsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getGradualWeightUpdateParams()`](getGradualWeightUpdateParamsCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getGradualWeightUpdateParamsReturn {
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getGradualWeightUpdateParamsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getGradualWeightUpdateParamsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getGradualWeightUpdateParamsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getGradualWeightUpdateParamsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getGradualWeightUpdateParamsReturn) -> Self {
+                    (value.startTime, value.endTime, value.endWeights)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getGradualWeightUpdateParamsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        startTime: tuple.0,
+                        endTime: tuple.1,
+                        endWeights: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getGradualWeightUpdateParamsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getGradualWeightUpdateParamsCall {
+            type Parameters<'a> = ();
+            type Return = getGradualWeightUpdateParamsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [123u8, 238u8, 210u8, 32u8];
+            const SIGNATURE: &'static str = "getGradualWeightUpdateParams()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getGradualWeightUpdateParamsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getInvariant()` and selector `0xc0ff1a15`.
+    ```solidity
+    function getInvariant() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getInvariantCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getInvariant()`](getInvariantCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getInvariantReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getInvariantCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getInvariantCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getInvariantReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getInvariantReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getInvariantCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [192u8, 255u8, 26u8, 21u8];
+            const SIGNATURE: &'static str = "getInvariant()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getInvariantReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getInvariantReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getLastInvariant()` and selector `0x9b02cdde`.
+    ```solidity
+    function getLastInvariant() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLastInvariantCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getLastInvariant()`](getLastInvariantCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLastInvariantReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLastInvariantCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLastInvariantCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLastInvariantReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLastInvariantReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLastInvariantCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [155u8, 2u8, 205u8, 222u8];
+            const SIGNATURE: &'static str = "getLastInvariant()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getLastInvariantReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getLastInvariantReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getNormalizedWeights()` and selector `0xf89f27ed`.
+    ```solidity
+    function getNormalizedWeights() external view returns (uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNormalizedWeightsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getNormalizedWeights()`](getNormalizedWeightsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNormalizedWeightsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNormalizedWeightsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNormalizedWeightsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getNormalizedWeightsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 159u8, 39u8, 237u8];
+            const SIGNATURE: &'static str = "getNormalizedWeights()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getNormalizedWeightsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getNormalizedWeightsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOwner()` and selector `0x893d20e8`.
+    ```solidity
+    function getOwner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOwner()`](getOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOwnerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
+            const SIGNATURE: &'static str = "getOwner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOwnerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOwnerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    ```solidity
+    function getPoolId() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolId()`](getPoolIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRate()` and selector `0x679aefce`.
+    ```solidity
+    function getRate() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRate()`](getRateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRateCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
+            const SIGNATURE: &'static str = "getRate()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRateReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRateReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getScalingFactors()` and selector `0x1dd746ea`.
+    ```solidity
+    function getScalingFactors() external view returns (uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getScalingFactorsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getScalingFactors()`](getScalingFactorsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getScalingFactorsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getScalingFactorsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getScalingFactorsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getScalingFactorsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [29u8, 215u8, 70u8, 234u8];
+            const SIGNATURE: &'static str = "getScalingFactors()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getScalingFactorsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getScalingFactorsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapEnabled()` and selector `0x47bc4d92`.
+    ```solidity
+    function getSwapEnabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapEnabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapEnabled()`](getSwapEnabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapEnabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapEnabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapEnabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapEnabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapEnabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapEnabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapEnabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapEnabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [71u8, 188u8, 77u8, 146u8];
+            const SIGNATURE: &'static str = "getSwapEnabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapEnabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapEnabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    ```solidity
+    function getSwapFeePercentage() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    ```solidity
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceCall) -> Self {
+                    (value.spender, value.addedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        addedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
+            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.addedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    ```solidity
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onExitPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onExitPoolReturn {
+            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onExitPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onExitPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
+            const SIGNATURE: &'static str =
+                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onExitPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    ```solidity
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onJoinPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onJoinPoolReturn {
+            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onJoinPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onJoinPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
+            const SIGNATURE: &'static str =
+                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onJoinPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256,uint256)` and selector `0x9d2c110c`.
+    ```solidity
+    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwapCall {
+        #[allow(missing_docs)]
+        pub request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
+    /// bytes),uint256,uint256)`](onSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwapCall) -> Self {
+                    (value.request, value.balanceTokenIn, value.balanceTokenOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        request: tuple.0,
+                        balanceTokenIn: tuple.1,
+                        balanceTokenOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onSwapCall {
+            type Parameters<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [157u8, 44u8, 17u8, 12u8];
+            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
+                                             uint256,address,address,bytes),uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.balanceTokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.balanceTokenOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onSwapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onSwapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    ```solidity
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryExitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitReturn {
+        #[allow(missing_docs)]
+        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitReturn) -> Self {
+                    (value.bptIn, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptIn: tuple.0,
+                        amountsOut: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryExitReturn {
+            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryExitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryExitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
+            const SIGNATURE: &'static str =
+                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryExitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    ```solidity
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryJoinCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinReturn {
+        #[allow(missing_docs)]
+        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinReturn) -> Self {
+                    (value.bptOut, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptOut: tuple.0,
+                        amountsIn: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryJoinReturn {
+            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryJoinCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryJoinReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
+            const SIGNATURE: &'static str =
+                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryJoinReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setAssetManagerPoolConfig(address,bytes)` and selector `0x50dd6ed9`.
+    ```solidity
+    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAssetManagerPoolConfigCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub poolConfig: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`setAssetManagerPoolConfig(address,
+    /// bytes)`](setAssetManagerPoolConfigCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAssetManagerPoolConfigReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAssetManagerPoolConfigCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setAssetManagerPoolConfigCall) -> Self {
+                    (value.token, value.poolConfig)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        poolConfig: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAssetManagerPoolConfigReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setAssetManagerPoolConfigReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setAssetManagerPoolConfigReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setAssetManagerPoolConfigCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = setAssetManagerPoolConfigReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [80u8, 221u8, 110u8, 217u8];
+            const SIGNATURE: &'static str = "setAssetManagerPoolConfig(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.poolConfig,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setAssetManagerPoolConfigReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    ```solidity
+    function setPaused(bool paused) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedCall {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setPaused(bool)`](setPausedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedCall) -> Self {
+                    (value.paused,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { paused: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setPausedReturn {
+            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setPausedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Return = setPausedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
+            const SIGNATURE: &'static str = "setPaused(bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setPausedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapEnabled(bool)` and selector `0xe01af92c`.
+    ```solidity
+    function setSwapEnabled(bool swapEnabled) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapEnabledCall {
+        #[allow(missing_docs)]
+        pub swapEnabled: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setSwapEnabled(bool)`](setSwapEnabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapEnabledReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapEnabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapEnabledCall) -> Self {
+                    (value.swapEnabled,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapEnabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapEnabled: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapEnabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapEnabledReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapEnabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapEnabledReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setSwapEnabledCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapEnabledCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Return = setSwapEnabledReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [224u8, 26u8, 249u8, 44u8];
+            const SIGNATURE: &'static str = "setSwapEnabled(bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabled,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapEnabledReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    ```solidity
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageCall {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageCall) -> Self {
+                    (value.swapFeePercentage,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapFeePercentage: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapFeePercentageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = setSwapFeePercentageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
+            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapFeePercentageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `updateWeightsGradually(uint256,uint256,uint256[])` and selector `0x3e569205`.
+    ```solidity
+    function updateWeightsGradually(uint256 startTime, uint256 endTime, uint256[] memory endWeights) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateWeightsGraduallyCall {
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`updateWeightsGradually(uint256,uint256,
+    /// uint256[])`](updateWeightsGraduallyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateWeightsGraduallyReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateWeightsGraduallyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: updateWeightsGraduallyCall) -> Self {
+                    (value.startTime, value.endTime, value.endWeights)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateWeightsGraduallyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        startTime: tuple.0,
+                        endTime: tuple.1,
+                        endWeights: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateWeightsGraduallyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: updateWeightsGraduallyReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateWeightsGraduallyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl updateWeightsGraduallyReturn {
+            fn _tokenize(
+                &self,
+            ) -> <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for updateWeightsGraduallyCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Return = updateWeightsGraduallyReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [62u8, 86u8, 146u8, 5u8];
+            const SIGNATURE: &'static str = "updateWeightsGradually(uint256,uint256,uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                updateWeightsGraduallyReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2LiquidityBootstrappingPool`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2LiquidityBootstrappingPoolCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        decreaseAllowance(decreaseAllowanceCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getGradualWeightUpdateParams(getGradualWeightUpdateParamsCall),
+        #[allow(missing_docs)]
+        getInvariant(getInvariantCall),
+        #[allow(missing_docs)]
+        getLastInvariant(getLastInvariantCall),
+        #[allow(missing_docs)]
+        getNormalizedWeights(getNormalizedWeightsCall),
+        #[allow(missing_docs)]
+        getOwner(getOwnerCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPoolId(getPoolIdCall),
+        #[allow(missing_docs)]
+        getRate(getRateCall),
+        #[allow(missing_docs)]
+        getScalingFactors(getScalingFactorsCall),
+        #[allow(missing_docs)]
+        getSwapEnabled(getSwapEnabledCall),
+        #[allow(missing_docs)]
+        getSwapFeePercentage(getSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        increaseAllowance(increaseAllowanceCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        onExitPool(onExitPoolCall),
+        #[allow(missing_docs)]
+        onJoinPool(onJoinPoolCall),
+        #[allow(missing_docs)]
+        onSwap(onSwapCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        queryExit(queryExitCall),
+        #[allow(missing_docs)]
+        queryJoin(queryJoinCall),
+        #[allow(missing_docs)]
+        setAssetManagerPoolConfig(setAssetManagerPoolConfigCall),
+        #[allow(missing_docs)]
+        setPaused(setPausedCall),
+        #[allow(missing_docs)]
+        setSwapEnabled(setSwapEnabledCall),
+        #[allow(missing_docs)]
+        setSwapFeePercentage(setSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+        #[allow(missing_docs)]
+        updateWeightsGradually(updateWeightsGraduallyCall),
+    }
+    impl BalancerV2LiquidityBootstrappingPoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [22u8, 195u8, 139u8, 60u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [29u8, 215u8, 70u8, 234u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [56u8, 233u8, 146u8, 46u8],
+            [56u8, 255u8, 242u8, 208u8],
+            [57u8, 80u8, 147u8, 81u8],
+            [62u8, 86u8, 146u8, 5u8],
+            [71u8, 188u8, 77u8, 146u8],
+            [80u8, 221u8, 110u8, 217u8],
+            [85u8, 198u8, 118u8, 40u8],
+            [96u8, 40u8, 191u8, 212u8],
+            [103u8, 154u8, 239u8, 206u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 243u8, 176u8, 9u8],
+            [123u8, 238u8, 210u8, 32u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [135u8, 236u8, 104u8, 23u8],
+            [137u8, 61u8, 32u8, 232u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [155u8, 2u8, 205u8, 222u8],
+            [157u8, 44u8, 17u8, 12u8],
+            [164u8, 87u8, 194u8, 215u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [170u8, 171u8, 173u8, 197u8],
+            [192u8, 255u8, 26u8, 21u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [213u8, 192u8, 150u8, 196u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [224u8, 26u8, 249u8, 44u8],
+            [248u8, 159u8, 39u8, 237u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getScalingFactorsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getLastInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(setPaused),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(getScalingFactors),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(setSwapFeePercentage),
+            ::core::stringify!(getPoolId),
+            ::core::stringify!(increaseAllowance),
+            ::core::stringify!(updateWeightsGradually),
+            ::core::stringify!(getSwapEnabled),
+            ::core::stringify!(setAssetManagerPoolConfig),
+            ::core::stringify!(getSwapFeePercentage),
+            ::core::stringify!(queryExit),
+            ::core::stringify!(getRate),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(onExitPool),
+            ::core::stringify!(getGradualWeightUpdateParams),
+            ::core::stringify!(nonces),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(queryJoin),
+            ::core::stringify!(getOwner),
+            ::core::stringify!(getVault),
+            ::core::stringify!(symbol),
+            ::core::stringify!(getLastInvariant),
+            ::core::stringify!(onSwap),
+            ::core::stringify!(decreaseAllowance),
+            ::core::stringify!(transfer),
+            ::core::stringify!(getAuthorizer),
+            ::core::stringify!(getInvariant),
+            ::core::stringify!(permit),
+            ::core::stringify!(onJoinPool),
+            ::core::stringify!(allowance),
+            ::core::stringify!(setSwapEnabled),
+            ::core::stringify!(getNormalizedWeights),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2LiquidityBootstrappingPoolCalls {
+        const COUNT: usize = 38usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2LiquidityBootstrappingPoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseAllowance(_) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getGradualWeightUpdateParams(_) => {
+                    <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getInvariant(_) => <getInvariantCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getLastInvariant(_) => {
+                    <getLastInvariantCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getNormalizedWeights(_) => {
+                    <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getScalingFactors(_) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getSwapEnabled(_) => {
+                    <getSwapEnabledCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getSwapFeePercentage(_) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::increaseAllowance(_) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onSwap(_) => <onSwapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setAssetManagerPoolConfig(_) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setSwapEnabled(_) => {
+                    <setSwapEnabledCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setSwapFeePercentage(_) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::updateWeightsGradually(_) => {
+                    <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2LiquidityBootstrappingPoolCalls,
+            >] = &[
+                {
+                    fn name(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn getScalingFactors(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getScalingFactors)
+                    }
+                    getScalingFactors
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn updateWeightsGradually(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::updateWeightsGradually)
+                    }
+                    updateWeightsGradually
+                },
+                {
+                    fn getSwapEnabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapEnabled)
+                    }
+                    getSwapEnabled
+                },
+                {
+                    fn setAssetManagerPoolConfig(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::setAssetManagerPoolConfig)
+                    }
+                    setAssetManagerPoolConfig
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn getRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn getGradualWeightUpdateParams(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::getGradualWeightUpdateParams,
+                            )
+                    }
+                    getGradualWeightUpdateParams
+                },
+                {
+                    fn nonces(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn getLastInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getLastInvariant)
+                    }
+                    getLastInvariant
+                },
+                {
+                    fn onSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onSwap)
+                    }
+                    onSwap
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn getInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getInvariant)
+                    }
+                    getInvariant
+                },
+                {
+                    fn permit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn setSwapEnabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setSwapEnabled)
+                    }
+                    setSwapEnabled
+                },
+                {
+                    fn getNormalizedWeights(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getNormalizedWeights)
+                    }
+                    getNormalizedWeights
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2LiquidityBootstrappingPoolCalls,
+            >] = &[
+                {
+                    fn name(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn getScalingFactors(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::getScalingFactors,
+                            )
+                    }
+                    getScalingFactors
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::setSwapFeePercentage,
+                            )
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::increaseAllowance,
+                            )
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn updateWeightsGradually(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::updateWeightsGradually,
+                            )
+                    }
+                    updateWeightsGradually
+                },
+                {
+                    fn getSwapEnabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapEnabled)
+                    }
+                    getSwapEnabled
+                },
+                {
+                    fn setAssetManagerPoolConfig(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::setAssetManagerPoolConfig,
+                            )
+                    }
+                    setAssetManagerPoolConfig
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::getSwapFeePercentage,
+                            )
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn getRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn getGradualWeightUpdateParams(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::getGradualWeightUpdateParams,
+                            )
+                    }
+                    getGradualWeightUpdateParams
+                },
+                {
+                    fn nonces(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn getLastInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getLastInvariant)
+                    }
+                    getLastInvariant
+                },
+                {
+                    fn onSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onSwap)
+                    }
+                    onSwap
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::decreaseAllowance,
+                            )
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn getInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getInvariant)
+                    }
+                    getInvariant
+                },
+                {
+                    fn permit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn setSwapEnabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::setSwapEnabled)
+                    }
+                    setSwapEnabled
+                },
+                {
+                    fn getNormalizedWeights(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
+                    {
+                        <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::getNormalizedWeights,
+                            )
+                    }
+                    getNormalizedWeights
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getGradualWeightUpdateParams(inner) => {
+                    <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getInvariant(inner) => {
+                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getLastInvariant(inner) => {
+                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getNormalizedWeights(inner) => {
+                    <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getScalingFactors(inner) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getSwapEnabled(inner) => {
+                    <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onSwap(inner) => {
+                    <onSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setAssetManagerPoolConfig(inner) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setSwapEnabled(inner) => {
+                    <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::updateWeightsGradually(inner) => {
+                    <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getGradualWeightUpdateParams(inner) => {
+                    <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getInvariant(inner) => {
+                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getLastInvariant(inner) => {
+                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getNormalizedWeights(inner) => {
+                    <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getScalingFactors(inner) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getSwapEnabled(inner) => {
+                    <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onSwap(inner) => {
+                    <onSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setAssetManagerPoolConfig(inner) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setSwapEnabled(inner) => {
+                    <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::updateWeightsGradually(inner) => {
+                    <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2LiquidityBootstrappingPool`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2LiquidityBootstrappingPoolEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        GradualWeightUpdateScheduled(GradualWeightUpdateScheduled),
+        #[allow(missing_docs)]
+        PausedStateChanged(PausedStateChanged),
+        #[allow(missing_docs)]
+        SwapEnabledSet(SwapEnabledSet),
+        #[allow(missing_docs)]
+        SwapFeePercentageChanged(SwapFeePercentageChanged),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl BalancerV2LiquidityBootstrappingPoolEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                15u8, 54u8, 49u8, 249u8, 218u8, 176u8, 129u8, 105u8, 209u8, 219u8, 33u8, 198u8,
+                220u8, 95u8, 50u8, 83u8, 111u8, 178u8, 176u8, 166u8, 185u8, 187u8, 83u8, 48u8,
+                215u8, 28u8, 82u8, 19u8, 47u8, 150u8, 139u8, 224u8,
+            ],
+            [
+                90u8, 158u8, 132u8, 247u8, 143u8, 121u8, 87u8, 203u8, 78u8, 215u8, 71u8, 142u8,
+                176u8, 252u8, 173u8, 53u8, 238u8, 78u8, 203u8, 226u8, 224u8, 242u8, 152u8, 66u8,
+                11u8, 40u8, 163u8, 149u8, 83u8, 146u8, 87u8, 63u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+            ],
+            [
+                169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8, 118u8,
+                249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <GradualWeightUpdateScheduled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SwapEnabledSet as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(GradualWeightUpdateScheduled),
+            ::core::stringify!(SwapEnabledSet),
+            ::core::stringify!(Approval),
+            ::core::stringify!(PausedStateChanged),
+            ::core::stringify!(SwapFeePercentageChanged),
+            ::core::stringify!(Transfer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2LiquidityBootstrappingPoolEvents {
+        const COUNT: usize = 6usize;
+        const NAME: &'static str = "BalancerV2LiquidityBootstrappingPoolEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(
+                    <GradualWeightUpdateScheduled as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => <GradualWeightUpdateScheduled as alloy_sol_types::SolEvent>::decode_raw_log(
+                    topics, data,
+                )
+                .map(Self::GradualWeightUpdateScheduled),
+                Some(<PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PausedStateChanged)
+                }
+                Some(<SwapEnabledSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SwapEnabledSet as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SwapEnabledSet)
+                }
+                Some(<SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::SwapFeePercentageChanged)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2LiquidityBootstrappingPoolEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::GradualWeightUpdateScheduled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SwapEnabledSet(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::GradualWeightUpdateScheduled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SwapEnabledSet(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2LiquidityBootstrappingPool`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2LiquidityBootstrappingPoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2LiquidityBootstrappingPoolInstance<P, N> {
+        BalancerV2LiquidityBootstrappingPoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2LiquidityBootstrappingPool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2LiquidityBootstrappingPool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2LiquidityBootstrappingPoolInstance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2LiquidityBootstrappingPoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2LiquidityBootstrappingPoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2LiquidityBootstrappingPoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2LiquidityBootstrappingPool`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2LiquidityBootstrappingPoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2LiquidityBootstrappingPoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2LiquidityBootstrappingPoolInstance<P, N> {
+            BalancerV2LiquidityBootstrappingPoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2LiquidityBootstrappingPoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`decreaseAllowance`] function.
+        pub fn decreaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
+            self.call_builder(&decreaseAllowanceCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getGradualWeightUpdateParams`]
+        /// function.
+        pub fn getGradualWeightUpdateParams(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getGradualWeightUpdateParamsCall, N> {
+            self.call_builder(&getGradualWeightUpdateParamsCall)
+        }
+
+        ///Creates a new call builder for the [`getInvariant`] function.
+        pub fn getInvariant(&self) -> alloy_contract::SolCallBuilder<&P, getInvariantCall, N> {
+            self.call_builder(&getInvariantCall)
+        }
+
+        ///Creates a new call builder for the [`getLastInvariant`] function.
+        pub fn getLastInvariant(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getLastInvariantCall, N> {
+            self.call_builder(&getLastInvariantCall)
+        }
+
+        ///Creates a new call builder for the [`getNormalizedWeights`]
+        /// function.
+        pub fn getNormalizedWeights(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getNormalizedWeightsCall, N> {
+            self.call_builder(&getNormalizedWeightsCall)
+        }
+
+        ///Creates a new call builder for the [`getOwner`] function.
+        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
+            self.call_builder(&getOwnerCall)
+        }
+
+        ///Creates a new call builder for the [`getPausedState`] function.
+        pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
+            self.call_builder(&getPausedStateCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolId`] function.
+        pub fn getPoolId(&self) -> alloy_contract::SolCallBuilder<&P, getPoolIdCall, N> {
+            self.call_builder(&getPoolIdCall)
+        }
+
+        ///Creates a new call builder for the [`getRate`] function.
+        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
+            self.call_builder(&getRateCall)
+        }
+
+        ///Creates a new call builder for the [`getScalingFactors`] function.
+        pub fn getScalingFactors(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getScalingFactorsCall, N> {
+            self.call_builder(&getScalingFactorsCall)
+        }
+
+        ///Creates a new call builder for the [`getSwapEnabled`] function.
+        pub fn getSwapEnabled(&self) -> alloy_contract::SolCallBuilder<&P, getSwapEnabledCall, N> {
+            self.call_builder(&getSwapEnabledCall)
+        }
+
+        ///Creates a new call builder for the [`getSwapFeePercentage`]
+        /// function.
+        pub fn getSwapFeePercentage(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getSwapFeePercentageCall, N> {
+            self.call_builder(&getSwapFeePercentageCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`increaseAllowance`] function.
+        pub fn increaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
+            self.call_builder(&increaseAllowanceCall {
+                spender,
+                addedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`onExitPool`] function.
+        pub fn onExitPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
+            self.call_builder(&onExitPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onJoinPool`] function.
+        pub fn onJoinPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
+            self.call_builder(&onJoinPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onSwap`] function.
+        pub fn onSwap(
+            &self,
+            request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+            balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+            balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, onSwapCall, N> {
+            self.call_builder(&onSwapCall {
+                request,
+                balanceTokenIn,
+                balanceTokenOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryExit`] function.
+        pub fn queryExit(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
+            self.call_builder(&queryExitCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryJoin`] function.
+        pub fn queryJoin(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
+            self.call_builder(&queryJoinCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`setAssetManagerPoolConfig`]
+        /// function.
+        pub fn setAssetManagerPoolConfig(
+            &self,
+            token: alloy_sol_types::private::Address,
+            poolConfig: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, setAssetManagerPoolConfigCall, N> {
+            self.call_builder(&setAssetManagerPoolConfigCall { token, poolConfig })
+        }
+
+        ///Creates a new call builder for the [`setPaused`] function.
+        pub fn setPaused(
+            &self,
+            paused: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
+            self.call_builder(&setPausedCall { paused })
+        }
+
+        ///Creates a new call builder for the [`setSwapEnabled`] function.
+        pub fn setSwapEnabled(
+            &self,
+            swapEnabled: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setSwapEnabledCall, N> {
+            self.call_builder(&setSwapEnabledCall { swapEnabled })
+        }
+
+        ///Creates a new call builder for the [`setSwapFeePercentage`]
+        /// function.
+        pub fn setSwapFeePercentage(
+            &self,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
+            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+
+        ///Creates a new call builder for the [`updateWeightsGradually`]
+        /// function.
+        pub fn updateWeightsGradually(
+            &self,
+            startTime: alloy_sol_types::private::primitives::aliases::U256,
+            endTime: alloy_sol_types::private::primitives::aliases::U256,
+            endWeights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, updateWeightsGraduallyCall, N> {
+            self.call_builder(&updateWeightsGraduallyCall {
+                startTime,
+                endTime,
+                endWeights,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2LiquidityBootstrappingPoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`GradualWeightUpdateScheduled`]
+        /// event.
+        pub fn GradualWeightUpdateScheduled_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, GradualWeightUpdateScheduled, N> {
+            self.event_filter::<GradualWeightUpdateScheduled>()
+        }
+
+        ///Creates a new event filter for the [`PausedStateChanged`] event.
+        pub fn PausedStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PausedStateChanged, N> {
+            self.event_filter::<PausedStateChanged>()
+        }
+
+        ///Creates a new event filter for the [`SwapEnabledSet`] event.
+        pub fn SwapEnabledSet_filter(&self) -> alloy_contract::Event<&P, SwapEnabledSet, N> {
+            self.event_filter::<SwapEnabledSet>()
+        }
+
+        ///Creates a new event filter for the [`SwapFeePercentageChanged`]
+        /// event.
+        pub fn SwapFeePercentageChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SwapFeePercentageChanged, N> {
+            self.event_filter::<SwapFeePercentageChanged>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2LiquidityBootstrappingPool::BalancerV2LiquidityBootstrappingPoolInstance<
+        ::alloy_provider::DynProvider,
+    >;
diff --git a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/Cargo.toml b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/Cargo.toml
new file mode 100644
index 0000000000..7f71999280
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2liquiditybootstrappingpoolfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs
new file mode 100644
index 0000000000..7a640bdbf4
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs
@@ -0,0 +1,1989 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2LiquidityBootstrappingPoolFactory {
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getVault() external view returns (address);
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "weights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "swapEnabledOnStart",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2LiquidityBootstrappingPoolFactory {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { vault: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256[],uint256,address,bool)` and selector `0x23679719`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub weights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub swapEnabledOnStart: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256[],uint256,address,
+    /// bool)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.weights,
+                        value.swapFeePercentage,
+                        value.owner,
+                        value.swapEnabledOnStart,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        weights: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        owner: tuple.5,
+                        swapEnabledOnStart: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 103u8, 151u8, 25u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],uint256,address,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabledOnStart,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the
+    /// [`BalancerV2LiquidityBootstrappingPoolFactory`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2LiquidityBootstrappingPoolFactoryCalls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+    }
+    impl BalancerV2LiquidityBootstrappingPoolFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [35u8, 103u8, 151u8, 25u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [141u8, 146u8, 138u8, 248u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(create),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(getVault),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2LiquidityBootstrappingPoolFactoryCalls {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2LiquidityBootstrappingPoolFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2LiquidityBootstrappingPoolFactoryCalls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(
+                            BalancerV2LiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
+                        )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2LiquidityBootstrappingPoolFactoryCalls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the
+    /// [`BalancerV2LiquidityBootstrappingPoolFactory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2LiquidityBootstrappingPoolFactoryEvents {
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2LiquidityBootstrappingPoolFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8, 73u8,
+            106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8, 188u8,
+            196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(PoolCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2LiquidityBootstrappingPoolFactoryEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "BalancerV2LiquidityBootstrappingPoolFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2LiquidityBootstrappingPoolFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2LiquidityBootstrappingPoolFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2LiquidityBootstrappingPoolFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2LiquidityBootstrappingPoolFactoryInstance<P, N> {
+        BalancerV2LiquidityBootstrappingPoolFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2LiquidityBootstrappingPoolFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2LiquidityBootstrappingPoolFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2LiquidityBootstrappingPoolFactoryInstance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2LiquidityBootstrappingPoolFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2LiquidityBootstrappingPoolFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2LiquidityBootstrappingPoolFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2LiquidityBootstrappingPoolFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2LiquidityBootstrappingPoolFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2LiquidityBootstrappingPoolFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(
+            self,
+        ) -> BalancerV2LiquidityBootstrappingPoolFactoryInstance<P, N> {
+            BalancerV2LiquidityBootstrappingPoolFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2LiquidityBootstrappingPoolFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            weights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+            swapEnabledOnStart: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                weights,
+                swapFeePercentage,
+                owner,
+                swapEnabledOnStart,
+            })
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2LiquidityBootstrappingPoolFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = BalancerV2LiquidityBootstrappingPoolFactory::BalancerV2LiquidityBootstrappingPoolFactoryInstance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE"),
+            Some(12871780u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE"),
+            Some(17116402u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x142B9666a0a3A30477b052962ddA81547E7029ab"),
+            Some(222870u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/Cargo.toml b/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/Cargo.toml
new file mode 100644
index 0000000000..57a32e9b91
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2noprotocolfeeliquiditybootstrappingpoolfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs
new file mode 100644
index 0000000000..53db73ef03
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs
@@ -0,0 +1,2052 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getVault() external view returns (address);
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "weights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "swapEnabledOnStart",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { vault: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256[],uint256,address,bool)` and selector `0x23679719`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub weights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub swapEnabledOnStart: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256[],uint256,address,
+    /// bool)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.weights,
+                        value.swapFeePercentage,
+                        value.owner,
+                        value.swapEnabledOnStart,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        weights: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        owner: tuple.5,
+                        swapEnabledOnStart: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 103u8, 151u8, 25u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],uint256,address,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabledOnStart,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the
+    /// [`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+    }
+    impl BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [35u8, 103u8, 151u8, 25u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [141u8, 146u8, 138u8, 248u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(create),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(getVault),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface
+        for BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls
+    {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCode,
+                            )
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data).map(
+                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::create,
+                        )
+                    }
+                    create
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data).map(
+                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getVault,
+                        )
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCode,
+                            )
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data).map(
+                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::create,
+                        )
+                    }
+                    create
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<
+                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                    > {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(
+                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getVault,
+                        )
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the
+    /// [`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryEvents {
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8, 73u8,
+            106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8, 188u8,
+            196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(PoolCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface
+        for BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryEvents
+    {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData
+        for BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryEvents
+    {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<P, N> {
+        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance::<P, N>::new(
+            address, __provider,
+        )
+    }
+    /**A [`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug
+        for BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<P, N>
+    {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N>
+        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<&P, N>
+    {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(
+            self,
+        ) -> BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<P, N> {
+            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            weights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+            swapEnabledOnStart: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                weights,
+                swapFeePercentage,
+                owner,
+                swapEnabledOnStart,
+            })
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory::BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryInstance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e"),
+            Some(13730248u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xf302f9F50958c5593770FDf4d4812309fF77414f"),
+            Some(7005915u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD"),
+            Some(22691243u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x85a80afee867aDf27B50BdB7b76DA70f1E853062"),
+            Some(25415236u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x41B953164995c11C81DA73D212ED8Af25741b7Ac"),
+            Some(22067480u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x0c6052254551EAe3ECac77B01DFcf1025418828f"),
+            Some(1206531u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x1802953277FD955f9a254B80Aa0582f193cF1d77"),
+            Some(4859669u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e"),
+            Some(26386552u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x45fFd460cC6642B8D8Fb12373DFd77Ceb0f4932B"),
+            Some(3419649u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2stablepool/Cargo.toml b/contracts/generated/contracts-generated/balancerv2stablepool/Cargo.toml
new file mode 100644
index 0000000000..d47208d5b3
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2stablepool/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2stablepool"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs
new file mode 100644
index 0000000000..9e12f5c6e5
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs
@@ -0,0 +1,10242 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IPoolSwapStructs {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapRequest {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            IVault::SwapKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapRequest) -> Self {
+                (
+                    value.kind,
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.amount,
+                    value.poolId,
+                    value.lastChangeBlock,
+                    value.from,
+                    value.to,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    kind: tuple.0,
+                    tokenIn: tuple.1,
+                    tokenOut: tuple.2,
+                    amount: tuple.3,
+                    poolId: tuple.4,
+                    lastChangeBlock: tuple.5,
+                    from: tuple.6,
+                    to: tuple.7,
+                    userData: tuple.8,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapRequest {
+            const NAME: &'static str = "SwapRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
+                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
+                     userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.lastChangeBlock,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.from,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.to,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.lastChangeBlock,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.from,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.to,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.lastChangeBlock,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.from,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.to,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IPoolSwapStructsInstance<P, N> {
+        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IPoolSwapStructs`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IPoolSwapStructs`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IPoolSwapStructsInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
+            IPoolSwapStructsInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    type SwapKind is uint8;
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SwapKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SwapKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SwapKind> for u8 {
+            fn from(value: SwapKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest {
+        IVault.SwapKind kind;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+}
+
+library IVault {
+    type SwapKind is uint8;
+}
+
+interface BalancerV2StablePool {
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    event AmpUpdateStopped(uint256 currentValue);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(address vault, string name, string symbol, address[] tokens, uint256 amplificationParameter, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    function getAuthorizer() external view returns (address);
+    function getOwner() external view returns (address);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getRate() external view returns (uint256);
+    function getSwapFeePercentage() external view returns (uint256);
+    function getVault() external view returns (address);
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external view returns (uint256);
+    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    function setPaused(bool paused) external;
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
+    function stopAmplificationParameterUpdate() external;
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decreaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmplificationParameter",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "isUpdating",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "precision",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRate",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapFeePercentage",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "increaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "addedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onExitPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onJoinPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onSwap",
+    "inputs": [
+      {
+        "name": "swapRequest",
+        "type": "tuple",
+        "internalType": "struct IPoolSwapStructs.SwapRequest",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "lastChangeBlock",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "from",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "indexIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "indexOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onSwap",
+    "inputs": [
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IPoolSwapStructs.SwapRequest",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "lastChangeBlock",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "from",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "balanceTokenIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "balanceTokenOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryExit",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryJoin",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setAssetManagerPoolConfig",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "poolConfig",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setPaused",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setSwapFeePercentage",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "startAmplificationParameterUpdate",
+    "inputs": [
+      {
+        "name": "rawEndValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "stopAmplificationParameterUpdate",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStarted",
+    "inputs": [
+      {
+        "name": "startValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "startTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStopped",
+    "inputs": [
+      {
+        "name": "currentValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2StablePool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AmpUpdateStarted(uint256,uint256,uint256,uint256)` and selector `0x1835882ee7a34ac194f717a35e09bb1d24c82a3b9d854ab6c9749525b714cdf2`.
+    ```solidity
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AmpUpdateStarted {
+        #[allow(missing_docs)]
+        pub startValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AmpUpdateStarted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStarted(uint256,uint256,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
+                    94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8,
+                    201u8, 116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    startValue: data.0,
+                    endValue: data.1,
+                    startTime: data.2,
+                    endTime: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endTime,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStarted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStarted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStarted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AmpUpdateStopped(uint256)` and selector `0xa0d01593e47e69d07e0ccd87bece09411e07dd1ed40ca8f2e7af2976542a0233`.
+    ```solidity
+    event AmpUpdateStopped(uint256 currentValue);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AmpUpdateStopped {
+        #[allow(missing_docs)]
+        pub currentValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AmpUpdateStopped {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStopped(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8,
+                    135u8, 190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8,
+                    242u8, 231u8, 175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    currentValue: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.currentValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStopped {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStopped> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStopped) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, string name, string symbol, address[] tokens, uint256 amplificationParameter, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.swapFeePercentage,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        name: tuple.1,
+                        symbol: tuple.2,
+                        tokens: tuple.3,
+                        amplificationParameter: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        pauseWindowDuration: tuple.6,
+                        bufferPeriodDuration: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    ```solidity
+    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
+            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmplificationParameter()` and selector `0x6daccffa`.
+    ```solidity
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmplificationParameterCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmplificationParameter()`](getAmplificationParameterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmplificationParameterReturn {
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub isUpdating: bool,
+        #[allow(missing_docs)]
+        pub precision: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmplificationParameterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmplificationParameterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterReturn) -> Self {
+                    (value.value, value.isUpdating, value.precision)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        value: tuple.0,
+                        isUpdating: tuple.1,
+                        precision: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getAmplificationParameterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getAmplificationParameterCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isUpdating,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.precision,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmplificationParameterCall {
+            type Parameters<'a> = ();
+            type Return = getAmplificationParameterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [109u8, 172u8, 207u8, 250u8];
+            const SIGNATURE: &'static str = "getAmplificationParameter()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getAmplificationParameterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOwner()` and selector `0x893d20e8`.
+    ```solidity
+    function getOwner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOwner()`](getOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOwnerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
+            const SIGNATURE: &'static str = "getOwner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOwnerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOwnerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    ```solidity
+    function getPoolId() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolId()`](getPoolIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRate()` and selector `0x679aefce`.
+    ```solidity
+    function getRate() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRate()`](getRateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRateCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
+            const SIGNATURE: &'static str = "getRate()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRateReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRateReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    ```solidity
+    function getSwapFeePercentage() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    ```solidity
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceCall) -> Self {
+                    (value.spender, value.addedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        addedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
+            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.addedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    ```solidity
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onExitPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onExitPoolReturn {
+            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onExitPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onExitPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
+            const SIGNATURE: &'static str =
+                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onExitPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    ```solidity
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onJoinPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onJoinPoolReturn {
+            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onJoinPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onJoinPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
+            const SIGNATURE: &'static str =
+                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onJoinPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256[],uint256,uint256)` and selector `0x01ec954a`.
+    ```solidity
+    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwap_0Call {
+        #[allow(missing_docs)]
+        pub swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub indexIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub indexOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
+    /// bytes),uint256[],uint256,uint256)`](onSwap_0Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwap_0Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwap_0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwap_0Call) -> Self {
+                    (
+                        value.swapRequest,
+                        value.balances,
+                        value.indexIn,
+                        value.indexOut,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapRequest: tuple.0,
+                        balances: tuple.1,
+                        indexIn: tuple.2,
+                        indexOut: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwap_0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwap_0Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onSwap_0Call {
+            type Parameters<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [1u8, 236u8, 149u8, 74u8];
+            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
+                                             uint256,address,address,bytes),uint256[],uint256,\
+                                             uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.swapRequest,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.indexIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.indexOut),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onSwap_0Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onSwap_0Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256,uint256)` and selector `0x9d2c110c`.
+    ```solidity
+    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwap_1Call {
+        #[allow(missing_docs)]
+        pub request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
+    /// bytes),uint256,uint256)`](onSwap_1Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwap_1Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwap_1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwap_1Call) -> Self {
+                    (value.request, value.balanceTokenIn, value.balanceTokenOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_1Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        request: tuple.0,
+                        balanceTokenIn: tuple.1,
+                        balanceTokenOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwap_1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwap_1Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_1Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onSwap_1Call {
+            type Parameters<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [157u8, 44u8, 17u8, 12u8];
+            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
+                                             uint256,address,address,bytes),uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.balanceTokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.balanceTokenOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onSwap_1Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onSwap_1Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    ```solidity
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryExitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitReturn {
+        #[allow(missing_docs)]
+        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitReturn) -> Self {
+                    (value.bptIn, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptIn: tuple.0,
+                        amountsOut: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryExitReturn {
+            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryExitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryExitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
+            const SIGNATURE: &'static str =
+                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryExitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    ```solidity
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryJoinCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinReturn {
+        #[allow(missing_docs)]
+        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinReturn) -> Self {
+                    (value.bptOut, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptOut: tuple.0,
+                        amountsIn: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryJoinReturn {
+            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryJoinCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryJoinReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
+            const SIGNATURE: &'static str =
+                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryJoinReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setAssetManagerPoolConfig(address,bytes)` and selector `0x50dd6ed9`.
+    ```solidity
+    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAssetManagerPoolConfigCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub poolConfig: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`setAssetManagerPoolConfig(address,
+    /// bytes)`](setAssetManagerPoolConfigCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAssetManagerPoolConfigReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAssetManagerPoolConfigCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setAssetManagerPoolConfigCall) -> Self {
+                    (value.token, value.poolConfig)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        poolConfig: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAssetManagerPoolConfigReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setAssetManagerPoolConfigReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setAssetManagerPoolConfigReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setAssetManagerPoolConfigCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = setAssetManagerPoolConfigReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [80u8, 221u8, 110u8, 217u8];
+            const SIGNATURE: &'static str = "setAssetManagerPoolConfig(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.poolConfig,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setAssetManagerPoolConfigReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    ```solidity
+    function setPaused(bool paused) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedCall {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setPaused(bool)`](setPausedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedCall) -> Self {
+                    (value.paused,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { paused: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setPausedReturn {
+            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setPausedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Return = setPausedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
+            const SIGNATURE: &'static str = "setPaused(bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setPausedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    ```solidity
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageCall {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageCall) -> Self {
+                    (value.swapFeePercentage,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapFeePercentage: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapFeePercentageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = setSwapFeePercentageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
+            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapFeePercentageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `startAmplificationParameterUpdate(uint256,uint256)` and selector `0x2f1a0bc9`.
+    ```solidity
+    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct startAmplificationParameterUpdateCall {
+        #[allow(missing_docs)]
+        pub rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`startAmplificationParameterUpdate(uint256,
+    /// uint256)`](startAmplificationParameterUpdateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct startAmplificationParameterUpdateReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<startAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: startAmplificationParameterUpdateCall) -> Self {
+                    (value.rawEndValue, value.endTime)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        rawEndValue: tuple.0,
+                        endTime: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<startAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: startAmplificationParameterUpdateReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl startAmplificationParameterUpdateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for startAmplificationParameterUpdateCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = startAmplificationParameterUpdateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 26u8, 11u8, 201u8];
+            const SIGNATURE: &'static str = "startAmplificationParameterUpdate(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.rawEndValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endTime,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                startAmplificationParameterUpdateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `stopAmplificationParameterUpdate()` and selector `0xeb0f24d6`.
+    ```solidity
+    function stopAmplificationParameterUpdate() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct stopAmplificationParameterUpdateCall;
+    ///Container type for the return parameters of the
+    /// [`stopAmplificationParameterUpdate()`](stopAmplificationParameterUpdateCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct stopAmplificationParameterUpdateReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<stopAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: stopAmplificationParameterUpdateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<stopAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: stopAmplificationParameterUpdateReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl stopAmplificationParameterUpdateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for stopAmplificationParameterUpdateCall {
+            type Parameters<'a> = ();
+            type Return = stopAmplificationParameterUpdateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [235u8, 15u8, 36u8, 214u8];
+            const SIGNATURE: &'static str = "stopAmplificationParameterUpdate()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                stopAmplificationParameterUpdateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2StablePool`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2StablePoolCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        decreaseAllowance(decreaseAllowanceCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAmplificationParameter(getAmplificationParameterCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getOwner(getOwnerCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPoolId(getPoolIdCall),
+        #[allow(missing_docs)]
+        getRate(getRateCall),
+        #[allow(missing_docs)]
+        getSwapFeePercentage(getSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        increaseAllowance(increaseAllowanceCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        onExitPool(onExitPoolCall),
+        #[allow(missing_docs)]
+        onJoinPool(onJoinPoolCall),
+        #[allow(missing_docs)]
+        onSwap_0(onSwap_0Call),
+        #[allow(missing_docs)]
+        onSwap_1(onSwap_1Call),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        queryExit(queryExitCall),
+        #[allow(missing_docs)]
+        queryJoin(queryJoinCall),
+        #[allow(missing_docs)]
+        setAssetManagerPoolConfig(setAssetManagerPoolConfigCall),
+        #[allow(missing_docs)]
+        setPaused(setPausedCall),
+        #[allow(missing_docs)]
+        setSwapFeePercentage(setSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        startAmplificationParameterUpdate(startAmplificationParameterUpdateCall),
+        #[allow(missing_docs)]
+        stopAmplificationParameterUpdate(stopAmplificationParameterUpdateCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl BalancerV2StablePoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [1u8, 236u8, 149u8, 74u8],
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [22u8, 195u8, 139u8, 60u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [47u8, 26u8, 11u8, 201u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [56u8, 233u8, 146u8, 46u8],
+            [56u8, 255u8, 242u8, 208u8],
+            [57u8, 80u8, 147u8, 81u8],
+            [80u8, 221u8, 110u8, 217u8],
+            [85u8, 198u8, 118u8, 40u8],
+            [96u8, 40u8, 191u8, 212u8],
+            [103u8, 154u8, 239u8, 206u8],
+            [109u8, 172u8, 207u8, 250u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 243u8, 176u8, 9u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [135u8, 236u8, 104u8, 23u8],
+            [137u8, 61u8, 32u8, 232u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [157u8, 44u8, 17u8, 12u8],
+            [164u8, 87u8, 194u8, 215u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [170u8, 171u8, 173u8, 197u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [213u8, 192u8, 150u8, 196u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [235u8, 15u8, 36u8, 214u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <onSwap_0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmplificationParameterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onSwap_1Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(onSwap_0),
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(setPaused),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(startAmplificationParameterUpdate),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(setSwapFeePercentage),
+            ::core::stringify!(getPoolId),
+            ::core::stringify!(increaseAllowance),
+            ::core::stringify!(setAssetManagerPoolConfig),
+            ::core::stringify!(getSwapFeePercentage),
+            ::core::stringify!(queryExit),
+            ::core::stringify!(getRate),
+            ::core::stringify!(getAmplificationParameter),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(onExitPool),
+            ::core::stringify!(nonces),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(queryJoin),
+            ::core::stringify!(getOwner),
+            ::core::stringify!(getVault),
+            ::core::stringify!(symbol),
+            ::core::stringify!(onSwap_1),
+            ::core::stringify!(decreaseAllowance),
+            ::core::stringify!(transfer),
+            ::core::stringify!(getAuthorizer),
+            ::core::stringify!(permit),
+            ::core::stringify!(onJoinPool),
+            ::core::stringify!(allowance),
+            ::core::stringify!(stopAmplificationParameterUpdate),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2StablePoolCalls {
+        const COUNT: usize = 34usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2StablePoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseAllowance(_) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmplificationParameter(_) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getSwapFeePercentage(_) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::increaseAllowance(_) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onSwap_0(_) => <onSwap_0Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onSwap_1(_) => <onSwap_1Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setAssetManagerPoolConfig(_) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setSwapFeePercentage(_) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::startAmplificationParameterUpdate(_) => {
+                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::stopAmplificationParameterUpdate(_) => {
+                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV2StablePoolCalls>] = &[
+                {
+                    fn onSwap_0(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onSwap_0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::onSwap_0)
+                    }
+                    onSwap_0
+                },
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn startAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2StablePoolCalls::startAmplificationParameterUpdate,
+                            )
+                    }
+                    startAmplificationParameterUpdate
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn setAssetManagerPoolConfig(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolCalls::setAssetManagerPoolConfig)
+                    }
+                    setAssetManagerPoolConfig
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn getRate(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn getAmplificationParameter(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolCalls::getAmplificationParameter)
+                    }
+                    getAmplificationParameter
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn onSwap_1(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onSwap_1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::onSwap_1)
+                    }
+                    onSwap_1
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn stopAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2StablePoolCalls::stopAmplificationParameterUpdate,
+                            )
+                    }
+                    stopAmplificationParameterUpdate
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2StablePoolCalls,
+            >] = &[
+                {
+                    fn onSwap_0(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onSwap_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::onSwap_0)
+                    }
+                    onSwap_0
+                },
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn startAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2StablePoolCalls::startAmplificationParameterUpdate,
+                            )
+                    }
+                    startAmplificationParameterUpdate
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn setAssetManagerPoolConfig(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolCalls::setAssetManagerPoolConfig)
+                    }
+                    setAssetManagerPoolConfig
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn getRate(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn getAmplificationParameter(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolCalls::getAmplificationParameter)
+                    }
+                    getAmplificationParameter
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn onSwap_1(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onSwap_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::onSwap_1)
+                    }
+                    onSwap_1
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn stopAmplificationParameterUpdate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
+                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2StablePoolCalls::stopAmplificationParameterUpdate,
+                            )
+                    }
+                    stopAmplificationParameterUpdate
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmplificationParameter(inner) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onSwap_0(inner) => {
+                    <onSwap_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onSwap_1(inner) => {
+                    <onSwap_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setAssetManagerPoolConfig(inner) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::startAmplificationParameterUpdate(inner) => {
+                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::stopAmplificationParameterUpdate(inner) => {
+                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmplificationParameter(inner) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onSwap_0(inner) => {
+                    <onSwap_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onSwap_1(inner) => {
+                    <onSwap_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setAssetManagerPoolConfig(inner) => {
+                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::startAmplificationParameterUpdate(inner) => {
+                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::stopAmplificationParameterUpdate(inner) => {
+                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2StablePool`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2StablePoolEvents {
+        #[allow(missing_docs)]
+        AmpUpdateStarted(AmpUpdateStarted),
+        #[allow(missing_docs)]
+        AmpUpdateStopped(AmpUpdateStopped),
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        PausedStateChanged(PausedStateChanged),
+        #[allow(missing_docs)]
+        SwapFeePercentageChanged(SwapFeePercentageChanged),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl BalancerV2StablePoolEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
+                94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8, 201u8,
+                116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+            ],
+            [
+                160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8, 135u8,
+                190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8, 242u8, 231u8,
+                175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
+            ],
+            [
+                169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8, 118u8,
+                249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <AmpUpdateStarted as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <AmpUpdateStopped as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(AmpUpdateStarted),
+            ::core::stringify!(Approval),
+            ::core::stringify!(PausedStateChanged),
+            ::core::stringify!(AmpUpdateStopped),
+            ::core::stringify!(SwapFeePercentageChanged),
+            ::core::stringify!(Transfer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2StablePoolEvents {
+        const COUNT: usize = 6usize;
+        const NAME: &'static str = "BalancerV2StablePoolEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<AmpUpdateStarted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <AmpUpdateStarted as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::AmpUpdateStarted)
+                }
+                Some(<AmpUpdateStopped as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <AmpUpdateStopped as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::AmpUpdateStopped)
+                }
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PausedStateChanged)
+                }
+                Some(<SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::SwapFeePercentageChanged)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2StablePoolEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AmpUpdateStarted(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::AmpUpdateStopped(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AmpUpdateStarted(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::AmpUpdateStopped(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2StablePool`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2StablePoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2StablePoolInstance<P, N> {
+        BalancerV2StablePoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2StablePool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2StablePool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2StablePoolInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2StablePoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2StablePoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2StablePoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2StablePool`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2StablePoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2StablePoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2StablePoolInstance<P, N> {
+            BalancerV2StablePoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2StablePoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`decreaseAllowance`] function.
+        pub fn decreaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
+            self.call_builder(&decreaseAllowanceCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAmplificationParameter`]
+        /// function.
+        pub fn getAmplificationParameter(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmplificationParameterCall, N> {
+            self.call_builder(&getAmplificationParameterCall)
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getOwner`] function.
+        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
+            self.call_builder(&getOwnerCall)
+        }
+
+        ///Creates a new call builder for the [`getPausedState`] function.
+        pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
+            self.call_builder(&getPausedStateCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolId`] function.
+        pub fn getPoolId(&self) -> alloy_contract::SolCallBuilder<&P, getPoolIdCall, N> {
+            self.call_builder(&getPoolIdCall)
+        }
+
+        ///Creates a new call builder for the [`getRate`] function.
+        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
+            self.call_builder(&getRateCall)
+        }
+
+        ///Creates a new call builder for the [`getSwapFeePercentage`]
+        /// function.
+        pub fn getSwapFeePercentage(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getSwapFeePercentageCall, N> {
+            self.call_builder(&getSwapFeePercentageCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`increaseAllowance`] function.
+        pub fn increaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
+            self.call_builder(&increaseAllowanceCall {
+                spender,
+                addedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`onExitPool`] function.
+        pub fn onExitPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
+            self.call_builder(&onExitPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onJoinPool`] function.
+        pub fn onJoinPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
+            self.call_builder(&onJoinPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onSwap_0`] function.
+        pub fn onSwap_0(
+            &self,
+            swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            indexIn: alloy_sol_types::private::primitives::aliases::U256,
+            indexOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, onSwap_0Call, N> {
+            self.call_builder(&onSwap_0Call {
+                swapRequest,
+                balances,
+                indexIn,
+                indexOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`onSwap_1`] function.
+        pub fn onSwap_1(
+            &self,
+            request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+            balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+            balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, onSwap_1Call, N> {
+            self.call_builder(&onSwap_1Call {
+                request,
+                balanceTokenIn,
+                balanceTokenOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryExit`] function.
+        pub fn queryExit(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
+            self.call_builder(&queryExitCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryJoin`] function.
+        pub fn queryJoin(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
+            self.call_builder(&queryJoinCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`setAssetManagerPoolConfig`]
+        /// function.
+        pub fn setAssetManagerPoolConfig(
+            &self,
+            token: alloy_sol_types::private::Address,
+            poolConfig: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, setAssetManagerPoolConfigCall, N> {
+            self.call_builder(&setAssetManagerPoolConfigCall { token, poolConfig })
+        }
+
+        ///Creates a new call builder for the [`setPaused`] function.
+        pub fn setPaused(
+            &self,
+            paused: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
+            self.call_builder(&setPausedCall { paused })
+        }
+
+        ///Creates a new call builder for the [`setSwapFeePercentage`]
+        /// function.
+        pub fn setSwapFeePercentage(
+            &self,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
+            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
+        }
+
+        ///Creates a new call builder for the
+        /// [`startAmplificationParameterUpdate`] function.
+        pub fn startAmplificationParameterUpdate(
+            &self,
+            rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
+            endTime: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, startAmplificationParameterUpdateCall, N> {
+            self.call_builder(&startAmplificationParameterUpdateCall {
+                rawEndValue,
+                endTime,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`stopAmplificationParameterUpdate`] function.
+        pub fn stopAmplificationParameterUpdate(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, stopAmplificationParameterUpdateCall, N> {
+            self.call_builder(&stopAmplificationParameterUpdateCall)
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2StablePoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`AmpUpdateStarted`] event.
+        pub fn AmpUpdateStarted_filter(&self) -> alloy_contract::Event<&P, AmpUpdateStarted, N> {
+            self.event_filter::<AmpUpdateStarted>()
+        }
+
+        ///Creates a new event filter for the [`AmpUpdateStopped`] event.
+        pub fn AmpUpdateStopped_filter(&self) -> alloy_contract::Event<&P, AmpUpdateStopped, N> {
+            self.event_filter::<AmpUpdateStopped>()
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`PausedStateChanged`] event.
+        pub fn PausedStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PausedStateChanged, N> {
+            self.event_filter::<PausedStateChanged>()
+        }
+
+        ///Creates a new event filter for the [`SwapFeePercentageChanged`]
+        /// event.
+        pub fn SwapFeePercentageChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SwapFeePercentageChanged, N> {
+            self.event_filter::<SwapFeePercentageChanged>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2StablePool::BalancerV2StablePoolInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/Cargo.toml b/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/Cargo.toml
new file mode 100644
index 0000000000..c0d0126850
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2stablepoolfactoryv2"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs b/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs
new file mode 100644
index 0000000000..06b62741ce
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs
@@ -0,0 +1,2854 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2StablePoolFactoryV2 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amplificationParameter",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2StablePoolFactoryV2 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { vault: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256,uint256,address)` and selector `0x7932c7f3`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256,uint256,address)`](createCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        amplificationParameter: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        owner: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 50u8, 199u8, 243u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.amplificationParameter,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2StablePoolFactoryV2`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2StablePoolFactoryV2Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+    }
+    impl BalancerV2StablePoolFactoryV2Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [121u8, 50u8, 199u8, 243u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(create),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2StablePoolFactoryV2Calls {
+        const COUNT: usize = 10usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2StablePoolFactoryV2Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2StablePoolFactoryV2Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolFactoryV2Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolFactoryV2Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2StablePoolFactoryV2Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolFactoryV2Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2StablePoolFactoryV2Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2StablePoolFactoryV2Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2StablePoolFactoryV2Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2StablePoolFactoryV2Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2StablePoolFactoryV2Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2StablePoolFactoryV2`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2StablePoolFactoryV2Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2StablePoolFactoryV2Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2StablePoolFactoryV2Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2StablePoolFactoryV2Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2StablePoolFactoryV2Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2StablePoolFactoryV2`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2StablePoolFactoryV2Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2StablePoolFactoryV2Instance<P, N> {
+        BalancerV2StablePoolFactoryV2Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2StablePoolFactoryV2`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2StablePoolFactoryV2`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2StablePoolFactoryV2Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2StablePoolFactoryV2Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2StablePoolFactoryV2Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2StablePoolFactoryV2Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2StablePoolFactoryV2`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2StablePoolFactoryV2Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2StablePoolFactoryV2Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2StablePoolFactoryV2Instance<P, N> {
+            BalancerV2StablePoolFactoryV2Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2StablePoolFactoryV2Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                amplificationParameter,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2StablePoolFactoryV2Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = BalancerV2StablePoolFactoryV2::BalancerV2StablePoolFactoryV2Instance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x8df6efec5547e31b0eb7d1291b511ff8a2bf987c"),
+            Some(14934936u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xeb151668006CD04DAdD098AFd0a82e78F77076c3"),
+            Some(11088891u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xf23b4DB826DbA14c0e857029dfF076b1c0264843"),
+            Some(25415344u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xcA96C4f198d343E251b1a01F3EBA061ef3DA73C1"),
+            Some(29371951u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xEF44D6786b2b4d544b7850Fe67CE6381626Bf2D6"),
+            Some(14244664u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2vault/Cargo.toml b/contracts/generated/contracts-generated/balancerv2vault/Cargo.toml
new file mode 100644
index 0000000000..36626224e0
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2vault/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2vault"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs b/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs
new file mode 100644
index 0000000000..6c561d4062
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs
@@ -0,0 +1,11577 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    type PoolBalanceOpKind is uint8;
+    type PoolSpecialization is uint8;
+    type SwapKind is uint8;
+    type UserBalanceOpKind is uint8;
+    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
+    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
+    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
+    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
+    struct PoolBalanceOp { PoolBalanceOpKind kind; bytes32 poolId; address token; uint256 amount; }
+    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
+    struct UserBalanceOp { UserBalanceOpKind kind; address asset; uint256 amount; address sender; address recipient; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PoolBalanceOpKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<PoolBalanceOpKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl PoolBalanceOpKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for PoolBalanceOpKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<PoolBalanceOpKind> for u8 {
+            fn from(value: PoolBalanceOpKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PoolBalanceOpKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PoolBalanceOpKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PoolSpecialization(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<PoolSpecialization> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl PoolSpecialization {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for PoolSpecialization {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<PoolSpecialization> for u8 {
+            fn from(value: PoolSpecialization) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PoolSpecialization {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PoolSpecialization {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SwapKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SwapKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SwapKind> for u8 {
+            fn from(value: SwapKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct UserBalanceOpKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<UserBalanceOpKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl UserBalanceOpKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for UserBalanceOpKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<UserBalanceOpKind> for u8 {
+            fn from(value: UserBalanceOpKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for UserBalanceOpKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for UserBalanceOpKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BatchSwapStep {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub assetInIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub assetOutIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<BatchSwapStep> for UnderlyingRustTuple<'_> {
+            fn from(value: BatchSwapStep) -> Self {
+                (
+                    value.poolId,
+                    value.assetInIndex,
+                    value.assetOutIndex,
+                    value.amount,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BatchSwapStep {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    poolId: tuple.0,
+                    assetInIndex: tuple.1,
+                    assetOutIndex: tuple.2,
+                    amount: tuple.3,
+                    userData: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for BatchSwapStep {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for BatchSwapStep {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetInIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetOutIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for BatchSwapStep {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for BatchSwapStep {
+            const NAME: &'static str = "BatchSwapStep";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "BatchSwapStep(bytes32 poolId,uint256 assetInIndex,uint256 \
+                     assetOutIndex,uint256 amount,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetInIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetOutIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for BatchSwapStep {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetInIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetOutIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetInIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetOutIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ExitPoolRequest {
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub minAmountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub toInternalBalance: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            alloy_sol_types::private::Bytes,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ExitPoolRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: ExitPoolRequest) -> Self {
+                (
+                    value.assets,
+                    value.minAmountsOut,
+                    value.userData,
+                    value.toInternalBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExitPoolRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    assets: tuple.0,
+                    minAmountsOut: tuple.1,
+                    userData: tuple.2,
+                    toInternalBalance: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for ExitPoolRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for ExitPoolRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minAmountsOut),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.toInternalBalance,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ExitPoolRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for ExitPoolRequest {
+            const NAME: &'static str = "ExitPoolRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "ExitPoolRequest(address[] assets,uint256[] minAmountsOut,bytes userData,bool \
+                     toInternalBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minAmountsOut)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.toInternalBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ExitPoolRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assets,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minAmountsOut,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toInternalBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assets,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minAmountsOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toInternalBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct FundManagement {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fromInternalBalance: bool,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub toInternalBalance: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            bool,
+            alloy_sol_types::private::Address,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<FundManagement> for UnderlyingRustTuple<'_> {
+            fn from(value: FundManagement) -> Self {
+                (
+                    value.sender,
+                    value.fromInternalBalance,
+                    value.recipient,
+                    value.toInternalBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FundManagement {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sender: tuple.0,
+                    fromInternalBalance: tuple.1,
+                    recipient: tuple.2,
+                    toInternalBalance: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for FundManagement {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for FundManagement {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.fromInternalBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.toInternalBalance,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for FundManagement {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for FundManagement {
+            const NAME: &'static str = "FundManagement";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "FundManagement(address sender,bool fromInternalBalance,address \
+                     recipient,bool toInternalBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.fromInternalBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.toInternalBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for FundManagement {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.fromInternalBalance,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toInternalBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fromInternalBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toInternalBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct JoinPoolRequest {
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub maxAmountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub fromInternalBalance: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            alloy_sol_types::private::Bytes,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<JoinPoolRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: JoinPoolRequest) -> Self {
+                (
+                    value.assets,
+                    value.maxAmountsIn,
+                    value.userData,
+                    value.fromInternalBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for JoinPoolRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    assets: tuple.0,
+                    maxAmountsIn: tuple.1,
+                    userData: tuple.2,
+                    fromInternalBalance: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for JoinPoolRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for JoinPoolRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.maxAmountsIn),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.fromInternalBalance,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for JoinPoolRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for JoinPoolRequest {
+            const NAME: &'static str = "JoinPoolRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "JoinPoolRequest(address[] assets,uint256[] maxAmountsIn,bytes userData,bool \
+                     fromInternalBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxAmountsIn)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.fromInternalBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for JoinPoolRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assets,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maxAmountsIn,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.fromInternalBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assets,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maxAmountsIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fromInternalBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PoolBalanceOp { PoolBalanceOpKind kind; bytes32 poolId; address token; uint256 amount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PoolBalanceOp {
+        #[allow(missing_docs)]
+        pub kind: <PoolBalanceOpKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            PoolBalanceOpKind,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <PoolBalanceOpKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PoolBalanceOp> for UnderlyingRustTuple<'_> {
+            fn from(value: PoolBalanceOp) -> Self {
+                (value.kind, value.poolId, value.token, value.amount)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PoolBalanceOp {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    kind: tuple.0,
+                    poolId: tuple.1,
+                    token: tuple.2,
+                    amount: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PoolBalanceOp {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PoolBalanceOp {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <PoolBalanceOpKind as alloy_sol_types::SolType>::tokenize(
+                        &self.kind,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PoolBalanceOp {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PoolBalanceOp {
+            const NAME: &'static str = "PoolBalanceOp";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PoolBalanceOp(uint8 kind,bytes32 poolId,address token,uint256 amount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <PoolBalanceOpKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PoolBalanceOp {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <PoolBalanceOpKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <PoolBalanceOpKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SingleSwap {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub kind: <SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub assetIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub assetOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            SwapKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            <SwapKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SingleSwap> for UnderlyingRustTuple<'_> {
+            fn from(value: SingleSwap) -> Self {
+                (
+                    value.poolId,
+                    value.kind,
+                    value.assetIn,
+                    value.assetOut,
+                    value.amount,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SingleSwap {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    poolId: tuple.0,
+                    kind: tuple.1,
+                    assetIn: tuple.2,
+                    assetOut: tuple.3,
+                    amount: tuple.4,
+                    userData: tuple.5,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SingleSwap {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SingleSwap {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.assetIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.assetOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SingleSwap {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SingleSwap {
+            const NAME: &'static str = "SingleSwap";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SingleSwap(bytes32 poolId,uint8 kind,address assetIn,address \
+                     assetOut,uint256 amount,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <SwapKind as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.assetIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.assetOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SingleSwap {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.kind, out);
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct UserBalanceOp { UserBalanceOpKind kind; address asset; uint256 amount; address sender; address recipient; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct UserBalanceOp {
+        #[allow(missing_docs)]
+        pub kind: <UserBalanceOpKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub asset: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            UserBalanceOpKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <UserBalanceOpKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UserBalanceOp> for UnderlyingRustTuple<'_> {
+            fn from(value: UserBalanceOp) -> Self {
+                (
+                    value.kind,
+                    value.asset,
+                    value.amount,
+                    value.sender,
+                    value.recipient,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UserBalanceOp {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    kind: tuple.0,
+                    asset: tuple.1,
+                    amount: tuple.2,
+                    sender: tuple.3,
+                    recipient: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for UserBalanceOp {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for UserBalanceOp {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <UserBalanceOpKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.asset,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for UserBalanceOp {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for UserBalanceOp {
+            const NAME: &'static str = "UserBalanceOp";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "UserBalanceOp(uint8 kind,address asset,uint256 amount,address sender,address \
+                     recipient)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <UserBalanceOpKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.asset,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for UserBalanceOp {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <UserBalanceOpKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.asset,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <UserBalanceOpKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.asset,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IVault {
+    type PoolBalanceOpKind is uint8;
+    type PoolSpecialization is uint8;
+    type SwapKind is uint8;
+    type UserBalanceOpKind is uint8;
+    struct BatchSwapStep {
+        bytes32 poolId;
+        uint256 assetInIndex;
+        uint256 assetOutIndex;
+        uint256 amount;
+        bytes userData;
+    }
+    struct ExitPoolRequest {
+        address[] assets;
+        uint256[] minAmountsOut;
+        bytes userData;
+        bool toInternalBalance;
+    }
+    struct FundManagement {
+        address sender;
+        bool fromInternalBalance;
+        address payable recipient;
+        bool toInternalBalance;
+    }
+    struct JoinPoolRequest {
+        address[] assets;
+        uint256[] maxAmountsIn;
+        bytes userData;
+        bool fromInternalBalance;
+    }
+    struct PoolBalanceOp {
+        PoolBalanceOpKind kind;
+        bytes32 poolId;
+        address token;
+        uint256 amount;
+    }
+    struct SingleSwap {
+        bytes32 poolId;
+        SwapKind kind;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+        bytes userData;
+    }
+    struct UserBalanceOp {
+        UserBalanceOpKind kind;
+        address asset;
+        uint256 amount;
+        address sender;
+        address payable recipient;
+    }
+}
+
+interface BalancerV2Vault {
+    event AuthorizerChanged(address indexed newAuthorizer);
+    event ExternalBalanceTransfer(address indexed token, address indexed sender, address recipient, uint256 amount);
+    event FlashLoan(address indexed recipient, address indexed token, uint256 amount, uint256 feeAmount);
+    event InternalBalanceChanged(address indexed user, address indexed token, int256 delta);
+    event PausedStateChanged(bool paused);
+    event PoolBalanceChanged(bytes32 indexed poolId, address indexed liquidityProvider, address[] tokens, int256[] deltas, uint256[] protocolFeeAmounts);
+    event PoolBalanceManaged(bytes32 indexed poolId, address indexed assetManager, address indexed token, int256 cashDelta, int256 managedDelta);
+    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, IVault.PoolSpecialization specialization);
+    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
+    event Swap(bytes32 indexed poolId, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
+    event TokensDeregistered(bytes32 indexed poolId, address[] tokens);
+    event TokensRegistered(bytes32 indexed poolId, address[] tokens, address[] assetManagers);
+
+    constructor(address authorizer, address weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+
+    receive() external payable;
+
+    function WETH() external view returns (address);
+    function batchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds, int256[] memory limits, uint256 deadline) external payable returns (int256[] memory assetDeltas);
+    function deregisterTokens(bytes32 poolId, address[] memory tokens) external;
+    function exitPool(bytes32 poolId, address sender, address payable recipient, IVault.ExitPoolRequest memory request) external;
+    function flashLoan(address recipient, address[] memory tokens, uint256[] memory amounts, bytes memory userData) external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getDomainSeparator() external view returns (bytes32);
+    function getInternalBalance(address user, address[] memory tokens) external view returns (uint256[] memory balances);
+    function getNextNonce(address user) external view returns (uint256);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPool(bytes32 poolId) external view returns (address, IVault.PoolSpecialization);
+    function getPoolTokenInfo(bytes32 poolId, address token) external view returns (uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager);
+    function getPoolTokens(bytes32 poolId) external view returns (address[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+    function getProtocolFeesCollector() external view returns (address);
+    function hasApprovedRelayer(address user, address relayer) external view returns (bool);
+    function joinPool(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external payable;
+    function managePoolBalance(IVault.PoolBalanceOp[] memory ops) external;
+    function manageUserBalance(IVault.UserBalanceOp[] memory ops) external payable;
+    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external view returns (int256[] memory);
+    function registerPool(IVault.PoolSpecialization specialization) external returns (bytes32);
+    function registerTokens(bytes32 poolId, address[] memory tokens, address[] memory assetManagers) external;
+    function setAuthorizer(address newAuthorizer) external;
+    function setPaused(bool paused) external;
+    function setRelayerApproval(address sender, address relayer, bool approved) external;
+    function swap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds, uint256 limit, uint256 deadline) external payable returns (uint256 amountCalculated);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "authorizer",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      },
+      {
+        "name": "weth",
+        "type": "address",
+        "internalType": "contract IWETH"
+      },
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IWETH"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "batchSwap",
+    "inputs": [
+      {
+        "name": "kind",
+        "type": "uint8",
+        "internalType": "enum IVault.SwapKind"
+      },
+      {
+        "name": "swaps",
+        "type": "tuple[]",
+        "internalType": "struct IVault.BatchSwapStep[]",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "assetInIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assetOutIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "assets",
+        "type": "address[]",
+        "internalType": "contract IAsset[]"
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      },
+      {
+        "name": "limits",
+        "type": "int256[]",
+        "internalType": "int256[]"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "assetDeltas",
+        "type": "int256[]",
+        "internalType": "int256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "deregisterTokens",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "exitPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address payable"
+      },
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IVault.ExitPoolRequest",
+        "components": [
+          {
+            "name": "assets",
+            "type": "address[]",
+            "internalType": "contract IAsset[]"
+          },
+          {
+            "name": "minAmountsOut",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "flashLoan",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "contract IFlashLoanRecipient"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getDomainSeparator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getInternalBalance",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getNextNonce",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "enum IVault.PoolSpecialization"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolTokenInfo",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "cash",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "managed",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "assetManager",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolTokens",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeesCollector",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ProtocolFeesCollector"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "hasApprovedRelayer",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "joinPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IVault.JoinPoolRequest",
+        "components": [
+          {
+            "name": "assets",
+            "type": "address[]",
+            "internalType": "contract IAsset[]"
+          },
+          {
+            "name": "maxAmountsIn",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "managePoolBalance",
+    "inputs": [
+      {
+        "name": "ops",
+        "type": "tuple[]",
+        "internalType": "struct IVault.PoolBalanceOp[]",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.PoolBalanceOpKind"
+          },
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "manageUserBalance",
+    "inputs": [
+      {
+        "name": "ops",
+        "type": "tuple[]",
+        "internalType": "struct IVault.UserBalanceOp[]",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.UserBalanceOpKind"
+          },
+          {
+            "name": "asset",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "queryBatchSwap",
+    "inputs": [
+      {
+        "name": "kind",
+        "type": "uint8",
+        "internalType": "enum IVault.SwapKind"
+      },
+      {
+        "name": "swaps",
+        "type": "tuple[]",
+        "internalType": "struct IVault.BatchSwapStep[]",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "assetInIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assetOutIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "assets",
+        "type": "address[]",
+        "internalType": "contract IAsset[]"
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "int256[]",
+        "internalType": "int256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "registerPool",
+    "inputs": [
+      {
+        "name": "specialization",
+        "type": "uint8",
+        "internalType": "enum IVault.PoolSpecialization"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "registerTokens",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "assetManagers",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setAuthorizer",
+    "inputs": [
+      {
+        "name": "newAuthorizer",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setPaused",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setRelayerApproval",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "singleSwap",
+        "type": "tuple",
+        "internalType": "struct IVault.SingleSwap",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "assetIn",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "assetOut",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountCalculated",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "event",
+    "name": "AuthorizerChanged",
+    "inputs": [
+      {
+        "name": "newAuthorizer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExternalBalanceTransfer",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "FlashLoan",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IFlashLoanRecipient"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "feeAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "InternalBalanceChanged",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "delta",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolBalanceChanged",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "liquidityProvider",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "deltas",
+        "type": "int256[]",
+        "indexed": false,
+        "internalType": "int256[]"
+      },
+      {
+        "name": "protocolFeeAmounts",
+        "type": "uint256[]",
+        "indexed": false,
+        "internalType": "uint256[]"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolBalanceManaged",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "assetManager",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "cashDelta",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      },
+      {
+        "name": "managedDelta",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolRegistered",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "poolAddress",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "specialization",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum IVault.PoolSpecialization"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RelayerApprovalChanged",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Swap",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokenIn",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "tokenOut",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokensDeregistered",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "contract IERC20[]"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokensRegistered",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "assetManagers",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2Vault {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\x80`@R4\x80\x15b\0\0\x12W`\0\x80\xFD[P`@Qb\0n\xD68\x03\x80b\0n\xD6\x839\x81\x01`@\x81\x90Rb\0\x005\x91b\0\x02SV[\x83\x82\x82`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01p\x10\x98[\x18[\x98\xD9\\\x88\x15\x8C\x88\x15\x98][\x1D`z\x1B\x81RP\x80`@Q\x80`@\x01`@R\x80`\x01\x81R` \x01`1`\xF8\x1B\x81RP0`\x01`\x01`\xA0\x1B\x03\x16`\0\x1B\x89\x80`\x01`\x01`\xA0\x1B\x03\x16`\x80\x81`\x01`\x01`\xA0\x1B\x03\x16``\x1B\x81RPPP0`@Qb\0\0\xB8\x90b\0\x02EV[b\0\0\xC4\x91\x90b\0\x02\x9FV[`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15b\0\0\xE1W=`\0\x80>=`\0\xFD[P``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0R`\x01`\0U`\xC0R\x81Q` \x92\x83\x01 `\xE0R\x80Q\x91\x01 a\x01\0RP\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0Fa\x01 Rb\0\x01Hbv\xA7\0\x83\x11\x15a\x01\x94b\0\x01\x81V[b\0\x01\\b'\x8D\0\x82\x11\x15a\x01\x95b\0\x01\x81V[B\x90\x91\x01a\x01@\x81\x90R\x01a\x01`Rb\0\x01v\x81b\0\x01\x96V[PPPPPb\0\x02\xCCV[\x81b\0\x01\x92Wb\0\x01\x92\x81b\0\x01\xF2V[PPV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\x94\xB9y\xB6\x83\x1AQ)>&ABo\x97t\x7F\xEE\xD4o\x17w\x9F\xED\x9C\xD1\x8D\x1E\xCE\xFC\xFE\x92\xEF\x90`\0\x90\xA2`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16a\x01\0\x02a\x01\0`\x01`\xA8\x1B\x03\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[a\x0B\xE6\x80b\0b\xF0\x839\x01\x90V[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15b\0\x02iW\x83\x84\xFD[\x84Qb\0\x02v\x81b\0\x02\xB3V[` \x86\x01Q\x90\x94Pb\0\x02\x89\x81b\0\x02\xB3V[`@\x86\x01Q``\x90\x96\x01Q\x94\x97\x90\x96P\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x02\xC9W`\0\x80\xFD[PV[`\x80Q``\x1C`\xA0Q``\x1C`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa_\xC0b\0\x030`\09\x80a\x1A\xEDRP\x80a\x1A\xC9RP\x80a(\x9FRP\x80a(\xE1RP\x80a(\xC0RP\x80a\x10\xFDRP\x80a\x13\xB1RP\x80a\x05(RPa_\xC0`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\xA5W`\x005`\xE0\x1C\x80c\x94[\xCE\xC9\x11a\0\xE1W\x80c\xE6\xC4`\x92\x11a\0\x8AW\x80c\xF8M\x06n\x11a\0dW\x80c\xF8M\x06n\x14a\x04\x8AW\x80c\xF9MFh\x14a\x04\xAAW\x80c\xFAng\x1D\x14a\x04\xD9W\x80c\xFE\xC9\rr\x14a\x04\xF9Wa\x01\xD3V[\x80c\xE6\xC4`\x92\x14a\x04'W\x80c\xED$\x91\x1D\x14a\x04GW\x80c\xF6\xC0\t'\x14a\x04\\Wa\x01\xD3V[\x80c\xB0_\x8EH\x11a\0\xBBW\x80c\xB0_\x8EH\x14a\x03\xCFW\x80c\xB9\\\xAC(\x14a\x03\xFFW\x80c\xD2\x94l+\x14a\x04\x12Wa\x01\xD3V[\x80c\x94[\xCE\xC9\x14a\x03\x85W\x80c\xAA\xAB\xAD\xC5\x14a\x03\x98W\x80c\xAD\\FH\x14a\x03\xBAWa\x01\xD3V[\x80cR\xBB\xBE)\x11a\x01NW\x80c}:\xEB\x96\x11a\x01(W\x80c}:\xEB\x96\x14a\x03\x05W\x80c\x85\x1C\x1B\xB3\x14a\x03%W\x80c\x8B\xDB9\x13\x14a\x03EW\x80c\x90\x19;|\x14a\x03eWa\x01\xD3V[\x80cR\xBB\xBE)\x14a\x02\xB2W\x80c\\8D\x9E\x14a\x02\xC5W\x80cf\xA9\xC7\xD2\x14a\x02\xE5Wa\x01\xD3V[\x80c\x0FZn\xFA\x11a\x01\x7FW\x80c\x0FZn\xFA\x14a\x02AW\x80c\x16\xC3\x8B<\x14a\x02nW\x80c\x1C\r\xE0Q\x14a\x02\x8EWa\x01\xD3V[\x80c\x05\x8Ab\x8F\x14a\x01\xD8W\x80c\t\xB2v\x0F\x14a\x01\xF8W\x80c\x0E\x8E>\x84\x14a\x02.Wa\x01\xD3V[6a\x01\xD3Wa\x01\xD1a\x01\xB5a\x05&V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x06a\x05KV[\0[`\0\x80\xFD[4\x80\x15a\x01\xE4W`\0\x80\xFD[Pa\x01\xD1a\x01\xF36`\x04aQWV[a\x05]V[4\x80\x15a\x02\x04W`\0\x80\xFD[Pa\x02\x18a\x02\x136`\x04aV\xE6V[a\x05\x81V[`@Qa\x02%\x91\x90a]>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xD1a\x02<6`\x04aS\x1EV[a\x064V[4\x80\x15a\x02MW`\0\x80\xFD[Pa\x02aa\x02\\6`\x04aQ\xF5V[a\x07pV[`@Qa\x02%\x91\x90a]\x08V[4\x80\x15a\x02zW`\0\x80\xFD[Pa\x01\xD1a\x02\x896`\x04aT\\V[a\x08\x06V[4\x80\x15a\x02\x9AW`\0\x80\xFD[Pa\x02\xA3a\x08\x1FV[`@Qa\x02%\x93\x92\x91\x90a]&V[a\x02\x18a\x02\xC06`\x04aX\x8FV[a\x08HV[4\x80\x15a\x02\xD1W`\0\x80\xFD[Pa\x01\xD1a\x02\xE06`\x04aV[V[a\t\xE9V[4\x80\x15a\x02\xF1W`\0\x80\xFD[Pa\x01\xD1a\x03\x006`\x04aUEV[a\x0E\x06V[4\x80\x15a\x03\x11W`\0\x80\xFD[Pa\x01\xD1a\x03 6`\x04aU\x16V[a\x0F\xA5V[4\x80\x15a\x031W`\0\x80\xFD[Pa\x02\x18a\x03@6`\x04aV3V[a\x10\xF9V[4\x80\x15a\x03QW`\0\x80\xFD[Pa\x01\xD1a\x03`6`\x04aT\xACV[a\x11KV[4\x80\x15a\x03qW`\0\x80\xFD[Pa\x02\x18a\x03\x806`\x04aQWV[a\x11aV[a\x02aa\x03\x936`\x04aW\x86V[a\x11|V[4\x80\x15a\x03\xA4W`\0\x80\xFD[Pa\x03\xADa\x12\xB0V[`@Qa\x02%\x91\x90a[cV[4\x80\x15a\x03\xC6W`\0\x80\xFD[Pa\x03\xADa\x12\xC4V[4\x80\x15a\x03\xDBW`\0\x80\xFD[Pa\x03\xEFa\x03\xEA6`\x04aV\x0FV[a\x12\xD3V[`@Qa\x02%\x94\x93\x92\x91\x90a^\xB9V[a\x01\xD1a\x04\r6`\x04aT\xACV[a\x13\x96V[4\x80\x15a\x04\x1EW`\0\x80\xFD[Pa\x03\xADa\x13\xAFV[4\x80\x15a\x043W`\0\x80\xFD[Pa\x01\xD1a\x04B6`\x04aRCV[a\x13\xD3V[4\x80\x15a\x04SW`\0\x80\xFD[Pa\x02\x18a\x14\xEFV[4\x80\x15a\x04hW`\0\x80\xFD[Pa\x04|a\x04w6`\x04aT\x94V[a\x14\xF9V[`@Qa\x02%\x92\x91\x90a[\x9BV[4\x80\x15a\x04\x96W`\0\x80\xFD[Pa\x02aa\x04\xA56`\x04aW\x02V[a\x15#V[4\x80\x15a\x04\xB6W`\0\x80\xFD[Pa\x04\xCAa\x04\xC56`\x04aT\x94V[a\x16 V[`@Qa\x02%\x93\x92\x91\x90a\\\xD2V[4\x80\x15a\x04\xE5W`\0\x80\xFD[Pa\x01\xD1a\x04\xF46`\x04aQ\xABV[a\x16TV[4\x80\x15a\x05\x05W`\0\x80\xFD[Pa\x05\x19a\x05\x146`\x04aQsV[a\x16\xE6V[`@Qa\x02%\x91\x90a]\x1BV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0[\x90V[\x81a\x05YWa\x05Y\x81a\x16\xFBV[PPV[a\x05ea\x17hV[a\x05ma\x17\x81V[a\x05v\x81a\x17\xAFV[a\x05~a\x18\"V[PV[`\0a\x05\x8Ba\x17hV[a\x05\x93a\x18)V[`\0a\x05\xA23\x84`\x06Ta\x18>V[`\0\x81\x81R`\x05` R`@\x90 T\x90\x91Pa\x05\xC4\x90`\xFF\x16\x15a\x01\xF4a\x05KV[`\0\x81\x81R`\x05` R`@\x90\x81\x90 \x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91U`\x06\x80T\x90\x91\x01\x90UQ3\x90\x82\x90\x7F<\x13\xBC0\xB8\xE8x\xC5?\xD2\xA3kg\x94\t\xC0s\xAF\xD7YP\xBEC\xD8\x85\x87h\xE9V\xFB\xC2\x0E\x90a\x06\x1D\x90\x87\x90a^:V[`@Q\x80\x91\x03\x90\xA3\x90Pa\x06/a\x18\"V[\x91\x90PV[a\x06<a\x17hV[`\0\x80`\0\x80[\x84Q\x81\x10\x15a\x07[W`\0\x80`\0\x80`\0a\x06q\x8A\x87\x81Q\x81\x10a\x06cW\xFE[` \x02` \x01\x01Q\x89a\x18}V[\x9CP\x93\x98P\x91\x96P\x94P\x92P\x90P`\x01\x85`\x03\x81\x11\x15a\x06\x8DW\xFE[\x14\x15a\x06\xA4Wa\x06\x9F\x84\x83\x83\x86a\x18\xF5V[a\x07JV[\x86a\x06\xB6Wa\x06\xB1a\x18)V[`\x01\x96P[`\0\x85`\x03\x81\x11\x15a\x06\xC4W\xFE[\x14\x15a\x06\xF5Wa\x06\xD6\x84\x83\x83\x86a\x19\x18V[a\x06\xDF\x84a\x198V[\x15a\x06\x9FWa\x06\xEE\x89\x84a\x19EV[\x98Pa\x07JV[a\x07\na\x07\x01\x85a\x198V[\x15a\x02\x07a\x05KV[`\0a\x07\x15\x85a\x05HV[\x90P`\x02\x86`\x03\x81\x11\x15a\x07%W\xFE[\x14\x15a\x07<Wa\x077\x81\x84\x84\x87a\x19WV[a\x07HV[a\x07H\x81\x84\x84\x87a\x19pV[P[PP`\x01\x90\x93\x01\x92Pa\x06C\x91PPV[Pa\x07e\x83a\x19\xDEV[PPPa\x05~a\x18\"V[``\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x07\x8AW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\xB4W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x82Q\x81\x10\x15a\x07\xFFWa\x07\xE0\x84\x84\x83\x81Q\x81\x10a\x07\xD3W\xFE[` \x02` \x01\x01Qa\x1A\x01V[\x82\x82\x81Q\x81\x10a\x07\xECW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07\xBAV[P\x92\x91PPV[a\x08\x0Ea\x17hV[a\x08\x16a\x17\x81V[a\x05v\x81a\x1A,V[`\0\x80`\0a\x08,a\x1A\xAAV[\x15\x92Pa\x087a\x1A\xC7V[\x91Pa\x08Aa\x1A\xEBV[\x90P\x90\x91\x92V[`\0a\x08Ra\x17hV[a\x08Za\x18)V[\x83Qa\x08e\x81a\x1B\x0FV[a\x08t\x83B\x11\x15a\x01\xFCa\x05KV[a\x08\x87`\0\x87`\x80\x01Q\x11a\x01\xFEa\x05KV[`\0a\x08\x96\x87`@\x01Qa\x1BAV[\x90P`\0a\x08\xA7\x88``\x01Qa\x1BAV[\x90Pa\x08\xCA\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x01\xFDa\x05KV[a\x08\xD2aL\xE1V[\x88Q`\x80\x82\x01R` \x89\x01Q\x81\x90`\x01\x81\x11\x15a\x08\xEBW\xFE[\x90\x81`\x01\x81\x11\x15a\x08\xF8W\xFE[\x90RP`\x01`\x01`\xA0\x1B\x03\x80\x84\x16` \x83\x01R\x82\x81\x16`@\x80\x84\x01\x91\x90\x91R`\x80\x8B\x01Q``\x84\x01R`\xA0\x8B\x01Qa\x01\0\x84\x01R\x89Q\x82\x16`\xC0\x84\x01R\x89\x01Q\x16`\xE0\x82\x01R`\0\x80a\tJ\x83a\x1BfV[\x91\x98P\x92P\x90Pa\t\x81`\0\x8C` \x01Q`\x01\x81\x11\x15a\tfW\xFE[\x14a\ttW\x89\x83\x11\x15a\tyV[\x89\x82\x10\x15[a\x01\xFBa\x05KV[a\t\x99\x8B`@\x01Q\x83\x8C`\0\x01Q\x8D` \x01Qa\x1CZV[a\t\xB1\x8B``\x01Q\x82\x8C`@\x01Q\x8D``\x01Qa\x1D8V[a\t\xD3a\t\xC1\x8C`@\x01Qa\x198V[a\t\xCCW`\0a\t\xCEV[\x82[a\x19\xDEV[PPPPPPa\t\xE1a\x18\"V[\x94\x93PPPPV[a\t\xF1a\x17hV[a\t\xF9a\x18)V[a\n\x05\x83Q\x83Qa\x1E\x12V[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\n\x1FW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\nIW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P``\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\nfW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x86Q\x81\x10\x15a\x0C\tW`\0\x87\x82\x81Q\x81\x10a\n\xAEW\xFE[` \x02` \x01\x01Q\x90P`\0\x87\x83\x81Q\x81\x10a\n\xC6W\xFE[` \x02` \x01\x01Q\x90Pa\x0B\x11\x84`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x11`\0`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0B\tW`fa\x0B\x0CV[`h[a\x05KV[\x81\x93P\x81`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0B@\x91\x90a[cV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x0BXW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x0BlW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x90\x91\x90aYhV[\x85\x84\x81Q\x81\x10a\x0B\x9CW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0B\xB1\x81a\x1E\x1FV[\x86\x84\x81Q\x81\x10a\x0B\xBDW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0B\xEB\x81\x86\x85\x81Q\x81\x10a\x0B\xD9W\xFE[` \x02` \x01\x01Q\x10\x15a\x02\x10a\x05KV[a\x0B\xFF`\x01`\x01`\xA0\x1B\x03\x83\x16\x8B\x83a\x1E\xA6V[PP`\x01\x01a\n\x97V[P`@Q\x7F\xF0O'\x07\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x88\x16\x90c\xF0O'\x07\x90a\x0CU\x90\x89\x90\x89\x90\x88\x90\x8A\x90`\x04\x01a\\\x85V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x0CoW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0C\x83W=`\0\x80>=`\0\xFD[PPPP`\0[\x86Q\x81\x10\x15a\r\xF4W`\0\x87\x82\x81Q\x81\x10a\x0C\xA1W\xFE[` \x02` \x01\x01Q\x90P`\0\x84\x83\x81Q\x81\x10a\x0C\xB9W\xFE[` \x02` \x01\x01Q\x90P`\0\x82`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0C\xF1\x91\x90a[cV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\r\tW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\r\x1DW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\rA\x91\x90aYhV[\x90Pa\rR\x82\x82\x10\x15a\x02\x03a\x05KV[`\0\x82\x82\x03\x90Pa\r{\x88\x86\x81Q\x81\x10a\rhW\xFE[` \x02` \x01\x01Q\x82\x10\x15a\x02Za\x05KV[a\r\x85\x84\x82a\x1F\x11V[\x83`\x01`\x01`\xA0\x1B\x03\x16\x8C`\x01`\x01`\xA0\x1B\x03\x16\x7F\r}u\xE0\x1A\xB9W\x80\xD3\xCD\x1C\x8E\xC0\xDDl,\xE1\x9E: B~\xEC\x8B\xF52\x83\xB6\xFB\x8E\x95\xF0\x8C\x88\x81Q\x81\x10a\r\xC6W\xFE[` \x02` \x01\x01Q\x84`@Qa\r\xDD\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA3PPPP\x80`\x01\x01\x90Pa\x0C\x8AV[PPPPa\x0E\0a\x18\"V[PPPPV[a\x0E\x0Ea\x17hV[a\x0E\x16a\x18)V[\x82a\x0E \x81a\x1F3V[a\x0E,\x83Q\x83Qa\x1E\x12V[`\0[\x83Q\x81\x10\x15a\x0E\xCAW`\0\x84\x82\x81Q\x81\x10a\x0EFW\xFE[` \x02` \x01\x01Q\x90Pa\x0Er`\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x015a\x05KV[\x83\x82\x81Q\x81\x10a\x0E~W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\0\x88\x81R`\n\x83R`@\x80\x82 `\x01`\x01`\xA0\x1B\x03\x95\x86\x16\x83R\x90\x93R\x91\x90\x91 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x92\x90\x91\x16\x91\x90\x91\x17\x90U`\x01\x01a\x0E/V[P`\0a\x0E\xD6\x85a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x0E\xE6W\xFE[\x14\x15a\x0F4Wa\x0E\xFC\x84Q`\x02\x14a\x02\x0Ca\x05KV[a\x0F/\x85\x85`\0\x81Q\x81\x10a\x0F\rW\xFE[` \x02` \x01\x01Q\x86`\x01\x81Q\x81\x10a\x0F\"W\xFE[` \x02` \x01\x01Qa\x1F~V[a\x0F\\V[`\x01\x81`\x02\x81\x11\x15a\x0FBW\xFE[\x14\x15a\x0FRWa\x0F/\x85\x85a *V[a\x0F\\\x85\x85a \x82V[\x84\x7F\xF5\x84}?!\x97\xB1l\xDC\xD2\t\x8E\xC9]\t\x05\xCD\x1A\xBD\xAFA_\x07\xBB|\xEF+\xBA\x8A\xC5\xDE\xC4\x85\x85`@Qa\x0F\x8E\x92\x91\x90a[\xEDV[`@Q\x80\x91\x03\x90\xA2PPa\x0F\xA0a\x18\"V[PPPV[a\x0F\xADa\x17hV[a\x0F\xB5a\x18)V[\x81a\x0F\xBF\x81a\x1F3V[`\0a\x0F\xCA\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x0F\xDAW\xFE[\x14\x15a\x10(Wa\x0F\xF0\x83Q`\x02\x14a\x02\x0Ca\x05KV[a\x10#\x84\x84`\0\x81Q\x81\x10a\x10\x01W\xFE[` \x02` \x01\x01Q\x85`\x01\x81Q\x81\x10a\x10\x16W\xFE[` \x02` \x01\x01Qa \xD7V[a\x10PV[`\x01\x81`\x02\x81\x11\x15a\x106W\xFE[\x14\x15a\x10FWa\x10#\x84\x84a!EV[a\x10P\x84\x84a!\xFFV[`\0[\x83Q\x81\x10\x15a\x10\xB6W`\n`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x85\x83\x81Q\x81\x10a\x10}W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x82R\x81\x01\x91\x90\x91R`@\x01`\0 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U`\x01\x01a\x10SV[P\x83\x7F}\xCD\xC6\xD0.\xF4\x0C|\x1ApF\xA0\x11\xB0X\xBD\x7F\x98\x8F\xA1N \xA6cD\xF9\xD4\xE6\x06W\xD6\x10\x84`@Qa\x10\xE7\x91\x90a[\xDAV[`@Q\x80\x91\x03\x90\xA2PPa\x05Ya\x18\"V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x11.\x92\x91\x90aZ\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x0E\0`\x01\x85\x85\x85a\x11\\\x86a\"bV[a\"nV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02` R`@\x90 T\x90V[``a\x11\x86a\x17hV[a\x11\x8Ea\x18)V[\x83Qa\x11\x99\x81a\x1B\x0FV[a\x11\xA8\x83B\x11\x15a\x01\xFCa\x05KV[a\x11\xB4\x86Q\x85Qa\x1E\x12V[a\x11\xC0\x87\x87\x87\x8Ba#\xF4V[\x91P`\0\x80[\x87Q\x81\x10\x15a\x12\x92W`\0\x88\x82\x81Q\x81\x10a\x11\xDDW\xFE[` \x02` \x01\x01Q\x90P`\0\x85\x83\x81Q\x81\x10a\x11\xF5W\xFE[` \x02` \x01\x01Q\x90Pa\x12!\x88\x84\x81Q\x81\x10a\x12\x0EW\xFE[` \x02` \x01\x01Q\x82\x13\x15a\x01\xFBa\x05KV[`\0\x81\x13\x15a\x12aW\x88Q` \x8A\x01Q\x82\x91a\x12@\x91\x85\x91\x84\x91a\x1CZV[a\x12I\x83a\x198V[\x15a\x12[Wa\x12X\x85\x82a\x19EV[\x94P[Pa\x12\x88V[`\0\x81\x12\x15a\x12\x88W`\0\x81`\0\x03\x90Pa\x12\x86\x83\x82\x8C`@\x01Q\x8D``\x01Qa\x1D8V[P[PP`\x01\x01a\x11\xC6V[Pa\x12\x9C\x81a\x19\xDEV[PPa\x12\xA6a\x18\"V[\x96\x95PPPPPPV[`\x03Ta\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\0a\x12\xCEa\x05&V[\x90P\x90V[`\0\x80`\0\x80\x85a\x12\xE3\x81a&\x83V[`\0\x80a\x12\xEF\x89a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x12\xFFW\xFE[\x14\x15a\x13\x16Wa\x13\x0F\x89\x89a&\xA1V[\x91Pa\x13AV[`\x01\x81`\x02\x81\x11\x15a\x13$W\xFE[\x14\x15a\x134Wa\x13\x0F\x89\x89a'\x1BV[a\x13>\x89\x89a'\x89V[\x91P[a\x13J\x82a'\xA1V[\x96Pa\x13U\x82a'\xB4V[\x95Pa\x13`\x82a'\xCAV[`\0\x99\x8AR`\n` \x90\x81R`@\x80\x8C `\x01`\x01`\xA0\x1B\x03\x9B\x8C\x16\x8DR\x90\x91R\x90\x99 T\x96\x99\x95\x98\x97\x96\x90\x96\x16\x95PPPPPV[a\x13\x9Ea\x18)V[a\x0E\0`\0\x85\x85\x85a\x11\\\x86a\"bV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[a\x13\xDBa\x17hV[a\x13\xE3a\x18)V[a\x13\xEBaM1V[`\0[\x82Q\x81\x10\x15a\x14\xE5W\x82\x81\x81Q\x81\x10a\x14\x03W\xFE[` \x02` \x01\x01Q\x91P`\0\x82` \x01Q\x90Pa\x14\x1F\x81a&\x83V[`@\x83\x01Qa\x149a\x141\x83\x83a'\xD0V[a\x02\ta\x05KV[`\0\x82\x81R`\n` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x85R\x92R\x90\x91 Ta\x14l\x91\x163\x14a\x01\xF6a\x05KV[\x83Q``\x85\x01Q`\0\x80a\x14\x82\x84\x87\x87\x86a(,V[\x91P\x91P\x84`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x87\x7Fn\xDC\xAFbA\x10[L\x94\xC2\xEF\xDB\xF3\xA6\xB1$X\xEB=\x07\xBE:\x0E\x81\xD2K\x13\xC4@E\xFEz\x85\x85`@Qa\x14\xCC\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA4PPPPPP\x80`\x01\x01\x90Pa\x13\xEEV[PPa\x05~a\x18\"V[`\0a\x12\xCEa(\x9BV[`\0\x80\x82a\x15\x06\x81a&\x83V[a\x15\x0F\x84a)8V[a\x15\x18\x85a\x1FdV[\x92P\x92P[P\x91P\x91V[``30\x14a\x15\xF6W`\x000`\x01`\x01`\xA0\x1B\x03\x16`\x006`@Qa\x15I\x92\x91\x90aZ\xDAV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x15\x86W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x15\x8BV[``\x91P[PP\x90P\x80`\0\x81\x14a\x15\x9AW\xFE[`\x04`\0\x80>`\0Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x7F\xFAa\xCC\x12\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x15\xDEW=`\0\x80>=`\0\xFD[P` `\0R`\x04=\x03\x80`\x04` >` \x81\x01`\0\xF3[``a\x16\x04\x85\x85\x85\x89a#\xF4V[\x90P` \x81Q\x02c\xFAa\xCC\x12` \x83\x03R`\x04\x82\x03`$\x82\x01\x81\xFD[``\x80`\0\x83a\x16/\x81a&\x83V[``a\x16:\x86a)>V[\x90\x95P\x90Pa\x16H\x81a)\xA0V[\x95\x97\x90\x96P\x93PPPPV[a\x16\\a\x17hV[a\x16da\x18)V[\x82a\x16n\x81a\x1B\x0FV[`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\0\x81\x81R`\x04` \x90\x81R`@\x80\x83 \x94\x88\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x80T`\xFF\x19\x16\x86\x15\x15\x17\x90UQ\x90\x91\x90\x7FF\x96\x1F\xDBE\x02\xB6F\xD5\t_\xBAv\0Hj\x8A\xC0PA\xD5\\\xDF\x0F\x16\xEDgq\x80\xB5\xCA\xD8\x90a\x16\xD5\x90\x86\x90a]\x1BV[`@Q\x80\x91\x03\x90\xA3Pa\x0F\xA0a\x18\"V[`\0a\x16\xF2\x83\x83a*OV[\x90P[\x92\x91PPV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[a\x17z`\x02`\0T\x14\x15a\x01\x90a\x05KV[`\x02`\0UV[`\0a\x17\x98`\x005`\x01`\x01`\xE0\x1B\x03\x19\x16a\x10\xF9V[\x90Pa\x05~a\x17\xA7\x823a*}V[a\x01\x91a\x05KV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\x94\xB9y\xB6\x83\x1AQ)>&ABo\x97t\x7F\xEE\xD4o\x17w\x9F\xED\x9C\xD1\x8D\x1E\xCE\xFC\xFE\x92\xEF\x90`\0\x90\xA2`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16a\x01\0\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\x90\x92\x16\x91\x90\x91\x17\x90UV[`\x01`\0UV[a\x18<a\x184a\x1A\xAAV[a\x01\x92a\x05KV[V[`\0i\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16`P\x84`\x02\x81\x11\x15a\x18[W\xFE[\x90\x1B\x17``\x85\x90\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x17\x90P[\x93\x92PPPV[`\0\x80`\0\x80`\0\x80`\0\x88``\x01Q\x90P3`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14a\x18\xCFW\x87a\x18\xBAWa\x18\xB5a\x17\x81V[`\x01\x97P[a\x18\xCFa\x18\xC7\x823a*OV[a\x01\xF7a\x05KV[\x88Q` \x8A\x01Q`@\x8B\x01Q`\x80\x90\x9B\x01Q\x91\x9B\x90\x9A\x99\x92\x98P\x90\x96P\x90\x94P\x92PPPV[a\x19\n\x83a\x19\x02\x86a\x1BAV[\x83`\0a+ V[Pa\x0E\0\x84\x82\x84`\0a\x1D8V[a\x19+\x82a\x19%\x86a\x1BAV[\x83a+vV[a\x0E\0\x84\x82\x85`\0a\x1CZV[`\x01`\x01`\xA0\x1B\x03\x16\x15\x90V[`\0\x82\x82\x01a\x16\xF2\x84\x82\x10\x15\x83a\x05KV[a\x19d\x83\x85\x83`\0a+ V[Pa\x0E\0\x82\x85\x83a+vV[\x80\x15a\x0E\0Wa\x19\x8B`\x01`\x01`\xA0\x1B\x03\x85\x16\x84\x84\x84a+\xA6V[\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x7FT\n\x1A?(4\x0C\xAE\xC36\xC8\x1D\x8D{=\xF19\xEE\\\xDC\x189\xA4\xF2\x83\xD7\xEB\xB7\xEA\xAE-\\\x84\x84`@Qa\x19\xD0\x92\x91\x90a[\xC1V[`@Q\x80\x91\x03\x90\xA3PPPPV[a\x19\xED\x814\x10\x15a\x02\x04a\x05KV[4\x81\x90\x03\x80\x15a\x05YWa\x05Y3\x82a+\xC7V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x0B` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[\x80\x15a\x1ALWa\x1AGa\x1A=a\x1A\xC7V[B\x10a\x01\x93a\x05KV[a\x1AaV[a\x1Aaa\x1AWa\x1A\xEBV[B\x10a\x01\xA9a\x05KV[`\x03\x80T`\xFF\x19\x16\x82\x15\x15\x17\x90U`@Q\x7F\x9E:^7\"E2\xDE\xA6{\x89\xFA\xCE\x18W\x03s\x8A\"\x8An\x8A#\xDE\xE5F\x96\x01\x80\xD3\xBEd\x90a\x1A\x9F\x90\x83\x90a]\x1BV[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x1A\xB4a\x1A\xEBV[B\x11\x80a\x12\xCEWPP`\x03T`\xFF\x16\x15\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[3`\x01`\x01`\xA0\x1B\x03\x82\x16\x14a\x05~Wa\x1B'a\x17\x81V[a\x1B1\x813a*OV[a\x05~Wa\x05~\x81a\x01\xF7a,AV[`\0a\x1BL\x82a\x198V[a\x1B^Wa\x1BY\x82a\x05HV[a\x16\xF5V[a\x16\xF5a\x05&V[`\0\x80`\0\x80a\x1By\x85`\x80\x01Qa)8V[\x90P`\0a\x1B\x8A\x86`\x80\x01Qa\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x1B\x9AW\xFE[\x14\x15a\x1B\xB1Wa\x1B\xAA\x86\x83a,uV[\x94Pa\x1B\xDCV[`\x01\x81`\x02\x81\x11\x15a\x1B\xBFW\xFE[\x14\x15a\x1B\xCFWa\x1B\xAA\x86\x83a-%V[a\x1B\xD9\x86\x83a-\xB8V[\x94P[a\x1B\xEF\x86`\0\x01Q\x87``\x01Q\x87a/\xF7V[\x80\x94P\x81\x95PPP\x85`@\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x86` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x87`\x80\x01Q\x7F!p\xC7A\xC4\x151\xAE\xC2\x0E|\x10|$\xEE\xCF\xDD\x15\xE6\x9C\x9B\xB0\xA8\xDD7\xB1\x84\x0B\x9E\x0B {\x87\x87`@Qa\x1CI\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA4PP\x91\x93\x90\x92PV[\x82a\x1CdWa\x0E\0V[a\x1Cm\x84a\x198V[\x15a\x1C\xEEWa\x1C\x7F\x81\x15a\x02\x02a\x05KV[a\x1C\x8E\x83G\x10\x15a\x02\x04a\x05KV[a\x1C\x96a\x05&V[`\x01`\x01`\xA0\x1B\x03\x16c\xD0\xE3\r\xB0\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x1C\xD0W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1C\xE4W=`\0\x80>=`\0\xFD[PPPPPa\x0E\0V[`\0a\x1C\xF9\x85a\x05HV[\x90P\x81\x15a\x1D\x16W`\0a\x1D\x10\x84\x83\x87`\x01a+ V[\x90\x94\x03\x93P[\x83\x15a\x1D1Wa\x1D1`\x01`\x01`\xA0\x1B\x03\x82\x16\x840\x87a+\xA6V[PPPPPV[\x82a\x1DBWa\x0E\0V[a\x1DK\x84a\x198V[\x15a\x1D\xDBWa\x1D]\x81\x15a\x02\x02a\x05KV[a\x1Dea\x05&V[`\x01`\x01`\xA0\x1B\x03\x16c.\x1A}M\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1D\x90\x91\x90a]>V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x1D\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1D\xBEW=`\0\x80>=`\0\xFD[Pa\x1D\xD6\x92PPP`\x01`\x01`\xA0\x1B\x03\x83\x16\x84a+\xC7V[a\x0E\0V[`\0a\x1D\xE6\x85a\x05HV[\x90P\x81\x15a\x1D\xFEWa\x1D\xF9\x83\x82\x86a+vV[a\x1D1V[a\x1D1`\x01`\x01`\xA0\x1B\x03\x82\x16\x84\x86a\x1E\xA6V[a\x05Y\x81\x83\x14`ga\x05KV[`\0\x80a\x1E*a\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x16c\xD8w\x84\\`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1EbW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1EvW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1E\x9A\x91\x90aYhV[\x90Pa\x18v\x83\x82a0%V[a\x0F\xA0\x83c\xA9\x05\x9C\xBB`\xE0\x1B\x84\x84`@Q`$\x01a\x1E\xC5\x92\x91\x90a[\xC1V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x90\x91Ra0rV[\x80\x15a\x05YWa\x05Ya\x1F\"a\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x84\x16\x90\x83a\x1E\xA6V[a\x1F<\x81a&\x83V[a\x05~a\x1FH\x82a)8V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x01\xF5a\x05KV[`\0a\xFF\xFF`P\x83\x90\x1C\x16a\x16\xF5`\x03\x82\x10a\x01\xF4a\x05KV[a\x1F\x9F\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x02\na\x05KV[a\x1F\xBE\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x10`fa\x05KV[`\0\x83\x81R`\t` R`@\x90 \x80Ta\x1F\xFB\x90`\x01`\x01`\xA0\x1B\x03\x16\x15\x80\x15a\x1F\xF3WP`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15[a\x02\x0Ba\x05KV[\x80T`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x01`\x01`\xA0\x1B\x03\x19\x91\x82\x16\x17\x82U`\x01\x90\x91\x01\x80T\x92\x90\x93\x16\x91\x16\x17\x90UPV[`\0\x82\x81R`\x08` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0a k\x84\x83\x81Q\x81\x10a TW\xFE[` \x02` \x01\x01Q\x84a1\x12\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90Pa y\x81a\x02\na\x05KV[P`\x01\x01a :V[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0a \xC0\x84\x83\x81Q\x81\x10a \xACW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01Q\x84\x90`\0a1uV[\x90Pa \xCE\x81a\x02\na\x05KV[P`\x01\x01a \x92V[`\0\x80`\0a \xE7\x86\x86\x86a2\"V[\x92P\x92P\x92Pa!\x11a \xF9\x84a2\xE9V[\x80\x15a!\tWPa!\t\x83a2\xE9V[a\x02\ra\x05KV[`\0\x95\x86R`\t` R`@\x86 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16\x82U`\x01\x90\x91\x01\x80T\x90\x91\x16\x90U\x94\x90\x94UPPPPV[`\0\x82\x81R`\x08` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0\x83\x82\x81Q\x81\x10a!lW\xFE[` \x02` \x01\x01Q\x90Pa!\xB8a!\t`\x07`\0\x88\x81R` \x01\x90\x81R` \x01`\0 `\0\x84`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01`\0 Ta2\xE9V[`\0\x85\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 \x81\x90Ua!\xE7\x84\x83a3\x0BV[\x90Pa!\xF5\x81a\x02\ta\x05KV[PP`\x01\x01a!UV[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0\x83\x82\x81Q\x81\x10a\"&W\xFE[` \x02` \x01\x01Q\x90P`\0a\"<\x84\x83a4\x12V[\x90Pa\"Ja!\t\x82a2\xE9V[a\"T\x84\x83a4!V[PPP\x80`\x01\x01\x90Pa\"\x0FV[a\"jaMZV[P\x90V[a\"va\x17hV[\x83a\"\x80\x81a&\x83V[\x83a\"\x8A\x81a\x1B\x0FV[a\"\x9E\x83`\0\x01QQ\x84` \x01QQa\x1E\x12V[``a\"\xAD\x84`\0\x01Qa4\xC3V[\x90P``a\"\xBB\x88\x83a5RV[\x90P``\x80``a\"\xD0\x8C\x8C\x8C\x8C\x8C\x89a5\xE3V[\x92P\x92P\x92P`\0a\"\xE1\x8Ca\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\"\xF1W\xFE[\x14\x15a#YWa#T\x8C\x87`\0\x81Q\x81\x10a#\x08W\xFE[` \x02` \x01\x01Q\x86`\0\x81Q\x81\x10a#\x1DW\xFE[` \x02` \x01\x01Q\x89`\x01\x81Q\x81\x10a#2W\xFE[` \x02` \x01\x01Q\x88`\x01\x81Q\x81\x10a#GW\xFE[` \x02` \x01\x01Qa7\xA8V[a#\x82V[`\x01\x81`\x02\x81\x11\x15a#gW\xFE[\x14\x15a#xWa#T\x8C\x87\x86a7\xE7V[a#\x82\x8C\x85a8TV[`\0\x80\x8E`\x01\x81\x11\x15a#\x91W\xFE[\x14\x90P\x8B`\x01`\x01`\xA0\x1B\x03\x16\x8D\x7F\xE5\xCE$\x90\x87\xCE\x04\xF0Z\x95q\x92CT\0\xFD\x97\x86\x8D\xBA\x0EjKL\x04\x9A\xBF\x8A\xF8\r\xAEx\x89a#\xCB\x88\x86a8\x9DV[\x87`@Qa#\xDB\x93\x92\x91\x90a\\LV[`@Q\x80\x91\x03\x90\xA3PPPPPPPPPa\x1D1a\x18\"V[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a$\x0EW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a$8W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90Pa$CaM\x84V[a$KaL\xE1V[`\0\x80`\0[\x89Q\x81\x10\x15a&vW\x89\x81\x81Q\x81\x10a$fW\xFE[` \x02` \x01\x01Q\x94P`\0\x89Q\x86` \x01Q\x10\x80\x15a$\x8AWP\x89Q\x86`@\x01Q\x10[\x90Pa$\x97\x81`da\x05KV[`\0a$\xB9\x8B\x88` \x01Q\x81Q\x81\x10a$\xACW\xFE[` \x02` \x01\x01Qa\x1BAV[\x90P`\0a$\xD0\x8C\x89`@\x01Q\x81Q\x81\x10a$\xACW\xFE[\x90Pa$\xF3\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x01\xFDa\x05KV[``\x88\x01Qa%CWa%\x0B`\0\x85\x11a\x01\xFEa\x05KV[`\0a%\x18\x8B\x84\x84a9EV[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa%:\x81a\x01\xFFa\x05KV[P``\x88\x01\x85\x90R[\x87Q`\x80\x88\x01R\x86\x8A`\x01\x81\x11\x15a%WW\xFE[\x90\x81`\x01\x81\x11\x15a%dW\xFE[\x90RP`\x01`\x01`\xA0\x1B\x03\x80\x83\x16` \x89\x01R\x81\x81\x16`@\x80\x8A\x01\x91\x90\x91R``\x80\x8B\x01Q\x90\x8A\x01R`\x80\x8A\x01Qa\x01\0\x8A\x01R\x8CQ\x82\x16`\xC0\x8A\x01R\x8C\x01Q\x16`\xE0\x88\x01R`\0\x80a%\xB6\x89a\x1BfV[\x91\x98P\x92P\x90Pa%\xC8\x8C\x85\x85a9gV[\x97Pa%\xFCa%\xD6\x83a9\x81V[\x8C\x8C` \x01Q\x81Q\x81\x10a%\xE6W\xFE[` \x02` \x01\x01Qa9\xB1\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x8B\x8B` \x01Q\x81Q\x81\x10a&\x0CW\xFE[` \x02` \x01\x01\x81\x81RPPa&Ja&$\x82a9\x81V[\x8C\x8C`@\x01Q\x81Q\x81\x10a&4W\xFE[` \x02` \x01\x01Qa9\xE5\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x8B\x8B`@\x01Q\x81Q\x81\x10a&ZW\xFE[` \x02` \x01\x01\x81\x81RPPPPPPP\x80`\x01\x01\x90Pa$QV[PPPPP\x94\x93PPPPV[`\0\x81\x81R`\x05` R`@\x90 Ta\x05~\x90`\xFF\x16a\x01\xF4a\x05KV[`\0\x80`\0\x80`\0a&\xB2\x87a:\x19V[\x94P\x94P\x94P\x94PP\x83`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a&\xE1W\x82\x94PPPPPa\x16\xF5V[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a'\x06W\x93Pa\x16\xF5\x92PPPV[a'\x11a\x02\ta\x16\xFBV[PPPP\x92\x91PPV[`\0\x82\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 T\x81a'H\x82a:\x8FV[\x80a'fWP`\0\x85\x81R`\x08` R`@\x90 a'f\x90\x85a:\xA1V[\x90P\x80a'\x81Wa'v\x85a&\x83V[a'\x81a\x02\ta\x16\xFBV[P\x93\x92PPPV[`\0\x82\x81R`\x01` R`@\x81 a\t\xE1\x81\x84a4\x12V[m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90V[`p\x1Cm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90V[`\xE0\x1C\x90V[`\0\x80a'\xDC\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a'\xECW\xFE[\x14\x15a(\x04Wa'\xFC\x84\x84a:\xC2V[\x91PPa\x16\xF5V[`\x01\x81`\x02\x81\x11\x15a(\x12W\xFE[\x14\x15a(\"Wa'\xFC\x84\x84a;\x13V[a'\xFC\x84\x84a;+V[`\0\x80`\0a(:\x86a\x1FdV[\x90P`\0\x87`\x02\x81\x11\x15a(JW\xFE[\x14\x15a(fWa(\\\x86\x82\x87\x87a;CV[\x92P\x92PPa(\x92V[`\x01\x87`\x02\x81\x11\x15a(tW\xFE[\x14\x15a(\x86Wa(\\\x86\x82\x87\x87a;\xBEV[a(\\\x86\x82\x87\x87a<:V[\x94P\x94\x92PPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a)\x08a<\x9DV[0`@Q` \x01a)\x1D\x95\x94\x93\x92\x91\x90a]\xF0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[``\x1C\x90V[``\x80`\0a)L\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a)\\W\xFE[\x14\x15a)uWa)k\x84a<\xA1V[\x92P\x92PPa)\x9BV[`\x01\x81`\x02\x81\x11\x15a)\x83W\xFE[\x14\x15a)\x92Wa)k\x84a=\xD6V[a)k\x84a>\xFDV[\x91P\x91V[```\0\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a)\xBCW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a)\xE6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0\x90P`\0[\x82Q\x81\x10\x15a\x15\x1DW`\0\x84\x82\x81Q\x81\x10a*\x07W\xFE[` \x02` \x01\x01Q\x90Pa*\x1A\x81a?\xF9V[\x84\x83\x81Q\x81\x10a*&W\xFE[` \x02` \x01\x01\x81\x81RPPa*D\x83a*?\x83a'\xCAV[a@\x14V[\x92PP`\x01\x01a)\xF0V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x04` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T`\xFF\x16\x90V[`\x03T`@Q\x7F\x9B\xE2\xA8\x84\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\0\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c\x9B\xE2\xA8\x84\x90a*\xD0\x90\x86\x90\x86\x900\x90`\x04\x01a]GV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a*\xE8W`\0\x80\xFD[PZ\xFA\x15\x80\x15a*\xFCW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xF2\x91\x90aTxV[`\0\x80a+-\x86\x86a\x1A\x01V[\x90Pa+F\x83\x80a+>WP\x84\x82\x10\x15[a\x02\x01a\x05KV[a+P\x81\x85a@+V[\x91P\x81\x81\x03a+l\x87\x87\x83a+d\x87a9\x81V[`\0\x03a@:V[PP\x94\x93PPPPV[`\0a+\x82\x84\x84a\x1A\x01V[\x90P`\0a+\x90\x82\x84a\x19EV[\x90Pa\x1D1\x85\x85\x83a+\xA1\x87a9\x81V[a@:V[a\x0E\0\x84c#\xB8r\xDD`\xE0\x1B\x85\x85\x85`@Q`$\x01a\x1E\xC5\x93\x92\x91\x90a[wV[a+\xD6\x81G\x10\x15a\x01\xA3a\x05KV[`\0\x82`\x01`\x01`\xA0\x1B\x03\x16\x82`@Qa+\xEF\x90a\x05HV[`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a,,W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a,1V[``\x91P[PP\x90Pa\x0F\xA0\x81a\x01\xA4a\x05KV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02` R`@\x90 \x80T`\x01\x81\x01\x90\x91Ua\x0F\xA0a,o\x84\x83a@\x95V[\x83a\x05KV[`\0\x80`\0\x80a,\x92\x86`\x80\x01Q\x87` \x01Q\x88`@\x01Qa2\"V[\x92P\x92P\x92P`\0\x80\x87`@\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x88` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x10\x15a,\xC7WP\x83\x90P\x82a,\xCDV[P\x82\x90P\x83[a,\xD9\x88\x88\x84\x84aA\xBBV[`@\x8B\x01Q` \x8C\x01Q\x91\x99P\x92\x94P\x90\x92P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x10a-\rWa-\x08\x81\x83aB\xD1V[a-\x17V[a-\x17\x82\x82aB\xD1V[\x90\x92UP\x92\x95\x94PPPPPV[`\0\x80a-:\x84`\x80\x01Q\x85` \x01Qa'\x1BV[\x90P`\0a-P\x85`\x80\x01Q\x86`@\x01Qa'\x1BV[\x90Pa-^\x85\x85\x84\x84aA\xBBV[`\x80\x88\x01\x80Q`\0\x90\x81R`\x07` \x81\x81R`@\x80\x84 \x82\x8E\x01Q`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x86R\x90\x83R\x81\x85 \x98\x90\x98U\x93Q\x83R\x90\x81R\x82\x82 \x9A\x83\x01Q\x90\x95\x16\x81R\x98\x90\x93R\x91\x90\x96 \x95\x90\x95UP\x92\x93\x92PPPV[`\x80\x82\x01Q`\0\x90\x81R`\x01` \x90\x81R`@\x82 \x90\x84\x01Q\x82\x91\x82\x91\x82\x90a-\xE2\x90\x83\x90aC\x0CV[\x90P`\0a-\xFD\x88`@\x01Q\x84aC\x0C\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x81\x15\x80a.\nWP\x80\x15[\x15a.'Wa.\x1C\x88`\x80\x01Qa&\x83V[a.'a\x02\ta\x16\xFBV[`\0\x19\x91\x82\x01\x91\x01`\0a.:\x84aC+V[\x90P``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a.UW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a.\x7FW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P`\0`\xA0\x8C\x01\x81\x90R\x90\x91P[\x82\x81\x10\x15a.\xFFW`\0a.\xA1\x87\x83aC/V[\x90Pa.\xAC\x81a?\xF9V[\x83\x83\x81Q\x81\x10a.\xB8W\xFE[` \x02` \x01\x01\x81\x81RPPa.\xD5\x8C`\xA0\x01Qa*?\x83a'\xCAV[`\xA0\x8D\x01R\x81\x86\x14\x15a.\xEAW\x80\x98Pa.\xF6V[\x84\x82\x14\x15a.\xF6W\x80\x97P[P`\x01\x01a.\x8DV[P`@Q\x7F\x01\xEC\x95J\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x16\x90c\x01\xEC\x95J\x90a/K\x90\x8D\x90\x85\x90\x89\x90\x89\x90`\x04\x01a^[V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a/eW`\0\x80\xFD[PZ\xF1\x15\x80\x15a/yW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a/\x9D\x91\x90aYhV[\x97P`\0\x80a/\xB5\x8C`\0\x01Q\x8D``\x01Q\x8Ca/\xF7V[\x90\x92P\x90Pa/\xC4\x89\x83aCEV[\x98Pa/\xD0\x88\x82aCvV[\x97Pa/\xDD\x87\x87\x8BaC\x8CV[a/\xE8\x87\x86\x8AaC\x8CV[PPPPPPPPP\x92\x91PPV[`\0\x80\x80\x85`\x01\x81\x11\x15a0\x07W\xFE[\x14\x15a0\x17WP\x82\x90P\x81a0\x1DV[P\x81\x90P\x82[\x93P\x93\x91PPV[`\0\x82\x82\x02a0I\x84\x15\x80a0BWP\x83\x85\x83\x81a0?W\xFE[\x04\x14[`\x03a\x05KV[\x80a0XW`\0\x91PPa\x16\xF5V[g\r\xE0\xB6\xB3\xA7d\0\0`\0\x19\x82\x01\x04`\x01\x01\x91PPa\x16\xF5V[`\0``\x83`\x01`\x01`\xA0\x1B\x03\x16\x83`@Qa0\x8E\x91\x90aZ\xEAV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a0\xCBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a0\xD0V[``\x91P[P\x91P\x91P`\0\x82\x14\x15a0\xE8W=`\0\x80>=`\0\xFD[a\x0E\0\x81Q`\0\x14\x80a1\nWP\x81\x80` \x01\x90Q\x81\x01\x90a1\n\x91\x90aTxV[a\x01\xA2a\x05KV[`\0a1\x1E\x83\x83a:\xA1V[a1mWP\x81T`\x01\x80\x82\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x86\x16\x90\x81\x17\x90\x91U\x85T\x90\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x16\xF5V[P`\0a\x16\xF5V[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02\x84\x01` R`@\x81 T\x80a2\x02WPP\x82T`@\x80Q\x80\x82\x01\x82R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x80\x83R` \x80\x84\x01\x87\x81R`\0\x87\x81R`\x01\x80\x8C\x01\x84R\x87\x82 \x96Q\x87T`\x01`\x01`\xA0\x1B\x03\x19\x16\x96\x16\x95\x90\x95\x17\x86U\x90Q\x94\x84\x01\x94\x90\x94U\x94\x82\x01\x80\x89U\x90\x83R`\x02\x88\x01\x90\x94R\x91\x90 \x91\x90\x91Ua\x18vV[`\0\x19\x01`\0\x90\x81R`\x01\x80\x86\x01` R`@\x82 \x01\x83\x90U\x90Pa\x18vV[`\0\x80`\0\x80`\0a24\x87\x87aC\xA4V[\x91P\x91P`\0a2D\x83\x83aC\xD5V[`\0\x8A\x81R`\t` \x90\x81R`@\x80\x83 \x84\x84R`\x02\x01\x90\x91R\x81 \x80T`\x01\x82\x01T\x91\x97P\x92\x93P\x90a2w\x83a:\x8FV[\x80a2\x86WPa2\x86\x82a:\x8FV[\x80a2\xA7WPa2\x96\x8C\x87a:\xC2V[\x80\x15a2\xA7WPa2\xA7\x8C\x86a:\xC2V[\x90P\x80a2\xC2Wa2\xB7\x8Ca&\x83V[a2\xC2a\x02\ta\x16\xFBV[a2\xCC\x83\x83aD\x08V[\x98Pa2\xD8\x83\x83aD-V[\x97PPPPPPP\x93P\x93P\x93\x90PV[{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a4\x08W\x83T`\0\x19\x80\x83\x01\x91\x90\x81\x01\x90`\0\x90\x87\x90\x83\x90\x81\x10a3HW\xFE[`\0\x91\x82R` \x90\x91 \x01T\x87T`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91P\x81\x90\x88\x90\x85\x90\x81\x10a3qW\xFE[`\0\x91\x82R` \x80\x83 \x91\x90\x91\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x17\x90U\x91\x83\x16\x81R`\x01\x89\x81\x01\x90\x92R`@\x90 \x90\x84\x01\x90U\x86T\x87\x90\x80a3\xBAW\xFE[`\0\x82\x81R` \x80\x82 \x83\x01`\0\x19\x90\x81\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U\x90\x92\x01\x90\x92U`\x01`\x01`\xA0\x1B\x03\x88\x16\x82R`\x01\x89\x81\x01\x90\x91R`@\x82 \x91\x90\x91U\x94Pa\x16\xF5\x93PPPPV[`\0\x91PPa\x16\xF5V[`\0a\x16\xF2\x83\x83a\x02\taDDV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x02\x83\x01` R`@\x81 T\x80\x15a4\x08W\x83T`\0\x19\x90\x81\x01`\0\x81\x81R`\x01\x87\x81\x01` \x90\x81R`@\x80\x84 \x95\x87\x01\x84R\x80\x84 \x86T\x81T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x17\x83U\x88\x86\x01\x80T\x93\x87\x01\x93\x90\x93U\x88T\x82\x16\x87R`\x02\x8D\x01\x80\x86R\x84\x88 \x9A\x90\x9AU\x88T\x16\x90\x97U\x84\x90U\x93\x89U\x93\x87\x16\x82R\x93\x90\x92R\x81 U\x90Pa\x16\xF5V[``\x80\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a4\xDEW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a5\x08W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x83Q\x81\x10\x15a\x07\xFFWa5&\x84\x82\x81Q\x81\x10a$\xACW\xFE[\x82\x82\x81Q\x81\x10a52W\xFE[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a5\x0EV[``\x80``a5`\x85a)>V[\x91P\x91Pa5p\x82Q\x85Qa\x1E\x12V[a5\x80`\0\x83Q\x11a\x02\x0Fa\x05KV[`\0[\x82Q\x81\x10\x15a5\xDAWa5\xD2\x85\x82\x81Q\x81\x10a5\x9BW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x84\x83\x81Q\x81\x10a5\xB8W\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x08a\x05KV[`\x01\x01a5\x83V[P\x94\x93PPPPV[``\x80``\x80`\0a5\xF4\x86a)\xA0V[\x91P\x91P`\0a6\x03\x8Ba)8V[\x90P`\0\x8C`\x01\x81\x11\x15a6\x13W\xFE[\x14a6\xB6W\x80`\x01`\x01`\xA0\x1B\x03\x16ct\xF3\xB0\t\x8C\x8C\x8C\x87\x87a64aD\x81V[\x8F`@\x01Q`@Q\x88c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6[\x97\x96\x95\x94\x93\x92\x91\x90a]fV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a6uW`\0\x80\xFD[PZ\xF1\x15\x80\x15a6\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xB1\x91\x90\x81\x01\x90aT\x05V[a7OV[\x80`\x01`\x01`\xA0\x1B\x03\x16c\xD5\xC0\x96\xC4\x8C\x8C\x8C\x87\x87a6\xD2aD\x81V[\x8F`@\x01Q`@Q\x88c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6\xF9\x97\x96\x95\x94\x93\x92\x91\x90a]fV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a7\x13W`\0\x80\xFD[PZ\xF1\x15\x80\x15a7'W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra7O\x91\x90\x81\x01\x90aT\x05V[\x80\x95P\x81\x96PPPa7e\x87Q\x86Q\x86QaD\xFBV[`\0\x8C`\x01\x81\x11\x15a7sW\xFE[\x14a7\x8AWa7\x85\x89\x89\x89\x88\x88aE\x13V[a7\x97V[a7\x97\x8A\x89\x89\x88\x88aFZV[\x95PPPP\x96P\x96P\x96\x93PPPPV[`\0a7\xB4\x85\x84aC\xD5V[`\0\x87\x81R`\t` \x90\x81R`@\x80\x83 \x84\x84R`\x02\x01\x90\x91R\x90 \x90\x91Pa7\xDD\x85\x84aB\xD1V[\x90UPPPPPPV[`\0[\x82Q\x81\x10\x15a\x0E\0W\x81\x81\x81Q\x81\x10a7\xFFW\xFE[` \x02` \x01\x01Q`\x07`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x85\x84\x81Q\x81\x10a8(W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x82R\x81\x01\x91\x90\x91R`@\x01`\0 U`\x01\x01a7\xEAV[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0Wa8\x95\x81\x84\x83\x81Q\x81\x10a8}W\xFE[` \x02` \x01\x01Q\x84aC\x8C\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\x01\x01a8dV[``\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a8\xB7W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8\xE1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x83Q\x81\x10\x15a\x07\xFFW\x82a9\x11W\x83\x81\x81Q\x81\x10a9\x01W\xFE[` \x02` \x01\x01Q`\0\x03a9&V[\x83\x81\x81Q\x81\x10a9\x1DW\xFE[` \x02` \x01\x01Q[\x82\x82\x81Q\x81\x10a92W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a8\xE7V[`\0\x80\x84`\x01\x81\x11\x15a9TW\xFE[\x14a9_W\x81a\t\xE1V[P\x90\x92\x91PPV[`\0\x80\x84`\x01\x81\x11\x15a9vW\xFE[\x14a\x07\xFFW\x82a\t\xE1V[`\0a\"j\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83\x10a\x01\xA5a\x05KV[`\0\x82\x82\x01a\x16\xF2\x82\x84\x12\x80\x15\x90a9\xC9WP\x84\x82\x12\x15[\x80a9\xDEWP`\0\x84\x12\x80\x15a9\xDEWP\x84\x82\x12[`\0a\x05KV[`\0\x81\x83\x03a\x16\xF2\x82\x84\x12\x80\x15\x90a9\xFDWP\x84\x82\x13\x15[\x80a:\x12WP`\0\x84\x12\x80\x15a:\x12WP\x84\x82\x13[`\x01a\x05KV[`\0\x81\x81R`\t` R`@\x81 \x80T`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x84\x92\x90\x91\x16\x90\x82\x90\x81a:M\x86\x85aC\xD5V[`\0\x81\x81R`\x02\x84\x01` R`@\x90 \x80T`\x01\x82\x01T\x91\x99P\x91\x92Pa:t\x82\x82aD\x08V[\x96Pa:\x80\x82\x82aD-V[\x94PPPPP\x91\x93\x95\x90\x92\x94PV[`\0a:\x9A\x82a2\xE9V[\x15\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x01\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[`\0\x82\x81R`\t` R`@\x81 \x80T`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x14\x80a:\xFAWP`\x01\x81\x01T`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x14[\x80\x15a\t\xE1WPPP`\x01`\x01`\xA0\x1B\x03\x16\x15\x15\x91\x90PV[`\0\x82\x81R`\x08` R`@\x81 a\t\xE1\x81\x84a:\xA1V[`\0\x82\x81R`\x01` R`@\x81 a\t\xE1\x81\x84aG\xD0V[`\0\x80`\x02\x85`\x02\x81\x11\x15a;TW\xFE[\x14\x15a;jWa;e\x86\x85\x85aG\xF1V[a;\x94V[`\x01\x85`\x02\x81\x11\x15a;xW\xFE[\x14\x15a;\x89Wa;e\x86\x85\x85aG\xFFV[a;\x94\x86\x85\x85aH\rV[\x82\x15a;\xAEWa;\xAE`\x01`\x01`\xA0\x1B\x03\x85\x163\x85a\x1E\xA6V[PP`\0\x81\x90\x03\x94\x90\x93P\x91PPV[`\0\x80`\x02\x85`\x02\x81\x11\x15a;\xCFW\xFE[\x14\x15a;\xE5Wa;\xE0\x86\x85\x85aH\x1BV[a<\x0FV[`\x01\x85`\x02\x81\x11\x15a;\xF3W\xFE[\x14\x15a<\x04Wa;\xE0\x86\x85\x85aH)V[a<\x0F\x86\x85\x85aH7V[\x82\x15a<*Wa<*`\x01`\x01`\xA0\x1B\x03\x85\x1630\x86a+\xA6V[P\x90\x94`\0\x86\x90\x03\x94P\x92PPPV[`\0\x80`\x02\x85`\x02\x81\x11\x15a<KW\xFE[\x14\x15a<cWa<\\\x86\x85\x85aHEV[\x90Pa<\x90V[`\x01\x85`\x02\x81\x11\x15a<qW\xFE[\x14\x15a<\x82Wa<\\\x86\x85\x85aHUV[a<\x8D\x86\x85\x85aHeV[\x90P[`\0\x91P\x94P\x94\x92PPPV[F\x90V[``\x80`\0\x80`\0\x80a<\xB3\x87a:\x19V[\x92\x97P\x90\x95P\x93P\x91PP`\x01`\x01`\xA0\x1B\x03\x84\x16\x15\x80a<\xDBWP`\x01`\x01`\xA0\x1B\x03\x82\x16\x15[\x15a=\x04WPP`@\x80Q`\0\x80\x82R` \x82\x01\x90\x81R\x81\x83\x01\x90\x92R\x94P\x92Pa)\x9B\x91PPV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x91` \x83\x01\x90\x806\x837\x01\x90PP\x95P\x83\x86`\0\x81Q\x81\x10a=2W\xFE[` \x02` \x01\x01\x90`\x01`\x01`\xA0\x1B\x03\x16\x90\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP\x81\x86`\x01\x81Q\x81\x10a=`W\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01R`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x92\x90\x91\x90\x83\x01\x90\x806\x837\x01\x90PP\x94P\x82\x85`\0\x81Q\x81\x10a=\xA7W\xFE[` \x02` \x01\x01\x81\x81RPP\x80\x85`\x01\x81Q\x81\x10a=\xC1W\xFE[` \x02` \x01\x01\x81\x81RPPPPPP\x91P\x91V[`\0\x81\x81R`\x08` R`@\x90 ``\x90\x81\x90a=\xF2\x81aC+V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a>\x08W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a>2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92P\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a>MW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a>wW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x83Q\x81\x10\x15a>\xF6W`\0a>\x92\x83\x83aHuV[\x90P\x80\x85\x83\x81Q\x81\x10a>\xA1W\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x81\x01\x91\x90\x91R`\0\x88\x81R`\x07\x82R`@\x80\x82 \x93\x85\x16\x82R\x92\x90\x91R T\x84Q\x85\x90\x84\x90\x81\x10a>\xE2W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RP`\x01\x01a>}V[PP\x91P\x91V[`\0\x81\x81R`\x01` R`@\x90 ``\x90\x81\x90a?\x19\x81aC+V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?/W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a?YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92P\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?tW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a?\x9EW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x83Q\x81\x10\x15a>\xF6Wa?\xB7\x82\x82aH\xA2V[\x85\x83\x81Q\x81\x10a?\xC3W\xFE[` \x02` \x01\x01\x85\x84\x81Q\x81\x10a?\xD6W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a?\xA4V[`\0a@\x04\x82a'\xB4V[a@\r\x83a'\xA1V[\x01\x92\x91PPV[`\0\x81\x83\x10\x15a@$W\x81a\x16\xF2V[P\x90\x91\x90PV[`\0\x81\x83\x10a@$W\x81a\x16\xF2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x81\x81R`\x0B` \x90\x81R`@\x80\x83 \x94\x88\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x85\x90UQ\x7F\x18\xE1\xEAA9\xE6\x84\x13\xD7\xD0\x8A\xA7R\xE7\x15h\xE3k,[\xF9@\x893\x14\xC2\xC5\xB0\x1E\xAA\x0CB\x90a\x19\xD0\x90\x85\x90a]>V[`\0\x80a@\xA0aH\xC6V[\x90PB\x81\x10\x15a@\xB4W`\0\x91PPa\x16\xF5V[`\0a@\xBEaH\xD2V[\x90P\x80a@\xD0W`\0\x92PPPa\x16\xF5V[`\0\x81a@\xDBaI\xE3V[\x80Q` \x91\x82\x01 `@Qa@\xF7\x93\x923\x91\x8A\x91\x89\x91\x01a]\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0aA\x1A\x82aJ2V[\x90P`\0\x80`\0aA)aJNV[\x92P\x92P\x92P`\0`\x01\x85\x85\x85\x85`@Q`\0\x81R` \x01`@R`@QaAT\x94\x93\x92\x91\x90a^\x1CV[` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15aAvW=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16\x15\x80\x15\x90aA\xACWP\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14[\x9B\x9APPPPPPPPPPPV[`\0\x80`\0\x80aA\xCA\x86a?\xF9V[\x90P`\0aA\xD7\x86a?\xF9V[\x90PaA\xEEaA\xE5\x88a'\xCAV[a*?\x88a'\xCAV[`\xA0\x8A\x01R`@Q\x7F\x9D,\x11\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x16\x90c\x9D,\x11\x0C\x90aB<\x90\x8C\x90\x86\x90\x86\x90`\x04\x01a^\x94V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aBVW`\0\x80\xFD[PZ\xF1\x15\x80\x15aBjW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90aB\x8E\x91\x90aYhV[\x92P`\0\x80aB\xA6\x8B`\0\x01Q\x8C``\x01Q\x87a/\xF7V[\x90\x92P\x90PaB\xB5\x89\x83aCEV[\x96PaB\xC1\x88\x82aCvV[\x95PPPPP\x94P\x94P\x94\x91PPV[`\0\x80aB\xE9aB\xE0\x85a'\xCAV[a*?\x85a'\xCAV[\x90Pa\t\xE1aB\xF7\x85a'\xA1V[aC\0\x85a'\xA1V[\x83c\xFF\xFF\xFF\xFF\x16aJuV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02\x91\x90\x91\x01` R`@\x90 T\x90V[T\x90V[`\0\x90\x81R`\x01\x91\x82\x01` R`@\x90 \x01T\x90V[`\0\x80aC[\x83aCU\x86a'\xA1V[\x90a\x19EV[\x90P`\0aCh\x85a'\xB4V[\x90PCa\x12\xA6\x83\x83\x83aJ\x83V[`\0\x80aC[\x83aC\x86\x86a'\xA1V[\x90aJ\xBCV[`\0\x91\x82R`\x01\x92\x83\x01` R`@\x90\x91 \x90\x91\x01UV[`\0\x80\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x10aC\xC7W\x82\x84aC\xCAV[\x83\x83[\x91P\x91P\x92P\x92\x90PV[`\0\x82\x82`@Q` \x01aC\xEA\x92\x91\x90a[\x06V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x92\x91PPV[`\0a\x16\xF2aD\x16\x84a'\xA1V[aD\x1F\x84a'\xA1V[aD(\x86a'\xCAV[aJ\x83V[`\0a\x16\xF2aD;\x84a'\xB4V[aD\x1F\x84a'\xB4V[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02\x84\x01` R`@\x81 TaDk\x81\x15\x15\x84a\x05KV[aDx\x85`\x01\x83\x03aC/V[\x95\x94PPPPPV[`\0aD\x8Ba\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x16cU\xC6v(`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aD\xC3W`\0\x80\xFD[PZ\xFA\x15\x80\x15aD\xD7W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xCE\x91\x90aYhV[a\x0F\xA0\x82\x84\x14\x80\x15aE\x0CWP\x81\x83\x14[`ga\x05KV[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aE-W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aEWW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x85QQ\x81\x10\x15aFPW`\0\x84\x82\x81Q\x81\x10aEuW\xFE[` \x02` \x01\x01Q\x90PaE\xA5\x87` \x01Q\x83\x81Q\x81\x10aE\x92W\xFE[` \x02` \x01\x01Q\x82\x10\x15a\x01\xF9a\x05KV[`\0\x87`\0\x01Q\x83\x81Q\x81\x10aE\xB7W\xFE[` \x02` \x01\x01Q\x90PaE\xD1\x81\x83\x8B\x8B``\x01Qa\x1D8V[`\0\x85\x84\x81Q\x81\x10aE\xDFW\xFE[` \x02` \x01\x01Q\x90PaE\xFBaE\xF5\x83a\x1BAV[\x82a\x1F\x11V[aF*aF\x08\x84\x83a\x19EV[\x89\x86\x81Q\x81\x10aF\x14W\xFE[` \x02` \x01\x01QaCv\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x85\x85\x81Q\x81\x10aF6W\xFE[` \x02` \x01\x01\x81\x81RPPPPP\x80`\x01\x01\x90PaE]V[P\x95\x94PPPPPV[```\0\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aFvW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aF\xA0W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x86QQ\x81\x10\x15aG\xC6W`\0\x85\x82\x81Q\x81\x10aF\xBEW\xFE[` \x02` \x01\x01Q\x90PaF\xEE\x88` \x01Q\x83\x81Q\x81\x10aF\xDBW\xFE[` \x02` \x01\x01Q\x82\x11\x15a\x01\xFAa\x05KV[`\0\x88`\0\x01Q\x83\x81Q\x81\x10aG\0W\xFE[` \x02` \x01\x01Q\x90PaG\x1A\x81\x83\x8C\x8C``\x01Qa\x1CZV[aG#\x81a\x198V[\x15aG5WaG2\x84\x83a\x19EV[\x93P[`\0\x86\x84\x81Q\x81\x10aGCW\xFE[` \x02` \x01\x01Q\x90PaGYaE\xF5\x83a\x1BAV[\x80\x83\x10\x15aGxWaGs\x83\x82\x03\x8A\x86\x81Q\x81\x10aF\x14W\xFE[aG\xA0V[aG\xA0\x81\x84\x03\x8A\x86\x81Q\x81\x10aG\x8AW\xFE[` \x02` \x01\x01QaCE\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x86\x85\x81Q\x81\x10aG\xACW\xFE[` \x02` \x01\x01\x81\x81RPPPPP\x80`\x01\x01\x90PaF\xA6V[PaFP\x81a\x19\xDEV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[a\x0E\0\x83\x83aJ\xD2\x84aK\rV[a\x0E\0\x83\x83aJ\xD2\x84aK\xB8V[a\x0E\0\x83\x83aJ\xD2\x84aL\x13V[a\x0E\0\x83\x83aLb\x84aK\rV[a\x0E\0\x83\x83aLb\x84aK\xB8V[a\x0E\0\x83\x83aLb\x84aL\x13V[`\0a\t\xE1\x84\x84aL\x83\x85aK\rV[`\0a\t\xE1\x84\x84aL\x83\x85aK\xB8V[`\0a\t\xE1\x84\x84aL\x83\x85aL\x13V[`\0\x82`\0\x01\x82\x81T\x81\x10aH\x86W\xFE[`\0\x91\x82R` \x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x93\x92PPPV[`\0\x90\x81R`\x01\x91\x82\x01` R`@\x90 \x80T\x91\x01T`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91V[`\0a\x12\xCE`\0aL\x9DV[`\0\x805`\xE0\x1C\x80c\xB9\\\xAC(\x81\x14aI\x1AWc\x8B\xDB9\x13\x81\x14aIBWcR\xBB\xBE)\x81\x14aIjWc\x94[\xCE\xC9\x81\x14aI\x92Wc\xFAng\x1D\x81\x14aI\xBAW`\0\x92PaI\xDEV[\x7F?{q%+\xD1\x91\x13\xFFH\xC1\x9Cn\0J\x9B\xCF\xCC\xA3 \xA0\xD7MX\xE8Xw\xCB\xD7\xDC\xAEX\x92PaI\xDEV[\x7F\x8B\xBCW\xF6n\xA96\x90/P\xA7\x1C\xE1+\x92\xC4?<S@\xBB@\xC2|N\x90\xAB\x84\xEE\xAE3S\x92PaI\xDEV[\x7F\xE1\x92\xDC\xBC\x14;\x1E$J\xD7;\x81?\xD3\xC0\x97\xB82\xAD&\n\x15s@\xB4\xE5\xE5\xBE\xDA\x06z\xBE\x92PaI\xDEV[\x7F\x9B\xFCC\xA4\xD9\x83\x13\xC6vi\x86\xFF\xD7\xC9\x16\xC7H\x15f\xD9\xF2$\xC6\x81\x9A\xF0\xA53\x88\xAC\xED:\x92PaI\xDEV[\x7F\xA3\xF8e\xAA5\x1EQ\xCF\xEB@\xF5\x17\x8D\x15d\xBBb\x9F\xE9\x03\x0B\x83\xCA\xF66\x1D\x1B\xAA\xF5\xB9\x0BZ\x92P[PP\x90V[```\x006\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RPP\x82Q\x92\x93PPP`\x80\x10\x15a\x05HW`\x806\x03\x81R\x90V[`\0aJ<a(\x9BV[\x82`@Q` \x01a\x11.\x92\x91\x90a[-V[`\0\x80`\0aJ]` aL\x9DV[\x92PaJi`@aL\x9DV[\x91Pa\x08A``aL\x9DV[`\xE0\x1B`p\x91\x90\x91\x1B\x01\x01\x90V[`\0\x83\x83\x01aJ\xB1\x85\x82\x10\x80\x15\x90aJ\xA9WPn\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x10[a\x02\x0Ea\x05KV[aDx\x85\x85\x85aJuV[`\0aJ\xCC\x83\x83\x11\x15`\x01a\x05KV[P\x90\x03\x90V[`\0\x80aJ\xE2\x83aC\x86\x86a'\xA1V[\x90P`\0aJ\xF3\x84aCU\x87a'\xB4V[\x90P`\0aK\0\x86a'\xCAV[\x90Pa\x12\xA6\x83\x83\x83aJ\x83V[`\0\x80`\0\x80`\0aK\x1E\x89a:\x19V[\x94PP\x93P\x93P\x93P`\0\x83`\x01`\x01`\xA0\x1B\x03\x16\x89`\x01`\x01`\xA0\x1B\x03\x16\x14\x15aKiW`\0aKS\x84\x89\x8Bc\xFF\xFF\xFF\xFF\x16V[\x90PaK_\x81\x85aL\xA7V[\x90\x93P\x90PaK\x8BV[`\0aKy\x83\x89\x8Bc\xFF\xFF\xFF\xFF\x16V[\x90PaK\x85\x81\x84aL\xA7V[\x90\x92P\x90P[aK\x95\x83\x83aB\xD1V[\x85UaK\xA1\x83\x83aL\xC3V[`\x01\x90\x95\x01\x94\x90\x94UP\x91\x92PPP\x94\x93PPPPV[`\0\x80aK\xC5\x86\x86a'\x1BV[\x90P`\0aK\xD7\x82\x85\x87c\xFF\xFF\xFF\xFF\x16V[`\0\x88\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x8B\x16\x84R\x90\x91R\x90 \x81\x90U\x90PaL\x08\x81\x83aL\xA7V[\x97\x96PPPPPPPV[`\0\x84\x81R`\x01` R`@\x81 \x81aL,\x82\x87a4\x12V[\x90P`\0aL>\x82\x86\x88c\xFF\xFF\xFF\xFF\x16V[\x90PaLK\x83\x88\x83a1uV[PaLV\x81\x83aL\xA7V[\x98\x97PPPPPPPPV[`\0\x80aLr\x83aCU\x86a'\xA1V[\x90P`\0aJ\xF3\x84aC\x86\x87a'\xB4V[`\0\x80aL\x8F\x84a'\xA1V[\x90PCaDx\x82\x85\x83aJ\x83V[6\x01`\x7F\x19\x015\x90V[`\0aL\xB2\x82a'\xB4V[aL\xBB\x84a'\xB4V[\x03\x93\x92PPPV[`\0a\x16\xF2aL\xD1\x84a'\xB4V[aL\xDA\x84a'\xB4V[`\0aJuV[`@\x80Qa\x01 \x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x80\x83\x01\x82\x90R`\x80\x83\x01\x82\x90R`\xA0\x83\x01\x82\x90R`\xC0\x83\x01\x82\x90R`\xE0\x83\x01\x91\x90\x91Ra\x01\0\x90\x91\x01R\x90V[`@\x80Q`\x80\x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[`@Q\x80`\x80\x01`@R\x80``\x81R` \x01``\x81R` \x01``\x81R` \x01`\0\x15\x15\x81RP\x90V[`@Q\x80`\xA0\x01`@R\x80`\0\x80\x19\x16\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01``\x81RP\x90V[\x805a\x16\xF5\x81a_ZV[`\0\x82`\x1F\x83\x01\x12aM\xD1W\x80\x81\xFD[\x815aM\xE4aM\xDF\x82a_\x04V[a^\xDDV[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aN\x05W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x815aN\x1B\x81a_ZV[\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aN\x08V[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12aNHW\x80\x81\xFD[\x815aNVaM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01`\0[\x84\x81\x10\x15aN-W\x815\x87\x01`\xA0\x80`\x1F\x19\x83\x8C\x03\x01\x12\x15aN\x88W`\0\x80\xFD[aN\x91\x81a^\xDDV[\x85\x83\x015\x81R`@\x80\x84\x015\x87\x83\x01R``\x80\x85\x015\x82\x84\x01R`\x80\x91P\x81\x85\x015\x81\x84\x01RP\x82\x84\x015\x92Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x15aN\xD3W`\0\x80\xFD[aN\xE1\x8C\x88\x85\x87\x01\x01aO\xC0V[\x90\x82\x01R\x86RPP\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aNgV[`\0\x82`\x1F\x83\x01\x12aO\tW\x80\x81\xFD[\x815aO\x17aM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aO8W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x815\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aO;V[`\0\x82`\x1F\x83\x01\x12aOgW\x80\x81\xFD[\x81QaOuaM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aO\x96W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x81Q\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aO\x99V[\x805a\x16\xF5\x81a_oV[`\0\x82`\x1F\x83\x01\x12aO\xD0W\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aO\xE6W\x81\x82\xFD[aO\xF9`\x1F\x82\x01`\x1F\x19\x16` \x01a^\xDDV[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15aP\x10W`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[\x805a\x16\xF5\x81a_}V[\x805`\x02\x81\x10a\x16\xF5W`\0\x80\xFD[\x805`\x04\x81\x10a\x16\xF5W`\0\x80\xFD[`\0`\x80\x82\x84\x03\x12\x15aPcW\x80\x81\xFD[aPm`\x80a^\xDDV[\x90P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aP\x87W`\0\x80\xFD[aP\x93\x85\x83\x86\x01aM\xC1V[\x83R` \x84\x015\x91P\x80\x82\x11\x15aP\xA9W`\0\x80\xFD[aP\xB5\x85\x83\x86\x01aN\xF9V[` \x84\x01R`@\x84\x015\x91P\x80\x82\x11\x15aP\xCEW`\0\x80\xFD[PaP\xDB\x84\x82\x85\x01aO\xC0V[`@\x83\x01RPaP\xEE\x83``\x84\x01aO\xB5V[``\x82\x01R\x92\x91PPV[`\0`\x80\x82\x84\x03\x12\x15aQ\nW\x80\x81\xFD[aQ\x14`\x80a^\xDDV[\x90P\x815aQ!\x81a_ZV[\x81R` \x82\x015aQ1\x81a_oV[` \x82\x01R`@\x82\x015aQD\x81a_ZV[`@\x82\x01R``\x82\x015aP\xEE\x81a_oV[`\0` \x82\x84\x03\x12\x15aQhW\x80\x81\xFD[\x815a\x16\xF2\x81a_ZV[`\0\x80`@\x83\x85\x03\x12\x15aQ\x85W\x80\x81\xFD[\x825aQ\x90\x81a_ZV[\x91P` \x83\x015aQ\xA0\x81a_ZV[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15aQ\xBFW\x80\x81\xFD[\x835aQ\xCA\x81a_ZV[\x92P` \x84\x015aQ\xDA\x81a_ZV[\x91P`@\x84\x015aQ\xEA\x81a_oV[\x80\x91PP\x92P\x92P\x92V[`\0\x80`@\x83\x85\x03\x12\x15aR\x07W\x81\x82\xFD[\x825aR\x12\x81a_ZV[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aR-W\x81\x82\xFD[aR9\x85\x82\x86\x01aM\xC1V[\x91PP\x92P\x92\x90PV[`\0` \x80\x83\x85\x03\x12\x15aRUW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aRkW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aR{W\x82\x83\xFD[\x805aR\x89aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`\x80\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aR\xA7W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aS\x10W\x80\x82\x8B\x03\x12\x15aR\xC1W\x87\x88\xFD[aR\xCA\x81a^\xDDV[aR\xD4\x8B\x84aP)V[\x81R\x87\x83\x015\x88\x82\x01R`@aR\xEC\x8C\x82\x86\x01aM\xB6V[\x90\x82\x01R``\x83\x81\x015\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aR\xABV[P\x90\x98\x97PPPPPPPPV[`\0` \x80\x83\x85\x03\x12\x15aS0W\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aSFW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aSVW\x82\x83\xFD[\x805aSdaM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`\xA0\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aS\x82W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aS\x10W\x80\x82\x8B\x03\x12\x15aS\x9CW\x87\x88\xFD[aS\xA5\x81a^\xDDV[aS\xAF\x8B\x84aPCV[\x81RaS\xBD\x8B\x89\x85\x01aM\xB6V[\x81\x89\x01R`@\x83\x81\x015\x90\x82\x01R``aS\xD9\x8C\x82\x86\x01aM\xB6V[\x90\x82\x01R`\x80aS\xEB\x8C\x85\x83\x01aM\xB6V[\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aS\x86V[`\0\x80`@\x83\x85\x03\x12\x15aT\x17W\x81\x82\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aT.W\x83\x84\xFD[aT:\x86\x83\x87\x01aOWV[\x93P` \x85\x01Q\x91P\x80\x82\x11\x15aTOW\x82\x83\xFD[PaR9\x85\x82\x86\x01aOWV[`\0` \x82\x84\x03\x12\x15aTmW\x80\x81\xFD[\x815a\x16\xF2\x81a_oV[`\0` \x82\x84\x03\x12\x15aT\x89W\x80\x81\xFD[\x81Qa\x16\xF2\x81a_oV[`\0` \x82\x84\x03\x12\x15aT\xA5W\x80\x81\xFD[P5\x91\x90PV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15aT\xC1W\x81\x82\xFD[\x845\x93P` \x85\x015aT\xD3\x81a_ZV[\x92P`@\x85\x015aT\xE3\x81a_ZV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aT\xFEW\x81\x82\xFD[aU\n\x87\x82\x88\x01aPRV[\x91PP\x92\x95\x91\x94P\x92PV[`\0\x80`@\x83\x85\x03\x12\x15aU(W\x81\x82\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aR-W\x81\x82\xFD[`\0\x80`\0``\x84\x86\x03\x12\x15aUYW\x80\x81\xFD[\x835\x92P` \x80\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aUxW\x83\x84\xFD[aU\x84\x88\x83\x89\x01aM\xC1V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aU\x99W\x83\x84\xFD[P\x85\x01`\x1F\x81\x01\x87\x13aU\xAAW\x82\x83\xFD[\x805aU\xB8aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x8B\x10\x15aU\xD4W\x86\x87\xFD[\x86\x94P[\x83\x85\x10\x15aU\xFFW\x805aU\xEB\x81a_ZV[\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01aU\xD8V[P\x80\x95PPPPPP\x92P\x92P\x92V[`\0\x80`@\x83\x85\x03\x12\x15aV!W\x81\x82\xFD[\x825\x91P` \x83\x015aQ\xA0\x81a_ZV[`\0` \x82\x84\x03\x12\x15aVDW\x80\x81\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x16\xF2W\x81\x82\xFD[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15aVpW\x81\x82\xFD[\x845aV{\x81a_ZV[\x93P` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aV\x97W\x83\x84\xFD[aV\xA3\x88\x83\x89\x01aM\xC1V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aV\xB8W\x83\x84\xFD[aV\xC4\x88\x83\x89\x01aN\xF9V[\x93P``\x87\x015\x91P\x80\x82\x11\x15aV\xD9W\x82\x83\xFD[PaU\n\x87\x82\x88\x01aO\xC0V[`\0` \x82\x84\x03\x12\x15aV\xF7W\x80\x81\xFD[\x815a\x16\xF2\x81a_}V[`\0\x80`\0\x80`\xE0\x85\x87\x03\x12\x15aW\x17W\x81\x82\xFD[aW!\x86\x86aP4V[\x93P` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aW=W\x83\x84\xFD[aWI\x88\x83\x89\x01aN8V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aW^W\x83\x84\xFD[PaWk\x87\x82\x88\x01aM\xC1V[\x92PPaW{\x86``\x87\x01aP\xF9V[\x90P\x92\x95\x91\x94P\x92PV[`\0\x80`\0\x80`\0\x80a\x01 \x87\x89\x03\x12\x15aW\x9FW\x83\x84\xFD[aW\xA9\x88\x88aP4V[\x95P` \x80\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aW\xC6W\x86\x87\xFD[aW\xD2\x8B\x83\x8C\x01aN8V[\x97P`@\x8A\x015\x91P\x80\x82\x11\x15aW\xE7W\x86\x87\xFD[aW\xF3\x8B\x83\x8C\x01aM\xC1V[\x96PaX\x02\x8B``\x8C\x01aP\xF9V[\x95P`\xE0\x8A\x015\x91P\x80\x82\x11\x15aX\x17W\x84\x85\xFD[P\x88\x01`\x1F\x81\x01\x8A\x13aX(W\x83\x84\xFD[\x805aX6aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x8E\x10\x15aXRW\x87\x88\xFD[\x87\x94P[\x83\x85\x10\x15aXtW\x805\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01aXVV[P\x80\x96PPPPPPa\x01\0\x87\x015\x90P\x92\x95P\x92\x95P\x92\x95V[`\0\x80`\0\x80`\xE0\x85\x87\x03\x12\x15aX\xA4W\x81\x82\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aX\xBBW\x83\x84\xFD[\x90\x86\x01\x90`\xC0\x82\x89\x03\x12\x15aX\xCEW\x83\x84\xFD[aX\xD8`\xC0a^\xDDV[\x825\x81RaX\xE9\x89` \x85\x01aP4V[` \x82\x01R`@\x83\x015aX\xFC\x81a_ZV[`@\x82\x01RaY\x0E\x89``\x85\x01aM\xB6V[``\x82\x01R`\x80\x83\x015`\x80\x82\x01R`\xA0\x83\x015\x82\x81\x11\x15aY.W\x85\x86\xFD[aY:\x8A\x82\x86\x01aO\xC0V[`\xA0\x83\x01RP\x80\x96PPPPaYS\x86` \x87\x01aP\xF9V[\x93\x96\x93\x95PPPP`\xA0\x82\x015\x91`\xC0\x015\x90V[`\0` \x82\x84\x03\x12\x15aYyW\x80\x81\xFD[PQ\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x16\x90RV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aY\xC5W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aY\xA0V[P\x94\x95\x94PPPPPV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aY\xC5W\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aY\xE3V[`\0\x81Q\x80\x84RaZ\x17\x81` \x86\x01` \x86\x01a_$V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\0a\x01 \x82Q`\x02\x81\x10aZ<W\xFE[\x80\x85RP` \x83\x01QaZR` \x86\x01\x82aY\x80V[P`@\x83\x01QaZe`@\x86\x01\x82aY\x80V[P``\x83\x01Q``\x85\x01R`\x80\x83\x01Q`\x80\x85\x01R`\xA0\x83\x01Q`\xA0\x85\x01R`\xC0\x83\x01QaZ\x96`\xC0\x86\x01\x82aY\x80V[P`\xE0\x83\x01QaZ\xA9`\xE0\x86\x01\x82aY\x80V[Pa\x01\0\x80\x84\x01Q\x82\x82\x87\x01Ra\x12\xA6\x83\x87\x01\x82aY\xFFV[\x91\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`$\x01\x90V[`\0\x82\x84\x837\x91\x01\x90\x81R\x91\x90PV[`\0\x82QaZ\xFC\x81\x84` \x87\x01a_$V[\x91\x90\x91\x01\x92\x91PPV[k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19``\x93\x84\x1B\x81\x16\x82R\x91\x90\x92\x1B\x16`\x14\x82\x01R`(\x01\x90V[\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R\x91\x90\x92\x16` \x82\x01R`@\x81\x01\x91\x90\x91R``\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x83\x16\x81R`@\x81\x01a[\xB4\x83a_PV[\x82` \x83\x01R\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[`\0` \x82Ra\x16\xF2` \x83\x01\x84aY\x8DV[`\0`@\x82Ra\\\0`@\x83\x01\x85aY\x8DV[\x82\x81\x03` \x84\x81\x01\x91\x90\x91R\x84Q\x80\x83R\x85\x82\x01\x92\x82\x01\x90\x84[\x81\x81\x10\x15a\\?W\x84Q`\x01`\x01`\xA0\x1B\x03\x16\x83R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01a\\\x1AV[P\x90\x97\x96PPPPPPPV[`\0``\x82Ra\\_``\x83\x01\x86aY\x8DV[\x82\x81\x03` \x84\x01Ra\\q\x81\x86aY\xD0V[\x90P\x82\x81\x03`@\x84\x01Ra\x12\xA6\x81\x85aY\xD0V[`\0`\x80\x82Ra\\\x98`\x80\x83\x01\x87aY\x8DV[\x82\x81\x03` \x84\x01Ra\\\xAA\x81\x87aY\xD0V[\x90P\x82\x81\x03`@\x84\x01Ra\\\xBE\x81\x86aY\xD0V[\x90P\x82\x81\x03``\x84\x01RaL\x08\x81\x85aY\xFFV[`\0``\x82Ra\\\xE5``\x83\x01\x86aY\x8DV[\x82\x81\x03` \x84\x01Ra\\\xF7\x81\x86aY\xD0V[\x91PP\x82`@\x83\x01R\x94\x93PPPPV[`\0` \x82Ra\x16\xF2` \x83\x01\x84aY\xD0V[\x90\x15\x15\x81R` \x01\x90V[\x92\x15\x15\x83R` \x83\x01\x91\x90\x91R`@\x82\x01R``\x01\x90V[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[`\0\x88\x82R`\x01`\x01`\xA0\x1B\x03\x80\x89\x16` \x84\x01R\x80\x88\x16`@\x84\x01RP`\xE0``\x83\x01Ra]\x98`\xE0\x83\x01\x87aY\xD0V[\x85`\x80\x84\x01R\x84`\xA0\x84\x01R\x82\x81\x03`\xC0\x84\x01Ra]\xB6\x81\x85aY\xFFV[\x9A\x99PPPPPPPPPPV[\x94\x85R` \x85\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16`@\x84\x01R``\x83\x01R`\x80\x82\x01R`\xA0\x01\x90V[\x94\x85R` \x85\x01\x93\x90\x93R`@\x84\x01\x91\x90\x91R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01\x90V[\x93\x84R`\xFF\x92\x90\x92\x16` \x84\x01R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[` \x81\x01a^G\x83a_PV[\x91\x90R\x90V[\x91\x82R` \x82\x01R`@\x01\x90V[`\0`\x80\x82Ra^n`\x80\x83\x01\x87aZ+V[\x82\x81\x03` \x84\x01Ra^\x80\x81\x87aY\xD0V[`@\x84\x01\x95\x90\x95RPP``\x01R\x92\x91PPV[`\0``\x82Ra^\xA7``\x83\x01\x86aZ+V[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[\x93\x84R` \x84\x01\x92\x90\x92R`@\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16``\x82\x01R`\x80\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a^\xFCW`\0\x80\xFD[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a_\x1AW\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\0[\x83\x81\x10\x15a_?W\x81\x81\x01Q\x83\x82\x01R` \x01a_'V[\x83\x81\x11\x15a\x0E\0WPP`\0\x91\x01RV[`\x03\x81\x10a\x05~W\xFE[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05~W`\0\x80\xFD[\x80\x15\x15\x81\x14a\x05~W`\0\x80\xFD[`\x03\x81\x10a\x05~W`\0\x80\xFD\xFE\xA2dipfsX\"\x12  \x1EO\x92n9\x0F\xED\x8D\xD51\x8CX\x84j\xF75\xC2\xBE\xBCa\xB8\x06\x93\xAE\x93j_\xE7m\xCF\x14dsolcC\0\x07\x01\x003`\xC0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x0B\xE68\x03\x80a\x0B\xE6\x839\x81\x01`@\x81\x90Ra\0/\x91a\0MV[0`\x80R`\x01`\0U``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0Ra\0{V[`\0` \x82\x84\x03\x12\x15a\0^W\x80\x81\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0tW\x81\x82\xFD[\x93\x92PPPV[`\x80Q`\xA0Q``\x1Ca\x0B@a\0\xA6`\09\x80a\x04\x13R\x80a\x05IRP\x80a\x02\xA7RPa\x0B@`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xA3W`\x005`\xE0\x1C\x80c\x85\x1C\x1B\xB3\x11a\0vW\x80c\xD8w\x84\\\x11a\0[W\x80c\xD8w\x84\\\x14a\x01)W\x80c\xE4*\xBF5\x14a\x011W\x80c\xFB\xFAw\xCF\x14a\x01QWa\0\xA3V[\x80c\x85\x1C\x1B\xB3\x14a\x01\x01W\x80c\xAA\xAB\xAD\xC5\x14a\x01\x14Wa\0\xA3V[\x80c8\xE9\x92.\x14a\0\xA8W\x80cU\xC6v(\x14a\0\xBDW\x80ckk\x9Fi\x14a\0\xDBW\x80cm\xAE\xFA\xB6\x14a\0\xEEW[`\0\x80\xFD[a\0\xBBa\0\xB66`\x04a\t\x9CV[a\x01YV[\0[a\0\xC5a\x01\xB8V[`@Qa\0\xD2\x91\x90a\n\xA6V[`@Q\x80\x91\x03\x90\xF3[a\0\xBBa\0\xE96`\x04a\t\x9CV[a\x01\xBEV[a\0\xBBa\0\xFC6`\x04a\x07\xD1V[a\x02\x11V[a\0\xC5a\x01\x0F6`\x04a\t$V[a\x02\xA3V[a\x01\x1Ca\x02\xF5V[`@Qa\0\xD2\x91\x90a\n5V[a\0\xC5a\x03\x04V[a\x01Da\x01?6`\x04a\x08RV[a\x03\nV[`@Qa\0\xD2\x91\x90a\nbV[a\x01\x1Ca\x04\x11V[a\x01aa\x045V[a\x01xg\x06\xF0[Y\xD3\xB2\0\0\x82\x11\x15a\x02Xa\x04~V[`\x01\x81\x90U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90a\x01\xAD\x90\x83\x90a\n\xA6V[`@Q\x80\x91\x03\x90\xA1PV[`\x01T\x90V[a\x01\xC6a\x045V[a\x01\xDCf#\x86\xF2o\xC1\0\0\x82\x11\x15a\x02Ya\x04~V[`\x02\x81\x90U`@Q\x7FZ\x0Bs\x86#~\x7F\x07\xFAt\x1E\xFCd\xE5\x9C\x93\x87\xD2\xCC\xCA\xFE\xC7`\xEF\xEDMS8\x7F \xE1\x9A\x90a\x01\xAD\x90\x83\x90a\n\xA6V[a\x02\x19a\x04\x90V[a\x02!a\x045V[a\x02+\x84\x83a\x04\xA9V[`\0[\x84\x81\x10\x15a\x02\x93W`\0\x86\x86\x83\x81\x81\x10a\x02DW\xFE[\x90P` \x02\x01` \x81\x01\x90a\x02Y\x91\x90a\t\x80V[\x90P`\0\x85\x85\x84\x81\x81\x10a\x02iW\xFE[` \x02\x91\x90\x91\x015\x91Pa\x02\x89\x90P`\x01`\x01`\xA0\x1B\x03\x83\x16\x85\x83a\x04\xB6V[PP`\x01\x01a\x02.V[Pa\x02\x9Ca\x05>V[PPPPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x02\xD8\x92\x91\x90a\t\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\0a\x02\xFFa\x05EV[\x90P\x90V[`\x02T\x90V[``\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x03$W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x03NW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x82Q\x81\x10\x15a\x04\x0BW\x82\x81\x81Q\x81\x10a\x03iW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\x9C\x91\x90a\n5V[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x03\xB4W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x03\xC8W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xEC\x91\x90a\t\xB4V[\x82\x82\x81Q\x81\x10a\x03\xF8W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x03TV[P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0a\x04d`\x005\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a\x02\xA3V[\x90Pa\x04{a\x04s\x823a\x05\xD8V[a\x01\x91a\x04~V[PV[\x81a\x04\x8CWa\x04\x8C\x81a\x06jV[PPV[a\x04\xA2`\x02`\0T\x14\x15a\x01\x90a\x04~V[`\x02`\0UV[a\x04\x8C\x81\x83\x14`ga\x04~V[a\x059\x83c\xA9\x05\x9C\xBB`\xE0\x1B\x84\x84`@Q`$\x01a\x04\xD5\x92\x91\x90a\nIV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x93\x16\x92\x90\x92\x17\x90\x91Ra\x06\xD7V[PPPV[`\x01`\0UV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xAA\xAB\xAD\xC5`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x05\xA0W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x05\xB4W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xFF\x91\x90a\tdV[`\0a\x05\xE2a\x05EV[`\x01`\x01`\xA0\x1B\x03\x16c\x9B\xE2\xA8\x84\x84\x840`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x06\x11\x93\x92\x91\x90a\n\xAFV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x06)W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x06=W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06a\x91\x90a\x08\xFDV[\x90P[\x92\x91PPV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[`\0``\x83`\x01`\x01`\xA0\x1B\x03\x16\x83`@Qa\x06\xF3\x91\x90a\t\xFCV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x070W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x075V[``\x91P[P\x91P\x91P`\0\x82\x14\x15a\x07MW=`\0\x80>=`\0\xFD[a\x07w\x81Q`\0\x14\x80a\x07oWP\x81\x80` \x01\x90Q\x81\x01\x90a\x07o\x91\x90a\x08\xFDV[a\x01\xA2a\x04~V[PPPPV[`\0\x80\x83`\x1F\x84\x01\x12a\x07\x8EW\x81\x82\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07\xA5W\x81\x82\xFD[` \x83\x01\x91P\x83` \x80\x83\x02\x85\x01\x01\x11\x15a\x07\xBFW`\0\x80\xFD[\x92P\x92\x90PV[\x805a\x06d\x81a\n\xF5V[`\0\x80`\0\x80`\0``\x86\x88\x03\x12\x15a\x07\xE8W\x80\x81\xFD[\x855g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x07\xFFW\x82\x83\xFD[a\x08\x0B\x89\x83\x8A\x01a\x07}V[\x90\x97P\x95P` \x88\x015\x91P\x80\x82\x11\x15a\x08#W\x82\x83\xFD[Pa\x080\x88\x82\x89\x01a\x07}V[\x90\x94P\x92PP`@\x86\x015a\x08D\x81a\n\xF5V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[`\0` \x80\x83\x85\x03\x12\x15a\x08dW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x08{W\x83\x84\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x08\x8EW\x83\x84\xFD[\x815\x81\x81\x11\x15a\x08\x9CW\x84\x85\xFD[\x83\x81\x02\x91Pa\x08\xAC\x84\x83\x01a\n\xCEV[\x81\x81R\x84\x81\x01\x90\x84\x86\x01\x84\x86\x01\x87\x01\x8A\x10\x15a\x08\xC6W\x87\x88\xFD[\x87\x95P[\x83\x86\x10\x15a\x08\xF0Wa\x08\xDC\x8A\x82a\x07\xC6V[\x83R`\x01\x95\x90\x95\x01\x94\x91\x86\x01\x91\x86\x01a\x08\xCAV[P\x98\x97PPPPPPPPV[`\0` \x82\x84\x03\x12\x15a\t\x0EW\x80\x81\xFD[\x81Q\x80\x15\x15\x81\x14a\t\x1DW\x81\x82\xFD[\x93\x92PPPV[`\0` \x82\x84\x03\x12\x15a\t5W\x80\x81\xFD[\x815\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\t\x1DW\x81\x82\xFD[`\0` \x82\x84\x03\x12\x15a\tuW\x80\x81\xFD[\x81Qa\t\x1D\x81a\n\xF5V[`\0` \x82\x84\x03\x12\x15a\t\x91W\x80\x81\xFD[\x815a\t\x1D\x81a\n\xF5V[`\0` \x82\x84\x03\x12\x15a\t\xADW\x80\x81\xFD[P5\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\t\xC5W\x80\x81\xFD[PQ\x91\x90PV[\x91\x82R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16` \x82\x01R`$\x01\x90V[`\0\x82Q\x81[\x81\x81\x10\x15a\n\x1CW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\n\x02V[\x81\x81\x11\x15a\n*W\x82\x82\x85\x01R[P\x91\x90\x91\x01\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15a\n\x9AW\x83Q\x83R\x92\x84\x01\x92\x91\x84\x01\x91`\x01\x01a\n~V[P\x90\x96\x95PPPPPPV[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\xEDW`\0\x80\xFD[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x04{W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xBEr\xBD\xF8\xE7\xA3\xC3\x86\x06\xC5\xF9T\xFB\xE2\xD7w\x984z\xAA\x1C\xFBv\xFEw\xEC/l$]$\xBCdsolcC\0\x07\x01\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AuthorizerChanged(address)` and selector `0x94b979b6831a51293e2641426f97747feed46f17779fed9cd18d1ecefcfe92ef`.
+    ```solidity
+    event AuthorizerChanged(address indexed newAuthorizer);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AuthorizerChanged {
+        #[allow(missing_docs)]
+        pub newAuthorizer: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AuthorizerChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AuthorizerChanged(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    148u8, 185u8, 121u8, 182u8, 131u8, 26u8, 81u8, 41u8, 62u8, 38u8, 65u8, 66u8,
+                    111u8, 151u8, 116u8, 127u8, 238u8, 212u8, 111u8, 23u8, 119u8, 159u8, 237u8,
+                    156u8, 209u8, 141u8, 30u8, 206u8, 252u8, 254u8, 146u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    newAuthorizer: topics.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.newAuthorizer.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.newAuthorizer,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AuthorizerChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AuthorizerChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AuthorizerChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ExternalBalanceTransfer(address,address,address,uint256)` and selector `0x540a1a3f28340caec336c81d8d7b3df139ee5cdc1839a4f283d7ebb7eaae2d5c`.
+    ```solidity
+    event ExternalBalanceTransfer(address indexed token, address indexed sender, address recipient, uint256 amount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ExternalBalanceTransfer {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ExternalBalanceTransfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "ExternalBalanceTransfer(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    84u8, 10u8, 26u8, 63u8, 40u8, 52u8, 12u8, 174u8, 195u8, 54u8, 200u8, 29u8,
+                    141u8, 123u8, 61u8, 241u8, 57u8, 238u8, 92u8, 220u8, 24u8, 57u8, 164u8, 242u8,
+                    131u8, 215u8, 235u8, 183u8, 234u8, 174u8, 45u8, 92u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    token: topics.1,
+                    sender: topics.2,
+                    recipient: data.0,
+                    amount: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.token.clone(),
+                    self.sender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExternalBalanceTransfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExternalBalanceTransfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExternalBalanceTransfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FlashLoan(address,address,uint256,uint256)` and selector `0x0d7d75e01ab95780d3cd1c8ec0dd6c2ce19e3a20427eec8bf53283b6fb8e95f0`.
+    ```solidity
+    event FlashLoan(address indexed recipient, address indexed token, uint256 amount, uint256 feeAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FlashLoan {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FlashLoan {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FlashLoan(address,address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    13u8, 125u8, 117u8, 224u8, 26u8, 185u8, 87u8, 128u8, 211u8, 205u8, 28u8, 142u8,
+                    192u8, 221u8, 108u8, 44u8, 225u8, 158u8, 58u8, 32u8, 66u8, 126u8, 236u8, 139u8,
+                    245u8, 50u8, 131u8, 182u8, 251u8, 142u8, 149u8, 240u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    recipient: topics.1,
+                    token: topics.2,
+                    amount: data.0,
+                    feeAmount: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.recipient.clone(),
+                    self.token.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.recipient,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FlashLoan {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FlashLoan> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FlashLoan) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `InternalBalanceChanged(address,address,int256)` and selector `0x18e1ea4139e68413d7d08aa752e71568e36b2c5bf940893314c2c5b01eaa0c42`.
+    ```solidity
+    event InternalBalanceChanged(address indexed user, address indexed token, int256 delta);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct InternalBalanceChanged {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub delta: alloy_sol_types::private::primitives::aliases::I256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for InternalBalanceChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Int<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "InternalBalanceChanged(address,address,int256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    24u8, 225u8, 234u8, 65u8, 57u8, 230u8, 132u8, 19u8, 215u8, 208u8, 138u8, 167u8,
+                    82u8, 231u8, 21u8, 104u8, 227u8, 107u8, 44u8, 91u8, 249u8, 64u8, 137u8, 51u8,
+                    20u8, 194u8, 197u8, 176u8, 30u8, 170u8, 12u8, 66u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    user: topics.1,
+                    token: topics.2,
+                    delta: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.delta,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.user.clone(),
+                    self.token.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.user,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for InternalBalanceChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&InternalBalanceChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &InternalBalanceChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolBalanceChanged(bytes32,address,address[],int256[],uint256[])` and selector `0xe5ce249087ce04f05a957192435400fd97868dba0e6a4b4c049abf8af80dae78`.
+    ```solidity
+    event PoolBalanceChanged(bytes32 indexed poolId, address indexed liquidityProvider, address[] tokens, int256[] deltas, uint256[] protocolFeeAmounts);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolBalanceChanged {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub liquidityProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub deltas:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+        #[allow(missing_docs)]
+        pub protocolFeeAmounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolBalanceChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PoolBalanceChanged(bytes32,address,address[],int256[],uint256[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    229u8, 206u8, 36u8, 144u8, 135u8, 206u8, 4u8, 240u8, 90u8, 149u8, 113u8, 146u8,
+                    67u8, 84u8, 0u8, 253u8, 151u8, 134u8, 141u8, 186u8, 14u8, 106u8, 75u8, 76u8,
+                    4u8, 154u8, 191u8, 138u8, 248u8, 13u8, 174u8, 120u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    liquidityProvider: topics.2,
+                    tokens: data.0,
+                    deltas: data.1,
+                    protocolFeeAmounts: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Int<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deltas),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.protocolFeeAmounts),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.liquidityProvider.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.liquidityProvider,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolBalanceChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolBalanceChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolBalanceChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolBalanceManaged(bytes32,address,address,int256,int256)` and selector `0x6edcaf6241105b4c94c2efdbf3a6b12458eb3d07be3a0e81d24b13c44045fe7a`.
+    ```solidity
+    event PoolBalanceManaged(bytes32 indexed poolId, address indexed assetManager, address indexed token, int256 cashDelta, int256 managedDelta);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolBalanceManaged {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub assetManager: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub cashDelta: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub managedDelta: alloy_sol_types::private::primitives::aliases::I256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolBalanceManaged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PoolBalanceManaged(bytes32,address,address,int256,int256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    110u8, 220u8, 175u8, 98u8, 65u8, 16u8, 91u8, 76u8, 148u8, 194u8, 239u8, 219u8,
+                    243u8, 166u8, 177u8, 36u8, 88u8, 235u8, 61u8, 7u8, 190u8, 58u8, 14u8, 129u8,
+                    210u8, 75u8, 19u8, 196u8, 64u8, 69u8, 254u8, 122u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    assetManager: topics.2,
+                    token: topics.3,
+                    cashDelta: data.0,
+                    managedDelta: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.cashDelta,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.managedDelta,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.assetManager.clone(),
+                    self.token.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.assetManager,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolBalanceManaged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolBalanceManaged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolBalanceManaged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolRegistered(bytes32,address,uint8)` and selector `0x3c13bc30b8e878c53fd2a36b679409c073afd75950be43d8858768e956fbc20e`.
+    ```solidity
+    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, IVault.PoolSpecialization specialization);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolRegistered {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub poolAddress: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolRegistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (IVault::PoolSpecialization,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolRegistered(bytes32,address,uint8)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    60u8, 19u8, 188u8, 48u8, 184u8, 232u8, 120u8, 197u8, 63u8, 210u8, 163u8, 107u8,
+                    103u8, 148u8, 9u8, 192u8, 115u8, 175u8, 215u8, 89u8, 80u8, 190u8, 67u8, 216u8,
+                    133u8, 135u8, 104u8, 233u8, 86u8, 251u8, 194u8, 14u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    poolAddress: topics.2,
+                    specialization: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(
+                        &self.specialization,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.poolAddress.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.poolAddress,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolRegistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolRegistered> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolRegistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RelayerApprovalChanged(address,address,bool)` and selector `0x46961fdb4502b646d5095fba7600486a8ac05041d55cdf0f16ed677180b5cad8`.
+    ```solidity
+    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RelayerApprovalChanged {
+        #[allow(missing_docs)]
+        pub relayer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub approved: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RelayerApprovalChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RelayerApprovalChanged(address,address,bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    70u8, 150u8, 31u8, 219u8, 69u8, 2u8, 182u8, 70u8, 213u8, 9u8, 95u8, 186u8,
+                    118u8, 0u8, 72u8, 106u8, 138u8, 192u8, 80u8, 65u8, 213u8, 92u8, 223u8, 15u8,
+                    22u8, 237u8, 103u8, 113u8, 128u8, 181u8, 202u8, 216u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    relayer: topics.1,
+                    sender: topics.2,
+                    approved: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approved,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.relayer.clone(),
+                    self.sender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.relayer,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RelayerApprovalChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RelayerApprovalChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RelayerApprovalChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Swap(bytes32,address,address,uint256,uint256)` and selector `0x2170c741c41531aec20e7c107c24eecfdd15e69c9bb0a8dd37b1840b9e0b207b`.
+    ```solidity
+    event Swap(bytes32 indexed poolId, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Swap {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Swap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Swap(bytes32,address,address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    33u8, 112u8, 199u8, 65u8, 196u8, 21u8, 49u8, 174u8, 194u8, 14u8, 124u8, 16u8,
+                    124u8, 36u8, 238u8, 207u8, 221u8, 21u8, 230u8, 156u8, 155u8, 176u8, 168u8,
+                    221u8, 55u8, 177u8, 132u8, 11u8, 158u8, 11u8, 32u8, 123u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    tokenIn: topics.2,
+                    tokenOut: topics.3,
+                    amountIn: data.0,
+                    amountOut: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.tokenIn.clone(),
+                    self.tokenOut.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.tokenIn,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.tokenOut,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Swap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Swap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Swap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokensDeregistered(bytes32,address[])` and selector `0x7dcdc6d02ef40c7c1a7046a011b058bd7f988fa14e20a66344f9d4e60657d610`.
+    ```solidity
+    event TokensDeregistered(bytes32 indexed poolId, address[] tokens);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokensDeregistered {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokensDeregistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokensDeregistered(bytes32,address[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    125u8, 205u8, 198u8, 208u8, 46u8, 244u8, 12u8, 124u8, 26u8, 112u8, 70u8, 160u8,
+                    17u8, 176u8, 88u8, 189u8, 127u8, 152u8, 143u8, 161u8, 78u8, 32u8, 166u8, 99u8,
+                    68u8, 249u8, 212u8, 230u8, 6u8, 87u8, 214u8, 16u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    tokens: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.tokens
+                ),)
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.poolId.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokensDeregistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokensDeregistered> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokensDeregistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokensRegistered(bytes32,address[],address[])` and selector `0xf5847d3f2197b16cdcd2098ec95d0905cd1abdaf415f07bb7cef2bba8ac5dec4`.
+    ```solidity
+    event TokensRegistered(bytes32 indexed poolId, address[] tokens, address[] assetManagers);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokensRegistered {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokensRegistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokensRegistered(bytes32,address[],address[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    245u8, 132u8, 125u8, 63u8, 33u8, 151u8, 177u8, 108u8, 220u8, 210u8, 9u8, 142u8,
+                    201u8, 93u8, 9u8, 5u8, 205u8, 26u8, 189u8, 175u8, 65u8, 95u8, 7u8, 187u8,
+                    124u8, 239u8, 43u8, 186u8, 138u8, 197u8, 222u8, 196u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    tokens: data.0,
+                    assetManagers: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetManagers),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.poolId.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokensRegistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokensRegistered> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokensRegistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address authorizer, address weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub authorizer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub weth: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.authorizer,
+                        value.weth,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        authorizer: tuple.0,
+                        weth: tuple.1,
+                        pauseWindowDuration: tuple.2,
+                        bufferPeriodDuration: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.authorizer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.weth,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256)` and selector `0x945bcec9`.
+    ```solidity
+    function batchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds, int256[] memory limits, uint256 deadline) external payable returns (int256[] memory assetDeltas);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchSwapCall {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub swaps: alloy_sol_types::private::Vec<
+            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub limits:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],
+    /// (address,bool,address,bool),int256[],uint256)`](batchSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchSwapReturn {
+        #[allow(missing_docs)]
+        pub assetDeltas:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchSwapCall) -> Self {
+                    (
+                        value.kind,
+                        value.swaps,
+                        value.assets,
+                        value.funds,
+                        value.limits,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        kind: tuple.0,
+                        swaps: tuple.1,
+                        assets: tuple.2,
+                        funds: tuple.3,
+                        limits: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchSwapReturn) -> Self {
+                    (value.assetDeltas,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        assetDeltas: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchSwapCall {
+            type Parameters<'a> = (
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [148u8, 91u8, 206u8, 201u8];
+            const SIGNATURE: &'static str = "batchSwap(uint8,(bytes32,uint256,uint256,uint256,\
+                                             bytes)[],address[],(address,bool,address,bool),\
+                                             int256[],uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::BatchSwapStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
+                        &self.funds,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Int<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.limits),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Int<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: batchSwapReturn = r.into();
+                        r.assetDeltas
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: batchSwapReturn = r.into();
+                    r.assetDeltas
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `deregisterTokens(bytes32,address[])` and selector `0x7d3aeb96`.
+    ```solidity
+    function deregisterTokens(bytes32 poolId, address[] memory tokens) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct deregisterTokensCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    ///Container type for the return parameters of the
+    /// [`deregisterTokens(bytes32,address[])`](deregisterTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct deregisterTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<deregisterTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: deregisterTokensCall) -> Self {
+                    (value.poolId, value.tokens)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        tokens: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<deregisterTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: deregisterTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl deregisterTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <deregisterTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for deregisterTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return = deregisterTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [125u8, 58u8, 235u8, 150u8];
+            const SIGNATURE: &'static str = "deregisterTokens(bytes32,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                deregisterTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `exitPool(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0x8bdb3913`.
+    ```solidity
+    function exitPool(bytes32 poolId, address sender, address recipient, IVault.ExitPoolRequest memory request) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct exitPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`exitPool(bytes32,address,address,(address[],uint256[],bytes,
+    /// bool))`](exitPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct exitPoolReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::ExitPoolRequest,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<exitPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: exitPoolCall) -> Self {
+                    (value.poolId, value.sender, value.recipient, value.request)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exitPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        request: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<exitPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: exitPoolReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exitPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl exitPoolReturn {
+            fn _tokenize(&self) -> <exitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for exitPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::ExitPoolRequest,
+            );
+            type Return = exitPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [139u8, 219u8, 57u8, 19u8];
+            const SIGNATURE: &'static str =
+                "exitPool(bytes32,address,address,(address[],uint256[],bytes,bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <IVault::ExitPoolRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                exitPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `flashLoan(address,address[],uint256[],bytes)` and selector `0x5c38449e`.
+    ```solidity
+    function flashLoan(address recipient, address[] memory tokens, uint256[] memory amounts, bytes memory userData) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct flashLoanCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`flashLoan(address,address[],uint256[],bytes)`](flashLoanCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct flashLoanReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<flashLoanCall> for UnderlyingRustTuple<'_> {
+                fn from(value: flashLoanCall) -> Self {
+                    (value.recipient, value.tokens, value.amounts, value.userData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        tokens: tuple.1,
+                        amounts: tuple.2,
+                        userData: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<flashLoanReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: flashLoanReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl flashLoanReturn {
+            fn _tokenize(&self) -> <flashLoanCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for flashLoanCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = flashLoanReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 56u8, 68u8, 158u8];
+            const SIGNATURE: &'static str = "flashLoan(address,address[],uint256[],bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amounts),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                flashLoanReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getDomainSeparator()` and selector `0xed24911d`.
+    ```solidity
+    function getDomainSeparator() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getDomainSeparatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getDomainSeparator()`](getDomainSeparatorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getDomainSeparatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getDomainSeparatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getDomainSeparatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getDomainSeparatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getDomainSeparatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getDomainSeparatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [237u8, 36u8, 145u8, 29u8];
+            const SIGNATURE: &'static str = "getDomainSeparator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getDomainSeparatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getDomainSeparatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getInternalBalance(address,address[])` and selector `0x0f5a6efa`.
+    ```solidity
+    function getInternalBalance(address user, address[] memory tokens) external view returns (uint256[] memory balances);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getInternalBalanceCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getInternalBalance(address,address[])`](getInternalBalanceCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getInternalBalanceReturn {
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getInternalBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getInternalBalanceCall) -> Self {
+                    (value.user, value.tokens)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInternalBalanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        user: tuple.0,
+                        tokens: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getInternalBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getInternalBalanceReturn) -> Self {
+                    (value.balances,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInternalBalanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { balances: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getInternalBalanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [15u8, 90u8, 110u8, 250u8];
+            const SIGNATURE: &'static str = "getInternalBalance(address,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getInternalBalanceReturn = r.into();
+                        r.balances
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getInternalBalanceReturn = r.into();
+                    r.balances
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getNextNonce(address)` and selector `0x90193b7c`.
+    ```solidity
+    function getNextNonce(address user) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNextNonceCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getNextNonce(address)`](getNextNonceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNextNonceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNextNonceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getNextNonceCall) -> Self {
+                    (value.user,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { user: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNextNonceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getNextNonceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getNextNonceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [144u8, 25u8, 59u8, 124u8];
+            const SIGNATURE: &'static str = "getNextNonce(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getNextNonceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getNextNonceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPool(bytes32)` and selector `0xf6c00927`.
+    ```solidity
+    function getPool(bytes32 poolId) external view returns (address, IVault.PoolSpecialization);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPool(bytes32)`](getPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolCall) -> Self {
+                    (value.poolId,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { poolId: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IVault::PoolSpecialization,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPoolReturn {
+            fn _tokenize(&self) -> <getPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = getPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IVault::PoolSpecialization,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 192u8, 9u8, 39u8];
+            const SIGNATURE: &'static str = "getPool(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolTokenInfo(bytes32,address)` and selector `0xb05f8e48`.
+    ```solidity
+    function getPoolTokenInfo(bytes32 poolId, address token) external view returns (uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolTokenInfoCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolTokenInfo(bytes32,address)`](getPoolTokenInfoCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolTokenInfoReturn {
+        #[allow(missing_docs)]
+        pub cash: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub managed: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub assetManager: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolTokenInfoCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolTokenInfoCall) -> Self {
+                    (value.poolId, value.token)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokenInfoCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        token: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolTokenInfoReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolTokenInfoReturn) -> Self {
+                    (
+                        value.cash,
+                        value.managed,
+                        value.lastChangeBlock,
+                        value.assetManager,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokenInfoReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        cash: tuple.0,
+                        managed: tuple.1,
+                        lastChangeBlock: tuple.2,
+                        assetManager: tuple.3,
+                    }
+                }
+            }
+        }
+        impl getPoolTokenInfoReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPoolTokenInfoCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.cash,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.managed,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.lastChangeBlock,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.assetManager,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolTokenInfoCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = getPoolTokenInfoReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [176u8, 95u8, 142u8, 72u8];
+            const SIGNATURE: &'static str = "getPoolTokenInfo(bytes32,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPoolTokenInfoReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolTokens(bytes32)` and selector `0xf94d4668`.
+    ```solidity
+    function getPoolTokens(bytes32 poolId) external view returns (address[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolTokensCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolTokens(bytes32)`](getPoolTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolTokensReturn {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolTokensCall) -> Self {
+                    (value.poolId,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { poolId: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolTokensReturn) -> Self {
+                    (value.tokens, value.balances, value.lastChangeBlock)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        balances: tuple.1,
+                        lastChangeBlock: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPoolTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPoolTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolTokensCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = getPoolTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [249u8, 77u8, 70u8, 104u8];
+            const SIGNATURE: &'static str = "getPoolTokens(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPoolTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeesCollector()` and selector `0xd2946c2b`.
+    ```solidity
+    function getProtocolFeesCollector() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeesCollectorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeesCollector()`](getProtocolFeesCollectorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeesCollectorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeesCollectorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeesCollectorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeesCollectorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeesCollectorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeesCollectorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 148u8, 108u8, 43u8];
+            const SIGNATURE: &'static str = "getProtocolFeesCollector()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeesCollectorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeesCollectorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hasApprovedRelayer(address,address)` and selector `0xfec90d72`.
+    ```solidity
+    function hasApprovedRelayer(address user, address relayer) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hasApprovedRelayerCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub relayer: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hasApprovedRelayer(address,address)`](hasApprovedRelayerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hasApprovedRelayerReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hasApprovedRelayerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hasApprovedRelayerCall) -> Self {
+                    (value.user, value.relayer)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasApprovedRelayerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        user: tuple.0,
+                        relayer: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hasApprovedRelayerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hasApprovedRelayerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasApprovedRelayerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hasApprovedRelayerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [254u8, 201u8, 13u8, 114u8];
+            const SIGNATURE: &'static str = "hasApprovedRelayer(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.relayer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hasApprovedRelayerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hasApprovedRelayerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `joinPool(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0xb95cac28`.
+    ```solidity
+    function joinPool(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct joinPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`joinPool(bytes32,address,address,(address[],uint256[],bytes,
+    /// bool))`](joinPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct joinPoolReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::JoinPoolRequest,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<joinPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: joinPoolCall) -> Self {
+                    (value.poolId, value.sender, value.recipient, value.request)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for joinPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        request: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<joinPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: joinPoolReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for joinPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl joinPoolReturn {
+            fn _tokenize(&self) -> <joinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for joinPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                IVault::JoinPoolRequest,
+            );
+            type Return = joinPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [185u8, 92u8, 172u8, 40u8];
+            const SIGNATURE: &'static str =
+                "joinPool(bytes32,address,address,(address[],uint256[],bytes,bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <IVault::JoinPoolRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                joinPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `managePoolBalance((uint8,bytes32,address,uint256)[])` and selector `0xe6c46092`.
+    ```solidity
+    function managePoolBalance(IVault.PoolBalanceOp[] memory ops) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct managePoolBalanceCall {
+        #[allow(missing_docs)]
+        pub ops: alloy_sol_types::private::Vec<
+            <IVault::PoolBalanceOp as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`managePoolBalance((uint8,bytes32,address,
+    /// uint256)[])`](managePoolBalanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct managePoolBalanceReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<IVault::PoolBalanceOp>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IVault::PoolBalanceOp as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<managePoolBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: managePoolBalanceCall) -> Self {
+                    (value.ops,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managePoolBalanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { ops: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<managePoolBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: managePoolBalanceReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managePoolBalanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl managePoolBalanceReturn {
+            fn _tokenize(
+                &self,
+            ) -> <managePoolBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for managePoolBalanceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<IVault::PoolBalanceOp>,);
+            type Return = managePoolBalanceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [230u8, 196u8, 96u8, 146u8];
+            const SIGNATURE: &'static str = "managePoolBalance((uint8,bytes32,address,uint256)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::PoolBalanceOp,
+                    > as alloy_sol_types::SolType>::tokenize(&self.ops),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                managePoolBalanceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `manageUserBalance((uint8,address,uint256,address,address)[])` and selector `0x0e8e3e84`.
+    ```solidity
+    function manageUserBalance(IVault.UserBalanceOp[] memory ops) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct manageUserBalanceCall {
+        #[allow(missing_docs)]
+        pub ops: alloy_sol_types::private::Vec<
+            <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`manageUserBalance((uint8,address,uint256,address,
+    /// address)[])`](manageUserBalanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct manageUserBalanceReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<IVault::UserBalanceOp>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<manageUserBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: manageUserBalanceCall) -> Self {
+                    (value.ops,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for manageUserBalanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { ops: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<manageUserBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: manageUserBalanceReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for manageUserBalanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl manageUserBalanceReturn {
+            fn _tokenize(
+                &self,
+            ) -> <manageUserBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for manageUserBalanceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<IVault::UserBalanceOp>,);
+            type Return = manageUserBalanceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [14u8, 142u8, 62u8, 132u8];
+            const SIGNATURE: &'static str =
+                "manageUserBalance((uint8,address,uint256,address,address)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::UserBalanceOp,
+                    > as alloy_sol_types::SolType>::tokenize(&self.ops),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                manageUserBalanceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool))` and selector `0xf84d066e`.
+    ```solidity
+    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external view returns (int256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryBatchSwapCall {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub swaps: alloy_sol_types::private::Vec<
+            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],
+    /// address[],(address,bool,address,bool))`](queryBatchSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryBatchSwapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryBatchSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryBatchSwapCall) -> Self {
+                    (value.kind, value.swaps, value.assets, value.funds)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        kind: tuple.0,
+                        swaps: tuple.1,
+                        assets: tuple.2,
+                        funds: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryBatchSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryBatchSwapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryBatchSwapCall {
+            type Parameters<'a> = (
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 77u8, 6u8, 110u8];
+            const SIGNATURE: &'static str = "queryBatchSwap(uint8,(bytes32,uint256,uint256,\
+                                             uint256,bytes)[],address[],(address,bool,address,\
+                                             bool))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::BatchSwapStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
+                        &self.funds,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Int<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: queryBatchSwapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: queryBatchSwapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `registerPool(uint8)` and selector `0x09b2760f`.
+    ```solidity
+    function registerPool(IVault.PoolSpecialization specialization) external returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerPoolCall {
+        #[allow(missing_docs)]
+        pub specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`registerPool(uint8)`](registerPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IVault::PoolSpecialization,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: registerPoolCall) -> Self {
+                    (value.specialization,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        specialization: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: registerPoolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for registerPoolCall {
+            type Parameters<'a> = (IVault::PoolSpecialization,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 178u8, 118u8, 15u8];
+            const SIGNATURE: &'static str = "registerPool(uint8)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(
+                        &self.specialization,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: registerPoolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: registerPoolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `registerTokens(bytes32,address[],address[])` and selector `0x66a9c7d2`.
+    ```solidity
+    function registerTokens(bytes32 poolId, address[] memory tokens, address[] memory assetManagers) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerTokensCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    ///Container type for the return parameters of the
+    /// [`registerTokens(bytes32,address[],address[])`](registerTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: registerTokensCall) -> Self {
+                    (value.poolId, value.tokens, value.assetManagers)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        tokens: tuple.1,
+                        assetManagers: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: registerTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl registerTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <registerTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for registerTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return = registerTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 169u8, 199u8, 210u8];
+            const SIGNATURE: &'static str = "registerTokens(bytes32,address[],address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetManagers),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                registerTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setAuthorizer(address)` and selector `0x058a628f`.
+    ```solidity
+    function setAuthorizer(address newAuthorizer) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAuthorizerCall {
+        #[allow(missing_docs)]
+        pub newAuthorizer: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setAuthorizer(address)`](setAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setAuthorizerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setAuthorizerCall) -> Self {
+                    (value.newAuthorizer,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        newAuthorizer: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setAuthorizerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setAuthorizerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setAuthorizerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setAuthorizerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setAuthorizerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 138u8, 98u8, 143u8];
+            const SIGNATURE: &'static str = "setAuthorizer(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newAuthorizer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setAuthorizerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    ```solidity
+    function setPaused(bool paused) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedCall {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setPaused(bool)`](setPausedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedCall) -> Self {
+                    (value.paused,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { paused: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setPausedReturn {
+            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setPausedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Return = setPausedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
+            const SIGNATURE: &'static str = "setPaused(bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setPausedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setRelayerApproval(address,address,bool)` and selector `0xfa6e671d`.
+    ```solidity
+    function setRelayerApproval(address sender, address relayer, bool approved) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setRelayerApprovalCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub relayer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub approved: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setRelayerApproval(address,address,bool)`](setRelayerApprovalCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setRelayerApprovalReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setRelayerApprovalCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setRelayerApprovalCall) -> Self {
+                    (value.sender, value.relayer, value.approved)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setRelayerApprovalCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        relayer: tuple.1,
+                        approved: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setRelayerApprovalReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setRelayerApprovalReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setRelayerApprovalReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setRelayerApprovalReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setRelayerApprovalCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setRelayerApprovalCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = setRelayerApprovalReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [250u8, 110u8, 103u8, 29u8];
+            const SIGNATURE: &'static str = "setRelayerApproval(address,address,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.relayer,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approved,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setRelayerApprovalReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `swap((bytes32,uint8,address,address,uint256,bytes),(address,bool,address,bool),uint256,uint256)` and selector `0x52bbbe29`.
+    ```solidity
+    function swap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds, uint256 limit, uint256 deadline) external payable returns (uint256 amountCalculated);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub singleSwap: <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub limit: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swap((bytes32,uint8,address,address,uint256,bytes),(address,bool,
+    /// address,bool),uint256,uint256)`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {
+        #[allow(missing_docs)]
+        pub amountCalculated: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IVault::SingleSwap,
+                IVault::FundManagement,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
+                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (value.singleSwap, value.funds, value.limit, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        singleSwap: tuple.0,
+                        funds: tuple.1,
+                        limit: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    (value.amountCalculated,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountCalculated: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                IVault::SingleSwap,
+                IVault::FundManagement,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [82u8, 187u8, 190u8, 41u8];
+            const SIGNATURE: &'static str = "swap((bytes32,uint8,address,address,uint256,bytes),\
+                                             (address,bool,address,bool),uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IVault::SingleSwap as alloy_sol_types::SolType>::tokenize(&self.singleSwap),
+                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(&self.funds),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.limit,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapReturn = r.into();
+                        r.amountCalculated
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapReturn = r.into();
+                    r.amountCalculated
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2Vault`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2VaultCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        batchSwap(batchSwapCall),
+        #[allow(missing_docs)]
+        deregisterTokens(deregisterTokensCall),
+        #[allow(missing_docs)]
+        exitPool(exitPoolCall),
+        #[allow(missing_docs)]
+        flashLoan(flashLoanCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getDomainSeparator(getDomainSeparatorCall),
+        #[allow(missing_docs)]
+        getInternalBalance(getInternalBalanceCall),
+        #[allow(missing_docs)]
+        getNextNonce(getNextNonceCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPool(getPoolCall),
+        #[allow(missing_docs)]
+        getPoolTokenInfo(getPoolTokenInfoCall),
+        #[allow(missing_docs)]
+        getPoolTokens(getPoolTokensCall),
+        #[allow(missing_docs)]
+        getProtocolFeesCollector(getProtocolFeesCollectorCall),
+        #[allow(missing_docs)]
+        hasApprovedRelayer(hasApprovedRelayerCall),
+        #[allow(missing_docs)]
+        joinPool(joinPoolCall),
+        #[allow(missing_docs)]
+        managePoolBalance(managePoolBalanceCall),
+        #[allow(missing_docs)]
+        manageUserBalance(manageUserBalanceCall),
+        #[allow(missing_docs)]
+        queryBatchSwap(queryBatchSwapCall),
+        #[allow(missing_docs)]
+        registerPool(registerPoolCall),
+        #[allow(missing_docs)]
+        registerTokens(registerTokensCall),
+        #[allow(missing_docs)]
+        setAuthorizer(setAuthorizerCall),
+        #[allow(missing_docs)]
+        setPaused(setPausedCall),
+        #[allow(missing_docs)]
+        setRelayerApproval(setRelayerApprovalCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+    }
+    impl BalancerV2VaultCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [5u8, 138u8, 98u8, 143u8],
+            [9u8, 178u8, 118u8, 15u8],
+            [14u8, 142u8, 62u8, 132u8],
+            [15u8, 90u8, 110u8, 250u8],
+            [22u8, 195u8, 139u8, 60u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [82u8, 187u8, 190u8, 41u8],
+            [92u8, 56u8, 68u8, 158u8],
+            [102u8, 169u8, 199u8, 210u8],
+            [125u8, 58u8, 235u8, 150u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [139u8, 219u8, 57u8, 19u8],
+            [144u8, 25u8, 59u8, 124u8],
+            [148u8, 91u8, 206u8, 201u8],
+            [170u8, 171u8, 173u8, 197u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [176u8, 95u8, 142u8, 72u8],
+            [185u8, 92u8, 172u8, 40u8],
+            [210u8, 148u8, 108u8, 43u8],
+            [230u8, 196u8, 96u8, 146u8],
+            [237u8, 36u8, 145u8, 29u8],
+            [246u8, 192u8, 9u8, 39u8],
+            [248u8, 77u8, 6u8, 110u8],
+            [249u8, 77u8, 70u8, 104u8],
+            [250u8, 110u8, 103u8, 29u8],
+            [254u8, 201u8, 13u8, 114u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <setAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <registerPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <manageUserBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getInternalBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <flashLoanCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <registerTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <deregisterTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <exitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getNextNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolTokenInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <joinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <managePoolBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getDomainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryBatchSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setRelayerApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hasApprovedRelayerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(setAuthorizer),
+            ::core::stringify!(registerPool),
+            ::core::stringify!(manageUserBalance),
+            ::core::stringify!(getInternalBalance),
+            ::core::stringify!(setPaused),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(swap),
+            ::core::stringify!(flashLoan),
+            ::core::stringify!(registerTokens),
+            ::core::stringify!(deregisterTokens),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(exitPool),
+            ::core::stringify!(getNextNonce),
+            ::core::stringify!(batchSwap),
+            ::core::stringify!(getAuthorizer),
+            ::core::stringify!(WETH),
+            ::core::stringify!(getPoolTokenInfo),
+            ::core::stringify!(joinPool),
+            ::core::stringify!(getProtocolFeesCollector),
+            ::core::stringify!(managePoolBalance),
+            ::core::stringify!(getDomainSeparator),
+            ::core::stringify!(getPool),
+            ::core::stringify!(queryBatchSwap),
+            ::core::stringify!(getPoolTokens),
+            ::core::stringify!(setRelayerApproval),
+            ::core::stringify!(hasApprovedRelayer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2VaultCalls {
+        const COUNT: usize = 26usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2VaultCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::batchSwap(_) => <batchSwapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::deregisterTokens(_) => {
+                    <deregisterTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::exitPool(_) => <exitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::flashLoan(_) => <flashLoanCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getDomainSeparator(_) => {
+                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getInternalBalance(_) => {
+                    <getInternalBalanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getNextNonce(_) => <getNextNonceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPool(_) => <getPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPoolTokenInfo(_) => {
+                    <getPoolTokenInfoCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolTokens(_) => <getPoolTokensCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getProtocolFeesCollector(_) => {
+                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::hasApprovedRelayer(_) => {
+                    <hasApprovedRelayerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::joinPool(_) => <joinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::managePoolBalance(_) => {
+                    <managePoolBalanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::manageUserBalance(_) => {
+                    <manageUserBalanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::queryBatchSwap(_) => {
+                    <queryBatchSwapCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::registerPool(_) => <registerPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::registerTokens(_) => {
+                    <registerTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setAuthorizer(_) => <setAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setRelayerApproval(_) => {
+                    <setRelayerApprovalCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls>] = &[
+                {
+                    fn setAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <setAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::setAuthorizer)
+                    }
+                    setAuthorizer
+                },
+                {
+                    fn registerPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <registerPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::registerPool)
+                    }
+                    registerPool
+                },
+                {
+                    fn manageUserBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <manageUserBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::manageUserBalance)
+                    }
+                    manageUserBalance
+                },
+                {
+                    fn getInternalBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getInternalBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getInternalBalance)
+                    }
+                    getInternalBalance
+                },
+                {
+                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn flashLoan(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <flashLoanCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::flashLoan)
+                    }
+                    flashLoan
+                },
+                {
+                    fn registerTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <registerTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::registerTokens)
+                    }
+                    registerTokens
+                },
+                {
+                    fn deregisterTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <deregisterTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::deregisterTokens)
+                    }
+                    deregisterTokens
+                },
+                {
+                    fn getActionId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn exitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <exitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::exitPool)
+                    }
+                    exitPool
+                },
+                {
+                    fn getNextNonce(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getNextNonce)
+                    }
+                    getNextNonce
+                },
+                {
+                    fn batchSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <batchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::batchSwap)
+                    }
+                    batchSwap
+                },
+                {
+                    fn getAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn getPoolTokenInfo(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getPoolTokenInfo)
+                    }
+                    getPoolTokenInfo
+                },
+                {
+                    fn joinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <joinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::joinPool)
+                    }
+                    joinPool
+                },
+                {
+                    fn getProtocolFeesCollector(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::getProtocolFeesCollector)
+                    }
+                    getProtocolFeesCollector
+                },
+                {
+                    fn managePoolBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::managePoolBalance)
+                    }
+                    managePoolBalance
+                },
+                {
+                    fn getDomainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getDomainSeparator)
+                    }
+                    getDomainSeparator
+                },
+                {
+                    fn getPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getPool)
+                    }
+                    getPool
+                },
+                {
+                    fn queryBatchSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::queryBatchSwap)
+                    }
+                    queryBatchSwap
+                },
+                {
+                    fn getPoolTokens(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPoolTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::getPoolTokens)
+                    }
+                    getPoolTokens
+                },
+                {
+                    fn setRelayerApproval(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <setRelayerApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::setRelayerApproval)
+                    }
+                    setRelayerApproval
+                },
+                {
+                    fn hasApprovedRelayer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <hasApprovedRelayerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2VaultCalls::hasApprovedRelayer)
+                    }
+                    hasApprovedRelayer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV2VaultCalls>] = &[
+                {
+                    fn setAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <setAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::setAuthorizer)
+                    }
+                    setAuthorizer
+                },
+                {
+                    fn registerPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <registerPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::registerPool)
+                    }
+                    registerPool
+                },
+                {
+                    fn manageUserBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <manageUserBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::manageUserBalance)
+                    }
+                    manageUserBalance
+                },
+                {
+                    fn getInternalBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getInternalBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::getInternalBalance)
+                    }
+                    getInternalBalance
+                },
+                {
+                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn flashLoan(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <flashLoanCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::flashLoan)
+                    }
+                    flashLoan
+                },
+                {
+                    fn registerTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <registerTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::registerTokens)
+                    }
+                    registerTokens
+                },
+                {
+                    fn deregisterTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <deregisterTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::deregisterTokens)
+                    }
+                    deregisterTokens
+                },
+                {
+                    fn getActionId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn exitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <exitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::exitPool)
+                    }
+                    exitPool
+                },
+                {
+                    fn getNextNonce(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::getNextNonce)
+                    }
+                    getNextNonce
+                },
+                {
+                    fn batchSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <batchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::batchSwap)
+                    }
+                    batchSwap
+                },
+                {
+                    fn getAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn getPoolTokenInfo(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::getPoolTokenInfo)
+                    }
+                    getPoolTokenInfo
+                },
+                {
+                    fn joinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <joinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::joinPool)
+                    }
+                    joinPool
+                },
+                {
+                    fn getProtocolFeesCollector(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::getProtocolFeesCollector)
+                    }
+                    getProtocolFeesCollector
+                },
+                {
+                    fn managePoolBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::managePoolBalance)
+                    }
+                    managePoolBalance
+                },
+                {
+                    fn getDomainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::getDomainSeparator)
+                    }
+                    getDomainSeparator
+                },
+                {
+                    fn getPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2VaultCalls::getPool)
+                    }
+                    getPool
+                },
+                {
+                    fn queryBatchSwap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::queryBatchSwap)
+                    }
+                    queryBatchSwap
+                },
+                {
+                    fn getPoolTokens(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <getPoolTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2VaultCalls::getPoolTokens)
+                    }
+                    getPoolTokens
+                },
+                {
+                    fn setRelayerApproval(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <setRelayerApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::setRelayerApproval)
+                    }
+                    setRelayerApproval
+                },
+                {
+                    fn hasApprovedRelayer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
+                        <hasApprovedRelayerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2VaultCalls::hasApprovedRelayer)
+                    }
+                    hasApprovedRelayer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::batchSwap(inner) => {
+                    <batchSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::deregisterTokens(inner) => {
+                    <deregisterTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::exitPool(inner) => {
+                    <exitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::flashLoan(inner) => {
+                    <flashLoanCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getDomainSeparator(inner) => {
+                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getInternalBalance(inner) => {
+                    <getInternalBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getNextNonce(inner) => {
+                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPool(inner) => {
+                    <getPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPoolTokenInfo(inner) => {
+                    <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPoolTokens(inner) => {
+                    <getPoolTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getProtocolFeesCollector(inner) => {
+                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::hasApprovedRelayer(inner) => {
+                    <hasApprovedRelayerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::joinPool(inner) => {
+                    <joinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::managePoolBalance(inner) => {
+                    <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::manageUserBalance(inner) => {
+                    <manageUserBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryBatchSwap(inner) => {
+                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::registerPool(inner) => {
+                    <registerPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::registerTokens(inner) => {
+                    <registerTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setAuthorizer(inner) => {
+                    <setAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setRelayerApproval(inner) => {
+                    <setRelayerApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::batchSwap(inner) => {
+                    <batchSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::deregisterTokens(inner) => {
+                    <deregisterTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::exitPool(inner) => {
+                    <exitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::flashLoan(inner) => {
+                    <flashLoanCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getDomainSeparator(inner) => {
+                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getInternalBalance(inner) => {
+                    <getInternalBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getNextNonce(inner) => {
+                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPool(inner) => {
+                    <getPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPoolTokenInfo(inner) => {
+                    <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPoolTokens(inner) => {
+                    <getPoolTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getProtocolFeesCollector(inner) => {
+                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::hasApprovedRelayer(inner) => {
+                    <hasApprovedRelayerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::joinPool(inner) => {
+                    <joinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::managePoolBalance(inner) => {
+                    <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::manageUserBalance(inner) => {
+                    <manageUserBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryBatchSwap(inner) => {
+                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::registerPool(inner) => {
+                    <registerPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::registerTokens(inner) => {
+                    <registerTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setAuthorizer(inner) => {
+                    <setAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setRelayerApproval(inner) => {
+                    <setRelayerApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2Vault`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2VaultEvents {
+        #[allow(missing_docs)]
+        AuthorizerChanged(AuthorizerChanged),
+        #[allow(missing_docs)]
+        ExternalBalanceTransfer(ExternalBalanceTransfer),
+        #[allow(missing_docs)]
+        FlashLoan(FlashLoan),
+        #[allow(missing_docs)]
+        InternalBalanceChanged(InternalBalanceChanged),
+        #[allow(missing_docs)]
+        PausedStateChanged(PausedStateChanged),
+        #[allow(missing_docs)]
+        PoolBalanceChanged(PoolBalanceChanged),
+        #[allow(missing_docs)]
+        PoolBalanceManaged(PoolBalanceManaged),
+        #[allow(missing_docs)]
+        PoolRegistered(PoolRegistered),
+        #[allow(missing_docs)]
+        RelayerApprovalChanged(RelayerApprovalChanged),
+        #[allow(missing_docs)]
+        Swap(Swap),
+        #[allow(missing_docs)]
+        TokensDeregistered(TokensDeregistered),
+        #[allow(missing_docs)]
+        TokensRegistered(TokensRegistered),
+    }
+    impl BalancerV2VaultEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                13u8, 125u8, 117u8, 224u8, 26u8, 185u8, 87u8, 128u8, 211u8, 205u8, 28u8, 142u8,
+                192u8, 221u8, 108u8, 44u8, 225u8, 158u8, 58u8, 32u8, 66u8, 126u8, 236u8, 139u8,
+                245u8, 50u8, 131u8, 182u8, 251u8, 142u8, 149u8, 240u8,
+            ],
+            [
+                24u8, 225u8, 234u8, 65u8, 57u8, 230u8, 132u8, 19u8, 215u8, 208u8, 138u8, 167u8,
+                82u8, 231u8, 21u8, 104u8, 227u8, 107u8, 44u8, 91u8, 249u8, 64u8, 137u8, 51u8, 20u8,
+                194u8, 197u8, 176u8, 30u8, 170u8, 12u8, 66u8,
+            ],
+            [
+                33u8, 112u8, 199u8, 65u8, 196u8, 21u8, 49u8, 174u8, 194u8, 14u8, 124u8, 16u8,
+                124u8, 36u8, 238u8, 207u8, 221u8, 21u8, 230u8, 156u8, 155u8, 176u8, 168u8, 221u8,
+                55u8, 177u8, 132u8, 11u8, 158u8, 11u8, 32u8, 123u8,
+            ],
+            [
+                60u8, 19u8, 188u8, 48u8, 184u8, 232u8, 120u8, 197u8, 63u8, 210u8, 163u8, 107u8,
+                103u8, 148u8, 9u8, 192u8, 115u8, 175u8, 215u8, 89u8, 80u8, 190u8, 67u8, 216u8,
+                133u8, 135u8, 104u8, 233u8, 86u8, 251u8, 194u8, 14u8,
+            ],
+            [
+                70u8, 150u8, 31u8, 219u8, 69u8, 2u8, 182u8, 70u8, 213u8, 9u8, 95u8, 186u8, 118u8,
+                0u8, 72u8, 106u8, 138u8, 192u8, 80u8, 65u8, 213u8, 92u8, 223u8, 15u8, 22u8, 237u8,
+                103u8, 113u8, 128u8, 181u8, 202u8, 216u8,
+            ],
+            [
+                84u8, 10u8, 26u8, 63u8, 40u8, 52u8, 12u8, 174u8, 195u8, 54u8, 200u8, 29u8, 141u8,
+                123u8, 61u8, 241u8, 57u8, 238u8, 92u8, 220u8, 24u8, 57u8, 164u8, 242u8, 131u8,
+                215u8, 235u8, 183u8, 234u8, 174u8, 45u8, 92u8,
+            ],
+            [
+                110u8, 220u8, 175u8, 98u8, 65u8, 16u8, 91u8, 76u8, 148u8, 194u8, 239u8, 219u8,
+                243u8, 166u8, 177u8, 36u8, 88u8, 235u8, 61u8, 7u8, 190u8, 58u8, 14u8, 129u8, 210u8,
+                75u8, 19u8, 196u8, 64u8, 69u8, 254u8, 122u8,
+            ],
+            [
+                125u8, 205u8, 198u8, 208u8, 46u8, 244u8, 12u8, 124u8, 26u8, 112u8, 70u8, 160u8,
+                17u8, 176u8, 88u8, 189u8, 127u8, 152u8, 143u8, 161u8, 78u8, 32u8, 166u8, 99u8,
+                68u8, 249u8, 212u8, 230u8, 6u8, 87u8, 214u8, 16u8,
+            ],
+            [
+                148u8, 185u8, 121u8, 182u8, 131u8, 26u8, 81u8, 41u8, 62u8, 38u8, 65u8, 66u8, 111u8,
+                151u8, 116u8, 127u8, 238u8, 212u8, 111u8, 23u8, 119u8, 159u8, 237u8, 156u8, 209u8,
+                141u8, 30u8, 206u8, 252u8, 254u8, 146u8, 239u8,
+            ],
+            [
+                158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+            ],
+            [
+                229u8, 206u8, 36u8, 144u8, 135u8, 206u8, 4u8, 240u8, 90u8, 149u8, 113u8, 146u8,
+                67u8, 84u8, 0u8, 253u8, 151u8, 134u8, 141u8, 186u8, 14u8, 106u8, 75u8, 76u8, 4u8,
+                154u8, 191u8, 138u8, 248u8, 13u8, 174u8, 120u8,
+            ],
+            [
+                245u8, 132u8, 125u8, 63u8, 33u8, 151u8, 177u8, 108u8, 220u8, 210u8, 9u8, 142u8,
+                201u8, 93u8, 9u8, 5u8, 205u8, 26u8, 189u8, 175u8, 65u8, 95u8, 7u8, 187u8, 124u8,
+                239u8, 43u8, 186u8, 138u8, 197u8, 222u8, 196u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FlashLoan as alloy_sol_types::SolEvent>::SIGNATURE,
+            <InternalBalanceChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Swap as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolRegistered as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RelayerApprovalChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ExternalBalanceTransfer as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolBalanceManaged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TokensDeregistered as alloy_sol_types::SolEvent>::SIGNATURE,
+            <AuthorizerChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolBalanceChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TokensRegistered as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FlashLoan),
+            ::core::stringify!(InternalBalanceChanged),
+            ::core::stringify!(Swap),
+            ::core::stringify!(PoolRegistered),
+            ::core::stringify!(RelayerApprovalChanged),
+            ::core::stringify!(ExternalBalanceTransfer),
+            ::core::stringify!(PoolBalanceManaged),
+            ::core::stringify!(TokensDeregistered),
+            ::core::stringify!(AuthorizerChanged),
+            ::core::stringify!(PausedStateChanged),
+            ::core::stringify!(PoolBalanceChanged),
+            ::core::stringify!(TokensRegistered),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2VaultEvents {
+        const COUNT: usize = 12usize;
+        const NAME: &'static str = "BalancerV2VaultEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<AuthorizerChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <AuthorizerChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::AuthorizerChanged)
+                }
+                Some(<ExternalBalanceTransfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ExternalBalanceTransfer as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ExternalBalanceTransfer)
+                }
+                Some(<FlashLoan as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FlashLoan as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FlashLoan)
+                }
+                Some(<InternalBalanceChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <InternalBalanceChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::InternalBalanceChanged)
+                }
+                Some(<PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PausedStateChanged)
+                }
+                Some(<PoolBalanceChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolBalanceChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolBalanceChanged)
+                }
+                Some(<PoolBalanceManaged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolBalanceManaged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolBalanceManaged)
+                }
+                Some(<PoolRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolRegistered as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolRegistered)
+                }
+                Some(<RelayerApprovalChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RelayerApprovalChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::RelayerApprovalChanged)
+                }
+                Some(<Swap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Swap as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Swap)
+                }
+                Some(<TokensDeregistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TokensDeregistered as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TokensDeregistered)
+                }
+                Some(<TokensRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TokensRegistered as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TokensRegistered)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2VaultEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AuthorizerChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ExternalBalanceTransfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::FlashLoan(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::InternalBalanceChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolBalanceChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolBalanceManaged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RelayerApprovalChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::TokensDeregistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TokensRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AuthorizerChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ExternalBalanceTransfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::FlashLoan(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::InternalBalanceChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolBalanceChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolBalanceManaged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RelayerApprovalChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::TokensDeregistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TokensRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2Vault`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2VaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2VaultInstance<P, N> {
+        BalancerV2VaultInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        authorizer: alloy_sol_types::private::Address,
+        weth: alloy_sol_types::private::Address,
+        pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<BalancerV2VaultInstance<P, N>>>
+    {
+        BalancerV2VaultInstance::<P, N>::deploy(
+            __provider,
+            authorizer,
+            weth,
+            pauseWindowDuration,
+            bufferPeriodDuration,
+        )
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        authorizer: alloy_sol_types::private::Address,
+        weth: alloy_sol_types::private::Address,
+        pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        BalancerV2VaultInstance::<P, N>::deploy_builder(
+            __provider,
+            authorizer,
+            weth,
+            pauseWindowDuration,
+            bufferPeriodDuration,
+        )
+    }
+    /**A [`BalancerV2Vault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2Vault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2VaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2VaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2VaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2VaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2Vault`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2VaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            authorizer: alloy_sol_types::private::Address,
+            weth: alloy_sol_types::private::Address,
+            pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+            bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::Result<BalancerV2VaultInstance<P, N>> {
+            let call_builder = Self::deploy_builder(
+                __provider,
+                authorizer,
+                weth,
+                pauseWindowDuration,
+                bufferPeriodDuration,
+            );
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            authorizer: alloy_sol_types::private::Address,
+            weth: alloy_sol_types::private::Address,
+            pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+            bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        authorizer,
+                        weth,
+                        pauseWindowDuration,
+                        bufferPeriodDuration,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2VaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2VaultInstance<P, N> {
+            BalancerV2VaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2VaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`batchSwap`] function.
+        pub fn batchSwap(
+            &self,
+            kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            swaps: alloy_sol_types::private::Vec<
+                <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+            >,
+            assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+            limits: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::I256,
+            >,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, batchSwapCall, N> {
+            self.call_builder(&batchSwapCall {
+                kind,
+                swaps,
+                assets,
+                funds,
+                limits,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`deregisterTokens`] function.
+        pub fn deregisterTokens(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, deregisterTokensCall, N> {
+            self.call_builder(&deregisterTokensCall { poolId, tokens })
+        }
+
+        ///Creates a new call builder for the [`exitPool`] function.
+        pub fn exitPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, exitPoolCall, N> {
+            self.call_builder(&exitPoolCall {
+                poolId,
+                sender,
+                recipient,
+                request,
+            })
+        }
+
+        ///Creates a new call builder for the [`flashLoan`] function.
+        pub fn flashLoan(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            amounts: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, flashLoanCall, N> {
+            self.call_builder(&flashLoanCall {
+                recipient,
+                tokens,
+                amounts,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getDomainSeparator`] function.
+        pub fn getDomainSeparator(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getDomainSeparatorCall, N> {
+            self.call_builder(&getDomainSeparatorCall)
+        }
+
+        ///Creates a new call builder for the [`getInternalBalance`] function.
+        pub fn getInternalBalance(
+            &self,
+            user: alloy_sol_types::private::Address,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getInternalBalanceCall, N> {
+            self.call_builder(&getInternalBalanceCall { user, tokens })
+        }
+
+        ///Creates a new call builder for the [`getNextNonce`] function.
+        pub fn getNextNonce(
+            &self,
+            user: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getNextNonceCall, N> {
+            self.call_builder(&getNextNonceCall { user })
+        }
+
+        ///Creates a new call builder for the [`getPausedState`] function.
+        pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
+            self.call_builder(&getPausedStateCall)
+        }
+
+        ///Creates a new call builder for the [`getPool`] function.
+        pub fn getPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, getPoolCall, N> {
+            self.call_builder(&getPoolCall { poolId })
+        }
+
+        ///Creates a new call builder for the [`getPoolTokenInfo`] function.
+        pub fn getPoolTokenInfo(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            token: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getPoolTokenInfoCall, N> {
+            self.call_builder(&getPoolTokenInfoCall { poolId, token })
+        }
+
+        ///Creates a new call builder for the [`getPoolTokens`] function.
+        pub fn getPoolTokens(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, getPoolTokensCall, N> {
+            self.call_builder(&getPoolTokensCall { poolId })
+        }
+
+        ///Creates a new call builder for the [`getProtocolFeesCollector`]
+        /// function.
+        pub fn getProtocolFeesCollector(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeesCollectorCall, N> {
+            self.call_builder(&getProtocolFeesCollectorCall)
+        }
+
+        ///Creates a new call builder for the [`hasApprovedRelayer`] function.
+        pub fn hasApprovedRelayer(
+            &self,
+            user: alloy_sol_types::private::Address,
+            relayer: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, hasApprovedRelayerCall, N> {
+            self.call_builder(&hasApprovedRelayerCall { user, relayer })
+        }
+
+        ///Creates a new call builder for the [`joinPool`] function.
+        pub fn joinPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, joinPoolCall, N> {
+            self.call_builder(&joinPoolCall {
+                poolId,
+                sender,
+                recipient,
+                request,
+            })
+        }
+
+        ///Creates a new call builder for the [`managePoolBalance`] function.
+        pub fn managePoolBalance(
+            &self,
+            ops: alloy_sol_types::private::Vec<
+                <IVault::PoolBalanceOp as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, managePoolBalanceCall, N> {
+            self.call_builder(&managePoolBalanceCall { ops })
+        }
+
+        ///Creates a new call builder for the [`manageUserBalance`] function.
+        pub fn manageUserBalance(
+            &self,
+            ops: alloy_sol_types::private::Vec<
+                <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, manageUserBalanceCall, N> {
+            self.call_builder(&manageUserBalanceCall { ops })
+        }
+
+        ///Creates a new call builder for the [`queryBatchSwap`] function.
+        pub fn queryBatchSwap(
+            &self,
+            kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            swaps: alloy_sol_types::private::Vec<
+                <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+            >,
+            assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, queryBatchSwapCall, N> {
+            self.call_builder(&queryBatchSwapCall {
+                kind,
+                swaps,
+                assets,
+                funds,
+            })
+        }
+
+        ///Creates a new call builder for the [`registerPool`] function.
+        pub fn registerPool(
+            &self,
+            specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, registerPoolCall, N> {
+            self.call_builder(&registerPoolCall { specialization })
+        }
+
+        ///Creates a new call builder for the [`registerTokens`] function.
+        pub fn registerTokens(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, registerTokensCall, N> {
+            self.call_builder(&registerTokensCall {
+                poolId,
+                tokens,
+                assetManagers,
+            })
+        }
+
+        ///Creates a new call builder for the [`setAuthorizer`] function.
+        pub fn setAuthorizer(
+            &self,
+            newAuthorizer: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setAuthorizerCall, N> {
+            self.call_builder(&setAuthorizerCall { newAuthorizer })
+        }
+
+        ///Creates a new call builder for the [`setPaused`] function.
+        pub fn setPaused(
+            &self,
+            paused: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
+            self.call_builder(&setPausedCall { paused })
+        }
+
+        ///Creates a new call builder for the [`setRelayerApproval`] function.
+        pub fn setRelayerApproval(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            relayer: alloy_sol_types::private::Address,
+            approved: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setRelayerApprovalCall, N> {
+            self.call_builder(&setRelayerApprovalCall {
+                sender,
+                relayer,
+                approved,
+            })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            singleSwap: <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
+            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+            limit: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                singleSwap,
+                funds,
+                limit,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2VaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`AuthorizerChanged`] event.
+        pub fn AuthorizerChanged_filter(&self) -> alloy_contract::Event<&P, AuthorizerChanged, N> {
+            self.event_filter::<AuthorizerChanged>()
+        }
+
+        ///Creates a new event filter for the [`ExternalBalanceTransfer`]
+        /// event.
+        pub fn ExternalBalanceTransfer_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ExternalBalanceTransfer, N> {
+            self.event_filter::<ExternalBalanceTransfer>()
+        }
+
+        ///Creates a new event filter for the [`FlashLoan`] event.
+        pub fn FlashLoan_filter(&self) -> alloy_contract::Event<&P, FlashLoan, N> {
+            self.event_filter::<FlashLoan>()
+        }
+
+        ///Creates a new event filter for the [`InternalBalanceChanged`] event.
+        pub fn InternalBalanceChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, InternalBalanceChanged, N> {
+            self.event_filter::<InternalBalanceChanged>()
+        }
+
+        ///Creates a new event filter for the [`PausedStateChanged`] event.
+        pub fn PausedStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PausedStateChanged, N> {
+            self.event_filter::<PausedStateChanged>()
+        }
+
+        ///Creates a new event filter for the [`PoolBalanceChanged`] event.
+        pub fn PoolBalanceChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PoolBalanceChanged, N> {
+            self.event_filter::<PoolBalanceChanged>()
+        }
+
+        ///Creates a new event filter for the [`PoolBalanceManaged`] event.
+        pub fn PoolBalanceManaged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PoolBalanceManaged, N> {
+            self.event_filter::<PoolBalanceManaged>()
+        }
+
+        ///Creates a new event filter for the [`PoolRegistered`] event.
+        pub fn PoolRegistered_filter(&self) -> alloy_contract::Event<&P, PoolRegistered, N> {
+            self.event_filter::<PoolRegistered>()
+        }
+
+        ///Creates a new event filter for the [`RelayerApprovalChanged`] event.
+        pub fn RelayerApprovalChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, RelayerApprovalChanged, N> {
+            self.event_filter::<RelayerApprovalChanged>()
+        }
+
+        ///Creates a new event filter for the [`Swap`] event.
+        pub fn Swap_filter(&self) -> alloy_contract::Event<&P, Swap, N> {
+            self.event_filter::<Swap>()
+        }
+
+        ///Creates a new event filter for the [`TokensDeregistered`] event.
+        pub fn TokensDeregistered_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, TokensDeregistered, N> {
+            self.event_filter::<TokensDeregistered>()
+        }
+
+        ///Creates a new event filter for the [`TokensRegistered`] event.
+        pub fn TokensRegistered_filter(&self) -> alloy_contract::Event<&P, TokensRegistered, N> {
+            self.event_filter::<TokensRegistered>()
+        }
+    }
+}
+pub type Instance = BalancerV2Vault::BalancerV2VaultInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(12272146u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(7003431u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(22691002u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(24821598u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(15832990u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(1196036u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(222832u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(26386141u64),
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(34313901u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
+            Some(3418831u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpool/Cargo.toml b/contracts/generated/contracts-generated/balancerv2weightedpool/Cargo.toml
new file mode 100644
index 0000000000..b1f3d89221
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpool/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2weightedpool"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs
new file mode 100644
index 0000000000..634e27e0e7
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs
@@ -0,0 +1,9215 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IPoolSwapStructs {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapRequest {
+        #[allow(missing_docs)]
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            IVault::SwapKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapRequest) -> Self {
+                (
+                    value.kind,
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.amount,
+                    value.poolId,
+                    value.lastChangeBlock,
+                    value.from,
+                    value.to,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    kind: tuple.0,
+                    tokenIn: tuple.1,
+                    tokenOut: tuple.2,
+                    amount: tuple.3,
+                    poolId: tuple.4,
+                    lastChangeBlock: tuple.5,
+                    from: tuple.6,
+                    to: tuple.7,
+                    userData: tuple.8,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapRequest {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapRequest {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapRequest {
+            const NAME: &'static str = "SwapRequest";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
+                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
+                     userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.lastChangeBlock,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.from,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.to,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapRequest {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.lastChangeBlock,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.from,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.to,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.lastChangeBlock,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.from,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.to,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IPoolSwapStructsInstance<P, N> {
+        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IPoolSwapStructs`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IPoolSwapStructs`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IPoolSwapStructsInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
+
+        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
+            IPoolSwapStructsInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPoolSwapStructsInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    type SwapKind is uint8;
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapKind(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SwapKind {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SwapKind {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SwapKind> for u8 {
+            fn from(value: SwapKind) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapKind {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapKind {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IPoolSwapStructs {
+    struct SwapRequest {
+        IVault.SwapKind kind;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        bytes32 poolId;
+        uint256 lastChangeBlock;
+        address from;
+        address to;
+        bytes userData;
+    }
+}
+
+library IVault {
+    type SwapKind is uint8;
+}
+
+interface BalancerV2WeightedPool {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external pure returns (uint8);
+    function decreaseApproval(address spender, uint256 amount) external returns (bool);
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getInvariant() external view returns (uint256);
+    function getLastInvariant() external view returns (uint256);
+    function getNormalizedWeights() external view returns (uint256[] memory);
+    function getOwner() external view returns (address);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getRate() external view returns (uint256);
+    function getSwapFeePercentage() external view returns (uint256);
+    function getVault() external view returns (address);
+    function increaseApproval(address spender, uint256 amount) external returns (bool);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
+    function setPaused(bool paused) external;
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "normalizedWeights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "decreaseApproval",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getInvariant",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getLastInvariant",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getNormalizedWeights",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRate",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapFeePercentage",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "increaseApproval",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onExitPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onJoinPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onSwap",
+    "inputs": [
+      {
+        "name": "request",
+        "type": "tuple",
+        "internalType": "struct IPoolSwapStructs.SwapRequest",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "lastChangeBlock",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "from",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "balanceTokenIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "balanceTokenOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "queryExit",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "queryJoin",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolSwapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bptOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setPaused",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setSwapFeePercentage",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2WeightedPool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub normalizedWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.normalizedWeights,
+                        value.swapFeePercentage,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        name: tuple.1,
+                        symbol: tuple.2,
+                        tokens: tuple.3,
+                        normalizedWeights: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        pauseWindowDuration: tuple.6,
+                        bufferPeriodDuration: tuple.7,
+                        owner: tuple.8,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external pure returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseApproval(address,uint256)` and selector `0x66188463`.
+    ```solidity
+    function decreaseApproval(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseApprovalCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseApproval(address,uint256)`](decreaseApprovalCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseApprovalReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseApprovalCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseApprovalCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseApprovalCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseApprovalReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseApprovalReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseApprovalReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseApprovalCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 24u8, 132u8, 99u8];
+            const SIGNATURE: &'static str = "decreaseApproval(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseApprovalReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseApprovalReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getInvariant()` and selector `0xc0ff1a15`.
+    ```solidity
+    function getInvariant() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getInvariantCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getInvariant()`](getInvariantCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getInvariantReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getInvariantCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getInvariantCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getInvariantReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getInvariantReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getInvariantCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [192u8, 255u8, 26u8, 21u8];
+            const SIGNATURE: &'static str = "getInvariant()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getInvariantReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getInvariantReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getLastInvariant()` and selector `0x9b02cdde`.
+    ```solidity
+    function getLastInvariant() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLastInvariantCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getLastInvariant()`](getLastInvariantCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLastInvariantReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLastInvariantCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLastInvariantCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLastInvariantReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLastInvariantReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLastInvariantCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [155u8, 2u8, 205u8, 222u8];
+            const SIGNATURE: &'static str = "getLastInvariant()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getLastInvariantReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getLastInvariantReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getNormalizedWeights()` and selector `0xf89f27ed`.
+    ```solidity
+    function getNormalizedWeights() external view returns (uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNormalizedWeightsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getNormalizedWeights()`](getNormalizedWeightsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getNormalizedWeightsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNormalizedWeightsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getNormalizedWeightsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getNormalizedWeightsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 159u8, 39u8, 237u8];
+            const SIGNATURE: &'static str = "getNormalizedWeights()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getNormalizedWeightsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getNormalizedWeightsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOwner()` and selector `0x893d20e8`.
+    ```solidity
+    function getOwner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOwner()`](getOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOwnerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
+            const SIGNATURE: &'static str = "getOwner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOwnerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOwnerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    ```solidity
+    function getPoolId() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolId()`](getPoolIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRate()` and selector `0x679aefce`.
+    ```solidity
+    function getRate() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRate()`](getRateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRateReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRateReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRateCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
+            const SIGNATURE: &'static str = "getRate()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRateReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRateReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    ```solidity
+    function getSwapFeePercentage() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseApproval(address,uint256)` and selector `0xd73dd623`.
+    ```solidity
+    function increaseApproval(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseApprovalCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseApproval(address,uint256)`](increaseApprovalCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseApprovalReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseApprovalCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseApprovalCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseApprovalCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseApprovalReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseApprovalReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseApprovalReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseApprovalCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [215u8, 61u8, 214u8, 35u8];
+            const SIGNATURE: &'static str = "increaseApproval(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseApprovalReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseApprovalReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    ```solidity
+    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onExitPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onExitPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onExitPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onExitPoolReturn {
+            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onExitPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onExitPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
+            const SIGNATURE: &'static str =
+                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onExitPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    ```solidity
+    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](onJoinPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onJoinPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onJoinPoolReturn) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl onJoinPoolReturn {
+            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onJoinPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = onJoinPoolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
+            const SIGNATURE: &'static str =
+                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                onJoinPoolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256,uint256)` and selector `0x9d2c110c`.
+    ```solidity
+    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwapCall {
+        #[allow(missing_docs)]
+        pub request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
+    /// bytes),uint256,uint256)`](onSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onSwapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwapCall) -> Self {
+                    (value.request, value.balanceTokenIn, value.balanceTokenOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        request: tuple.0,
+                        balanceTokenIn: tuple.1,
+                        balanceTokenOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onSwapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onSwapCall {
+            type Parameters<'a> = (
+                IPoolSwapStructs::SwapRequest,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [157u8, 44u8, 17u8, 12u8];
+            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
+                                             uint256,address,address,bytes),uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
+                        &self.request,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.balanceTokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.balanceTokenOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onSwapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onSwapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    ```solidity
+    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryExitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryExitReturn {
+        #[allow(missing_docs)]
+        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryExitReturn) -> Self {
+                    (value.bptIn, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptIn: tuple.0,
+                        amountsOut: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryExitReturn {
+            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryExitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryExitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
+            const SIGNATURE: &'static str =
+                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryExitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    ```solidity
+    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinCall {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
+    /// bytes)`](queryJoinCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct queryJoinReturn {
+        #[allow(missing_docs)]
+        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinCall) -> Self {
+                    (
+                        value.poolId,
+                        value.sender,
+                        value.recipient,
+                        value.balances,
+                        value.lastChangeBlock,
+                        value.protocolSwapFeePercentage,
+                        value.userData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        poolId: tuple.0,
+                        sender: tuple.1,
+                        recipient: tuple.2,
+                        balances: tuple.3,
+                        lastChangeBlock: tuple.4,
+                        protocolSwapFeePercentage: tuple.5,
+                        userData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: queryJoinReturn) -> Self {
+                    (value.bptOut, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        bptOut: tuple.0,
+                        amountsIn: tuple.1,
+                    }
+                }
+            }
+        }
+        impl queryJoinReturn {
+            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for queryJoinCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = queryJoinReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
+            const SIGNATURE: &'static str =
+                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolSwapFeePercentage,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                queryJoinReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    ```solidity
+    function setPaused(bool paused) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedCall {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setPaused(bool)`](setPausedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPausedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedCall) -> Self {
+                    (value.paused,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { paused: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPausedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setPausedReturn {
+            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setPausedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Return = setPausedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
+            const SIGNATURE: &'static str = "setPaused(bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setPausedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    ```solidity
+    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageCall {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeePercentageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageCall) -> Self {
+                    (value.swapFeePercentage,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swapFeePercentage: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeePercentageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapFeePercentageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = setSwapFeePercentageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
+            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapFeePercentageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2WeightedPool`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2WeightedPoolCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        decreaseApproval(decreaseApprovalCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getInvariant(getInvariantCall),
+        #[allow(missing_docs)]
+        getLastInvariant(getLastInvariantCall),
+        #[allow(missing_docs)]
+        getNormalizedWeights(getNormalizedWeightsCall),
+        #[allow(missing_docs)]
+        getOwner(getOwnerCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPoolId(getPoolIdCall),
+        #[allow(missing_docs)]
+        getRate(getRateCall),
+        #[allow(missing_docs)]
+        getSwapFeePercentage(getSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        increaseApproval(increaseApprovalCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        onExitPool(onExitPoolCall),
+        #[allow(missing_docs)]
+        onJoinPool(onJoinPoolCall),
+        #[allow(missing_docs)]
+        onSwap(onSwapCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        queryExit(queryExitCall),
+        #[allow(missing_docs)]
+        queryJoin(queryJoinCall),
+        #[allow(missing_docs)]
+        setPaused(setPausedCall),
+        #[allow(missing_docs)]
+        setSwapFeePercentage(setSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl BalancerV2WeightedPoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [22u8, 195u8, 139u8, 60u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [56u8, 233u8, 146u8, 46u8],
+            [56u8, 255u8, 242u8, 208u8],
+            [85u8, 198u8, 118u8, 40u8],
+            [96u8, 40u8, 191u8, 212u8],
+            [102u8, 24u8, 132u8, 99u8],
+            [103u8, 154u8, 239u8, 206u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 243u8, 176u8, 9u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [135u8, 236u8, 104u8, 23u8],
+            [137u8, 61u8, 32u8, 232u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [155u8, 2u8, 205u8, 222u8],
+            [157u8, 44u8, 17u8, 12u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [170u8, 171u8, 173u8, 197u8],
+            [192u8, 255u8, 26u8, 21u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [213u8, 192u8, 150u8, 196u8],
+            [215u8, 61u8, 214u8, 35u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [248u8, 159u8, 39u8, 237u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getLastInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(setPaused),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(setSwapFeePercentage),
+            ::core::stringify!(getPoolId),
+            ::core::stringify!(getSwapFeePercentage),
+            ::core::stringify!(queryExit),
+            ::core::stringify!(decreaseApproval),
+            ::core::stringify!(getRate),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(onExitPool),
+            ::core::stringify!(nonces),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(queryJoin),
+            ::core::stringify!(getOwner),
+            ::core::stringify!(getVault),
+            ::core::stringify!(symbol),
+            ::core::stringify!(getLastInvariant),
+            ::core::stringify!(onSwap),
+            ::core::stringify!(transfer),
+            ::core::stringify!(getAuthorizer),
+            ::core::stringify!(getInvariant),
+            ::core::stringify!(permit),
+            ::core::stringify!(onJoinPool),
+            ::core::stringify!(increaseApproval),
+            ::core::stringify!(allowance),
+            ::core::stringify!(getNormalizedWeights),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolCalls {
+        const COUNT: usize = 32usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseApproval(_) => {
+                    <decreaseApprovalCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getInvariant(_) => <getInvariantCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getLastInvariant(_) => {
+                    <getLastInvariantCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getNormalizedWeights(_) => {
+                    <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getSwapFeePercentage(_) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::increaseApproval(_) => {
+                    <increaseApprovalCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::onSwap(_) => <onSwapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setSwapFeePercentage(_) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn decreaseApproval(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::decreaseApproval)
+                    }
+                    decreaseApproval
+                },
+                {
+                    fn getRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn getLastInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getLastInvariant)
+                    }
+                    getLastInvariant
+                },
+                {
+                    fn onSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::onSwap)
+                    }
+                    onSwap
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn getInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getInvariant)
+                    }
+                    getInvariant
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn increaseApproval(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <increaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::increaseApproval)
+                    }
+                    increaseApproval
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn getNormalizedWeights(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getNormalizedWeights)
+                    }
+                    getNormalizedWeights
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolCalls,
+            >] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn setPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::setPaused)
+                    }
+                    setPaused
+                },
+                {
+                    fn totalSupply(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn getPausedState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::getPausedState)
+                    }
+                    getPausedState
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn setSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2WeightedPoolCalls::setSwapFeePercentage)
+                    }
+                    setSwapFeePercentage
+                },
+                {
+                    fn getPoolId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::getPoolId)
+                    }
+                    getPoolId
+                },
+                {
+                    fn getSwapFeePercentage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2WeightedPoolCalls::getSwapFeePercentage)
+                    }
+                    getSwapFeePercentage
+                },
+                {
+                    fn queryExit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::queryExit)
+                    }
+                    queryExit
+                },
+                {
+                    fn decreaseApproval(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::decreaseApproval)
+                    }
+                    decreaseApproval
+                },
+                {
+                    fn getRate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::getRate)
+                    }
+                    getRate
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn onExitPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::onExitPool)
+                    }
+                    onExitPool
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn queryJoin(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::queryJoin)
+                    }
+                    queryJoin
+                },
+                {
+                    fn getOwner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::getOwner)
+                    }
+                    getOwner
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn getLastInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::getLastInvariant)
+                    }
+                    getLastInvariant
+                },
+                {
+                    fn onSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::onSwap)
+                    }
+                    onSwap
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+                {
+                    fn getInvariant(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::getInvariant)
+                    }
+                    getInvariant
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn onJoinPool(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::onJoinPool)
+                    }
+                    onJoinPool
+                },
+                {
+                    fn increaseApproval(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <increaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolCalls::increaseApproval)
+                    }
+                    increaseApproval
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn getNormalizedWeights(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2WeightedPoolCalls::getNormalizedWeights)
+                    }
+                    getNormalizedWeights
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseApproval(inner) => {
+                    <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getInvariant(inner) => {
+                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getLastInvariant(inner) => {
+                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getNormalizedWeights(inner) => {
+                    <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseApproval(inner) => {
+                    <increaseApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onSwap(inner) => {
+                    <onSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decreaseApproval(inner) => {
+                    <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getInvariant(inner) => {
+                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getLastInvariant(inner) => {
+                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getNormalizedWeights(inner) => {
+                    <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getOwner(inner) => {
+                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getRate(inner) => {
+                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::increaseApproval(inner) => {
+                    <increaseApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onExitPool(inner) => {
+                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onJoinPool(inner) => {
+                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onSwap(inner) => {
+                    <onSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryExit(inner) => {
+                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::queryJoin(inner) => {
+                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setPaused(inner) => {
+                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setSwapFeePercentage(inner) => {
+                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2WeightedPool`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2WeightedPoolEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        PausedStateChanged(PausedStateChanged),
+        #[allow(missing_docs)]
+        SwapFeePercentageChanged(SwapFeePercentageChanged),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl BalancerV2WeightedPoolEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+            ],
+            [
+                169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8, 118u8,
+                249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(Approval),
+            ::core::stringify!(PausedStateChanged),
+            ::core::stringify!(SwapFeePercentageChanged),
+            ::core::stringify!(Transfer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2WeightedPoolEvents {
+        const COUNT: usize = 4usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<PausedStateChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PausedStateChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PausedStateChanged)
+                }
+                Some(<SwapFeePercentageChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SwapFeePercentageChanged as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::SwapFeePercentageChanged)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2WeightedPoolEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PausedStateChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SwapFeePercentageChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPool`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2WeightedPoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2WeightedPoolInstance<P, N> {
+        BalancerV2WeightedPoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2WeightedPool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2WeightedPool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2WeightedPoolInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2WeightedPoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2WeightedPoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPool`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2WeightedPoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2WeightedPoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2WeightedPoolInstance<P, N> {
+            BalancerV2WeightedPoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`decreaseApproval`] function.
+        pub fn decreaseApproval(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseApprovalCall, N> {
+            self.call_builder(&decreaseApprovalCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getInvariant`] function.
+        pub fn getInvariant(&self) -> alloy_contract::SolCallBuilder<&P, getInvariantCall, N> {
+            self.call_builder(&getInvariantCall)
+        }
+
+        ///Creates a new call builder for the [`getLastInvariant`] function.
+        pub fn getLastInvariant(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getLastInvariantCall, N> {
+            self.call_builder(&getLastInvariantCall)
+        }
+
+        ///Creates a new call builder for the [`getNormalizedWeights`]
+        /// function.
+        pub fn getNormalizedWeights(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getNormalizedWeightsCall, N> {
+            self.call_builder(&getNormalizedWeightsCall)
+        }
+
+        ///Creates a new call builder for the [`getOwner`] function.
+        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
+            self.call_builder(&getOwnerCall)
+        }
+
+        ///Creates a new call builder for the [`getPausedState`] function.
+        pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
+            self.call_builder(&getPausedStateCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolId`] function.
+        pub fn getPoolId(&self) -> alloy_contract::SolCallBuilder<&P, getPoolIdCall, N> {
+            self.call_builder(&getPoolIdCall)
+        }
+
+        ///Creates a new call builder for the [`getRate`] function.
+        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
+            self.call_builder(&getRateCall)
+        }
+
+        ///Creates a new call builder for the [`getSwapFeePercentage`]
+        /// function.
+        pub fn getSwapFeePercentage(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getSwapFeePercentageCall, N> {
+            self.call_builder(&getSwapFeePercentageCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`increaseApproval`] function.
+        pub fn increaseApproval(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseApprovalCall, N> {
+            self.call_builder(&increaseApprovalCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`onExitPool`] function.
+        pub fn onExitPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
+            self.call_builder(&onExitPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onJoinPool`] function.
+        pub fn onJoinPool(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
+            self.call_builder(&onJoinPoolCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`onSwap`] function.
+        pub fn onSwap(
+            &self,
+            request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+            balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+            balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, onSwapCall, N> {
+            self.call_builder(&onSwapCall {
+                request,
+                balanceTokenIn,
+                balanceTokenOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryExit`] function.
+        pub fn queryExit(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
+            self.call_builder(&queryExitCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`queryJoin`] function.
+        pub fn queryJoin(
+            &self,
+            poolId: alloy_sol_types::private::FixedBytes<32>,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            balances: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
+            self.call_builder(&queryJoinCall {
+                poolId,
+                sender,
+                recipient,
+                balances,
+                lastChangeBlock,
+                protocolSwapFeePercentage,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`setPaused`] function.
+        pub fn setPaused(
+            &self,
+            paused: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
+            self.call_builder(&setPausedCall { paused })
+        }
+
+        ///Creates a new call builder for the [`setSwapFeePercentage`]
+        /// function.
+        pub fn setSwapFeePercentage(
+            &self,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
+            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`PausedStateChanged`] event.
+        pub fn PausedStateChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PausedStateChanged, N> {
+            self.event_filter::<PausedStateChanged>()
+        }
+
+        ///Creates a new event filter for the [`SwapFeePercentageChanged`]
+        /// event.
+        pub fn SwapFeePercentageChanged_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SwapFeePercentageChanged, N> {
+            self.event_filter::<SwapFeePercentageChanged>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2WeightedPool::BalancerV2WeightedPoolInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/Cargo.toml b/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/Cargo.toml
new file mode 100644
index 0000000000..464db67155
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2weightedpool2tokensfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs
new file mode 100644
index 0000000000..a5724c48d5
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs
@@ -0,0 +1,1641 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2WeightedPool2TokensFactory {
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, bool oracleEnabled, address owner) external returns (address);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getVault() external view returns (address);
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "weights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "oracleEnabled",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2WeightedPool2TokensFactory {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xC0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa_\xE18\x03\x80a_\xE1\x839\x81\x01`@\x81\x90Ra\0/\x91a\0MV[``\x1B`\x01`\x01``\x1B\x03\x19\x16`\x80Rbv\xA7\0B\x01`\xA0Ra\0{V[`\0` \x82\x84\x03\x12\x15a\0^W\x80\x81\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0tW\x81\x82\xFD[\x93\x92PPPV[`\x80Q``\x1C`\xA0Qa_;a\0\xA6`\09\x80a\x02!R\x80a\x02KRP\x80a\x02\xA7RPa_;`\0\xF3\xFE`\x80`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`\x046\x10b\0\0RW`\x005`\xE0\x1C\x80c\x15\x96\x01\x9B\x14b\0\0WW\x80c-\xA4|@\x14b\0\0\x86W\x80cf4\xB7S\x14b\0\0\xA0W\x80c\x8D\x92\x8A\xF8\x14b\0\0\xC6W[`\0\x80\xFD[b\0\0nb\0\0h6`\x04b\0\x05HV[b\0\0\xD0V[`@Qb\0\0}\x91\x90b\0\x06\x8FV[`@Q\x80\x91\x03\x90\xF3[b\0\0\x90b\0\x02\x1BV[`@Qb\0\0}\x92\x91\x90b\0\x07\xA2V[b\0\0\xB7b\0\0\xB16`\x04b\0\x05\"V[b\0\x02\x87V[`@Qb\0\0}\x91\x90b\0\x06\xA3V[b\0\0nb\0\x02\xA5V[`\0\x80`\0b\0\0\xDFb\0\x02\x1BV[\x91P\x91Pb\0\0\xEDb\0\x03\x15V[`@Q\x80a\x01\x80\x01`@R\x80b\0\x01\x03b\0\x02\xA5V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8C\x81R` \x01\x8B\x81R` \x01\x8A`\0\x81Q\x81\x10b\0\x01+W\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A`\x01\x81Q\x81\x10b\0\x01OW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`\0\x81Q\x81\x10b\0\x01sW\xFE[` \x02` \x01\x01Q\x81R` \x01\x89`\x01\x81Q\x81\x10b\0\x01\x8EW\xFE[` \x02` \x01\x01Q\x81R` \x01\x88\x81R` \x01\x84\x81R` \x01\x83\x81R` \x01\x87\x15\x15\x81R` \x01\x86`\x01`\x01`\xA0\x1B\x03\x16\x81RP\x90P`\0\x81`@Qb\0\x01\xD5\x90b\0\x03\x9CV[b\0\x01\xE1\x91\x90b\0\x06\xAEV[`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15b\0\x01\xFEW=`\0\x80>=`\0\xFD[P\x90Pb\0\x02\x0C\x81b\0\x02\xC9V[\x9B\x9APPPPPPPPPPPV[`\0\x80B\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x10\x15b\0\x02yW\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x03\x92Pb'\x8D\0\x91Pb\0\x02\x82V[`\0\x92P`\0\x91P[P\x90\x91V[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R` \x81\x90R`@\x90 T`\xFF\x16\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R` \x81\x90R`@\x80\x82 \x80T`\xFF\x19\x16`\x01\x17\x90UQ\x7F\x83\xA4\x8F\xBC\xFC\x99\x1351Nt\xD0Ij\xABj\x19\x87\xE9\x92\xDD\xC8]\xDD\xBC\xC4\xD6\xDDn\xF2\xE9\xFC\x91\x90\xA2PV[`@Q\x80a\x01\x80\x01`@R\x80`\0`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01``\x81R` \x01``\x81R` \x01`\0`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01`\0`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x15\x15\x81R` \x01`\0`\x01`\x01`\xA0\x1B\x03\x16\x81RP\x90V[aV\xF3\x80b\0\x08\x13\x839\x01\x90V[\x805b\0\x03\xB7\x81b\0\x07\xF9V[\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12b\0\x03\xCEW\x80\x81\xFD[\x815b\0\x03\xE5b\0\x03\xDF\x82b\0\x07\xD8V[b\0\x07\xB0V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15b\0\x04\x07W`\0\x80\xFD[`\0[\x84\x81\x10\x15b\0\x043W\x815b\0\x04 \x81b\0\x07\xF9V[\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01b\0\x04\nV[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12b\0\x04OW\x80\x81\xFD[\x815b\0\x04`b\0\x03\xDF\x82b\0\x07\xD8V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15b\0\x04\x82W`\0\x80\xFD[`\0[\x84\x81\x10\x15b\0\x043W\x815\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01b\0\x04\x85V[\x805\x80\x15\x15\x81\x14b\0\x03\xB7W`\0\x80\xFD[`\0\x82`\x1F\x83\x01\x12b\0\x04\xC5W\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15b\0\x04\xDCW\x81\x82\xFD[b\0\x04\xF1`\x1F\x82\x01`\x1F\x19\x16` \x01b\0\x07\xB0V[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15b\0\x05\tW`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[`\0` \x82\x84\x03\x12\x15b\0\x054W\x80\x81\xFD[\x815b\0\x05A\x81b\0\x07\xF9V[\x93\x92PPPV[`\0\x80`\0\x80`\0\x80`\0`\xE0\x88\x8A\x03\x12\x15b\0\x05cW\x82\x83\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15b\0\x05{W\x84\x85\xFD[b\0\x05\x89\x8B\x83\x8C\x01b\0\x04\xB4V[\x98P` \x8A\x015\x91P\x80\x82\x11\x15b\0\x05\x9FW\x84\x85\xFD[b\0\x05\xAD\x8B\x83\x8C\x01b\0\x04\xB4V[\x97P`@\x8A\x015\x91P\x80\x82\x11\x15b\0\x05\xC3W\x84\x85\xFD[b\0\x05\xD1\x8B\x83\x8C\x01b\0\x03\xBDV[\x96P``\x8A\x015\x91P\x80\x82\x11\x15b\0\x05\xE7W\x84\x85\xFD[Pb\0\x05\xF6\x8A\x82\x8B\x01b\0\x04>V[\x94PP`\x80\x88\x015\x92Pb\0\x06\x0F\x89`\xA0\x8A\x01b\0\x04\xA3V[\x91Pb\0\x06 \x89`\xC0\x8A\x01b\0\x03\xAAV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[`\x01`\x01`\xA0\x1B\x03\x16\x90RV[\x15\x15\x90RV[`\0\x81Q\x80\x84R\x81[\x81\x81\x10\x15b\0\x06hW` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01b\0\x06JV[\x81\x81\x11\x15b\0\x06zW\x82` \x83\x87\x01\x01R[P`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[\x90\x15\x15\x81R` \x01\x90V[`\0` \x82Rb\0\x06\xC4` \x83\x01\x84Qb\0\x06.V[` \x83\x01Qa\x01\x80\x80`@\x85\x01Rb\0\x06\xE2a\x01\xA0\x85\x01\x83b\0\x06AV[\x91P`@\x85\x01Q`\x1F\x19\x85\x84\x03\x01``\x86\x01Rb\0\x07\x01\x83\x82b\0\x06AV[\x92PP``\x85\x01Qb\0\x07\x18`\x80\x86\x01\x82b\0\x06.V[P`\x80\x85\x01Qb\0\x07-`\xA0\x86\x01\x82b\0\x06.V[P`\xA0\x85\x01Q`\xC0\x85\x01R`\xC0\x85\x01Q`\xE0\x85\x01R`\xE0\x85\x01Qa\x01\0\x81\x81\x87\x01R\x80\x87\x01Q\x91PPa\x01 \x81\x81\x87\x01R\x80\x87\x01Q\x91PPa\x01@\x81\x81\x87\x01R\x80\x87\x01Q\x91PPa\x01`b\0\x07\x85\x81\x87\x01\x83b\0\x06;V[\x86\x01Q\x90Pb\0\x07\x98\x85\x83\x01\x82b\0\x06.V[P\x90\x94\x93PPPPV[\x91\x82R` \x82\x01R`@\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15b\0\x07\xD0W`\0\x80\xFD[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15b\0\x07\xEFW\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x08\x0FW`\0\x80\xFD[PV\xFEa\x02\xA0`@R\x7Fnq\xED\xAE\x12\xB1\xB9\x7FM\x1F`7\x0F\xEF\x10\x10_\xA2\xFA\xAE\x01&\x11J\x16\x9Cd\x84]a&\xC9a\x01 R4\x80\x15b\0\x007W`\0\x80\xFD[P`@Qb\0V\xF38\x03\x80b\0V\xF3\x839\x81\x01`@\x81\x90Rb\0\0Z\x91b\0\x08\x0CV[a\x01\0\x81\x81\x01Qa\x01 \x83\x01Q` \x80\x85\x01Q`@\x80\x87\x01Q\x81Q\x80\x83\x01\x90\x92R`\x01\x82R`1`\xF8\x1B\x82\x85\x01\x90\x81Ra\x01`\x89\x01Q3`\x80R``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0R\x83Q\x94\x84\x01\x94\x85 `\xC0R\x91Q\x90\x91 `\xE0R\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F\x90\x95R\x80Q\x93\x94\x92\x93\x90\x92\x91b\0\0\xF3\x91`\x03\x91\x90b\0\x06\x9FV[P\x80Qb\0\x01\t\x90`\x04\x90` \x84\x01\x90b\0\x06\x9FV[Pb\0\x01!\x91PPbv\xA7\0\x83\x11\x15a\x01\x94b\0\x04\nV[b\0\x015b'\x8D\0\x82\x11\x15a\x01\x95b\0\x04\nV[B\x90\x91\x01a\x01@\x81\x81R\x91\x01a\x01`R\x81\x01Qb\0\x01S\x90b\0\x04\x1FV[`\xE0\x81\x01Qb\0\x01c\x90b\0\x04{V[\x80Q`@Qc\t\xB2v\x0F`\xE0\x1B\x81R`\0\x91`\x01`\x01`\xA0\x1B\x03\x16\x90c\t\xB2v\x0F\x90b\0\x01\x96\x90`\x02\x90`\x04\x01b\0\n\x12V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15b\0\x01\xB1W`\0\x80\xFD[PZ\xF1\x15\x80\x15b\0\x01\xC6W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90b\0\x01\xEC\x91\x90b\0\x07\xF3V[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x93\x94P\x90\x91` \x83\x01\x90\x806\x837\x01\x90PP\x90P\x82``\x01Q\x81`\0\x81Q\x81\x10b\0\x02#W\xFE[` \x02` \x01\x01\x90`\x01`\x01`\xA0\x1B\x03\x16\x90\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP\x82`\x80\x01Q\x81`\x01\x81Q\x81\x10b\0\x02VW\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R\x83Q\x16cf\xA9\xC7\xD2\x83\x83`\x02`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15b\0\x02\xA2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01b\0\x02\xC3\x93\x92\x91\x90b\0\tvV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15b\0\x02\xDEW`\0\x80\xFD[PZ\xF1\x15\x80\x15b\0\x02\xF3W=`\0\x80>=`\0\xFD[PP\x84Q`\x01`\x01``\x1B\x03\x19``\x91\x82\x1B\x81\x16a\x01\x80Ra\x01\xA0\x86\x90R\x81\x87\x01\x80Q\x83\x1B\x82\x16a\x01\xC0R`\x80\x88\x01Q\x90\x92\x1B\x16a\x01\xE0RQb\0\x03:\x92P\x90Pb\0\x04\xF9V[a\x02`R`\x80\x83\x01Qb\0\x03N\x90b\0\x04\xF9V[a\x02\x80R`\xA0\x83\x01Qb\0\x03o\x90f#\x86\xF2o\xC1\0\0\x11\x15a\x01.b\0\x04\nV[b\0\x03\x91f#\x86\xF2o\xC1\0\0\x84`\xC0\x01Q\x10\x15a\x01.b\0\x04\n` \x1B` \x1CV[`\0b\0\x03\xB5\x84`\xC0\x01Q\x85`\xA0\x01Qb\0\x05\x9B` \x1Bb\0\x11\xC6\x17\x90\x91\x90` \x1CV[\x90Pb\0\x03\xCFg\r\xE0\xB6\xB3\xA7d\0\0\x82\x14a\x014b\0\x04\nV[`\xA0\x84\x01\x80Qa\x02\0R`\xC0\x85\x01\x80Qa\x02 RQ\x90Q\x10\x15b\0\x03\xF5W`\x01b\0\x03\xF8V[`\0[`\xFF\x16a\x02@RPb\0\nc\x92PPPV[\x81b\0\x04\x1BWb\0\x04\x1B\x81b\0\x05\xB8V[PPV[b\0\x04;\x81`\x08Tb\0\x06\x0B` \x1Bb\0\x11\xD8\x17\x90\x91\x90` \x1CV[`\x08U`@Q\x7F>5\x0BA\xE8j\x8E\x10\xF8\x04\xAD\xE6\xD3S@\xD6 \xBE5V\x9C\xC7Z\xC9C\xE8\xBB\x14\xAB\x80\xEA\xD1\x90b\0\x04p\x90\x83\x90b\0\tkV[`@Q\x80\x91\x03\x90\xA1PV[b\0\x04\x90d\xE8\xD4\xA5\x10\0\x82\x10\x15`\xCBb\0\x04\nV[b\0\x04\xA8g\x01cEx]\x8A\0\0\x82\x11\x15`\xCAb\0\x04\nV[b\0\x04\xC4\x81`\x08Tb\0\x06*` \x1Bb\0\x11\xE6\x17\x90\x91\x90` \x1CV[`\x08U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90b\0\x04p\x90\x83\x90b\0\n'V[`\0\x80\x82`\x01`\x01`\xA0\x1B\x03\x16c1<\xE5g`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15b\0\x056W`\0\x80\xFD[PZ\xFA\x15\x80\x15b\0\x05KW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90b\0\x05q\x91\x90b\0\tHV[`\xFF\x16\x90P`\0b\0\x05\x90`\x12\x83b\0\x06I` \x1Bb\0\x11\xF4\x17` \x1CV[`\n\n\x94\x93PPPPV[`\0\x82\x82\x01b\0\x05\xAF\x84\x82\x10\x15\x83b\0\x04\nV[\x90P[\x92\x91PPV[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[`\0b\0\x05\xAF\x82`U\x85b\0\x06a` \x1Bb\0\x12\n\x17\x90\x92\x91\x90` \x1CV[`\0b\0\x05\xAF\x82`V\x85b\0\x06\x8A` \x1Bb\0\x121\x17\x90\x92\x91\x90` \x1CV[`\0b\0\x06[\x83\x83\x11\x15`\x01b\0\x04\nV[P\x90\x03\x90V[`\0`\x01\x82\x1B\x19\x84\x16\x82\x84b\0\x06yW`\0b\0\x06|V[`\x01[`\xFF\x16\x90\x1B\x17\x94\x93PPPPV[`\x01`\x01`@\x1B\x03\x81\x1B\x19\x92\x90\x92\x16\x91\x1B\x17\x90V[\x82\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x90`\0R` `\0 \x90`\x1F\x01` \x90\x04\x81\x01\x92\x82`\x1F\x10b\0\x06\xE2W\x80Q`\xFF\x19\x16\x83\x80\x01\x17\x85Ub\0\x07\x12V[\x82\x80\x01`\x01\x01\x85U\x82\x15b\0\x07\x12W\x91\x82\x01[\x82\x81\x11\x15b\0\x07\x12W\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90b\0\x06\xF5V[Pb\0\x07 \x92\x91Pb\0\x07$V[P\x90V[[\x80\x82\x11\x15b\0\x07 W`\0\x81U`\x01\x01b\0\x07%V[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x05\xB2W`\0\x80\xFD[\x80Q\x80\x15\x15\x81\x14b\0\x05\xB2W`\0\x80\xFD[`\0\x82`\x1F\x83\x01\x12b\0\x07uW\x80\x81\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15b\0\x07\x8BW\x81\x82\xFD[` b\0\x07\xA1`\x1F\x83\x01`\x1F\x19\x16\x82\x01b\0\n0V[\x92P\x81\x83R\x84\x81\x83\x86\x01\x01\x11\x15b\0\x07\xB8W`\0\x80\xFD[`\0[\x82\x81\x10\x15b\0\x07\xD8W\x84\x81\x01\x82\x01Q\x84\x82\x01\x83\x01R\x81\x01b\0\x07\xBBV[\x82\x81\x11\x15b\0\x07\xEAW`\0\x82\x84\x86\x01\x01R[PPP\x92\x91PPV[`\0` \x82\x84\x03\x12\x15b\0\x08\x05W\x80\x81\xFD[PQ\x91\x90PV[`\0` \x82\x84\x03\x12\x15b\0\x08\x1EW\x80\x81\xFD[\x81Q`\x01`\x01`@\x1B\x03\x80\x82\x11\x15b\0\x085W\x82\x83\xFD[\x81\x84\x01\x91Pa\x01\x80\x80\x83\x87\x03\x12\x15b\0\x08LW\x83\x84\xFD[b\0\x08W\x81b\0\n0V[\x90Pb\0\x08e\x86\x84b\0\x07;V[\x81R` \x83\x01Q\x82\x81\x11\x15b\0\x08yW\x84\x85\xFD[b\0\x08\x87\x87\x82\x86\x01b\0\x07dV[` \x83\x01RP`@\x83\x01Q\x82\x81\x11\x15b\0\x08\x9FW\x84\x85\xFD[b\0\x08\xAD\x87\x82\x86\x01b\0\x07dV[`@\x83\x01RPb\0\x08\xC2\x86``\x85\x01b\0\x07;V[``\x82\x01Rb\0\x08\xD6\x86`\x80\x85\x01b\0\x07;V[`\x80\x82\x01R`\xA0\x83\x81\x01Q\x90\x82\x01R`\xC0\x80\x84\x01Q\x90\x82\x01R`\xE0\x80\x84\x01Q\x90\x82\x01Ra\x01\0\x80\x84\x01Q\x90\x82\x01Ra\x01 \x80\x84\x01Q\x90\x82\x01Ra\x01@\x91Pb\0\t\"\x86\x83\x85\x01b\0\x07SV[\x82\x82\x01Ra\x01`\x91Pb\0\t9\x86\x83\x85\x01b\0\x07;V[\x91\x81\x01\x91\x90\x91R\x94\x93PPPPV[`\0` \x82\x84\x03\x12\x15b\0\tZW\x80\x81\xFD[\x81Q`\xFF\x81\x16\x81\x14b\0\x05\xAFW\x81\x82\xFD[\x90\x15\x15\x81R` \x01\x90V[`\0``\x82\x01\x85\x83R` ``\x81\x85\x01R\x81\x86Q\x80\x84R`\x80\x86\x01\x91P\x82\x88\x01\x93P\x84[\x81\x81\x10\x15b\0\t\xC2Wb\0\t\xAF\x85Qb\0\nWV[\x83R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01b\0\t\x9AV[PP\x84\x81\x03`@\x86\x01R\x85Q\x80\x82R\x90\x82\x01\x92P\x81\x86\x01\x90\x84[\x81\x81\x10\x15b\0\n\x04Wb\0\t\xF1\x83Qb\0\nWV[\x85R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01b\0\t\xDCV[P\x92\x98\x97PPPPPPPPV[` \x81\x01`\x03\x83\x10b\0\n!W\xFE[\x91\x90R\x90V[\x90\x81R` \x01\x90V[`@Q\x81\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15b\0\nOW`\0\x80\xFD[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x80Q`\xA0Q``\x1C`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa\x01\x80Q``\x1Ca\x01\xA0Qa\x01\xC0Q``\x1Ca\x01\xE0Q``\x1Ca\x02\0Qa\x02 Qa\x02@Qa\x02`Qa\x02\x80QaK\xB8b\0\x0B;`\09\x80a\x1D\x12RP\x80a\x1D9RP\x80a)\xE2R\x80a*\x16R\x80a*RRP\x80a\x1DfR\x80a\x1E\x02RP\x80a\x1D\x8DR\x80a\x1D\xE0R\x80a\x1E0RPP\x80a\x0CjRP\x80a\x08\x08RP\x80a\x0B\xB8RP\x80a\x13\x9DRP\x80a\x13yRP\x80a\x0F RP\x80a\x16\xA5RP\x80a\x16\xE7RP\x80a\x16\xC6RP\x80a\x0B\x94RP\x80a\x0B\x1FRPaK\xB8`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x02HW`\x005`\xE0\x1C\x80ct\xF3\xB0\t\x11a\x01;W\x80c\xAA\xAB\xAD\xC5\x11a\0\xB8W\x80c\xD5\xC0\x96\xC4\x11a\0|W\x80c\xD5\xC0\x96\xC4\x14a\x04\xE1W\x80c\xD7=\xD6#\x14a\x04\xF4W\x80c\xDDb\xED>\x14a\x05\x07W\x80c\xF8\x9F'\xED\x14a\x05\x1AW\x80c\xFF\xD0\x88\xEB\x14a\x05\"Wa\x02HV[\x80c\xAA\xAB\xAD\xC5\x14a\x04\xA3W\x80c\xB1\x0B\xE79\x14a\x04\xABW\x80c\xB4\x8B[@\x14a\x04\xBEW\x80c\xC0\xFF\x1A\x15\x14a\x04\xC6W\x80c\xD5\x05\xAC\xCF\x14a\x04\xCEWa\x02HV[\x80c\x8D\x92\x8A\xF8\x11a\0\xFFW\x80c\x8D\x92\x8A\xF8\x14a\x04eW\x80c\x95\xD8\x9BA\x14a\x04mW\x80c\x9B\x02\xCD\xDE\x14a\x04uW\x80c\x9D,\x11\x0C\x14a\x04}W\x80c\xA9\x05\x9C\xBB\x14a\x04\x90Wa\x02HV[\x80ct\xF3\xB0\t\x14a\x03\xF6W\x80c~\xCE\xBE\0\x14a\x04\x17W\x80c\x85\x1C\x1B\xB3\x14a\x04*W\x80c\x87\xECh\x17\x14a\x04=W\x80c\x89= \xE8\x14a\x04PWa\x02HV[\x80c8\xE9\x92.\x11a\x01\xC9W\x80c`\xD1P|\x11a\x01\x8DW\x80c`\xD1P|\x14a\x03\x82W\x80cf\x18\x84c\x14a\x03\xA8W\x80cg\x9A\xEF\xCE\x14a\x03\xBBW\x80ck\x8429\x14a\x03\xC3W\x80cp\xA0\x821\x14a\x03\xE3Wa\x02HV[\x80c8\xE9\x92.\x14a\x03$W\x80c8\xFF\xF2\xD0\x14a\x037W\x80cJk\x0B\x15\x14a\x03?W\x80cU\xC6v(\x14a\x03YW\x80c`(\xBF\xD4\x14a\x03aWa\x02HV[\x80c\x1D\xCC\xD80\x11a\x02\x10W\x80c\x1D\xCC\xD80\x14a\x02\xCCW\x80c#\xB8r\xDD\x14a\x02\xECW\x80c),\x91J\x14a\x02\xFFW\x80c1<\xE5g\x14a\x03\x07W\x80c6D\xE5\x15\x14a\x03\x1CWa\x02HV[\x80c\x06\xFD\xDE\x03\x14a\x02MW\x80c\t^\xA7\xB3\x14a\x02kW\x80c\x16\xC3\x8B<\x14a\x02\x8BW\x80c\x18\x16\r\xDD\x14a\x02\xA0W\x80c\x1C\r\xE0Q\x14a\x02\xB5W[`\0\x80\xFD[a\x02Ua\x05*V[`@Qa\x02b\x91\x90aJ\x93V[`@Q\x80\x91\x03\x90\xF3[a\x02~a\x02y6`\x04aB;V[a\x05\xC0V[`@Qa\x02b\x91\x90aIpV[a\x02\x9Ea\x02\x996`\x04aD\xA9V[a\x05\xD7V[\0[a\x02\xA8a\x05\xEBV[`@Qa\x02b\x91\x90aI\x93V[a\x02\xBDa\x05\xF1V[`@Qa\x02b\x93\x92\x91\x90aI{V[a\x02\xDFa\x02\xDA6`\x04aC\xEFV[a\x06\x1AV[`@Qa\x02b\x91\x90aI8V[a\x02~a\x02\xFA6`\x04aA\x86V[a\x07\"V[a\x02\x9Ea\x07\xA5V[a\x03\x0Fa\x07\xD9V[`@Qa\x02b\x91\x90aJ\xFFV[a\x02\xA8a\x07\xDEV[a\x02\x9Ea\x0326`\x04aHKV[a\x07\xEDV[a\x02\xA8a\x08\x06V[a\x03Ga\x08*V[`@Qa\x02b\x96\x95\x94\x93\x92\x91\x90aJiV[a\x02\xA8a\x08\x85V[a\x03ta\x03o6`\x04aD\xE1V[a\x08\x92V[`@Qa\x02b\x92\x91\x90aJ\xE6V[a\x03\x95a\x03\x906`\x04aHKV[a\x08\xC3V[`@Qa\x02b\x97\x96\x95\x94\x93\x92\x91\x90aJ9V[a\x02~a\x03\xB66`\x04aB;V[a\t\x0CV[a\x02\xA8a\tfV[a\x03\xD6a\x03\xD16`\x04aC1V[a\t\x8BV[`@Qa\x02b\x91\x90aH\xF4V[a\x02\xA8a\x03\xF16`\x04aA2V[a\n<V[a\x04\ta\x04\x046`\x04aD\xE1V[a\n[V[`@Qa\x02b\x92\x91\x90aIKV[a\x02\xA8a\x04%6`\x04aA2V[a\x0B\0V[a\x02\xA8a\x0486`\x04aE\xDDV[a\x0B\x1BV[a\x03ta\x04K6`\x04aD\xE1V[a\x0BmV[a\x04Xa\x0B\x92V[`@Qa\x02b\x91\x90aH\xE0V[a\x04Xa\x0B\xB6V[a\x02Ua\x0B\xDAV[a\x02\xA8a\x0C;V[a\x02\xA8a\x04\x8B6`\x04aGPV[a\x0CAV[a\x02~a\x04\x9E6`\x04aB;V[a\r\xF0V[a\x04Xa\r\xFDV[a\x02\xA8a\x04\xB96`\x04aG4V[a\x0E\x07V[a\x02\xA8a\x0E)V[a\x02\xA8a\x0E/V[a\x02\x9Ea\x04\xDC6`\x04aA\xC6V[a\x0E\xEBV[a\x04\ta\x04\xEF6`\x04aD\xE1V[a\x104V[a\x02~a\x05\x026`\x04aB;V[a\x11TV[a\x02\xA8a\x05\x156`\x04aANV[a\x11\x8AV[a\x02\xDFa\x11\xB5V[a\x02\xA8a\x11\xBFV[`\x03\x80T`@\x80Q` `\x1F`\x02`\0\x19a\x01\0`\x01\x88\x16\x15\x02\x01\x90\x95\x16\x94\x90\x94\x04\x93\x84\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x82\x81R``\x93\x90\x92\x90\x91\x83\x01\x82\x82\x80\x15a\x05\xB6W\x80`\x1F\x10a\x05\x8BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xB6V[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[`\0a\x05\xCD3\x84\x84a\x12FV[P`\x01[\x92\x91PPV[a\x05\xDFa\x12\xAEV[a\x05\xE8\x81a\x12\xDCV[PV[`\x02T\x90V[`\0\x80`\0a\x05\xFEa\x13ZV[\x15\x92Pa\x06\ta\x13wV[\x91Pa\x06\x13a\x13\x9BV[\x90P\x90\x91\x92V[``\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x80\x15a\x063W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06]W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0a\x06m`\x08Ta\x13\xBFV[\x90Pa\x06wa?\xFEV[`\0[\x84Q\x81\x10\x15a\x07\x1AW\x84\x81\x81Q\x81\x10a\x06\x8FW\xFE[` \x02` \x01\x01Q\x91Pa\x06\xAD\x82` \x01Q`\0\x14\x15a\x01<a\x13\xCCV[`\0a\x06\xC8\x83`\0\x01Q\x85\x85` \x01Q\x86`@\x01Q\x01a\x13\xDEV[\x90P`\0a\x06\xDF\x84`\0\x01Q\x86\x86`@\x01Qa\x13\xDEV[\x90Pa\x06\xF9\x84` \x01Q\x83\x83\x03\x81a\x06\xF3W\xFE[\x05a\x15$V[\x86\x84\x81Q\x81\x10a\x07\x05W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP`\x01\x01a\x06zV[PPP\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 3\x80\x85R\x92R\x82 T\x91\x92a\x07`\x91\x14\x80a\x07XWP\x83\x82\x10\x15[a\x01\x97a\x13\xCCV[a\x07k\x85\x85\x85a\x157V[3`\x01`\x01`\xA0\x1B\x03\x86\x16\x14\x80\x15\x90a\x07\x86WP`\0\x19\x81\x14\x15[\x15a\x07\x98Wa\x07\x98\x853\x85\x84\x03a\x12FV[`\x01\x91PP[\x93\x92PPPV[a\x07\xADa\x16\x06V[a\x07\xB5a\x12\xAEV[a\x07\xBF`\x01a\x16\x19V[`\0a\x07\xC9a\x05\xEBV[\x11\x15a\x07\xD7Wa\x07\xD7a\x16YV[V[`\x12\x90V[`\0a\x07\xE8a\x16\xA1V[\x90P\x90V[a\x07\xF5a\x12\xAEV[a\x07\xFDa\x16\x06V[a\x05\xE8\x81a\x17>V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\0\x80`\0\x80`\0\x80`\0`\x08T\x90Pa\x08C\x81a\x17\xA7V[\x96Pa\x08N\x81a\x17\xB3V[\x95Pa\x08Y\x81a\x17\xC0V[\x94Pa\x08d\x81a\x13\xBFV[\x93Pa\x08o\x81a\x17\xCDV[\x92Pa\x08z\x81a\x17\xDAV[\x91PP\x90\x91\x92\x93\x94\x95V[`\0a\x07\xE8`\x08Ta\x17\xDAV[`\0``a\x08\xA2\x86Q`\x02a\x17\xE7V[a\x08\xB7\x89\x89\x89\x89\x89\x89\x89a\x17\xF4a\x18\xAEa\x19,V[\x97P\x97\x95PPPPPPV[`\0\x80`\0\x80`\0\x80`\0a\x08\xDEa\x04\0\x89\x10a\x01;a\x13\xCCV[`\0a\x08\xE9\x89a\x1AKV[\x90Pa\x08\xF4\x81a\x1A]V[\x95\x9F\x94\x9EP\x92\x9CP\x90\x9AP\x98P\x96P\x90\x94P\x92PPPV[3`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x84R\x90\x91R\x81 T\x80\x83\x10a\tHWa\tC3\x85`\0a\x12FV[a\t\\V[a\t\\3\x85a\tW\x84\x87a\x11\xF4V[a\x12FV[P`\x01\x93\x92PPPV[`\0a\x07\xE8a\tsa\x05\xEBV[a\t\x85a\t~a\x0E/V[`\x02a\x1A\xC0V[\x90a\x1A\xE4V[``\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x80\x15a\t\xA4W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\t\xCEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0a\t\xDE`\x08Ta\x13\xBFV[\x90Pa\t\xE8a@ V[`\0[\x84Q\x81\x10\x15a\x07\x1AW\x84\x81\x81Q\x81\x10a\n\0W\xFE[` \x02` \x01\x01Q\x91Pa\n\x1D\x82`\0\x01Q\x84\x84` \x01Qa\x13\xDEV[\x84\x82\x81Q\x81\x10a\n)W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\t\xEBV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R` \x81\x90R`@\x90 T[\x91\x90PV[``\x80\x88a\n\x85a\nja\x0B\xB6V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14`\xCDa\x13\xCCV[a\n\x9Aa\n\x90a\x08\x06V[\x82\x14a\x01\xF4a\x13\xCCV[a\n\xA3\x87a\x1B5V[`\0``\x80a\n\xB7\x8D\x8D\x8D\x8D\x8D\x8D\x8Da\x17\xF4V[\x92P\x92P\x92Pa\n\xC7\x8C\x84a\x1B\x97V[a\n\xD0\x82a\x18\xAEV[a\n\xD9\x81a\x18\xAEV[a\n\xE1a\x13ZV[\x15a\n\xEEWa\n\xEEa\x16YV[\x90\x9C\x90\x9BP\x99PPPPPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x05` R`@\x90 T\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x0BP\x92\x91\x90aH\x9DV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\0``a\x0B}\x86Q`\x02a\x17\xE7V[a\x08\xB7\x89\x89\x89\x89\x89\x89\x89a\x1C*a\x1C\xABa\x19,V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\x04\x80T`@\x80Q` `\x1F`\x02`\0\x19a\x01\0`\x01\x88\x16\x15\x02\x01\x90\x95\x16\x94\x90\x94\x04\x93\x84\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x82\x81R``\x93\x90\x92\x90\x91\x83\x01\x82\x82\x80\x15a\x05\xB6W\x80`\x1F\x10a\x05\x8BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xB6V[`\tT\x90V[`\0a\x0CKa\x16\x06V[\x83`\x80\x01Qa\x0C[a\nja\x0B\xB6V[a\x0Cfa\n\x90a\x08\x06V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x86` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14\x90P`\0a\x0C\xAE\x82a\x1D\tV[\x90P`\0a\x0C\xBC\x83\x15a\x1D\tV[\x90P`\0a\x0C\xC9\x84a\x1D]V[\x90P`\0a\x0C\xD7\x85\x15a\x1D]V[\x90Pa\x0C\xE3\x89\x85a\x1D\xB1V[\x98Pa\x0C\xEF\x88\x84a\x1D\xB1V[\x97Pa\r\x18\x8A`\xA0\x01Q\x86a\r\x04W\x89a\r\x06V[\x8A[\x87a\r\x11W\x8Ba\r\x13V[\x8A[a\x1D\xBDV[`\0\x8AQ`\x01\x81\x11\x15a\r'W\xFE[\x14\x15a\r\x95W`\0a\rEa\r:a\x08\x85V[``\x8D\x01Q\x90a\x1E\xC3V[\x90Pa\rga\ra\x82\x8D``\x01Qa\x11\xF4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x86a\x1D\xB1V[``\x8C\x01R`\0a\r{\x8C\x8C\x8C\x87\x87a\x1F\x07V[\x90Pa\r\x87\x81\x86a\x1F&V[\x98PPPPPPPPa\r\xE8V[a\r\xA3\x8A``\x01Q\x84a\x1D\xB1V[``\x8B\x01R`\0a\r\xB7\x8B\x8B\x8B\x86\x86a\x1F2V[\x90Pa\r\xC3\x81\x86a\x1FEV[\x90Pa\r\xDFa\r\xD8a\r\xD3a\x08\x85V[a\x1FQV[\x82\x90a\x1FwV[\x97PPPPPPP[P\x93\x92PPPV[`\0a\x05\xCD3\x84\x84a\x157V[`\0a\x07\xE8a\x1F\xB9V[`\0\x80a\x0E\x1E\x83a\x0E\x19`\x08Ta\x13\xBFV[a 3V[\x90Pa\x07\x9E\x81a\x15$V[a\x04\0\x90V[`\0``a\x0E;a\x0B\xB6V[`\x01`\x01`\xA0\x1B\x03\x16c\xF9MFha\x0EQa\x08\x06V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Em\x91\x90aI\x93V[`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x0E\x85W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x0E\x99W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0E\xC1\x91\x90\x81\x01\x90aBfV[P\x91PPa\x0E\xCE\x81a\x1B5V[``a\x0E\xD8a jV[\x90Pa\x0E\xE4\x81\x83a \xD8V[\x92PPP\x90V[a\x0E\xF9\x84B\x11\x15`\xD1a\x13\xCCV[`\x01`\x01`\xA0\x1B\x03\x87\x16`\0\x90\x81R`\x05` \x90\x81R`@\x80\x83 T\x90Q\x90\x92\x91a\x0FP\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x8C\x91\x8C\x91\x8C\x91\x88\x91\x8D\x91\x01aI\xBBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0a\x0Fs\x82a!JV[\x90P`\0`\x01\x82\x88\x88\x88`@Q`\0\x81R` \x01`@R`@Qa\x0F\x9A\x94\x93\x92\x91\x90aJ\x1BV[` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\x0F\xBCW=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91Pa\x0F\xFE\x90P`\x01`\x01`\xA0\x1B\x03\x82\x16\x15\x80\x15\x90a\x0F\xF6WP\x8B`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14[a\x01\xF8a\x13\xCCV[`\x01`\x01`\xA0\x1B\x03\x8B\x16`\0\x90\x81R`\x05` R`@\x90 `\x01\x85\x01\x90Ua\x10'\x8B\x8B\x8Ba\x12FV[PPPPPPPPPPPV[``\x80\x88a\x10Ca\nja\x0B\xB6V[a\x10Na\n\x90a\x08\x06V[a\x10Va\x16\x06V[`\0a\x10`a\x05\xEBV[a\x10\xD0Wa\x10p\x8B\x8B\x8B\x88a!fV[\x94P\x90Pa\x10\x85b\x0FB@\x82\x10\x15`\xCCa\x13\xCCV[a\x10\x93`\0b\x0FB@a!\xEFV[a\x10\xA2\x89b\x0FB@\x83\x03a!\xEFV[a\x10\xAB\x84a\x1C\xABV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x91` \x83\x01\x90\x806\x837\x01\x90PP\x92Pa\x11>V[a\x10\xD9\x88a\x1B5V[a\x11\x0C\x87\x89`\0\x81Q\x81\x10a\x10\xEAW\xFE[` \x02` \x01\x01Q\x8A`\x01\x81Q\x81\x10a\x10\xFFW\xFE[` \x02` \x01\x01Qa\x1D\xBDV[a\x11\x1B\x8B\x8B\x8B\x8B\x8B\x8B\x8Ba\x1C*V[\x90\x95P\x93P\x90Pa\x11,\x89\x82a!\xEFV[a\x115\x84a\x1C\xABV[a\x11>\x83a\x18\xAEV[a\x11Fa\x16YV[PP\x97P\x97\x95PPPPPPV[3`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91a\x05\xCD\x91\x85\x90a\tW\x90\x86a\x11\xC6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[``a\x07\xE8a jV[b\x01\xDE \x90V[`\0\x82\x82\x01a\x07\x9E\x84\x82\x10\x15\x83a\x13\xCCV[`\0a\x07\x9E\x83\x83`Ua\x12\nV[`\0a\x07\x9E\x83\x83`Va\x121V[`\0a\x12\x04\x83\x83\x11\x15`\x01a\x13\xCCV[P\x90\x03\x90V[`\0`\x01\x82\x1B\x19\x84\x16\x82\x84a\x12 W`\0a\x12#V[`\x01[`\xFF\x16\x90\x1B\x17\x94\x93PPPPV[`\x01`\x01`@\x1B\x03\x81\x1B\x19\x92\x90\x92\x16\x91\x1B\x17\x90V[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 \x94\x87\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x84\x90UQ\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x90a\x12\xA1\x90\x85\x90aI\x93V[`@Q\x80\x91\x03\x90\xA3PPPV[`\0a\x12\xC5`\x005`\x01`\x01`\xE0\x1B\x03\x19\x16a\x0B\x1BV[\x90Pa\x05\xE8a\x12\xD4\x823a\"\x85V[a\x01\x91a\x13\xCCV[\x80\x15a\x12\xFCWa\x12\xF7a\x12\xEDa\x13wV[B\x10a\x01\x93a\x13\xCCV[a\x13\x11V[a\x13\x11a\x13\x07a\x13\x9BV[B\x10a\x01\xA9a\x13\xCCV[`\x06\x80T`\xFF\x19\x16\x82\x15\x15\x17\x90U`@Q\x7F\x9E:^7\"E2\xDE\xA6{\x89\xFA\xCE\x18W\x03s\x8A\"\x8An\x8A#\xDE\xE5F\x96\x01\x80\xD3\xBEd\x90a\x13O\x90\x83\x90aIpV[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x13da\x13\x9BV[B\x11\x80a\x07\xE8WPP`\x06T`\xFF\x16\x15\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\0a\x05\xD1\x82`Ka#uV[\x81a\x13\xDAWa\x13\xDA\x81a#}V[PPV[`\0a\x13\xEF\x82B\x10\x15a\x018a\x13\xCCV[B\x82\x90\x03`\0a\x13\xFE\x85a\x1AKV[\x90P`\0a\x14\x0B\x82a#\xD0V[\x90Pa\x14\x1C`\0\x82\x11a\x019a\x13\xCCV[\x82\x81\x11a\x14HW\x80\x83\x03\x80a\x141\x84\x8Aa#\xDCV[\x02a\x14<\x84\x8Aa$ V[\x01\x94PPPPPa\x07\x9EV[`\0a\x14S\x87a$dV[\x90P`\0a\x14`\x82a\x1AKV[\x90P`\0a\x14m\x82a#\xD0V[\x90Pa\x14~`\0\x82\x11a\x019a\x13\xCCV[a\x14\x8D\x86\x82\x11\x15a\x01:a\x13\xCCV[PP`\0\x80a\x14\x9C\x86\x84a$qV[\x91P\x91P`\0a\x14\xAB\x83a#\xD0V[a\x14\xB4\x83a#\xD0V[\x03\x90P\x80\x15a\x15\x0CW`\0a\x14\xC9\x84\x8Da$ V[a\x14\xD3\x84\x8Ea$ V[\x03\x90P`\0a\x14\xE1\x85a#\xD0V[\x89\x03\x90P\x82\x81\x83\x02\x81a\x14\xF0W\xFE[\x05a\x14\xFB\x86\x8Fa$ V[\x01\x99PPPPPPPPPPa\x07\x9EV[a\x15\x16\x83\x8Ca$ V[\x97PPPPPPPPa\x07\x9EV[`\0a\x05\xD1eZ\xF3\x10z@\0\x83\x02a%$V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 Ta\x15_\x82\x82\x10\x15a\x01\x96a\x13\xCCV[a\x15v`\x01`\x01`\xA0\x1B\x03\x84\x16\x15\x15a\x01\x99a\x13\xCCV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R Ta\x15\xA6\x90\x83a\x11\xC6V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x81\x81R` \x81\x90R`@\x90\x81\x90 \x93\x90\x93U\x91Q\x90\x86\x16\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90a\x15\xF8\x90\x86\x90aI\x93V[`@Q\x80\x91\x03\x90\xA3PPPPV[a\x07\xD7a\x16\x11a\x13ZV[a\x01\x92a\x13\xCCV[`\x08Ta\x16&\x90\x82a\x11\xD8V[`\x08U`@Q\x7F>5\x0BA\xE8j\x8E\x10\xF8\x04\xAD\xE6\xD3S@\xD6 \xBE5V\x9C\xC7Z\xC9C\xE8\xBB\x14\xAB\x80\xEA\xD1\x90a\x13O\x90\x83\x90aIpV[`\x08Ta\x16e\x81a\x17\xCDV[\x15a\x05\xE8Wa\x16\x7Fa\x16x`\tTa)\x01V[\x82\x90a)EV[\x90Pa\x16\x9Ba\x16\x94a\x16\x8Fa\x05\xEBV[a)\x01V[\x82\x90a)RV[`\x08UPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x17\x0Ea)`V[0`@Q` \x01a\x17#\x95\x94\x93\x92\x91\x90aI\xEFV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[a\x17Qd\xE8\xD4\xA5\x10\0\x82\x10\x15`\xCBa\x13\xCCV[a\x17gg\x01cEx]\x8A\0\0\x82\x11\x15`\xCAa\x13\xCCV[`\x08Ta\x17t\x90\x82a\x11\xE6V[`\x08U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90a\x13O\x90\x83\x90aI\x93V[`\0a\x05\xD1\x82\x82a)dV[`\0a\x05\xD1\x82`\x16a)dV[`\0a\x05\xD1\x82`,a)\x8BV[`\0a\x05\xD1\x82`Ua)\x95V[`\0a\x05\xD1\x82`Va)\x9FV[a\x13\xDA\x81\x83\x14`ga\x13\xCCV[`\0``\x80``a\x18\x03a jV[\x90Pa\x18\ra\x13ZV[\x15a\x18UWa\x18#\x87\x89`\0\x81Q\x81\x10a\x10\xEAW\xFE[`\0a\x18/\x82\x8Aa \xD8V[\x90Pa\x18@\x89\x83`\tT\x84\x8Ba)\xACV[\x92Pa\x18O\x89\x84a\x11\xF4a*\x90V[Pa\x18vV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x91` \x83\x01\x90\x806\x837\x01\x90PP\x91P[a\x18\x81\x88\x82\x87a+\"V[\x90\x94P\x92Pa\x18\x93\x88\x84a\x11\xF4a*\x90V[a\x18\x9D\x81\x89a \xD8V[`\tUP\x97P\x97P\x97\x94PPPPPV[a\x18\xD5\x81`\0\x81Q\x81\x10a\x18\xBEW\xFE[` \x02` \x01\x01Qa\x18\xD0`\x01a\x1D\tV[a+\x8FV[\x81`\0\x81Q\x81\x10a\x18\xE2W\xFE[` \x02` \x01\x01\x81\x81RPPa\x19\x10\x81`\x01\x81Q\x81\x10a\x18\xFEW\xFE[` \x02` \x01\x01Qa\x18\xD0`\0a\x1D\tV[\x81`\x01\x81Q\x81\x10a\x19\x1DW\xFE[` \x02` \x01\x01\x81\x81RPPPV[30\x14a\x19\xEAW`\x000`\x01`\x01`\xA0\x1B\x03\x16`\x006`@Qa\x19P\x92\x91\x90aH\xB5V[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x19\x8DW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x19\x92V[``\x91P[PP\x90P\x80`\0\x81\x14a\x19\xA1W\xFE[`\x04`\0\x80>`\0Q`\x01`\x01`\xE0\x1B\x03\x19\x16cC\xAD\xBA\xFB`\xE0\x1B\x81\x14a\x19\xCCW=`\0\x80>=`\0\xFD[P` `\x04`\0>`@` R`$=\x03`$`@>`\x1C=\x01`\0\xF3[a\x19\xF3\x86a\x1B5V[`\0``a\x1A\n\x8B\x8B\x8B\x8B\x8B\x8B\x8B\x8Bc\xFF\xFF\xFF\xFF\x16V[P\x91P\x91Pa\x1A\x1C\x81\x84c\xFF\xFF\xFF\xFF\x16V[\x80Q`\x1F\x19\x82\x01\x83\x90RcC\xAD\xBA\xFB`?\x19\x83\x01R` \x02`#\x19\x82\x01`D\x82\x01\x81\xFD[PPPPPPPPPV[`\0\x90\x81R`\x07` R`@\x90 T\x90V[`\0\x80`\0\x80`\0\x80`\0a\x1Aq\x88a+\xAFV[\x96Pa\x1A|\x88a+\xBCV[\x95Pa\x1A\x87\x88a+\xC9V[\x94Pa\x1A\x92\x88a+\xD6V[\x93Pa\x1A\x9D\x88a+\xE3V[\x92Pa\x1A\xA8\x88a+\xF0V[\x91Pa\x1A\xB3\x88a#\xD0V[\x90P\x91\x93\x95\x97\x90\x92\x94\x96PV[`\0\x82\x82\x02a\x07\x9E\x84\x15\x80a\x1A\xDDWP\x83\x85\x83\x81a\x1A\xDAW\xFE[\x04\x14[`\x03a\x13\xCCV[`\0a\x1A\xF3\x82\x15\x15`\x04a\x13\xCCV[\x82a\x1B\0WP`\0a\x05\xD1V[g\r\xE0\xB6\xB3\xA7d\0\0\x83\x81\x02\x90a\x1B#\x90\x85\x83\x81a\x1B\x1AW\xFE[\x04\x14`\x05a\x13\xCCV[\x82\x81\x81a\x1B,W\xFE[\x04\x91PPa\x05\xD1V[a\x1B\\\x81`\0\x81Q\x81\x10a\x1BEW\xFE[` \x02` \x01\x01Qa\x1BW`\x01a\x1D\tV[a\x1A\xC0V[\x81`\0\x81Q\x81\x10a\x1BiW\xFE[` \x02` \x01\x01\x81\x81RPPa\x19\x10\x81`\x01\x81Q\x81\x10a\x1B\x85W\xFE[` \x02` \x01\x01Qa\x1BW`\0a\x1D\tV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R` \x81\x90R`@\x90 Ta\x1B\xBF\x82\x82\x10\x15a\x01\x96a\x13\xCCV[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 \x82\x82\x03\x90U`\x02Ta\x1B\xE9\x90\x83a\x11\xF4V[`\x02U`@Q`\0\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90a\x12\xA1\x90\x86\x90aI\x93V[`\0``\x80``a\x1C9a jV[\x90P`\0a\x1CG\x82\x8Aa \xD8V[\x90P``a\x1CZ\x8A\x84`\tT\x85\x8Ca)\xACV[\x90Pa\x1Ci\x8A\x82a\x11\xF4a*\x90V[`\0``a\x1Cx\x8C\x86\x8Ba+\xFDV[\x91P\x91Pa\x1C\x89\x8C\x82a\x11\xC6a*\x90V[a\x1C\x93\x85\x8Da \xD8V[`\tU\x90\x9E\x90\x9DP\x90\x9BP\x99PPPPPPPPPPV[a\x1C\xD2\x81`\0\x81Q\x81\x10a\x1C\xBBW\xFE[` \x02` \x01\x01Qa\x1C\xCD`\x01a\x1D\tV[a,WV[\x81`\0\x81Q\x81\x10a\x1C\xDFW\xFE[` \x02` \x01\x01\x81\x81RPPa\x19\x10\x81`\x01\x81Q\x81\x10a\x1C\xFBW\xFE[` \x02` \x01\x01Qa\x1C\xCD`\0[`\0\x81a\x1D6W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x05\xD1V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90PV[`\0\x81a\x1D\x8AW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x05\xD1V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90PV[`\0a\x07\x9E\x83\x83a\x1A\xC0V[`\x08Ta\x1D\xC9\x81a\x17\xCDV[\x80\x15a\x1D\xD4WP\x83C\x11[\x15a\x1E\xBDW`\0a\x1E'\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86a,\x8AV[\x90P`\0a\x1E^\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86a\x1EY\x86a\x17\xB3V[a,\xBFV[\x90P`\0a\x1Ek\x84a\x13\xBFV[\x90P`\0a\x1Ex\x85a\x17\xC0V[\x90P`\0a\x1E\x91\x82\x84\x87\x87a\x1E\x8C\x8Ba\x17\xA7V[a,\xDBV[\x90P\x80\x83\x14a\x1A@Wa\x1E\xA4\x86\x82a-2V[\x95Pa\x1E\xB0\x86Ba-@V[`\x08\x81\x90U\x95PPPPPP[PPPPV[`\0\x82\x82\x02a\x1E\xDD\x84\x15\x80a\x1A\xDDWP\x83\x85\x83\x81a\x1A\xDAW\xFE[\x80a\x1E\xECW`\0\x91PPa\x05\xD1V[g\r\xE0\xB6\xB3\xA7d\0\0`\0\x19\x82\x01[\x04`\x01\x01\x91PPa\x05\xD1V[`\0a\x1F\x1A\x85\x84\x86\x85\x8A``\x01Qa-NV[\x90P[\x95\x94PPPPPV[`\0a\x07\x9E\x83\x83a+\x8FV[`\0a\x1F\x1A\x85\x84\x86\x85\x8A``\x01Qa-\xC9V[`\0a\x07\x9E\x83\x83a,WV[`\0g\r\xE0\xB6\xB3\xA7d\0\0\x82\x10a\x1FiW`\0a\x05\xD1V[Pg\r\xE0\xB6\xB3\xA7d\0\0\x03\x90V[`\0a\x1F\x86\x82\x15\x15`\x04a\x13\xCCV[\x82a\x1F\x93WP`\0a\x05\xD1V[g\r\xE0\xB6\xB3\xA7d\0\0\x83\x81\x02\x90a\x1F\xAD\x90\x85\x83\x81a\x1B\x1AW\xFE[\x82`\x01\x82\x03\x81a\x1E\xFBW\xFE[`\0a\x1F\xC3a\x0B\xB6V[`\x01`\x01`\xA0\x1B\x03\x16c\xAA\xAB\xAD\xC5`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1F\xFBW`\0\x80\xFD[PZ\xFA\x15\x80\x15a \x0FW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xE8\x91\x90aF\x05V[`\0\x80a ?\x83a\x1AKV[\x90Pa X`\0a O\x83a#\xD0V[\x11a\x019a\x13\xCCV[a b\x81\x85a#\xDCV[\x94\x93PPPPV[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x92\x83\x92\x91\x90` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa \x98`\x01a\x1D]V[\x81`\0\x81Q\x81\x10a \xA5W\xFE[` \x02` \x01\x01\x81\x81RPPa \xBB`\0a\x1D]V[\x81`\x01\x81Q\x81\x10a \xC8W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x90P\x90V[g\r\xE0\xB6\xB3\xA7d\0\0`\0[\x83Q\x81\x10\x15a!:Wa!0a!)\x85\x83\x81Q\x81\x10a \xFFW\xFE[` \x02` \x01\x01Q\x85\x84\x81Q\x81\x10a!\x13W\xFE[` \x02` \x01\x01Qa.?\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x90a.\x8EV[\x91P`\x01\x01a \xE4V[Pa\x05\xD1`\0\x82\x11a\x017a\x13\xCCV[`\0a!Ta\x16\xA1V[\x82`@Q` \x01a\x0BP\x92\x91\x90aH\xC5V[`\0```\0a!u\x84a.\xBAV[\x90Pa!\x90`\0\x82`\x02\x81\x11\x15a!\x88W\xFE[\x14`\xCEa\x13\xCCV[``a!\x9B\x85a.\xD0V[\x90Pa!\xA9\x81Q`\x02a\x17\xE7V[a!\xB2\x81a\x1B5V[``a!\xBCa jV[\x90P`\0a!\xCA\x82\x84a \xD8V[\x90P`\0a!\xD9\x82`\x02a\x1A\xC0V[`\t\x92\x90\x92UP\x99\x91\x98P\x90\x96PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R` \x81\x90R`@\x90 Ta\"\x12\x90\x82a\x11\xC6V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 U`\x02Ta\"8\x90\x82a\x11\xC6V[`\x02U`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90a\"y\x90\x85\x90aI\x93V[`@Q\x80\x91\x03\x90\xA3PPV[`\0s\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1Ba\"\xA4a\x0B\x92V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15\x80\x15a\"\xBFWPa\"\xBF\x83a.\xE6V[\x15a\"\xE7Wa\"\xCCa\x0B\x92V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa\x05\xD1V[a\"\xEFa\x1F\xB9V[`\x01`\x01`\xA0\x1B\x03\x16c\x9B\xE2\xA8\x84\x84\x840`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\x1E\x93\x92\x91\x90aI\x9CV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a#6W`\0\x80\xFD[PZ\xFA\x15\x80\x15a#JW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#n\x91\x90aD\xC5V[\x90Pa\x05\xD1V[\x1Ca\x03\xFF\x16\x90V[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[`\0a\x05\xD1\x82\x82a)\x8BV[`\0\x80\x82`\x02\x81\x11\x15a#\xEBW\xFE[\x14\x15a#\xFAWa#n\x83a+\xAFV[`\x01\x82`\x02\x81\x11\x15a$\x08W\xFE[\x14\x15a$\x17Wa#n\x83a+\xC9V[a#n\x83a+\xE3V[`\0\x80\x82`\x02\x81\x11\x15a$/W\xFE[\x14\x15a$>Wa#n\x83a+\xBCV[`\x01\x82`\x02\x81\x11\x15a$LW\xFE[\x14\x15a$[Wa#n\x83a+\xD6V[a#n\x83a+\xF0V[`\0a\x05\xD1\x82`\x01a/\0V[`\0\x80\x80a\x03\xFF\x81\x80\x80[\x83\x85\x11a$\xE8W`\x02\x85\x85\x01\x04a$\x93\x81\x8Aa/\0V[\x93Pa$\x9E\x84a\x1AKV[\x92Pa$\xA9\x83a#\xD0V[\x91P\x89\x82\x10\x15a$\xBEW\x80`\x01\x01\x95Pa$\xE2V[\x89\x82\x11\x15a$\xD1W`\x01\x81\x03\x94Pa$\xE2V[\x82\x83\x97P\x97PPPPPPPa%\x1DV[Pa$|V[\x88\x81\x10a%\x06Wa%\0a$\xFB\x84a/\x11V[a\x1AKV[\x82a%\x13V[\x81a%\x13a$\xFB\x85a$dV[\x96P\x96PPPPPP[\x92P\x92\x90PV[`\0a%Sh\x028\xFDB\xC5\xCF\x03\xFF\xFF\x19\x83\x12\x15\x80\x15a%LWPh\x07\x0C\x1C\xC7;\0\xC8\0\0\x83\x13\x15[`\ta\x13\xCCV[`\0\x82\x12\x15a%\x86Wa%h\x82`\0\x03a%$V[j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x81a%~W\xFE[\x05\x90Pa\nVV[`\0h\x06\xF0[Y\xD3\xB2\0\0\0\x83\x12a%\xC6WPh\x06\xF0[Y\xD3\xB1\xFF\xFF\xFF\x19\x90\x91\x01\x90w\x01\x95\xE5L]\xD4!w\xF5:'\x17/\xA9\xECc\x02b\x82p\0\0\0\0a%\xFCV[h\x03x-\xAC\xE9\xD9\0\0\0\x83\x12a%\xF8WPh\x03x-\xAC\xE9\xD8\xFF\xFF\xFF\x19\x90\x91\x01\x90k\x14%\x98,\xF5\x97\xCD \\\xEFs\x80a%\xFCV[P`\x01[`d\x92\x90\x92\x02\x91h\x05k\xC7^-c\x10\0\0h\xADx\xEB\xC5\xACb\0\0\0\x84\x12a&LWh\xADx\xEB\xC5\xACa\xFF\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0n\x01\x85QD\x81J\x7F\xF8\x05\x98\x0F\xF0\x08@\0\x82\x02\x05\x90P[hV\xBCu\xE2\xD61\0\0\0\x84\x12a&\x88WhV\xBCu\xE2\xD60\xFF\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0k\x02\xDF\n\xB5\xA8\n\"\xC6\x1A\xB5\xA7\0\x82\x02\x05\x90P[h+^:\xF1k\x18\x80\0\0\x84\x12a&\xC2Wh+^:\xF1k\x18\x7F\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0i?\x1F\xCE=\xA66\xEA\\\xF8P\x82\x02\x05\x90P[h\x15\xAF\x1Dx\xB5\x8C@\0\0\x84\x12a&\xFCWh\x15\xAF\x1Dx\xB5\x8C?\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0i\x01'\xFA'r,\xC0l\xC5\xE2\x82\x02\x05\x90P[h\n\xD7\x8E\xBCZ\xC6 \0\0\x84\x12a'5Wh\n\xD7\x8E\xBCZ\xC6\x1F\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h(\x0E`\x11N\xDB\x80]\x03\x82\x02\x05\x90P[h\x05k\xC7^-c\x10\0\0\x84\x12a'nWh\x05k\xC7^-c\x0F\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h\x0E\xBC_\xB4\x17F\x12\x11\x10\x82\x02\x05\x90P[h\x02\xB5\xE3\xAF\x16\xB1\x88\0\0\x84\x12a'\xA7Wh\x02\xB5\xE3\xAF\x16\xB1\x87\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h\x08\xF0\x0Fv\nK-\xB5]\x82\x02\x05\x90P[h\x01Z\xF1\xD7\x8BX\xC4\0\0\x84\x12a'\xE0Wh\x01Z\xF1\xD7\x8BX\xC3\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h\x06\xF5\xF1wW\x88\x93y7\x82\x02\x05\x90P[h\x05k\xC7^-c\x10\0\0\x84\x81\x01\x90\x85\x90`\x02\x90\x82\x80\x02\x05\x05\x91\x82\x01\x91\x90P`\x03h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x04h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x05h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x06h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x07h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x08h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\th\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\nh\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x0Bh\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x0Ch\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`dh\x05k\xC7^-c\x10\0\0\x84\x84\x02\x05\x85\x02\x05\x96\x95PPPPPPV[`\0\x80a)\r\x83a/\x1EV[\x90PeZ\xF3\x10z@\0`\0\x82\x13a),We-y\x88= \0\x82\x03a)6V[e-y\x88= \0\x82\x01[\x81a)=W\xFE[\x05\x93\x92PPPV[`\0a\x07\x9E\x83\x83\x83a/zV[`\0a\x07\x9E\x83\x83`\x16a/zV[F\x90V[`\0\x82\x82\x1Cb?\xFF\xFF\x16b\x1F\xFF\xFF\x81\x13a)~W\x80a bV[b?\xFF\xFF\x19\x17\x93\x92PPPV[\x1Cc\x7F\xFF\xFF\xFF\x16\x90V[\x1C`\x01\x90\x81\x16\x14\x90V[\x1C`\x01`\x01`@\x1B\x03\x16\x90V[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x92\x83\x92\x91\x90` \x83\x01\x90\x806\x837\x01\x90PP\x90P\x82a)\xDCW\x90Pa\x1F\x1DV[a*O\x87\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Q\x81\x10a*\x0BW\xFE[` \x02` \x01\x01Q\x87\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Q\x81\x10a*?W\xFE[` \x02` \x01\x01Q\x87\x87\x87a/\x91V[\x81\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Q\x81\x10a*{W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x96\x95PPPPPPV[a*\xC6\x83`\0\x81Q\x81\x10a*\xA0W\xFE[` \x02` \x01\x01Q\x83`\0\x81Q\x81\x10a*\xB5W\xFE[` \x02` \x01\x01Q\x83c\xFF\xFF\xFF\xFF\x16V[\x83`\0\x81Q\x81\x10a*\xD3W\xFE[` \x02` \x01\x01\x81\x81RPPa+\x04\x83`\x01\x81Q\x81\x10a*\xEFW\xFE[` \x02` \x01\x01Q\x83`\x01\x81Q\x81\x10a*\xB5W\xFE[\x83`\x01\x81Q\x81\x10a+\x11W\xFE[` \x02` \x01\x01\x81\x81RPPPPPV[`\0```\0a+1\x84a.\xBAV[\x90P`\0\x81`\x02\x81\x11\x15a+AW\xFE[\x14\x15a+\\Wa+R\x86\x86\x86a0\tV[\x92P\x92PPa+\x87V[`\x01\x81`\x02\x81\x11\x15a+jW\xFE[\x14\x15a+zWa+R\x86\x85a0\xB9V[a+R\x86\x86\x86a0\xEBV[P[\x93P\x93\x91PPV[`\0a+\x9E\x82\x15\x15`\x04a\x13\xCCV[\x81\x83\x81a+\xA7W\xFE[\x04\x93\x92PPPV[`\0a\x05\xD1\x82`\xEAa)dV[`\0a\x05\xD1\x82`\xB5a1WV[`\0a\x05\xD1\x82`\x9Fa)dV[`\0a\x05\xD1\x82`ja1WV[`\0a\x05\xD1\x82`Ta)dV[`\0a\x05\xD1\x82`\x1Fa1WV[`\0```\0a,\x0C\x84a.\xBAV[\x90P`\x01\x81`\x02\x81\x11\x15a,\x1CW\xFE[\x14\x15a,-Wa+R\x86\x86\x86a1\x8AV[`\x02\x81`\x02\x81\x11\x15a,;W\xFE[\x14\x15a,LWa+R\x86\x86\x86a1\xE0V[a+\x85a\x016a#}V[`\0a,f\x82\x15\x15`\x04a\x13\xCCV[\x82a,sWP`\0a\x05\xD1V[\x81`\x01\x84\x03\x81a,\x7FW\xFE[\x04`\x01\x01\x90Pa\x05\xD1V[`\0\x80a,\xAAa,\x9A\x84\x86a\x1FwV[a,\xA4\x87\x89a\x1FwV[\x90a\x1FwV[\x90Pa,\xB5\x81a)\x01V[\x96\x95PPPPPPV[`\0\x80a,\xCFa\x16\x8F\x85\x87a\x1FwV[\x92\x90\x92\x03\x94\x93PPPPV[`\0\x80a,\xF7\x85\x85\x85Ba,\xEE\x8Ba\x1AKV[\x93\x92\x91\x90a2cV[\x90P`xB\x88\x90\x03\x10\x15\x80a-\x0CW\x86a-\x15V[a-\x15\x87a$dV[`\0\x81\x81R`\x07` R`@\x90 \x92\x90\x92UP\x96\x95PPPPPPV[`\0a\x07\x9E\x83\x83`Ka2\xB5V[`\0a\x07\x9E\x83\x83`,a2\xC5V[`\0a-pa-e\x87g\x04)\xD0i\x18\x9E\0\0a.\x8EV[\x83\x11\x15a\x010a\x13\xCCV[`\0a-|\x87\x84a\x11\xC6V[\x90P`\0a-\x8A\x88\x83a\x1FwV[\x90P`\0a-\x98\x88\x87a\x1A\xE4V[\x90P`\0a-\xA6\x83\x83a2\xD7V[\x90Pa-\xBBa-\xB4\x82a\x1FQV[\x89\x90a.\x8EV[\x9A\x99PPPPPPPPPPV[`\0a-\xEBa-\xE0\x85g\x04)\xD0i\x18\x9E\0\0a.\x8EV[\x83\x11\x15a\x011a\x13\xCCV[`\0a.\x01a-\xFA\x86\x85a\x11\xF4V[\x86\x90a\x1FwV[\x90P`\0a.\x0F\x85\x88a\x1FwV[\x90P`\0a.\x1D\x83\x83a2\xD7V[\x90P`\0a.3\x82g\r\xE0\xB6\xB3\xA7d\0\0a\x11\xF4V[\x90Pa-\xBB\x8A\x82a\x1E\xC3V[`\0\x80a.L\x84\x84a3\x03V[\x90P`\0a.fa._\x83a'\x10a\x1E\xC3V[`\x01a\x11\xC6V[\x90P\x80\x82\x10\x15a.{W`\0\x92PPPa\x05\xD1V[a.\x85\x82\x82a\x11\xF4V[\x92PPPa\x05\xD1V[`\0\x82\x82\x02a.\xA8\x84\x15\x80a\x1A\xDDWP\x83\x85\x83\x81a\x1A\xDAW\xFE[g\r\xE0\xB6\xB3\xA7d\0\0\x90\x04\x93\x92PPPV[`\0\x81\x80` \x01\x90Q\x81\x01\x90a\x05\xD1\x91\x90aF!V[``\x81\x80` \x01\x90Q\x81\x01\x90a\x07\x9E\x91\x90aF\xE6V[`\0a.\xF8c\x1Ct\xC9\x17`\xE1\x1Ba\x0B\x1BV[\x90\x91\x14\x91\x90PV[`\0a\x04\0\x83\x83\x01[\x06\x93\x92PPPV[`\0a\x05\xD1\x82`\x01a4\x04V[`\0a/.`\0\x83\x13`da\x13\xCCV[g\x0C}q;I\xDA\0\0\x82\x13\x80\x15a/LWPg\x0FC\xFC,\x04\xEE\0\0\x82\x12[\x15a/jWg\r\xE0\xB6\xB3\xA7d\0\0a/c\x83a4\x13V[\x81a%~W\xFE[a/s\x82a51V[\x90Pa\nVV[b?\xFF\xFF\x82\x81\x16\x82\x1B\x90\x82\x1B\x19\x84\x16\x17\x93\x92PPPV[`\0\x83\x83\x11a/\xA2WP`\0a\x1F\x1DV[`\0a/\xAE\x85\x85a\x1FwV[\x90P`\0a/\xC4g\r\xE0\xB6\xB3\xA7d\0\0\x88a\x1A\xE4V[\x90Pa/\xD8\x82g\t\xB6\xE6J\x8E\xC6\0\0a8\xD0V[\x91P`\0a/\xE6\x83\x83a2\xD7V[\x90P`\0a/\xFDa/\xF6\x83a\x1FQV[\x8B\x90a.\x8EV[\x90Pa-\xBB\x81\x87a.\x8EV[`\0``a0\x15a\x16\x06V[`\0\x80a0!\x85a8\xE7V[\x91P\x91Pa03`\x02\x82\x10`da\x13\xCCV[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x92` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa0\x94\x88\x83\x81Q\x81\x10a0bW\xFE[` \x02` \x01\x01Q\x88\x84\x81Q\x81\x10a0vW\xFE[` \x02` \x01\x01Q\x85a0\x87a\x05\xEBV[a0\x8Fa\x08\x85V[a9\tV[\x81\x83\x81Q\x81\x10a0\xA0W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x91\x97\x91\x96P\x90\x94PPPPPV[`\0```\0a0\xC8\x84a9\xC0V[\x90P``a0\xDE\x86\x83a0\xD9a\x05\xEBV[a9\xD6V[\x91\x96\x91\x95P\x90\x93PPPPV[`\0``a0\xF7a\x16\x06V[```\0a1\x04\x85a:\x87V[\x91P\x91Pa1\x14\x82Q`\x02a\x17\xE7V[a1\x1D\x82a\x1B5V[`\0a1:\x88\x88\x85a1-a\x05\xEBV[a15a\x08\x85V[a:\x9FV[\x90Pa1J\x82\x82\x11\x15`\xCFa\x13\xCCV[\x97\x91\x96P\x90\x94PPPPPV[`\0\x82\x82\x1Cf\x1F\xFF\xFF\xFF\xFF\xFF\xFF\x16f\x0F\xFF\xFF\xFF\xFF\xFF\xFF\x81\x13a1yW\x80a bV[f\x1F\xFF\xFF\xFF\xFF\xFF\xFF\x19\x17\x93\x92PPPV[`\0``\x80`\0a1\x9A\x85a:\x87V[\x91P\x91Pa1\xAA\x82Q`\x02a\x17\xE7V[a1\xB3\x82a\x1B5V[`\0a1\xD0\x88\x88\x85a1\xC3a\x05\xEBV[a1\xCBa\x08\x85V[a<\xCAV[\x90Pa1J\x82\x82\x10\x15`\xD0a\x13\xCCV[`\0```\0\x80a1\xF0\x85a8\xE7V[\x91P\x91Pa2\x02`\x02\x82\x10`da\x13\xCCV[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x92` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa0\x94\x88\x83\x81Q\x81\x10a21W\xFE[` \x02` \x01\x01Q\x88\x84\x81Q\x81\x10a2EW\xFE[` \x02` \x01\x01Q\x85a2Va\x05\xEBV[a2^a\x08\x85V[a>\xDAV[`\0\x80a2o\x87a#\xD0V[\x83\x03\x90P`\0\x81\x87\x02a2\x81\x89a+\xBCV[\x01\x90P`\0\x82\x87\x02a2\x92\x8Aa+\xD6V[\x01\x90P`\0\x83\x87\x02a2\xA3\x8Ba+\xF0V[\x01\x90Pa-\xBB\x89\x84\x8A\x85\x8B\x86\x8Ca?|V[a\x03\xFF\x81\x1B\x19\x92\x90\x92\x16\x91\x1B\x17\x90V[c\x7F\xFF\xFF\xFF\x81\x1B\x19\x92\x90\x92\x16\x91\x1B\x17\x90V[`\0\x80a2\xE4\x84\x84a3\x03V[\x90P`\0a2\xF7a._\x83a'\x10a\x1E\xC3V[\x90Pa\x1F\x1D\x82\x82a\x11\xC6V[`\0\x81a3\x19WPg\r\xE0\xB6\xB3\xA7d\0\0a\x05\xD1V[\x82a3&WP`\0a\x05\xD1V[a37`\x01`\xFF\x1B\x84\x10`\x06a\x13\xCCV[\x82a3]w\x0B\xCEP\x86I!\x11\xAE\xA8\x8FK\xB1\xCAk\xCFXA\x81\xEA\x80Y\xF7e2\x84\x10`\x07a\x13\xCCV[\x82`\0g\x0C}q;I\xDA\0\0\x83\x13\x80\x15a3~WPg\x0FC\xFC,\x04\xEE\0\0\x83\x12[\x15a3\xB5W`\0a3\x8E\x84a4\x13V[\x90Pg\r\xE0\xB6\xB3\xA7d\0\0\x80\x82\x07\x84\x02\x05\x83g\r\xE0\xB6\xB3\xA7d\0\0\x83\x05\x02\x01\x91PPa3\xC3V[\x81a3\xBF\x84a51V[\x02\x90P[g\r\xE0\xB6\xB3\xA7d\0\0\x90\x05a3\xFBh\x028\xFDB\xC5\xCF\x03\xFF\xFF\x19\x82\x12\x80\x15\x90a3\xF4WPh\x07\x0C\x1C\xC7;\0\xC8\0\0\x82\x13\x15[`\x08a\x13\xCCV[a,\xB5\x81a%$V[`\0a\x04\0\x82\x84\x03\x81\x01a/\tV[g\r\xE0\xB6\xB3\xA7d\0\0\x02`\0\x80j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x80\x84\x01\x90n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x0F\xFF\xFF\xFF\xFF\x19\x85\x01\x02\x81a4NW\xFE[\x05\x90P`\0j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x80\x02\x05\x90P\x81\x80j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x81\x84\x02\x05\x91P`\x03\x82\x05\x01j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x84\x02\x05\x91P`\x05\x82\x05\x01j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x84\x02\x05\x91P`\x07\x82\x05\x01j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x84\x02\x05\x91P`\t\x82\x05\x01j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x84\x02\x05\x91P`\x0B\x82\x05\x01j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x84\x02\x05\x91P`\r\x82\x05\x01j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x82\x84\x02\x05\x91P`\x0F\x82`\x02\x91\x90\x05\x91\x90\x91\x01\x02\x95\x94PPPPPV[`\0g\r\xE0\xB6\xB3\xA7d\0\0\x82\x12\x15a5mWa5c\x82j\x0C\t|\xE7\xBC\x90q[4\xB9\xF1`$\x1B\x81a5]W\xFE[\x05a51V[`\0\x03\x90Pa\nVV[`\0~\x16\0\xEF1r\xE5\x8D.\x93>\xC8\x84\xFD\xE1\0d\xC6;Sr\xD8\x05\xE2\x03\xC0\0\0\0\0\0\0\x83\x12a5\xBEWw\x01\x95\xE5L]\xD4!w\xF5:'\x17/\xA9\xECc\x02b\x82p\0\0\0\0\x83\x05\x92Ph\x06\xF0[Y\xD3\xB2\0\0\0\x01[s\x01\x17\x98\0Mu]<\x8B\xC8\xE02\x04\xCFDa\x9E\0\0\0\x83\x12a5\xF6Wk\x14%\x98,\xF5\x97\xCD \\\xEFs\x80\x83\x05\x92Ph\x03x-\xAC\xE9\xD9\0\0\0\x01[`d\x92\x83\x02\x92\x02n\x01\x85QD\x81J\x7F\xF8\x05\x98\x0F\xF0\x08@\0\x83\x12a6>Wn\x01\x85QD\x81J\x7F\xF8\x05\x98\x0F\xF0\x08@\0h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\xADx\xEB\xC5\xACb\0\0\0\x01[k\x02\xDF\n\xB5\xA8\n\"\xC6\x1A\xB5\xA7\0\x83\x12a6yWk\x02\xDF\n\xB5\xA8\n\"\xC6\x1A\xB5\xA7\0h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92PhV\xBCu\xE2\xD61\0\0\0\x01[i?\x1F\xCE=\xA66\xEA\\\xF8P\x83\x12a6\xB0Wi?\x1F\xCE=\xA66\xEA\\\xF8Ph\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph+^:\xF1k\x18\x80\0\0\x01[i\x01'\xFA'r,\xC0l\xC5\xE2\x83\x12a6\xE7Wi\x01'\xFA'r,\xC0l\xC5\xE2h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\x15\xAF\x1Dx\xB5\x8C@\0\0\x01[h(\x0E`\x11N\xDB\x80]\x03\x83\x12a7\x1CWh(\x0E`\x11N\xDB\x80]\x03h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\n\xD7\x8E\xBCZ\xC6 \0\0\x01[h\x0E\xBC_\xB4\x17F\x12\x11\x10\x83\x12a7GWh\x0E\xBC_\xB4\x17F\x12\x11\x10h\x05k\xC7^-c\x10\0\0\x93\x84\x02\x05\x92\x01[h\x08\xF0\x0Fv\nK-\xB5]\x83\x12a7|Wh\x08\xF0\x0Fv\nK-\xB5]h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\x02\xB5\xE3\xAF\x16\xB1\x88\0\0\x01[h\x06\xF5\xF1wW\x88\x93y7\x83\x12a7\xB1Wh\x06\xF5\xF1wW\x88\x93y7h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\x01Z\xF1\xD7\x8BX\xC4\0\0\x01[h\x06$\x8F3pK(f\x03\x83\x12a7\xE5Wh\x06$\x8F3pK(f\x03h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Pg\xADx\xEB\xC5\xACb\0\0\x01[h\x05\xC5Hg\x0B\x95\x10\xE7\xAC\x83\x12a8\x19Wh\x05\xC5Hg\x0B\x95\x10\xE7\xACh\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92PgV\xBCu\xE2\xD61\0\0\x01[`\0h\x05k\xC7^-c\x10\0\0\x84\x01h\x05k\xC7^-c\x10\0\0\x80\x86\x03\x02\x81a8<W\xFE[\x05\x90P`\0h\x05k\xC7^-c\x10\0\0\x82\x80\x02\x05\x90P\x81\x80h\x05k\xC7^-c\x10\0\0\x81\x84\x02\x05\x91P`\x03\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\x05\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\x07\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\t\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\x0B\x82\x05\x01`\x02\x02`d\x85\x82\x01\x05\x97\x96PPPPPPPV[`\0\x81\x83\x10\x15a8\xE0W\x81a\x07\x9EV[P\x90\x91\x90PV[`\0\x80\x82\x80` \x01\x90Q\x81\x01\x90a8\xFE\x91\x90aF\xB0V[\x90\x95\x90\x94P\x92PPPV[`\0\x80a9\x1A\x84a,\xA4\x81\x88a\x11\xF4V[\x90Pa93g\t\xB6\xE6J\x8E\xC6\0\0\x82\x10\x15a\x012a\x13\xCCV[`\0a9Qa9Jg\r\xE0\xB6\xB3\xA7d\0\0\x89a\x1A\xE4V[\x83\x90a2\xD7V[\x90P`\0a9ha9a\x83a\x1FQV[\x8A\x90a.\x8EV[\x90P`\0a9u\x89a\x1FQV[\x90P`\0a9\x83\x83\x83a\x1E\xC3V[\x90P`\0a9\x91\x84\x83a\x11\xF4V[\x90Pa9\xB0a9\xA9a9\xA2\x8Aa\x1FQV[\x84\x90a.\x8EV[\x82\x90a\x11\xC6V[\x9C\x9BPPPPPPPPPPPPV[`\0\x81\x80` \x01\x90Q\x81\x01\x90a\x07\x9E\x91\x90aF\x83V[```\0a9\xE4\x84\x84a\x1A\xE4V[\x90P``\x85Q`\x01`\x01`@\x1B\x03\x81\x11\x80\x15a9\xFFW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a:)W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x86Q\x81\x10\x15a:}Wa:^\x83\x88\x83\x81Q\x81\x10a:HW\xFE[` \x02` \x01\x01Qa.\x8E\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82\x82\x81Q\x81\x10a:jW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a:/V[P\x95\x94PPPPPV[```\0\x82\x80` \x01\x90Q\x81\x01\x90a8\xFE\x91\x90aF=V[`\0``\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x80\x15a:\xBAW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a:\xE4W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x88Q\x81\x10\x15a;\xA9Wa;D\x89\x82\x81Q\x81\x10a;\x03W\xFE[` \x02` \x01\x01Qa,\xA4\x89\x84\x81Q\x81\x10a;\x1AW\xFE[` \x02` \x01\x01Q\x8C\x85\x81Q\x81\x10a;.W\xFE[` \x02` \x01\x01Qa\x11\xF4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x82\x81Q\x81\x10a;PW\xFE[` \x02` \x01\x01\x81\x81RPPa;\x9Fa;\x98\x89\x83\x81Q\x81\x10a;nW\xFE[` \x02` \x01\x01Q\x85\x84\x81Q\x81\x10a;\x82W\xFE[` \x02` \x01\x01Qa\x1E\xC3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x90a\x11\xC6V[\x91P`\x01\x01a:\xEBV[Pg\r\xE0\xB6\xB3\xA7d\0\0`\0[\x89Q\x81\x10\x15a<\xA9W`\0\x84\x82\x81Q\x81\x10a;\xCDW\xFE[` \x02` \x01\x01Q\x84\x11\x15a<+W`\0a;\xF6a;\xEA\x86a\x1FQV[\x8D\x85\x81Q\x81\x10a:HW\xFE[\x90P`\0a<\n\x82\x8C\x86\x81Q\x81\x10a;.W\xFE[\x90Pa<\"a;\x98a<\x1B\x8Ba\x1FQV[\x83\x90a\x1FwV[\x92PPPa<BV[\x88\x82\x81Q\x81\x10a<7W\xFE[` \x02` \x01\x01Q\x90P[`\0a<k\x8C\x84\x81Q\x81\x10a<SW\xFE[` \x02` \x01\x01Qa\t\x85\x84\x8F\x87\x81Q\x81\x10a;.W\xFE[\x90Pa<\x9Da<\x96\x8C\x85\x81Q\x81\x10a<\x7FW\xFE[` \x02` \x01\x01Q\x83a.?\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x85\x90a.\x8EV[\x93PPP`\x01\x01a;\xB6V[Pa<\xBDa<\xB6\x82a\x1FQV[\x87\x90a\x1E\xC3V[\x99\x98PPPPPPPPPV[`\0``\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x80\x15a<\xE5W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a=\x0FW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x88Q\x81\x10\x15a=\xB7Wa=o\x89\x82\x81Q\x81\x10a=.W\xFE[` \x02` \x01\x01Qa\t\x85\x89\x84\x81Q\x81\x10a=EW\xFE[` \x02` \x01\x01Q\x8C\x85\x81Q\x81\x10a=YW\xFE[` \x02` \x01\x01Qa\x11\xC6\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x82\x81Q\x81\x10a={W\xFE[` \x02` \x01\x01\x81\x81RPPa=\xADa;\x98\x89\x83\x81Q\x81\x10a=\x99W\xFE[` \x02` \x01\x01Q\x85\x84\x81Q\x81\x10a:HW\xFE[\x91P`\x01\x01a=\x16V[Pg\r\xE0\xB6\xB3\xA7d\0\0`\0[\x89Q\x81\x10\x15a>\x98W`\0\x83\x85\x83\x81Q\x81\x10a=\xDCW\xFE[` \x02` \x01\x01Q\x11\x15a>8W`\0a>\x01a;\xEA\x86g\r\xE0\xB6\xB3\xA7d\0\0a\x11\xF4V[\x90P`\0a>\x15\x82\x8C\x86\x81Q\x81\x10a;.W\xFE[\x90Pa>/a;\x98a!)g\r\xE0\xB6\xB3\xA7d\0\0\x8Ca\x11\xF4V[\x92PPPa>OV[\x88\x82\x81Q\x81\x10a>DW\xFE[` \x02` \x01\x01Q\x90P[`\0a>x\x8C\x84\x81Q\x81\x10a>`W\xFE[` \x02` \x01\x01Qa\t\x85\x84\x8F\x87\x81Q\x81\x10a=YW\xFE[\x90Pa>\x8Ca<\x96\x8C\x85\x81Q\x81\x10a<\x7FW\xFE[\x93PPP`\x01\x01a=\xC4V[Pg\r\xE0\xB6\xB3\xA7d\0\0\x81\x10a>\xCEWa>\xC4a>\xBD\x82g\r\xE0\xB6\xB3\xA7d\0\0a\x11\xF4V[\x87\x90a.\x8EV[\x93PPPPa\x1F\x1DV[`\0\x93PPPPa\x1F\x1DV[`\0\x80a>\xEB\x84a,\xA4\x81\x88a\x11\xC6V[\x90Pa?\x04g)\xA2$\x1A\xF6,\0\0\x82\x11\x15a\x013a\x13\xCCV[`\0a?\x1Ba9Jg\r\xE0\xB6\xB3\xA7d\0\0\x89a\x1FwV[\x90P`\0a?;a?4\x83g\r\xE0\xB6\xB3\xA7d\0\0a\x11\xF4V[\x8A\x90a\x1E\xC3V[\x90P`\0a?H\x89a\x1FQV[\x90P`\0a?V\x83\x83a\x1E\xC3V[\x90P`\0a?d\x84\x83a\x11\xF4V[\x90Pa9\xB0a9\xA9a?u\x8Aa\x1FQV[\x84\x90a\x1FwV[`\0a?\x88\x82\x82a?\xDCV[a?\x93\x84`\x1Fa?\xE0V[a?\x9E\x86`Ta?\xF1V[a?\xA9\x88`ja?\xE0V[a?\xB4\x8A`\x9Fa?\xF1V[a?\xBF\x8C`\xB5a?\xE0V[a?\xCA\x8E`\xEAa?\xF1V[\x17\x17\x17\x17\x17\x17\x98\x97PPPPPPPPV[\x1B\x90V[f\x1F\xFF\xFF\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x90\x1B\x90V[b?\xFF\xFF\x91\x90\x91\x16\x90\x1B\x90V[`@\x80Q``\x81\x01\x90\x91R\x80`\0\x81R` \x01`\0\x81R` \x01`\0\x81RP\x90V[`@\x80Q\x80\x82\x01\x90\x91R`\0\x80\x82R` \x82\x01R\x90V[\x805a\x05\xD1\x81aKRV[`\0\x82`\x1F\x83\x01\x12a@RW\x80\x81\xFD[\x81Qa@ea@`\x82aK3V[aK\rV[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15a@\x86W`\0\x80\xFD[`\0[\x84\x81\x10\x15a@\xA5W\x81Q\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01a@\x89V[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12a@\xC0W\x80\x81\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a@\xD5W\x81\x82\xFD[a@\xE8`\x1F\x82\x01`\x1F\x19\x16` \x01aK\rV[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15a@\xFFW`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[\x805`\x02\x81\x10a\x05\xD1W`\0\x80\xFD[\x805a\x05\xD1\x81aKuV[`\0` \x82\x84\x03\x12\x15aACW\x80\x81\xFD[\x815a\x07\x9E\x81aKRV[`\0\x80`@\x83\x85\x03\x12\x15aA`W\x80\x81\xFD[\x825aAk\x81aKRV[\x91P` \x83\x015aA{\x81aKRV[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15aA\x9AW\x80\x81\xFD[\x835aA\xA5\x81aKRV[\x92P` \x84\x015aA\xB5\x81aKRV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[`\0\x80`\0\x80`\0\x80`\0`\xE0\x88\x8A\x03\x12\x15aA\xE0W\x84\x85\xFD[\x875aA\xEB\x81aKRV[\x96P` \x88\x015aA\xFB\x81aKRV[\x95P`@\x88\x015\x94P``\x88\x015\x93P`\x80\x88\x015`\xFF\x81\x16\x81\x14aB\x1EW\x83\x84\xFD[\x96\x99\x95\x98P\x93\x96\x92\x95\x94`\xA0\x84\x015\x94P`\xC0\x90\x93\x015\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15aBMW\x81\x82\xFD[\x825aBX\x81aKRV[\x94` \x93\x90\x93\x015\x93PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15aBzW\x80\x81\xFD[\x83Q`\x01`\x01`@\x1B\x03\x80\x82\x11\x15aB\x90W\x82\x83\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12aB\xA3W\x82\x83\xFD[\x81QaB\xB1a@`\x82aK3V[\x80\x82\x82R` \x80\x83\x01\x92P\x80\x86\x01\x8B\x82\x83\x87\x02\x89\x01\x01\x11\x15aB\xD1W\x87\x88\xFD[\x87\x96P[\x84\x87\x10\x15aB\xFCW\x80QaB\xE8\x81aKRV[\x84R`\x01\x96\x90\x96\x01\x95\x92\x81\x01\x92\x81\x01aB\xD5V[P\x89\x01Q\x90\x97P\x93PPP\x80\x82\x11\x15aC\x13W\x82\x83\xFD[PaC \x86\x82\x87\x01a@BV[\x92PP`@\x84\x01Q\x90P\x92P\x92P\x92V[`\0` \x80\x83\x85\x03\x12\x15aCCW\x81\x82\xFD[\x825`\x01`\x01`@\x1B\x03\x81\x11\x15aCXW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aChW\x82\x83\xFD[\x805aCva@`\x82aK3V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`@\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aC\x94W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aC\xE1W\x80\x82\x8B\x03\x12\x15aC\xAEW\x87\x88\xFD[aC\xB7\x81aK\rV[aC\xC1\x8B\x84aA'V[\x81R\x82\x88\x015\x88\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aC\x98V[P\x90\x98\x97PPPPPPPPV[`\0` \x80\x83\x85\x03\x12\x15aD\x01W\x81\x82\xFD[\x825`\x01`\x01`@\x1B\x03\x81\x11\x15aD\x16W\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aD&W\x82\x83\xFD[\x805aD4a@`\x82aK3V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01``\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aDRW\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aC\xE1W\x80\x82\x8B\x03\x12\x15aDlW\x87\x88\xFD[aDu\x81aK\rV[aD\x7F\x8B\x84aA'V[\x81R\x82\x88\x015\x88\x82\x01R`@\x80\x84\x015\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aDVV[`\0` \x82\x84\x03\x12\x15aD\xBAW\x80\x81\xFD[\x815a\x07\x9E\x81aKgV[`\0` \x82\x84\x03\x12\x15aD\xD6W\x80\x81\xFD[\x81Qa\x07\x9E\x81aKgV[`\0\x80`\0\x80`\0\x80`\0`\xE0\x88\x8A\x03\x12\x15aD\xFBW\x80\x81\xFD[\x875\x96P` \x80\x89\x015aE\x0E\x81aKRV[\x96P`@\x89\x015aE\x1E\x81aKRV[\x95P``\x89\x015`\x01`\x01`@\x1B\x03\x80\x82\x11\x15aE9W\x83\x84\xFD[\x81\x8B\x01\x91P\x8B`\x1F\x83\x01\x12aELW\x83\x84\xFD[\x815aEZa@`\x82aK3V[\x80\x82\x82R\x85\x82\x01\x91P\x85\x85\x01\x8F\x87\x88\x86\x02\x88\x01\x01\x11\x15aExW\x87\x88\xFD[\x87\x95P[\x83\x86\x10\x15aE\x9AW\x805\x83R`\x01\x95\x90\x95\x01\x94\x91\x86\x01\x91\x86\x01aE|V[P\x98PPP`\x80\x8B\x015\x95P`\xA0\x8B\x015\x94P`\xC0\x8B\x015\x92P\x80\x83\x11\x15aE\xC0W\x83\x84\xFD[PPaE\xCE\x8A\x82\x8B\x01a@\xB0V[\x91PP\x92\x95\x98\x91\x94\x97P\x92\x95PV[`\0` \x82\x84\x03\x12\x15aE\xEEW\x80\x81\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x07\x9EW\x81\x82\xFD[`\0` \x82\x84\x03\x12\x15aF\x16W\x80\x81\xFD[\x81Qa\x07\x9E\x81aKRV[`\0` \x82\x84\x03\x12\x15aF2W\x80\x81\xFD[\x81Qa\x07\x9E\x81aKuV[`\0\x80`\0``\x84\x86\x03\x12\x15aFQW\x80\x81\xFD[\x83QaF\\\x81aKuV[` \x85\x01Q\x90\x93P`\x01`\x01`@\x1B\x03\x81\x11\x15aFwW\x81\x82\xFD[aC \x86\x82\x87\x01a@BV[`\0\x80`@\x83\x85\x03\x12\x15aF\x95W\x81\x82\xFD[\x82QaF\xA0\x81aKuV[` \x93\x90\x93\x01Q\x92\x94\x92\x93PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15aF\xC4W\x80\x81\xFD[\x83QaF\xCF\x81aKuV[` \x85\x01Q`@\x90\x95\x01Q\x90\x96\x94\x95P\x93\x92PPPV[`\0\x80`@\x83\x85\x03\x12\x15aF\xF8W\x81\x82\xFD[\x82QaG\x03\x81aKuV[` \x84\x01Q\x90\x92P`\x01`\x01`@\x1B\x03\x81\x11\x15aG\x1EW\x81\x82\xFD[aG*\x85\x82\x86\x01a@BV[\x91PP\x92P\x92\x90PV[`\0` \x82\x84\x03\x12\x15aGEW\x80\x81\xFD[\x815a\x07\x9E\x81aKuV[`\0\x80`\0``\x84\x86\x03\x12\x15aGdW\x80\x81\xFD[\x835`\x01`\x01`@\x1B\x03\x80\x82\x11\x15aGzW\x82\x83\xFD[\x81\x86\x01\x91Pa\x01 \x80\x83\x89\x03\x12\x15aG\x90W\x83\x84\xFD[aG\x99\x81aK\rV[\x90PaG\xA5\x88\x84aA\x18V[\x81RaG\xB4\x88` \x85\x01a@7V[` \x82\x01RaG\xC6\x88`@\x85\x01a@7V[`@\x82\x01R``\x83\x015``\x82\x01R`\x80\x83\x015`\x80\x82\x01R`\xA0\x83\x015`\xA0\x82\x01RaG\xF6\x88`\xC0\x85\x01a@7V[`\xC0\x82\x01RaH\x08\x88`\xE0\x85\x01a@7V[`\xE0\x82\x01Ra\x01\0\x80\x84\x015\x83\x81\x11\x15aH W\x85\x86\xFD[aH,\x8A\x82\x87\x01a@\xB0V[\x91\x83\x01\x91\x90\x91RP\x97` \x87\x015\x97P`@\x90\x96\x015\x95\x94PPPPPV[`\0` \x82\x84\x03\x12\x15aH\\W\x80\x81\xFD[P5\x91\x90PV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aH\x92W\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aHvV[P\x94\x95\x94PPPPPV[\x91\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`$\x01\x90V[`\0\x82\x84\x837\x91\x01\x90\x81R\x91\x90PV[a\x19\x01`\xF0\x1B\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15aI,W\x83Q\x83R\x92\x84\x01\x92\x91\x84\x01\x91`\x01\x01aI\x10V[P\x90\x96\x95PPPPPPV[`\0` \x82Ra\x07\x9E` \x83\x01\x84aHcV[`\0`@\x82RaI^`@\x83\x01\x85aHcV[\x82\x81\x03` \x84\x01Ra\x1F\x1D\x81\x85aHcV[\x90\x15\x15\x81R` \x01\x90V[\x92\x15\x15\x83R` \x83\x01\x91\x90\x91R`@\x82\x01R``\x01\x90V[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16` \x87\x01R\x92\x90\x93\x16`@\x85\x01R``\x84\x01R`\x80\x83\x01\x91\x90\x91R`\xA0\x82\x01R`\xC0\x01\x90V[\x94\x85R` \x85\x01\x93\x90\x93R`@\x84\x01\x91\x90\x91R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01\x90V[\x93\x84R`\xFF\x92\x90\x92\x16` \x84\x01R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[\x96\x87R` \x87\x01\x95\x90\x95R`@\x86\x01\x93\x90\x93R``\x85\x01\x91\x90\x91R`\x80\x84\x01R`\xA0\x83\x01R`\xC0\x82\x01R`\xE0\x01\x90V[\x95\x86R` \x86\x01\x94\x90\x94R`@\x85\x01\x92\x90\x92R``\x84\x01R\x15\x15`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`\0` \x80\x83R\x83Q\x80\x82\x85\x01R\x82[\x81\x81\x10\x15aJ\xBFW\x85\x81\x01\x83\x01Q\x85\x82\x01`@\x01R\x82\x01aJ\xA3V[\x81\x81\x11\x15aJ\xD0W\x83`@\x83\x87\x01\x01R[P`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01`@\x01\x93\x92PPPV[`\0\x83\x82R`@` \x83\x01Ra b`@\x83\x01\x84aHcV[`\xFF\x91\x90\x91\x16\x81R` \x01\x90V[`@Q\x81\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15aK+W`\0\x80\xFD[`@R\x91\x90PV[`\0`\x01`\x01`@\x1B\x03\x82\x11\x15aKHW\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05\xE8W`\0\x80\xFD[\x80\x15\x15\x81\x14a\x05\xE8W`\0\x80\xFD[`\x03\x81\x10a\x05\xE8W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \x1D\xBF\x8D6M\x92`\x88\xA1\x9C_?]\x0C\xA0\xABr\xCF>\xDA\x8F?x\xDD\xA4Z\xB2a\x9D\xE4\xB6\xD6dsolcC\0\x07\x01\x003\xA2dipfsX\"\x12 b\xC6:,0\x89I\n\x93\x9F\xE9\xF2\x0E\x0E\x99\xEF1\x0F\x04\xA3\x93\xC3:\x92\xC6oE\xA3\xB2\xCE\xA1\x80dsolcC\0\x07\x01\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { vault: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256[],uint256,bool,address)` and selector `0x1596019b`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, bool oracleEnabled, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub weights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub oracleEnabled: bool,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256[],uint256,bool,
+    /// address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.weights,
+                        value.swapFeePercentage,
+                        value.oracleEnabled,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        weights: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        oracleEnabled: tuple.5,
+                        owner: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [21u8, 150u8, 1u8, 155u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],uint256,bool,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.oracleEnabled,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2WeightedPool2TokensFactory`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum BalancerV2WeightedPool2TokensFactoryCalls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+    }
+    impl BalancerV2WeightedPool2TokensFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [21u8, 150u8, 1u8, 155u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [141u8, 146u8, 138u8, 248u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(create),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(getVault),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2WeightedPool2TokensFactoryCalls {
+        const COUNT: usize = 4usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2WeightedPool2TokensFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPool2TokensFactoryCalls,
+            >] = &[
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPool2TokensFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPool2TokensFactoryCalls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPool2TokensFactoryCalls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPool2TokensFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPool2TokensFactoryCalls,
+            >] = &[
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPool2TokensFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPool2TokensFactoryCalls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPool2TokensFactoryCalls::isPoolFromFactory,
+                            )
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPool2TokensFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2WeightedPool2TokensFactory`](self)
+    /// events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2WeightedPool2TokensFactoryEvents {
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2WeightedPool2TokensFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8, 73u8,
+            106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8, 188u8,
+            196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(PoolCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2WeightedPool2TokensFactoryEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "BalancerV2WeightedPool2TokensFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2WeightedPool2TokensFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPool2TokensFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2WeightedPool2TokensFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2WeightedPool2TokensFactoryInstance<P, N> {
+        BalancerV2WeightedPool2TokensFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        vault: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<BalancerV2WeightedPool2TokensFactoryInstance<P, N>>,
+    > {
+        BalancerV2WeightedPool2TokensFactoryInstance::<P, N>::deploy(__provider, vault)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        vault: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        BalancerV2WeightedPool2TokensFactoryInstance::<P, N>::deploy_builder(__provider, vault)
+    }
+    /**A [`BalancerV2WeightedPool2TokensFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2WeightedPool2TokensFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2WeightedPool2TokensFactoryInstance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2WeightedPool2TokensFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2WeightedPool2TokensFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPool2TokensFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPool2TokensFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2WeightedPool2TokensFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            vault: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<BalancerV2WeightedPool2TokensFactoryInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, vault);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            vault: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { vault })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2WeightedPool2TokensFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2WeightedPool2TokensFactoryInstance<P, N> {
+            BalancerV2WeightedPool2TokensFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPool2TokensFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            weights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            oracleEnabled: bool,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                weights,
+                swapFeePercentage,
+                oracleEnabled,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPool2TokensFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance =
+    BalancerV2WeightedPool2TokensFactory::BalancerV2WeightedPool2TokensFactoryInstance<
+        ::alloy_provider::DynProvider,
+    >;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xa5bf2ddf098bb0ef6d120c98217dd6b141c74ee0"),
+            Some(12349891u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xdAE7e32ADc5d490a43cCba1f0c736033F2b4eFca"),
+            Some(7005512u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9"),
+            Some(15832998u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xCF0a32Bbef8F064969F21f7e02328FB577382018"),
+            Some(222864u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/Cargo.toml b/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/Cargo.toml
new file mode 100644
index 0000000000..23a0e3bbc9
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2weightedpoolfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs
new file mode 100644
index 0000000000..65d9512e70
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs
@@ -0,0 +1,1605 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2WeightedPoolFactory {
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner) external returns (address);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getVault() external view returns (address);
+    function isPoolFromFactory(address pool) external view returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "weights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2WeightedPoolFactory {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xC0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa`A8\x03\x80a`A\x839\x81\x01`@\x81\x90Ra\0/\x91a\0MV[``\x1B`\x01`\x01``\x1B\x03\x19\x16`\x80Rbv\xA7\0B\x01`\xA0Ra\0{V[`\0` \x82\x84\x03\x12\x15a\0^W\x80\x81\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0tW\x81\x82\xFD[\x93\x92PPPV[`\x80Q``\x1C`\xA0Qa_\x9Ca\0\xA5`\09\x80`\xD6R\x80a\x01\0RP\x80a\x01\\RPa_\x9C`\0\xF3\xFE`\x80`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`\x046\x10b\0\0RW`\x005`\xE0\x1C\x80c-\xA4|@\x14b\0\0WW\x80cf4\xB7S\x14b\0\0zW\x80c\x8D\x92\x8A\xF8\x14b\0\0\xA0W\x80c\xFB\xCE\x03\x93\x14b\0\0\xB9W[`\0\x80\xFD[b\0\0ab\0\0\xD0V[`@Qb\0\0q\x92\x91\x90b\0\x064V[`@Q\x80\x91\x03\x90\xF3[b\0\0\x91b\0\0\x8B6`\x04b\0\x03\xC0V[b\0\x01<V[`@Qb\0\0q\x91\x90b\0\x05bV[b\0\0\xAAb\0\x01ZV[`@Qb\0\0q\x91\x90b\0\x05NV[b\0\0\xAAb\0\0\xCA6`\x04b\0\x03\xE6V[b\0\x01~V[`\0\x80B\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x10\x15b\0\x01.W\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x03\x92Pb'\x8D\0\x91Pb\0\x017V[`\0\x92P`\0\x91P[P\x90\x91V[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R` \x81\x90R`@\x90 T`\xFF\x16\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\0\x80`\0b\0\x01\x8Db\0\0\xD0V[\x91P\x91P`\0b\0\x01\x9Db\0\x01ZV[\x8A\x8A\x8A\x8A\x8A\x88\x88\x8C`@Qb\0\x01\xB3\x90b\0\x02KV[b\0\x01\xC7\x99\x98\x97\x96\x95\x94\x93\x92\x91\x90b\0\x05mV[`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15b\0\x01\xE4W=`\0\x80>=`\0\xFD[P\x90Pb\0\x01\xF2\x81b\0\x01\xFFV[\x99\x98PPPPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R` \x81\x90R`@\x80\x82 \x80T`\xFF\x19\x16`\x01\x17\x90UQ\x7F\x83\xA4\x8F\xBC\xFC\x99\x1351Nt\xD0Ij\xABj\x19\x87\xE9\x92\xDD\xC8]\xDD\xBC\xC4\xD6\xDDn\xF2\xE9\xFC\x91\x90\xA2PV[aX\xB6\x80b\0\x06\xB1\x839\x01\x90V[\x805b\0\x02f\x81b\0\x06\x97V[\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12b\0\x02}W\x80\x81\xFD[\x815b\0\x02\x94b\0\x02\x8E\x82b\0\x06jV[b\0\x06BV[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15b\0\x02\xB6W`\0\x80\xFD[`\0[\x84\x81\x10\x15b\0\x02\xE2W\x815b\0\x02\xCF\x81b\0\x06\x97V[\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01b\0\x02\xB9V[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12b\0\x02\xFEW\x80\x81\xFD[\x815b\0\x03\x0Fb\0\x02\x8E\x82b\0\x06jV[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15b\0\x031W`\0\x80\xFD[`\0[\x84\x81\x10\x15b\0\x02\xE2W\x815\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01b\0\x034V[`\0\x82`\x1F\x83\x01\x12b\0\x03cW\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15b\0\x03zW\x81\x82\xFD[b\0\x03\x8F`\x1F\x82\x01`\x1F\x19\x16` \x01b\0\x06BV[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15b\0\x03\xA7W`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[`\0` \x82\x84\x03\x12\x15b\0\x03\xD2W\x80\x81\xFD[\x815b\0\x03\xDF\x81b\0\x06\x97V[\x93\x92PPPV[`\0\x80`\0\x80`\0\x80`\xC0\x87\x89\x03\x12\x15b\0\x03\xFFW\x81\x82\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15b\0\x04\x17W\x83\x84\xFD[b\0\x04%\x8A\x83\x8B\x01b\0\x03RV[\x97P` \x89\x015\x91P\x80\x82\x11\x15b\0\x04;W\x83\x84\xFD[b\0\x04I\x8A\x83\x8B\x01b\0\x03RV[\x96P`@\x89\x015\x91P\x80\x82\x11\x15b\0\x04_W\x83\x84\xFD[b\0\x04m\x8A\x83\x8B\x01b\0\x02lV[\x95P``\x89\x015\x91P\x80\x82\x11\x15b\0\x04\x83W\x83\x84\xFD[Pb\0\x04\x92\x89\x82\x8A\x01b\0\x02\xEDV[\x93PP`\x80\x87\x015\x91Pb\0\x04\xAB\x88`\xA0\x89\x01b\0\x02YV[\x90P\x92\x95P\x92\x95P\x92\x95V[`\x01`\x01`\xA0\x1B\x03\x16\x90RV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15b\0\x04\xF5W\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01b\0\x04\xD7V[P\x94\x95\x94PPPPPV[`\0\x81Q\x80\x84R\x81[\x81\x81\x10\x15b\0\x05'W` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01b\0\x05\tV[\x81\x81\x11\x15b\0\x059W\x82` \x83\x87\x01\x01R[P`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[\x90\x15\x15\x81R` \x01\x90V[`\0a\x01 `\x01`\x01`\xA0\x1B\x03\x8C\x16\x83R` \x81\x81\x85\x01Rb\0\x05\x93\x82\x85\x01\x8Db\0\x05\0V[\x91P\x83\x82\x03`@\x85\x01Rb\0\x05\xA9\x82\x8Cb\0\x05\0V[\x84\x81\x03``\x86\x01R\x8AQ\x80\x82R\x82\x8C\x01\x93P\x90\x82\x01\x90\x84[\x81\x81\x10\x15b\0\x05\xE9Wb\0\x05\xD6\x85Qb\0\x06\x8BV[\x83R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01b\0\x05\xC1V[PP\x84\x81\x03`\x80\x86\x01Rb\0\x05\xFF\x81\x8Bb\0\x04\xC4V[\x93PPPP\x85`\xA0\x83\x01R\x84`\xC0\x83\x01R\x83`\xE0\x83\x01Rb\0\x06&a\x01\0\x83\x01\x84b\0\x04\xB7V[\x9A\x99PPPPPPPPPPV[\x91\x82R` \x82\x01R`@\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15b\0\x06bW`\0\x80\xFD[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15b\0\x06\x81W\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x06\xADW`\0\x80\xFD[PV\xFEa\x05\0`@R\x7Fnq\xED\xAE\x12\xB1\xB9\x7FM\x1F`7\x0F\xEF\x10\x10_\xA2\xFA\xAE\x01&\x11J\x16\x9Cd\x84]a&\xC9a\x01 R4\x80\x15b\0\x007W`\0\x80\xFD[P`@Qb\0X\xB68\x03\x80b\0X\xB6\x839\x81\x01`@\x81\x90Rb\0\0Z\x91b\0\x0C\xF2V[\x88\x88\x88\x88\x87\x87\x87\x87\x87\x85Q`\x02\x14b\0\0uW`\x01b\0\0xV[`\x02[`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`1`\xF8\x1B` \x80\x83\x01\x91\x82R3`\x80R`\x01`\x01``\x1B\x03\x19``\x87\x90\x1B\x16`\xA0R\x8BQ\x90\x8C\x01\x90\x81 `\xC0R\x91Q\x90 `\xE0R\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0Fa\x01\0R\x89Q\x8A\x91\x8A\x91\x8A\x91\x8A\x91\x8A\x91\x8A\x91\x8A\x91\x84\x91\x84\x91\x8A\x91\x8A\x91b\0\x01\x07\x91`\x03\x91\x90b\0\n\xBBV[P\x80Qb\0\x01\x1D\x90`\x04\x90` \x84\x01\x90b\0\n\xBBV[Pb\0\x015\x91PPbv\xA7\0\x83\x11\x15a\x01\x94b\0\x08eV[b\0\x01Ib'\x8D\0\x82\x11\x15a\x01\x95b\0\x08eV[B\x90\x91\x01a\x01@\x81\x90R\x01a\x01`R\x84Qb\0\x01k\x90`\x02\x11\x15`\xC8b\0\x08eV[b\0\x01\x83`\x08\x86Q\x11\x15`\xC9b\0\x08e` \x1B` \x1CV[b\0\x01\x99\x85b\0\x08z` \x1Bb\0\rW\x17` \x1CV[b\0\x01\xA4\x84b\0\x08\x86V[`@Qc\t\xB2v\x0F`\xE0\x1B\x81R`\0\x90`\x01`\x01`\xA0\x1B\x03\x8B\x16\x90c\t\xB2v\x0F\x90b\0\x01\xD5\x90\x8C\x90`\x04\x01b\0\x0E\xABV[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15b\0\x01\xF0W`\0\x80\xFD[PZ\xF1\x15\x80\x15b\0\x02\x05W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90b\0\x02+\x91\x90b\0\x0C\xD9V[\x90P\x89`\x01`\x01`\xA0\x1B\x03\x16cf\xA9\xC7\xD2\x82\x88\x89Q`\x01`\x01`@\x1B\x03\x81\x11\x80\x15b\0\x02VW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15b\0\x02\x81W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01b\0\x02\xA2\x93\x92\x91\x90b\0\x0E\x0FV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15b\0\x02\xBDW`\0\x80\xFD[PZ\xF1\x15\x80\x15b\0\x02\xD2W=`\0\x80>=`\0\xFD[PPP`\x01`\x01``\x1B\x03\x19``\x8C\x90\x1B\x16a\x01\x80RPa\x01\xA0\x81\x90R\x85Qa\x01\xC0R\x85Qb\0\x03\x04W`\0b\0\x03\x1BV[\x85`\0\x81Q\x81\x10b\0\x03\x12W\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x01\xE0R\x85Q`\x01\x10b\0\x03>W`\0b\0\x03UV[\x85`\x01\x81Q\x81\x10b\0\x03LW\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02\0R\x85Q`\x02\x10b\0\x03xW`\0b\0\x03\x8FV[\x85`\x02\x81Q\x81\x10b\0\x03\x86W\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02 R\x85Q`\x03\x10b\0\x03\xB2W`\0b\0\x03\xC9V[\x85`\x03\x81Q\x81\x10b\0\x03\xC0W\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02@R\x85Q`\x04\x10b\0\x03\xECW`\0b\0\x04\x03V[\x85`\x04\x81Q\x81\x10b\0\x03\xFAW\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02`R\x85Q`\x05\x10b\0\x04&W`\0b\0\x04=V[\x85`\x05\x81Q\x81\x10b\0\x044W\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02\x80R\x85Q`\x06\x10b\0\x04`W`\0b\0\x04wV[\x85`\x06\x81Q\x81\x10b\0\x04nW\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02\xA0R\x85Q`\x07\x10b\0\x04\x9AW`\0b\0\x04\xB1V[\x85`\x07\x81Q\x81\x10b\0\x04\xA8W\xFE[` \x02` \x01\x01Q[``\x1B`\x01`\x01``\x1B\x03\x19\x16a\x02\xC0R\x85Qb\0\x04\xD1W`\0b\0\x04\xF7V[b\0\x04\xF7\x86`\0\x81Q\x81\x10b\0\x04\xE3W\xFE[` \x02` \x01\x01Qb\0\x08\xF5` \x1B` \x1CV[a\x02\xE0R\x85Q`\x01\x10b\0\x05\rW`\0b\0\x05\x1FV[b\0\x05\x1F\x86`\x01\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03\0R\x85Q`\x02\x10b\0\x055W`\0b\0\x05GV[b\0\x05G\x86`\x02\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03 R\x85Q`\x03\x10b\0\x05]W`\0b\0\x05oV[b\0\x05o\x86`\x03\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03@R\x85Q`\x04\x10b\0\x05\x85W`\0b\0\x05\x97V[b\0\x05\x97\x86`\x04\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03`R\x85Q`\x05\x10b\0\x05\xADW`\0b\0\x05\xBFV[b\0\x05\xBF\x86`\x05\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03\x80R\x85Q`\x06\x10b\0\x05\xD5W`\0b\0\x05\xE7V[b\0\x05\xE7\x86`\x06\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03\xA0R\x85Q`\x07\x10b\0\x05\xFDW`\0b\0\x06\x0FV[b\0\x06\x0F\x86`\x07\x81Q\x81\x10b\0\x04\xE3W\xFE[a\x03\xC0\x81\x81RPPPPPPPPPPPPPPPPPPPP`\0\x86Q\x90Pb\0\x06G\x81\x87Qb\0\t\x97` \x1Bb\0\re\x17` \x1CV[`\0\x80`\0\x80[\x84\x81`\xFF\x16\x10\x15b\0\x06\xCDW`\0\x8A\x82`\xFF\x16\x81Q\x81\x10b\0\x06lW\xFE[` \x02` \x01\x01Q\x90Pb\0\x06\x94f#\x86\xF2o\xC1\0\0\x82\x10\x15a\x01.b\0\x08e` \x1B` \x1CV[b\0\x06\xAE\x81\x86b\0\t\xA6` \x1Bb\0\rr\x17\x90\x91\x90` \x1CV[\x94P\x82\x81\x11\x15b\0\x06\xC3W\x81`\xFF\x16\x93P\x80\x92P[P`\x01\x01b\0\x06NV[Pb\0\x06\xE6g\r\xE0\xB6\xB3\xA7d\0\0\x84\x14a\x014b\0\x08eV[a\x03\xE0\x82\x90R\x88Qb\0\x06\xFBW`\0b\0\x07\x12V[\x88`\0\x81Q\x81\x10b\0\x07\tW\xFE[` \x02` \x01\x01Q[a\x04\0R\x88Q`\x01\x10b\0\x07(W`\0b\0\x07?V[\x88`\x01\x81Q\x81\x10b\0\x076W\xFE[` \x02` \x01\x01Q[a\x04 R\x88Q`\x02\x10b\0\x07UW`\0b\0\x07lV[\x88`\x02\x81Q\x81\x10b\0\x07cW\xFE[` \x02` \x01\x01Q[a\x04@R\x88Q`\x03\x10b\0\x07\x82W`\0b\0\x07\x99V[\x88`\x03\x81Q\x81\x10b\0\x07\x90W\xFE[` \x02` \x01\x01Q[a\x04`R\x88Q`\x04\x10b\0\x07\xAFW`\0b\0\x07\xC6V[\x88`\x04\x81Q\x81\x10b\0\x07\xBDW\xFE[` \x02` \x01\x01Q[a\x04\x80R\x88Q`\x05\x10b\0\x07\xDCW`\0b\0\x07\xF3V[\x88`\x05\x81Q\x81\x10b\0\x07\xEAW\xFE[` \x02` \x01\x01Q[a\x04\xA0R\x88Q`\x06\x10b\0\x08\tW`\0b\0\x08 V[\x88`\x06\x81Q\x81\x10b\0\x08\x17W\xFE[` \x02` \x01\x01Q[a\x04\xC0R\x88Q`\x07\x10b\0\x086W`\0b\0\x08MV[\x88`\x07\x81Q\x81\x10b\0\x08DW\xFE[` \x02` \x01\x01Q[a\x04\xE0RPb\0\x0F2\x9BPPPPPPPPPPPPV[\x81b\0\x08vWb\0\x08v\x81b\0\t\xC3V[PPV[\x80b\0\x08v\x81b\0\n\x16V[b\0\x08\x9Bd\xE8\xD4\xA5\x10\0\x82\x10\x15`\xCBb\0\x08eV[b\0\x08\xB3g\x01cEx]\x8A\0\0\x82\x11\x15`\xCAb\0\x08eV[`\x07\x81\x90U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90b\0\x08\xEA\x90\x83\x90b\0\x0E\xC0V[`@Q\x80\x91\x03\x90\xA1PV[`\0\x80\x82`\x01`\x01`\xA0\x1B\x03\x16c1<\xE5g`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15b\0\t2W`\0\x80\xFD[PZ\xFA\x15\x80\x15b\0\tGW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90b\0\tm\x91\x90b\0\r\xECV[`\xFF\x16\x90P`\0b\0\t\x8C`\x12\x83b\0\n\xA3` \x1Bb\0\r\x84\x17` \x1CV[`\n\n\x94\x93PPPPV[b\0\x08v\x82\x82\x14`gb\0\x08eV[`\0\x82\x82\x01b\0\t\xBA\x84\x82\x10\x15\x83b\0\x08eV[\x90P[\x92\x91PPV[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[`\x02\x81Q\x10\x15b\0\n'Wb\0\n\xA0V[`\0\x81`\0\x81Q\x81\x10b\0\n7W\xFE[` \x02` \x01\x01Q\x90P`\0`\x01\x90P[\x82Q\x81\x10\x15b\0\n\x9DW`\0\x83\x82\x81Q\x81\x10b\0\naW\xFE[` \x02` \x01\x01Q\x90Pb\0\n\x92\x81`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x10`eb\0\x08e` \x1B` \x1CV[\x91P`\x01\x01b\0\nHV[PP[PV[`\0b\0\n\xB5\x83\x83\x11\x15`\x01b\0\x08eV[P\x90\x03\x90V[\x82\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x90`\0R` `\0 \x90`\x1F\x01` \x90\x04\x81\x01\x92\x82`\x1F\x10b\0\n\xFEW\x80Q`\xFF\x19\x16\x83\x80\x01\x17\x85Ub\0\x0B.V[\x82\x80\x01`\x01\x01\x85U\x82\x15b\0\x0B.W\x91\x82\x01[\x82\x81\x11\x15b\0\x0B.W\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90b\0\x0B\x11V[Pb\0\x0B<\x92\x91Pb\0\x0B@V[P\x90V[[\x80\x82\x11\x15b\0\x0B<W`\0\x81U`\x01\x01b\0\x0BAV[\x80Qb\0\t\xBD\x81b\0\x0F\x1CV[`\0\x82`\x1F\x83\x01\x12b\0\x0BuW\x80\x81\xFD[\x81Qb\0\x0B\x8Cb\0\x0B\x86\x82b\0\x0E\xF0V[b\0\x0E\xC9V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15b\0\x0B\xAEW`\0\x80\xFD[`\0[\x84\x81\x10\x15b\0\x0B\xDAW\x81Qb\0\x0B\xC7\x81b\0\x0F\x1CV[\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01b\0\x0B\xB1V[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12b\0\x0B\xF6W\x80\x81\xFD[\x81Qb\0\x0C\x07b\0\x0B\x86\x82b\0\x0E\xF0V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15b\0\x0C)W`\0\x80\xFD[`\0[\x84\x81\x10\x15b\0\x0B\xDAW\x81Q\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01b\0\x0C,V[`\0\x82`\x1F\x83\x01\x12b\0\x0C[W\x80\x81\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15b\0\x0CqW\x81\x82\xFD[` b\0\x0C\x87`\x1F\x83\x01`\x1F\x19\x16\x82\x01b\0\x0E\xC9V[\x92P\x81\x83R\x84\x81\x83\x86\x01\x01\x11\x15b\0\x0C\x9EW`\0\x80\xFD[`\0[\x82\x81\x10\x15b\0\x0C\xBEW\x84\x81\x01\x82\x01Q\x84\x82\x01\x83\x01R\x81\x01b\0\x0C\xA1V[\x82\x81\x11\x15b\0\x0C\xD0W`\0\x82\x84\x86\x01\x01R[PPP\x92\x91PPV[`\0` \x82\x84\x03\x12\x15b\0\x0C\xEBW\x80\x81\xFD[PQ\x91\x90PV[`\0\x80`\0\x80`\0\x80`\0\x80`\0a\x01 \x8A\x8C\x03\x12\x15b\0\r\x11W\x84\x85\xFD[b\0\r\x1D\x8B\x8Bb\0\x0BWV[` \x8B\x01Q\x90\x99P`\x01`\x01`@\x1B\x03\x80\x82\x11\x15b\0\r:W\x86\x87\xFD[b\0\rH\x8D\x83\x8E\x01b\0\x0CJV[\x99P`@\x8C\x01Q\x91P\x80\x82\x11\x15b\0\r^W\x86\x87\xFD[b\0\rl\x8D\x83\x8E\x01b\0\x0CJV[\x98P``\x8C\x01Q\x91P\x80\x82\x11\x15b\0\r\x82W\x86\x87\xFD[b\0\r\x90\x8D\x83\x8E\x01b\0\x0BdV[\x97P`\x80\x8C\x01Q\x91P\x80\x82\x11\x15b\0\r\xA6W\x86\x87\xFD[Pb\0\r\xB5\x8C\x82\x8D\x01b\0\x0B\xE5V[\x95PP`\xA0\x8A\x01Q\x93P`\xC0\x8A\x01Q\x92P`\xE0\x8A\x01Q\x91Pb\0\r\xDD\x8Ba\x01\0\x8C\x01b\0\x0BWV[\x90P\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[`\0` \x82\x84\x03\x12\x15b\0\r\xFEW\x80\x81\xFD[\x81Q`\xFF\x81\x16\x81\x14b\0\t\xBAW\x81\x82\xFD[`\0``\x82\x01\x85\x83R` ``\x81\x85\x01R\x81\x86Q\x80\x84R`\x80\x86\x01\x91P\x82\x88\x01\x93P\x84[\x81\x81\x10\x15b\0\x0E[Wb\0\x0EH\x85Qb\0\x0F\x10V[\x83R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01b\0\x0E3V[PP\x84\x81\x03`@\x86\x01R\x85Q\x80\x82R\x90\x82\x01\x92P\x81\x86\x01\x90\x84[\x81\x81\x10\x15b\0\x0E\x9DWb\0\x0E\x8A\x83Qb\0\x0F\x10V[\x85R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01b\0\x0EuV[P\x92\x98\x97PPPPPPPPV[` \x81\x01`\x03\x83\x10b\0\x0E\xBAW\xFE[\x91\x90R\x90V[\x90\x81R` \x01\x90V[`@Q\x81\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15b\0\x0E\xE8W`\0\x80\xFD[`@R\x91\x90PV[`\0`\x01`\x01`@\x1B\x03\x82\x11\x15b\0\x0F\x06W\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\n\xA0W`\0\x80\xFD[`\x80Q`\xA0Q``\x1C`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa\x01\x80Q``\x1Ca\x01\xA0Qa\x01\xC0Qa\x01\xE0Q``\x1Ca\x02\0Q``\x1Ca\x02 Q``\x1Ca\x02@Q``\x1Ca\x02`Q``\x1Ca\x02\x80Q``\x1Ca\x02\xA0Q``\x1Ca\x02\xC0Q``\x1Ca\x02\xE0Qa\x03\0Qa\x03 Qa\x03@Qa\x03`Qa\x03\x80Qa\x03\xA0Qa\x03\xC0Qa\x03\xE0Qa\x04\0Qa\x04 Qa\x04@Qa\x04`Qa\x04\x80Qa\x04\xA0Qa\x04\xC0Qa\x04\xE0QaGnb\0\x11H`\09\x80a\x1E\xC5R\x80a(WRP\x80a\x1E\x82R\x80a'\xF6RP\x80a\x1E?R\x80a'\x95RP\x80a\x1D\xFCR\x80a'4RP\x80a\x1D\xB9R\x80a&\xD3RP\x80a\x1DvR\x80a&rRP\x80a\x1D3R\x80a&\x11RP\x80a\x1C\xF0R\x80a%\xB0RP\x80a\"\xD0R\x80a#\x04R\x80a#@RP\x80a\x16(R\x80a\x1B\x1ERP\x80a\x15\xE5R\x80a\x1A\xBDRP\x80a\x15\xA2R\x80a\x1A\\RP\x80a\x15_R\x80a\x19\xFBRP\x80a\x15\x1CR\x80a\x19\x9ARP\x80a\x14\xD9R\x80a\x199RP\x80a\x14\x96R\x80a\x18\xD8RP\x80a\x14ER\x80a\x18wRP\x80a\x1A\xE3R\x80a(\x1CRP\x80a\x1A\x82R\x80a'\xBBRP\x80a\x1A!R\x80a'ZRP\x80a\x19\xC0R\x80a&\xF9RP\x80a\x19_R\x80a&\x98RP\x80a\x18\xFER\x80a&7RP\x80a\x18\x9DR\x80a%\xD6RP\x80a\x18<R\x80a%uRP\x80a\x11\x02RP\x80a\x05\xD7RP\x80a\x085RP\x80a\x0E\xF1RP\x80a\x0E\xCDRP\x80a\n\xB5RP\x80a\x0F\xF4RP\x80a\x106RP\x80a\x10\x15RP\x80a\x08\x11RP\x80a\x07\x9BRPaGn`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\xF0W`\x005`\xE0\x1C\x80c~\xCE\xBE\0\x11a\x01\x0FW\x80c\xA9\x05\x9C\xBB\x11a\0\xA2W\x80c\xD5\xC0\x96\xC4\x11a\0qW\x80c\xD5\xC0\x96\xC4\x14a\x03\xE6W\x80c\xD7=\xD6#\x14a\x03\xF9W\x80c\xDDb\xED>\x14a\x04\x0CW\x80c\xF8\x9F'\xED\x14a\x04\x1FWa\x01\xF0V[\x80c\xA9\x05\x9C\xBB\x14a\x03\xB0W\x80c\xAA\xAB\xAD\xC5\x14a\x03\xC3W\x80c\xC0\xFF\x1A\x15\x14a\x03\xCBW\x80c\xD5\x05\xAC\xCF\x14a\x03\xD3Wa\x01\xF0V[\x80c\x8D\x92\x8A\xF8\x11a\0\xDEW\x80c\x8D\x92\x8A\xF8\x14a\x03\x85W\x80c\x95\xD8\x9BA\x14a\x03\x8DW\x80c\x9B\x02\xCD\xDE\x14a\x03\x95W\x80c\x9D,\x11\x0C\x14a\x03\x9DWa\x01\xF0V[\x80c~\xCE\xBE\0\x14a\x037W\x80c\x85\x1C\x1B\xB3\x14a\x03JW\x80c\x87\xECh\x17\x14a\x03]W\x80c\x89= \xE8\x14a\x03pWa\x01\xF0V[\x80c8\xE9\x92.\x11a\x01\x87W\x80cf\x18\x84c\x11a\x01VW\x80cf\x18\x84c\x14a\x02\xE8W\x80cg\x9A\xEF\xCE\x14a\x02\xFBW\x80cp\xA0\x821\x14a\x03\x03W\x80ct\xF3\xB0\t\x14a\x03\x16Wa\x01\xF0V[\x80c8\xE9\x92.\x14a\x02\xA4W\x80c8\xFF\xF2\xD0\x14a\x02\xB7W\x80cU\xC6v(\x14a\x02\xBFW\x80c`(\xBF\xD4\x14a\x02\xC7Wa\x01\xF0V[\x80c\x1C\r\xE0Q\x11a\x01\xC3W\x80c\x1C\r\xE0Q\x14a\x02]W\x80c#\xB8r\xDD\x14a\x02tW\x80c1<\xE5g\x14a\x02\x87W\x80c6D\xE5\x15\x14a\x02\x9CWa\x01\xF0V[\x80c\x06\xFD\xDE\x03\x14a\x01\xF5W\x80c\t^\xA7\xB3\x14a\x02\x13W\x80c\x16\xC3\x8B<\x14a\x023W\x80c\x18\x16\r\xDD\x14a\x02HW[`\0\x80\xFD[a\x01\xFDa\x044V[`@Qa\x02\n\x91\x90aFGV[`@Q\x80\x91\x03\x90\xF3[a\x02&a\x02!6`\x04a@\x1CV[a\x04\xCBV[`@Qa\x02\n\x91\x90aE~V[a\x02Fa\x02A6`\x04aA\x13V[a\x04\xE2V[\0[a\x02Pa\x04\xF6V[`@Qa\x02\n\x91\x90aE\xA1V[a\x02ea\x04\xFCV[`@Qa\x02\n\x93\x92\x91\x90aE\x89V[a\x02&a\x02\x826`\x04a?gV[a\x05%V[a\x02\x8Fa\x05\xA8V[`@Qa\x02\n\x91\x90aF\xB3V[a\x02Pa\x05\xADV[a\x02Fa\x02\xB26`\x04aD\x9DV[a\x05\xBCV[a\x02Pa\x05\xD5V[a\x02Pa\x05\xF9V[a\x02\xDAa\x02\xD56`\x04aAKV[a\x05\xFFV[`@Qa\x02\n\x92\x91\x90aF\x9AV[a\x02&a\x02\xF66`\x04a@\x1CV[a\x066V[a\x02Pa\x06\x90V[a\x02Pa\x03\x116`\x04a?\x13V[a\x06\xBBV[a\x03)a\x03$6`\x04aAKV[a\x06\xDAV[`@Qa\x02\n\x92\x91\x90aEYV[a\x02Pa\x03E6`\x04a?\x13V[a\x07|V[a\x02Pa\x03X6`\x04aBHV[a\x07\x97V[a\x02\xDAa\x03k6`\x04aAKV[a\x07\xE9V[a\x03xa\x08\x0FV[`@Qa\x02\n\x91\x90aE2V[a\x03xa\x083V[a\x01\xFDa\x08WV[a\x02Pa\x08\xB8V[a\x02Pa\x03\xAB6`\x04aC\xA1V[a\x08\xBEV[a\x02&a\x03\xBE6`\x04a@\x1CV[a\t\xA5V[a\x03xa\t\xB2V[a\x02Pa\t\xBCV[a\x02Fa\x03\xE16`\x04a?\xA7V[a\n\x80V[a\x03)a\x03\xF46`\x04aAKV[a\x0B\xC9V[a\x02&a\x04\x076`\x04a@\x1CV[a\x0C\xECV[a\x02Pa\x04\x1A6`\x04a?/V[a\r\"V[a\x04'a\rMV[`@Qa\x02\n\x91\x90aEFV[`\x03\x80T`@\x80Q` `\x1F`\x02`\0\x19a\x01\0`\x01\x88\x16\x15\x02\x01\x90\x95\x16\x94\x90\x94\x04\x93\x84\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x82\x81R``\x93\x90\x92\x90\x91\x83\x01\x82\x82\x80\x15a\x04\xC0W\x80`\x1F\x10a\x04\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xC0V[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P[\x90V[`\0a\x04\xD83\x84\x84a\r\x9AV[P`\x01[\x92\x91PPV[a\x04\xEAa\x0E\x02V[a\x04\xF3\x81a\x0E0V[PV[`\x02T\x90V[`\0\x80`\0a\x05\ta\x0E\xAEV[\x15\x92Pa\x05\x14a\x0E\xCBV[\x91Pa\x05\x1Ea\x0E\xEFV[\x90P\x90\x91\x92V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 3\x80\x85R\x92R\x82 T\x91\x92a\x05c\x91\x14\x80a\x05[WP\x83\x82\x10\x15[a\x01\x97a\x0F\x13V[a\x05n\x85\x85\x85a\x0F!V[3`\x01`\x01`\xA0\x1B\x03\x86\x16\x14\x80\x15\x90a\x05\x89WP`\0\x19\x81\x14\x15[\x15a\x05\x9BWa\x05\x9B\x853\x85\x84\x03a\r\x9AV[`\x01\x91PP[\x93\x92PPPV[`\x12\x90V[`\0a\x05\xB7a\x0F\xF0V[\x90P\x90V[a\x05\xC4a\x0E\x02V[a\x05\xCCa\x10\x8DV[a\x04\xF3\x81a\x10\xA2V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\x07T\x90V[`\0``a\x06\x15\x86Qa\x06\x10a\x11\0V[a\reV[a\x06*\x89\x89\x89\x89\x89\x89\x89a\x11$a\x11\xECa\x12RV[\x97P\x97\x95PPPPPPV[3`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x84R\x90\x91R\x81 T\x80\x83\x10a\x06rWa\x06m3\x85`\0a\r\x9AV[a\x06\x86V[a\x06\x863\x85a\x06\x81\x84\x87a\r\x84V[a\r\x9AV[P`\x01\x93\x92PPPV[`\0a\x05\xB7a\x06\x9Da\x04\xF6V[a\x06\xB5a\x06\xA8a\t\xBCV[a\x06\xB0a\x11\0V[a\x13tV[\x90a\x13\x98V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R` \x81\x90R`@\x90 T[\x91\x90PV[``\x80\x88a\x07\x04a\x06\xE9a\x083V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14`\xCDa\x0F\x13V[a\x07\x19a\x07\x0Fa\x05\xD5V[\x82\x14a\x01\xF4a\x0F\x13V[``a\x07#a\x13\xE9V[\x90Pa\x07/\x88\x82a\x16fV[`\0``\x80a\x07C\x8E\x8E\x8E\x8E\x8E\x8E\x8Ea\x11$V[\x92P\x92P\x92Pa\x07S\x8D\x84a\x16\xC7V[a\x07]\x82\x85a\x11\xECV[a\x07g\x81\x85a\x11\xECV[\x90\x95P\x93PPP[P\x97P\x97\x95PPPPPPV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x05` R`@\x90 T\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x07\xCC\x92\x91\x90aD\xEFV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\0``a\x07\xFA\x86Qa\x06\x10a\x11\0V[a\x06*\x89\x89\x89\x89\x89\x89\x89a\x17Za\x17\xD7a\x12RV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\x04\x80T`@\x80Q` `\x1F`\x02`\0\x19a\x01\0`\x01\x88\x16\x15\x02\x01\x90\x95\x16\x94\x90\x94\x04\x93\x84\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x82\x81R``\x93\x90\x92\x90\x91\x83\x01\x82\x82\x80\x15a\x04\xC0W\x80`\x1F\x10a\x04\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xC0V[`\x08T\x90V[`\0\x80a\x08\xCE\x85` \x01Qa\x188V[\x90P`\0a\x08\xDF\x86`@\x01Qa\x188V[\x90P`\0\x86Q`\x01\x81\x11\x15a\x08\xF0W\xFE[\x14\x15a\tVWa\t\x03\x86``\x01Qa\x1BMV[``\x87\x01Ra\t\x12\x85\x83a\x1BqV[\x94Pa\t\x1E\x84\x82a\x1BqV[\x93Pa\t.\x86``\x01Q\x83a\x1BqV[``\x87\x01R`\0a\t@\x87\x87\x87a\x1B}V[\x90Pa\tL\x81\x83a\x1B\xB8V[\x93PPPPa\x05\xA1V[a\t`\x85\x83a\x1BqV[\x94Pa\tl\x84\x82a\x1BqV[\x93Pa\t|\x86``\x01Q\x82a\x1BqV[``\x87\x01R`\0a\t\x8E\x87\x87\x87a\x1B\xC4V[\x90Pa\t\x9A\x81\x84a\x1B\xF7V[\x90Pa\tL\x81a\x1C\x03V[`\0a\x04\xD83\x84\x84a\x0F!V[`\0a\x05\xB7a\x1C\x1AV[`\0``a\t\xC8a\x083V[`\x01`\x01`\xA0\x1B\x03\x16c\xF9MFha\t\xDEa\x05\xD5V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xFA\x91\x90aE\xA1V[`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\n\x12W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\n&W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\nN\x91\x90\x81\x01\x90a@GV[P\x91PPa\nc\x81a\n^a\x13\xE9V[a\x16fV[``a\nma\x1C\x94V[\x90Pa\ny\x81\x83a\x1E\xF1V[\x92PPP\x90V[a\n\x8E\x84B\x11\x15`\xD1a\x0F\x13V[`\x01`\x01`\xA0\x1B\x03\x87\x16`\0\x90\x81R`\x05` \x90\x81R`@\x80\x83 T\x90Q\x90\x92\x91a\n\xE5\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x8C\x91\x8C\x91\x8C\x91\x88\x91\x8D\x91\x01aE\xC9V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0a\x0B\x08\x82a\x1FcV[\x90P`\0`\x01\x82\x88\x88\x88`@Q`\0\x81R` \x01`@R`@Qa\x0B/\x94\x93\x92\x91\x90aF)V[` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\x0BQW=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91Pa\x0B\x93\x90P`\x01`\x01`\xA0\x1B\x03\x82\x16\x15\x80\x15\x90a\x0B\x8BWP\x8B`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14[a\x01\xF8a\x0F\x13V[`\x01`\x01`\xA0\x1B\x03\x8B\x16`\0\x90\x81R`\x05` R`@\x90 `\x01\x85\x01\x90Ua\x0B\xBC\x8B\x8B\x8Ba\r\x9AV[PPPPPPPPPPPV[``\x80\x88a\x0B\xD8a\x06\xE9a\x083V[a\x0B\xE3a\x07\x0Fa\x05\xD5V[``a\x0B\xEDa\x13\xE9V[\x90Pa\x0B\xF7a\x04\xF6V[a\x0C\x9DW`\0``a\x0C\x0B\x8D\x8D\x8D\x8Aa\x1F\x7FV[\x91P\x91Pa\x0C b\x0FB@\x83\x10\x15`\xCCa\x0F\x13V[a\x0C.`\0b\x0FB@a \x1AV[a\x0C=\x8Bb\x0FB@\x84\x03a \x1AV[a\x0CG\x81\x84a\x17\xD7V[\x80a\x0CPa\x11\0V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x0CfW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0C\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x95P\x95PPPPa\x07oV[a\x0C\xA7\x88\x82a\x16fV[`\0``\x80a\x0C\xBB\x8E\x8E\x8E\x8E\x8E\x8E\x8Ea\x17ZV[\x92P\x92P\x92Pa\x0C\xCB\x8C\x84a \x1AV[a\x0C\xD5\x82\x85a\x17\xD7V[a\x0C\xDF\x81\x85a\x11\xECV[\x90\x95P\x93Pa\x07o\x91PPV[3`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91a\x04\xD8\x91\x85\x90a\x06\x81\x90\x86a\rrV[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[``a\x05\xB7a\x1C\x94V[\x80a\ra\x81a \xB0V[PPV[a\ra\x81\x83\x14`ga\x0F\x13V[`\0\x82\x82\x01a\x05\xA1\x84\x82\x10\x15\x83a\x0F\x13V[`\0a\r\x94\x83\x83\x11\x15`\x01a\x0F\x13V[P\x90\x03\x90V[`\x01`\x01`\xA0\x1B\x03\x80\x84\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 \x94\x87\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x84\x90UQ\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x90a\r\xF5\x90\x85\x90aE\xA1V[`@Q\x80\x91\x03\x90\xA3PPPV[`\0a\x0E\x19`\x005`\x01`\x01`\xE0\x1B\x03\x19\x16a\x07\x97V[\x90Pa\x04\xF3a\x0E(\x823a!)V[a\x01\x91a\x0F\x13V[\x80\x15a\x0EPWa\x0EKa\x0EAa\x0E\xCBV[B\x10a\x01\x93a\x0F\x13V[a\x0EeV[a\x0Eea\x0E[a\x0E\xEFV[B\x10a\x01\xA9a\x0F\x13V[`\x06\x80T`\xFF\x19\x16\x82\x15\x15\x17\x90U`@Q\x7F\x9E:^7\"E2\xDE\xA6{\x89\xFA\xCE\x18W\x03s\x8A\"\x8An\x8A#\xDE\xE5F\x96\x01\x80\xD3\xBEd\x90a\x0E\xA3\x90\x83\x90aE~V[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x0E\xB8a\x0E\xEFV[B\x11\x80a\x05\xB7WPP`\x06T`\xFF\x16\x15\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x81a\raWa\ra\x81a\"\x19V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 Ta\x0FI\x82\x82\x10\x15a\x01\x96a\x0F\x13V[a\x0F``\x01`\x01`\xA0\x1B\x03\x84\x16\x15\x15a\x01\x99a\x0F\x13V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R Ta\x0F\x90\x90\x83a\rrV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x81\x81R` \x81\x90R`@\x90\x81\x90 \x93\x90\x93U\x91Q\x90\x86\x16\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90a\x0F\xE2\x90\x86\x90aE\xA1V[`@Q\x80\x91\x03\x90\xA3PPPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x10]a\"lV[0`@Q` \x01a\x10r\x95\x94\x93\x92\x91\x90aE\xFDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[a\x10\xA0a\x10\x98a\x0E\xAEV[a\x01\x92a\x0F\x13V[V[a\x10\xB5d\xE8\xD4\xA5\x10\0\x82\x10\x15`\xCBa\x0F\x13V[a\x10\xCBg\x01cEx]\x8A\0\0\x82\x11\x15`\xCAa\x0F\x13V[`\x07\x81\x90U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90a\x0E\xA3\x90\x83\x90aE\xA1V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[`\0``\x80``a\x113a\x1C\x94V[\x90Pa\x11=a\x0E\xAEV[\x15a\x11tW`\0a\x11N\x82\x8Aa\x1E\xF1V[\x90Pa\x11_\x89\x83`\x08T\x84\x8Ba\"pV[\x92Pa\x11n\x89\x84a\r\x84a#\x80V[Pa\x11\xC0V[a\x11|a\x11\0V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x11\x92W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\xBCW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P[a\x11\xCB\x88\x82\x87a#\xEBV[\x90\x94P\x92Pa\x11\xDB\x88\x84\x83a$XV[`\x08UP\x97P\x97P\x97\x94PPPPPV[`\0[a\x11\xF7a\x11\0V[\x81\x10\x15a\x12MWa\x12.\x83\x82\x81Q\x81\x10a\x12\rW\xFE[` \x02` \x01\x01Q\x83\x83\x81Q\x81\x10a\x12!W\xFE[` \x02` \x01\x01Qa$qV[\x83\x82\x81Q\x81\x10a\x12:W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\xEFV[PPPV[30\x14a\x13\x10W`\x000`\x01`\x01`\xA0\x1B\x03\x16`\x006`@Qa\x12v\x92\x91\x90aE\x07V[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x12\xB3W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x12\xB8V[``\x91P[PP\x90P\x80`\0\x81\x14a\x12\xC7W\xFE[`\x04`\0\x80>`\0Q`\x01`\x01`\xE0\x1B\x03\x19\x16cC\xAD\xBA\xFB`\xE0\x1B\x81\x14a\x12\xF2W=`\0\x80>=`\0\xFD[P` `\x04`\0>`@` R`$=\x03`$`@>`\x1C=\x01`\0\xF3[``a\x13\x1Aa\x13\xE9V[\x90Pa\x13&\x87\x82a\x16fV[`\0``a\x13=\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8Cc\xFF\xFF\xFF\xFF\x16V[P\x91P\x91Pa\x13P\x81\x84\x86c\xFF\xFF\xFF\xFF\x16V[\x80Q`\x1F\x19\x82\x01\x83\x90RcC\xAD\xBA\xFB`?\x19\x83\x01R` \x02`#\x19\x82\x01`D\x82\x01\x81\xFD[`\0\x82\x82\x02a\x05\xA1\x84\x15\x80a\x13\x91WP\x83\x85\x83\x81a\x13\x8EW\xFE[\x04\x14[`\x03a\x0F\x13V[`\0a\x13\xA7\x82\x15\x15`\x04a\x0F\x13V[\x82a\x13\xB4WP`\0a\x04\xDCV[g\r\xE0\xB6\xB3\xA7d\0\0\x83\x81\x02\x90a\x13\xD7\x90\x85\x83\x81a\x13\xCEW\xFE[\x04\x14`\x05a\x0F\x13V[\x82\x81\x81a\x13\xE0W\xFE[\x04\x91PPa\x04\xDCV[```\0a\x13\xF5a\x11\0V[\x90P``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x14\x10W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14:W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x81\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\0\x81Q\x81\x10a\x14qW\xFE[` \x02` \x01\x01\x81\x81RPPa\x14\x8BV[\x91Pa\x04\xC8\x90PV[`\x01\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x01\x81Q\x81\x10a\x14\xC2W\xFE[` \x02` \x01\x01\x81\x81RPP`\x02\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x02\x81Q\x81\x10a\x15\x05W\xFE[` \x02` \x01\x01\x81\x81RPP`\x03\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x03\x81Q\x81\x10a\x15HW\xFE[` \x02` \x01\x01\x81\x81RPP`\x04\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x04\x81Q\x81\x10a\x15\x8BW\xFE[` \x02` \x01\x01\x81\x81RPP`\x05\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x05\x81Q\x81\x10a\x15\xCEW\xFE[` \x02` \x01\x01\x81\x81RPP`\x06\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x06\x81Q\x81\x10a\x16\x11W\xFE[` \x02` \x01\x01\x81\x81RPP`\x07\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x07\x81Q\x81\x10a\x16TW\xFE[` \x02` \x01\x01\x81\x81RPP\x91PP\x90V[`\0[a\x16qa\x11\0V[\x81\x10\x15a\x12MWa\x16\xA8\x83\x82\x81Q\x81\x10a\x16\x87W\xFE[` \x02` \x01\x01Q\x83\x83\x81Q\x81\x10a\x16\x9BW\xFE[` \x02` \x01\x01Qa\x13tV[\x83\x82\x81Q\x81\x10a\x16\xB4W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x16iV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R` \x81\x90R`@\x90 Ta\x16\xEF\x82\x82\x10\x15a\x01\x96a\x0F\x13V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 \x82\x82\x03\x90U`\x02Ta\x17\x19\x90\x83a\r\x84V[`\x02U`@Q`\0\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90a\r\xF5\x90\x86\x90aE\xA1V[`\0``\x80a\x17ga\x10\x8DV[``a\x17qa\x1C\x94V[\x90P`\0a\x17\x7F\x82\x8Aa\x1E\xF1V[\x90P``a\x17\x92\x8A\x84`\x08T\x85\x8Ca\"pV[\x90Pa\x17\xA1\x8A\x82a\r\x84a#\x80V[`\0``a\x17\xB0\x8C\x86\x8Ba$\x91V[\x91P\x91Pa\x17\xBF\x8C\x82\x87a$\xEBV[`\x08U\x90\x9E\x90\x9DP\x90\x9BP\x99PPPPPPPPPPV[`\0[a\x17\xE2a\x11\0V[\x81\x10\x15a\x12MWa\x18\x19\x83\x82\x81Q\x81\x10a\x17\xF8W\xFE[` \x02` \x01\x01Q\x83\x83\x81Q\x81\x10a\x18\x0CW\xFE[` \x02` \x01\x01Qa$\xFAV[\x83\x82\x81Q\x81\x10a\x18%W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17\xDAV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x18\x9BWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x18\xFCWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x19]WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x19\xBEWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x1A\x1FWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x1A\x80WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x1A\xE1WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x1BBWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[a\x06\xD5a\x015a\"\x19V[`\0\x80a\x1Be`\x07T\x84a%-\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90Pa\x05\xA1\x83\x82a\r\x84V[`\0a\x05\xA1\x83\x83a\x13tV[`\0a\x1B\x87a\x10\x8DV[a\x1B\xB0\x83a\x1B\x98\x86` \x01Qa%qV[\x84a\x1B\xA6\x88`@\x01Qa%qV[\x88``\x01Qa({V[\x94\x93PPPPV[`\0a\x05\xA1\x83\x83a$qV[`\0a\x1B\xCEa\x10\x8DV[a\x1B\xB0\x83a\x1B\xDF\x86` \x01Qa%qV[\x84a\x1B\xED\x88`@\x01Qa%qV[\x88``\x01Qa(\xF6V[`\0a\x05\xA1\x83\x83a$\xFAV[`\0a\x04\xDCa\x1C\x13`\x07Ta)lV[\x83\x90a)\x92V[`\0a\x1C$a\x083V[`\x01`\x01`\xA0\x1B\x03\x16c\xAA\xAB\xAD\xC5`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\\W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1CpW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB7\x91\x90aBpV[```\0a\x1C\xA0a\x11\0V[\x90P``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x1C\xBBW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1C\xE5W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x81\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\0\x81Q\x81\x10a\x1D\x1CW\xFE[` \x02` \x01\x01\x81\x81RPP`\x01\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x01\x81Q\x81\x10a\x1D_W\xFE[` \x02` \x01\x01\x81\x81RPP`\x02\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x02\x81Q\x81\x10a\x1D\xA2W\xFE[` \x02` \x01\x01\x81\x81RPP`\x03\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x03\x81Q\x81\x10a\x1D\xE5W\xFE[` \x02` \x01\x01\x81\x81RPP`\x04\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x04\x81Q\x81\x10a\x1E(W\xFE[` \x02` \x01\x01\x81\x81RPP`\x05\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x05\x81Q\x81\x10a\x1EkW\xFE[` \x02` \x01\x01\x81\x81RPP`\x06\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x06\x81Q\x81\x10a\x1E\xAEW\xFE[` \x02` \x01\x01\x81\x81RPP`\x07\x82\x11\x15a\x14\x82W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81`\x07\x81Q\x81\x10a\x16TW\xFE[g\r\xE0\xB6\xB3\xA7d\0\0`\0[\x83Q\x81\x10\x15a\x1FSWa\x1FIa\x1FB\x85\x83\x81Q\x81\x10a\x1F\x18W\xFE[` \x02` \x01\x01Q\x85\x84\x81Q\x81\x10a\x1F,W\xFE[` \x02` \x01\x01Qa)\xD4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x90a*#V[\x91P`\x01\x01a\x1E\xFDV[Pa\x04\xDC`\0\x82\x11a\x017a\x0F\x13V[`\0a\x1Fma\x0F\xF0V[\x82`@Q` \x01a\x07\xCC\x92\x91\x90aE\x17V[`\0``a\x1F\x8Ba\x10\x8DV[`\0a\x1F\x96\x84a*OV[\x90Pa\x1F\xB1`\0\x82`\x02\x81\x11\x15a\x1F\xA9W\xFE[\x14`\xCEa\x0F\x13V[``a\x1F\xBC\x85a*eV[\x90Pa\x1F\xD0a\x1F\xC9a\x11\0V[\x82Qa\reV[a\x1F\xDC\x81a\n^a\x13\xE9V[``a\x1F\xE6a\x1C\x94V[\x90P`\0a\x1F\xF4\x82\x84a\x1E\xF1V[\x90P`\0a \x04\x82a\x06\xB0a\x11\0V[`\x08\x92\x90\x92UP\x99\x91\x98P\x90\x96PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R` \x81\x90R`@\x90 Ta =\x90\x82a\rrV[`\x01`\x01`\xA0\x1B\x03\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 U`\x02Ta c\x90\x82a\rrV[`\x02U`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90a \xA4\x90\x85\x90aE\xA1V[`@Q\x80\x91\x03\x90\xA3PPV[`\x02\x81Q\x10\x15a \xBFWa\x04\xF3V[`\0\x81`\0\x81Q\x81\x10a \xCEW\xFE[` \x02` \x01\x01Q\x90P`\0`\x01\x90P[\x82Q\x81\x10\x15a\x12MW`\0\x83\x82\x81Q\x81\x10a \xF6W\xFE[` \x02` \x01\x01Q\x90Pa!\x1F\x81`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x10`ea\x0F\x13V[\x91P`\x01\x01a \xDFV[`\0s\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1B\xA1\xBA\x1Ba!Ha\x08\x0FV[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15\x80\x15a!cWPa!c\x83a*{V[\x15a!\x8BWa!pa\x08\x0FV[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa\x04\xDCV[a!\x93a\x1C\x1AV[`\x01`\x01`\xA0\x1B\x03\x16c\x9B\xE2\xA8\x84\x84\x840`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a!\xC2\x93\x92\x91\x90aE\xAAV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a!\xDAW`\0\x80\xFD[PZ\xFA\x15\x80\x15a!\xEEW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\"\x12\x91\x90aA/V[\x90Pa\x04\xDCV[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[F\x90V[``\x80a\"{a\x11\0V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\"\x91W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\"\xBBW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82a\"\xCAW\x90Pa#wV[a#=\x87\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Q\x81\x10a\"\xF9W\xFE[` \x02` \x01\x01Q\x87\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Q\x81\x10a#-W\xFE[` \x02` \x01\x01Q\x87\x87\x87a*\x95V[\x81\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Q\x81\x10a#iW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x90P[\x95\x94PPPPPV[`\0[a#\x8Ba\x11\0V[\x81\x10\x15a#\xE5Wa#\xC6\x84\x82\x81Q\x81\x10a#\xA1W\xFE[` \x02` \x01\x01Q\x84\x83\x81Q\x81\x10a#\xB5W\xFE[` \x02` \x01\x01Q\x84c\xFF\xFF\xFF\xFF\x16V[\x84\x82\x81Q\x81\x10a#\xD2W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a#\x83V[PPPPV[`\0```\0a#\xFA\x84a*OV[\x90P`\0\x81`\x02\x81\x11\x15a$\nW\xFE[\x14\x15a$%Wa$\x1B\x86\x86\x86a+\rV[\x92P\x92PPa$PV[`\x01\x81`\x02\x81\x11\x15a$3W\xFE[\x14\x15a$CWa$\x1B\x86\x85a+\xEBV[a$\x1B\x86\x86\x86a,\x1DV[P[\x93P\x93\x91PPV[`\0a$g\x84\x84a\r\x84a#\x80V[a\x1B\xB0\x82\x85a\x1E\xF1V[`\0a$\x80\x82\x15\x15`\x04a\x0F\x13V[\x81\x83\x81a$\x89W\xFE[\x04\x93\x92PPPV[`\0```\0a$\xA0\x84a*OV[\x90P`\x01\x81`\x02\x81\x11\x15a$\xB0W\xFE[\x14\x15a$\xC1Wa$\x1B\x86\x86\x86a,\x88V[`\x02\x81`\x02\x81\x11\x15a$\xCFW\xFE[\x14\x15a$\xE0Wa$\x1B\x86\x86\x86a,\xE2V[a$Na\x016a\"\x19V[`\0a$g\x84\x84a\rra#\x80V[`\0a%\t\x82\x15\x15`\x04a\x0F\x13V[\x82a%\x16WP`\0a\x04\xDCV[\x81`\x01\x84\x03\x81a%\"W\xFE[\x04`\x01\x01\x90Pa\x04\xDCV[`\0\x82\x82\x02a%G\x84\x15\x80a\x13\x91WP\x83\x85\x83\x81a\x13\x8EW\xFE[\x80a%VW`\0\x91PPa\x04\xDCV[g\r\xE0\xB6\xB3\xA7d\0\0`\0\x19\x82\x01[\x04`\x01\x01\x91PPa\x04\xDCV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a%\xD4WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a&5WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a&\x96WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a&\xF7WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a'XWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a'\xB9WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a(\x1AWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x1BBWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06\xD5V[`\0a(\x9Da(\x92\x87g\x04)\xD0i\x18\x9E\0\0a*#V[\x83\x11\x15a\x010a\x0F\x13V[`\0a(\xA9\x87\x84a\rrV[\x90P`\0a(\xB7\x88\x83a)\x92V[\x90P`\0a(\xC5\x88\x87a\x13\x98V[\x90P`\0a(\xD3\x83\x83a-\x8AV[\x90Pa(\xE8a(\xE1\x82a)lV[\x89\x90a*#V[\x9A\x99PPPPPPPPPPV[`\0a)\x18a)\r\x85g\x04)\xD0i\x18\x9E\0\0a*#V[\x83\x11\x15a\x011a\x0F\x13V[`\0a).a)'\x86\x85a\r\x84V[\x86\x90a)\x92V[\x90P`\0a)<\x85\x88a)\x92V[\x90P`\0a)J\x83\x83a-\x8AV[\x90P`\0a)`\x82g\r\xE0\xB6\xB3\xA7d\0\0a\r\x84V[\x90Pa(\xE8\x8A\x82a%-V[`\0g\r\xE0\xB6\xB3\xA7d\0\0\x82\x10a)\x84W`\0a\x04\xDCV[Pg\r\xE0\xB6\xB3\xA7d\0\0\x03\x90V[`\0a)\xA1\x82\x15\x15`\x04a\x0F\x13V[\x82a)\xAEWP`\0a\x04\xDCV[g\r\xE0\xB6\xB3\xA7d\0\0\x83\x81\x02\x90a)\xC8\x90\x85\x83\x81a\x13\xCEW\xFE[\x82`\x01\x82\x03\x81a%eW\xFE[`\0\x80a)\xE1\x84\x84a-\xB6V[\x90P`\0a)\xFBa)\xF4\x83a'\x10a%-V[`\x01a\rrV[\x90P\x80\x82\x10\x15a*\x10W`\0\x92PPPa\x04\xDCV[a*\x1A\x82\x82a\r\x84V[\x92PPPa\x04\xDCV[`\0\x82\x82\x02a*=\x84\x15\x80a\x13\x91WP\x83\x85\x83\x81a\x13\x8EW\xFE[g\r\xE0\xB6\xB3\xA7d\0\0\x90\x04\x93\x92PPPV[`\0\x81\x80` \x01\x90Q\x81\x01\x90a\x04\xDC\x91\x90aB\x8CV[``\x81\x80` \x01\x90Q\x81\x01\x90a\x05\xA1\x91\x90aCRV[`\0a*\x8Dc\x1Ct\xC9\x17`\xE1\x1Ba\x07\x97V[\x90\x91\x14\x91\x90PV[`\0\x83\x83\x11a*\xA6WP`\0a#wV[`\0a*\xB2\x85\x85a)\x92V[\x90P`\0a*\xC8g\r\xE0\xB6\xB3\xA7d\0\0\x88a\x13\x98V[\x90Pa*\xDC\x82g\t\xB6\xE6J\x8E\xC6\0\0a.\xC1V[\x91P`\0a*\xEA\x83\x83a-\x8AV[\x90P`\0a+\x01a*\xFA\x83a)lV[\x8B\x90a*#V[\x90Pa(\xE8\x81\x87a*#V[`\0``a+\x19a\x10\x8DV[`\0\x80a+%\x85a.\xD8V[\x91P\x91Pa+=a+4a\x11\0V[\x82\x10`da\x0F\x13V[``a+Ga\x11\0V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a+]W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a+\x87W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90Pa+\xC6\x88\x83\x81Q\x81\x10a+\x99W\xFE[` \x02` \x01\x01Q\x88\x84\x81Q\x81\x10a+\xADW\xFE[` \x02` \x01\x01Q\x85a+\xBEa\x04\xF6V[`\x07Ta.\xFAV[\x81\x83\x81Q\x81\x10a+\xD2W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x91\x97\x91\x96P\x90\x94PPPPPV[`\0```\0a+\xFA\x84a/\xB7V[\x90P``a,\x10\x86\x83a,\x0Ba\x04\xF6V[a/\xCDV[\x91\x96\x91\x95P\x90\x93PPPPV[`\0``a,)a\x10\x8DV[```\0a,6\x85a0\x7FV[\x91P\x91Pa,G\x82Qa\x06\x10a\x11\0V[a,S\x82a\n^a\x13\xE9V[`\0a,k\x88\x88\x85a,ca\x04\xF6V[`\x07Ta0\x97V[\x90Pa,{\x82\x82\x11\x15`\xCFa\x0F\x13V[\x97\x91\x96P\x90\x94PPPPPV[`\0``\x80`\0a,\x98\x85a0\x7FV[\x91P\x91Pa,\xAEa,\xA7a\x11\0V[\x83Qa\reV[a,\xBA\x82a\n^a\x13\xE9V[`\0a,\xD2\x88\x88\x85a,\xCAa\x04\xF6V[`\x07Ta2\xBCV[\x90Pa,{\x82\x82\x10\x15`\xD0a\x0F\x13V[`\0```\0\x80a,\xF2\x85a.\xD8V[\x91P\x91Pa-\x01a+4a\x11\0V[``a-\x0Ba\x11\0V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a-!W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a-KW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90Pa+\xC6\x88\x83\x81Q\x81\x10a-]W\xFE[` \x02` \x01\x01Q\x88\x84\x81Q\x81\x10a-qW\xFE[` \x02` \x01\x01Q\x85a-\x82a\x04\xF6V[`\x07Ta4\xCDV[`\0\x80a-\x97\x84\x84a-\xB6V[\x90P`\0a-\xAAa)\xF4\x83a'\x10a%-V[\x90Pa#w\x82\x82a\rrV[`\0\x81a-\xCCWPg\r\xE0\xB6\xB3\xA7d\0\0a\x04\xDCV[\x82a-\xD9WP`\0a\x04\xDCV[a-\xEA`\x01`\xFF\x1B\x84\x10`\x06a\x0F\x13V[\x82a.\x10w\x0B\xCEP\x86I!\x11\xAE\xA8\x8FK\xB1\xCAk\xCFXA\x81\xEA\x80Y\xF7e2\x84\x10`\x07a\x0F\x13V[\x82`\0g\x0C}q;I\xDA\0\0\x83\x13\x80\x15a.1WPg\x0FC\xFC,\x04\xEE\0\0\x83\x12[\x15a.hW`\0a.A\x84a5oV[\x90Pg\r\xE0\xB6\xB3\xA7d\0\0\x80\x82\x07\x84\x02\x05\x83g\r\xE0\xB6\xB3\xA7d\0\0\x83\x05\x02\x01\x91PPa.vV[\x81a.r\x84a6\x96V[\x02\x90P[g\r\xE0\xB6\xB3\xA7d\0\0\x90\x05a.\xAEh\x028\xFDB\xC5\xCF\x03\xFF\xFF\x19\x82\x12\x80\x15\x90a.\xA7WPh\x07\x0C\x1C\xC7;\0\xC8\0\0\x82\x13\x15[`\x08a\x0F\x13V[a.\xB7\x81a:DV[\x96\x95PPPPPPV[`\0\x81\x83\x10\x15a.\xD1W\x81a\x05\xA1V[P\x90\x91\x90PV[`\0\x80\x82\x80` \x01\x90Q\x81\x01\x90a.\xEF\x91\x90aC\x1CV[\x90\x95\x90\x94P\x92PPPV[`\0\x80a/\x11\x84a/\x0B\x81\x88a\r\x84V[\x90a)\x92V[\x90Pa/*g\t\xB6\xE6J\x8E\xC6\0\0\x82\x10\x15a\x012a\x0F\x13V[`\0a/Ha/Ag\r\xE0\xB6\xB3\xA7d\0\0\x89a\x13\x98V[\x83\x90a-\x8AV[\x90P`\0a/_a/X\x83a)lV[\x8A\x90a*#V[\x90P`\0a/l\x89a)lV[\x90P`\0a/z\x83\x83a%-V[\x90P`\0a/\x88\x84\x83a\r\x84V[\x90Pa/\xA7a/\xA0a/\x99\x8Aa)lV[\x84\x90a*#V[\x82\x90a\rrV[\x9C\x9BPPPPPPPPPPPPV[`\0\x81\x80` \x01\x90Q\x81\x01\x90a\x05\xA1\x91\x90aB\xEFV[```\0a/\xDB\x84\x84a\x13\x98V[\x90P``\x85Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a/\xF7W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a0!W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x86Q\x81\x10\x15a0uWa0V\x83\x88\x83\x81Q\x81\x10a0@W\xFE[` \x02` \x01\x01Qa*#\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82\x82\x81Q\x81\x10a0bW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a0'V[P\x95\x94PPPPPV[```\0\x82\x80` \x01\x90Q\x81\x01\x90a.\xEF\x91\x90aB\xA8V[`\0``\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a0\xB3W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a0\xDDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x88Q\x81\x10\x15a1\xA2Wa1=\x89\x82\x81Q\x81\x10a0\xFCW\xFE[` \x02` \x01\x01Qa/\x0B\x89\x84\x81Q\x81\x10a1\x13W\xFE[` \x02` \x01\x01Q\x8C\x85\x81Q\x81\x10a1'W\xFE[` \x02` \x01\x01Qa\r\x84\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x82\x81Q\x81\x10a1IW\xFE[` \x02` \x01\x01\x81\x81RPPa1\x98a1\x91\x89\x83\x81Q\x81\x10a1gW\xFE[` \x02` \x01\x01Q\x85\x84\x81Q\x81\x10a1{W\xFE[` \x02` \x01\x01Qa%-\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x90a\rrV[\x91P`\x01\x01a0\xE4V[Pg\r\xE0\xB6\xB3\xA7d\0\0`\0[\x89Q\x81\x10\x15a2\x9BW`\0\x84\x82\x81Q\x81\x10a1\xC6W\xFE[` \x02` \x01\x01Q\x84\x11\x15a2\x1DW`\0a1\xEFa1\xE3\x86a)lV[\x8D\x85\x81Q\x81\x10a0@W\xFE[\x90P`\0a2\x03\x82\x8C\x86\x81Q\x81\x10a1'W\xFE[\x90Pa2\x14a1\x91a\x1C\x13\x8Ba)lV[\x92PPPa24V[\x88\x82\x81Q\x81\x10a2)W\xFE[` \x02` \x01\x01Q\x90P[`\0a2]\x8C\x84\x81Q\x81\x10a2EW\xFE[` \x02` \x01\x01Qa\x06\xB5\x84\x8F\x87\x81Q\x81\x10a1'W\xFE[\x90Pa2\x8Fa2\x88\x8C\x85\x81Q\x81\x10a2qW\xFE[` \x02` \x01\x01Q\x83a)\xD4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x85\x90a*#V[\x93PPP`\x01\x01a1\xAFV[Pa2\xAFa2\xA8\x82a)lV[\x87\x90a%-V[\x99\x98PPPPPPPPPV[`\0``\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a2\xD8W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a3\x02W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x88Q\x81\x10\x15a3\xAAWa3b\x89\x82\x81Q\x81\x10a3!W\xFE[` \x02` \x01\x01Qa\x06\xB5\x89\x84\x81Q\x81\x10a38W\xFE[` \x02` \x01\x01Q\x8C\x85\x81Q\x81\x10a3LW\xFE[` \x02` \x01\x01Qa\rr\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x83\x82\x81Q\x81\x10a3nW\xFE[` \x02` \x01\x01\x81\x81RPPa3\xA0a1\x91\x89\x83\x81Q\x81\x10a3\x8CW\xFE[` \x02` \x01\x01Q\x85\x84\x81Q\x81\x10a0@W\xFE[\x91P`\x01\x01a3\tV[Pg\r\xE0\xB6\xB3\xA7d\0\0`\0[\x89Q\x81\x10\x15a4\x8BW`\0\x83\x85\x83\x81Q\x81\x10a3\xCFW\xFE[` \x02` \x01\x01Q\x11\x15a4+W`\0a3\xF4a1\xE3\x86g\r\xE0\xB6\xB3\xA7d\0\0a\r\x84V[\x90P`\0a4\x08\x82\x8C\x86\x81Q\x81\x10a1'W\xFE[\x90Pa4\"a1\x91a\x1FBg\r\xE0\xB6\xB3\xA7d\0\0\x8Ca\r\x84V[\x92PPPa4BV[\x88\x82\x81Q\x81\x10a47W\xFE[` \x02` \x01\x01Q\x90P[`\0a4k\x8C\x84\x81Q\x81\x10a4SW\xFE[` \x02` \x01\x01Qa\x06\xB5\x84\x8F\x87\x81Q\x81\x10a3LW\xFE[\x90Pa4\x7Fa2\x88\x8C\x85\x81Q\x81\x10a2qW\xFE[\x93PPP`\x01\x01a3\xB7V[Pg\r\xE0\xB6\xB3\xA7d\0\0\x81\x10a4\xC1Wa4\xB7a4\xB0\x82g\r\xE0\xB6\xB3\xA7d\0\0a\r\x84V[\x87\x90a*#V[\x93PPPPa#wV[`\0\x93PPPPa#wV[`\0\x80a4\xDE\x84a/\x0B\x81\x88a\rrV[\x90Pa4\xF7g)\xA2$\x1A\xF6,\0\0\x82\x11\x15a\x013a\x0F\x13V[`\0a5\x0Ea/Ag\r\xE0\xB6\xB3\xA7d\0\0\x89a)\x92V[\x90P`\0a5.a5'\x83g\r\xE0\xB6\xB3\xA7d\0\0a\r\x84V[\x8A\x90a%-V[\x90P`\0a5;\x89a)lV[\x90P`\0a5I\x83\x83a%-V[\x90P`\0a5W\x84\x83a\r\x84V[\x90Pa/\xA7a/\xA0a5h\x8Aa)lV[\x84\x90a)\x92V[g\r\xE0\xB6\xB3\xA7d\0\0\x02`\0\x80n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x80\x84\x01\x90n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x0F\xFF\xFF\xFF\xFF\x19\x85\x01\x02\x81a5\xABW\xFE[\x05\x90P`\0n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x80\x02\x05\x90P\x81\x80n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x81\x84\x02\x05\x91P`\x03\x82\x05\x01n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x84\x02\x05\x91P`\x05\x82\x05\x01n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x84\x02\x05\x91P`\x07\x82\x05\x01n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x84\x02\x05\x91P`\t\x82\x05\x01n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x84\x02\x05\x91P`\x0B\x82\x05\x01n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x84\x02\x05\x91P`\r\x82\x05\x01n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x82\x84\x02\x05\x91P`\x0F\x82`\x02\x91\x90\x05\x91\x90\x91\x01\x02\x95\x94PPPPPV[`\0a6\xA6`\0\x83\x13`da\x0F\x13V[g\r\xE0\xB6\xB3\xA7d\0\0\x82\x12\x15a6\xE1Wa6\xD7\x82n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x81a6\xD1W\xFE[\x05a6\x96V[`\0\x03\x90Pa\x06\xD5V[`\0~\x16\0\xEF1r\xE5\x8D.\x93>\xC8\x84\xFD\xE1\0d\xC6;Sr\xD8\x05\xE2\x03\xC0\0\0\0\0\0\0\x83\x12a72Ww\x01\x95\xE5L]\xD4!w\xF5:'\x17/\xA9\xECc\x02b\x82p\0\0\0\0\x83\x05\x92Ph\x06\xF0[Y\xD3\xB2\0\0\0\x01[s\x01\x17\x98\0Mu]<\x8B\xC8\xE02\x04\xCFDa\x9E\0\0\0\x83\x12a7jWk\x14%\x98,\xF5\x97\xCD \\\xEFs\x80\x83\x05\x92Ph\x03x-\xAC\xE9\xD9\0\0\0\x01[`d\x92\x83\x02\x92\x02n\x01\x85QD\x81J\x7F\xF8\x05\x98\x0F\xF0\x08@\0\x83\x12a7\xB2Wn\x01\x85QD\x81J\x7F\xF8\x05\x98\x0F\xF0\x08@\0h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\xADx\xEB\xC5\xACb\0\0\0\x01[k\x02\xDF\n\xB5\xA8\n\"\xC6\x1A\xB5\xA7\0\x83\x12a7\xEDWk\x02\xDF\n\xB5\xA8\n\"\xC6\x1A\xB5\xA7\0h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92PhV\xBCu\xE2\xD61\0\0\0\x01[i?\x1F\xCE=\xA66\xEA\\\xF8P\x83\x12a8$Wi?\x1F\xCE=\xA66\xEA\\\xF8Ph\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph+^:\xF1k\x18\x80\0\0\x01[i\x01'\xFA'r,\xC0l\xC5\xE2\x83\x12a8[Wi\x01'\xFA'r,\xC0l\xC5\xE2h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\x15\xAF\x1Dx\xB5\x8C@\0\0\x01[h(\x0E`\x11N\xDB\x80]\x03\x83\x12a8\x90Wh(\x0E`\x11N\xDB\x80]\x03h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\n\xD7\x8E\xBCZ\xC6 \0\0\x01[h\x0E\xBC_\xB4\x17F\x12\x11\x10\x83\x12a8\xBBWh\x0E\xBC_\xB4\x17F\x12\x11\x10h\x05k\xC7^-c\x10\0\0\x93\x84\x02\x05\x92\x01[h\x08\xF0\x0Fv\nK-\xB5]\x83\x12a8\xF0Wh\x08\xF0\x0Fv\nK-\xB5]h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\x02\xB5\xE3\xAF\x16\xB1\x88\0\0\x01[h\x06\xF5\xF1wW\x88\x93y7\x83\x12a9%Wh\x06\xF5\xF1wW\x88\x93y7h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Ph\x01Z\xF1\xD7\x8BX\xC4\0\0\x01[h\x06$\x8F3pK(f\x03\x83\x12a9YWh\x06$\x8F3pK(f\x03h\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92Pg\xADx\xEB\xC5\xACb\0\0\x01[h\x05\xC5Hg\x0B\x95\x10\xE7\xAC\x83\x12a9\x8DWh\x05\xC5Hg\x0B\x95\x10\xE7\xACh\x05k\xC7^-c\x10\0\0\x84\x02\x05\x92PgV\xBCu\xE2\xD61\0\0\x01[`\0h\x05k\xC7^-c\x10\0\0\x84\x01h\x05k\xC7^-c\x10\0\0\x80\x86\x03\x02\x81a9\xB0W\xFE[\x05\x90P`\0h\x05k\xC7^-c\x10\0\0\x82\x80\x02\x05\x90P\x81\x80h\x05k\xC7^-c\x10\0\0\x81\x84\x02\x05\x91P`\x03\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\x05\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\x07\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\t\x82\x05\x01h\x05k\xC7^-c\x10\0\0\x82\x84\x02\x05\x91P`\x0B\x82\x05\x01`\x02\x02`d\x85\x82\x01\x05\x97\x96PPPPPPPV[`\0a:sh\x028\xFDB\xC5\xCF\x03\xFF\xFF\x19\x83\x12\x15\x80\x15a:lWPh\x07\x0C\x1C\xC7;\0\xC8\0\0\x83\x13\x15[`\ta\x0F\x13V[`\0\x82\x12\x15a:\xA7Wa:\x88\x82`\0\x03a:DV[n\xC0\x97\xCE{\xC9\x07\x15\xB3K\x9F\x10\0\0\0\0\x81a:\x9FW\xFE[\x05\x90Pa\x06\xD5V[`\0h\x06\xF0[Y\xD3\xB2\0\0\0\x83\x12a:\xE7WPh\x06\xF0[Y\xD3\xB1\xFF\xFF\xFF\x19\x90\x91\x01\x90w\x01\x95\xE5L]\xD4!w\xF5:'\x17/\xA9\xECc\x02b\x82p\0\0\0\0a;\x1DV[h\x03x-\xAC\xE9\xD9\0\0\0\x83\x12a;\x19WPh\x03x-\xAC\xE9\xD8\xFF\xFF\xFF\x19\x90\x91\x01\x90k\x14%\x98,\xF5\x97\xCD \\\xEFs\x80a;\x1DV[P`\x01[`d\x92\x90\x92\x02\x91h\x05k\xC7^-c\x10\0\0h\xADx\xEB\xC5\xACb\0\0\0\x84\x12a;mWh\xADx\xEB\xC5\xACa\xFF\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0n\x01\x85QD\x81J\x7F\xF8\x05\x98\x0F\xF0\x08@\0\x82\x02\x05\x90P[hV\xBCu\xE2\xD61\0\0\0\x84\x12a;\xA9WhV\xBCu\xE2\xD60\xFF\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0k\x02\xDF\n\xB5\xA8\n\"\xC6\x1A\xB5\xA7\0\x82\x02\x05\x90P[h+^:\xF1k\x18\x80\0\0\x84\x12a;\xE3Wh+^:\xF1k\x18\x7F\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0i?\x1F\xCE=\xA66\xEA\\\xF8P\x82\x02\x05\x90P[h\x15\xAF\x1Dx\xB5\x8C@\0\0\x84\x12a<\x1DWh\x15\xAF\x1Dx\xB5\x8C?\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0i\x01'\xFA'r,\xC0l\xC5\xE2\x82\x02\x05\x90P[h\n\xD7\x8E\xBCZ\xC6 \0\0\x84\x12a<VWh\n\xD7\x8E\xBCZ\xC6\x1F\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h(\x0E`\x11N\xDB\x80]\x03\x82\x02\x05\x90P[h\x05k\xC7^-c\x10\0\0\x84\x12a<\x8FWh\x05k\xC7^-c\x0F\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h\x0E\xBC_\xB4\x17F\x12\x11\x10\x82\x02\x05\x90P[h\x02\xB5\xE3\xAF\x16\xB1\x88\0\0\x84\x12a<\xC8Wh\x02\xB5\xE3\xAF\x16\xB1\x87\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h\x08\xF0\x0Fv\nK-\xB5]\x82\x02\x05\x90P[h\x01Z\xF1\xD7\x8BX\xC4\0\0\x84\x12a=\x01Wh\x01Z\xF1\xD7\x8BX\xC3\xFF\xFF\x19\x90\x93\x01\x92h\x05k\xC7^-c\x10\0\0h\x06\xF5\xF1wW\x88\x93y7\x82\x02\x05\x90P[h\x05k\xC7^-c\x10\0\0\x84\x81\x01\x90\x85\x90`\x02\x90\x82\x80\x02\x05\x05\x91\x82\x01\x91\x90P`\x03h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x04h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x05h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x06h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x07h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x08h\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\th\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\nh\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x0Bh\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`\x0Ch\x05k\xC7^-c\x10\0\0\x87\x83\x02\x05\x05\x91\x82\x01\x91\x90P`dh\x05k\xC7^-c\x10\0\0\x84\x84\x02\x05\x85\x02\x05\x96\x95PPPPPPV[\x805a\x04\xDC\x81aG\x08V[`\0\x82`\x1F\x83\x01\x12a>=W\x80\x81\xFD[\x81Qa>Pa>K\x82aF\xE8V[aF\xC1V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15a>qW`\0\x80\xFD[`\0[\x84\x81\x10\x15a>\x90W\x81Q\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01a>tV[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12a>\xABW\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a>\xC1W\x81\x82\xFD[a>\xD4`\x1F\x82\x01`\x1F\x19\x16` \x01aF\xC1V[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15a>\xEBW`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[\x805`\x02\x81\x10a\x04\xDCW`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a?$W\x80\x81\xFD[\x815a\x05\xA1\x81aG\x08V[`\0\x80`@\x83\x85\x03\x12\x15a?AW\x80\x81\xFD[\x825a?L\x81aG\x08V[\x91P` \x83\x015a?\\\x81aG\x08V[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15a?{W\x80\x81\xFD[\x835a?\x86\x81aG\x08V[\x92P` \x84\x015a?\x96\x81aG\x08V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[`\0\x80`\0\x80`\0\x80`\0`\xE0\x88\x8A\x03\x12\x15a?\xC1W\x82\x83\xFD[\x875a?\xCC\x81aG\x08V[\x96P` \x88\x015a?\xDC\x81aG\x08V[\x95P`@\x88\x015\x94P``\x88\x015\x93P`\x80\x88\x015`\xFF\x81\x16\x81\x14a?\xFFW\x83\x84\xFD[\x96\x99\x95\x98P\x93\x96\x92\x95\x94`\xA0\x84\x015\x94P`\xC0\x90\x93\x015\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a@.W\x81\x82\xFD[\x825a@9\x81aG\x08V[\x94` \x93\x90\x93\x015\x93PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15a@[W\x80\x81\xFD[\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a@rW\x82\x83\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a@\x85W\x82\x83\xFD[\x81Qa@\x93a>K\x82aF\xE8V[\x80\x82\x82R` \x80\x83\x01\x92P\x80\x86\x01\x8B\x82\x83\x87\x02\x89\x01\x01\x11\x15a@\xB3W\x87\x88\xFD[\x87\x96P[\x84\x87\x10\x15a@\xDEW\x80Qa@\xCA\x81aG\x08V[\x84R`\x01\x96\x90\x96\x01\x95\x92\x81\x01\x92\x81\x01a@\xB7V[P\x89\x01Q\x90\x97P\x93PPP\x80\x82\x11\x15a@\xF5W\x82\x83\xFD[PaA\x02\x86\x82\x87\x01a>-V[\x92PP`@\x84\x01Q\x90P\x92P\x92P\x92V[`\0` \x82\x84\x03\x12\x15aA$W\x80\x81\xFD[\x815a\x05\xA1\x81aG\x1DV[`\0` \x82\x84\x03\x12\x15aA@W\x80\x81\xFD[\x81Qa\x05\xA1\x81aG\x1DV[`\0\x80`\0\x80`\0\x80`\0`\xE0\x88\x8A\x03\x12\x15aAeW\x80\x81\xFD[\x875\x96P` \x80\x89\x015aAx\x81aG\x08V[\x96P`@\x89\x015aA\x88\x81aG\x08V[\x95P``\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aA\xA4W\x83\x84\xFD[\x81\x8B\x01\x91P\x8B`\x1F\x83\x01\x12aA\xB7W\x83\x84\xFD[\x815aA\xC5a>K\x82aF\xE8V[\x80\x82\x82R\x85\x82\x01\x91P\x85\x85\x01\x8F\x87\x88\x86\x02\x88\x01\x01\x11\x15aA\xE3W\x87\x88\xFD[\x87\x95P[\x83\x86\x10\x15aB\x05W\x805\x83R`\x01\x95\x90\x95\x01\x94\x91\x86\x01\x91\x86\x01aA\xE7V[P\x98PPP`\x80\x8B\x015\x95P`\xA0\x8B\x015\x94P`\xC0\x8B\x015\x92P\x80\x83\x11\x15aB+W\x83\x84\xFD[PPaB9\x8A\x82\x8B\x01a>\x9BV[\x91PP\x92\x95\x98\x91\x94\x97P\x92\x95PV[`\0` \x82\x84\x03\x12\x15aBYW\x80\x81\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x05\xA1W\x81\x82\xFD[`\0` \x82\x84\x03\x12\x15aB\x81W\x80\x81\xFD[\x81Qa\x05\xA1\x81aG\x08V[`\0` \x82\x84\x03\x12\x15aB\x9DW\x80\x81\xFD[\x81Qa\x05\xA1\x81aG+V[`\0\x80`\0``\x84\x86\x03\x12\x15aB\xBCW\x80\x81\xFD[\x83QaB\xC7\x81aG+V[` \x85\x01Q\x90\x93Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aB\xE3W\x81\x82\xFD[aA\x02\x86\x82\x87\x01a>-V[`\0\x80`@\x83\x85\x03\x12\x15aC\x01W\x81\x82\xFD[\x82QaC\x0C\x81aG+V[` \x93\x90\x93\x01Q\x92\x94\x92\x93PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15aC0W\x80\x81\xFD[\x83QaC;\x81aG+V[` \x85\x01Q`@\x90\x95\x01Q\x90\x96\x94\x95P\x93\x92PPPV[`\0\x80`@\x83\x85\x03\x12\x15aCdW\x81\x82\xFD[\x82QaCo\x81aG+V[` \x84\x01Q\x90\x92Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aC\x8BW\x81\x82\xFD[aC\x97\x85\x82\x86\x01a>-V[\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15aC\xB5W\x80\x81\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aC\xCCW\x82\x83\xFD[\x81\x86\x01\x91Pa\x01 \x80\x83\x89\x03\x12\x15aC\xE2W\x83\x84\xFD[aC\xEB\x81aF\xC1V[\x90PaC\xF7\x88\x84a?\x04V[\x81RaD\x06\x88` \x85\x01a>\"V[` \x82\x01RaD\x18\x88`@\x85\x01a>\"V[`@\x82\x01R``\x83\x015``\x82\x01R`\x80\x83\x015`\x80\x82\x01R`\xA0\x83\x015`\xA0\x82\x01RaDH\x88`\xC0\x85\x01a>\"V[`\xC0\x82\x01RaDZ\x88`\xE0\x85\x01a>\"V[`\xE0\x82\x01Ra\x01\0\x80\x84\x015\x83\x81\x11\x15aDrW\x85\x86\xFD[aD~\x8A\x82\x87\x01a>\x9BV[\x91\x83\x01\x91\x90\x91RP\x97` \x87\x015\x97P`@\x90\x96\x015\x95\x94PPPPPV[`\0` \x82\x84\x03\x12\x15aD\xAEW\x80\x81\xFD[P5\x91\x90PV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aD\xE4W\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aD\xC8V[P\x94\x95\x94PPPPPV[\x91\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`$\x01\x90V[`\0\x82\x84\x837\x91\x01\x90\x81R\x91\x90PV[a\x19\x01`\xF0\x1B\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\0` \x82Ra\x05\xA1` \x83\x01\x84aD\xB5V[`\0`@\x82RaEl`@\x83\x01\x85aD\xB5V[\x82\x81\x03` \x84\x01Ra#w\x81\x85aD\xB5V[\x90\x15\x15\x81R` \x01\x90V[\x92\x15\x15\x83R` \x83\x01\x91\x90\x91R`@\x82\x01R``\x01\x90V[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16` \x87\x01R\x92\x90\x93\x16`@\x85\x01R``\x84\x01R`\x80\x83\x01\x91\x90\x91R`\xA0\x82\x01R`\xC0\x01\x90V[\x94\x85R` \x85\x01\x93\x90\x93R`@\x84\x01\x91\x90\x91R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01\x90V[\x93\x84R`\xFF\x92\x90\x92\x16` \x84\x01R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[`\0` \x80\x83R\x83Q\x80\x82\x85\x01R\x82[\x81\x81\x10\x15aFsW\x85\x81\x01\x83\x01Q\x85\x82\x01`@\x01R\x82\x01aFWV[\x81\x81\x11\x15aF\x84W\x83`@\x83\x87\x01\x01R[P`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01`@\x01\x93\x92PPPV[`\0\x83\x82R`@` \x83\x01Ra\x1B\xB0`@\x83\x01\x84aD\xB5V[`\xFF\x91\x90\x91\x16\x81R` \x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15aF\xE0W`\0\x80\xFD[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15aF\xFEW\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x04\xF3W`\0\x80\xFD[\x80\x15\x15\x81\x14a\x04\xF3W`\0\x80\xFD[`\x03\x81\x10a\x04\xF3W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xA2\xC3\xB6.\x0B\xC5\x05\x07Y\x83\x958~\x15Wa-z\xD5\x9E\x81}\xDA\xE4\xD5'\x99\x07@/\xED\xB4dsolcC\0\x07\x01\x003\xA2dipfsX\"\x12 \x1B\xCB:\x95;\0\xC5\xC4\xDC\xF4\xD3\xCFt\xF0G\xF6\x9D%2\x02\x98\xF4\x1Eoc\\\xB0)QoX7dsolcC\0\x07\x01\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { vault: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256[],uint256,address)` and selector `0xfbce0393`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub weights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256[],uint256,
+    /// address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.weights,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        weights: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        owner: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 206u8, 3u8, 147u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2WeightedPoolFactory`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2WeightedPoolFactoryCalls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+    }
+    impl BalancerV2WeightedPoolFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [45u8, 164u8, 124u8, 64u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [251u8, 206u8, 3u8, 147u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(getVault),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolFactoryCalls {
+        const COUNT: usize = 4usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolFactoryCalls,
+            >] = &[
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryCalls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryCalls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryCalls::create)
+                    }
+                    create
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolFactoryCalls,
+            >] = &[
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryCalls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2WeightedPoolFactoryCalls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryCalls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryCalls::create)
+                    }
+                    create
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2WeightedPoolFactory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2WeightedPoolFactoryEvents {
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2WeightedPoolFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8, 73u8,
+            106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8, 188u8,
+            196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(PoolCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2WeightedPoolFactoryEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2WeightedPoolFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPoolFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2WeightedPoolFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2WeightedPoolFactoryInstance<P, N> {
+        BalancerV2WeightedPoolFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        vault: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<BalancerV2WeightedPoolFactoryInstance<P, N>>,
+    > {
+        BalancerV2WeightedPoolFactoryInstance::<P, N>::deploy(__provider, vault)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        vault: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        BalancerV2WeightedPoolFactoryInstance::<P, N>::deploy_builder(__provider, vault)
+    }
+    /**A [`BalancerV2WeightedPoolFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2WeightedPoolFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2WeightedPoolFactoryInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2WeightedPoolFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2WeightedPoolFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPoolFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2WeightedPoolFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            vault: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<BalancerV2WeightedPoolFactoryInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, vault);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            vault: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { vault })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2WeightedPoolFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2WeightedPoolFactoryInstance<P, N> {
+            BalancerV2WeightedPoolFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            weights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                weights,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = BalancerV2WeightedPoolFactory::BalancerV2WeightedPoolFactoryInstance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9"),
+            Some(12272147u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/Cargo.toml b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/Cargo.toml
new file mode 100644
index 0000000000..7978bc8ca0
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2weightedpoolfactoryv3"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs
new file mode 100644
index 0000000000..572cd6089d
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs
@@ -0,0 +1,3547 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2WeightedPoolFactoryV3 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory normalizedWeights, address[] memory rateProviders, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "normalizedWeights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2WeightedPoolFactoryV3 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256[],address[],uint256,address)` and selector `0x80773a93`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory normalizedWeights, address[] memory rateProviders, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub normalizedWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256[],address[],uint256,
+    /// address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.normalizedWeights,
+                        value.rateProviders,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        normalizedWeights: tuple.3,
+                        rateProviders: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        owner: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [128u8, 119u8, 58u8, 147u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],address[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2WeightedPoolFactoryV3`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2WeightedPoolFactoryV3Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2WeightedPoolFactoryV3Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [128u8, 119u8, 58u8, 147u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(create),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolFactoryV3Calls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolFactoryV3Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolFactoryV3Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV3Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV3Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV3Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolFactoryV3Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV3Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV3Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV3Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV3Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV3Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV3Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV3Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2WeightedPoolFactoryV3`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2WeightedPoolFactoryV3Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2WeightedPoolFactoryV3Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2WeightedPoolFactoryV3Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolFactoryV3Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2WeightedPoolFactoryV3Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPoolFactoryV3`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2WeightedPoolFactoryV3Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2WeightedPoolFactoryV3Instance<P, N> {
+        BalancerV2WeightedPoolFactoryV3Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2WeightedPoolFactoryV3`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2WeightedPoolFactoryV3`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2WeightedPoolFactoryV3Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2WeightedPoolFactoryV3Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2WeightedPoolFactoryV3Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryV3Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPoolFactoryV3`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2WeightedPoolFactoryV3Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2WeightedPoolFactoryV3Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2WeightedPoolFactoryV3Instance<P, N> {
+            BalancerV2WeightedPoolFactoryV3Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryV3Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            normalizedWeights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                normalizedWeights,
+                rateProviders,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryV3Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = BalancerV2WeightedPoolFactoryV3::BalancerV2WeightedPoolFactoryV3Instance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x5Dd94Da3644DDD055fcf6B3E1aa310Bb7801EB8b"),
+            Some(16520627u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xA0DAbEBAAd1b243BBb243f933013d560819eB66f"),
+            Some(72832703u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x6e4cF292C5349c79cCd66349c3Ed56357dD11B46"),
+            Some(25474982u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xC128a9954e6c874eA3d62ce62B468bA073093F25"),
+            Some(26226256u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x82e4cFaef85b1B6299935340c964C942280327f4"),
+            Some(39036828u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x94f68b54191F62f781Fe8298A8A5Fa3ed772d227"),
+            Some(26389236u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/Cargo.toml b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/Cargo.toml
new file mode 100644
index 0000000000..65c20b6a27
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv2weightedpoolfactoryv4"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs
new file mode 100644
index 0000000000..f60555694f
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs
@@ -0,0 +1,3559 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BalancerV2WeightedPoolFactoryV4 {
+    event FactoryDisabled();
+    event PoolCreated(address indexed pool);
+
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory normalizedWeights, address[] memory rateProviders, uint256 swapFeePercentage, address owner) external returns (address);
+    function disable() external;
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getAuthorizer() external view returns (address);
+    function getCreationCode() external view returns (bytes memory);
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    function getPoolVersion() external view returns (string memory);
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    function getVault() external view returns (address);
+    function isDisabled() external view returns (bool);
+    function isPoolFromFactory(address pool) external view returns (bool);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "protocolFeeProvider",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      },
+      {
+        "name": "factoryVersion",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "poolVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "normalizedWeights",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "rateProviders",
+        "type": "address[]",
+        "internalType": "contract IRateProvider[]"
+      },
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disable",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getActionId",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAuthorizer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getCreationCodeContracts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "contractA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "contractB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPauseConfiguration",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolVersion",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeePercentagesProvider",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IProtocolFeePercentagesProvider"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getVault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isDisabled",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isPoolFromFactory",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "FactoryDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2WeightedPoolFactoryV4 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FactoryDisabled()` and selector `0x432acbfd662dbb5d8b378384a67159b47ca9d0f1b79f97cf64cf8585fa362d50`.
+    ```solidity
+    event FactoryDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FactoryDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FactoryDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FactoryDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                    166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8,
+                    207u8, 100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FactoryDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FactoryDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FactoryDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address)` and selector `0x83a48fbcfc991335314e74d0496aab6a1987e992ddc85dddbcc4d6dd6ef2e9fc`.
+    ```solidity
+    event PoolCreated(address indexed pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                    73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8,
+                    221u8, 188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { pool: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.pool.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.pool,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address protocolFeeProvider, string factoryVersion, string poolVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub protocolFeeProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub factoryVersion: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub poolVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.protocolFeeProvider,
+                        value.factoryVersion,
+                        value.poolVersion,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        protocolFeeProvider: tuple.1,
+                        factoryVersion: tuple.2,
+                        poolVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeeProvider,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.factoryVersion,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.poolVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(string,string,address[],uint256[],address[],uint256,address)` and selector `0x80773a93`.
+    ```solidity
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory normalizedWeights, address[] memory rateProviders, uint256 swapFeePercentage, address owner) external returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub normalizedWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(string,string,address[],uint256[],address[],uint256,
+    /// address)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.normalizedWeights,
+                        value.rateProviders,
+                        value.swapFeePercentage,
+                        value.owner,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        normalizedWeights: tuple.3,
+                        rateProviders: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        owner: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [128u8, 119u8, 58u8, 147u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],address[],uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.rateProviders),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disable()` and selector `0x2f2770db`.
+    ```solidity
+    function disable() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableCall;
+    ///Container type for the return parameters of the
+    /// [`disable()`](disableCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableReturn {
+            fn _tokenize(&self) -> <disableCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableCall {
+            type Parameters<'a> = ();
+            type Return = disableReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 39u8, 112u8, 219u8];
+            const SIGNATURE: &'static str = "disable()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    ```solidity
+    function getActionId(bytes4 selector) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getActionIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getActionIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getActionIdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
+            const SIGNATURE: &'static str = "getActionId(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getActionIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getActionIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    ```solidity
+    function getAuthorizer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAuthorizerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAuthorizerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAuthorizerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
+            const SIGNATURE: &'static str = "getAuthorizer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAuthorizerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAuthorizerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
+    ```solidity
+    function getCreationCode() external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCode()`](getCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
+            const SIGNATURE: &'static str = "getCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
+    ```solidity
+    function getCreationCodeContracts() external view returns (address contractA, address contractB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getCreationCodeContractsReturn {
+        #[allow(missing_docs)]
+        pub contractA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub contractB: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getCreationCodeContractsReturn) -> Self {
+                    (value.contractA, value.contractB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contractA: tuple.0,
+                        contractB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getCreationCodeContractsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.contractB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
+            type Parameters<'a> = ();
+            type Return = getCreationCodeContractsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
+            const SIGNATURE: &'static str = "getCreationCodeContracts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getCreationCodeContractsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
+    ```solidity
+    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPauseConfigurationReturn {
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPauseConfigurationReturn) -> Self {
+                    (value.pauseWindowDuration, value.bufferPeriodDuration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pauseWindowDuration: tuple.0,
+                        bufferPeriodDuration: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPauseConfigurationReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
+            type Parameters<'a> = ();
+            type Return = getPauseConfigurationReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
+            const SIGNATURE: &'static str = "getPauseConfiguration()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPauseConfigurationReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
+    ```solidity
+    function getPoolVersion() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolVersion()`](getPoolVersionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolVersionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolVersionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolVersionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
+            const SIGNATURE: &'static str = "getPoolVersion()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolVersionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolVersionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
+    ```solidity
+    function getProtocolFeePercentagesProvider() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeePercentagesProviderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
+            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeePercentagesProviderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeePercentagesProviderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    ```solidity
+    function getVault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getVault()`](getVaultCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getVaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getVaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getVaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
+            const SIGNATURE: &'static str = "getVault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getVaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getVaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
+    ```solidity
+    function isDisabled() external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isDisabled()`](isDisabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isDisabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isDisabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isDisabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
+            const SIGNATURE: &'static str = "isDisabled()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isDisabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isDisabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    ```solidity
+    function isPoolFromFactory(address pool) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isPoolFromFactoryReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isPoolFromFactoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
+            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isPoolFromFactoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isPoolFromFactoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2WeightedPoolFactoryV4`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2WeightedPoolFactoryV4Calls {
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        getActionId(getActionIdCall),
+        #[allow(missing_docs)]
+        getAuthorizer(getAuthorizerCall),
+        #[allow(missing_docs)]
+        getCreationCode(getCreationCodeCall),
+        #[allow(missing_docs)]
+        getCreationCodeContracts(getCreationCodeContractsCall),
+        #[allow(missing_docs)]
+        getPauseConfiguration(getPauseConfigurationCall),
+        #[allow(missing_docs)]
+        getPoolVersion(getPoolVersionCall),
+        #[allow(missing_docs)]
+        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
+        #[allow(missing_docs)]
+        getVault(getVaultCall),
+        #[allow(missing_docs)]
+        isDisabled(isDisabledCall),
+        #[allow(missing_docs)]
+        isPoolFromFactory(isPoolFromFactoryCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2WeightedPoolFactoryV4Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 193u8, 148u8, 219u8],
+            [23u8, 68u8, 129u8, 250u8],
+            [45u8, 164u8, 124u8, 64u8],
+            [47u8, 39u8, 112u8, 219u8],
+            [63u8, 129u8, 155u8, 111u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 52u8, 183u8, 83u8],
+            [108u8, 87u8, 245u8, 169u8],
+            [115u8, 146u8, 56u8, 214u8],
+            [128u8, 119u8, 58u8, 147u8],
+            [133u8, 28u8, 27u8, 179u8],
+            [141u8, 146u8, 138u8, 248u8],
+            [170u8, 171u8, 173u8, 197u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getCreationCode),
+            ::core::stringify!(getCreationCodeContracts),
+            ::core::stringify!(getPauseConfiguration),
+            ::core::stringify!(disable),
+            ::core::stringify!(getPoolVersion),
+            ::core::stringify!(version),
+            ::core::stringify!(isPoolFromFactory),
+            ::core::stringify!(isDisabled),
+            ::core::stringify!(getProtocolFeePercentagesProvider),
+            ::core::stringify!(create),
+            ::core::stringify!(getActionId),
+            ::core::stringify!(getVault),
+            ::core::stringify!(getAuthorizer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolFactoryV4Calls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolFactoryV4Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getCreationCode(_) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getCreationCodeContracts(_) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPauseConfiguration(_) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolVersion(_) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeePercentagesProvider(_) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isPoolFromFactory(_) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolFactoryV4Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV4Calls::getCreationCodeContracts)
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV4Calls::getPauseConfiguration)
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV4Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2WeightedPoolFactoryV4Calls,
+            >] = &[
+                {
+                    fn getCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV4Calls::getCreationCode)
+                    }
+                    getCreationCode
+                },
+                {
+                    fn getCreationCodeContracts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV4Calls::getCreationCodeContracts,
+                            )
+                    }
+                    getCreationCodeContracts
+                },
+                {
+                    fn getPauseConfiguration(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV4Calls::getPauseConfiguration,
+                            )
+                    }
+                    getPauseConfiguration
+                },
+                {
+                    fn disable(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <disableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::disable)
+                    }
+                    disable
+                },
+                {
+                    fn getPoolVersion(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV4Calls::getPoolVersion)
+                    }
+                    getPoolVersion
+                },
+                {
+                    fn version(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::version)
+                    }
+                    version
+                },
+                {
+                    fn isPoolFromFactory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::isPoolFromFactory)
+                    }
+                    isPoolFromFactory
+                },
+                {
+                    fn isDisabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::isDisabled)
+                    }
+                    isDisabled
+                },
+                {
+                    fn getProtocolFeePercentagesProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2WeightedPoolFactoryV4Calls::getProtocolFeePercentagesProvider,
+                            )
+                    }
+                    getProtocolFeePercentagesProvider
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::create)
+                    }
+                    create
+                },
+                {
+                    fn getActionId(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getActionId)
+                    }
+                    getActionId
+                },
+                {
+                    fn getVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2WeightedPoolFactoryV4Calls::getVault)
+                    }
+                    getVault
+                },
+                {
+                    fn getAuthorizer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
+                    {
+                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2WeightedPoolFactoryV4Calls::getAuthorizer)
+                    }
+                    getAuthorizer
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disable(inner) => {
+                    <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getActionId(inner) => {
+                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAuthorizer(inner) => {
+                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCode(inner) => {
+                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getCreationCodeContracts(inner) => {
+                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPauseConfiguration(inner) => {
+                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getPoolVersion(inner) => {
+                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeePercentagesProvider(inner) => {
+                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getVault(inner) => {
+                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isDisabled(inner) => {
+                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isPoolFromFactory(inner) => {
+                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV2WeightedPoolFactoryV4`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV2WeightedPoolFactoryV4Events {
+        #[allow(missing_docs)]
+        FactoryDisabled(FactoryDisabled),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl BalancerV2WeightedPoolFactoryV4Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                67u8, 42u8, 203u8, 253u8, 102u8, 45u8, 187u8, 93u8, 139u8, 55u8, 131u8, 132u8,
+                166u8, 113u8, 89u8, 180u8, 124u8, 169u8, 208u8, 241u8, 183u8, 159u8, 151u8, 207u8,
+                100u8, 207u8, 133u8, 133u8, 250u8, 54u8, 45u8, 80u8,
+            ],
+            [
+                131u8, 164u8, 143u8, 188u8, 252u8, 153u8, 19u8, 53u8, 49u8, 78u8, 116u8, 208u8,
+                73u8, 106u8, 171u8, 106u8, 25u8, 135u8, 233u8, 146u8, 221u8, 200u8, 93u8, 221u8,
+                188u8, 196u8, 214u8, 221u8, 110u8, 242u8, 233u8, 252u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(FactoryDisabled),
+            ::core::stringify!(PoolCreated),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for BalancerV2WeightedPoolFactoryV4Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "BalancerV2WeightedPoolFactoryV4Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FactoryDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FactoryDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FactoryDisabled)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for BalancerV2WeightedPoolFactoryV4Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FactoryDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPoolFactoryV4`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV2WeightedPoolFactoryV4Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV2WeightedPoolFactoryV4Instance<P, N> {
+        BalancerV2WeightedPoolFactoryV4Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`BalancerV2WeightedPoolFactoryV4`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV2WeightedPoolFactoryV4`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV2WeightedPoolFactoryV4Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV2WeightedPoolFactoryV4Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV2WeightedPoolFactoryV4Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryV4Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV2WeightedPoolFactoryV4`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV2WeightedPoolFactoryV4Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV2WeightedPoolFactoryV4Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV2WeightedPoolFactoryV4Instance<P, N> {
+            BalancerV2WeightedPoolFactoryV4Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryV4Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            name: alloy_sol_types::private::String,
+            symbol: alloy_sol_types::private::String,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            normalizedWeights: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            rateProviders: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                name,
+                symbol,
+                tokens,
+                normalizedWeights,
+                rateProviders,
+                swapFeePercentage,
+                owner,
+            })
+        }
+
+        ///Creates a new call builder for the [`disable`] function.
+        pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
+            self.call_builder(&disableCall)
+        }
+
+        ///Creates a new call builder for the [`getActionId`] function.
+        pub fn getActionId(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
+            self.call_builder(&getActionIdCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getAuthorizer`] function.
+        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
+            self.call_builder(&getAuthorizerCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCode`] function.
+        pub fn getCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
+            self.call_builder(&getCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`getCreationCodeContracts`]
+        /// function.
+        pub fn getCreationCodeContracts(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
+            self.call_builder(&getCreationCodeContractsCall)
+        }
+
+        ///Creates a new call builder for the [`getPauseConfiguration`]
+        /// function.
+        pub fn getPauseConfiguration(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
+            self.call_builder(&getPauseConfigurationCall)
+        }
+
+        ///Creates a new call builder for the [`getPoolVersion`] function.
+        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
+            self.call_builder(&getPoolVersionCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`getProtocolFeePercentagesProvider`] function.
+        pub fn getProtocolFeePercentagesProvider(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
+            self.call_builder(&getProtocolFeePercentagesProviderCall)
+        }
+
+        ///Creates a new call builder for the [`getVault`] function.
+        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
+            self.call_builder(&getVaultCall)
+        }
+
+        ///Creates a new call builder for the [`isDisabled`] function.
+        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
+            self.call_builder(&isDisabledCall)
+        }
+
+        ///Creates a new call builder for the [`isPoolFromFactory`] function.
+        pub fn isPoolFromFactory(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
+            self.call_builder(&isPoolFromFactoryCall { pool })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV2WeightedPoolFactoryV4Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FactoryDisabled`] event.
+        pub fn FactoryDisabled_filter(&self) -> alloy_contract::Event<&P, FactoryDisabled, N> {
+            self.event_filter::<FactoryDisabled>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = BalancerV2WeightedPoolFactoryV4::BalancerV2WeightedPoolFactoryV4Instance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x897888115Ada5773E02aA29F775430BFB5F34c51"),
+            Some(16878323u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a"),
+            Some(82737545u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a"),
+            Some(26665331u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x6CaD2ea22BFA7F4C14Aae92E47F510Cd5C509bc7"),
+            Some(27055829u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xFc8a407Bba312ac761D8BFe04CE1201904842B76"),
+            Some(40611103u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x4C32a8a8fDa4E24139B51b456B42290f51d6A1c4"),
+            Some(1204869u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xc7E5ED1054A24Ef31D827E6F86caA58B3Bc168d7"),
+            Some(72222060u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a"),
+            Some(27739006u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x7920BFa1b2041911b354747CA7A6cDD2dfC50Cfd"),
+            Some(3424893u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balancerv3batchrouter/Cargo.toml b/contracts/generated/contracts-generated/balancerv3batchrouter/Cargo.toml
new file mode 100644
index 0000000000..2fb3bae445
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv3batchrouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balancerv3batchrouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs b/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs
new file mode 100644
index 0000000000..29f345628c
--- /dev/null
+++ b/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs
@@ -0,0 +1,8461 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IAllowanceTransfer {
+    struct PermitBatch { PermitDetails[] details; address spender; uint256 sigDeadline; }
+    struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IAllowanceTransfer {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitBatch { PermitDetails[] details; address spender; uint256 sigDeadline; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitBatch {
+        #[allow(missing_docs)]
+        pub details:
+            alloy_sol_types::private::Vec<<PermitDetails as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sigDeadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<PermitDetails>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<<PermitDetails as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitBatch> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitBatch) -> Self {
+                (value.details, value.spender, value.sigDeadline)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitBatch {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    details: tuple.0,
+                    spender: tuple.1,
+                    sigDeadline: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitBatch {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitBatch {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        PermitDetails,
+                    > as alloy_sol_types::SolType>::tokenize(&self.details),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sigDeadline),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitBatch {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitBatch {
+            const NAME: &'static str = "PermitBatch";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitBatch(PermitDetails[] details,address spender,uint256 sigDeadline)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(<PermitDetails as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<PermitDetails as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        PermitDetails,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.details)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.spender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sigDeadline)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitBatch {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        PermitDetails,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.details,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.spender,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sigDeadline,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    PermitDetails,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.details,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.spender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sigDeadline,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitDetails {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<160>,
+            alloy_sol_types::sol_data::Uint<48>,
+            alloy_sol_types::sol_data::Uint<48>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U160,
+            alloy_sol_types::private::primitives::aliases::U48,
+            alloy_sol_types::private::primitives::aliases::U48,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitDetails> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitDetails) -> Self {
+                (value.token, value.amount, value.expiration, value.nonce)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitDetails {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    token: tuple.0,
+                    amount: tuple.1,
+                    expiration: tuple.2,
+                    nonce: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitDetails {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitDetails {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitDetails {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitDetails {
+            const NAME: &'static str = "PermitDetails";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiration)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitDetails {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiration,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    160,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    48,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiration,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    48,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
+
+    See the [wrapper's documentation](`IAllowanceTransferInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IAllowanceTransferInstance<P, N> {
+        IAllowanceTransferInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IAllowanceTransfer`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IAllowanceTransfer`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IAllowanceTransferInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IAllowanceTransferInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IAllowanceTransferInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IAllowanceTransferInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
+
+        See the [wrapper's documentation](`IAllowanceTransferInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IAllowanceTransferInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IAllowanceTransferInstance<P, N> {
+            IAllowanceTransferInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IAllowanceTransferInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IAllowanceTransferInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IBatchRouter {
+    struct SwapExactInHookParams { address sender; SwapPathExactAmountIn[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
+    struct SwapExactOutHookParams { address sender; SwapPathExactAmountOut[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
+    struct SwapPathExactAmountIn { address tokenIn; SwapPathStep[] steps; uint256 exactAmountIn; uint256 minAmountOut; }
+    struct SwapPathExactAmountOut { address tokenIn; SwapPathStep[] steps; uint256 maxAmountIn; uint256 exactAmountOut; }
+    struct SwapPathStep { address pool; address tokenOut; bool isBuffer; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IBatchRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapExactInHookParams { address sender; SwapPathExactAmountIn[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapExactInHookParams {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub paths: alloy_sol_types::private::Vec<
+            <SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub wethIsEth: bool,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Array<SwapPathExactAmountIn>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Vec<
+                <SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+            >,
+            alloy_sol_types::private::primitives::aliases::U256,
+            bool,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapExactInHookParams> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapExactInHookParams) -> Self {
+                (
+                    value.sender,
+                    value.paths,
+                    value.deadline,
+                    value.wethIsEth,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapExactInHookParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sender: tuple.0,
+                    paths: tuple.1,
+                    deadline: tuple.2,
+                    wethIsEth: tuple.3,
+                    userData: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapExactInHookParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapExactInHookParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathExactAmountIn,
+                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.wethIsEth,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapExactInHookParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapExactInHookParams {
+            const NAME: &'static str = "SwapExactInHookParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapExactInHookParams(address sender,SwapPathExactAmountIn[] paths,uint256 \
+                     deadline,bool wethIsEth,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(
+                    <SwapPathExactAmountIn as alloy_sol_types::SolStruct>::eip712_root_type(),
+                );
+                components.extend(
+                    <SwapPathExactAmountIn as alloy_sol_types::SolStruct>::eip712_components(),
+                );
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathExactAmountIn,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.paths)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.wethIsEth,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapExactInHookParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        SwapPathExactAmountIn,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.paths)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deadline,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.wethIsEth,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    SwapPathExactAmountIn,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.paths,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deadline,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.wethIsEth,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapExactOutHookParams { address sender; SwapPathExactAmountOut[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapExactOutHookParams {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub paths: alloy_sol_types::private::Vec<
+            <SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub wethIsEth: bool,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Array<SwapPathExactAmountOut>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Vec<
+                <SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+            >,
+            alloy_sol_types::private::primitives::aliases::U256,
+            bool,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapExactOutHookParams> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapExactOutHookParams) -> Self {
+                (
+                    value.sender,
+                    value.paths,
+                    value.deadline,
+                    value.wethIsEth,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapExactOutHookParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sender: tuple.0,
+                    paths: tuple.1,
+                    deadline: tuple.2,
+                    wethIsEth: tuple.3,
+                    userData: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapExactOutHookParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapExactOutHookParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathExactAmountOut,
+                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.wethIsEth,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapExactOutHookParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapExactOutHookParams {
+            const NAME: &'static str = "SwapExactOutHookParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapExactOutHookParams(address sender,SwapPathExactAmountOut[] paths,uint256 \
+                     deadline,bool wethIsEth,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(
+                    <SwapPathExactAmountOut as alloy_sol_types::SolStruct>::eip712_root_type(),
+                );
+                components.extend(
+                    <SwapPathExactAmountOut as alloy_sol_types::SolStruct>::eip712_components(),
+                );
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathExactAmountOut,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.paths)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.wethIsEth,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapExactOutHookParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        SwapPathExactAmountOut,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.paths)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deadline,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.wethIsEth,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    SwapPathExactAmountOut,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.paths,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deadline,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.wethIsEth,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapPathExactAmountIn { address tokenIn; SwapPathStep[] steps; uint256 exactAmountIn; uint256 minAmountOut; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapPathExactAmountIn {
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub steps:
+            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub exactAmountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minAmountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Array<SwapPathStep>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapPathExactAmountIn> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapPathExactAmountIn) -> Self {
+                (
+                    value.tokenIn,
+                    value.steps,
+                    value.exactAmountIn,
+                    value.minAmountOut,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapPathExactAmountIn {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    tokenIn: tuple.0,
+                    steps: tuple.1,
+                    exactAmountIn: tuple.2,
+                    minAmountOut: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapPathExactAmountIn {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapPathExactAmountIn {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.steps),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.exactAmountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minAmountOut),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapPathExactAmountIn {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapPathExactAmountIn {
+            const NAME: &'static str = "SwapPathExactAmountIn";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapPathExactAmountIn(address tokenIn,SwapPathStep[] steps,uint256 \
+                     exactAmountIn,uint256 minAmountOut)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathStep,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.steps)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.exactAmountIn)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minAmountOut)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapPathExactAmountIn {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        SwapPathStep,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.steps)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.exactAmountIn,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minAmountOut,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    SwapPathStep,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.steps,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.exactAmountIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minAmountOut,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapPathExactAmountOut { address tokenIn; SwapPathStep[] steps; uint256 maxAmountIn; uint256 exactAmountOut; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapPathExactAmountOut {
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub steps:
+            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub maxAmountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub exactAmountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Array<SwapPathStep>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapPathExactAmountOut> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapPathExactAmountOut) -> Self {
+                (
+                    value.tokenIn,
+                    value.steps,
+                    value.maxAmountIn,
+                    value.exactAmountOut,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapPathExactAmountOut {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    tokenIn: tuple.0,
+                    steps: tuple.1,
+                    maxAmountIn: tuple.2,
+                    exactAmountOut: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapPathExactAmountOut {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapPathExactAmountOut {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.steps),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.maxAmountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.exactAmountOut),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapPathExactAmountOut {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapPathExactAmountOut {
+            const NAME: &'static str = "SwapPathExactAmountOut";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapPathExactAmountOut(address tokenIn,SwapPathStep[] steps,uint256 \
+                     maxAmountIn,uint256 exactAmountOut)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        SwapPathStep,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.steps)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxAmountIn)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.exactAmountOut,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapPathExactAmountOut {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        SwapPathStep,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.steps)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maxAmountIn,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.exactAmountOut,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    SwapPathStep,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.steps,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maxAmountIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.exactAmountOut,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SwapPathStep { address pool; address tokenOut; bool isBuffer; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapPathStep {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub isBuffer: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bool,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            bool,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapPathStep> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapPathStep) -> Self {
+                (value.pool, value.tokenOut, value.isBuffer)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapPathStep {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    pool: tuple.0,
+                    tokenOut: tuple.1,
+                    isBuffer: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SwapPathStep {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SwapPathStep {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isBuffer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SwapPathStep {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SwapPathStep {
+            const NAME: &'static str = "SwapPathStep";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SwapPathStep(address pool,address tokenOut,bool isBuffer)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.pool,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.isBuffer,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SwapPathStep {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.pool,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.isBuffer,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.pool,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.isBuffer,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IBatchRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`IBatchRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IBatchRouterInstance<P, N> {
+        IBatchRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IBatchRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IBatchRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IBatchRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IBatchRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IBatchRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IBatchRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IBatchRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`IBatchRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IBatchRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IBatchRouterInstance<P, N> {
+            IBatchRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IBatchRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IBatchRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IRouterCommon {
+    struct PermitApproval { address token; address owner; address spender; uint256 amount; uint256 nonce; uint256 deadline; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IRouterCommon {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitApproval { address token; address owner; address spender; uint256 amount; uint256 nonce; uint256 deadline; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitApproval {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitApproval> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitApproval) -> Self {
+                (
+                    value.token,
+                    value.owner,
+                    value.spender,
+                    value.amount,
+                    value.nonce,
+                    value.deadline,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitApproval {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    token: tuple.0,
+                    owner: tuple.1,
+                    spender: tuple.2,
+                    amount: tuple.3,
+                    nonce: tuple.4,
+                    deadline: tuple.5,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitApproval {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitApproval {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitApproval {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitApproval {
+            const NAME: &'static str = "PermitApproval";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitApproval(address token,address owner,address spender,uint256 \
+                     amount,uint256 nonce,uint256 deadline)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.owner,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.spender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitApproval {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.owner,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.spender,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deadline,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.owner,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.spender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deadline,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IRouterCommon`](self) contract instance.
+
+    See the [wrapper's documentation](`IRouterCommonInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IRouterCommonInstance<P, N> {
+        IRouterCommonInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IRouterCommon`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IRouterCommon`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IRouterCommonInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IRouterCommonInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IRouterCommonInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IRouterCommonInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IRouterCommon`](self) contract instance.
+
+        See the [wrapper's documentation](`IRouterCommonInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IRouterCommonInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IRouterCommonInstance<P, N> {
+            IRouterCommonInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IRouterCommonInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IRouterCommonInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IAllowanceTransfer {
+    struct PermitBatch {
+        PermitDetails[] details;
+        address spender;
+        uint256 sigDeadline;
+    }
+    struct PermitDetails {
+        address token;
+        uint160 amount;
+        uint48 expiration;
+        uint48 nonce;
+    }
+}
+
+library IBatchRouter {
+    struct SwapExactInHookParams {
+        address sender;
+        SwapPathExactAmountIn[] paths;
+        uint256 deadline;
+        bool wethIsEth;
+        bytes userData;
+    }
+    struct SwapExactOutHookParams {
+        address sender;
+        SwapPathExactAmountOut[] paths;
+        uint256 deadline;
+        bool wethIsEth;
+        bytes userData;
+    }
+    struct SwapPathExactAmountIn {
+        address tokenIn;
+        SwapPathStep[] steps;
+        uint256 exactAmountIn;
+        uint256 minAmountOut;
+    }
+    struct SwapPathExactAmountOut {
+        address tokenIn;
+        SwapPathStep[] steps;
+        uint256 maxAmountIn;
+        uint256 exactAmountOut;
+    }
+    struct SwapPathStep {
+        address pool;
+        address tokenOut;
+        bool isBuffer;
+    }
+}
+
+library IRouterCommon {
+    struct PermitApproval {
+        address token;
+        address owner;
+        address spender;
+        uint256 amount;
+        uint256 nonce;
+        uint256 deadline;
+    }
+}
+
+interface BalancerV3BatchRouter {
+    error AddressEmptyCode(address target);
+    error AddressInsufficientBalance(address account);
+    error ErrorSelectorNotFound();
+    error EthTransfer();
+    error FailedInnerCall();
+    error InputLengthMismatch();
+    error InsufficientEth();
+    error ReentrancyGuardReentrantCall();
+    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
+    error SafeERC20FailedOperation(address token);
+    error SenderIsNotVault(address sender);
+    error SwapDeadline();
+    error TransientIndexOutOfBounds();
+
+    constructor(address vault, address weth, address permit2, string routerVersion);
+
+    receive() external payable;
+
+    function getSender() external view returns (address);
+    function multicall(bytes[] memory data) external payable returns (bytes[] memory results);
+    function permitBatchAndCall(IRouterCommon.PermitApproval[] memory permitBatch, bytes[] memory permitSignatures, IAllowanceTransfer.PermitBatch memory permit2Batch, bytes memory permit2Signature, bytes[] memory multicallData) external payable returns (bytes[] memory results);
+    function querySwapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    function querySwapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    function querySwapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    function querySwapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    function swapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    function swapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    function swapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    function swapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    function version() external view returns (string memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "weth",
+        "type": "address",
+        "internalType": "contract IWETH"
+      },
+      {
+        "name": "permit2",
+        "type": "address",
+        "internalType": "contract IPermit2"
+      },
+      {
+        "name": "routerVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "getSender",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "multicall",
+    "inputs": [
+      {
+        "name": "data",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "results",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "permitBatchAndCall",
+    "inputs": [
+      {
+        "name": "permitBatch",
+        "type": "tuple[]",
+        "internalType": "struct IRouterCommon.PermitApproval[]",
+        "components": [
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "owner",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "spender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "permitSignatures",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      },
+      {
+        "name": "permit2Batch",
+        "type": "tuple",
+        "internalType": "struct IAllowanceTransfer.PermitBatch",
+        "components": [
+          {
+            "name": "details",
+            "type": "tuple[]",
+            "internalType": "struct IAllowanceTransfer.PermitDetails[]",
+            "components": [
+              {
+                "name": "token",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint160",
+                "internalType": "uint160"
+              },
+              {
+                "name": "expiration",
+                "type": "uint48",
+                "internalType": "uint48"
+              },
+              {
+                "name": "nonce",
+                "type": "uint48",
+                "internalType": "uint48"
+              }
+            ]
+          },
+          {
+            "name": "spender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "permit2Signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "multicallData",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "results",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "querySwapExactIn",
+    "inputs": [
+      {
+        "name": "paths",
+        "type": "tuple[]",
+        "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "steps",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathStep[]",
+            "components": [
+              {
+                "name": "pool",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "tokenOut",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "isBuffer",
+                "type": "bool",
+                "internalType": "bool"
+              }
+            ]
+          },
+          {
+            "name": "exactAmountIn",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minAmountOut",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensOut",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "querySwapExactInHook",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IBatchRouter.SwapExactInHookParams",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "paths",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
+            "components": [
+              {
+                "name": "tokenIn",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "steps",
+                "type": "tuple[]",
+                "internalType": "struct IBatchRouter.SwapPathStep[]",
+                "components": [
+                  {
+                    "name": "pool",
+                    "type": "address",
+                    "internalType": "address"
+                  },
+                  {
+                    "name": "tokenOut",
+                    "type": "address",
+                    "internalType": "contract IERC20"
+                  },
+                  {
+                    "name": "isBuffer",
+                    "type": "bool",
+                    "internalType": "bool"
+                  }
+                ]
+              },
+              {
+                "name": "exactAmountIn",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "minAmountOut",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "wethIsEth",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensOut",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "querySwapExactOut",
+    "inputs": [
+      {
+        "name": "paths",
+        "type": "tuple[]",
+        "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "steps",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathStep[]",
+            "components": [
+              {
+                "name": "pool",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "tokenOut",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "isBuffer",
+                "type": "bool",
+                "internalType": "bool"
+              }
+            ]
+          },
+          {
+            "name": "maxAmountIn",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "exactAmountOut",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensIn",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "querySwapExactOutHook",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IBatchRouter.SwapExactOutHookParams",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "paths",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
+            "components": [
+              {
+                "name": "tokenIn",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "steps",
+                "type": "tuple[]",
+                "internalType": "struct IBatchRouter.SwapPathStep[]",
+                "components": [
+                  {
+                    "name": "pool",
+                    "type": "address",
+                    "internalType": "address"
+                  },
+                  {
+                    "name": "tokenOut",
+                    "type": "address",
+                    "internalType": "contract IERC20"
+                  },
+                  {
+                    "name": "isBuffer",
+                    "type": "bool",
+                    "internalType": "bool"
+                  }
+                ]
+              },
+              {
+                "name": "maxAmountIn",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "exactAmountOut",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "wethIsEth",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensIn",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactIn",
+    "inputs": [
+      {
+        "name": "paths",
+        "type": "tuple[]",
+        "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "steps",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathStep[]",
+            "components": [
+              {
+                "name": "pool",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "tokenOut",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "isBuffer",
+                "type": "bool",
+                "internalType": "bool"
+              }
+            ]
+          },
+          {
+            "name": "exactAmountIn",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minAmountOut",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "wethIsEth",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensOut",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactInHook",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IBatchRouter.SwapExactInHookParams",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "paths",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
+            "components": [
+              {
+                "name": "tokenIn",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "steps",
+                "type": "tuple[]",
+                "internalType": "struct IBatchRouter.SwapPathStep[]",
+                "components": [
+                  {
+                    "name": "pool",
+                    "type": "address",
+                    "internalType": "address"
+                  },
+                  {
+                    "name": "tokenOut",
+                    "type": "address",
+                    "internalType": "contract IERC20"
+                  },
+                  {
+                    "name": "isBuffer",
+                    "type": "bool",
+                    "internalType": "bool"
+                  }
+                ]
+              },
+              {
+                "name": "exactAmountIn",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "minAmountOut",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "wethIsEth",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensOut",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsOut",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactOut",
+    "inputs": [
+      {
+        "name": "paths",
+        "type": "tuple[]",
+        "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "steps",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathStep[]",
+            "components": [
+              {
+                "name": "pool",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "tokenOut",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "isBuffer",
+                "type": "bool",
+                "internalType": "bool"
+              }
+            ]
+          },
+          {
+            "name": "maxAmountIn",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "exactAmountOut",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "wethIsEth",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensIn",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactOutHook",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IBatchRouter.SwapExactOutHookParams",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "paths",
+            "type": "tuple[]",
+            "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
+            "components": [
+              {
+                "name": "tokenIn",
+                "type": "address",
+                "internalType": "contract IERC20"
+              },
+              {
+                "name": "steps",
+                "type": "tuple[]",
+                "internalType": "struct IBatchRouter.SwapPathStep[]",
+                "components": [
+                  {
+                    "name": "pool",
+                    "type": "address",
+                    "internalType": "address"
+                  },
+                  {
+                    "name": "tokenOut",
+                    "type": "address",
+                    "internalType": "contract IERC20"
+                  },
+                  {
+                    "name": "isBuffer",
+                    "type": "bool",
+                    "internalType": "bool"
+                  }
+                ]
+              },
+              {
+                "name": "maxAmountIn",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "exactAmountOut",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "wethIsEth",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pathAmountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "tokensIn",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "amountsIn",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "error",
+    "name": "AddressEmptyCode",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "AddressInsufficientBalance",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ErrorSelectorNotFound",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "EthTransfer",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "FailedInnerCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InputLengthMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InsufficientEth",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReentrancyGuardReentrantCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SafeCastOverflowedUintDowncast",
+    "inputs": [
+      {
+        "name": "bits",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SafeERC20FailedOperation",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SenderIsNotVault",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SwapDeadline",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "TransientIndexOutOfBounds",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV3BatchRouter {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\xC0`@\x90\x80\x82R4a\x05\xC9WaK\xBD\x808\x03\x80\x91a\0\x1F\x82\x85a\x05\xE8V[\x839\x81\x01\x91`\x80\x82\x84\x03\x12a\x05\xC9W\x81Q`\x01`\x01`\xA0\x1B\x03\x93\x90\x84\x81\x16\x81\x03a\x05\xC9W` \x93\x84\x81\x01Q\x92\x86\x84\x16\x84\x03a\x05\xC9W\x84\x82\x01Q\x96\x87\x16\x87\x03a\x05\xC9W``\x82\x01Q`\x01`\x01`@\x1B\x03\x92\x83\x82\x11a\x05\xC9W\x01\x92`\x1F\x90\x82\x82\x86\x01\x12\x15a\x05\xC9W\x84Q\x84\x81\x11a\x05\xB5W`\x1F\x19\x95\x88Q\x94a\0\xA5\x8B\x89\x87\x86\x01\x16\x01\x87a\x05\xE8V[\x82\x86R\x8A\x83\x83\x01\x01\x11a\x05\xC9W\x81_\x92\x8B\x80\x93\x01\x83\x88\x01^\x85\x01\x01R`\x80R\x81Q\x92\x83\x11a\x05\xB5W_T\x91`\x01\x92\x83\x81\x81\x1C\x91\x16\x80\x15a\x05\xABW[\x89\x82\x10\x14a\x05\x97W\x82\x81\x11a\x05TW[P\x87\x91\x84\x11`\x01\x14a\x04\xF7W\x83\x94P\x90\x83\x92\x91_\x94a\x04\xECW[PP\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17_U[a\x01Ia\x01&a\x06\x0BV[\x83Q\x90a\x012\x82a\x05\xCDV[`\x06\x82Re9\xB2\xB722\xB9`\xD1\x1B\x86\x83\x01Ra\x06iV[`\xA0Ra\x01\x85a\x01Wa\x06\x0BV[\x83Q\x90a\x01c\x82a\x05\xCDV[`\x11\x82Rp\x1A\\\xD4\x99]\x1D\\\x9B\x91]\x1A\x13\x1B\xD8\xDA\xD9Y`z\x1B\x86\x83\x01Ra\x06iV[`\xC0R`\xE0Ra\x01\0\x92\x83Ra\x01\xCD\x81Qa\x01\x9F\x81a\x05\xCDV[`\x13\x81R\x7FcurrentSwapTokensIn\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x82\x01Ra\x063V[\x91a\x01 \x92\x83Ra\x02\x10\x82Qa\x01\xE2\x81a\x05\xCDV[`\x14\x81R\x7FcurrentSwapTokensOut\0\0\0\0\0\0\0\0\0\0\0\0\x83\x82\x01Ra\x063V[a\x01@\x90\x81Ra\x02R\x83Qa\x02$\x81a\x05\xCDV[`\x19\x81R\x7FcurrentSwapTokenInAmounts\0\0\0\0\0\0\0\x84\x82\x01Ra\x063V[\x90a\x01`\x91\x82Ra\x02\xD8a\x02\x98\x85Qa\x02j\x81a\x05\xCDV[`\x1A\x81R\x7FcurrentSwapTokenOutAmounts\0\0\0\0\0\0\x86\x82\x01Ra\x063V[\x93a\x01\x80\x94\x85R\x7FsettledTokenAmounts\0\0\0\0\0\0\0\0\0\0\0\0\0\x86Q\x91a\x02\xCC\x83a\x05\xCDV[`\x13\x83R\x82\x01Ra\x063V[\x93a\x01\xA0\x94\x85RQ\x94aD\xA1\x96\x87a\x07\x1C\x889`\x80Q\x87\x81\x81a\x02F\x01R\x81\x81a\x19|\x01R\x81\x81a\x1B\xE0\x01R\x81\x81a\x1E\"\x01R\x81\x81a y\x01R\x81\x81a\"\x12\x01R\x81\x81a##\x01R\x81\x81a#\xB1\x01R\x81\x81a$s\x01R\x81\x81a*\xAD\x01R\x81\x81a,\x8C\x01R\x81\x81a,\xD4\x01R\x81\x81a-R\x01R\x81\x81a-\xF9\x01R\x81\x81a/\x07\x01R\x81\x81a/\x84\x01R\x81\x81a2\x19\x01R\x81\x81a3H\x01R\x81\x81a3\xE5\x01R\x81\x81a4\xAB\x01R\x81\x81a;l\x01R\x81\x81a<\x91\x01R\x81\x81a>\xD0\x01R\x81\x81a@\x15\x01RaBq\x01R`\xA0Q\x87\x81\x81a\x02\xAA\x01R\x81\x81a\x055\x01R\x81\x81a\x18\x1F\x01Ra(\xBE\x01R`\xC0Q\x87\x81\x81a\x17\xA9\x01Ra6\xBA\x01R`\xE0Q\x87\x81\x81`\"\x01R\x81\x81a:\xFE\x01R\x81\x81a=\xE4\x01R\x81\x81a?X\x01Ra@\xAF\x01RQ\x86\x81\x81a\t\xF0\x01R\x81\x81a\x0B\x04\x01R\x81\x81a\x1Fn\x01R\x81\x81a\x1F\xF4\x01R\x81\x81a0y\x01Ra<m\x01RQ\x85\x81\x81a%i\x01R\x81\x81a'P\x01R\x81\x81a)Z\x01Ra5\xD8\x01RQ\x84\x81\x81a\x1CC\x01R\x81\x81a\x1E\x8F\x01R\x81\x81a\"u\x01R\x81\x81a$\xD7\x01R\x81\x81a%\xCE\x01R\x81\x81a',\x01R\x81\x81a+\x12\x01Ra5\xA8\x01RQ\x83\x81\x81a\x1DC\x01R\x81\x81a%\x95\x01R\x81\x81a'|\x01R\x81\x81a2\x8E\x01R\x81\x81a5\t\x01Ra6+\x01RQ\x82\x81\x81a\x1Cl\x01R\x81\x81a\x1E\xC0\x01R\x81\x81a%\x01\x01R\x81\x81a&!\x01R\x81\x81a'\xB4\x01R\x81\x81a+Q\x01Ra2\xD0\x01RQ\x81\x81\x81a\"\x9F\x01R\x81\x81a%\xFF\x01R\x81\x81a+\x82\x01R\x81\x81a.V\x01Ra6\t\x01R\xF3[\x01Q\x92P_\x80a\x01\nV[\x91\x93\x83\x16\x91_\x80R\x83\x88_ \x93_[\x8A\x88\x83\x83\x10a\x05=WPPP\x10a\x05%W[PPP\x81\x1B\x01_Ua\x01\x1BV[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x05\x18V[\x86\x86\x01Q\x88U\x90\x96\x01\x95\x94\x85\x01\x94\x87\x93P\x01a\x05\x06V[_\x80R\x88_ \x83\x80\x87\x01`\x05\x1C\x82\x01\x92\x8B\x88\x10a\x05\x8EW[\x01`\x05\x1C\x01\x90\x84\x90[\x82\x81\x10a\x05\x83WPPa\0\xF0V[_\x81U\x01\x84\x90a\x05uV[\x92P\x81\x92a\x05lV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x90`\x7F\x16\x90a\0\xE0V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80\xFD[`@\x81\x01\x90\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17a\x05\xB5W`@RV[`\x1F\x90\x91\x01`\x1F\x19\x16\x81\x01\x90`\x01`\x01`@\x1B\x03\x82\x11\x90\x82\x10\x17a\x05\xB5W`@RV[`@Q\x90a\x06\x18\x82a\x05\xCDV[`\x0C\x82Rk)7\xBA\xBA2\xB9!\xB7\xB6\xB6\xB7\xB7`\xA1\x1B` \x83\x01RV[a\x06f\x90`@Qa\x06C\x81a\x05\xCDV[`\x11\x81Rp!0\xBA1\xB4)7\xBA\xBA2\xB9!\xB7\xB6\xB6\xB7\xB7`y\x1B` \x82\x01Ra\x06iV[\x90V[\x90a\x06\xD6`:` \x92`@Q\x93\x84\x91\x81\x80\x84\x01\x97\x7Fbalancer-labs.v3.storage.\0\0\0\0\0\0\0\x89R\x80Q\x91\x82\x91\x01`9\x86\x01^\x83\x01\x90`\x17`\xF9\x1B`9\x83\x01R\x80Q\x92\x83\x91\x01\x85\x83\x01^\x01_\x83\x82\x01R\x03`\x1A\x81\x01\x84R\x01\x82a\x05\xE8V[Q\x90 _\x19\x81\x01\x90\x81\x11a\x07\x07W`@Q\x90` \x82\x01\x90\x81R` \x82Ra\x06\xFC\x82a\x05\xCDV[\x90Q\x90 `\xFF\x19\x16\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD\xFE`\x80`@R`\x046\x10\x15a\0rW[6\x15a\0\x18W_\x80\xFD[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\0JW\0[\x7F\x05@\xDD\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[_5`\xE0\x1C\x80c\x08\xA4e\xF6\x14a\x0E\x9DW\x80c\x19\xC6\x98\x9F\x14a\x08NW\x80c(oX\r\x14a\x07\xB7W\x80c)P(n\x14a\x06\xCCW\x80cT\xFDMP\x14a\x05\x8FW\x80cZ<9\x87\x14a\x05fW\x80c^\x01\xEBZ\x14a\x05!W\x80c\x8A\x12\xA0\x8C\x14a\x04\xC6W\x80c\x8E\xB1\xB6^\x14a\x03\xBFW\x80c\x94^\xD3?\x14a\x03DW\x80c\xAC\x96P\xD8\x14a\x03\0Wc\xE3\xB5\xDF\xF4\x03a\0\x0EW4a\x02\xFCW``\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x01-\x906\x90`\x04\x01a\x12\xC4V[a\x015a\x11\xA1V[`D5\x92\x83\x11a\x02\xFCWa\x01Pa\x01X\x936\x90`\x04\x01a\x0F\xCDV[\x93\x90\x91a(\xB9V[\x90_[\x83Q\x81\x10\x15a\x01|W\x80_\x87a\x01s`\x01\x94\x88a\x16\x91V[Q\x01R\x01a\x01[V[Pa\x01\xF0a\x01\xFEa\x029\x94a\x01\xB6_\x94\x88`@Q\x93a\x01\x9A\x85a\x11\x1AV[0\x85R` \x85\x01R_\x19`@\x85\x01R\x86``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x8A\x12\xA0\x8C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[\x03`\x1F\x19\x81\x01\x83R\x82a\x11RV[`@Q\x80\x94\x81\x92\x7F\xED\xFA5h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x92a\x02\x8E\x91_\x91a\x02\xCFW[P` \x80\x82Q\x83\x01\x01\x91\x01a\x15\xD4V[\x90\x93\x91\x92a\x02\xA7W[`@Q\x93\x84\x93\x84a\x0F/V[\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]a\x02\x97V[a\x02\xEB\x91P=\x80_\x83>a\x02\xE3\x81\x83a\x11RV[\x81\x01\x90a\x15MV[\x84a\x02~V[`@Q=_\x82>=\x90\xFD[_\x80\xFD[` `\x03\x196\x01\x12a\x02\xFCW`\x045g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x038a\x032a\x02\xA3\x926\x90`\x04\x01a\x0F\x9CV[\x90a\x17\x9BV[`@Q\x91\x82\x91\x82a\x10 V[4a\x02\xFCWa\x03R6a\x0E\xCAV[a\x03Za\x19EV[a\x03ba\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a(\xFBV[\x91\x93\x90\x94a\x03\x8A``a\x03\x83\x83a\x13DV[\x92\x01a\x13XV[\x90a')V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]`@Q\x93\x84\x93\x84a\x0F/V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x03\xEC\x906\x90`\x04\x01a\x12\xC4V[\x90a\x03\xF5a\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x04Qa\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[a\x04%3a(\xB9V[\x97`@Q\x94a\x043\x86a\x11\x1AV[3\x86R` \x86\x01R`$5`@\x86\x01R\x15\x15``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x94^\xD3?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`@Q\x80\x94\x81\x92\x7FH\xC8\x94\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x04\xDA6a\x0E\xCAV[a\x04\xE2a\x19EV[a\x04\xEAa\x19rV[a\x1A;V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x94\x92\x94]`@Q\x93\x84\x93\x84a\x0F/V[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW` \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\`\x01`\x01`\xA0\x1B\x03`@Q\x91\x16\x81R\xF3[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x05z6a\x0E\xCAV[a\x05\x82a\x19EV[a\x05\x8Aa\x19rV[a(\xFBV[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW`@Q_\x80T\x90`\x01\x82`\x01\x1C\x91`\x01\x84\x16\x91\x82\x15a\x06\xC2W[` \x94\x85\x85\x10\x84\x14a\x06\x95W\x85\x87\x94\x86\x86R\x91\x82_\x14a\x06WWPP`\x01\x14a\x05\xFEW[Pa\x05\xEA\x92P\x03\x83a\x11RV[a\x02\xA3`@Q\x92\x82\x84\x93\x84R\x83\x01\x90a\x0F\xFBV[_\x80\x80R\x85\x92P\x90\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c[\x85\x83\x10a\x06?WPPa\x05\xEA\x93P\x82\x01\x01\x85a\x05\xDDV[\x80T\x83\x89\x01\x85\x01R\x87\x94P\x86\x93\x90\x92\x01\x91\x81\x01a\x06(V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x85\x82\x01Ra\x05\xEA\x95\x15\x15`\x05\x1B\x85\x01\x01\x92P\x87\x91Pa\x05\xDD\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\"`\x04R`$_\xFD[\x92`\x7F\x16\x92a\x05\xB9V[4a\x02\xFCW```\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x06\xFE\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\x07a\x11\xA1V[`D5\x91\x82\x11a\x02\xFCWa\x07\"a\x07*\x926\x90`\x04\x01a\x0F\xCDV[\x92\x90\x91a(\xB9V[\x90_[\x84Q\x81\x10\x15a\x07_W\x80o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@a\x07V`\x01\x94\x89a\x16\x91V[Q\x01R\x01a\x07-V[Pa\x01\xF0a\x01\xFE\x85a\x07}_\x94a\x029\x97`@Q\x93a\x01\x9A\x85a\x11\x1AV[`\x80\x82\x01R`@Q\x92\x83\x91\x7FZ<9\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x07\xE4\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\xEDa\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x08\x14a\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x08\xA4e\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[`\xA0`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x11a\x02\xFCW6`#`\x045\x01\x12\x15a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045`\x04\x015\x11a\x02\xFCW6`$`\xC0`\x045`\x04\x015\x02`\x045\x01\x01\x11a\x02\xFCW`$5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x08\xC4\x906\x90`\x04\x01a\x0F\x9CV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D5\x11a\x02\xFCW```\x03\x19`D56\x03\x01\x12a\x02\xFCW`d5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t\x05\x906\x90`\x04\x01a\x0F\xCDV[`\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t%\x906\x90`\x04\x01a\x0F\x9CV[\x94\x90\x93a\t0a\x19EV[\x80`\x045`\x04\x015\x03a\x0EuW_[`\x045`\x04\x015\x81\x10a\x0B\xD2WPPP`D5`\x04\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDD`D56\x03\x01\x82\x12\x15a\x02\xFCW\x81`D5\x01`\x04\x81\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW`$\x82`\x07\x1B6\x03\x91\x01\x13a\x02\xFCWa\t\xE3W[a\x02\xA3a\x038\x86\x86_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]a\x17\x9BV[`\x01`\x01`\xA0\x1B\x03\x94\x92\x94\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x94\x7F*-\x80\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R3`\x04\x87\x01R```$\x87\x01R`\xC4\x86\x01\x92`D5\x01`$\x81\x01\x93g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04\x83\x015\x11a\x02\xFCW`\x04\x82\x015`\x07\x1B6\x03\x85\x13a\x02\xFCW```d\x89\x01R`\x04\x82\x015\x90R\x91\x92\x86\x92`\xE4\x84\x01\x92\x91\x90_\x90[`\x04\x81\x015\x82\x10a\x0BTWPPP` \x91`\x1F\x19`\x1F\x86_\x97\x87\x95`\x01`\x01`\xA0\x1B\x03a\n\xC8`$`D5\x01a\x11\x8DV[\x16`\x84\x88\x01R`D\x805\x015`\xA4\x88\x01R`\x03\x19\x87\x87\x03\x01`D\x88\x01R\x81\x86R\x87\x86\x017\x87\x86\x82\x86\x01\x01R\x01\x16\x01\x03\x01\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x93a\x038\x93a\x0BEW[\x82\x94P\x81\x93Pa\t\xB3V[a\x0BN\x90a\x11\x06V[\x84a\x0B:V[\x91\x95\x94P\x91\x92`\x01`\x01`\xA0\x1B\x03a\x0Bk\x87a\x11\x8DV[\x16\x81R` \x80\x87\x015\x91`\x01`\x01`\xA0\x1B\x03\x83\x16\x80\x93\x03a\x02\xFCW`\x04\x92`\x01\x92\x82\x01Ra\x0B\x9B`@\x89\x01a(\xA6V[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x91\x16`@\x83\x01Ra\x0B\xB6``\x8A\x01a(\xA6V[\x16``\x82\x01R`\x80\x80\x91\x01\x97\x01\x93\x01\x90P\x88\x94\x95\x93\x92\x91a\n\x97V[a\x0B\xE7a\x0B\xE0\x82\x84\x86a\x19*V[6\x91a\x13\x81V[`@Qa\x0B\xF3\x81a\x10\xA1V[_\x81R` \x91_\x83\x83\x01R_`@\x83\x01R\x82\x81\x01Q\x90```@\x82\x01Q\x91\x01Q_\x1A\x91\x83R\x83\x83\x01R`@\x82\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDC\x81\x85\x02`\x045\x016\x03\x01\x12a\x02\xFCW`@Q\x90a\x0C`\x82a\x10\xEAV[a\x0Cs`$`\xC0\x86\x02`\x045\x01\x01a\x11\x8DV[\x80\x83Ra\x0C\x89`D`\xC0\x87\x02`\x045\x01\x01a\x11\x8DV[\x90\x81\x85\x85\x01Ra\x0C\xA2`d`\xC0\x88\x02`\x045\x01\x01a\x11\x8DV[`@\x85\x81\x01\x91\x90\x91R`\x045`\xC0\x88\x02\x01`\x84\x81\x015``\x87\x01R`\xA4\x81\x015`\x80\x87\x01R`\xC4\x015`\xA0\x86\x01R\x83\x01Q\x83Q\x93\x86\x01Q`\xFF\x91\x90\x91\x16\x92`\x01`\x01`\xA0\x1B\x03\x83\x16;\x15a\x02\xFCW_`\x01`\x01`\xA0\x1B\x03\x80\x94`\xE4\x94\x8B\x98\x84\x98`\xC4`\xC0`@Q\x9C\x8D\x9B\x8C\x9A\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8CR\x16`\x04\x8B\x01R0`$\x8B\x01R`\x84\x82\x82\x02`\x045\x01\x015`D\x8B\x01R\x02`\x045\x01\x015`d\x88\x01R`\x84\x87\x01R`\xA4\x86\x01R`\xC4\x85\x01R\x16Z\xF1\x90\x81a\x0EfW[Pa\x0E\\Wa\r\x7Fa(wV[\x90`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x81\x83\x01Q\x16`D`@Q\x80\x95\x81\x93\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01R0`$\x83\x01RZ\xFA\x91\x82\x15a\x02\xF1W_\x92a\x0E,W[P``\x01Q\x03a\r\xF7WPP`\x01\x90[\x01a\t?V[\x80Q\x15a\x0E\x04W\x80Q\x91\x01\xFD[\x7F\xA7(V\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x0EUW[a\x0ED\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x90``a\r\xE1V[P=a\x0E:V[PP`\x01\x90a\r\xF1V[a\x0Eo\x90a\x11\x06V[\x8Aa\rrV[\x7F\xAA\xAD\x13\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[4a\x02\xFCWa\x0E\xAB6a\x0E\xCAV[a\x0E\xB3a\x19EV[a\x0E\xBBa\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a\x1A;V[`\x03\x19\x90` \x82\x82\x01\x12a\x02\xFCW`\x045\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW\x82`\xA0\x92\x03\x01\x12a\x02\xFCW`\x04\x01\x90V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a\x0F\x1BWPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a\x0F\rV[\x93\x92\x90a\x0FD\x90``\x86R``\x86\x01\x90a\x0E\xFCV[\x93` \x94\x81\x81\x03` \x83\x01R` \x80\x85Q\x92\x83\x81R\x01\x94\x01\x90_[\x81\x81\x10a\x0F\x7FWPPPa\x0F|\x93\x94P`@\x81\x84\x03\x91\x01Ra\x0E\xFCV[\x90V[\x82Q`\x01`\x01`\xA0\x1B\x03\x16\x86R\x94\x87\x01\x94\x91\x87\x01\x91`\x01\x01a\x0F_V[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x80\x85\x01\x94\x84`\x05\x1B\x01\x01\x11a\x02\xFCWV[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x83\x81\x86\x01\x95\x01\x01\x11a\x02\xFCWV[\x90`\x1F\x19`\x1F` \x80\x94\x80Q\x91\x82\x91\x82\x87R\x01\x86\x86\x01^_\x85\x82\x86\x01\x01R\x01\x16\x01\x01\x90V[` \x80\x82\x01\x90` \x83R\x83Q\x80\x92R`@\x83\x01\x92` `@\x84`\x05\x1B\x83\x01\x01\x95\x01\x93_\x91[\x84\x83\x10a\x10UWPPPPPP\x90V[\x90\x91\x92\x93\x94\x95\x84\x80a\x10\x91\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC0\x86`\x01\x96\x03\x01\x87R\x8AQa\x0F\xFBV[\x98\x01\x93\x01\x93\x01\x91\x94\x93\x92\x90a\x10EV[``\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`\xC0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`@RV[`\xA0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[`\xE0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x90`\x1F`\x1F\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x05\x1B` \x01\x90V[5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`D5\x90\x81\x15\x15\x82\x03a\x02\xFCWV[\x91\x90\x91`\x80\x81\x84\x03\x12a\x02\xFCW`@\x90\x81Q\x91`\x80\x83\x01\x94g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x84\x81\x10\x87\x82\x11\x17a\x10\xBDW\x82R\x83\x95a\x12\0\x84a\x11\x8DV[\x85R` \x90\x81\x85\x015\x90\x81\x11a\x02\xFCW\x84\x01\x82`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x90a\x12)\x82a\x11uV[\x93a\x126\x86Q\x95\x86a\x11RV[\x82\x85R\x83\x85\x01\x90\x84``\x80\x95\x02\x84\x01\x01\x92\x81\x84\x11a\x02\xFCW\x85\x01\x91[\x83\x83\x10a\x12tWPPPPP\x84\x01R\x81\x81\x015\x90\x83\x01R``\x90\x81\x015\x91\x01RV[\x84\x83\x83\x03\x12a\x02\xFCW\x87Q\x90a\x12\x89\x82a\x10\xA1V[a\x12\x92\x84a\x11\x8DV[\x82Ra\x12\x9F\x87\x85\x01a\x11\x8DV[\x87\x83\x01R\x88\x84\x015\x90\x81\x15\x15\x82\x03a\x02\xFCW\x82\x88\x92\x8B\x89\x95\x01R\x81R\x01\x92\x01\x91a\x12RV[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x91` \x91a\x12\xDE\x84a\x11uV[\x93a\x12\xEC`@Q\x95\x86a\x11RV[\x80\x85R\x83\x80\x86\x01\x91`\x05\x1B\x83\x01\x01\x92\x80\x84\x11a\x02\xFCW\x84\x83\x01\x91[\x84\x83\x10a\x13\x17WPPPPPP\x90V[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCW\x86\x91a\x139\x84\x84\x80\x94\x89\x01\x01a\x11\xC6V[\x81R\x01\x92\x01\x91a\x13\x07V[5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x90V[5\x80\x15\x15\x81\x03a\x02\xFCW\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x13\x8D\x82a\x13eV[\x91a\x13\x9B`@Q\x93\x84a\x11RV[\x82\x94\x81\x84R\x81\x83\x01\x11a\x02\xFCW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90`\x80\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x80\x82Q\x16\x83R` \x93\x84\x83\x01Q\x94`\x80\x81\x86\x01R\x85Q\x80\x92R\x80`\xA0\x86\x01\x96\x01\x92_\x90[\x83\x82\x10a\x14\x0BWPPPPP``\x81`@\x82\x93\x01Q`@\x85\x01R\x01Q\x91\x01R\x90V[\x84Q\x80Q\x82\x16\x89R\x80\x84\x01Q\x82\x16\x89\x85\x01R`@\x90\x81\x01Q\x15\x15\x90\x89\x01R``\x90\x97\x01\x96\x93\x82\x01\x93`\x01\x90\x91\x01\x90a\x13\xE9V[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x14\xBDWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x14\xF8\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x14\x81V[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x80Q\x90a\x15\x1E\x82a\x13eV[\x92a\x15,`@Q\x94\x85a\x11RV[\x82\x84R` \x83\x83\x01\x01\x11a\x02\xFCW\x81_\x92` \x80\x93\x01\x83\x86\x01^\x83\x01\x01R\x90V[\x90` \x82\x82\x03\x12a\x02\xFCW\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x80`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x90` \x91a\x15\x8E\x81a\x11uV[\x93a\x15\x9C`@Q\x95\x86a\x11RV[\x81\x85R` \x80\x86\x01\x92`\x05\x1B\x82\x01\x01\x92\x83\x11a\x02\xFCW` \x01\x90[\x82\x82\x10a\x15\xC5WPPPP\x90V[\x81Q\x81R\x90\x83\x01\x90\x83\x01a\x15\xB7V[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a\x16\0\x91\x83\x01a\x15sV[\x93` \x80\x83\x01Q\x85\x81\x11a\x02\xFCW\x83\x01\x90\x82`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x91a\x16(\x83a\x11uV[\x92a\x166`@Q\x94\x85a\x11RV[\x80\x84R\x82\x80\x85\x01\x91`\x05\x1B\x83\x01\x01\x91\x85\x83\x11a\x02\xFCW\x83\x01\x90[\x82\x82\x10a\x16rWPPPP\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15sV[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x81R\x90\x83\x01\x90\x83\x01a\x16PV[\x80Q\x82\x10\x15a\x16\xA5W` \x91`\x05\x1B\x01\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x17QWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x17\x8C\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x17\x15V[\x91\x90a\x17\xA63a(\xB9V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x84\\a\x18\xB1W`\x01\x90`\x01\x86]a\x17\xDF\x83a\x11uV[\x92a\x17\xED`@Q\x94\x85a\x11RV[\x80\x84R`\x1F\x19a\x17\xFC\x82a\x11uV[\x01_[\x81\x81\x10a\x18\xA0WPP_[\x81\x81\x10a\x18WWPPPP\x90_a\x18L\x92\x94]\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\\\x91a\x18NW[Pa6\xB1V[V[_\x90]_a\x18FV[\x80a\x18\x84_\x80a\x18la\x0B\xE0\x89\x96\x88\x8Aa\x19*V[` \x81Q\x91\x010Z\xF4a\x18}a(wV[\x900aA\\V[a\x18\x8E\x82\x88a\x16\x91V[Ra\x18\x99\x81\x87a\x16\x91V[P\x01a\x18\nV[\x80``` \x80\x93\x89\x01\x01R\x01a\x17\xFFV[\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x816\x03\x83\x13a\x02\xFCWV[\x90\x82\x10\x15a\x16\xA5Wa\x19A\x91`\x05\x1B\x81\x01\x90a\x18\xD9V[\x90\x91V[\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x80\\a\x18\xB1W`\x01\x90]V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\x19\xA4WV[\x7F\x08\x96v\xD5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R3`\x04R`$_\xFD[\x90a\x19\xDA\x82a\x11uV[a\x19\xE7`@Q\x91\x82a\x11RV[\x82\x81R`\x1F\x19a\x19\xF7\x82\x94a\x11uV[\x01\x90` 6\x91\x017V[\x91\x90\x82\x01\x80\x92\x11a\x1A\x0EWV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[`@\x81\x015B\x11a&\xC3W\x90a\x1A^a\x1AW` \x84\x01\x84a6\xF4V[\x90Pa\x19\xD0V[\x91_[a\x1An` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a%\xC7Wa\x1A\x98\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[6\x93\x91a7HV[a\x11\xC6V[\x93`@\x85\x01Q\x93`\x01`\x01`\xA0\x1B\x03\x86Q\x16\x90` \x87\x01Q\x80Q\x15a\x16\xA5W` \x01Q`@\x01Q\x15\x15\x80a%\xBEW[\x15a%cWa\x1A\xECa\x1A\xD8\x86a\x13DV[\x87\x84a\x1A\xE6``\x8A\x01a\x13XV[\x92a:\xDDV[_[` \x88\x01QQ\x81\x10\x15a%SWa\x1B\x03a7\x88V[` \x89\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW\x82\x14\x80` \x83\x01R\x82\x15\x82R_\x14a%LW``\x89\x01Q\x90[a\x1B;\x83` \x8C\x01Qa\x16\x91V[Q`@\x81\x01Q\x90\x91\x90\x15a\x1C\xEEWa\x1B\xD3`\x01`\x01`\xA0\x1B\x03\x83Q\x16\x93`\x01`\x01`\xA0\x1B\x03\x88\x16\x85\x14_\x14a\x1C\xE7W`\x01\x94[`@Q\x95a\x1B{\x87a\x11\x1AV[_\x87Ra\x1B\x87\x81a7\xBEV[` \x87\x01R`@\x86\x01R``\x94\x85\x91\x8D\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x93\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1C\xB0W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1C\x90\x93`\x01\x96\x95a\x1C8\x8C\x8Ca\x16\x91V[R\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x01a\x1A\xEEV[` \x01Q\x90\x97P`\x01`\x01`\xA0\x1B\x03\x16\x92P`\x01\x90a\x1C\x90V[` \x92\x94P\x90\x81a\x1C\xD5\x92\x90=\x10a\x1C\xE0W[a\x1C\xCD\x81\x83a\x11RV[\x81\x01\x90a7\xF5V[\x91PP\x92\x90_a\x1C\x10V[P=a\x1C\xC3V[_\x94a\x1BnV[\x88\x8A`\x01`\x01`\xA0\x1B\x03\x84\x95\x94Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x8A\x16\x14_\x14a!2WPP\x81Q\x15\x90Pa nW\x88\x8A\x80\x15\x15\x80a SW[a\x1FMW[`\x01`\x01`\xA0\x1B\x03\x93\x92\x91a\x1D\xDD\x82a\x1E\x15\x97\x8B_\x95\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\x16\x80\x88R\x82` R`@\x88 \\a\x1F<W[PPP[`\x01a\x1D\x9C\x89\x83Q\x16` \x84\x01\x99\x8B\x8BQ\x16\x90\x80\x15\x8A\x14a\x1F6WP\x83\x91aB#V[\x99\x90\x92Q\x16\x94a\x1D\xB1`\x80\x91\x82\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a\x1D\xC1\x89a\x10\xEAV[\x88R0` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x96\x81\x92\x7F!Ex\x97\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a9\xB1V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1F\x0CW[P` \x01Q\x15a\x1E\xE9W\x91a\x1E\xBC\x82`\x01`\x01`\xA0\x1B\x03`\x01\x96\x95a\x1Eza\x1E\xE4\x96\x86a\x16\x91V[Qa\x1E\x85\x8D\x8Da\x16\x91V[Ra\x1E\xB3\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x92a\x16\x91V[Q\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1C\x90V[\x98P`\x01\x92\x94Pa\x1F\x02\x90`\x01`\x01`\xA0\x1B\x03\x92a\x16\x91V[Q\x97Q\x16\x92a\x1C\x90V[` \x91\x94Pa\x1F,\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[\x81\x01\x90a9iV[P\x94\x91\x90Pa\x1ERV[\x91aB#V[a\x1FE\x92aCAV[_\x82\x81a\x1DuV[Pa\x1FZ\x90\x92\x91\x92a\x13DV[\x91a\x1Fd\x8BaB\xFDV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x04\x82\x01R0`$\x82\x01R\x90\x84\x16`D\x82\x01R\x92\x87\x16`d\x84\x01R_\x83\x80`\x84\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a DW[P\x97P\x92PP\x91\x92\x93Pa\x1D*V[a M\x90a\x11\x06V[_a 5V[Pa ]\x82a\x13DV[`\x01`\x01`\xA0\x1B\x03\x160\x14\x15a\x1D%V[\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91`\x01`\x01`\xA0\x1B\x03\x84Q\x16\x92\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`\x04\x85\x01R0`$\x85\x01R`D\x84\x01\x8C\x90R_\x90\x84\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a!#W[Pa\x1DyV[a!,\x90a\x11\x06V[_a!\x1DV[`\x01`\x01`\xA0\x1B\x03` \x87\x96\x94\x97\x01Q\x16\x90\x89\x81\x83\x14_\x14a#\xD7Wa!\xCD\x92Pa\"\x05\x97\x91P`\x01a!s_\x96\x95`\x01`\x01`\xA0\x1B\x03\x93\x84\x8BQ\x16aB#V[P\x92\x82\x89Q\x16\x95` \x89\x01Q\x15\x15\x88\x14a#\xAEWa!\x90\x82a\x13DV[\x94[a!\xA1`\x80\x93\x84\x81\x01\x90a\x18\xD9V[\x95\x90\x96`@Q\x99a!\xB1\x8Ba\x10\xEAV[\x8AR\x16` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x95\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W_\x93a#\x84W[P` \x01Q\x15a\"\xC3W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a\"i\x8C\x8Ca\x16\x91V[Ra\"\x99\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x81\x81\x01Q\x91Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R`$\x81\x01\x85\x90R\x93\x9AP\x90\x91\x16\x94P\x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa#YW[P`\x01\x90a\x1C\x90V[` \x90\x81=\x83\x11a#}W[a#o\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a#PV[P=a#eV[` \x91\x93Pa#\xA4\x90=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x81\x01\x90a8|V[P\x93\x91\x90Pa\"BV[\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a!\x92V[`\x01`\x01`\xA0\x1B\x03a$f\x95a$.\x93\x94\x95a#\xF8`\x80\x9B\x8C\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a$\x08\x89a\x116V[_\x89R` \x89\x01R\x16`@\x87\x01R``\x9A\x8B\x97\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x93\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a%%W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a$\xCB\x8C\x8Ca\x16\x91V[Ra$\xFB\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x92\x94P\x90\x81a%A\x92\x90=\x10a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[\x91PP\x92\x90_a$\xA3V[_\x90a\x1B-V[P\x91\x95P\x90\x93PP`\x01\x01a\x1AaV[a%\x8D\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[Pa%\xB9\x86\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1A\xECV[P2\x15\x15a\x1A\xC7V[PPa%\xF2\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a%\xFD\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a&c\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra&\x91`@_ \\\x82a&~\x85\x8Da\x16\x91V[Q\x16_R\x88` R`@_ \\\x90a\x1A\x01V[a&\x9B\x83\x87a\x16\x91V[Ra&\xA6\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a&DV[P\x94\x93\x91P\x91PV[\x7F\xE0\x8B\x8A\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90_\x19\x82\x01\x91\x82\x13`\x01\x16a\x1A\x0EWV[\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x1A\x0EW_\x19\x01\x90V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x81\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a'y\x81\\a&\xEBV[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91[_\x81\x12\x15a(:WPPPa'\xB1\x90a&\xEBV[\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92[_\x81\x12\x15a'\xEAWPPPPa\x18L\x90a6\xB1V[a(5\x90\x82_Ra(/` _\x83\x82\x82 \x01\\\x91\x82\x82R\x88\x81R\x88`@\x91a(\"\x8A\x8D\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a>\xB0V[\x84\x84RR\x81 ]\x84a>\rV[Pa&\xFCV[a'\xD5V[a(r\x90\x82_Ra(/` _\x8A\x87\x85\x84\x84 \x01\\\x93\x84\x84R\x81\x81Ra(\"\x8C`@\x94\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a:\xDDV[a'\x9DV[=\x15a(\xA1W=\x90a(\x88\x82a\x13eV[\x91a(\x96`@Q\x93\x84a\x11RV[\x82R=_` \x84\x01>V[``\x90V[5\x90e\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x82\x03a\x02\xFCWV[\x90_\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x81\\\x16\x15a(\xF1WPPV[\x90\x91\x92P]`\x01\x90V[\x90`@\x82\x015B\x11a&\xC3Wa)\x17a\x1AW` \x84\x01\x84a6\xF4V[\x91_[a)'` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a5\xD1Wa)D\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[``\x81\x01Q\x90a)~`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P` \x81\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW[_\x81\x12\x15a)\xA4WPPP`\x01\x01a)\x1AV[a)\xB2\x81` \x84\x01Qa\x16\x91V[Qa)\xBBa7\x88V[\x90\x82\x15` \x83\x01R` \x84\x01QQ\x80_\x19\x81\x01\x11a\x1A\x0EW_\x19\x01\x83\x14\x80\x83Ra5\x8FW[` \x82\x01Q\x15a5TW`@\x84\x01Q`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x91[`@\x81\x01Q\x15a,\x1DW\x83\x91`\x01`\x01`\xA0\x1B\x03``\x92` a*\xA0\x97\x01Q\x15\x15\x80a,\x14W[a+\xEDW[Q\x16\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x82\x03a+\xE6W`\x01\x91[`@Q\x92a*L\x84a\x11\x1AV[`\x01\x84Ra*Y\x81a7\xBEV[` \x84\x01R`@\x83\x01R\x88\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x95\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a+\xBFW[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a+\x02a+\xAB\x97\x96\x94a+u\x94a\x16\x91V[Ra+6`\x01`\x01`\xA0\x1B\x03\x82\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P`\x01`\x01`\xA0\x1B\x03a+M\x84`@\x8A\x01Qa7\xB1V[\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a&\xFCV[a)\x91V[PPPa+\xAB\x91\x93P\x92a&\xFCV[` \x91\x95Pa+\xDC\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa*\xE1V[_\x91a*?V[a,\x0Fa+\xF9\x8Da\x13DV[\x8D\x8Ba\x1A\xE6\x88`@\x88\x84Q\x16\x93\x01Q\x93\x01a\x13XV[a*(V[P2\x15\x15a*#V[\x90`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x85\x16\x14_\x14a17WP` \x84\x01Qa0IWP`@Q\x92\x7F\x96xp\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x85\x01R` \x84`$\x81`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15a\x02\xF1W_\x94a0\x15W[P\x83\x91`\x01`\x01`\xA0\x1B\x03\x81Q\x16`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x95\x90\x95R_\x85\x80`d\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a0\x06W[P[a\x1D\xDD`\x01`\x01`\xA0\x1B\x03a-\xA8\x8B\x82\x85Q\x16\x83` \x87\x01Q\x16\x90aB#V[P\x92Q\x16\x91\x8C`\x02a-\xBF`\x80\x92\x83\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a-\xCF\x88a\x10\xEAV[\x87R0` \x88\x01R\x89`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a/\xE3W[P` \x01Q\x15a.\xCFW\x90\x82\x91a+\xAB\x94\x93a.E\x89\x8Da\x16\x91V[Ra.z\x83`\x01`\x01`\xA0\x1B\x03\x84\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x80\x83\x10\x80a.\xB4W[a.\x90W[PPPa&\xFCV[a.\xA6a.\xAC\x93a.\xA0\x8Ba\x13DV[\x92a7\xB1V[\x91aCVV[_\x80\x80a.\x88V[P0`\x01`\x01`\xA0\x1B\x03a.\xC7\x8Ba\x13DV[\x16\x14\x15a.\x83V[\x94P\x90\x80\x94\x80\x82\x10a.\xE8W[PPPa+\xAB\x90a&\xFCV[\x91a.\xF8` \x92a/w\x94a7\xB1V[\x90a/-\x82`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83aCVV[`@Q\x93\x84\x92\x83\x92\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa/\xB8W[\x80\x80a.\xDCV[` \x90\x81=\x83\x11a/\xDCW[a/\xCE\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a/\xB1V[P=a/\xC4V[` \x91\x94Pa/\xFB\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[P\x90\x94\x91\x90Pa.)V[a0\x0F\x90a\x11\x06V[_a-\x86V[\x90\x93P` \x81=` \x11a0AW[\x81a01` \x93\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x92_a,\xBCV[=\x91Pa0$V[\x90\x92a0T\x89a\x13DV[`\x01`\x01`\xA0\x1B\x030\x91\x16\x03a0oW[_a-\xEC\x94a-\x88V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a0\xA3\x8Aa\x13DV[a0\xAC\x84aB\xFDV[\x90\x86;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R0`$\x82\x01R\x91\x81\x16`D\x83\x01R\x85\x16`d\x82\x01R\x94_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a1(W[P\x94PPa0eV[a11\x90a\x11\x06V[_a1\x1FV[`\x01`\x01`\xA0\x1B\x03` \x84\x96\x95\x94\x01Q\x16\x8A\x82\x82\x14_\x14a4\x0BWPPPa2\x0Ca1n_\x92\x84`\x01`\x01`\xA0\x1B\x03\x88Q\x16aB#V[\x92\x90a1\xD4\x8C`\x01`\x01`\xA0\x1B\x03\x80\x8AQ\x16\x93\x89Q\x15\x15\x86\x14a3\xDFWa1\xA3a1\x97\x84a\x13DV[\x93[`\x80\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a1\xB3\x88a\x10\xEAV[\x87R\x16` \x86\x01R`@\x85\x01R\x8C``\x85\x01R`\x02`\x80\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x93\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1W_\x91a3\xC4W[P` \x84\x01Q\x8C\x90\x8A\x90\x15a3\xAAW\x83\x83`\x01`\x01`\xA0\x1B\x03\x93a2\x83a2\x89\x94a2|\x8F\x9C\x9B\x9A\x98\x99a2\xB2\x9Aa\x16\x91V[Q\x92a\x16\x91V[Ra\x16\x91V[Q\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[Q\x15a2\xF4Wa+\xAB\x92\x91`\x01`\x01`\xA0\x1B\x03` a+\xA6\x93\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aCAV[Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R` \x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa3\x7FW[Pa+\xAB\x90a&\xFCV[` \x90\x81=\x83\x11a3\xA3W[a3\x95\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a3uV[P=a3\x8BV[PP\x90\x91Pa3\xBB\x92\x93\x96Pa\x16\x91V[Q\x93\x84\x91a2\xB2V[a3\xD8\x91P=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x90Pa2IV[a1\xA3\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a1\x99V[a4\x9E\x96P\x90a4f\x91``\x94\x8Ba4+`\x80\x99\x98\x99\x93\x84\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a4;\x89a\x116V[`\x01\x89R` \x89\x01R`\x01`\x01`\xA0\x1B\x03\x8B\x16`@\x89\x01R\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x95\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a5-W[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a5\x05a+\xAB\x97\x96\x94`\x01`\x01`\xA0\x1B\x03\x94a\x16\x91V[R\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x91\x95Pa5J\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa4\xDFV[o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x01`\x01`\xA0\x1B\x03` a5\x85\x81\x88\x01Qa5\x7F\x88a&\xEBV[\x90a\x16\x91V[Q\x01Q\x16\x91a)\xFCV[a5\xCC\x85`\x01`\x01`\xA0\x1B\x03` \x84\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[a)\xE0V[PPa5\xFC\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a6\x07\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a6m\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra6\x88`@_ \\\x82a&~\x85\x8Da\x16\x91V[a6\x92\x83\x87a\x16\x91V[Ra6\x9D\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a6NV[G\x80\x15a6\xF0W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\a6\xF0W`\x01`\x01`\xA0\x1B\x03a\x18L\x92\x16a@\xE0V[PPV[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x02\xFCWV[\x91\x90\x81\x10\x15a\x16\xA5W`\x05\x1B\x81\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x90V[`@Q\x90`@\x82\x01\x82\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@R_` \x83\x82\x81R\x01RV[\x91\x90\x82\x03\x91\x82\x11a\x1A\x0EWV[`\x02\x11\x15a7\xC8WV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x90\x81``\x91\x03\x12a\x02\xFCW\x80Q\x91`@` \x83\x01Q\x92\x01Q\x90V[a\x01\0`\xC0a\x0F|\x93` \x84R\x80Qa8(\x81a7\xBEV[` \x85\x01R` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x91\x16`@\x86\x01R\x80`@\x83\x01Q\x16``\x86\x01R``\x82\x01Q\x16`\x80\x85\x01R`\x80\x81\x01Q`\xA0\x85\x01R`\xA0\x81\x01Q\x82\x85\x01R\x01Q\x91`\xE0\x80\x82\x01R\x01\x90a\x0F\xFBV[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a8\xA8\x91\x83\x01a\x15sV[\x93` \x82\x01Q\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a8\xE4WPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a8\xD6V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01Ra91`@\x83\x01Q`\xC0``\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90``\x83\x01Q`\x80\x82\x01R`\x80\x83\x01Q`\x05\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91``\x83\x83\x03\x12a\x02\xFCW\x82Q\x92` \x81\x01Q\x92g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x81\x11a\x02\xFCW\x81a9\x9A\x91\x84\x01a\x15sV[\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01R`@\x82\x01Q``\x82\x01Ra9\xF4``\x83\x01Q`\xC0`\x80\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90`\x80\x83\x01Q`\x04\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91\x90\x91`\x80\x80`\xA0\x83\x01\x94\x80Qa:8\x81a7\xBEV[\x84R` \x81\x01Qa:H\x81a7\xBEV[` \x85\x01R`\x01`\x01`\xA0\x1B\x03`@\x82\x01Q\x16`@\x85\x01R``\x81\x01Q``\x85\x01R\x01Q\x91\x01RV[\x90\x81\\a:}\x81a\x11uV[a:\x8A`@Q\x91\x82a\x11RV[\x81\x81Ra:\x96\x82a\x11uV[`\x1F\x19` \x91\x016` \x84\x017\x81\x94_[\x84\x81\x10a:\xB5WPPPPPV[`\x01\x90\x82_R\x80\x84_ \x01\\`\x01`\x01`\xA0\x1B\x03a:\xD3\x83\x88a\x16\x91V[\x91\x16\x90R\x01a:\xA7V[\x91\x92\x80a=\xD8W[\x15a<QWPP\x80G\x10a<)W`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x82;\x15a\x02\xFCW`@Q\x90\x7F\xD0\xE3\r\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R_\x91_\x81`\x04\x81\x85\x89Z\xF1\x80\x15a\x02\xF1Wa<\x12W[P`D` \x92\x93\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a;\x98\x83\x87\x83aCVV[\x84`@Q\x96\x87\x94\x85\x93\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85R`\x04\x85\x01R`$\x84\x01RZ\xF1\x90\x81\x15a<\x06WPa;\xDFWPV[` \x90\x81=\x83\x11a;\xFFW[a;\xF5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWV[P=a;\xEBV[`@Q\x90=\x90\x82>=\x90\xFD[` \x92Pa<\x1F\x90a\x11\x06V[`D_\x92Pa;cV[\x7F\xA0\x1A\x9D\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91_\x90\x80a<aW[PPPPV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91a<\xBB\x84aB\xFDV[\x96\x80;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R\x84\x83\x16`$\x82\x01R\x97\x82\x16`D\x89\x01R\x91\x86\x16\x16`d\x87\x01R_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x94\x85\x15a\x02\xF1Wa=\x80\x95a=\xC4W[P\x82\x93` \x93`@Q\x80\x97\x81\x95\x82\x94\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x92Z\xF1\x90\x81\x15a<\x06WPa=\x99W[\x80\x80\x80a<[V[` \x90\x81=\x83\x11a=\xBDW[a=\xAF\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a=\x91V[P=a=\xA5V[` \x93Pa=\xD1\x90a\x11\x06V[_\x92a=/V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x82\x16\x14a:\xE5V[`\x01\x81\x01\x91\x80_R` \x91\x83\x83R`@_ \\\x80\x15\x15_\x14a>\xA7W_\x19\x90\x81\x81\x01\x83\\\x83\x80\x82\x01\x91\x82\x84\x03a>jW[PPPPP\x81\\\x81\x81\x01\x92\x81\x84\x11a\x1A\x0EW_\x93\x81]\x83R\x84\x83 \x01\x01]_RR_`@\x81 ]`\x01\x90V[a>wa>\x87\x93\x88aD:V[\x86_R\x88_ \x01\x01\\\x91\x85aD:V[\x83_R\x80\x83\x83\x88_ \x01\x01]_R\x85\x85R`@_ ]_\x80\x80\x83\x81a>>V[PPPPP_\x90V[_\x94\x93\x83\x15a@\xD8W\x80a@\xA3W[\x15a@\x07W`\x01`\x01`\xA0\x1B\x03\x91\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`\x04\x83\x01R0`$\x83\x01R`D\x82\x01\x85\x90R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa?\xF4W[P\x84\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a?\xF0W\x81\x90`$`@Q\x80\x94\x81\x93\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R\x89`\x04\x84\x01RZ\xF1\x80\x15a?\xE5Wa?\xCDW[Pa\x18L\x93\x94P\x16a@\xE0V[a?\xD7\x86\x91a\x11\x06V[a?\xE1W\x84a?\xC0V[\x84\x80\xFD[`@Q=\x88\x82>=\x90\xFD[P\x80\xFD[a?\xFF\x91\x95Pa\x11\x06V[_\x93_a?SV[\x92\x93P\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x93\x90\x92\x16`$\x84\x01R`D\x83\x01R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa@\x9AWPV[a\x18L\x90a\x11\x06V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x83\x16\x14a>\xBFV[PPPP\x90PV[\x81G\x10aA0W_\x80\x80\x93`\x01`\x01`\xA0\x1B\x03\x82\x94\x16Z\xF1aA\0a(wV[P\x15aA\x08WV[\x7F\x14%\xEAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x7F\xCDx`Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R0`\x04R`$_\xFD[\x90aAqWP\x80Q\x15aA\x08W\x80Q\x90` \x01\xFD[\x81Q\x15\x80aA\xB7W[aA\x82WP\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x7F\x99\x96\xB3\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R\x16`\x04R`$_\xFD[P\x80;\x15aAzV[`\x01\x81\x01\x90\x82_R\x81` R`@_ \\\x15_\x14aB\x03W\x80\\\x81_R\x83\x81` _ \x01]`\x01\x81\x01\x80\x91\x11a\x1A\x0EW\x81]\\\x91_R` R`@_ ]`\x01\x90V[PPP_\x90V[\x90_R` RaB\x1F`@_ \x91\x82\\a\x1A\x01V[\x90]V[\x91`D\x92\x93\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x94\x85\x92\x82\x80\x85Q\x99\x8A\x95\x86\x94\x7F\xC9\xC1f\x1B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R\x16`\x04\x85\x01R\x16`$\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15aB\xF3W_\x93_\x95aB\xBCW[PPaB\xB9aB\xB2\x85\x94a\x19\xD0V[\x94\x85a\x16\x91V[RV[\x80\x92\x95P\x81\x94P=\x83\x11aB\xECW[aB\xD5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW` \x82Q\x92\x01Q\x92_\x80aB\xA3V[P=aB\xCBV[\x83Q=_\x82>=\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x81\x11aC\x11W\x16\x90V[\x7Fm\xFC\xC6P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\xA0`\x04R`$R`D_\xFD[\x90_R` RaB\x1F`@_ \x91\x82\\a7\xB1V[`@Q\x92` \x84\x01\x90\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R`\x01`\x01`\xA0\x1B\x03\x80\x94\x16`$\x86\x01R`D\x85\x01R`D\x84R`\x80\x84\x01\x90\x84\x82\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x17a\x10\xBDWaC\xD5\x93_\x93\x84\x93`@R\x16\x94Q\x90\x82\x86Z\xF1aC\xCEa(wV[\x90\x83aA\\V[\x80Q\x90\x81\x15\x15\x91\x82aD\x16W[PPaC\xEBWPV[\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04R`$_\xFD[\x81\x92P\x90` \x91\x81\x01\x03\x12a\x02\xFCW` \x01Q\x80\x15\x90\x81\x15\x03a\x02\xFCW_\x80aC\xE2V[\\\x11\x15aDCWV[\x7F\x0FJ\xE0\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD\xFE\xA2dipfsX\"\x12 \"\x9A\\\xF8\x9A\xA7\xC2\xD0\xA4\xB4\xD5\xDB \xBB\xA6\xC2\xB3\xA7K\x08\x03\x03\xFCn\xC0\x0B\xA5\x82\xA5\xDC\xF7QdsolcC\0\x08\x1A\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`\x046\x10\x15a\0rW[6\x15a\0\x18W_\x80\xFD[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\0JW\0[\x7F\x05@\xDD\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[_5`\xE0\x1C\x80c\x08\xA4e\xF6\x14a\x0E\x9DW\x80c\x19\xC6\x98\x9F\x14a\x08NW\x80c(oX\r\x14a\x07\xB7W\x80c)P(n\x14a\x06\xCCW\x80cT\xFDMP\x14a\x05\x8FW\x80cZ<9\x87\x14a\x05fW\x80c^\x01\xEBZ\x14a\x05!W\x80c\x8A\x12\xA0\x8C\x14a\x04\xC6W\x80c\x8E\xB1\xB6^\x14a\x03\xBFW\x80c\x94^\xD3?\x14a\x03DW\x80c\xAC\x96P\xD8\x14a\x03\0Wc\xE3\xB5\xDF\xF4\x03a\0\x0EW4a\x02\xFCW``\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x01-\x906\x90`\x04\x01a\x12\xC4V[a\x015a\x11\xA1V[`D5\x92\x83\x11a\x02\xFCWa\x01Pa\x01X\x936\x90`\x04\x01a\x0F\xCDV[\x93\x90\x91a(\xB9V[\x90_[\x83Q\x81\x10\x15a\x01|W\x80_\x87a\x01s`\x01\x94\x88a\x16\x91V[Q\x01R\x01a\x01[V[Pa\x01\xF0a\x01\xFEa\x029\x94a\x01\xB6_\x94\x88`@Q\x93a\x01\x9A\x85a\x11\x1AV[0\x85R` \x85\x01R_\x19`@\x85\x01R\x86``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x8A\x12\xA0\x8C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[\x03`\x1F\x19\x81\x01\x83R\x82a\x11RV[`@Q\x80\x94\x81\x92\x7F\xED\xFA5h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x92a\x02\x8E\x91_\x91a\x02\xCFW[P` \x80\x82Q\x83\x01\x01\x91\x01a\x15\xD4V[\x90\x93\x91\x92a\x02\xA7W[`@Q\x93\x84\x93\x84a\x0F/V[\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]a\x02\x97V[a\x02\xEB\x91P=\x80_\x83>a\x02\xE3\x81\x83a\x11RV[\x81\x01\x90a\x15MV[\x84a\x02~V[`@Q=_\x82>=\x90\xFD[_\x80\xFD[` `\x03\x196\x01\x12a\x02\xFCW`\x045g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x038a\x032a\x02\xA3\x926\x90`\x04\x01a\x0F\x9CV[\x90a\x17\x9BV[`@Q\x91\x82\x91\x82a\x10 V[4a\x02\xFCWa\x03R6a\x0E\xCAV[a\x03Za\x19EV[a\x03ba\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a(\xFBV[\x91\x93\x90\x94a\x03\x8A``a\x03\x83\x83a\x13DV[\x92\x01a\x13XV[\x90a')V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]`@Q\x93\x84\x93\x84a\x0F/V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x03\xEC\x906\x90`\x04\x01a\x12\xC4V[\x90a\x03\xF5a\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x04Qa\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[a\x04%3a(\xB9V[\x97`@Q\x94a\x043\x86a\x11\x1AV[3\x86R` \x86\x01R`$5`@\x86\x01R\x15\x15``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x94^\xD3?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`@Q\x80\x94\x81\x92\x7FH\xC8\x94\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x04\xDA6a\x0E\xCAV[a\x04\xE2a\x19EV[a\x04\xEAa\x19rV[a\x1A;V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x94\x92\x94]`@Q\x93\x84\x93\x84a\x0F/V[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW` \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\`\x01`\x01`\xA0\x1B\x03`@Q\x91\x16\x81R\xF3[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x05z6a\x0E\xCAV[a\x05\x82a\x19EV[a\x05\x8Aa\x19rV[a(\xFBV[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW`@Q_\x80T\x90`\x01\x82`\x01\x1C\x91`\x01\x84\x16\x91\x82\x15a\x06\xC2W[` \x94\x85\x85\x10\x84\x14a\x06\x95W\x85\x87\x94\x86\x86R\x91\x82_\x14a\x06WWPP`\x01\x14a\x05\xFEW[Pa\x05\xEA\x92P\x03\x83a\x11RV[a\x02\xA3`@Q\x92\x82\x84\x93\x84R\x83\x01\x90a\x0F\xFBV[_\x80\x80R\x85\x92P\x90\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c[\x85\x83\x10a\x06?WPPa\x05\xEA\x93P\x82\x01\x01\x85a\x05\xDDV[\x80T\x83\x89\x01\x85\x01R\x87\x94P\x86\x93\x90\x92\x01\x91\x81\x01a\x06(V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x85\x82\x01Ra\x05\xEA\x95\x15\x15`\x05\x1B\x85\x01\x01\x92P\x87\x91Pa\x05\xDD\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\"`\x04R`$_\xFD[\x92`\x7F\x16\x92a\x05\xB9V[4a\x02\xFCW```\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x06\xFE\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\x07a\x11\xA1V[`D5\x91\x82\x11a\x02\xFCWa\x07\"a\x07*\x926\x90`\x04\x01a\x0F\xCDV[\x92\x90\x91a(\xB9V[\x90_[\x84Q\x81\x10\x15a\x07_W\x80o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@a\x07V`\x01\x94\x89a\x16\x91V[Q\x01R\x01a\x07-V[Pa\x01\xF0a\x01\xFE\x85a\x07}_\x94a\x029\x97`@Q\x93a\x01\x9A\x85a\x11\x1AV[`\x80\x82\x01R`@Q\x92\x83\x91\x7FZ<9\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x07\xE4\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\xEDa\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x08\x14a\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x08\xA4e\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[`\xA0`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x11a\x02\xFCW6`#`\x045\x01\x12\x15a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045`\x04\x015\x11a\x02\xFCW6`$`\xC0`\x045`\x04\x015\x02`\x045\x01\x01\x11a\x02\xFCW`$5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x08\xC4\x906\x90`\x04\x01a\x0F\x9CV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D5\x11a\x02\xFCW```\x03\x19`D56\x03\x01\x12a\x02\xFCW`d5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t\x05\x906\x90`\x04\x01a\x0F\xCDV[`\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t%\x906\x90`\x04\x01a\x0F\x9CV[\x94\x90\x93a\t0a\x19EV[\x80`\x045`\x04\x015\x03a\x0EuW_[`\x045`\x04\x015\x81\x10a\x0B\xD2WPPP`D5`\x04\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDD`D56\x03\x01\x82\x12\x15a\x02\xFCW\x81`D5\x01`\x04\x81\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW`$\x82`\x07\x1B6\x03\x91\x01\x13a\x02\xFCWa\t\xE3W[a\x02\xA3a\x038\x86\x86_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]a\x17\x9BV[`\x01`\x01`\xA0\x1B\x03\x94\x92\x94\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x94\x7F*-\x80\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R3`\x04\x87\x01R```$\x87\x01R`\xC4\x86\x01\x92`D5\x01`$\x81\x01\x93g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04\x83\x015\x11a\x02\xFCW`\x04\x82\x015`\x07\x1B6\x03\x85\x13a\x02\xFCW```d\x89\x01R`\x04\x82\x015\x90R\x91\x92\x86\x92`\xE4\x84\x01\x92\x91\x90_\x90[`\x04\x81\x015\x82\x10a\x0BTWPPP` \x91`\x1F\x19`\x1F\x86_\x97\x87\x95`\x01`\x01`\xA0\x1B\x03a\n\xC8`$`D5\x01a\x11\x8DV[\x16`\x84\x88\x01R`D\x805\x015`\xA4\x88\x01R`\x03\x19\x87\x87\x03\x01`D\x88\x01R\x81\x86R\x87\x86\x017\x87\x86\x82\x86\x01\x01R\x01\x16\x01\x03\x01\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x93a\x038\x93a\x0BEW[\x82\x94P\x81\x93Pa\t\xB3V[a\x0BN\x90a\x11\x06V[\x84a\x0B:V[\x91\x95\x94P\x91\x92`\x01`\x01`\xA0\x1B\x03a\x0Bk\x87a\x11\x8DV[\x16\x81R` \x80\x87\x015\x91`\x01`\x01`\xA0\x1B\x03\x83\x16\x80\x93\x03a\x02\xFCW`\x04\x92`\x01\x92\x82\x01Ra\x0B\x9B`@\x89\x01a(\xA6V[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x91\x16`@\x83\x01Ra\x0B\xB6``\x8A\x01a(\xA6V[\x16``\x82\x01R`\x80\x80\x91\x01\x97\x01\x93\x01\x90P\x88\x94\x95\x93\x92\x91a\n\x97V[a\x0B\xE7a\x0B\xE0\x82\x84\x86a\x19*V[6\x91a\x13\x81V[`@Qa\x0B\xF3\x81a\x10\xA1V[_\x81R` \x91_\x83\x83\x01R_`@\x83\x01R\x82\x81\x01Q\x90```@\x82\x01Q\x91\x01Q_\x1A\x91\x83R\x83\x83\x01R`@\x82\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDC\x81\x85\x02`\x045\x016\x03\x01\x12a\x02\xFCW`@Q\x90a\x0C`\x82a\x10\xEAV[a\x0Cs`$`\xC0\x86\x02`\x045\x01\x01a\x11\x8DV[\x80\x83Ra\x0C\x89`D`\xC0\x87\x02`\x045\x01\x01a\x11\x8DV[\x90\x81\x85\x85\x01Ra\x0C\xA2`d`\xC0\x88\x02`\x045\x01\x01a\x11\x8DV[`@\x85\x81\x01\x91\x90\x91R`\x045`\xC0\x88\x02\x01`\x84\x81\x015``\x87\x01R`\xA4\x81\x015`\x80\x87\x01R`\xC4\x015`\xA0\x86\x01R\x83\x01Q\x83Q\x93\x86\x01Q`\xFF\x91\x90\x91\x16\x92`\x01`\x01`\xA0\x1B\x03\x83\x16;\x15a\x02\xFCW_`\x01`\x01`\xA0\x1B\x03\x80\x94`\xE4\x94\x8B\x98\x84\x98`\xC4`\xC0`@Q\x9C\x8D\x9B\x8C\x9A\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8CR\x16`\x04\x8B\x01R0`$\x8B\x01R`\x84\x82\x82\x02`\x045\x01\x015`D\x8B\x01R\x02`\x045\x01\x015`d\x88\x01R`\x84\x87\x01R`\xA4\x86\x01R`\xC4\x85\x01R\x16Z\xF1\x90\x81a\x0EfW[Pa\x0E\\Wa\r\x7Fa(wV[\x90`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x81\x83\x01Q\x16`D`@Q\x80\x95\x81\x93\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01R0`$\x83\x01RZ\xFA\x91\x82\x15a\x02\xF1W_\x92a\x0E,W[P``\x01Q\x03a\r\xF7WPP`\x01\x90[\x01a\t?V[\x80Q\x15a\x0E\x04W\x80Q\x91\x01\xFD[\x7F\xA7(V\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x0EUW[a\x0ED\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x90``a\r\xE1V[P=a\x0E:V[PP`\x01\x90a\r\xF1V[a\x0Eo\x90a\x11\x06V[\x8Aa\rrV[\x7F\xAA\xAD\x13\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[4a\x02\xFCWa\x0E\xAB6a\x0E\xCAV[a\x0E\xB3a\x19EV[a\x0E\xBBa\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a\x1A;V[`\x03\x19\x90` \x82\x82\x01\x12a\x02\xFCW`\x045\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW\x82`\xA0\x92\x03\x01\x12a\x02\xFCW`\x04\x01\x90V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a\x0F\x1BWPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a\x0F\rV[\x93\x92\x90a\x0FD\x90``\x86R``\x86\x01\x90a\x0E\xFCV[\x93` \x94\x81\x81\x03` \x83\x01R` \x80\x85Q\x92\x83\x81R\x01\x94\x01\x90_[\x81\x81\x10a\x0F\x7FWPPPa\x0F|\x93\x94P`@\x81\x84\x03\x91\x01Ra\x0E\xFCV[\x90V[\x82Q`\x01`\x01`\xA0\x1B\x03\x16\x86R\x94\x87\x01\x94\x91\x87\x01\x91`\x01\x01a\x0F_V[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x80\x85\x01\x94\x84`\x05\x1B\x01\x01\x11a\x02\xFCWV[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x83\x81\x86\x01\x95\x01\x01\x11a\x02\xFCWV[\x90`\x1F\x19`\x1F` \x80\x94\x80Q\x91\x82\x91\x82\x87R\x01\x86\x86\x01^_\x85\x82\x86\x01\x01R\x01\x16\x01\x01\x90V[` \x80\x82\x01\x90` \x83R\x83Q\x80\x92R`@\x83\x01\x92` `@\x84`\x05\x1B\x83\x01\x01\x95\x01\x93_\x91[\x84\x83\x10a\x10UWPPPPPP\x90V[\x90\x91\x92\x93\x94\x95\x84\x80a\x10\x91\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC0\x86`\x01\x96\x03\x01\x87R\x8AQa\x0F\xFBV[\x98\x01\x93\x01\x93\x01\x91\x94\x93\x92\x90a\x10EV[``\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`\xC0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`@RV[`\xA0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[`\xE0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x90`\x1F`\x1F\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x05\x1B` \x01\x90V[5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`D5\x90\x81\x15\x15\x82\x03a\x02\xFCWV[\x91\x90\x91`\x80\x81\x84\x03\x12a\x02\xFCW`@\x90\x81Q\x91`\x80\x83\x01\x94g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x84\x81\x10\x87\x82\x11\x17a\x10\xBDW\x82R\x83\x95a\x12\0\x84a\x11\x8DV[\x85R` \x90\x81\x85\x015\x90\x81\x11a\x02\xFCW\x84\x01\x82`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x90a\x12)\x82a\x11uV[\x93a\x126\x86Q\x95\x86a\x11RV[\x82\x85R\x83\x85\x01\x90\x84``\x80\x95\x02\x84\x01\x01\x92\x81\x84\x11a\x02\xFCW\x85\x01\x91[\x83\x83\x10a\x12tWPPPPP\x84\x01R\x81\x81\x015\x90\x83\x01R``\x90\x81\x015\x91\x01RV[\x84\x83\x83\x03\x12a\x02\xFCW\x87Q\x90a\x12\x89\x82a\x10\xA1V[a\x12\x92\x84a\x11\x8DV[\x82Ra\x12\x9F\x87\x85\x01a\x11\x8DV[\x87\x83\x01R\x88\x84\x015\x90\x81\x15\x15\x82\x03a\x02\xFCW\x82\x88\x92\x8B\x89\x95\x01R\x81R\x01\x92\x01\x91a\x12RV[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x91` \x91a\x12\xDE\x84a\x11uV[\x93a\x12\xEC`@Q\x95\x86a\x11RV[\x80\x85R\x83\x80\x86\x01\x91`\x05\x1B\x83\x01\x01\x92\x80\x84\x11a\x02\xFCW\x84\x83\x01\x91[\x84\x83\x10a\x13\x17WPPPPPP\x90V[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCW\x86\x91a\x139\x84\x84\x80\x94\x89\x01\x01a\x11\xC6V[\x81R\x01\x92\x01\x91a\x13\x07V[5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x90V[5\x80\x15\x15\x81\x03a\x02\xFCW\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x13\x8D\x82a\x13eV[\x91a\x13\x9B`@Q\x93\x84a\x11RV[\x82\x94\x81\x84R\x81\x83\x01\x11a\x02\xFCW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90`\x80\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x80\x82Q\x16\x83R` \x93\x84\x83\x01Q\x94`\x80\x81\x86\x01R\x85Q\x80\x92R\x80`\xA0\x86\x01\x96\x01\x92_\x90[\x83\x82\x10a\x14\x0BWPPPPP``\x81`@\x82\x93\x01Q`@\x85\x01R\x01Q\x91\x01R\x90V[\x84Q\x80Q\x82\x16\x89R\x80\x84\x01Q\x82\x16\x89\x85\x01R`@\x90\x81\x01Q\x15\x15\x90\x89\x01R``\x90\x97\x01\x96\x93\x82\x01\x93`\x01\x90\x91\x01\x90a\x13\xE9V[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x14\xBDWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x14\xF8\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x14\x81V[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x80Q\x90a\x15\x1E\x82a\x13eV[\x92a\x15,`@Q\x94\x85a\x11RV[\x82\x84R` \x83\x83\x01\x01\x11a\x02\xFCW\x81_\x92` \x80\x93\x01\x83\x86\x01^\x83\x01\x01R\x90V[\x90` \x82\x82\x03\x12a\x02\xFCW\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x80`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x90` \x91a\x15\x8E\x81a\x11uV[\x93a\x15\x9C`@Q\x95\x86a\x11RV[\x81\x85R` \x80\x86\x01\x92`\x05\x1B\x82\x01\x01\x92\x83\x11a\x02\xFCW` \x01\x90[\x82\x82\x10a\x15\xC5WPPPP\x90V[\x81Q\x81R\x90\x83\x01\x90\x83\x01a\x15\xB7V[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a\x16\0\x91\x83\x01a\x15sV[\x93` \x80\x83\x01Q\x85\x81\x11a\x02\xFCW\x83\x01\x90\x82`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x91a\x16(\x83a\x11uV[\x92a\x166`@Q\x94\x85a\x11RV[\x80\x84R\x82\x80\x85\x01\x91`\x05\x1B\x83\x01\x01\x91\x85\x83\x11a\x02\xFCW\x83\x01\x90[\x82\x82\x10a\x16rWPPPP\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15sV[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x81R\x90\x83\x01\x90\x83\x01a\x16PV[\x80Q\x82\x10\x15a\x16\xA5W` \x91`\x05\x1B\x01\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x17QWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x17\x8C\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x17\x15V[\x91\x90a\x17\xA63a(\xB9V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x84\\a\x18\xB1W`\x01\x90`\x01\x86]a\x17\xDF\x83a\x11uV[\x92a\x17\xED`@Q\x94\x85a\x11RV[\x80\x84R`\x1F\x19a\x17\xFC\x82a\x11uV[\x01_[\x81\x81\x10a\x18\xA0WPP_[\x81\x81\x10a\x18WWPPPP\x90_a\x18L\x92\x94]\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\\\x91a\x18NW[Pa6\xB1V[V[_\x90]_a\x18FV[\x80a\x18\x84_\x80a\x18la\x0B\xE0\x89\x96\x88\x8Aa\x19*V[` \x81Q\x91\x010Z\xF4a\x18}a(wV[\x900aA\\V[a\x18\x8E\x82\x88a\x16\x91V[Ra\x18\x99\x81\x87a\x16\x91V[P\x01a\x18\nV[\x80``` \x80\x93\x89\x01\x01R\x01a\x17\xFFV[\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x816\x03\x83\x13a\x02\xFCWV[\x90\x82\x10\x15a\x16\xA5Wa\x19A\x91`\x05\x1B\x81\x01\x90a\x18\xD9V[\x90\x91V[\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x80\\a\x18\xB1W`\x01\x90]V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\x19\xA4WV[\x7F\x08\x96v\xD5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R3`\x04R`$_\xFD[\x90a\x19\xDA\x82a\x11uV[a\x19\xE7`@Q\x91\x82a\x11RV[\x82\x81R`\x1F\x19a\x19\xF7\x82\x94a\x11uV[\x01\x90` 6\x91\x017V[\x91\x90\x82\x01\x80\x92\x11a\x1A\x0EWV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[`@\x81\x015B\x11a&\xC3W\x90a\x1A^a\x1AW` \x84\x01\x84a6\xF4V[\x90Pa\x19\xD0V[\x91_[a\x1An` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a%\xC7Wa\x1A\x98\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[6\x93\x91a7HV[a\x11\xC6V[\x93`@\x85\x01Q\x93`\x01`\x01`\xA0\x1B\x03\x86Q\x16\x90` \x87\x01Q\x80Q\x15a\x16\xA5W` \x01Q`@\x01Q\x15\x15\x80a%\xBEW[\x15a%cWa\x1A\xECa\x1A\xD8\x86a\x13DV[\x87\x84a\x1A\xE6``\x8A\x01a\x13XV[\x92a:\xDDV[_[` \x88\x01QQ\x81\x10\x15a%SWa\x1B\x03a7\x88V[` \x89\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW\x82\x14\x80` \x83\x01R\x82\x15\x82R_\x14a%LW``\x89\x01Q\x90[a\x1B;\x83` \x8C\x01Qa\x16\x91V[Q`@\x81\x01Q\x90\x91\x90\x15a\x1C\xEEWa\x1B\xD3`\x01`\x01`\xA0\x1B\x03\x83Q\x16\x93`\x01`\x01`\xA0\x1B\x03\x88\x16\x85\x14_\x14a\x1C\xE7W`\x01\x94[`@Q\x95a\x1B{\x87a\x11\x1AV[_\x87Ra\x1B\x87\x81a7\xBEV[` \x87\x01R`@\x86\x01R``\x94\x85\x91\x8D\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x93\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1C\xB0W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1C\x90\x93`\x01\x96\x95a\x1C8\x8C\x8Ca\x16\x91V[R\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x01a\x1A\xEEV[` \x01Q\x90\x97P`\x01`\x01`\xA0\x1B\x03\x16\x92P`\x01\x90a\x1C\x90V[` \x92\x94P\x90\x81a\x1C\xD5\x92\x90=\x10a\x1C\xE0W[a\x1C\xCD\x81\x83a\x11RV[\x81\x01\x90a7\xF5V[\x91PP\x92\x90_a\x1C\x10V[P=a\x1C\xC3V[_\x94a\x1BnV[\x88\x8A`\x01`\x01`\xA0\x1B\x03\x84\x95\x94Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x8A\x16\x14_\x14a!2WPP\x81Q\x15\x90Pa nW\x88\x8A\x80\x15\x15\x80a SW[a\x1FMW[`\x01`\x01`\xA0\x1B\x03\x93\x92\x91a\x1D\xDD\x82a\x1E\x15\x97\x8B_\x95\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\x16\x80\x88R\x82` R`@\x88 \\a\x1F<W[PPP[`\x01a\x1D\x9C\x89\x83Q\x16` \x84\x01\x99\x8B\x8BQ\x16\x90\x80\x15\x8A\x14a\x1F6WP\x83\x91aB#V[\x99\x90\x92Q\x16\x94a\x1D\xB1`\x80\x91\x82\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a\x1D\xC1\x89a\x10\xEAV[\x88R0` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x96\x81\x92\x7F!Ex\x97\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a9\xB1V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1F\x0CW[P` \x01Q\x15a\x1E\xE9W\x91a\x1E\xBC\x82`\x01`\x01`\xA0\x1B\x03`\x01\x96\x95a\x1Eza\x1E\xE4\x96\x86a\x16\x91V[Qa\x1E\x85\x8D\x8Da\x16\x91V[Ra\x1E\xB3\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x92a\x16\x91V[Q\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1C\x90V[\x98P`\x01\x92\x94Pa\x1F\x02\x90`\x01`\x01`\xA0\x1B\x03\x92a\x16\x91V[Q\x97Q\x16\x92a\x1C\x90V[` \x91\x94Pa\x1F,\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[\x81\x01\x90a9iV[P\x94\x91\x90Pa\x1ERV[\x91aB#V[a\x1FE\x92aCAV[_\x82\x81a\x1DuV[Pa\x1FZ\x90\x92\x91\x92a\x13DV[\x91a\x1Fd\x8BaB\xFDV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x04\x82\x01R0`$\x82\x01R\x90\x84\x16`D\x82\x01R\x92\x87\x16`d\x84\x01R_\x83\x80`\x84\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a DW[P\x97P\x92PP\x91\x92\x93Pa\x1D*V[a M\x90a\x11\x06V[_a 5V[Pa ]\x82a\x13DV[`\x01`\x01`\xA0\x1B\x03\x160\x14\x15a\x1D%V[\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91`\x01`\x01`\xA0\x1B\x03\x84Q\x16\x92\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`\x04\x85\x01R0`$\x85\x01R`D\x84\x01\x8C\x90R_\x90\x84\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a!#W[Pa\x1DyV[a!,\x90a\x11\x06V[_a!\x1DV[`\x01`\x01`\xA0\x1B\x03` \x87\x96\x94\x97\x01Q\x16\x90\x89\x81\x83\x14_\x14a#\xD7Wa!\xCD\x92Pa\"\x05\x97\x91P`\x01a!s_\x96\x95`\x01`\x01`\xA0\x1B\x03\x93\x84\x8BQ\x16aB#V[P\x92\x82\x89Q\x16\x95` \x89\x01Q\x15\x15\x88\x14a#\xAEWa!\x90\x82a\x13DV[\x94[a!\xA1`\x80\x93\x84\x81\x01\x90a\x18\xD9V[\x95\x90\x96`@Q\x99a!\xB1\x8Ba\x10\xEAV[\x8AR\x16` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x95\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W_\x93a#\x84W[P` \x01Q\x15a\"\xC3W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a\"i\x8C\x8Ca\x16\x91V[Ra\"\x99\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x81\x81\x01Q\x91Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R`$\x81\x01\x85\x90R\x93\x9AP\x90\x91\x16\x94P\x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa#YW[P`\x01\x90a\x1C\x90V[` \x90\x81=\x83\x11a#}W[a#o\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a#PV[P=a#eV[` \x91\x93Pa#\xA4\x90=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x81\x01\x90a8|V[P\x93\x91\x90Pa\"BV[\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a!\x92V[`\x01`\x01`\xA0\x1B\x03a$f\x95a$.\x93\x94\x95a#\xF8`\x80\x9B\x8C\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a$\x08\x89a\x116V[_\x89R` \x89\x01R\x16`@\x87\x01R``\x9A\x8B\x97\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x93\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a%%W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a$\xCB\x8C\x8Ca\x16\x91V[Ra$\xFB\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x92\x94P\x90\x81a%A\x92\x90=\x10a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[\x91PP\x92\x90_a$\xA3V[_\x90a\x1B-V[P\x91\x95P\x90\x93PP`\x01\x01a\x1AaV[a%\x8D\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[Pa%\xB9\x86\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1A\xECV[P2\x15\x15a\x1A\xC7V[PPa%\xF2\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a%\xFD\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a&c\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra&\x91`@_ \\\x82a&~\x85\x8Da\x16\x91V[Q\x16_R\x88` R`@_ \\\x90a\x1A\x01V[a&\x9B\x83\x87a\x16\x91V[Ra&\xA6\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a&DV[P\x94\x93\x91P\x91PV[\x7F\xE0\x8B\x8A\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90_\x19\x82\x01\x91\x82\x13`\x01\x16a\x1A\x0EWV[\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x1A\x0EW_\x19\x01\x90V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x81\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a'y\x81\\a&\xEBV[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91[_\x81\x12\x15a(:WPPPa'\xB1\x90a&\xEBV[\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92[_\x81\x12\x15a'\xEAWPPPPa\x18L\x90a6\xB1V[a(5\x90\x82_Ra(/` _\x83\x82\x82 \x01\\\x91\x82\x82R\x88\x81R\x88`@\x91a(\"\x8A\x8D\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a>\xB0V[\x84\x84RR\x81 ]\x84a>\rV[Pa&\xFCV[a'\xD5V[a(r\x90\x82_Ra(/` _\x8A\x87\x85\x84\x84 \x01\\\x93\x84\x84R\x81\x81Ra(\"\x8C`@\x94\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a:\xDDV[a'\x9DV[=\x15a(\xA1W=\x90a(\x88\x82a\x13eV[\x91a(\x96`@Q\x93\x84a\x11RV[\x82R=_` \x84\x01>V[``\x90V[5\x90e\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x82\x03a\x02\xFCWV[\x90_\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x81\\\x16\x15a(\xF1WPPV[\x90\x91\x92P]`\x01\x90V[\x90`@\x82\x015B\x11a&\xC3Wa)\x17a\x1AW` \x84\x01\x84a6\xF4V[\x91_[a)'` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a5\xD1Wa)D\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[``\x81\x01Q\x90a)~`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P` \x81\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW[_\x81\x12\x15a)\xA4WPPP`\x01\x01a)\x1AV[a)\xB2\x81` \x84\x01Qa\x16\x91V[Qa)\xBBa7\x88V[\x90\x82\x15` \x83\x01R` \x84\x01QQ\x80_\x19\x81\x01\x11a\x1A\x0EW_\x19\x01\x83\x14\x80\x83Ra5\x8FW[` \x82\x01Q\x15a5TW`@\x84\x01Q`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x91[`@\x81\x01Q\x15a,\x1DW\x83\x91`\x01`\x01`\xA0\x1B\x03``\x92` a*\xA0\x97\x01Q\x15\x15\x80a,\x14W[a+\xEDW[Q\x16\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x82\x03a+\xE6W`\x01\x91[`@Q\x92a*L\x84a\x11\x1AV[`\x01\x84Ra*Y\x81a7\xBEV[` \x84\x01R`@\x83\x01R\x88\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x95\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a+\xBFW[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a+\x02a+\xAB\x97\x96\x94a+u\x94a\x16\x91V[Ra+6`\x01`\x01`\xA0\x1B\x03\x82\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P`\x01`\x01`\xA0\x1B\x03a+M\x84`@\x8A\x01Qa7\xB1V[\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a&\xFCV[a)\x91V[PPPa+\xAB\x91\x93P\x92a&\xFCV[` \x91\x95Pa+\xDC\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa*\xE1V[_\x91a*?V[a,\x0Fa+\xF9\x8Da\x13DV[\x8D\x8Ba\x1A\xE6\x88`@\x88\x84Q\x16\x93\x01Q\x93\x01a\x13XV[a*(V[P2\x15\x15a*#V[\x90`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x85\x16\x14_\x14a17WP` \x84\x01Qa0IWP`@Q\x92\x7F\x96xp\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x85\x01R` \x84`$\x81`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15a\x02\xF1W_\x94a0\x15W[P\x83\x91`\x01`\x01`\xA0\x1B\x03\x81Q\x16`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x95\x90\x95R_\x85\x80`d\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a0\x06W[P[a\x1D\xDD`\x01`\x01`\xA0\x1B\x03a-\xA8\x8B\x82\x85Q\x16\x83` \x87\x01Q\x16\x90aB#V[P\x92Q\x16\x91\x8C`\x02a-\xBF`\x80\x92\x83\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a-\xCF\x88a\x10\xEAV[\x87R0` \x88\x01R\x89`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a/\xE3W[P` \x01Q\x15a.\xCFW\x90\x82\x91a+\xAB\x94\x93a.E\x89\x8Da\x16\x91V[Ra.z\x83`\x01`\x01`\xA0\x1B\x03\x84\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x80\x83\x10\x80a.\xB4W[a.\x90W[PPPa&\xFCV[a.\xA6a.\xAC\x93a.\xA0\x8Ba\x13DV[\x92a7\xB1V[\x91aCVV[_\x80\x80a.\x88V[P0`\x01`\x01`\xA0\x1B\x03a.\xC7\x8Ba\x13DV[\x16\x14\x15a.\x83V[\x94P\x90\x80\x94\x80\x82\x10a.\xE8W[PPPa+\xAB\x90a&\xFCV[\x91a.\xF8` \x92a/w\x94a7\xB1V[\x90a/-\x82`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83aCVV[`@Q\x93\x84\x92\x83\x92\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa/\xB8W[\x80\x80a.\xDCV[` \x90\x81=\x83\x11a/\xDCW[a/\xCE\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a/\xB1V[P=a/\xC4V[` \x91\x94Pa/\xFB\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[P\x90\x94\x91\x90Pa.)V[a0\x0F\x90a\x11\x06V[_a-\x86V[\x90\x93P` \x81=` \x11a0AW[\x81a01` \x93\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x92_a,\xBCV[=\x91Pa0$V[\x90\x92a0T\x89a\x13DV[`\x01`\x01`\xA0\x1B\x030\x91\x16\x03a0oW[_a-\xEC\x94a-\x88V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a0\xA3\x8Aa\x13DV[a0\xAC\x84aB\xFDV[\x90\x86;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R0`$\x82\x01R\x91\x81\x16`D\x83\x01R\x85\x16`d\x82\x01R\x94_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a1(W[P\x94PPa0eV[a11\x90a\x11\x06V[_a1\x1FV[`\x01`\x01`\xA0\x1B\x03` \x84\x96\x95\x94\x01Q\x16\x8A\x82\x82\x14_\x14a4\x0BWPPPa2\x0Ca1n_\x92\x84`\x01`\x01`\xA0\x1B\x03\x88Q\x16aB#V[\x92\x90a1\xD4\x8C`\x01`\x01`\xA0\x1B\x03\x80\x8AQ\x16\x93\x89Q\x15\x15\x86\x14a3\xDFWa1\xA3a1\x97\x84a\x13DV[\x93[`\x80\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a1\xB3\x88a\x10\xEAV[\x87R\x16` \x86\x01R`@\x85\x01R\x8C``\x85\x01R`\x02`\x80\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x93\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1W_\x91a3\xC4W[P` \x84\x01Q\x8C\x90\x8A\x90\x15a3\xAAW\x83\x83`\x01`\x01`\xA0\x1B\x03\x93a2\x83a2\x89\x94a2|\x8F\x9C\x9B\x9A\x98\x99a2\xB2\x9Aa\x16\x91V[Q\x92a\x16\x91V[Ra\x16\x91V[Q\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[Q\x15a2\xF4Wa+\xAB\x92\x91`\x01`\x01`\xA0\x1B\x03` a+\xA6\x93\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aCAV[Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R` \x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa3\x7FW[Pa+\xAB\x90a&\xFCV[` \x90\x81=\x83\x11a3\xA3W[a3\x95\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a3uV[P=a3\x8BV[PP\x90\x91Pa3\xBB\x92\x93\x96Pa\x16\x91V[Q\x93\x84\x91a2\xB2V[a3\xD8\x91P=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x90Pa2IV[a1\xA3\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a1\x99V[a4\x9E\x96P\x90a4f\x91``\x94\x8Ba4+`\x80\x99\x98\x99\x93\x84\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a4;\x89a\x116V[`\x01\x89R` \x89\x01R`\x01`\x01`\xA0\x1B\x03\x8B\x16`@\x89\x01R\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x95\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a5-W[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a5\x05a+\xAB\x97\x96\x94`\x01`\x01`\xA0\x1B\x03\x94a\x16\x91V[R\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x91\x95Pa5J\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa4\xDFV[o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x01`\x01`\xA0\x1B\x03` a5\x85\x81\x88\x01Qa5\x7F\x88a&\xEBV[\x90a\x16\x91V[Q\x01Q\x16\x91a)\xFCV[a5\xCC\x85`\x01`\x01`\xA0\x1B\x03` \x84\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[a)\xE0V[PPa5\xFC\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a6\x07\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a6m\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra6\x88`@_ \\\x82a&~\x85\x8Da\x16\x91V[a6\x92\x83\x87a\x16\x91V[Ra6\x9D\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a6NV[G\x80\x15a6\xF0W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\a6\xF0W`\x01`\x01`\xA0\x1B\x03a\x18L\x92\x16a@\xE0V[PPV[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x02\xFCWV[\x91\x90\x81\x10\x15a\x16\xA5W`\x05\x1B\x81\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x90V[`@Q\x90`@\x82\x01\x82\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@R_` \x83\x82\x81R\x01RV[\x91\x90\x82\x03\x91\x82\x11a\x1A\x0EWV[`\x02\x11\x15a7\xC8WV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x90\x81``\x91\x03\x12a\x02\xFCW\x80Q\x91`@` \x83\x01Q\x92\x01Q\x90V[a\x01\0`\xC0a\x0F|\x93` \x84R\x80Qa8(\x81a7\xBEV[` \x85\x01R` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x91\x16`@\x86\x01R\x80`@\x83\x01Q\x16``\x86\x01R``\x82\x01Q\x16`\x80\x85\x01R`\x80\x81\x01Q`\xA0\x85\x01R`\xA0\x81\x01Q\x82\x85\x01R\x01Q\x91`\xE0\x80\x82\x01R\x01\x90a\x0F\xFBV[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a8\xA8\x91\x83\x01a\x15sV[\x93` \x82\x01Q\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a8\xE4WPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a8\xD6V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01Ra91`@\x83\x01Q`\xC0``\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90``\x83\x01Q`\x80\x82\x01R`\x80\x83\x01Q`\x05\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91``\x83\x83\x03\x12a\x02\xFCW\x82Q\x92` \x81\x01Q\x92g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x81\x11a\x02\xFCW\x81a9\x9A\x91\x84\x01a\x15sV[\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01R`@\x82\x01Q``\x82\x01Ra9\xF4``\x83\x01Q`\xC0`\x80\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90`\x80\x83\x01Q`\x04\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91\x90\x91`\x80\x80`\xA0\x83\x01\x94\x80Qa:8\x81a7\xBEV[\x84R` \x81\x01Qa:H\x81a7\xBEV[` \x85\x01R`\x01`\x01`\xA0\x1B\x03`@\x82\x01Q\x16`@\x85\x01R``\x81\x01Q``\x85\x01R\x01Q\x91\x01RV[\x90\x81\\a:}\x81a\x11uV[a:\x8A`@Q\x91\x82a\x11RV[\x81\x81Ra:\x96\x82a\x11uV[`\x1F\x19` \x91\x016` \x84\x017\x81\x94_[\x84\x81\x10a:\xB5WPPPPPV[`\x01\x90\x82_R\x80\x84_ \x01\\`\x01`\x01`\xA0\x1B\x03a:\xD3\x83\x88a\x16\x91V[\x91\x16\x90R\x01a:\xA7V[\x91\x92\x80a=\xD8W[\x15a<QWPP\x80G\x10a<)W`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x82;\x15a\x02\xFCW`@Q\x90\x7F\xD0\xE3\r\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R_\x91_\x81`\x04\x81\x85\x89Z\xF1\x80\x15a\x02\xF1Wa<\x12W[P`D` \x92\x93\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a;\x98\x83\x87\x83aCVV[\x84`@Q\x96\x87\x94\x85\x93\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85R`\x04\x85\x01R`$\x84\x01RZ\xF1\x90\x81\x15a<\x06WPa;\xDFWPV[` \x90\x81=\x83\x11a;\xFFW[a;\xF5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWV[P=a;\xEBV[`@Q\x90=\x90\x82>=\x90\xFD[` \x92Pa<\x1F\x90a\x11\x06V[`D_\x92Pa;cV[\x7F\xA0\x1A\x9D\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91_\x90\x80a<aW[PPPPV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91a<\xBB\x84aB\xFDV[\x96\x80;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R\x84\x83\x16`$\x82\x01R\x97\x82\x16`D\x89\x01R\x91\x86\x16\x16`d\x87\x01R_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x94\x85\x15a\x02\xF1Wa=\x80\x95a=\xC4W[P\x82\x93` \x93`@Q\x80\x97\x81\x95\x82\x94\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x92Z\xF1\x90\x81\x15a<\x06WPa=\x99W[\x80\x80\x80a<[V[` \x90\x81=\x83\x11a=\xBDW[a=\xAF\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a=\x91V[P=a=\xA5V[` \x93Pa=\xD1\x90a\x11\x06V[_\x92a=/V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x82\x16\x14a:\xE5V[`\x01\x81\x01\x91\x80_R` \x91\x83\x83R`@_ \\\x80\x15\x15_\x14a>\xA7W_\x19\x90\x81\x81\x01\x83\\\x83\x80\x82\x01\x91\x82\x84\x03a>jW[PPPPP\x81\\\x81\x81\x01\x92\x81\x84\x11a\x1A\x0EW_\x93\x81]\x83R\x84\x83 \x01\x01]_RR_`@\x81 ]`\x01\x90V[a>wa>\x87\x93\x88aD:V[\x86_R\x88_ \x01\x01\\\x91\x85aD:V[\x83_R\x80\x83\x83\x88_ \x01\x01]_R\x85\x85R`@_ ]_\x80\x80\x83\x81a>>V[PPPPP_\x90V[_\x94\x93\x83\x15a@\xD8W\x80a@\xA3W[\x15a@\x07W`\x01`\x01`\xA0\x1B\x03\x91\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`\x04\x83\x01R0`$\x83\x01R`D\x82\x01\x85\x90R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa?\xF4W[P\x84\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a?\xF0W\x81\x90`$`@Q\x80\x94\x81\x93\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R\x89`\x04\x84\x01RZ\xF1\x80\x15a?\xE5Wa?\xCDW[Pa\x18L\x93\x94P\x16a@\xE0V[a?\xD7\x86\x91a\x11\x06V[a?\xE1W\x84a?\xC0V[\x84\x80\xFD[`@Q=\x88\x82>=\x90\xFD[P\x80\xFD[a?\xFF\x91\x95Pa\x11\x06V[_\x93_a?SV[\x92\x93P\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x93\x90\x92\x16`$\x84\x01R`D\x83\x01R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa@\x9AWPV[a\x18L\x90a\x11\x06V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x83\x16\x14a>\xBFV[PPPP\x90PV[\x81G\x10aA0W_\x80\x80\x93`\x01`\x01`\xA0\x1B\x03\x82\x94\x16Z\xF1aA\0a(wV[P\x15aA\x08WV[\x7F\x14%\xEAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x7F\xCDx`Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R0`\x04R`$_\xFD[\x90aAqWP\x80Q\x15aA\x08W\x80Q\x90` \x01\xFD[\x81Q\x15\x80aA\xB7W[aA\x82WP\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x7F\x99\x96\xB3\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R\x16`\x04R`$_\xFD[P\x80;\x15aAzV[`\x01\x81\x01\x90\x82_R\x81` R`@_ \\\x15_\x14aB\x03W\x80\\\x81_R\x83\x81` _ \x01]`\x01\x81\x01\x80\x91\x11a\x1A\x0EW\x81]\\\x91_R` R`@_ ]`\x01\x90V[PPP_\x90V[\x90_R` RaB\x1F`@_ \x91\x82\\a\x1A\x01V[\x90]V[\x91`D\x92\x93\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x94\x85\x92\x82\x80\x85Q\x99\x8A\x95\x86\x94\x7F\xC9\xC1f\x1B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R\x16`\x04\x85\x01R\x16`$\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15aB\xF3W_\x93_\x95aB\xBCW[PPaB\xB9aB\xB2\x85\x94a\x19\xD0V[\x94\x85a\x16\x91V[RV[\x80\x92\x95P\x81\x94P=\x83\x11aB\xECW[aB\xD5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW` \x82Q\x92\x01Q\x92_\x80aB\xA3V[P=aB\xCBV[\x83Q=_\x82>=\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x81\x11aC\x11W\x16\x90V[\x7Fm\xFC\xC6P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\xA0`\x04R`$R`D_\xFD[\x90_R` RaB\x1F`@_ \x91\x82\\a7\xB1V[`@Q\x92` \x84\x01\x90\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R`\x01`\x01`\xA0\x1B\x03\x80\x94\x16`$\x86\x01R`D\x85\x01R`D\x84R`\x80\x84\x01\x90\x84\x82\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x17a\x10\xBDWaC\xD5\x93_\x93\x84\x93`@R\x16\x94Q\x90\x82\x86Z\xF1aC\xCEa(wV[\x90\x83aA\\V[\x80Q\x90\x81\x15\x15\x91\x82aD\x16W[PPaC\xEBWPV[\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04R`$_\xFD[\x81\x92P\x90` \x91\x81\x01\x03\x12a\x02\xFCW` \x01Q\x80\x15\x90\x81\x15\x03a\x02\xFCW_\x80aC\xE2V[\\\x11\x15aDCWV[\x7F\x0FJ\xE0\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD\xFE\xA2dipfsX\"\x12 \"\x9A\\\xF8\x9A\xA7\xC2\xD0\xA4\xB4\xD5\xDB \xBB\xA6\xC2\xB3\xA7K\x08\x03\x03\xFCn\xC0\x0B\xA5\x82\xA5\xDC\xF7QdsolcC\0\x08\x1A\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`.
+    ```solidity
+    error AddressEmptyCode(address target);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct AddressEmptyCode {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
+            fn from(value: AddressEmptyCode) -> Self {
+                (value.target,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { target: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for AddressEmptyCode {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
+            const SIGNATURE: &'static str = "AddressEmptyCode(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `AddressInsufficientBalance(address)` and selector `0xcd786059`.
+    ```solidity
+    error AddressInsufficientBalance(address account);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct AddressInsufficientBalance {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<AddressInsufficientBalance> for UnderlyingRustTuple<'_> {
+            fn from(value: AddressInsufficientBalance) -> Self {
+                (value.account,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressInsufficientBalance {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { account: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for AddressInsufficientBalance {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [205u8, 120u8, 96u8, 89u8];
+            const SIGNATURE: &'static str = "AddressInsufficientBalance(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ErrorSelectorNotFound()` and selector `0xa7285689`.
+    ```solidity
+    error ErrorSelectorNotFound();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ErrorSelectorNotFound;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ErrorSelectorNotFound> for UnderlyingRustTuple<'_> {
+            fn from(value: ErrorSelectorNotFound) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ErrorSelectorNotFound {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ErrorSelectorNotFound {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [167u8, 40u8, 86u8, 137u8];
+            const SIGNATURE: &'static str = "ErrorSelectorNotFound()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `EthTransfer()` and selector `0x0540ddf6`.
+    ```solidity
+    error EthTransfer();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct EthTransfer;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<EthTransfer> for UnderlyingRustTuple<'_> {
+            fn from(value: EthTransfer) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for EthTransfer {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for EthTransfer {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 64u8, 221u8, 246u8];
+            const SIGNATURE: &'static str = "EthTransfer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`.
+    ```solidity
+    error FailedInnerCall();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct FailedInnerCall;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
+            fn from(value: FailedInnerCall) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for FailedInnerCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
+            const SIGNATURE: &'static str = "FailedInnerCall()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InputLengthMismatch()` and selector `0xaaad13f7`.
+    ```solidity
+    error InputLengthMismatch();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InputLengthMismatch;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InputLengthMismatch> for UnderlyingRustTuple<'_> {
+            fn from(value: InputLengthMismatch) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputLengthMismatch {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InputLengthMismatch {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 173u8, 19u8, 247u8];
+            const SIGNATURE: &'static str = "InputLengthMismatch()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InsufficientEth()` and selector `0xa01a9df6`.
+    ```solidity
+    error InsufficientEth();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InsufficientEth;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InsufficientEth> for UnderlyingRustTuple<'_> {
+            fn from(value: InsufficientEth) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientEth {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InsufficientEth {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [160u8, 26u8, 157u8, 246u8];
+            const SIGNATURE: &'static str = "InsufficientEth()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ReentrancyGuardReentrantCall()` and selector `0x3ee5aeb5`.
+    ```solidity
+    error ReentrancyGuardReentrantCall();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ReentrancyGuardReentrantCall;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReentrancyGuardReentrantCall> for UnderlyingRustTuple<'_> {
+            fn from(value: ReentrancyGuardReentrantCall) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReentrancyGuardReentrantCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
+            const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SafeCastOverflowedUintDowncast(uint8,uint256)` and selector `0x6dfcc650`.
+    ```solidity
+    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SafeCastOverflowedUintDowncast {
+        #[allow(missing_docs)]
+        pub bits: u8,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<8>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (u8, alloy_sol_types::private::primitives::aliases::U256);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SafeCastOverflowedUintDowncast> for UnderlyingRustTuple<'_> {
+            fn from(value: SafeCastOverflowedUintDowncast) -> Self {
+                (value.bits, value.value)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeCastOverflowedUintDowncast {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    bits: tuple.0,
+                    value: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SafeCastOverflowedUintDowncast {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [109u8, 252u8, 198u8, 80u8];
+            const SIGNATURE: &'static str = "SafeCastOverflowedUintDowncast(uint8,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.bits,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SafeERC20FailedOperation(address)` and selector `0x5274afe7`.
+    ```solidity
+    error SafeERC20FailedOperation(address token);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SafeERC20FailedOperation {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SafeERC20FailedOperation> for UnderlyingRustTuple<'_> {
+            fn from(value: SafeERC20FailedOperation) -> Self {
+                (value.token,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeERC20FailedOperation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { token: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SafeERC20FailedOperation {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [82u8, 116u8, 175u8, 231u8];
+            const SIGNATURE: &'static str = "SafeERC20FailedOperation(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SenderIsNotVault(address)` and selector `0x089676d5`.
+    ```solidity
+    error SenderIsNotVault(address sender);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SenderIsNotVault {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SenderIsNotVault> for UnderlyingRustTuple<'_> {
+            fn from(value: SenderIsNotVault) -> Self {
+                (value.sender,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SenderIsNotVault {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { sender: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SenderIsNotVault {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [8u8, 150u8, 118u8, 213u8];
+            const SIGNATURE: &'static str = "SenderIsNotVault(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SwapDeadline()` and selector `0xe08b8af0`.
+    ```solidity
+    error SwapDeadline();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SwapDeadline;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapDeadline> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapDeadline) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapDeadline {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SwapDeadline {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [224u8, 139u8, 138u8, 240u8];
+            const SIGNATURE: &'static str = "SwapDeadline()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `TransientIndexOutOfBounds()` and selector `0x0f4ae0e4`.
+    ```solidity
+    error TransientIndexOutOfBounds();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TransientIndexOutOfBounds;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TransientIndexOutOfBounds> for UnderlyingRustTuple<'_> {
+            fn from(value: TransientIndexOutOfBounds) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TransientIndexOutOfBounds {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for TransientIndexOutOfBounds {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [15u8, 74u8, 224u8, 228u8];
+            const SIGNATURE: &'static str = "TransientIndexOutOfBounds()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address weth, address permit2, string routerVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub weth: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub permit2: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub routerVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault, value.weth, value.permit2, value.routerVersion)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        vault: tuple.0,
+                        weth: tuple.1,
+                        permit2: tuple.2,
+                        routerVersion: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.weth,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.permit2,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.routerVersion,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSender()` and selector `0x5e01eb5a`.
+    ```solidity
+    function getSender() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSenderCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSender()`](getSenderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSenderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSenderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSenderCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSenderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSenderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSenderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSenderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSenderCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [94u8, 1u8, 235u8, 90u8];
+            const SIGNATURE: &'static str = "getSender()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSenderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSenderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `multicall(bytes[])` and selector `0xac9650d8`.
+    ```solidity
+    function multicall(bytes[] memory data) external payable returns (bytes[] memory results);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multicallCall {
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multicall(bytes[])`](multicallCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multicallReturn {
+        #[allow(missing_docs)]
+        pub results: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multicallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multicallCall) -> Self {
+                    (value.data,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multicallCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { data: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multicallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multicallReturn) -> Self {
+                    (value.results,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multicallReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { results: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multicallCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [172u8, 150u8, 80u8, 216u8];
+            const SIGNATURE: &'static str = "multicall(bytes[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bytes,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.data
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bytes,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multicallReturn = r.into();
+                        r.results
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multicallReturn = r.into();
+                    r.results
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `permitBatchAndCall((address,address,address,uint256,uint256,uint256)[],bytes[],((address,uint160,uint48,uint48)[],address,uint256),bytes,bytes[])` and selector `0x19c6989f`.
+    ```solidity
+    function permitBatchAndCall(IRouterCommon.PermitApproval[] memory permitBatch, bytes[] memory permitSignatures, IAllowanceTransfer.PermitBatch memory permit2Batch, bytes memory permit2Signature, bytes[] memory multicallData) external payable returns (bytes[] memory results);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitBatchAndCallCall {
+        #[allow(missing_docs)]
+        pub permitBatch: alloy_sol_types::private::Vec<
+            <IRouterCommon::PermitApproval as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub permitSignatures: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        #[allow(missing_docs)]
+        pub permit2Batch: <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub permit2Signature: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub multicallData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`permitBatchAndCall((address,address,address,uint256,uint256,
+    /// uint256)[],bytes[],((address,uint160,uint48,uint48)[],address,uint256),
+    /// bytes,bytes[])`](permitBatchAndCallCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitBatchAndCallReturn {
+        #[allow(missing_docs)]
+        pub results: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IRouterCommon::PermitApproval>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+                IAllowanceTransfer::PermitBatch,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IRouterCommon::PermitApproval as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+                <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitBatchAndCallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitBatchAndCallCall) -> Self {
+                    (
+                        value.permitBatch,
+                        value.permitSignatures,
+                        value.permit2Batch,
+                        value.permit2Signature,
+                        value.multicallData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitBatchAndCallCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        permitBatch: tuple.0,
+                        permitSignatures: tuple.1,
+                        permit2Batch: tuple.2,
+                        permit2Signature: tuple.3,
+                        multicallData: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitBatchAndCallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitBatchAndCallReturn) -> Self {
+                    (value.results,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitBatchAndCallReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { results: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitBatchAndCallCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IRouterCommon::PermitApproval>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+                IAllowanceTransfer::PermitBatch,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+            );
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [25u8, 198u8, 152u8, 159u8];
+            const SIGNATURE: &'static str = "permitBatchAndCall((address,address,address,uint256,\
+                                             uint256,uint256)[],bytes[],((address,uint160,uint48,\
+                                             uint48)[],address,uint256),bytes,bytes[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IRouterCommon::PermitApproval,
+                    > as alloy_sol_types::SolType>::tokenize(&self.permitBatch),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bytes,
+                    > as alloy_sol_types::SolType>::tokenize(&self.permitSignatures),
+                    <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::tokenize(
+                        &self.permit2Batch,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.permit2Signature,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bytes,
+                    > as alloy_sol_types::SolType>::tokenize(&self.multicallData),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bytes,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: permitBatchAndCallReturn = r.into();
+                        r.results
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: permitBatchAndCallReturn = r.into();
+                    r.results
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `querySwapExactIn((address,(address,address,bool)[],uint256,uint256)[],address,bytes)` and selector `0xe3b5dff4`.
+    ```solidity
+    function querySwapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactInCall {
+        #[allow(missing_docs)]
+        pub paths: alloy_sol_types::private::Vec<
+            <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`querySwapExactIn((address,(address,address,bool)[],uint256,uint256)[],
+    /// address,bytes)`](querySwapExactInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactInReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactInCall) -> Self {
+                    (value.paths, value.sender, value.userData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paths: tuple.0,
+                        sender: tuple.1,
+                        userData: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactInReturn) -> Self {
+                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsOut: tuple.0,
+                        tokensOut: tuple.1,
+                        amountsOut: tuple.2,
+                    }
+                }
+            }
+        }
+        impl querySwapExactInReturn {
+            fn _tokenize(
+                &self,
+            ) -> <querySwapExactInCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for querySwapExactInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = querySwapExactInReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [227u8, 181u8, 223u8, 244u8];
+            const SIGNATURE: &'static str = "querySwapExactIn((address,(address,address,bool)[],\
+                                             uint256,uint256)[],address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IBatchRouter::SwapPathExactAmountIn,
+                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                querySwapExactInReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `querySwapExactInHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x8a12a08c`.
+    ```solidity
+    function querySwapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactInHookCall {
+        #[allow(missing_docs)]
+        pub params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`querySwapExactInHook((address,(address,(address,address,bool)[],
+    /// uint256,uint256)[],uint256,bool,bytes))`](querySwapExactInHookCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactInHookReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactInHookParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactInHookCall> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactInHookCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInHookCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactInHookReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactInHookReturn) -> Self {
+                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInHookReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsOut: tuple.0,
+                        tokensOut: tuple.1,
+                        amountsOut: tuple.2,
+                    }
+                }
+            }
+        }
+        impl querySwapExactInHookReturn {
+            fn _tokenize(
+                &self,
+            ) -> <querySwapExactInHookCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for querySwapExactInHookCall {
+            type Parameters<'a> = (IBatchRouter::SwapExactInHookParams,);
+            type Return = querySwapExactInHookReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [138u8, 18u8, 160u8, 140u8];
+            const SIGNATURE: &'static str = "querySwapExactInHook((address,(address,(address,\
+                                             address,bool)[],uint256,uint256)[],uint256,bool,\
+                                             bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                querySwapExactInHookReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `querySwapExactOut((address,(address,address,bool)[],uint256,uint256)[],address,bytes)` and selector `0x2950286e`.
+    ```solidity
+    function querySwapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactOutCall {
+        #[allow(missing_docs)]
+        pub paths: alloy_sol_types::private::Vec<
+            <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`querySwapExactOut((address,(address,address,bool)[],uint256,
+    /// uint256)[],address,bytes)`](querySwapExactOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactOutReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactOutCall) -> Self {
+                    (value.paths, value.sender, value.userData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paths: tuple.0,
+                        sender: tuple.1,
+                        userData: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactOutReturn) -> Self {
+                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsIn: tuple.0,
+                        tokensIn: tuple.1,
+                        amountsIn: tuple.2,
+                    }
+                }
+            }
+        }
+        impl querySwapExactOutReturn {
+            fn _tokenize(
+                &self,
+            ) -> <querySwapExactOutCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for querySwapExactOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = querySwapExactOutReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [41u8, 80u8, 40u8, 110u8];
+            const SIGNATURE: &'static str = "querySwapExactOut((address,(address,address,bool)[],\
+                                             uint256,uint256)[],address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IBatchRouter::SwapPathExactAmountOut,
+                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                querySwapExactOutReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `querySwapExactOutHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x5a3c3987`.
+    ```solidity
+    function querySwapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactOutHookCall {
+        #[allow(missing_docs)]
+        pub params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`querySwapExactOutHook((address,(address,(address,address,bool)[],
+    /// uint256,uint256)[],uint256,bool,bytes))`](querySwapExactOutHookCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct querySwapExactOutHookReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactOutHookParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactOutHookCall> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactOutHookCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutHookCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<querySwapExactOutHookReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: querySwapExactOutHookReturn) -> Self {
+                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutHookReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsIn: tuple.0,
+                        tokensIn: tuple.1,
+                        amountsIn: tuple.2,
+                    }
+                }
+            }
+        }
+        impl querySwapExactOutHookReturn {
+            fn _tokenize(
+                &self,
+            ) -> <querySwapExactOutHookCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for querySwapExactOutHookCall {
+            type Parameters<'a> = (IBatchRouter::SwapExactOutHookParams,);
+            type Return = querySwapExactOutHookReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [90u8, 60u8, 57u8, 135u8];
+            const SIGNATURE: &'static str = "querySwapExactOutHook((address,(address,(address,\
+                                             address,bool)[],uint256,uint256)[],uint256,bool,\
+                                             bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                querySwapExactOutHookReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `swapExactIn((address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes)` and selector `0x286f580d`.
+    ```solidity
+    function swapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactInCall {
+        #[allow(missing_docs)]
+        pub paths: alloy_sol_types::private::Vec<
+            <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub wethIsEth: bool,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactIn((address,(address,address,bool)[],uint256,uint256)[],
+    /// uint256,bool,bytes)`](swapExactInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactInReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactInCall) -> Self {
+                    (value.paths, value.deadline, value.wethIsEth, value.userData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paths: tuple.0,
+                        deadline: tuple.1,
+                        wethIsEth: tuple.2,
+                        userData: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactInReturn) -> Self {
+                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsOut: tuple.0,
+                        tokensOut: tuple.1,
+                        amountsOut: tuple.2,
+                    }
+                }
+            }
+        }
+        impl swapExactInReturn {
+            fn _tokenize(&self) -> <swapExactInCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapExactInReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [40u8, 111u8, 88u8, 13u8];
+            const SIGNATURE: &'static str = "swapExactIn((address,(address,address,bool)[],\
+                                             uint256,uint256)[],uint256,bool,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IBatchRouter::SwapPathExactAmountIn,
+                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.wethIsEth,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactInReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `swapExactInHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x08a465f6`.
+    ```solidity
+    function swapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactInHookCall {
+        #[allow(missing_docs)]
+        pub params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactInHook((address,(address,(address,address,bool)[],uint256,
+    /// uint256)[],uint256,bool,bytes))`](swapExactInHookCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactInHookReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsOut:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactInHookParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactInHookCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactInHookCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInHookCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactInHookReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactInHookReturn) -> Self {
+                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInHookReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsOut: tuple.0,
+                        tokensOut: tuple.1,
+                        amountsOut: tuple.2,
+                    }
+                }
+            }
+        }
+        impl swapExactInHookReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactInHookCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactInHookCall {
+            type Parameters<'a> = (IBatchRouter::SwapExactInHookParams,);
+            type Return = swapExactInHookReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [8u8, 164u8, 101u8, 246u8];
+            const SIGNATURE: &'static str = "swapExactInHook((address,(address,(address,address,\
+                                             bool)[],uint256,uint256)[],uint256,bool,bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactInHookReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `swapExactOut((address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes)` and selector `0x8eb1b65e`.
+    ```solidity
+    function swapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactOutCall {
+        #[allow(missing_docs)]
+        pub paths: alloy_sol_types::private::Vec<
+            <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub wethIsEth: bool,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactOut((address,(address,address,bool)[],uint256,uint256)[],
+    /// uint256,bool,bytes)`](swapExactOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactOutReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactOutCall) -> Self {
+                    (value.paths, value.deadline, value.wethIsEth, value.userData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paths: tuple.0,
+                        deadline: tuple.1,
+                        wethIsEth: tuple.2,
+                        userData: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactOutReturn) -> Self {
+                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsIn: tuple.0,
+                        tokensIn: tuple.1,
+                        amountsIn: tuple.2,
+                    }
+                }
+            }
+        }
+        impl swapExactOutReturn {
+            fn _tokenize(&self) -> <swapExactOutCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapExactOutReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [142u8, 177u8, 182u8, 94u8];
+            const SIGNATURE: &'static str = "swapExactOut((address,(address,address,bool)[],\
+                                             uint256,uint256)[],uint256,bool,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IBatchRouter::SwapPathExactAmountOut,
+                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.wethIsEth,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactOutReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `swapExactOutHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x945ed33f`.
+    ```solidity
+    function swapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactOutHookCall {
+        #[allow(missing_docs)]
+        pub params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactOutHook((address,(address,(address,address,bool)[],uint256,
+    /// uint256)[],uint256,bool,bytes))`](swapExactOutHookCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactOutHookReturn {
+        #[allow(missing_docs)]
+        pub pathAmountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amountsIn:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactOutHookParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactOutHookCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactOutHookCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutHookCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactOutHookReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactOutHookReturn) -> Self {
+                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutHookReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pathAmountsIn: tuple.0,
+                        tokensIn: tuple.1,
+                        amountsIn: tuple.2,
+                    }
+                }
+            }
+        }
+        impl swapExactOutHookReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactOutHookCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactOutHookCall {
+            type Parameters<'a> = (IBatchRouter::SwapExactOutHookParams,);
+            type Return = swapExactOutHookReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [148u8, 94u8, 211u8, 63u8];
+            const SIGNATURE: &'static str = "swapExactOutHook((address,(address,(address,address,\
+                                             bool)[],uint256,uint256)[],uint256,bool,bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactOutHookReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV3BatchRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancerV3BatchRouterCalls {
+        #[allow(missing_docs)]
+        getSender(getSenderCall),
+        #[allow(missing_docs)]
+        multicall(multicallCall),
+        #[allow(missing_docs)]
+        permitBatchAndCall(permitBatchAndCallCall),
+        #[allow(missing_docs)]
+        querySwapExactIn(querySwapExactInCall),
+        #[allow(missing_docs)]
+        querySwapExactInHook(querySwapExactInHookCall),
+        #[allow(missing_docs)]
+        querySwapExactOut(querySwapExactOutCall),
+        #[allow(missing_docs)]
+        querySwapExactOutHook(querySwapExactOutHookCall),
+        #[allow(missing_docs)]
+        swapExactIn(swapExactInCall),
+        #[allow(missing_docs)]
+        swapExactInHook(swapExactInHookCall),
+        #[allow(missing_docs)]
+        swapExactOut(swapExactOutCall),
+        #[allow(missing_docs)]
+        swapExactOutHook(swapExactOutHookCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV3BatchRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [8u8, 164u8, 101u8, 246u8],
+            [25u8, 198u8, 152u8, 159u8],
+            [40u8, 111u8, 88u8, 13u8],
+            [41u8, 80u8, 40u8, 110u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [90u8, 60u8, 57u8, 135u8],
+            [94u8, 1u8, 235u8, 90u8],
+            [138u8, 18u8, 160u8, 140u8],
+            [142u8, 177u8, 182u8, 94u8],
+            [148u8, 94u8, 211u8, 63u8],
+            [172u8, 150u8, 80u8, 216u8],
+            [227u8, 181u8, 223u8, 244u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <swapExactInHookCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitBatchAndCallCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <querySwapExactOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <querySwapExactOutHookCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSenderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <querySwapExactInHookCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactOutHookCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multicallCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <querySwapExactInCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(swapExactInHook),
+            ::core::stringify!(permitBatchAndCall),
+            ::core::stringify!(swapExactIn),
+            ::core::stringify!(querySwapExactOut),
+            ::core::stringify!(version),
+            ::core::stringify!(querySwapExactOutHook),
+            ::core::stringify!(getSender),
+            ::core::stringify!(querySwapExactInHook),
+            ::core::stringify!(swapExactOut),
+            ::core::stringify!(swapExactOutHook),
+            ::core::stringify!(multicall),
+            ::core::stringify!(querySwapExactIn),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV3BatchRouterCalls {
+        const COUNT: usize = 12usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV3BatchRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::getSender(_) => <getSenderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::multicall(_) => <multicallCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permitBatchAndCall(_) => {
+                    <permitBatchAndCallCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::querySwapExactIn(_) => {
+                    <querySwapExactInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::querySwapExactInHook(_) => {
+                    <querySwapExactInHookCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::querySwapExactOut(_) => {
+                    <querySwapExactOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::querySwapExactOutHook(_) => {
+                    <querySwapExactOutHookCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactIn(_) => <swapExactInCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapExactInHook(_) => {
+                    <swapExactInHookCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactOut(_) => <swapExactOutCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapExactOutHook(_) => {
+                    <swapExactOutHookCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV3BatchRouterCalls>] = &[
+                {
+                    fn swapExactInHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::swapExactInHook)
+                    }
+                    swapExactInHook
+                },
+                {
+                    fn permitBatchAndCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::permitBatchAndCall)
+                    }
+                    permitBatchAndCall
+                },
+                {
+                    fn swapExactIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::swapExactIn)
+                    }
+                    swapExactIn
+                },
+                {
+                    fn querySwapExactOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::querySwapExactOut)
+                    }
+                    querySwapExactOut
+                },
+                {
+                    fn version(data: &[u8]) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::version)
+                    }
+                    version
+                },
+                {
+                    fn querySwapExactOutHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterCalls::querySwapExactOutHook)
+                    }
+                    querySwapExactOutHook
+                },
+                {
+                    fn getSender(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <getSenderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::getSender)
+                    }
+                    getSender
+                },
+                {
+                    fn querySwapExactInHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::querySwapExactInHook)
+                    }
+                    querySwapExactInHook
+                },
+                {
+                    fn swapExactOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::swapExactOut)
+                    }
+                    swapExactOut
+                },
+                {
+                    fn swapExactOutHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::swapExactOutHook)
+                    }
+                    swapExactOutHook
+                },
+                {
+                    fn multicall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <multicallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::multicall)
+                    }
+                    multicall
+                },
+                {
+                    fn querySwapExactIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterCalls::querySwapExactIn)
+                    }
+                    querySwapExactIn
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV3BatchRouterCalls,
+            >] = &[
+                {
+                    fn swapExactInHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterCalls::swapExactInHook)
+                    }
+                    swapExactInHook
+                },
+                {
+                    fn permitBatchAndCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterCalls::permitBatchAndCall)
+                    }
+                    permitBatchAndCall
+                },
+                {
+                    fn swapExactIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV3BatchRouterCalls::swapExactIn)
+                    }
+                    swapExactIn
+                },
+                {
+                    fn querySwapExactOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterCalls::querySwapExactOut)
+                    }
+                    querySwapExactOut
+                },
+                {
+                    fn version(data: &[u8]) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV3BatchRouterCalls::version)
+                    }
+                    version
+                },
+                {
+                    fn querySwapExactOutHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterCalls::querySwapExactOutHook)
+                    }
+                    querySwapExactOutHook
+                },
+                {
+                    fn getSender(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <getSenderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV3BatchRouterCalls::getSender)
+                    }
+                    getSender
+                },
+                {
+                    fn querySwapExactInHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterCalls::querySwapExactInHook)
+                    }
+                    querySwapExactInHook
+                },
+                {
+                    fn swapExactOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterCalls::swapExactOut)
+                    }
+                    swapExactOut
+                },
+                {
+                    fn swapExactOutHook(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterCalls::swapExactOutHook)
+                    }
+                    swapExactOutHook
+                },
+                {
+                    fn multicall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <multicallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV3BatchRouterCalls::multicall)
+                    }
+                    multicall
+                },
+                {
+                    fn querySwapExactIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                        <querySwapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterCalls::querySwapExactIn)
+                    }
+                    querySwapExactIn
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::getSender(inner) => {
+                    <getSenderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::multicall(inner) => {
+                    <multicallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permitBatchAndCall(inner) => {
+                    <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::querySwapExactIn(inner) => {
+                    <querySwapExactInCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::querySwapExactInHook(inner) => {
+                    <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::querySwapExactOut(inner) => {
+                    <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::querySwapExactOutHook(inner) => {
+                    <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swapExactIn(inner) => {
+                    <swapExactInCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swapExactInHook(inner) => {
+                    <swapExactInHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swapExactOut(inner) => {
+                    <swapExactOutCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swapExactOutHook(inner) => {
+                    <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::getSender(inner) => {
+                    <getSenderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::multicall(inner) => {
+                    <multicallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permitBatchAndCall(inner) => {
+                    <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::querySwapExactIn(inner) => {
+                    <querySwapExactInCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::querySwapExactInHook(inner) => {
+                    <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::querySwapExactOut(inner) => {
+                    <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::querySwapExactOutHook(inner) => {
+                    <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::swapExactIn(inner) => {
+                    <swapExactInCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swapExactInHook(inner) => {
+                    <swapExactInHookCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swapExactOut(inner) => {
+                    <swapExactOutCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swapExactOutHook(inner) => {
+                    <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`BalancerV3BatchRouter`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum BalancerV3BatchRouterErrors {
+        #[allow(missing_docs)]
+        AddressEmptyCode(AddressEmptyCode),
+        #[allow(missing_docs)]
+        AddressInsufficientBalance(AddressInsufficientBalance),
+        #[allow(missing_docs)]
+        ErrorSelectorNotFound(ErrorSelectorNotFound),
+        #[allow(missing_docs)]
+        EthTransfer(EthTransfer),
+        #[allow(missing_docs)]
+        FailedInnerCall(FailedInnerCall),
+        #[allow(missing_docs)]
+        InputLengthMismatch(InputLengthMismatch),
+        #[allow(missing_docs)]
+        InsufficientEth(InsufficientEth),
+        #[allow(missing_docs)]
+        ReentrancyGuardReentrantCall(ReentrancyGuardReentrantCall),
+        #[allow(missing_docs)]
+        SafeCastOverflowedUintDowncast(SafeCastOverflowedUintDowncast),
+        #[allow(missing_docs)]
+        SafeERC20FailedOperation(SafeERC20FailedOperation),
+        #[allow(missing_docs)]
+        SenderIsNotVault(SenderIsNotVault),
+        #[allow(missing_docs)]
+        SwapDeadline(SwapDeadline),
+        #[allow(missing_docs)]
+        TransientIndexOutOfBounds(TransientIndexOutOfBounds),
+    }
+    impl BalancerV3BatchRouterErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [5u8, 64u8, 221u8, 246u8],
+            [8u8, 150u8, 118u8, 213u8],
+            [15u8, 74u8, 224u8, 228u8],
+            [20u8, 37u8, 234u8, 66u8],
+            [62u8, 229u8, 174u8, 181u8],
+            [82u8, 116u8, 175u8, 231u8],
+            [109u8, 252u8, 198u8, 80u8],
+            [153u8, 150u8, 179u8, 21u8],
+            [160u8, 26u8, 157u8, 246u8],
+            [167u8, 40u8, 86u8, 137u8],
+            [170u8, 173u8, 19u8, 247u8],
+            [205u8, 120u8, 96u8, 89u8],
+            [224u8, 139u8, 138u8, 240u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <EthTransfer as alloy_sol_types::SolError>::SIGNATURE,
+            <SenderIsNotVault as alloy_sol_types::SolError>::SIGNATURE,
+            <TransientIndexOutOfBounds as alloy_sol_types::SolError>::SIGNATURE,
+            <FailedInnerCall as alloy_sol_types::SolError>::SIGNATURE,
+            <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::SIGNATURE,
+            <SafeERC20FailedOperation as alloy_sol_types::SolError>::SIGNATURE,
+            <SafeCastOverflowedUintDowncast as alloy_sol_types::SolError>::SIGNATURE,
+            <AddressEmptyCode as alloy_sol_types::SolError>::SIGNATURE,
+            <InsufficientEth as alloy_sol_types::SolError>::SIGNATURE,
+            <ErrorSelectorNotFound as alloy_sol_types::SolError>::SIGNATURE,
+            <InputLengthMismatch as alloy_sol_types::SolError>::SIGNATURE,
+            <AddressInsufficientBalance as alloy_sol_types::SolError>::SIGNATURE,
+            <SwapDeadline as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(EthTransfer),
+            ::core::stringify!(SenderIsNotVault),
+            ::core::stringify!(TransientIndexOutOfBounds),
+            ::core::stringify!(FailedInnerCall),
+            ::core::stringify!(ReentrancyGuardReentrantCall),
+            ::core::stringify!(SafeERC20FailedOperation),
+            ::core::stringify!(SafeCastOverflowedUintDowncast),
+            ::core::stringify!(AddressEmptyCode),
+            ::core::stringify!(InsufficientEth),
+            ::core::stringify!(ErrorSelectorNotFound),
+            ::core::stringify!(InputLengthMismatch),
+            ::core::stringify!(AddressInsufficientBalance),
+            ::core::stringify!(SwapDeadline),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV3BatchRouterErrors {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV3BatchRouterErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::AddressEmptyCode(_) => {
+                    <AddressEmptyCode as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::AddressInsufficientBalance(_) => {
+                    <AddressInsufficientBalance as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ErrorSelectorNotFound(_) => {
+                    <ErrorSelectorNotFound as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::EthTransfer(_) => <EthTransfer as alloy_sol_types::SolError>::SELECTOR,
+                Self::FailedInnerCall(_) => {
+                    <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InputLengthMismatch(_) => {
+                    <InputLengthMismatch as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InsufficientEth(_) => {
+                    <InsufficientEth as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ReentrancyGuardReentrantCall(_) => {
+                    <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SafeCastOverflowedUintDowncast(_) => {
+                    <SafeCastOverflowedUintDowncast as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SafeERC20FailedOperation(_) => {
+                    <SafeERC20FailedOperation as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SenderIsNotVault(_) => {
+                    <SenderIsNotVault as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SwapDeadline(_) => <SwapDeadline as alloy_sol_types::SolError>::SELECTOR,
+                Self::TransientIndexOutOfBounds(_) => {
+                    <TransientIndexOutOfBounds as alloy_sol_types::SolError>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BalancerV3BatchRouterErrors>] = &[
+                {
+                    fn EthTransfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <EthTransfer as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::EthTransfer)
+                    }
+                    EthTransfer
+                },
+                {
+                    fn SenderIsNotVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SenderIsNotVault as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::SenderIsNotVault)
+                    }
+                    SenderIsNotVault
+                },
+                {
+                    fn TransientIndexOutOfBounds(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <TransientIndexOutOfBounds as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::TransientIndexOutOfBounds)
+                    }
+                    TransientIndexOutOfBounds
+                },
+                {
+                    fn FailedInnerCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::FailedInnerCall)
+                    }
+                    FailedInnerCall
+                },
+                {
+                    fn ReentrancyGuardReentrantCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::ReentrancyGuardReentrantCall)
+                    }
+                    ReentrancyGuardReentrantCall
+                },
+                {
+                    fn SafeERC20FailedOperation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::SafeERC20FailedOperation)
+                    }
+                    SafeERC20FailedOperation
+                },
+                {
+                    fn SafeCastOverflowedUintDowncast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SafeCastOverflowedUintDowncast as alloy_sol_types::SolError>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BalancerV3BatchRouterErrors::SafeCastOverflowedUintDowncast,
+                            )
+                    }
+                    SafeCastOverflowedUintDowncast
+                },
+                {
+                    fn AddressEmptyCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::AddressEmptyCode)
+                    }
+                    AddressEmptyCode
+                },
+                {
+                    fn InsufficientEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <InsufficientEth as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::InsufficientEth)
+                    }
+                    InsufficientEth
+                },
+                {
+                    fn ErrorSelectorNotFound(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <ErrorSelectorNotFound as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::ErrorSelectorNotFound)
+                    }
+                    ErrorSelectorNotFound
+                },
+                {
+                    fn InputLengthMismatch(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <InputLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::InputLengthMismatch)
+                    }
+                    InputLengthMismatch
+                },
+                {
+                    fn AddressInsufficientBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <AddressInsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::AddressInsufficientBalance)
+                    }
+                    AddressInsufficientBalance
+                },
+                {
+                    fn SwapDeadline(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SwapDeadline as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(BalancerV3BatchRouterErrors::SwapDeadline)
+                    }
+                    SwapDeadline
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV3BatchRouterErrors,
+            >] = &[
+                {
+                    fn EthTransfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <EthTransfer as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(BalancerV3BatchRouterErrors::EthTransfer)
+                    }
+                    EthTransfer
+                },
+                {
+                    fn SenderIsNotVault(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SenderIsNotVault as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::SenderIsNotVault)
+                    }
+                    SenderIsNotVault
+                },
+                {
+                    fn TransientIndexOutOfBounds(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <TransientIndexOutOfBounds as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterErrors::TransientIndexOutOfBounds)
+                    }
+                    TransientIndexOutOfBounds
+                },
+                {
+                    fn FailedInnerCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::FailedInnerCall)
+                    }
+                    FailedInnerCall
+                },
+                {
+                    fn ReentrancyGuardReentrantCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV3BatchRouterErrors::ReentrancyGuardReentrantCall,
+                            )
+                    }
+                    ReentrancyGuardReentrantCall
+                },
+                {
+                    fn SafeERC20FailedOperation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterErrors::SafeERC20FailedOperation)
+                    }
+                    SafeERC20FailedOperation
+                },
+                {
+                    fn SafeCastOverflowedUintDowncast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SafeCastOverflowedUintDowncast as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV3BatchRouterErrors::SafeCastOverflowedUintDowncast,
+                            )
+                    }
+                    SafeCastOverflowedUintDowncast
+                },
+                {
+                    fn AddressEmptyCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <AddressEmptyCode as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::AddressEmptyCode)
+                    }
+                    AddressEmptyCode
+                },
+                {
+                    fn InsufficientEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <InsufficientEth as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::InsufficientEth)
+                    }
+                    InsufficientEth
+                },
+                {
+                    fn ErrorSelectorNotFound(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <ErrorSelectorNotFound as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterErrors::ErrorSelectorNotFound)
+                    }
+                    ErrorSelectorNotFound
+                },
+                {
+                    fn InputLengthMismatch(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <InputLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV3BatchRouterErrors::InputLengthMismatch)
+                    }
+                    InputLengthMismatch
+                },
+                {
+                    fn AddressInsufficientBalance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <AddressInsufficientBalance as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV3BatchRouterErrors::AddressInsufficientBalance)
+                    }
+                    AddressInsufficientBalance
+                },
+                {
+                    fn SwapDeadline(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterErrors> {
+                        <SwapDeadline as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(BalancerV3BatchRouterErrors::SwapDeadline)
+                    }
+                    SwapDeadline
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::AddressEmptyCode(inner) => {
+                    <AddressEmptyCode as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::AddressInsufficientBalance(inner) => {
+                    <AddressInsufficientBalance as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ErrorSelectorNotFound(inner) => {
+                    <ErrorSelectorNotFound as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::EthTransfer(inner) => {
+                    <EthTransfer as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::FailedInnerCall(inner) => {
+                    <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InputLengthMismatch(inner) => {
+                    <InputLengthMismatch as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InsufficientEth(inner) => {
+                    <InsufficientEth as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::ReentrancyGuardReentrantCall(inner) => {
+                    <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::SafeCastOverflowedUintDowncast(inner) => {
+                    <SafeCastOverflowedUintDowncast as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::SafeERC20FailedOperation(inner) => {
+                    <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::SenderIsNotVault(inner) => {
+                    <SenderIsNotVault as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::SwapDeadline(inner) => {
+                    <SwapDeadline as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::TransientIndexOutOfBounds(inner) => {
+                    <TransientIndexOutOfBounds as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::AddressEmptyCode(inner) => {
+                    <AddressEmptyCode as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::AddressInsufficientBalance(inner) => {
+                    <AddressInsufficientBalance as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::ErrorSelectorNotFound(inner) => {
+                    <ErrorSelectorNotFound as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::EthTransfer(inner) => {
+                    <EthTransfer as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::FailedInnerCall(inner) => {
+                    <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InputLengthMismatch(inner) => {
+                    <InputLengthMismatch as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InsufficientEth(inner) => {
+                    <InsufficientEth as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::ReentrancyGuardReentrantCall(inner) => {
+                    <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::SafeCastOverflowedUintDowncast(inner) => {
+                    <SafeCastOverflowedUintDowncast as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::SafeERC20FailedOperation(inner) => {
+                    <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::SenderIsNotVault(inner) => {
+                    <SenderIsNotVault as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::SwapDeadline(inner) => {
+                    <SwapDeadline as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::TransientIndexOutOfBounds(inner) => {
+                    <TransientIndexOutOfBounds as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BalancerV3BatchRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancerV3BatchRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancerV3BatchRouterInstance<P, N> {
+        BalancerV3BatchRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        vault: alloy_sol_types::private::Address,
+        weth: alloy_sol_types::private::Address,
+        permit2: alloy_sol_types::private::Address,
+        routerVersion: alloy_sol_types::private::String,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<BalancerV3BatchRouterInstance<P, N>>>
+    {
+        BalancerV3BatchRouterInstance::<P, N>::deploy(
+            __provider,
+            vault,
+            weth,
+            permit2,
+            routerVersion,
+        )
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        vault: alloy_sol_types::private::Address,
+        weth: alloy_sol_types::private::Address,
+        permit2: alloy_sol_types::private::Address,
+        routerVersion: alloy_sol_types::private::String,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        BalancerV3BatchRouterInstance::<P, N>::deploy_builder(
+            __provider,
+            vault,
+            weth,
+            permit2,
+            routerVersion,
+        )
+    }
+    /**A [`BalancerV3BatchRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BalancerV3BatchRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancerV3BatchRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancerV3BatchRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancerV3BatchRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV3BatchRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BalancerV3BatchRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancerV3BatchRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            vault: alloy_sol_types::private::Address,
+            weth: alloy_sol_types::private::Address,
+            permit2: alloy_sol_types::private::Address,
+            routerVersion: alloy_sol_types::private::String,
+        ) -> alloy_contract::Result<BalancerV3BatchRouterInstance<P, N>> {
+            let call_builder =
+                Self::deploy_builder(__provider, vault, weth, permit2, routerVersion);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            vault: alloy_sol_types::private::Address,
+            weth: alloy_sol_types::private::Address,
+            permit2: alloy_sol_types::private::Address,
+            routerVersion: alloy_sol_types::private::String,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        vault,
+                        weth,
+                        permit2,
+                        routerVersion,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancerV3BatchRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancerV3BatchRouterInstance<P, N> {
+            BalancerV3BatchRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV3BatchRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`getSender`] function.
+        pub fn getSender(&self) -> alloy_contract::SolCallBuilder<&P, getSenderCall, N> {
+            self.call_builder(&getSenderCall)
+        }
+
+        ///Creates a new call builder for the [`multicall`] function.
+        pub fn multicall(
+            &self,
+            data: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        ) -> alloy_contract::SolCallBuilder<&P, multicallCall, N> {
+            self.call_builder(&multicallCall { data })
+        }
+
+        ///Creates a new call builder for the [`permitBatchAndCall`] function.
+        pub fn permitBatchAndCall(
+            &self,
+            permitBatch: alloy_sol_types::private::Vec<
+                <IRouterCommon::PermitApproval as alloy_sol_types::SolType>::RustType,
+            >,
+            permitSignatures: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+            permit2Batch: <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::RustType,
+            permit2Signature: alloy_sol_types::private::Bytes,
+            multicallData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitBatchAndCallCall, N> {
+            self.call_builder(&permitBatchAndCallCall {
+                permitBatch,
+                permitSignatures,
+                permit2Batch,
+                permit2Signature,
+                multicallData,
+            })
+        }
+
+        ///Creates a new call builder for the [`querySwapExactIn`] function.
+        pub fn querySwapExactIn(
+            &self,
+            paths: alloy_sol_types::private::Vec<
+                <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+            >,
+            sender: alloy_sol_types::private::Address,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactInCall, N> {
+            self.call_builder(&querySwapExactInCall {
+                paths,
+                sender,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`querySwapExactInHook`]
+        /// function.
+        pub fn querySwapExactInHook(
+            &self,
+            params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactInHookCall, N> {
+            self.call_builder(&querySwapExactInHookCall { params })
+        }
+
+        ///Creates a new call builder for the [`querySwapExactOut`] function.
+        pub fn querySwapExactOut(
+            &self,
+            paths: alloy_sol_types::private::Vec<
+                <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+            >,
+            sender: alloy_sol_types::private::Address,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactOutCall, N> {
+            self.call_builder(&querySwapExactOutCall {
+                paths,
+                sender,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`querySwapExactOutHook`]
+        /// function.
+        pub fn querySwapExactOutHook(
+            &self,
+            params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactOutHookCall, N> {
+            self.call_builder(&querySwapExactOutHookCall { params })
+        }
+
+        ///Creates a new call builder for the [`swapExactIn`] function.
+        pub fn swapExactIn(
+            &self,
+            paths: alloy_sol_types::private::Vec<
+                <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
+            >,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            wethIsEth: bool,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactInCall, N> {
+            self.call_builder(&swapExactInCall {
+                paths,
+                deadline,
+                wethIsEth,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactInHook`] function.
+        pub fn swapExactInHook(
+            &self,
+            params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactInHookCall, N> {
+            self.call_builder(&swapExactInHookCall { params })
+        }
+
+        ///Creates a new call builder for the [`swapExactOut`] function.
+        pub fn swapExactOut(
+            &self,
+            paths: alloy_sol_types::private::Vec<
+                <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
+            >,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            wethIsEth: bool,
+            userData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactOutCall, N> {
+            self.call_builder(&swapExactOutCall {
+                paths,
+                deadline,
+                wethIsEth,
+                userData,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactOutHook`] function.
+        pub fn swapExactOutHook(
+            &self,
+            params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactOutHookCall, N> {
+            self.call_builder(&swapExactOutHookCall { params })
+        }
+
+        ///Creates a new call builder for the [`version`] function.
+        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
+            self.call_builder(&versionCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancerV3BatchRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    BalancerV3BatchRouter::BalancerV3BatchRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x136f1EFcC3f8f88516B9E94110D56FDBfB1778d1"),
+            Some(21339510u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E"),
+            Some(133969588u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b"),
+            Some(37377506u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x85a80afee867aDf27B50BdB7b76DA70f1E853062"),
+            Some(25347205u64),
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x85a80afee867aDf27B50BdB7b76DA70f1E853062"),
+            Some(782312u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E"),
+            Some(297828544u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xc9b36096f5201ea332Db35d6D195774ea0D5988f"),
+            Some(59965747u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xC85b652685567C1B074e8c0D4389f83a2E458b1C"),
+            Some(7219301u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/balances/Cargo.toml b/contracts/generated/contracts-generated/balances/Cargo.toml
new file mode 100644
index 0000000000..11c7a8266d
--- /dev/null
+++ b/contracts/generated/contracts-generated/balances/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-balances"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/balances/src/lib.rs b/contracts/generated/contracts-generated/balances/src/lib.rs
new file mode 100644
index 0000000000..56507b2c6b
--- /dev/null
+++ b/contracts/generated/contracts-generated/balances/src/lib.rs
@@ -0,0 +1,1267 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Balances {
+    struct Contracts {
+        address settlement;
+        address vaultRelayer;
+        address vault;
+    }
+    struct Interaction {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    function balance(Contracts memory contracts, address trader, address token, uint256 amount, bytes32 source, Interaction[] memory interactions) external returns (uint256 tokenBalance, uint256 allowance, uint256 effectiveBalance, bool canTransfer);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "balance",
+    "inputs": [
+      {
+        "name": "contracts",
+        "type": "tuple",
+        "internalType": "struct Balances.Contracts",
+        "components": [
+          {
+            "name": "settlement",
+            "type": "address",
+            "internalType": "contract ISettlement"
+          },
+          {
+            "name": "vaultRelayer",
+            "type": "address",
+            "internalType": "contract IVaultRelayer"
+          },
+          {
+            "name": "vault",
+            "type": "address",
+            "internalType": "contract IVault"
+          }
+        ]
+      },
+      {
+        "name": "trader",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "source",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "interactions",
+        "type": "tuple[]",
+        "internalType": "struct Interaction[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "tokenBalance",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "allowance",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "effectiveBalance",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "canTransfer",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Balances {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x0EC\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xF8\x8C\xF6\xDB\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\n\x96V[a\0fV[`@\x80Q\x94\x85R` \x85\x01\x93\x90\x93R\x91\x83\x01R\x15\x15``\x82\x01R`\x80\x01`@Q\x80\x91\x03\x90\xF3[____a\0u\x8B\x87\x87a\x07\x88V[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x87\x03a\x01\xD0W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x06W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01*\x91\x90a\x0B[V[` \x8C\x01Q`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x91\x95P\x8A\x16\x90c\xDDb\xED>\x90`D\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xA5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xC9\x91\x90a\x0B[V[\x92Pa\x06\x0EV[\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x87\x03a\x03\x93W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02aW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\x85\x91\x90a\x0B[V[`@\x80\x8D\x01Q` \x8E\x01Q\x91Q\x7F\xFE\xC9\rr\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16`\x04\x83\x01R\x92\x83\x16`$\x82\x01R\x92\x96P\x16\x90c\xFE\xC9\rr\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03'\x91\x90a\x0BrV[a\x031W_a\x01\xC9V[`@\x8B\x81\x01Q\x90Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x90\x8A\x16\x90c\xDDb\xED>\x90`D\x01a\x01\x8AV[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x87\x03a\x05\xA7W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x89\x81_\x81Q\x81\x10a\x03\xEEWa\x03\xEEa\x0B\x98V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@\x80\x8E\x01Q\x90Q\x7F\x0FZn\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16\x90c\x0FZn\xFA\x90a\x04U\x90\x8E\x90\x85\x90`\x04\x01a\x0B\xC5V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04oW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x04\xB4\x91\x90\x81\x01\x90a\x0C>V[_\x81Q\x81\x10a\x04\xC5Wa\x04\xC5a\x0B\x98V[` \x02` \x01\x01Q\x94P\x8B`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFE\xC9\rr\x8C\x8E` \x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x054\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05OW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05s\x91\x90a\x0BrV[a\x05}W_a\x05\x9FV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[\x93PPa\x06\x0EV[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Finvalid token source\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x82\x84\x11\x15a\x06\x1CW\x82a\x06\x1EV[\x83[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x93P_\x91\x90\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x01\x91\x01\x81a\x068W\x90PP\x90P`@Q\x80`\x80\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A_\x03a\x06\xDBW\x84a\x06\xDDV[\x8A[\x81R` \x01\x89\x81RP\x81_\x81Q\x81\x10a\x06\xF8Wa\x06\xF8a\x0B\x98V[` \x02` \x01\x01\x81\x90RP\x8B` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c}\x10\xD1\x1F\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07@\x91\x90a\x0C\xEAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07WW__\xFD[PZ\xF1\x92PPP\x80\x15a\x07hWP`\x01[a\x07tW_\x91Pa\x07yV[`\x01\x91P[P\x97P\x97P\x97P\x97\x93PPPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x08\x08W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[_[\x81\x81\x10\x15a\toW_\x83\x83\x83\x81\x81\x10a\x08%Wa\x08%a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x087\x91\x90a\r~V[a\x08E\x90` \x81\x01\x90a\r\xBAV[\x90P_\x84\x84\x84\x81\x81\x10a\x08ZWa\x08Za\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08l\x91\x90a\r~V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x08\x86Wa\x08\x86a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08\x98\x91\x90a\r~V[a\x08\xA6\x90`@\x81\x01\x90a\r\xD5V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\tCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\t^W=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x08\n\x91PPV[PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC5Wa\t\xC5a\tuV[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\x12Wa\n\x12a\tuV[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\n;W__\xFD[PV[\x805a\nI\x81a\n\x1AV[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\n^W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nuW__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\n\x8FW__\xFD[\x92P\x92\x90PV[_______\x87\x89\x03a\x01\0\x81\x12\x15a\n\xAEW__\xFD[``\x81\x12\x15a\n\xBBW__\xFD[Pa\n\xC4a\t\xA2V[\x885a\n\xCF\x81a\n\x1AV[\x81R` \x89\x015a\n\xDF\x81a\n\x1AV[` \x82\x01R`@\x89\x015a\n\xF2\x81a\n\x1AV[`@\x82\x01R\x96Pa\x0B\x05``\x89\x01a\n>V[\x95Pa\x0B\x13`\x80\x89\x01a\n>V[\x94P`\xA0\x88\x015\x93P`\xC0\x88\x015\x92P`\xE0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B<W__\xFD[a\x0BH\x8A\x82\x8B\x01a\nNV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[_` \x82\x84\x03\x12\x15a\x0BkW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x82W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0B\x91W__\xFD[\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_`@\x82\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0C2W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0B\xFEV[P\x90\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0CNW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CdW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0CtW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\x8EWa\x0C\x8Ea\tuV[\x80`\x05\x1Ba\x0C\x9E` \x82\x01a\t\xCBV[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0C\xB9W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0C\xDFW\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0C\xC0V[\x97\x96PPPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\rsW\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R``\x81\x01Q``\x85\x01RP`\x80\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\x03V[P\x90\x95\x94PPPPPV[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\r\xB0W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\r\xCAW__\xFD[\x815a\x0B\x91\x81a\n\x1AV[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x0E\x08W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\"W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\n\x8FW__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xF8\x8C\xF6\xDB\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\n\x96V[a\0fV[`@\x80Q\x94\x85R` \x85\x01\x93\x90\x93R\x91\x83\x01R\x15\x15``\x82\x01R`\x80\x01`@Q\x80\x91\x03\x90\xF3[____a\0u\x8B\x87\x87a\x07\x88V[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x87\x03a\x01\xD0W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x06W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01*\x91\x90a\x0B[V[` \x8C\x01Q`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x91\x95P\x8A\x16\x90c\xDDb\xED>\x90`D\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xA5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xC9\x91\x90a\x0B[V[\x92Pa\x06\x0EV[\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x87\x03a\x03\x93W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02aW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\x85\x91\x90a\x0B[V[`@\x80\x8D\x01Q` \x8E\x01Q\x91Q\x7F\xFE\xC9\rr\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16`\x04\x83\x01R\x92\x83\x16`$\x82\x01R\x92\x96P\x16\x90c\xFE\xC9\rr\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03'\x91\x90a\x0BrV[a\x031W_a\x01\xC9V[`@\x8B\x81\x01Q\x90Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x90\x8A\x16\x90c\xDDb\xED>\x90`D\x01a\x01\x8AV[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x87\x03a\x05\xA7W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x89\x81_\x81Q\x81\x10a\x03\xEEWa\x03\xEEa\x0B\x98V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@\x80\x8E\x01Q\x90Q\x7F\x0FZn\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16\x90c\x0FZn\xFA\x90a\x04U\x90\x8E\x90\x85\x90`\x04\x01a\x0B\xC5V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04oW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x04\xB4\x91\x90\x81\x01\x90a\x0C>V[_\x81Q\x81\x10a\x04\xC5Wa\x04\xC5a\x0B\x98V[` \x02` \x01\x01Q\x94P\x8B`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFE\xC9\rr\x8C\x8E` \x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x054\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05OW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05s\x91\x90a\x0BrV[a\x05}W_a\x05\x9FV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[\x93PPa\x06\x0EV[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Finvalid token source\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x82\x84\x11\x15a\x06\x1CW\x82a\x06\x1EV[\x83[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x93P_\x91\x90\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x01\x91\x01\x81a\x068W\x90PP\x90P`@Q\x80`\x80\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A_\x03a\x06\xDBW\x84a\x06\xDDV[\x8A[\x81R` \x01\x89\x81RP\x81_\x81Q\x81\x10a\x06\xF8Wa\x06\xF8a\x0B\x98V[` \x02` \x01\x01\x81\x90RP\x8B` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c}\x10\xD1\x1F\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07@\x91\x90a\x0C\xEAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07WW__\xFD[PZ\xF1\x92PPP\x80\x15a\x07hWP`\x01[a\x07tW_\x91Pa\x07yV[`\x01\x91P[P\x97P\x97P\x97P\x97\x93PPPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x08\x08W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[_[\x81\x81\x10\x15a\toW_\x83\x83\x83\x81\x81\x10a\x08%Wa\x08%a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x087\x91\x90a\r~V[a\x08E\x90` \x81\x01\x90a\r\xBAV[\x90P_\x84\x84\x84\x81\x81\x10a\x08ZWa\x08Za\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08l\x91\x90a\r~V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x08\x86Wa\x08\x86a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08\x98\x91\x90a\r~V[a\x08\xA6\x90`@\x81\x01\x90a\r\xD5V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\tCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\t^W=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x08\n\x91PPV[PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC5Wa\t\xC5a\tuV[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\x12Wa\n\x12a\tuV[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\n;W__\xFD[PV[\x805a\nI\x81a\n\x1AV[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\n^W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nuW__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\n\x8FW__\xFD[\x92P\x92\x90PV[_______\x87\x89\x03a\x01\0\x81\x12\x15a\n\xAEW__\xFD[``\x81\x12\x15a\n\xBBW__\xFD[Pa\n\xC4a\t\xA2V[\x885a\n\xCF\x81a\n\x1AV[\x81R` \x89\x015a\n\xDF\x81a\n\x1AV[` \x82\x01R`@\x89\x015a\n\xF2\x81a\n\x1AV[`@\x82\x01R\x96Pa\x0B\x05``\x89\x01a\n>V[\x95Pa\x0B\x13`\x80\x89\x01a\n>V[\x94P`\xA0\x88\x015\x93P`\xC0\x88\x015\x92P`\xE0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B<W__\xFD[a\x0BH\x8A\x82\x8B\x01a\nNV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[_` \x82\x84\x03\x12\x15a\x0BkW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x82W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0B\x91W__\xFD[\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_`@\x82\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0C2W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0B\xFEV[P\x90\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0CNW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CdW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0CtW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\x8EWa\x0C\x8Ea\tuV[\x80`\x05\x1Ba\x0C\x9E` \x82\x01a\t\xCBV[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0C\xB9W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0C\xDFW\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0C\xC0V[\x97\x96PPPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\rsW\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R``\x81\x01Q``\x85\x01RP`\x80\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\x03V[P\x90\x95\x94PPPPPV[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\r\xB0W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\r\xCAW__\xFD[\x815a\x0B\x91\x81a\n\x1AV[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x0E\x08W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\"W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\n\x8FW__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Contracts { address settlement; address vaultRelayer; address vault; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Contracts {
+        #[allow(missing_docs)]
+        pub settlement: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub vaultRelayer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Contracts> for UnderlyingRustTuple<'_> {
+            fn from(value: Contracts) -> Self {
+                (value.settlement, value.vaultRelayer, value.vault)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Contracts {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    settlement: tuple.0,
+                    vaultRelayer: tuple.1,
+                    vault: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Contracts {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Contracts {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlement,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vaultRelayer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Contracts {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Contracts {
+            const NAME: &'static str = "Contracts";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Contracts(address settlement,address vaultRelayer,address vault)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.settlement,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.vaultRelayer,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.vault,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Contracts {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.settlement,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.vaultRelayer,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.vault,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.settlement,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.vaultRelayer,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.vault,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Interaction { address target; uint256 value; bytes callData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Interaction {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Interaction> for UnderlyingRustTuple<'_> {
+            fn from(value: Interaction) -> Self {
+                (value.target, value.value, value.callData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Interaction {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    value: tuple.1,
+                    callData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Interaction {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Interaction {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Interaction {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Interaction {
+            const NAME: &'static str = "Interaction";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Interaction(address target,uint256 value,bytes callData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Interaction {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balance((address,address,address),address,address,uint256,bytes32,(address,uint256,bytes)[])` and selector `0xf88cf6db`.
+    ```solidity
+    function balance(Contracts memory contracts, address trader, address token, uint256 amount, bytes32 source, Interaction[] memory interactions) external returns (uint256 tokenBalance, uint256 allowance, uint256 effectiveBalance, bool canTransfer);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceCall {
+        #[allow(missing_docs)]
+        pub contracts: <Contracts as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub trader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub source: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub interactions:
+            alloy_sol_types::private::Vec<<Interaction as alloy_sol_types::SolType>::RustType>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balance((address,address,address),address,address,uint256,bytes32,
+    /// (address,uint256,bytes)[])`](balanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceReturn {
+        #[allow(missing_docs)]
+        pub tokenBalance: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub allowance: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub effectiveBalance: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub canTransfer: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                Contracts,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Array<Interaction>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <Contracts as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Vec<<Interaction as alloy_sol_types::SolType>::RustType>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceCall) -> Self {
+                    (
+                        value.contracts,
+                        value.trader,
+                        value.token,
+                        value.amount,
+                        value.source,
+                        value.interactions,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contracts: tuple.0,
+                        trader: tuple.1,
+                        token: tuple.2,
+                        amount: tuple.3,
+                        source: tuple.4,
+                        interactions: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceReturn) -> Self {
+                    (
+                        value.tokenBalance,
+                        value.allowance,
+                        value.effectiveBalance,
+                        value.canTransfer,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenBalance: tuple.0,
+                        allowance: tuple.1,
+                        effectiveBalance: tuple.2,
+                        canTransfer: tuple.3,
+                    }
+                }
+            }
+        }
+        impl balanceReturn {
+            fn _tokenize(&self) -> <balanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.allowance,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.effectiveBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.canTransfer,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceCall {
+            type Parameters<'a> = (
+                Contracts,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Array<Interaction>,
+            );
+            type Return = balanceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 140u8, 246u8, 219u8];
+            const SIGNATURE: &'static str = "balance((address,address,address),address,address,\
+                                             uint256,bytes32,(address,uint256,bytes)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <Contracts as alloy_sol_types::SolType>::tokenize(&self.contracts),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.trader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.source),
+                    <alloy_sol_types::sol_data::Array<
+                        Interaction,
+                    > as alloy_sol_types::SolType>::tokenize(&self.interactions),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                balanceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`Balances`](self) function calls.
+    #[derive(Clone)]
+    pub enum BalancesCalls {
+        #[allow(missing_docs)]
+        balance(balanceCall),
+    }
+    impl BalancesCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[248u8, 140u8, 246u8, 219u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<balanceCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(balance)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancesCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 288usize;
+        const NAME: &'static str = "BalancesCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::balance(_) => <balanceCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancesCalls>] = &[{
+                fn balance(data: &[u8]) -> alloy_sol_types::Result<BalancesCalls> {
+                    <balanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(BalancesCalls::balance)
+                }
+                balance
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancesCalls>] =
+                &[{
+                    fn balance(data: &[u8]) -> alloy_sol_types::Result<BalancesCalls> {
+                        <balanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancesCalls::balance)
+                    }
+                    balance
+                }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::balance(inner) => {
+                    <balanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::balance(inner) => {
+                    <balanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Balances`](self) contract instance.
+
+    See the [wrapper's documentation](`BalancesInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BalancesInstance<P, N> {
+        BalancesInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<BalancesInstance<P, N>>> {
+        BalancesInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        BalancesInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Balances`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Balances`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BalancesInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BalancesInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BalancesInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancesInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Balances`](self) contract instance.
+
+        See the [wrapper's documentation](`BalancesInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<BalancesInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BalancesInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BalancesInstance<P, N> {
+            BalancesInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancesInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`balance`] function.
+        pub fn balance(
+            &self,
+            contracts: <Contracts as alloy_sol_types::SolType>::RustType,
+            trader: alloy_sol_types::private::Address,
+            token: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+            source: alloy_sol_types::private::FixedBytes<32>,
+            interactions: alloy_sol_types::private::Vec<
+                <Interaction as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceCall, N> {
+            self.call_builder(&balanceCall {
+                contracts,
+                trader,
+                token,
+                amount,
+                source,
+                interactions,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BalancesInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Balances::BalancesInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x361350f708f7c0c63c8a505226592c3e5d1faa29"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/baoswaprouter/Cargo.toml b/contracts/generated/contracts-generated/baoswaprouter/Cargo.toml
new file mode 100644
index 0000000000..cbff1c8f69
--- /dev/null
+++ b/contracts/generated/contracts-generated/baoswaprouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-baoswaprouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs b/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs
new file mode 100644
index 0000000000..31d4431ca1
--- /dev/null
+++ b/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs
@@ -0,0 +1,7537 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface BaoswapRouter {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BaoswapRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`BaoswapRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum BaoswapRouterCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl BaoswapRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BaoswapRouterCalls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BaoswapRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BaoswapRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<BaoswapRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BaoswapRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BaoswapRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BaoswapRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BaoswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BaoswapRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BaoswapRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BaoswapRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`BaoswapRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`BaoswapRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> BaoswapRouterInstance<P, N> {
+        BaoswapRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`BaoswapRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`BaoswapRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct BaoswapRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for BaoswapRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("BaoswapRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BaoswapRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`BaoswapRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`BaoswapRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> BaoswapRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> BaoswapRouterInstance<P, N> {
+            BaoswapRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BaoswapRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        BaoswapRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = BaoswapRouter::BaoswapRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        100u64 => Some((
+            ::alloy_primitives::address!("0x6093AeBAC87d62b1A5a4cEec91204e35020E38bE"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/chainalysisoracle/Cargo.toml b/contracts/generated/contracts-generated/chainalysisoracle/Cargo.toml
new file mode 100644
index 0000000000..9d645d896d
--- /dev/null
+++ b/contracts/generated/contracts-generated/chainalysisoracle/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-chainalysisoracle"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs b/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs
new file mode 100644
index 0000000000..086d7b80c5
--- /dev/null
+++ b/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs
@@ -0,0 +1,2800 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface ChainalysisOracle {
+    event NonSanctionedAddress(address indexed addr);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event SanctionedAddress(address indexed addr);
+    event SanctionedAddressesAdded(address[] addrs);
+    event SanctionedAddressesRemoved(address[] addrs);
+
+    constructor();
+
+    function addToSanctionsList(address[] memory newSanctions) external;
+    function isSanctioned(address addr) external view returns (bool);
+    function isSanctionedVerbose(address addr) external returns (bool);
+    function name() external pure returns (string memory);
+    function owner() external view returns (address);
+    function removeFromSanctionsList(address[] memory removeSanctions) external;
+    function renounceOwnership() external;
+    function transferOwnership(address newOwner) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addToSanctionsList",
+    "inputs": [
+      {
+        "name": "newSanctions",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isSanctioned",
+    "inputs": [
+      {
+        "name": "addr",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isSanctionedVerbose",
+    "inputs": [
+      {
+        "name": "addr",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "removeFromSanctionsList",
+    "inputs": [
+      {
+        "name": "removeSanctions",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "renounceOwnership",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "NonSanctionedAddress",
+    "inputs": [
+      {
+        "name": "addr",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SanctionedAddress",
+    "inputs": [
+      {
+        "name": "addr",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SanctionedAddressesAdded",
+    "inputs": [
+      {
+        "name": "addrs",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SanctionedAddressesRemoved",
+    "inputs": [
+      {
+        "name": "addrs",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ChainalysisOracle {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `NonSanctionedAddress(address)` and selector `0xd595018321fcb8c2bcbf5bfe4b27d74bea505825f7d195abe8517f94a065539c`.
+    ```solidity
+    event NonSanctionedAddress(address indexed addr);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct NonSanctionedAddress {
+        #[allow(missing_docs)]
+        pub addr: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for NonSanctionedAddress {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "NonSanctionedAddress(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    213u8, 149u8, 1u8, 131u8, 33u8, 252u8, 184u8, 194u8, 188u8, 191u8, 91u8, 254u8,
+                    75u8, 39u8, 215u8, 75u8, 234u8, 80u8, 88u8, 37u8, 247u8, 209u8, 149u8, 171u8,
+                    232u8, 81u8, 127u8, 148u8, 160u8, 101u8, 83u8, 156u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { addr: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.addr.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.addr,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for NonSanctionedAddress {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&NonSanctionedAddress> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &NonSanctionedAddress) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
+    ```solidity
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OwnershipTransferred {
+        #[allow(missing_docs)]
+        pub previousOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OwnershipTransferred {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
+                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
+                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    previousOwner: topics.1,
+                    newOwner: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.previousOwner.clone(),
+                    self.newOwner.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.previousOwner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.newOwner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SanctionedAddress(address)` and selector `0x8027911123971054d93579ebea046c8461473fa4d2e510b9b49eed3bed3270e0`.
+    ```solidity
+    event SanctionedAddress(address indexed addr);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SanctionedAddress {
+        #[allow(missing_docs)]
+        pub addr: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SanctionedAddress {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SanctionedAddress(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    128u8, 39u8, 145u8, 17u8, 35u8, 151u8, 16u8, 84u8, 217u8, 53u8, 121u8, 235u8,
+                    234u8, 4u8, 108u8, 132u8, 97u8, 71u8, 63u8, 164u8, 210u8, 229u8, 16u8, 185u8,
+                    180u8, 158u8, 237u8, 59u8, 237u8, 50u8, 112u8, 224u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { addr: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.addr.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.addr,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SanctionedAddress {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SanctionedAddress> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SanctionedAddress) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SanctionedAddressesAdded(address[])` and selector `0x2596d7dd6966c5673f9c06ddb0564c4f0e6d8d206ea075b83ad9ddd71a4fb927`.
+    ```solidity
+    event SanctionedAddressesAdded(address[] addrs);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SanctionedAddressesAdded {
+        #[allow(missing_docs)]
+        pub addrs: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SanctionedAddressesAdded {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SanctionedAddressesAdded(address[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    37u8, 150u8, 215u8, 221u8, 105u8, 102u8, 197u8, 103u8, 63u8, 156u8, 6u8, 221u8,
+                    176u8, 86u8, 76u8, 79u8, 14u8, 109u8, 141u8, 32u8, 110u8, 160u8, 117u8, 184u8,
+                    58u8, 217u8, 221u8, 215u8, 26u8, 79u8, 185u8, 39u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { addrs: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.addrs
+                ),)
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SanctionedAddressesAdded {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SanctionedAddressesAdded> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SanctionedAddressesAdded) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SanctionedAddressesRemoved(address[])` and selector `0x32aab684eee99db715515d1a9987a8fe33bb6341b0e35e60db7eab48a08f9a3a`.
+    ```solidity
+    event SanctionedAddressesRemoved(address[] addrs);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SanctionedAddressesRemoved {
+        #[allow(missing_docs)]
+        pub addrs: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SanctionedAddressesRemoved {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SanctionedAddressesRemoved(address[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    50u8, 170u8, 182u8, 132u8, 238u8, 233u8, 157u8, 183u8, 21u8, 81u8, 93u8, 26u8,
+                    153u8, 135u8, 168u8, 254u8, 51u8, 187u8, 99u8, 65u8, 176u8, 227u8, 94u8, 96u8,
+                    219u8, 126u8, 171u8, 72u8, 160u8, 143u8, 154u8, 58u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { addrs: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.addrs
+                ),)
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SanctionedAddressesRemoved {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SanctionedAddressesRemoved> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SanctionedAddressesRemoved) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {}
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addToSanctionsList(address[])` and selector `0xb972dfcc`.
+    ```solidity
+    function addToSanctionsList(address[] memory newSanctions) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addToSanctionsListCall {
+        #[allow(missing_docs)]
+        pub newSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    ///Container type for the return parameters of the
+    /// [`addToSanctionsList(address[])`](addToSanctionsListCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addToSanctionsListReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addToSanctionsListCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addToSanctionsListCall) -> Self {
+                    (value.newSanctions,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addToSanctionsListCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        newSanctions: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addToSanctionsListReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addToSanctionsListReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addToSanctionsListReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl addToSanctionsListReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addToSanctionsListCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addToSanctionsListCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type Return = addToSanctionsListReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [185u8, 114u8, 223u8, 204u8];
+            const SIGNATURE: &'static str = "addToSanctionsList(address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.newSanctions
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addToSanctionsListReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isSanctioned(address)` and selector `0xdf592f7d`.
+    ```solidity
+    function isSanctioned(address addr) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSanctionedCall {
+        #[allow(missing_docs)]
+        pub addr: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isSanctioned(address)`](isSanctionedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSanctionedReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSanctionedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isSanctionedCall) -> Self {
+                    (value.addr,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSanctionedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { addr: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSanctionedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isSanctionedReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSanctionedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isSanctionedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [223u8, 89u8, 47u8, 125u8];
+            const SIGNATURE: &'static str = "isSanctioned(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.addr,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isSanctionedReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isSanctionedReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isSanctionedVerbose(address)` and selector `0xa2a6bbd8`.
+    ```solidity
+    function isSanctionedVerbose(address addr) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSanctionedVerboseCall {
+        #[allow(missing_docs)]
+        pub addr: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isSanctionedVerbose(address)`](isSanctionedVerboseCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSanctionedVerboseReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSanctionedVerboseCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isSanctionedVerboseCall) -> Self {
+                    (value.addr,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSanctionedVerboseCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { addr: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSanctionedVerboseReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isSanctionedVerboseReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSanctionedVerboseReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isSanctionedVerboseCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [162u8, 166u8, 187u8, 216u8];
+            const SIGNATURE: &'static str = "isSanctionedVerbose(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.addr,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isSanctionedVerboseReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isSanctionedVerboseReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external pure returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `owner()` and selector `0x8da5cb5b`.
+    ```solidity
+    function owner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`owner()`](ownerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
+            const SIGNATURE: &'static str = "owner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ownerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: ownerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeFromSanctionsList(address[])` and selector `0xef782431`.
+    ```solidity
+    function removeFromSanctionsList(address[] memory removeSanctions) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeFromSanctionsListCall {
+        #[allow(missing_docs)]
+        pub removeSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    ///Container type for the return parameters of the
+    /// [`removeFromSanctionsList(address[])`](removeFromSanctionsListCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeFromSanctionsListReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeFromSanctionsListCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeFromSanctionsListCall) -> Self {
+                    (value.removeSanctions,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeFromSanctionsListCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        removeSanctions: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeFromSanctionsListReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeFromSanctionsListReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeFromSanctionsListReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl removeFromSanctionsListReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeFromSanctionsListCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeFromSanctionsListCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type Return = removeFromSanctionsListReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [239u8, 120u8, 36u8, 49u8];
+            const SIGNATURE: &'static str = "removeFromSanctionsList(address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.removeSanctions,
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeFromSanctionsListReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
+    ```solidity
+    function renounceOwnership() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct renounceOwnershipCall;
+    ///Container type for the return parameters of the
+    /// [`renounceOwnership()`](renounceOwnershipCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct renounceOwnershipReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
+                fn from(value: renounceOwnershipCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: renounceOwnershipReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl renounceOwnershipReturn {
+            fn _tokenize(
+                &self,
+            ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for renounceOwnershipCall {
+            type Parameters<'a> = ();
+            type Return = renounceOwnershipReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
+            const SIGNATURE: &'static str = "renounceOwnership()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                renounceOwnershipReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
+    ```solidity
+    function transferOwnership(address newOwner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferOwnershipCall {
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferOwnership(address)`](transferOwnershipCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferOwnershipReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferOwnershipCall) -> Self {
+                    (value.newOwner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { newOwner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferOwnershipReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferOwnershipReturn {
+            fn _tokenize(
+                &self,
+            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferOwnershipCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = transferOwnershipReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
+            const SIGNATURE: &'static str = "transferOwnership(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newOwner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferOwnershipReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`ChainalysisOracle`](self) function calls.
+    #[derive(Clone)]
+    pub enum ChainalysisOracleCalls {
+        #[allow(missing_docs)]
+        addToSanctionsList(addToSanctionsListCall),
+        #[allow(missing_docs)]
+        isSanctioned(isSanctionedCall),
+        #[allow(missing_docs)]
+        isSanctionedVerbose(isSanctionedVerboseCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        owner(ownerCall),
+        #[allow(missing_docs)]
+        removeFromSanctionsList(removeFromSanctionsListCall),
+        #[allow(missing_docs)]
+        renounceOwnership(renounceOwnershipCall),
+        #[allow(missing_docs)]
+        transferOwnership(transferOwnershipCall),
+    }
+    impl ChainalysisOracleCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [113u8, 80u8, 24u8, 166u8],
+            [141u8, 165u8, 203u8, 91u8],
+            [162u8, 166u8, 187u8, 216u8],
+            [185u8, 114u8, 223u8, 204u8],
+            [223u8, 89u8, 47u8, 125u8],
+            [239u8, 120u8, 36u8, 49u8],
+            [242u8, 253u8, 227u8, 139u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isSanctionedVerboseCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addToSanctionsListCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isSanctionedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeFromSanctionsListCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(renounceOwnership),
+            ::core::stringify!(owner),
+            ::core::stringify!(isSanctionedVerbose),
+            ::core::stringify!(addToSanctionsList),
+            ::core::stringify!(isSanctioned),
+            ::core::stringify!(removeFromSanctionsList),
+            ::core::stringify!(transferOwnership),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for ChainalysisOracleCalls {
+        const COUNT: usize = 8usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "ChainalysisOracleCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::addToSanctionsList(_) => {
+                    <addToSanctionsListCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isSanctioned(_) => <isSanctionedCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isSanctionedVerbose(_) => {
+                    <isSanctionedVerboseCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeFromSanctionsList(_) => {
+                    <removeFromSanctionsListCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::renounceOwnership(_) => {
+                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::transferOwnership(_) => {
+                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls>] =
+                &[
+                    {
+                        fn name(data: &[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                            <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(ChainalysisOracleCalls::name)
+                        }
+                        name
+                    },
+                    {
+                        fn renounceOwnership(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
+                        {
+                            <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::renounceOwnership)
+                        }
+                        renounceOwnership
+                    },
+                    {
+                        fn owner(data: &[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                            <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(ChainalysisOracleCalls::owner)
+                        }
+                        owner
+                    },
+                    {
+                        fn isSanctionedVerbose(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
+                        {
+                            <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::isSanctionedVerbose)
+                        }
+                        isSanctionedVerbose
+                    },
+                    {
+                        fn addToSanctionsList(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
+                        {
+                            <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::addToSanctionsList)
+                        }
+                        addToSanctionsList
+                    },
+                    {
+                        fn isSanctioned(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
+                        {
+                            <isSanctionedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(ChainalysisOracleCalls::isSanctioned)
+                        }
+                        isSanctioned
+                    },
+                    {
+                        fn removeFromSanctionsList(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
+                        {
+                            <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::removeFromSanctionsList)
+                        }
+                        removeFromSanctionsList
+                    },
+                    {
+                        fn transferOwnership(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
+                        {
+                            <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::transferOwnership)
+                        }
+                        transferOwnership
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                ChainalysisOracleCalls,
+            >] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ChainalysisOracleCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn renounceOwnership(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::renounceOwnership)
+                    }
+                    renounceOwnership
+                },
+                {
+                    fn owner(data: &[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ChainalysisOracleCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn isSanctionedVerbose(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::isSanctionedVerbose)
+                    }
+                    isSanctionedVerbose
+                },
+                {
+                    fn addToSanctionsList(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::addToSanctionsList)
+                    }
+                    addToSanctionsList
+                },
+                {
+                    fn isSanctioned(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <isSanctionedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ChainalysisOracleCalls::isSanctioned)
+                    }
+                    isSanctioned
+                },
+                {
+                    fn removeFromSanctionsList(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::removeFromSanctionsList)
+                    }
+                    removeFromSanctionsList
+                },
+                {
+                    fn transferOwnership(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
+                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ChainalysisOracleCalls::transferOwnership)
+                    }
+                    transferOwnership
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::addToSanctionsList(inner) => {
+                    <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isSanctioned(inner) => {
+                    <isSanctionedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isSanctionedVerbose(inner) => {
+                    <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeFromSanctionsList(inner) => {
+                    <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::renounceOwnership(inner) => {
+                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferOwnership(inner) => {
+                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::addToSanctionsList(inner) => {
+                    <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isSanctioned(inner) => {
+                    <isSanctionedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isSanctionedVerbose(inner) => {
+                    <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeFromSanctionsList(inner) => {
+                    <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::renounceOwnership(inner) => {
+                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferOwnership(inner) => {
+                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`ChainalysisOracle`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum ChainalysisOracleEvents {
+        #[allow(missing_docs)]
+        NonSanctionedAddress(NonSanctionedAddress),
+        #[allow(missing_docs)]
+        OwnershipTransferred(OwnershipTransferred),
+        #[allow(missing_docs)]
+        SanctionedAddress(SanctionedAddress),
+        #[allow(missing_docs)]
+        SanctionedAddressesAdded(SanctionedAddressesAdded),
+        #[allow(missing_docs)]
+        SanctionedAddressesRemoved(SanctionedAddressesRemoved),
+    }
+    impl ChainalysisOracleEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                37u8, 150u8, 215u8, 221u8, 105u8, 102u8, 197u8, 103u8, 63u8, 156u8, 6u8, 221u8,
+                176u8, 86u8, 76u8, 79u8, 14u8, 109u8, 141u8, 32u8, 110u8, 160u8, 117u8, 184u8,
+                58u8, 217u8, 221u8, 215u8, 26u8, 79u8, 185u8, 39u8,
+            ],
+            [
+                50u8, 170u8, 182u8, 132u8, 238u8, 233u8, 157u8, 183u8, 21u8, 81u8, 93u8, 26u8,
+                153u8, 135u8, 168u8, 254u8, 51u8, 187u8, 99u8, 65u8, 176u8, 227u8, 94u8, 96u8,
+                219u8, 126u8, 171u8, 72u8, 160u8, 143u8, 154u8, 58u8,
+            ],
+            [
+                128u8, 39u8, 145u8, 17u8, 35u8, 151u8, 16u8, 84u8, 217u8, 53u8, 121u8, 235u8,
+                234u8, 4u8, 108u8, 132u8, 97u8, 71u8, 63u8, 164u8, 210u8, 229u8, 16u8, 185u8,
+                180u8, 158u8, 237u8, 59u8, 237u8, 50u8, 112u8, 224u8,
+            ],
+            [
+                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
+                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
+                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
+            ],
+            [
+                213u8, 149u8, 1u8, 131u8, 33u8, 252u8, 184u8, 194u8, 188u8, 191u8, 91u8, 254u8,
+                75u8, 39u8, 215u8, 75u8, 234u8, 80u8, 88u8, 37u8, 247u8, 209u8, 149u8, 171u8,
+                232u8, 81u8, 127u8, 148u8, 160u8, 101u8, 83u8, 156u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <SanctionedAddressesAdded as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SanctionedAddressesRemoved as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SanctionedAddress as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
+            <NonSanctionedAddress as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(SanctionedAddressesAdded),
+            ::core::stringify!(SanctionedAddressesRemoved),
+            ::core::stringify!(SanctionedAddress),
+            ::core::stringify!(OwnershipTransferred),
+            ::core::stringify!(NonSanctionedAddress),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for ChainalysisOracleEvents {
+        const COUNT: usize = 5usize;
+        const NAME: &'static str = "ChainalysisOracleEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<NonSanctionedAddress as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <NonSanctionedAddress as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::NonSanctionedAddress)
+                }
+                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::OwnershipTransferred)
+                }
+                Some(<SanctionedAddress as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SanctionedAddress as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SanctionedAddress)
+                }
+                Some(<SanctionedAddressesAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SanctionedAddressesAdded as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::SanctionedAddressesAdded)
+                }
+                Some(<SanctionedAddressesRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SanctionedAddressesRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::SanctionedAddressesRemoved)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for ChainalysisOracleEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::NonSanctionedAddress(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OwnershipTransferred(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SanctionedAddress(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SanctionedAddressesAdded(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SanctionedAddressesRemoved(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::NonSanctionedAddress(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OwnershipTransferred(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SanctionedAddress(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SanctionedAddressesAdded(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SanctionedAddressesRemoved(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ChainalysisOracle`](self) contract instance.
+
+    See the [wrapper's documentation](`ChainalysisOracleInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ChainalysisOracleInstance<P, N> {
+        ChainalysisOracleInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ChainalysisOracle`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ChainalysisOracle`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ChainalysisOracleInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ChainalysisOracleInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ChainalysisOracleInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ChainalysisOracleInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ChainalysisOracle`](self) contract instance.
+
+        See the [wrapper's documentation](`ChainalysisOracleInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ChainalysisOracleInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ChainalysisOracleInstance<P, N> {
+            ChainalysisOracleInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ChainalysisOracleInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`addToSanctionsList`] function.
+        pub fn addToSanctionsList(
+            &self,
+            newSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, addToSanctionsListCall, N> {
+            self.call_builder(&addToSanctionsListCall { newSanctions })
+        }
+
+        ///Creates a new call builder for the [`isSanctioned`] function.
+        pub fn isSanctioned(
+            &self,
+            addr: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isSanctionedCall, N> {
+            self.call_builder(&isSanctionedCall { addr })
+        }
+
+        ///Creates a new call builder for the [`isSanctionedVerbose`] function.
+        pub fn isSanctionedVerbose(
+            &self,
+            addr: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isSanctionedVerboseCall, N> {
+            self.call_builder(&isSanctionedVerboseCall { addr })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`owner`] function.
+        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
+            self.call_builder(&ownerCall)
+        }
+
+        ///Creates a new call builder for the [`removeFromSanctionsList`]
+        /// function.
+        pub fn removeFromSanctionsList(
+            &self,
+            removeSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeFromSanctionsListCall, N> {
+            self.call_builder(&removeFromSanctionsListCall { removeSanctions })
+        }
+
+        ///Creates a new call builder for the [`renounceOwnership`] function.
+        pub fn renounceOwnership(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
+            self.call_builder(&renounceOwnershipCall)
+        }
+
+        ///Creates a new call builder for the [`transferOwnership`] function.
+        pub fn transferOwnership(
+            &self,
+            newOwner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
+            self.call_builder(&transferOwnershipCall { newOwner })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ChainalysisOracleInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`NonSanctionedAddress`] event.
+        pub fn NonSanctionedAddress_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, NonSanctionedAddress, N> {
+            self.event_filter::<NonSanctionedAddress>()
+        }
+
+        ///Creates a new event filter for the [`OwnershipTransferred`] event.
+        pub fn OwnershipTransferred_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
+            self.event_filter::<OwnershipTransferred>()
+        }
+
+        ///Creates a new event filter for the [`SanctionedAddress`] event.
+        pub fn SanctionedAddress_filter(&self) -> alloy_contract::Event<&P, SanctionedAddress, N> {
+            self.event_filter::<SanctionedAddress>()
+        }
+
+        ///Creates a new event filter for the [`SanctionedAddressesAdded`]
+        /// event.
+        pub fn SanctionedAddressesAdded_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SanctionedAddressesAdded, N> {
+            self.event_filter::<SanctionedAddressesAdded>()
+        }
+
+        ///Creates a new event filter for the [`SanctionedAddressesRemoved`]
+        /// event.
+        pub fn SanctionedAddressesRemoved_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, SanctionedAddressesRemoved, N> {
+            self.event_filter::<SanctionedAddressesRemoved>()
+        }
+    }
+}
+pub type Instance = ChainalysisOracle::ChainalysisOracleInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x40C57923924B5c5c5455c48D93317139ADDaC8fb"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x40C57923924B5c5c5455c48D93317139ADDaC8fb"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x40C57923924B5c5c5455c48D93317139ADDaC8fb"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x40C57923924B5c5c5455c48D93317139ADDaC8fb"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x3A91A31cB3dC49b4db9Ce721F50a9D076c8D739B"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x40C57923924B5c5c5455c48D93317139ADDaC8fb"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x40C57923924B5c5c5455c48D93317139ADDaC8fb"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/counter/Cargo.toml b/contracts/generated/contracts-generated/counter/Cargo.toml
new file mode 100644
index 0000000000..0a64b45896
--- /dev/null
+++ b/contracts/generated/contracts-generated/counter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-counter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/counter/src/lib.rs b/contracts/generated/contracts-generated/counter/src/lib.rs
new file mode 100644
index 0000000000..4815a41f7f
--- /dev/null
+++ b/contracts/generated/contracts-generated/counter/src/lib.rs
@@ -0,0 +1,952 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Counter {
+    function counters(string memory) external view returns (uint256);
+    function incrementCounter(string memory key) external;
+    function setCounterToBalance(string memory key, address token, address owner) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "counters",
+    "inputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "incrementCounter",
+    "inputs": [
+      {
+        "name": "key",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setCounterToBalance",
+    "inputs": [
+      {
+        "name": "key",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Counter {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x03\xCD\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\t1\x83\x1E\x14a\0CW\x80cW\xCE\xDF@\x14a\0XW\x80c\x94$\xC8\xC8\x14a\0\x94W[__\xFD[a\0Va\0Q6`\x04a\x02\xABV[a\0\xA7V[\0[a\0\x82a\0f6`\x04a\x03\x05V[\x80Q` \x81\x83\x01\x81\x01\x80Q_\x82R\x92\x82\x01\x91\x90\x93\x01 \x91RT\x81V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0Va\0\xA26`\x04a\x03\x05V[a\x01YV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16`\x04\x83\x01R\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x015\x91\x90a\x03?V[_\x84`@Qa\x01D\x91\x90a\x03VV[\x90\x81R`@Q\x90\x81\x90\x03` \x01\x90 UPPPV[`\x01_\x82`@Qa\x01j\x91\x90a\x03VV[\x90\x81R` \x01`@Q\x80\x91\x03\x90 _\x82\x82Ta\x01\x86\x91\x90a\x03\x82V[\x90\x91UPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\x01\xCAW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xE4Wa\x01\xE4a\x01\x8EV[`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`?\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x02PWa\x02Pa\x01\x8EV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x02gW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02\xA6W__\xFD[\x91\x90PV[___``\x84\x86\x03\x12\x15a\x02\xBDW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x02\xD3W__\xFD[a\x02\xDF\x86\x82\x87\x01a\x01\xBBV[\x93PPa\x02\xEE` \x85\x01a\x02\x83V[\x91Pa\x02\xFC`@\x85\x01a\x02\x83V[\x90P\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x03\x15W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03+W__\xFD[a\x037\x84\x82\x85\x01a\x01\xBBV[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x03OW__\xFD[PQ\x91\x90PV[_\x82Q_[\x81\x81\x10\x15a\x03uW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\x03[V[P_\x92\x01\x91\x82RP\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03\xBAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x92\x91PPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x608060405234801561000f575f5ffd5b506004361061003f575f3560e01c80630931831e1461004357806357cedf40146100585780639424c8c814610094575b5f5ffd5b6100566100513660046102ab565b6100a7565b005b610082610066366004610305565b80516020818301810180515f8252928201919093012091525481565b60405190815260200160405180910390f35b6100566100a2366004610305565b610159565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff82811660048301528316906370a0823190602401602060405180830381865afa158015610111573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610135919061033f565b5f846040516101449190610356565b90815260405190819003602001902055505050565b60015f8260405161016a9190610356565b90815260200160405180910390205f8282546101869190610382565b909155505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f82601f8301126101ca575f5ffd5b813567ffffffffffffffff8111156101e4576101e461018e565b6040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8501160116810181811067ffffffffffffffff821117156102505761025061018e565b604052818152838201602001851015610267575f5ffd5b816020850160208301375f918101602001919091529392505050565b803573ffffffffffffffffffffffffffffffffffffffff811681146102a6575f5ffd5b919050565b5f5f5f606084860312156102bd575f5ffd5b833567ffffffffffffffff8111156102d3575f5ffd5b6102df868287016101bb565b9350506102ee60208501610283565b91506102fc60408501610283565b90509250925092565b5f60208284031215610315575f5ffd5b813567ffffffffffffffff81111561032b575f5ffd5b610337848285016101bb565b949350505050565b5f6020828403121561034f575f5ffd5b5051919050565b5f82515f5b81811015610375576020818601810151858301520161035b565b505f920191825250919050565b808201808211156103ba577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b9291505056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\t1\x83\x1E\x14a\0CW\x80cW\xCE\xDF@\x14a\0XW\x80c\x94$\xC8\xC8\x14a\0\x94W[__\xFD[a\0Va\0Q6`\x04a\x02\xABV[a\0\xA7V[\0[a\0\x82a\0f6`\x04a\x03\x05V[\x80Q` \x81\x83\x01\x81\x01\x80Q_\x82R\x92\x82\x01\x91\x90\x93\x01 \x91RT\x81V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0Va\0\xA26`\x04a\x03\x05V[a\x01YV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16`\x04\x83\x01R\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x015\x91\x90a\x03?V[_\x84`@Qa\x01D\x91\x90a\x03VV[\x90\x81R`@Q\x90\x81\x90\x03` \x01\x90 UPPPV[`\x01_\x82`@Qa\x01j\x91\x90a\x03VV[\x90\x81R` \x01`@Q\x80\x91\x03\x90 _\x82\x82Ta\x01\x86\x91\x90a\x03\x82V[\x90\x91UPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\x01\xCAW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xE4Wa\x01\xE4a\x01\x8EV[`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`?\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x02PWa\x02Pa\x01\x8EV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x02gW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02\xA6W__\xFD[\x91\x90PV[___``\x84\x86\x03\x12\x15a\x02\xBDW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x02\xD3W__\xFD[a\x02\xDF\x86\x82\x87\x01a\x01\xBBV[\x93PPa\x02\xEE` \x85\x01a\x02\x83V[\x91Pa\x02\xFC`@\x85\x01a\x02\x83V[\x90P\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x03\x15W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03+W__\xFD[a\x037\x84\x82\x85\x01a\x01\xBBV[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x03OW__\xFD[PQ\x91\x90PV[_\x82Q_[\x81\x81\x10\x15a\x03uW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\x03[V[P_\x92\x01\x91\x82RP\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03\xBAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x92\x91PPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `counters(string)` and selector `0x57cedf40`.
+    ```solidity
+    function counters(string memory) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct countersCall(pub alloy_sol_types::private::String);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`counters(string)`](countersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct countersReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<countersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: countersCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for countersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<countersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: countersReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for countersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for countersCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::String,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [87u8, 206u8, 223u8, 64u8];
+            const SIGNATURE: &'static str = "counters(string)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: countersReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: countersReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `incrementCounter(string)` and selector `0x9424c8c8`.
+    ```solidity
+    function incrementCounter(string memory key) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct incrementCounterCall {
+        #[allow(missing_docs)]
+        pub key: alloy_sol_types::private::String,
+    }
+    ///Container type for the return parameters of the
+    /// [`incrementCounter(string)`](incrementCounterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct incrementCounterReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<incrementCounterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: incrementCounterCall) -> Self {
+                    (value.key,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for incrementCounterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { key: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<incrementCounterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: incrementCounterReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for incrementCounterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl incrementCounterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <incrementCounterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for incrementCounterCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::String,);
+            type Return = incrementCounterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [148u8, 36u8, 200u8, 200u8];
+            const SIGNATURE: &'static str = "incrementCounter(string)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.key,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                incrementCounterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setCounterToBalance(string,address,address)` and selector `0x0931831e`.
+    ```solidity
+    function setCounterToBalance(string memory key, address token, address owner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setCounterToBalanceCall {
+        #[allow(missing_docs)]
+        pub key: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setCounterToBalance(string,address,address)`](setCounterToBalanceCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setCounterToBalanceReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setCounterToBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setCounterToBalanceCall) -> Self {
+                    (value.key, value.token, value.owner)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setCounterToBalanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        key: tuple.0,
+                        token: tuple.1,
+                        owner: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setCounterToBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setCounterToBalanceReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setCounterToBalanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setCounterToBalanceReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setCounterToBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setCounterToBalanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = setCounterToBalanceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 49u8, 131u8, 30u8];
+            const SIGNATURE: &'static str = "setCounterToBalance(string,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.key,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setCounterToBalanceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`Counter`](self) function calls.
+    #[derive(Clone)]
+    pub enum CounterCalls {
+        #[allow(missing_docs)]
+        counters(countersCall),
+        #[allow(missing_docs)]
+        incrementCounter(incrementCounterCall),
+        #[allow(missing_docs)]
+        setCounterToBalance(setCounterToBalanceCall),
+    }
+    impl CounterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [9u8, 49u8, 131u8, 30u8],
+            [87u8, 206u8, 223u8, 64u8],
+            [148u8, 36u8, 200u8, 200u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <setCounterToBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <countersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <incrementCounterCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(setCounterToBalance),
+            ::core::stringify!(counters),
+            ::core::stringify!(incrementCounter),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CounterCalls {
+        const COUNT: usize = 3usize;
+        const MIN_DATA_LENGTH: usize = 64usize;
+        const NAME: &'static str = "CounterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::counters(_) => <countersCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::incrementCounter(_) => {
+                    <incrementCounterCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setCounterToBalance(_) => {
+                    <setCounterToBalanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CounterCalls>] = &[
+                {
+                    fn setCounterToBalance(data: &[u8]) -> alloy_sol_types::Result<CounterCalls> {
+                        <setCounterToBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CounterCalls::setCounterToBalance)
+                    }
+                    setCounterToBalance
+                },
+                {
+                    fn counters(data: &[u8]) -> alloy_sol_types::Result<CounterCalls> {
+                        <countersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CounterCalls::counters)
+                    }
+                    counters
+                },
+                {
+                    fn incrementCounter(data: &[u8]) -> alloy_sol_types::Result<CounterCalls> {
+                        <incrementCounterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CounterCalls::incrementCounter)
+                    }
+                    incrementCounter
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CounterCalls>] = &[
+                {
+                    fn setCounterToBalance(data: &[u8]) -> alloy_sol_types::Result<CounterCalls> {
+                        <setCounterToBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CounterCalls::setCounterToBalance)
+                    }
+                    setCounterToBalance
+                },
+                {
+                    fn counters(data: &[u8]) -> alloy_sol_types::Result<CounterCalls> {
+                        <countersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CounterCalls::counters)
+                    }
+                    counters
+                },
+                {
+                    fn incrementCounter(data: &[u8]) -> alloy_sol_types::Result<CounterCalls> {
+                        <incrementCounterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CounterCalls::incrementCounter)
+                    }
+                    incrementCounter
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::counters(inner) => {
+                    <countersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::incrementCounter(inner) => {
+                    <incrementCounterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setCounterToBalance(inner) => {
+                    <setCounterToBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::counters(inner) => {
+                    <countersCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::incrementCounter(inner) => {
+                    <incrementCounterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setCounterToBalance(inner) => {
+                    <setCounterToBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Counter`](self) contract instance.
+
+    See the [wrapper's documentation](`CounterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CounterInstance<P, N> {
+        CounterInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<CounterInstance<P, N>>> {
+        CounterInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CounterInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Counter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Counter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CounterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CounterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CounterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CounterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Counter`](self) contract instance.
+
+        See the [wrapper's documentation](`CounterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<CounterInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CounterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CounterInstance<P, N> {
+            CounterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CounterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`counters`] function.
+        pub fn counters(
+            &self,
+            _0: alloy_sol_types::private::String,
+        ) -> alloy_contract::SolCallBuilder<&P, countersCall, N> {
+            self.call_builder(&countersCall(_0))
+        }
+
+        ///Creates a new call builder for the [`incrementCounter`] function.
+        pub fn incrementCounter(
+            &self,
+            key: alloy_sol_types::private::String,
+        ) -> alloy_contract::SolCallBuilder<&P, incrementCounterCall, N> {
+            self.call_builder(&incrementCounterCall { key })
+        }
+
+        ///Creates a new call builder for the [`setCounterToBalance`] function.
+        pub fn setCounterToBalance(
+            &self,
+            key: alloy_sol_types::private::String,
+            token: alloy_sol_types::private::Address,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setCounterToBalanceCall, N> {
+            self.call_builder(&setCounterToBalanceCall { key, token, owner })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CounterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Counter::CounterInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/cowamm/Cargo.toml b/contracts/generated/contracts-generated/cowamm/Cargo.toml
new file mode 100644
index 0000000000..5d4ed709e9
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowamm/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowamm"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowamm/src/lib.rs b/contracts/generated/contracts-generated/cowamm/src/lib.rs
new file mode 100644
index 0000000000..4b9d028c82
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowamm/src/lib.rs
@@ -0,0 +1,6641 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ConstantProduct {
+    struct TradingParams { uint256 minTradedToken0; address priceOracle; bytes priceOracleData; bytes32 appData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ConstantProduct {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct TradingParams { uint256 minTradedToken0; address priceOracle; bytes priceOracleData; bytes32 appData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TradingParams {
+        #[allow(missing_docs)]
+        pub minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub priceOracle: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub priceOracleData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TradingParams> for UnderlyingRustTuple<'_> {
+            fn from(value: TradingParams) -> Self {
+                (
+                    value.minTradedToken0,
+                    value.priceOracle,
+                    value.priceOracleData,
+                    value.appData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TradingParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    minTradedToken0: tuple.0,
+                    priceOracle: tuple.1,
+                    priceOracleData: tuple.2,
+                    appData: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for TradingParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for TradingParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minTradedToken0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracle,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracleData,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TradingParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for TradingParams {
+            const NAME: &'static str = "TradingParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "TradingParams(uint256 minTradedToken0,address priceOracle,bytes \
+                     priceOracleData,bytes32 appData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.minTradedToken0,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.priceOracle,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.priceOracleData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TradingParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minTradedToken0,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.priceOracle,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.priceOracleData,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minTradedToken0,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.priceOracle,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.priceOracleData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ConstantProduct`](self) contract instance.
+
+    See the [wrapper's documentation](`ConstantProductInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ConstantProductInstance<P, N> {
+        ConstantProductInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ConstantProduct`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ConstantProduct`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ConstantProductInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ConstantProductInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ConstantProductInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ConstantProductInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ConstantProduct`](self) contract instance.
+
+        See the [wrapper's documentation](`ConstantProductInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ConstantProductInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ConstantProductInstance<P, N> {
+            ConstantProductInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ConstantProductInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ConstantProductInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Order {
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Order {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub kind: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub partiallyFillable: bool,
+        #[allow(missing_docs)]
+        pub sellTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub buyTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            bool,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.sellToken,
+                    value.buyToken,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.validTo,
+                    value.appData,
+                    value.feeAmount,
+                    value.kind,
+                    value.partiallyFillable,
+                    value.sellTokenBalance,
+                    value.buyTokenBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sellToken: tuple.0,
+                    buyToken: tuple.1,
+                    receiver: tuple.2,
+                    sellAmount: tuple.3,
+                    buyAmount: tuple.4,
+                    validTo: tuple.5,
+                    appData: tuple.6,
+                    feeAmount: tuple.7,
+                    kind: tuple.8,
+                    partiallyFillable: tuple.9,
+                    sellTokenBalance: tuple.10,
+                    buyTokenBalance: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.partiallyFillable,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenBalance),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenBalance),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address sellToken,address buyToken,address receiver,uint256 \
+                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
+                     feeAmount,bytes32 kind,bool partiallyFillable,bytes32 \
+                     sellTokenBalance,bytes32 buyTokenBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.partiallyFillable,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellTokenBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyTokenBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.kind)
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.partiallyFillable,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellTokenBalance,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyTokenBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.partiallyFillable,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellTokenBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyTokenBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2OrderInstance<P, N> {
+        GPv2OrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Order`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Order`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2OrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2OrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2OrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2OrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2OrderInstance<P, N> {
+            GPv2OrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library ConstantProduct {
+    struct TradingParams {
+        uint256 minTradedToken0;
+        address priceOracle;
+        bytes priceOracleData;
+        bytes32 appData;
+    }
+}
+
+library GPv2Order {
+    struct Data {
+        address sellToken;
+        address buyToken;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        uint32 validTo;
+        bytes32 appData;
+        uint256 feeAmount;
+        bytes32 kind;
+        bool partiallyFillable;
+        bytes32 sellTokenBalance;
+        bytes32 buyTokenBalance;
+    }
+}
+
+interface CowAmm {
+    error CommitOutsideOfSettlement();
+    error OnlyManagerCanCall();
+    error OrderDoesNotMatchCommitmentHash();
+    error OrderDoesNotMatchDefaultTradeableOrder();
+    error OrderDoesNotMatchMessageHash();
+    error OrderNotValid(string);
+    error PollTryAtBlock(uint256 blockNumber, string message);
+    error TradingParamsDoNotMatchHash();
+
+    event TradingDisabled();
+    event TradingEnabled(bytes32 indexed hash, ConstantProduct.TradingParams params);
+
+    constructor(address _solutionSettler, address _token0, address _token1);
+
+    function COMMITMENT_SLOT() external view returns (uint256);
+    function EMPTY_COMMITMENT() external view returns (bytes32);
+    function MAX_ORDER_DURATION() external view returns (uint32);
+    function NO_TRADING() external view returns (bytes32);
+    function commit(bytes32 orderHash) external;
+    function commitment() external view returns (bytes32 value);
+    function disableTrading() external;
+    function enableTrading(ConstantProduct.TradingParams memory tradingParams) external;
+    function getTradeableOrder(ConstantProduct.TradingParams memory tradingParams) external view returns (GPv2Order.Data memory order);
+    function hash(ConstantProduct.TradingParams memory tradingParams) external pure returns (bytes32);
+    function isValidSignature(bytes32 _hash, bytes memory signature) external view returns (bytes4);
+    function manager() external view returns (address);
+    function solutionSettler() external view returns (address);
+    function solutionSettlerDomainSeparator() external view returns (bytes32);
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function tradingParamsHash() external view returns (bytes32);
+    function verify(ConstantProduct.TradingParams memory tradingParams, GPv2Order.Data memory order) external view;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_solutionSettler",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      },
+      {
+        "name": "_token0",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "_token1",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "COMMITMENT_SLOT",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "EMPTY_COMMITMENT",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MAX_ORDER_DURATION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "NO_TRADING",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "commit",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "commitment",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "value",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "disableTrading",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "enableTrading",
+    "inputs": [
+      {
+        "name": "tradingParams",
+        "type": "tuple",
+        "internalType": "struct ConstantProduct.TradingParams",
+        "components": [
+          {
+            "name": "minTradedToken0",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "priceOracle",
+            "type": "address",
+            "internalType": "contract IPriceOracle"
+          },
+          {
+            "name": "priceOracleData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getTradeableOrder",
+    "inputs": [
+      {
+        "name": "tradingParams",
+        "type": "tuple",
+        "internalType": "struct ConstantProduct.TradingParams",
+        "components": [
+          {
+            "name": "minTradedToken0",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "priceOracle",
+            "type": "address",
+            "internalType": "contract IPriceOracle"
+          },
+          {
+            "name": "priceOracleData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct GPv2Order.Data",
+        "components": [
+          {
+            "name": "sellToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "kind",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "sellTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "buyTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "hash",
+    "inputs": [
+      {
+        "name": "tradingParams",
+        "type": "tuple",
+        "internalType": "struct ConstantProduct.TradingParams",
+        "components": [
+          {
+            "name": "minTradedToken0",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "priceOracle",
+            "type": "address",
+            "internalType": "contract IPriceOracle"
+          },
+          {
+            "name": "priceOracleData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "_hash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "manager",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "solutionSettler",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "solutionSettlerDomainSeparator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "token0",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "token1",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "tradingParamsHash",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "verify",
+    "inputs": [
+      {
+        "name": "tradingParams",
+        "type": "tuple",
+        "internalType": "struct ConstantProduct.TradingParams",
+        "components": [
+          {
+            "name": "minTradedToken0",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "priceOracle",
+            "type": "address",
+            "internalType": "contract IPriceOracle"
+          },
+          {
+            "name": "priceOracleData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct GPv2Order.Data",
+        "components": [
+          {
+            "name": "sellToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "kind",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "sellTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "buyTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "TradingDisabled",
+    "inputs": [],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TradingEnabled",
+    "inputs": [
+      {
+        "name": "hash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "params",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct ConstantProduct.TradingParams",
+        "components": [
+          {
+            "name": "minTradedToken0",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "priceOracle",
+            "type": "address",
+            "internalType": "contract IPriceOracle"
+          },
+          {
+            "name": "priceOracleData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "CommitOutsideOfSettlement",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OnlyManagerCanCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderDoesNotMatchCommitmentHash",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderDoesNotMatchDefaultTradeableOrder",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderDoesNotMatchMessageHash",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderNotValid",
+    "inputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "PollTryAtBlock",
+    "inputs": [
+      {
+        "name": "blockNumber",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "message",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "TradingParamsDoNotMatchHash",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowAmm {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `CommitOutsideOfSettlement()` and selector `0xbf848977`.
+    ```solidity
+    error CommitOutsideOfSettlement();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct CommitOutsideOfSettlement;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<CommitOutsideOfSettlement> for UnderlyingRustTuple<'_> {
+            fn from(value: CommitOutsideOfSettlement) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CommitOutsideOfSettlement {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for CommitOutsideOfSettlement {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [191u8, 132u8, 137u8, 119u8];
+            const SIGNATURE: &'static str = "CommitOutsideOfSettlement()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OnlyManagerCanCall()` and selector `0xf87d0d16`.
+    ```solidity
+    error OnlyManagerCanCall();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnlyManagerCanCall;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OnlyManagerCanCall> for UnderlyingRustTuple<'_> {
+            fn from(value: OnlyManagerCanCall) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyManagerCanCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OnlyManagerCanCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 125u8, 13u8, 22u8];
+            const SIGNATURE: &'static str = "OnlyManagerCanCall()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderDoesNotMatchCommitmentHash()` and selector `0xdafbdd1f`.
+    ```solidity
+    error OrderDoesNotMatchCommitmentHash();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderDoesNotMatchCommitmentHash;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderDoesNotMatchCommitmentHash> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderDoesNotMatchCommitmentHash) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderDoesNotMatchCommitmentHash {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderDoesNotMatchCommitmentHash {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [218u8, 251u8, 221u8, 31u8];
+            const SIGNATURE: &'static str = "OrderDoesNotMatchCommitmentHash()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderDoesNotMatchDefaultTradeableOrder()` and selector `0xd9ff24c7`.
+    ```solidity
+    error OrderDoesNotMatchDefaultTradeableOrder();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderDoesNotMatchDefaultTradeableOrder;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderDoesNotMatchDefaultTradeableOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderDoesNotMatchDefaultTradeableOrder) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderDoesNotMatchDefaultTradeableOrder {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderDoesNotMatchDefaultTradeableOrder {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [217u8, 255u8, 36u8, 199u8];
+            const SIGNATURE: &'static str = "OrderDoesNotMatchDefaultTradeableOrder()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderDoesNotMatchMessageHash()` and selector `0x593fcacd`.
+    ```solidity
+    error OrderDoesNotMatchMessageHash();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderDoesNotMatchMessageHash;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderDoesNotMatchMessageHash> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderDoesNotMatchMessageHash) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderDoesNotMatchMessageHash {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderDoesNotMatchMessageHash {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [89u8, 63u8, 202u8, 205u8];
+            const SIGNATURE: &'static str = "OrderDoesNotMatchMessageHash()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderNotValid(string)` and selector `0xc8fc2725`.
+    ```solidity
+    error OrderNotValid(string);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderNotValid(pub alloy_sol_types::private::String);
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderNotValid> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderNotValid) -> Self {
+                (value.0,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderNotValid {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self(tuple.0)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderNotValid {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [200u8, 252u8, 39u8, 37u8];
+            const SIGNATURE: &'static str = "OrderNotValid(string)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `PollTryAtBlock(uint256,string)` and selector `0x1fe8506e`.
+    ```solidity
+    error PollTryAtBlock(uint256 blockNumber, string message);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PollTryAtBlock {
+        #[allow(missing_docs)]
+        pub blockNumber: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub message: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::String,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::String,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PollTryAtBlock> for UnderlyingRustTuple<'_> {
+            fn from(value: PollTryAtBlock) -> Self {
+                (value.blockNumber, value.message)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PollTryAtBlock {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    blockNumber: tuple.0,
+                    message: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for PollTryAtBlock {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 232u8, 80u8, 110u8];
+            const SIGNATURE: &'static str = "PollTryAtBlock(uint256,string)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockNumber,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.message,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `TradingParamsDoNotMatchHash()` and selector `0xf1a67890`.
+    ```solidity
+    error TradingParamsDoNotMatchHash();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TradingParamsDoNotMatchHash;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TradingParamsDoNotMatchHash> for UnderlyingRustTuple<'_> {
+            fn from(value: TradingParamsDoNotMatchHash) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TradingParamsDoNotMatchHash {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for TradingParamsDoNotMatchHash {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [241u8, 166u8, 120u8, 144u8];
+            const SIGNATURE: &'static str = "TradingParamsDoNotMatchHash()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TradingDisabled()` and selector `0xbcb8b8fbdea8aa6dc4ae41213e4da81e605a3d1a56ed851b9355182321c09190`.
+    ```solidity
+    event TradingDisabled();
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TradingDisabled;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TradingDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TradingDisabled()";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    188u8, 184u8, 184u8, 251u8, 222u8, 168u8, 170u8, 109u8, 196u8, 174u8, 65u8,
+                    33u8, 62u8, 77u8, 168u8, 30u8, 96u8, 90u8, 61u8, 26u8, 86u8, 237u8, 133u8,
+                    27u8, 147u8, 85u8, 24u8, 35u8, 33u8, 192u8, 145u8, 144u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {}
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TradingDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TradingDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TradingDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TradingEnabled(bytes32,(uint256,address,bytes,bytes32))` and selector `0x510e4a4f76907c2d6158b343f7c4f2f597df385b727c26e9ef90e75093ace19a`.
+    ```solidity
+    event TradingEnabled(bytes32 indexed hash, ConstantProduct.TradingParams params);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TradingEnabled {
+        #[allow(missing_docs)]
+        pub hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub params: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TradingEnabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (ConstantProduct::TradingParams,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "TradingEnabled(bytes32,(uint256,address,bytes,bytes32))";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    81u8, 14u8, 74u8, 79u8, 118u8, 144u8, 124u8, 45u8, 97u8, 88u8, 179u8, 67u8,
+                    247u8, 196u8, 242u8, 245u8, 151u8, 223u8, 56u8, 91u8, 114u8, 124u8, 38u8,
+                    233u8, 239u8, 144u8, 231u8, 80u8, 147u8, 172u8, 225u8, 154u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    hash: topics.1,
+                    params: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.hash.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.hash);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TradingEnabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TradingEnabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TradingEnabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address _solutionSettler, address _token0, address _token1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _solutionSettler: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _token1: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._solutionSettler, value._token0, value._token1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _solutionSettler: tuple.0,
+                        _token0: tuple.1,
+                        _token1: tuple.2,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._solutionSettler,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._token0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._token1,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `COMMITMENT_SLOT()` and selector `0x3e706e32`.
+    ```solidity
+    function COMMITMENT_SLOT() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct COMMITMENT_SLOTCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`COMMITMENT_SLOT()`](COMMITMENT_SLOTCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct COMMITMENT_SLOTReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<COMMITMENT_SLOTCall> for UnderlyingRustTuple<'_> {
+                fn from(value: COMMITMENT_SLOTCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for COMMITMENT_SLOTCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<COMMITMENT_SLOTReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: COMMITMENT_SLOTReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for COMMITMENT_SLOTReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for COMMITMENT_SLOTCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [62u8, 112u8, 110u8, 50u8];
+            const SIGNATURE: &'static str = "COMMITMENT_SLOT()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: COMMITMENT_SLOTReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: COMMITMENT_SLOTReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `EMPTY_COMMITMENT()` and selector `0xff2dbc98`.
+    ```solidity
+    function EMPTY_COMMITMENT() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct EMPTY_COMMITMENTCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`EMPTY_COMMITMENT()`](EMPTY_COMMITMENTCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct EMPTY_COMMITMENTReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<EMPTY_COMMITMENTCall> for UnderlyingRustTuple<'_> {
+                fn from(value: EMPTY_COMMITMENTCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for EMPTY_COMMITMENTCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<EMPTY_COMMITMENTReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: EMPTY_COMMITMENTReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for EMPTY_COMMITMENTReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for EMPTY_COMMITMENTCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 45u8, 188u8, 152u8];
+            const SIGNATURE: &'static str = "EMPTY_COMMITMENT()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: EMPTY_COMMITMENTReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: EMPTY_COMMITMENTReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `MAX_ORDER_DURATION()` and selector `0x981a160b`.
+    ```solidity
+    function MAX_ORDER_DURATION() external view returns (uint32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MAX_ORDER_DURATIONCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`MAX_ORDER_DURATION()`](MAX_ORDER_DURATIONCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MAX_ORDER_DURATIONReturn {
+        #[allow(missing_docs)]
+        pub _0: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MAX_ORDER_DURATIONCall> for UnderlyingRustTuple<'_> {
+                fn from(value: MAX_ORDER_DURATIONCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_ORDER_DURATIONCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u32,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MAX_ORDER_DURATIONReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: MAX_ORDER_DURATIONReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_ORDER_DURATIONReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for MAX_ORDER_DURATIONCall {
+            type Parameters<'a> = ();
+            type Return = u32;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [152u8, 26u8, 22u8, 11u8];
+            const SIGNATURE: &'static str = "MAX_ORDER_DURATION()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: MAX_ORDER_DURATIONReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: MAX_ORDER_DURATIONReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `NO_TRADING()` and selector `0x1c7de941`.
+    ```solidity
+    function NO_TRADING() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NO_TRADINGCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`NO_TRADING()`](NO_TRADINGCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NO_TRADINGReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<NO_TRADINGCall> for UnderlyingRustTuple<'_> {
+                fn from(value: NO_TRADINGCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for NO_TRADINGCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<NO_TRADINGReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: NO_TRADINGReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for NO_TRADINGReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for NO_TRADINGCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 125u8, 233u8, 65u8];
+            const SIGNATURE: &'static str = "NO_TRADING()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: NO_TRADINGReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: NO_TRADINGReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `commit(bytes32)` and selector `0xf14fcbc8`.
+    ```solidity
+    function commit(bytes32 orderHash) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct commitCall {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`commit(bytes32)`](commitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct commitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<commitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: commitCall) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<commitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: commitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl commitReturn {
+            fn _tokenize(&self) -> <commitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for commitCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = commitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [241u8, 79u8, 203u8, 200u8];
+            const SIGNATURE: &'static str = "commit(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                commitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `commitment()` and selector `0x1303a484`.
+    ```solidity
+    function commitment() external view returns (bytes32 value);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct commitmentCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`commitment()`](commitmentCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct commitmentReturn {
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<commitmentCall> for UnderlyingRustTuple<'_> {
+                fn from(value: commitmentCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitmentCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<commitmentReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: commitmentReturn) -> Self {
+                    (value.value,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitmentReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { value: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for commitmentCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [19u8, 3u8, 164u8, 132u8];
+            const SIGNATURE: &'static str = "commitment()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: commitmentReturn = r.into();
+                        r.value
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: commitmentReturn = r.into();
+                    r.value
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disableTrading()` and selector `0x17700f01`.
+    ```solidity
+    function disableTrading() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableTradingCall;
+    ///Container type for the return parameters of the
+    /// [`disableTrading()`](disableTradingCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableTradingReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableTradingCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableTradingCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableTradingReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableTradingReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableTradingReturn {
+            fn _tokenize(
+                &self,
+            ) -> <disableTradingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableTradingCall {
+            type Parameters<'a> = ();
+            type Return = disableTradingReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 112u8, 15u8, 1u8];
+            const SIGNATURE: &'static str = "disableTrading()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableTradingReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `enableTrading((uint256,address,bytes,bytes32))` and selector `0xc5f3d254`.
+    ```solidity
+    function enableTrading(ConstantProduct.TradingParams memory tradingParams) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableTradingCall {
+        #[allow(missing_docs)]
+        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`enableTrading((uint256,address,bytes,bytes32))`](enableTradingCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableTradingReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableTradingCall> for UnderlyingRustTuple<'_> {
+                fn from(value: enableTradingCall) -> Self {
+                    (value.tradingParams,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableTradingCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tradingParams: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableTradingReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: enableTradingReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableTradingReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl enableTradingReturn {
+            fn _tokenize(
+                &self,
+            ) -> <enableTradingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for enableTradingCall {
+            type Parameters<'a> = (ConstantProduct::TradingParams,);
+            type Return = enableTradingReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [197u8, 243u8, 210u8, 84u8];
+            const SIGNATURE: &'static str = "enableTrading((uint256,address,bytes,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
+                        &self.tradingParams,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                enableTradingReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTradeableOrder((uint256,address,bytes,bytes32))` and selector `0xe3e6f5b2`.
+    ```solidity
+    function getTradeableOrder(ConstantProduct.TradingParams memory tradingParams) external view returns (GPv2Order.Data memory order);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTradeableOrderCall {
+        #[allow(missing_docs)]
+        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTradeableOrder((uint256,address,bytes,
+    /// bytes32))`](getTradeableOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTradeableOrderReturn {
+        #[allow(missing_docs)]
+        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTradeableOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTradeableOrderCall) -> Self {
+                    (value.tradingParams,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tradingParams: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (GPv2Order::Data,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<GPv2Order::Data as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTradeableOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTradeableOrderReturn) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTradeableOrderCall {
+            type Parameters<'a> = (ConstantProduct::TradingParams,);
+            type Return = <GPv2Order::Data as alloy_sol_types::SolType>::RustType;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (GPv2Order::Data,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [227u8, 230u8, 245u8, 178u8];
+            const SIGNATURE: &'static str = "getTradeableOrder((uint256,address,bytes,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
+                        &self.tradingParams,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<GPv2Order::Data as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getTradeableOrderReturn = r.into();
+                        r.order
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getTradeableOrderReturn = r.into();
+                    r.order
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hash((uint256,address,bytes,bytes32))` and selector `0xb09aaaca`.
+    ```solidity
+    function hash(ConstantProduct.TradingParams memory tradingParams) external pure returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashCall {
+        #[allow(missing_docs)]
+        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hash((uint256,address,bytes,bytes32))`](hashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashCall) -> Self {
+                    (value.tradingParams,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tradingParams: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hashCall {
+            type Parameters<'a> = (ConstantProduct::TradingParams,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [176u8, 154u8, 170u8, 202u8];
+            const SIGNATURE: &'static str = "hash((uint256,address,bytes,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
+                        &self.tradingParams,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hashReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hashReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32 _hash, bytes memory signature) external view returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub _hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value._hash, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _hash: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `manager()` and selector `0x481c6a75`.
+    ```solidity
+    function manager() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct managerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`manager()`](managerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct managerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<managerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: managerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<managerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: managerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for managerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [72u8, 28u8, 106u8, 117u8];
+            const SIGNATURE: &'static str = "manager()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: managerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: managerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `solutionSettler()` and selector `0xe516715b`.
+    ```solidity
+    function solutionSettler() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct solutionSettlerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`solutionSettler()`](solutionSettlerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct solutionSettlerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<solutionSettlerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: solutionSettlerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<solutionSettlerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: solutionSettlerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for solutionSettlerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [229u8, 22u8, 113u8, 91u8];
+            const SIGNATURE: &'static str = "solutionSettler()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: solutionSettlerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: solutionSettlerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `solutionSettlerDomainSeparator()` and selector `0xd25e0cb6`.
+    ```solidity
+    function solutionSettlerDomainSeparator() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct solutionSettlerDomainSeparatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`solutionSettlerDomainSeparator()`](solutionSettlerDomainSeparatorCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct solutionSettlerDomainSeparatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<solutionSettlerDomainSeparatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: solutionSettlerDomainSeparatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerDomainSeparatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<solutionSettlerDomainSeparatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: solutionSettlerDomainSeparatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerDomainSeparatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for solutionSettlerDomainSeparatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 94u8, 12u8, 182u8];
+            const SIGNATURE: &'static str = "solutionSettlerDomainSeparator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: solutionSettlerDomainSeparatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: solutionSettlerDomainSeparatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token0()` and selector `0x0dfe1681`.
+    ```solidity
+    function token0() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token0()`](token0Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token0Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 254u8, 22u8, 129u8];
+            const SIGNATURE: &'static str = "token0()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token0Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token0Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token1()` and selector `0xd21220a7`.
+    ```solidity
+    function token1() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token1()`](token1Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token1Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 18u8, 32u8, 167u8];
+            const SIGNATURE: &'static str = "token1()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token1Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token1Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `tradingParamsHash()` and selector `0xeec50b97`.
+    ```solidity
+    function tradingParamsHash() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tradingParamsHashCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`tradingParamsHash()`](tradingParamsHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tradingParamsHashReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tradingParamsHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: tradingParamsHashCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tradingParamsHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tradingParamsHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: tradingParamsHashReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tradingParamsHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for tradingParamsHashCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [238u8, 197u8, 11u8, 151u8];
+            const SIGNATURE: &'static str = "tradingParamsHash()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: tradingParamsHashReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: tradingParamsHashReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `verify((uint256,address,bytes,bytes32),(address,address,address,uint256,uint256,uint32,bytes32,uint256,bytes32,bool,bytes32,bytes32))` and selector `0xa029a8d4`.
+    ```solidity
+    function verify(ConstantProduct.TradingParams memory tradingParams, GPv2Order.Data memory order) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct verifyCall {
+        #[allow(missing_docs)]
+        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`verify((uint256,address,bytes,bytes32),(address,address,address,
+    /// uint256,uint256,uint32,bytes32,uint256,bytes32,bool,bytes32,
+    /// bytes32))`](verifyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct verifyReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams, GPv2Order::Data);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+                <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<verifyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: verifyCall) -> Self {
+                    (value.tradingParams, value.order)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for verifyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tradingParams: tuple.0,
+                        order: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<verifyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: verifyReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for verifyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl verifyReturn {
+            fn _tokenize(&self) -> <verifyCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for verifyCall {
+            type Parameters<'a> = (ConstantProduct::TradingParams, GPv2Order::Data);
+            type Return = verifyReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [160u8, 41u8, 168u8, 212u8];
+            const SIGNATURE: &'static str = "verify((uint256,address,bytes,bytes32),(address,\
+                                             address,address,uint256,uint256,uint32,bytes32,\
+                                             uint256,bytes32,bool,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
+                        &self.tradingParams,
+                    ),
+                    <GPv2Order::Data as alloy_sol_types::SolType>::tokenize(&self.order),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                verifyReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`CowAmm`](self) function calls.
+    #[derive(Clone)]
+    pub enum CowAmmCalls {
+        #[allow(missing_docs)]
+        COMMITMENT_SLOT(COMMITMENT_SLOTCall),
+        #[allow(missing_docs)]
+        EMPTY_COMMITMENT(EMPTY_COMMITMENTCall),
+        #[allow(missing_docs)]
+        MAX_ORDER_DURATION(MAX_ORDER_DURATIONCall),
+        #[allow(missing_docs)]
+        NO_TRADING(NO_TRADINGCall),
+        #[allow(missing_docs)]
+        commit(commitCall),
+        #[allow(missing_docs)]
+        commitment(commitmentCall),
+        #[allow(missing_docs)]
+        disableTrading(disableTradingCall),
+        #[allow(missing_docs)]
+        enableTrading(enableTradingCall),
+        #[allow(missing_docs)]
+        getTradeableOrder(getTradeableOrderCall),
+        #[allow(missing_docs)]
+        hash(hashCall),
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+        #[allow(missing_docs)]
+        manager(managerCall),
+        #[allow(missing_docs)]
+        solutionSettler(solutionSettlerCall),
+        #[allow(missing_docs)]
+        solutionSettlerDomainSeparator(solutionSettlerDomainSeparatorCall),
+        #[allow(missing_docs)]
+        token0(token0Call),
+        #[allow(missing_docs)]
+        token1(token1Call),
+        #[allow(missing_docs)]
+        tradingParamsHash(tradingParamsHashCall),
+        #[allow(missing_docs)]
+        verify(verifyCall),
+    }
+    impl CowAmmCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [13u8, 254u8, 22u8, 129u8],
+            [19u8, 3u8, 164u8, 132u8],
+            [22u8, 38u8, 186u8, 126u8],
+            [23u8, 112u8, 15u8, 1u8],
+            [28u8, 125u8, 233u8, 65u8],
+            [62u8, 112u8, 110u8, 50u8],
+            [72u8, 28u8, 106u8, 117u8],
+            [152u8, 26u8, 22u8, 11u8],
+            [160u8, 41u8, 168u8, 212u8],
+            [176u8, 154u8, 170u8, 202u8],
+            [197u8, 243u8, 210u8, 84u8],
+            [210u8, 18u8, 32u8, 167u8],
+            [210u8, 94u8, 12u8, 182u8],
+            [227u8, 230u8, 245u8, 178u8],
+            [229u8, 22u8, 113u8, 91u8],
+            [238u8, 197u8, 11u8, 151u8],
+            [241u8, 79u8, 203u8, 200u8],
+            [255u8, 45u8, 188u8, 152u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <commitmentCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableTradingCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <NO_TRADINGCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <managerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <verifyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <enableTradingCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTradeableOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <solutionSettlerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <tradingParamsHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <commitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(token0),
+            ::core::stringify!(commitment),
+            ::core::stringify!(isValidSignature),
+            ::core::stringify!(disableTrading),
+            ::core::stringify!(NO_TRADING),
+            ::core::stringify!(COMMITMENT_SLOT),
+            ::core::stringify!(manager),
+            ::core::stringify!(MAX_ORDER_DURATION),
+            ::core::stringify!(verify),
+            ::core::stringify!(hash),
+            ::core::stringify!(enableTrading),
+            ::core::stringify!(token1),
+            ::core::stringify!(solutionSettlerDomainSeparator),
+            ::core::stringify!(getTradeableOrder),
+            ::core::stringify!(solutionSettler),
+            ::core::stringify!(tradingParamsHash),
+            ::core::stringify!(commit),
+            ::core::stringify!(EMPTY_COMMITMENT),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmCalls {
+        const COUNT: usize = 18usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowAmmCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::COMMITMENT_SLOT(_) => {
+                    <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::EMPTY_COMMITMENT(_) => {
+                    <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::MAX_ORDER_DURATION(_) => {
+                    <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::NO_TRADING(_) => <NO_TRADINGCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::commit(_) => <commitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::commitment(_) => <commitmentCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disableTrading(_) => {
+                    <disableTradingCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::enableTrading(_) => <enableTradingCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getTradeableOrder(_) => {
+                    <getTradeableOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::hash(_) => <hashCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::manager(_) => <managerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::solutionSettler(_) => {
+                    <solutionSettlerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::solutionSettlerDomainSeparator(_) => {
+                    <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::tradingParamsHash(_) => {
+                    <tradingParamsHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::verify(_) => <verifyCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CowAmmCalls>] = &[
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn commitment(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <commitmentCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::commitment)
+                    }
+                    commitment
+                },
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn disableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::disableTrading)
+                    }
+                    disableTrading
+                },
+                {
+                    fn NO_TRADING(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::NO_TRADING)
+                    }
+                    NO_TRADING
+                },
+                {
+                    fn COMMITMENT_SLOT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::COMMITMENT_SLOT)
+                    }
+                    COMMITMENT_SLOT
+                },
+                {
+                    fn manager(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <managerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::manager)
+                    }
+                    manager
+                },
+                {
+                    fn MAX_ORDER_DURATION(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::MAX_ORDER_DURATION)
+                    }
+                    MAX_ORDER_DURATION
+                },
+                {
+                    fn verify(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <verifyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::verify)
+                    }
+                    verify
+                },
+                {
+                    fn hash(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <hashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::hash)
+                    }
+                    hash
+                },
+                {
+                    fn enableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <enableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::enableTrading)
+                    }
+                    enableTrading
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn solutionSettlerDomainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(CowAmmCalls::solutionSettlerDomainSeparator)
+                    }
+                    solutionSettlerDomainSeparator
+                },
+                {
+                    fn getTradeableOrder(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::getTradeableOrder)
+                    }
+                    getTradeableOrder
+                },
+                {
+                    fn solutionSettler(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <solutionSettlerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::solutionSettler)
+                    }
+                    solutionSettler
+                },
+                {
+                    fn tradingParamsHash(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::tradingParamsHash)
+                    }
+                    tradingParamsHash
+                },
+                {
+                    fn commit(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <commitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::commit)
+                    }
+                    commit
+                },
+                {
+                    fn EMPTY_COMMITMENT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmCalls::EMPTY_COMMITMENT)
+                    }
+                    EMPTY_COMMITMENT
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CowAmmCalls>] = &[
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn commitment(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <commitmentCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::commitment)
+                    }
+                    commitment
+                },
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn disableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmCalls::disableTrading)
+                    }
+                    disableTrading
+                },
+                {
+                    fn NO_TRADING(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::NO_TRADING)
+                    }
+                    NO_TRADING
+                },
+                {
+                    fn COMMITMENT_SLOT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmCalls::COMMITMENT_SLOT)
+                    }
+                    COMMITMENT_SLOT
+                },
+                {
+                    fn manager(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <managerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::manager)
+                    }
+                    manager
+                },
+                {
+                    fn MAX_ORDER_DURATION(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmCalls::MAX_ORDER_DURATION)
+                    }
+                    MAX_ORDER_DURATION
+                },
+                {
+                    fn verify(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <verifyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::verify)
+                    }
+                    verify
+                },
+                {
+                    fn hash(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <hashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::hash)
+                    }
+                    hash
+                },
+                {
+                    fn enableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <enableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmCalls::enableTrading)
+                    }
+                    enableTrading
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn solutionSettlerDomainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmCalls::solutionSettlerDomainSeparator)
+                    }
+                    solutionSettlerDomainSeparator
+                },
+                {
+                    fn getTradeableOrder(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmCalls::getTradeableOrder)
+                    }
+                    getTradeableOrder
+                },
+                {
+                    fn solutionSettler(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <solutionSettlerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmCalls::solutionSettler)
+                    }
+                    solutionSettler
+                },
+                {
+                    fn tradingParamsHash(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmCalls::tradingParamsHash)
+                    }
+                    tradingParamsHash
+                },
+                {
+                    fn commit(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <commitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmCalls::commit)
+                    }
+                    commit
+                },
+                {
+                    fn EMPTY_COMMITMENT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
+                        <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmCalls::EMPTY_COMMITMENT)
+                    }
+                    EMPTY_COMMITMENT
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::COMMITMENT_SLOT(inner) => {
+                    <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::EMPTY_COMMITMENT(inner) => {
+                    <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::MAX_ORDER_DURATION(inner) => {
+                    <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::NO_TRADING(inner) => {
+                    <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::commit(inner) => {
+                    <commitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::commitment(inner) => {
+                    <commitmentCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disableTrading(inner) => {
+                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::enableTrading(inner) => {
+                    <enableTradingCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTradeableOrder(inner) => {
+                    <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::hash(inner) => {
+                    <hashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::manager(inner) => {
+                    <managerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::solutionSettler(inner) => {
+                    <solutionSettlerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::solutionSettlerDomainSeparator(inner) => {
+                    <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::tradingParamsHash(inner) => {
+                    <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::verify(inner) => {
+                    <verifyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::COMMITMENT_SLOT(inner) => {
+                    <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::EMPTY_COMMITMENT(inner) => {
+                    <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::MAX_ORDER_DURATION(inner) => {
+                    <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::NO_TRADING(inner) => {
+                    <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::commit(inner) => {
+                    <commitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::commitment(inner) => {
+                    <commitmentCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disableTrading(inner) => {
+                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::enableTrading(inner) => {
+                    <enableTradingCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getTradeableOrder(inner) => {
+                    <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::hash(inner) => {
+                    <hashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::manager(inner) => {
+                    <managerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::solutionSettler(inner) => {
+                    <solutionSettlerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::solutionSettlerDomainSeparator(inner) => {
+                    <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::tradingParamsHash(inner) => {
+                    <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::verify(inner) => {
+                    <verifyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowAmm`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowAmmErrors {
+        #[allow(missing_docs)]
+        CommitOutsideOfSettlement(CommitOutsideOfSettlement),
+        #[allow(missing_docs)]
+        OnlyManagerCanCall(OnlyManagerCanCall),
+        #[allow(missing_docs)]
+        OrderDoesNotMatchCommitmentHash(OrderDoesNotMatchCommitmentHash),
+        #[allow(missing_docs)]
+        OrderDoesNotMatchDefaultTradeableOrder(OrderDoesNotMatchDefaultTradeableOrder),
+        #[allow(missing_docs)]
+        OrderDoesNotMatchMessageHash(OrderDoesNotMatchMessageHash),
+        #[allow(missing_docs)]
+        OrderNotValid(OrderNotValid),
+        #[allow(missing_docs)]
+        PollTryAtBlock(PollTryAtBlock),
+        #[allow(missing_docs)]
+        TradingParamsDoNotMatchHash(TradingParamsDoNotMatchHash),
+    }
+    impl CowAmmErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [31u8, 232u8, 80u8, 110u8],
+            [89u8, 63u8, 202u8, 205u8],
+            [191u8, 132u8, 137u8, 119u8],
+            [200u8, 252u8, 39u8, 37u8],
+            [217u8, 255u8, 36u8, 199u8],
+            [218u8, 251u8, 221u8, 31u8],
+            [241u8, 166u8, 120u8, 144u8],
+            [248u8, 125u8, 13u8, 22u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <PollTryAtBlock as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderDoesNotMatchMessageHash as alloy_sol_types::SolError>::SIGNATURE,
+            <CommitOutsideOfSettlement as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderNotValid as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderDoesNotMatchDefaultTradeableOrder as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderDoesNotMatchCommitmentHash as alloy_sol_types::SolError>::SIGNATURE,
+            <TradingParamsDoNotMatchHash as alloy_sol_types::SolError>::SIGNATURE,
+            <OnlyManagerCanCall as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(PollTryAtBlock),
+            ::core::stringify!(OrderDoesNotMatchMessageHash),
+            ::core::stringify!(CommitOutsideOfSettlement),
+            ::core::stringify!(OrderNotValid),
+            ::core::stringify!(OrderDoesNotMatchDefaultTradeableOrder),
+            ::core::stringify!(OrderDoesNotMatchCommitmentHash),
+            ::core::stringify!(TradingParamsDoNotMatchHash),
+            ::core::stringify!(OnlyManagerCanCall),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmErrors {
+        const COUNT: usize = 8usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowAmmErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::CommitOutsideOfSettlement(_) => {
+                    <CommitOutsideOfSettlement as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OnlyManagerCanCall(_) => {
+                    <OnlyManagerCanCall as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderDoesNotMatchCommitmentHash(_) => {
+                    <OrderDoesNotMatchCommitmentHash as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderDoesNotMatchDefaultTradeableOrder(_) => {
+                    <OrderDoesNotMatchDefaultTradeableOrder as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderDoesNotMatchMessageHash(_) => {
+                    <OrderDoesNotMatchMessageHash as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderNotValid(_) => <OrderNotValid as alloy_sol_types::SolError>::SELECTOR,
+                Self::PollTryAtBlock(_) => <PollTryAtBlock as alloy_sol_types::SolError>::SELECTOR,
+                Self::TradingParamsDoNotMatchHash(_) => {
+                    <TradingParamsDoNotMatchHash as alloy_sol_types::SolError>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CowAmmErrors>] = &[
+                {
+                    fn PollTryAtBlock(data: &[u8]) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <PollTryAtBlock as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmErrors::PollTryAtBlock)
+                    }
+                    PollTryAtBlock
+                },
+                {
+                    fn OrderDoesNotMatchMessageHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderDoesNotMatchMessageHash as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CowAmmErrors::OrderDoesNotMatchMessageHash)
+                    }
+                    OrderDoesNotMatchMessageHash
+                },
+                {
+                    fn CommitOutsideOfSettlement(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <CommitOutsideOfSettlement as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CowAmmErrors::CommitOutsideOfSettlement)
+                    }
+                    CommitOutsideOfSettlement
+                },
+                {
+                    fn OrderNotValid(data: &[u8]) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderNotValid as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmErrors::OrderNotValid)
+                    }
+                    OrderNotValid
+                },
+                {
+                    fn OrderDoesNotMatchDefaultTradeableOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderDoesNotMatchDefaultTradeableOrder as alloy_sol_types::SolError>::abi_decode_raw(
+                                data,
+                            )
+                            .map(CowAmmErrors::OrderDoesNotMatchDefaultTradeableOrder)
+                    }
+                    OrderDoesNotMatchDefaultTradeableOrder
+                },
+                {
+                    fn OrderDoesNotMatchCommitmentHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderDoesNotMatchCommitmentHash as alloy_sol_types::SolError>::abi_decode_raw(
+                                data,
+                            )
+                            .map(CowAmmErrors::OrderDoesNotMatchCommitmentHash)
+                    }
+                    OrderDoesNotMatchCommitmentHash
+                },
+                {
+                    fn TradingParamsDoNotMatchHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <TradingParamsDoNotMatchHash as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CowAmmErrors::TradingParamsDoNotMatchHash)
+                    }
+                    TradingParamsDoNotMatchHash
+                },
+                {
+                    fn OnlyManagerCanCall(data: &[u8]) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OnlyManagerCanCall as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmErrors::OnlyManagerCanCall)
+                    }
+                    OnlyManagerCanCall
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CowAmmErrors>] = &[
+                {
+                    fn PollTryAtBlock(data: &[u8]) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <PollTryAtBlock as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowAmmErrors::PollTryAtBlock)
+                    }
+                    PollTryAtBlock
+                },
+                {
+                    fn OrderDoesNotMatchMessageHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderDoesNotMatchMessageHash as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmErrors::OrderDoesNotMatchMessageHash)
+                    }
+                    OrderDoesNotMatchMessageHash
+                },
+                {
+                    fn CommitOutsideOfSettlement(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <CommitOutsideOfSettlement as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmErrors::CommitOutsideOfSettlement)
+                    }
+                    CommitOutsideOfSettlement
+                },
+                {
+                    fn OrderNotValid(data: &[u8]) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderNotValid as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowAmmErrors::OrderNotValid)
+                    }
+                    OrderNotValid
+                },
+                {
+                    fn OrderDoesNotMatchDefaultTradeableOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderDoesNotMatchDefaultTradeableOrder as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmErrors::OrderDoesNotMatchDefaultTradeableOrder)
+                    }
+                    OrderDoesNotMatchDefaultTradeableOrder
+                },
+                {
+                    fn OrderDoesNotMatchCommitmentHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OrderDoesNotMatchCommitmentHash as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmErrors::OrderDoesNotMatchCommitmentHash)
+                    }
+                    OrderDoesNotMatchCommitmentHash
+                },
+                {
+                    fn TradingParamsDoNotMatchHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <TradingParamsDoNotMatchHash as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmErrors::TradingParamsDoNotMatchHash)
+                    }
+                    TradingParamsDoNotMatchHash
+                },
+                {
+                    fn OnlyManagerCanCall(data: &[u8]) -> alloy_sol_types::Result<CowAmmErrors> {
+                        <OnlyManagerCanCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmErrors::OnlyManagerCanCall)
+                    }
+                    OnlyManagerCanCall
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::CommitOutsideOfSettlement(inner) => {
+                    <CommitOutsideOfSettlement as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::OnlyManagerCanCall(inner) => {
+                    <OnlyManagerCanCall as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::OrderDoesNotMatchCommitmentHash(inner) => {
+                    <OrderDoesNotMatchCommitmentHash as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::OrderDoesNotMatchDefaultTradeableOrder(inner) => {
+                    <OrderDoesNotMatchDefaultTradeableOrder as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::OrderDoesNotMatchMessageHash(inner) => {
+                    <OrderDoesNotMatchMessageHash as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::OrderNotValid(inner) => {
+                    <OrderNotValid as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::PollTryAtBlock(inner) => {
+                    <PollTryAtBlock as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::TradingParamsDoNotMatchHash(inner) => {
+                    <TradingParamsDoNotMatchHash as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::CommitOutsideOfSettlement(inner) => {
+                    <CommitOutsideOfSettlement as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::OnlyManagerCanCall(inner) => {
+                    <OnlyManagerCanCall as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::OrderDoesNotMatchCommitmentHash(inner) => {
+                    <OrderDoesNotMatchCommitmentHash as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::OrderDoesNotMatchDefaultTradeableOrder(inner) => {
+                    <OrderDoesNotMatchDefaultTradeableOrder as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::OrderDoesNotMatchMessageHash(inner) => {
+                    <OrderDoesNotMatchMessageHash as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::OrderNotValid(inner) => {
+                    <OrderNotValid as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::PollTryAtBlock(inner) => {
+                    <PollTryAtBlock as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::TradingParamsDoNotMatchHash(inner) => {
+                    <TradingParamsDoNotMatchHash as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowAmm`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowAmmEvents {
+        #[allow(missing_docs)]
+        TradingDisabled(TradingDisabled),
+        #[allow(missing_docs)]
+        TradingEnabled(TradingEnabled),
+    }
+    impl CowAmmEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                81u8, 14u8, 74u8, 79u8, 118u8, 144u8, 124u8, 45u8, 97u8, 88u8, 179u8, 67u8, 247u8,
+                196u8, 242u8, 245u8, 151u8, 223u8, 56u8, 91u8, 114u8, 124u8, 38u8, 233u8, 239u8,
+                144u8, 231u8, 80u8, 147u8, 172u8, 225u8, 154u8,
+            ],
+            [
+                188u8, 184u8, 184u8, 251u8, 222u8, 168u8, 170u8, 109u8, 196u8, 174u8, 65u8, 33u8,
+                62u8, 77u8, 168u8, 30u8, 96u8, 90u8, 61u8, 26u8, 86u8, 237u8, 133u8, 27u8, 147u8,
+                85u8, 24u8, 35u8, 33u8, 192u8, 145u8, 144u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <TradingEnabled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TradingDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(TradingEnabled),
+            ::core::stringify!(TradingDisabled),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CowAmmEvents {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "CowAmmEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<TradingDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TradingDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TradingDisabled)
+                }
+                Some(<TradingEnabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TradingEnabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TradingEnabled)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CowAmmEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::TradingDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TradingEnabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::TradingDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TradingEnabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowAmm`](self) contract instance.
+
+    See the [wrapper's documentation](`CowAmmInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowAmmInstance<P, N> {
+        CowAmmInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _solutionSettler: alloy_sol_types::private::Address,
+        _token0: alloy_sol_types::private::Address,
+        _token1: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<CowAmmInstance<P, N>>> {
+        CowAmmInstance::<P, N>::deploy(__provider, _solutionSettler, _token0, _token1)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _solutionSettler: alloy_sol_types::private::Address,
+        _token0: alloy_sol_types::private::Address,
+        _token1: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CowAmmInstance::<P, N>::deploy_builder(__provider, _solutionSettler, _token0, _token1)
+    }
+    /**A [`CowAmm`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowAmm`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowAmmInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowAmmInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowAmmInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowAmm`](self) contract instance.
+
+        See the [wrapper's documentation](`CowAmmInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _solutionSettler: alloy_sol_types::private::Address,
+            _token0: alloy_sol_types::private::Address,
+            _token1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<CowAmmInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _solutionSettler, _token0, _token1);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _solutionSettler: alloy_sol_types::private::Address,
+            _token0: alloy_sol_types::private::Address,
+            _token1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        _solutionSettler,
+                        _token0,
+                        _token1,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowAmmInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowAmmInstance<P, N> {
+            CowAmmInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`COMMITMENT_SLOT`] function.
+        pub fn COMMITMENT_SLOT(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, COMMITMENT_SLOTCall, N> {
+            self.call_builder(&COMMITMENT_SLOTCall)
+        }
+
+        ///Creates a new call builder for the [`EMPTY_COMMITMENT`] function.
+        pub fn EMPTY_COMMITMENT(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, EMPTY_COMMITMENTCall, N> {
+            self.call_builder(&EMPTY_COMMITMENTCall)
+        }
+
+        ///Creates a new call builder for the [`MAX_ORDER_DURATION`] function.
+        pub fn MAX_ORDER_DURATION(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, MAX_ORDER_DURATIONCall, N> {
+            self.call_builder(&MAX_ORDER_DURATIONCall)
+        }
+
+        ///Creates a new call builder for the [`NO_TRADING`] function.
+        pub fn NO_TRADING(&self) -> alloy_contract::SolCallBuilder<&P, NO_TRADINGCall, N> {
+            self.call_builder(&NO_TRADINGCall)
+        }
+
+        ///Creates a new call builder for the [`commit`] function.
+        pub fn commit(
+            &self,
+            orderHash: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, commitCall, N> {
+            self.call_builder(&commitCall { orderHash })
+        }
+
+        ///Creates a new call builder for the [`commitment`] function.
+        pub fn commitment(&self) -> alloy_contract::SolCallBuilder<&P, commitmentCall, N> {
+            self.call_builder(&commitmentCall)
+        }
+
+        ///Creates a new call builder for the [`disableTrading`] function.
+        pub fn disableTrading(&self) -> alloy_contract::SolCallBuilder<&P, disableTradingCall, N> {
+            self.call_builder(&disableTradingCall)
+        }
+
+        ///Creates a new call builder for the [`enableTrading`] function.
+        pub fn enableTrading(
+            &self,
+            tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, enableTradingCall, N> {
+            self.call_builder(&enableTradingCall { tradingParams })
+        }
+
+        ///Creates a new call builder for the [`getTradeableOrder`] function.
+        pub fn getTradeableOrder(
+            &self,
+            tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getTradeableOrderCall, N> {
+            self.call_builder(&getTradeableOrderCall { tradingParams })
+        }
+
+        ///Creates a new call builder for the [`hash`] function.
+        pub fn hash(
+            &self,
+            tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, hashCall, N> {
+            self.call_builder(&hashCall { tradingParams })
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            _hash: alloy_sol_types::private::FixedBytes<32>,
+            signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { _hash, signature })
+        }
+
+        ///Creates a new call builder for the [`manager`] function.
+        pub fn manager(&self) -> alloy_contract::SolCallBuilder<&P, managerCall, N> {
+            self.call_builder(&managerCall)
+        }
+
+        ///Creates a new call builder for the [`solutionSettler`] function.
+        pub fn solutionSettler(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, solutionSettlerCall, N> {
+            self.call_builder(&solutionSettlerCall)
+        }
+
+        ///Creates a new call builder for the
+        /// [`solutionSettlerDomainSeparator`] function.
+        pub fn solutionSettlerDomainSeparator(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, solutionSettlerDomainSeparatorCall, N> {
+            self.call_builder(&solutionSettlerDomainSeparatorCall)
+        }
+
+        ///Creates a new call builder for the [`token0`] function.
+        pub fn token0(&self) -> alloy_contract::SolCallBuilder<&P, token0Call, N> {
+            self.call_builder(&token0Call)
+        }
+
+        ///Creates a new call builder for the [`token1`] function.
+        pub fn token1(&self) -> alloy_contract::SolCallBuilder<&P, token1Call, N> {
+            self.call_builder(&token1Call)
+        }
+
+        ///Creates a new call builder for the [`tradingParamsHash`] function.
+        pub fn tradingParamsHash(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, tradingParamsHashCall, N> {
+            self.call_builder(&tradingParamsHashCall)
+        }
+
+        ///Creates a new call builder for the [`verify`] function.
+        pub fn verify(
+            &self,
+            tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+            order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, verifyCall, N> {
+            self.call_builder(&verifyCall {
+                tradingParams,
+                order,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`TradingDisabled`] event.
+        pub fn TradingDisabled_filter(&self) -> alloy_contract::Event<&P, TradingDisabled, N> {
+            self.event_filter::<TradingDisabled>()
+        }
+
+        ///Creates a new event filter for the [`TradingEnabled`] event.
+        pub fn TradingEnabled_filter(&self) -> alloy_contract::Event<&P, TradingEnabled, N> {
+            self.event_filter::<TradingEnabled>()
+        }
+    }
+}
+pub type Instance = CowAmm::CowAmmInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/cowammconstantproductfactory/Cargo.toml b/contracts/generated/contracts-generated/cowammconstantproductfactory/Cargo.toml
new file mode 100644
index 0000000000..f5e1521cc8
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammconstantproductfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowammconstantproductfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs b/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs
new file mode 100644
index 0000000000..2806a011e2
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs
@@ -0,0 +1,4729 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Order {
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Order {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub kind: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub partiallyFillable: bool,
+        #[allow(missing_docs)]
+        pub sellTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub buyTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            bool,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.sellToken,
+                    value.buyToken,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.validTo,
+                    value.appData,
+                    value.feeAmount,
+                    value.kind,
+                    value.partiallyFillable,
+                    value.sellTokenBalance,
+                    value.buyTokenBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sellToken: tuple.0,
+                    buyToken: tuple.1,
+                    receiver: tuple.2,
+                    sellAmount: tuple.3,
+                    buyAmount: tuple.4,
+                    validTo: tuple.5,
+                    appData: tuple.6,
+                    feeAmount: tuple.7,
+                    kind: tuple.8,
+                    partiallyFillable: tuple.9,
+                    sellTokenBalance: tuple.10,
+                    buyTokenBalance: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.partiallyFillable,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenBalance),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenBalance),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address sellToken,address buyToken,address receiver,uint256 \
+                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
+                     feeAmount,bytes32 kind,bool partiallyFillable,bytes32 \
+                     sellTokenBalance,bytes32 buyTokenBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.partiallyFillable,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellTokenBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyTokenBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.kind)
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.partiallyFillable,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellTokenBalance,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyTokenBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.partiallyFillable,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellTokenBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyTokenBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2OrderInstance<P, N> {
+        GPv2OrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Order`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Order`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2OrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2OrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2OrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2OrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2OrderInstance<P, N> {
+            GPv2OrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IConditionalOrder {
+    struct ConditionalOrderParams { address handler; bytes32 salt; bytes staticInput; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IConditionalOrder {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct ConditionalOrderParams { address handler; bytes32 salt; bytes staticInput; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ConditionalOrderParams {
+        #[allow(missing_docs)]
+        pub handler: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub salt: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub staticInput: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ConditionalOrderParams> for UnderlyingRustTuple<'_> {
+            fn from(value: ConditionalOrderParams) -> Self {
+                (value.handler, value.salt, value.staticInput)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ConditionalOrderParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    handler: tuple.0,
+                    salt: tuple.1,
+                    staticInput: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for ConditionalOrderParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for ConditionalOrderParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.handler,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.staticInput,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ConditionalOrderParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for ConditionalOrderParams {
+            const NAME: &'static str = "ConditionalOrderParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "ConditionalOrderParams(address handler,bytes32 salt,bytes staticInput)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.handler,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.staticInput,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ConditionalOrderParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.handler,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.staticInput,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.handler,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.salt,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.staticInput,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IConditionalOrder`](self) contract instance.
+
+    See the [wrapper's documentation](`IConditionalOrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IConditionalOrderInstance<P, N> {
+        IConditionalOrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IConditionalOrder`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IConditionalOrder`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IConditionalOrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IConditionalOrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IConditionalOrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IConditionalOrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IConditionalOrder`](self) contract instance.
+
+        See the [wrapper's documentation](`IConditionalOrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IConditionalOrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IConditionalOrderInstance<P, N> {
+            IConditionalOrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IConditionalOrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IConditionalOrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library GPv2Order {
+    struct Data {
+        address sellToken;
+        address buyToken;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        uint32 validTo;
+        bytes32 appData;
+        uint256 feeAmount;
+        bytes32 kind;
+        bool partiallyFillable;
+        bytes32 sellTokenBalance;
+        bytes32 buyTokenBalance;
+    }
+}
+
+library IConditionalOrder {
+    struct ConditionalOrderParams {
+        address handler;
+        bytes32 salt;
+        bytes staticInput;
+    }
+}
+
+interface CowAmmConstantProductFactory {
+    error OnlyOwnerCanCall(address owner);
+    error OrderNotValid(string);
+
+    event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params);
+    event Deployed(address indexed amm, address indexed owner, address token0, address token1);
+    event TradingDisabled(address indexed amm);
+
+    constructor(address _settler);
+
+    function ammDeterministicAddress(address ammOwner, address token0, address token1) external view returns (address);
+    function create(address token0, uint256 amount0, address token1, uint256 amount1, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external returns (address amm);
+    function deposit(address amm, uint256 amount0, uint256 amount1) external;
+    function disableTrading(address amm) external;
+    function getTradeableOrderWithSignature(address amm, IConditionalOrder.ConditionalOrderParams memory params, bytes memory, bytes32[] memory) external view returns (GPv2Order.Data memory order, bytes memory signature);
+    function owner(address) external view returns (address);
+    function settler() external view returns (address);
+    function updateParameters(address amm, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external;
+    function withdraw(address amm, uint256 amount0, uint256 amount1) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_settler",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "ammDeterministicAddress",
+    "inputs": [
+      {
+        "name": "ammOwner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "token0",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "token0",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minTradedToken0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "priceOracle",
+        "type": "address",
+        "internalType": "contract IPriceOracle"
+      },
+      {
+        "name": "priceOracleData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "appData",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "deposit",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "disableTrading",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getTradeableOrderWithSignature",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IConditionalOrder.ConditionalOrderParams",
+        "components": [
+          {
+            "name": "handler",
+            "type": "address",
+            "internalType": "contract IConditionalOrder"
+          },
+          {
+            "name": "salt",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "staticInput",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct GPv2Order.Data",
+        "components": [
+          {
+            "name": "sellToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "kind",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "sellTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "buyTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "settler",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "updateParameters",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "minTradedToken0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "priceOracle",
+        "type": "address",
+        "internalType": "contract IPriceOracle"
+      },
+      {
+        "name": "priceOracleData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "appData",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "withdraw",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "ConditionalOrderCreated",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "params",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct IConditionalOrder.ConditionalOrderParams",
+        "components": [
+          {
+            "name": "handler",
+            "type": "address",
+            "internalType": "contract IConditionalOrder"
+          },
+          {
+            "name": "salt",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "staticInput",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Deployed",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token0",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TradingDisabled",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "OnlyOwnerCanCall",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OrderNotValid",
+    "inputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowAmmConstantProductFactory {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xA0`@R4\x80\x15`\x0EW_\x80\xFD[P`@QaA\xB38\x03\x80aA\xB3\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW_\x80\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W_\x80\xFD[\x93\x92PPPV[`\x80QaA'a\0\x8C_9_\x81\x81a\x01\x89\x01R\x81\x81a\x02\xA8\x01Ra\x08\xC4\x01RaA'_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x9FW_5`\xE0\x1C\x80c7\xEB\xDFP\x11a\0rW\x80cfn\x1B9\x11a\0XW\x80cfn\x1B9\x14a\x01OW\x80c\xAB\"\x1Av\x14a\x01\x84W\x80c\xB5\xC5\xF6r\x14a\x01\xABW_\x80\xFD[\x80c7\xEB\xDFP\x14a\x01)W\x80c[]\x9E\xE6\x14a\x01<W_\x80\xFD[\x80c\x0E\xFEj\x8B\x14a\0\xA3W\x80c\"\xB1U\xC6\x14a\0\xB8W\x80c&\xE0\xA1\x96\x14a\0\xF5W\x80c'\x91\x05e\x14a\x01\x16W[_\x80\xFD[a\0\xB6a\0\xB16`\x04a\x11\xEAV[a\x01\xBEV[\0[a\0\xCBa\0\xC66`\x04a\x12aV[a\x02\xA3V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\x08a\x01\x036`\x04a\x12\xFBV[a\x04_V[`@Qa\0\xEC\x92\x91\x90a\x14\xFDV[a\0\xB6a\x01$6`\x04a\x15'V[a\x07\x97V[a\0\xCBa\x0176`\x04a\x15IV[a\x08/V[a\0\xB6a\x01J6`\x04a\x15\x91V[a\n\x01V[a\0\xCBa\x01]6`\x04a\x15'V[_` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\0\xCB\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB6a\x01\xB96`\x04a\x11\xEAV[a\x0B\x17V[a\x02O3\x84\x84\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x021\x91\x90a\x16\x17V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x0CFV[a\x02\x9E3\x84\x83\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPV[_3\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8B`@Qa\x02\xD5\x90a\x11\xB9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x81R\x91\x83\x16` \x83\x01R\x90\x91\x16`@\x82\x01R``\x01\x81\x90`@Q\x80\x91\x03\x90_\xF5\x90P\x80\x15\x80\x15a\x03\x1FW=_\x80>=_\xFD[P`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16\x82R\x8C\x81\x16` \x83\x01R\x92\x94P\x82\x84\x16\x92\x85\x16\x91\x7Fg\x07%[,\\\xA8\x12 \xB2\xF3\xE4\x08\xA2i\xCB\x83\xBA\xA6\xAA~^7\xAA\x17V\x88:l\xDF\x06\xF1\x91\x01`@Q\x80\x91\x03\x90\xA3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16_\x90\x81R` \x81\x90R`@\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x83\x16\x91\x90\x91\x17\x90Ua\x03\xD8\x82\x8B\x8Aa\x01\xBEV[_`@Q\x80`\x80\x01`@R\x80\x89\x81R` \x01\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x85\x90R\x90Pa\x04P\x83\x82a\x0C\xDBV[PP\x99\x98PPPPPPPPPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``0a\x04\xCF` \x89\x01\x89a\x15'V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x05QW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Fcan only handle own orders\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x05_`@\x89\x01\x89a\x162V[\x81\x01\x90a\x05l\x91\x90a\x17\\V[\x90P\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xEE\xC5\x0B\x97`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDB\x91\x90a\x18ZV[`@Q\x7F\xB0\x9A\xAA\xCA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x90c\xB0\x9A\xAA\xCA\x90a\x06-\x90\x85\x90`\x04\x01a\x18\xC3V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06HW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06l\x91\x90a\x18ZV[\x14a\x06\xD3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Finvalid trading parameters\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05HV[`@Q\x7F\xE3\xE6\xF5\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x90c\xE3\xE6\xF5\xB2\x90a\x07%\x90\x84\x90`\x04\x01a\x18\xC3V[a\x01\x80`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a\x18\xF7V[\x92P\x82\x81`@Q` \x01a\x07z\x92\x91\x90a\x19\xB3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x96P\x96\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16_\x90\x81R` \x81\x90R`@\x90 T\x82\x91\x163\x14a\x08\"Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x08+\x82a\x0E\x05V[PPV[_\x80\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16`@Qa\x08y` \x82\x01a\x11\xB9V[\x81\x81\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x01\x83R`\x1F\x90\x91\x01\x16`@\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16` \x84\x01R\x80\x8B\x16\x91\x83\x01\x91\x90\x91R\x88\x16``\x82\x01R`\x80\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\t:\x92\x91` \x01a\x19\xEBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\t\xC2\x94\x93\x92\x91\x90\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\x90\x94\x16\x84R``\x92\x90\x92\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x01\x84\x01R`\x15\x83\x01R`5\x82\x01R`U\x01\x90V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 \x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x87\x16_\x90\x81R` \x81\x90R`@\x90 T\x87\x91\x163\x14a\n\x8CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[_`@Q\x80`\x80\x01`@R\x80\x88\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x86\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x84\x90R\x90Pa\x0B\x03\x88a\x0E\x05V[a\x0B\r\x88\x82a\x0C\xDBV[PPPPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16_\x90\x81R` \x81\x90R`@\x90 T\x84\x91\x163\x14a\x0B\xA2Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x0B\xF1\x843\x85\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[a\x0C@\x843\x84\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C@\x90\x85\x90a\x0E\xA3V[`@Q\x7F\xC5\xF3\xD2T\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xC5\xF3\xD2T\x90a\r-\x90\x84\x90`\x04\x01a\x18\xC3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rDW_\x80\xFD[PZ\xF1\x15\x80\x15a\rVW=_\x80>=_\xFD[PP`@\x80Q``\x81\x01\x82R0\x81R_` \x80\x83\x01\x82\x90R\x83Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x94P\x7F,\xCE\xACUU\xB0\xCAE\xA3tL\xEDT/T\xB5j\xD2\xEBE\xE5!\x96#r\xEE\xF2\x12\xA2\xCB\xF3a\x93\x83\x01\x91a\r\xBD\x91\x88\x91\x01a\x18\xC3V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R\x91RQa\r\xF8\x91\x90a\x19\xFFV[`@Q\x80\x91\x03\x90\xA2PPPV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17p\x0F\x01`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0EJW_\x80\xFD[PZ\xF1\x15\x80\x15a\x0E\\W=_\x80>=_\xFD[PP`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x92P\x7F\xC7[\xF4\xF0<\x02\xFA\xB9AJ}zT\x04\x8C\x04\x86r+\xC7/3\xAD\x92G\t\xA0Y6\x08\xAD'\x91P_\x90\xA2PV[_a\x0F\x04\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xB0\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x80Q_\x14\x80a\x0F$WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0F$\x91\x90a\x1ACV[a\x02\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01R\x7Fot succeed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[``a\x0F\xBE\x84\x84_\x85a\x0F\xC6V[\x94\x93PPPPV[``\x82G\x10\x15a\x10XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01R\x7Fr call\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[_\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x87`@Qa\x10\x80\x91\x90a\x1A\\V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x10\xBAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x10\xBFV[``\x91P[P\x91P\x91Pa\x10\xD0\x87\x83\x83\x87a\x10\xDBV[\x97\x96PPPPPPPV[``\x83\x15a\x11pW\x82Q_\x03a\x11iWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x11iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x05HV[P\x81a\x0F\xBEV[a\x0F\xBE\x83\x83\x81Q\x15a\x11\x85W\x81Q\x80\x83` \x01\xFD[\x80`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x05H\x91\x90a\x1AgV[a&x\x80a\x1Az\x839\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xE7W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x11\xFCW_\x80\xFD[\x835a\x12\x07\x81a\x11\xC6V[\x95` \x85\x015\x95P`@\x90\x94\x015\x93\x92PPPV[_\x80\x83`\x1F\x84\x01\x12a\x12,W_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12CW_\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x12ZW_\x80\xFD[\x92P\x92\x90PV[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a\x12zW_\x80\xFD[\x895a\x12\x85\x81a\x11\xC6V[\x98P` \x8A\x015\x97P`@\x8A\x015a\x12\x9C\x81a\x11\xC6V[\x96P``\x8A\x015\x95P`\x80\x8A\x015\x94P`\xA0\x8A\x015a\x12\xBA\x81a\x11\xC6V[\x93P`\xC0\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xD5W_\x80\xFD[a\x12\xE1\x8C\x82\x8D\x01a\x12\x1CV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x95\x98\x94\x97\x96`\xE0\x015\x94\x93PPPPV[_\x80_\x80_\x80`\x80\x87\x89\x03\x12\x15a\x13\x10W_\x80\xFD[\x865a\x13\x1B\x81a\x11\xC6V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x137W_\x80\xFD[\x90\x88\x01\x90``\x82\x8B\x03\x12\x15a\x13JW_\x80\xFD[\x90\x95P`@\x88\x015\x90\x80\x82\x11\x15a\x13_W_\x80\xFD[a\x13k\x8A\x83\x8B\x01a\x12\x1CV[\x90\x96P\x94P``\x89\x015\x91P\x80\x82\x11\x15a\x13\x83W_\x80\xFD[\x81\x89\x01\x91P\x89`\x1F\x83\x01\x12a\x13\x96W_\x80\xFD[\x815\x81\x81\x11\x15a\x13\xA4W_\x80\xFD[\x8A` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x13\xB8W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa\x14\x0F` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa\x147`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa\x14c`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa\x14\x98\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_a\x01\xA0a\x15\x0B\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x14\xB1V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x157W_\x80\xFD[\x815a\x15B\x81a\x11\xC6V[\x93\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a\x15[W_\x80\xFD[\x835a\x15f\x81a\x11\xC6V[\x92P` \x84\x015a\x15v\x81a\x11\xC6V[\x91P`@\x84\x015a\x15\x86\x81a\x11\xC6V[\x80\x91PP\x92P\x92P\x92V[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a\x15\xA6W_\x80\xFD[\x865a\x15\xB1\x81a\x11\xC6V[\x95P` \x87\x015\x94P`@\x87\x015a\x15\xC8\x81a\x11\xC6V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xE3W_\x80\xFD[a\x15\xEF\x89\x82\x8A\x01a\x12\x1CV[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95`\x80\x90\x95\x015\x94\x93PPPPV[\x80Qa\x16\x12\x81a\x11\xC6V[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16'W_\x80\xFD[\x81Qa\x15B\x81a\x11\xC6V[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x16eW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16\x7FW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x12ZW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17TWa\x17Ta\x16\x93V[`@R\x91\x90PV[_` \x80\x83\x85\x03\x12\x15a\x17mW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x84W_\x80\xFD[\x90\x84\x01\x90`\x80\x82\x87\x03\x12\x15a\x17\x97W_\x80\xFD[a\x17\x9Fa\x16\xC0V[\x825\x81R\x83\x83\x015a\x17\xB0\x81a\x11\xC6V[\x81\x85\x01R`@\x83\x015\x82\x81\x11\x15a\x17\xC5W_\x80\xFD[\x83\x01`\x1F\x81\x01\x88\x13a\x17\xD5W_\x80\xFD[\x805\x83\x81\x11\x15a\x17\xE7Wa\x17\xE7a\x16\x93V[a\x18\x17\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\rV[\x93P\x80\x84R\x88\x86\x82\x84\x01\x01\x11\x15a\x18,W_\x80\xFD[\x80\x86\x83\x01\x87\x86\x017_\x86\x82\x86\x01\x01RPP\x81`@\x82\x01R``\x83\x015``\x82\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x18jW_\x80\xFD[PQ\x91\x90PV[\x80Q\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x83\x01R_`@\x82\x01Q`\x80`@\x85\x01Ra\x18\xAF`\x80\x85\x01\x82a\x14\xB1V[``\x93\x84\x01Q\x94\x90\x93\x01\x93\x90\x93RP\x91\x90PV[` \x81R_a\x15B` \x83\x01\x84a\x18qV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x16\x12W_\x80\xFD[\x80Q\x80\x15\x15\x81\x14a\x16\x12W_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19\x08W_\x80\xFD[a\x19\x10a\x16\xE9V[a\x19\x19\x83a\x16\x07V[\x81Ra\x19'` \x84\x01a\x16\x07V[` \x82\x01Ra\x198`@\x84\x01a\x16\x07V[`@\x82\x01R``\x83\x01Q``\x82\x01R`\x80\x83\x01Q`\x80\x82\x01Ra\x19]`\xA0\x84\x01a\x18\xD5V[`\xA0\x82\x01R`\xC0\x83\x01Q`\xC0\x82\x01R`\xE0\x83\x01Q`\xE0\x82\x01Ra\x01\0\x80\x84\x01Q\x81\x83\x01RPa\x01 a\x19\x90\x81\x85\x01a\x18\xE8V[\x90\x82\x01Ra\x01@\x83\x81\x01Q\x90\x82\x01Ra\x01`\x92\x83\x01Q\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_a\x01\xA0a\x19\xC1\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x18qV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0F\xBEa\x19\xF9\x83\x86a\x19\xD4V[\x84a\x19\xD4V[` \x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82Q\x16` \x82\x01R` \x82\x01Q`@\x82\x01R_`@\x83\x01Q``\x80\x84\x01Ra\x0F\xBE`\x80\x84\x01\x82a\x14\xB1V[_` \x82\x84\x03\x12\x15a\x1ASW_\x80\xFD[a\x15B\x82a\x18\xE8V[_a\x15B\x82\x84a\x19\xD4V[` \x81R_a\x15B` \x83\x01\x84a\x14\xB1V\xFEa\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003\xA2dipfsX\"\x12 \x11\x90\xCFB\xF9\x89\xCE\xE2?\x12Y|\x8C\x1E\x9D\xAA\xB6\xD8\xC8\x16Q3I\xC3\xCE\x7F\xD2)\xCA\xE5\xB0\xFFdsolcC\0\x08\x19\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x9FW_5`\xE0\x1C\x80c7\xEB\xDFP\x11a\0rW\x80cfn\x1B9\x11a\0XW\x80cfn\x1B9\x14a\x01OW\x80c\xAB\"\x1Av\x14a\x01\x84W\x80c\xB5\xC5\xF6r\x14a\x01\xABW_\x80\xFD[\x80c7\xEB\xDFP\x14a\x01)W\x80c[]\x9E\xE6\x14a\x01<W_\x80\xFD[\x80c\x0E\xFEj\x8B\x14a\0\xA3W\x80c\"\xB1U\xC6\x14a\0\xB8W\x80c&\xE0\xA1\x96\x14a\0\xF5W\x80c'\x91\x05e\x14a\x01\x16W[_\x80\xFD[a\0\xB6a\0\xB16`\x04a\x11\xEAV[a\x01\xBEV[\0[a\0\xCBa\0\xC66`\x04a\x12aV[a\x02\xA3V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\x08a\x01\x036`\x04a\x12\xFBV[a\x04_V[`@Qa\0\xEC\x92\x91\x90a\x14\xFDV[a\0\xB6a\x01$6`\x04a\x15'V[a\x07\x97V[a\0\xCBa\x0176`\x04a\x15IV[a\x08/V[a\0\xB6a\x01J6`\x04a\x15\x91V[a\n\x01V[a\0\xCBa\x01]6`\x04a\x15'V[_` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\0\xCB\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB6a\x01\xB96`\x04a\x11\xEAV[a\x0B\x17V[a\x02O3\x84\x84\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x021\x91\x90a\x16\x17V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x0CFV[a\x02\x9E3\x84\x83\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPV[_3\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8B`@Qa\x02\xD5\x90a\x11\xB9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x81R\x91\x83\x16` \x83\x01R\x90\x91\x16`@\x82\x01R``\x01\x81\x90`@Q\x80\x91\x03\x90_\xF5\x90P\x80\x15\x80\x15a\x03\x1FW=_\x80>=_\xFD[P`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16\x82R\x8C\x81\x16` \x83\x01R\x92\x94P\x82\x84\x16\x92\x85\x16\x91\x7Fg\x07%[,\\\xA8\x12 \xB2\xF3\xE4\x08\xA2i\xCB\x83\xBA\xA6\xAA~^7\xAA\x17V\x88:l\xDF\x06\xF1\x91\x01`@Q\x80\x91\x03\x90\xA3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16_\x90\x81R` \x81\x90R`@\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x83\x16\x91\x90\x91\x17\x90Ua\x03\xD8\x82\x8B\x8Aa\x01\xBEV[_`@Q\x80`\x80\x01`@R\x80\x89\x81R` \x01\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x85\x90R\x90Pa\x04P\x83\x82a\x0C\xDBV[PP\x99\x98PPPPPPPPPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``0a\x04\xCF` \x89\x01\x89a\x15'V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x05QW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Fcan only handle own orders\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x05_`@\x89\x01\x89a\x162V[\x81\x01\x90a\x05l\x91\x90a\x17\\V[\x90P\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xEE\xC5\x0B\x97`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDB\x91\x90a\x18ZV[`@Q\x7F\xB0\x9A\xAA\xCA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x90c\xB0\x9A\xAA\xCA\x90a\x06-\x90\x85\x90`\x04\x01a\x18\xC3V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06HW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06l\x91\x90a\x18ZV[\x14a\x06\xD3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Finvalid trading parameters\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05HV[`@Q\x7F\xE3\xE6\xF5\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x90c\xE3\xE6\xF5\xB2\x90a\x07%\x90\x84\x90`\x04\x01a\x18\xC3V[a\x01\x80`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a\x18\xF7V[\x92P\x82\x81`@Q` \x01a\x07z\x92\x91\x90a\x19\xB3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x96P\x96\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16_\x90\x81R` \x81\x90R`@\x90 T\x82\x91\x163\x14a\x08\"Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x08+\x82a\x0E\x05V[PPV[_\x80\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16`@Qa\x08y` \x82\x01a\x11\xB9V[\x81\x81\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x01\x83R`\x1F\x90\x91\x01\x16`@\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16` \x84\x01R\x80\x8B\x16\x91\x83\x01\x91\x90\x91R\x88\x16``\x82\x01R`\x80\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\t:\x92\x91` \x01a\x19\xEBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\t\xC2\x94\x93\x92\x91\x90\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\x90\x94\x16\x84R``\x92\x90\x92\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x01\x84\x01R`\x15\x83\x01R`5\x82\x01R`U\x01\x90V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 \x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x87\x16_\x90\x81R` \x81\x90R`@\x90 T\x87\x91\x163\x14a\n\x8CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[_`@Q\x80`\x80\x01`@R\x80\x88\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x86\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x84\x90R\x90Pa\x0B\x03\x88a\x0E\x05V[a\x0B\r\x88\x82a\x0C\xDBV[PPPPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16_\x90\x81R` \x81\x90R`@\x90 T\x84\x91\x163\x14a\x0B\xA2Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x0B\xF1\x843\x85\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[a\x0C@\x843\x84\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C@\x90\x85\x90a\x0E\xA3V[`@Q\x7F\xC5\xF3\xD2T\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xC5\xF3\xD2T\x90a\r-\x90\x84\x90`\x04\x01a\x18\xC3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rDW_\x80\xFD[PZ\xF1\x15\x80\x15a\rVW=_\x80>=_\xFD[PP`@\x80Q``\x81\x01\x82R0\x81R_` \x80\x83\x01\x82\x90R\x83Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x94P\x7F,\xCE\xACUU\xB0\xCAE\xA3tL\xEDT/T\xB5j\xD2\xEBE\xE5!\x96#r\xEE\xF2\x12\xA2\xCB\xF3a\x93\x83\x01\x91a\r\xBD\x91\x88\x91\x01a\x18\xC3V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R\x91RQa\r\xF8\x91\x90a\x19\xFFV[`@Q\x80\x91\x03\x90\xA2PPPV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17p\x0F\x01`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0EJW_\x80\xFD[PZ\xF1\x15\x80\x15a\x0E\\W=_\x80>=_\xFD[PP`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x92P\x7F\xC7[\xF4\xF0<\x02\xFA\xB9AJ}zT\x04\x8C\x04\x86r+\xC7/3\xAD\x92G\t\xA0Y6\x08\xAD'\x91P_\x90\xA2PV[_a\x0F\x04\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xB0\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x80Q_\x14\x80a\x0F$WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0F$\x91\x90a\x1ACV[a\x02\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01R\x7Fot succeed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[``a\x0F\xBE\x84\x84_\x85a\x0F\xC6V[\x94\x93PPPPV[``\x82G\x10\x15a\x10XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01R\x7Fr call\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[_\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x87`@Qa\x10\x80\x91\x90a\x1A\\V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x10\xBAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x10\xBFV[``\x91P[P\x91P\x91Pa\x10\xD0\x87\x83\x83\x87a\x10\xDBV[\x97\x96PPPPPPPV[``\x83\x15a\x11pW\x82Q_\x03a\x11iWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x11iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x05HV[P\x81a\x0F\xBEV[a\x0F\xBE\x83\x83\x81Q\x15a\x11\x85W\x81Q\x80\x83` \x01\xFD[\x80`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x05H\x91\x90a\x1AgV[a&x\x80a\x1Az\x839\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xE7W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x11\xFCW_\x80\xFD[\x835a\x12\x07\x81a\x11\xC6V[\x95` \x85\x015\x95P`@\x90\x94\x015\x93\x92PPPV[_\x80\x83`\x1F\x84\x01\x12a\x12,W_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12CW_\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x12ZW_\x80\xFD[\x92P\x92\x90PV[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a\x12zW_\x80\xFD[\x895a\x12\x85\x81a\x11\xC6V[\x98P` \x8A\x015\x97P`@\x8A\x015a\x12\x9C\x81a\x11\xC6V[\x96P``\x8A\x015\x95P`\x80\x8A\x015\x94P`\xA0\x8A\x015a\x12\xBA\x81a\x11\xC6V[\x93P`\xC0\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xD5W_\x80\xFD[a\x12\xE1\x8C\x82\x8D\x01a\x12\x1CV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x95\x98\x94\x97\x96`\xE0\x015\x94\x93PPPPV[_\x80_\x80_\x80`\x80\x87\x89\x03\x12\x15a\x13\x10W_\x80\xFD[\x865a\x13\x1B\x81a\x11\xC6V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x137W_\x80\xFD[\x90\x88\x01\x90``\x82\x8B\x03\x12\x15a\x13JW_\x80\xFD[\x90\x95P`@\x88\x015\x90\x80\x82\x11\x15a\x13_W_\x80\xFD[a\x13k\x8A\x83\x8B\x01a\x12\x1CV[\x90\x96P\x94P``\x89\x015\x91P\x80\x82\x11\x15a\x13\x83W_\x80\xFD[\x81\x89\x01\x91P\x89`\x1F\x83\x01\x12a\x13\x96W_\x80\xFD[\x815\x81\x81\x11\x15a\x13\xA4W_\x80\xFD[\x8A` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x13\xB8W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa\x14\x0F` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa\x147`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa\x14c`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa\x14\x98\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_a\x01\xA0a\x15\x0B\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x14\xB1V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x157W_\x80\xFD[\x815a\x15B\x81a\x11\xC6V[\x93\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a\x15[W_\x80\xFD[\x835a\x15f\x81a\x11\xC6V[\x92P` \x84\x015a\x15v\x81a\x11\xC6V[\x91P`@\x84\x015a\x15\x86\x81a\x11\xC6V[\x80\x91PP\x92P\x92P\x92V[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a\x15\xA6W_\x80\xFD[\x865a\x15\xB1\x81a\x11\xC6V[\x95P` \x87\x015\x94P`@\x87\x015a\x15\xC8\x81a\x11\xC6V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xE3W_\x80\xFD[a\x15\xEF\x89\x82\x8A\x01a\x12\x1CV[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95`\x80\x90\x95\x015\x94\x93PPPPV[\x80Qa\x16\x12\x81a\x11\xC6V[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16'W_\x80\xFD[\x81Qa\x15B\x81a\x11\xC6V[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x16eW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16\x7FW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x12ZW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17TWa\x17Ta\x16\x93V[`@R\x91\x90PV[_` \x80\x83\x85\x03\x12\x15a\x17mW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x84W_\x80\xFD[\x90\x84\x01\x90`\x80\x82\x87\x03\x12\x15a\x17\x97W_\x80\xFD[a\x17\x9Fa\x16\xC0V[\x825\x81R\x83\x83\x015a\x17\xB0\x81a\x11\xC6V[\x81\x85\x01R`@\x83\x015\x82\x81\x11\x15a\x17\xC5W_\x80\xFD[\x83\x01`\x1F\x81\x01\x88\x13a\x17\xD5W_\x80\xFD[\x805\x83\x81\x11\x15a\x17\xE7Wa\x17\xE7a\x16\x93V[a\x18\x17\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\rV[\x93P\x80\x84R\x88\x86\x82\x84\x01\x01\x11\x15a\x18,W_\x80\xFD[\x80\x86\x83\x01\x87\x86\x017_\x86\x82\x86\x01\x01RPP\x81`@\x82\x01R``\x83\x015``\x82\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x18jW_\x80\xFD[PQ\x91\x90PV[\x80Q\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x83\x01R_`@\x82\x01Q`\x80`@\x85\x01Ra\x18\xAF`\x80\x85\x01\x82a\x14\xB1V[``\x93\x84\x01Q\x94\x90\x93\x01\x93\x90\x93RP\x91\x90PV[` \x81R_a\x15B` \x83\x01\x84a\x18qV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x16\x12W_\x80\xFD[\x80Q\x80\x15\x15\x81\x14a\x16\x12W_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19\x08W_\x80\xFD[a\x19\x10a\x16\xE9V[a\x19\x19\x83a\x16\x07V[\x81Ra\x19'` \x84\x01a\x16\x07V[` \x82\x01Ra\x198`@\x84\x01a\x16\x07V[`@\x82\x01R``\x83\x01Q``\x82\x01R`\x80\x83\x01Q`\x80\x82\x01Ra\x19]`\xA0\x84\x01a\x18\xD5V[`\xA0\x82\x01R`\xC0\x83\x01Q`\xC0\x82\x01R`\xE0\x83\x01Q`\xE0\x82\x01Ra\x01\0\x80\x84\x01Q\x81\x83\x01RPa\x01 a\x19\x90\x81\x85\x01a\x18\xE8V[\x90\x82\x01Ra\x01@\x83\x81\x01Q\x90\x82\x01Ra\x01`\x92\x83\x01Q\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_a\x01\xA0a\x19\xC1\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x18qV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0F\xBEa\x19\xF9\x83\x86a\x19\xD4V[\x84a\x19\xD4V[` \x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82Q\x16` \x82\x01R` \x82\x01Q`@\x82\x01R_`@\x83\x01Q``\x80\x84\x01Ra\x0F\xBE`\x80\x84\x01\x82a\x14\xB1V[_` \x82\x84\x03\x12\x15a\x1ASW_\x80\xFD[a\x15B\x82a\x18\xE8V[_a\x15B\x82\x84a\x19\xD4V[` \x81R_a\x15B` \x83\x01\x84a\x14\xB1V\xFEa\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003\xA2dipfsX\"\x12 \x11\x90\xCFB\xF9\x89\xCE\xE2?\x12Y|\x8C\x1E\x9D\xAA\xB6\xD8\xC8\x16Q3I\xC3\xCE\x7F\xD2)\xCA\xE5\xB0\xFFdsolcC\0\x08\x19\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OnlyOwnerCanCall(address)` and selector `0x68bafff8`.
+    ```solidity
+    error OnlyOwnerCanCall(address owner);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnlyOwnerCanCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OnlyOwnerCanCall> for UnderlyingRustTuple<'_> {
+            fn from(value: OnlyOwnerCanCall) -> Self {
+                (value.owner,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyOwnerCanCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { owner: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OnlyOwnerCanCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [104u8, 186u8, 255u8, 248u8];
+            const SIGNATURE: &'static str = "OnlyOwnerCanCall(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderNotValid(string)` and selector `0xc8fc2725`.
+    ```solidity
+    error OrderNotValid(string);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderNotValid(pub alloy_sol_types::private::String);
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderNotValid> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderNotValid) -> Self {
+                (value.0,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderNotValid {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self(tuple.0)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderNotValid {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [200u8, 252u8, 39u8, 37u8];
+            const SIGNATURE: &'static str = "OrderNotValid(string)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ConditionalOrderCreated(address,(address,bytes32,bytes))` and selector `0x2cceac5555b0ca45a3744ced542f54b56ad2eb45e521962372eef212a2cbf361`.
+    ```solidity
+    event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ConditionalOrderCreated {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub params:
+            <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ConditionalOrderCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (IConditionalOrder::ConditionalOrderParams,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "ConditionalOrderCreated(address,(address,bytes32,bytes))";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    44u8, 206u8, 172u8, 85u8, 85u8, 176u8, 202u8, 69u8, 163u8, 116u8, 76u8, 237u8,
+                    84u8, 47u8, 84u8, 181u8, 106u8, 210u8, 235u8, 69u8, 229u8, 33u8, 150u8, 35u8,
+                    114u8, 238u8, 242u8, 18u8, 162u8, 203u8, 243u8, 97u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    params: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ConditionalOrderCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ConditionalOrderCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ConditionalOrderCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Deployed(address,address,address,address)` and selector `0x6707255b2c5ca81220b2f3e408a269cb83baa6aa7e5e37aa1756883a6cdf06f1`.
+    ```solidity
+    event Deployed(address indexed amm, address indexed owner, address token0, address token1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Deployed {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Deployed {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Deployed(address,address,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    103u8, 7u8, 37u8, 91u8, 44u8, 92u8, 168u8, 18u8, 32u8, 178u8, 243u8, 228u8,
+                    8u8, 162u8, 105u8, 203u8, 131u8, 186u8, 166u8, 170u8, 126u8, 94u8, 55u8, 170u8,
+                    23u8, 86u8, 136u8, 58u8, 108u8, 223u8, 6u8, 241u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    amm: topics.1,
+                    owner: topics.2,
+                    token0: data.0,
+                    token1: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.amm.clone(),
+                    self.owner.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.amm,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Deployed {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Deployed> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Deployed) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TradingDisabled(address)` and selector `0xc75bf4f03c02fab9414a7d7a54048c0486722bc72f33ad924709a0593608ad27`.
+    ```solidity
+    event TradingDisabled(address indexed amm);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TradingDisabled {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TradingDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TradingDisabled(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    199u8, 91u8, 244u8, 240u8, 60u8, 2u8, 250u8, 185u8, 65u8, 74u8, 125u8, 122u8,
+                    84u8, 4u8, 140u8, 4u8, 134u8, 114u8, 43u8, 199u8, 47u8, 51u8, 173u8, 146u8,
+                    71u8, 9u8, 160u8, 89u8, 54u8, 8u8, 173u8, 39u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { amm: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.amm.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.amm,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TradingDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TradingDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TradingDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address _settler);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _settler: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._settler,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _settler: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._settler,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `ammDeterministicAddress(address,address,address)` and selector `0x37ebdf50`.
+    ```solidity
+    function ammDeterministicAddress(address ammOwner, address token0, address token1) external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ammDeterministicAddressCall {
+        #[allow(missing_docs)]
+        pub ammOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`ammDeterministicAddress(address,address,
+    /// address)`](ammDeterministicAddressCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ammDeterministicAddressReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ammDeterministicAddressCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ammDeterministicAddressCall) -> Self {
+                    (value.ammOwner, value.token0, value.token1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ammDeterministicAddressCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        ammOwner: tuple.0,
+                        token0: tuple.1,
+                        token1: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ammDeterministicAddressReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ammDeterministicAddressReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ammDeterministicAddressReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ammDeterministicAddressCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [55u8, 235u8, 223u8, 80u8];
+            const SIGNATURE: &'static str = "ammDeterministicAddress(address,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.ammOwner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ammDeterministicAddressReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: ammDeterministicAddressReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `create(address,uint256,address,uint256,uint256,address,bytes,bytes32)` and selector `0x22b155c6`.
+    ```solidity
+    function create(address token0, uint256 amount0, address token1, uint256 amount1, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external returns (address amm);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub priceOracle: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub priceOracleData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`create(address,uint256,address,uint256,uint256,address,bytes,
+    /// bytes32)`](createCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createReturn {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.token0,
+                        value.amount0,
+                        value.token1,
+                        value.amount1,
+                        value.minTradedToken0,
+                        value.priceOracle,
+                        value.priceOracleData,
+                        value.appData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token0: tuple.0,
+                        amount0: tuple.1,
+                        token1: tuple.2,
+                        amount1: tuple.3,
+                        minTradedToken0: tuple.4,
+                        priceOracle: tuple.5,
+                        priceOracleData: tuple.6,
+                        appData: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value.amm,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amm: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [34u8, 177u8, 85u8, 198u8];
+            const SIGNATURE: &'static str =
+                "create(address,uint256,address,uint256,uint256,address,bytes,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount1),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minTradedToken0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracle,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracleData,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createReturn = r.into();
+                        r.amm
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createReturn = r.into();
+                    r.amm
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `deposit(address,uint256,uint256)` and selector `0x0efe6a8b`.
+    ```solidity
+    function deposit(address amm, uint256 amount0, uint256 amount1) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct depositCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`deposit(address,uint256,uint256)`](depositCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct depositReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
+                fn from(value: depositCall) -> Self {
+                    (value.amm, value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amm: tuple.0,
+                        amount0: tuple.1,
+                        amount1: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: depositReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl depositReturn {
+            fn _tokenize(&self) -> <depositCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for depositCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = depositReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [14u8, 254u8, 106u8, 139u8];
+            const SIGNATURE: &'static str = "deposit(address,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                depositReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disableTrading(address)` and selector `0x27910565`.
+    ```solidity
+    function disableTrading(address amm) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableTradingCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`disableTrading(address)`](disableTradingCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableTradingReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableTradingCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableTradingCall) -> Self {
+                    (value.amm,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amm: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableTradingReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableTradingReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableTradingReturn {
+            fn _tokenize(
+                &self,
+            ) -> <disableTradingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableTradingCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = disableTradingReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [39u8, 145u8, 5u8, 101u8];
+            const SIGNATURE: &'static str = "disableTrading(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableTradingReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,bytes32[])` and selector `0x26e0a196`.
+    ```solidity
+    function getTradeableOrderWithSignature(address amm, IConditionalOrder.ConditionalOrderParams memory params, bytes memory, bytes32[] memory) external view returns (GPv2Order.Data memory order, bytes memory signature);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTradeableOrderWithSignatureCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub params:
+            <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub _3: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,
+    /// bytes32[])`](getTradeableOrderWithSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTradeableOrderWithSignatureReturn {
+        #[allow(missing_docs)]
+        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IConditionalOrder::ConditionalOrderParams,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTradeableOrderWithSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTradeableOrderWithSignatureCall) -> Self {
+                    (value.amm, value.params, value._2, value._3)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderWithSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amm: tuple.0,
+                        params: tuple.1,
+                        _2: tuple.2,
+                        _3: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (GPv2Order::Data, alloy_sol_types::sol_data::Bytes);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTradeableOrderWithSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTradeableOrderWithSignatureReturn) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderWithSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getTradeableOrderWithSignatureReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <GPv2Order::Data as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTradeableOrderWithSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IConditionalOrder::ConditionalOrderParams,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+            );
+            type Return = getTradeableOrderWithSignatureReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (GPv2Order::Data, alloy_sol_types::sol_data::Bytes);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [38u8, 224u8, 161u8, 150u8];
+            const SIGNATURE: &'static str =
+                "getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,bytes32[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                    <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::FixedBytes<32>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._3),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getTradeableOrderWithSignatureReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `owner(address)` and selector `0x666e1b39`.
+    ```solidity
+    function owner(address) external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerCall(pub alloy_sol_types::private::Address);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`owner(address)`](ownerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [102u8, 110u8, 27u8, 57u8];
+            const SIGNATURE: &'static str = "owner(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ownerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: ownerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `settler()` and selector `0xab221a76`.
+    ```solidity
+    function settler() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`settler()`](settlerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settlerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settlerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settlerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [171u8, 34u8, 26u8, 118u8];
+            const SIGNATURE: &'static str = "settler()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: settlerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: settlerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `updateParameters(address,uint256,address,bytes,bytes32)` and selector `0x5b5d9ee6`.
+    ```solidity
+    function updateParameters(address amm, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateParametersCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub priceOracle: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub priceOracleData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`updateParameters(address,uint256,address,bytes,
+    /// bytes32)`](updateParametersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct updateParametersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateParametersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: updateParametersCall) -> Self {
+                    (
+                        value.amm,
+                        value.minTradedToken0,
+                        value.priceOracle,
+                        value.priceOracleData,
+                        value.appData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateParametersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amm: tuple.0,
+                        minTradedToken0: tuple.1,
+                        priceOracle: tuple.2,
+                        priceOracleData: tuple.3,
+                        appData: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<updateParametersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: updateParametersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateParametersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl updateParametersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <updateParametersCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for updateParametersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = updateParametersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 93u8, 158u8, 230u8];
+            const SIGNATURE: &'static str =
+                "updateParameters(address,uint256,address,bytes,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minTradedToken0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracle,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracleData,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                updateParametersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `withdraw(address,uint256,uint256)` and selector `0xb5c5f672`.
+    ```solidity
+    function withdraw(address amm, uint256 amount0, uint256 amount1) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct withdrawCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`withdraw(address,uint256,uint256)`](withdrawCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct withdrawReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<withdrawCall> for UnderlyingRustTuple<'_> {
+                fn from(value: withdrawCall) -> Self {
+                    (value.amm, value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amm: tuple.0,
+                        amount0: tuple.1,
+                        amount1: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<withdrawReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: withdrawReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl withdrawReturn {
+            fn _tokenize(&self) -> <withdrawCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for withdrawCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = withdrawReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [181u8, 197u8, 246u8, 114u8];
+            const SIGNATURE: &'static str = "withdraw(address,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                withdrawReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`CowAmmConstantProductFactory`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum CowAmmConstantProductFactoryCalls {
+        #[allow(missing_docs)]
+        ammDeterministicAddress(ammDeterministicAddressCall),
+        #[allow(missing_docs)]
+        create(createCall),
+        #[allow(missing_docs)]
+        deposit(depositCall),
+        #[allow(missing_docs)]
+        disableTrading(disableTradingCall),
+        #[allow(missing_docs)]
+        getTradeableOrderWithSignature(getTradeableOrderWithSignatureCall),
+        #[allow(missing_docs)]
+        owner(ownerCall),
+        #[allow(missing_docs)]
+        settler(settlerCall),
+        #[allow(missing_docs)]
+        updateParameters(updateParametersCall),
+        #[allow(missing_docs)]
+        withdraw(withdrawCall),
+    }
+    impl CowAmmConstantProductFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [14u8, 254u8, 106u8, 139u8],
+            [34u8, 177u8, 85u8, 198u8],
+            [38u8, 224u8, 161u8, 150u8],
+            [39u8, 145u8, 5u8, 101u8],
+            [55u8, 235u8, 223u8, 80u8],
+            [91u8, 93u8, 158u8, 230u8],
+            [102u8, 110u8, 27u8, 57u8],
+            [171u8, 34u8, 26u8, 118u8],
+            [181u8, 197u8, 246u8, 114u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <depositCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableTradingCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ammDeterministicAddressCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <updateParametersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <settlerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <withdrawCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(deposit),
+            ::core::stringify!(create),
+            ::core::stringify!(getTradeableOrderWithSignature),
+            ::core::stringify!(disableTrading),
+            ::core::stringify!(ammDeterministicAddress),
+            ::core::stringify!(updateParameters),
+            ::core::stringify!(owner),
+            ::core::stringify!(settler),
+            ::core::stringify!(withdraw),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmConstantProductFactoryCalls {
+        const COUNT: usize = 9usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowAmmConstantProductFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::ammDeterministicAddress(_) => {
+                    <ammDeterministicAddressCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disableTrading(_) => {
+                    <disableTradingCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getTradeableOrderWithSignature(_) => {
+                    <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::settler(_) => <settlerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::updateParameters(_) => {
+                    <updateParametersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmConstantProductFactoryCalls,
+            >] = &[
+                {
+                    fn deposit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <depositCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::deposit)
+                    }
+                    deposit
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn getTradeableOrderWithSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                CowAmmConstantProductFactoryCalls::getTradeableOrderWithSignature,
+                            )
+                    }
+                    getTradeableOrderWithSignature
+                },
+                {
+                    fn disableTrading(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::disableTrading)
+                    }
+                    disableTrading
+                },
+                {
+                    fn ammDeterministicAddress(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <ammDeterministicAddressCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CowAmmConstantProductFactoryCalls::ammDeterministicAddress)
+                    }
+                    ammDeterministicAddress
+                },
+                {
+                    fn updateParameters(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <updateParametersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::updateParameters)
+                    }
+                    updateParameters
+                },
+                {
+                    fn owner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn settler(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <settlerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::settler)
+                    }
+                    settler
+                },
+                {
+                    fn withdraw(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryCalls::withdraw)
+                    }
+                    withdraw
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmConstantProductFactoryCalls,
+            >] = &[
+                {
+                    fn deposit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <depositCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmConstantProductFactoryCalls::deposit)
+                    }
+                    deposit
+                },
+                {
+                    fn create(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmConstantProductFactoryCalls::create)
+                    }
+                    create
+                },
+                {
+                    fn getTradeableOrderWithSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                CowAmmConstantProductFactoryCalls::getTradeableOrderWithSignature,
+                            )
+                    }
+                    getTradeableOrderWithSignature
+                },
+                {
+                    fn disableTrading(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmConstantProductFactoryCalls::disableTrading)
+                    }
+                    disableTrading
+                },
+                {
+                    fn ammDeterministicAddress(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <ammDeterministicAddressCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                CowAmmConstantProductFactoryCalls::ammDeterministicAddress,
+                            )
+                    }
+                    ammDeterministicAddress
+                },
+                {
+                    fn updateParameters(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <updateParametersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmConstantProductFactoryCalls::updateParameters)
+                    }
+                    updateParameters
+                },
+                {
+                    fn owner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmConstantProductFactoryCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn settler(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <settlerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmConstantProductFactoryCalls::settler)
+                    }
+                    settler
+                },
+                {
+                    fn withdraw(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
+                    {
+                        <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmConstantProductFactoryCalls::withdraw)
+                    }
+                    withdraw
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::ammDeterministicAddress(inner) => {
+                    <ammDeterministicAddressCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::deposit(inner) => {
+                    <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::disableTrading(inner) => {
+                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTradeableOrderWithSignature(inner) => {
+                    <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::settler(inner) => {
+                    <settlerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::updateParameters(inner) => {
+                    <updateParametersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::withdraw(inner) => {
+                    <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::ammDeterministicAddress(inner) => {
+                    <ammDeterministicAddressCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::create(inner) => {
+                    <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::deposit(inner) => {
+                    <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::disableTrading(inner) => {
+                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getTradeableOrderWithSignature(inner) => {
+                    <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::settler(inner) => {
+                    <settlerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::updateParameters(inner) => {
+                    <updateParametersCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::withdraw(inner) => {
+                    <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowAmmConstantProductFactory`](self) custom
+    /// errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowAmmConstantProductFactoryErrors {
+        #[allow(missing_docs)]
+        OnlyOwnerCanCall(OnlyOwnerCanCall),
+        #[allow(missing_docs)]
+        OrderNotValid(OrderNotValid),
+    }
+    impl CowAmmConstantProductFactoryErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[104u8, 186u8, 255u8, 248u8], [200u8, 252u8, 39u8, 37u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <OnlyOwnerCanCall as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderNotValid as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(OnlyOwnerCanCall),
+            ::core::stringify!(OrderNotValid),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmConstantProductFactoryErrors {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
+        const NAME: &'static str = "CowAmmConstantProductFactoryErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::OnlyOwnerCanCall(_) => {
+                    <OnlyOwnerCanCall as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderNotValid(_) => <OrderNotValid as alloy_sol_types::SolError>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmConstantProductFactoryErrors,
+            >] = &[
+                {
+                    fn OnlyOwnerCanCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryErrors>
+                    {
+                        <OnlyOwnerCanCall as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryErrors::OnlyOwnerCanCall)
+                    }
+                    OnlyOwnerCanCall
+                },
+                {
+                    fn OrderNotValid(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryErrors>
+                    {
+                        <OrderNotValid as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmConstantProductFactoryErrors::OrderNotValid)
+                    }
+                    OrderNotValid
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmConstantProductFactoryErrors,
+            >] = &[
+                {
+                    fn OnlyOwnerCanCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryErrors>
+                    {
+                        <OnlyOwnerCanCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmConstantProductFactoryErrors::OnlyOwnerCanCall)
+                    }
+                    OnlyOwnerCanCall
+                },
+                {
+                    fn OrderNotValid(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryErrors>
+                    {
+                        <OrderNotValid as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowAmmConstantProductFactoryErrors::OrderNotValid)
+                    }
+                    OrderNotValid
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::OnlyOwnerCanCall(inner) => {
+                    <OnlyOwnerCanCall as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::OrderNotValid(inner) => {
+                    <OrderNotValid as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::OnlyOwnerCanCall(inner) => {
+                    <OnlyOwnerCanCall as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::OrderNotValid(inner) => {
+                    <OrderNotValid as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowAmmConstantProductFactory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowAmmConstantProductFactoryEvents {
+        #[allow(missing_docs)]
+        ConditionalOrderCreated(ConditionalOrderCreated),
+        #[allow(missing_docs)]
+        Deployed(Deployed),
+        #[allow(missing_docs)]
+        TradingDisabled(TradingDisabled),
+    }
+    impl CowAmmConstantProductFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                44u8, 206u8, 172u8, 85u8, 85u8, 176u8, 202u8, 69u8, 163u8, 116u8, 76u8, 237u8,
+                84u8, 47u8, 84u8, 181u8, 106u8, 210u8, 235u8, 69u8, 229u8, 33u8, 150u8, 35u8,
+                114u8, 238u8, 242u8, 18u8, 162u8, 203u8, 243u8, 97u8,
+            ],
+            [
+                103u8, 7u8, 37u8, 91u8, 44u8, 92u8, 168u8, 18u8, 32u8, 178u8, 243u8, 228u8, 8u8,
+                162u8, 105u8, 203u8, 131u8, 186u8, 166u8, 170u8, 126u8, 94u8, 55u8, 170u8, 23u8,
+                86u8, 136u8, 58u8, 108u8, 223u8, 6u8, 241u8,
+            ],
+            [
+                199u8, 91u8, 244u8, 240u8, 60u8, 2u8, 250u8, 185u8, 65u8, 74u8, 125u8, 122u8, 84u8,
+                4u8, 140u8, 4u8, 134u8, 114u8, 43u8, 199u8, 47u8, 51u8, 173u8, 146u8, 71u8, 9u8,
+                160u8, 89u8, 54u8, 8u8, 173u8, 39u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <ConditionalOrderCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Deployed as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TradingDisabled as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(ConditionalOrderCreated),
+            ::core::stringify!(Deployed),
+            ::core::stringify!(TradingDisabled),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CowAmmConstantProductFactoryEvents {
+        const COUNT: usize = 3usize;
+        const NAME: &'static str = "CowAmmConstantProductFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<ConditionalOrderCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ConditionalOrderCreated as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ConditionalOrderCreated)
+                }
+                Some(<Deployed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Deployed as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Deployed)
+                }
+                Some(<TradingDisabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TradingDisabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TradingDisabled)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CowAmmConstantProductFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ConditionalOrderCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Deployed(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::TradingDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ConditionalOrderCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Deployed(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TradingDisabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowAmmConstantProductFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`CowAmmConstantProductFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowAmmConstantProductFactoryInstance<P, N> {
+        CowAmmConstantProductFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _settler: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<CowAmmConstantProductFactoryInstance<P, N>>,
+    > {
+        CowAmmConstantProductFactoryInstance::<P, N>::deploy(__provider, _settler)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _settler: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CowAmmConstantProductFactoryInstance::<P, N>::deploy_builder(__provider, _settler)
+    }
+    /**A [`CowAmmConstantProductFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowAmmConstantProductFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowAmmConstantProductFactoryInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowAmmConstantProductFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowAmmConstantProductFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmConstantProductFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowAmmConstantProductFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`CowAmmConstantProductFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _settler: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<CowAmmConstantProductFactoryInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _settler);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _settler: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { _settler })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowAmmConstantProductFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowAmmConstantProductFactoryInstance<P, N> {
+            CowAmmConstantProductFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmConstantProductFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`ammDeterministicAddress`]
+        /// function.
+        pub fn ammDeterministicAddress(
+            &self,
+            ammOwner: alloy_sol_types::private::Address,
+            token0: alloy_sol_types::private::Address,
+            token1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, ammDeterministicAddressCall, N> {
+            self.call_builder(&ammDeterministicAddressCall {
+                ammOwner,
+                token0,
+                token1,
+            })
+        }
+
+        ///Creates a new call builder for the [`create`] function.
+        pub fn create(
+            &self,
+            token0: alloy_sol_types::private::Address,
+            amount0: alloy_sol_types::private::primitives::aliases::U256,
+            token1: alloy_sol_types::private::Address,
+            amount1: alloy_sol_types::private::primitives::aliases::U256,
+            minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
+            priceOracle: alloy_sol_types::private::Address,
+            priceOracleData: alloy_sol_types::private::Bytes,
+            appData: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, createCall, N> {
+            self.call_builder(&createCall {
+                token0,
+                amount0,
+                token1,
+                amount1,
+                minTradedToken0,
+                priceOracle,
+                priceOracleData,
+                appData,
+            })
+        }
+
+        ///Creates a new call builder for the [`deposit`] function.
+        pub fn deposit(
+            &self,
+            amm: alloy_sol_types::private::Address,
+            amount0: alloy_sol_types::private::primitives::aliases::U256,
+            amount1: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, depositCall, N> {
+            self.call_builder(&depositCall {
+                amm,
+                amount0,
+                amount1,
+            })
+        }
+
+        ///Creates a new call builder for the [`disableTrading`] function.
+        pub fn disableTrading(
+            &self,
+            amm: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, disableTradingCall, N> {
+            self.call_builder(&disableTradingCall { amm })
+        }
+
+        ///Creates a new call builder for the
+        /// [`getTradeableOrderWithSignature`] function.
+        pub fn getTradeableOrderWithSignature(
+            &self,
+            amm: alloy_sol_types::private::Address,
+            params: <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
+            _2: alloy_sol_types::private::Bytes,
+            _3: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        ) -> alloy_contract::SolCallBuilder<&P, getTradeableOrderWithSignatureCall, N> {
+            self.call_builder(&getTradeableOrderWithSignatureCall {
+                amm,
+                params,
+                _2,
+                _3,
+            })
+        }
+
+        ///Creates a new call builder for the [`owner`] function.
+        pub fn owner(
+            &self,
+            _0: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
+            self.call_builder(&ownerCall(_0))
+        }
+
+        ///Creates a new call builder for the [`settler`] function.
+        pub fn settler(&self) -> alloy_contract::SolCallBuilder<&P, settlerCall, N> {
+            self.call_builder(&settlerCall)
+        }
+
+        ///Creates a new call builder for the [`updateParameters`] function.
+        pub fn updateParameters(
+            &self,
+            amm: alloy_sol_types::private::Address,
+            minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
+            priceOracle: alloy_sol_types::private::Address,
+            priceOracleData: alloy_sol_types::private::Bytes,
+            appData: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, updateParametersCall, N> {
+            self.call_builder(&updateParametersCall {
+                amm,
+                minTradedToken0,
+                priceOracle,
+                priceOracleData,
+                appData,
+            })
+        }
+
+        ///Creates a new call builder for the [`withdraw`] function.
+        pub fn withdraw(
+            &self,
+            amm: alloy_sol_types::private::Address,
+            amount0: alloy_sol_types::private::primitives::aliases::U256,
+            amount1: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> {
+            self.call_builder(&withdrawCall {
+                amm,
+                amount0,
+                amount1,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmConstantProductFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`ConditionalOrderCreated`]
+        /// event.
+        pub fn ConditionalOrderCreated_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ConditionalOrderCreated, N> {
+            self.event_filter::<ConditionalOrderCreated>()
+        }
+
+        ///Creates a new event filter for the [`Deployed`] event.
+        pub fn Deployed_filter(&self) -> alloy_contract::Event<&P, Deployed, N> {
+            self.event_filter::<Deployed>()
+        }
+
+        ///Creates a new event filter for the [`TradingDisabled`] event.
+        pub fn TradingDisabled_filter(&self) -> alloy_contract::Event<&P, TradingDisabled, N> {
+            self.event_filter::<TradingDisabled>()
+        }
+    }
+}
+pub type Instance = CowAmmConstantProductFactory::CowAmmConstantProductFactoryInstance<
+    ::alloy_provider::DynProvider,
+>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x40664207e3375FB4b733d4743CE9b159331fd034"),
+            Some(19861952u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xdb1cba3a87f2db53b6e1e6af48e28ed877592ec0"),
+            Some(33874317u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xb808e8183e3a72d196457d127c7fd4befa0d7fd3"),
+            Some(5874562u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/cowammfactorygetter/Cargo.toml b/contracts/generated/contracts-generated/cowammfactorygetter/Cargo.toml
new file mode 100644
index 0000000000..f70f9f2106
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammfactorygetter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowammfactorygetter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowammfactorygetter/src/lib.rs b/contracts/generated/contracts-generated/cowammfactorygetter/src/lib.rs
new file mode 100644
index 0000000000..c3dbb5b91f
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammfactorygetter/src/lib.rs
@@ -0,0 +1,441 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface CowAmmFactoryGetter {
+    function FACTORY() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "FACTORY",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowAmmFactoryGetter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `FACTORY()` and selector `0x2dd31000`.
+    ```solidity
+    function FACTORY() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct FACTORYCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`FACTORY()`](FACTORYCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct FACTORYReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<FACTORYCall> for UnderlyingRustTuple<'_> {
+                fn from(value: FACTORYCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for FACTORYCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<FACTORYReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: FACTORYReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for FACTORYReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for FACTORYCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 211u8, 16u8, 0u8];
+            const SIGNATURE: &'static str = "FACTORY()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: FACTORYReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: FACTORYReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`CowAmmFactoryGetter`](self) function calls.
+    #[derive(Clone)]
+    pub enum CowAmmFactoryGetterCalls {
+        #[allow(missing_docs)]
+        FACTORY(FACTORYCall),
+    }
+    impl CowAmmFactoryGetterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[45u8, 211u8, 16u8, 0u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<FACTORYCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(FACTORY)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmFactoryGetterCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowAmmFactoryGetterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::FACTORY(_) => <FACTORYCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CowAmmFactoryGetterCalls>] = &[{
+                fn FACTORY(data: &[u8]) -> alloy_sol_types::Result<CowAmmFactoryGetterCalls> {
+                    <FACTORYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(CowAmmFactoryGetterCalls::FACTORY)
+                }
+                FACTORY
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmFactoryGetterCalls,
+            >] = &[{
+                fn FACTORY(data: &[u8]) -> alloy_sol_types::Result<CowAmmFactoryGetterCalls> {
+                    <FACTORYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(CowAmmFactoryGetterCalls::FACTORY)
+                }
+                FACTORY
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::FACTORY(inner) => {
+                    <FACTORYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::FACTORY(inner) => {
+                    <FACTORYCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowAmmFactoryGetter`](self) contract instance.
+
+    See the [wrapper's documentation](`CowAmmFactoryGetterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowAmmFactoryGetterInstance<P, N> {
+        CowAmmFactoryGetterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`CowAmmFactoryGetter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowAmmFactoryGetter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowAmmFactoryGetterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowAmmFactoryGetterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowAmmFactoryGetterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmFactoryGetterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowAmmFactoryGetter`](self) contract instance.
+
+        See the [wrapper's documentation](`CowAmmFactoryGetterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowAmmFactoryGetterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowAmmFactoryGetterInstance<P, N> {
+            CowAmmFactoryGetterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmFactoryGetterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`FACTORY`] function.
+        pub fn FACTORY(&self) -> alloy_contract::SolCallBuilder<&P, FACTORYCall, N> {
+            self.call_builder(&FACTORYCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmFactoryGetterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = CowAmmFactoryGetter::CowAmmFactoryGetterInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/cowammlegacyhelper/Cargo.toml b/contracts/generated/contracts-generated/cowammlegacyhelper/Cargo.toml
new file mode 100644
index 0000000000..39331d874d
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammlegacyhelper/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowammlegacyhelper"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs b/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs
new file mode 100644
index 0000000000..2b806732b9
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs
@@ -0,0 +1,3796 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Interaction {
+    struct Data { address target; uint256 value; bytes callData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Interaction {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address target; uint256 value; bytes callData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (value.target, value.value, value.callData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    value: tuple.1,
+                    callData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address target,uint256 value,bytes callData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Interaction`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2InteractionInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2InteractionInstance<P, N> {
+        GPv2InteractionInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Interaction`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Interaction`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2InteractionInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2InteractionInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2InteractionInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Interaction`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2InteractionInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2InteractionInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2InteractionInstance<P, N> {
+            GPv2InteractionInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Order {
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Order {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub kind: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub partiallyFillable: bool,
+        #[allow(missing_docs)]
+        pub sellTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub buyTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            bool,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.sellToken,
+                    value.buyToken,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.validTo,
+                    value.appData,
+                    value.feeAmount,
+                    value.kind,
+                    value.partiallyFillable,
+                    value.sellTokenBalance,
+                    value.buyTokenBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sellToken: tuple.0,
+                    buyToken: tuple.1,
+                    receiver: tuple.2,
+                    sellAmount: tuple.3,
+                    buyAmount: tuple.4,
+                    validTo: tuple.5,
+                    appData: tuple.6,
+                    feeAmount: tuple.7,
+                    kind: tuple.8,
+                    partiallyFillable: tuple.9,
+                    sellTokenBalance: tuple.10,
+                    buyTokenBalance: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.partiallyFillable,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenBalance),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenBalance),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address sellToken,address buyToken,address receiver,uint256 \
+                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
+                     feeAmount,bytes32 kind,bool partiallyFillable,bytes32 \
+                     sellTokenBalance,bytes32 buyTokenBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.partiallyFillable,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellTokenBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyTokenBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.kind)
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.partiallyFillable,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellTokenBalance,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyTokenBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.partiallyFillable,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellTokenBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyTokenBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2OrderInstance<P, N> {
+        GPv2OrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Order`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Order`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2OrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2OrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2OrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2OrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2OrderInstance<P, N> {
+            GPv2OrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library GPv2Interaction {
+    struct Data {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+}
+
+library GPv2Order {
+    struct Data {
+        address sellToken;
+        address buyToken;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        uint32 validTo;
+        bytes32 appData;
+        uint256 feeAmount;
+        bytes32 kind;
+        bool partiallyFillable;
+        bytes32 sellTokenBalance;
+        bytes32 buyTokenBalance;
+    }
+}
+
+interface CowAmmLegacyHelper {
+    error InvalidArrayLength();
+    error MathOverflowedMulDiv();
+    error NoOrder();
+    error PoolDoesNotExist();
+    error PoolIsClosed();
+    error PoolIsPaused();
+
+    event COWAMMPoolCreated(address indexed amm);
+
+    constructor();
+
+    function factory() external view returns (address);
+    function getSnapshot(address amm) external view returns (bytes memory);
+    function isLegacy(address amm) external view returns (bool);
+    function isLegacyEnabled(address amm) external view returns (bool success);
+    function order(address pool, uint256[] memory prices) external view returns (GPv2Order.Data memory _order, GPv2Interaction.Data[] memory preInteractions, GPv2Interaction.Data[] memory postInteractions, bytes memory sig);
+    function tokens(address pool) external view returns (address[] memory _tokens);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSnapshot",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isLegacy",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isLegacyEnabled",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "order",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "prices",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct GPv2Order.Data",
+        "components": [
+          {
+            "name": "sellToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "kind",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "sellTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "buyTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "preInteractions",
+        "type": "tuple[]",
+        "internalType": "struct GPv2Interaction.Data[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "postInteractions",
+        "type": "tuple[]",
+        "internalType": "struct GPv2Interaction.Data[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "sig",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "tokens",
+    "inputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "_tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "COWAMMPoolCreated",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "InvalidArrayLength",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "MathOverflowedMulDiv",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NoOrder",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PoolDoesNotExist",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PoolIsClosed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PoolIsPaused",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowAmmLegacyHelper {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[Pa\0\x18a\0\x1DV[a\x02\xFFV[F`\x01\x81\x90\x03a\x01\x12Wa\0Ds\x99A\xFD}\xB2\x003\x08\xE7\xEE\x17\xB0D\0\x01\"x\xF1*\xC6a\x02\xC9V[a\0as\xB3\xBF\x81qOpG \xDC\xB05\x1F\xF0\xD4.\xCAa\xB0i\xFCa\x02\xC9V[a\0~s0\x10v\xC3n\x03IH\xA7G\xBBa\xBA\xB9\xCD\x03\xF6&r\xE3a\x02\xC9V[a\0\x9Bs\x02~\x1C\xBF,)\x9C\xBA^\xB8\xA2XI\x10\xD0O\x1A\x8A\xA4\x03a\x02\xC9V[a\0\xB8s\xBE\xEFZ\xFE\x88\xEFs3~Pp\xAB(U\xD3}\xBFT\x93\xA4a\x02\xC9V[a\0\xD5s\xC6\xB1=^f/\xA0E\x8F\x03\x99[\xCB\x82J\x194\xAA\x89_a\x02\xC9V[a\0\xF2s\xD7\xCB\x8C\xC1\xB5cV\xBB{x\xD0.x^\xAD(\xE2\x15\x86`a\x02\xC9V[a\x01\x0Fs\x07\x9C\x86\x8F\x97\xAE\xD8\xE0\xD0?\x11\xE1R\x9C;\x05o\xF2\x1C\xEAa\x02\xC9V[PV[\x80`d\x03a\x01\x0FWa\x017s\xBCaY\xFDB\x9B\xE1\x82\x06\xE6\x0B;\xB0\x1Dr\x89\xF9\x05Q\x1Ba\x02\xC9V[a\x01Ts\xE5\xD1\xAA\x85e\xF5\xDB\xFC\x06\xCD\xE2\r\xFDv\xB4\xC7\xC6\xD4;\xD5a\x02\xC9V[a\x01qs\x9D\x85p\xEF\x9AQ\x9C\xA8\x1D\xAE\xC3R\x12\xF45\xD9\x84;\xA5da\x02\xC9V[a\x01\x8Es\xD9|1\xE5?\x16\xF4\x95q\\\xE7\x1E\x12\xE1\x1B\x95E\xEE\xDD\x8Ba\x02\xC9V[a\x01\xABs\xFF\x1B\xD3\xD5p\xE3TL\x18;\xA7\x7FZM<\xC7B\xC8\xD2\xB3a\x02\xC9V[a\x01\xC8s \x9D&\x9D\xFDf\xB9\xCE\xC7d\xDE~\xB6\xFE\xFC$\xF7[\xDDHa\x02\xC9V[a\x01\xE5s\xC3uu\xAD\x8E\xFES\x0F\xD8\xA7\x9A\xEB\0\x87\xE5\x87*$\xDA\xBCa\x02\xC9V[a\x02\x02s\x1Cx(\xDA\xDA\xDE\x12\xA8H\xF3k\xE8\xE2\xD3\x14db\xAB\xFFha\x02\xC9V[a\x02\x1Fs\xAB\xA5)K\xBA}65\xC2\xA3\xE4M\x0E\x87\xEA\x7FX\x89\x8F\xB7a\x02\xC9V[a\x02<sn\xB7\xBE\x97*\xEB\xB6\xBE-\x9A\xCFC|\xB4\x12\xC0\xAB\xEE\x91+a\x02\xC9V[a\x02Ys\xC4\xD0\x99i\xAA\xD7\xF2R\xC7]\xD3R\xBB\xBDq\x9E4\xED\x06\xADa\x02\xC9V[a\x02vs\xA2Z\xF8j]\xBE\xA4^\x9F\xD7\x0C\x18yH\x9Fc\xD0\x81\xADDa\x02\xC9V[a\x02\x93sWI,\xB6\xC8\xEE)\x98\xE9\xD8=\xDC\x8Cq>x\x1F\xFET\x8Ea\x02\xC9V[a\x02\xB0s\xC3>>\xC1EV\xA8\xE7\x1B\xE3\t\x7F\xE2\xDC\x8C\x0B\x91\x19\xC8\x97a\x02\xC9V[a\x01\x0FswG(&\x87YS7N\xD3\x08L1\xA4\x83\xF8'\x98\x7F\x14[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\r\x03\x83M\r\x86\xC7\xF5~\x87z\xF4\x0E&\xF1v\xDC1\xBDcu5\xD4\xBA\x15=\x1A\xC9\xDE\x88\xA7\xEA\x90_\x90\xA2PV[aV\x84\x80a\x03\x0C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0oW_5`\xE0\x1C\x80c*\xECy\xA0\x11a\0MW\x80c*\xECy\xA0\x14a\0\xDEW\x80c\xC4Z\x01U\x14a\0\xF1W\x80c\xE4\x86\x039\x14a\x01\x1EW_\x80\xFD[\x80c\x10\x02\x9D\xAA\x14a\0sW\x80c!W\x02V\x14a\0\x9BW\x80c'$,\x9B\x14a\0\xBBW[_\x80\xFD[a\0\x86a\0\x816`\x04a$bV[a\x01>V[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xAEa\0\xA96`\x04a$bV[a\x05\x0CV[`@Qa\0\x92\x91\x90a$\xC9V[a\0\xCEa\0\xC96`\x04a$\xDBV[a\x0C\xC6V[`@Qa\0\x92\x94\x93\x92\x91\x90a&\xE9V[a\0\x86a\0\xEC6`\x04a$bV[a\x13-V[a\0\xF9a\x13@V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\x92V[a\x011a\x01,6`\x04a$bV[a\x14\x10V[`@Qa\0\x92\x91\x90a'4V[`@Q\x7FV$\xB2[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\x04\x82\x01R`\x01`$\x82\x01R_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cV$\xB2[\x90`D\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD0W=_\x80>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x02\x15\x91\x90\x81\x01\x90a(\x8AV[\x80` \x01\x90Q\x81\x01\x90a\x02(\x91\x90a(\xC4V[\x90P_s/U\xE8\xB2\r\x0B\x9F\xEF\xA1\x87\xAA}\0\xB6\xCB\xE5c`[\xF5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_s\xFD\xAF\xC9\xD1\x90/N\x0B\x84\xF6_I\xF2D\xB3+1\x01;ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s/U\xE8\xB2\r\x0B\x9F\xEF\xA1\x87\xAA}\0\xB6\xCB\xE5c`[\xF5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cQ\xCA\xD5\xEE\x87s\x90\x08\xD1\x9FX\xAA\xBD\x9E\xD0\xD6\tqVZ\xA8Q\x05`\xABAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03*W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03N\x91\x90a(\xDFV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16`\x04\x83\x01R`$\x82\x01R`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xBAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xDE\x91\x90a(\xC4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_a\x04\x01\x86a\x05\x0CV[\x80` \x01\x90Q\x81\x01\x90a\x04\x14\x91\x90a(\xF6V[\x90P_s\xFD\xAF\xC9\xD1\x90/N\x0B\x84\xF6_I\xF2D\xB3+1\x01;ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16ca\x08\xC52\x88\x84`@Q` \x01a\x04Y\x91\x90a)\xCFV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\xAD\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xC8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xEC\x91\x90a)\xE1V[\x90P\x83\x80\x15a\x04\xF8WP\x82[\x80\x15a\x05\x01WP\x80[\x97\x96PPPPPPPV[``F`\x01\x81\x90\x03a\x07\xBDWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x99A\xFD}\xB2\x003\x08\xE7\xEE\x17\xB0D\0\x01\"x\xF1*\xC6\x03a\x05lW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aH/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xB3\xBF\x81qOpG \xDC\xB05\x1F\xF0\xD4.\xCAa\xB0i\xFC\x03a\x05\xC0W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aP\xEFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s0\x10v\xC3n\x03IH\xA7G\xBBa\xBA\xB9\xCD\x03\xF6&r\xE3\x03a\x06\x14W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a6Oa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x02~\x1C\xBF,)\x9C\xBA^\xB8\xA2XI\x10\xD0O\x1A\x8A\xA4\x03\x03a\x06hW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a-/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xBE\xEFZ\xFE\x88\xEFs3~Pp\xAB(U\xD3}\xBFT\x93\xA4\x03a\x06\xBCW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aB\xEFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC6\xB1=^f/\xA0E\x8F\x03\x99[\xCB\x82J\x194\xAA\x89_\x03a\x07\x10W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aA/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xD7\xCB\x8C\xC1\xB5cV\xBB{x\xD0.x^\xAD(\xE2\x15\x86`\x03a\x07dW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a9\xCFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x07\x9C\x86\x8F\x97\xAE\xD8\xE0\xD0?\x11\xE1R\x9C;\x05o\xF2\x1C\xEA\x03a\x07\xB8W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aI\xEFa\x01\xC0\x919\x93\x92PPPV[a\x0C\xB1V[\x80`d\x03a\x0C\xB1Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xBCaY\xFDB\x9B\xE1\x82\x06\xE6\x0B;\xB0\x1Dr\x89\xF9\x05Q\x1B\x03a\x08\x19W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a.\xEFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xE5\xD1\xAA\x85e\xF5\xDB\xFC\x06\xCD\xE2\r\xFDv\xB4\xC7\xC6\xD4;\xD5\x03a\x08mW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aFoa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x9D\x85p\xEF\x9AQ\x9C\xA8\x1D\xAE\xC3R\x12\xF45\xD9\x84;\xA5d\x03a\x08\xC1W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aK\xAFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xD9|1\xE5?\x16\xF4\x95q\\\xE7\x1E\x12\xE1\x1B\x95E\xEE\xDD\x8B\x03a\t\x15W`@Q\x80a\x02@\x01`@R\x80a\x02 \x81R` \x01a0\xAFa\x02 \x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xFF\x1B\xD3\xD5p\xE3TL\x18;\xA7\x7FZM<\xC7B\xC8\xD2\xB3\x03a\tiW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aT\x8Fa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s \x9D&\x9D\xFDf\xB9\xCE\xC7d\xDE~\xB6\xFE\xFC$\xF7[\xDDH\x03a\t\xBDW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aO/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC3uu\xAD\x8E\xFES\x0F\xD8\xA7\x9A\xEB\0\x87\xE5\x87*$\xDA\xBC\x03a\n\x11W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a4\x8Fa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x1Cx(\xDA\xDA\xDE\x12\xA8H\xF3k\xE8\xE2\xD3\x14db\xAB\xFFh\x03a\neW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a?oa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xAB\xA5)K\xBA}65\xC2\xA3\xE4M\x0E\x87\xEA\x7FX\x89\x8F\xB7\x03a\n\xB9W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aMoa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16sn\xB7\xBE\x97*\xEB\xB6\xBE-\x9A\xCFC|\xB4\x12\xC0\xAB\xEE\x91+\x03a\x0B\rW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a2\xCFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC4\xD0\x99i\xAA\xD7\xF2R\xC7]\xD3R\xBB\xBDq\x9E4\xED\x06\xAD\x03a\x0BaW`@Q\x80a\x02@\x01`@R\x80a\x02 \x81R` \x01a=Oa\x02 \x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xA2Z\xF8j]\xBE\xA4^\x9F\xD7\x0C\x18yH\x9Fc\xD0\x81\xADD\x03a\x0B\xB5W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aD\xAFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16sWI,\xB6\xC8\xEE)\x98\xE9\xD8=\xDC\x8Cq>x\x1F\xFET\x8E\x03a\x0C\tW`@Q\x80a\x02\0\x01`@R\x80a\x01\xE0\x81R` \x01aR\xAFa\x01\xE0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC3>>\xC1EV\xA8\xE7\x1B\xE3\t\x7F\xE2\xDC\x8C\x0B\x91\x19\xC8\x97\x03a\x0C]W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a8\x0Fa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16swG(&\x87YS7N\xD3\x08L1\xA4\x83\xF8'\x98\x7F\x14\x03a\x0C\xB1W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a;\x8Fa\x01\xC0\x919\x93\x92PPPV[PP`@\x80Q` \x81\x01\x90\x91R_\x81R\x91\x90PV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``\x80\x80`\x02\x85\x14a\rdW`@Q\x7F\x9D\x89\x02\n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``a\ro\x88a\x13-V[a\x12\xE9Wa\r|\x88a\x16\x96V[a\r\xE7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FPool is not a CoW AMM\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EU\x91\x90a(\xC4V[\x90P_\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xA1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xC5\x91\x90a(\xC4V[\x90P\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cJ\xDA!\x8B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x10W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F4\x91\x90a)\xE1V[\x15\x15_\x03a\x0FnW`@Q\x7F!\x08\x1A\xBF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x10\x81`@Q\x80`\xC0\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B\x8B`\x01\x81\x81\x10a\x0F\xE3Wa\x0F\xE3a*\0V[\x90P` \x02\x015\x81R` \x01\x8B\x8B_\x81\x81\x10a\x10\x01Wa\x10\x01a*\0V[\x90P` \x02\x015\x81R` \x01\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cm\xBC\x88\x13`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10VW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10z\x91\x90a(\xDFV[\x90Ra\x17NV[\x96P\x86`@Q` \x01a\x10\x94\x91\x90a*-V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R`\x01\x80\x84R\x83\x83\x01\x90\x92R\x94P\x81` \x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x10\xD1W\x90PP\x95P`@Q\x80``\x01`@R\x80\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01a\x12;s\x90\x08\xD1\x9FX\xAA\xBD\x9E\xD0\xD6\tqVZ\xA8Q\x05`\xABAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x8EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xB2\x91\x90a(\xDFV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x8B\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[`@Q`$\x01a\x12M\x91\x81R` \x01\x90V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xF1O\xCB\xC8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90R\x86Q\x87\x90_\x90a\x12\xD7Wa\x12\xD7a*\0V[` \x02` \x01\x01\x81\x90RPPPa\x12\xFFV[a\x12\xF4\x88\x88\x88a\x1A\xD6V[\x92\x97P\x90\x95P\x93P\x90P[\x87\x81`@Q` \x01a\x13\x12\x92\x91\x90a*<V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x93P\x93P\x93P\x93V[_\x80a\x138\x83a\x05\x0CV[Q\x11\x92\x91PPV[_F`\x01\x81\x90\x03a\x13fWs\x8D\xEE\xD8\xED|_\xCBU\x88O\x13\xF1!eK\xB4\xBB|\x847\x91PP\x90V[\x80`d\x03a\x13\x89Ws*\xF6\xC5\x9F\xC9W\xD4\xA4]\xDB\xBD\x92\x7F\xA3\x0F|PQ\xF5\x83\x91PP\x90V[\x80b\xAA6\xA7\x03a\x13\xAEWs\xBD\x18u\x80U\xDB\xE3\xED7\xA2G\x13\x94U\x9A\xE9z]\xA5\xC0\x91PP\x90V[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUnsupported chain\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\r\xDEV[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x92` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa\x149\x82a\x13-V[a\x15\xB5W\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\x86W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xAA\x91\x90a(\xC4V[\x81_\x81Q\x81\x10a\x14\xBCWa\x14\xBCa*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15?W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15c\x91\x90a(\xC4V[\x81`\x01\x81Q\x81\x10a\x15vWa\x15va*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x91\x90PV[_a\x15\xBF\x83a!_V[P\x90P\x80_\x81Q\x81\x10a\x15\xD4Wa\x15\xD4a*\0V[` \x02` \x01\x01Q\x82_\x81Q\x81\x10a\x15\xEEWa\x15\xEEa*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x80`\x01\x81Q\x81\x10a\x16;Wa\x16;a*\0V[` \x02` \x01\x01Q\x82`\x01\x81Q\x81\x10a\x16VWa\x16Va*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPP\x91\x90PV[_\x80a\x16\xA0a\x13@V[`@Q\x7Ffn\x1B9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`\x04\x83\x01R\x91\x90\x91\x16\x90cfn\x1B9\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x170\x91\x90a(\xC4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x92\x91PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R` \x82\x01Q\x82Q`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16`\x04\x82\x01R_\x92\x83\x92\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\"W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18F\x91\x90a(\xDFV[`@\x85\x81\x01Q\x86Q\x91Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16`\x04\x82\x01R\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18\xDB\x91\x90a(\xDFV[\x91P\x91P_\x80_\x80_\x88`\x80\x01Q\x87a\x18\xF4\x91\x90a*\xAEV[\x90P_\x89``\x01Q\x87a\x19\x07\x91\x90a*\xAEV[\x90P\x81\x81\x10\x15a\x19mW\x89` \x01Q\x95P\x89`@\x01Q\x94Pa\x199\x81\x8B`\x80\x01Q`\x02a\x194\x91\x90a*\xAEV[a\"{V[a\x19D`\x02\x8Aa*\xF2V[a\x19N\x91\x90a+\x05V[\x93Pa\x19f\x84\x88a\x19_\x82\x8Ca+\x05V[`\x01a\"\xCBV[\x92Pa\x19\xB9V[\x89`@\x01Q\x95P\x89` \x01Q\x94Pa\x19\x90\x82\x8B``\x01Q`\x02a\x194\x91\x90a*\xAEV[a\x19\x9B`\x02\x89a*\xF2V[a\x19\xA5\x91\x90a+\x05V[\x93Pa\x19\xB6\x84\x89a\x19_\x82\x8Ba+\x05V[\x92P[`@Q\x80a\x01\x80\x01`@R\x80\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85\x81R` \x01\x84\x81R` \x01a\x01,Ba\x1A3\x91\x90a+\x18V[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B`\xA0\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x98PPPPPPPPP\x91\x90PV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``\x80``a\x1BD\x87a\x01>V[a\x1BzW`@Q\x7F\xEF\xC8i\xB4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x85\x89a!_V[\x91P\x91P_\x81`@\x01Q\x80` \x01\x90Q\x81\x01\x90a\x1B\xA2\x91\x90a+<V[\x90Pa\x1C\x83`@Q\x80`\xC0\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85_\x81Q\x81\x10a\x1B\xE0Wa\x1B\xE0a*\0V[` \x02` \x01\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85`\x01\x81Q\x81\x10a\x1C\x16Wa\x1C\x16a*\0V[` \x02` \x01\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B\x8B`\x01\x81\x81\x10a\x1CLWa\x1CLa*\0V[\x90P` \x02\x015\x81R` \x01\x8B\x8B_\x81\x81\x10a\x1CjWa\x1Cja*\0V[\x90P` \x02\x015\x81R` \x01\x83`\xA0\x01Q\x81RPa\x17NV[\x96P_s\x90\x08\xD1\x9FX\xAA\xBD\x9E\xD0\xD6\tqVZ\xA8Q\x05`\xABAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C\xE3W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1D\x07\x91\x90a(\xDFV[\x90P\x80\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x89`@Q` \x01a\x1D<\x91\x90a*-V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R_``\x84\x01\x81\x81R`\x80\x85\x01\x84R\x84R` \x80\x85\x01\x8A\x90R\x83Q\x80\x82\x01\x85R\x91\x82R\x84\x84\x01\x91\x90\x91R\x91Q\x90\x92a\x1D\xA0\x92\x90\x91\x01a+\xF4V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x1D\xDE\x94\x93\x92\x91`$\x01a,\x9DV[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R` \x80\x83\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F_\xD7\xE9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x81Q`\x01\x80\x82R\x81\x84\x01\x90\x93R\x92\x97P\x82\x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x1EhW\x90PP`@\x80Q``\x81\x01\x82R\x85Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R_` \x82\x01R\x91\x98P\x81\x01\x8Ca\x1FU\x8B\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x91\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16`$\x83\x01R`D\x82\x01R`d\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F0\xF7<\x99\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90R\x87Q\x88\x90_\x90a \x07Wa \x07a*\0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x90\x81` \x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a 'W\x90PP\x95P`@Q\x80``\x01`@R\x80\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01\x8C_\x80\x1B`@Q`$\x01a \xBD\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F0\xF7<\x99\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90R\x86Q\x87\x90_\x90a!GWa!Ga*\0V[` \x02` \x01\x01\x81\x90RPPPPP\x93P\x93P\x93P\x93V[`@\x80Q``\x81\x81\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x82\x90Ra!\x82\x83a\x05\x0CV[\x80` \x01\x90Q\x81\x01\x90a!\x95\x91\x90a(\xF6V[\x90P_\x81`@\x01Q\x80` \x01\x90Q\x81\x01\x90a!\xB0\x91\x90a+<V[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x92\x93P\x91\x90` \x83\x01\x90\x806\x837\x01\x90PP\x92P\x80_\x01Q\x83_\x81Q\x81\x10a!\xE9Wa!\xE9a*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x80` \x01Q\x83`\x01\x81Q\x81\x10a\";Wa\";a*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPP\x91P\x91V[_\x81_\x03a\"\x94Wa\"\x8D\x82\x84a*\xF2V[\x90Pa\"\xC5V[\x82\x15a\"\xC0W\x81a\"\xA6`\x01\x85a+\x05V[a\"\xB0\x91\x90a*\xF2V[a\"\xBB\x90`\x01a,\xCDV[a\"\xC2V[_[\x90P[\x92\x91PPV[_\x80a\"\xD8\x86\x86\x86a#\x1AV[\x90Pa\"\xE3\x83a$\x12V[\x80\x15a\"\xFEWP_\x84\x80a\"\xF9Wa\"\xF9a*\xC5V[\x86\x88\t\x11[\x15a#\x11Wa#\x0E`\x01\x82a,\xCDV[\x90P[\x95\x94PPPPPV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a#mW\x83\x82\x81a#cWa#ca*\xC5V[\x04\x92PPPa$\x0BV[\x80\x84\x11a#\xA6W`@Q\x7F\"{\xC1S\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP[\x93\x92PPPV[_`\x02\x82`\x03\x81\x11\x15a$'Wa$'a,\xE0V[a$1\x91\x90a-\rV[`\xFF\x16`\x01\x14\x90P\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a$_W_\x80\xFD[PV[_` \x82\x84\x03\x12\x15a$rW_\x80\xFD[\x815a$\x0B\x81a$>V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\"\xC2` \x83\x01\x84a$}V[_\x80_`@\x84\x86\x03\x12\x15a$\xEDW_\x80\xFD[\x835a$\xF8\x81a$>V[\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a%\x14W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a%'W_\x80\xFD[\x815\x81\x81\x11\x15a%5W_\x80\xFD[\x87` \x82`\x05\x1B\x85\x01\x01\x11\x15a%IW_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa%\x9D` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa%\xC5`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa%\xF1`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa&&\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x82\x82Q\x80\x85R` \x80\x86\x01\x95P\x80\x82`\x05\x1B\x84\x01\x01\x81\x86\x01_[\x84\x81\x10\x15a&\xDCW\x85\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x89R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84R\x84\x81\x01Q\x85\x85\x01R`@\x90\x81\x01Q``\x91\x85\x01\x82\x90R\x90a&\xC8\x81\x86\x01\x83a$}V[\x9A\x86\x01\x9A\x94PPP\x90\x83\x01\x90`\x01\x01a&ZV[P\x90\x97\x96PPPPPPPV[_a\x01\xE0a&\xF7\x83\x88a%\\V[\x80a\x01\x80\x84\x01Ra'\n\x81\x84\x01\x87a&?V[\x90P\x82\x81\x03a\x01\xA0\x84\x01Ra'\x1F\x81\x86a&?V[\x90P\x82\x81\x03a\x01\xC0\x84\x01Ra\x05\x01\x81\x85a$}V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15a'\x81W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R\x92\x84\x01\x92\x91\x84\x01\x91`\x01\x01a'OV[P\x90\x96\x95PPPPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\xC0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a'\xDDWa'\xDDa'\x8DV[`@R\x90V[_\x82`\x1F\x83\x01\x12a'\xF2W_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a(\rWa(\ra'\x8DV[`@Q`\x1F\x83\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x16`?\x01\x16\x81\x01\x90\x82\x82\x11\x81\x83\x10\x17\x15a(SWa(Sa'\x8DV[\x81`@R\x83\x81R\x86` \x85\x88\x01\x01\x11\x15a(kW_\x80\xFD[\x83` \x87\x01` \x83\x01^_` \x85\x83\x01\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a(\x9AW_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a(\xB0W_\x80\xFD[a(\xBC\x84\x82\x85\x01a'\xE3V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a(\xD4W_\x80\xFD[\x81Qa$\x0B\x81a$>V[_` \x82\x84\x03\x12\x15a(\xEFW_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a)\x06W_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a)\x1DW_\x80\xFD[\x90\x83\x01\x90``\x82\x86\x03\x12\x15a)0W_\x80\xFD[`@Q``\x81\x01\x81\x81\x10\x83\x82\x11\x17\x15a)KWa)Ka'\x8DV[`@R\x82Qa)Y\x81a$>V[\x81R` \x83\x81\x01Q\x90\x82\x01R`@\x83\x01Q\x82\x81\x11\x15a)vW_\x80\xFD[a)\x82\x87\x82\x86\x01a'\xE3V[`@\x83\x01RP\x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x82R` \x81\x01Q` \x83\x01R_`@\x82\x01Q```@\x85\x01Ra(\xBC``\x85\x01\x82a$}V[` \x81R_a\"\xC2` \x83\x01\x84a)\x91V[_` \x82\x84\x03\x12\x15a)\xF1W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a$\x0BW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[a\x01\x80\x81\x01a\"\xC5\x82\x84a%\\V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x83``\x1B\x16\x81R_\x82Q\x80` \x85\x01`\x14\x85\x01^_\x92\x01`\x14\x01\x91\x82RP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\"\xC5Wa\"\xC5a*\x81V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a+\0Wa+\0a*\xC5V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\"\xC5Wa\"\xC5a*\x81V[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a+5Wa+5a*\x81V[P\x92\x91PPV[_` \x82\x84\x03\x12\x15a+LW_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a+cW_\x80\xFD[\x90\x83\x01\x90`\xC0\x82\x86\x03\x12\x15a+vW_\x80\xFD[a+~a'\xBAV[\x82Qa+\x89\x81a$>V[\x81R` \x83\x01Qa+\x99\x81a$>V[` \x82\x01R`@\x83\x81\x01Q\x90\x82\x01R``\x83\x01Qa+\xB6\x81a$>V[``\x82\x01R`\x80\x83\x01Q\x82\x81\x11\x15a+\xCCW_\x80\xFD[a+\xD8\x87\x82\x86\x01a'\xE3V[`\x80\x83\x01RP`\xA0\x83\x01Q`\xA0\x82\x01R\x80\x93PPPP\x92\x91PPV[` \x80\x82R\x82Q``\x83\x83\x01R\x80Q`\x80\x84\x01\x81\x90R_\x92\x91\x82\x01\x90\x83\x90`\xA0\x86\x01\x90[\x80\x83\x10\x15a,8W\x83Q\x82R\x92\x84\x01\x92`\x01\x92\x90\x92\x01\x91\x90\x84\x01\x90a,\x18V[P\x83\x87\x01Q\x93P\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x92P\x82\x86\x82\x03\x01`@\x87\x01Ra,v\x81\x85a)\x91V[\x93PPP`@\x85\x01Q\x81\x85\x84\x03\x01``\x86\x01Ra,\x93\x83\x82a$}V[\x96\x95PPPPPPV[\x84\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a,\xBB`\x80\x83\x01\x85a$}V[\x82\x81\x03``\x84\x01Ra\x05\x01\x81\x85a$}V[\x80\x82\x01\x80\x82\x11\x15a\"\xC5Wa\"\xC5a*\x81V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_`\xFF\x83\x16\x80a-\x1FWa-\x1Fa*\xC5V[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\xC5\xA0\xE7V\xAC\x88\xC1\xD3\xA4\xC4\x19\0\xD9w\xFE\x93\xC2\xD3O\xC9Z\0\xCA>\x84\xEBLkP\xFA\xF9I\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0Z\xFE8U5\x8E\x11+VG\xB9Rp\x9Eae\xE1\xC1\xEE\xEE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01cEx]\x8A\0\0\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0.~\x97\x8D\xA0\xC54\x04\xA8\xCFf\xEDK\xA2\xC7pl\x07\xB6*\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xD8\\\x99\x99m\x84\xD2S\x87\xBC\r\x01\xE5\x0E>\xA8\x14\xF6N~\x04\xA3\xB9I\xA5qx\x9E\x19lZ\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0j\x02<\xCD\x1F\xF6\xF2\x04\\3\tv\x8E\xAD\x9Eh\xF9x\xF6\xE1\0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n\xFF\xD9\xFD\xEB\x8E\x08\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xA9\x9F\xD9\x95\x0B]]\xCE\xEA\xF4\x93\x9E\"\x1D\xCA\x8C\xA9\xB98\xAB\0\x01\0\0\0\0\0\0\0\0\0%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Qx\xA7)\xEE0\x08\xC7\xD4\x882\xD0\"g\xB7._4\xAD\xA8\xF5T\xA6s\x1A6\x8F\x01Y\x0E\xD7\x1B4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xCBDN\x90\xD8\x19\x84\x15&lj'$\xB7\x90\x0F\xB1/\xC5n\0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V\x19zT%\xC0\xC8\0\0\0\0\0\0\0\0\0\0\0\0\xBD\x91\xA7-\xC3\xD9\xB5\xD9\xB1n\xE8c\x8D\xA1\xFCe1\x1B\xD9\n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\0\0\0\0\0\0\0\0\0\0\0\0\xABp\xBC\xB2`\x07=\x03m\x16` \x1E\x9DT\x05\xF5\x82\x9Bz\0\0\0\0\0\0\0\0\0\0\0\0g\x8D\xF3A_\xC3\x19G\xDAC$\xECc!(t\xBEZ\x82\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01Q\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q.1\x98\x1E4\x96\ti\xEBT\x9F^\x82l\xF7\x7Fe^r\xB06\x03\xADWJy\xFD\x01_M\xE4\xDE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n\x16\xC9ZM.<\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\xCE\x9E\x05\xC2\xAE\xE5\xF2/\x99A\xC4\xCD\x1F\x1A\x1D\x13\x19K\x10\x97yB-Z\xD9\xA9\x80\x15{\xD0\xF1d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xA2\x02\x9F\xBBTYx\xD0Sx\xB6\xDF\x19\xE3uO\xE5\xED-\x0B\xA1\xE0Q\x02u\x03\x93Cr\xF7\xBE\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\x17q'b,J\0\xF3\xD4\t\xB7Uq\xE1,\xB3\xC8\x97=<\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0R\xBA\x9E\xFC8D\x1A\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 !\xD4\xC7\x92\xEA~8\xE0\xD0\x81\x9C \x11\xA2\xB1\xCBrR\xBD\x99\0\x02\0\0\0\0\0\0\0\0\0\x1E\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\xCAD\xB6\xA3\x04\xBA\xA1m\x11\xB6\xDB\x07\x06l\x12v\xB1'>\xE3\xF9E\x90\xBB\xD02\x01\xA6\x18\x82\xAF\x9A\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xA0\xB8i\x91\xC6!\x8B6\xC1\xD1\x9DJ.\x9E\xB0\xCE6\x06\xEBH\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\xCBv\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB4\xE1m\x01h\xE5-5\xCA\xCD,a\x85\xB4B\x81\xEC(\xC9\xDC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8QYEz\xC6 \x1D\xA7q>\xFE\xCD\x84a\x8Cz\x16\x8E\x88\xB9\xCB}\x1C\r\xB1(\xAF\x1E\xFE\n\x08\xBB\xB1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n\x17'?\xC1Kd\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\x80\xBAS?\x01N\xF4#\x8A\xB7\xAD <\n\xEA\xCB\xF3\nq\xC04a@\xDBw\xC4:\xE3\x12\x1A\xFA\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xAE\xA4j`6\x8A{\xD0`\xEE\xC7\xDF\x8C\xBAC\xB7\xEFA\xAD\x85\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x003f2\xE5<\x8E\xCF\x04\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0@B\xA0LT\xEF\x13:\xC2\xA3\xC9=\xB6\x9DC\xC6\xC0*3\x0B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xD6|\x9F\xB8pE\xE0}\xA9L\x81\xDE\x03[\\\x7FC\\\xD4eh\xFC\xA0*\xA3]p\x9B\xBC\x9E!\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x8E[\xBB\xB0\x9E\xD1\xEB\xDE\x86t\xCD\xA3\x9A\x0C\x16\x94\x01\xDBBR\0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0'\x10\0\0\0\0\0\0\0\0\0\0\0\0\xE0\x89\x04\x90'\xB9\\'E\xD1\xA9T\xBC\x1D$SR\xD8\x84\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x8D\xB8\x87\x0C\xA4\xB8\xAC\x18\x8CM\x1A\x01O4\xA3\x81\xAE'\xE1\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q \x9C\x17\xD9\xEB\xE3\xACsRy_\x7F\x8B=\x14\xD2S\xD9$0\x83\x1D;,9e\xF9\xA5x\xDAv\x18\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\xA3\xA5(\x15&/X\0\0\0\0\0\0\0\0\0\0\0\0\xBD\x91\xA7-\xC3\xD9\xB5\xD9\xB1n\xE8c\x8D\xA1\xFCe1\x1B\xD9\n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\0\0\0\0\0\0\0\0\0\0\0\0\0d\xAC\0\x7F\xF6e\xCF\x8D\r:\xF5\xE0\xAD\x1C&\xA3\xF8S\xEA\0\0\0\0\0\0\0\0\0\0\0\0\xA7g\xF7E3\x1D&|wQ)}\x98+\x05\x0C\x93\x98V'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01Q\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\x05Ad`\xDE\xB7mW\xAF`\x1B\xE1~w{\x93Y-\x8DMJ@\x96\xC5xv\xA9\x1C\x84\xF4\x18\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\xCE\x11\xE1B%WYE\xB8\xE6\xDC\rO-\xD4\xC5p\xF7\x9D\x9F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0#\x86\xF2o\xC1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x964\xCAdtt\xB6\xB7\x8D3\x823\x1Aw\xCD\0\xA8\xA9@\xDA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\x93%B)O\xF2p\xA8\xBB\xDB\xE1\xFB\x92\x1D\xE3\xD0\x9C\x97I\xDC5bsa\xFC\x17\xC4K\x9B\x02k\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x83\x90\xA1\xDA\x07\xE3v\xEFz\xDDK\xE8Y\xBAt\xFB\x83\xAA\x02\xD5\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xAE\xC1\xC9I\x98\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0i\xC6k\xEA\xFB\x06gM\xB4\x1B\"\xCF\xC5\x0C4\xA9;\x8D\x82\xA2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\xDE\xF1\xCA\x1F\xB7\xFB\xCD\xC7wR\n\xA7\xF3\x96\xB4\xE0\x15\xF4\x97\xAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02[\xF6\x19k\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xAD7\xFE=\xDE\xDF\x8C\xDE\xE1\x02-\xA1\xB1t\x12\xCF\xB6IU\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\xD6a\xA1k\x0E\x85\xEA\xDBp\\\xF5\x15\x812\xB5\xDD\x1E\xBC\nI\x92\x9E\xF6\x80\x97i\x8D\x15\xE2\xA4\xE3\xB4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xDE\x8C\x19Z\xA4\x1C\x11\xA0\xC4xsr\xDE\xFB\xBD\xDA\xA3\x13\x06\xD2\0\x02\0\0\0\0\0\0\0\0\x01\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8QV\r3\xBC\xC2k\x7F\x10v_\x8A\xE1\x0B\x1A\xBCN\xD2e\xBA\x0Cz\x1F\x99H\xD0m\xE9|1\x04J\xEE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0M\x18\x81]\x14\xFE\\3\x04\xE8{?\xA1\x83\x18\xBA\xA5\xC28 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\r\xE0\xB6\xB3\xA7d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xA9\xB2#Gs\xCCjO:4\xA7p\xC5,\x93\x1C\xBA\\$\xB2\0\x02\0\0\0\0\0\0\0\0\0\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8QCzr\xB1\x9B%\xE8\xB6/\xDF\xB8\x11F\xEC\x83\xC6db\x13\x8D=\x9E\x08\x99\x85\x94\x855f\xFA\x9A\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x17q'b,J\0\xF3\xD4\t\xB7Uq\xE1,\xB3\xC8\x97=<\0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01F\xE1\x145^\x0F`\x88\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 L\xDA\xBE\x9E\x07\xCA99C\xAC\xFB\x92\x86\xBB\xBD\r\n1\x0F\xF6\0\x02\0\0\0\0\0\0\0\0\0\\\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDAU\x9D_\xDA \xBE\x80`\x8EM^\xA1\xB4\x1Ek\x930\xEF\xCAy4\xBE\xB0\x94(\x1D\xD4\xD8\xF4\x88\x93t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0QI\x10w\x1A\xF9\xCAej\xF8@\xDF\xF8>\x82d\xEC\xF9\x86\xCA\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x07\x9E\xF7\xF1\x10\xFD\xFA\xE4\0\0\0\0\0\0\0\0\0\0\0\0\xAD7\xFE=\xDE\xDF\x8C\xDE\xE1\x02-\xA1\xB1t\x12\xCF\xB6IU\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xE9\x94\x81\xDCwi\x1D\x8E$V\xE5\xF3\xF6\x1C\x18\x10\xAD\xFC\x15\x03\0\x02\0\0\0\0\0\0\0\0\0\x18\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDAV\x87\x1A\xFB\x17\xE4D\xC4\x18\x90\x0Fm\xB3\xE1\xAD\xE0}I\xEA\xDE\xA1\xAC\xCF\x03\xFC\xEB\xC0\xA6\xE7\xE4\xB6S\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB2arF\xD0\xC6\xC0\x08\x7F\x18p=Wh1\x89\x9C\xA9O\x01\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\x8B\xCBy\xDB\xA2\xB5k\x90\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB3n\xC8=\x84L\x05y\xEC$\x93\xF1\x0B \x87\xE9k\xB6T`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\x1E\xA5j\xC9jci\xD3n\xF3\xFEV\xAE\r\xDF\xF8\xD0\xCC\x89\xE1b0\x95#\x9C\\\xEE\xD2PZ\xA2\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0j\x02<\xCD\x1F\xF6\xF2\x04\\3\tv\x8E\xAD\x9Eh\xF9x\xF6\xE1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0kC\xC2}.\x83\0\0\0\0\0\0\0\0\0\0\0\0\0\xE0\x89\x04\x90'\xB9\\'E\xD1\xA9T\xBC\x1D$SR\xD8\x84\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0(\xDB\xD3_\xD7\x9FH\xBF\xA9DM3\r\x14h>q\x01\xD8\x17\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xD1\xE8h\xD1 \xE3&\xE5X\x1C\xAA9\x85+\xB0\xDA\x924\xA5\x11\xEDv\xE6\xF7\xA9\xDC\xCE\xB0\xD5\xF1T\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\t\x8EF\x99T%\xCA\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xF0\xE8\xECQ+%\x07\xDA\xE9\x91u\xA0\xA4y-\x8AS\xE0\x86?\xBB^sZ\\\x992\x95\xBB\xD1\x7FH\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\tO\x8D\x91h\xE2q\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 F\x83\xE3@\xA8\x04\x92a\x05}Z\xB1\xB2\x9C\x8D\x84\x0Eui^\0\x02\0\0\0\0\0\0\0\0\0Z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\xD0\x03\x83\x88)\x11_]\x9F\xF3\xEDi\xC8\xD2\xB4\xB2n\x10\xEB\x1Ay3\x12\x06\xC2\x8F\xBBG49\n^\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x80\x85\x07\x12\x1B\x80\xC0#\x88\xFA\xD1G&H.\x06\x1B\x8D\xA8'\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x18\x9B#B*\x9B\x84\xD8\0\0\0\0\0\0\0\0\0\0\0\0\xAD7\xFE=\xDE\xDF\x8C\xDE\xE1\x02-\xA1\xB1t\x12\xCF\xB6IU\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xFD\x1C\xF6\xFDA\xF2)\xCA\x86\xAD\xA0XLc\xC4\x9C=f\xBB\xC9\0\x02\0\0\0\0\0\0\0\0\x048\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q9V\xEF\xD657\xB0\x0B\xB3\xB1R\xD3\xC4\x96\x12\x07\xB6\xCA\x14\xD6\xF5\x06\xC6o\xC0\xAE\xF4\xC8\xE2\xE1v\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01@\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xCBDN\x90\xD8\x19\x84\x15&lj'$\xB7\x90\x0F\xB1/\xC5n\0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0E\0\0\0\0\0\0\0\0\0\0\0\0\x15\xB4\xC6pp\xD3t\x8B\x8E\xC9<\x8A2\xF7\xEF\xE2\xE8\xF6\x84\xC9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\x05n\x98\x06\xD9S\xDB\xE2\xDFCR\xA9\n\xD2\xC1\x14\x8CQF\x0E\x94\x11\x07\xF0\x90\x9F\xAE8+\x16a\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0@\0\0\0\0\0\0\0\0\0\0\0\0\"D\x1D\x81Ad0\xA5C6\xAB(vZ\xBD1\xA7\x92\xAD7\0\0\0\0\0\0\0\0\0\0\0\0\xABp\xBC\xB2`\x07=\x03m\x16` \x1E\x9DT\x05\xF5\x82\x9Bz\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q3\xF5\x83\xD5\\E\t\xD5\xE1\x0E\xBE<|i\xBC\xE1z\xF4\xC5t\x19\xD6\xC9\xC9\x0C\x8FX\x8D\xD3#,\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\x10\xD5\x86\xA2\nL\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\xA2dipfsX\"\x12 \xC3\xB6\xB7\x01\xE7\xD5\xDBS#.\xFC\xEB\xE1\xFE\x1B\xDD@\xA3VSD\x9B\xA7\xCD\x10U\x1B\x9E[\xF6\xA9JdsolcC\0\x08\x19\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0oW_5`\xE0\x1C\x80c*\xECy\xA0\x11a\0MW\x80c*\xECy\xA0\x14a\0\xDEW\x80c\xC4Z\x01U\x14a\0\xF1W\x80c\xE4\x86\x039\x14a\x01\x1EW_\x80\xFD[\x80c\x10\x02\x9D\xAA\x14a\0sW\x80c!W\x02V\x14a\0\x9BW\x80c'$,\x9B\x14a\0\xBBW[_\x80\xFD[a\0\x86a\0\x816`\x04a$bV[a\x01>V[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xAEa\0\xA96`\x04a$bV[a\x05\x0CV[`@Qa\0\x92\x91\x90a$\xC9V[a\0\xCEa\0\xC96`\x04a$\xDBV[a\x0C\xC6V[`@Qa\0\x92\x94\x93\x92\x91\x90a&\xE9V[a\0\x86a\0\xEC6`\x04a$bV[a\x13-V[a\0\xF9a\x13@V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\x92V[a\x011a\x01,6`\x04a$bV[a\x14\x10V[`@Qa\0\x92\x91\x90a'4V[`@Q\x7FV$\xB2[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\x04\x82\x01R`\x01`$\x82\x01R_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cV$\xB2[\x90`D\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD0W=_\x80>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x02\x15\x91\x90\x81\x01\x90a(\x8AV[\x80` \x01\x90Q\x81\x01\x90a\x02(\x91\x90a(\xC4V[\x90P_s/U\xE8\xB2\r\x0B\x9F\xEF\xA1\x87\xAA}\0\xB6\xCB\xE5c`[\xF5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_s\xFD\xAF\xC9\xD1\x90/N\x0B\x84\xF6_I\xF2D\xB3+1\x01;ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s/U\xE8\xB2\r\x0B\x9F\xEF\xA1\x87\xAA}\0\xB6\xCB\xE5c`[\xF5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cQ\xCA\xD5\xEE\x87s\x90\x08\xD1\x9FX\xAA\xBD\x9E\xD0\xD6\tqVZ\xA8Q\x05`\xABAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03*W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03N\x91\x90a(\xDFV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16`\x04\x83\x01R`$\x82\x01R`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xBAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xDE\x91\x90a(\xC4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_a\x04\x01\x86a\x05\x0CV[\x80` \x01\x90Q\x81\x01\x90a\x04\x14\x91\x90a(\xF6V[\x90P_s\xFD\xAF\xC9\xD1\x90/N\x0B\x84\xF6_I\xF2D\xB3+1\x01;ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16ca\x08\xC52\x88\x84`@Q` \x01a\x04Y\x91\x90a)\xCFV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\xAD\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xC8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xEC\x91\x90a)\xE1V[\x90P\x83\x80\x15a\x04\xF8WP\x82[\x80\x15a\x05\x01WP\x80[\x97\x96PPPPPPPV[``F`\x01\x81\x90\x03a\x07\xBDWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x99A\xFD}\xB2\x003\x08\xE7\xEE\x17\xB0D\0\x01\"x\xF1*\xC6\x03a\x05lW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aH/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xB3\xBF\x81qOpG \xDC\xB05\x1F\xF0\xD4.\xCAa\xB0i\xFC\x03a\x05\xC0W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aP\xEFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s0\x10v\xC3n\x03IH\xA7G\xBBa\xBA\xB9\xCD\x03\xF6&r\xE3\x03a\x06\x14W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a6Oa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x02~\x1C\xBF,)\x9C\xBA^\xB8\xA2XI\x10\xD0O\x1A\x8A\xA4\x03\x03a\x06hW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a-/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xBE\xEFZ\xFE\x88\xEFs3~Pp\xAB(U\xD3}\xBFT\x93\xA4\x03a\x06\xBCW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aB\xEFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC6\xB1=^f/\xA0E\x8F\x03\x99[\xCB\x82J\x194\xAA\x89_\x03a\x07\x10W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aA/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xD7\xCB\x8C\xC1\xB5cV\xBB{x\xD0.x^\xAD(\xE2\x15\x86`\x03a\x07dW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a9\xCFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x07\x9C\x86\x8F\x97\xAE\xD8\xE0\xD0?\x11\xE1R\x9C;\x05o\xF2\x1C\xEA\x03a\x07\xB8W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aI\xEFa\x01\xC0\x919\x93\x92PPPV[a\x0C\xB1V[\x80`d\x03a\x0C\xB1Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xBCaY\xFDB\x9B\xE1\x82\x06\xE6\x0B;\xB0\x1Dr\x89\xF9\x05Q\x1B\x03a\x08\x19W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a.\xEFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xE5\xD1\xAA\x85e\xF5\xDB\xFC\x06\xCD\xE2\r\xFDv\xB4\xC7\xC6\xD4;\xD5\x03a\x08mW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aFoa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x9D\x85p\xEF\x9AQ\x9C\xA8\x1D\xAE\xC3R\x12\xF45\xD9\x84;\xA5d\x03a\x08\xC1W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aK\xAFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xD9|1\xE5?\x16\xF4\x95q\\\xE7\x1E\x12\xE1\x1B\x95E\xEE\xDD\x8B\x03a\t\x15W`@Q\x80a\x02@\x01`@R\x80a\x02 \x81R` \x01a0\xAFa\x02 \x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xFF\x1B\xD3\xD5p\xE3TL\x18;\xA7\x7FZM<\xC7B\xC8\xD2\xB3\x03a\tiW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aT\x8Fa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s \x9D&\x9D\xFDf\xB9\xCE\xC7d\xDE~\xB6\xFE\xFC$\xF7[\xDDH\x03a\t\xBDW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aO/a\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC3uu\xAD\x8E\xFES\x0F\xD8\xA7\x9A\xEB\0\x87\xE5\x87*$\xDA\xBC\x03a\n\x11W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a4\x8Fa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\x1Cx(\xDA\xDA\xDE\x12\xA8H\xF3k\xE8\xE2\xD3\x14db\xAB\xFFh\x03a\neW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a?oa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xAB\xA5)K\xBA}65\xC2\xA3\xE4M\x0E\x87\xEA\x7FX\x89\x8F\xB7\x03a\n\xB9W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aMoa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16sn\xB7\xBE\x97*\xEB\xB6\xBE-\x9A\xCFC|\xB4\x12\xC0\xAB\xEE\x91+\x03a\x0B\rW`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a2\xCFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC4\xD0\x99i\xAA\xD7\xF2R\xC7]\xD3R\xBB\xBDq\x9E4\xED\x06\xAD\x03a\x0BaW`@Q\x80a\x02@\x01`@R\x80a\x02 \x81R` \x01a=Oa\x02 \x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xA2Z\xF8j]\xBE\xA4^\x9F\xD7\x0C\x18yH\x9Fc\xD0\x81\xADD\x03a\x0B\xB5W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01aD\xAFa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16sWI,\xB6\xC8\xEE)\x98\xE9\xD8=\xDC\x8Cq>x\x1F\xFET\x8E\x03a\x0C\tW`@Q\x80a\x02\0\x01`@R\x80a\x01\xE0\x81R` \x01aR\xAFa\x01\xE0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16s\xC3>>\xC1EV\xA8\xE7\x1B\xE3\t\x7F\xE2\xDC\x8C\x0B\x91\x19\xC8\x97\x03a\x0C]W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a8\x0Fa\x01\xC0\x919\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16swG(&\x87YS7N\xD3\x08L1\xA4\x83\xF8'\x98\x7F\x14\x03a\x0C\xB1W`@Q\x80a\x01\xE0\x01`@R\x80a\x01\xC0\x81R` \x01a;\x8Fa\x01\xC0\x919\x93\x92PPPV[PP`@\x80Q` \x81\x01\x90\x91R_\x81R\x91\x90PV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``\x80\x80`\x02\x85\x14a\rdW`@Q\x7F\x9D\x89\x02\n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``a\ro\x88a\x13-V[a\x12\xE9Wa\r|\x88a\x16\x96V[a\r\xE7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FPool is not a CoW AMM\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EU\x91\x90a(\xC4V[\x90P_\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xA1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xC5\x91\x90a(\xC4V[\x90P\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cJ\xDA!\x8B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x10W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F4\x91\x90a)\xE1V[\x15\x15_\x03a\x0FnW`@Q\x7F!\x08\x1A\xBF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x10\x81`@Q\x80`\xC0\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B\x8B`\x01\x81\x81\x10a\x0F\xE3Wa\x0F\xE3a*\0V[\x90P` \x02\x015\x81R` \x01\x8B\x8B_\x81\x81\x10a\x10\x01Wa\x10\x01a*\0V[\x90P` \x02\x015\x81R` \x01\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cm\xBC\x88\x13`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10VW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10z\x91\x90a(\xDFV[\x90Ra\x17NV[\x96P\x86`@Q` \x01a\x10\x94\x91\x90a*-V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R`\x01\x80\x84R\x83\x83\x01\x90\x92R\x94P\x81` \x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x10\xD1W\x90PP\x95P`@Q\x80``\x01`@R\x80\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01a\x12;s\x90\x08\xD1\x9FX\xAA\xBD\x9E\xD0\xD6\tqVZ\xA8Q\x05`\xABAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x8EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xB2\x91\x90a(\xDFV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x8B\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[`@Q`$\x01a\x12M\x91\x81R` \x01\x90V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xF1O\xCB\xC8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90R\x86Q\x87\x90_\x90a\x12\xD7Wa\x12\xD7a*\0V[` \x02` \x01\x01\x81\x90RPPPa\x12\xFFV[a\x12\xF4\x88\x88\x88a\x1A\xD6V[\x92\x97P\x90\x95P\x93P\x90P[\x87\x81`@Q` \x01a\x13\x12\x92\x91\x90a*<V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x93P\x93P\x93P\x93V[_\x80a\x138\x83a\x05\x0CV[Q\x11\x92\x91PPV[_F`\x01\x81\x90\x03a\x13fWs\x8D\xEE\xD8\xED|_\xCBU\x88O\x13\xF1!eK\xB4\xBB|\x847\x91PP\x90V[\x80`d\x03a\x13\x89Ws*\xF6\xC5\x9F\xC9W\xD4\xA4]\xDB\xBD\x92\x7F\xA3\x0F|PQ\xF5\x83\x91PP\x90V[\x80b\xAA6\xA7\x03a\x13\xAEWs\xBD\x18u\x80U\xDB\xE3\xED7\xA2G\x13\x94U\x9A\xE9z]\xA5\xC0\x91PP\x90V[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUnsupported chain\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\r\xDEV[`@\x80Q`\x02\x80\x82R``\x80\x83\x01\x84R\x92` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa\x149\x82a\x13-V[a\x15\xB5W\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\x86W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xAA\x91\x90a(\xC4V[\x81_\x81Q\x81\x10a\x14\xBCWa\x14\xBCa*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15?W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15c\x91\x90a(\xC4V[\x81`\x01\x81Q\x81\x10a\x15vWa\x15va*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x91\x90PV[_a\x15\xBF\x83a!_V[P\x90P\x80_\x81Q\x81\x10a\x15\xD4Wa\x15\xD4a*\0V[` \x02` \x01\x01Q\x82_\x81Q\x81\x10a\x15\xEEWa\x15\xEEa*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x80`\x01\x81Q\x81\x10a\x16;Wa\x16;a*\0V[` \x02` \x01\x01Q\x82`\x01\x81Q\x81\x10a\x16VWa\x16Va*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPP\x91\x90PV[_\x80a\x16\xA0a\x13@V[`@Q\x7Ffn\x1B9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`\x04\x83\x01R\x91\x90\x91\x16\x90cfn\x1B9\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x170\x91\x90a(\xC4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x92\x91PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R` \x82\x01Q\x82Q`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16`\x04\x82\x01R_\x92\x83\x92\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\"W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18F\x91\x90a(\xDFV[`@\x85\x81\x01Q\x86Q\x91Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16`\x04\x82\x01R\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18\xDB\x91\x90a(\xDFV[\x91P\x91P_\x80_\x80_\x88`\x80\x01Q\x87a\x18\xF4\x91\x90a*\xAEV[\x90P_\x89``\x01Q\x87a\x19\x07\x91\x90a*\xAEV[\x90P\x81\x81\x10\x15a\x19mW\x89` \x01Q\x95P\x89`@\x01Q\x94Pa\x199\x81\x8B`\x80\x01Q`\x02a\x194\x91\x90a*\xAEV[a\"{V[a\x19D`\x02\x8Aa*\xF2V[a\x19N\x91\x90a+\x05V[\x93Pa\x19f\x84\x88a\x19_\x82\x8Ca+\x05V[`\x01a\"\xCBV[\x92Pa\x19\xB9V[\x89`@\x01Q\x95P\x89` \x01Q\x94Pa\x19\x90\x82\x8B``\x01Q`\x02a\x194\x91\x90a*\xAEV[a\x19\x9B`\x02\x89a*\xF2V[a\x19\xA5\x91\x90a+\x05V[\x93Pa\x19\xB6\x84\x89a\x19_\x82\x8Ba+\x05V[\x92P[`@Q\x80a\x01\x80\x01`@R\x80\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85\x81R` \x01\x84\x81R` \x01a\x01,Ba\x1A3\x91\x90a+\x18V[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B`\xA0\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x98PPPPPPPPP\x91\x90PV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``\x80``a\x1BD\x87a\x01>V[a\x1BzW`@Q\x7F\xEF\xC8i\xB4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x85\x89a!_V[\x91P\x91P_\x81`@\x01Q\x80` \x01\x90Q\x81\x01\x90a\x1B\xA2\x91\x90a+<V[\x90Pa\x1C\x83`@Q\x80`\xC0\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85_\x81Q\x81\x10a\x1B\xE0Wa\x1B\xE0a*\0V[` \x02` \x01\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85`\x01\x81Q\x81\x10a\x1C\x16Wa\x1C\x16a*\0V[` \x02` \x01\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B\x8B`\x01\x81\x81\x10a\x1CLWa\x1CLa*\0V[\x90P` \x02\x015\x81R` \x01\x8B\x8B_\x81\x81\x10a\x1CjWa\x1Cja*\0V[\x90P` \x02\x015\x81R` \x01\x83`\xA0\x01Q\x81RPa\x17NV[\x96P_s\x90\x08\xD1\x9FX\xAA\xBD\x9E\xD0\xD6\tqVZ\xA8Q\x05`\xABAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C\xE3W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1D\x07\x91\x90a(\xDFV[\x90P\x80\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x89`@Q` \x01a\x1D<\x91\x90a*-V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R_``\x84\x01\x81\x81R`\x80\x85\x01\x84R\x84R` \x80\x85\x01\x8A\x90R\x83Q\x80\x82\x01\x85R\x91\x82R\x84\x84\x01\x91\x90\x91R\x91Q\x90\x92a\x1D\xA0\x92\x90\x91\x01a+\xF4V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x1D\xDE\x94\x93\x92\x91`$\x01a,\x9DV[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R` \x80\x83\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F_\xD7\xE9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x81Q`\x01\x80\x82R\x81\x84\x01\x90\x93R\x92\x97P\x82\x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x1EhW\x90PP`@\x80Q``\x81\x01\x82R\x85Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R_` \x82\x01R\x91\x98P\x81\x01\x8Ca\x1FU\x8B\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x91\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16`$\x83\x01R`D\x82\x01R`d\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F0\xF7<\x99\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90R\x87Q\x88\x90_\x90a \x07Wa \x07a*\0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x90\x81` \x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a 'W\x90PP\x95P`@Q\x80``\x01`@R\x80\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01\x8C_\x80\x1B`@Q`$\x01a \xBD\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F0\xF7<\x99\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90R\x86Q\x87\x90_\x90a!GWa!Ga*\0V[` \x02` \x01\x01\x81\x90RPPPPP\x93P\x93P\x93P\x93V[`@\x80Q``\x81\x81\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x82\x90Ra!\x82\x83a\x05\x0CV[\x80` \x01\x90Q\x81\x01\x90a!\x95\x91\x90a(\xF6V[\x90P_\x81`@\x01Q\x80` \x01\x90Q\x81\x01\x90a!\xB0\x91\x90a+<V[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x92\x93P\x91\x90` \x83\x01\x90\x806\x837\x01\x90PP\x92P\x80_\x01Q\x83_\x81Q\x81\x10a!\xE9Wa!\xE9a*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x80` \x01Q\x83`\x01\x81Q\x81\x10a\";Wa\";a*\0V[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPP\x91P\x91V[_\x81_\x03a\"\x94Wa\"\x8D\x82\x84a*\xF2V[\x90Pa\"\xC5V[\x82\x15a\"\xC0W\x81a\"\xA6`\x01\x85a+\x05V[a\"\xB0\x91\x90a*\xF2V[a\"\xBB\x90`\x01a,\xCDV[a\"\xC2V[_[\x90P[\x92\x91PPV[_\x80a\"\xD8\x86\x86\x86a#\x1AV[\x90Pa\"\xE3\x83a$\x12V[\x80\x15a\"\xFEWP_\x84\x80a\"\xF9Wa\"\xF9a*\xC5V[\x86\x88\t\x11[\x15a#\x11Wa#\x0E`\x01\x82a,\xCDV[\x90P[\x95\x94PPPPPV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a#mW\x83\x82\x81a#cWa#ca*\xC5V[\x04\x92PPPa$\x0BV[\x80\x84\x11a#\xA6W`@Q\x7F\"{\xC1S\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP[\x93\x92PPPV[_`\x02\x82`\x03\x81\x11\x15a$'Wa$'a,\xE0V[a$1\x91\x90a-\rV[`\xFF\x16`\x01\x14\x90P\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a$_W_\x80\xFD[PV[_` \x82\x84\x03\x12\x15a$rW_\x80\xFD[\x815a$\x0B\x81a$>V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\"\xC2` \x83\x01\x84a$}V[_\x80_`@\x84\x86\x03\x12\x15a$\xEDW_\x80\xFD[\x835a$\xF8\x81a$>V[\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a%\x14W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a%'W_\x80\xFD[\x815\x81\x81\x11\x15a%5W_\x80\xFD[\x87` \x82`\x05\x1B\x85\x01\x01\x11\x15a%IW_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa%\x9D` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa%\xC5`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa%\xF1`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa&&\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x82\x82Q\x80\x85R` \x80\x86\x01\x95P\x80\x82`\x05\x1B\x84\x01\x01\x81\x86\x01_[\x84\x81\x10\x15a&\xDCW\x85\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x89R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84R\x84\x81\x01Q\x85\x85\x01R`@\x90\x81\x01Q``\x91\x85\x01\x82\x90R\x90a&\xC8\x81\x86\x01\x83a$}V[\x9A\x86\x01\x9A\x94PPP\x90\x83\x01\x90`\x01\x01a&ZV[P\x90\x97\x96PPPPPPPV[_a\x01\xE0a&\xF7\x83\x88a%\\V[\x80a\x01\x80\x84\x01Ra'\n\x81\x84\x01\x87a&?V[\x90P\x82\x81\x03a\x01\xA0\x84\x01Ra'\x1F\x81\x86a&?V[\x90P\x82\x81\x03a\x01\xC0\x84\x01Ra\x05\x01\x81\x85a$}V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15a'\x81W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R\x92\x84\x01\x92\x91\x84\x01\x91`\x01\x01a'OV[P\x90\x96\x95PPPPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\xC0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a'\xDDWa'\xDDa'\x8DV[`@R\x90V[_\x82`\x1F\x83\x01\x12a'\xF2W_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a(\rWa(\ra'\x8DV[`@Q`\x1F\x83\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x16`?\x01\x16\x81\x01\x90\x82\x82\x11\x81\x83\x10\x17\x15a(SWa(Sa'\x8DV[\x81`@R\x83\x81R\x86` \x85\x88\x01\x01\x11\x15a(kW_\x80\xFD[\x83` \x87\x01` \x83\x01^_` \x85\x83\x01\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a(\x9AW_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a(\xB0W_\x80\xFD[a(\xBC\x84\x82\x85\x01a'\xE3V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a(\xD4W_\x80\xFD[\x81Qa$\x0B\x81a$>V[_` \x82\x84\x03\x12\x15a(\xEFW_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a)\x06W_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a)\x1DW_\x80\xFD[\x90\x83\x01\x90``\x82\x86\x03\x12\x15a)0W_\x80\xFD[`@Q``\x81\x01\x81\x81\x10\x83\x82\x11\x17\x15a)KWa)Ka'\x8DV[`@R\x82Qa)Y\x81a$>V[\x81R` \x83\x81\x01Q\x90\x82\x01R`@\x83\x01Q\x82\x81\x11\x15a)vW_\x80\xFD[a)\x82\x87\x82\x86\x01a'\xE3V[`@\x83\x01RP\x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x82R` \x81\x01Q` \x83\x01R_`@\x82\x01Q```@\x85\x01Ra(\xBC``\x85\x01\x82a$}V[` \x81R_a\"\xC2` \x83\x01\x84a)\x91V[_` \x82\x84\x03\x12\x15a)\xF1W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a$\x0BW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[a\x01\x80\x81\x01a\"\xC5\x82\x84a%\\V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x83``\x1B\x16\x81R_\x82Q\x80` \x85\x01`\x14\x85\x01^_\x92\x01`\x14\x01\x91\x82RP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\"\xC5Wa\"\xC5a*\x81V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a+\0Wa+\0a*\xC5V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\"\xC5Wa\"\xC5a*\x81V[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a+5Wa+5a*\x81V[P\x92\x91PPV[_` \x82\x84\x03\x12\x15a+LW_\x80\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a+cW_\x80\xFD[\x90\x83\x01\x90`\xC0\x82\x86\x03\x12\x15a+vW_\x80\xFD[a+~a'\xBAV[\x82Qa+\x89\x81a$>V[\x81R` \x83\x01Qa+\x99\x81a$>V[` \x82\x01R`@\x83\x81\x01Q\x90\x82\x01R``\x83\x01Qa+\xB6\x81a$>V[``\x82\x01R`\x80\x83\x01Q\x82\x81\x11\x15a+\xCCW_\x80\xFD[a+\xD8\x87\x82\x86\x01a'\xE3V[`\x80\x83\x01RP`\xA0\x83\x01Q`\xA0\x82\x01R\x80\x93PPPP\x92\x91PPV[` \x80\x82R\x82Q``\x83\x83\x01R\x80Q`\x80\x84\x01\x81\x90R_\x92\x91\x82\x01\x90\x83\x90`\xA0\x86\x01\x90[\x80\x83\x10\x15a,8W\x83Q\x82R\x92\x84\x01\x92`\x01\x92\x90\x92\x01\x91\x90\x84\x01\x90a,\x18V[P\x83\x87\x01Q\x93P\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x92P\x82\x86\x82\x03\x01`@\x87\x01Ra,v\x81\x85a)\x91V[\x93PPP`@\x85\x01Q\x81\x85\x84\x03\x01``\x86\x01Ra,\x93\x83\x82a$}V[\x96\x95PPPPPPV[\x84\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a,\xBB`\x80\x83\x01\x85a$}V[\x82\x81\x03``\x84\x01Ra\x05\x01\x81\x85a$}V[\x80\x82\x01\x80\x82\x11\x15a\"\xC5Wa\"\xC5a*\x81V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_`\xFF\x83\x16\x80a-\x1FWa-\x1Fa*\xC5V[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\xC5\xA0\xE7V\xAC\x88\xC1\xD3\xA4\xC4\x19\0\xD9w\xFE\x93\xC2\xD3O\xC9Z\0\xCA>\x84\xEBLkP\xFA\xF9I\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0Z\xFE8U5\x8E\x11+VG\xB9Rp\x9Eae\xE1\xC1\xEE\xEE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01cEx]\x8A\0\0\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0.~\x97\x8D\xA0\xC54\x04\xA8\xCFf\xEDK\xA2\xC7pl\x07\xB6*\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xD8\\\x99\x99m\x84\xD2S\x87\xBC\r\x01\xE5\x0E>\xA8\x14\xF6N~\x04\xA3\xB9I\xA5qx\x9E\x19lZ\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0j\x02<\xCD\x1F\xF6\xF2\x04\\3\tv\x8E\xAD\x9Eh\xF9x\xF6\xE1\0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n\xFF\xD9\xFD\xEB\x8E\x08\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xA9\x9F\xD9\x95\x0B]]\xCE\xEA\xF4\x93\x9E\"\x1D\xCA\x8C\xA9\xB98\xAB\0\x01\0\0\0\0\0\0\0\0\0%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Qx\xA7)\xEE0\x08\xC7\xD4\x882\xD0\"g\xB7._4\xAD\xA8\xF5T\xA6s\x1A6\x8F\x01Y\x0E\xD7\x1B4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xCBDN\x90\xD8\x19\x84\x15&lj'$\xB7\x90\x0F\xB1/\xC5n\0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V\x19zT%\xC0\xC8\0\0\0\0\0\0\0\0\0\0\0\0\xBD\x91\xA7-\xC3\xD9\xB5\xD9\xB1n\xE8c\x8D\xA1\xFCe1\x1B\xD9\n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\0\0\0\0\0\0\0\0\0\0\0\0\xABp\xBC\xB2`\x07=\x03m\x16` \x1E\x9DT\x05\xF5\x82\x9Bz\0\0\0\0\0\0\0\0\0\0\0\0g\x8D\xF3A_\xC3\x19G\xDAC$\xECc!(t\xBEZ\x82\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01Q\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q.1\x98\x1E4\x96\ti\xEBT\x9F^\x82l\xF7\x7Fe^r\xB06\x03\xADWJy\xFD\x01_M\xE4\xDE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n\x16\xC9ZM.<\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\xCE\x9E\x05\xC2\xAE\xE5\xF2/\x99A\xC4\xCD\x1F\x1A\x1D\x13\x19K\x10\x97yB-Z\xD9\xA9\x80\x15{\xD0\xF1d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xA2\x02\x9F\xBBTYx\xD0Sx\xB6\xDF\x19\xE3uO\xE5\xED-\x0B\xA1\xE0Q\x02u\x03\x93Cr\xF7\xBE\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\x17q'b,J\0\xF3\xD4\t\xB7Uq\xE1,\xB3\xC8\x97=<\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0R\xBA\x9E\xFC8D\x1A\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 !\xD4\xC7\x92\xEA~8\xE0\xD0\x81\x9C \x11\xA2\xB1\xCBrR\xBD\x99\0\x02\0\0\0\0\0\0\0\0\0\x1E\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\xCAD\xB6\xA3\x04\xBA\xA1m\x11\xB6\xDB\x07\x06l\x12v\xB1'>\xE3\xF9E\x90\xBB\xD02\x01\xA6\x18\x82\xAF\x9A\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xA0\xB8i\x91\xC6!\x8B6\xC1\xD1\x9DJ.\x9E\xB0\xCE6\x06\xEBH\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\xCBv\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB4\xE1m\x01h\xE5-5\xCA\xCD,a\x85\xB4B\x81\xEC(\xC9\xDC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8QYEz\xC6 \x1D\xA7q>\xFE\xCD\x84a\x8Cz\x16\x8E\x88\xB9\xCB}\x1C\r\xB1(\xAF\x1E\xFE\n\x08\xBB\xB1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\n\x17'?\xC1Kd\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\x80\xBAS?\x01N\xF4#\x8A\xB7\xAD <\n\xEA\xCB\xF3\nq\xC04a@\xDBw\xC4:\xE3\x12\x1A\xFA\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xAE\xA4j`6\x8A{\xD0`\xEE\xC7\xDF\x8C\xBAC\xB7\xEFA\xAD\x85\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x003f2\xE5<\x8E\xCF\x04\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0@B\xA0LT\xEF\x13:\xC2\xA3\xC9=\xB6\x9DC\xC6\xC0*3\x0B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xD6|\x9F\xB8pE\xE0}\xA9L\x81\xDE\x03[\\\x7FC\\\xD4eh\xFC\xA0*\xA3]p\x9B\xBC\x9E!\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x8E[\xBB\xB0\x9E\xD1\xEB\xDE\x86t\xCD\xA3\x9A\x0C\x16\x94\x01\xDBBR\0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0'\x10\0\0\0\0\0\0\0\0\0\0\0\0\xE0\x89\x04\x90'\xB9\\'E\xD1\xA9T\xBC\x1D$SR\xD8\x84\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x8D\xB8\x87\x0C\xA4\xB8\xAC\x18\x8CM\x1A\x01O4\xA3\x81\xAE'\xE1\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q \x9C\x17\xD9\xEB\xE3\xACsRy_\x7F\x8B=\x14\xD2S\xD9$0\x83\x1D;,9e\xF9\xA5x\xDAv\x18\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xE9\x1D\x15>\x0BAQ\x8A,\xE8\xDD=yD\xFA\x864c\xA9}\0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\xA3\xA5(\x15&/X\0\0\0\0\0\0\0\0\0\0\0\0\xBD\x91\xA7-\xC3\xD9\xB5\xD9\xB1n\xE8c\x8D\xA1\xFCe1\x1B\xD9\n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\0\0\0\0\0\0\0\0\0\0\0\0\0d\xAC\0\x7F\xF6e\xCF\x8D\r:\xF5\xE0\xAD\x1C&\xA3\xF8S\xEA\0\0\0\0\0\0\0\0\0\0\0\0\xA7g\xF7E3\x1D&|wQ)}\x98+\x05\x0C\x93\x98V'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01Q\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\x05Ad`\xDE\xB7mW\xAF`\x1B\xE1~w{\x93Y-\x8DMJ@\x96\xC5xv\xA9\x1C\x84\xF4\x18\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\xCE\x11\xE1B%WYE\xB8\xE6\xDC\rO-\xD4\xC5p\xF7\x9D\x9F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0#\x86\xF2o\xC1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x964\xCAdtt\xB6\xB7\x8D3\x823\x1Aw\xCD\0\xA8\xA9@\xDA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\x93%B)O\xF2p\xA8\xBB\xDB\xE1\xFB\x92\x1D\xE3\xD0\x9C\x97I\xDC5bsa\xFC\x17\xC4K\x9B\x02k\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x83\x90\xA1\xDA\x07\xE3v\xEFz\xDDK\xE8Y\xBAt\xFB\x83\xAA\x02\xD5\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xAE\xC1\xC9I\x98\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0i\xC6k\xEA\xFB\x06gM\xB4\x1B\"\xCF\xC5\x0C4\xA9;\x8D\x82\xA2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\xDE\xF1\xCA\x1F\xB7\xFB\xCD\xC7wR\n\xA7\xF3\x96\xB4\xE0\x15\xF4\x97\xAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02[\xF6\x19k\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xAD7\xFE=\xDE\xDF\x8C\xDE\xE1\x02-\xA1\xB1t\x12\xCF\xB6IU\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\xD6a\xA1k\x0E\x85\xEA\xDBp\\\xF5\x15\x812\xB5\xDD\x1E\xBC\nI\x92\x9E\xF6\x80\x97i\x8D\x15\xE2\xA4\xE3\xB4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xDE\x8C\x19Z\xA4\x1C\x11\xA0\xC4xsr\xDE\xFB\xBD\xDA\xA3\x13\x06\xD2\0\x02\0\0\0\0\0\0\0\0\x01\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8QV\r3\xBC\xC2k\x7F\x10v_\x8A\xE1\x0B\x1A\xBCN\xD2e\xBA\x0Cz\x1F\x99H\xD0m\xE9|1\x04J\xEE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0M\x18\x81]\x14\xFE\\3\x04\xE8{?\xA1\x83\x18\xBA\xA5\xC28 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\r\xE0\xB6\xB3\xA7d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xA9\xB2#Gs\xCCjO:4\xA7p\xC5,\x93\x1C\xBA\\$\xB2\0\x02\0\0\0\0\0\0\0\0\0\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8QCzr\xB1\x9B%\xE8\xB6/\xDF\xB8\x11F\xEC\x83\xC6db\x13\x8D=\x9E\x08\x99\x85\x94\x855f\xFA\x9A\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x17q'b,J\0\xF3\xD4\t\xB7Uq\xE1,\xB3\xC8\x97=<\0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01F\xE1\x145^\x0F`\x88\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 L\xDA\xBE\x9E\x07\xCA99C\xAC\xFB\x92\x86\xBB\xBD\r\n1\x0F\xF6\0\x02\0\0\0\0\0\0\0\0\0\\\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDAU\x9D_\xDA \xBE\x80`\x8EM^\xA1\xB4\x1Ek\x930\xEF\xCAy4\xBE\xB0\x94(\x1D\xD4\xD8\xF4\x88\x93t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0QI\x10w\x1A\xF9\xCAej\xF8@\xDF\xF8>\x82d\xEC\xF9\x86\xCA\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x07\x9E\xF7\xF1\x10\xFD\xFA\xE4\0\0\0\0\0\0\0\0\0\0\0\0\xAD7\xFE=\xDE\xDF\x8C\xDE\xE1\x02-\xA1\xB1t\x12\xCF\xB6IU\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xE9\x94\x81\xDCwi\x1D\x8E$V\xE5\xF3\xF6\x1C\x18\x10\xAD\xFC\x15\x03\0\x02\0\0\0\0\0\0\0\0\0\x18\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDAV\x87\x1A\xFB\x17\xE4D\xC4\x18\x90\x0Fm\xB3\xE1\xAD\xE0}I\xEA\xDE\xA1\xAC\xCF\x03\xFC\xEB\xC0\xA6\xE7\xE4\xB6S\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB2arF\xD0\xC6\xC0\x08\x7F\x18p=Wh1\x89\x9C\xA9O\x01\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\x8B\xCBy\xDB\xA2\xB5k\x90\0\0\0\0\0\0\0\0\0\0\0\0W<\xC0\xC8\0\x04\x8F\x94\xE0\"F;\x92\x14\xD9,-e\xE9{\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB3n\xC8=\x84L\x05y\xEC$\x93\xF1\x0B \x87\xE9k\xB6T`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\x1E\xA5j\xC9jci\xD3n\xF3\xFEV\xAE\r\xDF\xF8\xD0\xCC\x89\xE1b0\x95#\x9C\\\xEE\xD2PZ\xA2\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0j\x02<\xCD\x1F\xF6\xF2\x04\\3\tv\x8E\xAD\x9Eh\xF9x\xF6\xE1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0kC\xC2}.\x83\0\0\0\0\0\0\0\0\0\0\0\0\0\xE0\x89\x04\x90'\xB9\\'E\xD1\xA9T\xBC\x1D$SR\xD8\x84\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0(\xDB\xD3_\xD7\x9FH\xBF\xA9DM3\r\x14h>q\x01\xD8\x17\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xD1\xE8h\xD1 \xE3&\xE5X\x1C\xAA9\x85+\xB0\xDA\x924\xA5\x11\xEDv\xE6\xF7\xA9\xDC\xCE\xB0\xD5\xF1T\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\t\x8EF\x99T%\xCA\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q\xF0\xE8\xECQ+%\x07\xDA\xE9\x91u\xA0\xA4y-\x8AS\xE0\x86?\xBB^sZ\\\x992\x95\xBB\xD1\x7FH\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\tO\x8D\x91h\xE2q\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 F\x83\xE3@\xA8\x04\x92a\x05}Z\xB1\xB2\x9C\x8D\x84\x0Eui^\0\x02\0\0\0\0\0\0\0\0\0Z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\x0042;\x930\x96SNC\x95\x8Fl{\xF4O+\xB5\x94$\xDA\xD0\x03\x83\x88)\x11_]\x9F\xF3\xEDi\xC8\xD2\xB4\xB2n\x10\xEB\x1Ay3\x12\x06\xC2\x8F\xBBG49\n^\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\x80\x85\x07\x12\x1B\x80\xC0#\x88\xFA\xD1G&H.\x06\x1B\x8D\xA8'\0\0\0\0\0\0\0\0\0\0\0\0\xC0*\xAA9\xB2#\xFE\x8D\n\x0E\\O'\xEA\xD9\x08<ul\xC2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x18\x9B#B*\x9B\x84\xD8\0\0\0\0\0\0\0\0\0\0\0\0\xAD7\xFE=\xDE\xDF\x8C\xDE\xE1\x02-\xA1\xB1t\x12\xCF\xB6IU\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xFD\x1C\xF6\xFDA\xF2)\xCA\x86\xAD\xA0XLc\xC4\x9C=f\xBB\xC9\0\x02\0\0\0\0\0\0\0\0\x048\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q9V\xEF\xD657\xB0\x0B\xB3\xB1R\xD3\xC4\x96\x12\x07\xB6\xCA\x14\xD6\xF5\x06\xC6o\xC0\xAE\xF4\xC8\xE2\xE1v\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01@\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xCBDN\x90\xD8\x19\x84\x15&lj'$\xB7\x90\x0F\xB1/\xC5n\0\0\0\0\0\0\0\0\0\0\0\0\x9CX\xBA\xCC3\x1C\x9A\xA8q\xAF\xD8\x02\xDBcy\xA9\x8E\x80\xCE\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0E\0\0\0\0\0\0\0\0\0\0\0\0\x15\xB4\xC6pp\xD3t\x8B\x8E\xC9<\x8A2\xF7\xEF\xE2\xE8\xF6\x84\xC9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0\x05n\x98\x06\xD9S\xDB\xE2\xDFCR\xA9\n\xD2\xC1\x14\x8CQF\x0E\x94\x11\x07\xF0\x90\x9F\xAE8+\x16a\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0@\0\0\0\0\0\0\0\0\0\0\0\0\"D\x1D\x81Ad0\xA5C6\xAB(vZ\xBD1\xA7\x92\xAD7\0\0\0\0\0\0\0\0\0\0\0\0\xABp\xBC\xB2`\x07=\x03m\x16` \x1E\x9DT\x05\xF5\x82\x9Bz\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xB1H\xF4\x0F\xFF\x05\xB5\xCEk\"u,\xF8\xE4T\xB5V\xF7\xA8Q3\xF5\x83\xD5\\E\t\xD5\xE1\x0E\xBE<|i\xBC\xE1z\xF4\xC5t\x19\xD6\xC9\xC9\x0C\x8FX\x8D\xD3#,\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0\xAF Gv\xC7$[\xF4\x14|&\x12\xBFnYr\xEEH7\x01\0\0\0\0\0\0\0\0\0\0\0\0lv\x97\x1F\x98\x94Z\xE9\x8D\xD7\xD4\xDF\xCA\x87\x11\xEB\xEA\x94n\xA6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\x10\xD5\x86\xA2\nL\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xD3\xA8H\x95\x08\x06\t\xE1\x16<\x80\xB2\xBDesm\xB1\xB8k\xEC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xC0M\x82\x1D\xDC\x9Deaw\xDA\xD4\xD5\xC2\xF7jK\xFF.\xD5\x14\xFFi\xFAJ\xA4\xFD\x86\x9Dn\x98\xD5\\\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \xBC*\xCF^\x82\x1C\\\x9F\x86g\xA3k\xB1\x13\x1D\xAD&\xEDd\xF9\0\x02\0\0\0\0\0\0\0\0\0c\xA2dipfsX\"\x12 \xC3\xB6\xB7\x01\xE7\xD5\xDBS#.\xFC\xEB\xE1\xFE\x1B\xDD@\xA3VSD\x9B\xA7\xCD\x10U\x1B\x9E[\xF6\xA9JdsolcC\0\x08\x19\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidArrayLength()` and selector `0x9d89020a`.
+    ```solidity
+    error InvalidArrayLength();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidArrayLength;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidArrayLength> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidArrayLength) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidArrayLength {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidArrayLength {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [157u8, 137u8, 2u8, 10u8];
+            const SIGNATURE: &'static str = "InvalidArrayLength()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `MathOverflowedMulDiv()` and selector `0x227bc153`.
+    ```solidity
+    error MathOverflowedMulDiv();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MathOverflowedMulDiv;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<MathOverflowedMulDiv> for UnderlyingRustTuple<'_> {
+            fn from(value: MathOverflowedMulDiv) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MathOverflowedMulDiv {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for MathOverflowedMulDiv {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [34u8, 123u8, 193u8, 83u8];
+            const SIGNATURE: &'static str = "MathOverflowedMulDiv()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NoOrder()` and selector `0x19aad573`.
+    ```solidity
+    error NoOrder();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NoOrder;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NoOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: NoOrder) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NoOrder {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NoOrder {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [25u8, 170u8, 213u8, 115u8];
+            const SIGNATURE: &'static str = "NoOrder()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `PoolDoesNotExist()` and selector `0x9c8787c0`.
+    ```solidity
+    error PoolDoesNotExist();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PoolDoesNotExist;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PoolDoesNotExist> for UnderlyingRustTuple<'_> {
+            fn from(value: PoolDoesNotExist) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PoolDoesNotExist {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for PoolDoesNotExist {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [156u8, 135u8, 135u8, 192u8];
+            const SIGNATURE: &'static str = "PoolDoesNotExist()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `PoolIsClosed()` and selector `0xefc869b4`.
+    ```solidity
+    error PoolIsClosed();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PoolIsClosed;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PoolIsClosed> for UnderlyingRustTuple<'_> {
+            fn from(value: PoolIsClosed) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PoolIsClosed {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for PoolIsClosed {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [239u8, 200u8, 105u8, 180u8];
+            const SIGNATURE: &'static str = "PoolIsClosed()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `PoolIsPaused()` and selector `0x21081abf`.
+    ```solidity
+    error PoolIsPaused();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PoolIsPaused;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PoolIsPaused> for UnderlyingRustTuple<'_> {
+            fn from(value: PoolIsPaused) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PoolIsPaused {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for PoolIsPaused {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 8u8, 26u8, 191u8];
+            const SIGNATURE: &'static str = "PoolIsPaused()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `COWAMMPoolCreated(address)` and selector `0x0d03834d0d86c7f57e877af40e26f176dc31bd637535d4ba153d1ac9de88a7ea`.
+    ```solidity
+    event COWAMMPoolCreated(address indexed amm);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct COWAMMPoolCreated {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for COWAMMPoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "COWAMMPoolCreated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    13u8, 3u8, 131u8, 77u8, 13u8, 134u8, 199u8, 245u8, 126u8, 135u8, 122u8, 244u8,
+                    14u8, 38u8, 241u8, 118u8, 220u8, 49u8, 189u8, 99u8, 117u8, 53u8, 212u8, 186u8,
+                    21u8, 61u8, 26u8, 201u8, 222u8, 136u8, 167u8, 234u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { amm: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.amm.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.amm,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for COWAMMPoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&COWAMMPoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &COWAMMPoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {}
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSnapshot(address)` and selector `0x21570256`.
+    ```solidity
+    function getSnapshot(address amm) external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSnapshotCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSnapshot(address)`](getSnapshotCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSnapshotReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSnapshotCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSnapshotCall) -> Self {
+                    (value.amm,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSnapshotCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amm: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSnapshotReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSnapshotReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSnapshotReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSnapshotCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 87u8, 2u8, 86u8];
+            const SIGNATURE: &'static str = "getSnapshot(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSnapshotReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSnapshotReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isLegacy(address)` and selector `0x2aec79a0`.
+    ```solidity
+    function isLegacy(address amm) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isLegacyCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isLegacy(address)`](isLegacyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isLegacyReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isLegacyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isLegacyCall) -> Self {
+                    (value.amm,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amm: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isLegacyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isLegacyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isLegacyCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [42u8, 236u8, 121u8, 160u8];
+            const SIGNATURE: &'static str = "isLegacy(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isLegacyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isLegacyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isLegacyEnabled(address)` and selector `0x10029daa`.
+    ```solidity
+    function isLegacyEnabled(address amm) external view returns (bool success);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isLegacyEnabledCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isLegacyEnabled(address)`](isLegacyEnabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isLegacyEnabledReturn {
+        #[allow(missing_docs)]
+        pub success: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isLegacyEnabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isLegacyEnabledCall) -> Self {
+                    (value.amm,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyEnabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amm: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isLegacyEnabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isLegacyEnabledReturn) -> Self {
+                    (value.success,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyEnabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { success: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isLegacyEnabledCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [16u8, 2u8, 157u8, 170u8];
+            const SIGNATURE: &'static str = "isLegacyEnabled(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isLegacyEnabledReturn = r.into();
+                        r.success
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isLegacyEnabledReturn = r.into();
+                    r.success
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `order(address,uint256[])` and selector `0x27242c9b`.
+    ```solidity
+    function order(address pool, uint256[] memory prices) external view returns (GPv2Order.Data memory _order, GPv2Interaction.Data[] memory preInteractions, GPv2Interaction.Data[] memory postInteractions, bytes memory sig);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct orderCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub prices:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`order(address,uint256[])`](orderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct orderReturn {
+        #[allow(missing_docs)]
+        pub _order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub preInteractions: alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub postInteractions: alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sig: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<orderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: orderCall) -> Self {
+                    (value.pool, value.prices)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for orderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        pool: tuple.0,
+                        prices: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                GPv2Order::Data,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<orderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: orderReturn) -> Self {
+                    (
+                        value._order,
+                        value.preInteractions,
+                        value.postInteractions,
+                        value.sig,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for orderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _order: tuple.0,
+                        preInteractions: tuple.1,
+                        postInteractions: tuple.2,
+                        sig: tuple.3,
+                    }
+                }
+            }
+        }
+        impl orderReturn {
+            fn _tokenize(&self) -> <orderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <GPv2Order::Data as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Interaction::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self.preInteractions),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Interaction::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self.postInteractions),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.sig,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for orderCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Return = orderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                GPv2Order::Data,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [39u8, 36u8, 44u8, 155u8];
+            const SIGNATURE: &'static str = "order(address,uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.prices),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                orderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `tokens(address)` and selector `0xe4860339`.
+    ```solidity
+    function tokens(address pool) external view returns (address[] memory _tokens);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tokensCall {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`tokens(address)`](tokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tokensReturn {
+        #[allow(missing_docs)]
+        pub _tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: tokensCall) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: tokensReturn) -> Self {
+                    (value._tokens,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _tokens: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for tokensCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [228u8, 134u8, 3u8, 57u8];
+            const SIGNATURE: &'static str = "tokens(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: tokensReturn = r.into();
+                        r._tokens
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: tokensReturn = r.into();
+                    r._tokens
+                })
+            }
+        }
+    };
+    ///Container for all the [`CowAmmLegacyHelper`](self) function calls.
+    #[derive(Clone)]
+    pub enum CowAmmLegacyHelperCalls {
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getSnapshot(getSnapshotCall),
+        #[allow(missing_docs)]
+        isLegacy(isLegacyCall),
+        #[allow(missing_docs)]
+        isLegacyEnabled(isLegacyEnabledCall),
+        #[allow(missing_docs)]
+        order(orderCall),
+        #[allow(missing_docs)]
+        tokens(tokensCall),
+    }
+    impl CowAmmLegacyHelperCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [16u8, 2u8, 157u8, 170u8],
+            [33u8, 87u8, 2u8, 86u8],
+            [39u8, 36u8, 44u8, 155u8],
+            [42u8, 236u8, 121u8, 160u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [228u8, 134u8, 3u8, 57u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isLegacyEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSnapshotCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <orderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isLegacyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <tokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isLegacyEnabled),
+            ::core::stringify!(getSnapshot),
+            ::core::stringify!(order),
+            ::core::stringify!(isLegacy),
+            ::core::stringify!(factory),
+            ::core::stringify!(tokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmLegacyHelperCalls {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowAmmLegacyHelperCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getSnapshot(_) => <getSnapshotCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isLegacy(_) => <isLegacyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isLegacyEnabled(_) => {
+                    <isLegacyEnabledCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::order(_) => <orderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::tokens(_) => <tokensCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CowAmmLegacyHelperCalls>] = &[
+                {
+                    fn isLegacyEnabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperCalls::isLegacyEnabled)
+                    }
+                    isLegacyEnabled
+                },
+                {
+                    fn getSnapshot(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <getSnapshotCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperCalls::getSnapshot)
+                    }
+                    getSnapshot
+                },
+                {
+                    fn order(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <orderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperCalls::order)
+                    }
+                    order
+                },
+                {
+                    fn isLegacy(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <isLegacyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperCalls::isLegacy)
+                    }
+                    isLegacy
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn tokens(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <tokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperCalls::tokens)
+                    }
+                    tokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmLegacyHelperCalls,
+            >] = &[
+                {
+                    fn isLegacyEnabled(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmLegacyHelperCalls::isLegacyEnabled)
+                    }
+                    isLegacyEnabled
+                },
+                {
+                    fn getSnapshot(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <getSnapshotCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperCalls::getSnapshot)
+                    }
+                    getSnapshot
+                },
+                {
+                    fn order(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <orderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperCalls::order)
+                    }
+                    order
+                },
+                {
+                    fn isLegacy(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <isLegacyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperCalls::isLegacy)
+                    }
+                    isLegacy
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn tokens(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
+                        <tokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperCalls::tokens)
+                    }
+                    tokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getSnapshot(inner) => {
+                    <getSnapshotCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isLegacy(inner) => {
+                    <isLegacyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isLegacyEnabled(inner) => {
+                    <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::order(inner) => {
+                    <orderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::tokens(inner) => {
+                    <tokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getSnapshot(inner) => {
+                    <getSnapshotCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isLegacy(inner) => {
+                    <isLegacyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isLegacyEnabled(inner) => {
+                    <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::order(inner) => {
+                    <orderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::tokens(inner) => {
+                    <tokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowAmmLegacyHelper`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowAmmLegacyHelperErrors {
+        #[allow(missing_docs)]
+        InvalidArrayLength(InvalidArrayLength),
+        #[allow(missing_docs)]
+        MathOverflowedMulDiv(MathOverflowedMulDiv),
+        #[allow(missing_docs)]
+        NoOrder(NoOrder),
+        #[allow(missing_docs)]
+        PoolDoesNotExist(PoolDoesNotExist),
+        #[allow(missing_docs)]
+        PoolIsClosed(PoolIsClosed),
+        #[allow(missing_docs)]
+        PoolIsPaused(PoolIsPaused),
+    }
+    impl CowAmmLegacyHelperErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [25u8, 170u8, 213u8, 115u8],
+            [33u8, 8u8, 26u8, 191u8],
+            [34u8, 123u8, 193u8, 83u8],
+            [156u8, 135u8, 135u8, 192u8],
+            [157u8, 137u8, 2u8, 10u8],
+            [239u8, 200u8, 105u8, 180u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <NoOrder as alloy_sol_types::SolError>::SIGNATURE,
+            <PoolIsPaused as alloy_sol_types::SolError>::SIGNATURE,
+            <MathOverflowedMulDiv as alloy_sol_types::SolError>::SIGNATURE,
+            <PoolDoesNotExist as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidArrayLength as alloy_sol_types::SolError>::SIGNATURE,
+            <PoolIsClosed as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(NoOrder),
+            ::core::stringify!(PoolIsPaused),
+            ::core::stringify!(MathOverflowedMulDiv),
+            ::core::stringify!(PoolDoesNotExist),
+            ::core::stringify!(InvalidArrayLength),
+            ::core::stringify!(PoolIsClosed),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmLegacyHelperErrors {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowAmmLegacyHelperErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::InvalidArrayLength(_) => {
+                    <InvalidArrayLength as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::MathOverflowedMulDiv(_) => {
+                    <MathOverflowedMulDiv as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::NoOrder(_) => <NoOrder as alloy_sol_types::SolError>::SELECTOR,
+                Self::PoolDoesNotExist(_) => {
+                    <PoolDoesNotExist as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::PoolIsClosed(_) => <PoolIsClosed as alloy_sol_types::SolError>::SELECTOR,
+                Self::PoolIsPaused(_) => <PoolIsPaused as alloy_sol_types::SolError>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CowAmmLegacyHelperErrors>] = &[
+                {
+                    fn NoOrder(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <NoOrder as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperErrors::NoOrder)
+                    }
+                    NoOrder
+                },
+                {
+                    fn PoolIsPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <PoolIsPaused as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperErrors::PoolIsPaused)
+                    }
+                    PoolIsPaused
+                },
+                {
+                    fn MathOverflowedMulDiv(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <MathOverflowedMulDiv as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperErrors::MathOverflowedMulDiv)
+                    }
+                    MathOverflowedMulDiv
+                },
+                {
+                    fn PoolDoesNotExist(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <PoolDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperErrors::PoolDoesNotExist)
+                    }
+                    PoolDoesNotExist
+                },
+                {
+                    fn InvalidArrayLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <InvalidArrayLength as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperErrors::InvalidArrayLength)
+                    }
+                    InvalidArrayLength
+                },
+                {
+                    fn PoolIsClosed(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <PoolIsClosed as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CowAmmLegacyHelperErrors::PoolIsClosed)
+                    }
+                    PoolIsClosed
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmLegacyHelperErrors,
+            >] = &[
+                {
+                    fn NoOrder(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <NoOrder as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperErrors::NoOrder)
+                    }
+                    NoOrder
+                },
+                {
+                    fn PoolIsPaused(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <PoolIsPaused as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperErrors::PoolIsPaused)
+                    }
+                    PoolIsPaused
+                },
+                {
+                    fn MathOverflowedMulDiv(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <MathOverflowedMulDiv as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowAmmLegacyHelperErrors::MathOverflowedMulDiv)
+                    }
+                    MathOverflowedMulDiv
+                },
+                {
+                    fn PoolDoesNotExist(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <PoolDoesNotExist as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmLegacyHelperErrors::PoolDoesNotExist)
+                    }
+                    PoolDoesNotExist
+                },
+                {
+                    fn InvalidArrayLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <InvalidArrayLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowAmmLegacyHelperErrors::InvalidArrayLength)
+                    }
+                    InvalidArrayLength
+                },
+                {
+                    fn PoolIsClosed(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperErrors> {
+                        <PoolIsClosed as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowAmmLegacyHelperErrors::PoolIsClosed)
+                    }
+                    PoolIsClosed
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::InvalidArrayLength(inner) => {
+                    <InvalidArrayLength as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::MathOverflowedMulDiv(inner) => {
+                    <MathOverflowedMulDiv as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::NoOrder(inner) => {
+                    <NoOrder as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::PoolDoesNotExist(inner) => {
+                    <PoolDoesNotExist as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::PoolIsClosed(inner) => {
+                    <PoolIsClosed as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::PoolIsPaused(inner) => {
+                    <PoolIsPaused as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::InvalidArrayLength(inner) => {
+                    <InvalidArrayLength as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::MathOverflowedMulDiv(inner) => {
+                    <MathOverflowedMulDiv as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::NoOrder(inner) => {
+                    <NoOrder as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::PoolDoesNotExist(inner) => {
+                    <PoolDoesNotExist as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::PoolIsClosed(inner) => {
+                    <PoolIsClosed as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::PoolIsPaused(inner) => {
+                    <PoolIsPaused as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowAmmLegacyHelper`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowAmmLegacyHelperEvents {
+        #[allow(missing_docs)]
+        COWAMMPoolCreated(COWAMMPoolCreated),
+    }
+    impl CowAmmLegacyHelperEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            13u8, 3u8, 131u8, 77u8, 13u8, 134u8, 199u8, 245u8, 126u8, 135u8, 122u8, 244u8, 14u8,
+            38u8, 241u8, 118u8, 220u8, 49u8, 189u8, 99u8, 117u8, 53u8, 212u8, 186u8, 21u8, 61u8,
+            26u8, 201u8, 222u8, 136u8, 167u8, 234u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<COWAMMPoolCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(COWAMMPoolCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CowAmmLegacyHelperEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "CowAmmLegacyHelperEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<COWAMMPoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <COWAMMPoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::COWAMMPoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CowAmmLegacyHelperEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::COWAMMPoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::COWAMMPoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowAmmLegacyHelper`](self) contract instance.
+
+    See the [wrapper's documentation](`CowAmmLegacyHelperInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowAmmLegacyHelperInstance<P, N> {
+        CowAmmLegacyHelperInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<CowAmmLegacyHelperInstance<P, N>>>
+    {
+        CowAmmLegacyHelperInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CowAmmLegacyHelperInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`CowAmmLegacyHelper`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowAmmLegacyHelper`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowAmmLegacyHelperInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowAmmLegacyHelperInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowAmmLegacyHelperInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmLegacyHelperInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowAmmLegacyHelper`](self) contract instance.
+
+        See the [wrapper's documentation](`CowAmmLegacyHelperInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<CowAmmLegacyHelperInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowAmmLegacyHelperInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowAmmLegacyHelperInstance<P, N> {
+            CowAmmLegacyHelperInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmLegacyHelperInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getSnapshot`] function.
+        pub fn getSnapshot(
+            &self,
+            amm: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getSnapshotCall, N> {
+            self.call_builder(&getSnapshotCall { amm })
+        }
+
+        ///Creates a new call builder for the [`isLegacy`] function.
+        pub fn isLegacy(
+            &self,
+            amm: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isLegacyCall, N> {
+            self.call_builder(&isLegacyCall { amm })
+        }
+
+        ///Creates a new call builder for the [`isLegacyEnabled`] function.
+        pub fn isLegacyEnabled(
+            &self,
+            amm: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isLegacyEnabledCall, N> {
+            self.call_builder(&isLegacyEnabledCall { amm })
+        }
+
+        ///Creates a new call builder for the [`order`] function.
+        pub fn order(
+            &self,
+            pool: alloy_sol_types::private::Address,
+            prices: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, orderCall, N> {
+            self.call_builder(&orderCall { pool, prices })
+        }
+
+        ///Creates a new call builder for the [`tokens`] function.
+        pub fn tokens(
+            &self,
+            pool: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, tokensCall, N> {
+            self.call_builder(&tokensCall { pool })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmLegacyHelperInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`COWAMMPoolCreated`] event.
+        pub fn COWAMMPoolCreated_filter(&self) -> alloy_contract::Event<&P, COWAMMPoolCreated, N> {
+            self.event_filter::<COWAMMPoolCreated>()
+        }
+    }
+}
+pub type Instance = CowAmmLegacyHelper::CowAmmLegacyHelperInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x3705ceee5eaa561e3157cf92641ce28c45a3999c"),
+            Some(20332745u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xd9ec06b001957498ab1bc716145515d1d0e30ffb"),
+            Some(35026999u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/Cargo.toml b/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/Cargo.toml
new file mode 100644
index 0000000000..aba73a2198
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowammuniswapv2priceoracle"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs b/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs
new file mode 100644
index 0000000000..920989fea9
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs
@@ -0,0 +1,604 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface CowAmmUniswapV2PriceOracle {
+    function getPrice(address token0, address token1, bytes memory data) external view returns (uint256 priceNumerator, uint256 priceDenominator);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "getPrice",
+    "inputs": [
+      {
+        "name": "token0",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "priceNumerator",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "priceDenominator",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowAmmUniswapV2PriceOracle {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW_\x80\xFD[Pa\x05F\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c5^\xFD\xD9\x14a\0-W[_\x80\xFD[a\0@a\0;6`\x04a\x03\x86V[a\0YV[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x01`@Q\x80\x91\x03\x90\xF3[_\x80\x80a\0h\x84\x86\x01\x86a\x04\x11V[\x90P\x80_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xB6W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xDA\x91\x90a\x04\xA2V[\x82m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92P\x81m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91PP\x80\x93P\x81\x94PPP_\x81_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01VW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01z\x91\x90a\x04\xEEV[\x90P_\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC9W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xED\x91\x90a\x04\xEEV[\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x02'W\x92\x93\x92\x90[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x02\xC1W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7Foracle: invalid token0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x03VW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7Foracle: invalid token1\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02\xB8V[PPP\x94P\x94\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\x83W_\x80\xFD[PV[_\x80_\x80``\x85\x87\x03\x12\x15a\x03\x99W_\x80\xFD[\x845a\x03\xA4\x81a\x03bV[\x93P` \x85\x015a\x03\xB4\x81a\x03bV[\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x03\xD0W_\x80\xFD[\x81\x87\x01\x91P\x87`\x1F\x83\x01\x12a\x03\xE3W_\x80\xFD[\x815\x81\x81\x11\x15a\x03\xF1W_\x80\xFD[\x88` \x82\x85\x01\x01\x11\x15a\x04\x02W_\x80\xFD[\x95\x98\x94\x97PP` \x01\x94PPPV[_` \x82\x84\x03\x12\x15a\x04!W_\x80\xFD[`@Q` \x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04iW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@R\x825a\x04w\x81a\x03bV[\x81R\x93\x92PPPV[\x80Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\x9DW_\x80\xFD[\x91\x90PV[_\x80_``\x84\x86\x03\x12\x15a\x04\xB4W_\x80\xFD[a\x04\xBD\x84a\x04\x80V[\x92Pa\x04\xCB` \x85\x01a\x04\x80V[\x91P`@\x84\x01Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xE3W_\x80\xFD[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x04\xFEW_\x80\xFD[\x81Qa\x05\t\x81a\x03bV[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1F\xE6\xADMk\x89\xD2\x04\xDBS\x94\xBD\xED\xEF#\xD1\x0E\xD8\xC7\xE4\xF8;\xE4\xC5\xFE\x14\xDC\xC0\x94p\"4dsolcC\0\x08\x19\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c5^\xFD\xD9\x14a\0-W[_\x80\xFD[a\0@a\0;6`\x04a\x03\x86V[a\0YV[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x01`@Q\x80\x91\x03\x90\xF3[_\x80\x80a\0h\x84\x86\x01\x86a\x04\x11V[\x90P\x80_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xB6W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xDA\x91\x90a\x04\xA2V[\x82m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92P\x81m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91PP\x80\x93P\x81\x94PPP_\x81_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01VW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01z\x91\x90a\x04\xEEV[\x90P_\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC9W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xED\x91\x90a\x04\xEEV[\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x02'W\x92\x93\x92\x90[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x02\xC1W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7Foracle: invalid token0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x03VW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7Foracle: invalid token1\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02\xB8V[PPP\x94P\x94\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\x83W_\x80\xFD[PV[_\x80_\x80``\x85\x87\x03\x12\x15a\x03\x99W_\x80\xFD[\x845a\x03\xA4\x81a\x03bV[\x93P` \x85\x015a\x03\xB4\x81a\x03bV[\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x03\xD0W_\x80\xFD[\x81\x87\x01\x91P\x87`\x1F\x83\x01\x12a\x03\xE3W_\x80\xFD[\x815\x81\x81\x11\x15a\x03\xF1W_\x80\xFD[\x88` \x82\x85\x01\x01\x11\x15a\x04\x02W_\x80\xFD[\x95\x98\x94\x97PP` \x01\x94PPPV[_` \x82\x84\x03\x12\x15a\x04!W_\x80\xFD[`@Q` \x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04iW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@R\x825a\x04w\x81a\x03bV[\x81R\x93\x92PPPV[\x80Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\x9DW_\x80\xFD[\x91\x90PV[_\x80_``\x84\x86\x03\x12\x15a\x04\xB4W_\x80\xFD[a\x04\xBD\x84a\x04\x80V[\x92Pa\x04\xCB` \x85\x01a\x04\x80V[\x91P`@\x84\x01Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xE3W_\x80\xFD[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x04\xFEW_\x80\xFD[\x81Qa\x05\t\x81a\x03bV[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1F\xE6\xADMk\x89\xD2\x04\xDBS\x94\xBD\xED\xEF#\xD1\x0E\xD8\xC7\xE4\xF8;\xE4\xC5\xFE\x14\xDC\xC0\x94p\"4dsolcC\0\x08\x19\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPrice(address,address,bytes)` and selector `0x355efdd9`.
+    ```solidity
+    function getPrice(address token0, address token1, bytes memory data) external view returns (uint256 priceNumerator, uint256 priceDenominator);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPriceCall {
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPrice(address,address,bytes)`](getPriceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPriceReturn {
+        #[allow(missing_docs)]
+        pub priceNumerator: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub priceDenominator: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPriceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPriceCall) -> Self {
+                    (value.token0, value.token1, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPriceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token0: tuple.0,
+                        token1: tuple.1,
+                        data: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPriceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPriceReturn) -> Self {
+                    (value.priceNumerator, value.priceDenominator)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPriceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        priceNumerator: tuple.0,
+                        priceDenominator: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getPriceReturn {
+            fn _tokenize(&self) -> <getPriceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.priceNumerator,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.priceDenominator,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPriceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = getPriceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [53u8, 94u8, 253u8, 217u8];
+            const SIGNATURE: &'static str = "getPrice(address,address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPriceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`CowAmmUniswapV2PriceOracle`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum CowAmmUniswapV2PriceOracleCalls {
+        #[allow(missing_docs)]
+        getPrice(getPriceCall),
+    }
+    impl CowAmmUniswapV2PriceOracleCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[53u8, 94u8, 253u8, 217u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<getPriceCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(getPrice)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowAmmUniswapV2PriceOracleCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 128usize;
+        const NAME: &'static str = "CowAmmUniswapV2PriceOracleCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::getPrice(_) => <getPriceCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmUniswapV2PriceOracleCalls,
+            >] = &[{
+                fn getPrice(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<CowAmmUniswapV2PriceOracleCalls> {
+                    <getPriceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(CowAmmUniswapV2PriceOracleCalls::getPrice)
+                }
+                getPrice
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowAmmUniswapV2PriceOracleCalls,
+            >] = &[{
+                fn getPrice(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<CowAmmUniswapV2PriceOracleCalls> {
+                    <getPriceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(CowAmmUniswapV2PriceOracleCalls::getPrice)
+                }
+                getPrice
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::getPrice(inner) => {
+                    <getPriceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::getPrice(inner) => {
+                    <getPriceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowAmmUniswapV2PriceOracle`](self) contract instance.
+
+    See the [wrapper's documentation](`CowAmmUniswapV2PriceOracleInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowAmmUniswapV2PriceOracleInstance<P, N> {
+        CowAmmUniswapV2PriceOracleInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<CowAmmUniswapV2PriceOracleInstance<P, N>>,
+    > {
+        CowAmmUniswapV2PriceOracleInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CowAmmUniswapV2PriceOracleInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`CowAmmUniswapV2PriceOracle`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowAmmUniswapV2PriceOracle`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowAmmUniswapV2PriceOracleInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowAmmUniswapV2PriceOracleInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowAmmUniswapV2PriceOracleInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmUniswapV2PriceOracleInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowAmmUniswapV2PriceOracle`](self) contract instance.
+
+        See the [wrapper's documentation](`CowAmmUniswapV2PriceOracleInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<CowAmmUniswapV2PriceOracleInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowAmmUniswapV2PriceOracleInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowAmmUniswapV2PriceOracleInstance<P, N> {
+            CowAmmUniswapV2PriceOracleInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmUniswapV2PriceOracleInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`getPrice`] function.
+        pub fn getPrice(
+            &self,
+            token0: alloy_sol_types::private::Address,
+            token1: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, getPriceCall, N> {
+            self.call_builder(&getPriceCall {
+                token0,
+                token1,
+                data,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowAmmUniswapV2PriceOracleInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    CowAmmUniswapV2PriceOracle::CowAmmUniswapV2PriceOracleInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/cowprotocoltoken/Cargo.toml b/contracts/generated/contracts-generated/cowprotocoltoken/Cargo.toml
new file mode 100644
index 0000000000..2ef10310c4
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowprotocoltoken/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowprotocoltoken"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs b/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs
new file mode 100644
index 0000000000..d2d9bc3ae3
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs
@@ -0,0 +1,6059 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface CowProtocolToken {
+    error AlreadyInflated();
+    error ExceedingMintCap();
+    error OnlyCowDao();
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(address initialTokenHolder, address cowDao, uint256 totalSupply);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function MAX_YEARLY_INFLATION() external view returns (uint256);
+    function TIME_BETWEEN_MINTINGS() external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function cowDao() external view returns (address);
+    function decimals() external view returns (uint8);
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function mint(address target, uint256 amount) external;
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    function symbol() external view returns (string memory);
+    function timestampLastMinting() external view returns (uint256);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "initialTokenHolder",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "cowDao",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "totalSupply",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MAX_YEARLY_INFLATION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "TIME_BETWEEN_MINTINGS",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "cowDao",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decreaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "subtractedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getStorageAt",
+    "inputs": [
+      {
+        "name": "offset",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "increaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "addedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "simulateDelegatecall",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "simulateDelegatecallInternal",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "timestampLastMinting",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AlreadyInflated",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ExceedingMintCap",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OnlyCowDao",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowProtocolToken {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\x80`@R\x7Fnq\xED\xAE\x12\xB1\xB9\x7FM\x1F`7\x0F\xEF\x10\x10_\xA2\xFA\xAE\x01&\x11J\x16\x9Cd\x84]a&\xC9a\x01@R`\0`\x06U4\x80\x15b\0\0<W`\0\x80\xFD[P`@Qb\0!\"8\x03\x80b\0!\"\x839\x81\x01`@\x81\x90Rb\0\0_\x91b\0\x03_V[\x82\x82\x82`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q!\xB7\xAB\x90(97\xBA7\xB1\xB7\xB6\x10*7\xB5\xB2\xB7`q\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01bCOW`\xE8\x1B\x81RP\x81\x80`@Q\x80`@\x01`@R\x80`\x01\x81R` \x01`1`\xF8\x1B\x81RP\x84\x84\x81`\x03\x90\x80Q\x90` \x01\x90b\0\0\xDF\x92\x91\x90b\0\x02\x9CV[P\x80Qb\0\0\xF5\x90`\x04\x90` \x84\x01\x90b\0\x02\x9CV[PP\x82Q` \x93\x84\x01 \x82Q\x92\x84\x01\x92\x90\x92 `\xE0\x83\x90Ra\x01\0\x81\x90RF`\xA0\x81\x81R`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F\x81\x89\x01\x81\x90R\x81\x83\x01\x97\x90\x97R``\x81\x01\x94\x90\x94R`\x80\x80\x85\x01\x93\x90\x93R0\x84\x83\x01\x81\x90R\x81Q\x80\x86\x03\x90\x93\x01\x83R`\xC0\x94\x85\x01\x90\x91R\x81Q\x91\x90\x96\x01 \x90R\x92\x90\x92Ra\x01 RPb\0\x01\x95\x90P\x85\x84b\0\x01\xB4V[PPP`\x01`\x01`\xA0\x1B\x03\x16a\x01`RPPB`\x06UPb\0\x04\x04\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16b\0\x02\x0FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[\x80`\x02`\0\x82\x82Tb\0\x02#\x91\x90b\0\x03\xA0V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90b\0\x02R\x90\x84\x90b\0\x03\xA0V[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90`\0\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90` \x01`@Q\x80\x91\x03\x90\xA3PPV[\x82\x80Tb\0\x02\xAA\x90b\0\x03\xC7V[\x90`\0R` `\0 \x90`\x1F\x01` \x90\x04\x81\x01\x92\x82b\0\x02\xCEW`\0\x85Ub\0\x03\x19V[\x82`\x1F\x10b\0\x02\xE9W\x80Q`\xFF\x19\x16\x83\x80\x01\x17\x85Ub\0\x03\x19V[\x82\x80\x01`\x01\x01\x85U\x82\x15b\0\x03\x19W\x91\x82\x01[\x82\x81\x11\x15b\0\x03\x19W\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90b\0\x02\xFCV[Pb\0\x03'\x92\x91Pb\0\x03+V[P\x90V[[\x80\x82\x11\x15b\0\x03'W`\0\x81U`\x01\x01b\0\x03,V[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x03ZW`\0\x80\xFD[\x91\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15b\0\x03uW`\0\x80\xFD[b\0\x03\x80\x84b\0\x03BV[\x92Pb\0\x03\x90` \x85\x01b\0\x03BV[\x91P`@\x84\x01Q\x90P\x92P\x92P\x92V[`\0\x82\x19\x82\x11\x15b\0\x03\xC2WcNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[P\x01\x90V[`\x01\x81\x81\x1C\x90\x82\x16\x80b\0\x03\xDCW`\x7F\x82\x16\x91P[` \x82\x10\x81\x14\x15b\0\x03\xFEWcNH{q`\xE0\x1B`\0R`\"`\x04R`$`\0\xFD[P\x91\x90PV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa\x1C\xB1b\0\x04q`\09`\0\x81\x81a\x03:\x01Ra\x05\xA1\x01R`\0a\td\x01R`\0a\x115\x01R`\0a\x11\x84\x01R`\0a\x11_\x01R`\0a\x10\xB8\x01R`\0a\x10\xE2\x01R`\0a\x11\x0C\x01Ra\x1C\xB1`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\x82W`\x005`\xE0\x1C\x80cp\xA0\x821\x11a\0\xD8W\x80c\xCDB\xDC\xBE\x11a\0\x8CW\x80c\xE2\xD5\x14\x89\x11a\0fW\x80c\xE2\xD5\x14\x89\x14a\x035W\x80c\xF8D6\xBD\x14a\x03\x81W\x80c\xFD\xE9\xE0z\x14a\x03\x94W`\0\x80\xFD[\x80c\xCDB\xDC\xBE\x14a\x02\xD1W\x80c\xD5\x05\xAC\xCF\x14a\x02\xDCW\x80c\xDDb\xED>\x14a\x02\xEFW`\0\x80\xFD[\x80c\x95\xD8\x9BA\x11a\0\xBDW\x80c\x95\xD8\x9BA\x14a\x02\xA3W\x80c\xA4W\xC2\xD7\x14a\x02\xABW\x80c\xA9\x05\x9C\xBB\x14a\x02\xBEW`\0\x80\xFD[\x80cp\xA0\x821\x14a\x02ZW\x80c~\xCE\xBE\0\x14a\x02\x90W`\0\x80\xFD[\x80c6D\xE5\x15\x11a\x01:W\x80cC!\x8E\x19\x11a\x01\x14W\x80cC!\x8E\x19\x14a\x02,W\x80cV$\xB2[\x14a\x02?W\x80cXb\xBF=\x14a\x02RW`\0\x80\xFD[\x80c6D\xE5\x15\x14a\x01\xFCW\x80c9P\x93Q\x14a\x02\x04W\x80c@\xC1\x0F\x19\x14a\x02\x17W`\0\x80\xFD[\x80c\x18\x16\r\xDD\x11a\x01kW\x80c\x18\x16\r\xDD\x14a\x01\xC8W\x80c#\xB8r\xDD\x14a\x01\xDAW\x80c1<\xE5g\x14a\x01\xEDW`\0\x80\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x87W\x80c\t^\xA7\xB3\x14a\x01\xA5W[`\0\x80\xFD[a\x01\x8Fa\x03\x9DV[`@Qa\x01\x9C\x91\x90a\x17\xAAV[`@Q\x80\x91\x03\x90\xF3[a\x01\xB8a\x01\xB36`\x04a\x17\xEDV[a\x04/V[`@Q\x90\x15\x15\x81R` \x01a\x01\x9CV[`\x02T[`@Q\x90\x81R` \x01a\x01\x9CV[a\x01\xB8a\x01\xE86`\x04a\x18\x17V[a\x04FV[`@Q`\x12\x81R` \x01a\x01\x9CV[a\x01\xCCa\x051V[a\x01\xB8a\x02\x126`\x04a\x17\xEDV[a\x05@V[a\x02*a\x02%6`\x04a\x17\xEDV[a\x05\x89V[\0[a\x01\x8Fa\x02:6`\x04a\x18\x82V[a\x06\xAFV[a\x01\x8Fa\x02M6`\x04a\x19bV[a\x07QV[a\x01\xCC`\x03\x81V[a\x01\xCCa\x02h6`\x04a\x19\x84V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\0\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\xCCa\x02\x9E6`\x04a\x19\x84V[a\x07\xD7V[a\x01\x8Fa\x08\x02V[a\x01\xB8a\x02\xB96`\x04a\x17\xEDV[a\x08\x11V[a\x01\xB8a\x02\xCC6`\x04a\x17\xEDV[a\x08\xE9V[a\x01\xCCc\x01\xE13\x80\x81V[a\x02*a\x02\xEA6`\x04a\x19\x9FV[a\x08\xF6V[a\x01\xCCa\x02\xFD6`\x04a\x1A\x12V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x03\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\x9CV[a\x01\x8Fa\x03\x8F6`\x04a\x18\x82V[a\n\xB5V[a\x01\xCC`\x06T\x81V[```\x03\x80Ta\x03\xAC\x90a\x1AEV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xD8\x90a\x1AEV[\x80\x15a\x04%W\x80`\x1F\x10a\x03\xFAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04%V[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x08W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[`\0a\x04<3\x84\x84a\x0C6V[P`\x01[\x92\x91PPV[`\0a\x04S\x84\x84\x84a\r\xE9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 T\x82\x81\x10\x15a\x05\x19W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FERC20: transfer amount exceeds a`D\x82\x01R\x7Fllowance\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x05&\x853\x85\x84\x03a\x0C6V[P`\x01\x94\x93PPPPV[`\0a\x05;a\x10\x9EV[\x90P\x90V[3`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x84R\x90\x91R\x81 T\x90\x91a\x04<\x91\x85\x90a\x05\x84\x90\x86\x90a\x1A\xC2V[a\x0C6V[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x05\xF8W`@Q\x7F\xFEr\xC3n\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`d`\x03a\x06\x05`\x02T\x90V[a\x06\x0F\x91\x90a\x1A\xDAV[a\x06\x19\x91\x90a\x1B\x17V[\x81\x11\x15a\x06RW`@Q\x7F,j\xF2\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[Bc\x01\xE13\x80`\x06Ta\x06e\x91\x90a\x1A\xC2V[\x11\x15a\x06\x9DW`@Q\x7F{\x06G\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[B`\x06Ua\x06\xAB\x82\x82a\x11\xD2V[PPV[```\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83`@Qa\x06\xD8\x91\x90a\x1BRV[`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\x07\x13W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x07\x18V[``\x91P[P`@Q\x90\x93P\x90\x91Pa\x07J\x90a\x076\x90\x84\x90\x84\x90` \x01a\x1BnV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x12\xF2V[P\x92\x91PPV[```\0a\x07`\x83` a\x1A\xDAV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07xWa\x07xa\x18SV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x07\xA2W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\0[\x83\x81\x10\x15a\x07\xCFW\x84\x81\x01T` \x80\x83\x02\x84\x01\x01R\x80a\x07\xC7\x81a\x1B\x96V[\x91PPa\x07\xA8V[P\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`\0\x90\x81R`\x05` R`@\x81 Ta\x04@V[```\x04\x80Ta\x03\xAC\x90a\x1AEV[3`\0\x90\x81R`\x01` \x90\x81R`@\x80\x83 s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x84R\x90\x91R\x81 T\x82\x81\x10\x15a\x08\xD2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FERC20: decreased allowance below`D\x82\x01R\x7F zero\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[a\x08\xDF3\x85\x85\x84\x03a\x0C6V[P`\x01\x93\x92PPPV[`\0a\x04<3\x84\x84a\r\xE9V[\x83B\x11\x15a\t`W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20Permit: expired deadline\0\0\0`D\x82\x01R`d\x01a\x05\x10V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88\x88a\t\x8F\x8Ca\x12\xFAV[`@\x80Q` \x81\x01\x96\x90\x96Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16\x90\x86\x01R\x92\x90\x91\x16``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x81\x01\x86\x90R`\xE0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0a\t\xF7\x82a\x13/V[\x90P`\0a\n\x07\x82\x87\x87\x87a\x13\x98V[\x90P\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\n\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FERC20Permit: invalid signature\0\0`D\x82\x01R`d\x01a\x05\x10V[a\n\xA9\x8A\x8A\x8Aa\x0C6V[PPPPPPPPPPV[```\0cC!\x8E\x19`\xE0\x1B\x84\x84`@Q`$\x01a\n\xD4\x92\x91\x90a\x1B\xCFV[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x94\x16\x93\x90\x93\x17\x90\x92R\x90Q\x90\x91P0\x90a\x0Bc\x90\x83\x90a\x1BRV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x0B\xA0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x0B\xA5V[``\x91P[P\x90P\x80\x92PP`\0\x82`\x01\x84Qa\x0B\xBD\x91\x90a\x1C\x06V[\x81Q\x81\x10a\x0B\xCDWa\x0B\xCDa\x1C\x1DV[` \x01\x01Q`\xF8\x1C`\xF8\x1B~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\xF8\x1B\x14\x90Pa\x0C\x18\x83`\x01\x85Qa\x0C\x14\x91\x90a\x1C\x06V[\x90RV[\x80\x15a\x0C%WPPa\x04@V[a\x0C.\x83a\x12\xF2V[PP\x92\x91PPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x0C\xD8W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FERC20: approve from the zero add`D\x82\x01R\x7Fress\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\r{W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\"`$\x82\x01R\x7FERC20: approve to the zero addre`D\x82\x01R\x7Fss\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 \x94\x87\x16\x80\x84R\x94\x82R\x91\x82\x90 \x85\x90U\x90Q\x84\x81R\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x91\x01`@Q\x80\x91\x03\x90\xA3PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x0E\x8CW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FERC20: transfer from the zero ad`D\x82\x01R\x7Fdress\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x0F/W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FERC20: transfer to the zero addr`D\x82\x01R\x7Fess\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`\0\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\x0F\xE5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FERC20: transfer amount exceeds b`D\x82\x01R\x7Falance\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`\0\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x10)\x90\x84\x90a\x1A\xC2V[\x92PP\x81\x90UP\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x84`@Qa\x10\x8F\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3[PPPPV[`\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80\x15a\x11\x04WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14[\x15a\x11.WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[P`@\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x80\x83\x01\x91\x90\x91R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x84\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x83\x01RF`\x80\x83\x01R0`\xA0\x80\x84\x01\x91\x90\x91R\x83Q\x80\x84\x03\x90\x91\x01\x81R`\xC0\x90\x92\x01\x90\x92R\x80Q\x91\x01 \x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x12OW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x05\x10V[\x80`\x02`\0\x82\x82Ta\x12a\x91\x90a\x1A\xC2V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16`\0\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x12\x9B\x90\x84\x90a\x1A\xC2V[\x90\x91UPP`@Q\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90`\0\x90\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x90` \x01`@Q\x80\x91\x03\x90\xA3PPV[\x80Q` \x82\x01\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`\0\x90\x81R`\x05` R`@\x90 \x80T`\x01\x81\x01\x82U\x90[P\x91\x90PV[`\0a\x04@a\x13<a\x10\x9EV[\x83`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R`\"\x81\x01\x83\x90R`B\x81\x01\x82\x90R`\0\x90`b\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x92\x91PPV[`\0\x80`\0a\x13\xA9\x87\x87\x87\x87a\x13\xC0V[\x91P\x91Pa\x13\xB6\x81a\x14\xD8V[P\x95\x94PPPPPV[`\0\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x83\x11\x15a\x13\xF7WP`\0\x90P`\x03a\x14\xCFV[\x84`\xFF\x16`\x1B\x14\x15\x80\x15a\x14\x0FWP\x84`\xFF\x16`\x1C\x14\x15[\x15a\x14 WP`\0\x90P`\x04a\x14\xCFV[`@\x80Q`\0\x80\x82R` \x82\x01\x80\x84R\x89\x90R`\xFF\x88\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x86\x90R`\x80\x81\x01\x85\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\x14tW=`\0\x80>=`\0\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16a\x14\xC8W`\0`\x01\x92P\x92PPa\x14\xCFV[\x91P`\0\x90P[\x94P\x94\x92PPPV[`\0\x81`\x04\x81\x11\x15a\x14\xECWa\x14\xECa\x1CLV[\x14\x15a\x14\xF5WPV[`\x01\x81`\x04\x81\x11\x15a\x15\tWa\x15\ta\x1CLV[\x14\x15a\x15qW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FECDSA: invalid signature\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05\x10V[`\x02\x81`\x04\x81\x11\x15a\x15\x85Wa\x15\x85a\x1CLV[\x14\x15a\x15\xEDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FECDSA: invalid signature length\0`D\x82\x01R`d\x01a\x05\x10V[`\x03\x81`\x04\x81\x11\x15a\x16\x01Wa\x16\x01a\x1CLV[\x14\x15a\x16\x8FW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\"`$\x82\x01R\x7FECDSA: invalid signature 's' val`D\x82\x01R\x7Fue\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[`\x04\x81`\x04\x81\x11\x15a\x16\xA3Wa\x16\xA3a\x1CLV[\x14\x15a\x171W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\"`$\x82\x01R\x7FECDSA: invalid signature 'v' val`D\x82\x01R\x7Fue\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05\x10V[PV[`\0[\x83\x81\x10\x15a\x17OW\x81\x81\x01Q\x83\x82\x01R` \x01a\x177V[\x83\x81\x11\x15a\x10\x98WPP`\0\x91\x01RV[`\0\x81Q\x80\x84Ra\x17x\x81` \x86\x01` \x86\x01a\x174V[`\x1F\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x92\x90\x92\x01` \x01\x92\x91PPV[` \x81R`\0a\x17\xBD` \x83\x01\x84a\x17`V[\x93\x92PPPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x17\xE8W`\0\x80\xFD[\x91\x90PV[`\0\x80`@\x83\x85\x03\x12\x15a\x18\0W`\0\x80\xFD[a\x18\t\x83a\x17\xC4V[\x94` \x93\x90\x93\x015\x93PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x18,W`\0\x80\xFD[a\x185\x84a\x17\xC4V[\x92Pa\x18C` \x85\x01a\x17\xC4V[\x91P`@\x84\x015\x90P\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\x18\x95W`\0\x80\xFD[a\x18\x9E\x83a\x17\xC4V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18\xBBW`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\xCFW`\0\x80\xFD[\x815\x81\x81\x11\x15a\x18\xE1Wa\x18\xE1a\x18SV[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x16`?\x01\x16\x81\x01\x90\x83\x82\x11\x81\x83\x10\x17\x15a\x19'Wa\x19'a\x18SV[\x81`@R\x82\x81R\x88` \x84\x87\x01\x01\x11\x15a\x19@W`\0\x80\xFD[\x82` \x86\x01` \x83\x017`\0` \x84\x83\x01\x01R\x80\x95PPPPPP\x92P\x92\x90PV[`\0\x80`@\x83\x85\x03\x12\x15a\x19uW`\0\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[`\0` \x82\x84\x03\x12\x15a\x19\x96W`\0\x80\xFD[a\x17\xBD\x82a\x17\xC4V[`\0\x80`\0\x80`\0\x80`\0`\xE0\x88\x8A\x03\x12\x15a\x19\xBAW`\0\x80\xFD[a\x19\xC3\x88a\x17\xC4V[\x96Pa\x19\xD1` \x89\x01a\x17\xC4V[\x95P`@\x88\x015\x94P``\x88\x015\x93P`\x80\x88\x015`\xFF\x81\x16\x81\x14a\x19\xF5W`\0\x80\xFD[\x96\x99\x95\x98P\x93\x96\x92\x95\x94`\xA0\x84\x015\x94P`\xC0\x90\x93\x015\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a\x1A%W`\0\x80\xFD[a\x1A.\x83a\x17\xC4V[\x91Pa\x1A<` \x84\x01a\x17\xC4V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1AYW`\x7F\x82\x16\x91P[` \x82\x10\x81\x14\x15a\x13)W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\"`\x04R`$`\0\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0\x82\x19\x82\x11\x15a\x1A\xD5Wa\x1A\xD5a\x1A\x93V[P\x01\x90V[`\0\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15a\x1B\x12Wa\x1B\x12a\x1A\x93V[P\x02\x90V[`\0\x82a\x1BMW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x12`\x04R`$`\0\xFD[P\x04\x90V[`\0\x82Qa\x1Bd\x81\x84` \x87\x01a\x174V[\x91\x90\x91\x01\x92\x91PPV[`\0\x83Qa\x1B\x80\x81\x84` \x88\x01a\x174V[\x92\x15\x15`\xF8\x1B\x91\x90\x92\x01\x90\x81R`\x01\x01\x92\x91PPV[`\0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x14\x15a\x1B\xC8Wa\x1B\xC8a\x1A\x93V[P`\x01\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x81R`@` \x82\x01R`\0a\x1B\xFE`@\x83\x01\x84a\x17`V[\x94\x93PPPPV[`\0\x82\x82\x10\x15a\x1C\x18Wa\x1C\x18a\x1A\x93V[P\x03\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`2`\x04R`$`\0\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD\xFE\xA2dipfsX\"\x12 S\tT\xA1\xB4\n\x0E<mE3\x0C\x16\xC5\xBF8J\x84{\xA0k\xF8\xEB\xBB\x9A\xFD\xFB\t\xAD\xA6\x8C\x0BdsolcC\0\x08\n\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `AlreadyInflated()` and selector `0x7b064715`.
+    ```solidity
+    error AlreadyInflated();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct AlreadyInflated;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<AlreadyInflated> for UnderlyingRustTuple<'_> {
+            fn from(value: AlreadyInflated) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AlreadyInflated {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for AlreadyInflated {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [123u8, 6u8, 71u8, 21u8];
+            const SIGNATURE: &'static str = "AlreadyInflated()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ExceedingMintCap()` and selector `0x2c6af208`.
+    ```solidity
+    error ExceedingMintCap();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ExceedingMintCap;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ExceedingMintCap> for UnderlyingRustTuple<'_> {
+            fn from(value: ExceedingMintCap) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExceedingMintCap {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ExceedingMintCap {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [44u8, 106u8, 242u8, 8u8];
+            const SIGNATURE: &'static str = "ExceedingMintCap()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OnlyCowDao()` and selector `0xfe72c36e`.
+    ```solidity
+    error OnlyCowDao();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnlyCowDao;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OnlyCowDao> for UnderlyingRustTuple<'_> {
+            fn from(value: OnlyCowDao) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyCowDao {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OnlyCowDao {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [254u8, 114u8, 195u8, 110u8];
+            const SIGNATURE: &'static str = "OnlyCowDao()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address initialTokenHolder, address cowDao, uint256 totalSupply);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub initialTokenHolder: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub cowDao: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub totalSupply: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.initialTokenHolder, value.cowDao, value.totalSupply)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        initialTokenHolder: tuple.0,
+                        cowDao: tuple.1,
+                        totalSupply: tuple.2,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.initialTokenHolder,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.cowDao,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.totalSupply,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `MAX_YEARLY_INFLATION()` and selector `0x5862bf3d`.
+    ```solidity
+    function MAX_YEARLY_INFLATION() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MAX_YEARLY_INFLATIONCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`MAX_YEARLY_INFLATION()`](MAX_YEARLY_INFLATIONCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MAX_YEARLY_INFLATIONReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MAX_YEARLY_INFLATIONCall> for UnderlyingRustTuple<'_> {
+                fn from(value: MAX_YEARLY_INFLATIONCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_YEARLY_INFLATIONCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MAX_YEARLY_INFLATIONReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: MAX_YEARLY_INFLATIONReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_YEARLY_INFLATIONReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for MAX_YEARLY_INFLATIONCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [88u8, 98u8, 191u8, 61u8];
+            const SIGNATURE: &'static str = "MAX_YEARLY_INFLATION()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: MAX_YEARLY_INFLATIONReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: MAX_YEARLY_INFLATIONReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `TIME_BETWEEN_MINTINGS()` and selector `0xcd42dcbe`.
+    ```solidity
+    function TIME_BETWEEN_MINTINGS() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TIME_BETWEEN_MINTINGSCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`TIME_BETWEEN_MINTINGS()`](TIME_BETWEEN_MINTINGSCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TIME_BETWEEN_MINTINGSReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<TIME_BETWEEN_MINTINGSCall> for UnderlyingRustTuple<'_> {
+                fn from(value: TIME_BETWEEN_MINTINGSCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for TIME_BETWEEN_MINTINGSCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<TIME_BETWEEN_MINTINGSReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: TIME_BETWEEN_MINTINGSReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for TIME_BETWEEN_MINTINGSReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for TIME_BETWEEN_MINTINGSCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [205u8, 66u8, 220u8, 190u8];
+            const SIGNATURE: &'static str = "TIME_BETWEEN_MINTINGS()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: TIME_BETWEEN_MINTINGSReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: TIME_BETWEEN_MINTINGSReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cowDao()` and selector `0xe2d51489`.
+    ```solidity
+    function cowDao() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cowDaoCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`cowDao()`](cowDaoCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cowDaoReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cowDaoCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cowDaoCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowDaoCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cowDaoReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cowDaoReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowDaoReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cowDaoCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [226u8, 213u8, 20u8, 137u8];
+            const SIGNATURE: &'static str = "cowDao()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: cowDaoReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: cowDaoReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    ```solidity
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceCall) -> Self {
+                    (value.spender, value.subtractedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        subtractedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
+            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.subtractedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
+    ```solidity
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtCall {
+        #[allow(missing_docs)]
+        pub offset: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub length: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtCall) -> Self {
+                    (value.offset, value.length)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        offset: tuple.0,
+                        length: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getStorageAtCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
+            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.offset,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.length,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getStorageAtReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getStorageAtReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    ```solidity
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceCall) -> Self {
+                    (value.spender, value.addedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        addedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
+            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.addedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
+    ```solidity
+    function mint(address target, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`mint(address,uint256)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.target, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        target: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = mintReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                mintReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
+    ```solidity
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
+            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateDelegatecallReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateDelegatecallInternal(address,bytes)` and selector `0x43218e19`.
+    ```solidity
+    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallInternalCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulateDelegatecallInternal(address,
+    /// bytes)`](simulateDelegatecallInternalCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallInternalReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallInternalCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallInternalCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallInternalReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallInternalReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateDelegatecallInternalCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [67u8, 33u8, 142u8, 25u8];
+            const SIGNATURE: &'static str = "simulateDelegatecallInternal(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallInternalReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateDelegatecallInternalReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `timestampLastMinting()` and selector `0xfde9e07a`.
+    ```solidity
+    function timestampLastMinting() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct timestampLastMintingCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`timestampLastMinting()`](timestampLastMintingCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct timestampLastMintingReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<timestampLastMintingCall> for UnderlyingRustTuple<'_> {
+                fn from(value: timestampLastMintingCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for timestampLastMintingCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<timestampLastMintingReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: timestampLastMintingReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for timestampLastMintingReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for timestampLastMintingCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [253u8, 233u8, 224u8, 122u8];
+            const SIGNATURE: &'static str = "timestampLastMinting()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: timestampLastMintingReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: timestampLastMintingReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`CowProtocolToken`](self) function calls.
+    #[derive(Clone)]
+    pub enum CowProtocolTokenCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        MAX_YEARLY_INFLATION(MAX_YEARLY_INFLATIONCall),
+        #[allow(missing_docs)]
+        TIME_BETWEEN_MINTINGS(TIME_BETWEEN_MINTINGSCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        cowDao(cowDaoCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        decreaseAllowance(decreaseAllowanceCall),
+        #[allow(missing_docs)]
+        getStorageAt(getStorageAtCall),
+        #[allow(missing_docs)]
+        increaseAllowance(increaseAllowanceCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        simulateDelegatecall(simulateDelegatecallCall),
+        #[allow(missing_docs)]
+        simulateDelegatecallInternal(simulateDelegatecallInternalCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        timestampLastMinting(timestampLastMintingCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl CowProtocolTokenCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [57u8, 80u8, 147u8, 81u8],
+            [64u8, 193u8, 15u8, 25u8],
+            [67u8, 33u8, 142u8, 25u8],
+            [86u8, 36u8, 178u8, 91u8],
+            [88u8, 98u8, 191u8, 61u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [164u8, 87u8, 194u8, 215u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [205u8, 66u8, 220u8, 190u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [226u8, 213u8, 20u8, 137u8],
+            [248u8, 68u8, 54u8, 189u8],
+            [253u8, 233u8, 224u8, 122u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cowDaoCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateDelegatecallCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <timestampLastMintingCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(increaseAllowance),
+            ::core::stringify!(mint),
+            ::core::stringify!(simulateDelegatecallInternal),
+            ::core::stringify!(getStorageAt),
+            ::core::stringify!(MAX_YEARLY_INFLATION),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(nonces),
+            ::core::stringify!(symbol),
+            ::core::stringify!(decreaseAllowance),
+            ::core::stringify!(transfer),
+            ::core::stringify!(TIME_BETWEEN_MINTINGS),
+            ::core::stringify!(permit),
+            ::core::stringify!(allowance),
+            ::core::stringify!(cowDao),
+            ::core::stringify!(simulateDelegatecall),
+            ::core::stringify!(timestampLastMinting),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowProtocolTokenCalls {
+        const COUNT: usize = 22usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowProtocolTokenCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::MAX_YEARLY_INFLATION(_) => {
+                    <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::TIME_BETWEEN_MINTINGS(_) => {
+                    <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::cowDao(_) => <cowDaoCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseAllowance(_) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::increaseAllowance(_) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::simulateDelegatecall(_) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::simulateDelegatecallInternal(_) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::timestampLastMinting(_) => {
+                    <timestampLastMintingCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn simulateDelegatecallInternal(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::simulateDelegatecallInternal)
+                    }
+                    simulateDelegatecallInternal
+                },
+                {
+                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn MAX_YEARLY_INFLATION(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::MAX_YEARLY_INFLATION)
+                    }
+                    MAX_YEARLY_INFLATION
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn TIME_BETWEEN_MINTINGS(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CowProtocolTokenCalls::TIME_BETWEEN_MINTINGS)
+                    }
+                    TIME_BETWEEN_MINTINGS
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn cowDao(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <cowDaoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::cowDao)
+                    }
+                    cowDao
+                },
+                {
+                    fn simulateDelegatecall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::simulateDelegatecall)
+                    }
+                    simulateDelegatecall
+                },
+                {
+                    fn timestampLastMinting(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowProtocolTokenCalls::timestampLastMinting)
+                    }
+                    timestampLastMinting
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowProtocolTokenCalls,
+            >] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowProtocolTokenCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowProtocolTokenCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn simulateDelegatecallInternal(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::simulateDelegatecallInternal)
+                    }
+                    simulateDelegatecallInternal
+                },
+                {
+                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowProtocolTokenCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn MAX_YEARLY_INFLATION(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::MAX_YEARLY_INFLATION)
+                    }
+                    MAX_YEARLY_INFLATION
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn TIME_BETWEEN_MINTINGS(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::TIME_BETWEEN_MINTINGS)
+                    }
+                    TIME_BETWEEN_MINTINGS
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn cowDao(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <cowDaoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenCalls::cowDao)
+                    }
+                    cowDao
+                },
+                {
+                    fn simulateDelegatecall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::simulateDelegatecall)
+                    }
+                    simulateDelegatecall
+                },
+                {
+                    fn timestampLastMinting(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
+                        <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowProtocolTokenCalls::timestampLastMinting)
+                    }
+                    timestampLastMinting
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::MAX_YEARLY_INFLATION(inner) => {
+                    <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::TIME_BETWEEN_MINTINGS(inner) => {
+                    <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::cowDao(inner) => {
+                    <cowDaoCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulateDelegatecall(inner) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulateDelegatecallInternal(inner) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::timestampLastMinting(inner) => {
+                    <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::MAX_YEARLY_INFLATION(inner) => {
+                    <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::TIME_BETWEEN_MINTINGS(inner) => {
+                    <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::cowDao(inner) => {
+                    <cowDaoCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::simulateDelegatecall(inner) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::simulateDelegatecallInternal(inner) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::timestampLastMinting(inner) => {
+                    <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowProtocolToken`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowProtocolTokenErrors {
+        #[allow(missing_docs)]
+        AlreadyInflated(AlreadyInflated),
+        #[allow(missing_docs)]
+        ExceedingMintCap(ExceedingMintCap),
+        #[allow(missing_docs)]
+        OnlyCowDao(OnlyCowDao),
+    }
+    impl CowProtocolTokenErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [44u8, 106u8, 242u8, 8u8],
+            [123u8, 6u8, 71u8, 21u8],
+            [254u8, 114u8, 195u8, 110u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <ExceedingMintCap as alloy_sol_types::SolError>::SIGNATURE,
+            <AlreadyInflated as alloy_sol_types::SolError>::SIGNATURE,
+            <OnlyCowDao as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(ExceedingMintCap),
+            ::core::stringify!(AlreadyInflated),
+            ::core::stringify!(OnlyCowDao),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowProtocolTokenErrors {
+        const COUNT: usize = 3usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowProtocolTokenErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::AlreadyInflated(_) => {
+                    <AlreadyInflated as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ExceedingMintCap(_) => {
+                    <ExceedingMintCap as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OnlyCowDao(_) => <OnlyCowDao as alloy_sol_types::SolError>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CowProtocolTokenErrors>] =
+                &[
+                    {
+                        fn ExceedingMintCap(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<CowProtocolTokenErrors>
+                        {
+                            <ExceedingMintCap as alloy_sol_types::SolError>::abi_decode_raw(data)
+                                .map(CowProtocolTokenErrors::ExceedingMintCap)
+                        }
+                        ExceedingMintCap
+                    },
+                    {
+                        fn AlreadyInflated(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<CowProtocolTokenErrors>
+                        {
+                            <AlreadyInflated as alloy_sol_types::SolError>::abi_decode_raw(data)
+                                .map(CowProtocolTokenErrors::AlreadyInflated)
+                        }
+                        AlreadyInflated
+                    },
+                    {
+                        fn OnlyCowDao(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<CowProtocolTokenErrors>
+                        {
+                            <OnlyCowDao as alloy_sol_types::SolError>::abi_decode_raw(data)
+                                .map(CowProtocolTokenErrors::OnlyCowDao)
+                        }
+                        OnlyCowDao
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowProtocolTokenErrors,
+            >] = &[
+                {
+                    fn ExceedingMintCap(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenErrors> {
+                        <ExceedingMintCap as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowProtocolTokenErrors::ExceedingMintCap)
+                    }
+                    ExceedingMintCap
+                },
+                {
+                    fn AlreadyInflated(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowProtocolTokenErrors> {
+                        <AlreadyInflated as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowProtocolTokenErrors::AlreadyInflated)
+                    }
+                    AlreadyInflated
+                },
+                {
+                    fn OnlyCowDao(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenErrors> {
+                        <OnlyCowDao as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(CowProtocolTokenErrors::OnlyCowDao)
+                    }
+                    OnlyCowDao
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::AlreadyInflated(inner) => {
+                    <AlreadyInflated as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::ExceedingMintCap(inner) => {
+                    <ExceedingMintCap as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::OnlyCowDao(inner) => {
+                    <OnlyCowDao as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::AlreadyInflated(inner) => {
+                    <AlreadyInflated as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::ExceedingMintCap(inner) => {
+                    <ExceedingMintCap as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::OnlyCowDao(inner) => {
+                    <OnlyCowDao as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowProtocolToken`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowProtocolTokenEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl CowProtocolTokenEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] =
+            &[::core::stringify!(Approval), ::core::stringify!(Transfer)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CowProtocolTokenEvents {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "CowProtocolTokenEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CowProtocolTokenEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowProtocolToken`](self) contract instance.
+
+    See the [wrapper's documentation](`CowProtocolTokenInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowProtocolTokenInstance<P, N> {
+        CowProtocolTokenInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        initialTokenHolder: alloy_sol_types::private::Address,
+        cowDao: alloy_sol_types::private::Address,
+        totalSupply: alloy_sol_types::private::primitives::aliases::U256,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<CowProtocolTokenInstance<P, N>>>
+    {
+        CowProtocolTokenInstance::<P, N>::deploy(
+            __provider,
+            initialTokenHolder,
+            cowDao,
+            totalSupply,
+        )
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        initialTokenHolder: alloy_sol_types::private::Address,
+        cowDao: alloy_sol_types::private::Address,
+        totalSupply: alloy_sol_types::private::primitives::aliases::U256,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CowProtocolTokenInstance::<P, N>::deploy_builder(
+            __provider,
+            initialTokenHolder,
+            cowDao,
+            totalSupply,
+        )
+    }
+    /**A [`CowProtocolToken`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowProtocolToken`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowProtocolTokenInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowProtocolTokenInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowProtocolTokenInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowProtocolTokenInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowProtocolToken`](self) contract instance.
+
+        See the [wrapper's documentation](`CowProtocolTokenInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            initialTokenHolder: alloy_sol_types::private::Address,
+            cowDao: alloy_sol_types::private::Address,
+            totalSupply: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::Result<CowProtocolTokenInstance<P, N>> {
+            let call_builder =
+                Self::deploy_builder(__provider, initialTokenHolder, cowDao, totalSupply);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            initialTokenHolder: alloy_sol_types::private::Address,
+            cowDao: alloy_sol_types::private::Address,
+            totalSupply: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        initialTokenHolder,
+                        cowDao,
+                        totalSupply,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowProtocolTokenInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowProtocolTokenInstance<P, N> {
+            CowProtocolTokenInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowProtocolTokenInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`MAX_YEARLY_INFLATION`]
+        /// function.
+        pub fn MAX_YEARLY_INFLATION(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, MAX_YEARLY_INFLATIONCall, N> {
+            self.call_builder(&MAX_YEARLY_INFLATIONCall)
+        }
+
+        ///Creates a new call builder for the [`TIME_BETWEEN_MINTINGS`]
+        /// function.
+        pub fn TIME_BETWEEN_MINTINGS(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, TIME_BETWEEN_MINTINGSCall, N> {
+            self.call_builder(&TIME_BETWEEN_MINTINGSCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`cowDao`] function.
+        pub fn cowDao(&self) -> alloy_contract::SolCallBuilder<&P, cowDaoCall, N> {
+            self.call_builder(&cowDaoCall)
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`decreaseAllowance`] function.
+        pub fn decreaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
+            self.call_builder(&decreaseAllowanceCall {
+                spender,
+                subtractedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`getStorageAt`] function.
+        pub fn getStorageAt(
+            &self,
+            offset: alloy_sol_types::private::primitives::aliases::U256,
+            length: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
+            self.call_builder(&getStorageAtCall { offset, length })
+        }
+
+        ///Creates a new call builder for the [`increaseAllowance`] function.
+        pub fn increaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
+            self.call_builder(&increaseAllowanceCall {
+                spender,
+                addedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            target: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { target, amount })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`simulateDelegatecall`]
+        /// function.
+        pub fn simulateDelegatecall(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallCall, N> {
+            self.call_builder(&simulateDelegatecallCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`simulateDelegatecallInternal`]
+        /// function.
+        pub fn simulateDelegatecallInternal(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallInternalCall, N> {
+            self.call_builder(&simulateDelegatecallInternalCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`timestampLastMinting`]
+        /// function.
+        pub fn timestampLastMinting(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, timestampLastMintingCall, N> {
+            self.call_builder(&timestampLastMintingCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowProtocolTokenInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = CowProtocolToken::CowProtocolTokenInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x177127622c4A00F3d409B75571e12cB3c8973d3c"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0xc694a91e6b071bF030A18BD3053A7fE09B6DaE69"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xcb8b5CD20BdCaea9a010aC1F8d835824F5C87A04"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x0625aFB445C3B6B7B929342a04A22599fd5dBB59"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/cowsettlementforwarder/Cargo.toml b/contracts/generated/contracts-generated/cowsettlementforwarder/Cargo.toml
new file mode 100644
index 0000000000..3c4e9baed8
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowsettlementforwarder/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowsettlementforwarder"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowsettlementforwarder/src/lib.rs b/contracts/generated/contracts-generated/cowsettlementforwarder/src/lib.rs
new file mode 100644
index 0000000000..c22351f5ef
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowsettlementforwarder/src/lib.rs
@@ -0,0 +1,1419 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface CowSettlementForwarder {
+    error Unauthorized();
+
+    event ApprovedCallerSet(address indexed caller, bool approved);
+
+    function forward(address target, bytes memory data) external payable;
+    function isApprovedCaller(address) external view returns (bool);
+    function setApprovedCallers(address[] memory callers, bool approved) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "forward",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "isApprovedCaller",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setApprovedCallers",
+    "inputs": [
+      {
+        "name": "callers",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "ApprovedCallerSet",
+    "inputs": [
+      {
+        "name": "caller",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "Unauthorized",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowSettlementForwarder {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x6080604052348015600e575f5ffd5b506104558061001c5f395ff3fe608060405260043610610033575f3560e01c80636fadcf7214610037578063913091181461004c578063dbce662a1461008e575b5f5ffd5b61004a6100453660046102e8565b6100ad565b005b348015610057575f5ffd5b5061007a610066366004610366565b5f6020819052908152604090205460ff1681565b604051901515815260200160405180910390f35b348015610099575f5ffd5b5061004a6100a8366004610386565b61017b565b335f9081526020819052604090205460ff166100f5576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5f8473ffffffffffffffffffffffffffffffffffffffff1634858560405161011f92919061040c565b5f6040518083038185875af1925050503d805f8114610159576040519150601f19603f3d011682016040523d82523d5f602084013e61015e565b606091505b5091509150815f811461017357815160208301f35b815160208301fd5b3330146101b4576040517f82b4290000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5b828110156102ba57815f5f8686858181106101d3576101d361041b565b90506020020160208101906101e89190610366565b73ffffffffffffffffffffffffffffffffffffffff16815260208101919091526040015f2080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001691151591909117905583838281811061024c5761024c61041b565b90506020020160208101906102619190610366565b73ffffffffffffffffffffffffffffffffffffffff167f68ed3b38c2f0d62db783d9c67eaf2c4af5a242f77c7280ef00694036995009f0836040516102aa911515815260200190565b60405180910390a26001016101b6565b50505050565b803573ffffffffffffffffffffffffffffffffffffffff811681146102e3575f5ffd5b919050565b5f5f5f604084860312156102fa575f5ffd5b610303846102c0565b9250602084013567ffffffffffffffff81111561031e575f5ffd5b8401601f8101861361032e575f5ffd5b803567ffffffffffffffff811115610344575f5ffd5b866020828401011115610355575f5ffd5b939660209190910195509293505050565b5f60208284031215610376575f5ffd5b61037f826102c0565b9392505050565b5f5f5f60408486031215610398575f5ffd5b833567ffffffffffffffff8111156103ae575f5ffd5b8401601f810186136103be575f5ffd5b803567ffffffffffffffff8111156103d4575f5ffd5b8660208260051b84010111156103e8575f5ffd5b6020918201945092508401358015158114610401575f5ffd5b809150509250925092565b818382375f9101908152919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffdfea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x04U\x80a\0\x1C_9_\xF3\xFE`\x80`@R`\x046\x10a\x003W_5`\xE0\x1C\x80co\xAD\xCFr\x14a\x007W\x80c\x910\x91\x18\x14a\0LW\x80c\xDB\xCEf*\x14a\0\x8EW[__\xFD[a\0Ja\0E6`\x04a\x02\xE8V[a\0\xADV[\0[4\x80\x15a\0WW__\xFD[Pa\0za\0f6`\x04a\x03fV[_` \x81\x90R\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\0\x99W__\xFD[Pa\0Ja\0\xA86`\x04a\x03\x86V[a\x01{V[3_\x90\x81R` \x81\x90R`@\x90 T`\xFF\x16a\0\xF5W`@Q\x7F\x82\xB4)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[__\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x164\x85\x85`@Qa\x01\x1F\x92\x91\x90a\x04\x0CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x01YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01^V[``\x91P[P\x91P\x91P\x81_\x81\x14a\x01sW\x81Q` \x83\x01\xF3[\x81Q` \x83\x01\xFD[30\x14a\x01\xB4W`@Q\x7F\x82\xB4)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82\x81\x10\x15a\x02\xBAW\x81__\x86\x86\x85\x81\x81\x10a\x01\xD3Wa\x01\xD3a\x04\x1BV[\x90P` \x02\x01` \x81\x01\x90a\x01\xE8\x91\x90a\x03fV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x91\x15\x15\x91\x90\x91\x17\x90U\x83\x83\x82\x81\x81\x10a\x02LWa\x02La\x04\x1BV[\x90P` \x02\x01` \x81\x01\x90a\x02a\x91\x90a\x03fV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fh\xED;8\xC2\xF0\xD6-\xB7\x83\xD9\xC6~\xAF,J\xF5\xA2B\xF7|r\x80\xEF\0i@6\x99P\t\xF0\x83`@Qa\x02\xAA\x91\x15\x15\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2`\x01\x01a\x01\xB6V[PPPPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02\xE3W__\xFD[\x91\x90PV[___`@\x84\x86\x03\x12\x15a\x02\xFAW__\xFD[a\x03\x03\x84a\x02\xC0V[\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\x1EW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03DW__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\x03UW__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[_` \x82\x84\x03\x12\x15a\x03vW__\xFD[a\x03\x7F\x82a\x02\xC0V[\x93\x92PPPV[___`@\x84\x86\x03\x12\x15a\x03\x98W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xAEW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03\xBEW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xD4W__\xFD[\x86` \x82`\x05\x1B\x84\x01\x01\x11\x15a\x03\xE8W__\xFD[` \x91\x82\x01\x94P\x92P\x84\x015\x80\x15\x15\x81\x14a\x04\x01W__\xFD[\x80\x91PP\x92P\x92P\x92V[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`\x046\x10a\x003W_5`\xE0\x1C\x80co\xAD\xCFr\x14a\x007W\x80c\x910\x91\x18\x14a\0LW\x80c\xDB\xCEf*\x14a\0\x8EW[__\xFD[a\0Ja\0E6`\x04a\x02\xE8V[a\0\xADV[\0[4\x80\x15a\0WW__\xFD[Pa\0za\0f6`\x04a\x03fV[_` \x81\x90R\x90\x81R`@\x90 T`\xFF\x16\x81V[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\0\x99W__\xFD[Pa\0Ja\0\xA86`\x04a\x03\x86V[a\x01{V[3_\x90\x81R` \x81\x90R`@\x90 T`\xFF\x16a\0\xF5W`@Q\x7F\x82\xB4)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[__\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x164\x85\x85`@Qa\x01\x1F\x92\x91\x90a\x04\x0CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x01YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01^V[``\x91P[P\x91P\x91P\x81_\x81\x14a\x01sW\x81Q` \x83\x01\xF3[\x81Q` \x83\x01\xFD[30\x14a\x01\xB4W`@Q\x7F\x82\xB4)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_[\x82\x81\x10\x15a\x02\xBAW\x81__\x86\x86\x85\x81\x81\x10a\x01\xD3Wa\x01\xD3a\x04\x1BV[\x90P` \x02\x01` \x81\x01\x90a\x01\xE8\x91\x90a\x03fV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x81\x01\x91\x90\x91R`@\x01_ \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x91\x15\x15\x91\x90\x91\x17\x90U\x83\x83\x82\x81\x81\x10a\x02LWa\x02La\x04\x1BV[\x90P` \x02\x01` \x81\x01\x90a\x02a\x91\x90a\x03fV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fh\xED;8\xC2\xF0\xD6-\xB7\x83\xD9\xC6~\xAF,J\xF5\xA2B\xF7|r\x80\xEF\0i@6\x99P\t\xF0\x83`@Qa\x02\xAA\x91\x15\x15\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2`\x01\x01a\x01\xB6V[PPPPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02\xE3W__\xFD[\x91\x90PV[___`@\x84\x86\x03\x12\x15a\x02\xFAW__\xFD[a\x03\x03\x84a\x02\xC0V[\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\x1EW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03DW__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\x03UW__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[_` \x82\x84\x03\x12\x15a\x03vW__\xFD[a\x03\x7F\x82a\x02\xC0V[\x93\x92PPPV[___`@\x84\x86\x03\x12\x15a\x03\x98W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xAEW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03\xBEW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xD4W__\xFD[\x86` \x82`\x05\x1B\x84\x01\x01\x11\x15a\x03\xE8W__\xFD[` \x91\x82\x01\x94P\x92P\x84\x015\x80\x15\x15\x81\x14a\x04\x01W__\xFD[\x80\x91PP\x92P\x92P\x92V[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `Unauthorized()` and selector `0x82b42900`.
+    ```solidity
+    error Unauthorized();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Unauthorized;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Unauthorized> for UnderlyingRustTuple<'_> {
+            fn from(value: Unauthorized) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Unauthorized {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for Unauthorized {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [130u8, 180u8, 41u8, 0u8];
+            const SIGNATURE: &'static str = "Unauthorized()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ApprovedCallerSet(address,bool)` and selector `0x68ed3b38c2f0d62db783d9c67eaf2c4af5a242f77c7280ef00694036995009f0`.
+    ```solidity
+    event ApprovedCallerSet(address indexed caller, bool approved);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ApprovedCallerSet {
+        #[allow(missing_docs)]
+        pub caller: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub approved: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ApprovedCallerSet {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ApprovedCallerSet(address,bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    104u8, 237u8, 59u8, 56u8, 194u8, 240u8, 214u8, 45u8, 183u8, 131u8, 217u8,
+                    198u8, 126u8, 175u8, 44u8, 74u8, 245u8, 162u8, 66u8, 247u8, 124u8, 114u8,
+                    128u8, 239u8, 0u8, 105u8, 64u8, 54u8, 153u8, 80u8, 9u8, 240u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    caller: topics.1,
+                    approved: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approved,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.caller.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.caller,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ApprovedCallerSet {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ApprovedCallerSet> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ApprovedCallerSet) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `forward(address,bytes)` and selector `0x6fadcf72`.
+    ```solidity
+    function forward(address target, bytes memory data) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct forwardCall {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`forward(address,bytes)`](forwardCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct forwardReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<forwardCall> for UnderlyingRustTuple<'_> {
+                fn from(value: forwardCall) -> Self {
+                    (value.target, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for forwardCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        target: tuple.0,
+                        data: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<forwardReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: forwardReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for forwardReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl forwardReturn {
+            fn _tokenize(&self) -> <forwardCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for forwardCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = forwardReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [111u8, 173u8, 207u8, 114u8];
+            const SIGNATURE: &'static str = "forward(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                forwardReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isApprovedCaller(address)` and selector `0x91309118`.
+    ```solidity
+    function isApprovedCaller(address) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isApprovedCallerCall(pub alloy_sol_types::private::Address);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isApprovedCaller(address)`](isApprovedCallerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isApprovedCallerReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isApprovedCallerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isApprovedCallerCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isApprovedCallerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isApprovedCallerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isApprovedCallerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isApprovedCallerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isApprovedCallerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [145u8, 48u8, 145u8, 24u8];
+            const SIGNATURE: &'static str = "isApprovedCaller(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isApprovedCallerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isApprovedCallerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setApprovedCallers(address[],bool)` and selector `0xdbce662a`.
+    ```solidity
+    function setApprovedCallers(address[] memory callers, bool approved) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setApprovedCallersCall {
+        #[allow(missing_docs)]
+        pub callers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub approved: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setApprovedCallers(address[],bool)`](setApprovedCallersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setApprovedCallersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setApprovedCallersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setApprovedCallersCall) -> Self {
+                    (value.callers, value.approved)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setApprovedCallersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        callers: tuple.0,
+                        approved: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setApprovedCallersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setApprovedCallersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setApprovedCallersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setApprovedCallersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setApprovedCallersCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setApprovedCallersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = setApprovedCallersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [219u8, 206u8, 102u8, 42u8];
+            const SIGNATURE: &'static str = "setApprovedCallers(address[],bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.callers),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approved,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setApprovedCallersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`CowSettlementForwarder`](self) function calls.
+    #[derive(Clone)]
+    pub enum CowSettlementForwarderCalls {
+        #[allow(missing_docs)]
+        forward(forwardCall),
+        #[allow(missing_docs)]
+        isApprovedCaller(isApprovedCallerCall),
+        #[allow(missing_docs)]
+        setApprovedCallers(setApprovedCallersCall),
+    }
+    impl CowSettlementForwarderCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [111u8, 173u8, 207u8, 114u8],
+            [145u8, 48u8, 145u8, 24u8],
+            [219u8, 206u8, 102u8, 42u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <forwardCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isApprovedCallerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setApprovedCallersCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(forward),
+            ::core::stringify!(isApprovedCaller),
+            ::core::stringify!(setApprovedCallers),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowSettlementForwarderCalls {
+        const COUNT: usize = 3usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
+        const NAME: &'static str = "CowSettlementForwarderCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::forward(_) => <forwardCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isApprovedCaller(_) => {
+                    <isApprovedCallerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setApprovedCallers(_) => {
+                    <setApprovedCallersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CowSettlementForwarderCalls>] = &[
+                {
+                    fn forward(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowSettlementForwarderCalls> {
+                        <forwardCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowSettlementForwarderCalls::forward)
+                    }
+                    forward
+                },
+                {
+                    fn isApprovedCaller(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowSettlementForwarderCalls> {
+                        <isApprovedCallerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowSettlementForwarderCalls::isApprovedCaller)
+                    }
+                    isApprovedCaller
+                },
+                {
+                    fn setApprovedCallers(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowSettlementForwarderCalls> {
+                        <setApprovedCallersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CowSettlementForwarderCalls::setApprovedCallers)
+                    }
+                    setApprovedCallers
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowSettlementForwarderCalls,
+            >] = &[
+                {
+                    fn forward(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowSettlementForwarderCalls> {
+                        <forwardCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CowSettlementForwarderCalls::forward)
+                    }
+                    forward
+                },
+                {
+                    fn isApprovedCaller(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowSettlementForwarderCalls> {
+                        <isApprovedCallerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CowSettlementForwarderCalls::isApprovedCaller)
+                    }
+                    isApprovedCaller
+                },
+                {
+                    fn setApprovedCallers(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CowSettlementForwarderCalls> {
+                        <setApprovedCallersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CowSettlementForwarderCalls::setApprovedCallers)
+                    }
+                    setApprovedCallers
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::forward(inner) => {
+                    <forwardCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isApprovedCaller(inner) => {
+                    <isApprovedCallerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setApprovedCallers(inner) => {
+                    <setApprovedCallersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::forward(inner) => {
+                    <forwardCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isApprovedCaller(inner) => {
+                    <isApprovedCallerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setApprovedCallers(inner) => {
+                    <setApprovedCallersCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowSettlementForwarder`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowSettlementForwarderErrors {
+        #[allow(missing_docs)]
+        Unauthorized(Unauthorized),
+    }
+    impl CowSettlementForwarderErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[130u8, 180u8, 41u8, 0u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<Unauthorized as alloy_sol_types::SolError>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(Unauthorized)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CowSettlementForwarderErrors {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CowSettlementForwarderErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::Unauthorized(_) => <Unauthorized as alloy_sol_types::SolError>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CowSettlementForwarderErrors>] = &[{
+                fn Unauthorized(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<CowSettlementForwarderErrors> {
+                    <Unauthorized as alloy_sol_types::SolError>::abi_decode_raw(data)
+                        .map(CowSettlementForwarderErrors::Unauthorized)
+                }
+                Unauthorized
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                CowSettlementForwarderErrors,
+            >] = &[{
+                fn Unauthorized(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<CowSettlementForwarderErrors> {
+                    <Unauthorized as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                        .map(CowSettlementForwarderErrors::Unauthorized)
+                }
+                Unauthorized
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::Unauthorized(inner) => {
+                    <Unauthorized as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::Unauthorized(inner) => {
+                    <Unauthorized as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CowSettlementForwarder`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CowSettlementForwarderEvents {
+        #[allow(missing_docs)]
+        ApprovedCallerSet(ApprovedCallerSet),
+    }
+    impl CowSettlementForwarderEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            104u8, 237u8, 59u8, 56u8, 194u8, 240u8, 214u8, 45u8, 183u8, 131u8, 217u8, 198u8, 126u8,
+            175u8, 44u8, 74u8, 245u8, 162u8, 66u8, 247u8, 124u8, 114u8, 128u8, 239u8, 0u8, 105u8,
+            64u8, 54u8, 153u8, 80u8, 9u8, 240u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<ApprovedCallerSet as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(ApprovedCallerSet)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CowSettlementForwarderEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "CowSettlementForwarderEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<ApprovedCallerSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ApprovedCallerSet as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ApprovedCallerSet)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CowSettlementForwarderEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ApprovedCallerSet(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ApprovedCallerSet(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CowSettlementForwarder`](self) contract instance.
+
+    See the [wrapper's documentation](`CowSettlementForwarderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CowSettlementForwarderInstance<P, N> {
+        CowSettlementForwarderInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<CowSettlementForwarderInstance<P, N>>>
+    {
+        CowSettlementForwarderInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CowSettlementForwarderInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`CowSettlementForwarder`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CowSettlementForwarder`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CowSettlementForwarderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CowSettlementForwarderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CowSettlementForwarderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowSettlementForwarderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CowSettlementForwarder`](self) contract instance.
+
+        See the [wrapper's documentation](`CowSettlementForwarderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<CowSettlementForwarderInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CowSettlementForwarderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CowSettlementForwarderInstance<P, N> {
+            CowSettlementForwarderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowSettlementForwarderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`forward`] function.
+        pub fn forward(
+            &self,
+            target: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, forwardCall, N> {
+            self.call_builder(&forwardCall { target, data })
+        }
+
+        ///Creates a new call builder for the [`isApprovedCaller`] function.
+        pub fn isApprovedCaller(
+            &self,
+            _0: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isApprovedCallerCall, N> {
+            self.call_builder(&isApprovedCallerCall(_0))
+        }
+
+        ///Creates a new call builder for the [`setApprovedCallers`] function.
+        pub fn setApprovedCallers(
+            &self,
+            callers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            approved: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setApprovedCallersCall, N> {
+            self.call_builder(&setApprovedCallersCall { callers, approved })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CowSettlementForwarderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`ApprovedCallerSet`] event.
+        pub fn ApprovedCallerSet_filter(&self) -> alloy_contract::Event<&P, ApprovedCallerSet, N> {
+            self.event_filter::<ApprovedCallerSet>()
+        }
+    }
+}
+pub type Instance =
+    CowSettlementForwarder::CowSettlementForwarderInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/cowswapethflow/Cargo.toml b/contracts/generated/contracts-generated/cowswapethflow/Cargo.toml
new file mode 100644
index 0000000000..a0532ea4de
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowswapethflow/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowswapethflow"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs b/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
new file mode 100644
index 0000000000..eef46097a3
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
@@ -0,0 +1,5891 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library EthFlowOrder {
+    struct Data { address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; bytes32 appData; uint256 feeAmount; uint32 validTo; bool partiallyFillable; int64 quoteId; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod EthFlowOrder {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; bytes32 appData; uint256 feeAmount; uint32 validTo; bool partiallyFillable; int64 quoteId; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub partiallyFillable: bool,
+        #[allow(missing_docs)]
+        pub quoteId: i64,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Int<64>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            bool,
+            i64,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.buyToken,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.appData,
+                    value.feeAmount,
+                    value.validTo,
+                    value.partiallyFillable,
+                    value.quoteId,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    buyToken: tuple.0,
+                    receiver: tuple.1,
+                    sellAmount: tuple.2,
+                    buyAmount: tuple.3,
+                    appData: tuple.4,
+                    feeAmount: tuple.5,
+                    validTo: tuple.6,
+                    partiallyFillable: tuple.7,
+                    quoteId: tuple.8,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.partiallyFillable,
+                    ),
+                    <alloy_sol_types::sol_data::Int<
+                        64,
+                    > as alloy_sol_types::SolType>::tokenize(&self.quoteId),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address buyToken,address receiver,uint256 sellAmount,uint256 \
+                     buyAmount,bytes32 appData,uint256 feeAmount,uint32 validTo,bool \
+                     partiallyFillable,int64 quoteId)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.partiallyFillable,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Int<
+                        64,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.quoteId)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.partiallyFillable,
+                    )
+                    + <alloy_sol_types::sol_data::Int<
+                        64,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.quoteId,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.partiallyFillable,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Int<
+                    64,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.quoteId,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`EthFlowOrder`](self) contract instance.
+
+    See the [wrapper's documentation](`EthFlowOrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> EthFlowOrderInstance<P, N> {
+        EthFlowOrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`EthFlowOrder`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`EthFlowOrder`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct EthFlowOrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for EthFlowOrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("EthFlowOrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        EthFlowOrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`EthFlowOrder`](self) contract instance.
+
+        See the [wrapper's documentation](`EthFlowOrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> EthFlowOrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> EthFlowOrderInstance<P, N> {
+            EthFlowOrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        EthFlowOrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        EthFlowOrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Order {
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Order {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub kind: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub partiallyFillable: bool,
+        #[allow(missing_docs)]
+        pub sellTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub buyTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            bool,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.sellToken,
+                    value.buyToken,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.validTo,
+                    value.appData,
+                    value.feeAmount,
+                    value.kind,
+                    value.partiallyFillable,
+                    value.sellTokenBalance,
+                    value.buyTokenBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sellToken: tuple.0,
+                    buyToken: tuple.1,
+                    receiver: tuple.2,
+                    sellAmount: tuple.3,
+                    buyAmount: tuple.4,
+                    validTo: tuple.5,
+                    appData: tuple.6,
+                    feeAmount: tuple.7,
+                    kind: tuple.8,
+                    partiallyFillable: tuple.9,
+                    sellTokenBalance: tuple.10,
+                    buyTokenBalance: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.partiallyFillable,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenBalance),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenBalance),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address sellToken,address buyToken,address receiver,uint256 \
+                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
+                     feeAmount,bytes32 kind,bool partiallyFillable,bytes32 \
+                     sellTokenBalance,bytes32 buyTokenBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.partiallyFillable,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellTokenBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyTokenBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.kind)
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.partiallyFillable,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellTokenBalance,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyTokenBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.partiallyFillable,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellTokenBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyTokenBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2OrderInstance<P, N> {
+        GPv2OrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Order`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Order`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2OrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2OrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2OrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2OrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2OrderInstance<P, N> {
+            GPv2OrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ICoWSwapOnchainOrders {
+    type OnchainSigningScheme is uint8;
+    struct OnchainSignature { OnchainSigningScheme scheme; bytes data; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ICoWSwapOnchainOrders {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnchainSigningScheme(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<OnchainSigningScheme> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl OnchainSigningScheme {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for OnchainSigningScheme {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<OnchainSigningScheme> for u8 {
+            fn from(value: OnchainSigningScheme) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OnchainSigningScheme {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OnchainSigningScheme {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OnchainSignature { OnchainSigningScheme scheme; bytes data; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnchainSignature {
+        #[allow(missing_docs)]
+        pub scheme: <OnchainSigningScheme as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (OnchainSigningScheme, alloy_sol_types::sol_data::Bytes);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <OnchainSigningScheme as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OnchainSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: OnchainSignature) -> Self {
+                (value.scheme, value.data)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnchainSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    scheme: tuple.0,
+                    data: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for OnchainSignature {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for OnchainSignature {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <OnchainSigningScheme as alloy_sol_types::SolType>::tokenize(&self.scheme),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OnchainSignature {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for OnchainSignature {
+            const NAME: &'static str = "OnchainSignature";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed("OnchainSignature(uint8 scheme,bytes data)")
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <OnchainSigningScheme as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.scheme,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.data,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OnchainSignature {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <OnchainSigningScheme as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.scheme,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.data,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <OnchainSigningScheme as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.scheme,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.data,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ICoWSwapOnchainOrders`](self) contract instance.
+
+    See the [wrapper's documentation](`ICoWSwapOnchainOrdersInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ICoWSwapOnchainOrdersInstance<P, N> {
+        ICoWSwapOnchainOrdersInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ICoWSwapOnchainOrders`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ICoWSwapOnchainOrders`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ICoWSwapOnchainOrdersInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ICoWSwapOnchainOrdersInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ICoWSwapOnchainOrdersInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICoWSwapOnchainOrdersInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ICoWSwapOnchainOrders`](self) contract instance.
+
+        See the [wrapper's documentation](`ICoWSwapOnchainOrdersInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ICoWSwapOnchainOrdersInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ICoWSwapOnchainOrdersInstance<P, N> {
+            ICoWSwapOnchainOrdersInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICoWSwapOnchainOrdersInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICoWSwapOnchainOrdersInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library EthFlowOrder {
+    struct Data {
+        address buyToken;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        bytes32 appData;
+        uint256 feeAmount;
+        uint32 validTo;
+        bool partiallyFillable;
+        int64 quoteId;
+    }
+}
+
+library GPv2Order {
+    struct Data {
+        address sellToken;
+        address buyToken;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        uint32 validTo;
+        bytes32 appData;
+        uint256 feeAmount;
+        bytes32 kind;
+        bool partiallyFillable;
+        bytes32 sellTokenBalance;
+        bytes32 buyTokenBalance;
+    }
+}
+
+library ICoWSwapOnchainOrders {
+    type OnchainSigningScheme is uint8;
+    struct OnchainSignature {
+        OnchainSigningScheme scheme;
+        bytes data;
+    }
+}
+
+interface CoWSwapEthFlow {
+    error EthTransferFailed();
+    error IncorrectEthAmount();
+    error NotAllowedToInvalidateOrder(bytes32 orderHash);
+    error NotAllowedZeroSellAmount();
+    error OrderIsAlreadyExpired();
+    error OrderIsAlreadyOwned(bytes32 orderHash);
+    error ReceiverMustBeSet();
+
+    event OrderInvalidation(bytes orderUid);
+    event OrderPlacement(address indexed sender, GPv2Order.Data order, ICoWSwapOnchainOrders.OnchainSignature signature, bytes data);
+    event OrderRefund(bytes orderUid, address indexed refunder);
+
+    constructor(address _cowSwapSettlement, address _wrappedNativeToken);
+
+    receive() external payable;
+
+    function cowSwapSettlement() external view returns (address);
+    function createOrder(EthFlowOrder.Data memory order) external payable returns (bytes32 orderHash);
+    function invalidateOrder(EthFlowOrder.Data memory order) external;
+    function invalidateOrdersIgnoringNotAllowed(EthFlowOrder.Data[] memory orderArray) external;
+    function isValidSignature(bytes32 orderHash, bytes memory) external view returns (bytes4);
+    function orders(bytes32) external view returns (address owner, uint32 validTo);
+    function unwrap(uint256 amount) external;
+    function wrap(uint256 amount) external;
+    function wrapAll() external;
+    function wrappedNativeToken() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_cowSwapSettlement",
+        "type": "address",
+        "internalType": "contract ICoWSwapSettlement"
+      },
+      {
+        "name": "_wrappedNativeToken",
+        "type": "address",
+        "internalType": "contract IWrappedNativeToken"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "cowSwapSettlement",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ICoWSwapSettlement"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "createOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct EthFlowOrder.Data",
+        "components": [
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "quoteId",
+            "type": "int64",
+            "internalType": "int64"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "invalidateOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct EthFlowOrder.Data",
+        "components": [
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "quoteId",
+            "type": "int64",
+            "internalType": "int64"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "invalidateOrdersIgnoringNotAllowed",
+    "inputs": [
+      {
+        "name": "orderArray",
+        "type": "tuple[]",
+        "internalType": "struct EthFlowOrder.Data[]",
+        "components": [
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "quoteId",
+            "type": "int64",
+            "internalType": "int64"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "orders",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "validTo",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "unwrap",
+    "inputs": [
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "wrap",
+    "inputs": [
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "wrapAll",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "wrappedNativeToken",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IWrappedNativeToken"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "OrderInvalidation",
+    "inputs": [
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderPlacement",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "order",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct GPv2Order.Data",
+        "components": [
+          {
+            "name": "sellToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "kind",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "sellTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "buyTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct ICoWSwapOnchainOrders.OnchainSignature",
+        "components": [
+          {
+            "name": "scheme",
+            "type": "uint8",
+            "internalType": "enum ICoWSwapOnchainOrders.OnchainSigningScheme"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderRefund",
+    "inputs": [
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      },
+      {
+        "name": "refunder",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "EthTransferFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "IncorrectEthAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotAllowedToInvalidateOrder",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "NotAllowedZeroSellAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderIsAlreadyExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderIsAlreadyOwned",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ReceiverMustBeSet",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CoWSwapEthFlow {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xE0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0\x1B*8\x03\x80b\0\x1B*\x839\x81\x01`@\x81\x90Rb\0\x004\x91b\0\x02\x1EV[\x81b\0\0K\x81b\0\x01R` \x1Bb\0\x08\x9B\x17` \x1CV[`\x80RP`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\xA0\x81\x90R\x90\x82\x16`\xC0\x81\x90R`@\x80QcM\xAA\x96a`\xE1\x1B\x81R\x90Q\x91\x92c\t^\xA7\xB3\x92\x90\x91c\x9BU,\xC2\x91`\x04\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81`\0\x87Z\xF1\x15\x80\x15b\0\0\xAEW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90b\0\0\xD4\x91\x90b\0\x02]V[`@Q`\x01`\x01`\xE0\x1B\x03\x19`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`\0\x19`$\x82\x01R`D\x01` `@Q\x80\x83\x03\x81`\0\x87Z\xF1\x15\x80\x15b\0\x01#W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90b\0\x01I\x91\x90b\0\x02\x84V[PPPb\0\x02\xA8V[`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fl\x85\xC03~\xBA\x16a2\x7F\x94\xF3\xBFF\xC8\xA7\xF91\x1AV?M\\\x94\x83bV\x7F]\x8E\xD6\x0C\x91\x81\x01\x91\x90\x91R\x7F\xF9Dk\x8E\x93}\x86\xF0\xBC\x87\xCA\xC79#I\x16\x92\xB1#\xCA_\x87a\x90\x84\x94p7X j\xDF``\x82\x01RF`\x80\x82\x01\x81\x90R`\x01`\x01`\xA0\x1B\x03\x83\x16`\xA0\x83\x01R`\0\x91`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x91PP\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x02\x1BW`\0\x80\xFD[PV[`\0\x80`@\x83\x85\x03\x12\x15b\0\x022W`\0\x80\xFD[\x82Qb\0\x02?\x81b\0\x02\x05V[` \x84\x01Q\x90\x92Pb\0\x02R\x81b\0\x02\x05V[\x80\x91PP\x92P\x92\x90PV[`\0` \x82\x84\x03\x12\x15b\0\x02pW`\0\x80\xFD[\x81Qb\0\x02}\x81b\0\x02\x05V[\x93\x92PPPV[`\0` \x82\x84\x03\x12\x15b\0\x02\x97W`\0\x80\xFD[\x81Q\x80\x15\x15\x81\x14b\0\x02}W`\0\x80\xFD[`\x80Q`\xA0Q`\xC0Qa\x18!b\0\x03\t`\09`\0\x81\x81a\x01)\x01R\x81\x81a\x05\xFF\x01R\x81\x81a\x07\xAD\x01R\x81\x81a\x08%\x01R\x81\x81a\x0C3\x01Ra\x101\x01R`\0\x81\x81a\x02\xCE\x01Ra\x0FK\x01R`\0\x81\x81a\x0B\xF7\x01Ra\x0C\xD9\x01Ra\x18!`\0\xF3\xFE`\x80`@R`\x046\x10a\0\xB5W`\x005`\xE0\x1C\x80c{\xC4\x1B\x96\x11a\0iW\x80c\xDE\x0E\x9A>\x11a\0NW\x80c\xDE\x0E\x9A>\x14a\x02|W\x80c\xEAY\x8C\xB0\x14a\x02\x9CW\x80c\xEC0\xBB\x88\x14a\x02\xBCW`\0\x80\xFD[\x80c{\xC4\x1B\x96\x14a\x01\xC8W\x80c\x9C?\x1E\x90\x14a\x01\xE8W`\0\x80\xFD[\x80c2+\xBA!\x11a\0\x9AW\x80c2+\xBA!\x14a\x01pW\x80cL\x84\xC1\xC8\x14a\x01\x91W\x80cL\xB7d\x98\x14a\x01\xA8W`\0\x80\xFD[\x80c\x16&\xBA~\x14a\0\xC1W\x80c\x17\xFC\xB3\x9B\x14a\x01\x17W`\0\x80\xFD[6a\0\xBCW\0[`\0\x80\xFD[4\x80\x15a\0\xCDW`\0\x80\xFD[Pa\0\xE1a\0\xDC6`\x04a\x12nV[a\x02\xF0V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01#W`\0\x80\xFD[Pa\x01K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\x0EV[a\x01\x83a\x01~6`\x04a\x13+V[a\x03\xDEV[`@Q\x90\x81R` \x01a\x01\x0EV[4\x80\x15a\x01\x9DW`\0\x80\xFD[Pa\x01\xA6a\x07 V[\0[4\x80\x15a\x01\xB4W`\0\x80\xFD[Pa\x01\xA6a\x01\xC36`\x04a\x13DV[a\x07+V[4\x80\x15a\x01\xD4W`\0\x80\xFD[Pa\x01\xA6a\x01\xE36`\x04a\x13+V[a\x07pV[4\x80\x15a\x01\xF4W`\0\x80\xFD[Pa\x02Ka\x02\x036`\x04a\x13\xBAV[`\0` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x90t\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04c\xFF\xFF\xFF\xFF\x16\x82V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x93\x16\x83Rc\xFF\xFF\xFF\xFF\x90\x91\x16` \x83\x01R\x01a\x01\x0EV[4\x80\x15a\x02\x88W`\0\x80\xFD[Pa\x01\xA6a\x02\x976`\x04a\x13\xBAV[a\x07~V[4\x80\x15a\x02\xA8W`\0\x80\xFD[Pa\x01\xA6a\x02\xB76`\x04a\x13\xBAV[a\x08!V[4\x80\x15a\x02\xC8W`\0\x80\xFD[Pa\x01K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0\x82\x81R` \x81\x81R`@\x80\x83 \x81Q\x80\x83\x01\x90\x92RTs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x80\x83Rt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x04c\xFF\xFF\xFF\xFF\x16\x92\x82\x01\x92\x90\x92R\x90\x15\x80\x15\x90a\x03oWP\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x14\x15[\x80\x15a\x03\x85WPB\x81` \x01Qc\xFF\xFF\xFF\xFF\x16\x10\x15[\x15a\x03\xB3WP\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90Pa\x03\xD8V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x92\x91PPV[`\0a\x03\xF2`\xA0\x83\x015`@\x84\x015a\x14\x02V[4\x14a\x04*W`@Q\x7F\x8Bn\xBBM\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`@\x015`\0\x03a\x04hW`@Q\x7F\xEA\xEC\\\x9D\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[Ba\x04y`\xE0\x84\x01`\xC0\x85\x01a\x14.V[c\xFF\xFF\xFF\xFF\x16\x10\x15a\x04\xB7W`@Q\x7F\x89\xBB&\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x80Q\x80\x82\x01\x90\x91R3\x81R`\0\x90` \x81\x01a\x04\xDB`\xE0\x86\x01`\xC0\x87\x01a\x14.V[c\xFF\xFF\xFF\xFF\x16\x90R`@\x80Q\x80\x82\x01\x90\x91R\x90\x91P`\0\x90\x80\x82\x81R` \x010`@Q` \x01a\x056\x91\x90``\x91\x90\x91\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81R`\x14\x01\x90V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x90R\x90P`\0a\x05|a\x01 \x86\x01a\x01\0\x87\x01a\x14bV[` \x80\x85\x01Q`@Qa\x05\xC3\x93\x92\x01`\xC0\x92\x90\x92\x1B\x82R`\xE0\x1B\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x08\x82\x01R`\x0C\x01\x90V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x83Q\x90\x91Pa\x06:\x90a\x063\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06-6\x8A\x90\x03\x8A\x01\x8Aa\x14\xB1V[\x90a\t[V[\x84\x84a\x0B*V[`\0\x81\x81R` \x81\x90R`@\x90 T\x90\x94Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x06\xA1W`@Q\x7FV\xA1\xD2\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x85\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[PP`\0\x82\x81R` \x81\x81R`@\x90\x91 \x82Q\x81T\x92\x90\x93\x01Qc\xFF\xFF\xFF\xFF\x16t\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x93\x16\x92\x90\x92\x17\x17\x90U\x91\x90PV[a\x07)Ga\x08!V[V[`\0[\x81\x81\x10\x15a\x07kWa\x07Y\x83\x83\x83\x81\x81\x10a\x07KWa\x07Ka\x15KV[\x90Pa\x01 \x02\x01`\0a\x0C,V[\x80a\x07c\x81a\x15zV[\x91PPa\x07.V[PPPV[a\x07{\x81`\x01a\x0C,V[PV[`@Q\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c.\x1A}M\x90`$\x01`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x08\x06W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x08\x1AW=`\0\x80>=`\0\xFD[PPPPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82`@Q`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a\x08\x1AW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x08\x1AV[`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fl\x85\xC03~\xBA\x16a2\x7F\x94\xF3\xBFF\xC8\xA7\xF91\x1AV?M\\\x94\x83bV\x7F]\x8E\xD6\x0C\x91\x81\x01\x91\x90\x91R\x7F\xF9Dk\x8E\x93}\x86\xF0\xBC\x87\xCA\xC79#I\x16\x92\xB1#\xCA_\x87a\x90\x84\x94p7X j\xDF``\x82\x01RF`\x80\x82\x01\x81\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`\xA0\x83\x01R`\0\x91`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x91PP\x91\x90PV[`@\x80Qa\x01\x80\x81\x01\x82R`\0\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x82\x01\x81\x90R`\xC0\x82\x01\x81\x90R`\xE0\x82\x01\x81\x90Ra\x01\0\x82\x01\x81\x90Ra\x01 \x82\x01\x81\x90Ra\x01@\x82\x01\x81\x90Ra\x01`\x82\x01R\x90\x83\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\n\nW`@Q\x7F\xEF\xC9\xCC\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x80a\x01\x80\x01`@R\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x84`\0\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x84` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x84`@\x01Q\x81R` \x01\x84``\x01Q\x81R` \x01c\xFF\xFF\xFF\xFF\x80\x16\x81R` \x01\x84`\x80\x01Q\x81R` \x01\x84`\xA0\x01Q\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01\x84`\xE0\x01Q\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x90P\x92\x91PPV[`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xCF_\x9D\xE2\x98A2&R\x03\xB5\xC35\xB2W'p,\xA7rb\xFFb.\x13k\xAAsb\xBF\x1D\xA9\x85\x85\x85`@Qa\x0Bv\x93\x92\x91\x90a\x16vV[`@Q\x80\x91\x03\x90\xA2PPP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x91\x90PV[`\0a\x0Ca\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06-6\x86\x90\x03\x86\x01\x86a\x14\xB1V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@\x80Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x92\x90\x92R`B\x90\x91 `\0\x81\x81R` \x81\x81R\x90\x83\x90 \x83Q\x80\x85\x01\x90\x94RTs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16\x80\x86Rt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x04c\xFF\xFF\xFF\xFF\x16\x92\x85\x01\x83\x90R\x94\x95P\x91\x93B\x90\x91\x10\x15\x91\x14\x80a\r\x8DWP\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15[\x80a\r\xB7WP\x80\x80\x15a\r\xB7WP\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14\x15[\x15a\r\xFFW\x84\x15a\r\xF7W`@Q\x7F\xF8\xCCp\xCE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x84\x90R`$\x01a\x06\x98V[PPPPPPV[`\0\x83\x81R` \x81\x81R`@\x80\x83 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x17\x90U\x80Q`8\x80\x82R``\x82\x01\x90\x92R\x91\x82\x01\x81\x806\x837PPP`\xA0\x86\x01Q\x90\x91Pa\x0Ez\x90\x82\x90\x86\x900\x90a\x11IV[\x81\x15a\x0E\xBCW\x7F\xB8\xBA\xD1\x02\xAC\x8B\xBA\xCF\xEF1\xFF\x1C\x90n\xC6\xD9Q\xC20\xB4\xDC\xE7P\xBB\x03v\xB8\x12\xAD5\x85*\x81`@Qa\x0E\xAF\x91\x90a\x17\x90V[`@Q\x80\x91\x03\x90\xA1a\x0F\x0BV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x19Rq\x06\x8A(\x81\x91\xE4\xB2e\xC6A\xA5k\x982\x91\x9Fi\xE9\xE7\xD6\xC2\xF3\x1B\xA4\x02x\xAE\xB8Z\x82`@Qa\x0F\x02\x91\x90a\x17\x90V[`@Q\x80\x91\x03\x90\xA2[`@Q\x7F$y\xFBn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c$y\xFBn\x90a\x0F\x80\x90\x85\x90`\x04\x01a\x17\x90V[` `@Q\x80\x83\x03\x81`\0\x87Z\xF1\x15\x80\x15a\x0F\x9FW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xC3\x91\x90a\x17\xA3V[\x90P`\0\x80\x87``\x01Q\x83\x89`\xE0\x01Q\x02\x81a\x0F\xE1Wa\x0F\xE1a\x17\xBCV[\x04\x88`\xE0\x01Q\x03\x90P\x80\x83\x89``\x01Q\x03\x01\x91PP\x80G\x10\x15a\x10\xA4W`@Q\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RG\x82\x03`\x04\x82\x01\x81\x90R\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c.\x1A}M\x90`$\x01`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x10\x8AW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x10\x9EW=`\0\x80>=`\0\xFD[PPPPP[\x84Q`@Q`\0\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x83\x90\x83\x81\x81\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a\x10\xFDW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x11\x02V[``\x91P[PP\x90P\x80a\x11=W`@Q\x7Fm\x96?\x88\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPPPPPPPV[`8\x84Q\x14a\x11\xB4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGPv2: uid buffer overflow\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x98V[`8\x84\x01R`4\x83\x01R` \x90\x91\x01RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[`@Qa\x01 \x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x12\x19Wa\x12\x19a\x11\xC6V[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x12fWa\x12fa\x11\xC6V[`@R\x91\x90PV[`\0\x80`@\x83\x85\x03\x12\x15a\x12\x81W`\0\x80\xFD[\x825\x91P` \x80\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x12\xA1W`\0\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x12\xB5W`\0\x80\xFD[\x815\x81\x81\x11\x15a\x12\xC7Wa\x12\xC7a\x11\xC6V[a\x12\xF7\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x12\x1FV[\x91P\x80\x82R\x87\x84\x82\x85\x01\x01\x11\x15a\x13\rW`\0\x80\xFD[\x80\x84\x84\x01\x85\x84\x017`\0\x84\x82\x84\x01\x01RP\x80\x93PPPP\x92P\x92\x90PV[`\0a\x01 \x82\x84\x03\x12\x15a\x13>W`\0\x80\xFD[P\x91\x90PV[`\0\x80` \x83\x85\x03\x12\x15a\x13WW`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x13oW`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x13\x83W`\0\x80\xFD[\x815\x81\x81\x11\x15a\x13\x92W`\0\x80\xFD[\x86` a\x01 \x83\x02\x85\x01\x01\x11\x15a\x13\xA8W`\0\x80\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[`\0` \x82\x84\x03\x12\x15a\x13\xCCW`\0\x80\xFD[P5\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[\x80\x82\x01\x80\x82\x11\x15a\x03\xD8Wa\x03\xD8a\x13\xD3V[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x14)W`\0\x80\xFD[\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\x14@W`\0\x80\xFD[a\x14I\x82a\x14\x15V[\x93\x92PPPV[\x805`\x07\x81\x90\x0B\x81\x14a\x14)W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x14tW`\0\x80\xFD[a\x14I\x82a\x14PV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x14)W`\0\x80\xFD[\x805\x80\x15\x15\x81\x14a\x14)W`\0\x80\xFD[`\0a\x01 \x82\x84\x03\x12\x15a\x14\xC4W`\0\x80\xFD[a\x14\xCCa\x11\xF5V[a\x14\xD5\x83a\x14}V[\x81Ra\x14\xE3` \x84\x01a\x14}V[` \x82\x01R`@\x83\x015`@\x82\x01R``\x83\x015``\x82\x01R`\x80\x83\x015`\x80\x82\x01R`\xA0\x83\x015`\xA0\x82\x01Ra\x15\x1C`\xC0\x84\x01a\x14\x15V[`\xC0\x82\x01Ra\x15-`\xE0\x84\x01a\x14\xA1V[`\xE0\x82\x01Ra\x01\0a\x15@\x81\x85\x01a\x14PV[\x90\x82\x01R\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`2`\x04R`$`\0\xFD[`\0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x03a\x15\xABWa\x15\xABa\x13\xD3V[P`\x01\x01\x90V[`\0\x81Q\x80\x84R`\0[\x81\x81\x10\x15a\x15\xD8W` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01a\x15\xBCV[P`\0` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[`\0\x81Q`\x02\x81\x10a\x16QW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[\x80\x84RP` \x82\x01Q`@` \x85\x01Ra\x16n`@\x85\x01\x82a\x15\xB2V[\x94\x93PPPPV[\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\0a\x01\xC0` \x86\x01Qa\x16\xBC` \x85\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x86\x01Qa\x16\xE4`@\x85\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x86\x01Q``\x84\x01R`\x80\x86\x01Q`\x80\x84\x01R`\xA0\x86\x01Qa\x17\x10`\xA0\x85\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x86\x01Q`\xC0\x84\x01R`\xE0\x86\x01Q`\xE0\x84\x01Ra\x01\0\x80\x87\x01Q\x81\x85\x01RPa\x01 \x80\x87\x01Qa\x17E\x82\x86\x01\x82\x15\x15\x90RV[PPa\x01@\x86\x81\x01Q\x90\x84\x01Ra\x01`\x80\x87\x01Q\x90\x84\x01Ra\x01\x80\x83\x01\x81\x90Ra\x17q\x81\x84\x01\x86a\x16\x16V[\x90P\x82\x81\x03a\x01\xA0\x84\x01Ra\x17\x86\x81\x85a\x15\xB2V[\x96\x95PPPPPPV[` \x81R`\0a\x14I` \x83\x01\x84a\x15\xB2V[`\0` \x82\x84\x03\x12\x15a\x17\xB5W`\0\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x12`\x04R`$`\0\xFD\xFE\xA2dipfsX\"\x12 \xD3!\x9A$?\xB3\xB7h<lj\t\x18\x14H\x85\xC8U\x1F\x0F\xD8{\x19\xA0\xE75^\xD3\xD1\x0E\x93pdsolcC\0\x08\x10\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `EthTransferFailed()` and selector `0x6d963f88`.
+    ```solidity
+    error EthTransferFailed();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct EthTransferFailed;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<EthTransferFailed> for UnderlyingRustTuple<'_> {
+            fn from(value: EthTransferFailed) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for EthTransferFailed {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for EthTransferFailed {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [109u8, 150u8, 63u8, 136u8];
+            const SIGNATURE: &'static str = "EthTransferFailed()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `IncorrectEthAmount()` and selector `0x8b6ebb4d`.
+    ```solidity
+    error IncorrectEthAmount();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct IncorrectEthAmount;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<IncorrectEthAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: IncorrectEthAmount) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for IncorrectEthAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for IncorrectEthAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [139u8, 110u8, 187u8, 77u8];
+            const SIGNATURE: &'static str = "IncorrectEthAmount()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotAllowedToInvalidateOrder(bytes32)` and selector `0xf8cc70ce`.
+    ```solidity
+    error NotAllowedToInvalidateOrder(bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NotAllowedToInvalidateOrder {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NotAllowedToInvalidateOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: NotAllowedToInvalidateOrder) -> Self {
+                (value.orderHash,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotAllowedToInvalidateOrder {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { orderHash: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NotAllowedToInvalidateOrder {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 204u8, 112u8, 206u8];
+            const SIGNATURE: &'static str = "NotAllowedToInvalidateOrder(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotAllowedZeroSellAmount()` and selector `0xeaec5c9d`.
+    ```solidity
+    error NotAllowedZeroSellAmount();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NotAllowedZeroSellAmount;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NotAllowedZeroSellAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: NotAllowedZeroSellAmount) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotAllowedZeroSellAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NotAllowedZeroSellAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [234u8, 236u8, 92u8, 157u8];
+            const SIGNATURE: &'static str = "NotAllowedZeroSellAmount()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderIsAlreadyExpired()` and selector `0x89bb2601`.
+    ```solidity
+    error OrderIsAlreadyExpired();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderIsAlreadyExpired;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderIsAlreadyExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderIsAlreadyExpired) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderIsAlreadyExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderIsAlreadyExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 187u8, 38u8, 1u8];
+            const SIGNATURE: &'static str = "OrderIsAlreadyExpired()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderIsAlreadyOwned(bytes32)` and selector `0x56a1d2b2`.
+    ```solidity
+    error OrderIsAlreadyOwned(bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderIsAlreadyOwned {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderIsAlreadyOwned> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderIsAlreadyOwned) -> Self {
+                (value.orderHash,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderIsAlreadyOwned {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { orderHash: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderIsAlreadyOwned {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [86u8, 161u8, 210u8, 178u8];
+            const SIGNATURE: &'static str = "OrderIsAlreadyOwned(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ReceiverMustBeSet()` and selector `0xefc9ccdf`.
+    ```solidity
+    error ReceiverMustBeSet();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ReceiverMustBeSet;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReceiverMustBeSet> for UnderlyingRustTuple<'_> {
+            fn from(value: ReceiverMustBeSet) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReceiverMustBeSet {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ReceiverMustBeSet {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [239u8, 201u8, 204u8, 223u8];
+            const SIGNATURE: &'static str = "ReceiverMustBeSet()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderInvalidation(bytes)` and selector `0xb8bad102ac8bbacfef31ff1c906ec6d951c230b4dce750bb0376b812ad35852a`.
+    ```solidity
+    event OrderInvalidation(bytes orderUid);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderInvalidation {
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderInvalidation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderInvalidation(bytes)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    184u8, 186u8, 209u8, 2u8, 172u8, 139u8, 186u8, 207u8, 239u8, 49u8, 255u8, 28u8,
+                    144u8, 110u8, 198u8, 217u8, 81u8, 194u8, 48u8, 180u8, 220u8, 231u8, 80u8,
+                    187u8, 3u8, 118u8, 184u8, 18u8, 173u8, 53u8, 133u8, 42u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { orderUid: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderInvalidation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderInvalidation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderInvalidation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive()]
+    /**Event with signature `OrderPlacement(address,(address,address,address,uint256,uint256,uint32,bytes32,uint256,bytes32,bool,bytes32,bytes32),(uint8,bytes),bytes)` and selector `0xcf5f9de2984132265203b5c335b25727702ca77262ff622e136baa7362bf1da9`.
+    ```solidity
+    event OrderPlacement(address indexed sender, GPv2Order.Data order, ICoWSwapOnchainOrders.OnchainSignature signature, bytes data);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderPlacement {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature:
+            <ICoWSwapOnchainOrders::OnchainSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderPlacement {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                GPv2Order::Data,
+                ICoWSwapOnchainOrders::OnchainSignature,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderPlacement(address,(address,address,address,\
+                                             uint256,uint256,uint32,bytes32,uint256,bytes32,bool,\
+                                             bytes32,bytes32),(uint8,bytes),bytes)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    207u8, 95u8, 157u8, 226u8, 152u8, 65u8, 50u8, 38u8, 82u8, 3u8, 181u8, 195u8,
+                    53u8, 178u8, 87u8, 39u8, 112u8, 44u8, 167u8, 114u8, 98u8, 255u8, 98u8, 46u8,
+                    19u8, 107u8, 170u8, 115u8, 98u8, 191u8, 29u8, 169u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    order: data.0,
+                    signature: data.1,
+                    data: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <GPv2Order::Data as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <ICoWSwapOnchainOrders::OnchainSignature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.sender.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderPlacement {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderPlacement> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderPlacement) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderRefund(bytes,address)` and selector `0x195271068a288191e4b265c641a56b9832919f69e9e7d6c2f31ba40278aeb85a`.
+    ```solidity
+    event OrderRefund(bytes orderUid, address indexed refunder);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderRefund {
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub refunder: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderRefund {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderRefund(bytes,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    25u8, 82u8, 113u8, 6u8, 138u8, 40u8, 129u8, 145u8, 228u8, 178u8, 101u8, 198u8,
+                    65u8, 165u8, 107u8, 152u8, 50u8, 145u8, 159u8, 105u8, 233u8, 231u8, 214u8,
+                    194u8, 243u8, 27u8, 164u8, 2u8, 120u8, 174u8, 184u8, 90u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderUid: data.0,
+                    refunder: topics.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.refunder.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.refunder,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderRefund {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderRefund> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderRefund) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address _cowSwapSettlement, address _wrappedNativeToken);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _cowSwapSettlement: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _wrappedNativeToken: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._cowSwapSettlement, value._wrappedNativeToken)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _cowSwapSettlement: tuple.0,
+                        _wrappedNativeToken: tuple.1,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._cowSwapSettlement,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._wrappedNativeToken,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cowSwapSettlement()` and selector `0xec30bb88`.
+    ```solidity
+    function cowSwapSettlement() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cowSwapSettlementCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`cowSwapSettlement()`](cowSwapSettlementCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cowSwapSettlementReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cowSwapSettlementCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cowSwapSettlementCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowSwapSettlementCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cowSwapSettlementReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cowSwapSettlementReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowSwapSettlementReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cowSwapSettlementCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [236u8, 48u8, 187u8, 136u8];
+            const SIGNATURE: &'static str = "cowSwapSettlement()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: cowSwapSettlementReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: cowSwapSettlementReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createOrder((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64))` and selector `0x322bba21`.
+    ```solidity
+    function createOrder(EthFlowOrder.Data memory order) external payable returns (bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createOrderCall {
+        #[allow(missing_docs)]
+        pub order: <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createOrder((address,address,uint256,uint256,bytes32,uint256,uint32,
+    /// bool,int64))`](createOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createOrderReturn {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (EthFlowOrder::Data,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createOrderCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createOrderReturn) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createOrderCall {
+            type Parameters<'a> = (EthFlowOrder::Data,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [50u8, 43u8, 186u8, 33u8];
+            const SIGNATURE: &'static str =
+                "createOrder((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<EthFlowOrder::Data as alloy_sol_types::SolType>::tokenize(
+                    &self.order,
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createOrderReturn = r.into();
+                        r.orderHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createOrderReturn = r.into();
+                    r.orderHash
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `invalidateOrder((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64))` and selector `0x7bc41b96`.
+    ```solidity
+    function invalidateOrder(EthFlowOrder.Data memory order) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateOrderCall {
+        #[allow(missing_docs)]
+        pub order: <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`invalidateOrder((address,address,uint256,uint256,bytes32,uint256,
+    /// uint32,bool,int64))`](invalidateOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateOrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (EthFlowOrder::Data,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrderCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl invalidateOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <invalidateOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for invalidateOrderCall {
+            type Parameters<'a> = (EthFlowOrder::Data,);
+            type Return = invalidateOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [123u8, 196u8, 27u8, 150u8];
+            const SIGNATURE: &'static str = "invalidateOrder((address,address,uint256,uint256,\
+                                             bytes32,uint256,uint32,bool,int64))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<EthFlowOrder::Data as alloy_sol_types::SolType>::tokenize(
+                    &self.order,
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                invalidateOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `invalidateOrdersIgnoringNotAllowed((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64)[])` and selector `0x4cb76498`.
+    ```solidity
+    function invalidateOrdersIgnoringNotAllowed(EthFlowOrder.Data[] memory orderArray) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateOrdersIgnoringNotAllowedCall {
+        #[allow(missing_docs)]
+        pub orderArray: alloy_sol_types::private::Vec<
+            <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`invalidateOrdersIgnoringNotAllowed((address,address,uint256,uint256,
+    /// bytes32,uint256,uint32,bool,
+    /// int64)[])`](invalidateOrdersIgnoringNotAllowedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateOrdersIgnoringNotAllowedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Array<EthFlowOrder::Data>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateOrdersIgnoringNotAllowedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrdersIgnoringNotAllowedCall) -> Self {
+                    (value.orderArray,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrdersIgnoringNotAllowedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderArray: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateOrdersIgnoringNotAllowedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrdersIgnoringNotAllowedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrdersIgnoringNotAllowedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl invalidateOrdersIgnoringNotAllowedReturn {
+            fn _tokenize(
+                &self,
+            ) -> <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for invalidateOrdersIgnoringNotAllowedCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<EthFlowOrder::Data>,);
+            type Return = invalidateOrdersIgnoringNotAllowedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [76u8, 183u8, 100u8, 152u8];
+            const SIGNATURE: &'static str = "invalidateOrdersIgnoringNotAllowed((address,address,\
+                                             uint256,uint256,bytes32,uint256,uint32,bool,int64)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        EthFlowOrder::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderArray),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                invalidateOrdersIgnoringNotAllowedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32 orderHash, bytes memory) external view returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value.orderHash, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderHash: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `orders(bytes32)` and selector `0x9c3f1e90`.
+    ```solidity
+    function orders(bytes32) external view returns (address owner, uint32 validTo);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ordersCall(pub alloy_sol_types::private::FixedBytes<32>);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`orders(bytes32)`](ordersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ordersReturn {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ordersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ordersCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ordersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, u32);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ordersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ordersReturn) -> Self {
+                    (value.owner, value.validTo)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ordersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        validTo: tuple.1,
+                    }
+                }
+            }
+        }
+        impl ordersReturn {
+            fn _tokenize(&self) -> <ordersCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.validTo,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ordersCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = ordersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [156u8, 63u8, 30u8, 144u8];
+            const SIGNATURE: &'static str = "orders(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.0),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                ordersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `unwrap(uint256)` and selector `0xde0e9a3e`.
+    ```solidity
+    function unwrap(uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct unwrapCall {
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`unwrap(uint256)`](unwrapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct unwrapReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<unwrapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: unwrapCall) -> Self {
+                    (value.amount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unwrapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amount: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<unwrapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: unwrapReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unwrapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl unwrapReturn {
+            fn _tokenize(&self) -> <unwrapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for unwrapCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = unwrapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 14u8, 154u8, 62u8];
+            const SIGNATURE: &'static str = "unwrap(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                unwrapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `wrap(uint256)` and selector `0xea598cb0`.
+    ```solidity
+    function wrap(uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrapCall {
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`wrap(uint256)`](wrapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrapReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: wrapCall) -> Self {
+                    (value.amount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amount: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: wrapReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl wrapReturn {
+            fn _tokenize(&self) -> <wrapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for wrapCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = wrapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [234u8, 89u8, 140u8, 176u8];
+            const SIGNATURE: &'static str = "wrap(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                wrapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `wrapAll()` and selector `0x4c84c1c8`.
+    ```solidity
+    function wrapAll() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrapAllCall;
+    ///Container type for the return parameters of the
+    /// [`wrapAll()`](wrapAllCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrapAllReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrapAllCall> for UnderlyingRustTuple<'_> {
+                fn from(value: wrapAllCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrapAllCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrapAllReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: wrapAllReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrapAllReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl wrapAllReturn {
+            fn _tokenize(&self) -> <wrapAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for wrapAllCall {
+            type Parameters<'a> = ();
+            type Return = wrapAllReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [76u8, 132u8, 193u8, 200u8];
+            const SIGNATURE: &'static str = "wrapAll()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                wrapAllReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `wrappedNativeToken()` and selector `0x17fcb39b`.
+    ```solidity
+    function wrappedNativeToken() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrappedNativeTokenCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`wrappedNativeToken()`](wrappedNativeTokenCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrappedNativeTokenReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrappedNativeTokenCall> for UnderlyingRustTuple<'_> {
+                fn from(value: wrappedNativeTokenCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrappedNativeTokenCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrappedNativeTokenReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: wrappedNativeTokenReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrappedNativeTokenReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for wrappedNativeTokenCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [23u8, 252u8, 179u8, 155u8];
+            const SIGNATURE: &'static str = "wrappedNativeToken()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: wrappedNativeTokenReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: wrappedNativeTokenReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`CoWSwapEthFlow`](self) function calls.
+    #[derive(Clone)]
+    pub enum CoWSwapEthFlowCalls {
+        #[allow(missing_docs)]
+        cowSwapSettlement(cowSwapSettlementCall),
+        #[allow(missing_docs)]
+        createOrder(createOrderCall),
+        #[allow(missing_docs)]
+        invalidateOrder(invalidateOrderCall),
+        #[allow(missing_docs)]
+        invalidateOrdersIgnoringNotAllowed(invalidateOrdersIgnoringNotAllowedCall),
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+        #[allow(missing_docs)]
+        orders(ordersCall),
+        #[allow(missing_docs)]
+        unwrap(unwrapCall),
+        #[allow(missing_docs)]
+        wrap(wrapCall),
+        #[allow(missing_docs)]
+        wrapAll(wrapAllCall),
+        #[allow(missing_docs)]
+        wrappedNativeToken(wrappedNativeTokenCall),
+    }
+    impl CoWSwapEthFlowCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [22u8, 38u8, 186u8, 126u8],
+            [23u8, 252u8, 179u8, 155u8],
+            [50u8, 43u8, 186u8, 33u8],
+            [76u8, 132u8, 193u8, 200u8],
+            [76u8, 183u8, 100u8, 152u8],
+            [123u8, 196u8, 27u8, 150u8],
+            [156u8, 63u8, 30u8, 144u8],
+            [222u8, 14u8, 154u8, 62u8],
+            [234u8, 89u8, 140u8, 176u8],
+            [236u8, 48u8, 187u8, 136u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <wrappedNativeTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <wrapAllCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <invalidateOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ordersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <unwrapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <wrapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cowSwapSettlementCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isValidSignature),
+            ::core::stringify!(wrappedNativeToken),
+            ::core::stringify!(createOrder),
+            ::core::stringify!(wrapAll),
+            ::core::stringify!(invalidateOrdersIgnoringNotAllowed),
+            ::core::stringify!(invalidateOrder),
+            ::core::stringify!(orders),
+            ::core::stringify!(unwrap),
+            ::core::stringify!(wrap),
+            ::core::stringify!(cowSwapSettlement),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CoWSwapEthFlowCalls {
+        const COUNT: usize = 10usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CoWSwapEthFlowCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::cowSwapSettlement(_) => {
+                    <cowSwapSettlementCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::createOrder(_) => <createOrderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::invalidateOrder(_) => {
+                    <invalidateOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::invalidateOrdersIgnoringNotAllowed(_) => {
+                    <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::orders(_) => <ordersCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::unwrap(_) => <unwrapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::wrap(_) => <wrapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::wrapAll(_) => <wrapAllCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::wrappedNativeToken(_) => {
+                    <wrappedNativeTokenCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls>] = &[
+                {
+                    fn isValidSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn wrappedNativeToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::wrappedNativeToken)
+                    }
+                    wrappedNativeToken
+                },
+                {
+                    fn createOrder(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <createOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::createOrder)
+                    }
+                    createOrder
+                },
+                {
+                    fn wrapAll(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <wrapAllCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::wrapAll)
+                    }
+                    wrapAll
+                },
+                {
+                    fn invalidateOrdersIgnoringNotAllowed(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowCalls::invalidateOrdersIgnoringNotAllowed)
+                    }
+                    invalidateOrdersIgnoringNotAllowed
+                },
+                {
+                    fn invalidateOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <invalidateOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::invalidateOrder)
+                    }
+                    invalidateOrder
+                },
+                {
+                    fn orders(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <ordersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::orders)
+                    }
+                    orders
+                },
+                {
+                    fn unwrap(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <unwrapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::unwrap)
+                    }
+                    unwrap
+                },
+                {
+                    fn wrap(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <wrapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::wrap)
+                    }
+                    wrap
+                },
+                {
+                    fn cowSwapSettlement(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowCalls::cowSwapSettlement)
+                    }
+                    cowSwapSettlement
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CoWSwapEthFlowCalls>] = &[
+                {
+                    fn isValidSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn wrappedNativeToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowCalls::wrappedNativeToken)
+                    }
+                    wrappedNativeToken
+                },
+                {
+                    fn createOrder(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <createOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CoWSwapEthFlowCalls::createOrder)
+                    }
+                    createOrder
+                },
+                {
+                    fn wrapAll(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <wrapAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CoWSwapEthFlowCalls::wrapAll)
+                    }
+                    wrapAll
+                },
+                {
+                    fn invalidateOrdersIgnoringNotAllowed(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowCalls::invalidateOrdersIgnoringNotAllowed)
+                    }
+                    invalidateOrdersIgnoringNotAllowed
+                },
+                {
+                    fn invalidateOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <invalidateOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowCalls::invalidateOrder)
+                    }
+                    invalidateOrder
+                },
+                {
+                    fn orders(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <ordersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CoWSwapEthFlowCalls::orders)
+                    }
+                    orders
+                },
+                {
+                    fn unwrap(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <unwrapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CoWSwapEthFlowCalls::unwrap)
+                    }
+                    unwrap
+                },
+                {
+                    fn wrap(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <wrapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(CoWSwapEthFlowCalls::wrap)
+                    }
+                    wrap
+                },
+                {
+                    fn cowSwapSettlement(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
+                        <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowCalls::cowSwapSettlement)
+                    }
+                    cowSwapSettlement
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::cowSwapSettlement(inner) => {
+                    <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::createOrder(inner) => {
+                    <createOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::invalidateOrder(inner) => {
+                    <invalidateOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::invalidateOrdersIgnoringNotAllowed(inner) => {
+                    <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::orders(inner) => {
+                    <ordersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::unwrap(inner) => {
+                    <unwrapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::wrap(inner) => {
+                    <wrapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::wrapAll(inner) => {
+                    <wrapAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::wrappedNativeToken(inner) => {
+                    <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::cowSwapSettlement(inner) => {
+                    <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::createOrder(inner) => {
+                    <createOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::invalidateOrder(inner) => {
+                    <invalidateOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::invalidateOrdersIgnoringNotAllowed(inner) => {
+                    <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::orders(inner) => {
+                    <ordersCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::unwrap(inner) => {
+                    <unwrapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::wrap(inner) => {
+                    <wrapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::wrapAll(inner) => {
+                    <wrapAllCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::wrappedNativeToken(inner) => {
+                    <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`CoWSwapEthFlow`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum CoWSwapEthFlowErrors {
+        #[allow(missing_docs)]
+        EthTransferFailed(EthTransferFailed),
+        #[allow(missing_docs)]
+        IncorrectEthAmount(IncorrectEthAmount),
+        #[allow(missing_docs)]
+        NotAllowedToInvalidateOrder(NotAllowedToInvalidateOrder),
+        #[allow(missing_docs)]
+        NotAllowedZeroSellAmount(NotAllowedZeroSellAmount),
+        #[allow(missing_docs)]
+        OrderIsAlreadyExpired(OrderIsAlreadyExpired),
+        #[allow(missing_docs)]
+        OrderIsAlreadyOwned(OrderIsAlreadyOwned),
+        #[allow(missing_docs)]
+        ReceiverMustBeSet(ReceiverMustBeSet),
+    }
+    impl CoWSwapEthFlowErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [86u8, 161u8, 210u8, 178u8],
+            [109u8, 150u8, 63u8, 136u8],
+            [137u8, 187u8, 38u8, 1u8],
+            [139u8, 110u8, 187u8, 77u8],
+            [234u8, 236u8, 92u8, 157u8],
+            [239u8, 201u8, 204u8, 223u8],
+            [248u8, 204u8, 112u8, 206u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <OrderIsAlreadyOwned as alloy_sol_types::SolError>::SIGNATURE,
+            <EthTransferFailed as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderIsAlreadyExpired as alloy_sol_types::SolError>::SIGNATURE,
+            <IncorrectEthAmount as alloy_sol_types::SolError>::SIGNATURE,
+            <NotAllowedZeroSellAmount as alloy_sol_types::SolError>::SIGNATURE,
+            <ReceiverMustBeSet as alloy_sol_types::SolError>::SIGNATURE,
+            <NotAllowedToInvalidateOrder as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(OrderIsAlreadyOwned),
+            ::core::stringify!(EthTransferFailed),
+            ::core::stringify!(OrderIsAlreadyExpired),
+            ::core::stringify!(IncorrectEthAmount),
+            ::core::stringify!(NotAllowedZeroSellAmount),
+            ::core::stringify!(ReceiverMustBeSet),
+            ::core::stringify!(NotAllowedToInvalidateOrder),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for CoWSwapEthFlowErrors {
+        const COUNT: usize = 7usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "CoWSwapEthFlowErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::EthTransferFailed(_) => {
+                    <EthTransferFailed as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::IncorrectEthAmount(_) => {
+                    <IncorrectEthAmount as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::NotAllowedToInvalidateOrder(_) => {
+                    <NotAllowedToInvalidateOrder as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::NotAllowedZeroSellAmount(_) => {
+                    <NotAllowedZeroSellAmount as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderIsAlreadyExpired(_) => {
+                    <OrderIsAlreadyExpired as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::OrderIsAlreadyOwned(_) => {
+                    <OrderIsAlreadyOwned as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ReceiverMustBeSet(_) => {
+                    <ReceiverMustBeSet as alloy_sol_types::SolError>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowErrors>] = &[
+                {
+                    fn OrderIsAlreadyOwned(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <OrderIsAlreadyOwned as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowErrors::OrderIsAlreadyOwned)
+                    }
+                    OrderIsAlreadyOwned
+                },
+                {
+                    fn EthTransferFailed(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <EthTransferFailed as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowErrors::EthTransferFailed)
+                    }
+                    EthTransferFailed
+                },
+                {
+                    fn OrderIsAlreadyExpired(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <OrderIsAlreadyExpired as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowErrors::OrderIsAlreadyExpired)
+                    }
+                    OrderIsAlreadyExpired
+                },
+                {
+                    fn IncorrectEthAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <IncorrectEthAmount as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowErrors::IncorrectEthAmount)
+                    }
+                    IncorrectEthAmount
+                },
+                {
+                    fn NotAllowedZeroSellAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <NotAllowedZeroSellAmount as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowErrors::NotAllowedZeroSellAmount)
+                    }
+                    NotAllowedZeroSellAmount
+                },
+                {
+                    fn ReceiverMustBeSet(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <ReceiverMustBeSet as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(CoWSwapEthFlowErrors::ReceiverMustBeSet)
+                    }
+                    ReceiverMustBeSet
+                },
+                {
+                    fn NotAllowedToInvalidateOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <NotAllowedToInvalidateOrder as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowErrors::NotAllowedToInvalidateOrder)
+                    }
+                    NotAllowedToInvalidateOrder
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<CoWSwapEthFlowErrors>] = &[
+                {
+                    fn OrderIsAlreadyOwned(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <OrderIsAlreadyOwned as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowErrors::OrderIsAlreadyOwned)
+                    }
+                    OrderIsAlreadyOwned
+                },
+                {
+                    fn EthTransferFailed(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <EthTransferFailed as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowErrors::EthTransferFailed)
+                    }
+                    EthTransferFailed
+                },
+                {
+                    fn OrderIsAlreadyExpired(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <OrderIsAlreadyExpired as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowErrors::OrderIsAlreadyExpired)
+                    }
+                    OrderIsAlreadyExpired
+                },
+                {
+                    fn IncorrectEthAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <IncorrectEthAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowErrors::IncorrectEthAmount)
+                    }
+                    IncorrectEthAmount
+                },
+                {
+                    fn NotAllowedZeroSellAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <NotAllowedZeroSellAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowErrors::NotAllowedZeroSellAmount)
+                    }
+                    NotAllowedZeroSellAmount
+                },
+                {
+                    fn ReceiverMustBeSet(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <ReceiverMustBeSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(CoWSwapEthFlowErrors::ReceiverMustBeSet)
+                    }
+                    ReceiverMustBeSet
+                },
+                {
+                    fn NotAllowedToInvalidateOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<CoWSwapEthFlowErrors> {
+                        <NotAllowedToInvalidateOrder as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(CoWSwapEthFlowErrors::NotAllowedToInvalidateOrder)
+                    }
+                    NotAllowedToInvalidateOrder
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::EthTransferFailed(inner) => {
+                    <EthTransferFailed as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::IncorrectEthAmount(inner) => {
+                    <IncorrectEthAmount as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::NotAllowedToInvalidateOrder(inner) => {
+                    <NotAllowedToInvalidateOrder as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::NotAllowedZeroSellAmount(inner) => {
+                    <NotAllowedZeroSellAmount as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::OrderIsAlreadyExpired(inner) => {
+                    <OrderIsAlreadyExpired as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::OrderIsAlreadyOwned(inner) => {
+                    <OrderIsAlreadyOwned as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::ReceiverMustBeSet(inner) => {
+                    <ReceiverMustBeSet as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::EthTransferFailed(inner) => {
+                    <EthTransferFailed as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::IncorrectEthAmount(inner) => {
+                    <IncorrectEthAmount as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::NotAllowedToInvalidateOrder(inner) => {
+                    <NotAllowedToInvalidateOrder as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::NotAllowedZeroSellAmount(inner) => {
+                    <NotAllowedZeroSellAmount as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::OrderIsAlreadyExpired(inner) => {
+                    <OrderIsAlreadyExpired as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::OrderIsAlreadyOwned(inner) => {
+                    <OrderIsAlreadyOwned as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::ReceiverMustBeSet(inner) => {
+                    <ReceiverMustBeSet as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`CoWSwapEthFlow`](self) events.
+    #[derive(Clone)]
+    pub enum CoWSwapEthFlowEvents {
+        #[allow(missing_docs)]
+        OrderInvalidation(OrderInvalidation),
+        #[allow(missing_docs)]
+        OrderPlacement(OrderPlacement),
+        #[allow(missing_docs)]
+        OrderRefund(OrderRefund),
+    }
+    impl CoWSwapEthFlowEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                25u8, 82u8, 113u8, 6u8, 138u8, 40u8, 129u8, 145u8, 228u8, 178u8, 101u8, 198u8,
+                65u8, 165u8, 107u8, 152u8, 50u8, 145u8, 159u8, 105u8, 233u8, 231u8, 214u8, 194u8,
+                243u8, 27u8, 164u8, 2u8, 120u8, 174u8, 184u8, 90u8,
+            ],
+            [
+                184u8, 186u8, 209u8, 2u8, 172u8, 139u8, 186u8, 207u8, 239u8, 49u8, 255u8, 28u8,
+                144u8, 110u8, 198u8, 217u8, 81u8, 194u8, 48u8, 180u8, 220u8, 231u8, 80u8, 187u8,
+                3u8, 118u8, 184u8, 18u8, 173u8, 53u8, 133u8, 42u8,
+            ],
+            [
+                207u8, 95u8, 157u8, 226u8, 152u8, 65u8, 50u8, 38u8, 82u8, 3u8, 181u8, 195u8, 53u8,
+                178u8, 87u8, 39u8, 112u8, 44u8, 167u8, 114u8, 98u8, 255u8, 98u8, 46u8, 19u8, 107u8,
+                170u8, 115u8, 98u8, 191u8, 29u8, 169u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <OrderRefund as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderInvalidation as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderPlacement as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(OrderRefund),
+            ::core::stringify!(OrderInvalidation),
+            ::core::stringify!(OrderPlacement),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CoWSwapEthFlowEvents {
+        const COUNT: usize = 3usize;
+        const NAME: &'static str = "CoWSwapEthFlowEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<OrderInvalidation as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderInvalidation as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderInvalidation)
+                }
+                Some(<OrderPlacement as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderPlacement as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderPlacement)
+                }
+                Some(<OrderRefund as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderRefund as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderRefund)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CoWSwapEthFlowEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::OrderInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OrderPlacement(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OrderRefund(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::OrderInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderPlacement(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderRefund(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CoWSwapEthFlow`](self) contract instance.
+
+    See the [wrapper's documentation](`CoWSwapEthFlowInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CoWSwapEthFlowInstance<P, N> {
+        CoWSwapEthFlowInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _cowSwapSettlement: alloy_sol_types::private::Address,
+        _wrappedNativeToken: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<CoWSwapEthFlowInstance<P, N>>>
+    {
+        CoWSwapEthFlowInstance::<P, N>::deploy(__provider, _cowSwapSettlement, _wrappedNativeToken)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _cowSwapSettlement: alloy_sol_types::private::Address,
+        _wrappedNativeToken: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        CoWSwapEthFlowInstance::<P, N>::deploy_builder(
+            __provider,
+            _cowSwapSettlement,
+            _wrappedNativeToken,
+        )
+    }
+    /**A [`CoWSwapEthFlow`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CoWSwapEthFlow`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CoWSwapEthFlowInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CoWSwapEthFlowInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CoWSwapEthFlowInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CoWSwapEthFlowInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CoWSwapEthFlow`](self) contract instance.
+
+        See the [wrapper's documentation](`CoWSwapEthFlowInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _cowSwapSettlement: alloy_sol_types::private::Address,
+            _wrappedNativeToken: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<CoWSwapEthFlowInstance<P, N>> {
+            let call_builder =
+                Self::deploy_builder(__provider, _cowSwapSettlement, _wrappedNativeToken);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _cowSwapSettlement: alloy_sol_types::private::Address,
+            _wrappedNativeToken: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        _cowSwapSettlement,
+                        _wrappedNativeToken,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CoWSwapEthFlowInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CoWSwapEthFlowInstance<P, N> {
+            CoWSwapEthFlowInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CoWSwapEthFlowInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`cowSwapSettlement`] function.
+        pub fn cowSwapSettlement(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, cowSwapSettlementCall, N> {
+            self.call_builder(&cowSwapSettlementCall)
+        }
+
+        ///Creates a new call builder for the [`createOrder`] function.
+        pub fn createOrder(
+            &self,
+            order: <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, createOrderCall, N> {
+            self.call_builder(&createOrderCall { order })
+        }
+
+        ///Creates a new call builder for the [`invalidateOrder`] function.
+        pub fn invalidateOrder(
+            &self,
+            order: <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, invalidateOrderCall, N> {
+            self.call_builder(&invalidateOrderCall { order })
+        }
+
+        ///Creates a new call builder for the
+        /// [`invalidateOrdersIgnoringNotAllowed`] function.
+        pub fn invalidateOrdersIgnoringNotAllowed(
+            &self,
+            orderArray: alloy_sol_types::private::Vec<
+                <EthFlowOrder::Data as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, invalidateOrdersIgnoringNotAllowedCall, N> {
+            self.call_builder(&invalidateOrdersIgnoringNotAllowedCall { orderArray })
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            orderHash: alloy_sol_types::private::FixedBytes<32>,
+            _1: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { orderHash, _1 })
+        }
+
+        ///Creates a new call builder for the [`orders`] function.
+        pub fn orders(
+            &self,
+            _0: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, ordersCall, N> {
+            self.call_builder(&ordersCall(_0))
+        }
+
+        ///Creates a new call builder for the [`unwrap`] function.
+        pub fn unwrap(
+            &self,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, unwrapCall, N> {
+            self.call_builder(&unwrapCall { amount })
+        }
+
+        ///Creates a new call builder for the [`wrap`] function.
+        pub fn wrap(
+            &self,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, wrapCall, N> {
+            self.call_builder(&wrapCall { amount })
+        }
+
+        ///Creates a new call builder for the [`wrapAll`] function.
+        pub fn wrapAll(&self) -> alloy_contract::SolCallBuilder<&P, wrapAllCall, N> {
+            self.call_builder(&wrapAllCall)
+        }
+
+        ///Creates a new call builder for the [`wrappedNativeToken`] function.
+        pub fn wrappedNativeToken(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, wrappedNativeTokenCall, N> {
+            self.call_builder(&wrappedNativeTokenCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CoWSwapEthFlowInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`OrderInvalidation`] event.
+        pub fn OrderInvalidation_filter(&self) -> alloy_contract::Event<&P, OrderInvalidation, N> {
+            self.event_filter::<OrderInvalidation>()
+        }
+
+        ///Creates a new event filter for the [`OrderPlacement`] event.
+        pub fn OrderPlacement_filter(&self) -> alloy_contract::Event<&P, OrderPlacement, N> {
+            self.event_filter::<OrderPlacement>()
+        }
+
+        ///Creates a new event filter for the [`OrderRefund`] event.
+        pub fn OrderRefund_filter(&self) -> alloy_contract::Event<&P, OrderRefund, N> {
+            self.event_filter::<OrderRefund>()
+        }
+    }
+}
+pub type Instance = CoWSwapEthFlow::CoWSwapEthFlowInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x40a50cf069e992aa4536211b23f286ef88752187"),
+            Some(16169866u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
+            Some(134607215u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
+            Some(48411237u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x40a50cf069e992aa4536211b23f286ef88752187"),
+            Some(25414331u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
+            Some(71296258u64),
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0xFb337f8a725A142f65fb9ff4902d41cc901de222"),
+            Some(3007173u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x3C3eA1829891BC9bEC3d06A81d5d169e52a415e3"),
+            Some(21490258u64),
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
+            Some(3521855u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x6DFE75B5ddce1ADE279D4fa6BD6AeF3cBb6f49dB"),
+            Some(204747458u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
+            Some(60496408u64),
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
+            Some(24522097u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x0b7795E18767259CC253a2dF471db34c72B49516"),
+            Some(4718739u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/cowswaponchainorders/Cargo.toml b/contracts/generated/contracts-generated/cowswaponchainorders/Cargo.toml
new file mode 100644
index 0000000000..c1b80ba336
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowswaponchainorders/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-cowswaponchainorders"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/cowswaponchainorders/src/lib.rs b/contracts/generated/contracts-generated/cowswaponchainorders/src/lib.rs
new file mode 100644
index 0000000000..071ff13688
--- /dev/null
+++ b/contracts/generated/contracts-generated/cowswaponchainorders/src/lib.rs
@@ -0,0 +1,1815 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Order {
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Order {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub kind: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub partiallyFillable: bool,
+        #[allow(missing_docs)]
+        pub sellTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub buyTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::FixedBytes<32>,
+            bool,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.sellToken,
+                    value.buyToken,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.validTo,
+                    value.appData,
+                    value.feeAmount,
+                    value.kind,
+                    value.partiallyFillable,
+                    value.sellTokenBalance,
+                    value.buyTokenBalance,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sellToken: tuple.0,
+                    buyToken: tuple.1,
+                    receiver: tuple.2,
+                    sellAmount: tuple.3,
+                    buyAmount: tuple.4,
+                    validTo: tuple.5,
+                    appData: tuple.6,
+                    feeAmount: tuple.7,
+                    kind: tuple.8,
+                    partiallyFillable: tuple.9,
+                    sellTokenBalance: tuple.10,
+                    buyTokenBalance: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.partiallyFillable,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenBalance),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenBalance),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address sellToken,address buyToken,address receiver,uint256 \
+                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
+                     feeAmount,bytes32 kind,bool partiallyFillable,bytes32 \
+                     sellTokenBalance,bytes32 buyTokenBalance)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.partiallyFillable,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellTokenBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.buyTokenBalance,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.kind)
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.partiallyFillable,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellTokenBalance,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyTokenBalance,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.partiallyFillable,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellTokenBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyTokenBalance,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2OrderInstance<P, N> {
+        GPv2OrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Order`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Order`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2OrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2OrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2OrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2OrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2OrderInstance<P, N> {
+            GPv2OrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2OrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ICoWSwapOnchainOrders {
+    type OnchainSigningScheme is uint8;
+    struct OnchainSignature { OnchainSigningScheme scheme; bytes data; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ICoWSwapOnchainOrders {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnchainSigningScheme(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<OnchainSigningScheme> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl OnchainSigningScheme {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for OnchainSigningScheme {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<OnchainSigningScheme> for u8 {
+            fn from(value: OnchainSigningScheme) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OnchainSigningScheme {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OnchainSigningScheme {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OnchainSignature { OnchainSigningScheme scheme; bytes data; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OnchainSignature {
+        #[allow(missing_docs)]
+        pub scheme: <OnchainSigningScheme as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (OnchainSigningScheme, alloy_sol_types::sol_data::Bytes);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <OnchainSigningScheme as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OnchainSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: OnchainSignature) -> Self {
+                (value.scheme, value.data)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnchainSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    scheme: tuple.0,
+                    data: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for OnchainSignature {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for OnchainSignature {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <OnchainSigningScheme as alloy_sol_types::SolType>::tokenize(&self.scheme),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OnchainSignature {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for OnchainSignature {
+            const NAME: &'static str = "OnchainSignature";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed("OnchainSignature(uint8 scheme,bytes data)")
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <OnchainSigningScheme as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.scheme,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.data,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OnchainSignature {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <OnchainSigningScheme as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.scheme,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.data,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <OnchainSigningScheme as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.scheme,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.data,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ICoWSwapOnchainOrders`](self) contract instance.
+
+    See the [wrapper's documentation](`ICoWSwapOnchainOrdersInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ICoWSwapOnchainOrdersInstance<P, N> {
+        ICoWSwapOnchainOrdersInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ICoWSwapOnchainOrders`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ICoWSwapOnchainOrders`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ICoWSwapOnchainOrdersInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ICoWSwapOnchainOrdersInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ICoWSwapOnchainOrdersInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICoWSwapOnchainOrdersInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ICoWSwapOnchainOrders`](self) contract instance.
+
+        See the [wrapper's documentation](`ICoWSwapOnchainOrdersInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ICoWSwapOnchainOrdersInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ICoWSwapOnchainOrdersInstance<P, N> {
+            ICoWSwapOnchainOrdersInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICoWSwapOnchainOrdersInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICoWSwapOnchainOrdersInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library GPv2Order {
+    struct Data {
+        address sellToken;
+        address buyToken;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        uint32 validTo;
+        bytes32 appData;
+        uint256 feeAmount;
+        bytes32 kind;
+        bool partiallyFillable;
+        bytes32 sellTokenBalance;
+        bytes32 buyTokenBalance;
+    }
+}
+
+library ICoWSwapOnchainOrders {
+    type OnchainSigningScheme is uint8;
+    struct OnchainSignature {
+        OnchainSigningScheme scheme;
+        bytes data;
+    }
+}
+
+interface CoWSwapOnchainOrders {
+    event OrderInvalidation(bytes orderUid);
+    event OrderPlacement(address indexed sender, GPv2Order.Data order, ICoWSwapOnchainOrders.OnchainSignature signature, bytes data);
+
+    constructor(address settlementContractAddress);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "settlementContractAddress",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "OrderInvalidation",
+    "inputs": [
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderPlacement",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "order",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct GPv2Order.Data",
+        "components": [
+          {
+            "name": "sellToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "buyToken",
+            "type": "address",
+            "internalType": "contract IERC20"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "kind",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "partiallyFillable",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "sellTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "buyTokenBalance",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct ICoWSwapOnchainOrders.OnchainSignature",
+        "components": [
+          {
+            "name": "scheme",
+            "type": "uint8",
+            "internalType": "enum ICoWSwapOnchainOrders.OnchainSigningScheme"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CoWSwapOnchainOrders {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderInvalidation(bytes)` and selector `0xb8bad102ac8bbacfef31ff1c906ec6d951c230b4dce750bb0376b812ad35852a`.
+    ```solidity
+    event OrderInvalidation(bytes orderUid);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderInvalidation {
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderInvalidation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderInvalidation(bytes)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    184u8, 186u8, 209u8, 2u8, 172u8, 139u8, 186u8, 207u8, 239u8, 49u8, 255u8, 28u8,
+                    144u8, 110u8, 198u8, 217u8, 81u8, 194u8, 48u8, 180u8, 220u8, 231u8, 80u8,
+                    187u8, 3u8, 118u8, 184u8, 18u8, 173u8, 53u8, 133u8, 42u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { orderUid: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderInvalidation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderInvalidation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderInvalidation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive()]
+    /**Event with signature `OrderPlacement(address,(address,address,address,uint256,uint256,uint32,bytes32,uint256,bytes32,bool,bytes32,bytes32),(uint8,bytes),bytes)` and selector `0xcf5f9de2984132265203b5c335b25727702ca77262ff622e136baa7362bf1da9`.
+    ```solidity
+    event OrderPlacement(address indexed sender, GPv2Order.Data order, ICoWSwapOnchainOrders.OnchainSignature signature, bytes data);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderPlacement {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature:
+            <ICoWSwapOnchainOrders::OnchainSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderPlacement {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                GPv2Order::Data,
+                ICoWSwapOnchainOrders::OnchainSignature,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderPlacement(address,(address,address,address,\
+                                             uint256,uint256,uint32,bytes32,uint256,bytes32,bool,\
+                                             bytes32,bytes32),(uint8,bytes),bytes)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    207u8, 95u8, 157u8, 226u8, 152u8, 65u8, 50u8, 38u8, 82u8, 3u8, 181u8, 195u8,
+                    53u8, 178u8, 87u8, 39u8, 112u8, 44u8, 167u8, 114u8, 98u8, 255u8, 98u8, 46u8,
+                    19u8, 107u8, 170u8, 115u8, 98u8, 191u8, 29u8, 169u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    order: data.0,
+                    signature: data.1,
+                    data: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <GPv2Order::Data as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <ICoWSwapOnchainOrders::OnchainSignature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.sender.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderPlacement {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderPlacement> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderPlacement) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address settlementContractAddress);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub settlementContractAddress: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.settlementContractAddress,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        settlementContractAddress: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlementContractAddress,
+                    ),
+                )
+            }
+        }
+    };
+    ///Container for all the [`CoWSwapOnchainOrders`](self) events.
+    #[derive(Clone)]
+    pub enum CoWSwapOnchainOrdersEvents {
+        #[allow(missing_docs)]
+        OrderInvalidation(OrderInvalidation),
+        #[allow(missing_docs)]
+        OrderPlacement(OrderPlacement),
+    }
+    impl CoWSwapOnchainOrdersEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                184u8, 186u8, 209u8, 2u8, 172u8, 139u8, 186u8, 207u8, 239u8, 49u8, 255u8, 28u8,
+                144u8, 110u8, 198u8, 217u8, 81u8, 194u8, 48u8, 180u8, 220u8, 231u8, 80u8, 187u8,
+                3u8, 118u8, 184u8, 18u8, 173u8, 53u8, 133u8, 42u8,
+            ],
+            [
+                207u8, 95u8, 157u8, 226u8, 152u8, 65u8, 50u8, 38u8, 82u8, 3u8, 181u8, 195u8, 53u8,
+                178u8, 87u8, 39u8, 112u8, 44u8, 167u8, 114u8, 98u8, 255u8, 98u8, 46u8, 19u8, 107u8,
+                170u8, 115u8, 98u8, 191u8, 29u8, 169u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <OrderInvalidation as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderPlacement as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(OrderInvalidation),
+            ::core::stringify!(OrderPlacement),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for CoWSwapOnchainOrdersEvents {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "CoWSwapOnchainOrdersEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<OrderInvalidation as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderInvalidation as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderInvalidation)
+                }
+                Some(<OrderPlacement as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderPlacement as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderPlacement)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for CoWSwapOnchainOrdersEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::OrderInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OrderPlacement(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::OrderInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderPlacement(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`CoWSwapOnchainOrders`](self) contract instance.
+
+    See the [wrapper's documentation](`CoWSwapOnchainOrdersInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> CoWSwapOnchainOrdersInstance<P, N> {
+        CoWSwapOnchainOrdersInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`CoWSwapOnchainOrders`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`CoWSwapOnchainOrders`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct CoWSwapOnchainOrdersInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for CoWSwapOnchainOrdersInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("CoWSwapOnchainOrdersInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CoWSwapOnchainOrdersInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`CoWSwapOnchainOrders`](self) contract instance.
+
+        See the [wrapper's documentation](`CoWSwapOnchainOrdersInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> CoWSwapOnchainOrdersInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> CoWSwapOnchainOrdersInstance<P, N> {
+            CoWSwapOnchainOrdersInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CoWSwapOnchainOrdersInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        CoWSwapOnchainOrdersInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`OrderInvalidation`] event.
+        pub fn OrderInvalidation_filter(&self) -> alloy_contract::Event<&P, OrderInvalidation, N> {
+            self.event_filter::<OrderInvalidation>()
+        }
+
+        ///Creates a new event filter for the [`OrderPlacement`] event.
+        pub fn OrderPlacement_filter(&self) -> alloy_contract::Event<&P, OrderPlacement, N> {
+            self.event_filter::<OrderPlacement>()
+        }
+    }
+}
+pub type Instance =
+    CoWSwapOnchainOrders::CoWSwapOnchainOrdersInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/erc1271signaturevalidator/Cargo.toml b/contracts/generated/contracts-generated/erc1271signaturevalidator/Cargo.toml
new file mode 100644
index 0000000000..06f922ce6f
--- /dev/null
+++ b/contracts/generated/contracts-generated/erc1271signaturevalidator/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-erc1271signaturevalidator"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/erc1271signaturevalidator/src/lib.rs b/contracts/generated/contracts-generated/erc1271signaturevalidator/src/lib.rs
new file mode 100644
index 0000000000..d57519f715
--- /dev/null
+++ b/contracts/generated/contracts-generated/erc1271signaturevalidator/src/lib.rs
@@ -0,0 +1,497 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface ERC1271SignatureValidator {
+    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "hash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "magicValue",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ERC1271SignatureValidator {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub magicValue: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value.hash, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        hash: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value.magicValue,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        magicValue: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.hash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r.magicValue
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r.magicValue
+                })
+            }
+        }
+    };
+    ///Container for all the [`ERC1271SignatureValidator`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum ERC1271SignatureValidatorCalls {
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+    }
+    impl ERC1271SignatureValidatorCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[22u8, 38u8, 186u8, 126u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(isValidSignature)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for ERC1271SignatureValidatorCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 96usize;
+        const NAME: &'static str = "ERC1271SignatureValidatorCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                ERC1271SignatureValidatorCalls,
+            >] = &[{
+                fn isValidSignature(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<ERC1271SignatureValidatorCalls> {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(ERC1271SignatureValidatorCalls::isValidSignature)
+                }
+                isValidSignature
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                ERC1271SignatureValidatorCalls,
+            >] = &[{
+                fn isValidSignature(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<ERC1271SignatureValidatorCalls> {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        data,
+                    )
+                    .map(ERC1271SignatureValidatorCalls::isValidSignature)
+                }
+                isValidSignature
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ERC1271SignatureValidator`](self) contract instance.
+
+    See the [wrapper's documentation](`ERC1271SignatureValidatorInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ERC1271SignatureValidatorInstance<P, N> {
+        ERC1271SignatureValidatorInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ERC1271SignatureValidator`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ERC1271SignatureValidator`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ERC1271SignatureValidatorInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ERC1271SignatureValidatorInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ERC1271SignatureValidatorInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC1271SignatureValidatorInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ERC1271SignatureValidator`](self) contract instance.
+
+        See the [wrapper's documentation](`ERC1271SignatureValidatorInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ERC1271SignatureValidatorInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ERC1271SignatureValidatorInstance<P, N> {
+            ERC1271SignatureValidatorInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC1271SignatureValidatorInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            hash: alloy_sol_types::private::FixedBytes<32>,
+            signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { hash, signature })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC1271SignatureValidatorInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    ERC1271SignatureValidator::ERC1271SignatureValidatorInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/erc20/Cargo.toml b/contracts/generated/contracts-generated/erc20/Cargo.toml
new file mode 100644
index 0000000000..43ed4adef2
--- /dev/null
+++ b/contracts/generated/contracts-generated/erc20/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-erc20"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/erc20/src/lib.rs b/contracts/generated/contracts-generated/erc20/src/lib.rs
new file mode 100644
index 0000000000..0170198953
--- /dev/null
+++ b/contracts/generated/contracts-generated/erc20/src/lib.rs
@@ -0,0 +1,3063 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface ERC20 {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(string name_, string symbol_);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "name_",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "symbol_",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decreaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "subtractedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "increaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "addedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ERC20 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(string name_, string symbol_);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub name_: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol_: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.name_, value.symbol_)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        name_: tuple.0,
+                        symbol_: tuple.1,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name_,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol_,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    ```solidity
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceCall) -> Self {
+                    (value.spender, value.subtractedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        subtractedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
+            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.subtractedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    ```solidity
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceCall) -> Self {
+                    (value.spender, value.addedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        addedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
+            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.addedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`ERC20`](self) function calls.
+    #[derive(Clone)]
+    pub enum ERC20Calls {
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        decreaseAllowance(decreaseAllowanceCall),
+        #[allow(missing_docs)]
+        increaseAllowance(increaseAllowanceCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl ERC20Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [57u8, 80u8, 147u8, 81u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [164u8, 87u8, 194u8, 215u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(increaseAllowance),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(symbol),
+            ::core::stringify!(decreaseAllowance),
+            ::core::stringify!(transfer),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for ERC20Calls {
+        const COUNT: usize = 11usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "ERC20Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseAllowance(_) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::increaseAllowance(_) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ERC20Calls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn increaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn decreaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20Calls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ERC20Calls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ERC20Calls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn increaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ERC20Calls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn decreaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ERC20Calls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20Calls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`ERC20`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum ERC20Events {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl ERC20Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] =
+            &[::core::stringify!(Approval), ::core::stringify!(Transfer)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for ERC20Events {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "ERC20Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for ERC20Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ERC20`](self) contract instance.
+
+    See the [wrapper's documentation](`ERC20Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ERC20Instance<P, N> {
+        ERC20Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`ERC20`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ERC20`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ERC20Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ERC20Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ERC20Instance").field(&self.address).finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC20Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ERC20`](self) contract instance.
+
+        See the [wrapper's documentation](`ERC20Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ERC20Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ERC20Instance<P, N> {
+            ERC20Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC20Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`decreaseAllowance`] function.
+        pub fn decreaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
+            self.call_builder(&decreaseAllowanceCall {
+                spender,
+                subtractedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`increaseAllowance`] function.
+        pub fn increaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
+            self.call_builder(&increaseAllowanceCall {
+                spender,
+                addedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC20Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = ERC20::ERC20Instance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/erc20mintable/Cargo.toml b/contracts/generated/contracts-generated/erc20mintable/Cargo.toml
new file mode 100644
index 0000000000..54d1accfd5
--- /dev/null
+++ b/contracts/generated/contracts-generated/erc20mintable/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-erc20mintable"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/erc20mintable/src/lib.rs b/contracts/generated/contracts-generated/erc20mintable/src/lib.rs
new file mode 100644
index 0000000000..d8c69b0f31
--- /dev/null
+++ b/contracts/generated/contracts-generated/erc20mintable/src/lib.rs
@@ -0,0 +1,3565 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface ERC20Mintable {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event MinterAdded(address indexed account);
+    event MinterRemoved(address indexed account);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function addMinter(address account) external;
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function isMinter(address account) external view returns (bool);
+    function mint(address account, uint256 amount) external returns (bool);
+    function renounceMinter() external;
+    function totalSupply() external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "addMinter",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decreaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "subtractedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "increaseAllowance",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "addedValue",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isMinter",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "renounceMinter",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "MinterAdded",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "MinterRemoved",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ERC20Mintable {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@Rb\0\0$b\0\0\x18b\0\0*` \x1B` \x1CV[b\0\x002` \x1B` \x1CV[b\0\x02WV[`\x003\x90P\x90V[b\0\0M\x81`\x03b\0\0\x93` \x1Bb\0\x12\xA8\x17\x90\x91\x90` \x1CV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fj\xE1r\x83~\xA3\x0B\x80\x1F\xBF\xCD\xD4\x10\x8A\xA1\xD5\xBF\x8F\xF7uDO\xD7\x02V\xB4Nk\xF3\xDF\xC3\xF6`@Q`@Q\x80\x91\x03\x90\xA2PV[b\0\0\xA5\x82\x82b\0\x01w` \x1B` \x1CV[\x15b\0\x01\x19W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x1F\x81R` \x01\x80\x7FRoles: account already has role\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x82`\0\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPPPV[`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15b\0\x02\0W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\"\x81R` \x01\x80b\0\x18P`\"\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82`\0\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90P\x92\x91PPV[a\x15\xE9\x80b\0\x02g`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xB4W`\x005`\xE0\x1C\x80c\x98;-V\x11a\0qW\x80c\x98;-V\x14a\x02\xE7W\x80c\x98e\x02u\x14a\x03+W\x80c\xA4W\xC2\xD7\x14a\x035W\x80c\xA9\x05\x9C\xBB\x14a\x03\x9BW\x80c\xAA'\x1E\x1A\x14a\x04\x01W\x80c\xDDb\xED>\x14a\x04]Wa\0\xB4V[\x80c\t^\xA7\xB3\x14a\0\xB9W\x80c\x18\x16\r\xDD\x14a\x01\x1FW\x80c#\xB8r\xDD\x14a\x01=W\x80c9P\x93Q\x14a\x01\xC3W\x80c@\xC1\x0F\x19\x14a\x02)W\x80cp\xA0\x821\x14a\x02\x8FW[`\0\x80\xFD[a\x01\x05`\x04\x806\x03`@\x81\x10\x15a\0\xCFW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x04\xD5V[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x01'a\x04\xF3V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x01\xA9`\x04\x806\x03``\x81\x10\x15a\x01SW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x04\xFDV[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x02\x0F`\x04\x806\x03`@\x81\x10\x15a\x01\xD9W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x05\xD6V[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x02u`\x04\x806\x03`@\x81\x10\x15a\x02?W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x06\x89V[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x02\xD1`\x04\x806\x03` \x81\x10\x15a\x02\xA5W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x07\x04V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x03)`\x04\x806\x03` \x81\x10\x15a\x02\xFDW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x07LV[\0[a\x033a\x07\xBDV[\0[a\x03\x81`\x04\x806\x03`@\x81\x10\x15a\x03KW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x07\xCFV[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x03\xE7`\x04\x806\x03`@\x81\x10\x15a\x03\xB1W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x08\x9CV[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x04C`\x04\x806\x03` \x81\x10\x15a\x04\x17W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x08\xBAV[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x04\xBF`\x04\x806\x03`@\x81\x10\x15a\x04sW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x08\xD7V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[`\0a\x04\xE9a\x04\xE2a\t^V[\x84\x84a\tfV[`\x01\x90P\x92\x91PPV[`\0`\x02T\x90P\x90V[`\0a\x05\n\x84\x84\x84a\x0B]V[a\x05\xCB\x84a\x05\x16a\t^V[a\x05\xC6\x85`@Q\x80``\x01`@R\x80`(\x81R` \x01a\x14\xFD`(\x919`\x01`\0\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x05|a\t^V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 Ta\x0E\x13\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\tfV[`\x01\x90P\x93\x92PPPV[`\0a\x06\x7Fa\x05\xE3a\t^V[\x84a\x06z\x85`\x01`\0a\x05\xF4a\t^V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 Ta\x0E\xD3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\tfV[`\x01\x90P\x92\x91PPV[`\0a\x06\x9Ba\x06\x96a\t^V[a\x08\xBAV[a\x06\xF0W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`0\x81R` \x01\x80a\x14\xAC`0\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x06\xFA\x83\x83a\x0F[V[`\x01\x90P\x92\x91PPV[`\0\x80`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P\x91\x90PV[a\x07\\a\x07Wa\t^V[a\x08\xBAV[a\x07\xB1W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`0\x81R` \x01\x80a\x14\xAC`0\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x07\xBA\x81a\x11\x16V[PV[a\x07\xCDa\x07\xC8a\t^V[a\x11pV[V[`\0a\x08\x92a\x07\xDCa\t^V[\x84a\x08\x8D\x85`@Q\x80``\x01`@R\x80`%\x81R` \x01a\x15\x90`%\x919`\x01`\0a\x08\x06a\t^V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x8As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 Ta\x0E\x13\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\tfV[`\x01\x90P\x92\x91PPV[`\0a\x08\xB0a\x08\xA9a\t^V[\x84\x84a\x0B]V[`\x01\x90P\x92\x91PPV[`\0a\x08\xD0\x82`\x03a\x11\xCA\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x91\x90PV[`\0`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P\x92\x91PPV[`\x003\x90P\x90V[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\t\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`$\x81R` \x01\x80a\x15l`$\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\nrW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\"\x81R` \x01\x80a\x14d`\"\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x01`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x83`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA3PPPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x0B\xE3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80a\x15G`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x0CiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`#\x81R` \x01\x80a\x14A`#\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x0C\xD4\x81`@Q\x80``\x01`@R\x80`&\x81R` \x01a\x14\x86`&\x919`\0\x80\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 Ta\x0E\x13\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\rg\x81`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 Ta\x0E\xD3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x83`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA3PPPV[`\0\x83\x83\x11\x15\x82\x90a\x0E\xC0W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x0E\x85W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0EjV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x0E\xB2W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xFD[P`\0\x83\x85\x03\x90P\x80\x91PP\x93\x92PPPV[`\0\x80\x82\x84\x01\x90P\x83\x81\x10\x15a\x0FQW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x1B\x81R` \x01\x80\x7FSafeMath: addition overflow\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80\x91PP\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x0F\xFEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x1F\x81R` \x01\x80\x7FERC20: mint to the zero address\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x10\x13\x81`\x02Ta\x0E\xD3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\x02\x81\x90UPa\x10j\x81`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 Ta\x0E\xD3\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x83`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA3PPV[a\x11*\x81`\x03a\x12\xA8\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fj\xE1r\x83~\xA3\x0B\x80\x1F\xBF\xCD\xD4\x10\x8A\xA1\xD5\xBF\x8F\xF7uDO\xD7\x02V\xB4Nk\xF3\xDF\xC3\xF6`@Q`@Q\x80\x91\x03\x90\xA2PV[a\x11\x84\x81`\x03a\x13\x83\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xE9Dy\xA9\xF7\xE1\x95,\xC7\x8F-k\xAA\xB6x\xAD\xC1\xB7r\xD96\xC6X=\xEFH\x9ERL\xB6f\x92`@Q`@Q\x80\x91\x03\x90\xA2PV[`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x12QW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\"\x81R` \x01\x80a\x15%`\"\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82`\0\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90P\x92\x91PPV[a\x12\xB2\x82\x82a\x11\xCAV[\x15a\x13%W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x1F\x81R` \x01\x80\x7FRoles: account already has role\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x82`\0\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPPPV[a\x13\x8D\x82\x82a\x11\xCAV[a\x13\xE2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`!\x81R` \x01\x80a\x14\xDC`!\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x82`\0\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPPPV\xFEERC20: transfer to the zero addressERC20: approve to the zero addressERC20: transfer amount exceeds balanceMinterRole: caller does not have the Minter roleRoles: account does not have roleERC20: transfer amount exceeds allowanceRoles: account is the zero addressERC20: transfer from the zero addressERC20: approve from the zero addressERC20: decreased allowance below zero\xA2ebzzr1X V\xE4\xB78\xCFv\xF0\x83\x8Eq}\x12yN\xCB\xBDbx9\x9C\x81\xF9\x19*\xB9\xD5\xF0\x1D\\L;\xAFdsolcC\0\x05\x10\x002Roles: account is the zero address",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `MinterAdded(address)` and selector `0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6`.
+    ```solidity
+    event MinterAdded(address indexed account);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct MinterAdded {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for MinterAdded {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "MinterAdded(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    106u8, 225u8, 114u8, 131u8, 126u8, 163u8, 11u8, 128u8, 31u8, 191u8, 205u8,
+                    212u8, 16u8, 138u8, 161u8, 213u8, 191u8, 143u8, 247u8, 117u8, 68u8, 79u8,
+                    215u8, 2u8, 86u8, 180u8, 78u8, 107u8, 243u8, 223u8, 195u8, 246u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { account: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.account.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.account,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for MinterAdded {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&MinterAdded> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &MinterAdded) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `MinterRemoved(address)` and selector `0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692`.
+    ```solidity
+    event MinterRemoved(address indexed account);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct MinterRemoved {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for MinterRemoved {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "MinterRemoved(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    233u8, 68u8, 121u8, 169u8, 247u8, 225u8, 149u8, 44u8, 199u8, 143u8, 45u8,
+                    107u8, 170u8, 182u8, 120u8, 173u8, 193u8, 183u8, 114u8, 217u8, 54u8, 198u8,
+                    88u8, 61u8, 239u8, 72u8, 158u8, 82u8, 76u8, 182u8, 102u8, 146u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { account: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.account.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.account,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for MinterRemoved {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&MinterRemoved> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &MinterRemoved) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addMinter(address)` and selector `0x983b2d56`.
+    ```solidity
+    function addMinter(address account) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addMinterCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`addMinter(address)`](addMinterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addMinterReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addMinterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addMinterCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addMinterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addMinterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addMinterReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addMinterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl addMinterReturn {
+            fn _tokenize(&self) -> <addMinterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addMinterCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = addMinterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [152u8, 59u8, 45u8, 86u8];
+            const SIGNATURE: &'static str = "addMinter(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addMinterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    ```solidity
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decreaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceCall) -> Self {
+                    (value.spender, value.subtractedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        subtractedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decreaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
+            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.subtractedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decreaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decreaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    ```solidity
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseAllowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceCall) -> Self {
+                    (value.spender, value.addedValue)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        addedValue: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseAllowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
+            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.addedValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: increaseAllowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: increaseAllowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isMinter(address)` and selector `0xaa271e1a`.
+    ```solidity
+    function isMinter(address account) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isMinterCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isMinter(address)`](isMinterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isMinterReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isMinterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isMinterCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isMinterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isMinterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isMinterReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isMinterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isMinterCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 39u8, 30u8, 26u8];
+            const SIGNATURE: &'static str = "isMinter(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isMinterReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isMinterReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
+    ```solidity
+    function mint(address account, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`mint(address,uint256)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.account, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        account: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: mintReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: mintReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `renounceMinter()` and selector `0x98650275`.
+    ```solidity
+    function renounceMinter() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct renounceMinterCall;
+    ///Container type for the return parameters of the
+    /// [`renounceMinter()`](renounceMinterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct renounceMinterReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<renounceMinterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: renounceMinterCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceMinterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<renounceMinterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: renounceMinterReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceMinterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl renounceMinterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <renounceMinterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for renounceMinterCall {
+            type Parameters<'a> = ();
+            type Return = renounceMinterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [152u8, 101u8, 2u8, 117u8];
+            const SIGNATURE: &'static str = "renounceMinter()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                renounceMinterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`ERC20Mintable`](self) function calls.
+    #[derive(Clone)]
+    pub enum ERC20MintableCalls {
+        #[allow(missing_docs)]
+        addMinter(addMinterCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decreaseAllowance(decreaseAllowanceCall),
+        #[allow(missing_docs)]
+        increaseAllowance(increaseAllowanceCall),
+        #[allow(missing_docs)]
+        isMinter(isMinterCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        renounceMinter(renounceMinterCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl ERC20MintableCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [9u8, 94u8, 167u8, 179u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [57u8, 80u8, 147u8, 81u8],
+            [64u8, 193u8, 15u8, 25u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [152u8, 59u8, 45u8, 86u8],
+            [152u8, 101u8, 2u8, 117u8],
+            [164u8, 87u8, 194u8, 215u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [170u8, 39u8, 30u8, 26u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addMinterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <renounceMinterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isMinterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(approve),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(increaseAllowance),
+            ::core::stringify!(mint),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(addMinter),
+            ::core::stringify!(renounceMinter),
+            ::core::stringify!(decreaseAllowance),
+            ::core::stringify!(transfer),
+            ::core::stringify!(isMinter),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for ERC20MintableCalls {
+        const COUNT: usize = 12usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "ERC20MintableCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::addMinter(_) => <addMinterCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decreaseAllowance(_) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::increaseAllowance(_) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isMinter(_) => <isMinterCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::renounceMinter(_) => {
+                    <renounceMinterCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ERC20MintableCalls>] = &[
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn addMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <addMinterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::addMinter)
+                    }
+                    addMinter
+                },
+                {
+                    fn renounceMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <renounceMinterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::renounceMinter)
+                    }
+                    renounceMinter
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn isMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <isMinterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::isMinter)
+                    }
+                    isMinter
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ERC20MintableCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<ERC20MintableCalls>] = &[
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ERC20MintableCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn increaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ERC20MintableCalls::increaseAllowance)
+                    }
+                    increaseAllowance
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn addMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <addMinterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::addMinter)
+                    }
+                    addMinter
+                },
+                {
+                    fn renounceMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <renounceMinterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ERC20MintableCalls::renounceMinter)
+                    }
+                    renounceMinter
+                },
+                {
+                    fn decreaseAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ERC20MintableCalls::decreaseAllowance)
+                    }
+                    decreaseAllowance
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn isMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <isMinterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::isMinter)
+                    }
+                    isMinter
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ERC20MintableCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::addMinter(inner) => {
+                    <addMinterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isMinter(inner) => {
+                    <isMinterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::renounceMinter(inner) => {
+                    <renounceMinterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::addMinter(inner) => {
+                    <addMinterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decreaseAllowance(inner) => {
+                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::increaseAllowance(inner) => {
+                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isMinter(inner) => {
+                    <isMinterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::renounceMinter(inner) => {
+                    <renounceMinterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`ERC20Mintable`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum ERC20MintableEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        MinterAdded(MinterAdded),
+        #[allow(missing_docs)]
+        MinterRemoved(MinterRemoved),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl ERC20MintableEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                106u8, 225u8, 114u8, 131u8, 126u8, 163u8, 11u8, 128u8, 31u8, 191u8, 205u8, 212u8,
+                16u8, 138u8, 161u8, 213u8, 191u8, 143u8, 247u8, 117u8, 68u8, 79u8, 215u8, 2u8,
+                86u8, 180u8, 78u8, 107u8, 243u8, 223u8, 195u8, 246u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+            [
+                233u8, 68u8, 121u8, 169u8, 247u8, 225u8, 149u8, 44u8, 199u8, 143u8, 45u8, 107u8,
+                170u8, 182u8, 120u8, 173u8, 193u8, 183u8, 114u8, 217u8, 54u8, 198u8, 88u8, 61u8,
+                239u8, 72u8, 158u8, 82u8, 76u8, 182u8, 102u8, 146u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <MinterAdded as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+            <MinterRemoved as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(MinterAdded),
+            ::core::stringify!(Approval),
+            ::core::stringify!(Transfer),
+            ::core::stringify!(MinterRemoved),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for ERC20MintableEvents {
+        const COUNT: usize = 4usize;
+        const NAME: &'static str = "ERC20MintableEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<MinterAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <MinterAdded as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::MinterAdded)
+                }
+                Some(<MinterRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <MinterRemoved as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::MinterRemoved)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for ERC20MintableEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::MinterAdded(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::MinterRemoved(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::MinterAdded(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::MinterRemoved(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ERC20Mintable`](self) contract instance.
+
+    See the [wrapper's documentation](`ERC20MintableInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ERC20MintableInstance<P, N> {
+        ERC20MintableInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<ERC20MintableInstance<P, N>>>
+    {
+        ERC20MintableInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        ERC20MintableInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`ERC20Mintable`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ERC20Mintable`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ERC20MintableInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ERC20MintableInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ERC20MintableInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC20MintableInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ERC20Mintable`](self) contract instance.
+
+        See the [wrapper's documentation](`ERC20MintableInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<ERC20MintableInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ERC20MintableInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ERC20MintableInstance<P, N> {
+            ERC20MintableInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC20MintableInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`addMinter`] function.
+        pub fn addMinter(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, addMinterCall, N> {
+            self.call_builder(&addMinterCall { account })
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { account })
+        }
+
+        ///Creates a new call builder for the [`decreaseAllowance`] function.
+        pub fn decreaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
+            self.call_builder(&decreaseAllowanceCall {
+                spender,
+                subtractedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`increaseAllowance`] function.
+        pub fn increaseAllowance(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
+            self.call_builder(&increaseAllowanceCall {
+                spender,
+                addedValue,
+            })
+        }
+
+        ///Creates a new call builder for the [`isMinter`] function.
+        pub fn isMinter(
+            &self,
+            account: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isMinterCall, N> {
+            self.call_builder(&isMinterCall { account })
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            account: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { account, amount })
+        }
+
+        ///Creates a new call builder for the [`renounceMinter`] function.
+        pub fn renounceMinter(&self) -> alloy_contract::SolCallBuilder<&P, renounceMinterCall, N> {
+            self.call_builder(&renounceMinterCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { recipient, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            sender: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                sender,
+                recipient,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ERC20MintableInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`MinterAdded`] event.
+        pub fn MinterAdded_filter(&self) -> alloy_contract::Event<&P, MinterAdded, N> {
+            self.event_filter::<MinterAdded>()
+        }
+
+        ///Creates a new event filter for the [`MinterRemoved`] event.
+        pub fn MinterRemoved_filter(&self) -> alloy_contract::Event<&P, MinterRemoved, N> {
+            self.event_filter::<MinterRemoved>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = ERC20Mintable::ERC20MintableInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/flashloanrouter/Cargo.toml b/contracts/generated/contracts-generated/flashloanrouter/Cargo.toml
new file mode 100644
index 0000000000..ef3d5a05dd
--- /dev/null
+++ b/contracts/generated/contracts-generated/flashloanrouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-flashloanrouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs b/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs
new file mode 100644
index 0000000000..67a120838e
--- /dev/null
+++ b/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs
@@ -0,0 +1,1729 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library LoanRequest {
+    struct Data { uint256 amount; address borrower; address lender; address token; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod LoanRequest {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { uint256 amount; address borrower; address lender; address token; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub borrower: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub lender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (value.amount, value.borrower, value.lender, value.token)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    amount: tuple.0,
+                    borrower: tuple.1,
+                    lender: tuple.2,
+                    token: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.borrower,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.lender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(uint256 amount,address borrower,address lender,address token)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.borrower,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.lender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.borrower,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.lender,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.borrower,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.lender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`LoanRequest`](self) contract instance.
+
+    See the [wrapper's documentation](`LoanRequestInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> LoanRequestInstance<P, N> {
+        LoanRequestInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`LoanRequest`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`LoanRequest`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct LoanRequestInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for LoanRequestInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("LoanRequestInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LoanRequestInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`LoanRequest`](self) contract instance.
+
+        See the [wrapper's documentation](`LoanRequestInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> LoanRequestInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> LoanRequestInstance<P, N> {
+            LoanRequestInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LoanRequestInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LoanRequestInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library LoanRequest {
+    struct Data {
+        uint256 amount;
+        address borrower;
+        address lender;
+        address token;
+    }
+}
+
+interface FlashLoanRouter {
+    constructor(address _settlementContract);
+
+    function borrowerCallback(bytes memory encodedLoansWithSettlement) external;
+    function flashLoanAndSettle(LoanRequest.Data[] memory loans, bytes memory settlement) external;
+    function settlementAuthentication() external view returns (address);
+    function settlementContract() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_settlementContract",
+        "type": "address",
+        "internalType": "contract ICowSettlement"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "borrowerCallback",
+    "inputs": [
+      {
+        "name": "encodedLoansWithSettlement",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "flashLoanAndSettle",
+    "inputs": [
+      {
+        "name": "loans",
+        "type": "tuple[]",
+        "internalType": "struct LoanRequest.Data[]",
+        "components": [
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "borrower",
+            "type": "address",
+            "internalType": "contract IFlashLoanSolverWrapper"
+          },
+          {
+            "name": "lender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "contract IERC20"
+          }
+        ]
+      },
+      {
+        "name": "settlement",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "settlementAuthentication",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ICowAuthentication"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "settlementContract",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ICowSettlement"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod FlashLoanRouter {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xC0`@R_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U4\x80\x15a\0\x1EW__\xFD[P`@Qa\r\xC08\x03\x80a\r\xC0\x839\x81\x01`@\x81\x90Ra\0=\x91a\0\xD3V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\x80\x81\x90R`@\x80Qc#5\xC7k`\xE0\x1B\x81R\x90Qc#5\xC7k\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0\x86W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xAA\x91\x90a\0\xD3V[`\x01`\x01`\xA0\x1B\x03\x16`\xA0RPa\0\xF5V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0\xD0W__\xFD[PV[_` \x82\x84\x03\x12\x15a\0\xE3W__\xFD[\x81Qa\0\xEE\x81a\0\xBCV[\x93\x92PPPV[`\x80Q`\xA0Qa\x0C\x9Ea\x01\"_9_\x81\x81`S\x01Ra\x02`\x01R_\x81\x81`\xCB\x01Ra\x06A\x01Ra\x0C\x9E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x02\xEB\xCB\xEA\x14a\0NW\x80c\x0E\xFB\x1F\xB6\x14a\0\x9EW\x80c\xE7\xC48\xC9\x14a\0\xB3W\x80c\xEABA\x8B\x14a\0\xC6W[__\xFD[a\0u\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xB1a\0\xAC6`\x04a\x08\xB0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\t\xE5V[a\x022V[a\0u\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF_\\\x16\x14a\x01rW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FOnly callable by borrower\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\\\x16\x82\x17\x90]P\x80Q` \x82\x01 `\x01\\\x14a\x02&W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad data from borrower\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[a\x02/\x81a\x03cV[PV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xBAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDE\x91\x90a\n\x80V[a\x03DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FOnly callable by a solver\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[_a\x03Q\x85\x85\x85\x85a\x04\x8DV[\x90Pa\x03\\\x81a\x03cV[PPPPPV[` \x81\x01Q_\x03a\x03\x7FWa\x02/a\x03z\x82a\x05IV[a\x05\x8BV[_a\x03\x89\x82a\x071V[` \x81\x81\x01Q\x84Q\x91\x85\x01\x91\x90\x91 \x91\x92P\x90\x81_\x80\\\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x17\x90]P\x80\x80`\x01]P`@\x80Q\x80\x82\x01\x82R``\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x82R\x85Q` \x83\x01R\x85\x83\x01Q\x92Q\x7F\xE0\xBB\xECw\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x92\x90\x85\x16\x91c\xE0\xBB\xECw\x91a\x04Y\x91\x85\x90\x87\x90\x8B\x90`\x04\x01a\n\xA6V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04pW__\xFD[PZ\xF1\x15\x80\x15a\x04\x82W=__>=_\xFD[PPPPPPPPPV[``a\x04\xC4a\x04\x9D`\\\x86a\x0BrV[a\x04\xA8\x84` a\x0B\x8FV[a\x04\xB2\x91\x90a\x0B\x8FV[`@\x80Q\x82\x81R\x91\x82\x01` \x01\x90R\x90V[` \x80\x82\x01\x86\x81R\x91\x92Pa\x04\xD9\x90\x82a\x0B\x8FV[\x90P\x82\x84\x827a\x04\xE9\x83\x82a\x0B\x8FV[\x90P\x84[\x80\x15a\x05?W\x80a\x04\xFD\x81a\x0B\xA2V[\x91P\x82\x90Pa\x05,\x88\x88\x84\x81\x81\x10a\x05\x17Wa\x05\x17a\x0B\xD6V[\x90P`\x80\x02\x01\x82a\x08\x18\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x057`\\\x84a\x0B\x8FV[\x92PPa\x04\xEDV[PP\x94\x93PPPPV[``_`\\a\x05Y\x84` \x01Q\x90V[a\x05c\x91\x90a\x0BrV[` \x84Qa\x05q\x91\x90a\x0C\x03V[a\x05{\x91\x90a\x0C\x03V[` \x93\x90\x93\x01\x92\x83RP\x90\x91\x90PV[\x7F\x13\xD7\x9A\x0B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x05\xB5\x82a\x08gV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x06>W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FOnly settle() is allowed\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82`@Qa\x06\x84\x91\x90a\x0C\x16V[_`@Q\x80\x83\x03\x81_\x86Z\xF1\x91PP=\x80_\x81\x14a\x06\xBDW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x06\xC2V[``\x91P[PP\x90P\x80a\x07-W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FSettlement reverted\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[PPV[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R\x90`\x01a\x07a\x84` \x01Q\x90V[a\x07k\x91\x90a\x0C\x03V[\x90P_`\\\x84Qa\x07|\x91\x90a\x0C\x03V[\x90P` \x84\x01_a\x07\x8D\x83\x83a\x0B\x8FV[\x90P\x82\x86R\x83\x82Ra\x08\x0E\x81`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x91\x90\x91RP\x80Q`\x14\x82\x01Q`(\x83\x01Q`<\x90\x93\x01Q`@\x80Q`\x80\x81\x01\x82R\x93\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x85\x01R\x93\x82\x16\x93\x83\x01\x93\x90\x93R\x90\x91\x16``\x82\x01R\x90V[\x96\x95PPPPPPV[\x805_a\x08+`@\x84\x01` \x85\x01a\x0CMV[\x90P_a\x08>``\x85\x01`@\x86\x01a\x0CMV[\x90P_a\x08Q`\x80\x86\x01``\x87\x01a\x0CMV[`<\x87\x01RP`(\x85\x01R`\x14\x84\x01R\x90\x91RPV[_\x80` \x83\x01\x90P`\x04\x83Q\x10a\x08}W\x80Q\x91P[P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x08\xC0W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x08\xD6W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x08\xE6W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\0Wa\t\0a\x08\x83V[`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`?\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\tlWa\tla\x08\x83V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\t\x83W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[__\x83`\x1F\x84\x01\x12a\t\xB0W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xC7W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\t\xDEW__\xFD[\x92P\x92\x90PV[____`@\x85\x87\x03\x12\x15a\t\xF8W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x0EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x1EW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n4W__\xFD[\x87` \x82`\x07\x1B\x84\x01\x01\x11\x15a\nHW__\xFD[` \x91\x82\x01\x95P\x93P\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nhW__\xFD[a\nt\x87\x82\x88\x01a\t\xA0V[\x95\x98\x94\x97P\x95PPPPV[_` \x82\x84\x03\x12\x15a\n\x90W__\xFD[\x81Q\x80\x15\x15\x81\x14a\n\x9FW__\xFD[\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84Q\x16` \x82\x01R` \x84\x01Q`@\x82\x01R\x82``\x82\x01R`\xA0`\x80\x82\x01R_\x82Q\x80`\xA0\x84\x01R\x80` \x85\x01`\xC0\x85\x01^_`\xC0\x82\x85\x01\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x95\x94PPPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x0B\x89Wa\x0B\x89a\x0BEV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x89Wa\x0B\x89a\x0BEV[_\x81a\x0B\xB0Wa\x0B\xB0a\x0BEV[P\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0B\x89Wa\x0B\x89a\x0BEV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02/W__\xFD[_` \x82\x84\x03\x12\x15a\x0C]W__\xFD[\x815a\n\x9F\x81a\x0C,V\xFE\xA2dipfsX\"\x12 @\xD87\xBBq#c\x08_\xA1_\x0B)\x0ETY\x08C2\x13B\xF6\x1B/!\xD5$2\xD2\xDC\x8E{dsolcC\0\x08\x1C\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x02\xEB\xCB\xEA\x14a\0NW\x80c\x0E\xFB\x1F\xB6\x14a\0\x9EW\x80c\xE7\xC48\xC9\x14a\0\xB3W\x80c\xEABA\x8B\x14a\0\xC6W[__\xFD[a\0u\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xB1a\0\xAC6`\x04a\x08\xB0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\t\xE5V[a\x022V[a\0u\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF_\\\x16\x14a\x01rW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FOnly callable by borrower\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\\\x16\x82\x17\x90]P\x80Q` \x82\x01 `\x01\\\x14a\x02&W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad data from borrower\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[a\x02/\x81a\x03cV[PV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xBAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDE\x91\x90a\n\x80V[a\x03DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FOnly callable by a solver\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[_a\x03Q\x85\x85\x85\x85a\x04\x8DV[\x90Pa\x03\\\x81a\x03cV[PPPPPV[` \x81\x01Q_\x03a\x03\x7FWa\x02/a\x03z\x82a\x05IV[a\x05\x8BV[_a\x03\x89\x82a\x071V[` \x81\x81\x01Q\x84Q\x91\x85\x01\x91\x90\x91 \x91\x92P\x90\x81_\x80\\\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x17\x90]P\x80\x80`\x01]P`@\x80Q\x80\x82\x01\x82R``\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x82R\x85Q` \x83\x01R\x85\x83\x01Q\x92Q\x7F\xE0\xBB\xECw\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x92\x90\x85\x16\x91c\xE0\xBB\xECw\x91a\x04Y\x91\x85\x90\x87\x90\x8B\x90`\x04\x01a\n\xA6V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04pW__\xFD[PZ\xF1\x15\x80\x15a\x04\x82W=__>=_\xFD[PPPPPPPPPV[``a\x04\xC4a\x04\x9D`\\\x86a\x0BrV[a\x04\xA8\x84` a\x0B\x8FV[a\x04\xB2\x91\x90a\x0B\x8FV[`@\x80Q\x82\x81R\x91\x82\x01` \x01\x90R\x90V[` \x80\x82\x01\x86\x81R\x91\x92Pa\x04\xD9\x90\x82a\x0B\x8FV[\x90P\x82\x84\x827a\x04\xE9\x83\x82a\x0B\x8FV[\x90P\x84[\x80\x15a\x05?W\x80a\x04\xFD\x81a\x0B\xA2V[\x91P\x82\x90Pa\x05,\x88\x88\x84\x81\x81\x10a\x05\x17Wa\x05\x17a\x0B\xD6V[\x90P`\x80\x02\x01\x82a\x08\x18\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[a\x057`\\\x84a\x0B\x8FV[\x92PPa\x04\xEDV[PP\x94\x93PPPPV[``_`\\a\x05Y\x84` \x01Q\x90V[a\x05c\x91\x90a\x0BrV[` \x84Qa\x05q\x91\x90a\x0C\x03V[a\x05{\x91\x90a\x0C\x03V[` \x93\x90\x93\x01\x92\x83RP\x90\x91\x90PV[\x7F\x13\xD7\x9A\x0B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x05\xB5\x82a\x08gV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x06>W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FOnly settle() is allowed\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82`@Qa\x06\x84\x91\x90a\x0C\x16V[_`@Q\x80\x83\x03\x81_\x86Z\xF1\x91PP=\x80_\x81\x14a\x06\xBDW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x06\xC2V[``\x91P[PP\x90P\x80a\x07-W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FSettlement reverted\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01iV[PPV[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R\x90`\x01a\x07a\x84` \x01Q\x90V[a\x07k\x91\x90a\x0C\x03V[\x90P_`\\\x84Qa\x07|\x91\x90a\x0C\x03V[\x90P` \x84\x01_a\x07\x8D\x83\x83a\x0B\x8FV[\x90P\x82\x86R\x83\x82Ra\x08\x0E\x81`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x91\x90\x91RP\x80Q`\x14\x82\x01Q`(\x83\x01Q`<\x90\x93\x01Q`@\x80Q`\x80\x81\x01\x82R\x93\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x85\x01R\x93\x82\x16\x93\x83\x01\x93\x90\x93R\x90\x91\x16``\x82\x01R\x90V[\x96\x95PPPPPPV[\x805_a\x08+`@\x84\x01` \x85\x01a\x0CMV[\x90P_a\x08>``\x85\x01`@\x86\x01a\x0CMV[\x90P_a\x08Q`\x80\x86\x01``\x87\x01a\x0CMV[`<\x87\x01RP`(\x85\x01R`\x14\x84\x01R\x90\x91RPV[_\x80` \x83\x01\x90P`\x04\x83Q\x10a\x08}W\x80Q\x91P[P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x08\xC0W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x08\xD6W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x08\xE6W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\0Wa\t\0a\x08\x83V[`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`?\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\tlWa\tla\x08\x83V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\t\x83W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[__\x83`\x1F\x84\x01\x12a\t\xB0W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xC7W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\t\xDEW__\xFD[\x92P\x92\x90PV[____`@\x85\x87\x03\x12\x15a\t\xF8W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x0EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x1EW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n4W__\xFD[\x87` \x82`\x07\x1B\x84\x01\x01\x11\x15a\nHW__\xFD[` \x91\x82\x01\x95P\x93P\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nhW__\xFD[a\nt\x87\x82\x88\x01a\t\xA0V[\x95\x98\x94\x97P\x95PPPPV[_` \x82\x84\x03\x12\x15a\n\x90W__\xFD[\x81Q\x80\x15\x15\x81\x14a\n\x9FW__\xFD[\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84Q\x16` \x82\x01R` \x84\x01Q`@\x82\x01R\x82``\x82\x01R`\xA0`\x80\x82\x01R_\x82Q\x80`\xA0\x84\x01R\x80` \x85\x01`\xC0\x85\x01^_`\xC0\x82\x85\x01\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x95\x94PPPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x0B\x89Wa\x0B\x89a\x0BEV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x89Wa\x0B\x89a\x0BEV[_\x81a\x0B\xB0Wa\x0B\xB0a\x0BEV[P\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0B\x89Wa\x0B\x89a\x0BEV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02/W__\xFD[_` \x82\x84\x03\x12\x15a\x0C]W__\xFD[\x815a\n\x9F\x81a\x0C,V\xFE\xA2dipfsX\"\x12 @\xD87\xBBq#c\x08_\xA1_\x0B)\x0ETY\x08C2\x13B\xF6\x1B/!\xD5$2\xD2\xDC\x8E{dsolcC\0\x08\x1C\x003",
+    );
+    /**Constructor`.
+    ```solidity
+    constructor(address _settlementContract);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _settlementContract: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._settlementContract,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _settlementContract: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._settlementContract,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `borrowerCallback(bytes)` and selector `0x0efb1fb6`.
+    ```solidity
+    function borrowerCallback(bytes memory encodedLoansWithSettlement) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct borrowerCallbackCall {
+        #[allow(missing_docs)]
+        pub encodedLoansWithSettlement: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`borrowerCallback(bytes)`](borrowerCallbackCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct borrowerCallbackReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<borrowerCallbackCall> for UnderlyingRustTuple<'_> {
+                fn from(value: borrowerCallbackCall) -> Self {
+                    (value.encodedLoansWithSettlement,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for borrowerCallbackCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        encodedLoansWithSettlement: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<borrowerCallbackReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: borrowerCallbackReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for borrowerCallbackReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl borrowerCallbackReturn {
+            fn _tokenize(
+                &self,
+            ) -> <borrowerCallbackCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for borrowerCallbackCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = borrowerCallbackReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [14u8, 251u8, 31u8, 182u8];
+            const SIGNATURE: &'static str = "borrowerCallback(bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.encodedLoansWithSettlement,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                borrowerCallbackReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `flashLoanAndSettle((uint256,address,address,address)[],bytes)` and selector `0xe7c438c9`.
+    ```solidity
+    function flashLoanAndSettle(LoanRequest.Data[] memory loans, bytes memory settlement) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct flashLoanAndSettleCall {
+        #[allow(missing_docs)]
+        pub loans: alloy_sol_types::private::Vec<
+            <LoanRequest::Data as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub settlement: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`flashLoanAndSettle((uint256,address,address,address)[],
+    /// bytes)`](flashLoanAndSettleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct flashLoanAndSettleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LoanRequest::Data>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LoanRequest::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<flashLoanAndSettleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: flashLoanAndSettleCall) -> Self {
+                    (value.loans, value.settlement)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanAndSettleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        loans: tuple.0,
+                        settlement: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<flashLoanAndSettleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: flashLoanAndSettleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanAndSettleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl flashLoanAndSettleReturn {
+            fn _tokenize(
+                &self,
+            ) -> <flashLoanAndSettleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for flashLoanAndSettleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LoanRequest::Data>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = flashLoanAndSettleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [231u8, 196u8, 56u8, 201u8];
+            const SIGNATURE: &'static str =
+                "flashLoanAndSettle((uint256,address,address,address)[],bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LoanRequest::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self.loans),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.settlement,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                flashLoanAndSettleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `settlementAuthentication()` and selector `0x02ebcbea`.
+    ```solidity
+    function settlementAuthentication() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlementAuthenticationCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`settlementAuthentication()`](settlementAuthenticationCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlementAuthenticationReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlementAuthenticationCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settlementAuthenticationCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementAuthenticationCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlementAuthenticationReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settlementAuthenticationReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementAuthenticationReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settlementAuthenticationCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 235u8, 203u8, 234u8];
+            const SIGNATURE: &'static str = "settlementAuthentication()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: settlementAuthenticationReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: settlementAuthenticationReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `settlementContract()` and selector `0xea42418b`.
+    ```solidity
+    function settlementContract() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlementContractCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`settlementContract()`](settlementContractCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlementContractReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlementContractCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settlementContractCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementContractCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlementContractReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settlementContractReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementContractReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settlementContractCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [234u8, 66u8, 65u8, 139u8];
+            const SIGNATURE: &'static str = "settlementContract()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: settlementContractReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: settlementContractReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`FlashLoanRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum FlashLoanRouterCalls {
+        #[allow(missing_docs)]
+        borrowerCallback(borrowerCallbackCall),
+        #[allow(missing_docs)]
+        flashLoanAndSettle(flashLoanAndSettleCall),
+        #[allow(missing_docs)]
+        settlementAuthentication(settlementAuthenticationCall),
+        #[allow(missing_docs)]
+        settlementContract(settlementContractCall),
+    }
+    impl FlashLoanRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 235u8, 203u8, 234u8],
+            [14u8, 251u8, 31u8, 182u8],
+            [231u8, 196u8, 56u8, 201u8],
+            [234u8, 66u8, 65u8, 139u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <settlementAuthenticationCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <borrowerCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <flashLoanAndSettleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <settlementContractCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(settlementAuthentication),
+            ::core::stringify!(borrowerCallback),
+            ::core::stringify!(flashLoanAndSettle),
+            ::core::stringify!(settlementContract),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for FlashLoanRouterCalls {
+        const COUNT: usize = 4usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "FlashLoanRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::borrowerCallback(_) => {
+                    <borrowerCallbackCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::flashLoanAndSettle(_) => {
+                    <flashLoanAndSettleCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::settlementAuthentication(_) => {
+                    <settlementAuthenticationCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::settlementContract(_) => {
+                    <settlementContractCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<FlashLoanRouterCalls>] = &[
+                {
+                    fn settlementAuthentication(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(FlashLoanRouterCalls::settlementAuthentication)
+                    }
+                    settlementAuthentication
+                },
+                {
+                    fn borrowerCallback(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(FlashLoanRouterCalls::borrowerCallback)
+                    }
+                    borrowerCallback
+                },
+                {
+                    fn flashLoanAndSettle(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <flashLoanAndSettleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(FlashLoanRouterCalls::flashLoanAndSettle)
+                    }
+                    flashLoanAndSettle
+                },
+                {
+                    fn settlementContract(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <settlementContractCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(FlashLoanRouterCalls::settlementContract)
+                    }
+                    settlementContract
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<FlashLoanRouterCalls>] = &[
+                {
+                    fn settlementAuthentication(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(FlashLoanRouterCalls::settlementAuthentication)
+                    }
+                    settlementAuthentication
+                },
+                {
+                    fn borrowerCallback(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(FlashLoanRouterCalls::borrowerCallback)
+                    }
+                    borrowerCallback
+                },
+                {
+                    fn flashLoanAndSettle(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <flashLoanAndSettleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(FlashLoanRouterCalls::flashLoanAndSettle)
+                    }
+                    flashLoanAndSettle
+                },
+                {
+                    fn settlementContract(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
+                        <settlementContractCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(FlashLoanRouterCalls::settlementContract)
+                    }
+                    settlementContract
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::borrowerCallback(inner) => {
+                    <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::flashLoanAndSettle(inner) => {
+                    <flashLoanAndSettleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::settlementAuthentication(inner) => {
+                    <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::settlementContract(inner) => {
+                    <settlementContractCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::borrowerCallback(inner) => {
+                    <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::flashLoanAndSettle(inner) => {
+                    <flashLoanAndSettleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::settlementAuthentication(inner) => {
+                    <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::settlementContract(inner) => {
+                    <settlementContractCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`FlashLoanRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`FlashLoanRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> FlashLoanRouterInstance<P, N> {
+        FlashLoanRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _settlementContract: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<FlashLoanRouterInstance<P, N>>>
+    {
+        FlashLoanRouterInstance::<P, N>::deploy(__provider, _settlementContract)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _settlementContract: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        FlashLoanRouterInstance::<P, N>::deploy_builder(__provider, _settlementContract)
+    }
+    /**A [`FlashLoanRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`FlashLoanRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct FlashLoanRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for FlashLoanRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("FlashLoanRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        FlashLoanRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`FlashLoanRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`FlashLoanRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _settlementContract: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<FlashLoanRouterInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _settlementContract);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _settlementContract: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        _settlementContract,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> FlashLoanRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> FlashLoanRouterInstance<P, N> {
+            FlashLoanRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        FlashLoanRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`borrowerCallback`] function.
+        pub fn borrowerCallback(
+            &self,
+            encodedLoansWithSettlement: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, borrowerCallbackCall, N> {
+            self.call_builder(&borrowerCallbackCall {
+                encodedLoansWithSettlement,
+            })
+        }
+
+        ///Creates a new call builder for the [`flashLoanAndSettle`] function.
+        pub fn flashLoanAndSettle(
+            &self,
+            loans: alloy_sol_types::private::Vec<
+                <LoanRequest::Data as alloy_sol_types::SolType>::RustType,
+            >,
+            settlement: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, flashLoanAndSettleCall, N> {
+            self.call_builder(&flashLoanAndSettleCall { loans, settlement })
+        }
+
+        ///Creates a new call builder for the [`settlementAuthentication`]
+        /// function.
+        pub fn settlementAuthentication(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, settlementAuthenticationCall, N> {
+            self.call_builder(&settlementAuthenticationCall)
+        }
+
+        ///Creates a new call builder for the [`settlementContract`] function.
+        pub fn settlementContract(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, settlementContractCall, N> {
+            self.call_builder(&settlementContractCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        FlashLoanRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = FlashLoanRouter::FlashLoanRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x9da8b48441583a2b93e2ef8213aad0ec0b392c69"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/gashog/Cargo.toml b/contracts/generated/contracts-generated/gashog/Cargo.toml
new file mode 100644
index 0000000000..9e318062b7
--- /dev/null
+++ b/contracts/generated/contracts-generated/gashog/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gashog"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gashog/src/lib.rs b/contracts/generated/contracts-generated/gashog/src/lib.rs
new file mode 100644
index 0000000000..92965c1e03
--- /dev/null
+++ b/contracts/generated/contracts-generated/gashog/src/lib.rs
@@ -0,0 +1,784 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface GasHog {
+    function approve(address token, address spender, uint256 amount) external;
+    function isValidSignature(bytes32 order, bytes memory signature) external view returns (bytes4);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "contract ERC20"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GasHog {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x6080604052348015600e575f5ffd5b506103008061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80631626ba7e14610038578063e1f21c6714610080575b5f5ffd5b61004b6100463660046101c5565b610095565b6040517fffffffff00000000000000000000000000000000000000000000000000000000909116815260200160405180910390f35b61009361008e366004610260565b61013d565b005b5f5f5a90505f6100a78486018661029e565b90507fce7d7369855be79904099402d83db6d6ab8840dcd5c086e062cd1ca0c8111dfc5b815a6100d790856102b5565b1015610106576040805160208101839052016040516020818303038152906040528051906020012090506100cb565b868103610111575f5ffd5b507f1626ba7e000000000000000000000000000000000000000000000000000000009695505050505050565b6040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301526024820183905284169063095ea7b3906044015f604051808303815f87803b1580156101aa575f5ffd5b505af11580156101bc573d5f5f3e3d5ffd5b50505050505050565b5f5f5f604084860312156101d7575f5ffd5b83359250602084013567ffffffffffffffff8111156101f4575f5ffd5b8401601f81018613610204575f5ffd5b803567ffffffffffffffff81111561021a575f5ffd5b86602082840101111561022b575f5ffd5b939660209190910195509293505050565b73ffffffffffffffffffffffffffffffffffffffff8116811461025d575f5ffd5b50565b5f5f5f60608486031215610272575f5ffd5b833561027d8161023c565b9250602084013561028d8161023c565b929592945050506040919091013590565b5f602082840312156102ae575f5ffd5b5035919050565b818103818111156102ed577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b9291505056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x03\0\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80c\x16&\xBA~\x14a\08W\x80c\xE1\xF2\x1Cg\x14a\0\x80W[__\xFD[a\0Ka\0F6`\x04a\x01\xC5V[a\0\x95V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\x93a\0\x8E6`\x04a\x02`V[a\x01=V[\0[__Z\x90P_a\0\xA7\x84\x86\x01\x86a\x02\x9EV[\x90P\x7F\xCE}si\x85[\xE7\x99\x04\t\x94\x02\xD8=\xB6\xD6\xAB\x88@\xDC\xD5\xC0\x86\xE0b\xCD\x1C\xA0\xC8\x11\x1D\xFC[\x81Za\0\xD7\x90\x85a\x02\xB5V[\x10\x15a\x01\x06W`@\x80Q` \x81\x01\x83\x90R\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90Pa\0\xCBV[\x86\x81\x03a\x01\x11W__\xFD[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96\x95PPPPPPV[`@Q\x7F\t^\xA7\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`\x04\x83\x01R`$\x82\x01\x83\x90R\x84\x16\x90c\t^\xA7\xB3\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x01\xAAW__\xFD[PZ\xF1\x15\x80\x15a\x01\xBCW=__>=_\xFD[PPPPPPPV[___`@\x84\x86\x03\x12\x15a\x01\xD7W__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xF4W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x02\x04W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x02\x1AW__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\x02+W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02]W__\xFD[PV[___``\x84\x86\x03\x12\x15a\x02rW__\xFD[\x835a\x02}\x81a\x02<V[\x92P` \x84\x015a\x02\x8D\x81a\x02<V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x02\xAEW__\xFD[P5\x91\x90PV[\x81\x81\x03\x81\x81\x11\x15a\x02\xEDW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x92\x91PPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80631626ba7e14610038578063e1f21c6714610080575b5f5ffd5b61004b6100463660046101c5565b610095565b6040517fffffffff00000000000000000000000000000000000000000000000000000000909116815260200160405180910390f35b61009361008e366004610260565b61013d565b005b5f5f5a90505f6100a78486018661029e565b90507fce7d7369855be79904099402d83db6d6ab8840dcd5c086e062cd1ca0c8111dfc5b815a6100d790856102b5565b1015610106576040805160208101839052016040516020818303038152906040528051906020012090506100cb565b868103610111575f5ffd5b507f1626ba7e000000000000000000000000000000000000000000000000000000009695505050505050565b6040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301526024820183905284169063095ea7b3906044015f604051808303815f87803b1580156101aa575f5ffd5b505af11580156101bc573d5f5f3e3d5ffd5b50505050505050565b5f5f5f604084860312156101d7575f5ffd5b83359250602084013567ffffffffffffffff8111156101f4575f5ffd5b8401601f81018613610204575f5ffd5b803567ffffffffffffffff81111561021a575f5ffd5b86602082840101111561022b575f5ffd5b939660209190910195509293505050565b73ffffffffffffffffffffffffffffffffffffffff8116811461025d575f5ffd5b50565b5f5f5f60608486031215610272575f5ffd5b833561027d8161023c565b9250602084013561028d8161023c565b929592945050506040919091013590565b5f602082840312156102ae575f5ffd5b5035919050565b818103818111156102ed577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b9291505056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80c\x16&\xBA~\x14a\08W\x80c\xE1\xF2\x1Cg\x14a\0\x80W[__\xFD[a\0Ka\0F6`\x04a\x01\xC5V[a\0\x95V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\x93a\0\x8E6`\x04a\x02`V[a\x01=V[\0[__Z\x90P_a\0\xA7\x84\x86\x01\x86a\x02\x9EV[\x90P\x7F\xCE}si\x85[\xE7\x99\x04\t\x94\x02\xD8=\xB6\xD6\xAB\x88@\xDC\xD5\xC0\x86\xE0b\xCD\x1C\xA0\xC8\x11\x1D\xFC[\x81Za\0\xD7\x90\x85a\x02\xB5V[\x10\x15a\x01\x06W`@\x80Q` \x81\x01\x83\x90R\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90Pa\0\xCBV[\x86\x81\x03a\x01\x11W__\xFD[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96\x95PPPPPPV[`@Q\x7F\t^\xA7\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`\x04\x83\x01R`$\x82\x01\x83\x90R\x84\x16\x90c\t^\xA7\xB3\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x01\xAAW__\xFD[PZ\xF1\x15\x80\x15a\x01\xBCW=__>=_\xFD[PPPPPPPV[___`@\x84\x86\x03\x12\x15a\x01\xD7W__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xF4W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x02\x04W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x02\x1AW__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\x02+W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02]W__\xFD[PV[___``\x84\x86\x03\x12\x15a\x02rW__\xFD[\x835a\x02}\x81a\x02<V[\x92P` \x84\x015a\x02\x8D\x81a\x02<V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x02\xAEW__\xFD[P5\x91\x90PV[\x81\x81\x03\x81\x81\x11\x15a\x02\xEDW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x92\x91PPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,address,uint256)` and selector `0xe1f21c67`.
+    ```solidity
+    function approve(address token, address spender, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`approve(address,address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.token, value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        spender: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl approveReturn {
+            fn _tokenize(&self) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = approveReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [225u8, 242u8, 28u8, 103u8];
+            const SIGNATURE: &'static str = "approve(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                approveReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32 order, bytes memory signature) external view returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub order: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`GasHog`](self) function calls.
+    #[derive(Clone)]
+    pub enum GasHogCalls {
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+    }
+    impl GasHogCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[22u8, 38u8, 186u8, 126u8], [225u8, 242u8, 28u8, 103u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isValidSignature),
+            ::core::stringify!(approve),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for GasHogCalls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 96usize;
+        const NAME: &'static str = "GasHogCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<GasHogCalls>] = &[
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<GasHogCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GasHogCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<GasHogCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GasHogCalls::approve)
+                    }
+                    approve
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<GasHogCalls>] = &[
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<GasHogCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GasHogCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<GasHogCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GasHogCalls::approve)
+                    }
+                    approve
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GasHog`](self) contract instance.
+
+    See the [wrapper's documentation](`GasHogInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GasHogInstance<P, N> {
+        GasHogInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<GasHogInstance<P, N>>> {
+        GasHogInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GasHogInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`GasHog`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GasHog`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GasHogInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GasHogInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GasHogInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GasHogInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GasHog`](self) contract instance.
+
+        See the [wrapper's documentation](`GasHogInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<GasHogInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GasHogInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GasHogInstance<P, N> {
+            GasHogInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GasHogInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            token: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall {
+                token,
+                spender,
+                amount,
+            })
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            order: alloy_sol_types::private::FixedBytes<32>,
+            signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { order, signature })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GasHogInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = GasHog::GasHogInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/gnosissafe/Cargo.toml b/contracts/generated/contracts-generated/gnosissafe/Cargo.toml
new file mode 100644
index 0000000000..cd0a1543ef
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafe/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gnosissafe"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gnosissafe/src/lib.rs b/contracts/generated/contracts-generated/gnosissafe/src/lib.rs
new file mode 100644
index 0000000000..5194dadb85
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafe/src/lib.rs
@@ -0,0 +1,10361 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library Enum {
+    type Operation is uint8;
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Enum {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Operation(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Operation> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl Operation {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for Operation {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<Operation> for u8 {
+            fn from(value: Operation) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Operation {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Operation {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Enum`](self) contract instance.
+
+    See the [wrapper's documentation](`EnumInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> EnumInstance<P, N> {
+        EnumInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`Enum`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Enum`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct EnumInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for EnumInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("EnumInstance").field(&self.address).finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        EnumInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Enum`](self) contract instance.
+
+        See the [wrapper's documentation](`EnumInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> EnumInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> EnumInstance<P, N> {
+            EnumInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        EnumInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        EnumInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library Enum {
+    type Operation is uint8;
+}
+
+interface GnosisSafe {
+    event AddedOwner(address owner);
+    event ApproveHash(bytes32 indexed approvedHash, address indexed owner);
+    event ChangedFallbackHandler(address handler);
+    event ChangedGuard(address guard);
+    event ChangedThreshold(uint256 threshold);
+    event DisabledModule(address module);
+    event EnabledModule(address module);
+    event ExecutionFailure(bytes32 txHash, uint256 payment);
+    event ExecutionFromModuleFailure(address indexed module);
+    event ExecutionFromModuleSuccess(address indexed module);
+    event ExecutionSuccess(bytes32 txHash, uint256 payment);
+    event RemovedOwner(address owner);
+    event SafeReceived(address indexed sender, uint256 value);
+    event SafeSetup(address indexed initiator, address[] owners, uint256 threshold, address initializer, address fallbackHandler);
+    event SignMsg(bytes32 indexed msgHash);
+
+    constructor();
+
+    fallback() external;
+
+    receive() external payable;
+
+    function VERSION() external view returns (string memory);
+    function addOwnerWithThreshold(address owner, uint256 _threshold) external;
+    function approveHash(bytes32 hashToApprove) external;
+    function approvedHashes(address, bytes32) external view returns (uint256);
+    function changeThreshold(uint256 _threshold) external;
+    function checkNSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures, uint256 requiredSignatures) external view;
+    function checkSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures) external view;
+    function disableModule(address prevModule, address module) external;
+    function domainSeparator() external view returns (bytes32);
+    function enableModule(address module) external;
+    function encodeTransactionData(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes memory);
+    function execTransaction(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address payable refundReceiver, bytes memory signatures) external payable returns (bool success);
+    function execTransactionFromModule(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success);
+    function execTransactionFromModuleReturnData(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success, bytes memory returnData);
+    function getChainId() external view returns (uint256);
+    function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next);
+    function getOwners() external view returns (address[] memory);
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    function getThreshold() external view returns (uint256);
+    function getTransactionHash(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes32);
+    function isModuleEnabled(address module) external view returns (bool);
+    function isOwner(address owner) external view returns (bool);
+    function nonce() external view returns (uint256);
+    function removeOwner(address prevOwner, address owner, uint256 _threshold) external;
+    function requiredTxGas(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (uint256);
+    function setFallbackHandler(address handler) external;
+    function setGuard(address guard) external;
+    function setup(address[] memory _owners, uint256 _threshold, address to, bytes memory data, address fallbackHandler, address paymentToken, uint256 payment, address payable paymentReceiver) external;
+    function signedMessages(bytes32) external view returns (uint256);
+    function simulateAndRevert(address targetContract, bytes memory calldataPayload) external;
+    function swapOwner(address prevOwner, address oldOwner, address newOwner) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "fallback",
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "addOwnerWithThreshold",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_threshold",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "approveHash",
+    "inputs": [
+      {
+        "name": "hashToApprove",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "approvedHashes",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "changeThreshold",
+    "inputs": [
+      {
+        "name": "_threshold",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "checkNSignatures",
+    "inputs": [
+      {
+        "name": "dataHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "signatures",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "requiredSignatures",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "checkSignatures",
+    "inputs": [
+      {
+        "name": "dataHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "signatures",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "disableModule",
+    "inputs": [
+      {
+        "name": "prevModule",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "module",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "domainSeparator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "enableModule",
+    "inputs": [
+      {
+        "name": "module",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "encodeTransactionData",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "operation",
+        "type": "uint8",
+        "internalType": "enum Enum.Operation"
+      },
+      {
+        "name": "safeTxGas",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "baseGas",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "gasPrice",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "gasToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "refundReceiver",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_nonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "execTransaction",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "operation",
+        "type": "uint8",
+        "internalType": "enum Enum.Operation"
+      },
+      {
+        "name": "safeTxGas",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "baseGas",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "gasPrice",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "gasToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "refundReceiver",
+        "type": "address",
+        "internalType": "address payable"
+      },
+      {
+        "name": "signatures",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "execTransactionFromModule",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "operation",
+        "type": "uint8",
+        "internalType": "enum Enum.Operation"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "execTransactionFromModuleReturnData",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "operation",
+        "type": "uint8",
+        "internalType": "enum Enum.Operation"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "returnData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getChainId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getModulesPaginated",
+    "inputs": [
+      {
+        "name": "start",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "pageSize",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "array",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "next",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwners",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getStorageAt",
+    "inputs": [
+      {
+        "name": "offset",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getThreshold",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getTransactionHash",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "operation",
+        "type": "uint8",
+        "internalType": "enum Enum.Operation"
+      },
+      {
+        "name": "safeTxGas",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "baseGas",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "gasPrice",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "gasToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "refundReceiver",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_nonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isModuleEnabled",
+    "inputs": [
+      {
+        "name": "module",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonce",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "removeOwner",
+    "inputs": [
+      {
+        "name": "prevOwner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_threshold",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "requiredTxGas",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "operation",
+        "type": "uint8",
+        "internalType": "enum Enum.Operation"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setFallbackHandler",
+    "inputs": [
+      {
+        "name": "handler",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setGuard",
+    "inputs": [
+      {
+        "name": "guard",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setup",
+    "inputs": [
+      {
+        "name": "_owners",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "_threshold",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "fallbackHandler",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "paymentToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "payment",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "paymentReceiver",
+        "type": "address",
+        "internalType": "address payable"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "signedMessages",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "simulateAndRevert",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapOwner",
+    "inputs": [
+      {
+        "name": "prevOwner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "oldOwner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "AddedOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ApproveHash",
+    "inputs": [
+      {
+        "name": "approvedHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ChangedFallbackHandler",
+    "inputs": [
+      {
+        "name": "handler",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ChangedGuard",
+    "inputs": [
+      {
+        "name": "guard",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ChangedThreshold",
+    "inputs": [
+      {
+        "name": "threshold",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "DisabledModule",
+    "inputs": [
+      {
+        "name": "module",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "EnabledModule",
+    "inputs": [
+      {
+        "name": "module",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExecutionFailure",
+    "inputs": [
+      {
+        "name": "txHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "payment",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExecutionFromModuleFailure",
+    "inputs": [
+      {
+        "name": "module",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExecutionFromModuleSuccess",
+    "inputs": [
+      {
+        "name": "module",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExecutionSuccess",
+    "inputs": [
+      {
+        "name": "txHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "payment",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RemovedOwner",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SafeReceived",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SafeSetup",
+    "inputs": [
+      {
+        "name": "initiator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "owners",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      },
+      {
+        "name": "threshold",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "initializer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "fallbackHandler",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SignMsg",
+    "inputs": [
+      {
+        "name": "msgHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GnosisSafe {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x01`\x04\x81\x90UPaY\xAE\x80b\0\0)`\09`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\xDCW`\x005`\xE0\x1C\x80c\xAF\xFE\xD0\xE0\x11a\x01\x02W\x80c\xE1\x9A\x9D\xD9\x11a\0\x95W\x80c\xF0\x8A\x03#\x11a\0dW\x80c\xF0\x8A\x03#\x14a\x16GW\x80c\xF6\x98\xDA%\x14a\x16\x98W\x80c\xF8\xDC]\xD9\x14a\x16\xC3W\x80c\xFF\xA1\xADt\x14a\x17>Wa\x021V[\x80c\xE1\x9A\x9D\xD9\x14a\x13\x9BW\x80c\xE3\x18\xB5+\x14a\x13\xECW\x80c\xE7R5\xB8\x14a\x14}W\x80c\xE8f7\xDB\x14a\x14\xA8Wa\x021V[\x80c\xCC/\x84R\x11a\0\xD1W\x80c\xCC/\x84R\x14a\x10\xE8W\x80c\xD4\xD9\xBD\xCD\x14a\x11\xB5W\x80c\xD8\xD1\x1Fx\x14a\x11\xF0W\x80c\xE0\t\xCF\xDE\x14a\x13*Wa\x021V[\x80c\xAF\xFE\xD0\xE0\x14a\r\x94W\x80c\xB4\xFA\xBA\t\x14a\r\xBFW\x80c\xB6>\x80\r\x14a\x0E\xA7W\x80c\xC4\xCA:\x9C\x14a\x10\x17Wa\x021V[\x80cV$\xB2[\x11a\x01zW\x80cjv\x12\x02\x11a\x01IW\x80cjv\x12\x02\x14a\t\x94W\x80c}\x83)t\x14a\x0BPW\x80c\x93O:\x11\x14a\x0B\xBFW\x80c\xA0\xE6~+\x14a\r(Wa\x021V[\x80cV$\xB2[\x14a\x07\xFBW\x80cZ\xE6\xBD7\x14a\x08\xB9W\x80ca\x0BY%\x14a\t\x08W\x80ciN\x80\xC3\x14a\tYWa\x021V[\x80c/T\xBFn\x11a\x01\xB6W\x80c/T\xBFn\x14a\x04\xD3W\x80c4\x08\xE4p\x14a\x05:W\x80cF\x87!\xA7\x14a\x05eW\x80cR)\x07?\x14a\x06zWa\x021V[\x80c\rX/\x13\x14a\x02\x9EW\x80c\x12\xFBh\xE0\x14a\x02\xF9W\x80c-\x9A\xD5=\x14a\x04lWa\x021V[6a\x021W3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F=\x0C\xE9\xBF\xC3\xED}hb\xDB\xB2\x8B-\xEA\x94V\x1F\xE7\x14\xA1\xB4\xD0\x19\xAA\x8A\xF3\x970\xD1\xAD|=4`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA2\0[4\x80\x15a\x02=W`\0\x80\xFD[P`\0\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\0\x1B\x90P\x80T\x80a\x02rW`\0\x80\xF3[6`\0\x8073``\x1B6R`\0\x80`\x146\x01`\0\x80\x85Z\xF1=`\0\x80>\x80a\x02\x99W=`\0\xFD[=`\0\xF3[4\x80\x15a\x02\xAAW`\0\x80\xFD[Pa\x02\xF7`\x04\x806\x03`@\x81\x10\x15a\x02\xC1W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x17\xCEV[\0[4\x80\x15a\x03\x05W`\0\x80\xFD[Pa\x04j`\x04\x806\x03`\x80\x81\x10\x15a\x03\x1CW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03UW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03wW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03\xDAW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xECW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\x0EW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x1B\xBEV[\0[4\x80\x15a\x04xW`\0\x80\xFD[Pa\x04\xBB`\x04\x806\x03` \x81\x10\x15a\x04\x8FW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa$@V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xDFW`\0\x80\xFD[Pa\x05\"`\x04\x806\x03` \x81\x10\x15a\x04\xF6W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa%\x12V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05FW`\0\x80\xFD[Pa\x05Oa%\xE4V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05qW`\0\x80\xFD[Pa\x06b`\x04\x806\x03`\x80\x81\x10\x15a\x05\x88W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x05\xCFW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\xE1W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x06\x03W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa%\xF1V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\x86W`\0\x80\xFD[Pa\x07w`\x04\x806\x03`\x80\x81\x10\x15a\x06\x9DW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x06\xE4W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\xF6W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\x18W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa'\xD7V[`@Q\x80\x83\x15\x15\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x07\xBFW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x07\xA4V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x07\xECW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x93PPPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x07W`\0\x80\xFD[Pa\x08>`\x04\x806\x03`@\x81\x10\x15a\x08\x1EW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa(\rV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x08~W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x08cV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x08\xABW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xC5W`\0\x80\xFD[Pa\x08\xF2`\x04\x806\x03` \x81\x10\x15a\x08\xDCW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa(\x94V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x14W`\0\x80\xFD[Pa\tW`\x04\x806\x03` \x81\x10\x15a\t+W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa(\xACV[\0[4\x80\x15a\teW`\0\x80\xFD[Pa\t\x92`\x04\x806\x03` \x81\x10\x15a\t|W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa,>V[\0[a\x0B8`\x04\x806\x03a\x01@\x81\x10\x15a\t\xABW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\t\xF2W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\x04W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n&W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\n\xB2W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\xC4W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n\xE6W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa-xV[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x0B\\W`\0\x80\xFD[Pa\x0B\xA9`\x04\x806\x03`@\x81\x10\x15a\x0BsW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa2\xB5V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x0B\xCBW`\0\x80\xFD[Pa\r&`\x04\x806\x03``\x81\x10\x15a\x0B\xE2W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0C\tW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0C\x1BW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0C=W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0C\xA0W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0C\xB2W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0C\xD4W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa2\xDAV[\0[4\x80\x15a\r4W`\0\x80\xFD[Pa\r=a3iV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\r\x80W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\reV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\r\xA0W`\0\x80\xFD[Pa\r\xA9a5\x12V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\r\xCBW`\0\x80\xFD[Pa\x0E\xA5`\x04\x806\x03`@\x81\x10\x15a\r\xE2W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0E\x1FW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0E1W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0ESW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa5\x18V[\0[4\x80\x15a\x0E\xB3W`\0\x80\xFD[Pa\x10\x15`\x04\x806\x03a\x01\0\x81\x10\x15a\x0E\xCBW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0E\xE8W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0E\xFAW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0F\x1CW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0FgW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0FyW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0F\x9BW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa5:V[\0[4\x80\x15a\x10#W`\0\x80\xFD[Pa\x10\xD2`\x04\x806\x03`\x80\x81\x10\x15a\x10:W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x10\x81W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x10\x93W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x10\xB5W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa6\xF8V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x10\xF4W`\0\x80\xFD[Pa\x11A`\x04\x806\x03`@\x81\x10\x15a\x11\x0BW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa8 V[`@Q\x80\x80` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x11\xA0W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x11\x85V[PPPP\x90P\x01\x93PPPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x11\xC1W`\0\x80\xFD[Pa\x11\xEE`\x04\x806\x03` \x81\x10\x15a\x11\xD8W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa:\x12V[\0[4\x80\x15a\x11\xFCW`\0\x80\xFD[Pa\x13\x14`\x04\x806\x03a\x01@\x81\x10\x15a\x12\x14W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x12[W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x12mW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x12\x8FW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa;\xB1V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x136W`\0\x80\xFD[Pa\x13\x99`\x04\x806\x03`@\x81\x10\x15a\x13MW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa;\xDEV[\0[4\x80\x15a\x13\xA7W`\0\x80\xFD[Pa\x13\xEA`\x04\x806\x03` \x81\x10\x15a\x13\xBEW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa?oV[\0[4\x80\x15a\x13\xF8W`\0\x80\xFD[Pa\x14{`\x04\x806\x03``\x81\x10\x15a\x14\x0FW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa?\xF3V[\0[4\x80\x15a\x14\x89W`\0\x80\xFD[Pa\x14\x92aFeV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x14\xB4W`\0\x80\xFD[Pa\x15\xCC`\x04\x806\x03a\x01@\x81\x10\x15a\x14\xCCW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x15\x13W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x15%W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x15GW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPaFoV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x16\x0CW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x15\xF1V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x169W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x16SW`\0\x80\xFD[Pa\x16\x96`\x04\x806\x03` \x81\x10\x15a\x16jW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPaH\x17V[\0[4\x80\x15a\x16\xA4W`\0\x80\xFD[Pa\x16\xADaHxV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x16\xCFW`\0\x80\xFD[Pa\x17<`\x04\x806\x03``\x81\x10\x15a\x16\xE6W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPaH\xF6V[\0[4\x80\x15a\x17JW`\0\x80\xFD[Pa\x17SaM)V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x17\x93W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x17xV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x17\xC0W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x17\xD6aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x18@WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a\x18xWP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a\x18\xEAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x19\xEBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x03`\0\x81T\x80\x92\x91\x90`\x01\x01\x91\x90PUP\x7F\x94e\xFA\x0C\x96,\xC7iX\xE67:\x993&@\x0C\x1C\x94\xF8\xBE/\xE3\xA9R\xAD\xFA\x7F`\xB2\xEA&\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x80`\x04T\x14a\x1B\xBAWa\x1B\xB9\x81a,>V[[PPV[a\x1B\xD2`A\x82aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82Q\x10\x15a\x1CHW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS020\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80\x80`\0\x80`\0[\x86\x81\x10\x15a$4Wa\x1Cd\x88\x82aN?V[\x80\x94P\x81\x95P\x82\x96PPPP`\0\x84`\xFF\x16\x14\x15a mW\x82`\0\x1C\x94Pa\x1C\x96`A\x88aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82`\0\x1C\x10\x15a\x1D\x0EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS021\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x87Qa\x1D'` \x84`\0\x1CaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x11\x15a\x1D\x9BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS022\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0` \x83\x8A\x01\x01Q\x90P\x88Qa\x1D\xD1\x82a\x1D\xC3` \x87`\0\x1CaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x11\x15a\x1EEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS023\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[``` \x84\x8B\x01\x01\x90Pc \xC1;\x0B`\xE0\x1B{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \xC1;\x0B\x8D\x84`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x80` \x01\x80` \x01\x83\x81\x03\x83R\x85\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x1E\xE7W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1E\xCCV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x1F\x14W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x83\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x1FMW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1F2V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x1FzW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x94PPPPP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1F\x99W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\xADW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1F\xC3W`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14a fW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS024\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPa\"\xB2V[`\x01\x84`\xFF\x16\x14\x15a!\x81W\x82`\0\x1C\x94P\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x80a!\nWP`\0`\x08`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x8C\x81R` \x01\x90\x81R` \x01`\0 T\x14\x15[a!|W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS025\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\"\xB1V[`\x1E\x84`\xFF\x16\x11\x15a\"IW`\x01\x8A`@Q` \x01\x80\x80\x7F\x19Ethereum Signed Message:\n32\0\0\0\0\x81RP`\x1C\x01\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `\x04\x86\x03\x85\x85`@Q`\0\x81R` \x01`@R`@Q\x80\x85\x81R` \x01\x84`\xFF\x16\x81R` \x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\"8W=`\0\x80>=`\0\xFD[PPP` `@Q\x03Q\x94Pa\"\xB0V[`\x01\x8A\x85\x85\x85`@Q`\0\x81R` \x01`@R`@Q\x80\x85\x81R` \x01\x84`\xFF\x16\x81R` \x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\"\xA3W=`\0\x80>=`\0\xFD[PPP` `@Q\x03Q\x94P[[[\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11\x80\x15a#yWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a#\xB2WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a$$W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS026\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x84\x95P\x80\x80`\x01\x01\x91PPa\x1CRV[PPPPPPPPPPV[`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a%\x0BWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x91\x90PV[`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a%\xDDWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x91\x90PV[`\0\x80F\x90P\x80\x91PP\x90V[`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a&\xBCWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a'.W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS104\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a';\x85\x85\x85\x85ZaN\x8DV[\x90P\x80\x15a'\x8BW3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fh\x95\xC16d\xAAOg(\x8B%\xD7\xA2\x1Dz\xAA4\x91n5_\xB9\xB6\xFA\xE0\xA19\xA9\x08[\xEC\xB8`@Q`@Q\x80\x91\x03\x90\xA2a'\xCFV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xAC\xD2\xC8p(\x04\x12\x8F\xDB\r\xB2\xBBI\xF6\xD1'\xDD\x01\x81\xC1?\xD4]\xBF\xE1m\xE0\x93\x0E+\xD3u`@Q`@Q\x80\x91\x03\x90\xA2[\x94\x93PPPPV[`\0``a'\xE7\x86\x86\x86\x86a%\xF1V[\x91P`@Q` =\x01\x81\x01`@R=\x81R=`\0` \x83\x01>\x80\x91PP\x94P\x94\x92PPPV[```\0` \x83\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a(+W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a(^W\x81` \x01`\x01\x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x90P`\0[\x83\x81\x10\x15a(\x89W\x80\x85\x01T\x80` \x83\x02` \x85\x01\x01RP\x80\x80`\x01\x01\x91PPa(dV[P\x80\x91PP\x92\x91PPV[`\x07` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a(\xB4aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a)\x1EWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a)\x90W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS101\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a*\x91W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS102\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xEC\xDF:>\xFF\xEAW\x83\xA3\xC4\xC2\x14\x0Eguwfd(\xD4N\xD9\xD4t\xA0\xB3\xA4\xC9\x94?\x84@\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[a,FaMbV[`\x03T\x81\x11\x15a,\xBEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x81\x10\x15a-5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS202\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x04\x81\x90UP\x7Fa\x0F\x7F\xF2\xB3\x04\xAE\x89\x03\xC3\xDEt\xC6\x0Cj\xB1\xF7\xD6\"k?R\xC5\x16\x19\x05\xBBZ\xD4\x03\x9C\x93`\x04T`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[`\0\x80`\0a-\x92\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E`\x05TaFoV[\x90P`\x05`\0\x81T\x80\x92\x91\x90`\x01\x01\x91\x90PUP\x80\x80Q\x90` \x01 \x91Pa-\xBB\x82\x82\x86a2\xDAV[P`\0a-\xC6aN\xD9V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a/\xACW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cu\xF0\xBBR\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F3`@Q\x8Dc\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8C\x81R` \x01\x80` \x01\x8A`\x01\x81\x11\x15a.iW\xFE[\x81R` \x01\x89\x81R` \x01\x88\x81R` \x01\x87\x81R` \x01\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83\x81\x03\x83R\x8D\x8D\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x83\x81\x03\x82R\x85\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a/;W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa/ V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a/hW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x9EPPPPPPPPPPPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a/\x93W`\0\x80\xFD[PZ\xF1\x15\x80\x15a/\xA7W=`\0\x80>=`\0\xFD[PPPP[a\x01\xF4a/\xD3a\t\xC4\x8B\x01`?`@\x8D\x02\x81a/\xC4W\xFE[\x04aO\n\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x01Z\x10\x15a0IW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS010\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0Z\x90Pa0\xB2\x8F\x8F\x8F\x8F\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x8E`\0\x8D\x14a0\xA7W\x8Ea0\xADV[a\t\xC4Z\x03[aN\x8DV[\x93Pa0\xC7Z\x82aO$\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x83\x80a0\xD6WP`\0\x8A\x14\x15[\x80a0\xE2WP`\0\x88\x14\x15[a1TW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS013\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80\x89\x11\x15a1nWa1k\x82\x8B\x8B\x8B\x8BaODV[\x90P[\x84\x15a1\xB8W\x7FD.q_bcF\xE8\xC5C\x81\0-\xA6\x14\xF6+\xEE\x8D'8e5\xB2R\x1E\xC8T\x08\x98Un\x84\x82`@Q\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1a1\xF8V[\x7F#B\x8B\x18\xAC\xFB>\xA6K\x08\xDC\x0C\x1D)n\xA9\xC0\x97\x02\xC0\x90\x83\xCARr\xE6M\x11[h}#\x84\x82`@Q\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1[PP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a2\xA4W\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x93'\x13h\x83\x85`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83\x81R` \x01\x82\x15\x15\x81R` \x01\x92PPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a2\x8BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a2\x9FW=`\0\x80>=`\0\xFD[PPPP[PP\x9B\x9APPPPPPPPPPPV[`\x08` R\x81`\0R`@`\0 ` R\x80`\0R`@`\0 `\0\x91P\x91PPT\x81V[`\0`\x04T\x90P`\0\x81\x11a3WW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS001\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a3c\x84\x84\x84\x84a\x1B\xBEV[PPPPV[```\0`\x03Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a3\x86W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a3\xB5W\x81` \x01` \x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x90P`\0\x80`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a5\tW\x80\x83\x83\x81Q\x81\x10a4`W\xFE[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP`\x02`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81\x80`\x01\x01\x92PPa4\x1FV[\x82\x93PPPP\x90V[`\x05T\x81V[`\0\x80\x82Q` \x84\x01\x85Z\xF4\x80`\0R=` R=`\0`@>`@=\x01`\0\xFD[a5\x85\x8A\x8A\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x89aQJV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a5\xC3Wa5\xC2\x84aVJV[[a6\x11\x87\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPPaVyV[`\0\x82\x11\x15a6+Wa6)\x82`\0`\x01\x86\x85aODV[P[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x14\x1D\xF8h\xA63\x1A\xF5(\xE3\x8C\x83\xB7\xAA\x03\xED\xC1\x9B\xE6n7\xAEg\xF9([\xF4\xF8\xE3\xC6\xA1\xA8\x8B\x8B\x8B\x8B\x89`@Q\x80\x80` \x01\x85\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81\x03\x82R\x87\x87\x82\x81\x81R` \x01\x92P` \x02\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x96PPPPPPP`@Q\x80\x91\x03\x90\xA2PPPPPPPPPPV[`\0\x80Z\x90Pa7O\x87\x87\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x86ZaN\x8DV[a7XW`\0\x80\xFD[`\0Z\x82\x03\x90P\x80`@Q` \x01\x80\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a7\xE5W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa7\xCAV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a8\x12W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xFD[```\0\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a8;W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8jW\x81` \x01` \x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x91P`\0\x80`\x01`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a9=WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a9HWP\x84\x82\x10[\x15a:\x03W\x80\x84\x83\x81Q\x81\x10a9ZW\xFE[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP`\x01`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81\x80`\x01\x01\x92PPa8\xD3V[\x80\x92P\x81\x84RPP\x92P\x92\x90PV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a;\x14W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS030\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\x08`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x83\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x7F\xF2\xA0\xEB\x15dr\xD1D\x02U\xB0\xD7\xC1\xE1\x9C\xC0q\x15\xD1\x05\x1F\xE6\x05\xB0\xDC\xE6\x9A\xCF\xEC\x88M\x9C`@Q`@Q\x80\x91\x03\x90\xA3PV[`\0a;\xC6\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8CaFoV[\x80Q\x90` \x01 \x90P\x9B\x9APPPPPPPPPPPV[a;\xE6aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a<PWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a<\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS101\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a=\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS103\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xAA\xB4\xFA+F?X\x1B+2\xCB;~;pK\x9C\xE3|\xC2\t\xB5\xFBMw\xE5\x93\xAC\xE4\x05Bv\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPV[a?waMbV[`\0\x7FJ Ob\x0C\x8C\\\xCD\xCA?\xD5M\0;\xAD\xD8[\xA5\0CjC\x1F\x0C\xBD\xA4\xF5X\xC9<4\xC8`\0\x1B\x90P\x81\x81U\x7F\x11Q\x11i\x14Q[\xC0\x89\x1F\xF9\x04zl\xB3,\xF9\x02To\x83\x06d\x99\xBC\xF8\xBA3\xD25?\xA2\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPV[a?\xFBaMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a@eWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a@\x9DWP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aA\x0FW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aB\x10W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aBzWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aB\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aC\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS205\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xF8\xD4\x9F\xC5)\x81.\x9A|\\P\xE6\x9C \xF0\xDC\xCC\r\xB8\xFA\x95\xC9\x8B\xC5\x8C\xC9\xA4\xF1\xC1)\x9E\xAF\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x7F\x94e\xFA\x0C\x96,\xC7iX\xE67:\x993&@\x0C\x1C\x94\xF8\xBE/\xE3\xA9R\xAD\xFA\x7F`\xB2\xEA&\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPPV[`\0`\x04T\x90P\x90V[```\0\x7F\xBB\x83\x10\xD4\x866\x8D\xB6\xBDo\x84\x94\x02\xFD\xD7:\xD5=1kZK&D\xADn\xFE\x0F\x94\x12\x86\xD8`\0\x1B\x8D\x8D\x8D\x8D`@Q\x80\x83\x83\x80\x82\x847\x80\x83\x01\x92PPP\x92PPP`@Q\x80\x91\x03\x90 \x8C\x8C\x8C\x8C\x8C\x8C\x8C`@Q` \x01\x80\x8C\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A\x81R` \x01\x89\x81R` \x01\x88`\x01\x81\x11\x15aG\0W\xFE[\x81R` \x01\x87\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x9BPPPPPPPPPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\x19`\xF8\x1B`\x01`\xF8\x1BaG\x8CaHxV[\x83`@Q` \x01\x80\x85~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x84~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x9B\x9APPPPPPPPPPPV[aH\x1FaMbV[aH(\x81aVJV[\x7FZ\xC6\xC4l\x93\xC8\xD0\xE57\x14\xBA;S\xDB>|\x04m\xA9\x941=~\xD0\xD1\x92\x02\x8B\xC7\xC2(\xB0\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[`\0\x7FG\xE7\x954\xA2E\x95.\x8B\x16\x89:3k\x85\xA3\xD9\xEA\x9F\xA8\xC5s\xF3\xD8\x03\xAF\xB9*yF\x92\x18`\0\x1BaH\xA6a%\xE4V[0`@Q` \x01\x80\x84\x81R` \x01\x83\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x93PPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[aH\xFEaMbV[\x80`\x01`\x03T\x03\x10\x15aIyW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aI\xE3WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aJUW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aKUW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS205\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x03`\0\x81T\x80\x92\x91\x90`\x01\x90\x03\x91\x90PUP\x7F\xF8\xD4\x9F\xC5)\x81.\x9A|\\P\xE6\x9C \xF0\xDC\xCC\r\xB8\xFA\x95\xC9\x8B\xC5\x8C\xC9\xA4\xF1\xC1)\x9E\xAF\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x80`\x04T\x14aM$WaM#\x81a,>V[[PPPV[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F1.3.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aN\x03W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS031\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[V[`\0\x80\x83\x14\x15aN\x18W`\0\x90PaN9V[`\0\x82\x84\x02\x90P\x82\x84\x82\x81aN)W\xFE[\x04\x14aN4W`\0\x80\xFD[\x80\x91PP[\x92\x91PPV[`\0\x80`\0\x83`A\x02` \x81\x01\x86\x01Q\x92P`@\x81\x01\x86\x01Q\x91P`\xFF`A\x82\x01\x87\x01Q\x16\x93PP\x92P\x92P\x92V[`\0\x80\x82\x84\x01\x90P\x83\x81\x10\x15aN\x83W`\0\x80\xFD[\x80\x91PP\x92\x91PPV[`\0`\x01\x80\x81\x11\x15aN\x9BW\xFE[\x83`\x01\x81\x11\x15aN\xA7W\xFE[\x14\x15aN\xC0W`\0\x80\x85Q` \x87\x01\x89\x86\xF4\x90PaN\xD0V[`\0\x80\x85Q` \x87\x01\x88\x8A\x87\xF1\x90P[\x95\x94PPPPPV[`\0\x80\x7FJ Ob\x0C\x8C\\\xCD\xCA?\xD5M\0;\xAD\xD8[\xA5\0CjC\x1F\x0C\xBD\xA4\xF5X\xC9<4\xC8`\0\x1B\x90P\x80T\x91PP\x90V[`\0\x81\x83\x10\x15aO\x1AW\x81aO\x1CV[\x82[\x90P\x92\x91PPV[`\0\x82\x82\x11\x15aO3W`\0\x80\xFD[`\0\x82\x84\x03\x90P\x80\x91PP\x92\x91PPV[`\0\x80`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aO\x81W\x82aO\x83V[2[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aP\x9BWaO\xED:\x86\x10aO\xCAW:aO\xCCV[\x85[aO\xDF\x88\x8AaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x08\xFC\x83\x90\x81\x15\x02\x90`@Q`\0`@Q\x80\x83\x03\x81\x85\x88\x88\xF1\x93PPPPaP\x96W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS011\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[aQ@V[aP\xC0\x85aP\xB2\x88\x8AaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91PaP\xCD\x84\x82\x84aX\xB4V[aQ?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS012\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[[P\x95\x94PPPPPV[`\0`\x04T\x14aQ\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81Q\x81\x11\x15aR9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x81\x10\x15aR\xB0W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS202\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0`\x01\x90P`\0[\x83Q\x81\x10\x15aU\xB6W`\0\x84\x82\x81Q\x81\x10aR\xD0W\xFE[` \x02` \x01\x01Q\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aSDWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15aS|WP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15aS\xB4WP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aT&W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aU'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80\x92PP\x80\x80`\x01\x01\x91PPaR\xB9V[P`\x01`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x82Q`\x03\x81\x90UP\x81`\x04\x81\x90UPPPPV[`\0\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\0\x1B\x90P\x81\x81UPPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aW{W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS100\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x80`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aX\xB0WaX=\x82`\0\x83`\x01ZaN\x8DV[aX\xAFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS000\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[[PPV[`\0\x80c\xA9\x05\x9C\xBB\x84\x84`@Q`$\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90`\xE0\x1B` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x83\x16\x17\x83RPPPP\x90P` `\0\x82Q` \x84\x01`\0\x89a'\x10Z\x03\xF1=`\0\x81\x14aY[W` \x81\x14aYcW`\0\x93PaYnV[\x81\x93PaYnV[`\0Q\x15\x82\x15\x17\x15\x93P[PPP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 8t\xBC\xF9.\x17\"\xCC{\xFA\x0C\xEF\x1A\t\x85\xCF\r\xC3H[\xA0f=\xB3t|\xCD\xF1`]\xF54dsolcC\0\x07\x06\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AddedOwner(address)` and selector `0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26`.
+    ```solidity
+    event AddedOwner(address owner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AddedOwner {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AddedOwner {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AddedOwner(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    148u8, 101u8, 250u8, 12u8, 150u8, 44u8, 199u8, 105u8, 88u8, 230u8, 55u8, 58u8,
+                    153u8, 51u8, 38u8, 64u8, 12u8, 28u8, 148u8, 248u8, 190u8, 47u8, 227u8, 169u8,
+                    82u8, 173u8, 250u8, 127u8, 96u8, 178u8, 234u8, 38u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { owner: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AddedOwner {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AddedOwner> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AddedOwner) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ApproveHash(bytes32,address)` and selector `0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c`.
+    ```solidity
+    event ApproveHash(bytes32 indexed approvedHash, address indexed owner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ApproveHash {
+        #[allow(missing_docs)]
+        pub approvedHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ApproveHash {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ApproveHash(bytes32,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    242u8, 160u8, 235u8, 21u8, 100u8, 114u8, 209u8, 68u8, 2u8, 85u8, 176u8, 215u8,
+                    193u8, 225u8, 156u8, 192u8, 113u8, 21u8, 209u8, 5u8, 31u8, 230u8, 5u8, 176u8,
+                    220u8, 230u8, 154u8, 207u8, 236u8, 136u8, 77u8, 156u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    approvedHash: topics.1,
+                    owner: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.approvedHash.clone(),
+                    self.owner.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.approvedHash);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ApproveHash {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ApproveHash> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ApproveHash) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ChangedFallbackHandler(address)` and selector `0x5ac6c46c93c8d0e53714ba3b53db3e7c046da994313d7ed0d192028bc7c228b0`.
+    ```solidity
+    event ChangedFallbackHandler(address handler);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ChangedFallbackHandler {
+        #[allow(missing_docs)]
+        pub handler: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ChangedFallbackHandler {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ChangedFallbackHandler(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    90u8, 198u8, 196u8, 108u8, 147u8, 200u8, 208u8, 229u8, 55u8, 20u8, 186u8, 59u8,
+                    83u8, 219u8, 62u8, 124u8, 4u8, 109u8, 169u8, 148u8, 49u8, 61u8, 126u8, 208u8,
+                    209u8, 146u8, 2u8, 139u8, 199u8, 194u8, 40u8, 176u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { handler: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.handler,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ChangedFallbackHandler {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ChangedFallbackHandler> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ChangedFallbackHandler) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ChangedGuard(address)` and selector `0x1151116914515bc0891ff9047a6cb32cf902546f83066499bcf8ba33d2353fa2`.
+    ```solidity
+    event ChangedGuard(address guard);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ChangedGuard {
+        #[allow(missing_docs)]
+        pub guard: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ChangedGuard {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ChangedGuard(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    17u8, 81u8, 17u8, 105u8, 20u8, 81u8, 91u8, 192u8, 137u8, 31u8, 249u8, 4u8,
+                    122u8, 108u8, 179u8, 44u8, 249u8, 2u8, 84u8, 111u8, 131u8, 6u8, 100u8, 153u8,
+                    188u8, 248u8, 186u8, 51u8, 210u8, 53u8, 63u8, 162u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { guard: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.guard,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ChangedGuard {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ChangedGuard> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ChangedGuard) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ChangedThreshold(uint256)` and selector `0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93`.
+    ```solidity
+    event ChangedThreshold(uint256 threshold);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ChangedThreshold {
+        #[allow(missing_docs)]
+        pub threshold: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ChangedThreshold {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ChangedThreshold(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    97u8, 15u8, 127u8, 242u8, 179u8, 4u8, 174u8, 137u8, 3u8, 195u8, 222u8, 116u8,
+                    198u8, 12u8, 106u8, 177u8, 247u8, 214u8, 34u8, 107u8, 63u8, 82u8, 197u8, 22u8,
+                    25u8, 5u8, 187u8, 90u8, 212u8, 3u8, 156u8, 147u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { threshold: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.threshold,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ChangedThreshold {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ChangedThreshold> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ChangedThreshold) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `DisabledModule(address)` and selector `0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276`.
+    ```solidity
+    event DisabledModule(address module);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct DisabledModule {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for DisabledModule {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "DisabledModule(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    170u8, 180u8, 250u8, 43u8, 70u8, 63u8, 88u8, 27u8, 43u8, 50u8, 203u8, 59u8,
+                    126u8, 59u8, 112u8, 75u8, 156u8, 227u8, 124u8, 194u8, 9u8, 181u8, 251u8, 77u8,
+                    119u8, 229u8, 147u8, 172u8, 228u8, 5u8, 66u8, 118u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { module: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for DisabledModule {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&DisabledModule> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &DisabledModule) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `EnabledModule(address)` and selector `0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440`.
+    ```solidity
+    event EnabledModule(address module);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct EnabledModule {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for EnabledModule {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "EnabledModule(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    236u8, 223u8, 58u8, 62u8, 255u8, 234u8, 87u8, 131u8, 163u8, 196u8, 194u8, 20u8,
+                    14u8, 103u8, 117u8, 119u8, 102u8, 100u8, 40u8, 212u8, 78u8, 217u8, 212u8,
+                    116u8, 160u8, 179u8, 164u8, 201u8, 148u8, 63u8, 132u8, 64u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { module: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for EnabledModule {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&EnabledModule> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &EnabledModule) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ExecutionFailure(bytes32,uint256)` and selector `0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23`.
+    ```solidity
+    event ExecutionFailure(bytes32 txHash, uint256 payment);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ExecutionFailure {
+        #[allow(missing_docs)]
+        pub txHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub payment: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ExecutionFailure {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionFailure(bytes32,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    35u8, 66u8, 139u8, 24u8, 172u8, 251u8, 62u8, 166u8, 75u8, 8u8, 220u8, 12u8,
+                    29u8, 41u8, 110u8, 169u8, 192u8, 151u8, 2u8, 192u8, 144u8, 131u8, 202u8, 82u8,
+                    114u8, 230u8, 77u8, 17u8, 91u8, 104u8, 125u8, 35u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    txHash: data.0,
+                    payment: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.txHash),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionFailure {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionFailure> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionFailure) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ExecutionFromModuleFailure(address)` and selector `0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375`.
+    ```solidity
+    event ExecutionFromModuleFailure(address indexed module);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ExecutionFromModuleFailure {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ExecutionFromModuleFailure {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionFromModuleFailure(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    172u8, 210u8, 200u8, 112u8, 40u8, 4u8, 18u8, 143u8, 219u8, 13u8, 178u8, 187u8,
+                    73u8, 246u8, 209u8, 39u8, 221u8, 1u8, 129u8, 193u8, 63u8, 212u8, 93u8, 191u8,
+                    225u8, 109u8, 224u8, 147u8, 14u8, 43u8, 211u8, 117u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { module: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.module.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.module,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionFromModuleFailure {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionFromModuleFailure> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionFromModuleFailure) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ExecutionFromModuleSuccess(address)` and selector `0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8`.
+    ```solidity
+    event ExecutionFromModuleSuccess(address indexed module);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ExecutionFromModuleSuccess {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ExecutionFromModuleSuccess {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionFromModuleSuccess(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    104u8, 149u8, 193u8, 54u8, 100u8, 170u8, 79u8, 103u8, 40u8, 139u8, 37u8, 215u8,
+                    162u8, 29u8, 122u8, 170u8, 52u8, 145u8, 110u8, 53u8, 95u8, 185u8, 182u8, 250u8,
+                    224u8, 161u8, 57u8, 169u8, 8u8, 91u8, 236u8, 184u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { module: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.module.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.module,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionFromModuleSuccess {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionFromModuleSuccess> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionFromModuleSuccess) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ExecutionSuccess(bytes32,uint256)` and selector `0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e`.
+    ```solidity
+    event ExecutionSuccess(bytes32 txHash, uint256 payment);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ExecutionSuccess {
+        #[allow(missing_docs)]
+        pub txHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub payment: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ExecutionSuccess {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionSuccess(bytes32,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    68u8, 46u8, 113u8, 95u8, 98u8, 99u8, 70u8, 232u8, 197u8, 67u8, 129u8, 0u8,
+                    45u8, 166u8, 20u8, 246u8, 43u8, 238u8, 141u8, 39u8, 56u8, 101u8, 53u8, 178u8,
+                    82u8, 30u8, 200u8, 84u8, 8u8, 152u8, 85u8, 110u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    txHash: data.0,
+                    payment: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.txHash),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionSuccess {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionSuccess> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionSuccess) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RemovedOwner(address)` and selector `0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf`.
+    ```solidity
+    event RemovedOwner(address owner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RemovedOwner {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RemovedOwner {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RemovedOwner(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    248u8, 212u8, 159u8, 197u8, 41u8, 129u8, 46u8, 154u8, 124u8, 92u8, 80u8, 230u8,
+                    156u8, 32u8, 240u8, 220u8, 204u8, 13u8, 184u8, 250u8, 149u8, 201u8, 139u8,
+                    197u8, 140u8, 201u8, 164u8, 241u8, 193u8, 41u8, 158u8, 175u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { owner: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RemovedOwner {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RemovedOwner> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RemovedOwner) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SafeReceived(address,uint256)` and selector `0x3d0ce9bfc3ed7d6862dbb28b2dea94561fe714a1b4d019aa8af39730d1ad7c3d`.
+    ```solidity
+    event SafeReceived(address indexed sender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SafeReceived {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SafeReceived {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SafeReceived(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    61u8, 12u8, 233u8, 191u8, 195u8, 237u8, 125u8, 104u8, 98u8, 219u8, 178u8,
+                    139u8, 45u8, 234u8, 148u8, 86u8, 31u8, 231u8, 20u8, 161u8, 180u8, 208u8, 25u8,
+                    170u8, 138u8, 243u8, 151u8, 48u8, 209u8, 173u8, 124u8, 61u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.sender.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SafeReceived {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SafeReceived> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SafeReceived) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SafeSetup(address,address[],uint256,address,address)` and selector `0x141df868a6331af528e38c83b7aa03edc19be66e37ae67f9285bf4f8e3c6a1a8`.
+    ```solidity
+    event SafeSetup(address indexed initiator, address[] owners, uint256 threshold, address initializer, address fallbackHandler);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SafeSetup {
+        #[allow(missing_docs)]
+        pub initiator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub threshold: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub initializer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fallbackHandler: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SafeSetup {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SafeSetup(address,address[],uint256,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    20u8, 29u8, 248u8, 104u8, 166u8, 51u8, 26u8, 245u8, 40u8, 227u8, 140u8, 131u8,
+                    183u8, 170u8, 3u8, 237u8, 193u8, 155u8, 230u8, 110u8, 55u8, 174u8, 103u8,
+                    249u8, 40u8, 91u8, 244u8, 248u8, 227u8, 198u8, 161u8, 168u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    initiator: topics.1,
+                    owners: data.0,
+                    threshold: data.1,
+                    initializer: data.2,
+                    fallbackHandler: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.owners),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.threshold),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.initializer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.fallbackHandler,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.initiator.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.initiator,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SafeSetup {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SafeSetup> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SafeSetup) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SignMsg(bytes32)` and selector `0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4`.
+    ```solidity
+    event SignMsg(bytes32 indexed msgHash);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SignMsg {
+        #[allow(missing_docs)]
+        pub msgHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SignMsg {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SignMsg(bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    231u8, 244u8, 103u8, 80u8, 56u8, 244u8, 246u8, 3u8, 77u8, 252u8, 187u8, 178u8,
+                    76u8, 77u8, 192u8, 142u8, 78u8, 191u8, 16u8, 235u8, 157u8, 37u8, 125u8, 61u8,
+                    2u8, 192u8, 243u8, 141u8, 18u8, 42u8, 198u8, 228u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { msgHash: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.msgHash.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.msgHash);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SignMsg {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SignMsg> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SignMsg) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {}
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `VERSION()` and selector `0xffa1ad74`.
+    ```solidity
+    function VERSION() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct VERSIONCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`VERSION()`](VERSIONCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct VERSIONReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<VERSIONCall> for UnderlyingRustTuple<'_> {
+                fn from(value: VERSIONCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<VERSIONReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: VERSIONReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for VERSIONCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 161u8, 173u8, 116u8];
+            const SIGNATURE: &'static str = "VERSION()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: VERSIONReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: VERSIONReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addOwnerWithThreshold(address,uint256)` and selector `0x0d582f13`.
+    ```solidity
+    function addOwnerWithThreshold(address owner, uint256 _threshold) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addOwnerWithThresholdCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`addOwnerWithThreshold(address,uint256)`](addOwnerWithThresholdCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addOwnerWithThresholdReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addOwnerWithThresholdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addOwnerWithThresholdCall) -> Self {
+                    (value.owner, value._threshold)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addOwnerWithThresholdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        _threshold: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addOwnerWithThresholdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addOwnerWithThresholdReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addOwnerWithThresholdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl addOwnerWithThresholdReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addOwnerWithThresholdCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addOwnerWithThresholdReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 88u8, 47u8, 19u8];
+            const SIGNATURE: &'static str = "addOwnerWithThreshold(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._threshold,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addOwnerWithThresholdReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approveHash(bytes32)` and selector `0xd4d9bdcd`.
+    ```solidity
+    function approveHash(bytes32 hashToApprove) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveHashCall {
+        #[allow(missing_docs)]
+        pub hashToApprove: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`approveHash(bytes32)`](approveHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveHashReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveHashCall) -> Self {
+                    (value.hashToApprove,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        hashToApprove: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveHashReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl approveHashReturn {
+            fn _tokenize(&self) -> <approveHashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveHashCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = approveHashReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [212u8, 217u8, 189u8, 205u8];
+            const SIGNATURE: &'static str = "approveHash(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.hashToApprove),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                approveHashReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approvedHashes(address,bytes32)` and selector `0x7d832974`.
+    ```solidity
+    function approvedHashes(address, bytes32) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approvedHashesCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approvedHashes(address,bytes32)`](approvedHashesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approvedHashesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approvedHashesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approvedHashesCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approvedHashesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approvedHashesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approvedHashesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approvedHashesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approvedHashesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [125u8, 131u8, 41u8, 116u8];
+            const SIGNATURE: &'static str = "approvedHashes(address,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approvedHashesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approvedHashesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `changeThreshold(uint256)` and selector `0x694e80c3`.
+    ```solidity
+    function changeThreshold(uint256 _threshold) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct changeThresholdCall {
+        #[allow(missing_docs)]
+        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`changeThreshold(uint256)`](changeThresholdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct changeThresholdReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<changeThresholdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: changeThresholdCall) -> Self {
+                    (value._threshold,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for changeThresholdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _threshold: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<changeThresholdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: changeThresholdReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for changeThresholdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl changeThresholdReturn {
+            fn _tokenize(
+                &self,
+            ) -> <changeThresholdCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for changeThresholdCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = changeThresholdReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [105u8, 78u8, 128u8, 195u8];
+            const SIGNATURE: &'static str = "changeThreshold(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._threshold,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                changeThresholdReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `checkNSignatures(bytes32,bytes,bytes,uint256)` and selector `0x12fb68e0`.
+    ```solidity
+    function checkNSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures, uint256 requiredSignatures) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct checkNSignaturesCall {
+        #[allow(missing_docs)]
+        pub dataHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub requiredSignatures: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`checkNSignatures(bytes32,bytes,bytes,uint256)`](checkNSignaturesCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct checkNSignaturesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<checkNSignaturesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: checkNSignaturesCall) -> Self {
+                    (
+                        value.dataHash,
+                        value.data,
+                        value.signatures,
+                        value.requiredSignatures,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkNSignaturesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        dataHash: tuple.0,
+                        data: tuple.1,
+                        signatures: tuple.2,
+                        requiredSignatures: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<checkNSignaturesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: checkNSignaturesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkNSignaturesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl checkNSignaturesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <checkNSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for checkNSignaturesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = checkNSignaturesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [18u8, 251u8, 104u8, 224u8];
+            const SIGNATURE: &'static str = "checkNSignatures(bytes32,bytes,bytes,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.dataHash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signatures,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.requiredSignatures),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                checkNSignaturesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `checkSignatures(bytes32,bytes,bytes)` and selector `0x934f3a11`.
+    ```solidity
+    function checkSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct checkSignaturesCall {
+        #[allow(missing_docs)]
+        pub dataHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`checkSignatures(bytes32,bytes,bytes)`](checkSignaturesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct checkSignaturesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<checkSignaturesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: checkSignaturesCall) -> Self {
+                    (value.dataHash, value.data, value.signatures)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkSignaturesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        dataHash: tuple.0,
+                        data: tuple.1,
+                        signatures: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<checkSignaturesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: checkSignaturesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkSignaturesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl checkSignaturesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <checkSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for checkSignaturesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = checkSignaturesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [147u8, 79u8, 58u8, 17u8];
+            const SIGNATURE: &'static str = "checkSignatures(bytes32,bytes,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.dataHash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signatures,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                checkSignaturesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `disableModule(address,address)` and selector `0xe009cfde`.
+    ```solidity
+    function disableModule(address prevModule, address module) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableModuleCall {
+        #[allow(missing_docs)]
+        pub prevModule: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`disableModule(address,address)`](disableModuleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct disableModuleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableModuleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: disableModuleCall) -> Self {
+                    (value.prevModule, value.module)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableModuleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        prevModule: tuple.0,
+                        module: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<disableModuleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: disableModuleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableModuleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl disableModuleReturn {
+            fn _tokenize(
+                &self,
+            ) -> <disableModuleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for disableModuleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = disableModuleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [224u8, 9u8, 207u8, 222u8];
+            const SIGNATURE: &'static str = "disableModule(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.prevModule,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                disableModuleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `domainSeparator()` and selector `0xf698da25`.
+    ```solidity
+    function domainSeparator() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct domainSeparatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`domainSeparator()`](domainSeparatorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct domainSeparatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<domainSeparatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: domainSeparatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<domainSeparatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: domainSeparatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for domainSeparatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 152u8, 218u8, 37u8];
+            const SIGNATURE: &'static str = "domainSeparator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: domainSeparatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: domainSeparatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `enableModule(address)` and selector `0x610b5925`.
+    ```solidity
+    function enableModule(address module) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableModuleCall {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`enableModule(address)`](enableModuleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableModuleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableModuleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: enableModuleCall) -> Self {
+                    (value.module,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableModuleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { module: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableModuleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: enableModuleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableModuleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl enableModuleReturn {
+            fn _tokenize(&self) -> <enableModuleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for enableModuleCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = enableModuleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [97u8, 11u8, 89u8, 37u8];
+            const SIGNATURE: &'static str = "enableModule(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                enableModuleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `encodeTransactionData(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)` and selector `0xe86637db`.
+    ```solidity
+    function encodeTransactionData(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct encodeTransactionDataCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub refundReceiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`encodeTransactionData(address,uint256,bytes,uint8,uint256,uint256,
+    /// uint256,address,address,uint256)`](encodeTransactionDataCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct encodeTransactionDataReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<encodeTransactionDataCall> for UnderlyingRustTuple<'_> {
+                fn from(value: encodeTransactionDataCall) -> Self {
+                    (
+                        value.to,
+                        value.value,
+                        value.data,
+                        value.operation,
+                        value.safeTxGas,
+                        value.baseGas,
+                        value.gasPrice,
+                        value.gasToken,
+                        value.refundReceiver,
+                        value._nonce,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for encodeTransactionDataCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                        safeTxGas: tuple.4,
+                        baseGas: tuple.5,
+                        gasPrice: tuple.6,
+                        gasToken: tuple.7,
+                        refundReceiver: tuple.8,
+                        _nonce: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<encodeTransactionDataReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: encodeTransactionDataReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for encodeTransactionDataReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for encodeTransactionDataCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 102u8, 55u8, 219u8];
+            const SIGNATURE: &'static str = "encodeTransactionData(address,uint256,bytes,uint8,\
+                                             uint256,uint256,uint256,address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.safeTxGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasPrice,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.gasToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.refundReceiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: encodeTransactionDataReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: encodeTransactionDataReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)` and selector `0x6a761202`.
+    ```solidity
+    function execTransaction(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes memory signatures) external payable returns (bool success);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct execTransactionCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub refundReceiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,
+    /// address,address,bytes)`](execTransactionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct execTransactionReturn {
+        #[allow(missing_docs)]
+        pub success: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<execTransactionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionCall) -> Self {
+                    (
+                        value.to,
+                        value.value,
+                        value.data,
+                        value.operation,
+                        value.safeTxGas,
+                        value.baseGas,
+                        value.gasPrice,
+                        value.gasToken,
+                        value.refundReceiver,
+                        value.signatures,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                        safeTxGas: tuple.4,
+                        baseGas: tuple.5,
+                        gasPrice: tuple.6,
+                        gasToken: tuple.7,
+                        refundReceiver: tuple.8,
+                        signatures: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<execTransactionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionReturn) -> Self {
+                    (value.success,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { success: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for execTransactionCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [106u8, 118u8, 18u8, 2u8];
+            const SIGNATURE: &'static str = "execTransaction(address,uint256,bytes,uint8,uint256,\
+                                             uint256,uint256,address,address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.safeTxGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasPrice,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.gasToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.refundReceiver,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signatures,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: execTransactionReturn = r.into();
+                        r.success
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: execTransactionReturn = r.into();
+                    r.success
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `execTransactionFromModule(address,uint256,bytes,uint8)` and selector `0x468721a7`.
+    ```solidity
+    function execTransactionFromModule(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct execTransactionFromModuleCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`execTransactionFromModule(address,uint256,bytes,
+    /// uint8)`](execTransactionFromModuleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct execTransactionFromModuleReturn {
+        #[allow(missing_docs)]
+        pub success: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<execTransactionFromModuleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionFromModuleCall) -> Self {
+                    (value.to, value.value, value.data, value.operation)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<execTransactionFromModuleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionFromModuleReturn) -> Self {
+                    (value.success,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { success: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for execTransactionFromModuleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [70u8, 135u8, 33u8, 167u8];
+            const SIGNATURE: &'static str =
+                "execTransactionFromModule(address,uint256,bytes,uint8)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: execTransactionFromModuleReturn = r.into();
+                        r.success
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: execTransactionFromModuleReturn = r.into();
+                    r.success
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `execTransactionFromModuleReturnData(address,uint256,bytes,uint8)` and selector `0x5229073f`.
+    ```solidity
+    function execTransactionFromModuleReturnData(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success, bytes memory returnData);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct execTransactionFromModuleReturnDataCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`execTransactionFromModuleReturnData(address,uint256,bytes,
+    /// uint8)`](execTransactionFromModuleReturnDataCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct execTransactionFromModuleReturnDataReturn {
+        #[allow(missing_docs)]
+        pub success: bool,
+        #[allow(missing_docs)]
+        pub returnData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<execTransactionFromModuleReturnDataCall> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionFromModuleReturnDataCall) -> Self {
+                    (value.to, value.value, value.data, value.operation)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleReturnDataCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool, alloy_sol_types::private::Bytes);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<execTransactionFromModuleReturnDataReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionFromModuleReturnDataReturn) -> Self {
+                    (value.success, value.returnData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleReturnDataReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        success: tuple.0,
+                        returnData: tuple.1,
+                    }
+                }
+            }
+        }
+        impl execTransactionFromModuleReturnDataReturn {
+            fn _tokenize(
+                &self,
+            ) -> <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.success,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.returnData,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for execTransactionFromModuleReturnDataCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+            );
+            type Return = execTransactionFromModuleReturnDataReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [82u8, 41u8, 7u8, 63u8];
+            const SIGNATURE: &'static str =
+                "execTransactionFromModuleReturnData(address,uint256,bytes,uint8)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                execTransactionFromModuleReturnDataReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getChainId()` and selector `0x3408e470`.
+    ```solidity
+    function getChainId() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getChainIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getChainId()`](getChainIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getChainIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getChainIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getChainIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getChainIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getChainIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getChainIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getChainIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getChainIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [52u8, 8u8, 228u8, 112u8];
+            const SIGNATURE: &'static str = "getChainId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getChainIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getChainIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getModulesPaginated(address,uint256)` and selector `0xcc2f8452`.
+    ```solidity
+    function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getModulesPaginatedCall {
+        #[allow(missing_docs)]
+        pub start: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pageSize: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getModulesPaginated(address,uint256)`](getModulesPaginatedCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getModulesPaginatedReturn {
+        #[allow(missing_docs)]
+        pub array: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub next: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getModulesPaginatedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getModulesPaginatedCall) -> Self {
+                    (value.start, value.pageSize)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesPaginatedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        start: tuple.0,
+                        pageSize: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getModulesPaginatedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getModulesPaginatedReturn) -> Self {
+                    (value.array, value.next)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesPaginatedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        array: tuple.0,
+                        next: tuple.1,
+                    }
+                }
+            }
+        }
+        impl getModulesPaginatedReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getModulesPaginatedCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.array),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.next,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getModulesPaginatedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = getModulesPaginatedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [204u8, 47u8, 132u8, 82u8];
+            const SIGNATURE: &'static str = "getModulesPaginated(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.start,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pageSize,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getModulesPaginatedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOwners()` and selector `0xa0e67e2b`.
+    ```solidity
+    function getOwners() external view returns (address[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnersCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOwners()`](getOwnersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOwnersReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnersCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOwnersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOwnersReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOwnersCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [160u8, 230u8, 126u8, 43u8];
+            const SIGNATURE: &'static str = "getOwners()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOwnersReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOwnersReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
+    ```solidity
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtCall {
+        #[allow(missing_docs)]
+        pub offset: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub length: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtCall) -> Self {
+                    (value.offset, value.length)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        offset: tuple.0,
+                        length: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getStorageAtCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
+            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.offset,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.length,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getStorageAtReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getStorageAtReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getThreshold()` and selector `0xe75235b8`.
+    ```solidity
+    function getThreshold() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getThresholdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getThreshold()`](getThresholdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getThresholdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getThresholdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getThresholdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getThresholdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getThresholdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getThresholdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getThresholdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getThresholdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [231u8, 82u8, 53u8, 184u8];
+            const SIGNATURE: &'static str = "getThreshold()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getThresholdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getThresholdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)` and selector `0xd8d11f78`.
+    ```solidity
+    function getTransactionHash(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTransactionHashCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub refundReceiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,
+    /// uint256,address,address,uint256)`](getTransactionHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTransactionHashReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTransactionHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTransactionHashCall) -> Self {
+                    (
+                        value.to,
+                        value.value,
+                        value.data,
+                        value.operation,
+                        value.safeTxGas,
+                        value.baseGas,
+                        value.gasPrice,
+                        value.gasToken,
+                        value.refundReceiver,
+                        value._nonce,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransactionHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                        safeTxGas: tuple.4,
+                        baseGas: tuple.5,
+                        gasPrice: tuple.6,
+                        gasToken: tuple.7,
+                        refundReceiver: tuple.8,
+                        _nonce: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTransactionHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTransactionHashReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransactionHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTransactionHashCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [216u8, 209u8, 31u8, 120u8];
+            const SIGNATURE: &'static str = "getTransactionHash(address,uint256,bytes,uint8,\
+                                             uint256,uint256,uint256,address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.safeTxGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasPrice,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.gasToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.refundReceiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getTransactionHashReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getTransactionHashReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isModuleEnabled(address)` and selector `0x2d9ad53d`.
+    ```solidity
+    function isModuleEnabled(address module) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isModuleEnabledCall {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isModuleEnabled(address)`](isModuleEnabledCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isModuleEnabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isModuleEnabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isModuleEnabledCall) -> Self {
+                    (value.module,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isModuleEnabledCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { module: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isModuleEnabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isModuleEnabledReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isModuleEnabledReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isModuleEnabledCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [45u8, 154u8, 213u8, 61u8];
+            const SIGNATURE: &'static str = "isModuleEnabled(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isModuleEnabledReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isModuleEnabledReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isOwner(address)` and selector `0x2f54bf6e`.
+    ```solidity
+    function isOwner(address owner) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isOwnerCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isOwner(address)`](isOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isOwnerReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isOwnerCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isOwnerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isOwnerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 84u8, 191u8, 110u8];
+            const SIGNATURE: &'static str = "isOwner(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isOwnerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isOwnerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonce()` and selector `0xaffed0e0`.
+    ```solidity
+    function nonce() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nonceCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`nonce()`](nonceCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nonceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nonceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nonceCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nonceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nonceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nonceCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 254u8, 208u8, 224u8];
+            const SIGNATURE: &'static str = "nonce()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nonceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nonceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeOwner(address,address,uint256)` and selector `0xf8dc5dd9`.
+    ```solidity
+    function removeOwner(address prevOwner, address owner, uint256 _threshold) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeOwnerCall {
+        #[allow(missing_docs)]
+        pub prevOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`removeOwner(address,address,uint256)`](removeOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeOwnerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeOwnerCall) -> Self {
+                    (value.prevOwner, value.owner, value._threshold)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        prevOwner: tuple.0,
+                        owner: tuple.1,
+                        _threshold: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeOwnerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl removeOwnerReturn {
+            fn _tokenize(&self) -> <removeOwnerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeOwnerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeOwnerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 220u8, 93u8, 217u8];
+            const SIGNATURE: &'static str = "removeOwner(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.prevOwner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._threshold,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeOwnerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `requiredTxGas(address,uint256,bytes,uint8)` and selector `0xc4ca3a9c`.
+    ```solidity
+    function requiredTxGas(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct requiredTxGasCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`requiredTxGas(address,uint256,bytes,uint8)`](requiredTxGasCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct requiredTxGasReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<requiredTxGasCall> for UnderlyingRustTuple<'_> {
+                fn from(value: requiredTxGasCall) -> Self {
+                    (value.to, value.value, value.data, value.operation)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requiredTxGasCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<requiredTxGasReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: requiredTxGasReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requiredTxGasReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for requiredTxGasCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 202u8, 58u8, 156u8];
+            const SIGNATURE: &'static str = "requiredTxGas(address,uint256,bytes,uint8)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: requiredTxGasReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: requiredTxGasReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setFallbackHandler(address)` and selector `0xf08a0323`.
+    ```solidity
+    function setFallbackHandler(address handler) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFallbackHandlerCall {
+        #[allow(missing_docs)]
+        pub handler: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setFallbackHandler(address)`](setFallbackHandlerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFallbackHandlerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFallbackHandlerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setFallbackHandlerCall) -> Self {
+                    (value.handler,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFallbackHandlerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { handler: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFallbackHandlerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setFallbackHandlerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFallbackHandlerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setFallbackHandlerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setFallbackHandlerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setFallbackHandlerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setFallbackHandlerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [240u8, 138u8, 3u8, 35u8];
+            const SIGNATURE: &'static str = "setFallbackHandler(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.handler,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setFallbackHandlerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setGuard(address)` and selector `0xe19a9dd9`.
+    ```solidity
+    function setGuard(address guard) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setGuardCall {
+        #[allow(missing_docs)]
+        pub guard: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setGuard(address)`](setGuardCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setGuardReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setGuardCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setGuardCall) -> Self {
+                    (value.guard,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setGuardCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { guard: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setGuardReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setGuardReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setGuardReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setGuardReturn {
+            fn _tokenize(&self) -> <setGuardCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setGuardCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setGuardReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [225u8, 154u8, 157u8, 217u8];
+            const SIGNATURE: &'static str = "setGuard(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.guard,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setGuardReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setup(address[],uint256,address,bytes,address,address,uint256,address)` and selector `0xb63e800d`.
+    ```solidity
+    function setup(address[] memory _owners, uint256 _threshold, address to, bytes memory data, address fallbackHandler, address paymentToken, uint256 payment, address paymentReceiver) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setupCall {
+        #[allow(missing_docs)]
+        pub _owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub fallbackHandler: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub paymentToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub payment: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub paymentReceiver: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setup(address[],uint256,address,bytes,address,address,uint256,
+    /// address)`](setupCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setupReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setupCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setupCall) -> Self {
+                    (
+                        value._owners,
+                        value._threshold,
+                        value.to,
+                        value.data,
+                        value.fallbackHandler,
+                        value.paymentToken,
+                        value.payment,
+                        value.paymentReceiver,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setupCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _owners: tuple.0,
+                        _threshold: tuple.1,
+                        to: tuple.2,
+                        data: tuple.3,
+                        fallbackHandler: tuple.4,
+                        paymentToken: tuple.5,
+                        payment: tuple.6,
+                        paymentReceiver: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setupReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setupReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setupReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setupReturn {
+            fn _tokenize(&self) -> <setupCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setupCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = setupReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 62u8, 128u8, 13u8];
+            const SIGNATURE: &'static str =
+                "setup(address[],uint256,address,bytes,address,address,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self._owners),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self._threshold),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.fallbackHandler,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.paymentToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.paymentReceiver,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setupReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `signedMessages(bytes32)` and selector `0x5ae6bd37`.
+    ```solidity
+    function signedMessages(bytes32) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct signedMessagesCall(pub alloy_sol_types::private::FixedBytes<32>);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`signedMessages(bytes32)`](signedMessagesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct signedMessagesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<signedMessagesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: signedMessagesCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for signedMessagesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<signedMessagesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: signedMessagesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for signedMessagesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for signedMessagesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [90u8, 230u8, 189u8, 55u8];
+            const SIGNATURE: &'static str = "signedMessages(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.0),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: signedMessagesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: signedMessagesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateAndRevert(address,bytes)` and selector `0xb4faba09`.
+    ```solidity
+    function simulateAndRevert(address targetContract, bytes memory calldataPayload) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateAndRevertCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`simulateAndRevert(address,bytes)`](simulateAndRevertCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateAndRevertReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateAndRevertCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateAndRevertCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateAndRevertCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateAndRevertReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateAndRevertReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateAndRevertReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl simulateAndRevertReturn {
+            fn _tokenize(
+                &self,
+            ) -> <simulateAndRevertCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateAndRevertCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = simulateAndRevertReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [180u8, 250u8, 186u8, 9u8];
+            const SIGNATURE: &'static str = "simulateAndRevert(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                simulateAndRevertReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapOwner(address,address,address)` and selector `0xe318b52b`.
+    ```solidity
+    function swapOwner(address prevOwner, address oldOwner, address newOwner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapOwnerCall {
+        #[allow(missing_docs)]
+        pub prevOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub oldOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapOwner(address,address,address)`](swapOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapOwnerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapOwnerCall) -> Self {
+                    (value.prevOwner, value.oldOwner, value.newOwner)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        prevOwner: tuple.0,
+                        oldOwner: tuple.1,
+                        newOwner: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapOwnerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapOwnerReturn {
+            fn _tokenize(&self) -> <swapOwnerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapOwnerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = swapOwnerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [227u8, 24u8, 181u8, 43u8];
+            const SIGNATURE: &'static str = "swapOwner(address,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.prevOwner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.oldOwner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newOwner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapOwnerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`GnosisSafe`](self) function calls.
+    #[derive(Clone)]
+    pub enum GnosisSafeCalls {
+        #[allow(missing_docs)]
+        VERSION(VERSIONCall),
+        #[allow(missing_docs)]
+        addOwnerWithThreshold(addOwnerWithThresholdCall),
+        #[allow(missing_docs)]
+        approveHash(approveHashCall),
+        #[allow(missing_docs)]
+        approvedHashes(approvedHashesCall),
+        #[allow(missing_docs)]
+        changeThreshold(changeThresholdCall),
+        #[allow(missing_docs)]
+        checkNSignatures(checkNSignaturesCall),
+        #[allow(missing_docs)]
+        checkSignatures(checkSignaturesCall),
+        #[allow(missing_docs)]
+        disableModule(disableModuleCall),
+        #[allow(missing_docs)]
+        domainSeparator(domainSeparatorCall),
+        #[allow(missing_docs)]
+        enableModule(enableModuleCall),
+        #[allow(missing_docs)]
+        encodeTransactionData(encodeTransactionDataCall),
+        #[allow(missing_docs)]
+        execTransaction(execTransactionCall),
+        #[allow(missing_docs)]
+        execTransactionFromModule(execTransactionFromModuleCall),
+        #[allow(missing_docs)]
+        execTransactionFromModuleReturnData(execTransactionFromModuleReturnDataCall),
+        #[allow(missing_docs)]
+        getChainId(getChainIdCall),
+        #[allow(missing_docs)]
+        getModulesPaginated(getModulesPaginatedCall),
+        #[allow(missing_docs)]
+        getOwners(getOwnersCall),
+        #[allow(missing_docs)]
+        getStorageAt(getStorageAtCall),
+        #[allow(missing_docs)]
+        getThreshold(getThresholdCall),
+        #[allow(missing_docs)]
+        getTransactionHash(getTransactionHashCall),
+        #[allow(missing_docs)]
+        isModuleEnabled(isModuleEnabledCall),
+        #[allow(missing_docs)]
+        isOwner(isOwnerCall),
+        #[allow(missing_docs)]
+        nonce(nonceCall),
+        #[allow(missing_docs)]
+        removeOwner(removeOwnerCall),
+        #[allow(missing_docs)]
+        requiredTxGas(requiredTxGasCall),
+        #[allow(missing_docs)]
+        setFallbackHandler(setFallbackHandlerCall),
+        #[allow(missing_docs)]
+        setGuard(setGuardCall),
+        #[allow(missing_docs)]
+        setup(setupCall),
+        #[allow(missing_docs)]
+        signedMessages(signedMessagesCall),
+        #[allow(missing_docs)]
+        simulateAndRevert(simulateAndRevertCall),
+        #[allow(missing_docs)]
+        swapOwner(swapOwnerCall),
+    }
+    impl GnosisSafeCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [13u8, 88u8, 47u8, 19u8],
+            [18u8, 251u8, 104u8, 224u8],
+            [45u8, 154u8, 213u8, 61u8],
+            [47u8, 84u8, 191u8, 110u8],
+            [52u8, 8u8, 228u8, 112u8],
+            [70u8, 135u8, 33u8, 167u8],
+            [82u8, 41u8, 7u8, 63u8],
+            [86u8, 36u8, 178u8, 91u8],
+            [90u8, 230u8, 189u8, 55u8],
+            [97u8, 11u8, 89u8, 37u8],
+            [105u8, 78u8, 128u8, 195u8],
+            [106u8, 118u8, 18u8, 2u8],
+            [125u8, 131u8, 41u8, 116u8],
+            [147u8, 79u8, 58u8, 17u8],
+            [160u8, 230u8, 126u8, 43u8],
+            [175u8, 254u8, 208u8, 224u8],
+            [180u8, 250u8, 186u8, 9u8],
+            [182u8, 62u8, 128u8, 13u8],
+            [196u8, 202u8, 58u8, 156u8],
+            [204u8, 47u8, 132u8, 82u8],
+            [212u8, 217u8, 189u8, 205u8],
+            [216u8, 209u8, 31u8, 120u8],
+            [224u8, 9u8, 207u8, 222u8],
+            [225u8, 154u8, 157u8, 217u8],
+            [227u8, 24u8, 181u8, 43u8],
+            [231u8, 82u8, 53u8, 184u8],
+            [232u8, 102u8, 55u8, 219u8],
+            [240u8, 138u8, 3u8, 35u8],
+            [246u8, 152u8, 218u8, 37u8],
+            [248u8, 220u8, 93u8, 217u8],
+            [255u8, 161u8, 173u8, 116u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <checkNSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isModuleEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getChainIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <execTransactionFromModuleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <signedMessagesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <enableModuleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <changeThresholdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <execTransactionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approvedHashesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <checkSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOwnersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <nonceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateAndRevertCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setupCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <requiredTxGasCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getModulesPaginatedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTransactionHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <disableModuleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setGuardCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getThresholdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <encodeTransactionDataCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setFallbackHandlerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <domainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(addOwnerWithThreshold),
+            ::core::stringify!(checkNSignatures),
+            ::core::stringify!(isModuleEnabled),
+            ::core::stringify!(isOwner),
+            ::core::stringify!(getChainId),
+            ::core::stringify!(execTransactionFromModule),
+            ::core::stringify!(execTransactionFromModuleReturnData),
+            ::core::stringify!(getStorageAt),
+            ::core::stringify!(signedMessages),
+            ::core::stringify!(enableModule),
+            ::core::stringify!(changeThreshold),
+            ::core::stringify!(execTransaction),
+            ::core::stringify!(approvedHashes),
+            ::core::stringify!(checkSignatures),
+            ::core::stringify!(getOwners),
+            ::core::stringify!(nonce),
+            ::core::stringify!(simulateAndRevert),
+            ::core::stringify!(setup),
+            ::core::stringify!(requiredTxGas),
+            ::core::stringify!(getModulesPaginated),
+            ::core::stringify!(approveHash),
+            ::core::stringify!(getTransactionHash),
+            ::core::stringify!(disableModule),
+            ::core::stringify!(setGuard),
+            ::core::stringify!(swapOwner),
+            ::core::stringify!(getThreshold),
+            ::core::stringify!(encodeTransactionData),
+            ::core::stringify!(setFallbackHandler),
+            ::core::stringify!(domainSeparator),
+            ::core::stringify!(removeOwner),
+            ::core::stringify!(VERSION),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for GnosisSafeCalls {
+        const COUNT: usize = 31usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "GnosisSafeCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::VERSION(_) => <VERSIONCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addOwnerWithThreshold(_) => {
+                    <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::approveHash(_) => <approveHashCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approvedHashes(_) => {
+                    <approvedHashesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::changeThreshold(_) => {
+                    <changeThresholdCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::checkNSignatures(_) => {
+                    <checkNSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::checkSignatures(_) => {
+                    <checkSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::disableModule(_) => <disableModuleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::domainSeparator(_) => {
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::enableModule(_) => <enableModuleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::encodeTransactionData(_) => {
+                    <encodeTransactionDataCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::execTransaction(_) => {
+                    <execTransactionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::execTransactionFromModule(_) => {
+                    <execTransactionFromModuleCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::execTransactionFromModuleReturnData(_) => {
+                    <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getChainId(_) => <getChainIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getModulesPaginated(_) => {
+                    <getModulesPaginatedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getOwners(_) => <getOwnersCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getThreshold(_) => <getThresholdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getTransactionHash(_) => {
+                    <getTransactionHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isModuleEnabled(_) => {
+                    <isModuleEnabledCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isOwner(_) => <isOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonce(_) => <nonceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeOwner(_) => <removeOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::requiredTxGas(_) => <requiredTxGasCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setFallbackHandler(_) => {
+                    <setFallbackHandlerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setGuard(_) => <setGuardCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setup(_) => <setupCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::signedMessages(_) => {
+                    <signedMessagesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::simulateAndRevert(_) => {
+                    <simulateAndRevertCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapOwner(_) => <swapOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<GnosisSafeCalls>] = &[
+                {
+                    fn addOwnerWithThreshold(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::addOwnerWithThreshold)
+                    }
+                    addOwnerWithThreshold
+                },
+                {
+                    fn checkNSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::checkNSignatures)
+                    }
+                    checkNSignatures
+                },
+                {
+                    fn isModuleEnabled(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::isModuleEnabled)
+                    }
+                    isModuleEnabled
+                },
+                {
+                    fn isOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <isOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::isOwner)
+                    }
+                    isOwner
+                },
+                {
+                    fn getChainId(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getChainIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::getChainId)
+                    }
+                    getChainId
+                },
+                {
+                    fn execTransactionFromModule(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::execTransactionFromModule)
+                    }
+                    execTransactionFromModule
+                },
+                {
+                    fn execTransactionFromModuleReturnData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::execTransactionFromModuleReturnData)
+                    }
+                    execTransactionFromModuleReturnData
+                },
+                {
+                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn signedMessages(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <signedMessagesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::signedMessages)
+                    }
+                    signedMessages
+                },
+                {
+                    fn enableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <enableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::enableModule)
+                    }
+                    enableModule
+                },
+                {
+                    fn changeThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <changeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::changeThreshold)
+                    }
+                    changeThreshold
+                },
+                {
+                    fn execTransaction(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <execTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::execTransaction)
+                    }
+                    execTransaction
+                },
+                {
+                    fn approvedHashes(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <approvedHashesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::approvedHashes)
+                    }
+                    approvedHashes
+                },
+                {
+                    fn checkSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <checkSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::checkSignatures)
+                    }
+                    checkSignatures
+                },
+                {
+                    fn getOwners(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getOwnersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::getOwners)
+                    }
+                    getOwners
+                },
+                {
+                    fn nonce(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <nonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::nonce)
+                    }
+                    nonce
+                },
+                {
+                    fn simulateAndRevert(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::simulateAndRevert)
+                    }
+                    simulateAndRevert
+                },
+                {
+                    fn setup(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <setupCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::setup)
+                    }
+                    setup
+                },
+                {
+                    fn requiredTxGas(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <requiredTxGasCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::requiredTxGas)
+                    }
+                    requiredTxGas
+                },
+                {
+                    fn getModulesPaginated(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::getModulesPaginated)
+                    }
+                    getModulesPaginated
+                },
+                {
+                    fn approveHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <approveHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::approveHash)
+                    }
+                    approveHash
+                },
+                {
+                    fn getTransactionHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::getTransactionHash)
+                    }
+                    getTransactionHash
+                },
+                {
+                    fn disableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <disableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::disableModule)
+                    }
+                    disableModule
+                },
+                {
+                    fn setGuard(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <setGuardCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::setGuard)
+                    }
+                    setGuard
+                },
+                {
+                    fn swapOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <swapOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::swapOwner)
+                    }
+                    swapOwner
+                },
+                {
+                    fn getThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::getThreshold)
+                    }
+                    getThreshold
+                },
+                {
+                    fn encodeTransactionData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::encodeTransactionData)
+                    }
+                    encodeTransactionData
+                },
+                {
+                    fn setFallbackHandler(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::setFallbackHandler)
+                    }
+                    setFallbackHandler
+                },
+                {
+                    fn domainSeparator(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::domainSeparator)
+                    }
+                    domainSeparator
+                },
+                {
+                    fn removeOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <removeOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::removeOwner)
+                    }
+                    removeOwner
+                },
+                {
+                    fn VERSION(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCalls::VERSION)
+                    }
+                    VERSION
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<GnosisSafeCalls>] = &[
+                {
+                    fn addOwnerWithThreshold(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::addOwnerWithThreshold)
+                    }
+                    addOwnerWithThreshold
+                },
+                {
+                    fn checkNSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::checkNSignatures)
+                    }
+                    checkNSignatures
+                },
+                {
+                    fn isModuleEnabled(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::isModuleEnabled)
+                    }
+                    isModuleEnabled
+                },
+                {
+                    fn isOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <isOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::isOwner)
+                    }
+                    isOwner
+                },
+                {
+                    fn getChainId(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getChainIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::getChainId)
+                    }
+                    getChainId
+                },
+                {
+                    fn execTransactionFromModule(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::execTransactionFromModule)
+                    }
+                    execTransactionFromModule
+                },
+                {
+                    fn execTransactionFromModuleReturnData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::execTransactionFromModuleReturnData)
+                    }
+                    execTransactionFromModuleReturnData
+                },
+                {
+                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn signedMessages(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <signedMessagesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::signedMessages)
+                    }
+                    signedMessages
+                },
+                {
+                    fn enableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <enableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::enableModule)
+                    }
+                    enableModule
+                },
+                {
+                    fn changeThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <changeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::changeThreshold)
+                    }
+                    changeThreshold
+                },
+                {
+                    fn execTransaction(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <execTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::execTransaction)
+                    }
+                    execTransaction
+                },
+                {
+                    fn approvedHashes(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <approvedHashesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::approvedHashes)
+                    }
+                    approvedHashes
+                },
+                {
+                    fn checkSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <checkSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::checkSignatures)
+                    }
+                    checkSignatures
+                },
+                {
+                    fn getOwners(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getOwnersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::getOwners)
+                    }
+                    getOwners
+                },
+                {
+                    fn nonce(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <nonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::nonce)
+                    }
+                    nonce
+                },
+                {
+                    fn simulateAndRevert(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::simulateAndRevert)
+                    }
+                    simulateAndRevert
+                },
+                {
+                    fn setup(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <setupCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::setup)
+                    }
+                    setup
+                },
+                {
+                    fn requiredTxGas(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <requiredTxGasCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::requiredTxGas)
+                    }
+                    requiredTxGas
+                },
+                {
+                    fn getModulesPaginated(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::getModulesPaginated)
+                    }
+                    getModulesPaginated
+                },
+                {
+                    fn approveHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <approveHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::approveHash)
+                    }
+                    approveHash
+                },
+                {
+                    fn getTransactionHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::getTransactionHash)
+                    }
+                    getTransactionHash
+                },
+                {
+                    fn disableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <disableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::disableModule)
+                    }
+                    disableModule
+                },
+                {
+                    fn setGuard(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <setGuardCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::setGuard)
+                    }
+                    setGuard
+                },
+                {
+                    fn swapOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <swapOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::swapOwner)
+                    }
+                    swapOwner
+                },
+                {
+                    fn getThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <getThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::getThreshold)
+                    }
+                    getThreshold
+                },
+                {
+                    fn encodeTransactionData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::encodeTransactionData)
+                    }
+                    encodeTransactionData
+                },
+                {
+                    fn setFallbackHandler(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeCalls::setFallbackHandler)
+                    }
+                    setFallbackHandler
+                },
+                {
+                    fn domainSeparator(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCalls::domainSeparator)
+                    }
+                    domainSeparator
+                },
+                {
+                    fn removeOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <removeOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::removeOwner)
+                    }
+                    removeOwner
+                },
+                {
+                    fn VERSION(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
+                        <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCalls::VERSION)
+                    }
+                    VERSION
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::VERSION(inner) => {
+                    <VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addOwnerWithThreshold(inner) => {
+                    <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::approveHash(inner) => {
+                    <approveHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::approvedHashes(inner) => {
+                    <approvedHashesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::changeThreshold(inner) => {
+                    <changeThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::checkNSignatures(inner) => {
+                    <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::checkSignatures(inner) => {
+                    <checkSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::disableModule(inner) => {
+                    <disableModuleCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::domainSeparator(inner) => {
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::enableModule(inner) => {
+                    <enableModuleCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::encodeTransactionData(inner) => {
+                    <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::execTransaction(inner) => {
+                    <execTransactionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::execTransactionFromModule(inner) => {
+                    <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::execTransactionFromModuleReturnData(inner) => {
+                    <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getChainId(inner) => {
+                    <getChainIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getModulesPaginated(inner) => {
+                    <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getOwners(inner) => {
+                    <getOwnersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getThreshold(inner) => {
+                    <getThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTransactionHash(inner) => {
+                    <getTransactionHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isModuleEnabled(inner) => {
+                    <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isOwner(inner) => {
+                    <isOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonce(inner) => {
+                    <nonceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeOwner(inner) => {
+                    <removeOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::requiredTxGas(inner) => {
+                    <requiredTxGasCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setFallbackHandler(inner) => {
+                    <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setGuard(inner) => {
+                    <setGuardCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setup(inner) => {
+                    <setupCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::signedMessages(inner) => {
+                    <signedMessagesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::simulateAndRevert(inner) => {
+                    <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapOwner(inner) => {
+                    <swapOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::VERSION(inner) => {
+                    <VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addOwnerWithThreshold(inner) => {
+                    <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::approveHash(inner) => {
+                    <approveHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::approvedHashes(inner) => {
+                    <approvedHashesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::changeThreshold(inner) => {
+                    <changeThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::checkNSignatures(inner) => {
+                    <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::checkSignatures(inner) => {
+                    <checkSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::disableModule(inner) => {
+                    <disableModuleCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::domainSeparator(inner) => {
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::enableModule(inner) => {
+                    <enableModuleCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::encodeTransactionData(inner) => {
+                    <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::execTransaction(inner) => {
+                    <execTransactionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::execTransactionFromModule(inner) => {
+                    <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::execTransactionFromModuleReturnData(inner) => {
+                    <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getChainId(inner) => {
+                    <getChainIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getModulesPaginated(inner) => {
+                    <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getOwners(inner) => {
+                    <getOwnersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getThreshold(inner) => {
+                    <getThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getTransactionHash(inner) => {
+                    <getTransactionHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isModuleEnabled(inner) => {
+                    <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isOwner(inner) => {
+                    <isOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonce(inner) => {
+                    <nonceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeOwner(inner) => {
+                    <removeOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::requiredTxGas(inner) => {
+                    <requiredTxGasCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setFallbackHandler(inner) => {
+                    <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setGuard(inner) => {
+                    <setGuardCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setup(inner) => {
+                    <setupCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::signedMessages(inner) => {
+                    <signedMessagesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::simulateAndRevert(inner) => {
+                    <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapOwner(inner) => {
+                    <swapOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`GnosisSafe`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum GnosisSafeEvents {
+        #[allow(missing_docs)]
+        AddedOwner(AddedOwner),
+        #[allow(missing_docs)]
+        ApproveHash(ApproveHash),
+        #[allow(missing_docs)]
+        ChangedFallbackHandler(ChangedFallbackHandler),
+        #[allow(missing_docs)]
+        ChangedGuard(ChangedGuard),
+        #[allow(missing_docs)]
+        ChangedThreshold(ChangedThreshold),
+        #[allow(missing_docs)]
+        DisabledModule(DisabledModule),
+        #[allow(missing_docs)]
+        EnabledModule(EnabledModule),
+        #[allow(missing_docs)]
+        ExecutionFailure(ExecutionFailure),
+        #[allow(missing_docs)]
+        ExecutionFromModuleFailure(ExecutionFromModuleFailure),
+        #[allow(missing_docs)]
+        ExecutionFromModuleSuccess(ExecutionFromModuleSuccess),
+        #[allow(missing_docs)]
+        ExecutionSuccess(ExecutionSuccess),
+        #[allow(missing_docs)]
+        RemovedOwner(RemovedOwner),
+        #[allow(missing_docs)]
+        SafeReceived(SafeReceived),
+        #[allow(missing_docs)]
+        SafeSetup(SafeSetup),
+        #[allow(missing_docs)]
+        SignMsg(SignMsg),
+    }
+    impl GnosisSafeEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                17u8, 81u8, 17u8, 105u8, 20u8, 81u8, 91u8, 192u8, 137u8, 31u8, 249u8, 4u8, 122u8,
+                108u8, 179u8, 44u8, 249u8, 2u8, 84u8, 111u8, 131u8, 6u8, 100u8, 153u8, 188u8,
+                248u8, 186u8, 51u8, 210u8, 53u8, 63u8, 162u8,
+            ],
+            [
+                20u8, 29u8, 248u8, 104u8, 166u8, 51u8, 26u8, 245u8, 40u8, 227u8, 140u8, 131u8,
+                183u8, 170u8, 3u8, 237u8, 193u8, 155u8, 230u8, 110u8, 55u8, 174u8, 103u8, 249u8,
+                40u8, 91u8, 244u8, 248u8, 227u8, 198u8, 161u8, 168u8,
+            ],
+            [
+                35u8, 66u8, 139u8, 24u8, 172u8, 251u8, 62u8, 166u8, 75u8, 8u8, 220u8, 12u8, 29u8,
+                41u8, 110u8, 169u8, 192u8, 151u8, 2u8, 192u8, 144u8, 131u8, 202u8, 82u8, 114u8,
+                230u8, 77u8, 17u8, 91u8, 104u8, 125u8, 35u8,
+            ],
+            [
+                61u8, 12u8, 233u8, 191u8, 195u8, 237u8, 125u8, 104u8, 98u8, 219u8, 178u8, 139u8,
+                45u8, 234u8, 148u8, 86u8, 31u8, 231u8, 20u8, 161u8, 180u8, 208u8, 25u8, 170u8,
+                138u8, 243u8, 151u8, 48u8, 209u8, 173u8, 124u8, 61u8,
+            ],
+            [
+                68u8, 46u8, 113u8, 95u8, 98u8, 99u8, 70u8, 232u8, 197u8, 67u8, 129u8, 0u8, 45u8,
+                166u8, 20u8, 246u8, 43u8, 238u8, 141u8, 39u8, 56u8, 101u8, 53u8, 178u8, 82u8, 30u8,
+                200u8, 84u8, 8u8, 152u8, 85u8, 110u8,
+            ],
+            [
+                90u8, 198u8, 196u8, 108u8, 147u8, 200u8, 208u8, 229u8, 55u8, 20u8, 186u8, 59u8,
+                83u8, 219u8, 62u8, 124u8, 4u8, 109u8, 169u8, 148u8, 49u8, 61u8, 126u8, 208u8,
+                209u8, 146u8, 2u8, 139u8, 199u8, 194u8, 40u8, 176u8,
+            ],
+            [
+                97u8, 15u8, 127u8, 242u8, 179u8, 4u8, 174u8, 137u8, 3u8, 195u8, 222u8, 116u8,
+                198u8, 12u8, 106u8, 177u8, 247u8, 214u8, 34u8, 107u8, 63u8, 82u8, 197u8, 22u8,
+                25u8, 5u8, 187u8, 90u8, 212u8, 3u8, 156u8, 147u8,
+            ],
+            [
+                104u8, 149u8, 193u8, 54u8, 100u8, 170u8, 79u8, 103u8, 40u8, 139u8, 37u8, 215u8,
+                162u8, 29u8, 122u8, 170u8, 52u8, 145u8, 110u8, 53u8, 95u8, 185u8, 182u8, 250u8,
+                224u8, 161u8, 57u8, 169u8, 8u8, 91u8, 236u8, 184u8,
+            ],
+            [
+                148u8, 101u8, 250u8, 12u8, 150u8, 44u8, 199u8, 105u8, 88u8, 230u8, 55u8, 58u8,
+                153u8, 51u8, 38u8, 64u8, 12u8, 28u8, 148u8, 248u8, 190u8, 47u8, 227u8, 169u8, 82u8,
+                173u8, 250u8, 127u8, 96u8, 178u8, 234u8, 38u8,
+            ],
+            [
+                170u8, 180u8, 250u8, 43u8, 70u8, 63u8, 88u8, 27u8, 43u8, 50u8, 203u8, 59u8, 126u8,
+                59u8, 112u8, 75u8, 156u8, 227u8, 124u8, 194u8, 9u8, 181u8, 251u8, 77u8, 119u8,
+                229u8, 147u8, 172u8, 228u8, 5u8, 66u8, 118u8,
+            ],
+            [
+                172u8, 210u8, 200u8, 112u8, 40u8, 4u8, 18u8, 143u8, 219u8, 13u8, 178u8, 187u8,
+                73u8, 246u8, 209u8, 39u8, 221u8, 1u8, 129u8, 193u8, 63u8, 212u8, 93u8, 191u8,
+                225u8, 109u8, 224u8, 147u8, 14u8, 43u8, 211u8, 117u8,
+            ],
+            [
+                231u8, 244u8, 103u8, 80u8, 56u8, 244u8, 246u8, 3u8, 77u8, 252u8, 187u8, 178u8,
+                76u8, 77u8, 192u8, 142u8, 78u8, 191u8, 16u8, 235u8, 157u8, 37u8, 125u8, 61u8, 2u8,
+                192u8, 243u8, 141u8, 18u8, 42u8, 198u8, 228u8,
+            ],
+            [
+                236u8, 223u8, 58u8, 62u8, 255u8, 234u8, 87u8, 131u8, 163u8, 196u8, 194u8, 20u8,
+                14u8, 103u8, 117u8, 119u8, 102u8, 100u8, 40u8, 212u8, 78u8, 217u8, 212u8, 116u8,
+                160u8, 179u8, 164u8, 201u8, 148u8, 63u8, 132u8, 64u8,
+            ],
+            [
+                242u8, 160u8, 235u8, 21u8, 100u8, 114u8, 209u8, 68u8, 2u8, 85u8, 176u8, 215u8,
+                193u8, 225u8, 156u8, 192u8, 113u8, 21u8, 209u8, 5u8, 31u8, 230u8, 5u8, 176u8,
+                220u8, 230u8, 154u8, 207u8, 236u8, 136u8, 77u8, 156u8,
+            ],
+            [
+                248u8, 212u8, 159u8, 197u8, 41u8, 129u8, 46u8, 154u8, 124u8, 92u8, 80u8, 230u8,
+                156u8, 32u8, 240u8, 220u8, 204u8, 13u8, 184u8, 250u8, 149u8, 201u8, 139u8, 197u8,
+                140u8, 201u8, 164u8, 241u8, 193u8, 41u8, 158u8, 175u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <ChangedGuard as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SafeSetup as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ExecutionFailure as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SafeReceived as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ExecutionSuccess as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ChangedFallbackHandler as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ChangedThreshold as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ExecutionFromModuleSuccess as alloy_sol_types::SolEvent>::SIGNATURE,
+            <AddedOwner as alloy_sol_types::SolEvent>::SIGNATURE,
+            <DisabledModule as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ExecutionFromModuleFailure as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SignMsg as alloy_sol_types::SolEvent>::SIGNATURE,
+            <EnabledModule as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ApproveHash as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RemovedOwner as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(ChangedGuard),
+            ::core::stringify!(SafeSetup),
+            ::core::stringify!(ExecutionFailure),
+            ::core::stringify!(SafeReceived),
+            ::core::stringify!(ExecutionSuccess),
+            ::core::stringify!(ChangedFallbackHandler),
+            ::core::stringify!(ChangedThreshold),
+            ::core::stringify!(ExecutionFromModuleSuccess),
+            ::core::stringify!(AddedOwner),
+            ::core::stringify!(DisabledModule),
+            ::core::stringify!(ExecutionFromModuleFailure),
+            ::core::stringify!(SignMsg),
+            ::core::stringify!(EnabledModule),
+            ::core::stringify!(ApproveHash),
+            ::core::stringify!(RemovedOwner),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for GnosisSafeEvents {
+        const COUNT: usize = 15usize;
+        const NAME: &'static str = "GnosisSafeEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<AddedOwner as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <AddedOwner as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::AddedOwner)
+                }
+                Some(<ApproveHash as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ApproveHash as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ApproveHash)
+                }
+                Some(<ChangedFallbackHandler as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ChangedFallbackHandler as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ChangedFallbackHandler)
+                }
+                Some(<ChangedGuard as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ChangedGuard as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ChangedGuard)
+                }
+                Some(<ChangedThreshold as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ChangedThreshold as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ChangedThreshold)
+                }
+                Some(<DisabledModule as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <DisabledModule as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::DisabledModule)
+                }
+                Some(<EnabledModule as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <EnabledModule as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::EnabledModule)
+                }
+                Some(<ExecutionFailure as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ExecutionFailure as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ExecutionFailure)
+                }
+                Some(<ExecutionFromModuleFailure as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ExecutionFromModuleFailure as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ExecutionFromModuleFailure)
+                }
+                Some(<ExecutionFromModuleSuccess as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ExecutionFromModuleSuccess as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ExecutionFromModuleSuccess)
+                }
+                Some(<ExecutionSuccess as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ExecutionSuccess as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ExecutionSuccess)
+                }
+                Some(<RemovedOwner as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RemovedOwner as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::RemovedOwner)
+                }
+                Some(<SafeReceived as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SafeReceived as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SafeReceived)
+                }
+                Some(<SafeSetup as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SafeSetup as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SafeSetup)
+                }
+                Some(<SignMsg as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SignMsg as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SignMsg)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for GnosisSafeEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AddedOwner(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ApproveHash(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ChangedFallbackHandler(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ChangedGuard(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ChangedThreshold(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::DisabledModule(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::EnabledModule(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ExecutionFailure(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ExecutionFromModuleFailure(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ExecutionFromModuleSuccess(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ExecutionSuccess(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RemovedOwner(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SafeReceived(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SafeSetup(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::SignMsg(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::AddedOwner(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ApproveHash(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ChangedFallbackHandler(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ChangedGuard(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ChangedThreshold(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::DisabledModule(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::EnabledModule(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ExecutionFailure(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ExecutionFromModuleFailure(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ExecutionFromModuleSuccess(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ExecutionSuccess(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RemovedOwner(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SafeReceived(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SafeSetup(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SignMsg(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GnosisSafe`](self) contract instance.
+
+    See the [wrapper's documentation](`GnosisSafeInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GnosisSafeInstance<P, N> {
+        GnosisSafeInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<GnosisSafeInstance<P, N>>>
+    {
+        GnosisSafeInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GnosisSafeInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`GnosisSafe`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GnosisSafe`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GnosisSafeInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GnosisSafeInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GnosisSafeInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GnosisSafe`](self) contract instance.
+
+        See the [wrapper's documentation](`GnosisSafeInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<GnosisSafeInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GnosisSafeInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GnosisSafeInstance<P, N> {
+            GnosisSafeInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`VERSION`] function.
+        pub fn VERSION(&self) -> alloy_contract::SolCallBuilder<&P, VERSIONCall, N> {
+            self.call_builder(&VERSIONCall)
+        }
+
+        ///Creates a new call builder for the [`addOwnerWithThreshold`]
+        /// function.
+        pub fn addOwnerWithThreshold(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            _threshold: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addOwnerWithThresholdCall, N> {
+            self.call_builder(&addOwnerWithThresholdCall { owner, _threshold })
+        }
+
+        ///Creates a new call builder for the [`approveHash`] function.
+        pub fn approveHash(
+            &self,
+            hashToApprove: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, approveHashCall, N> {
+            self.call_builder(&approveHashCall { hashToApprove })
+        }
+
+        ///Creates a new call builder for the [`approvedHashes`] function.
+        pub fn approvedHashes(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, approvedHashesCall, N> {
+            self.call_builder(&approvedHashesCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`changeThreshold`] function.
+        pub fn changeThreshold(
+            &self,
+            _threshold: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, changeThresholdCall, N> {
+            self.call_builder(&changeThresholdCall { _threshold })
+        }
+
+        ///Creates a new call builder for the [`checkNSignatures`] function.
+        pub fn checkNSignatures(
+            &self,
+            dataHash: alloy_sol_types::private::FixedBytes<32>,
+            data: alloy_sol_types::private::Bytes,
+            signatures: alloy_sol_types::private::Bytes,
+            requiredSignatures: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, checkNSignaturesCall, N> {
+            self.call_builder(&checkNSignaturesCall {
+                dataHash,
+                data,
+                signatures,
+                requiredSignatures,
+            })
+        }
+
+        ///Creates a new call builder for the [`checkSignatures`] function.
+        pub fn checkSignatures(
+            &self,
+            dataHash: alloy_sol_types::private::FixedBytes<32>,
+            data: alloy_sol_types::private::Bytes,
+            signatures: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, checkSignaturesCall, N> {
+            self.call_builder(&checkSignaturesCall {
+                dataHash,
+                data,
+                signatures,
+            })
+        }
+
+        ///Creates a new call builder for the [`disableModule`] function.
+        pub fn disableModule(
+            &self,
+            prevModule: alloy_sol_types::private::Address,
+            module: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, disableModuleCall, N> {
+            self.call_builder(&disableModuleCall { prevModule, module })
+        }
+
+        ///Creates a new call builder for the [`domainSeparator`] function.
+        pub fn domainSeparator(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, domainSeparatorCall, N> {
+            self.call_builder(&domainSeparatorCall)
+        }
+
+        ///Creates a new call builder for the [`enableModule`] function.
+        pub fn enableModule(
+            &self,
+            module: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, enableModuleCall, N> {
+            self.call_builder(&enableModuleCall { module })
+        }
+
+        ///Creates a new call builder for the [`encodeTransactionData`]
+        /// function.
+        pub fn encodeTransactionData(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+            safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+            baseGas: alloy_sol_types::private::primitives::aliases::U256,
+            gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+            gasToken: alloy_sol_types::private::Address,
+            refundReceiver: alloy_sol_types::private::Address,
+            _nonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, encodeTransactionDataCall, N> {
+            self.call_builder(&encodeTransactionDataCall {
+                to,
+                value,
+                data,
+                operation,
+                safeTxGas,
+                baseGas,
+                gasPrice,
+                gasToken,
+                refundReceiver,
+                _nonce,
+            })
+        }
+
+        ///Creates a new call builder for the [`execTransaction`] function.
+        pub fn execTransaction(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+            safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+            baseGas: alloy_sol_types::private::primitives::aliases::U256,
+            gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+            gasToken: alloy_sol_types::private::Address,
+            refundReceiver: alloy_sol_types::private::Address,
+            signatures: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, execTransactionCall, N> {
+            self.call_builder(&execTransactionCall {
+                to,
+                value,
+                data,
+                operation,
+                safeTxGas,
+                baseGas,
+                gasPrice,
+                gasToken,
+                refundReceiver,
+                signatures,
+            })
+        }
+
+        ///Creates a new call builder for the [`execTransactionFromModule`]
+        /// function.
+        pub fn execTransactionFromModule(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, execTransactionFromModuleCall, N> {
+            self.call_builder(&execTransactionFromModuleCall {
+                to,
+                value,
+                data,
+                operation,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`execTransactionFromModuleReturnData`] function.
+        pub fn execTransactionFromModuleReturnData(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, execTransactionFromModuleReturnDataCall, N>
+        {
+            self.call_builder(&execTransactionFromModuleReturnDataCall {
+                to,
+                value,
+                data,
+                operation,
+            })
+        }
+
+        ///Creates a new call builder for the [`getChainId`] function.
+        pub fn getChainId(&self) -> alloy_contract::SolCallBuilder<&P, getChainIdCall, N> {
+            self.call_builder(&getChainIdCall)
+        }
+
+        ///Creates a new call builder for the [`getModulesPaginated`] function.
+        pub fn getModulesPaginated(
+            &self,
+            start: alloy_sol_types::private::Address,
+            pageSize: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getModulesPaginatedCall, N> {
+            self.call_builder(&getModulesPaginatedCall { start, pageSize })
+        }
+
+        ///Creates a new call builder for the [`getOwners`] function.
+        pub fn getOwners(&self) -> alloy_contract::SolCallBuilder<&P, getOwnersCall, N> {
+            self.call_builder(&getOwnersCall)
+        }
+
+        ///Creates a new call builder for the [`getStorageAt`] function.
+        pub fn getStorageAt(
+            &self,
+            offset: alloy_sol_types::private::primitives::aliases::U256,
+            length: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
+            self.call_builder(&getStorageAtCall { offset, length })
+        }
+
+        ///Creates a new call builder for the [`getThreshold`] function.
+        pub fn getThreshold(&self) -> alloy_contract::SolCallBuilder<&P, getThresholdCall, N> {
+            self.call_builder(&getThresholdCall)
+        }
+
+        ///Creates a new call builder for the [`getTransactionHash`] function.
+        pub fn getTransactionHash(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+            safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+            baseGas: alloy_sol_types::private::primitives::aliases::U256,
+            gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+            gasToken: alloy_sol_types::private::Address,
+            refundReceiver: alloy_sol_types::private::Address,
+            _nonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getTransactionHashCall, N> {
+            self.call_builder(&getTransactionHashCall {
+                to,
+                value,
+                data,
+                operation,
+                safeTxGas,
+                baseGas,
+                gasPrice,
+                gasToken,
+                refundReceiver,
+                _nonce,
+            })
+        }
+
+        ///Creates a new call builder for the [`isModuleEnabled`] function.
+        pub fn isModuleEnabled(
+            &self,
+            module: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isModuleEnabledCall, N> {
+            self.call_builder(&isModuleEnabledCall { module })
+        }
+
+        ///Creates a new call builder for the [`isOwner`] function.
+        pub fn isOwner(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isOwnerCall, N> {
+            self.call_builder(&isOwnerCall { owner })
+        }
+
+        ///Creates a new call builder for the [`nonce`] function.
+        pub fn nonce(&self) -> alloy_contract::SolCallBuilder<&P, nonceCall, N> {
+            self.call_builder(&nonceCall)
+        }
+
+        ///Creates a new call builder for the [`removeOwner`] function.
+        pub fn removeOwner(
+            &self,
+            prevOwner: alloy_sol_types::private::Address,
+            owner: alloy_sol_types::private::Address,
+            _threshold: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeOwnerCall, N> {
+            self.call_builder(&removeOwnerCall {
+                prevOwner,
+                owner,
+                _threshold,
+            })
+        }
+
+        ///Creates a new call builder for the [`requiredTxGas`] function.
+        pub fn requiredTxGas(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, requiredTxGasCall, N> {
+            self.call_builder(&requiredTxGasCall {
+                to,
+                value,
+                data,
+                operation,
+            })
+        }
+
+        ///Creates a new call builder for the [`setFallbackHandler`] function.
+        pub fn setFallbackHandler(
+            &self,
+            handler: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setFallbackHandlerCall, N> {
+            self.call_builder(&setFallbackHandlerCall { handler })
+        }
+
+        ///Creates a new call builder for the [`setGuard`] function.
+        pub fn setGuard(
+            &self,
+            guard: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setGuardCall, N> {
+            self.call_builder(&setGuardCall { guard })
+        }
+
+        ///Creates a new call builder for the [`setup`] function.
+        pub fn setup(
+            &self,
+            _owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            _threshold: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+            fallbackHandler: alloy_sol_types::private::Address,
+            paymentToken: alloy_sol_types::private::Address,
+            payment: alloy_sol_types::private::primitives::aliases::U256,
+            paymentReceiver: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setupCall, N> {
+            self.call_builder(&setupCall {
+                _owners,
+                _threshold,
+                to,
+                data,
+                fallbackHandler,
+                paymentToken,
+                payment,
+                paymentReceiver,
+            })
+        }
+
+        ///Creates a new call builder for the [`signedMessages`] function.
+        pub fn signedMessages(
+            &self,
+            _0: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, signedMessagesCall, N> {
+            self.call_builder(&signedMessagesCall(_0))
+        }
+
+        ///Creates a new call builder for the [`simulateAndRevert`] function.
+        pub fn simulateAndRevert(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateAndRevertCall, N> {
+            self.call_builder(&simulateAndRevertCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapOwner`] function.
+        pub fn swapOwner(
+            &self,
+            prevOwner: alloy_sol_types::private::Address,
+            oldOwner: alloy_sol_types::private::Address,
+            newOwner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, swapOwnerCall, N> {
+            self.call_builder(&swapOwnerCall {
+                prevOwner,
+                oldOwner,
+                newOwner,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`AddedOwner`] event.
+        pub fn AddedOwner_filter(&self) -> alloy_contract::Event<&P, AddedOwner, N> {
+            self.event_filter::<AddedOwner>()
+        }
+
+        ///Creates a new event filter for the [`ApproveHash`] event.
+        pub fn ApproveHash_filter(&self) -> alloy_contract::Event<&P, ApproveHash, N> {
+            self.event_filter::<ApproveHash>()
+        }
+
+        ///Creates a new event filter for the [`ChangedFallbackHandler`] event.
+        pub fn ChangedFallbackHandler_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ChangedFallbackHandler, N> {
+            self.event_filter::<ChangedFallbackHandler>()
+        }
+
+        ///Creates a new event filter for the [`ChangedGuard`] event.
+        pub fn ChangedGuard_filter(&self) -> alloy_contract::Event<&P, ChangedGuard, N> {
+            self.event_filter::<ChangedGuard>()
+        }
+
+        ///Creates a new event filter for the [`ChangedThreshold`] event.
+        pub fn ChangedThreshold_filter(&self) -> alloy_contract::Event<&P, ChangedThreshold, N> {
+            self.event_filter::<ChangedThreshold>()
+        }
+
+        ///Creates a new event filter for the [`DisabledModule`] event.
+        pub fn DisabledModule_filter(&self) -> alloy_contract::Event<&P, DisabledModule, N> {
+            self.event_filter::<DisabledModule>()
+        }
+
+        ///Creates a new event filter for the [`EnabledModule`] event.
+        pub fn EnabledModule_filter(&self) -> alloy_contract::Event<&P, EnabledModule, N> {
+            self.event_filter::<EnabledModule>()
+        }
+
+        ///Creates a new event filter for the [`ExecutionFailure`] event.
+        pub fn ExecutionFailure_filter(&self) -> alloy_contract::Event<&P, ExecutionFailure, N> {
+            self.event_filter::<ExecutionFailure>()
+        }
+
+        ///Creates a new event filter for the [`ExecutionFromModuleFailure`]
+        /// event.
+        pub fn ExecutionFromModuleFailure_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ExecutionFromModuleFailure, N> {
+            self.event_filter::<ExecutionFromModuleFailure>()
+        }
+
+        ///Creates a new event filter for the [`ExecutionFromModuleSuccess`]
+        /// event.
+        pub fn ExecutionFromModuleSuccess_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ExecutionFromModuleSuccess, N> {
+            self.event_filter::<ExecutionFromModuleSuccess>()
+        }
+
+        ///Creates a new event filter for the [`ExecutionSuccess`] event.
+        pub fn ExecutionSuccess_filter(&self) -> alloy_contract::Event<&P, ExecutionSuccess, N> {
+            self.event_filter::<ExecutionSuccess>()
+        }
+
+        ///Creates a new event filter for the [`RemovedOwner`] event.
+        pub fn RemovedOwner_filter(&self) -> alloy_contract::Event<&P, RemovedOwner, N> {
+            self.event_filter::<RemovedOwner>()
+        }
+
+        ///Creates a new event filter for the [`SafeReceived`] event.
+        pub fn SafeReceived_filter(&self) -> alloy_contract::Event<&P, SafeReceived, N> {
+            self.event_filter::<SafeReceived>()
+        }
+
+        ///Creates a new event filter for the [`SafeSetup`] event.
+        pub fn SafeSetup_filter(&self) -> alloy_contract::Event<&P, SafeSetup, N> {
+            self.event_filter::<SafeSetup>()
+        }
+
+        ///Creates a new event filter for the [`SignMsg`] event.
+        pub fn SignMsg_filter(&self) -> alloy_contract::Event<&P, SignMsg, N> {
+            self.event_filter::<SignMsg>()
+        }
+    }
+}
+pub type Instance = GnosisSafe::GnosisSafeInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/Cargo.toml b/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/Cargo.toml
new file mode 100644
index 0000000000..d543682cdd
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gnosissafecompatibilityfallbackhandler"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs b/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs
new file mode 100644
index 0000000000..26b06b3e20
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs
@@ -0,0 +1,3390 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface GnosisSafeCompatibilityFallbackHandler {
+    function NAME() external view returns (string memory);
+    function VERSION() external view returns (string memory);
+    function getMessageHash(bytes memory message) external view returns (bytes32);
+    function getMessageHashForSafe(address safe, bytes memory message) external view returns (bytes32);
+    function getModules() external view returns (address[] memory);
+    function isValidSignature(bytes32 _dataHash, bytes memory _signature) external view returns (bytes4);
+    function isValidSignature(bytes memory _data, bytes memory _signature) external view returns (bytes4);
+    function onERC1155BatchReceived(address, address, uint256[] memory, uint256[] memory, bytes memory) external pure returns (bytes4);
+    function onERC1155Received(address, address, uint256, uint256, bytes memory) external pure returns (bytes4);
+    function onERC721Received(address, address, uint256, bytes memory) external pure returns (bytes4);
+    function simulate(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+    function tokensReceived(address, address, address, uint256, bytes memory, bytes memory) external pure;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "NAME",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getMessageHash",
+    "inputs": [
+      {
+        "name": "message",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getMessageHashForSafe",
+    "inputs": [
+      {
+        "name": "safe",
+        "type": "address",
+        "internalType": "contract GnosisSafe"
+      },
+      {
+        "name": "message",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getModules",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "_dataHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "_signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "_data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "_signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "onERC1155BatchReceived",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "onERC1155Received",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "onERC721Received",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "simulate",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "supportsInterface",
+    "inputs": [
+      {
+        "name": "interfaceId",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "tokensReceived",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "pure"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GnosisSafeCompatibilityFallbackHandler {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[Pa\x15t\x80a\0 `\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xCEW`\x005`\xE0\x1C\x80cj\xC2G\x84\x11a\0\x8CW\x80c\xBC\x19|\x81\x11a\0fW\x80c\xBC\x19|\x81\x14a\x07\xBBW\x80c\xBDa\x95\x1D\x14a\tQW\x80c\xF2:na\x14a\ncW\x80c\xFF\xA1\xADt\x14a\x0BcWa\0\xCEV[\x80cj\xC2G\x84\x14a\x05\xEAW\x80c\xA3\xF4\xDF~\x14a\x06\xD9W\x80c\xB2IM\xF3\x14a\x07\\Wa\0\xCEV[\x80b#\xDE)\x14a\0\xD3W\x80c\x01\xFF\xC9\xA7\x14a\x02\x0BW\x80c\n\x10(\xC4\x14a\x02nW\x80c\x15\x0Bz\x02\x14a\x03=W\x80c\x16&\xBA~\x14a\x043W\x80c \xC1;\x0B\x14a\x04\xE9W[`\0\x80\xFD[a\x02\t`\x04\x806\x03`\xC0\x81\x10\x15a\0\xE9W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x01pW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x01\x82W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x01\xA4W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x01\xC5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x01\xD7W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x01\xF9W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\x0B\xE6V[\0[a\x02V`\x04\x806\x03` \x81\x10\x15a\x02!W`\0\x80\xFD[\x81\x01\x90\x80\x805{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x90` \x01\x90\x92\x91\x90PPPa\x0B\xF0V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x03'`\x04\x806\x03` \x81\x10\x15a\x02\x84W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x02\xA1W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x02\xB3W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x02\xD5W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa\r*V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x03\xFE`\x04\x806\x03`\x80\x81\x10\x15a\x03SW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03\xBAW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xCCW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03\xEEW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\r=V[`@Q\x80\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x04\xB4`\x04\x806\x03`@\x81\x10\x15a\x04IW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x04pW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x04\x82W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\xA4W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\rRV[`@Q\x80\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x05\xB5`\x04\x806\x03`@\x81\x10\x15a\x04\xFFW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x05\x1CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05.W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05PW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x05qW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\x83W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05\xA5W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\x0F\nV[`@Q\x80\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x06\xC3`\x04\x806\x03`@\x81\x10\x15a\x06\0W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x06=W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06OW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x06qW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa\x11[V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x06\xE1a\x12\xCDV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x07!W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x07\x06V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x07NW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x07da\x13\x06V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x07\xA7W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x07\x8CV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[a\t\x1C`\x04\x806\x03`\xA0\x81\x10\x15a\x07\xD1W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x08.W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x08@W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x08bW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x08\x83W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x08\x95W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x08\xB7W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x08\xD8W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x08\xEAW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\t\x0CW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\x14mV[`@Q\x80\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\t\xE8`\x04\x806\x03`@\x81\x10\x15a\tgW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\t\xA4W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\t\xB6W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\t\xD8W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\x14\x85V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\n(W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\n\rV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\nUW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x0B.`\x04\x806\x03`\xA0\x81\x10\x15a\nyW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\n\xEAW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\xFCW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0B\x1EW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90PPPa\x14\xEFV[`@Q\x80\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x0Bka\x15\x05V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x0B\xABW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0B\x90V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x0B\xD8W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[PPPPPPPPV[`\0\x7FN#\x12\xE0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14\x80a\x0C\xBBWP\x7F\x15\x0Bz\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14[\x80a\r#WP\x7F\x01\xFF\xC9\xA7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x82{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14[\x90P\x91\x90PV[`\0a\r63\x83a\x11[V[\x90P\x91\x90PV[`\0c\x15\x0Bz\x02`\xE0\x1B\x90P\x95\x94PPPPPV[`\0\x803\x90P`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \xC1;\x0B\x87`@Q` \x01\x80\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x87\x87`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x80` \x01\x80` \x01\x83\x81\x03\x83R\x86\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\r\xEBW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\r\xD0V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x0E\x18W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x83\x81\x03\x82R\x85\x85\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x95PPPPPP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x0EcW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x0EwW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x0E\x8DW`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP\x90Pc \xC1;\x0B`\xE0\x1B{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14a\x0E\xF6W`\0`\xE0\x1Ba\x0E\xFFV[c\x16&\xBA~`\xE0\x1B[\x92PPP\x93\x92PPPV[`\0\x803\x90P`\0a\x0F`\x82\x88\x88\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPPa\x11[V[\x90P`\0\x85\x85\x90P\x14\x15a\x10uW`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cZ\xE6\xBD7\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x0F\xC1W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x0F\xD5W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x0F\xEBW`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP\x14\x15a\x10pW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x11\x81R` \x01\x80\x7FHash not approved\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x11GV[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x93O:\x11\x82\x89\x89\x89\x89`@Q\x86c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x86\x81R` \x01\x80` \x01\x80` \x01\x83\x81\x03\x83R\x87\x87\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x83\x81\x03\x82R\x85\x85\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x97PPPPPPPP`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11.W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x11BW=`\0\x80>=`\0\xFD[PPPP[c \xC1;\x0B`\xE0\x1B\x92PPP\x94\x93PPPPV[`\0\x80\x7F`\xB3\xCB\xF8\xB4\xA2#\xD6\x8Dd\x1B;m\xDF\x9A)\x8E\x7F3q\x0C\xF3\xD3\xA9\xD1\x14kZaP\xFB\xCA`\0\x1B\x83\x80Q\x90` \x01 `@Q` \x01\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\x19`\xF8\x1B`\x01`\xF8\x1B\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF6\x98\xDA%`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\tW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x12\x1DW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x123W`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP\x83`@Q` \x01\x80\x85~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x84~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x91PP\x92\x91PPV[`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7FDefault Callback Handler\0\0\0\0\0\0\0\0\x81RP\x81V[```\x003\x90P`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xCC/\x84R`\x01`\n`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x80W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x13\x94W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP`@\x81\x10\x15a\x13\xBEW`\0\x80\xFD[\x81\x01\x90\x80\x80Q`@Q\x93\x92\x91\x90\x84d\x01\0\0\0\0\x82\x11\x15a\x13\xDEW`\0\x80\xFD[\x83\x82\x01\x91P` \x82\x01\x85\x81\x11\x15a\x13\xF4W`\0\x80\xFD[\x82Q\x86` \x82\x02\x83\x01\x11d\x01\0\0\0\0\x82\x11\x17\x15a\x14\x11W`\0\x80\xFD[\x80\x83R` \x83\x01\x92PPP\x90\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x14HW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x14-V[PPPP\x90P\x01`@R` \x01\x80Q\x90` \x01\x90\x92\x91\x90PPPP\x90P\x80\x92PPP\x90V[`\0c\xBC\x19|\x81`\xE0\x1B\x90P\x98\x97PPPPPPPPV[```@Q\x7F\xB4\xFA\xBA\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x046\x03`\x04\x80\x83\x017` `\x006\x83`\x003Z\xF1P` =\x03`@Q\x92P\x80\x83\x01`@R\x80` \x84>`\0Qa\x14\xE6W\x82Q` \x84\x01\xFD[PP\x93\x92PPPV[`\0c\xF2:na`\xE0\x1B\x90P\x96\x95PPPPPPV[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F1.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V\xFE\xA2dipfsX\"\x12 BQ\xD5\x8F*\x19t9#\x9F\xAA\xFA\x82\x81\x8Bv\x96\xD2[\xB7VUyJ\x81\xCCw:\x0E9\xED+dsolcC\0\x07\x06\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `NAME()` and selector `0xa3f4df7e`.
+    ```solidity
+    function NAME() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NAMECall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`NAME()`](NAMECall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NAMEReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<NAMECall> for UnderlyingRustTuple<'_> {
+                fn from(value: NAMECall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for NAMECall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<NAMEReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: NAMEReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for NAMEReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for NAMECall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [163u8, 244u8, 223u8, 126u8];
+            const SIGNATURE: &'static str = "NAME()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: NAMEReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: NAMEReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `VERSION()` and selector `0xffa1ad74`.
+    ```solidity
+    function VERSION() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct VERSIONCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`VERSION()`](VERSIONCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct VERSIONReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<VERSIONCall> for UnderlyingRustTuple<'_> {
+                fn from(value: VERSIONCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<VERSIONReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: VERSIONReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for VERSIONCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 161u8, 173u8, 116u8];
+            const SIGNATURE: &'static str = "VERSION()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: VERSIONReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: VERSIONReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getMessageHash(bytes)` and selector `0x0a1028c4`.
+    ```solidity
+    function getMessageHash(bytes memory message) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMessageHashCall {
+        #[allow(missing_docs)]
+        pub message: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getMessageHash(bytes)`](getMessageHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMessageHashReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMessageHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getMessageHashCall) -> Self {
+                    (value.message,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { message: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMessageHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getMessageHashReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getMessageHashCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [10u8, 16u8, 40u8, 196u8];
+            const SIGNATURE: &'static str = "getMessageHash(bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.message,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getMessageHashReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getMessageHashReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getMessageHashForSafe(address,bytes)` and selector `0x6ac24784`.
+    ```solidity
+    function getMessageHashForSafe(address safe, bytes memory message) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMessageHashForSafeCall {
+        #[allow(missing_docs)]
+        pub safe: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub message: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getMessageHashForSafe(address,bytes)`](getMessageHashForSafeCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMessageHashForSafeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMessageHashForSafeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getMessageHashForSafeCall) -> Self {
+                    (value.safe, value.message)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashForSafeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        safe: tuple.0,
+                        message: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMessageHashForSafeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getMessageHashForSafeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashForSafeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getMessageHashForSafeCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [106u8, 194u8, 71u8, 132u8];
+            const SIGNATURE: &'static str = "getMessageHashForSafe(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.safe,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.message,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getMessageHashForSafeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getMessageHashForSafeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getModules()` and selector `0xb2494df3`.
+    ```solidity
+    function getModules() external view returns (address[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getModulesCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getModules()`](getModulesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getModulesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getModulesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getModulesCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getModulesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getModulesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getModulesCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [178u8, 73u8, 77u8, 243u8];
+            const SIGNATURE: &'static str = "getModules()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getModulesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getModulesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32 _dataHash, bytes memory _signature) external view returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignature_0Call {
+        #[allow(missing_docs)]
+        pub _dataHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub _signature: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignature_0Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignature_0Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignature_0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_0Call) -> Self {
+                    (value._dataHash, value._signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _dataHash: tuple.0,
+                        _signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignature_0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_0Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignature_0Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._dataHash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignature_0Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignature_0Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes,bytes)` and selector `0x20c13b0b`.
+    ```solidity
+    function isValidSignature(bytes memory _data, bytes memory _signature) external view returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignature_1Call {
+        #[allow(missing_docs)]
+        pub _data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub _signature: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes,bytes)`](isValidSignature_1Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignature_1Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignature_1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_1Call) -> Self {
+                    (value._data, value._signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_1Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _data: tuple.0,
+                        _signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignature_1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_1Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_1Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignature_1Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [32u8, 193u8, 59u8, 11u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._data,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignature_1Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignature_1Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)` and selector `0xbc197c81`.
+    ```solidity
+    function onERC1155BatchReceived(address, address, uint256[] memory, uint256[] memory, bytes memory) external pure returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC1155BatchReceivedCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _3: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub _4: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onERC1155BatchReceived(address,address,uint256[],uint256[],
+    /// bytes)`](onERC1155BatchReceivedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC1155BatchReceivedReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC1155BatchReceivedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC1155BatchReceivedCall) -> Self {
+                    (value._0, value._1, value._2, value._3, value._4)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155BatchReceivedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                        _2: tuple.2,
+                        _3: tuple.3,
+                        _4: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC1155BatchReceivedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC1155BatchReceivedReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155BatchReceivedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onERC1155BatchReceivedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [188u8, 25u8, 124u8, 129u8];
+            const SIGNATURE: &'static str =
+                "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._2),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self._3),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._4,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onERC1155BatchReceivedReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onERC1155BatchReceivedReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onERC1155Received(address,address,uint256,uint256,bytes)` and selector `0xf23a6e61`.
+    ```solidity
+    function onERC1155Received(address, address, uint256, uint256, bytes memory) external pure returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC1155ReceivedCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _3: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _4: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onERC1155Received(address,address,uint256,uint256,
+    /// bytes)`](onERC1155ReceivedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC1155ReceivedReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC1155ReceivedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC1155ReceivedCall) -> Self {
+                    (value._0, value._1, value._2, value._3, value._4)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                        _2: tuple.2,
+                        _3: tuple.3,
+                        _4: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC1155ReceivedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC1155ReceivedReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
+            const SIGNATURE: &'static str =
+                "onERC1155Received(address,address,uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._3,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._4,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onERC1155ReceivedReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onERC1155ReceivedReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onERC721Received(address,address,uint256,bytes)` and selector `0x150b7a02`.
+    ```solidity
+    function onERC721Received(address, address, uint256, bytes memory) external pure returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC721ReceivedCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _3: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onERC721Received(address,address,uint256,
+    /// bytes)`](onERC721ReceivedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC721ReceivedReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC721ReceivedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC721ReceivedCall) -> Self {
+                    (value._0, value._1, value._2, value._3)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                        _2: tuple.2,
+                        _3: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC721ReceivedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC721ReceivedReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onERC721ReceivedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
+            const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._3,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onERC721ReceivedReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onERC721ReceivedReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulate(address,bytes)` and selector `0xbd61951d`.
+    ```solidity
+    function simulate(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulate(address,bytes)`](simulateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [189u8, 97u8, 149u8, 29u8];
+            const SIGNATURE: &'static str = "simulate(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `supportsInterface(bytes4)` and selector `0x01ffc9a7`.
+    ```solidity
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct supportsInterfaceCall {
+        #[allow(missing_docs)]
+        pub interfaceId: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`supportsInterface(bytes4)`](supportsInterfaceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct supportsInterfaceReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<supportsInterfaceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: supportsInterfaceCall) -> Self {
+                    (value.interfaceId,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsInterfaceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        interfaceId: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<supportsInterfaceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: supportsInterfaceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsInterfaceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for supportsInterfaceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
+            const SIGNATURE: &'static str = "supportsInterface(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: supportsInterfaceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: supportsInterfaceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `tokensReceived(address,address,address,uint256,bytes,bytes)` and selector `0x0023de29`.
+    ```solidity
+    function tokensReceived(address, address, address, uint256, bytes memory, bytes memory) external pure;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tokensReceivedCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _3: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _4: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub _5: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`tokensReceived(address,address,address,uint256,bytes,
+    /// bytes)`](tokensReceivedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tokensReceivedReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tokensReceivedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: tokensReceivedCall) -> Self {
+                    (value._0, value._1, value._2, value._3, value._4, value._5)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokensReceivedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                        _2: tuple.2,
+                        _3: tuple.3,
+                        _4: tuple.4,
+                        _5: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tokensReceivedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: tokensReceivedReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokensReceivedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl tokensReceivedReturn {
+            fn _tokenize(
+                &self,
+            ) -> <tokensReceivedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for tokensReceivedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = tokensReceivedReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [0u8, 35u8, 222u8, 41u8];
+            const SIGNATURE: &'static str =
+                "tokensReceived(address,address,address,uint256,bytes,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._3,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._4,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._5,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                tokensReceivedReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`GnosisSafeCompatibilityFallbackHandler`](self)
+    /// function calls.
+    #[derive(Clone)]
+    pub enum GnosisSafeCompatibilityFallbackHandlerCalls {
+        #[allow(missing_docs)]
+        NAME(NAMECall),
+        #[allow(missing_docs)]
+        VERSION(VERSIONCall),
+        #[allow(missing_docs)]
+        getMessageHash(getMessageHashCall),
+        #[allow(missing_docs)]
+        getMessageHashForSafe(getMessageHashForSafeCall),
+        #[allow(missing_docs)]
+        getModules(getModulesCall),
+        #[allow(missing_docs)]
+        isValidSignature_0(isValidSignature_0Call),
+        #[allow(missing_docs)]
+        isValidSignature_1(isValidSignature_1Call),
+        #[allow(missing_docs)]
+        onERC1155BatchReceived(onERC1155BatchReceivedCall),
+        #[allow(missing_docs)]
+        onERC1155Received(onERC1155ReceivedCall),
+        #[allow(missing_docs)]
+        onERC721Received(onERC721ReceivedCall),
+        #[allow(missing_docs)]
+        simulate(simulateCall),
+        #[allow(missing_docs)]
+        supportsInterface(supportsInterfaceCall),
+        #[allow(missing_docs)]
+        tokensReceived(tokensReceivedCall),
+    }
+    impl GnosisSafeCompatibilityFallbackHandlerCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [0u8, 35u8, 222u8, 41u8],
+            [1u8, 255u8, 201u8, 167u8],
+            [10u8, 16u8, 40u8, 196u8],
+            [21u8, 11u8, 122u8, 2u8],
+            [22u8, 38u8, 186u8, 126u8],
+            [32u8, 193u8, 59u8, 11u8],
+            [106u8, 194u8, 71u8, 132u8],
+            [163u8, 244u8, 223u8, 126u8],
+            [178u8, 73u8, 77u8, 243u8],
+            [188u8, 25u8, 124u8, 129u8],
+            [189u8, 97u8, 149u8, 29u8],
+            [242u8, 58u8, 110u8, 97u8],
+            [255u8, 161u8, 173u8, 116u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <tokensReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <supportsInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getMessageHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onERC721ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <isValidSignature_0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <isValidSignature_1Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <getMessageHashForSafeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <NAMECall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getModulesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(tokensReceived),
+            ::core::stringify!(supportsInterface),
+            ::core::stringify!(getMessageHash),
+            ::core::stringify!(onERC721Received),
+            ::core::stringify!(isValidSignature_0),
+            ::core::stringify!(isValidSignature_1),
+            ::core::stringify!(getMessageHashForSafe),
+            ::core::stringify!(NAME),
+            ::core::stringify!(getModules),
+            ::core::stringify!(onERC1155BatchReceived),
+            ::core::stringify!(simulate),
+            ::core::stringify!(onERC1155Received),
+            ::core::stringify!(VERSION),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for GnosisSafeCompatibilityFallbackHandlerCalls {
+        const COUNT: usize = 13usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "GnosisSafeCompatibilityFallbackHandlerCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::NAME(_) => <NAMECall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::VERSION(_) => <VERSIONCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getMessageHash(_) => {
+                    <getMessageHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getMessageHashForSafe(_) => {
+                    <getMessageHashForSafeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getModules(_) => <getModulesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::isValidSignature_0(_) => {
+                    <isValidSignature_0Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isValidSignature_1(_) => {
+                    <isValidSignature_1Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::onERC1155BatchReceived(_) => {
+                    <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::onERC1155Received(_) => {
+                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::onERC721Received(_) => {
+                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::simulate(_) => <simulateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::supportsInterface(_) => {
+                    <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::tokensReceived(_) => {
+                    <tokensReceivedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                GnosisSafeCompatibilityFallbackHandlerCalls,
+            >] = &[
+                {
+                    fn tokensReceived(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <tokensReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::tokensReceived)
+                    }
+                    tokensReceived
+                },
+                {
+                    fn supportsInterface(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::supportsInterface)
+                    }
+                    supportsInterface
+                },
+                {
+                    fn getMessageHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <getMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHash)
+                    }
+                    getMessageHash
+                },
+                {
+                    fn onERC721Received(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC721Received)
+                    }
+                    onERC721Received
+                },
+                {
+                    fn isValidSignature_0(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <isValidSignature_0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::isValidSignature_0)
+                    }
+                    isValidSignature_0
+                },
+                {
+                    fn isValidSignature_1(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <isValidSignature_1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::isValidSignature_1)
+                    }
+                    isValidSignature_1
+                },
+                {
+                    fn getMessageHashForSafe(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHashForSafe)
+                    }
+                    getMessageHashForSafe
+                },
+                {
+                    fn NAME(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <NAMECall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::NAME)
+                    }
+                    NAME
+                },
+                {
+                    fn getModules(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <getModulesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::getModules)
+                    }
+                    getModules
+                },
+                {
+                    fn onERC1155BatchReceived(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155BatchReceived)
+                    }
+                    onERC1155BatchReceived
+                },
+                {
+                    fn simulate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <simulateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::simulate)
+                    }
+                    simulate
+                },
+                {
+                    fn onERC1155Received(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155Received)
+                    }
+                    onERC1155Received
+                },
+                {
+                    fn VERSION(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::VERSION)
+                    }
+                    VERSION
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                GnosisSafeCompatibilityFallbackHandlerCalls,
+            >] = &[
+                {
+                    fn tokensReceived(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <tokensReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::tokensReceived)
+                    }
+                    tokensReceived
+                },
+                {
+                    fn supportsInterface(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeCompatibilityFallbackHandlerCalls::supportsInterface,
+                            )
+                    }
+                    supportsInterface
+                },
+                {
+                    fn getMessageHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <getMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHash)
+                    }
+                    getMessageHash
+                },
+                {
+                    fn onERC721Received(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC721Received)
+                    }
+                    onERC721Received
+                },
+                {
+                    fn isValidSignature_0(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <isValidSignature_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeCompatibilityFallbackHandlerCalls::isValidSignature_0,
+                            )
+                    }
+                    isValidSignature_0
+                },
+                {
+                    fn isValidSignature_1(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <isValidSignature_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeCompatibilityFallbackHandlerCalls::isValidSignature_1,
+                            )
+                    }
+                    isValidSignature_1
+                },
+                {
+                    fn getMessageHashForSafe(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHashForSafe,
+                            )
+                    }
+                    getMessageHashForSafe
+                },
+                {
+                    fn NAME(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <NAMECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::NAME)
+                    }
+                    NAME
+                },
+                {
+                    fn getModules(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <getModulesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::getModules)
+                    }
+                    getModules
+                },
+                {
+                    fn onERC1155BatchReceived(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155BatchReceived,
+                            )
+                    }
+                    onERC1155BatchReceived
+                },
+                {
+                    fn simulate(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <simulateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::simulate)
+                    }
+                    simulate
+                },
+                {
+                    fn onERC1155Received(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155Received,
+                            )
+                    }
+                    onERC1155Received
+                },
+                {
+                    fn VERSION(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
+                    {
+                        <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::VERSION)
+                    }
+                    VERSION
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::NAME(inner) => {
+                    <NAMECall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::VERSION(inner) => {
+                    <VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getMessageHash(inner) => {
+                    <getMessageHashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getMessageHashForSafe(inner) => {
+                    <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getModules(inner) => {
+                    <getModulesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isValidSignature_0(inner) => {
+                    <isValidSignature_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isValidSignature_1(inner) => {
+                    <isValidSignature_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onERC1155BatchReceived(inner) => {
+                    <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::onERC1155Received(inner) => {
+                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::onERC721Received(inner) => {
+                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulate(inner) => {
+                    <simulateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::supportsInterface(inner) => {
+                    <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::tokensReceived(inner) => {
+                    <tokensReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::NAME(inner) => {
+                    <NAMECall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::VERSION(inner) => {
+                    <VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getMessageHash(inner) => {
+                    <getMessageHashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getMessageHashForSafe(inner) => {
+                    <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getModules(inner) => {
+                    <getModulesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isValidSignature_0(inner) => {
+                    <isValidSignature_0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isValidSignature_1(inner) => {
+                    <isValidSignature_1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onERC1155BatchReceived(inner) => {
+                    <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::onERC1155Received(inner) => {
+                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::onERC721Received(inner) => {
+                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::simulate(inner) => {
+                    <simulateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::supportsInterface(inner) => {
+                    <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::tokensReceived(inner) => {
+                    <tokensReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GnosisSafeCompatibilityFallbackHandler`](self) contract instance.
+
+    See the [wrapper's documentation](`GnosisSafeCompatibilityFallbackHandlerInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GnosisSafeCompatibilityFallbackHandlerInstance<P, N> {
+        GnosisSafeCompatibilityFallbackHandlerInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<GnosisSafeCompatibilityFallbackHandlerInstance<P, N>>,
+    > {
+        GnosisSafeCompatibilityFallbackHandlerInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GnosisSafeCompatibilityFallbackHandlerInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`GnosisSafeCompatibilityFallbackHandler`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GnosisSafeCompatibilityFallbackHandler`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GnosisSafeCompatibilityFallbackHandlerInstance<
+        P,
+        N = alloy_contract::private::Ethereum,
+    > {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GnosisSafeCompatibilityFallbackHandlerInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GnosisSafeCompatibilityFallbackHandlerInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeCompatibilityFallbackHandlerInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GnosisSafeCompatibilityFallbackHandler`](self) contract instance.
+
+        See the [wrapper's documentation](`GnosisSafeCompatibilityFallbackHandlerInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<GnosisSafeCompatibilityFallbackHandlerInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GnosisSafeCompatibilityFallbackHandlerInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GnosisSafeCompatibilityFallbackHandlerInstance<P, N> {
+            GnosisSafeCompatibilityFallbackHandlerInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeCompatibilityFallbackHandlerInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`NAME`] function.
+        pub fn NAME(&self) -> alloy_contract::SolCallBuilder<&P, NAMECall, N> {
+            self.call_builder(&NAMECall)
+        }
+
+        ///Creates a new call builder for the [`VERSION`] function.
+        pub fn VERSION(&self) -> alloy_contract::SolCallBuilder<&P, VERSIONCall, N> {
+            self.call_builder(&VERSIONCall)
+        }
+
+        ///Creates a new call builder for the [`getMessageHash`] function.
+        pub fn getMessageHash(
+            &self,
+            message: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, getMessageHashCall, N> {
+            self.call_builder(&getMessageHashCall { message })
+        }
+
+        ///Creates a new call builder for the [`getMessageHashForSafe`]
+        /// function.
+        pub fn getMessageHashForSafe(
+            &self,
+            safe: alloy_sol_types::private::Address,
+            message: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, getMessageHashForSafeCall, N> {
+            self.call_builder(&getMessageHashForSafeCall { safe, message })
+        }
+
+        ///Creates a new call builder for the [`getModules`] function.
+        pub fn getModules(&self) -> alloy_contract::SolCallBuilder<&P, getModulesCall, N> {
+            self.call_builder(&getModulesCall)
+        }
+
+        ///Creates a new call builder for the [`isValidSignature_0`] function.
+        pub fn isValidSignature_0(
+            &self,
+            _dataHash: alloy_sol_types::private::FixedBytes<32>,
+            _signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignature_0Call, N> {
+            self.call_builder(&isValidSignature_0Call {
+                _dataHash,
+                _signature,
+            })
+        }
+
+        ///Creates a new call builder for the [`isValidSignature_1`] function.
+        pub fn isValidSignature_1(
+            &self,
+            _data: alloy_sol_types::private::Bytes,
+            _signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignature_1Call, N> {
+            self.call_builder(&isValidSignature_1Call { _data, _signature })
+        }
+
+        ///Creates a new call builder for the [`onERC1155BatchReceived`]
+        /// function.
+        pub fn onERC1155BatchReceived(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+            _2: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            _3: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            _4: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onERC1155BatchReceivedCall, N> {
+            self.call_builder(&onERC1155BatchReceivedCall { _0, _1, _2, _3, _4 })
+        }
+
+        ///Creates a new call builder for the [`onERC1155Received`] function.
+        pub fn onERC1155Received(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+            _2: alloy_sol_types::private::primitives::aliases::U256,
+            _3: alloy_sol_types::private::primitives::aliases::U256,
+            _4: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
+            self.call_builder(&onERC1155ReceivedCall { _0, _1, _2, _3, _4 })
+        }
+
+        ///Creates a new call builder for the [`onERC721Received`] function.
+        pub fn onERC721Received(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+            _2: alloy_sol_types::private::primitives::aliases::U256,
+            _3: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
+            self.call_builder(&onERC721ReceivedCall { _0, _1, _2, _3 })
+        }
+
+        ///Creates a new call builder for the [`simulate`] function.
+        pub fn simulate(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateCall, N> {
+            self.call_builder(&simulateCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`supportsInterface`] function.
+        pub fn supportsInterface(
+            &self,
+            interfaceId: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
+            self.call_builder(&supportsInterfaceCall { interfaceId })
+        }
+
+        ///Creates a new call builder for the [`tokensReceived`] function.
+        pub fn tokensReceived(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+            _2: alloy_sol_types::private::Address,
+            _3: alloy_sol_types::private::primitives::aliases::U256,
+            _4: alloy_sol_types::private::Bytes,
+            _5: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, tokensReceivedCall, N> {
+            self.call_builder(&tokensReceivedCall {
+                _0,
+                _1,
+                _2,
+                _3,
+                _4,
+                _5,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeCompatibilityFallbackHandlerInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    GnosisSafeCompatibilityFallbackHandler::GnosisSafeCompatibilityFallbackHandlerInstance<
+        ::alloy_provider::DynProvider,
+    >;
diff --git a/contracts/generated/contracts-generated/gnosissafeproxy/Cargo.toml b/contracts/generated/contracts-generated/gnosissafeproxy/Cargo.toml
new file mode 100644
index 0000000000..aef25e34bb
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafeproxy/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gnosissafeproxy"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gnosissafeproxy/src/lib.rs b/contracts/generated/contracts-generated/gnosissafeproxy/src/lib.rs
new file mode 100644
index 0000000000..28b7fbe126
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafeproxy/src/lib.rs
@@ -0,0 +1,317 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface GnosisSafeProxy {
+    constructor(address _singleton);
+
+    fallback() external payable;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_singleton",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "fallback",
+    "stateMutability": "payable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GnosisSafeProxy {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x608060405234801561001057600080fd5b506040516101e63803806101e68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101c46022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505060ab806101196000396000f3fe608060405273ffffffffffffffffffffffffffffffffffffffff600054167fa619486e0000000000000000000000000000000000000000000000000000000060003514156050578060005260206000f35b3660008037600080366000845af43d6000803e60008114156070573d6000fd5b3d6000f3fea2646970667358221220d1429297349653a4918076d650332de1a1068c5f3e07c5c82360c277770b955264736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x01\xE68\x03\x80a\x01\xE6\x839\x81\x81\x01`@R` \x81\x10\x15a\x003W`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\0\xCAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\"\x81R` \x01\x80a\x01\xC4`\"\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPP`\xAB\x80a\x01\x19`\09`\0\xF3\xFE`\x80`@Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\0T\x16\x7F\xA6\x19Hn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x005\x14\x15`PW\x80`\0R` `\0\xF3[6`\0\x807`\0\x806`\0\x84Z\xF4=`\0\x80>`\0\x81\x14\x15`pW=`\0\xFD[=`\0\xF3\xFE\xA2dipfsX\"\x12 \xD1B\x92\x974\x96S\xA4\x91\x80v\xD6P3-\xE1\xA1\x06\x8C_>\x07\xC5\xC8#`\xC2ww\x0B\x95RdsolcC\0\x07\x06\x003Invalid singleton address provided",
+    );
+    /**Constructor`.
+    ```solidity
+    constructor(address _singleton);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _singleton: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._singleton,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _singleton: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._singleton,
+                    ),
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GnosisSafeProxy`](self) contract instance.
+
+    See the [wrapper's documentation](`GnosisSafeProxyInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GnosisSafeProxyInstance<P, N> {
+        GnosisSafeProxyInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _singleton: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<GnosisSafeProxyInstance<P, N>>>
+    {
+        GnosisSafeProxyInstance::<P, N>::deploy(__provider, _singleton)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _singleton: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GnosisSafeProxyInstance::<P, N>::deploy_builder(__provider, _singleton)
+    }
+    /**A [`GnosisSafeProxy`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GnosisSafeProxy`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GnosisSafeProxyInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GnosisSafeProxyInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GnosisSafeProxyInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeProxyInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GnosisSafeProxy`](self) contract instance.
+
+        See the [wrapper's documentation](`GnosisSafeProxyInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _singleton: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<GnosisSafeProxyInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _singleton);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _singleton: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(
+                        &constructorCall { _singleton },
+                    )[..],
+                ]
+                    .concat()
+                    .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GnosisSafeProxyInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GnosisSafeProxyInstance<P, N> {
+            GnosisSafeProxyInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeProxyInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeProxyInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = GnosisSafeProxy::GnosisSafeProxyInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/gnosissafeproxyfactory/Cargo.toml b/contracts/generated/contracts-generated/gnosissafeproxyfactory/Cargo.toml
new file mode 100644
index 0000000000..d767974466
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafeproxyfactory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gnosissafeproxyfactory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs b/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs
new file mode 100644
index 0000000000..a77305e207
--- /dev/null
+++ b/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs
@@ -0,0 +1,1975 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface GnosisSafeProxyFactory {
+    event ProxyCreation(address proxy, address singleton);
+
+    function calculateCreateProxyWithNonceAddress(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
+    function createProxy(address singleton, bytes memory data) external returns (address proxy);
+    function createProxyWithCallback(address _singleton, bytes memory initializer, uint256 saltNonce, address callback) external returns (address proxy);
+    function createProxyWithNonce(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
+    function proxyCreationCode() external pure returns (bytes memory);
+    function proxyRuntimeCode() external pure returns (bytes memory);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "calculateCreateProxyWithNonceAddress",
+    "inputs": [
+      {
+        "name": "_singleton",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "initializer",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "saltNonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "proxy",
+        "type": "address",
+        "internalType": "contract GnosisSafeProxy"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "createProxy",
+    "inputs": [
+      {
+        "name": "singleton",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "proxy",
+        "type": "address",
+        "internalType": "contract GnosisSafeProxy"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "createProxyWithCallback",
+    "inputs": [
+      {
+        "name": "_singleton",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "initializer",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "saltNonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "callback",
+        "type": "address",
+        "internalType": "contract IProxyCreationCallback"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "proxy",
+        "type": "address",
+        "internalType": "contract GnosisSafeProxy"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "createProxyWithNonce",
+    "inputs": [
+      {
+        "name": "_singleton",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "initializer",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "saltNonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "proxy",
+        "type": "address",
+        "internalType": "contract GnosisSafeProxy"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "proxyCreationCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "proxyRuntimeCode",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "event",
+    "name": "ProxyCreation",
+    "inputs": [
+      {
+        "name": "proxy",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract GnosisSafeProxy"
+      },
+      {
+        "name": "singleton",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GnosisSafeProxyFactory {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[Pa\x0E\xBE\x80a\0 `\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0bW`\x005`\xE0\x1C\x80c\x16\x88\xF0\xB9\x14a\0gW\x80c%\0Q\x0E\x14a\x01vW\x80cS\xE5\xD95\x14a\x02CW\x80ca\xB6\x9A\xBD\x14a\x02\xC6W\x80c\xAD\xDA\xCC\x0F\x14a\x03\xCBW\x80c\xD1\x8A\xF5M\x14a\x04NW[`\0\x80\xFD[a\x01J`\x04\x806\x03``\x81\x10\x15a\0}W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\0\xBAW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\0\xCCW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\0\xEEW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x05}V[`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x02\x17`\x04\x806\x03``\x81\x10\x15a\x01\x8CW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x01\xC9W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x01\xDBW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x01\xFDW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x06$V[`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x02Ka\x07QV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x02\x8BW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x02pV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x02\xB8W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x03\x9F`\x04\x806\x03`@\x81\x10\x15a\x02\xDCW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03\x19W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03+W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03MW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa\x07|V[`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x03\xD3a\x08aV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x04\x13W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x03\xF8V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x04@W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x05Q`\x04\x806\x03`\x80\x81\x10\x15a\x04dW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x04\xA1W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x04\xB3W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\xD5W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x08\x8CV[`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[`\0a\x05\x8A\x84\x84\x84a\n;V[\x90P`\0\x83Q\x11\x15a\x05\xB2W`\0\x80`\0\x85Q` \x87\x01`\0\x86Z\xF1\x14\x15a\x05\xB1W`\0\x80\xFD[[\x7FOQ\xFA\xF6\xC4V\x1F\xF9_\x06vW\xE449\xF0\xF8V\xD9|\x04\xD9\xEC\x90p\xA6\x19\x9A\xD4\x18\xE25\x81\x85`@Q\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1\x93\x92PPPV[`\0a\x06u\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x84a\n;V[\x90P\x80`@Q` \x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16``\x1B\x81R`\x14\x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x07\x16W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x06\xFBV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x07CW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xFD[```@Q\x80` \x01a\x07c\x90a\x0B\xDEV[` \x82\x01\x81\x03\x82R`\x1F\x19`\x1F\x82\x01\x16`@RP\x90P\x90V[`\0\x82`@Qa\x07\x8B\x90a\x0B\xDEV[\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15a\x07\xC7W=`\0\x80>=`\0\xFD[P\x90P`\0\x82Q\x11\x15a\x07\xF0W`\0\x80`\0\x84Q` \x86\x01`\0\x86Z\xF1\x14\x15a\x07\xEFW`\0\x80\xFD[[\x7FOQ\xFA\xF6\xC4V\x1F\xF9_\x06vW\xE449\xF0\xF8V\xD9|\x04\xD9\xEC\x90p\xA6\x19\x9A\xD4\x18\xE25\x81\x84`@Q\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1\x92\x91PPV[```@Q\x80` \x01a\x08s\x90a\x0B\xEBV[` \x82\x01\x81\x03\x82R`\x1F\x19`\x1F\x82\x01\x16`@RP\x90P\x90V[`\0\x80\x83\x83`@Q` \x01\x80\x83\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16``\x1B\x81R`\x14\x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `\0\x1C\x90Pa\x08\xE7\x86\x86\x83a\x05}V[\x91P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\n2W\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x1ER\xB5\x18\x83\x88\x88\x88`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x83\x81R` \x01\x82\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\t\xCAW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\t\xAFV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\t\xF7W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\n\x19W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\n-W=`\0\x80>=`\0\xFD[PPPP[P\x94\x93PPPPV[`\0\x80\x83\x80Q\x90` \x01 \x83`@Q` \x01\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0`@Q\x80` \x01a\n\x88\x90a\x0B\xDEV[` \x82\x01\x81\x03\x82R`\x1F\x19`\x1F\x82\x01\x16`@RP\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`@Q` \x01\x80\x83\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a\n\xE9W\x80Q\x82R` \x82\x01\x91P` \x81\x01\x90P` \x83\x03\x92Pa\n\xC6V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x82\x81R` \x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P\x81\x81Q\x82` \x01`\0\xF5\x92P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x0B\xD5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x13\x81R` \x01\x80\x7FCreate2 call failed\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[PP\x93\x92PPPV[a\x01\xE6\x80a\x0B\xF8\x839\x01\x90V[`\xAB\x80a\r\xDE\x839\x01\x90V\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x01\xE68\x03\x80a\x01\xE6\x839\x81\x81\x01`@R` \x81\x10\x15a\x003W`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\0\xCAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\"\x81R` \x01\x80a\x01\xC4`\"\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPP`\xAB\x80a\x01\x19`\09`\0\xF3\xFE`\x80`@Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\0T\x16\x7F\xA6\x19Hn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x005\x14\x15`PW\x80`\0R` `\0\xF3[6`\0\x807`\0\x806`\0\x84Z\xF4=`\0\x80>`\0\x81\x14\x15`pW=`\0\xFD[=`\0\xF3\xFE\xA2dipfsX\"\x12 \xD1B\x92\x974\x96S\xA4\x91\x80v\xD6P3-\xE1\xA1\x06\x8C_>\x07\xC5\xC8#`\xC2ww\x0B\x95RdsolcC\0\x07\x06\x003Invalid singleton address provided`\x80`@Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\0T\x16\x7F\xA6\x19Hn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x005\x14\x15`PW\x80`\0R` `\0\xF3[6`\0\x807`\0\x806`\0\x84Z\xF4=`\0\x80>`\0\x81\x14\x15`pW=`\0\xFD[=`\0\xF3\xFE\xA2dipfsX\"\x12 \xD1B\x92\x974\x96S\xA4\x91\x80v\xD6P3-\xE1\xA1\x06\x8C_>\x07\xC5\xC8#`\xC2ww\x0B\x95RdsolcC\0\x07\x06\x003\xA2dipfsX\"\x12 \x0Cu\xFE!\x96\xB9\xF7R\xC8'\x94%?.\xBC\xE0\xD8!\xAF\xEFY\x97\xE1\xD5\xA3^\xC3\x16\xCEY/fdsolcC\0\x07\x06\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ProxyCreation(address,address)` and selector `0x4f51faf6c4561ff95f067657e43439f0f856d97c04d9ec9070a6199ad418e235`.
+    ```solidity
+    event ProxyCreation(address proxy, address singleton);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ProxyCreation {
+        #[allow(missing_docs)]
+        pub proxy: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub singleton: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ProxyCreation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ProxyCreation(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    79u8, 81u8, 250u8, 246u8, 196u8, 86u8, 31u8, 249u8, 95u8, 6u8, 118u8, 87u8,
+                    228u8, 52u8, 57u8, 240u8, 248u8, 86u8, 217u8, 124u8, 4u8, 217u8, 236u8, 144u8,
+                    112u8, 166u8, 25u8, 154u8, 212u8, 24u8, 226u8, 53u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    proxy: data.0,
+                    singleton: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.proxy,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.singleton,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ProxyCreation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ProxyCreation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ProxyCreation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `calculateCreateProxyWithNonceAddress(address,bytes,uint256)` and selector `0x2500510e`.
+    ```solidity
+    function calculateCreateProxyWithNonceAddress(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct calculateCreateProxyWithNonceAddressCall {
+        #[allow(missing_docs)]
+        pub _singleton: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub initializer: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub saltNonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`calculateCreateProxyWithNonceAddress(address,bytes,
+    /// uint256)`](calculateCreateProxyWithNonceAddressCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct calculateCreateProxyWithNonceAddressReturn {
+        #[allow(missing_docs)]
+        pub proxy: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<calculateCreateProxyWithNonceAddressCall> for UnderlyingRustTuple<'_> {
+                fn from(value: calculateCreateProxyWithNonceAddressCall) -> Self {
+                    (value._singleton, value.initializer, value.saltNonce)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for calculateCreateProxyWithNonceAddressCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _singleton: tuple.0,
+                        initializer: tuple.1,
+                        saltNonce: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<calculateCreateProxyWithNonceAddressReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: calculateCreateProxyWithNonceAddressReturn) -> Self {
+                    (value.proxy,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for calculateCreateProxyWithNonceAddressReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { proxy: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for calculateCreateProxyWithNonceAddressCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [37u8, 0u8, 81u8, 14u8];
+            const SIGNATURE: &'static str =
+                "calculateCreateProxyWithNonceAddress(address,bytes,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._singleton,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.initializer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.saltNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: calculateCreateProxyWithNonceAddressReturn = r.into();
+                        r.proxy
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: calculateCreateProxyWithNonceAddressReturn = r.into();
+                    r.proxy
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createProxy(address,bytes)` and selector `0x61b69abd`.
+    ```solidity
+    function createProxy(address singleton, bytes memory data) external returns (address proxy);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createProxyCall {
+        #[allow(missing_docs)]
+        pub singleton: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createProxy(address,bytes)`](createProxyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createProxyReturn {
+        #[allow(missing_docs)]
+        pub proxy: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createProxyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyCall) -> Self {
+                    (value.singleton, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        singleton: tuple.0,
+                        data: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createProxyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyReturn) -> Self {
+                    (value.proxy,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { proxy: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createProxyCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [97u8, 182u8, 154u8, 189u8];
+            const SIGNATURE: &'static str = "createProxy(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.singleton,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createProxyReturn = r.into();
+                        r.proxy
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createProxyReturn = r.into();
+                    r.proxy
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createProxyWithCallback(address,bytes,uint256,address)` and selector `0xd18af54d`.
+    ```solidity
+    function createProxyWithCallback(address _singleton, bytes memory initializer, uint256 saltNonce, address callback) external returns (address proxy);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createProxyWithCallbackCall {
+        #[allow(missing_docs)]
+        pub _singleton: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub initializer: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub saltNonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callback: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createProxyWithCallback(address,bytes,uint256,
+    /// address)`](createProxyWithCallbackCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createProxyWithCallbackReturn {
+        #[allow(missing_docs)]
+        pub proxy: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createProxyWithCallbackCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyWithCallbackCall) -> Self {
+                    (
+                        value._singleton,
+                        value.initializer,
+                        value.saltNonce,
+                        value.callback,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithCallbackCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _singleton: tuple.0,
+                        initializer: tuple.1,
+                        saltNonce: tuple.2,
+                        callback: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createProxyWithCallbackReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyWithCallbackReturn) -> Self {
+                    (value.proxy,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithCallbackReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { proxy: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createProxyWithCallbackCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [209u8, 138u8, 245u8, 77u8];
+            const SIGNATURE: &'static str =
+                "createProxyWithCallback(address,bytes,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._singleton,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.initializer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.saltNonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.callback,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createProxyWithCallbackReturn = r.into();
+                        r.proxy
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createProxyWithCallbackReturn = r.into();
+                    r.proxy
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createProxyWithNonce(address,bytes,uint256)` and selector `0x1688f0b9`.
+    ```solidity
+    function createProxyWithNonce(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createProxyWithNonceCall {
+        #[allow(missing_docs)]
+        pub _singleton: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub initializer: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub saltNonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createProxyWithNonce(address,bytes,
+    /// uint256)`](createProxyWithNonceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createProxyWithNonceReturn {
+        #[allow(missing_docs)]
+        pub proxy: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createProxyWithNonceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyWithNonceCall) -> Self {
+                    (value._singleton, value.initializer, value.saltNonce)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithNonceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _singleton: tuple.0,
+                        initializer: tuple.1,
+                        saltNonce: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createProxyWithNonceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyWithNonceReturn) -> Self {
+                    (value.proxy,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithNonceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { proxy: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createProxyWithNonceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 136u8, 240u8, 185u8];
+            const SIGNATURE: &'static str = "createProxyWithNonce(address,bytes,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._singleton,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.initializer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.saltNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createProxyWithNonceReturn = r.into();
+                        r.proxy
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createProxyWithNonceReturn = r.into();
+                    r.proxy
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `proxyCreationCode()` and selector `0x53e5d935`.
+    ```solidity
+    function proxyCreationCode() external pure returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct proxyCreationCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`proxyCreationCode()`](proxyCreationCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct proxyCreationCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<proxyCreationCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: proxyCreationCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyCreationCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<proxyCreationCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: proxyCreationCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyCreationCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for proxyCreationCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [83u8, 229u8, 217u8, 53u8];
+            const SIGNATURE: &'static str = "proxyCreationCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: proxyCreationCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: proxyCreationCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `proxyRuntimeCode()` and selector `0xaddacc0f`.
+    ```solidity
+    function proxyRuntimeCode() external pure returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct proxyRuntimeCodeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`proxyRuntimeCode()`](proxyRuntimeCodeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct proxyRuntimeCodeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<proxyRuntimeCodeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: proxyRuntimeCodeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyRuntimeCodeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<proxyRuntimeCodeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: proxyRuntimeCodeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyRuntimeCodeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for proxyRuntimeCodeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 218u8, 204u8, 15u8];
+            const SIGNATURE: &'static str = "proxyRuntimeCode()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: proxyRuntimeCodeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: proxyRuntimeCodeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`GnosisSafeProxyFactory`](self) function calls.
+    #[derive(Clone)]
+    pub enum GnosisSafeProxyFactoryCalls {
+        #[allow(missing_docs)]
+        calculateCreateProxyWithNonceAddress(calculateCreateProxyWithNonceAddressCall),
+        #[allow(missing_docs)]
+        createProxy(createProxyCall),
+        #[allow(missing_docs)]
+        createProxyWithCallback(createProxyWithCallbackCall),
+        #[allow(missing_docs)]
+        createProxyWithNonce(createProxyWithNonceCall),
+        #[allow(missing_docs)]
+        proxyCreationCode(proxyCreationCodeCall),
+        #[allow(missing_docs)]
+        proxyRuntimeCode(proxyRuntimeCodeCall),
+    }
+    impl GnosisSafeProxyFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [22u8, 136u8, 240u8, 185u8],
+            [37u8, 0u8, 81u8, 14u8],
+            [83u8, 229u8, 217u8, 53u8],
+            [97u8, 182u8, 154u8, 189u8],
+            [173u8, 218u8, 204u8, 15u8],
+            [209u8, 138u8, 245u8, 77u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <createProxyWithNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <proxyCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createProxyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createProxyWithCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(createProxyWithNonce),
+            ::core::stringify!(calculateCreateProxyWithNonceAddress),
+            ::core::stringify!(proxyCreationCode),
+            ::core::stringify!(createProxy),
+            ::core::stringify!(proxyRuntimeCode),
+            ::core::stringify!(createProxyWithCallback),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for GnosisSafeProxyFactoryCalls {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "GnosisSafeProxyFactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::calculateCreateProxyWithNonceAddress(_) => {
+                    <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::createProxy(_) => <createProxyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::createProxyWithCallback(_) => {
+                    <createProxyWithCallbackCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::createProxyWithNonce(_) => {
+                    <createProxyWithNonceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::proxyCreationCode(_) => {
+                    <proxyCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::proxyRuntimeCode(_) => {
+                    <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls>] = &[
+                {
+                    fn createProxyWithNonce(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeProxyFactoryCalls::createProxyWithNonce)
+                    }
+                    createProxyWithNonce
+                },
+                {
+                    fn calculateCreateProxyWithNonceAddress(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeProxyFactoryCalls::calculateCreateProxyWithNonceAddress,
+                            )
+                    }
+                    calculateCreateProxyWithNonceAddress
+                },
+                {
+                    fn proxyCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeProxyFactoryCalls::proxyCreationCode)
+                    }
+                    proxyCreationCode
+                },
+                {
+                    fn createProxy(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <createProxyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeProxyFactoryCalls::createProxy)
+                    }
+                    createProxy
+                },
+                {
+                    fn proxyRuntimeCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GnosisSafeProxyFactoryCalls::proxyRuntimeCode)
+                    }
+                    proxyRuntimeCode
+                },
+                {
+                    fn createProxyWithCallback(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GnosisSafeProxyFactoryCalls::createProxyWithCallback)
+                    }
+                    createProxyWithCallback
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                GnosisSafeProxyFactoryCalls,
+            >] = &[
+                {
+                    fn createProxyWithNonce(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeProxyFactoryCalls::createProxyWithNonce)
+                    }
+                    createProxyWithNonce
+                },
+                {
+                    fn calculateCreateProxyWithNonceAddress(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GnosisSafeProxyFactoryCalls::calculateCreateProxyWithNonceAddress,
+                            )
+                    }
+                    calculateCreateProxyWithNonceAddress
+                },
+                {
+                    fn proxyCreationCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeProxyFactoryCalls::proxyCreationCode)
+                    }
+                    proxyCreationCode
+                },
+                {
+                    fn createProxy(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <createProxyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GnosisSafeProxyFactoryCalls::createProxy)
+                    }
+                    createProxy
+                },
+                {
+                    fn proxyRuntimeCode(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GnosisSafeProxyFactoryCalls::proxyRuntimeCode)
+                    }
+                    proxyRuntimeCode
+                },
+                {
+                    fn createProxyWithCallback(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                        <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GnosisSafeProxyFactoryCalls::createProxyWithCallback)
+                    }
+                    createProxyWithCallback
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::calculateCreateProxyWithNonceAddress(inner) => {
+                    <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::createProxy(inner) => {
+                    <createProxyCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::createProxyWithCallback(inner) => {
+                    <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::createProxyWithNonce(inner) => {
+                    <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::proxyCreationCode(inner) => {
+                    <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::proxyRuntimeCode(inner) => {
+                    <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::calculateCreateProxyWithNonceAddress(inner) => {
+                    <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::createProxy(inner) => {
+                    <createProxyCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::createProxyWithCallback(inner) => {
+                    <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::createProxyWithNonce(inner) => {
+                    <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::proxyCreationCode(inner) => {
+                    <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::proxyRuntimeCode(inner) => {
+                    <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`GnosisSafeProxyFactory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum GnosisSafeProxyFactoryEvents {
+        #[allow(missing_docs)]
+        ProxyCreation(ProxyCreation),
+    }
+    impl GnosisSafeProxyFactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            79u8, 81u8, 250u8, 246u8, 196u8, 86u8, 31u8, 249u8, 95u8, 6u8, 118u8, 87u8, 228u8,
+            52u8, 57u8, 240u8, 248u8, 86u8, 217u8, 124u8, 4u8, 217u8, 236u8, 144u8, 112u8, 166u8,
+            25u8, 154u8, 212u8, 24u8, 226u8, 53u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<ProxyCreation as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(ProxyCreation)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for GnosisSafeProxyFactoryEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "GnosisSafeProxyFactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<ProxyCreation as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ProxyCreation as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ProxyCreation)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for GnosisSafeProxyFactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ProxyCreation(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ProxyCreation(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GnosisSafeProxyFactory`](self) contract instance.
+
+    See the [wrapper's documentation](`GnosisSafeProxyFactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GnosisSafeProxyFactoryInstance<P, N> {
+        GnosisSafeProxyFactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<GnosisSafeProxyFactoryInstance<P, N>>>
+    {
+        GnosisSafeProxyFactoryInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GnosisSafeProxyFactoryInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`GnosisSafeProxyFactory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GnosisSafeProxyFactory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GnosisSafeProxyFactoryInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GnosisSafeProxyFactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GnosisSafeProxyFactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeProxyFactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GnosisSafeProxyFactory`](self) contract instance.
+
+        See the [wrapper's documentation](`GnosisSafeProxyFactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<GnosisSafeProxyFactoryInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GnosisSafeProxyFactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GnosisSafeProxyFactoryInstance<P, N> {
+            GnosisSafeProxyFactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeProxyFactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the
+        /// [`calculateCreateProxyWithNonceAddress`] function.
+        pub fn calculateCreateProxyWithNonceAddress(
+            &self,
+            _singleton: alloy_sol_types::private::Address,
+            initializer: alloy_sol_types::private::Bytes,
+            saltNonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, calculateCreateProxyWithNonceAddressCall, N>
+        {
+            self.call_builder(&calculateCreateProxyWithNonceAddressCall {
+                _singleton,
+                initializer,
+                saltNonce,
+            })
+        }
+
+        ///Creates a new call builder for the [`createProxy`] function.
+        pub fn createProxy(
+            &self,
+            singleton: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, createProxyCall, N> {
+            self.call_builder(&createProxyCall { singleton, data })
+        }
+
+        ///Creates a new call builder for the [`createProxyWithCallback`]
+        /// function.
+        pub fn createProxyWithCallback(
+            &self,
+            _singleton: alloy_sol_types::private::Address,
+            initializer: alloy_sol_types::private::Bytes,
+            saltNonce: alloy_sol_types::private::primitives::aliases::U256,
+            callback: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createProxyWithCallbackCall, N> {
+            self.call_builder(&createProxyWithCallbackCall {
+                _singleton,
+                initializer,
+                saltNonce,
+                callback,
+            })
+        }
+
+        ///Creates a new call builder for the [`createProxyWithNonce`]
+        /// function.
+        pub fn createProxyWithNonce(
+            &self,
+            _singleton: alloy_sol_types::private::Address,
+            initializer: alloy_sol_types::private::Bytes,
+            saltNonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, createProxyWithNonceCall, N> {
+            self.call_builder(&createProxyWithNonceCall {
+                _singleton,
+                initializer,
+                saltNonce,
+            })
+        }
+
+        ///Creates a new call builder for the [`proxyCreationCode`] function.
+        pub fn proxyCreationCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, proxyCreationCodeCall, N> {
+            self.call_builder(&proxyCreationCodeCall)
+        }
+
+        ///Creates a new call builder for the [`proxyRuntimeCode`] function.
+        pub fn proxyRuntimeCode(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, proxyRuntimeCodeCall, N> {
+            self.call_builder(&proxyRuntimeCodeCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GnosisSafeProxyFactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`ProxyCreation`] event.
+        pub fn ProxyCreation_filter(&self) -> alloy_contract::Event<&P, ProxyCreation, N> {
+            self.event_filter::<ProxyCreation>()
+        }
+    }
+}
+pub type Instance =
+    GnosisSafeProxyFactory::GnosisSafeProxyFactoryInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/gpv2allowlistauthentication/Cargo.toml b/contracts/generated/contracts-generated/gpv2allowlistauthentication/Cargo.toml
new file mode 100644
index 0000000000..7fc05ddbbd
--- /dev/null
+++ b/contracts/generated/contracts-generated/gpv2allowlistauthentication/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gpv2allowlistauthentication"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs b/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
new file mode 100644
index 0000000000..68a54ea295
--- /dev/null
+++ b/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
@@ -0,0 +1,2815 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface GPv2AllowListAuthentication {
+    event ManagerChanged(address newManager, address oldManager);
+    event SolverAdded(address solver);
+    event SolverRemoved(address solver);
+
+    function addSolver(address solver) external;
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    function initializeManager(address manager_) external;
+    function isSolver(address prospectiveSolver) external view returns (bool);
+    function manager() external view returns (address);
+    function removeSolver(address solver) external;
+    function setManager(address manager_) external;
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "addSolver",
+    "inputs": [
+      {
+        "name": "solver",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getStorageAt",
+    "inputs": [
+      {
+        "name": "offset",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "initializeManager",
+    "inputs": [
+      {
+        "name": "manager_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isSolver",
+    "inputs": [
+      {
+        "name": "prospectiveSolver",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "manager",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "removeSolver",
+    "inputs": [
+      {
+        "name": "solver",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setManager",
+    "inputs": [
+      {
+        "name": "manager_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "simulateDelegatecall",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "simulateDelegatecallInternal",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "ManagerChanged",
+    "inputs": [
+      {
+        "name": "newManager",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "oldManager",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SolverAdded",
+    "inputs": [
+      {
+        "name": "solver",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SolverRemoved",
+    "inputs": [
+      {
+        "name": "solver",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2AllowListAuthentication {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[Pa\x0E\x10\x80a\0 `\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xA3W`\x005`\xE0\x1C\x80c\x7Fq \xFE\x11a\0vW\x80c\xD0\xEB\xDB\xE7\x11a\0[W\x80c\xD0\xEB\xDB\xE7\x14a\x02\xE3W\x80c\xECX\xF4\xB8\x14a\x03\x16W\x80c\xF8D6\xBD\x14a\x03IWa\0\xA3V[\x80c\x7Fq \xFE\x14a\x02{W\x80c\x8F\xD5{\x92\x14a\x02\xB0Wa\0\xA3V[\x80c\x02\xCC%\r\x14a\0\xA8W\x80cC!\x8E\x19\x14a\0\xEFW\x80cH\x1Cju\x14a\x02'W\x80cV$\xB2[\x14a\x02XW[`\0\x80\xFD[a\0\xDB`\x04\x806\x03` \x81\x10\x15a\0\xBEW`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x04\x0CV[`@\x80Q\x91\x15\x15\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x01\xB2`\x04\x806\x03`@\x81\x10\x15a\x01\x05W`\0\x80\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x825\x16\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x01=W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x01OW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x01qW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x047\x94PPPPPV[`@\x80Q` \x80\x82R\x83Q\x81\x83\x01R\x83Q\x91\x92\x83\x92\x90\x83\x01\x91\x85\x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x01\xECW\x81\x81\x01Q\x83\x82\x01R` \x01a\x01\xD4V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x02\x19W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x02/a\x05\xAFV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x01\xB2`\x04\x806\x03`@\x81\x10\x15a\x02nW`\0\x80\xFD[P\x805\x90` \x015a\x05\xD1V[a\x02\xAE`\x04\x806\x03` \x81\x10\x15a\x02\x91W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x06GV[\0[a\x02\xAE`\x04\x806\x03` \x81\x10\x15a\x02\xC6W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x07\xF8V[a\x02\xAE`\x04\x806\x03` \x81\x10\x15a\x02\xF9W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\t\x07V[a\x02\xAE`\x04\x806\x03` \x81\x10\x15a\x03,W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\nGV[a\x01\xB2`\x04\x806\x03`@\x81\x10\x15a\x03_W`\0\x80\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x825\x16\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x03\x97W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xA9W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03\xCBW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x0BZ\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16\x90V[```\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83`@Q\x80\x82\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a\x04\xA0W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a\x04cV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\x05\0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x05\x05V[``\x91P[P\x80\x93P\x81\x92PPPa\x05\xA8\x82\x82`@Q` \x01\x80\x83\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a\x05cW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a\x05&V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x82\x15\x15`\xF8\x1B\x81R`\x01\x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\r\xA3V[P\x92\x91PPV[`\0Tb\x01\0\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[```\0\x82` \x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x05\xEFW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x06\x1AW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\0[\x83\x81\x10\x15a\x06=W\x84\x81\x01T` \x80\x83\x02\x84\x01\x01R`\x01\x01a\x06 V[P\x90P[\x92\x91PPV[`\0Ta\x01\0\x90\x04`\xFF\x16\x80a\x06`WPa\x06`a\r\xABV[\x80a\x06nWP`\0T`\xFF\x16\x15[a\x06\xD9W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInitializable: initialized\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0Ta\x01\0\x90\x04`\xFF\x16\x15\x80\x15a\x07?W`\0\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\x90\x91\x16a\x01\0\x17\x16`\x01\x17\x90U[`\0\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\xFF\x16b\x01\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x90\x81\x02\x91\x90\x91\x17\x82U`@\x80Q\x91\x82R` \x82\x01\x92\x90\x92R\x81Q\x7F`\\-\xBFv._}`\xA5F\xD4.r\x05\xDC\xB1\xB0\x11\xEB\xC6*asjW\xC9\x08\x9D:CP\x92\x91\x81\x90\x03\x90\x91\x01\x90\xA1\x80\x15a\x07\xF4W`\0\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\x16\x90U[PPV[`\0Tb\x01\0\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x08\x84W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FGPv2: caller not manager\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`\0\x81\x81R`\x01` \x90\x81R`@\x91\x82\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x90U\x81Q\x92\x83R\x90Q\x7Fd\x0E\x18\xA2X~\x1D\x83\xE4\xFD\xAB\xF7\x02W\xD0\xA8\0\xCAK,\x1A\xAA\xD1\xDF\xC4\x85\xA4\xAD\x8B\xBB\xD6\xC6\x92\x81\x90\x03\x90\x91\x01\x90\xA1PV[`\0Tb\x01\0\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14\x80a\tOWP3a\t7a\r\xB1V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14[a\t\xBAW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FGPv2: not authorized\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16b\x01\0\0\x81\x81\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\xFF\x85\x16\x17\x90\x94U`@\x80Q\x91\x82R\x93\x90\x92\x04\x16` \x82\x01\x81\x90R\x82Q\x90\x92\x7F`\\-\xBFv._}`\xA5F\xD4.r\x05\xDC\xB1\xB0\x11\xEB\xC6*asjW\xC9\x08\x9D:CP\x92\x82\x90\x03\x01\x90\xA1PPV[`\0Tb\x01\0\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\n\xD3W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FGPv2: caller not manager\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`\0\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x90\x92\x17\x90\x91U\x81Q\x92\x83R\x90Q\x7FA\xF9\xD0\x9D\xD5\x15\x92Q\xF8\xA8\xE4\x82\xBB\xE0\x97\xB7\xC0\x1A^op\xC5\xA0\xDD\xB4\x94\x90dd\xFC\x9D\xD7\x92\x81\x90\x03\x90\x91\x01\x90\xA1PV[```\0cC!\x8E\x19`\xE0\x1B\x84\x84`@Q`$\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x0B\xC4W\x81\x81\x01Q\x83\x82\x01R` \x01a\x0B\xACV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x0B\xF1W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x98\x16\x97\x90\x97\x17\x87RQ\x81Q\x91\x97P0\x96\x88\x96P\x90\x94P\x84\x93P\x91P\x80\x83\x83[` \x83\x10a\x0C\xC2W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a\x0C\x85V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\r$W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\r)V[``\x91P[P\x90P\x80\x92PP`\0\x82`\x01\x84Q\x03\x81Q\x81\x10a\rBW\xFE[` \x01\x01Q`\xF8\x1C`\xF8\x1B~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\xF8\x1B\x14\x90Pa\r\x85\x83`\x01\x85Q\x03a\r\xD6V[\x80\x15a\r\x92WPPa\x06AV[a\r\x9B\x83a\r\xA3V[PP\x92\x91PPV[\x80Q` \x82\x01\xFD[0;\x15\x90V[\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03T\x90V[\x90RV\xFE\xA2dipfsX\"\x12 q\x06\xBA6\xB2\xD5\x18\xD8\x9A\\\xE8\x87\x05\xDD\x7FR\xD9\x8F:\x8C\x83\x8B\x8B\xB7\xAD\x9C\xDA\xA5\xB4%J\xB1dsolcC\0\x07\x06\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ManagerChanged(address,address)` and selector `0x605c2dbf762e5f7d60a546d42e7205dcb1b011ebc62a61736a57c9089d3a4350`.
+    ```solidity
+    event ManagerChanged(address newManager, address oldManager);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ManagerChanged {
+        #[allow(missing_docs)]
+        pub newManager: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub oldManager: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ManagerChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ManagerChanged(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    96u8, 92u8, 45u8, 191u8, 118u8, 46u8, 95u8, 125u8, 96u8, 165u8, 70u8, 212u8,
+                    46u8, 114u8, 5u8, 220u8, 177u8, 176u8, 17u8, 235u8, 198u8, 42u8, 97u8, 115u8,
+                    106u8, 87u8, 201u8, 8u8, 157u8, 58u8, 67u8, 80u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    newManager: data.0,
+                    oldManager: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newManager,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.oldManager,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ManagerChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ManagerChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ManagerChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SolverAdded(address)` and selector `0x41f9d09dd5159251f8a8e482bbe097b7c01a5e6f70c5a0ddb494906464fc9dd7`.
+    ```solidity
+    event SolverAdded(address solver);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SolverAdded {
+        #[allow(missing_docs)]
+        pub solver: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SolverAdded {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SolverAdded(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    65u8, 249u8, 208u8, 157u8, 213u8, 21u8, 146u8, 81u8, 248u8, 168u8, 228u8,
+                    130u8, 187u8, 224u8, 151u8, 183u8, 192u8, 26u8, 94u8, 111u8, 112u8, 197u8,
+                    160u8, 221u8, 180u8, 148u8, 144u8, 100u8, 100u8, 252u8, 157u8, 215u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { solver: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.solver,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SolverAdded {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SolverAdded> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SolverAdded) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SolverRemoved(address)` and selector `0x640e18a2587e1d83e4fdabf70257d0a800ca4b2c1aaad1dfc485a4ad8bbbd6c6`.
+    ```solidity
+    event SolverRemoved(address solver);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SolverRemoved {
+        #[allow(missing_docs)]
+        pub solver: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SolverRemoved {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SolverRemoved(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    100u8, 14u8, 24u8, 162u8, 88u8, 126u8, 29u8, 131u8, 228u8, 253u8, 171u8, 247u8,
+                    2u8, 87u8, 208u8, 168u8, 0u8, 202u8, 75u8, 44u8, 26u8, 170u8, 209u8, 223u8,
+                    196u8, 133u8, 164u8, 173u8, 139u8, 187u8, 214u8, 198u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { solver: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.solver,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SolverRemoved {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SolverRemoved> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SolverRemoved) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addSolver(address)` and selector `0xec58f4b8`.
+    ```solidity
+    function addSolver(address solver) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addSolverCall {
+        #[allow(missing_docs)]
+        pub solver: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`addSolver(address)`](addSolverCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addSolverReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addSolverCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addSolverCall) -> Self {
+                    (value.solver,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addSolverCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { solver: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addSolverReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addSolverReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addSolverReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl addSolverReturn {
+            fn _tokenize(&self) -> <addSolverCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addSolverCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = addSolverReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [236u8, 88u8, 244u8, 184u8];
+            const SIGNATURE: &'static str = "addSolver(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.solver,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addSolverReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
+    ```solidity
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtCall {
+        #[allow(missing_docs)]
+        pub offset: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub length: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtCall) -> Self {
+                    (value.offset, value.length)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        offset: tuple.0,
+                        length: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getStorageAtCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
+            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.offset,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.length,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getStorageAtReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getStorageAtReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `initializeManager(address)` and selector `0x7f7120fe`.
+    ```solidity
+    function initializeManager(address manager_) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeManagerCall {
+        #[allow(missing_docs)]
+        pub manager_: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`initializeManager(address)`](initializeManagerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeManagerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeManagerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeManagerCall) -> Self {
+                    (value.manager_,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeManagerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { manager_: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeManagerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeManagerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeManagerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl initializeManagerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <initializeManagerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for initializeManagerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = initializeManagerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 113u8, 32u8, 254u8];
+            const SIGNATURE: &'static str = "initializeManager(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.manager_,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                initializeManagerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isSolver(address)` and selector `0x02cc250d`.
+    ```solidity
+    function isSolver(address prospectiveSolver) external view returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSolverCall {
+        #[allow(missing_docs)]
+        pub prospectiveSolver: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isSolver(address)`](isSolverCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isSolverReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSolverCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isSolverCall) -> Self {
+                    (value.prospectiveSolver,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSolverCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        prospectiveSolver: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isSolverReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isSolverReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSolverReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isSolverCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 204u8, 37u8, 13u8];
+            const SIGNATURE: &'static str = "isSolver(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.prospectiveSolver,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isSolverReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isSolverReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `manager()` and selector `0x481c6a75`.
+    ```solidity
+    function manager() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct managerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`manager()`](managerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct managerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<managerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: managerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<managerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: managerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for managerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [72u8, 28u8, 106u8, 117u8];
+            const SIGNATURE: &'static str = "manager()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: managerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: managerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeSolver(address)` and selector `0x8fd57b92`.
+    ```solidity
+    function removeSolver(address solver) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeSolverCall {
+        #[allow(missing_docs)]
+        pub solver: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`removeSolver(address)`](removeSolverCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeSolverReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeSolverCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeSolverCall) -> Self {
+                    (value.solver,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeSolverCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { solver: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeSolverReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeSolverReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeSolverReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl removeSolverReturn {
+            fn _tokenize(&self) -> <removeSolverCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeSolverCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = removeSolverReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [143u8, 213u8, 123u8, 146u8];
+            const SIGNATURE: &'static str = "removeSolver(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.solver,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeSolverReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setManager(address)` and selector `0xd0ebdbe7`.
+    ```solidity
+    function setManager(address manager_) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setManagerCall {
+        #[allow(missing_docs)]
+        pub manager_: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setManager(address)`](setManagerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setManagerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setManagerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setManagerCall) -> Self {
+                    (value.manager_,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setManagerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { manager_: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setManagerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setManagerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setManagerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setManagerReturn {
+            fn _tokenize(&self) -> <setManagerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setManagerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setManagerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 235u8, 219u8, 231u8];
+            const SIGNATURE: &'static str = "setManager(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.manager_,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setManagerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
+    ```solidity
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
+            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateDelegatecallReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateDelegatecallInternal(address,bytes)` and selector `0x43218e19`.
+    ```solidity
+    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallInternalCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulateDelegatecallInternal(address,
+    /// bytes)`](simulateDelegatecallInternalCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallInternalReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallInternalCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallInternalCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallInternalReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallInternalReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateDelegatecallInternalCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [67u8, 33u8, 142u8, 25u8];
+            const SIGNATURE: &'static str = "simulateDelegatecallInternal(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallInternalReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateDelegatecallInternalReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    ///Container for all the [`GPv2AllowListAuthentication`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum GPv2AllowListAuthenticationCalls {
+        #[allow(missing_docs)]
+        addSolver(addSolverCall),
+        #[allow(missing_docs)]
+        getStorageAt(getStorageAtCall),
+        #[allow(missing_docs)]
+        initializeManager(initializeManagerCall),
+        #[allow(missing_docs)]
+        isSolver(isSolverCall),
+        #[allow(missing_docs)]
+        manager(managerCall),
+        #[allow(missing_docs)]
+        removeSolver(removeSolverCall),
+        #[allow(missing_docs)]
+        setManager(setManagerCall),
+        #[allow(missing_docs)]
+        simulateDelegatecall(simulateDelegatecallCall),
+        #[allow(missing_docs)]
+        simulateDelegatecallInternal(simulateDelegatecallInternalCall),
+    }
+    impl GPv2AllowListAuthenticationCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 204u8, 37u8, 13u8],
+            [67u8, 33u8, 142u8, 25u8],
+            [72u8, 28u8, 106u8, 117u8],
+            [86u8, 36u8, 178u8, 91u8],
+            [127u8, 113u8, 32u8, 254u8],
+            [143u8, 213u8, 123u8, 146u8],
+            [208u8, 235u8, 219u8, 231u8],
+            [236u8, 88u8, 244u8, 184u8],
+            [248u8, 68u8, 54u8, 189u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isSolverCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <managerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <initializeManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeSolverCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addSolverCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateDelegatecallCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isSolver),
+            ::core::stringify!(simulateDelegatecallInternal),
+            ::core::stringify!(manager),
+            ::core::stringify!(getStorageAt),
+            ::core::stringify!(initializeManager),
+            ::core::stringify!(removeSolver),
+            ::core::stringify!(setManager),
+            ::core::stringify!(addSolver),
+            ::core::stringify!(simulateDelegatecall),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for GPv2AllowListAuthenticationCalls {
+        const COUNT: usize = 9usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "GPv2AllowListAuthenticationCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::addSolver(_) => <addSolverCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::initializeManager(_) => {
+                    <initializeManagerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isSolver(_) => <isSolverCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::manager(_) => <managerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeSolver(_) => <removeSolverCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setManager(_) => <setManagerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::simulateDelegatecall(_) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::simulateDelegatecallInternal(_) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                GPv2AllowListAuthenticationCalls,
+            >] = &[
+                {
+                    fn isSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <isSolverCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::isSolver)
+                    }
+                    isSolver
+                },
+                {
+                    fn simulateDelegatecallInternal(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                GPv2AllowListAuthenticationCalls::simulateDelegatecallInternal,
+                            )
+                    }
+                    simulateDelegatecallInternal
+                },
+                {
+                    fn manager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <managerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::manager)
+                    }
+                    manager
+                },
+                {
+                    fn getStorageAt(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn initializeManager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <initializeManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::initializeManager)
+                    }
+                    initializeManager
+                },
+                {
+                    fn removeSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <removeSolverCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::removeSolver)
+                    }
+                    removeSolver
+                },
+                {
+                    fn setManager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <setManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::setManager)
+                    }
+                    setManager
+                },
+                {
+                    fn addSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <addSolverCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::addSolver)
+                    }
+                    addSolver
+                },
+                {
+                    fn simulateDelegatecall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2AllowListAuthenticationCalls::simulateDelegatecall)
+                    }
+                    simulateDelegatecall
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                GPv2AllowListAuthenticationCalls,
+            >] = &[
+                {
+                    fn isSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <isSolverCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2AllowListAuthenticationCalls::isSolver)
+                    }
+                    isSolver
+                },
+                {
+                    fn simulateDelegatecallInternal(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                GPv2AllowListAuthenticationCalls::simulateDelegatecallInternal,
+                            )
+                    }
+                    simulateDelegatecallInternal
+                },
+                {
+                    fn manager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <managerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2AllowListAuthenticationCalls::manager)
+                    }
+                    manager
+                },
+                {
+                    fn getStorageAt(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2AllowListAuthenticationCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn initializeManager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <initializeManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GPv2AllowListAuthenticationCalls::initializeManager)
+                    }
+                    initializeManager
+                },
+                {
+                    fn removeSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <removeSolverCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2AllowListAuthenticationCalls::removeSolver)
+                    }
+                    removeSolver
+                },
+                {
+                    fn setManager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <setManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2AllowListAuthenticationCalls::setManager)
+                    }
+                    setManager
+                },
+                {
+                    fn addSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <addSolverCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2AllowListAuthenticationCalls::addSolver)
+                    }
+                    addSolver
+                },
+                {
+                    fn simulateDelegatecall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
+                    {
+                        <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GPv2AllowListAuthenticationCalls::simulateDelegatecall)
+                    }
+                    simulateDelegatecall
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::addSolver(inner) => {
+                    <addSolverCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::initializeManager(inner) => {
+                    <initializeManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::isSolver(inner) => {
+                    <isSolverCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::manager(inner) => {
+                    <managerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeSolver(inner) => {
+                    <removeSolverCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setManager(inner) => {
+                    <setManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulateDelegatecall(inner) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulateDelegatecallInternal(inner) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::addSolver(inner) => {
+                    <addSolverCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::initializeManager(inner) => {
+                    <initializeManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::isSolver(inner) => {
+                    <isSolverCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::manager(inner) => {
+                    <managerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeSolver(inner) => {
+                    <removeSolverCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setManager(inner) => {
+                    <setManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::simulateDelegatecall(inner) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::simulateDelegatecallInternal(inner) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`GPv2AllowListAuthentication`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum GPv2AllowListAuthenticationEvents {
+        #[allow(missing_docs)]
+        ManagerChanged(ManagerChanged),
+        #[allow(missing_docs)]
+        SolverAdded(SolverAdded),
+        #[allow(missing_docs)]
+        SolverRemoved(SolverRemoved),
+    }
+    impl GPv2AllowListAuthenticationEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                65u8, 249u8, 208u8, 157u8, 213u8, 21u8, 146u8, 81u8, 248u8, 168u8, 228u8, 130u8,
+                187u8, 224u8, 151u8, 183u8, 192u8, 26u8, 94u8, 111u8, 112u8, 197u8, 160u8, 221u8,
+                180u8, 148u8, 144u8, 100u8, 100u8, 252u8, 157u8, 215u8,
+            ],
+            [
+                96u8, 92u8, 45u8, 191u8, 118u8, 46u8, 95u8, 125u8, 96u8, 165u8, 70u8, 212u8, 46u8,
+                114u8, 5u8, 220u8, 177u8, 176u8, 17u8, 235u8, 198u8, 42u8, 97u8, 115u8, 106u8,
+                87u8, 201u8, 8u8, 157u8, 58u8, 67u8, 80u8,
+            ],
+            [
+                100u8, 14u8, 24u8, 162u8, 88u8, 126u8, 29u8, 131u8, 228u8, 253u8, 171u8, 247u8,
+                2u8, 87u8, 208u8, 168u8, 0u8, 202u8, 75u8, 44u8, 26u8, 170u8, 209u8, 223u8, 196u8,
+                133u8, 164u8, 173u8, 139u8, 187u8, 214u8, 198u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <SolverAdded as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ManagerChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SolverRemoved as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(SolverAdded),
+            ::core::stringify!(ManagerChanged),
+            ::core::stringify!(SolverRemoved),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for GPv2AllowListAuthenticationEvents {
+        const COUNT: usize = 3usize;
+        const NAME: &'static str = "GPv2AllowListAuthenticationEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<ManagerChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ManagerChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ManagerChanged)
+                }
+                Some(<SolverAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SolverAdded as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SolverAdded)
+                }
+                Some(<SolverRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SolverRemoved as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::SolverRemoved)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for GPv2AllowListAuthenticationEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ManagerChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SolverAdded(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::SolverRemoved(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ManagerChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SolverAdded(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::SolverRemoved(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2AllowListAuthentication`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2AllowListAuthenticationInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2AllowListAuthenticationInstance<P, N> {
+        GPv2AllowListAuthenticationInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<GPv2AllowListAuthenticationInstance<P, N>>,
+    > {
+        GPv2AllowListAuthenticationInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GPv2AllowListAuthenticationInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`GPv2AllowListAuthentication`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2AllowListAuthentication`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2AllowListAuthenticationInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2AllowListAuthenticationInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2AllowListAuthenticationInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2AllowListAuthenticationInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2AllowListAuthentication`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2AllowListAuthenticationInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<GPv2AllowListAuthenticationInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2AllowListAuthenticationInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2AllowListAuthenticationInstance<P, N> {
+            GPv2AllowListAuthenticationInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2AllowListAuthenticationInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`addSolver`] function.
+        pub fn addSolver(
+            &self,
+            solver: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, addSolverCall, N> {
+            self.call_builder(&addSolverCall { solver })
+        }
+
+        ///Creates a new call builder for the [`getStorageAt`] function.
+        pub fn getStorageAt(
+            &self,
+            offset: alloy_sol_types::private::primitives::aliases::U256,
+            length: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
+            self.call_builder(&getStorageAtCall { offset, length })
+        }
+
+        ///Creates a new call builder for the [`initializeManager`] function.
+        pub fn initializeManager(
+            &self,
+            manager_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, initializeManagerCall, N> {
+            self.call_builder(&initializeManagerCall { manager_ })
+        }
+
+        ///Creates a new call builder for the [`isSolver`] function.
+        pub fn isSolver(
+            &self,
+            prospectiveSolver: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isSolverCall, N> {
+            self.call_builder(&isSolverCall { prospectiveSolver })
+        }
+
+        ///Creates a new call builder for the [`manager`] function.
+        pub fn manager(&self) -> alloy_contract::SolCallBuilder<&P, managerCall, N> {
+            self.call_builder(&managerCall)
+        }
+
+        ///Creates a new call builder for the [`removeSolver`] function.
+        pub fn removeSolver(
+            &self,
+            solver: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, removeSolverCall, N> {
+            self.call_builder(&removeSolverCall { solver })
+        }
+
+        ///Creates a new call builder for the [`setManager`] function.
+        pub fn setManager(
+            &self,
+            manager_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setManagerCall, N> {
+            self.call_builder(&setManagerCall { manager_ })
+        }
+
+        ///Creates a new call builder for the [`simulateDelegatecall`]
+        /// function.
+        pub fn simulateDelegatecall(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallCall, N> {
+            self.call_builder(&simulateDelegatecallCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`simulateDelegatecallInternal`]
+        /// function.
+        pub fn simulateDelegatecallInternal(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallInternalCall, N> {
+            self.call_builder(&simulateDelegatecallInternalCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2AllowListAuthenticationInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`ManagerChanged`] event.
+        pub fn ManagerChanged_filter(&self) -> alloy_contract::Event<&P, ManagerChanged, N> {
+            self.event_filter::<ManagerChanged>()
+        }
+
+        ///Creates a new event filter for the [`SolverAdded`] event.
+        pub fn SolverAdded_filter(&self) -> alloy_contract::Event<&P, SolverAdded, N> {
+            self.event_filter::<SolverAdded>()
+        }
+
+        ///Creates a new event filter for the [`SolverRemoved`] event.
+        pub fn SolverRemoved_filter(&self) -> alloy_contract::Event<&P, SolverRemoved, N> {
+            self.event_filter::<SolverRemoved>()
+        }
+    }
+}
+pub type Instance =
+    GPv2AllowListAuthentication::GPv2AllowListAuthenticationInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(12593263u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(134254466u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(48173639u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(16465099u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(45854728u64),
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(2612937u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(21407137u64),
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(3439709u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(204702129u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(59891351u64),
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(34436840u64),
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(24333100u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
+            Some(4717469u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/gpv2settlement/Cargo.toml b/contracts/generated/contracts-generated/gpv2settlement/Cargo.toml
new file mode 100644
index 0000000000..846c1e3539
--- /dev/null
+++ b/contracts/generated/contracts-generated/gpv2settlement/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-gpv2settlement"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs b/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
new file mode 100644
index 0000000000..1bbdf44f2a
--- /dev/null
+++ b/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
@@ -0,0 +1,6224 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Interaction {
+    struct Data { address target; uint256 value; bytes callData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Interaction {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address target; uint256 value; bytes callData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (value.target, value.value, value.callData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    value: tuple.1,
+                    callData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address target,uint256 value,bytes callData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Interaction`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2InteractionInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2InteractionInstance<P, N> {
+        GPv2InteractionInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Interaction`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Interaction`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2InteractionInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2InteractionInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2InteractionInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Interaction`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2InteractionInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2InteractionInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2InteractionInstance<P, N> {
+            GPv2InteractionInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Trade {
+    struct Data { uint256 sellTokenIndex; uint256 buyTokenIndex; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; uint256 flags; uint256 executedAmount; bytes signature; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Trade {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { uint256 sellTokenIndex; uint256 buyTokenIndex; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; uint256 flags; uint256 executedAmount; bytes signature; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub sellTokenIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyTokenIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub validTo: u32,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub flags: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub executedAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            u32,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (
+                    value.sellTokenIndex,
+                    value.buyTokenIndex,
+                    value.receiver,
+                    value.sellAmount,
+                    value.buyAmount,
+                    value.validTo,
+                    value.appData,
+                    value.feeAmount,
+                    value.flags,
+                    value.executedAmount,
+                    value.signature,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    sellTokenIndex: tuple.0,
+                    buyTokenIndex: tuple.1,
+                    receiver: tuple.2,
+                    sellAmount: tuple.3,
+                    buyAmount: tuple.4,
+                    validTo: tuple.5,
+                    appData: tuple.6,
+                    feeAmount: tuple.7,
+                    flags: tuple.8,
+                    executedAmount: tuple.9,
+                    signature: tuple.10,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenIndex),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.flags),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.executedAmount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(uint256 sellTokenIndex,uint256 buyTokenIndex,address receiver,uint256 \
+                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
+                     feeAmount,uint256 flags,uint256 executedAmount,bytes signature)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sellTokenIndex,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyTokenIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.receiver,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.flags)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.executedAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signature,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellTokenIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyTokenIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.receiver,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.buyAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.validTo,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.appData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.flags)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.executedAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signature,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellTokenIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyTokenIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.receiver,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.buyAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.validTo,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.appData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.flags,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.executedAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signature,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Trade`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2TradeInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2TradeInstance<P, N> {
+        GPv2TradeInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Trade`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Trade`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2TradeInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2TradeInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2TradeInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2TradeInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Trade`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2TradeInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2TradeInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2TradeInstance<P, N> {
+            GPv2TradeInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2TradeInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2TradeInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IVault {
+    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IVault {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BatchSwapStep {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub assetInIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub assetOutIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<BatchSwapStep> for UnderlyingRustTuple<'_> {
+            fn from(value: BatchSwapStep) -> Self {
+                (
+                    value.poolId,
+                    value.assetInIndex,
+                    value.assetOutIndex,
+                    value.amount,
+                    value.userData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BatchSwapStep {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    poolId: tuple.0,
+                    assetInIndex: tuple.1,
+                    assetOutIndex: tuple.2,
+                    amount: tuple.3,
+                    userData: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for BatchSwapStep {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for BatchSwapStep {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetInIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetOutIndex),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for BatchSwapStep {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for BatchSwapStep {
+            const NAME: &'static str = "BatchSwapStep";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "BatchSwapStep(bytes32 poolId,uint256 assetInIndex,uint256 \
+                     assetOutIndex,uint256 amount,bytes userData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetInIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetOutIndex)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for BatchSwapStep {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetInIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetOutIndex,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetInIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetOutIndex,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
+
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library GPv2Interaction {
+    struct Data {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+}
+
+library GPv2Trade {
+    struct Data {
+        uint256 sellTokenIndex;
+        uint256 buyTokenIndex;
+        address receiver;
+        uint256 sellAmount;
+        uint256 buyAmount;
+        uint32 validTo;
+        bytes32 appData;
+        uint256 feeAmount;
+        uint256 flags;
+        uint256 executedAmount;
+        bytes signature;
+    }
+}
+
+library IVault {
+    struct BatchSwapStep {
+        bytes32 poolId;
+        uint256 assetInIndex;
+        uint256 assetOutIndex;
+        uint256 amount;
+        bytes userData;
+    }
+}
+
+interface GPv2Settlement {
+    event Interaction(address indexed target, uint256 value, bytes4 selector);
+    event OrderInvalidated(address indexed owner, bytes orderUid);
+    event PreSignature(address indexed owner, bytes orderUid, bool signed);
+    event Settlement(address indexed solver);
+    event Trade(address indexed owner, address sellToken, address buyToken, uint256 sellAmount, uint256 buyAmount, uint256 feeAmount, bytes orderUid);
+
+    constructor(address authenticator_, address vault_);
+
+    receive() external payable;
+
+    function authenticator() external view returns (address);
+    function domainSeparator() external view returns (bytes32);
+    function filledAmount(bytes memory) external view returns (uint256);
+    function freeFilledAmountStorage(bytes[] memory orderUids) external;
+    function freePreSignatureStorage(bytes[] memory orderUids) external;
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    function invalidateOrder(bytes memory orderUid) external;
+    function preSignature(bytes memory) external view returns (uint256);
+    function setPreSignature(bytes memory orderUid, bool signed) external;
+    function settle(address[] memory tokens, uint256[] memory clearingPrices, GPv2Trade.Data[] memory trades, GPv2Interaction.Data[][3] memory interactions) external;
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    function swap(IVault.BatchSwapStep[] memory swaps, address[] memory tokens, GPv2Trade.Data memory trade) external;
+    function vault() external view returns (address);
+    function vaultRelayer() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "authenticator_",
+        "type": "address",
+        "internalType": "contract GPv2Authentication"
+      },
+      {
+        "name": "vault_",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "authenticator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract GPv2Authentication"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "domainSeparator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "filledAmount",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "freeFilledAmountStorage",
+    "inputs": [
+      {
+        "name": "orderUids",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "freePreSignatureStorage",
+    "inputs": [
+      {
+        "name": "orderUids",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getStorageAt",
+    "inputs": [
+      {
+        "name": "offset",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "invalidateOrder",
+    "inputs": [
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "preSignature",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setPreSignature",
+    "inputs": [
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "signed",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "settle",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "clearingPrices",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "trades",
+        "type": "tuple[]",
+        "internalType": "struct GPv2Trade.Data[]",
+        "components": [
+          {
+            "name": "sellTokenIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyTokenIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "flags",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "executedAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "signature",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "interactions",
+        "type": "tuple[][3]",
+        "internalType": "struct GPv2Interaction.Data[][3]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "simulateDelegatecall",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "simulateDelegatecallInternal",
+    "inputs": [
+      {
+        "name": "targetContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "calldataPayload",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "response",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "swaps",
+        "type": "tuple[]",
+        "internalType": "struct IVault.BatchSwapStep[]",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "assetInIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assetOutIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "trade",
+        "type": "tuple",
+        "internalType": "struct GPv2Trade.Data",
+        "components": [
+          {
+            "name": "sellTokenIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyTokenIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "receiver",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "buyAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "validTo",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "appData",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "flags",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "executedAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "signature",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "vault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "vaultRelayer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract GPv2VaultRelayer"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "Interaction",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": false,
+        "internalType": "bytes4"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderInvalidated",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PreSignature",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      },
+      {
+        "name": "signed",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Settlement",
+    "inputs": [
+      {
+        "name": "solver",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Trade",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "sellToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "buyToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "feeAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "orderUid",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Settlement {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\0`@R4\x80\x15b\0\0\x12W`\0\x80\xFD[P`@Qb\0S\xEB8\x03\x80b\0S\xEB\x839\x81\x01`@\x81\x90Rb\0\x005\x91b\0\x01[V[`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x80\x83\x01\x91\x90\x91R\x7Fl\x85\xC03~\xBA\x16a2\x7F\x94\xF3\xBFF\xC8\xA7\xF91\x1AV?M\\\x94\x83bV\x7F]\x8E\xD6\x0C\x82\x84\x01R\x7F\xF9Dk\x8E\x93}\x86\xF0\xBC\x87\xCA\xC79#I\x16\x92\xB1#\xCA_\x87a\x90\x84\x94p7X j\xDF``\x80\x84\x01\x91\x90\x91RF`\x80\x80\x85\x01\x91\x90\x91R0`\xA0\x80\x86\x01\x91\x90\x91R\x85Q\x80\x86\x03\x82\x01\x81R`\xC0\x95\x86\x01\x96\x87\x90R\x80Q\x94\x01\x93\x90\x93 \x90R`\x01\x80U`\x01`\x01``\x1B\x03\x19\x86\x82\x1B\x81\x16\x90\x92R\x84\x90\x1B\x16\x90R\x81\x90b\0\x01\n\x90b\0\x01MV[b\0\x01\x16\x91\x90b\0\x01\x99V[`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15b\0\x013W=`\0\x80>=`\0\xFD[P``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xE0RPb\0\x01\xC6\x90PV[a\x12\x9E\x80b\0AM\x839\x01\x90V[`\0\x80`@\x83\x85\x03\x12\x15b\0\x01nW\x81\x82\xFD[\x82Qb\0\x01{\x81b\0\x01\xADV[` \x84\x01Q\x90\x92Pb\0\x01\x8E\x81b\0\x01\xADV[\x80\x91PP\x92P\x92\x90PV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x01\xC3W`\0\x80\xFD[PV[`\x80Q`\xA0Q``\x1C`\xC0Q``\x1C`\xE0Q``\x1Ca?%b\0\x02(`\09\x80a\x04\xC5R\x80a\raR\x80a\x10\x90R\x80a\x15\xF0RP\x80a\x05VR\x80a\x15\x8BRP\x80a\x03\x92R\x80a\x06\xBCR\x80a\t\x9DRP\x80a\x13\x1ER\x80a#\xDFRPa?%`\0\xF3\xFE`\x80`@R`\x046\x10a\0\xECW`\x005`\xE0\x1C\x80c\x9BU,\xC2\x11a\0\x8AW\x80c\xED\x9F5\xCE\x11a\0YW\x80c\xED\x9F5\xCE\x14a\x02tW\x80c\xF6\x98\xDA%\x14a\x02\x94W\x80c\xF8D6\xBD\x14a\x02\xA9W\x80c\xFB\xFAw\xCF\x14a\x02\xC9Wa\0\xF3V[\x80c\x9BU,\xC2\x14a\x01\xFFW\x80c\xA2\xA7\xD5\x1B\x14a\x02\x14W\x80c\xD0\x8D3\xD1\x14a\x024W\x80c\xECl\xB1?\x14a\x02TWa\0\xF3V[\x80c$y\xFBn\x11a\0\xC6W\x80c$y\xFBn\x14a\x01eW\x80cC!\x8E\x19\x14a\x01\x92W\x80cV$\xB2[\x14a\x01\xBFW\x80c\x84Z\x10\x1F\x14a\x01\xDFWa\0\xF3V[\x80c\x13\xD7\x9A\x0B\x14a\0\xF8W\x80c\x153{\xC0\x14a\x01\x1AW\x80c#5\xC7k\x14a\x01:Wa\0\xF3V[6a\0\xF3W\0[`\0\x80\xFD[4\x80\x15a\x01\x04W`\0\x80\xFD[Pa\x01\x18a\x01\x136`\x04a2.V[a\x02\xDEV[\0[4\x80\x15a\x01&W`\0\x80\xFD[Pa\x01\x18a\x0156`\x04a4AV[a\x05\xC1V[4\x80\x15a\x01FW`\0\x80\xFD[Pa\x01Oa\x06\xBAV[`@Qa\x01\\\x91\x90a6\xEEV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01qW`\0\x80\xFD[Pa\x01\x85a\x01\x806`\x04a4\xCAV[a\x06\xDEV[`@Qa\x01\\\x91\x90a7\xF0V[4\x80\x15a\x01\x9EW`\0\x80\xFD[Pa\x01\xB2a\x01\xAD6`\x04a1\xA0V[a\x06\xFBV[`@Qa\x01\\\x91\x90a8\rV[4\x80\x15a\x01\xCBW`\0\x80\xFD[Pa\x01\xB2a\x01\xDA6`\x04a4\xFDV[a\x08sV[4\x80\x15a\x01\xEBW`\0\x80\xFD[Pa\x01\x18a\x01\xFA6`\x04a3\x8EV[a\x08\xE9V[4\x80\x15a\x02\x0BW`\0\x80\xFD[Pa\x01Oa\x10\x8EV[4\x80\x15a\x02 W`\0\x80\xFD[Pa\x01\x18a\x02/6`\x04a1\xEEV[a\x10\xB2V[4\x80\x15a\x02@W`\0\x80\xFD[Pa\x01\x85a\x02O6`\x04a4\xCAV[a\x10\xFBV[4\x80\x15a\x02`W`\0\x80\xFD[Pa\x01\x18a\x02o6`\x04a4uV[a\x11\x18V[4\x80\x15a\x02\x80W`\0\x80\xFD[Pa\x01\x18a\x02\x8F6`\x04a1\xEEV[a\x12\xD7V[4\x80\x15a\x02\xA0W`\0\x80\xFD[Pa\x01\x85a\x13\x1CV[4\x80\x15a\x02\xB5W`\0\x80\xFD[Pa\x01\xB2a\x02\xC46`\x04a1\xA0V[a\x13@V[4\x80\x15a\x02\xD5W`\0\x80\xFD[Pa\x01Oa\x15\x89V[`\x02`\x01T\x14\x15a\x03PW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FReentrancyGuard: reentrant call\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x02`\x01U`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x02\xCC%\r\x90a\x03\xC7\x903\x90`\x04\x01a6\xEEV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x03\xDFW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x03\xF3W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\x17\x91\x90a4%V[a\x04VW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a<xV[`@Q\x80\x91\x03\x90\xFD[a\x04r\x81`\0[` \x02\x81\x01\x90a\x04m\x91\x90a=\x16V[a\x15\xADV[`\0\x80a\x04\x83\x89\x89\x89\x89\x89\x89a\x16\xEAV[`@Q\x7F}\x10\xD1\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c}\x10\xD1\x1F\x90a\x04\xFA\x90\x85\x90`\x04\x01a7\x0FV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x05\x14W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x05(W=`\0\x80>=`\0\xFD[PPPPa\x05<\x83`\x01`\x03\x81\x10a\x04]W\xFE[a\x05|s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x82a\x18QV[a\x05\x87\x83`\x02a\x04]V[`@Q3\x90\x7F@3\x8C\xE1\xA7\xC4\x92\x04\xF0\t\x953\xB1\xE9\xA7\xEE\n=&\x1F\x84\x97J\xB7\xAF6\x10[\x8CN\x9D\xB4\x90`\0\x90\xA2PP`\x01\x80UPPPPPPPV[`\0a\x05\xCD\x83\x83a\x1B/V[P\x91PPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x163\x14a\x06 W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a:\x1BV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x02\x84\x84`@Qa\x06S\x92\x91\x90a6\xC2V[\x90\x81R` \x01`@Q\x80\x91\x03\x90 \x81\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x87[l\xB05\xBB\xD4\xACe\0\xFA\xBCm\x1EL\xA5\xBD\xC5\x8A>+BL\xCB\\$\xCD\xBE\xBE\xB0\t\xA9\x84\x84`@Qa\x06\xAD\x92\x91\x90a7\xF9V[`@Q\x80\x91\x03\x90\xA2PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[\x80Q` \x81\x83\x01\x81\x01\x80Q`\x02\x82R\x92\x82\x01\x91\x90\x93\x01 \x91RT\x81V[```\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83`@Q\x80\x82\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a\x07dW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a\x07'V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\x07\xC4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x07\xC9V[``\x91P[P\x80\x93P\x81\x92PPPa\x08l\x82\x82`@Q` \x01\x80\x83\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a\x08'W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a\x07\xEAV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x82\x15\x15`\xF8\x1B\x81R`\x01\x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1B\xBDV[P\x92\x91PPV[```\0\x82` \x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x08\x91W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x08\xBCW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P`\0[\x83\x81\x10\x15a\x08\xDFW\x84\x81\x01T` \x80\x83\x02\x84\x01\x01R`\x01\x01a\x08\xC2V[P\x90P[\x92\x91PPV[`\x02`\x01T\x14\x15a\t[W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FReentrancyGuard: reentrant call\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x02`\x01U`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x02\xCC%\r\x90a\t\xD2\x903\x90`\x04\x01a6\xEEV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\t\xEAW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\t\xFEW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\"\x91\x90a4%V[a\nXW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a<xV[`\0a\nba\x1B\xC5V[\x80Q\x90\x91Pa\ns\x82\x86\x86\x86a\x1B\xF2V[`\0\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x82a\x01\0\x01Q\x14a\n\xA8W`\x01a\n\xABV[`\0[\x90Pa\n\xB5a/\x90V[`@\x80\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x83Ra\x01@\x85\x01Q\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x90\x81\x14` \x85\x01R``\x80\x88\x01Q\x90\x92\x16\x92\x84\x01\x92\x90\x92Ra\x01`\x85\x01Q\x90\x91\x14\x90\x82\x01R`\0\x86g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x0B:W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0BdW\x81` \x01` \x82\x02\x806\x837\x01\x90P[Pa\x01\0\x85\x01Q\x90\x91Pa\x01 \x87\x015\x90\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x14\x15a\x0C0W\x84`\x80\x01Q\x81\x10\x15a\x0B\xDAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a<AV[a\x0B\xE7\x85``\x01Qa\x1C\x90V[\x82\x88`\0\x015\x81Q\x81\x10a\x0B\xF7W\xFE[` \x02` \x01\x01\x81\x81RPPa\x0C\x0C\x81a\x1C\x90V[`\0\x03\x82\x88` \x015\x81Q\x81\x10a\x0C\x1FW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0C\xC0V[\x84``\x01Q\x81\x11\x15a\x0CnW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;\x9CV[a\x0Cw\x81a\x1C\x90V[\x82\x88`\0\x015\x81Q\x81\x10a\x0C\x87W\xFE[` \x02` \x01\x01\x81\x81RPPa\x0C\xA0\x85`\x80\x01Qa\x1C\x90V[`\0\x03\x82\x88` \x015\x81Q\x81\x10a\x0C\xB3W\xFE[` \x02` \x01\x01\x81\x81RPP[a\x0C\xC8a/\x90V[\x86`@\x01Q\x81`\0\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x85`\0\x01Q\x81` \x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x85`\xE0\x01Q\x81`@\x01\x81\x81RPP\x85a\x01@\x01Q\x81``\x01\x81\x81RPP`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cH\x17\xA2\x86\x87\x8F\x8F\x8F\x8F\x8B\x8B\x8F`\xA0\x01Q\x8B`@Q\x8Ac\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\xCC\x99\x98\x97\x96\x95\x94\x93\x92\x91\x90a8wV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\r\xE6W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\r\xFAW=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x0E@\x91\x90\x81\x01\x90a2\xEDV[\x90P`\0\x88` \x01Q\x90P`\0a\x0Em\x83\x8C`\0\x015\x81Q\x81\x10a\x0E`W\xFE[` \x02` \x01\x01Qa\x1D%V[\x90P`\0a\x0E\x94\x84\x8D` \x015\x81Q\x81\x10a\x0E\x84W\xFE[` \x02` \x01\x01Q`\0\x03a\x1D%V[\x90P`\x02\x83`@Qa\x0E\xA6\x91\x90a6\xD2V[\x90\x81R` \x01`@Q\x80\x91\x03\x90 T`\0\x14a\x0E\xEEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;\xD3V[\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x8Aa\x01\0\x01Q\x14\x15a\x0F\x82W\x89``\x01Q\x82\x14a\x0FXW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a:\xC0V[\x89``\x01Q`\x02\x84`@Qa\x0Fm\x91\x90a6\xD2V[\x90\x81R`@Q\x90\x81\x90\x03` \x01\x90 Ua\x0F\xE5V[\x89`\x80\x01Q\x81\x14a\x0F\xBFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a:\xF7V[\x89`\x80\x01Q`\x02\x84`@Qa\x0F\xD4\x91\x90a6\xD2V[\x90\x81R`@Q\x90\x81\x90\x03` \x01\x90 U[\x8A`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA0zT:\xB8\xA0\x18\x19\x8E\x99\xCA\x01\x84\xC9?\xE9\x05\ny@\n\nr4A\xF8M\xE1\xD9r\xCC\x17\x8B`\0\x01Q\x8C` \x01Q\x85\x85\x8F`\xE0\x01Q\x89`@Qa\x10E\x96\x95\x94\x93\x92\x91\x90a8 V[`@Q\x80\x91\x03\x90\xA2`@Q3\x90\x7F@3\x8C\xE1\xA7\xC4\x92\x04\xF0\t\x953\xB1\xE9\xA7\xEE\n=&\x1F\x84\x97J\xB7\xAF6\x10[\x8CN\x9D\xB4\x90`\0\x90\xA2PP`\x01\x80UPPPPPPPPPPPPPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[03\x14a\x10\xEBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;eV[a\x10\xF7`\0\x83\x83a\x1D\x96V[PPV[\x80Q` \x81\x83\x01\x81\x01\x80Q`\0\x82R\x92\x82\x01\x91\x90\x93\x01 \x91RT\x81V[`\0a\x11$\x84\x84a\x1B/V[P\x91PPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x163\x14a\x11\xACW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FGPv2: cannot presign order\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81\x15a\x12\x06W\x7F\xF5\x9C\0\x92\x83\xFF\x87\xAAx ?\xC4\xD9\xC2\xDF\x02^\xE8Q\x13\x0F\xB6\x9C\xC3\xE0h\x94\x1Fk^-o`\0\x1C`\0\x85\x85`@Q\x80\x83\x83\x80\x82\x847\x80\x83\x01\x92PPP\x92PPP\x90\x81R` \x01`@Q\x80\x91\x03\x90 \x81\x90UPa\x122V[`\0\x80\x85\x85`@Q\x80\x83\x83\x80\x82\x847\x91\x90\x91\x01\x94\x85RPP`@Q\x92\x83\x90\x03` \x01\x90\x92 \x92\x90\x92UPP[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x01\xBF|\x8B\x0C\xA5]\xEE\xCB\xEA\x89\xD7\xE5\x82\x95\xB7\xFF\xBFh_\xD0\xD9h\x01\x03K\xA8\xC6\xFF\xE1\xC6\x8D\x85\x85\x85`@Q\x80\x80` \x01\x83\x15\x15\x81R` \x01\x82\x81\x03\x82R\x85\x85\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x83\x82\x01R`@Q`\x1F\x90\x91\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x90\x92\x01\x82\x90\x03\x96P\x90\x94PPPPP\xA2PPPPV[03\x14a\x13\x10W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;eV[a\x10\xF7`\x02\x83\x83a\x1D\x96V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[```\0cC!\x8E\x19`\xE0\x1B\x84\x84`@Q`$\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x13\xAAW\x81\x81\x01Q\x83\x82\x01R` \x01a\x13\x92V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x13\xD7W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x98\x16\x97\x90\x97\x17\x87RQ\x81Q\x91\x97P0\x96\x88\x96P\x90\x94P\x84\x93P\x91P\x80\x83\x83[` \x83\x10a\x14\xA8W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a\x14kV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x15\nW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x15\x0FV[``\x91P[P\x90P\x80\x92PP`\0\x82`\x01\x84Q\x03\x81Q\x81\x10a\x15(W\xFE[` \x01\x01Q`\xF8\x1C`\xF8\x1B~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01`\xF8\x1B\x14\x90Pa\x15k\x83`\x01\x85Q\x03a\x1EFV[\x80\x15a\x15xWPPa\x08\xE3V[a\x15\x81\x83a\x1B\xBDV[PP\x92\x91PPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0[\x81\x81\x10\x15a\x16\xE5W6\x83\x83\x83\x81\x81\x10a\x15\xC5W\xFE[\x90P` \x02\x81\x01\x90a\x15\xD7\x91\x90a=\xDEV[\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a\x16\x1D` \x83\x01\x83a1\x84V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x16kW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a<\xAFV[a\x16t\x81a\x1EJV[a\x16\x81` \x82\x01\x82a1\x84V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a\x16\xC6\x84a\x1E\xA1V[`@Qa\x16\xD4\x92\x91\x90a<\xE6V[`@Q\x80\x91\x03\x90\xA2P`\x01\x01a\x15\xB0V[PPPV[``\x80`\0a\x16\xF7a\x1B\xC5V[\x90P\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x17\x10W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17JW\x81` \x01[a\x177a/\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x17/W\x90P[P\x92P\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x17dW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x9EW\x81` \x01[a\x17\x8Ba/\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x17\x83W\x90P[P\x91P`\0[\x84\x81\x10\x15a\x18DW6\x86\x86\x83\x81\x81\x10a\x17\xB9W\xFE[\x90P` \x02\x81\x01\x90a\x17\xCB\x91\x90a>\x11V[\x90Pa\x17\xD9\x83\x8C\x8C\x84a\x1B\xF2V[a\x18;\x83\x8A\x8A\x845\x81\x81\x10a\x17\xEAW\xFE[\x90P` \x02\x015\x8B\x8B\x85` \x015\x81\x81\x10a\x18\x01W\xFE[\x90P` \x02\x015\x84a\x01 \x015\x89\x87\x81Q\x81\x10a\x18\x1AW\xFE[` \x02` \x01\x01Q\x89\x88\x81Q\x81\x10a\x18.W\xFE[` \x02` \x01\x01Qa\x1E\xCBV[P`\x01\x01a\x17\xA4V[PP\x96P\x96\x94PPPPPV[`\0\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x18kW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x18\xA5W\x81` \x01[a\x18\x92a/\xB7V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x18\x8AW\x90P[P\x90P`\0\x80[\x83Q\x81\x10\x15a\x1A\x93W`\0\x84\x82\x81Q\x81\x10a\x18\xC3W\xFE[` \x02` \x01\x01Q\x90Ps\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEEs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x19\xC7W\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x81``\x01Q\x14\x15a\x19wW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;.V[\x80Q`@\x80\x83\x01Q\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x81\x15a\x08\xFC\x02\x91\x90`\0\x81\x81\x81\x85\x88\x88\xF1\x93PPPP\x15\x80\x15a\x19\xC1W=`\0\x80>=`\0\xFD[Pa\x1A\x8AV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81``\x01Q\x14\x15a\x1A&W\x80Q`@\x82\x01Q` \x83\x01Qa\x1A!\x92s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x91a\"\x16V[a\x1A\x8AV[`\0\x84\x84\x80`\x01\x01\x95P\x81Q\x81\x10a\x1A:W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\0\x81R\x83\x82\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x92\x82\x01\x92\x90\x92R`@\x80\x85\x01Q\x90\x82\x01R0``\x82\x01R\x83Q\x90\x91\x16`\x80\x90\x91\x01RP[P`\x01\x01a\x18\xACV[P\x80\x15a\x1B)Wa\x1A\xA4\x82\x82a\x1EFV[`@Q\x7F\x0E\x8E>\x84\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x90c\x0E\x8E>\x84\x90a\x1A\xF6\x90\x85\x90`\x04\x01a7]V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x1B\x10W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1B$W=`\0\x80>=`\0\xFD[PPPP[PPPPV[`\0\x80\x80`8\x84\x14a\x1B\xA2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FGPv2: invalid uid\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PP\x825\x93` \x84\x015``\x1C\x93`4\x015`\xE0\x1C\x92P\x90PV[\x80Q` \x82\x01\xFD[a\x1B\xCDa/\xE7V[`@\x80Q`8\x80\x82R``\x82\x01\x90\x92R\x90` \x82\x01\x81\x806\x837PPP` \x82\x01R\x90V[\x83Q`\0a\x1C\x02\x83\x86\x86\x85a\"\xEEV[\x90P`\0\x80a\x1C\x1F\x84\x84a\x1C\x1Aa\x01@\x89\x01\x89a={V[a#\xD6V[\x91P\x91Pa\x1CB\x82\x82\x86`\xA0\x01Q\x8B` \x01Qa$\x85\x90\x93\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x89\x01Ra\x1Ch\x84\x82a%\x07V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16``\x90\x98\x01\x97\x90\x97RPPPPPPPV[`\0\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1D!W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FSafeCast: int256 overflow\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[P\x90V[`\0\x80\x82\x12\x15a\x1D!W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FSafeCast: not positive\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0[\x81\x81\x10\x15a\x1B)W6`\0\x84\x84\x84\x81\x81\x10a\x1D\xB0W\xFE[\x90P` \x02\x81\x01\x90a\x1D\xC2\x91\x90a={V[\x91P\x91P`\0a\x1D\xD2\x83\x83a\x1B/V[\x92PPPB\x81c\xFF\xFF\xFF\xFF\x16\x10a\x1E\x15W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a<\nV[`\0\x87\x84\x84`@Qa\x1E(\x92\x91\x90a6\xC2V[\x90\x81R`@Q\x90\x81\x90\x03` \x01\x90 UPP`\x01\x90\x91\x01\x90Pa\x1D\x99V[\x90RV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16` \x82\x0156`\0a\x1Ew`@\x86\x01\x86a={V[\x91P\x91P`@Q\x81\x83\x827`\0\x80\x83\x83\x87\x89Z\xF1a\x1E\x99W=`\0\x80>=`\0\xFD[PPPPPPV[`\x006\x81a\x1E\xB2`@\x85\x01\x85a={V[\x90\x92P\x90P`\x04\x81\x10a\x1E\xC4W\x815\x92P[PP\x91\x90PV[\x85Q` \x87\x01Q`\xA0\x82\x01QBc\xFF\xFF\xFF\xFF\x90\x91\x16\x10\x15a\x1F\x18W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a:RV[`\x80\x82\x01Qa\x1F'\x90\x87a%9V[``\x83\x01Qa\x1F6\x90\x89a%9V[\x10\x15a\x1FnW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a:\x89V[`\0\x80`\0\x80\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x86a\x01\0\x01Q\x14\x15a oW\x85a\x01 \x01Q\x15a\x1F\xDBW\x88\x93Pa\x1F\xD4\x86``\x01Qa\x1F\xCE\x86\x89`\xE0\x01Qa%9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90a%\xC9V[\x91Pa\x1F\xEAV[\x85``\x01Q\x93P\x85`\xE0\x01Q\x91P[a\x1F\xFE\x8Aa\x1F\xF8\x86\x8Ea%9V[\x90a&JV[\x92Pa *\x84`\x02\x87`@Qa \x14\x91\x90a6\xD2V[\x90\x81R`@Q\x90\x81\x90\x03` \x01\x90 T\x90a&\xE8V[\x90P\x85``\x01Q\x81\x11\x15a jW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;\xD3V[a!\x16V[\x85a\x01 \x01Q\x15a \xA3W\x88\x92Pa \x9C\x86`\x80\x01Qa\x1F\xCE\x85\x89`\xE0\x01Qa%9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91Pa \xB2V[\x85`\x80\x01Q\x92P\x85`\xE0\x01Q\x91P[a \xC0\x8Ba\x1F\xCE\x85\x8Da%9V[\x93Pa \xD6\x83`\x02\x87`@Qa \x14\x91\x90a6\xD2V[\x90P\x85`\x80\x01Q\x81\x11\x15a!\x16W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x04M\x90a;\xD3V[a! \x84\x83a&\xE8V[\x93P\x80`\x02\x86`@Qa!3\x91\x90a6\xD2V[\x90\x81R` \x01`@Q\x80\x91\x03\x90 \x81\x90UP\x8B`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA0zT:\xB8\xA0\x18\x19\x8E\x99\xCA\x01\x84\xC9?\xE9\x05\ny@\n\nr4A\xF8M\xE1\xD9r\xCC\x17\x87`\0\x01Q\x88` \x01Q\x87\x87\x87\x8B`@Qa!\xA1\x96\x95\x94\x93\x92\x91\x90a8 V[`@Q\x80\x91\x03\x90\xA2PP`@\x80\x8B\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x88R\x85Q\x81\x16` \x80\x8A\x01\x91\x90\x91R\x88\x83\x01\x94\x90\x94Ra\x01@\x86\x01Q``\x98\x89\x01R\x9A\x87\x01Q\x8B\x16\x86R\x82\x85\x01Q\x90\x9A\x16\x91\x85\x01\x91\x90\x91R\x97\x83\x01\x97\x90\x97Ra\x01`\x01Q\x91\x01RPPPPV[`@Q\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x83\x01R`$\x82\x01\x83\x90R\x90`\0\x80`D\x83\x82\x89Z\xF1a\"yW=`\0\x80>=`\0\xFD[Pa\"\x83\x84a'\\V[a\x1B)W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FGPv2: failed transfer\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x83\x83\x865\x81\x81\x10a\"\xFDW\xFE[` \x90\x81\x02\x92\x90\x92\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84RP\x84\x90\x84\x90\x87\x015\x81\x81\x10a#0W\xFE[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x91\x82\x02\x93\x90\x93\x015\x83\x16\x90\x85\x01RP`@\x80\x87\x015\x90\x91\x16\x90\x83\x01R``\x80\x86\x015\x90\x83\x01R`\x80\x80\x86\x015\x90\x83\x01Rc\xFF\xFF\xFF\xFF`\xA0\x80\x87\x015\x91\x90\x91\x16\x90\x83\x01R`\xC0\x80\x86\x015\x90\x83\x01R`\xE0\x80\x86\x015\x90\x83\x01Ra#\xACa\x01\0\x86\x015a(&V[a\x01`\x87\x01\x91\x90\x91Ra\x01@\x86\x01\x91\x90\x91R\x90\x15\x15a\x01 \x85\x01Ra\x01\0\x90\x93\x01RP\x93\x92PPPV[`\0\x80a$\x03\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a){V[\x91P`\0\x85`\x03\x81\x11\x15a$\x13W\xFE[\x14\x15a$+Wa$$\x82\x85\x85a*\x05V[\x90Pa$|V[`\x01\x85`\x03\x81\x11\x15a$9W\xFE[\x14\x15a$JWa$$\x82\x85\x85a*\x1AV[`\x02\x85`\x03\x81\x11\x15a$XW\xFE[\x14\x15a$iWa$$\x82\x85\x85a*\x82V[a$y\x82\x85\x85\x89`\xA0\x01Qa, V[\x90P[\x94P\x94\x92PPPV[`8\x84Q\x14a$\xF5W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGPv2: uid buffer overflow\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`8\x84\x01R`4\x83\x01R` \x90\x91\x01RV[`@\x82\x01Q`\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a%0WP\x80a\x08\xE3V[PP`@\x01Q\x90V[`\0\x82a%HWP`\0a\x08\xE3V[\x82\x82\x02\x82\x84\x82\x81a%UW\xFE[\x04\x14a%\xC2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FSafeMath: mul overflow\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x93\x92PPPV[`\0\x80\x82\x11a&9W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FSafeMath: division by 0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81\x83\x81a&BW\xFE[\x04\x93\x92PPPV[`\0\x80\x82\x11a&\xBAW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FSafeMath: ceiling division by 0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81\x83\x81a&\xC3W\xFE[\x06\x15a&\xD0W`\x01a&\xD3V[`\0[`\xFF\x16\x82\x84\x81a&\xDFW\xFE[\x04\x01\x93\x92PPPV[`\0\x82\x82\x01\x83\x81\x10\x15a%\xC2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FSafeMath: addition overflow\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0a'\x9AV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R` `\x04R\x80`$R\x81`DR`d`\0\xFD[=\x80\x15a'\xD9W` \x81\x14a(\x13Wa'\xD4\x7FGPv2: malformed transfer result\0`\x1Fa'cV[a( V[\x82;a(\nWa(\n\x7FGPv2: not a contract\0\0\0\0\0\0\0\0\0\0\0\0`\x14a'cV[`\x01\x91Pa( V[=`\0\x80>`\0Q\x15\x15\x91P[P\x91\x90PV[`\0\x80\x80\x80\x80`\x01\x86\x16a(\\W\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x94Pa(\x80V[\x7Fn\xD8\x8E\x86\x8A\xF0\xA1\x98>8\x86\xD5\xF3\xE9Z/\xAF\xBDl4P\xBC\"\x9E'4\"\x83\xDCB\x9C\xCC\x94P[`\x02\x86\x16\x15\x15\x93P`\x08\x86\x16a(\xB8W\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x92Pa)\x0CV[`\x04\x86\x16a(\xE8W\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x92Pa)\x0CV[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x92P[`\x10\x86\x16a)<W\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x91Pa)`V[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x91P[`\x05\x86\x90\x1C`\x03\x81\x11\x15a)pW\xFE[\x90P\x91\x93\x95\x90\x92\x94PV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x91\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x90 \x90V[`\0a*\x12\x84\x84\x84a-\xE5V[\x94\x93PPPPV[`\0\x80\x84`@Q` \x01\x80\x80\x7F\x19Ethereum Signed Message:\n32\0\0\0\0\x81RP`\x1C\x01\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90Pa*y\x81\x85\x85a-\xE5V[\x95\x94PPPPPV[\x815``\x1C6`\0a*\x97\x84`\x14\x81\x88a>hV[`@\x80Q\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\x82R`\x04\x82\x01\x8B\x81R`$\x83\x01\x93\x84R`D\x83\x01\x85\x90R\x94\x96P\x92\x94P\x91\x92s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x92c\x16&\xBA~\x92\x8B\x92\x88\x92\x88\x92\x90`d\x01\x84\x84\x80\x82\x847`\0\x83\x82\x01R`@Q`\x1F\x90\x91\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x90\x92\x01\x96P` \x95P\x90\x93PPP\x81\x84\x03\x90P\x81\x86\x80;\x15\x80\x15a+]W`\0\x80\xFD[PZ\xFA\x15\x80\x15a+qW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a+\x87W`\0\x80\xFD[PQ\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a,\x17W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FGPv2: invalid eip1271 signature\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PP\x93\x92PPPV[`\0`\x14\x83\x14a,\x91W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FGPv2: malformed presignature\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[P`@\x80Q`8\x80\x82R``\x82\x81\x01\x90\x93R\x855\x90\x92\x1C\x91`\0\x91\x90` \x82\x01\x81\x806\x837\x01\x90PP\x90Pa,\xC8\x81\x87\x84\x86a$\x85V[\x7F\xF5\x9C\0\x92\x83\xFF\x87\xAAx ?\xC4\xD9\xC2\xDF\x02^\xE8Q\x13\x0F\xB6\x9C\xC3\xE0h\x94\x1Fk^-o`\0\x1C`\0\x82`@Q\x80\x82\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a-<W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a,\xFFV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP\x90\x81R` \x01`@Q\x80\x91\x03\x90 T\x14a-\xDCW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGPv2: order not presigned\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[P\x94\x93PPPPV[`\0`A\x82\x14a.VW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FGPv2: malformed ecdsa signature\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`@\x80Q`\0\x81R` \x81\x81\x01\x80\x84R\x87\x90R\x82\x86\x015`\xF8\x1C\x82\x84\x01\x81\x90R\x865``\x84\x01\x81\x90R\x82\x88\x015`\x80\x85\x01\x81\x90R\x94Q\x90\x94\x93\x91\x92`\x01\x92`\xA0\x80\x82\x01\x93\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x01\x92\x81\x90\x03\x90\x91\x01\x90\x85Z\xFA\x15\x80\x15a.\xD9W=`\0\x80>=`\0\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x94PPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16a/\x86W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FGPv2: invalid ecdsa signature\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPP\x93\x92PPPV[`@\x80Q`\x80\x81\x01\x82R`\0\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x91\x90\x91R\x90V[`@\x80Q`\xA0\x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x90\x91\x01R\x90V[`@Q\x80`\x80\x01`@R\x80a/\xFAa0\x14V[\x81R``` \x82\x01\x81\x90R`\0`@\x83\x01\x81\x90R\x91\x01R\x90V[`@\x80Qa\x01\x80\x81\x01\x82R`\0\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R\x90V[`\0\x80\x83`\x1F\x84\x01\x12a0\x89W\x81\x82\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xA0W\x81\x82\xFD[` \x83\x01\x91P\x83` \x80\x83\x02\x85\x01\x01\x11\x15a0\xBAW`\0\x80\xFD[\x92P\x92\x90PV[`\0\x80\x83`\x1F\x84\x01\x12a0\xD2W\x81\x82\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xE9W\x81\x82\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a0\xBAW`\0\x80\xFD[`\0\x82`\x1F\x83\x01\x12a1\x11W\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a1%W\xFE[a1V` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a>DV[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a1jW\x82\x83\xFD[\x81` \x85\x01` \x83\x017\x90\x81\x01` \x01\x91\x90\x91R\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a1\x95W\x80\x81\xFD[\x815a%\xC2\x81a>\xBCV[`\0\x80`@\x83\x85\x03\x12\x15a1\xB2W\x80\x81\xFD[\x825a1\xBD\x81a>\xBCV[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a1\xD8W\x81\x82\xFD[a1\xE4\x85\x82\x86\x01a1\x01V[\x91PP\x92P\x92\x90PV[`\0\x80` \x83\x85\x03\x12\x15a2\0W\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a2\x16W\x82\x83\xFD[a2\"\x85\x82\x86\x01a0xV[\x90\x96\x90\x95P\x93PPPPV[`\0\x80`\0\x80`\0\x80`\0`\x80\x88\x8A\x03\x12\x15a2HW\x82\x83\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a2_W\x84\x85\xFD[a2k\x8B\x83\x8C\x01a0xV[\x90\x99P\x97P` \x8A\x015\x91P\x80\x82\x11\x15a2\x83W\x84\x85\xFD[a2\x8F\x8B\x83\x8C\x01a0xV[\x90\x97P\x95P`@\x8A\x015\x91P\x80\x82\x11\x15a2\xA7W\x84\x85\xFD[a2\xB3\x8B\x83\x8C\x01a0xV[\x90\x95P\x93P``\x8A\x015\x91P\x80\x82\x11\x15a2\xCBW\x82\x83\xFD[P\x88\x01``\x81\x01\x8A\x10\x15a2\xDDW\x81\x82\xFD[\x80\x91PP\x92\x95\x98\x91\x94\x97P\x92\x95PV[`\0` \x80\x83\x85\x03\x12\x15a2\xFFW\x81\x82\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a3\x16W\x83\x84\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a3)W\x83\x84\xFD[\x81Q\x81\x81\x11\x15a35W\xFE[\x83\x81\x02\x91Pa3E\x84\x83\x01a>DV[\x81\x81R\x84\x81\x01\x90\x84\x86\x01\x84\x86\x01\x87\x01\x8A\x10\x15a3_W\x87\x88\xFD[\x87\x95P[\x83\x86\x10\x15a3\x81W\x80Q\x83R`\x01\x95\x90\x95\x01\x94\x91\x86\x01\x91\x86\x01a3cV[P\x98\x97PPPPPPPPV[`\0\x80`\0\x80`\0``\x86\x88\x03\x12\x15a3\xA5W\x80\x81\xFD[\x855g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a3\xBCW\x82\x83\xFD[a3\xC8\x89\x83\x8A\x01a0xV[\x90\x97P\x95P` \x88\x015\x91P\x80\x82\x11\x15a3\xE0W\x82\x83\xFD[a3\xEC\x89\x83\x8A\x01a0xV[\x90\x95P\x93P`@\x88\x015\x91P\x80\x82\x11\x15a4\x04W\x82\x83\xFD[P\x86\x01a\x01`\x81\x89\x03\x12\x15a4\x17W\x81\x82\xFD[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[`\0` \x82\x84\x03\x12\x15a46W\x80\x81\xFD[\x81Qa%\xC2\x81a>\xE1V[`\0\x80` \x83\x85\x03\x12\x15a4SW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4iW\x82\x83\xFD[a2\"\x85\x82\x86\x01a0\xC1V[`\0\x80`\0`@\x84\x86\x03\x12\x15a4\x89W\x80\x81\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4\x9FW\x81\x82\xFD[a4\xAB\x86\x82\x87\x01a0\xC1V[\x90\x94P\x92PP` \x84\x015a4\xBF\x81a>\xE1V[\x80\x91PP\x92P\x92P\x92V[`\0` \x82\x84\x03\x12\x15a4\xDBW\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4\xF1W\x81\x82\xFD[a*\x12\x84\x82\x85\x01a1\x01V[`\0\x80`@\x83\x85\x03\x12\x15a5\x0FW\x81\x82\xFD[PP\x805\x92` \x90\x91\x015\x91PV[`\0\x82\x84R` \x80\x85\x01\x94P\x82\x82[\x85\x81\x10\x15a5hW\x815a5@\x81a>\xBCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01a5-V[P\x94\x95\x94PPPPPV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15a5hW\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01a5\x86V[`\0\x82\x84R\x82\x82` \x86\x017\x80` \x84\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x85\x01\x16\x85\x01\x01\x90P\x93\x92PPPV[`\0\x81Q\x80\x84Ra6\x02\x81` \x86\x01` \x86\x01a>\x90V[`\x1F\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x92\x90\x92\x01` \x01\x92\x91PPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82Q\x16\x83R\x80` \x83\x01Q\x16` \x84\x01RP`@\x81\x01Q`@\x83\x01R``\x81\x01Q``\x83\x01RPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82Q\x16\x83R` \x82\x01Q\x15\x15` \x84\x01R\x80`@\x83\x01Q\x16`@\x84\x01RP``\x81\x01Q\x15\x15``\x83\x01RPPV[c\xFF\xFF\xFF\xFF\x16\x90RV[`\0\x82\x84\x837\x91\x01\x90\x81R\x91\x90PV[`\0\x82Qa6\xE4\x81\x84` \x87\x01a>\x90V[\x91\x90\x91\x01\x92\x91PPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x81R` \x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15a7QWa7>\x83\x85Qa64V[\x92\x84\x01\x92`\x80\x92\x90\x92\x01\x91`\x01\x01a7+V[P\x90\x96\x95PPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90`@\x90\x81\x85\x01\x90\x86\x84\x01\x85[\x82\x81\x10\x15a7\xE3W\x81Q\x80Q`\x04\x81\x10a7\x90W\xFE[\x85R\x80\x87\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x88\x87\x01R\x86\x82\x01Q\x87\x87\x01R``\x80\x83\x01Q\x82\x16\x90\x87\x01R`\x80\x91\x82\x01Q\x16\x90\x85\x01R`\xA0\x90\x93\x01\x92\x90\x85\x01\x90`\x01\x01a7zV[P\x91\x97\x96PPPPPPPV[\x90\x81R` \x01\x90V[`\0` \x82Ra*\x12` \x83\x01\x84\x86a5\xA2V[`\0` \x82Ra%\xC2` \x83\x01\x84a5\xEAV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x89\x16\x83R\x80\x88\x16` \x84\x01RP\x85`@\x83\x01R\x84``\x83\x01R\x83`\x80\x83\x01R`\xC0`\xA0\x83\x01Ra8k`\xC0\x83\x01\x84a5\xEAV[\x98\x97PPPPPPPPV[`\0a\x01\xA0\x82\x01`\x02\x8C\x10a8\x88W\xFE[\x8B\x83R` a\x01\xA0\x81\x85\x01R\x81\x8B\x83Ra\x01\xC0\x85\x01\x90Pa\x01\xC0\x82\x8D\x02\x86\x01\x01\x92P\x8C\x84[\x8D\x81\x10\x15a9\xB6W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE@\x87\x86\x03\x01\x83R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFFa\x8F6\x03\x01\x825\x12a9\x0CW\x85\x86\xFD[\x8E\x825\x01\x805\x86R\x84\x81\x015\x85\x87\x01R`@\x81\x015`@\x87\x01R``\x81\x015``\x87\x01R`\x80\x81\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x826\x03\x01\x81\x12a9dW\x87\x88\xFD[\x81\x01\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9|W\x88\x89\xFD[\x806\x03\x83\x13\x15a9\x8AW\x88\x89\xFD[`\xA0`\x80\x89\x01Ra9\xA1`\xA0\x89\x01\x82\x89\x85\x01a5\xA2V[\x97PPP\x92\x84\x01\x92P\x90\x83\x01\x90`\x01\x01a8\xADV[PPPP\x82\x81\x03`@\x84\x01Ra9\xCD\x81\x89\x8Ba5\x1EV[\x90Pa9\xDC``\x84\x01\x88a6tV[\x82\x81\x03`\xE0\x84\x01Ra9\xEE\x81\x87a5sV[\x91PPa9\xFFa\x01\0\x83\x01\x85a6\xB8V[a:\ra\x01 \x83\x01\x84a64V[\x9A\x99PPPPPPPPPPV[` \x80\x82R`\x1F\x90\x82\x01R\x7FGPv2: caller does not own order\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x13\x90\x82\x01R\x7FGPv2: order expired\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x1F\x90\x82\x01R\x7FGPv2: limit price not respected\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x1F\x90\x82\x01R\x7FGPv2: sell amount not respected\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x1E\x90\x82\x01R\x7FGPv2: buy amount not respected\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x1E\x90\x82\x01R\x7FGPv2: unsupported internal ETH\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x18\x90\x82\x01R\x7FGPv2: not an interaction\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x14\x90\x82\x01R\x7FGPv2: limit too high\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x12\x90\x82\x01R\x7FGPv2: order filled\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x17\x90\x82\x01R\x7FGPv2: order still valid\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x13\x90\x82\x01R\x7FGPv2: limit too low\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x12\x90\x82\x01R\x7FGPv2: not a solver\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R`\x1B\x90\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`@\x82\x01R``\x01\x90V[\x91\x82R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16` \x82\x01R`@\x01\x90V[`\0\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=JW\x82\x83\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=dW\x82\x83\xFD[` \x90\x81\x01\x92P\x81\x026\x03\x82\x13\x15a0\xBAW`\0\x80\xFD[`\0\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xAFW\x82\x83\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xC9W\x82\x83\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a0\xBAW`\0\x80\xFD[`\0\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a6\xE4W\x81\x82\xFD[`\0\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE\xA1\x836\x03\x01\x81\x12a6\xE4W\x81\x82\xFD[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a>`W\xFE[`@R\x91\x90PV[`\0\x80\x85\x85\x11\x15a>wW\x81\x82\xFD[\x83\x86\x11\x15a>\x83W\x81\x82\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[`\0[\x83\x81\x10\x15a>\xABW\x81\x81\x01Q\x83\x82\x01R` \x01a>\x93V[\x83\x81\x11\x15a\x1B)WPP`\0\x91\x01RV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a>\xDEW`\0\x80\xFD[PV[\x80\x15\x15\x81\x14a>\xDEW`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xDE^I<H\xA3\xB4-\xA0:]\xB8\x90\x85\x17{\x8D\x8C\xCE\xC6\xE9\xBFn\x8EH\xB3\x80\x93CbL\x8FdsolcC\0\x07\x06\x003`\xC0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x12\x9E8\x03\x80a\x12\x9E\x839\x81\x01`@\x81\x90Ra\0/\x91a\0KV[3``\x90\x81\x1B`\x80R\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0Ra\0yV[`\0` \x82\x84\x03\x12\x15a\0\\W\x80\x81\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0rW\x81\x82\xFD[\x93\x92PPPV[`\x80Q``\x1C`\xA0Q``\x1Ca\x11\xEEa\0\xB0`\09\x80a\x010R\x80a\x02\x01R\x80a\x02\xBDRP\x80`\x93R\x80a\x02LRPa\x11\xEE`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x006W`\x005`\xE0\x1C\x80cH\x17\xA2\x86\x14a\0;W\x80c}\x10\xD1\x1F\x14a\0dW[`\0\x80\xFD[a\0Na\0I6`\x04a\x0C\xD9V[a\0yV[`@Qa\0[\x91\x90a\x0E\xB3V[`@Q\x80\x91\x03\x90\xF3[a\0wa\0r6`\x04a\x0CiV[a\x024V[\0[``3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\0\xF3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\0\xEA\x90a\x10\xE5V[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\x94[\xCE\xC9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\x94[\xCE\xC9\x90a\x01q\x90\x8C\x90\x8C\x90\x8C\x90\x8C\x90\x8C\x90\x8C\x90\x8C\x90`\x04\x01a\x0FYV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x01\x8BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x01\x9FW=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x01\xE5\x91\x90\x81\x01\x90a\x0B\xD9V[\x90Pa\x02(s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x833a\x02\xE9V[\x98\x97PPPPPPPPV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x02\xA3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\0\xEA\x90a\x10\xE5V[a\x02\xE5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83\x833a\x05QV[PPV[s\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEEa\x03\x0E`@\x84\x01` \x85\x01a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x03\\W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\0\xEA\x90a\x11\x1CV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x82``\x015\x14\x15a\x03\xD0Wa\x03\xCBa\x03\x98` \x84\x01\x84a\x0B\xB6V[\x82`@\x85\x01\x805\x90a\x03\xAD\x90` \x88\x01a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x08\x16V[a\x05LV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R`\0\x91\x81` \x01[a\x03\xEFa\t\xCBV[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x03\xE7W\x90PP\x90P`\0\x81`\0\x81Q\x81\x10a\x04\x13W\xFE[` \x02` \x01\x01Q\x90P\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x84``\x015\x14a\x04OW`\x02a\x04RV[`\x03[\x81\x90`\x03\x81\x11\x15a\x04_W\xFE[\x90\x81`\x03\x81\x11\x15a\x04lW\xFE[\x90RPa\x04\x7F`@\x85\x01` \x86\x01a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16` \x80\x83\x01\x91\x90\x91R`@\x80\x86\x015\x90\x83\x01Ra\x04\xB4\x90\x85\x01\x85a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16``\x83\x01R\x83\x81\x16`\x80\x83\x01R`@Q\x7F\x0E\x8E>\x84\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x90\x86\x16\x90c\x0E\x8E>\x84\x90a\x05\x17\x90\x85\x90`\x04\x01a\x0E\xC6V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x051W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x05EW=`\0\x80>=`\0\xFD[PPPPPP[PPPV[`\0\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x05jW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\xA4W\x81` \x01[a\x05\x91a\t\xCBV[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x05\x89W\x90P[P\x90P`\0\x80[\x84\x81\x10\x15a\x07xW6\x86\x86\x83\x81\x81\x10a\x05\xC0W\xFE[`\x80\x02\x91\x90\x91\x01\x91Ps\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\x90Pa\x05\xF0`@\x83\x01` \x84\x01a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x06>W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\0\xEA\x90a\x11\x1CV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81``\x015\x14\x15a\x06\x94Wa\x06\x8Fa\x06z` \x83\x01\x83a\x0B\xB6V[\x86`@\x84\x01\x805\x90a\x03\xAD\x90` \x87\x01a\x0B\xB6V[a\x07oV[`\0\x84\x84\x80`\x01\x01\x95P\x81Q\x81\x10a\x06\xA8W\xFE[` \x02` \x01\x01Q\x90P\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x82``\x015\x14a\x06\xE4W`\x01a\x06\xE7V[`\x03[\x81\x90`\x03\x81\x11\x15a\x06\xF4W\xFE[\x90\x81`\x03\x81\x11\x15a\x07\x01W\xFE[\x90RPa\x07\x14`@\x83\x01` \x84\x01a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16` \x80\x83\x01\x91\x90\x91R`@\x80\x84\x015\x90\x83\x01Ra\x07I\x90\x83\x01\x83a\x0B\xB6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16``\x83\x01R\x86\x16`\x80\x90\x91\x01R[P`\x01\x01a\x05\xABV[P\x80\x15a\x08\x0EWa\x07\x89\x82\x82a\x08\xFDV[`@Q\x7F\x0E\x8E>\x84\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x90c\x0E\x8E>\x84\x90a\x07\xDB\x90\x85\x90`\x04\x01a\x0E\xC6V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x07\xF5W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x08\tW=`\0\x80>=`\0\xFD[PPPP[PPPPPPV[`@Q\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`\x04\x84\x01R\x84\x16`$\x83\x01R`D\x82\x01\x83\x90R\x90`\0\x80`d\x83\x82\x8AZ\xF1a\x08\x81W=`\0\x80>=`\0\xFD[Pa\x08\x8B\x85a\t\x01V[a\x08\xF6W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGPv2: failed transferFrom\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPPPPV[\x90RV[`\0a\t?V[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R` `\x04R\x80`$R\x81`DR`d`\0\xFD[=\x80\x15a\t~W` \x81\x14a\t\xB8Wa\ty\x7FGPv2: malformed transfer result\0`\x1Fa\t\x08V[a\t\xC5V[\x82;a\t\xAFWa\t\xAF\x7FGPv2: not a contract\0\0\0\0\0\0\0\0\0\0\0\0`\x14a\t\x08V[`\x01\x91Pa\t\xC5V[=`\0\x80>`\0Q\x15\x15\x91P[P\x91\x90PV[`@\x80Q`\xA0\x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x90\x91\x01R\x90V[`\0\x82`\x1F\x83\x01\x12a\n\x0BW\x80\x81\xFD[\x815` a\n a\n\x1B\x83a\x11uV[a\x11QV[\x82\x81R\x81\x81\x01\x90\x85\x83\x01\x83\x85\x02\x87\x01\x84\x01\x88\x10\x15a\n<W\x85\x86\xFD[\x85[\x85\x81\x10\x15a\ncW\x815a\nQ\x81a\x11\x93V[\x84R\x92\x84\x01\x92\x90\x84\x01\x90`\x01\x01a\n>V[P\x90\x97\x96PPPPPPPV[`\0\x82`\x1F\x83\x01\x12a\n\x80W\x80\x81\xFD[\x815` a\n\x90a\n\x1B\x83a\x11uV[\x82\x81R\x81\x81\x01\x90\x85\x83\x01\x83\x85\x02\x87\x01\x84\x01\x88\x10\x15a\n\xACW\x85\x86\xFD[\x85[\x85\x81\x10\x15a\ncW\x815\x84R\x92\x84\x01\x92\x90\x84\x01\x90`\x01\x01a\n\xAEV[`\0\x80\x83`\x1F\x84\x01\x12a\n\xDBW\x81\x82\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF2W\x81\x82\xFD[` \x83\x01\x91P\x83` \x80\x83\x02\x85\x01\x01\x11\x15a\x0B\x0CW`\0\x80\xFD[\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x0B#W`\0\x80\xFD[\x91\x90PV[`\0`\x80\x82\x84\x03\x12\x15a\t\xC5W\x80\x81\xFD[`\0`\x80\x82\x84\x03\x12\x15a\x0BJW\x80\x81\xFD[`@Q`\x80\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x0BgW\xFE[`@R\x90P\x80\x825a\x0Bx\x81a\x11\x93V[\x81Ra\x0B\x86` \x84\x01a\x0B\x13V[` \x82\x01R`@\x83\x015a\x0B\x99\x81a\x11\x93V[`@\x82\x01Ra\x0B\xAA``\x84\x01a\x0B\x13V[``\x82\x01RP\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0B\xC7W\x80\x81\xFD[\x815a\x0B\xD2\x81a\x11\x93V[\x93\x92PPPV[`\0` \x80\x83\x85\x03\x12\x15a\x0B\xEBW\x81\x82\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\x01W\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x0C\x11W\x82\x83\xFD[\x80Qa\x0C\x1Fa\n\x1B\x82a\x11uV[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x89\x10\x15a\x0C;W\x86\x87\xFD[\x86\x94P[\x83\x85\x10\x15a\x0C]W\x80Q\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01a\x0C?V[P\x97\x96PPPPPPPV[`\0\x80` \x83\x85\x03\x12\x15a\x0C{W\x80\x81\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x0C\x92W\x82\x83\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x0C\xA5W\x82\x83\xFD[\x815\x81\x81\x11\x15a\x0C\xB3W\x83\x84\xFD[\x86` `\x80\x83\x02\x85\x01\x01\x11\x15a\x0C\xC7W\x83\x84\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[`\0\x80`\0\x80`\0\x80`\0\x80a\x01\xA0\x89\x8B\x03\x12\x15a\x0C\xF5W\x83\x84\xFD[\x885`\x02\x81\x10a\r\x03W\x84\x85\xFD[\x97P` \x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\r\x1FW\x85\x86\xFD[a\r+\x8C\x83\x8D\x01a\n\xCAV[\x90\x99P\x97P`@\x8B\x015\x91P\x80\x82\x11\x15a\rCW\x85\x86\xFD[a\rO\x8C\x83\x8D\x01a\t\xFBV[\x96Pa\r^\x8C``\x8D\x01a\x0B9V[\x95P`\xE0\x8B\x015\x91P\x80\x82\x11\x15a\rsW\x84\x85\xFD[Pa\r\x80\x8B\x82\x8C\x01a\npV[\x93PPa\x01\0\x89\x015\x91Pa\r\x99\x8Aa\x01 \x8B\x01a\x0B(V[\x90P\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15a\r\xEDW\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01a\r\xBBV[P\x94\x95\x94PPPPPV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15a\r\xEDW\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01a\x0E\x0BV[`\0\x82\x84R\x82\x82` \x86\x017\x80` \x84\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x85\x01\x16\x85\x01\x01\x90P\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82Q\x16\x83R` \x82\x01Q\x15\x15` \x84\x01R\x80`@\x83\x01Q\x16`@\x84\x01RP``\x81\x01Q\x15\x15``\x83\x01RPPV[`\0` \x82Ra\x0B\xD2` \x83\x01\x84a\r\xF8V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90`@\x90\x81\x85\x01\x90\x86\x84\x01\x85[\x82\x81\x10\x15a\x0FLW\x81Q\x80Q`\x04\x81\x10a\x0E\xF9W\xFE[\x85R\x80\x87\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x88\x87\x01R\x86\x82\x01Q\x87\x87\x01R``\x80\x83\x01Q\x82\x16\x90\x87\x01R`\x80\x91\x82\x01Q\x16\x90\x85\x01R`\xA0\x90\x93\x01\x92\x90\x85\x01\x90`\x01\x01a\x0E\xE3V[P\x91\x97\x96PPPPPPPV[`\0a\x01 \x80\x83\x01`\x02\x8B\x10a\x0FkW\xFE[\x8A\x84R` \x80\x85\x01\x92\x90\x92R\x88\x90Ra\x01@\x80\x84\x01\x91\x89\x81\x02\x85\x01\x90\x91\x01\x90\x8A\x84[\x8B\x81\x10\x15a\x10\x98W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE\xC0\x87\x85\x03\x01\x85R\x815\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFFa\x8E6\x03\x01\x81\x12a\x0F\xEDW\x86\x87\xFD[\x8D\x01\x805\x85R\x83\x81\x015\x84\x86\x01R`@\x80\x82\x015\x90\x86\x01R``\x80\x82\x015\x90\x86\x01R`\xA0`\x80\x80\x83\x0156\x84\x90\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x01\x81\x12a\x10GW\x89\x8A\xFD[\x83\x01\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10_W\x8A\x8B\xFD[\x806\x03\x85\x13\x15a\x10mW\x8A\x8B\xFD[\x83\x83\x8A\x01Ra\x10\x81\x84\x8A\x01\x82\x8A\x85\x01a\x0E'V[\x99\x88\x01\x99\x98PPP\x93\x85\x01\x93PPP`\x01\x01a\x0F\x8DV[PPP\x83\x81\x03`@\x85\x01Ra\x10\xAD\x81\x89a\r\xA8V[\x91PPa\x10\xBD``\x84\x01\x87a\x0EoV[\x82\x81\x03`\xE0\x84\x01Ra\x10\xCF\x81\x86a\r\xF8V[\x91PP\x82a\x01\0\x83\x01R\x98\x97PPPPPPPPV[` \x80\x82R`\x11\x90\x82\x01R\x7FGPv2: not creator\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01R``\x01\x90V[` \x80\x82R\x81\x81\x01R\x7FGPv2: cannot transfer native ETH`@\x82\x01R``\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x11mW\xFE[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x11\x89W\xFE[P` \x90\x81\x02\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xB5W`\0\x80\xFD[PV\xFE\xA2dipfsX\"\x12 6JiA\xBE\xA6\x96 \xB7\xDC:\x95}\n\xB4\xCB\xF3\xBF\xC4Y\xC7\xAD9$\xD2 b\n\xCA\x92\x02\xFCdsolcC\0\x07\x06\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Interaction(address,uint256,bytes4)` and selector `0xed99827efb37016f2275f98c4bcf71c7551c75d59e9b450f79fa32e60be672c2`.
+    ```solidity
+    event Interaction(address indexed target, uint256 value, bytes4 selector);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Interaction {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Interaction {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Interaction(address,uint256,bytes4)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    237u8, 153u8, 130u8, 126u8, 251u8, 55u8, 1u8, 111u8, 34u8, 117u8, 249u8, 140u8,
+                    75u8, 207u8, 113u8, 199u8, 85u8, 28u8, 117u8, 213u8, 158u8, 155u8, 69u8, 15u8,
+                    121u8, 250u8, 50u8, 230u8, 11u8, 230u8, 114u8, 194u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    target: topics.1,
+                    value: data.0,
+                    selector: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.target.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.target,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Interaction {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Interaction> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Interaction) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderInvalidated(address,bytes)` and selector `0x875b6cb035bbd4ac6500fabc6d1e4ca5bdc58a3e2b424ccb5c24cdbebeb009a9`.
+    ```solidity
+    event OrderInvalidated(address indexed owner, bytes orderUid);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderInvalidated {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderInvalidated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderInvalidated(address,bytes)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    135u8, 91u8, 108u8, 176u8, 53u8, 187u8, 212u8, 172u8, 101u8, 0u8, 250u8, 188u8,
+                    109u8, 30u8, 76u8, 165u8, 189u8, 197u8, 138u8, 62u8, 43u8, 66u8, 76u8, 203u8,
+                    92u8, 36u8, 205u8, 190u8, 190u8, 176u8, 9u8, 169u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    orderUid: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderInvalidated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderInvalidated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderInvalidated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PreSignature(address,bytes,bool)` and selector `0x01bf7c8b0ca55deecbea89d7e58295b7ffbf685fd0d96801034ba8c6ffe1c68d`.
+    ```solidity
+    event PreSignature(address indexed owner, bytes orderUid, bool signed);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PreSignature {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub signed: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PreSignature {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PreSignature(address,bytes,bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    1u8, 191u8, 124u8, 139u8, 12u8, 165u8, 93u8, 238u8, 203u8, 234u8, 137u8, 215u8,
+                    229u8, 130u8, 149u8, 183u8, 255u8, 191u8, 104u8, 95u8, 208u8, 217u8, 104u8,
+                    1u8, 3u8, 75u8, 168u8, 198u8, 255u8, 225u8, 198u8, 141u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    orderUid: data.0,
+                    signed: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.signed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PreSignature {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PreSignature> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PreSignature) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Settlement(address)` and selector `0x40338ce1a7c49204f0099533b1e9a7ee0a3d261f84974ab7af36105b8c4e9db4`.
+    ```solidity
+    event Settlement(address indexed solver);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Settlement {
+        #[allow(missing_docs)]
+        pub solver: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Settlement {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Settlement(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    64u8, 51u8, 140u8, 225u8, 167u8, 196u8, 146u8, 4u8, 240u8, 9u8, 149u8, 51u8,
+                    177u8, 233u8, 167u8, 238u8, 10u8, 61u8, 38u8, 31u8, 132u8, 151u8, 74u8, 183u8,
+                    175u8, 54u8, 16u8, 91u8, 140u8, 78u8, 157u8, 180u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { solver: topics.1 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.solver.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.solver,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Settlement {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Settlement> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Settlement) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Trade(address,address,address,uint256,uint256,uint256,bytes)` and selector `0xa07a543ab8a018198e99ca0184c93fe9050a79400a0a723441f84de1d972cc17`.
+    ```solidity
+    event Trade(address indexed owner, address sellToken, address buyToken, uint256 sellAmount, uint256 buyAmount, uint256 feeAmount, bytes orderUid);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Trade {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub buyToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Trade {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "Trade(address,address,address,uint256,uint256,uint256,bytes)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 122u8, 84u8, 58u8, 184u8, 160u8, 24u8, 25u8, 142u8, 153u8, 202u8, 1u8,
+                    132u8, 201u8, 63u8, 233u8, 5u8, 10u8, 121u8, 64u8, 10u8, 10u8, 114u8, 52u8,
+                    65u8, 248u8, 77u8, 225u8, 217u8, 114u8, 204u8, 23u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    sellToken: data.0,
+                    buyToken: data.1,
+                    sellAmount: data.2,
+                    buyAmount: data.3,
+                    feeAmount: data.4,
+                    orderUid: data.5,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.buyToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.buyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Trade {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Trade> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Trade) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address authenticator_, address vault_);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub authenticator_: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub vault_: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.authenticator_, value.vault_)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        authenticator_: tuple.0,
+                        vault_: tuple.1,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.authenticator_,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault_,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `authenticator()` and selector `0x2335c76b`.
+    ```solidity
+    function authenticator() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct authenticatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`authenticator()`](authenticatorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct authenticatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<authenticatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: authenticatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for authenticatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<authenticatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: authenticatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for authenticatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for authenticatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 53u8, 199u8, 107u8];
+            const SIGNATURE: &'static str = "authenticator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: authenticatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: authenticatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `domainSeparator()` and selector `0xf698da25`.
+    ```solidity
+    function domainSeparator() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct domainSeparatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`domainSeparator()`](domainSeparatorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct domainSeparatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<domainSeparatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: domainSeparatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<domainSeparatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: domainSeparatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for domainSeparatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 152u8, 218u8, 37u8];
+            const SIGNATURE: &'static str = "domainSeparator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: domainSeparatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: domainSeparatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `filledAmount(bytes)` and selector `0x2479fb6e`.
+    ```solidity
+    function filledAmount(bytes memory) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct filledAmountCall(pub alloy_sol_types::private::Bytes);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`filledAmount(bytes)`](filledAmountCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct filledAmountReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<filledAmountCall> for UnderlyingRustTuple<'_> {
+                fn from(value: filledAmountCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for filledAmountCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<filledAmountReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: filledAmountReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for filledAmountReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for filledAmountCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [36u8, 121u8, 251u8, 110u8];
+            const SIGNATURE: &'static str = "filledAmount(bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: filledAmountReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: filledAmountReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `freeFilledAmountStorage(bytes[])` and selector `0xed9f35ce`.
+    ```solidity
+    function freeFilledAmountStorage(bytes[] memory orderUids) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct freeFilledAmountStorageCall {
+        #[allow(missing_docs)]
+        pub orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    ///Container type for the return parameters of the
+    /// [`freeFilledAmountStorage(bytes[])`](freeFilledAmountStorageCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct freeFilledAmountStorageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<freeFilledAmountStorageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: freeFilledAmountStorageCall) -> Self {
+                    (value.orderUids,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freeFilledAmountStorageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderUids: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<freeFilledAmountStorageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: freeFilledAmountStorageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freeFilledAmountStorageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl freeFilledAmountStorageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for freeFilledAmountStorageCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type Return = freeFilledAmountStorageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [237u8, 159u8, 53u8, 206u8];
+            const SIGNATURE: &'static str = "freeFilledAmountStorage(bytes[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bytes,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.orderUids
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                freeFilledAmountStorageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `freePreSignatureStorage(bytes[])` and selector `0xa2a7d51b`.
+    ```solidity
+    function freePreSignatureStorage(bytes[] memory orderUids) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct freePreSignatureStorageCall {
+        #[allow(missing_docs)]
+        pub orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    ///Container type for the return parameters of the
+    /// [`freePreSignatureStorage(bytes[])`](freePreSignatureStorageCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct freePreSignatureStorageReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<freePreSignatureStorageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: freePreSignatureStorageCall) -> Self {
+                    (value.orderUids,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freePreSignatureStorageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderUids: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<freePreSignatureStorageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: freePreSignatureStorageReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freePreSignatureStorageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl freePreSignatureStorageReturn {
+            fn _tokenize(
+                &self,
+            ) -> <freePreSignatureStorageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for freePreSignatureStorageCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type Return = freePreSignatureStorageReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [162u8, 167u8, 213u8, 27u8];
+            const SIGNATURE: &'static str = "freePreSignatureStorage(bytes[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bytes,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.orderUids
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                freePreSignatureStorageReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
+    ```solidity
+    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtCall {
+        #[allow(missing_docs)]
+        pub offset: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub length: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getStorageAtReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtCall) -> Self {
+                    (value.offset, value.length)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        offset: tuple.0,
+                        length: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getStorageAtReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getStorageAtCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
+            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.offset,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.length,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getStorageAtReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getStorageAtReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `invalidateOrder(bytes)` and selector `0x15337bc0`.
+    ```solidity
+    function invalidateOrder(bytes memory orderUid) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateOrderCall {
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`invalidateOrder(bytes)`](invalidateOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateOrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrderCall) -> Self {
+                    (value.orderUid,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderUid: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl invalidateOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <invalidateOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for invalidateOrderCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = invalidateOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [21u8, 51u8, 123u8, 192u8];
+            const SIGNATURE: &'static str = "invalidateOrder(bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                invalidateOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `preSignature(bytes)` and selector `0xd08d33d1`.
+    ```solidity
+    function preSignature(bytes memory) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct preSignatureCall(pub alloy_sol_types::private::Bytes);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`preSignature(bytes)`](preSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct preSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<preSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: preSignatureCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<preSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: preSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for preSignatureCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 141u8, 51u8, 209u8];
+            const SIGNATURE: &'static str = "preSignature(bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: preSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: preSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setPreSignature(bytes,bool)` and selector `0xec6cb13f`.
+    ```solidity
+    function setPreSignature(bytes memory orderUid, bool signed) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPreSignatureCall {
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub signed: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`setPreSignature(bytes,bool)`](setPreSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setPreSignatureReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes, bool);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPreSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPreSignatureCall) -> Self {
+                    (value.orderUid, value.signed)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPreSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderUid: tuple.0,
+                        signed: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setPreSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPreSignatureReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPreSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setPreSignatureReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setPreSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setPreSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = setPreSignatureReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [236u8, 108u8, 177u8, 63u8];
+            const SIGNATURE: &'static str = "setPreSignature(bytes,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.signed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setPreSignatureReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `settle(address[],uint256[],(uint256,uint256,address,uint256,uint256,uint32,bytes32,uint256,uint256,uint256,bytes)[],(address,uint256,bytes)[][3])` and selector `0x13d79a0b`.
+    ```solidity
+    function settle(address[] memory tokens, uint256[] memory clearingPrices, GPv2Trade.Data[] memory trades, GPv2Interaction.Data[][3] memory interactions) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub clearingPrices:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub trades:
+            alloy_sol_types::private::Vec<<GPv2Trade::Data as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub interactions: [alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >; 3usize],
+    }
+    ///Container type for the return parameters of the
+    /// [`settle(address[],uint256[],(uint256,uint256,address,uint256,uint256,
+    /// uint32,bytes32,uint256,uint256,uint256,bytes)[],(address,uint256,
+    /// bytes)[][3])`](settleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<GPv2Trade::Data>,
+                alloy_sol_types::sol_data::FixedArray<
+                    alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                    3usize,
+                >,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<
+                    <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                [alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >; 3usize],
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleCall) -> Self {
+                    (
+                        value.tokens,
+                        value.clearingPrices,
+                        value.trades,
+                        value.interactions,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        clearingPrices: tuple.1,
+                        trades: tuple.2,
+                        interactions: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl settleReturn {
+            fn _tokenize(&self) -> <settleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<GPv2Trade::Data>,
+                alloy_sol_types::sol_data::FixedArray<
+                    alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                    3usize,
+                >,
+            );
+            type Return = settleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [19u8, 215u8, 154u8, 11u8];
+            const SIGNATURE: &'static str = "settle(address[],uint256[],(uint256,uint256,address,\
+                                             uint256,uint256,uint32,bytes32,uint256,uint256,\
+                                             uint256,bytes)[],(address,uint256,bytes)[][3])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.clearingPrices),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Trade::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self.trades),
+                    <alloy_sol_types::sol_data::FixedArray<
+                        alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                        3usize,
+                    > as alloy_sol_types::SolType>::tokenize(&self.interactions),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                settleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
+    ```solidity
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
+            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateDelegatecallReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `simulateDelegatecallInternal(address,bytes)` and selector `0x43218e19`.
+    ```solidity
+    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallInternalCall {
+        #[allow(missing_docs)]
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`simulateDelegatecallInternal(address,
+    /// bytes)`](simulateDelegatecallInternalCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct simulateDelegatecallInternalReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallInternalCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallInternalCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<simulateDelegatecallInternalReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallInternalReturn) -> Self {
+                    (value.response,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { response: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for simulateDelegatecallInternalCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [67u8, 33u8, 142u8, 25u8];
+            const SIGNATURE: &'static str = "simulateDelegatecallInternal(address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallInternalReturn = r.into();
+                        r.response
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: simulateDelegatecallInternalReturn = r.into();
+                    r.response
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swap((bytes32,uint256,uint256,uint256,bytes)[],address[],(uint256,uint256,address,uint256,uint256,uint32,bytes32,uint256,uint256,uint256,bytes))` and selector `0x845a101f`.
+    ```solidity
+    function swap(IVault.BatchSwapStep[] memory swaps, address[] memory tokens, GPv2Trade.Data memory trade) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub swaps: alloy_sol_types::private::Vec<
+            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub trade: <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`swap((bytes32,uint256,uint256,uint256,bytes)[],address[],(uint256,
+    /// uint256,address,uint256,uint256,uint32,bytes32,uint256,uint256,uint256,
+    /// bytes))`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                GPv2Trade::Data,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (value.swaps, value.tokens, value.trade)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        swaps: tuple.0,
+                        tokens: tuple.1,
+                        trade: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapReturn {
+            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                GPv2Trade::Data,
+            );
+            type Return = swapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [132u8, 90u8, 16u8, 31u8];
+            const SIGNATURE: &'static str = "swap((bytes32,uint256,uint256,uint256,bytes)[],\
+                                             address[],(uint256,uint256,address,uint256,uint256,\
+                                             uint32,bytes32,uint256,uint256,uint256,bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::BatchSwapStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <GPv2Trade::Data as alloy_sol_types::SolType>::tokenize(&self.trade),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `vault()` and selector `0xfbfa77cf`.
+    ```solidity
+    function vault() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct vaultCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`vault()`](vaultCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct vaultReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<vaultCall> for UnderlyingRustTuple<'_> {
+                fn from(value: vaultCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for vaultCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<vaultReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: vaultReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for vaultReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for vaultCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 250u8, 119u8, 207u8];
+            const SIGNATURE: &'static str = "vault()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: vaultReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: vaultReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `vaultRelayer()` and selector `0x9b552cc2`.
+    ```solidity
+    function vaultRelayer() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct vaultRelayerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`vaultRelayer()`](vaultRelayerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct vaultRelayerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<vaultRelayerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: vaultRelayerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for vaultRelayerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<vaultRelayerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: vaultRelayerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for vaultRelayerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for vaultRelayerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [155u8, 85u8, 44u8, 194u8];
+            const SIGNATURE: &'static str = "vaultRelayer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: vaultRelayerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: vaultRelayerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`GPv2Settlement`](self) function calls.
+    #[derive(Clone)]
+    pub enum GPv2SettlementCalls {
+        #[allow(missing_docs)]
+        authenticator(authenticatorCall),
+        #[allow(missing_docs)]
+        domainSeparator(domainSeparatorCall),
+        #[allow(missing_docs)]
+        filledAmount(filledAmountCall),
+        #[allow(missing_docs)]
+        freeFilledAmountStorage(freeFilledAmountStorageCall),
+        #[allow(missing_docs)]
+        freePreSignatureStorage(freePreSignatureStorageCall),
+        #[allow(missing_docs)]
+        getStorageAt(getStorageAtCall),
+        #[allow(missing_docs)]
+        invalidateOrder(invalidateOrderCall),
+        #[allow(missing_docs)]
+        preSignature(preSignatureCall),
+        #[allow(missing_docs)]
+        setPreSignature(setPreSignatureCall),
+        #[allow(missing_docs)]
+        settle(settleCall),
+        #[allow(missing_docs)]
+        simulateDelegatecall(simulateDelegatecallCall),
+        #[allow(missing_docs)]
+        simulateDelegatecallInternal(simulateDelegatecallInternalCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+        #[allow(missing_docs)]
+        vault(vaultCall),
+        #[allow(missing_docs)]
+        vaultRelayer(vaultRelayerCall),
+    }
+    impl GPv2SettlementCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [19u8, 215u8, 154u8, 11u8],
+            [21u8, 51u8, 123u8, 192u8],
+            [35u8, 53u8, 199u8, 107u8],
+            [36u8, 121u8, 251u8, 110u8],
+            [67u8, 33u8, 142u8, 25u8],
+            [86u8, 36u8, 178u8, 91u8],
+            [132u8, 90u8, 16u8, 31u8],
+            [155u8, 85u8, 44u8, 194u8],
+            [162u8, 167u8, 213u8, 27u8],
+            [208u8, 141u8, 51u8, 209u8],
+            [236u8, 108u8, 177u8, 63u8],
+            [237u8, 159u8, 53u8, 206u8],
+            [246u8, 152u8, 218u8, 37u8],
+            [248u8, 68u8, 54u8, 189u8],
+            [251u8, 250u8, 119u8, 207u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <settleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <invalidateOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <authenticatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <filledAmountCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <vaultRelayerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <freePreSignatureStorageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <preSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setPreSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <domainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <simulateDelegatecallCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <vaultCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(settle),
+            ::core::stringify!(invalidateOrder),
+            ::core::stringify!(authenticator),
+            ::core::stringify!(filledAmount),
+            ::core::stringify!(simulateDelegatecallInternal),
+            ::core::stringify!(getStorageAt),
+            ::core::stringify!(swap),
+            ::core::stringify!(vaultRelayer),
+            ::core::stringify!(freePreSignatureStorage),
+            ::core::stringify!(preSignature),
+            ::core::stringify!(setPreSignature),
+            ::core::stringify!(freeFilledAmountStorage),
+            ::core::stringify!(domainSeparator),
+            ::core::stringify!(simulateDelegatecall),
+            ::core::stringify!(vault),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for GPv2SettlementCalls {
+        const COUNT: usize = 15usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "GPv2SettlementCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::authenticator(_) => <authenticatorCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::domainSeparator(_) => {
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::filledAmount(_) => <filledAmountCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::freeFilledAmountStorage(_) => {
+                    <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::freePreSignatureStorage(_) => {
+                    <freePreSignatureStorageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::invalidateOrder(_) => {
+                    <invalidateOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::preSignature(_) => <preSignatureCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setPreSignature(_) => {
+                    <setPreSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::settle(_) => <settleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::simulateDelegatecall(_) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::simulateDelegatecallInternal(_) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::vault(_) => <vaultCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::vaultRelayer(_) => <vaultRelayerCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls>] = &[
+                {
+                    fn settle(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <settleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::settle)
+                    }
+                    settle
+                },
+                {
+                    fn invalidateOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <invalidateOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::invalidateOrder)
+                    }
+                    invalidateOrder
+                },
+                {
+                    fn authenticator(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <authenticatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::authenticator)
+                    }
+                    authenticator
+                },
+                {
+                    fn filledAmount(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <filledAmountCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::filledAmount)
+                    }
+                    filledAmount
+                },
+                {
+                    fn simulateDelegatecallInternal(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(GPv2SettlementCalls::simulateDelegatecallInternal)
+                    }
+                    simulateDelegatecallInternal
+                },
+                {
+                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn vaultRelayer(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <vaultRelayerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::vaultRelayer)
+                    }
+                    vaultRelayer
+                },
+                {
+                    fn freePreSignatureStorage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::freePreSignatureStorage)
+                    }
+                    freePreSignatureStorage
+                },
+                {
+                    fn preSignature(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <preSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::preSignature)
+                    }
+                    preSignature
+                },
+                {
+                    fn setPreSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <setPreSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::setPreSignature)
+                    }
+                    setPreSignature
+                },
+                {
+                    fn freeFilledAmountStorage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::freeFilledAmountStorage)
+                    }
+                    freeFilledAmountStorage
+                },
+                {
+                    fn domainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::domainSeparator)
+                    }
+                    domainSeparator
+                },
+                {
+                    fn simulateDelegatecall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::simulateDelegatecall)
+                    }
+                    simulateDelegatecall
+                },
+                {
+                    fn vault(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(GPv2SettlementCalls::vault)
+                    }
+                    vault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<GPv2SettlementCalls>] = &[
+                {
+                    fn settle(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <settleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2SettlementCalls::settle)
+                    }
+                    settle
+                },
+                {
+                    fn invalidateOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <invalidateOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::invalidateOrder)
+                    }
+                    invalidateOrder
+                },
+                {
+                    fn authenticator(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <authenticatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::authenticator)
+                    }
+                    authenticator
+                },
+                {
+                    fn filledAmount(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <filledAmountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::filledAmount)
+                    }
+                    filledAmount
+                },
+                {
+                    fn simulateDelegatecallInternal(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GPv2SettlementCalls::simulateDelegatecallInternal)
+                    }
+                    simulateDelegatecallInternal
+                },
+                {
+                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::getStorageAt)
+                    }
+                    getStorageAt
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2SettlementCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn vaultRelayer(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <vaultRelayerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::vaultRelayer)
+                    }
+                    vaultRelayer
+                },
+                {
+                    fn freePreSignatureStorage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GPv2SettlementCalls::freePreSignatureStorage)
+                    }
+                    freePreSignatureStorage
+                },
+                {
+                    fn preSignature(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <preSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::preSignature)
+                    }
+                    preSignature
+                },
+                {
+                    fn setPreSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <setPreSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::setPreSignature)
+                    }
+                    setPreSignature
+                },
+                {
+                    fn freeFilledAmountStorage(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GPv2SettlementCalls::freeFilledAmountStorage)
+                    }
+                    freeFilledAmountStorage
+                },
+                {
+                    fn domainSeparator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(GPv2SettlementCalls::domainSeparator)
+                    }
+                    domainSeparator
+                },
+                {
+                    fn simulateDelegatecall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(GPv2SettlementCalls::simulateDelegatecall)
+                    }
+                    simulateDelegatecall
+                },
+                {
+                    fn vault(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
+                        <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(GPv2SettlementCalls::vault)
+                    }
+                    vault
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::authenticator(inner) => {
+                    <authenticatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::domainSeparator(inner) => {
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::filledAmount(inner) => {
+                    <filledAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::freeFilledAmountStorage(inner) => {
+                    <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::freePreSignatureStorage(inner) => {
+                    <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::invalidateOrder(inner) => {
+                    <invalidateOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::preSignature(inner) => {
+                    <preSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setPreSignature(inner) => {
+                    <setPreSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::settle(inner) => {
+                    <settleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulateDelegatecall(inner) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::simulateDelegatecallInternal(inner) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::vault(inner) => {
+                    <vaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::vaultRelayer(inner) => {
+                    <vaultRelayerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::authenticator(inner) => {
+                    <authenticatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::domainSeparator(inner) => {
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::filledAmount(inner) => {
+                    <filledAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::freeFilledAmountStorage(inner) => {
+                    <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::freePreSignatureStorage(inner) => {
+                    <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getStorageAt(inner) => {
+                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::invalidateOrder(inner) => {
+                    <invalidateOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::preSignature(inner) => {
+                    <preSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setPreSignature(inner) => {
+                    <setPreSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::settle(inner) => {
+                    <settleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::simulateDelegatecall(inner) => {
+                    <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::simulateDelegatecallInternal(inner) => {
+                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::vault(inner) => {
+                    <vaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::vaultRelayer(inner) => {
+                    <vaultRelayerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`GPv2Settlement`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum GPv2SettlementEvents {
+        #[allow(missing_docs)]
+        Interaction(Interaction),
+        #[allow(missing_docs)]
+        OrderInvalidated(OrderInvalidated),
+        #[allow(missing_docs)]
+        PreSignature(PreSignature),
+        #[allow(missing_docs)]
+        Settlement(Settlement),
+        #[allow(missing_docs)]
+        Trade(Trade),
+    }
+    impl GPv2SettlementEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                1u8, 191u8, 124u8, 139u8, 12u8, 165u8, 93u8, 238u8, 203u8, 234u8, 137u8, 215u8,
+                229u8, 130u8, 149u8, 183u8, 255u8, 191u8, 104u8, 95u8, 208u8, 217u8, 104u8, 1u8,
+                3u8, 75u8, 168u8, 198u8, 255u8, 225u8, 198u8, 141u8,
+            ],
+            [
+                64u8, 51u8, 140u8, 225u8, 167u8, 196u8, 146u8, 4u8, 240u8, 9u8, 149u8, 51u8, 177u8,
+                233u8, 167u8, 238u8, 10u8, 61u8, 38u8, 31u8, 132u8, 151u8, 74u8, 183u8, 175u8,
+                54u8, 16u8, 91u8, 140u8, 78u8, 157u8, 180u8,
+            ],
+            [
+                135u8, 91u8, 108u8, 176u8, 53u8, 187u8, 212u8, 172u8, 101u8, 0u8, 250u8, 188u8,
+                109u8, 30u8, 76u8, 165u8, 189u8, 197u8, 138u8, 62u8, 43u8, 66u8, 76u8, 203u8, 92u8,
+                36u8, 205u8, 190u8, 190u8, 176u8, 9u8, 169u8,
+            ],
+            [
+                160u8, 122u8, 84u8, 58u8, 184u8, 160u8, 24u8, 25u8, 142u8, 153u8, 202u8, 1u8,
+                132u8, 201u8, 63u8, 233u8, 5u8, 10u8, 121u8, 64u8, 10u8, 10u8, 114u8, 52u8, 65u8,
+                248u8, 77u8, 225u8, 217u8, 114u8, 204u8, 23u8,
+            ],
+            [
+                237u8, 153u8, 130u8, 126u8, 251u8, 55u8, 1u8, 111u8, 34u8, 117u8, 249u8, 140u8,
+                75u8, 207u8, 113u8, 199u8, 85u8, 28u8, 117u8, 213u8, 158u8, 155u8, 69u8, 15u8,
+                121u8, 250u8, 50u8, 230u8, 11u8, 230u8, 114u8, 194u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <PreSignature as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Settlement as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderInvalidated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Trade as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Interaction as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(PreSignature),
+            ::core::stringify!(Settlement),
+            ::core::stringify!(OrderInvalidated),
+            ::core::stringify!(Trade),
+            ::core::stringify!(Interaction),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for GPv2SettlementEvents {
+        const COUNT: usize = 5usize;
+        const NAME: &'static str = "GPv2SettlementEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Interaction as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Interaction as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Interaction)
+                }
+                Some(<OrderInvalidated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderInvalidated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderInvalidated)
+                }
+                Some(<PreSignature as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PreSignature as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PreSignature)
+                }
+                Some(<Settlement as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Settlement as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Settlement)
+                }
+                Some(<Trade as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Trade as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Trade)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for GPv2SettlementEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Interaction(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OrderInvalidated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PreSignature(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Settlement(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Trade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Interaction(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderInvalidated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PreSignature(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Settlement(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Trade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Settlement`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2SettlementInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2SettlementInstance<P, N> {
+        GPv2SettlementInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        authenticator_: alloy_sol_types::private::Address,
+        vault_: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<GPv2SettlementInstance<P, N>>>
+    {
+        GPv2SettlementInstance::<P, N>::deploy(__provider, authenticator_, vault_)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        authenticator_: alloy_sol_types::private::Address,
+        vault_: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        GPv2SettlementInstance::<P, N>::deploy_builder(__provider, authenticator_, vault_)
+    }
+    /**A [`GPv2Settlement`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Settlement`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2SettlementInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2SettlementInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2SettlementInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2SettlementInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Settlement`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2SettlementInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            authenticator_: alloy_sol_types::private::Address,
+            vault_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<GPv2SettlementInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, authenticator_, vault_);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            authenticator_: alloy_sol_types::private::Address,
+            vault_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        authenticator_,
+                        vault_,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2SettlementInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2SettlementInstance<P, N> {
+            GPv2SettlementInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2SettlementInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`authenticator`] function.
+        pub fn authenticator(&self) -> alloy_contract::SolCallBuilder<&P, authenticatorCall, N> {
+            self.call_builder(&authenticatorCall)
+        }
+
+        ///Creates a new call builder for the [`domainSeparator`] function.
+        pub fn domainSeparator(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, domainSeparatorCall, N> {
+            self.call_builder(&domainSeparatorCall)
+        }
+
+        ///Creates a new call builder for the [`filledAmount`] function.
+        pub fn filledAmount(
+            &self,
+            _0: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, filledAmountCall, N> {
+            self.call_builder(&filledAmountCall(_0))
+        }
+
+        ///Creates a new call builder for the [`freeFilledAmountStorage`]
+        /// function.
+        pub fn freeFilledAmountStorage(
+            &self,
+            orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        ) -> alloy_contract::SolCallBuilder<&P, freeFilledAmountStorageCall, N> {
+            self.call_builder(&freeFilledAmountStorageCall { orderUids })
+        }
+
+        ///Creates a new call builder for the [`freePreSignatureStorage`]
+        /// function.
+        pub fn freePreSignatureStorage(
+            &self,
+            orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        ) -> alloy_contract::SolCallBuilder<&P, freePreSignatureStorageCall, N> {
+            self.call_builder(&freePreSignatureStorageCall { orderUids })
+        }
+
+        ///Creates a new call builder for the [`getStorageAt`] function.
+        pub fn getStorageAt(
+            &self,
+            offset: alloy_sol_types::private::primitives::aliases::U256,
+            length: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
+            self.call_builder(&getStorageAtCall { offset, length })
+        }
+
+        ///Creates a new call builder for the [`invalidateOrder`] function.
+        pub fn invalidateOrder(
+            &self,
+            orderUid: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, invalidateOrderCall, N> {
+            self.call_builder(&invalidateOrderCall { orderUid })
+        }
+
+        ///Creates a new call builder for the [`preSignature`] function.
+        pub fn preSignature(
+            &self,
+            _0: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, preSignatureCall, N> {
+            self.call_builder(&preSignatureCall(_0))
+        }
+
+        ///Creates a new call builder for the [`setPreSignature`] function.
+        pub fn setPreSignature(
+            &self,
+            orderUid: alloy_sol_types::private::Bytes,
+            signed: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, setPreSignatureCall, N> {
+            self.call_builder(&setPreSignatureCall { orderUid, signed })
+        }
+
+        ///Creates a new call builder for the [`settle`] function.
+        pub fn settle(
+            &self,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            clearingPrices: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+            trades: alloy_sol_types::private::Vec<
+                <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
+            >,
+            interactions: [alloy_sol_types::private::Vec<
+                <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+            >; 3usize],
+        ) -> alloy_contract::SolCallBuilder<&P, settleCall, N> {
+            self.call_builder(&settleCall {
+                tokens,
+                clearingPrices,
+                trades,
+                interactions,
+            })
+        }
+
+        ///Creates a new call builder for the [`simulateDelegatecall`]
+        /// function.
+        pub fn simulateDelegatecall(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallCall, N> {
+            self.call_builder(&simulateDelegatecallCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`simulateDelegatecallInternal`]
+        /// function.
+        pub fn simulateDelegatecallInternal(
+            &self,
+            targetContract: alloy_sol_types::private::Address,
+            calldataPayload: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallInternalCall, N> {
+            self.call_builder(&simulateDelegatecallInternalCall {
+                targetContract,
+                calldataPayload,
+            })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            swaps: alloy_sol_types::private::Vec<
+                <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+            >,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            trade: <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                swaps,
+                tokens,
+                trade,
+            })
+        }
+
+        ///Creates a new call builder for the [`vault`] function.
+        pub fn vault(&self) -> alloy_contract::SolCallBuilder<&P, vaultCall, N> {
+            self.call_builder(&vaultCall)
+        }
+
+        ///Creates a new call builder for the [`vaultRelayer`] function.
+        pub fn vaultRelayer(&self) -> alloy_contract::SolCallBuilder<&P, vaultRelayerCall, N> {
+            self.call_builder(&vaultRelayerCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2SettlementInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Interaction`] event.
+        pub fn Interaction_filter(&self) -> alloy_contract::Event<&P, Interaction, N> {
+            self.event_filter::<Interaction>()
+        }
+
+        ///Creates a new event filter for the [`OrderInvalidated`] event.
+        pub fn OrderInvalidated_filter(&self) -> alloy_contract::Event<&P, OrderInvalidated, N> {
+            self.event_filter::<OrderInvalidated>()
+        }
+
+        ///Creates a new event filter for the [`PreSignature`] event.
+        pub fn PreSignature_filter(&self) -> alloy_contract::Event<&P, PreSignature, N> {
+            self.event_filter::<PreSignature>()
+        }
+
+        ///Creates a new event filter for the [`Settlement`] event.
+        pub fn Settlement_filter(&self) -> alloy_contract::Event<&P, Settlement, N> {
+            self.event_filter::<Settlement>()
+        }
+
+        ///Creates a new event filter for the [`Trade`] event.
+        pub fn Trade_filter(&self) -> alloy_contract::Event<&P, Trade, N> {
+            self.event_filter::<Trade>()
+        }
+    }
+}
+pub type Instance = GPv2Settlement::GPv2SettlementInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(12593265u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(134254624u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(48173641u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(16465100u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(45859743u64),
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(2621745u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(21407238u64),
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(3439711u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(204704802u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(59891356u64),
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(34436849u64),
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(24333100u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
+            Some(4717488u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/honeyswaprouter/Cargo.toml b/contracts/generated/contracts-generated/honeyswaprouter/Cargo.toml
new file mode 100644
index 0000000000..efba40cf2f
--- /dev/null
+++ b/contracts/generated/contracts-generated/honeyswaprouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-honeyswaprouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs b/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs
new file mode 100644
index 0000000000..33f9dbf01d
--- /dev/null
+++ b/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs
@@ -0,0 +1,7545 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface HoneyswapRouter {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod HoneyswapRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`HoneyswapRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum HoneyswapRouterCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl HoneyswapRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for HoneyswapRouterCalls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "HoneyswapRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HoneyswapRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<HoneyswapRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(HoneyswapRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(HoneyswapRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(HoneyswapRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                HoneyswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(HoneyswapRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(HoneyswapRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(HoneyswapRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`HoneyswapRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`HoneyswapRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> HoneyswapRouterInstance<P, N> {
+        HoneyswapRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`HoneyswapRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`HoneyswapRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct HoneyswapRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for HoneyswapRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("HoneyswapRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        HoneyswapRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`HoneyswapRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`HoneyswapRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> HoneyswapRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> HoneyswapRouterInstance<P, N> {
+            HoneyswapRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        HoneyswapRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        HoneyswapRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = HoneyswapRouter::HoneyswapRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        100u64 => Some((
+            ::alloy_primitives::address!("0x1C232F01118CB8B424793ae03F870aa7D0ac7f77"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/hookstrampoline/Cargo.toml b/contracts/generated/contracts-generated/hookstrampoline/Cargo.toml
new file mode 100644
index 0000000000..b872d54cda
--- /dev/null
+++ b/contracts/generated/contracts-generated/hookstrampoline/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-hookstrampoline"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs b/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs
new file mode 100644
index 0000000000..bcc0cd0566
--- /dev/null
+++ b/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs
@@ -0,0 +1,1333 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface HooksTrampoline {
+    struct Hook {
+        address target;
+        bytes callData;
+        uint256 gasLimit;
+    }
+
+    error NotASettlement();
+
+    constructor(address settlement_);
+
+    function execute(Hook[] memory hooks) external;
+    function settlement() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "settlement_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "execute",
+    "inputs": [
+      {
+        "name": "hooks",
+        "type": "tuple[]",
+        "internalType": "struct HooksTrampoline.Hook[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "gasLimit",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "settlement",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "error",
+    "name": "NotASettlement",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod HooksTrampoline {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xA0`@R4\x80\x15a\0\x0FW_\x80\xFD[P`@Qa\x04}8\x03\x80a\x04}\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW_\x80\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW_\x80\xFD[\x93\x92PPPV[`\x80Qa\x03\xF4a\0\x89_9_\x81\x81`=\x01R`\xB5\x01Ra\x03\xF4_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80cQ\x16\x060\x14a\08W\x80cv\x0F*\x0B\x14a\0\x88W[_\x80\xFD[a\0_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\x9Ba\0\x966`\x04a\x02\x08V[a\0\x9DV[\0[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x01\x0CW`@Q\x7F\x0C\xD4\x1E\xC0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[6_[\x82\x81\x10\x15a\x01\xFCW\x83\x83\x82\x81\x81\x10a\x01)Wa\x01)a\x02wV[\x90P` \x02\x81\x01\x90a\x01;\x91\x90a\x02\xA4V[\x91P_`@Z`?\x02\x81a\x01QWa\x01Qa\x02\xE0V[\x04\x90P\x82`@\x015\x81\x10\x15a\x01hWa\x01ha\x02\x02V[_a\x01v` \x85\x01\x85a\x03\rV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`@\x85\x015a\x01\x9E` \x87\x01\x87a\x03GV[`@Qa\x01\xAC\x92\x91\x90a\x03\xAFV[_`@Q\x80\x83\x03\x81_\x87\x87\xF1\x92PPP=\x80_\x81\x14a\x01\xE6W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xEBV[``\x91P[PP\x90PPP\x80`\x01\x01\x90Pa\x01\x0FV[PPPPV[[a\x02\x03V[_\x80` \x83\x85\x03\x12\x15a\x02\x19W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x020W_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x02CW_\x80\xFD[\x815\x81\x81\x11\x15a\x02QW_\x80\xFD[\x86` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x02eW_\x80\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\x02\xD6W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x03\x1DW_\x80\xFD[\x815s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03@W_\x80\xFD[\x93\x92PPPV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x03zW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x03\x94W_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x03\xA8W_\x80\xFD[\x92P\x92\x90PV[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV\xFE\xA2dipfsX\"\x12 :\xECV\x97\x18D\xBF\x1B\xEFi$*\x1F\x8Eb\xBF\x0B\xC7\xF5G\x1D\xF2@\xE4\xD8\xB1\xEDAKR\xB7<dsolcC\0\x08\x14\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Hook { address target; bytes callData; uint256 gasLimit; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Hook {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub gasLimit: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Hook> for UnderlyingRustTuple<'_> {
+            fn from(value: Hook) -> Self {
+                (value.target, value.callData, value.gasLimit)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Hook {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    callData: tuple.1,
+                    gasLimit: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Hook {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Hook {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasLimit,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Hook {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Hook {
+            const NAME: &'static str = "Hook";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Hook(address target,bytes callData,uint256 gasLimit)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.gasLimit)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Hook {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.gasLimit,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.gasLimit,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotASettlement()` and selector `0x0cd41ec0`.
+    ```solidity
+    error NotASettlement();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NotASettlement;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NotASettlement> for UnderlyingRustTuple<'_> {
+            fn from(value: NotASettlement) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotASettlement {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NotASettlement {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [12u8, 212u8, 30u8, 192u8];
+            const SIGNATURE: &'static str = "NotASettlement()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address settlement_);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub settlement_: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.settlement_,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        settlement_: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlement_,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `execute((address,bytes,uint256)[])` and selector `0x760f2a0b`.
+    ```solidity
+    function execute(Hook[] memory hooks) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct executeCall {
+        #[allow(missing_docs)]
+        pub hooks: alloy_sol_types::private::Vec<<Hook as alloy_sol_types::SolType>::RustType>,
+    }
+    ///Container type for the return parameters of the
+    /// [`execute((address,bytes,uint256)[])`](executeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct executeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Array<Hook>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<<Hook as alloy_sol_types::SolType>::RustType>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<executeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: executeCall) -> Self {
+                    (value.hooks,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { hooks: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<executeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: executeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl executeReturn {
+            fn _tokenize(&self) -> <executeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for executeCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<Hook>,);
+            type Return = executeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [118u8, 15u8, 42u8, 11u8];
+            const SIGNATURE: &'static str = "execute((address,bytes,uint256)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<Hook> as alloy_sol_types::SolType>::tokenize(
+                        &self.hooks,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                executeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `settlement()` and selector `0x51160630`.
+    ```solidity
+    function settlement() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlementCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`settlement()`](settlementCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settlementReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlementCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settlementCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settlementReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settlementReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settlementCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [81u8, 22u8, 6u8, 48u8];
+            const SIGNATURE: &'static str = "settlement()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: settlementReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: settlementReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`HooksTrampoline`](self) function calls.
+    #[derive(Clone)]
+    pub enum HooksTrampolineCalls {
+        #[allow(missing_docs)]
+        execute(executeCall),
+        #[allow(missing_docs)]
+        settlement(settlementCall),
+    }
+    impl HooksTrampolineCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[81u8, 22u8, 6u8, 48u8], [118u8, 15u8, 42u8, 11u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <settlementCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <executeCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] =
+            &[::core::stringify!(settlement), ::core::stringify!(execute)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for HooksTrampolineCalls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "HooksTrampolineCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::execute(_) => <executeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::settlement(_) => <settlementCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<HooksTrampolineCalls>] = &[
+                {
+                    fn settlement(data: &[u8]) -> alloy_sol_types::Result<HooksTrampolineCalls> {
+                        <settlementCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HooksTrampolineCalls::settlement)
+                    }
+                    settlement
+                },
+                {
+                    fn execute(data: &[u8]) -> alloy_sol_types::Result<HooksTrampolineCalls> {
+                        <executeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(HooksTrampolineCalls::execute)
+                    }
+                    execute
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<HooksTrampolineCalls>] = &[
+                {
+                    fn settlement(data: &[u8]) -> alloy_sol_types::Result<HooksTrampolineCalls> {
+                        <settlementCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(HooksTrampolineCalls::settlement)
+                    }
+                    settlement
+                },
+                {
+                    fn execute(data: &[u8]) -> alloy_sol_types::Result<HooksTrampolineCalls> {
+                        <executeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(HooksTrampolineCalls::execute)
+                    }
+                    execute
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::execute(inner) => {
+                    <executeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::settlement(inner) => {
+                    <settlementCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::execute(inner) => {
+                    <executeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::settlement(inner) => {
+                    <settlementCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`HooksTrampoline`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum HooksTrampolineErrors {
+        #[allow(missing_docs)]
+        NotASettlement(NotASettlement),
+    }
+    impl HooksTrampolineErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[12u8, 212u8, 30u8, 192u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<NotASettlement as alloy_sol_types::SolError>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(NotASettlement)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for HooksTrampolineErrors {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "HooksTrampolineErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::NotASettlement(_) => <NotASettlement as alloy_sol_types::SolError>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<HooksTrampolineErrors>] =
+                &[{
+                    fn NotASettlement(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<HooksTrampolineErrors> {
+                        <NotASettlement as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(HooksTrampolineErrors::NotASettlement)
+                    }
+                    NotASettlement
+                }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                HooksTrampolineErrors,
+            >] = &[{
+                fn NotASettlement(data: &[u8]) -> alloy_sol_types::Result<HooksTrampolineErrors> {
+                    <NotASettlement as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                        .map(HooksTrampolineErrors::NotASettlement)
+                }
+                NotASettlement
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::NotASettlement(inner) => {
+                    <NotASettlement as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::NotASettlement(inner) => {
+                    <NotASettlement as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`HooksTrampoline`](self) contract instance.
+
+    See the [wrapper's documentation](`HooksTrampolineInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> HooksTrampolineInstance<P, N> {
+        HooksTrampolineInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        settlement_: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<HooksTrampolineInstance<P, N>>>
+    {
+        HooksTrampolineInstance::<P, N>::deploy(__provider, settlement_)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        settlement_: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        HooksTrampolineInstance::<P, N>::deploy_builder(__provider, settlement_)
+    }
+    /**A [`HooksTrampoline`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`HooksTrampoline`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct HooksTrampolineInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for HooksTrampolineInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("HooksTrampolineInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        HooksTrampolineInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`HooksTrampoline`](self) contract instance.
+
+        See the [wrapper's documentation](`HooksTrampolineInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            settlement_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<HooksTrampolineInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, settlement_);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            settlement_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { settlement_ })
+                        [..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> HooksTrampolineInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> HooksTrampolineInstance<P, N> {
+            HooksTrampolineInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        HooksTrampolineInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`execute`] function.
+        pub fn execute(
+            &self,
+            hooks: alloy_sol_types::private::Vec<<Hook as alloy_sol_types::SolType>::RustType>,
+        ) -> alloy_contract::SolCallBuilder<&P, executeCall, N> {
+            self.call_builder(&executeCall { hooks })
+        }
+
+        ///Creates a new call builder for the [`settlement`] function.
+        pub fn settlement(&self) -> alloy_contract::SolCallBuilder<&P, settlementCall, N> {
+            self.call_builder(&settlementCall)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        HooksTrampolineInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = HooksTrampoline::HooksTrampolineInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x01DcB88678aedD0C4cC9552B20F4718550250574"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x60bf78233f48ec42ee3f101b9a05ec7878728006"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/icowwrapper/Cargo.toml b/contracts/generated/contracts-generated/icowwrapper/Cargo.toml
new file mode 100644
index 0000000000..3395cef70f
--- /dev/null
+++ b/contracts/generated/contracts-generated/icowwrapper/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-icowwrapper"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/icowwrapper/src/lib.rs b/contracts/generated/contracts-generated/icowwrapper/src/lib.rs
new file mode 100644
index 0000000000..58cbc1ceee
--- /dev/null
+++ b/contracts/generated/contracts-generated/icowwrapper/src/lib.rs
@@ -0,0 +1,682 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface ICowWrapper {
+    function parseWrapperData(bytes memory wrapperData) external view returns (bytes memory remainingWrapperData);
+    function wrappedSettle(bytes memory settleData, bytes memory wrapperData) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "parseWrapperData",
+    "inputs": [
+      {
+        "name": "wrapperData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "remainingWrapperData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "wrappedSettle",
+    "inputs": [
+      {
+        "name": "settleData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "wrapperData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ICowWrapper {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `parseWrapperData(bytes)` and selector `0x79abe637`.
+    ```solidity
+    function parseWrapperData(bytes memory wrapperData) external view returns (bytes memory remainingWrapperData);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct parseWrapperDataCall {
+        #[allow(missing_docs)]
+        pub wrapperData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`parseWrapperData(bytes)`](parseWrapperDataCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct parseWrapperDataReturn {
+        #[allow(missing_docs)]
+        pub remainingWrapperData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<parseWrapperDataCall> for UnderlyingRustTuple<'_> {
+                fn from(value: parseWrapperDataCall) -> Self {
+                    (value.wrapperData,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for parseWrapperDataCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        wrapperData: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<parseWrapperDataReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: parseWrapperDataReturn) -> Self {
+                    (value.remainingWrapperData,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for parseWrapperDataReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        remainingWrapperData: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for parseWrapperDataCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 171u8, 230u8, 55u8];
+            const SIGNATURE: &'static str = "parseWrapperData(bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.wrapperData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: parseWrapperDataReturn = r.into();
+                        r.remainingWrapperData
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: parseWrapperDataReturn = r.into();
+                    r.remainingWrapperData
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `wrappedSettle(bytes,bytes)` and selector `0xd20e71e7`.
+    ```solidity
+    function wrappedSettle(bytes memory settleData, bytes memory wrapperData) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrappedSettleCall {
+        #[allow(missing_docs)]
+        pub settleData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub wrapperData: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`wrappedSettle(bytes,bytes)`](wrappedSettleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct wrappedSettleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrappedSettleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: wrappedSettleCall) -> Self {
+                    (value.settleData, value.wrapperData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrappedSettleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        settleData: tuple.0,
+                        wrapperData: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<wrappedSettleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: wrappedSettleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrappedSettleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl wrappedSettleReturn {
+            fn _tokenize(
+                &self,
+            ) -> <wrappedSettleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for wrappedSettleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = wrappedSettleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 14u8, 113u8, 231u8];
+            const SIGNATURE: &'static str = "wrappedSettle(bytes,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.settleData,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.wrapperData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                wrappedSettleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`ICowWrapper`](self) function calls.
+    #[derive(Clone)]
+    pub enum ICowWrapperCalls {
+        #[allow(missing_docs)]
+        parseWrapperData(parseWrapperDataCall),
+        #[allow(missing_docs)]
+        wrappedSettle(wrappedSettleCall),
+    }
+    impl ICowWrapperCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[121u8, 171u8, 230u8, 55u8], [210u8, 14u8, 113u8, 231u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <parseWrapperDataCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <wrappedSettleCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(parseWrapperData),
+            ::core::stringify!(wrappedSettle),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for ICowWrapperCalls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 64usize;
+        const NAME: &'static str = "ICowWrapperCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::parseWrapperData(_) => {
+                    <parseWrapperDataCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::wrappedSettle(_) => <wrappedSettleCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ICowWrapperCalls>] = &[
+                {
+                    fn parseWrapperData(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
+                        <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ICowWrapperCalls::parseWrapperData)
+                    }
+                    parseWrapperData
+                },
+                {
+                    fn wrappedSettle(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
+                        <wrappedSettleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ICowWrapperCalls::wrappedSettle)
+                    }
+                    wrappedSettle
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<ICowWrapperCalls>] = &[
+                {
+                    fn parseWrapperData(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
+                        <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ICowWrapperCalls::parseWrapperData)
+                    }
+                    parseWrapperData
+                },
+                {
+                    fn wrappedSettle(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
+                        <wrappedSettleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ICowWrapperCalls::wrappedSettle)
+                    }
+                    wrappedSettle
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::parseWrapperData(inner) => {
+                    <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::wrappedSettle(inner) => {
+                    <wrappedSettleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::parseWrapperData(inner) => {
+                    <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::wrappedSettle(inner) => {
+                    <wrappedSettleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ICowWrapper`](self) contract instance.
+
+    See the [wrapper's documentation](`ICowWrapperInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ICowWrapperInstance<P, N> {
+        ICowWrapperInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ICowWrapper`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ICowWrapper`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ICowWrapperInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ICowWrapperInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ICowWrapperInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICowWrapperInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ICowWrapper`](self) contract instance.
+
+        See the [wrapper's documentation](`ICowWrapperInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ICowWrapperInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ICowWrapperInstance<P, N> {
+            ICowWrapperInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICowWrapperInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`parseWrapperData`] function.
+        pub fn parseWrapperData(
+            &self,
+            wrapperData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, parseWrapperDataCall, N> {
+            self.call_builder(&parseWrapperDataCall { wrapperData })
+        }
+
+        ///Creates a new call builder for the [`wrappedSettle`] function.
+        pub fn wrappedSettle(
+            &self,
+            settleData: alloy_sol_types::private::Bytes,
+            wrapperData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, wrappedSettleCall, N> {
+            self.call_builder(&wrappedSettleCall {
+                settleData,
+                wrapperData,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ICowWrapperInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = ICowWrapper::ICowWrapperInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/iswaprpair/Cargo.toml b/contracts/generated/contracts-generated/iswaprpair/Cargo.toml
new file mode 100644
index 0000000000..915048461d
--- /dev/null
+++ b/contracts/generated/contracts-generated/iswaprpair/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-iswaprpair"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/iswaprpair/src/lib.rs b/contracts/generated/contracts-generated/iswaprpair/src/lib.rs
new file mode 100644
index 0000000000..8c1fdec219
--- /dev/null
+++ b/contracts/generated/contracts-generated/iswaprpair/src/lib.rs
@@ -0,0 +1,7237 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface ISwaprPair {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
+    event Sync(uint112 reserve0, uint112 reserve1);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 value) external returns (bool);
+    function balanceOf(address owner) external view returns (uint256);
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+    function decimals() external pure returns (uint8);
+    function factory() external view returns (address);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    function initialize(address, address) external;
+    function kLast() external view returns (uint256);
+    function mint(address to) external returns (uint256 liquidity);
+    function name() external pure returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function price0CumulativeLast() external view returns (uint256);
+    function price1CumulativeLast() external view returns (uint256);
+    function setSwapFee(uint32) external;
+    function skim(address to) external;
+    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes memory data) external;
+    function swapFee() external view returns (uint32);
+    function symbol() external pure returns (string memory);
+    function sync() external;
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function totalSupply() external view returns (uint256);
+    function transfer(address to, uint256 value) external returns (bool);
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MINIMUM_LIQUIDITY",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "PERMIT_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "burn",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getReserves",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "reserve0",
+        "type": "uint112",
+        "internalType": "uint112"
+      },
+      {
+        "name": "reserve1",
+        "type": "uint112",
+        "internalType": "uint112"
+      },
+      {
+        "name": "blockTimestampLast",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "initialize",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "kLast",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "price0CumulativeLast",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "price1CumulativeLast",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setSwapFee",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "skim",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "amount0Out",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1Out",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapFee",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "sync",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "token0",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "token1",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Burn",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Mint",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Swap",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0In",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1In",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount0Out",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1Out",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Sync",
+    "inputs": [
+      {
+        "name": "reserve0",
+        "type": "uint112",
+        "indexed": false,
+        "internalType": "uint112"
+      },
+      {
+        "name": "reserve1",
+        "type": "uint112",
+        "indexed": false,
+        "internalType": "uint112"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ISwaprPair {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Burn(address,uint256,uint256,address)` and selector `0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496`.
+    ```solidity
+    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Burn {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Burn {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Burn(address,uint256,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    220u8, 205u8, 65u8, 47u8, 11u8, 18u8, 82u8, 129u8, 156u8, 177u8, 253u8, 51u8,
+                    11u8, 147u8, 34u8, 76u8, 164u8, 38u8, 18u8, 137u8, 43u8, 179u8, 244u8, 247u8,
+                    137u8, 151u8, 110u8, 109u8, 129u8, 147u8, 100u8, 150u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    amount0: data.0,
+                    amount1: data.1,
+                    to: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Burn {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Burn> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Burn) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Mint(address,uint256,uint256)` and selector `0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f`.
+    ```solidity
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Mint {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Mint {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Mint(address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    76u8, 32u8, 155u8, 95u8, 200u8, 173u8, 80u8, 117u8, 143u8, 19u8, 226u8, 225u8,
+                    8u8, 139u8, 165u8, 106u8, 86u8, 13u8, 255u8, 105u8, 10u8, 28u8, 111u8, 239u8,
+                    38u8, 57u8, 79u8, 76u8, 3u8, 130u8, 28u8, 79u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    amount0: data.0,
+                    amount1: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.sender.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Mint {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Mint> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Mint) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Swap(address,uint256,uint256,uint256,uint256,address)` and selector `0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822`.
+    ```solidity
+    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Swap {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0In: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1In: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount0Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Swap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Swap(address,uint256,uint256,uint256,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    215u8, 138u8, 217u8, 95u8, 164u8, 108u8, 153u8, 75u8, 101u8, 81u8, 208u8,
+                    218u8, 133u8, 252u8, 39u8, 95u8, 230u8, 19u8, 206u8, 55u8, 101u8, 127u8, 184u8,
+                    213u8, 227u8, 209u8, 48u8, 132u8, 1u8, 89u8, 216u8, 34u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    amount0In: data.0,
+                    amount1In: data.1,
+                    amount0Out: data.2,
+                    amount1Out: data.3,
+                    to: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0In,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1In,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Out,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Out,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Swap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Swap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Swap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Sync(uint112,uint112)` and selector `0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1`.
+    ```solidity
+    event Sync(uint112 reserve0, uint112 reserve1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Sync {
+        #[allow(missing_docs)]
+        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Sync {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Sync(uint112,uint112)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    28u8, 65u8, 30u8, 154u8, 150u8, 224u8, 113u8, 36u8, 28u8, 47u8, 33u8, 247u8,
+                    114u8, 107u8, 23u8, 174u8, 137u8, 227u8, 202u8, 180u8, 199u8, 139u8, 229u8,
+                    14u8, 6u8, 43u8, 3u8, 169u8, 255u8, 251u8, 186u8, 209u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    reserve0: data.0,
+                    reserve1: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Sync {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Sync> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Sync) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `MINIMUM_LIQUIDITY()` and selector `0xba9a7a56`.
+    ```solidity
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MINIMUM_LIQUIDITYCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`MINIMUM_LIQUIDITY()`](MINIMUM_LIQUIDITYCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MINIMUM_LIQUIDITYReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MINIMUM_LIQUIDITYCall> for UnderlyingRustTuple<'_> {
+                fn from(value: MINIMUM_LIQUIDITYCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MINIMUM_LIQUIDITYReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: MINIMUM_LIQUIDITYReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for MINIMUM_LIQUIDITYCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 154u8, 122u8, 86u8];
+            const SIGNATURE: &'static str = "MINIMUM_LIQUIDITY()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: MINIMUM_LIQUIDITYReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: MINIMUM_LIQUIDITYReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `PERMIT_TYPEHASH()` and selector `0x30adf81f`.
+    ```solidity
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PERMIT_TYPEHASHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`PERMIT_TYPEHASH()`](PERMIT_TYPEHASHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PERMIT_TYPEHASHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<PERMIT_TYPEHASHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: PERMIT_TYPEHASHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<PERMIT_TYPEHASHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: PERMIT_TYPEHASHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for PERMIT_TYPEHASHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [48u8, 173u8, 248u8, 31u8];
+            const SIGNATURE: &'static str = "PERMIT_TYPEHASH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: PERMIT_TYPEHASHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: PERMIT_TYPEHASHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 value) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.value)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        value: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `burn(address)` and selector `0x89afcb44`.
+    ```solidity
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct burnCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`burn(address)`](burnCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct burnReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
+                fn from(value: burnCall) -> Self {
+                    (value.to,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { to: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: burnReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl burnReturn {
+            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for burnCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = burnReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 175u8, 203u8, 68u8];
+            const SIGNATURE: &'static str = "burn(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                burnReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external pure returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getReserves()` and selector `0x0902f1ac`.
+    ```solidity
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getReservesCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getReserves()`](getReservesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getReservesReturn {
+        #[allow(missing_docs)]
+        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub blockTimestampLast: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getReservesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U112,
+                alloy_sol_types::private::primitives::aliases::U112,
+                u32,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getReservesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesReturn) -> Self {
+                    (value.reserve0, value.reserve1, value.blockTimestampLast)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        reserve0: tuple.0,
+                        reserve1: tuple.1,
+                        blockTimestampLast: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getReservesReturn {
+            fn _tokenize(&self) -> <getReservesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockTimestampLast,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getReservesCall {
+            type Parameters<'a> = ();
+            type Return = getReservesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 2u8, 241u8, 172u8];
+            const SIGNATURE: &'static str = "getReserves()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getReservesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `initialize(address,address)` and selector `0x485cc955`.
+    ```solidity
+    function initialize(address, address) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`initialize(address,address)`](initializeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl initializeReturn {
+            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for initializeCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = initializeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
+            const SIGNATURE: &'static str = "initialize(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                initializeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `kLast()` and selector `0x7464fc3d`.
+    ```solidity
+    function kLast() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct kLastCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`kLast()`](kLastCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct kLastReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<kLastCall> for UnderlyingRustTuple<'_> {
+                fn from(value: kLastCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<kLastReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: kLastReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for kLastCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 100u8, 252u8, 61u8];
+            const SIGNATURE: &'static str = "kLast()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: kLastReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: kLastReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address)` and selector `0x6a627842`.
+    ```solidity
+    function mint(address to) external returns (uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`mint(address)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.to,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { to: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value.liquidity,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { liquidity: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [106u8, 98u8, 120u8, 66u8];
+            const SIGNATURE: &'static str = "mint(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: mintReturn = r.into();
+                        r.liquidity
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: mintReturn = r.into();
+                    r.liquidity
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external pure returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `price0CumulativeLast()` and selector `0x5909c0d5`.
+    ```solidity
+    function price0CumulativeLast() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price0CumulativeLastCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`price0CumulativeLast()`](price0CumulativeLastCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price0CumulativeLastReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price0CumulativeLastCall> for UnderlyingRustTuple<'_> {
+                fn from(value: price0CumulativeLastCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price0CumulativeLastReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: price0CumulativeLastReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for price0CumulativeLastCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [89u8, 9u8, 192u8, 213u8];
+            const SIGNATURE: &'static str = "price0CumulativeLast()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: price0CumulativeLastReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: price0CumulativeLastReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `price1CumulativeLast()` and selector `0x5a3d5493`.
+    ```solidity
+    function price1CumulativeLast() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price1CumulativeLastCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`price1CumulativeLast()`](price1CumulativeLastCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price1CumulativeLastReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price1CumulativeLastCall> for UnderlyingRustTuple<'_> {
+                fn from(value: price1CumulativeLastCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price1CumulativeLastReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: price1CumulativeLastReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for price1CumulativeLastCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [90u8, 61u8, 84u8, 147u8];
+            const SIGNATURE: &'static str = "price1CumulativeLast()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: price1CumulativeLastReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: price1CumulativeLastReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setSwapFee(uint32)` and selector `0xd6d788c3`.
+    ```solidity
+    function setSwapFee(uint32) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeeCall(pub u32);
+    ///Container type for the return parameters of the
+    /// [`setSwapFee(uint32)`](setSwapFeeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setSwapFeeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u32,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeeCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setSwapFeeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setSwapFeeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setSwapFeeReturn {
+            fn _tokenize(&self) -> <setSwapFeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setSwapFeeCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type Return = setSwapFeeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [214u8, 215u8, 136u8, 195u8];
+            const SIGNATURE: &'static str = "setSwapFee(uint32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setSwapFeeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `skim(address)` and selector `0xbc25cf77`.
+    ```solidity
+    function skim(address to) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct skimCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`skim(address)`](skimCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct skimReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<skimCall> for UnderlyingRustTuple<'_> {
+                fn from(value: skimCall) -> Self {
+                    (value.to,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { to: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<skimReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: skimReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl skimReturn {
+            fn _tokenize(&self) -> <skimCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for skimCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = skimReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [188u8, 37u8, 207u8, 119u8];
+            const SIGNATURE: &'static str = "skim(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                skimReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swap(uint256,uint256,address,bytes)` and selector `0x022c0d9f`.
+    ```solidity
+    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes memory data) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub amount0Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`swap(uint256,uint256,address,bytes)`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (value.amount0Out, value.amount1Out, value.to, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0Out: tuple.0,
+                        amount1Out: tuple.1,
+                        to: tuple.2,
+                        data: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapReturn {
+            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 44u8, 13u8, 159u8];
+            const SIGNATURE: &'static str = "swap(uint256,uint256,address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Out,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Out,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapFee()` and selector `0x54cf2aeb`.
+    ```solidity
+    function swapFee() external view returns (uint32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapFeeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapFee()`](swapFeeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapFeeReturn {
+        #[allow(missing_docs)]
+        pub _0: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapFeeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapFeeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapFeeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u32,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapFeeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapFeeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapFeeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapFeeCall {
+            type Parameters<'a> = ();
+            type Return = u32;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 207u8, 42u8, 235u8];
+            const SIGNATURE: &'static str = "swapFee()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapFeeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapFeeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external pure returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sync()` and selector `0xfff6cae9`.
+    ```solidity
+    function sync() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct syncCall;
+    ///Container type for the return parameters of the [`sync()`](syncCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct syncReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<syncCall> for UnderlyingRustTuple<'_> {
+                fn from(value: syncCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for syncCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<syncReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: syncReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for syncReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl syncReturn {
+            fn _tokenize(&self) -> <syncCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for syncCall {
+            type Parameters<'a> = ();
+            type Return = syncReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 246u8, 202u8, 233u8];
+            const SIGNATURE: &'static str = "sync()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                syncReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token0()` and selector `0x0dfe1681`.
+    ```solidity
+    function token0() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token0()`](token0Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token0Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 254u8, 22u8, 129u8];
+            const SIGNATURE: &'static str = "token0()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token0Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token0Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token1()` and selector `0xd21220a7`.
+    ```solidity
+    function token1() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token1()`](token1Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token1Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 18u8, 32u8, 167u8];
+            const SIGNATURE: &'static str = "token1()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token1Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token1Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address to, uint256 value) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.to, value.value)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.from, value.to, value.value)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        from: tuple.0,
+                        to: tuple.1,
+                        value: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`ISwaprPair`](self) function calls.
+    #[derive(Clone)]
+    pub enum ISwaprPairCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        MINIMUM_LIQUIDITY(MINIMUM_LIQUIDITYCall),
+        #[allow(missing_docs)]
+        PERMIT_TYPEHASH(PERMIT_TYPEHASHCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        burn(burnCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getReserves(getReservesCall),
+        #[allow(missing_docs)]
+        initialize(initializeCall),
+        #[allow(missing_docs)]
+        kLast(kLastCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        price0CumulativeLast(price0CumulativeLastCall),
+        #[allow(missing_docs)]
+        price1CumulativeLast(price1CumulativeLastCall),
+        #[allow(missing_docs)]
+        setSwapFee(setSwapFeeCall),
+        #[allow(missing_docs)]
+        skim(skimCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+        #[allow(missing_docs)]
+        swapFee(swapFeeCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        sync(syncCall),
+        #[allow(missing_docs)]
+        token0(token0Call),
+        #[allow(missing_docs)]
+        token1(token1Call),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl ISwaprPairCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 44u8, 13u8, 159u8],
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 2u8, 241u8, 172u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [13u8, 254u8, 22u8, 129u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [48u8, 173u8, 248u8, 31u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [72u8, 92u8, 201u8, 85u8],
+            [84u8, 207u8, 42u8, 235u8],
+            [89u8, 9u8, 192u8, 213u8],
+            [90u8, 61u8, 84u8, 147u8],
+            [106u8, 98u8, 120u8, 66u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 100u8, 252u8, 61u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [137u8, 175u8, 203u8, 68u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [186u8, 154u8, 122u8, 86u8],
+            [188u8, 37u8, 207u8, 119u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [210u8, 18u8, 32u8, 167u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [214u8, 215u8, 136u8, 195u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [255u8, 246u8, 202u8, 233u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getReservesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapFeeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <price0CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <price1CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <kLastCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <burnCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <skimCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setSwapFeeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <syncCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(swap),
+            ::core::stringify!(name),
+            ::core::stringify!(getReserves),
+            ::core::stringify!(approve),
+            ::core::stringify!(token0),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(PERMIT_TYPEHASH),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(initialize),
+            ::core::stringify!(swapFee),
+            ::core::stringify!(price0CumulativeLast),
+            ::core::stringify!(price1CumulativeLast),
+            ::core::stringify!(mint),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(kLast),
+            ::core::stringify!(nonces),
+            ::core::stringify!(burn),
+            ::core::stringify!(symbol),
+            ::core::stringify!(transfer),
+            ::core::stringify!(MINIMUM_LIQUIDITY),
+            ::core::stringify!(skim),
+            ::core::stringify!(factory),
+            ::core::stringify!(token1),
+            ::core::stringify!(permit),
+            ::core::stringify!(setSwapFee),
+            ::core::stringify!(allowance),
+            ::core::stringify!(sync),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for ISwaprPairCalls {
+        const COUNT: usize = 29usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "ISwaprPairCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::MINIMUM_LIQUIDITY(_) => {
+                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::PERMIT_TYPEHASH(_) => {
+                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::burn(_) => <burnCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getReserves(_) => <getReservesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::kLast(_) => <kLastCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::price0CumulativeLast(_) => {
+                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::price1CumulativeLast(_) => {
+                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setSwapFee(_) => <setSwapFeeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::skim(_) => <skimCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapFee(_) => <swapFeeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::sync(_) => <syncCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ISwaprPairCalls>] = &[
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn getReserves(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <getReservesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::getReserves)
+                    }
+                    getReserves
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn PERMIT_TYPEHASH(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::PERMIT_TYPEHASH)
+                    }
+                    PERMIT_TYPEHASH
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::initialize)
+                    }
+                    initialize
+                },
+                {
+                    fn swapFee(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <swapFeeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::swapFee)
+                    }
+                    swapFee
+                },
+                {
+                    fn price0CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::price0CumulativeLast)
+                    }
+                    price0CumulativeLast
+                },
+                {
+                    fn price1CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::price1CumulativeLast)
+                    }
+                    price1CumulativeLast
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::kLast)
+                    }
+                    kLast
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn burn(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <burnCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::burn)
+                    }
+                    burn
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn MINIMUM_LIQUIDITY(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::MINIMUM_LIQUIDITY)
+                    }
+                    MINIMUM_LIQUIDITY
+                },
+                {
+                    fn skim(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::skim)
+                    }
+                    skim
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn setSwapFee(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <setSwapFeeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::setSwapFee)
+                    }
+                    setSwapFee
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn sync(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <syncCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(ISwaprPairCalls::sync)
+                    }
+                    sync
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<ISwaprPairCalls>] = &[
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn getReserves(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <getReservesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::getReserves)
+                    }
+                    getReserves
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ISwaprPairCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn PERMIT_TYPEHASH(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ISwaprPairCalls::PERMIT_TYPEHASH)
+                    }
+                    PERMIT_TYPEHASH
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(ISwaprPairCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::initialize)
+                    }
+                    initialize
+                },
+                {
+                    fn swapFee(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <swapFeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::swapFee)
+                    }
+                    swapFee
+                },
+                {
+                    fn price0CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ISwaprPairCalls::price0CumulativeLast)
+                    }
+                    price0CumulativeLast
+                },
+                {
+                    fn price1CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ISwaprPairCalls::price1CumulativeLast)
+                    }
+                    price1CumulativeLast
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::kLast)
+                    }
+                    kLast
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn burn(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <burnCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::burn)
+                    }
+                    burn
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn MINIMUM_LIQUIDITY(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(ISwaprPairCalls::MINIMUM_LIQUIDITY)
+                    }
+                    MINIMUM_LIQUIDITY
+                },
+                {
+                    fn skim(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::skim)
+                    }
+                    skim
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn setSwapFee(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <setSwapFeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::setSwapFee)
+                    }
+                    setSwapFee
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn sync(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
+                        <syncCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(ISwaprPairCalls::sync)
+                    }
+                    sync
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::MINIMUM_LIQUIDITY(inner) => {
+                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::PERMIT_TYPEHASH(inner) => {
+                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::burn(inner) => {
+                    <burnCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getReserves(inner) => {
+                    <getReservesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::initialize(inner) => {
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::kLast(inner) => {
+                    <kLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::price0CumulativeLast(inner) => {
+                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::price1CumulativeLast(inner) => {
+                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setSwapFee(inner) => {
+                    <setSwapFeeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::skim(inner) => {
+                    <skimCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swapFee(inner) => {
+                    <swapFeeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::sync(inner) => {
+                    <syncCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::MINIMUM_LIQUIDITY(inner) => {
+                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::PERMIT_TYPEHASH(inner) => {
+                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::burn(inner) => {
+                    <burnCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getReserves(inner) => {
+                    <getReservesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::initialize(inner) => {
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::kLast(inner) => {
+                    <kLastCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::price0CumulativeLast(inner) => {
+                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::price1CumulativeLast(inner) => {
+                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::setSwapFee(inner) => {
+                    <setSwapFeeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::skim(inner) => {
+                    <skimCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swapFee(inner) => {
+                    <swapFeeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::sync(inner) => {
+                    <syncCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`ISwaprPair`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum ISwaprPairEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        Burn(Burn),
+        #[allow(missing_docs)]
+        Mint(Mint),
+        #[allow(missing_docs)]
+        Swap(Swap),
+        #[allow(missing_docs)]
+        Sync(Sync),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl ISwaprPairEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                28u8, 65u8, 30u8, 154u8, 150u8, 224u8, 113u8, 36u8, 28u8, 47u8, 33u8, 247u8, 114u8,
+                107u8, 23u8, 174u8, 137u8, 227u8, 202u8, 180u8, 199u8, 139u8, 229u8, 14u8, 6u8,
+                43u8, 3u8, 169u8, 255u8, 251u8, 186u8, 209u8,
+            ],
+            [
+                76u8, 32u8, 155u8, 95u8, 200u8, 173u8, 80u8, 117u8, 143u8, 19u8, 226u8, 225u8, 8u8,
+                139u8, 165u8, 106u8, 86u8, 13u8, 255u8, 105u8, 10u8, 28u8, 111u8, 239u8, 38u8,
+                57u8, 79u8, 76u8, 3u8, 130u8, 28u8, 79u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                215u8, 138u8, 217u8, 95u8, 164u8, 108u8, 153u8, 75u8, 101u8, 81u8, 208u8, 218u8,
+                133u8, 252u8, 39u8, 95u8, 230u8, 19u8, 206u8, 55u8, 101u8, 127u8, 184u8, 213u8,
+                227u8, 209u8, 48u8, 132u8, 1u8, 89u8, 216u8, 34u8,
+            ],
+            [
+                220u8, 205u8, 65u8, 47u8, 11u8, 18u8, 82u8, 129u8, 156u8, 177u8, 253u8, 51u8, 11u8,
+                147u8, 34u8, 76u8, 164u8, 38u8, 18u8, 137u8, 43u8, 179u8, 244u8, 247u8, 137u8,
+                151u8, 110u8, 109u8, 129u8, 147u8, 100u8, 150u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Sync as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Mint as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Swap as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Burn as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(Sync),
+            ::core::stringify!(Mint),
+            ::core::stringify!(Approval),
+            ::core::stringify!(Swap),
+            ::core::stringify!(Burn),
+            ::core::stringify!(Transfer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for ISwaprPairEvents {
+        const COUNT: usize = 6usize;
+        const NAME: &'static str = "ISwaprPairEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<Burn as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Burn as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Burn)
+                }
+                Some(<Mint as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Mint as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Mint)
+                }
+                Some(<Swap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Swap as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Swap)
+                }
+                Some(<Sync as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Sync as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Sync)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for ISwaprPairEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Burn(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Mint(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Sync(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Burn(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Mint(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Sync(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ISwaprPair`](self) contract instance.
+
+    See the [wrapper's documentation](`ISwaprPairInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ISwaprPairInstance<P, N> {
+        ISwaprPairInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ISwaprPair`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ISwaprPair`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ISwaprPairInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ISwaprPairInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ISwaprPairInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ISwaprPairInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ISwaprPair`](self) contract instance.
+
+        See the [wrapper's documentation](`ISwaprPairInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ISwaprPairInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ISwaprPairInstance<P, N> {
+            ISwaprPairInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ISwaprPairInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`MINIMUM_LIQUIDITY`] function.
+        pub fn MINIMUM_LIQUIDITY(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, MINIMUM_LIQUIDITYCall, N> {
+            self.call_builder(&MINIMUM_LIQUIDITYCall)
+        }
+
+        ///Creates a new call builder for the [`PERMIT_TYPEHASH`] function.
+        pub fn PERMIT_TYPEHASH(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, PERMIT_TYPEHASHCall, N> {
+            self.call_builder(&PERMIT_TYPEHASHCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, value })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { owner })
+        }
+
+        ///Creates a new call builder for the [`burn`] function.
+        pub fn burn(
+            &self,
+            to: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, burnCall, N> {
+            self.call_builder(&burnCall { to })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getReserves`] function.
+        pub fn getReserves(&self) -> alloy_contract::SolCallBuilder<&P, getReservesCall, N> {
+            self.call_builder(&getReservesCall)
+        }
+
+        ///Creates a new call builder for the [`initialize`] function.
+        pub fn initialize(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
+            self.call_builder(&initializeCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`kLast`] function.
+        pub fn kLast(&self) -> alloy_contract::SolCallBuilder<&P, kLastCall, N> {
+            self.call_builder(&kLastCall)
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            to: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { to })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`price0CumulativeLast`]
+        /// function.
+        pub fn price0CumulativeLast(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, price0CumulativeLastCall, N> {
+            self.call_builder(&price0CumulativeLastCall)
+        }
+
+        ///Creates a new call builder for the [`price1CumulativeLast`]
+        /// function.
+        pub fn price1CumulativeLast(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, price1CumulativeLastCall, N> {
+            self.call_builder(&price1CumulativeLastCall)
+        }
+
+        ///Creates a new call builder for the [`setSwapFee`] function.
+        pub fn setSwapFee(&self, _0: u32) -> alloy_contract::SolCallBuilder<&P, setSwapFeeCall, N> {
+            self.call_builder(&setSwapFeeCall(_0))
+        }
+
+        ///Creates a new call builder for the [`skim`] function.
+        pub fn skim(
+            &self,
+            to: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, skimCall, N> {
+            self.call_builder(&skimCall { to })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            amount0Out: alloy_sol_types::private::primitives::aliases::U256,
+            amount1Out: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                amount0Out,
+                amount1Out,
+                to,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapFee`] function.
+        pub fn swapFee(&self) -> alloy_contract::SolCallBuilder<&P, swapFeeCall, N> {
+            self.call_builder(&swapFeeCall)
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`sync`] function.
+        pub fn sync(&self) -> alloy_contract::SolCallBuilder<&P, syncCall, N> {
+            self.call_builder(&syncCall)
+        }
+
+        ///Creates a new call builder for the [`token0`] function.
+        pub fn token0(&self) -> alloy_contract::SolCallBuilder<&P, token0Call, N> {
+            self.call_builder(&token0Call)
+        }
+
+        ///Creates a new call builder for the [`token1`] function.
+        pub fn token1(&self) -> alloy_contract::SolCallBuilder<&P, token1Call, N> {
+            self.call_builder(&token1Call)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { to, value })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            from: alloy_sol_types::private::Address,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall { from, to, value })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ISwaprPairInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`Burn`] event.
+        pub fn Burn_filter(&self) -> alloy_contract::Event<&P, Burn, N> {
+            self.event_filter::<Burn>()
+        }
+
+        ///Creates a new event filter for the [`Mint`] event.
+        pub fn Mint_filter(&self) -> alloy_contract::Event<&P, Mint, N> {
+            self.event_filter::<Mint>()
+        }
+
+        ///Creates a new event filter for the [`Swap`] event.
+        pub fn Swap_filter(&self) -> alloy_contract::Event<&P, Swap, N> {
+            self.event_filter::<Swap>()
+        }
+
+        ///Creates a new event filter for the [`Sync`] event.
+        pub fn Sync_filter(&self) -> alloy_contract::Event<&P, Sync, N> {
+            self.event_filter::<Sync>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = ISwaprPair::ISwaprPairInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/iuniswaplikepair/Cargo.toml b/contracts/generated/contracts-generated/iuniswaplikepair/Cargo.toml
new file mode 100644
index 0000000000..1d20caa72f
--- /dev/null
+++ b/contracts/generated/contracts-generated/iuniswaplikepair/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-iuniswaplikepair"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs b/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs
new file mode 100644
index 0000000000..1922d1d1b6
--- /dev/null
+++ b/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs
@@ -0,0 +1,6888 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface IUniswapLikePair {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
+    event Sync(uint112 reserve0, uint112 reserve1);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 value) external returns (bool);
+    function balanceOf(address owner) external view returns (uint256);
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+    function decimals() external pure returns (uint8);
+    function factory() external view returns (address);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    function initialize(address, address) external;
+    function kLast() external view returns (uint256);
+    function mint(address to) external returns (uint256 liquidity);
+    function name() external pure returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function price0CumulativeLast() external view returns (uint256);
+    function price1CumulativeLast() external view returns (uint256);
+    function skim(address to) external;
+    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes memory data) external;
+    function symbol() external pure returns (string memory);
+    function sync() external;
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function totalSupply() external view returns (uint256);
+    function transfer(address to, uint256 value) external returns (bool);
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MINIMUM_LIQUIDITY",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "PERMIT_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "burn",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getReserves",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "reserve0",
+        "type": "uint112",
+        "internalType": "uint112"
+      },
+      {
+        "name": "reserve1",
+        "type": "uint112",
+        "internalType": "uint112"
+      },
+      {
+        "name": "blockTimestampLast",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "initialize",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "kLast",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "price0CumulativeLast",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "price1CumulativeLast",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "skim",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "amount0Out",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1Out",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "sync",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "token0",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "token1",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Burn",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Mint",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Swap",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0In",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1In",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount0Out",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1Out",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Sync",
+    "inputs": [
+      {
+        "name": "reserve0",
+        "type": "uint112",
+        "indexed": false,
+        "internalType": "uint112"
+      },
+      {
+        "name": "reserve1",
+        "type": "uint112",
+        "indexed": false,
+        "internalType": "uint112"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IUniswapLikePair {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Burn(address,uint256,uint256,address)` and selector `0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496`.
+    ```solidity
+    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Burn {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Burn {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Burn(address,uint256,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    220u8, 205u8, 65u8, 47u8, 11u8, 18u8, 82u8, 129u8, 156u8, 177u8, 253u8, 51u8,
+                    11u8, 147u8, 34u8, 76u8, 164u8, 38u8, 18u8, 137u8, 43u8, 179u8, 244u8, 247u8,
+                    137u8, 151u8, 110u8, 109u8, 129u8, 147u8, 100u8, 150u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    amount0: data.0,
+                    amount1: data.1,
+                    to: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Burn {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Burn> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Burn) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Mint(address,uint256,uint256)` and selector `0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f`.
+    ```solidity
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Mint {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Mint {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Mint(address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    76u8, 32u8, 155u8, 95u8, 200u8, 173u8, 80u8, 117u8, 143u8, 19u8, 226u8, 225u8,
+                    8u8, 139u8, 165u8, 106u8, 86u8, 13u8, 255u8, 105u8, 10u8, 28u8, 111u8, 239u8,
+                    38u8, 57u8, 79u8, 76u8, 3u8, 130u8, 28u8, 79u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    amount0: data.0,
+                    amount1: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.sender.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Mint {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Mint> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Mint) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Swap(address,uint256,uint256,uint256,uint256,address)` and selector `0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822`.
+    ```solidity
+    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Swap {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0In: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1In: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount0Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Swap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Swap(address,uint256,uint256,uint256,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    215u8, 138u8, 217u8, 95u8, 164u8, 108u8, 153u8, 75u8, 101u8, 81u8, 208u8,
+                    218u8, 133u8, 252u8, 39u8, 95u8, 230u8, 19u8, 206u8, 55u8, 101u8, 127u8, 184u8,
+                    213u8, 227u8, 209u8, 48u8, 132u8, 1u8, 89u8, 216u8, 34u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    amount0In: data.0,
+                    amount1In: data.1,
+                    amount0Out: data.2,
+                    amount1Out: data.3,
+                    to: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0In,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1In,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Out,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Out,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Swap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Swap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Swap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Sync(uint112,uint112)` and selector `0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1`.
+    ```solidity
+    event Sync(uint112 reserve0, uint112 reserve1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Sync {
+        #[allow(missing_docs)]
+        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Sync {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Sync(uint112,uint112)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    28u8, 65u8, 30u8, 154u8, 150u8, 224u8, 113u8, 36u8, 28u8, 47u8, 33u8, 247u8,
+                    114u8, 107u8, 23u8, 174u8, 137u8, 227u8, 202u8, 180u8, 199u8, 139u8, 229u8,
+                    14u8, 6u8, 43u8, 3u8, 169u8, 255u8, 251u8, 186u8, 209u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    reserve0: data.0,
+                    reserve1: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Sync {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Sync> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Sync) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `MINIMUM_LIQUIDITY()` and selector `0xba9a7a56`.
+    ```solidity
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MINIMUM_LIQUIDITYCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`MINIMUM_LIQUIDITY()`](MINIMUM_LIQUIDITYCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MINIMUM_LIQUIDITYReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MINIMUM_LIQUIDITYCall> for UnderlyingRustTuple<'_> {
+                fn from(value: MINIMUM_LIQUIDITYCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<MINIMUM_LIQUIDITYReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: MINIMUM_LIQUIDITYReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for MINIMUM_LIQUIDITYCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 154u8, 122u8, 86u8];
+            const SIGNATURE: &'static str = "MINIMUM_LIQUIDITY()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: MINIMUM_LIQUIDITYReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: MINIMUM_LIQUIDITYReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `PERMIT_TYPEHASH()` and selector `0x30adf81f`.
+    ```solidity
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PERMIT_TYPEHASHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`PERMIT_TYPEHASH()`](PERMIT_TYPEHASHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PERMIT_TYPEHASHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<PERMIT_TYPEHASHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: PERMIT_TYPEHASHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<PERMIT_TYPEHASHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: PERMIT_TYPEHASHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for PERMIT_TYPEHASHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [48u8, 173u8, 248u8, 31u8];
+            const SIGNATURE: &'static str = "PERMIT_TYPEHASH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: PERMIT_TYPEHASHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: PERMIT_TYPEHASHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 value) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.value)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        value: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `burn(address)` and selector `0x89afcb44`.
+    ```solidity
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct burnCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`burn(address)`](burnCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct burnReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
+                fn from(value: burnCall) -> Self {
+                    (value.to,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { to: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: burnReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl burnReturn {
+            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for burnCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = burnReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [137u8, 175u8, 203u8, 68u8];
+            const SIGNATURE: &'static str = "burn(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                burnReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external pure returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getReserves()` and selector `0x0902f1ac`.
+    ```solidity
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getReservesCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getReserves()`](getReservesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getReservesReturn {
+        #[allow(missing_docs)]
+        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub blockTimestampLast: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getReservesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U112,
+                alloy_sol_types::private::primitives::aliases::U112,
+                u32,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getReservesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesReturn) -> Self {
+                    (value.reserve0, value.reserve1, value.blockTimestampLast)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        reserve0: tuple.0,
+                        reserve1: tuple.1,
+                        blockTimestampLast: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getReservesReturn {
+            fn _tokenize(&self) -> <getReservesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockTimestampLast,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getReservesCall {
+            type Parameters<'a> = ();
+            type Return = getReservesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 2u8, 241u8, 172u8];
+            const SIGNATURE: &'static str = "getReserves()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getReservesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `initialize(address,address)` and selector `0x485cc955`.
+    ```solidity
+    function initialize(address, address) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`initialize(address,address)`](initializeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl initializeReturn {
+            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for initializeCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = initializeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
+            const SIGNATURE: &'static str = "initialize(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                initializeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `kLast()` and selector `0x7464fc3d`.
+    ```solidity
+    function kLast() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct kLastCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`kLast()`](kLastCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct kLastReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<kLastCall> for UnderlyingRustTuple<'_> {
+                fn from(value: kLastCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<kLastReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: kLastReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for kLastCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [116u8, 100u8, 252u8, 61u8];
+            const SIGNATURE: &'static str = "kLast()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: kLastReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: kLastReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address)` and selector `0x6a627842`.
+    ```solidity
+    function mint(address to) external returns (uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`mint(address)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.to,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { to: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value.liquidity,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { liquidity: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [106u8, 98u8, 120u8, 66u8];
+            const SIGNATURE: &'static str = "mint(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: mintReturn = r.into();
+                        r.liquidity
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: mintReturn = r.into();
+                    r.liquidity
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external pure returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `price0CumulativeLast()` and selector `0x5909c0d5`.
+    ```solidity
+    function price0CumulativeLast() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price0CumulativeLastCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`price0CumulativeLast()`](price0CumulativeLastCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price0CumulativeLastReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price0CumulativeLastCall> for UnderlyingRustTuple<'_> {
+                fn from(value: price0CumulativeLastCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price0CumulativeLastReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: price0CumulativeLastReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for price0CumulativeLastCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [89u8, 9u8, 192u8, 213u8];
+            const SIGNATURE: &'static str = "price0CumulativeLast()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: price0CumulativeLastReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: price0CumulativeLastReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `price1CumulativeLast()` and selector `0x5a3d5493`.
+    ```solidity
+    function price1CumulativeLast() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price1CumulativeLastCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`price1CumulativeLast()`](price1CumulativeLastCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct price1CumulativeLastReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price1CumulativeLastCall> for UnderlyingRustTuple<'_> {
+                fn from(value: price1CumulativeLastCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<price1CumulativeLastReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: price1CumulativeLastReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for price1CumulativeLastCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [90u8, 61u8, 84u8, 147u8];
+            const SIGNATURE: &'static str = "price1CumulativeLast()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: price1CumulativeLastReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: price1CumulativeLastReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `skim(address)` and selector `0xbc25cf77`.
+    ```solidity
+    function skim(address to) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct skimCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`skim(address)`](skimCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct skimReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<skimCall> for UnderlyingRustTuple<'_> {
+                fn from(value: skimCall) -> Self {
+                    (value.to,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { to: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<skimReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: skimReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl skimReturn {
+            fn _tokenize(&self) -> <skimCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for skimCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = skimReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [188u8, 37u8, 207u8, 119u8];
+            const SIGNATURE: &'static str = "skim(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                skimReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swap(uint256,uint256,address,bytes)` and selector `0x022c0d9f`.
+    ```solidity
+    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes memory data) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub amount0Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1Out: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`swap(uint256,uint256,address,bytes)`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (value.amount0Out, value.amount1Out, value.to, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0Out: tuple.0,
+                        amount1Out: tuple.1,
+                        to: tuple.2,
+                        data: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapReturn {
+            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 44u8, 13u8, 159u8];
+            const SIGNATURE: &'static str = "swap(uint256,uint256,address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Out,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Out,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external pure returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sync()` and selector `0xfff6cae9`.
+    ```solidity
+    function sync() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct syncCall;
+    ///Container type for the return parameters of the [`sync()`](syncCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct syncReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<syncCall> for UnderlyingRustTuple<'_> {
+                fn from(value: syncCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for syncCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<syncReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: syncReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for syncReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl syncReturn {
+            fn _tokenize(&self) -> <syncCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for syncCall {
+            type Parameters<'a> = ();
+            type Return = syncReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 246u8, 202u8, 233u8];
+            const SIGNATURE: &'static str = "sync()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                syncReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token0()` and selector `0x0dfe1681`.
+    ```solidity
+    function token0() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token0()`](token0Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token0Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 254u8, 22u8, 129u8];
+            const SIGNATURE: &'static str = "token0()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token0Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token0Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token1()` and selector `0xd21220a7`.
+    ```solidity
+    function token1() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token1()`](token1Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token1Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 18u8, 32u8, 167u8];
+            const SIGNATURE: &'static str = "token1()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token1Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token1Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address to, uint256 value) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.to, value.value)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.from, value.to, value.value)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        from: tuple.0,
+                        to: tuple.1,
+                        value: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`IUniswapLikePair`](self) function calls.
+    #[derive(Clone)]
+    pub enum IUniswapLikePairCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        MINIMUM_LIQUIDITY(MINIMUM_LIQUIDITYCall),
+        #[allow(missing_docs)]
+        PERMIT_TYPEHASH(PERMIT_TYPEHASHCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        burn(burnCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getReserves(getReservesCall),
+        #[allow(missing_docs)]
+        initialize(initializeCall),
+        #[allow(missing_docs)]
+        kLast(kLastCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        price0CumulativeLast(price0CumulativeLastCall),
+        #[allow(missing_docs)]
+        price1CumulativeLast(price1CumulativeLastCall),
+        #[allow(missing_docs)]
+        skim(skimCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        sync(syncCall),
+        #[allow(missing_docs)]
+        token0(token0Call),
+        #[allow(missing_docs)]
+        token1(token1Call),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl IUniswapLikePairCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 44u8, 13u8, 159u8],
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 2u8, 241u8, 172u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [13u8, 254u8, 22u8, 129u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [48u8, 173u8, 248u8, 31u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [72u8, 92u8, 201u8, 85u8],
+            [89u8, 9u8, 192u8, 213u8],
+            [90u8, 61u8, 84u8, 147u8],
+            [106u8, 98u8, 120u8, 66u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [116u8, 100u8, 252u8, 61u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [137u8, 175u8, 203u8, 68u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [186u8, 154u8, 122u8, 86u8],
+            [188u8, 37u8, 207u8, 119u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [210u8, 18u8, 32u8, 167u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [221u8, 98u8, 237u8, 62u8],
+            [255u8, 246u8, 202u8, 233u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getReservesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <price0CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <price1CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <kLastCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <burnCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <skimCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <syncCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(swap),
+            ::core::stringify!(name),
+            ::core::stringify!(getReserves),
+            ::core::stringify!(approve),
+            ::core::stringify!(token0),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(PERMIT_TYPEHASH),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(initialize),
+            ::core::stringify!(price0CumulativeLast),
+            ::core::stringify!(price1CumulativeLast),
+            ::core::stringify!(mint),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(kLast),
+            ::core::stringify!(nonces),
+            ::core::stringify!(burn),
+            ::core::stringify!(symbol),
+            ::core::stringify!(transfer),
+            ::core::stringify!(MINIMUM_LIQUIDITY),
+            ::core::stringify!(skim),
+            ::core::stringify!(factory),
+            ::core::stringify!(token1),
+            ::core::stringify!(permit),
+            ::core::stringify!(allowance),
+            ::core::stringify!(sync),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for IUniswapLikePairCalls {
+        const COUNT: usize = 27usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "IUniswapLikePairCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::MINIMUM_LIQUIDITY(_) => {
+                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::PERMIT_TYPEHASH(_) => {
+                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::burn(_) => <burnCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getReserves(_) => <getReservesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::kLast(_) => <kLastCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::price0CumulativeLast(_) => {
+                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::price1CumulativeLast(_) => {
+                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::skim(_) => <skimCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::sync(_) => <syncCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls>] = &[
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn getReserves(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <getReservesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::getReserves)
+                    }
+                    getReserves
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn PERMIT_TYPEHASH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::PERMIT_TYPEHASH)
+                    }
+                    PERMIT_TYPEHASH
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::initialize)
+                    }
+                    initialize
+                },
+                {
+                    fn price0CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::price0CumulativeLast)
+                    }
+                    price0CumulativeLast
+                },
+                {
+                    fn price1CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::price1CumulativeLast)
+                    }
+                    price1CumulativeLast
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::kLast)
+                    }
+                    kLast
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn burn(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <burnCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::burn)
+                    }
+                    burn
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn MINIMUM_LIQUIDITY(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::MINIMUM_LIQUIDITY)
+                    }
+                    MINIMUM_LIQUIDITY
+                },
+                {
+                    fn skim(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::skim)
+                    }
+                    skim
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn sync(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <syncCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikePairCalls::sync)
+                    }
+                    sync
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                IUniswapLikePairCalls,
+            >] = &[
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::name)
+                    }
+                    name
+                },
+                {
+                    fn getReserves(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <getReservesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::getReserves)
+                    }
+                    getReserves
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikePairCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn PERMIT_TYPEHASH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikePairCalls::PERMIT_TYPEHASH)
+                    }
+                    PERMIT_TYPEHASH
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikePairCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::initialize)
+                    }
+                    initialize
+                },
+                {
+                    fn price0CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikePairCalls::price0CumulativeLast)
+                    }
+                    price0CumulativeLast
+                },
+                {
+                    fn price1CumulativeLast(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikePairCalls::price1CumulativeLast)
+                    }
+                    price1CumulativeLast
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::kLast)
+                    }
+                    kLast
+                },
+                {
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::nonces)
+                    }
+                    nonces
+                },
+                {
+                    fn burn(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <burnCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::burn)
+                    }
+                    burn
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn MINIMUM_LIQUIDITY(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikePairCalls::MINIMUM_LIQUIDITY)
+                    }
+                    MINIMUM_LIQUIDITY
+                },
+                {
+                    fn skim(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::skim)
+                    }
+                    skim
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn sync(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
+                        <syncCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikePairCalls::sync)
+                    }
+                    sync
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::MINIMUM_LIQUIDITY(inner) => {
+                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::PERMIT_TYPEHASH(inner) => {
+                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::burn(inner) => {
+                    <burnCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getReserves(inner) => {
+                    <getReservesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::initialize(inner) => {
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::kLast(inner) => {
+                    <kLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::price0CumulativeLast(inner) => {
+                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::price1CumulativeLast(inner) => {
+                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::skim(inner) => {
+                    <skimCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::sync(inner) => {
+                    <syncCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::MINIMUM_LIQUIDITY(inner) => {
+                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::PERMIT_TYPEHASH(inner) => {
+                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::burn(inner) => {
+                    <burnCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getReserves(inner) => {
+                    <getReservesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::initialize(inner) => {
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::kLast(inner) => {
+                    <kLastCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::price0CumulativeLast(inner) => {
+                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::price1CumulativeLast(inner) => {
+                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::skim(inner) => {
+                    <skimCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::sync(inner) => {
+                    <syncCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`IUniswapLikePair`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum IUniswapLikePairEvents {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        Burn(Burn),
+        #[allow(missing_docs)]
+        Mint(Mint),
+        #[allow(missing_docs)]
+        Swap(Swap),
+        #[allow(missing_docs)]
+        Sync(Sync),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+    }
+    impl IUniswapLikePairEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                28u8, 65u8, 30u8, 154u8, 150u8, 224u8, 113u8, 36u8, 28u8, 47u8, 33u8, 247u8, 114u8,
+                107u8, 23u8, 174u8, 137u8, 227u8, 202u8, 180u8, 199u8, 139u8, 229u8, 14u8, 6u8,
+                43u8, 3u8, 169u8, 255u8, 251u8, 186u8, 209u8,
+            ],
+            [
+                76u8, 32u8, 155u8, 95u8, 200u8, 173u8, 80u8, 117u8, 143u8, 19u8, 226u8, 225u8, 8u8,
+                139u8, 165u8, 106u8, 86u8, 13u8, 255u8, 105u8, 10u8, 28u8, 111u8, 239u8, 38u8,
+                57u8, 79u8, 76u8, 3u8, 130u8, 28u8, 79u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                215u8, 138u8, 217u8, 95u8, 164u8, 108u8, 153u8, 75u8, 101u8, 81u8, 208u8, 218u8,
+                133u8, 252u8, 39u8, 95u8, 230u8, 19u8, 206u8, 55u8, 101u8, 127u8, 184u8, 213u8,
+                227u8, 209u8, 48u8, 132u8, 1u8, 89u8, 216u8, 34u8,
+            ],
+            [
+                220u8, 205u8, 65u8, 47u8, 11u8, 18u8, 82u8, 129u8, 156u8, 177u8, 253u8, 51u8, 11u8,
+                147u8, 34u8, 76u8, 164u8, 38u8, 18u8, 137u8, 43u8, 179u8, 244u8, 247u8, 137u8,
+                151u8, 110u8, 109u8, 129u8, 147u8, 100u8, 150u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Sync as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Mint as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Swap as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Burn as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(Sync),
+            ::core::stringify!(Mint),
+            ::core::stringify!(Approval),
+            ::core::stringify!(Swap),
+            ::core::stringify!(Burn),
+            ::core::stringify!(Transfer),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for IUniswapLikePairEvents {
+        const COUNT: usize = 6usize;
+        const NAME: &'static str = "IUniswapLikePairEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<Burn as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Burn as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Burn)
+                }
+                Some(<Mint as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Mint as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Mint)
+                }
+                Some(<Swap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Swap as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Swap)
+                }
+                Some(<Sync as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Sync as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Sync)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for IUniswapLikePairEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Burn(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Mint(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Sync(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Burn(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Mint(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Sync(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IUniswapLikePair`](self) contract instance.
+
+    See the [wrapper's documentation](`IUniswapLikePairInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IUniswapLikePairInstance<P, N> {
+        IUniswapLikePairInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IUniswapLikePair`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IUniswapLikePair`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IUniswapLikePairInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IUniswapLikePairInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IUniswapLikePairInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapLikePairInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IUniswapLikePair`](self) contract instance.
+
+        See the [wrapper's documentation](`IUniswapLikePairInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IUniswapLikePairInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IUniswapLikePairInstance<P, N> {
+            IUniswapLikePairInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapLikePairInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`MINIMUM_LIQUIDITY`] function.
+        pub fn MINIMUM_LIQUIDITY(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, MINIMUM_LIQUIDITYCall, N> {
+            self.call_builder(&MINIMUM_LIQUIDITYCall)
+        }
+
+        ///Creates a new call builder for the [`PERMIT_TYPEHASH`] function.
+        pub fn PERMIT_TYPEHASH(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, PERMIT_TYPEHASHCall, N> {
+            self.call_builder(&PERMIT_TYPEHASHCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { owner, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, value })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { owner })
+        }
+
+        ///Creates a new call builder for the [`burn`] function.
+        pub fn burn(
+            &self,
+            to: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, burnCall, N> {
+            self.call_builder(&burnCall { to })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getReserves`] function.
+        pub fn getReserves(&self) -> alloy_contract::SolCallBuilder<&P, getReservesCall, N> {
+            self.call_builder(&getReservesCall)
+        }
+
+        ///Creates a new call builder for the [`initialize`] function.
+        pub fn initialize(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
+            self.call_builder(&initializeCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`kLast`] function.
+        pub fn kLast(&self) -> alloy_contract::SolCallBuilder<&P, kLastCall, N> {
+            self.call_builder(&kLastCall)
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            to: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { to })
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`nonces`] function.
+        pub fn nonces(
+            &self,
+            owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
+            self.call_builder(&noncesCall { owner })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                spender,
+                value,
+                deadline,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`price0CumulativeLast`]
+        /// function.
+        pub fn price0CumulativeLast(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, price0CumulativeLastCall, N> {
+            self.call_builder(&price0CumulativeLastCall)
+        }
+
+        ///Creates a new call builder for the [`price1CumulativeLast`]
+        /// function.
+        pub fn price1CumulativeLast(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, price1CumulativeLastCall, N> {
+            self.call_builder(&price1CumulativeLastCall)
+        }
+
+        ///Creates a new call builder for the [`skim`] function.
+        pub fn skim(
+            &self,
+            to: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, skimCall, N> {
+            self.call_builder(&skimCall { to })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            amount0Out: alloy_sol_types::private::primitives::aliases::U256,
+            amount1Out: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                amount0Out,
+                amount1Out,
+                to,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`sync`] function.
+        pub fn sync(&self) -> alloy_contract::SolCallBuilder<&P, syncCall, N> {
+            self.call_builder(&syncCall)
+        }
+
+        ///Creates a new call builder for the [`token0`] function.
+        pub fn token0(&self) -> alloy_contract::SolCallBuilder<&P, token0Call, N> {
+            self.call_builder(&token0Call)
+        }
+
+        ///Creates a new call builder for the [`token1`] function.
+        pub fn token1(&self) -> alloy_contract::SolCallBuilder<&P, token1Call, N> {
+            self.call_builder(&token1Call)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { to, value })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            from: alloy_sol_types::private::Address,
+            to: alloy_sol_types::private::Address,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall { from, to, value })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapLikePairInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`Burn`] event.
+        pub fn Burn_filter(&self) -> alloy_contract::Event<&P, Burn, N> {
+            self.event_filter::<Burn>()
+        }
+
+        ///Creates a new event filter for the [`Mint`] event.
+        pub fn Mint_filter(&self) -> alloy_contract::Event<&P, Mint, N> {
+            self.event_filter::<Mint>()
+        }
+
+        ///Creates a new event filter for the [`Swap`] event.
+        pub fn Swap_filter(&self) -> alloy_contract::Event<&P, Swap, N> {
+            self.event_filter::<Swap>()
+        }
+
+        ///Creates a new event filter for the [`Sync`] event.
+        pub fn Sync_filter(&self) -> alloy_contract::Event<&P, Sync, N> {
+            self.event_filter::<Sync>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+    }
+}
+pub type Instance = IUniswapLikePair::IUniswapLikePairInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/iuniswaplikerouter/Cargo.toml b/contracts/generated/contracts-generated/iuniswaplikerouter/Cargo.toml
new file mode 100644
index 0000000000..8967d78c34
--- /dev/null
+++ b/contracts/generated/contracts-generated/iuniswaplikerouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-iuniswaplikerouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs b/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs
new file mode 100644
index 0000000000..0e40935392
--- /dev/null
+++ b/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs
@@ -0,0 +1,7529 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface IUniswapLikeRouter {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IUniswapLikeRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`IUniswapLikeRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum IUniswapLikeRouterCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl IUniswapLikeRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for IUniswapLikeRouterCalls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "IUniswapLikeRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<IUniswapLikeRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IUniswapLikeRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                IUniswapLikeRouterCalls,
+            >] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikeRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikeRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikeRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                IUniswapLikeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapLikeRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapLikeRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapLikeRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IUniswapLikeRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`IUniswapLikeRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IUniswapLikeRouterInstance<P, N> {
+        IUniswapLikeRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IUniswapLikeRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IUniswapLikeRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IUniswapLikeRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IUniswapLikeRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IUniswapLikeRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapLikeRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IUniswapLikeRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`IUniswapLikeRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IUniswapLikeRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IUniswapLikeRouterInstance<P, N> {
+            IUniswapLikeRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapLikeRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapLikeRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = IUniswapLikeRouter::IUniswapLikeRouterInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/iuniswapv3factory/Cargo.toml b/contracts/generated/contracts-generated/iuniswapv3factory/Cargo.toml
new file mode 100644
index 0000000000..090a4745e0
--- /dev/null
+++ b/contracts/generated/contracts-generated/iuniswapv3factory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-iuniswapv3factory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
new file mode 100644
index 0000000000..eb6d721593
--- /dev/null
+++ b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
@@ -0,0 +1,2239 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface IUniswapV3Factory {
+    event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);
+    event OwnerChanged(address indexed oldOwner, address indexed newOwner);
+    event PoolCreated(address indexed token0, address indexed token1, uint24 indexed fee, int24 tickSpacing, address pool);
+
+    function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);
+    function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
+    function feeAmountTickSpacing(uint24 fee) external view returns (int24);
+    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);
+    function owner() external view returns (address);
+    function setOwner(address _owner) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "createPool",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "fee",
+        "type": "uint24",
+        "internalType": "uint24"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "enableFeeAmount",
+    "inputs": [
+      {
+        "name": "fee",
+        "type": "uint24",
+        "internalType": "uint24"
+      },
+      {
+        "name": "tickSpacing",
+        "type": "int24",
+        "internalType": "int24"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "feeAmountTickSpacing",
+    "inputs": [
+      {
+        "name": "fee",
+        "type": "uint24",
+        "internalType": "uint24"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "int24",
+        "internalType": "int24"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPool",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "fee",
+        "type": "uint24",
+        "internalType": "uint24"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pool",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setOwner",
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "FeeAmountEnabled",
+    "inputs": [
+      {
+        "name": "fee",
+        "type": "uint24",
+        "indexed": true,
+        "internalType": "uint24"
+      },
+      {
+        "name": "tickSpacing",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnerChanged",
+    "inputs": [
+      {
+        "name": "oldOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolCreated",
+    "inputs": [
+      {
+        "name": "token0",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "fee",
+        "type": "uint24",
+        "indexed": true,
+        "internalType": "uint24"
+      },
+      {
+        "name": "tickSpacing",
+        "type": "int24",
+        "indexed": false,
+        "internalType": "int24"
+      },
+      {
+        "name": "pool",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IUniswapV3Factory {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `FeeAmountEnabled(uint24,int24)` and selector `0xc66a3fdf07232cdd185febcc6579d408c241b47ae2f9907d84be655141eeaecc`.
+    ```solidity
+    event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct FeeAmountEnabled {
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+        #[allow(missing_docs)]
+        pub tickSpacing: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for FeeAmountEnabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FeeAmountEnabled(uint24,int24)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    198u8, 106u8, 63u8, 223u8, 7u8, 35u8, 44u8, 221u8, 24u8, 95u8, 235u8, 204u8,
+                    101u8, 121u8, 212u8, 8u8, 194u8, 65u8, 180u8, 122u8, 226u8, 249u8, 144u8,
+                    125u8, 132u8, 190u8, 101u8, 81u8, 65u8, 238u8, 174u8, 204u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    fee: topics.1,
+                    tickSpacing: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.fee.clone(),
+                    self.tickSpacing.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.fee);
+                out[2usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickSpacing);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FeeAmountEnabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FeeAmountEnabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FeeAmountEnabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OwnerChanged(address,address)` and selector `0xb532073b38c83145e3e5135377a08bf9aab55bc0fd7c1179cd4fb995d2a5159c`.
+    ```solidity
+    event OwnerChanged(address indexed oldOwner, address indexed newOwner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OwnerChanged {
+        #[allow(missing_docs)]
+        pub oldOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OwnerChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OwnerChanged(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    181u8, 50u8, 7u8, 59u8, 56u8, 200u8, 49u8, 69u8, 227u8, 229u8, 19u8, 83u8,
+                    119u8, 160u8, 139u8, 249u8, 170u8, 181u8, 91u8, 192u8, 253u8, 124u8, 17u8,
+                    121u8, 205u8, 79u8, 185u8, 149u8, 210u8, 165u8, 21u8, 156u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    oldOwner: topics.1,
+                    newOwner: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.oldOwner.clone(),
+                    self.newOwner.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.oldOwner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.newOwner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OwnerChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OwnerChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OwnerChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolCreated(address,address,uint24,int24,address)` and selector `0x783cca1c0412dd0d695e784568c96da2e9c22ff989357a2e8b1d9b2b4e6b7118`.
+    ```solidity
+    event PoolCreated(address indexed token0, address indexed token1, uint24 indexed fee, int24 tickSpacing, address pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolCreated {
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+        #[allow(missing_docs)]
+        pub tickSpacing: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<24>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolCreated(address,address,uint24,int24,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    120u8, 60u8, 202u8, 28u8, 4u8, 18u8, 221u8, 13u8, 105u8, 94u8, 120u8, 69u8,
+                    104u8, 201u8, 109u8, 162u8, 233u8, 194u8, 47u8, 249u8, 137u8, 53u8, 122u8,
+                    46u8, 139u8, 29u8, 155u8, 43u8, 78u8, 107u8, 113u8, 24u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    token0: topics.1,
+                    token1: topics.2,
+                    fee: topics.3,
+                    tickSpacing: data.0,
+                    pool: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickSpacing,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pool,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.token0.clone(),
+                    self.token1.clone(),
+                    self.fee.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token0,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token1,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Uint<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.fee);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createPool(address,address,uint24)` and selector `0xa1671295`.
+    ```solidity
+    function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createPoolCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createPool(address,address,uint24)`](createPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createPoolReturn {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<24>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U24,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createPoolCall) -> Self {
+                    (value.tokenA, value.tokenB, value.fee)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        fee: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createPoolReturn) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<24>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [161u8, 103u8, 18u8, 149u8];
+            const SIGNATURE: &'static str = "createPool(address,address,uint24)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createPoolReturn = r.into();
+                        r.pool
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createPoolReturn = r.into();
+                    r.pool
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `enableFeeAmount(uint24,int24)` and selector `0x8a7c195f`.
+    ```solidity
+    function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableFeeAmountCall {
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+        #[allow(missing_docs)]
+        pub tickSpacing: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    ///Container type for the return parameters of the
+    /// [`enableFeeAmount(uint24,int24)`](enableFeeAmountCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct enableFeeAmountReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U24,
+                alloy_sol_types::private::primitives::aliases::I24,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableFeeAmountCall> for UnderlyingRustTuple<'_> {
+                fn from(value: enableFeeAmountCall) -> Self {
+                    (value.fee, value.tickSpacing)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableFeeAmountCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        fee: tuple.0,
+                        tickSpacing: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<enableFeeAmountReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: enableFeeAmountReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableFeeAmountReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl enableFeeAmountReturn {
+            fn _tokenize(
+                &self,
+            ) -> <enableFeeAmountCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for enableFeeAmountCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+            type Return = enableFeeAmountReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [138u8, 124u8, 25u8, 95u8];
+            const SIGNATURE: &'static str = "enableFeeAmount(uint24,int24)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickSpacing,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                enableFeeAmountReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `feeAmountTickSpacing(uint24)` and selector `0x22afcccb`.
+    ```solidity
+    function feeAmountTickSpacing(uint24 fee) external view returns (int24);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeAmountTickSpacingCall {
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`feeAmountTickSpacing(uint24)`](feeAmountTickSpacingCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeAmountTickSpacingReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<24>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U24,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeAmountTickSpacingCall> for UnderlyingRustTuple<'_> {
+                fn from(value: feeAmountTickSpacingCall) -> Self {
+                    (value.fee,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeAmountTickSpacingCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { fee: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::I24,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeAmountTickSpacingReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: feeAmountTickSpacingReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeAmountTickSpacingReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for feeAmountTickSpacingCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<24>,);
+            type Return = alloy_sol_types::private::primitives::aliases::I24;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [34u8, 175u8, 204u8, 203u8];
+            const SIGNATURE: &'static str = "feeAmountTickSpacing(uint24)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: feeAmountTickSpacingReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: feeAmountTickSpacingReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPool(address,address,uint24)` and selector `0x1698ee82`.
+    ```solidity
+    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPool(address,address,uint24)`](getPoolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolReturn {
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<24>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U24,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolCall) -> Self {
+                    (value.tokenA, value.tokenB, value.fee)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        fee: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolReturn) -> Self {
+                    (value.pool,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pool: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<24>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 152u8, 238u8, 130u8];
+            const SIGNATURE: &'static str = "getPool(address,address,uint24)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolReturn = r.into();
+                        r.pool
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolReturn = r.into();
+                    r.pool
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `owner()` and selector `0x8da5cb5b`.
+    ```solidity
+    function owner() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`owner()`](ownerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
+            const SIGNATURE: &'static str = "owner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ownerReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: ownerReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setOwner(address)` and selector `0x13af4035`.
+    ```solidity
+    function setOwner(address _owner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setOwnerCall {
+        #[allow(missing_docs)]
+        pub _owner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setOwner(address)`](setOwnerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setOwnerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setOwnerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setOwnerCall) -> Self {
+                    (value._owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setOwnerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setOwnerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setOwnerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setOwnerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setOwnerReturn {
+            fn _tokenize(&self) -> <setOwnerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setOwnerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setOwnerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [19u8, 175u8, 64u8, 53u8];
+            const SIGNATURE: &'static str = "setOwner(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setOwnerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`IUniswapV3Factory`](self) function calls.
+    #[derive(Clone)]
+    pub enum IUniswapV3FactoryCalls {
+        #[allow(missing_docs)]
+        createPool(createPoolCall),
+        #[allow(missing_docs)]
+        enableFeeAmount(enableFeeAmountCall),
+        #[allow(missing_docs)]
+        feeAmountTickSpacing(feeAmountTickSpacingCall),
+        #[allow(missing_docs)]
+        getPool(getPoolCall),
+        #[allow(missing_docs)]
+        owner(ownerCall),
+        #[allow(missing_docs)]
+        setOwner(setOwnerCall),
+    }
+    impl IUniswapV3FactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [19u8, 175u8, 64u8, 53u8],
+            [22u8, 152u8, 238u8, 130u8],
+            [34u8, 175u8, 204u8, 203u8],
+            [138u8, 124u8, 25u8, 95u8],
+            [141u8, 165u8, 203u8, 91u8],
+            [161u8, 103u8, 18u8, 149u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <setOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <enableFeeAmountCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(setOwner),
+            ::core::stringify!(getPool),
+            ::core::stringify!(feeAmountTickSpacing),
+            ::core::stringify!(enableFeeAmount),
+            ::core::stringify!(owner),
+            ::core::stringify!(createPool),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for IUniswapV3FactoryCalls {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "IUniswapV3FactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::createPool(_) => <createPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::enableFeeAmount(_) => {
+                    <enableFeeAmountCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::feeAmountTickSpacing(_) => {
+                    <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPool(_) => <getPoolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setOwner(_) => <setOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>] =
+                &[
+                    {
+                        fn setOwner(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
+                        {
+                            <setOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(IUniswapV3FactoryCalls::setOwner)
+                        }
+                        setOwner
+                    },
+                    {
+                        fn getPool(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                            <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(IUniswapV3FactoryCalls::getPool)
+                        }
+                        getPool
+                    },
+                    {
+                        fn feeAmountTickSpacing(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
+                        {
+                            <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IUniswapV3FactoryCalls::feeAmountTickSpacing)
+                        }
+                        feeAmountTickSpacing
+                    },
+                    {
+                        fn enableFeeAmount(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
+                        {
+                            <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(IUniswapV3FactoryCalls::enableFeeAmount)
+                        }
+                        enableFeeAmount
+                    },
+                    {
+                        fn owner(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                            <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(IUniswapV3FactoryCalls::owner)
+                        }
+                        owner
+                    },
+                    {
+                        fn createPool(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
+                        {
+                            <createPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(IUniswapV3FactoryCalls::createPool)
+                        }
+                        createPool
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                IUniswapV3FactoryCalls,
+            >] = &[
+                {
+                    fn setOwner(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                        <setOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapV3FactoryCalls::setOwner)
+                    }
+                    setOwner
+                },
+                {
+                    fn getPool(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                        <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapV3FactoryCalls::getPool)
+                    }
+                    getPool
+                },
+                {
+                    fn feeAmountTickSpacing(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                        <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IUniswapV3FactoryCalls::feeAmountTickSpacing)
+                    }
+                    feeAmountTickSpacing
+                },
+                {
+                    fn enableFeeAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                        <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IUniswapV3FactoryCalls::enableFeeAmount)
+                    }
+                    enableFeeAmount
+                },
+                {
+                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapV3FactoryCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn createPool(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
+                        <createPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IUniswapV3FactoryCalls::createPool)
+                    }
+                    createPool
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::createPool(inner) => {
+                    <createPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::enableFeeAmount(inner) => {
+                    <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::feeAmountTickSpacing(inner) => {
+                    <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPool(inner) => {
+                    <getPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setOwner(inner) => {
+                    <setOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::createPool(inner) => {
+                    <createPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::enableFeeAmount(inner) => {
+                    <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::feeAmountTickSpacing(inner) => {
+                    <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getPool(inner) => {
+                    <getPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setOwner(inner) => {
+                    <setOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`IUniswapV3Factory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum IUniswapV3FactoryEvents {
+        #[allow(missing_docs)]
+        FeeAmountEnabled(FeeAmountEnabled),
+        #[allow(missing_docs)]
+        OwnerChanged(OwnerChanged),
+        #[allow(missing_docs)]
+        PoolCreated(PoolCreated),
+    }
+    impl IUniswapV3FactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                120u8, 60u8, 202u8, 28u8, 4u8, 18u8, 221u8, 13u8, 105u8, 94u8, 120u8, 69u8, 104u8,
+                201u8, 109u8, 162u8, 233u8, 194u8, 47u8, 249u8, 137u8, 53u8, 122u8, 46u8, 139u8,
+                29u8, 155u8, 43u8, 78u8, 107u8, 113u8, 24u8,
+            ],
+            [
+                181u8, 50u8, 7u8, 59u8, 56u8, 200u8, 49u8, 69u8, 227u8, 229u8, 19u8, 83u8, 119u8,
+                160u8, 139u8, 249u8, 170u8, 181u8, 91u8, 192u8, 253u8, 124u8, 17u8, 121u8, 205u8,
+                79u8, 185u8, 149u8, 210u8, 165u8, 21u8, 156u8,
+            ],
+            [
+                198u8, 106u8, 63u8, 223u8, 7u8, 35u8, 44u8, 221u8, 24u8, 95u8, 235u8, 204u8, 101u8,
+                121u8, 212u8, 8u8, 194u8, 65u8, 180u8, 122u8, 226u8, 249u8, 144u8, 125u8, 132u8,
+                190u8, 101u8, 81u8, 65u8, 238u8, 174u8, 204u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OwnerChanged as alloy_sol_types::SolEvent>::SIGNATURE,
+            <FeeAmountEnabled as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(PoolCreated),
+            ::core::stringify!(OwnerChanged),
+            ::core::stringify!(FeeAmountEnabled),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for IUniswapV3FactoryEvents {
+        const COUNT: usize = 3usize;
+        const NAME: &'static str = "IUniswapV3FactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<FeeAmountEnabled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <FeeAmountEnabled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::FeeAmountEnabled)
+                }
+                Some(<OwnerChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OwnerChanged as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OwnerChanged)
+                }
+                Some(<PoolCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PoolCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PoolCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for IUniswapV3FactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FeeAmountEnabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OwnerChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::FeeAmountEnabled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OwnerChanged(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PoolCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IUniswapV3Factory`](self) contract instance.
+
+    See the [wrapper's documentation](`IUniswapV3FactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IUniswapV3FactoryInstance<P, N> {
+        IUniswapV3FactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IUniswapV3Factory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IUniswapV3Factory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IUniswapV3FactoryInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IUniswapV3FactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IUniswapV3FactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapV3FactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IUniswapV3Factory`](self) contract instance.
+
+        See the [wrapper's documentation](`IUniswapV3FactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IUniswapV3FactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IUniswapV3FactoryInstance<P, N> {
+            IUniswapV3FactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapV3FactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`createPool`] function.
+        pub fn createPool(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            fee: alloy_sol_types::private::primitives::aliases::U24,
+        ) -> alloy_contract::SolCallBuilder<&P, createPoolCall, N> {
+            self.call_builder(&createPoolCall {
+                tokenA,
+                tokenB,
+                fee,
+            })
+        }
+
+        ///Creates a new call builder for the [`enableFeeAmount`] function.
+        pub fn enableFeeAmount(
+            &self,
+            fee: alloy_sol_types::private::primitives::aliases::U24,
+            tickSpacing: alloy_sol_types::private::primitives::aliases::I24,
+        ) -> alloy_contract::SolCallBuilder<&P, enableFeeAmountCall, N> {
+            self.call_builder(&enableFeeAmountCall { fee, tickSpacing })
+        }
+
+        ///Creates a new call builder for the [`feeAmountTickSpacing`]
+        /// function.
+        pub fn feeAmountTickSpacing(
+            &self,
+            fee: alloy_sol_types::private::primitives::aliases::U24,
+        ) -> alloy_contract::SolCallBuilder<&P, feeAmountTickSpacingCall, N> {
+            self.call_builder(&feeAmountTickSpacingCall { fee })
+        }
+
+        ///Creates a new call builder for the [`getPool`] function.
+        pub fn getPool(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            fee: alloy_sol_types::private::primitives::aliases::U24,
+        ) -> alloy_contract::SolCallBuilder<&P, getPoolCall, N> {
+            self.call_builder(&getPoolCall {
+                tokenA,
+                tokenB,
+                fee,
+            })
+        }
+
+        ///Creates a new call builder for the [`owner`] function.
+        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
+            self.call_builder(&ownerCall)
+        }
+
+        ///Creates a new call builder for the [`setOwner`] function.
+        pub fn setOwner(
+            &self,
+            _owner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setOwnerCall, N> {
+            self.call_builder(&setOwnerCall { _owner })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IUniswapV3FactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`FeeAmountEnabled`] event.
+        pub fn FeeAmountEnabled_filter(&self) -> alloy_contract::Event<&P, FeeAmountEnabled, N> {
+            self.event_filter::<FeeAmountEnabled>()
+        }
+
+        ///Creates a new event filter for the [`OwnerChanged`] event.
+        pub fn OwnerChanged_filter(&self) -> alloy_contract::Event<&P, OwnerChanged, N> {
+            self.event_filter::<OwnerChanged>()
+        }
+
+        ///Creates a new event filter for the [`PoolCreated`] event.
+        pub fn PoolCreated_filter(&self) -> alloy_contract::Event<&P, PoolCreated, N> {
+            self.event_filter::<PoolCreated>()
+        }
+    }
+}
+pub type Instance = IUniswapV3Factory::IUniswapV3FactoryInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0xc3A5b857Ba82a2586A45a8B59ECc3AA50Bc3D0e3"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x33128a8fC17869897dcE68Ed026d694621f6FDfD"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0xcb2436774C3e191c85056d248EF4260ce5f27A9D"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x740b1c1de25031C31FF4fC9A62f554A55cdC1baD"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x640887A9ba3A9C53Ed27D0F7e8246A4F933f3424"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x31FAfd4889FA1269F7a13A66eE0fB458f27D72A9"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/izeroex/Cargo.toml b/contracts/generated/contracts-generated/izeroex/Cargo.toml
new file mode 100644
index 0000000000..394a6db115
--- /dev/null
+++ b/contracts/generated/contracts-generated/izeroex/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-izeroex"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/izeroex/src/lib.rs b/contracts/generated/contracts-generated/izeroex/src/lib.rs
new file mode 100644
index 0000000000..4b1cc35f1d
--- /dev/null
+++ b/contracts/generated/contracts-generated/izeroex/src/lib.rs
@@ -0,0 +1,41951 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IMetaTransactionsFeature {
+    struct MetaTransactionData { address signer; address sender; uint256 minGasPrice; uint256 maxGasPrice; uint256 expirationTimeSeconds; uint256 salt; bytes callData; uint256 value; address feeToken; uint256 feeAmount; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IMetaTransactionsFeature {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct MetaTransactionData { address signer; address sender; uint256 minGasPrice; uint256 maxGasPrice; uint256 expirationTimeSeconds; uint256 salt; bytes callData; uint256 value; address feeToken; uint256 feeAmount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MetaTransactionData {
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minGasPrice: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub maxGasPrice: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub expirationTimeSeconds: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub salt: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<MetaTransactionData> for UnderlyingRustTuple<'_> {
+            fn from(value: MetaTransactionData) -> Self {
+                (
+                    value.signer,
+                    value.sender,
+                    value.minGasPrice,
+                    value.maxGasPrice,
+                    value.expirationTimeSeconds,
+                    value.salt,
+                    value.callData,
+                    value.value,
+                    value.feeToken,
+                    value.feeAmount,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MetaTransactionData {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    signer: tuple.0,
+                    sender: tuple.1,
+                    minGasPrice: tuple.2,
+                    maxGasPrice: tuple.3,
+                    expirationTimeSeconds: tuple.4,
+                    salt: tuple.5,
+                    callData: tuple.6,
+                    value: tuple.7,
+                    feeToken: tuple.8,
+                    feeAmount: tuple.9,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for MetaTransactionData {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for MetaTransactionData {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minGasPrice,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.maxGasPrice,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.expirationTimeSeconds,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.salt,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.feeToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for MetaTransactionData {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for MetaTransactionData {
+            const NAME: &'static str = "MetaTransactionData";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "MetaTransactionData(address signer,address sender,uint256 \
+                     minGasPrice,uint256 maxGasPrice,uint256 expirationTimeSeconds,uint256 \
+                     salt,bytes callData,uint256 value,address feeToken,uint256 feeAmount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signer,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minGasPrice)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxGasPrice)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.expirationTimeSeconds,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.feeToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for MetaTransactionData {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signer,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minGasPrice,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maxGasPrice,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expirationTimeSeconds,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeToken,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeAmount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signer,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minGasPrice,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maxGasPrice,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expirationTimeSeconds,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.salt,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeAmount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IMetaTransactionsFeature`](self) contract instance.
+
+    See the [wrapper's documentation](`IMetaTransactionsFeatureInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IMetaTransactionsFeatureInstance<P, N> {
+        IMetaTransactionsFeatureInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IMetaTransactionsFeature`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IMetaTransactionsFeature`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IMetaTransactionsFeatureInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IMetaTransactionsFeatureInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IMetaTransactionsFeatureInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IMetaTransactionsFeatureInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IMetaTransactionsFeature`](self) contract instance.
+
+        See the [wrapper's documentation](`IMetaTransactionsFeatureInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IMetaTransactionsFeatureInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IMetaTransactionsFeatureInstance<P, N> {
+            IMetaTransactionsFeatureInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IMetaTransactionsFeatureInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IMetaTransactionsFeatureInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IMultiplexFeature {
+    type MultiplexSubcall is uint8;
+    struct BatchSellSubcall { MultiplexSubcall id; uint256 sellAmount; bytes data; }
+    struct MultiHopSellSubcall { MultiplexSubcall id; bytes data; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IMultiplexFeature {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MultiplexSubcall(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<MultiplexSubcall> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl MultiplexSubcall {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for MultiplexSubcall {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<MultiplexSubcall> for u8 {
+            fn from(value: MultiplexSubcall) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for MultiplexSubcall {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for MultiplexSubcall {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct BatchSellSubcall { MultiplexSubcall id; uint256 sellAmount; bytes data; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BatchSellSubcall {
+        #[allow(missing_docs)]
+        pub id: <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            MultiplexSubcall,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<BatchSellSubcall> for UnderlyingRustTuple<'_> {
+            fn from(value: BatchSellSubcall) -> Self {
+                (value.id, value.sellAmount, value.data)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BatchSellSubcall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    id: tuple.0,
+                    sellAmount: tuple.1,
+                    data: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for BatchSellSubcall {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for BatchSellSubcall {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <MultiplexSubcall as alloy_sol_types::SolType>::tokenize(&self.id),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for BatchSellSubcall {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for BatchSellSubcall {
+            const NAME: &'static str = "BatchSellSubcall";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "BatchSellSubcall(uint8 id,uint256 sellAmount,bytes data)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <MultiplexSubcall as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.id,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.data,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for BatchSellSubcall {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <MultiplexSubcall as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.id,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sellAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.data,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <MultiplexSubcall as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.id, out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sellAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.data,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct MultiHopSellSubcall { MultiplexSubcall id; bytes data; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct MultiHopSellSubcall {
+        #[allow(missing_docs)]
+        pub id: <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (MultiplexSubcall, alloy_sol_types::sol_data::Bytes);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<MultiHopSellSubcall> for UnderlyingRustTuple<'_> {
+            fn from(value: MultiHopSellSubcall) -> Self {
+                (value.id, value.data)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MultiHopSellSubcall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    id: tuple.0,
+                    data: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for MultiHopSellSubcall {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for MultiHopSellSubcall {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <MultiplexSubcall as alloy_sol_types::SolType>::tokenize(&self.id),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for MultiHopSellSubcall {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for MultiHopSellSubcall {
+            const NAME: &'static str = "MultiHopSellSubcall";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed("MultiHopSellSubcall(uint8 id,bytes data)")
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <MultiplexSubcall as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.id,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.data,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for MultiHopSellSubcall {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <MultiplexSubcall as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.id,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.data,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <MultiplexSubcall as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.id, out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.data,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IMultiplexFeature`](self) contract instance.
+
+    See the [wrapper's documentation](`IMultiplexFeatureInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IMultiplexFeatureInstance<P, N> {
+        IMultiplexFeatureInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IMultiplexFeature`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IMultiplexFeature`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IMultiplexFeatureInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IMultiplexFeatureInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IMultiplexFeatureInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IMultiplexFeatureInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IMultiplexFeature`](self) contract instance.
+
+        See the [wrapper's documentation](`IMultiplexFeatureInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IMultiplexFeatureInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IMultiplexFeatureInstance<P, N> {
+            IMultiplexFeatureInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IMultiplexFeatureInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IMultiplexFeatureInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IPancakeSwapFeature {
+    type ProtocolFork is uint8;
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IPancakeSwapFeature {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ProtocolFork(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<ProtocolFork> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl ProtocolFork {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for ProtocolFork {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<ProtocolFork> for u8 {
+            fn from(value: ProtocolFork) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ProtocolFork {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ProtocolFork {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IPancakeSwapFeature`](self) contract instance.
+
+    See the [wrapper's documentation](`IPancakeSwapFeatureInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IPancakeSwapFeatureInstance<P, N> {
+        IPancakeSwapFeatureInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IPancakeSwapFeature`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IPancakeSwapFeature`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IPancakeSwapFeatureInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IPancakeSwapFeatureInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IPancakeSwapFeatureInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPancakeSwapFeatureInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IPancakeSwapFeature`](self) contract instance.
+
+        See the [wrapper's documentation](`IPancakeSwapFeatureInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IPancakeSwapFeatureInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IPancakeSwapFeatureInstance<P, N> {
+            IPancakeSwapFeatureInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPancakeSwapFeatureInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IPancakeSwapFeatureInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ITransformERC20Feature {
+    struct TransformERC20Args { address taker; address inputToken; address outputToken; uint256 inputTokenAmount; uint256 minOutputTokenAmount; Transformation[] transformations; bool useSelfBalance; address recipient; }
+    struct Transformation { uint32 deploymentNonce; bytes data; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ITransformERC20Feature {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct TransformERC20Args { address taker; address inputToken; address outputToken; uint256 inputTokenAmount; uint256 minOutputTokenAmount; Transformation[] transformations; bool useSelfBalance; address recipient; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TransformERC20Args {
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minOutputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub transformations:
+            alloy_sol_types::private::Vec<<Transformation as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub useSelfBalance: bool,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Array<Transformation>,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Vec<<Transformation as alloy_sol_types::SolType>::RustType>,
+            bool,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TransformERC20Args> for UnderlyingRustTuple<'_> {
+            fn from(value: TransformERC20Args) -> Self {
+                (
+                    value.taker,
+                    value.inputToken,
+                    value.outputToken,
+                    value.inputTokenAmount,
+                    value.minOutputTokenAmount,
+                    value.transformations,
+                    value.useSelfBalance,
+                    value.recipient,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TransformERC20Args {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    taker: tuple.0,
+                    inputToken: tuple.1,
+                    outputToken: tuple.2,
+                    inputTokenAmount: tuple.3,
+                    minOutputTokenAmount: tuple.4,
+                    transformations: tuple.5,
+                    useSelfBalance: tuple.6,
+                    recipient: tuple.7,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for TransformERC20Args {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for TransformERC20Args {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.inputTokenAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minOutputTokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        Transformation,
+                    > as alloy_sol_types::SolType>::tokenize(&self.transformations),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.useSelfBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TransformERC20Args {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for TransformERC20Args {
+            const NAME: &'static str = "TransformERC20Args";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "TransformERC20Args(address taker,address inputToken,address \
+                     outputToken,uint256 inputTokenAmount,uint256 \
+                     minOutputTokenAmount,Transformation[] transformations,bool \
+                     useSelfBalance,address recipient)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(<Transformation as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<Transformation as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.inputToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.outputToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.inputTokenAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.minOutputTokenAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        Transformation,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.transformations,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.useSelfBalance,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TransformERC20Args {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.inputToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.outputToken,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.inputTokenAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minOutputTokenAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        Transformation,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.transformations,
+                    )
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.useSelfBalance,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.inputToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.outputToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.inputTokenAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minOutputTokenAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    Transformation,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.transformations,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.useSelfBalance,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Transformation { uint32 deploymentNonce; bytes data; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Transformation {
+        #[allow(missing_docs)]
+        pub deploymentNonce: u32,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<32>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (u32, alloy_sol_types::private::Bytes);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Transformation> for UnderlyingRustTuple<'_> {
+            fn from(value: Transformation) -> Self {
+                (value.deploymentNonce, value.data)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Transformation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    deploymentNonce: tuple.0,
+                    data: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Transformation {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Transformation {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.deploymentNonce,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Transformation {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Transformation {
+            const NAME: &'static str = "Transformation";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Transformation(uint32 deploymentNonce,bytes data)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.deploymentNonce,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.data,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Transformation {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Uint<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deploymentNonce,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.data,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Uint<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deploymentNonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.data,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ITransformERC20Feature`](self) contract instance.
+
+    See the [wrapper's documentation](`ITransformERC20FeatureInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ITransformERC20FeatureInstance<P, N> {
+        ITransformERC20FeatureInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ITransformERC20Feature`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ITransformERC20Feature`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ITransformERC20FeatureInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ITransformERC20FeatureInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ITransformERC20FeatureInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ITransformERC20FeatureInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ITransformERC20Feature`](self) contract instance.
+
+        See the [wrapper's documentation](`ITransformERC20FeatureInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ITransformERC20FeatureInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ITransformERC20FeatureInstance<P, N> {
+            ITransformERC20FeatureInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ITransformERC20FeatureInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ITransformERC20FeatureInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library LibNFTOrder {
+    type OrderStatus is uint8;
+    type TradeDirection is uint8;
+    struct ERC1155Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc1155Token; uint256 erc1155TokenId; Property[] erc1155TokenProperties; uint128 erc1155TokenAmount; }
+    struct ERC721Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc721Token; uint256 erc721TokenId; Property[] erc721TokenProperties; }
+    struct Fee { address recipient; uint256 amount; bytes feeData; }
+    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 orderAmount; uint128 remainingAmount; }
+    struct Property { address propertyValidator; bytes propertyData; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod LibNFTOrder {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderStatus(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<OrderStatus> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl OrderStatus {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for OrderStatus {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<OrderStatus> for u8 {
+            fn from(value: OrderStatus) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OrderStatus {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OrderStatus {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TradeDirection(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<TradeDirection> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl TradeDirection {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for TradeDirection {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<TradeDirection> for u8 {
+            fn from(value: TradeDirection) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TradeDirection {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TradeDirection {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct ERC1155Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc1155Token; uint256 erc1155TokenId; Property[] erc1155TokenProperties; uint128 erc1155TokenAmount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ERC1155Order {
+        #[allow(missing_docs)]
+        pub direction: <TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fees: alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc1155Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155TokenProperties:
+            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc1155TokenAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            TradeDirection,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Array<Fee>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Array<Property>,
+            alloy_sol_types::sol_data::Uint<128>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <TradeDirection as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
+            u128,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ERC1155Order> for UnderlyingRustTuple<'_> {
+            fn from(value: ERC1155Order) -> Self {
+                (
+                    value.direction,
+                    value.maker,
+                    value.taker,
+                    value.expiry,
+                    value.nonce,
+                    value.erc20Token,
+                    value.erc20TokenAmount,
+                    value.fees,
+                    value.erc1155Token,
+                    value.erc1155TokenId,
+                    value.erc1155TokenProperties,
+                    value.erc1155TokenAmount,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1155Order {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    direction: tuple.0,
+                    maker: tuple.1,
+                    taker: tuple.2,
+                    expiry: tuple.3,
+                    nonce: tuple.4,
+                    erc20Token: tuple.5,
+                    erc20TokenAmount: tuple.6,
+                    fees: tuple.7,
+                    erc1155Token: tuple.8,
+                    erc1155TokenId: tuple.9,
+                    erc1155TokenProperties: tuple.10,
+                    erc1155TokenAmount: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for ERC1155Order {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for ERC1155Order {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        Fee,
+                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenId),
+                    <alloy_sol_types::sol_data::Array<
+                        Property,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenProperties,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmount),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ERC1155Order {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for ERC1155Order {
+            const NAME: &'static str = "ERC1155Order";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "ERC1155Order(uint8 direction,address maker,address taker,uint256 \
+                     expiry,uint256 nonce,address erc20Token,uint256 erc20TokenAmount,Fee[] \
+                     fees,address erc1155Token,uint256 erc1155TokenId,Property[] \
+                     erc1155TokenProperties,uint128 erc1155TokenAmount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
+                components.push(<Fee as alloy_sol_types::SolStruct>::eip712_root_type());
+                components.extend(<Fee as alloy_sol_types::SolStruct>::eip712_components());
+                components.push(<Property as alloy_sol_types::SolStruct>::eip712_root_type());
+                components.extend(<Property as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <TradeDirection as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.direction,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.maker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc20Token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc20TokenAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        Fee,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fees)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc1155Token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc1155TokenId,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        Property,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc1155TokenProperties,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc1155TokenAmount,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ERC1155Order {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <TradeDirection as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.direction,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiry,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc20Token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc20TokenAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        Fee,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fees)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc1155Token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc1155TokenId,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        Property,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc1155TokenProperties,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc1155TokenAmount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <TradeDirection as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.direction,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc20Token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc20TokenAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    Fee,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fees,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc1155Token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc1155TokenId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    Property,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc1155TokenProperties,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc1155TokenAmount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct ERC721Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc721Token; uint256 erc721TokenId; Property[] erc721TokenProperties; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ERC721Order {
+        #[allow(missing_docs)]
+        pub direction: <TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fees: alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc721Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc721TokenProperties:
+            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            TradeDirection,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Array<Fee>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Array<Property>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <TradeDirection as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ERC721Order> for UnderlyingRustTuple<'_> {
+            fn from(value: ERC721Order) -> Self {
+                (
+                    value.direction,
+                    value.maker,
+                    value.taker,
+                    value.expiry,
+                    value.nonce,
+                    value.erc20Token,
+                    value.erc20TokenAmount,
+                    value.fees,
+                    value.erc721Token,
+                    value.erc721TokenId,
+                    value.erc721TokenProperties,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721Order {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    direction: tuple.0,
+                    maker: tuple.1,
+                    taker: tuple.2,
+                    expiry: tuple.3,
+                    nonce: tuple.4,
+                    erc20Token: tuple.5,
+                    erc20TokenAmount: tuple.6,
+                    fees: tuple.7,
+                    erc721Token: tuple.8,
+                    erc721TokenId: tuple.9,
+                    erc721TokenProperties: tuple.10,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for ERC721Order {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for ERC721Order {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        Fee,
+                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenId),
+                    <alloy_sol_types::sol_data::Array<
+                        Property,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenProperties),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ERC721Order {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for ERC721Order {
+            const NAME: &'static str = "ERC721Order";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "ERC721Order(uint8 direction,address maker,address taker,uint256 \
+                     expiry,uint256 nonce,address erc20Token,uint256 erc20TokenAmount,Fee[] \
+                     fees,address erc721Token,uint256 erc721TokenId,Property[] \
+                     erc721TokenProperties)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
+                components.push(<Fee as alloy_sol_types::SolStruct>::eip712_root_type());
+                components.extend(<Fee as alloy_sol_types::SolStruct>::eip712_components());
+                components.push(<Property as alloy_sol_types::SolStruct>::eip712_root_type());
+                components.extend(<Property as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <TradeDirection as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.direction,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.maker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc20Token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc20TokenAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        Fee,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fees)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc721Token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.erc721TokenId)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        Property,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.erc721TokenProperties,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ERC721Order {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <TradeDirection as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.direction,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiry,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc20Token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc20TokenAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        Fee,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fees)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc721Token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc721TokenId,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        Property,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.erc721TokenProperties,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <TradeDirection as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.direction,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc20Token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc20TokenAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    Fee,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fees,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc721Token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc721TokenId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    Property,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.erc721TokenProperties,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Fee { address recipient; uint256 amount; bytes feeData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Fee {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Fee> for UnderlyingRustTuple<'_> {
+            fn from(value: Fee) -> Self {
+                (value.recipient, value.amount, value.feeData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Fee {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    recipient: tuple.0,
+                    amount: tuple.1,
+                    feeData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Fee {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Fee {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.feeData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Fee {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Fee {
+            const NAME: &'static str = "Fee";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Fee(address recipient,uint256 amount,bytes feeData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.feeData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Fee {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 orderAmount; uint128 remainingAmount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderInfo {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub orderAmount: u128,
+        #[allow(missing_docs)]
+        pub remainingAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            OrderStatus,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            <OrderStatus as alloy_sol_types::SolType>::RustType,
+            u128,
+            u128,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderInfo> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderInfo) -> Self {
+                (
+                    value.orderHash,
+                    value.status,
+                    value.orderAmount,
+                    value.remainingAmount,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderInfo {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    orderHash: tuple.0,
+                    status: tuple.1,
+                    orderAmount: tuple.2,
+                    remainingAmount: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for OrderInfo {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for OrderInfo {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.remainingAmount),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OrderInfo {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for OrderInfo {
+            const NAME: &'static str = "OrderInfo";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "OrderInfo(bytes32 orderHash,uint8 status,uint128 orderAmount,uint128 \
+                     remainingAmount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
+                        .0,
+                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.status,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.remainingAmount,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OrderInfo {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.orderHash,
+                    )
+                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.status,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.orderAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.remainingAmount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.orderHash,
+                    out,
+                );
+                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.status,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.orderAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.remainingAmount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Property { address propertyValidator; bytes propertyData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Property {
+        #[allow(missing_docs)]
+        pub propertyValidator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub propertyData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Property> for UnderlyingRustTuple<'_> {
+            fn from(value: Property) -> Self {
+                (value.propertyValidator, value.propertyData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Property {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    propertyValidator: tuple.0,
+                    propertyData: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Property {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Property {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.propertyValidator,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.propertyData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Property {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Property {
+            const NAME: &'static str = "Property";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Property(address propertyValidator,bytes propertyData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.propertyValidator,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.propertyData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Property {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.propertyValidator,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.propertyData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.propertyValidator,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.propertyData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`LibNFTOrder`](self) contract instance.
+
+    See the [wrapper's documentation](`LibNFTOrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> LibNFTOrderInstance<P, N> {
+        LibNFTOrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`LibNFTOrder`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`LibNFTOrder`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct LibNFTOrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for LibNFTOrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("LibNFTOrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibNFTOrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`LibNFTOrder`](self) contract instance.
+
+        See the [wrapper's documentation](`LibNFTOrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> LibNFTOrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> LibNFTOrderInstance<P, N> {
+            LibNFTOrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibNFTOrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibNFTOrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library LibNativeOrder {
+    type OrderStatus is uint8;
+    struct LimitOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; uint128 takerTokenFeeAmount; address maker; address taker; address sender; address feeRecipient; bytes32 pool; uint64 expiry; uint256 salt; }
+    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 takerTokenFilledAmount; }
+    struct OtcOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; uint256 expiryAndNonce; }
+    struct OtcOrderInfo { bytes32 orderHash; OrderStatus status; }
+    struct RfqOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; bytes32 pool; uint64 expiry; uint256 salt; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod LibNativeOrder {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderStatus(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<OrderStatus> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl OrderStatus {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for OrderStatus {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<OrderStatus> for u8 {
+            fn from(value: OrderStatus) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OrderStatus {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OrderStatus {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct LimitOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; uint128 takerTokenFeeAmount; address maker; address taker; address sender; address feeRecipient; bytes32 pool; uint64 expiry; uint256 salt; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct LimitOrder {
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerAmount: u128,
+        #[allow(missing_docs)]
+        pub takerAmount: u128,
+        #[allow(missing_docs)]
+        pub takerTokenFeeAmount: u128,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub feeRecipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub expiry: u64,
+        #[allow(missing_docs)]
+        pub salt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<64>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            u128,
+            u128,
+            u128,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::FixedBytes<32>,
+            u64,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<LimitOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: LimitOrder) -> Self {
+                (
+                    value.makerToken,
+                    value.takerToken,
+                    value.makerAmount,
+                    value.takerAmount,
+                    value.takerTokenFeeAmount,
+                    value.maker,
+                    value.taker,
+                    value.sender,
+                    value.feeRecipient,
+                    value.pool,
+                    value.expiry,
+                    value.salt,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LimitOrder {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    makerToken: tuple.0,
+                    takerToken: tuple.1,
+                    makerAmount: tuple.2,
+                    takerAmount: tuple.3,
+                    takerTokenFeeAmount: tuple.4,
+                    maker: tuple.5,
+                    taker: tuple.6,
+                    sender: tuple.7,
+                    feeRecipient: tuple.8,
+                    pool: tuple.9,
+                    expiry: tuple.10,
+                    salt: tuple.11,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for LimitOrder {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for LimitOrder {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokenFeeAmount),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.feeRecipient,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                    <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for LimitOrder {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for LimitOrder {
+            const NAME: &'static str = "LimitOrder";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "LimitOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
+                     takerAmount,uint128 takerTokenFeeAmount,address maker,address taker,address \
+                     sender,address feeRecipient,bytes32 pool,uint64 expiry,uint256 salt)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.makerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerTokenFeeAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.maker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.feeRecipient,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pool)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for LimitOrder {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerTokenFeeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeRecipient,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.pool)
+                    + <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiry,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerTokenFeeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeRecipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.pool,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    64,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.salt,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 takerTokenFilledAmount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderInfo {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            OrderStatus,
+            alloy_sol_types::sol_data::Uint<128>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            <OrderStatus as alloy_sol_types::SolType>::RustType,
+            u128,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderInfo> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderInfo) -> Self {
+                (value.orderHash, value.status, value.takerTokenFilledAmount)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderInfo {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    orderHash: tuple.0,
+                    status: tuple.1,
+                    takerTokenFilledAmount: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for OrderInfo {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for OrderInfo {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OrderInfo {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for OrderInfo {
+            const NAME: &'static str = "OrderInfo";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "OrderInfo(bytes32 orderHash,uint8 status,uint128 takerTokenFilledAmount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
+                        .0,
+                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.status,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerTokenFilledAmount,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OrderInfo {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.orderHash,
+                    )
+                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.status,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerTokenFilledAmount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.orderHash,
+                    out,
+                );
+                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.status,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerTokenFilledAmount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OtcOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; uint256 expiryAndNonce; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OtcOrder {
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerAmount: u128,
+        #[allow(missing_docs)]
+        pub takerAmount: u128,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub txOrigin: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiryAndNonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            u128,
+            u128,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OtcOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: OtcOrder) -> Self {
+                (
+                    value.makerToken,
+                    value.takerToken,
+                    value.makerAmount,
+                    value.takerAmount,
+                    value.maker,
+                    value.taker,
+                    value.txOrigin,
+                    value.expiryAndNonce,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OtcOrder {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    makerToken: tuple.0,
+                    takerToken: tuple.1,
+                    makerAmount: tuple.2,
+                    takerAmount: tuple.3,
+                    maker: tuple.4,
+                    taker: tuple.5,
+                    txOrigin: tuple.6,
+                    expiryAndNonce: tuple.7,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for OtcOrder {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for OtcOrder {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.txOrigin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiryAndNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OtcOrder {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for OtcOrder {
+            const NAME: &'static str = "OtcOrder";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "OtcOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
+                     takerAmount,address maker,address taker,address txOrigin,uint256 \
+                     expiryAndNonce)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.makerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.maker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.txOrigin,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.expiryAndNonce,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OtcOrder {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.txOrigin,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiryAndNonce,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.txOrigin,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiryAndNonce,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OtcOrderInfo { bytes32 orderHash; OrderStatus status; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OtcOrderInfo {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>, OrderStatus);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            <OrderStatus as alloy_sol_types::SolType>::RustType,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OtcOrderInfo> for UnderlyingRustTuple<'_> {
+            fn from(value: OtcOrderInfo) -> Self {
+                (value.orderHash, value.status)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OtcOrderInfo {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    orderHash: tuple.0,
+                    status: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for OtcOrderInfo {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for OtcOrderInfo {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for OtcOrderInfo {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for OtcOrderInfo {
+            const NAME: &'static str = "OtcOrderInfo";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "OtcOrderInfo(bytes32 orderHash,uint8 status)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
+                        .0,
+                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.status,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for OtcOrderInfo {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.orderHash,
+                    )
+                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.status,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.orderHash,
+                    out,
+                );
+                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.status,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct RfqOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; bytes32 pool; uint64 expiry; uint256 salt; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct RfqOrder {
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerAmount: u128,
+        #[allow(missing_docs)]
+        pub takerAmount: u128,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub txOrigin: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub expiry: u64,
+        #[allow(missing_docs)]
+        pub salt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<64>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            u128,
+            u128,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::FixedBytes<32>,
+            u64,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<RfqOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: RfqOrder) -> Self {
+                (
+                    value.makerToken,
+                    value.takerToken,
+                    value.makerAmount,
+                    value.takerAmount,
+                    value.maker,
+                    value.taker,
+                    value.txOrigin,
+                    value.pool,
+                    value.expiry,
+                    value.salt,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for RfqOrder {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    makerToken: tuple.0,
+                    takerToken: tuple.1,
+                    makerAmount: tuple.2,
+                    takerAmount: tuple.3,
+                    maker: tuple.4,
+                    taker: tuple.5,
+                    txOrigin: tuple.6,
+                    pool: tuple.7,
+                    expiry: tuple.8,
+                    salt: tuple.9,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for RfqOrder {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for RfqOrder {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerAmount),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.txOrigin,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                    <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for RfqOrder {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for RfqOrder {
+            const NAME: &'static str = "RfqOrder";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "RfqOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
+                     takerAmount,address maker,address taker,address txOrigin,bytes32 pool,uint64 \
+                     expiry,uint256 salt)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.makerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.maker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.txOrigin,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pool)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for RfqOrder {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.txOrigin,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.pool)
+                    + <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiry,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.txOrigin,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.pool,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    64,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.salt,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`LibNativeOrder`](self) contract instance.
+
+    See the [wrapper's documentation](`LibNativeOrderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> LibNativeOrderInstance<P, N> {
+        LibNativeOrderInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`LibNativeOrder`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`LibNativeOrder`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct LibNativeOrderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for LibNativeOrderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("LibNativeOrderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibNativeOrderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`LibNativeOrder`](self) contract instance.
+
+        See the [wrapper's documentation](`LibNativeOrderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> LibNativeOrderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> LibNativeOrderInstance<P, N> {
+            LibNativeOrderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibNativeOrderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibNativeOrderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library LibSignature {
+    type SignatureType is uint8;
+    struct Signature { SignatureType signatureType; uint8 v; bytes32 r; bytes32 s; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod LibSignature {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SignatureType(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<SignatureType> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl SignatureType {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for SignatureType {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<SignatureType> for u8 {
+            fn from(value: SignatureType) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SignatureType {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SignatureType {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Signature { SignatureType signatureType; uint8 v; bytes32 r; bytes32 s; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Signature {
+        #[allow(missing_docs)]
+        pub signatureType: <SignatureType as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            SignatureType,
+            alloy_sol_types::sol_data::Uint<8>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <SignatureType as alloy_sol_types::SolType>::RustType,
+            u8,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Signature> for UnderlyingRustTuple<'_> {
+            fn from(value: Signature) -> Self {
+                (value.signatureType, value.v, value.r, value.s)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Signature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    signatureType: tuple.0,
+                    v: tuple.1,
+                    r: tuple.2,
+                    s: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Signature {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Signature {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <SignatureType as alloy_sol_types::SolType>::tokenize(
+                        &self.signatureType,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Signature {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Signature {
+            const NAME: &'static str = "Signature";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Signature(uint8 signatureType,uint8 v,bytes32 r,bytes32 s)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <SignatureType as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signatureType,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.v)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.r)
+                        .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.s)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Signature {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <SignatureType as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signatureType,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.v)
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.r)
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.s)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <SignatureType as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signatureType,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.v, out);
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.r, out);
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.s, out);
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`LibSignature`](self) contract instance.
+
+    See the [wrapper's documentation](`LibSignatureInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> LibSignatureInstance<P, N> {
+        LibSignatureInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`LibSignature`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`LibSignature`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct LibSignatureInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for LibSignatureInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("LibSignatureInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibSignatureInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`LibSignature`](self) contract instance.
+
+        See the [wrapper's documentation](`LibSignatureInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> LibSignatureInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> LibSignatureInstance<P, N> {
+            LibSignatureInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibSignatureInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LibSignatureInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IMetaTransactionsFeature {
+    struct MetaTransactionData {
+        address payable signer;
+        address sender;
+        uint256 minGasPrice;
+        uint256 maxGasPrice;
+        uint256 expirationTimeSeconds;
+        uint256 salt;
+        bytes callData;
+        uint256 value;
+        address feeToken;
+        uint256 feeAmount;
+    }
+}
+
+library IMultiplexFeature {
+    type MultiplexSubcall is uint8;
+    struct BatchSellSubcall {
+        MultiplexSubcall id;
+        uint256 sellAmount;
+        bytes data;
+    }
+    struct MultiHopSellSubcall {
+        MultiplexSubcall id;
+        bytes data;
+    }
+}
+
+library IPancakeSwapFeature {
+    type ProtocolFork is uint8;
+}
+
+library ITransformERC20Feature {
+    struct TransformERC20Args {
+        address payable taker;
+        address inputToken;
+        address outputToken;
+        uint256 inputTokenAmount;
+        uint256 minOutputTokenAmount;
+        Transformation[] transformations;
+        bool useSelfBalance;
+        address payable recipient;
+    }
+    struct Transformation {
+        uint32 deploymentNonce;
+        bytes data;
+    }
+}
+
+library LibNFTOrder {
+    type OrderStatus is uint8;
+    type TradeDirection is uint8;
+    struct ERC1155Order {
+        TradeDirection direction;
+        address maker;
+        address taker;
+        uint256 expiry;
+        uint256 nonce;
+        address erc20Token;
+        uint256 erc20TokenAmount;
+        Fee[] fees;
+        address erc1155Token;
+        uint256 erc1155TokenId;
+        Property[] erc1155TokenProperties;
+        uint128 erc1155TokenAmount;
+    }
+    struct ERC721Order {
+        TradeDirection direction;
+        address maker;
+        address taker;
+        uint256 expiry;
+        uint256 nonce;
+        address erc20Token;
+        uint256 erc20TokenAmount;
+        Fee[] fees;
+        address erc721Token;
+        uint256 erc721TokenId;
+        Property[] erc721TokenProperties;
+    }
+    struct Fee {
+        address recipient;
+        uint256 amount;
+        bytes feeData;
+    }
+    struct OrderInfo {
+        bytes32 orderHash;
+        OrderStatus status;
+        uint128 orderAmount;
+        uint128 remainingAmount;
+    }
+    struct Property {
+        address propertyValidator;
+        bytes propertyData;
+    }
+}
+
+library LibNativeOrder {
+    type OrderStatus is uint8;
+    struct LimitOrder {
+        address makerToken;
+        address takerToken;
+        uint128 makerAmount;
+        uint128 takerAmount;
+        uint128 takerTokenFeeAmount;
+        address maker;
+        address taker;
+        address sender;
+        address feeRecipient;
+        bytes32 pool;
+        uint64 expiry;
+        uint256 salt;
+    }
+    struct OrderInfo {
+        bytes32 orderHash;
+        OrderStatus status;
+        uint128 takerTokenFilledAmount;
+    }
+    struct OtcOrder {
+        address makerToken;
+        address takerToken;
+        uint128 makerAmount;
+        uint128 takerAmount;
+        address maker;
+        address taker;
+        address txOrigin;
+        uint256 expiryAndNonce;
+    }
+    struct OtcOrderInfo {
+        bytes32 orderHash;
+        OrderStatus status;
+    }
+    struct RfqOrder {
+        address makerToken;
+        address takerToken;
+        uint128 makerAmount;
+        uint128 takerAmount;
+        address maker;
+        address taker;
+        address txOrigin;
+        bytes32 pool;
+        uint64 expiry;
+        uint256 salt;
+    }
+}
+
+library LibSignature {
+    type SignatureType is uint8;
+    struct Signature {
+        SignatureType signatureType;
+        uint8 v;
+        bytes32 r;
+        bytes32 s;
+    }
+}
+
+interface IZeroex {
+    event ERC1155OrderCancelled(address maker, uint256 nonce);
+    event ERC1155OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20FillAmount, address erc1155Token, uint256 erc1155TokenId, uint128 erc1155FillAmount, address matcher);
+    event ERC1155OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc1155Token, uint256 erc1155TokenId, LibNFTOrder.Property[] erc1155TokenProperties, uint128 erc1155TokenAmount);
+    event ERC721OrderCancelled(address maker, uint256 nonce);
+    event ERC721OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, address erc721Token, uint256 erc721TokenId, address matcher);
+    event ERC721OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc721Token, uint256 erc721TokenId, LibNFTOrder.Property[] erc721TokenProperties);
+    event LimitOrderFilled(bytes32 orderHash, address maker, address taker, address feeRecipient, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, uint128 takerTokenFeeFilledAmount, uint256 protocolFeePaid, bytes32 pool);
+    event LiquidityProviderSwap(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount, address provider, address recipient);
+    event MetaTransactionExecuted(bytes32 hash, bytes4 indexed selector, address signer, address sender);
+    event Migrated(address caller, address migrator, address newOwner);
+    event OrderCancelled(bytes32 orderHash, address maker);
+    event OrderSignerRegistered(address maker, address signer, bool allowed);
+    event OtcOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 makerTokenFilledAmount, uint128 takerTokenFilledAmount);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event PairCancelledLimitOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    event PairCancelledRfqOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    event ProxyFunctionUpdated(bytes4 indexed selector, address oldImpl, address newImpl);
+    event QuoteSignerUpdated(address quoteSigner);
+    event RfqOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, bytes32 pool);
+    event RfqOrderOriginsAllowed(address origin, address[] addrs, bool allowed);
+    event TransformedERC20(address indexed taker, address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount);
+    event TransformerDeployerUpdated(address transformerDeployer);
+
+    function _fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, address sender) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function _fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function _fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function _sellHeldTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
+    function _transformERC20(ITransformERC20Feature.TransformERC20Args memory args) external payable returns (uint256 outputTokenAmount);
+    function batchBuyERC1155s(LibNFTOrder.ERC1155Order[] memory sellOrders, LibSignature.Signature[] memory signatures, uint128[] memory erc1155TokenAmounts, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
+    function batchBuyERC721s(LibNFTOrder.ERC721Order[] memory sellOrders, LibSignature.Signature[] memory signatures, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
+    function batchCancelERC1155Orders(uint256[] memory orderNonces) external;
+    function batchCancelERC721Orders(uint256[] memory orderNonces) external;
+    function batchCancelLimitOrders(LibNativeOrder.LimitOrder[] memory orders) external;
+    function batchCancelPairLimitOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    function batchCancelPairLimitOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    function batchCancelPairRfqOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    function batchCancelPairRfqOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    function batchCancelRfqOrders(LibNativeOrder.RfqOrder[] memory orders) external;
+    function batchExecuteMetaTransactions(IMetaTransactionsFeature.MetaTransactionData[] memory mtxs, LibSignature.Signature[] memory signatures) external payable returns (bytes[] memory returnResults);
+    function batchFillLimitOrders(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external payable returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
+    function batchFillRfqOrders(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
+    function batchFillTakerSignedOtcOrders(LibNativeOrder.OtcOrder[] memory orders, LibSignature.Signature[] memory makerSignatures, LibSignature.Signature[] memory takerSignatures, bool[] memory unwrapWeth) external returns (bool[] memory successes);
+    function batchGetLimitOrderRelevantStates(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
+    function batchGetRfqOrderRelevantStates(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
+    function batchMatchERC721Orders(LibNFTOrder.ERC721Order[] memory sellOrders, LibNFTOrder.ERC721Order[] memory buyOrders, LibSignature.Signature[] memory sellOrderSignatures, LibSignature.Signature[] memory buyOrderSignatures) external returns (uint256[] memory profits, bool[] memory successes);
+    function buyERC1155(LibNFTOrder.ERC1155Order memory sellOrder, LibSignature.Signature memory signature, uint128 erc1155BuyAmount, bytes memory callbackData) external payable;
+    function buyERC721(LibNFTOrder.ERC721Order memory sellOrder, LibSignature.Signature memory signature, bytes memory callbackData) external payable;
+    function cancelERC1155Order(uint256 orderNonce) external;
+    function cancelERC721Order(uint256 orderNonce) external;
+    function cancelLimitOrder(LibNativeOrder.LimitOrder memory order) external;
+    function cancelPairLimitOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
+    function cancelPairLimitOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
+    function cancelPairRfqOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
+    function cancelPairRfqOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
+    function cancelRfqOrder(LibNativeOrder.RfqOrder memory order) external;
+    function createTransformWallet() external returns (address wallet);
+    function executeMetaTransaction(IMetaTransactionsFeature.MetaTransactionData memory mtx, LibSignature.Signature memory signature) external payable returns (bytes memory returnResult);
+    function extend(bytes4 selector, address impl) external;
+    function fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function fillOrKillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 makerTokenFilledAmount);
+    function fillOrKillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 makerTokenFilledAmount);
+    function fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function fillOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function fillOtcOrderWithEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    function fillTakerSignedOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
+    function fillTakerSignedOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
+    function getERC1155OrderHash(LibNFTOrder.ERC1155Order memory order) external view returns (bytes32 orderHash);
+    function getERC1155OrderInfo(LibNFTOrder.ERC1155Order memory order) external view returns (LibNFTOrder.OrderInfo memory orderInfo);
+    function getERC721OrderHash(LibNFTOrder.ERC721Order memory order) external view returns (bytes32 orderHash);
+    function getERC721OrderStatus(LibNFTOrder.ERC721Order memory order) external view returns (LibNFTOrder.OrderStatus status);
+    function getERC721OrderStatusBitVector(address maker, uint248 nonceRange) external view returns (uint256 bitVector);
+    function getLimitOrderHash(LibNativeOrder.LimitOrder memory order) external view returns (bytes32 orderHash);
+    function getLimitOrderInfo(LibNativeOrder.LimitOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
+    function getLimitOrderRelevantState(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
+    function getMetaTransactionExecutedBlock(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (uint256 blockNumber);
+    function getMetaTransactionHash(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (bytes32 mtxHash);
+    function getMetaTransactionHashExecutedBlock(bytes32 mtxHash) external view returns (uint256 blockNumber);
+    function getOtcOrderHash(LibNativeOrder.OtcOrder memory order) external view returns (bytes32 orderHash);
+    function getOtcOrderInfo(LibNativeOrder.OtcOrder memory order) external view returns (LibNativeOrder.OtcOrderInfo memory orderInfo);
+    function getProtocolFeeMultiplier() external view returns (uint32 multiplier);
+    function getQuoteSigner() external view returns (address signer);
+    function getRfqOrderHash(LibNativeOrder.RfqOrder memory order) external view returns (bytes32 orderHash);
+    function getRfqOrderInfo(LibNativeOrder.RfqOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
+    function getRfqOrderRelevantState(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
+    function getRollbackEntryAtIndex(bytes4 selector, uint256 idx) external view returns (address impl);
+    function getRollbackLength(bytes4 selector) external view returns (uint256 rollbackLength);
+    function getTransformWallet() external view returns (address wallet);
+    function getTransformerDeployer() external view returns (address deployer);
+    function isValidOrderSigner(address maker, address signer) external view returns (bool isAllowed);
+    function lastOtcTxOriginNonce(address txOrigin, uint64 nonceBucket) external view returns (uint128 lastNonce);
+    function matchERC721Orders(LibNFTOrder.ERC721Order memory sellOrder, LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory sellOrderSignature, LibSignature.Signature memory buyOrderSignature) external returns (uint256 profit);
+    function migrate(address target, bytes memory data, address newOwner) external;
+    function multiplexBatchSellEthForToken(address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
+    function multiplexBatchSellTokenForEth(address inputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    function multiplexBatchSellTokenForToken(address inputToken, address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    function multiplexMultiHopSellEthForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
+    function multiplexMultiHopSellTokenForEth(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    function multiplexMultiHopSellTokenForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    function onERC1155Received(address operator, address from, uint256 tokenId, uint256 value, bytes memory data) external returns (bytes4 success);
+    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) external returns (bytes4 success);
+    function owner() external view returns (address ownerAddress);
+    function preSignERC1155Order(LibNFTOrder.ERC1155Order memory order) external;
+    function preSignERC721Order(LibNFTOrder.ERC721Order memory order) external;
+    function registerAllowedOrderSigner(address signer, bool allowed) external;
+    function registerAllowedRfqOrigins(address[] memory origins, bool allowed) external;
+    function rollback(bytes4 selector, address targetImpl) external;
+    function sellERC1155(LibNFTOrder.ERC1155Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc1155TokenId, uint128 erc1155SellAmount, bool unwrapNativeToken, bytes memory callbackData) external;
+    function sellERC721(LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc721TokenId, bool unwrapNativeToken, bytes memory callbackData) external;
+    function sellEthForTokenToUniswapV3(bytes memory encodedPath, uint256 minBuyAmount, address recipient) external payable returns (uint256 buyAmount);
+    function sellToLiquidityProvider(address inputToken, address outputToken, address provider, address recipient, uint256 sellAmount, uint256 minBuyAmount, bytes memory auxiliaryData) external payable returns (uint256 boughtAmount);
+    function sellToPancakeSwap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, IPancakeSwapFeature.ProtocolFork fork) external payable returns (uint256 buyAmount);
+    function sellToUniswap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, bool isSushi) external payable returns (uint256 buyAmount);
+    function sellTokenForEthToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address payable recipient) external returns (uint256 buyAmount);
+    function sellTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
+    function setQuoteSigner(address quoteSigner) external;
+    function setTransformerDeployer(address transformerDeployer) external;
+    function supportInterface(bytes4 interfaceId) external pure returns (bool isSupported);
+    function transferOwnership(address newOwner) external;
+    function transferProtocolFeesForPools(bytes32[] memory poolIds) external;
+    function transferTrappedTokensTo(address erc20, uint256 amountOut, address payable recipientWallet) external;
+    function transformERC20(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 minOutputTokenAmount, ITransformERC20Feature.Transformation[] memory transformations) external payable returns (uint256 outputTokenAmount);
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data) external;
+    function validateERC1155OrderProperties(LibNFTOrder.ERC1155Order memory order, uint256 erc1155TokenId) external view;
+    function validateERC1155OrderSignature(LibNFTOrder.ERC1155Order memory order, LibSignature.Signature memory signature) external view;
+    function validateERC721OrderProperties(LibNFTOrder.ERC721Order memory order, uint256 erc721TokenId) external view;
+    function validateERC721OrderSignature(LibNFTOrder.ERC721Order memory order, LibSignature.Signature memory signature) external view;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "_fillLimitOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "_fillOtcOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "useSelfBalance",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "_fillRfqOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "useSelfBalance",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "_sellHeldTokenForTokenToUniswapV3",
+    "inputs": [
+      {
+        "name": "encodedPath",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "_transformERC20",
+    "inputs": [
+      {
+        "name": "args",
+        "type": "tuple",
+        "internalType": "struct ITransformERC20Feature.TransformERC20Args",
+        "components": [
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "inputToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "outputToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "inputTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minOutputTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "transformations",
+            "type": "tuple[]",
+            "internalType": "struct ITransformERC20Feature.Transformation[]",
+            "components": [
+              {
+                "name": "deploymentNonce",
+                "type": "uint32",
+                "internalType": "uint32"
+              },
+              {
+                "name": "data",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "useSelfBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "outputTokenAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "batchBuyERC1155s",
+    "inputs": [
+      {
+        "name": "sellOrders",
+        "type": "tuple[]",
+        "internalType": "struct LibNFTOrder.ERC1155Order[]",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "erc1155TokenAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "callbackData",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      },
+      {
+        "name": "revertIfIncomplete",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "successes",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "batchBuyERC721s",
+    "inputs": [
+      {
+        "name": "sellOrders",
+        "type": "tuple[]",
+        "internalType": "struct LibNFTOrder.ERC721Order[]",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "callbackData",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      },
+      {
+        "name": "revertIfIncomplete",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "successes",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelERC1155Orders",
+    "inputs": [
+      {
+        "name": "orderNonces",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelERC721Orders",
+    "inputs": [
+      {
+        "name": "orderNonces",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelLimitOrders",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.LimitOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelPairLimitOrders",
+    "inputs": [
+      {
+        "name": "makerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "takerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "minValidSalts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelPairLimitOrdersWithSigner",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "makerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "takerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "minValidSalts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelPairRfqOrders",
+    "inputs": [
+      {
+        "name": "makerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "takerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "minValidSalts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelPairRfqOrdersWithSigner",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "makerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "takerTokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "minValidSalts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchCancelRfqOrders",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.RfqOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchExecuteMetaTransactions",
+    "inputs": [
+      {
+        "name": "mtxs",
+        "type": "tuple[]",
+        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData[]",
+        "components": [
+          {
+            "name": "signer",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "expirationTimeSeconds",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "returnResults",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "batchFillLimitOrders",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.LimitOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "revertIfIncomplete",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "makerTokenFilledAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "batchFillRfqOrders",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.RfqOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "revertIfIncomplete",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "makerTokenFilledAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchFillTakerSignedOtcOrders",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.OtcOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerSignatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "unwrapWeth",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "successes",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "batchGetLimitOrderRelevantStates",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.LimitOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfos",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.OrderInfo[]",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "actualFillableTakerTokenAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "isSignatureValids",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "batchGetRfqOrderRelevantStates",
+    "inputs": [
+      {
+        "name": "orders",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.RfqOrder[]",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfos",
+        "type": "tuple[]",
+        "internalType": "struct LibNativeOrder.OrderInfo[]",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "actualFillableTakerTokenAmounts",
+        "type": "uint128[]",
+        "internalType": "uint128[]"
+      },
+      {
+        "name": "isSignatureValids",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "batchMatchERC721Orders",
+    "inputs": [
+      {
+        "name": "sellOrders",
+        "type": "tuple[]",
+        "internalType": "struct LibNFTOrder.ERC721Order[]",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "buyOrders",
+        "type": "tuple[]",
+        "internalType": "struct LibNFTOrder.ERC721Order[]",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "sellOrderSignatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "buyOrderSignatures",
+        "type": "tuple[]",
+        "internalType": "struct LibSignature.Signature[]",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "profits",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "successes",
+        "type": "bool[]",
+        "internalType": "bool[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "buyERC1155",
+    "inputs": [
+      {
+        "name": "sellOrder",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "erc1155BuyAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "callbackData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "buyERC721",
+    "inputs": [
+      {
+        "name": "sellOrder",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "callbackData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "cancelERC1155Order",
+    "inputs": [
+      {
+        "name": "orderNonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelERC721Order",
+    "inputs": [
+      {
+        "name": "orderNonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelLimitOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelPairLimitOrders",
+    "inputs": [
+      {
+        "name": "makerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelPairLimitOrdersWithSigner",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelPairRfqOrders",
+    "inputs": [
+      {
+        "name": "makerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelPairRfqOrdersWithSigner",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "cancelRfqOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "createTransformWallet",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "wallet",
+        "type": "address",
+        "internalType": "contract IFlashWallet"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "executeMetaTransaction",
+    "inputs": [
+      {
+        "name": "mtx",
+        "type": "tuple",
+        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
+        "components": [
+          {
+            "name": "signer",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "expirationTimeSeconds",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "returnResult",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "extend",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      },
+      {
+        "name": "impl",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillLimitOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "fillOrKillLimitOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "fillOrKillRfqOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillOtcOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillOtcOrderForEth",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillOtcOrderWithEth",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "fillRfqOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillTakerSignedOtcOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillTakerSignedOtcOrderForEth",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "makerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getERC1155OrderHash",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getERC1155OrderInfo",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.OrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.OrderStatus"
+          },
+          {
+            "name": "orderAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "remainingAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getERC721OrderHash",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getERC721OrderStatus",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "status",
+        "type": "uint8",
+        "internalType": "enum LibNFTOrder.OrderStatus"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getERC721OrderStatusBitVector",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "nonceRange",
+        "type": "uint248",
+        "internalType": "uint248"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "bitVector",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getLimitOrderHash",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getLimitOrderInfo",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getLimitOrderRelevantState",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "actualFillableTakerTokenAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "isSignatureValid",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getMetaTransactionExecutedBlock",
+    "inputs": [
+      {
+        "name": "mtx",
+        "type": "tuple",
+        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
+        "components": [
+          {
+            "name": "signer",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "expirationTimeSeconds",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "blockNumber",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getMetaTransactionHash",
+    "inputs": [
+      {
+        "name": "mtx",
+        "type": "tuple",
+        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
+        "components": [
+          {
+            "name": "signer",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "maxGasPrice",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "expirationTimeSeconds",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "feeAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "mtxHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getMetaTransactionHashExecutedBlock",
+    "inputs": [
+      {
+        "name": "mtxHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "blockNumber",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOtcOrderHash",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOtcOrderInfo",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiryAndNonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OtcOrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getProtocolFeeMultiplier",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "multiplier",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getQuoteSigner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "signer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRfqOrderHash",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRfqOrderInfo",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRfqOrderRelevantState",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.RfqOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "txOrigin",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "actualFillableTakerTokenAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "isSignatureValid",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRollbackEntryAtIndex",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      },
+      {
+        "name": "idx",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "impl",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getRollbackLength",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "rollbackLength",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getTransformWallet",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "wallet",
+        "type": "address",
+        "internalType": "contract IFlashWallet"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getTransformerDeployer",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "deployer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isValidOrderSigner",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "signer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "isAllowed",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "lastOtcTxOriginNonce",
+    "inputs": [
+      {
+        "name": "txOrigin",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "nonceBucket",
+        "type": "uint64",
+        "internalType": "uint64"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "lastNonce",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "matchERC721Orders",
+    "inputs": [
+      {
+        "name": "sellOrder",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "buyOrder",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "sellOrderSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "buyOrderSignature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "profit",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "migrate",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "multiplexBatchSellEthForToken",
+    "inputs": [
+      {
+        "name": "outputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
+        "components": [
+          {
+            "name": "id",
+            "type": "uint8",
+            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "multiplexBatchSellTokenForEth",
+    "inputs": [
+      {
+        "name": "inputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
+        "components": [
+          {
+            "name": "id",
+            "type": "uint8",
+            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "multiplexBatchSellTokenForToken",
+    "inputs": [
+      {
+        "name": "inputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
+        "components": [
+          {
+            "name": "id",
+            "type": "uint8",
+            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
+          },
+          {
+            "name": "sellAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "multiplexMultiHopSellEthForToken",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
+        "components": [
+          {
+            "name": "id",
+            "type": "uint8",
+            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "multiplexMultiHopSellTokenForEth",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
+        "components": [
+          {
+            "name": "id",
+            "type": "uint8",
+            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "multiplexMultiHopSellTokenForToken",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
+        "components": [
+          {
+            "name": "id",
+            "type": "uint8",
+            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onERC1155Received",
+    "inputs": [
+      {
+        "name": "operator",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "onERC721Received",
+    "inputs": [
+      {
+        "name": "operator",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "ownerAddress",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "preSignERC1155Order",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "preSignERC721Order",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "registerAllowedOrderSigner",
+    "inputs": [
+      {
+        "name": "signer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "registerAllowedRfqOrigins",
+    "inputs": [
+      {
+        "name": "origins",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "rollback",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      },
+      {
+        "name": "targetImpl",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "sellERC1155",
+    "inputs": [
+      {
+        "name": "buyOrder",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "erc1155TokenId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155SellAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "unwrapNativeToken",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "callbackData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "sellERC721",
+    "inputs": [
+      {
+        "name": "buyOrder",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "erc721TokenId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "unwrapNativeToken",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "callbackData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "sellEthForTokenToUniswapV3",
+    "inputs": [
+      {
+        "name": "encodedPath",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "sellToLiquidityProvider",
+    "inputs": [
+      {
+        "name": "inputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "provider",
+        "type": "address",
+        "internalType": "contract ILiquidityProvider"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "auxiliaryData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "boughtAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "sellToPancakeSwap",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "fork",
+        "type": "uint8",
+        "internalType": "enum IPancakeSwapFeature.ProtocolFork"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "sellToUniswap",
+    "inputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20TokenV06[]"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "isSushi",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "sellTokenForEthToUniswapV3",
+    "inputs": [
+      {
+        "name": "encodedPath",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address payable"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "sellTokenForTokenToUniswapV3",
+    "inputs": [
+      {
+        "name": "encodedPath",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minBuyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "buyAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setQuoteSigner",
+    "inputs": [
+      {
+        "name": "quoteSigner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setTransformerDeployer",
+    "inputs": [
+      {
+        "name": "transformerDeployer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "supportInterface",
+    "inputs": [
+      {
+        "name": "interfaceId",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "isSupported",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "transferOwnership",
+    "inputs": [
+      {
+        "name": "newOwner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferProtocolFeesForPools",
+    "inputs": [
+      {
+        "name": "poolIds",
+        "type": "bytes32[]",
+        "internalType": "bytes32[]"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferTrappedTokensTo",
+    "inputs": [
+      {
+        "name": "erc20",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "recipientWallet",
+        "type": "address",
+        "internalType": "address payable"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transformERC20",
+    "inputs": [
+      {
+        "name": "inputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "inputTokenAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minOutputTokenAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "transformations",
+        "type": "tuple[]",
+        "internalType": "struct ITransformERC20Feature.Transformation[]",
+        "components": [
+          {
+            "name": "deploymentNonce",
+            "type": "uint32",
+            "internalType": "uint32"
+          },
+          {
+            "name": "data",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "outputTokenAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "uniswapV3SwapCallback",
+    "inputs": [
+      {
+        "name": "amount0Delta",
+        "type": "int256",
+        "internalType": "int256"
+      },
+      {
+        "name": "amount1Delta",
+        "type": "int256",
+        "internalType": "int256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "validateERC1155OrderProperties",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "erc1155TokenId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "validateERC1155OrderSignature",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC1155Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155Token",
+            "type": "address",
+            "internalType": "contract IERC1155Token"
+          },
+          {
+            "name": "erc1155TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc1155TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc1155TokenAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "validateERC721OrderProperties",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "erc721TokenId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "validateERC721OrderSignature",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNFTOrder.ERC721Order",
+        "components": [
+          {
+            "name": "direction",
+            "type": "uint8",
+            "internalType": "enum LibNFTOrder.TradeDirection"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "expiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc20Token",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "erc20TokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fees",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Fee[]",
+            "components": [
+              {
+                "name": "recipient",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "feeData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "erc721Token",
+            "type": "address",
+            "internalType": "contract IERC721Token"
+          },
+          {
+            "name": "erc721TokenId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "erc721TokenProperties",
+            "type": "tuple[]",
+            "internalType": "struct LibNFTOrder.Property[]",
+            "components": [
+              {
+                "name": "propertyValidator",
+                "type": "address",
+                "internalType": "contract IPropertyValidator"
+              },
+              {
+                "name": "propertyData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "ERC1155OrderCancelled",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC1155OrderFilled",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20FillAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC1155Token"
+      },
+      {
+        "name": "erc1155TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155FillAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "matcher",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC1155OrderPreSigned",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "expiry",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20TokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "fees",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Fee[]",
+        "components": [
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "erc1155Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC1155Token"
+      },
+      {
+        "name": "erc1155TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155TokenProperties",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Property[]",
+        "components": [
+          {
+            "name": "propertyValidator",
+            "type": "address",
+            "internalType": "contract IPropertyValidator"
+          },
+          {
+            "name": "propertyData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "erc1155TokenAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC721OrderCancelled",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC721OrderFilled",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20TokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc721Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC721Token"
+      },
+      {
+        "name": "erc721TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "matcher",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC721OrderPreSigned",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "expiry",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20TokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "fees",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Fee[]",
+        "components": [
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "erc721Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC721Token"
+      },
+      {
+        "name": "erc721TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc721TokenProperties",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Property[]",
+        "components": [
+          {
+            "name": "propertyValidator",
+            "type": "address",
+            "internalType": "contract IPropertyValidator"
+          },
+          {
+            "name": "propertyData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "LimitOrderFilled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "feeRecipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "takerTokenFeeFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "protocolFeePaid",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "pool",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "LiquidityProviderSwap",
+    "inputs": [
+      {
+        "name": "inputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "inputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "outputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "provider",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract ILiquidityProvider"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "MetaTransactionExecuted",
+    "inputs": [
+      {
+        "name": "hash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": true,
+        "internalType": "bytes4"
+      },
+      {
+        "name": "signer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Migrated",
+    "inputs": [
+      {
+        "name": "caller",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "migrator",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderCancelled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderSignerRegistered",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "signer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OtcOrderFilled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PairCancelledLimitOrders",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PairCancelledRfqOrders",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProxyFunctionUpdated",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": true,
+        "internalType": "bytes4"
+      },
+      {
+        "name": "oldImpl",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "newImpl",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "QuoteSignerUpdated",
+    "inputs": [
+      {
+        "name": "quoteSigner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RfqOrderFilled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "pool",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RfqOrderOriginsAllowed",
+    "inputs": [
+      {
+        "name": "origin",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "addrs",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TransformedERC20",
+    "inputs": [
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "inputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "inputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "outputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TransformerDeployerUpdated",
+    "inputs": [
+      {
+        "name": "transformerDeployer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IZeroex {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC1155OrderCancelled(address,uint256)` and selector `0x4d5ea7da64f50a4a329921b8d2cab52dff4ebcc58b61d10ff839e28e91445684`.
+    ```solidity
+    event ERC1155OrderCancelled(address maker, uint256 nonce);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC1155OrderCancelled {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC1155OrderCancelled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC1155OrderCancelled(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    77u8, 94u8, 167u8, 218u8, 100u8, 245u8, 10u8, 74u8, 50u8, 153u8, 33u8, 184u8,
+                    210u8, 202u8, 181u8, 45u8, 255u8, 78u8, 188u8, 197u8, 139u8, 97u8, 209u8, 15u8,
+                    248u8, 57u8, 226u8, 142u8, 145u8, 68u8, 86u8, 132u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    nonce: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC1155OrderCancelled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC1155OrderCancelled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC1155OrderCancelled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC1155OrderFilled(uint8,address,address,uint256,address,uint256,address,uint256,uint128,address)` and selector `0x20cca81b0e269b265b3229d6b537da91ef475ca0ef55caed7dd30731700ba98d`.
+    ```solidity
+    event ERC1155OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20FillAmount, address erc1155Token, uint256 erc1155TokenId, uint128 erc1155FillAmount, address matcher);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC1155OrderFilled {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20FillAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155FillAmount: u128,
+        #[allow(missing_docs)]
+        pub matcher: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC1155OrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC1155OrderFilled(uint8,address,address,uint256,\
+                                             address,uint256,address,uint256,uint128,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    32u8, 204u8, 168u8, 27u8, 14u8, 38u8, 155u8, 38u8, 91u8, 50u8, 41u8, 214u8,
+                    181u8, 55u8, 218u8, 145u8, 239u8, 71u8, 92u8, 160u8, 239u8, 85u8, 202u8, 237u8,
+                    125u8, 211u8, 7u8, 49u8, 112u8, 11u8, 169u8, 141u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    nonce: data.3,
+                    erc20Token: data.4,
+                    erc20FillAmount: data.5,
+                    erc1155Token: data.6,
+                    erc1155TokenId: data.7,
+                    erc1155FillAmount: data.8,
+                    matcher: data.9,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20FillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155FillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.matcher,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC1155OrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC1155OrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC1155OrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC1155OrderPreSigned(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)` and selector `0x5e91ddfeb7bf2e12f7e8ab017d2b63a9217f004a15a53346ad90353ec63d14e4`.
+    ```solidity
+    event ERC1155OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc1155Token, uint256 erc1155TokenId, LibNFTOrder.Property[] erc1155TokenProperties, uint128 erc1155TokenAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC1155OrderPreSigned {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fees:
+            alloy_sol_types::private::Vec<<LibNFTOrder::Fee as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc1155Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155TokenProperties: alloy_sol_types::private::Vec<
+            <LibNFTOrder::Property as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub erc1155TokenAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC1155OrderPreSigned {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Fee>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Property>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC1155OrderPreSigned(uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[],uint128)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    94u8, 145u8, 221u8, 254u8, 183u8, 191u8, 46u8, 18u8, 247u8, 232u8, 171u8, 1u8,
+                    125u8, 43u8, 99u8, 169u8, 33u8, 127u8, 0u8, 74u8, 21u8, 165u8, 51u8, 70u8,
+                    173u8, 144u8, 53u8, 62u8, 198u8, 61u8, 20u8, 228u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    expiry: data.3,
+                    nonce: data.4,
+                    erc20Token: data.5,
+                    erc20TokenAmount: data.6,
+                    fees: data.7,
+                    erc1155Token: data.8,
+                    erc1155TokenId: data.9,
+                    erc1155TokenProperties: data.10,
+                    erc1155TokenAmount: data.11,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Fee,
+                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenId),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Property,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenProperties,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmount),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC1155OrderPreSigned {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC1155OrderPreSigned> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC1155OrderPreSigned) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC721OrderCancelled(address,uint256)` and selector `0xa015ad2dc32f266993958a0fd9884c746b971b254206f3478bc43e2f125c7b9e`.
+    ```solidity
+    event ERC721OrderCancelled(address maker, uint256 nonce);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC721OrderCancelled {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC721OrderCancelled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC721OrderCancelled(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 21u8, 173u8, 45u8, 195u8, 47u8, 38u8, 105u8, 147u8, 149u8, 138u8, 15u8,
+                    217u8, 136u8, 76u8, 116u8, 107u8, 151u8, 27u8, 37u8, 66u8, 6u8, 243u8, 71u8,
+                    139u8, 196u8, 62u8, 47u8, 18u8, 92u8, 123u8, 158u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    nonce: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC721OrderCancelled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC721OrderCancelled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC721OrderCancelled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC721OrderFilled(uint8,address,address,uint256,address,uint256,address,uint256,address)` and selector `0x50273fa02273cceea9cf085b42de5c8af60624140168bd71357db833535877af`.
+    ```solidity
+    event ERC721OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, address erc721Token, uint256 erc721TokenId, address matcher);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC721OrderFilled {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc721Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub matcher: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC721OrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC721OrderFilled(uint8,address,address,uint256,\
+                                             address,uint256,address,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    80u8, 39u8, 63u8, 160u8, 34u8, 115u8, 204u8, 238u8, 169u8, 207u8, 8u8, 91u8,
+                    66u8, 222u8, 92u8, 138u8, 246u8, 6u8, 36u8, 20u8, 1u8, 104u8, 189u8, 113u8,
+                    53u8, 125u8, 184u8, 51u8, 83u8, 88u8, 119u8, 175u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    nonce: data.3,
+                    erc20Token: data.4,
+                    erc20TokenAmount: data.5,
+                    erc721Token: data.6,
+                    erc721TokenId: data.7,
+                    matcher: data.8,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20TokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721TokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.matcher,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC721OrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC721OrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC721OrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC721OrderPreSigned(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])` and selector `0x8c5d0c41fb16a7317a6c55ff7ba93d9d74f79e434fefa694e50d6028afbfa3f0`.
+    ```solidity
+    event ERC721OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc721Token, uint256 erc721TokenId, LibNFTOrder.Property[] erc721TokenProperties);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC721OrderPreSigned {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fees:
+            alloy_sol_types::private::Vec<<LibNFTOrder::Fee as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc721Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc721TokenProperties: alloy_sol_types::private::Vec<
+            <LibNFTOrder::Property as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC721OrderPreSigned {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Fee>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Property>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC721OrderPreSigned(uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 93u8, 12u8, 65u8, 251u8, 22u8, 167u8, 49u8, 122u8, 108u8, 85u8, 255u8,
+                    123u8, 169u8, 61u8, 157u8, 116u8, 247u8, 158u8, 67u8, 79u8, 239u8, 166u8,
+                    148u8, 229u8, 13u8, 96u8, 40u8, 175u8, 191u8, 163u8, 240u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    expiry: data.3,
+                    nonce: data.4,
+                    erc20Token: data.5,
+                    erc20TokenAmount: data.6,
+                    fees: data.7,
+                    erc721Token: data.8,
+                    erc721TokenId: data.9,
+                    erc721TokenProperties: data.10,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Fee,
+                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenId),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Property,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenProperties),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC721OrderPreSigned {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC721OrderPreSigned> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC721OrderPreSigned) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `LimitOrderFilled(bytes32,address,address,address,address,address,uint128,uint128,uint128,uint256,bytes32)` and selector `0xab614d2b738543c0ea21f56347cf696a3a0c42a7cbec3212a5ca22a4dcff2124`.
+    ```solidity
+    event LimitOrderFilled(bytes32 orderHash, address maker, address taker, address feeRecipient, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, uint128 takerTokenFeeFilledAmount, uint256 protocolFeePaid, bytes32 pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct LimitOrderFilled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub feeRecipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub takerTokenFeeFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub protocolFeePaid: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for LimitOrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "LimitOrderFilled(bytes32,address,address,address,\
+                                             address,address,uint128,uint128,uint128,uint256,\
+                                             bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    171u8, 97u8, 77u8, 43u8, 115u8, 133u8, 67u8, 192u8, 234u8, 33u8, 245u8, 99u8,
+                    71u8, 207u8, 105u8, 106u8, 58u8, 12u8, 66u8, 167u8, 203u8, 236u8, 50u8, 18u8,
+                    165u8, 202u8, 34u8, 164u8, 220u8, 255u8, 33u8, 36u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    feeRecipient: data.3,
+                    makerToken: data.4,
+                    takerToken: data.5,
+                    takerTokenFilledAmount: data.6,
+                    makerTokenFilledAmount: data.7,
+                    takerTokenFeeFilledAmount: data.8,
+                    protocolFeePaid: data.9,
+                    pool: data.10,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.feeRecipient,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFeeFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.protocolFeePaid),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for LimitOrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&LimitOrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &LimitOrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `LiquidityProviderSwap(address,address,uint256,uint256,address,address)` and selector `0x40a6ba9513d09e3488135e0e0d10e2d4382b792720155b144cbea89ac9db6d34`.
+    ```solidity
+    event LiquidityProviderSwap(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount, address provider, address recipient);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct LiquidityProviderSwap {
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub provider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for LiquidityProviderSwap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "LiquidityProviderSwap(address,address,uint256,uint256,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    64u8, 166u8, 186u8, 149u8, 19u8, 208u8, 158u8, 52u8, 136u8, 19u8, 94u8, 14u8,
+                    13u8, 16u8, 226u8, 212u8, 56u8, 43u8, 121u8, 39u8, 32u8, 21u8, 91u8, 20u8,
+                    76u8, 190u8, 168u8, 154u8, 201u8, 219u8, 109u8, 52u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    inputToken: data.0,
+                    outputToken: data.1,
+                    inputTokenAmount: data.2,
+                    outputTokenAmount: data.3,
+                    provider: data.4,
+                    recipient: data.5,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.inputTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.outputTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.provider,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for LiquidityProviderSwap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&LiquidityProviderSwap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &LiquidityProviderSwap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `MetaTransactionExecuted(bytes32,bytes4,address,address)` and selector `0x7f4fe3ff8ae440e1570c558da08440b26f89fb1c1f2910cd91ca6452955f121a`.
+    ```solidity
+    event MetaTransactionExecuted(bytes32 hash, bytes4 indexed selector, address signer, address sender);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct MetaTransactionExecuted {
+        #[allow(missing_docs)]
+        pub hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for MetaTransactionExecuted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "MetaTransactionExecuted(bytes32,bytes4,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    127u8, 79u8, 227u8, 255u8, 138u8, 228u8, 64u8, 225u8, 87u8, 12u8, 85u8, 141u8,
+                    160u8, 132u8, 64u8, 178u8, 111u8, 137u8, 251u8, 28u8, 31u8, 41u8, 16u8, 205u8,
+                    145u8, 202u8, 100u8, 82u8, 149u8, 95u8, 18u8, 26u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    hash: data.0,
+                    selector: topics.1,
+                    signer: data.1,
+                    sender: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.hash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.selector.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    4,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.selector);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for MetaTransactionExecuted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&MetaTransactionExecuted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &MetaTransactionExecuted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Migrated(address,address,address)` and selector `0xe1b831b0e6f3aa16b4b1a6bd526b5cdeab4940744ca6e0251f5fe5f8caf1c81a`.
+    ```solidity
+    event Migrated(address caller, address migrator, address newOwner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Migrated {
+        #[allow(missing_docs)]
+        pub caller: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub migrator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Migrated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Migrated(address,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    225u8, 184u8, 49u8, 176u8, 230u8, 243u8, 170u8, 22u8, 180u8, 177u8, 166u8,
+                    189u8, 82u8, 107u8, 92u8, 222u8, 171u8, 73u8, 64u8, 116u8, 76u8, 166u8, 224u8,
+                    37u8, 31u8, 95u8, 229u8, 248u8, 202u8, 241u8, 200u8, 26u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    caller: data.0,
+                    migrator: data.1,
+                    newOwner: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.caller,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.migrator,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newOwner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Migrated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Migrated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Migrated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderCancelled(bytes32,address)` and selector `0xa6eb7cdc219e1518ced964e9a34e61d68a94e4f1569db3e84256ba981ba52753`.
+    ```solidity
+    event OrderCancelled(bytes32 orderHash, address maker);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderCancelled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderCancelled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderCancelled(bytes32,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    166u8, 235u8, 124u8, 220u8, 33u8, 158u8, 21u8, 24u8, 206u8, 217u8, 100u8,
+                    233u8, 163u8, 78u8, 97u8, 214u8, 138u8, 148u8, 228u8, 241u8, 86u8, 157u8,
+                    179u8, 232u8, 66u8, 86u8, 186u8, 152u8, 27u8, 165u8, 39u8, 83u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderCancelled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderCancelled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderCancelled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderSignerRegistered(address,address,bool)` and selector `0x6ea9dbe8b2cc119348716a9220a0742ad62b7884ecb0ff4b32cd508121fd9379`.
+    ```solidity
+    event OrderSignerRegistered(address maker, address signer, bool allowed);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderSignerRegistered {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub allowed: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderSignerRegistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderSignerRegistered(address,address,bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    110u8, 169u8, 219u8, 232u8, 178u8, 204u8, 17u8, 147u8, 72u8, 113u8, 106u8,
+                    146u8, 32u8, 160u8, 116u8, 42u8, 214u8, 43u8, 120u8, 132u8, 236u8, 176u8,
+                    255u8, 75u8, 50u8, 205u8, 80u8, 129u8, 33u8, 253u8, 147u8, 121u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    signer: data.1,
+                    allowed: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.allowed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderSignerRegistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderSignerRegistered> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderSignerRegistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OtcOrderFilled(bytes32,address,address,address,address,uint128,uint128)` and selector `0xac75f773e3a92f1a02b12134d65e1f47f8a14eabe4eaf1e24624918e6a8b269f`.
+    ```solidity
+    event OtcOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 makerTokenFilledAmount, uint128 takerTokenFilledAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OtcOrderFilled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OtcOrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "OtcOrderFilled(bytes32,address,address,address,address,uint128,uint128)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    172u8, 117u8, 247u8, 115u8, 227u8, 169u8, 47u8, 26u8, 2u8, 177u8, 33u8, 52u8,
+                    214u8, 94u8, 31u8, 71u8, 248u8, 161u8, 78u8, 171u8, 228u8, 234u8, 241u8, 226u8,
+                    70u8, 36u8, 145u8, 142u8, 106u8, 139u8, 38u8, 159u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    makerToken: data.3,
+                    takerToken: data.4,
+                    makerTokenFilledAmount: data.5,
+                    takerTokenFilledAmount: data.6,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OtcOrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OtcOrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OtcOrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
+    ```solidity
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OwnershipTransferred {
+        #[allow(missing_docs)]
+        pub previousOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OwnershipTransferred {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
+                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
+                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    previousOwner: topics.1,
+                    newOwner: topics.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.previousOwner.clone(),
+                    self.newOwner.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.previousOwner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.newOwner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PairCancelledLimitOrders(address,address,address,uint256)` and selector `0xa91fe7ae62fce669df2c7f880f8c14d178531aae72515558e5c948e37c32a572`.
+    ```solidity
+    event PairCancelledLimitOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PairCancelledLimitOrders {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PairCancelledLimitOrders {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PairCancelledLimitOrders(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 31u8, 231u8, 174u8, 98u8, 252u8, 230u8, 105u8, 223u8, 44u8, 127u8,
+                    136u8, 15u8, 140u8, 20u8, 209u8, 120u8, 83u8, 26u8, 174u8, 114u8, 81u8, 85u8,
+                    88u8, 229u8, 201u8, 72u8, 227u8, 124u8, 50u8, 165u8, 114u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    makerToken: data.1,
+                    takerToken: data.2,
+                    minValidSalt: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PairCancelledLimitOrders {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PairCancelledLimitOrders> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PairCancelledLimitOrders) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PairCancelledRfqOrders(address,address,address,uint256)` and selector `0xfe7ffb1edfe79f4df716cb2dcad21cf2f31b104d816a7976ba1e6e4653c1efb1`.
+    ```solidity
+    event PairCancelledRfqOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PairCancelledRfqOrders {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PairCancelledRfqOrders {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PairCancelledRfqOrders(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    254u8, 127u8, 251u8, 30u8, 223u8, 231u8, 159u8, 77u8, 247u8, 22u8, 203u8, 45u8,
+                    202u8, 210u8, 28u8, 242u8, 243u8, 27u8, 16u8, 77u8, 129u8, 106u8, 121u8, 118u8,
+                    186u8, 30u8, 110u8, 70u8, 83u8, 193u8, 239u8, 177u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    makerToken: data.1,
+                    takerToken: data.2,
+                    minValidSalt: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PairCancelledRfqOrders {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PairCancelledRfqOrders> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PairCancelledRfqOrders) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ProxyFunctionUpdated(bytes4,address,address)` and selector `0x2ae221083467de52078b0096696ab88d8d53a7ecb44bb65b56a2bab687598367`.
+    ```solidity
+    event ProxyFunctionUpdated(bytes4 indexed selector, address oldImpl, address newImpl);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ProxyFunctionUpdated {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub oldImpl: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newImpl: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ProxyFunctionUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ProxyFunctionUpdated(bytes4,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    42u8, 226u8, 33u8, 8u8, 52u8, 103u8, 222u8, 82u8, 7u8, 139u8, 0u8, 150u8,
+                    105u8, 106u8, 184u8, 141u8, 141u8, 83u8, 167u8, 236u8, 180u8, 75u8, 182u8,
+                    91u8, 86u8, 162u8, 186u8, 182u8, 135u8, 89u8, 131u8, 103u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    selector: topics.1,
+                    oldImpl: data.0,
+                    newImpl: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.oldImpl,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newImpl,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.selector.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    4,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.selector);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ProxyFunctionUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ProxyFunctionUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ProxyFunctionUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `QuoteSignerUpdated(address)` and selector `0xf5550c5eea19b48ac6eb5f03abdc4f59c0a60697abb3d973cd68669703b5c8b9`.
+    ```solidity
+    event QuoteSignerUpdated(address quoteSigner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct QuoteSignerUpdated {
+        #[allow(missing_docs)]
+        pub quoteSigner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for QuoteSignerUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "QuoteSignerUpdated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    245u8, 85u8, 12u8, 94u8, 234u8, 25u8, 180u8, 138u8, 198u8, 235u8, 95u8, 3u8,
+                    171u8, 220u8, 79u8, 89u8, 192u8, 166u8, 6u8, 151u8, 171u8, 179u8, 217u8, 115u8,
+                    205u8, 104u8, 102u8, 151u8, 3u8, 181u8, 200u8, 185u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    quoteSigner: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteSigner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for QuoteSignerUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&QuoteSignerUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &QuoteSignerUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RfqOrderFilled(bytes32,address,address,address,address,uint128,uint128,bytes32)` and selector `0x829fa99d94dc4636925b38632e625736a614c154d55006b7ab6bea979c210c32`.
+    ```solidity
+    event RfqOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, bytes32 pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RfqOrderFilled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RfqOrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "RfqOrderFilled(bytes32,address,address,address,address,uint128,uint128,bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    130u8, 159u8, 169u8, 157u8, 148u8, 220u8, 70u8, 54u8, 146u8, 91u8, 56u8, 99u8,
+                    46u8, 98u8, 87u8, 54u8, 166u8, 20u8, 193u8, 84u8, 213u8, 80u8, 6u8, 183u8,
+                    171u8, 107u8, 234u8, 151u8, 156u8, 33u8, 12u8, 50u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    makerToken: data.3,
+                    takerToken: data.4,
+                    takerTokenFilledAmount: data.5,
+                    makerTokenFilledAmount: data.6,
+                    pool: data.7,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RfqOrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RfqOrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RfqOrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RfqOrderOriginsAllowed(address,address[],bool)` and selector `0x02dfead5eb769b298e82dd9650b31c40559a3d42701dbf53c931bc2682847c31`.
+    ```solidity
+    event RfqOrderOriginsAllowed(address origin, address[] addrs, bool allowed);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RfqOrderOriginsAllowed {
+        #[allow(missing_docs)]
+        pub origin: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addrs: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub allowed: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RfqOrderOriginsAllowed {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RfqOrderOriginsAllowed(address,address[],bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    2u8, 223u8, 234u8, 213u8, 235u8, 118u8, 155u8, 41u8, 142u8, 130u8, 221u8,
+                    150u8, 80u8, 179u8, 28u8, 64u8, 85u8, 154u8, 61u8, 66u8, 112u8, 29u8, 191u8,
+                    83u8, 201u8, 49u8, 188u8, 38u8, 130u8, 132u8, 124u8, 49u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    origin: data.0,
+                    addrs: data.1,
+                    allowed: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.origin,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.addrs),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.allowed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RfqOrderOriginsAllowed {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RfqOrderOriginsAllowed> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RfqOrderOriginsAllowed) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TransformedERC20(address,address,address,uint256,uint256)` and selector `0x0f6672f78a59ba8e5e5b5d38df3ebc67f3c792e2c9259b8d97d7f00dd78ba1b3`.
+    ```solidity
+    event TransformedERC20(address indexed taker, address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TransformedERC20 {
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TransformedERC20 {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "TransformedERC20(address,address,address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    15u8, 102u8, 114u8, 247u8, 138u8, 89u8, 186u8, 142u8, 94u8, 91u8, 93u8, 56u8,
+                    223u8, 62u8, 188u8, 103u8, 243u8, 199u8, 146u8, 226u8, 201u8, 37u8, 155u8,
+                    141u8, 151u8, 215u8, 240u8, 13u8, 215u8, 139u8, 161u8, 179u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    taker: topics.1,
+                    inputToken: data.0,
+                    outputToken: data.1,
+                    inputTokenAmount: data.2,
+                    outputTokenAmount: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.inputTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.outputTokenAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.taker.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.taker,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TransformedERC20 {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TransformedERC20> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TransformedERC20) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TransformerDeployerUpdated(address)` and selector `0xfd45604abad79c16e23348a137ed8292661be1b8eba6e4806ebed6833b1c046a`.
+    ```solidity
+    event TransformerDeployerUpdated(address transformerDeployer);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TransformerDeployerUpdated {
+        #[allow(missing_docs)]
+        pub transformerDeployer: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TransformerDeployerUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TransformerDeployerUpdated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    253u8, 69u8, 96u8, 74u8, 186u8, 215u8, 156u8, 22u8, 226u8, 51u8, 72u8, 161u8,
+                    55u8, 237u8, 130u8, 146u8, 102u8, 27u8, 225u8, 184u8, 235u8, 166u8, 228u8,
+                    128u8, 110u8, 190u8, 214u8, 131u8, 59u8, 28u8, 4u8, 106u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    transformerDeployer: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.transformerDeployer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TransformerDeployerUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TransformerDeployerUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TransformerDeployerUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `_fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,address)` and selector `0x414e4ccf`.
+    ```solidity
+    function _fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, address sender) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _fillLimitOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`_fillLimitOrder((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
+    /// bytes32),uint128,address,address)`](_fillLimitOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _fillLimitOrderReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_fillLimitOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: _fillLimitOrderCall) -> Self {
+                    (
+                        value.order,
+                        value.signature,
+                        value.takerTokenFillAmount,
+                        value.taker,
+                        value.sender,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillLimitOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                        taker: tuple.3,
+                        sender: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_fillLimitOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: _fillLimitOrderReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillLimitOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl _fillLimitOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <_fillLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for _fillLimitOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = _fillLimitOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [65u8, 78u8, 76u8, 207u8];
+            const SIGNATURE: &'static str = "_fillLimitOrder((address,address,uint128,uint128,\
+                                             uint128,address,address,address,address,bytes32,\
+                                             uint64,uint256),(uint8,uint8,bytes32,bytes32),\
+                                             uint128,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                _fillLimitOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `_fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)` and selector `0xe4ba8439`.
+    ```solidity
+    function _fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _fillOtcOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub useSelfBalance: bool,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`_fillOtcOrder((address,address,uint128,uint128,address,address,
+    /// address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,
+    /// address)`](_fillOtcOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _fillOtcOrderReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+                alloy_sol_types::private::Address,
+                bool,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_fillOtcOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: _fillOtcOrderCall) -> Self {
+                    (
+                        value.order,
+                        value.makerSignature,
+                        value.takerTokenFillAmount,
+                        value.taker,
+                        value.useSelfBalance,
+                        value.recipient,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillOtcOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        makerSignature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                        taker: tuple.3,
+                        useSelfBalance: tuple.4,
+                        recipient: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_fillOtcOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: _fillOtcOrderReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillOtcOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl _fillOtcOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <_fillOtcOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for _fillOtcOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = _fillOtcOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [228u8, 186u8, 132u8, 57u8];
+            const SIGNATURE: &'static str = "_fillOtcOrder((address,address,uint128,uint128,\
+                                             address,address,address,uint256),(uint8,uint8,\
+                                             bytes32,bytes32),uint128,address,bool,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.makerSignature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.useSelfBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                _fillOtcOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)` and selector `0xaa6b21cd`.
+    ```solidity
+    function _fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _fillRfqOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub useSelfBalance: bool,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`_fillRfqOrder((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,
+    /// address,bool,address)`](_fillRfqOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _fillRfqOrderReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::RfqOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+                alloy_sol_types::private::Address,
+                bool,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_fillRfqOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: _fillRfqOrderCall) -> Self {
+                    (
+                        value.order,
+                        value.signature,
+                        value.takerTokenFillAmount,
+                        value.taker,
+                        value.useSelfBalance,
+                        value.recipient,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillRfqOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                        taker: tuple.3,
+                        useSelfBalance: tuple.4,
+                        recipient: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_fillRfqOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: _fillRfqOrderReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillRfqOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl _fillRfqOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <_fillRfqOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for _fillRfqOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::RfqOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = _fillRfqOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 107u8, 33u8, 205u8];
+            const SIGNATURE: &'static str =
+                "_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,\
+                 uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.useSelfBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                _fillRfqOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)` and selector `0x4a931ba1`.
+    ```solidity
+    function _sellHeldTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _sellHeldTokenForTokenToUniswapV3Call {
+        #[allow(missing_docs)]
+        pub encodedPath: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,
+    /// address)`](_sellHeldTokenForTokenToUniswapV3Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _sellHeldTokenForTokenToUniswapV3Return {
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_sellHeldTokenForTokenToUniswapV3Call> for UnderlyingRustTuple<'_> {
+                fn from(value: _sellHeldTokenForTokenToUniswapV3Call) -> Self {
+                    (
+                        value.encodedPath,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                        value.recipient,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _sellHeldTokenForTokenToUniswapV3Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        encodedPath: tuple.0,
+                        sellAmount: tuple.1,
+                        minBuyAmount: tuple.2,
+                        recipient: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_sellHeldTokenForTokenToUniswapV3Return> for UnderlyingRustTuple<'_> {
+                fn from(value: _sellHeldTokenForTokenToUniswapV3Return) -> Self {
+                    (value.buyAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _sellHeldTokenForTokenToUniswapV3Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { buyAmount: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for _sellHeldTokenForTokenToUniswapV3Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 147u8, 27u8, 161u8];
+            const SIGNATURE: &'static str =
+                "_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.encodedPath,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minBuyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: _sellHeldTokenForTokenToUniswapV3Return = r.into();
+                        r.buyAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: _sellHeldTokenForTokenToUniswapV3Return = r.into();
+                    r.buyAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `_transformERC20((address,address,address,uint256,uint256,(uint32,bytes)[],bool,address))` and selector `0x8aa6539b`.
+    ```solidity
+    function _transformERC20(ITransformERC20Feature.TransformERC20Args memory args) external payable returns (uint256 outputTokenAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _transformERC20Call {
+        #[allow(missing_docs)]
+        pub args:
+            <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`_transformERC20((address,address,address,uint256,uint256,(uint32,
+    /// bytes)[],bool,address))`](_transformERC20Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct _transformERC20Return {
+        #[allow(missing_docs)]
+        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ITransformERC20Feature::TransformERC20Args,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_transformERC20Call> for UnderlyingRustTuple<'_> {
+                fn from(value: _transformERC20Call) -> Self {
+                    (value.args,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _transformERC20Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { args: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<_transformERC20Return> for UnderlyingRustTuple<'_> {
+                fn from(value: _transformERC20Return) -> Self {
+                    (value.outputTokenAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _transformERC20Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        outputTokenAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for _transformERC20Call {
+            type Parameters<'a> = (ITransformERC20Feature::TransformERC20Args,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [138u8, 166u8, 83u8, 155u8];
+            const SIGNATURE: &'static str = "_transformERC20((address,address,address,uint256,\
+                                             uint256,(uint32,bytes)[],bool,address))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::tokenize(
+                        &self.args,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: _transformERC20Return = r.into();
+                        r.outputTokenAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: _transformERC20Return = r.into();
+                    r.outputTokenAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchBuyERC1155s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bytes[],bool)` and selector `0x84680615`.
+    ```solidity
+    function batchBuyERC1155s(LibNFTOrder.ERC1155Order[] memory sellOrders, LibSignature.Signature[] memory signatures, uint128[] memory erc1155TokenAmounts, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchBuyERC1155sCall {
+        #[allow(missing_docs)]
+        pub sellOrders: alloy_sol_types::private::Vec<
+            <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub erc1155TokenAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        #[allow(missing_docs)]
+        pub revertIfIncomplete: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchBuyERC1155s((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
+    /// uint128)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bytes[],
+    /// bool)`](batchBuyERC1155sCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchBuyERC1155sReturn {
+        #[allow(missing_docs)]
+        pub successes: alloy_sol_types::private::Vec<bool>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC1155Order>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<u128>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchBuyERC1155sCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchBuyERC1155sCall) -> Self {
+                    (
+                        value.sellOrders,
+                        value.signatures,
+                        value.erc1155TokenAmounts,
+                        value.callbackData,
+                        value.revertIfIncomplete,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC1155sCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sellOrders: tuple.0,
+                        signatures: tuple.1,
+                        erc1155TokenAmounts: tuple.2,
+                        callbackData: tuple.3,
+                        revertIfIncomplete: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<bool>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchBuyERC1155sReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchBuyERC1155sReturn) -> Self {
+                    (value.successes,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC1155sReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { successes: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchBuyERC1155sCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC1155Order>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::Vec<bool>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [132u8, 104u8, 6u8, 21u8];
+            const SIGNATURE: &'static str = "batchBuyERC1155s((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[],uint128)[],(uint8,\
+                                             uint8,bytes32,bytes32)[],uint128[],bytes[],bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::ERC1155Order,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmounts),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bytes,
+                    > as alloy_sol_types::SolType>::tokenize(&self.callbackData),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.revertIfIncomplete,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bool,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: batchBuyERC1155sReturn = r.into();
+                        r.successes
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: batchBuyERC1155sReturn = r.into();
+                    r.successes
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchBuyERC721s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],bytes[],bool)` and selector `0xeae93ee7`.
+    ```solidity
+    function batchBuyERC721s(LibNFTOrder.ERC721Order[] memory sellOrders, LibSignature.Signature[] memory signatures, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchBuyERC721sCall {
+        #[allow(missing_docs)]
+        pub sellOrders: alloy_sol_types::private::Vec<
+            <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        #[allow(missing_docs)]
+        pub revertIfIncomplete: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchBuyERC721s((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],
+    /// (uint8,uint8,bytes32,bytes32)[],bytes[],bool)`](batchBuyERC721sCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchBuyERC721sReturn {
+        #[allow(missing_docs)]
+        pub successes: alloy_sol_types::private::Vec<bool>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchBuyERC721sCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchBuyERC721sCall) -> Self {
+                    (
+                        value.sellOrders,
+                        value.signatures,
+                        value.callbackData,
+                        value.revertIfIncomplete,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC721sCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sellOrders: tuple.0,
+                        signatures: tuple.1,
+                        callbackData: tuple.2,
+                        revertIfIncomplete: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<bool>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchBuyERC721sReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchBuyERC721sReturn) -> Self {
+                    (value.successes,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC721sReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { successes: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchBuyERC721sCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::Vec<bool>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [234u8, 233u8, 62u8, 231u8];
+            const SIGNATURE: &'static str = "batchBuyERC721s((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[])[],(uint8,uint8,\
+                                             bytes32,bytes32)[],bytes[],bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::ERC721Order,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bytes,
+                    > as alloy_sol_types::SolType>::tokenize(&self.callbackData),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.revertIfIncomplete,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bool,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: batchBuyERC721sReturn = r.into();
+                        r.successes
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: batchBuyERC721sReturn = r.into();
+                    r.successes
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelERC1155Orders(uint256[])` and selector `0xa1865d6f`.
+    ```solidity
+    function batchCancelERC1155Orders(uint256[] memory orderNonces) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelERC1155OrdersCall {
+        #[allow(missing_docs)]
+        pub orderNonces:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelERC1155Orders(uint256[])`](batchCancelERC1155OrdersCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelERC1155OrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelERC1155OrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelERC1155OrdersCall) -> Self {
+                    (value.orderNonces,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC1155OrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderNonces: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelERC1155OrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelERC1155OrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC1155OrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelERC1155OrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelERC1155OrdersCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Return = batchCancelERC1155OrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [161u8, 134u8, 93u8, 111u8];
+            const SIGNATURE: &'static str = "batchCancelERC1155Orders(uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.orderNonces
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelERC1155OrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelERC721Orders(uint256[])` and selector `0x86219940`.
+    ```solidity
+    function batchCancelERC721Orders(uint256[] memory orderNonces) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelERC721OrdersCall {
+        #[allow(missing_docs)]
+        pub orderNonces:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelERC721Orders(uint256[])`](batchCancelERC721OrdersCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelERC721OrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelERC721OrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelERC721OrdersCall) -> Self {
+                    (value.orderNonces,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC721OrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderNonces: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelERC721OrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelERC721OrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC721OrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelERC721OrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelERC721OrdersCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Return = batchCancelERC721OrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [134u8, 33u8, 153u8, 64u8];
+            const SIGNATURE: &'static str = "batchCancelERC721Orders(uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.orderNonces
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelERC721OrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[])` and selector `0x9baa45a8`.
+    ```solidity
+    function batchCancelLimitOrders(LibNativeOrder.LimitOrder[] memory orders) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelLimitOrdersCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelLimitOrders((address,address,uint128,uint128,uint128,
+    /// address,address,address,address,bytes32,uint64,
+    /// uint256)[])`](batchCancelLimitOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelLimitOrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelLimitOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelLimitOrdersCall) -> Self {
+                    (value.orders,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelLimitOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orders: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelLimitOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelLimitOrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelLimitOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelLimitOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelLimitOrdersCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,);
+            type Return = batchCancelLimitOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [155u8, 170u8, 69u8, 168u8];
+            const SIGNATURE: &'static str = "batchCancelLimitOrders((address,address,uint128,\
+                                             uint128,uint128,address,address,address,address,\
+                                             bytes32,uint64,uint256)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::LimitOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelLimitOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelPairLimitOrders(address[],address[],uint256[])` and selector `0x86a0c8d7`.
+    ```solidity
+    function batchCancelPairLimitOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairLimitOrdersCall {
+        #[allow(missing_docs)]
+        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub minValidSalts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelPairLimitOrders(address[],address[],
+    /// uint256[])`](batchCancelPairLimitOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairLimitOrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairLimitOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairLimitOrdersCall) -> Self {
+                    (value.makerTokens, value.takerTokens, value.minValidSalts)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerTokens: tuple.0,
+                        takerTokens: tuple.1,
+                        minValidSalts: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairLimitOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairLimitOrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelPairLimitOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelPairLimitOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Return = batchCancelPairLimitOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [134u8, 160u8, 200u8, 215u8];
+            const SIGNATURE: &'static str =
+                "batchCancelPairLimitOrders(address[],address[],uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelPairLimitOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])` and selector `0x9f0434f5`.
+    ```solidity
+    function batchCancelPairLimitOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairLimitOrdersWithSignerCall {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub minValidSalts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelPairLimitOrdersWithSigner(address,address[],address[],
+    /// uint256[])`](batchCancelPairLimitOrdersWithSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairLimitOrdersWithSignerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairLimitOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairLimitOrdersWithSignerCall) -> Self {
+                    (
+                        value.maker,
+                        value.makerTokens,
+                        value.takerTokens,
+                        value.minValidSalts,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersWithSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        maker: tuple.0,
+                        makerTokens: tuple.1,
+                        takerTokens: tuple.2,
+                        minValidSalts: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairLimitOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairLimitOrdersWithSignerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersWithSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelPairLimitOrdersWithSignerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelPairLimitOrdersWithSignerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Return = batchCancelPairLimitOrdersWithSignerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [159u8, 4u8, 52u8, 245u8];
+            const SIGNATURE: &'static str =
+                "batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelPairLimitOrdersWithSignerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelPairRfqOrders(address[],address[],uint256[])` and selector `0x0f0e8cf7`.
+    ```solidity
+    function batchCancelPairRfqOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairRfqOrdersCall {
+        #[allow(missing_docs)]
+        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub minValidSalts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelPairRfqOrders(address[],address[],
+    /// uint256[])`](batchCancelPairRfqOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairRfqOrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairRfqOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairRfqOrdersCall) -> Self {
+                    (value.makerTokens, value.takerTokens, value.minValidSalts)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerTokens: tuple.0,
+                        takerTokens: tuple.1,
+                        minValidSalts: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairRfqOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairRfqOrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelPairRfqOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelPairRfqOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Return = batchCancelPairRfqOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [15u8, 14u8, 140u8, 247u8];
+            const SIGNATURE: &'static str =
+                "batchCancelPairRfqOrders(address[],address[],uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelPairRfqOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])` and selector `0xfd5f995b`.
+    ```solidity
+    function batchCancelPairRfqOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairRfqOrdersWithSignerCall {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub minValidSalts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelPairRfqOrdersWithSigner(address,address[],address[],
+    /// uint256[])`](batchCancelPairRfqOrdersWithSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelPairRfqOrdersWithSignerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairRfqOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairRfqOrdersWithSignerCall) -> Self {
+                    (
+                        value.maker,
+                        value.makerTokens,
+                        value.takerTokens,
+                        value.minValidSalts,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersWithSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        maker: tuple.0,
+                        makerTokens: tuple.1,
+                        takerTokens: tuple.2,
+                        minValidSalts: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelPairRfqOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelPairRfqOrdersWithSignerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersWithSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelPairRfqOrdersWithSignerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelPairRfqOrdersWithSignerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Return = batchCancelPairRfqOrdersWithSignerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [253u8, 95u8, 153u8, 91u8];
+            const SIGNATURE: &'static str =
+                "batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelPairRfqOrdersWithSignerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `batchCancelRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[])` and selector `0xf6e0f6a5`.
+    ```solidity
+    function batchCancelRfqOrders(LibNativeOrder.RfqOrder[] memory orders) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelRfqOrdersCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`batchCancelRfqOrders((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256)[])`](batchCancelRfqOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchCancelRfqOrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelRfqOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelRfqOrdersCall) -> Self {
+                    (value.orders,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelRfqOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orders: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchCancelRfqOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchCancelRfqOrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelRfqOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl batchCancelRfqOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchCancelRfqOrdersCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,);
+            type Return = batchCancelRfqOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 224u8, 246u8, 165u8];
+            const SIGNATURE: &'static str = "batchCancelRfqOrders((address,address,uint128,\
+                                             uint128,address,address,address,bytes32,uint64,\
+                                             uint256)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::RfqOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchCancelRfqOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0xc5579ec8`.
+    ```solidity
+    function batchExecuteMetaTransactions(IMetaTransactionsFeature.MetaTransactionData[] memory mtxs, LibSignature.Signature[] memory signatures) external payable returns (bytes[] memory returnResults);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchExecuteMetaTransactionsCall {
+        #[allow(missing_docs)]
+        pub mtxs: alloy_sol_types::private::Vec<
+            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,
+    /// uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,
+    /// bytes32)[])`](batchExecuteMetaTransactionsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchExecuteMetaTransactionsReturn {
+        #[allow(missing_docs)]
+        pub returnResults: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<IMetaTransactionsFeature::MetaTransactionData>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchExecuteMetaTransactionsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchExecuteMetaTransactionsCall) -> Self {
+                    (value.mtxs, value.signatures)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchExecuteMetaTransactionsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        mtxs: tuple.0,
+                        signatures: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchExecuteMetaTransactionsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchExecuteMetaTransactionsReturn) -> Self {
+                    (value.returnResults,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchExecuteMetaTransactionsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        returnResults: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchExecuteMetaTransactionsCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<IMetaTransactionsFeature::MetaTransactionData>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [197u8, 87u8, 158u8, 200u8];
+            const SIGNATURE: &'static str = "batchExecuteMetaTransactions((address,address,\
+                                             uint256,uint256,uint256,uint256,bytes,uint256,\
+                                             address,uint256)[],(uint8,uint8,bytes32,bytes32)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        IMetaTransactionsFeature::MetaTransactionData,
+                    > as alloy_sol_types::SolType>::tokenize(&self.mtxs),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bytes,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: batchExecuteMetaTransactionsReturn = r.into();
+                        r.returnResults
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: batchExecuteMetaTransactionsReturn = r.into();
+                    r.returnResults
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchFillLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)` and selector `0x1baaa00b`.
+    ```solidity
+    function batchFillLimitOrders(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external payable returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchFillLimitOrdersCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub revertIfIncomplete: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchFillLimitOrders((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,
+    /// bytes32)[],uint128[],bool)`](batchFillLimitOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchFillLimitOrdersReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<u128>,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchFillLimitOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchFillLimitOrdersCall) -> Self {
+                    (
+                        value.orders,
+                        value.signatures,
+                        value.takerTokenFillAmounts,
+                        value.revertIfIncomplete,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillLimitOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orders: tuple.0,
+                        signatures: tuple.1,
+                        takerTokenFillAmounts: tuple.2,
+                        revertIfIncomplete: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<u128>,
+                alloy_sol_types::private::Vec<u128>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchFillLimitOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchFillLimitOrdersReturn) -> Self {
+                    (value.takerTokenFilledAmounts, value.makerTokenFilledAmounts)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillLimitOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmounts: tuple.0,
+                        makerTokenFilledAmounts: tuple.1,
+                    }
+                }
+            }
+        }
+        impl batchFillLimitOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmounts,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmounts,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchFillLimitOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = batchFillLimitOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [27u8, 170u8, 160u8, 11u8];
+            const SIGNATURE: &'static str = "batchFillLimitOrders((address,address,uint128,\
+                                             uint128,uint128,address,address,address,address,\
+                                             bytes32,uint64,uint256)[],(uint8,uint8,bytes32,\
+                                             bytes32)[],uint128[],bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::LimitOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmounts,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.revertIfIncomplete,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchFillLimitOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchFillRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)` and selector `0x75103cb9`.
+    ```solidity
+    function batchFillRfqOrders(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchFillRfqOrdersCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub revertIfIncomplete: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchFillRfqOrders((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],
+    /// uint128[],bool)`](batchFillRfqOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchFillRfqOrdersReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<u128>,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchFillRfqOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchFillRfqOrdersCall) -> Self {
+                    (
+                        value.orders,
+                        value.signatures,
+                        value.takerTokenFillAmounts,
+                        value.revertIfIncomplete,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillRfqOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orders: tuple.0,
+                        signatures: tuple.1,
+                        takerTokenFillAmounts: tuple.2,
+                        revertIfIncomplete: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<u128>,
+                alloy_sol_types::private::Vec<u128>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchFillRfqOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchFillRfqOrdersReturn) -> Self {
+                    (value.takerTokenFilledAmounts, value.makerTokenFilledAmounts)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillRfqOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmounts: tuple.0,
+                        makerTokenFilledAmounts: tuple.1,
+                    }
+                }
+            }
+        }
+        impl batchFillRfqOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmounts,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmounts,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchFillRfqOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = batchFillRfqOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [117u8, 16u8, 60u8, 185u8];
+            const SIGNATURE: &'static str = "batchFillRfqOrders((address,address,uint128,uint128,\
+                                             address,address,address,bytes32,uint64,uint256)[],\
+                                             (uint8,uint8,bytes32,bytes32)[],uint128[],bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::RfqOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmounts,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.revertIfIncomplete,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchFillRfqOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchFillTakerSignedOtcOrders((address,address,uint128,uint128,address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[],bool[])` and selector `0xe52d1764`.
+    ```solidity
+    function batchFillTakerSignedOtcOrders(LibNativeOrder.OtcOrder[] memory orders, LibSignature.Signature[] memory makerSignatures, LibSignature.Signature[] memory takerSignatures, bool[] memory unwrapWeth) external returns (bool[] memory successes);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchFillTakerSignedOtcOrdersCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub makerSignatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub takerSignatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub unwrapWeth: alloy_sol_types::private::Vec<bool>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchFillTakerSignedOtcOrders((address,address,uint128,uint128,
+    /// address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],
+    /// (uint8,uint8,bytes32,bytes32)[],
+    /// bool[])`](batchFillTakerSignedOtcOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchFillTakerSignedOtcOrdersReturn {
+        #[allow(missing_docs)]
+        pub successes: alloy_sol_types::private::Vec<bool>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::OtcOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<bool>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchFillTakerSignedOtcOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchFillTakerSignedOtcOrdersCall) -> Self {
+                    (
+                        value.orders,
+                        value.makerSignatures,
+                        value.takerSignatures,
+                        value.unwrapWeth,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillTakerSignedOtcOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orders: tuple.0,
+                        makerSignatures: tuple.1,
+                        takerSignatures: tuple.2,
+                        unwrapWeth: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<bool>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchFillTakerSignedOtcOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchFillTakerSignedOtcOrdersReturn) -> Self {
+                    (value.successes,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillTakerSignedOtcOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { successes: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchFillTakerSignedOtcOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::OtcOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            type Return = alloy_sol_types::private::Vec<bool>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [229u8, 45u8, 23u8, 100u8];
+            const SIGNATURE: &'static str = "batchFillTakerSignedOtcOrders((address,address,\
+                                             uint128,uint128,address,address,address,uint256)[],\
+                                             (uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,\
+                                             bytes32)[],bool[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::OtcOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerSignatures),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerSignatures),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(&self.unwrapWeth),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Bool,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: batchFillTakerSignedOtcOrdersReturn = r.into();
+                        r.successes
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: batchFillTakerSignedOtcOrdersReturn = r.into();
+                    r.successes
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchGetLimitOrderRelevantStates((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0xb4658bfb`.
+    ```solidity
+    function batchGetLimitOrderRelevantStates(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchGetLimitOrderRelevantStatesCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`batchGetLimitOrderRelevantStates((address,address,uint128,uint128,
+    /// uint128,address,address,address,address,bytes32,uint64,uint256)[],
+    /// (uint8,uint8,bytes32,bytes32)[])`](batchGetLimitOrderRelevantStatesCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchGetLimitOrderRelevantStatesReturn {
+        #[allow(missing_docs)]
+        pub orderInfos: alloy_sol_types::private::Vec<
+            <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub actualFillableTakerTokenAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub isSignatureValids: alloy_sol_types::private::Vec<bool>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchGetLimitOrderRelevantStatesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchGetLimitOrderRelevantStatesCall) -> Self {
+                    (value.orders, value.signatures)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetLimitOrderRelevantStatesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orders: tuple.0,
+                        signatures: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<u128>,
+                alloy_sol_types::private::Vec<bool>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchGetLimitOrderRelevantStatesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchGetLimitOrderRelevantStatesReturn) -> Self {
+                    (
+                        value.orderInfos,
+                        value.actualFillableTakerTokenAmounts,
+                        value.isSignatureValids,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetLimitOrderRelevantStatesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderInfos: tuple.0,
+                        actualFillableTakerTokenAmounts: tuple.1,
+                        isSignatureValids: tuple.2,
+                    }
+                }
+            }
+        }
+        impl batchGetLimitOrderRelevantStatesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::OrderInfo,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderInfos),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.actualFillableTakerTokenAmounts,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(&self.isSignatureValids),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchGetLimitOrderRelevantStatesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            type Return = batchGetLimitOrderRelevantStatesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [180u8, 101u8, 139u8, 251u8];
+            const SIGNATURE: &'static str = "batchGetLimitOrderRelevantStates((address,address,\
+                                             uint128,uint128,uint128,address,address,address,\
+                                             address,bytes32,uint64,uint256)[],(uint8,uint8,\
+                                             bytes32,bytes32)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::LimitOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchGetLimitOrderRelevantStatesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchGetRfqOrderRelevantStates((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0xad354eeb`.
+    ```solidity
+    function batchGetRfqOrderRelevantStates(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchGetRfqOrderRelevantStatesCall {
+        #[allow(missing_docs)]
+        pub orders: alloy_sol_types::private::Vec<
+            <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`batchGetRfqOrderRelevantStates((address,address,uint128,uint128,
+    /// address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,
+    /// bytes32)[])`](batchGetRfqOrderRelevantStatesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchGetRfqOrderRelevantStatesReturn {
+        #[allow(missing_docs)]
+        pub orderInfos: alloy_sol_types::private::Vec<
+            <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub actualFillableTakerTokenAmounts: alloy_sol_types::private::Vec<u128>,
+        #[allow(missing_docs)]
+        pub isSignatureValids: alloy_sol_types::private::Vec<bool>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchGetRfqOrderRelevantStatesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchGetRfqOrderRelevantStatesCall) -> Self {
+                    (value.orders, value.signatures)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetRfqOrderRelevantStatesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orders: tuple.0,
+                        signatures: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<u128>,
+                alloy_sol_types::private::Vec<bool>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchGetRfqOrderRelevantStatesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchGetRfqOrderRelevantStatesReturn) -> Self {
+                    (
+                        value.orderInfos,
+                        value.actualFillableTakerTokenAmounts,
+                        value.isSignatureValids,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetRfqOrderRelevantStatesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderInfos: tuple.0,
+                        actualFillableTakerTokenAmounts: tuple.1,
+                        isSignatureValids: tuple.2,
+                    }
+                }
+            }
+        }
+        impl batchGetRfqOrderRelevantStatesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::OrderInfo,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderInfos),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<128>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.actualFillableTakerTokenAmounts,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(&self.isSignatureValids),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchGetRfqOrderRelevantStatesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            type Return = batchGetRfqOrderRelevantStatesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 53u8, 78u8, 235u8];
+            const SIGNATURE: &'static str = "batchGetRfqOrderRelevantStates((address,address,\
+                                             uint128,uint128,address,address,address,bytes32,\
+                                             uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNativeOrder::RfqOrder,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchGetRfqOrderRelevantStatesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0x7da9e2cf`.
+    ```solidity
+    function batchMatchERC721Orders(LibNFTOrder.ERC721Order[] memory sellOrders, LibNFTOrder.ERC721Order[] memory buyOrders, LibSignature.Signature[] memory sellOrderSignatures, LibSignature.Signature[] memory buyOrderSignatures) external returns (uint256[] memory profits, bool[] memory successes);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchMatchERC721OrdersCall {
+        #[allow(missing_docs)]
+        pub sellOrders: alloy_sol_types::private::Vec<
+            <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub buyOrders: alloy_sol_types::private::Vec<
+            <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sellOrderSignatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub buyOrderSignatures: alloy_sol_types::private::Vec<
+            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],
+    /// (uint8,address,address,uint256,uint256,address,uint256,(address,uint256,
+    /// bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,
+    /// bytes32)[],(uint8,uint8,bytes32,
+    /// bytes32)[])`](batchMatchERC721OrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct batchMatchERC721OrdersReturn {
+        #[allow(missing_docs)]
+        pub profits:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub successes: alloy_sol_types::private::Vec<bool>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<
+                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchMatchERC721OrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchMatchERC721OrdersCall) -> Self {
+                    (
+                        value.sellOrders,
+                        value.buyOrders,
+                        value.sellOrderSignatures,
+                        value.buyOrderSignatures,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchMatchERC721OrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sellOrders: tuple.0,
+                        buyOrders: tuple.1,
+                        sellOrderSignatures: tuple.2,
+                        buyOrderSignatures: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<bool>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<batchMatchERC721OrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchMatchERC721OrdersReturn) -> Self {
+                    (value.profits, value.successes)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchMatchERC721OrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        profits: tuple.0,
+                        successes: tuple.1,
+                    }
+                }
+            }
+        }
+        impl batchMatchERC721OrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.profits),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Bool,
+                    > as alloy_sol_types::SolType>::tokenize(&self.successes),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for batchMatchERC721OrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
+            );
+            type Return = batchMatchERC721OrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [125u8, 169u8, 226u8, 207u8];
+            const SIGNATURE: &'static str =
+                "batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,\
+                 (address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,address,\
+                 address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,\
+                 uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,\
+                 bytes32,bytes32)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::ERC721Order,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::ERC721Order,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyOrders),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrderSignatures),
+                    <alloy_sol_types::sol_data::Array<
+                        LibSignature::Signature,
+                    > as alloy_sol_types::SolType>::tokenize(&self.buyOrderSignatures),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                batchMatchERC721OrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `buyERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint128,bytes)` and selector `0x7cdb54d8`.
+    ```solidity
+    function buyERC1155(LibNFTOrder.ERC1155Order memory sellOrder, LibSignature.Signature memory signature, uint128 erc1155BuyAmount, bytes memory callbackData) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct buyERC1155Call {
+        #[allow(missing_docs)]
+        pub sellOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub erc1155BuyAmount: u128,
+        #[allow(missing_docs)]
+        pub callbackData: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`buyERC1155((uint8,address,address,uint256,uint256,address,uint256,
+    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),
+    /// (uint8,uint8,bytes32,bytes32),uint128,bytes)`](buyERC1155Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct buyERC1155Return {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC1155Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<buyERC1155Call> for UnderlyingRustTuple<'_> {
+                fn from(value: buyERC1155Call) -> Self {
+                    (
+                        value.sellOrder,
+                        value.signature,
+                        value.erc1155BuyAmount,
+                        value.callbackData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC1155Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sellOrder: tuple.0,
+                        signature: tuple.1,
+                        erc1155BuyAmount: tuple.2,
+                        callbackData: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<buyERC1155Return> for UnderlyingRustTuple<'_> {
+                fn from(value: buyERC1155Return) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC1155Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl buyERC1155Return {
+            fn _tokenize(&self) -> <buyERC1155Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for buyERC1155Call {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC1155Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = buyERC1155Return;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [124u8, 219u8, 84u8, 216u8];
+            const SIGNATURE: &'static str = "buyERC1155((uint8,address,address,uint256,uint256,\
+                                             address,uint256,(address,uint256,bytes)[],address,\
+                                             uint256,(address,bytes)[],uint128),(uint8,uint8,\
+                                             bytes32,bytes32),uint128,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(
+                        &self.sellOrder,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155BuyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callbackData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                buyERC1155Return::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `buyERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),bytes)` and selector `0xfbee349d`.
+    ```solidity
+    function buyERC721(LibNFTOrder.ERC721Order memory sellOrder, LibSignature.Signature memory signature, bytes memory callbackData) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct buyERC721Call {
+        #[allow(missing_docs)]
+        pub sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub callbackData: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`buyERC721((uint8,address,address,uint256,uint256,address,uint256,
+    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,
+    /// uint8,bytes32,bytes32),bytes)`](buyERC721Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct buyERC721Return {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC721Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<buyERC721Call> for UnderlyingRustTuple<'_> {
+                fn from(value: buyERC721Call) -> Self {
+                    (value.sellOrder, value.signature, value.callbackData)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC721Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sellOrder: tuple.0,
+                        signature: tuple.1,
+                        callbackData: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<buyERC721Return> for UnderlyingRustTuple<'_> {
+                fn from(value: buyERC721Return) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC721Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl buyERC721Return {
+            fn _tokenize(&self) -> <buyERC721Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for buyERC721Call {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC721Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = buyERC721Return;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 238u8, 52u8, 157u8];
+            const SIGNATURE: &'static str = "buyERC721((uint8,address,address,uint256,uint256,\
+                                             address,uint256,(address,uint256,bytes)[],address,\
+                                             uint256,(address,bytes)[]),(uint8,uint8,bytes32,\
+                                             bytes32),bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
+                        &self.sellOrder,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callbackData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                buyERC721Return::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelERC1155Order(uint256)` and selector `0x06d2596b`.
+    ```solidity
+    function cancelERC1155Order(uint256 orderNonce) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelERC1155OrderCall {
+        #[allow(missing_docs)]
+        pub orderNonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelERC1155Order(uint256)`](cancelERC1155OrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelERC1155OrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelERC1155OrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelERC1155OrderCall) -> Self {
+                    (value.orderNonce,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC1155OrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderNonce: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelERC1155OrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelERC1155OrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC1155OrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelERC1155OrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelERC1155OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelERC1155OrderCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = cancelERC1155OrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 210u8, 89u8, 107u8];
+            const SIGNATURE: &'static str = "cancelERC1155Order(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.orderNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelERC1155OrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelERC721Order(uint256)` and selector `0xbe167b9d`.
+    ```solidity
+    function cancelERC721Order(uint256 orderNonce) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelERC721OrderCall {
+        #[allow(missing_docs)]
+        pub orderNonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelERC721Order(uint256)`](cancelERC721OrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelERC721OrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelERC721OrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelERC721OrderCall) -> Self {
+                    (value.orderNonce,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC721OrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderNonce: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelERC721OrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelERC721OrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC721OrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelERC721OrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelERC721OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelERC721OrderCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = cancelERC721OrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [190u8, 22u8, 123u8, 157u8];
+            const SIGNATURE: &'static str = "cancelERC721Order(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.orderNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelERC721OrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))` and selector `0x7d49ec1a`.
+    ```solidity
+    function cancelLimitOrder(LibNativeOrder.LimitOrder memory order) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelLimitOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelLimitOrder((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,uint256))`](cancelLimitOrderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelLimitOrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelLimitOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelLimitOrderCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelLimitOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelLimitOrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelLimitOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelLimitOrderCall {
+            type Parameters<'a> = (LibNativeOrder::LimitOrder,);
+            type Return = cancelLimitOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [125u8, 73u8, 236u8, 26u8];
+            const SIGNATURE: &'static str = "cancelLimitOrder((address,address,uint128,uint128,\
+                                             uint128,address,address,address,address,bytes32,\
+                                             uint64,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelLimitOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelPairLimitOrders(address,address,uint256)` and selector `0xd0a55fb0`.
+    ```solidity
+    function cancelPairLimitOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairLimitOrdersCall {
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelPairLimitOrders(address,address,
+    /// uint256)`](cancelPairLimitOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairLimitOrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairLimitOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairLimitOrdersCall) -> Self {
+                    (value.makerToken, value.takerToken, value.minValidSalt)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerToken: tuple.0,
+                        takerToken: tuple.1,
+                        minValidSalt: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairLimitOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairLimitOrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelPairLimitOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelPairLimitOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = cancelPairLimitOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 165u8, 95u8, 176u8];
+            const SIGNATURE: &'static str = "cancelPairLimitOrders(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelPairLimitOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelPairLimitOrdersWithSigner(address,address,address,uint256)` and selector `0xb10a33f4`.
+    ```solidity
+    function cancelPairLimitOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairLimitOrdersWithSignerCall {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelPairLimitOrdersWithSigner(address,address,address,
+    /// uint256)`](cancelPairLimitOrdersWithSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairLimitOrdersWithSignerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairLimitOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairLimitOrdersWithSignerCall) -> Self {
+                    (
+                        value.maker,
+                        value.makerToken,
+                        value.takerToken,
+                        value.minValidSalt,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersWithSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        maker: tuple.0,
+                        makerToken: tuple.1,
+                        takerToken: tuple.2,
+                        minValidSalt: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairLimitOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairLimitOrdersWithSignerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersWithSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelPairLimitOrdersWithSignerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelPairLimitOrdersWithSignerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = cancelPairLimitOrdersWithSignerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [177u8, 10u8, 51u8, 244u8];
+            const SIGNATURE: &'static str =
+                "cancelPairLimitOrdersWithSigner(address,address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelPairLimitOrdersWithSignerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelPairRfqOrders(address,address,uint256)` and selector `0x9a4f809c`.
+    ```solidity
+    function cancelPairRfqOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairRfqOrdersCall {
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelPairRfqOrders(address,address,
+    /// uint256)`](cancelPairRfqOrdersCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairRfqOrdersReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairRfqOrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairRfqOrdersCall) -> Self {
+                    (value.makerToken, value.takerToken, value.minValidSalt)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerToken: tuple.0,
+                        takerToken: tuple.1,
+                        minValidSalt: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairRfqOrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairRfqOrdersReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelPairRfqOrdersReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelPairRfqOrdersCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = cancelPairRfqOrdersReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [154u8, 79u8, 128u8, 156u8];
+            const SIGNATURE: &'static str = "cancelPairRfqOrders(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelPairRfqOrdersReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelPairRfqOrdersWithSigner(address,address,address,uint256)` and selector `0x935c82a4`.
+    ```solidity
+    function cancelPairRfqOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairRfqOrdersWithSignerCall {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelPairRfqOrdersWithSigner(address,address,address,
+    /// uint256)`](cancelPairRfqOrdersWithSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelPairRfqOrdersWithSignerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairRfqOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairRfqOrdersWithSignerCall) -> Self {
+                    (
+                        value.maker,
+                        value.makerToken,
+                        value.takerToken,
+                        value.minValidSalt,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersWithSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        maker: tuple.0,
+                        makerToken: tuple.1,
+                        takerToken: tuple.2,
+                        minValidSalt: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelPairRfqOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelPairRfqOrdersWithSignerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersWithSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelPairRfqOrdersWithSignerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelPairRfqOrdersWithSignerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = cancelPairRfqOrdersWithSignerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [147u8, 92u8, 130u8, 164u8];
+            const SIGNATURE: &'static str =
+                "cancelPairRfqOrdersWithSigner(address,address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelPairRfqOrdersWithSignerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))` and selector `0xfe55a3ef`.
+    ```solidity
+    function cancelRfqOrder(LibNativeOrder.RfqOrder memory order) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelRfqOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelRfqOrder((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256))`](cancelRfqOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelRfqOrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelRfqOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelRfqOrderCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelRfqOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelRfqOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelRfqOrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelRfqOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelRfqOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelRfqOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelRfqOrderCall {
+            type Parameters<'a> = (LibNativeOrder::RfqOrder,);
+            type Return = cancelRfqOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [254u8, 85u8, 163u8, 239u8];
+            const SIGNATURE: &'static str = "cancelRfqOrder((address,address,uint128,uint128,\
+                                             address,address,address,bytes32,uint64,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelRfqOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createTransformWallet()` and selector `0x287b071b`.
+    ```solidity
+    function createTransformWallet() external returns (address wallet);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createTransformWalletCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createTransformWallet()`](createTransformWalletCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createTransformWalletReturn {
+        #[allow(missing_docs)]
+        pub wallet: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createTransformWalletCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createTransformWalletCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createTransformWalletCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createTransformWalletReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createTransformWalletReturn) -> Self {
+                    (value.wallet,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createTransformWalletReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { wallet: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createTransformWalletCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [40u8, 123u8, 7u8, 27u8];
+            const SIGNATURE: &'static str = "createTransformWallet()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createTransformWalletReturn = r.into();
+                        r.wallet
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createTransformWalletReturn = r.into();
+                    r.wallet
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `executeMetaTransaction((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x3d61ed3e`.
+    ```solidity
+    function executeMetaTransaction(IMetaTransactionsFeature.MetaTransactionData memory mtx, LibSignature.Signature memory signature) external payable returns (bytes memory returnResult);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct executeMetaTransactionCall {
+        #[allow(missing_docs)]
+        pub mtx:
+            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`executeMetaTransaction((address,address,uint256,uint256,uint256,
+    /// uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,
+    /// bytes32))`](executeMetaTransactionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct executeMetaTransactionReturn {
+        #[allow(missing_docs)]
+        pub returnResult: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                IMetaTransactionsFeature::MetaTransactionData,
+                LibSignature::Signature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<executeMetaTransactionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: executeMetaTransactionCall) -> Self {
+                    (value.mtx, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeMetaTransactionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        mtx: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<executeMetaTransactionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: executeMetaTransactionReturn) -> Self {
+                    (value.returnResult,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeMetaTransactionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        returnResult: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for executeMetaTransactionCall {
+            type Parameters<'a> = (
+                IMetaTransactionsFeature::MetaTransactionData,
+                LibSignature::Signature,
+            );
+            type Return = alloy_sol_types::private::Bytes;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [61u8, 97u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "executeMetaTransaction((address,address,uint256,\
+                                             uint256,uint256,uint256,bytes,uint256,address,\
+                                             uint256),(uint8,uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::tokenize(
+                        &self.mtx,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: executeMetaTransactionReturn = r.into();
+                        r.returnResult
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: executeMetaTransactionReturn = r.into();
+                    r.returnResult
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `extend(bytes4,address)` and selector `0x6eb224cb`.
+    ```solidity
+    function extend(bytes4 selector, address r#impl) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct extendCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub r#impl: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`extend(bytes4,address)`](extendCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct extendReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<4>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<extendCall> for UnderlyingRustTuple<'_> {
+                fn from(value: extendCall) -> Self {
+                    (value.selector, value.r#impl)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for extendCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        selector: tuple.0,
+                        r#impl: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<extendReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: extendReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for extendReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl extendReturn {
+            fn _tokenize(&self) -> <extendCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for extendCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = extendReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [110u8, 178u8, 36u8, 203u8];
+            const SIGNATURE: &'static str = "extend(bytes4,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.r#impl,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                extendReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xf6274f66`.
+    ```solidity
+    function fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillLimitOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillLimitOrder((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
+    /// bytes32),uint128)`](fillLimitOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillLimitOrderReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillLimitOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillLimitOrderCall) -> Self {
+                    (value.order, value.signature, value.takerTokenFillAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillLimitOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillLimitOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillLimitOrderReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillLimitOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl fillLimitOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <fillLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillLimitOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = fillLimitOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 39u8, 79u8, 102u8];
+            const SIGNATURE: &'static str =
+                "fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,\
+                 address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillLimitOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0x9240529c`.
+    ```solidity
+    function fillOrKillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOrKillLimitOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
+    /// bytes32),uint128)`](fillOrKillLimitOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOrKillLimitOrderReturn {
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOrKillLimitOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOrKillLimitOrderCall) -> Self {
+                    (value.order, value.signature, value.takerTokenFillAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillLimitOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOrKillLimitOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOrKillLimitOrderReturn) -> Self {
+                    (value.makerTokenFilledAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillLimitOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerTokenFilledAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillOrKillLimitOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = u128;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [146u8, 64u8, 82u8, 156u8];
+            const SIGNATURE: &'static str =
+                "fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,\
+                 address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: fillOrKillLimitOrderReturn = r.into();
+                        r.makerTokenFilledAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: fillOrKillLimitOrderReturn = r.into();
+                    r.makerTokenFilledAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillOrKillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0x438cdfc5`.
+    ```solidity
+    function fillOrKillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOrKillRfqOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillOrKillRfqOrder((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),
+    /// uint128)`](fillOrKillRfqOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOrKillRfqOrderReturn {
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::RfqOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOrKillRfqOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOrKillRfqOrderCall) -> Self {
+                    (value.order, value.signature, value.takerTokenFillAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillRfqOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOrKillRfqOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOrKillRfqOrderReturn) -> Self {
+                    (value.makerTokenFilledAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillRfqOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerTokenFilledAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillOrKillRfqOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::RfqOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = u128;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [67u8, 140u8, 223u8, 197u8];
+            const SIGNATURE: &'static str = "fillOrKillRfqOrder((address,address,uint128,uint128,\
+                                             address,address,address,bytes32,uint64,uint256),\
+                                             (uint8,uint8,bytes32,bytes32),uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: fillOrKillRfqOrderReturn = r.into();
+                        r.makerTokenFilledAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: fillOrKillRfqOrderReturn = r.into();
+                    r.makerTokenFilledAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xdac748d4`.
+    ```solidity
+    function fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOtcOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillOtcOrder((address,address,uint128,uint128,address,address,address,
+    /// uint256),(uint8,uint8,bytes32,bytes32),uint128)`](fillOtcOrderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOtcOrderReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOtcOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOtcOrderCall) -> Self {
+                    (
+                        value.order,
+                        value.makerSignature,
+                        value.takerTokenFillAmount,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        makerSignature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOtcOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOtcOrderReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl fillOtcOrderReturn {
+            fn _tokenize(&self) -> <fillOtcOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillOtcOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = fillOtcOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [218u8, 199u8, 72u8, 212u8];
+            const SIGNATURE: &'static str = "fillOtcOrder((address,address,uint128,uint128,\
+                                             address,address,address,uint256),(uint8,uint8,\
+                                             bytes32,bytes32),uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.makerSignature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillOtcOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xa578efaf`.
+    ```solidity
+    function fillOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOtcOrderForEthCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillOtcOrderForEth((address,address,uint128,uint128,address,address,
+    /// address,uint256),(uint8,uint8,bytes32,bytes32),
+    /// uint128)`](fillOtcOrderForEthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOtcOrderForEthReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOtcOrderForEthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOtcOrderForEthCall) -> Self {
+                    (
+                        value.order,
+                        value.makerSignature,
+                        value.takerTokenFillAmount,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderForEthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        makerSignature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOtcOrderForEthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOtcOrderForEthReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderForEthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl fillOtcOrderForEthReturn {
+            fn _tokenize(
+                &self,
+            ) -> <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillOtcOrderForEthCall {
+            type Parameters<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = fillOtcOrderForEthReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [165u8, 120u8, 239u8, 175u8];
+            const SIGNATURE: &'static str = "fillOtcOrderForEth((address,address,uint128,uint128,\
+                                             address,address,address,uint256),(uint8,uint8,\
+                                             bytes32,bytes32),uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.makerSignature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillOtcOrderForEthReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillOtcOrderWithEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x706394d5`.
+    ```solidity
+    function fillOtcOrderWithEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOtcOrderWithEthCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillOtcOrderWithEth((address,address,uint128,uint128,address,address,
+    /// address,uint256),(uint8,uint8,bytes32,
+    /// bytes32))`](fillOtcOrderWithEthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOtcOrderWithEthReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrder, LibSignature::Signature);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOtcOrderWithEthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOtcOrderWithEthCall) -> Self {
+                    (value.order, value.makerSignature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderWithEthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        makerSignature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOtcOrderWithEthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOtcOrderWithEthReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderWithEthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl fillOtcOrderWithEthReturn {
+            fn _tokenize(
+                &self,
+            ) -> <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillOtcOrderWithEthCall {
+            type Parameters<'a> = (LibNativeOrder::OtcOrder, LibSignature::Signature);
+            type Return = fillOtcOrderWithEthReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 99u8, 148u8, 213u8];
+            const SIGNATURE: &'static str = "fillOtcOrderWithEth((address,address,uint128,uint128,\
+                                             address,address,address,uint256),(uint8,uint8,\
+                                             bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.makerSignature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillOtcOrderWithEthReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xaa77476c`.
+    ```solidity
+    function fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillRfqOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillRfqOrder((address,address,uint128,uint128,address,address,address,
+    /// bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),
+    /// uint128)`](fillRfqOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillRfqOrderReturn {
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::RfqOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillRfqOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillRfqOrderCall) -> Self {
+                    (value.order, value.signature, value.takerTokenFillAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillRfqOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillRfqOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillRfqOrderReturn) -> Self {
+                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillRfqOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        takerTokenFilledAmount: tuple.0,
+                        makerTokenFilledAmount: tuple.1,
+                    }
+                }
+            }
+        }
+        impl fillRfqOrderReturn {
+            fn _tokenize(&self) -> <fillRfqOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillRfqOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::RfqOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = fillRfqOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 119u8, 71u8, 108u8];
+            const SIGNATURE: &'static str = "fillRfqOrder((address,address,uint128,uint128,\
+                                             address,address,address,bytes32,uint64,uint256),\
+                                             (uint8,uint8,bytes32,bytes32),uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillRfqOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillTakerSignedOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))` and selector `0x4f948110`.
+    ```solidity
+    function fillTakerSignedOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillTakerSignedOtcOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`fillTakerSignedOtcOrder((address,address,uint128,uint128,address,
+    /// address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,
+    /// bytes32,bytes32))`](fillTakerSignedOtcOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillTakerSignedOtcOrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                LibSignature::Signature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillTakerSignedOtcOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillTakerSignedOtcOrderCall) -> Self {
+                    (value.order, value.makerSignature, value.takerSignature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        makerSignature: tuple.1,
+                        takerSignature: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillTakerSignedOtcOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillTakerSignedOtcOrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl fillTakerSignedOtcOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillTakerSignedOtcOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                LibSignature::Signature,
+            );
+            type Return = fillTakerSignedOtcOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [79u8, 148u8, 129u8, 16u8];
+            const SIGNATURE: &'static str = "fillTakerSignedOtcOrder((address,address,uint128,\
+                                             uint128,address,address,address,uint256),(uint8,\
+                                             uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.makerSignature,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.takerSignature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillTakerSignedOtcOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))` and selector `0x724d3953`.
+    ```solidity
+    function fillTakerSignedOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillTakerSignedOtcOrderForEthCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,
+    /// address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,
+    /// uint8,bytes32,bytes32))`](fillTakerSignedOtcOrderForEthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillTakerSignedOtcOrderForEthReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                LibSignature::Signature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillTakerSignedOtcOrderForEthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillTakerSignedOtcOrderForEthCall) -> Self {
+                    (value.order, value.makerSignature, value.takerSignature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderForEthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        makerSignature: tuple.1,
+                        takerSignature: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillTakerSignedOtcOrderForEthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillTakerSignedOtcOrderForEthReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderForEthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl fillTakerSignedOtcOrderForEthReturn {
+            fn _tokenize(
+                &self,
+            ) -> <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillTakerSignedOtcOrderForEthCall {
+            type Parameters<'a> = (
+                LibNativeOrder::OtcOrder,
+                LibSignature::Signature,
+                LibSignature::Signature,
+            );
+            type Return = fillTakerSignedOtcOrderForEthReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [114u8, 77u8, 57u8, 83u8];
+            const SIGNATURE: &'static str =
+                "fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,\
+                 address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.makerSignature,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.takerSignature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                fillTakerSignedOtcOrderForEthReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `getERC1155OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))` and selector `0x1de3a7ac`.
+    ```solidity
+    function getERC1155OrderHash(LibNFTOrder.ERC1155Order memory order) external view returns (bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC1155OrderHashCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getERC1155OrderHash((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
+    /// uint128))`](getERC1155OrderHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC1155OrderHashReturn {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC1155OrderHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC1155OrderHashCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC1155OrderHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC1155OrderHashReturn) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getERC1155OrderHashCall {
+            type Parameters<'a> = (LibNFTOrder::ERC1155Order,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [29u8, 227u8, 167u8, 172u8];
+            const SIGNATURE: &'static str = "getERC1155OrderHash((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[],uint128))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getERC1155OrderHashReturn = r.into();
+                        r.orderHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getERC1155OrderHashReturn = r.into();
+                    r.orderHash
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `getERC1155OrderInfo((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))` and selector `0x4991fd72`.
+    ```solidity
+    function getERC1155OrderInfo(LibNFTOrder.ERC1155Order memory order) external view returns (LibNFTOrder.OrderInfo memory orderInfo);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC1155OrderInfoCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getERC1155OrderInfo((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
+    /// uint128))`](getERC1155OrderInfoCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC1155OrderInfoReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC1155OrderInfoCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC1155OrderInfoCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderInfoCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::OrderInfo,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC1155OrderInfoReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC1155OrderInfoReturn) -> Self {
+                    (value.orderInfo,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderInfoReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderInfo: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getERC1155OrderInfoCall {
+            type Parameters<'a> = (LibNFTOrder::ERC1155Order,);
+            type Return = <LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::RustType;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (LibNFTOrder::OrderInfo,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [73u8, 145u8, 253u8, 114u8];
+            const SIGNATURE: &'static str = "getERC1155OrderInfo((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[],uint128))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getERC1155OrderInfoReturn = r.into();
+                        r.orderInfo
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getERC1155OrderInfoReturn = r.into();
+                    r.orderInfo
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `getERC721OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))` and selector `0xb73a6027`.
+    ```solidity
+    function getERC721OrderHash(LibNFTOrder.ERC721Order memory order) external view returns (bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC721OrderHashCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getERC721OrderHash((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[]))`](getERC721OrderHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC721OrderHashReturn {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC721OrderHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC721OrderHashCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC721OrderHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC721OrderHashReturn) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getERC721OrderHashCall {
+            type Parameters<'a> = (LibNFTOrder::ERC721Order,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [183u8, 58u8, 96u8, 39u8];
+            const SIGNATURE: &'static str = "getERC721OrderHash((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[]))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getERC721OrderHashReturn = r.into();
+                        r.orderHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getERC721OrderHashReturn = r.into();
+                    r.orderHash
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `getERC721OrderStatus((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))` and selector `0xfbc4a518`.
+    ```solidity
+    function getERC721OrderStatus(LibNFTOrder.ERC721Order memory order) external view returns (LibNFTOrder.OrderStatus status);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC721OrderStatusCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getERC721OrderStatus((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[]))`](getERC721OrderStatusCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC721OrderStatusReturn {
+        #[allow(missing_docs)]
+        pub status: <LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC721OrderStatusCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC721OrderStatusCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::OrderStatus,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC721OrderStatusReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC721OrderStatusReturn) -> Self {
+                    (value.status,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { status: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getERC721OrderStatusCall {
+            type Parameters<'a> = (LibNFTOrder::ERC721Order,);
+            type Return = <LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::RustType;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (LibNFTOrder::OrderStatus,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 196u8, 165u8, 24u8];
+            const SIGNATURE: &'static str = "getERC721OrderStatus((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[]))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getERC721OrderStatusReturn = r.into();
+                        r.status
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getERC721OrderStatusReturn = r.into();
+                    r.status
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getERC721OrderStatusBitVector(address,uint248)` and selector `0x030b2730`.
+    ```solidity
+    function getERC721OrderStatusBitVector(address maker, uint248 nonceRange) external view returns (uint256 bitVector);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC721OrderStatusBitVectorCall {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonceRange: alloy_sol_types::private::primitives::aliases::U248,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getERC721OrderStatusBitVector(address,
+    /// uint248)`](getERC721OrderStatusBitVectorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getERC721OrderStatusBitVectorReturn {
+        #[allow(missing_docs)]
+        pub bitVector: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<248>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U248,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC721OrderStatusBitVectorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC721OrderStatusBitVectorCall) -> Self {
+                    (value.maker, value.nonceRange)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusBitVectorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        maker: tuple.0,
+                        nonceRange: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getERC721OrderStatusBitVectorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getERC721OrderStatusBitVectorReturn) -> Self {
+                    (value.bitVector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusBitVectorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { bitVector: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getERC721OrderStatusBitVectorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<248>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [3u8, 11u8, 39u8, 48u8];
+            const SIGNATURE: &'static str = "getERC721OrderStatusBitVector(address,uint248)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<248> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonceRange,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getERC721OrderStatusBitVectorReturn = r.into();
+                        r.bitVector
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getERC721OrderStatusBitVectorReturn = r.into();
+                    r.bitVector
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getLimitOrderHash((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))` and selector `0xdd11d225`.
+    ```solidity
+    function getLimitOrderHash(LibNativeOrder.LimitOrder memory order) external view returns (bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderHashCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getLimitOrderHash((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,
+    /// uint256))`](getLimitOrderHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderHashReturn {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderHashCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderHashReturn) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLimitOrderHashCall {
+            type Parameters<'a> = (LibNativeOrder::LimitOrder,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 17u8, 210u8, 37u8];
+            const SIGNATURE: &'static str = "getLimitOrderHash((address,address,uint128,uint128,\
+                                             uint128,address,address,address,address,bytes32,\
+                                             uint64,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getLimitOrderHashReturn = r.into();
+                        r.orderHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getLimitOrderHashReturn = r.into();
+                    r.orderHash
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getLimitOrderInfo((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))` and selector `0x95480889`.
+    ```solidity
+    function getLimitOrderInfo(LibNativeOrder.LimitOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderInfoCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getLimitOrderInfo((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,
+    /// uint256))`](getLimitOrderInfoCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderInfoReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderInfoCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderInfoCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderInfoCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::OrderInfo,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderInfoReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderInfoReturn) -> Self {
+                    (value.orderInfo,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderInfoReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderInfo: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLimitOrderInfoCall {
+            type Parameters<'a> = (LibNativeOrder::LimitOrder,);
+            type Return = <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (LibNativeOrder::OrderInfo,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 72u8, 8u8, 137u8];
+            const SIGNATURE: &'static str = "getLimitOrderInfo((address,address,uint128,uint128,\
+                                             uint128,address,address,address,address,bytes32,\
+                                             uint64,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getLimitOrderInfoReturn = r.into();
+                        r.orderInfo
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getLimitOrderInfoReturn = r.into();
+                    r.orderInfo
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x1fb09795`.
+    ```solidity
+    function getLimitOrderRelevantState(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderRelevantStateCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getLimitOrderRelevantState((address,address,uint128,uint128,uint128,
+    /// address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,
+    /// bytes32,bytes32))`](getLimitOrderRelevantStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderRelevantStateReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub actualFillableTakerTokenAmount: u128,
+        #[allow(missing_docs)]
+        pub isSignatureValid: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder, LibSignature::Signature);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderRelevantStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderRelevantStateCall) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderRelevantStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OrderInfo,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+                u128,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderRelevantStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderRelevantStateReturn) -> Self {
+                    (
+                        value.orderInfo,
+                        value.actualFillableTakerTokenAmount,
+                        value.isSignatureValid,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderRelevantStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderInfo: tuple.0,
+                        actualFillableTakerTokenAmount: tuple.1,
+                        isSignatureValid: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getLimitOrderRelevantStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(
+                        &self.orderInfo,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.actualFillableTakerTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isSignatureValid,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLimitOrderRelevantStateCall {
+            type Parameters<'a> = (LibNativeOrder::LimitOrder, LibSignature::Signature);
+            type Return = getLimitOrderRelevantStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                LibNativeOrder::OrderInfo,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 176u8, 151u8, 149u8];
+            const SIGNATURE: &'static str =
+                "getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,\
+                 address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getLimitOrderRelevantStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getMetaTransactionExecutedBlock((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))` and selector `0x3fb2da38`.
+    ```solidity
+    function getMetaTransactionExecutedBlock(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (uint256 blockNumber);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMetaTransactionExecutedBlockCall {
+        #[allow(missing_docs)]
+        pub mtx:
+            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getMetaTransactionExecutedBlock((address,address,uint256,uint256,
+    /// uint256,uint256,bytes,uint256,address,
+    /// uint256))`](getMetaTransactionExecutedBlockCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMetaTransactionExecutedBlockReturn {
+        #[allow(missing_docs)]
+        pub blockNumber: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMetaTransactionExecutedBlockCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getMetaTransactionExecutedBlockCall) -> Self {
+                    (value.mtx,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionExecutedBlockCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { mtx: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMetaTransactionExecutedBlockReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getMetaTransactionExecutedBlockReturn) -> Self {
+                    (value.blockNumber,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionExecutedBlockReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        blockNumber: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getMetaTransactionExecutedBlockCall {
+            type Parameters<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 178u8, 218u8, 56u8];
+            const SIGNATURE: &'static str = "getMetaTransactionExecutedBlock((address,address,\
+                                             uint256,uint256,uint256,uint256,bytes,uint256,\
+                                             address,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::tokenize(
+                        &self.mtx,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getMetaTransactionExecutedBlockReturn = r.into();
+                        r.blockNumber
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getMetaTransactionExecutedBlockReturn = r.into();
+                    r.blockNumber
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getMetaTransactionHash((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))` and selector `0xae550497`.
+    ```solidity
+    function getMetaTransactionHash(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (bytes32 mtxHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMetaTransactionHashCall {
+        #[allow(missing_docs)]
+        pub mtx:
+            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getMetaTransactionHash((address,address,uint256,uint256,uint256,
+    /// uint256,bytes,uint256,address,uint256))`](getMetaTransactionHashCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMetaTransactionHashReturn {
+        #[allow(missing_docs)]
+        pub mtxHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMetaTransactionHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getMetaTransactionHashCall) -> Self {
+                    (value.mtx,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { mtx: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMetaTransactionHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getMetaTransactionHashReturn) -> Self {
+                    (value.mtxHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { mtxHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getMetaTransactionHashCall {
+            type Parameters<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [174u8, 85u8, 4u8, 151u8];
+            const SIGNATURE: &'static str = "getMetaTransactionHash((address,address,uint256,\
+                                             uint256,uint256,uint256,bytes,uint256,address,\
+                                             uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::tokenize(
+                        &self.mtx,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getMetaTransactionHashReturn = r.into();
+                        r.mtxHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getMetaTransactionHashReturn = r.into();
+                    r.mtxHash
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getMetaTransactionHashExecutedBlock(bytes32)` and selector `0x72d17d03`.
+    ```solidity
+    function getMetaTransactionHashExecutedBlock(bytes32 mtxHash) external view returns (uint256 blockNumber);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMetaTransactionHashExecutedBlockCall {
+        #[allow(missing_docs)]
+        pub mtxHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getMetaTransactionHashExecutedBlock(bytes32)`](getMetaTransactionHashExecutedBlockCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getMetaTransactionHashExecutedBlockReturn {
+        #[allow(missing_docs)]
+        pub blockNumber: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMetaTransactionHashExecutedBlockCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getMetaTransactionHashExecutedBlockCall) -> Self {
+                    (value.mtxHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashExecutedBlockCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { mtxHash: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getMetaTransactionHashExecutedBlockReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getMetaTransactionHashExecutedBlockReturn) -> Self {
+                    (value.blockNumber,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashExecutedBlockReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        blockNumber: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getMetaTransactionHashExecutedBlockCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [114u8, 209u8, 125u8, 3u8];
+            const SIGNATURE: &'static str = "getMetaTransactionHashExecutedBlock(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.mtxHash),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getMetaTransactionHashExecutedBlockReturn = r.into();
+                        r.blockNumber
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getMetaTransactionHashExecutedBlockReturn = r.into();
+                    r.blockNumber
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOtcOrderHash((address,address,uint128,uint128,address,address,address,uint256))` and selector `0x53476b89`.
+    ```solidity
+    function getOtcOrderHash(LibNativeOrder.OtcOrder memory order) external view returns (bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOtcOrderHashCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getOtcOrderHash((address,address,uint128,uint128,address,address,
+    /// address,uint256))`](getOtcOrderHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOtcOrderHashReturn {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOtcOrderHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOtcOrderHashCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOtcOrderHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOtcOrderHashReturn) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOtcOrderHashCall {
+            type Parameters<'a> = (LibNativeOrder::OtcOrder,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [83u8, 71u8, 107u8, 137u8];
+            const SIGNATURE: &'static str = "getOtcOrderHash((address,address,uint128,uint128,\
+                                             address,address,address,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOtcOrderHashReturn = r.into();
+                        r.orderHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOtcOrderHashReturn = r.into();
+                    r.orderHash
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getOtcOrderInfo((address,address,uint128,uint128,address,address,address,uint256))` and selector `0x8c807c43`.
+    ```solidity
+    function getOtcOrderInfo(LibNativeOrder.OtcOrder memory order) external view returns (LibNativeOrder.OtcOrderInfo memory orderInfo);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOtcOrderInfoCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getOtcOrderInfo((address,address,uint128,uint128,address,address,
+    /// address,uint256))`](getOtcOrderInfoCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getOtcOrderInfoReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOtcOrderInfoCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getOtcOrderInfoCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderInfoCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrderInfo,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getOtcOrderInfoReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getOtcOrderInfoReturn) -> Self {
+                    (value.orderInfo,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderInfoReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderInfo: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getOtcOrderInfoCall {
+            type Parameters<'a> = (LibNativeOrder::OtcOrder,);
+            type Return = <LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::RustType;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (LibNativeOrder::OtcOrderInfo,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [140u8, 128u8, 124u8, 67u8];
+            const SIGNATURE: &'static str = "getOtcOrderInfo((address,address,uint128,uint128,\
+                                             address,address,address,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getOtcOrderInfoReturn = r.into();
+                        r.orderInfo
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getOtcOrderInfoReturn = r.into();
+                    r.orderInfo
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getProtocolFeeMultiplier()` and selector `0x487b5c20`.
+    ```solidity
+    function getProtocolFeeMultiplier() external view returns (uint32 multiplier);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeeMultiplierCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getProtocolFeeMultiplier()`](getProtocolFeeMultiplierCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getProtocolFeeMultiplierReturn {
+        #[allow(missing_docs)]
+        pub multiplier: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeeMultiplierCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeeMultiplierCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeeMultiplierCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u32,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getProtocolFeeMultiplierReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getProtocolFeeMultiplierReturn) -> Self {
+                    (value.multiplier,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeeMultiplierReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        multiplier: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getProtocolFeeMultiplierCall {
+            type Parameters<'a> = ();
+            type Return = u32;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [72u8, 123u8, 92u8, 32u8];
+            const SIGNATURE: &'static str = "getProtocolFeeMultiplier()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getProtocolFeeMultiplierReturn = r.into();
+                        r.multiplier
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getProtocolFeeMultiplierReturn = r.into();
+                    r.multiplier
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getQuoteSigner()` and selector `0x9f1ec78b`.
+    ```solidity
+    function getQuoteSigner() external view returns (address signer);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getQuoteSignerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getQuoteSigner()`](getQuoteSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getQuoteSignerReturn {
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getQuoteSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getQuoteSignerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getQuoteSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getQuoteSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getQuoteSignerReturn) -> Self {
+                    (value.signer,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getQuoteSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { signer: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getQuoteSignerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [159u8, 30u8, 199u8, 139u8];
+            const SIGNATURE: &'static str = "getQuoteSigner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getQuoteSignerReturn = r.into();
+                        r.signer
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getQuoteSignerReturn = r.into();
+                    r.signer
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRfqOrderHash((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))` and selector `0x016a6d65`.
+    ```solidity
+    function getRfqOrderHash(LibNativeOrder.RfqOrder memory order) external view returns (bytes32 orderHash);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRfqOrderHashCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRfqOrderHash((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256))`](getRfqOrderHashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRfqOrderHashReturn {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRfqOrderHashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRfqOrderHashCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderHashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRfqOrderHashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRfqOrderHashReturn) -> Self {
+                    (value.orderHash,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderHashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderHash: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRfqOrderHashCall {
+            type Parameters<'a> = (LibNativeOrder::RfqOrder,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [1u8, 106u8, 109u8, 101u8];
+            const SIGNATURE: &'static str = "getRfqOrderHash((address,address,uint128,uint128,\
+                                             address,address,address,bytes32,uint64,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRfqOrderHashReturn = r.into();
+                        r.orderHash
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRfqOrderHashReturn = r.into();
+                    r.orderHash
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRfqOrderInfo((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))` and selector `0x346693c5`.
+    ```solidity
+    function getRfqOrderInfo(LibNativeOrder.RfqOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRfqOrderInfoCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getRfqOrderInfo((address,address,uint128,uint128,address,address,
+    /// address,bytes32,uint64,uint256))`](getRfqOrderInfoCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRfqOrderInfoReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRfqOrderInfoCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRfqOrderInfoCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderInfoCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::OrderInfo,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRfqOrderInfoReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRfqOrderInfoReturn) -> Self {
+                    (value.orderInfo,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderInfoReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { orderInfo: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRfqOrderInfoCall {
+            type Parameters<'a> = (LibNativeOrder::RfqOrder,);
+            type Return = <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (LibNativeOrder::OrderInfo,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [52u8, 102u8, 147u8, 197u8];
+            const SIGNATURE: &'static str = "getRfqOrderInfo((address,address,uint128,uint128,\
+                                             address,address,address,bytes32,uint64,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRfqOrderInfoReturn = r.into();
+                        r.orderInfo
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRfqOrderInfoReturn = r.into();
+                    r.orderInfo
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `getRfqOrderRelevantState((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x37f381d8`.
+    ```solidity
+    function getRfqOrderRelevantState(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRfqOrderRelevantStateCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getRfqOrderRelevantState((address,address,uint128,uint128,address,
+    /// address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
+    /// bytes32))`](getRfqOrderRelevantStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRfqOrderRelevantStateReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub actualFillableTakerTokenAmount: u128,
+        #[allow(missing_docs)]
+        pub isSignatureValid: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder, LibSignature::Signature);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRfqOrderRelevantStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRfqOrderRelevantStateCall) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderRelevantStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OrderInfo,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+                u128,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRfqOrderRelevantStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRfqOrderRelevantStateReturn) -> Self {
+                    (
+                        value.orderInfo,
+                        value.actualFillableTakerTokenAmount,
+                        value.isSignatureValid,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderRelevantStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderInfo: tuple.0,
+                        actualFillableTakerTokenAmount: tuple.1,
+                        isSignatureValid: tuple.2,
+                    }
+                }
+            }
+        }
+        impl getRfqOrderRelevantStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(
+                        &self.orderInfo,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.actualFillableTakerTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isSignatureValid,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRfqOrderRelevantStateCall {
+            type Parameters<'a> = (LibNativeOrder::RfqOrder, LibSignature::Signature);
+            type Return = getRfqOrderRelevantStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                LibNativeOrder::OrderInfo,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [55u8, 243u8, 129u8, 216u8];
+            const SIGNATURE: &'static str = "getRfqOrderRelevantState((address,address,uint128,\
+                                             uint128,address,address,address,bytes32,uint64,\
+                                             uint256),(uint8,uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getRfqOrderRelevantStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRollbackEntryAtIndex(bytes4,uint256)` and selector `0x6ba6bbc2`.
+    ```solidity
+    function getRollbackEntryAtIndex(bytes4 selector, uint256 idx) external view returns (address r#impl);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRollbackEntryAtIndexCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub idx: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRollbackEntryAtIndex(bytes4,uint256)`](getRollbackEntryAtIndexCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRollbackEntryAtIndexReturn {
+        #[allow(missing_docs)]
+        pub r#impl: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<4>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRollbackEntryAtIndexCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRollbackEntryAtIndexCall) -> Self {
+                    (value.selector, value.idx)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackEntryAtIndexCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        selector: tuple.0,
+                        idx: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRollbackEntryAtIndexReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRollbackEntryAtIndexReturn) -> Self {
+                    (value.r#impl,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackEntryAtIndexReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { r#impl: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRollbackEntryAtIndexCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [107u8, 166u8, 187u8, 194u8];
+            const SIGNATURE: &'static str = "getRollbackEntryAtIndex(bytes4,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.idx),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRollbackEntryAtIndexReturn = r.into();
+                        r.r#impl
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRollbackEntryAtIndexReturn = r.into();
+                    r.r#impl
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getRollbackLength(bytes4)` and selector `0xdfd00749`.
+    ```solidity
+    function getRollbackLength(bytes4 selector) external view returns (uint256 rollbackLength);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRollbackLengthCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getRollbackLength(bytes4)`](getRollbackLengthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getRollbackLengthReturn {
+        #[allow(missing_docs)]
+        pub rollbackLength: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRollbackLengthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getRollbackLengthCall) -> Self {
+                    (value.selector,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackLengthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { selector: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getRollbackLengthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getRollbackLengthReturn) -> Self {
+                    (value.rollbackLength,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackLengthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        rollbackLength: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getRollbackLengthCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [223u8, 208u8, 7u8, 73u8];
+            const SIGNATURE: &'static str = "getRollbackLength(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getRollbackLengthReturn = r.into();
+                        r.rollbackLength
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getRollbackLengthReturn = r.into();
+                    r.rollbackLength
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTransformWallet()` and selector `0xf028e9be`.
+    ```solidity
+    function getTransformWallet() external view returns (address wallet);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTransformWalletCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTransformWallet()`](getTransformWalletCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTransformWalletReturn {
+        #[allow(missing_docs)]
+        pub wallet: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTransformWalletCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTransformWalletCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformWalletCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTransformWalletReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTransformWalletReturn) -> Self {
+                    (value.wallet,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformWalletReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { wallet: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTransformWalletCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [240u8, 40u8, 233u8, 190u8];
+            const SIGNATURE: &'static str = "getTransformWallet()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getTransformWalletReturn = r.into();
+                        r.wallet
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getTransformWalletReturn = r.into();
+                    r.wallet
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getTransformerDeployer()` and selector `0x4d54cdb6`.
+    ```solidity
+    function getTransformerDeployer() external view returns (address deployer);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTransformerDeployerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getTransformerDeployer()`](getTransformerDeployerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getTransformerDeployerReturn {
+        #[allow(missing_docs)]
+        pub deployer: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTransformerDeployerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getTransformerDeployerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformerDeployerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getTransformerDeployerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getTransformerDeployerReturn) -> Self {
+                    (value.deployer,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformerDeployerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { deployer: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getTransformerDeployerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [77u8, 84u8, 205u8, 182u8];
+            const SIGNATURE: &'static str = "getTransformerDeployer()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getTransformerDeployerReturn = r.into();
+                        r.deployer
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getTransformerDeployerReturn = r.into();
+                    r.deployer
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidOrderSigner(address,address)` and selector `0x6b52a4a8`.
+    ```solidity
+    function isValidOrderSigner(address maker, address signer) external view returns (bool isAllowed);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidOrderSignerCall {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidOrderSigner(address,address)`](isValidOrderSignerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidOrderSignerReturn {
+        #[allow(missing_docs)]
+        pub isAllowed: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidOrderSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidOrderSignerCall) -> Self {
+                    (value.maker, value.signer)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidOrderSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        maker: tuple.0,
+                        signer: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidOrderSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidOrderSignerReturn) -> Self {
+                    (value.isAllowed,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidOrderSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { isAllowed: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidOrderSignerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [107u8, 82u8, 164u8, 168u8];
+            const SIGNATURE: &'static str = "isValidOrderSigner(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidOrderSignerReturn = r.into();
+                        r.isAllowed
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidOrderSignerReturn = r.into();
+                    r.isAllowed
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `lastOtcTxOriginNonce(address,uint64)` and selector `0x59ebfb45`.
+    ```solidity
+    function lastOtcTxOriginNonce(address txOrigin, uint64 nonceBucket) external view returns (uint128 lastNonce);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct lastOtcTxOriginNonceCall {
+        #[allow(missing_docs)]
+        pub txOrigin: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonceBucket: u64,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`lastOtcTxOriginNonce(address,uint64)`](lastOtcTxOriginNonceCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct lastOtcTxOriginNonceReturn {
+        #[allow(missing_docs)]
+        pub lastNonce: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<64>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, u64);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<lastOtcTxOriginNonceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: lastOtcTxOriginNonceCall) -> Self {
+                    (value.txOrigin, value.nonceBucket)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lastOtcTxOriginNonceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        txOrigin: tuple.0,
+                        nonceBucket: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<lastOtcTxOriginNonceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: lastOtcTxOriginNonceReturn) -> Self {
+                    (value.lastNonce,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lastOtcTxOriginNonceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { lastNonce: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for lastOtcTxOriginNonceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<64>,
+            );
+            type Return = u128;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [89u8, 235u8, 251u8, 69u8];
+            const SIGNATURE: &'static str = "lastOtcTxOriginNonce(address,uint64)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.txOrigin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonceBucket,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: lastOtcTxOriginNonceReturn = r.into();
+                        r.lastNonce
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: lastOtcTxOriginNonceReturn = r.into();
+                    r.lastNonce
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `matchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))` and selector `0x0d8261eb`.
+    ```solidity
+    function matchERC721Orders(LibNFTOrder.ERC721Order memory sellOrder, LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory sellOrderSignature, LibSignature.Signature memory buyOrderSignature) external returns (uint256 profit);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct matchERC721OrdersCall {
+        #[allow(missing_docs)]
+        pub sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub sellOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub buyOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`matchERC721Orders((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),
+    /// (uint8,address,address,uint256,uint256,address,uint256,(address,uint256,
+    /// bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,
+    /// bytes32),(uint8,uint8,bytes32,bytes32))`](matchERC721OrdersCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct matchERC721OrdersReturn {
+        #[allow(missing_docs)]
+        pub profit: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC721Order,
+                LibNFTOrder::ERC721Order,
+                LibSignature::Signature,
+                LibSignature::Signature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<matchERC721OrdersCall> for UnderlyingRustTuple<'_> {
+                fn from(value: matchERC721OrdersCall) -> Self {
+                    (
+                        value.sellOrder,
+                        value.buyOrder,
+                        value.sellOrderSignature,
+                        value.buyOrderSignature,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for matchERC721OrdersCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sellOrder: tuple.0,
+                        buyOrder: tuple.1,
+                        sellOrderSignature: tuple.2,
+                        buyOrderSignature: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<matchERC721OrdersReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: matchERC721OrdersReturn) -> Self {
+                    (value.profit,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for matchERC721OrdersReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { profit: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for matchERC721OrdersCall {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC721Order,
+                LibNFTOrder::ERC721Order,
+                LibSignature::Signature,
+                LibSignature::Signature,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 130u8, 97u8, 235u8];
+            const SIGNATURE: &'static str =
+                "matchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,\
+                 (address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,address,\
+                 address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,\
+                 uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,\
+                 bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
+                        &self.sellOrder,
+                    ),
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
+                        &self.buyOrder,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.sellOrderSignature,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.buyOrderSignature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: matchERC721OrdersReturn = r.into();
+                        r.profit
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: matchERC721OrdersReturn = r.into();
+                    r.profit
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `migrate(address,bytes,address)` and selector `0x261fe679`.
+    ```solidity
+    function migrate(address target, bytes memory data, address newOwner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct migrateCall {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`migrate(address,bytes,address)`](migrateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct migrateReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<migrateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: migrateCall) -> Self {
+                    (value.target, value.data, value.newOwner)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for migrateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        target: tuple.0,
+                        data: tuple.1,
+                        newOwner: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<migrateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: migrateReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for migrateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl migrateReturn {
+            fn _tokenize(&self) -> <migrateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for migrateCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = migrateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [38u8, 31u8, 230u8, 121u8];
+            const SIGNATURE: &'static str = "migrate(address,bytes,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newOwner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                migrateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)` and selector `0xf35b4733`.
+    ```solidity
+    function multiplexBatchSellEthForToken(address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexBatchSellEthForTokenCall {
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calls: alloy_sol_types::private::Vec<
+            <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],
+    /// uint256)`](multiplexBatchSellEthForTokenCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexBatchSellEthForTokenReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<
+                    <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexBatchSellEthForTokenCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexBatchSellEthForTokenCall) -> Self {
+                    (value.outputToken, value.calls, value.minBuyAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellEthForTokenCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        outputToken: tuple.0,
+                        calls: tuple.1,
+                        minBuyAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexBatchSellEthForTokenReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexBatchSellEthForTokenReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellEthForTokenReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multiplexBatchSellEthForTokenCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 91u8, 71u8, 51u8];
+            const SIGNATURE: &'static str =
+                "multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        IMultiplexFeature::BatchSellSubcall,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multiplexBatchSellEthForTokenReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multiplexBatchSellEthForTokenReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)` and selector `0x77725df6`.
+    ```solidity
+    function multiplexBatchSellTokenForEth(address inputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexBatchSellTokenForEthCall {
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calls: alloy_sol_types::private::Vec<
+            <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,
+    /// uint256)`](multiplexBatchSellTokenForEthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexBatchSellTokenForEthReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<
+                    <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexBatchSellTokenForEthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexBatchSellTokenForEthCall) -> Self {
+                    (
+                        value.inputToken,
+                        value.calls,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForEthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        inputToken: tuple.0,
+                        calls: tuple.1,
+                        sellAmount: tuple.2,
+                        minBuyAmount: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexBatchSellTokenForEthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexBatchSellTokenForEthReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForEthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multiplexBatchSellTokenForEthCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [119u8, 114u8, 93u8, 246u8];
+            const SIGNATURE: &'static str =
+                "multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        IMultiplexFeature::BatchSellSubcall,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multiplexBatchSellTokenForEthReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multiplexBatchSellTokenForEthReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `multiplexBatchSellTokenForToken(address,address,(uint8,uint256,bytes)[],uint256,uint256)` and selector `0x7a1eb1b9`.
+    ```solidity
+    function multiplexBatchSellTokenForToken(address inputToken, address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexBatchSellTokenForTokenCall {
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calls: alloy_sol_types::private::Vec<
+            <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multiplexBatchSellTokenForToken(address,address,(uint8,uint256,
+    /// bytes)[],uint256,uint256)`](multiplexBatchSellTokenForTokenCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexBatchSellTokenForTokenReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<
+                    <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexBatchSellTokenForTokenCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexBatchSellTokenForTokenCall) -> Self {
+                    (
+                        value.inputToken,
+                        value.outputToken,
+                        value.calls,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForTokenCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        inputToken: tuple.0,
+                        outputToken: tuple.1,
+                        calls: tuple.2,
+                        sellAmount: tuple.3,
+                        minBuyAmount: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexBatchSellTokenForTokenReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexBatchSellTokenForTokenReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForTokenReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multiplexBatchSellTokenForTokenCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [122u8, 30u8, 177u8, 185u8];
+            const SIGNATURE: &'static str = "multiplexBatchSellTokenForToken(address,address,\
+                                             (uint8,uint256,bytes)[],uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        IMultiplexFeature::BatchSellSubcall,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multiplexBatchSellTokenForTokenReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multiplexBatchSellTokenForTokenReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)` and selector `0x5161b966`.
+    ```solidity
+    function multiplexMultiHopSellEthForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexMultiHopSellEthForTokenCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub calls: alloy_sol_types::private::Vec<
+            <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],
+    /// uint256)`](multiplexMultiHopSellEthForTokenCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexMultiHopSellEthForTokenReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<
+                    <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexMultiHopSellEthForTokenCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexMultiHopSellEthForTokenCall) -> Self {
+                    (value.tokens, value.calls, value.minBuyAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellEthForTokenCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        calls: tuple.1,
+                        minBuyAmount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexMultiHopSellEthForTokenReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexMultiHopSellEthForTokenReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellEthForTokenReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multiplexMultiHopSellEthForTokenCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [81u8, 97u8, 185u8, 102u8];
+            const SIGNATURE: &'static str =
+                "multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        IMultiplexFeature::MultiHopSellSubcall,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multiplexMultiHopSellEthForTokenReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multiplexMultiHopSellEthForTokenReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)` and selector `0x9a2967d2`.
+    ```solidity
+    function multiplexMultiHopSellTokenForEth(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexMultiHopSellTokenForEthCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub calls: alloy_sol_types::private::Vec<
+            <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,
+    /// uint256)`](multiplexMultiHopSellTokenForEthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexMultiHopSellTokenForEthReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<
+                    <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexMultiHopSellTokenForEthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexMultiHopSellTokenForEthCall) -> Self {
+                    (
+                        value.tokens,
+                        value.calls,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForEthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        calls: tuple.1,
+                        sellAmount: tuple.2,
+                        minBuyAmount: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexMultiHopSellTokenForEthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexMultiHopSellTokenForEthReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForEthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multiplexMultiHopSellTokenForEthCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [154u8, 41u8, 103u8, 210u8];
+            const SIGNATURE: &'static str =
+                "multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        IMultiplexFeature::MultiHopSellSubcall,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multiplexMultiHopSellTokenForEthReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multiplexMultiHopSellTokenForEthReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)` and selector `0x0f3b31b2`.
+    ```solidity
+    function multiplexMultiHopSellTokenForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexMultiHopSellTokenForTokenCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub calls: alloy_sol_types::private::Vec<
+            <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,
+    /// uint256)`](multiplexMultiHopSellTokenForTokenCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct multiplexMultiHopSellTokenForTokenReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<
+                    <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexMultiHopSellTokenForTokenCall> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexMultiHopSellTokenForTokenCall) -> Self {
+                    (
+                        value.tokens,
+                        value.calls,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForTokenCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        calls: tuple.1,
+                        sellAmount: tuple.2,
+                        minBuyAmount: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<multiplexMultiHopSellTokenForTokenReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: multiplexMultiHopSellTokenForTokenReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForTokenReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for multiplexMultiHopSellTokenForTokenCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [15u8, 59u8, 49u8, 178u8];
+            const SIGNATURE: &'static str =
+                "multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        IMultiplexFeature::MultiHopSellSubcall,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: multiplexMultiHopSellTokenForTokenReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: multiplexMultiHopSellTokenForTokenReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onERC1155Received(address,address,uint256,uint256,bytes)` and selector `0xf23a6e61`.
+    ```solidity
+    function onERC1155Received(address operator, address from, uint256 tokenId, uint256 value, bytes memory data) external returns (bytes4 success);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC1155ReceivedCall {
+        #[allow(missing_docs)]
+        pub operator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onERC1155Received(address,address,uint256,uint256,
+    /// bytes)`](onERC1155ReceivedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC1155ReceivedReturn {
+        #[allow(missing_docs)]
+        pub success: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC1155ReceivedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC1155ReceivedCall) -> Self {
+                    (
+                        value.operator,
+                        value.from,
+                        value.tokenId,
+                        value.value,
+                        value.data,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        operator: tuple.0,
+                        from: tuple.1,
+                        tokenId: tuple.2,
+                        value: tuple.3,
+                        data: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC1155ReceivedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC1155ReceivedReturn) -> Self {
+                    (value.success,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { success: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
+            const SIGNATURE: &'static str =
+                "onERC1155Received(address,address,uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.operator,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onERC1155ReceivedReturn = r.into();
+                        r.success
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onERC1155ReceivedReturn = r.into();
+                    r.success
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `onERC721Received(address,address,uint256,bytes)` and selector `0x150b7a02`.
+    ```solidity
+    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) external returns (bytes4 success);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC721ReceivedCall {
+        #[allow(missing_docs)]
+        pub operator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`onERC721Received(address,address,uint256,
+    /// bytes)`](onERC721ReceivedCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct onERC721ReceivedReturn {
+        #[allow(missing_docs)]
+        pub success: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC721ReceivedCall> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC721ReceivedCall) -> Self {
+                    (value.operator, value.from, value.tokenId, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        operator: tuple.0,
+                        from: tuple.1,
+                        tokenId: tuple.2,
+                        data: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<onERC721ReceivedReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: onERC721ReceivedReturn) -> Self {
+                    (value.success,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { success: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for onERC721ReceivedCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
+            const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.operator,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: onERC721ReceivedReturn = r.into();
+                        r.success
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: onERC721ReceivedReturn = r.into();
+                    r.success
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `owner()` and selector `0x8da5cb5b`.
+    ```solidity
+    function owner() external view returns (address ownerAddress);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`owner()`](ownerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerReturn {
+        #[allow(missing_docs)]
+        pub ownerAddress: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
+                    (value.ownerAddress,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        ownerAddress: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
+            const SIGNATURE: &'static str = "owner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ownerReturn = r.into();
+                        r.ownerAddress
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: ownerReturn = r.into();
+                    r.ownerAddress
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `preSignERC1155Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))` and selector `0x7b757d97`.
+    ```solidity
+    function preSignERC1155Order(LibNFTOrder.ERC1155Order memory order) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct preSignERC1155OrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`preSignERC1155Order((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
+    /// uint128))`](preSignERC1155OrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct preSignERC1155OrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<preSignERC1155OrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: preSignERC1155OrderCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC1155OrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<preSignERC1155OrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: preSignERC1155OrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC1155OrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl preSignERC1155OrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <preSignERC1155OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for preSignERC1155OrderCall {
+            type Parameters<'a> = (LibNFTOrder::ERC1155Order,);
+            type Return = preSignERC1155OrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [123u8, 117u8, 125u8, 151u8];
+            const SIGNATURE: &'static str = "preSignERC1155Order((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[],uint128))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                preSignERC1155OrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `preSignERC721Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))` and selector `0x462103af`.
+    ```solidity
+    function preSignERC721Order(LibNFTOrder.ERC721Order memory order) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct preSignERC721OrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`preSignERC721Order((uint8,address,address,uint256,uint256,address,
+    /// uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[]))`](preSignERC721OrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct preSignERC721OrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<preSignERC721OrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: preSignERC721OrderCall) -> Self {
+                    (value.order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC721OrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<preSignERC721OrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: preSignERC721OrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC721OrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl preSignERC721OrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <preSignERC721OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for preSignERC721OrderCall {
+            type Parameters<'a> = (LibNFTOrder::ERC721Order,);
+            type Return = preSignERC721OrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [70u8, 33u8, 3u8, 175u8];
+            const SIGNATURE: &'static str = "preSignERC721Order((uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[]))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                preSignERC721OrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `registerAllowedOrderSigner(address,bool)` and selector `0xea7faa61`.
+    ```solidity
+    function registerAllowedOrderSigner(address signer, bool allowed) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerAllowedOrderSignerCall {
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub allowed: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`registerAllowedOrderSigner(address,
+    /// bool)`](registerAllowedOrderSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerAllowedOrderSignerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, bool);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerAllowedOrderSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: registerAllowedOrderSignerCall) -> Self {
+                    (value.signer, value.allowed)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedOrderSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        signer: tuple.0,
+                        allowed: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerAllowedOrderSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: registerAllowedOrderSignerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedOrderSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl registerAllowedOrderSignerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for registerAllowedOrderSignerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = registerAllowedOrderSignerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [234u8, 127u8, 170u8, 97u8];
+            const SIGNATURE: &'static str = "registerAllowedOrderSigner(address,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.allowed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                registerAllowedOrderSignerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `registerAllowedRfqOrigins(address[],bool)` and selector `0xb09f1fb1`.
+    ```solidity
+    function registerAllowedRfqOrigins(address[] memory origins, bool allowed) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerAllowedRfqOriginsCall {
+        #[allow(missing_docs)]
+        pub origins: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub allowed: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`registerAllowedRfqOrigins(address[],
+    /// bool)`](registerAllowedRfqOriginsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct registerAllowedRfqOriginsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerAllowedRfqOriginsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: registerAllowedRfqOriginsCall) -> Self {
+                    (value.origins, value.allowed)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedRfqOriginsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        origins: tuple.0,
+                        allowed: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<registerAllowedRfqOriginsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: registerAllowedRfqOriginsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedRfqOriginsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl registerAllowedRfqOriginsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for registerAllowedRfqOriginsCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = registerAllowedRfqOriginsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [176u8, 159u8, 31u8, 177u8];
+            const SIGNATURE: &'static str = "registerAllowedRfqOrigins(address[],bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.origins),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.allowed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                registerAllowedRfqOriginsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `rollback(bytes4,address)` and selector `0x9db64a40`.
+    ```solidity
+    function rollback(bytes4 selector, address targetImpl) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct rollbackCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub targetImpl: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`rollback(bytes4,address)`](rollbackCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct rollbackReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<4>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<rollbackCall> for UnderlyingRustTuple<'_> {
+                fn from(value: rollbackCall) -> Self {
+                    (value.selector, value.targetImpl)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rollbackCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        selector: tuple.0,
+                        targetImpl: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<rollbackReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: rollbackReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rollbackReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl rollbackReturn {
+            fn _tokenize(&self) -> <rollbackCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for rollbackCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = rollbackReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [157u8, 182u8, 74u8, 64u8];
+            const SIGNATURE: &'static str = "rollback(bytes4,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetImpl,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                rollbackReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `sellERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint256,uint128,bool,bytes)` and selector `0x6e2eec9e`.
+    ```solidity
+    function sellERC1155(LibNFTOrder.ERC1155Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc1155TokenId, uint128 erc1155SellAmount, bool unwrapNativeToken, bytes memory callbackData) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellERC1155Call {
+        #[allow(missing_docs)]
+        pub buyOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155SellAmount: u128,
+        #[allow(missing_docs)]
+        pub unwrapNativeToken: bool,
+        #[allow(missing_docs)]
+        pub callbackData: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`sellERC1155((uint8,address,address,uint256,uint256,address,uint256,
+    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),
+    /// (uint8,uint8,bytes32,bytes32),uint256,uint128,bool,
+    /// bytes)`](sellERC1155Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellERC1155Return {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC1155Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u128,
+                bool,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellERC1155Call> for UnderlyingRustTuple<'_> {
+                fn from(value: sellERC1155Call) -> Self {
+                    (
+                        value.buyOrder,
+                        value.signature,
+                        value.erc1155TokenId,
+                        value.erc1155SellAmount,
+                        value.unwrapNativeToken,
+                        value.callbackData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC1155Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        buyOrder: tuple.0,
+                        signature: tuple.1,
+                        erc1155TokenId: tuple.2,
+                        erc1155SellAmount: tuple.3,
+                        unwrapNativeToken: tuple.4,
+                        callbackData: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellERC1155Return> for UnderlyingRustTuple<'_> {
+                fn from(value: sellERC1155Return) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC1155Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl sellERC1155Return {
+            fn _tokenize(&self) -> <sellERC1155Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellERC1155Call {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC1155Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = sellERC1155Return;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [110u8, 46u8, 236u8, 158u8];
+            const SIGNATURE: &'static str = "sellERC1155((uint8,address,address,uint256,uint256,\
+                                             address,uint256,(address,uint256,bytes)[],address,\
+                                             uint256,(address,bytes)[],uint128),(uint8,uint8,\
+                                             bytes32,bytes32),uint256,uint128,bool,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(
+                        &self.buyOrder,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155SellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.unwrapNativeToken,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callbackData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                sellERC1155Return::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `sellERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),uint256,bool,bytes)` and selector `0xafde1b3c`.
+    ```solidity
+    function sellERC721(LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc721TokenId, bool unwrapNativeToken, bytes memory callbackData) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellERC721Call {
+        #[allow(missing_docs)]
+        pub buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub unwrapNativeToken: bool,
+        #[allow(missing_docs)]
+        pub callbackData: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`sellERC721((uint8,address,address,uint256,uint256,address,uint256,
+    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,
+    /// uint8,bytes32,bytes32),uint256,bool,bytes)`](sellERC721Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellERC721Return {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC721Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellERC721Call> for UnderlyingRustTuple<'_> {
+                fn from(value: sellERC721Call) -> Self {
+                    (
+                        value.buyOrder,
+                        value.signature,
+                        value.erc721TokenId,
+                        value.unwrapNativeToken,
+                        value.callbackData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC721Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        buyOrder: tuple.0,
+                        signature: tuple.1,
+                        erc721TokenId: tuple.2,
+                        unwrapNativeToken: tuple.3,
+                        callbackData: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellERC721Return> for UnderlyingRustTuple<'_> {
+                fn from(value: sellERC721Return) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC721Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl sellERC721Return {
+            fn _tokenize(&self) -> <sellERC721Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellERC721Call {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC721Order,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = sellERC721Return;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 222u8, 27u8, 60u8];
+            const SIGNATURE: &'static str = "sellERC721((uint8,address,address,uint256,uint256,\
+                                             address,uint256,(address,uint256,bytes)[],address,\
+                                             uint256,(address,bytes)[]),(uint8,uint8,bytes32,\
+                                             bytes32),uint256,bool,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
+                        &self.buyOrder,
+                    ),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721TokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.unwrapNativeToken,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callbackData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                sellERC721Return::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sellEthForTokenToUniswapV3(bytes,uint256,address)` and selector `0x3598d8ab`.
+    ```solidity
+    function sellEthForTokenToUniswapV3(bytes memory encodedPath, uint256 minBuyAmount, address recipient) external payable returns (uint256 buyAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellEthForTokenToUniswapV3Call {
+        #[allow(missing_docs)]
+        pub encodedPath: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`sellEthForTokenToUniswapV3(bytes,uint256,
+    /// address)`](sellEthForTokenToUniswapV3Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellEthForTokenToUniswapV3Return {
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellEthForTokenToUniswapV3Call> for UnderlyingRustTuple<'_> {
+                fn from(value: sellEthForTokenToUniswapV3Call) -> Self {
+                    (value.encodedPath, value.minBuyAmount, value.recipient)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellEthForTokenToUniswapV3Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        encodedPath: tuple.0,
+                        minBuyAmount: tuple.1,
+                        recipient: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellEthForTokenToUniswapV3Return> for UnderlyingRustTuple<'_> {
+                fn from(value: sellEthForTokenToUniswapV3Return) -> Self {
+                    (value.buyAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellEthForTokenToUniswapV3Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { buyAmount: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellEthForTokenToUniswapV3Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [53u8, 152u8, 216u8, 171u8];
+            const SIGNATURE: &'static str = "sellEthForTokenToUniswapV3(bytes,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.encodedPath,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minBuyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: sellEthForTokenToUniswapV3Return = r.into();
+                        r.buyAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: sellEthForTokenToUniswapV3Return = r.into();
+                    r.buyAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)` and selector `0xf7fcd384`.
+    ```solidity
+    function sellToLiquidityProvider(address inputToken, address outputToken, address provider, address recipient, uint256 sellAmount, uint256 minBuyAmount, bytes memory auxiliaryData) external payable returns (uint256 boughtAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellToLiquidityProviderCall {
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub provider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub auxiliaryData: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`sellToLiquidityProvider(address,address,address,address,uint256,
+    /// uint256,bytes)`](sellToLiquidityProviderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellToLiquidityProviderReturn {
+        #[allow(missing_docs)]
+        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellToLiquidityProviderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: sellToLiquidityProviderCall) -> Self {
+                    (
+                        value.inputToken,
+                        value.outputToken,
+                        value.provider,
+                        value.recipient,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                        value.auxiliaryData,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToLiquidityProviderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        inputToken: tuple.0,
+                        outputToken: tuple.1,
+                        provider: tuple.2,
+                        recipient: tuple.3,
+                        sellAmount: tuple.4,
+                        minBuyAmount: tuple.5,
+                        auxiliaryData: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellToLiquidityProviderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: sellToLiquidityProviderReturn) -> Self {
+                    (value.boughtAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToLiquidityProviderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        boughtAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellToLiquidityProviderCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [247u8, 252u8, 211u8, 132u8];
+            const SIGNATURE: &'static str =
+                "sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.provider,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minBuyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.auxiliaryData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: sellToLiquidityProviderReturn = r.into();
+                        r.boughtAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: sellToLiquidityProviderReturn = r.into();
+                    r.boughtAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sellToPancakeSwap(address[],uint256,uint256,uint8)` and selector `0xc43c9ef6`.
+    ```solidity
+    function sellToPancakeSwap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, IPancakeSwapFeature.ProtocolFork fork) external payable returns (uint256 buyAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellToPancakeSwapCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fork: <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`sellToPancakeSwap(address[],uint256,uint256,
+    /// uint8)`](sellToPancakeSwapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellToPancakeSwapReturn {
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                IPancakeSwapFeature::ProtocolFork,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellToPancakeSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: sellToPancakeSwapCall) -> Self {
+                    (
+                        value.tokens,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                        value.fork,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToPancakeSwapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        sellAmount: tuple.1,
+                        minBuyAmount: tuple.2,
+                        fork: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellToPancakeSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: sellToPancakeSwapReturn) -> Self {
+                    (value.buyAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToPancakeSwapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { buyAmount: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellToPancakeSwapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                IPancakeSwapFeature::ProtocolFork,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 60u8, 158u8, 246u8];
+            const SIGNATURE: &'static str = "sellToPancakeSwap(address[],uint256,uint256,uint8)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                    <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::tokenize(
+                        &self.fork,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: sellToPancakeSwapReturn = r.into();
+                        r.buyAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: sellToPancakeSwapReturn = r.into();
+                    r.buyAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sellToUniswap(address[],uint256,uint256,bool)` and selector `0xd9627aa4`.
+    ```solidity
+    function sellToUniswap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, bool isSushi) external payable returns (uint256 buyAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellToUniswapCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub isSushi: bool,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`sellToUniswap(address[],uint256,uint256,bool)`](sellToUniswapCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellToUniswapReturn {
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellToUniswapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: sellToUniswapCall) -> Self {
+                    (
+                        value.tokens,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                        value.isSushi,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToUniswapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokens: tuple.0,
+                        sellAmount: tuple.1,
+                        minBuyAmount: tuple.2,
+                        isSushi: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellToUniswapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: sellToUniswapReturn) -> Self {
+                    (value.buyAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToUniswapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { buyAmount: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellToUniswapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [217u8, 98u8, 122u8, 164u8];
+            const SIGNATURE: &'static str = "sellToUniswap(address[],uint256,uint256,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isSushi,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: sellToUniswapReturn = r.into();
+                        r.buyAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: sellToUniswapReturn = r.into();
+                    r.buyAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)` and selector `0x803ba26d`.
+    ```solidity
+    function sellTokenForEthToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellTokenForEthToUniswapV3Call {
+        #[allow(missing_docs)]
+        pub encodedPath: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`sellTokenForEthToUniswapV3(bytes,uint256,uint256,
+    /// address)`](sellTokenForEthToUniswapV3Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellTokenForEthToUniswapV3Return {
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellTokenForEthToUniswapV3Call> for UnderlyingRustTuple<'_> {
+                fn from(value: sellTokenForEthToUniswapV3Call) -> Self {
+                    (
+                        value.encodedPath,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                        value.recipient,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForEthToUniswapV3Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        encodedPath: tuple.0,
+                        sellAmount: tuple.1,
+                        minBuyAmount: tuple.2,
+                        recipient: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellTokenForEthToUniswapV3Return> for UnderlyingRustTuple<'_> {
+                fn from(value: sellTokenForEthToUniswapV3Return) -> Self {
+                    (value.buyAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForEthToUniswapV3Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { buyAmount: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellTokenForEthToUniswapV3Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [128u8, 59u8, 162u8, 109u8];
+            const SIGNATURE: &'static str =
+                "sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.encodedPath,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minBuyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: sellTokenForEthToUniswapV3Return = r.into();
+                        r.buyAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: sellTokenForEthToUniswapV3Return = r.into();
+                    r.buyAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)` and selector `0x6af479b2`.
+    ```solidity
+    function sellTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellTokenForTokenToUniswapV3Call {
+        #[allow(missing_docs)]
+        pub encodedPath: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`sellTokenForTokenToUniswapV3(bytes,uint256,uint256,
+    /// address)`](sellTokenForTokenToUniswapV3Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct sellTokenForTokenToUniswapV3Return {
+        #[allow(missing_docs)]
+        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellTokenForTokenToUniswapV3Call> for UnderlyingRustTuple<'_> {
+                fn from(value: sellTokenForTokenToUniswapV3Call) -> Self {
+                    (
+                        value.encodedPath,
+                        value.sellAmount,
+                        value.minBuyAmount,
+                        value.recipient,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForTokenToUniswapV3Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        encodedPath: tuple.0,
+                        sellAmount: tuple.1,
+                        minBuyAmount: tuple.2,
+                        recipient: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<sellTokenForTokenToUniswapV3Return> for UnderlyingRustTuple<'_> {
+                fn from(value: sellTokenForTokenToUniswapV3Return) -> Self {
+                    (value.buyAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForTokenToUniswapV3Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { buyAmount: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for sellTokenForTokenToUniswapV3Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [106u8, 244u8, 121u8, 178u8];
+            const SIGNATURE: &'static str =
+                "sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.encodedPath,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minBuyAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: sellTokenForTokenToUniswapV3Return = r.into();
+                        r.buyAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: sellTokenForTokenToUniswapV3Return = r.into();
+                    r.buyAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setQuoteSigner(address)` and selector `0x56ce180a`.
+    ```solidity
+    function setQuoteSigner(address quoteSigner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setQuoteSignerCall {
+        #[allow(missing_docs)]
+        pub quoteSigner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setQuoteSigner(address)`](setQuoteSignerCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setQuoteSignerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setQuoteSignerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setQuoteSignerCall) -> Self {
+                    (value.quoteSigner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setQuoteSignerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        quoteSigner: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setQuoteSignerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setQuoteSignerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setQuoteSignerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setQuoteSignerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setQuoteSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setQuoteSignerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setQuoteSignerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [86u8, 206u8, 24u8, 10u8];
+            const SIGNATURE: &'static str = "setQuoteSigner(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteSigner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setQuoteSignerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setTransformerDeployer(address)` and selector `0x87c96419`.
+    ```solidity
+    function setTransformerDeployer(address transformerDeployer) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setTransformerDeployerCall {
+        #[allow(missing_docs)]
+        pub transformerDeployer: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setTransformerDeployer(address)`](setTransformerDeployerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setTransformerDeployerReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setTransformerDeployerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setTransformerDeployerCall) -> Self {
+                    (value.transformerDeployer,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTransformerDeployerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        transformerDeployer: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setTransformerDeployerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setTransformerDeployerReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTransformerDeployerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setTransformerDeployerReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setTransformerDeployerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setTransformerDeployerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setTransformerDeployerReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 201u8, 100u8, 25u8];
+            const SIGNATURE: &'static str = "setTransformerDeployer(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.transformerDeployer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setTransformerDeployerReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `supportInterface(bytes4)` and selector `0x75e79be6`.
+    ```solidity
+    function supportInterface(bytes4 interfaceId) external pure returns (bool isSupported);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct supportInterfaceCall {
+        #[allow(missing_docs)]
+        pub interfaceId: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`supportInterface(bytes4)`](supportInterfaceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct supportInterfaceReturn {
+        #[allow(missing_docs)]
+        pub isSupported: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<supportInterfaceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: supportInterfaceCall) -> Self {
+                    (value.interfaceId,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportInterfaceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        interfaceId: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<supportInterfaceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: supportInterfaceReturn) -> Self {
+                    (value.isSupported,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportInterfaceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        isSupported: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for supportInterfaceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [117u8, 231u8, 155u8, 230u8];
+            const SIGNATURE: &'static str = "supportInterface(bytes4)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: supportInterfaceReturn = r.into();
+                        r.isSupported
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: supportInterfaceReturn = r.into();
+                    r.isSupported
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
+    ```solidity
+    function transferOwnership(address newOwner) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferOwnershipCall {
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferOwnership(address)`](transferOwnershipCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferOwnershipReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferOwnershipCall) -> Self {
+                    (value.newOwner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { newOwner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferOwnershipReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferOwnershipReturn {
+            fn _tokenize(
+                &self,
+            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferOwnershipCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = transferOwnershipReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
+            const SIGNATURE: &'static str = "transferOwnership(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newOwner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferOwnershipReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferProtocolFeesForPools(bytes32[])` and selector `0x3cd2f026`.
+    ```solidity
+    function transferProtocolFeesForPools(bytes32[] memory poolIds) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferProtocolFeesForPoolsCall {
+        #[allow(missing_docs)]
+        pub poolIds: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferProtocolFeesForPools(bytes32[])`](transferProtocolFeesForPoolsCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferProtocolFeesForPoolsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferProtocolFeesForPoolsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferProtocolFeesForPoolsCall) -> Self {
+                    (value.poolIds,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferProtocolFeesForPoolsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { poolIds: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferProtocolFeesForPoolsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferProtocolFeesForPoolsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferProtocolFeesForPoolsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferProtocolFeesForPoolsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferProtocolFeesForPoolsCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,);
+            type Return = transferProtocolFeesForPoolsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [60u8, 210u8, 240u8, 38u8];
+            const SIGNATURE: &'static str = "transferProtocolFeesForPools(bytes32[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::FixedBytes<32>,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.poolIds
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferProtocolFeesForPoolsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferTrappedTokensTo(address,uint256,address)` and selector `0x0d375884`.
+    ```solidity
+    function transferTrappedTokensTo(address erc20, uint256 amountOut, address recipientWallet) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferTrappedTokensToCall {
+        #[allow(missing_docs)]
+        pub erc20: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipientWallet: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferTrappedTokensTo(address,uint256,
+    /// address)`](transferTrappedTokensToCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferTrappedTokensToReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferTrappedTokensToCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferTrappedTokensToCall) -> Self {
+                    (value.erc20, value.amountOut, value.recipientWallet)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferTrappedTokensToCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        erc20: tuple.0,
+                        amountOut: tuple.1,
+                        recipientWallet: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferTrappedTokensToReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferTrappedTokensToReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferTrappedTokensToReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferTrappedTokensToReturn {
+            fn _tokenize(
+                &self,
+            ) -> <transferTrappedTokensToCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferTrappedTokensToCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = transferTrappedTokensToReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 55u8, 88u8, 132u8];
+            const SIGNATURE: &'static str = "transferTrappedTokensTo(address,uint256,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipientWallet,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferTrappedTokensToReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transformERC20(address,address,uint256,uint256,(uint32,bytes)[])` and selector `0x415565b0`.
+    ```solidity
+    function transformERC20(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 minOutputTokenAmount, ITransformERC20Feature.Transformation[] memory transformations) external payable returns (uint256 outputTokenAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transformERC20Call {
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minOutputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub transformations: alloy_sol_types::private::Vec<
+            <ITransformERC20Feature::Transformation as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transformERC20(address,address,uint256,uint256,(uint32,
+    /// bytes)[])`](transformERC20Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transformERC20Return {
+        #[allow(missing_docs)]
+        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<ITransformERC20Feature::Transformation>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<
+                    <ITransformERC20Feature::Transformation as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transformERC20Call> for UnderlyingRustTuple<'_> {
+                fn from(value: transformERC20Call) -> Self {
+                    (
+                        value.inputToken,
+                        value.outputToken,
+                        value.inputTokenAmount,
+                        value.minOutputTokenAmount,
+                        value.transformations,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transformERC20Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        inputToken: tuple.0,
+                        outputToken: tuple.1,
+                        inputTokenAmount: tuple.2,
+                        minOutputTokenAmount: tuple.3,
+                        transformations: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transformERC20Return> for UnderlyingRustTuple<'_> {
+                fn from(value: transformERC20Return) -> Self {
+                    (value.outputTokenAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transformERC20Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        outputTokenAmount: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transformERC20Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<ITransformERC20Feature::Transformation>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [65u8, 85u8, 101u8, 176u8];
+            const SIGNATURE: &'static str =
+                "transformERC20(address,address,uint256,uint256,(uint32,bytes)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.inputTokenAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minOutputTokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        ITransformERC20Feature::Transformation,
+                    > as alloy_sol_types::SolType>::tokenize(&self.transformations),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transformERC20Return = r.into();
+                        r.outputTokenAmount
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transformERC20Return = r.into();
+                    r.outputTokenAmount
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `uniswapV3SwapCallback(int256,int256,bytes)` and selector `0xfa461e33`.
+    ```solidity
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct uniswapV3SwapCallbackCall {
+        #[allow(missing_docs)]
+        pub amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`uniswapV3SwapCallback(int256,int256,
+    /// bytes)`](uniswapV3SwapCallbackCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct uniswapV3SwapCallbackReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<uniswapV3SwapCallbackCall> for UnderlyingRustTuple<'_> {
+                fn from(value: uniswapV3SwapCallbackCall) -> Self {
+                    (value.amount0Delta, value.amount1Delta, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0Delta: tuple.0,
+                        amount1Delta: tuple.1,
+                        data: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<uniswapV3SwapCallbackReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: uniswapV3SwapCallbackReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl uniswapV3SwapCallbackReturn {
+            fn _tokenize(
+                &self,
+            ) -> <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for uniswapV3SwapCallbackCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = uniswapV3SwapCallbackReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [250u8, 70u8, 30u8, 51u8];
+            const SIGNATURE: &'static str = "uniswapV3SwapCallback(int256,int256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Delta,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Delta,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                uniswapV3SwapCallbackReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateERC1155OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),uint256)` and selector `0x2ac6f62a`.
+    ```solidity
+    function validateERC1155OrderProperties(LibNFTOrder.ERC1155Order memory order, uint256 erc1155TokenId) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC1155OrderPropertiesCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateERC1155OrderProperties((uint8,address,address,uint256,uint256,
+    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[],uint128),uint256)`](validateERC1155OrderPropertiesCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC1155OrderPropertiesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC1155Order,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC1155OrderPropertiesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC1155OrderPropertiesCall) -> Self {
+                    (value.order, value.erc1155TokenId)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderPropertiesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        erc1155TokenId: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC1155OrderPropertiesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC1155OrderPropertiesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderPropertiesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateERC1155OrderPropertiesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateERC1155OrderPropertiesCall {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC1155Order,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = validateERC1155OrderPropertiesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [42u8, 198u8, 246u8, 42u8];
+            const SIGNATURE: &'static str = "validateERC1155OrderProperties((uint8,address,\
+                                             address,uint256,uint256,address,uint256,(address,\
+                                             uint256,bytes)[],address,uint256,(address,bytes)[],\
+                                             uint128),uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenId,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateERC1155OrderPropertiesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateERC1155OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32))` and selector `0x0d32a531`.
+    ```solidity
+    function validateERC1155OrderSignature(LibNFTOrder.ERC1155Order memory order, LibSignature.Signature memory signature) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC1155OrderSignatureCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateERC1155OrderSignature((uint8,address,address,uint256,uint256,
+    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[],uint128),(uint8,uint8,bytes32,
+    /// bytes32))`](validateERC1155OrderSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC1155OrderSignatureReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order, LibSignature::Signature);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC1155OrderSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC1155OrderSignatureCall) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC1155OrderSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC1155OrderSignatureReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateERC1155OrderSignatureReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateERC1155OrderSignatureCall {
+            type Parameters<'a> = (LibNFTOrder::ERC1155Order, LibSignature::Signature);
+            type Return = validateERC1155OrderSignatureReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 50u8, 165u8, 49u8];
+            const SIGNATURE: &'static str = "validateERC1155OrderSignature((uint8,address,address,\
+                                             uint256,uint256,address,uint256,(address,uint256,\
+                                             bytes)[],address,uint256,(address,bytes)[],uint128),\
+                                             (uint8,uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateERC1155OrderSignatureReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateERC721OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),uint256)` and selector `0x4a13d797`.
+    ```solidity
+    function validateERC721OrderProperties(LibNFTOrder.ERC721Order memory order, uint256 erc721TokenId) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC721OrderPropertiesCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateERC721OrderProperties((uint8,address,address,uint256,uint256,
+    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[]),uint256)`](validateERC721OrderPropertiesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC721OrderPropertiesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNFTOrder::ERC721Order,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC721OrderPropertiesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC721OrderPropertiesCall) -> Self {
+                    (value.order, value.erc721TokenId)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderPropertiesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        erc721TokenId: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC721OrderPropertiesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC721OrderPropertiesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderPropertiesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateERC721OrderPropertiesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateERC721OrderPropertiesCall {
+            type Parameters<'a> = (
+                LibNFTOrder::ERC721Order,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = validateERC721OrderPropertiesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 19u8, 215u8, 151u8];
+            const SIGNATURE: &'static str = "validateERC721OrderProperties((uint8,address,address,\
+                                             uint256,uint256,address,uint256,(address,uint256,\
+                                             bytes)[],address,uint256,(address,bytes)[]),uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721TokenId,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateERC721OrderPropertiesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateERC721OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32))` and selector `0xd1ca183b`.
+    ```solidity
+    function validateERC721OrderSignature(LibNFTOrder.ERC721Order memory order, LibSignature.Signature memory signature) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC721OrderSignatureCall {
+        #[allow(missing_docs)]
+        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateERC721OrderSignature((uint8,address,address,uint256,uint256,
+    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
+    /// bytes)[]),(uint8,uint8,bytes32,
+    /// bytes32))`](validateERC721OrderSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateERC721OrderSignatureReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order, LibSignature::Signature);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC721OrderSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC721OrderSignatureCall) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateERC721OrderSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateERC721OrderSignatureReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateERC721OrderSignatureReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateERC721OrderSignatureCall {
+            type Parameters<'a> = (LibNFTOrder::ERC721Order, LibSignature::Signature);
+            type Return = validateERC721OrderSignatureReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [209u8, 202u8, 24u8, 59u8];
+            const SIGNATURE: &'static str = "validateERC721OrderSignature((uint8,address,address,\
+                                             uint256,uint256,address,uint256,(address,uint256,\
+                                             bytes)[],address,uint256,(address,bytes)[]),(uint8,\
+                                             uint8,bytes32,bytes32))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateERC721OrderSignatureReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`IZeroex`](self) function calls.
+    #[derive(Clone)]
+    pub enum IZeroexCalls {
+        #[allow(missing_docs)]
+        _fillLimitOrder(_fillLimitOrderCall),
+        #[allow(missing_docs)]
+        _fillOtcOrder(_fillOtcOrderCall),
+        #[allow(missing_docs)]
+        _fillRfqOrder(_fillRfqOrderCall),
+        #[allow(missing_docs)]
+        _sellHeldTokenForTokenToUniswapV3(_sellHeldTokenForTokenToUniswapV3Call),
+        #[allow(missing_docs)]
+        _transformERC20(_transformERC20Call),
+        #[allow(missing_docs)]
+        batchBuyERC1155s(batchBuyERC1155sCall),
+        #[allow(missing_docs)]
+        batchBuyERC721s(batchBuyERC721sCall),
+        #[allow(missing_docs)]
+        batchCancelERC1155Orders(batchCancelERC1155OrdersCall),
+        #[allow(missing_docs)]
+        batchCancelERC721Orders(batchCancelERC721OrdersCall),
+        #[allow(missing_docs)]
+        batchCancelLimitOrders(batchCancelLimitOrdersCall),
+        #[allow(missing_docs)]
+        batchCancelPairLimitOrders(batchCancelPairLimitOrdersCall),
+        #[allow(missing_docs)]
+        batchCancelPairLimitOrdersWithSigner(batchCancelPairLimitOrdersWithSignerCall),
+        #[allow(missing_docs)]
+        batchCancelPairRfqOrders(batchCancelPairRfqOrdersCall),
+        #[allow(missing_docs)]
+        batchCancelPairRfqOrdersWithSigner(batchCancelPairRfqOrdersWithSignerCall),
+        #[allow(missing_docs)]
+        batchCancelRfqOrders(batchCancelRfqOrdersCall),
+        #[allow(missing_docs)]
+        batchExecuteMetaTransactions(batchExecuteMetaTransactionsCall),
+        #[allow(missing_docs)]
+        batchFillLimitOrders(batchFillLimitOrdersCall),
+        #[allow(missing_docs)]
+        batchFillRfqOrders(batchFillRfqOrdersCall),
+        #[allow(missing_docs)]
+        batchFillTakerSignedOtcOrders(batchFillTakerSignedOtcOrdersCall),
+        #[allow(missing_docs)]
+        batchGetLimitOrderRelevantStates(batchGetLimitOrderRelevantStatesCall),
+        #[allow(missing_docs)]
+        batchGetRfqOrderRelevantStates(batchGetRfqOrderRelevantStatesCall),
+        #[allow(missing_docs)]
+        batchMatchERC721Orders(batchMatchERC721OrdersCall),
+        #[allow(missing_docs)]
+        buyERC1155(buyERC1155Call),
+        #[allow(missing_docs)]
+        buyERC721(buyERC721Call),
+        #[allow(missing_docs)]
+        cancelERC1155Order(cancelERC1155OrderCall),
+        #[allow(missing_docs)]
+        cancelERC721Order(cancelERC721OrderCall),
+        #[allow(missing_docs)]
+        cancelLimitOrder(cancelLimitOrderCall),
+        #[allow(missing_docs)]
+        cancelPairLimitOrders(cancelPairLimitOrdersCall),
+        #[allow(missing_docs)]
+        cancelPairLimitOrdersWithSigner(cancelPairLimitOrdersWithSignerCall),
+        #[allow(missing_docs)]
+        cancelPairRfqOrders(cancelPairRfqOrdersCall),
+        #[allow(missing_docs)]
+        cancelPairRfqOrdersWithSigner(cancelPairRfqOrdersWithSignerCall),
+        #[allow(missing_docs)]
+        cancelRfqOrder(cancelRfqOrderCall),
+        #[allow(missing_docs)]
+        createTransformWallet(createTransformWalletCall),
+        #[allow(missing_docs)]
+        executeMetaTransaction(executeMetaTransactionCall),
+        #[allow(missing_docs)]
+        extend(extendCall),
+        #[allow(missing_docs)]
+        fillLimitOrder(fillLimitOrderCall),
+        #[allow(missing_docs)]
+        fillOrKillLimitOrder(fillOrKillLimitOrderCall),
+        #[allow(missing_docs)]
+        fillOrKillRfqOrder(fillOrKillRfqOrderCall),
+        #[allow(missing_docs)]
+        fillOtcOrder(fillOtcOrderCall),
+        #[allow(missing_docs)]
+        fillOtcOrderForEth(fillOtcOrderForEthCall),
+        #[allow(missing_docs)]
+        fillOtcOrderWithEth(fillOtcOrderWithEthCall),
+        #[allow(missing_docs)]
+        fillRfqOrder(fillRfqOrderCall),
+        #[allow(missing_docs)]
+        fillTakerSignedOtcOrder(fillTakerSignedOtcOrderCall),
+        #[allow(missing_docs)]
+        fillTakerSignedOtcOrderForEth(fillTakerSignedOtcOrderForEthCall),
+        #[allow(missing_docs)]
+        getERC1155OrderHash(getERC1155OrderHashCall),
+        #[allow(missing_docs)]
+        getERC1155OrderInfo(getERC1155OrderInfoCall),
+        #[allow(missing_docs)]
+        getERC721OrderHash(getERC721OrderHashCall),
+        #[allow(missing_docs)]
+        getERC721OrderStatus(getERC721OrderStatusCall),
+        #[allow(missing_docs)]
+        getERC721OrderStatusBitVector(getERC721OrderStatusBitVectorCall),
+        #[allow(missing_docs)]
+        getLimitOrderHash(getLimitOrderHashCall),
+        #[allow(missing_docs)]
+        getLimitOrderInfo(getLimitOrderInfoCall),
+        #[allow(missing_docs)]
+        getLimitOrderRelevantState(getLimitOrderRelevantStateCall),
+        #[allow(missing_docs)]
+        getMetaTransactionExecutedBlock(getMetaTransactionExecutedBlockCall),
+        #[allow(missing_docs)]
+        getMetaTransactionHash(getMetaTransactionHashCall),
+        #[allow(missing_docs)]
+        getMetaTransactionHashExecutedBlock(getMetaTransactionHashExecutedBlockCall),
+        #[allow(missing_docs)]
+        getOtcOrderHash(getOtcOrderHashCall),
+        #[allow(missing_docs)]
+        getOtcOrderInfo(getOtcOrderInfoCall),
+        #[allow(missing_docs)]
+        getProtocolFeeMultiplier(getProtocolFeeMultiplierCall),
+        #[allow(missing_docs)]
+        getQuoteSigner(getQuoteSignerCall),
+        #[allow(missing_docs)]
+        getRfqOrderHash(getRfqOrderHashCall),
+        #[allow(missing_docs)]
+        getRfqOrderInfo(getRfqOrderInfoCall),
+        #[allow(missing_docs)]
+        getRfqOrderRelevantState(getRfqOrderRelevantStateCall),
+        #[allow(missing_docs)]
+        getRollbackEntryAtIndex(getRollbackEntryAtIndexCall),
+        #[allow(missing_docs)]
+        getRollbackLength(getRollbackLengthCall),
+        #[allow(missing_docs)]
+        getTransformWallet(getTransformWalletCall),
+        #[allow(missing_docs)]
+        getTransformerDeployer(getTransformerDeployerCall),
+        #[allow(missing_docs)]
+        isValidOrderSigner(isValidOrderSignerCall),
+        #[allow(missing_docs)]
+        lastOtcTxOriginNonce(lastOtcTxOriginNonceCall),
+        #[allow(missing_docs)]
+        matchERC721Orders(matchERC721OrdersCall),
+        #[allow(missing_docs)]
+        migrate(migrateCall),
+        #[allow(missing_docs)]
+        multiplexBatchSellEthForToken(multiplexBatchSellEthForTokenCall),
+        #[allow(missing_docs)]
+        multiplexBatchSellTokenForEth(multiplexBatchSellTokenForEthCall),
+        #[allow(missing_docs)]
+        multiplexBatchSellTokenForToken(multiplexBatchSellTokenForTokenCall),
+        #[allow(missing_docs)]
+        multiplexMultiHopSellEthForToken(multiplexMultiHopSellEthForTokenCall),
+        #[allow(missing_docs)]
+        multiplexMultiHopSellTokenForEth(multiplexMultiHopSellTokenForEthCall),
+        #[allow(missing_docs)]
+        multiplexMultiHopSellTokenForToken(multiplexMultiHopSellTokenForTokenCall),
+        #[allow(missing_docs)]
+        onERC1155Received(onERC1155ReceivedCall),
+        #[allow(missing_docs)]
+        onERC721Received(onERC721ReceivedCall),
+        #[allow(missing_docs)]
+        owner(ownerCall),
+        #[allow(missing_docs)]
+        preSignERC1155Order(preSignERC1155OrderCall),
+        #[allow(missing_docs)]
+        preSignERC721Order(preSignERC721OrderCall),
+        #[allow(missing_docs)]
+        registerAllowedOrderSigner(registerAllowedOrderSignerCall),
+        #[allow(missing_docs)]
+        registerAllowedRfqOrigins(registerAllowedRfqOriginsCall),
+        #[allow(missing_docs)]
+        rollback(rollbackCall),
+        #[allow(missing_docs)]
+        sellERC1155(sellERC1155Call),
+        #[allow(missing_docs)]
+        sellERC721(sellERC721Call),
+        #[allow(missing_docs)]
+        sellEthForTokenToUniswapV3(sellEthForTokenToUniswapV3Call),
+        #[allow(missing_docs)]
+        sellToLiquidityProvider(sellToLiquidityProviderCall),
+        #[allow(missing_docs)]
+        sellToPancakeSwap(sellToPancakeSwapCall),
+        #[allow(missing_docs)]
+        sellToUniswap(sellToUniswapCall),
+        #[allow(missing_docs)]
+        sellTokenForEthToUniswapV3(sellTokenForEthToUniswapV3Call),
+        #[allow(missing_docs)]
+        sellTokenForTokenToUniswapV3(sellTokenForTokenToUniswapV3Call),
+        #[allow(missing_docs)]
+        setQuoteSigner(setQuoteSignerCall),
+        #[allow(missing_docs)]
+        setTransformerDeployer(setTransformerDeployerCall),
+        #[allow(missing_docs)]
+        supportInterface(supportInterfaceCall),
+        #[allow(missing_docs)]
+        transferOwnership(transferOwnershipCall),
+        #[allow(missing_docs)]
+        transferProtocolFeesForPools(transferProtocolFeesForPoolsCall),
+        #[allow(missing_docs)]
+        transferTrappedTokensTo(transferTrappedTokensToCall),
+        #[allow(missing_docs)]
+        transformERC20(transformERC20Call),
+        #[allow(missing_docs)]
+        uniswapV3SwapCallback(uniswapV3SwapCallbackCall),
+        #[allow(missing_docs)]
+        validateERC1155OrderProperties(validateERC1155OrderPropertiesCall),
+        #[allow(missing_docs)]
+        validateERC1155OrderSignature(validateERC1155OrderSignatureCall),
+        #[allow(missing_docs)]
+        validateERC721OrderProperties(validateERC721OrderPropertiesCall),
+        #[allow(missing_docs)]
+        validateERC721OrderSignature(validateERC721OrderSignatureCall),
+    }
+    impl IZeroexCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [1u8, 106u8, 109u8, 101u8],
+            [3u8, 11u8, 39u8, 48u8],
+            [6u8, 210u8, 89u8, 107u8],
+            [13u8, 50u8, 165u8, 49u8],
+            [13u8, 55u8, 88u8, 132u8],
+            [13u8, 130u8, 97u8, 235u8],
+            [15u8, 14u8, 140u8, 247u8],
+            [15u8, 59u8, 49u8, 178u8],
+            [21u8, 11u8, 122u8, 2u8],
+            [27u8, 170u8, 160u8, 11u8],
+            [29u8, 227u8, 167u8, 172u8],
+            [31u8, 176u8, 151u8, 149u8],
+            [38u8, 31u8, 230u8, 121u8],
+            [40u8, 123u8, 7u8, 27u8],
+            [42u8, 198u8, 246u8, 42u8],
+            [52u8, 102u8, 147u8, 197u8],
+            [53u8, 152u8, 216u8, 171u8],
+            [55u8, 243u8, 129u8, 216u8],
+            [60u8, 210u8, 240u8, 38u8],
+            [61u8, 97u8, 237u8, 62u8],
+            [63u8, 178u8, 218u8, 56u8],
+            [65u8, 78u8, 76u8, 207u8],
+            [65u8, 85u8, 101u8, 176u8],
+            [67u8, 140u8, 223u8, 197u8],
+            [70u8, 33u8, 3u8, 175u8],
+            [72u8, 123u8, 92u8, 32u8],
+            [73u8, 145u8, 253u8, 114u8],
+            [74u8, 19u8, 215u8, 151u8],
+            [74u8, 147u8, 27u8, 161u8],
+            [77u8, 84u8, 205u8, 182u8],
+            [79u8, 148u8, 129u8, 16u8],
+            [81u8, 97u8, 185u8, 102u8],
+            [83u8, 71u8, 107u8, 137u8],
+            [86u8, 206u8, 24u8, 10u8],
+            [89u8, 235u8, 251u8, 69u8],
+            [106u8, 244u8, 121u8, 178u8],
+            [107u8, 82u8, 164u8, 168u8],
+            [107u8, 166u8, 187u8, 194u8],
+            [110u8, 46u8, 236u8, 158u8],
+            [110u8, 178u8, 36u8, 203u8],
+            [112u8, 99u8, 148u8, 213u8],
+            [114u8, 77u8, 57u8, 83u8],
+            [114u8, 209u8, 125u8, 3u8],
+            [117u8, 16u8, 60u8, 185u8],
+            [117u8, 231u8, 155u8, 230u8],
+            [119u8, 114u8, 93u8, 246u8],
+            [122u8, 30u8, 177u8, 185u8],
+            [123u8, 117u8, 125u8, 151u8],
+            [124u8, 219u8, 84u8, 216u8],
+            [125u8, 73u8, 236u8, 26u8],
+            [125u8, 169u8, 226u8, 207u8],
+            [128u8, 59u8, 162u8, 109u8],
+            [132u8, 104u8, 6u8, 21u8],
+            [134u8, 33u8, 153u8, 64u8],
+            [134u8, 160u8, 200u8, 215u8],
+            [135u8, 201u8, 100u8, 25u8],
+            [138u8, 166u8, 83u8, 155u8],
+            [140u8, 128u8, 124u8, 67u8],
+            [141u8, 165u8, 203u8, 91u8],
+            [146u8, 64u8, 82u8, 156u8],
+            [147u8, 92u8, 130u8, 164u8],
+            [149u8, 72u8, 8u8, 137u8],
+            [154u8, 41u8, 103u8, 210u8],
+            [154u8, 79u8, 128u8, 156u8],
+            [155u8, 170u8, 69u8, 168u8],
+            [157u8, 182u8, 74u8, 64u8],
+            [159u8, 4u8, 52u8, 245u8],
+            [159u8, 30u8, 199u8, 139u8],
+            [161u8, 134u8, 93u8, 111u8],
+            [165u8, 120u8, 239u8, 175u8],
+            [170u8, 107u8, 33u8, 205u8],
+            [170u8, 119u8, 71u8, 108u8],
+            [173u8, 53u8, 78u8, 235u8],
+            [174u8, 85u8, 4u8, 151u8],
+            [175u8, 222u8, 27u8, 60u8],
+            [176u8, 159u8, 31u8, 177u8],
+            [177u8, 10u8, 51u8, 244u8],
+            [180u8, 101u8, 139u8, 251u8],
+            [183u8, 58u8, 96u8, 39u8],
+            [190u8, 22u8, 123u8, 157u8],
+            [196u8, 60u8, 158u8, 246u8],
+            [197u8, 87u8, 158u8, 200u8],
+            [208u8, 165u8, 95u8, 176u8],
+            [209u8, 202u8, 24u8, 59u8],
+            [217u8, 98u8, 122u8, 164u8],
+            [218u8, 199u8, 72u8, 212u8],
+            [221u8, 17u8, 210u8, 37u8],
+            [223u8, 208u8, 7u8, 73u8],
+            [228u8, 186u8, 132u8, 57u8],
+            [229u8, 45u8, 23u8, 100u8],
+            [234u8, 127u8, 170u8, 97u8],
+            [234u8, 233u8, 62u8, 231u8],
+            [240u8, 40u8, 233u8, 190u8],
+            [242u8, 58u8, 110u8, 97u8],
+            [242u8, 253u8, 227u8, 139u8],
+            [243u8, 91u8, 71u8, 51u8],
+            [246u8, 39u8, 79u8, 102u8],
+            [246u8, 224u8, 246u8, 165u8],
+            [247u8, 252u8, 211u8, 132u8],
+            [250u8, 70u8, 30u8, 51u8],
+            [251u8, 196u8, 165u8, 24u8],
+            [251u8, 238u8, 52u8, 157u8],
+            [253u8, 95u8, 153u8, 91u8],
+            [254u8, 85u8, 163u8, 239u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getRfqOrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelERC1155OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferTrappedTokensToCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <matchERC721OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onERC721ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getERC1155OrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <migrateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createTransformWalletCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRfqOrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <executeMetaTransactionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <_fillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transformERC20Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <preSignERC721OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTransformerDeployerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOtcOrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setQuoteSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <isValidOrderSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellERC1155Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <extendCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <supportInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <preSignERC1155OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <buyERC1155Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchBuyERC1155sCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setTransformerDeployerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <_transformERC20Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <getOtcOrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getLimitOrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <rollbackCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getQuoteSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <_fillRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getMetaTransactionHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellERC721Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getERC721OrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelERC721OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellToPancakeSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellToUniswapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillOtcOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getLimitOrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getRollbackLengthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <_fillOtcOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchBuyERC721sCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getTransformWalletCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getERC721OrderStatusCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <buyERC721Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getRfqOrderHash),
+            ::core::stringify!(getERC721OrderStatusBitVector),
+            ::core::stringify!(cancelERC1155Order),
+            ::core::stringify!(validateERC1155OrderSignature),
+            ::core::stringify!(transferTrappedTokensTo),
+            ::core::stringify!(matchERC721Orders),
+            ::core::stringify!(batchCancelPairRfqOrders),
+            ::core::stringify!(multiplexMultiHopSellTokenForToken),
+            ::core::stringify!(onERC721Received),
+            ::core::stringify!(batchFillLimitOrders),
+            ::core::stringify!(getERC1155OrderHash),
+            ::core::stringify!(getLimitOrderRelevantState),
+            ::core::stringify!(migrate),
+            ::core::stringify!(createTransformWallet),
+            ::core::stringify!(validateERC1155OrderProperties),
+            ::core::stringify!(getRfqOrderInfo),
+            ::core::stringify!(sellEthForTokenToUniswapV3),
+            ::core::stringify!(getRfqOrderRelevantState),
+            ::core::stringify!(transferProtocolFeesForPools),
+            ::core::stringify!(executeMetaTransaction),
+            ::core::stringify!(getMetaTransactionExecutedBlock),
+            ::core::stringify!(_fillLimitOrder),
+            ::core::stringify!(transformERC20),
+            ::core::stringify!(fillOrKillRfqOrder),
+            ::core::stringify!(preSignERC721Order),
+            ::core::stringify!(getProtocolFeeMultiplier),
+            ::core::stringify!(getERC1155OrderInfo),
+            ::core::stringify!(validateERC721OrderProperties),
+            ::core::stringify!(_sellHeldTokenForTokenToUniswapV3),
+            ::core::stringify!(getTransformerDeployer),
+            ::core::stringify!(fillTakerSignedOtcOrder),
+            ::core::stringify!(multiplexMultiHopSellEthForToken),
+            ::core::stringify!(getOtcOrderHash),
+            ::core::stringify!(setQuoteSigner),
+            ::core::stringify!(lastOtcTxOriginNonce),
+            ::core::stringify!(sellTokenForTokenToUniswapV3),
+            ::core::stringify!(isValidOrderSigner),
+            ::core::stringify!(getRollbackEntryAtIndex),
+            ::core::stringify!(sellERC1155),
+            ::core::stringify!(extend),
+            ::core::stringify!(fillOtcOrderWithEth),
+            ::core::stringify!(fillTakerSignedOtcOrderForEth),
+            ::core::stringify!(getMetaTransactionHashExecutedBlock),
+            ::core::stringify!(batchFillRfqOrders),
+            ::core::stringify!(supportInterface),
+            ::core::stringify!(multiplexBatchSellTokenForEth),
+            ::core::stringify!(multiplexBatchSellTokenForToken),
+            ::core::stringify!(preSignERC1155Order),
+            ::core::stringify!(buyERC1155),
+            ::core::stringify!(cancelLimitOrder),
+            ::core::stringify!(batchMatchERC721Orders),
+            ::core::stringify!(sellTokenForEthToUniswapV3),
+            ::core::stringify!(batchBuyERC1155s),
+            ::core::stringify!(batchCancelERC721Orders),
+            ::core::stringify!(batchCancelPairLimitOrders),
+            ::core::stringify!(setTransformerDeployer),
+            ::core::stringify!(_transformERC20),
+            ::core::stringify!(getOtcOrderInfo),
+            ::core::stringify!(owner),
+            ::core::stringify!(fillOrKillLimitOrder),
+            ::core::stringify!(cancelPairRfqOrdersWithSigner),
+            ::core::stringify!(getLimitOrderInfo),
+            ::core::stringify!(multiplexMultiHopSellTokenForEth),
+            ::core::stringify!(cancelPairRfqOrders),
+            ::core::stringify!(batchCancelLimitOrders),
+            ::core::stringify!(rollback),
+            ::core::stringify!(batchCancelPairLimitOrdersWithSigner),
+            ::core::stringify!(getQuoteSigner),
+            ::core::stringify!(batchCancelERC1155Orders),
+            ::core::stringify!(fillOtcOrderForEth),
+            ::core::stringify!(_fillRfqOrder),
+            ::core::stringify!(fillRfqOrder),
+            ::core::stringify!(batchGetRfqOrderRelevantStates),
+            ::core::stringify!(getMetaTransactionHash),
+            ::core::stringify!(sellERC721),
+            ::core::stringify!(registerAllowedRfqOrigins),
+            ::core::stringify!(cancelPairLimitOrdersWithSigner),
+            ::core::stringify!(batchGetLimitOrderRelevantStates),
+            ::core::stringify!(getERC721OrderHash),
+            ::core::stringify!(cancelERC721Order),
+            ::core::stringify!(sellToPancakeSwap),
+            ::core::stringify!(batchExecuteMetaTransactions),
+            ::core::stringify!(cancelPairLimitOrders),
+            ::core::stringify!(validateERC721OrderSignature),
+            ::core::stringify!(sellToUniswap),
+            ::core::stringify!(fillOtcOrder),
+            ::core::stringify!(getLimitOrderHash),
+            ::core::stringify!(getRollbackLength),
+            ::core::stringify!(_fillOtcOrder),
+            ::core::stringify!(batchFillTakerSignedOtcOrders),
+            ::core::stringify!(registerAllowedOrderSigner),
+            ::core::stringify!(batchBuyERC721s),
+            ::core::stringify!(getTransformWallet),
+            ::core::stringify!(onERC1155Received),
+            ::core::stringify!(transferOwnership),
+            ::core::stringify!(multiplexBatchSellEthForToken),
+            ::core::stringify!(fillLimitOrder),
+            ::core::stringify!(batchCancelRfqOrders),
+            ::core::stringify!(sellToLiquidityProvider),
+            ::core::stringify!(uniswapV3SwapCallback),
+            ::core::stringify!(getERC721OrderStatus),
+            ::core::stringify!(buyERC721),
+            ::core::stringify!(batchCancelPairRfqOrdersWithSigner),
+            ::core::stringify!(cancelRfqOrder),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for IZeroexCalls {
+        const COUNT: usize = 104usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "IZeroexCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::_fillLimitOrder(_) => {
+                    <_fillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::_fillOtcOrder(_) => <_fillOtcOrderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::_fillRfqOrder(_) => <_fillRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::_sellHeldTokenForTokenToUniswapV3(_) => {
+                    <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::_transformERC20(_) => {
+                    <_transformERC20Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchBuyERC1155s(_) => {
+                    <batchBuyERC1155sCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchBuyERC721s(_) => {
+                    <batchBuyERC721sCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelERC1155Orders(_) => {
+                    <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelERC721Orders(_) => {
+                    <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelLimitOrders(_) => {
+                    <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelPairLimitOrders(_) => {
+                    <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelPairLimitOrdersWithSigner(_) => {
+                    <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelPairRfqOrders(_) => {
+                    <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelPairRfqOrdersWithSigner(_) => {
+                    <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchCancelRfqOrders(_) => {
+                    <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchExecuteMetaTransactions(_) => {
+                    <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchFillLimitOrders(_) => {
+                    <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchFillRfqOrders(_) => {
+                    <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchFillTakerSignedOtcOrders(_) => {
+                    <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchGetLimitOrderRelevantStates(_) => {
+                    <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchGetRfqOrderRelevantStates(_) => {
+                    <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::batchMatchERC721Orders(_) => {
+                    <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::buyERC1155(_) => <buyERC1155Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::buyERC721(_) => <buyERC721Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::cancelERC1155Order(_) => {
+                    <cancelERC1155OrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelERC721Order(_) => {
+                    <cancelERC721OrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelLimitOrder(_) => {
+                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelPairLimitOrders(_) => {
+                    <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelPairLimitOrdersWithSigner(_) => {
+                    <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelPairRfqOrders(_) => {
+                    <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelPairRfqOrdersWithSigner(_) => {
+                    <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::cancelRfqOrder(_) => {
+                    <cancelRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::createTransformWallet(_) => {
+                    <createTransformWalletCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::executeMetaTransaction(_) => {
+                    <executeMetaTransactionCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::extend(_) => <extendCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::fillLimitOrder(_) => {
+                    <fillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::fillOrKillLimitOrder(_) => {
+                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::fillOrKillRfqOrder(_) => {
+                    <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::fillOtcOrder(_) => <fillOtcOrderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::fillOtcOrderForEth(_) => {
+                    <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::fillOtcOrderWithEth(_) => {
+                    <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::fillRfqOrder(_) => <fillRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::fillTakerSignedOtcOrder(_) => {
+                    <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::fillTakerSignedOtcOrderForEth(_) => {
+                    <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getERC1155OrderHash(_) => {
+                    <getERC1155OrderHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getERC1155OrderInfo(_) => {
+                    <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getERC721OrderHash(_) => {
+                    <getERC721OrderHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getERC721OrderStatus(_) => {
+                    <getERC721OrderStatusCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getERC721OrderStatusBitVector(_) => {
+                    <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getLimitOrderHash(_) => {
+                    <getLimitOrderHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getLimitOrderInfo(_) => {
+                    <getLimitOrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getLimitOrderRelevantState(_) => {
+                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getMetaTransactionExecutedBlock(_) => {
+                    <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getMetaTransactionHash(_) => {
+                    <getMetaTransactionHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getMetaTransactionHashExecutedBlock(_) => {
+                    <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getOtcOrderHash(_) => {
+                    <getOtcOrderHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getOtcOrderInfo(_) => {
+                    <getOtcOrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getProtocolFeeMultiplier(_) => {
+                    <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getQuoteSigner(_) => {
+                    <getQuoteSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getRfqOrderHash(_) => {
+                    <getRfqOrderHashCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getRfqOrderInfo(_) => {
+                    <getRfqOrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getRfqOrderRelevantState(_) => {
+                    <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getRollbackEntryAtIndex(_) => {
+                    <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getRollbackLength(_) => {
+                    <getRollbackLengthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getTransformWallet(_) => {
+                    <getTransformWalletCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getTransformerDeployer(_) => {
+                    <getTransformerDeployerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isValidOrderSigner(_) => {
+                    <isValidOrderSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::lastOtcTxOriginNonce(_) => {
+                    <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::matchERC721Orders(_) => {
+                    <matchERC721OrdersCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::migrate(_) => <migrateCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::multiplexBatchSellEthForToken(_) => {
+                    <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::multiplexBatchSellTokenForEth(_) => {
+                    <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::multiplexBatchSellTokenForToken(_) => {
+                    <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::multiplexMultiHopSellEthForToken(_) => {
+                    <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::multiplexMultiHopSellTokenForEth(_) => {
+                    <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::multiplexMultiHopSellTokenForToken(_) => {
+                    <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::onERC1155Received(_) => {
+                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::onERC721Received(_) => {
+                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::preSignERC1155Order(_) => {
+                    <preSignERC1155OrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::preSignERC721Order(_) => {
+                    <preSignERC721OrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::registerAllowedOrderSigner(_) => {
+                    <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::registerAllowedRfqOrigins(_) => {
+                    <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::rollback(_) => <rollbackCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::sellERC1155(_) => <sellERC1155Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::sellERC721(_) => <sellERC721Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::sellEthForTokenToUniswapV3(_) => {
+                    <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::sellToLiquidityProvider(_) => {
+                    <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::sellToPancakeSwap(_) => {
+                    <sellToPancakeSwapCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::sellToUniswap(_) => <sellToUniswapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::sellTokenForEthToUniswapV3(_) => {
+                    <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::sellTokenForTokenToUniswapV3(_) => {
+                    <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setQuoteSigner(_) => {
+                    <setQuoteSignerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::setTransformerDeployer(_) => {
+                    <setTransformerDeployerCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::supportInterface(_) => {
+                    <supportInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::transferOwnership(_) => {
+                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::transferProtocolFeesForPools(_) => {
+                    <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::transferTrappedTokensTo(_) => {
+                    <transferTrappedTokensToCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::transformERC20(_) => {
+                    <transformERC20Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::uniswapV3SwapCallback(_) => {
+                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateERC1155OrderProperties(_) => {
+                    <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateERC1155OrderSignature(_) => {
+                    <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateERC721OrderProperties(_) => {
+                    <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateERC721OrderSignature(_) => {
+                    <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IZeroexCalls>] = &[
+                {
+                    fn getRfqOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getRfqOrderHash)
+                    }
+                    getRfqOrderHash
+                },
+                {
+                    fn getERC721OrderStatusBitVector(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::getERC721OrderStatusBitVector)
+                    }
+                    getERC721OrderStatusBitVector
+                },
+                {
+                    fn cancelERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::cancelERC1155Order)
+                    }
+                    cancelERC1155Order
+                },
+                {
+                    fn validateERC1155OrderSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC1155OrderSignature)
+                    }
+                    validateERC1155OrderSignature
+                },
+                {
+                    fn transferTrappedTokensTo(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::transferTrappedTokensTo)
+                    }
+                    transferTrappedTokensTo
+                },
+                {
+                    fn matchERC721Orders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::matchERC721Orders)
+                    }
+                    matchERC721Orders
+                },
+                {
+                    fn batchCancelPairRfqOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchCancelPairRfqOrders)
+                    }
+                    batchCancelPairRfqOrders
+                },
+                {
+                    fn multiplexMultiHopSellTokenForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexMultiHopSellTokenForToken)
+                    }
+                    multiplexMultiHopSellTokenForToken
+                },
+                {
+                    fn onERC721Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::onERC721Received)
+                    }
+                    onERC721Received
+                },
+                {
+                    fn batchFillLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::batchFillLimitOrders)
+                    }
+                    batchFillLimitOrders
+                },
+                {
+                    fn getERC1155OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getERC1155OrderHash)
+                    }
+                    getERC1155OrderHash
+                },
+                {
+                    fn getLimitOrderRelevantState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::getLimitOrderRelevantState)
+                    }
+                    getLimitOrderRelevantState
+                },
+                {
+                    fn migrate(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <migrateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::migrate)
+                    }
+                    migrate
+                },
+                {
+                    fn createTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <createTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::createTransformWallet)
+                    }
+                    createTransformWallet
+                },
+                {
+                    fn validateERC1155OrderProperties(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC1155OrderProperties)
+                    }
+                    validateERC1155OrderProperties
+                },
+                {
+                    fn getRfqOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getRfqOrderInfo)
+                    }
+                    getRfqOrderInfo
+                },
+                {
+                    fn sellEthForTokenToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellEthForTokenToUniswapV3)
+                    }
+                    sellEthForTokenToUniswapV3
+                },
+                {
+                    fn getRfqOrderRelevantState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::getRfqOrderRelevantState)
+                    }
+                    getRfqOrderRelevantState
+                },
+                {
+                    fn transferProtocolFeesForPools(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::transferProtocolFeesForPools)
+                    }
+                    transferProtocolFeesForPools
+                },
+                {
+                    fn executeMetaTransaction(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::executeMetaTransaction)
+                    }
+                    executeMetaTransaction
+                },
+                {
+                    fn getMetaTransactionExecutedBlock(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::getMetaTransactionExecutedBlock)
+                    }
+                    getMetaTransactionExecutedBlock
+                },
+                {
+                    fn _fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::_fillLimitOrder)
+                    }
+                    _fillLimitOrder
+                },
+                {
+                    fn transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::transformERC20)
+                    }
+                    transformERC20
+                },
+                {
+                    fn fillOrKillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillOrKillRfqOrder)
+                    }
+                    fillOrKillRfqOrder
+                },
+                {
+                    fn preSignERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::preSignERC721Order)
+                    }
+                    preSignERC721Order
+                },
+                {
+                    fn getProtocolFeeMultiplier(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::getProtocolFeeMultiplier)
+                    }
+                    getProtocolFeeMultiplier
+                },
+                {
+                    fn getERC1155OrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getERC1155OrderInfo)
+                    }
+                    getERC1155OrderInfo
+                },
+                {
+                    fn validateERC721OrderProperties(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC721OrderProperties)
+                    }
+                    validateERC721OrderProperties
+                },
+                {
+                    fn _sellHeldTokenForTokenToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::_sellHeldTokenForTokenToUniswapV3)
+                    }
+                    _sellHeldTokenForTokenToUniswapV3
+                },
+                {
+                    fn getTransformerDeployer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::getTransformerDeployer)
+                    }
+                    getTransformerDeployer
+                },
+                {
+                    fn fillTakerSignedOtcOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::fillTakerSignedOtcOrder)
+                    }
+                    fillTakerSignedOtcOrder
+                },
+                {
+                    fn multiplexMultiHopSellEthForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexMultiHopSellEthForToken)
+                    }
+                    multiplexMultiHopSellEthForToken
+                },
+                {
+                    fn getOtcOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getOtcOrderHash)
+                    }
+                    getOtcOrderHash
+                },
+                {
+                    fn setQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::setQuoteSigner)
+                    }
+                    setQuoteSigner
+                },
+                {
+                    fn lastOtcTxOriginNonce(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::lastOtcTxOriginNonce)
+                    }
+                    lastOtcTxOriginNonce
+                },
+                {
+                    fn sellTokenForTokenToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellTokenForTokenToUniswapV3)
+                    }
+                    sellTokenForTokenToUniswapV3
+                },
+                {
+                    fn isValidOrderSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::isValidOrderSigner)
+                    }
+                    isValidOrderSigner
+                },
+                {
+                    fn getRollbackEntryAtIndex(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::getRollbackEntryAtIndex)
+                    }
+                    getRollbackEntryAtIndex
+                },
+                {
+                    fn sellERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::sellERC1155)
+                    }
+                    sellERC1155
+                },
+                {
+                    fn extend(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <extendCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::extend)
+                    }
+                    extend
+                },
+                {
+                    fn fillOtcOrderWithEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillOtcOrderWithEth)
+                    }
+                    fillOtcOrderWithEth
+                },
+                {
+                    fn fillTakerSignedOtcOrderForEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillTakerSignedOtcOrderForEth)
+                    }
+                    fillTakerSignedOtcOrderForEth
+                },
+                {
+                    fn getMetaTransactionHashExecutedBlock(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::getMetaTransactionHashExecutedBlock)
+                    }
+                    getMetaTransactionHashExecutedBlock
+                },
+                {
+                    fn batchFillRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::batchFillRfqOrders)
+                    }
+                    batchFillRfqOrders
+                },
+                {
+                    fn supportInterface(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <supportInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::supportInterface)
+                    }
+                    supportInterface
+                },
+                {
+                    fn multiplexBatchSellTokenForEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexBatchSellTokenForEth)
+                    }
+                    multiplexBatchSellTokenForEth
+                },
+                {
+                    fn multiplexBatchSellTokenForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexBatchSellTokenForToken)
+                    }
+                    multiplexBatchSellTokenForToken
+                },
+                {
+                    fn preSignERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::preSignERC1155Order)
+                    }
+                    preSignERC1155Order
+                },
+                {
+                    fn buyERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <buyERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::buyERC1155)
+                    }
+                    buyERC1155
+                },
+                {
+                    fn cancelLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::cancelLimitOrder)
+                    }
+                    cancelLimitOrder
+                },
+                {
+                    fn batchMatchERC721Orders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchMatchERC721Orders)
+                    }
+                    batchMatchERC721Orders
+                },
+                {
+                    fn sellTokenForEthToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellTokenForEthToUniswapV3)
+                    }
+                    sellTokenForEthToUniswapV3
+                },
+                {
+                    fn batchBuyERC1155s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::batchBuyERC1155s)
+                    }
+                    batchBuyERC1155s
+                },
+                {
+                    fn batchCancelERC721Orders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchCancelERC721Orders)
+                    }
+                    batchCancelERC721Orders
+                },
+                {
+                    fn batchCancelPairLimitOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairLimitOrders)
+                    }
+                    batchCancelPairLimitOrders
+                },
+                {
+                    fn setTransformerDeployer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::setTransformerDeployer)
+                    }
+                    setTransformerDeployer
+                },
+                {
+                    fn _transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::_transformERC20)
+                    }
+                    _transformERC20
+                },
+                {
+                    fn getOtcOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getOtcOrderInfo)
+                    }
+                    getOtcOrderInfo
+                },
+                {
+                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn fillOrKillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillOrKillLimitOrder)
+                    }
+                    fillOrKillLimitOrder
+                },
+                {
+                    fn cancelPairRfqOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelPairRfqOrdersWithSigner)
+                    }
+                    cancelPairRfqOrdersWithSigner
+                },
+                {
+                    fn getLimitOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getLimitOrderInfo)
+                    }
+                    getLimitOrderInfo
+                },
+                {
+                    fn multiplexMultiHopSellTokenForEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexMultiHopSellTokenForEth)
+                    }
+                    multiplexMultiHopSellTokenForEth
+                },
+                {
+                    fn cancelPairRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::cancelPairRfqOrders)
+                    }
+                    cancelPairRfqOrders
+                },
+                {
+                    fn batchCancelLimitOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchCancelLimitOrders)
+                    }
+                    batchCancelLimitOrders
+                },
+                {
+                    fn rollback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <rollbackCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::rollback)
+                    }
+                    rollback
+                },
+                {
+                    fn batchCancelPairLimitOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairLimitOrdersWithSigner)
+                    }
+                    batchCancelPairLimitOrdersWithSigner
+                },
+                {
+                    fn getQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getQuoteSigner)
+                    }
+                    getQuoteSigner
+                },
+                {
+                    fn batchCancelERC1155Orders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchCancelERC1155Orders)
+                    }
+                    batchCancelERC1155Orders
+                },
+                {
+                    fn fillOtcOrderForEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillOtcOrderForEth)
+                    }
+                    fillOtcOrderForEth
+                },
+                {
+                    fn _fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::_fillRfqOrder)
+                    }
+                    _fillRfqOrder
+                },
+                {
+                    fn fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillRfqOrder)
+                    }
+                    fillRfqOrder
+                },
+                {
+                    fn batchGetRfqOrderRelevantStates(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchGetRfqOrderRelevantStates)
+                    }
+                    batchGetRfqOrderRelevantStates
+                },
+                {
+                    fn getMetaTransactionHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::getMetaTransactionHash)
+                    }
+                    getMetaTransactionHash
+                },
+                {
+                    fn sellERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellERC721Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::sellERC721)
+                    }
+                    sellERC721
+                },
+                {
+                    fn registerAllowedRfqOrigins(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::registerAllowedRfqOrigins)
+                    }
+                    registerAllowedRfqOrigins
+                },
+                {
+                    fn cancelPairLimitOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelPairLimitOrdersWithSigner)
+                    }
+                    cancelPairLimitOrdersWithSigner
+                },
+                {
+                    fn batchGetLimitOrderRelevantStates(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchGetLimitOrderRelevantStates)
+                    }
+                    batchGetLimitOrderRelevantStates
+                },
+                {
+                    fn getERC721OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getERC721OrderHash)
+                    }
+                    getERC721OrderHash
+                },
+                {
+                    fn cancelERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::cancelERC721Order)
+                    }
+                    cancelERC721Order
+                },
+                {
+                    fn sellToPancakeSwap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::sellToPancakeSwap)
+                    }
+                    sellToPancakeSwap
+                },
+                {
+                    fn batchExecuteMetaTransactions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchExecuteMetaTransactions)
+                    }
+                    batchExecuteMetaTransactions
+                },
+                {
+                    fn cancelPairLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::cancelPairLimitOrders)
+                    }
+                    cancelPairLimitOrders
+                },
+                {
+                    fn validateERC721OrderSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC721OrderSignature)
+                    }
+                    validateERC721OrderSignature
+                },
+                {
+                    fn sellToUniswap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellToUniswapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::sellToUniswap)
+                    }
+                    sellToUniswap
+                },
+                {
+                    fn fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillOtcOrder)
+                    }
+                    fillOtcOrder
+                },
+                {
+                    fn getLimitOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getLimitOrderHash)
+                    }
+                    getLimitOrderHash
+                },
+                {
+                    fn getRollbackLength(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getRollbackLength)
+                    }
+                    getRollbackLength
+                },
+                {
+                    fn _fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::_fillOtcOrder)
+                    }
+                    _fillOtcOrder
+                },
+                {
+                    fn batchFillTakerSignedOtcOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchFillTakerSignedOtcOrders)
+                    }
+                    batchFillTakerSignedOtcOrders
+                },
+                {
+                    fn registerAllowedOrderSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::registerAllowedOrderSigner)
+                    }
+                    registerAllowedOrderSigner
+                },
+                {
+                    fn batchBuyERC721s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::batchBuyERC721s)
+                    }
+                    batchBuyERC721s
+                },
+                {
+                    fn getTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getTransformWallet)
+                    }
+                    getTransformWallet
+                },
+                {
+                    fn onERC1155Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::onERC1155Received)
+                    }
+                    onERC1155Received
+                },
+                {
+                    fn transferOwnership(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::transferOwnership)
+                    }
+                    transferOwnership
+                },
+                {
+                    fn multiplexBatchSellEthForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexBatchSellEthForToken)
+                    }
+                    multiplexBatchSellEthForToken
+                },
+                {
+                    fn fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillLimitOrder)
+                    }
+                    fillLimitOrder
+                },
+                {
+                    fn batchCancelRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::batchCancelRfqOrders)
+                    }
+                    batchCancelRfqOrders
+                },
+                {
+                    fn sellToLiquidityProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::sellToLiquidityProvider)
+                    }
+                    sellToLiquidityProvider
+                },
+                {
+                    fn uniswapV3SwapCallback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(IZeroexCalls::uniswapV3SwapCallback)
+                    }
+                    uniswapV3SwapCallback
+                },
+                {
+                    fn getERC721OrderStatus(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::getERC721OrderStatus)
+                    }
+                    getERC721OrderStatus
+                },
+                {
+                    fn buyERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <buyERC721Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::buyERC721)
+                    }
+                    buyERC721
+                },
+                {
+                    fn batchCancelPairRfqOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairRfqOrdersWithSigner)
+                    }
+                    batchCancelPairRfqOrdersWithSigner
+                },
+                {
+                    fn cancelRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::cancelRfqOrder)
+                    }
+                    cancelRfqOrder
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IZeroexCalls>] = &[
+                {
+                    fn getRfqOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::getRfqOrderHash)
+                    }
+                    getRfqOrderHash
+                },
+                {
+                    fn getERC721OrderStatusBitVector(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getERC721OrderStatusBitVector)
+                    }
+                    getERC721OrderStatusBitVector
+                },
+                {
+                    fn cancelERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelERC1155Order)
+                    }
+                    cancelERC1155Order
+                },
+                {
+                    fn validateERC1155OrderSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC1155OrderSignature)
+                    }
+                    validateERC1155OrderSignature
+                },
+                {
+                    fn transferTrappedTokensTo(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::transferTrappedTokensTo)
+                    }
+                    transferTrappedTokensTo
+                },
+                {
+                    fn matchERC721Orders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::matchERC721Orders)
+                    }
+                    matchERC721Orders
+                },
+                {
+                    fn batchCancelPairRfqOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairRfqOrders)
+                    }
+                    batchCancelPairRfqOrders
+                },
+                {
+                    fn multiplexMultiHopSellTokenForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexMultiHopSellTokenForToken)
+                    }
+                    multiplexMultiHopSellTokenForToken
+                },
+                {
+                    fn onERC721Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::onERC721Received)
+                    }
+                    onERC721Received
+                },
+                {
+                    fn batchFillLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchFillLimitOrders)
+                    }
+                    batchFillLimitOrders
+                },
+                {
+                    fn getERC1155OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getERC1155OrderHash)
+                    }
+                    getERC1155OrderHash
+                },
+                {
+                    fn getLimitOrderRelevantState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getLimitOrderRelevantState)
+                    }
+                    getLimitOrderRelevantState
+                },
+                {
+                    fn migrate(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <migrateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::migrate)
+                    }
+                    migrate
+                },
+                {
+                    fn createTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <createTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::createTransformWallet)
+                    }
+                    createTransformWallet
+                },
+                {
+                    fn validateERC1155OrderProperties(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC1155OrderProperties)
+                    }
+                    validateERC1155OrderProperties
+                },
+                {
+                    fn getRfqOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::getRfqOrderInfo)
+                    }
+                    getRfqOrderInfo
+                },
+                {
+                    fn sellEthForTokenToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellEthForTokenToUniswapV3)
+                    }
+                    sellEthForTokenToUniswapV3
+                },
+                {
+                    fn getRfqOrderRelevantState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getRfqOrderRelevantState)
+                    }
+                    getRfqOrderRelevantState
+                },
+                {
+                    fn transferProtocolFeesForPools(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::transferProtocolFeesForPools)
+                    }
+                    transferProtocolFeesForPools
+                },
+                {
+                    fn executeMetaTransaction(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::executeMetaTransaction)
+                    }
+                    executeMetaTransaction
+                },
+                {
+                    fn getMetaTransactionExecutedBlock(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getMetaTransactionExecutedBlock)
+                    }
+                    getMetaTransactionExecutedBlock
+                },
+                {
+                    fn _fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::_fillLimitOrder)
+                    }
+                    _fillLimitOrder
+                },
+                {
+                    fn transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::transformERC20)
+                    }
+                    transformERC20
+                },
+                {
+                    fn fillOrKillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillOrKillRfqOrder)
+                    }
+                    fillOrKillRfqOrder
+                },
+                {
+                    fn preSignERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::preSignERC721Order)
+                    }
+                    preSignERC721Order
+                },
+                {
+                    fn getProtocolFeeMultiplier(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getProtocolFeeMultiplier)
+                    }
+                    getProtocolFeeMultiplier
+                },
+                {
+                    fn getERC1155OrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getERC1155OrderInfo)
+                    }
+                    getERC1155OrderInfo
+                },
+                {
+                    fn validateERC721OrderProperties(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC721OrderProperties)
+                    }
+                    validateERC721OrderProperties
+                },
+                {
+                    fn _sellHeldTokenForTokenToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::_sellHeldTokenForTokenToUniswapV3)
+                    }
+                    _sellHeldTokenForTokenToUniswapV3
+                },
+                {
+                    fn getTransformerDeployer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getTransformerDeployer)
+                    }
+                    getTransformerDeployer
+                },
+                {
+                    fn fillTakerSignedOtcOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillTakerSignedOtcOrder)
+                    }
+                    fillTakerSignedOtcOrder
+                },
+                {
+                    fn multiplexMultiHopSellEthForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexMultiHopSellEthForToken)
+                    }
+                    multiplexMultiHopSellEthForToken
+                },
+                {
+                    fn getOtcOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::getOtcOrderHash)
+                    }
+                    getOtcOrderHash
+                },
+                {
+                    fn setQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::setQuoteSigner)
+                    }
+                    setQuoteSigner
+                },
+                {
+                    fn lastOtcTxOriginNonce(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::lastOtcTxOriginNonce)
+                    }
+                    lastOtcTxOriginNonce
+                },
+                {
+                    fn sellTokenForTokenToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellTokenForTokenToUniswapV3)
+                    }
+                    sellTokenForTokenToUniswapV3
+                },
+                {
+                    fn isValidOrderSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::isValidOrderSigner)
+                    }
+                    isValidOrderSigner
+                },
+                {
+                    fn getRollbackEntryAtIndex(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getRollbackEntryAtIndex)
+                    }
+                    getRollbackEntryAtIndex
+                },
+                {
+                    fn sellERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::sellERC1155)
+                    }
+                    sellERC1155
+                },
+                {
+                    fn extend(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <extendCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::extend)
+                    }
+                    extend
+                },
+                {
+                    fn fillOtcOrderWithEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillOtcOrderWithEth)
+                    }
+                    fillOtcOrderWithEth
+                },
+                {
+                    fn fillTakerSignedOtcOrderForEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillTakerSignedOtcOrderForEth)
+                    }
+                    fillTakerSignedOtcOrderForEth
+                },
+                {
+                    fn getMetaTransactionHashExecutedBlock(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getMetaTransactionHashExecutedBlock)
+                    }
+                    getMetaTransactionHashExecutedBlock
+                },
+                {
+                    fn batchFillRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchFillRfqOrders)
+                    }
+                    batchFillRfqOrders
+                },
+                {
+                    fn supportInterface(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <supportInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::supportInterface)
+                    }
+                    supportInterface
+                },
+                {
+                    fn multiplexBatchSellTokenForEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexBatchSellTokenForEth)
+                    }
+                    multiplexBatchSellTokenForEth
+                },
+                {
+                    fn multiplexBatchSellTokenForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexBatchSellTokenForToken)
+                    }
+                    multiplexBatchSellTokenForToken
+                },
+                {
+                    fn preSignERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::preSignERC1155Order)
+                    }
+                    preSignERC1155Order
+                },
+                {
+                    fn buyERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <buyERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::buyERC1155)
+                    }
+                    buyERC1155
+                },
+                {
+                    fn cancelLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::cancelLimitOrder)
+                    }
+                    cancelLimitOrder
+                },
+                {
+                    fn batchMatchERC721Orders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchMatchERC721Orders)
+                    }
+                    batchMatchERC721Orders
+                },
+                {
+                    fn sellTokenForEthToUniswapV3(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellTokenForEthToUniswapV3)
+                    }
+                    sellTokenForEthToUniswapV3
+                },
+                {
+                    fn batchBuyERC1155s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchBuyERC1155s)
+                    }
+                    batchBuyERC1155s
+                },
+                {
+                    fn batchCancelERC721Orders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelERC721Orders)
+                    }
+                    batchCancelERC721Orders
+                },
+                {
+                    fn batchCancelPairLimitOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairLimitOrders)
+                    }
+                    batchCancelPairLimitOrders
+                },
+                {
+                    fn setTransformerDeployer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::setTransformerDeployer)
+                    }
+                    setTransformerDeployer
+                },
+                {
+                    fn _transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::_transformERC20)
+                    }
+                    _transformERC20
+                },
+                {
+                    fn getOtcOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::getOtcOrderInfo)
+                    }
+                    getOtcOrderInfo
+                },
+                {
+                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn fillOrKillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillOrKillLimitOrder)
+                    }
+                    fillOrKillLimitOrder
+                },
+                {
+                    fn cancelPairRfqOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelPairRfqOrdersWithSigner)
+                    }
+                    cancelPairRfqOrdersWithSigner
+                },
+                {
+                    fn getLimitOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getLimitOrderInfo)
+                    }
+                    getLimitOrderInfo
+                },
+                {
+                    fn multiplexMultiHopSellTokenForEth(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexMultiHopSellTokenForEth)
+                    }
+                    multiplexMultiHopSellTokenForEth
+                },
+                {
+                    fn cancelPairRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelPairRfqOrders)
+                    }
+                    cancelPairRfqOrders
+                },
+                {
+                    fn batchCancelLimitOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelLimitOrders)
+                    }
+                    batchCancelLimitOrders
+                },
+                {
+                    fn rollback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <rollbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::rollback)
+                    }
+                    rollback
+                },
+                {
+                    fn batchCancelPairLimitOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairLimitOrdersWithSigner)
+                    }
+                    batchCancelPairLimitOrdersWithSigner
+                },
+                {
+                    fn getQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::getQuoteSigner)
+                    }
+                    getQuoteSigner
+                },
+                {
+                    fn batchCancelERC1155Orders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelERC1155Orders)
+                    }
+                    batchCancelERC1155Orders
+                },
+                {
+                    fn fillOtcOrderForEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillOtcOrderForEth)
+                    }
+                    fillOtcOrderForEth
+                },
+                {
+                    fn _fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::_fillRfqOrder)
+                    }
+                    _fillRfqOrder
+                },
+                {
+                    fn fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::fillRfqOrder)
+                    }
+                    fillRfqOrder
+                },
+                {
+                    fn batchGetRfqOrderRelevantStates(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchGetRfqOrderRelevantStates)
+                    }
+                    batchGetRfqOrderRelevantStates
+                },
+                {
+                    fn getMetaTransactionHash(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getMetaTransactionHash)
+                    }
+                    getMetaTransactionHash
+                },
+                {
+                    fn sellERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellERC721Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::sellERC721)
+                    }
+                    sellERC721
+                },
+                {
+                    fn registerAllowedRfqOrigins(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::registerAllowedRfqOrigins)
+                    }
+                    registerAllowedRfqOrigins
+                },
+                {
+                    fn cancelPairLimitOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelPairLimitOrdersWithSigner)
+                    }
+                    cancelPairLimitOrdersWithSigner
+                },
+                {
+                    fn batchGetLimitOrderRelevantStates(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchGetLimitOrderRelevantStates)
+                    }
+                    batchGetLimitOrderRelevantStates
+                },
+                {
+                    fn getERC721OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getERC721OrderHash)
+                    }
+                    getERC721OrderHash
+                },
+                {
+                    fn cancelERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelERC721Order)
+                    }
+                    cancelERC721Order
+                },
+                {
+                    fn sellToPancakeSwap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellToPancakeSwap)
+                    }
+                    sellToPancakeSwap
+                },
+                {
+                    fn batchExecuteMetaTransactions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchExecuteMetaTransactions)
+                    }
+                    batchExecuteMetaTransactions
+                },
+                {
+                    fn cancelPairLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::cancelPairLimitOrders)
+                    }
+                    cancelPairLimitOrders
+                },
+                {
+                    fn validateERC721OrderSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::validateERC721OrderSignature)
+                    }
+                    validateERC721OrderSignature
+                },
+                {
+                    fn sellToUniswap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellToUniswapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::sellToUniswap)
+                    }
+                    sellToUniswap
+                },
+                {
+                    fn fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::fillOtcOrder)
+                    }
+                    fillOtcOrder
+                },
+                {
+                    fn getLimitOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getLimitOrderHash)
+                    }
+                    getLimitOrderHash
+                },
+                {
+                    fn getRollbackLength(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getRollbackLength)
+                    }
+                    getRollbackLength
+                },
+                {
+                    fn _fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::_fillOtcOrder)
+                    }
+                    _fillOtcOrder
+                },
+                {
+                    fn batchFillTakerSignedOtcOrders(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchFillTakerSignedOtcOrders)
+                    }
+                    batchFillTakerSignedOtcOrders
+                },
+                {
+                    fn registerAllowedOrderSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::registerAllowedOrderSigner)
+                    }
+                    registerAllowedOrderSigner
+                },
+                {
+                    fn batchBuyERC721s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::batchBuyERC721s)
+                    }
+                    batchBuyERC721s
+                },
+                {
+                    fn getTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getTransformWallet)
+                    }
+                    getTransformWallet
+                },
+                {
+                    fn onERC1155Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::onERC1155Received)
+                    }
+                    onERC1155Received
+                },
+                {
+                    fn transferOwnership(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::transferOwnership)
+                    }
+                    transferOwnership
+                },
+                {
+                    fn multiplexBatchSellEthForToken(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::multiplexBatchSellEthForToken)
+                    }
+                    multiplexBatchSellEthForToken
+                },
+                {
+                    fn fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::fillLimitOrder)
+                    }
+                    fillLimitOrder
+                },
+                {
+                    fn batchCancelRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelRfqOrders)
+                    }
+                    batchCancelRfqOrders
+                },
+                {
+                    fn sellToLiquidityProvider(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::sellToLiquidityProvider)
+                    }
+                    sellToLiquidityProvider
+                },
+                {
+                    fn uniswapV3SwapCallback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::uniswapV3SwapCallback)
+                    }
+                    uniswapV3SwapCallback
+                },
+                {
+                    fn getERC721OrderStatus(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getERC721OrderStatus)
+                    }
+                    getERC721OrderStatus
+                },
+                {
+                    fn buyERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <buyERC721Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::buyERC721)
+                    }
+                    buyERC721
+                },
+                {
+                    fn batchCancelPairRfqOrdersWithSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::batchCancelPairRfqOrdersWithSigner)
+                    }
+                    batchCancelPairRfqOrdersWithSigner
+                },
+                {
+                    fn cancelRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(IZeroexCalls::cancelRfqOrder)
+                    }
+                    cancelRfqOrder
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::_fillLimitOrder(inner) => {
+                    <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::_fillOtcOrder(inner) => {
+                    <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::_fillRfqOrder(inner) => {
+                    <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::_sellHeldTokenForTokenToUniswapV3(inner) => {
+                    <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::_transformERC20(inner) => {
+                    <_transformERC20Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchBuyERC1155s(inner) => {
+                    <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchBuyERC721s(inner) => {
+                    <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelERC1155Orders(inner) => {
+                    <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelERC721Orders(inner) => {
+                    <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelLimitOrders(inner) => {
+                    <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelPairLimitOrders(inner) => {
+                    <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelPairLimitOrdersWithSigner(inner) => {
+                    <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelPairRfqOrders(inner) => {
+                    <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelPairRfqOrdersWithSigner(inner) => {
+                    <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchCancelRfqOrders(inner) => {
+                    <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchExecuteMetaTransactions(inner) => {
+                    <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchFillLimitOrders(inner) => {
+                    <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchFillRfqOrders(inner) => {
+                    <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchFillTakerSignedOtcOrders(inner) => {
+                    <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchGetLimitOrderRelevantStates(inner) => {
+                    <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchGetRfqOrderRelevantStates(inner) => {
+                    <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::batchMatchERC721Orders(inner) => {
+                    <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::buyERC1155(inner) => {
+                    <buyERC1155Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::buyERC721(inner) => {
+                    <buyERC721Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::cancelERC1155Order(inner) => {
+                    <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelERC721Order(inner) => {
+                    <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelLimitOrder(inner) => {
+                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelPairLimitOrders(inner) => {
+                    <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelPairLimitOrdersWithSigner(inner) => {
+                    <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelPairRfqOrders(inner) => {
+                    <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelPairRfqOrdersWithSigner(inner) => {
+                    <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::cancelRfqOrder(inner) => {
+                    <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::createTransformWallet(inner) => {
+                    <createTransformWalletCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::executeMetaTransaction(inner) => {
+                    <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::extend(inner) => {
+                    <extendCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::fillLimitOrder(inner) => {
+                    <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillOrKillLimitOrder(inner) => {
+                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillOrKillRfqOrder(inner) => {
+                    <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillOtcOrder(inner) => {
+                    <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillOtcOrderForEth(inner) => {
+                    <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillOtcOrderWithEth(inner) => {
+                    <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillRfqOrder(inner) => {
+                    <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillTakerSignedOtcOrder(inner) => {
+                    <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::fillTakerSignedOtcOrderForEth(inner) => {
+                    <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getERC1155OrderHash(inner) => {
+                    <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getERC1155OrderInfo(inner) => {
+                    <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getERC721OrderHash(inner) => {
+                    <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getERC721OrderStatus(inner) => {
+                    <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getERC721OrderStatusBitVector(inner) => {
+                    <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getLimitOrderHash(inner) => {
+                    <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getLimitOrderInfo(inner) => {
+                    <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getLimitOrderRelevantState(inner) => {
+                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getMetaTransactionExecutedBlock(inner) => {
+                    <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getMetaTransactionHash(inner) => {
+                    <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getMetaTransactionHashExecutedBlock(inner) => {
+                    <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getOtcOrderHash(inner) => {
+                    <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getOtcOrderInfo(inner) => {
+                    <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getProtocolFeeMultiplier(inner) => {
+                    <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getQuoteSigner(inner) => {
+                    <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getRfqOrderHash(inner) => {
+                    <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getRfqOrderInfo(inner) => {
+                    <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getRfqOrderRelevantState(inner) => {
+                    <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getRollbackEntryAtIndex(inner) => {
+                    <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getRollbackLength(inner) => {
+                    <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTransformWallet(inner) => {
+                    <getTransformWalletCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getTransformerDeployer(inner) => {
+                    <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isValidOrderSigner(inner) => {
+                    <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::lastOtcTxOriginNonce(inner) => {
+                    <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::matchERC721Orders(inner) => {
+                    <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::migrate(inner) => {
+                    <migrateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::multiplexBatchSellEthForToken(inner) => {
+                    <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::multiplexBatchSellTokenForEth(inner) => {
+                    <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::multiplexBatchSellTokenForToken(inner) => {
+                    <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::multiplexMultiHopSellEthForToken(inner) => {
+                    <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::multiplexMultiHopSellTokenForEth(inner) => {
+                    <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::multiplexMultiHopSellTokenForToken(inner) => {
+                    <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::onERC1155Received(inner) => {
+                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::onERC721Received(inner) => {
+                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::preSignERC1155Order(inner) => {
+                    <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::preSignERC721Order(inner) => {
+                    <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::registerAllowedOrderSigner(inner) => {
+                    <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::registerAllowedRfqOrigins(inner) => {
+                    <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::rollback(inner) => {
+                    <rollbackCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::sellERC1155(inner) => {
+                    <sellERC1155Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::sellERC721(inner) => {
+                    <sellERC721Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::sellEthForTokenToUniswapV3(inner) => {
+                    <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::sellToLiquidityProvider(inner) => {
+                    <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::sellToPancakeSwap(inner) => {
+                    <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::sellToUniswap(inner) => {
+                    <sellToUniswapCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::sellTokenForEthToUniswapV3(inner) => {
+                    <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::sellTokenForTokenToUniswapV3(inner) => {
+                    <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setQuoteSigner(inner) => {
+                    <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setTransformerDeployer(inner) => {
+                    <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::supportInterface(inner) => {
+                    <supportInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transferOwnership(inner) => {
+                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transferProtocolFeesForPools(inner) => {
+                    <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transferTrappedTokensTo(inner) => {
+                    <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transformERC20(inner) => {
+                    <transformERC20Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::uniswapV3SwapCallback(inner) => {
+                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateERC1155OrderProperties(inner) => {
+                    <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateERC1155OrderSignature(inner) => {
+                    <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateERC721OrderProperties(inner) => {
+                    <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateERC721OrderSignature(inner) => {
+                    <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::_fillLimitOrder(inner) => {
+                    <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::_fillOtcOrder(inner) => {
+                    <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::_fillRfqOrder(inner) => {
+                    <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::_sellHeldTokenForTokenToUniswapV3(inner) => {
+                    <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::_transformERC20(inner) => {
+                    <_transformERC20Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchBuyERC1155s(inner) => {
+                    <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchBuyERC721s(inner) => {
+                    <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelERC1155Orders(inner) => {
+                    <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelERC721Orders(inner) => {
+                    <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelLimitOrders(inner) => {
+                    <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelPairLimitOrders(inner) => {
+                    <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelPairLimitOrdersWithSigner(inner) => {
+                    <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelPairRfqOrders(inner) => {
+                    <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelPairRfqOrdersWithSigner(inner) => {
+                    <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchCancelRfqOrders(inner) => {
+                    <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchExecuteMetaTransactions(inner) => {
+                    <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchFillLimitOrders(inner) => {
+                    <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchFillRfqOrders(inner) => {
+                    <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchFillTakerSignedOtcOrders(inner) => {
+                    <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchGetLimitOrderRelevantStates(inner) => {
+                    <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchGetRfqOrderRelevantStates(inner) => {
+                    <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::batchMatchERC721Orders(inner) => {
+                    <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::buyERC1155(inner) => {
+                    <buyERC1155Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::buyERC721(inner) => {
+                    <buyERC721Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelERC1155Order(inner) => {
+                    <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelERC721Order(inner) => {
+                    <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelLimitOrder(inner) => {
+                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelPairLimitOrders(inner) => {
+                    <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelPairLimitOrdersWithSigner(inner) => {
+                    <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelPairRfqOrders(inner) => {
+                    <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelPairRfqOrdersWithSigner(inner) => {
+                    <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelRfqOrder(inner) => {
+                    <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::createTransformWallet(inner) => {
+                    <createTransformWalletCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::executeMetaTransaction(inner) => {
+                    <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::extend(inner) => {
+                    <extendCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::fillLimitOrder(inner) => {
+                    <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillOrKillLimitOrder(inner) => {
+                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillOrKillRfqOrder(inner) => {
+                    <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillOtcOrder(inner) => {
+                    <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillOtcOrderForEth(inner) => {
+                    <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillOtcOrderWithEth(inner) => {
+                    <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillRfqOrder(inner) => {
+                    <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillTakerSignedOtcOrder(inner) => {
+                    <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::fillTakerSignedOtcOrderForEth(inner) => {
+                    <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getERC1155OrderHash(inner) => {
+                    <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getERC1155OrderInfo(inner) => {
+                    <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getERC721OrderHash(inner) => {
+                    <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getERC721OrderStatus(inner) => {
+                    <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getERC721OrderStatusBitVector(inner) => {
+                    <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getLimitOrderHash(inner) => {
+                    <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getLimitOrderInfo(inner) => {
+                    <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getLimitOrderRelevantState(inner) => {
+                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getMetaTransactionExecutedBlock(inner) => {
+                    <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getMetaTransactionHash(inner) => {
+                    <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getMetaTransactionHashExecutedBlock(inner) => {
+                    <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getOtcOrderHash(inner) => {
+                    <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getOtcOrderInfo(inner) => {
+                    <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getProtocolFeeMultiplier(inner) => {
+                    <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getQuoteSigner(inner) => {
+                    <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRfqOrderHash(inner) => {
+                    <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRfqOrderInfo(inner) => {
+                    <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRfqOrderRelevantState(inner) => {
+                    <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRollbackEntryAtIndex(inner) => {
+                    <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getRollbackLength(inner) => {
+                    <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getTransformWallet(inner) => {
+                    <getTransformWalletCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getTransformerDeployer(inner) => {
+                    <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isValidOrderSigner(inner) => {
+                    <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::lastOtcTxOriginNonce(inner) => {
+                    <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::matchERC721Orders(inner) => {
+                    <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::migrate(inner) => {
+                    <migrateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::multiplexBatchSellEthForToken(inner) => {
+                    <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::multiplexBatchSellTokenForEth(inner) => {
+                    <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::multiplexBatchSellTokenForToken(inner) => {
+                    <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::multiplexMultiHopSellEthForToken(inner) => {
+                    <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::multiplexMultiHopSellTokenForEth(inner) => {
+                    <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::multiplexMultiHopSellTokenForToken(inner) => {
+                    <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onERC1155Received(inner) => {
+                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::onERC721Received(inner) => {
+                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::preSignERC1155Order(inner) => {
+                    <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::preSignERC721Order(inner) => {
+                    <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::registerAllowedOrderSigner(inner) => {
+                    <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::registerAllowedRfqOrigins(inner) => {
+                    <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::rollback(inner) => {
+                    <rollbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellERC1155(inner) => {
+                    <sellERC1155Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellERC721(inner) => {
+                    <sellERC721Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellEthForTokenToUniswapV3(inner) => {
+                    <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellToLiquidityProvider(inner) => {
+                    <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellToPancakeSwap(inner) => {
+                    <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellToUniswap(inner) => {
+                    <sellToUniswapCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellTokenForEthToUniswapV3(inner) => {
+                    <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::sellTokenForTokenToUniswapV3(inner) => {
+                    <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setQuoteSigner(inner) => {
+                    <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setTransformerDeployer(inner) => {
+                    <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::supportInterface(inner) => {
+                    <supportInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transferOwnership(inner) => {
+                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transferProtocolFeesForPools(inner) => {
+                    <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transferTrappedTokensTo(inner) => {
+                    <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::transformERC20(inner) => {
+                    <transformERC20Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::uniswapV3SwapCallback(inner) => {
+                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateERC1155OrderProperties(inner) => {
+                    <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateERC1155OrderSignature(inner) => {
+                    <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateERC721OrderProperties(inner) => {
+                    <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateERC721OrderSignature(inner) => {
+                    <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`IZeroex`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum IZeroexEvents {
+        #[allow(missing_docs)]
+        ERC1155OrderCancelled(ERC1155OrderCancelled),
+        #[allow(missing_docs)]
+        ERC1155OrderFilled(ERC1155OrderFilled),
+        #[allow(missing_docs)]
+        ERC1155OrderPreSigned(ERC1155OrderPreSigned),
+        #[allow(missing_docs)]
+        ERC721OrderCancelled(ERC721OrderCancelled),
+        #[allow(missing_docs)]
+        ERC721OrderFilled(ERC721OrderFilled),
+        #[allow(missing_docs)]
+        ERC721OrderPreSigned(ERC721OrderPreSigned),
+        #[allow(missing_docs)]
+        LimitOrderFilled(LimitOrderFilled),
+        #[allow(missing_docs)]
+        LiquidityProviderSwap(LiquidityProviderSwap),
+        #[allow(missing_docs)]
+        MetaTransactionExecuted(MetaTransactionExecuted),
+        #[allow(missing_docs)]
+        Migrated(Migrated),
+        #[allow(missing_docs)]
+        OrderCancelled(OrderCancelled),
+        #[allow(missing_docs)]
+        OrderSignerRegistered(OrderSignerRegistered),
+        #[allow(missing_docs)]
+        OtcOrderFilled(OtcOrderFilled),
+        #[allow(missing_docs)]
+        OwnershipTransferred(OwnershipTransferred),
+        #[allow(missing_docs)]
+        PairCancelledLimitOrders(PairCancelledLimitOrders),
+        #[allow(missing_docs)]
+        PairCancelledRfqOrders(PairCancelledRfqOrders),
+        #[allow(missing_docs)]
+        ProxyFunctionUpdated(ProxyFunctionUpdated),
+        #[allow(missing_docs)]
+        QuoteSignerUpdated(QuoteSignerUpdated),
+        #[allow(missing_docs)]
+        RfqOrderFilled(RfqOrderFilled),
+        #[allow(missing_docs)]
+        RfqOrderOriginsAllowed(RfqOrderOriginsAllowed),
+        #[allow(missing_docs)]
+        TransformedERC20(TransformedERC20),
+        #[allow(missing_docs)]
+        TransformerDeployerUpdated(TransformerDeployerUpdated),
+    }
+    impl IZeroexEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                2u8, 223u8, 234u8, 213u8, 235u8, 118u8, 155u8, 41u8, 142u8, 130u8, 221u8, 150u8,
+                80u8, 179u8, 28u8, 64u8, 85u8, 154u8, 61u8, 66u8, 112u8, 29u8, 191u8, 83u8, 201u8,
+                49u8, 188u8, 38u8, 130u8, 132u8, 124u8, 49u8,
+            ],
+            [
+                15u8, 102u8, 114u8, 247u8, 138u8, 89u8, 186u8, 142u8, 94u8, 91u8, 93u8, 56u8,
+                223u8, 62u8, 188u8, 103u8, 243u8, 199u8, 146u8, 226u8, 201u8, 37u8, 155u8, 141u8,
+                151u8, 215u8, 240u8, 13u8, 215u8, 139u8, 161u8, 179u8,
+            ],
+            [
+                32u8, 204u8, 168u8, 27u8, 14u8, 38u8, 155u8, 38u8, 91u8, 50u8, 41u8, 214u8, 181u8,
+                55u8, 218u8, 145u8, 239u8, 71u8, 92u8, 160u8, 239u8, 85u8, 202u8, 237u8, 125u8,
+                211u8, 7u8, 49u8, 112u8, 11u8, 169u8, 141u8,
+            ],
+            [
+                42u8, 226u8, 33u8, 8u8, 52u8, 103u8, 222u8, 82u8, 7u8, 139u8, 0u8, 150u8, 105u8,
+                106u8, 184u8, 141u8, 141u8, 83u8, 167u8, 236u8, 180u8, 75u8, 182u8, 91u8, 86u8,
+                162u8, 186u8, 182u8, 135u8, 89u8, 131u8, 103u8,
+            ],
+            [
+                64u8, 166u8, 186u8, 149u8, 19u8, 208u8, 158u8, 52u8, 136u8, 19u8, 94u8, 14u8, 13u8,
+                16u8, 226u8, 212u8, 56u8, 43u8, 121u8, 39u8, 32u8, 21u8, 91u8, 20u8, 76u8, 190u8,
+                168u8, 154u8, 201u8, 219u8, 109u8, 52u8,
+            ],
+            [
+                77u8, 94u8, 167u8, 218u8, 100u8, 245u8, 10u8, 74u8, 50u8, 153u8, 33u8, 184u8,
+                210u8, 202u8, 181u8, 45u8, 255u8, 78u8, 188u8, 197u8, 139u8, 97u8, 209u8, 15u8,
+                248u8, 57u8, 226u8, 142u8, 145u8, 68u8, 86u8, 132u8,
+            ],
+            [
+                80u8, 39u8, 63u8, 160u8, 34u8, 115u8, 204u8, 238u8, 169u8, 207u8, 8u8, 91u8, 66u8,
+                222u8, 92u8, 138u8, 246u8, 6u8, 36u8, 20u8, 1u8, 104u8, 189u8, 113u8, 53u8, 125u8,
+                184u8, 51u8, 83u8, 88u8, 119u8, 175u8,
+            ],
+            [
+                94u8, 145u8, 221u8, 254u8, 183u8, 191u8, 46u8, 18u8, 247u8, 232u8, 171u8, 1u8,
+                125u8, 43u8, 99u8, 169u8, 33u8, 127u8, 0u8, 74u8, 21u8, 165u8, 51u8, 70u8, 173u8,
+                144u8, 53u8, 62u8, 198u8, 61u8, 20u8, 228u8,
+            ],
+            [
+                110u8, 169u8, 219u8, 232u8, 178u8, 204u8, 17u8, 147u8, 72u8, 113u8, 106u8, 146u8,
+                32u8, 160u8, 116u8, 42u8, 214u8, 43u8, 120u8, 132u8, 236u8, 176u8, 255u8, 75u8,
+                50u8, 205u8, 80u8, 129u8, 33u8, 253u8, 147u8, 121u8,
+            ],
+            [
+                127u8, 79u8, 227u8, 255u8, 138u8, 228u8, 64u8, 225u8, 87u8, 12u8, 85u8, 141u8,
+                160u8, 132u8, 64u8, 178u8, 111u8, 137u8, 251u8, 28u8, 31u8, 41u8, 16u8, 205u8,
+                145u8, 202u8, 100u8, 82u8, 149u8, 95u8, 18u8, 26u8,
+            ],
+            [
+                130u8, 159u8, 169u8, 157u8, 148u8, 220u8, 70u8, 54u8, 146u8, 91u8, 56u8, 99u8,
+                46u8, 98u8, 87u8, 54u8, 166u8, 20u8, 193u8, 84u8, 213u8, 80u8, 6u8, 183u8, 171u8,
+                107u8, 234u8, 151u8, 156u8, 33u8, 12u8, 50u8,
+            ],
+            [
+                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
+                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
+                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
+            ],
+            [
+                140u8, 93u8, 12u8, 65u8, 251u8, 22u8, 167u8, 49u8, 122u8, 108u8, 85u8, 255u8,
+                123u8, 169u8, 61u8, 157u8, 116u8, 247u8, 158u8, 67u8, 79u8, 239u8, 166u8, 148u8,
+                229u8, 13u8, 96u8, 40u8, 175u8, 191u8, 163u8, 240u8,
+            ],
+            [
+                160u8, 21u8, 173u8, 45u8, 195u8, 47u8, 38u8, 105u8, 147u8, 149u8, 138u8, 15u8,
+                217u8, 136u8, 76u8, 116u8, 107u8, 151u8, 27u8, 37u8, 66u8, 6u8, 243u8, 71u8, 139u8,
+                196u8, 62u8, 47u8, 18u8, 92u8, 123u8, 158u8,
+            ],
+            [
+                166u8, 235u8, 124u8, 220u8, 33u8, 158u8, 21u8, 24u8, 206u8, 217u8, 100u8, 233u8,
+                163u8, 78u8, 97u8, 214u8, 138u8, 148u8, 228u8, 241u8, 86u8, 157u8, 179u8, 232u8,
+                66u8, 86u8, 186u8, 152u8, 27u8, 165u8, 39u8, 83u8,
+            ],
+            [
+                169u8, 31u8, 231u8, 174u8, 98u8, 252u8, 230u8, 105u8, 223u8, 44u8, 127u8, 136u8,
+                15u8, 140u8, 20u8, 209u8, 120u8, 83u8, 26u8, 174u8, 114u8, 81u8, 85u8, 88u8, 229u8,
+                201u8, 72u8, 227u8, 124u8, 50u8, 165u8, 114u8,
+            ],
+            [
+                171u8, 97u8, 77u8, 43u8, 115u8, 133u8, 67u8, 192u8, 234u8, 33u8, 245u8, 99u8, 71u8,
+                207u8, 105u8, 106u8, 58u8, 12u8, 66u8, 167u8, 203u8, 236u8, 50u8, 18u8, 165u8,
+                202u8, 34u8, 164u8, 220u8, 255u8, 33u8, 36u8,
+            ],
+            [
+                172u8, 117u8, 247u8, 115u8, 227u8, 169u8, 47u8, 26u8, 2u8, 177u8, 33u8, 52u8,
+                214u8, 94u8, 31u8, 71u8, 248u8, 161u8, 78u8, 171u8, 228u8, 234u8, 241u8, 226u8,
+                70u8, 36u8, 145u8, 142u8, 106u8, 139u8, 38u8, 159u8,
+            ],
+            [
+                225u8, 184u8, 49u8, 176u8, 230u8, 243u8, 170u8, 22u8, 180u8, 177u8, 166u8, 189u8,
+                82u8, 107u8, 92u8, 222u8, 171u8, 73u8, 64u8, 116u8, 76u8, 166u8, 224u8, 37u8, 31u8,
+                95u8, 229u8, 248u8, 202u8, 241u8, 200u8, 26u8,
+            ],
+            [
+                245u8, 85u8, 12u8, 94u8, 234u8, 25u8, 180u8, 138u8, 198u8, 235u8, 95u8, 3u8, 171u8,
+                220u8, 79u8, 89u8, 192u8, 166u8, 6u8, 151u8, 171u8, 179u8, 217u8, 115u8, 205u8,
+                104u8, 102u8, 151u8, 3u8, 181u8, 200u8, 185u8,
+            ],
+            [
+                253u8, 69u8, 96u8, 74u8, 186u8, 215u8, 156u8, 22u8, 226u8, 51u8, 72u8, 161u8, 55u8,
+                237u8, 130u8, 146u8, 102u8, 27u8, 225u8, 184u8, 235u8, 166u8, 228u8, 128u8, 110u8,
+                190u8, 214u8, 131u8, 59u8, 28u8, 4u8, 106u8,
+            ],
+            [
+                254u8, 127u8, 251u8, 30u8, 223u8, 231u8, 159u8, 77u8, 247u8, 22u8, 203u8, 45u8,
+                202u8, 210u8, 28u8, 242u8, 243u8, 27u8, 16u8, 77u8, 129u8, 106u8, 121u8, 118u8,
+                186u8, 30u8, 110u8, 70u8, 83u8, 193u8, 239u8, 177u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TransformedERC20 as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC1155OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ProxyFunctionUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <LiquidityProviderSwap as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC1155OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC721OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderSignerRegistered as alloy_sol_types::SolEvent>::SIGNATURE,
+            <MetaTransactionExecuted as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RfqOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC721OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC721OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PairCancelledLimitOrders as alloy_sol_types::SolEvent>::SIGNATURE,
+            <LimitOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OtcOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Migrated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <QuoteSignerUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TransformerDeployerUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PairCancelledRfqOrders as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(RfqOrderOriginsAllowed),
+            ::core::stringify!(TransformedERC20),
+            ::core::stringify!(ERC1155OrderFilled),
+            ::core::stringify!(ProxyFunctionUpdated),
+            ::core::stringify!(LiquidityProviderSwap),
+            ::core::stringify!(ERC1155OrderCancelled),
+            ::core::stringify!(ERC721OrderFilled),
+            ::core::stringify!(ERC1155OrderPreSigned),
+            ::core::stringify!(OrderSignerRegistered),
+            ::core::stringify!(MetaTransactionExecuted),
+            ::core::stringify!(RfqOrderFilled),
+            ::core::stringify!(OwnershipTransferred),
+            ::core::stringify!(ERC721OrderPreSigned),
+            ::core::stringify!(ERC721OrderCancelled),
+            ::core::stringify!(OrderCancelled),
+            ::core::stringify!(PairCancelledLimitOrders),
+            ::core::stringify!(LimitOrderFilled),
+            ::core::stringify!(OtcOrderFilled),
+            ::core::stringify!(Migrated),
+            ::core::stringify!(QuoteSignerUpdated),
+            ::core::stringify!(TransformerDeployerUpdated),
+            ::core::stringify!(PairCancelledRfqOrders),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for IZeroexEvents {
+        const COUNT: usize = 22usize;
+        const NAME: &'static str = "IZeroexEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<ERC1155OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC1155OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC1155OrderCancelled)
+                }
+                Some(<ERC1155OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC1155OrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ERC1155OrderFilled)
+                }
+                Some(<ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC1155OrderPreSigned)
+                }
+                Some(<ERC721OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC721OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC721OrderCancelled)
+                }
+                Some(<ERC721OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC721OrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ERC721OrderFilled)
+                }
+                Some(<ERC721OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC721OrderPreSigned as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC721OrderPreSigned)
+                }
+                Some(<LimitOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <LimitOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::LimitOrderFilled)
+                }
+                Some(<LiquidityProviderSwap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <LiquidityProviderSwap as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::LiquidityProviderSwap)
+                }
+                Some(<MetaTransactionExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <MetaTransactionExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::MetaTransactionExecuted)
+                }
+                Some(<Migrated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Migrated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Migrated)
+                }
+                Some(<OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderCancelled)
+                }
+                Some(<OrderSignerRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderSignerRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::OrderSignerRegistered)
+                }
+                Some(<OtcOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OtcOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OtcOrderFilled)
+                }
+                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::OwnershipTransferred)
+                }
+                Some(<PairCancelledLimitOrders as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PairCancelledLimitOrders as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::PairCancelledLimitOrders)
+                }
+                Some(<PairCancelledRfqOrders as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PairCancelledRfqOrders as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::PairCancelledRfqOrders)
+                }
+                Some(<ProxyFunctionUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ProxyFunctionUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ProxyFunctionUpdated)
+                }
+                Some(<QuoteSignerUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <QuoteSignerUpdated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::QuoteSignerUpdated)
+                }
+                Some(<RfqOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RfqOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::RfqOrderFilled)
+                }
+                Some(<RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::RfqOrderOriginsAllowed)
+                }
+                Some(<TransformedERC20 as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TransformedERC20 as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TransformedERC20)
+                }
+                Some(<TransformerDeployerUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TransformerDeployerUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::TransformerDeployerUpdated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for IZeroexEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ERC1155OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC1155OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC1155OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC721OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC721OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC721OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::LimitOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::LiquidityProviderSwap(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::MetaTransactionExecuted(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Migrated(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OrderSignerRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OtcOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OwnershipTransferred(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PairCancelledLimitOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PairCancelledRfqOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ProxyFunctionUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::QuoteSignerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RfqOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RfqOrderOriginsAllowed(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TransformedERC20(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TransformerDeployerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ERC1155OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC1155OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC1155OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC721OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC721OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC721OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::LimitOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::LiquidityProviderSwap(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::MetaTransactionExecuted(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Migrated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderSignerRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OtcOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OwnershipTransferred(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PairCancelledLimitOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PairCancelledRfqOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ProxyFunctionUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::QuoteSignerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RfqOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RfqOrderOriginsAllowed(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TransformedERC20(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TransformerDeployerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IZeroex`](self) contract instance.
+
+    See the [wrapper's documentation](`IZeroexInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IZeroexInstance<P, N> {
+        IZeroexInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IZeroex`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IZeroex`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IZeroexInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IZeroexInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IZeroexInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IZeroexInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IZeroex`](self) contract instance.
+
+        See the [wrapper's documentation](`IZeroexInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IZeroexInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IZeroexInstance<P, N> {
+            IZeroexInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IZeroexInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`_fillLimitOrder`] function.
+        pub fn _fillLimitOrder(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+            taker: alloy_sol_types::private::Address,
+            sender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, _fillLimitOrderCall, N> {
+            self.call_builder(&_fillLimitOrderCall {
+                order,
+                signature,
+                takerTokenFillAmount,
+                taker,
+                sender,
+            })
+        }
+
+        ///Creates a new call builder for the [`_fillOtcOrder`] function.
+        pub fn _fillOtcOrder(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+            taker: alloy_sol_types::private::Address,
+            useSelfBalance: bool,
+            recipient: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, _fillOtcOrderCall, N> {
+            self.call_builder(&_fillOtcOrderCall {
+                order,
+                makerSignature,
+                takerTokenFillAmount,
+                taker,
+                useSelfBalance,
+                recipient,
+            })
+        }
+
+        ///Creates a new call builder for the [`_fillRfqOrder`] function.
+        pub fn _fillRfqOrder(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+            taker: alloy_sol_types::private::Address,
+            useSelfBalance: bool,
+            recipient: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, _fillRfqOrderCall, N> {
+            self.call_builder(&_fillRfqOrderCall {
+                order,
+                signature,
+                takerTokenFillAmount,
+                taker,
+                useSelfBalance,
+                recipient,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`_sellHeldTokenForTokenToUniswapV3`] function.
+        pub fn _sellHeldTokenForTokenToUniswapV3(
+            &self,
+            encodedPath: alloy_sol_types::private::Bytes,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            recipient: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, _sellHeldTokenForTokenToUniswapV3Call, N> {
+            self.call_builder(&_sellHeldTokenForTokenToUniswapV3Call {
+                encodedPath,
+                sellAmount,
+                minBuyAmount,
+                recipient,
+            })
+        }
+
+        ///Creates a new call builder for the [`_transformERC20`] function.
+        pub fn _transformERC20(
+            &self,
+            args: <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, _transformERC20Call, N> {
+            self.call_builder(&_transformERC20Call { args })
+        }
+
+        ///Creates a new call builder for the [`batchBuyERC1155s`] function.
+        pub fn batchBuyERC1155s(
+            &self,
+            sellOrders: alloy_sol_types::private::Vec<
+                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            erc1155TokenAmounts: alloy_sol_types::private::Vec<u128>,
+            callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+            revertIfIncomplete: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, batchBuyERC1155sCall, N> {
+            self.call_builder(&batchBuyERC1155sCall {
+                sellOrders,
+                signatures,
+                erc1155TokenAmounts,
+                callbackData,
+                revertIfIncomplete,
+            })
+        }
+
+        ///Creates a new call builder for the [`batchBuyERC721s`] function.
+        pub fn batchBuyERC721s(
+            &self,
+            sellOrders: alloy_sol_types::private::Vec<
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+            revertIfIncomplete: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, batchBuyERC721sCall, N> {
+            self.call_builder(&batchBuyERC721sCall {
+                sellOrders,
+                signatures,
+                callbackData,
+                revertIfIncomplete,
+            })
+        }
+
+        ///Creates a new call builder for the [`batchCancelERC1155Orders`]
+        /// function.
+        pub fn batchCancelERC1155Orders(
+            &self,
+            orderNonces: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelERC1155OrdersCall, N> {
+            self.call_builder(&batchCancelERC1155OrdersCall { orderNonces })
+        }
+
+        ///Creates a new call builder for the [`batchCancelERC721Orders`]
+        /// function.
+        pub fn batchCancelERC721Orders(
+            &self,
+            orderNonces: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelERC721OrdersCall, N> {
+            self.call_builder(&batchCancelERC721OrdersCall { orderNonces })
+        }
+
+        ///Creates a new call builder for the [`batchCancelLimitOrders`]
+        /// function.
+        pub fn batchCancelLimitOrders(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelLimitOrdersCall, N> {
+            self.call_builder(&batchCancelLimitOrdersCall { orders })
+        }
+
+        ///Creates a new call builder for the [`batchCancelPairLimitOrders`]
+        /// function.
+        pub fn batchCancelPairLimitOrders(
+            &self,
+            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            minValidSalts: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairLimitOrdersCall, N> {
+            self.call_builder(&batchCancelPairLimitOrdersCall {
+                makerTokens,
+                takerTokens,
+                minValidSalts,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`batchCancelPairLimitOrdersWithSigner`] function.
+        pub fn batchCancelPairLimitOrdersWithSigner(
+            &self,
+            maker: alloy_sol_types::private::Address,
+            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            minValidSalts: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairLimitOrdersWithSignerCall, N>
+        {
+            self.call_builder(&batchCancelPairLimitOrdersWithSignerCall {
+                maker,
+                makerTokens,
+                takerTokens,
+                minValidSalts,
+            })
+        }
+
+        ///Creates a new call builder for the [`batchCancelPairRfqOrders`]
+        /// function.
+        pub fn batchCancelPairRfqOrders(
+            &self,
+            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            minValidSalts: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairRfqOrdersCall, N> {
+            self.call_builder(&batchCancelPairRfqOrdersCall {
+                makerTokens,
+                takerTokens,
+                minValidSalts,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`batchCancelPairRfqOrdersWithSigner`] function.
+        pub fn batchCancelPairRfqOrdersWithSigner(
+            &self,
+            maker: alloy_sol_types::private::Address,
+            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            minValidSalts: alloy_sol_types::private::Vec<
+                alloy_sol_types::private::primitives::aliases::U256,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairRfqOrdersWithSignerCall, N> {
+            self.call_builder(&batchCancelPairRfqOrdersWithSignerCall {
+                maker,
+                makerTokens,
+                takerTokens,
+                minValidSalts,
+            })
+        }
+
+        ///Creates a new call builder for the [`batchCancelRfqOrders`]
+        /// function.
+        pub fn batchCancelRfqOrders(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchCancelRfqOrdersCall, N> {
+            self.call_builder(&batchCancelRfqOrdersCall { orders })
+        }
+
+        ///Creates a new call builder for the [`batchExecuteMetaTransactions`]
+        /// function.
+        pub fn batchExecuteMetaTransactions(
+            &self,
+            mtxs: alloy_sol_types::private::Vec<
+                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchExecuteMetaTransactionsCall, N> {
+            self.call_builder(&batchExecuteMetaTransactionsCall { mtxs, signatures })
+        }
+
+        ///Creates a new call builder for the [`batchFillLimitOrders`]
+        /// function.
+        pub fn batchFillLimitOrders(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
+            revertIfIncomplete: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, batchFillLimitOrdersCall, N> {
+            self.call_builder(&batchFillLimitOrdersCall {
+                orders,
+                signatures,
+                takerTokenFillAmounts,
+                revertIfIncomplete,
+            })
+        }
+
+        ///Creates a new call builder for the [`batchFillRfqOrders`] function.
+        pub fn batchFillRfqOrders(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
+            revertIfIncomplete: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, batchFillRfqOrdersCall, N> {
+            self.call_builder(&batchFillRfqOrdersCall {
+                orders,
+                signatures,
+                takerTokenFillAmounts,
+                revertIfIncomplete,
+            })
+        }
+
+        ///Creates a new call builder for the [`batchFillTakerSignedOtcOrders`]
+        /// function.
+        pub fn batchFillTakerSignedOtcOrders(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            >,
+            makerSignatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            takerSignatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            unwrapWeth: alloy_sol_types::private::Vec<bool>,
+        ) -> alloy_contract::SolCallBuilder<&P, batchFillTakerSignedOtcOrdersCall, N> {
+            self.call_builder(&batchFillTakerSignedOtcOrdersCall {
+                orders,
+                makerSignatures,
+                takerSignatures,
+                unwrapWeth,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`batchGetLimitOrderRelevantStates`] function.
+        pub fn batchGetLimitOrderRelevantStates(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchGetLimitOrderRelevantStatesCall, N> {
+            self.call_builder(&batchGetLimitOrderRelevantStatesCall { orders, signatures })
+        }
+
+        ///Creates a new call builder for the
+        /// [`batchGetRfqOrderRelevantStates`] function.
+        pub fn batchGetRfqOrderRelevantStates(
+            &self,
+            orders: alloy_sol_types::private::Vec<
+                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            >,
+            signatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchGetRfqOrderRelevantStatesCall, N> {
+            self.call_builder(&batchGetRfqOrderRelevantStatesCall { orders, signatures })
+        }
+
+        ///Creates a new call builder for the [`batchMatchERC721Orders`]
+        /// function.
+        pub fn batchMatchERC721Orders(
+            &self,
+            sellOrders: alloy_sol_types::private::Vec<
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            >,
+            buyOrders: alloy_sol_types::private::Vec<
+                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            >,
+            sellOrderSignatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+            buyOrderSignatures: alloy_sol_types::private::Vec<
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, batchMatchERC721OrdersCall, N> {
+            self.call_builder(&batchMatchERC721OrdersCall {
+                sellOrders,
+                buyOrders,
+                sellOrderSignatures,
+                buyOrderSignatures,
+            })
+        }
+
+        ///Creates a new call builder for the [`buyERC1155`] function.
+        pub fn buyERC1155(
+            &self,
+            sellOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            erc1155BuyAmount: u128,
+            callbackData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, buyERC1155Call, N> {
+            self.call_builder(&buyERC1155Call {
+                sellOrder,
+                signature,
+                erc1155BuyAmount,
+                callbackData,
+            })
+        }
+
+        ///Creates a new call builder for the [`buyERC721`] function.
+        pub fn buyERC721(
+            &self,
+            sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            callbackData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, buyERC721Call, N> {
+            self.call_builder(&buyERC721Call {
+                sellOrder,
+                signature,
+                callbackData,
+            })
+        }
+
+        ///Creates a new call builder for the [`cancelERC1155Order`] function.
+        pub fn cancelERC1155Order(
+            &self,
+            orderNonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelERC1155OrderCall, N> {
+            self.call_builder(&cancelERC1155OrderCall { orderNonce })
+        }
+
+        ///Creates a new call builder for the [`cancelERC721Order`] function.
+        pub fn cancelERC721Order(
+            &self,
+            orderNonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelERC721OrderCall, N> {
+            self.call_builder(&cancelERC721OrderCall { orderNonce })
+        }
+
+        ///Creates a new call builder for the [`cancelLimitOrder`] function.
+        pub fn cancelLimitOrder(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelLimitOrderCall, N> {
+            self.call_builder(&cancelLimitOrderCall { order })
+        }
+
+        ///Creates a new call builder for the [`cancelPairLimitOrders`]
+        /// function.
+        pub fn cancelPairLimitOrders(
+            &self,
+            makerToken: alloy_sol_types::private::Address,
+            takerToken: alloy_sol_types::private::Address,
+            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelPairLimitOrdersCall, N> {
+            self.call_builder(&cancelPairLimitOrdersCall {
+                makerToken,
+                takerToken,
+                minValidSalt,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`cancelPairLimitOrdersWithSigner`] function.
+        pub fn cancelPairLimitOrdersWithSigner(
+            &self,
+            maker: alloy_sol_types::private::Address,
+            makerToken: alloy_sol_types::private::Address,
+            takerToken: alloy_sol_types::private::Address,
+            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelPairLimitOrdersWithSignerCall, N> {
+            self.call_builder(&cancelPairLimitOrdersWithSignerCall {
+                maker,
+                makerToken,
+                takerToken,
+                minValidSalt,
+            })
+        }
+
+        ///Creates a new call builder for the [`cancelPairRfqOrders`] function.
+        pub fn cancelPairRfqOrders(
+            &self,
+            makerToken: alloy_sol_types::private::Address,
+            takerToken: alloy_sol_types::private::Address,
+            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelPairRfqOrdersCall, N> {
+            self.call_builder(&cancelPairRfqOrdersCall {
+                makerToken,
+                takerToken,
+                minValidSalt,
+            })
+        }
+
+        ///Creates a new call builder for the [`cancelPairRfqOrdersWithSigner`]
+        /// function.
+        pub fn cancelPairRfqOrdersWithSigner(
+            &self,
+            maker: alloy_sol_types::private::Address,
+            makerToken: alloy_sol_types::private::Address,
+            takerToken: alloy_sol_types::private::Address,
+            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelPairRfqOrdersWithSignerCall, N> {
+            self.call_builder(&cancelPairRfqOrdersWithSignerCall {
+                maker,
+                makerToken,
+                takerToken,
+                minValidSalt,
+            })
+        }
+
+        ///Creates a new call builder for the [`cancelRfqOrder`] function.
+        pub fn cancelRfqOrder(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelRfqOrderCall, N> {
+            self.call_builder(&cancelRfqOrderCall { order })
+        }
+
+        ///Creates a new call builder for the [`createTransformWallet`]
+        /// function.
+        pub fn createTransformWallet(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, createTransformWalletCall, N> {
+            self.call_builder(&createTransformWalletCall)
+        }
+
+        ///Creates a new call builder for the [`executeMetaTransaction`]
+        /// function.
+        pub fn executeMetaTransaction(
+            &self,
+            mtx: <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, executeMetaTransactionCall, N> {
+            self.call_builder(&executeMetaTransactionCall { mtx, signature })
+        }
+
+        ///Creates a new call builder for the [`extend`] function.
+        pub fn extend(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+            r#impl: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, extendCall, N> {
+            self.call_builder(&extendCall { selector, r#impl })
+        }
+
+        ///Creates a new call builder for the [`fillLimitOrder`] function.
+        pub fn fillLimitOrder(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillLimitOrderCall, N> {
+            self.call_builder(&fillLimitOrderCall {
+                order,
+                signature,
+                takerTokenFillAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillOrKillLimitOrder`]
+        /// function.
+        pub fn fillOrKillLimitOrder(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillOrKillLimitOrderCall, N> {
+            self.call_builder(&fillOrKillLimitOrderCall {
+                order,
+                signature,
+                takerTokenFillAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillOrKillRfqOrder`] function.
+        pub fn fillOrKillRfqOrder(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillOrKillRfqOrderCall, N> {
+            self.call_builder(&fillOrKillRfqOrderCall {
+                order,
+                signature,
+                takerTokenFillAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillOtcOrder`] function.
+        pub fn fillOtcOrder(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillOtcOrderCall, N> {
+            self.call_builder(&fillOtcOrderCall {
+                order,
+                makerSignature,
+                takerTokenFillAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillOtcOrderForEth`] function.
+        pub fn fillOtcOrderForEth(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillOtcOrderForEthCall, N> {
+            self.call_builder(&fillOtcOrderForEthCall {
+                order,
+                makerSignature,
+                takerTokenFillAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillOtcOrderWithEth`] function.
+        pub fn fillOtcOrderWithEth(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, fillOtcOrderWithEthCall, N> {
+            self.call_builder(&fillOtcOrderWithEthCall {
+                order,
+                makerSignature,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillRfqOrder`] function.
+        pub fn fillRfqOrder(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillRfqOrderCall, N> {
+            self.call_builder(&fillRfqOrderCall {
+                order,
+                signature,
+                takerTokenFillAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillTakerSignedOtcOrder`]
+        /// function.
+        pub fn fillTakerSignedOtcOrder(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, fillTakerSignedOtcOrderCall, N> {
+            self.call_builder(&fillTakerSignedOtcOrderCall {
+                order,
+                makerSignature,
+                takerSignature,
+            })
+        }
+
+        ///Creates a new call builder for the [`fillTakerSignedOtcOrderForEth`]
+        /// function.
+        pub fn fillTakerSignedOtcOrderForEth(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, fillTakerSignedOtcOrderForEthCall, N> {
+            self.call_builder(&fillTakerSignedOtcOrderForEthCall {
+                order,
+                makerSignature,
+                takerSignature,
+            })
+        }
+
+        ///Creates a new call builder for the [`getERC1155OrderHash`] function.
+        pub fn getERC1155OrderHash(
+            &self,
+            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getERC1155OrderHashCall, N> {
+            self.call_builder(&getERC1155OrderHashCall { order })
+        }
+
+        ///Creates a new call builder for the [`getERC1155OrderInfo`] function.
+        pub fn getERC1155OrderInfo(
+            &self,
+            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getERC1155OrderInfoCall, N> {
+            self.call_builder(&getERC1155OrderInfoCall { order })
+        }
+
+        ///Creates a new call builder for the [`getERC721OrderHash`] function.
+        pub fn getERC721OrderHash(
+            &self,
+            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getERC721OrderHashCall, N> {
+            self.call_builder(&getERC721OrderHashCall { order })
+        }
+
+        ///Creates a new call builder for the [`getERC721OrderStatus`]
+        /// function.
+        pub fn getERC721OrderStatus(
+            &self,
+            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getERC721OrderStatusCall, N> {
+            self.call_builder(&getERC721OrderStatusCall { order })
+        }
+
+        ///Creates a new call builder for the [`getERC721OrderStatusBitVector`]
+        /// function.
+        pub fn getERC721OrderStatusBitVector(
+            &self,
+            maker: alloy_sol_types::private::Address,
+            nonceRange: alloy_sol_types::private::primitives::aliases::U248,
+        ) -> alloy_contract::SolCallBuilder<&P, getERC721OrderStatusBitVectorCall, N> {
+            self.call_builder(&getERC721OrderStatusBitVectorCall { maker, nonceRange })
+        }
+
+        ///Creates a new call builder for the [`getLimitOrderHash`] function.
+        pub fn getLimitOrderHash(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderHashCall, N> {
+            self.call_builder(&getLimitOrderHashCall { order })
+        }
+
+        ///Creates a new call builder for the [`getLimitOrderInfo`] function.
+        pub fn getLimitOrderInfo(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderInfoCall, N> {
+            self.call_builder(&getLimitOrderInfoCall { order })
+        }
+
+        ///Creates a new call builder for the [`getLimitOrderRelevantState`]
+        /// function.
+        pub fn getLimitOrderRelevantState(
+            &self,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderRelevantStateCall, N> {
+            self.call_builder(&getLimitOrderRelevantStateCall { order, signature })
+        }
+
+        ///Creates a new call builder for the
+        /// [`getMetaTransactionExecutedBlock`] function.
+        pub fn getMetaTransactionExecutedBlock(
+            &self,
+            mtx: <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getMetaTransactionExecutedBlockCall, N> {
+            self.call_builder(&getMetaTransactionExecutedBlockCall { mtx })
+        }
+
+        ///Creates a new call builder for the [`getMetaTransactionHash`]
+        /// function.
+        pub fn getMetaTransactionHash(
+            &self,
+            mtx: <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getMetaTransactionHashCall, N> {
+            self.call_builder(&getMetaTransactionHashCall { mtx })
+        }
+
+        ///Creates a new call builder for the
+        /// [`getMetaTransactionHashExecutedBlock`] function.
+        pub fn getMetaTransactionHashExecutedBlock(
+            &self,
+            mtxHash: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, getMetaTransactionHashExecutedBlockCall, N>
+        {
+            self.call_builder(&getMetaTransactionHashExecutedBlockCall { mtxHash })
+        }
+
+        ///Creates a new call builder for the [`getOtcOrderHash`] function.
+        pub fn getOtcOrderHash(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getOtcOrderHashCall, N> {
+            self.call_builder(&getOtcOrderHashCall { order })
+        }
+
+        ///Creates a new call builder for the [`getOtcOrderInfo`] function.
+        pub fn getOtcOrderInfo(
+            &self,
+            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getOtcOrderInfoCall, N> {
+            self.call_builder(&getOtcOrderInfoCall { order })
+        }
+
+        ///Creates a new call builder for the [`getProtocolFeeMultiplier`]
+        /// function.
+        pub fn getProtocolFeeMultiplier(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeeMultiplierCall, N> {
+            self.call_builder(&getProtocolFeeMultiplierCall)
+        }
+
+        ///Creates a new call builder for the [`getQuoteSigner`] function.
+        pub fn getQuoteSigner(&self) -> alloy_contract::SolCallBuilder<&P, getQuoteSignerCall, N> {
+            self.call_builder(&getQuoteSignerCall)
+        }
+
+        ///Creates a new call builder for the [`getRfqOrderHash`] function.
+        pub fn getRfqOrderHash(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getRfqOrderHashCall, N> {
+            self.call_builder(&getRfqOrderHashCall { order })
+        }
+
+        ///Creates a new call builder for the [`getRfqOrderInfo`] function.
+        pub fn getRfqOrderInfo(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getRfqOrderInfoCall, N> {
+            self.call_builder(&getRfqOrderInfoCall { order })
+        }
+
+        ///Creates a new call builder for the [`getRfqOrderRelevantState`]
+        /// function.
+        pub fn getRfqOrderRelevantState(
+            &self,
+            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, getRfqOrderRelevantStateCall, N> {
+            self.call_builder(&getRfqOrderRelevantStateCall { order, signature })
+        }
+
+        ///Creates a new call builder for the [`getRollbackEntryAtIndex`]
+        /// function.
+        pub fn getRollbackEntryAtIndex(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+            idx: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getRollbackEntryAtIndexCall, N> {
+            self.call_builder(&getRollbackEntryAtIndexCall { selector, idx })
+        }
+
+        ///Creates a new call builder for the [`getRollbackLength`] function.
+        pub fn getRollbackLength(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, getRollbackLengthCall, N> {
+            self.call_builder(&getRollbackLengthCall { selector })
+        }
+
+        ///Creates a new call builder for the [`getTransformWallet`] function.
+        pub fn getTransformWallet(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getTransformWalletCall, N> {
+            self.call_builder(&getTransformWalletCall)
+        }
+
+        ///Creates a new call builder for the [`getTransformerDeployer`]
+        /// function.
+        pub fn getTransformerDeployer(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, getTransformerDeployerCall, N> {
+            self.call_builder(&getTransformerDeployerCall)
+        }
+
+        ///Creates a new call builder for the [`isValidOrderSigner`] function.
+        pub fn isValidOrderSigner(
+            &self,
+            maker: alloy_sol_types::private::Address,
+            signer: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidOrderSignerCall, N> {
+            self.call_builder(&isValidOrderSignerCall { maker, signer })
+        }
+
+        ///Creates a new call builder for the [`lastOtcTxOriginNonce`]
+        /// function.
+        pub fn lastOtcTxOriginNonce(
+            &self,
+            txOrigin: alloy_sol_types::private::Address,
+            nonceBucket: u64,
+        ) -> alloy_contract::SolCallBuilder<&P, lastOtcTxOriginNonceCall, N> {
+            self.call_builder(&lastOtcTxOriginNonceCall {
+                txOrigin,
+                nonceBucket,
+            })
+        }
+
+        ///Creates a new call builder for the [`matchERC721Orders`] function.
+        pub fn matchERC721Orders(
+            &self,
+            sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            sellOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            buyOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, matchERC721OrdersCall, N> {
+            self.call_builder(&matchERC721OrdersCall {
+                sellOrder,
+                buyOrder,
+                sellOrderSignature,
+                buyOrderSignature,
+            })
+        }
+
+        ///Creates a new call builder for the [`migrate`] function.
+        pub fn migrate(
+            &self,
+            target: alloy_sol_types::private::Address,
+            data: alloy_sol_types::private::Bytes,
+            newOwner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, migrateCall, N> {
+            self.call_builder(&migrateCall {
+                target,
+                data,
+                newOwner,
+            })
+        }
+
+        ///Creates a new call builder for the [`multiplexBatchSellEthForToken`]
+        /// function.
+        pub fn multiplexBatchSellEthForToken(
+            &self,
+            outputToken: alloy_sol_types::private::Address,
+            calls: alloy_sol_types::private::Vec<
+                <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+            >,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, multiplexBatchSellEthForTokenCall, N> {
+            self.call_builder(&multiplexBatchSellEthForTokenCall {
+                outputToken,
+                calls,
+                minBuyAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`multiplexBatchSellTokenForEth`]
+        /// function.
+        pub fn multiplexBatchSellTokenForEth(
+            &self,
+            inputToken: alloy_sol_types::private::Address,
+            calls: alloy_sol_types::private::Vec<
+                <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+            >,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, multiplexBatchSellTokenForEthCall, N> {
+            self.call_builder(&multiplexBatchSellTokenForEthCall {
+                inputToken,
+                calls,
+                sellAmount,
+                minBuyAmount,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`multiplexBatchSellTokenForToken`] function.
+        pub fn multiplexBatchSellTokenForToken(
+            &self,
+            inputToken: alloy_sol_types::private::Address,
+            outputToken: alloy_sol_types::private::Address,
+            calls: alloy_sol_types::private::Vec<
+                <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
+            >,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, multiplexBatchSellTokenForTokenCall, N> {
+            self.call_builder(&multiplexBatchSellTokenForTokenCall {
+                inputToken,
+                outputToken,
+                calls,
+                sellAmount,
+                minBuyAmount,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`multiplexMultiHopSellEthForToken`] function.
+        pub fn multiplexMultiHopSellEthForToken(
+            &self,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            calls: alloy_sol_types::private::Vec<
+                <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+            >,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, multiplexMultiHopSellEthForTokenCall, N> {
+            self.call_builder(&multiplexMultiHopSellEthForTokenCall {
+                tokens,
+                calls,
+                minBuyAmount,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`multiplexMultiHopSellTokenForEth`] function.
+        pub fn multiplexMultiHopSellTokenForEth(
+            &self,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            calls: alloy_sol_types::private::Vec<
+                <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+            >,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, multiplexMultiHopSellTokenForEthCall, N> {
+            self.call_builder(&multiplexMultiHopSellTokenForEthCall {
+                tokens,
+                calls,
+                sellAmount,
+                minBuyAmount,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`multiplexMultiHopSellTokenForToken`] function.
+        pub fn multiplexMultiHopSellTokenForToken(
+            &self,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            calls: alloy_sol_types::private::Vec<
+                <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
+            >,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, multiplexMultiHopSellTokenForTokenCall, N> {
+            self.call_builder(&multiplexMultiHopSellTokenForTokenCall {
+                tokens,
+                calls,
+                sellAmount,
+                minBuyAmount,
+            })
+        }
+
+        ///Creates a new call builder for the [`onERC1155Received`] function.
+        pub fn onERC1155Received(
+            &self,
+            operator: alloy_sol_types::private::Address,
+            from: alloy_sol_types::private::Address,
+            tokenId: alloy_sol_types::private::primitives::aliases::U256,
+            value: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
+            self.call_builder(&onERC1155ReceivedCall {
+                operator,
+                from,
+                tokenId,
+                value,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the [`onERC721Received`] function.
+        pub fn onERC721Received(
+            &self,
+            operator: alloy_sol_types::private::Address,
+            from: alloy_sol_types::private::Address,
+            tokenId: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
+            self.call_builder(&onERC721ReceivedCall {
+                operator,
+                from,
+                tokenId,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the [`owner`] function.
+        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
+            self.call_builder(&ownerCall)
+        }
+
+        ///Creates a new call builder for the [`preSignERC1155Order`] function.
+        pub fn preSignERC1155Order(
+            &self,
+            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, preSignERC1155OrderCall, N> {
+            self.call_builder(&preSignERC1155OrderCall { order })
+        }
+
+        ///Creates a new call builder for the [`preSignERC721Order`] function.
+        pub fn preSignERC721Order(
+            &self,
+            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, preSignERC721OrderCall, N> {
+            self.call_builder(&preSignERC721OrderCall { order })
+        }
+
+        ///Creates a new call builder for the [`registerAllowedOrderSigner`]
+        /// function.
+        pub fn registerAllowedOrderSigner(
+            &self,
+            signer: alloy_sol_types::private::Address,
+            allowed: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, registerAllowedOrderSignerCall, N> {
+            self.call_builder(&registerAllowedOrderSignerCall { signer, allowed })
+        }
+
+        ///Creates a new call builder for the [`registerAllowedRfqOrigins`]
+        /// function.
+        pub fn registerAllowedRfqOrigins(
+            &self,
+            origins: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            allowed: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, registerAllowedRfqOriginsCall, N> {
+            self.call_builder(&registerAllowedRfqOriginsCall { origins, allowed })
+        }
+
+        ///Creates a new call builder for the [`rollback`] function.
+        pub fn rollback(
+            &self,
+            selector: alloy_sol_types::private::FixedBytes<4>,
+            targetImpl: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, rollbackCall, N> {
+            self.call_builder(&rollbackCall {
+                selector,
+                targetImpl,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellERC1155`] function.
+        pub fn sellERC1155(
+            &self,
+            buyOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+            erc1155SellAmount: u128,
+            unwrapNativeToken: bool,
+            callbackData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, sellERC1155Call, N> {
+            self.call_builder(&sellERC1155Call {
+                buyOrder,
+                signature,
+                erc1155TokenId,
+                erc1155SellAmount,
+                unwrapNativeToken,
+                callbackData,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellERC721`] function.
+        pub fn sellERC721(
+            &self,
+            buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+            unwrapNativeToken: bool,
+            callbackData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, sellERC721Call, N> {
+            self.call_builder(&sellERC721Call {
+                buyOrder,
+                signature,
+                erc721TokenId,
+                unwrapNativeToken,
+                callbackData,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellEthForTokenToUniswapV3`]
+        /// function.
+        pub fn sellEthForTokenToUniswapV3(
+            &self,
+            encodedPath: alloy_sol_types::private::Bytes,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            recipient: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, sellEthForTokenToUniswapV3Call, N> {
+            self.call_builder(&sellEthForTokenToUniswapV3Call {
+                encodedPath,
+                minBuyAmount,
+                recipient,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellToLiquidityProvider`]
+        /// function.
+        pub fn sellToLiquidityProvider(
+            &self,
+            inputToken: alloy_sol_types::private::Address,
+            outputToken: alloy_sol_types::private::Address,
+            provider: alloy_sol_types::private::Address,
+            recipient: alloy_sol_types::private::Address,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            auxiliaryData: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, sellToLiquidityProviderCall, N> {
+            self.call_builder(&sellToLiquidityProviderCall {
+                inputToken,
+                outputToken,
+                provider,
+                recipient,
+                sellAmount,
+                minBuyAmount,
+                auxiliaryData,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellToPancakeSwap`] function.
+        pub fn sellToPancakeSwap(
+            &self,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            fork: <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, sellToPancakeSwapCall, N> {
+            self.call_builder(&sellToPancakeSwapCall {
+                tokens,
+                sellAmount,
+                minBuyAmount,
+                fork,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellToUniswap`] function.
+        pub fn sellToUniswap(
+            &self,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            isSushi: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, sellToUniswapCall, N> {
+            self.call_builder(&sellToUniswapCall {
+                tokens,
+                sellAmount,
+                minBuyAmount,
+                isSushi,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellTokenForEthToUniswapV3`]
+        /// function.
+        pub fn sellTokenForEthToUniswapV3(
+            &self,
+            encodedPath: alloy_sol_types::private::Bytes,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            recipient: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, sellTokenForEthToUniswapV3Call, N> {
+            self.call_builder(&sellTokenForEthToUniswapV3Call {
+                encodedPath,
+                sellAmount,
+                minBuyAmount,
+                recipient,
+            })
+        }
+
+        ///Creates a new call builder for the [`sellTokenForTokenToUniswapV3`]
+        /// function.
+        pub fn sellTokenForTokenToUniswapV3(
+            &self,
+            encodedPath: alloy_sol_types::private::Bytes,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
+            recipient: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, sellTokenForTokenToUniswapV3Call, N> {
+            self.call_builder(&sellTokenForTokenToUniswapV3Call {
+                encodedPath,
+                sellAmount,
+                minBuyAmount,
+                recipient,
+            })
+        }
+
+        ///Creates a new call builder for the [`setQuoteSigner`] function.
+        pub fn setQuoteSigner(
+            &self,
+            quoteSigner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setQuoteSignerCall, N> {
+            self.call_builder(&setQuoteSignerCall { quoteSigner })
+        }
+
+        ///Creates a new call builder for the [`setTransformerDeployer`]
+        /// function.
+        pub fn setTransformerDeployer(
+            &self,
+            transformerDeployer: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setTransformerDeployerCall, N> {
+            self.call_builder(&setTransformerDeployerCall {
+                transformerDeployer,
+            })
+        }
+
+        ///Creates a new call builder for the [`supportInterface`] function.
+        pub fn supportInterface(
+            &self,
+            interfaceId: alloy_sol_types::private::FixedBytes<4>,
+        ) -> alloy_contract::SolCallBuilder<&P, supportInterfaceCall, N> {
+            self.call_builder(&supportInterfaceCall { interfaceId })
+        }
+
+        ///Creates a new call builder for the [`transferOwnership`] function.
+        pub fn transferOwnership(
+            &self,
+            newOwner: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
+            self.call_builder(&transferOwnershipCall { newOwner })
+        }
+
+        ///Creates a new call builder for the [`transferProtocolFeesForPools`]
+        /// function.
+        pub fn transferProtocolFeesForPools(
+            &self,
+            poolIds: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        ) -> alloy_contract::SolCallBuilder<&P, transferProtocolFeesForPoolsCall, N> {
+            self.call_builder(&transferProtocolFeesForPoolsCall { poolIds })
+        }
+
+        ///Creates a new call builder for the [`transferTrappedTokensTo`]
+        /// function.
+        pub fn transferTrappedTokensTo(
+            &self,
+            erc20: alloy_sol_types::private::Address,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            recipientWallet: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, transferTrappedTokensToCall, N> {
+            self.call_builder(&transferTrappedTokensToCall {
+                erc20,
+                amountOut,
+                recipientWallet,
+            })
+        }
+
+        ///Creates a new call builder for the [`transformERC20`] function.
+        pub fn transformERC20(
+            &self,
+            inputToken: alloy_sol_types::private::Address,
+            outputToken: alloy_sol_types::private::Address,
+            inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+            minOutputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+            transformations: alloy_sol_types::private::Vec<
+                <ITransformERC20Feature::Transformation as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, transformERC20Call, N> {
+            self.call_builder(&transformERC20Call {
+                inputToken,
+                outputToken,
+                inputTokenAmount,
+                minOutputTokenAmount,
+                transformations,
+            })
+        }
+
+        ///Creates a new call builder for the [`uniswapV3SwapCallback`]
+        /// function.
+        pub fn uniswapV3SwapCallback(
+            &self,
+            amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
+            amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, uniswapV3SwapCallbackCall, N> {
+            self.call_builder(&uniswapV3SwapCallbackCall {
+                amount0Delta,
+                amount1Delta,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`validateERC1155OrderProperties`] function.
+        pub fn validateERC1155OrderProperties(
+            &self,
+            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+            erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, validateERC1155OrderPropertiesCall, N> {
+            self.call_builder(&validateERC1155OrderPropertiesCall {
+                order,
+                erc1155TokenId,
+            })
+        }
+
+        ///Creates a new call builder for the [`validateERC1155OrderSignature`]
+        /// function.
+        pub fn validateERC1155OrderSignature(
+            &self,
+            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, validateERC1155OrderSignatureCall, N> {
+            self.call_builder(&validateERC1155OrderSignatureCall { order, signature })
+        }
+
+        ///Creates a new call builder for the [`validateERC721OrderProperties`]
+        /// function.
+        pub fn validateERC721OrderProperties(
+            &self,
+            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, validateERC721OrderPropertiesCall, N> {
+            self.call_builder(&validateERC721OrderPropertiesCall {
+                order,
+                erc721TokenId,
+            })
+        }
+
+        ///Creates a new call builder for the [`validateERC721OrderSignature`]
+        /// function.
+        pub fn validateERC721OrderSignature(
+            &self,
+            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, validateERC721OrderSignatureCall, N> {
+            self.call_builder(&validateERC721OrderSignatureCall { order, signature })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IZeroexInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`ERC1155OrderCancelled`] event.
+        pub fn ERC1155OrderCancelled_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ERC1155OrderCancelled, N> {
+            self.event_filter::<ERC1155OrderCancelled>()
+        }
+
+        ///Creates a new event filter for the [`ERC1155OrderFilled`] event.
+        pub fn ERC1155OrderFilled_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ERC1155OrderFilled, N> {
+            self.event_filter::<ERC1155OrderFilled>()
+        }
+
+        ///Creates a new event filter for the [`ERC1155OrderPreSigned`] event.
+        pub fn ERC1155OrderPreSigned_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ERC1155OrderPreSigned, N> {
+            self.event_filter::<ERC1155OrderPreSigned>()
+        }
+
+        ///Creates a new event filter for the [`ERC721OrderCancelled`] event.
+        pub fn ERC721OrderCancelled_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ERC721OrderCancelled, N> {
+            self.event_filter::<ERC721OrderCancelled>()
+        }
+
+        ///Creates a new event filter for the [`ERC721OrderFilled`] event.
+        pub fn ERC721OrderFilled_filter(&self) -> alloy_contract::Event<&P, ERC721OrderFilled, N> {
+            self.event_filter::<ERC721OrderFilled>()
+        }
+
+        ///Creates a new event filter for the [`ERC721OrderPreSigned`] event.
+        pub fn ERC721OrderPreSigned_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ERC721OrderPreSigned, N> {
+            self.event_filter::<ERC721OrderPreSigned>()
+        }
+
+        ///Creates a new event filter for the [`LimitOrderFilled`] event.
+        pub fn LimitOrderFilled_filter(&self) -> alloy_contract::Event<&P, LimitOrderFilled, N> {
+            self.event_filter::<LimitOrderFilled>()
+        }
+
+        ///Creates a new event filter for the [`LiquidityProviderSwap`] event.
+        pub fn LiquidityProviderSwap_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, LiquidityProviderSwap, N> {
+            self.event_filter::<LiquidityProviderSwap>()
+        }
+
+        ///Creates a new event filter for the [`MetaTransactionExecuted`]
+        /// event.
+        pub fn MetaTransactionExecuted_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, MetaTransactionExecuted, N> {
+            self.event_filter::<MetaTransactionExecuted>()
+        }
+
+        ///Creates a new event filter for the [`Migrated`] event.
+        pub fn Migrated_filter(&self) -> alloy_contract::Event<&P, Migrated, N> {
+            self.event_filter::<Migrated>()
+        }
+
+        ///Creates a new event filter for the [`OrderCancelled`] event.
+        pub fn OrderCancelled_filter(&self) -> alloy_contract::Event<&P, OrderCancelled, N> {
+            self.event_filter::<OrderCancelled>()
+        }
+
+        ///Creates a new event filter for the [`OrderSignerRegistered`] event.
+        pub fn OrderSignerRegistered_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, OrderSignerRegistered, N> {
+            self.event_filter::<OrderSignerRegistered>()
+        }
+
+        ///Creates a new event filter for the [`OtcOrderFilled`] event.
+        pub fn OtcOrderFilled_filter(&self) -> alloy_contract::Event<&P, OtcOrderFilled, N> {
+            self.event_filter::<OtcOrderFilled>()
+        }
+
+        ///Creates a new event filter for the [`OwnershipTransferred`] event.
+        pub fn OwnershipTransferred_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
+            self.event_filter::<OwnershipTransferred>()
+        }
+
+        ///Creates a new event filter for the [`PairCancelledLimitOrders`]
+        /// event.
+        pub fn PairCancelledLimitOrders_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PairCancelledLimitOrders, N> {
+            self.event_filter::<PairCancelledLimitOrders>()
+        }
+
+        ///Creates a new event filter for the [`PairCancelledRfqOrders`] event.
+        pub fn PairCancelledRfqOrders_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, PairCancelledRfqOrders, N> {
+            self.event_filter::<PairCancelledRfqOrders>()
+        }
+
+        ///Creates a new event filter for the [`ProxyFunctionUpdated`] event.
+        pub fn ProxyFunctionUpdated_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, ProxyFunctionUpdated, N> {
+            self.event_filter::<ProxyFunctionUpdated>()
+        }
+
+        ///Creates a new event filter for the [`QuoteSignerUpdated`] event.
+        pub fn QuoteSignerUpdated_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, QuoteSignerUpdated, N> {
+            self.event_filter::<QuoteSignerUpdated>()
+        }
+
+        ///Creates a new event filter for the [`RfqOrderFilled`] event.
+        pub fn RfqOrderFilled_filter(&self) -> alloy_contract::Event<&P, RfqOrderFilled, N> {
+            self.event_filter::<RfqOrderFilled>()
+        }
+
+        ///Creates a new event filter for the [`RfqOrderOriginsAllowed`] event.
+        pub fn RfqOrderOriginsAllowed_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, RfqOrderOriginsAllowed, N> {
+            self.event_filter::<RfqOrderOriginsAllowed>()
+        }
+
+        ///Creates a new event filter for the [`TransformedERC20`] event.
+        pub fn TransformedERC20_filter(&self) -> alloy_contract::Event<&P, TransformedERC20, N> {
+            self.event_filter::<TransformedERC20>()
+        }
+
+        ///Creates a new event filter for the [`TransformerDeployerUpdated`]
+        /// event.
+        pub fn TransformerDeployerUpdated_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, TransformerDeployerUpdated, N> {
+            self.event_filter::<TransformerDeployerUpdated>()
+        }
+    }
+}
+pub type Instance = IZeroex::IZeroexInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0xdef1abe32c034e558cdd535791643c58a13acc10"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xdef1c0ded9bec7f1a1670819833240f027b25eff"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/liquoricesettlement/Cargo.toml b/contracts/generated/contracts-generated/liquoricesettlement/Cargo.toml
new file mode 100644
index 0000000000..227b925146
--- /dev/null
+++ b/contracts/generated/contracts-generated/liquoricesettlement/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-liquoricesettlement"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs b/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs
new file mode 100644
index 0000000000..2815eb02ab
--- /dev/null
+++ b/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs
@@ -0,0 +1,13331 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library GPv2Interaction {
+    struct Data { address target; uint256 value; bytes callData; }
+    struct Hooks { Data[] beforeSettle; Data[] afterSettle; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod GPv2Interaction {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Data { address target; uint256 value; bytes callData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Data {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
+            fn from(value: Data) -> Self {
+                (value.target, value.value, value.callData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    value: tuple.1,
+                    callData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Data {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Data {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Data {
+            const NAME: &'static str = "Data";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Data(address target,uint256 value,bytes callData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Data {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Hooks { Data[] beforeSettle; Data[] afterSettle; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Hooks {
+        #[allow(missing_docs)]
+        pub beforeSettle:
+            alloy_sol_types::private::Vec<<Data as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub afterSettle:
+            alloy_sol_types::private::Vec<<Data as alloy_sol_types::SolType>::RustType>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<Data>,
+            alloy_sol_types::sol_data::Array<Data>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<<Data as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::Vec<<Data as alloy_sol_types::SolType>::RustType>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Hooks> for UnderlyingRustTuple<'_> {
+            fn from(value: Hooks) -> Self {
+                (value.beforeSettle, value.afterSettle)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Hooks {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    beforeSettle: tuple.0,
+                    afterSettle: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Hooks {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Hooks {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<Data> as alloy_sol_types::SolType>::tokenize(
+                        &self.beforeSettle,
+                    ),
+                    <alloy_sol_types::sol_data::Array<Data> as alloy_sol_types::SolType>::tokenize(
+                        &self.afterSettle,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Hooks {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Hooks {
+            const NAME: &'static str = "Hooks";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Hooks(Data[] beforeSettle,Data[] afterSettle)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
+                components.push(<Data as alloy_sol_types::SolStruct>::eip712_root_type());
+                components.extend(<Data as alloy_sol_types::SolStruct>::eip712_components());
+                components.push(<Data as alloy_sol_types::SolStruct>::eip712_root_type());
+                components.extend(<Data as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        Data,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.beforeSettle)
+                        .0,
+                    <alloy_sol_types::sol_data::Array<
+                        Data,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.afterSettle)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Hooks {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        Data,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.beforeSettle,
+                    )
+                    + <alloy_sol_types::sol_data::Array<
+                        Data,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.afterSettle,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    Data,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.beforeSettle,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Array<
+                    Data,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.afterSettle,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`GPv2Interaction`](self) contract instance.
+
+    See the [wrapper's documentation](`GPv2InteractionInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> GPv2InteractionInstance<P, N> {
+        GPv2InteractionInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`GPv2Interaction`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`GPv2Interaction`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct GPv2InteractionInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for GPv2InteractionInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("GPv2InteractionInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`GPv2Interaction`](self) contract instance.
+
+        See the [wrapper's documentation](`GPv2InteractionInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> GPv2InteractionInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> GPv2InteractionInstance<P, N> {
+            GPv2InteractionInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        GPv2InteractionInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ILiquoriceSettlement {
+    struct BaseTokenData { address addr; uint256 amount; uint256 toRecipient; uint256 toRepay; uint256 toSupply; }
+    struct Order { address market; uint256 chainId; string rfqId; uint256 nonce; address trader; address effectiveTrader; uint256 quoteExpiry; address recipient; uint256 minFillAmount; BaseTokenData baseTokenData; QuoteTokenData quoteTokenData; }
+    struct QuoteTokenData { address addr; uint256 amount; uint256 toTrader; uint256 toWithdraw; uint256 toBorrow; }
+    struct Single { string rfqId; uint256 nonce; address trader; address effectiveTrader; address baseToken; address quoteToken; uint256 baseTokenAmount; uint256 quoteTokenAmount; uint256 minFillAmount; uint256 quoteExpiry; address recipient; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ILiquoriceSettlement {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct BaseTokenData { address addr; uint256 amount; uint256 toRecipient; uint256 toRepay; uint256 toSupply; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BaseTokenData {
+        #[allow(missing_docs)]
+        pub addr: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub toRecipient: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub toRepay: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub toSupply: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<BaseTokenData> for UnderlyingRustTuple<'_> {
+            fn from(value: BaseTokenData) -> Self {
+                (
+                    value.addr,
+                    value.amount,
+                    value.toRecipient,
+                    value.toRepay,
+                    value.toSupply,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BaseTokenData {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    addr: tuple.0,
+                    amount: tuple.1,
+                    toRecipient: tuple.2,
+                    toRepay: tuple.3,
+                    toSupply: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for BaseTokenData {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for BaseTokenData {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.addr,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.toRecipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.toRepay,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.toSupply,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for BaseTokenData {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for BaseTokenData {
+            const NAME: &'static str = "BaseTokenData";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "BaseTokenData(address addr,uint256 amount,uint256 toRecipient,uint256 \
+                     toRepay,uint256 toSupply)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.addr,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.toRecipient)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.toRepay)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.toSupply)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for BaseTokenData {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.addr,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toRecipient,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toRepay,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toSupply,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.addr,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toRecipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toRepay,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toSupply,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Order { address market; uint256 chainId; string rfqId; uint256 nonce; address trader; address effectiveTrader; uint256 quoteExpiry; address recipient; uint256 minFillAmount; BaseTokenData baseTokenData; QuoteTokenData quoteTokenData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Order {
+        #[allow(missing_docs)]
+        pub market: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub chainId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rfqId: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub trader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub effectiveTrader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub quoteExpiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minFillAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub baseTokenData: <BaseTokenData as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub quoteTokenData: <QuoteTokenData as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::String,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            BaseTokenData,
+            QuoteTokenData,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::String,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            <BaseTokenData as alloy_sol_types::SolType>::RustType,
+            <QuoteTokenData as alloy_sol_types::SolType>::RustType,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Order> for UnderlyingRustTuple<'_> {
+            fn from(value: Order) -> Self {
+                (
+                    value.market,
+                    value.chainId,
+                    value.rfqId,
+                    value.nonce,
+                    value.trader,
+                    value.effectiveTrader,
+                    value.quoteExpiry,
+                    value.recipient,
+                    value.minFillAmount,
+                    value.baseTokenData,
+                    value.quoteTokenData,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Order {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    market: tuple.0,
+                    chainId: tuple.1,
+                    rfqId: tuple.2,
+                    nonce: tuple.3,
+                    trader: tuple.4,
+                    effectiveTrader: tuple.5,
+                    quoteExpiry: tuple.6,
+                    recipient: tuple.7,
+                    minFillAmount: tuple.8,
+                    baseTokenData: tuple.9,
+                    quoteTokenData: tuple.10,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Order {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Order {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.market,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.chainId,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.rfqId,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.trader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.effectiveTrader,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteExpiry,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minFillAmount,
+                    ),
+                    <BaseTokenData as alloy_sol_types::SolType>::tokenize(&self.baseTokenData),
+                    <QuoteTokenData as alloy_sol_types::SolType>::tokenize(&self.quoteTokenData),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Order {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Order {
+            const NAME: &'static str = "Order";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Order(address market,uint256 chainId,string rfqId,uint256 nonce,address \
+                     trader,address effectiveTrader,uint256 quoteExpiry,address recipient,uint256 \
+                     minFillAmount,BaseTokenData baseTokenData,QuoteTokenData quoteTokenData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
+                components.push(<BaseTokenData as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<BaseTokenData as alloy_sol_types::SolStruct>::eip712_components());
+                components.push(<QuoteTokenData as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<QuoteTokenData as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.market,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.chainId)
+                        .0,
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.rfqId,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.trader,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.effectiveTrader,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.quoteExpiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minFillAmount)
+                        .0,
+                    <BaseTokenData as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.baseTokenData,
+                        )
+                        .0,
+                    <QuoteTokenData as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.quoteTokenData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Order {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.market,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.chainId,
+                    )
+                    + <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.rfqId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.trader,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.effectiveTrader,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.quoteExpiry,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minFillAmount,
+                    )
+                    + <BaseTokenData as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.baseTokenData,
+                    )
+                    + <QuoteTokenData as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.quoteTokenData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.market,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.chainId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.rfqId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.trader,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.effectiveTrader,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.quoteExpiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minFillAmount,
+                    out,
+                );
+                <BaseTokenData as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.baseTokenData,
+                    out,
+                );
+                <QuoteTokenData as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.quoteTokenData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct QuoteTokenData { address addr; uint256 amount; uint256 toTrader; uint256 toWithdraw; uint256 toBorrow; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct QuoteTokenData {
+        #[allow(missing_docs)]
+        pub addr: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub toTrader: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub toWithdraw: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub toBorrow: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<QuoteTokenData> for UnderlyingRustTuple<'_> {
+            fn from(value: QuoteTokenData) -> Self {
+                (
+                    value.addr,
+                    value.amount,
+                    value.toTrader,
+                    value.toWithdraw,
+                    value.toBorrow,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuoteTokenData {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    addr: tuple.0,
+                    amount: tuple.1,
+                    toTrader: tuple.2,
+                    toWithdraw: tuple.3,
+                    toBorrow: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for QuoteTokenData {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for QuoteTokenData {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.addr,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.toTrader,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.toWithdraw,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.toBorrow,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for QuoteTokenData {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for QuoteTokenData {
+            const NAME: &'static str = "QuoteTokenData";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "QuoteTokenData(address addr,uint256 amount,uint256 toTrader,uint256 \
+                     toWithdraw,uint256 toBorrow)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.addr,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.toTrader)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.toWithdraw)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.toBorrow)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for QuoteTokenData {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.addr,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toTrader,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toWithdraw,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.toBorrow,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.addr,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toTrader,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toWithdraw,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.toBorrow,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Single { string rfqId; uint256 nonce; address trader; address effectiveTrader; address baseToken; address quoteToken; uint256 baseTokenAmount; uint256 quoteTokenAmount; uint256 minFillAmount; uint256 quoteExpiry; address recipient; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Single {
+        #[allow(missing_docs)]
+        pub rfqId: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub trader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub effectiveTrader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub baseToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub quoteToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub baseTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub quoteTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minFillAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub quoteExpiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::String,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::String,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Single> for UnderlyingRustTuple<'_> {
+            fn from(value: Single) -> Self {
+                (
+                    value.rfqId,
+                    value.nonce,
+                    value.trader,
+                    value.effectiveTrader,
+                    value.baseToken,
+                    value.quoteToken,
+                    value.baseTokenAmount,
+                    value.quoteTokenAmount,
+                    value.minFillAmount,
+                    value.quoteExpiry,
+                    value.recipient,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Single {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    rfqId: tuple.0,
+                    nonce: tuple.1,
+                    trader: tuple.2,
+                    effectiveTrader: tuple.3,
+                    baseToken: tuple.4,
+                    quoteToken: tuple.5,
+                    baseTokenAmount: tuple.6,
+                    quoteTokenAmount: tuple.7,
+                    minFillAmount: tuple.8,
+                    quoteExpiry: tuple.9,
+                    recipient: tuple.10,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Single {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Single {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.rfqId,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.trader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.effectiveTrader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.baseToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minFillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteExpiry,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Single {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Single {
+            const NAME: &'static str = "Single";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Single(string rfqId,uint256 nonce,address trader,address \
+                     effectiveTrader,address baseToken,address quoteToken,uint256 \
+                     baseTokenAmount,uint256 quoteTokenAmount,uint256 minFillAmount,uint256 \
+                     quoteExpiry,address recipient)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.rfqId,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.trader,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.effectiveTrader,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.baseToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.quoteToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.baseTokenAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.quoteTokenAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minFillAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.quoteExpiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Single {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.rfqId,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.trader,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.effectiveTrader,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.baseToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.quoteToken,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.baseTokenAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.quoteTokenAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.minFillAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.quoteExpiry,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.rfqId,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.trader,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.effectiveTrader,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.baseToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.quoteToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.baseTokenAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.quoteTokenAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.minFillAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.quoteExpiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ILiquoriceSettlement`](self) contract instance.
+
+    See the [wrapper's documentation](`ILiquoriceSettlementInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ILiquoriceSettlementInstance<P, N> {
+        ILiquoriceSettlementInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ILiquoriceSettlement`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ILiquoriceSettlement`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ILiquoriceSettlementInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ILiquoriceSettlementInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ILiquoriceSettlementInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ILiquoriceSettlementInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ILiquoriceSettlement`](self) contract instance.
+
+        See the [wrapper's documentation](`ILiquoriceSettlementInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ILiquoriceSettlementInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ILiquoriceSettlementInstance<P, N> {
+            ILiquoriceSettlementInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ILiquoriceSettlementInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ILiquoriceSettlementInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library Signature {
+    type TransferCommand is uint8;
+    type Type is uint8;
+    struct TakerPermitInfo { bytes signature; uint48 nonce; uint48 deadline; }
+    struct TypedSignature { Type signatureType; TransferCommand transferCommand; bytes signatureBytes; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Signature {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TransferCommand(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<TransferCommand> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl TransferCommand {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for TransferCommand {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<TransferCommand> for u8 {
+            fn from(value: TransferCommand) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TransferCommand {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TransferCommand {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Type(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Type> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl Type {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for Type {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<Type> for u8 {
+            fn from(value: Type) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Type {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Type {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct TakerPermitInfo { bytes signature; uint48 nonce; uint48 deadline; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TakerPermitInfo {
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Uint<48>,
+            alloy_sol_types::sol_data::Uint<48>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Bytes,
+            alloy_sol_types::private::primitives::aliases::U48,
+            alloy_sol_types::private::primitives::aliases::U48,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TakerPermitInfo> for UnderlyingRustTuple<'_> {
+            fn from(value: TakerPermitInfo) -> Self {
+                (value.signature, value.nonce, value.deadline)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TakerPermitInfo {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    signature: tuple.0,
+                    nonce: tuple.1,
+                    deadline: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for TakerPermitInfo {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for TakerPermitInfo {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TakerPermitInfo {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for TakerPermitInfo {
+            const NAME: &'static str = "TakerPermitInfo";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "TakerPermitInfo(bytes signature,uint48 nonce,uint48 deadline)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signature,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TakerPermitInfo {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signature,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deadline,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signature,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    48,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    48,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deadline,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct TypedSignature { Type signatureType; TransferCommand transferCommand; bytes signatureBytes; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TypedSignature {
+        #[allow(missing_docs)]
+        pub signatureType: <Type as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub transferCommand: <TransferCommand as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signatureBytes: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (Type, TransferCommand, alloy_sol_types::sol_data::Bytes);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <Type as alloy_sol_types::SolType>::RustType,
+            <TransferCommand as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TypedSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: TypedSignature) -> Self {
+                (
+                    value.signatureType,
+                    value.transferCommand,
+                    value.signatureBytes,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TypedSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    signatureType: tuple.0,
+                    transferCommand: tuple.1,
+                    signatureBytes: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for TypedSignature {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for TypedSignature {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <Type as alloy_sol_types::SolType>::tokenize(&self.signatureType),
+                    <TransferCommand as alloy_sol_types::SolType>::tokenize(&self.transferCommand),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signatureBytes,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TypedSignature {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for TypedSignature {
+            const NAME: &'static str = "TypedSignature";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "TypedSignature(uint8 signatureType,uint8 transferCommand,bytes \
+                     signatureBytes)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <Type as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signatureType,
+                        )
+                        .0,
+                    <TransferCommand as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.transferCommand,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signatureBytes,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TypedSignature {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <Type as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signatureType,
+                    )
+                    + <TransferCommand as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.transferCommand,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signatureBytes,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <Type as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signatureType,
+                    out,
+                );
+                <TransferCommand as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.transferCommand,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signatureBytes,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Signature`](self) contract instance.
+
+    See the [wrapper's documentation](`SignatureInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SignatureInstance<P, N> {
+        SignatureInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`Signature`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Signature`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SignatureInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SignatureInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SignatureInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SignatureInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Signature`](self) contract instance.
+
+        See the [wrapper's documentation](`SignatureInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SignatureInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SignatureInstance<P, N> {
+            SignatureInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SignatureInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SignatureInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library GPv2Interaction {
+    struct Data {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+    struct Hooks {
+        Data[] beforeSettle;
+        Data[] afterSettle;
+    }
+}
+
+library ILiquoriceSettlement {
+    struct BaseTokenData {
+        address addr;
+        uint256 amount;
+        uint256 toRecipient;
+        uint256 toRepay;
+        uint256 toSupply;
+    }
+    struct Order {
+        address market;
+        uint256 chainId;
+        string rfqId;
+        uint256 nonce;
+        address trader;
+        address effectiveTrader;
+        uint256 quoteExpiry;
+        address recipient;
+        uint256 minFillAmount;
+        BaseTokenData baseTokenData;
+        QuoteTokenData quoteTokenData;
+    }
+    struct QuoteTokenData {
+        address addr;
+        uint256 amount;
+        uint256 toTrader;
+        uint256 toWithdraw;
+        uint256 toBorrow;
+    }
+    struct Single {
+        string rfqId;
+        uint256 nonce;
+        address trader;
+        address effectiveTrader;
+        address baseToken;
+        address quoteToken;
+        uint256 baseTokenAmount;
+        uint256 quoteTokenAmount;
+        uint256 minFillAmount;
+        uint256 quoteExpiry;
+        address recipient;
+    }
+}
+
+library Signature {
+    type TransferCommand is uint8;
+    type Type is uint8;
+    struct TakerPermitInfo {
+        bytes signature;
+        uint48 nonce;
+        uint48 deadline;
+    }
+    struct TypedSignature {
+        Type signatureType;
+        TransferCommand transferCommand;
+        bytes signatureBytes;
+    }
+}
+
+interface LiquoriceSettlement {
+    error ECDSAInvalidSignature();
+    error ECDSAInvalidSignatureLength(uint256 length);
+    error ECDSAInvalidSignatureS(bytes32 s);
+    error InvalidAmount();
+    error InvalidAsset();
+    error InvalidBaseTokenAmounts();
+    error InvalidDestination();
+    error InvalidEIP1271Signature();
+    error InvalidEIP712Signature();
+    error InvalidETHSignSignature();
+    error InvalidFillAmount();
+    error InvalidHooksTarget();
+    error InvalidInteractionsBaseTokenAmounts();
+    error InvalidInteractionsQuoteTokenAmounts();
+    error InvalidLendingPoolInteraction();
+    error InvalidQuoteTokenAmounts();
+    error InvalidSignatureType();
+    error InvalidSigner();
+    error InvalidSource();
+    error NonceInvalid();
+    error NotMaker();
+    error NotSolver();
+    error OrderExpired();
+    error PartialFillNotSupported();
+    error ReceiverNotManager();
+    error ReentrancyGuardReentrantCall();
+    error SafeERC20FailedOperation(address token);
+    error SignatureIsExpired();
+    error SignatureIsNotEmpty();
+    error UpdatedMakerAmountsTooLow();
+    error ZeroMakerAmount();
+
+    event Interaction(address indexed target, uint256 value, bytes4 selector);
+    event TradeOrder(string indexed rfqId, address trader, address effectiveTrader, address baseToken, address quoteToken, uint256 baseTokenAmount, uint256 quoteTokenAmount, address recipient);
+
+    constructor(address authenticator_, address repository_, address permit2_);
+
+    receive() external payable;
+
+    function AUTHENTICATOR() external view returns (address);
+    function BALANCE_MANAGER() external view returns (address);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function REPOSITORY() external view returns (address);
+    function cancelLimitOrder(uint256 nonce) external;
+    function hashBaseTokenData(ILiquoriceSettlement.BaseTokenData memory _baseTokenData) external pure returns (bytes32);
+    function hashOrder(ILiquoriceSettlement.Order memory _order) external view returns (bytes32);
+    function hashQuoteTokenData(ILiquoriceSettlement.QuoteTokenData memory _quoteTokenData) external pure returns (bytes32);
+    function hashSingleOrder(ILiquoriceSettlement.Single memory _order) external view returns (bytes32);
+    function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4);
+    function settle(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature) external;
+    function settleSingle(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature) external payable;
+    function settleSingleWithPermitsSignatures(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
+    function settleWithPermitsSignatures(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
+    function validateHooks(address _repository, GPv2Interaction.Hooks memory _hooks) external view;
+    function validateInteractions(address _repository, address _signer, bool _isPartialFill, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions) external view;
+    function validateOrderAmounts(ILiquoriceSettlement.Order memory _order) external pure;
+    function validateSignature(address _validationAddress, bytes32 _hash, Signature.TypedSignature memory _signature) external view;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "authenticator_",
+        "type": "address",
+        "internalType": "contract IAllowListAuthentication"
+      },
+      {
+        "name": "repository_",
+        "type": "address",
+        "internalType": "contract IRepository"
+      },
+      {
+        "name": "permit2_",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "AUTHENTICATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAllowListAuthentication"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "BALANCE_MANAGER",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IBalanceManager"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "REPOSITORY",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IRepository"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "cancelLimitOrder",
+    "inputs": [
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "hashBaseTokenData",
+    "inputs": [
+      {
+        "name": "_baseTokenData",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+        "components": [
+          {
+            "name": "addr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "toRecipient",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "toRepay",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "toSupply",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "hashOrder",
+    "inputs": [
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Order",
+        "components": [
+          {
+            "name": "market",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "baseTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRecipient",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRepay",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toSupply",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "quoteTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toTrader",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toWithdraw",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toBorrow",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "hashQuoteTokenData",
+    "inputs": [
+      {
+        "name": "_quoteTokenData",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+        "components": [
+          {
+            "name": "addr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "toTrader",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "toWithdraw",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "toBorrow",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "hashSingleOrder",
+    "inputs": [
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Single",
+        "components": [
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "quoteTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "_hash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "_signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "settle",
+    "inputs": [
+      {
+        "name": "_signer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_filledTakerAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Order",
+        "components": [
+          {
+            "name": "market",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "baseTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRecipient",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRepay",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toSupply",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "quoteTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toTrader",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toWithdraw",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toBorrow",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "_interactions",
+        "type": "tuple[]",
+        "internalType": "struct GPv2Interaction.Data[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_hooks",
+        "type": "tuple",
+        "internalType": "struct GPv2Interaction.Hooks",
+        "components": [
+          {
+            "name": "beforeSettle",
+            "type": "tuple[]",
+            "internalType": "struct GPv2Interaction.Data[]",
+            "components": [
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "value",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "callData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "afterSettle",
+            "type": "tuple[]",
+            "internalType": "struct GPv2Interaction.Data[]",
+            "components": [
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "value",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "callData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "_makerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_takerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "settleSingle",
+    "inputs": [
+      {
+        "name": "_signer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Single",
+        "components": [
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "quoteTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      },
+      {
+        "name": "_makerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_filledTakerAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_takerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "settleSingleWithPermitsSignatures",
+    "inputs": [
+      {
+        "name": "_signer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Single",
+        "components": [
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "quoteTokenAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      },
+      {
+        "name": "_makerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_filledTakerAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_takerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_takerPermitInfo",
+        "type": "tuple",
+        "internalType": "struct Signature.TakerPermitInfo",
+        "components": [
+          {
+            "name": "signature",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "nonce",
+            "type": "uint48",
+            "internalType": "uint48"
+          },
+          {
+            "name": "deadline",
+            "type": "uint48",
+            "internalType": "uint48"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "settleWithPermitsSignatures",
+    "inputs": [
+      {
+        "name": "_signer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_filledTakerAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Order",
+        "components": [
+          {
+            "name": "market",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "baseTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRecipient",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRepay",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toSupply",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "quoteTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toTrader",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toWithdraw",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toBorrow",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "_interactions",
+        "type": "tuple[]",
+        "internalType": "struct GPv2Interaction.Data[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_hooks",
+        "type": "tuple",
+        "internalType": "struct GPv2Interaction.Hooks",
+        "components": [
+          {
+            "name": "beforeSettle",
+            "type": "tuple[]",
+            "internalType": "struct GPv2Interaction.Data[]",
+            "components": [
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "value",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "callData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "afterSettle",
+            "type": "tuple[]",
+            "internalType": "struct GPv2Interaction.Data[]",
+            "components": [
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "value",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "callData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "_makerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_takerSignature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "_takerPermitInfo",
+        "type": "tuple",
+        "internalType": "struct Signature.TakerPermitInfo",
+        "components": [
+          {
+            "name": "signature",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "nonce",
+            "type": "uint48",
+            "internalType": "uint48"
+          },
+          {
+            "name": "deadline",
+            "type": "uint48",
+            "internalType": "uint48"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "validateHooks",
+    "inputs": [
+      {
+        "name": "_repository",
+        "type": "address",
+        "internalType": "contract IRepository"
+      },
+      {
+        "name": "_hooks",
+        "type": "tuple",
+        "internalType": "struct GPv2Interaction.Hooks",
+        "components": [
+          {
+            "name": "beforeSettle",
+            "type": "tuple[]",
+            "internalType": "struct GPv2Interaction.Data[]",
+            "components": [
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "value",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "callData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          },
+          {
+            "name": "afterSettle",
+            "type": "tuple[]",
+            "internalType": "struct GPv2Interaction.Data[]",
+            "components": [
+              {
+                "name": "target",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "value",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "callData",
+                "type": "bytes",
+                "internalType": "bytes"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "validateInteractions",
+    "inputs": [
+      {
+        "name": "_repository",
+        "type": "address",
+        "internalType": "contract IRepository"
+      },
+      {
+        "name": "_signer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_isPartialFill",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Order",
+        "components": [
+          {
+            "name": "market",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "baseTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRecipient",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRepay",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toSupply",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "quoteTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toTrader",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toWithdraw",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toBorrow",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "_interactions",
+        "type": "tuple[]",
+        "internalType": "struct GPv2Interaction.Data[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "validateOrderAmounts",
+    "inputs": [
+      {
+        "name": "_order",
+        "type": "tuple",
+        "internalType": "struct ILiquoriceSettlement.Order",
+        "components": [
+          {
+            "name": "market",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "chainId",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteExpiry",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "minFillAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "baseTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRecipient",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toRepay",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toSupply",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "quoteTokenData",
+            "type": "tuple",
+            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toTrader",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toWithdraw",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "toBorrow",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "validateSignature",
+    "inputs": [
+      {
+        "name": "_validationAddress",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_hash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "_signature",
+        "type": "tuple",
+        "internalType": "struct Signature.TypedSignature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum Signature.Type"
+          },
+          {
+            "name": "transferCommand",
+            "type": "uint8",
+            "internalType": "enum Signature.TransferCommand"
+          },
+          {
+            "name": "signatureBytes",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "Interaction",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": false,
+        "internalType": "bytes4"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TradeOrder",
+    "inputs": [
+      {
+        "name": "rfqId",
+        "type": "string",
+        "indexed": true,
+        "internalType": "string"
+      },
+      {
+        "name": "trader",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "effectiveTrader",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "baseToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "quoteToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "baseTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "quoteTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureLength",
+    "inputs": [
+      {
+        "name": "length",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureS",
+    "inputs": [
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidAsset",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidBaseTokenAmounts",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidDestination",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidEIP1271Signature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidEIP712Signature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidETHSignSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidFillAmount",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidHooksTarget",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidInteractionsBaseTokenAmounts",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidInteractionsQuoteTokenAmounts",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidLendingPoolInteraction",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidQuoteTokenAmounts",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignatureType",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSigner",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSource",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NonceInvalid",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotMaker",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotSolver",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PartialFillNotSupported",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReceiverNotManager",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReentrancyGuardReentrantCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SafeERC20FailedOperation",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SignatureIsExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SignatureIsNotEmpty",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UpdatedMakerAmountsTooLow",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroMakerAmount",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod LiquoriceSettlement {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01 `@R4\x80\x15b\0\0\x11W_\x80\xFD[P`@Qb\0N\xF68\x03\x80b\0N\xF6\x839\x81\x01`@\x81\x90Rb\0\x004\x91b\0\x01uV[F`\xA0\x81\x81R`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01R`\x80\x81\x01\x92\x90\x92R0\x90\x82\x01R`\xC0\x01`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x80Q` \x90\x91\x01 `\x80R`\x01\x80U`\x01`\x01`\xA0\x1B\x03\x84\x16`\xC0R0\x90\x82\x90b\0\0\xFE\x90b\0\x01OV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15b\0\x01/W=_\x80>=_\xFD[P`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\xE0R\x91\x90\x91\x16a\x01\0RPb\0\x01\xC6\x90PV[a\tc\x80b\0E\x93\x839\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x01rW_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15b\0\x01\x88W_\x80\xFD[\x83Qb\0\x01\x95\x81b\0\x01]V[` \x85\x01Q\x90\x93Pb\0\x01\xA8\x81b\0\x01]V[`@\x85\x01Q\x90\x92Pb\0\x01\xBB\x81b\0\x01]V[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0QaC-b\0\x02f_9_\x81\x81a\x02W\x01R\x81\x81a\x07\x84\x01Ra\x16\xDC\x01R_\x81\x81a\x01\x97\x01R\x81\x81a\x07\xBA\x01R\x81\x81a\x18\x8C\x01R\x81\x81a\x1E,\x01R\x81\x81a\x1F\x1E\x01R\x81\x81a ,\x01R\x81\x81a#\x0B\x01R\x81\x81a$'\x01Ra0<\x01R_\x81\x81a\x038\x01R\x81\x81a\x04\x12\x01R\x81\x81a\x06\xA7\x01R\x81\x81a\x15 \x01Ra\x15\xFF\x01R_a\x04\xDA\x01R_a\x05\xA4\x01RaC-_\xF3\xFE`\x80`@R`\x046\x10a\x01&W_5`\xE0\x1C\x80c\xA5\xCD\xC8\xFC\x11a\0\xA1W\x80c\xC6\x18a\x81\x11a\0qW\x80c\xDBXw(\x11a\0WW\x80c\xDBXw(\x14a\x03yW\x80c\xE2B\x92N\x14a\x03\x8CW\x80c\xFA\\\xD5l\x14a\x03\xABW_\x80\xFD[\x80c\xC6\x18a\x81\x14a\x03'W\x80c\xCB\xA6s\xA7\x14a\x03ZW_\x80\xFD[\x80c\xA5\xCD\xC8\xFC\x14a\x02\xABW\x80c\xA7\xABI\xBC\x14a\x02\xCAW\x80c\xAE\x80\xC5\x84\x14a\x02\xE9W\x80c\xB1\x1F\x12b\x14a\x03\x08W_\x80\xFD[\x80cQ\xD4h\x15\x11a\0\xF6W\x80co5\xD2\xD2\x11a\0\xDCW\x80co5\xD2\xD2\x14a\x02FW\x80c\x87U0\xFF\x14a\x02yW\x80c\x995\xC8h\x14a\x02\x98W_\x80\xFD[\x80cQ\xD4h\x15\x14a\x02\x12W\x80cZ\xA0\xE9]\x14a\x02'W_\x80\xFD[\x80c\x16&\xBA~\x14a\x011W\x80c)\xBC\xDC\x95\x14a\x01\x86W\x80c6D\xE5\x15\x14a\x01\xD1W\x80cL\x9E\x03\xD3\x14a\x01\xF3W_\x80\xFD[6a\x01-W\0[_\x80\xFD[4\x80\x15a\x01<W_\x80\xFD[Pa\x01Pa\x01K6`\x04a5\x95V[a\x03\xCAV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x91W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01}V[4\x80\x15a\x01\xDCW_\x80\xFD[Pa\x01\xE5a\x04\xD7V[`@Q\x90\x81R` \x01a\x01}V[4\x80\x15a\x01\xFEW_\x80\xFD[Pa\x01\xE5a\x02\r6`\x04a6 V[a\x05\xC6V[a\x02%a\x02 6`\x04a6\xD7V[a\x06gV[\0[4\x80\x15a\x022W_\x80\xFD[Pa\x02%a\x02A6`\x04a7\xE1V[a\t\xE8V[4\x80\x15a\x02QW_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x02\x84W_\x80\xFD[Pa\x01\xE5a\x02\x936`\x04a6 V[a\x0C0V[a\x02%a\x02\xA66`\x04a8?V[a\x0C_V[4\x80\x15a\x02\xB6W_\x80\xFD[Pa\x02%a\x02\xC56`\x04a8\xDDV[a\x0C\x7FV[4\x80\x15a\x02\xD5W_\x80\xFD[Pa\x02%a\x02\xE46`\x04a9\x01V[a\x0C\x8CV[4\x80\x15a\x02\xF4W_\x80\xFD[Pa\x02%a\x03\x036`\x04a9\x9DV[a\x10gV[4\x80\x15a\x03\x13W_\x80\xFD[Pa\x01\xE5a\x03\"6`\x04a9\xF2V[a\x12\xEBV[4\x80\x15a\x032W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x03eW_\x80\xFD[Pa\x02%a\x03t6`\x04a:$V[a\x14\xEAV[a\x02%a\x03\x876`\x04a;\x0BV[a\x18xV[4\x80\x15a\x03\x97W_\x80\xFD[Pa\x01\xE5a\x03\xA66`\x04a;\xC9V[a\x19LV[4\x80\x15a\x03\xB6W_\x80\xFD[Pa\x02%a\x03\xC56`\x04a;\xC9V[a\x1A\x8EV[_\x80a\x03\xD7\x85\x85\x85a\x1BPV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\x04\x83\x01R\x91\x92P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04YW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04}\x91\x90a;\xFBV[\x15a\x04\xABW\x7F\x16&\xBA~5oYy\xDD5Z=+\xFBC\xE8\x04 \xA4\x80\xC3\xB8T\xED\xCE(j\x82\xD7Ihi\x91PPa\x04\xD0V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14a\x05\xA1W`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[_\x7Fh\xB8\xE9M\xC0wE\x82A\xD6\xC8\xD8\x9F\nve\xC7\xCD\xA2\xCF\xE7\x0C\x9E\xB4C~\xFE\xE1f<f\xFEa\x05\xF5` \x84\x01\x84a<\x16V[\x83` \x015\x84`@\x015\x85``\x015\x86`\x80\x015`@Q` \x01a\x06J\x96\x95\x94\x93\x92\x91\x90\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16` \x86\x01R`@\x85\x01\x92\x90\x92R``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x06oa\x1B\xDBV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xECW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x10\x91\x90a;\xFBV[a\x07FW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x87\x015\x88\x15\x80\x15\x90a\x07`WPa\x01`\x88\x015\x89\x11\x15[\x15a\x07\x7FWa\x07|\x89a\x02\0\x8A\x015a\x01`\x8B\x015`\x01a\x1C\x1EV[\x90P[a\x07\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x83\x8B\x8B\x8B\x8B\x8B\x8Ba\x1CiV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x07\xEF`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x08\x01a\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Ra\x08D\x92\x91\x90a\x01`\x8E\x015\x90\x88\x90`\x04\x01a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08[W_\x80\xFD[PZ\xF1\x15\x80\x15a\x08mW=_\x80>=_\xFD[PPPPa\x08\xB4\x88\x8B\x83\x8C_\x14\x80a\x08\x89WPa\x01`\x8C\x015\x8D\x11[a\x08\x93W\x8Ca\x08\x9AV[a\x01`\x8C\x015[\x89\x8C\x8C`\x02a\x08\xAF`@\x8E\x01` \x8F\x01a=aV[a\x1E\x01V[a\x08\xC1`@\x89\x01\x89a=\x7FV[`@Qa\x08\xCF\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\t\t`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a\t\x19`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[a\t+a\x01@\x8D\x01a\x01 \x8E\x01a<\x16V[a\t=a\x01\xE0\x8E\x01a\x01\xC0\x8F\x01a<\x16V[\x8E\x15\x80a\tNWPa\x01`\x8E\x015\x8F\x11[a\tXW\x8Ea\t_V[a\x01@\x8E\x015[a\x02\0\x8F\x015\x88\x14a\tqW\x87a\txV[a\x01\xE0\x8F\x015[\x8F`\xE0\x01` \x81\x01\x90a\t\x8B\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\t\xDD`\x01\x80UV[PPPPPPPPPV[_[a\t\xF4\x82\x80a=\xEFV[\x90P\x81\x10\x15a\x0B\x06W6a\n\x08\x83\x80a=\xEFV[\x83\x81\x81\x10a\n\x18Wa\n\x18a>SV[\x90P` \x02\x81\x01\x90a\n*\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\nH` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xA2W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xC6\x91\x90a;\xFBV[\x15a\n\xFDW`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\t\xEAV[P_[a\x0B\x16` \x83\x01\x83a=\xEFV[\x90P\x81\x10\x15a\x0C+W6a\x0B-` \x84\x01\x84a=\xEFV[\x83\x81\x81\x10a\x0B=Wa\x0B=a>SV[\x90P` \x02\x81\x01\x90a\x0BO\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\x0Bm` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xC7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xEB\x91\x90a;\xFBV[\x15a\x0C\"W`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x0B\tV[PPPV[_\x7F\xAEgk\xF6\x91:\xC2h\x9Bs1)<\x98\x9F\xE7r1$\xFA\xF8\xB5\xD2u\xF0o\xBC\xEB\xC7yP\ta\x05\xF5` \x84\x01\x84a<\x16V[a\x0Ci\x84\x82a\"\x12V[a\x0Cx\x85\x85\x85\x85`\x01\x80a\"\xC9V[PPPPPV[a\x0C\x893\x82a&\x1EV[PV[a\x0C\xBF`@Q\x80`\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[_[\x82\x81\x10\x15a\x10SW6\x84\x84\x83\x81\x81\x10a\x0C\xDCWa\x0C\xDCa>SV[\x90P` \x02\x81\x01\x90a\x0C\xEE\x91\x90a>\x80V[\x90P6_a\x0C\xFF`@\x84\x01\x84a=\x7FV[\x90\x92P\x90P`\x01`\x01`\xA0\x1B\x03\x8B\x16c\xA8\xC4\xBC\x95a\r ` \x86\x01\x86a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\rzW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x9E\x91\x90a;\xFBV[\x15a\x10EW_\x89\x15a\r\xDCW`@Q\x7F}a{\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04\x82\x10a\r\xE8WP\x815[\x7F\xC0:\x9D\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0EVWa\x0E=\x83\x83\x8D\x8Ca&\xC4V[\x86` \x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x90RPa\x10CV[\x7F$:K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0E\xBCWa\x0E\xAB\x83\x83\x8D\x8Ca'\xDAV[\x86``\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x7F}\xC4\xF4X\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0FGWa\x0F\x11\x83\x83\x8D\x8Ca)NV[`\xA0\x88\x01R`\x80\x87\x01\x81\x90R``\x87\x01\x80Qa\x0F.\x90\x83\x90a>\xBCV[\x90RP`\xA0\x86\x01Q` \x87\x01\x80Qa\x0EN\x90\x83\x90a>\xBCV[\x7Fh\x93\x1Bk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0F\xABWa\x0F\x9C\x83\x83\x8D\x8Ca+\xB6V[\x86Q\x87\x90a\x0EN\x90\x83\x90a>\xBCV[\x7F\x0C\x9B\xE7\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x10\x11Wa\x10\0\x83\x83\x8D\x8Ca,\xC0V[\x86`@\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[`@Q\x7F\x05a\xD8\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPP\x80`\x01\x01\x90Pa\x0C\xC1V[Pa\x10^\x84\x82a.)V[PPPPPPPV[`\x03a\x10v` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x10\x87Wa\x10\x87a>\xF4V[\x03a\x10\xECW`\x01`\x01`\xA0\x1B\x03\x83\x16a\x10\xAC\x83a\x10\xA7`@\x85\x01\x85a=\x7FV[a\x1BPV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0C+W`@Q\x7F\xB8\x1DX\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01a\x10\xFB` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\x0CWa\x11\x0Ca>\xF4V[\x03a\x11\xA0W\x7F\x19Ethereum Signed Message:\n32\0\0\0\0_\x90\x81R`\x1C\x83\x90R`<\x90 `\x01`\x01`\xA0\x1B\x03\x84\x16a\x11Z\x82a\x10\xA7`@\x86\x01\x86a=\x7FV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x11\x9AW`@Q\x7FdJ\xE6\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\x02a\x11\xAF` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\xC0Wa\x11\xC0a>\xF4V[\x03a\x12\xB9W\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x84\x16c\x16&\xBA~\x84a\x12\x03`@\x86\x01\x86a=\x7FV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12!\x93\x92\x91\x90a??V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12<W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12`\x91\x90a?XV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x0C+W`@Q\x7F]R\xCB\xE3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F`\xCD@-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xF4a\x04\xD7V[\x7F\xD2\x8E\x80\x9Bp\x8F^\xE3\x8B\xE84}m\x86\x9D\x822I<\tJ\xB2\xDD\xE9\x83i\xE4\x10#i\xA9\x9Da\x13\x1F\x84\x80a=\x7FV[`@Q` \x01a\x130\x92\x91\x90a?\x97V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x84` \x015\x85`@\x01` \x81\x01\x90a\x13^\x91\x90a<\x16V[`@\x80Q` \x81\x01\x95\x90\x95R\x84\x01\x92\x90\x92R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90Ra\x13\xC4`\x80\x85\x01``\x86\x01a<\x16V[a\x13\xD4`\xA0\x86\x01`\x80\x87\x01a<\x16V[a\x13\xE4`\xC0\x87\x01`\xA0\x88\x01a<\x16V[`\xC0\x87\x015`\xE0\x88\x015a\x01\0\x89\x015a\x01 \x8A\x015a\x14\x0Ca\x01`\x8C\x01a\x01@\x8D\x01a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x99\x8A\x16` \x82\x01R\x97\x89\x16\x90\x88\x01R\x94\x87\x16``\x87\x01R`\x80\x86\x01\x93\x90\x93R`\xA0\x85\x01\x91\x90\x91R`\xC0\x84\x01R`\xE0\x83\x01R\x90\x91\x16a\x01\0\x82\x01Ra\x01 \x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x14\x92\x92\x91` \x01a?\xD7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\x06J\x92\x91\x90\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[a\x14\xF2a\x1B\xDBV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15mW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x91\x91\x90a;\xFBV[a\x15\xC7W`@Q\x7F\xC19\xEA\xBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16DW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16h\x91\x90a;\xFBV[a\x16\x9EW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x86\x015\x87\x15\x80\x15\x90a\x16\xB8WPa\x01`\x87\x015\x88\x11\x15[\x15a\x16\xD7Wa\x16\xD4\x88a\x02\0\x89\x015a\x01`\x8A\x015`\x01a\x1C\x1EV[\x90P[a\x17\x08\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x83\x8A\x8A\x8A\x8A\x8A\x8Aa\x1CiV[a\x17E\x87\x8A\x83\x8B\x15\x80a\x17\x1FWPa\x01`\x8B\x015\x8C\x11[a\x17)W\x8Ba\x170V[a\x01`\x8B\x015[\x88\x8B\x8B`\x01a\x08\xAF`@\x8D\x01` \x8E\x01a=aV[a\x17R`@\x88\x01\x88a=\x7FV[`@Qa\x17`\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\x17\x9A`\xA0\x8A\x01`\x80\x8B\x01a<\x16V[a\x17\xAA`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x17\xBCa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[a\x17\xCEa\x01\xE0\x8D\x01a\x01\xC0\x8E\x01a<\x16V[\x8D\x15\x80a\x17\xDFWPa\x01`\x8D\x015\x8E\x11[a\x17\xE9W\x8Da\x17\xF0V[a\x01@\x8D\x015[a\x02\0\x8E\x015\x88\x14a\x18\x02W\x87a\x18\tV[a\x01\xE0\x8E\x015[\x8E`\xE0\x01` \x81\x01\x90a\x18\x1C\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\x18n`\x01\x80UV[PPPPPPPPV[a\x18\x82\x85\x83a\"\x12V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x18\xC1`\x80\x88\x01``\x89\x01a<\x16V[a\x18\xD1`\xA0\x89\x01`\x80\x8A\x01a<\x16V[\x88`\xC0\x015\x85`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x18\xF6\x94\x93\x92\x91\x90a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x19\rW_\x80\xFD[PZ\xF1\x15\x80\x15a\x19\x1FW=_\x80>=_\xFD[PPPPa\x19D\x86\x86\x86\x86`\x02\x89` \x01` \x81\x01\x90a\x19?\x91\x90a=aV[a\"\xC9V[PPPPPPV[_a\x19Ua\x04\xD7V[\x7F\xC9\x94\xD2\xCA\x03u\xD6\xD4sx^\x0C\xE0\xB1\xD2\x03\xF0i\x12\x1B\xAC\x13\x14\xF7,\\\x0F\xE6\x01\xEB9\x10a\x19\x83`@\x85\x01\x85a=\x7FV[`@Q` \x01a\x19\x94\x92\x91\x90a?\x97V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 ``\x85\x015a\x19\xDF`\xA0\x87\x01`\x80\x88\x01a<\x16V[a\x19\xEF`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\xC0\x88\x015a\x1A\x05a\x01\0\x8A\x01`\xE0\x8B\x01a<\x16V[`@\x80Q` \x81\x01\x98\x90\x98R\x87\x01\x95\x90\x95R``\x86\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80\x86\x01R\x81\x16`\xA0\x85\x01R`\xC0\x84\x01\x91\x90\x91R\x16`\xE0\x82\x01Ra\x01\0\x80\x85\x015\x90\x82\x01Ra\x01 \x01`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1Ao\x84a\x01 \x01a\x0C0V[a\x1A|\x85a\x01\xC0\x01a\x05\xC6V[`@Q` \x01a\x14\x92\x93\x92\x91\x90a?\xEBV[a\x01\xA0\x81\x015a\x1A\xA8a\x01\x80\x83\x015a\x01`\x84\x015a>\xBCV[a\x1A\xB2\x91\x90a>\xBCV[a\x01@\x82\x015\x14a\x1A\xEFW`@Q\x7F\xC0Cw\xD3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x81\x015a\x1B\ta\x02 \x83\x015a\x02\0\x84\x015a>\xBCV[a\x1B\x13\x91\x90a>\xBCV[a\x01\xE0\x82\x015\x14a\x0C\x89W`@Q\x7F\x87v0\xBE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x91\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa.\xD6\x92PPPV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1B\xD3W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x94\x93PPPPV[`\x02`\x01T\x03a\x1C\x17W`@Q\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01UV[_a\x1CKa\x1C+\x83a/\0V[\x80\x15a\x1CFWP_\x84\x80a\x1CAWa\x1CAa@\x08V[\x86\x88\t\x11[\x15\x15\x90V[a\x1CV\x86\x86\x86a/,V[a\x1C`\x91\x90a>\xBCV[\x95\x94PPPPPV[_a\x1Cs\x87a\x19LV[\x90Pa\x1C\x80\x89\x82\x85a\x10gV[a\x1C\x90`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1C\xC7Wa\x1C\xC2a\x1C\xBB`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x82\x84a\x10gV[a\x1D\x0EV[a\x1C\xD4`@\x83\x01\x83a=\x7FV[\x90P_\x03a\x1D\x0EW`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D+a\x1D!`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x88``\x015a&\x1EV[\x86`\xC0\x015B\x11\x15a\x1DiW`@Q\x7F\x13=\xF0)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x88\x11\x80\x15a\x1D|WP\x86a\x01\0\x015\x88\x10[\x15a\x1D\xB3W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\xBC\x87a\x1A\x8EV[a\x1D\xC6\x8A\x85a\t\xE8V[a\x1D\xE7\x8A\x8A_\x8B\x11\x80\x15a\x1D\xDFWPa\x02\0\x8A\x015\x8B\x14\x15[\x8A\x8A\x8Aa\x0C\x8CV[a\x1D\xF5\x89\x88``\x015a&\x1EV[PPPPPPPPPPV[a\x1E\x13a\x1E\x0E\x86\x80a=\xEFV[a0\x01V[_a\x1E(a\x01\x80\x8B\x015a\x01\xA0\x8C\x015a>\xBCV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Ew\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x010`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1E\xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x86`\x02\x81\x11\x15a\x1E\xD0Wa\x1E\xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1F\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a\x1F\x18W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Fi\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\xE0\x01` \x81\x01\x90a\x1F\x8A\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1F\xAE\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A\x81R` \x01\x86`\x02\x81\x11\x15a\x1F\xD4Wa\x1F\xD4a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F\xF3\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a \nW_\x80\xFD[PZ\xF1\x15\x80\x15a \x1CW=_\x80>=_\xFD[PPPPa *\x85\x85a0\x01V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8C`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\x80\x01` \x81\x01\x90a \x86\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01\xC0\x01_\x01` \x81\x01\x90a \xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8B\x81R` \x01\x85`\x02\x81\x11\x15a \xD0Wa \xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a!\x18W=_\x80>=_\xFD[Pa!.\x92Pa\x1E\x0E\x91PP` \x88\x01\x88a=\xEFV[_a!Aa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!\x9EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\xC2\x91\x90a@\xB4V[\x90P\x80\x15a\"\x05Wa\"\x05a!\xDEa\x01\0\x8D\x01`\xE0\x8E\x01a<\x16V[\x82\x8Da\x01 \x01_\x01` \x81\x01\x90a!\xF5\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a19V[PPPPPPPPPPPV[a\"\"`\x80\x83\x01``\x84\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\"aWa\"\\a\"M`\x80\x84\x01``\x85\x01a<\x16V[a\"V\x84a\x12\xEBV[\x83a\x10gV[a\"\xA8V[a\"n`@\x82\x01\x82a=\x7FV[\x90P_\x03a\"\xA8W`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\"\xC5a\"\xBB`\x80\x84\x01``\x85\x01a<\x16V[\x83` \x015a&\x1EV[PPV[`\xE0\x85\x015\x83\x15\x80\x15\x90a\"\xE0WP\x85`\xC0\x015\x84\x10[\x15a\"\xFDWa\"\xFA\x84\x87`\xE0\x015\x88`\xC0\x015`\x01a\x1C\x1EV[\x90P[a#\t\x87\x82\x88\x88a1\xB9V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x89``\x01` \x81\x01\x90a#V\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#va\x01`\x8B\x01a\x01@\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#\x94`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x87\x15\x80a#\xB2WP\x89`\xC0\x015\x88\x11[a#\xBCW\x87a#\xC2V[\x89`\xC0\x015[\x81R` \x01\x86`\x02\x81\x11\x15a#\xD9Wa#\xD9a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\xF8\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\x0FW_\x80\xFD[PZ\xF1\x15\x80\x15a$!W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`@\x01` \x81\x01\x90a$\x81\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a$\x9F`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x02\x81\x11\x15a$\xC5Wa$\xC5a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a$\xE4\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\xFBW_\x80\xFD[PZ\xF1\x15\x80\x15a%\rW=_\x80>=_\xFD[Pa%\x1E\x92P\x88\x91P\x81\x90Pa=\x7FV[`@Qa%,\x92\x91\x90a=\xE0V[`@Q\x80\x91\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6\x87`@\x01` \x81\x01\x90a%h\x91\x90a<\x16V[a%x`\x80\x8A\x01``\x8B\x01a<\x16V[a%\x88`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a%\x98`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[\x89\x15\x80a%\xA8WP\x8B`\xC0\x015\x8A\x11[a%\xB2W\x89a%\xB8V[\x8B`\xC0\x015[\x87\x8Da\x01@\x01` \x81\x01\x90a%\xCD\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x84\x84R\x90\x91R\x90 T`\xFF\x16\x15a&yW`@Q\x7F\xBC\r\xA7\xD6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x83R\x92\x90R \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16`\x01\x17\x90UV[_\x80\x80\x80a&\xD5\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a&\xE2\x91\x90a@\xF2V[P\x91\x94P\x92P\x90Pa&\xFCa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a'FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a'\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x97\x96PPPPPPPV[_\x80\x80\x80\x80a'\xEC\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a'\xF9\x91\x90aABV[\x92\x96P\x90\x94P\x92P\x90Pa(\x15a\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a(_W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a(\xAAW`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a(\xBA`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a)\x04W`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x98\x97PPPPPPPPV[_\x80_\x80_\x80_\x80_\x8C\x8C`\x04\x90\x80\x92a)j\x93\x92\x91\x90a@\xCBV[\x81\x01\x90a)w\x91\x90aA\x90V[\x95\x9CP\x93\x9AP\x91\x98P\x96P\x94P\x92P\x90Pa)\x9Aa\x01\xE0\x8B\x01a\x01\xC0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a)\xE4W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85`\x01`\x01`\xA0\x1B\x03\x16\x8B`\x01`\x01`\xA0\x1B\x03\x16\x14a*/W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x160\x14a*qW`@Q\x7F\x81T7K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x81`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a*\xCBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x8A\x015\x83\x14a+\tW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+\x1Ba\x01@\x8B\x01a\x01 \x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a+eW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x8A\x015\x81\x14a+\xA3W`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x9C\x91\x9BP\x90\x99PPPPPPPPPPV[_\x80\x80\x80a+\xC7\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a+\xD4\x91\x90aB\x0FV[\x91\x94P\x92P\x90Pa+\xEDa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a,7W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a,\x82W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\x80\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80\x80\x80a,\xD2\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a,\xDF\x91\x90aBMV[P\x92\x96P\x90\x94P\x92P\x90Pa,\xFCa\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a-FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a-\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a-\xA1`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a-\xEBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02 \x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01\x80\x83\x015\x14\x15\x80a.GWP` \x81\x01Qa\x01\xA0\x83\x015\x14\x15[\x15a.~W`@Q\x7FJU\xDA \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x81\x01Qa\x02 \x83\x015\x14\x15\x80a.\x9FWP``\x81\x01Qa\x02@\x83\x015\x14\x15[\x15a\"\xC5W`@Q\x7Fw\xA5\x92\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x80a.\xE4\x86\x86a2\\V[\x92P\x92P\x92Pa.\xF4\x82\x82a2\xA5V[P\x90\x91PP[\x92\x91PPV[_`\x02\x82`\x03\x81\x11\x15a/\x15Wa/\x15a>\xF4V[a/\x1F\x91\x90aB\xB1V[`\xFF\x16`\x01\x14\x90P\x91\x90PV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a/\x7FW\x83\x82\x81a/uWa/ua@\x08V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a/\x96Wa/\x96`\x03\x85\x15\x02`\x11\x18a3\xADV[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP\x93\x92PPPV[_[\x81\x81\x10\x15a\x0C+W6\x83\x83\x83\x81\x81\x10a0\x1EWa0\x1Ea>SV[\x90P` \x02\x81\x01\x90a00\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a0i` \x83\x01\x83a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x03a0\xA9W`@Q\x7Fy\xA1\xBF\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a0\xB2\x81a3\xBEV[a0\xBF` \x82\x01\x82a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a0\xF7\x84a4\x01V[`@\x80Q\x92\x83R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA2P`\x01\x01a0\x03V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C+\x90\x84\x90a4*V[_\x83\x11\x80\x15a1\xCCWP\x81a\x01\0\x015\x83\x10[\x15a2\x03W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2\x10\x84a\"V\x84a\x12\xEBV[a2\x1E\x84\x83` \x015a&\x1EV[B\x82a\x01 \x015\x11a\x11\x9AW`@Q\x7F\xC5hs\xBA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x83Q`A\x03a2\x93W` \x84\x01Q`@\x85\x01Q``\x86\x01Q_\x1Aa2\x85\x88\x82\x85\x85a4\xAFV[\x95P\x95P\x95PPPPa2\x9EV[PP\x81Q_\x91P`\x02\x90[\x92P\x92P\x92V[_\x82`\x03\x81\x11\x15a2\xB8Wa2\xB8a>\xF4V[\x03a2\xC1WPPV[`\x01\x82`\x03\x81\x11\x15a2\xD5Wa2\xD5a>\xF4V[\x03a3\x0CW`@Q\x7F\xF6E\xEE\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x82`\x03\x81\x11\x15a3 Wa3 a>\xF4V[\x03a3_W`@Q\x7F\xFC\xE6\x98\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x03\x82`\x03\x81\x11\x15a3sWa3sa>\xF4V[\x03a\"\xC5W`@Q\x7F\xD7\x8B\xCE\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01a3VV[cNH{q_R\x80` R`$`\x1C\xFD[_a3\xCC` \x83\x01\x83a<\x16V[\x90P` \x82\x0156_a3\xE2`@\x86\x01\x86a=\x7FV[\x91P\x91P`@Q\x81\x83\x827_\x80\x83\x83\x87\x89Z\xF1a\x19DW=_\x80>=_\xFD[_6\x81a4\x11`@\x85\x01\x85a=\x7FV[\x90\x92P\x90P`\x04\x81\x10a4#W\x815\x92P[PP\x91\x90PV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a4IW`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a4`W\x80`\x01\x14\x15a4mV[`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x11\x9AW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a3VV[_\x80\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x84\x11\x15a4\xE8WP_\x91P`\x03\x90P\x82a5\x8BV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x8A\x90R`\xFF\x89\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x87\x90R`\x80\x81\x01\x86\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a59W=_\x80>=_\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a5\x82WP_\x92P`\x01\x91P\x82\x90Pa5\x8BV[\x92P_\x91P\x81\x90P[\x94P\x94P\x94\x91PPV[_\x80_`@\x84\x86\x03\x12\x15a5\xA7W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a5\xC5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a5\xD8W_\x80\xFD[\x815\x81\x81\x11\x15a5\xE6W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a5\xF7W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[_`\xA0\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[P\x91\x90PV[_`\xA0\x82\x84\x03\x12\x15a60W_\x80\xFD[a\x04\xD0\x83\x83a6\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x89W_\x80\xFD[\x805a6Y\x81a6:V[\x91\x90PV[_a\x02`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80\x83`\x1F\x84\x01\x12a6\x7FW_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x96W_\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a6\xB0W_\x80\xFD[\x92P\x92\x90PV[_`@\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_``\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a6\xF0W_\x80\xFD[a6\xF9\x8Aa6NV[\x98P` \x8A\x015\x97P`@\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a7\x1CW_\x80\xFD[a7(\x8D\x83\x8E\x01a6^V[\x98P``\x8C\x015\x91P\x80\x82\x11\x15a7=W_\x80\xFD[a7I\x8D\x83\x8E\x01a6oV[\x90\x98P\x96P`\x80\x8C\x015\x91P\x80\x82\x11\x15a7aW_\x80\xFD[a7m\x8D\x83\x8E\x01a6\xB7V[\x95P`\xA0\x8C\x015\x91P\x80\x82\x11\x15a7\x82W_\x80\xFD[a7\x8E\x8D\x83\x8E\x01a6\xC7V[\x94P`\xC0\x8C\x015\x91P\x80\x82\x11\x15a7\xA3W_\x80\xFD[a7\xAF\x8D\x83\x8E\x01a6\xC7V[\x93P`\xE0\x8C\x015\x91P\x80\x82\x11\x15a7\xC4W_\x80\xFD[Pa7\xD1\x8C\x82\x8D\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[_\x80`@\x83\x85\x03\x12\x15a7\xF2W_\x80\xFD[\x825a7\xFD\x81a6:V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x18W_\x80\xFD[a8$\x85\x82\x86\x01a6\xB7V[\x91PP\x92P\x92\x90PV[_a\x01`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15a8SW_\x80\xFD[\x855a8^\x81a6:V[\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a8zW_\x80\xFD[a8\x86\x89\x83\x8A\x01a8.V[\x95P`@\x88\x015\x91P\x80\x82\x11\x15a8\x9BW_\x80\xFD[a8\xA7\x89\x83\x8A\x01a6\xC7V[\x94P``\x88\x015\x93P`\x80\x88\x015\x91P\x80\x82\x11\x15a8\xC3W_\x80\xFD[Pa8\xD0\x88\x82\x89\x01a6\xC7V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_` \x82\x84\x03\x12\x15a8\xEDW_\x80\xFD[P5\x91\x90PV[\x80\x15\x15\x81\x14a\x0C\x89W_\x80\xFD[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a9\x16W_\x80\xFD[\x865a9!\x81a6:V[\x95P` \x87\x015a91\x81a6:V[\x94P`@\x87\x015a9A\x81a8\xF4V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a9]W_\x80\xFD[a9i\x8A\x83\x8B\x01a6^V[\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a9~W_\x80\xFD[Pa9\x8B\x89\x82\x8A\x01a6oV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a9\xAFW_\x80\xFD[\x835a9\xBA\x81a6:V[\x92P` \x84\x015\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9\xDCW_\x80\xFD[a9\xE8\x86\x82\x87\x01a6\xC7V[\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a:\x02W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a:\x18W_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a8.V[_\x80_\x80_\x80_\x80`\xE0\x89\x8B\x03\x12\x15a:;W_\x80\xFD[a:D\x89a6NV[\x97P` \x89\x015\x96P`@\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a:gW_\x80\xFD[a:s\x8C\x83\x8D\x01a6^V[\x97P``\x8B\x015\x91P\x80\x82\x11\x15a:\x88W_\x80\xFD[a:\x94\x8C\x83\x8D\x01a6oV[\x90\x97P\x95P`\x80\x8B\x015\x91P\x80\x82\x11\x15a:\xACW_\x80\xFD[a:\xB8\x8C\x83\x8D\x01a6\xB7V[\x94P`\xA0\x8B\x015\x91P\x80\x82\x11\x15a:\xCDW_\x80\xFD[a:\xD9\x8C\x83\x8D\x01a6\xC7V[\x93P`\xC0\x8B\x015\x91P\x80\x82\x11\x15a:\xEEW_\x80\xFD[Pa:\xFB\x8B\x82\x8C\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[_\x80_\x80_\x80`\xC0\x87\x89\x03\x12\x15a; W_\x80\xFD[a;)\x87a6NV[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a;EW_\x80\xFD[a;Q\x8A\x83\x8B\x01a8.V[\x96P`@\x89\x015\x91P\x80\x82\x11\x15a;fW_\x80\xFD[a;r\x8A\x83\x8B\x01a6\xC7V[\x95P``\x89\x015\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a;\x8EW_\x80\xFD[a;\x9A\x8A\x83\x8B\x01a6\xC7V[\x93P`\xA0\x89\x015\x91P\x80\x82\x11\x15a;\xAFW_\x80\xFD[Pa;\xBC\x89\x82\x8A\x01a6\xC7V[\x91PP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a;\xD9W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a;\xEFW_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a6^V[_` \x82\x84\x03\x12\x15a<\x0BW_\x80\xFD[\x81Qa\x04\xD0\x81a8\xF4V[_` \x82\x84\x03\x12\x15a<&W_\x80\xFD[\x815a\x04\xD0\x81a6:V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[\x805e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a6YW_\x80\xFD[_`\x01`\x01`\xA0\x1B\x03\x80\x87\x16\x83R\x80\x86\x16` \x84\x01RP\x83`@\x83\x01R`\x80``\x83\x01R\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a<\xE2W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a<\xFEW_\x80\xFD[\x806\x03\x82\x13\x15a=\x0CW_\x80\xFD[```\x80\x85\x01Ra=!`\xE0\x85\x01\x82\x84a<1V[\x91PPa=0` \x85\x01a<xV[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16`\xA0\x86\x01R\x80a=L`@\x88\x01a<xV[\x16`\xC0\x86\x01RPP\x80\x91PP\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a=qW_\x80\xFD[\x815`\x03\x81\x10a\x04\xD0W_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xB2W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xCCW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a>\"W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a><W_\x80\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a>\xB2W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a.\xFAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a?1W_\x80\xFD[\x815`\x04\x81\x10a\x04\xD0W_\x80\xFD[\x83\x81R`@` \x82\x01R_a\x1C``@\x83\x01\x84\x86a<1V[_` \x82\x84\x03\x12\x15a?hW_\x80\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x04\xD0W_\x80\xFD[` \x81R_a\x1B\xD3` \x83\x01\x84\x86a<1V[_\x81Q_[\x81\x81\x10\x15a?\xC9W` \x81\x85\x01\x81\x01Q\x86\x83\x01R\x01a?\xAFV[P_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x1B\xD3a?\xE5\x83\x86a?\xAAV[\x84a?\xAAV[_a?\xF6\x82\x86a?\xAAV[\x93\x84RPP` \x82\x01R`@\x01\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_`\xA0\x82\x01\x90P`\x01`\x01`\xA0\x1B\x03\x80\x84Q\x16\x83R\x80` \x85\x01Q\x16` \x84\x01R\x80`@\x85\x01Q\x16`@\x84\x01RP``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x03\x81\x10a@\xA7W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x80`\x80\x84\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a@\xC4W_\x80\xFD[PQ\x91\x90PV[_\x80\x85\x85\x11\x15a@\xD9W_\x80\xFD[\x83\x86\x11\x15a@\xE5W_\x80\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aA\x05W_\x80\xFD[\x845aA\x10\x81a6:V[\x93P` \x85\x015aA \x81a6:V[\x92P`@\x85\x015\x91P``\x85\x015aA7\x81a8\xF4V[\x93\x96\x92\x95P\x90\x93PPV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aAUW_\x80\xFD[\x845aA`\x81a6:V[\x93P` \x85\x015aAp\x81a6:V[\x92P`@\x85\x015aA\x80\x81a6:V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_\x80_\x80_\x80_`\xE0\x88\x8A\x03\x12\x15aA\xA6W_\x80\xFD[\x875aA\xB1\x81a6:V[\x96P` \x88\x015aA\xC1\x81a6:V[\x95P`@\x88\x015aA\xD1\x81a6:V[\x94P``\x88\x015aA\xE1\x81a6:V[\x93P`\x80\x88\x015\x92P`\xA0\x88\x015aA\xF8\x81a6:V[\x80\x92PP`\xC0\x88\x015\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[_\x80_``\x84\x86\x03\x12\x15aB!W_\x80\xFD[\x835aB,\x81a6:V[\x92P` \x84\x015aB<\x81a6:V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15aBaW_\x80\xFD[\x855aBl\x81a6:V[\x94P` \x86\x015aB|\x81a6:V[\x93P`@\x86\x015aB\x8C\x81a6:V[\x92P``\x86\x015\x91P`\x80\x86\x015aB\xA3\x81a8\xF4V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_`\xFF\x83\x16\x80aB\xE8W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x9B\xE5\x8A\xCA\xDA50a\xA2\xA2\x02\xCCp\x11\xF3\xC9\x13\x93\xE0\xF2\xE3\x05\xE9 $E\xB0B\xFCJL\xE6dsolcC\0\x08\x17\x003`\xC0`@R4\x80\x15a\0\x0FW_\x80\xFD[P`@Qa\tc8\x03\x80a\tc\x839\x81\x01`@\x81\x90Ra\0.\x91a\0`V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x91V[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0[W_\x80\xFD[\x91\x90PV[_\x80`@\x83\x85\x03\x12\x15a\0qW_\x80\xFD[a\0z\x83a\0EV[\x91Pa\0\x88` \x84\x01a\0EV[\x90P\x92P\x92\x90PV[`\x80Q`\xA0Qa\x08\x9Ea\0\xC5_9_\x81\x81`H\x01R\x81\x81a\x01\xF2\x01Ra\x03\x81\x01R_\x81\x81`\xD3\x01Ra\x03'\x01Ra\x08\x9E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cj\xFD\xD8P\x14a\0CW\x80c\xB5\x19\xD3i\x14a\0\x93W\x80c\xBC\x11x\xE6\x14a\0\xA8W[_\x80\xFD[a\0j\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xA6a\0\xA16`\x04a\x06\nV[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\x06HV[a\x03\x0FV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81\x14a\x01+W`@Q\x7F|!O\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82\x015\x15a\x01\xAFW`\x01a\x01G`\xA0\x84\x01`\x80\x85\x01a\x06\xDDV[`\x02\x81\x11\x15a\x01XWa\x01Xa\x06\xB0V[\x03a\x01\xB3Wa\x01\xAFa\x01m` \x84\x01\x84a\x07\x02V[a\x01}`@\x85\x01` \x86\x01a\x07\x02V[``\x85\x01\x805\x90a\x01\x91\x90`@\x88\x01a\x07\x02V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x04\xCCV[PPV[`\x02a\x01\xC5`\xA0\x84\x01`\x80\x85\x01a\x06\xDDV[`\x02\x81\x11\x15a\x01\xD6Wa\x01\xD6a\x06\xB0V[\x03a\x02\xDDWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c6\xC7\x85\x16a\x02$` \x85\x01\x85a\x07\x02V[a\x024`@\x86\x01` \x87\x01a\x07\x02V[``\x86\x01\x805\x90a\x02H\x90`@\x89\x01a\x07\x02V[`@Q`\xE0\x86\x90\x1B\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16`\x04\x82\x01R\x92\x84\x16`$\x84\x01R\x90\x83\x16`D\x83\x01R\x90\x91\x16`d\x82\x01R`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xC3W_\x80\xFD[PZ\xF1\x15\x80\x15a\x02\xD5W=_\x80>=_\xFD[PPPPPPV[`@Q\x7F\xC7\x9A\xAAD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81\x14a\x03\x7FW`@Q\x7F|!O\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c+g\xB5p\x86`@Q\x80``\x01`@R\x80`@Q\x80`\x80\x01`@R\x80\x8As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x88`@\x01` \x81\x01\x90a\x04\x1D\x91\x90a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x88` \x01` \x81\x01\x90a\x04=\x91\x90a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90R\x81R0` \x82\x01R`@\x90\x81\x01\x90a\x04e\x90``\x89\x01\x90\x89\x01a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90Ra\x04y\x86\x80a\x07@V[`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x98\x94\x93\x92\x91\x90a\x07\xA8V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xAFW_\x80\xFD[PZ\xF1\x15\x80\x15a\x04\xC1W=_\x80>=_\xFD[PPPPPPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x05a\x90\x85\x90a\x05gV[PPPPV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a\x05\x86W`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a\x05\x9DW\x80`\x01\x14\x15a\x05\xB7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16;\x15[\x15a\x05aW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`\x04\x82\x01R`$\x01`@Q\x80\x91\x03\x90\xFD[_`\xA0\x82\x84\x03\x12\x15a\x06\x1AW_\x80\xFD[P\x91\x90PV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06CW_\x80\xFD[\x91\x90PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15a\x06[W_\x80\xFD[a\x06d\x85a\x06 V[\x93Pa\x06r` \x86\x01a\x06 V[\x92P`@\x85\x015\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x94W_\x80\xFD[\x85\x01``\x81\x88\x03\x12\x15a\x06\xA5W_\x80\xFD[\x93\x96\x92\x95P\x90\x93PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x06\xEDW_\x80\xFD[\x815`\x03\x81\x10a\x06\xFBW_\x80\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x07\x12W_\x80\xFD[a\x06\xFB\x82a\x06 V[_` \x82\x84\x03\x12\x15a\x07+W_\x80\xFD[\x815e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06\xFBW_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x07sW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x07\x8DW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x07\xA1W_\x80\xFD[\x92P\x92\x90PV[_a\x01\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16\x84R\x86Q\x81\x81Q\x16` \x86\x01R\x81` \x82\x01Q\x16`@\x86\x01R`@\x81\x01Qe\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16``\x88\x01R\x80``\x84\x01Q\x16`\x80\x88\x01RPPP\x80` \x88\x01Q\x16`\xA0\x85\x01RP`@\x86\x01Q`\xC0\x84\x01R\x80`\xE0\x84\x01R\x83\x81\x84\x01RPa\x01 \x83\x85\x82\x85\x017_\x83\x85\x01\x82\x01R`\x1F\x90\x93\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x90\x91\x01\x90\x91\x01\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xF3V_e\x89P\x02v\xFC\xBBo\xB3=>\xE3\xB54\xD9Vl['2\xFE\x10\xA6\x03\x9Bu<:\x07dsolcC\0\x08\x17\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`\x046\x10a\x01&W_5`\xE0\x1C\x80c\xA5\xCD\xC8\xFC\x11a\0\xA1W\x80c\xC6\x18a\x81\x11a\0qW\x80c\xDBXw(\x11a\0WW\x80c\xDBXw(\x14a\x03yW\x80c\xE2B\x92N\x14a\x03\x8CW\x80c\xFA\\\xD5l\x14a\x03\xABW_\x80\xFD[\x80c\xC6\x18a\x81\x14a\x03'W\x80c\xCB\xA6s\xA7\x14a\x03ZW_\x80\xFD[\x80c\xA5\xCD\xC8\xFC\x14a\x02\xABW\x80c\xA7\xABI\xBC\x14a\x02\xCAW\x80c\xAE\x80\xC5\x84\x14a\x02\xE9W\x80c\xB1\x1F\x12b\x14a\x03\x08W_\x80\xFD[\x80cQ\xD4h\x15\x11a\0\xF6W\x80co5\xD2\xD2\x11a\0\xDCW\x80co5\xD2\xD2\x14a\x02FW\x80c\x87U0\xFF\x14a\x02yW\x80c\x995\xC8h\x14a\x02\x98W_\x80\xFD[\x80cQ\xD4h\x15\x14a\x02\x12W\x80cZ\xA0\xE9]\x14a\x02'W_\x80\xFD[\x80c\x16&\xBA~\x14a\x011W\x80c)\xBC\xDC\x95\x14a\x01\x86W\x80c6D\xE5\x15\x14a\x01\xD1W\x80cL\x9E\x03\xD3\x14a\x01\xF3W_\x80\xFD[6a\x01-W\0[_\x80\xFD[4\x80\x15a\x01<W_\x80\xFD[Pa\x01Pa\x01K6`\x04a5\x95V[a\x03\xCAV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x91W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01}V[4\x80\x15a\x01\xDCW_\x80\xFD[Pa\x01\xE5a\x04\xD7V[`@Q\x90\x81R` \x01a\x01}V[4\x80\x15a\x01\xFEW_\x80\xFD[Pa\x01\xE5a\x02\r6`\x04a6 V[a\x05\xC6V[a\x02%a\x02 6`\x04a6\xD7V[a\x06gV[\0[4\x80\x15a\x022W_\x80\xFD[Pa\x02%a\x02A6`\x04a7\xE1V[a\t\xE8V[4\x80\x15a\x02QW_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x02\x84W_\x80\xFD[Pa\x01\xE5a\x02\x936`\x04a6 V[a\x0C0V[a\x02%a\x02\xA66`\x04a8?V[a\x0C_V[4\x80\x15a\x02\xB6W_\x80\xFD[Pa\x02%a\x02\xC56`\x04a8\xDDV[a\x0C\x7FV[4\x80\x15a\x02\xD5W_\x80\xFD[Pa\x02%a\x02\xE46`\x04a9\x01V[a\x0C\x8CV[4\x80\x15a\x02\xF4W_\x80\xFD[Pa\x02%a\x03\x036`\x04a9\x9DV[a\x10gV[4\x80\x15a\x03\x13W_\x80\xFD[Pa\x01\xE5a\x03\"6`\x04a9\xF2V[a\x12\xEBV[4\x80\x15a\x032W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x03eW_\x80\xFD[Pa\x02%a\x03t6`\x04a:$V[a\x14\xEAV[a\x02%a\x03\x876`\x04a;\x0BV[a\x18xV[4\x80\x15a\x03\x97W_\x80\xFD[Pa\x01\xE5a\x03\xA66`\x04a;\xC9V[a\x19LV[4\x80\x15a\x03\xB6W_\x80\xFD[Pa\x02%a\x03\xC56`\x04a;\xC9V[a\x1A\x8EV[_\x80a\x03\xD7\x85\x85\x85a\x1BPV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\x04\x83\x01R\x91\x92P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04YW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04}\x91\x90a;\xFBV[\x15a\x04\xABW\x7F\x16&\xBA~5oYy\xDD5Z=+\xFBC\xE8\x04 \xA4\x80\xC3\xB8T\xED\xCE(j\x82\xD7Ihi\x91PPa\x04\xD0V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14a\x05\xA1W`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[_\x7Fh\xB8\xE9M\xC0wE\x82A\xD6\xC8\xD8\x9F\nve\xC7\xCD\xA2\xCF\xE7\x0C\x9E\xB4C~\xFE\xE1f<f\xFEa\x05\xF5` \x84\x01\x84a<\x16V[\x83` \x015\x84`@\x015\x85``\x015\x86`\x80\x015`@Q` \x01a\x06J\x96\x95\x94\x93\x92\x91\x90\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16` \x86\x01R`@\x85\x01\x92\x90\x92R``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x06oa\x1B\xDBV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xECW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x10\x91\x90a;\xFBV[a\x07FW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x87\x015\x88\x15\x80\x15\x90a\x07`WPa\x01`\x88\x015\x89\x11\x15[\x15a\x07\x7FWa\x07|\x89a\x02\0\x8A\x015a\x01`\x8B\x015`\x01a\x1C\x1EV[\x90P[a\x07\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x83\x8B\x8B\x8B\x8B\x8B\x8Ba\x1CiV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x07\xEF`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x08\x01a\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Ra\x08D\x92\x91\x90a\x01`\x8E\x015\x90\x88\x90`\x04\x01a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08[W_\x80\xFD[PZ\xF1\x15\x80\x15a\x08mW=_\x80>=_\xFD[PPPPa\x08\xB4\x88\x8B\x83\x8C_\x14\x80a\x08\x89WPa\x01`\x8C\x015\x8D\x11[a\x08\x93W\x8Ca\x08\x9AV[a\x01`\x8C\x015[\x89\x8C\x8C`\x02a\x08\xAF`@\x8E\x01` \x8F\x01a=aV[a\x1E\x01V[a\x08\xC1`@\x89\x01\x89a=\x7FV[`@Qa\x08\xCF\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\t\t`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a\t\x19`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[a\t+a\x01@\x8D\x01a\x01 \x8E\x01a<\x16V[a\t=a\x01\xE0\x8E\x01a\x01\xC0\x8F\x01a<\x16V[\x8E\x15\x80a\tNWPa\x01`\x8E\x015\x8F\x11[a\tXW\x8Ea\t_V[a\x01@\x8E\x015[a\x02\0\x8F\x015\x88\x14a\tqW\x87a\txV[a\x01\xE0\x8F\x015[\x8F`\xE0\x01` \x81\x01\x90a\t\x8B\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\t\xDD`\x01\x80UV[PPPPPPPPPV[_[a\t\xF4\x82\x80a=\xEFV[\x90P\x81\x10\x15a\x0B\x06W6a\n\x08\x83\x80a=\xEFV[\x83\x81\x81\x10a\n\x18Wa\n\x18a>SV[\x90P` \x02\x81\x01\x90a\n*\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\nH` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xA2W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xC6\x91\x90a;\xFBV[\x15a\n\xFDW`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\t\xEAV[P_[a\x0B\x16` \x83\x01\x83a=\xEFV[\x90P\x81\x10\x15a\x0C+W6a\x0B-` \x84\x01\x84a=\xEFV[\x83\x81\x81\x10a\x0B=Wa\x0B=a>SV[\x90P` \x02\x81\x01\x90a\x0BO\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\x0Bm` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xC7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xEB\x91\x90a;\xFBV[\x15a\x0C\"W`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x0B\tV[PPPV[_\x7F\xAEgk\xF6\x91:\xC2h\x9Bs1)<\x98\x9F\xE7r1$\xFA\xF8\xB5\xD2u\xF0o\xBC\xEB\xC7yP\ta\x05\xF5` \x84\x01\x84a<\x16V[a\x0Ci\x84\x82a\"\x12V[a\x0Cx\x85\x85\x85\x85`\x01\x80a\"\xC9V[PPPPPV[a\x0C\x893\x82a&\x1EV[PV[a\x0C\xBF`@Q\x80`\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[_[\x82\x81\x10\x15a\x10SW6\x84\x84\x83\x81\x81\x10a\x0C\xDCWa\x0C\xDCa>SV[\x90P` \x02\x81\x01\x90a\x0C\xEE\x91\x90a>\x80V[\x90P6_a\x0C\xFF`@\x84\x01\x84a=\x7FV[\x90\x92P\x90P`\x01`\x01`\xA0\x1B\x03\x8B\x16c\xA8\xC4\xBC\x95a\r ` \x86\x01\x86a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\rzW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x9E\x91\x90a;\xFBV[\x15a\x10EW_\x89\x15a\r\xDCW`@Q\x7F}a{\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04\x82\x10a\r\xE8WP\x815[\x7F\xC0:\x9D\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0EVWa\x0E=\x83\x83\x8D\x8Ca&\xC4V[\x86` \x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x90RPa\x10CV[\x7F$:K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0E\xBCWa\x0E\xAB\x83\x83\x8D\x8Ca'\xDAV[\x86``\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x7F}\xC4\xF4X\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0FGWa\x0F\x11\x83\x83\x8D\x8Ca)NV[`\xA0\x88\x01R`\x80\x87\x01\x81\x90R``\x87\x01\x80Qa\x0F.\x90\x83\x90a>\xBCV[\x90RP`\xA0\x86\x01Q` \x87\x01\x80Qa\x0EN\x90\x83\x90a>\xBCV[\x7Fh\x93\x1Bk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0F\xABWa\x0F\x9C\x83\x83\x8D\x8Ca+\xB6V[\x86Q\x87\x90a\x0EN\x90\x83\x90a>\xBCV[\x7F\x0C\x9B\xE7\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x10\x11Wa\x10\0\x83\x83\x8D\x8Ca,\xC0V[\x86`@\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[`@Q\x7F\x05a\xD8\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPP\x80`\x01\x01\x90Pa\x0C\xC1V[Pa\x10^\x84\x82a.)V[PPPPPPPV[`\x03a\x10v` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x10\x87Wa\x10\x87a>\xF4V[\x03a\x10\xECW`\x01`\x01`\xA0\x1B\x03\x83\x16a\x10\xAC\x83a\x10\xA7`@\x85\x01\x85a=\x7FV[a\x1BPV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0C+W`@Q\x7F\xB8\x1DX\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01a\x10\xFB` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\x0CWa\x11\x0Ca>\xF4V[\x03a\x11\xA0W\x7F\x19Ethereum Signed Message:\n32\0\0\0\0_\x90\x81R`\x1C\x83\x90R`<\x90 `\x01`\x01`\xA0\x1B\x03\x84\x16a\x11Z\x82a\x10\xA7`@\x86\x01\x86a=\x7FV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x11\x9AW`@Q\x7FdJ\xE6\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\x02a\x11\xAF` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\xC0Wa\x11\xC0a>\xF4V[\x03a\x12\xB9W\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x84\x16c\x16&\xBA~\x84a\x12\x03`@\x86\x01\x86a=\x7FV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12!\x93\x92\x91\x90a??V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12<W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12`\x91\x90a?XV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x0C+W`@Q\x7F]R\xCB\xE3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F`\xCD@-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xF4a\x04\xD7V[\x7F\xD2\x8E\x80\x9Bp\x8F^\xE3\x8B\xE84}m\x86\x9D\x822I<\tJ\xB2\xDD\xE9\x83i\xE4\x10#i\xA9\x9Da\x13\x1F\x84\x80a=\x7FV[`@Q` \x01a\x130\x92\x91\x90a?\x97V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x84` \x015\x85`@\x01` \x81\x01\x90a\x13^\x91\x90a<\x16V[`@\x80Q` \x81\x01\x95\x90\x95R\x84\x01\x92\x90\x92R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90Ra\x13\xC4`\x80\x85\x01``\x86\x01a<\x16V[a\x13\xD4`\xA0\x86\x01`\x80\x87\x01a<\x16V[a\x13\xE4`\xC0\x87\x01`\xA0\x88\x01a<\x16V[`\xC0\x87\x015`\xE0\x88\x015a\x01\0\x89\x015a\x01 \x8A\x015a\x14\x0Ca\x01`\x8C\x01a\x01@\x8D\x01a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x99\x8A\x16` \x82\x01R\x97\x89\x16\x90\x88\x01R\x94\x87\x16``\x87\x01R`\x80\x86\x01\x93\x90\x93R`\xA0\x85\x01\x91\x90\x91R`\xC0\x84\x01R`\xE0\x83\x01R\x90\x91\x16a\x01\0\x82\x01Ra\x01 \x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x14\x92\x92\x91` \x01a?\xD7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\x06J\x92\x91\x90\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[a\x14\xF2a\x1B\xDBV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15mW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x91\x91\x90a;\xFBV[a\x15\xC7W`@Q\x7F\xC19\xEA\xBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16DW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16h\x91\x90a;\xFBV[a\x16\x9EW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x86\x015\x87\x15\x80\x15\x90a\x16\xB8WPa\x01`\x87\x015\x88\x11\x15[\x15a\x16\xD7Wa\x16\xD4\x88a\x02\0\x89\x015a\x01`\x8A\x015`\x01a\x1C\x1EV[\x90P[a\x17\x08\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x83\x8A\x8A\x8A\x8A\x8A\x8Aa\x1CiV[a\x17E\x87\x8A\x83\x8B\x15\x80a\x17\x1FWPa\x01`\x8B\x015\x8C\x11[a\x17)W\x8Ba\x170V[a\x01`\x8B\x015[\x88\x8B\x8B`\x01a\x08\xAF`@\x8D\x01` \x8E\x01a=aV[a\x17R`@\x88\x01\x88a=\x7FV[`@Qa\x17`\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\x17\x9A`\xA0\x8A\x01`\x80\x8B\x01a<\x16V[a\x17\xAA`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x17\xBCa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[a\x17\xCEa\x01\xE0\x8D\x01a\x01\xC0\x8E\x01a<\x16V[\x8D\x15\x80a\x17\xDFWPa\x01`\x8D\x015\x8E\x11[a\x17\xE9W\x8Da\x17\xF0V[a\x01@\x8D\x015[a\x02\0\x8E\x015\x88\x14a\x18\x02W\x87a\x18\tV[a\x01\xE0\x8E\x015[\x8E`\xE0\x01` \x81\x01\x90a\x18\x1C\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\x18n`\x01\x80UV[PPPPPPPPV[a\x18\x82\x85\x83a\"\x12V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x18\xC1`\x80\x88\x01``\x89\x01a<\x16V[a\x18\xD1`\xA0\x89\x01`\x80\x8A\x01a<\x16V[\x88`\xC0\x015\x85`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x18\xF6\x94\x93\x92\x91\x90a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x19\rW_\x80\xFD[PZ\xF1\x15\x80\x15a\x19\x1FW=_\x80>=_\xFD[PPPPa\x19D\x86\x86\x86\x86`\x02\x89` \x01` \x81\x01\x90a\x19?\x91\x90a=aV[a\"\xC9V[PPPPPPV[_a\x19Ua\x04\xD7V[\x7F\xC9\x94\xD2\xCA\x03u\xD6\xD4sx^\x0C\xE0\xB1\xD2\x03\xF0i\x12\x1B\xAC\x13\x14\xF7,\\\x0F\xE6\x01\xEB9\x10a\x19\x83`@\x85\x01\x85a=\x7FV[`@Q` \x01a\x19\x94\x92\x91\x90a?\x97V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 ``\x85\x015a\x19\xDF`\xA0\x87\x01`\x80\x88\x01a<\x16V[a\x19\xEF`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\xC0\x88\x015a\x1A\x05a\x01\0\x8A\x01`\xE0\x8B\x01a<\x16V[`@\x80Q` \x81\x01\x98\x90\x98R\x87\x01\x95\x90\x95R``\x86\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80\x86\x01R\x81\x16`\xA0\x85\x01R`\xC0\x84\x01\x91\x90\x91R\x16`\xE0\x82\x01Ra\x01\0\x80\x85\x015\x90\x82\x01Ra\x01 \x01`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1Ao\x84a\x01 \x01a\x0C0V[a\x1A|\x85a\x01\xC0\x01a\x05\xC6V[`@Q` \x01a\x14\x92\x93\x92\x91\x90a?\xEBV[a\x01\xA0\x81\x015a\x1A\xA8a\x01\x80\x83\x015a\x01`\x84\x015a>\xBCV[a\x1A\xB2\x91\x90a>\xBCV[a\x01@\x82\x015\x14a\x1A\xEFW`@Q\x7F\xC0Cw\xD3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x81\x015a\x1B\ta\x02 \x83\x015a\x02\0\x84\x015a>\xBCV[a\x1B\x13\x91\x90a>\xBCV[a\x01\xE0\x82\x015\x14a\x0C\x89W`@Q\x7F\x87v0\xBE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x91\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa.\xD6\x92PPPV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1B\xD3W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x94\x93PPPPV[`\x02`\x01T\x03a\x1C\x17W`@Q\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01UV[_a\x1CKa\x1C+\x83a/\0V[\x80\x15a\x1CFWP_\x84\x80a\x1CAWa\x1CAa@\x08V[\x86\x88\t\x11[\x15\x15\x90V[a\x1CV\x86\x86\x86a/,V[a\x1C`\x91\x90a>\xBCV[\x95\x94PPPPPV[_a\x1Cs\x87a\x19LV[\x90Pa\x1C\x80\x89\x82\x85a\x10gV[a\x1C\x90`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1C\xC7Wa\x1C\xC2a\x1C\xBB`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x82\x84a\x10gV[a\x1D\x0EV[a\x1C\xD4`@\x83\x01\x83a=\x7FV[\x90P_\x03a\x1D\x0EW`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D+a\x1D!`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x88``\x015a&\x1EV[\x86`\xC0\x015B\x11\x15a\x1DiW`@Q\x7F\x13=\xF0)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x88\x11\x80\x15a\x1D|WP\x86a\x01\0\x015\x88\x10[\x15a\x1D\xB3W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\xBC\x87a\x1A\x8EV[a\x1D\xC6\x8A\x85a\t\xE8V[a\x1D\xE7\x8A\x8A_\x8B\x11\x80\x15a\x1D\xDFWPa\x02\0\x8A\x015\x8B\x14\x15[\x8A\x8A\x8Aa\x0C\x8CV[a\x1D\xF5\x89\x88``\x015a&\x1EV[PPPPPPPPPPV[a\x1E\x13a\x1E\x0E\x86\x80a=\xEFV[a0\x01V[_a\x1E(a\x01\x80\x8B\x015a\x01\xA0\x8C\x015a>\xBCV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Ew\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x010`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1E\xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x86`\x02\x81\x11\x15a\x1E\xD0Wa\x1E\xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1F\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a\x1F\x18W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Fi\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\xE0\x01` \x81\x01\x90a\x1F\x8A\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1F\xAE\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A\x81R` \x01\x86`\x02\x81\x11\x15a\x1F\xD4Wa\x1F\xD4a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F\xF3\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a \nW_\x80\xFD[PZ\xF1\x15\x80\x15a \x1CW=_\x80>=_\xFD[PPPPa *\x85\x85a0\x01V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8C`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\x80\x01` \x81\x01\x90a \x86\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01\xC0\x01_\x01` \x81\x01\x90a \xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8B\x81R` \x01\x85`\x02\x81\x11\x15a \xD0Wa \xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a!\x18W=_\x80>=_\xFD[Pa!.\x92Pa\x1E\x0E\x91PP` \x88\x01\x88a=\xEFV[_a!Aa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!\x9EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\xC2\x91\x90a@\xB4V[\x90P\x80\x15a\"\x05Wa\"\x05a!\xDEa\x01\0\x8D\x01`\xE0\x8E\x01a<\x16V[\x82\x8Da\x01 \x01_\x01` \x81\x01\x90a!\xF5\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a19V[PPPPPPPPPPPV[a\"\"`\x80\x83\x01``\x84\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\"aWa\"\\a\"M`\x80\x84\x01``\x85\x01a<\x16V[a\"V\x84a\x12\xEBV[\x83a\x10gV[a\"\xA8V[a\"n`@\x82\x01\x82a=\x7FV[\x90P_\x03a\"\xA8W`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\"\xC5a\"\xBB`\x80\x84\x01``\x85\x01a<\x16V[\x83` \x015a&\x1EV[PPV[`\xE0\x85\x015\x83\x15\x80\x15\x90a\"\xE0WP\x85`\xC0\x015\x84\x10[\x15a\"\xFDWa\"\xFA\x84\x87`\xE0\x015\x88`\xC0\x015`\x01a\x1C\x1EV[\x90P[a#\t\x87\x82\x88\x88a1\xB9V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x89``\x01` \x81\x01\x90a#V\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#va\x01`\x8B\x01a\x01@\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#\x94`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x87\x15\x80a#\xB2WP\x89`\xC0\x015\x88\x11[a#\xBCW\x87a#\xC2V[\x89`\xC0\x015[\x81R` \x01\x86`\x02\x81\x11\x15a#\xD9Wa#\xD9a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\xF8\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\x0FW_\x80\xFD[PZ\xF1\x15\x80\x15a$!W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`@\x01` \x81\x01\x90a$\x81\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a$\x9F`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x02\x81\x11\x15a$\xC5Wa$\xC5a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a$\xE4\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\xFBW_\x80\xFD[PZ\xF1\x15\x80\x15a%\rW=_\x80>=_\xFD[Pa%\x1E\x92P\x88\x91P\x81\x90Pa=\x7FV[`@Qa%,\x92\x91\x90a=\xE0V[`@Q\x80\x91\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6\x87`@\x01` \x81\x01\x90a%h\x91\x90a<\x16V[a%x`\x80\x8A\x01``\x8B\x01a<\x16V[a%\x88`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a%\x98`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[\x89\x15\x80a%\xA8WP\x8B`\xC0\x015\x8A\x11[a%\xB2W\x89a%\xB8V[\x8B`\xC0\x015[\x87\x8Da\x01@\x01` \x81\x01\x90a%\xCD\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x84\x84R\x90\x91R\x90 T`\xFF\x16\x15a&yW`@Q\x7F\xBC\r\xA7\xD6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x83R\x92\x90R \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16`\x01\x17\x90UV[_\x80\x80\x80a&\xD5\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a&\xE2\x91\x90a@\xF2V[P\x91\x94P\x92P\x90Pa&\xFCa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a'FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a'\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x97\x96PPPPPPPV[_\x80\x80\x80\x80a'\xEC\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a'\xF9\x91\x90aABV[\x92\x96P\x90\x94P\x92P\x90Pa(\x15a\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a(_W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a(\xAAW`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a(\xBA`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a)\x04W`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x98\x97PPPPPPPPV[_\x80_\x80_\x80_\x80_\x8C\x8C`\x04\x90\x80\x92a)j\x93\x92\x91\x90a@\xCBV[\x81\x01\x90a)w\x91\x90aA\x90V[\x95\x9CP\x93\x9AP\x91\x98P\x96P\x94P\x92P\x90Pa)\x9Aa\x01\xE0\x8B\x01a\x01\xC0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a)\xE4W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85`\x01`\x01`\xA0\x1B\x03\x16\x8B`\x01`\x01`\xA0\x1B\x03\x16\x14a*/W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x160\x14a*qW`@Q\x7F\x81T7K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x81`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a*\xCBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x8A\x015\x83\x14a+\tW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+\x1Ba\x01@\x8B\x01a\x01 \x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a+eW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x8A\x015\x81\x14a+\xA3W`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x9C\x91\x9BP\x90\x99PPPPPPPPPPV[_\x80\x80\x80a+\xC7\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a+\xD4\x91\x90aB\x0FV[\x91\x94P\x92P\x90Pa+\xEDa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a,7W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a,\x82W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\x80\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80\x80\x80a,\xD2\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a,\xDF\x91\x90aBMV[P\x92\x96P\x90\x94P\x92P\x90Pa,\xFCa\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a-FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a-\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a-\xA1`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a-\xEBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02 \x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01\x80\x83\x015\x14\x15\x80a.GWP` \x81\x01Qa\x01\xA0\x83\x015\x14\x15[\x15a.~W`@Q\x7FJU\xDA \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x81\x01Qa\x02 \x83\x015\x14\x15\x80a.\x9FWP``\x81\x01Qa\x02@\x83\x015\x14\x15[\x15a\"\xC5W`@Q\x7Fw\xA5\x92\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x80a.\xE4\x86\x86a2\\V[\x92P\x92P\x92Pa.\xF4\x82\x82a2\xA5V[P\x90\x91PP[\x92\x91PPV[_`\x02\x82`\x03\x81\x11\x15a/\x15Wa/\x15a>\xF4V[a/\x1F\x91\x90aB\xB1V[`\xFF\x16`\x01\x14\x90P\x91\x90PV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a/\x7FW\x83\x82\x81a/uWa/ua@\x08V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a/\x96Wa/\x96`\x03\x85\x15\x02`\x11\x18a3\xADV[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP\x93\x92PPPV[_[\x81\x81\x10\x15a\x0C+W6\x83\x83\x83\x81\x81\x10a0\x1EWa0\x1Ea>SV[\x90P` \x02\x81\x01\x90a00\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a0i` \x83\x01\x83a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x03a0\xA9W`@Q\x7Fy\xA1\xBF\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a0\xB2\x81a3\xBEV[a0\xBF` \x82\x01\x82a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a0\xF7\x84a4\x01V[`@\x80Q\x92\x83R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA2P`\x01\x01a0\x03V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C+\x90\x84\x90a4*V[_\x83\x11\x80\x15a1\xCCWP\x81a\x01\0\x015\x83\x10[\x15a2\x03W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2\x10\x84a\"V\x84a\x12\xEBV[a2\x1E\x84\x83` \x015a&\x1EV[B\x82a\x01 \x015\x11a\x11\x9AW`@Q\x7F\xC5hs\xBA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x83Q`A\x03a2\x93W` \x84\x01Q`@\x85\x01Q``\x86\x01Q_\x1Aa2\x85\x88\x82\x85\x85a4\xAFV[\x95P\x95P\x95PPPPa2\x9EV[PP\x81Q_\x91P`\x02\x90[\x92P\x92P\x92V[_\x82`\x03\x81\x11\x15a2\xB8Wa2\xB8a>\xF4V[\x03a2\xC1WPPV[`\x01\x82`\x03\x81\x11\x15a2\xD5Wa2\xD5a>\xF4V[\x03a3\x0CW`@Q\x7F\xF6E\xEE\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x82`\x03\x81\x11\x15a3 Wa3 a>\xF4V[\x03a3_W`@Q\x7F\xFC\xE6\x98\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x03\x82`\x03\x81\x11\x15a3sWa3sa>\xF4V[\x03a\"\xC5W`@Q\x7F\xD7\x8B\xCE\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01a3VV[cNH{q_R\x80` R`$`\x1C\xFD[_a3\xCC` \x83\x01\x83a<\x16V[\x90P` \x82\x0156_a3\xE2`@\x86\x01\x86a=\x7FV[\x91P\x91P`@Q\x81\x83\x827_\x80\x83\x83\x87\x89Z\xF1a\x19DW=_\x80>=_\xFD[_6\x81a4\x11`@\x85\x01\x85a=\x7FV[\x90\x92P\x90P`\x04\x81\x10a4#W\x815\x92P[PP\x91\x90PV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a4IW`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a4`W\x80`\x01\x14\x15a4mV[`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x11\x9AW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a3VV[_\x80\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x84\x11\x15a4\xE8WP_\x91P`\x03\x90P\x82a5\x8BV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x8A\x90R`\xFF\x89\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x87\x90R`\x80\x81\x01\x86\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a59W=_\x80>=_\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a5\x82WP_\x92P`\x01\x91P\x82\x90Pa5\x8BV[\x92P_\x91P\x81\x90P[\x94P\x94P\x94\x91PPV[_\x80_`@\x84\x86\x03\x12\x15a5\xA7W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a5\xC5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a5\xD8W_\x80\xFD[\x815\x81\x81\x11\x15a5\xE6W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a5\xF7W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[_`\xA0\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[P\x91\x90PV[_`\xA0\x82\x84\x03\x12\x15a60W_\x80\xFD[a\x04\xD0\x83\x83a6\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x89W_\x80\xFD[\x805a6Y\x81a6:V[\x91\x90PV[_a\x02`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80\x83`\x1F\x84\x01\x12a6\x7FW_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x96W_\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a6\xB0W_\x80\xFD[\x92P\x92\x90PV[_`@\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_``\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a6\xF0W_\x80\xFD[a6\xF9\x8Aa6NV[\x98P` \x8A\x015\x97P`@\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a7\x1CW_\x80\xFD[a7(\x8D\x83\x8E\x01a6^V[\x98P``\x8C\x015\x91P\x80\x82\x11\x15a7=W_\x80\xFD[a7I\x8D\x83\x8E\x01a6oV[\x90\x98P\x96P`\x80\x8C\x015\x91P\x80\x82\x11\x15a7aW_\x80\xFD[a7m\x8D\x83\x8E\x01a6\xB7V[\x95P`\xA0\x8C\x015\x91P\x80\x82\x11\x15a7\x82W_\x80\xFD[a7\x8E\x8D\x83\x8E\x01a6\xC7V[\x94P`\xC0\x8C\x015\x91P\x80\x82\x11\x15a7\xA3W_\x80\xFD[a7\xAF\x8D\x83\x8E\x01a6\xC7V[\x93P`\xE0\x8C\x015\x91P\x80\x82\x11\x15a7\xC4W_\x80\xFD[Pa7\xD1\x8C\x82\x8D\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[_\x80`@\x83\x85\x03\x12\x15a7\xF2W_\x80\xFD[\x825a7\xFD\x81a6:V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x18W_\x80\xFD[a8$\x85\x82\x86\x01a6\xB7V[\x91PP\x92P\x92\x90PV[_a\x01`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15a8SW_\x80\xFD[\x855a8^\x81a6:V[\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a8zW_\x80\xFD[a8\x86\x89\x83\x8A\x01a8.V[\x95P`@\x88\x015\x91P\x80\x82\x11\x15a8\x9BW_\x80\xFD[a8\xA7\x89\x83\x8A\x01a6\xC7V[\x94P``\x88\x015\x93P`\x80\x88\x015\x91P\x80\x82\x11\x15a8\xC3W_\x80\xFD[Pa8\xD0\x88\x82\x89\x01a6\xC7V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_` \x82\x84\x03\x12\x15a8\xEDW_\x80\xFD[P5\x91\x90PV[\x80\x15\x15\x81\x14a\x0C\x89W_\x80\xFD[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a9\x16W_\x80\xFD[\x865a9!\x81a6:V[\x95P` \x87\x015a91\x81a6:V[\x94P`@\x87\x015a9A\x81a8\xF4V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a9]W_\x80\xFD[a9i\x8A\x83\x8B\x01a6^V[\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a9~W_\x80\xFD[Pa9\x8B\x89\x82\x8A\x01a6oV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a9\xAFW_\x80\xFD[\x835a9\xBA\x81a6:V[\x92P` \x84\x015\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9\xDCW_\x80\xFD[a9\xE8\x86\x82\x87\x01a6\xC7V[\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a:\x02W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a:\x18W_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a8.V[_\x80_\x80_\x80_\x80`\xE0\x89\x8B\x03\x12\x15a:;W_\x80\xFD[a:D\x89a6NV[\x97P` \x89\x015\x96P`@\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a:gW_\x80\xFD[a:s\x8C\x83\x8D\x01a6^V[\x97P``\x8B\x015\x91P\x80\x82\x11\x15a:\x88W_\x80\xFD[a:\x94\x8C\x83\x8D\x01a6oV[\x90\x97P\x95P`\x80\x8B\x015\x91P\x80\x82\x11\x15a:\xACW_\x80\xFD[a:\xB8\x8C\x83\x8D\x01a6\xB7V[\x94P`\xA0\x8B\x015\x91P\x80\x82\x11\x15a:\xCDW_\x80\xFD[a:\xD9\x8C\x83\x8D\x01a6\xC7V[\x93P`\xC0\x8B\x015\x91P\x80\x82\x11\x15a:\xEEW_\x80\xFD[Pa:\xFB\x8B\x82\x8C\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[_\x80_\x80_\x80`\xC0\x87\x89\x03\x12\x15a; W_\x80\xFD[a;)\x87a6NV[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a;EW_\x80\xFD[a;Q\x8A\x83\x8B\x01a8.V[\x96P`@\x89\x015\x91P\x80\x82\x11\x15a;fW_\x80\xFD[a;r\x8A\x83\x8B\x01a6\xC7V[\x95P``\x89\x015\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a;\x8EW_\x80\xFD[a;\x9A\x8A\x83\x8B\x01a6\xC7V[\x93P`\xA0\x89\x015\x91P\x80\x82\x11\x15a;\xAFW_\x80\xFD[Pa;\xBC\x89\x82\x8A\x01a6\xC7V[\x91PP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a;\xD9W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a;\xEFW_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a6^V[_` \x82\x84\x03\x12\x15a<\x0BW_\x80\xFD[\x81Qa\x04\xD0\x81a8\xF4V[_` \x82\x84\x03\x12\x15a<&W_\x80\xFD[\x815a\x04\xD0\x81a6:V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[\x805e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a6YW_\x80\xFD[_`\x01`\x01`\xA0\x1B\x03\x80\x87\x16\x83R\x80\x86\x16` \x84\x01RP\x83`@\x83\x01R`\x80``\x83\x01R\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a<\xE2W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a<\xFEW_\x80\xFD[\x806\x03\x82\x13\x15a=\x0CW_\x80\xFD[```\x80\x85\x01Ra=!`\xE0\x85\x01\x82\x84a<1V[\x91PPa=0` \x85\x01a<xV[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16`\xA0\x86\x01R\x80a=L`@\x88\x01a<xV[\x16`\xC0\x86\x01RPP\x80\x91PP\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a=qW_\x80\xFD[\x815`\x03\x81\x10a\x04\xD0W_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xB2W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xCCW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a>\"W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a><W_\x80\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a>\xB2W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a.\xFAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a?1W_\x80\xFD[\x815`\x04\x81\x10a\x04\xD0W_\x80\xFD[\x83\x81R`@` \x82\x01R_a\x1C``@\x83\x01\x84\x86a<1V[_` \x82\x84\x03\x12\x15a?hW_\x80\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x04\xD0W_\x80\xFD[` \x81R_a\x1B\xD3` \x83\x01\x84\x86a<1V[_\x81Q_[\x81\x81\x10\x15a?\xC9W` \x81\x85\x01\x81\x01Q\x86\x83\x01R\x01a?\xAFV[P_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x1B\xD3a?\xE5\x83\x86a?\xAAV[\x84a?\xAAV[_a?\xF6\x82\x86a?\xAAV[\x93\x84RPP` \x82\x01R`@\x01\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_`\xA0\x82\x01\x90P`\x01`\x01`\xA0\x1B\x03\x80\x84Q\x16\x83R\x80` \x85\x01Q\x16` \x84\x01R\x80`@\x85\x01Q\x16`@\x84\x01RP``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x03\x81\x10a@\xA7W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x80`\x80\x84\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a@\xC4W_\x80\xFD[PQ\x91\x90PV[_\x80\x85\x85\x11\x15a@\xD9W_\x80\xFD[\x83\x86\x11\x15a@\xE5W_\x80\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aA\x05W_\x80\xFD[\x845aA\x10\x81a6:V[\x93P` \x85\x015aA \x81a6:V[\x92P`@\x85\x015\x91P``\x85\x015aA7\x81a8\xF4V[\x93\x96\x92\x95P\x90\x93PPV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aAUW_\x80\xFD[\x845aA`\x81a6:V[\x93P` \x85\x015aAp\x81a6:V[\x92P`@\x85\x015aA\x80\x81a6:V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_\x80_\x80_\x80_`\xE0\x88\x8A\x03\x12\x15aA\xA6W_\x80\xFD[\x875aA\xB1\x81a6:V[\x96P` \x88\x015aA\xC1\x81a6:V[\x95P`@\x88\x015aA\xD1\x81a6:V[\x94P``\x88\x015aA\xE1\x81a6:V[\x93P`\x80\x88\x015\x92P`\xA0\x88\x015aA\xF8\x81a6:V[\x80\x92PP`\xC0\x88\x015\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[_\x80_``\x84\x86\x03\x12\x15aB!W_\x80\xFD[\x835aB,\x81a6:V[\x92P` \x84\x015aB<\x81a6:V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15aBaW_\x80\xFD[\x855aBl\x81a6:V[\x94P` \x86\x015aB|\x81a6:V[\x93P`@\x86\x015aB\x8C\x81a6:V[\x92P``\x86\x015\x91P`\x80\x86\x015aB\xA3\x81a8\xF4V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_`\xFF\x83\x16\x80aB\xE8W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x9B\xE5\x8A\xCA\xDA50a\xA2\xA2\x02\xCCp\x11\xF3\xC9\x13\x93\xE0\xF2\xE3\x05\xE9 $E\xB0B\xFCJL\xE6dsolcC\0\x08\x17\x003",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ECDSAInvalidSignature()` and selector `0xf645eedf`.
+    ```solidity
+    error ECDSAInvalidSignature();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ECDSAInvalidSignature;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ECDSAInvalidSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: ECDSAInvalidSignature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ECDSAInvalidSignature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 69u8, 238u8, 223u8];
+            const SIGNATURE: &'static str = "ECDSAInvalidSignature()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ECDSAInvalidSignatureLength(uint256)` and selector `0xfce698f7`.
+    ```solidity
+    error ECDSAInvalidSignatureLength(uint256 length);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ECDSAInvalidSignatureLength {
+        #[allow(missing_docs)]
+        pub length: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ECDSAInvalidSignatureLength> for UnderlyingRustTuple<'_> {
+            fn from(value: ECDSAInvalidSignatureLength) -> Self {
+                (value.length,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignatureLength {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { length: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ECDSAInvalidSignatureLength {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [252u8, 230u8, 152u8, 247u8];
+            const SIGNATURE: &'static str = "ECDSAInvalidSignatureLength(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.length,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ECDSAInvalidSignatureS(bytes32)` and selector `0xd78bce0c`.
+    ```solidity
+    error ECDSAInvalidSignatureS(bytes32 s);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ECDSAInvalidSignatureS {
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ECDSAInvalidSignatureS> for UnderlyingRustTuple<'_> {
+            fn from(value: ECDSAInvalidSignatureS) -> Self {
+                (value.s,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignatureS {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { s: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ECDSAInvalidSignatureS {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [215u8, 139u8, 206u8, 12u8];
+            const SIGNATURE: &'static str = "ECDSAInvalidSignatureS(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidAmount()` and selector `0x2c5211c6`.
+    ```solidity
+    error InvalidAmount();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidAmount;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidAmount) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [44u8, 82u8, 17u8, 198u8];
+            const SIGNATURE: &'static str = "InvalidAmount()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidAsset()` and selector `0xc891add2`.
+    ```solidity
+    error InvalidAsset();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidAsset;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidAsset> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidAsset) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAsset {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidAsset {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [200u8, 145u8, 173u8, 210u8];
+            const SIGNATURE: &'static str = "InvalidAsset()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidBaseTokenAmounts()` and selector `0xc04377d3`.
+    ```solidity
+    error InvalidBaseTokenAmounts();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidBaseTokenAmounts;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidBaseTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidBaseTokenAmounts) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidBaseTokenAmounts {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidBaseTokenAmounts {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [192u8, 67u8, 119u8, 211u8];
+            const SIGNATURE: &'static str = "InvalidBaseTokenAmounts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidDestination()` and selector `0xac6b05f5`.
+    ```solidity
+    error InvalidDestination();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidDestination;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidDestination> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidDestination) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidDestination {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidDestination {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [172u8, 107u8, 5u8, 245u8];
+            const SIGNATURE: &'static str = "InvalidDestination()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidEIP1271Signature()` and selector `0x5d52cbe3`.
+    ```solidity
+    error InvalidEIP1271Signature();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidEIP1271Signature;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidEIP1271Signature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidEIP1271Signature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEIP1271Signature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidEIP1271Signature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [93u8, 82u8, 203u8, 227u8];
+            const SIGNATURE: &'static str = "InvalidEIP1271Signature()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidEIP712Signature()` and selector `0xb81d58e7`.
+    ```solidity
+    error InvalidEIP712Signature();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidEIP712Signature;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidEIP712Signature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidEIP712Signature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEIP712Signature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidEIP712Signature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [184u8, 29u8, 88u8, 231u8];
+            const SIGNATURE: &'static str = "InvalidEIP712Signature()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidETHSignSignature()` and selector `0x644ae6c3`.
+    ```solidity
+    error InvalidETHSignSignature();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidETHSignSignature;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidETHSignSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidETHSignSignature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidETHSignSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidETHSignSignature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [100u8, 74u8, 230u8, 195u8];
+            const SIGNATURE: &'static str = "InvalidETHSignSignature()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidFillAmount()` and selector `0x94697444`.
+    ```solidity
+    error InvalidFillAmount();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidFillAmount;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidFillAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidFillAmount) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidFillAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidFillAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [148u8, 105u8, 116u8, 68u8];
+            const SIGNATURE: &'static str = "InvalidFillAmount()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidHooksTarget()` and selector `0xc99e8872`.
+    ```solidity
+    error InvalidHooksTarget();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidHooksTarget;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidHooksTarget> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidHooksTarget) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidHooksTarget {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidHooksTarget {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [201u8, 158u8, 136u8, 114u8];
+            const SIGNATURE: &'static str = "InvalidHooksTarget()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidInteractionsBaseTokenAmounts()` and selector `0x4a55da20`.
+    ```solidity
+    error InvalidInteractionsBaseTokenAmounts();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidInteractionsBaseTokenAmounts;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidInteractionsBaseTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidInteractionsBaseTokenAmounts) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInteractionsBaseTokenAmounts {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidInteractionsBaseTokenAmounts {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 85u8, 218u8, 32u8];
+            const SIGNATURE: &'static str = "InvalidInteractionsBaseTokenAmounts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidInteractionsQuoteTokenAmounts()` and selector `0x77a59203`.
+    ```solidity
+    error InvalidInteractionsQuoteTokenAmounts();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidInteractionsQuoteTokenAmounts;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidInteractionsQuoteTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidInteractionsQuoteTokenAmounts) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInteractionsQuoteTokenAmounts {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidInteractionsQuoteTokenAmounts {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [119u8, 165u8, 146u8, 3u8];
+            const SIGNATURE: &'static str = "InvalidInteractionsQuoteTokenAmounts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidLendingPoolInteraction()` and selector `0x0561d8b3`.
+    ```solidity
+    error InvalidLendingPoolInteraction();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidLendingPoolInteraction;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidLendingPoolInteraction> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidLendingPoolInteraction) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidLendingPoolInteraction {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidLendingPoolInteraction {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 97u8, 216u8, 179u8];
+            const SIGNATURE: &'static str = "InvalidLendingPoolInteraction()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidQuoteTokenAmounts()` and selector `0x877630be`.
+    ```solidity
+    error InvalidQuoteTokenAmounts();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidQuoteTokenAmounts;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidQuoteTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidQuoteTokenAmounts) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidQuoteTokenAmounts {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidQuoteTokenAmounts {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 118u8, 48u8, 190u8];
+            const SIGNATURE: &'static str = "InvalidQuoteTokenAmounts()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSignatureType()` and selector `0x60cd402d`.
+    ```solidity
+    error InvalidSignatureType();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSignatureType;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSignatureType> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSignatureType) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignatureType {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSignatureType {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [96u8, 205u8, 64u8, 45u8];
+            const SIGNATURE: &'static str = "InvalidSignatureType()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSigner()` and selector `0x815e1d64`.
+    ```solidity
+    error InvalidSigner();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSigner;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSigner> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSigner) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSigner {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSigner {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [129u8, 94u8, 29u8, 100u8];
+            const SIGNATURE: &'static str = "InvalidSigner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSource()` and selector `0x8154374b`.
+    ```solidity
+    error InvalidSource();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSource;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSource> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSource) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSource {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSource {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [129u8, 84u8, 55u8, 75u8];
+            const SIGNATURE: &'static str = "InvalidSource()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NonceInvalid()` and selector `0xbc0da7d6`.
+    ```solidity
+    error NonceInvalid();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NonceInvalid;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NonceInvalid> for UnderlyingRustTuple<'_> {
+            fn from(value: NonceInvalid) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NonceInvalid {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NonceInvalid {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [188u8, 13u8, 167u8, 214u8];
+            const SIGNATURE: &'static str = "NonceInvalid()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotMaker()` and selector `0xb331e421`.
+    ```solidity
+    error NotMaker();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NotMaker;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NotMaker> for UnderlyingRustTuple<'_> {
+            fn from(value: NotMaker) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotMaker {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NotMaker {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [179u8, 49u8, 228u8, 33u8];
+            const SIGNATURE: &'static str = "NotMaker()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotSolver()` and selector `0xc139eabd`.
+    ```solidity
+    error NotSolver();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NotSolver;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NotSolver> for UnderlyingRustTuple<'_> {
+            fn from(value: NotSolver) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotSolver {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NotSolver {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [193u8, 57u8, 234u8, 189u8];
+            const SIGNATURE: &'static str = "NotSolver()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `OrderExpired()` and selector `0xc56873ba`.
+    ```solidity
+    error OrderExpired();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderExpired;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderExpired) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [197u8, 104u8, 115u8, 186u8];
+            const SIGNATURE: &'static str = "OrderExpired()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `PartialFillNotSupported()` and selector `0x7d617bb3`.
+    ```solidity
+    error PartialFillNotSupported();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PartialFillNotSupported;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PartialFillNotSupported> for UnderlyingRustTuple<'_> {
+            fn from(value: PartialFillNotSupported) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PartialFillNotSupported {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for PartialFillNotSupported {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [125u8, 97u8, 123u8, 179u8];
+            const SIGNATURE: &'static str = "PartialFillNotSupported()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ReceiverNotManager()` and selector `0x79a1bff0`.
+    ```solidity
+    error ReceiverNotManager();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ReceiverNotManager;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReceiverNotManager> for UnderlyingRustTuple<'_> {
+            fn from(value: ReceiverNotManager) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReceiverNotManager {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ReceiverNotManager {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 161u8, 191u8, 240u8];
+            const SIGNATURE: &'static str = "ReceiverNotManager()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ReentrancyGuardReentrantCall()` and selector `0x3ee5aeb5`.
+    ```solidity
+    error ReentrancyGuardReentrantCall();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ReentrancyGuardReentrantCall;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReentrancyGuardReentrantCall> for UnderlyingRustTuple<'_> {
+            fn from(value: ReentrancyGuardReentrantCall) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReentrancyGuardReentrantCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
+            const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SafeERC20FailedOperation(address)` and selector `0x5274afe7`.
+    ```solidity
+    error SafeERC20FailedOperation(address token);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SafeERC20FailedOperation {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SafeERC20FailedOperation> for UnderlyingRustTuple<'_> {
+            fn from(value: SafeERC20FailedOperation) -> Self {
+                (value.token,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeERC20FailedOperation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { token: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SafeERC20FailedOperation {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [82u8, 116u8, 175u8, 231u8];
+            const SIGNATURE: &'static str = "SafeERC20FailedOperation(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SignatureIsExpired()` and selector `0x133df029`.
+    ```solidity
+    error SignatureIsExpired();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SignatureIsExpired;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureIsExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureIsExpired) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureIsExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SignatureIsExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [19u8, 61u8, 240u8, 41u8];
+            const SIGNATURE: &'static str = "SignatureIsExpired()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SignatureIsNotEmpty()` and selector `0x0e364efc`.
+    ```solidity
+    error SignatureIsNotEmpty();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SignatureIsNotEmpty;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureIsNotEmpty> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureIsNotEmpty) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureIsNotEmpty {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SignatureIsNotEmpty {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [14u8, 54u8, 78u8, 252u8];
+            const SIGNATURE: &'static str = "SignatureIsNotEmpty()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `UpdatedMakerAmountsTooLow()` and selector `0x711dbe4a`.
+    ```solidity
+    error UpdatedMakerAmountsTooLow();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct UpdatedMakerAmountsTooLow;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UpdatedMakerAmountsTooLow> for UnderlyingRustTuple<'_> {
+            fn from(value: UpdatedMakerAmountsTooLow) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UpdatedMakerAmountsTooLow {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for UpdatedMakerAmountsTooLow {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [113u8, 29u8, 190u8, 74u8];
+            const SIGNATURE: &'static str = "UpdatedMakerAmountsTooLow()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ZeroMakerAmount()` and selector `0xb2f300d0`.
+    ```solidity
+    error ZeroMakerAmount();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ZeroMakerAmount;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ZeroMakerAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: ZeroMakerAmount) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroMakerAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ZeroMakerAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [178u8, 243u8, 0u8, 208u8];
+            const SIGNATURE: &'static str = "ZeroMakerAmount()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Interaction(address,uint256,bytes4)` and selector `0xed99827efb37016f2275f98c4bcf71c7551c75d59e9b450f79fa32e60be672c2`.
+    ```solidity
+    event Interaction(address indexed target, uint256 value, bytes4 selector);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Interaction {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Interaction {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Interaction(address,uint256,bytes4)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    237u8, 153u8, 130u8, 126u8, 251u8, 55u8, 1u8, 111u8, 34u8, 117u8, 249u8, 140u8,
+                    75u8, 207u8, 113u8, 199u8, 85u8, 28u8, 117u8, 213u8, 158u8, 155u8, 69u8, 15u8,
+                    121u8, 250u8, 50u8, 230u8, 11u8, 230u8, 114u8, 194u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    target: topics.1,
+                    value: data.0,
+                    selector: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.target.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.target,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Interaction {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Interaction> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Interaction) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TradeOrder(string,address,address,address,address,uint256,uint256,address)` and selector `0x0fce007c38c6c8ed9e545b3a148095762738618f8c21b673222613e4d45734b6`.
+    ```solidity
+    event TradeOrder(string indexed rfqId, address trader, address effectiveTrader, address baseToken, address quoteToken, uint256 baseTokenAmount, uint256 quoteTokenAmount, address recipient);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TradeOrder {
+        #[allow(missing_docs)]
+        pub rfqId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub trader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub effectiveTrader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub baseToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub quoteToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub baseTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub quoteTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TradeOrder {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "TradeOrder(string,address,address,address,address,uint256,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    15u8, 206u8, 0u8, 124u8, 56u8, 198u8, 200u8, 237u8, 158u8, 84u8, 91u8, 58u8,
+                    20u8, 128u8, 149u8, 118u8, 39u8, 56u8, 97u8, 143u8, 140u8, 33u8, 182u8, 115u8,
+                    34u8, 38u8, 19u8, 228u8, 212u8, 87u8, 52u8, 182u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    rfqId: topics.1,
+                    trader: data.0,
+                    effectiveTrader: data.1,
+                    baseToken: data.2,
+                    quoteToken: data.3,
+                    baseTokenAmount: data.4,
+                    quoteTokenAmount: data.5,
+                    recipient: data.6,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.trader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.effectiveTrader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.baseToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.rfqId.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.rfqId);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TradeOrder {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TradeOrder> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TradeOrder) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address authenticator_, address repository_, address permit2_);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub authenticator_: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub repository_: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub permit2_: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.authenticator_, value.repository_, value.permit2_)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        authenticator_: tuple.0,
+                        repository_: tuple.1,
+                        permit2_: tuple.2,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.authenticator_,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.repository_,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.permit2_,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `AUTHENTICATOR()` and selector `0xc6186181`.
+    ```solidity
+    function AUTHENTICATOR() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct AUTHENTICATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`AUTHENTICATOR()`](AUTHENTICATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct AUTHENTICATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<AUTHENTICATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: AUTHENTICATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for AUTHENTICATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<AUTHENTICATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: AUTHENTICATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for AUTHENTICATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for AUTHENTICATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [198u8, 24u8, 97u8, 129u8];
+            const SIGNATURE: &'static str = "AUTHENTICATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: AUTHENTICATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: AUTHENTICATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `BALANCE_MANAGER()` and selector `0x29bcdc95`.
+    ```solidity
+    function BALANCE_MANAGER() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BALANCE_MANAGERCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`BALANCE_MANAGER()`](BALANCE_MANAGERCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct BALANCE_MANAGERReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<BALANCE_MANAGERCall> for UnderlyingRustTuple<'_> {
+                fn from(value: BALANCE_MANAGERCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for BALANCE_MANAGERCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<BALANCE_MANAGERReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: BALANCE_MANAGERReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for BALANCE_MANAGERReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for BALANCE_MANAGERCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [41u8, 188u8, 220u8, 149u8];
+            const SIGNATURE: &'static str = "BALANCE_MANAGER()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: BALANCE_MANAGERReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: BALANCE_MANAGERReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `REPOSITORY()` and selector `0x6f35d2d2`.
+    ```solidity
+    function REPOSITORY() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct REPOSITORYCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`REPOSITORY()`](REPOSITORYCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct REPOSITORYReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<REPOSITORYCall> for UnderlyingRustTuple<'_> {
+                fn from(value: REPOSITORYCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for REPOSITORYCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<REPOSITORYReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: REPOSITORYReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for REPOSITORYReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for REPOSITORYCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [111u8, 53u8, 210u8, 210u8];
+            const SIGNATURE: &'static str = "REPOSITORY()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: REPOSITORYReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: REPOSITORYReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `cancelLimitOrder(uint256)` and selector `0xa5cdc8fc`.
+    ```solidity
+    function cancelLimitOrder(uint256 nonce) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelLimitOrderCall {
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`cancelLimitOrder(uint256)`](cancelLimitOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct cancelLimitOrderReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelLimitOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelLimitOrderCall) -> Self {
+                    (value.nonce,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { nonce: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<cancelLimitOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: cancelLimitOrderReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl cancelLimitOrderReturn {
+            fn _tokenize(
+                &self,
+            ) -> <cancelLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for cancelLimitOrderCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = cancelLimitOrderReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [165u8, 205u8, 200u8, 252u8];
+            const SIGNATURE: &'static str = "cancelLimitOrder(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                cancelLimitOrderReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hashBaseTokenData((address,uint256,uint256,uint256,uint256))` and selector `0x875530ff`.
+    ```solidity
+    function hashBaseTokenData(ILiquoriceSettlement.BaseTokenData memory _baseTokenData) external pure returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashBaseTokenDataCall {
+        #[allow(missing_docs)]
+        pub _baseTokenData:
+            <ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hashBaseTokenData((address,uint256,uint256,uint256,
+    /// uint256))`](hashBaseTokenDataCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashBaseTokenDataReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::BaseTokenData,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashBaseTokenDataCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashBaseTokenDataCall) -> Self {
+                    (value._baseTokenData,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashBaseTokenDataCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _baseTokenData: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashBaseTokenDataReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashBaseTokenDataReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashBaseTokenDataReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hashBaseTokenDataCall {
+            type Parameters<'a> = (ILiquoriceSettlement::BaseTokenData,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 85u8, 48u8, 255u8];
+            const SIGNATURE: &'static str =
+                "hashBaseTokenData((address,uint256,uint256,uint256,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::tokenize(
+                        &self._baseTokenData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hashBaseTokenDataReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hashBaseTokenDataReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))` and selector `0xe242924e`.
+    ```solidity
+    function hashOrder(ILiquoriceSettlement.Order memory _order) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashOrderCall {
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hashOrder((address,uint256,string,uint256,address,address,uint256,
+    /// address,uint256,(address,uint256,uint256,uint256,uint256),(address,
+    /// uint256,uint256,uint256,uint256)))`](hashOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashOrderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashOrderCall) -> Self {
+                    (value._order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashOrderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hashOrderCall {
+            type Parameters<'a> = (ILiquoriceSettlement::Order,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [226u8, 66u8, 146u8, 78u8];
+            const SIGNATURE: &'static str = "hashOrder((address,uint256,string,uint256,address,\
+                                             address,uint256,address,uint256,(address,uint256,\
+                                             uint256,uint256,uint256),(address,uint256,uint256,\
+                                             uint256,uint256)))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hashOrderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hashOrderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hashQuoteTokenData((address,uint256,uint256,uint256,uint256))` and selector `0x4c9e03d3`.
+    ```solidity
+    function hashQuoteTokenData(ILiquoriceSettlement.QuoteTokenData memory _quoteTokenData) external pure returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashQuoteTokenDataCall {
+        #[allow(missing_docs)]
+        pub _quoteTokenData:
+            <ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hashQuoteTokenData((address,uint256,uint256,uint256,
+    /// uint256))`](hashQuoteTokenDataCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashQuoteTokenDataReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::QuoteTokenData,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashQuoteTokenDataCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashQuoteTokenDataCall) -> Self {
+                    (value._quoteTokenData,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashQuoteTokenDataCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _quoteTokenData: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashQuoteTokenDataReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashQuoteTokenDataReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashQuoteTokenDataReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hashQuoteTokenDataCall {
+            type Parameters<'a> = (ILiquoriceSettlement::QuoteTokenData,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [76u8, 158u8, 3u8, 211u8];
+            const SIGNATURE: &'static str =
+                "hashQuoteTokenData((address,uint256,uint256,uint256,uint256))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::tokenize(
+                        &self._quoteTokenData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hashQuoteTokenDataReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hashQuoteTokenDataReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))` and selector `0xb11f1262`.
+    ```solidity
+    function hashSingleOrder(ILiquoriceSettlement.Single memory _order) external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashSingleOrderCall {
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`hashSingleOrder((string,uint256,address,address,address,address,
+    /// uint256,uint256,uint256,uint256,address))`](hashSingleOrderCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct hashSingleOrderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Single,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashSingleOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashSingleOrderCall) -> Self {
+                    (value._order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashSingleOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<hashSingleOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashSingleOrderReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashSingleOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for hashSingleOrderCall {
+            type Parameters<'a> = (ILiquoriceSettlement::Single,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [177u8, 31u8, 18u8, 98u8];
+            const SIGNATURE: &'static str = "hashSingleOrder((string,uint256,address,address,\
+                                             address,address,uint256,uint256,uint256,uint256,\
+                                             address))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hashSingleOrderReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: hashSingleOrderReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub _hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub _signature: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value._hash, value._signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _hash: tuple.0,
+                        _signature: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))` and selector `0xcba673a7`.
+    ```solidity
+    function settle(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleCall {
+        #[allow(missing_docs)]
+        pub _signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _interactions: alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`settle(address,uint256,(address,uint256,string,uint256,address,
+    /// address,uint256,address,uint256,(address,uint256,uint256,uint256,
+    /// uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,
+    /// bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,
+    /// uint8,bytes),(uint8,uint8,bytes))`](settleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                GPv2Interaction::Hooks,
+                Signature::TypedSignature,
+                Signature::TypedSignature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleCall) -> Self {
+                    (
+                        value._signer,
+                        value._filledTakerAmount,
+                        value._order,
+                        value._interactions,
+                        value._hooks,
+                        value._makerSignature,
+                        value._takerSignature,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _signer: tuple.0,
+                        _filledTakerAmount: tuple.1,
+                        _order: tuple.2,
+                        _interactions: tuple.3,
+                        _hooks: tuple.4,
+                        _makerSignature: tuple.5,
+                        _takerSignature: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl settleReturn {
+            fn _tokenize(&self) -> <settleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                GPv2Interaction::Hooks,
+                Signature::TypedSignature,
+                Signature::TypedSignature,
+            );
+            type Return = settleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [203u8, 166u8, 115u8, 167u8];
+            const SIGNATURE: &'static str =
+                "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,\
+                 address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,\
+                 uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],\
+                 (address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._signer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self._filledTakerAmount),
+                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Interaction::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
+                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(
+                        &self._hooks,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._makerSignature,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._takerSignature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                settleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))` and selector `0x9935c868`.
+    ```solidity
+    function settleSingle(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleSingleCall {
+        #[allow(missing_docs)]
+        pub _signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`settleSingle(address,(string,uint256,address,address,address,address,
+    /// uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,
+    /// (uint8,uint8,bytes))`](settleSingleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleSingleReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                ILiquoriceSettlement::Single,
+                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Uint<256>,
+                Signature::TypedSignature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleSingleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleSingleCall) -> Self {
+                    (
+                        value._signer,
+                        value._order,
+                        value._makerSignature,
+                        value._filledTakerAmount,
+                        value._takerSignature,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _signer: tuple.0,
+                        _order: tuple.1,
+                        _makerSignature: tuple.2,
+                        _filledTakerAmount: tuple.3,
+                        _takerSignature: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleSingleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleSingleReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl settleSingleReturn {
+            fn _tokenize(&self) -> <settleSingleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settleSingleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                ILiquoriceSettlement::Single,
+                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Uint<256>,
+                Signature::TypedSignature,
+            );
+            type Return = settleSingleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [153u8, 53u8, 200u8, 104u8];
+            const SIGNATURE: &'static str =
+                "settleSingle(address,(string,uint256,address,address,address,address,uint256,\
+                 uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._signer,
+                    ),
+                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._makerSignature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._filledTakerAmount,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._takerSignature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                settleSingleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `settleSingleWithPermitsSignatures(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes),(bytes,uint48,uint48))` and selector `0xdb587728`.
+    ```solidity
+    function settleSingleWithPermitsSignatures(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleSingleWithPermitsSignaturesCall {
+        #[allow(missing_docs)]
+        pub _signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`settleSingleWithPermitsSignatures(address,(string,uint256,address,
+    /// address,address,address,uint256,uint256,uint256,uint256,address),(uint8,
+    /// uint8,bytes),uint256,(uint8,uint8,bytes),(bytes,uint48,
+    /// uint48))`](settleSingleWithPermitsSignaturesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleSingleWithPermitsSignaturesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                ILiquoriceSettlement::Single,
+                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Uint<256>,
+                Signature::TypedSignature,
+                Signature::TakerPermitInfo,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleSingleWithPermitsSignaturesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleSingleWithPermitsSignaturesCall) -> Self {
+                    (
+                        value._signer,
+                        value._order,
+                        value._makerSignature,
+                        value._filledTakerAmount,
+                        value._takerSignature,
+                        value._takerPermitInfo,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleWithPermitsSignaturesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _signer: tuple.0,
+                        _order: tuple.1,
+                        _makerSignature: tuple.2,
+                        _filledTakerAmount: tuple.3,
+                        _takerSignature: tuple.4,
+                        _takerPermitInfo: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleSingleWithPermitsSignaturesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleSingleWithPermitsSignaturesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleWithPermitsSignaturesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl settleSingleWithPermitsSignaturesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settleSingleWithPermitsSignaturesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                ILiquoriceSettlement::Single,
+                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Uint<256>,
+                Signature::TypedSignature,
+                Signature::TakerPermitInfo,
+            );
+            type Return = settleSingleWithPermitsSignaturesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [219u8, 88u8, 119u8, 40u8];
+            const SIGNATURE: &'static str = "settleSingleWithPermitsSignatures(address,(string,\
+                                             uint256,address,address,address,address,uint256,\
+                                             uint256,uint256,uint256,address),(uint8,uint8,bytes),\
+                                             uint256,(uint8,uint8,bytes),(bytes,uint48,uint48))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._signer,
+                    ),
+                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._makerSignature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._filledTakerAmount,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._takerSignature,
+                    ),
+                    <Signature::TakerPermitInfo as alloy_sol_types::SolType>::tokenize(
+                        &self._takerPermitInfo,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                settleSingleWithPermitsSignaturesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `settleWithPermitsSignatures(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes),(bytes,uint48,uint48))` and selector `0x51d46815`.
+    ```solidity
+    function settleWithPermitsSignatures(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleWithPermitsSignaturesCall {
+        #[allow(missing_docs)]
+        pub _signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _interactions: alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`settleWithPermitsSignatures(address,uint256,(address,uint256,string,
+    /// uint256,address,address,uint256,address,uint256,(address,uint256,
+    /// uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),
+    /// (address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,
+    /// bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes),(bytes,uint48,
+    /// uint48))`](settleWithPermitsSignaturesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct settleWithPermitsSignaturesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                GPv2Interaction::Hooks,
+                Signature::TypedSignature,
+                Signature::TypedSignature,
+                Signature::TakerPermitInfo,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleWithPermitsSignaturesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleWithPermitsSignaturesCall) -> Self {
+                    (
+                        value._signer,
+                        value._filledTakerAmount,
+                        value._order,
+                        value._interactions,
+                        value._hooks,
+                        value._makerSignature,
+                        value._takerSignature,
+                        value._takerPermitInfo,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleWithPermitsSignaturesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _signer: tuple.0,
+                        _filledTakerAmount: tuple.1,
+                        _order: tuple.2,
+                        _interactions: tuple.3,
+                        _hooks: tuple.4,
+                        _makerSignature: tuple.5,
+                        _takerSignature: tuple.6,
+                        _takerPermitInfo: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<settleWithPermitsSignaturesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleWithPermitsSignaturesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleWithPermitsSignaturesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl settleWithPermitsSignaturesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for settleWithPermitsSignaturesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                GPv2Interaction::Hooks,
+                Signature::TypedSignature,
+                Signature::TypedSignature,
+                Signature::TakerPermitInfo,
+            );
+            type Return = settleWithPermitsSignaturesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [81u8, 212u8, 104u8, 21u8];
+            const SIGNATURE: &'static str =
+                "settleWithPermitsSignatures(address,uint256,(address,uint256,string,uint256,\
+                 address,address,uint256,address,uint256,(address,uint256,uint256,uint256,\
+                 uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],\
+                 ((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,\
+                 uint8,bytes),(bytes,uint48,uint48))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._signer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self._filledTakerAmount),
+                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Interaction::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
+                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(
+                        &self._hooks,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._makerSignature,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._takerSignature,
+                    ),
+                    <Signature::TakerPermitInfo as alloy_sol_types::SolType>::tokenize(
+                        &self._takerPermitInfo,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                settleWithPermitsSignaturesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))` and selector `0x5aa0e95d`.
+    ```solidity
+    function validateHooks(address _repository, GPv2Interaction.Hooks memory _hooks) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateHooksCall {
+        #[allow(missing_docs)]
+        pub _repository: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateHooks(address,((address,uint256,bytes)[],(address,uint256,
+    /// bytes)[]))`](validateHooksCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateHooksReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Address, GPv2Interaction::Hooks);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateHooksCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateHooksCall) -> Self {
+                    (value._repository, value._hooks)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateHooksCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _repository: tuple.0,
+                        _hooks: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateHooksReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateHooksReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateHooksReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateHooksReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateHooksCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateHooksCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address, GPv2Interaction::Hooks);
+            type Return = validateHooksReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [90u8, 160u8, 233u8, 93u8];
+            const SIGNATURE: &'static str =
+                "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._repository,
+                    ),
+                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(&self._hooks),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateHooksReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])` and selector `0xa7ab49bc`.
+    ```solidity
+    function validateInteractions(address _repository, address _signer, bool _isPartialFill, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateInteractionsCall {
+        #[allow(missing_docs)]
+        pub _repository: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _isPartialFill: bool,
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _interactions: alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateInteractions(address,address,bool,(address,uint256,string,
+    /// uint256,address,address,uint256,address,uint256,(address,uint256,
+    /// uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),
+    /// (address,uint256,bytes)[])`](validateInteractionsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateInteractionsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                bool,
+                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateInteractionsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateInteractionsCall) -> Self {
+                    (
+                        value._repository,
+                        value._signer,
+                        value._isPartialFill,
+                        value._order,
+                        value._interactions,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateInteractionsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _repository: tuple.0,
+                        _signer: tuple.1,
+                        _isPartialFill: tuple.2,
+                        _order: tuple.3,
+                        _interactions: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateInteractionsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateInteractionsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateInteractionsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateInteractionsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateInteractionsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateInteractionsCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+            );
+            type Return = validateInteractionsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [167u8, 171u8, 73u8, 188u8];
+            const SIGNATURE: &'static str =
+                "validateInteractions(address,address,bool,(address,uint256,string,uint256,\
+                 address,address,uint256,address,uint256,(address,uint256,uint256,uint256,\
+                 uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._repository,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._signer,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self._isPartialFill,
+                    ),
+                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Interaction::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateInteractionsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))` and selector `0xfa5cd56c`.
+    ```solidity
+    function validateOrderAmounts(ILiquoriceSettlement.Order memory _order) external pure;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateOrderAmountsCall {
+        #[allow(missing_docs)]
+        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateOrderAmounts((address,uint256,string,uint256,address,address,
+    /// uint256,address,uint256,(address,uint256,uint256,uint256,uint256),
+    /// (address,uint256,uint256,uint256,uint256)))`](validateOrderAmountsCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateOrderAmountsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Order,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateOrderAmountsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateOrderAmountsCall) -> Self {
+                    (value._order,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateOrderAmountsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _order: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateOrderAmountsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateOrderAmountsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateOrderAmountsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateOrderAmountsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateOrderAmountsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateOrderAmountsCall {
+            type Parameters<'a> = (ILiquoriceSettlement::Order,);
+            type Return = validateOrderAmountsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [250u8, 92u8, 213u8, 108u8];
+            const SIGNATURE: &'static str = "validateOrderAmounts((address,uint256,string,uint256,\
+                                             address,address,uint256,address,uint256,(address,\
+                                             uint256,uint256,uint256,uint256),(address,uint256,\
+                                             uint256,uint256,uint256)))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateOrderAmountsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `validateSignature(address,bytes32,(uint8,uint8,bytes))` and selector `0xae80c584`.
+    ```solidity
+    function validateSignature(address _validationAddress, bytes32 _hash, Signature.TypedSignature memory _signature) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateSignatureCall {
+        #[allow(missing_docs)]
+        pub _validationAddress: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub _signature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+    }
+    ///Container type for the return parameters of the
+    /// [`validateSignature(address,bytes32,(uint8,uint8,
+    /// bytes))`](validateSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateSignatureReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                Signature::TypedSignature,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::FixedBytes<32>,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateSignatureCall) -> Self {
+                    (value._validationAddress, value._hash, value._signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _validationAddress: tuple.0,
+                        _hash: tuple.1,
+                        _signature: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateSignatureReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl validateSignatureReturn {
+            fn _tokenize(
+                &self,
+            ) -> <validateSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                Signature::TypedSignature,
+            );
+            type Return = validateSignatureReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [174u8, 128u8, 197u8, 132u8];
+            const SIGNATURE: &'static str =
+                "validateSignature(address,bytes32,(uint8,uint8,bytes))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._validationAddress,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                validateSignatureReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`LiquoriceSettlement`](self) function calls.
+    #[derive(Clone)]
+    pub enum LiquoriceSettlementCalls {
+        #[allow(missing_docs)]
+        AUTHENTICATOR(AUTHENTICATORCall),
+        #[allow(missing_docs)]
+        BALANCE_MANAGER(BALANCE_MANAGERCall),
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        REPOSITORY(REPOSITORYCall),
+        #[allow(missing_docs)]
+        cancelLimitOrder(cancelLimitOrderCall),
+        #[allow(missing_docs)]
+        hashBaseTokenData(hashBaseTokenDataCall),
+        #[allow(missing_docs)]
+        hashOrder(hashOrderCall),
+        #[allow(missing_docs)]
+        hashQuoteTokenData(hashQuoteTokenDataCall),
+        #[allow(missing_docs)]
+        hashSingleOrder(hashSingleOrderCall),
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+        #[allow(missing_docs)]
+        settle(settleCall),
+        #[allow(missing_docs)]
+        settleSingle(settleSingleCall),
+        #[allow(missing_docs)]
+        settleSingleWithPermitsSignatures(settleSingleWithPermitsSignaturesCall),
+        #[allow(missing_docs)]
+        settleWithPermitsSignatures(settleWithPermitsSignaturesCall),
+        #[allow(missing_docs)]
+        validateHooks(validateHooksCall),
+        #[allow(missing_docs)]
+        validateInteractions(validateInteractionsCall),
+        #[allow(missing_docs)]
+        validateOrderAmounts(validateOrderAmountsCall),
+        #[allow(missing_docs)]
+        validateSignature(validateSignatureCall),
+    }
+    impl LiquoriceSettlementCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [22u8, 38u8, 186u8, 126u8],
+            [41u8, 188u8, 220u8, 149u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [76u8, 158u8, 3u8, 211u8],
+            [81u8, 212u8, 104u8, 21u8],
+            [90u8, 160u8, 233u8, 93u8],
+            [111u8, 53u8, 210u8, 210u8],
+            [135u8, 85u8, 48u8, 255u8],
+            [153u8, 53u8, 200u8, 104u8],
+            [165u8, 205u8, 200u8, 252u8],
+            [167u8, 171u8, 73u8, 188u8],
+            [174u8, 128u8, 197u8, 132u8],
+            [177u8, 31u8, 18u8, 98u8],
+            [198u8, 24u8, 97u8, 129u8],
+            [203u8, 166u8, 115u8, 167u8],
+            [219u8, 88u8, 119u8, 40u8],
+            [226u8, 66u8, 146u8, 78u8],
+            [250u8, 92u8, 213u8, 108u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateHooksCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <REPOSITORYCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hashBaseTokenDataCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <settleSingleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <cancelLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateInteractionsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hashSingleOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <AUTHENTICATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <settleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <hashOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <validateOrderAmountsCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isValidSignature),
+            ::core::stringify!(BALANCE_MANAGER),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(hashQuoteTokenData),
+            ::core::stringify!(settleWithPermitsSignatures),
+            ::core::stringify!(validateHooks),
+            ::core::stringify!(REPOSITORY),
+            ::core::stringify!(hashBaseTokenData),
+            ::core::stringify!(settleSingle),
+            ::core::stringify!(cancelLimitOrder),
+            ::core::stringify!(validateInteractions),
+            ::core::stringify!(validateSignature),
+            ::core::stringify!(hashSingleOrder),
+            ::core::stringify!(AUTHENTICATOR),
+            ::core::stringify!(settle),
+            ::core::stringify!(settleSingleWithPermitsSignatures),
+            ::core::stringify!(hashOrder),
+            ::core::stringify!(validateOrderAmounts),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for LiquoriceSettlementCalls {
+        const COUNT: usize = 18usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "LiquoriceSettlementCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::AUTHENTICATOR(_) => <AUTHENTICATORCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::BALANCE_MANAGER(_) => {
+                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::REPOSITORY(_) => <REPOSITORYCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::cancelLimitOrder(_) => {
+                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::hashBaseTokenData(_) => {
+                    <hashBaseTokenDataCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::hashOrder(_) => <hashOrderCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::hashQuoteTokenData(_) => {
+                    <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::hashSingleOrder(_) => {
+                    <hashSingleOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::settle(_) => <settleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::settleSingle(_) => <settleSingleCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::settleSingleWithPermitsSignatures(_) => {
+                    <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::settleWithPermitsSignatures(_) => {
+                    <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateHooks(_) => <validateHooksCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::validateInteractions(_) => {
+                    <validateInteractionsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateOrderAmounts(_) => {
+                    <validateOrderAmountsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::validateSignature(_) => {
+                    <validateSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<LiquoriceSettlementCalls>] = &[
+                {
+                    fn isValidSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn BALANCE_MANAGER(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::BALANCE_MANAGER)
+                    }
+                    BALANCE_MANAGER
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn hashQuoteTokenData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::hashQuoteTokenData)
+                    }
+                    hashQuoteTokenData
+                },
+                {
+                    fn settleWithPermitsSignatures(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::settleWithPermitsSignatures)
+                    }
+                    settleWithPermitsSignatures
+                },
+                {
+                    fn validateHooks(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateHooksCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::validateHooks)
+                    }
+                    validateHooks
+                },
+                {
+                    fn REPOSITORY(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <REPOSITORYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::REPOSITORY)
+                    }
+                    REPOSITORY
+                },
+                {
+                    fn hashBaseTokenData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::hashBaseTokenData)
+                    }
+                    hashBaseTokenData
+                },
+                {
+                    fn settleSingle(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleSingleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::settleSingle)
+                    }
+                    settleSingle
+                },
+                {
+                    fn cancelLimitOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::cancelLimitOrder)
+                    }
+                    cancelLimitOrder
+                },
+                {
+                    fn validateInteractions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateInteractionsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::validateInteractions)
+                    }
+                    validateInteractions
+                },
+                {
+                    fn validateSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::validateSignature)
+                    }
+                    validateSignature
+                },
+                {
+                    fn hashSingleOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::hashSingleOrder)
+                    }
+                    hashSingleOrder
+                },
+                {
+                    fn AUTHENTICATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::AUTHENTICATOR)
+                    }
+                    AUTHENTICATOR
+                },
+                {
+                    fn settle(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::settle)
+                    }
+                    settle
+                },
+                {
+                    fn settleSingleWithPermitsSignatures(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementCalls::settleSingleWithPermitsSignatures,
+                            )
+                    }
+                    settleSingleWithPermitsSignatures
+                },
+                {
+                    fn hashOrder(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::hashOrder)
+                    }
+                    hashOrder
+                },
+                {
+                    fn validateOrderAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::validateOrderAmounts)
+                    }
+                    validateOrderAmounts
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                LiquoriceSettlementCalls,
+            >] = &[
+                {
+                    fn isValidSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn BALANCE_MANAGER(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::BALANCE_MANAGER)
+                    }
+                    BALANCE_MANAGER
+                },
+                {
+                    fn DOMAIN_SEPARATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn hashQuoteTokenData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::hashQuoteTokenData)
+                    }
+                    hashQuoteTokenData
+                },
+                {
+                    fn settleWithPermitsSignatures(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::settleWithPermitsSignatures)
+                    }
+                    settleWithPermitsSignatures
+                },
+                {
+                    fn validateHooks(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateHooksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::validateHooks)
+                    }
+                    validateHooks
+                },
+                {
+                    fn REPOSITORY(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <REPOSITORYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementCalls::REPOSITORY)
+                    }
+                    REPOSITORY
+                },
+                {
+                    fn hashBaseTokenData(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::hashBaseTokenData)
+                    }
+                    hashBaseTokenData
+                },
+                {
+                    fn settleSingle(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleSingleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::settleSingle)
+                    }
+                    settleSingle
+                },
+                {
+                    fn cancelLimitOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::cancelLimitOrder)
+                    }
+                    cancelLimitOrder
+                },
+                {
+                    fn validateInteractions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateInteractionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::validateInteractions)
+                    }
+                    validateInteractions
+                },
+                {
+                    fn validateSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::validateSignature)
+                    }
+                    validateSignature
+                },
+                {
+                    fn hashSingleOrder(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::hashSingleOrder)
+                    }
+                    hashSingleOrder
+                },
+                {
+                    fn AUTHENTICATOR(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementCalls::AUTHENTICATOR)
+                    }
+                    AUTHENTICATOR
+                },
+                {
+                    fn settle(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementCalls::settle)
+                    }
+                    settle
+                },
+                {
+                    fn settleSingleWithPermitsSignatures(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementCalls::settleSingleWithPermitsSignatures,
+                            )
+                    }
+                    settleSingleWithPermitsSignatures
+                },
+                {
+                    fn hashOrder(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <hashOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementCalls::hashOrder)
+                    }
+                    hashOrder
+                },
+                {
+                    fn validateOrderAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementCalls::validateOrderAmounts)
+                    }
+                    validateOrderAmounts
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::AUTHENTICATOR(inner) => {
+                    <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::BALANCE_MANAGER(inner) => {
+                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::REPOSITORY(inner) => {
+                    <REPOSITORYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::cancelLimitOrder(inner) => {
+                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::hashBaseTokenData(inner) => {
+                    <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::hashOrder(inner) => {
+                    <hashOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::hashQuoteTokenData(inner) => {
+                    <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::hashSingleOrder(inner) => {
+                    <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::settle(inner) => {
+                    <settleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::settleSingle(inner) => {
+                    <settleSingleCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::settleSingleWithPermitsSignatures(inner) => {
+                    <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::settleWithPermitsSignatures(inner) => {
+                    <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateHooks(inner) => {
+                    <validateHooksCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateInteractions(inner) => {
+                    <validateInteractionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateOrderAmounts(inner) => {
+                    <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::validateSignature(inner) => {
+                    <validateSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::AUTHENTICATOR(inner) => {
+                    <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::BALANCE_MANAGER(inner) => {
+                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::REPOSITORY(inner) => {
+                    <REPOSITORYCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::cancelLimitOrder(inner) => {
+                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::hashBaseTokenData(inner) => {
+                    <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::hashOrder(inner) => {
+                    <hashOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::hashQuoteTokenData(inner) => {
+                    <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::hashSingleOrder(inner) => {
+                    <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::settle(inner) => {
+                    <settleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::settleSingle(inner) => {
+                    <settleSingleCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::settleSingleWithPermitsSignatures(inner) => {
+                    <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::settleWithPermitsSignatures(inner) => {
+                    <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateHooks(inner) => {
+                    <validateHooksCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateInteractions(inner) => {
+                    <validateInteractionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateOrderAmounts(inner) => {
+                    <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::validateSignature(inner) => {
+                    <validateSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`LiquoriceSettlement`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum LiquoriceSettlementErrors {
+        #[allow(missing_docs)]
+        ECDSAInvalidSignature(ECDSAInvalidSignature),
+        #[allow(missing_docs)]
+        ECDSAInvalidSignatureLength(ECDSAInvalidSignatureLength),
+        #[allow(missing_docs)]
+        ECDSAInvalidSignatureS(ECDSAInvalidSignatureS),
+        #[allow(missing_docs)]
+        InvalidAmount(InvalidAmount),
+        #[allow(missing_docs)]
+        InvalidAsset(InvalidAsset),
+        #[allow(missing_docs)]
+        InvalidBaseTokenAmounts(InvalidBaseTokenAmounts),
+        #[allow(missing_docs)]
+        InvalidDestination(InvalidDestination),
+        #[allow(missing_docs)]
+        InvalidEIP1271Signature(InvalidEIP1271Signature),
+        #[allow(missing_docs)]
+        InvalidEIP712Signature(InvalidEIP712Signature),
+        #[allow(missing_docs)]
+        InvalidETHSignSignature(InvalidETHSignSignature),
+        #[allow(missing_docs)]
+        InvalidFillAmount(InvalidFillAmount),
+        #[allow(missing_docs)]
+        InvalidHooksTarget(InvalidHooksTarget),
+        #[allow(missing_docs)]
+        InvalidInteractionsBaseTokenAmounts(InvalidInteractionsBaseTokenAmounts),
+        #[allow(missing_docs)]
+        InvalidInteractionsQuoteTokenAmounts(InvalidInteractionsQuoteTokenAmounts),
+        #[allow(missing_docs)]
+        InvalidLendingPoolInteraction(InvalidLendingPoolInteraction),
+        #[allow(missing_docs)]
+        InvalidQuoteTokenAmounts(InvalidQuoteTokenAmounts),
+        #[allow(missing_docs)]
+        InvalidSignatureType(InvalidSignatureType),
+        #[allow(missing_docs)]
+        InvalidSigner(InvalidSigner),
+        #[allow(missing_docs)]
+        InvalidSource(InvalidSource),
+        #[allow(missing_docs)]
+        NonceInvalid(NonceInvalid),
+        #[allow(missing_docs)]
+        NotMaker(NotMaker),
+        #[allow(missing_docs)]
+        NotSolver(NotSolver),
+        #[allow(missing_docs)]
+        OrderExpired(OrderExpired),
+        #[allow(missing_docs)]
+        PartialFillNotSupported(PartialFillNotSupported),
+        #[allow(missing_docs)]
+        ReceiverNotManager(ReceiverNotManager),
+        #[allow(missing_docs)]
+        ReentrancyGuardReentrantCall(ReentrancyGuardReentrantCall),
+        #[allow(missing_docs)]
+        SafeERC20FailedOperation(SafeERC20FailedOperation),
+        #[allow(missing_docs)]
+        SignatureIsExpired(SignatureIsExpired),
+        #[allow(missing_docs)]
+        SignatureIsNotEmpty(SignatureIsNotEmpty),
+        #[allow(missing_docs)]
+        UpdatedMakerAmountsTooLow(UpdatedMakerAmountsTooLow),
+        #[allow(missing_docs)]
+        ZeroMakerAmount(ZeroMakerAmount),
+    }
+    impl LiquoriceSettlementErrors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [5u8, 97u8, 216u8, 179u8],
+            [14u8, 54u8, 78u8, 252u8],
+            [19u8, 61u8, 240u8, 41u8],
+            [44u8, 82u8, 17u8, 198u8],
+            [62u8, 229u8, 174u8, 181u8],
+            [74u8, 85u8, 218u8, 32u8],
+            [82u8, 116u8, 175u8, 231u8],
+            [93u8, 82u8, 203u8, 227u8],
+            [96u8, 205u8, 64u8, 45u8],
+            [100u8, 74u8, 230u8, 195u8],
+            [113u8, 29u8, 190u8, 74u8],
+            [119u8, 165u8, 146u8, 3u8],
+            [121u8, 161u8, 191u8, 240u8],
+            [125u8, 97u8, 123u8, 179u8],
+            [129u8, 84u8, 55u8, 75u8],
+            [129u8, 94u8, 29u8, 100u8],
+            [135u8, 118u8, 48u8, 190u8],
+            [148u8, 105u8, 116u8, 68u8],
+            [172u8, 107u8, 5u8, 245u8],
+            [178u8, 243u8, 0u8, 208u8],
+            [179u8, 49u8, 228u8, 33u8],
+            [184u8, 29u8, 88u8, 231u8],
+            [188u8, 13u8, 167u8, 214u8],
+            [192u8, 67u8, 119u8, 211u8],
+            [193u8, 57u8, 234u8, 189u8],
+            [197u8, 104u8, 115u8, 186u8],
+            [200u8, 145u8, 173u8, 210u8],
+            [201u8, 158u8, 136u8, 114u8],
+            [215u8, 139u8, 206u8, 12u8],
+            [246u8, 69u8, 238u8, 223u8],
+            [252u8, 230u8, 152u8, 247u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <InvalidLendingPoolInteraction as alloy_sol_types::SolError>::SIGNATURE,
+            <SignatureIsNotEmpty as alloy_sol_types::SolError>::SIGNATURE,
+            <SignatureIsExpired as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidAmount as alloy_sol_types::SolError>::SIGNATURE,
+            <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidInteractionsBaseTokenAmounts as alloy_sol_types::SolError>::SIGNATURE,
+            <SafeERC20FailedOperation as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidEIP1271Signature as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidSignatureType as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidETHSignSignature as alloy_sol_types::SolError>::SIGNATURE,
+            <UpdatedMakerAmountsTooLow as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidInteractionsQuoteTokenAmounts as alloy_sol_types::SolError>::SIGNATURE,
+            <ReceiverNotManager as alloy_sol_types::SolError>::SIGNATURE,
+            <PartialFillNotSupported as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidSource as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidSigner as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidQuoteTokenAmounts as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidFillAmount as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidDestination as alloy_sol_types::SolError>::SIGNATURE,
+            <ZeroMakerAmount as alloy_sol_types::SolError>::SIGNATURE,
+            <NotMaker as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidEIP712Signature as alloy_sol_types::SolError>::SIGNATURE,
+            <NonceInvalid as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidBaseTokenAmounts as alloy_sol_types::SolError>::SIGNATURE,
+            <NotSolver as alloy_sol_types::SolError>::SIGNATURE,
+            <OrderExpired as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidAsset as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidHooksTarget as alloy_sol_types::SolError>::SIGNATURE,
+            <ECDSAInvalidSignatureS as alloy_sol_types::SolError>::SIGNATURE,
+            <ECDSAInvalidSignature as alloy_sol_types::SolError>::SIGNATURE,
+            <ECDSAInvalidSignatureLength as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(InvalidLendingPoolInteraction),
+            ::core::stringify!(SignatureIsNotEmpty),
+            ::core::stringify!(SignatureIsExpired),
+            ::core::stringify!(InvalidAmount),
+            ::core::stringify!(ReentrancyGuardReentrantCall),
+            ::core::stringify!(InvalidInteractionsBaseTokenAmounts),
+            ::core::stringify!(SafeERC20FailedOperation),
+            ::core::stringify!(InvalidEIP1271Signature),
+            ::core::stringify!(InvalidSignatureType),
+            ::core::stringify!(InvalidETHSignSignature),
+            ::core::stringify!(UpdatedMakerAmountsTooLow),
+            ::core::stringify!(InvalidInteractionsQuoteTokenAmounts),
+            ::core::stringify!(ReceiverNotManager),
+            ::core::stringify!(PartialFillNotSupported),
+            ::core::stringify!(InvalidSource),
+            ::core::stringify!(InvalidSigner),
+            ::core::stringify!(InvalidQuoteTokenAmounts),
+            ::core::stringify!(InvalidFillAmount),
+            ::core::stringify!(InvalidDestination),
+            ::core::stringify!(ZeroMakerAmount),
+            ::core::stringify!(NotMaker),
+            ::core::stringify!(InvalidEIP712Signature),
+            ::core::stringify!(NonceInvalid),
+            ::core::stringify!(InvalidBaseTokenAmounts),
+            ::core::stringify!(NotSolver),
+            ::core::stringify!(OrderExpired),
+            ::core::stringify!(InvalidAsset),
+            ::core::stringify!(InvalidHooksTarget),
+            ::core::stringify!(ECDSAInvalidSignatureS),
+            ::core::stringify!(ECDSAInvalidSignature),
+            ::core::stringify!(ECDSAInvalidSignatureLength),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for LiquoriceSettlementErrors {
+        const COUNT: usize = 31usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "LiquoriceSettlementErrors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::ECDSAInvalidSignature(_) => {
+                    <ECDSAInvalidSignature as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ECDSAInvalidSignatureLength(_) => {
+                    <ECDSAInvalidSignatureLength as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ECDSAInvalidSignatureS(_) => {
+                    <ECDSAInvalidSignatureS as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidAmount(_) => <InvalidAmount as alloy_sol_types::SolError>::SELECTOR,
+                Self::InvalidAsset(_) => <InvalidAsset as alloy_sol_types::SolError>::SELECTOR,
+                Self::InvalidBaseTokenAmounts(_) => {
+                    <InvalidBaseTokenAmounts as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidDestination(_) => {
+                    <InvalidDestination as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidEIP1271Signature(_) => {
+                    <InvalidEIP1271Signature as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidEIP712Signature(_) => {
+                    <InvalidEIP712Signature as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidETHSignSignature(_) => {
+                    <InvalidETHSignSignature as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidFillAmount(_) => {
+                    <InvalidFillAmount as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidHooksTarget(_) => {
+                    <InvalidHooksTarget as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidInteractionsBaseTokenAmounts(_) => {
+                    <InvalidInteractionsBaseTokenAmounts as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidInteractionsQuoteTokenAmounts(_) => {
+                    <InvalidInteractionsQuoteTokenAmounts as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidLendingPoolInteraction(_) => {
+                    <InvalidLendingPoolInteraction as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidQuoteTokenAmounts(_) => {
+                    <InvalidQuoteTokenAmounts as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidSignatureType(_) => {
+                    <InvalidSignatureType as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidSigner(_) => <InvalidSigner as alloy_sol_types::SolError>::SELECTOR,
+                Self::InvalidSource(_) => <InvalidSource as alloy_sol_types::SolError>::SELECTOR,
+                Self::NonceInvalid(_) => <NonceInvalid as alloy_sol_types::SolError>::SELECTOR,
+                Self::NotMaker(_) => <NotMaker as alloy_sol_types::SolError>::SELECTOR,
+                Self::NotSolver(_) => <NotSolver as alloy_sol_types::SolError>::SELECTOR,
+                Self::OrderExpired(_) => <OrderExpired as alloy_sol_types::SolError>::SELECTOR,
+                Self::PartialFillNotSupported(_) => {
+                    <PartialFillNotSupported as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ReceiverNotManager(_) => {
+                    <ReceiverNotManager as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ReentrancyGuardReentrantCall(_) => {
+                    <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SafeERC20FailedOperation(_) => {
+                    <SafeERC20FailedOperation as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SignatureIsExpired(_) => {
+                    <SignatureIsExpired as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::SignatureIsNotEmpty(_) => {
+                    <SignatureIsNotEmpty as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::UpdatedMakerAmountsTooLow(_) => {
+                    <UpdatedMakerAmountsTooLow as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ZeroMakerAmount(_) => {
+                    <ZeroMakerAmount as alloy_sol_types::SolError>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<LiquoriceSettlementErrors>] = &[
+                {
+                    fn InvalidLendingPoolInteraction(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidLendingPoolInteraction as alloy_sol_types::SolError>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementErrors::InvalidLendingPoolInteraction,
+                            )
+                    }
+                    InvalidLendingPoolInteraction
+                },
+                {
+                    fn SignatureIsNotEmpty(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <SignatureIsNotEmpty as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::SignatureIsNotEmpty)
+                    }
+                    SignatureIsNotEmpty
+                },
+                {
+                    fn SignatureIsExpired(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <SignatureIsExpired as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::SignatureIsExpired)
+                    }
+                    SignatureIsExpired
+                },
+                {
+                    fn InvalidAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidAmount as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidAmount)
+                    }
+                    InvalidAmount
+                },
+                {
+                    fn ReentrancyGuardReentrantCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::ReentrancyGuardReentrantCall)
+                    }
+                    ReentrancyGuardReentrantCall
+                },
+                {
+                    fn InvalidInteractionsBaseTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidInteractionsBaseTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementErrors::InvalidInteractionsBaseTokenAmounts,
+                            )
+                    }
+                    InvalidInteractionsBaseTokenAmounts
+                },
+                {
+                    fn SafeERC20FailedOperation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::SafeERC20FailedOperation)
+                    }
+                    SafeERC20FailedOperation
+                },
+                {
+                    fn InvalidEIP1271Signature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidEIP1271Signature as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidEIP1271Signature)
+                    }
+                    InvalidEIP1271Signature
+                },
+                {
+                    fn InvalidSignatureType(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidSignatureType as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidSignatureType)
+                    }
+                    InvalidSignatureType
+                },
+                {
+                    fn InvalidETHSignSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidETHSignSignature as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidETHSignSignature)
+                    }
+                    InvalidETHSignSignature
+                },
+                {
+                    fn UpdatedMakerAmountsTooLow(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <UpdatedMakerAmountsTooLow as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::UpdatedMakerAmountsTooLow)
+                    }
+                    UpdatedMakerAmountsTooLow
+                },
+                {
+                    fn InvalidInteractionsQuoteTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidInteractionsQuoteTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementErrors::InvalidInteractionsQuoteTokenAmounts,
+                            )
+                    }
+                    InvalidInteractionsQuoteTokenAmounts
+                },
+                {
+                    fn ReceiverNotManager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ReceiverNotManager as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::ReceiverNotManager)
+                    }
+                    ReceiverNotManager
+                },
+                {
+                    fn PartialFillNotSupported(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <PartialFillNotSupported as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::PartialFillNotSupported)
+                    }
+                    PartialFillNotSupported
+                },
+                {
+                    fn InvalidSource(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidSource as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidSource)
+                    }
+                    InvalidSource
+                },
+                {
+                    fn InvalidSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidSigner as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidSigner)
+                    }
+                    InvalidSigner
+                },
+                {
+                    fn InvalidQuoteTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidQuoteTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::InvalidQuoteTokenAmounts)
+                    }
+                    InvalidQuoteTokenAmounts
+                },
+                {
+                    fn InvalidFillAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidFillAmount as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidFillAmount)
+                    }
+                    InvalidFillAmount
+                },
+                {
+                    fn InvalidDestination(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidDestination as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidDestination)
+                    }
+                    InvalidDestination
+                },
+                {
+                    fn ZeroMakerAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ZeroMakerAmount as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::ZeroMakerAmount)
+                    }
+                    ZeroMakerAmount
+                },
+                {
+                    fn NotMaker(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <NotMaker as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::NotMaker)
+                    }
+                    NotMaker
+                },
+                {
+                    fn InvalidEIP712Signature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidEIP712Signature as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidEIP712Signature)
+                    }
+                    InvalidEIP712Signature
+                },
+                {
+                    fn NonceInvalid(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <NonceInvalid as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::NonceInvalid)
+                    }
+                    NonceInvalid
+                },
+                {
+                    fn InvalidBaseTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidBaseTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidBaseTokenAmounts)
+                    }
+                    InvalidBaseTokenAmounts
+                },
+                {
+                    fn NotSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <NotSolver as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::NotSolver)
+                    }
+                    NotSolver
+                },
+                {
+                    fn OrderExpired(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <OrderExpired as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::OrderExpired)
+                    }
+                    OrderExpired
+                },
+                {
+                    fn InvalidAsset(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidAsset as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidAsset)
+                    }
+                    InvalidAsset
+                },
+                {
+                    fn InvalidHooksTarget(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidHooksTarget as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::InvalidHooksTarget)
+                    }
+                    InvalidHooksTarget
+                },
+                {
+                    fn ECDSAInvalidSignatureS(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ECDSAInvalidSignatureS as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::ECDSAInvalidSignatureS)
+                    }
+                    ECDSAInvalidSignatureS
+                },
+                {
+                    fn ECDSAInvalidSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ECDSAInvalidSignature as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementErrors::ECDSAInvalidSignature)
+                    }
+                    ECDSAInvalidSignature
+                },
+                {
+                    fn ECDSAInvalidSignatureLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ECDSAInvalidSignatureLength as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::ECDSAInvalidSignatureLength)
+                    }
+                    ECDSAInvalidSignatureLength
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                LiquoriceSettlementErrors,
+            >] = &[
+                {
+                    fn InvalidLendingPoolInteraction(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidLendingPoolInteraction as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementErrors::InvalidLendingPoolInteraction,
+                            )
+                    }
+                    InvalidLendingPoolInteraction
+                },
+                {
+                    fn SignatureIsNotEmpty(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <SignatureIsNotEmpty as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::SignatureIsNotEmpty)
+                    }
+                    SignatureIsNotEmpty
+                },
+                {
+                    fn SignatureIsExpired(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <SignatureIsExpired as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::SignatureIsExpired)
+                    }
+                    SignatureIsExpired
+                },
+                {
+                    fn InvalidAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::InvalidAmount)
+                    }
+                    InvalidAmount
+                },
+                {
+                    fn ReentrancyGuardReentrantCall(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::ReentrancyGuardReentrantCall)
+                    }
+                    ReentrancyGuardReentrantCall
+                },
+                {
+                    fn InvalidInteractionsBaseTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidInteractionsBaseTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementErrors::InvalidInteractionsBaseTokenAmounts,
+                            )
+                    }
+                    InvalidInteractionsBaseTokenAmounts
+                },
+                {
+                    fn SafeERC20FailedOperation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::SafeERC20FailedOperation)
+                    }
+                    SafeERC20FailedOperation
+                },
+                {
+                    fn InvalidEIP1271Signature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidEIP1271Signature as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::InvalidEIP1271Signature)
+                    }
+                    InvalidEIP1271Signature
+                },
+                {
+                    fn InvalidSignatureType(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidSignatureType as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::InvalidSignatureType)
+                    }
+                    InvalidSignatureType
+                },
+                {
+                    fn InvalidETHSignSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidETHSignSignature as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::InvalidETHSignSignature)
+                    }
+                    InvalidETHSignSignature
+                },
+                {
+                    fn UpdatedMakerAmountsTooLow(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <UpdatedMakerAmountsTooLow as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::UpdatedMakerAmountsTooLow)
+                    }
+                    UpdatedMakerAmountsTooLow
+                },
+                {
+                    fn InvalidInteractionsQuoteTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidInteractionsQuoteTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                LiquoriceSettlementErrors::InvalidInteractionsQuoteTokenAmounts,
+                            )
+                    }
+                    InvalidInteractionsQuoteTokenAmounts
+                },
+                {
+                    fn ReceiverNotManager(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ReceiverNotManager as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::ReceiverNotManager)
+                    }
+                    ReceiverNotManager
+                },
+                {
+                    fn PartialFillNotSupported(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <PartialFillNotSupported as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::PartialFillNotSupported)
+                    }
+                    PartialFillNotSupported
+                },
+                {
+                    fn InvalidSource(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidSource as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::InvalidSource)
+                    }
+                    InvalidSource
+                },
+                {
+                    fn InvalidSigner(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidSigner as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::InvalidSigner)
+                    }
+                    InvalidSigner
+                },
+                {
+                    fn InvalidQuoteTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidQuoteTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::InvalidQuoteTokenAmounts)
+                    }
+                    InvalidQuoteTokenAmounts
+                },
+                {
+                    fn InvalidFillAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidFillAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::InvalidFillAmount)
+                    }
+                    InvalidFillAmount
+                },
+                {
+                    fn InvalidDestination(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidDestination as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::InvalidDestination)
+                    }
+                    InvalidDestination
+                },
+                {
+                    fn ZeroMakerAmount(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ZeroMakerAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::ZeroMakerAmount)
+                    }
+                    ZeroMakerAmount
+                },
+                {
+                    fn NotMaker(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <NotMaker as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::NotMaker)
+                    }
+                    NotMaker
+                },
+                {
+                    fn InvalidEIP712Signature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidEIP712Signature as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::InvalidEIP712Signature)
+                    }
+                    InvalidEIP712Signature
+                },
+                {
+                    fn NonceInvalid(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <NonceInvalid as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::NonceInvalid)
+                    }
+                    NonceInvalid
+                },
+                {
+                    fn InvalidBaseTokenAmounts(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidBaseTokenAmounts as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::InvalidBaseTokenAmounts)
+                    }
+                    InvalidBaseTokenAmounts
+                },
+                {
+                    fn NotSolver(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <NotSolver as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::NotSolver)
+                    }
+                    NotSolver
+                },
+                {
+                    fn OrderExpired(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <OrderExpired as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::OrderExpired)
+                    }
+                    OrderExpired
+                },
+                {
+                    fn InvalidAsset(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidAsset as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
+                            .map(LiquoriceSettlementErrors::InvalidAsset)
+                    }
+                    InvalidAsset
+                },
+                {
+                    fn InvalidHooksTarget(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <InvalidHooksTarget as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(LiquoriceSettlementErrors::InvalidHooksTarget)
+                    }
+                    InvalidHooksTarget
+                },
+                {
+                    fn ECDSAInvalidSignatureS(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ECDSAInvalidSignatureS as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::ECDSAInvalidSignatureS)
+                    }
+                    ECDSAInvalidSignatureS
+                },
+                {
+                    fn ECDSAInvalidSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ECDSAInvalidSignature as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::ECDSAInvalidSignature)
+                    }
+                    ECDSAInvalidSignature
+                },
+                {
+                    fn ECDSAInvalidSignatureLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<LiquoriceSettlementErrors> {
+                        <ECDSAInvalidSignatureLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(LiquoriceSettlementErrors::ECDSAInvalidSignatureLength)
+                    }
+                    ECDSAInvalidSignatureLength
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::ECDSAInvalidSignature(inner) => {
+                    <ECDSAInvalidSignature as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ECDSAInvalidSignatureLength(inner) => {
+                    <ECDSAInvalidSignatureLength as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ECDSAInvalidSignatureS(inner) => {
+                    <ECDSAInvalidSignatureS as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidAmount(inner) => {
+                    <InvalidAmount as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidAsset(inner) => {
+                    <InvalidAsset as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidBaseTokenAmounts(inner) => {
+                    <InvalidBaseTokenAmounts as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidDestination(inner) => {
+                    <InvalidDestination as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidEIP1271Signature(inner) => {
+                    <InvalidEIP1271Signature as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidEIP712Signature(inner) => {
+                    <InvalidEIP712Signature as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidETHSignSignature(inner) => {
+                    <InvalidETHSignSignature as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidFillAmount(inner) => {
+                    <InvalidFillAmount as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidHooksTarget(inner) => {
+                    <InvalidHooksTarget as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidInteractionsBaseTokenAmounts(inner) => {
+                    <InvalidInteractionsBaseTokenAmounts as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidInteractionsQuoteTokenAmounts(inner) => {
+                    <InvalidInteractionsQuoteTokenAmounts as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidLendingPoolInteraction(inner) => {
+                    <InvalidLendingPoolInteraction as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidQuoteTokenAmounts(inner) => {
+                    <InvalidQuoteTokenAmounts as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidSignatureType(inner) => {
+                    <InvalidSignatureType as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::InvalidSigner(inner) => {
+                    <InvalidSigner as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidSource(inner) => {
+                    <InvalidSource as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::NonceInvalid(inner) => {
+                    <NonceInvalid as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::NotMaker(inner) => {
+                    <NotMaker as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::NotSolver(inner) => {
+                    <NotSolver as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::OrderExpired(inner) => {
+                    <OrderExpired as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::PartialFillNotSupported(inner) => {
+                    <PartialFillNotSupported as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ReceiverNotManager(inner) => {
+                    <ReceiverNotManager as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ReentrancyGuardReentrantCall(inner) => {
+                    <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::SafeERC20FailedOperation(inner) => {
+                    <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::SignatureIsExpired(inner) => {
+                    <SignatureIsExpired as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::SignatureIsNotEmpty(inner) => {
+                    <SignatureIsNotEmpty as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::UpdatedMakerAmountsTooLow(inner) => {
+                    <UpdatedMakerAmountsTooLow as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ZeroMakerAmount(inner) => {
+                    <ZeroMakerAmount as alloy_sol_types::SolError>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::ECDSAInvalidSignature(inner) => {
+                    <ECDSAInvalidSignature as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::ECDSAInvalidSignatureLength(inner) => {
+                    <ECDSAInvalidSignatureLength as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::ECDSAInvalidSignatureS(inner) => {
+                    <ECDSAInvalidSignatureS as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidAmount(inner) => {
+                    <InvalidAmount as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidAsset(inner) => {
+                    <InvalidAsset as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidBaseTokenAmounts(inner) => {
+                    <InvalidBaseTokenAmounts as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidDestination(inner) => {
+                    <InvalidDestination as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidEIP1271Signature(inner) => {
+                    <InvalidEIP1271Signature as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidEIP712Signature(inner) => {
+                    <InvalidEIP712Signature as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidETHSignSignature(inner) => {
+                    <InvalidETHSignSignature as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidFillAmount(inner) => {
+                    <InvalidFillAmount as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidHooksTarget(inner) => {
+                    <InvalidHooksTarget as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidInteractionsBaseTokenAmounts(inner) => {
+                    <InvalidInteractionsBaseTokenAmounts as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidInteractionsQuoteTokenAmounts(inner) => {
+                    <InvalidInteractionsQuoteTokenAmounts as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidLendingPoolInteraction(inner) => {
+                    <InvalidLendingPoolInteraction as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidQuoteTokenAmounts(inner) => {
+                    <InvalidQuoteTokenAmounts as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidSignatureType(inner) => {
+                    <InvalidSignatureType as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidSigner(inner) => {
+                    <InvalidSigner as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::InvalidSource(inner) => {
+                    <InvalidSource as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::NonceInvalid(inner) => {
+                    <NonceInvalid as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::NotMaker(inner) => {
+                    <NotMaker as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::NotSolver(inner) => {
+                    <NotSolver as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::OrderExpired(inner) => {
+                    <OrderExpired as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::PartialFillNotSupported(inner) => {
+                    <PartialFillNotSupported as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::ReceiverNotManager(inner) => {
+                    <ReceiverNotManager as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::ReentrancyGuardReentrantCall(inner) => {
+                    <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::SafeERC20FailedOperation(inner) => {
+                    <SafeERC20FailedOperation as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::SignatureIsExpired(inner) => {
+                    <SignatureIsExpired as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::SignatureIsNotEmpty(inner) => {
+                    <SignatureIsNotEmpty as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::UpdatedMakerAmountsTooLow(inner) => {
+                    <UpdatedMakerAmountsTooLow as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::ZeroMakerAmount(inner) => {
+                    <ZeroMakerAmount as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    ///Container for all the [`LiquoriceSettlement`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum LiquoriceSettlementEvents {
+        #[allow(missing_docs)]
+        Interaction(Interaction),
+        #[allow(missing_docs)]
+        TradeOrder(TradeOrder),
+    }
+    impl LiquoriceSettlementEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                15u8, 206u8, 0u8, 124u8, 56u8, 198u8, 200u8, 237u8, 158u8, 84u8, 91u8, 58u8, 20u8,
+                128u8, 149u8, 118u8, 39u8, 56u8, 97u8, 143u8, 140u8, 33u8, 182u8, 115u8, 34u8,
+                38u8, 19u8, 228u8, 212u8, 87u8, 52u8, 182u8,
+            ],
+            [
+                237u8, 153u8, 130u8, 126u8, 251u8, 55u8, 1u8, 111u8, 34u8, 117u8, 249u8, 140u8,
+                75u8, 207u8, 113u8, 199u8, 85u8, 28u8, 117u8, 213u8, 158u8, 155u8, 69u8, 15u8,
+                121u8, 250u8, 50u8, 230u8, 11u8, 230u8, 114u8, 194u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <TradeOrder as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Interaction as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(TradeOrder),
+            ::core::stringify!(Interaction),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for LiquoriceSettlementEvents {
+        const COUNT: usize = 2usize;
+        const NAME: &'static str = "LiquoriceSettlementEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Interaction as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Interaction as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Interaction)
+                }
+                Some(<TradeOrder as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TradeOrder as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TradeOrder)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for LiquoriceSettlementEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Interaction(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TradeOrder(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Interaction(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TradeOrder(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`LiquoriceSettlement`](self) contract instance.
+
+    See the [wrapper's documentation](`LiquoriceSettlementInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> LiquoriceSettlementInstance<P, N> {
+        LiquoriceSettlementInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        authenticator_: alloy_sol_types::private::Address,
+        repository_: alloy_sol_types::private::Address,
+        permit2_: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<LiquoriceSettlementInstance<P, N>>>
+    {
+        LiquoriceSettlementInstance::<P, N>::deploy(
+            __provider,
+            authenticator_,
+            repository_,
+            permit2_,
+        )
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        authenticator_: alloy_sol_types::private::Address,
+        repository_: alloy_sol_types::private::Address,
+        permit2_: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        LiquoriceSettlementInstance::<P, N>::deploy_builder(
+            __provider,
+            authenticator_,
+            repository_,
+            permit2_,
+        )
+    }
+    /**A [`LiquoriceSettlement`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`LiquoriceSettlement`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct LiquoriceSettlementInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for LiquoriceSettlementInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("LiquoriceSettlementInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LiquoriceSettlementInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`LiquoriceSettlement`](self) contract instance.
+
+        See the [wrapper's documentation](`LiquoriceSettlementInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            authenticator_: alloy_sol_types::private::Address,
+            repository_: alloy_sol_types::private::Address,
+            permit2_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<LiquoriceSettlementInstance<P, N>> {
+            let call_builder =
+                Self::deploy_builder(__provider, authenticator_, repository_, permit2_);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            authenticator_: alloy_sol_types::private::Address,
+            repository_: alloy_sol_types::private::Address,
+            permit2_: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        authenticator_,
+                        repository_,
+                        permit2_,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> LiquoriceSettlementInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> LiquoriceSettlementInstance<P, N> {
+            LiquoriceSettlementInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LiquoriceSettlementInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`AUTHENTICATOR`] function.
+        pub fn AUTHENTICATOR(&self) -> alloy_contract::SolCallBuilder<&P, AUTHENTICATORCall, N> {
+            self.call_builder(&AUTHENTICATORCall)
+        }
+
+        ///Creates a new call builder for the [`BALANCE_MANAGER`] function.
+        pub fn BALANCE_MANAGER(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, BALANCE_MANAGERCall, N> {
+            self.call_builder(&BALANCE_MANAGERCall)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`REPOSITORY`] function.
+        pub fn REPOSITORY(&self) -> alloy_contract::SolCallBuilder<&P, REPOSITORYCall, N> {
+            self.call_builder(&REPOSITORYCall)
+        }
+
+        ///Creates a new call builder for the [`cancelLimitOrder`] function.
+        pub fn cancelLimitOrder(
+            &self,
+            nonce: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, cancelLimitOrderCall, N> {
+            self.call_builder(&cancelLimitOrderCall { nonce })
+        }
+
+        ///Creates a new call builder for the [`hashBaseTokenData`] function.
+        pub fn hashBaseTokenData(
+            &self,
+            _baseTokenData: <ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, hashBaseTokenDataCall, N> {
+            self.call_builder(&hashBaseTokenDataCall { _baseTokenData })
+        }
+
+        ///Creates a new call builder for the [`hashOrder`] function.
+        pub fn hashOrder(
+            &self,
+            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, hashOrderCall, N> {
+            self.call_builder(&hashOrderCall { _order })
+        }
+
+        ///Creates a new call builder for the [`hashQuoteTokenData`] function.
+        pub fn hashQuoteTokenData(
+            &self,
+            _quoteTokenData: <ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, hashQuoteTokenDataCall, N> {
+            self.call_builder(&hashQuoteTokenDataCall { _quoteTokenData })
+        }
+
+        ///Creates a new call builder for the [`hashSingleOrder`] function.
+        pub fn hashSingleOrder(
+            &self,
+            _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, hashSingleOrderCall, N> {
+            self.call_builder(&hashSingleOrderCall { _order })
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            _hash: alloy_sol_types::private::FixedBytes<32>,
+            _signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { _hash, _signature })
+        }
+
+        ///Creates a new call builder for the [`settle`] function.
+        pub fn settle(
+            &self,
+            _signer: alloy_sol_types::private::Address,
+            _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+            _interactions: alloy_sol_types::private::Vec<
+                <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+            >,
+            _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+            _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, settleCall, N> {
+            self.call_builder(&settleCall {
+                _signer,
+                _filledTakerAmount,
+                _order,
+                _interactions,
+                _hooks,
+                _makerSignature,
+                _takerSignature,
+            })
+        }
+
+        ///Creates a new call builder for the [`settleSingle`] function.
+        pub fn settleSingle(
+            &self,
+            _signer: alloy_sol_types::private::Address,
+            _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+            _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+            _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, settleSingleCall, N> {
+            self.call_builder(&settleSingleCall {
+                _signer,
+                _order,
+                _makerSignature,
+                _filledTakerAmount,
+                _takerSignature,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`settleSingleWithPermitsSignatures`] function.
+        pub fn settleSingleWithPermitsSignatures(
+            &self,
+            _signer: alloy_sol_types::private::Address,
+            _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+            _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+            _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, settleSingleWithPermitsSignaturesCall, N> {
+            self.call_builder(&settleSingleWithPermitsSignaturesCall {
+                _signer,
+                _order,
+                _makerSignature,
+                _filledTakerAmount,
+                _takerSignature,
+                _takerPermitInfo,
+            })
+        }
+
+        ///Creates a new call builder for the [`settleWithPermitsSignatures`]
+        /// function.
+        pub fn settleWithPermitsSignatures(
+            &self,
+            _signer: alloy_sol_types::private::Address,
+            _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
+            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+            _interactions: alloy_sol_types::private::Vec<
+                <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+            >,
+            _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+            _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, settleWithPermitsSignaturesCall, N> {
+            self.call_builder(&settleWithPermitsSignaturesCall {
+                _signer,
+                _filledTakerAmount,
+                _order,
+                _interactions,
+                _hooks,
+                _makerSignature,
+                _takerSignature,
+                _takerPermitInfo,
+            })
+        }
+
+        ///Creates a new call builder for the [`validateHooks`] function.
+        pub fn validateHooks(
+            &self,
+            _repository: alloy_sol_types::private::Address,
+            _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, validateHooksCall, N> {
+            self.call_builder(&validateHooksCall {
+                _repository,
+                _hooks,
+            })
+        }
+
+        ///Creates a new call builder for the [`validateInteractions`]
+        /// function.
+        pub fn validateInteractions(
+            &self,
+            _repository: alloy_sol_types::private::Address,
+            _signer: alloy_sol_types::private::Address,
+            _isPartialFill: bool,
+            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+            _interactions: alloy_sol_types::private::Vec<
+                <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, validateInteractionsCall, N> {
+            self.call_builder(&validateInteractionsCall {
+                _repository,
+                _signer,
+                _isPartialFill,
+                _order,
+                _interactions,
+            })
+        }
+
+        ///Creates a new call builder for the [`validateOrderAmounts`]
+        /// function.
+        pub fn validateOrderAmounts(
+            &self,
+            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, validateOrderAmountsCall, N> {
+            self.call_builder(&validateOrderAmountsCall { _order })
+        }
+
+        ///Creates a new call builder for the [`validateSignature`] function.
+        pub fn validateSignature(
+            &self,
+            _validationAddress: alloy_sol_types::private::Address,
+            _hash: alloy_sol_types::private::FixedBytes<32>,
+            _signature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, validateSignatureCall, N> {
+            self.call_builder(&validateSignatureCall {
+                _validationAddress,
+                _hash,
+                _signature,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        LiquoriceSettlementInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Interaction`] event.
+        pub fn Interaction_filter(&self) -> alloy_contract::Event<&P, Interaction, N> {
+            self.event_filter::<Interaction>()
+        }
+
+        ///Creates a new event filter for the [`TradeOrder`] event.
+        pub fn TradeOrder_filter(&self) -> alloy_contract::Event<&P, TradeOrder, N> {
+            self.event_filter::<TradeOrder>()
+        }
+    }
+}
+pub type Instance = LiquoriceSettlement::LiquoriceSettlementInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x0448633eb8B0A42EfED924C42069E0DcF08fb552"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x0448633eb8B0A42EfED924C42069E0DcF08fb552"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/nonstandarderc20balances/Cargo.toml b/contracts/generated/contracts-generated/nonstandarderc20balances/Cargo.toml
new file mode 100644
index 0000000000..74e9a223ba
--- /dev/null
+++ b/contracts/generated/contracts-generated/nonstandarderc20balances/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-nonstandarderc20balances"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/nonstandarderc20balances/src/lib.rs b/contracts/generated/contracts-generated/nonstandarderc20balances/src/lib.rs
new file mode 100644
index 0000000000..f0f586feff
--- /dev/null
+++ b/contracts/generated/contracts-generated/nonstandarderc20balances/src/lib.rs
@@ -0,0 +1,1643 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface NonStandardERC20Balances {
+    function allowance(address user, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external;
+    function balanceOf(address user) external view returns (uint256);
+    function mint(address user, uint256 amount) external;
+    function transfer(address to, uint256 amount) external;
+    function transferFrom(address from, address to, uint256 amount) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod NonStandardERC20Balances {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x05\x0E\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0oW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0MW\x80cp\xA0\x821\x14a\x01\x0BW\x80c\xA9\x05\x9C\xBB\x14a\x01UW\x80c\xDDb\xED>\x14a\x01hW__\xFD[\x80c\t^\xA7\xB3\x14a\0sW\x80c#\xB8r\xDD\x14a\0\xBBW\x80c@\xC1\x0F\x19\x14a\0\xCEW[__\xFD[a\0\xB9a\0\x816`\x04a\x03\xC4V[3_\x90\x81R` \x81\x81R`@\x80\x83 s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x90\x95\x16\x83R`\x01\x90\x94\x01\x90R\x91\x90\x91 UV[\0[a\0\xB9a\0\xC96`\x04a\x03\xECV[a\x01{V[a\0\xB9a\0\xDC6`\x04a\x03\xC4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16_\x90\x81R` \x81\x90R`@\x90 `\x01\x81U`\x02\x01UV[a\x01Ca\x01\x196`\x04a\x04&V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x90\x81R` \x81\x90R`@\x90 `\x02\x01T\x90V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xB9a\x01c6`\x04a\x03\xC4V[a\x02\xA7V[a\x01Ca\x01v6`\x04a\x04FV[a\x03aV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 3\x84R`\x01\x01\x90\x91R\x81 \x80T\x83\x92\x90a\x01\xBB\x90\x84\x90a\x04\xA4V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x01\xF7\x90\x84\x90a\x04\xA4V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02,\x83a\x04\xB7V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02h\x90\x84\x90a\x04\xEEV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02\x9D\x83a\x04\xB7V[\x91\x90PUPPPPV[3_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02\xC8\x90\x84\x90a\x04\xA4V[\x90\x91UPP3_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02\xE7\x83a\x04\xB7V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x03#\x90\x84\x90a\x04\xEEV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x03X\x83a\x04\xB7V[\x91\x90PUPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x85\x16\x83R`\x01\x90\x93\x01\x90R T[\x92\x91PPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\xBFW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x03\xD5W__\xFD[a\x03\xDE\x83a\x03\x9CV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x03\xFEW__\xFD[a\x04\x07\x84a\x03\x9CV[\x92Pa\x04\x15` \x85\x01a\x03\x9CV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x046W__\xFD[a\x04?\x82a\x03\x9CV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x04WW__\xFD[a\x04`\x83a\x03\x9CV[\x91Pa\x04n` \x84\x01a\x03\x9CV[\x90P\x92P\x92\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x03\x96Wa\x03\x96a\x04wV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x03a\x04\xE7Wa\x04\xE7a\x04wV[P`\x01\x01\x90V[\x80\x82\x01\x80\x82\x11\x15a\x03\x96Wa\x03\x96a\x04wV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0oW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0MW\x80cp\xA0\x821\x14a\x01\x0BW\x80c\xA9\x05\x9C\xBB\x14a\x01UW\x80c\xDDb\xED>\x14a\x01hW__\xFD[\x80c\t^\xA7\xB3\x14a\0sW\x80c#\xB8r\xDD\x14a\0\xBBW\x80c@\xC1\x0F\x19\x14a\0\xCEW[__\xFD[a\0\xB9a\0\x816`\x04a\x03\xC4V[3_\x90\x81R` \x81\x81R`@\x80\x83 s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x90\x95\x16\x83R`\x01\x90\x94\x01\x90R\x91\x90\x91 UV[\0[a\0\xB9a\0\xC96`\x04a\x03\xECV[a\x01{V[a\0\xB9a\0\xDC6`\x04a\x03\xC4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16_\x90\x81R` \x81\x90R`@\x90 `\x01\x81U`\x02\x01UV[a\x01Ca\x01\x196`\x04a\x04&V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x90\x81R` \x81\x90R`@\x90 `\x02\x01T\x90V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xB9a\x01c6`\x04a\x03\xC4V[a\x02\xA7V[a\x01Ca\x01v6`\x04a\x04FV[a\x03aV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 3\x84R`\x01\x01\x90\x91R\x81 \x80T\x83\x92\x90a\x01\xBB\x90\x84\x90a\x04\xA4V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x01\xF7\x90\x84\x90a\x04\xA4V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02,\x83a\x04\xB7V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02h\x90\x84\x90a\x04\xEEV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02\x9D\x83a\x04\xB7V[\x91\x90PUPPPPV[3_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02\xC8\x90\x84\x90a\x04\xA4V[\x90\x91UPP3_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02\xE7\x83a\x04\xB7V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x03#\x90\x84\x90a\x04\xEEV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x03X\x83a\x04\xB7V[\x91\x90PUPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x85\x16\x83R`\x01\x90\x93\x01\x90R T[\x92\x91PPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\xBFW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x03\xD5W__\xFD[a\x03\xDE\x83a\x03\x9CV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x03\xFEW__\xFD[a\x04\x07\x84a\x03\x9CV[\x92Pa\x04\x15` \x85\x01a\x03\x9CV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x046W__\xFD[a\x04?\x82a\x03\x9CV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x04WW__\xFD[a\x04`\x83a\x03\x9CV[\x91Pa\x04n` \x84\x01a\x03\x9CV[\x90P\x92P\x92\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x03\x96Wa\x03\x96a\x04wV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x03a\x04\xE7Wa\x04\xE7a\x04wV[P`\x01\x01\x90V[\x80\x82\x01\x80\x82\x11\x15a\x03\x96Wa\x03\x96a\x04wV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address user, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.user, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        user: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl approveReturn {
+            fn _tokenize(&self) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = approveReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                approveReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address user) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.user,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { user: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
+    ```solidity
+    function mint(address user, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`mint(address,uint256)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.user, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        user: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = mintReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                mintReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address to, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferReturn {
+            fn _tokenize(&self) -> <transferCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = transferReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address from, address to, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.from, value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        from: tuple.0,
+                        to: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferFromReturn {
+            fn _tokenize(&self) -> <transferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = transferFromReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferFromReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`NonStandardERC20Balances`](self) function calls.
+    #[derive(Clone)]
+    pub enum NonStandardERC20BalancesCalls {
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl NonStandardERC20BalancesCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [9u8, 94u8, 167u8, 179u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [64u8, 193u8, 15u8, 25u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(approve),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(mint),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(transfer),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for NonStandardERC20BalancesCalls {
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
+        const NAME: &'static str = "NonStandardERC20BalancesCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>] = &[
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(NonStandardERC20BalancesCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(NonStandardERC20BalancesCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(NonStandardERC20BalancesCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(NonStandardERC20BalancesCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(NonStandardERC20BalancesCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(NonStandardERC20BalancesCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                NonStandardERC20BalancesCalls,
+            >] = &[
+                {
+                    fn approve(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(NonStandardERC20BalancesCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(NonStandardERC20BalancesCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(NonStandardERC20BalancesCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(NonStandardERC20BalancesCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn transfer(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(NonStandardERC20BalancesCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn allowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<NonStandardERC20BalancesCalls>
+                    {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(NonStandardERC20BalancesCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`NonStandardERC20Balances`](self) contract instance.
+
+    See the [wrapper's documentation](`NonStandardERC20BalancesInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> NonStandardERC20BalancesInstance<P, N> {
+        NonStandardERC20BalancesInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<
+        Output = alloy_contract::Result<NonStandardERC20BalancesInstance<P, N>>,
+    > {
+        NonStandardERC20BalancesInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        NonStandardERC20BalancesInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`NonStandardERC20Balances`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`NonStandardERC20Balances`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct NonStandardERC20BalancesInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for NonStandardERC20BalancesInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("NonStandardERC20BalancesInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        NonStandardERC20BalancesInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`NonStandardERC20Balances`](self) contract instance.
+
+        See the [wrapper's documentation](`NonStandardERC20BalancesInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+        ) -> alloy_contract::Result<NonStandardERC20BalancesInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> NonStandardERC20BalancesInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> NonStandardERC20BalancesInstance<P, N> {
+            NonStandardERC20BalancesInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        NonStandardERC20BalancesInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            user: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { user, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            user: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { user })
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            user: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { user, amount })
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { to, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            from: alloy_sol_types::private::Address,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall { from, to, amount })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        NonStandardERC20BalancesInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    NonStandardERC20Balances::NonStandardERC20BalancesInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/pancakerouter/Cargo.toml b/contracts/generated/contracts-generated/pancakerouter/Cargo.toml
new file mode 100644
index 0000000000..0f4463b992
--- /dev/null
+++ b/contracts/generated/contracts-generated/pancakerouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-pancakerouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/pancakerouter/src/lib.rs b/contracts/generated/contracts-generated/pancakerouter/src/lib.rs
new file mode 100644
index 0000000000..23b132d8fb
--- /dev/null
+++ b/contracts/generated/contracts-generated/pancakerouter/src/lib.rs
@@ -0,0 +1,7549 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface PancakeRouter {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod PancakeRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`PancakeRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum PancakeRouterCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl PancakeRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for PancakeRouterCalls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "PancakeRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<PancakeRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(PancakeRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<PancakeRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(PancakeRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(PancakeRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(PancakeRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                PancakeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(PancakeRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(PancakeRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(PancakeRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`PancakeRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`PancakeRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> PancakeRouterInstance<P, N> {
+        PancakeRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`PancakeRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`PancakeRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct PancakeRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for PancakeRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("PancakeRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        PancakeRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`PancakeRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`PancakeRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> PancakeRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> PancakeRouterInstance<P, N> {
+            PancakeRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        PancakeRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        PancakeRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = PancakeRouter::PancakeRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xEfF92A263d31888d860bD50809A8D171709b7b1c"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x10ED43C718714eb63d5aA57B78B54704E256024E"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/permit2/Cargo.toml b/contracts/generated/contracts-generated/permit2/Cargo.toml
new file mode 100644
index 0000000000..364b5e1cc0
--- /dev/null
+++ b/contracts/generated/contracts-generated/permit2/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-permit2"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/permit2/src/lib.rs b/contracts/generated/contracts-generated/permit2/src/lib.rs
new file mode 100644
index 0000000000..26243a5948
--- /dev/null
+++ b/contracts/generated/contracts-generated/permit2/src/lib.rs
@@ -0,0 +1,7518 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IAllowanceTransfer {
+    struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
+    struct PermitSingle { PermitDetails details; address spender; uint256 sigDeadline; }
+    struct TokenSpenderPair { address token; address spender; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IAllowanceTransfer {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitDetails {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<160>,
+            alloy_sol_types::sol_data::Uint<48>,
+            alloy_sol_types::sol_data::Uint<48>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U160,
+            alloy_sol_types::private::primitives::aliases::U48,
+            alloy_sol_types::private::primitives::aliases::U48,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitDetails> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitDetails) -> Self {
+                (value.token, value.amount, value.expiration, value.nonce)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitDetails {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    token: tuple.0,
+                    amount: tuple.1,
+                    expiration: tuple.2,
+                    nonce: tuple.3,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitDetails {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitDetails {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitDetails {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitDetails {
+            const NAME: &'static str = "PermitDetails";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiration)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitDetails {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiration,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        48,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    160,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    48,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiration,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    48,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitSingle { PermitDetails details; address spender; uint256 sigDeadline; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitSingle {
+        #[allow(missing_docs)]
+        pub details: <PermitDetails as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sigDeadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            PermitDetails,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <PermitDetails as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitSingle> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitSingle) -> Self {
+                (value.details, value.spender, value.sigDeadline)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitSingle {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    details: tuple.0,
+                    spender: tuple.1,
+                    sigDeadline: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitSingle {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitSingle {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <PermitDetails as alloy_sol_types::SolType>::tokenize(&self.details),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sigDeadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitSingle {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitSingle {
+            const NAME: &'static str = "PermitSingle";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitSingle(PermitDetails details,address spender,uint256 sigDeadline)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components.push(<PermitDetails as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<PermitDetails as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <PermitDetails as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.details,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.spender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sigDeadline)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitSingle {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <PermitDetails as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.details,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.spender,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sigDeadline,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <PermitDetails as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.details,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.spender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sigDeadline,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct TokenSpenderPair { address token; address spender; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TokenSpenderPair {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TokenSpenderPair> for UnderlyingRustTuple<'_> {
+            fn from(value: TokenSpenderPair) -> Self {
+                (value.token, value.spender)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TokenSpenderPair {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    token: tuple.0,
+                    spender: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for TokenSpenderPair {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for TokenSpenderPair {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TokenSpenderPair {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for TokenSpenderPair {
+            const NAME: &'static str = "TokenSpenderPair";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "TokenSpenderPair(address token,address spender)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.spender,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TokenSpenderPair {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.spender,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.spender,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
+
+    See the [wrapper's documentation](`IAllowanceTransferInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IAllowanceTransferInstance<P, N> {
+        IAllowanceTransferInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IAllowanceTransfer`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IAllowanceTransfer`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IAllowanceTransferInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IAllowanceTransferInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IAllowanceTransferInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IAllowanceTransferInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
+
+        See the [wrapper's documentation](`IAllowanceTransferInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IAllowanceTransferInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IAllowanceTransferInstance<P, N> {
+            IAllowanceTransferInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IAllowanceTransferInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IAllowanceTransferInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library ISignatureTransfer {
+    struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }
+    struct PermitTransferFrom { TokenPermissions permitted; uint256 nonce; uint256 deadline; }
+    struct SignatureTransferDetails { address to; uint256 requestedAmount; }
+    struct TokenPermissions { address token; uint256 amount; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod ISignatureTransfer {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitBatchTransferFrom {
+        #[allow(missing_docs)]
+        pub permitted:
+            alloy_sol_types::private::Vec<<TokenPermissions as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Array<TokenPermissions>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Vec<<TokenPermissions as alloy_sol_types::SolType>::RustType>,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitBatchTransferFrom> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitBatchTransferFrom) -> Self {
+                (value.permitted, value.nonce, value.deadline)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitBatchTransferFrom {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    permitted: tuple.0,
+                    nonce: tuple.1,
+                    deadline: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitBatchTransferFrom {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitBatchTransferFrom {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        TokenPermissions,
+                    > as alloy_sol_types::SolType>::tokenize(&self.permitted),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitBatchTransferFrom {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitBatchTransferFrom {
+            const NAME: &'static str = "PermitBatchTransferFrom";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitBatchTransferFrom(TokenPermissions[] permitted,uint256 nonce,uint256 \
+                     deadline)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components
+                    .push(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Array<
+                        TokenPermissions,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.permitted)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitBatchTransferFrom {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Array<
+                        TokenPermissions,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.permitted,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deadline,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Array<
+                    TokenPermissions,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.permitted,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deadline,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct PermitTransferFrom { TokenPermissions permitted; uint256 nonce; uint256 deadline; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PermitTransferFrom {
+        #[allow(missing_docs)]
+        pub permitted: <TokenPermissions as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            TokenPermissions,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <TokenPermissions as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PermitTransferFrom> for UnderlyingRustTuple<'_> {
+            fn from(value: PermitTransferFrom) -> Self {
+                (value.permitted, value.nonce, value.deadline)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitTransferFrom {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    permitted: tuple.0,
+                    nonce: tuple.1,
+                    deadline: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for PermitTransferFrom {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for PermitTransferFrom {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <TokenPermissions as alloy_sol_types::SolType>::tokenize(&self.permitted),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for PermitTransferFrom {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for PermitTransferFrom {
+            const NAME: &'static str = "PermitTransferFrom";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "PermitTransferFrom(TokenPermissions permitted,uint256 nonce,uint256 deadline)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
+                components
+                    .push(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_root_type());
+                components
+                    .extend(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_components());
+                components
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <TokenPermissions as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.permitted,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for PermitTransferFrom {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <TokenPermissions as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.permitted,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.deadline,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <TokenPermissions as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.permitted,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.nonce,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.deadline,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct SignatureTransferDetails { address to; uint256 requestedAmount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SignatureTransferDetails {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub requestedAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureTransferDetails> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureTransferDetails) -> Self {
+                (value.to, value.requestedAmount)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureTransferDetails {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    to: tuple.0,
+                    requestedAmount: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for SignatureTransferDetails {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for SignatureTransferDetails {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.requestedAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for SignatureTransferDetails {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for SignatureTransferDetails {
+            const NAME: &'static str = "SignatureTransferDetails";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "SignatureTransferDetails(address to,uint256 requestedAmount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.to,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.requestedAmount,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for SignatureTransferDetails {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.to,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.requestedAmount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.to,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.requestedAmount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct TokenPermissions { address token; uint256 amount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TokenPermissions {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TokenPermissions> for UnderlyingRustTuple<'_> {
+            fn from(value: TokenPermissions) -> Self {
+                (value.token, value.amount)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TokenPermissions {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    token: tuple.0,
+                    amount: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for TokenPermissions {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for TokenPermissions {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TokenPermissions {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for TokenPermissions {
+            const NAME: &'static str = "TokenPermissions";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "TokenPermissions(address token,uint256 amount)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TokenPermissions {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`ISignatureTransfer`](self) contract instance.
+
+    See the [wrapper's documentation](`ISignatureTransferInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> ISignatureTransferInstance<P, N> {
+        ISignatureTransferInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`ISignatureTransfer`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`ISignatureTransfer`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct ISignatureTransferInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for ISignatureTransferInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("ISignatureTransferInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ISignatureTransferInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`ISignatureTransfer`](self) contract instance.
+
+        See the [wrapper's documentation](`ISignatureTransferInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> ISignatureTransferInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> ISignatureTransferInstance<P, N> {
+            ISignatureTransferInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ISignatureTransferInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        ISignatureTransferInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IAllowanceTransfer {
+    struct PermitDetails {
+        address token;
+        uint160 amount;
+        uint48 expiration;
+        uint48 nonce;
+    }
+    struct PermitSingle {
+        PermitDetails details;
+        address spender;
+        uint256 sigDeadline;
+    }
+    struct TokenSpenderPair {
+        address token;
+        address spender;
+    }
+}
+
+library ISignatureTransfer {
+    struct PermitBatchTransferFrom {
+        TokenPermissions[] permitted;
+        uint256 nonce;
+        uint256 deadline;
+    }
+    struct PermitTransferFrom {
+        TokenPermissions permitted;
+        uint256 nonce;
+        uint256 deadline;
+    }
+    struct SignatureTransferDetails {
+        address to;
+        uint256 requestedAmount;
+    }
+    struct TokenPermissions {
+        address token;
+        uint256 amount;
+    }
+}
+
+interface Permit2 {
+    error AllowanceExpired(uint256 deadline);
+    error ExcessiveInvalidation();
+    error InsufficientAllowance(uint256 amount);
+    error InvalidAmount(uint256 maxAmount);
+    error InvalidContractSignature();
+    error InvalidNonce();
+    error InvalidSignature();
+    error InvalidSignatureLength();
+    error InvalidSigner();
+    error LengthMismatch();
+    error SignatureExpired(uint256 signatureDeadline);
+
+    event Approval(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration);
+    event Lockdown(address indexed owner, address token, address spender);
+    event NonceInvalidation(address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce);
+    event Permit(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce);
+    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address, address, address) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
+    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
+    function invalidateNonces(address token, address spender, uint48 newNonce) external;
+    function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
+    function lockdown(IAllowanceTransfer.TokenSpenderPair[] memory approvals) external;
+    function nonceBitmap(address, uint256) external view returns (uint256);
+    function permit(address owner, IAllowanceTransfer.PermitSingle memory permitSingle, bytes memory signature) external;
+    function permitTransferFrom(ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address owner, bytes memory signature) external;
+    function permitWitnessTransferFrom(ISignatureTransfer.PermitBatchTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails[] memory transferDetails, address owner, bytes32 witness, string memory witnessTypeString, bytes memory signature) external;
+    function transferFrom(address from, address to, uint160 amount, address token) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "internalType": "uint48"
+      },
+      {
+        "name": "nonce",
+        "type": "uint48",
+        "internalType": "uint48"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "internalType": "uint48"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "invalidateNonces",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "newNonce",
+        "type": "uint48",
+        "internalType": "uint48"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "invalidateUnorderedNonces",
+    "inputs": [
+      {
+        "name": "wordPos",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "mask",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "lockdown",
+    "inputs": [
+      {
+        "name": "approvals",
+        "type": "tuple[]",
+        "internalType": "struct IAllowanceTransfer.TokenSpenderPair[]",
+        "components": [
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "spender",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "nonceBitmap",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "permitSingle",
+        "type": "tuple",
+        "internalType": "struct IAllowanceTransfer.PermitSingle",
+        "components": [
+          {
+            "name": "details",
+            "type": "tuple",
+            "internalType": "struct IAllowanceTransfer.PermitDetails",
+            "components": [
+              {
+                "name": "token",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint160",
+                "internalType": "uint160"
+              },
+              {
+                "name": "expiration",
+                "type": "uint48",
+                "internalType": "uint48"
+              },
+              {
+                "name": "nonce",
+                "type": "uint48",
+                "internalType": "uint48"
+              }
+            ]
+          },
+          {
+            "name": "spender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permitTransferFrom",
+    "inputs": [
+      {
+        "name": "permit",
+        "type": "tuple",
+        "internalType": "struct ISignatureTransfer.PermitTransferFrom",
+        "components": [
+          {
+            "name": "permitted",
+            "type": "tuple",
+            "internalType": "struct ISignatureTransfer.TokenPermissions",
+            "components": [
+              {
+                "name": "token",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "transferDetails",
+        "type": "tuple",
+        "internalType": "struct ISignatureTransfer.SignatureTransferDetails",
+        "components": [
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "requestedAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permitWitnessTransferFrom",
+    "inputs": [
+      {
+        "name": "permit",
+        "type": "tuple",
+        "internalType": "struct ISignatureTransfer.PermitBatchTransferFrom",
+        "components": [
+          {
+            "name": "permitted",
+            "type": "tuple[]",
+            "internalType": "struct ISignatureTransfer.TokenPermissions[]",
+            "components": [
+              {
+                "name": "token",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              }
+            ]
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "deadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "transferDetails",
+        "type": "tuple[]",
+        "internalType": "struct ISignatureTransfer.SignatureTransferDetails[]",
+        "components": [
+          {
+            "name": "to",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "requestedAmount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "witness",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "witnessTypeString",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "indexed": false,
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Lockdown",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "NonceInvalidation",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newNonce",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      },
+      {
+        "name": "oldNonce",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "indexed": false,
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      },
+      {
+        "name": "nonce",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "UnorderedNonceInvalidation",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "word",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "mask",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AllowanceExpired",
+    "inputs": [
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ExcessiveInvalidation",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InsufficientAllowance",
+    "inputs": [
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidAmount",
+    "inputs": [
+      {
+        "name": "maxAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidContractSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidNonce",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignatureLength",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSigner",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "LengthMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SignatureExpired",
+    "inputs": [
+      {
+        "name": "signatureDeadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Permit2 {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `AllowanceExpired(uint256)` and selector `0xd81b2f2e`.
+    ```solidity
+    error AllowanceExpired(uint256 deadline);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct AllowanceExpired {
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<AllowanceExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: AllowanceExpired) -> Self {
+                (value.deadline,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AllowanceExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { deadline: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for AllowanceExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [216u8, 27u8, 47u8, 46u8];
+            const SIGNATURE: &'static str = "AllowanceExpired(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ExcessiveInvalidation()` and selector `0x24d35a26`.
+    ```solidity
+    error ExcessiveInvalidation();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ExcessiveInvalidation;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ExcessiveInvalidation> for UnderlyingRustTuple<'_> {
+            fn from(value: ExcessiveInvalidation) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExcessiveInvalidation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ExcessiveInvalidation {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [36u8, 211u8, 90u8, 38u8];
+            const SIGNATURE: &'static str = "ExcessiveInvalidation()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InsufficientAllowance(uint256)` and selector `0xf96fb071`.
+    ```solidity
+    error InsufficientAllowance(uint256 amount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InsufficientAllowance {
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InsufficientAllowance> for UnderlyingRustTuple<'_> {
+            fn from(value: InsufficientAllowance) -> Self {
+                (value.amount,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientAllowance {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { amount: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InsufficientAllowance {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [249u8, 111u8, 176u8, 113u8];
+            const SIGNATURE: &'static str = "InsufficientAllowance(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidAmount(uint256)` and selector `0x3728b83d`.
+    ```solidity
+    error InvalidAmount(uint256 maxAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidAmount {
+        #[allow(missing_docs)]
+        pub maxAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidAmount) -> Self {
+                (value.maxAmount,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { maxAmount: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [55u8, 40u8, 184u8, 61u8];
+            const SIGNATURE: &'static str = "InvalidAmount(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.maxAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidContractSignature()` and selector `0xb0669cbc`.
+    ```solidity
+    error InvalidContractSignature();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidContractSignature;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidContractSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidContractSignature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidContractSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidContractSignature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [176u8, 102u8, 156u8, 188u8];
+            const SIGNATURE: &'static str = "InvalidContractSignature()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidNonce()` and selector `0x756688fe`.
+    ```solidity
+    error InvalidNonce();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidNonce;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidNonce> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidNonce) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNonce {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidNonce {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [117u8, 102u8, 136u8, 254u8];
+            const SIGNATURE: &'static str = "InvalidNonce()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSignature()` and selector `0x8baa579f`.
+    ```solidity
+    error InvalidSignature();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSignature;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSignature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSignature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [139u8, 170u8, 87u8, 159u8];
+            const SIGNATURE: &'static str = "InvalidSignature()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSignatureLength()` and selector `0x4be6321b`.
+    ```solidity
+    error InvalidSignatureLength();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSignatureLength;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSignatureLength> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSignatureLength) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignatureLength {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSignatureLength {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [75u8, 230u8, 50u8, 27u8];
+            const SIGNATURE: &'static str = "InvalidSignatureLength()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSigner()` and selector `0x815e1d64`.
+    ```solidity
+    error InvalidSigner();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSigner;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSigner> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSigner) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSigner {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSigner {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [129u8, 94u8, 29u8, 100u8];
+            const SIGNATURE: &'static str = "InvalidSigner()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `LengthMismatch()` and selector `0xff633a38`.
+    ```solidity
+    error LengthMismatch();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct LengthMismatch;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<LengthMismatch> for UnderlyingRustTuple<'_> {
+            fn from(value: LengthMismatch) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LengthMismatch {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for LengthMismatch {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 99u8, 58u8, 56u8];
+            const SIGNATURE: &'static str = "LengthMismatch()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SignatureExpired(uint256)` and selector `0xcd21db4f`.
+    ```solidity
+    error SignatureExpired(uint256 signatureDeadline);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SignatureExpired {
+        #[allow(missing_docs)]
+        pub signatureDeadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureExpired) -> Self {
+                (value.signatureDeadline,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    signatureDeadline: tuple.0,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SignatureExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [205u8, 33u8, 219u8, 79u8];
+            const SIGNATURE: &'static str = "SignatureExpired(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.signatureDeadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,address,uint160,uint48)` and selector `0xda9fa7c1b00402c17d0161b249b1ab8bbec047c5a52207b9c112deffd817036b`.
+    ```solidity
+    event Approval(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,address,uint160,uint48)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    218u8, 159u8, 167u8, 193u8, 176u8, 4u8, 2u8, 193u8, 125u8, 1u8, 97u8, 178u8,
+                    73u8, 177u8, 171u8, 139u8, 190u8, 192u8, 71u8, 197u8, 165u8, 34u8, 7u8, 185u8,
+                    193u8, 18u8, 222u8, 255u8, 216u8, 23u8, 3u8, 107u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: topics.2,
+                    spender: topics.3,
+                    amount: data.0,
+                    expiration: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.token.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Lockdown(address,address,address)` and selector `0x89b1add15eff56b3dfe299ad94e01f2b52fbcb80ae1a3baea6ae8c04cb2b98a4`.
+    ```solidity
+    event Lockdown(address indexed owner, address token, address spender);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Lockdown {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Lockdown {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Lockdown(address,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    137u8, 177u8, 173u8, 209u8, 94u8, 255u8, 86u8, 179u8, 223u8, 226u8, 153u8,
+                    173u8, 148u8, 224u8, 31u8, 43u8, 82u8, 251u8, 203u8, 128u8, 174u8, 26u8, 59u8,
+                    174u8, 166u8, 174u8, 140u8, 4u8, 203u8, 43u8, 152u8, 164u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: data.0,
+                    spender: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Lockdown {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Lockdown> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Lockdown) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `NonceInvalidation(address,address,address,uint48,uint48)` and selector `0x55eb90d810e1700b35a8e7e25395ff7f2b2259abd7415ca2284dfb1c246418f3`.
+    ```solidity
+    event NonceInvalidation(address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct NonceInvalidation {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newNonce: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub oldNonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for NonceInvalidation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "NonceInvalidation(address,address,address,uint48,uint48)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    85u8, 235u8, 144u8, 216u8, 16u8, 225u8, 112u8, 11u8, 53u8, 168u8, 231u8, 226u8,
+                    83u8, 149u8, 255u8, 127u8, 43u8, 34u8, 89u8, 171u8, 215u8, 65u8, 92u8, 162u8,
+                    40u8, 77u8, 251u8, 28u8, 36u8, 100u8, 24u8, 243u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: topics.2,
+                    spender: topics.3,
+                    newNonce: data.0,
+                    oldNonce: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.newNonce,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.oldNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.token.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for NonceInvalidation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&NonceInvalidation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &NonceInvalidation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Permit(address,address,address,uint160,uint48,uint48)` and selector `0xc6a377bfc4eb120024a8ac08eef205be16b817020812c73223e81d1bdb9708ec`.
+    ```solidity
+    event Permit(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Permit {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Permit {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Permit(address,address,address,uint160,uint48,uint48)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    198u8, 163u8, 119u8, 191u8, 196u8, 235u8, 18u8, 0u8, 36u8, 168u8, 172u8, 8u8,
+                    238u8, 242u8, 5u8, 190u8, 22u8, 184u8, 23u8, 2u8, 8u8, 18u8, 199u8, 50u8, 35u8,
+                    232u8, 29u8, 27u8, 219u8, 151u8, 8u8, 236u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: topics.2,
+                    spender: topics.3,
+                    amount: data.0,
+                    expiration: data.1,
+                    nonce: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.token.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Permit {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Permit> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Permit) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `UnorderedNonceInvalidation(address,uint256,uint256)` and selector `0x3704902f963766a4e561bbaab6e6cdc1b1dd12f6e9e99648da8843b3f46b918d`.
+    ```solidity
+    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct UnorderedNonceInvalidation {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub word: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub mask: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for UnorderedNonceInvalidation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "UnorderedNonceInvalidation(address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    55u8, 4u8, 144u8, 47u8, 150u8, 55u8, 102u8, 164u8, 229u8, 97u8, 187u8, 170u8,
+                    182u8, 230u8, 205u8, 193u8, 177u8, 221u8, 18u8, 246u8, 233u8, 233u8, 150u8,
+                    72u8, 218u8, 136u8, 67u8, 179u8, 244u8, 107u8, 145u8, 141u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    word: data.0,
+                    mask: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.word,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.mask,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for UnorderedNonceInvalidation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&UnorderedNonceInvalidation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &UnorderedNonceInvalidation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address,address)` and selector `0x927da105`.
+    ```solidity
+    function allowance(address, address, address) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _2: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value._0, value._1, value._2)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                        _2: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::primitives::aliases::U48,
+                alloy_sol_types::private::primitives::aliases::U48,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value.amount, value.expiration, value.nonce)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount: tuple.0,
+                        expiration: tuple.1,
+                        nonce: tuple.2,
+                    }
+                }
+            }
+        }
+        impl allowanceReturn {
+            fn _tokenize(&self) -> <allowanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = allowanceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [146u8, 125u8, 161u8, 5u8];
+            const SIGNATURE: &'static str = "allowance(address,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                allowanceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,address,uint160,uint48)` and selector `0x87517c45`.
+    ```solidity
+    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    ///Container type for the return parameters of the
+    /// [`approve(address,address,uint160,uint48)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::primitives::aliases::U48,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.token, value.spender, value.amount, value.expiration)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        spender: tuple.1,
+                        amount: tuple.2,
+                        expiration: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl approveReturn {
+            fn _tokenize(&self) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type Return = approveReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [135u8, 81u8, 124u8, 69u8];
+            const SIGNATURE: &'static str = "approve(address,address,uint160,uint48)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                approveReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `invalidateNonces(address,address,uint48)` and selector `0x65d9723c`.
+    ```solidity
+    function invalidateNonces(address token, address spender, uint48 newNonce) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateNoncesCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newNonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
+    ///Container type for the return parameters of the
+    /// [`invalidateNonces(address,address,uint48)`](invalidateNoncesCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateNoncesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U48,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateNoncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateNoncesCall) -> Self {
+                    (value.token, value.spender, value.newNonce)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateNoncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        spender: tuple.1,
+                        newNonce: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateNoncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateNoncesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateNoncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl invalidateNoncesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <invalidateNoncesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for invalidateNoncesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type Return = invalidateNoncesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [101u8, 217u8, 114u8, 60u8];
+            const SIGNATURE: &'static str = "invalidateNonces(address,address,uint48)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.newNonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                invalidateNoncesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `invalidateUnorderedNonces(uint256,uint256)` and selector `0x3ff9dcb1`.
+    ```solidity
+    function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateUnorderedNoncesCall {
+        #[allow(missing_docs)]
+        pub wordPos: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub mask: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`invalidateUnorderedNonces(uint256,
+    /// uint256)`](invalidateUnorderedNoncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct invalidateUnorderedNoncesReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateUnorderedNoncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateUnorderedNoncesCall) -> Self {
+                    (value.wordPos, value.mask)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateUnorderedNoncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        wordPos: tuple.0,
+                        mask: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<invalidateUnorderedNoncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateUnorderedNoncesReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateUnorderedNoncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl invalidateUnorderedNoncesReturn {
+            fn _tokenize(
+                &self,
+            ) -> <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for invalidateUnorderedNoncesCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = invalidateUnorderedNoncesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [63u8, 249u8, 220u8, 177u8];
+            const SIGNATURE: &'static str = "invalidateUnorderedNonces(uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wordPos,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.mask,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                invalidateUnorderedNoncesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `lockdown((address,address)[])` and selector `0xcc53287f`.
+    ```solidity
+    function lockdown(IAllowanceTransfer.TokenSpenderPair[] memory approvals) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct lockdownCall {
+        #[allow(missing_docs)]
+        pub approvals: alloy_sol_types::private::Vec<
+            <IAllowanceTransfer::TokenSpenderPair as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    ///Container type for the return parameters of the
+    /// [`lockdown((address,address)[])`](lockdownCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct lockdownReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<IAllowanceTransfer::TokenSpenderPair>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IAllowanceTransfer::TokenSpenderPair as alloy_sol_types::SolType>::RustType,
+                >,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<lockdownCall> for UnderlyingRustTuple<'_> {
+                fn from(value: lockdownCall) -> Self {
+                    (value.approvals,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lockdownCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { approvals: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<lockdownReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: lockdownReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lockdownReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl lockdownReturn {
+            fn _tokenize(&self) -> <lockdownCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for lockdownCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<IAllowanceTransfer::TokenSpenderPair>,);
+            type Return = lockdownReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [204u8, 83u8, 40u8, 127u8];
+            const SIGNATURE: &'static str = "lockdown((address,address)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    IAllowanceTransfer::TokenSpenderPair,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.approvals
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                lockdownReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonceBitmap(address,uint256)` and selector `0x4fe02b44`.
+    ```solidity
+    function nonceBitmap(address, uint256) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nonceBitmapCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonceBitmap(address,uint256)`](nonceBitmapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nonceBitmapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nonceBitmapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nonceBitmapCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceBitmapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nonceBitmapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nonceBitmapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceBitmapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nonceBitmapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [79u8, 224u8, 43u8, 68u8];
+            const SIGNATURE: &'static str = "nonceBitmap(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nonceBitmapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nonceBitmapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)` and selector `0x2b67b570`.
+    ```solidity
+    function permit(address owner, IAllowanceTransfer.PermitSingle memory permitSingle, bytes memory signature) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub permitSingle: <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,((address,uint160,uint48,uint48),address,uint256),
+    /// bytes)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IAllowanceTransfer::PermitSingle,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (value.owner, value.permitSingle, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        permitSingle: tuple.1,
+                        signature: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IAllowanceTransfer::PermitSingle,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [43u8, 103u8, 181u8, 112u8];
+            const SIGNATURE: &'static str =
+                "permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::tokenize(
+                        &self.permitSingle,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `permitTransferFrom(((address,uint256),uint256,uint256),(address,uint256),address,bytes)` and selector `0x30f28b7a`.
+    ```solidity
+    function permitTransferFrom(ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address owner, bytes memory signature) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitTransferFromCall {
+        #[allow(missing_docs)]
+        pub permit: <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub transferDetails:
+            <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`permitTransferFrom(((address,uint256),uint256,uint256),(address,
+    /// uint256),address,bytes)`](permitTransferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitTransferFromReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                ISignatureTransfer::PermitTransferFrom,
+                ISignatureTransfer::SignatureTransferDetails,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::RustType,
+                <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitTransferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitTransferFromCall) -> Self {
+                    (
+                        value.permit,
+                        value.transferDetails,
+                        value.owner,
+                        value.signature,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitTransferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        permit: tuple.0,
+                        transferDetails: tuple.1,
+                        owner: tuple.2,
+                        signature: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitTransferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitTransferFromReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitTransferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitTransferFromReturn {
+            fn _tokenize(
+                &self,
+            ) -> <permitTransferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitTransferFromCall {
+            type Parameters<'a> = (
+                ISignatureTransfer::PermitTransferFrom,
+                ISignatureTransfer::SignatureTransferDetails,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = permitTransferFromReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [48u8, 242u8, 139u8, 122u8];
+            const SIGNATURE: &'static str = "permitTransferFrom(((address,uint256),uint256,\
+                                             uint256),(address,uint256),address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::tokenize(
+                        &self.permit,
+                    ),
+                    <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::tokenize(
+                        &self.transferDetails,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitTransferFromReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive()]
+    /**Function with signature `permitWitnessTransferFrom(((address,uint256)[],uint256,uint256),(address,uint256)[],address,bytes32,string,bytes)` and selector `0xfe8ec1a7`.
+    ```solidity
+    function permitWitnessTransferFrom(ISignatureTransfer.PermitBatchTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails[] memory transferDetails, address owner, bytes32 witness, string memory witnessTypeString, bytes memory signature) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitWitnessTransferFromCall {
+        #[allow(missing_docs)]
+        pub permit:
+            <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub transferDetails: alloy_sol_types::private::Vec<
+            <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub witness: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub witnessTypeString: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`permitWitnessTransferFrom(((address,uint256)[],uint256,uint256),
+    /// (address,uint256)[],address,bytes32,string,
+    /// bytes)`](permitWitnessTransferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitWitnessTransferFromReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                ISignatureTransfer::PermitBatchTransferFrom,
+                alloy_sol_types::sol_data::Array<ISignatureTransfer::SignatureTransferDetails>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitWitnessTransferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitWitnessTransferFromCall) -> Self {
+                    (
+                        value.permit,
+                        value.transferDetails,
+                        value.owner,
+                        value.witness,
+                        value.witnessTypeString,
+                        value.signature,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitWitnessTransferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        permit: tuple.0,
+                        transferDetails: tuple.1,
+                        owner: tuple.2,
+                        witness: tuple.3,
+                        witnessTypeString: tuple.4,
+                        signature: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitWitnessTransferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitWitnessTransferFromReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitWitnessTransferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitWitnessTransferFromReturn {
+            fn _tokenize(
+                &self,
+            ) -> <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitWitnessTransferFromCall {
+            type Parameters<'a> = (
+                ISignatureTransfer::PermitBatchTransferFrom,
+                alloy_sol_types::sol_data::Array<ISignatureTransfer::SignatureTransferDetails>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = permitWitnessTransferFromReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [254u8, 142u8, 193u8, 167u8];
+            const SIGNATURE: &'static str = "permitWitnessTransferFrom(((address,uint256)[],\
+                                             uint256,uint256),(address,uint256)[],address,bytes32,\
+                                             string,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::tokenize(
+                        &self.permit,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        ISignatureTransfer::SignatureTransferDetails,
+                    > as alloy_sol_types::SolType>::tokenize(&self.transferDetails),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.witness),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.witnessTypeString,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitWitnessTransferFromReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint160,address)` and selector `0x36c78516`.
+    ```solidity
+    function transferFrom(address from, address to, uint160 amount, address token) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint160,address)`](transferFromCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.from, value.to, value.amount, value.token)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        from: tuple.0,
+                        to: tuple.1,
+                        amount: tuple.2,
+                        token: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferFromReturn {
+            fn _tokenize(&self) -> <transferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = transferFromReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 199u8, 133u8, 22u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint160,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferFromReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`Permit2`](self) function calls.
+    #[derive(Clone)]
+    pub enum Permit2Calls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        invalidateNonces(invalidateNoncesCall),
+        #[allow(missing_docs)]
+        invalidateUnorderedNonces(invalidateUnorderedNoncesCall),
+        #[allow(missing_docs)]
+        lockdown(lockdownCall),
+        #[allow(missing_docs)]
+        nonceBitmap(nonceBitmapCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        permitTransferFrom(permitTransferFromCall),
+        #[allow(missing_docs)]
+        permitWitnessTransferFrom(permitWitnessTransferFromCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl Permit2Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [43u8, 103u8, 181u8, 112u8],
+            [48u8, 242u8, 139u8, 122u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [54u8, 199u8, 133u8, 22u8],
+            [63u8, 249u8, 220u8, 177u8],
+            [79u8, 224u8, 43u8, 68u8],
+            [101u8, 217u8, 114u8, 60u8],
+            [135u8, 81u8, 124u8, 69u8],
+            [146u8, 125u8, 161u8, 5u8],
+            [204u8, 83u8, 40u8, 127u8],
+            [254u8, 142u8, 193u8, 167u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitTransferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <nonceBitmapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <invalidateNoncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <lockdownCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(permit),
+            ::core::stringify!(permitTransferFrom),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(invalidateUnorderedNonces),
+            ::core::stringify!(nonceBitmap),
+            ::core::stringify!(invalidateNonces),
+            ::core::stringify!(approve),
+            ::core::stringify!(allowance),
+            ::core::stringify!(lockdown),
+            ::core::stringify!(permitWitnessTransferFrom),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for Permit2Calls {
+        const COUNT: usize = 11usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "Permit2Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::invalidateNonces(_) => {
+                    <invalidateNoncesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::invalidateUnorderedNonces(_) => {
+                    <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::lockdown(_) => <lockdownCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonceBitmap(_) => <nonceBitmapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permitTransferFrom(_) => {
+                    <permitTransferFromCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::permitWitnessTransferFrom(_) => {
+                    <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<Permit2Calls>] = &[
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn permitTransferFrom(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <permitTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::permitTransferFrom)
+                    }
+                    permitTransferFrom
+                },
+                {
+                    fn DOMAIN_SEPARATOR(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn invalidateUnorderedNonces(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Calls> {
+                        <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(Permit2Calls::invalidateUnorderedNonces)
+                    }
+                    invalidateUnorderedNonces
+                },
+                {
+                    fn nonceBitmap(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <nonceBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::nonceBitmap)
+                    }
+                    nonceBitmap
+                },
+                {
+                    fn invalidateNonces(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::invalidateNonces)
+                    }
+                    invalidateNonces
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn lockdown(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <lockdownCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(Permit2Calls::lockdown)
+                    }
+                    lockdown
+                },
+                {
+                    fn permitWitnessTransferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Calls> {
+                        <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(Permit2Calls::permitWitnessTransferFrom)
+                    }
+                    permitWitnessTransferFrom
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<Permit2Calls>] = &[
+                {
+                    fn permit(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(Permit2Calls::permit)
+                    }
+                    permit
+                },
+                {
+                    fn permitTransferFrom(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <permitTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Calls::permitTransferFrom)
+                    }
+                    permitTransferFrom
+                },
+                {
+                    fn DOMAIN_SEPARATOR(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(Permit2Calls::DOMAIN_SEPARATOR)
+                    }
+                    DOMAIN_SEPARATOR
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(Permit2Calls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn invalidateUnorderedNonces(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Calls> {
+                        <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Calls::invalidateUnorderedNonces)
+                    }
+                    invalidateUnorderedNonces
+                },
+                {
+                    fn nonceBitmap(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <nonceBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(Permit2Calls::nonceBitmap)
+                    }
+                    nonceBitmap
+                },
+                {
+                    fn invalidateNonces(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(Permit2Calls::invalidateNonces)
+                    }
+                    invalidateNonces
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(Permit2Calls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(Permit2Calls::allowance)
+                    }
+                    allowance
+                },
+                {
+                    fn lockdown(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
+                        <lockdownCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(Permit2Calls::lockdown)
+                    }
+                    lockdown
+                },
+                {
+                    fn permitWitnessTransferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Calls> {
+                        <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Calls::permitWitnessTransferFrom)
+                    }
+                    permitWitnessTransferFrom
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::invalidateNonces(inner) => {
+                    <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::invalidateUnorderedNonces(inner) => {
+                    <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::lockdown(inner) => {
+                    <lockdownCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::nonceBitmap(inner) => {
+                    <nonceBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permitTransferFrom(inner) => {
+                    <permitTransferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::permitWitnessTransferFrom(inner) => {
+                    <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::invalidateNonces(inner) => {
+                    <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::invalidateUnorderedNonces(inner) => {
+                    <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::lockdown(inner) => {
+                    <lockdownCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::nonceBitmap(inner) => {
+                    <nonceBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permitTransferFrom(inner) => {
+                    <permitTransferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permitWitnessTransferFrom(inner) => {
+                    <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`Permit2`](self) custom errors.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum Permit2Errors {
+        #[allow(missing_docs)]
+        AllowanceExpired(AllowanceExpired),
+        #[allow(missing_docs)]
+        ExcessiveInvalidation(ExcessiveInvalidation),
+        #[allow(missing_docs)]
+        InsufficientAllowance(InsufficientAllowance),
+        #[allow(missing_docs)]
+        InvalidAmount(InvalidAmount),
+        #[allow(missing_docs)]
+        InvalidContractSignature(InvalidContractSignature),
+        #[allow(missing_docs)]
+        InvalidNonce(InvalidNonce),
+        #[allow(missing_docs)]
+        InvalidSignature(InvalidSignature),
+        #[allow(missing_docs)]
+        InvalidSignatureLength(InvalidSignatureLength),
+        #[allow(missing_docs)]
+        InvalidSigner(InvalidSigner),
+        #[allow(missing_docs)]
+        LengthMismatch(LengthMismatch),
+        #[allow(missing_docs)]
+        SignatureExpired(SignatureExpired),
+    }
+    impl Permit2Errors {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [36u8, 211u8, 90u8, 38u8],
+            [55u8, 40u8, 184u8, 61u8],
+            [75u8, 230u8, 50u8, 27u8],
+            [117u8, 102u8, 136u8, 254u8],
+            [129u8, 94u8, 29u8, 100u8],
+            [139u8, 170u8, 87u8, 159u8],
+            [176u8, 102u8, 156u8, 188u8],
+            [205u8, 33u8, 219u8, 79u8],
+            [216u8, 27u8, 47u8, 46u8],
+            [249u8, 111u8, 176u8, 113u8],
+            [255u8, 99u8, 58u8, 56u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <ExcessiveInvalidation as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidAmount as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidSignatureLength as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidNonce as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidSigner as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidSignature as alloy_sol_types::SolError>::SIGNATURE,
+            <InvalidContractSignature as alloy_sol_types::SolError>::SIGNATURE,
+            <SignatureExpired as alloy_sol_types::SolError>::SIGNATURE,
+            <AllowanceExpired as alloy_sol_types::SolError>::SIGNATURE,
+            <InsufficientAllowance as alloy_sol_types::SolError>::SIGNATURE,
+            <LengthMismatch as alloy_sol_types::SolError>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(ExcessiveInvalidation),
+            ::core::stringify!(InvalidAmount),
+            ::core::stringify!(InvalidSignatureLength),
+            ::core::stringify!(InvalidNonce),
+            ::core::stringify!(InvalidSigner),
+            ::core::stringify!(InvalidSignature),
+            ::core::stringify!(InvalidContractSignature),
+            ::core::stringify!(SignatureExpired),
+            ::core::stringify!(AllowanceExpired),
+            ::core::stringify!(InsufficientAllowance),
+            ::core::stringify!(LengthMismatch),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for Permit2Errors {
+        const COUNT: usize = 11usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "Permit2Errors";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::AllowanceExpired(_) => {
+                    <AllowanceExpired as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::ExcessiveInvalidation(_) => {
+                    <ExcessiveInvalidation as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InsufficientAllowance(_) => {
+                    <InsufficientAllowance as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidAmount(_) => <InvalidAmount as alloy_sol_types::SolError>::SELECTOR,
+                Self::InvalidContractSignature(_) => {
+                    <InvalidContractSignature as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidNonce(_) => <InvalidNonce as alloy_sol_types::SolError>::SELECTOR,
+                Self::InvalidSignature(_) => {
+                    <InvalidSignature as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidSignatureLength(_) => {
+                    <InvalidSignatureLength as alloy_sol_types::SolError>::SELECTOR
+                }
+                Self::InvalidSigner(_) => <InvalidSigner as alloy_sol_types::SolError>::SELECTOR,
+                Self::LengthMismatch(_) => <LengthMismatch as alloy_sol_types::SolError>::SELECTOR,
+                Self::SignatureExpired(_) => {
+                    <SignatureExpired as alloy_sol_types::SolError>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<Permit2Errors>] = &[
+                {
+                    fn ExcessiveInvalidation(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Errors> {
+                        <ExcessiveInvalidation as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::ExcessiveInvalidation)
+                    }
+                    ExcessiveInvalidation
+                },
+                {
+                    fn InvalidAmount(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InvalidAmount as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::InvalidAmount)
+                    }
+                    InvalidAmount
+                },
+                {
+                    fn InvalidSignatureLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InvalidSignatureLength as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::InvalidSignatureLength)
+                    }
+                    InvalidSignatureLength
+                },
+                {
+                    fn InvalidNonce(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InvalidNonce as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::InvalidNonce)
+                    }
+                    InvalidNonce
+                },
+                {
+                    fn InvalidSigner(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InvalidSigner as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::InvalidSigner)
+                    }
+                    InvalidSigner
+                },
+                {
+                    fn InvalidSignature(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InvalidSignature as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::InvalidSignature)
+                    }
+                    InvalidSignature
+                },
+                {
+                    fn InvalidContractSignature(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InvalidContractSignature as alloy_sol_types::SolError>::abi_decode_raw(
+                            data,
+                        )
+                        .map(Permit2Errors::InvalidContractSignature)
+                    }
+                    InvalidContractSignature
+                },
+                {
+                    fn SignatureExpired(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <SignatureExpired as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::SignatureExpired)
+                    }
+                    SignatureExpired
+                },
+                {
+                    fn AllowanceExpired(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <AllowanceExpired as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::AllowanceExpired)
+                    }
+                    AllowanceExpired
+                },
+                {
+                    fn InsufficientAllowance(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<Permit2Errors> {
+                        <InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::InsufficientAllowance)
+                    }
+                    InsufficientAllowance
+                },
+                {
+                    fn LengthMismatch(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                        <LengthMismatch as alloy_sol_types::SolError>::abi_decode_raw(data)
+                            .map(Permit2Errors::LengthMismatch)
+                    }
+                    LengthMismatch
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<Permit2Errors>] =
+                &[
+                    {
+                        fn ExcessiveInvalidation(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<Permit2Errors> {
+                            <ExcessiveInvalidation as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::ExcessiveInvalidation)
+                        }
+                        ExcessiveInvalidation
+                    },
+                    {
+                        fn InvalidAmount(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InvalidAmount as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InvalidAmount)
+                        }
+                        InvalidAmount
+                    },
+                    {
+                        fn InvalidSignatureLength(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InvalidSignatureLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InvalidSignatureLength)
+                        }
+                        InvalidSignatureLength
+                    },
+                    {
+                        fn InvalidNonce(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InvalidNonce as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InvalidNonce)
+                        }
+                        InvalidNonce
+                    },
+                    {
+                        fn InvalidSigner(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InvalidSigner as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InvalidSigner)
+                        }
+                        InvalidSigner
+                    },
+                    {
+                        fn InvalidSignature(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InvalidSignature as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InvalidSignature)
+                        }
+                        InvalidSignature
+                    },
+                    {
+                        fn InvalidContractSignature(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InvalidContractSignature as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InvalidContractSignature)
+                        }
+                        InvalidContractSignature
+                    },
+                    {
+                        fn SignatureExpired(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <SignatureExpired as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::SignatureExpired)
+                        }
+                        SignatureExpired
+                    },
+                    {
+                        fn AllowanceExpired(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <AllowanceExpired as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::AllowanceExpired)
+                        }
+                        AllowanceExpired
+                    },
+                    {
+                        fn InsufficientAllowance(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<Permit2Errors> {
+                            <InsufficientAllowance as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::InsufficientAllowance)
+                        }
+                        InsufficientAllowance
+                    },
+                    {
+                        fn LengthMismatch(data: &[u8]) -> alloy_sol_types::Result<Permit2Errors> {
+                            <LengthMismatch as alloy_sol_types::SolError>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(Permit2Errors::LengthMismatch)
+                        }
+                        LengthMismatch
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::AllowanceExpired(inner) => {
+                    <AllowanceExpired as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::ExcessiveInvalidation(inner) => {
+                    <ExcessiveInvalidation as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InsufficientAllowance(inner) => {
+                    <InsufficientAllowance as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidAmount(inner) => {
+                    <InvalidAmount as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidContractSignature(inner) => {
+                    <InvalidContractSignature as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidNonce(inner) => {
+                    <InvalidNonce as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidSignature(inner) => {
+                    <InvalidSignature as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidSignatureLength(inner) => {
+                    <InvalidSignatureLength as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::InvalidSigner(inner) => {
+                    <InvalidSigner as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::LengthMismatch(inner) => {
+                    <LengthMismatch as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+                Self::SignatureExpired(inner) => {
+                    <SignatureExpired as alloy_sol_types::SolError>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::AllowanceExpired(inner) => {
+                    <AllowanceExpired as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::ExcessiveInvalidation(inner) => {
+                    <ExcessiveInvalidation as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InsufficientAllowance(inner) => {
+                    <InsufficientAllowance as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InvalidAmount(inner) => {
+                    <InvalidAmount as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InvalidContractSignature(inner) => {
+                    <InvalidContractSignature as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::InvalidNonce(inner) => {
+                    <InvalidNonce as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InvalidSignature(inner) => {
+                    <InvalidSignature as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::InvalidSignatureLength(inner) => {
+                    <InvalidSignatureLength as alloy_sol_types::SolError>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::InvalidSigner(inner) => {
+                    <InvalidSigner as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::LengthMismatch(inner) => {
+                    <LengthMismatch as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+                Self::SignatureExpired(inner) => {
+                    <SignatureExpired as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`Permit2`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum Permit2Events {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        Lockdown(Lockdown),
+        #[allow(missing_docs)]
+        NonceInvalidation(NonceInvalidation),
+        #[allow(missing_docs)]
+        Permit(Permit),
+        #[allow(missing_docs)]
+        UnorderedNonceInvalidation(UnorderedNonceInvalidation),
+    }
+    impl Permit2Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                55u8, 4u8, 144u8, 47u8, 150u8, 55u8, 102u8, 164u8, 229u8, 97u8, 187u8, 170u8,
+                182u8, 230u8, 205u8, 193u8, 177u8, 221u8, 18u8, 246u8, 233u8, 233u8, 150u8, 72u8,
+                218u8, 136u8, 67u8, 179u8, 244u8, 107u8, 145u8, 141u8,
+            ],
+            [
+                85u8, 235u8, 144u8, 216u8, 16u8, 225u8, 112u8, 11u8, 53u8, 168u8, 231u8, 226u8,
+                83u8, 149u8, 255u8, 127u8, 43u8, 34u8, 89u8, 171u8, 215u8, 65u8, 92u8, 162u8, 40u8,
+                77u8, 251u8, 28u8, 36u8, 100u8, 24u8, 243u8,
+            ],
+            [
+                137u8, 177u8, 173u8, 209u8, 94u8, 255u8, 86u8, 179u8, 223u8, 226u8, 153u8, 173u8,
+                148u8, 224u8, 31u8, 43u8, 82u8, 251u8, 203u8, 128u8, 174u8, 26u8, 59u8, 174u8,
+                166u8, 174u8, 140u8, 4u8, 203u8, 43u8, 152u8, 164u8,
+            ],
+            [
+                198u8, 163u8, 119u8, 191u8, 196u8, 235u8, 18u8, 0u8, 36u8, 168u8, 172u8, 8u8,
+                238u8, 242u8, 5u8, 190u8, 22u8, 184u8, 23u8, 2u8, 8u8, 18u8, 199u8, 50u8, 35u8,
+                232u8, 29u8, 27u8, 219u8, 151u8, 8u8, 236u8,
+            ],
+            [
+                218u8, 159u8, 167u8, 193u8, 176u8, 4u8, 2u8, 193u8, 125u8, 1u8, 97u8, 178u8, 73u8,
+                177u8, 171u8, 139u8, 190u8, 192u8, 71u8, 197u8, 165u8, 34u8, 7u8, 185u8, 193u8,
+                18u8, 222u8, 255u8, 216u8, 23u8, 3u8, 107u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <UnorderedNonceInvalidation as alloy_sol_types::SolEvent>::SIGNATURE,
+            <NonceInvalidation as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Lockdown as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Permit as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(UnorderedNonceInvalidation),
+            ::core::stringify!(NonceInvalidation),
+            ::core::stringify!(Lockdown),
+            ::core::stringify!(Permit),
+            ::core::stringify!(Approval),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for Permit2Events {
+        const COUNT: usize = 5usize;
+        const NAME: &'static str = "Permit2Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<Lockdown as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Lockdown as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Lockdown)
+                }
+                Some(<NonceInvalidation as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <NonceInvalidation as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::NonceInvalidation)
+                }
+                Some(<Permit as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Permit as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Permit)
+                }
+                Some(<UnorderedNonceInvalidation as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <UnorderedNonceInvalidation as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::UnorderedNonceInvalidation)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for Permit2Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Lockdown(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::NonceInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Permit(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::UnorderedNonceInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Lockdown(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::NonceInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Permit(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::UnorderedNonceInvalidation(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Permit2`](self) contract instance.
+
+    See the [wrapper's documentation](`Permit2Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> Permit2Instance<P, N> {
+        Permit2Instance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<Permit2Instance<P, N>>> {
+        Permit2Instance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        Permit2Instance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Permit2`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Permit2`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct Permit2Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for Permit2Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("Permit2Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        Permit2Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Permit2`](self) contract instance.
+
+        See the [wrapper's documentation](`Permit2Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<Permit2Instance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> Permit2Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> Permit2Instance<P, N> {
+            Permit2Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        Permit2Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
+        pub fn DOMAIN_SEPARATOR(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, DOMAIN_SEPARATORCall, N> {
+            self.call_builder(&DOMAIN_SEPARATORCall)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+            _2: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { _0, _1, _2 })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            token: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U160,
+            expiration: alloy_sol_types::private::primitives::aliases::U48,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall {
+                token,
+                spender,
+                amount,
+                expiration,
+            })
+        }
+
+        ///Creates a new call builder for the [`invalidateNonces`] function.
+        pub fn invalidateNonces(
+            &self,
+            token: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+            newNonce: alloy_sol_types::private::primitives::aliases::U48,
+        ) -> alloy_contract::SolCallBuilder<&P, invalidateNoncesCall, N> {
+            self.call_builder(&invalidateNoncesCall {
+                token,
+                spender,
+                newNonce,
+            })
+        }
+
+        ///Creates a new call builder for the [`invalidateUnorderedNonces`]
+        /// function.
+        pub fn invalidateUnorderedNonces(
+            &self,
+            wordPos: alloy_sol_types::private::primitives::aliases::U256,
+            mask: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, invalidateUnorderedNoncesCall, N> {
+            self.call_builder(&invalidateUnorderedNoncesCall { wordPos, mask })
+        }
+
+        ///Creates a new call builder for the [`lockdown`] function.
+        pub fn lockdown(
+            &self,
+            approvals: alloy_sol_types::private::Vec<
+                <IAllowanceTransfer::TokenSpenderPair as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, lockdownCall, N> {
+            self.call_builder(&lockdownCall { approvals })
+        }
+
+        ///Creates a new call builder for the [`nonceBitmap`] function.
+        pub fn nonceBitmap(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, nonceBitmapCall, N> {
+            self.call_builder(&nonceBitmapCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`permit`] function.
+        pub fn permit(
+            &self,
+            owner: alloy_sol_types::private::Address,
+            permitSingle: <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
+            signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, permitCall, N> {
+            self.call_builder(&permitCall {
+                owner,
+                permitSingle,
+                signature,
+            })
+        }
+
+        ///Creates a new call builder for the [`permitTransferFrom`] function.
+        pub fn permitTransferFrom(
+            &self,
+            permit: <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::RustType,
+            transferDetails: <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+            owner: alloy_sol_types::private::Address,
+            signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, permitTransferFromCall, N> {
+            self.call_builder(&permitTransferFromCall {
+                permit,
+                transferDetails,
+                owner,
+                signature,
+            })
+        }
+
+        ///Creates a new call builder for the [`permitWitnessTransferFrom`]
+        /// function.
+        pub fn permitWitnessTransferFrom(
+            &self,
+            permit: <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::RustType,
+            transferDetails: alloy_sol_types::private::Vec<
+                <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+            >,
+            owner: alloy_sol_types::private::Address,
+            witness: alloy_sol_types::private::FixedBytes<32>,
+            witnessTypeString: alloy_sol_types::private::String,
+            signature: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, permitWitnessTransferFromCall, N> {
+            self.call_builder(&permitWitnessTransferFromCall {
+                permit,
+                transferDetails,
+                owner,
+                witness,
+                witnessTypeString,
+                signature,
+            })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            from: alloy_sol_types::private::Address,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U160,
+            token: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall {
+                from,
+                to,
+                amount,
+                token,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        Permit2Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`Lockdown`] event.
+        pub fn Lockdown_filter(&self) -> alloy_contract::Event<&P, Lockdown, N> {
+            self.event_filter::<Lockdown>()
+        }
+
+        ///Creates a new event filter for the [`NonceInvalidation`] event.
+        pub fn NonceInvalidation_filter(&self) -> alloy_contract::Event<&P, NonceInvalidation, N> {
+            self.event_filter::<NonceInvalidation>()
+        }
+
+        ///Creates a new event filter for the [`Permit`] event.
+        pub fn Permit_filter(&self) -> alloy_contract::Event<&P, Permit, N> {
+            self.event_filter::<Permit>()
+        }
+
+        ///Creates a new event filter for the [`UnorderedNonceInvalidation`]
+        /// event.
+        pub fn UnorderedNonceInvalidation_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, UnorderedNonceInvalidation, N> {
+            self.event_filter::<UnorderedNonceInvalidation>()
+        }
+    }
+}
+pub type Instance = Permit2::Permit2Instance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(15986406u64),
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(38854427u64),
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(25343783u64),
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(27338672u64),
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(35701901u64),
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(1425180u64),
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(7808u64),
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(38692735u64),
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(28844415u64),
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(0u64),
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x000000000022D473030F116dDEE9F6B43aC78BA3"),
+            Some(2356287u64),
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/remoteerc20balances/Cargo.toml b/contracts/generated/contracts-generated/remoteerc20balances/Cargo.toml
new file mode 100644
index 0000000000..af047dacde
--- /dev/null
+++ b/contracts/generated/contracts-generated/remoteerc20balances/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-remoteerc20balances"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/remoteerc20balances/src/lib.rs b/contracts/generated/contracts-generated/remoteerc20balances/src/lib.rs
new file mode 100644
index 0000000000..8178b3dc19
--- /dev/null
+++ b/contracts/generated/contracts-generated/remoteerc20balances/src/lib.rs
@@ -0,0 +1,1909 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface RemoteERC20Balances {
+    constructor(address _target, bool _balanceFromHere);
+
+    function allowance(address user, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external;
+    function balanceOf(address user) external view returns (uint256);
+    function mint(address user, uint256 amount) external;
+    function target() external view returns (address);
+    function transfer(address to, uint256 amount) external;
+    function transferFrom(address from, address to, uint256 amount) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_target",
+        "type": "address",
+        "internalType": "contract NonStandardERC20Balances"
+      },
+      {
+        "name": "_balanceFromHere",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "target",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract NonStandardERC20Balances"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod RemoteERC20Balances {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x07\x138\x03\x80a\x07\x13\x839\x81\x01`@\x81\x90Ra\0.\x91a\0DV[\x15\x15`\x80R`\x01`\x01`\xA0\x1B\x03\x16`\xA0Ra\0\x8BV[__`@\x83\x85\x03\x12\x15a\0UW__\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0kW__\xFD[` \x84\x01Q\x90\x92P\x80\x15\x15\x81\x14a\0\x80W__\xFD[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x06`a\0\xB3_9_\x81\x81a\x01T\x01Ra\x03#\x01R_a\x03\x90\x01Ra\x06`_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0zW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0XW\x80cp\xA0\x821\x14a\x01\x16W\x80c\xA9\x05\x9C\xBB\x14a\x01<W\x80c\xD4\xB89\x92\x14a\x01OW\x80c\xDDb\xED>\x14a\x01\x9BW__\xFD[\x80c\t^\xA7\xB3\x14a\0~W\x80c#\xB8r\xDD\x14a\0\xC6W\x80c@\xC1\x0F\x19\x14a\0\xD9W[__\xFD[a\0\xC4a\0\x8C6`\x04a\x05\x06V[3_\x90\x81R` \x81\x81R`@\x80\x83 s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x90\x95\x16\x83R`\x01\x90\x94\x01\x90R\x91\x90\x91 UV[\0[a\0\xC4a\0\xD46`\x04a\x05.V[a\x01\xAEV[a\0\xC4a\0\xE76`\x04a\x05\x06V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16_\x90\x81R` \x81\x90R`@\x90 `\x01\x81U`\x02\x01UV[a\x01)a\x01$6`\x04a\x05hV[a\x02\xDAV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xC4a\x01J6`\x04a\x05\x06V[a\x03\xE9V[a\x01v\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x013V[a\x01)a\x01\xA96`\x04a\x05\x81V[a\x04\xA3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 3\x84R`\x01\x01\x90\x91R\x81 \x80T\x83\x92\x90a\x01\xEE\x90\x84\x90a\x05\xDFV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02*\x90\x84\x90a\x05\xDFV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02_\x83a\x05\xF2V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02\x9B\x90\x84\x90a\x06)V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02\xD0\x83a\x05\xF2V[\x91\x90PUPPPPV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16`\x04\x83\x01R_\x91\x82\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03hW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x8C\x91\x90a\x06<V[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x03\xB9W\x80a\x03\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x90 `\x02\x01T[\x93\x92PPPV[3_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x04\n\x90\x84\x90a\x05\xDFV[\x90\x91UPP3_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x04)\x83a\x05\xF2V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x04e\x90\x84\x90a\x06)V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x04\x9A\x83a\x05\xF2V[\x91\x90PUPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x85\x16\x83R`\x01\x90\x93\x01\x90R T[\x92\x91PPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x05\x01W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x05\x17W__\xFD[a\x05 \x83a\x04\xDEV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x05@W__\xFD[a\x05I\x84a\x04\xDEV[\x92Pa\x05W` \x85\x01a\x04\xDEV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x05xW__\xFD[a\x03\xE2\x82a\x04\xDEV[__`@\x83\x85\x03\x12\x15a\x05\x92W__\xFD[a\x05\x9B\x83a\x04\xDEV[\x91Pa\x05\xA9` \x84\x01a\x04\xDEV[\x90P\x92P\x92\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x04\xD8Wa\x04\xD8a\x05\xB2V[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x03a\x06\"Wa\x06\"a\x05\xB2V[P`\x01\x01\x90V[\x80\x82\x01\x80\x82\x11\x15a\x04\xD8Wa\x04\xD8a\x05\xB2V[_` \x82\x84\x03\x12\x15a\x06LW__\xFD[PQ\x91\x90PV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x608060405234801561000f575f5ffd5b506004361061007a575f3560e01c806370a082311161005857806370a0823114610116578063a9059cbb1461013c578063d4b839921461014f578063dd62ed3e1461019b575f5ffd5b8063095ea7b31461007e57806323b872dd146100c657806340c10f19146100d9575b5f5ffd5b6100c461008c366004610506565b335f9081526020818152604080832073ffffffffffffffffffffffffffffffffffffffff959095168352600190940190529190912055565b005b6100c46100d436600461052e565b6101ae565b6100c46100e7366004610506565b73ffffffffffffffffffffffffffffffffffffffff9091165f9081526020819052604090206001815560020155565b610129610124366004610568565b6102da565b6040519081526020015b60405180910390f35b6100c461014a366004610506565b6103e9565b6101767f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610133565b6101296101a9366004610581565b6104a3565b73ffffffffffffffffffffffffffffffffffffffff83165f90815260208181526040808320338452600101909152812080548392906101ee9084906105df565b909155505073ffffffffffffffffffffffffffffffffffffffff83165f908152602081905260408120600201805483929061022a9084906105df565b909155505073ffffffffffffffffffffffffffffffffffffffff83165f90815260208190526040812080549161025f836105f2565b909155505073ffffffffffffffffffffffffffffffffffffffff82165f908152602081905260408120600201805483929061029b908490610629565b909155505073ffffffffffffffffffffffffffffffffffffffff82165f9081526020819052604081208054916102d0836105f2565b9190505550505050565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff82811660048301525f9182917f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015610368573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061038c919061063c565b90507f00000000000000000000000000000000000000000000000000000000000000006103b957806103e2565b73ffffffffffffffffffffffffffffffffffffffff83165f908152602081905260409020600201545b9392505050565b335f908152602081905260408120600201805483929061040a9084906105df565b9091555050335f908152602081905260408120805491610429836105f2565b909155505073ffffffffffffffffffffffffffffffffffffffff82165f9081526020819052604081206002018054839290610465908490610629565b909155505073ffffffffffffffffffffffffffffffffffffffff82165f90815260208190526040812080549161049a836105f2565b91905055505050565b73ffffffffffffffffffffffffffffffffffffffff8083165f9081526020818152604080832093851683526001909301905220545b92915050565b803573ffffffffffffffffffffffffffffffffffffffff81168114610501575f5ffd5b919050565b5f5f60408385031215610517575f5ffd5b610520836104de565b946020939093013593505050565b5f5f5f60608486031215610540575f5ffd5b610549846104de565b9250610557602085016104de565b929592945050506040919091013590565b5f60208284031215610578575f5ffd5b6103e2826104de565b5f5f60408385031215610592575f5ffd5b61059b836104de565b91506105a9602084016104de565b90509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b818103818111156104d8576104d86105b2565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203610622576106226105b2565b5060010190565b808201808211156104d8576104d86105b2565b5f6020828403121561064c575f5ffd5b505191905056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0zW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0XW\x80cp\xA0\x821\x14a\x01\x16W\x80c\xA9\x05\x9C\xBB\x14a\x01<W\x80c\xD4\xB89\x92\x14a\x01OW\x80c\xDDb\xED>\x14a\x01\x9BW__\xFD[\x80c\t^\xA7\xB3\x14a\0~W\x80c#\xB8r\xDD\x14a\0\xC6W\x80c@\xC1\x0F\x19\x14a\0\xD9W[__\xFD[a\0\xC4a\0\x8C6`\x04a\x05\x06V[3_\x90\x81R` \x81\x81R`@\x80\x83 s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x90\x95\x16\x83R`\x01\x90\x94\x01\x90R\x91\x90\x91 UV[\0[a\0\xC4a\0\xD46`\x04a\x05.V[a\x01\xAEV[a\0\xC4a\0\xE76`\x04a\x05\x06V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16_\x90\x81R` \x81\x90R`@\x90 `\x01\x81U`\x02\x01UV[a\x01)a\x01$6`\x04a\x05hV[a\x02\xDAV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xC4a\x01J6`\x04a\x05\x06V[a\x03\xE9V[a\x01v\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x013V[a\x01)a\x01\xA96`\x04a\x05\x81V[a\x04\xA3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 3\x84R`\x01\x01\x90\x91R\x81 \x80T\x83\x92\x90a\x01\xEE\x90\x84\x90a\x05\xDFV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02*\x90\x84\x90a\x05\xDFV[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02_\x83a\x05\xF2V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x02\x9B\x90\x84\x90a\x06)V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x02\xD0\x83a\x05\xF2V[\x91\x90PUPPPPV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16`\x04\x83\x01R_\x91\x82\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03hW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x8C\x91\x90a\x06<V[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x03\xB9W\x80a\x03\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16_\x90\x81R` \x81\x90R`@\x90 `\x02\x01T[\x93\x92PPPV[3_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x04\n\x90\x84\x90a\x05\xDFV[\x90\x91UPP3_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x04)\x83a\x05\xF2V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 `\x02\x01\x80T\x83\x92\x90a\x04e\x90\x84\x90a\x06)V[\x90\x91UPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x91a\x04\x9A\x83a\x05\xF2V[\x91\x90PUPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x85\x16\x83R`\x01\x90\x93\x01\x90R T[\x92\x91PPV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x05\x01W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x05\x17W__\xFD[a\x05 \x83a\x04\xDEV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x05@W__\xFD[a\x05I\x84a\x04\xDEV[\x92Pa\x05W` \x85\x01a\x04\xDEV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x05xW__\xFD[a\x03\xE2\x82a\x04\xDEV[__`@\x83\x85\x03\x12\x15a\x05\x92W__\xFD[a\x05\x9B\x83a\x04\xDEV[\x91Pa\x05\xA9` \x84\x01a\x04\xDEV[\x90P\x92P\x92\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x04\xD8Wa\x04\xD8a\x05\xB2V[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x03a\x06\"Wa\x06\"a\x05\xB2V[P`\x01\x01\x90V[\x80\x82\x01\x80\x82\x11\x15a\x04\xD8Wa\x04\xD8a\x05\xB2V[_` \x82\x84\x03\x12\x15a\x06LW__\xFD[PQ\x91\x90PV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /**Constructor`.
+    ```solidity
+    constructor(address _target, bool _balanceFromHere);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _balanceFromHere: bool,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, bool);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._target, value._balanceFromHere)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _target: tuple.0,
+                        _balanceFromHere: tuple.1,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._target,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self._balanceFromHere,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address user, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.user, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        user: tuple.0,
+                        spender: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl approveReturn {
+            fn _tokenize(&self) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = approveReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                approveReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address user) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.user,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { user: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
+    ```solidity
+    function mint(address user, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`mint(address,uint256)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.user, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        user: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = mintReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                mintReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `target()` and selector `0xd4b83992`.
+    ```solidity
+    function target() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct targetCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`target()`](targetCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct targetReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<targetCall> for UnderlyingRustTuple<'_> {
+                fn from(value: targetCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for targetCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<targetReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: targetReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for targetReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for targetCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [212u8, 184u8, 57u8, 146u8];
+            const SIGNATURE: &'static str = "target()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: targetReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: targetReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address to, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferReturn {
+            fn _tokenize(&self) -> <transferCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = transferReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address from, address to, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.from, value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        from: tuple.0,
+                        to: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl transferFromReturn {
+            fn _tokenize(&self) -> <transferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = transferFromReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                transferFromReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`RemoteERC20Balances`](self) function calls.
+    #[derive(Clone)]
+    pub enum RemoteERC20BalancesCalls {
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        target(targetCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl RemoteERC20BalancesCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [9u8, 94u8, 167u8, 179u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [64u8, 193u8, 15u8, 25u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [212u8, 184u8, 57u8, 146u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <targetCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(approve),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(mint),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(transfer),
+            ::core::stringify!(target),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for RemoteERC20BalancesCalls {
+        const COUNT: usize = 7usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "RemoteERC20BalancesCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::target(_) => <targetCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<RemoteERC20BalancesCalls>] = &[
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn target(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <targetCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::target)
+                    }
+                    target
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(RemoteERC20BalancesCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                RemoteERC20BalancesCalls,
+            >] = &[
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(RemoteERC20BalancesCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(RemoteERC20BalancesCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(RemoteERC20BalancesCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(RemoteERC20BalancesCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(RemoteERC20BalancesCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn target(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <targetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(RemoteERC20BalancesCalls::target)
+                    }
+                    target
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<RemoteERC20BalancesCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(RemoteERC20BalancesCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::target(inner) => {
+                    <targetCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::target(inner) => {
+                    <targetCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`RemoteERC20Balances`](self) contract instance.
+
+    See the [wrapper's documentation](`RemoteERC20BalancesInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> RemoteERC20BalancesInstance<P, N> {
+        RemoteERC20BalancesInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _target: alloy_sol_types::private::Address,
+        _balanceFromHere: bool,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<RemoteERC20BalancesInstance<P, N>>>
+    {
+        RemoteERC20BalancesInstance::<P, N>::deploy(__provider, _target, _balanceFromHere)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _target: alloy_sol_types::private::Address,
+        _balanceFromHere: bool,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        RemoteERC20BalancesInstance::<P, N>::deploy_builder(__provider, _target, _balanceFromHere)
+    }
+    /**A [`RemoteERC20Balances`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`RemoteERC20Balances`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct RemoteERC20BalancesInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for RemoteERC20BalancesInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("RemoteERC20BalancesInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        RemoteERC20BalancesInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`RemoteERC20Balances`](self) contract instance.
+
+        See the [wrapper's documentation](`RemoteERC20BalancesInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _target: alloy_sol_types::private::Address,
+            _balanceFromHere: bool,
+        ) -> alloy_contract::Result<RemoteERC20BalancesInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _target, _balanceFromHere);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _target: alloy_sol_types::private::Address,
+            _balanceFromHere: bool,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        _target,
+                        _balanceFromHere,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> RemoteERC20BalancesInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> RemoteERC20BalancesInstance<P, N> {
+            RemoteERC20BalancesInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        RemoteERC20BalancesInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            user: alloy_sol_types::private::Address,
+            spender: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { user, spender })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            user: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall { user })
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            user: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { user, amount })
+        }
+
+        ///Creates a new call builder for the [`target`] function.
+        pub fn target(&self) -> alloy_contract::SolCallBuilder<&P, targetCall, N> {
+            self.call_builder(&targetCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { to, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            from: alloy_sol_types::private::Address,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall { from, to, amount })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        RemoteERC20BalancesInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = RemoteERC20Balances::RemoteERC20BalancesInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/signatures/Cargo.toml b/contracts/generated/contracts-generated/signatures/Cargo.toml
new file mode 100644
index 0000000000..19b023805a
--- /dev/null
+++ b/contracts/generated/contracts-generated/signatures/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-signatures"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/signatures/src/lib.rs b/contracts/generated/contracts-generated/signatures/src/lib.rs
new file mode 100644
index 0000000000..1f94bce242
--- /dev/null
+++ b/contracts/generated/contracts-generated/signatures/src/lib.rs
@@ -0,0 +1,1175 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Signatures {
+    struct Contracts {
+        address settlement;
+        address vaultRelayer;
+    }
+    struct Interaction {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    function validate(Contracts memory contracts, address signer, bytes32 order, bytes memory signature, Interaction[] memory interactions) external returns (uint256 gasUsed);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "validate",
+    "inputs": [
+      {
+        "name": "contracts",
+        "type": "tuple",
+        "internalType": "struct Signatures.Contracts",
+        "components": [
+          {
+            "name": "settlement",
+            "type": "address",
+            "internalType": "contract ISettlement"
+          },
+          {
+            "name": "vaultRelayer",
+            "type": "address",
+            "internalType": "contract IVaultRelayer"
+          }
+        ]
+      },
+      {
+        "name": "signer",
+        "type": "address",
+        "internalType": "contract IERC1271"
+      },
+      {
+        "name": "order",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "interactions",
+        "type": "tuple[]",
+        "internalType": "struct Interaction[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "gasUsed",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Signatures {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x07#\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xB4`T\x15\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x04PV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0^\x88\x84\x84a\x01\xA9V[Z\x90P_\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x16&\xBA~\x88\x88\x88`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\0\x9F\x93\x92\x91\x90a\x05ZV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xBAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xDE\x91\x90a\x05\xADV[\x90PZa\0\xEB\x90\x83a\x05\xF3V[\x91P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x14a\x01\x9DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fdidn't say the magic word\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[P\x97\x96PPPPPPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x02)W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x94V[_[\x81\x81\x10\x15a\x03\x90W_\x83\x83\x83\x81\x81\x10a\x02FWa\x02Fa\x061V[\x90P` \x02\x81\x01\x90a\x02X\x91\x90a\x06^V[a\x02f\x90` \x81\x01\x90a\x06\x9AV[\x90P_\x84\x84\x84\x81\x81\x10a\x02{Wa\x02{a\x061V[\x90P` \x02\x81\x01\x90a\x02\x8D\x91\x90a\x06^V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x02\xA7Wa\x02\xA7a\x061V[\x90P` \x02\x81\x01\x90a\x02\xB9\x91\x90a\x06^V[a\x02\xC7\x90`@\x81\x01\x90a\x06\xB5V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x03dW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x94V[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\x03\x7FW=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x02+\x91PPV[PPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\xB7W__\xFD[PV[\x805a\x03\xC5\x81a\x03\x96V[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x03\xDAW__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xF1W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x04\x08W__\xFD[\x92P\x92\x90PV[__\x83`\x1F\x84\x01\x12a\x04\x1FW__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x046W__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x04\x08W__\xFD[_______\x87\x89\x03`\xC0\x81\x12\x15a\x04gW__\xFD[`@\x81\x12\x15a\x04tW__\xFD[P`@Q`@\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04\xBDW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@R\x885a\x04\xCB\x81a\x03\x96V[\x81R` \x89\x015a\x04\xDB\x81a\x03\x96V[` \x82\x01R\x96Pa\x04\xEE`@\x89\x01a\x03\xBAV[\x95P``\x88\x015\x94P`\x80\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05\x10W__\xFD[a\x05\x1C\x8A\x82\x8B\x01a\x03\xCAV[\x90\x95P\x93PP`\xA0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05;W__\xFD[a\x05G\x8A\x82\x8B\x01a\x04\x0FV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[\x83\x81R`@` \x82\x01R\x81`@\x82\x01R\x81\x83``\x83\x017_\x81\x83\x01``\x90\x81\x01\x91\x90\x91R`\x1F\x90\x92\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x01\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x05\xBDW__\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x05\xECW__\xFD[\x93\x92PPPV[\x81\x81\x03\x81\x81\x11\x15a\x06+W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\x06\x90W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\xAAW__\xFD[\x815a\x05\xEC\x81a\x03\x96V[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x06\xE8W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x07\x02W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x04\x08W__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063b46054151461002d575b5f5ffd5b61004061003b366004610450565b610052565b60405190815260200160405180910390f35b5f61005e8884846101a9565b5a90505f8773ffffffffffffffffffffffffffffffffffffffff16631626ba7e8888886040518463ffffffff1660e01b815260040161009f9392919061055a565b602060405180830381865afa1580156100ba573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100de91906105ad565b90505a6100eb90836105f3565b91507fffffffff0000000000000000000000000000000000000000000000000000000081167f1626ba7e000000000000000000000000000000000000000000000000000000001461019d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f6469646e27742073617920746865206d6167696320776f72640000000000000060448201526064015b60405180910390fd5b50979650505050505050565b825173ffffffffffffffffffffffffffffffffffffffff163014610229576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f696e636f72726563742063616c6c696e6720636f6e74657874000000000000006044820152606401610194565b5f5b81811015610390575f83838381811061024657610246610631565b9050602002810190610258919061065e565b61026690602081019061069a565b90505f84848481811061027b5761027b610631565b905060200281019061028d919061065e565b602001359050365f8686868181106102a7576102a7610631565b90506020028101906102b9919061065e565b6102c79060408101906106b5565b91509150876020015173ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1603610364576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601b60248201527f475076323a20666f7262696464656e20696e746572616374696f6e00000000006044820152606401610194565b604051818382375f5f838387895af161037f573d5f5f3e3d5ffd5b50506001909301925061022b915050565b50505050565b73ffffffffffffffffffffffffffffffffffffffff811681146103b7575f5ffd5b50565b80356103c581610396565b919050565b5f5f83601f8401126103da575f5ffd5b50813567ffffffffffffffff8111156103f1575f5ffd5b602083019150836020828501011115610408575f5ffd5b9250929050565b5f5f83601f84011261041f575f5ffd5b50813567ffffffffffffffff811115610436575f5ffd5b6020830191508360208260051b8501011115610408575f5ffd5b5f5f5f5f5f5f5f87890360c0811215610467575f5ffd5b6040811215610474575f5ffd5b506040516040810181811067ffffffffffffffff821117156104bd577f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b60405288356104cb81610396565b815260208901356104db81610396565b602082015296506104ee604089016103ba565b955060608801359450608088013567ffffffffffffffff811115610510575f5ffd5b61051c8a828b016103ca565b90955093505060a088013567ffffffffffffffff81111561053b575f5ffd5b6105478a828b0161040f565b989b979a50959850939692959293505050565b83815260406020820152816040820152818360608301375f818301606090810191909152601f9092017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016010192915050565b5f602082840312156105bd575f5ffd5b81517fffffffff00000000000000000000000000000000000000000000000000000000811681146105ec575f5ffd5b9392505050565b8181038181111561062b577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f82357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa1833603018112610690575f5ffd5b9190910192915050565b5f602082840312156106aa575f5ffd5b81356105ec81610396565b5f5f83357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe18436030181126106e8575f5ffd5b83018035915067ffffffffffffffff821115610702575f5ffd5b602001915036819003821315610408575f5ffdfea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xB4`T\x15\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x04PV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0^\x88\x84\x84a\x01\xA9V[Z\x90P_\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x16&\xBA~\x88\x88\x88`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\0\x9F\x93\x92\x91\x90a\x05ZV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xBAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xDE\x91\x90a\x05\xADV[\x90PZa\0\xEB\x90\x83a\x05\xF3V[\x91P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x14a\x01\x9DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fdidn't say the magic word\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[P\x97\x96PPPPPPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x02)W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x94V[_[\x81\x81\x10\x15a\x03\x90W_\x83\x83\x83\x81\x81\x10a\x02FWa\x02Fa\x061V[\x90P` \x02\x81\x01\x90a\x02X\x91\x90a\x06^V[a\x02f\x90` \x81\x01\x90a\x06\x9AV[\x90P_\x84\x84\x84\x81\x81\x10a\x02{Wa\x02{a\x061V[\x90P` \x02\x81\x01\x90a\x02\x8D\x91\x90a\x06^V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x02\xA7Wa\x02\xA7a\x061V[\x90P` \x02\x81\x01\x90a\x02\xB9\x91\x90a\x06^V[a\x02\xC7\x90`@\x81\x01\x90a\x06\xB5V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x03dW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x94V[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\x03\x7FW=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x02+\x91PPV[PPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\xB7W__\xFD[PV[\x805a\x03\xC5\x81a\x03\x96V[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x03\xDAW__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xF1W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x04\x08W__\xFD[\x92P\x92\x90PV[__\x83`\x1F\x84\x01\x12a\x04\x1FW__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x046W__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x04\x08W__\xFD[_______\x87\x89\x03`\xC0\x81\x12\x15a\x04gW__\xFD[`@\x81\x12\x15a\x04tW__\xFD[P`@Q`@\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04\xBDW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@R\x885a\x04\xCB\x81a\x03\x96V[\x81R` \x89\x015a\x04\xDB\x81a\x03\x96V[` \x82\x01R\x96Pa\x04\xEE`@\x89\x01a\x03\xBAV[\x95P``\x88\x015\x94P`\x80\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05\x10W__\xFD[a\x05\x1C\x8A\x82\x8B\x01a\x03\xCAV[\x90\x95P\x93PP`\xA0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05;W__\xFD[a\x05G\x8A\x82\x8B\x01a\x04\x0FV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[\x83\x81R`@` \x82\x01R\x81`@\x82\x01R\x81\x83``\x83\x017_\x81\x83\x01``\x90\x81\x01\x91\x90\x91R`\x1F\x90\x92\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x01\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x05\xBDW__\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x05\xECW__\xFD[\x93\x92PPPV[\x81\x81\x03\x81\x81\x11\x15a\x06+W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\x06\x90W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\xAAW__\xFD[\x815a\x05\xEC\x81a\x03\x96V[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x06\xE8W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x07\x02W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x04\x08W__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Contracts { address settlement; address vaultRelayer; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Contracts {
+        #[allow(missing_docs)]
+        pub settlement: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub vaultRelayer: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Contracts> for UnderlyingRustTuple<'_> {
+            fn from(value: Contracts) -> Self {
+                (value.settlement, value.vaultRelayer)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Contracts {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    settlement: tuple.0,
+                    vaultRelayer: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Contracts {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Contracts {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlement,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vaultRelayer,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Contracts {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Contracts {
+            const NAME: &'static str = "Contracts";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Contracts(address settlement,address vaultRelayer)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.settlement,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.vaultRelayer,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Contracts {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.settlement,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.vaultRelayer,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.settlement,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.vaultRelayer,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Interaction { address target; uint256 value; bytes callData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Interaction {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Interaction> for UnderlyingRustTuple<'_> {
+            fn from(value: Interaction) -> Self {
+                (value.target, value.value, value.callData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Interaction {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    value: tuple.1,
+                    callData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Interaction {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Interaction {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Interaction {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Interaction {
+            const NAME: &'static str = "Interaction";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Interaction(address target,uint256 value,bytes callData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Interaction {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `validate((address,address),address,bytes32,bytes,(address,uint256,bytes)[])` and selector `0xb4605415`.
+    ```solidity
+    function validate(Contracts memory contracts, address signer, bytes32 order, bytes memory signature, Interaction[] memory interactions) external returns (uint256 gasUsed);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateCall {
+        #[allow(missing_docs)]
+        pub contracts: <Contracts as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub order: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub interactions:
+            alloy_sol_types::private::Vec<<Interaction as alloy_sol_types::SolType>::RustType>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`validate((address,address),address,bytes32,bytes,(address,uint256,
+    /// bytes)[])`](validateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct validateReturn {
+        #[allow(missing_docs)]
+        pub gasUsed: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                Contracts,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Array<Interaction>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <Contracts as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Vec<<Interaction as alloy_sol_types::SolType>::RustType>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: validateCall) -> Self {
+                    (
+                        value.contracts,
+                        value.signer,
+                        value.order,
+                        value.signature,
+                        value.interactions,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        contracts: tuple.0,
+                        signer: tuple.1,
+                        order: tuple.2,
+                        signature: tuple.3,
+                        interactions: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<validateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: validateReturn) -> Self {
+                    (value.gasUsed,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { gasUsed: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for validateCall {
+            type Parameters<'a> = (
+                Contracts,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Array<Interaction>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [180u8, 96u8, 84u8, 21u8];
+            const SIGNATURE: &'static str =
+                "validate((address,address),address,bytes32,bytes,(address,uint256,bytes)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <Contracts as alloy_sol_types::SolType>::tokenize(&self.contracts),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        Interaction,
+                    > as alloy_sol_types::SolType>::tokenize(&self.interactions),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: validateReturn = r.into();
+                        r.gasUsed
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: validateReturn = r.into();
+                    r.gasUsed
+                })
+            }
+        }
+    };
+    ///Container for all the [`Signatures`](self) function calls.
+    #[derive(Clone)]
+    pub enum SignaturesCalls {
+        #[allow(missing_docs)]
+        validate(validateCall),
+    }
+    impl SignaturesCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[180u8, 96u8, 84u8, 21u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<validateCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(validate)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SignaturesCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 256usize;
+        const NAME: &'static str = "SignaturesCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::validate(_) => <validateCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SignaturesCalls>] = &[{
+                fn validate(data: &[u8]) -> alloy_sol_types::Result<SignaturesCalls> {
+                    <validateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(SignaturesCalls::validate)
+                }
+                validate
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<SignaturesCalls>] = &[{
+                fn validate(data: &[u8]) -> alloy_sol_types::Result<SignaturesCalls> {
+                    <validateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(SignaturesCalls::validate)
+                }
+                validate
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::validate(inner) => {
+                    <validateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::validate(inner) => {
+                    <validateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Signatures`](self) contract instance.
+
+    See the [wrapper's documentation](`SignaturesInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SignaturesInstance<P, N> {
+        SignaturesInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<SignaturesInstance<P, N>>>
+    {
+        SignaturesInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        SignaturesInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Signatures`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Signatures`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SignaturesInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SignaturesInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SignaturesInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SignaturesInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Signatures`](self) contract instance.
+
+        See the [wrapper's documentation](`SignaturesInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<SignaturesInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SignaturesInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SignaturesInstance<P, N> {
+            SignaturesInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SignaturesInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`validate`] function.
+        pub fn validate(
+            &self,
+            contracts: <Contracts as alloy_sol_types::SolType>::RustType,
+            signer: alloy_sol_types::private::Address,
+            order: alloy_sol_types::private::FixedBytes<32>,
+            signature: alloy_sol_types::private::Bytes,
+            interactions: alloy_sol_types::private::Vec<
+                <Interaction as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, validateCall, N> {
+            self.call_builder(&validateCall {
+                contracts,
+                signer,
+                order,
+                signature,
+                interactions,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SignaturesInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Signatures::SignaturesInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0xf6E57e72F7dB3D9A51a8B4c149C00475b94A37e4"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/solver/Cargo.toml b/contracts/generated/contracts-generated/solver/Cargo.toml
new file mode 100644
index 0000000000..8f6ee5bae2
--- /dev/null
+++ b/contracts/generated/contracts-generated/solver/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-solver"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/solver/src/lib.rs b/contracts/generated/contracts-generated/solver/src/lib.rs
new file mode 100644
index 0000000000..cd27b738be
--- /dev/null
+++ b/contracts/generated/contracts-generated/solver/src/lib.rs
@@ -0,0 +1,1146 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Solver {
+    function ensureTradePreconditions(address trader, address settlementContract, address sellToken, uint256 sellAmount, address nativeToken, address spardose) external;
+    function storeBalance(address token, address owner, bool countGas) external;
+    function swap(address settlementContract, address[] memory tokens, address payable receiver, bytes memory settlementCall) external returns (uint256 gasUsed, uint256[] memory queriedBalances);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "ensureTradePreconditions",
+    "inputs": [
+      {
+        "name": "trader",
+        "type": "address",
+        "internalType": "contract Trader"
+      },
+      {
+        "name": "settlementContract",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      },
+      {
+        "name": "sellToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "nativeToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spardose",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "storeBalance",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "countGas",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "settlementContract",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "receiver",
+        "type": "address",
+        "internalType": "address payable"
+      },
+      {
+        "name": "settlementCall",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "gasUsed",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "queriedBalances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Solver {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\t\xC5\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1DG\xE7\xF4\x14a\0CW\x80c%\x82\xED\xB4\x14a\0mW\x80c;\xBB.\x1D\x14a\0\x82W[__\xFD[a\0Va\0Q6`\x04a\x07\x02V[a\0\x95V[`@Qa\0d\x92\x91\x90a\x07\xC6V[`@Q\x80\x91\x03\x90\xF3[a\0\x80a\0{6`\x04a\x08\x13V[a\x02)V[\0[a\0\x80a\0\x906`\x04a\x08\x88V[a\x03\x1EV[_``30\x14a\x01+W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`8`$\x82\x01R\x7Fonly simulation logic is allowed`D\x82\x01R\x7F to call 'swap' function\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01`@Q\x80\x91\x03\x90\xFD[_\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_`@Q_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x01\x81W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\x86V[``\x91P[PP\x90PPa\x01\x96\x87\x87\x8Aa\x04\x8DV[a\x01\xA1\x88\x85\x85a\x05WV[\x91Pa\x01\xAE\x87\x87\x8Aa\x04\x8DV[\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r,\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\x17W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11a\x02\x03W[PPPPP\x90P\x96P\x96\x94PPPPPV[_Z`@Q\x7FT.\xB7}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x87\x81\x16`$\x83\x01R`D\x82\x01\x87\x90R\x85\x81\x16`d\x83\x01R\x84\x81\x16`\x84\x83\x01R\x91\x92P\x90\x88\x16\x90cT.\xB7}\x90`\xA4\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xB4W__\xFD[PZ\xF1\x15\x80\x15a\x02\xC6W=__>=_\xFD[PPPPZa\x02\xD5\x90\x82a\t\x01V[a\x02\xE1\x90a\x11la\t\x1AV[\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r+_\x82\x82Ta\x03\x10\x91\x90a\t\x1AV[\x90\x91UPPPPPPPPPV[_Z\x90P\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r,s\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEEs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x14a\x04\x07W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`\x04\x83\x01R\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\x02\x91\x90a\t-V[a\x04 V[\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x161[\x81T`\x01\x81\x01\x83U_\x92\x83R` \x90\x92 \x90\x91\x01U\x81\x15a\x04\x87WZa\x04F\x90\x82a\t\x01V[a\x04R\x90a\x11la\t\x1AV[\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r+_\x82\x82Ta\x04\x81\x91\x90a\t\x1AV[\x90\x91UPP[PPPPV[_[\x82\x81\x10\x15a\x04\x87W0c;\xBB.\x1D\x85\x85\x84\x81\x81\x10a\x04\xAFWa\x04\xAFa\tDV[\x90P` \x02\x01` \x81\x01\x90a\x04\xC4\x91\x90a\tqV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16`\x04\x82\x01R\x90\x85\x16`$\x82\x01R_`D\x82\x01R`d\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x055W__\xFD[PZ\xF1\x15\x80\x15a\x05GW=__>=_\xFD[PP`\x01\x90\x92\x01\x91Pa\x04\x8F\x90PV[__Z\x90Pa\x05\xB2\x84\x84\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x89\x16\x92\x91PPa\x05\xF3V[P\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r+TZa\x05\xE0\x90\x83a\t\x01V[a\x05\xEA\x91\x90a\t\x01V[\x95\x94PPPPPV[``a\x06\0\x83_\x84a\x06\x07V[\x93\x92PPPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\x060\x91\x90a\t\x8CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x06jW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x06oV[``\x91P[P\x92P\x90P\x80a\x06\x81W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06\xAAW__\xFD[PV[\x805a\x06\xB8\x81a\x06\x89V[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x06\xCDW__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xE4W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x06\xFBW__\xFD[\x92P\x92\x90PV[______`\x80\x87\x89\x03\x12\x15a\x07\x17W__\xFD[\x865a\x07\"\x81a\x06\x89V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07=W__\xFD[\x87\x01`\x1F\x81\x01\x89\x13a\x07MW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07cW__\xFD[\x89` \x82`\x05\x1B\x84\x01\x01\x11\x15a\x07wW__\xFD[` \x91\x90\x91\x01\x95P\x93Pa\x07\x8D`@\x88\x01a\x06\xADV[\x92P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07\xA8W__\xFD[a\x07\xB4\x89\x82\x8A\x01a\x06\xBDV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_`@\x82\x01\x84\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x08\x07W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x07\xE9V[P\x90\x96\x95PPPPPPV[______`\xC0\x87\x89\x03\x12\x15a\x08(W__\xFD[\x865a\x083\x81a\x06\x89V[\x95P` \x87\x015a\x08C\x81a\x06\x89V[\x94P`@\x87\x015a\x08S\x81a\x06\x89V[\x93P``\x87\x015\x92P`\x80\x87\x015a\x08j\x81a\x06\x89V[\x91P`\xA0\x87\x015a\x08z\x81a\x06\x89V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[___``\x84\x86\x03\x12\x15a\x08\x9AW__\xFD[\x835a\x08\xA5\x81a\x06\x89V[\x92P` \x84\x015a\x08\xB5\x81a\x06\x89V[\x91P`@\x84\x015\x80\x15\x15\x81\x14a\x08\xC9W__\xFD[\x80\x91PP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\t\x14Wa\t\x14a\x08\xD4V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\t\x14Wa\t\x14a\x08\xD4V[_` \x82\x84\x03\x12\x15a\t=W__\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\t\x81W__\xFD[\x815a\x06\0\x81a\x06\x89V[_\x82Q_[\x81\x81\x10\x15a\t\xABW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\t\x91V[P_\x92\x01\x91\x82RP\x91\x90PV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1DG\xE7\xF4\x14a\0CW\x80c%\x82\xED\xB4\x14a\0mW\x80c;\xBB.\x1D\x14a\0\x82W[__\xFD[a\0Va\0Q6`\x04a\x07\x02V[a\0\x95V[`@Qa\0d\x92\x91\x90a\x07\xC6V[`@Q\x80\x91\x03\x90\xF3[a\0\x80a\0{6`\x04a\x08\x13V[a\x02)V[\0[a\0\x80a\0\x906`\x04a\x08\x88V[a\x03\x1EV[_``30\x14a\x01+W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`8`$\x82\x01R\x7Fonly simulation logic is allowed`D\x82\x01R\x7F to call 'swap' function\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01`@Q\x80\x91\x03\x90\xFD[_\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_`@Q_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x01\x81W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\x86V[``\x91P[PP\x90PPa\x01\x96\x87\x87\x8Aa\x04\x8DV[a\x01\xA1\x88\x85\x85a\x05WV[\x91Pa\x01\xAE\x87\x87\x8Aa\x04\x8DV[\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r,\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\x17W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11a\x02\x03W[PPPPP\x90P\x96P\x96\x94PPPPPV[_Z`@Q\x7FT.\xB7}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x87\x81\x16`$\x83\x01R`D\x82\x01\x87\x90R\x85\x81\x16`d\x83\x01R\x84\x81\x16`\x84\x83\x01R\x91\x92P\x90\x88\x16\x90cT.\xB7}\x90`\xA4\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xB4W__\xFD[PZ\xF1\x15\x80\x15a\x02\xC6W=__>=_\xFD[PPPPZa\x02\xD5\x90\x82a\t\x01V[a\x02\xE1\x90a\x11la\t\x1AV[\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r+_\x82\x82Ta\x03\x10\x91\x90a\t\x1AV[\x90\x91UPPPPPPPPPV[_Z\x90P\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r,s\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEEs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x14a\x04\x07W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`\x04\x83\x01R\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\x02\x91\x90a\t-V[a\x04 V[\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x161[\x81T`\x01\x81\x01\x83U_\x92\x83R` \x90\x92 \x90\x91\x01U\x81\x15a\x04\x87WZa\x04F\x90\x82a\t\x01V[a\x04R\x90a\x11la\t\x1AV[\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r+_\x82\x82Ta\x04\x81\x91\x90a\t\x1AV[\x90\x91UPP[PPPPV[_[\x82\x81\x10\x15a\x04\x87W0c;\xBB.\x1D\x85\x85\x84\x81\x81\x10a\x04\xAFWa\x04\xAFa\tDV[\x90P` \x02\x01` \x81\x01\x90a\x04\xC4\x91\x90a\tqV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16`\x04\x82\x01R\x90\x85\x16`$\x82\x01R_`D\x82\x01R`d\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x055W__\xFD[PZ\xF1\x15\x80\x15a\x05GW=__>=_\xFD[PP`\x01\x90\x92\x01\x91Pa\x04\x8F\x90PV[__Z\x90Pa\x05\xB2\x84\x84\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x89\x16\x92\x91PPa\x05\xF3V[P\x7F\x14\xF5\xB2\xC1\x85\xFC\x03\xC7\\x}\x1F\x0E\x10\xEA\x13|\xC6\xD25\xA0\x04tH\xEF\xF1\x8C\x9A\x17:r+TZa\x05\xE0\x90\x83a\t\x01V[a\x05\xEA\x91\x90a\t\x01V[\x95\x94PPPPPV[``a\x06\0\x83_\x84a\x06\x07V[\x93\x92PPPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\x060\x91\x90a\t\x8CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x06jW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x06oV[``\x91P[P\x92P\x90P\x80a\x06\x81W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06\xAAW__\xFD[PV[\x805a\x06\xB8\x81a\x06\x89V[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x06\xCDW__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xE4W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x06\xFBW__\xFD[\x92P\x92\x90PV[______`\x80\x87\x89\x03\x12\x15a\x07\x17W__\xFD[\x865a\x07\"\x81a\x06\x89V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07=W__\xFD[\x87\x01`\x1F\x81\x01\x89\x13a\x07MW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07cW__\xFD[\x89` \x82`\x05\x1B\x84\x01\x01\x11\x15a\x07wW__\xFD[` \x91\x90\x91\x01\x95P\x93Pa\x07\x8D`@\x88\x01a\x06\xADV[\x92P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07\xA8W__\xFD[a\x07\xB4\x89\x82\x8A\x01a\x06\xBDV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_`@\x82\x01\x84\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x08\x07W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x07\xE9V[P\x90\x96\x95PPPPPPV[______`\xC0\x87\x89\x03\x12\x15a\x08(W__\xFD[\x865a\x083\x81a\x06\x89V[\x95P` \x87\x015a\x08C\x81a\x06\x89V[\x94P`@\x87\x015a\x08S\x81a\x06\x89V[\x93P``\x87\x015\x92P`\x80\x87\x015a\x08j\x81a\x06\x89V[\x91P`\xA0\x87\x015a\x08z\x81a\x06\x89V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[___``\x84\x86\x03\x12\x15a\x08\x9AW__\xFD[\x835a\x08\xA5\x81a\x06\x89V[\x92P` \x84\x015a\x08\xB5\x81a\x06\x89V[\x91P`@\x84\x015\x80\x15\x15\x81\x14a\x08\xC9W__\xFD[\x80\x91PP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\t\x14Wa\t\x14a\x08\xD4V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\t\x14Wa\t\x14a\x08\xD4V[_` \x82\x84\x03\x12\x15a\t=W__\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\t\x81W__\xFD[\x815a\x06\0\x81a\x06\x89V[_\x82Q_[\x81\x81\x10\x15a\t\xABW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\t\x91V[P_\x92\x01\x91\x82RP\x91\x90PV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `ensureTradePreconditions(address,address,address,uint256,address,address)` and selector `0x2582edb4`.
+    ```solidity
+    function ensureTradePreconditions(address trader, address settlementContract, address sellToken, uint256 sellAmount, address nativeToken, address spardose) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ensureTradePreconditionsCall {
+        #[allow(missing_docs)]
+        pub trader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub settlementContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nativeToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spardose: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`ensureTradePreconditions(address,address,address,uint256,address,
+    /// address)`](ensureTradePreconditionsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ensureTradePreconditionsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ensureTradePreconditionsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ensureTradePreconditionsCall) -> Self {
+                    (
+                        value.trader,
+                        value.settlementContract,
+                        value.sellToken,
+                        value.sellAmount,
+                        value.nativeToken,
+                        value.spardose,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ensureTradePreconditionsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        trader: tuple.0,
+                        settlementContract: tuple.1,
+                        sellToken: tuple.2,
+                        sellAmount: tuple.3,
+                        nativeToken: tuple.4,
+                        spardose: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ensureTradePreconditionsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ensureTradePreconditionsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ensureTradePreconditionsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl ensureTradePreconditionsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ensureTradePreconditionsCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = ensureTradePreconditionsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [37u8, 130u8, 237u8, 180u8];
+            const SIGNATURE: &'static str =
+                "ensureTradePreconditions(address,address,address,uint256,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.trader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlementContract,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.nativeToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spardose,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                ensureTradePreconditionsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `storeBalance(address,address,bool)` and selector `0x3bbb2e1d`.
+    ```solidity
+    function storeBalance(address token, address owner, bool countGas) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct storeBalanceCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub countGas: bool,
+    }
+    ///Container type for the return parameters of the
+    /// [`storeBalance(address,address,bool)`](storeBalanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct storeBalanceReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<storeBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: storeBalanceCall) -> Self {
+                    (value.token, value.owner, value.countGas)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for storeBalanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        owner: tuple.1,
+                        countGas: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<storeBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: storeBalanceReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for storeBalanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl storeBalanceReturn {
+            fn _tokenize(&self) -> <storeBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for storeBalanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = storeBalanceReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [59u8, 187u8, 46u8, 29u8];
+            const SIGNATURE: &'static str = "storeBalance(address,address,bool)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.countGas,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                storeBalanceReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swap(address,address[],address,bytes)` and selector `0x1d47e7f4`.
+    ```solidity
+    function swap(address settlementContract, address[] memory tokens, address receiver, bytes memory settlementCall) external returns (uint256 gasUsed, uint256[] memory queriedBalances);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub settlementContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub receiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub settlementCall: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swap(address,address[],address,bytes)`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {
+        #[allow(missing_docs)]
+        pub gasUsed: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub queriedBalances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (
+                        value.settlementContract,
+                        value.tokens,
+                        value.receiver,
+                        value.settlementCall,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        settlementContract: tuple.0,
+                        tokens: tuple.1,
+                        receiver: tuple.2,
+                        settlementCall: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    (value.gasUsed, value.queriedBalances)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        gasUsed: tuple.0,
+                        queriedBalances: tuple.1,
+                    }
+                }
+            }
+        }
+        impl swapReturn {
+            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.gasUsed),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.queriedBalances),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [29u8, 71u8, 231u8, 244u8];
+            const SIGNATURE: &'static str = "swap(address,address[],address,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlementContract,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.receiver,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.settlementCall,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`Solver`](self) function calls.
+    #[derive(Clone)]
+    pub enum SolverCalls {
+        #[allow(missing_docs)]
+        ensureTradePreconditions(ensureTradePreconditionsCall),
+        #[allow(missing_docs)]
+        storeBalance(storeBalanceCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+    }
+    impl SolverCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [29u8, 71u8, 231u8, 244u8],
+            [37u8, 130u8, 237u8, 180u8],
+            [59u8, 187u8, 46u8, 29u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <storeBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(swap),
+            ::core::stringify!(ensureTradePreconditions),
+            ::core::stringify!(storeBalance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SolverCalls {
+        const COUNT: usize = 3usize;
+        const MIN_DATA_LENGTH: usize = 96usize;
+        const NAME: &'static str = "SolverCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::ensureTradePreconditions(_) => {
+                    <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::storeBalance(_) => <storeBalanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SolverCalls>] = &[
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<SolverCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SolverCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn ensureTradePreconditions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SolverCalls> {
+                        <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SolverCalls::ensureTradePreconditions)
+                    }
+                    ensureTradePreconditions
+                },
+                {
+                    fn storeBalance(data: &[u8]) -> alloy_sol_types::Result<SolverCalls> {
+                        <storeBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SolverCalls::storeBalance)
+                    }
+                    storeBalance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SolverCalls>] = &[
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<SolverCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SolverCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn ensureTradePreconditions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SolverCalls> {
+                        <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SolverCalls::ensureTradePreconditions)
+                    }
+                    ensureTradePreconditions
+                },
+                {
+                    fn storeBalance(data: &[u8]) -> alloy_sol_types::Result<SolverCalls> {
+                        <storeBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SolverCalls::storeBalance)
+                    }
+                    storeBalance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::ensureTradePreconditions(inner) => {
+                    <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::storeBalance(inner) => {
+                    <storeBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::ensureTradePreconditions(inner) => {
+                    <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::storeBalance(inner) => {
+                    <storeBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Solver`](self) contract instance.
+
+    See the [wrapper's documentation](`SolverInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SolverInstance<P, N> {
+        SolverInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<SolverInstance<P, N>>> {
+        SolverInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        SolverInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Solver`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Solver`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SolverInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SolverInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SolverInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SolverInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Solver`](self) contract instance.
+
+        See the [wrapper's documentation](`SolverInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<SolverInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SolverInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SolverInstance<P, N> {
+            SolverInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SolverInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`ensureTradePreconditions`]
+        /// function.
+        pub fn ensureTradePreconditions(
+            &self,
+            trader: alloy_sol_types::private::Address,
+            settlementContract: alloy_sol_types::private::Address,
+            sellToken: alloy_sol_types::private::Address,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            nativeToken: alloy_sol_types::private::Address,
+            spardose: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, ensureTradePreconditionsCall, N> {
+            self.call_builder(&ensureTradePreconditionsCall {
+                trader,
+                settlementContract,
+                sellToken,
+                sellAmount,
+                nativeToken,
+                spardose,
+            })
+        }
+
+        ///Creates a new call builder for the [`storeBalance`] function.
+        pub fn storeBalance(
+            &self,
+            token: alloy_sol_types::private::Address,
+            owner: alloy_sol_types::private::Address,
+            countGas: bool,
+        ) -> alloy_contract::SolCallBuilder<&P, storeBalanceCall, N> {
+            self.call_builder(&storeBalanceCall {
+                token,
+                owner,
+                countGas,
+            })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            settlementContract: alloy_sol_types::private::Address,
+            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            receiver: alloy_sol_types::private::Address,
+            settlementCall: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                settlementContract,
+                tokens,
+                receiver,
+                settlementCall,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SolverInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Solver::SolverInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/spardose/Cargo.toml b/contracts/generated/contracts-generated/spardose/Cargo.toml
new file mode 100644
index 0000000000..4082b38f9f
--- /dev/null
+++ b/contracts/generated/contracts-generated/spardose/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-spardose"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/spardose/src/lib.rs b/contracts/generated/contracts-generated/spardose/src/lib.rs
new file mode 100644
index 0000000000..70b893969a
--- /dev/null
+++ b/contracts/generated/contracts-generated/spardose/src/lib.rs
@@ -0,0 +1,534 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Spardose {
+    function requestFunds(address token, uint256 amount) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "requestFunds",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Spardose {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x6080604052348015600e575f5ffd5b506102ca8061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063494666b61461002d575b5f5ffd5b61004061003b366004610230565b610042565b005b61006373ffffffffffffffffffffffffffffffffffffffff83163383610067565b5050565b6040805173ffffffffffffffffffffffffffffffffffffffff848116602483015260448083018590528351808403909101815260649092019092526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052905f906100f990861683610175565b905061010481610189565b61016e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f5361666545524332303a207472616e73666572206661696c6564000000000000604482015260640160405180910390fd5b5050505050565b6060610182835f846101ae565b9392505050565b5f81515f14806101a85750818060200190518101906101a89190610272565b92915050565b60605f8473ffffffffffffffffffffffffffffffffffffffff1684846040516101d79190610291565b5f6040518083038185875af1925050503d805f8114610211576040519150601f19603f3d011682016040523d82523d5f602084013e610216565b606091505b50925090508061022857815160208301fd5b509392505050565b5f5f60408385031215610241575f5ffd5b823573ffffffffffffffffffffffffffffffffffffffff81168114610264575f5ffd5b946020939093013593505050565b5f60208284031215610282575f5ffd5b81518015158114610182575f5ffd5b5f82515f5b818110156102b05760208186018101518583015201610296565b505f92019182525091905056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x02\xCA\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80cIFf\xB6\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x020V[a\0BV[\0[a\0cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x163\x83a\0gV[PPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x90\x92R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90_\x90a\0\xF9\x90\x86\x16\x83a\x01uV[\x90Pa\x01\x04\x81a\x01\x89V[a\x01nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FSafeERC20: transfer failed\0\0\0\0\0\0`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[PPPPPV[``a\x01\x82\x83_\x84a\x01\xAEV[\x93\x92PPPV[_\x81Q_\x14\x80a\x01\xA8WP\x81\x80` \x01\x90Q\x81\x01\x90a\x01\xA8\x91\x90a\x02rV[\x92\x91PPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\x01\xD7\x91\x90a\x02\x91V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x02\x11W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x02\x16V[``\x91P[P\x92P\x90P\x80a\x02(W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x02AW__\xFD[\x825s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02dW__\xFD[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15a\x02\x82W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01\x82W__\xFD[_\x82Q_[\x81\x81\x10\x15a\x02\xB0W` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\x02\x96V[P_\x92\x01\x91\x82RP\x91\x90PV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063494666b61461002d575b5f5ffd5b61004061003b366004610230565b610042565b005b61006373ffffffffffffffffffffffffffffffffffffffff83163383610067565b5050565b6040805173ffffffffffffffffffffffffffffffffffffffff848116602483015260448083018590528351808403909101815260649092019092526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052905f906100f990861683610175565b905061010481610189565b61016e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f5361666545524332303a207472616e73666572206661696c6564000000000000604482015260640160405180910390fd5b5050505050565b6060610182835f846101ae565b9392505050565b5f81515f14806101a85750818060200190518101906101a89190610272565b92915050565b60605f8473ffffffffffffffffffffffffffffffffffffffff1684846040516101d79190610291565b5f6040518083038185875af1925050503d805f8114610211576040519150601f19603f3d011682016040523d82523d5f602084013e610216565b606091505b50925090508061022857815160208301fd5b509392505050565b5f5f60408385031215610241575f5ffd5b823573ffffffffffffffffffffffffffffffffffffffff81168114610264575f5ffd5b946020939093013593505050565b5f60208284031215610282575f5ffd5b81518015158114610182575f5ffd5b5f82515f5b818110156102b05760208186018101518583015201610296565b505f92019182525091905056fea164736f6c634300081e000a
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80cIFf\xB6\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x020V[a\0BV[\0[a\0cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x163\x83a\0gV[PPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x90\x92R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90_\x90a\0\xF9\x90\x86\x16\x83a\x01uV[\x90Pa\x01\x04\x81a\x01\x89V[a\x01nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FSafeERC20: transfer failed\0\0\0\0\0\0`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[PPPPPV[``a\x01\x82\x83_\x84a\x01\xAEV[\x93\x92PPPV[_\x81Q_\x14\x80a\x01\xA8WP\x81\x80` \x01\x90Q\x81\x01\x90a\x01\xA8\x91\x90a\x02rV[\x92\x91PPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\x01\xD7\x91\x90a\x02\x91V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x02\x11W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x02\x16V[``\x91P[P\x92P\x90P\x80a\x02(W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x02AW__\xFD[\x825s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x02dW__\xFD[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15a\x02\x82W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01\x82W__\xFD[_\x82Q_[\x81\x81\x10\x15a\x02\xB0W` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\x02\x96V[P_\x92\x01\x91\x82RP\x91\x90PV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `requestFunds(address,uint256)` and selector `0x494666b6`.
+    ```solidity
+    function requestFunds(address token, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct requestFundsCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`requestFunds(address,uint256)`](requestFundsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct requestFundsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<requestFundsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: requestFundsCall) -> Self {
+                    (value.token, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requestFundsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<requestFundsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: requestFundsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requestFundsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl requestFundsReturn {
+            fn _tokenize(&self) -> <requestFundsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for requestFundsCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = requestFundsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [73u8, 70u8, 102u8, 182u8];
+            const SIGNATURE: &'static str = "requestFunds(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                requestFundsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`Spardose`](self) function calls.
+    #[derive(Clone)]
+    pub enum SpardoseCalls {
+        #[allow(missing_docs)]
+        requestFunds(requestFundsCall),
+    }
+    impl SpardoseCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[73u8, 70u8, 102u8, 182u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<requestFundsCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(requestFunds)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SpardoseCalls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 64usize;
+        const NAME: &'static str = "SpardoseCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::requestFunds(_) => <requestFundsCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SpardoseCalls>] = &[{
+                fn requestFunds(data: &[u8]) -> alloy_sol_types::Result<SpardoseCalls> {
+                    <requestFundsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(SpardoseCalls::requestFunds)
+                }
+                requestFunds
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SpardoseCalls>] =
+                &[{
+                    fn requestFunds(data: &[u8]) -> alloy_sol_types::Result<SpardoseCalls> {
+                        <requestFundsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SpardoseCalls::requestFunds)
+                    }
+                    requestFunds
+                }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::requestFunds(inner) => {
+                    <requestFundsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::requestFunds(inner) => {
+                    <requestFundsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Spardose`](self) contract instance.
+
+    See the [wrapper's documentation](`SpardoseInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SpardoseInstance<P, N> {
+        SpardoseInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<SpardoseInstance<P, N>>> {
+        SpardoseInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        SpardoseInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Spardose`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Spardose`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SpardoseInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SpardoseInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SpardoseInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SpardoseInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Spardose`](self) contract instance.
+
+        See the [wrapper's documentation](`SpardoseInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<SpardoseInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SpardoseInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SpardoseInstance<P, N> {
+            SpardoseInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SpardoseInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`requestFunds`] function.
+        pub fn requestFunds(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, requestFundsCall, N> {
+            self.call_builder(&requestFundsCall { token, amount })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SpardoseInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Spardose::SpardoseInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/sushiswaprouter/Cargo.toml b/contracts/generated/contracts-generated/sushiswaprouter/Cargo.toml
new file mode 100644
index 0000000000..4e099e1e1d
--- /dev/null
+++ b/contracts/generated/contracts-generated/sushiswaprouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-sushiswaprouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs b/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs
new file mode 100644
index 0000000000..c62b7b87f0
--- /dev/null
+++ b/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs
@@ -0,0 +1,7573 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface SushiSwapRouter {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod SushiSwapRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`SushiSwapRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum SushiSwapRouterCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl SushiSwapRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SushiSwapRouterCalls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "SushiSwapRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SushiSwapRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<SushiSwapRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SushiSwapRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SushiSwapRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SushiSwapRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SushiSwapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SushiSwapRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SushiSwapRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SushiSwapRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`SushiSwapRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`SushiSwapRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SushiSwapRouterInstance<P, N> {
+        SushiSwapRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`SushiSwapRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`SushiSwapRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SushiSwapRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SushiSwapRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SushiSwapRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SushiSwapRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`SushiSwapRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`SushiSwapRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SushiSwapRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SushiSwapRouterInstance<P, N> {
+            SushiSwapRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SushiSwapRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SushiSwapRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = SushiSwapRouter::SushiSwapRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x2abf469074dc0b54d793850807e6eb5faf2625b1"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x1b02da8cb0d097eb8d57a175b88c7d8b47997506"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x1b02da8cb0d097eb8d57a175b88c7d8b47997506"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x1b02da8cb0d097eb8d57a175b88c7d8b47997506"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x6bded42c6da8fbf0d2ba55b2fa120c5e0c8d7891"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x1b02da8cb0d097eb8d57a175b88c7d8b47997506"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x1b02da8cb0d097eb8d57a175b88c7d8b47997506"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/swapper/Cargo.toml b/contracts/generated/contracts-generated/swapper/Cargo.toml
new file mode 100644
index 0000000000..d5555196aa
--- /dev/null
+++ b/contracts/generated/contracts-generated/swapper/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-swapper"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/swapper/src/lib.rs b/contracts/generated/contracts-generated/swapper/src/lib.rs
new file mode 100644
index 0000000000..570e7ff6e7
--- /dev/null
+++ b/contracts/generated/contracts-generated/swapper/src/lib.rs
@@ -0,0 +1,1553 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Swapper {
+    struct Allowance {
+        address spender;
+        uint256 amount;
+    }
+    struct Asset {
+        address token;
+        uint256 amount;
+    }
+    struct Interaction {
+        address target;
+        uint256 value;
+        bytes callData;
+    }
+
+    function isValidSignature(bytes32, bytes memory) external pure returns (bytes4);
+    function swap(address settlement, Asset memory sell, Asset memory buy, Allowance memory allowance, Interaction[] memory calls) external returns (uint256 gasUsed);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "settlement",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      },
+      {
+        "name": "sell",
+        "type": "tuple",
+        "internalType": "struct Asset",
+        "components": [
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "buy",
+        "type": "tuple",
+        "internalType": "struct Asset",
+        "components": [
+          {
+            "name": "token",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "allowance",
+        "type": "tuple",
+        "internalType": "struct Allowance",
+        "components": [
+          {
+            "name": "spender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "internalType": "struct Interaction[]",
+        "components": [
+          {
+            "name": "target",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "value",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "callData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "gasUsed",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Swapper {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x11\xEA\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80c\x16&\xBA~\x14a\08W\x80c\xE83>\r\x14a\0\xA4W[__\xFD[a\0na\0F6`\x04a\ncV[\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x92PPPV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xB7a\0\xB26`\x04a\x0B\x14V[a\0\xC5V[`@Q\x90\x81R` \x01a\0\x9BV[_` \x86\x01\x805\x90a\0\xD7\x90\x88a\x0B\xCCV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01e\x91\x90a\x0B\xE7V[\x10\x15a\x01rWP_a\x08.V[a\x02\r\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xBEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xE2\x91\x90a\x0B\xFEV[_a\x01\xF0` \x8A\x01\x8Aa\x0B\xCCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x90a\x088V[a\x02\x8E\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02YW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02}\x91\x90a\x0B\xFEV[` \x88\x01\x805\x90a\x01\xF0\x90\x8Aa\x0B\xCCV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R_\x92` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa\x02\xBB` \x88\x01\x88a\x0B\xCCV[\x81_\x81Q\x81\x10a\x02\xCDWa\x02\xCDa\x0CFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01Ra\x02\xFD\x90\x87\x01\x87a\x0B\xCCV[\x81`\x01\x81Q\x81\x10a\x03\x10Wa\x03\x10a\x0CFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01R`@\x80Q`\x02\x80\x82R``\x82\x01\x83R_\x93\x91\x92\x90\x91\x83\x01\x90\x806\x837\x01\x90PP\x90P\x86` \x015\x81_\x81Q\x81\x10a\x03nWa\x03na\x0CFV[` \x02` \x01\x01\x81\x81RPP\x87` \x015\x81`\x01\x81Q\x81\x10a\x03\x92Wa\x03\x92a\x0CFV[` \x90\x81\x02\x91\x90\x91\x01\x01R`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91\x81` \x01[a\x04\"`@Q\x80a\x01`\x01`@R\x80_\x81R` \x01_\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01_\x81R` \x01_c\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01``\x81RP\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x03\xB3W\x90PP\x90P`@Q\x80a\x01`\x01`@R\x80_\x81R` \x01`\x01\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A` \x015\x81R` \x01\x89` \x015\x81R` \x01c\xFF\xFF\xFF\xFF\x80\x16\x81R` \x01__\x1B\x81R` \x01_\x81R` \x01`@\x81R` \x01_\x81R` \x010`@Q` \x01a\x04\xE3\x91\x90``\x91\x90\x91\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81R`\x14\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x81RP\x81_\x81Q\x81\x10a\x05\x07Wa\x05\x07a\x0CFV[` \x02` \x01\x01\x81\x90RPa\x05\x1Aa\n<V[` \x80\x89\x015\x90a\x05-\x90\x8C\x01\x8Ca\x0B\xCCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xDDb\xED>\x8Da\x05V` \x8D\x01\x8Da\x0B\xCCV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16`\x04\x82\x01R\x91\x16`$\x82\x01R`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xE8\x91\x90a\x0B\xE7V[\x10\x15a\x07bW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x90\x81` \x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\x03WPP\x81Ra\x06?` \x8B\x01\x8Ba\x0B\xCCV[\x81Q\x80Q_\x90a\x06QWa\x06Qa\x0CFV[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x90\x91Ra\x06\x84\x90\x8B\x01\x8Ba\x0B\xCCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t^\xA7\xB3a\x06\xAC` \x8B\x01\x8Ba\x0B\xCCV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16`$\x82\x01R` \x8B\x015`D\x82\x01R`d\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xE0\x93\x90\x93\x1B\x92\x90\x92\x17\x90\x91R\x90P\x81_` \x02\x01Q_\x81Q\x81\x10a\x07RWa\x07Ra\x0CFV[` \x02` \x01\x01Q`@\x01\x81\x90RP[a\x07l\x86\x88a\x0C\xEBV[` \x82\x01R`@Qa\x08'\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x16\x90c\x13\xD7\x9A\x0B\x90a\x07\xAA\x90\x88\x90\x88\x90\x88\x90\x88\x90`$\x01a\x10\xA8V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xE0\x93\x90\x93\x1B\x92\x90\x92\x17\x90\x91Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x16\x91Pa\tFV[\x94PPPPP[\x96\x95PPPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x90\x92R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\t^\xA7\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90_\x90a\x08\xCA\x90\x86\x16\x83a\tYV[\x90Pa\x08\xD5\x81a\tfV[a\t?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FSafeERC20: approval failed\0\0\0\0\0\0`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[PPPPPV[_a\tR\x83_\x84a\t\x8BV[\x93\x92PPPV[``a\tR\x83_\x84a\t\xBAV[_\x81Q_\x14\x80a\t\x85WP\x81\x80` \x01\x90Q\x81\x01\x90a\t\x85\x91\x90a\x11kV[\x92\x91PPV[_Z\x90P__\x83Q` \x85\x01\x86\x88Z\xF1a\t\xA7W=__>=_\xFD[Za\t\xB2\x90\x82a\x11\x8AV[\x94\x93PPPPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\t\xE3\x91\x90a\x11\xC2V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\n\x1DW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\n\"V[``\x91P[P\x92P\x90P\x80a\n4W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[`@Q\x80``\x01`@R\x80`\x03\x90[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\nKW\x90PP\x90V[___`@\x84\x86\x03\x12\x15a\nuW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x92W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\n\xA2W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB8W__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\n\xC9W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\n\xFBW__\xFD[PV[_`@\x82\x84\x03\x12\x15a\x0B\x0EW__\xFD[P\x91\x90PV[______a\x01\0\x87\x89\x03\x12\x15a\x0B*W__\xFD[\x865a\x0B5\x81a\n\xDAV[\x95Pa\x0BD\x88` \x89\x01a\n\xFEV[\x94Pa\x0BS\x88``\x89\x01a\n\xFEV[\x93Pa\x0Bb\x88`\xA0\x89\x01a\n\xFEV[\x92P`\xE0\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B}W__\xFD[\x87\x01`\x1F\x81\x01\x89\x13a\x0B\x8DW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xA3W__\xFD[\x89` \x82`\x05\x1B\x84\x01\x01\x11\x15a\x0B\xB7W__\xFD[` \x82\x01\x93P\x80\x92PPP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a\x0B\xDCW__\xFD[\x815a\tR\x81a\n\xDAV[_` \x82\x84\x03\x12\x15a\x0B\xF7W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\x0EW__\xFD[\x81Qa\tR\x81a\n\xDAV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\x96Wa\x0C\x96a\x0C\x19V[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xE3Wa\x0C\xE3a\x0C\x19V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x15a\r\x04Wa\r\x04a\x0C\x19V[\x82`\x05\x1Ba\r\x14` \x82\x01a\x0C\x9CV[\x84\x81R\x90\x83\x01\x90` \x81\x01\x906\x83\x11\x15a\r,W__\xFD[\x84[\x83\x81\x10\x15a\x0E8W\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\rLW__\xFD[\x86\x01``6\x82\x90\x03\x12\x15a\r^W__\xFD[a\rfa\x0CsV[\x815a\rq\x81a\n\xDAV[\x81R` \x82\x81\x015\x90\x82\x01R`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x96W__\xFD[\x91\x90\x91\x01\x906`\x1F\x83\x01\x12a\r\xA9W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xC3Wa\r\xC3a\x0C\x19V[a\r\xF4` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x0C\x9CV[\x81\x81R6` \x83\x86\x01\x01\x11\x15a\x0E\x08W__\xFD[\x81` \x85\x01` \x83\x017_` \x83\x83\x01\x01R\x80`@\x84\x01RPP\x80\x85RPP` \x83\x01\x92P` \x81\x01\x90Pa\r.V[P\x95\x94PPPPPV[_[\x83\x81\x10\x15a\x0E\\W\x81\x81\x01Q\x83\x82\x01R` \x01a\x0EDV[PP_\x91\x01RV[_\x81Q\x80\x84Ra\x0E{\x81` \x86\x01` \x86\x01a\x0EBV[`\x1F\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x92\x90\x92\x01` \x01\x92\x91PPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x0F\xBEW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x85\x84\x03\x01\x88R\x81Q\x80Q\x84R` \x81\x01Q` \x85\x01R`@\x81\x01Qa\x0F/`@\x86\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x85\x01R`\x80\x81\x01Q`\x80\x85\x01R`\xA0\x81\x01Qa\x0F[`\xA0\x86\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x85\x01R`\xE0\x81\x01Q`\xE0\x85\x01Ra\x01\0\x81\x01Qa\x01\0\x85\x01Ra\x01 \x81\x01Qa\x01 \x85\x01Ra\x01@\x81\x01Q\x90Pa\x01`a\x01@\x85\x01Ra\x0F\xA7a\x01`\x85\x01\x82a\x0EdV[` \x99\x8A\x01\x99\x90\x94P\x92\x90\x92\x01\x91P`\x01\x01a\x0E\xC9V[P\x90\x96\x95PPPPPPV[_\x82``\x81\x01\x83_[`\x03\x81\x10\x15a\x10\x9DW\x83\x83\x03\x87R\x81Q\x80Q\x80\x85R` \x91\x82\x01\x91\x80\x86\x01\x91\x90`\x05\x82\x90\x1B\x87\x01\x01_[\x82\x81\x10\x15a\x10\x83W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x88\x83\x03\x01\x84R\x84Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x83R` \x81\x01Q` \x84\x01R`@\x81\x01Q\x90P```@\x84\x01Ra\x10m``\x84\x01\x82a\x0EdV[` \x96\x87\x01\x96\x95\x90\x95\x01\x94\x92PP`\x01\x01a\x0F\xFDV[P` \x9A\x8B\x01\x9A\x90\x96P\x94\x90\x94\x01\x93PPP`\x01\x01a\x0F\xD3V[P\x90\x95\x94PPPPPV[`\x80\x80\x82R\x85Q\x90\x82\x01\x81\x90R_\x90` \x87\x01\x90`\xA0\x84\x01\x90\x83[\x81\x81\x10\x15a\x10\xF7W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x10\xC3V[PP\x83\x81\x03` \x85\x01R\x80\x91P_\x87Q\x80\x83R` \x83\x01\x93P` \x89\x01\x92P_[\x81\x81\x10\x15a\x116W\x83Q\x85R` \x94\x85\x01\x94\x90\x93\x01\x92`\x01\x01a\x11\x18V[PPPP\x82\x81\x03`@\x84\x01Ra\x11L\x81\x86a\x0E\xADV[\x90P\x82\x81\x03``\x84\x01Ra\x11`\x81\x85a\x0F\xCAV[\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a\x11{W__\xFD[\x81Q\x80\x15\x15\x81\x14a\tRW__\xFD[\x81\x81\x03\x81\x81\x11\x15a\t\x85W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[_\x82Qa\x11\xD3\x81\x84` \x87\x01a\x0EBV[\x91\x90\x91\x01\x92\x91PPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80c\x16&\xBA~\x14a\08W\x80c\xE83>\r\x14a\0\xA4W[__\xFD[a\0na\0F6`\x04a\ncV[\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x92PPPV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xB7a\0\xB26`\x04a\x0B\x14V[a\0\xC5V[`@Q\x90\x81R` \x01a\0\x9BV[_` \x86\x01\x805\x90a\0\xD7\x90\x88a\x0B\xCCV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01e\x91\x90a\x0B\xE7V[\x10\x15a\x01rWP_a\x08.V[a\x02\r\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xBEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xE2\x91\x90a\x0B\xFEV[_a\x01\xF0` \x8A\x01\x8Aa\x0B\xCCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x90a\x088V[a\x02\x8E\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02YW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02}\x91\x90a\x0B\xFEV[` \x88\x01\x805\x90a\x01\xF0\x90\x8Aa\x0B\xCCV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R_\x92` \x83\x01\x90\x806\x837\x01\x90PP\x90Pa\x02\xBB` \x88\x01\x88a\x0B\xCCV[\x81_\x81Q\x81\x10a\x02\xCDWa\x02\xCDa\x0CFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01Ra\x02\xFD\x90\x87\x01\x87a\x0B\xCCV[\x81`\x01\x81Q\x81\x10a\x03\x10Wa\x03\x10a\x0CFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01R`@\x80Q`\x02\x80\x82R``\x82\x01\x83R_\x93\x91\x92\x90\x91\x83\x01\x90\x806\x837\x01\x90PP\x90P\x86` \x015\x81_\x81Q\x81\x10a\x03nWa\x03na\x0CFV[` \x02` \x01\x01\x81\x81RPP\x87` \x015\x81`\x01\x81Q\x81\x10a\x03\x92Wa\x03\x92a\x0CFV[` \x90\x81\x02\x91\x90\x91\x01\x01R`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91\x81` \x01[a\x04\"`@Q\x80a\x01`\x01`@R\x80_\x81R` \x01_\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01_\x81R` \x01_c\xFF\xFF\xFF\xFF\x16\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01``\x81RP\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x03\xB3W\x90PP\x90P`@Q\x80a\x01`\x01`@R\x80_\x81R` \x01`\x01\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A` \x015\x81R` \x01\x89` \x015\x81R` \x01c\xFF\xFF\xFF\xFF\x80\x16\x81R` \x01__\x1B\x81R` \x01_\x81R` \x01`@\x81R` \x01_\x81R` \x010`@Q` \x01a\x04\xE3\x91\x90``\x91\x90\x91\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81R`\x14\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x81RP\x81_\x81Q\x81\x10a\x05\x07Wa\x05\x07a\x0CFV[` \x02` \x01\x01\x81\x90RPa\x05\x1Aa\n<V[` \x80\x89\x015\x90a\x05-\x90\x8C\x01\x8Ca\x0B\xCCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xDDb\xED>\x8Da\x05V` \x8D\x01\x8Da\x0B\xCCV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16`\x04\x82\x01R\x91\x16`$\x82\x01R`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xE8\x91\x90a\x0B\xE7V[\x10\x15a\x07bW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x90\x81` \x01[`@\x80Q``\x80\x82\x01\x83R_\x80\x83R` \x83\x01R\x91\x81\x01\x91\x90\x91R\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\x03WPP\x81Ra\x06?` \x8B\x01\x8Ba\x0B\xCCV[\x81Q\x80Q_\x90a\x06QWa\x06Qa\x0CFV[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x90\x91Ra\x06\x84\x90\x8B\x01\x8Ba\x0B\xCCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t^\xA7\xB3a\x06\xAC` \x8B\x01\x8Ba\x0B\xCCV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16`$\x82\x01R` \x8B\x015`D\x82\x01R`d\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xE0\x93\x90\x93\x1B\x92\x90\x92\x17\x90\x91R\x90P\x81_` \x02\x01Q_\x81Q\x81\x10a\x07RWa\x07Ra\x0CFV[` \x02` \x01\x01Q`@\x01\x81\x90RP[a\x07l\x86\x88a\x0C\xEBV[` \x82\x01R`@Qa\x08'\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x16\x90c\x13\xD7\x9A\x0B\x90a\x07\xAA\x90\x88\x90\x88\x90\x88\x90\x88\x90`$\x01a\x10\xA8V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xE0\x93\x90\x93\x1B\x92\x90\x92\x17\x90\x91Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x16\x91Pa\tFV[\x94PPPPP[\x96\x95PPPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x90\x92R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\t^\xA7\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90_\x90a\x08\xCA\x90\x86\x16\x83a\tYV[\x90Pa\x08\xD5\x81a\tfV[a\t?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FSafeERC20: approval failed\0\0\0\0\0\0`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[PPPPPV[_a\tR\x83_\x84a\t\x8BV[\x93\x92PPPV[``a\tR\x83_\x84a\t\xBAV[_\x81Q_\x14\x80a\t\x85WP\x81\x80` \x01\x90Q\x81\x01\x90a\t\x85\x91\x90a\x11kV[\x92\x91PPV[_Z\x90P__\x83Q` \x85\x01\x86\x88Z\xF1a\t\xA7W=__>=_\xFD[Za\t\xB2\x90\x82a\x11\x8AV[\x94\x93PPPPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\t\xE3\x91\x90a\x11\xC2V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\n\x1DW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\n\"V[``\x91P[P\x92P\x90P\x80a\n4W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[`@Q\x80``\x01`@R\x80`\x03\x90[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\nKW\x90PP\x90V[___`@\x84\x86\x03\x12\x15a\nuW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x92W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\n\xA2W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB8W__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\n\xC9W__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\n\xFBW__\xFD[PV[_`@\x82\x84\x03\x12\x15a\x0B\x0EW__\xFD[P\x91\x90PV[______a\x01\0\x87\x89\x03\x12\x15a\x0B*W__\xFD[\x865a\x0B5\x81a\n\xDAV[\x95Pa\x0BD\x88` \x89\x01a\n\xFEV[\x94Pa\x0BS\x88``\x89\x01a\n\xFEV[\x93Pa\x0Bb\x88`\xA0\x89\x01a\n\xFEV[\x92P`\xE0\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B}W__\xFD[\x87\x01`\x1F\x81\x01\x89\x13a\x0B\x8DW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xA3W__\xFD[\x89` \x82`\x05\x1B\x84\x01\x01\x11\x15a\x0B\xB7W__\xFD[` \x82\x01\x93P\x80\x92PPP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a\x0B\xDCW__\xFD[\x815a\tR\x81a\n\xDAV[_` \x82\x84\x03\x12\x15a\x0B\xF7W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\x0EW__\xFD[\x81Qa\tR\x81a\n\xDAV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\x96Wa\x0C\x96a\x0C\x19V[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xE3Wa\x0C\xE3a\x0C\x19V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x15a\r\x04Wa\r\x04a\x0C\x19V[\x82`\x05\x1Ba\r\x14` \x82\x01a\x0C\x9CV[\x84\x81R\x90\x83\x01\x90` \x81\x01\x906\x83\x11\x15a\r,W__\xFD[\x84[\x83\x81\x10\x15a\x0E8W\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\rLW__\xFD[\x86\x01``6\x82\x90\x03\x12\x15a\r^W__\xFD[a\rfa\x0CsV[\x815a\rq\x81a\n\xDAV[\x81R` \x82\x81\x015\x90\x82\x01R`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x96W__\xFD[\x91\x90\x91\x01\x906`\x1F\x83\x01\x12a\r\xA9W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xC3Wa\r\xC3a\x0C\x19V[a\r\xF4` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x0C\x9CV[\x81\x81R6` \x83\x86\x01\x01\x11\x15a\x0E\x08W__\xFD[\x81` \x85\x01` \x83\x017_` \x83\x83\x01\x01R\x80`@\x84\x01RPP\x80\x85RPP` \x83\x01\x92P` \x81\x01\x90Pa\r.V[P\x95\x94PPPPPV[_[\x83\x81\x10\x15a\x0E\\W\x81\x81\x01Q\x83\x82\x01R` \x01a\x0EDV[PP_\x91\x01RV[_\x81Q\x80\x84Ra\x0E{\x81` \x86\x01` \x86\x01a\x0EBV[`\x1F\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x92\x90\x92\x01` \x01\x92\x91PPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x0F\xBEW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x85\x84\x03\x01\x88R\x81Q\x80Q\x84R` \x81\x01Q` \x85\x01R`@\x81\x01Qa\x0F/`@\x86\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x85\x01R`\x80\x81\x01Q`\x80\x85\x01R`\xA0\x81\x01Qa\x0F[`\xA0\x86\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x85\x01R`\xE0\x81\x01Q`\xE0\x85\x01Ra\x01\0\x81\x01Qa\x01\0\x85\x01Ra\x01 \x81\x01Qa\x01 \x85\x01Ra\x01@\x81\x01Q\x90Pa\x01`a\x01@\x85\x01Ra\x0F\xA7a\x01`\x85\x01\x82a\x0EdV[` \x99\x8A\x01\x99\x90\x94P\x92\x90\x92\x01\x91P`\x01\x01a\x0E\xC9V[P\x90\x96\x95PPPPPPV[_\x82``\x81\x01\x83_[`\x03\x81\x10\x15a\x10\x9DW\x83\x83\x03\x87R\x81Q\x80Q\x80\x85R` \x91\x82\x01\x91\x80\x86\x01\x91\x90`\x05\x82\x90\x1B\x87\x01\x01_[\x82\x81\x10\x15a\x10\x83W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x88\x83\x03\x01\x84R\x84Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x83R` \x81\x01Q` \x84\x01R`@\x81\x01Q\x90P```@\x84\x01Ra\x10m``\x84\x01\x82a\x0EdV[` \x96\x87\x01\x96\x95\x90\x95\x01\x94\x92PP`\x01\x01a\x0F\xFDV[P` \x9A\x8B\x01\x9A\x90\x96P\x94\x90\x94\x01\x93PPP`\x01\x01a\x0F\xD3V[P\x90\x95\x94PPPPPV[`\x80\x80\x82R\x85Q\x90\x82\x01\x81\x90R_\x90` \x87\x01\x90`\xA0\x84\x01\x90\x83[\x81\x81\x10\x15a\x10\xF7W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x10\xC3V[PP\x83\x81\x03` \x85\x01R\x80\x91P_\x87Q\x80\x83R` \x83\x01\x93P` \x89\x01\x92P_[\x81\x81\x10\x15a\x116W\x83Q\x85R` \x94\x85\x01\x94\x90\x93\x01\x92`\x01\x01a\x11\x18V[PPPP\x82\x81\x03`@\x84\x01Ra\x11L\x81\x86a\x0E\xADV[\x90P\x82\x81\x03``\x84\x01Ra\x11`\x81\x85a\x0F\xCAV[\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a\x11{W__\xFD[\x81Q\x80\x15\x15\x81\x14a\tRW__\xFD[\x81\x81\x03\x81\x81\x11\x15a\t\x85W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[_\x82Qa\x11\xD3\x81\x84` \x87\x01a\x0EBV[\x91\x90\x91\x01\x92\x91PPV\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Allowance { address spender; uint256 amount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Allowance {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Allowance> for UnderlyingRustTuple<'_> {
+            fn from(value: Allowance) -> Self {
+                (value.spender, value.amount)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Allowance {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    spender: tuple.0,
+                    amount: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Allowance {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Allowance {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Allowance {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Allowance {
+            const NAME: &'static str = "Allowance";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed("Allowance(address spender,uint256 amount)")
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.spender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Allowance {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.spender,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.spender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Asset { address token; uint256 amount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Asset {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Asset> for UnderlyingRustTuple<'_> {
+            fn from(value: Asset) -> Self {
+                (value.token, value.amount)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Asset {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    token: tuple.0,
+                    amount: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Asset {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Asset {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Asset {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Asset {
+            const NAME: &'static str = "Asset";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed("Asset(address token,uint256 amount)")
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.token,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Asset {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.token,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.token,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Interaction { address target; uint256 value; bytes callData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Interaction {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub callData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Interaction> for UnderlyingRustTuple<'_> {
+            fn from(value: Interaction) -> Self {
+                (value.target, value.value, value.callData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Interaction {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    target: tuple.0,
+                    value: tuple.1,
+                    callData: tuple.2,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Interaction {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Interaction {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.callData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Interaction {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Interaction {
+            const NAME: &'static str = "Interaction";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Interaction(address target,uint256 value,bytes callData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.target,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.callData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Interaction {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.target,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.callData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.target,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.value,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.callData,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32, bytes memory) external pure returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swap(address,(address,uint256),(address,uint256),(address,uint256),(address,uint256,bytes)[])` and selector `0xe8333e0d`.
+    ```solidity
+    function swap(address settlement, Asset memory sell, Asset memory buy, Allowance memory allowance, Interaction[] memory calls) external returns (uint256 gasUsed);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub settlement: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sell: <Asset as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub buy: <Asset as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub allowance: <Allowance as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub calls:
+            alloy_sol_types::private::Vec<<Interaction as alloy_sol_types::SolType>::RustType>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swap(address,(address,uint256),(address,uint256),(address,uint256),
+    /// (address,uint256,bytes)[])`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {
+        #[allow(missing_docs)]
+        pub gasUsed: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                Asset,
+                Asset,
+                Allowance,
+                alloy_sol_types::sol_data::Array<Interaction>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <Asset as alloy_sol_types::SolType>::RustType,
+                <Asset as alloy_sol_types::SolType>::RustType,
+                <Allowance as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<<Interaction as alloy_sol_types::SolType>::RustType>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (
+                        value.settlement,
+                        value.sell,
+                        value.buy,
+                        value.allowance,
+                        value.calls,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        settlement: tuple.0,
+                        sell: tuple.1,
+                        buy: tuple.2,
+                        allowance: tuple.3,
+                        calls: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    (value.gasUsed,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { gasUsed: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                Asset,
+                Asset,
+                Allowance,
+                alloy_sol_types::sol_data::Array<Interaction>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 51u8, 62u8, 13u8];
+            const SIGNATURE: &'static str = "swap(address,(address,uint256),(address,uint256),\
+                                             (address,uint256),(address,uint256,bytes)[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlement,
+                    ),
+                    <Asset as alloy_sol_types::SolType>::tokenize(&self.sell),
+                    <Asset as alloy_sol_types::SolType>::tokenize(&self.buy),
+                    <Allowance as alloy_sol_types::SolType>::tokenize(&self.allowance),
+                    <alloy_sol_types::sol_data::Array<
+                        Interaction,
+                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapReturn = r.into();
+                        r.gasUsed
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapReturn = r.into();
+                    r.gasUsed
+                })
+            }
+        }
+    };
+    ///Container for all the [`Swapper`](self) function calls.
+    #[derive(Clone)]
+    pub enum SwapperCalls {
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+    }
+    impl SwapperCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[22u8, 38u8, 186u8, 126u8], [232u8, 51u8, 62u8, 13u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isValidSignature),
+            ::core::stringify!(swap),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SwapperCalls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 96usize;
+        const NAME: &'static str = "SwapperCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SwapperCalls>] = &[
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<SwapperCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwapperCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<SwapperCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwapperCalls::swap)
+                    }
+                    swap
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SwapperCalls>] = &[
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<SwapperCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwapperCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<SwapperCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SwapperCalls::swap)
+                    }
+                    swap
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Swapper`](self) contract instance.
+
+    See the [wrapper's documentation](`SwapperInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SwapperInstance<P, N> {
+        SwapperInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<SwapperInstance<P, N>>> {
+        SwapperInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        SwapperInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Swapper`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Swapper`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SwapperInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SwapperInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SwapperInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SwapperInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Swapper`](self) contract instance.
+
+        See the [wrapper's documentation](`SwapperInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<SwapperInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SwapperInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SwapperInstance<P, N> {
+            SwapperInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SwapperInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            _0: alloy_sol_types::private::FixedBytes<32>,
+            _1: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            settlement: alloy_sol_types::private::Address,
+            sell: <Asset as alloy_sol_types::SolType>::RustType,
+            buy: <Asset as alloy_sol_types::SolType>::RustType,
+            allowance: <Allowance as alloy_sol_types::SolType>::RustType,
+            calls: alloy_sol_types::private::Vec<
+                <Interaction as alloy_sol_types::SolType>::RustType,
+            >,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                settlement,
+                sell,
+                buy,
+                allowance,
+                calls,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SwapperInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Swapper::SwapperInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/swaprrouter/Cargo.toml b/contracts/generated/contracts-generated/swaprrouter/Cargo.toml
new file mode 100644
index 0000000000..f33aba7f10
--- /dev/null
+++ b/contracts/generated/contracts-generated/swaprrouter/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-swaprrouter"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/swaprrouter/src/lib.rs b/contracts/generated/contracts-generated/swaprrouter/src/lib.rs
new file mode 100644
index 0000000000..f343552f44
--- /dev/null
+++ b/contracts/generated/contracts-generated/swaprrouter/src/lib.rs
@@ -0,0 +1,7545 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface SwaprRouter {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod SwaprRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`SwaprRouter`](self) function calls.
+    #[derive(Clone)]
+    pub enum SwaprRouterCalls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl SwaprRouterCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SwaprRouterCalls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "SwaprRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SwaprRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(SwaprRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<SwaprRouterCalls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SwaprRouterCalls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SwaprRouterCalls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SwaprRouterCalls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                SwaprRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(SwaprRouterCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(SwaprRouterCalls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(SwaprRouterCalls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`SwaprRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`SwaprRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> SwaprRouterInstance<P, N> {
+        SwaprRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`SwaprRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`SwaprRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct SwaprRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for SwaprRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("SwaprRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SwaprRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`SwaprRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`SwaprRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> SwaprRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> SwaprRouterInstance<P, N> {
+            SwaprRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SwaprRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        SwaprRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = SwaprRouter::SwaprRouterInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xb9960d9bca016e9748be75dd52f02188b9d0829f"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xE43e60736b1cb4a75ad25240E2f9a62Bff65c0C0"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x530476d5583724A89c8841eB6Da76E7Af4C0F17E"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/testnetuniswapv2router02/Cargo.toml b/contracts/generated/contracts-generated/testnetuniswapv2router02/Cargo.toml
new file mode 100644
index 0000000000..75fff0fbb5
--- /dev/null
+++ b/contracts/generated/contracts-generated/testnetuniswapv2router02/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-testnetuniswapv2router02"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs b/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs
new file mode 100644
index 0000000000..5947b91bf4
--- /dev/null
+++ b/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs
@@ -0,0 +1,7630 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface TestnetUniswapV2Router02 {
+    function WETH() external pure returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external pure returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod TestnetUniswapV2Router02 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external pure returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`TestnetUniswapV2Router02`](self) function calls.
+    #[derive(Clone)]
+    pub enum TestnetUniswapV2Router02Calls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl TestnetUniswapV2Router02Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for TestnetUniswapV2Router02Calls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "TestnetUniswapV2Router02Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermit,
+                            )
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                TestnetUniswapV2Router02Calls,
+            >] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityWithPermit,
+                            )
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(TestnetUniswapV2Router02Calls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(TestnetUniswapV2Router02Calls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(TestnetUniswapV2Router02Calls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(TestnetUniswapV2Router02Calls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermit,
+                            )
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TestnetUniswapV2Router02Calls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
+                    {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TestnetUniswapV2Router02Calls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`TestnetUniswapV2Router02`](self) contract instance.
+
+    See the [wrapper's documentation](`TestnetUniswapV2Router02Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> TestnetUniswapV2Router02Instance<P, N> {
+        TestnetUniswapV2Router02Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`TestnetUniswapV2Router02`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`TestnetUniswapV2Router02`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct TestnetUniswapV2Router02Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for TestnetUniswapV2Router02Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("TestnetUniswapV2Router02Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        TestnetUniswapV2Router02Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`TestnetUniswapV2Router02`](self) contract instance.
+
+        See the [wrapper's documentation](`TestnetUniswapV2Router02Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> TestnetUniswapV2Router02Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> TestnetUniswapV2Router02Instance<P, N> {
+            TestnetUniswapV2Router02Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        TestnetUniswapV2Router02Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        TestnetUniswapV2Router02Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    TestnetUniswapV2Router02::TestnetUniswapV2Router02Instance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0x86dcd3293C53Cf8EFd7303B57beb2a3F671dDE98"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/trader/Cargo.toml b/contracts/generated/contracts-generated/trader/Cargo.toml
new file mode 100644
index 0000000000..3a469a3081
--- /dev/null
+++ b/contracts/generated/contracts-generated/trader/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-trader"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/trader/src/lib.rs b/contracts/generated/contracts-generated/trader/src/lib.rs
new file mode 100644
index 0000000000..9583bc614e
--- /dev/null
+++ b/contracts/generated/contracts-generated/trader/src/lib.rs
@@ -0,0 +1,1082 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface Trader {
+    fallback() external payable;
+
+    receive() external payable;
+
+    function ensureTradePreconditions(address settlementContract, address sellToken, uint256 sellAmount, address nativeToken, address spardose) external;
+    function isValidSignature(bytes32, bytes memory) external pure returns (bytes4);
+    function safeApprove(address token, address vaultRelayer, uint256 amount) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "fallback",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "ensureTradePreconditions",
+    "inputs": [
+      {
+        "name": "settlementContract",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      },
+      {
+        "name": "sellToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "sellAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "nativeToken",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spardose",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isValidSignature",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "safeApprove",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "vaultRelayer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Trader {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\r\0\x80a\0\x1C_9_\xF3\xFE`\x80`@R`\x046\x10a\x007W_5`\xE0\x1C\x80c\x16&\xBA~\x14a\0\x8DW\x80cT.\xB7}\x14a\x01\x04W\x80c\xEBV%\xD9\x14a\x01%Wa\0>V[6a\0>W\0[_a\0\x83_6\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPb\x01\0\0\x93\x92PPa\x01D\x90PV[\x90P\x80Q` \x82\x01\xF3[4\x80\x15a\0\x98W__\xFD[Pa\0\xCFa\0\xA76`\x04a\x0B\x01V[\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x92PPPV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x0FW__\xFD[Pa\x01#a\x01\x1E6`\x04a\x0B\x9CV[a\x01\xC2V[\0[4\x80\x15a\x010W__\xFD[Pa\x01#a\x01?6`\x04a\x0C\0V[a\t\x16V[``_\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83`@Qa\x01l\x91\x90a\x0C>V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x01\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xA9V[``\x91P[P\x92P\x90P\x80a\x01\xBBW\x81Q` \x83\x01\xFD[P\x92\x91PPV[\x7F\x02V]\xBA}h\xDC\xBE\xD6)\x11\0$\xB7\xB5\xE7\x85\xBF\xC1\xA4\x84` E\xEE\xA5\x13\xDE\x8A-\xCF\x99\x80T`\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x82\x16\x17\x90\x91U`\xFF\x16\x15a\x02\xA3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FprepareSwap can only be called o`D\x82\x01R\x7Fnce\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x03\xE4W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03@W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03d\x91\x90a\x0CjV[\x90P\x83\x81\x10\x15a\x03\xE2W_a\x03y\x82\x86a\x0C\x81V[\x90P\x80G\x10a\x03\xE0W\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x03\xC8W__\xFD[PZ\xF1\x15\x80\x15a\x03\xDAW=__>=_\xFD[PPPPP[P[P[_\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04.W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04R\x91\x90a\x0C\xB9V[`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`$\x83\x01R\x91\x92P_\x91\x87\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xC7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xEB\x91\x90a\x0CjV[\x90P\x84\x81\x10\x15a\x07HW`@Q\x7F\xEBV%\xD9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16`\x04\x83\x01R\x83\x16`$\x82\x01R_`D\x82\x01R0\x90c\xEBV%\xD9\x90`d\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05gW__\xFD[PZ\xF1\x92PPP\x80\x15a\x05xWP`\x01[P`@Q\x7F\xEBV%\xD9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16`\x04\x83\x01R\x83\x16`$\x82\x01R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D\x82\x01R0\x90c\xEBV%\xD9\x90`d\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x0BW__\xFD[PZ\xF1\x92PPP\x80\x15a\x06\x1CWP`\x01[P`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`$\x83\x01R_\x91\x90\x88\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x90W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xB4\x91\x90a\x0CjV[\x90P\x85\x81\x10\x15a\x07FW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7Ftrader did not give the required`D\x82\x01R\x7F approvals\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02\x9AV[P[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xB2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xD6\x91\x90a\x0CjV[\x90P\x85\x81\x10\x15a\t\x0CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16cIFf\xB6\x88a\x08\x07\x84\x8Aa\x0C\x81V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16`\x04\x83\x01R`$\x82\x01R`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08oW__\xFD[PZ\xF1\x92PPP\x80\x15a\x08\x80WP`\x01[a\t\x0CW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7Ftrader does not have enough sell`D\x82\x01R\x7F token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02\x9AV[PPPPPPPPV[a\t7s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x83\x83a\t<V[PPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x90\x92R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\t^\xA7\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90_\x90a\t\xCE\x90\x86\x16\x83a\nFV[\x90Pa\t\xD9\x81a\nZV[a\n?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FSafeERC20: approval failed\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02\x9AV[PPPPPV[``a\nS\x83_\x84a\n\x7FV[\x93\x92PPPV[_\x81Q_\x14\x80a\nyWP\x81\x80` \x01\x90Q\x81\x01\x90a\ny\x91\x90a\x0C\xD4V[\x92\x91PPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\n\xA8\x91\x90a\x0C>V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\n\xE2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\n\xE7V[``\x91P[P\x92P\x90P\x80a\n\xF9W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[___`@\x84\x86\x03\x12\x15a\x0B\x13W__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B0W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x0B@W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0BVW__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\x0BgW__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x0B\x99W__\xFD[PV[_____`\xA0\x86\x88\x03\x12\x15a\x0B\xB0W__\xFD[\x855a\x0B\xBB\x81a\x0BxV[\x94P` \x86\x015a\x0B\xCB\x81a\x0BxV[\x93P`@\x86\x015\x92P``\x86\x015a\x0B\xE2\x81a\x0BxV[\x91P`\x80\x86\x015a\x0B\xF2\x81a\x0BxV[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[___``\x84\x86\x03\x12\x15a\x0C\x12W__\xFD[\x835a\x0C\x1D\x81a\x0BxV[\x92P` \x84\x015a\x0C-\x81a\x0BxV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x82Q_[\x81\x81\x10\x15a\x0C]W` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\x0CCV[P_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0CzW__\xFD[PQ\x91\x90PV[\x81\x81\x03\x81\x81\x11\x15a\nyW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x0C\xC9W__\xFD[\x81Qa\nS\x81a\x0BxV[_` \x82\x84\x03\x12\x15a\x0C\xE4W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nSW__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`\x046\x10a\x007W_5`\xE0\x1C\x80c\x16&\xBA~\x14a\0\x8DW\x80cT.\xB7}\x14a\x01\x04W\x80c\xEBV%\xD9\x14a\x01%Wa\0>V[6a\0>W\0[_a\0\x83_6\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPb\x01\0\0\x93\x92PPa\x01D\x90PV[\x90P\x80Q` \x82\x01\xF3[4\x80\x15a\0\x98W__\xFD[Pa\0\xCFa\0\xA76`\x04a\x0B\x01V[\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x92PPPV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x0FW__\xFD[Pa\x01#a\x01\x1E6`\x04a\x0B\x9CV[a\x01\xC2V[\0[4\x80\x15a\x010W__\xFD[Pa\x01#a\x01?6`\x04a\x0C\0V[a\t\x16V[``_\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83`@Qa\x01l\x91\x90a\x0C>V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x01\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x01\xA9V[``\x91P[P\x92P\x90P\x80a\x01\xBBW\x81Q` \x83\x01\xFD[P\x92\x91PPV[\x7F\x02V]\xBA}h\xDC\xBE\xD6)\x11\0$\xB7\xB5\xE7\x85\xBF\xC1\xA4\x84` E\xEE\xA5\x13\xDE\x8A-\xCF\x99\x80T`\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x82\x16\x17\x90\x91U`\xFF\x16\x15a\x02\xA3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FprepareSwap can only be called o`D\x82\x01R\x7Fnce\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x03\xE4W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03@W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03d\x91\x90a\x0CjV[\x90P\x83\x81\x10\x15a\x03\xE2W_a\x03y\x82\x86a\x0C\x81V[\x90P\x80G\x10a\x03\xE0W\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x03\xC8W__\xFD[PZ\xF1\x15\x80\x15a\x03\xDAW=__>=_\xFD[PPPPP[P[P[_\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04.W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04R\x91\x90a\x0C\xB9V[`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`$\x83\x01R\x91\x92P_\x91\x87\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xC7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xEB\x91\x90a\x0CjV[\x90P\x84\x81\x10\x15a\x07HW`@Q\x7F\xEBV%\xD9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16`\x04\x83\x01R\x83\x16`$\x82\x01R_`D\x82\x01R0\x90c\xEBV%\xD9\x90`d\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05gW__\xFD[PZ\xF1\x92PPP\x80\x15a\x05xWP`\x01[P`@Q\x7F\xEBV%\xD9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16`\x04\x83\x01R\x83\x16`$\x82\x01R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D\x82\x01R0\x90c\xEBV%\xD9\x90`d\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x0BW__\xFD[PZ\xF1\x92PPP\x80\x15a\x06\x1CWP`\x01[P`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`$\x83\x01R_\x91\x90\x88\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x90W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xB4\x91\x90a\x0CjV[\x90P\x85\x81\x10\x15a\x07FW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7Ftrader did not give the required`D\x82\x01R\x7F approvals\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02\x9AV[P[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xB2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xD6\x91\x90a\x0CjV[\x90P\x85\x81\x10\x15a\t\x0CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16cIFf\xB6\x88a\x08\x07\x84\x8Aa\x0C\x81V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16`\x04\x83\x01R`$\x82\x01R`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08oW__\xFD[PZ\xF1\x92PPP\x80\x15a\x08\x80WP`\x01[a\t\x0CW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7Ftrader does not have enough sell`D\x82\x01R\x7F token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02\x9AV[PPPPPPPPV[a\t7s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x83\x83a\t<V[PPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x90\x92R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\t^\xA7\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90R\x90_\x90a\t\xCE\x90\x86\x16\x83a\nFV[\x90Pa\t\xD9\x81a\nZV[a\n?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FSafeERC20: approval failed\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02\x9AV[PPPPPV[``a\nS\x83_\x84a\n\x7FV[\x93\x92PPPV[_\x81Q_\x14\x80a\nyWP\x81\x80` \x01\x90Q\x81\x01\x90a\ny\x91\x90a\x0C\xD4V[\x92\x91PPV[``_\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84\x84`@Qa\n\xA8\x91\x90a\x0C>V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\n\xE2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\n\xE7V[``\x91P[P\x92P\x90P\x80a\n\xF9W\x81Q` \x83\x01\xFD[P\x93\x92PPPV[___`@\x84\x86\x03\x12\x15a\x0B\x13W__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B0W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x0B@W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0BVW__\xFD[\x86` \x82\x84\x01\x01\x11\x15a\x0BgW__\xFD[\x93\x96` \x91\x90\x91\x01\x95P\x92\x93PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x0B\x99W__\xFD[PV[_____`\xA0\x86\x88\x03\x12\x15a\x0B\xB0W__\xFD[\x855a\x0B\xBB\x81a\x0BxV[\x94P` \x86\x015a\x0B\xCB\x81a\x0BxV[\x93P`@\x86\x015\x92P``\x86\x015a\x0B\xE2\x81a\x0BxV[\x91P`\x80\x86\x015a\x0B\xF2\x81a\x0BxV[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[___``\x84\x86\x03\x12\x15a\x0C\x12W__\xFD[\x835a\x0C\x1D\x81a\x0BxV[\x92P` \x84\x015a\x0C-\x81a\x0BxV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x82Q_[\x81\x81\x10\x15a\x0C]W` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\x0CCV[P_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0CzW__\xFD[PQ\x91\x90PV[\x81\x81\x03\x81\x81\x11\x15a\nyW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x0C\xC9W__\xFD[\x81Qa\nS\x81a\x0BxV[_` \x82\x84\x03\x12\x15a\x0C\xE4W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nSW__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `ensureTradePreconditions(address,address,uint256,address,address)` and selector `0x542eb77d`.
+    ```solidity
+    function ensureTradePreconditions(address settlementContract, address sellToken, uint256 sellAmount, address nativeToken, address spardose) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ensureTradePreconditionsCall {
+        #[allow(missing_docs)]
+        pub settlementContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nativeToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spardose: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`ensureTradePreconditions(address,address,uint256,address,
+    /// address)`](ensureTradePreconditionsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ensureTradePreconditionsReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ensureTradePreconditionsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ensureTradePreconditionsCall) -> Self {
+                    (
+                        value.settlementContract,
+                        value.sellToken,
+                        value.sellAmount,
+                        value.nativeToken,
+                        value.spardose,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ensureTradePreconditionsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        settlementContract: tuple.0,
+                        sellToken: tuple.1,
+                        sellAmount: tuple.2,
+                        nativeToken: tuple.3,
+                        spardose: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ensureTradePreconditionsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ensureTradePreconditionsReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ensureTradePreconditionsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl ensureTradePreconditionsReturn {
+            fn _tokenize(
+                &self,
+            ) -> <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ensureTradePreconditionsCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = ensureTradePreconditionsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 46u8, 183u8, 125u8];
+            const SIGNATURE: &'static str =
+                "ensureTradePreconditions(address,address,uint256,address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.settlementContract,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sellToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.sellAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.nativeToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spardose,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                ensureTradePreconditionsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    ```solidity
+    function isValidSignature(bytes32, bytes memory) external pure returns (bytes4);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._0),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `safeApprove(address,address,uint256)` and selector `0xeb5625d9`.
+    ```solidity
+    function safeApprove(address token, address vaultRelayer, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct safeApproveCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub vaultRelayer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`safeApprove(address,address,uint256)`](safeApproveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct safeApproveReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<safeApproveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: safeApproveCall) -> Self {
+                    (value.token, value.vaultRelayer, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for safeApproveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        vaultRelayer: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<safeApproveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: safeApproveReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for safeApproveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl safeApproveReturn {
+            fn _tokenize(&self) -> <safeApproveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for safeApproveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = safeApproveReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [235u8, 86u8, 37u8, 217u8];
+            const SIGNATURE: &'static str = "safeApprove(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vaultRelayer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                safeApproveReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`Trader`](self) function calls.
+    #[derive(Clone)]
+    pub enum TraderCalls {
+        #[allow(missing_docs)]
+        ensureTradePreconditions(ensureTradePreconditionsCall),
+        #[allow(missing_docs)]
+        isValidSignature(isValidSignatureCall),
+        #[allow(missing_docs)]
+        safeApprove(safeApproveCall),
+    }
+    impl TraderCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [22u8, 38u8, 186u8, 126u8],
+            [84u8, 46u8, 183u8, 125u8],
+            [235u8, 86u8, 37u8, 217u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <safeApproveCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(isValidSignature),
+            ::core::stringify!(ensureTradePreconditions),
+            ::core::stringify!(safeApprove),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for TraderCalls {
+        const COUNT: usize = 3usize;
+        const MIN_DATA_LENGTH: usize = 96usize;
+        const NAME: &'static str = "TraderCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::ensureTradePreconditions(_) => {
+                    <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::isValidSignature(_) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::safeApprove(_) => <safeApproveCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<TraderCalls>] = &[
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<TraderCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TraderCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn ensureTradePreconditions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TraderCalls> {
+                        <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(TraderCalls::ensureTradePreconditions)
+                    }
+                    ensureTradePreconditions
+                },
+                {
+                    fn safeApprove(data: &[u8]) -> alloy_sol_types::Result<TraderCalls> {
+                        <safeApproveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TraderCalls::safeApprove)
+                    }
+                    safeApprove
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<TraderCalls>] = &[
+                {
+                    fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<TraderCalls> {
+                        <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(TraderCalls::isValidSignature)
+                    }
+                    isValidSignature
+                },
+                {
+                    fn ensureTradePreconditions(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<TraderCalls> {
+                        <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(TraderCalls::ensureTradePreconditions)
+                    }
+                    ensureTradePreconditions
+                },
+                {
+                    fn safeApprove(data: &[u8]) -> alloy_sol_types::Result<TraderCalls> {
+                        <safeApproveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(TraderCalls::safeApprove)
+                    }
+                    safeApprove
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::ensureTradePreconditions(inner) => {
+                    <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::safeApprove(inner) => {
+                    <safeApproveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::ensureTradePreconditions(inner) => {
+                    <ensureTradePreconditionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::isValidSignature(inner) => {
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::safeApprove(inner) => {
+                    <safeApproveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`Trader`](self) contract instance.
+
+    See the [wrapper's documentation](`TraderInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> TraderInstance<P, N> {
+        TraderInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<TraderInstance<P, N>>> {
+        TraderInstance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        TraderInstance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`Trader`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`Trader`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct TraderInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for TraderInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("TraderInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        TraderInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`Trader`](self) contract instance.
+
+        See the [wrapper's documentation](`TraderInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<TraderInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> TraderInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> TraderInstance<P, N> {
+            TraderInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        TraderInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`ensureTradePreconditions`]
+        /// function.
+        pub fn ensureTradePreconditions(
+            &self,
+            settlementContract: alloy_sol_types::private::Address,
+            sellToken: alloy_sol_types::private::Address,
+            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+            nativeToken: alloy_sol_types::private::Address,
+            spardose: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, ensureTradePreconditionsCall, N> {
+            self.call_builder(&ensureTradePreconditionsCall {
+                settlementContract,
+                sellToken,
+                sellAmount,
+                nativeToken,
+                spardose,
+            })
+        }
+
+        ///Creates a new call builder for the [`isValidSignature`] function.
+        pub fn isValidSignature(
+            &self,
+            _0: alloy_sol_types::private::FixedBytes<32>,
+            _1: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, isValidSignatureCall, N> {
+            self.call_builder(&isValidSignatureCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`safeApprove`] function.
+        pub fn safeApprove(
+            &self,
+            token: alloy_sol_types::private::Address,
+            vaultRelayer: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, safeApproveCall, N> {
+            self.call_builder(&safeApproveCall {
+                token,
+                vaultRelayer,
+                amount,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        TraderInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = Trader::TraderInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/uniswapv2factory/Cargo.toml b/contracts/generated/contracts-generated/uniswapv2factory/Cargo.toml
new file mode 100644
index 0000000000..6fb108842d
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv2factory/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-uniswapv2factory"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs b/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs
new file mode 100644
index 0000000000..33b655e28e
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs
@@ -0,0 +1,2320 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface UniswapV2Factory {
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
+
+    constructor(address _feeToSetter);
+
+    function allPairs(uint256) external view returns (address);
+    function allPairsLength() external view returns (uint256);
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+    function feeTo() external view returns (address);
+    function feeToSetter() external view returns (address);
+    function getPair(address, address) external view returns (address);
+    function setFeeTo(address _feeTo) external;
+    function setFeeToSetter(address _feeToSetter) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_feeToSetter",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "allPairs",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allPairsLength",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "createPair",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pair",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "feeTo",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "feeToSetter",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPair",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setFeeTo",
+    "inputs": [
+      {
+        "name": "_feeTo",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setFeeToSetter",
+    "inputs": [
+      {
+        "name": "_feeToSetter",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "PairCreated",
+    "inputs": [
+      {
+        "name": "token0",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "pair",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod UniswapV2Factory {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa6\x868\x03\x80a6\x86\x839\x81\x81\x01`@R` \x81\x10\x15a\x003W`\0\x80\xFD[PQ`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x90\x92\x16\x91\x90\x91\x17\x90Ua6#\x80a\0c`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\x88W`\x005`\xE0\x1C\x80c\xA2\xE7J\xF6\x11a\0[W\x80c\xA2\xE7J\xF6\x14a\0\xFDW\x80c\xC9\xC6S\x96\x14a\x012W\x80c\xE6\xA49\x05\x14a\x01mW\x80c\xF4i\x01\xED\x14a\x01\xA8Wa\0\x88V[\x80c\x01~~X\x14a\0\x8DW\x80c\tKt\x15\x14a\0\xBEW\x80c\x1E=\xD1\x8B\x14a\0\xC6W\x80cWO+\xA3\x14a\0\xE3W[`\0\x80\xFD[a\0\x95a\x01\xDBV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\0\x95a\x01\xF7V[a\0\x95`\x04\x806\x03` \x81\x10\x15a\0\xDCW`\0\x80\xFD[P5a\x02\x13V[a\0\xEBa\x02GV[`@\x80Q\x91\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x010`\x04\x806\x03` \x81\x10\x15a\x01\x13W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x02MV[\0[a\0\x95`\x04\x806\x03`@\x81\x10\x15a\x01HW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x015\x16a\x03\x1AV[a\0\x95`\x04\x806\x03`@\x81\x10\x15a\x01\x83W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x015\x16a\x07mV[a\x010`\x04\x806\x03` \x81\x10\x15a\x01\xBEW`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x07\xA0V[`\0Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x01Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x03\x81\x81T\x81\x10a\x02 W\xFE[`\0\x91\x82R` \x90\x91 \x01Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81V[`\x03T\x90V[`\x01Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x02\xD3W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FUniswapV2: FORBIDDEN\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x01\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a\x03\xB7W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2: IDENTICAL_ADDRESSES\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10a\x03\xF4W\x83\x85a\x03\xF7V[\x84\x84[\x90\x92P\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x04~W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FUniswapV2: ZERO_ADDRESS\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16`\0\x90\x81R`\x02` \x90\x81R`@\x80\x83 \x85\x85\x16\x84R\x90\x91R\x90 T\x16\x15a\x05\x1FW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FUniswapV2: PAIR_EXISTS\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[```@Q\x80` \x01a\x051\x90a\x08mV[` \x82\x01\x81\x03\x82R`\x1F\x19`\x1F\x82\x01\x16`@RP\x90P`\0\x83\x83`@Q` \x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16``\x1B\x81R`\x14\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16``\x1B\x81R`\x14\x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x80\x82Q` \x84\x01`\0\xF5`@\x80Q\x7FH\\\xC9U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x81\x16`\x04\x83\x01R\x86\x81\x16`$\x83\x01R\x91Q\x92\x97P\x90\x87\x16\x91cH\\\xC9U\x91`D\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x06^W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x06rW=`\0\x80>=`\0\xFD[PPPPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`\0\x81\x81R`\x02` \x81\x81R`@\x80\x84 \x89\x87\x16\x80\x86R\x90\x83R\x81\x85 \x80T\x97\x8D\x16\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\x89\x16\x81\x17\x90\x91U\x93\x83R\x81\x85 \x86\x86R\x83R\x81\x85 \x80T\x88\x16\x85\x17\x90U`\x03\x80T`\x01\x81\x01\x82U\x95\x81\x90R\x7F\xC2WZ\x0E\x9EY<\0\xF9Y\xF8\xC9/\x12\xDB(i\xC39Z;\x05\x02\xD0^%\x16Doq\xF8[\x90\x95\x01\x80T\x90\x97\x16\x84\x17\x90\x96U\x92T\x83Q\x92\x83R\x90\x82\x01R\x81Q\x7F\r6H\xBD\x0Fk\xA8\x014\xA3;\xA9'Z\xC5\x85\xD9\xD3\x15\xF0\xAD\x83U\xCD\xDE\xFD\xE3\x1A\xFA(\xD0\xE9\x92\x91\x81\x90\x03\x90\x91\x01\x90\xA3PPPP\x92\x91PPV[`\x02` \x90\x81R`\0\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x01Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x08&W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FUniswapV2: FORBIDDEN\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[a-t\x80a\x08{\x839\x01\x90V\xFE`\x80`@R`\x01`\x0CU4\x80\x15a\0\x15W`\0\x80\xFD[P`@QF\x90\x80`Ra-\"\x829`@\x80Q\x91\x82\x90\x03`R\x01\x82 \x82\x82\x01\x82R`\n\x83Ri*\xB74\xB9\xBB\xB0\xB8\x10+\x19`\xB1\x1B` \x93\x84\x01R\x81Q\x80\x83\x01\x83R`\x01\x81R`1`\xF8\x1B\x90\x84\x01R\x81Q\x80\x84\x01\x91\x90\x91R\x7F\xBF\xCC\x8E\xF9\x8F\xFB\xF7\xB6\xC3\xFE\xC7\xBFQ\x85\xB5f\xB9\x86>5\xA9\xD8:\xCDI\xADh$\xB5\x96\x978\x81\x83\x01R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01R`\x80\x81\x01\x94\x90\x94R0`\xA0\x80\x86\x01\x91\x90\x91R\x81Q\x80\x86\x03\x90\x91\x01\x81R`\xC0\x90\x94\x01\x90R\x82Q\x92\x01\x91\x90\x91 `\x03UP`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x19\x163\x17\x90Ua,\x1D\x80a\x01\x05`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\xB9W`\x005`\xE0\x1C\x80cjbxB\x11a\0\xF9W\x80c\xBA\x9AzV\x11a\0\x97W\x80c\xD2\x12 \xA7\x11a\0qW\x80c\xD2\x12 \xA7\x14a\x05\xDAW\x80c\xD5\x05\xAC\xCF\x14a\x05\xE2W\x80c\xDDb\xED>\x14a\x06@W\x80c\xFF\xF6\xCA\xE9\x14a\x06{Wa\x01\xB9V[\x80c\xBA\x9AzV\x14a\x05\x97W\x80c\xBC%\xCFw\x14a\x05\x9FW\x80c\xC4Z\x01U\x14a\x05\xD2Wa\x01\xB9V[\x80c~\xCE\xBE\0\x11a\0\xD3W\x80c~\xCE\xBE\0\x14a\x04\xD7W\x80c\x89\xAF\xCBD\x14a\x05\nW\x80c\x95\xD8\x9BA\x14a\x05VW\x80c\xA9\x05\x9C\xBB\x14a\x05^Wa\x01\xB9V[\x80cjbxB\x14a\x04iW\x80cp\xA0\x821\x14a\x04\x9CW\x80ctd\xFC=\x14a\x04\xCFWa\x01\xB9V[\x80c#\xB8r\xDD\x11a\x01fW\x80c6D\xE5\x15\x11a\x01@W\x80c6D\xE5\x15\x14a\x04\x16W\x80cH\\\xC9U\x14a\x04\x1EW\x80cY\t\xC0\xD5\x14a\x04YW\x80cZ=T\x93\x14a\x04aWa\x01\xB9V[\x80c#\xB8r\xDD\x14a\x03\xADW\x80c0\xAD\xF8\x1F\x14a\x03\xF0W\x80c1<\xE5g\x14a\x03\xF8Wa\x01\xB9V[\x80c\t^\xA7\xB3\x11a\x01\x97W\x80c\t^\xA7\xB3\x14a\x03\x15W\x80c\r\xFE\x16\x81\x14a\x03bW\x80c\x18\x16\r\xDD\x14a\x03\x93Wa\x01\xB9V[\x80c\x02,\r\x9F\x14a\x01\xBEW\x80c\x06\xFD\xDE\x03\x14a\x02YW\x80c\t\x02\xF1\xAC\x14a\x02\xD6W[`\0\x80\xFD[a\x02W`\x04\x806\x03`\x80\x81\x10\x15a\x01\xD4W`\0\x80\xFD[\x815\x91` \x81\x015\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@\x83\x015\x16\x91\x90\x81\x01\x90`\x80\x81\x01``\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x02\x18W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x02*W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x02LW`\0\x80\xFD[P\x90\x92P\x90Pa\x06\x83V[\0[a\x02aa\rWV[`@\x80Q` \x80\x82R\x83Q\x81\x83\x01R\x83Q\x91\x92\x83\x92\x90\x83\x01\x91\x85\x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x02\x9BW\x81\x81\x01Q\x83\x82\x01R` \x01a\x02\x83V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x02\xC8W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x02\xDEa\r\x90V[`@\x80Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16\x81R\x92\x90\x93\x16` \x83\x01Rc\xFF\xFF\xFF\xFF\x16\x81\x83\x01R\x90Q\x90\x81\x90\x03``\x01\x90\xF3[a\x03N`\x04\x806\x03`@\x81\x10\x15a\x03+W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\r\xE5V[`@\x80Q\x91\x15\x15\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x03ja\r\xFCV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x03\x9Ba\x0E\x18V[`@\x80Q\x91\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x03N`\x04\x806\x03``\x81\x10\x15a\x03\xC3W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x90\x91\x16\x90`@\x015a\x0E\x1EV[a\x03\x9Ba\x0E\xFDV[a\x04\0a\x0F!V[`@\x80Q`\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[a\x03\x9Ba\x0F&V[a\x02W`\x04\x806\x03`@\x81\x10\x15a\x044W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x015\x16a\x0F,V[a\x03\x9Ba\x10\x05V[a\x03\x9Ba\x10\x0BV[a\x03\x9B`\x04\x806\x03` \x81\x10\x15a\x04\x7FW`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x10\x11V[a\x03\x9B`\x04\x806\x03` \x81\x10\x15a\x04\xB2W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x13\xCBV[a\x03\x9Ba\x13\xDDV[a\x03\x9B`\x04\x806\x03` \x81\x10\x15a\x04\xEDW`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x13\xE3V[a\x05=`\x04\x806\x03` \x81\x10\x15a\x05 W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x13\xF5V[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x80Q\x91\x82\x90\x03\x01\x90\xF3[a\x02aa\x18\x92V[a\x03N`\x04\x806\x03`@\x81\x10\x15a\x05tW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x18\xCBV[a\x03\x9Ba\x18\xD8V[a\x02W`\x04\x806\x03` \x81\x10\x15a\x05\xB5W`\0\x80\xFD[P5s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x18\xDEV[a\x03ja\x1A\xD4V[a\x03ja\x1A\xF0V[a\x02W`\x04\x806\x03`\xE0\x81\x10\x15a\x05\xF8W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x90\x91\x16\x90`@\x81\x015\x90``\x81\x015\x90`\xFF`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x015a\x1B\x0CV[a\x03\x9B`\x04\x806\x03`@\x81\x10\x15a\x06VW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x015\x16a\x1D\xD8V[a\x02Wa\x1D\xF5V[`\x0CT`\x01\x14a\x06\xF4W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUniswapV2: LOCKED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0`\x0CU\x84\x15\x15\x80a\x07\x07WP`\0\x84\x11[a\x07\\W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80a+/`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80a\x07ga\r\x90V[P\x91P\x91P\x81m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x87\x10\x80\x15a\x07\x9AWP\x80m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x10[a\x07\xEFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`!\x81R` \x01\x80a+x`!\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x06T`\x07T`\0\x91\x82\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x91\x90\x81\x16\x90\x89\x16\x82\x14\x80\x15\x90a\x08TWP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a\x08\xBFW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FUniswapV2: INVALID_TO\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x8A\x15a\x08\xD0Wa\x08\xD0\x82\x8A\x8Da\x1F\xDBV[\x89\x15a\x08\xE1Wa\x08\xE1\x81\x8A\x8Ca\x1F\xDBV[\x86\x15a\t\xC3W\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x10\xD1\xE8\\3\x8D\x8D\x8C\x8C`@Q\x86c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85\x81R` \x01\x84\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x84\x84\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x96PPPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\t\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\t\xBEW=`\0\x80>=`\0\xFD[PPPP[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91cp\xA0\x821\x91`$\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\n/W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\nCW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\nYW`\0\x80\xFD[PQ`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\n\xCBW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\n\xDFW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\n\xF5W`\0\x80\xFD[PQ\x92P`\0\x91PPm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x8A\x90\x03\x83\x11a\x0B\x1FW`\0a\x0B5V[\x89\x85m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03\x83\x03[\x90P`\0\x89\x85m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03\x83\x11a\x0BYW`\0a\x0BoV[\x89\x85m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03\x83\x03[\x90P`\0\x82\x11\x80a\x0B\x80WP`\0\x81\x11[a\x0B\xD5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`$\x81R` \x01\x80a+T`$\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0a\x0C\ta\x0B\xEB\x84`\x03c\xFF\xFF\xFF\xFFa!\xE8\x16V[a\x0B\xFD\x87a\x03\xE8c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x90c\xFF\xFF\xFF\xFFa\"n\x16V[\x90P`\0a\x0C!a\x0B\xEB\x84`\x03c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x90Pa\x0CYb\x0FB@a\x0CMm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16\x90\x8B\x16c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x90c\xFF\xFF\xFF\xFFa!\xE8\x16V[a\x0Ci\x83\x83c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x10\x15a\x0C\xD6W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0C`$\x82\x01R\x7FUniswapV2: K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPa\x0C\xE4\x84\x84\x88\x88a\"\xE0V[`@\x80Q\x83\x81R` \x81\x01\x83\x90R\x80\x82\x01\x8D\x90R``\x81\x01\x8C\x90R\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x913\x91\x7F\xD7\x8A\xD9_\xA4l\x99KeQ\xD0\xDA\x85\xFC'_\xE6\x13\xCE7e\x7F\xB8\xD5\xE3\xD10\x84\x01Y\xD8\"\x91\x81\x90\x03`\x80\x01\x90\xA3PP`\x01`\x0CUPPPPPPPPPV[`@Q\x80`@\x01`@R\x80`\n\x81R` \x01\x7FUniswap V2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\x08Tm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16\x92n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83\x04\x90\x91\x16\x91|\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04c\xFF\xFF\xFF\xFF\x16\x90V[`\0a\r\xF23\x84\x84a%\x9CV[P`\x01[\x92\x91PPV[`\x06Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0T\x81V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`\0\x90\x81R`\x02` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x81 T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x14a\x0E\xE8Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\0\x90\x81R`\x02` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 Ta\x0E\xB6\x90\x83c\xFF\xFF\xFF\xFFa\"n\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`\0\x90\x81R`\x02` \x90\x81R`@\x80\x83 3\x84R\x90\x91R\x90 U[a\x0E\xF3\x84\x84\x84a&\x0BV[P`\x01\x93\x92PPPV[\x7Fnq\xED\xAE\x12\xB1\xB9\x7FM\x1F`7\x0F\xEF\x10\x10_\xA2\xFA\xAE\x01&\x11J\x16\x9Cd\x84]a&\xC9\x81V[`\x12\x81V[`\x03T\x81V[`\x05Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0F\xB2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FUniswapV2: FORBIDDEN\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x06\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x82\x16\x17\x90\x91U`\x07\x80T\x92\x90\x93\x16\x91\x16\x17\x90UV[`\tT\x81V[`\nT\x81V[`\0`\x0CT`\x01\x14a\x10\x84W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUniswapV2: LOCKED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0`\x0C\x81\x90U\x80a\x10\x94a\r\x90V[P`\x06T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x93\x95P\x91\x93P`\0\x92s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x91cp\xA0\x821\x91`$\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x11\x0EW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x11\"W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x118W`\0\x80\xFD[PQ`\x07T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x92\x93P`\0\x92s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x11\xB1W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x11\xC5W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x11\xDBW`\0\x80\xFD[PQ\x90P`\0a\x12\x01\x83m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16c\xFF\xFF\xFF\xFFa\"n\x16V[\x90P`\0a\x12%\x83m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16c\xFF\xFF\xFF\xFFa\"n\x16V[\x90P`\0a\x123\x87\x87a&\xECV[`\0T\x90\x91P\x80a\x12pWa\x12\\a\x03\xE8a\x0B\xFDa\x12W\x87\x87c\xFF\xFF\xFF\xFFa!\xE8\x16V[a(xV[\x98Pa\x12k`\0a\x03\xE8a(\xCAV[a\x12\xCDV[a\x12\xCAm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x89\x16a\x12\x94\x86\x84c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x81a\x12\x9BW\xFE[\x04m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x89\x16a\x12\xBD\x86\x85c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x81a\x12\xC4W\xFE[\x04a)zV[\x98P[`\0\x89\x11a\x13&W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80a+\xC1`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x130\x8A\x8Aa(\xCAV[a\x13<\x86\x86\x8A\x8Aa\"\xE0V[\x81\x15a\x13~W`\x08Ta\x13z\x90m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16\x91n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04\x16c\xFF\xFF\xFF\xFFa!\xE8\x16V[`\x0BU[`@\x80Q\x85\x81R` \x81\x01\x85\x90R\x81Q3\x92\x7FL \x9B_\xC8\xADPu\x8F\x13\xE2\xE1\x08\x8B\xA5jV\r\xFFi\n\x1Co\xEF&9OL\x03\x82\x1CO\x92\x82\x90\x03\x01\x90\xA2PP`\x01`\x0CUP\x94\x96\x95PPPPPPV[`\x01` R`\0\x90\x81R`@\x90 T\x81V[`\x0BT\x81V[`\x04` R`\0\x90\x81R`@\x90 T\x81V[`\0\x80`\x0CT`\x01\x14a\x14iW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUniswapV2: LOCKED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0`\x0C\x81\x90U\x80a\x14ya\r\x90V[P`\x06T`\x07T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x94\x96P\x92\x94Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93\x91\x16\x91`\0\x91\x84\x91cp\xA0\x821\x91`$\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x14\xFBW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x15\x0FW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x15%W`\0\x80\xFD[PQ`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x91\x92P`\0\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91cp\xA0\x821\x91`$\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x15\x99W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x15\xADW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x15\xC3W`\0\x80\xFD[PQ0`\0\x90\x81R`\x01` R`@\x81 T\x91\x92Pa\x15\xE2\x88\x88a&\xECV[`\0T\x90\x91P\x80a\x15\xF9\x84\x87c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x81a\x16\0W\xFE[\x04\x9AP\x80a\x16\x14\x84\x86c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x81a\x16\x1BW\xFE[\x04\x99P`\0\x8B\x11\x80\x15a\x16.WP`\0\x8A\x11[a\x16\x83W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80a+\x99`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x16\x8D0\x84a)\x92V[a\x16\x98\x87\x8D\x8Da\x1F\xDBV[a\x16\xA3\x86\x8D\x8Ca\x1F\xDBV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x89\x16\x91cp\xA0\x821\x91`$\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x17\x0FW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x17#W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x179W`\0\x80\xFD[PQ`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x91\x96Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x17\xABW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x17\xBFW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x17\xD5W`\0\x80\xFD[PQ\x93Pa\x17\xE5\x85\x85\x8B\x8Ba\"\xE0V[\x81\x15a\x18'W`\x08Ta\x18#\x90m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16\x91n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04\x16c\xFF\xFF\xFF\xFFa!\xE8\x16V[`\x0BU[`@\x80Q\x8C\x81R` \x81\x01\x8C\x90R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8F\x16\x923\x92\x7F\xDC\xCDA/\x0B\x12R\x81\x9C\xB1\xFD3\x0B\x93\"L\xA4&\x12\x89+\xB3\xF4\xF7\x89\x97nm\x81\x93d\x96\x92\x90\x81\x90\x03\x90\x91\x01\x90\xA3PPPPPPPPP`\x01`\x0C\x81\x90UP\x91P\x91V[`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7FUNI-V2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0a\r\xF23\x84\x84a&\x0BV[a\x03\xE8\x81V[`\x0CT`\x01\x14a\x19OW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUniswapV2: LOCKED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0`\x0CU`\x06T`\x07T`\x08T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16\x94\x90\x93\x16\x92a\x1A+\x92\x85\x92\x87\x92a\x1A&\x92m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x85\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x19\xEEW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1A\x02W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1A\x18W`\0\x80\xFD[PQ\x90c\xFF\xFF\xFF\xFFa\"n\x16V[a\x1F\xDBV[`\x08T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Qa\x1A\xCA\x92\x84\x92\x87\x92a\x1A&\x92n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x19\xEEW`\0\x80\xFD[PP`\x01`\x0CUPV[`\x05Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x07Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[B\x84\x10\x15a\x1B{W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7FUniswapV2: EXPIRED\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x03Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x89\x16`\0\x81\x81R`\x04` \x90\x81R`@\x80\x83 \x80T`\x01\x80\x82\x01\x90\x92U\x82Q\x7Fnq\xED\xAE\x12\xB1\xB9\x7FM\x1F`7\x0F\xEF\x10\x10_\xA2\xFA\xAE\x01&\x11J\x16\x9Cd\x84]a&\xC9\x81\x86\x01R\x80\x84\x01\x96\x90\x96R\x95\x8D\x16``\x86\x01R`\x80\x85\x01\x8C\x90R`\xA0\x85\x01\x95\x90\x95R`\xC0\x80\x85\x01\x8B\x90R\x81Q\x80\x86\x03\x90\x91\x01\x81R`\xE0\x85\x01\x82R\x80Q\x90\x83\x01 \x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x01\0\x86\x01Ra\x01\x02\x85\x01\x96\x90\x96Ra\x01\"\x80\x85\x01\x96\x90\x96R\x80Q\x80\x85\x03\x90\x96\x01\x86Ra\x01B\x84\x01\x80\x82R\x86Q\x96\x83\x01\x96\x90\x96 \x95\x83\x90Ra\x01b\x84\x01\x80\x82R\x86\x90R`\xFF\x89\x16a\x01\x82\x85\x01Ra\x01\xA2\x84\x01\x88\x90Ra\x01\xC2\x84\x01\x87\x90RQ\x91\x93\x92a\x01\xE2\x80\x82\x01\x93\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x01\x92\x81\x90\x03\x90\x91\x01\x90\x85Z\xFA\x15\x80\x15a\x1C\xDCW=`\0\x80>=`\0\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PPs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x15\x80\x15\x90a\x1DWWP\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14[a\x1D\xC2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FUniswapV2: INVALID_SIGNATURE\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1D\xCD\x89\x89\x89a%\x9CV[PPPPPPPPPV[`\x02` \x90\x81R`\0\x92\x83R`@\x80\x84 \x90\x91R\x90\x82R\x90 T\x81V[`\x0CT`\x01\x14a\x1EfW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7FUniswapV2: LOCKED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0`\x0CU`\x06T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Qa\x1F\xD4\x92s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91cp\xA0\x821\x91`$\x80\x83\x01\x92` \x92\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x1E\xDDW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1E\xF1W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1F\x07W`\0\x80\xFD[PQ`\x07T`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x1FzW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\x8EW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1F\xA4W`\0\x80\xFD[PQ`\x08Tm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16\x91n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04\x16a\"\xE0V[`\x01`\x0CUV[`@\x80Q\x80\x82\x01\x82R`\x19\x81R\x7Ftransfer(address,uint256)\0\0\0\0\0\0\0` \x91\x82\x01R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R`D\x80\x83\x01\x86\x90R\x84Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x84R\x91\x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x81Q`\0\x94``\x94\x89\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10a \xE1W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a \xA4V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a!CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a!HV[``\x91P[P\x91P\x91P\x81\x80\x15a!vWP\x80Q\x15\x80a!vWP\x80\x80` \x01\x90Q` \x81\x10\x15a!sW`\0\x80\xFD[PQ[a!\xE1W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FUniswapV2: TRANSFER_FAILED\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPPPPV[`\0\x81\x15\x80a\"\x03WPP\x80\x82\x02\x82\x82\x82\x81a\"\0W\xFE[\x04\x14[a\r\xF6W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-mul-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x80\x82\x03\x82\x81\x11\x15a\r\xF6W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7Fds-math-sub-underflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x11\x80\x15\x90a#\x0CWPm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x15[a#wW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FUniswapV2: OVERFLOW\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x08Tc\xFF\xFF\xFF\xFFB\x81\x16\x91|\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04\x81\x16\x82\x03\x90\x81\x16\x15\x80\x15\x90a#\xC7WPm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x15\x15[\x80\x15a#\xE2WPm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x15\x15[\x15a$\x92W\x80c\xFF\xFF\xFF\xFF\x16a$%\x85a#\xFB\x86a*WV[{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xFF\xFF\xFF\xFFa*{\x16V[`\t\x80T{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x92\x90\x92\x02\x01\x90Uc\xFF\xFF\xFF\xFF\x81\x16a$e\x84a#\xFB\x87a*WV[`\n\x80T{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x92\x90\x92\x02\x01\x90U[`\x08\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16\x91\x90\x91\x17\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x83\x16\x81\x02\x91\x90\x91\x17{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16|\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0c\xFF\xFF\xFF\xFF\x87\x16\x02\x17\x92\x83\x90U`@\x80Q\x84\x84\x16\x81R\x91\x90\x93\x04\x90\x91\x16` \x82\x01R\x81Q\x7F\x1CA\x1E\x9A\x96\xE0q$\x1C/!\xF7rk\x17\xAE\x89\xE3\xCA\xB4\xC7\x8B\xE5\x0E\x06+\x03\xA9\xFF\xFB\xBA\xD1\x92\x91\x81\x90\x03\x90\x91\x01\x90\xA1PPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16`\0\x81\x81R`\x02` \x90\x81R`@\x80\x83 \x94\x87\x16\x80\x84R\x94\x82R\x91\x82\x90 \x85\x90U\x81Q\x85\x81R\x91Q\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x92\x81\x90\x03\x90\x91\x01\x90\xA3PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`\0\x90\x81R`\x01` R`@\x90 Ta&A\x90\x82c\xFF\xFF\xFF\xFFa\"n\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`\0\x90\x81R`\x01` R`@\x80\x82 \x93\x90\x93U\x90\x84\x16\x81R Ta&\x83\x90\x82c\xFF\xFF\xFF\xFFa*\xBC\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16`\0\x81\x81R`\x01` \x90\x81R`@\x91\x82\x90 \x94\x90\x94U\x80Q\x85\x81R\x90Q\x91\x93\x92\x87\x16\x92\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x92\x91\x82\x90\x03\x01\x90\xA3PPPV[`\0\x80`\x05`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x01~~X`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a'WW`\0\x80\xFD[PZ\xFA\x15\x80\x15a'kW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a'\x81W`\0\x80\xFD[PQ`\x0BTs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x15\x80\x15\x94P\x91\x92P\x90a(dW\x80\x15a(_W`\0a'\xD8a\x12Wm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16\x90\x88\x16c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x90P`\0a'\xE5\x83a(xV[\x90P\x80\x82\x11\x15a(\\W`\0a(\x13a(\x04\x84\x84c\xFF\xFF\xFF\xFFa\"n\x16V[`\0T\x90c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x90P`\0a(8\x83a(,\x86`\x05c\xFF\xFF\xFF\xFFa!\xE8\x16V[\x90c\xFF\xFF\xFF\xFFa*\xBC\x16V[\x90P`\0\x81\x83\x81a(EW\xFE[\x04\x90P\x80\x15a(XWa(X\x87\x82a(\xCAV[PPP[PP[a(pV[\x80\x15a(pW`\0`\x0BU[PP\x92\x91PPV[`\0`\x03\x82\x11\x15a(\xBBWP\x80`\x01`\x02\x82\x04\x01[\x81\x81\x10\x15a(\xB5W\x80\x91P`\x02\x81\x82\x85\x81a(\xA4W\xFE[\x04\x01\x81a(\xADW\xFE[\x04\x90Pa(\x8DV[Pa(\xC5V[\x81\x15a(\xC5WP`\x01[\x91\x90PV[`\0Ta(\xDD\x90\x82c\xFF\xFF\xFF\xFFa*\xBC\x16V[`\0\x90\x81Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x81R`\x01` R`@\x90 Ta)\x15\x90\x82c\xFF\xFF\xFF\xFFa*\xBC\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 \x94\x90\x94U\x83Q\x85\x81R\x93Q\x92\x93\x91\x92\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x92\x81\x90\x03\x90\x91\x01\x90\xA3PPV[`\0\x81\x83\x10a)\x89W\x81a)\x8BV[\x82[\x93\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16`\0\x90\x81R`\x01` R`@\x90 Ta)\xC8\x90\x82c\xFF\xFF\xFF\xFFa\"n\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`\0\x90\x81R`\x01` R`@\x81 \x91\x90\x91UTa*\x02\x90\x82c\xFF\xFF\xFF\xFFa\"n\x16V[`\0\x90\x81U`@\x80Q\x83\x81R\x90Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x91\x90\x81\x90\x03` \x01\x90\xA3PPV[m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02\x90V[`\0m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81a*\xB4W\xFE[\x04\x93\x92PPPV[\x80\x82\x01\x82\x81\x10\x15a\r\xF6W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-add-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD\xFEUniswapV2: INSUFFICIENT_OUTPUT_AMOUNTUniswapV2: INSUFFICIENT_INPUT_AMOUNTUniswapV2: INSUFFICIENT_LIQUIDITYUniswapV2: INSUFFICIENT_LIQUIDITY_BURNEDUniswapV2: INSUFFICIENT_LIQUIDITY_MINTED\xA2ebzzr1X }\xCA\x18G\x9EXHv\x06\xBFp\xC7\x9ED\xD8\xDE\xE6#S\xC9\xEEm\x01\xF9\xA9\xD7\x08\x85\xB8v_\"dsolcC\0\x05\x10\x002EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\xA2ebzzr1X '`\xF9-\x7F\xA1\xDBoZ\xA1c\x07\xBA\xD6]\xF4\xEB\xCC\x85P\xC4\xB1\xF07U\xAB\x8D\xFD\x83\x0C\x17\x8FdsolcC\0\x05\x10\x002",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PairCreated(address,address,address,uint256)` and selector `0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9`.
+    ```solidity
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PairCreated {
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pair: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _3: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PairCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PairCreated(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    13u8, 54u8, 72u8, 189u8, 15u8, 107u8, 168u8, 1u8, 52u8, 163u8, 59u8, 169u8,
+                    39u8, 90u8, 197u8, 133u8, 217u8, 211u8, 21u8, 240u8, 173u8, 131u8, 85u8, 205u8,
+                    222u8, 253u8, 227u8, 26u8, 250u8, 40u8, 208u8, 233u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    token0: topics.1,
+                    token1: topics.2,
+                    pair: data.0,
+                    _3: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.pair,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._3,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.token0.clone(),
+                    self.token1.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token0,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token1,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PairCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PairCreated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PairCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address _feeToSetter);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _feeToSetter: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._feeToSetter,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _feeToSetter: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._feeToSetter,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allPairs(uint256)` and selector `0x1e3dd18b`.
+    ```solidity
+    function allPairs(uint256) external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allPairsCall(pub alloy_sol_types::private::primitives::aliases::U256);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allPairs(uint256)`](allPairsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allPairsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allPairsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allPairsCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allPairsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allPairsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allPairsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [30u8, 61u8, 209u8, 139u8];
+            const SIGNATURE: &'static str = "allPairs(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allPairsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allPairsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allPairsLength()` and selector `0x574f2ba3`.
+    ```solidity
+    function allPairsLength() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allPairsLengthCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allPairsLength()`](allPairsLengthCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allPairsLengthReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allPairsLengthCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allPairsLengthCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsLengthCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allPairsLengthReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allPairsLengthReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsLengthReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allPairsLengthCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [87u8, 79u8, 43u8, 163u8];
+            const SIGNATURE: &'static str = "allPairsLength()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allPairsLengthReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allPairsLengthReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `createPair(address,address)` and selector `0xc9c65396`.
+    ```solidity
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createPairCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`createPair(address,address)`](createPairCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct createPairReturn {
+        #[allow(missing_docs)]
+        pub pair: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createPairCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createPairCall) -> Self {
+                    (value.tokenA, value.tokenB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPairCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<createPairReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createPairReturn) -> Self {
+                    (value.pair,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPairReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { pair: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for createPairCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [201u8, 198u8, 83u8, 150u8];
+            const SIGNATURE: &'static str = "createPair(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createPairReturn = r.into();
+                        r.pair
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: createPairReturn = r.into();
+                    r.pair
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `feeTo()` and selector `0x017e7e58`.
+    ```solidity
+    function feeTo() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeToCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`feeTo()`](feeToCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeToReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeToCall> for UnderlyingRustTuple<'_> {
+                fn from(value: feeToCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeToReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: feeToReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for feeToCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [1u8, 126u8, 126u8, 88u8];
+            const SIGNATURE: &'static str = "feeTo()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: feeToReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: feeToReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `feeToSetter()` and selector `0x094b7415`.
+    ```solidity
+    function feeToSetter() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeToSetterCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`feeToSetter()`](feeToSetterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeToSetterReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeToSetterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: feeToSetterCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToSetterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeToSetterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: feeToSetterReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToSetterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for feeToSetterCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 75u8, 116u8, 21u8];
+            const SIGNATURE: &'static str = "feeToSetter()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: feeToSetterReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: feeToSetterReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPair(address,address)` and selector `0xe6a43905`.
+    ```solidity
+    function getPair(address, address) external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPairCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPair(address,address)`](getPairCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPairReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPairCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPairCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPairCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPairReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPairReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPairReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPairCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [230u8, 164u8, 57u8, 5u8];
+            const SIGNATURE: &'static str = "getPair(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPairReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPairReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setFeeTo(address)` and selector `0xf46901ed`.
+    ```solidity
+    function setFeeTo(address _feeTo) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFeeToCall {
+        #[allow(missing_docs)]
+        pub _feeTo: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setFeeTo(address)`](setFeeToCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFeeToReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFeeToCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setFeeToCall) -> Self {
+                    (value._feeTo,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _feeTo: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFeeToReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setFeeToReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setFeeToReturn {
+            fn _tokenize(&self) -> <setFeeToCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setFeeToCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setFeeToReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [244u8, 105u8, 1u8, 237u8];
+            const SIGNATURE: &'static str = "setFeeTo(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._feeTo,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setFeeToReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setFeeToSetter(address)` and selector `0xa2e74af6`.
+    ```solidity
+    function setFeeToSetter(address _feeToSetter) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFeeToSetterCall {
+        #[allow(missing_docs)]
+        pub _feeToSetter: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`setFeeToSetter(address)`](setFeeToSetterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFeeToSetterReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFeeToSetterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setFeeToSetterCall) -> Self {
+                    (value._feeToSetter,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToSetterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _feeToSetter: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFeeToSetterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setFeeToSetterReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToSetterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setFeeToSetterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setFeeToSetterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setFeeToSetterCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = setFeeToSetterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [162u8, 231u8, 74u8, 246u8];
+            const SIGNATURE: &'static str = "setFeeToSetter(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._feeToSetter,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setFeeToSetterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`UniswapV2Factory`](self) function calls.
+    #[derive(Clone)]
+    pub enum UniswapV2FactoryCalls {
+        #[allow(missing_docs)]
+        allPairs(allPairsCall),
+        #[allow(missing_docs)]
+        allPairsLength(allPairsLengthCall),
+        #[allow(missing_docs)]
+        createPair(createPairCall),
+        #[allow(missing_docs)]
+        feeTo(feeToCall),
+        #[allow(missing_docs)]
+        feeToSetter(feeToSetterCall),
+        #[allow(missing_docs)]
+        getPair(getPairCall),
+        #[allow(missing_docs)]
+        setFeeTo(setFeeToCall),
+        #[allow(missing_docs)]
+        setFeeToSetter(setFeeToSetterCall),
+    }
+    impl UniswapV2FactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [1u8, 126u8, 126u8, 88u8],
+            [9u8, 75u8, 116u8, 21u8],
+            [30u8, 61u8, 209u8, 139u8],
+            [87u8, 79u8, 43u8, 163u8],
+            [162u8, 231u8, 74u8, 246u8],
+            [201u8, 198u8, 83u8, 150u8],
+            [230u8, 164u8, 57u8, 5u8],
+            [244u8, 105u8, 1u8, 237u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <feeToCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <feeToSetterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allPairsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allPairsLengthCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setFeeToSetterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createPairCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPairCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setFeeToCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(feeTo),
+            ::core::stringify!(feeToSetter),
+            ::core::stringify!(allPairs),
+            ::core::stringify!(allPairsLength),
+            ::core::stringify!(setFeeToSetter),
+            ::core::stringify!(createPair),
+            ::core::stringify!(getPair),
+            ::core::stringify!(setFeeTo),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for UniswapV2FactoryCalls {
+        const COUNT: usize = 8usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "UniswapV2FactoryCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::allPairs(_) => <allPairsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::allPairsLength(_) => {
+                    <allPairsLengthCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::createPair(_) => <createPairCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::feeTo(_) => <feeToCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::feeToSetter(_) => <feeToSetterCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getPair(_) => <getPairCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setFeeTo(_) => <setFeeToCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setFeeToSetter(_) => {
+                    <setFeeToSetterCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls>] = &[
+                {
+                    fn feeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <feeToCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::feeTo)
+                    }
+                    feeTo
+                },
+                {
+                    fn feeToSetter(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <feeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::feeToSetter)
+                    }
+                    feeToSetter
+                },
+                {
+                    fn allPairs(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <allPairsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::allPairs)
+                    }
+                    allPairs
+                },
+                {
+                    fn allPairsLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <allPairsLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::allPairsLength)
+                    }
+                    allPairsLength
+                },
+                {
+                    fn setFeeToSetter(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::setFeeToSetter)
+                    }
+                    setFeeToSetter
+                },
+                {
+                    fn createPair(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <createPairCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::createPair)
+                    }
+                    createPair
+                },
+                {
+                    fn getPair(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <getPairCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::getPair)
+                    }
+                    getPair
+                },
+                {
+                    fn setFeeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <setFeeToCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV2FactoryCalls::setFeeTo)
+                    }
+                    setFeeTo
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                UniswapV2FactoryCalls,
+            >] = &[
+                {
+                    fn feeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <feeToCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2FactoryCalls::feeTo)
+                    }
+                    feeTo
+                },
+                {
+                    fn feeToSetter(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <feeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2FactoryCalls::feeToSetter)
+                    }
+                    feeToSetter
+                },
+                {
+                    fn allPairs(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <allPairsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2FactoryCalls::allPairs)
+                    }
+                    allPairs
+                },
+                {
+                    fn allPairsLength(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <allPairsLengthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2FactoryCalls::allPairsLength)
+                    }
+                    allPairsLength
+                },
+                {
+                    fn setFeeToSetter(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2FactoryCalls::setFeeToSetter)
+                    }
+                    setFeeToSetter
+                },
+                {
+                    fn createPair(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <createPairCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2FactoryCalls::createPair)
+                    }
+                    createPair
+                },
+                {
+                    fn getPair(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <getPairCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2FactoryCalls::getPair)
+                    }
+                    getPair
+                },
+                {
+                    fn setFeeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
+                        <setFeeToCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2FactoryCalls::setFeeTo)
+                    }
+                    setFeeTo
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::allPairs(inner) => {
+                    <allPairsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::allPairsLength(inner) => {
+                    <allPairsLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::createPair(inner) => {
+                    <createPairCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::feeTo(inner) => {
+                    <feeToCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::feeToSetter(inner) => {
+                    <feeToSetterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getPair(inner) => {
+                    <getPairCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setFeeTo(inner) => {
+                    <setFeeToCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::setFeeToSetter(inner) => {
+                    <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::allPairs(inner) => {
+                    <allPairsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::allPairsLength(inner) => {
+                    <allPairsLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::createPair(inner) => {
+                    <createPairCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::feeTo(inner) => {
+                    <feeToCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::feeToSetter(inner) => {
+                    <feeToSetterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getPair(inner) => {
+                    <getPairCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setFeeTo(inner) => {
+                    <setFeeToCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::setFeeToSetter(inner) => {
+                    <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`UniswapV2Factory`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum UniswapV2FactoryEvents {
+        #[allow(missing_docs)]
+        PairCreated(PairCreated),
+    }
+    impl UniswapV2FactoryEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[[
+            13u8, 54u8, 72u8, 189u8, 15u8, 107u8, 168u8, 1u8, 52u8, 163u8, 59u8, 169u8, 39u8, 90u8,
+            197u8, 133u8, 217u8, 211u8, 21u8, 240u8, 173u8, 131u8, 85u8, 205u8, 222u8, 253u8,
+            227u8, 26u8, 250u8, 40u8, 208u8, 233u8,
+        ]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<PairCreated as alloy_sol_types::SolEvent>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(PairCreated)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for UniswapV2FactoryEvents {
+        const COUNT: usize = 1usize;
+        const NAME: &'static str = "UniswapV2FactoryEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<PairCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PairCreated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::PairCreated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for UniswapV2FactoryEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PairCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::PairCreated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`UniswapV2Factory`](self) contract instance.
+
+    See the [wrapper's documentation](`UniswapV2FactoryInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> UniswapV2FactoryInstance<P, N> {
+        UniswapV2FactoryInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _feeToSetter: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<UniswapV2FactoryInstance<P, N>>>
+    {
+        UniswapV2FactoryInstance::<P, N>::deploy(__provider, _feeToSetter)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _feeToSetter: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        UniswapV2FactoryInstance::<P, N>::deploy_builder(__provider, _feeToSetter)
+    }
+    /**A [`UniswapV2Factory`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`UniswapV2Factory`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct UniswapV2FactoryInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for UniswapV2FactoryInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("UniswapV2FactoryInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV2FactoryInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`UniswapV2Factory`](self) contract instance.
+
+        See the [wrapper's documentation](`UniswapV2FactoryInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _feeToSetter: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<UniswapV2FactoryInstance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _feeToSetter);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _feeToSetter: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { _feeToSetter })
+                        [..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> UniswapV2FactoryInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> UniswapV2FactoryInstance<P, N> {
+            UniswapV2FactoryInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV2FactoryInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`allPairs`] function.
+        pub fn allPairs(
+            &self,
+            _0: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, allPairsCall, N> {
+            self.call_builder(&allPairsCall(_0))
+        }
+
+        ///Creates a new call builder for the [`allPairsLength`] function.
+        pub fn allPairsLength(&self) -> alloy_contract::SolCallBuilder<&P, allPairsLengthCall, N> {
+            self.call_builder(&allPairsLengthCall)
+        }
+
+        ///Creates a new call builder for the [`createPair`] function.
+        pub fn createPair(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, createPairCall, N> {
+            self.call_builder(&createPairCall { tokenA, tokenB })
+        }
+
+        ///Creates a new call builder for the [`feeTo`] function.
+        pub fn feeTo(&self) -> alloy_contract::SolCallBuilder<&P, feeToCall, N> {
+            self.call_builder(&feeToCall)
+        }
+
+        ///Creates a new call builder for the [`feeToSetter`] function.
+        pub fn feeToSetter(&self) -> alloy_contract::SolCallBuilder<&P, feeToSetterCall, N> {
+            self.call_builder(&feeToSetterCall)
+        }
+
+        ///Creates a new call builder for the [`getPair`] function.
+        pub fn getPair(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, getPairCall, N> {
+            self.call_builder(&getPairCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`setFeeTo`] function.
+        pub fn setFeeTo(
+            &self,
+            _feeTo: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setFeeToCall, N> {
+            self.call_builder(&setFeeToCall { _feeTo })
+        }
+
+        ///Creates a new call builder for the [`setFeeToSetter`] function.
+        pub fn setFeeToSetter(
+            &self,
+            _feeToSetter: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, setFeeToSetterCall, N> {
+            self.call_builder(&setFeeToSetterCall { _feeToSetter })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV2FactoryInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`PairCreated`] event.
+        pub fn PairCreated_filter(&self) -> alloy_contract::Event<&P, PairCreated, N> {
+            self.event_filter::<PairCreated>()
+        }
+    }
+}
+pub type Instance = UniswapV2Factory::UniswapV2FactoryInstance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xA818b4F111Ccac7AA31D0BCc0806d64F2E0737D7"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xF62c03E08ada871A0bEb309762E260a7a6a880E6"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/uniswapv2router02/Cargo.toml b/contracts/generated/contracts-generated/uniswapv2router02/Cargo.toml
new file mode 100644
index 0000000000..22cfbf004c
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv2router02/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-uniswapv2router02"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs b/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs
new file mode 100644
index 0000000000..2d04f9b08e
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs
@@ -0,0 +1,7806 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface UniswapV2Router02 {
+    constructor(address _factory, address _WETH);
+
+    receive() external payable;
+
+    function WETH() external view returns (address);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    function factory() external view returns (address);
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_factory",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_WETH",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountADesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "addLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amountTokenDesired",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsIn",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmountsOut",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidity",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETH",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermit",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountToken",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountTokenMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountETHMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountETH",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "removeLiquidityWithPermit",
+    "inputs": [
+      {
+        "name": "tokenA",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokenB",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountAMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountBMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "approveMax",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapETHForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETH",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "inputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOutMin",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactETH",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod UniswapV2Router02 {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x60c06040523480156200001157600080fd5b506040516200573e3803806200573e833981810160405260408110156200003757600080fd5b5080516020909101516001600160601b0319606092831b8116608052911b1660a05260805160601c60a05160601c6155b762000187600039806101ac5280610e5d5280610e985280610fd5528061129852806116f252806118d65280611e1e5280611fa252806120725280612179528061232c52806123c15280612673528061271a52806127ef52806128f452806129dc5280612a5d52806130ec5280613422528061347852806134ac528061352d528061374752806138f7528061398c5250806110c752806111c5528061136b52806113a4528061154f52806117e452806118b45280611aa1528061225f528061240052806125a95280612a9c5280612ddf5280613071528061309a52806130ca52806132a75280613456528061382d52806139cb528061444a528061448d52806147ed52806149ce5280614f49528061502a52806150aa52506155b76000f3fe60806040526004361061018f5760003560e01c80638803dbee116100d6578063c45a01551161007f578063e8e3370011610059578063e8e3370014610c71578063f305d71914610cfe578063fb3bdb4114610d51576101d5565b8063c45a015514610b25578063d06ca61f14610b3a578063ded9382a14610bf1576101d5565b8063af2979eb116100b0578063af2979eb146109c8578063b6f9de9514610a28578063baa2abde14610abb576101d5565b80638803dbee146108af578063ad5c464814610954578063ad615dec14610992576101d5565b80634a25d94a11610138578063791ac94711610112578063791ac947146107415780637ff36ab5146107e657806385f8c25914610879576101d5565b80634a25d94a146105775780635b0d59841461061c5780635c11d7951461069c576101d5565b80631f00ca74116101695780631f00ca74146103905780632195995c1461044757806338ed1739146104d2576101d5565b806302751cec146101da578063054d50d41461025357806318cbafe51461029b576101d5565b366101d5573373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016146101d357fe5b005b600080fd5b3480156101e657600080fd5b5061023a600480360360c08110156101fd57600080fd5b5073ffffffffffffffffffffffffffffffffffffffff81358116916020810135916040820135916060810135916080820135169060a00135610de4565b6040805192835260208301919091528051918290030190f35b34801561025f57600080fd5b506102896004803603606081101561027657600080fd5b5080359060208101359060400135610f37565b60408051918252519081900360200190f35b3480156102a757600080fd5b50610340600480360360a08110156102be57600080fd5b8135916020810135918101906060810160408201356401000000008111156102e557600080fd5b8201836020820111156102f757600080fd5b8035906020019184602083028401116401000000008311171561031957600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff8135169060200135610f4c565b60408051602080825283518183015283519192839290830191858101910280838360005b8381101561037c578181015183820152602001610364565b505050509050019250505060405180910390f35b34801561039c57600080fd5b50610340600480360360408110156103b357600080fd5b813591908101906040810160208201356401000000008111156103d557600080fd5b8201836020820111156103e757600080fd5b8035906020019184602083028401116401000000008311171561040957600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550611364945050505050565b34801561045357600080fd5b5061023a600480360361016081101561046b57600080fd5b5073ffffffffffffffffffffffffffffffffffffffff8135811691602081013582169160408201359160608101359160808201359160a08101359091169060c08101359060e081013515159060ff610100820135169061012081013590610140013561139a565b3480156104de57600080fd5b50610340600480360360a08110156104f557600080fd5b81359160208101359181019060608101604082013564010000000081111561051c57600080fd5b82018360208201111561052e57600080fd5b8035906020019184602083028401116401000000008311171561055057600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff81351690602001356114d8565b34801561058357600080fd5b50610340600480360360a081101561059a57600080fd5b8135916020810135918101906060810160408201356401000000008111156105c157600080fd5b8201836020820111156105d357600080fd5b803590602001918460208302840111640100000000831117156105f557600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff8135169060200135611669565b34801561062857600080fd5b50610289600480360361014081101561064057600080fd5b5073ffffffffffffffffffffffffffffffffffffffff81358116916020810135916040820135916060810135916080820135169060a08101359060c081013515159060ff60e082013516906101008101359061012001356118ac565b3480156106a857600080fd5b506101d3600480360360a08110156106bf57600080fd5b8135916020810135918101906060810160408201356401000000008111156106e657600080fd5b8201836020820111156106f857600080fd5b8035906020019184602083028401116401000000008311171561071a57600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff81351690602001356119fe565b34801561074d57600080fd5b506101d3600480360360a081101561076457600080fd5b81359160208101359181019060608101604082013564010000000081111561078b57600080fd5b82018360208201111561079d57600080fd5b803590602001918460208302840111640100000000831117156107bf57600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff8135169060200135611d97565b610340600480360360808110156107fc57600080fd5b8135919081019060408101602082013564010000000081111561081e57600080fd5b82018360208201111561083057600080fd5b8035906020019184602083028401116401000000008311171561085257600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff8135169060200135612105565b34801561088557600080fd5b506102896004803603606081101561089c57600080fd5b5080359060208101359060400135612525565b3480156108bb57600080fd5b50610340600480360360a08110156108d257600080fd5b8135916020810135918101906060810160408201356401000000008111156108f957600080fd5b82018360208201111561090b57600080fd5b8035906020019184602083028401116401000000008311171561092d57600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff8135169060200135612532565b34801561096057600080fd5b50610969612671565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b34801561099e57600080fd5b50610289600480360360608110156109b557600080fd5b5080359060208101359060400135612695565b3480156109d457600080fd5b50610289600480360360c08110156109eb57600080fd5b5073ffffffffffffffffffffffffffffffffffffffff81358116916020810135916040820135916060810135916080820135169060a001356126a2565b6101d360048036036080811015610a3e57600080fd5b81359190810190604081016020820135640100000000811115610a6057600080fd5b820183602082011115610a7257600080fd5b80359060200191846020830284011164010000000083111715610a9457600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff8135169060200135612882565b348015610ac757600080fd5b5061023a600480360360e0811015610ade57600080fd5b5073ffffffffffffffffffffffffffffffffffffffff8135811691602081013582169160408201359160608101359160808201359160a08101359091169060c00135612d65565b348015610b3157600080fd5b5061096961306f565b348015610b4657600080fd5b5061034060048036036040811015610b5d57600080fd5b81359190810190604081016020820135640100000000811115610b7f57600080fd5b820183602082011115610b9157600080fd5b80359060200191846020830284011164010000000083111715610bb357600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550613093945050505050565b348015610bfd57600080fd5b5061023a6004803603610140811015610c1557600080fd5b5073ffffffffffffffffffffffffffffffffffffffff81358116916020810135916040820135916060810135916080820135169060a08101359060c081013515159060ff60e082013516906101008101359061012001356130c0565b348015610c7d57600080fd5b50610ce06004803603610100811015610c9557600080fd5b5073ffffffffffffffffffffffffffffffffffffffff8135811691602081013582169160408201359160608101359160808201359160a08101359160c0820135169060e00135613218565b60408051938452602084019290925282820152519081900360600190f35b610ce0600480360360c0811015610d1457600080fd5b5073ffffffffffffffffffffffffffffffffffffffff81358116916020810135916040820135916060810135916080820135169060a001356133a7565b61034060048036036080811015610d6757600080fd5b81359190810190604081016020820135640100000000811115610d8957600080fd5b820183602082011115610d9b57600080fd5b80359060200191846020830284011164010000000083111715610dbd57600080fd5b919350915073ffffffffffffffffffffffffffffffffffffffff81351690602001356136d3565b6000808242811015610e5757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b610e86897f00000000000000000000000000000000000000000000000000000000000000008a8a8a308a612d65565b9093509150610e96898685613b22565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16632e1a7d4d836040518263ffffffff1660e01b815260040180828152602001915050600060405180830381600087803b158015610f0957600080fd5b505af1158015610f1d573d6000803e3d6000fd5b50505050610f2b8583613cff565b50965096945050505050565b6000610f44848484613e3c565b949350505050565b60608142811015610fbe57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b73ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001686867fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff810181811061102357fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146110c257604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f556e69737761705632526f757465723a20494e56414c49445f50415448000000604482015290519081900360640190fd5b6111207f000000000000000000000000000000000000000000000000000000000000000089888880806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250613f6092505050565b9150868260018451038151811061113357fe5b60200260200101511015611192576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b815260200180615508602b913960400191505060405180910390fd5b611257868660008181106111a257fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff163361123d7f00000000000000000000000000000000000000000000000000000000000000008a8a60008181106111f157fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff168b8b600181811061121b57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff166140c6565b8560008151811061124a57fe5b60200260200101516141b1565b61129682878780806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250309250614381915050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16632e1a7d4d836001855103815181106112e257fe5b60200260200101516040518263ffffffff1660e01b815260040180828152602001915050600060405180830381600087803b15801561132057600080fd5b505af1158015611334573d6000803e3d6000fd5b50505050611359848360018551038151811061134c57fe5b6020026020010151613cff565b509695505050505050565b60606113917f00000000000000000000000000000000000000000000000000000000000000008484614608565b90505b92915050565b60008060006113ca7f00000000000000000000000000000000000000000000000000000000000000008f8f6140c6565b90506000876113d9578c6113fb565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b604080517fd505accf00000000000000000000000000000000000000000000000000000000815233600482015230602482015260448101839052606481018c905260ff8a16608482015260a4810189905260c48101889052905191925073ffffffffffffffffffffffffffffffffffffffff84169163d505accf9160e48082019260009290919082900301818387803b15801561149757600080fd5b505af11580156114ab573d6000803e3d6000fd5b505050506114be8f8f8f8f8f8f8f612d65565b809450819550505050509b509b9950505050505050505050565b6060814281101561154a57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b6115a87f000000000000000000000000000000000000000000000000000000000000000089888880806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250613f6092505050565b915086826001845103815181106115bb57fe5b6020026020010151101561161a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b815260200180615508602b913960400191505060405180910390fd5b61162a868660008181106111a257fe5b61135982878780806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250899250614381915050565b606081428110156116db57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b73ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001686867fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff810181811061174057fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146117df57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f556e69737761705632526f757465723a20494e56414c49445f50415448000000604482015290519081900360640190fd5b61183d7f00000000000000000000000000000000000000000000000000000000000000008988888080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525061460892505050565b9150868260008151811061184d57fe5b60200260200101511115611192576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260278152602001806154986027913960400191505060405180910390fd5b6000806118fa7f00000000000000000000000000000000000000000000000000000000000000008d7f00000000000000000000000000000000000000000000000000000000000000006140c6565b9050600086611909578b61192b565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b604080517fd505accf00000000000000000000000000000000000000000000000000000000815233600482015230602482015260448101839052606481018b905260ff8916608482015260a4810188905260c48101879052905191925073ffffffffffffffffffffffffffffffffffffffff84169163d505accf9160e48082019260009290919082900301818387803b1580156119c757600080fd5b505af11580156119db573d6000803e3d6000fd5b505050506119ed8d8d8d8d8d8d6126a2565b9d9c50505050505050505050505050565b8042811015611a6e57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b611afd85856000818110611a7e57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1633611af77f000000000000000000000000000000000000000000000000000000000000000089896000818110611acd57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff168a8a600181811061121b57fe5b8a6141b1565b600085857fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101818110611b2d57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231856040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015611bc657600080fd5b505afa158015611bda573d6000803e3d6000fd5b505050506040513d6020811015611bf057600080fd5b50516040805160208881028281018201909352888252929350611c32929091899189918291850190849080828437600092019190915250889250614796915050565b86611d368288887fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101818110611c6557fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231886040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015611cfe57600080fd5b505afa158015611d12573d6000803e3d6000fd5b505050506040513d6020811015611d2857600080fd5b50519063ffffffff614b2916565b1015611d8d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b815260200180615508602b913960400191505060405180910390fd5b5050505050505050565b8042811015611e0757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b73ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001685857fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101818110611e6c57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611f0b57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f556e69737761705632526f757465723a20494e56414c49445f50415448000000604482015290519081900360640190fd5b611f1b85856000818110611a7e57fe5b611f59858580806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250309250614796915050565b604080517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152905160009173ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016916370a0823191602480820192602092909190829003018186803b158015611fe957600080fd5b505afa158015611ffd573d6000803e3d6000fd5b505050506040513d602081101561201357600080fd5b5051905086811015612070576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b815260200180615508602b913960400191505060405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16632e1a7d4d826040518263ffffffff1660e01b815260040180828152602001915050600060405180830381600087803b1580156120e357600080fd5b505af11580156120f7573d6000803e3d6000fd5b50505050611d8d8482613cff565b6060814281101561217757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16868660008181106121bb57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461225a57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f556e69737761705632526f757465723a20494e56414c49445f50415448000000604482015290519081900360640190fd5b6122b87f000000000000000000000000000000000000000000000000000000000000000034888880806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250613f6092505050565b915086826001845103815181106122cb57fe5b6020026020010151101561232a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b815260200180615508602b913960400191505060405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663d0e30db08360008151811061237357fe5b60200260200101516040518263ffffffff1660e01b81526004016000604051808303818588803b1580156123a657600080fd5b505af11580156123ba573d6000803e3d6000fd5b50505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb61242c7f000000000000000000000000000000000000000000000000000000000000000089896000818110611acd57fe5b8460008151811061243957fe5b60200260200101516040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b1580156124aa57600080fd5b505af11580156124be573d6000803e3d6000fd5b505050506040513d60208110156124d457600080fd5b50516124dc57fe5b61251b82878780806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250899250614381915050565b5095945050505050565b6000610f44848484614b9b565b606081428110156125a457604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b6126027f00000000000000000000000000000000000000000000000000000000000000008988888080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525061460892505050565b9150868260008151811061261257fe5b6020026020010151111561161a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260278152602001806154986027913960400191505060405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000081565b6000610f44848484614cbf565b6000814281101561271457604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b612743887f00000000000000000000000000000000000000000000000000000000000000008989893089612d65565b604080517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015290519194506127ed92508a91879173ffffffffffffffffffffffffffffffffffffffff8416916370a0823191602480820192602092909190829003018186803b1580156127bc57600080fd5b505afa1580156127d0573d6000803e3d6000fd5b505050506040513d60208110156127e657600080fd5b5051613b22565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16632e1a7d4d836040518263ffffffff1660e01b815260040180828152602001915050600060405180830381600087803b15801561286057600080fd5b505af1158015612874573d6000803e3d6000fd5b505050506113598483613cff565b80428110156128f257604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168585600081811061293657fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146129d557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f556e69737761705632526f757465723a20494e56414c49445f50415448000000604482015290519081900360640190fd5b60003490507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663d0e30db0826040518263ffffffff1660e01b81526004016000604051808303818588803b158015612a4257600080fd5b505af1158015612a56573d6000803e3d6000fd5b50505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb612ac87f000000000000000000000000000000000000000000000000000000000000000089896000818110611acd57fe5b836040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b158015612b3257600080fd5b505af1158015612b46573d6000803e3d6000fd5b505050506040513d6020811015612b5c57600080fd5b5051612b6457fe5b600086867fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101818110612b9457fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231866040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015612c2d57600080fd5b505afa158015612c41573d6000803e3d6000fd5b505050506040513d6020811015612c5757600080fd5b50516040805160208981028281018201909352898252929350612c999290918a918a918291850190849080828437600092019190915250899250614796915050565b87611d368289897fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8101818110612ccc57fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231896040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015611cfe57600080fd5b6000808242811015612dd857604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b6000612e057f00000000000000000000000000000000000000000000000000000000000000008c8c6140c6565b604080517f23b872dd00000000000000000000000000000000000000000000000000000000815233600482015273ffffffffffffffffffffffffffffffffffffffff831660248201819052604482018d9052915192935090916323b872dd916064808201926020929091908290030181600087803b158015612e8657600080fd5b505af1158015612e9a573d6000803e3d6000fd5b505050506040513d6020811015612eb057600080fd5b5050604080517f89afcb4400000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff888116600483015282516000938493928616926389afcb44926024808301939282900301818787803b158015612f2357600080fd5b505af1158015612f37573d6000803e3d6000fd5b505050506040513d6040811015612f4d57600080fd5b50805160209091015190925090506000612f678e8e614d9f565b5090508073ffffffffffffffffffffffffffffffffffffffff168e73ffffffffffffffffffffffffffffffffffffffff1614612fa4578183612fa7565b82825b90975095508a871015613005576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260268152602001806154bf6026913960400191505060405180910390fd5b8986101561305e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260268152602001806154256026913960400191505060405180910390fd5b505050505097509795505050505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b60606113917f00000000000000000000000000000000000000000000000000000000000000008484613f60565b60008060006131107f00000000000000000000000000000000000000000000000000000000000000008e7f00000000000000000000000000000000000000000000000000000000000000006140c6565b905060008761311f578c613141565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b604080517fd505accf00000000000000000000000000000000000000000000000000000000815233600482015230602482015260448101839052606481018c905260ff8a16608482015260a4810189905260c48101889052905191925073ffffffffffffffffffffffffffffffffffffffff84169163d505accf9160e48082019260009290919082900301818387803b1580156131dd57600080fd5b505af11580156131f1573d6000803e3d6000fd5b505050506132038e8e8e8e8e8e610de4565b909f909e509c50505050505050505050505050565b6000806000834281101561328d57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b61329b8c8c8c8c8c8c614ef2565b909450925060006132cd7f00000000000000000000000000000000000000000000000000000000000000008e8e6140c6565b90506132db8d3383886141b1565b6132e78c3383876141b1565b8073ffffffffffffffffffffffffffffffffffffffff16636a627842886040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001915050602060405180830381600087803b15801561336657600080fd5b505af115801561337a573d6000803e3d6000fd5b505050506040513d602081101561339057600080fd5b5051949d939c50939a509198505050505050505050565b6000806000834281101561341c57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b61344a8a7f00000000000000000000000000000000000000000000000000000000000000008b348c8c614ef2565b9094509250600061349c7f00000000000000000000000000000000000000000000000000000000000000008c7f00000000000000000000000000000000000000000000000000000000000000006140c6565b90506134aa8b3383886141b1565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663d0e30db0856040518263ffffffff1660e01b81526004016000604051808303818588803b15801561351257600080fd5b505af1158015613526573d6000803e3d6000fd5b50505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb82866040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b1580156135d257600080fd5b505af11580156135e6573d6000803e3d6000fd5b505050506040513d60208110156135fc57600080fd5b505161360457fe5b8073ffffffffffffffffffffffffffffffffffffffff16636a627842886040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001915050602060405180830381600087803b15801561368357600080fd5b505af1158015613697573d6000803e3d6000fd5b505050506040513d60208110156136ad57600080fd5b50519250348410156136c5576136c533853403613cff565b505096509650969350505050565b6060814281101561374557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f556e69737761705632526f757465723a20455850495245440000000000000000604482015290519081900360640190fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff168686600081811061378957fe5b9050602002013573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461382857604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f556e69737761705632526f757465723a20494e56414c49445f50415448000000604482015290519081900360640190fd5b6138867f00000000000000000000000000000000000000000000000000000000000000008888888080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525061460892505050565b9150348260008151811061389657fe5b602002602001015111156138f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260278152602001806154986027913960400191505060405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663d0e30db08360008151811061393e57fe5b60200260200101516040518263ffffffff1660e01b81526004016000604051808303818588803b15801561397157600080fd5b505af1158015613985573d6000803e3d6000fd5b50505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663a9059cbb6139f77f000000000000000000000000000000000000000000000000000000000000000089896000818110611acd57fe5b84600081518110613a0457fe5b60200260200101516040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b158015613a7557600080fd5b505af1158015613a89573d6000803e3d6000fd5b505050506040513d6020811015613a9f57600080fd5b5051613aa757fe5b613ae682878780806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250899250614381915050565b81600081518110613af357fe5b602002602001015134111561251b5761251b3383600081518110613b1357fe5b60200260200101513403613cff565b6040805173ffffffffffffffffffffffffffffffffffffffff8481166024830152604480830185905283518084039091018152606490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000178152925182516000946060949389169392918291908083835b60208310613bf857805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101613bbb565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114613c5a576040519150601f19603f3d011682016040523d82523d6000602084013e613c5f565b606091505b5091509150818015613c8d575080511580613c8d5750808060200190516020811015613c8a57600080fd5b50515b613cf857604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f5472616e7366657248656c7065723a205452414e534645525f4641494c454400604482015290519081900360640190fd5b5050505050565b6040805160008082526020820190925273ffffffffffffffffffffffffffffffffffffffff84169083906040518082805190602001908083835b60208310613d7657805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101613d39565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d8060008114613dd8576040519150601f19603f3d011682016040523d82523d6000602084013e613ddd565b606091505b5050905080613e37576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260238152602001806154e56023913960400191505060405180910390fd5b505050565b6000808411613e96576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602b815260200180615557602b913960400191505060405180910390fd5b600083118015613ea65750600082115b613efb576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602881526020018061544b6028913960400191505060405180910390fd5b6000613f0f856103e563ffffffff6151f316565b90506000613f23828563ffffffff6151f316565b90506000613f4983613f3d886103e863ffffffff6151f316565b9063ffffffff61527916565b9050808281613f5457fe5b04979650505050505050565b6060600282511015613fd357604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f556e697377617056324c6962726172793a20494e56414c49445f504154480000604482015290519081900360640190fd5b815167ffffffffffffffff81118015613feb57600080fd5b50604051908082528060200260200182016040528015614015578160200160208202803683370190505b509050828160008151811061402657fe5b60200260200101818152505060005b60018351038110156140be576000806140788786858151811061405457fe5b602002602001015187866001018151811061406b57fe5b60200260200101516152eb565b9150915061409a84848151811061408b57fe5b60200260200101518383613e3c565b8484600101815181106140a957fe5b60209081029190910101525050600101614035565b509392505050565b60008060006140d58585614d9f565b604080517fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606094851b811660208084019190915293851b81166034830152825160288184030181526048830184528051908501207fff0000000000000000000000000000000000000000000000000000000000000060688401529a90941b9093166069840152607d8301989098527f96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f609d808401919091528851808403909101815260bd909201909752805196019590952095945050505050565b6040805173ffffffffffffffffffffffffffffffffffffffff85811660248301528481166044830152606480830185905283518084039091018152608490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f23b872dd0000000000000000000000000000000000000000000000000000000017815292518251600094606094938a169392918291908083835b6020831061428f57805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101614252565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d80600081146142f1576040519150601f19603f3d011682016040523d82523d6000602084013e6142f6565b606091505b5091509150818015614324575080511580614324575080806020019051602081101561432157600080fd5b50515b614379576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806155336024913960400191505060405180910390fd5b505050505050565b60005b60018351038110156146025760008084838151811061439f57fe5b60200260200101518584600101815181106143b657fe5b60200260200101519150915060006143ce8383614d9f565b50905060008785600101815181106143e257fe5b602002602001015190506000808373ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff161461442a5782600061442e565b6000835b91509150600060028a510388106144455788614486565b6144867f0000000000000000000000000000000000000000000000000000000000000000878c8b6002018151811061447957fe5b60200260200101516140c6565b90506144b37f000000000000000000000000000000000000000000000000000000000000000088886140c6565b73ffffffffffffffffffffffffffffffffffffffff1663022c0d9f84848460006040519080825280601f01601f1916602001820160405280156144fd576020820181803683370190505b506040518563ffffffff1660e01b8152600401808581526020018481526020018373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200180602001828103825283818151815260200191508051906020019080838360005b83811015614588578181015183820152602001614570565b50505050905090810190601f1680156145b55780820380516001836020036101000a031916815260200191505b5095505050505050600060405180830381600087803b1580156145d757600080fd5b505af11580156145eb573d6000803e3d6000fd5b505060019099019850614384975050505050505050565b50505050565b606060028251101561467b57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f556e697377617056324c6962726172793a20494e56414c49445f504154480000604482015290519081900360640190fd5b815167ffffffffffffffff8111801561469357600080fd5b506040519080825280602002602001820160405280156146bd578160200160208202803683370190505b50905082816001835103815181106146d157fe5b602090810291909101015281517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff015b80156140be576000806147318786600186038151811061471d57fe5b602002602001015187868151811061406b57fe5b9150915061475384848151811061474457fe5b60200260200101518383614b9b565b84600185038151811061476257fe5b602090810291909101015250507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01614701565b60005b6001835103811015613e37576000808483815181106147b457fe5b60200260200101518584600101815181106147cb57fe5b60200260200101519150915060006147e38383614d9f565b50905060006148137f000000000000000000000000000000000000000000000000000000000000000085856140c6565b90506000806000808473ffffffffffffffffffffffffffffffffffffffff16630902f1ac6040518163ffffffff1660e01b815260040160606040518083038186803b15801561486157600080fd5b505afa158015614875573d6000803e3d6000fd5b505050506040513d606081101561488b57600080fd5b5080516020909101516dffffffffffffffffffffffffffff918216935016905060008073ffffffffffffffffffffffffffffffffffffffff8a8116908916146148d55782846148d8565b83835b9150915061495d828b73ffffffffffffffffffffffffffffffffffffffff166370a082318a6040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015611cfe57600080fd5b955061496a868383613e3c565b9450505050506000808573ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff16146149ae578260006149b2565b6000835b91509150600060028c51038a106149c9578a6149fd565b6149fd7f0000000000000000000000000000000000000000000000000000000000000000898e8d6002018151811061447957fe5b60408051600080825260208201928390527f022c0d9f000000000000000000000000000000000000000000000000000000008352602482018781526044830187905273ffffffffffffffffffffffffffffffffffffffff8086166064850152608060848501908152845160a48601819052969750908c169563022c0d9f958a958a958a9591949193919260c486019290918190849084905b83811015614aad578181015183820152602001614a95565b50505050905090810190601f168015614ada5780820380516001836020036101000a031916815260200191505b5095505050505050600060405180830381600087803b158015614afc57600080fd5b505af1158015614b10573d6000803e3d6000fd5b50506001909b019a506147999950505050505050505050565b8082038281111561139457604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601560248201527f64732d6d6174682d7375622d756e646572666c6f770000000000000000000000604482015290519081900360640190fd5b6000808411614bf5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602c8152602001806153d4602c913960400191505060405180910390fd5b600083118015614c055750600082115b614c5a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602881526020018061544b6028913960400191505060405180910390fd5b6000614c7e6103e8614c72868863ffffffff6151f316565b9063ffffffff6151f316565b90506000614c986103e5614c72868963ffffffff614b2916565b9050614cb56001828481614ca857fe5b049063ffffffff61527916565b9695505050505050565b6000808411614d19576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260258152602001806154736025913960400191505060405180910390fd5b600083118015614d295750600082115b614d7e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602881526020018061544b6028913960400191505060405180910390fd5b82614d8f858463ffffffff6151f316565b81614d9657fe5b04949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161415614e27576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260258152602001806154006025913960400191505060405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1610614e61578284614e64565b83835b909250905073ffffffffffffffffffffffffffffffffffffffff8216614eeb57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f556e697377617056324c6962726172793a205a45524f5f414444524553530000604482015290519081900360640190fd5b9250929050565b604080517fe6a4390500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff888116600483015287811660248301529151600092839283927f00000000000000000000000000000000000000000000000000000000000000009092169163e6a4390591604480820192602092909190829003018186803b158015614f9257600080fd5b505afa158015614fa6573d6000803e3d6000fd5b505050506040513d6020811015614fbc57600080fd5b505173ffffffffffffffffffffffffffffffffffffffff1614156150a257604080517fc9c6539600000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8a81166004830152898116602483015291517f00000000000000000000000000000000000000000000000000000000000000009092169163c9c65396916044808201926020929091908290030181600087803b15801561507557600080fd5b505af1158015615089573d6000803e3d6000fd5b505050506040513d602081101561509f57600080fd5b50505b6000806150d07f00000000000000000000000000000000000000000000000000000000000000008b8b6152eb565b915091508160001480156150e2575080155b156150f2578793508692506151e6565b60006150ff898484614cbf565b905087811161516c5785811015615161576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260268152602001806154256026913960400191505060405180910390fd5b8894509250826151e4565b6000615179898486614cbf565b90508981111561518557fe5b878110156151de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260268152602001806154bf6026913960400191505060405180910390fd5b94508793505b505b5050965096945050505050565b600081158061520e5750508082028282828161520b57fe5b04145b61139457604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f64732d6d6174682d6d756c2d6f766572666c6f77000000000000000000000000604482015290519081900360640190fd5b8082018281101561139457604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f64732d6d6174682d6164642d6f766572666c6f77000000000000000000000000604482015290519081900360640190fd5b60008060006152fa8585614d9f565b50905060008061530b8888886140c6565b73ffffffffffffffffffffffffffffffffffffffff16630902f1ac6040518163ffffffff1660e01b815260040160606040518083038186803b15801561535057600080fd5b505afa158015615364573d6000803e3d6000fd5b505050506040513d606081101561537a57600080fd5b5080516020909101516dffffffffffffffffffffffffffff918216935016905073ffffffffffffffffffffffffffffffffffffffff878116908416146153c15780826153c4565b81815b9099909850965050505050505056fe556e697377617056324c6962726172793a20494e53554646494349454e545f4f55545055545f414d4f554e54556e697377617056324c6962726172793a204944454e544943414c5f414444524553534553556e69737761705632526f757465723a20494e53554646494349454e545f425f414d4f554e54556e697377617056324c6962726172793a20494e53554646494349454e545f4c4951554944495459556e697377617056324c6962726172793a20494e53554646494349454e545f414d4f554e54556e69737761705632526f757465723a204558434553534956455f494e5055545f414d4f554e54556e69737761705632526f757465723a20494e53554646494349454e545f415f414d4f554e545472616e7366657248656c7065723a204554485f5452414e534645525f4641494c4544556e69737761705632526f757465723a20494e53554646494349454e545f4f55545055545f414d4f554e545472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641494c4544556e697377617056324c6962726172793a20494e53554646494349454e545f494e5055545f414d4f554e54a26469706673582212206dd6e03c4b2c0a8e55214926227ae9e2d6f9fec2ce74a6446d615afa355c84f364736f6c63430006060033
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xC0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0W>8\x03\x80b\0W>\x839\x81\x81\x01`@R`@\x81\x10\x15b\0\x007W`\0\x80\xFD[P\x80Q` \x90\x91\x01Q`\x01`\x01``\x1B\x03\x19``\x92\x83\x1B\x81\x16`\x80R\x91\x1B\x16`\xA0R`\x80Q``\x1C`\xA0Q``\x1CaU\xB7b\0\x01\x87`\09\x80a\x01\xACR\x80a\x0E]R\x80a\x0E\x98R\x80a\x0F\xD5R\x80a\x12\x98R\x80a\x16\xF2R\x80a\x18\xD6R\x80a\x1E\x1ER\x80a\x1F\xA2R\x80a rR\x80a!yR\x80a#,R\x80a#\xC1R\x80a&sR\x80a'\x1AR\x80a'\xEFR\x80a(\xF4R\x80a)\xDCR\x80a*]R\x80a0\xECR\x80a4\"R\x80a4xR\x80a4\xACR\x80a5-R\x80a7GR\x80a8\xF7R\x80a9\x8CRP\x80a\x10\xC7R\x80a\x11\xC5R\x80a\x13kR\x80a\x13\xA4R\x80a\x15OR\x80a\x17\xE4R\x80a\x18\xB4R\x80a\x1A\xA1R\x80a\"_R\x80a$\0R\x80a%\xA9R\x80a*\x9CR\x80a-\xDFR\x80a0qR\x80a0\x9AR\x80a0\xCAR\x80a2\xA7R\x80a4VR\x80a8-R\x80a9\xCBR\x80aDJR\x80aD\x8DR\x80aG\xEDR\x80aI\xCER\x80aOIR\x80aP*R\x80aP\xAARPaU\xB7`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\x8FW`\x005`\xE0\x1C\x80c\x88\x03\xDB\xEE\x11a\0\xD6W\x80c\xC4Z\x01U\x11a\0\x7FW\x80c\xE8\xE37\0\x11a\0YW\x80c\xE8\xE37\0\x14a\x0CqW\x80c\xF3\x05\xD7\x19\x14a\x0C\xFEW\x80c\xFB;\xDBA\x14a\rQWa\x01\xD5V[\x80c\xC4Z\x01U\x14a\x0B%W\x80c\xD0l\xA6\x1F\x14a\x0B:W\x80c\xDE\xD98*\x14a\x0B\xF1Wa\x01\xD5V[\x80c\xAF)y\xEB\x11a\0\xB0W\x80c\xAF)y\xEB\x14a\t\xC8W\x80c\xB6\xF9\xDE\x95\x14a\n(W\x80c\xBA\xA2\xAB\xDE\x14a\n\xBBWa\x01\xD5V[\x80c\x88\x03\xDB\xEE\x14a\x08\xAFW\x80c\xAD\\FH\x14a\tTW\x80c\xADa]\xEC\x14a\t\x92Wa\x01\xD5V[\x80cJ%\xD9J\x11a\x018W\x80cy\x1A\xC9G\x11a\x01\x12W\x80cy\x1A\xC9G\x14a\x07AW\x80c\x7F\xF3j\xB5\x14a\x07\xE6W\x80c\x85\xF8\xC2Y\x14a\x08yWa\x01\xD5V[\x80cJ%\xD9J\x14a\x05wW\x80c[\rY\x84\x14a\x06\x1CW\x80c\\\x11\xD7\x95\x14a\x06\x9CWa\x01\xD5V[\x80c\x1F\0\xCAt\x11a\x01iW\x80c\x1F\0\xCAt\x14a\x03\x90W\x80c!\x95\x99\\\x14a\x04GW\x80c8\xED\x179\x14a\x04\xD2Wa\x01\xD5V[\x80c\x02u\x1C\xEC\x14a\x01\xDAW\x80c\x05MP\xD4\x14a\x02SW\x80c\x18\xCB\xAF\xE5\x14a\x02\x9BWa\x01\xD5V[6a\x01\xD5W3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x01\xD3W\xFE[\0[`\0\x80\xFD[4\x80\x15a\x01\xE6W`\0\x80\xFD[Pa\x02:`\x04\x806\x03`\xC0\x81\x10\x15a\x01\xFDW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a\r\xE4V[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x80Q\x91\x82\x90\x03\x01\x90\xF3[4\x80\x15a\x02_W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\x02vW`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a\x0F7V[`@\x80Q\x91\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[4\x80\x15a\x02\xA7W`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x02\xBEW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x02\xE5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x02\xF7W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03\x19W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x0FLV[`@\x80Q` \x80\x82R\x83Q\x81\x83\x01R\x83Q\x91\x92\x83\x92\x90\x83\x01\x91\x85\x81\x01\x91\x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x03|W\x81\x81\x01Q\x83\x82\x01R` \x01a\x03dV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x9CW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`@\x81\x10\x15a\x03\xB3W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x03\xD5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xE7W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\tW`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x13d\x94PPPPPV[4\x80\x15a\x04SW`\0\x80\xFD[Pa\x02:`\x04\x806\x03a\x01`\x81\x10\x15a\x04kW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x90\x91\x16\x90`\xC0\x81\x015\x90`\xE0\x81\x015\x15\x15\x90`\xFFa\x01\0\x82\x015\x16\x90a\x01 \x81\x015\x90a\x01@\x015a\x13\x9AV[4\x80\x15a\x04\xDEW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x04\xF5W`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x05\x1CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05.W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05PW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x14\xD8V[4\x80\x15a\x05\x83W`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x05\x9AW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x05\xC1W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\xD3W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05\xF5W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x16iV[4\x80\x15a\x06(W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03a\x01@\x81\x10\x15a\x06@W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x81\x015\x15\x15\x90`\xFF`\xE0\x82\x015\x16\x90a\x01\0\x81\x015\x90a\x01 \x015a\x18\xACV[4\x80\x15a\x06\xA8W`\0\x80\xFD[Pa\x01\xD3`\x04\x806\x03`\xA0\x81\x10\x15a\x06\xBFW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x06\xE6W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\xF8W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\x1AW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x19\xFEV[4\x80\x15a\x07MW`\0\x80\xFD[Pa\x01\xD3`\x04\x806\x03`\xA0\x81\x10\x15a\x07dW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x07\x8BW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x07\x9DW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\xBFW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x1D\x97V[a\x03@`\x04\x806\x03`\x80\x81\x10\x15a\x07\xFCW`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x08\x1EW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x080W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x08RW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a!\x05V[4\x80\x15a\x08\x85W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\x08\x9CW`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a%%V[4\x80\x15a\x08\xBBW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x08\xD2W`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x08\xF9W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\t\x0BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\t-W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a%2V[4\x80\x15a\t`W`\0\x80\xFD[Pa\tia&qV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[4\x80\x15a\t\x9EW`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\t\xB5W`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a&\x95V[4\x80\x15a\t\xD4W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03`\xC0\x81\x10\x15a\t\xEBW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a&\xA2V[a\x01\xD3`\x04\x806\x03`\x80\x81\x10\x15a\n>W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\n`W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\nrW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n\x94W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a(\x82V[4\x80\x15a\n\xC7W`\0\x80\xFD[Pa\x02:`\x04\x806\x03`\xE0\x81\x10\x15a\n\xDEW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x90\x91\x16\x90`\xC0\x015a-eV[4\x80\x15a\x0B1W`\0\x80\xFD[Pa\tia0oV[4\x80\x15a\x0BFW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`@\x81\x10\x15a\x0B]W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x0B\x7FW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0B\x91W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0B\xB3W`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa0\x93\x94PPPPPV[4\x80\x15a\x0B\xFDW`\0\x80\xFD[Pa\x02:`\x04\x806\x03a\x01@\x81\x10\x15a\x0C\x15W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x81\x015\x15\x15\x90`\xFF`\xE0\x82\x015\x16\x90a\x01\0\x81\x015\x90a\x01 \x015a0\xC0V[4\x80\x15a\x0C}W`\0\x80\xFD[Pa\x0C\xE0`\x04\x806\x03a\x01\0\x81\x10\x15a\x0C\x95W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x91`\xC0\x82\x015\x16\x90`\xE0\x015a2\x18V[`@\x80Q\x93\x84R` \x84\x01\x92\x90\x92R\x82\x82\x01RQ\x90\x81\x90\x03``\x01\x90\xF3[a\x0C\xE0`\x04\x806\x03`\xC0\x81\x10\x15a\r\x14W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a3\xA7V[a\x03@`\x04\x806\x03`\x80\x81\x10\x15a\rgW`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\r\x89W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\r\x9BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\r\xBDW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a6\xD3V[`\0\x80\x82B\x81\x10\x15a\x0EWW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x0E\x86\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x8A\x8A0\x8Aa-eV[\x90\x93P\x91Pa\x0E\x96\x89\x86\x85a;\"V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x0F\tW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0F\x1DW=`\0\x80>=`\0\xFD[PPPPa\x0F+\x85\x83a<\xFFV[P\x96P\x96\x94PPPPPV[`\0a\x0FD\x84\x84\x84a><V[\x94\x93PPPPV[``\x81B\x81\x10\x15a\x0F\xBEW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x10#W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x10\xC2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x11 \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\x113W\xFE[` \x02` \x01\x01Q\x10\x15a\x11\x92W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x12W\x86\x86`\0\x81\x81\x10a\x11\xA2W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163a\x12=\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x8A`\0\x81\x81\x10a\x11\xF1W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8B\x8B`\x01\x81\x81\x10a\x12\x1BW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a@\xC6V[\x85`\0\x81Q\x81\x10a\x12JW\xFE[` \x02` \x01\x01QaA\xB1V[a\x12\x96\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP0\x92PaC\x81\x91PPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`\x01\x85Q\x03\x81Q\x81\x10a\x12\xE2W\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x13 W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x134W=`\0\x80>=`\0\xFD[PPPPa\x13Y\x84\x83`\x01\x85Q\x03\x81Q\x81\x10a\x13LW\xFE[` \x02` \x01\x01Qa<\xFFV[P\x96\x95PPPPPPV[``a\x13\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x84aF\x08V[\x90P[\x92\x91PPV[`\0\x80`\0a\x13\xCA\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8F\x8Fa@\xC6V[\x90P`\0\x87a\x13\xD9W\x8Ca\x13\xFBV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8C\x90R`\xFF\x8A\x16`\x84\x82\x01R`\xA4\x81\x01\x89\x90R`\xC4\x81\x01\x88\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x14\x97W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x14\xABW=`\0\x80>=`\0\xFD[PPPPa\x14\xBE\x8F\x8F\x8F\x8F\x8F\x8F\x8Fa-eV[\x80\x94P\x81\x95PPPPP\x9BP\x9B\x99PPPPPPPPPPV[``\x81B\x81\x10\x15a\x15JW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x15\xA8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\x15\xBBW\xFE[` \x02` \x01\x01Q\x10\x15a\x16\x1AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x16*\x86\x86`\0\x81\x81\x10a\x11\xA2W\xFE[a\x13Y\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[``\x81B\x81\x10\x15a\x16\xDBW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x17@W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x17\xDFW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x18=\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P\x86\x82`\0\x81Q\x81\x10a\x18MW\xFE[` \x02` \x01\x01Q\x11\x15a\x11\x92W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80a\x18\xFA\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8D\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90P`\0\x86a\x19\tW\x8Ba\x19+V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8B\x90R`\xFF\x89\x16`\x84\x82\x01R`\xA4\x81\x01\x88\x90R`\xC4\x81\x01\x87\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x19\xC7W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x19\xDBW=`\0\x80>=`\0\xFD[PPPPa\x19\xED\x8D\x8D\x8D\x8D\x8D\x8Da&\xA2V[\x9D\x9CPPPPPPPPPPPPPV[\x80B\x81\x10\x15a\x1AnW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1A\xFD\x85\x85`\0\x81\x81\x10a\x1A~W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163a\x1A\xF7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8A\x8A`\x01\x81\x81\x10a\x12\x1BW\xFE[\x8AaA\xB1V[`\0\x85\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1B-W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x85`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1B\xC6W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1B\xDAW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1B\xF0W`\0\x80\xFD[PQ`@\x80Q` \x88\x81\x02\x82\x81\x01\x82\x01\x90\x93R\x88\x82R\x92\x93Pa\x1C2\x92\x90\x91\x89\x91\x89\x91\x82\x91\x85\x01\x90\x84\x90\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x88\x92PaG\x96\x91PPV[\x86a\x1D6\x82\x88\x88\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1CeW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1D\x12W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1D(W`\0\x80\xFD[PQ\x90c\xFF\xFF\xFF\xFFaK)\x16V[\x10\x15a\x1D\x8DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPPPPPV[\x80B\x81\x10\x15a\x1E\x07W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x85\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1ElW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1F\x0BW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1F\x1B\x85\x85`\0\x81\x81\x10a\x1A~W\xFE[a\x1FY\x85\x85\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP0\x92PaG\x96\x91PPV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q`\0\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x1F\xE9W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\xFDW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a \x13W`\0\x80\xFD[PQ\x90P\x86\x81\x10\x15a pW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a \xE3W`\0\x80\xFD[PZ\xF1\x15\x80\x15a \xF7W=`\0\x80>=`\0\xFD[PPPPa\x1D\x8D\x84\x82a<\xFFV[``\x81B\x81\x10\x15a!wW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x86`\0\x81\x81\x10a!\xBBW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\"ZW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\"\xB8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x004\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\"\xCBW\xFE[` \x02` \x01\x01Q\x10\x15a#*W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x83`\0\x81Q\x81\x10a#sW\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a#\xA6W`\0\x80\xFD[PZ\xF1\x15\x80\x15a#\xBAW=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa$,\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x84`\0\x81Q\x81\x10a$9W\xFE[` \x02` \x01\x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a$\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a$\xBEW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a$\xD4W`\0\x80\xFD[PQa$\xDCW\xFE[a%\x1B\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[P\x95\x94PPPPPV[`\0a\x0FD\x84\x84\x84aK\x9BV[``\x81B\x81\x10\x15a%\xA4W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a&\x02\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P\x86\x82`\0\x81Q\x81\x10a&\x12W\xFE[` \x02` \x01\x01Q\x11\x15a\x16\x1AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0a\x0FD\x84\x84\x84aL\xBFV[`\0\x81B\x81\x10\x15a'\x14W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a'C\x88\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89\x890\x89a-eV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x91\x94Pa'\xED\x92P\x8A\x91\x87\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a'\xBCW`\0\x80\xFD[PZ\xFA\x15\x80\x15a'\xD0W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a'\xE6W`\0\x80\xFD[PQa;\"V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a(`W`\0\x80\xFD[PZ\xF1\x15\x80\x15a(tW=`\0\x80>=`\0\xFD[PPPPa\x13Y\x84\x83a<\xFFV[\x80B\x81\x10\x15a(\xF2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x85`\0\x81\x81\x10a)6W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a)\xD5W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x004\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a*BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a*VW=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa*\xC8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a+2W`\0\x80\xFD[PZ\xF1\x15\x80\x15a+FW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a+\\W`\0\x80\xFD[PQa+dW\xFE[`\0\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a+\x94W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x86`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a,-W`\0\x80\xFD[PZ\xFA\x15\x80\x15a,AW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a,WW`\0\x80\xFD[PQ`@\x80Q` \x89\x81\x02\x82\x81\x01\x82\x01\x90\x93R\x89\x82R\x92\x93Pa,\x99\x92\x90\x91\x8A\x91\x8A\x91\x82\x91\x85\x01\x90\x84\x90\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaG\x96\x91PPV[\x87a\x1D6\x82\x89\x89\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a,\xCCW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x89`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[`\0\x80\x82B\x81\x10\x15a-\xD8W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0a.\x05\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8Ca@\xC6V[`@\x80Q\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01\x81\x90R`D\x82\x01\x8D\x90R\x91Q\x92\x93P\x90\x91c#\xB8r\xDD\x91`d\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81`\0\x87\x80;\x15\x80\x15a.\x86W`\0\x80\xFD[PZ\xF1\x15\x80\x15a.\x9AW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a.\xB0W`\0\x80\xFD[PP`@\x80Q\x7F\x89\xAF\xCBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x82Q`\0\x93\x84\x93\x92\x86\x16\x92c\x89\xAF\xCBD\x92`$\x80\x83\x01\x93\x92\x82\x90\x03\x01\x81\x87\x87\x80;\x15\x80\x15a/#W`\0\x80\xFD[PZ\xF1\x15\x80\x15a/7W=`\0\x80>=`\0\xFD[PPPP`@Q=`@\x81\x10\x15a/MW`\0\x80\xFD[P\x80Q` \x90\x91\x01Q\x90\x92P\x90P`\0a/g\x8E\x8EaM\x9FV[P\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a/\xA4W\x81\x83a/\xA7V[\x82\x82[\x90\x97P\x95P\x8A\x87\x10\x15a0\x05W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT\xBF`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x89\x86\x10\x15a0^W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT%`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPP\x97P\x97\x95PPPPPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[``a\x13\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x84a?`V[`\0\x80`\0a1\x10\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8E\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90P`\0\x87a1\x1FW\x8Ca1AV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8C\x90R`\xFF\x8A\x16`\x84\x82\x01R`\xA4\x81\x01\x89\x90R`\xC4\x81\x01\x88\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a1\xDDW`\0\x80\xFD[PZ\xF1\x15\x80\x15a1\xF1W=`\0\x80>=`\0\xFD[PPPPa2\x03\x8E\x8E\x8E\x8E\x8E\x8Ea\r\xE4V[\x90\x9F\x90\x9EP\x9CPPPPPPPPPPPPPV[`\0\x80`\0\x83B\x81\x10\x15a2\x8DW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a2\x9B\x8C\x8C\x8C\x8C\x8C\x8CaN\xF2V[\x90\x94P\x92P`\0a2\xCD\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8E\x8Ea@\xC6V[\x90Pa2\xDB\x8D3\x83\x88aA\xB1V[a2\xE7\x8C3\x83\x87aA\xB1V[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cjbxB\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a3fW`\0\x80\xFD[PZ\xF1\x15\x80\x15a3zW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a3\x90W`\0\x80\xFD[PQ\x94\x9D\x93\x9CP\x93\x9AP\x91\x98PPPPPPPPPV[`\0\x80`\0\x83B\x81\x10\x15a4\x1CW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a4J\x8A\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B4\x8C\x8CaN\xF2V[\x90\x94P\x92P`\0a4\x9C\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90Pa4\xAA\x8B3\x83\x88aA\xB1V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x85`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a5\x12W`\0\x80\xFD[PZ\xF1\x15\x80\x15a5&W=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBB\x82\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a5\xD2W`\0\x80\xFD[PZ\xF1\x15\x80\x15a5\xE6W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a5\xFCW`\0\x80\xFD[PQa6\x04W\xFE[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cjbxB\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a6\x83W`\0\x80\xFD[PZ\xF1\x15\x80\x15a6\x97W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a6\xADW`\0\x80\xFD[PQ\x92P4\x84\x10\x15a6\xC5Wa6\xC53\x854\x03a<\xFFV[PP\x96P\x96P\x96\x93PPPPV[``\x81B\x81\x10\x15a7EW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x86`\0\x81\x81\x10a7\x89W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a8(W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a8\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P4\x82`\0\x81Q\x81\x10a8\x96W\xFE[` \x02` \x01\x01Q\x11\x15a8\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x83`\0\x81Q\x81\x10a9>W\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a9qW`\0\x80\xFD[PZ\xF1\x15\x80\x15a9\x85W=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa9\xF7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x84`\0\x81Q\x81\x10a:\x04W\xFE[` \x02` \x01\x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a:uW`\0\x80\xFD[PZ\xF1\x15\x80\x15a:\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a:\x9FW`\0\x80\xFD[PQa:\xA7W\xFE[a:\xE6\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[\x81`\0\x81Q\x81\x10a:\xF3W\xFE[` \x02` \x01\x01Q4\x11\x15a%\x1BWa%\x1B3\x83`\0\x81Q\x81\x10a;\x13W\xFE[` \x02` \x01\x01Q4\x03a<\xFFV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x83R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x82Q`\0\x94``\x94\x93\x89\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10a;\xF8W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a;\xBBV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a<ZW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a<_V[``\x91P[P\x91P\x91P\x81\x80\x15a<\x8DWP\x80Q\x15\x80a<\x8DWP\x80\x80` \x01\x90Q` \x81\x10\x15a<\x8AW`\0\x80\xFD[PQ[a<\xF8W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FTransferHelper: TRANSFER_FAILED\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPPPPV[`@\x80Q`\0\x80\x82R` \x82\x01\x90\x92Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90\x83\x90`@Q\x80\x82\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a=vW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a=9V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a=\xD8W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a=\xDDV[``\x91P[PP\x90P\x80a>7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`#\x81R` \x01\x80aT\xE5`#\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPV[`\0\x80\x84\x11a>\x96W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aUW`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15a>\xA6WP`\0\x82\x11[a>\xFBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0a?\x0F\x85a\x03\xE5c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0a?#\x82\x85c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0a?I\x83a?=\x88a\x03\xE8c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90c\xFF\xFF\xFF\xFFaRy\x16V[\x90P\x80\x82\x81a?TW\xFE[\x04\x97\x96PPPPPPPV[```\x02\x82Q\x10\x15a?\xD3W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: INVALID_PATH\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?\xEBW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a@\x15W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82\x81`\0\x81Q\x81\x10a@&W\xFE[` \x02` \x01\x01\x81\x81RPP`\0[`\x01\x83Q\x03\x81\x10\x15a@\xBEW`\0\x80a@x\x87\x86\x85\x81Q\x81\x10a@TW\xFE[` \x02` \x01\x01Q\x87\x86`\x01\x01\x81Q\x81\x10a@kW\xFE[` \x02` \x01\x01QaR\xEBV[\x91P\x91Pa@\x9A\x84\x84\x81Q\x81\x10a@\x8BW\xFE[` \x02` \x01\x01Q\x83\x83a><V[\x84\x84`\x01\x01\x81Q\x81\x10a@\xA9W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP`\x01\x01a@5V[P\x93\x92PPPV[`\0\x80`\0a@\xD5\x85\x85aM\x9FV[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0``\x94\x85\x1B\x81\x16` \x80\x84\x01\x91\x90\x91R\x93\x85\x1B\x81\x16`4\x83\x01R\x82Q`(\x81\x84\x03\x01\x81R`H\x83\x01\x84R\x80Q\x90\x85\x01 \x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`h\x84\x01R\x9A\x90\x94\x1B\x90\x93\x16`i\x84\x01R`}\x83\x01\x98\x90\x98R\x7F\x96\xE8\xACBw\x19\x8F\xF8\xB6\xF7\x85G\x8A\xA9\xA3\x9F@<\xB7h\xDD\x02\xCB\xEE2l>}\xA3H\x84_`\x9D\x80\x84\x01\x91\x90\x91R\x88Q\x80\x84\x03\x90\x91\x01\x81R`\xBD\x90\x92\x01\x90\x97R\x80Q\x96\x01\x95\x90\x95 \x95\x94PPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x81\x16`D\x83\x01R`d\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`\x84\x90\x92\x01\x83R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x82Q`\0\x94``\x94\x93\x8A\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10aB\x8FW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01aBRV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14aB\xF1W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>aB\xF6V[``\x91P[P\x91P\x91P\x81\x80\x15aC$WP\x80Q\x15\x80aC$WP\x80\x80` \x01\x90Q` \x81\x10\x15aC!W`\0\x80\xFD[PQ[aCyW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`$\x81R` \x01\x80aU3`$\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPPPV[`\0[`\x01\x83Q\x03\x81\x10\x15aF\x02W`\0\x80\x84\x83\x81Q\x81\x10aC\x9FW\xFE[` \x02` \x01\x01Q\x85\x84`\x01\x01\x81Q\x81\x10aC\xB6W\xFE[` \x02` \x01\x01Q\x91P\x91P`\0aC\xCE\x83\x83aM\x9FV[P\x90P`\0\x87\x85`\x01\x01\x81Q\x81\x10aC\xE2W\xFE[` \x02` \x01\x01Q\x90P`\0\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aD*W\x82`\0aD.V[`\0\x83[\x91P\x91P`\0`\x02\x8AQ\x03\x88\x10aDEW\x88aD\x86V[aD\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87\x8C\x8B`\x02\x01\x81Q\x81\x10aDyW\xFE[` \x02` \x01\x01Qa@\xC6V[\x90PaD\xB3\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88a@\xC6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x02,\r\x9F\x84\x84\x84`\0`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15aD\xFDW` \x82\x01\x81\x806\x837\x01\x90P[P`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x85\x81R` \x01\x84\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15aE\x88W\x81\x81\x01Q\x83\x82\x01R` \x01aEpV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15aE\xB5W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aE\xD7W`\0\x80\xFD[PZ\xF1\x15\x80\x15aE\xEBW=`\0\x80>=`\0\xFD[PP`\x01\x90\x99\x01\x98PaC\x84\x97PPPPPPPPV[PPPPV[```\x02\x82Q\x10\x15aF{W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: INVALID_PATH\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aF\x93W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aF\xBDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82\x81`\x01\x83Q\x03\x81Q\x81\x10aF\xD1W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01[\x80\x15a@\xBEW`\0\x80aG1\x87\x86`\x01\x86\x03\x81Q\x81\x10aG\x1DW\xFE[` \x02` \x01\x01Q\x87\x86\x81Q\x81\x10a@kW\xFE[\x91P\x91PaGS\x84\x84\x81Q\x81\x10aGDW\xFE[` \x02` \x01\x01Q\x83\x83aK\x9BV[\x84`\x01\x85\x03\x81Q\x81\x10aGbW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01aG\x01V[`\0[`\x01\x83Q\x03\x81\x10\x15a>7W`\0\x80\x84\x83\x81Q\x81\x10aG\xB4W\xFE[` \x02` \x01\x01Q\x85\x84`\x01\x01\x81Q\x81\x10aG\xCBW\xFE[` \x02` \x01\x01Q\x91P\x91P`\0aG\xE3\x83\x83aM\x9FV[P\x90P`\0aH\x13\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85\x85a@\xC6V[\x90P`\0\x80`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aHaW`\0\x80\xFD[PZ\xFA\x15\x80\x15aHuW=`\0\x80>=`\0\xFD[PPPP`@Q=``\x81\x10\x15aH\x8BW`\0\x80\xFD[P\x80Q` \x90\x91\x01Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93P\x16\x90P`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x81\x16\x90\x89\x16\x14aH\xD5W\x82\x84aH\xD8V[\x83\x83[\x91P\x91PaI]\x82\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x8A`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[\x95PaIj\x86\x83\x83a><V[\x94PPPPP`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aI\xAEW\x82`\0aI\xB2V[`\0\x83[\x91P\x91P`\0`\x02\x8CQ\x03\x8A\x10aI\xC9W\x8AaI\xFDV[aI\xFD\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x8E\x8D`\x02\x01\x81Q\x81\x10aDyW\xFE[`@\x80Q`\0\x80\x82R` \x82\x01\x92\x83\x90R\x7F\x02,\r\x9F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`$\x82\x01\x87\x81R`D\x83\x01\x87\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16`d\x85\x01R`\x80`\x84\x85\x01\x90\x81R\x84Q`\xA4\x86\x01\x81\x90R\x96\x97P\x90\x8C\x16\x95c\x02,\r\x9F\x95\x8A\x95\x8A\x95\x8A\x95\x91\x94\x91\x93\x91\x92`\xC4\x86\x01\x92\x90\x91\x81\x90\x84\x90\x84\x90[\x83\x81\x10\x15aJ\xADW\x81\x81\x01Q\x83\x82\x01R` \x01aJ\x95V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15aJ\xDAW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aJ\xFCW`\0\x80\xFD[PZ\xF1\x15\x80\x15aK\x10W=`\0\x80>=`\0\xFD[PP`\x01\x90\x9B\x01\x9APaG\x99\x99PPPPPPPPPPV[\x80\x82\x03\x82\x81\x11\x15a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7Fds-math-sub-underflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80\x84\x11aK\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`,\x81R` \x01\x80aS\xD4`,\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15aL\x05WP`\0\x82\x11[aLZW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0aL~a\x03\xE8aLr\x86\x88c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0aL\x98a\x03\xE5aLr\x86\x89c\xFF\xFF\xFF\xFFaK)\x16V[\x90PaL\xB5`\x01\x82\x84\x81aL\xA8W\xFE[\x04\x90c\xFF\xFF\xFF\xFFaRy\x16V[\x96\x95PPPPPPV[`\0\x80\x84\x11aM\x19W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80aTs`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15aM)WP`\0\x82\x11[aM~W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82aM\x8F\x85\x84c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x81aM\x96W\xFE[\x04\x94\x93PPPPV[`\0\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aN'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80aT\0`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10aNaW\x82\x84aNdV[\x83\x83[\x90\x92P\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16aN\xEBW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: ZERO_ADDRESS\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x92P\x92\x90PV[`@\x80Q\x7F\xE6\xA49\x05\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x87\x81\x16`$\x83\x01R\x91Q`\0\x92\x83\x92\x83\x92\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16\x91c\xE6\xA49\x05\x91`D\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15aO\x92W`\0\x80\xFD[PZ\xFA\x15\x80\x15aO\xA6W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15aO\xBCW`\0\x80\xFD[PQs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aP\xA2W`@\x80Q\x7F\xC9\xC6S\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x81\x16`\x04\x83\x01R\x89\x81\x16`$\x83\x01R\x91Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16\x91c\xC9\xC6S\x96\x91`D\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81`\0\x87\x80;\x15\x80\x15aPuW`\0\x80\xFD[PZ\xF1\x15\x80\x15aP\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15aP\x9FW`\0\x80\xFD[PP[`\0\x80aP\xD0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x8BaR\xEBV[\x91P\x91P\x81`\0\x14\x80\x15aP\xE2WP\x80\x15[\x15aP\xF2W\x87\x93P\x86\x92PaQ\xE6V[`\0aP\xFF\x89\x84\x84aL\xBFV[\x90P\x87\x81\x11aQlW\x85\x81\x10\x15aQaW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT%`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x88\x94P\x92P\x82aQ\xE4V[`\0aQy\x89\x84\x86aL\xBFV[\x90P\x89\x81\x11\x15aQ\x85W\xFE[\x87\x81\x10\x15aQ\xDEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT\xBF`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x94P\x87\x93P[P[PP\x96P\x96\x94PPPPPV[`\0\x81\x15\x80aR\x0EWPP\x80\x82\x02\x82\x82\x82\x81aR\x0BW\xFE[\x04\x14[a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-mul-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x80\x82\x01\x82\x81\x10\x15a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-add-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80`\0aR\xFA\x85\x85aM\x9FV[P\x90P`\0\x80aS\x0B\x88\x88\x88a@\xC6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aSPW`\0\x80\xFD[PZ\xFA\x15\x80\x15aSdW=`\0\x80>=`\0\xFD[PPPP`@Q=``\x81\x10\x15aSzW`\0\x80\xFD[P\x80Q` \x90\x91\x01Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93P\x16\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x81\x16\x90\x84\x16\x14aS\xC1W\x80\x82aS\xC4V[\x81\x81[\x90\x99\x90\x98P\x96PPPPPPPV\xFEUniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNTUniswapV2Library: IDENTICAL_ADDRESSESUniswapV2Router: INSUFFICIENT_B_AMOUNTUniswapV2Library: INSUFFICIENT_LIQUIDITYUniswapV2Library: INSUFFICIENT_AMOUNTUniswapV2Router: EXCESSIVE_INPUT_AMOUNTUniswapV2Router: INSUFFICIENT_A_AMOUNTTransferHelper: ETH_TRANSFER_FAILEDUniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNTTransferHelper: TRANSFER_FROM_FAILEDUniswapV2Library: INSUFFICIENT_INPUT_AMOUNT\xA2dipfsX\"\x12 m\xD6\xE0<K,\n\x8EU!I&\"z\xE9\xE2\xD6\xF9\xFE\xC2\xCEt\xA6DmaZ\xFA5\\\x84\xF3dsolcC\0\x06\x06\x003",
+    );
+    /**Constructor`.
+    ```solidity
+    constructor(address _factory, address _WETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _factory: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _WETH: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._factory, value._WETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _factory: tuple.0,
+                        _WETH: tuple.1,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._factory,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._WETH,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
+    ```solidity
+    function WETH() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
+    ```solidity
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
+            const SIGNATURE: &'static str =
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
+    ```solidity
+    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct addLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.amountTokenDesired,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        amountTokenDesired: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH, value.liquidity)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                        liquidity: tuple.2,
+                    }
+                }
+            }
+        }
+        impl addLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for addLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = addLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
+            const SIGNATURE: &'static str =
+                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                addLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
+    ```solidity
+    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountInReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInCall) -> Self {
+                    (value.amountOut, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountInReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
+            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountInReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountInReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
+    ```solidity
+    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountOutReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutCall) -> Self {
+                    (value.amountIn, value.reserveIn, value.reserveOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        reserveIn: tuple.1,
+                        reserveOut: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountOutReturn) -> Self {
+                    (value.amountOut,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountOut: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
+            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountOutReturn = r.into();
+                        r.amountOut
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountOutReturn = r.into();
+                    r.amountOut
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
+    ```solidity
+    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsInReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInCall) -> Self {
+                    (value.amountOut, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsInReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsInCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
+            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsInReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsInReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
+    ```solidity
+    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmountsOutReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutCall) -> Self {
+                    (value.amountIn, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        path: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmountsOutReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmountsOutCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
+            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getAmountsOutReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getAmountsOutReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
+    ```solidity
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteCall {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteReturn {
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountB: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: quoteReturn = r.into();
+                        r.amountB
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: quoteReturn = r.into();
+                    r.amountB
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
+    ```solidity
+    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
+    ```solidity
+    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = removeLiquidityETHReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
+    ```solidity
+    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
+    /// uint256,uint256,address,
+    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountTokenMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETHMin,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
+    ```solidity
+    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
+    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
+                    (value.amountToken, value.amountETH)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountToken: tuple.0,
+                        amountETH: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityETHWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountETH,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityETHWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
+            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
+                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityETHWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
+    ```solidity
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
+    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
+        #[allow(missing_docs)]
+        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+                ) -> Self {
+                    (
+                        value.token,
+                        value.liquidity,
+                        value.amountTokenMin,
+                        value.amountETHMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token: tuple.0,
+                        liquidity: tuple.1,
+                        amountTokenMin: tuple.2,
+                        amountETHMin: tuple.3,
+                        to: tuple.4,
+                        deadline: tuple.5,
+                        approveMax: tuple.6,
+                        v: tuple.7,
+                        r: tuple.8,
+                        s: tuple.9,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl
+                ::core::convert::From<
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                > for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    (value.amountETH,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountETH: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
+            const SIGNATURE: &'static str =
+                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
+                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                            r.into();
+                        r.amountETH
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
+                        r.into();
+                    r.amountETH
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
+    ```solidity
+    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenB: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub approveMax: bool,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
+    /// address,uint256,bool,uint8,bytes32,
+    /// bytes32)`](removeLiquidityWithPermitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct removeLiquidityWithPermitReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitCall) -> Self {
+                    (
+                        value.tokenA,
+                        value.tokenB,
+                        value.liquidity,
+                        value.amountAMin,
+                        value.amountBMin,
+                        value.to,
+                        value.deadline,
+                        value.approveMax,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        liquidity: tuple.2,
+                        amountAMin: tuple.3,
+                        amountBMin: tuple.4,
+                        to: tuple.5,
+                        deadline: tuple.6,
+                        approveMax: tuple.7,
+                        v: tuple.8,
+                        r: tuple.9,
+                        s: tuple.10,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: removeLiquidityWithPermitReturn) -> Self {
+                    (value.amountA, value.amountB)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                    }
+                }
+            }
+        }
+        impl removeLiquidityWithPermitReturn {
+            fn _tokenize(
+                &self,
+            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = removeLiquidityWithPermitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
+            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
+                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
+                                             bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approveMax,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                removeLiquidityWithPermitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
+    ```solidity
+    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapETHForExactTokens(uint256,address[],address,
+    /// uint256)`](swapETHForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapETHForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensCall) -> Self {
+                    (value.amountOut, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapETHForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
+            const SIGNATURE: &'static str =
+                "swapETHForExactTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapETHForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapETHForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
+    ```solidity
+    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokens(uint256,address[],address,
+    /// uint256)`](swapExactETHForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactETHForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokens(uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactETHForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactETHForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
+    ```solidity
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
+    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (value.amountOutMin, value.path, value.to, value.deadline)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOutMin: tuple.0,
+                        path: tuple.1,
+                        to: tuple.2,
+                        deadline: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
+                 uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    ```solidity
+    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    ```solidity
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    ```solidity
+    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapExactTokensForTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapExactTokensForTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapExactTokensForTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapExactTokensForTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    ```solidity
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
+    /// address[],address,
+    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
+                    (
+                        value.amountIn,
+                        value.amountOutMin,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        amountOutMin: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
+                for UnderlyingRustTuple<'_>
+            {
+                fn from(
+                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
+                ) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>>
+                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
+            {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
+            fn _tokenize(
+                &self,
+            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
+                '_,
+            >{
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
+            const SIGNATURE: &'static str =
+                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
+                 address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    ```solidity
+    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactETHCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactETHReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactETHReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactETHReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactETHReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swapTokensForExactTokens(uint256,uint256,address[],address,uint256)` and selector `0x8803dbee`.
+    ```solidity
+    function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensCall {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swapTokensForExactTokens(uint256,uint256,address[],address,
+    /// uint256)`](swapTokensForExactTokensCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapTokensForExactTokensReturn {
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensCall) -> Self {
+                    (
+                        value.amountOut,
+                        value.amountInMax,
+                        value.path,
+                        value.to,
+                        value.deadline,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        amountInMax: tuple.1,
+                        path: tuple.2,
+                        to: tuple.3,
+                        deadline: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapTokensForExactTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapTokensForExactTokensReturn) -> Self {
+                    (value.amounts,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactTokensReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amounts: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapTokensForExactTokensCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 3u8, 219u8, 238u8];
+            const SIGNATURE: &'static str =
+                "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: swapTokensForExactTokensReturn = r.into();
+                        r.amounts
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: swapTokensForExactTokensReturn = r.into();
+                    r.amounts
+                })
+            }
+        }
+    };
+    ///Container for all the [`UniswapV2Router02`](self) function calls.
+    #[derive(Clone)]
+    pub enum UniswapV2Router02Calls {
+        #[allow(missing_docs)]
+        WETH(WETHCall),
+        #[allow(missing_docs)]
+        addLiquidity(addLiquidityCall),
+        #[allow(missing_docs)]
+        addLiquidityETH(addLiquidityETHCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        getAmountIn(getAmountInCall),
+        #[allow(missing_docs)]
+        getAmountOut(getAmountOutCall),
+        #[allow(missing_docs)]
+        getAmountsIn(getAmountsInCall),
+        #[allow(missing_docs)]
+        getAmountsOut(getAmountsOutCall),
+        #[allow(missing_docs)]
+        quote(quoteCall),
+        #[allow(missing_docs)]
+        removeLiquidity(removeLiquidityCall),
+        #[allow(missing_docs)]
+        removeLiquidityETH(removeLiquidityETHCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHSupportingFeeOnTransferTokens(
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
+        #[allow(missing_docs)]
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
+        #[allow(missing_docs)]
+        swapETHForExactTokens(swapETHForExactTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokens(swapExactETHForTokensCall),
+        #[allow(missing_docs)]
+        swapExactETHForTokensSupportingFeeOnTransferTokens(
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForETH(swapExactTokensForETHCall),
+        #[allow(missing_docs)]
+        swapExactTokensForETHSupportingFeeOnTransferTokens(
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapExactTokensForTokens(swapExactTokensForTokensCall),
+        #[allow(missing_docs)]
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+        ),
+        #[allow(missing_docs)]
+        swapTokensForExactETH(swapTokensForExactETHCall),
+        #[allow(missing_docs)]
+        swapTokensForExactTokens(swapTokensForExactTokensCall),
+    }
+    impl UniswapV2Router02Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [2u8, 117u8, 28u8, 236u8],
+            [5u8, 77u8, 80u8, 212u8],
+            [24u8, 203u8, 175u8, 229u8],
+            [31u8, 0u8, 202u8, 116u8],
+            [33u8, 149u8, 153u8, 92u8],
+            [56u8, 237u8, 23u8, 57u8],
+            [74u8, 37u8, 217u8, 74u8],
+            [91u8, 13u8, 89u8, 132u8],
+            [92u8, 17u8, 215u8, 149u8],
+            [121u8, 26u8, 201u8, 71u8],
+            [127u8, 243u8, 106u8, 181u8],
+            [133u8, 248u8, 194u8, 89u8],
+            [136u8, 3u8, 219u8, 238u8],
+            [173u8, 92u8, 70u8, 72u8],
+            [173u8, 97u8, 93u8, 236u8],
+            [175u8, 41u8, 121u8, 235u8],
+            [182u8, 249u8, 222u8, 149u8],
+            [186u8, 162u8, 171u8, 222u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 108u8, 166u8, 31u8],
+            [222u8, 217u8, 56u8, 42u8],
+            [232u8, 227u8, 55u8, 0u8],
+            [243u8, 5u8, 215u8, 25u8],
+            [251u8, 59u8, 219u8, 65u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(removeLiquidityETH),
+            ::core::stringify!(getAmountOut),
+            ::core::stringify!(swapExactTokensForETH),
+            ::core::stringify!(getAmountsIn),
+            ::core::stringify!(removeLiquidityWithPermit),
+            ::core::stringify!(swapExactTokensForTokens),
+            ::core::stringify!(swapTokensForExactETH),
+            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokens),
+            ::core::stringify!(getAmountIn),
+            ::core::stringify!(swapTokensForExactTokens),
+            ::core::stringify!(WETH),
+            ::core::stringify!(quote),
+            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
+            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
+            ::core::stringify!(removeLiquidity),
+            ::core::stringify!(factory),
+            ::core::stringify!(getAmountsOut),
+            ::core::stringify!(removeLiquidityETHWithPermit),
+            ::core::stringify!(addLiquidity),
+            ::core::stringify!(addLiquidityETH),
+            ::core::stringify!(swapETHForExactTokens),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for UniswapV2Router02Calls {
+        const COUNT: usize = 24usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "UniswapV2Router02Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::addLiquidityETH(_) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmountIn(_) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountOut(_) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsIn(_) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getAmountsOut(_) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::removeLiquidity(_) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETH(_) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermit(_) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::removeLiquidityWithPermit(_) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapETHForExactTokens(_) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokens(_) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETH(_) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokens(_) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactETH(_) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls>] =
+                &[
+                    {
+                        fn removeLiquidityETH(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::removeLiquidityETH)
+                        }
+                        removeLiquidityETH
+                    },
+                    {
+                        fn getAmountOut(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::getAmountOut)
+                        }
+                        getAmountOut
+                    },
+                    {
+                        fn swapExactTokensForETH(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapExactTokensForETH)
+                        }
+                        swapExactTokensForETH
+                    },
+                    {
+                        fn getAmountsIn(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::getAmountsIn)
+                        }
+                        getAmountsIn
+                    },
+                    {
+                        fn removeLiquidityWithPermit(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::removeLiquidityWithPermit)
+                        }
+                        removeLiquidityWithPermit
+                    },
+                    {
+                        fn swapExactTokensForTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapExactTokensForTokens)
+                        }
+                        swapExactTokensForTokens
+                    },
+                    {
+                        fn swapTokensForExactETH(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapTokensForExactETH)
+                        }
+                        swapTokensForExactETH
+                    },
+                    {
+                        fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                        }
+                        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                    },
+                    {
+                        fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                        }
+                        swapExactTokensForTokensSupportingFeeOnTransferTokens
+                    },
+                    {
+                        fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                        }
+                        swapExactTokensForETHSupportingFeeOnTransferTokens
+                    },
+                    {
+                        fn swapExactETHForTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapExactETHForTokens)
+                        }
+                        swapExactETHForTokens
+                    },
+                    {
+                        fn getAmountIn(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::getAmountIn)
+                        }
+                        getAmountIn
+                    },
+                    {
+                        fn swapTokensForExactTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapTokensForExactTokens)
+                        }
+                        swapTokensForExactTokens
+                    },
+                    {
+                        fn WETH(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                            <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::WETH)
+                        }
+                        WETH
+                    },
+                    {
+                        fn quote(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                            <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::quote)
+                        }
+                        quote
+                    },
+                    {
+                        fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                        }
+                        removeLiquidityETHSupportingFeeOnTransferTokens
+                    },
+                    {
+                        fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                        }
+                        swapExactETHForTokensSupportingFeeOnTransferTokens
+                    },
+                    {
+                        fn removeLiquidity(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::removeLiquidity)
+                        }
+                        removeLiquidity
+                    },
+                    {
+                        fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                            <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::factory)
+                        }
+                        factory
+                    },
+                    {
+                        fn getAmountsOut(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::getAmountsOut)
+                        }
+                        getAmountsOut
+                    },
+                    {
+                        fn removeLiquidityETHWithPermit(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::removeLiquidityETHWithPermit)
+                        }
+                        removeLiquidityETHWithPermit
+                    },
+                    {
+                        fn addLiquidity(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::addLiquidity)
+                        }
+                        addLiquidity
+                    },
+                    {
+                        fn addLiquidityETH(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV2Router02Calls::addLiquidityETH)
+                        }
+                        addLiquidityETH
+                    },
+                    {
+                        fn swapETHForExactTokens(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
+                        {
+                            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapETHForExactTokens)
+                        }
+                        swapETHForExactTokens
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                UniswapV2Router02Calls,
+            >] = &[
+                {
+                    fn removeLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::removeLiquidityETH)
+                    }
+                    removeLiquidityETH
+                },
+                {
+                    fn getAmountOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2Router02Calls::getAmountOut)
+                    }
+                    getAmountOut
+                },
+                {
+                    fn swapExactTokensForETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapExactTokensForETH)
+                    }
+                    swapExactTokensForETH
+                },
+                {
+                    fn getAmountsIn(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2Router02Calls::getAmountsIn)
+                    }
+                    getAmountsIn
+                },
+                {
+                    fn removeLiquidityWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::removeLiquidityWithPermit)
+                    }
+                    removeLiquidityWithPermit
+                },
+                {
+                    fn swapExactTokensForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapExactTokensForTokens)
+                    }
+                    swapExactTokensForTokens
+                },
+                {
+                    fn swapTokensForExactETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapTokensForExactETH)
+                    }
+                    swapTokensForExactETH
+                },
+                {
+                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactTokensForETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapExactETHForTokens)
+                    }
+                    swapExactETHForTokens
+                },
+                {
+                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2Router02Calls::getAmountIn)
+                    }
+                    getAmountIn
+                },
+                {
+                    fn swapTokensForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapTokensForExactTokens)
+                    }
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2Router02Calls::WETH)
+                    }
+                    WETH
+                },
+                {
+                    fn quote(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2Router02Calls::quote)
+                    }
+                    quote
+                },
+                {
+                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    removeLiquidityETHSupportingFeeOnTransferTokens
+                },
+                {
+                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                UniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
+                            )
+                    }
+                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                },
+                {
+                    fn removeLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2Router02Calls::removeLiquidity)
+                    }
+                    removeLiquidity
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV2Router02Calls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn getAmountsOut(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2Router02Calls::getAmountsOut)
+                    }
+                    getAmountsOut
+                },
+                {
+                    fn removeLiquidityETHWithPermit(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::removeLiquidityETHWithPermit)
+                    }
+                    removeLiquidityETHWithPermit
+                },
+                {
+                    fn addLiquidity(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2Router02Calls::addLiquidity)
+                    }
+                    addLiquidity
+                },
+                {
+                    fn addLiquidityETH(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV2Router02Calls::addLiquidityETH)
+                    }
+                    addLiquidityETH
+                },
+                {
+                    fn swapETHForExactTokens(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
+                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV2Router02Calls::swapETHForExactTokens)
+                    }
+                    swapETHForExactTokens
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH(inner) => {
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::addLiquidityETH(inner) => {
+                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::getAmountIn(inner) => {
+                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountOut(inner) => {
+                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsIn(inner) => {
+                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::getAmountsOut(inner) => {
+                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::removeLiquidity(inner) => {
+                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETH(inner) => {
+                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
+                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermit(inner) => {
+                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+                    inner,
+                ) => {
+                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::removeLiquidityWithPermit(inner) => {
+                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapETHForExactTokens(inner) => {
+                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokens(inner) => {
+                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETH(inner) => {
+                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokens(inner) => {
+                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
+                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactETH(inner) => {
+                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swapTokensForExactTokens(inner) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`UniswapV2Router02`](self) contract instance.
+
+    See the [wrapper's documentation](`UniswapV2Router02Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> UniswapV2Router02Instance<P, N> {
+        UniswapV2Router02Instance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _factory: alloy_sol_types::private::Address,
+        _WETH: alloy_sol_types::private::Address,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<UniswapV2Router02Instance<P, N>>>
+    {
+        UniswapV2Router02Instance::<P, N>::deploy(__provider, _factory, _WETH)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _factory: alloy_sol_types::private::Address,
+        _WETH: alloy_sol_types::private::Address,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        UniswapV2Router02Instance::<P, N>::deploy_builder(__provider, _factory, _WETH)
+    }
+    /**A [`UniswapV2Router02`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`UniswapV2Router02`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct UniswapV2Router02Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for UniswapV2Router02Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("UniswapV2Router02Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV2Router02Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`UniswapV2Router02`](self) contract instance.
+
+        See the [wrapper's documentation](`UniswapV2Router02Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _factory: alloy_sol_types::private::Address,
+            _WETH: alloy_sol_types::private::Address,
+        ) -> alloy_contract::Result<UniswapV2Router02Instance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider, _factory, _WETH);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _factory: alloy_sol_types::private::Address,
+            _WETH: alloy_sol_types::private::Address,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        _factory,
+                        _WETH,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> UniswapV2Router02Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> UniswapV2Router02Instance<P, N> {
+            UniswapV2Router02Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV2Router02Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH`] function.
+        pub fn WETH(&self) -> alloy_contract::SolCallBuilder<&P, WETHCall, N> {
+            self.call_builder(&WETHCall)
+        }
+
+        ///Creates a new call builder for the [`addLiquidity`] function.
+        pub fn addLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityCall, N> {
+            self.call_builder(&addLiquidityCall {
+                tokenA,
+                tokenB,
+                amountADesired,
+                amountBDesired,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`addLiquidityETH`] function.
+        pub fn addLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
+            self.call_builder(&addLiquidityETHCall {
+                token,
+                amountTokenDesired,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`getAmountIn`] function.
+        pub fn getAmountIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
+            self.call_builder(&getAmountInCall {
+                amountOut,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountOut`] function.
+        pub fn getAmountOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
+            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
+            self.call_builder(&getAmountOutCall {
+                amountIn,
+                reserveIn,
+                reserveOut,
+            })
+        }
+
+        ///Creates a new call builder for the [`getAmountsIn`] function.
+        pub fn getAmountsIn(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
+            self.call_builder(&getAmountsInCall { amountOut, path })
+        }
+
+        ///Creates a new call builder for the [`getAmountsOut`] function.
+        pub fn getAmountsOut(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
+            self.call_builder(&getAmountsOutCall { amountIn, path })
+        }
+
+        ///Creates a new call builder for the [`quote`] function.
+        pub fn quote(
+            &self,
+            amountA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveA: alloy_sol_types::private::primitives::aliases::U256,
+            reserveB: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteCall, N> {
+            self.call_builder(&quoteCall {
+                amountA,
+                reserveA,
+                reserveB,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidity`] function.
+        pub fn removeLiquidity(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
+            self.call_builder(&removeLiquidityCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETH`] function.
+        pub fn removeLiquidityETH(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
+            self.call_builder(&removeLiquidityETHCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
+        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
+        /// function.
+        pub fn removeLiquidityETHWithPermit(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
+            self.call_builder(&removeLiquidityETHWithPermitCall {
+                token,
+                liquidity,
+                amountTokenMin,
+                amountETHMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
+        /// function.
+        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+            &self,
+            token: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(
+                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
+                    token,
+                    liquidity,
+                    amountTokenMin,
+                    amountETHMin,
+                    to,
+                    deadline,
+                    approveMax,
+                    v,
+                    r,
+                    s,
+                },
+            )
+        }
+
+        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
+        /// function.
+        pub fn removeLiquidityWithPermit(
+            &self,
+            tokenA: alloy_sol_types::private::Address,
+            tokenB: alloy_sol_types::private::Address,
+            liquidity: alloy_sol_types::private::primitives::aliases::U256,
+            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+            approveMax: bool,
+            v: u8,
+            r: alloy_sol_types::private::FixedBytes<32>,
+            s: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
+            self.call_builder(&removeLiquidityWithPermitCall {
+                tokenA,
+                tokenB,
+                liquidity,
+                amountAMin,
+                amountBMin,
+                to,
+                deadline,
+                approveMax,
+                v,
+                r,
+                s,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapETHForExactTokens`]
+        /// function.
+        pub fn swapETHForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
+            self.call_builder(&swapETHForExactTokensCall {
+                amountOut,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactETHForTokens`]
+        /// function.
+        pub fn swapExactETHForTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
+            self.call_builder(&swapExactETHForTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForETH`]
+        /// function.
+        pub fn swapExactTokensForETH(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
+            self.call_builder(&swapExactTokensForETHCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapExactTokensForTokens`]
+        /// function.
+        pub fn swapExactTokensForTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
+            self.call_builder(&swapExactTokensForTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
+        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            &self,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<
+            &P,
+            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
+            N,
+        > {
+            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
+                amountIn,
+                amountOutMin,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactETH`]
+        /// function.
+        pub fn swapTokensForExactETH(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
+            self.call_builder(&swapTokensForExactETHCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+
+        ///Creates a new call builder for the [`swapTokensForExactTokens`]
+        /// function.
+        pub fn swapTokensForExactTokens(
+            &self,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+            to: alloy_sol_types::private::Address,
+            deadline: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactTokensCall, N> {
+            self.call_builder(&swapTokensForExactTokensCall {
+                amountOut,
+                amountInMax,
+                path,
+                to,
+                deadline,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV2Router02Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = UniswapV2Router02::UniswapV2Router02Instance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x1C232F01118CB8B424793ae03F870aa7D0ac7f77"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0xedf6066a2b290C185783862C7F4776A2C8077AD1"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/uniswapv3pool/Cargo.toml b/contracts/generated/contracts-generated/uniswapv3pool/Cargo.toml
new file mode 100644
index 0000000000..65106539a9
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv3pool/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-uniswapv3pool"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs
new file mode 100644
index 0000000000..1a2b108692
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs
@@ -0,0 +1,8255 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface UniswapV3Pool {
+    event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1);
+    event Collect(address indexed owner, address recipient, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount0, uint128 amount1);
+    event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
+    event Flash(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1, uint256 paid0, uint256 paid1);
+    event IncreaseObservationCardinalityNext(uint16 observationCardinalityNextOld, uint16 observationCardinalityNextNew);
+    event Initialize(uint160 sqrtPriceX96, int24 tick);
+    event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1);
+    event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
+    event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick);
+
+    constructor();
+
+    function burn(int24 tickLower, int24 tickUpper, uint128 amount) external returns (uint256 amount0, uint256 amount1);
+    function collect(address recipient, int24 tickLower, int24 tickUpper, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
+    function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
+    function factory() external view returns (address);
+    function fee() external view returns (uint24);
+    function feeGrowthGlobal0X128() external view returns (uint256);
+    function feeGrowthGlobal1X128() external view returns (uint256);
+    function flash(address recipient, uint256 amount0, uint256 amount1, bytes memory data) external;
+    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
+    function initialize(uint160 sqrtPriceX96) external;
+    function liquidity() external view returns (uint128);
+    function maxLiquidityPerTick() external view returns (uint128);
+    function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes memory data) external returns (uint256 amount0, uint256 amount1);
+    function observations(uint256) external view returns (uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized);
+    function observe(uint32[] memory secondsAgos) external view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
+    function positions(bytes32) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1);
+    function protocolFees() external view returns (uint128 token0, uint128 token1);
+    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
+    function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked);
+    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) external view returns (int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside);
+    function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes memory data) external returns (int256 amount0, int256 amount1);
+    function tickBitmap(int16) external view returns (uint256);
+    function tickSpacing() external view returns (int24);
+    function ticks(int24) external view returns (uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized);
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "burn",
+    "inputs": [
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "amount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "collect",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "amount0Requested",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount1Requested",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount1",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "collectProtocol",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount0Requested",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount1Requested",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount1",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "fee",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint24",
+        "internalType": "uint24"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "feeGrowthGlobal0X128",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "feeGrowthGlobal1X128",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "flash",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "increaseObservationCardinalityNext",
+    "inputs": [
+      {
+        "name": "observationCardinalityNext",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "initialize",
+    "inputs": [
+      {
+        "name": "sqrtPriceX96",
+        "type": "uint160",
+        "internalType": "uint160"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "liquidity",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "maxLiquidityPerTick",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "amount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "observations",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "blockTimestamp",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "tickCumulative",
+        "type": "int56",
+        "internalType": "int56"
+      },
+      {
+        "name": "secondsPerLiquidityCumulativeX128",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "initialized",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "observe",
+    "inputs": [
+      {
+        "name": "secondsAgos",
+        "type": "uint32[]",
+        "internalType": "uint32[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "tickCumulatives",
+        "type": "int56[]",
+        "internalType": "int56[]"
+      },
+      {
+        "name": "secondsPerLiquidityCumulativeX128s",
+        "type": "uint160[]",
+        "internalType": "uint160[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "positions",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "liquidity",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "feeGrowthInside0LastX128",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "feeGrowthInside1LastX128",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "tokensOwed0",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "tokensOwed1",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "protocolFees",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "token0",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "token1",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setFeeProtocol",
+    "inputs": [
+      {
+        "name": "feeProtocol0",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "feeProtocol1",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "slot0",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "sqrtPriceX96",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "tick",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "observationIndex",
+        "type": "uint16",
+        "internalType": "uint16"
+      },
+      {
+        "name": "observationCardinality",
+        "type": "uint16",
+        "internalType": "uint16"
+      },
+      {
+        "name": "observationCardinalityNext",
+        "type": "uint16",
+        "internalType": "uint16"
+      },
+      {
+        "name": "feeProtocol",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "unlocked",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "snapshotCumulativesInside",
+    "inputs": [
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "internalType": "int24"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "tickCumulativeInside",
+        "type": "int56",
+        "internalType": "int56"
+      },
+      {
+        "name": "secondsPerLiquidityInsideX128",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "secondsInside",
+        "type": "uint32",
+        "internalType": "uint32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "zeroForOne",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "amountSpecified",
+        "type": "int256",
+        "internalType": "int256"
+      },
+      {
+        "name": "sqrtPriceLimitX96",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount0",
+        "type": "int256",
+        "internalType": "int256"
+      },
+      {
+        "name": "amount1",
+        "type": "int256",
+        "internalType": "int256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "tickBitmap",
+    "inputs": [
+      {
+        "name": "",
+        "type": "int16",
+        "internalType": "int16"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "tickSpacing",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "int24",
+        "internalType": "int24"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "ticks",
+    "inputs": [
+      {
+        "name": "",
+        "type": "int24",
+        "internalType": "int24"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "liquidityGross",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "liquidityNet",
+        "type": "int128",
+        "internalType": "int128"
+      },
+      {
+        "name": "feeGrowthOutside0X128",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "feeGrowthOutside1X128",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "tickCumulativeOutside",
+        "type": "int56",
+        "internalType": "int56"
+      },
+      {
+        "name": "secondsPerLiquidityOutsideX128",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "secondsOutside",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "initialized",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "token0",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "token1",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "Burn",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      },
+      {
+        "name": "amount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Collect",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      },
+      {
+        "name": "amount0",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount1",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "CollectProtocol",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount1",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Flash",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "paid0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "paid1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "IncreaseObservationCardinalityNext",
+    "inputs": [
+      {
+        "name": "observationCardinalityNextOld",
+        "type": "uint16",
+        "indexed": false,
+        "internalType": "uint16"
+      },
+      {
+        "name": "observationCardinalityNextNew",
+        "type": "uint16",
+        "indexed": false,
+        "internalType": "uint16"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Initialize",
+    "inputs": [
+      {
+        "name": "sqrtPriceX96",
+        "type": "uint160",
+        "indexed": false,
+        "internalType": "uint160"
+      },
+      {
+        "name": "tick",
+        "type": "int24",
+        "indexed": false,
+        "internalType": "int24"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Mint",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "tickLower",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      },
+      {
+        "name": "tickUpper",
+        "type": "int24",
+        "indexed": true,
+        "internalType": "int24"
+      },
+      {
+        "name": "amount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SetFeeProtocol",
+    "inputs": [
+      {
+        "name": "feeProtocol0Old",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      },
+      {
+        "name": "feeProtocol1Old",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      },
+      {
+        "name": "feeProtocol0New",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      },
+      {
+        "name": "feeProtocol1New",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Swap",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount0",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      },
+      {
+        "name": "amount1",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      },
+      {
+        "name": "sqrtPriceX96",
+        "type": "uint160",
+        "indexed": false,
+        "internalType": "uint160"
+      },
+      {
+        "name": "liquidity",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "tick",
+        "type": "int24",
+        "indexed": false,
+        "internalType": "int24"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod UniswapV3Pool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Burn(address,int24,int24,uint128,uint256,uint256)` and selector `0x0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c`.
+    ```solidity
+    event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Burn {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount: u128,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Burn {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Burn(address,int24,int24,uint128,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    12u8, 57u8, 108u8, 217u8, 137u8, 163u8, 159u8, 68u8, 89u8, 181u8, 250u8, 26u8,
+                    237u8, 106u8, 154u8, 141u8, 205u8, 188u8, 69u8, 144u8, 138u8, 207u8, 214u8,
+                    126u8, 2u8, 140u8, 213u8, 104u8, 218u8, 152u8, 152u8, 44u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    tickLower: topics.2,
+                    tickUpper: topics.3,
+                    amount: data.0,
+                    amount0: data.1,
+                    amount1: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.tickLower.clone(),
+                    self.tickUpper.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickLower);
+                out[3usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickUpper);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Burn {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Burn> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Burn) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Collect(address,address,int24,int24,uint128,uint128)` and selector `0x70935338e69775456a85ddef226c395fb668b63fa0115f5f20610b388e6ca9c0`.
+    ```solidity
+    event Collect(address indexed owner, address recipient, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount0, uint128 amount1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Collect {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount0: u128,
+        #[allow(missing_docs)]
+        pub amount1: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Collect {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Collect(address,address,int24,int24,uint128,uint128)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    112u8, 147u8, 83u8, 56u8, 230u8, 151u8, 117u8, 69u8, 106u8, 133u8, 221u8,
+                    239u8, 34u8, 108u8, 57u8, 95u8, 182u8, 104u8, 182u8, 63u8, 160u8, 17u8, 95u8,
+                    95u8, 32u8, 97u8, 11u8, 56u8, 142u8, 108u8, 169u8, 192u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    recipient: data.0,
+                    tickLower: topics.2,
+                    tickUpper: topics.3,
+                    amount0: data.1,
+                    amount1: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.tickLower.clone(),
+                    self.tickUpper.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickLower);
+                out[3usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickUpper);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Collect {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Collect> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Collect) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `CollectProtocol(address,address,uint128,uint128)` and selector `0x596b573906218d3411850b26a6b437d6c4522fdb43d2d2386263f86d50b8b151`.
+    ```solidity
+    event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct CollectProtocol {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: u128,
+        #[allow(missing_docs)]
+        pub amount1: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for CollectProtocol {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "CollectProtocol(address,address,uint128,uint128)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    89u8, 107u8, 87u8, 57u8, 6u8, 33u8, 141u8, 52u8, 17u8, 133u8, 11u8, 38u8,
+                    166u8, 180u8, 55u8, 214u8, 196u8, 82u8, 47u8, 219u8, 67u8, 210u8, 210u8, 56u8,
+                    98u8, 99u8, 248u8, 109u8, 80u8, 184u8, 177u8, 81u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    recipient: topics.2,
+                    amount0: data.0,
+                    amount1: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.recipient.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.recipient,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for CollectProtocol {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&CollectProtocol> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &CollectProtocol) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Flash(address,address,uint256,uint256,uint256,uint256)` and selector `0xbdbdb71d7860376ba52b25a5028beea23581364a40522f6bcfb86bb1f2dca633`.
+    ```solidity
+    event Flash(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1, uint256 paid0, uint256 paid1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Flash {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub paid0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub paid1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Flash {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "Flash(address,address,uint256,uint256,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    189u8, 189u8, 183u8, 29u8, 120u8, 96u8, 55u8, 107u8, 165u8, 43u8, 37u8, 165u8,
+                    2u8, 139u8, 238u8, 162u8, 53u8, 129u8, 54u8, 74u8, 64u8, 82u8, 47u8, 107u8,
+                    207u8, 184u8, 107u8, 177u8, 242u8, 220u8, 166u8, 51u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    recipient: topics.2,
+                    amount0: data.0,
+                    amount1: data.1,
+                    paid0: data.2,
+                    paid1: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.paid0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.paid1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.recipient.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.recipient,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Flash {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Flash> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Flash) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `IncreaseObservationCardinalityNext(uint16,uint16)` and selector `0xac49e518f90a358f652e4400164f05a5d8f7e35e7747279bc3a93dbf584e125a`.
+    ```solidity
+    event IncreaseObservationCardinalityNext(uint16 observationCardinalityNextOld, uint16 observationCardinalityNextNew);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct IncreaseObservationCardinalityNext {
+        #[allow(missing_docs)]
+        pub observationCardinalityNextOld: u16,
+        #[allow(missing_docs)]
+        pub observationCardinalityNextNew: u16,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for IncreaseObservationCardinalityNext {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<16>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "IncreaseObservationCardinalityNext(uint16,uint16)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    172u8, 73u8, 229u8, 24u8, 249u8, 10u8, 53u8, 143u8, 101u8, 46u8, 68u8, 0u8,
+                    22u8, 79u8, 5u8, 165u8, 216u8, 247u8, 227u8, 94u8, 119u8, 71u8, 39u8, 155u8,
+                    195u8, 169u8, 61u8, 191u8, 88u8, 78u8, 18u8, 90u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    observationCardinalityNextOld: data.0,
+                    observationCardinalityNextNew: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.observationCardinalityNextOld,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.observationCardinalityNextNew,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for IncreaseObservationCardinalityNext {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&IncreaseObservationCardinalityNext> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(
+                this: &IncreaseObservationCardinalityNext,
+            ) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Initialize(uint160,int24)` and selector `0x98636036cb66a9c19a37435efc1e90142190214e8abeb821bdba3f2990dd4c95`.
+    ```solidity
+    event Initialize(uint160 sqrtPriceX96, int24 tick);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Initialize {
+        #[allow(missing_docs)]
+        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub tick: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Initialize {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Initialize(uint160,int24)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    152u8, 99u8, 96u8, 54u8, 203u8, 102u8, 169u8, 193u8, 154u8, 55u8, 67u8, 94u8,
+                    252u8, 30u8, 144u8, 20u8, 33u8, 144u8, 33u8, 78u8, 138u8, 190u8, 184u8, 33u8,
+                    189u8, 186u8, 63u8, 41u8, 144u8, 221u8, 76u8, 149u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sqrtPriceX96: data.0,
+                    tick: data.1,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tick,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Initialize {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Initialize> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Initialize) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Mint(address,address,int24,int24,uint128,uint256,uint256)` and selector `0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde`.
+    ```solidity
+    event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Mint {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount: u128,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Mint {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "Mint(address,address,int24,int24,uint128,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    122u8, 83u8, 8u8, 11u8, 164u8, 20u8, 21u8, 139u8, 231u8, 236u8, 105u8, 185u8,
+                    135u8, 181u8, 251u8, 125u8, 7u8, 222u8, 225u8, 1u8, 254u8, 133u8, 72u8, 143u8,
+                    8u8, 83u8, 174u8, 22u8, 35u8, 157u8, 11u8, 222u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: data.0,
+                    owner: topics.1,
+                    tickLower: topics.2,
+                    tickUpper: topics.3,
+                    amount: data.1,
+                    amount0: data.2,
+                    amount1: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.tickLower.clone(),
+                    self.tickUpper.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickLower);
+                out[3usize] = <alloy_sol_types::sol_data::Int<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tickUpper);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Mint {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Mint> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Mint) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SetFeeProtocol(uint8,uint8,uint8,uint8)` and selector `0x973d8d92bb299f4af6ce49b52a8adb85ae46b9f214c4c4fc06ac77401237b133`.
+    ```solidity
+    event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SetFeeProtocol {
+        #[allow(missing_docs)]
+        pub feeProtocol0Old: u8,
+        #[allow(missing_docs)]
+        pub feeProtocol1Old: u8,
+        #[allow(missing_docs)]
+        pub feeProtocol0New: u8,
+        #[allow(missing_docs)]
+        pub feeProtocol1New: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SetFeeProtocol {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<8>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SetFeeProtocol(uint8,uint8,uint8,uint8)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    151u8, 61u8, 141u8, 146u8, 187u8, 41u8, 159u8, 74u8, 246u8, 206u8, 73u8, 181u8,
+                    42u8, 138u8, 219u8, 133u8, 174u8, 70u8, 185u8, 242u8, 20u8, 196u8, 196u8,
+                    252u8, 6u8, 172u8, 119u8, 64u8, 18u8, 55u8, 177u8, 51u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    feeProtocol0Old: data.0,
+                    feeProtocol1Old: data.1,
+                    feeProtocol0New: data.2,
+                    feeProtocol1New: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol0Old,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol1Old,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol0New,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol1New,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SetFeeProtocol {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SetFeeProtocol> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SetFeeProtocol) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Swap(address,address,int256,int256,uint160,uint128,int24)` and selector `0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67`.
+    ```solidity
+    event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Swap {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub liquidity: u128,
+        #[allow(missing_docs)]
+        pub tick: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Swap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "Swap(address,address,int256,int256,uint160,uint128,int24)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    196u8, 32u8, 121u8, 249u8, 74u8, 99u8, 80u8, 215u8, 230u8, 35u8, 95u8, 41u8,
+                    23u8, 73u8, 36u8, 249u8, 40u8, 204u8, 42u8, 200u8, 24u8, 235u8, 100u8, 254u8,
+                    216u8, 0u8, 78u8, 17u8, 95u8, 188u8, 202u8, 103u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    sender: topics.1,
+                    recipient: topics.2,
+                    amount0: data.0,
+                    amount1: data.1,
+                    sqrtPriceX96: data.2,
+                    liquidity: data.3,
+                    tick: data.4,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tick,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.sender.clone(),
+                    self.recipient.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.recipient,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Swap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Swap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Swap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {}
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `burn(int24,int24,uint128)` and selector `0xa34123a7`.
+    ```solidity
+    function burn(int24 tickLower, int24 tickUpper, uint128 amount) external returns (uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct burnCall {
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`burn(int24,int24,uint128)`](burnCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct burnReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I24,
+                alloy_sol_types::private::primitives::aliases::I24,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
+                fn from(value: burnCall) -> Self {
+                    (value.tickLower, value.tickUpper, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tickLower: tuple.0,
+                        tickUpper: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: burnReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl burnReturn {
+            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for burnCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = burnReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [163u8, 65u8, 35u8, 167u8];
+            const SIGNATURE: &'static str = "burn(int24,int24,uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickLower,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickUpper,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                burnReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `collect(address,int24,int24,uint128,uint128)` and selector `0x4f1eb3d8`.
+    ```solidity
+    function collect(address recipient, int24 tickLower, int24 tickUpper, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct collectCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount0Requested: u128,
+        #[allow(missing_docs)]
+        pub amount1Requested: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`collect(address,int24,int24,uint128,uint128)`](collectCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct collectReturn {
+        #[allow(missing_docs)]
+        pub amount0: u128,
+        #[allow(missing_docs)]
+        pub amount1: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::I24,
+                alloy_sol_types::private::primitives::aliases::I24,
+                u128,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<collectCall> for UnderlyingRustTuple<'_> {
+                fn from(value: collectCall) -> Self {
+                    (
+                        value.recipient,
+                        value.tickLower,
+                        value.tickUpper,
+                        value.amount0Requested,
+                        value.amount1Requested,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for collectCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        tickLower: tuple.1,
+                        tickUpper: tuple.2,
+                        amount0Requested: tuple.3,
+                        amount1Requested: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<collectReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: collectReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for collectReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl collectReturn {
+            fn _tokenize(&self) -> <collectCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for collectCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = collectReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [79u8, 30u8, 179u8, 216u8];
+            const SIGNATURE: &'static str = "collect(address,int24,int24,uint128,uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickLower,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickUpper,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Requested,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Requested,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                collectReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `collectProtocol(address,uint128,uint128)` and selector `0x85b66729`.
+    ```solidity
+    function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct collectProtocolCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0Requested: u128,
+        #[allow(missing_docs)]
+        pub amount1Requested: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`collectProtocol(address,uint128,uint128)`](collectProtocolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct collectProtocolReturn {
+        #[allow(missing_docs)]
+        pub amount0: u128,
+        #[allow(missing_docs)]
+        pub amount1: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<collectProtocolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: collectProtocolCall) -> Self {
+                    (
+                        value.recipient,
+                        value.amount0Requested,
+                        value.amount1Requested,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for collectProtocolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount0Requested: tuple.1,
+                        amount1Requested: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<collectProtocolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: collectProtocolReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for collectProtocolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl collectProtocolReturn {
+            fn _tokenize(
+                &self,
+            ) -> <collectProtocolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for collectProtocolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = collectProtocolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [133u8, 182u8, 103u8, 41u8];
+            const SIGNATURE: &'static str = "collectProtocol(address,uint128,uint128)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Requested,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Requested,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                collectProtocolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `fee()` and selector `0xddca3f43`.
+    ```solidity
+    function fee() external view returns (uint24);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`fee()`](feeCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U24,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: feeCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<24>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U24,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: feeReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for feeCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U24;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<24>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 202u8, 63u8, 67u8];
+            const SIGNATURE: &'static str = "fee()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: feeReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: feeReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `feeGrowthGlobal0X128()` and selector `0xf3058399`.
+    ```solidity
+    function feeGrowthGlobal0X128() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeGrowthGlobal0X128Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`feeGrowthGlobal0X128()`](feeGrowthGlobal0X128Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeGrowthGlobal0X128Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeGrowthGlobal0X128Call> for UnderlyingRustTuple<'_> {
+                fn from(value: feeGrowthGlobal0X128Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal0X128Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeGrowthGlobal0X128Return> for UnderlyingRustTuple<'_> {
+                fn from(value: feeGrowthGlobal0X128Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal0X128Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for feeGrowthGlobal0X128Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 5u8, 131u8, 153u8];
+            const SIGNATURE: &'static str = "feeGrowthGlobal0X128()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: feeGrowthGlobal0X128Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: feeGrowthGlobal0X128Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `feeGrowthGlobal1X128()` and selector `0x46141319`.
+    ```solidity
+    function feeGrowthGlobal1X128() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeGrowthGlobal1X128Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`feeGrowthGlobal1X128()`](feeGrowthGlobal1X128Call) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct feeGrowthGlobal1X128Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeGrowthGlobal1X128Call> for UnderlyingRustTuple<'_> {
+                fn from(value: feeGrowthGlobal1X128Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal1X128Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<feeGrowthGlobal1X128Return> for UnderlyingRustTuple<'_> {
+                fn from(value: feeGrowthGlobal1X128Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal1X128Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for feeGrowthGlobal1X128Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [70u8, 20u8, 19u8, 25u8];
+            const SIGNATURE: &'static str = "feeGrowthGlobal1X128()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: feeGrowthGlobal1X128Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: feeGrowthGlobal1X128Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `flash(address,uint256,uint256,bytes)` and selector `0x490e6cbc`.
+    ```solidity
+    function flash(address recipient, uint256 amount0, uint256 amount1, bytes memory data) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct flashCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`flash(address,uint256,uint256,bytes)`](flashCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct flashReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<flashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: flashCall) -> Self {
+                    (value.recipient, value.amount0, value.amount1, value.data)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount0: tuple.1,
+                        amount1: tuple.2,
+                        data: tuple.3,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<flashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: flashReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl flashReturn {
+            fn _tokenize(&self) -> <flashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for flashCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = flashReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [73u8, 14u8, 108u8, 188u8];
+            const SIGNATURE: &'static str = "flash(address,uint256,uint256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                flashReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `increaseObservationCardinalityNext(uint16)` and selector `0x32148f67`.
+    ```solidity
+    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseObservationCardinalityNextCall {
+        #[allow(missing_docs)]
+        pub observationCardinalityNext: u16,
+    }
+    ///Container type for the return parameters of the
+    /// [`increaseObservationCardinalityNext(uint16)`](increaseObservationCardinalityNextCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct increaseObservationCardinalityNextReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<16>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u16,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseObservationCardinalityNextCall> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseObservationCardinalityNextCall) -> Self {
+                    (value.observationCardinalityNext,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseObservationCardinalityNextCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        observationCardinalityNext: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<increaseObservationCardinalityNextReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: increaseObservationCardinalityNextReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseObservationCardinalityNextReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl increaseObservationCardinalityNextReturn {
+            fn _tokenize(
+                &self,
+            ) -> <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for increaseObservationCardinalityNextCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<16>,);
+            type Return = increaseObservationCardinalityNextReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [50u8, 20u8, 143u8, 103u8];
+            const SIGNATURE: &'static str = "increaseObservationCardinalityNext(uint16)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.observationCardinalityNext,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                increaseObservationCardinalityNextReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `initialize(uint160)` and selector `0xf637731d`.
+    ```solidity
+    function initialize(uint160 sqrtPriceX96) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeCall {
+        #[allow(missing_docs)]
+        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
+    }
+    ///Container type for the return parameters of the
+    /// [`initialize(uint160)`](initializeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<160>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U160,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeCall) -> Self {
+                    (value.sqrtPriceX96,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sqrtPriceX96: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl initializeReturn {
+            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for initializeCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<160>,);
+            type Return = initializeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [246u8, 55u8, 115u8, 29u8];
+            const SIGNATURE: &'static str = "initialize(uint160)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                initializeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `liquidity()` and selector `0x1a686502`.
+    ```solidity
+    function liquidity() external view returns (uint128);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct liquidityCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`liquidity()`](liquidityCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct liquidityReturn {
+        #[allow(missing_docs)]
+        pub _0: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<liquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: liquidityCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for liquidityCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<liquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: liquidityReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for liquidityReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for liquidityCall {
+            type Parameters<'a> = ();
+            type Return = u128;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [26u8, 104u8, 101u8, 2u8];
+            const SIGNATURE: &'static str = "liquidity()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: liquidityReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: liquidityReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `maxLiquidityPerTick()` and selector `0x70cf754a`.
+    ```solidity
+    function maxLiquidityPerTick() external view returns (uint128);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct maxLiquidityPerTickCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`maxLiquidityPerTick()`](maxLiquidityPerTickCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct maxLiquidityPerTickReturn {
+        #[allow(missing_docs)]
+        pub _0: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<maxLiquidityPerTickCall> for UnderlyingRustTuple<'_> {
+                fn from(value: maxLiquidityPerTickCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for maxLiquidityPerTickCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<maxLiquidityPerTickReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: maxLiquidityPerTickReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for maxLiquidityPerTickReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for maxLiquidityPerTickCall {
+            type Parameters<'a> = ();
+            type Return = u128;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 207u8, 117u8, 74u8];
+            const SIGNATURE: &'static str = "maxLiquidityPerTick()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: maxLiquidityPerTickReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: maxLiquidityPerTickReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address,int24,int24,uint128,bytes)` and selector `0x3c8a7d8d`.
+    ```solidity
+    function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes memory data) external returns (uint256 amount0, uint256 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount: u128,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`mint(address,int24,int24,uint128,bytes)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::I24,
+                alloy_sol_types::private::primitives::aliases::I24,
+                u128,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (
+                        value.recipient,
+                        value.tickLower,
+                        value.tickUpper,
+                        value.amount,
+                        value.data,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        tickLower: tuple.1,
+                        tickUpper: tuple.2,
+                        amount: tuple.3,
+                        data: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = mintReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [60u8, 138u8, 125u8, 141u8];
+            const SIGNATURE: &'static str = "mint(address,int24,int24,uint128,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickLower,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickUpper,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                mintReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `observations(uint256)` and selector `0x252c09d7`.
+    ```solidity
+    function observations(uint256) external view returns (uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct observationsCall(pub alloy_sol_types::private::primitives::aliases::U256);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`observations(uint256)`](observationsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct observationsReturn {
+        #[allow(missing_docs)]
+        pub blockTimestamp: u32,
+        #[allow(missing_docs)]
+        pub tickCumulative: alloy_sol_types::private::primitives::aliases::I56,
+        #[allow(missing_docs)]
+        pub secondsPerLiquidityCumulativeX128: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub initialized: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<observationsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: observationsCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observationsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Int<56>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                u32,
+                alloy_sol_types::private::primitives::aliases::I56,
+                alloy_sol_types::private::primitives::aliases::U160,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<observationsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: observationsReturn) -> Self {
+                    (
+                        value.blockTimestamp,
+                        value.tickCumulative,
+                        value.secondsPerLiquidityCumulativeX128,
+                        value.initialized,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observationsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        blockTimestamp: tuple.0,
+                        tickCumulative: tuple.1,
+                        secondsPerLiquidityCumulativeX128: tuple.2,
+                        initialized: tuple.3,
+                    }
+                }
+            }
+        }
+        impl observationsReturn {
+            fn _tokenize(&self) -> <observationsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockTimestamp,
+                    ),
+                    <alloy_sol_types::sol_data::Int<56> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickCumulative,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsPerLiquidityCumulativeX128,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.initialized,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for observationsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = observationsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Int<56>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [37u8, 44u8, 9u8, 215u8];
+            const SIGNATURE: &'static str = "observations(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                observationsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `observe(uint32[])` and selector `0x883bdbfd`.
+    ```solidity
+    function observe(uint32[] memory secondsAgos) external view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct observeCall {
+        #[allow(missing_docs)]
+        pub secondsAgos: alloy_sol_types::private::Vec<u32>,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`observe(uint32[])`](observeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct observeReturn {
+        #[allow(missing_docs)]
+        pub tickCumulatives:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I56>,
+        #[allow(missing_docs)]
+        pub secondsPerLiquidityCumulativeX128s:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<u32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<observeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: observeCall) -> Self {
+                    (value.secondsAgos,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observeCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        secondsAgos: tuple.0,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<56>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I56>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<observeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: observeReturn) -> Self {
+                    (
+                        value.tickCumulatives,
+                        value.secondsPerLiquidityCumulativeX128s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observeReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tickCumulatives: tuple.0,
+                        secondsPerLiquidityCumulativeX128s: tuple.1,
+                    }
+                }
+            }
+        }
+        impl observeReturn {
+            fn _tokenize(&self) -> <observeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Int<56>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tickCumulatives),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<160>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsPerLiquidityCumulativeX128s,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for observeCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,);
+            type Return = observeReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<56>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [136u8, 59u8, 219u8, 253u8];
+            const SIGNATURE: &'static str = "observe(uint32[])";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<32>,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.secondsAgos
+                ),)
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                observeReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `positions(bytes32)` and selector `0x514ea4bf`.
+    ```solidity
+    function positions(bytes32) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct positionsCall(pub alloy_sol_types::private::FixedBytes<32>);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`positions(bytes32)`](positionsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct positionsReturn {
+        #[allow(missing_docs)]
+        pub liquidity: u128,
+        #[allow(missing_docs)]
+        pub feeGrowthInside0LastX128: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeGrowthInside1LastX128: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub tokensOwed0: u128,
+        #[allow(missing_docs)]
+        pub tokensOwed1: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<positionsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: positionsCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for positionsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                u128,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u128,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<positionsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: positionsReturn) -> Self {
+                    (
+                        value.liquidity,
+                        value.feeGrowthInside0LastX128,
+                        value.feeGrowthInside1LastX128,
+                        value.tokensOwed0,
+                        value.tokensOwed1,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for positionsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        liquidity: tuple.0,
+                        feeGrowthInside0LastX128: tuple.1,
+                        feeGrowthInside1LastX128: tuple.2,
+                        tokensOwed0: tuple.3,
+                        tokensOwed1: tuple.4,
+                    }
+                }
+            }
+        }
+        impl positionsReturn {
+            fn _tokenize(&self) -> <positionsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeGrowthInside0LastX128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeGrowthInside1LastX128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokensOwed0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokensOwed1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for positionsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = positionsReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [81u8, 78u8, 164u8, 191u8];
+            const SIGNATURE: &'static str = "positions(bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.0),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                positionsReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `protocolFees()` and selector `0x1ad8b03b`.
+    ```solidity
+    function protocolFees() external view returns (uint128 token0, uint128 token1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct protocolFeesCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`protocolFees()`](protocolFeesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct protocolFeesReturn {
+        #[allow(missing_docs)]
+        pub token0: u128,
+        #[allow(missing_docs)]
+        pub token1: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<protocolFeesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: protocolFeesCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for protocolFeesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128, u128);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<protocolFeesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: protocolFeesReturn) -> Self {
+                    (value.token0, value.token1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for protocolFeesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        token0: tuple.0,
+                        token1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl protocolFeesReturn {
+            fn _tokenize(&self) -> <protocolFeesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for protocolFeesCall {
+            type Parameters<'a> = ();
+            type Return = protocolFeesReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [26u8, 216u8, 176u8, 59u8];
+            const SIGNATURE: &'static str = "protocolFees()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                protocolFeesReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `setFeeProtocol(uint8,uint8)` and selector `0x8206a4d1`.
+    ```solidity
+    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFeeProtocolCall {
+        #[allow(missing_docs)]
+        pub feeProtocol0: u8,
+        #[allow(missing_docs)]
+        pub feeProtocol1: u8,
+    }
+    ///Container type for the return parameters of the
+    /// [`setFeeProtocol(uint8,uint8)`](setFeeProtocolCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct setFeeProtocolReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<8>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8, u8);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFeeProtocolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setFeeProtocolCall) -> Self {
+                    (value.feeProtocol0, value.feeProtocol1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeProtocolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        feeProtocol0: tuple.0,
+                        feeProtocol1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<setFeeProtocolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setFeeProtocolReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeProtocolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl setFeeProtocolReturn {
+            fn _tokenize(
+                &self,
+            ) -> <setFeeProtocolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for setFeeProtocolCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<8>,
+            );
+            type Return = setFeeProtocolReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [130u8, 6u8, 164u8, 209u8];
+            const SIGNATURE: &'static str = "setFeeProtocol(uint8,uint8)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                setFeeProtocolReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `slot0()` and selector `0x3850c7bd`.
+    ```solidity
+    function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct slot0Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`slot0()`](slot0Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct slot0Return {
+        #[allow(missing_docs)]
+        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub tick: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub observationIndex: u16,
+        #[allow(missing_docs)]
+        pub observationCardinality: u16,
+        #[allow(missing_docs)]
+        pub observationCardinalityNext: u16,
+        #[allow(missing_docs)]
+        pub feeProtocol: u8,
+        #[allow(missing_docs)]
+        pub unlocked: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<slot0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: slot0Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slot0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::primitives::aliases::I24,
+                u16,
+                u16,
+                u16,
+                u8,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<slot0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: slot0Return) -> Self {
+                    (
+                        value.sqrtPriceX96,
+                        value.tick,
+                        value.observationIndex,
+                        value.observationCardinality,
+                        value.observationCardinalityNext,
+                        value.feeProtocol,
+                        value.unlocked,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slot0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sqrtPriceX96: tuple.0,
+                        tick: tuple.1,
+                        observationIndex: tuple.2,
+                        observationCardinality: tuple.3,
+                        observationCardinalityNext: tuple.4,
+                        feeProtocol: tuple.5,
+                        unlocked: tuple.6,
+                    }
+                }
+            }
+        }
+        impl slot0Return {
+            fn _tokenize(&self) -> <slot0Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tick,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.observationIndex,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.observationCardinality,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.observationCardinalityNext,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeProtocol,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.unlocked,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for slot0Call {
+            type Parameters<'a> = ();
+            type Return = slot0Return;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<16>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 80u8, 199u8, 189u8];
+            const SIGNATURE: &'static str = "slot0()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                slot0Return::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `snapshotCumulativesInside(int24,int24)` and selector `0xa38807f2`.
+    ```solidity
+    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) external view returns (int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct snapshotCumulativesInsideCall {
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`snapshotCumulativesInside(int24,
+    /// int24)`](snapshotCumulativesInsideCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct snapshotCumulativesInsideReturn {
+        #[allow(missing_docs)]
+        pub tickCumulativeInside: alloy_sol_types::private::primitives::aliases::I56,
+        #[allow(missing_docs)]
+        pub secondsPerLiquidityInsideX128: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub secondsInside: u32,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I24,
+                alloy_sol_types::private::primitives::aliases::I24,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<snapshotCumulativesInsideCall> for UnderlyingRustTuple<'_> {
+                fn from(value: snapshotCumulativesInsideCall) -> Self {
+                    (value.tickLower, value.tickUpper)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for snapshotCumulativesInsideCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tickLower: tuple.0,
+                        tickUpper: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<56>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I56,
+                alloy_sol_types::private::primitives::aliases::U160,
+                u32,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<snapshotCumulativesInsideReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: snapshotCumulativesInsideReturn) -> Self {
+                    (
+                        value.tickCumulativeInside,
+                        value.secondsPerLiquidityInsideX128,
+                        value.secondsInside,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for snapshotCumulativesInsideReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        tickCumulativeInside: tuple.0,
+                        secondsPerLiquidityInsideX128: tuple.1,
+                        secondsInside: tuple.2,
+                    }
+                }
+            }
+        }
+        impl snapshotCumulativesInsideReturn {
+            fn _tokenize(
+                &self,
+            ) -> <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Int<56> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickCumulativeInside,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsPerLiquidityInsideX128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsInside,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for snapshotCumulativesInsideCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+            );
+            type Return = snapshotCumulativesInsideReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Int<56>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [163u8, 136u8, 7u8, 242u8];
+            const SIGNATURE: &'static str = "snapshotCumulativesInside(int24,int24)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickLower,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickUpper,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                snapshotCumulativesInsideReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `swap(address,bool,int256,uint160,bytes)` and selector `0x128acb08`.
+    ```solidity
+    function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes memory data) external returns (int256 amount0, int256 amount1);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub zeroForOne: bool,
+        #[allow(missing_docs)]
+        pub amountSpecified: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`swap(address,bool,int256,uint160,bytes)`](swapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct swapReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::I256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                bool,
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (
+                        value.recipient,
+                        value.zeroForOne,
+                        value.amountSpecified,
+                        value.sqrtPriceLimitX96,
+                        value.data,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        zeroForOne: tuple.1,
+                        amountSpecified: tuple.2,
+                        sqrtPriceLimitX96: tuple.3,
+                        data: tuple.4,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::primitives::aliases::I256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    (value.amount0, value.amount1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
+                }
+            }
+        }
+        impl swapReturn {
+            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [18u8, 138u8, 203u8, 8u8];
+            const SIGNATURE: &'static str = "swap(address,bool,int256,uint160,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.zeroForOne,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountSpecified,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceLimitX96,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                swapReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `tickBitmap(int16)` and selector `0x5339c296`.
+    ```solidity
+    function tickBitmap(int16) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tickBitmapCall(pub i16);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`tickBitmap(int16)`](tickBitmapCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tickBitmapReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<16>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (i16,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tickBitmapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: tickBitmapCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickBitmapCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tickBitmapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: tickBitmapReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickBitmapReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for tickBitmapCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Int<16>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [83u8, 57u8, 194u8, 150u8];
+            const SIGNATURE: &'static str = "tickBitmap(int16)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<16> as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: tickBitmapReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: tickBitmapReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `tickSpacing()` and selector `0xd0c93a7c`.
+    ```solidity
+    function tickSpacing() external view returns (int24);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tickSpacingCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`tickSpacing()`](tickSpacingCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct tickSpacingReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::I24,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tickSpacingCall> for UnderlyingRustTuple<'_> {
+                fn from(value: tickSpacingCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickSpacingCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::I24,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<tickSpacingReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: tickSpacingReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickSpacingReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for tickSpacingCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::I24;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 201u8, 58u8, 124u8];
+            const SIGNATURE: &'static str = "tickSpacing()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: tickSpacingReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: tickSpacingReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `ticks(int24)` and selector `0xf30dba93`.
+    ```solidity
+    function ticks(int24) external view returns (uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ticksCall(pub alloy_sol_types::private::primitives::aliases::I24);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`ticks(int24)`](ticksCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ticksReturn {
+        #[allow(missing_docs)]
+        pub liquidityGross: u128,
+        #[allow(missing_docs)]
+        pub liquidityNet: i128,
+        #[allow(missing_docs)]
+        pub feeGrowthOutside0X128: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeGrowthOutside1X128: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub tickCumulativeOutside: alloy_sol_types::private::primitives::aliases::I56,
+        #[allow(missing_docs)]
+        pub secondsPerLiquidityOutsideX128: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub secondsOutside: u32,
+        #[allow(missing_docs)]
+        pub initialized: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::I24,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ticksCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ticksCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ticksCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Int<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Int<56>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                u128,
+                i128,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::I56,
+                alloy_sol_types::private::primitives::aliases::U160,
+                u32,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ticksReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ticksReturn) -> Self {
+                    (
+                        value.liquidityGross,
+                        value.liquidityNet,
+                        value.feeGrowthOutside0X128,
+                        value.feeGrowthOutside1X128,
+                        value.tickCumulativeOutside,
+                        value.secondsPerLiquidityOutsideX128,
+                        value.secondsOutside,
+                        value.initialized,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ticksReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        liquidityGross: tuple.0,
+                        liquidityNet: tuple.1,
+                        feeGrowthOutside0X128: tuple.2,
+                        feeGrowthOutside1X128: tuple.3,
+                        tickCumulativeOutside: tuple.4,
+                        secondsPerLiquidityOutsideX128: tuple.5,
+                        secondsOutside: tuple.6,
+                        initialized: tuple.7,
+                    }
+                }
+            }
+        }
+        impl ticksReturn {
+            fn _tokenize(&self) -> <ticksCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidityGross,
+                    ),
+                    <alloy_sol_types::sol_data::Int<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidityNet,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeGrowthOutside0X128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeGrowthOutside1X128,
+                    ),
+                    <alloy_sol_types::sol_data::Int<56> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickCumulativeOutside,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsPerLiquidityOutsideX128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsOutside,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.initialized,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ticksCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type Return = ticksReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Int<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Int<56>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [243u8, 13u8, 186u8, 147u8];
+            const SIGNATURE: &'static str = "ticks(int24)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                ticksReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token0()` and selector `0x0dfe1681`.
+    ```solidity
+    function token0() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token0()`](token0Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token0Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token0Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [13u8, 254u8, 22u8, 129u8];
+            const SIGNATURE: &'static str = "token0()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token0Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token0Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `token1()` and selector `0xd21220a7`.
+    ```solidity
+    function token1() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`token1()`](token1Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct token1Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<token1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for token1Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [210u8, 18u8, 32u8, 167u8];
+            const SIGNATURE: &'static str = "token1()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: token1Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: token1Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`UniswapV3Pool`](self) function calls.
+    #[derive(Clone)]
+    pub enum UniswapV3PoolCalls {
+        #[allow(missing_docs)]
+        burn(burnCall),
+        #[allow(missing_docs)]
+        collect(collectCall),
+        #[allow(missing_docs)]
+        collectProtocol(collectProtocolCall),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        fee(feeCall),
+        #[allow(missing_docs)]
+        feeGrowthGlobal0X128(feeGrowthGlobal0X128Call),
+        #[allow(missing_docs)]
+        feeGrowthGlobal1X128(feeGrowthGlobal1X128Call),
+        #[allow(missing_docs)]
+        flash(flashCall),
+        #[allow(missing_docs)]
+        increaseObservationCardinalityNext(increaseObservationCardinalityNextCall),
+        #[allow(missing_docs)]
+        initialize(initializeCall),
+        #[allow(missing_docs)]
+        liquidity(liquidityCall),
+        #[allow(missing_docs)]
+        maxLiquidityPerTick(maxLiquidityPerTickCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        observations(observationsCall),
+        #[allow(missing_docs)]
+        observe(observeCall),
+        #[allow(missing_docs)]
+        positions(positionsCall),
+        #[allow(missing_docs)]
+        protocolFees(protocolFeesCall),
+        #[allow(missing_docs)]
+        setFeeProtocol(setFeeProtocolCall),
+        #[allow(missing_docs)]
+        slot0(slot0Call),
+        #[allow(missing_docs)]
+        snapshotCumulativesInside(snapshotCumulativesInsideCall),
+        #[allow(missing_docs)]
+        swap(swapCall),
+        #[allow(missing_docs)]
+        tickBitmap(tickBitmapCall),
+        #[allow(missing_docs)]
+        tickSpacing(tickSpacingCall),
+        #[allow(missing_docs)]
+        ticks(ticksCall),
+        #[allow(missing_docs)]
+        token0(token0Call),
+        #[allow(missing_docs)]
+        token1(token1Call),
+    }
+    impl UniswapV3PoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [13u8, 254u8, 22u8, 129u8],
+            [18u8, 138u8, 203u8, 8u8],
+            [26u8, 104u8, 101u8, 2u8],
+            [26u8, 216u8, 176u8, 59u8],
+            [37u8, 44u8, 9u8, 215u8],
+            [50u8, 20u8, 143u8, 103u8],
+            [56u8, 80u8, 199u8, 189u8],
+            [60u8, 138u8, 125u8, 141u8],
+            [70u8, 20u8, 19u8, 25u8],
+            [73u8, 14u8, 108u8, 188u8],
+            [79u8, 30u8, 179u8, 216u8],
+            [81u8, 78u8, 164u8, 191u8],
+            [83u8, 57u8, 194u8, 150u8],
+            [112u8, 207u8, 117u8, 74u8],
+            [130u8, 6u8, 164u8, 209u8],
+            [133u8, 182u8, 103u8, 41u8],
+            [136u8, 59u8, 219u8, 253u8],
+            [163u8, 65u8, 35u8, 167u8],
+            [163u8, 136u8, 7u8, 242u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [208u8, 201u8, 58u8, 124u8],
+            [210u8, 18u8, 32u8, 167u8],
+            [221u8, 202u8, 63u8, 67u8],
+            [243u8, 5u8, 131u8, 153u8],
+            [243u8, 13u8, 186u8, 147u8],
+            [246u8, 55u8, 115u8, 29u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <liquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <protocolFeesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <observationsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <slot0Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <flashCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <collectCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <positionsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <tickBitmapCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <setFeeProtocolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <collectProtocolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <observeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <burnCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <tickSpacingCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <feeCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <ticksCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(token0),
+            ::core::stringify!(swap),
+            ::core::stringify!(liquidity),
+            ::core::stringify!(protocolFees),
+            ::core::stringify!(observations),
+            ::core::stringify!(increaseObservationCardinalityNext),
+            ::core::stringify!(slot0),
+            ::core::stringify!(mint),
+            ::core::stringify!(feeGrowthGlobal1X128),
+            ::core::stringify!(flash),
+            ::core::stringify!(collect),
+            ::core::stringify!(positions),
+            ::core::stringify!(tickBitmap),
+            ::core::stringify!(maxLiquidityPerTick),
+            ::core::stringify!(setFeeProtocol),
+            ::core::stringify!(collectProtocol),
+            ::core::stringify!(observe),
+            ::core::stringify!(burn),
+            ::core::stringify!(snapshotCumulativesInside),
+            ::core::stringify!(factory),
+            ::core::stringify!(tickSpacing),
+            ::core::stringify!(token1),
+            ::core::stringify!(fee),
+            ::core::stringify!(feeGrowthGlobal0X128),
+            ::core::stringify!(ticks),
+            ::core::stringify!(initialize),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for UniswapV3PoolCalls {
+        const COUNT: usize = 26usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "UniswapV3PoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::burn(_) => <burnCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::collect(_) => <collectCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::collectProtocol(_) => {
+                    <collectProtocolCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::fee(_) => <feeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::feeGrowthGlobal0X128(_) => {
+                    <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::feeGrowthGlobal1X128(_) => {
+                    <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::flash(_) => <flashCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::increaseObservationCardinalityNext(_) => {
+                    <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::liquidity(_) => <liquidityCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::maxLiquidityPerTick(_) => {
+                    <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::observations(_) => <observationsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::observe(_) => <observeCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::positions(_) => <positionsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::protocolFees(_) => <protocolFeesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::setFeeProtocol(_) => {
+                    <setFeeProtocolCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::slot0(_) => <slot0Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::snapshotCumulativesInside(_) => {
+                    <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::tickBitmap(_) => <tickBitmapCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::tickSpacing(_) => <tickSpacingCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::ticks(_) => <ticksCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls>] = &[
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn liquidity(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <liquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::liquidity)
+                    }
+                    liquidity
+                },
+                {
+                    fn protocolFees(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <protocolFeesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::protocolFees)
+                    }
+                    protocolFees
+                },
+                {
+                    fn observations(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <observationsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::observations)
+                    }
+                    observations
+                },
+                {
+                    fn increaseObservationCardinalityNext(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV3PoolCalls::increaseObservationCardinalityNext)
+                    }
+                    increaseObservationCardinalityNext
+                },
+                {
+                    fn slot0(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <slot0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::slot0)
+                    }
+                    slot0
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn feeGrowthGlobal1X128(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::feeGrowthGlobal1X128)
+                    }
+                    feeGrowthGlobal1X128
+                },
+                {
+                    fn flash(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <flashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::flash)
+                    }
+                    flash
+                },
+                {
+                    fn collect(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <collectCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::collect)
+                    }
+                    collect
+                },
+                {
+                    fn positions(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <positionsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::positions)
+                    }
+                    positions
+                },
+                {
+                    fn tickBitmap(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <tickBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::tickBitmap)
+                    }
+                    tickBitmap
+                },
+                {
+                    fn maxLiquidityPerTick(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::maxLiquidityPerTick)
+                    }
+                    maxLiquidityPerTick
+                },
+                {
+                    fn setFeeProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::setFeeProtocol)
+                    }
+                    setFeeProtocol
+                },
+                {
+                    fn collectProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <collectProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::collectProtocol)
+                    }
+                    collectProtocol
+                },
+                {
+                    fn observe(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <observeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::observe)
+                    }
+                    observe
+                },
+                {
+                    fn burn(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <burnCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::burn)
+                    }
+                    burn
+                },
+                {
+                    fn snapshotCumulativesInside(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(UniswapV3PoolCalls::snapshotCumulativesInside)
+                    }
+                    snapshotCumulativesInside
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn tickSpacing(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <tickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::tickSpacing)
+                    }
+                    tickSpacing
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn fee(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <feeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::fee)
+                    }
+                    fee
+                },
+                {
+                    fn feeGrowthGlobal0X128(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::feeGrowthGlobal0X128)
+                    }
+                    feeGrowthGlobal0X128
+                },
+                {
+                    fn ticks(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <ticksCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::ticks)
+                    }
+                    ticks
+                },
+                {
+                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(UniswapV3PoolCalls::initialize)
+                    }
+                    initialize
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<UniswapV3PoolCalls>] = &[
+                {
+                    fn token0(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <token0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::token0)
+                    }
+                    token0
+                },
+                {
+                    fn swap(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::swap)
+                    }
+                    swap
+                },
+                {
+                    fn liquidity(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <liquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::liquidity)
+                    }
+                    liquidity
+                },
+                {
+                    fn protocolFees(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <protocolFeesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV3PoolCalls::protocolFees)
+                    }
+                    protocolFees
+                },
+                {
+                    fn observations(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <observationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV3PoolCalls::observations)
+                    }
+                    observations
+                },
+                {
+                    fn increaseObservationCardinalityNext(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3PoolCalls::increaseObservationCardinalityNext)
+                    }
+                    increaseObservationCardinalityNext
+                },
+                {
+                    fn slot0(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <slot0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::slot0)
+                    }
+                    slot0
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn feeGrowthGlobal1X128(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3PoolCalls::feeGrowthGlobal1X128)
+                    }
+                    feeGrowthGlobal1X128
+                },
+                {
+                    fn flash(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <flashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::flash)
+                    }
+                    flash
+                },
+                {
+                    fn collect(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <collectCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::collect)
+                    }
+                    collect
+                },
+                {
+                    fn positions(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <positionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::positions)
+                    }
+                    positions
+                },
+                {
+                    fn tickBitmap(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <tickBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::tickBitmap)
+                    }
+                    tickBitmap
+                },
+                {
+                    fn maxLiquidityPerTick(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3PoolCalls::maxLiquidityPerTick)
+                    }
+                    maxLiquidityPerTick
+                },
+                {
+                    fn setFeeProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV3PoolCalls::setFeeProtocol)
+                    }
+                    setFeeProtocol
+                },
+                {
+                    fn collectProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <collectProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV3PoolCalls::collectProtocol)
+                    }
+                    collectProtocol
+                },
+                {
+                    fn observe(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <observeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::observe)
+                    }
+                    observe
+                },
+                {
+                    fn burn(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <burnCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::burn)
+                    }
+                    burn
+                },
+                {
+                    fn snapshotCumulativesInside(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3PoolCalls::snapshotCumulativesInside)
+                    }
+                    snapshotCumulativesInside
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn tickSpacing(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <tickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::tickSpacing)
+                    }
+                    tickSpacing
+                },
+                {
+                    fn token1(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <token1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::token1)
+                    }
+                    token1
+                },
+                {
+                    fn fee(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <feeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::fee)
+                    }
+                    fee
+                },
+                {
+                    fn feeGrowthGlobal0X128(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3PoolCalls::feeGrowthGlobal0X128)
+                    }
+                    feeGrowthGlobal0X128
+                },
+                {
+                    fn ticks(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <ticksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::ticks)
+                    }
+                    ticks
+                },
+                {
+                    fn initialize(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
+                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3PoolCalls::initialize)
+                    }
+                    initialize
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::burn(inner) => {
+                    <burnCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::collect(inner) => {
+                    <collectCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::collectProtocol(inner) => {
+                    <collectProtocolCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::fee(inner) => {
+                    <feeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::feeGrowthGlobal0X128(inner) => {
+                    <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::feeGrowthGlobal1X128(inner) => {
+                    <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::flash(inner) => {
+                    <flashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::increaseObservationCardinalityNext(inner) => {
+                    <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::initialize(inner) => {
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::liquidity(inner) => {
+                    <liquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::maxLiquidityPerTick(inner) => {
+                    <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::observations(inner) => {
+                    <observationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::observe(inner) => {
+                    <observeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::positions(inner) => {
+                    <positionsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::protocolFees(inner) => {
+                    <protocolFeesCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::setFeeProtocol(inner) => {
+                    <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::slot0(inner) => {
+                    <slot0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::snapshotCumulativesInside(inner) => {
+                    <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::tickBitmap(inner) => {
+                    <tickBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::tickSpacing(inner) => {
+                    <tickSpacingCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::ticks(inner) => {
+                    <ticksCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::burn(inner) => {
+                    <burnCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::collect(inner) => {
+                    <collectCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::collectProtocol(inner) => {
+                    <collectProtocolCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::fee(inner) => {
+                    <feeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::feeGrowthGlobal0X128(inner) => {
+                    <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::feeGrowthGlobal1X128(inner) => {
+                    <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::flash(inner) => {
+                    <flashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::increaseObservationCardinalityNext(inner) => {
+                    <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::initialize(inner) => {
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::liquidity(inner) => {
+                    <liquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::maxLiquidityPerTick(inner) => {
+                    <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::observations(inner) => {
+                    <observationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::observe(inner) => {
+                    <observeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::positions(inner) => {
+                    <positionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::protocolFees(inner) => {
+                    <protocolFeesCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::setFeeProtocol(inner) => {
+                    <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::slot0(inner) => {
+                    <slot0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::snapshotCumulativesInside(inner) => {
+                    <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::swap(inner) => {
+                    <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::tickBitmap(inner) => {
+                    <tickBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::tickSpacing(inner) => {
+                    <tickSpacingCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner,
+                        out,
+                    )
+                }
+                Self::ticks(inner) => {
+                    <ticksCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token0(inner) => {
+                    <token0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::token1(inner) => {
+                    <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`UniswapV3Pool`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum UniswapV3PoolEvents {
+        #[allow(missing_docs)]
+        Burn(Burn),
+        #[allow(missing_docs)]
+        Collect(Collect),
+        #[allow(missing_docs)]
+        CollectProtocol(CollectProtocol),
+        #[allow(missing_docs)]
+        Flash(Flash),
+        #[allow(missing_docs)]
+        IncreaseObservationCardinalityNext(IncreaseObservationCardinalityNext),
+        #[allow(missing_docs)]
+        Initialize(Initialize),
+        #[allow(missing_docs)]
+        Mint(Mint),
+        #[allow(missing_docs)]
+        SetFeeProtocol(SetFeeProtocol),
+        #[allow(missing_docs)]
+        Swap(Swap),
+    }
+    impl UniswapV3PoolEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                12u8, 57u8, 108u8, 217u8, 137u8, 163u8, 159u8, 68u8, 89u8, 181u8, 250u8, 26u8,
+                237u8, 106u8, 154u8, 141u8, 205u8, 188u8, 69u8, 144u8, 138u8, 207u8, 214u8, 126u8,
+                2u8, 140u8, 213u8, 104u8, 218u8, 152u8, 152u8, 44u8,
+            ],
+            [
+                89u8, 107u8, 87u8, 57u8, 6u8, 33u8, 141u8, 52u8, 17u8, 133u8, 11u8, 38u8, 166u8,
+                180u8, 55u8, 214u8, 196u8, 82u8, 47u8, 219u8, 67u8, 210u8, 210u8, 56u8, 98u8, 99u8,
+                248u8, 109u8, 80u8, 184u8, 177u8, 81u8,
+            ],
+            [
+                112u8, 147u8, 83u8, 56u8, 230u8, 151u8, 117u8, 69u8, 106u8, 133u8, 221u8, 239u8,
+                34u8, 108u8, 57u8, 95u8, 182u8, 104u8, 182u8, 63u8, 160u8, 17u8, 95u8, 95u8, 32u8,
+                97u8, 11u8, 56u8, 142u8, 108u8, 169u8, 192u8,
+            ],
+            [
+                122u8, 83u8, 8u8, 11u8, 164u8, 20u8, 21u8, 139u8, 231u8, 236u8, 105u8, 185u8,
+                135u8, 181u8, 251u8, 125u8, 7u8, 222u8, 225u8, 1u8, 254u8, 133u8, 72u8, 143u8, 8u8,
+                83u8, 174u8, 22u8, 35u8, 157u8, 11u8, 222u8,
+            ],
+            [
+                151u8, 61u8, 141u8, 146u8, 187u8, 41u8, 159u8, 74u8, 246u8, 206u8, 73u8, 181u8,
+                42u8, 138u8, 219u8, 133u8, 174u8, 70u8, 185u8, 242u8, 20u8, 196u8, 196u8, 252u8,
+                6u8, 172u8, 119u8, 64u8, 18u8, 55u8, 177u8, 51u8,
+            ],
+            [
+                152u8, 99u8, 96u8, 54u8, 203u8, 102u8, 169u8, 193u8, 154u8, 55u8, 67u8, 94u8,
+                252u8, 30u8, 144u8, 20u8, 33u8, 144u8, 33u8, 78u8, 138u8, 190u8, 184u8, 33u8,
+                189u8, 186u8, 63u8, 41u8, 144u8, 221u8, 76u8, 149u8,
+            ],
+            [
+                172u8, 73u8, 229u8, 24u8, 249u8, 10u8, 53u8, 143u8, 101u8, 46u8, 68u8, 0u8, 22u8,
+                79u8, 5u8, 165u8, 216u8, 247u8, 227u8, 94u8, 119u8, 71u8, 39u8, 155u8, 195u8,
+                169u8, 61u8, 191u8, 88u8, 78u8, 18u8, 90u8,
+            ],
+            [
+                189u8, 189u8, 183u8, 29u8, 120u8, 96u8, 55u8, 107u8, 165u8, 43u8, 37u8, 165u8, 2u8,
+                139u8, 238u8, 162u8, 53u8, 129u8, 54u8, 74u8, 64u8, 82u8, 47u8, 107u8, 207u8,
+                184u8, 107u8, 177u8, 242u8, 220u8, 166u8, 51u8,
+            ],
+            [
+                196u8, 32u8, 121u8, 249u8, 74u8, 99u8, 80u8, 215u8, 230u8, 35u8, 95u8, 41u8, 23u8,
+                73u8, 36u8, 249u8, 40u8, 204u8, 42u8, 200u8, 24u8, 235u8, 100u8, 254u8, 216u8, 0u8,
+                78u8, 17u8, 95u8, 188u8, 202u8, 103u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Burn as alloy_sol_types::SolEvent>::SIGNATURE,
+            <CollectProtocol as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Collect as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Mint as alloy_sol_types::SolEvent>::SIGNATURE,
+            <SetFeeProtocol as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Initialize as alloy_sol_types::SolEvent>::SIGNATURE,
+            <IncreaseObservationCardinalityNext as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Flash as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Swap as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(Burn),
+            ::core::stringify!(CollectProtocol),
+            ::core::stringify!(Collect),
+            ::core::stringify!(Mint),
+            ::core::stringify!(SetFeeProtocol),
+            ::core::stringify!(Initialize),
+            ::core::stringify!(IncreaseObservationCardinalityNext),
+            ::core::stringify!(Flash),
+            ::core::stringify!(Swap),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for UniswapV3PoolEvents {
+        const COUNT: usize = 9usize;
+        const NAME: &'static str = "UniswapV3PoolEvents";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Burn as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Burn as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Burn)
+                }
+                Some(<Collect as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Collect as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Collect)
+                }
+                Some(<CollectProtocol as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <CollectProtocol as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::CollectProtocol)
+                }
+                Some(<Flash as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Flash as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Flash)
+                }
+                Some(
+                    <IncreaseObservationCardinalityNext as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
+                ) => {
+                    <IncreaseObservationCardinalityNext as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::IncreaseObservationCardinalityNext)
+                }
+                Some(<Initialize as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Initialize as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::Initialize)
+                }
+                Some(<Mint as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Mint as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Mint)
+                }
+                Some(<SetFeeProtocol as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <SetFeeProtocol as alloy_sol_types::SolEvent>::decode_raw_log(
+                            topics,
+                            data,
+                        )
+                        .map(Self::SetFeeProtocol)
+                }
+                Some(<Swap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Swap as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Swap)
+                }
+                _ => {
+                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                        log: alloy_sol_types::private::Box::new(
+                            alloy_sol_types::private::LogData::new_unchecked(
+                                topics.to_vec(),
+                                data.to_vec().into(),
+                            ),
+                        ),
+                    })
+                }
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for UniswapV3PoolEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Burn(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Collect(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::CollectProtocol(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Flash(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::IncreaseObservationCardinalityNext(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Initialize(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Mint(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::SetFeeProtocol(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Burn(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Collect(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::CollectProtocol(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Flash(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::IncreaseObservationCardinalityNext(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Initialize(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Mint(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::SetFeeProtocol(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Swap(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`UniswapV3Pool`](self) contract instance.
+
+    See the [wrapper's documentation](`UniswapV3PoolInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> UniswapV3PoolInstance<P, N> {
+        UniswapV3PoolInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`UniswapV3Pool`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`UniswapV3Pool`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct UniswapV3PoolInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for UniswapV3PoolInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("UniswapV3PoolInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3PoolInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`UniswapV3Pool`](self) contract instance.
+
+        See the [wrapper's documentation](`UniswapV3PoolInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> UniswapV3PoolInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> UniswapV3PoolInstance<P, N> {
+            UniswapV3PoolInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3PoolInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`burn`] function.
+        pub fn burn(
+            &self,
+            tickLower: alloy_sol_types::private::primitives::aliases::I24,
+            tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+            amount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, burnCall, N> {
+            self.call_builder(&burnCall {
+                tickLower,
+                tickUpper,
+                amount,
+            })
+        }
+
+        ///Creates a new call builder for the [`collect`] function.
+        pub fn collect(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            tickLower: alloy_sol_types::private::primitives::aliases::I24,
+            tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+            amount0Requested: u128,
+            amount1Requested: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, collectCall, N> {
+            self.call_builder(&collectCall {
+                recipient,
+                tickLower,
+                tickUpper,
+                amount0Requested,
+                amount1Requested,
+            })
+        }
+
+        ///Creates a new call builder for the [`collectProtocol`] function.
+        pub fn collectProtocol(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount0Requested: u128,
+            amount1Requested: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, collectProtocolCall, N> {
+            self.call_builder(&collectProtocolCall {
+                recipient,
+                amount0Requested,
+                amount1Requested,
+            })
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`fee`] function.
+        pub fn fee(&self) -> alloy_contract::SolCallBuilder<&P, feeCall, N> {
+            self.call_builder(&feeCall)
+        }
+
+        ///Creates a new call builder for the [`feeGrowthGlobal0X128`]
+        /// function.
+        pub fn feeGrowthGlobal0X128(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, feeGrowthGlobal0X128Call, N> {
+            self.call_builder(&feeGrowthGlobal0X128Call)
+        }
+
+        ///Creates a new call builder for the [`feeGrowthGlobal1X128`]
+        /// function.
+        pub fn feeGrowthGlobal1X128(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, feeGrowthGlobal1X128Call, N> {
+            self.call_builder(&feeGrowthGlobal1X128Call)
+        }
+
+        ///Creates a new call builder for the [`flash`] function.
+        pub fn flash(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            amount0: alloy_sol_types::private::primitives::aliases::U256,
+            amount1: alloy_sol_types::private::primitives::aliases::U256,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, flashCall, N> {
+            self.call_builder(&flashCall {
+                recipient,
+                amount0,
+                amount1,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the
+        /// [`increaseObservationCardinalityNext`] function.
+        pub fn increaseObservationCardinalityNext(
+            &self,
+            observationCardinalityNext: u16,
+        ) -> alloy_contract::SolCallBuilder<&P, increaseObservationCardinalityNextCall, N> {
+            self.call_builder(&increaseObservationCardinalityNextCall {
+                observationCardinalityNext,
+            })
+        }
+
+        ///Creates a new call builder for the [`initialize`] function.
+        pub fn initialize(
+            &self,
+            sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
+        ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
+            self.call_builder(&initializeCall { sqrtPriceX96 })
+        }
+
+        ///Creates a new call builder for the [`liquidity`] function.
+        pub fn liquidity(&self) -> alloy_contract::SolCallBuilder<&P, liquidityCall, N> {
+            self.call_builder(&liquidityCall)
+        }
+
+        ///Creates a new call builder for the [`maxLiquidityPerTick`] function.
+        pub fn maxLiquidityPerTick(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, maxLiquidityPerTickCall, N> {
+            self.call_builder(&maxLiquidityPerTickCall)
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            tickLower: alloy_sol_types::private::primitives::aliases::I24,
+            tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+            amount: u128,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall {
+                recipient,
+                tickLower,
+                tickUpper,
+                amount,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the [`observations`] function.
+        pub fn observations(
+            &self,
+            _0: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, observationsCall, N> {
+            self.call_builder(&observationsCall(_0))
+        }
+
+        ///Creates a new call builder for the [`observe`] function.
+        pub fn observe(
+            &self,
+            secondsAgos: alloy_sol_types::private::Vec<u32>,
+        ) -> alloy_contract::SolCallBuilder<&P, observeCall, N> {
+            self.call_builder(&observeCall { secondsAgos })
+        }
+
+        ///Creates a new call builder for the [`positions`] function.
+        pub fn positions(
+            &self,
+            _0: alloy_sol_types::private::FixedBytes<32>,
+        ) -> alloy_contract::SolCallBuilder<&P, positionsCall, N> {
+            self.call_builder(&positionsCall(_0))
+        }
+
+        ///Creates a new call builder for the [`protocolFees`] function.
+        pub fn protocolFees(&self) -> alloy_contract::SolCallBuilder<&P, protocolFeesCall, N> {
+            self.call_builder(&protocolFeesCall)
+        }
+
+        ///Creates a new call builder for the [`setFeeProtocol`] function.
+        pub fn setFeeProtocol(
+            &self,
+            feeProtocol0: u8,
+            feeProtocol1: u8,
+        ) -> alloy_contract::SolCallBuilder<&P, setFeeProtocolCall, N> {
+            self.call_builder(&setFeeProtocolCall {
+                feeProtocol0,
+                feeProtocol1,
+            })
+        }
+
+        ///Creates a new call builder for the [`slot0`] function.
+        pub fn slot0(&self) -> alloy_contract::SolCallBuilder<&P, slot0Call, N> {
+            self.call_builder(&slot0Call)
+        }
+
+        ///Creates a new call builder for the [`snapshotCumulativesInside`]
+        /// function.
+        pub fn snapshotCumulativesInside(
+            &self,
+            tickLower: alloy_sol_types::private::primitives::aliases::I24,
+            tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        ) -> alloy_contract::SolCallBuilder<&P, snapshotCumulativesInsideCall, N> {
+            self.call_builder(&snapshotCumulativesInsideCall {
+                tickLower,
+                tickUpper,
+            })
+        }
+
+        ///Creates a new call builder for the [`swap`] function.
+        pub fn swap(
+            &self,
+            recipient: alloy_sol_types::private::Address,
+            zeroForOne: bool,
+            amountSpecified: alloy_sol_types::private::primitives::aliases::I256,
+            sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
+            data: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, swapCall, N> {
+            self.call_builder(&swapCall {
+                recipient,
+                zeroForOne,
+                amountSpecified,
+                sqrtPriceLimitX96,
+                data,
+            })
+        }
+
+        ///Creates a new call builder for the [`tickBitmap`] function.
+        pub fn tickBitmap(&self, _0: i16) -> alloy_contract::SolCallBuilder<&P, tickBitmapCall, N> {
+            self.call_builder(&tickBitmapCall(_0))
+        }
+
+        ///Creates a new call builder for the [`tickSpacing`] function.
+        pub fn tickSpacing(&self) -> alloy_contract::SolCallBuilder<&P, tickSpacingCall, N> {
+            self.call_builder(&tickSpacingCall)
+        }
+
+        ///Creates a new call builder for the [`ticks`] function.
+        pub fn ticks(
+            &self,
+            _0: alloy_sol_types::private::primitives::aliases::I24,
+        ) -> alloy_contract::SolCallBuilder<&P, ticksCall, N> {
+            self.call_builder(&ticksCall(_0))
+        }
+
+        ///Creates a new call builder for the [`token0`] function.
+        pub fn token0(&self) -> alloy_contract::SolCallBuilder<&P, token0Call, N> {
+            self.call_builder(&token0Call)
+        }
+
+        ///Creates a new call builder for the [`token1`] function.
+        pub fn token1(&self) -> alloy_contract::SolCallBuilder<&P, token1Call, N> {
+            self.call_builder(&token1Call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3PoolInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Burn`] event.
+        pub fn Burn_filter(&self) -> alloy_contract::Event<&P, Burn, N> {
+            self.event_filter::<Burn>()
+        }
+
+        ///Creates a new event filter for the [`Collect`] event.
+        pub fn Collect_filter(&self) -> alloy_contract::Event<&P, Collect, N> {
+            self.event_filter::<Collect>()
+        }
+
+        ///Creates a new event filter for the [`CollectProtocol`] event.
+        pub fn CollectProtocol_filter(&self) -> alloy_contract::Event<&P, CollectProtocol, N> {
+            self.event_filter::<CollectProtocol>()
+        }
+
+        ///Creates a new event filter for the [`Flash`] event.
+        pub fn Flash_filter(&self) -> alloy_contract::Event<&P, Flash, N> {
+            self.event_filter::<Flash>()
+        }
+
+        ///Creates a new event filter for the
+        /// [`IncreaseObservationCardinalityNext`] event.
+        pub fn IncreaseObservationCardinalityNext_filter(
+            &self,
+        ) -> alloy_contract::Event<&P, IncreaseObservationCardinalityNext, N> {
+            self.event_filter::<IncreaseObservationCardinalityNext>()
+        }
+
+        ///Creates a new event filter for the [`Initialize`] event.
+        pub fn Initialize_filter(&self) -> alloy_contract::Event<&P, Initialize, N> {
+            self.event_filter::<Initialize>()
+        }
+
+        ///Creates a new event filter for the [`Mint`] event.
+        pub fn Mint_filter(&self) -> alloy_contract::Event<&P, Mint, N> {
+            self.event_filter::<Mint>()
+        }
+
+        ///Creates a new event filter for the [`SetFeeProtocol`] event.
+        pub fn SetFeeProtocol_filter(&self) -> alloy_contract::Event<&P, SetFeeProtocol, N> {
+            self.event_filter::<SetFeeProtocol>()
+        }
+
+        ///Creates a new event filter for the [`Swap`] event.
+        pub fn Swap_filter(&self) -> alloy_contract::Event<&P, Swap, N> {
+            self.event_filter::<Swap>()
+        }
+    }
+}
+pub type Instance = UniswapV3Pool::UniswapV3PoolInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/uniswapv3quoterv2/Cargo.toml b/contracts/generated/contracts-generated/uniswapv3quoterv2/Cargo.toml
new file mode 100644
index 0000000000..6bbff33248
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv3quoterv2/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-uniswapv3quoterv2"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
new file mode 100644
index 0000000000..f9cb522cbb
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
@@ -0,0 +1,2960 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IQuoterV2 {
+    struct QuoteExactInputSingleParams { address tokenIn; address tokenOut; uint256 amountIn; uint24 fee; uint160 sqrtPriceLimitX96; }
+    struct QuoteExactOutputSingleParams { address tokenIn; address tokenOut; uint256 amount; uint24 fee; uint160 sqrtPriceLimitX96; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IQuoterV2 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct QuoteExactInputSingleParams { address tokenIn; address tokenOut; uint256 amountIn; uint24 fee; uint160 sqrtPriceLimitX96; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct QuoteExactInputSingleParams {
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+        #[allow(missing_docs)]
+        pub sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<24>,
+            alloy_sol_types::sol_data::Uint<160>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U24,
+            alloy_sol_types::private::primitives::aliases::U160,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<QuoteExactInputSingleParams> for UnderlyingRustTuple<'_> {
+            fn from(value: QuoteExactInputSingleParams) -> Self {
+                (
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.amountIn,
+                    value.fee,
+                    value.sqrtPriceLimitX96,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuoteExactInputSingleParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    tokenIn: tuple.0,
+                    tokenOut: tuple.1,
+                    amountIn: tuple.2,
+                    fee: tuple.3,
+                    sqrtPriceLimitX96: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for QuoteExactInputSingleParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for QuoteExactInputSingleParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceLimitX96,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for QuoteExactInputSingleParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for QuoteExactInputSingleParams {
+            const NAME: &'static str = "QuoteExactInputSingleParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "QuoteExactInputSingleParams(address tokenIn,address tokenOut,uint256 \
+                     amountIn,uint24 fee,uint160 sqrtPriceLimitX96)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amountIn)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        24,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fee)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sqrtPriceLimitX96,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for QuoteExactInputSingleParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amountIn,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        24,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fee)
+                    + <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sqrtPriceLimitX96,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amountIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.fee, out);
+                <alloy_sol_types::sol_data::Uint<
+                    160,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sqrtPriceLimitX96,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct QuoteExactOutputSingleParams { address tokenIn; address tokenOut; uint256 amount; uint24 fee; uint160 sqrtPriceLimitX96; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct QuoteExactOutputSingleParams {
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+        #[allow(missing_docs)]
+        pub sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<24>,
+            alloy_sol_types::sol_data::Uint<160>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U24,
+            alloy_sol_types::private::primitives::aliases::U160,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<QuoteExactOutputSingleParams> for UnderlyingRustTuple<'_> {
+            fn from(value: QuoteExactOutputSingleParams) -> Self {
+                (
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.amount,
+                    value.fee,
+                    value.sqrtPriceLimitX96,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for QuoteExactOutputSingleParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    tokenIn: tuple.0,
+                    tokenOut: tuple.1,
+                    amount: tuple.2,
+                    fee: tuple.3,
+                    sqrtPriceLimitX96: tuple.4,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for QuoteExactOutputSingleParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for QuoteExactOutputSingleParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceLimitX96,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for QuoteExactOutputSingleParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for QuoteExactOutputSingleParams {
+            const NAME: &'static str = "QuoteExactOutputSingleParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "QuoteExactOutputSingleParams(address tokenIn,address tokenOut,uint256 \
+                     amount,uint24 fee,uint160 sqrtPriceLimitX96)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        24,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fee)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sqrtPriceLimitX96,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for QuoteExactOutputSingleParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        24,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fee)
+                    + <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sqrtPriceLimitX96,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.fee, out);
+                <alloy_sol_types::sol_data::Uint<
+                    160,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sqrtPriceLimitX96,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IQuoterV2`](self) contract instance.
+
+    See the [wrapper's documentation](`IQuoterV2Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IQuoterV2Instance<P, N> {
+        IQuoterV2Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`IQuoterV2`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IQuoterV2`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IQuoterV2Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IQuoterV2Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IQuoterV2Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IQuoterV2Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IQuoterV2`](self) contract instance.
+
+        See the [wrapper's documentation](`IQuoterV2Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IQuoterV2Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IQuoterV2Instance<P, N> {
+            IQuoterV2Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IQuoterV2Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IQuoterV2Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IQuoterV2 {
+    struct QuoteExactInputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint256 amountIn;
+        uint24 fee;
+        uint160 sqrtPriceLimitX96;
+    }
+    struct QuoteExactOutputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        uint24 fee;
+        uint160 sqrtPriceLimitX96;
+    }
+}
+
+interface UniswapV3QuoterV2 {
+    constructor(address _factory, address _WETH9);
+
+    function WETH9() external view returns (address);
+    function factory() external view returns (address);
+    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut, uint160[] memory sqrtPriceX96AfterList, uint32[] memory initializedTicksCrossedList, uint256 gasEstimate);
+    function quoteExactInputSingle(IQuoterV2.QuoteExactInputSingleParams memory params) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
+    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn, uint160[] memory sqrtPriceX96AfterList, uint32[] memory initializedTicksCrossedList, uint256 gasEstimate);
+    function quoteExactOutputSingle(IQuoterV2.QuoteExactOutputSingleParams memory params) external returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory path) external view;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_factory",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_WETH9",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "WETH9",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "quoteExactInput",
+    "inputs": [
+      {
+        "name": "path",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "sqrtPriceX96AfterList",
+        "type": "uint160[]",
+        "internalType": "uint160[]"
+      },
+      {
+        "name": "initializedTicksCrossedList",
+        "type": "uint32[]",
+        "internalType": "uint32[]"
+      },
+      {
+        "name": "gasEstimate",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "quoteExactInputSingle",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IQuoterV2.QuoteExactInputSingleParams",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amountIn",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fee",
+            "type": "uint24",
+            "internalType": "uint24"
+          },
+          {
+            "name": "sqrtPriceLimitX96",
+            "type": "uint160",
+            "internalType": "uint160"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "sqrtPriceX96After",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "initializedTicksCrossed",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "gasEstimate",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "quoteExactOutput",
+    "inputs": [
+      {
+        "name": "path",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "sqrtPriceX96AfterList",
+        "type": "uint160[]",
+        "internalType": "uint160[]"
+      },
+      {
+        "name": "initializedTicksCrossedList",
+        "type": "uint32[]",
+        "internalType": "uint32[]"
+      },
+      {
+        "name": "gasEstimate",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "quoteExactOutputSingle",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IQuoterV2.QuoteExactOutputSingleParams",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "fee",
+            "type": "uint24",
+            "internalType": "uint24"
+          },
+          {
+            "name": "sqrtPriceLimitX96",
+            "type": "uint160",
+            "internalType": "uint160"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "sqrtPriceX96After",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "initializedTicksCrossed",
+        "type": "uint32",
+        "internalType": "uint32"
+      },
+      {
+        "name": "gasEstimate",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "uniswapV3SwapCallback",
+    "inputs": [
+      {
+        "name": "amount0Delta",
+        "type": "int256",
+        "internalType": "int256"
+      },
+      {
+        "name": "amount1Delta",
+        "type": "int256",
+        "internalType": "int256"
+      },
+      {
+        "name": "path",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod UniswapV3QuoterV2 {
+    use {super::*, alloy_sol_types};
+    /**Constructor`.
+    ```solidity
+    constructor(address _factory, address _WETH9);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _factory: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _WETH9: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._factory, value._WETH9)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _factory: tuple.0,
+                        _WETH9: tuple.1,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._factory,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._WETH9,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `WETH9()` and selector `0x4aa4a4fc`.
+    ```solidity
+    function WETH9() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETH9Call;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH9()`](WETH9Call)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct WETH9Return {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETH9Call> for UnderlyingRustTuple<'_> {
+                fn from(value: WETH9Call) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETH9Call {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<WETH9Return> for UnderlyingRustTuple<'_> {
+                fn from(value: WETH9Return) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETH9Return {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for WETH9Call {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [74u8, 164u8, 164u8, 252u8];
+            const SIGNATURE: &'static str = "WETH9()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETH9Return = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: WETH9Return = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `factory()` and selector `0xc45a0155`.
+    ```solidity
+    function factory() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`factory()`](factoryCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quoteExactInput(bytes,uint256)` and selector `0xcdca1753`.
+    ```solidity
+    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut, uint160[] memory sqrtPriceX96AfterList, uint32[] memory initializedTicksCrossedList, uint256 gasEstimate);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactInputCall {
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quoteExactInput(bytes,uint256)`](quoteExactInputCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactInputReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub sqrtPriceX96AfterList:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
+        #[allow(missing_docs)]
+        pub initializedTicksCrossedList: alloy_sol_types::private::Vec<u32>,
+        #[allow(missing_docs)]
+        pub gasEstimate: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactInputCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactInputCall) -> Self {
+                    (value.path, value.amountIn)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactInputCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        path: tuple.0,
+                        amountIn: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
+                alloy_sol_types::private::Vec<u32>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactInputReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactInputReturn) -> Self {
+                    (
+                        value.amountOut,
+                        value.sqrtPriceX96AfterList,
+                        value.initializedTicksCrossedList,
+                        value.gasEstimate,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactInputReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        sqrtPriceX96AfterList: tuple.1,
+                        initializedTicksCrossedList: tuple.2,
+                        gasEstimate: tuple.3,
+                    }
+                }
+            }
+        }
+        impl quoteExactInputReturn {
+            fn _tokenize(
+                &self,
+            ) -> <quoteExactInputCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<160>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96AfterList,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<32>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.initializedTicksCrossedList,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.gasEstimate),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteExactInputCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = quoteExactInputReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [205u8, 202u8, 23u8, 83u8];
+            const SIGNATURE: &'static str = "quoteExactInput(bytes,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.path,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                quoteExactInputReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quoteExactInputSingle((address,address,uint256,uint24,uint160))` and selector `0xc6a5026a`.
+    ```solidity
+    function quoteExactInputSingle(IQuoterV2.QuoteExactInputSingleParams memory params) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactInputSingleCall {
+        #[allow(missing_docs)]
+        pub params: <IQuoterV2::QuoteExactInputSingleParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quoteExactInputSingle((address,address,uint256,uint24,
+    /// uint160))`](quoteExactInputSingleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactInputSingleReturn {
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub sqrtPriceX96After: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub initializedTicksCrossed: u32,
+        #[allow(missing_docs)]
+        pub gasEstimate: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IQuoterV2::QuoteExactInputSingleParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IQuoterV2::QuoteExactInputSingleParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactInputSingleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactInputSingleCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactInputSingleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U160,
+                u32,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactInputSingleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactInputSingleReturn) -> Self {
+                    (
+                        value.amountOut,
+                        value.sqrtPriceX96After,
+                        value.initializedTicksCrossed,
+                        value.gasEstimate,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactInputSingleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountOut: tuple.0,
+                        sqrtPriceX96After: tuple.1,
+                        initializedTicksCrossed: tuple.2,
+                        gasEstimate: tuple.3,
+                    }
+                }
+            }
+        }
+        impl quoteExactInputSingleReturn {
+            fn _tokenize(
+                &self,
+            ) -> <quoteExactInputSingleCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96After,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.initializedTicksCrossed,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasEstimate,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteExactInputSingleCall {
+            type Parameters<'a> = (IQuoterV2::QuoteExactInputSingleParams,);
+            type Return = quoteExactInputSingleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [198u8, 165u8, 2u8, 106u8];
+            const SIGNATURE: &'static str =
+                "quoteExactInputSingle((address,address,uint256,uint24,uint160))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IQuoterV2::QuoteExactInputSingleParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                quoteExactInputSingleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quoteExactOutput(bytes,uint256)` and selector `0x2f80bb1d`.
+    ```solidity
+    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn, uint160[] memory sqrtPriceX96AfterList, uint32[] memory initializedTicksCrossedList, uint256 gasEstimate);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactOutputCall {
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quoteExactOutput(bytes,uint256)`](quoteExactOutputCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactOutputReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub sqrtPriceX96AfterList:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
+        #[allow(missing_docs)]
+        pub initializedTicksCrossedList: alloy_sol_types::private::Vec<u32>,
+        #[allow(missing_docs)]
+        pub gasEstimate: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactOutputCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactOutputCall) -> Self {
+                    (value.path, value.amountOut)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactOutputCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        path: tuple.0,
+                        amountOut: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
+                alloy_sol_types::private::Vec<u32>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactOutputReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactOutputReturn) -> Self {
+                    (
+                        value.amountIn,
+                        value.sqrtPriceX96AfterList,
+                        value.initializedTicksCrossedList,
+                        value.gasEstimate,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactOutputReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        sqrtPriceX96AfterList: tuple.1,
+                        initializedTicksCrossedList: tuple.2,
+                        gasEstimate: tuple.3,
+                    }
+                }
+            }
+        }
+        impl quoteExactOutputReturn {
+            fn _tokenize(
+                &self,
+            ) -> <quoteExactOutputCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<160>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96AfterList,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<32>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.initializedTicksCrossedList,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.gasEstimate),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteExactOutputCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = quoteExactOutputReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [47u8, 128u8, 187u8, 29u8];
+            const SIGNATURE: &'static str = "quoteExactOutput(bytes,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.path,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                quoteExactOutputReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `quoteExactOutputSingle((address,address,uint256,uint24,uint160))` and selector `0xbd21704a`.
+    ```solidity
+    function quoteExactOutputSingle(IQuoterV2.QuoteExactOutputSingleParams memory params) external returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactOutputSingleCall {
+        #[allow(missing_docs)]
+        pub params: <IQuoterV2::QuoteExactOutputSingleParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`quoteExactOutputSingle((address,address,uint256,uint24,
+    /// uint160))`](quoteExactOutputSingleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct quoteExactOutputSingleReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub sqrtPriceX96After: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub initializedTicksCrossed: u32,
+        #[allow(missing_docs)]
+        pub gasEstimate: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IQuoterV2::QuoteExactOutputSingleParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IQuoterV2::QuoteExactOutputSingleParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactOutputSingleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactOutputSingleCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactOutputSingleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U160,
+                u32,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<quoteExactOutputSingleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteExactOutputSingleReturn) -> Self {
+                    (
+                        value.amountIn,
+                        value.sqrtPriceX96After,
+                        value.initializedTicksCrossed,
+                        value.gasEstimate,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteExactOutputSingleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amountIn: tuple.0,
+                        sqrtPriceX96After: tuple.1,
+                        initializedTicksCrossed: tuple.2,
+                        gasEstimate: tuple.3,
+                    }
+                }
+            }
+        }
+        impl quoteExactOutputSingleReturn {
+            fn _tokenize(
+                &self,
+            ) -> <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountIn,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96After,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.initializedTicksCrossed,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasEstimate,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for quoteExactOutputSingleCall {
+            type Parameters<'a> = (IQuoterV2::QuoteExactOutputSingleParams,);
+            type Return = quoteExactOutputSingleReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [189u8, 33u8, 112u8, 74u8];
+            const SIGNATURE: &'static str =
+                "quoteExactOutputSingle((address,address,uint256,uint24,uint160))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IQuoterV2::QuoteExactOutputSingleParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                quoteExactOutputSingleReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `uniswapV3SwapCallback(int256,int256,bytes)` and selector `0xfa461e33`.
+    ```solidity
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory path) external view;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct uniswapV3SwapCallbackCall {
+        #[allow(missing_docs)]
+        pub amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub path: alloy_sol_types::private::Bytes,
+    }
+    ///Container type for the return parameters of the
+    /// [`uniswapV3SwapCallback(int256,int256,
+    /// bytes)`](uniswapV3SwapCallbackCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct uniswapV3SwapCallbackReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::Bytes,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<uniswapV3SwapCallbackCall> for UnderlyingRustTuple<'_> {
+                fn from(value: uniswapV3SwapCallbackCall) -> Self {
+                    (value.amount0Delta, value.amount1Delta, value.path)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        amount0Delta: tuple.0,
+                        amount1Delta: tuple.1,
+                        path: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<uniswapV3SwapCallbackReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: uniswapV3SwapCallbackReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl uniswapV3SwapCallbackReturn {
+            fn _tokenize(
+                &self,
+            ) -> <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for uniswapV3SwapCallbackCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = uniswapV3SwapCallbackReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [250u8, 70u8, 30u8, 51u8];
+            const SIGNATURE: &'static str = "uniswapV3SwapCallback(int256,int256,bytes)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0Delta,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1Delta,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.path,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                uniswapV3SwapCallbackReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`UniswapV3QuoterV2`](self) function calls.
+    #[derive(Clone)]
+    pub enum UniswapV3QuoterV2Calls {
+        #[allow(missing_docs)]
+        WETH9(WETH9Call),
+        #[allow(missing_docs)]
+        factory(factoryCall),
+        #[allow(missing_docs)]
+        quoteExactInput(quoteExactInputCall),
+        #[allow(missing_docs)]
+        quoteExactInputSingle(quoteExactInputSingleCall),
+        #[allow(missing_docs)]
+        quoteExactOutput(quoteExactOutputCall),
+        #[allow(missing_docs)]
+        quoteExactOutputSingle(quoteExactOutputSingleCall),
+        #[allow(missing_docs)]
+        uniswapV3SwapCallback(uniswapV3SwapCallbackCall),
+    }
+    impl UniswapV3QuoterV2Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 128u8, 187u8, 29u8],
+            [74u8, 164u8, 164u8, 252u8],
+            [189u8, 33u8, 112u8, 74u8],
+            [196u8, 90u8, 1u8, 85u8],
+            [198u8, 165u8, 2u8, 106u8],
+            [205u8, 202u8, 23u8, 83u8],
+            [250u8, 70u8, 30u8, 51u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <quoteExactOutputCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <WETH9Call as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteExactInputSingleCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <quoteExactInputCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(quoteExactOutput),
+            ::core::stringify!(WETH9),
+            ::core::stringify!(quoteExactOutputSingle),
+            ::core::stringify!(factory),
+            ::core::stringify!(quoteExactInputSingle),
+            ::core::stringify!(quoteExactInput),
+            ::core::stringify!(uniswapV3SwapCallback),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for UniswapV3QuoterV2Calls {
+        const COUNT: usize = 7usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "UniswapV3QuoterV2Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH9(_) => <WETH9Call as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::quoteExactInput(_) => {
+                    <quoteExactInputCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quoteExactInputSingle(_) => {
+                    <quoteExactInputSingleCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quoteExactOutput(_) => {
+                    <quoteExactOutputCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::quoteExactOutputSingle(_) => {
+                    <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::uniswapV3SwapCallback(_) => {
+                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>] =
+                &[
+                    {
+                        fn quoteExactOutput(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>
+                        {
+                            <quoteExactOutputCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV3QuoterV2Calls::quoteExactOutput)
+                        }
+                        quoteExactOutput
+                    },
+                    {
+                        fn WETH9(data: &[u8]) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                            <WETH9Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV3QuoterV2Calls::WETH9)
+                        }
+                        WETH9
+                    },
+                    {
+                        fn quoteExactOutputSingle(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>
+                        {
+                            <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV3QuoterV2Calls::quoteExactOutputSingle)
+                        }
+                        quoteExactOutputSingle
+                    },
+                    {
+                        fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                            <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV3QuoterV2Calls::factory)
+                        }
+                        factory
+                    },
+                    {
+                        fn quoteExactInputSingle(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>
+                        {
+                            <quoteExactInputSingleCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV3QuoterV2Calls::quoteExactInputSingle)
+                        }
+                        quoteExactInputSingle
+                    },
+                    {
+                        fn quoteExactInput(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>
+                        {
+                            <quoteExactInputCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                                .map(UniswapV3QuoterV2Calls::quoteExactInput)
+                        }
+                        quoteExactInput
+                    },
+                    {
+                        fn uniswapV3SwapCallback(
+                            data: &[u8],
+                        ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>
+                        {
+                            <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(UniswapV3QuoterV2Calls::uniswapV3SwapCallback)
+                        }
+                        uniswapV3SwapCallback
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                UniswapV3QuoterV2Calls,
+            >] = &[
+                {
+                    fn quoteExactOutput(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <quoteExactOutputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV3QuoterV2Calls::quoteExactOutput)
+                    }
+                    quoteExactOutput
+                },
+                {
+                    fn WETH9(data: &[u8]) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <WETH9Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3QuoterV2Calls::WETH9)
+                    }
+                    WETH9
+                },
+                {
+                    fn quoteExactOutputSingle(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3QuoterV2Calls::quoteExactOutputSingle)
+                    }
+                    quoteExactOutputSingle
+                },
+                {
+                    fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(UniswapV3QuoterV2Calls::factory)
+                    }
+                    factory
+                },
+                {
+                    fn quoteExactInputSingle(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <quoteExactInputSingleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3QuoterV2Calls::quoteExactInputSingle)
+                    }
+                    quoteExactInputSingle
+                },
+                {
+                    fn quoteExactInput(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <quoteExactInputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(UniswapV3QuoterV2Calls::quoteExactInput)
+                    }
+                    quoteExactInput
+                },
+                {
+                    fn uniswapV3SwapCallback(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
+                        <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(UniswapV3QuoterV2Calls::uniswapV3SwapCallback)
+                    }
+                    uniswapV3SwapCallback
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::WETH9(inner) => {
+                    <WETH9Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::quoteExactInput(inner) => {
+                    <quoteExactInputCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::quoteExactInputSingle(inner) => {
+                    <quoteExactInputSingleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::quoteExactOutput(inner) => {
+                    <quoteExactOutputCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::quoteExactOutputSingle(inner) => {
+                    <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::uniswapV3SwapCallback(inner) => {
+                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::WETH9(inner) => {
+                    <WETH9Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::quoteExactInput(inner) => {
+                    <quoteExactInputCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::quoteExactInputSingle(inner) => {
+                    <quoteExactInputSingleCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::quoteExactOutput(inner) => {
+                    <quoteExactOutputCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::quoteExactOutputSingle(inner) => {
+                    <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::uniswapV3SwapCallback(inner) => {
+                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`UniswapV3QuoterV2`](self) contract instance.
+
+    See the [wrapper's documentation](`UniswapV3QuoterV2Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> UniswapV3QuoterV2Instance<P, N> {
+        UniswapV3QuoterV2Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`UniswapV3QuoterV2`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`UniswapV3QuoterV2`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct UniswapV3QuoterV2Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for UniswapV3QuoterV2Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("UniswapV3QuoterV2Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3QuoterV2Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`UniswapV3QuoterV2`](self) contract instance.
+
+        See the [wrapper's documentation](`UniswapV3QuoterV2Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> UniswapV3QuoterV2Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> UniswapV3QuoterV2Instance<P, N> {
+            UniswapV3QuoterV2Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3QuoterV2Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`WETH9`] function.
+        pub fn WETH9(&self) -> alloy_contract::SolCallBuilder<&P, WETH9Call, N> {
+            self.call_builder(&WETH9Call)
+        }
+
+        ///Creates a new call builder for the [`factory`] function.
+        pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
+            self.call_builder(&factoryCall)
+        }
+
+        ///Creates a new call builder for the [`quoteExactInput`] function.
+        pub fn quoteExactInput(
+            &self,
+            path: alloy_sol_types::private::Bytes,
+            amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteExactInputCall, N> {
+            self.call_builder(&quoteExactInputCall { path, amountIn })
+        }
+
+        ///Creates a new call builder for the [`quoteExactInputSingle`]
+        /// function.
+        pub fn quoteExactInputSingle(
+            &self,
+            params: <IQuoterV2::QuoteExactInputSingleParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteExactInputSingleCall, N> {
+            self.call_builder(&quoteExactInputSingleCall { params })
+        }
+
+        ///Creates a new call builder for the [`quoteExactOutput`] function.
+        pub fn quoteExactOutput(
+            &self,
+            path: alloy_sol_types::private::Bytes,
+            amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteExactOutputCall, N> {
+            self.call_builder(&quoteExactOutputCall { path, amountOut })
+        }
+
+        ///Creates a new call builder for the [`quoteExactOutputSingle`]
+        /// function.
+        pub fn quoteExactOutputSingle(
+            &self,
+            params: <IQuoterV2::QuoteExactOutputSingleParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, quoteExactOutputSingleCall, N> {
+            self.call_builder(&quoteExactOutputSingleCall { params })
+        }
+
+        ///Creates a new call builder for the [`uniswapV3SwapCallback`]
+        /// function.
+        pub fn uniswapV3SwapCallback(
+            &self,
+            amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
+            amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
+            path: alloy_sol_types::private::Bytes,
+        ) -> alloy_contract::SolCallBuilder<&P, uniswapV3SwapCallbackCall, N> {
+            self.call_builder(&uniswapV3SwapCallbackCall {
+                amount0Delta,
+                amount1Delta,
+                path,
+            })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3QuoterV2Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = UniswapV3QuoterV2::UniswapV3QuoterV2Instance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x61fFE014bA17989E743c5F6cB21bF9697530B21e"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x61fFE014bA17989E743c5F6cB21bF9697530B21e"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0x78D78E420Da98ad378D7799bE8f4AF69033EB077"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x61fFE014bA17989E743c5F6cB21bF9697530B21e"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x1eEA2B790Dc527c5a4cd3d4f3ae8A2DDB65B2af1"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0xaa52bB8110fE38D0d2d2AF0B85C3A3eE622CA455"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x61fFE014bA17989E743c5F6cB21bF9697530B21e"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xbe0F5544EC67e9B3b2D979aaA43f18Fd87E6257F"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x96b572D2d880cf2Fa2563651BD23ADE6f5516652"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x42bE4D6527829FeFA1493e1fb9F3676d2425C3C1"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/uniswapv3swaprouterv2/Cargo.toml b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/Cargo.toml
new file mode 100644
index 0000000000..8114568730
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-uniswapv3swaprouterv2"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
new file mode 100644
index 0000000000..1870e65c85
--- /dev/null
+++ b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
@@ -0,0 +1,1073 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+///Module containing a contract's types and functions.
+/**
+
+```solidity
+library IV3SwapRouter {
+    struct ExactOutputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96; }
+}
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IV3SwapRouter {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct ExactOutputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ExactOutputSingleParams {
+        #[allow(missing_docs)]
+        pub tokenIn: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokenOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub fee: alloy_sol_types::private::primitives::aliases::U24,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountInMaximum: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<24>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Uint<160>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U24,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::primitives::aliases::U160,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ExactOutputSingleParams> for UnderlyingRustTuple<'_> {
+            fn from(value: ExactOutputSingleParams) -> Self {
+                (
+                    value.tokenIn,
+                    value.tokenOut,
+                    value.fee,
+                    value.recipient,
+                    value.amountOut,
+                    value.amountInMaximum,
+                    value.sqrtPriceLimitX96,
+                )
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExactOutputSingleParams {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    tokenIn: tuple.0,
+                    tokenOut: tuple.1,
+                    fee: tuple.2,
+                    recipient: tuple.3,
+                    amountOut: tuple.4,
+                    amountInMaximum: tuple.5,
+                    sqrtPriceLimitX96: tuple.6,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for ExactOutputSingleParams {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for ExactOutputSingleParams {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenIn,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.fee,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountOut,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountInMaximum,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceLimitX96,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for ExactOutputSingleParams {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for ExactOutputSingleParams {
+            const NAME: &'static str = "ExactOutputSingleParams";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "ExactOutputSingleParams(address tokenIn,address tokenOut,uint24 fee,address \
+                     recipient,uint256 amountOut,uint256 amountInMaximum,uint160 \
+                     sqrtPriceLimitX96)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenIn,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.tokenOut,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        24,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fee)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amountOut)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.amountInMaximum,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sqrtPriceLimitX96,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for ExactOutputSingleParams {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenIn,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.tokenOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        24,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fee)
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amountOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amountInMaximum,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        160,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sqrtPriceLimitX96,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenIn,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.tokenOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    24,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.fee, out);
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amountOut,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amountInMaximum,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    160,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sqrtPriceLimitX96,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IV3SwapRouter`](self) contract instance.
+
+    See the [wrapper's documentation](`IV3SwapRouterInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IV3SwapRouterInstance<P, N> {
+        IV3SwapRouterInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IV3SwapRouter`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IV3SwapRouter`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IV3SwapRouterInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IV3SwapRouterInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IV3SwapRouterInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IV3SwapRouterInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IV3SwapRouter`](self) contract instance.
+
+        See the [wrapper's documentation](`IV3SwapRouterInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IV3SwapRouterInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IV3SwapRouterInstance<P, N> {
+            IV3SwapRouterInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IV3SwapRouterInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IV3SwapRouterInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+/**
+
+Generated by the following Solidity interface...
+```solidity
+library IV3SwapRouter {
+    struct ExactOutputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 amountOut;
+        uint256 amountInMaximum;
+        uint160 sqrtPriceLimitX96;
+    }
+}
+
+interface UniswapV3SwapRouterV2 {
+    function exactOutputSingle(IV3SwapRouter.ExactOutputSingleParams memory params) external payable returns (uint256 amountIn);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "exactOutputSingle",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct IV3SwapRouter.ExactOutputSingleParams",
+        "components": [
+          {
+            "name": "tokenIn",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "tokenOut",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fee",
+            "type": "uint24",
+            "internalType": "uint24"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amountOut",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "amountInMaximum",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "sqrtPriceLimitX96",
+            "type": "uint160",
+            "internalType": "uint160"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod UniswapV3SwapRouterV2 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `exactOutputSingle((address,address,uint24,address,uint256,uint256,uint160))` and selector `0x5023b4df`.
+    ```solidity
+    function exactOutputSingle(IV3SwapRouter.ExactOutputSingleParams memory params) external payable returns (uint256 amountIn);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct exactOutputSingleCall {
+        #[allow(missing_docs)]
+        pub params: <IV3SwapRouter::ExactOutputSingleParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`exactOutputSingle((address,address,uint24,address,uint256,uint256,
+    /// uint160))`](exactOutputSingleCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct exactOutputSingleReturn {
+        #[allow(missing_docs)]
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (IV3SwapRouter::ExactOutputSingleParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<IV3SwapRouter::ExactOutputSingleParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<exactOutputSingleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: exactOutputSingleCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exactOutputSingleCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<exactOutputSingleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: exactOutputSingleReturn) -> Self {
+                    (value.amountIn,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exactOutputSingleReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { amountIn: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for exactOutputSingleCall {
+            type Parameters<'a> = (IV3SwapRouter::ExactOutputSingleParams,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [80u8, 35u8, 180u8, 223u8];
+            const SIGNATURE: &'static str =
+                "exactOutputSingle((address,address,uint24,address,uint256,uint256,uint160))";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <IV3SwapRouter::ExactOutputSingleParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: exactOutputSingleReturn = r.into();
+                        r.amountIn
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: exactOutputSingleReturn = r.into();
+                    r.amountIn
+                })
+            }
+        }
+    };
+    ///Container for all the [`UniswapV3SwapRouterV2`](self) function calls.
+    #[derive(Clone)]
+    pub enum UniswapV3SwapRouterV2Calls {
+        #[allow(missing_docs)]
+        exactOutputSingle(exactOutputSingleCall),
+    }
+    impl UniswapV3SwapRouterV2Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[80u8, 35u8, 180u8, 223u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<exactOutputSingleCall as alloy_sol_types::SolCall>::SIGNATURE];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(exactOutputSingle)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for UniswapV3SwapRouterV2Calls {
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 224usize;
+        const NAME: &'static str = "UniswapV3SwapRouterV2Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::exactOutputSingle(_) => {
+                    <exactOutputSingleCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<UniswapV3SwapRouterV2Calls>] = &[{
+                fn exactOutputSingle(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<UniswapV3SwapRouterV2Calls> {
+                    <exactOutputSingleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(UniswapV3SwapRouterV2Calls::exactOutputSingle)
+                }
+                exactOutputSingle
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                UniswapV3SwapRouterV2Calls,
+            >] = &[{
+                fn exactOutputSingle(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<UniswapV3SwapRouterV2Calls> {
+                    <exactOutputSingleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        data,
+                    )
+                    .map(UniswapV3SwapRouterV2Calls::exactOutputSingle)
+                }
+                exactOutputSingle
+            }];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::exactOutputSingle(inner) => {
+                    <exactOutputSingleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::exactOutputSingle(inner) => {
+                    <exactOutputSingleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`UniswapV3SwapRouterV2`](self) contract instance.
+
+    See the [wrapper's documentation](`UniswapV3SwapRouterV2Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> UniswapV3SwapRouterV2Instance<P, N> {
+        UniswapV3SwapRouterV2Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`UniswapV3SwapRouterV2`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`UniswapV3SwapRouterV2`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct UniswapV3SwapRouterV2Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for UniswapV3SwapRouterV2Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("UniswapV3SwapRouterV2Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3SwapRouterV2Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`UniswapV3SwapRouterV2`](self) contract instance.
+
+        See the [wrapper's documentation](`UniswapV3SwapRouterV2Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> UniswapV3SwapRouterV2Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> UniswapV3SwapRouterV2Instance<P, N> {
+            UniswapV3SwapRouterV2Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3SwapRouterV2Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`exactOutputSingle`] function.
+        pub fn exactOutputSingle(
+            &self,
+            params: <IV3SwapRouter::ExactOutputSingleParams as alloy_sol_types::SolType>::RustType,
+        ) -> alloy_contract::SolCallBuilder<&P, exactOutputSingleCall, N> {
+            self.call_builder(&exactOutputSingleCall { params })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        UniswapV3SwapRouterV2Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance =
+    UniswapV3SwapRouterV2::UniswapV3SwapRouterV2Instance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x6ddD32cd941041D8b61df213B9f515A7D288Dc13"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x2626664c2603336E57B271c5C0b26F421741e481"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x807F4E281B7A3B324825C64ca53c69F0b418dE40"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xbb00FF08d01D300023C629E8fFfFcb65A5a578cE"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x177778F19E89dD1012BdBe603F144088A95C4B53"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/contracts-generated/weth9/Cargo.toml b/contracts/generated/contracts-generated/weth9/Cargo.toml
new file mode 100644
index 0000000000..2bd1f8db76
--- /dev/null
+++ b/contracts/generated/contracts-generated/weth9/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-weth9"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/weth9/src/lib.rs b/contracts/generated/contracts-generated/weth9/src/lib.rs
new file mode 100644
index 0000000000..e1db1eefad
--- /dev/null
+++ b/contracts/generated/contracts-generated/weth9/src/lib.rs
@@ -0,0 +1,3301 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface WETH9 {
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    fallback() external payable;
+
+    function allowance(address, address) external view returns (uint256);
+    function approve(address guy, uint256 wad) external returns (bool);
+    function balanceOf(address) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function deposit() external payable;
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address dst, uint256 wad) external returns (bool);
+    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
+    function withdraw(uint256 wad) external;
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "fallback",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address"
+      },
+      {
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "guy",
+        "type": "address"
+      },
+      {
+        "name": "wad",
+        "type": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "deposit",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "dst",
+        "type": "address"
+      },
+      {
+        "name": "wad",
+        "type": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "src",
+        "type": "address"
+      },
+      {
+        "name": "dst",
+        "type": "address"
+      },
+      {
+        "name": "wad",
+        "type": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "withdraw",
+    "inputs": [
+      {
+        "name": "wad",
+        "type": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "src",
+        "type": "address",
+        "indexed": true
+      },
+      {
+        "name": "guy",
+        "type": "address",
+        "indexed": true
+      },
+      {
+        "name": "wad",
+        "type": "uint256",
+        "indexed": false
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Deposit",
+    "inputs": [
+      {
+        "name": "dst",
+        "type": "address",
+        "indexed": true
+      },
+      {
+        "name": "wad",
+        "type": "uint256",
+        "indexed": false
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "src",
+        "type": "address",
+        "indexed": true
+      },
+      {
+        "name": "dst",
+        "type": "address",
+        "indexed": true
+      },
+      {
+        "name": "wad",
+        "type": "uint256",
+        "indexed": false
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Withdrawal",
+    "inputs": [
+      {
+        "name": "src",
+        "type": "address",
+        "indexed": true
+      },
+      {
+        "name": "wad",
+        "type": "uint256",
+        "indexed": false
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod WETH9 {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`@\x80Q\x90\x81\x01`@R\x80`\r\x81R` \x01\x7FWrapped Ether\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP`\0\x90\x80Q\x90` \x01\x90a\0O\x92\x91\x90a\0\xCAV[P`@\x80Q\x90\x81\x01`@R\x80`\x04\x81R` \x01\x7FWETH\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP`\x01\x90\x80Q\x90` \x01\x90a\0\x9B\x92\x91\x90a\0\xCAV[P`\x12`\x02`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP4\x80\x15a\0\xC4W`\0\x80\xFD[Pa\x01oV[\x82\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x90`\0R` `\0 \x90`\x1F\x01` \x90\x04\x81\x01\x92\x82`\x1F\x10a\x01\x0BW\x80Q`\xFF\x19\x16\x83\x80\x01\x17\x85Ua\x019V[\x82\x80\x01`\x01\x01\x85U\x82\x15a\x019W\x91\x82\x01[\x82\x81\x11\x15a\x018W\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90a\x01\x1DV[[P\x90Pa\x01F\x91\x90a\x01JV[P\x90V[a\x01l\x91\x90[\x80\x82\x11\x15a\x01hW`\0\x81`\0\x90UP`\x01\x01a\x01PV[P\x90V[\x90V[a\x0C\xD8\x80a\x01~`\09`\0\xF3\xFE`\x80`@R`\x046\x10a\0\xAFW`\x005|\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04c\xFF\xFF\xFF\xFF\x16\x80c\x06\xFD\xDE\x03\x14a\0\xB9W\x80c\t^\xA7\xB3\x14a\x01IW\x80c\x18\x16\r\xDD\x14a\x01\xBCW\x80c#\xB8r\xDD\x14a\x01\xE7W\x80c.\x1A}M\x14a\x02zW\x80c1<\xE5g\x14a\x02\xB5W\x80cp\xA0\x821\x14a\x02\xE6W\x80c\x95\xD8\x9BA\x14a\x03KW\x80c\xA9\x05\x9C\xBB\x14a\x03\xDBW\x80c\xD0\xE3\r\xB0\x14a\x04NW\x80c\xDDb\xED>\x14a\x04XW[a\0\xB7a\x04\xDDV[\0[4\x80\x15a\0\xC5W`\0\x80\xFD[Pa\0\xCEa\x05zV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x01\x0EW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\0\xF3V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x01;W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01UW`\0\x80\xFD[Pa\x01\xA2`\x04\x806\x03`@\x81\x10\x15a\x01lW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x06\x18V[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xC8W`\0\x80\xFD[Pa\x01\xD1a\x07\nV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xF3W`\0\x80\xFD[Pa\x02``\x04\x806\x03``\x81\x10\x15a\x02\nW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x07)V[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x86W`\0\x80\xFD[Pa\x02\xB3`\x04\x806\x03` \x81\x10\x15a\x02\x9DW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa\nvV[\0[4\x80\x15a\x02\xC1W`\0\x80\xFD[Pa\x02\xCAa\x0B\xA9V[`@Q\x80\x82`\xFF\x16`\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xF2W`\0\x80\xFD[Pa\x035`\x04\x806\x03` \x81\x10\x15a\x03\tW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x0B\xBCV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03WW`\0\x80\xFD[Pa\x03`a\x0B\xD4V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x03\xA0W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x03\x85V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x03\xCDW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xE7W`\0\x80\xFD[Pa\x044`\x04\x806\x03`@\x81\x10\x15a\x03\xFEW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x0CrV[`@Q\x80\x82\x15\x15\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[a\x04Va\x04\xDDV[\0[4\x80\x15a\x04dW`\0\x80\xFD[Pa\x04\xC7`\x04\x806\x03`@\x81\x10\x15a\x04{W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa\x0C\x87V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4`\x03`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82T\x01\x92PP\x81\x90UP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xE1\xFF\xFC\xC4\x92=\x04\xB5Y\xF4\xD2\x9A\x8B\xFCl\xDA\x04\xEB[\r<F\x07Q\xC2@,\\\\\xC9\x10\x9C4`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA2V[`\0\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x80\x15a\x06\x10W\x80`\x1F\x10a\x05\xE5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x10V[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xF3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81V[`\0\x81`\x04`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x84`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA3`\x01\x90P\x92\x91PPV[`\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x161\x90P\x90V[`\0\x81`\x03`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x10\x15\x15\x15a\x07yW`\0\x80\xFD[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x08QWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x14\x15[\x15a\tlW\x81`\x04`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x10\x15\x15\x15a\x08\xE1W`\0\x80\xFD[\x81`\x04`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82T\x03\x92PP\x81\x90UP[\x81`\x03`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82T\x03\x92PP\x81\x90UP\x81`\x03`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82T\x01\x92PP\x81\x90UP\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x84`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA3`\x01\x90P\x93\x92PPPV[\x80`\x03`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x10\x15\x15\x15a\n\xC4W`\0\x80\xFD[\x80`\x03`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82T\x03\x92PP\x81\x90UP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x08\xFC\x82\x90\x81\x15\x02\x90`@Q`\0`@Q\x80\x83\x03\x81\x85\x88\x88\xF1\x93PPPP\x15\x80\x15a\x0BWW=`\0\x80>=`\0\xFD[P3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x7F\xCFS,\x15\xF0\xA6\xDB\x0B\xD6\xD0\xE08\xBE\xA7\x1D0\xD8\x08\xC7\xD9\x8C\xB3\xBFrh\xA9[\xF5\x08\x1Be\x82`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA2PV[`\x02`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\x03` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\x01\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T`\x01\x81`\x01\x16\x15a\x01\0\x02\x03\x16`\x02\x90\x04\x80\x15a\x0CjW\x80`\x1F\x10a\x0C?Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0CjV[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0CMW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81V[`\0a\x0C\x7F3\x84\x84a\x07)V[\x90P\x92\x91PPV[`\x04` R\x81`\0R`@`\0 ` R\x80`\0R`@`\0 `\0\x91P\x91PPT\x81V\xFE\xA1ebzzr0X \x89\xF5\xA5\t\xECI\xDE\xF9\xE0\xFDi\x99o~\xA7\xCBB\xAD\xB1O\x13Oq\xEA\x03K\x8C\xE3\x9D\xF0\xA1\xE0\0)",
+    );
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub src: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub guy: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    src: topics.1,
+                    guy: topics.2,
+                    wad: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.src.clone(),
+                    self.guy.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.src,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.guy,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Deposit(address,uint256)` and selector `0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c`.
+    ```solidity
+    event Deposit(address indexed dst, uint256 wad);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Deposit {
+        #[allow(missing_docs)]
+        pub dst: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Deposit {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Deposit(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8, 154u8,
+                    139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8, 7u8, 81u8,
+                    194u8, 64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    dst: topics.1,
+                    wad: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.dst.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.dst,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Deposit {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Deposit> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Deposit) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub src: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub dst: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    src: topics.1,
+                    dst: topics.2,
+                    wad: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.src.clone(),
+                    self.dst.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.src,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.dst,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Withdrawal(address,uint256)` and selector `0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65`.
+    ```solidity
+    event Withdrawal(address indexed src, uint256 wad);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Withdrawal {
+        #[allow(missing_docs)]
+        pub src: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Withdrawal {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Withdrawal(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    127u8, 207u8, 83u8, 44u8, 21u8, 240u8, 166u8, 219u8, 11u8, 214u8, 208u8, 224u8,
+                    56u8, 190u8, 167u8, 29u8, 48u8, 216u8, 8u8, 199u8, 217u8, 140u8, 179u8, 191u8,
+                    114u8, 104u8, 169u8, 91u8, 245u8, 8u8, 27u8, 101u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    src: topics.1,
+                    wad: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.src.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.src,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Withdrawal {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Withdrawal> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Withdrawal) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address, address) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address guy, uint256 wad) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub guy: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.guy, value.wad)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        guy: tuple.0,
+                        wad: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.guy,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall(pub alloy_sol_types::private::Address);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `deposit()` and selector `0xd0e30db0`.
+    ```solidity
+    function deposit() external payable;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct depositCall;
+    ///Container type for the return parameters of the
+    /// [`deposit()`](depositCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct depositReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
+                fn from(value: depositCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: depositReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl depositReturn {
+            fn _tokenize(&self) -> <depositCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for depositCall {
+            type Parameters<'a> = ();
+            type Return = depositReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [208u8, 227u8, 13u8, 176u8];
+            const SIGNATURE: &'static str = "deposit()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                depositReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    ```solidity
+    function totalSupply() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`totalSupply()`](totalSupplyCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct totalSupplyReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: totalSupplyReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for totalSupplyCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
+            const SIGNATURE: &'static str = "totalSupply()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: totalSupplyReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: totalSupplyReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address dst, uint256 wad) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub dst: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.dst, value.wad)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        dst: tuple.0,
+                        wad: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.dst,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address src, address dst, uint256 wad) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub src: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub dst: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.src, value.dst, value.wad)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        src: tuple.0,
+                        dst: tuple.1,
+                        wad: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.src,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.dst,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `withdraw(uint256)` and selector `0x2e1a7d4d`.
+    ```solidity
+    function withdraw(uint256 wad) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct withdrawCall {
+        #[allow(missing_docs)]
+        pub wad: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`withdraw(uint256)`](withdrawCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct withdrawReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<withdrawCall> for UnderlyingRustTuple<'_> {
+                fn from(value: withdrawCall) -> Self {
+                    (value.wad,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { wad: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<withdrawReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: withdrawReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl withdrawReturn {
+            fn _tokenize(&self) -> <withdrawCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for withdrawCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = withdrawReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [46u8, 26u8, 125u8, 77u8];
+            const SIGNATURE: &'static str = "withdraw(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.wad,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                withdrawReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    ///Container for all the [`WETH9`](self) function calls.
+    #[derive(Clone)]
+    pub enum WETH9Calls {
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        deposit(depositCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        totalSupply(totalSupplyCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+        #[allow(missing_docs)]
+        withdraw(withdrawCall),
+    }
+    impl WETH9Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [24u8, 22u8, 13u8, 221u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [46u8, 26u8, 125u8, 77u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [208u8, 227u8, 13u8, 176u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <withdrawCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <depositCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(totalSupply),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(withdraw),
+            ::core::stringify!(decimals),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(symbol),
+            ::core::stringify!(transfer),
+            ::core::stringify!(deposit),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for WETH9Calls {
+        const COUNT: usize = 11usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "WETH9Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<WETH9Calls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn withdraw(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::withdraw)
+                    }
+                    withdraw
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn deposit(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <depositCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::deposit)
+                    }
+                    deposit
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(WETH9Calls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<WETH9Calls>] = &[
+                {
+                    fn name(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::name)
+                    }
+                    name
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::totalSupply)
+                    }
+                    totalSupply
+                },
+                {
+                    fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(WETH9Calls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn withdraw(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::withdraw)
+                    }
+                    withdraw
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn symbol(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::symbol)
+                    }
+                    symbol
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn deposit(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <depositCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::deposit)
+                    }
+                    deposit
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(WETH9Calls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::deposit(inner) => {
+                    <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::withdraw(inner) => {
+                    <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::deposit(inner) => {
+                    <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::totalSupply(inner) => {
+                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::withdraw(inner) => {
+                    <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    ///Container for all the [`WETH9`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum WETH9Events {
+        #[allow(missing_docs)]
+        Approval(Approval),
+        #[allow(missing_docs)]
+        Deposit(Deposit),
+        #[allow(missing_docs)]
+        Transfer(Transfer),
+        #[allow(missing_docs)]
+        Withdrawal(Withdrawal),
+    }
+    impl WETH9Events {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                127u8, 207u8, 83u8, 44u8, 21u8, 240u8, 166u8, 219u8, 11u8, 214u8, 208u8, 224u8,
+                56u8, 190u8, 167u8, 29u8, 48u8, 216u8, 8u8, 199u8, 217u8, 140u8, 179u8, 191u8,
+                114u8, 104u8, 169u8, 91u8, 245u8, 8u8, 27u8, 101u8,
+            ],
+            [
+                140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
+                32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+            ],
+            [
+                221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
+                252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
+                40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+            ],
+            [
+                225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8, 154u8,
+                139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8, 7u8, 81u8, 194u8,
+                64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <Withdrawal as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Approval as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Transfer as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Deposit as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(Withdrawal),
+            ::core::stringify!(Approval),
+            ::core::stringify!(Transfer),
+            ::core::stringify!(Deposit),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for WETH9Events {
+        const COUNT: usize = 4usize;
+        const NAME: &'static str = "WETH9Events";
+
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Approval)
+                }
+                Some(<Deposit as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Deposit as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Deposit)
+                }
+                Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Transfer)
+                }
+                Some(<Withdrawal as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Withdrawal as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Withdrawal)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for WETH9Events {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Deposit(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::Withdrawal(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
+        }
+
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::Approval(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Deposit(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
+                Self::Transfer(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Withdrawal(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`WETH9`](self) contract instance.
+
+    See the [wrapper's documentation](`WETH9Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> WETH9Instance<P, N> {
+        WETH9Instance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<WETH9Instance<P, N>>> {
+        WETH9Instance::<P, N>::deploy(__provider)
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        WETH9Instance::<P, N>::deploy_builder(__provider)
+    }
+    /**A [`WETH9`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`WETH9`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct WETH9Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for WETH9Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("WETH9Instance").field(&self.address).finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        WETH9Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`WETH9`](self) contract instance.
+
+        See the [wrapper's documentation](`WETH9Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(__provider: P) -> alloy_contract::Result<WETH9Instance<P, N>> {
+            let call_builder = Self::deploy_builder(__provider);
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                ::core::clone::Clone::clone(&BYTECODE),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> WETH9Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> WETH9Instance<P, N> {
+            WETH9Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        WETH9Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            guy: alloy_sol_types::private::Address,
+            wad: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { guy, wad })
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            _0: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall(_0))
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`deposit`] function.
+        pub fn deposit(&self) -> alloy_contract::SolCallBuilder<&P, depositCall, N> {
+            self.call_builder(&depositCall)
+        }
+
+        ///Creates a new call builder for the [`name`] function.
+        pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
+            self.call_builder(&nameCall)
+        }
+
+        ///Creates a new call builder for the [`symbol`] function.
+        pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
+            self.call_builder(&symbolCall)
+        }
+
+        ///Creates a new call builder for the [`totalSupply`] function.
+        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
+            self.call_builder(&totalSupplyCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            dst: alloy_sol_types::private::Address,
+            wad: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { dst, wad })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            src: alloy_sol_types::private::Address,
+            dst: alloy_sol_types::private::Address,
+            wad: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall { src, dst, wad })
+        }
+
+        ///Creates a new call builder for the [`withdraw`] function.
+        pub fn withdraw(
+            &self,
+            wad: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> {
+            self.call_builder(&withdrawCall { wad })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        WETH9Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+
+        ///Creates a new event filter for the [`Approval`] event.
+        pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
+            self.event_filter::<Approval>()
+        }
+
+        ///Creates a new event filter for the [`Deposit`] event.
+        pub fn Deposit_filter(&self) -> alloy_contract::Event<&P, Deposit, N> {
+            self.event_filter::<Deposit>()
+        }
+
+        ///Creates a new event filter for the [`Transfer`] event.
+        pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
+            self.event_filter::<Transfer>()
+        }
+
+        ///Creates a new event filter for the [`Withdrawal`] event.
+        pub fn Withdrawal_filter(&self) -> alloy_contract::Event<&P, Withdrawal, N> {
+            self.event_filter::<Withdrawal>()
+        }
+    }
+}
+pub type Instance = WETH9::WETH9Instance<::alloy_provider::DynProvider>;
+use {
+    alloy_primitives::{Address, address},
+    alloy_provider::{DynProvider, Provider},
+    anyhow::{Context, Result},
+    std::{collections::HashMap, sync::LazyLock},
+};
+pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+    match chain_id {
+        1u64 => Some((
+            ::alloy_primitives::address!("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+            None,
+        )),
+        10u64 => Some((
+            ::alloy_primitives::address!("0x4200000000000000000000000000000000000006"),
+            None,
+        )),
+        56u64 => Some((
+            ::alloy_primitives::address!("0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"),
+            None,
+        )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d"),
+            None,
+        )),
+        137u64 => Some((
+            ::alloy_primitives::address!("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+            None,
+        )),
+        232u64 => Some((
+            ::alloy_primitives::address!("0x6bDc36E20D267Ff0dd6097799f82e78907105e2F"),
+            None,
+        )),
+        8453u64 => Some((
+            ::alloy_primitives::address!("0x4200000000000000000000000000000000000006"),
+            None,
+        )),
+        9745u64 => Some((
+            ::alloy_primitives::address!("0x6100E367285b01F48D07953803A2d8dCA5D19873"),
+            None,
+        )),
+        42161u64 => Some((
+            ::alloy_primitives::address!("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+            None,
+        )),
+        43114u64 => Some((
+            ::alloy_primitives::address!("0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7"),
+            None,
+        )),
+        57073u64 => Some((
+            ::alloy_primitives::address!("0x4200000000000000000000000000000000000006"),
+            None,
+        )),
+        59144u64 => Some((
+            ::alloy_primitives::address!("0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f"),
+            None,
+        )),
+        11155111u64 => Some((
+            ::alloy_primitives::address!("0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14"),
+            None,
+        )),
+        _ => None,
+    }
+}
+pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+    match deployment_info(*chain_id) {
+        Some((address, _)) => Some(address),
+        None => None,
+    }
+}
+pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+    match deployment_info(*chain_id) {
+        Some((_, block)) => block,
+        None => None,
+    }
+}
+impl Instance {
+    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+        async move {
+            let chain_id = provider
+                .get_chain_id()
+                .await
+                .context("could not fetch current chain id")?;
+            let (address, _deployed_block) = deployment_info(chain_id)
+                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+            Ok(Instance::new(address, provider.clone()))
+        }
+    }
+}
diff --git a/contracts/generated/rustfmt.toml b/contracts/generated/rustfmt.toml
new file mode 100644
index 0000000000..2349451ea0
--- /dev/null
+++ b/contracts/generated/rustfmt.toml
@@ -0,0 +1,12 @@
+format_code_in_doc_comments = true
+format_strings = true
+imports_layout = "HorizontalVertical"
+imports_granularity = "One"
+normalize_doc_attributes = true
+reorder_impl_items = true
+group_imports = "StdExternalCrate"
+use_try_shorthand = true
+wrap_comments = true
+remove_nested_parens = true
+unstable_features = true
+use_field_init_shorthand = true
diff --git a/crates/contracts/script/DeployBalances.s.sol b/contracts/script/DeployBalances.s.sol
similarity index 100%
rename from crates/contracts/script/DeployBalances.s.sol
rename to contracts/script/DeployBalances.s.sol
diff --git a/crates/contracts/script/DeploySignatures.s.sol b/contracts/script/DeploySignatures.s.sol
similarity index 100%
rename from crates/contracts/script/DeploySignatures.s.sol
rename to contracts/script/DeploySignatures.s.sol
diff --git a/crates/contracts/solidity/AnyoneAuthenticator.sol b/contracts/solidity/AnyoneAuthenticator.sol
similarity index 100%
rename from crates/contracts/solidity/AnyoneAuthenticator.sol
rename to contracts/solidity/AnyoneAuthenticator.sol
diff --git a/crates/contracts/solidity/Balances.sol b/contracts/solidity/Balances.sol
similarity index 100%
rename from crates/contracts/solidity/Balances.sol
rename to contracts/solidity/Balances.sol
diff --git a/crates/contracts/solidity/CowSettlementForwarder.sol b/contracts/solidity/CowSettlementForwarder.sol
similarity index 100%
rename from crates/contracts/solidity/CowSettlementForwarder.sol
rename to contracts/solidity/CowSettlementForwarder.sol
diff --git a/crates/contracts/solidity/Makefile b/contracts/solidity/Makefile
similarity index 97%
rename from crates/contracts/solidity/Makefile
rename to contracts/solidity/Makefile
index af5933bd9d..ef57ef6090 100644
--- a/crates/contracts/solidity/Makefile
+++ b/contracts/solidity/Makefile
@@ -4,7 +4,7 @@ JQ     := jq
 SOLC     := ethereum/solc:0.8.30
 SOLFLAGS := --overwrite --abi --bin --bin-runtime --metadata-hash none --optimize --optimize-runs 1000000 --evm-version shanghai
 
-TARGETDIR   := ../../../target/solidity
+TARGETDIR   := ../target/solidity
 ARTIFACTDIR := ../artifacts
 
 CONTRACTS := \
diff --git a/crates/contracts/solidity/README.md b/contracts/solidity/README.md
similarity index 100%
rename from crates/contracts/solidity/README.md
rename to contracts/solidity/README.md
diff --git a/crates/contracts/solidity/Signatures.sol b/contracts/solidity/Signatures.sol
similarity index 100%
rename from crates/contracts/solidity/Signatures.sol
rename to contracts/solidity/Signatures.sol
diff --git a/crates/contracts/solidity/Solver.sol b/contracts/solidity/Solver.sol
similarity index 100%
rename from crates/contracts/solidity/Solver.sol
rename to contracts/solidity/Solver.sol
diff --git a/crates/contracts/solidity/Spardose.sol b/contracts/solidity/Spardose.sol
similarity index 100%
rename from crates/contracts/solidity/Spardose.sol
rename to contracts/solidity/Spardose.sol
diff --git a/crates/contracts/solidity/Swapper.sol b/contracts/solidity/Swapper.sol
similarity index 100%
rename from crates/contracts/solidity/Swapper.sol
rename to contracts/solidity/Swapper.sol
diff --git a/crates/contracts/solidity/Trader.sol b/contracts/solidity/Trader.sol
similarity index 100%
rename from crates/contracts/solidity/Trader.sol
rename to contracts/solidity/Trader.sol
diff --git a/crates/contracts/solidity/interfaces/IERC1271.sol b/contracts/solidity/interfaces/IERC1271.sol
similarity index 100%
rename from crates/contracts/solidity/interfaces/IERC1271.sol
rename to contracts/solidity/interfaces/IERC1271.sol
diff --git a/crates/contracts/solidity/interfaces/IERC20.sol b/contracts/solidity/interfaces/IERC20.sol
similarity index 100%
rename from crates/contracts/solidity/interfaces/IERC20.sol
rename to contracts/solidity/interfaces/IERC20.sol
diff --git a/crates/contracts/solidity/interfaces/ISettlement.sol b/contracts/solidity/interfaces/ISettlement.sol
similarity index 100%
rename from crates/contracts/solidity/interfaces/ISettlement.sol
rename to contracts/solidity/interfaces/ISettlement.sol
diff --git a/crates/contracts/solidity/interfaces/IStorageAccessible.sol b/contracts/solidity/interfaces/IStorageAccessible.sol
similarity index 100%
rename from crates/contracts/solidity/interfaces/IStorageAccessible.sol
rename to contracts/solidity/interfaces/IStorageAccessible.sol
diff --git a/crates/contracts/solidity/interfaces/IVault.sol b/contracts/solidity/interfaces/IVault.sol
similarity index 100%
rename from crates/contracts/solidity/interfaces/IVault.sol
rename to contracts/solidity/interfaces/IVault.sol
diff --git a/crates/contracts/solidity/interfaces/IVaultRelayer.sol b/contracts/solidity/interfaces/IVaultRelayer.sol
similarity index 100%
rename from crates/contracts/solidity/interfaces/IVaultRelayer.sol
rename to contracts/solidity/interfaces/IVaultRelayer.sol
diff --git a/crates/contracts/solidity/libraries/Caller.sol b/contracts/solidity/libraries/Caller.sol
similarity index 100%
rename from crates/contracts/solidity/libraries/Caller.sol
rename to contracts/solidity/libraries/Caller.sol
diff --git a/crates/contracts/solidity/libraries/Math.sol b/contracts/solidity/libraries/Math.sol
similarity index 100%
rename from crates/contracts/solidity/libraries/Math.sol
rename to contracts/solidity/libraries/Math.sol
diff --git a/crates/contracts/solidity/libraries/SafeERC20.sol b/contracts/solidity/libraries/SafeERC20.sol
similarity index 100%
rename from crates/contracts/solidity/libraries/SafeERC20.sol
rename to contracts/solidity/libraries/SafeERC20.sol
diff --git a/crates/contracts/solidity/tests/Counter.sol b/contracts/solidity/tests/Counter.sol
similarity index 100%
rename from crates/contracts/solidity/tests/Counter.sol
rename to contracts/solidity/tests/Counter.sol
diff --git a/crates/contracts/solidity/tests/GasHog.sol b/contracts/solidity/tests/GasHog.sol
similarity index 100%
rename from crates/contracts/solidity/tests/GasHog.sol
rename to contracts/solidity/tests/GasHog.sol
diff --git a/crates/contracts/solidity/tests/NonStandardERC20Balances.sol b/contracts/solidity/tests/NonStandardERC20Balances.sol
similarity index 100%
rename from crates/contracts/solidity/tests/NonStandardERC20Balances.sol
rename to contracts/solidity/tests/NonStandardERC20Balances.sol
diff --git a/crates/contracts/solidity/tests/RemoteERC20Balances.sol b/contracts/solidity/tests/RemoteERC20Balances.sol
similarity index 100%
rename from crates/contracts/solidity/tests/RemoteERC20Balances.sol
rename to contracts/solidity/tests/RemoteERC20Balances.sol
diff --git a/contracts/src/codegen.rs b/contracts/src/codegen.rs
new file mode 100644
index 0000000000..84c0822c76
--- /dev/null
+++ b/contracts/src/codegen.rs
@@ -0,0 +1,487 @@
+use {
+    alloy_sol_macro_expander::expand::expand,
+    alloy_sol_macro_input::{SolInput, SolInputKind},
+    anyhow::{Context, Result},
+    proc_macro2::{Span, TokenStream},
+    quote::{ToTokens, format_ident},
+    rayon::prelude::*,
+    std::{
+        collections::HashMap,
+        fmt::Write,
+        path::{Path, PathBuf},
+    },
+};
+
+/// Header for generated lib.rs files.
+const LIB_HEADER: &str = "\
+#![allow(unused_imports, unused_attributes, clippy::all, rustdoc::all, non_snake_case)]
+//! Auto-generated contract bindings. Do not edit.
+";
+
+/// Header for the facade lib.rs.
+const FACADE_HEADER: &str = "\
+#![allow(unused_imports, unused_attributes, clippy::all, rustdoc::all, non_snake_case)]
+//! This crate re-exports per-contract crate bindings.
+//! Auto-generated by contracts-generate. Do not edit.
+";
+
+/// Cargo.toml template for generated per-contract crates.
+const CARGO_TOML_TEMPLATE: &str = "\
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = \"{crate_name}\"
+version = \"0.1.0\"
+edition = \"2024\"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-primitives = { workspace = true }
+alloy-sol-types = { workspace = true }
+alloy-contract = { workspace = true }
+alloy-provider = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
+";
+
+/// Workspace Cargo.toml template for the generated workspace.
+const WORKSPACE_CARGO_TOML: &str = "\
+# Auto-generated by contracts-generate. Do not edit.
+[workspace]
+resolver = \"3\"
+members = [
+    \"contracts-facade\",
+    \"contracts-generated/*\",
+]
+
+[workspace.dependencies]
+alloy-primitives = { version =  \"1.5.7\", default-features = false }
+alloy-sol-types = { version =  \"1.5.7\", default-features = false }
+alloy-contract = { version =  \"1.7.3\" }
+alloy-provider = { version =  \"1.7.3\", default-features = false }
+anyhow = \"1.0.100\"
+
+[workspace.lints.clippy]
+all = \"warn\"
+";
+
+/// Convert a PascalCase contract name to a kebab-case crate name.
+fn to_crate_name(contract_name: &str) -> String {
+    format!("cow-contract-{}", contract_name.to_lowercase())
+}
+
+/// Convert a contract name to a directory name under contracts-generated/.
+fn to_dir_name(contract_name: &str) -> String {
+    contract_name.to_lowercase()
+}
+
+/// Convert a crate name (kebab-case) to a Rust identifier (underscore_case).
+fn to_rust_ident(crate_name: &str) -> String {
+    crate_name.replace('-', "_")
+}
+
+/// Metadata about a generated contract crate, used for facade generation.
+struct CrateEntry {
+    contract_name: String,
+    crate_name: String,
+    dir_name: String,
+    submodule: Option<String>,
+}
+
+#[derive(Default)]
+pub struct Module {
+    pub contracts: Vec<Contract>,
+    pub submodules: Vec<Submodule>,
+}
+
+impl Module {
+    pub fn add_contract(mut self, contract: Contract) -> Self {
+        self.contracts.push(contract);
+        self
+    }
+
+    pub fn add_submodule(mut self, submodule: Submodule) -> Self {
+        self.submodules.push(submodule);
+        self
+    }
+
+    /// Generate a self-contained Cargo workspace under `output_dir` containing:
+    /// - `contracts-generated/<name>/` per-contract crates
+    /// - `contracts-facade/` facade crate that re-exports all contracts
+    /// - Root workspace `Cargo.toml`
+    pub fn generate(self, artifacts_dir: &Path, output_dir: &Path) -> Result<()> {
+        let contracts_generated_dir = output_dir.join("contracts-generated");
+        let facade_dir = output_dir.join("contracts-facade");
+
+        std::fs::create_dir_all(&contracts_generated_dir)?;
+        std::fs::create_dir_all(&facade_dir)?;
+
+        // Collect all contracts with their submodule association, then
+        // generate crates in parallel.
+        let entries: Vec<CrateEntry> = self
+            .contracts
+            .iter()
+            .map(|c| (c, None))
+            .chain(
+                self.submodules
+                    .iter()
+                    .flat_map(|s| s.contracts.iter().map(move |c| (c, Some(s.name.clone())))),
+            )
+            .collect::<Vec<_>>()
+            .into_par_iter()
+            .map(|(contract, submodule)| {
+                contract.write_crate(artifacts_dir, &contracts_generated_dir)?;
+                Ok(CrateEntry {
+                    contract_name: contract.name.clone(),
+                    crate_name: to_crate_name(&contract.name),
+                    dir_name: to_dir_name(&contract.name),
+                    submodule,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        let mut entries = entries;
+        entries.sort_by_key(|entry| entry.crate_name.clone());
+
+        // Generate the facade crate
+        write_facade_lib(&entries, &facade_dir)?;
+        write_facade_cargo_toml(&entries, &facade_dir)?;
+
+        // Generate the workspace Cargo.toml
+        write_workspace_cargo_toml(output_dir)?;
+
+        Ok(())
+    }
+}
+
+/// Generate the facade crate's lib.rs file.
+fn write_facade_lib(entries: &[CrateEntry], facade_dir: &Path) -> Result<()> {
+    let src_dir = facade_dir.join("src");
+    std::fs::create_dir_all(&src_dir)?;
+
+    let mut contents = String::from(FACADE_HEADER);
+
+    // Top-level re-exports
+    for entry in entries {
+        if entry.submodule.is_none() {
+            let rust_ident = to_rust_ident(&entry.crate_name);
+            writeln!(contents, "pub use {rust_ident} as {};", entry.contract_name)?;
+        }
+    }
+
+    // Group submodule contracts, preserving insertion order
+    let mut submodule_names: Vec<String> = Vec::new();
+    let mut submodule_map: HashMap<String, Vec<&CrateEntry>> = HashMap::new();
+    for entry in entries {
+        if let Some(submod) = &entry.submodule {
+            if !submodule_map.contains_key(submod) {
+                submodule_names.push(submod.clone());
+            }
+            submodule_map.entry(submod.clone()).or_default().push(entry);
+        }
+    }
+
+    // Write submodule blocks in insertion order
+    for submod_name in &submodule_names {
+        let contracts = &submodule_map[submod_name];
+        writeln!(contents, "pub mod {submod_name} {{")?;
+        for entry in contracts {
+            let rust_ident = to_rust_ident(&entry.crate_name);
+            writeln!(
+                contents,
+                "    pub use {rust_ident} as {};",
+                entry.contract_name
+            )?;
+        }
+        writeln!(contents, "}}")?;
+    }
+
+    let file: syn::File = syn::parse_file(&contents)?;
+    let formatted = prettyplease::unparse(&file);
+    std::fs::write(src_dir.join("lib.rs"), formatted)?;
+
+    Ok(())
+}
+
+/// Generate the facade crate's Cargo.toml.
+fn write_facade_cargo_toml(entries: &[CrateEntry], facade_dir: &Path) -> Result<()> {
+    let mut contents = String::from(
+        "\
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = \"contracts\"
+version = \"0.1.0\"
+edition = \"2024\"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+",
+    );
+
+    for entry in entries {
+        writeln!(
+            contents,
+            "{} = {{ path = \"../contracts-generated/{}\" }}",
+            entry.crate_name, entry.dir_name
+        )?;
+    }
+
+    contents.push_str("\n[lints]\nworkspace = true\n");
+
+    std::fs::write(facade_dir.join("Cargo.toml"), contents)?;
+    eprintln!("  generated facade Cargo.toml");
+
+    Ok(())
+}
+
+/// Generate the workspace root Cargo.toml.
+fn write_workspace_cargo_toml(output_dir: &Path) -> Result<()> {
+    std::fs::write(output_dir.join("Cargo.toml"), WORKSPACE_CARGO_TOML)?;
+    eprintln!("  generated workspace Cargo.toml");
+    Ok(())
+}
+
+pub struct Submodule {
+    pub name: String,
+    pub contracts: Vec<Contract>,
+}
+
+impl Submodule {
+    pub fn new<S: ToString>(name: S) -> Self {
+        Self {
+            name: name.to_string(),
+            contracts: vec![],
+        }
+    }
+
+    pub fn add_contract(mut self, contract: Contract) -> Self {
+        self.contracts.push(contract);
+        self
+    }
+}
+
+pub struct Contract {
+    pub name: String,
+    networks: HashMap<u64, (String, Option<u64>)>,
+}
+
+impl Contract {
+    pub fn new<S: AsRef<str>>(name: S) -> Self {
+        Self {
+            name: name.as_ref().to_string(),
+            networks: HashMap::new(),
+        }
+    }
+
+    pub fn with_networks<S, I>(mut self, networks: I) -> Self
+    where
+        S: AsRef<str>,
+        I: IntoIterator<Item = (u64, (S, Option<u64>))>,
+    {
+        for (id, (address, block_number)) in networks.into_iter() {
+            self.networks
+                .insert(id, (address.as_ref().to_string(), block_number));
+        }
+        self
+    }
+
+    fn artifacts_path(&self, artifacts_dir: &Path) -> PathBuf {
+        artifacts_dir.join(&self.name).with_extension("json")
+    }
+
+    /// Generate the Rust code for this contract's bindings.
+    fn generate_code(&self, artifacts_dir: &Path) -> Result<TokenStream> {
+        let bindings_path = self.artifacts_path(artifacts_dir);
+        let mut macrogen = SolMacroGen::new(bindings_path, self.name.clone());
+        generate_binding(&mut macrogen, true)?;
+        let mut expansion = macrogen
+            .expansion
+            .expect("if the expansion failed, it should have errored earlier");
+
+        let module_name_ident = format_ident!("{}", self.name);
+        let instance_name_ident = format_ident!("{}Instance", self.name);
+        let instance = quote::quote! {
+            pub type Instance = #module_name_ident :: #instance_name_ident<::alloy_provider::DynProvider>;
+        };
+        expansion.extend(instance);
+
+        if !self.networks.is_empty() {
+            let mut networks: Vec<_> = self
+                .networks
+                .iter()
+                .map(|(&chain_id, info)| NetworkArm(chain_id, (info.0.clone(), info.1)))
+                .collect();
+            // Sorting is required to keep generation stable and changes to a minimum
+            networks.sort_by_key(|arm| arm.0);
+            let deployment_info = quote::quote! {
+                use {
+                    std::{
+                        sync::LazyLock,
+                        collections::HashMap
+                    },
+                    anyhow::{Result, Context},
+                    alloy_primitives::{address, Address},
+                    alloy_provider::{Provider, DynProvider},
+                };
+
+                pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
+                    match chain_id {
+                        #( #networks ,)*
+                        _ => None
+                    }
+                }
+
+                pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
+                    match deployment_info(*chain_id) {
+                        Some((address, _)) => Some(address),
+                        None => None,
+                    }
+                }
+
+                pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
+                    match deployment_info(*chain_id) {
+                        Some((_, block)) => block,
+                        None => None,
+                    }
+                }
+
+                impl Instance {
+                    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
+                        async move {
+                            let chain_id = provider
+                                .get_chain_id()
+                                .await
+                                .context("could not fetch current chain id")?;
+
+                            let (address, _deployed_block) = deployment_info(chain_id)
+                                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
+
+                            Ok(Instance::new(
+                                address,
+                                provider.clone(),
+                            ))
+                        }
+                    }
+                }
+            };
+            expansion.extend(deployment_info);
+        }
+
+        Ok(expansion)
+    }
+
+    /// Write a per-contract crate to the contracts-generated directory.
+    fn write_crate(&self, artifacts_dir: &Path, contracts_generated_dir: &Path) -> Result<()> {
+        let crate_name = to_crate_name(&self.name);
+        let dir_name = to_dir_name(&self.name);
+        let crate_dir = contracts_generated_dir.join(&dir_name);
+        let src_dir = crate_dir.join("src");
+        std::fs::create_dir_all(&src_dir)?;
+
+        // Generate Cargo.toml
+        let cargo_toml = CARGO_TOML_TEMPLATE.replace("{crate_name}", &crate_name);
+        std::fs::write(crate_dir.join("Cargo.toml"), cargo_toml)?;
+
+        // Generate lib.rs
+        let token_stream = self.generate_code(artifacts_dir)?;
+        let mut buffer = String::from(LIB_HEADER);
+        write!(buffer, "{}", token_stream)?;
+        let file: syn::File = syn::parse_file(&buffer)
+            .with_context(|| format!("parsing generated code for {}", self.name))?;
+        let formatted = prettyplease::unparse(&file);
+        std::fs::write(src_dir.join("lib.rs"), formatted)?;
+
+        eprintln!("  generated crate: {crate_name} (contracts-generated/{dir_name})");
+        Ok(())
+    }
+}
+
+fn generate_binding(instance: &mut SolMacroGen, all_derives: bool) -> Result<()> {
+    let input = instance
+        .get_sol_input()
+        .map_err(|err| anyhow::anyhow!("{:?}", err))?
+        .normalize_json()
+        .map_err(|err| anyhow::anyhow!("{:?}", err))?;
+    let SolInput {
+        attrs: _,
+        path: _,
+        kind,
+    } = input;
+
+    let tokens = match kind {
+        SolInputKind::Sol(mut file) => {
+            let sol_attr: syn::Attribute = if all_derives {
+                syn::parse_quote! {
+                    #[sol(rpc, alloy_sol_types = alloy_sol_types, alloy_contract =
+                alloy_contract, all_derives = true)]
+                }
+            } else {
+                syn::parse_quote! {
+                    #[sol(rpc, alloy_sol_types = alloy_sol_types, alloy_contract =
+                alloy_contract)]
+                }
+            };
+            file.attrs.push(sol_attr);
+            expand(file)?
+        }
+        _ => unreachable!(),
+    };
+
+    instance.expansion = Some(tokens);
+    Ok(())
+}
+
+struct NetworkArm(u64, (String, Option<u64>));
+
+impl ToTokens for NetworkArm {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let chain_id = self.0;
+        let address = &self.1.0;
+        let block_number = match self.1.1 {
+            Some(block) => quote::quote! {Some(#block)},
+            None => quote::quote! {None},
+        };
+        tokens.extend(quote::quote! {
+           #chain_id => Some((::alloy_primitives::address!(#address), #block_number))
+        });
+    }
+}
+
+/// SolMacroGen implementation vendored from
+/// <https://github.com/foundry-rs/foundry/blob/cc24b6b74978e72b7330ad7d4b39140e9ee33deb/crates/sol-macro-gen/src/sol_macro_gen.rs>
+struct SolMacroGen {
+    path: PathBuf,
+    name: String,
+    expansion: Option<TokenStream>,
+}
+
+impl SolMacroGen {
+    fn new(path: PathBuf, name: String) -> Self {
+        Self {
+            path,
+            name,
+            expansion: None,
+        }
+    }
+
+    fn get_sol_input(&self) -> Result<SolInput> {
+        let path = self.path.to_string_lossy().into_owned();
+        let name = proc_macro2::Ident::new(&self.name, Span::call_site());
+        let tokens = quote::quote! {
+            #[sol(ignore_unlinked)]
+            #name,
+            #path
+        };
+
+        let sol_input: SolInput = syn::parse2(tokens).context("failed to parse input")?;
+
+        Ok(sol_input)
+    }
+}
diff --git a/contracts/src/main.rs b/contracts/src/main.rs
new file mode 100644
index 0000000000..34ec14364c
--- /dev/null
+++ b/contracts/src/main.rs
@@ -0,0 +1,564 @@
+mod codegen;
+mod networks;
+mod vendor;
+
+use {
+    codegen::{Contract, Module, Submodule},
+    networks::*,
+    std::path::Path,
+};
+
+/// Declare a network tuple with an optional block number.
+///
+/// Example, without blocks:
+/// ```no_run
+/// networks! {
+///     MAINNET => "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+///     SEPOLIA => "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+/// };
+/// ```
+///
+/// Example, with blocks:
+/// ```no_run
+/// networks! {
+///     MAINNET => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 12593265),
+///     SEPOLIA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 4717488),
+/// };
+/// ```
+macro_rules! networks {
+    [$(
+        $id:expr => $value:tt
+    ),* $(,)?] => {
+        [$(
+            networks!(@entry $id => $value)
+        ),*]
+    };
+
+    (@entry $id:expr => ($addr:expr, $block:expr)) => {
+        ($id, ($addr, Some($block)))
+    };
+
+    (@entry $id:expr => $value:expr) => {
+        ($id, ($value, None))
+    };
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let command = args.first().map(String::as_str).unwrap_or("generate");
+
+    let result = match command {
+        "vendor" => run_vendor(),
+        "generate" => run_generate(),
+        "all" => run_vendor().and_then(|()| run_generate()),
+        other => {
+            eprintln!("Unknown command: {other}");
+            eprintln!("Usage: contracts-generate [vendor|generate|all]");
+            std::process::exit(1);
+        }
+    };
+
+    if let Err(err) = result {
+        eprintln!("Error: {err:?}");
+        std::process::exit(1);
+    }
+}
+
+fn workspace_root() -> &'static Path {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+}
+
+fn run_vendor() -> anyhow::Result<()> {
+    let artifacts_dir = workspace_root().join("artifacts");
+    vendor::run(&artifacts_dir)
+}
+
+fn run_generate() -> anyhow::Result<()> {
+    let workspace_root = workspace_root();
+
+    let artifacts_dir = workspace_root.join("artifacts");
+    let output_dir = workspace_root.join("generated");
+
+    eprintln!("Generating workspace under {}...", output_dir.display());
+    eprintln!("  artifacts: {}", artifacts_dir.display());
+
+    build_module().generate(&artifacts_dir, &output_dir)?;
+
+    eprintln!("\nDone!");
+    Ok(())
+}
+
+#[rustfmt::skip]
+fn build_module() -> Module {
+    Module::default()
+        // 0x
+        .add_contract(Contract::new("IZeroex").with_networks(networks![
+            MAINNET => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+            SEPOLIA => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+            ARBITRUM_ONE => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+            BASE => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+            AVALANCHE => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+            BNB => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+            OPTIMISM => "0xdef1abe32c034e558cdd535791643c58a13acc10",
+            POLYGON => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+        ]))
+        // Misc
+        .add_contract(Contract::new("ERC20"))
+        .add_contract(Contract::new("ERC20Mintable"))
+        // GnosisSafe
+        .add_contract(Contract::new("GnosisSafe"))
+        .add_contract(Contract::new("GnosisSafeCompatibilityFallbackHandler"))
+        .add_contract(Contract::new("GnosisSafeProxy"))
+        .add_contract(Contract::new("GnosisSafeProxyFactory"))
+        // Balancer V2
+        .add_contract(Contract::new("BalancerV2Authorizer"))
+        .add_contract(Contract::new("BalancerV2BasePool"))
+        .add_contract(Contract::new("BalancerV2BasePoolFactory"))
+        .add_contract(Contract::new("BalancerV2WeightedPool"))
+        .add_contract(Contract::new("BalancerV2StablePool"))
+        .add_contract(Contract::new("BalancerV2ComposableStablePool"))
+        .add_contract(Contract::new("BalancerV2LiquidityBootstrappingPool"))
+        .add_contract(
+            Contract::new("BalancerV2WeightedPoolFactory").with_networks(networks![
+                MAINNET => ("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9", 12272147),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2WeightedPoolFactoryV3").with_networks(networks![
+                MAINNET => ("0x5Dd94Da3644DDD055fcf6B3E1aa310Bb7801EB8b", 16520627),
+                GNOSIS => ("0xC128a9954e6c874eA3d62ce62B468bA073093F25", 26226256),
+                AVALANCHE => ("0x94f68b54191F62f781Fe8298A8A5Fa3ed772d227", 26389236),
+                OPTIMISM => ("0xA0DAbEBAAd1b243BBb243f933013d560819eB66f", 72832703),
+                POLYGON => ("0x82e4cFaef85b1B6299935340c964C942280327f4", 39036828),
+                BNB => ("0x6e4cF292C5349c79cCd66349c3Ed56357dD11B46", 25474982),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2WeightedPoolFactoryV4").with_networks(networks![
+                MAINNET => ("0x897888115Ada5773E02aA29F775430BFB5F34c51", 16878323),
+                GNOSIS => ("0x6CaD2ea22BFA7F4C14Aae92E47F510Cd5C509bc7", 27055829),
+                SEPOLIA => ("0x7920BFa1b2041911b354747CA7A6cDD2dfC50Cfd", 3424893),
+                ARBITRUM_ONE => ("0xc7E5ED1054A24Ef31D827E6F86caA58B3Bc168d7", 72222060),
+                BASE => ("0x4C32a8a8fDa4E24139B51b456B42290f51d6A1c4", 1204869),
+                AVALANCHE => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 27739006),
+                OPTIMISM => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 82737545),
+                POLYGON => ("0xFc8a407Bba312ac761D8BFe04CE1201904842B76", 40611103),
+                BNB => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 26665331),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2WeightedPool2TokensFactory").with_networks(networks![
+                MAINNET => ("0xa5bf2ddf098bb0ef6d120c98217dd6b141c74ee0", 12349891),
+                ARBITRUM_ONE => ("0xCF0a32Bbef8F064969F21f7e02328FB577382018", 222864),
+                OPTIMISM => ("0xdAE7e32ADc5d490a43cCba1f0c736033F2b4eFca", 7005512),
+                POLYGON => ("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9", 15832998),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2StablePoolFactoryV2").with_networks(networks![
+                MAINNET => ("0x8df6efec5547e31b0eb7d1291b511ff8a2bf987c", 14934936),
+                GNOSIS => ("0xf23b4DB826DbA14c0e857029dfF076b1c0264843", 25415344),
+                ARBITRUM_ONE => ("0xEF44D6786b2b4d544b7850Fe67CE6381626Bf2D6", 14244664),
+                OPTIMISM => ("0xeb151668006CD04DAdD098AFd0a82e78F77076c3", 11088891),
+                POLYGON => ("0xcA96C4f198d343E251b1a01F3EBA061ef3DA73C1", 29371951),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2LiquidityBootstrappingPoolFactory").with_networks(networks![
+                MAINNET => ("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE", 12871780),
+                ARBITRUM_ONE => ("0x142B9666a0a3A30477b052962ddA81547E7029ab", 222870),
+                POLYGON => ("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE", 17116402),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory")
+                .with_networks(networks![
+                    MAINNET => ("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", 13730248),
+                    GNOSIS => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 25415236),
+                    SEPOLIA => ("0x45fFd460cC6642B8D8Fb12373DFd77Ceb0f4932B", 3419649),
+                    ARBITRUM_ONE => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 4859669),
+                    BASE => ("0x0c6052254551EAe3ECac77B01DFcf1025418828f", 1206531),
+                    AVALANCHE => ("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", 26386552),
+                    BNB => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 22691243),
+                    OPTIMISM => ("0xf302f9F50958c5593770FDf4d4812309fF77414f", 7005915),
+                    POLYGON => ("0x41B953164995c11C81DA73D212ED8Af25741b7Ac", 22067480),
+                ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2ComposableStablePoolFactory").with_networks(networks![
+                MAINNET => ("0xf9ac7B9dF2b3454E841110CcE5550bD5AC6f875F", 15485885),
+                ARBITRUM_ONE => ("0xaEb406b0E430BF5Ea2Dc0B9Fe62E4E53f74B3a33", 23227044),
+                BNB => ("0xf302f9F50958c5593770FDf4d4812309fF77414f", 22691193),
+                OPTIMISM => ("0xf145caFB67081895EE80eB7c04A30Cf87f07b745", 22182522),
+                POLYGON => ("0x136FD06Fa01eCF624C7F2B3CB15742c1339dC2c4", 32774224),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2ComposableStablePoolFactoryV3").with_networks(networks![
+                MAINNET => ("0xdba127fBc23fb20F5929C546af220A991b5C6e01", 16580899),
+                GNOSIS => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 26365805),
+                ARBITRUM_ONE => ("0x1c99324EDC771c82A0DCCB780CC7DDA0045E50e7", 58948370),
+                BNB => ("0xacAaC3e6D6Df918Bf3c809DFC7d42de0e4a72d4C", 25475700),
+                OPTIMISM => ("0xe2E901AB09f37884BA31622dF3Ca7FC19AA443Be", 72832821),
+                POLYGON => ("0x7bc6C0E73EDAa66eF3F6E2f27b0EE8661834c6C9", 39037615),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2ComposableStablePoolFactoryV4").with_networks(networks![
+                MAINNET => ("0xfADa0f4547AB2de89D1304A668C39B3E09Aa7c76", 16878679),
+                GNOSIS => ("0xD87F44Df0159DC78029AB9CA7D7e57E7249F5ACD", 27056416),
+                SEPOLIA => ("0xA3fd20E29358c056B727657E83DFd139abBC9924", 3425277),
+                ARBITRUM_ONE => ("0x2498A2B0d6462d2260EAC50aE1C3e03F4829BA95", 72235860),
+                AVALANCHE => ("0x3B1eb8EB7b43882b385aB30533D9A2BeF9052a98", 29221425),
+                BNB => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 26666380),
+                OPTIMISM => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 82748180),
+                POLYGON => ("0x6Ab5549bBd766A43aFb687776ad8466F8b42f777", 40613553),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2ComposableStablePoolFactoryV5").with_networks(networks![
+                MAINNET => ("0xDB8d758BCb971e482B2C45f7F8a7740283A1bd3A", 17672478),
+                GNOSIS => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 28900564),
+                SEPOLIA => ("0xa523f47A933D5020b23629dDf689695AA94612Dc", 3872211),
+                ARBITRUM_ONE => ("0xA8920455934Da4D853faac1f94Fe7bEf72943eF1", 110212282),
+                BASE => ("0x8df317a729fcaA260306d7de28888932cb579b88", 1204710),
+                AVALANCHE => ("0xE42FFA682A26EF8F25891db4882932711D42e467", 32478827),
+                BNB => ("0x4fb47126Fa83A8734991E41B942Ac29A3266C968", 29877945),
+                OPTIMISM => ("0x043A2daD730d585C44FB79D2614F295D2d625412", 106752707),
+                POLYGON => ("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b", 44961548),
+            ]),
+        )
+        .add_contract(
+            Contract::new("BalancerV2ComposableStablePoolFactoryV6").with_networks(networks![
+                MAINNET => ("0x5B42eC6D40f7B7965BE5308c70e2603c0281C1E9", 19314764),
+                GNOSIS => ("0x47B489bf5836f83ABD928C316F8e39bC0587B020", 32650879),
+                SEPOLIA => ("0x05503B3aDE04aCA81c8D6F88eCB73Ba156982D2B", 5369821),
+                ARBITRUM_ONE => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 184805448),
+                BASE => ("0x956CCab09898C0AF2aCa5e6C228c3aD4E93d9288", 11099703),
+                AVALANCHE => ("0xb9F8AB3ED3F3aCBa64Bc6cd2DcA74B7F38fD7B88", 42186350),
+                BNB => ("0x6B5dA774890Db7B7b96C6f44e6a4b0F657399E2e", 36485719),
+                OPTIMISM => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 116694338),
+                POLYGON => ("0xEAedc32a51c510d35ebC11088fD5fF2b47aACF2E", 53996258),
+            ]),
+        )
+        .add_contract(Contract::new("BalancerV2Vault").with_networks(networks![
+            MAINNET => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 12272146),
+            GNOSIS => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 24821598),
+            SEPOLIA => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 3418831),
+            ARBITRUM_ONE => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 222832),
+            BASE => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 1196036),
+            AVALANCHE => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 26386141),
+            BNB => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 22691002),
+            OPTIMISM => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 7003431),
+            POLYGON => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 15832990),
+            INK => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 34313901),
+        ]))
+        .add_contract(
+            Contract::new("BalancerV3BatchRouter").with_networks(networks![
+                MAINNET => ("0x136f1EFcC3f8f88516B9E94110D56FDBfB1778d1", 21339510),
+                GNOSIS => ("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b", 37377506),
+                SEPOLIA => ("0xC85b652685567C1B074e8c0D4389f83a2E458b1C", 7219301),
+                ARBITRUM_ONE => ("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E", 297828544),
+                BASE => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 25347205),
+                AVALANCHE => ("0xc9b36096f5201ea332Db35d6D195774ea0D5988f", 59965747),
+                OPTIMISM => ("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E", 133969588),
+                PLASMA => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 782312),
+            ]),
+        )
+        // UniV2
+        .add_contract(Contract::new("BaoswapRouter").with_networks(networks![
+            GNOSIS => "0x6093AeBAC87d62b1A5a4cEec91204e35020E38bE",
+        ]))
+        .add_contract(Contract::new("HoneyswapRouter").with_networks(networks![
+            GNOSIS => "0x1C232F01118CB8B424793ae03F870aa7D0ac7f77",
+        ]))
+        .add_contract(Contract::new("PancakeRouter").with_networks(networks![
+            MAINNET => "0xEfF92A263d31888d860bD50809A8D171709b7b1c",
+            ARBITRUM_ONE => "0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb",
+            BASE => "0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb",
+            BNB => "0x10ED43C718714eb63d5aA57B78B54704E256024E",
+        ]))
+        .add_contract(Contract::new("SushiSwapRouter").with_networks(networks![
+            MAINNET => "0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f",
+            GNOSIS => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
+            ARBITRUM_ONE => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
+            BASE => "0x6bded42c6da8fbf0d2ba55b2fa120c5e0c8d7891",
+            AVALANCHE => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
+            BNB => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
+            OPTIMISM => "0x2abf469074dc0b54d793850807e6eb5faf2625b1",
+            POLYGON => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
+        ]))
+        .add_contract(Contract::new("SwaprRouter").with_networks(networks![
+            MAINNET => "0xb9960d9bca016e9748be75dd52f02188b9d0829f",
+            GNOSIS => "0xE43e60736b1cb4a75ad25240E2f9a62Bff65c0C0",
+            ARBITRUM_ONE => "0x530476d5583724A89c8841eB6Da76E7Af4C0F17E",
+        ]))
+        .add_contract(Contract::new("ISwaprPair"))
+        .add_contract(
+            Contract::new("TestnetUniswapV2Router02").with_networks(networks![
+                SEPOLIA => "0x86dcd3293C53Cf8EFd7303B57beb2a3F671dDE98",
+            ]),
+        )
+        .add_contract(Contract::new("UniswapV2Factory").with_networks(networks![
+            MAINNET => "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
+            GNOSIS => "0xA818b4F111Ccac7AA31D0BCc0806d64F2E0737D7",
+            ARBITRUM_ONE => "0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9",
+            BASE => "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6",
+            SEPOLIA => "0xF62c03E08ada871A0bEb309762E260a7a6a880E6",
+            AVALANCHE => "0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C",
+            BNB => "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6",
+            OPTIMISM => "0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf",
+            POLYGON => "0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C",
+        ]))
+        .add_contract(Contract::new("UniswapV2Router02").with_networks(networks![
+            MAINNET => "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
+            GNOSIS => "0x1C232F01118CB8B424793ae03F870aa7D0ac7f77",
+            ARBITRUM_ONE => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+            BASE => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+            SEPOLIA => "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
+            AVALANCHE => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+            BNB => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+            OPTIMISM => "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
+            POLYGON => "0xedf6066a2b290C185783862C7F4776A2C8077AD1",
+        ]))
+        .add_contract(Contract::new("IUniswapLikeRouter"))
+        .add_contract(Contract::new("IUniswapLikePair"))
+        .add_contract(Contract::new("UniswapV3Pool"))
+        .add_contract(Contract::new("UniswapV3QuoterV2").with_networks(networks![
+            MAINNET => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+            ARBITRUM_ONE => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+            BASE => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
+            AVALANCHE => "0xbe0F5544EC67e9B3b2D979aaA43f18Fd87E6257F",
+            BNB => "0x78D78E420Da98ad378D7799bE8f4AF69033EB077",
+            OPTIMISM => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+            POLYGON => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+            LENS => "0x1eEA2B790Dc527c5a4cd3d4f3ae8A2DDB65B2af1",
+            LINEA => "0x42bE4D6527829FeFA1493e1fb9F3676d2425C3C1",
+            PLASMA => "0xaa52bB8110fE38D0d2d2AF0B85C3A3eE622CA455",
+            INK => "0x96b572D2d880cf2Fa2563651BD23ADE6f5516652",
+        ]))
+        .add_contract(
+            Contract::new("UniswapV3SwapRouterV2").with_networks(networks![
+                ARBITRUM_ONE => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+                MAINNET => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+                POLYGON => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+                OPTIMISM => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+                BASE => "0x2626664c2603336E57B271c5C0b26F421741e481",
+                AVALANCHE => "0xbb00FF08d01D300023C629E8fFfFcb65A5a578cE",
+                BNB => "0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2",
+                LENS => "0x6ddD32cd941041D8b61df213B9f515A7D288Dc13",
+                LINEA => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
+                PLASMA => "0x807F4E281B7A3B324825C64ca53c69F0b418dE40",
+                INK => "0x177778F19E89dD1012BdBe603F144088A95C4B53",
+            ]),
+        )
+        .add_contract(Contract::new("IUniswapV3Factory").with_networks(networks![
+            MAINNET => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            SEPOLIA => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            ARBITRUM_ONE => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            BASE => "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+            AVALANCHE => "0x740b1c1de25031C31FF4fC9A62f554A55cdC1baD",
+            BNB => "0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7",
+            OPTIMISM => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            POLYGON => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            LENS => "0xc3A5b857Ba82a2586A45a8B59ECc3AA50Bc3D0e3",
+            LINEA => "0x31FAfd4889FA1269F7a13A66eE0fB458f27D72A9",
+            PLASMA => "0xcb2436774C3e191c85056d248EF4260ce5f27A9D",
+            INK => "0x640887A9ba3A9C53Ed27D0F7e8246A4F933f3424",
+        ]))
+        .add_contract(Contract::new("HooksTrampoline").with_networks(networks![
+            MAINNET => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            GNOSIS => "0x01DcB88678aedD0C4cC9552B20F4718550250574",
+            SEPOLIA => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            ARBITRUM_ONE => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            BASE => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            AVALANCHE => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            BNB => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            OPTIMISM => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            POLYGON => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            LENS => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            LINEA => "0x60bf78233f48ec42ee3f101b9a05ec7878728006",
+            PLASMA => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+            INK => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
+        ]))
+        .add_contract(Contract::new("CoWSwapEthFlow").with_networks(networks![
+            MAINNET => ("0x40a50cf069e992aa4536211b23f286ef88752187", 16169866),
+            GNOSIS => ("0x40a50cf069e992aa4536211b23f286ef88752187", 25414331),
+            SEPOLIA => ("0x0b7795E18767259CC253a2dF471db34c72B49516", 4718739),
+            ARBITRUM_ONE => ("0x6DFE75B5ddce1ADE279D4fa6BD6AeF3cBb6f49dB", 204747458),
+            BASE => ("0x3C3eA1829891BC9bEC3d06A81d5d169e52a415e3", 21490258),
+            AVALANCHE => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 60496408),
+            BNB => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 48411237),
+            OPTIMISM => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 134607215),
+            POLYGON => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 71296258),
+            LENS => ("0xFb337f8a725A142f65fb9ff4902d41cc901de222", 3007173),
+            LINEA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 24522097),
+            PLASMA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 3521855),
+        ]))
+        .add_contract(Contract::new("CoWSwapOnchainOrders"))
+        .add_contract(Contract::new("ERC1271SignatureValidator"))
+        .add_contract(Contract::new("BalancerQueries").with_networks(networks![
+            MAINNET => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 15188261),
+            ARBITRUM_ONE => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 18238624),
+            OPTIMISM => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 15288107),
+            BASE => ("0x300Ab2038EAc391f26D9F895dc61F8F66a548833", 1205869),
+            GNOSIS => ("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", 24821845),
+            POLYGON => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 30988035),
+            AVALANCHE => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 26387068),
+        ]))
+        .add_contract(
+            Contract::new("LiquoriceSettlement").with_networks(networks![
+                MAINNET => "0x0448633eb8B0A42EfED924C42069E0DcF08fb552",
+                ARBITRUM_ONE => "0x0448633eb8B0A42EfED924C42069E0DcF08fb552",
+            ]),
+        )
+        .add_contract(Contract::new("FlashLoanRouter").with_networks(networks![
+            MAINNET => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+            GNOSIS => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+            SEPOLIA => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+            ARBITRUM_ONE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+            BASE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+            POLYGON => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+            AVALANCHE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
+        ]))
+        .add_contract(Contract::new("CowSettlementForwarder"))
+        .add_contract(Contract::new("ICowWrapper"))
+        .add_contract(Contract::new("ChainalysisOracle").with_networks(networks![
+            MAINNET => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
+            ARBITRUM_ONE => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
+            BASE => "0x3A91A31cB3dC49b4db9Ce721F50a9D076c8D739B",
+            AVALANCHE => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
+            BNB => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
+            OPTIMISM => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
+            POLYGON => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
+        ]))
+        .add_contract(Contract::new("Permit2").with_networks(networks![
+            MAINNET => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 15986406),
+            GNOSIS => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 27338672),
+            SEPOLIA => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 2356287),
+            ARBITRUM_ONE => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 38692735),
+            BASE => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 1425180),
+            AVALANCHE => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 28844415),
+            BNB => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 25343783),
+            OPTIMISM => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 38854427),
+            POLYGON => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 35701901),
+            PLASMA => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 7808),
+            INK => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 0),
+        ]))
+        .add_contract(
+            Contract::new("GPv2AllowListAuthentication").with_networks(networks![
+                MAINNET => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 12593263),
+                GNOSIS => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 16465099),
+                SEPOLIA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 4717469),
+                ARBITRUM_ONE => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 204702129),
+                BASE => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 21407137),
+                AVALANCHE => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 59891351),
+                BNB => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 48173639),
+                OPTIMISM => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 134254466),
+                POLYGON => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 45854728),
+                LENS => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 2612937),
+                LINEA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 24333100),
+                PLASMA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 3439709),
+                INK => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 34436840),
+            ]),
+        )
+        .add_contract(Contract::new("GPv2Settlement").with_networks(networks![
+            MAINNET => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 12593265),
+            GNOSIS => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 16465100),
+            SEPOLIA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 4717488),
+            ARBITRUM_ONE => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 204704802),
+            BASE => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 21407238),
+            AVALANCHE => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 59891356),
+            BNB => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 48173641),
+            OPTIMISM => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 134254624),
+            POLYGON => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 45859743),
+            LENS => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 2621745),
+            LINEA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 24333100),
+            PLASMA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 3439711),
+            INK => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 34436849),
+        ]))
+        .add_contract(Contract::new("WETH9").with_networks(networks![
+            MAINNET => "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+            GNOSIS => "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
+            SEPOLIA => "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+            ARBITRUM_ONE => "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+            BASE => "0x4200000000000000000000000000000000000006",
+            AVALANCHE => "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
+            BNB => "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+            OPTIMISM => "0x4200000000000000000000000000000000000006",
+            POLYGON => "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+            LENS => "0x6bDc36E20D267Ff0dd6097799f82e78907105e2F",
+            LINEA => "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
+            PLASMA => "0x6100E367285b01F48D07953803A2d8dCA5D19873",
+            INK => "0x4200000000000000000000000000000000000006",
+        ]))
+        .add_submodule(
+            Submodule::new("cow_amm")
+                .add_contract(Contract::new("CowAmm"))
+                .add_contract(Contract::new("CowAmmConstantProductFactory").with_networks(
+                    networks![
+                        MAINNET => ("0x40664207e3375FB4b733d4743CE9b159331fd034", 19861952),
+                        GNOSIS => ("0xdb1cba3a87f2db53b6e1e6af48e28ed877592ec0", 33874317),
+                        SEPOLIA => ("0xb808e8183e3a72d196457d127c7fd4befa0d7fd3", 5874562),
+                    ],
+                ))
+                .add_contract(Contract::new("CowAmmLegacyHelper").with_networks(networks![
+                    MAINNET => ("0x3705ceee5eaa561e3157cf92641ce28c45a3999c", 20332745),
+                    GNOSIS => ("0xd9ec06b001957498ab1bc716145515d1d0e30ffb", 35026999),
+                ]))
+                .add_contract(Contract::new("CowAmmUniswapV2PriceOracle"))
+                .add_contract(Contract::new("CowAmmFactoryGetter")),
+        )
+        .add_submodule(
+            Submodule::new("test")
+                .add_contract(Contract::new("GasHog"))
+                .add_contract(Contract::new("Counter"))
+                .add_contract(Contract::new("CowProtocolToken").with_networks(networks![
+                    MAINNET => "0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB",
+                    GNOSIS => "0x177127622c4A00F3d409B75571e12cB3c8973d3c",
+                    SEPOLIA => "0x0625aFB445C3B6B7B929342a04A22599fd5dBB59",
+                    ARBITRUM_ONE => "0xcb8b5CD20BdCaea9a010aC1F8d835824F5C87A04",
+                    BASE => "0xc694a91e6b071bF030A18BD3053A7fE09B6DaE69",
+                ]))
+                .add_contract(Contract::new("NonStandardERC20Balances"))
+                .add_contract(Contract::new("RemoteERC20Balances")),
+        )
+        .add_submodule(
+            Submodule::new("support")
+                .add_contract(Contract::new("AnyoneAuthenticator"))
+                .add_contract(Contract::new("Solver"))
+                .add_contract(Contract::new("Spardose"))
+                .add_contract(Contract::new("Trader"))
+                .add_contract(Contract::new("Swapper"))
+                .add_contract(Contract::new("Signatures").with_networks(networks![
+                    MAINNET => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    ARBITRUM_ONE => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    BASE => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    AVALANCHE => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    BNB => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    OPTIMISM => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    POLYGON => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    LENS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    GNOSIS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    SEPOLIA => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    LINEA => "0xf6E57e72F7dB3D9A51a8B4c149C00475b94A37e4",
+                    PLASMA => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                    INK => "0x8262d639c38470F38d2eff15926F7071c28057Af",
+                ]))
+                .add_contract(Contract::new("Balances").with_networks(networks![
+                    MAINNET => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    ARBITRUM_ONE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    BASE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    AVALANCHE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    BNB => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    OPTIMISM => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    POLYGON => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    LENS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    GNOSIS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    SEPOLIA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    PLASMA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    LINEA => "0x361350f708f7c0c63c8a505226592c3e5d1faa29",
+                    INK => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                ])),
+        )
+}
diff --git a/contracts/src/networks.rs b/contracts/src/networks.rs
new file mode 100644
index 0000000000..4af659aab0
--- /dev/null
+++ b/contracts/src/networks.rs
@@ -0,0 +1,13 @@
+pub const MAINNET: u64 = 1;
+pub const GNOSIS: u64 = 100;
+pub const SEPOLIA: u64 = 11155111;
+pub const ARBITRUM_ONE: u64 = 42161;
+pub const BASE: u64 = 8453;
+pub const POLYGON: u64 = 137;
+pub const AVALANCHE: u64 = 43114;
+pub const BNB: u64 = 56;
+pub const OPTIMISM: u64 = 10;
+pub const LENS: u64 = 232;
+pub const LINEA: u64 = 59144;
+pub const PLASMA: u64 = 9745;
+pub const INK: u64 = 57073;
diff --git a/crates/contracts/src/bin/vendor.rs b/contracts/src/vendor.rs
similarity index 87%
rename from crates/contracts/src/bin/vendor.rs
rename to contracts/src/vendor.rs
index 2d26a17e27..576ae5fe2a 100644
--- a/crates/contracts/src/bin/vendor.rs
+++ b/contracts/src/vendor.rs
@@ -6,25 +6,11 @@ use {
         fs,
         path::{Path, PathBuf},
     },
-    tracing_subscriber::EnvFilter,
 };
 
-fn main() {
-    tracing_subscriber::fmt::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_env("LOG_FILTER").unwrap_or_else(|_| "warn,vendor=info".into()),
-        )
-        .init();
-
-    if let Err(err) = run() {
-        tracing::error!("Error vendoring contracts: {:?}", err);
-        std::process::exit(-1);
-    }
-}
-
 #[rustfmt::skip]
-fn run() -> Result<()> {
-    let vendor = Vendor::try_new()?;
+pub fn run(artifacts_dir: &Path) -> Result<()> {
+    let vendor = Vendor::new(artifacts_dir)?;
 
     const ETHFLOW_VERSION: &str = "0.0.0-rc.3";
 
@@ -219,11 +205,15 @@ struct Vendor {
 }
 
 impl Vendor {
-    fn try_new() -> Result<Self> {
-        let artifacts = contract_artifacts_dir();
-        tracing::info!("vendoring contract artifacts to '{}'", artifacts.display());
-        fs::create_dir_all(&artifacts)?;
-        Ok(Self { artifacts })
+    fn new(artifacts_dir: &Path) -> Result<Self> {
+        eprintln!(
+            "vendoring contract artifacts to '{}'",
+            artifacts_dir.display()
+        );
+        fs::create_dir_all(artifacts_dir)?;
+        Ok(Self {
+            artifacts: artifacts_dir.to_path_buf(),
+        })
     }
 
     /// Creates a context for vendoring "full" contract data, including bytecode
@@ -271,16 +261,14 @@ impl Src {
     }
 
     fn fetch_json(self) -> Result<serde_json::Value> {
-        // Best-effort coercion of an ABI or artifact JSON document into an artifact JSON document.
-        // Approach taken from ethcontract_generate::source::abi_or_artifact, which is called for each JSON fetch
         let value = match reqwest::blocking::get(self.0)?.json::<serde_json::Value>()? {
             serde_json::Value::Array(values) => {
                 json!({"abi": values})
             }
             value @ serde_json::Value::Object(_) => value,
             value => {
-                tracing::warn!(
-                    "unexpected value format, expected an array or object, got {value:?}"
+                eprintln!(
+                    "warning: unexpected value format, expected an array or object, got {value:?}"
                 );
                 value
             }
@@ -312,9 +300,7 @@ impl VendorContext<'_> {
     }
 
     fn manual(&self, name: &str, reason: &str) -> &Self {
-        // We just keep these here to document that they are manually generated
-        // and not pulled from some source.
-        tracing::info!("skipping {}: {}", name, reason);
+        eprintln!("  skipping {name}: {reason}");
         self
     }
 
@@ -327,10 +313,9 @@ impl VendorContext<'_> {
     }
 
     fn vendor_source(&self, name: &str, source: Src) -> Result<&Self> {
-        tracing::info!("retrieving {:?}", source);
+        eprintln!("  fetching {source:?}");
         let artifact_json = source.fetch_json()?;
 
-        tracing::debug!("pruning artifact JSON");
         let pruned_artifact_json = {
             let mut pruned = Map::new();
             for (property, paths) in self.properties {
@@ -346,14 +331,8 @@ impl VendorContext<'_> {
         };
 
         let path = self.artifacts.join(name).with_extension("json");
-        tracing::debug!("saving artifact to {}", path.display());
         fs::write(path, pruned_artifact_json)?;
 
         Ok(self)
     }
 }
-
-/// Path to the directory containing the vendored contract artifacts.
-pub fn contract_artifacts_dir() -> PathBuf {
-    Path::new(env!("CARGO_MANIFEST_DIR")).join("artifacts")
-}
diff --git a/crates/account-balances/src/lib.rs b/crates/account-balances/src/lib.rs
index 37dff5bc77..4979e4c652 100644
--- a/crates/account-balances/src/lib.rs
+++ b/crates/account-balances/src/lib.rs
@@ -3,7 +3,7 @@ use {
     alloy_rpc_types::state::StateOverride,
     alloy_sol_types::{SolCall, SolType, sol_data},
     balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
-    contracts::alloy::{GPv2Settlement, support::Balances},
+    contracts::{GPv2Settlement, support::Balances},
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     model::{
         interaction::InteractionData,
diff --git a/crates/account-balances/src/simulation.rs b/crates/account-balances/src/simulation.rs
index 1587598e78..b98166fccb 100644
--- a/crates/account-balances/src/simulation.rs
+++ b/crates/account-balances/src/simulation.rs
@@ -7,7 +7,7 @@ use {
     crate::BalanceSimulator,
     alloy_primitives::{Address, U256},
     anyhow::Result,
-    contracts::alloy::{BalancerV2Vault::BalancerV2Vault, ERC20},
+    contracts::{BalancerV2Vault::BalancerV2Vault, ERC20},
     ethrpc::{Web3, alloy::ProviderLabelingExt},
     futures::future,
     model::order::SellTokenSource,
@@ -169,7 +169,7 @@ mod tests {
         super::*,
         alloy_primitives::address,
         balance_overrides::DummyOverrider,
-        contracts::alloy::GPv2Settlement,
+        contracts::GPv2Settlement,
         ethrpc::Web3,
         model::order::SellTokenSource,
         std::sync::Arc,
@@ -183,7 +183,7 @@ mod tests {
             address!("0x9008d19f58aabd9ed0d60971565aa8510560ab41"),
             web3.provider.clone(),
         );
-        let balances = contracts::alloy::support::Balances::Instance::new(
+        let balances = contracts::support::Balances::Instance::new(
             address!("3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
             web3.provider.clone(),
         );
diff --git a/crates/autopilot/src/boundary/events/settlement.rs b/crates/autopilot/src/boundary/events/settlement.rs
index 15f2cd5df6..846b1b68de 100644
--- a/crates/autopilot/src/boundary/events/settlement.rs
+++ b/crates/autopilot/src/boundary/events/settlement.rs
@@ -5,7 +5,7 @@ use {
         rpc::types::{Filter, Log},
     },
     anyhow::Result,
-    contracts::alloy::GPv2Settlement::GPv2Settlement::GPv2SettlementEvents,
+    contracts::GPv2Settlement::GPv2Settlement::GPv2SettlementEvents,
     ethrpc::AlloyProvider,
     event_indexing::{
         block_retriever::RangeInclusive,
diff --git a/crates/autopilot/src/database/ethflow_events/event_retriever.rs b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
index 01e5178eb2..1278097c09 100644
--- a/crates/autopilot/src/database/ethflow_events/event_retriever.rs
+++ b/crates/autopilot/src/database/ethflow_events/event_retriever.rs
@@ -7,7 +7,7 @@ use {
         rpc::types::{Filter, FilterSet},
         sol_types::SolEvent,
     },
-    contracts::alloy::CoWSwapEthFlow::CoWSwapEthFlow,
+    contracts::CoWSwapEthFlow::CoWSwapEthFlow,
     ethrpc::Web3,
     event_indexing::event_handler::AlloyEventRetrieving,
 };
diff --git a/crates/autopilot/src/database/ethflow_events/event_storing.rs b/crates/autopilot/src/database/ethflow_events/event_storing.rs
index adb2baa805..82e37ff484 100644
--- a/crates/autopilot/src/database/ethflow_events/event_storing.rs
+++ b/crates/autopilot/src/database/ethflow_events/event_storing.rs
@@ -4,7 +4,7 @@ use {
     crate::database::{Postgres, events::bytes_to_order_uid},
     alloy::rpc::types::Log,
     anyhow::Result,
-    contracts::alloy::CoWSwapEthFlow::CoWSwapEthFlow::CoWSwapEthFlowEvents,
+    contracts::CoWSwapEthFlow::CoWSwapEthFlow::CoWSwapEthFlowEvents,
     database::ethflow_orders::Refund,
     event_indexing::{block_retriever::RangeInclusive, event_handler::EventStoring},
 };
diff --git a/crates/autopilot/src/database/events.rs b/crates/autopilot/src/database/events.rs
index ebb523b559..fc46c257f7 100644
--- a/crates/autopilot/src/database/events.rs
+++ b/crates/autopilot/src/database/events.rs
@@ -1,7 +1,7 @@
 use {
     alloy::rpc::types::Log,
     anyhow::{Context, Result},
-    contracts::alloy::GPv2Settlement::GPv2Settlement::{self, GPv2SettlementEvents},
+    contracts::GPv2Settlement::GPv2Settlement::{self, GPv2SettlementEvents},
     database::{
         OrderUid,
         PgTransaction,
diff --git a/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs b/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs
index ab68bb1d4f..9f6c545503 100644
--- a/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs
+++ b/crates/autopilot/src/database/onchain_order_events/ethflow_events.rs
@@ -3,7 +3,7 @@ use {
     crate::database::events::log_to_event_index,
     alloy::{eips::BlockNumberOrTag, rpc::types::Log},
     anyhow::{Context, Result, anyhow},
-    contracts::alloy::{
+    contracts::{
         CoWSwapOnchainOrders::CoWSwapOnchainOrders::{
             CoWSwapOnchainOrdersEvents as ContractEvent,
             OrderPlacement as ContractOrderPlacement,
@@ -293,7 +293,7 @@ mod test {
     use {
         super::*,
         alloy::primitives::{Address, U256},
-        contracts::alloy::CoWSwapOnchainOrders,
+        contracts::CoWSwapOnchainOrders,
         model::order::{BuyTokenDestination, OrderKind, SellTokenSource},
     };
 
diff --git a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
index b5e93f14fd..4f7619e48b 100644
--- a/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
+++ b/crates/autopilot/src/database/onchain_order_events/event_retriever.rs
@@ -4,7 +4,7 @@ use {
         rpc::types::{Filter, FilterSet},
         sol_types::SolEvent,
     },
-    contracts::alloy::CoWSwapOnchainOrders,
+    contracts::CoWSwapOnchainOrders,
     ethrpc::Web3,
     event_indexing::event_handler::AlloyEventRetrieving,
 };
diff --git a/crates/autopilot/src/database/onchain_order_events/mod.rs b/crates/autopilot/src/database/onchain_order_events/mod.rs
index 24a19fd77f..289ae0fd5e 100644
--- a/crates/autopilot/src/database/onchain_order_events/mod.rs
+++ b/crates/autopilot/src/database/onchain_order_events/mod.rs
@@ -12,7 +12,7 @@ use {
     anyhow::{Context, Result, anyhow, bail},
     app_data::AppDataHash,
     chrono::{TimeZone, Utc},
-    contracts::alloy::{
+    contracts::{
         CoWSwapOnchainOrders::CoWSwapOnchainOrders::{
             CoWSwapOnchainOrdersEvents as ContractEvent,
             OrderInvalidation,
@@ -780,7 +780,7 @@ mod test {
     use {
         super::*,
         alloy::primitives::U256,
-        contracts::alloy::CoWSwapOnchainOrders,
+        contracts::CoWSwapOnchainOrders,
         database::{byte_array::ByteArray, onchain_broadcasted_orders::OnchainOrderPlacement},
         ethrpc::Web3,
         model::{
@@ -948,7 +948,7 @@ mod test {
 
         let order_placement = ContractOrderPlacement {
             sender,
-            order: contracts::alloy::CoWSwapOnchainOrders::GPv2Order::Data {
+            order: contracts::CoWSwapOnchainOrders::GPv2Order::Data {
                 sellToken: sell_token,
                 buyToken: buy_token,
                 receiver,
@@ -962,11 +962,10 @@ mod test {
                 sellTokenBalance: SellTokenSource::ERC20.into(),
                 buyTokenBalance: BuyTokenDestination::ERC20.into(),
             },
-            signature:
-                contracts::alloy::CoWSwapOnchainOrders::ICoWSwapOnchainOrders::OnchainSignature {
-                    scheme: 0,
-                    data: owner.0.into(),
-                },
+            signature: contracts::CoWSwapOnchainOrders::ICoWSwapOnchainOrders::OnchainSignature {
+                scheme: 0,
+                data: owner.0.into(),
+            },
             data: Default::default(),
         };
         let settlement_contract = Address::repeat_byte(8);
@@ -1059,7 +1058,7 @@ mod test {
         };
         let order_placement = ContractOrderPlacement {
             sender,
-            order: contracts::alloy::CoWSwapOnchainOrders::GPv2Order::Data {
+            order: contracts::CoWSwapOnchainOrders::GPv2Order::Data {
                 sellToken: sell_token,
                 buyToken: buy_token,
                 receiver,
@@ -1073,11 +1072,10 @@ mod test {
                 sellTokenBalance: SellTokenSource::ERC20.into(),
                 buyTokenBalance: BuyTokenDestination::ERC20.into(),
             },
-            signature:
-                contracts::alloy::CoWSwapOnchainOrders::ICoWSwapOnchainOrders::OnchainSignature {
-                    scheme: 0,
-                    data: owner.0.into(),
-                },
+            signature: contracts::CoWSwapOnchainOrders::ICoWSwapOnchainOrders::OnchainSignature {
+                scheme: 0,
+                data: owner.0.into(),
+            },
             data: Default::default(),
         };
         let settlement_contract = Address::repeat_byte(8);
@@ -1160,7 +1158,7 @@ mod test {
         let owner = Address::from([6; 20]);
         let order_placement = ContractOrderPlacement {
             sender,
-            order: contracts::alloy::CoWSwapOnchainOrders::GPv2Order::Data {
+            order: contracts::CoWSwapOnchainOrders::GPv2Order::Data {
                 sellToken: sell_token,
                 buyToken: buy_token,
                 receiver,
@@ -1174,11 +1172,10 @@ mod test {
                 sellTokenBalance: SellTokenSource::ERC20.into(),
                 buyTokenBalance: BuyTokenDestination::ERC20.into(),
             },
-            signature:
-                contracts::alloy::CoWSwapOnchainOrders::ICoWSwapOnchainOrders::OnchainSignature {
-                    scheme: 0,
-                    data: owner.0.into(),
-                },
+            signature: contracts::CoWSwapOnchainOrders::ICoWSwapOnchainOrders::OnchainSignature {
+                scheme: 0,
+                data: owner.0.into(),
+            },
             data: vec![0u8, 0u8, 1u8, 2u8, 0u8, 0u8, 1u8, 2u8, 0u8, 0u8, 1u8, 2u8].into(),
         };
 
diff --git a/crates/autopilot/src/domain/settlement/transaction/mod.rs b/crates/autopilot/src/domain/settlement/transaction/mod.rs
index a24a1b02fd..5e8f67a3bf 100644
--- a/crates/autopilot/src/domain/settlement/transaction/mod.rs
+++ b/crates/autopilot/src/domain/settlement/transaction/mod.rs
@@ -4,7 +4,7 @@ use {
         domain::{self, auction::order, blockchain},
     },
     alloy::{eips::BlockId, sol_types::SolCall},
-    contracts::alloy::{GPv2AllowListAuthentication, GPv2Settlement},
+    contracts::{GPv2AllowListAuthentication, GPv2Settlement},
     eth_domain_types as eth,
     std::collections::HashSet,
 };
diff --git a/crates/autopilot/src/domain/settlement/transaction/tokenized.rs b/crates/autopilot/src/domain/settlement/transaction/tokenized.rs
index 8b3656a1f3..d7d66438e7 100644
--- a/crates/autopilot/src/domain/settlement/transaction/tokenized.rs
+++ b/crates/autopilot/src/domain/settlement/transaction/tokenized.rs
@@ -5,7 +5,7 @@ use {
     },
     alloy::primitives::U256,
     app_data::AppDataHash,
-    contracts::alloy::GPv2Settlement,
+    contracts::GPv2Settlement,
     eth_domain_types as eth,
 };
 
diff --git a/crates/autopilot/src/infra/blockchain/contracts.rs b/crates/autopilot/src/infra/blockchain/contracts.rs
index 3b95903938..27a3ebf298 100644
--- a/crates/autopilot/src/infra/blockchain/contracts.rs
+++ b/crates/autopilot/src/infra/blockchain/contracts.rs
@@ -1,7 +1,7 @@
 use {
     alloy::primitives::Address,
     chain::Chain,
-    contracts::alloy::{
+    contracts::{
         ChainalysisOracle,
         GPv2AllowListAuthentication,
         GPv2Settlement,
@@ -16,7 +16,7 @@ use {
 #[derive(Debug, Clone)]
 pub struct Contracts {
     settlement: GPv2Settlement::Instance,
-    signatures: contracts::alloy::support::Signatures::Instance,
+    signatures: contracts::support::Signatures::Instance,
     weth: WETH9::Instance,
     balances: Balances::Instance,
     chainalysis_oracle: Option<ChainalysisOracle::Instance>,
@@ -48,10 +48,10 @@ impl Contracts {
             web3.provider.clone(),
         );
 
-        let signatures = contracts::alloy::support::Signatures::Instance::new(
+        let signatures = contracts::support::Signatures::Instance::new(
             addresses
                 .signatures
-                .or_else(|| contracts::alloy::support::Signatures::deployment_address(&chain.id()))
+                .or_else(|| contracts::support::Signatures::deployment_address(&chain.id()))
                 .unwrap(),
             web3.provider.clone(),
         );
@@ -122,7 +122,7 @@ impl Contracts {
         &self.balances
     }
 
-    pub fn signatures(&self) -> &contracts::alloy::support::Signatures::Instance {
+    pub fn signatures(&self) -> &contracts::support::Signatures::Instance {
         &self.signatures
     }
 
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 13ba483655..9d0a1cdf24 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -30,7 +30,7 @@ use {
     chain::Chain,
     clap::Parser,
     configs::autopilot::{Configuration, solver::Account},
-    contracts::alloy::{BalancerV2Vault, GPv2Settlement, WETH9},
+    contracts::{BalancerV2Vault, GPv2Settlement, WETH9},
     ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
     event_indexing::block_retriever::BlockRetriever,
     http_client::HttpClientFactory,
diff --git a/crates/bad-tokens/src/trace_call.rs b/crates/bad-tokens/src/trace_call.rs
index 67b02d173d..3147a0f502 100644
--- a/crates/bad-tokens/src/trace_call.rs
+++ b/crates/bad-tokens/src/trace_call.rs
@@ -8,7 +8,7 @@ use {
     alloy_sol_types::SolCall,
     alloy_transport::{RpcError, TransportErrorKind},
     anyhow::{Context, Result, bail, ensure},
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     ethrpc::Web3,
     model::interaction::InteractionData,
 };
diff --git a/crates/balance-overrides/src/detector.rs b/crates/balance-overrides/src/detector.rs
index 920f617173..6a11b1109f 100644
--- a/crates/balance-overrides/src/detector.rs
+++ b/crates/balance-overrides/src/detector.rs
@@ -11,7 +11,7 @@ use {
     },
     alloy_sol_types::SolCall,
     alloy_transport::{RpcError, TransportErrorKind},
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     std::{
         collections::HashMap,
         fmt::{self, Debug, Formatter},
diff --git a/crates/contracts/.gitignore b/crates/contracts/.gitignore
deleted file mode 100644
index 1884d50914..0000000000
--- a/crates/contracts/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# Generated by build.rs, will contain the contract bindings
-src/alloy
diff --git a/crates/contracts/Cargo.toml b/crates/contracts/Cargo.toml
deleted file mode 100644
index 31b2560420..0000000000
--- a/crates/contracts/Cargo.toml
+++ /dev/null
@@ -1,42 +0,0 @@
-[package]
-name = "contracts"
-version = "0.1.0"
-authors = ["Gnosis Developers <developers@gnosis.io>", "Cow Protocol Developers <dev@cow.fi>"]
-edition = "2024"
-license = "MIT OR Apache-2.0"
-
-[lib]
-doctest = false
-
-[[bin]]
-name = "vendor"
-required-features = ["bin"]
-
-[dependencies]
-alloy-contract = { workspace = true }
-alloy-primitives = { workspace = true }
-alloy-provider = { workspace = true }
-alloy-sol-types = { workspace = true, features = ["json"] }
-anyhow = { workspace = true }
-paste = { workspace = true }
-reqwest = { workspace = true, features = ["blocking", "json"], optional = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-tracing = { workspace = true, optional = true }
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"], optional = true }
-
-[build-dependencies]
-alloy-sol-macro-expander = { workspace = true }
-alloy-sol-macro-input = { workspace = true, features = ["json"] }
-anyhow = { workspace = true }
-prettyplease = { workspace = true }
-proc-macro2 = { workspace = true }
-quote = { workspace = true }
-syn = { workspace = true }
-
-[features]
-default = []
-bin = ["reqwest", "tracing", "tracing-subscriber"]
-
-[lints]
-workspace = true
diff --git a/crates/contracts/README.md b/crates/contracts/README.md
deleted file mode 100644
index 719ddf139e..0000000000
--- a/crates/contracts/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# contracts
-
-The library part of this crate contains `ethcontract` generated bindings to the smart contracts we use.
-
-## `vendor` script
-
-A `[[bin]]` script for vendoring smart contract json artifacts that ethcontract uses to generate its bindings. We keep these in the repository to make the build more deterministic and robust.
-
-## Steps to add a new contract
-
-- In `vendor.rs` extend `ARTIFACTS` with the package and contract name.
-- Run the vendor binary for example with `(cd crates/contracts; cargo run --bin vendor --features bin)`. This creates a new json file for this contract in the `artifacts` folder.
-- In `build.rs` add a `generate_contract` call for the contract. This creates the ethcontract generated rust code file.
-- In `lib.rs` add an `include!` call for the contract. This imports the rust code into the library.
diff --git a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json b/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
deleted file mode 120000
index eb797bfd90..0000000000
--- a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
+++ /dev/null
@@ -1 +0,0 @@
-BalancerV2ComposableStablePoolFactory.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json b/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
deleted file mode 120000
index eb797bfd90..0000000000
--- a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
+++ /dev/null
@@ -1 +0,0 @@
-BalancerV2ComposableStablePoolFactory.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json b/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
deleted file mode 120000
index eb797bfd90..0000000000
--- a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
+++ /dev/null
@@ -1 +0,0 @@
-BalancerV2ComposableStablePoolFactory.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json b/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
deleted file mode 120000
index eb797bfd90..0000000000
--- a/crates/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
+++ /dev/null
@@ -1 +0,0 @@
-BalancerV2ComposableStablePoolFactory.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json b/crates/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
deleted file mode 120000
index feca9d5f06..0000000000
--- a/crates/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
+++ /dev/null
@@ -1 +0,0 @@
-BalancerV2LiquidityBootstrappingPoolFactory.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json b/crates/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
deleted file mode 120000
index 744617e3de..0000000000
--- a/crates/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
+++ /dev/null
@@ -1 +0,0 @@
-BalancerV2WeightedPoolFactoryV3.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/BaoswapRouter.json b/crates/contracts/artifacts/BaoswapRouter.json
deleted file mode 120000
index e485e1a596..0000000000
--- a/crates/contracts/artifacts/BaoswapRouter.json
+++ /dev/null
@@ -1 +0,0 @@
-IUniswapLikeRouter.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/HoneyswapRouter.json b/crates/contracts/artifacts/HoneyswapRouter.json
deleted file mode 120000
index e485e1a596..0000000000
--- a/crates/contracts/artifacts/HoneyswapRouter.json
+++ /dev/null
@@ -1 +0,0 @@
-IUniswapLikeRouter.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/PancakeRouter.json b/crates/contracts/artifacts/PancakeRouter.json
deleted file mode 120000
index e485e1a596..0000000000
--- a/crates/contracts/artifacts/PancakeRouter.json
+++ /dev/null
@@ -1 +0,0 @@
-IUniswapLikeRouter.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/SushiSwapRouter.json b/crates/contracts/artifacts/SushiSwapRouter.json
deleted file mode 120000
index e485e1a596..0000000000
--- a/crates/contracts/artifacts/SushiSwapRouter.json
+++ /dev/null
@@ -1 +0,0 @@
-IUniswapLikeRouter.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/SwaprRouter.json b/crates/contracts/artifacts/SwaprRouter.json
deleted file mode 120000
index e485e1a596..0000000000
--- a/crates/contracts/artifacts/SwaprRouter.json
+++ /dev/null
@@ -1 +0,0 @@
-IUniswapLikeRouter.json
\ No newline at end of file
diff --git a/crates/contracts/artifacts/TestnetUniswapV2Router02.json b/crates/contracts/artifacts/TestnetUniswapV2Router02.json
deleted file mode 120000
index e485e1a596..0000000000
--- a/crates/contracts/artifacts/TestnetUniswapV2Router02.json
+++ /dev/null
@@ -1 +0,0 @@
-IUniswapLikeRouter.json
\ No newline at end of file
diff --git a/crates/contracts/build.rs b/crates/contracts/build.rs
deleted file mode 100644
index f4945ac87a..0000000000
--- a/crates/contracts/build.rs
+++ /dev/null
@@ -1,1208 +0,0 @@
-use {
-    alloy_sol_macro_expander::expand::expand,
-    alloy_sol_macro_input::{SolInput, SolInputKind},
-    anyhow::{Context, Result},
-    networks::*,
-    proc_macro2::{Span, TokenStream},
-    quote::{ToTokens, format_ident},
-    std::{
-        collections::HashMap,
-        fmt::Write,
-        path::{Path, PathBuf},
-    },
-};
-
-mod networks {
-    pub const MAINNET: u64 = 1;
-    pub const GNOSIS: u64 = 100;
-    pub const SEPOLIA: u64 = 11155111;
-    pub const ARBITRUM_ONE: u64 = 42161;
-    pub const BASE: u64 = 8453;
-    pub const POLYGON: u64 = 137;
-    pub const AVALANCHE: u64 = 43114;
-    pub const BNB: u64 = 56;
-    pub const OPTIMISM: u64 = 10;
-    pub const LINEA: u64 = 59144;
-    pub const PLASMA: u64 = 9745;
-    pub const INK: u64 = 57073;
-}
-
-/// Declare a network tuple with an optional block number.
-///
-/// Example, without blocks:
-/// ```no_run
-/// # #[macro_use] extern crate contracts_generate;
-/// # use contracts_generate::networks::{MAINNET, SEPOLIA};
-/// # fn main() {
-/// # let _: [(_, (_, Option<u64>)); _] =
-/// networks! {
-///     MAINNET => "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-///     SEPOLIA => "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
-/// };
-/// # }
-/// ```
-///
-/// Example, with blocks:
-/// ```no_run
-/// # #[macro_use] extern crate contracts_generate;
-/// # use contracts_generate::networks::{MAINNET, SEPOLIA};
-/// # fn main() {
-/// # let _: [(_, (_, Option<u64>)); _] =
-/// networks! {
-///     MAINNET => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 12593265),
-///     SEPOLIA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 4717488),
-/// };
-/// # }
-/// ```
-#[macro_export]
-macro_rules! networks {
-    // Entry point: accepts a list of entries and delegates to internal rules
-    [$(
-        $id:expr => $value:tt
-    ),* $(,)?] => {
-        [$(
-            networks!(@entry $id => $value)
-        ),*]
-    };
-
-    // Internal rule: handle entry with address and block (parenthesized)
-    (@entry $id:expr => ($addr:expr, $block:expr)) => {
-        ($id, ($addr, Some($block)))
-    };
-
-    // Internal rule: handle entry with just address
-    (@entry $id:expr => $value:expr) => {
-        ($id, ($value, None))
-    };
-}
-
-fn main() {
-    // NOTE: This is a workaround for `rerun-if-changed` directives for
-    // non-existent files cause the crate's build unit to get flagged for a
-    // rebuild if any files in the workspace change.
-    //
-    // See:
-    // - https://github.com/rust-lang/cargo/issues/6003
-    // - https://doc.rust-lang.org/cargo/reference/build-scripts.html#cargorerun-if-changedpath
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-changed=artifacts/");
-
-    // Path to the directory containing the vendored contract artifacts.
-    let vendored_bindings = Path::new(env!("CARGO_MANIFEST_DIR"))
-        .join("src")
-        .join("alloy");
-
-    Module::default()
-        // 0x
-        .add_contract(Contract::new("IZeroex").with_networks(networks![
-            MAINNET => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            SEPOLIA => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            ARBITRUM_ONE => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            BASE => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            AVALANCHE => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            BNB => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            OPTIMISM => "0xdef1abe32c034e558cdd535791643c58a13acc10",
-            POLYGON => "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
-            // Not available on Linea, Plasma and Ink
-        ]))
-        // Misc
-        .add_contract(Contract::new("ERC20"))
-        .add_contract(Contract::new("ERC20Mintable"))
-        // GnosisSafe
-        .add_contract(Contract::new("GnosisSafe"))
-        .add_contract(Contract::new("GnosisSafeCompatibilityFallbackHandler"))
-        .add_contract(Contract::new("GnosisSafeProxy"))
-        .add_contract(Contract::new("GnosisSafeProxyFactory"))
-        // Balancer V2
-        .add_contract(Contract::new("BalancerV2Authorizer"))
-        .add_contract(Contract::new("BalancerV2BasePool"))
-        .add_contract(Contract::new("BalancerV2BasePoolFactory"))
-        .add_contract(Contract::new("BalancerV2WeightedPool"))
-        .add_contract(Contract::new("BalancerV2StablePool"))
-        .add_contract(Contract::new("BalancerV2ComposableStablePool"))
-        .add_contract(Contract::new("BalancerV2LiquidityBootstrappingPool"))
-        // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
-        .add_contract(
-            Contract::new("BalancerV2WeightedPoolFactory").with_networks(networks![
-                // <https://etherscan.io/tx/0x0f9bb3624c185b4e107eaf9176170d2dc9cb1c48d0f070ed18416864b3202792>
-                MAINNET => ("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9", 12272147),
-                // Not available on Sepolia (only version ≥ 4)
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // Not available on Linea, Plasma and Ink
-            ]),
-        )
-        // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
-        .add_contract(
-            Contract::new("BalancerV2WeightedPoolFactoryV3").with_networks(networks![
-                // <https://etherscan.io/tx/0x39f357b78c03954f0bcee2288bf3b223f454816c141ef20399a7bf38057254c4>
-                MAINNET => ("0x5Dd94Da3644DDD055fcf6B3E1aa310Bb7801EB8b", 16520627),
-                // <https://gnosisscan.io/tx/0x2ac3d873b6f43de6dd77525c7e5b68a8fc3a1dee40303e1b6a680b0285b26091>
-                GNOSIS => ("0xC128a9954e6c874eA3d62ce62B468bA073093F25", 26226256),
-                // <https://snowscan.xyz/tx/0xdf2c77743cc9287df2022cd6c5f9209ecfecde07371717ab0427d96042a88640>
-                AVALANCHE => ("0x94f68b54191F62f781Fe8298A8A5Fa3ed772d227", 26389236),
-                // <https://optimistic.etherscan.io/tx/0xc5e79fb00b9a8e2c89b136aae0be098e58f8e832ede13e8079213a75c9cd9c08>
-                OPTIMISM => ("0xA0DAbEBAAd1b243BBb243f933013d560819eB66f", 72832703),
-                // <https://polygonscan.com/tx/0x2bc079c0e725f43670898b474afedf38462feee72ef8e874a1efcec0736672fc>
-                POLYGON => ("0x82e4cFaef85b1B6299935340c964C942280327f4", 39036828),
-                // <https://bscscan.com/tx/0x91107b9581e18ec0a4a575d4713bdd7b1fc08656c35522d216307930aa4de7b6>
-                BNB => ("0x6e4cF292C5349c79cCd66349c3Ed56357dD11B46", 25474982),
-                // Not available on Sepolia (only version ≥ 4)
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // Not available on Linea, Plasma and Ink
-            ]),
-        )
-        .add_contract(
-            Contract::new("BalancerV2WeightedPoolFactoryV4").with_networks(networks![
-                // <https://etherscan.io/tx/0xa5e6d73befaacc6fff0a4b99fd4eaee58f49949bcfb8262d91c78f24667fbfc9>
-                MAINNET => ("0x897888115Ada5773E02aA29F775430BFB5F34c51", 16878323),
-                // <https://gnosisscan.io/tx/0xcb6768bd92add227d46668357291e1d67c864769d353f9f0041c59ad2a3b21bf>
-                GNOSIS => ("0x6CaD2ea22BFA7F4C14Aae92E47F510Cd5C509bc7", 27055829),
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html#pool-factories>
-                // <https://sepolia.etherscan.io/tx/0x7dd392b586f1cdecfc635e7dd40ee1444a7836772811e59321fd4873ecfdf3eb>
-                SEPOLIA => ("0x7920BFa1b2041911b354747CA7A6cDD2dfC50Cfd", 3424893),
-                // <https://arbiscan.io/tx/0x167fe7eb776d1be36b21402d8ae120088c393e28ae7ca0bd1defac84e0f2848b>
-                ARBITRUM_ONE => ("0xc7E5ED1054A24Ef31D827E6F86caA58B3Bc168d7", 72222060),
-                // <https://basescan.org/tx/0x0732d3a45a3233a134d6e0e72a00ca7a971d82cdc51f71477892ac517bf0d4c9>
-                BASE => ("0x4C32a8a8fDa4E24139B51b456B42290f51d6A1c4", 1204869),
-                // <https://snowscan.xyz/tx/0xa3fc8aab3b9baba3905045a53e52a47daafe79d4aa26d4fef5c51f3840aa55fa>
-                AVALANCHE => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 27739006),
-                // <https://optimistic.etherscan.io/tx/0xad915050179db368e43703f3ee1ec55ff5e5e5e0268c15f8839c9f360caf7b0b>
-                OPTIMISM => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 82737545),
-                // <https://polygonscan.com/tx/0x65e6b13231c2c5656357005a9e419ad6697178ae74eda1ea7522ecdafcf77136>
-                POLYGON => ("0xFc8a407Bba312ac761D8BFe04CE1201904842B76", 40611103),
-                // <https://bscscan.com/tx/0xc7fada60761e3240332c4cbd169633f1828b2a15de23f0148db9d121afebbb4b>
-                BNB => ("0x230a59F4d9ADc147480f03B0D3fFfeCd56c3289a", 26665331),
-                // Not available on Base, Linea, Plasma and Ink
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-            ]),
-        )
-        // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
-        .add_contract(
-            Contract::new("BalancerV2WeightedPool2TokensFactory").with_networks(networks![
-                // <https://etherscan.io/tx/0xa5e6d73befaacc6fff0a4b99fd4eaee58f49949bcfb8262d91c78f24667fbfc9>
-                MAINNET => ("0xa5bf2ddf098bb0ef6d120c98217dd6b141c74ee0", 12349891),
-                ARBITRUM_ONE => ("0xCF0a32Bbef8F064969F21f7e02328FB577382018", 222864),
-                // <https://optimistic.etherscan.io/tx/0xd5754950d47179d822ea976a8b2af82ffa80e992cf0660b02c0c218359cc8987>
-                OPTIMISM => ("0xdAE7e32ADc5d490a43cCba1f0c736033F2b4eFca", 7005512),
-                // <https://polygonscan.com/tx/0xb8ac851249cc95bc0943ef0732d28bbd53b0b36c7dd808372666acd8c5f26e1c>
-                POLYGON => ("0x8E9aa87E45e92bad84D5F8DD1bff34Fb92637dE9", 15832998),
-                // Not available on Sepolia, Base, Avalanche, BNB, Linea, Plasma and Ink
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-            ]),
-        )
-        // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
-        .add_contract(
-            Contract::new("BalancerV2StablePoolFactoryV2").with_networks(networks![
-                // <https://etherscan.io/tx/0xef36451947ebd97b72278face57a53806e90071f4c902259db2db41d0c9a143d>
-                MAINNET => ("0x8df6efec5547e31b0eb7d1291b511ff8a2bf987c", 14934936),
-                // <https://gnosisscan.io/tx/0xe062237f0c8583375b10cf514d091781bfcd52d9ababbd324180770a5efbc6b1>
-                GNOSIS => ("0xf23b4DB826DbA14c0e857029dfF076b1c0264843", 25415344),
-                ARBITRUM_ONE => ("0xEF44D6786b2b4d544b7850Fe67CE6381626Bf2D6", 14244664),
-                // <https://optimistic.etherscan.io/tx/0xcf9f0bd731ded0e513708200df28ac11d17246fb53fc852cddedf590e41c9c03>
-                OPTIMISM => ("0xeb151668006CD04DAdD098AFd0a82e78F77076c3", 11088891),
-                // <https://polygonscan.com/tx/0xa2c41d014791888a29a9491204446c1b9b2f5dee3f3eb31ad03f290259067b44>
-                POLYGON => ("0xcA96C4f198d343E251b1a01F3EBA061ef3DA73C1", 29371951),
-                // Not available on Sepolia, Base, Avalanche, BNB, Linea, Plasma and Ink
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-            ]),
-        )
-        // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
-        .add_contract(
-            Contract::new("BalancerV2LiquidityBootstrappingPoolFactory").with_networks(networks![
-                // <https://etherscan.io/tx/0x665ac1c7c5290d70154d9dfc1d91dc2562b143aaa9e8a77aa13e7053e4fe9b7c>
-                MAINNET => ("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE", 12871780),
-                ARBITRUM_ONE => ("0x142B9666a0a3A30477b052962ddA81547E7029ab", 222870),
-                // <https://polygonscan.com/tx/0xd9b5b9a9e6ea17a87f85574e93577e3646c9c2f9c8f38644f936949e6c853288>
-                POLYGON => ("0x751A0bC0e3f75b38e01Cf25bFCE7fF36DE1C87DE", 17116402),
-                // Not available on Sepolia, Base, Avalanche, BNB, Optimism, Linea, Plasma and Ink
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-            ]),
-        )
-        // <https://docs.balancer.fi/reference/contracts/deployment-addresses/mainnet.html#ungrouped-active-current-contracts>
-        .add_contract(
-            Contract::new("BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory")
-                .with_networks(networks![
-                    // <https://etherscan.io/tx/0x298381e567ff6643d9b32e8e7e9ff0f04a80929dce3e004f6fa1a0104b2b69c3>
-                    MAINNET => ("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", 13730248),
-                    // <https://docs.balancer.fi/reference/contracts/deployment-addresses/gnosis.html#ungrouped-active-current-contracts>
-                    // <https://gnosis.blockscout.com/tx/0xbd56fefdb27e4ff1c0852e405f78311d6bc2befabaf6c87a405ab19de8c1506a>
-                    GNOSIS => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 25415236),
-                    // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html#ungrouped-active-current-contracts>
-                    // <https://sepolia.etherscan.io/tx/0xe0e8feb509a8aa8a1eaa0b0c4b34395ff2fd880fb854fbeeccc0af1826e395c9>
-                    SEPOLIA => ("0x45fFd460cC6642B8D8Fb12373DFd77Ceb0f4932B", 3419649),
-                    ARBITRUM_ONE => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 4859669),
-                    // <https://basescan.org/tx/0x0529de9dbe772f4b4f48da93ae2c2d2c46e3d3221ced9e0c4063a7a5bc47e874>
-                    BASE => ("0x0c6052254551EAe3ECac77B01DFcf1025418828f", 1206531),
-                    // <https://snowscan.xyz/tx/0x33a75d83436ae9fcda4b4986713417bf3dc80d9ceb8d2541817846b1ac579d9f>
-                    AVALANCHE => ("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", 26386552),
-                    // <https://bscscan.com/tx/0x8b964b97e6091bd41c93002c558d49adc26b8b31d2b30f3a33babbbbe8c55f47>
-                    BNB => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 22691243),
-                    // <https://optimistic.etherscan.io/tx/0x14fb43f051eebdec645abf0125e52348dc875b0887b689f8db026d75f9c78dda>
-                    OPTIMISM => ("0xf302f9F50958c5593770FDf4d4812309fF77414f", 7005915),
-                    // <https://polygonscan.com/tx/0x125bc007a86d771f8dc8f5fa1017de6e5a11162a458a72f25814503404bbeb0b>
-                    POLYGON => ("0x41B953164995c11C81DA73D212ED8Af25741b7Ac", 22067480),
-                    // Not available on Linea, Plasma and Ink
-                ]),
-        )
-        .add_contract(
-            Contract::new("BalancerV2ComposableStablePoolFactory").with_networks(networks![
-                // <https://etherscan.io/tx/0x3b9e93ae050e59b3ca3657958ca30d1fd13fbc43208f8f0aa01ae992294f9961>
-                MAINNET => ("0xf9ac7B9dF2b3454E841110CcE5550bD5AC6f875F", 15485885),
-                ARBITRUM_ONE => ("0xaEb406b0E430BF5Ea2Dc0B9Fe62E4E53f74B3a33", 23227044),
-                // <https://bscscan.com/tx/0x6c6e1c72c91c75714f698049f1c7b66d8f2baced54e0dd2522dfadff27b5ccf1>
-                BNB => ("0xf302f9F50958c5593770FDf4d4812309fF77414f", 22691193),
-                // <https://optimistic.etherscan.io/tx/0xad2f330ad865dc7955376a3d9733486b38c53ba0d4757ad4e1b63b105401c506>
-                OPTIMISM => ("0xf145caFB67081895EE80eB7c04A30Cf87f07b745", 22182522),
-                // <https://polygonscan.com/tx/0xe5d908be686056f1519663a407167c088924f60d29c799ec74438b9de891989e>
-                POLYGON => ("0x136FD06Fa01eCF624C7F2B3CB15742c1339dC2c4", 32774224),
-                // Not available on Sepolia, Gnosis Chain, Base, Avalanche, Linea, Plasma and Ink
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-            ]),
-        )
-        .add_contract(
-            Contract::new("BalancerV2ComposableStablePoolFactoryV3").with_networks(networks![
-                // <https://etherscan.io/tx/0xd8c9ba758cb318beb0c9525b7621280a22b6dfe02cf725a3ece0718598f260ef>
-                MAINNET => ("0xdba127fBc23fb20F5929C546af220A991b5C6e01", 16580899),
-                // <https://gnosisscan.io/tx/0x2abd7c865f8ab432b340f7de897192c677ffa254908fdec14091e0cd06962963>
-                GNOSIS => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 26365805),
-                ARBITRUM_ONE => ("0x1c99324EDC771c82A0DCCB780CC7DDA0045E50e7", 58948370),
-                // <https://bscscan.com/tx/0xfe0c47c2b124a059d11704c1bd1815dcc554834ae0c2d11c433946226015619f>
-                BNB => ("0xacAaC3e6D6Df918Bf3c809DFC7d42de0e4a72d4C", 25475700),
-                // <https://optimistic.etherscan.io/tx/0x2bb1c3fbf1370c6e20ecda36b555de1a4426340908055c4274823e31f92210e>
-                OPTIMISM => ("0xe2E901AB09f37884BA31622dF3Ca7FC19AA443Be", 72832821),
-                // <https://polygonscan.com/tx/0xb189a45eac7ea59c0bb638b5ae6c4c93f9877f31ce826e96b792a9154e7a32a7>
-                POLYGON => ("0x7bc6C0E73EDAa66eF3F6E2f27b0EE8661834c6C9", 39037615),
-                // Not available on Sepolia (only version ≥ 4) and on Base (only version ≥ 5)
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html>
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-                // Not available on Linea, Plasma and Ink
-            ]),
-        )
-        .add_contract(
-            Contract::new("BalancerV2ComposableStablePoolFactoryV4").with_networks(networks![
-                // <https://etherscan.io/tx/0x3b61da162f3414c376cfe8b38d57ca6ba3c40b24446029ddab1187f4ae7c2bd7>
-                MAINNET => ("0xfADa0f4547AB2de89D1304A668C39B3E09Aa7c76", 16878679),
-                // <https://gnosisscan.io/tx/0x2739416da7e44add08bdfb5e4e5a29ca981383b97162748887efcc5c1241b2f1>
-                GNOSIS => ("0xD87F44Df0159DC78029AB9CA7D7e57E7249F5ACD", 27056416),
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html#deprecated-contracts>
-                // <https://sepolia.etherscan.io/tx/0x9313a59ad9a95f2518076cbf4d0dc5f312e0b013a43a7ea4821cae2aa7a50aa2>
-                SEPOLIA => ("0xA3fd20E29358c056B727657E83DFd139abBC9924", 3425277),
-                ARBITRUM_ONE => ("0x2498A2B0d6462d2260EAC50aE1C3e03F4829BA95", 72235860),
-                // <https://snowscan.xyz/tx/0x7b396102e767ec5f2bc06fb2c9d7fb704d0ddc537c04f28cb538c6de7cc4261e>
-                AVALANCHE => ("0x3B1eb8EB7b43882b385aB30533D9A2BeF9052a98", 29221425),
-                // <https://bscscan.com/tx/0x2819b490b5e04e27d66476730411df8e572bc33038aa869a370ecfa852de0cbf>
-                BNB => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 26666380),
-                // <https://optimistic.etherscan.io/tx/0x5d6c515442188eb4af83524618333c0fbdab0df809af01c4e7a9e380f1841199>
-                OPTIMISM => ("0x1802953277FD955f9a254B80Aa0582f193cF1d77", 82748180),
-                // <https://polygonscan.com/tx/0x2cea6a0683e67ebdb7d4a1cf1ad303126c5f228f05f8c9e2ccafdb1f5a024376>
-                POLYGON => ("0x6Ab5549bBd766A43aFb687776ad8466F8b42f777", 40613553),
-                // Not available on Base, Linea, Plasma and Ink
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/base.html>
-            ]),
-        )
-        .add_contract(
-            Contract::new("BalancerV2ComposableStablePoolFactoryV5").with_networks(networks![
-                // <https://etherscan.io/tx/0x1fc28221925959c0713d04d9f9159255927ebb94b7fa76e4795db0e365643c07>
-                MAINNET => ("0xDB8d758BCb971e482B2C45f7F8a7740283A1bd3A", 17672478),
-                // <https://gnosisscan.io/tx/0xcbf18b5a0d1f1fca9b30d08ab77d8554567c3bffa7efdd3add273073d20bb1e2>
-                GNOSIS => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 28900564),
-                // <https://docs.balancer.fi/reference/contracts/deployment-addresses/sepolia.html#ungrouped-active-current-contracts>
-                // <https://sepolia.etherscan.io/tx/0x2c155dde7c480929991dd2a3344d9fdd20252f235370d46d0887b151dc0416bd>
-                SEPOLIA => ("0xa523f47A933D5020b23629dDf689695AA94612Dc", 3872211),
-                ARBITRUM_ONE => ("0xA8920455934Da4D853faac1f94Fe7bEf72943eF1", 110212282),
-                // <https://basescan.org/tx/0x1d291ba796b0397d73581b17695cf0e53e61551e419c43d11d81198b00c2bfd3>
-                BASE => ("0x8df317a729fcaA260306d7de28888932cb579b88", 1204710),
-                // <https://snowscan.xyz/tx/0x000659feb0831fc511f5c2ad12f3b2d466152b753c805fcb06e848701fd1b4b7>
-                AVALANCHE => ("0xE42FFA682A26EF8F25891db4882932711D42e467", 32478827),
-                // <https://bscscan.com/tx/0x5bdfed936f82800e80543d5212cb287dceebb52c29133838acbe7e148bf1a447>
-                BNB => ("0x4fb47126Fa83A8734991E41B942Ac29A3266C968", 29877945),
-                // <https://optimistic.etherscan.io/tx/0xa141b35dbbb18154e2452b1ae6ab7d82a6555724a878b5fccff40e18c8ae3484>
-                OPTIMISM => ("0x043A2daD730d585C44FB79D2614F295D2d625412", 106752707),
-                // <https://polygonscan.com/tx/0xa3d9a1cf00eaca469d6f9ec2fb836bbbfdfbc3b0eeadc07619bb9e695bfdecb8>
-                POLYGON => ("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b", 44961548),
-                // Not available on Linea, Plasma and Ink
-            ]),
-        )
-        .add_contract(
-            Contract::new("BalancerV2ComposableStablePoolFactoryV6").with_networks(networks![
-                // <https://etherscan.io/tx/0x4149cadfe5d3431205d9819fca44ed7a4c2b101adc51adc75cc4586dee237be8>
-                MAINNET => ("0x5B42eC6D40f7B7965BE5308c70e2603c0281C1E9", 19314764),
-                // <https://gnosisscan.io/tx/0xc3fc1fb96712a0659b7e9e5f406f63bdf5cbd5df9e04f0372c28f75785036791>
-                GNOSIS => ("0x47B489bf5836f83ABD928C316F8e39bC0587B020", 32650879),
-                // <https://sepolia.etherscan.io/tx/0x53aa3587002469b758e2bb87135d9599fd06e7be944fe61c7f82045c45328566>
-                SEPOLIA => ("0x05503B3aDE04aCA81c8D6F88eCB73Ba156982D2B", 5369821),
-                // <https://arbiscan.io/tx/0xfa1e7642e135fb32dc14c990b851e5e7a0ac7a463e3a60c5003ae4142396f45e>
-                ARBITRUM_ONE => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 184805448),
-                // <https://basescan.org/tx/0x5d3342faf0368b939daa93247536afa26cc72c83de52ba7711ae1b8646688467>
-                BASE => ("0x956CCab09898C0AF2aCa5e6C229c3aD4E93d9288", 11099703),
-                // <https://snowscan.xyz/tx/0x246248ad396826dbfbdc5360cb9cbbdb3a672efa08cc745d1670900888c58c7b>
-                AVALANCHE => ("0xb9F8AB3ED3F3aCBa64Bc6cd2DcA74B7F38fD7B88", 42186350),
-                // <https://bscscan.com/tx/0x6784ab50138c7488bc14d4d9beb6a9e1ddc209a45f0a96b4ee98a7db84167dea>
-                BNB => ("0x6B5dA774890Db7B7b96C6f44e6a4b0F657399E2e", 36485719),
-                // <https://optimistic.etherscan.io/tx/0xa38b696479f35a9751ca8b1f0ddeb160188b3146113975b8c2b657c2fe7d7fd2>
-                OPTIMISM => ("0x4bdCc2fb18AEb9e2d281b0278D946445070EAda7", 116694338),
-                // <https://polygonscan.com/tx/0x7b9678ad538b1cd3f3a03e63455e7d49a1bc716ea42310fbf99df4bf93ecfdfa>
-                POLYGON => ("0xEAedc32a51c510d35ebC11088fD5fF2b47aACF2E", 53996258),
-                // Not available on Linea, Plasma and Ink
-            ]),
-        )
-        // Balancer addresses can be obtained from:
-        // <https://github.com/balancer/balancer-subgraph-v2/blob/master/networks.yaml>
-        .add_contract(Contract::new("BalancerV2Vault").with_networks(networks![
-            // <https://etherscan.io/tx/0x28c44bb10d469cbd42accf97bd00b73eabbace138e9d44593e851231fbed1cb7>
-            MAINNET => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 12272146),
-            // <https://gnosisscan.io/tx/0x21947751661e1b9197492f22779af1f5175b71dc7057869e5a8593141d40edf1>
-            GNOSIS => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 24821598),
-            // <https://sepolia.etherscan.io/tx/0xb22509c6725dd69a975ecb96a0c594901eeee6a279cc66d9d5191022a7039ee6>
-            SEPOLIA => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 3418831),
-            // <https://arbiscan.io/tx/0xe2c3826bd7b15ef8d338038769fe6140a44f1957a36b0f27ab321ab6c68d5a8e>
-            ARBITRUM_ONE => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 222832),
-            // <https://basescan.org/tx/0x0dc2e3d436424f2f038774805116896d31828c0bf3795a6901337bdec4e0dff6>
-            BASE => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 1196036),
-            // <https://snowscan.xyz/tx/0xc49af0372feb032e0edbba6988410304566b1fd65546c01ced620ac3c934120f>
-            AVALANCHE => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 26386141),
-            // <https://bscscan.com/tx/0x1de8caa6c54ff9a25600e26d80865d84c9cc4d33c2b98611240529ee7de5cd74>
-            BNB => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 22691002),
-            // <https://optimistic.etherscan.io/tx/0xa03cb990595df9eed6c5db17a09468cab534aed5f5589a06c0bb3d19dd2f7ce9>
-            OPTIMISM => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 7003431),
-            // <https://polygonscan.com/tx/0x66f275a2ed102a5b679c0894ced62c4ebcb2a65336d086a916eb83bd1fe5c8d2>
-            POLYGON => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 15832990),
-            // <https://explorer.inkonchain.com/address/0xBA12222222228d8Ba445958a75a0704d566BF2C8>
-            INK => ("0xBA12222222228d8Ba445958a75a0704d566BF2C8", 34313901),
-            // Not available on Linea and Plasma
-        ]))
-        .add_contract(
-            Contract::new("BalancerV3BatchRouter").with_networks(networks![
-                // <https://etherscan.io/tx/0x41cb8619fb92dd532eb09b0e81fd4ce1c6006a10924893f02909e36a317777f3>
-                MAINNET => ("0x136f1EFcC3f8f88516B9E94110D56FDBfB1778d1", 21339510),
-                // <https://gnosisscan.io/tx/0xeafddbace9f445266f851ef1d92928e3d01a4622a1a6780b41ac52d5872f12ab>
-                GNOSIS => ("0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b", 37377506),
-                // <https://sepolia.etherscan.io/tx/0x95ed8e1aaaa7bdc5881f3c8fc5a4914a66639bee52987c3a1ea88545083b0681>
-                SEPOLIA => ("0xC85b652685567C1B074e8c0D4389f83a2E458b1C", 7219301),
-                // <https://arbiscan.io/tx/0xa7968c6bc0775208ffece789c6e5d09b0eea5f2c3ed2806e9bd94fb0b978ff0f>
-                ARBITRUM_ONE => ("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E", 297828544),
-                // <https://basescan.org/tx/0x47b81146714630ce50445bfa28872a36973acedf785317ca423498810ec8e76c>
-                BASE => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 25347205),
-                // <https://snowscan.xyz/tx/0x3bfaba7135ee2d67d98f20ee1aa4c8b7e81e47be64223376f3086bab429ac806>
-                AVALANCHE => ("0xc9b36096f5201ea332Db35d6D195774ea0D5988f", 59965747),
-                // <https://optimistic.etherscan.io/tx/0xf370aab0d652f3e0f7c34e1a53e1afd98e86c487138300b0939d4e54b0088b67>
-                OPTIMISM => ("0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E", 133969588),
-                // <https://plasmascan.to/tx/0x7368609020622059d1061b4e3cc16aa448315956cace1e089f6876143cf2f90c?chainid=9745>
-                PLASMA => ("0x85a80afee867aDf27B50BdB7b76DA70f1E853062", 782312),
-                // Not available on Polygon, BNB, Linea and Ink
-            ]),
-        )
-        // UniV2
-        .add_contract(Contract::new("BaoswapRouter").with_networks(networks![
-            // https://gnosisscan.io/tx/0xdcbfa037f2c6c7456022df0632ec8d6a75d0f9a195238eec679d5d26895eb7b1
-            GNOSIS => "0x6093AeBAC87d62b1A5a4cEec91204e35020E38bE",
-        ]))
-        .add_contract(Contract::new("HoneyswapRouter").with_networks(networks![
-            GNOSIS => "0x1C232F01118CB8B424793ae03F870aa7D0ac7f77",
-        ]))
-        .add_contract(Contract::new("PancakeRouter").with_networks(networks![
-            // <https://etherscan.io/tx/0x6e441248a9835ca10a3c29a19f2e1ed61d2e35f3ecb3a5b9e4ee170d62a22d16>
-            MAINNET => "0xEfF92A263d31888d860bD50809A8D171709b7b1c",
-            // <https://arbiscan.io/tx/0x4a2da73cbfcaafb0347e4525307a095e38bf7532435cb0327d1f5ee2ee15a011>
-            ARBITRUM_ONE => "0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb",
-            // <https://basescan.org/tx/0xda322aef5776698ac6da56be1ffaa0f9994a983cdeb9f2aeaba47437809ae6ef>
-            BASE => "0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb",
-            // <https://bscscan.com/tx/0x1bfbff8411ed44e609d911476b0d35a28284545b690902806ea0a7ff0453e931>
-            BNB => "0x10ED43C718714eb63d5aA57B78B54704E256024E",
-        ]))
-        // <https://docs.sushi.com/contracts/cpamm>
-        .add_contract(Contract::new("SushiSwapRouter").with_networks(networks![
-            // <https://etherscan.io/tx/0x4ff39eceee7ba9a63736eae38be69b10347975ff5fa4d9b85743a51e1c384094>
-            MAINNET => "0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f",
-            // <https://gnosisscan.io/tx/0x8b45ccbc2afd0132ef8b636064e0e745ff93b53942a56e320bb930666dd0fb18>
-            GNOSIS => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
-            // <https://arbiscan.io/tx/0x40b22402bcac46330149ac9848f8bddd02b0a1e79d4a71934655a634051be1a1>
-            ARBITRUM_ONE => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
-            // <https://basescan.org/tx/0xbb673c483292e03d202e95a023048b8bda459bf12402e7688f7e10be8b4dc67d>
-            BASE => "0x6bded42c6da8fbf0d2ba55b2fa120c5e0c8d7891",
-            // <https://snowtrace.io/tx/0x8185bcd3cc8544f8767e5270c4d7eb1e9b170fc0532fc4f0d7e7a1018e1f13ba>
-            AVALANCHE => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
-            // <https://bscscan.com/tx/0xf22f827ae797390f6e478b0a11aa6e92d6da527f47130ef70d313ff0e0b2a83f>
-            BNB => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
-            // <https://optimistic.etherscan.io/tx/0x88be6cc83f5bfccb8196db351866bac5c99ab8f7b451ea9975319ba05c3bf8f7>
-            OPTIMISM => "0x2abf469074dc0b54d793850807e6eb5faf2625b1",
-            // <https://polygonscan.com/tx/0x3dcf8fc780ae6fbe40b1ae57927a8fb405f54cbe89d0021a781a100d2086e5ba>
-            POLYGON => "0x1b02da8cb0d097eb8d57a175b88c7d8b47997506",
-            // Not available on Linea, Plasma and Ink
-        ]))
-        // <https://swapr.gitbook.io/swapr/contracts>
-        .add_contract(Contract::new("SwaprRouter").with_networks(networks![
-            // <https://etherscan.io/tx/0x3f4ccc676637906db24caf043c89dafce959321c02266c6a4ab706fcec79a5f7>
-            MAINNET => "0xb9960d9bca016e9748be75dd52f02188b9d0829f",
-            // <https://gnosisscan.io/tx/0x0406e774caced468b8f84d7c7ed9b6e9c324601af38f44e385aecf7a7d01feb4>
-            GNOSIS => "0xE43e60736b1cb4a75ad25240E2f9a62Bff65c0C0",
-            // <https://arbiscan.io/tx/0x09771774fc138775472910f6bb0f2e03ff74e1e32a658e9c3e4d8f59f6431ba8>
-            ARBITRUM_ONE => "0x530476d5583724A89c8841eB6Da76E7Af4C0F17E",
-            // Not available on Base, Linea, Plasma and Ink
-        ]))
-        .add_contract(Contract::new("ISwaprPair"))
-        .add_contract(
-            Contract::new("TestnetUniswapV2Router02").with_networks(networks![
-                // <https://sepolia.etherscan.io/tx/0x2bf9a91a42d53e161897d9c581f798df9db6fb00587803dde7e7b8859118d821>
-                SEPOLIA => "0x86dcd3293C53Cf8EFd7303B57beb2a3F671dDE98",
-            ]),
-        )
-        // <https://docs.uniswap.org/contracts/v2/reference/smart-contracts/factory>
-        .add_contract(Contract::new("UniswapV2Factory").with_networks(networks![
-            // <https://etherscan.io/tx/0xc31d7e7e85cab1d38ce1b8ac17e821ccd47dbde00f9d57f2bd8613bff9428396>
-            MAINNET => "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
-            // <https://gnosisscan.io/tx/0x446de52c460bed3f49a4342eab247bb4b2fe2993962c284fb9bc14a983c7a3d4>
-            GNOSIS => "0xA818b4F111Ccac7AA31D0BCc0806d64F2E0737D7",
-            // <https://arbiscan.io/tx/0x83b597d54496c0b64d66a3b9a65c312e406262511c908f702ef06755d13ab2f3>
-            ARBITRUM_ONE => "0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9",
-            // <https://basescan.org/tx/0x3c94031f81d9afe3beeb8fbcf4dcf1bd5b5688b86081d94e3d0231514dc00d31>
-            BASE => "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6",
-            // <https://sepolia.etherscan.io/tx/0x0a5e26b22f6b470857957a1d5a92ad4a7d3c5e7cf254ddd80edfe23df70eae71>
-            SEPOLIA => "0xF62c03E08ada871A0bEb309762E260a7a6a880E6",
-            // <https://snowtrace.io/tx/0xd06a069b11fc0c998b404c5736957cc16c71cf1f7dbf8a7d4244c84036ea6edd>
-            AVALANCHE => "0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C",
-            // <https://bscscan.com/tx/0x7305a4bddc54eee158f245a09526969697ac1a9f56d090b124ebfc85ff71a5cf>
-            BNB => "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6",
-            // <https://optimistic.etherscan.io/tx/0xf7227dcbbfa4ea2bb2634f2a1f364a64b028f9e9e393974fea8d435cd097c72e>
-            OPTIMISM => "0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf",
-            // <https://polygonscan.com/tx/0x712ac56155a301fca4b7a761e232233f41a104865a74b1a59293835da355292a>
-            POLYGON => "0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C",
-            // Not available on Ink (no Uniswap V2)
-        ]))
-        // <https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02>
-        .add_contract(Contract::new("UniswapV2Router02").with_networks(networks![
-            // <https://etherscan.io/tx/0x4fc1580e7f66c58b7c26881cce0aab9c3509afe6e507527f30566fbf8039bcd0>
-            MAINNET => "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
-            // <https://gnosisscan.io/tx/0xfcc495cdb313b48bbb0cd0a25cb2e8fd512eb8fb0b15f75947a9d5668e47a918>
-            GNOSIS => "0x1C232F01118CB8B424793ae03F870aa7D0ac7f77",
-            // <https://arbiscan.io/tx/0x630cd9d56a85e1bac7795d254fef861304a6838e28869badef19f19defb48ba6>
-            ARBITRUM_ONE => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
-            // <https://basescan.org/tx/0x039224ce16ebe5574f51da761acbdfbd21099d6230c39fcd8ff566bbfd6a50a9>
-            BASE => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
-            // <https://sepolia.etherscan.io/tx/0x92674b51681d2e99e71e03bd387bc0f0e79f2412302b49ed5626d1fa2311bab9>
-            SEPOLIA => "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
-            // <https://snowtrace.io/tx/0x7372f1eedf9d32fb4185d486911f44542723dae766eea04bc3f14724bae9552e>
-            AVALANCHE => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
-            // <https://bscscan.com/tx/0x9e940f846abea7dcc1f0bd5c261f405c104628c855346f8cac966f52905ee0fa>
-            BNB => "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
-            // <https://optimistic.etherscan.io/tx/0x2dcb9a76100e5be49e89085b87bd447b1966a9d823d5985e1a8197834c60e6bd>
-            OPTIMISM => "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
-            // <https://polygonscan.com/tx/0x66186e0cacd2f6b3ad2eae586bd331daafd0572eb80bf71be694181858198025>
-            POLYGON => "0xedf6066a2b290C185783862C7F4776A2C8077AD1",
-            // Not available on Ink (no Uniswap V2)
-        ]))
-        .add_contract(Contract::new("IUniswapLikeRouter"))
-        .add_contract(Contract::new("IUniswapLikePair"))
-        .add_contract(Contract::new("UniswapV3Pool"))
-        // <https://docs.uniswap.org/contracts/v3/reference/deployments/>
-        .add_contract(Contract::new("UniswapV3QuoterV2").with_networks(networks![
-            MAINNET => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-            ARBITRUM_ONE => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-            BASE => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
-            AVALANCHE => "0xbe0F5544EC67e9B3b2D979aaA43f18Fd87E6257F",
-            BNB => "0x78D78E420Da98ad378D7799bE8f4AF69033EB077",
-            OPTIMISM => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-            POLYGON => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-            LINEA => "0x42bE4D6527829FeFA1493e1fb9F3676d2425C3C1",
-            // not official (deployed by oku trade)
-            // <https://docs.oku.trade/home/extra-information/deployed-contracts#plasma>
-            PLASMA => "0xaa52bB8110fE38D0d2d2AF0B85C3A3eE622CA455",
-            // <https://explorer.inkonchain.com/address/0x96b572D2d880cf2Fa2563651BD23ADE6f5516652>
-            INK => "0x96b572D2d880cf2Fa2563651BD23ADE6f5516652",
-            // Not listed on Gnosis and Sepolia chains
-        ]))
-        // <https://github.com/Uniswap/v3-periphery/blob/697c2474757ea89fec12a4e6db16a574fe259610/deploys.md>
-        .add_contract(
-            Contract::new("UniswapV3SwapRouterV2").with_networks(networks![
-                ARBITRUM_ONE => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-                MAINNET => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-                POLYGON => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-                OPTIMISM => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-                BASE => "0x2626664c2603336E57B271c5C0b26F421741e481",
-                AVALANCHE => "0xbb00FF08d01D300023C629E8fFfFcb65A5a578cE",
-                BNB => "0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2",
-                LINEA => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
-                // not official (deployed by oku trade)
-                // <https://docs.oku.trade/home/extra-information/deployed-contracts#plasma>
-                PLASMA => "0x807F4E281B7A3B324825C64ca53c69F0b418dE40",
-                // <https://explorer.inkonchain.com/address/0x177778F19E89dD1012BdBe603F144088A95C4B53>
-                INK => "0x177778F19E89dD1012BdBe603F144088A95C4B53",
-                // Not available on Gnosis Chain
-            ]),
-        )
-        // <https://github.com/Uniswap/v3-periphery/blob/697c2474757ea89fec12a4e6db16a574fe259610/deploys.md>
-        .add_contract(Contract::new("IUniswapV3Factory").with_networks(networks![
-            MAINNET => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            SEPOLIA => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            ARBITRUM_ONE => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            BASE => "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
-            AVALANCHE => "0x740b1c1de25031C31FF4fC9A62f554A55cdC1baD",
-            BNB => "0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7",
-            OPTIMISM => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            POLYGON => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            LINEA => "0x31FAfd4889FA1269F7a13A66eE0fB458f27D72A9",
-            // not official (deployed by oku trade)
-            // <https://docs.oku.trade/home/extra-information/deployed-contracts#plasma>
-            PLASMA => "0xcb2436774C3e191c85056d248EF4260ce5f27A9D",
-            // <https://explorer.inkonchain.com/address/0x640887A9ba3A9C53Ed27D0F7e8246A4F933f3424>
-            INK => "0x640887A9ba3A9C53Ed27D0F7e8246A4F933f3424",
-            // Not available on Gnosis Chain
-        ]))
-        // <https://github.com/cowprotocol/hooks-trampoline/blob/993427166ade6c65875b932f853776299290ac4b/networks.json>
-        .add_contract(Contract::new("HooksTrampoline").with_networks(networks![
-            MAINNET => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            // Gnosis is using the old instance of the hook trampoline since it's hardcoded in gnosis pay rebalance integration.
-            GNOSIS => "0x01DcB88678aedD0C4cC9552B20F4718550250574",
-            SEPOLIA => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            ARBITRUM_ONE => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            BASE => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            AVALANCHE => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            BNB => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            OPTIMISM => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            POLYGON => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            LINEA => "0x60bf78233f48ec42ee3f101b9a05ec7878728006",
-            PLASMA => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            INK => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-        ]))
-        .add_contract(Contract::new("CoWSwapEthFlow").with_networks(networks![
-            // <https://etherscan.io/tx/0x0247e3c15f59a52b099f192265f1c1e6227f48a280717b3eefd7a5d9d0c051a1>
-            MAINNET => ("0x40a50cf069e992aa4536211b23f286ef88752187", 16169866),
-            // <https://gnosisscan.io/tx/0x6280e079f454fbb5de3c52beddd64ca2b5be0a4b3ec74edfd5f47e118347d4fb>
-            GNOSIS => ("0x40a50cf069e992aa4536211b23f286ef88752187", 25414331),
-            // <https://github.com/cowprotocol/ethflowcontract/blob/v1.1.0-artifacts/networks.prod.json#L11-L14>
-            // <https://sepolia.etherscan.io/tx/0x558a7608a770b5c4f68fffa9b02e7908a40f61b557b435ea768a4c62cb79ae25>
-            SEPOLIA => ("0x0b7795E18767259CC253a2dF471db34c72B49516", 4718739),
-            // <https://arbiscan.io/tx/0xa4066ca77bbe1f21776b4c26315ead3b1c054b35814b49e0c35afcbff23e1b8d>
-            ARBITRUM_ONE => ("0x6DFE75B5ddce1ADE279D4fa6BD6AeF3cBb6f49dB", 204747458),
-            // <https://basescan.org/tx/0xc3555c4b065867cbf34382438e1bbaf8ee39eaf10fb0c70940c8955962e76e2c>
-            BASE => ("0x3C3eA1829891BC9bEC3d06A81d5d169e52a415e3", 21490258),
-            // <https://snowscan.xyz/tx/0x71a2ed9754247210786effa3269bc6eb68b7521b5052ac9f205af7ac364f608f>
-            AVALANCHE => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 60496408),
-            // <https://bscscan.com/tx/0x959a60a42d36e0efd247b3cf19ed9d6da503d01bce6f87ed31e5e5921111222e>
-            BNB => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 48411237),
-            // <https://optimistic.etherscan.io/tx/0x0644f10f7ae5448240fc592ad21abf4dabac473a9d80904af5f7865f2d6509e2>
-            OPTIMISM => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 134607215),
-            // <https://polygonscan.com/tx/0xc3781c19674d97623d13afc938fca94d53583f4051020512100e84fecd230f91>
-            POLYGON => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 71296258),
-            // <https://lineascan.build/tx/0x0e20a4e0bbce2e28b89b7dcfc4dd4dfb48f5b0b8473b3b5bdeb1bf9f09943485>
-            LINEA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 24522097),
-            // <https://plasmascan.to/tx/0xda72b111ac2a7d182bf3c884373882add6f4c78f6d4bdae7efcae143be716b38>
-            PLASMA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 3521855),
-        ]))
-        .add_contract(Contract::new("CoWSwapOnchainOrders"))
-        .add_contract(Contract::new("ERC1271SignatureValidator"))
-        // Used in the gnosis/solvers repo for the balancer solver
-        .add_contract(Contract::new("BalancerQueries").with_networks(networks![
-            // <https://etherscan.io/tx/0x30799534f3a0ab8c7fa492b88b56e9354152ffaddad15415184a3926c0dd9b09>
-            MAINNET => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 15188261),
-            // <https://arbiscan.io/tx/0x710d93aab52b6c10197eab20f9d6db1af3931f9890233d8832268291ef2f54b3>
-            ARBITRUM_ONE => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 18238624),
-            // <https://optimistic.etherscan.io/tx/0xf3b2aaf3e12c7de0987dc99a26242b227b9bc055342dda2e013dab0657d6f9f1>
-            OPTIMISM => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 15288107),
-            // <https://basescan.org/tx/0x425d04ee79511c17d06cd96fe1df9e0727f7e7d46b31f36ecaa044ada6a0d29a>
-            BASE => ("0x300Ab2038EAc391f26D9F895dc61F8F66a548833", 1205869),
-            // <https://gnosisscan.io/tx/0x5beb3051d393aac24cb236dc850c644f345af65c4927030bd1033403e2f2e503>
-            GNOSIS => ("0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", 24821845),
-            // <https://polygonscan.com/tx/0x0b74f5c230f9b7df8c7a7f0d1ebd5e6c3fab51a67a9bcc8f05c350180041682e>
-            POLYGON => ("0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5", 30988035),
-            // <https://snowtrace.io/tx/0xf484e1efde47209bad5f72642bcb8d8e2a4092a5036434724ffa2d039e93a1bf?chainid=43114>
-            AVALANCHE => ("0xC128468b7Ce63eA702C1f104D55A2566b13D3ABD", 26387068),
-            // Not available on Linea, Plasma and Ink
-        ]))
-        // <https://liquorice.gitbook.io/liquorice-docs/links/smart-contracts>
-        .add_contract(
-            Contract::new("LiquoriceSettlement").with_networks(networks![
-                MAINNET => "0x0448633eb8B0A42EfED924C42069E0DcF08fb552",
-                ARBITRUM_ONE => "0x0448633eb8B0A42EfED924C42069E0DcF08fb552",
-            ]),
-        )
-        .add_contract(Contract::new("FlashLoanRouter").with_networks(networks![
-            MAINNET => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-            GNOSIS => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-            SEPOLIA => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-            ARBITRUM_ONE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-            BASE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-            POLYGON => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-            AVALANCHE => "0x9da8b48441583a2b93e2ef8213aad0ec0b392c69",
-        ]))
-        .add_contract(Contract::new("ICowWrapper"))
-        .add_contract(Contract::new("CowSettlementForwarder"))
-        .add_contract(Contract::new("ChainalysisOracle").with_networks(networks![
-            MAINNET => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
-            ARBITRUM_ONE => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
-            BASE => "0x3A91A31cB3dC49b4db9Ce721F50a9D076c8D739B",
-            AVALANCHE => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
-            BNB => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
-            OPTIMISM => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
-            POLYGON => "0x40C57923924B5c5c5455c48D93317139ADDaC8fb",
-        ]))
-        // Only used in <github.com/gnosis/solvers>
-        .add_contract(Contract::new("Permit2").with_networks(networks![
-            // <https://etherscan.io/tx/0xf2f1fe96c16ee674bb7fcee166be52465a418927d124f5f1d231b36eae65d377>
-            MAINNET => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 15986406),
-            // <https://gnosisscan.io/tx/0x3ba511410edc92cafe94bd100e25adb37981499d17947a3d64c8523fbfd31864>
-            GNOSIS => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 27338672),
-            // <https://sepolia.etherscan.io/tx/0x363df5deeead44d8fd38425f3986e3e81946a6c59d8b68fe33926cc700713173>
-            SEPOLIA => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 2356287),
-            // <https://arbiscan.io/tx/0xe244dafca8211ed6fb123efaa5075b7d5813749718412ca435c872afd0e2ea82>
-            ARBITRUM_ONE => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 38692735),
-            // <https://basescan.org/tx/0x26fbdea9a47ba8e21676bc6b6a72a19dded1a0c270e96d5236886ca9c5000d3f>
-            BASE => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 1425180),
-            // <https://snowscan.xyz/tx/0x38fd76c2165d920c7e006defd67eeeb0069bf93e41741eec3bbb83d196610a56>
-            AVALANCHE => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 28844415),
-            // <https://bscscan.com/tx/0xb038ec7b72db4207e0c0d5433e1cabc41b4e4f9b9cac577173b3188fc508a6c3>
-            BNB => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 25343783),
-            // <https://optimistic.etherscan.io/tx/0xf0a51e0d0579ef8cc7965f5797bd7665ddac14d4d2141423676b8862f7668352>
-            OPTIMISM => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 38854427),
-            // <https://polygonscan.com/tx/0xe2a4d996de0d6a23108f701b37acba6c47ee34448bb51fec5c23f542a6f3ccc8>
-            POLYGON => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 35701901),
-            // <https://plasmascan.to/tx/0x6d19057fb8b25b17fe9107be7726007d503dae50d1b0965b422fc3b512bf5dbe?chainid=9745>
-            PLASMA => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 7808),
-            // <https://explorer.inkonchain.com/address/0x000000000022D473030F116dDEE9F6B43aC78BA3> Pre Install
-            INK => ("0x000000000022D473030F116dDEE9F6B43aC78BA3", 0)
-        ]))
-        .add_contract(
-            Contract::new("GPv2AllowListAuthentication").with_networks(networks![
-                // <https://etherscan.io/tx/0xb84bf720364f94c749f1ec1cdf0d4c44c70411b716459aaccfd24fc677013375>
-                MAINNET => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 12593263),
-                // <https://gnosisscan.io/tx/0x1a2d87a05a94bc6680a4faee31bbafbd74e9ddb63dd3941c717b5c609c08b957>
-                GNOSIS => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 16465099),
-                // <https://sepolia.etherscan.io/tx/0x73c54c75b3f382304f3adf33e3876c8999fb10df786d4a902733369251033cd1>
-                SEPOLIA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 4717469),
-                // <https://arbiscan.io/tx/0xe994adff141a2e72bd9dab3eb7b3480637013bdfb1aa42c62d9d6c90de091237>
-                ARBITRUM_ONE => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 204702129),
-                // <https://basescan.org/tx/0x5497004d2a37c9eafd0bd1e5861a67d3a209c5b845724166e3dbca9527ee05ec>
-                BASE => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 21407137),
-                // <https://snowscan.xyz/tx/0xa58fc76846917779d7bcbb7d34f4a2a44aab2b702ef983594e34e6972a0c626b>
-                AVALANCHE => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 59891351),
-                // <https://bscscan.com/tx/0x8da639c62eb4a810573c178ed245184944d66c834122e3f88994ebf679b50e34>
-                BNB => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 48173639),
-                // <https://optimistic.etherscan.io/tx/0x5b6403b485e369ce524d04234807df782e6639e55a7c1d859f0a67925d9a5f49>
-                OPTIMISM => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 134254466),
-                // <https://polygonscan.com/tx/0x686e4bbcfd6ebae91f0fcc667407c831953629877ec622457916729de3d461c3>
-                POLYGON => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 45854728),
-                // <https://lineascan.build/tx/0x6e5d2c4381320efdd21ccde1534560ded1b9ab07638776833faa22820c378155>
-                LINEA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 24333100),
-                // <https://plasmascan.to/tx/0xc2ac50ad302e402c4db1e956bd357af7d84e3684ad65e4fdee58abea092ac88c>
-                PLASMA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 3439709),
-                // <https://explorer.inkonchain.com/address/0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE>
-                INK => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 34436840),
-            ]),
-        )
-        .add_contract(Contract::new("GPv2Settlement").with_networks(networks![
-            // <https://etherscan.io/tx/0xf49f90aa5a268c40001d1227b76bb4dd8247f18361fcad9fffd4a7a44f1320d3>
-            MAINNET => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 12593265),
-            // <https://blockscout.com/xdai/mainnet/tx/0x9ddc538f89cd8433f4a19bc4de0de27e7c68a1d04a14b327185e4bba9af87133>
-            GNOSIS => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 16465100),
-            // <https://sepolia.etherscan.io/tx/0x6bba22a00ffcff6bca79aced546e18d2a5a4f4e484a4e4dbafab13daf42f718d>
-            SEPOLIA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 4717488),
-            // <https://arbiscan.io/tx/0x240486f35ebf42ea69b2b3f1569d587c18c87f98c0ec997bef7d18182ca4c38c>
-            ARBITRUM_ONE => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 204704802),
-            // <https://basescan.org/tx/0x00a3c4e2dc4241465208beeba27e90a9ce3159ad4f41581c4c3a1ef02d6e37cb>
-            BASE => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 21407238),
-            // <https://snowscan.xyz/tx/0x374b84f0ea6bc554abc3ffdc3fbce4374fefc76f2bd25e324ce95a62cafcc142>
-            AVALANCHE => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 59891356),
-            // <https://bscscan.com/tx/0x9e0c16a655ceadcb95ba2de3bf59d2b3a3d10cce7bdf52aa5520164b58ffd969>
-            BNB => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 48173641),
-            // <https://optimistic.etherscan.io/tx/0xd1bbd68ee6b0eecf6f883e148284fc4fb4c960299b75004dfddd5135246cd5eb>
-            OPTIMISM => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 134254624),
-            // <https://polygonscan.com/tx/0x0e24d3a2a8530eaad5ae62e54e64d57665a77ce3970227d20c1b77da315cbbf6>
-            POLYGON => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 45859743),
-            // <https://lineascan.build/tx/0x6e5d2c4381320efdd21ccde1534560ded1b9ab07638776833faa22820c378155>
-            LINEA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 24333100),
-            // <https://plasmascan.to/tx/0xf16bd6f307dce94ab252d8dd8266ab30091879fb3d631cbcf3d0ffddf9e6ad05?chainid=9745>
-            PLASMA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 3439711),
-            // <https://explorer.inkonchain.com/address/0x9008D19f58AAbD9eD0D60971565AA8510560ab41>
-            INK => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 34436849),
-        ]))
-        // Note: the WETH address must be consistent with the one used by the ETH-flow
-        // contract
-        .add_contract(Contract::new("WETH9").with_networks(networks![
-            MAINNET => "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-            GNOSIS => "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
-            SEPOLIA => "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
-            ARBITRUM_ONE => "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-            BASE => "0x4200000000000000000000000000000000000006",
-            AVALANCHE => "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
-            BNB => "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
-            OPTIMISM => "0x4200000000000000000000000000000000000006",
-            POLYGON => "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-            LINEA => "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
-            PLASMA => "0x6100E367285b01F48D07953803A2d8dCA5D19873",
-            INK => "0x4200000000000000000000000000000000000006",
-        ]))
-        .add_submodule(
-            Submodule::new("cow_amm")
-                .add_contract(Contract::new("CowAmm"))
-                .add_contract(Contract::new("CowAmmConstantProductFactory").with_networks(
-                    networks![
-                        // <https://etherscan.io/tx/0xf37fc438ddacb00c28305bd7dea3b79091cd5be3405a2b445717d9faf946fa50>
-                        MAINNET => ("0x40664207e3375FB4b733d4743CE9b159331fd034", 19861952),
-                        // <https://gnosisscan.io/tx/0x4121efab4ad58ae7ad73b50448cccae0de92905e181648e5e08de3d6d9c66083>
-                        GNOSIS => ("0xdb1cba3a87f2db53b6e1e6af48e28ed877592ec0", 33874317),
-                        // <https://sepolia.etherscan.io/tx/0x5e6af00c670eb421b96e78fd2e3b9df573b19e6e0ea77d8003e47cdde384b048>
-                        SEPOLIA => ("0xb808e8183e3a72d196457d127c7fd4befa0d7fd3", 5874562),
-                    ],
-                ))
-                .add_contract(Contract::new("CowAmmLegacyHelper").with_networks(networks![
-                    // <https://etherscan.io/tx/0x07f0ce50fb9cd30e69799a63ae9100869a3c653d62ea3ba49d2e5e1282f42b63>
-                    MAINNET => ("0x3705ceee5eaa561e3157cf92641ce28c45a3999c", 20332745),
-                    // <https://gnosisscan.io/tx/0x09e56c7173ab1e1c5d02bc2832799422ebca6d9a40e5bae77f6ca908696bfebf>
-                    GNOSIS => ("0xd9ec06b001957498ab1bc716145515d1d0e30ffb", 35026999),
-                ]))
-                .add_contract(Contract::new("CowAmmUniswapV2PriceOracle"))
-                .add_contract(Contract::new("CowAmmFactoryGetter")),
-        )
-        .add_submodule(
-            Submodule::new("test") // Test Contract for using up a specified amount of gas.
-                .add_contract(Contract::new("GasHog"))
-                // Test Contract for incrementing arbitrary counters.
-                .add_contract(Contract::new("Counter"))
-                // Token with support for `permit` (for pre-interaction tests)
-                .add_contract(Contract::new("CowProtocolToken").with_networks(networks![
-                    MAINNET => "0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB",
-                    GNOSIS => "0x177127622c4A00F3d409B75571e12cB3c8973d3c",
-                    SEPOLIA => "0x0625aFB445C3B6B7B929342a04A22599fd5dBB59",
-                    ARBITRUM_ONE => "0xcb8b5CD20BdCaea9a010aC1F8d835824F5C87A04",
-                    BASE => "0xc694a91e6b071bF030A18BD3053A7fE09B6DaE69",
-                ]))
-                // Test Contract with non-standard ERC20 balance storage
-                .add_contract(Contract::new("NonStandardERC20Balances"))
-                // Test Contract which selectively pulls balance storage from another target
-                .add_contract(Contract::new("RemoteERC20Balances")),
-        )
-        .add_submodule(
-            Submodule::new("support") // support module
-                // Support contracts used for trade and token simulations.
-                .add_contract(Contract::new("AnyoneAuthenticator"))
-                .add_contract(Contract::new("Solver"))
-                .add_contract(Contract::new("Spardose"))
-                .add_contract(Contract::new("Trader"))
-                // Support contract used for solver fee simulations in the gnosis/solvers repo.
-                .add_contract(Contract::new("Swapper"))
-                .add_contract(Contract::new("Signatures").with_networks(networks![
-                    MAINNET => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    ARBITRUM_ONE => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    BASE => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    AVALANCHE => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    BNB => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    OPTIMISM => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    POLYGON => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    GNOSIS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    SEPOLIA => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    // built with evm=London, because deployment reverts on Linea otherwise
-                    LINEA => "0xf6E57e72F7dB3D9A51a8B4c149C00475b94A37e4",
-                    PLASMA => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    INK => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                ]))
-                // Support contracts used for various order simulations.
-                .add_contract(Contract::new("Balances").with_networks(networks![
-                    MAINNET => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    ARBITRUM_ONE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    BASE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    AVALANCHE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    BNB => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    OPTIMISM => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    POLYGON => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    GNOSIS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    SEPOLIA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    PLASMA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    // built with evm=London, because deployment reverts on Linea otherwise
-                    LINEA => "0x361350f708f7c0c63c8a505226592c3e5d1faa29",
-                    INK => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                ])),
-        )
-        .write_formatted(Path::new("artifacts"), true, vendored_bindings)
-        .unwrap();
-}
-
-// Codegen implementation starts here
-
-const MOD_HEADER: &str = r#"#![allow(unused_imports, unused_attributes, clippy::all, rustdoc::all, non_snake_case)]
-    //! This module contains the sol! generated bindings for solidity contracts.
-    //! This is autogenerated code.
-    //! Do not manually edit these files.
-    //! These files may be overwritten by the codegen system at any time.
-    "#;
-
-#[derive(Default)]
-pub struct Module {
-    pub contracts: Vec<Contract>,
-    submodules: Vec<Submodule>,
-}
-
-impl Module {
-    pub fn add_contract(mut self, contract: Contract) -> Self {
-        self.contracts.push(contract);
-        self
-    }
-
-    pub fn add_submodule(mut self, module: Submodule) -> Self {
-        self.submodules.push(module);
-        self
-    }
-
-    pub fn write_formatted<P1, P2>(
-        self,
-        bindings_folder: P1,
-        all_derives: bool,
-        output_folder: P2,
-    ) -> anyhow::Result<()>
-    where
-        P1: AsRef<Path>,
-        P2: AsRef<Path>,
-    {
-        std::fs::create_dir_all(&output_folder)?;
-
-        let mut mod_file = String::from(MOD_HEADER);
-        for submodule in self.submodules {
-            write_mod_name(&mut mod_file, &submodule.name)?;
-            submodule.write_formatted(bindings_folder.as_ref(), all_derives, &output_folder)?;
-        }
-
-        for contract in self.contracts {
-            let name = contract.name.clone();
-            contract.write_formatted(bindings_folder.as_ref(), all_derives, &output_folder)?;
-            write_mod_name(&mut mod_file, &name).context(name)?;
-        }
-
-        let file: syn::File = syn::parse_file(&mod_file)?;
-        let formatted = prettyplease::unparse(&file);
-        std::fs::write(output_folder.as_ref().join("mod.rs"), formatted)?;
-
-        Ok(())
-    }
-}
-
-pub struct Submodule {
-    pub name: String,
-    pub contracts: Vec<Contract>,
-    submodules: Vec<Submodule>,
-}
-
-impl Submodule {
-    pub fn new<S: ToString>(name: S) -> Self {
-        Self {
-            name: name.to_string(),
-            contracts: vec![],
-            submodules: vec![],
-        }
-    }
-
-    pub fn add_contract(mut self, contract: Contract) -> Self {
-        self.contracts.push(contract);
-        self
-    }
-
-    pub fn add_submodule(mut self, module: Submodule) -> Self {
-        self.submodules.push(module);
-        self
-    }
-
-    pub fn write_formatted<P1, P2>(
-        self,
-        bindings_folder: P1,
-        all_derives: bool,
-        output_folder: P2,
-    ) -> anyhow::Result<()>
-    where
-        P1: AsRef<Path>,
-        P2: AsRef<Path>,
-    {
-        let output_folder = output_folder.as_ref().join(self.name);
-        std::fs::create_dir_all(&output_folder)?;
-
-        let mut mod_file = String::from(MOD_HEADER);
-        for submodule in self.submodules {
-            write_mod_name(&mut mod_file, &submodule.name)?;
-            submodule.write_formatted(bindings_folder.as_ref(), all_derives, &output_folder)?;
-        }
-
-        for contract in self.contracts {
-            let name = contract.name.clone();
-            contract.write_formatted(bindings_folder.as_ref(), all_derives, &output_folder)?;
-            write_mod_name(&mut mod_file, &name)?;
-        }
-
-        let file: syn::File = syn::parse_file(&mod_file)?;
-        let formatted = prettyplease::unparse(&file);
-        std::fs::write(output_folder.join("mod.rs"), formatted)?;
-
-        Ok(())
-    }
-}
-
-pub struct Contract {
-    pub name: String,
-    networks: HashMap<u64, (String, Option<u64>)>,
-}
-
-impl Contract {
-    pub fn new<S: AsRef<str>>(name: S) -> Self {
-        Self {
-            name: name.as_ref().to_string(),
-            networks: HashMap::new(),
-        }
-    }
-
-    pub fn with_networks<S, I>(mut self, networks: I) -> Self
-    where
-        S: AsRef<str>,
-        I: IntoIterator<Item = (u64, (S, Option<u64>))>,
-    {
-        for (id, (address, block_number)) in networks.into_iter() {
-            self.networks
-                .insert(id, (address.as_ref().to_string(), block_number));
-        }
-        self
-    }
-
-    fn bindings_path(&self, bindings_folder: &Path) -> PathBuf {
-        bindings_folder.join(&self.name).with_extension("json")
-    }
-
-    pub fn generate<P: AsRef<Path>>(
-        self,
-        bindings_folder: P,
-        all_derives: bool,
-    ) -> anyhow::Result<proc_macro2::TokenStream> {
-        let bindings_path = self.bindings_path(bindings_folder.as_ref());
-        let mut macrogen = SolMacroGen::new(bindings_path, self.name.clone());
-        generate_binding(&mut macrogen, all_derives)?;
-        let mut expansion = macrogen
-            .expansion
-            .expect("if the expansion failed, it should have errored earlier");
-
-        let module_name_ident = format_ident!("{}", self.name);
-        let instance_name_ident = format_ident!("{}Instance", self.name);
-        let instance = quote::quote! {
-            pub type Instance = #module_name_ident :: #instance_name_ident<::alloy_provider::DynProvider>;
-        };
-        expansion.extend(instance);
-
-        let no_networks = self.networks.is_empty();
-        let networks = self.networks.into_iter().map(NetworkArm::from);
-        let deployment_info = if no_networks {
-            proc_macro2::TokenStream::new()
-        } else {
-            quote::quote! {
-                use {
-                    std::{
-                        sync::LazyLock,
-                        collections::HashMap
-                    },
-                    anyhow::{Result, Context},
-                    alloy_provider::{Provider, DynProvider},
-                    alloy_primitives::{address, Address},
-                };
-
-                pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
-                    match chain_id {
-                        #( #networks ,)*
-                        _ => None
-                    }
-                }
-
-                /// Returns the contract's deployment address (if one exists) for the given chain.
-                pub const fn deployment_address(chain_id: &u64) -> Option<alloy_primitives::Address> {
-                    match deployment_info(*chain_id) {
-                        Some((address, _)) => Some(address),
-                        None => None,
-                    }
-                }
-
-                /// Returns the contract's deployment block (if one exists) for the given chain.
-                pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
-                    match deployment_info(*chain_id) {
-                        Some((_, block)) => block,
-                        None => None,
-                    }
-                }
-
-                impl Instance {
-                    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
-                        async move {
-                            let chain_id = provider
-                                .get_chain_id()
-                                .await
-                                .context("could not fetch current chain id")?;
-
-                            let (address, _deployed_block) = deployment_info(chain_id)
-                                .with_context(|| format!("no deployment info for chain {chain_id:?}"))?;
-
-                            Ok(Instance::new(
-                                address,
-                                provider.clone(),
-                            ))
-                        }
-                    }
-                }
-            }
-        };
-        expansion.extend(deployment_info);
-
-        Ok(expansion)
-    }
-
-    pub fn write_formatted<P1, P2>(
-        self,
-        bindings_folder: P1,
-        all_derives: bool,
-        output_folder: P2,
-    ) -> anyhow::Result<()>
-    where
-        P1: AsRef<Path>,
-        P2: AsRef<Path>,
-    {
-        let name = self.name.clone();
-        let token_stream = self.generate(bindings_folder, all_derives)?;
-        let mut buffer = String::new();
-        write!(buffer, "{}", token_stream)?;
-        let file: syn::File = syn::parse_file(&buffer)?;
-        let formatted = prettyplease::unparse(&file);
-        std::fs::write(
-            output_folder.as_ref().join(name).with_extension("rs"),
-            formatted,
-        )?;
-        Ok(())
-    }
-}
-
-fn generate_binding(instance: &mut SolMacroGen, all_derives: bool) -> anyhow::Result<()> {
-    let input = instance
-        .get_sol_input()
-        .map_err(|err| anyhow::anyhow!("{:?}", err))?
-        .normalize_json()
-        .map_err(|err| anyhow::anyhow!("{:?}", err))?;
-    let SolInput {
-        attrs: _,
-        path: _,
-        kind,
-    } = input;
-
-    let tokens = match kind {
-        SolInputKind::Sol(mut file) => {
-            let sol_attr: syn::Attribute = if all_derives {
-                syn::parse_quote! {
-                    #[sol(
-                        rpc,
-                        all_derives = true,
-                        extra_derives(serde::Serialize,
-                        serde::Deserialize)
-                    )]
-                }
-            } else {
-                syn::parse_quote! { #[sol(rpc)] }
-            };
-            file.attrs.push(sol_attr);
-            expand(file)?
-        }
-        _ => unreachable!(),
-    };
-
-    instance.expansion = Some(tokens);
-    Ok(())
-}
-
-fn write_mod_name(contents: &mut String, name: &str) -> anyhow::Result<()> {
-    if syn::parse_str::<syn::ItemMod>(&format!("pub mod {name};")).is_ok() {
-        write!(contents, "pub mod {name};")?;
-    } else {
-        write!(contents, "pub mod r#{name};")?;
-    }
-    Ok(())
-}
-
-/// Wrapper to avoid destructuring the vector of tuples into three iterators.
-///
-/// The following code:
-/// ```ignore
-/// // We need to "destructure" the iterator into several due to
-/// let chain_ids = self.networks.iter().map(|n| n.0);
-/// let addresses = self.networks.iter().map(|n| n.1.0.clone());
-/// let blocks = self.networks.iter().map(|n| match n.1.1 {
-///     Some(block) => quote::quote! {Some (#block)},
-///     None => quote::quote! {None},
-/// });
-/// // ...
-/// quote::quote! {
-///     pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
-///         match chain_id {
-///             #(#chain_id => Some((alloy_primitives::address!(#address), #block_number)),)*
-///             _ => None
-///         }
-///     }
-/// }
-/// ```
-///
-/// Becomes:
-/// ```ignore
-/// let networks = self.networks.into_iter().map(NetworkArm::from);
-/// // ...
-/// quote::quote! {
-///     pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
-///         match chain_id {
-///             #( #networks ,)*
-///             _ => None
-///         }
-///     }
-/// }
-/// ```
-struct NetworkArm(u64, (String, Option<u64>));
-
-impl ToTokens for NetworkArm {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let chain_id = self.0;
-        let address = &self.1.0;
-        let block_number = match self.1.1 {
-            Some(block) => quote::quote! {Some (#block)},
-            None => quote::quote! {None},
-        };
-        tokens.extend(quote::quote! {
-           #chain_id => Some((alloy_primitives::address!(#address), #block_number))
-        });
-    }
-}
-
-impl From<(u64, (String, Option<u64>))> for NetworkArm {
-    fn from((chain_id, info): (u64, (String, Option<u64>))) -> Self {
-        Self(chain_id, info)
-    }
-}
-
-/// SolMacroGen implementation vendored from
-/// <https://github.com/foundry-rs/foundry/blob/cc24b6b74978e72b7330ad7d4b39140e9ee33deb/crates/sol-macro-gen/src/sol_macro_gen.rs>
-/// to avoid depending on forge-sol-macro-gen.
-pub struct SolMacroGen {
-    pub path: PathBuf,
-    pub name: String,
-    pub expansion: Option<TokenStream>,
-}
-
-impl SolMacroGen {
-    pub fn new(path: PathBuf, name: String) -> Self {
-        Self {
-            path,
-            name,
-            expansion: None,
-        }
-    }
-
-    pub fn get_sol_input(&self) -> Result<SolInput> {
-        let path = self.path.to_string_lossy().into_owned();
-        let name = proc_macro2::Ident::new(&self.name, Span::call_site());
-        let tokens = quote::quote! {
-            #[sol(ignore_unlinked)]
-            #name,
-            #path
-        };
-
-        let sol_input: SolInput = syn::parse2(tokens).context("failed to parse input")?;
-
-        Ok(sol_input)
-    }
-}
diff --git a/crates/contracts/rustfmt.toml b/crates/contracts/rustfmt.toml
deleted file mode 100644
index 0cf3970aa7..0000000000
--- a/crates/contracts/rustfmt.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-# Applying our custom formatting to the generated code is broken.
-# That's why we specifically unset those rules for this directory.
diff --git a/crates/contracts/src/lib.rs b/crates/contracts/src/lib.rs
deleted file mode 100644
index 01f758308e..0000000000
--- a/crates/contracts/src/lib.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![allow(clippy::let_unit_value)]
-
-// This module get's auto-generated by the contracts build.rs
-#[rustfmt::skip]
-pub mod alloy;
diff --git a/crates/cow-amm/src/amm.rs b/crates/cow-amm/src/amm.rs
index 32c2b88129..738ada502c 100644
--- a/crates/cow-amm/src/amm.rs
+++ b/crates/cow-amm/src/amm.rs
@@ -2,10 +2,7 @@ use {
     alloy_primitives::{Address, TxHash, U256},
     anyhow::{Context, Result},
     app_data::AppDataHash,
-    contracts::alloy::cow_amm::{
-        CowAmmLegacyHelper,
-        CowAmmLegacyHelper::CowAmmLegacyHelper::orderReturn,
-    },
+    contracts::cow_amm::{CowAmmLegacyHelper, CowAmmLegacyHelper::CowAmmLegacyHelper::orderReturn},
     database::byte_array::ByteArray,
     model::{
         DomainSeparator,
diff --git a/crates/cow-amm/src/cache.rs b/crates/cow-amm/src/cache.rs
index 3b2eb064c3..87d111be09 100644
--- a/crates/cow-amm/src/cache.rs
+++ b/crates/cow-amm/src/cache.rs
@@ -3,7 +3,7 @@ use {
     alloy_primitives::Address,
     alloy_rpc_types::Log,
     anyhow::Context,
-    contracts::alloy::cow_amm::{
+    contracts::cow_amm::{
         CowAmmLegacyHelper,
         CowAmmLegacyHelper::CowAmmLegacyHelper::CowAmmLegacyHelperEvents as CowAmmEvent,
     },
diff --git a/crates/cow-amm/src/factory.rs b/crates/cow-amm/src/factory.rs
index 306de409b6..ee506217b4 100644
--- a/crates/cow-amm/src/factory.rs
+++ b/crates/cow-amm/src/factory.rs
@@ -3,7 +3,7 @@ use {
     alloy_provider::DynProvider,
     alloy_rpc_types::{Filter, FilterSet},
     alloy_sol_types::SolEvent,
-    contracts::alloy::cow_amm::CowAmmLegacyHelper::CowAmmLegacyHelper::{
+    contracts::cow_amm::CowAmmLegacyHelper::CowAmmLegacyHelper::{
         self,
         CowAmmLegacyHelperEvents as CowAmmEvent,
     },
diff --git a/crates/cow-amm/src/lib.rs b/crates/cow-amm/src/lib.rs
index f157c28009..9aa1cd3c4d 100644
--- a/crates/cow-amm/src/lib.rs
+++ b/crates/cow-amm/src/lib.rs
@@ -6,7 +6,7 @@ mod registry;
 
 pub use {
     amm::Amm,
-    contracts::alloy::cow_amm::CowAmmLegacyHelper::Instance as Helper,
+    contracts::cow_amm::CowAmmLegacyHelper::Instance as Helper,
     registry::Registry,
 };
 
@@ -34,7 +34,7 @@ pub mod gpv2_order {
     use {
         alloy_primitives::{Address, B256, Keccak256},
         alloy_sol_types::{SolStruct, SolValue},
-        contracts::alloy::cow_amm::CowAmm,
+        contracts::cow_amm::CowAmm,
         model::{DomainSeparator, interaction::InteractionData, signature::hashed_eip712_message},
     };
 
diff --git a/crates/cow-amm/src/maintainers.rs b/crates/cow-amm/src/maintainers.rs
index 7a8852d903..12431db15f 100644
--- a/crates/cow-amm/src/maintainers.rs
+++ b/crates/cow-amm/src/maintainers.rs
@@ -1,6 +1,6 @@
 use {
     crate::{Amm, cache::Storage},
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     ethrpc::AlloyProvider,
     event_indexing::maintenance::Maintaining,
     futures::{
diff --git a/crates/cow-amm/src/registry.rs b/crates/cow-amm/src/registry.rs
index 7a1d329322..343906e08b 100644
--- a/crates/cow-amm/src/registry.rs
+++ b/crates/cow-amm/src/registry.rs
@@ -1,7 +1,7 @@
 use {
     crate::{Amm, cache::Storage, factory::Factory, maintainers::EmptyPoolRemoval},
     alloy_primitives::Address,
-    contracts::alloy::cow_amm::CowAmmLegacyHelper,
+    contracts::cow_amm::CowAmmLegacyHelper,
     ethrpc::{AlloyProvider, block_stream::CurrentBlockWatcher},
     event_indexing::{
         block_retriever::BlockRetriever,
diff --git a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
index f641c1ca5f..350a687555 100644
--- a/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
+++ b/crates/driver/src/boundary/liquidity/balancer/v2/mod.rs
@@ -8,7 +8,7 @@ use {
         infra::{self, blockchain::Ethereum},
     },
     anyhow::{Context, Result},
-    contracts::alloy::{
+    contracts::{
         BalancerV2ComposableStablePoolFactory,
         BalancerV2LiquidityBootstrappingPoolFactory,
         BalancerV2StablePoolFactoryV2,
diff --git a/crates/driver/src/boundary/liquidity/uniswap/v2.rs b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
index ab7e32a88b..70deaf9bcf 100644
--- a/crates/driver/src/boundary/liquidity/uniswap/v2.rs
+++ b/crates/driver/src/boundary/liquidity/uniswap/v2.rs
@@ -7,7 +7,7 @@ use {
         },
         infra::{self, blockchain::Ethereum},
     },
-    contracts::alloy::IUniswapLikeRouter,
+    contracts::IUniswapLikeRouter,
     eth_domain_types as eth,
     ethrpc::{Web3, block_stream::CurrentBlockWatcher},
     liquidity_sources::uniswap_v2::{
diff --git a/crates/driver/src/boundary/liquidity/zeroex.rs b/crates/driver/src/boundary/liquidity/zeroex.rs
index 7e4e449547..257ccaf2af 100644
--- a/crates/driver/src/boundary/liquidity/zeroex.rs
+++ b/crates/driver/src/boundary/liquidity/zeroex.rs
@@ -85,7 +85,7 @@ pub async fn collector(
     let eth = eth.with_metric_label("zeroex".into());
     let settlement = *eth.contracts().settlement().address();
     let web3 = eth.web3().clone();
-    let contract = contracts::alloy::IZeroex::Instance::deployed(&web3.provider).await?;
+    let contract = contracts::IZeroex::Instance::deployed(&web3.provider).await?;
     let http_client_factory = &HttpClientFactory::new(&configs::http_client::HttpClient {
         timeout: config.http_timeout,
     });
diff --git a/crates/driver/src/domain/competition/solution/encoding.rs b/crates/driver/src/domain/competition/solution/encoding.rs
index f656c06113..ea55b103af 100644
--- a/crates/driver/src/domain/competition/solution/encoding.rs
+++ b/crates/driver/src/domain/competition/solution/encoding.rs
@@ -13,7 +13,7 @@ use {
     },
     allowance::Allowance,
     alloy::primitives::{Address, Bytes, FixedBytes, U256},
-    contracts::alloy::{FlashLoanRouter::LoanRequest, WETH9},
+    contracts::{FlashLoanRouter::LoanRequest, WETH9},
     eth_domain_types::{self as eth, Ether, allowance},
     itertools::Itertools,
     num::Zero,
@@ -370,7 +370,7 @@ pub mod codec {
     use {
         crate::domain::{self, competition::order},
         alloy::primitives::{Bytes, U256},
-        contracts::alloy::GPv2Settlement,
+        contracts::GPv2Settlement,
         eth_domain_types as eth,
     };
 
diff --git a/crates/driver/src/domain/cow_amm.rs b/crates/driver/src/domain/cow_amm.rs
index adca1186cf..9b9cd8688c 100644
--- a/crates/driver/src/domain/cow_amm.rs
+++ b/crates/driver/src/domain/cow_amm.rs
@@ -1,6 +1,6 @@
 use {
     alloy::{primitives::Address, providers::DynProvider},
-    contracts::alloy::cow_amm::CowAmmLegacyHelper,
+    contracts::cow_amm::CowAmmLegacyHelper,
     cow_amm::Amm,
     eth_domain_types as eth,
     itertools::{
@@ -124,11 +124,10 @@ impl Cache {
     /// Fetches the factory address for the given AMM by calling the
     /// `FACTORY` function.
     async fn fetch_amm_factory_address(&self, amm_address: Address) -> anyhow::Result<Address> {
-        let factory_getter =
-            contracts::alloy::cow_amm::CowAmmFactoryGetter::CowAmmFactoryGetter::new(
-                amm_address,
-                self.web3.clone(),
-            );
+        let factory_getter = contracts::cow_amm::CowAmmFactoryGetter::CowAmmFactoryGetter::new(
+            amm_address,
+            self.web3.clone(),
+        );
         Ok(factory_getter.FACTORY().call().await?)
     }
 }
diff --git a/crates/driver/src/domain/liquidity/zeroex.rs b/crates/driver/src/domain/liquidity/zeroex.rs
index ff112eabd7..cae4192b49 100644
--- a/crates/driver/src/domain/liquidity/zeroex.rs
+++ b/crates/driver/src/domain/liquidity/zeroex.rs
@@ -2,7 +2,7 @@ use {
     crate::domain::{self, liquidity},
     alloy::primitives::{Address, B256, U256},
     anyhow::anyhow,
-    contracts::alloy::IZeroex,
+    contracts::IZeroex,
     std::sync::Arc,
 };
 
diff --git a/crates/driver/src/domain/mempools.rs b/crates/driver/src/domain/mempools.rs
index 7a83ea4160..452e5bf00e 100644
--- a/crates/driver/src/domain/mempools.rs
+++ b/crates/driver/src/domain/mempools.rs
@@ -6,7 +6,7 @@ use {
     },
     alloy::{consensus::Transaction, eips::eip1559::Eip1559Estimation, sol_types::SolCall},
     anyhow::Context,
-    contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
+    contracts::CowSettlementForwarder::CowSettlementForwarder,
     eth_domain_types::{self as eth, BlockNo, TxId},
     ethrpc::block_stream::into_stream,
     futures::{FutureExt, StreamExt, future::select_ok},
diff --git a/crates/driver/src/infra/blockchain/contracts.rs b/crates/driver/src/infra/blockchain/contracts.rs
index a5f58e3960..c2f937f818 100644
--- a/crates/driver/src/infra/blockchain/contracts.rs
+++ b/crates/driver/src/infra/blockchain/contracts.rs
@@ -1,12 +1,6 @@
 use {
     chain::Chain,
-    contracts::alloy::{
-        BalancerV2Vault,
-        FlashLoanRouter,
-        GPv2Settlement,
-        WETH9,
-        support::Balances,
-    },
+    contracts::{BalancerV2Vault, FlashLoanRouter, GPv2Settlement, WETH9, support::Balances},
     eth_domain_types as eth,
     ethrpc::Web3,
     std::collections::HashMap,
@@ -17,7 +11,7 @@ pub struct Contracts {
     settlement: GPv2Settlement::Instance,
     vault_relayer: eth::ContractAddress,
     vault: BalancerV2Vault::Instance,
-    signatures: contracts::alloy::support::Signatures::Instance,
+    signatures: contracts::support::Signatures::Instance,
     weth: WETH9::Instance,
 
     /// The domain separator for settlement contract used for signing orders.
@@ -70,11 +64,11 @@ impl Contracts {
                 .unwrap(),
             web3.provider.clone(),
         );
-        let signatures = contracts::alloy::support::Signatures::Instance::new(
+        let signatures = contracts::support::Signatures::Instance::new(
             addresses
                 .signatures
                 .map(Into::into)
-                .or_else(|| contracts::alloy::support::Signatures::deployment_address(&chain.id()))
+                .or_else(|| contracts::support::Signatures::deployment_address(&chain.id()))
                 .unwrap(),
             web3.provider.clone(),
         );
@@ -123,7 +117,7 @@ impl Contracts {
         &self.settlement
     }
 
-    pub fn signatures(&self) -> &contracts::alloy::support::Signatures::Instance {
+    pub fn signatures(&self) -> &contracts::support::Signatures::Instance {
         &self.signatures
     }
 
diff --git a/crates/driver/src/infra/blockchain/token.rs b/crates/driver/src/infra/blockchain/token.rs
index e95af850ef..2aeb7dbcdd 100644
--- a/crates/driver/src/infra/blockchain/token.rs
+++ b/crates/driver/src/infra/blockchain/token.rs
@@ -8,13 +8,13 @@ use {
 ///
 /// https://eips.ethereum.org/EIPS/eip-20
 pub struct Erc20 {
-    token: contracts::alloy::ERC20::Instance,
+    token: contracts::ERC20::Instance,
 }
 
 impl Erc20 {
     pub(super) fn new(eth: &Ethereum, address: eth::TokenAddress) -> Self {
         Self {
-            token: contracts::alloy::ERC20::Instance::new(*address, eth.web3.provider.clone()),
+            token: contracts::ERC20::Instance::new(*address, eth.web3.provider.clone()),
         }
     }
 
diff --git a/crates/driver/src/infra/liquidity/config.rs b/crates/driver/src/infra/liquidity/config.rs
index 4540268a01..ef05baa2a1 100644
--- a/crates/driver/src/infra/liquidity/config.rs
+++ b/crates/driver/src/infra/liquidity/config.rs
@@ -2,7 +2,7 @@ use {
     crate::domain::blockchain::CodeDigest,
     alloy::primitives::Address,
     chain::Chain,
-    contracts::alloy::BalancerV2Vault,
+    contracts::BalancerV2Vault,
     derive_more::Debug,
     eth_domain_types::{self as eth, ContractAddress},
     hex_literal::hex,
@@ -63,7 +63,7 @@ impl UniswapV2 {
     #[expect(clippy::self_named_constructors)]
     pub fn uniswap_v2(chain: Chain) -> Option<Self> {
         Some(Self {
-            router: ContractAddress::from(contracts::alloy::UniswapV2Router02::deployment_address(
+            router: ContractAddress::from(contracts::UniswapV2Router02::deployment_address(
                 &chain.id(),
             )?),
             pool_code: UNISWAP_INIT.into(),
@@ -74,7 +74,7 @@ impl UniswapV2 {
     /// Returns the liquidity configuration for SushiSwap.
     pub fn sushi_swap(chain: Chain) -> Option<Self> {
         Some(Self {
-            router: ContractAddress::from(contracts::alloy::SushiSwapRouter::deployment_address(
+            router: ContractAddress::from(contracts::SushiSwapRouter::deployment_address(
                 &chain.id(),
             )?),
             pool_code: SUSHISWAP_INIT.into(),
@@ -85,7 +85,7 @@ impl UniswapV2 {
     /// Returns the liquidity configuration for Honeyswap.
     pub fn honeyswap(chain: Chain) -> Option<Self> {
         Some(Self {
-            router: ContractAddress::from(contracts::alloy::BaoswapRouter::deployment_address(
+            router: ContractAddress::from(contracts::BaoswapRouter::deployment_address(
                 &chain.id(),
             )?),
             pool_code: HONEYSWAP_INIT.into(),
@@ -96,7 +96,7 @@ impl UniswapV2 {
     /// Returns the liquidity configuration for Baoswap.
     pub fn baoswap(chain: Chain) -> Option<Self> {
         Some(Self {
-            router: ContractAddress::from(contracts::alloy::BaoswapRouter::deployment_address(
+            router: ContractAddress::from(contracts::BaoswapRouter::deployment_address(
                 &chain.id(),
             )?),
             pool_code: BAOSWAP_INIT.into(),
@@ -112,7 +112,7 @@ impl UniswapV2 {
         }
         .into();
         Some(Self {
-            router: ContractAddress::from(contracts::alloy::PancakeRouter::deployment_address(
+            router: ContractAddress::from(contracts::PancakeRouter::deployment_address(
                 &chain.id(),
             )?),
             pool_code,
@@ -124,9 +124,9 @@ impl UniswapV2 {
     /// test networks.
     pub fn testnet_uniswapv2(chain: Chain) -> Option<Self> {
         Some(Self {
-            router: ContractAddress::from(
-                contracts::alloy::TestnetUniswapV2Router02::deployment_address(&chain.id())?,
-            ),
+            router: ContractAddress::from(contracts::TestnetUniswapV2Router02::deployment_address(
+                &chain.id(),
+            )?),
             pool_code: TESTNET_UNISWAP_INIT.into(),
             missing_pool_cache_time: Duration::from_secs(60 * 60),
         })
@@ -151,9 +151,7 @@ impl Swapr {
     #[expect(clippy::self_named_constructors)]
     pub fn swapr(chain: Chain) -> Option<Self> {
         Some(Self {
-            router: ContractAddress::from(contracts::alloy::SwaprRouter::deployment_address(
-                &chain.id(),
-            )?),
+            router: ContractAddress::from(contracts::SwaprRouter::deployment_address(&chain.id())?),
             pool_code: SWAPR_INIT.into(),
             missing_pool_cache_time: Duration::from_secs(60 * 60),
         })
@@ -191,8 +189,7 @@ impl UniswapV3 {
         max_pools_per_tick_query: usize,
     ) -> Option<Self> {
         Some(Self {
-            router: contracts::alloy::UniswapV3SwapRouterV2::deployment_address(&chain.id())?
-                .into(),
+            router: contracts::UniswapV3SwapRouterV2::deployment_address(&chain.id())?.into(),
             max_pools_to_initialize: 100,
             graph_url: graph_url.clone(),
             reinit_interval: None,
@@ -257,33 +254,33 @@ impl BalancerV2 {
             weighted: address_for!(
                 chain,
                 [
-                    contracts::alloy::BalancerV2WeightedPoolFactory,
-                    contracts::alloy::BalancerV2WeightedPool2TokensFactory,
+                    contracts::BalancerV2WeightedPoolFactory,
+                    contracts::BalancerV2WeightedPool2TokensFactory,
                 ]
             ),
             weighted_v3plus: address_for!(
                 chain,
                 [
-                    contracts::alloy::BalancerV2WeightedPoolFactoryV3,
-                    contracts::alloy::BalancerV2WeightedPoolFactoryV4,
+                    contracts::BalancerV2WeightedPoolFactoryV3,
+                    contracts::BalancerV2WeightedPoolFactoryV4,
                 ]
             ),
-            stable: address_for!(chain, [contracts::alloy::BalancerV2StablePoolFactoryV2,]),
+            stable: address_for!(chain, [contracts::BalancerV2StablePoolFactoryV2,]),
             liquidity_bootstrapping: address_for!(
                 chain,
                 [
-                    contracts::alloy::BalancerV2LiquidityBootstrappingPoolFactory,
-                    contracts::alloy::BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory,
+                    contracts::BalancerV2LiquidityBootstrappingPoolFactory,
+                    contracts::BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory,
                 ]
             ),
             composable_stable: address_for!(
                 chain,
                 [
-                    contracts::alloy::BalancerV2ComposableStablePoolFactory,
-                    contracts::alloy::BalancerV2ComposableStablePoolFactoryV3,
-                    contracts::alloy::BalancerV2ComposableStablePoolFactoryV4,
-                    contracts::alloy::BalancerV2ComposableStablePoolFactoryV5,
-                    contracts::alloy::BalancerV2ComposableStablePoolFactoryV6,
+                    contracts::BalancerV2ComposableStablePoolFactory,
+                    contracts::BalancerV2ComposableStablePoolFactoryV3,
+                    contracts::BalancerV2ComposableStablePoolFactoryV4,
+                    contracts::BalancerV2ComposableStablePoolFactoryV5,
+                    contracts::BalancerV2ComposableStablePoolFactoryV6,
                 ]
             ),
             pool_deny_list: Vec::new(),
diff --git a/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs b/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
index 53de34df80..182c384e00 100644
--- a/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
+++ b/crates/driver/src/infra/notify/liquidity_sources/liquorice/notifier.rs
@@ -20,7 +20,7 @@ use {
     alloy::primitives::Address,
     anyhow::{Context, Result, anyhow},
     chrono::Utc,
-    contracts::alloy::LiquoriceSettlement,
+    contracts::LiquoriceSettlement,
 };
 
 const NOTIFICATION_SOURCE: &str = "cow_protocol";
@@ -89,7 +89,7 @@ mod utils {
             competition::solution::{self, Settlement},
         },
         alloy::{primitives::Address, sol_types::SolCall},
-        contracts::alloy::LiquoriceSettlement,
+        contracts::LiquoriceSettlement,
         std::collections::HashSet,
     };
 
diff --git a/crates/driver/src/infra/solver/eip7702.rs b/crates/driver/src/infra/solver/eip7702.rs
index a6fa8771f5..b0e195a7dd 100644
--- a/crates/driver/src/infra/solver/eip7702.rs
+++ b/crates/driver/src/infra/solver/eip7702.rs
@@ -10,7 +10,7 @@ use {
         sol_types::SolCall,
     },
     anyhow::Context,
-    contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
+    contracts::CowSettlementForwarder::CowSettlementForwarder,
     futures::future::try_join_all,
     std::time::Duration,
     tracing::instrument,
diff --git a/crates/driver/src/tests/setup/blockchain.rs b/crates/driver/src/tests/setup/blockchain.rs
index 60b5e8a049..c90e6f20f2 100644
--- a/crates/driver/src/tests/setup/blockchain.rs
+++ b/crates/driver/src/tests/setup/blockchain.rs
@@ -11,7 +11,7 @@ use {
         signers::local::{MnemonicBuilder, PrivateKeySigner},
         sol_types::SolCall,
     },
-    contracts::alloy::{
+    contracts::{
         BalancerV2Authorizer,
         BalancerV2Vault,
         ERC20,
@@ -38,7 +38,7 @@ use {
 pub struct Pair {
     token_a: &'static str,
     token_b: &'static str,
-    contract: contracts::alloy::IUniswapLikePair::Instance,
+    contract: contracts::IUniswapLikePair::Instance,
     pool: Pool,
 }
 
@@ -269,7 +269,7 @@ impl Blockchain {
         .await
         .unwrap();
 
-        let weth = contracts::alloy::WETH9::Instance::deploy_builder(web3.provider.clone())
+        let weth = contracts::WETH9::Instance::deploy_builder(web3.provider.clone())
             .from(main_trader_address)
             .deploy()
             .await
@@ -440,7 +440,7 @@ impl Blockchain {
             }
         }
         // Create the uniswap factory.
-        let contract_address = contracts::alloy::UniswapV2Factory::Instance::deploy_builder(
+        let contract_address = contracts::UniswapV2Factory::Instance::deploy_builder(
             web3.provider.clone(),
             main_trader_address,
         )
@@ -448,10 +448,8 @@ impl Blockchain {
         .deploy()
         .await
         .unwrap();
-        let uniswap_factory = contracts::alloy::UniswapV2Factory::Instance::new(
-            contract_address,
-            web3.provider.clone(),
-        );
+        let uniswap_factory =
+            contracts::UniswapV2Factory::Instance::new(contract_address, web3.provider.clone());
         // Create and fund a uniswap pair for each pool. Fund the settlement contract
         // with the same liquidity as the pool, to allow for internalized interactions.
         let mut pairs = Vec::new();
@@ -475,7 +473,7 @@ impl Blockchain {
                 .await
                 .unwrap();
             // Fund the pair and the settlement contract.
-            let pair = contracts::alloy::IUniswapLikePair::Instance::new(
+            let pair = contracts::IUniswapLikePair::Instance::new(
                 uniswap_factory
                     .getPair(token_a, token_b)
                     .call()
diff --git a/crates/driver/src/tests/setup/solver.rs b/crates/driver/src/tests/setup/solver.rs
index 1e9b37c4d5..f18f11c64c 100644
--- a/crates/driver/src/tests/setup/solver.rs
+++ b/crates/driver/src/tests/setup/solver.rs
@@ -14,7 +14,7 @@ use {
     },
     alloy::{primitives::Address, signers::local::PrivateKeySigner},
     const_hex::ToHexExt,
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     eth_domain_types as eth,
     gas_price_estimation::Eip1559EstimationExt,
     itertools::Itertools,
diff --git a/crates/e2e/src/setup/deploy.rs b/crates/e2e/src/setup/deploy.rs
index 1cba658b81..a4efac5672 100644
--- a/crates/e2e/src/setup/deploy.rs
+++ b/crates/e2e/src/setup/deploy.rs
@@ -4,7 +4,7 @@ use {
         providers::Provider,
         sol_types::SolCall,
     },
-    contracts::alloy::{
+    contracts::{
         BalancerV2Authorizer,
         BalancerV2Vault,
         CoWSwapEthFlow,
@@ -276,10 +276,7 @@ async fn grant_required_roles(
     vault: Address,
     vault_relayer: Address,
 ) {
-    use contracts::alloy::BalancerV2Vault::BalancerV2Vault::{
-        batchSwapCall,
-        manageUserBalanceCall,
-    };
+    use contracts::BalancerV2Vault::BalancerV2Vault::{batchSwapCall, manageUserBalanceCall};
 
     authorizer
         .grantRoles(
diff --git a/crates/e2e/src/setup/onchain_components/mod.rs b/crates/e2e/src/setup/onchain_components/mod.rs
index c5080fc3e9..3a9ebc53a8 100644
--- a/crates/e2e/src/setup/onchain_components/mod.rs
+++ b/crates/e2e/src/setup/onchain_components/mod.rs
@@ -11,7 +11,7 @@ use {
         signers::local::PrivateKeySigner,
     },
     app_data::Hook,
-    contracts::alloy::{
+    contracts::{
         ERC20Mintable,
         GPv2AllowListAuthentication::GPv2AllowListAuthentication,
         test::CowProtocolToken,
@@ -491,7 +491,7 @@ impl OnchainComponents {
     ///
     /// This can be used to modify the pool reserves during a test.
     pub async fn mint_token_to_weth_uni_v2_pool(&self, token: &MintableToken, amount: U256) {
-        let pair = contracts::alloy::IUniswapLikePair::Instance::new(
+        let pair = contracts::IUniswapLikePair::Instance::new(
             self.contracts
                 .uniswap_v2_factory
                 .getPair(*self.contracts.weth.address(), *token.address())
diff --git a/crates/e2e/src/setup/onchain_components/safe.rs b/crates/e2e/src/setup/onchain_components/safe.rs
index 8b15316d53..550cc27a84 100644
--- a/crates/e2e/src/setup/onchain_components/safe.rs
+++ b/crates/e2e/src/setup/onchain_components/safe.rs
@@ -5,7 +5,7 @@ use {
         providers::Provider,
         rpc::types::TransactionRequest,
     },
-    contracts::alloy::{
+    contracts::{
         GnosisSafe::{self, GnosisSafe::execTransactionCall},
         GnosisSafeCompatibilityFallbackHandler,
         GnosisSafeProxy,
diff --git a/crates/e2e/tests/e2e/banned_users.rs b/crates/e2e/tests/e2e/banned_users.rs
index e317134fdc..b580d0d337 100644
--- a/crates/e2e/tests/e2e/banned_users.rs
+++ b/crates/e2e/tests/e2e/banned_users.rs
@@ -3,7 +3,7 @@ use {
         primitives::{Address, address},
         providers::ext::{AnvilApi, ImpersonateConfig},
     },
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     e2e::setup::{OnchainComponents, Services, run_forked_test_with_block_number},
     ethrpc::Web3,
     model::quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs
index e2dc3ce564..36c3c06110 100644
--- a/crates/e2e/tests/e2e/cow_amm.rs
+++ b/crates/e2e/tests/e2e/cow_amm.rs
@@ -11,7 +11,7 @@ use {
         order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
-    contracts::alloy::{
+    contracts::{
         ERC20,
         support::{Balances, Signatures},
     },
@@ -74,20 +74,18 @@ async fn cow_amm_jit(web3: Web3) {
     .await;
 
     // set up cow_amm
-    let oracle = contracts::alloy::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(
+    let oracle =
+        contracts::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(web3.provider.clone())
+            .await
+            .unwrap();
+
+    let cow_amm_factory = contracts::cow_amm::CowAmmConstantProductFactory::Instance::deploy(
         web3.provider.clone(),
+        *onchain.contracts().gp_settlement.address(),
     )
     .await
     .unwrap();
 
-    let cow_amm_factory =
-        contracts::alloy::cow_amm::CowAmmConstantProductFactory::Instance::deploy(
-            web3.provider.clone(),
-            *onchain.contracts().gp_settlement.address(),
-        )
-        .await
-        .unwrap();
-
     // Fund cow amm owner with 2_000 dai and allow factory take them
     dai.mint(cow_amm_owner.address(), 2_000u64.eth()).await;
 
@@ -152,7 +150,7 @@ async fn cow_amm_jit(web3: Web3) {
         .send_and_watch()
         .await
         .unwrap();
-    let cow_amm = contracts::alloy::cow_amm::CowAmm::Instance::new(cow_amm, web3.provider.clone());
+    let cow_amm = contracts::cow_amm::CowAmm::Instance::new(cow_amm, web3.provider.clone());
 
     // Start system with the regular baseline solver as a quoter but a mock solver
     // for the actual solver competition. That way we can handcraft a solution
@@ -226,7 +224,7 @@ async fn cow_amm_jit(web3: Web3) {
     // oracle price => 100 WETH == 300000 DAI => 1 WETH == 3000 DAI
     // If this order gets settled around the oracle price it will receive plenty of
     // surplus.
-    let cow_amm_order = contracts::alloy::cow_amm::CowAmm::GPv2Order::Data {
+    let cow_amm_order = contracts::cow_amm::CowAmm::GPv2Order::Data {
         sellToken: *onchain.contracts().weth.address(),
         buyToken: *dai.address(),
         receiver: Default::default(),
@@ -249,7 +247,7 @@ async fn cow_amm_jit(web3: Web3) {
                 .unwrap(),
         ), // erc20
     };
-    let trading_params = contracts::alloy::cow_amm::CowAmm::ConstantProduct::TradingParams {
+    let trading_params = contracts::cow_amm::CowAmm::ConstantProduct::TradingParams {
         minTradedToken0: U256::ZERO,
         priceOracle: *oracle.address(),
         priceOracleData: Bytes::copy_from_slice(&oracle_data),
@@ -721,20 +719,18 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     // the user order.
 
     // Set up the CoW AMM as before
-    let oracle = contracts::alloy::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(
+    let oracle =
+        contracts::cow_amm::CowAmmUniswapV2PriceOracle::Instance::deploy(web3.provider.clone())
+            .await
+            .unwrap();
+
+    let cow_amm_factory = contracts::cow_amm::CowAmmConstantProductFactory::Instance::deploy(
         web3.provider.clone(),
+        *onchain.contracts().gp_settlement.address(),
     )
     .await
     .unwrap();
 
-    let cow_amm_factory =
-        contracts::alloy::cow_amm::CowAmmConstantProductFactory::Instance::deploy(
-            web3.provider.clone(),
-            *onchain.contracts().gp_settlement.address(),
-        )
-        .await
-        .unwrap();
-
     // Fund the CoW AMM owner with DAI and WETH and approve the factory to transfer
     // them
     dai.mint(cow_amm_owner.address(), 2_000u64.eth()).await;
@@ -811,8 +807,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
         .send_and_watch()
         .await
         .unwrap();
-    let cow_amm =
-        contracts::alloy::cow_amm::CowAmm::Instance::new(cow_amm_address, web3.provider.clone());
+    let cow_amm = contracts::cow_amm::CowAmm::Instance::new(cow_amm_address, web3.provider.clone());
 
     // Start system with the mocked solver. Baseline is still required for the
     // native price estimation.
@@ -878,7 +873,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
     let executed_amount = 230u64.eth();
 
     // CoW AMM order remains the same (selling WETH for DAI)
-    let cow_amm_order = contracts::alloy::cow_amm::CowAmm::GPv2Order::Data {
+    let cow_amm_order = contracts::cow_amm::CowAmm::GPv2Order::Data {
         sellToken: *onchain.contracts().weth.address(),
         buyToken: *dai.address(),
         receiver: Default::default(),
@@ -901,7 +896,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
                 .unwrap(),
         ), // erc20
     };
-    let trading_params = contracts::alloy::cow_amm::CowAmm::ConstantProduct::TradingParams {
+    let trading_params = contracts::cow_amm::CowAmm::ConstantProduct::TradingParams {
         minTradedToken0: U256::ZERO,
         priceOracle: *oracle.address(),
         priceOracleData: Bytes::copy_from_slice(&oracle_data),
diff --git a/crates/e2e/tests/e2e/ethflow.rs b/crates/e2e/tests/e2e/ethflow.rs
index 8b8c5d70dc..4a8f789b77 100644
--- a/crates/e2e/tests/e2e/ethflow.rs
+++ b/crates/e2e/tests/e2e/ethflow.rs
@@ -5,7 +5,7 @@ use {
     },
     anyhow::bail,
     autopilot::database::onchain_order_events::ethflow_events::WRAP_ALL_SELECTOR,
-    contracts::alloy::{CoWSwapEthFlow, ERC20Mintable, WETH9},
+    contracts::{CoWSwapEthFlow, ERC20Mintable, WETH9},
     database::{byte_array::ByteArray, order_events::OrderEventLabel},
     e2e::setup::{
         ACCOUNT_ENDPOINT,
diff --git a/crates/e2e/tests/e2e/hooks.rs b/crates/e2e/tests/e2e/hooks.rs
index b88eedec5e..8b17ec3af4 100644
--- a/crates/e2e/tests/e2e/hooks.rs
+++ b/crates/e2e/tests/e2e/hooks.rs
@@ -287,7 +287,7 @@ async fn signature(web3: Web3) {
     let safe_address = safe_creation_builder.clone().call().await.unwrap();
     let safe = Safe::deployed(
         chain_id,
-        contracts::alloy::GnosisSafe::Instance::new(safe_address, web3.provider.clone()),
+        contracts::GnosisSafe::Instance::new(safe_address, web3.provider.clone()),
         trader.clone(),
     );
 
@@ -401,7 +401,7 @@ async fn partial_fills(web3: Web3) {
     let [solver] = onchain.make_solvers(1u64.eth()).await;
     let [trader] = onchain.make_accounts(3u64.eth()).await;
 
-    let counter = contracts::alloy::test::Counter::Instance::deploy(web3.provider.clone())
+    let counter = contracts::test::Counter::Instance::deploy(web3.provider.clone())
         .await
         .unwrap();
 
@@ -554,7 +554,7 @@ async fn quote_verification(web3: Web3) {
 
     let safe = Safe::deployed(
         chain_id,
-        contracts::alloy::GnosisSafe::Instance::new(safe_address, web3.provider.clone()),
+        contracts::GnosisSafe::Instance::new(safe_address, web3.provider.clone()),
         trader.clone(),
     );
 
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 742c2446c1..2b8ee84858 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -16,7 +16,7 @@ use {
         orderbook::order_validation::OrderValidationConfig,
         test_util::TestDefault,
     },
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     database::byte_array::ByteArray,
     e2e::setup::{
         proxy::{OnRequest, ReverseProxy},
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 96f4dd2d7b..878397d3d3 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -12,7 +12,7 @@ use {
         order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
-    contracts::alloy::{ERC20, IZeroex},
+    contracts::{ERC20, IZeroex},
     e2e::{
         api::zeroex::{Eip712TypedZeroExOrder, ZeroExApi},
         assert_approximately_eq,
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index e4815b599c..f517e09315 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -10,7 +10,7 @@ use {
         order_quoting::{ExternalSolver, OrderQuoting},
         test_util::TestDefault,
     },
-    contracts::alloy::{ERC20, LiquoriceSettlement},
+    contracts::{ERC20, LiquoriceSettlement},
     driver::infra,
     e2e::{
         api,
diff --git a/crates/e2e/tests/e2e/parallel_settlement.rs b/crates/e2e/tests/e2e/parallel_settlement.rs
index 9e54cc9ee0..b983be982f 100644
--- a/crates/e2e/tests/e2e/parallel_settlement.rs
+++ b/crates/e2e/tests/e2e/parallel_settlement.rs
@@ -4,7 +4,7 @@ use {
         primitives::{Address, U256},
         providers::{Provider, ext::TxPoolApi},
     },
-    contracts::alloy::CowSettlementForwarder::CowSettlementForwarder,
+    contracts::CowSettlementForwarder::CowSettlementForwarder,
     e2e::setup::{colocation, *},
     ethrpc::{
         Web3,
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 45fb7af7e6..1497e42645 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -605,7 +605,7 @@ async fn trace_based_balance_detection(web3: Web3) {
     // offset within a struct mapping, making it undetectable by standard slot
     // calculation methods
     let struct_offset_token =
-        contracts::alloy::test::NonStandardERC20Balances::Instance::deploy(web3.provider.clone())
+        contracts::test::NonStandardERC20Balances::Instance::deploy(web3.provider.clone())
             .await
             .unwrap();
 
@@ -614,20 +614,14 @@ async fn trace_based_balance_detection(web3: Web3) {
     // delegate the balance it returns between itself (allowing for testing of
     // calling another contract to get a balance--or calling another contract to
     // *not* get a balance)
-    let local_storage_token = contracts::alloy::test::RemoteERC20Balances::Instance::deploy(
-        web3.provider.clone(),
-        weth,
-        true,
-    )
-    .await
-    .unwrap();
-    let delegated_storage_token = contracts::alloy::test::RemoteERC20Balances::Instance::deploy(
-        web3.provider.clone(),
-        weth,
-        false,
-    )
-    .await
-    .unwrap();
+    let local_storage_token =
+        contracts::test::RemoteERC20Balances::Instance::deploy(web3.provider.clone(), weth, true)
+            .await
+            .unwrap();
+    let delegated_storage_token =
+        contracts::test::RemoteERC20Balances::Instance::deploy(web3.provider.clone(), weth, false)
+            .await
+            .unwrap();
 
     // Mint some tokens to the trader (so the contract has non-zero state)
     struct_offset_token
@@ -704,7 +698,7 @@ async fn trace_based_balance_detection(web3: Web3) {
 
     // Verify that the detected strategies actually work by testing balance
     // overrides
-    use contracts::alloy::ERC20;
+    use contracts::ERC20;
 
     async fn test_balance_override(
         web3: &Web3,
diff --git a/crates/e2e/tests/e2e/refunder.rs b/crates/e2e/tests/e2e/refunder.rs
index 36f50f5a7b..728bd0cd4c 100644
--- a/crates/e2e/tests/e2e/refunder.rs
+++ b/crates/e2e/tests/e2e/refunder.rs
@@ -78,7 +78,7 @@ async fn wait_for_order_settlement(
 /// Creates a standard quote request for ethflow orders.
 fn default_quote_request(
     from: Address,
-    weth: &contracts::alloy::WETH9::Instance,
+    weth: &contracts::WETH9::Instance,
     buy_token: Address,
     sell_amount: NonZeroU256,
 ) -> OrderQuoteRequest {
diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs
index cf17e3baec..e6dab581ca 100644
--- a/crates/e2e/tests/e2e/smart_contract_orders.rs
+++ b/crates/e2e/tests/e2e/smart_contract_orders.rs
@@ -156,7 +156,7 @@ async fn erc1271_gas_limit(web3: Web3) {
     let mut onchain = OnchainComponents::deploy(web3.clone()).await;
 
     let [solver] = onchain.make_solvers(1u64.eth()).await;
-    let trader = contracts::alloy::test::GasHog::Instance::deploy(web3.provider.clone())
+    let trader = contracts::test::GasHog::Instance::deploy(web3.provider.clone())
         .await
         .unwrap();
 
diff --git a/crates/e2e/tests/e2e/univ2.rs b/crates/e2e/tests/e2e/univ2.rs
index 57812bf129..f6bfc7a40f 100644
--- a/crates/e2e/tests/e2e/univ2.rs
+++ b/crates/e2e/tests/e2e/univ2.rs
@@ -1,6 +1,6 @@
 use {
     ::alloy::primitives::U256,
-    contracts::alloy::GPv2Settlement,
+    contracts::GPv2Settlement,
     database::order_events::{OrderEvent, OrderEventLabel},
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
diff --git a/crates/e2e/tests/e2e/wrapper.rs b/crates/e2e/tests/e2e/wrapper.rs
index edffd1444b..66be717b54 100644
--- a/crates/e2e/tests/e2e/wrapper.rs
+++ b/crates/e2e/tests/e2e/wrapper.rs
@@ -8,7 +8,7 @@ use {
         rpc::types::trace::geth::{CallConfig, GethDebugTracingOptions},
     },
     app_data::{AppDataHash, hash_full_app_data},
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
     model::{
diff --git a/crates/event-indexing/src/event_handler.rs b/crates/event-indexing/src/event_handler.rs
index 54841fcaa8..b47bc70400 100644
--- a/crates/event-indexing/src/event_handler.rs
+++ b/crates/event-indexing/src/event_handler.rs
@@ -684,7 +684,7 @@ mod tests {
         super::*,
         alloy_eips::BlockNumberOrTag,
         alloy_primitives::b256,
-        contracts::alloy::GPv2Settlement,
+        contracts::GPv2Settlement,
         ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
     };
 
diff --git a/crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs
index fd792b1ff1..1dfdaab5d2 100644
--- a/crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/mod.rs
@@ -32,7 +32,7 @@ use {
         providers::{DynProvider, Provider},
     },
     anyhow::{Context, Result},
-    contracts::alloy::{
+    contracts::{
         BalancerV2ComposableStablePoolFactory,
         BalancerV2ComposableStablePoolFactoryV3,
         BalancerV2ComposableStablePoolFactoryV4,
diff --git a/crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs
index 3e57bae018..835b622160 100644
--- a/crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/pool_storage.rs
@@ -22,7 +22,7 @@ use {
         rpc::types::Log,
     },
     anyhow::{Context, Result},
-    contracts::alloy::BalancerV2BasePoolFactory::BalancerV2BasePoolFactory::{
+    contracts::BalancerV2BasePoolFactory::BalancerV2BasePoolFactory::{
         BalancerV2BasePoolFactoryEvents,
         PoolCreated,
     },
diff --git a/crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs b/crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs
index 3a64978195..9c2cbf7ee8 100644
--- a/crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pool_fetching/registry.rs
@@ -18,7 +18,7 @@ use {
         sol_types::SolEvent,
     },
     anyhow::Result,
-    contracts::alloy::BalancerV2BasePoolFactory::{self, BalancerV2BasePoolFactory::PoolCreated},
+    contracts::BalancerV2BasePoolFactory::{self, BalancerV2BasePoolFactory::PoolCreated},
     ethrpc::{alloy::errors::ContractErrorExt, block_stream::BlockNumberHash},
     event_indexing::{
         block_retriever::BlockRetrieving,
diff --git a/crates/liquidity-sources/src/balancer_v2/pools/common.rs b/crates/liquidity-sources/src/balancer_v2/pools/common.rs
index b2c4a08a4f..c9c6c831d3 100644
--- a/crates/liquidity-sources/src/balancer_v2/pools/common.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/common.rs
@@ -11,7 +11,7 @@ use {
         primitives::{Address, B256, U256},
     },
     anyhow::{Context, Result, anyhow, ensure},
-    contracts::alloy::{BalancerV2BasePool, BalancerV2Vault},
+    contracts::{BalancerV2BasePool, BalancerV2Vault},
     futures::{FutureExt as _, future::BoxFuture},
     std::{collections::BTreeMap, future::Future, sync::Arc},
     token_info::TokenInfoFetching,
@@ -368,7 +368,7 @@ mod tests {
             transports::mock::Asserter,
         },
         anyhow::bail,
-        contracts::alloy::BalancerV2Vault,
+        contracts::BalancerV2Vault,
         maplit::{btreemap, hashmap},
         mockall::predicate,
         std::future,
diff --git a/crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs b/crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs
index 8a1fd2d12e..5f5164fa37 100644
--- a/crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/composable_stable.rs
@@ -8,7 +8,7 @@ use {
     },
     alloy::eips::BlockId,
     anyhow::Result,
-    contracts::alloy::{BalancerV2ComposableStablePool, BalancerV2ComposableStablePoolFactory},
+    contracts::{BalancerV2ComposableStablePool, BalancerV2ComposableStablePoolFactory},
     futures::{FutureExt as _, future::BoxFuture},
 };
 
diff --git a/crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs b/crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs
index 930416afc8..535cfdfef2 100644
--- a/crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/liquidity_bootstrapping.rs
@@ -8,7 +8,7 @@ use {
     },
     alloy::eips::BlockId,
     anyhow::Result,
-    contracts::alloy::{
+    contracts::{
         BalancerV2LiquidityBootstrappingPool,
         BalancerV2LiquidityBootstrappingPoolFactory,
     },
diff --git a/crates/liquidity-sources/src/balancer_v2/pools/stable.rs b/crates/liquidity-sources/src/balancer_v2/pools/stable.rs
index cf8669aead..21ad5dd031 100644
--- a/crates/liquidity-sources/src/balancer_v2/pools/stable.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/stable.rs
@@ -11,7 +11,7 @@ use {
         primitives::{Address, U256},
     },
     anyhow::{Result, ensure},
-    contracts::alloy::{BalancerV2StablePool, BalancerV2StablePoolFactoryV2},
+    contracts::{BalancerV2StablePool, BalancerV2StablePoolFactoryV2},
     futures::{FutureExt as _, future::BoxFuture},
     num::BigRational,
     std::collections::BTreeMap,
diff --git a/crates/liquidity-sources/src/balancer_v2/pools/weighted.rs b/crates/liquidity-sources/src/balancer_v2/pools/weighted.rs
index 08dae4e147..2e654de6a5 100644
--- a/crates/liquidity-sources/src/balancer_v2/pools/weighted.rs
+++ b/crates/liquidity-sources/src/balancer_v2/pools/weighted.rs
@@ -8,7 +8,7 @@ use {
     },
     alloy::{eips::BlockId, primitives::Address},
     anyhow::{Result, anyhow},
-    contracts::alloy::{
+    contracts::{
         BalancerV2WeightedPool,
         BalancerV2WeightedPoolFactory,
         BalancerV2WeightedPoolFactoryV3,
diff --git a/crates/liquidity-sources/src/swapr.rs b/crates/liquidity-sources/src/swapr.rs
index ffa67bddf0..476b9b841f 100644
--- a/crates/liquidity-sources/src/swapr.rs
+++ b/crates/liquidity-sources/src/swapr.rs
@@ -4,7 +4,7 @@ use {
     crate::uniswap_v2::pool_fetching::{DefaultPoolReader, Pool, PoolReading},
     alloy::eips::BlockId,
     anyhow::Result,
-    contracts::alloy::ISwaprPair,
+    contracts::ISwaprPair,
     ethrpc::alloy::errors::ignore_non_node_error,
     futures::{FutureExt as _, future::BoxFuture},
     model::TokenPair,
diff --git a/crates/liquidity-sources/src/uniswap_v2/mod.rs b/crates/liquidity-sources/src/uniswap_v2/mod.rs
index c371d6a98c..5d934565de 100644
--- a/crates/liquidity-sources/src/uniswap_v2/mod.rs
+++ b/crates/liquidity-sources/src/uniswap_v2/mod.rs
@@ -12,7 +12,7 @@ use {
     crate::{BaselineSource, swapr::SwaprPoolReader},
     alloy::primitives::{Address, B256},
     anyhow::{Context, Result},
-    contracts::alloy::IUniswapLikeRouter,
+    contracts::IUniswapLikeRouter,
     ethrpc::{Web3, alloy::ProviderLabelingExt},
     hex_literal::hex,
     std::{fmt::Display, str::FromStr, sync::Arc},
@@ -67,32 +67,32 @@ impl UniV2BaselineSourceParameters {
         match source {
             BS::None | BS::BalancerV2 | BS::ZeroEx | BS::UniswapV3 => None,
             BS::UniswapV2 => Some(Self {
-                router: contracts::alloy::UniswapV2Router02::deployment_address(&chain_id)?,
+                router: contracts::UniswapV2Router02::deployment_address(&chain_id)?,
                 init_code_digest: UNISWAP_INIT.into(),
                 pool_reading: PoolReadingStyle::Default,
             }),
             BS::Honeyswap => Some(Self {
-                router: contracts::alloy::HoneyswapRouter::deployment_address(&chain_id)?,
+                router: contracts::HoneyswapRouter::deployment_address(&chain_id)?,
                 init_code_digest: HONEYSWAP_INIT.into(),
                 pool_reading: PoolReadingStyle::Default,
             }),
             BS::SushiSwap => Some(Self {
-                router: contracts::alloy::SushiSwapRouter::deployment_address(&chain_id)?,
+                router: contracts::SushiSwapRouter::deployment_address(&chain_id)?,
                 init_code_digest: SUSHISWAP_INIT.into(),
                 pool_reading: PoolReadingStyle::Default,
             }),
             BS::Swapr => Some(Self {
-                router: contracts::alloy::SwaprRouter::deployment_address(&chain_id)?,
+                router: contracts::SwaprRouter::deployment_address(&chain_id)?,
                 init_code_digest: SWAPR_INIT.into(),
                 pool_reading: PoolReadingStyle::Swapr,
             }),
             BS::TestnetUniswapV2 => Some(Self {
-                router: contracts::alloy::TestnetUniswapV2Router02::deployment_address(&chain_id)?,
+                router: contracts::TestnetUniswapV2Router02::deployment_address(&chain_id)?,
                 init_code_digest: TESTNET_UNISWAP_INIT.into(),
                 pool_reading: PoolReadingStyle::Default,
             }),
             BS::Baoswap => Some(Self {
-                router: contracts::alloy::BaoswapRouter::deployment_address(&chain_id)?,
+                router: contracts::BaoswapRouter::deployment_address(&chain_id)?,
                 init_code_digest: BAOSWAP_INIT.into(),
                 pool_reading: PoolReadingStyle::Default,
             }),
@@ -102,7 +102,7 @@ impl UniV2BaselineSourceParameters {
     pub async fn into_source(&self, web3: &Web3) -> Result<UniV2BaselineSource> {
         let web3 = web3.labeled("uniswapV2");
         let router =
-            contracts::alloy::IUniswapLikeRouter::Instance::new(self.router, web3.provider.clone());
+            contracts::IUniswapLikeRouter::Instance::new(self.router, web3.provider.clone());
         let factory = router.factory().call().await.context("factory")?;
         let pair_provider = pair_provider::PairProvider {
             factory,
diff --git a/crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs b/crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs
index 0720448e8d..d9d323ad2a 100644
--- a/crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs
+++ b/crates/liquidity-sources/src/uniswap_v2/pool_fetching.rs
@@ -7,7 +7,7 @@ use {
     },
     anyhow::Result,
     cached::{Cached, TimedCache},
-    contracts::alloy::{
+    contracts::{
         ERC20,
         IUniswapLikePair::{self, IUniswapLikePair::getReservesReturn},
     },
diff --git a/crates/liquidity-sources/src/uniswap_v3/event_fetching.rs b/crates/liquidity-sources/src/uniswap_v3/event_fetching.rs
index 69827b6fc1..4aaf0c4e34 100644
--- a/crates/liquidity-sources/src/uniswap_v3/event_fetching.rs
+++ b/crates/liquidity-sources/src/uniswap_v3/event_fetching.rs
@@ -7,7 +7,7 @@ use {
         sol_types::SolEvent,
     },
     anyhow::{Context, Result},
-    contracts::alloy::{
+    contracts::{
         UniswapV3Pool,
         UniswapV3Pool::UniswapV3Pool::{Burn, Mint, Swap, UniswapV3PoolEvents},
     },
diff --git a/crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs b/crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs
index 34e24647b5..faa3643715 100644
--- a/crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs
+++ b/crates/liquidity-sources/src/uniswap_v3/pool_fetching.rs
@@ -9,7 +9,7 @@ use {
         rpc::types::Log,
     },
     anyhow::{Context, Result},
-    contracts::alloy::UniswapV3Pool::UniswapV3Pool::{
+    contracts::UniswapV3Pool::UniswapV3Pool::{
         UniswapV3PoolEvents as AlloyUniswapV3PoolEvents,
         UniswapV3PoolEvents,
     },
@@ -519,7 +519,7 @@ mod tests {
     use {
         super::*,
         alloy::primitives::{U160, address, aliases::I24},
-        contracts::alloy::UniswapV3Pool::UniswapV3Pool::{Burn, Mint, Swap},
+        contracts::UniswapV3Pool::UniswapV3Pool::{Burn, Mint, Swap},
         serde_json::json,
         std::str::FromStr,
         testlib::assert_json_matches,
diff --git a/crates/order-validation/src/banned.rs b/crates/order-validation/src/banned.rs
index d281b85206..70781b1fb8 100644
--- a/crates/order-validation/src/banned.rs
+++ b/crates/order-validation/src/banned.rs
@@ -6,7 +6,7 @@
 
 use {
     alloy_primitives::Address,
-    contracts::alloy::ChainalysisOracle,
+    contracts::ChainalysisOracle,
     futures::future::join_all,
     moka::sync::Cache,
     std::{
diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
index 92d06ae289..8cdc7ab4df 100644
--- a/crates/orderbook/src/order_simulator.rs
+++ b/crates/orderbook/src/order_simulator.rs
@@ -8,7 +8,7 @@ use {
     anyhow::{Context, Result, anyhow},
     app_data::WrapperCall,
     balance_overrides::BalanceOverrideRequest,
-    contracts::alloy::support::{AnyoneAuthenticator, Trader},
+    contracts::support::{AnyoneAuthenticator, Trader},
     eth_domain_types::{BlockNo, NonZeroU256},
     model::order::Order,
     shared::remaining_amounts,
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 1950f9865d..da0e6b852b 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -17,7 +17,7 @@ use {
     chain::Chain,
     clap::Parser,
     configs::orderbook::Configuration,
-    contracts::alloy::{
+    contracts::{
         BalancerV2Vault,
         ChainalysisOracle,
         GPv2Settlement,
@@ -125,9 +125,9 @@ pub async fn run(config: Configuration) {
         .expect("Couldn't get vault relayer address");
     let signatures_contract = match config.shared.contracts.signatures {
         Some(address) => {
-            contracts::alloy::support::Signatures::Instance::new(address, web3.provider.clone())
+            contracts::support::Signatures::Instance::new(address, web3.provider.clone())
         }
-        None => contracts::alloy::support::Signatures::Instance::deployed(&web3.provider)
+        None => contracts::support::Signatures::Instance::deployed(&web3.provider)
             .await
             .expect("load signatures contract"),
     };
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index 57225a974e..4d5268ca64 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -21,7 +21,7 @@ use {
     anyhow::{Context as _, Result},
     bad_tokens::list_based::DenyListedTokens,
     configs::price_estimation::PriceEstimation,
-    contracts::alloy::WETH9,
+    contracts::WETH9,
     ethrpc::{Web3, alloy::ProviderLabelingExt, block_stream::CurrentBlockWatcher},
     gas_price_estimation::GasPriceEstimating,
     http_client::HttpClientFactory,
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index 641e670ab1..0edb4ff55a 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -18,7 +18,7 @@ use {
     anyhow::{Context, Result},
     balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
     bigdecimal::BigDecimal,
-    contracts::alloy::{
+    contracts::{
         GPv2Settlement,
         support::{AnyoneAuthenticator, Solver, Spardose, Trader},
     },
diff --git a/crates/refunder/src/infra/chain.rs b/crates/refunder/src/infra/chain.rs
index f7b660a5f9..8664e172a8 100644
--- a/crates/refunder/src/infra/chain.rs
+++ b/crates/refunder/src/infra/chain.rs
@@ -4,7 +4,7 @@ use {
     crate::traits::{ChainRead, RefundStatus},
     alloy::{primitives::Address, providers::Provider, rpc::types::TransactionRequest},
     anyhow::{Result, anyhow},
-    contracts::alloy::CoWSwapEthFlow,
+    contracts::CoWSwapEthFlow,
     ethrpc::{AlloyProvider, block_stream::timestamp_of_current_block_in_seconds},
     std::collections::HashMap,
 };
diff --git a/crates/refunder/src/infra/database.rs b/crates/refunder/src/infra/database.rs
index 2bbbf246d2..92964f395e 100644
--- a/crates/refunder/src/infra/database.rs
+++ b/crates/refunder/src/infra/database.rs
@@ -4,7 +4,7 @@ use {
     crate::traits::DbRead,
     alloy::primitives::Address,
     anyhow::{Context, Result},
-    contracts::alloy::CoWSwapEthFlow::EthFlowOrder,
+    contracts::CoWSwapEthFlow::EthFlowOrder,
     database::{
         OrderUid,
         ethflow_orders::{EthOrderPlacement, read_order, refundable_orders},
diff --git a/crates/refunder/src/refund_service.rs b/crates/refunder/src/refund_service.rs
index 5d24e5220d..1bdeaeba23 100644
--- a/crates/refunder/src/refund_service.rs
+++ b/crates/refunder/src/refund_service.rs
@@ -288,7 +288,7 @@ mod tests {
         },
         alloy::primitives::Address,
         anyhow::anyhow,
-        contracts::alloy::CoWSwapEthFlow::EthFlowOrder,
+        contracts::CoWSwapEthFlow::EthFlowOrder,
         database::{byte_array::ByteArray, ethflow_orders::EthOrderPlacement},
         rand::random,
         rstest::rstest,
diff --git a/crates/refunder/src/submitter.rs b/crates/refunder/src/submitter.rs
index 5f7cbb85b5..e2f3e64ba0 100644
--- a/crates/refunder/src/submitter.rs
+++ b/crates/refunder/src/submitter.rs
@@ -9,7 +9,7 @@ use {
     crate::traits::ChainWrite,
     alloy::{eips::eip1559::Eip1559Estimation, primitives::Address, providers::Provider},
     anyhow::{Context, Result},
-    contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
+    contracts::CoWSwapEthFlow::{self, EthFlowOrder},
     database::OrderUid,
     ethrpc::Web3,
     gas_price_estimation::{Eip1559EstimationExt, GasPriceEstimating},
diff --git a/crates/refunder/src/traits.rs b/crates/refunder/src/traits.rs
index 197e9837dc..4a957c5aa8 100644
--- a/crates/refunder/src/traits.rs
+++ b/crates/refunder/src/traits.rs
@@ -5,7 +5,7 @@
 use {
     alloy::primitives::{Address, B256},
     anyhow::Result,
-    contracts::alloy::CoWSwapEthFlow::{self, EthFlowOrder},
+    contracts::CoWSwapEthFlow::{self, EthFlowOrder},
     database::{OrderUid, ethflow_orders::EthOrderPlacement},
 };
 
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index 3846be7df8..e6761b7c65 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -13,7 +13,7 @@ use {
     async_trait::async_trait,
     bad_tokens::list_based::DenyListedTokens,
     balance_overrides::BalanceOverrideRequest,
-    contracts::alloy::{HooksTrampoline, WETH9},
+    contracts::{HooksTrampoline, WETH9},
     model::{
         DomainSeparator,
         interaction::InteractionData,
diff --git a/crates/signature-validator/src/lib.rs b/crates/signature-validator/src/lib.rs
index 69d5c01eb7..8f1a20cfb6 100644
--- a/crates/signature-validator/src/lib.rs
+++ b/crates/signature-validator/src/lib.rs
@@ -1,7 +1,7 @@
 use {
     alloy_primitives::{Address, FixedBytes},
     balance_overrides::{BalanceOverrideRequest, BalanceOverriding},
-    contracts::alloy::GPv2Settlement,
+    contracts::GPv2Settlement,
     ethrpc::Web3,
     hex_literal::hex,
     model::interaction::InteractionData,
@@ -92,7 +92,7 @@ pub fn check_erc1271_result(result: FixedBytes<4>) -> Result<(), SignatureValida
 /// Contracts required for signature verification simulation.
 pub struct Contracts {
     pub settlement: GPv2Settlement::Instance,
-    pub signatures: contracts::alloy::support::Signatures::Instance,
+    pub signatures: contracts::support::Signatures::Instance,
     pub vault_relayer: Address,
 }
 
diff --git a/crates/signature-validator/src/simulation.rs b/crates/signature-validator/src/simulation.rs
index 3a99a25efa..25266a7d37 100644
--- a/crates/signature-validator/src/simulation.rs
+++ b/crates/signature-validator/src/simulation.rs
@@ -12,7 +12,7 @@ use {
     alloy_transport::RpcError,
     anyhow::{Context, Result},
     balance_overrides::BalanceOverriding,
-    contracts::alloy::{
+    contracts::{
         ERC1271SignatureValidator::ERC1271SignatureValidator,
         GPv2Settlement,
         support::Signatures,
diff --git a/crates/simulator/src/encoding.rs b/crates/simulator/src/encoding.rs
index c82dfc5cc1..8c6d188c24 100644
--- a/crates/simulator/src/encoding.rs
+++ b/crates/simulator/src/encoding.rs
@@ -2,7 +2,7 @@ use {
     alloy_primitives::{Address, B256, Bytes, U256},
     alloy_sol_types::SolCall,
     app_data::AppDataHash,
-    contracts::alloy::GPv2Settlement,
+    contracts::GPv2Settlement,
     derive_more::Debug,
     model::{
         interaction::InteractionData,
@@ -270,7 +270,7 @@ pub fn encode_wrapper_settlement(
     let wrapper_data = encode_wrapper_data(wrappers);
 
     // Create wrappedSettleCall
-    let calldata = contracts::alloy::ICowWrapper::ICowWrapper::wrappedSettleCall {
+    let calldata = contracts::ICowWrapper::ICowWrapper::wrappedSettleCall {
         settleData: settle_calldata,
         wrapperData: wrapper_data,
     }
diff --git a/crates/simulator/src/ethereum/contracts.rs b/crates/simulator/src/ethereum/contracts.rs
index 8b51f55455..55069f8c45 100644
--- a/crates/simulator/src/ethereum/contracts.rs
+++ b/crates/simulator/src/ethereum/contracts.rs
@@ -1,7 +1,7 @@
 use {
     chain::Chain,
     configs::simulator::Addresses,
-    contracts::alloy::{GPv2Settlement, WETH9},
+    contracts::{GPv2Settlement, WETH9},
     ethrpc::Web3,
 };
 
diff --git a/crates/simulator/src/swap_simulator.rs b/crates/simulator/src/swap_simulator.rs
index fc34cb1b57..e7c5a81f08 100644
--- a/crates/simulator/src/swap_simulator.rs
+++ b/crates/simulator/src/swap_simulator.rs
@@ -13,7 +13,7 @@ use {
     alloy_sol_types::SolCall,
     anyhow::{Context, Result, anyhow},
     balance_overrides::BalanceOverriding,
-    contracts::alloy::{
+    contracts::{
         GPv2Settlement::{self},
         WETH9,
         support::Solver::{self, Solver::swapReturn},
diff --git a/crates/solver/src/interactions/balancer_v2.rs b/crates/solver/src/interactions/balancer_v2.rs
index b7bf413143..e94a748292 100644
--- a/crates/solver/src/interactions/balancer_v2.rs
+++ b/crates/solver/src/interactions/balancer_v2.rs
@@ -3,7 +3,7 @@ use {
         primitives::{Address, B256, Bytes, U256},
         sol_types::SolCall,
     },
-    contracts::alloy::BalancerV2Vault::{BalancerV2Vault::swapCall, IVault},
+    contracts::BalancerV2Vault::{BalancerV2Vault::swapCall, IVault},
     shared::{
         http_solver::model::TokenAmount,
         interaction::{EncodedInteraction, Interaction},
@@ -126,7 +126,8 @@ mod tests {
                     00000000000000000000000000000000000000000000000000000000000000c0\
                     0000000000000000000000000000000000000000000000000000000000000000"
                 )
-                .unwrap().into()
+                .unwrap()
+                .into()
             )
         );
     }
diff --git a/crates/solver/src/interactions/erc20.rs b/crates/solver/src/interactions/erc20.rs
index 975467d403..a52e42c2ad 100644
--- a/crates/solver/src/interactions/erc20.rs
+++ b/crates/solver/src/interactions/erc20.rs
@@ -5,7 +5,7 @@ use {
         primitives::{Address, U256},
         sol_types::SolCall,
     },
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     shared::interaction::{EncodedInteraction, Interaction},
 };
 
diff --git a/crates/solver/src/interactions/uniswap_v2.rs b/crates/solver/src/interactions/uniswap_v2.rs
index 4d9afca8c0..6e7e69c08f 100644
--- a/crates/solver/src/interactions/uniswap_v2.rs
+++ b/crates/solver/src/interactions/uniswap_v2.rs
@@ -3,7 +3,7 @@ use {
         primitives::{Address, U256},
         sol_types::SolCall,
     },
-    contracts::alloy::IUniswapLikeRouter,
+    contracts::IUniswapLikeRouter,
     shared::interaction::{EncodedInteraction, Interaction},
 };
 
diff --git a/crates/solver/src/interactions/uniswap_v3.rs b/crates/solver/src/interactions/uniswap_v3.rs
index 2552a77569..3cdeb8f852 100644
--- a/crates/solver/src/interactions/uniswap_v3.rs
+++ b/crates/solver/src/interactions/uniswap_v3.rs
@@ -3,7 +3,7 @@ use {
         primitives::{Address, U256},
         sol_types::SolCall,
     },
-    contracts::alloy::UniswapV3SwapRouterV2::{
+    contracts::UniswapV3SwapRouterV2::{
         IV3SwapRouter::ExactOutputSingleParams,
         UniswapV3SwapRouterV2::exactOutputSingleCall,
     },
diff --git a/crates/solver/src/interactions/weth.rs b/crates/solver/src/interactions/weth.rs
index 5189bc73fc..79e27af0c9 100644
--- a/crates/solver/src/interactions/weth.rs
+++ b/crates/solver/src/interactions/weth.rs
@@ -1,7 +1,7 @@
 use {
     alloy::primitives::U256,
     anyhow::{Result, ensure},
-    contracts::alloy::WETH9,
+    contracts::WETH9,
     shared::interaction::{EncodedInteraction, Interaction},
 };
 
diff --git a/crates/solver/src/interactions/zeroex.rs b/crates/solver/src/interactions/zeroex.rs
index b4735026fa..445e48364c 100644
--- a/crates/solver/src/interactions/zeroex.rs
+++ b/crates/solver/src/interactions/zeroex.rs
@@ -1,5 +1,5 @@
 use {
-    contracts::alloy::IZeroex,
+    contracts::IZeroex,
     liquidity_sources::zeroex::Order,
     shared::interaction::{EncodedInteraction, Interaction},
     std::sync::Arc,
diff --git a/crates/solver/src/liquidity/balancer_v2.rs b/crates/solver/src/liquidity/balancer_v2.rs
index 94e8609a95..72391abcbe 100644
--- a/crates/solver/src/liquidity/balancer_v2.rs
+++ b/crates/solver/src/liquidity/balancer_v2.rs
@@ -195,7 +195,7 @@ mod tests {
     use {
         super::*,
         alloy::primitives::U256,
-        contracts::alloy::BalancerV2Vault,
+        contracts::BalancerV2Vault,
         liquidity_sources::{
             balancer_v2::{
                 pool_fetching::{
diff --git a/crates/solver/src/liquidity/uniswap_v3.rs b/crates/solver/src/liquidity/uniswap_v3.rs
index b13216252d..8c67b98126 100644
--- a/crates/solver/src/liquidity/uniswap_v3.rs
+++ b/crates/solver/src/liquidity/uniswap_v3.rs
@@ -8,7 +8,7 @@ use {
     },
     alloy::primitives::Address,
     anyhow::{Context, Result, ensure},
-    contracts::alloy::UniswapV3SwapRouterV2::IV3SwapRouter::ExactOutputSingleParams,
+    contracts::UniswapV3SwapRouterV2::IV3SwapRouter::ExactOutputSingleParams,
     liquidity_sources::{recent_block_cache::Block, uniswap_v3::pool_fetching::PoolFetching},
     model::TokenPair,
     num::{CheckedMul, rational::Ratio},
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index b2df40bfde..de138a47b1 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -9,7 +9,7 @@ use {
     alloy::primitives::{Address, U256},
     anyhow::Result,
     arc_swap::ArcSwap,
-    contracts::alloy::IZeroex,
+    contracts::IZeroex,
     ethrpc::block_stream::{CurrentBlockWatcher, into_stream},
     futures::StreamExt,
     itertools::Itertools,
diff --git a/crates/solver/src/settlement/settlement_encoder.rs b/crates/solver/src/settlement/settlement_encoder.rs
index e227d6cfc0..12d9d0b130 100644
--- a/crates/solver/src/settlement/settlement_encoder.rs
+++ b/crates/solver/src/settlement/settlement_encoder.rs
@@ -584,7 +584,7 @@ pub mod tests {
     use {
         super::*,
         alloy::primitives::Address,
-        contracts::alloy::WETH9,
+        contracts::WETH9,
         maplit::hashmap,
         model::order::{Interactions, OrderBuilder, OrderData},
         shared::interaction::{EncodedInteraction, Interaction},
diff --git a/crates/solvers/src/boundary/baseline.rs b/crates/solvers/src/boundary/baseline.rs
index 12b113885b..394d758e49 100644
--- a/crates/solvers/src/boundary/baseline.rs
+++ b/crates/solvers/src/boundary/baseline.rs
@@ -9,7 +9,7 @@ use {
         domain::{eth, liquidity, order, solver},
     },
     alloy::primitives::{Address, U256},
-    contracts::alloy::UniswapV3QuoterV2,
+    contracts::UniswapV3QuoterV2,
     liquidity_sources::{base_tokens::BaseTokens, baseline_solvable::BaselineSolvable},
     model::TokenPair,
     std::{
@@ -157,7 +157,7 @@ impl<'a> Solver<'a> {
 
 fn to_boundary_liquidity(
     liquidity: &[liquidity::Liquidity],
-    uni_v3_quoter_v2: Option<Arc<contracts::alloy::UniswapV3QuoterV2::Instance>>,
+    uni_v3_quoter_v2: Option<Arc<contracts::UniswapV3QuoterV2::Instance>>,
 ) -> HashMap<TokenPair, Vec<OnchainLiquidity>> {
     liquidity
         .iter()
diff --git a/crates/solvers/src/boundary/liquidity/concentrated.rs b/crates/solvers/src/boundary/liquidity/concentrated.rs
index cfff21a7c9..e9ad48cba3 100644
--- a/crates/solvers/src/boundary/liquidity/concentrated.rs
+++ b/crates/solvers/src/boundary/liquidity/concentrated.rs
@@ -1,6 +1,6 @@
 use {
     alloy::primitives::{Address, U256, aliases::U24},
-    contracts::alloy::UniswapV3QuoterV2::IQuoterV2::{
+    contracts::UniswapV3QuoterV2::IQuoterV2::{
         QuoteExactInputSingleParams,
         QuoteExactOutputSingleParams,
     },
@@ -11,7 +11,7 @@ use {
 
 #[derive(Debug)]
 pub struct Pool {
-    pub uni_v3_quoter_contract: Arc<contracts::alloy::UniswapV3QuoterV2::Instance>,
+    pub uni_v3_quoter_contract: Arc<contracts::UniswapV3QuoterV2::Instance>,
     pub address: Address,
     pub tokens: TokenPair,
     pub fee: U24,
diff --git a/crates/solvers/src/domain/solver/baseline.rs b/crates/solvers/src/domain/solver/baseline.rs
index 80c4ff52f6..1ee13045e7 100644
--- a/crates/solvers/src/domain/solver/baseline.rs
+++ b/crates/solvers/src/domain/solver/baseline.rs
@@ -71,7 +71,7 @@ struct Inner {
     native_token_price_estimation_amount: eth::U256,
 
     /// If provided, the solver can rely on Uniswap V3 LPs
-    uni_v3_quoter_v2: Option<Arc<contracts::alloy::UniswapV3QuoterV2::Instance>>,
+    uni_v3_quoter_v2: Option<Arc<contracts::UniswapV3QuoterV2::Instance>>,
 }
 
 impl Solver {
@@ -80,7 +80,7 @@ impl Solver {
         let uni_v3_quoter_v2 = match config.uni_v3_node_url {
             Some(url) => {
                 let web3 = ethrpc::web3(Default::default(), &url, Some("baseline"));
-                contracts::alloy::UniswapV3QuoterV2::Instance::deployed(&web3.provider)
+                contracts::UniswapV3QuoterV2::Instance::deployed(&web3.provider)
                     .await
                     .map(Arc::new)
                     .inspect_err(|err| {
diff --git a/crates/solvers/src/infra/config/dex/file.rs b/crates/solvers/src/infra/config/dex/file.rs
index 7e9bbb1dce..c88f216940 100644
--- a/crates/solvers/src/infra/config/dex/file.rs
+++ b/crates/solvers/src/infra/config/dex/file.rs
@@ -150,10 +150,8 @@ pub async fn load<T: DeserializeOwned>(path: &Path) -> (super::Config, T) {
         let authenticator =
             {
                 let web3 = blockchain::rpc(&config.node_url);
-                let settlement = ::contracts::alloy::GPv2Settlement::Instance::new(
-                    settlement,
-                    web3.provider.clone(),
-                );
+                let settlement =
+                    ::contracts::GPv2Settlement::Instance::new(settlement, web3.provider.clone());
                 settlement.authenticator().call().await.unwrap_or_else(|e| {
                     panic!("error reading authenticator contract address: {e:?}")
                 })
diff --git a/crates/solvers/src/infra/contracts.rs b/crates/solvers/src/infra/contracts.rs
index 0df89afe11..8f4cd3abf0 100644
--- a/crates/solvers/src/infra/contracts.rs
+++ b/crates/solvers/src/infra/contracts.rs
@@ -2,7 +2,7 @@ use {
     crate::domain::eth,
     alloy::primitives::Address,
     chain::Chain,
-    contracts::alloy::{GPv2AllowListAuthentication, GPv2Settlement, WETH9},
+    contracts::{GPv2AllowListAuthentication, GPv2Settlement, WETH9},
 };
 
 #[derive(Clone, Debug)]
diff --git a/crates/solvers/src/infra/dex/simulator.rs b/crates/solvers/src/infra/dex/simulator.rs
index d154744728..6ce7046e5d 100644
--- a/crates/solvers/src/infra/dex/simulator.rs
+++ b/crates/solvers/src/infra/dex/simulator.rs
@@ -8,7 +8,7 @@ use {
         providers::DynProvider,
         rpc::types::state::{AccountOverride, StateOverridesBuilder},
     },
-    contracts::alloy::support::{
+    contracts::support::{
         AnyoneAuthenticator,
         Swapper::{
             self,
diff --git a/crates/token-info/src/lib.rs b/crates/token-info/src/lib.rs
index 71891f5638..19c053b8a2 100644
--- a/crates/token-info/src/lib.rs
+++ b/crates/token-info/src/lib.rs
@@ -2,7 +2,7 @@ use {
     alloy_primitives::Address,
     anyhow::Result,
     async_trait::async_trait,
-    contracts::alloy::ERC20,
+    contracts::ERC20,
     ethrpc::{Web3, alloy::errors::ignore_non_node_error},
     futures::{
         FutureExt,

From 0ea7a77ddbe29be6bf7bcf839a6c77fd2e996f45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Thu, 9 Apr 2026 09:56:15 +0100
Subject: [PATCH 189/219] docs: add onboarding diagrams and entrypoints (#4311)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Addresses review feedback on #4296.

New contributors need a single place to see how orderbook, autopilot,
driver, solvers, Postgres, and the chain fit together, plus where to
open the codebase for each area. This PR adds `docs/ONBOARDING.md` with
Mermaid diagrams and practical code entrypoints, and links it from
`README.md`.

# Changes

* Add `docs/ONBOARDING.md`: system context diagram, order→auction→settle
sequence diagram, service responsibilities diagram, DB mental model
diagram
* Add "Where to start reading code" with entrypoints pointing to
`run.rs` for each service (orderbook, autopilot, driver, solvers,
contracts, database)
* Add solver types section explaining colocated vs non-colocated
distinction
* Add local development quick-start (playground with `ETH_RPC_URL` note,
cargo check/nextest, formatting)
* Add debugging section linking to `COW_ORDER_DEBUG_SKILL.md`
* Update `README.md` with a link to `docs/ONBOARDING.md`

## How to test

1. Open `docs/ONBOARDING.md` on GitHub and confirm all Mermaid blocks
render (context flowchart, sequence diagram, responsibilities flowchart,
DB flowchart)
2. Click links to `playground/README.md`, `database/README.md`, and
`COW_ORDER_DEBUG_SKILL.md` and confirm they resolve
3. Open `README.md` and confirm the new onboarding link points to
`./docs/ONBOARDING.md`
---
 README.md          |   2 +
 docs/ONBOARDING.md | 205 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 207 insertions(+)
 create mode 100644 docs/ONBOARDING.md

diff --git a/README.md b/README.md
index 84316c85fd..bcc18a0841 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,8 @@
 
 This repository contains backend code for [Cow Protocol Services](https://docs.cow.fi/) written in Rust.
 
+New to the repo? Start with the architecture + flow diagrams in [`docs/ONBOARDING.md`](./docs/ONBOARDING.md), then run the stack locally via the [`playground`](./playground/README.md).
+
 ## Order Book
 
 The `orderbook` crate provides the http api through which users (usually through a frontend web application) interact with the order book.
diff --git a/docs/ONBOARDING.md b/docs/ONBOARDING.md
new file mode 100644
index 0000000000..77d24b3d85
--- /dev/null
+++ b/docs/ONBOARDING.md
@@ -0,0 +1,205 @@
+# Onboarding: CoW Protocol Services (this repo)
+
+This repository is a Rust workspace containing the core backend services that run the CoW Protocol off-chain system:
+
+- Users submit **signed orders** to the **orderbook**
+- **autopilot** periodically creates **auctions** and sends them to **drivers**
+- Each **driver** calls its **solver(s)** for solutions, then simulates + submits the winner to the on-chain **Settlement** contract
+
+For local end-to-end development, use the playground stack. See `playground/README.md`.
+
+## System context (big picture)
+
+```mermaid
+flowchart LR
+  U["User / Wallet"] -->|signed order| OB["orderbook"]
+  UI["CoW Swap UI"] -->|quotes / orders| OB
+  OB <--> DB[("PostgreSQL")]
+  AP["autopilot"] <--> DB
+  AP -->|auction| DR["driver"]
+  AP -->|auction| CO["colocated solvers\n(own driver + solver)"]
+
+  DR -->|auction request| IS["internal solvers"]
+  DR -->|auction request| ES["external solver APIs"]
+
+  DR -->|simulate + submit tx| CH[("EVM chain\n+ Settlement contract")]
+  CO -->|submit tx| CH
+  AP -->|index events| CH
+```
+
+## Core "happy path" flow (order → auction → settlement)
+
+```mermaid
+sequenceDiagram
+  autonumber
+  participant User
+  participant Orderbook as orderbook
+  participant DB as Postgres
+  participant Autopilot as autopilot
+  participant Driver as driver
+  participant Solver as solver(s)
+  participant Chain as EVM chain + Settlement contract
+
+  User->>Orderbook: GET /quote (fee + price estimate)
+  Orderbook-->>User: quote response
+  User->>Orderbook: POST /orders (signed order)
+  Orderbook->>Orderbook: validate (signature, app-data, funding/approval, etc.)
+  Orderbook->>DB: persist order + order events
+  Orderbook-->>User: 201 Created (order uid)
+
+  loop every new block (~12s on mainnet)
+    Autopilot->>DB: fetch eligible orders + state
+    Autopilot->>Autopilot: apply policies (fees, filtering, scoring inputs)
+    Autopilot->>DB: store current auction + competition metadata
+    Autopilot->>Driver: send auction (or make it available for fetch)
+
+    Driver->>Solver: request solution(s) for auction
+    Solver-->>Driver: proposed solution(s)
+    Driver->>Driver: encode calldata + simulate
+    Driver-->>Autopilot: submit bid(s)
+    Autopilot->>Autopilot: rank bids, pick winner
+    Autopilot->>Driver: tell winner to execute
+    Driver->>Chain: submit transaction (time-bounded)
+    Chain-->>Chain: execute settle(...) + emit events
+    Autopilot->>Chain: fetch + index relevant events
+    Autopilot->>DB: update competition/settlement tables + order events
+  end
+```
+
+## Solver types
+
+- **Colocated**: External partners run their own driver + solver. Autopilot sends them the auction and they submit solutions independently. Full control, full responsibility.
+- **Non-colocated**: We run the driver, configured with their solver API endpoint. We handle simulation and submission on their behalf.
+
+## Responsibilities by service (what to touch for what change)
+
+```mermaid
+flowchart TB
+  subgraph OB["orderbook"]
+    OB1["HTTP API: orders, quotes, status"]
+    OB2["Validations: signatures, app-data, funding/approval checks"]
+    OB3["Persists orders + lifecycle events"]
+  end
+
+  subgraph AP["autopilot"]
+    AP1["Auction cutting: boundaries + inclusion"]
+    AP2["Filtering + fee policies + scoring inputs"]
+    AP3["Event indexing + competition metadata"]
+  end
+
+  subgraph DR["driver"]
+    DR1["Receive auction + fetch liquidity context"]
+    DR2["Call internal/external solvers"]
+    DR3["Encode solution to calldata, simulate"]
+    DR4["Submit tx, manage retries/time window"]
+  end
+
+  subgraph S["solvers"]
+    S1["Pure routing/matching math"]
+    S2["Return solution objects/calldata recipe"]
+  end
+
+  subgraph DBL["database layer"]
+    DBL1["migrations + schema"]
+    DBL2["typed query helpers used by services"]
+  end
+
+  AP --> DR
+  OB --> DBL
+  AP --> DBL
+  DR --> S
+```
+
+## Key crates (where shared logic lives)
+
+- `crates/shared`: common utilities (order quoting/validation, fee logic, external prices, argument parsing)
+- `crates/price-estimation`: price estimation strategies (onchain, trade-based, native)
+- `crates/gas-price-estimation`: gas price estimation
+- `crates/database`: schema + DB helpers used by `orderbook` and `autopilot`
+- `crates/model`: API/data model types used across services
+- `crates/contracts`: Alloy-based contract bindings for on-chain interaction
+- `crates/ethrpc` + `crates/chain`: Ethereum RPC / chain interaction helpers
+- `crates/observe`: logging/metrics initialization helpers
+- `crates/app-data`: order app-data validation
+
+## Where to start reading code (practical entrypoints)
+
+Each service follows the same pattern: `main.rs` just sets up the allocator and calls `start()`, which lives in `run.rs`. The `run.rs` file parses CLI arguments, initializes logging/metrics, connects to the database and/or chain, and wires up the service components.
+
+- **Orderbook (HTTP API + order validation)**
+  - Start here: `crates/orderbook/src/run.rs` (initialization + service wiring)
+  - Typical changes: API endpoints, order validation, quoting, DB writes
+
+- **Autopilot (auction creation + policies + event indexing)**
+  - Start here: `crates/autopilot/src/run.rs`
+  - Typical changes: auction filtering/inclusion, fee policies, competition persistence, chain event indexing
+
+- **Driver (simulation + settlement submission + solver integration)**
+  - Start here: `crates/driver/README.md` for context, then `crates/driver/src/run.rs`
+  - Typical changes: solver API integration, encoding/calldata, simulation logic, submission strategy
+
+- **Solvers (internal solver engines)**
+  - Start here: `crates/solvers/src/run.rs`
+  - Typical changes: routing/matching math, solution generation
+
+- **On-chain bindings**
+  - Start here: `crates/contracts/README.md`
+  - Typical changes: adding new contract artifacts/bindings, updating ABIs, exposing bindings in `lib.rs`
+
+- **Database schema + migrations**
+  - Start here: `database/README.md` (schema overview) and `crates/database` (query code)
+
+- **End-to-end tests**
+  - Start here: `crates/e2e/tests/e2e/` (individual test scenarios) and `crates/e2e/src/setup/` (test harness)
+  - The e2e crate spins up a local Anvil node (optionally forking mainnet/Gnosis), deploys contracts, starts services (orderbook, autopilot, driver, solver), and runs full order→settlement flows
+  - Tests are split into `local_node` (clean chain) and `forked_node` (forking a real network via `FORK_URL_MAINNET` / `FORK_URL_GNOSIS`)
+  - Run local e2e tests: `cargo nextest run -p e2e local_node --test-threads 1 --failure-output final --run-ignored ignored-only`
+  - Run forked e2e tests: `cargo nextest run -p e2e forked_node --test-threads 1 --run-ignored ignored-only --failure-output final`
+
+## Local development (recommended path)
+
+### Run the full stack (best for onboarding)
+
+See `playground/README.md`. The short version is:
+
+```bash
+docker compose -f playground/docker-compose.fork.yml up --build
+```
+
+You'll need to set `ETH_RPC_URL` in `playground/.env` first (an Ethereum RPC endpoint for anvil to fork from). This starts a forked chain + Postgres + services + UI/Explorer components with live-reload behavior.
+
+### Fast local compile / test loop (without running the stack)
+
+- **Check**:
+
+```bash
+cargo check --workspace --all-targets
+```
+
+- **Unit tests (CI-compatible runner)**:
+
+```bash
+cargo nextest run
+```
+
+### Formatting and linting
+
+This repo formats Rust code with nightly rustfmt (and TOML with Tombi). See `README.md` for the `just` commands.
+
+## Database mental model (what’s in Postgres)
+
+The DB stores orders, auctions, competitions, and indexed on-chain events.
+
+- For a guided schema overview, see `database/README.md`.
+
+```mermaid
+flowchart LR
+  OB["orderbook"] -->|orders + order_events + quotes| DB[("Postgres")]
+  AP["autopilot"] -->|auctions + competitions + event-derived tables| DB
+  AP -->|fetch + index chain events| CH[("chain")]
+```
+
+## Debugging "why didn’t my order trade"?
+
+When you need to investigate an order lifecycle end-to-end (API → DB → logs → auction inclusion → solver bids → settlement),
+see [`COW_ORDER_DEBUG_SKILL.md`](./COW_ORDER_DEBUG_SKILL.md).

From 1af5aa64cee8ad0d3b2a866dfd69028ecefba49a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Thu, 9 Apr 2026 10:02:04 +0100
Subject: [PATCH 190/219] Add a timeout to balance override detection (#4317)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Balance override detection can stall the quote pipeline when probing
certain tokens. Reflection tokens (e.g. LuckyBlock) implement
`balanceOf` by iterating over a storage array in `_getReflectionRate()`.
During strategy verification, we override storage slots with a test
value — if that value lands on an array-length slot, the EVM loops until
the node's execution timeout.

This adds a configurable timeout around the full `detect()` call in
`cached_detection` to prevent slow tokens from blocking quote
processing. The default is 1 second.

# Changes

* Add `detection_timeout` field to `BalanceOverrides` with a default of
1s
* Wrap `detector.detect()` in `tokio::time::timeout` inside
`cached_detection`, treating timeouts as `DetectionError::NotFound`
(which gets cached to avoid retrying)
* Add `detection-timeout-secs` config field to `BalanceOverridesConfig`
so the timeout is tunable per deployment

## How to test

Staging

---

<details><summary>Before applying this</summary>
<p>

```
jmgduarte@unknown5e8ed84873b2 ~/D/c/infrastructure (staging)> time curl --location 'https://barn.api.cow.fi/bnb/api/v1/quote' \
                                                                  --header 'Content-Type: application/json' \
                                                                  --data '{
                                                                  "sellToken": "0x2cd96e8c3ff6b5e01169f6e3b61d28204e7810bb",
                                                                  "buyToken": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                                                                  "from": "0x4EF880525383ab4E3d94b7689e3146bF899A296e",
                                                                  "receiver": "0x4EF880525383ab4E3d94b7689e3146bF899A296e",
                                                                  "sellAmountBeforeFee": "243443381571330",
                                                                  "kind": "sell",
                                                                  "priceQuality": "optimal",
                                                                  "validFor": 300,
                                                                  "appData": "{\"appCode\":\"OneKey CowSwap\",\"environment\":\"production\",\"metadata\":{\"orderClass\":{\"orderClass\":\"market\"},\"partnerFee\":{\"recipient\":\"0x09DDb1031A31Ac82Ef276AB8Ea67c0941ef27c02\",\"volumeBps\":30},\"quote\":{\"slippageBips\":62,\"smartSlippage\":false},\"referrer\":{\"address\":\"0x09DDb1031A31Ac82Ef276AB8Ea67c0941ef27c02\"}},\"version\":\"1.6.0\"}",
                                                                  "appDataHash": "0x8bc9701f53009567e798a5b879ca06aa849e4b10ada621b7f2d147f9e411d4d8",
                                                                  "timeout":6000
                                                              }'
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML><HEAD><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
<TITLE>ERROR: The request could not be satisfied</TITLE>
</HEAD><BODY>
<H1>504 Gateway Timeout ERROR</H1>
<H2>The request could not be satisfied.</H2>
<HR noshade size="1px">
We can't connect to the server for this app or website at this time. There might be too much traffic or a configuration error. Try again later, or contact the app or website owner.
<BR clear="all">
If you provide content to customers through CloudFront, you can find steps to troubleshoot and help prevent this error by reviewing the CloudFront documentation.
<BR clear="all">
<HR noshade size="1px">
<PRE>
Generated by cloudfront (CloudFront) HTTP3 Server
Request ID: R7hFhywd1QB3QiA7xso829L_FErAgjEvZXCpY3fNa_SGX19Flxfq4g&#x3D;&#x3D;
</PRE>
<ADDRESS>
</ADDRESS>
</BODY></HTML>
________________________________________________________
Executed in   30.20 secs      fish           external
   usr time   16.68 millis    0.41 millis   16.28 millis
   sys time   15.25 millis    1.99 millis   13.27 millis
```

</p>
</details>

<details><summary>After applying this</summary>
<p>

```
jmgduarte@unknown5e8ed84873b2 ~/D/c/infrastructure (staging)> time curl --location 'https://barn.api.cow.fi/bnb/api/v1/quote' \
                                                                  --header 'Content-Type: application/json' \
                                                                  --data '{
                                                                  "sellToken": "0x2cd96e8c3ff6b5e01169f6e3b61d28204e7810bb",
                                                                  "buyToken": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                                                                  "from": "0x4EF880525383ab4E3d94b7689e3146bF899A296e",
                                                                  "receiver": "0x4EF880525383ab4E3d94b7689e3146bF899A296e",
                                                                  "sellAmountBeforeFee": "243443381571330",
                                                                  "kind": "sell",
                                                                  "priceQuality": "optimal",
                                                                  "validFor": 300,                                                                                                              "appData": "{\"appCode\":\"OneKey CowSwap\",\"environment\":\"production\",\"metadata\":{\"orderClass\":{\"orderClass\":\"market\"},\"partnerFee\":{\"recipient\":\"0x09DDb1031A31Ac82Ef276AB8Ea67c0941ef27c02\",\"volumeBps\":30},\"quote\":{\"slippageBips\":62,\"smartSlippage\":false},\"referrer\":{\"address\":\"0x09DDb1031A31Ac82Ef276AB8Ea67c0941ef27c02\"}},\"version\":\"1.6.0\"}",                                                                                                                          "appDataHash": "0x8bc9701f53009567e798a5b879ca06aa849e4b10ada621b7f2d147f9e411d4d8",
                                                                  "timeout":6000
                                                              }'
{"quote":{"sellToken":"0x2cd96e8c3ff6b5e01169f6e3b61d28204e7810bb","buyToken":"0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee","receiver":"0x4ef880525383ab4e3d94b7689e3146bf899a296e","sellAmount":"101408548709609","buyAmount":"19632333521561","validTo":1775660168,"appData":"{\"appCode\":\"OneKey CowSwap\",\"environment\":\"production\",\"metadata\":{\"orderClass\":{\"orderClass\":\"market\"},\"partnerFee\":{\"recipient\":\"0x09DDb1031A31Ac82Ef276AB8Ea67c0941ef27c02\",\"volumeBps\":30},\"quote\":{\"slippageBips\":62,\"smartSlippage\":false},\"referrer\":{\"address\":\"0x09DDb1031A31Ac82Ef276AB8Ea67c0941ef27c02\"}},\"version\":\"1.6.0\"}","appDataHash":"0x8bc9701f53009567e798a5b879ca06aa849e4b10ada621b7f2d147f9e411d4d8","feeAmount":"142034832861721","gasAmount":"235614","gasPrice":"52500001","sellTokenPrice":"0.0870894483162219235072853962265071459114551544189453125","kind":"sell","partiallyFillable":false,"sellTokenBalance":"erc20","buyTokenBalance":"erc20","signingScheme":"eip712"},"from":"0x4ef880525383ab4e3d94b7689e3146bf899a296e","expiration":"2026-04-08T14:53:08.775181109Z","id":24317,"verified":false,"protocolFeeBps":"2"}
________________________________________________________
Executed in    1.51 secs      fish           external
   usr time   14.70 millis    1.25 millis   13.45 millis
   sys time   12.12 millis    3.78 millis    8.34 millis
```


</p>
</details>
---
 crates/balance-overrides/Cargo.toml           |  1 +
 crates/balance-overrides/src/detector.rs      | 54 ++++++++++++++-----
 crates/balance-overrides/src/lib.rs           |  6 +--
 crates/configs/src/price_estimation.rs        | 12 +++++
 crates/e2e/tests/e2e/quote_verification.rs    |  6 ++-
 .../src/config/price_estimation.rs            |  6 ++-
 6 files changed, 67 insertions(+), 18 deletions(-)

diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
index 127187e892..cd97be3fdf 100644
--- a/crates/balance-overrides/Cargo.toml
+++ b/crates/balance-overrides/Cargo.toml
@@ -24,6 +24,7 @@ contracts = { workspace = true }
 ethrpc = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
+tokio = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
diff --git a/crates/balance-overrides/src/detector.rs b/crates/balance-overrides/src/detector.rs
index 6a11b1109f..5dacf85c35 100644
--- a/crates/balance-overrides/src/detector.rs
+++ b/crates/balance-overrides/src/detector.rs
@@ -16,10 +16,13 @@ use {
         collections::HashMap,
         fmt::{self, Debug, Formatter},
         sync::Arc,
+        time::Duration,
     },
     thiserror::Error,
 };
 
+pub const DEFAULT_VERIFICATION_TIMEOUT: Duration = Duration::from_secs(1);
+
 // These are the solady magic bytes for user balances, with padding
 // https://github.com/Vectorized/solady/blob/main/src/tokens/ERC20.sol#L81
 const SOLADY_MAGIC_BYTES: &[u8] = &[
@@ -44,6 +47,7 @@ pub struct Detector(Arc<Inner>);
 pub struct Inner {
     probing_depth: u8,
     web3: ethrpc::Web3,
+    verification_timeout: Duration,
 }
 
 impl std::ops::Deref for Detector {
@@ -112,10 +116,11 @@ fn create_strategies_from_slots(
 
 impl Detector {
     /// Creates a new balance override detector.
-    pub fn new(web3: ethrpc::Web3, probing_depth: u8) -> Self {
+    pub fn new(web3: ethrpc::Web3, probing_depth: u8, verification_timeout: Duration) -> Self {
         Self(Arc::new(Inner {
             web3,
             probing_depth,
+            verification_timeout,
         }))
     }
 
@@ -192,16 +197,39 @@ impl Detector {
             .take(self.probing_depth.into())
             .enumerate()
         {
-            if self.verify_strategy(token, holder, strategy).await.is_ok() {
-                tracing::debug!(
-                    ?token,
-                    ?holder,
-                    ?strategy,
-                    iterations = i + 1,
-                    total = storage_slots.len(),
-                    "verified balance strategy via testing",
-                );
-                return Ok(strategy.clone());
+            // Some tokens (e.g. reflection tokens like LuckyBlock) have
+            // `balanceOf` implementations that iterate over storage arrays.
+            // During verification we override storage slots with a test value —
+            // if that value lands on an array-length slot the EVM loops until
+            // the node's execution timeout. A per-strategy timeout prevents one
+            // slow slot from blocking the entire detection.
+            let result = tokio::time::timeout(
+                self.verification_timeout,
+                self.verify_strategy(token, holder, strategy),
+            )
+            .await;
+
+            match result {
+                Ok(Ok(())) => {
+                    tracing::debug!(
+                        ?token,
+                        ?holder,
+                        ?strategy,
+                        iterations = i + 1,
+                        total = storage_slots.len(),
+                        "verified balance strategy via testing",
+                    );
+                    return Ok(strategy.clone());
+                }
+                Err(_) => {
+                    tracing::warn!(
+                        ?token,
+                        ?holder,
+                        ?strategy,
+                        "balance override strategy verification timed out, skipping",
+                    );
+                }
+                Ok(Err(_)) => {}
             }
         }
 
@@ -358,7 +386,7 @@ mod tests {
     #[ignore]
     #[tokio::test]
     async fn detects_storage_slots_mainnet() {
-        let detector = Detector::new(Web3::new_from_env(), 60);
+        let detector = Detector::new(Web3::new_from_env(), 60, DEFAULT_VERIFICATION_TIMEOUT);
 
         let storage = detector
             .detect(
@@ -411,7 +439,7 @@ mod tests {
     #[ignore]
     #[tokio::test]
     async fn detects_storage_slots_arbitrum() {
-        let detector = Detector::new(Web3::new_from_env(), 60);
+        let detector = Detector::new(Web3::new_from_env(), 60, DEFAULT_VERIFICATION_TIMEOUT);
 
         // all bridged tokens on arbitrum require a ton of probing
         let storage = detector
diff --git a/crates/balance-overrides/src/lib.rs b/crates/balance-overrides/src/lib.rs
index c6c3077334..8dcb97e638 100644
--- a/crates/balance-overrides/src/lib.rs
+++ b/crates/balance-overrides/src/lib.rs
@@ -112,7 +112,7 @@ impl BalanceOverrides {
         Self {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(web3, 60),
+                Detector::new(web3, 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
                 Mutex::new(SizedCache::with_size(1000)),
             )),
         }
@@ -372,7 +372,7 @@ mod tests {
         let balance_overrides = BalanceOverrides {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(mock_web3, 60),
+                Detector::new(mock_web3, 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
                 Mutex::new(SizedCache::with_size(100)),
             )),
         };
@@ -420,7 +420,7 @@ mod tests {
         let balance_overrides = BalanceOverrides {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(mock_web3, 60),
+                Detector::new(mock_web3, 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
                 Mutex::new(SizedCache::with_size(100)),
             )),
         };
diff --git a/crates/configs/src/price_estimation.rs b/crates/configs/src/price_estimation.rs
index 773fe73bb2..0be549bf3b 100644
--- a/crates/configs/src/price_estimation.rs
+++ b/crates/configs/src/price_estimation.rs
@@ -211,6 +211,10 @@ const fn default_cache_size() -> usize {
     1000
 }
 
+fn default_detection_timeout() -> Duration {
+    Duration::from_secs(1)
+}
+
 #[derive(Debug, Deserialize)]
 #[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
@@ -235,6 +239,13 @@ pub struct BalanceOverridesConfig {
     /// balance override detection before evicting less used entries.
     #[serde(default = "default_cache_size")]
     pub cache_size: usize,
+
+    /// Maximum time to wait for each balance override strategy verification
+    /// before giving up. Some tokens (e.g. reflection tokens) can cause the
+    /// node to loop during verification, so this prevents stalling the quote
+    /// pipeline.
+    #[serde(default = "default_detection_timeout", with = "humantime_serde")]
+    pub detection_timeout: Duration,
 }
 
 impl Default for BalanceOverridesConfig {
@@ -244,6 +255,7 @@ impl Default for BalanceOverridesConfig {
             autodetect: false,
             probing_depth: default_probing_depth(),
             cache_size: default_cache_size(),
+            detection_timeout: default_detection_timeout(),
         }
     }
 }
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index 1497e42645..a20d344ec4 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -638,7 +638,11 @@ async fn trace_based_balance_detection(web3: Web3) {
         .await
         .unwrap();
 
-    let detector = Detector::new(web3.clone(), 60);
+    let detector = Detector::new(
+        web3.clone(),
+        60,
+        balance_overrides::detector::DEFAULT_VERIFICATION_TIMEOUT,
+    );
 
     let test_account = address!("0000000000000000000000000000000000000042");
     let test_balance = U256::from(123_456_789_u64);
diff --git a/crates/price-estimation/src/config/price_estimation.rs b/crates/price-estimation/src/config/price_estimation.rs
index d54e2c1778..cf4c409cd5 100644
--- a/crates/price-estimation/src/config/price_estimation.rs
+++ b/crates/price-estimation/src/config/price_estimation.rs
@@ -14,7 +14,11 @@ impl BalanceOverridesConfigExt for BalanceOverridesConfig {
             hardcoded: self.token_overrides.inner().clone(),
             detector: self.autodetect.then(|| {
                 (
-                    balance_overrides::detector::Detector::new(web3, self.probing_depth),
+                    balance_overrides::detector::Detector::new(
+                        web3,
+                        self.probing_depth,
+                        self.detection_timeout,
+                    ),
                     std::sync::Mutex::new(cached::SizedCache::with_size(self.cache_size)),
                 )
             }),

From 1467ba02e812449dffe27bf7685b0109d3b2f512 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 9 Apr 2026 15:57:00 +0200
Subject: [PATCH 191/219] Generate tendery link on simulation (#4320)

# Description

The debug simulation endpoint (/api/v1/debug/simulation/{uid}) currently
returns a raw Tenderly API request object that you have to manually POST
to Tenderly to debug. This adds automatic submission + sharing so the
response includes a clickable tenderlyUrl link.

# Changes

- Add simulate_and_share to the Tenderly Api trait - submits a
simulation, shares it, and returns the public dashboard URL
- Refactor TenderlyApi to store api_base URL instead of the full
/simulate endpoint, appending paths as needed
- Add optional tenderly config to OrderSimulationConfig - when set,
simulations are auto-submitted
- Return tenderlyUrl field in OrderSimulationResult (omitted from JSON
when Tenderly is not configured)

## How to test

I ran the orderbook locally with tenderly config, hit the API and got a
tenderly link.
---
 crates/configs/src/orderbook/mod.rs     |  7 ++++
 crates/orderbook/src/dto/mod.rs         |  4 +++
 crates/orderbook/src/order_simulator.rs | 21 +++++++++++-
 crates/orderbook/src/run.rs             |  9 +++++
 crates/simulator/src/tenderly/mod.rs    | 45 +++++++++++++++++++------
 5 files changed, 75 insertions(+), 11 deletions(-)

diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index 225bd89619..5362370643 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -53,6 +53,12 @@ pub struct VolumeFeeConfig {
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct OrderSimulationConfig {
     pub gas_limit: U256,
+
+    /// Optional Tenderly configuration. When set, simulations are automatically
+    /// submitted and shared on Tenderly, and the response includes a dashboard
+    /// URL.
+    #[serde(default)]
+    pub tenderly: Option<crate::simulator::TenderlyConfig>,
 }
 
 /// Top-level orderbook service configuration.
@@ -216,6 +222,7 @@ pub mod test_util {
                 // Enable order simulation for testing
                 order_simulation: Some(OrderSimulationConfig {
                     gas_limit: U256::try_from(16777215).expect("u64 can be converted to U256"),
+                    tenderly: None,
                 }),
             }
         }
diff --git a/crates/orderbook/src/dto/mod.rs b/crates/orderbook/src/dto/mod.rs
index bb856b87fe..9c14e3e259 100644
--- a/crates/orderbook/src/dto/mod.rs
+++ b/crates/orderbook/src/dto/mod.rs
@@ -57,9 +57,13 @@ pub struct OrderSimulationRequest {
 /// and full Tenderly API request that can be used to resimulate
 /// and debug using Tenderly
 #[derive(Clone, Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
 pub struct OrderSimulationResult {
     /// Full request object that can be used directly with the Tenderly API
     pub tenderly_request: tenderly::dto::Request,
+    /// Shared Tenderly simulation URL for debugging in the dashboard
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tenderly_url: Option<String>,
     /// Any error that might have been reported during order simulation
     pub error: Option<String>,
 }
diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
index 8cdc7ab4df..b87fe17936 100644
--- a/crates/orderbook/src/order_simulator.rs
+++ b/crates/orderbook/src/order_simulator.rs
@@ -15,11 +15,13 @@ use {
     simulator::{
         encoding::InteractionEncoding,
         swap_simulator::{EncodedSwap, Query, SwapSimulator, TradeEncoding},
+        tenderly,
     },
     thiserror::Error,
 };
 pub struct OrderSimulator {
     simulator: SwapSimulator,
+    tenderly: Option<Box<dyn tenderly::Api>>,
     chain_id: String,
 }
 
@@ -32,9 +34,14 @@ pub enum Error {
 }
 
 impl OrderSimulator {
-    pub fn new(simulator: SwapSimulator, chain_id: String) -> Self {
+    pub fn new(
+        simulator: SwapSimulator,
+        chain_id: String,
+        tenderly: Option<Box<dyn tenderly::Api>>,
+    ) -> Self {
         Self {
             simulator,
+            tenderly,
             chain_id,
         }
     }
@@ -174,8 +181,20 @@ impl OrderSimulator {
             .map_err(|err| Error::Other(anyhow!(err)))?
         };
 
+        let tenderly_url = match &self.tenderly {
+            Some(api) => match api.simulate_and_share(tenderly_request.clone()).await {
+                Ok(url) => Some(url),
+                Err(err) => {
+                    tracing::warn!(?err, "failed to create Tenderly simulation");
+                    None
+                }
+            },
+            None => None,
+        };
+
         Ok(OrderSimulationResult {
             tenderly_request,
+            tenderly_url,
             error: result.result.err().map(|err| err.to_string()),
         })
     }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index da0e6b852b..68b4fcd307 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -412,6 +412,14 @@ pub async fn run(config: Configuration) {
     ));
 
     let order_simulator = if let Some(config) = config.order_simulation {
+        let tenderly: Option<Box<dyn simulator::tenderly::Api>> =
+            config.tenderly.as_ref().map(|tenderly_config| {
+                Box::new(simulator::tenderly::TenderlyApi::new(
+                    tenderly_config,
+                    &http_factory,
+                    chain.id().to_string(),
+                )) as _
+            });
         Some(Arc::new(OrderSimulator::new(
             SwapSimulator::new(
                 balance_overrider.clone(),
@@ -427,6 +435,7 @@ pub async fn run(config: Configuration) {
             .await
             .expect("failed to create SwapSimulator"),
             chain.id().to_string(),
+            tenderly,
         )))
     } else {
         None
diff --git a/crates/simulator/src/tenderly/mod.rs b/crates/simulator/src/tenderly/mod.rs
index 2ada00ae06..fe6c55d66d 100644
--- a/crates/simulator/src/tenderly/mod.rs
+++ b/crates/simulator/src/tenderly/mod.rs
@@ -31,7 +31,9 @@ pub struct Tenderly {
 
 #[derive(Debug, Clone)]
 pub struct TenderlyApi {
-    simulation_endpoint: Url,
+    /// Base URL for the Tenderly API project, e.g.
+    /// `https://api.tenderly.co/api/v1/account/{user}/project/{project}`
+    api_base: Url,
     client: reqwest::Client,
     dashboard: Url,
     chain_id: String,
@@ -47,6 +49,9 @@ pub trait Api: Send + Sync + 'static {
     ) -> Result<()>;
 
     async fn simulate(&self, request: dto::Request) -> Result<dto::Response>;
+
+    /// Submits a simulation, shares it, and returns the shared Tenderly URL.
+    async fn simulate_and_share(&self, request: dto::Request) -> Result<String>;
 }
 
 impl Tenderly {
@@ -111,8 +116,8 @@ impl TenderlyApi {
             "application/json".parse().unwrap(),
         );
         Self {
-            simulation_endpoint: Url::parse(&format!(
-                "{url}/v1/account/{user}/project/{project}/simulate",
+            api_base: Url::parse(&format!(
+                "{url}/v1/account/{user}/project/{project}/",
                 url = config
                     .url
                     .as_ref()
@@ -164,18 +169,15 @@ impl Api for TenderlyApi {
             save_if_fails: Some(true),
             ..prepare_request(self.chain_id.clone(), &tx, overrides, block)?
         };
-        log_simulation_request(&self.simulation_endpoint, &self.dashboard, request)
+        let simulate_url = crate::utils::join_url(&self.api_base, "simulate");
+        log_simulation_request(&simulate_url, &self.dashboard, request)
     }
 
     async fn simulate(&self, request: dto::Request) -> Result<dto::Response> {
         let body = serde_json::to_string(&request).map_err(|err| Error::Other(anyhow!(err)))?;
 
-        let response = self
-            .client
-            .post(self.simulation_endpoint.clone())
-            .body(body)
-            .send()
-            .await?;
+        let simulate_url = crate::utils::join_url(&self.api_base, "simulate");
+        let response = self.client.post(simulate_url).body(body).send().await?;
 
         let ok = response.error_for_status_ref().map(|_| ());
         let status = response.status();
@@ -188,6 +190,25 @@ impl Api for TenderlyApi {
 
         Ok(serde_json::from_str::<dto::Response>(&body)?)
     }
+
+    async fn simulate_and_share(&self, request: dto::Request) -> Result<String> {
+        let response = self.simulate(request).await?;
+        let id = &response.simulation.id;
+        self.share_simulation(id).await?;
+        Ok(shared_simulation_url(id))
+    }
+}
+
+impl TenderlyApi {
+    async fn share_simulation(&self, id: &str) -> Result<()> {
+        let url = crate::utils::join_url(&self.api_base, &format!("simulations/{id}/share"));
+        self.client.post(url).send().await?.error_for_status()?;
+        Ok(())
+    }
+}
+
+fn shared_simulation_url(id: &str) -> String {
+    format!("{DASHBOARD_URL}/shared/simulation/{id}")
 }
 
 pub fn prepare_request(
@@ -302,6 +323,10 @@ impl Api for Instrumented {
     ) -> Result<()> {
         self.inner.log_simulation_command(tx, overrides, block)
     }
+
+    async fn simulate_and_share(&self, request: dto::Request) -> Result<String> {
+        self.inner.simulate_and_share(request).await
+    }
 }
 
 #[derive(prometheus_metric_storage::MetricStorage)]

From befce9d07cee735d495f0bc06b4a1a40252ffda2 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Thu, 9 Apr 2026 19:48:19 +0100
Subject: [PATCH 192/219] [TRIVIAL] Pin Claude workflow actions to full commit
 SHAs (#4323)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Pin `actions/checkout` and `anthropics/claude-code-action` to full
commit SHAs in Claude workflow files, as required by the repo's action
policy.

- `actions/checkout@v4` →
`actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683` (v4.2.2)
- `anthropics/claude-code-action@v1` →
`anthropics/claude-code-action@e0f2d99545298b87c2f984ab534af3a6534142ae`
(v1)
---
 .github/workflows/claude-code-review.yml | 4 ++--
 .github/workflows/claude.yml             | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml
index feff389d73..2dc7b0fa7c 100644
--- a/.github/workflows/claude-code-review.yml
+++ b/.github/workflows/claude-code-review.yml
@@ -16,13 +16,13 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 1
 
       - name: Run Claude Code Review
         id: claude-review
-        uses: anthropics/claude-code-action@v1
+        uses: anthropics/claude-code-action@e0f2d99545298b87c2f984ab534af3a6534142ae # v1
         with:
           anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
           plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
index 79fe056478..4a7f25605e 100644
--- a/.github/workflows/claude.yml
+++ b/.github/workflows/claude.yml
@@ -26,13 +26,13 @@ jobs:
       actions: read # Required for Claude to read CI results on PRs
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 1
 
       - name: Run Claude Code
         id: claude
-        uses: anthropics/claude-code-action@v1
+        uses: anthropics/claude-code-action@e0f2d99545298b87c2f984ab534af3a6534142ae # v1
         with:
           anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 

From d0073a2b02243f05587b96100ce68fc2063cec13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Fri, 10 Apr 2026 10:53:53 +0100
Subject: [PATCH 193/219] [TRIVIAL] Redact IPFS auth_token in debug (#4325)

# Description
Fixes https://github.com/cowprotocol/services/issues/4310

This fixes the leakage by redacting the IPFS secret in the Debug
implementation.

# Changes

* Manually implement debug to redact IPFS token

## How to test
Added a test to ensure it doesn't break without us noticing
---
 crates/configs/src/orderbook/ipfs.rs | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/crates/configs/src/orderbook/ipfs.rs b/crates/configs/src/orderbook/ipfs.rs
index bc365ecdf5..6b710b8c1c 100644
--- a/crates/configs/src/orderbook/ipfs.rs
+++ b/crates/configs/src/orderbook/ipfs.rs
@@ -1,5 +1,6 @@
 use {
     serde::{Deserialize, Deserializer, Serialize},
+    std::fmt::Debug,
     url::Url,
 };
 
@@ -28,7 +29,7 @@ where
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct IpfsConfig {
     /// IPFS gateway to fetch full app data for orders that only specify the
@@ -40,10 +41,34 @@ pub struct IpfsConfig {
     pub auth_token: Option<String>,
 }
 
+impl Debug for IpfsConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("IpfsConfig")
+            .field("gateway", &self.gateway)
+            .field("auth_token", &"<REDACTED>")
+            .finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn auth_token_is_redacted() {
+        let config = IpfsConfig {
+            gateway: Url::parse("https://google.com").unwrap(),
+            auth_token: None,
+        };
+        assert!(format!("{:?}", config).contains(r#"auth_token: "<REDACTED>""#));
+
+        let config = IpfsConfig {
+            gateway: Url::parse("https://google.com").unwrap(),
+            auth_token: Some("SOME_TOKEN".to_string()),
+        };
+        assert!(format!("{:?}", config).contains(r#"auth_token: "<REDACTED>""#));
+    }
+
     #[test]
     fn deserialize_full() {
         let toml = r#"

From 9281fe1c1413fbb9f4ed9f9127c34fd036cba7f9 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 10 Apr 2026 18:04:01 +0100
Subject: [PATCH 194/219] Surface transfer simulation revert reasons in order
 creation API (#4321)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

- When order creation fails with `TransferSimulationFailed`, the API now
includes the actual revert reason (e.g. `0x5b263df7` =
`LtvValidationFailed()`) instead of the generic "sell token cannot be
transferred"
- Changed `Balances.sol` helper contract to capture revert bytes from
the `transferFromAccounts` try/catch block
- Threaded revert bytes through `Simulation` →
`TransferSimulationError::TransferFailed(Vec<u8>)` →
`ValidationError::TransferSimulationFailed(Vec<u8>)` → API error
description
- Deployed new Balances contract at
`0x88b4B74082BffB2976C306CB3f7E9093AE48B94F` on all chains (except Lens
which keeps the old deployment)
- Updated e2e forked test block numbers to include the new deployment

## Motivation

Aave aTokens (e.g. aBasUSDC) revert with `LtvValidationFailed()` when a
user has zero-LTV collateral blocking transfers. The current generic
error gives no indication of why the transfer fails, making it very
difficult to debug.

## API Change

Before:
```json
{"errorType": "TransferSimulationFailed", "description": "sell token cannot be transferred"}
```

After (when revert data available):
```json
{"errorType": "TransferSimulationFailed", "description": "sell token cannot be transferred, token reverted with: 0x5b263df7"}
```

The 4-byte selector can be decoded client-side (e.g. `cast 4byte
0x5b263df7` → `LtvValidationFailed()`).

## Changes

- **`contracts/solidity/Balances.sol`** — `catch` → `catch (bytes memory
reason)`, added `transferRevertReason` return value
- **`contracts/artifacts/Balances.json`** — Rebuilt with solc
- **`crates/account-balances/src/lib.rs`** — Added
`transfer_revert_reason` to `Simulation`, changed `TransferFailed` to
carry `Vec<u8>`, switched to `abi_decode_params` (required for dynamic
return types)
- **`crates/account-balances/src/simulation.rs`** — Pass revert bytes
into `TransferFailed`
- **`crates/shared/src/order_validation.rs`** — Thread `Vec<u8>` through
`TransferSimulationFailed`
- **`crates/orderbook/src/api/post_order.rs`** — Format revert selector
in error description
- **`contracts/src/main.rs`** — Updated Balances addresses to new
deployment `0x88b4B74082BffB2976C306CB3f7E9093AE48B94F`
- **`Justfile`** — Added formatting steps to `generate-contracts`
- **e2e forked tests** — Updated fork block numbers and whale addresses
for new deployment

## New Balances Deployment

Address `0x88b4B74082BffB2976C306CB3f7E9093AE48B94F` on: Mainnet,
Arbitrum, Base, Avalanche, BNB, Optimism, Polygon, Gnosis, Linea, Ink,
Sepolia, Plasma. And also Optimism, since we deployed everything there
already and in case we will add support for this chain sometime later.

Lens keeps the old address
(`0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b`), since it will be dropped
from the codebase in a follow-up PR.

## Test plan

- [x] Existing unit tests pass (account-balances, shared, orderbook)
- [x] Clippy clean
- [x] E2E local node tests pass
- [x] E2E forked node tests pass
- [ ] Manual test: submit order with aToken that has LTV-blocked
transfer, verify revert selector appears in error
---
 Justfile                                      | 14 +++--
 contracts/artifacts/Balances.json             |  9 ++-
 .../contracts-generated/balances/src/lib.rs   | 55 +++++++++++--------
 .../cowswapethflow/src/lib.rs                 |  4 --
 .../gpv2allowlistauthentication/src/lib.rs    |  4 --
 .../gpv2settlement/src/lib.rs                 |  4 --
 .../hookstrampoline/src/lib.rs                |  4 --
 .../iuniswapv3factory/src/lib.rs              |  4 --
 .../contracts-generated/signatures/src/lib.rs |  4 --
 .../uniswapv3quoterv2/src/lib.rs              |  4 --
 .../uniswapv3swaprouterv2/src/lib.rs          |  4 --
 .../contracts-generated/weth9/src/lib.rs      |  4 --
 contracts/solidity/Balances.sol               |  8 ++-
 contracts/src/main.rs                         | 34 ++++--------
 contracts/src/networks.rs                     |  1 -
 crates/account-balances/src/lib.rs            |  9 ++-
 crates/account-balances/src/simulation.rs     |  4 +-
 crates/e2e/tests/e2e/banned_users.rs          |  4 +-
 crates/e2e/tests/e2e/limit_orders.rs          |  4 +-
 crates/e2e/tests/e2e/liquidity.rs             |  2 +-
 .../e2e/liquidity_source_notification.rs      |  2 +-
 crates/e2e/tests/e2e/quote_verification.rs    |  2 +-
 crates/e2e/tests/e2e/wrapper.rs               |  2 +-
 crates/orderbook/src/api/post_order.rs        | 23 +++++---
 crates/shared/src/order_validation.rs         | 10 ++--
 25 files changed, 104 insertions(+), 115 deletions(-)

diff --git a/Justfile b/Justfile
index 1cebc4e575..a9156bda66 100644
--- a/Justfile
+++ b/Justfile
@@ -5,16 +5,20 @@ help:
 setup:
     cd contracts && \
     cargo r -r -- vendor && \
-    cargo r -r -- generate && \
-    cargo +nightly fmt --all && \
-    cd generated && cargo +nightly fmt --all && \
-    cd ../.. && \
-    tombi format
+    cargo r -r -- generate
+    just _format_generated_contracts
 
 # Generate contract bindings
 generate-contracts:
     cd contracts && \
     cargo r -r -- generate
+    just _format_generated_contracts
+
+_format_generated_contracts:
+    cd contracts && cargo +nightly fmt --all && \
+    cd generated && cargo +nightly fmt --all && \
+    cd ../.. && \
+    tombi format
 
 # Run unit tests
 test-unit:
diff --git a/contracts/artifacts/Balances.json b/contracts/artifacts/Balances.json
index 7bfb804785..08238348aa 100644
--- a/contracts/artifacts/Balances.json
+++ b/contracts/artifacts/Balances.json
@@ -88,14 +88,19 @@
           "internalType": "bool",
           "name": "canTransfer",
           "type": "bool"
+        },
+        {
+          "internalType": "bytes",
+          "name": "transferRevertReason",
+          "type": "bytes"
         }
       ],
       "stateMutability": "nonpayable",
       "type": "function"
     }
   ],
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "0x6080604052348015600e575f5ffd5b50610ef28061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063f88cf6db1461002d575b5f5ffd5b61004061003b366004610abe565b61005a565b604051610051959493929190610b83565b60405180910390f35b5f5f5f5f606061006b8c88886107b0565b7f5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc988036101c6576040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8c811660048301528b16906370a0823190602401602060405180830381865afa1580156100fc573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101209190610c0a565b60208d01516040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8e8116600483015291821660248201529196508b169063dd62ed3e906044015b602060405180830381865afa15801561019b573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101bf9190610c0a565b9350610604565b7fabee3b73373acd583a130924aad6dc38cfdc44ba0555ba94ce2ff63980ea06328803610389576040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8c811660048301528b16906370a0823190602401602060405180830381865afa158015610257573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061027b9190610c0a565b6040808e015160208f015191517ffec90d7200000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8f811660048301529283166024820152929750169063fec90d7290604401602060405180830381865afa1580156102f9573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061031d9190610c21565b610327575f6101bf565b60408c81015190517fdd62ed3e00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8d811660048301529182166024820152908b169063dd62ed3e90604401610180565b7f4ac99ace14ee0a5ef932dc609df0943ab7ac16b7583634612f8dc35a4289a6ce880361059d576040805160018082528183019092525f91602080830190803683370190505090508a815f815181106103e4576103e4610c47565b73ffffffffffffffffffffffffffffffffffffffff92831660209182029290920101526040808f015190517f0f5a6efa000000000000000000000000000000000000000000000000000000008152911690630f5a6efa9061044b908f908590600401610c74565b5f60405180830381865afa158015610465573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526104aa9190810190610ced565b5f815181106104bb576104bb610c47565b602002602001015195508c6040015173ffffffffffffffffffffffffffffffffffffffff1663fec90d728d8f602001516040518363ffffffff1660e01b815260040161052a92919073ffffffffffffffffffffffffffffffffffffffff92831681529116602082015260400190565b602060405180830381865afa158015610545573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105699190610c21565b610573575f610595565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b945050610604565b6040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f696e76616c696420746f6b656e20736f7572636500000000000000000000000060448201526064015b60405180910390fd5b838511156106125783610614565b845b6040805160018082528183019092529194505f9190816020015b604080516080810182525f8082526020808301829052928201819052606082015282527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90920191018161062e57905050905060405180608001604052808d73ffffffffffffffffffffffffffffffffffffffff1681526020018c73ffffffffffffffffffffffffffffffffffffffff1681526020018b5f036106d157856106d3565b8b5b81526020018a815250815f815181106106ee576106ee610c47565b60200260200101819052508c6020015173ffffffffffffffffffffffffffffffffffffffff16637d10d11f826040518263ffffffff1660e01b81526004016107369190610d99565b5f604051808303815f87803b15801561074d575f5ffd5b505af192505050801561075e575060015b61079b573d80801561078b576040519150601f19603f3d011682016040523d82523d5f602084013e610790565b606091505b505f935091506107a0565b600192505b5097509750975097509792505050565b825173ffffffffffffffffffffffffffffffffffffffff163014610830576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f696e636f72726563742063616c6c696e6720636f6e746578740000000000000060448201526064016105fb565b5f5b81811015610997575f83838381811061084d5761084d610c47565b905060200281019061085f9190610e2d565b61086d906020810190610e69565b90505f84848481811061088257610882610c47565b90506020028101906108949190610e2d565b602001359050365f8686868181106108ae576108ae610c47565b90506020028101906108c09190610e2d565b6108ce906040810190610e84565b91509150876020015173ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff160361096b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601b60248201527f475076323a20666f7262696464656e20696e746572616374696f6e000000000060448201526064016105fb565b604051818382375f5f838387895af1610986573d5f5f3e3d5ffd5b505060019093019250610832915050565b50505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516060810167ffffffffffffffff811182821017156109ed576109ed61099d565b60405290565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715610a3a57610a3a61099d565b604052919050565b73ffffffffffffffffffffffffffffffffffffffff81168114610a63575f5ffd5b50565b8035610a7181610a42565b919050565b5f5f83601f840112610a86575f5ffd5b50813567ffffffffffffffff811115610a9d575f5ffd5b6020830191508360208260051b8501011115610ab7575f5ffd5b9250929050565b5f5f5f5f5f5f5f878903610100811215610ad6575f5ffd5b6060811215610ae3575f5ffd5b50610aec6109ca565b8835610af781610a42565b81526020890135610b0781610a42565b60208201526040890135610b1a81610a42565b60408201529650610b2d60608901610a66565b9550610b3b60808901610a66565b945060a0880135935060c0880135925060e088013567ffffffffffffffff811115610b64575f5ffd5b610b708a828b01610a76565b989b979a50959850939692959293505050565b858152846020820152836040820152821515606082015260a060808201525f82518060a08401525f5b81811015610bc957602081860181015160c0868401015201610bac565b505f60c0828501015260c07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8301168401019150509695505050505050565b5f60208284031215610c1a575f5ffd5b5051919050565b5f60208284031215610c31575f5ffd5b81518015158114610c40575f5ffd5b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f6040820173ffffffffffffffffffffffffffffffffffffffff85168352604060208401528084518083526060850191506020860192505f5b81811015610ce157835173ffffffffffffffffffffffffffffffffffffffff16835260209384019390920191600101610cad565b50909695505050505050565b5f60208284031215610cfd575f5ffd5b815167ffffffffffffffff811115610d13575f5ffd5b8201601f81018413610d23575f5ffd5b805167ffffffffffffffff811115610d3d57610d3d61099d565b8060051b610d4d602082016109f3565b91825260208184018101929081019087841115610d68575f5ffd5b6020850194505b83851015610d8e57845180835260209586019590935090910190610d6f565b979650505050505050565b602080825282518282018190525f918401906040840190835b81811015610e2257835173ffffffffffffffffffffffffffffffffffffffff815116845273ffffffffffffffffffffffffffffffffffffffff6020820151166020850152604081015160408501526060810151606085015250608083019250602084019350600181019050610db2565b509095945050505050565b5f82357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa1833603018112610e5f575f5ffd5b9190910192915050565b5f60208284031215610e79575f5ffd5b8135610c4081610a42565b5f5f83357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112610eb7575f5ffd5b83018035915067ffffffffffffffff821115610ed1575f5ffd5b602001915036819003821315610ab7575f5ffdfea164736f6c634300081e000a",
+  "deployedBytecode": "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",
   "devdoc": {
     "methods": {}
   },
diff --git a/contracts/generated/contracts-generated/balances/src/lib.rs b/contracts/generated/contracts-generated/balances/src/lib.rs
index 56507b2c6b..0c4f3080f2 100644
--- a/contracts/generated/contracts-generated/balances/src/lib.rs
+++ b/contracts/generated/contracts-generated/balances/src/lib.rs
@@ -22,7 +22,7 @@ interface Balances {
         bytes callData;
     }
 
-    function balance(Contracts memory contracts, address trader, address token, uint256 amount, bytes32 source, Interaction[] memory interactions) external returns (uint256 tokenBalance, uint256 allowance, uint256 effectiveBalance, bool canTransfer);
+    function balance(Contracts memory contracts, address trader, address token, uint256 amount, bytes32 source, Interaction[] memory interactions) external returns (uint256 tokenBalance, uint256 allowance, uint256 effectiveBalance, bool canTransfer, bytes memory transferRevertReason);
 }
 ```
 
@@ -118,6 +118,11 @@ interface Balances {
         "name": "canTransfer",
         "type": "bool",
         "internalType": "bool"
+      },
+      {
+        "name": "transferRevertReason",
+        "type": "bytes",
+        "internalType": "bytes"
       }
     ],
     "stateMutability": "nonpayable"
@@ -136,22 +141,22 @@ pub mod Balances {
     /// The creation / init bytecode of the contract.
     ///
     /// ```text
-    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
+    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
     /// ```
     #[rustfmt::skip]
     #[allow(clippy::all)]
     pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x0EC\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xF8\x8C\xF6\xDB\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\n\x96V[a\0fV[`@\x80Q\x94\x85R` \x85\x01\x93\x90\x93R\x91\x83\x01R\x15\x15``\x82\x01R`\x80\x01`@Q\x80\x91\x03\x90\xF3[____a\0u\x8B\x87\x87a\x07\x88V[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x87\x03a\x01\xD0W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x06W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01*\x91\x90a\x0B[V[` \x8C\x01Q`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x91\x95P\x8A\x16\x90c\xDDb\xED>\x90`D\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xA5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xC9\x91\x90a\x0B[V[\x92Pa\x06\x0EV[\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x87\x03a\x03\x93W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02aW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\x85\x91\x90a\x0B[V[`@\x80\x8D\x01Q` \x8E\x01Q\x91Q\x7F\xFE\xC9\rr\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16`\x04\x83\x01R\x92\x83\x16`$\x82\x01R\x92\x96P\x16\x90c\xFE\xC9\rr\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03'\x91\x90a\x0BrV[a\x031W_a\x01\xC9V[`@\x8B\x81\x01Q\x90Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x90\x8A\x16\x90c\xDDb\xED>\x90`D\x01a\x01\x8AV[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x87\x03a\x05\xA7W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x89\x81_\x81Q\x81\x10a\x03\xEEWa\x03\xEEa\x0B\x98V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@\x80\x8E\x01Q\x90Q\x7F\x0FZn\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16\x90c\x0FZn\xFA\x90a\x04U\x90\x8E\x90\x85\x90`\x04\x01a\x0B\xC5V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04oW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x04\xB4\x91\x90\x81\x01\x90a\x0C>V[_\x81Q\x81\x10a\x04\xC5Wa\x04\xC5a\x0B\x98V[` \x02` \x01\x01Q\x94P\x8B`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFE\xC9\rr\x8C\x8E` \x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x054\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05OW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05s\x91\x90a\x0BrV[a\x05}W_a\x05\x9FV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[\x93PPa\x06\x0EV[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Finvalid token source\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x82\x84\x11\x15a\x06\x1CW\x82a\x06\x1EV[\x83[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x93P_\x91\x90\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x01\x91\x01\x81a\x068W\x90PP\x90P`@Q\x80`\x80\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A_\x03a\x06\xDBW\x84a\x06\xDDV[\x8A[\x81R` \x01\x89\x81RP\x81_\x81Q\x81\x10a\x06\xF8Wa\x06\xF8a\x0B\x98V[` \x02` \x01\x01\x81\x90RP\x8B` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c}\x10\xD1\x1F\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07@\x91\x90a\x0C\xEAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07WW__\xFD[PZ\xF1\x92PPP\x80\x15a\x07hWP`\x01[a\x07tW_\x91Pa\x07yV[`\x01\x91P[P\x97P\x97P\x97P\x97\x93PPPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x08\x08W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[_[\x81\x81\x10\x15a\toW_\x83\x83\x83\x81\x81\x10a\x08%Wa\x08%a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x087\x91\x90a\r~V[a\x08E\x90` \x81\x01\x90a\r\xBAV[\x90P_\x84\x84\x84\x81\x81\x10a\x08ZWa\x08Za\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08l\x91\x90a\r~V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x08\x86Wa\x08\x86a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08\x98\x91\x90a\r~V[a\x08\xA6\x90`@\x81\x01\x90a\r\xD5V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\tCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\t^W=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x08\n\x91PPV[PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC5Wa\t\xC5a\tuV[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\x12Wa\n\x12a\tuV[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\n;W__\xFD[PV[\x805a\nI\x81a\n\x1AV[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\n^W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nuW__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\n\x8FW__\xFD[\x92P\x92\x90PV[_______\x87\x89\x03a\x01\0\x81\x12\x15a\n\xAEW__\xFD[``\x81\x12\x15a\n\xBBW__\xFD[Pa\n\xC4a\t\xA2V[\x885a\n\xCF\x81a\n\x1AV[\x81R` \x89\x015a\n\xDF\x81a\n\x1AV[` \x82\x01R`@\x89\x015a\n\xF2\x81a\n\x1AV[`@\x82\x01R\x96Pa\x0B\x05``\x89\x01a\n>V[\x95Pa\x0B\x13`\x80\x89\x01a\n>V[\x94P`\xA0\x88\x015\x93P`\xC0\x88\x015\x92P`\xE0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B<W__\xFD[a\x0BH\x8A\x82\x8B\x01a\nNV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[_` \x82\x84\x03\x12\x15a\x0BkW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x82W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0B\x91W__\xFD[\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_`@\x82\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0C2W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0B\xFEV[P\x90\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0CNW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CdW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0CtW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\x8EWa\x0C\x8Ea\tuV[\x80`\x05\x1Ba\x0C\x9E` \x82\x01a\t\xCBV[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0C\xB9W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0C\xDFW\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0C\xC0V[\x97\x96PPPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\rsW\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R``\x81\x01Q``\x85\x01RP`\x80\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\x03V[P\x90\x95\x94PPPPPV[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\r\xB0W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\r\xCAW__\xFD[\x815a\x0B\x91\x81a\n\x1AV[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x0E\x08W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\"W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\n\x8FW__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+        b"`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x0E\xF2\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xF8\x8C\xF6\xDB\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\n\xBEV[a\0ZV[`@Qa\0Q\x95\x94\x93\x92\x91\x90a\x0B\x83V[`@Q\x80\x91\x03\x90\xF3[____``a\0k\x8C\x88\x88a\x07\xB0V[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x88\x03a\x01\xC6W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x8B\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01 \x91\x90a\x0C\nV[` \x8D\x01Q`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x91\x96P\x8B\x16\x90c\xDDb\xED>\x90`D\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x9BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xBF\x91\x90a\x0C\nV[\x93Pa\x06\x04V[\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x88\x03a\x03\x89W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x8B\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02WW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02{\x91\x90a\x0C\nV[`@\x80\x8E\x01Q` \x8F\x01Q\x91Q\x7F\xFE\xC9\rr\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8F\x81\x16`\x04\x83\x01R\x92\x83\x16`$\x82\x01R\x92\x97P\x16\x90c\xFE\xC9\rr\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x1D\x91\x90a\x0C!V[a\x03'W_a\x01\xBFV[`@\x8C\x81\x01Q\x90Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x90\x8B\x16\x90c\xDDb\xED>\x90`D\x01a\x01\x80V[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x88\x03a\x05\x9DW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x8A\x81_\x81Q\x81\x10a\x03\xE4Wa\x03\xE4a\x0CGV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@\x80\x8F\x01Q\x90Q\x7F\x0FZn\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16\x90c\x0FZn\xFA\x90a\x04K\x90\x8F\x90\x85\x90`\x04\x01a\x0CtV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04eW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x04\xAA\x91\x90\x81\x01\x90a\x0C\xEDV[_\x81Q\x81\x10a\x04\xBBWa\x04\xBBa\x0CGV[` \x02` \x01\x01Q\x95P\x8C`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFE\xC9\rr\x8D\x8F` \x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x05*\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05i\x91\x90a\x0C!V[a\x05sW_a\x05\x95V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[\x94PPa\x06\x04V[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Finvalid token source\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x83\x85\x11\x15a\x06\x12W\x83a\x06\x14V[\x84[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x94P_\x91\x90\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x01\x91\x01\x81a\x06.W\x90PP\x90P`@Q\x80`\x80\x01`@R\x80\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B_\x03a\x06\xD1W\x85a\x06\xD3V[\x8B[\x81R` \x01\x8A\x81RP\x81_\x81Q\x81\x10a\x06\xEEWa\x06\xEEa\x0CGV[` \x02` \x01\x01\x81\x90RP\x8C` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c}\x10\xD1\x1F\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x076\x91\x90a\r\x99V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07MW__\xFD[PZ\xF1\x92PPP\x80\x15a\x07^WP`\x01[a\x07\x9BW=\x80\x80\x15a\x07\x8BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x07\x90V[``\x91P[P_\x93P\x91Pa\x07\xA0V[`\x01\x92P[P\x97P\x97P\x97P\x97P\x97\x92PPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x080W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xFBV[_[\x81\x81\x10\x15a\t\x97W_\x83\x83\x83\x81\x81\x10a\x08MWa\x08Ma\x0CGV[\x90P` \x02\x81\x01\x90a\x08_\x91\x90a\x0E-V[a\x08m\x90` \x81\x01\x90a\x0EiV[\x90P_\x84\x84\x84\x81\x81\x10a\x08\x82Wa\x08\x82a\x0CGV[\x90P` \x02\x81\x01\x90a\x08\x94\x91\x90a\x0E-V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x08\xAEWa\x08\xAEa\x0CGV[\x90P` \x02\x81\x01\x90a\x08\xC0\x91\x90a\x0E-V[a\x08\xCE\x90`@\x81\x01\x90a\x0E\x84V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\tkW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xFBV[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\t\x86W=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x082\x91PPV[PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xEDWa\t\xEDa\t\x9DV[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n:Wa\n:a\t\x9DV[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\ncW__\xFD[PV[\x805a\nq\x81a\nBV[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\n\x86W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x9DW__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\n\xB7W__\xFD[\x92P\x92\x90PV[_______\x87\x89\x03a\x01\0\x81\x12\x15a\n\xD6W__\xFD[``\x81\x12\x15a\n\xE3W__\xFD[Pa\n\xECa\t\xCAV[\x885a\n\xF7\x81a\nBV[\x81R` \x89\x015a\x0B\x07\x81a\nBV[` \x82\x01R`@\x89\x015a\x0B\x1A\x81a\nBV[`@\x82\x01R\x96Pa\x0B-``\x89\x01a\nfV[\x95Pa\x0B;`\x80\x89\x01a\nfV[\x94P`\xA0\x88\x015\x93P`\xC0\x88\x015\x92P`\xE0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0BdW__\xFD[a\x0Bp\x8A\x82\x8B\x01a\nvV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[\x85\x81R\x84` \x82\x01R\x83`@\x82\x01R\x82\x15\x15``\x82\x01R`\xA0`\x80\x82\x01R_\x82Q\x80`\xA0\x84\x01R_[\x81\x81\x10\x15a\x0B\xC9W` \x81\x86\x01\x81\x01Q`\xC0\x86\x84\x01\x01R\x01a\x0B\xACV[P_`\xC0\x82\x85\x01\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0C\x1AW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0C@W__\xFD[\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_`@\x82\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0C\xE1W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0C\xADV[P\x90\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0C\xFDW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x13W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\r#W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r=Wa\r=a\t\x9DV[\x80`\x05\x1Ba\rM` \x82\x01a\t\xF3V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\rhW__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\r\x8EW\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\roV[\x97\x96PPPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\"W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R``\x81\x01Q``\x85\x01RP`\x80\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\xB2V[P\x90\x95\x94PPPPPV[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\x0E_W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x0EyW__\xFD[\x815a\x0C@\x81a\nBV[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x0E\xB7W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\xD1W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\n\xB7W__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
     );
     /// The runtime bytecode of the contract, as deployed on the network.
     ///
     /// ```text
-    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
+    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
     /// ```
     #[rustfmt::skip]
     #[allow(clippy::all)]
     pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xF8\x8C\xF6\xDB\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\n\x96V[a\0fV[`@\x80Q\x94\x85R` \x85\x01\x93\x90\x93R\x91\x83\x01R\x15\x15``\x82\x01R`\x80\x01`@Q\x80\x91\x03\x90\xF3[____a\0u\x8B\x87\x87a\x07\x88V[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x87\x03a\x01\xD0W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x06W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01*\x91\x90a\x0B[V[` \x8C\x01Q`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x91\x95P\x8A\x16\x90c\xDDb\xED>\x90`D\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xA5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xC9\x91\x90a\x0B[V[\x92Pa\x06\x0EV[\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x87\x03a\x03\x93W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x81\x16`\x04\x83\x01R\x8A\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02aW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\x85\x91\x90a\x0B[V[`@\x80\x8D\x01Q` \x8E\x01Q\x91Q\x7F\xFE\xC9\rr\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16`\x04\x83\x01R\x92\x83\x16`$\x82\x01R\x92\x96P\x16\x90c\xFE\xC9\rr\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03'\x91\x90a\x0BrV[a\x031W_a\x01\xC9V[`@\x8B\x81\x01Q\x90Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x90\x8A\x16\x90c\xDDb\xED>\x90`D\x01a\x01\x8AV[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x87\x03a\x05\xA7W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x89\x81_\x81Q\x81\x10a\x03\xEEWa\x03\xEEa\x0B\x98V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@\x80\x8E\x01Q\x90Q\x7F\x0FZn\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16\x90c\x0FZn\xFA\x90a\x04U\x90\x8E\x90\x85\x90`\x04\x01a\x0B\xC5V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04oW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x04\xB4\x91\x90\x81\x01\x90a\x0C>V[_\x81Q\x81\x10a\x04\xC5Wa\x04\xC5a\x0B\x98V[` \x02` \x01\x01Q\x94P\x8B`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFE\xC9\rr\x8C\x8E` \x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x054\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05OW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05s\x91\x90a\x0BrV[a\x05}W_a\x05\x9FV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[\x93PPa\x06\x0EV[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Finvalid token source\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x82\x84\x11\x15a\x06\x1CW\x82a\x06\x1EV[\x83[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x93P_\x91\x90\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x01\x91\x01\x81a\x068W\x90PP\x90P`@Q\x80`\x80\x01`@R\x80\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A_\x03a\x06\xDBW\x84a\x06\xDDV[\x8A[\x81R` \x01\x89\x81RP\x81_\x81Q\x81\x10a\x06\xF8Wa\x06\xF8a\x0B\x98V[` \x02` \x01\x01\x81\x90RP\x8B` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c}\x10\xD1\x1F\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07@\x91\x90a\x0C\xEAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07WW__\xFD[PZ\xF1\x92PPP\x80\x15a\x07hWP`\x01[a\x07tW_\x91Pa\x07yV[`\x01\x91P[P\x97P\x97P\x97P\x97\x93PPPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x08\x08W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[_[\x81\x81\x10\x15a\toW_\x83\x83\x83\x81\x81\x10a\x08%Wa\x08%a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x087\x91\x90a\r~V[a\x08E\x90` \x81\x01\x90a\r\xBAV[\x90P_\x84\x84\x84\x81\x81\x10a\x08ZWa\x08Za\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08l\x91\x90a\r~V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x08\x86Wa\x08\x86a\x0B\x98V[\x90P` \x02\x81\x01\x90a\x08\x98\x91\x90a\r~V[a\x08\xA6\x90`@\x81\x01\x90a\r\xD5V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\tCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x06\x05V[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\t^W=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x08\n\x91PPV[PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC5Wa\t\xC5a\tuV[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\x12Wa\n\x12a\tuV[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\n;W__\xFD[PV[\x805a\nI\x81a\n\x1AV[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\n^W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nuW__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\n\x8FW__\xFD[\x92P\x92\x90PV[_______\x87\x89\x03a\x01\0\x81\x12\x15a\n\xAEW__\xFD[``\x81\x12\x15a\n\xBBW__\xFD[Pa\n\xC4a\t\xA2V[\x885a\n\xCF\x81a\n\x1AV[\x81R` \x89\x015a\n\xDF\x81a\n\x1AV[` \x82\x01R`@\x89\x015a\n\xF2\x81a\n\x1AV[`@\x82\x01R\x96Pa\x0B\x05``\x89\x01a\n>V[\x95Pa\x0B\x13`\x80\x89\x01a\n>V[\x94P`\xA0\x88\x015\x93P`\xC0\x88\x015\x92P`\xE0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B<W__\xFD[a\x0BH\x8A\x82\x8B\x01a\nNV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[_` \x82\x84\x03\x12\x15a\x0BkW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x82W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0B\x91W__\xFD[\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_`@\x82\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0C2W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0B\xFEV[P\x90\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0CNW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CdW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0CtW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\x8EWa\x0C\x8Ea\tuV[\x80`\x05\x1Ba\x0C\x9E` \x82\x01a\t\xCBV[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0C\xB9W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0C\xDFW\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0C\xC0V[\x97\x96PPPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\rsW\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R``\x81\x01Q``\x85\x01RP`\x80\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\x03V[P\x90\x95\x94PPPPPV[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\r\xB0W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\r\xCAW__\xFD[\x815a\x0B\x91\x81a\n\x1AV[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x0E\x08W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\"W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\n\x8FW__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
+        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\xF8\x8C\xF6\xDB\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\n\xBEV[a\0ZV[`@Qa\0Q\x95\x94\x93\x92\x91\x90a\x0B\x83V[`@Q\x80\x91\x03\x90\xF3[____``a\0k\x8C\x88\x88a\x07\xB0V[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x88\x03a\x01\xC6W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x8B\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01 \x91\x90a\x0C\nV[` \x8D\x01Q`@Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x91\x96P\x8B\x16\x90c\xDDb\xED>\x90`D\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x9BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xBF\x91\x90a\x0C\nV[\x93Pa\x06\x04V[\x7F\xAB\xEE;s7:\xCDX:\x13\t$\xAA\xD6\xDC8\xCF\xDCD\xBA\x05U\xBA\x94\xCE/\xF69\x80\xEA\x062\x88\x03a\x03\x89W`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8C\x81\x16`\x04\x83\x01R\x8B\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02WW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02{\x91\x90a\x0C\nV[`@\x80\x8E\x01Q` \x8F\x01Q\x91Q\x7F\xFE\xC9\rr\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8F\x81\x16`\x04\x83\x01R\x92\x83\x16`$\x82\x01R\x92\x97P\x16\x90c\xFE\xC9\rr\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x1D\x91\x90a\x0C!V[a\x03'W_a\x01\xBFV[`@\x8C\x81\x01Q\x90Q\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8D\x81\x16`\x04\x83\x01R\x91\x82\x16`$\x82\x01R\x90\x8B\x16\x90c\xDDb\xED>\x90`D\x01a\x01\x80V[\x7FJ\xC9\x9A\xCE\x14\xEE\n^\xF92\xDC`\x9D\xF0\x94:\xB7\xAC\x16\xB7X64a/\x8D\xC3ZB\x89\xA6\xCE\x88\x03a\x05\x9DW`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x8A\x81_\x81Q\x81\x10a\x03\xE4Wa\x03\xE4a\x0CGV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@\x80\x8F\x01Q\x90Q\x7F\x0FZn\xFA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16\x90c\x0FZn\xFA\x90a\x04K\x90\x8F\x90\x85\x90`\x04\x01a\x0CtV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04eW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x82\x01`@Ra\x04\xAA\x91\x90\x81\x01\x90a\x0C\xEDV[_\x81Q\x81\x10a\x04\xBBWa\x04\xBBa\x0CGV[` \x02` \x01\x01Q\x95P\x8C`@\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFE\xC9\rr\x8D\x8F` \x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x05*\x92\x91\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05i\x91\x90a\x0C!V[a\x05sW_a\x05\x95V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[\x94PPa\x06\x04V[`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Finvalid token source\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x83\x85\x11\x15a\x06\x12W\x83a\x06\x14V[\x84[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x94P_\x91\x90\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x01\x91\x01\x81a\x06.W\x90PP\x90P`@Q\x80`\x80\x01`@R\x80\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8Cs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8B_\x03a\x06\xD1W\x85a\x06\xD3V[\x8B[\x81R` \x01\x8A\x81RP\x81_\x81Q\x81\x10a\x06\xEEWa\x06\xEEa\x0CGV[` \x02` \x01\x01\x81\x90RP\x8C` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c}\x10\xD1\x1F\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x076\x91\x90a\r\x99V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07MW__\xFD[PZ\xF1\x92PPP\x80\x15a\x07^WP`\x01[a\x07\x9BW=\x80\x80\x15a\x07\x8BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x07\x90V[``\x91P[P_\x93P\x91Pa\x07\xA0V[`\x01\x92P[P\x97P\x97P\x97P\x97P\x97\x92PPPV[\x82Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x160\x14a\x080W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7Fincorrect calling context\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xFBV[_[\x81\x81\x10\x15a\t\x97W_\x83\x83\x83\x81\x81\x10a\x08MWa\x08Ma\x0CGV[\x90P` \x02\x81\x01\x90a\x08_\x91\x90a\x0E-V[a\x08m\x90` \x81\x01\x90a\x0EiV[\x90P_\x84\x84\x84\x81\x81\x10a\x08\x82Wa\x08\x82a\x0CGV[\x90P` \x02\x81\x01\x90a\x08\x94\x91\x90a\x0E-V[` \x015\x90P6_\x86\x86\x86\x81\x81\x10a\x08\xAEWa\x08\xAEa\x0CGV[\x90P` \x02\x81\x01\x90a\x08\xC0\x91\x90a\x0E-V[a\x08\xCE\x90`@\x81\x01\x90a\x0E\x84V[\x91P\x91P\x87` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\tkW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGPv2: forbidden interaction\0\0\0\0\0`D\x82\x01R`d\x01a\x05\xFBV[`@Q\x81\x83\x827__\x83\x83\x87\x89Z\xF1a\t\x86W=__>=_\xFD[PP`\x01\x90\x93\x01\x92Pa\x082\x91PPV[PPPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xEDWa\t\xEDa\t\x9DV[`@R\x90V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n:Wa\n:a\t\x9DV[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\ncW__\xFD[PV[\x805a\nq\x81a\nBV[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\n\x86W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x9DW__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\n\xB7W__\xFD[\x92P\x92\x90PV[_______\x87\x89\x03a\x01\0\x81\x12\x15a\n\xD6W__\xFD[``\x81\x12\x15a\n\xE3W__\xFD[Pa\n\xECa\t\xCAV[\x885a\n\xF7\x81a\nBV[\x81R` \x89\x015a\x0B\x07\x81a\nBV[` \x82\x01R`@\x89\x015a\x0B\x1A\x81a\nBV[`@\x82\x01R\x96Pa\x0B-``\x89\x01a\nfV[\x95Pa\x0B;`\x80\x89\x01a\nfV[\x94P`\xA0\x88\x015\x93P`\xC0\x88\x015\x92P`\xE0\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0BdW__\xFD[a\x0Bp\x8A\x82\x8B\x01a\nvV[\x98\x9B\x97\x9AP\x95\x98P\x93\x96\x92\x95\x92\x93PPPV[\x85\x81R\x84` \x82\x01R\x83`@\x82\x01R\x82\x15\x15``\x82\x01R`\xA0`\x80\x82\x01R_\x82Q\x80`\xA0\x84\x01R_[\x81\x81\x10\x15a\x0B\xC9W` \x81\x86\x01\x81\x01Q`\xC0\x86\x84\x01\x01R\x01a\x0B\xACV[P_`\xC0\x82\x85\x01\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0C\x1AW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0C@W__\xFD[\x93\x92PPPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_`@\x82\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x83R`@` \x84\x01R\x80\x84Q\x80\x83R``\x85\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0C\xE1W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0C\xADV[P\x90\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a\x0C\xFDW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x13W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\r#W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r=Wa\r=a\t\x9DV[\x80`\x05\x1Ba\rM` \x82\x01a\t\xF3V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\rhW__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\r\x8EW\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\roV[\x97\x96PPPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\"W\x83Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x84Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R``\x81\x01Q``\x85\x01RP`\x80\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\xB2V[P\x90\x95\x94PPPPPV[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a\x0E_W__\xFD[\x91\x90\x91\x01\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x0EyW__\xFD[\x815a\x0C@\x81a\nBV[__\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x0E\xB7W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\xD1W__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\n\xB7W__\xFD\xFE\xA1dsolcC\0\x08\x1E\0\n",
     );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
@@ -612,7 +617,7 @@ pub mod Balances {
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `balance((address,address,address),address,address,uint256,bytes32,(address,uint256,bytes)[])` and selector `0xf88cf6db`.
     ```solidity
-    function balance(Contracts memory contracts, address trader, address token, uint256 amount, bytes32 source, Interaction[] memory interactions) external returns (uint256 tokenBalance, uint256 allowance, uint256 effectiveBalance, bool canTransfer);
+    function balance(Contracts memory contracts, address trader, address token, uint256 amount, bytes32 source, Interaction[] memory interactions) external returns (uint256 tokenBalance, uint256 allowance, uint256 effectiveBalance, bool canTransfer, bytes memory transferRevertReason);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
@@ -646,6 +651,8 @@ pub mod Balances {
         pub effectiveBalance: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub canTransfer: bool,
+        #[allow(missing_docs)]
+        pub transferRevertReason: alloy_sol_types::private::Bytes,
     }
     #[allow(
         non_camel_case_types,
@@ -721,6 +728,7 @@ pub mod Balances {
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
@@ -728,6 +736,7 @@ pub mod Balances {
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 bool,
+                alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -747,6 +756,7 @@ pub mod Balances {
                         value.allowance,
                         value.effectiveBalance,
                         value.canTransfer,
+                        value.transferRevertReason,
                     )
                 }
             }
@@ -759,6 +769,7 @@ pub mod Balances {
                         allowance: tuple.1,
                         effectiveBalance: tuple.2,
                         canTransfer: tuple.3,
+                        transferRevertReason: tuple.4,
                     }
                 }
             }
@@ -778,6 +789,9 @@ pub mod Balances {
                     <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
                         &self.canTransfer,
                     ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.transferRevertReason,
+                    ),
                 )
             }
         }
@@ -798,6 +812,7 @@ pub mod Balances {
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Bytes,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -1186,55 +1201,51 @@ use {
 pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
     match chain_id {
         1u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         10u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         56u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         100u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         137u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
-            None,
-        )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         8453u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         9745u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         42161u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         43114u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         57073u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         59144u64 => Some((
-            ::alloy_primitives::address!("0x361350f708f7c0c63c8a505226592c3e5d1faa29"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         11155111u64 => Some((
-            ::alloy_primitives::address!("0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b"),
+            ::alloy_primitives::address!("0x88b4B74082BffB2976C306CB3f7E9093AE48B94F"),
             None,
         )),
         _ => None,
diff --git a/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs b/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
index eef46097a3..a95fc944a7 100644
--- a/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
@@ -5833,10 +5833,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x04501b9b1d52e67f6862d157e00d13419d2d6e95"),
             Some(71296258u64),
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0xFb337f8a725A142f65fb9ff4902d41cc901de222"),
-            Some(3007173u64),
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x3C3eA1829891BC9bEC3d06A81d5d169e52a415e3"),
             Some(21490258u64),
diff --git a/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs b/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
index 68a54ea295..4aafc4e0f0 100644
--- a/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
+++ b/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
@@ -2753,10 +2753,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
             Some(45854728u64),
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
-            Some(2612937u64),
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE"),
             Some(21407137u64),
diff --git a/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs b/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
index 1bbdf44f2a..edadccd68a 100644
--- a/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
+++ b/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
@@ -6162,10 +6162,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
             Some(45859743u64),
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
-            Some(2621745u64),
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x9008D19f58AAbD9eD0D60971565AA8510560ab41"),
             Some(21407238u64),
diff --git a/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs b/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs
index bcc0cd0566..b6002f94ac 100644
--- a/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs
+++ b/contracts/generated/contracts-generated/hookstrampoline/src/lib.rs
@@ -1271,10 +1271,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
             None,
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
-            None,
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x60Bf78233f48eC42eE3F101b9a05eC7878728006"),
             None,
diff --git a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
index eb6d721593..19886c69ec 100644
--- a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
+++ b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
@@ -2177,10 +2177,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
             None,
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0xc3A5b857Ba82a2586A45a8B59ECc3AA50Bc3D0e3"),
-            None,
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x33128a8fC17869897dcE68Ed026d694621f6FDfD"),
             None,
diff --git a/contracts/generated/contracts-generated/signatures/src/lib.rs b/contracts/generated/contracts-generated/signatures/src/lib.rs
index 1f94bce242..c787ca99df 100644
--- a/contracts/generated/contracts-generated/signatures/src/lib.rs
+++ b/contracts/generated/contracts-generated/signatures/src/lib.rs
@@ -1113,10 +1113,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
             None,
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
-            None,
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x8262d639c38470F38d2eff15926F7071c28057Af"),
             None,
diff --git a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
index f9cb522cbb..f9d342e7ed 100644
--- a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
@@ -2902,10 +2902,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x61fFE014bA17989E743c5F6cB21bF9697530B21e"),
             None,
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x1eEA2B790Dc527c5a4cd3d4f3ae8A2DDB65B2af1"),
-            None,
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"),
             None,
diff --git a/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
index 1870e65c85..0bb24e41c1 100644
--- a/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
@@ -1015,10 +1015,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"),
             None,
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x6ddD32cd941041D8b61df213B9f515A7D288Dc13"),
-            None,
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x2626664c2603336E57B271c5C0b26F421741e481"),
             None,
diff --git a/contracts/generated/contracts-generated/weth9/src/lib.rs b/contracts/generated/contracts-generated/weth9/src/lib.rs
index e1db1eefad..7e647d9e38 100644
--- a/contracts/generated/contracts-generated/weth9/src/lib.rs
+++ b/contracts/generated/contracts-generated/weth9/src/lib.rs
@@ -3239,10 +3239,6 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
             None,
         )),
-        232u64 => Some((
-            ::alloy_primitives::address!("0x6bDc36E20D267Ff0dd6097799f82e78907105e2F"),
-            None,
-        )),
         8453u64 => Some((
             ::alloy_primitives::address!("0x4200000000000000000000000000000000000006"),
             None,
diff --git a/contracts/solidity/Balances.sol b/contracts/solidity/Balances.sol
index c7d5a2d5a0..2ab9afe006 100644
--- a/contracts/solidity/Balances.sol
+++ b/contracts/solidity/Balances.sol
@@ -38,6 +38,8 @@ contract Balances {
     /// contract when executing a trade.
     /// @return canTransfer - Returns whether or not the transfer into the
     /// settlement contract for the specified amount would succeed.
+    /// @return transferRevertReason - The revert reason bytes if the transfer
+    /// failed, or empty bytes if it succeeded.
     function balance(
         Contracts memory contracts,
         address trader,
@@ -49,7 +51,8 @@ contract Balances {
         uint256 tokenBalance,
         uint256 allowance,
         uint256 effectiveBalance,
-        bool canTransfer
+        bool canTransfer,
+        bytes memory transferRevertReason
     ) {
         // Execute the interactions within the current context. This ensures
         // that any pre-interactions that setup balances and/or allowances
@@ -96,8 +99,9 @@ contract Balances {
         try contracts.vaultRelayer.transferFromAccounts(transfers) {
             canTransfer = true;
         }
-        catch {
+        catch (bytes memory reason) {
             canTransfer = false;
+            transferRevertReason = reason;
         }
     }
 
diff --git a/contracts/src/main.rs b/contracts/src/main.rs
index 34ec14364c..1f4ed17afa 100644
--- a/contracts/src/main.rs
+++ b/contracts/src/main.rs
@@ -332,7 +332,6 @@ fn build_module() -> Module {
             BNB => "0x78D78E420Da98ad378D7799bE8f4AF69033EB077",
             OPTIMISM => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
             POLYGON => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-            LENS => "0x1eEA2B790Dc527c5a4cd3d4f3ae8A2DDB65B2af1",
             LINEA => "0x42bE4D6527829FeFA1493e1fb9F3676d2425C3C1",
             PLASMA => "0xaa52bB8110fE38D0d2d2AF0B85C3A3eE622CA455",
             INK => "0x96b572D2d880cf2Fa2563651BD23ADE6f5516652",
@@ -346,7 +345,6 @@ fn build_module() -> Module {
                 BASE => "0x2626664c2603336E57B271c5C0b26F421741e481",
                 AVALANCHE => "0xbb00FF08d01D300023C629E8fFfFcb65A5a578cE",
                 BNB => "0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2",
-                LENS => "0x6ddD32cd941041D8b61df213B9f515A7D288Dc13",
                 LINEA => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
                 PLASMA => "0x807F4E281B7A3B324825C64ca53c69F0b418dE40",
                 INK => "0x177778F19E89dD1012BdBe603F144088A95C4B53",
@@ -361,7 +359,6 @@ fn build_module() -> Module {
             BNB => "0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7",
             OPTIMISM => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
             POLYGON => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-            LENS => "0xc3A5b857Ba82a2586A45a8B59ECc3AA50Bc3D0e3",
             LINEA => "0x31FAfd4889FA1269F7a13A66eE0fB458f27D72A9",
             PLASMA => "0xcb2436774C3e191c85056d248EF4260ce5f27A9D",
             INK => "0x640887A9ba3A9C53Ed27D0F7e8246A4F933f3424",
@@ -376,7 +373,6 @@ fn build_module() -> Module {
             BNB => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             OPTIMISM => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             POLYGON => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
-            LENS => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             LINEA => "0x60bf78233f48ec42ee3f101b9a05ec7878728006",
             PLASMA => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
             INK => "0x60Bf78233f48eC42eE3F101b9a05eC7878728006",
@@ -391,7 +387,6 @@ fn build_module() -> Module {
             BNB => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 48411237),
             OPTIMISM => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 134607215),
             POLYGON => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 71296258),
-            LENS => ("0xFb337f8a725A142f65fb9ff4902d41cc901de222", 3007173),
             LINEA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 24522097),
             PLASMA => ("0x04501b9b1d52e67f6862d157e00d13419d2d6e95", 3521855),
         ]))
@@ -456,7 +451,6 @@ fn build_module() -> Module {
                 BNB => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 48173639),
                 OPTIMISM => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 134254466),
                 POLYGON => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 45854728),
-                LENS => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 2612937),
                 LINEA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 24333100),
                 PLASMA => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 3439709),
                 INK => ("0x2c4c28DDBdAc9C5E7055b4C863b72eA0149D8aFE", 34436840),
@@ -472,7 +466,6 @@ fn build_module() -> Module {
             BNB => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 48173641),
             OPTIMISM => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 134254624),
             POLYGON => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 45859743),
-            LENS => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 2621745),
             LINEA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 24333100),
             PLASMA => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 3439711),
             INK => ("0x9008D19f58AAbD9eD0D60971565AA8510560ab41", 34436849),
@@ -487,7 +480,6 @@ fn build_module() -> Module {
             BNB => "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
             OPTIMISM => "0x4200000000000000000000000000000000000006",
             POLYGON => "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-            LENS => "0x6bDc36E20D267Ff0dd6097799f82e78907105e2F",
             LINEA => "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
             PLASMA => "0x6100E367285b01F48D07953803A2d8dCA5D19873",
             INK => "0x4200000000000000000000000000000000000006",
@@ -538,7 +530,6 @@ fn build_module() -> Module {
                     BNB => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     OPTIMISM => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     POLYGON => "0x8262d639c38470F38d2eff15926F7071c28057Af",
-                    LENS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     GNOSIS => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     SEPOLIA => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                     LINEA => "0xf6E57e72F7dB3D9A51a8B4c149C00475b94A37e4",
@@ -546,19 +537,18 @@ fn build_module() -> Module {
                     INK => "0x8262d639c38470F38d2eff15926F7071c28057Af",
                 ]))
                 .add_contract(Contract::new("Balances").with_networks(networks![
-                    MAINNET => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    ARBITRUM_ONE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    BASE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    AVALANCHE => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    BNB => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    OPTIMISM => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    POLYGON => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    LENS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    GNOSIS => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    SEPOLIA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    PLASMA => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
-                    LINEA => "0x361350f708f7c0c63c8a505226592c3e5d1faa29",
-                    INK => "0x3e8C6De9510e7ECad902D005DE3Ab52f35cF4f1b",
+                    MAINNET => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    ARBITRUM_ONE => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    BASE => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    AVALANCHE => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    BNB => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    OPTIMISM => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    POLYGON => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    GNOSIS => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    SEPOLIA => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    PLASMA => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    LINEA => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
+                    INK => "0x88b4B74082BffB2976C306CB3f7E9093AE48B94F",
                 ])),
         )
 }
diff --git a/contracts/src/networks.rs b/contracts/src/networks.rs
index 4af659aab0..1d8948644b 100644
--- a/contracts/src/networks.rs
+++ b/contracts/src/networks.rs
@@ -7,7 +7,6 @@ pub const POLYGON: u64 = 137;
 pub const AVALANCHE: u64 = 43114;
 pub const BNB: u64 = 56;
 pub const OPTIMISM: u64 = 10;
-pub const LENS: u64 = 232;
 pub const LINEA: u64 = 59144;
 pub const PLASMA: u64 = 9745;
 pub const INK: u64 = 57073;
diff --git a/crates/account-balances/src/lib.rs b/crates/account-balances/src/lib.rs
index 4979e4c652..ed33acaf37 100644
--- a/crates/account-balances/src/lib.rs
+++ b/crates/account-balances/src/lib.rs
@@ -42,7 +42,7 @@ impl Query {
 pub enum TransferSimulationError {
     InsufficientAllowance,
     InsufficientBalance,
-    TransferFailed,
+    TransferFailed(Vec<u8>),
     Other(anyhow::Error),
 }
 
@@ -176,13 +176,14 @@ impl BalanceSimulator {
             .call()
             .await?;
 
-        let (token_balance, allowance, effective_balance, can_transfer) =
+        let (token_balance, allowance, effective_balance, can_transfer, transfer_revert_reason) =
             <(
                 sol_data::Uint<256>,
                 sol_data::Uint<256>,
                 sol_data::Uint<256>,
                 sol_data::Bool,
-            )>::abi_decode(&response.0)
+                sol_data::Bytes,
+            )>::abi_decode_params(&response.0)
             .map_err(|err| {
                 tracing::error!(?err, "failed to decode balance response");
                 alloy_contract::Error::AbiError(alloy_dyn_abi::Error::SolTypes(err))
@@ -193,6 +194,7 @@ impl BalanceSimulator {
             allowance: U256::from_le_slice(&allowance.as_le_bytes()),
             effective_balance: U256::from_le_slice(&effective_balance.as_le_bytes()),
             can_transfer,
+            transfer_revert_reason: transfer_revert_reason.to_vec(),
         };
 
         tracing::trace!(
@@ -214,6 +216,7 @@ pub struct Simulation {
     pub allowance: U256,
     pub effective_balance: U256,
     pub can_transfer: bool,
+    pub transfer_revert_reason: Vec<u8>,
 }
 
 #[derive(Debug)]
diff --git a/crates/account-balances/src/simulation.rs b/crates/account-balances/src/simulation.rs
index b98166fccb..0c0378601b 100644
--- a/crates/account-balances/src/simulation.rs
+++ b/crates/account-balances/src/simulation.rs
@@ -156,7 +156,9 @@ impl BalanceFetching for Balances {
             return Err(TransferSimulationError::InsufficientAllowance);
         }
         if !simulation.can_transfer {
-            return Err(TransferSimulationError::TransferFailed);
+            return Err(TransferSimulationError::TransferFailed(
+                simulation.transfer_revert_reason,
+            ));
         }
 
         Ok(())
diff --git a/crates/e2e/tests/e2e/banned_users.rs b/crates/e2e/tests/e2e/banned_users.rs
index b580d0d337..b1ee2c6bfd 100644
--- a/crates/e2e/tests/e2e/banned_users.rs
+++ b/crates/e2e/tests/e2e/banned_users.rs
@@ -24,9 +24,9 @@ async fn forked_node_mainnet_single_limit_order() {
 }
 
 /// The block number from which we will fetch state for the forked tests.
-const FORK_BLOCK_MAINNET: u64 = 23112197;
+const FORK_BLOCK_MAINNET: u64 = 24843565;
 /// DAI whale address as per [FORK_BLOCK_MAINNET].
-const DAI_WHALE_MAINNET: Address = address!("762d46904B93a1EEDBfF2fD50445CB8ffA41F9FB");
+const DAI_WHALE_MAINNET: Address = address!("28c6c06298d514db089934071355e5743bf21d60");
 const BANNED_USER: Address = address!("7F367cC41522cE07553e823bf3be79A889DEbe1B");
 
 async fn forked_mainnet_onchain_banned_user_test(web3: Web3) {
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 2b8ee84858..1ba0d40c74 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -101,7 +101,7 @@ async fn local_node_buy_order_with_haircut() {
 }
 
 /// The block number from which we will fetch state for the forked tests.
-const FORK_BLOCK_MAINNET: u64 = 23112197;
+const FORK_BLOCK_MAINNET: u64 = 24843565;
 /// USDC whale address as per [FORK_BLOCK_MAINNET].
 const USDC_WHALE_MAINNET: Address = address!("28c6c06298d514db089934071355e5743bf21d60");
 
@@ -117,7 +117,7 @@ async fn forked_node_mainnet_single_limit_order() {
     .await;
 }
 
-const FORK_BLOCK_GNOSIS: u64 = 41502478;
+const FORK_BLOCK_GNOSIS: u64 = 45588623;
 /// USDC whale address as per [FORK_BLOCK_GNOSIS].
 const USDC_WHALE_GNOSIS: Address = address!("d4A39d219ADB43aB00739DC5D876D98Fdf0121Bf");
 
diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs
index 878397d3d3..5133e5e4e1 100644
--- a/crates/e2e/tests/e2e/liquidity.rs
+++ b/crates/e2e/tests/e2e/liquidity.rs
@@ -36,7 +36,7 @@ use {
 };
 
 /// The block number from which we will fetch state for the forked tests.
-pub const FORK_BLOCK: u64 = 23112197;
+pub const FORK_BLOCK: u64 = 24843565;
 pub const USDT_WHALE: Address = address!("F977814e90dA44bFA03b6295A0616a897441aceC");
 pub const USDC_WHALE: Address = address!("28c6c06298d514db089934071355e5743bf21d60");
 
diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs
index f517e09315..35a09588e2 100644
--- a/crates/e2e/tests/e2e/liquidity_source_notification.rs
+++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs
@@ -35,7 +35,7 @@ use {
 };
 
 /// The block number from which we will fetch state for the forked tests.
-pub const FORK_BLOCK: u64 = 23326100;
+pub const FORK_BLOCK: u64 = 24843565;
 pub const USDT_WHALE: Address = address!("6AC38D1b2f0c0c3b9E816342b1CA14d91D5Ff60B");
 pub const USDC_WHALE: Address = address!("01b8697695eab322a339c4bf75740db75dc9375e");
 
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index a20d344ec4..bcc5c933fa 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -127,7 +127,7 @@ async fn standard_verified_quote(web3: Web3) {
 }
 
 /// The block number from which we will fetch state for the forked tests.
-const FORK_BLOCK_MAINNET: u64 = 23112197;
+const FORK_BLOCK_MAINNET: u64 = 24843565;
 
 /// Tests that quotes requesting `tx_origin: 0x0000` bypass the verification
 /// because those are currently used by some solvers to provide market maker
diff --git a/crates/e2e/tests/e2e/wrapper.rs b/crates/e2e/tests/e2e/wrapper.rs
index 66be717b54..deecd0377e 100644
--- a/crates/e2e/tests/e2e/wrapper.rs
+++ b/crates/e2e/tests/e2e/wrapper.rs
@@ -22,7 +22,7 @@ use {
 };
 
 /// The block number from which we will fetch state for the forked test.
-const FORK_BLOCK_MAINNET: u64 = 23688436;
+const FORK_BLOCK_MAINNET: u64 = 24843565;
 
 /// EmptyWrapper contract address deployed on mainnet.
 const EMPTY_WRAPPER_MAINNET: Address = address!("751871E9cA28B441Bb6d3b7C4255cf2B5873d56a");
diff --git a/crates/orderbook/src/api/post_order.rs b/crates/orderbook/src/api/post_order.rs
index c67270b84a..9db253913b 100644
--- a/crates/orderbook/src/api/post_order.rs
+++ b/crates/orderbook/src/api/post_order.rs
@@ -222,14 +222,21 @@ impl IntoResponse for ValidationErrorWrapper {
                 ),
             )
                 .into_response(),
-            ValidationError::TransferSimulationFailed => (
-                StatusCode::BAD_REQUEST,
-                error(
-                    "TransferSimulationFailed",
-                    "sell token cannot be transferred",
-                ),
-            )
-                .into_response(),
+            ValidationError::TransferSimulationFailed(revert_data) => {
+                let description = if revert_data.is_empty() {
+                    "sell token cannot be transferred".to_string()
+                } else {
+                    format!(
+                        "sell token cannot be transferred, token reverted with: 0x{}",
+                        const_hex::encode(&revert_data),
+                    )
+                };
+                (
+                    StatusCode::BAD_REQUEST,
+                    error("TransferSimulationFailed", description),
+                )
+            }
+            .into_response(),
             ValidationError::QuoteNotVerified => (
                 StatusCode::BAD_REQUEST,
                 error(
diff --git a/crates/shared/src/order_validation.rs b/crates/shared/src/order_validation.rs
index e6761b7c65..21bf3a781c 100644
--- a/crates/shared/src/order_validation.rs
+++ b/crates/shared/src/order_validation.rs
@@ -141,7 +141,7 @@ pub enum ValidationError {
     InvalidSignature,
     /// If fee and sell amount overflow u256
     SellAmountOverflow,
-    TransferSimulationFailed,
+    TransferSimulationFailed(Vec<u8>),
     /// The specified on-chain signature requires the from address of the
     /// order signer.
     MissingFrom,
@@ -445,7 +445,7 @@ impl OrderValidator {
                 res = match err {
                     TransferSimulationError::InsufficientAllowance
                     | TransferSimulationError::InsufficientBalance
-                    | TransferSimulationError::TransferFailed
+                    | TransferSimulationError::TransferFailed(_)
                         if order.signature == Signature::PreSign || has_wrappers =>
                     {
                         // Pre-sign orders do not require sufficient balance or allowance.
@@ -469,12 +469,12 @@ impl OrderValidator {
                         // will be triggered for the other amounts too
                         return Err(ValidationError::InsufficientBalance);
                     }
-                    TransferSimulationError::TransferFailed => {
-                        Err(ValidationError::TransferSimulationFailed)
+                    TransferSimulationError::TransferFailed(reason) => {
+                        Err(ValidationError::TransferSimulationFailed(reason))
                     }
                     TransferSimulationError::Other(err) => {
                         tracing::warn!("TransferSimulation failed: {:?}", err);
-                        Err(ValidationError::TransferSimulationFailed)
+                        Err(ValidationError::TransferSimulationFailed(Vec::new()))
                     }
                 };
             }

From 0dd0349b39c8d1b34905da3eb6a4329dc95d4eef Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Mon, 13 Apr 2026 13:00:50 +0200
Subject: [PATCH 195/219] Don't compile contract bindindgs we don't use (#4324)

# Description
Currently many contracts we use have many functions we don't use. Those
result in a lot of code that gets compiled unnecessarily which is slow.

# Changes
I moved the unused functions in the artifact ABI files into under a new
key (`_disabled`) which does not get parsed by `alloy` for code
generation. I decided to do that instead of deleting the functions
entirely in case we need to use some of them in the future.

This resulted in ~180K lines of net reduction. On my machine this
reduced compile times of a clean rebuild from 69s to 63.7s. The effects
on CI are 10s faster compilation of tests and likely significantly more
savings when building the full image.

## How to test
all tests should still pass
---
 contracts/artifacts/BalancerQueries.json      |    30 +-
 contracts/artifacts/BalancerV2Authorizer.json |   170 +-
 contracts/artifacts/BalancerV2BasePool.json   |   298 +-
 .../artifacts/BalancerV2BasePoolFactory.json  |     4 +-
 .../BalancerV2ComposableStablePool.json       |   526 +-
 ...BalancerV2ComposableStablePoolFactory.json |    30 +-
 ...lancerV2ComposableStablePoolFactoryV3.json |    30 +-
 ...lancerV2ComposableStablePoolFactoryV4.json |    30 +-
 ...lancerV2ComposableStablePoolFactoryV5.json |    30 +-
 ...lancerV2ComposableStablePoolFactoryV6.json |    30 +-
 .../BalancerV2LiquidityBootstrappingPool.json |   404 +-
 ...erV2LiquidityBootstrappingPoolFactory.json |     6 +-
 ...lFeeLiquidityBootstrappingPoolFactory.json |     6 +-
 contracts/artifacts/BalancerV2StablePool.json |   370 +-
 .../BalancerV2StablePoolFactoryV2.json        |     6 +-
 contracts/artifacts/BalancerV2Vault.json      |   634 +-
 .../artifacts/BalancerV2WeightedPool.json     |   366 +-
 .../BalancerV2WeightedPool2TokensFactory.json |    10 +-
 .../BalancerV2WeightedPoolFactory.json        |    10 +-
 .../BalancerV2WeightedPoolFactoryV3.json      |    28 +-
 .../BalancerV2WeightedPoolFactoryV4.json      |    28 +-
 .../artifacts/BalancerV3BatchRouter.json      |    46 +-
 contracts/artifacts/BaoswapRouter.json        |   166 +-
 contracts/artifacts/ChainalysisOracle.json    |    66 +-
 contracts/artifacts/CoWSwapEthFlow.json       |    38 +-
 contracts/artifacts/CowAmm.json               |   662 +-
 .../CowAmmConstantProductFactory.json         |   610 +-
 contracts/artifacts/CowAmmLegacyHelper.json   |   190 +-
 .../artifacts/CowAmmUniswapV2PriceOracle.json |    75 +-
 contracts/artifacts/CowProtocolToken.json     |   278 +-
 contracts/artifacts/ERC20.json                |   114 +-
 contracts/artifacts/ERC20Mintable.json        |   142 +-
 contracts/artifacts/FlashLoanRouter.json      |    56 +-
 .../GPv2AllowListAuthentication.json          |   128 +-
 contracts/artifacts/GPv2Settlement.json       |   238 +-
 contracts/artifacts/GnosisSafe.json           |   292 +-
 ...nosisSafeCompatibilityFallbackHandler.json |   124 +-
 .../artifacts/GnosisSafeProxyFactory.json     |    32 +-
 contracts/artifacts/HoneyswapRouter.json      |   166 +-
 contracts/artifacts/ICowWrapper.json          |    30 +-
 contracts/artifacts/ISwaprPair.json           |   244 +-
 contracts/artifacts/IUniswapLikePair.json     |   186 +-
 contracts/artifacts/IUniswapLikeRouter.json   |   166 +-
 contracts/artifacts/IUniswapV3Factory.json    |    78 +-
 contracts/artifacts/IZeroex.json              | 10362 ++--
 contracts/artifacts/LiquoriceSettlement.json  |  8014 +--
 contracts/artifacts/PancakeRouter.json        |   166 +-
 contracts/artifacts/Permit2.json              |   200 +-
 contracts/artifacts/SushiSwapRouter.json      |   166 +-
 contracts/artifacts/SwaprRouter.json          |   166 +-
 .../artifacts/TestnetUniswapV2Router02.json   |   166 +-
 contracts/artifacts/UniswapV2Factory.json     |    88 +-
 contracts/artifacts/UniswapV2Router02.json    |   178 +-
 contracts/artifacts/UniswapV3Pool.json        |   398 +-
 contracts/artifacts/UniswapV3QuoterV2.json    |     4 +-
 contracts/artifacts/WETH9.json                |   196 +-
 .../balancerqueries/src/lib.rs                |  3035 +-
 .../balancerv2authorizer/src/lib.rs           |  2486 +-
 .../balancerv2basepool/src/lib.rs             |  3332 +-
 .../balancerv2basepoolfactory/src/lib.rs      |   506 -
 .../balancerv2composablestablepool/src/lib.rs | 19508 ++-----
 .../src/lib.rs                                |  2194 +-
 .../src/lib.rs                                |  2194 +-
 .../src/lib.rs                                |  2194 +-
 .../src/lib.rs                                |  2194 +-
 .../src/lib.rs                                |  2194 +-
 .../src/lib.rs                                |  9070 +--
 .../src/lib.rs                                |  1345 +-
 .../src/lib.rs                                |  1394 +-
 .../balancerv2stablepool/src/lib.rs           |  8292 +--
 .../balancerv2stablepoolfactoryv2/src/lib.rs  |  1738 +-
 .../balancerv2vault/src/lib.rs                | 10215 +---
 .../balancerv2weightedpool/src/lib.rs         |  7485 +--
 .../src/lib.rs                                |   677 +-
 .../balancerv2weightedpoolfactory/src/lib.rs  |   677 +-
 .../src/lib.rs                                |  2192 +-
 .../src/lib.rs                                |  2192 +-
 .../balancerv3batchrouter/src/lib.rs          |  7554 +--
 .../baoswaprouter/src/lib.rs                  |  6561 +--
 .../chainalysisoracle/src/lib.rs              |  1108 +-
 .../contracts-generated/cowamm/src/lib.rs     |  2587 +-
 .../cowammconstantproductfactory/src/lib.rs   |  3712 +-
 .../cowammlegacyhelper/src/lib.rs             |   602 +-
 .../cowammuniswapv2priceoracle/src/lib.rs     |   378 +-
 .../cowprotocoltoken/src/lib.rs               |  2728 +-
 .../cowswapethflow/src/lib.rs                 |   562 +-
 .../contracts-generated/erc20/src/lib.rs      |   638 +-
 .../erc20mintable/src/lib.rs                  |  1300 +-
 .../flashloanrouter/src/lib.rs                |   403 +-
 .../contracts-generated/gnosissafe/src/lib.rs |  9633 +---
 .../src/lib.rs                                |  2235 +-
 .../gnosissafeproxyfactory/src/lib.rs         |  1521 +-
 .../gpv2allowlistauthentication/src/lib.rs    |   775 +-
 .../gpv2settlement/src/lib.rs                 |  1358 +-
 .../honeyswaprouter/src/lib.rs                |  6705 +--
 .../icowwrapper/src/lib.rs                    |   251 +-
 .../contracts-generated/iswaprpair/src/lib.rs |  2558 +-
 .../iuniswaplikepair/src/lib.rs               |  2452 +-
 .../iuniswaplikerouter/src/lib.rs             |  6559 +--
 .../iuniswapv3factory/src/lib.rs              |   960 +-
 .../contracts-generated/izeroex/src/lib.rs    | 46751 +++-------------
 .../liquoricesettlement/src/lib.rs            |  6912 +--
 .../pancakerouter/src/lib.rs                  |  6561 +--
 .../contracts-generated/permit2/src/lib.rs    |  6300 +--
 .../sushiswaprouter/src/lib.rs                |  6705 +--
 .../swaprrouter/src/lib.rs                    |  6561 +--
 .../testnetuniswapv2router02/src/lib.rs       |  6735 +--
 .../uniswapv2factory/src/lib.rs               |  1389 +-
 .../uniswapv2router02/src/lib.rs              |  6630 +--
 .../uniswapv3pool/src/lib.rs                  |  3555 +-
 .../uniswapv3quoterv2/src/lib.rs              |   246 +-
 .../contracts-generated/weth9/src/lib.rs      |   185 +-
 112 files changed, 46654 insertions(+), 227407 deletions(-)

diff --git a/contracts/artifacts/BalancerQueries.json b/contracts/artifacts/BalancerQueries.json
index 1700f74239..0825eed02f 100644
--- a/contracts/artifacts/BalancerQueries.json
+++ b/contracts/artifacts/BalancerQueries.json
@@ -11,6 +11,21 @@
       "stateMutability": "nonpayable",
       "type": "constructor"
     },
+    {
+      "inputs": [],
+      "name": "vault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -293,19 +308,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "vault",
-      "outputs": [
-        {
-          "internalType": "contract IVault",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2Authorizer.json b/contracts/artifacts/BalancerV2Authorizer.json
index 6785e8ea0b..57d5ad3163 100644
--- a/contracts/artifacts/BalancerV2Authorizer.json
+++ b/contracts/artifacts/BalancerV2Authorizer.json
@@ -86,6 +86,90 @@
       "name": "RoleRevoked",
       "type": "event"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "role",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "address",
+          "name": "account",
+          "type": "address"
+        }
+      ],
+      "name": "grantRole",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32[]",
+          "name": "roles",
+          "type": "bytes32[]"
+        },
+        {
+          "internalType": "address",
+          "name": "account",
+          "type": "address"
+        }
+      ],
+      "name": "grantRoles",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "devdoc": {
+    "details": "Basic Authorizer implementation, based on OpenZeppelin's Access Control. Users are allowed to perform actions if they have the role with the same identifier. In this sense, roles are not being truly used as such, since they each map to a single action identifier. This temporary implementation is expected to be replaced soon after launch by a more sophisticated one, able to manage permissions across multiple contracts and to natively handle timelocks.",
+    "kind": "dev",
+    "methods": {
+      "getRoleAdmin(bytes32)": {
+        "details": "Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."
+      },
+      "getRoleMember(bytes32,uint256)": {
+        "details": "Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information."
+      },
+      "getRoleMemberCount(bytes32)": {
+        "details": "Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role."
+      },
+      "grantRole(bytes32,address)": {
+        "details": "Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role."
+      },
+      "grantRoles(bytes32[],address)": {
+        "details": "Grants multiple roles to a single account."
+      },
+      "grantRolesToMany(bytes32[],address[])": {
+        "details": "Grants roles to a list of accounts."
+      },
+      "hasRole(bytes32,address)": {
+        "details": "Returns `true` if `account` has been granted `role`."
+      },
+      "renounceRole(bytes32,address)": {
+        "details": "Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`."
+      },
+      "revokeRole(bytes32,address)": {
+        "details": "Revokes `role` from `account`. If `account` had already been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role."
+      },
+      "revokeRoles(bytes32[],address)": {
+        "details": "Revokes multiple roles from a single account."
+      },
+      "revokeRolesFromMany(bytes32[],address[])": {
+        "details": "Revokes roles from a list of accounts."
+      }
+    },
+    "version": 1
+  },
+  "userdoc": {
+    "kind": "user",
+    "methods": {},
+    "version": 1
+  },
+  "_disabled": [
     {
       "inputs": [],
       "name": "DEFAULT_ADMIN_ROLE",
@@ -190,42 +274,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes32",
-          "name": "role",
-          "type": "bytes32"
-        },
-        {
-          "internalType": "address",
-          "name": "account",
-          "type": "address"
-        }
-      ],
-      "name": "grantRole",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes32[]",
-          "name": "roles",
-          "type": "bytes32[]"
-        },
-        {
-          "internalType": "address",
-          "name": "account",
-          "type": "address"
-        }
-      ],
-      "name": "grantRoles",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -340,51 +388,5 @@
       "stateMutability": "nonpayable",
       "type": "function"
     }
-  ],
-  "bytecode": "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",
-  "devdoc": {
-    "details": "Basic Authorizer implementation, based on OpenZeppelin's Access Control. Users are allowed to perform actions if they have the role with the same identifier. In this sense, roles are not being truly used as such, since they each map to a single action identifier. This temporary implementation is expected to be replaced soon after launch by a more sophisticated one, able to manage permissions across multiple contracts and to natively handle timelocks.",
-    "kind": "dev",
-    "methods": {
-      "getRoleAdmin(bytes32)": {
-        "details": "Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."
-      },
-      "getRoleMember(bytes32,uint256)": {
-        "details": "Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information."
-      },
-      "getRoleMemberCount(bytes32)": {
-        "details": "Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role."
-      },
-      "grantRole(bytes32,address)": {
-        "details": "Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role."
-      },
-      "grantRoles(bytes32[],address)": {
-        "details": "Grants multiple roles to a single account."
-      },
-      "grantRolesToMany(bytes32[],address[])": {
-        "details": "Grants roles to a list of accounts."
-      },
-      "hasRole(bytes32,address)": {
-        "details": "Returns `true` if `account` has been granted `role`."
-      },
-      "renounceRole(bytes32,address)": {
-        "details": "Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`."
-      },
-      "revokeRole(bytes32,address)": {
-        "details": "Revokes `role` from `account`. If `account` had already been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role."
-      },
-      "revokeRoles(bytes32[],address)": {
-        "details": "Revokes multiple roles from a single account."
-      },
-      "revokeRolesFromMany(bytes32[],address[])": {
-        "details": "Revokes roles from a list of accounts."
-      }
-    },
-    "version": 1
-  },
-  "userdoc": {
-    "kind": "user",
-    "methods": {},
-    "version": 1
-  }
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/BalancerV2BasePool.json b/contracts/artifacts/BalancerV2BasePool.json
index 304a555430..34ffd8baca 100644
--- a/contracts/artifacts/BalancerV2BasePool.json
+++ b/contracts/artifacts/BalancerV2BasePool.json
@@ -170,14 +170,31 @@
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "getPausedState",
+      "outputs": [
         {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
+          "internalType": "bool",
+          "name": "paused",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowEndTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodEndTime",
+          "type": "uint256"
         }
       ],
-      "name": "getActionId",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -190,12 +207,12 @@
     },
     {
       "inputs": [],
-      "name": "getAuthorizer",
+      "name": "getSwapFeePercentage",
       "outputs": [
         {
-          "internalType": "contract IAuthorizer",
+          "internalType": "uint256",
           "name": "",
-          "type": "address"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -203,74 +220,161 @@
     },
     {
       "inputs": [],
-      "name": "getOwner",
+      "name": "name",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "string",
           "name": "",
-          "type": "address"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getPausedState",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "nonces",
       "outputs": [
         {
-          "internalType": "bool",
-          "name": "paused",
-          "type": "bool"
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "pauseWindowEndTime",
+          "name": "value",
           "type": "uint256"
         },
         {
           "internalType": "uint256",
-          "name": "bufferPeriodEndTime",
+          "name": "deadline",
           "type": "uint256"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
         }
       ],
-      "stateMutability": "view",
+      "name": "permit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [],
-      "name": "getPoolId",
+      "name": "symbol",
       "outputs": [
         {
-          "internalType": "bytes32",
+          "internalType": "string",
           "name": "",
-          "type": "bytes32"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getSwapFeePercentage",
-      "outputs": [
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
         {
           "internalType": "uint256",
-          "name": "",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "stateMutability": "view",
+      "name": "transfer",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getVault",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "transferFrom",
       "outputs": [
         {
-          "internalType": "contract IVault",
+          "internalType": "bool",
           "name": "",
-          "type": "address"
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
         }
       ],
       "stateMutability": "view",
@@ -278,31 +382,38 @@
     },
     {
       "inputs": [],
-      "name": "name",
+      "name": "getAuthorizer",
       "outputs": [
         {
-          "internalType": "string",
+          "internalType": "contract IAuthorizer",
           "name": "",
-          "type": "string"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "getOwner",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "owner",
+          "name": "",
           "type": "address"
         }
       ],
-      "name": "nonces",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getVault",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "contract IVault",
           "name": "",
-          "type": "uint256"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -416,49 +527,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint8",
-          "name": "v",
-          "type": "uint8"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "r",
-          "type": "bytes32"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "s",
-          "type": "bytes32"
-        }
-      ],
-      "name": "permit",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -593,19 +661,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "totalSupply",
@@ -618,59 +673,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transfer",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transferFrom",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
 }
diff --git a/contracts/artifacts/BalancerV2BasePoolFactory.json b/contracts/artifacts/BalancerV2BasePoolFactory.json
index b11b9c2e61..cbdd83ddcb 100644
--- a/contracts/artifacts/BalancerV2BasePoolFactory.json
+++ b/contracts/artifacts/BalancerV2BasePoolFactory.json
@@ -12,7 +12,9 @@
       ],
       "name": "PoolCreated",
       "type": "event"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [],
       "name": "getVault",
diff --git a/contracts/artifacts/BalancerV2ComposableStablePool.json b/contracts/artifacts/BalancerV2ComposableStablePool.json
index c3c36cdb5d..703f50c58c 100644
--- a/contracts/artifacts/BalancerV2ComposableStablePool.json
+++ b/contracts/artifacts/BalancerV2ComposableStablePool.json
@@ -281,7 +281,74 @@
     },
     {
       "inputs": [],
-      "name": "DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL",
+      "name": "DOMAIN_SEPARATOR",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "allowance",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "approve",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "account",
+          "type": "address"
+        }
+      ],
+      "name": "balanceOf",
       "outputs": [
         {
           "internalType": "uint256",
@@ -294,7 +361,66 @@
     },
     {
       "inputs": [],
-      "name": "DOMAIN_SEPARATOR",
+      "name": "decimals",
+      "outputs": [
+        {
+          "internalType": "uint8",
+          "name": "",
+          "type": "uint8"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getAmplificationParameter",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "isUpdating",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "precision",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPausedState",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "paused",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowEndTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodEndTime",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPoolId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -305,6 +431,71 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "getScalingFactors",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getSwapFeePercentage",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "name",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "nonces",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "pause",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -316,14 +507,46 @@
           "internalType": "address",
           "name": "spender",
           "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
         }
       ],
-      "name": "allowance",
+      "name": "permit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "symbol",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "string",
           "name": "",
-          "type": "uint256"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
@@ -333,7 +556,7 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "spender",
+          "name": "recipient",
           "type": "address"
         },
         {
@@ -342,7 +565,7 @@
           "type": "uint256"
         }
       ],
-      "name": "approve",
+      "name": "transfer",
       "outputs": [
         {
           "internalType": "bool",
@@ -357,29 +580,54 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "account",
+          "name": "sender",
           "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
         }
       ],
-      "name": "balanceOf",
+      "name": "transferFrom",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
           "name": "",
-          "type": "uint256"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [],
-      "name": "decimals",
+      "name": "DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL",
       "outputs": [
         {
-          "internalType": "uint8",
+          "internalType": "uint256",
           "name": "",
-          "type": "uint8"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -455,29 +703,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "getAmplificationParameter",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bool",
-          "name": "isUpdating",
-          "type": "bool"
-        },
-        {
-          "internalType": "uint256",
-          "name": "precision",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "getAuthorizer",
@@ -580,42 +805,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "getPausedState",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "paused",
-          "type": "bool"
-        },
-        {
-          "internalType": "uint256",
-          "name": "pauseWindowEndTime",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "bufferPeriodEndTime",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getPoolId",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -687,32 +876,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "getScalingFactors",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getSwapFeePercentage",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -835,38 +998,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "name",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        }
-      ],
-      "name": "nonces",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -1056,56 +1187,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "pause",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint8",
-          "name": "v",
-          "type": "uint8"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "r",
-          "type": "bytes32"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "s",
-          "type": "bytes32"
-        }
-      ],
-      "name": "permit",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -1288,19 +1369,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "totalSupply",
@@ -1314,59 +1382,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transfer",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transferFrom",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "unpause",
@@ -1393,19 +1408,6 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json
index 699b15575d..75d73ce83d 100644
--- a/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactory.json
@@ -111,6 +111,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -262,19 +277,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
index 699b15575d..75d73ce83d 100644
--- a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV3.json
@@ -111,6 +111,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -262,19 +277,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
index 699b15575d..75d73ce83d 100644
--- a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV4.json
@@ -111,6 +111,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -262,19 +277,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
index 699b15575d..75d73ce83d 100644
--- a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV5.json
@@ -111,6 +111,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -262,19 +277,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
index 699b15575d..75d73ce83d 100644
--- a/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
+++ b/contracts/artifacts/BalancerV2ComposableStablePoolFactoryV6.json
@@ -111,6 +111,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -262,19 +277,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json b/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json
index cb791acd13..c1c66b3f2e 100644
--- a/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json
+++ b/contracts/artifacts/BalancerV2LiquidityBootstrappingPool.json
@@ -270,38 +270,44 @@
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
+      "inputs": [],
+      "name": "getNormalizedWeights",
+      "outputs": [
         {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
+          "internalType": "uint256[]",
+          "name": "",
+          "type": "uint256[]"
         }
       ],
-      "name": "decreaseAllowance",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPausedState",
       "outputs": [
         {
           "internalType": "bool",
-          "name": "",
+          "name": "paused",
           "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowEndTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodEndTime",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        }
-      ],
-      "name": "getActionId",
+      "inputs": [],
+      "name": "getPoolId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -314,12 +320,12 @@
     },
     {
       "inputs": [],
-      "name": "getAuthorizer",
+      "name": "getScalingFactors",
       "outputs": [
         {
-          "internalType": "contract IAuthorizer",
+          "internalType": "uint256[]",
           "name": "",
-          "type": "address"
+          "type": "uint256[]"
         }
       ],
       "stateMutability": "view",
@@ -327,22 +333,12 @@
     },
     {
       "inputs": [],
-      "name": "getGradualWeightUpdateParams",
+      "name": "getSwapEnabled",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "startTime",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "endTime",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256[]",
-          "name": "endWeights",
-          "type": "uint256[]"
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
         }
       ],
       "stateMutability": "view",
@@ -350,7 +346,7 @@
     },
     {
       "inputs": [],
-      "name": "getInvariant",
+      "name": "getSwapFeePercentage",
       "outputs": [
         {
           "internalType": "uint256",
@@ -363,69 +359,180 @@
     },
     {
       "inputs": [],
-      "name": "getLastInvariant",
+      "name": "name",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "string",
           "name": "",
-          "type": "uint256"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getNormalizedWeights",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "nonces",
       "outputs": [
         {
-          "internalType": "uint256[]",
+          "internalType": "uint256",
           "name": "",
-          "type": "uint256[]"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
+        }
+      ],
+      "name": "permit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [],
-      "name": "getOwner",
+      "name": "symbol",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "string",
           "name": "",
-          "type": "address"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getPausedState",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "transfer",
       "outputs": [
         {
           "internalType": "bool",
-          "name": "paused",
+          "name": "",
           "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "pauseWindowEndTime",
+          "name": "amount",
           "type": "uint256"
+        }
+      ],
+      "name": "transferFrom",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "bufferPeriodEndTime",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "stateMutability": "view",
+      "name": "decreaseAllowance",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getPoolId",
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -438,12 +545,12 @@
     },
     {
       "inputs": [],
-      "name": "getRate",
+      "name": "getAuthorizer",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "contract IAuthorizer",
           "name": "",
-          "type": "uint256"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -451,11 +558,21 @@
     },
     {
       "inputs": [],
-      "name": "getScalingFactors",
+      "name": "getGradualWeightUpdateParams",
       "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "startTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "endTime",
+          "type": "uint256"
+        },
         {
           "internalType": "uint256[]",
-          "name": "",
+          "name": "endWeights",
           "type": "uint256[]"
         }
       ],
@@ -464,12 +581,12 @@
     },
     {
       "inputs": [],
-      "name": "getSwapEnabled",
+      "name": "getInvariant",
       "outputs": [
         {
-          "internalType": "bool",
+          "internalType": "uint256",
           "name": "",
-          "type": "bool"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -477,7 +594,7 @@
     },
     {
       "inputs": [],
-      "name": "getSwapFeePercentage",
+      "name": "getLastInvariant",
       "outputs": [
         {
           "internalType": "uint256",
@@ -490,10 +607,10 @@
     },
     {
       "inputs": [],
-      "name": "getVault",
+      "name": "getOwner",
       "outputs": [
         {
-          "internalType": "contract IVault",
+          "internalType": "address",
           "name": "",
           "type": "address"
         }
@@ -502,37 +619,26 @@
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "addedValue",
-          "type": "uint256"
-        }
-      ],
-      "name": "increaseAllowance",
+      "inputs": [],
+      "name": "getRate",
       "outputs": [
         {
-          "internalType": "bool",
+          "internalType": "uint256",
           "name": "",
-          "type": "bool"
+          "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [],
-      "name": "name",
+      "name": "getVault",
       "outputs": [
         {
-          "internalType": "string",
+          "internalType": "contract IVault",
           "name": "",
-          "type": "string"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -542,19 +648,24 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "owner",
+          "name": "spender",
           "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "addedValue",
+          "type": "uint256"
         }
       ],
-      "name": "nonces",
+      "name": "increaseAllowance",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "bool",
           "name": "",
-          "type": "uint256"
+          "type": "bool"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -741,49 +852,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint8",
-          "name": "v",
-          "type": "uint8"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "r",
-          "type": "bytes32"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "s",
-          "type": "bytes32"
-        }
-      ],
-      "name": "permit",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -949,19 +1017,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "totalSupply",
@@ -975,59 +1030,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transfer",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transferFrom",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -1052,4 +1054,4 @@
       "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json b/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json
index 91bf462796..ab8352a0bb 100644
--- a/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json
+++ b/contracts/artifacts/BalancerV2LiquidityBootstrappingPoolFactory.json
@@ -72,7 +72,9 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [],
       "name": "getCreationCode",
@@ -155,4 +157,4 @@
       "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json b/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
index 91bf462796..ab8352a0bb 100644
--- a/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
+++ b/contracts/artifacts/BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory.json
@@ -72,7 +72,9 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [],
       "name": "getCreationCode",
@@ -155,4 +157,4 @@
       "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2StablePool.json b/contracts/artifacts/BalancerV2StablePool.json
index 764622b457..e82fb11951 100644
--- a/contracts/artifacts/BalancerV2StablePool.json
+++ b/contracts/artifacts/BalancerV2StablePool.json
@@ -265,38 +265,54 @@
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "getAmplificationParameter",
+      "outputs": [
         {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bool",
+          "name": "isUpdating",
+          "type": "bool"
         },
         {
           "internalType": "uint256",
-          "name": "amount",
+          "name": "precision",
           "type": "uint256"
         }
       ],
-      "name": "decreaseAllowance",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPausedState",
       "outputs": [
         {
           "internalType": "bool",
-          "name": "",
+          "name": "paused",
           "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowEndTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodEndTime",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        }
-      ],
-      "name": "getActionId",
+      "inputs": [],
+      "name": "getPoolId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -309,21 +325,11 @@
     },
     {
       "inputs": [],
-      "name": "getAmplificationParameter",
+      "name": "getSwapFeePercentage",
       "outputs": [
         {
           "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bool",
-          "name": "isUpdating",
-          "type": "bool"
-        },
-        {
-          "internalType": "uint256",
-          "name": "precision",
+          "name": "",
           "type": "uint256"
         }
       ],
@@ -332,105 +338,147 @@
     },
     {
       "inputs": [],
-      "name": "getAuthorizer",
+      "name": "name",
       "outputs": [
         {
-          "internalType": "contract IAuthorizer",
+          "internalType": "string",
           "name": "",
-          "type": "address"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getOwner",
-      "outputs": [
+      "inputs": [
         {
           "internalType": "address",
-          "name": "",
+          "name": "owner",
           "type": "address"
         }
       ],
+      "name": "nonces",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getPausedState",
-      "outputs": [
+      "inputs": [
         {
-          "internalType": "bool",
-          "name": "paused",
-          "type": "bool"
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "pauseWindowEndTime",
+          "name": "value",
           "type": "uint256"
         },
         {
           "internalType": "uint256",
-          "name": "bufferPeriodEndTime",
+          "name": "deadline",
           "type": "uint256"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
         }
       ],
-      "stateMutability": "view",
+      "name": "permit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [],
-      "name": "getPoolId",
+      "name": "symbol",
       "outputs": [
         {
-          "internalType": "bytes32",
+          "internalType": "string",
           "name": "",
-          "type": "bytes32"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getRate",
-      "outputs": [
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
         {
           "internalType": "uint256",
-          "name": "",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getSwapFeePercentage",
+      "name": "transfer",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "bool",
           "name": "",
-          "type": "uint256"
+          "type": "bool"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getVault",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "transferFrom",
       "outputs": [
         {
-          "internalType": "contract IVault",
+          "internalType": "bool",
           "name": "",
-          "type": "address"
+          "type": "bool"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -440,11 +488,11 @@
         },
         {
           "internalType": "uint256",
-          "name": "addedValue",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "name": "increaseAllowance",
+      "name": "decreaseAllowance",
       "outputs": [
         {
           "internalType": "bool",
@@ -455,28 +503,54 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [],
-      "name": "name",
+      "name": "getAuthorizer",
       "outputs": [
         {
-          "internalType": "string",
+          "internalType": "contract IAuthorizer",
           "name": "",
-          "type": "string"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "getOwner",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "owner",
+          "name": "",
           "type": "address"
         }
       ],
-      "name": "nonces",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getRate",
       "outputs": [
         {
           "internalType": "uint256",
@@ -487,6 +561,43 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "getVault",
+      "outputs": [
+        {
+          "internalType": "contract IVault",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "addedValue",
+          "type": "uint256"
+        }
+      ],
+      "name": "increaseAllowance",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -752,49 +863,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint8",
-          "name": "v",
-          "type": "uint8"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "r",
-          "type": "bytes32"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "s",
-          "type": "bytes32"
-        }
-      ],
-      "name": "permit",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -972,19 +1040,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "totalSupply",
@@ -997,59 +1052,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transfer",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transferFrom",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2StablePoolFactoryV2.json b/contracts/artifacts/BalancerV2StablePoolFactoryV2.json
index 72bf185cf6..1492dde6b1 100644
--- a/contracts/artifacts/BalancerV2StablePoolFactoryV2.json
+++ b/contracts/artifacts/BalancerV2StablePoolFactoryV2.json
@@ -80,7 +80,9 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -208,4 +210,4 @@
       "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2Vault.json b/contracts/artifacts/BalancerV2Vault.json
index 628e630583..e0291e07fe 100644
--- a/contracts/artifacts/BalancerV2Vault.json
+++ b/contracts/artifacts/BalancerV2Vault.json
@@ -344,6 +344,10 @@
       "name": "TokensRegistered",
       "type": "event"
     },
+    {
+      "stateMutability": "payable",
+      "type": "receive"
+    },
     {
       "inputs": [],
       "name": "WETH",
@@ -453,95 +457,214 @@
     {
       "inputs": [
         {
-          "internalType": "bytes32",
-          "name": "poolId",
-          "type": "bytes32"
+          "internalType": "contract IFlashLoanRecipient",
+          "name": "recipient",
+          "type": "address"
         },
         {
           "internalType": "contract IERC20[]",
           "name": "tokens",
           "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "bytes",
+          "name": "userData",
+          "type": "bytes"
         }
       ],
-      "name": "deregisterTokens",
+      "name": "flashLoan",
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        }
+      ],
+      "name": "getInternalBalance",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "balances",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPausedState",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "paused",
+          "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowEndTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodEndTime",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
           "internalType": "bytes32",
           "name": "poolId",
           "type": "bytes32"
-        },
+        }
+      ],
+      "name": "getPool",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "sender",
+          "name": "",
           "type": "address"
         },
         {
-          "internalType": "address payable",
-          "name": "recipient",
+          "internalType": "enum IVault.PoolSpecialization",
+          "name": "",
+          "type": "uint8"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "poolId",
+          "type": "bytes32"
+        }
+      ],
+      "name": "getPoolTokens",
+      "outputs": [
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "balances",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "lastChangeBlock",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
           "type": "address"
         },
+        {
+          "internalType": "address",
+          "name": "relayer",
+          "type": "address"
+        }
+      ],
+      "name": "hasApprovedRelayer",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
         {
           "components": [
             {
-              "internalType": "contract IAsset[]",
-              "name": "assets",
-              "type": "address[]"
+              "internalType": "enum IVault.UserBalanceOpKind",
+              "name": "kind",
+              "type": "uint8"
             },
             {
-              "internalType": "uint256[]",
-              "name": "minAmountsOut",
-              "type": "uint256[]"
+              "internalType": "contract IAsset",
+              "name": "asset",
+              "type": "address"
             },
             {
-              "internalType": "bytes",
-              "name": "userData",
-              "type": "bytes"
+              "internalType": "uint256",
+              "name": "amount",
+              "type": "uint256"
             },
             {
-              "internalType": "bool",
-              "name": "toInternalBalance",
-              "type": "bool"
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address payable",
+              "name": "recipient",
+              "type": "address"
             }
           ],
-          "internalType": "struct IVault.ExitPoolRequest",
-          "name": "request",
-          "type": "tuple"
+          "internalType": "struct IVault.UserBalanceOp[]",
+          "name": "ops",
+          "type": "tuple[]"
         }
       ],
-      "name": "exitPool",
+      "name": "manageUserBalance",
       "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "contract IFlashLoanRecipient",
-          "name": "recipient",
+          "internalType": "address",
+          "name": "sender",
           "type": "address"
         },
         {
-          "internalType": "contract IERC20[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
+          "internalType": "address",
+          "name": "relayer",
+          "type": "address"
         },
         {
-          "internalType": "bytes",
-          "name": "userData",
-          "type": "bytes"
+          "internalType": "bool",
+          "name": "approved",
+          "type": "bool"
         }
       ],
-      "name": "flashLoan",
+      "name": "setRelayerApproval",
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
@@ -549,86 +672,176 @@
     {
       "inputs": [
         {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        }
-      ],
-      "name": "getActionId",
-      "outputs": [
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "poolId",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "enum IVault.SwapKind",
+              "name": "kind",
+              "type": "uint8"
+            },
+            {
+              "internalType": "contract IAsset",
+              "name": "assetIn",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IAsset",
+              "name": "assetOut",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "amount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "userData",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IVault.SingleSwap",
+          "name": "singleSwap",
+          "type": "tuple"
+        },
         {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
+          "components": [
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "bool",
+              "name": "fromInternalBalance",
+              "type": "bool"
+            },
+            {
+              "internalType": "address payable",
+              "name": "recipient",
+              "type": "address"
+            },
+            {
+              "internalType": "bool",
+              "name": "toInternalBalance",
+              "type": "bool"
+            }
+          ],
+          "internalType": "struct IVault.FundManagement",
+          "name": "funds",
+          "type": "tuple"
+        },
+        {
+          "internalType": "uint256",
+          "name": "limit",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getAuthorizer",
+      "name": "swap",
       "outputs": [
         {
-          "internalType": "contract IAuthorizer",
-          "name": "",
-          "type": "address"
+          "internalType": "uint256",
+          "name": "amountCalculated",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "payable",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
-      "inputs": [],
-      "name": "getDomainSeparator",
-      "outputs": [
+      "inputs": [
         {
           "internalType": "bytes32",
-          "name": "",
+          "name": "poolId",
           "type": "bytes32"
+        },
+        {
+          "internalType": "contract IERC20[]",
+          "name": "tokens",
+          "type": "address[]"
         }
       ],
-      "stateMutability": "view",
+      "name": "deregisterTokens",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "poolId",
+          "type": "bytes32"
+        },
         {
           "internalType": "address",
-          "name": "user",
+          "name": "sender",
           "type": "address"
         },
         {
-          "internalType": "contract IERC20[]",
-          "name": "tokens",
-          "type": "address[]"
-        }
-      ],
-      "name": "getInternalBalance",
-      "outputs": [
+          "internalType": "address payable",
+          "name": "recipient",
+          "type": "address"
+        },
         {
-          "internalType": "uint256[]",
-          "name": "balances",
-          "type": "uint256[]"
+          "components": [
+            {
+              "internalType": "contract IAsset[]",
+              "name": "assets",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "minAmountsOut",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "bytes",
+              "name": "userData",
+              "type": "bytes"
+            },
+            {
+              "internalType": "bool",
+              "name": "toInternalBalance",
+              "type": "bool"
+            }
+          ],
+          "internalType": "struct IVault.ExitPoolRequest",
+          "name": "request",
+          "type": "tuple"
         }
       ],
-      "stateMutability": "view",
+      "name": "exitPool",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "address",
-          "name": "user",
-          "type": "address"
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
         }
       ],
-      "name": "getNextNonce",
+      "name": "getActionId",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "bytes32",
           "name": "",
-          "type": "uint256"
+          "type": "bytes32"
         }
       ],
       "stateMutability": "view",
@@ -636,46 +849,44 @@
     },
     {
       "inputs": [],
-      "name": "getPausedState",
+      "name": "getAuthorizer",
       "outputs": [
         {
-          "internalType": "bool",
-          "name": "paused",
-          "type": "bool"
-        },
-        {
-          "internalType": "uint256",
-          "name": "pauseWindowEndTime",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "bufferPeriodEndTime",
-          "type": "uint256"
+          "internalType": "contract IAuthorizer",
+          "name": "",
+          "type": "address"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "getDomainSeparator",
+      "outputs": [
         {
           "internalType": "bytes32",
-          "name": "poolId",
+          "name": "",
           "type": "bytes32"
         }
       ],
-      "name": "getPool",
-      "outputs": [
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
         {
           "internalType": "address",
-          "name": "",
+          "name": "user",
           "type": "address"
-        },
+        }
+      ],
+      "name": "getNextNonce",
+      "outputs": [
         {
-          "internalType": "enum IVault.PoolSpecialization",
+          "internalType": "uint256",
           "name": "",
-          "type": "uint8"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -720,35 +931,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes32",
-          "name": "poolId",
-          "type": "bytes32"
-        }
-      ],
-      "name": "getPoolTokens",
-      "outputs": [
-        {
-          "internalType": "contract IERC20[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
-        {
-          "internalType": "uint256[]",
-          "name": "balances",
-          "type": "uint256[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "lastChangeBlock",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "getProtocolFeesCollector",
@@ -762,30 +944,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "user",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "relayer",
-          "type": "address"
-        }
-      ],
-      "name": "hasApprovedRelayer",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -871,46 +1029,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "enum IVault.UserBalanceOpKind",
-              "name": "kind",
-              "type": "uint8"
-            },
-            {
-              "internalType": "contract IAsset",
-              "name": "asset",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "amount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "address payable",
-              "name": "recipient",
-              "type": "address"
-            }
-          ],
-          "internalType": "struct IVault.UserBalanceOp[]",
-          "name": "ops",
-          "type": "tuple[]"
-        }
-      ],
-      "name": "manageUserBalance",
-      "outputs": [],
-      "stateMutability": "payable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -1061,122 +1179,6 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "relayer",
-          "type": "address"
-        },
-        {
-          "internalType": "bool",
-          "name": "approved",
-          "type": "bool"
-        }
-      ],
-      "name": "setRelayerApproval",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "bytes32",
-              "name": "poolId",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "enum IVault.SwapKind",
-              "name": "kind",
-              "type": "uint8"
-            },
-            {
-              "internalType": "contract IAsset",
-              "name": "assetIn",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IAsset",
-              "name": "assetOut",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "amount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "bytes",
-              "name": "userData",
-              "type": "bytes"
-            }
-          ],
-          "internalType": "struct IVault.SingleSwap",
-          "name": "singleSwap",
-          "type": "tuple"
-        },
-        {
-          "components": [
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "bool",
-              "name": "fromInternalBalance",
-              "type": "bool"
-            },
-            {
-              "internalType": "address payable",
-              "name": "recipient",
-              "type": "address"
-            },
-            {
-              "internalType": "bool",
-              "name": "toInternalBalance",
-              "type": "bool"
-            }
-          ],
-          "internalType": "struct IVault.FundManagement",
-          "name": "funds",
-          "type": "tuple"
-        },
-        {
-          "internalType": "uint256",
-          "name": "limit",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swap",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountCalculated",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "stateMutability": "payable",
-      "type": "receive"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/BalancerV2WeightedPool.json b/contracts/artifacts/BalancerV2WeightedPool.json
index d8d777cff7..4009c41c20 100644
--- a/contracts/artifacts/BalancerV2WeightedPool.json
+++ b/contracts/artifacts/BalancerV2WeightedPool.json
@@ -221,38 +221,44 @@
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
+      "inputs": [],
+      "name": "getNormalizedWeights",
+      "outputs": [
         {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
+          "internalType": "uint256[]",
+          "name": "",
+          "type": "uint256[]"
         }
       ],
-      "name": "decreaseApproval",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getPausedState",
       "outputs": [
         {
           "internalType": "bool",
-          "name": "",
+          "name": "paused",
           "type": "bool"
+        },
+        {
+          "internalType": "uint256",
+          "name": "pauseWindowEndTime",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "bufferPeriodEndTime",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        }
-      ],
-      "name": "getActionId",
+      "inputs": [],
+      "name": "getPoolId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -265,12 +271,12 @@
     },
     {
       "inputs": [],
-      "name": "getAuthorizer",
+      "name": "getSwapFeePercentage",
       "outputs": [
         {
-          "internalType": "contract IAuthorizer",
+          "internalType": "uint256",
           "name": "",
-          "type": "address"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -278,20 +284,26 @@
     },
     {
       "inputs": [],
-      "name": "getInvariant",
+      "name": "name",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "string",
           "name": "",
-          "type": "uint256"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getLastInvariant",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        }
+      ],
+      "name": "nonces",
       "outputs": [
         {
           "internalType": "uint256",
@@ -303,57 +315,149 @@
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getNormalizedWeights",
-      "outputs": [
+      "inputs": [
         {
-          "internalType": "uint256[]",
-          "name": "",
-          "type": "uint256[]"
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
         }
       ],
-      "stateMutability": "view",
+      "name": "permit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [],
-      "name": "getOwner",
+      "name": "symbol",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "string",
           "name": "",
-          "type": "address"
+          "type": "string"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getPausedState",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "transfer",
       "outputs": [
         {
           "internalType": "bool",
-          "name": "paused",
+          "name": "",
           "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "pauseWindowEndTime",
+          "name": "amount",
           "type": "uint256"
+        }
+      ],
+      "name": "transferFrom",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "bufferPeriodEndTime",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "stateMutability": "view",
+      "name": "decreaseApproval",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getPoolId",
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        }
+      ],
+      "name": "getActionId",
       "outputs": [
         {
           "internalType": "bytes32",
@@ -366,12 +470,12 @@
     },
     {
       "inputs": [],
-      "name": "getRate",
+      "name": "getAuthorizer",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "contract IAuthorizer",
           "name": "",
-          "type": "uint256"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -379,7 +483,7 @@
     },
     {
       "inputs": [],
-      "name": "getSwapFeePercentage",
+      "name": "getInvariant",
       "outputs": [
         {
           "internalType": "uint256",
@@ -392,49 +496,51 @@
     },
     {
       "inputs": [],
-      "name": "getVault",
+      "name": "getLastInvariant",
       "outputs": [
         {
-          "internalType": "contract IVault",
+          "internalType": "uint256",
           "name": "",
-          "type": "address"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "getOwner",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "spender",
+          "name": "",
           "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
         }
       ],
-      "name": "increaseApproval",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getRate",
       "outputs": [
         {
-          "internalType": "bool",
+          "internalType": "uint256",
           "name": "",
-          "type": "bool"
+          "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [],
-      "name": "name",
+      "name": "getVault",
       "outputs": [
         {
-          "internalType": "string",
+          "internalType": "contract IVault",
           "name": "",
-          "type": "string"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -444,19 +550,24 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "owner",
+          "name": "spender",
           "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
         }
       ],
-      "name": "nonces",
+      "name": "increaseApproval",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "bool",
           "name": "",
-          "type": "uint256"
+          "type": "bool"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -643,49 +754,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint8",
-          "name": "v",
-          "type": "uint8"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "r",
-          "type": "bytes32"
-        },
-        {
-          "internalType": "bytes32",
-          "name": "s",
-          "type": "bytes32"
-        }
-      ],
-      "name": "permit",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -820,19 +888,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "totalSupply",
@@ -845,59 +900,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transfer",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "name": "transferFrom",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json b/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json
index 2dd90dbbde..c0a4ff8e54 100644
--- a/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json
+++ b/contracts/artifacts/BalancerV2WeightedPool2TokensFactory.json
@@ -72,7 +72,10 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [],
       "name": "getPauseConfiguration",
@@ -123,6 +126,5 @@
       "stateMutability": "view",
       "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/BalancerV2WeightedPoolFactory.json b/contracts/artifacts/BalancerV2WeightedPoolFactory.json
index ebd97e1e2f..18feaf9fa5 100644
--- a/contracts/artifacts/BalancerV2WeightedPoolFactory.json
+++ b/contracts/artifacts/BalancerV2WeightedPoolFactory.json
@@ -67,7 +67,10 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [],
       "name": "getPauseConfiguration",
@@ -118,6 +121,5 @@
       "stateMutability": "view",
       "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json b/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json
index 17bfe6a1b4..2ad632b064 100644
--- a/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json
+++ b/contracts/artifacts/BalancerV2WeightedPoolFactoryV3.json
@@ -101,6 +101,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -252,19 +267,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
 }
diff --git a/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json b/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
index 17bfe6a1b4..2ad632b064 100644
--- a/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
+++ b/contracts/artifacts/BalancerV2WeightedPoolFactoryV4.json
@@ -101,6 +101,21 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -252,19 +267,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
     }
   ]
 }
diff --git a/contracts/artifacts/BalancerV3BatchRouter.json b/contracts/artifacts/BalancerV3BatchRouter.json
index 645cf4e136..e5c865a083 100644
--- a/contracts/artifacts/BalancerV3BatchRouter.json
+++ b/contracts/artifacts/BalancerV3BatchRouter.json
@@ -129,6 +129,29 @@
       "name": "TransientIndexOutOfBounds",
       "type": "error"
     },
+    {
+      "stateMutability": "payable",
+      "type": "receive"
+    },
+    {
+      "inputs": [],
+      "name": "version",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "deployedBytecode": "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",
+  "linkReferences": {},
+  "deployedLinkReferences": {},
+  "_disabled": [
     {
       "inputs": [],
       "name": "getSender",
@@ -972,27 +995,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "version",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "stateMutability": "payable",
-      "type": "receive"
     }
-  ],
-  "bytecode": "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",
-  "deployedBytecode": "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",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
+  ]
 }
diff --git a/contracts/artifacts/BaoswapRouter.json b/contracts/artifacts/BaoswapRouter.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/BaoswapRouter.json
+++ b/contracts/artifacts/BaoswapRouter.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/ChainalysisOracle.json b/contracts/artifacts/ChainalysisOracle.json
index 7b7318b2b8..066ba42f7a 100644
--- a/contracts/artifacts/ChainalysisOracle.json
+++ b/contracts/artifacts/ChainalysisOracle.json
@@ -76,19 +76,6 @@
       "name": "SanctionedAddressesRemoved",
       "type": "event"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address[]",
-          "name": "newSanctions",
-          "type": "address[]"
-        }
-      ],
-      "name": "addToSanctionsList",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -108,25 +95,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "addr",
-          "type": "address"
-        }
-      ],
-      "name": "isSanctionedVerbose",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "name",
@@ -152,6 +120,40 @@
       ],
       "stateMutability": "view",
       "type": "function"
+    }
+  ],
+  "_disabled": [
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "newSanctions",
+          "type": "address[]"
+        }
+      ],
+      "name": "addToSanctionsList",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "addr",
+          "type": "address"
+        }
+      ],
+      "name": "isSanctionedVerbose",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
     },
     {
       "inputs": [
diff --git a/contracts/artifacts/CoWSwapEthFlow.json b/contracts/artifacts/CoWSwapEthFlow.json
index d2ed8570c9..e4fcf8356f 100644
--- a/contracts/artifacts/CoWSwapEthFlow.json
+++ b/contracts/artifacts/CoWSwapEthFlow.json
@@ -201,17 +201,8 @@
       "type": "event"
     },
     {
-      "inputs": [],
-      "name": "cowSwapSettlement",
-      "outputs": [
-        {
-          "internalType": "contract ICoWSwapSettlement",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
+      "stateMutability": "payable",
+      "type": "receive"
     },
     {
       "inputs": [
@@ -472,6 +463,22 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
+    {
+      "inputs": [],
+      "name": "cowSwapSettlement",
+      "outputs": [
+        {
+          "internalType": "contract ICoWSwapSettlement",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
     },
     {
       "inputs": [],
@@ -492,11 +499,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "stateMutability": "payable",
-      "type": "receive"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/CowAmm.json b/contracts/artifacts/CowAmm.json
index 2f9b322da2..eed411938a 100644
--- a/contracts/artifacts/CowAmm.json
+++ b/contracts/artifacts/CowAmm.json
@@ -22,97 +22,25 @@
       "stateMutability": "nonpayable"
     },
     {
-      "type": "function",
-      "name": "COMMITMENT_SLOT",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "EMPTY_COMMITMENT",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bytes32",
-          "internalType": "bytes32"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "MAX_ORDER_DURATION",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint32",
-          "internalType": "uint32"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "NO_TRADING",
+      "type": "event",
+      "name": "TradingDisabled",
       "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bytes32",
-          "internalType": "bytes32"
-        }
-      ],
-      "stateMutability": "view"
+      "anonymous": false
     },
     {
-      "type": "function",
-      "name": "commit",
+      "type": "event",
+      "name": "TradingEnabled",
       "inputs": [
         {
-          "name": "orderHash",
-          "type": "bytes32",
-          "internalType": "bytes32"
-        }
-      ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "function",
-      "name": "commitment",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "value",
+          "name": "hash",
           "type": "bytes32",
+          "indexed": true,
           "internalType": "bytes32"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "disableTrading",
-      "inputs": [],
-      "outputs": [],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "function",
-      "name": "enableTrading",
-      "inputs": [
+        },
         {
-          "name": "tradingParams",
+          "name": "params",
           "type": "tuple",
+          "indexed": false,
           "internalType": "struct ConstantProduct.TradingParams",
           "components": [
             {
@@ -138,111 +66,77 @@
           ]
         }
       ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
+      "anonymous": false
     },
     {
-      "type": "function",
-      "name": "getTradeableOrder",
+      "type": "error",
+      "name": "CommitOutsideOfSettlement",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "OnlyManagerCanCall",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "OrderDoesNotMatchCommitmentHash",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "OrderDoesNotMatchDefaultTradeableOrder",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "OrderDoesNotMatchMessageHash",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "OrderNotValid",
       "inputs": [
         {
-          "name": "tradingParams",
-          "type": "tuple",
-          "internalType": "struct ConstantProduct.TradingParams",
-          "components": [
-            {
-              "name": "minTradedToken0",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "priceOracle",
-              "type": "address",
-              "internalType": "contract IPriceOracle"
-            },
-            {
-              "name": "priceOracleData",
-              "type": "bytes",
-              "internalType": "bytes"
-            },
-            {
-              "name": "appData",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            }
-          ]
+          "name": "",
+          "type": "string",
+          "internalType": "string"
         }
-      ],
-      "outputs": [
+      ]
+    },
+    {
+      "type": "error",
+      "name": "PollTryAtBlock",
+      "inputs": [
         {
-          "name": "order",
-          "type": "tuple",
-          "internalType": "struct GPv2Order.Data",
-          "components": [
-            {
-              "name": "sellToken",
-              "type": "address",
-              "internalType": "contract IERC20"
-            },
-            {
-              "name": "buyToken",
-              "type": "address",
-              "internalType": "contract IERC20"
-            },
-            {
-              "name": "receiver",
-              "type": "address",
-              "internalType": "address"
-            },
-            {
-              "name": "sellAmount",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "buyAmount",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "validTo",
-              "type": "uint32",
-              "internalType": "uint32"
-            },
-            {
-              "name": "appData",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "feeAmount",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "kind",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "partiallyFillable",
-              "type": "bool",
-              "internalType": "bool"
-            },
-            {
-              "name": "sellTokenBalance",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "buyTokenBalance",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            }
-          ]
+          "name": "blockNumber",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "message",
+          "type": "string",
+          "internalType": "string"
+        }
+      ]
+    },
+    {
+      "type": "error",
+      "name": "TradingParamsDoNotMatchHash",
+      "inputs": []
+    },
+    {
+      "type": "function",
+      "name": "commit",
+      "inputs": [
+        {
+          "name": "orderHash",
+          "type": "bytes32",
+          "internalType": "bytes32"
         }
       ],
-      "stateMutability": "view"
+      "outputs": [],
+      "stateMutability": "nonpayable"
     },
     {
       "type": "function",
@@ -322,32 +216,6 @@
       ],
       "stateMutability": "view"
     },
-    {
-      "type": "function",
-      "name": "solutionSettler",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "address",
-          "internalType": "contract ISettlement"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "solutionSettlerDomainSeparator",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bytes32",
-          "internalType": "bytes32"
-        }
-      ],
-      "stateMutability": "view"
-    },
     {
       "type": "function",
       "name": "token0",
@@ -374,19 +242,6 @@
       ],
       "stateMutability": "view"
     },
-    {
-      "type": "function",
-      "name": "tradingParamsHash",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bytes32",
-          "internalType": "bytes32"
-        }
-      ],
-      "stateMutability": "view"
-    },
     {
       "type": "function",
       "name": "verify",
@@ -481,117 +336,13 @@
             {
               "name": "buyTokenBalance",
               "type": "bytes32",
-              "internalType": "bytes32"
-            }
-          ]
-        }
-      ],
-      "outputs": [],
-      "stateMutability": "view"
-    },
-    {
-      "type": "event",
-      "name": "TradingDisabled",
-      "inputs": [],
-      "anonymous": false
-    },
-    {
-      "type": "event",
-      "name": "TradingEnabled",
-      "inputs": [
-        {
-          "name": "hash",
-          "type": "bytes32",
-          "indexed": true,
-          "internalType": "bytes32"
-        },
-        {
-          "name": "params",
-          "type": "tuple",
-          "indexed": false,
-          "internalType": "struct ConstantProduct.TradingParams",
-          "components": [
-            {
-              "name": "minTradedToken0",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "priceOracle",
-              "type": "address",
-              "internalType": "contract IPriceOracle"
-            },
-            {
-              "name": "priceOracleData",
-              "type": "bytes",
-              "internalType": "bytes"
-            },
-            {
-              "name": "appData",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            }
-          ]
-        }
-      ],
-      "anonymous": false
-    },
-    {
-      "type": "error",
-      "name": "CommitOutsideOfSettlement",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "OnlyManagerCanCall",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "OrderDoesNotMatchCommitmentHash",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "OrderDoesNotMatchDefaultTradeableOrder",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "OrderDoesNotMatchMessageHash",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "OrderNotValid",
-      "inputs": [
-        {
-          "name": "",
-          "type": "string",
-          "internalType": "string"
-        }
-      ]
-    },
-    {
-      "type": "error",
-      "name": "PollTryAtBlock",
-      "inputs": [
-        {
-          "name": "blockNumber",
-          "type": "uint256",
-          "internalType": "uint256"
-        },
-        {
-          "name": "message",
-          "type": "string",
-          "internalType": "string"
-        }
-      ]
-    },
-    {
-      "type": "error",
-      "name": "TradingParamsDoNotMatchHash",
-      "inputs": []
+              "internalType": "bytes32"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "view"
     }
   ],
   "bytecode": "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",
@@ -1496,5 +1247,256 @@
     },
     "version": 1
   },
-  "id": 169
+  "id": 169,
+  "_disabled": [
+    {
+      "type": "function",
+      "name": "COMMITMENT_SLOT",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "EMPTY_COMMITMENT",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "MAX_ORDER_DURATION",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint32",
+          "internalType": "uint32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "NO_TRADING",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "commitment",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "value",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "disableTrading",
+      "inputs": [],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "enableTrading",
+      "inputs": [
+        {
+          "name": "tradingParams",
+          "type": "tuple",
+          "internalType": "struct ConstantProduct.TradingParams",
+          "components": [
+            {
+              "name": "minTradedToken0",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "priceOracle",
+              "type": "address",
+              "internalType": "contract IPriceOracle"
+            },
+            {
+              "name": "priceOracleData",
+              "type": "bytes",
+              "internalType": "bytes"
+            },
+            {
+              "name": "appData",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "getTradeableOrder",
+      "inputs": [
+        {
+          "name": "tradingParams",
+          "type": "tuple",
+          "internalType": "struct ConstantProduct.TradingParams",
+          "components": [
+            {
+              "name": "minTradedToken0",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "priceOracle",
+              "type": "address",
+              "internalType": "contract IPriceOracle"
+            },
+            {
+              "name": "priceOracleData",
+              "type": "bytes",
+              "internalType": "bytes"
+            },
+            {
+              "name": "appData",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            }
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "order",
+          "type": "tuple",
+          "internalType": "struct GPv2Order.Data",
+          "components": [
+            {
+              "name": "sellToken",
+              "type": "address",
+              "internalType": "contract IERC20"
+            },
+            {
+              "name": "buyToken",
+              "type": "address",
+              "internalType": "contract IERC20"
+            },
+            {
+              "name": "receiver",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "sellAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "buyAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "validTo",
+              "type": "uint32",
+              "internalType": "uint32"
+            },
+            {
+              "name": "appData",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "feeAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "kind",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "partiallyFillable",
+              "type": "bool",
+              "internalType": "bool"
+            },
+            {
+              "name": "sellTokenBalance",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "buyTokenBalance",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            }
+          ]
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "solutionSettler",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "contract ISettlement"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "solutionSettlerDomainSeparator",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "tradingParamsHash",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    }
+  ]
 }
diff --git a/contracts/artifacts/CowAmmConstantProductFactory.json b/contracts/artifacts/CowAmmConstantProductFactory.json
index 131f459659..66ecf78cbc 100644
--- a/contracts/artifacts/CowAmmConstantProductFactory.json
+++ b/contracts/artifacts/CowAmmConstantProductFactory.json
@@ -12,250 +12,125 @@
       "stateMutability": "nonpayable"
     },
     {
-      "type": "function",
-      "name": "ammDeterministicAddress",
+      "type": "event",
+      "name": "ConditionalOrderCreated",
       "inputs": [
         {
-          "name": "ammOwner",
+          "name": "owner",
           "type": "address",
+          "indexed": true,
           "internalType": "address"
         },
         {
-          "name": "token0",
-          "type": "address",
-          "internalType": "contract IERC20"
-        },
-        {
-          "name": "token1",
-          "type": "address",
-          "internalType": "contract IERC20"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "address",
-          "internalType": "address"
+          "name": "params",
+          "type": "tuple",
+          "indexed": false,
+          "internalType": "struct IConditionalOrder.ConditionalOrderParams",
+          "components": [
+            {
+              "name": "handler",
+              "type": "address",
+              "internalType": "contract IConditionalOrder"
+            },
+            {
+              "name": "salt",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "staticInput",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
         }
       ],
-      "stateMutability": "view"
+      "anonymous": false
     },
     {
-      "type": "function",
-      "name": "create",
+      "type": "event",
+      "name": "Deployed",
       "inputs": [
         {
-          "name": "token0",
+          "name": "amm",
           "type": "address",
-          "internalType": "contract IERC20"
+          "indexed": true,
+          "internalType": "contract ConstantProduct"
         },
         {
-          "name": "amount0",
-          "type": "uint256",
-          "internalType": "uint256"
+          "name": "owner",
+          "type": "address",
+          "indexed": true,
+          "internalType": "address"
         },
         {
-          "name": "token1",
+          "name": "token0",
           "type": "address",
+          "indexed": false,
           "internalType": "contract IERC20"
         },
         {
-          "name": "amount1",
-          "type": "uint256",
-          "internalType": "uint256"
-        },
-        {
-          "name": "minTradedToken0",
-          "type": "uint256",
-          "internalType": "uint256"
-        },
-        {
-          "name": "priceOracle",
+          "name": "token1",
           "type": "address",
-          "internalType": "contract IPriceOracle"
-        },
-        {
-          "name": "priceOracleData",
-          "type": "bytes",
-          "internalType": "bytes"
-        },
-        {
-          "name": "appData",
-          "type": "bytes32",
-          "internalType": "bytes32"
+          "indexed": false,
+          "internalType": "contract IERC20"
         }
       ],
-      "outputs": [
+      "anonymous": false
+    },
+    {
+      "type": "event",
+      "name": "TradingDisabled",
+      "inputs": [
         {
           "name": "amm",
           "type": "address",
+          "indexed": true,
           "internalType": "contract ConstantProduct"
         }
       ],
-      "stateMutability": "nonpayable"
+      "anonymous": false
     },
     {
-      "type": "function",
-      "name": "deposit",
+      "type": "error",
+      "name": "OnlyOwnerCanCall",
       "inputs": [
         {
-          "name": "amm",
+          "name": "owner",
           "type": "address",
-          "internalType": "contract ConstantProduct"
-        },
-        {
-          "name": "amount0",
-          "type": "uint256",
-          "internalType": "uint256"
-        },
-        {
-          "name": "amount1",
-          "type": "uint256",
-          "internalType": "uint256"
+          "internalType": "address"
         }
-      ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
+      ]
     },
     {
-      "type": "function",
-      "name": "disableTrading",
+      "type": "error",
+      "name": "OrderNotValid",
       "inputs": [
         {
-          "name": "amm",
-          "type": "address",
-          "internalType": "contract ConstantProduct"
+          "name": "",
+          "type": "string",
+          "internalType": "string"
         }
-      ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
+      ]
     },
     {
       "type": "function",
-      "name": "getTradeableOrderWithSignature",
+      "name": "ammDeterministicAddress",
       "inputs": [
         {
-          "name": "amm",
+          "name": "ammOwner",
           "type": "address",
-          "internalType": "contract ConstantProduct"
-        },
-        {
-          "name": "params",
-          "type": "tuple",
-          "internalType": "struct IConditionalOrder.ConditionalOrderParams",
-          "components": [
-            {
-              "name": "handler",
-              "type": "address",
-              "internalType": "contract IConditionalOrder"
-            },
-            {
-              "name": "salt",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "staticInput",
-              "type": "bytes",
-              "internalType": "bytes"
-            }
-          ]
-        },
-        {
-          "name": "",
-          "type": "bytes",
-          "internalType": "bytes"
+          "internalType": "address"
         },
         {
-          "name": "",
-          "type": "bytes32[]",
-          "internalType": "bytes32[]"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "order",
-          "type": "tuple",
-          "internalType": "struct GPv2Order.Data",
-          "components": [
-            {
-              "name": "sellToken",
-              "type": "address",
-              "internalType": "contract IERC20"
-            },
-            {
-              "name": "buyToken",
-              "type": "address",
-              "internalType": "contract IERC20"
-            },
-            {
-              "name": "receiver",
-              "type": "address",
-              "internalType": "address"
-            },
-            {
-              "name": "sellAmount",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "buyAmount",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "validTo",
-              "type": "uint32",
-              "internalType": "uint32"
-            },
-            {
-              "name": "appData",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "feeAmount",
-              "type": "uint256",
-              "internalType": "uint256"
-            },
-            {
-              "name": "kind",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "partiallyFillable",
-              "type": "bool",
-              "internalType": "bool"
-            },
-            {
-              "name": "sellTokenBalance",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "buyTokenBalance",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            }
-          ]
+          "name": "token0",
+          "type": "address",
+          "internalType": "contract IERC20"
         },
         {
-          "name": "signature",
-          "type": "bytes",
-          "internalType": "bytes"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "owner",
-      "inputs": [
-        {
-          "name": "",
+          "name": "token1",
           "type": "address",
-          "internalType": "contract ConstantProduct"
+          "internalType": "contract IERC20"
         }
       ],
       "outputs": [
@@ -269,25 +144,27 @@
     },
     {
       "type": "function",
-      "name": "settler",
-      "inputs": [],
-      "outputs": [
+      "name": "create",
+      "inputs": [
         {
-          "name": "",
+          "name": "token0",
           "type": "address",
-          "internalType": "contract ISettlement"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "updateParameters",
-      "inputs": [
+          "internalType": "contract IERC20"
+        },
         {
-          "name": "amm",
+          "name": "amount0",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "token1",
           "type": "address",
-          "internalType": "contract ConstantProduct"
+          "internalType": "contract IERC20"
+        },
+        {
+          "name": "amount1",
+          "type": "uint256",
+          "internalType": "uint256"
         },
         {
           "name": "minTradedToken0",
@@ -309,134 +186,80 @@
           "type": "bytes32",
           "internalType": "bytes32"
         }
-      ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "function",
-      "name": "withdraw",
-      "inputs": [
-        {
-          "name": "amm",
-          "type": "address",
-          "internalType": "contract ConstantProduct"
-        },
-        {
-          "name": "amount0",
-          "type": "uint256",
-          "internalType": "uint256"
-        },
-        {
-          "name": "amount1",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
-    },
-    {
-      "type": "event",
-      "name": "ConditionalOrderCreated",
-      "inputs": [
-        {
-          "name": "owner",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        },
-        {
-          "name": "params",
-          "type": "tuple",
-          "indexed": false,
-          "internalType": "struct IConditionalOrder.ConditionalOrderParams",
-          "components": [
-            {
-              "name": "handler",
-              "type": "address",
-              "internalType": "contract IConditionalOrder"
-            },
-            {
-              "name": "salt",
-              "type": "bytes32",
-              "internalType": "bytes32"
-            },
-            {
-              "name": "staticInput",
-              "type": "bytes",
-              "internalType": "bytes"
-            }
-          ]
+      ],
+      "outputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "contract ConstantProduct"
         }
       ],
-      "anonymous": false
+      "stateMutability": "nonpayable"
     },
     {
-      "type": "event",
-      "name": "Deployed",
+      "type": "function",
+      "name": "deposit",
       "inputs": [
         {
           "name": "amm",
           "type": "address",
-          "indexed": true,
           "internalType": "contract ConstantProduct"
         },
         {
-          "name": "owner",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        },
-        {
-          "name": "token0",
-          "type": "address",
-          "indexed": false,
-          "internalType": "contract IERC20"
+          "name": "amount0",
+          "type": "uint256",
+          "internalType": "uint256"
         },
         {
-          "name": "token1",
-          "type": "address",
-          "indexed": false,
-          "internalType": "contract IERC20"
+          "name": "amount1",
+          "type": "uint256",
+          "internalType": "uint256"
         }
       ],
-      "anonymous": false
+      "outputs": [],
+      "stateMutability": "nonpayable"
     },
     {
-      "type": "event",
-      "name": "TradingDisabled",
+      "type": "function",
+      "name": "owner",
       "inputs": [
         {
-          "name": "amm",
+          "name": "",
           "type": "address",
-          "indexed": true,
           "internalType": "contract ConstantProduct"
         }
       ],
-      "anonymous": false
-    },
-    {
-      "type": "error",
-      "name": "OnlyOwnerCanCall",
-      "inputs": [
+      "outputs": [
         {
-          "name": "owner",
+          "name": "",
           "type": "address",
           "internalType": "address"
         }
-      ]
+      ],
+      "stateMutability": "view"
     },
     {
-      "type": "error",
-      "name": "OrderNotValid",
+      "type": "function",
+      "name": "withdraw",
       "inputs": [
         {
-          "name": "",
-          "type": "string",
-          "internalType": "string"
+          "name": "amm",
+          "type": "address",
+          "internalType": "contract ConstantProduct"
+        },
+        {
+          "name": "amount0",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "amount1",
+          "type": "uint256",
+          "internalType": "uint256"
         }
-      ]
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
     }
   ],
   "bytecode": "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",
@@ -1428,5 +1251,184 @@
     },
     "version": 1
   },
-  "id": 170
+  "id": 170,
+  "_disabled": [
+    {
+      "type": "function",
+      "name": "disableTrading",
+      "inputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "contract ConstantProduct"
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "getTradeableOrderWithSignature",
+      "inputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "contract ConstantProduct"
+        },
+        {
+          "name": "params",
+          "type": "tuple",
+          "internalType": "struct IConditionalOrder.ConditionalOrderParams",
+          "components": [
+            {
+              "name": "handler",
+              "type": "address",
+              "internalType": "contract IConditionalOrder"
+            },
+            {
+              "name": "salt",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "staticInput",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "",
+          "type": "bytes",
+          "internalType": "bytes"
+        },
+        {
+          "name": "",
+          "type": "bytes32[]",
+          "internalType": "bytes32[]"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "order",
+          "type": "tuple",
+          "internalType": "struct GPv2Order.Data",
+          "components": [
+            {
+              "name": "sellToken",
+              "type": "address",
+              "internalType": "contract IERC20"
+            },
+            {
+              "name": "buyToken",
+              "type": "address",
+              "internalType": "contract IERC20"
+            },
+            {
+              "name": "receiver",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "sellAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "buyAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "validTo",
+              "type": "uint32",
+              "internalType": "uint32"
+            },
+            {
+              "name": "appData",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "feeAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "kind",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "partiallyFillable",
+              "type": "bool",
+              "internalType": "bool"
+            },
+            {
+              "name": "sellTokenBalance",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            },
+            {
+              "name": "buyTokenBalance",
+              "type": "bytes32",
+              "internalType": "bytes32"
+            }
+          ]
+        },
+        {
+          "name": "signature",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "settler",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "contract ISettlement"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "updateParameters",
+      "inputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "contract ConstantProduct"
+        },
+        {
+          "name": "minTradedToken0",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "priceOracle",
+          "type": "address",
+          "internalType": "contract IPriceOracle"
+        },
+        {
+          "name": "priceOracleData",
+          "type": "bytes",
+          "internalType": "bytes"
+        },
+        {
+          "name": "appData",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    }
+  ]
 }
diff --git a/contracts/artifacts/CowAmmLegacyHelper.json b/contracts/artifacts/CowAmmLegacyHelper.json
index 391823f88c..892d1e1d16 100644
--- a/contracts/artifacts/CowAmmLegacyHelper.json
+++ b/contracts/artifacts/CowAmmLegacyHelper.json
@@ -6,73 +6,59 @@
       "stateMutability": "nonpayable"
     },
     {
-      "type": "function",
-      "name": "factory",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "address",
-          "internalType": "address"
-        }
-      ],
-      "stateMutability": "view"
-    },
-    {
-      "type": "function",
-      "name": "getSnapshot",
+      "type": "event",
+      "name": "COWAMMPoolCreated",
       "inputs": [
         {
           "name": "amm",
           "type": "address",
+          "indexed": true,
           "internalType": "address"
         }
       ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bytes",
-          "internalType": "bytes"
-        }
-      ],
-      "stateMutability": "view"
+      "anonymous": false
     },
     {
-      "type": "function",
-      "name": "isLegacy",
-      "inputs": [
-        {
-          "name": "amm",
-          "type": "address",
-          "internalType": "address"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "",
-          "type": "bool",
-          "internalType": "bool"
-        }
-      ],
-      "stateMutability": "view"
+      "type": "error",
+      "name": "InvalidArrayLength",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "MathOverflowedMulDiv",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "NoOrder",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "PoolDoesNotExist",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "PoolIsClosed",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "PoolIsPaused",
+      "inputs": []
     },
     {
       "type": "function",
-      "name": "isLegacyEnabled",
-      "inputs": [
+      "name": "factory",
+      "inputs": [],
+      "outputs": [
         {
-          "name": "amm",
+          "name": "",
           "type": "address",
           "internalType": "address"
         }
       ],
-      "outputs": [
-        {
-          "name": "success",
-          "type": "bool",
-          "internalType": "bool"
-        }
-      ],
       "stateMutability": "view"
     },
     {
@@ -228,49 +214,6 @@
         }
       ],
       "stateMutability": "view"
-    },
-    {
-      "type": "event",
-      "name": "COWAMMPoolCreated",
-      "inputs": [
-        {
-          "name": "amm",
-          "type": "address",
-          "indexed": true,
-          "internalType": "address"
-        }
-      ],
-      "anonymous": false
-    },
-    {
-      "type": "error",
-      "name": "InvalidArrayLength",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "MathOverflowedMulDiv",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "NoOrder",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "PoolDoesNotExist",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "PoolIsClosed",
-      "inputs": []
-    },
-    {
-      "type": "error",
-      "name": "PoolIsPaused",
-      "inputs": []
     }
   ],
   "bytecode": "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",
@@ -1079,5 +1022,64 @@
     },
     "version": 1
   },
-  "id": 126
+  "id": 126,
+  "_disabled": [
+    {
+      "type": "function",
+      "name": "getSnapshot",
+      "inputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "isLegacy",
+      "inputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bool",
+          "internalType": "bool"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "isLegacyEnabled",
+      "inputs": [
+        {
+          "name": "amm",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "success",
+          "type": "bool",
+          "internalType": "bool"
+        }
+      ],
+      "stateMutability": "view"
+    }
+  ]
 }
diff --git a/contracts/artifacts/CowAmmUniswapV2PriceOracle.json b/contracts/artifacts/CowAmmUniswapV2PriceOracle.json
index c232352da2..0016f79051 100644
--- a/contracts/artifacts/CowAmmUniswapV2PriceOracle.json
+++ b/contracts/artifacts/CowAmmUniswapV2PriceOracle.json
@@ -1,40 +1,5 @@
 {
-  "abi": [
-    {
-      "type": "function",
-      "name": "getPrice",
-      "inputs": [
-        {
-          "name": "token0",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "token1",
-          "type": "address",
-          "internalType": "address"
-        },
-        {
-          "name": "data",
-          "type": "bytes",
-          "internalType": "bytes"
-        }
-      ],
-      "outputs": [
-        {
-          "name": "priceNumerator",
-          "type": "uint256",
-          "internalType": "uint256"
-        },
-        {
-          "name": "priceDenominator",
-          "type": "uint256",
-          "internalType": "uint256"
-        }
-      ],
-      "stateMutability": "view"
-    }
-  ],
+  "abi": [],
   "bytecode": "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",
   "deployedBytecode": "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",
   "methodIdentifiers": {
@@ -171,5 +136,41 @@
     },
     "version": 1
   },
-  "id": 178
+  "id": 178,
+  "_disabled": [
+    {
+      "type": "function",
+      "name": "getPrice",
+      "inputs": [
+        {
+          "name": "token0",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "token1",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "data",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "priceNumerator",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "priceDenominator",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    }
+  ]
 }
diff --git a/contracts/artifacts/CowProtocolToken.json b/contracts/artifacts/CowProtocolToken.json
index 50679b3be3..6e7084fb0c 100644
--- a/contracts/artifacts/CowProtocolToken.json
+++ b/contracts/artifacts/CowProtocolToken.json
@@ -99,32 +99,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "MAX_YEARLY_INFLATION",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "TIME_BETWEEN_MINTINGS",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -192,19 +166,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "cowDao",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "decimals",
@@ -218,78 +179,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "subtractedValue",
-          "type": "uint256"
-        }
-      ],
-      "name": "decreaseAllowance",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "offset",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "length",
-          "type": "uint256"
-        }
-      ],
-      "name": "getStorageAt",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "addedValue",
-          "type": "uint256"
-        }
-      ],
-      "name": "increaseAllowance",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -407,38 +296,83 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "symbol",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
           "internalType": "address",
-          "name": "targetContract",
+          "name": "recipient",
           "type": "address"
         },
         {
-          "internalType": "bytes",
-          "name": "calldataPayload",
-          "type": "bytes"
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
         }
       ],
-      "name": "simulateDelegatecallInternal",
+      "name": "transfer",
       "outputs": [
         {
-          "internalType": "bytes",
-          "name": "response",
-          "type": "bytes"
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
         }
       ],
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "transferFrom",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [],
-      "name": "symbol",
+      "name": "MAX_YEARLY_INFLATION",
       "outputs": [
         {
-          "internalType": "string",
+          "internalType": "uint256",
           "name": "",
-          "type": "string"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -446,7 +380,7 @@
     },
     {
       "inputs": [],
-      "name": "timestampLastMinting",
+      "name": "TIME_BETWEEN_MINTINGS",
       "outputs": [
         {
           "internalType": "uint256",
@@ -459,12 +393,12 @@
     },
     {
       "inputs": [],
-      "name": "totalSupply",
+      "name": "cowDao",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "address",
           "name": "",
-          "type": "uint256"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -474,16 +408,16 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "recipient",
+          "name": "spender",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "amount",
+          "name": "subtractedValue",
           "type": "uint256"
         }
       ],
-      "name": "transfer",
+      "name": "decreaseAllowance",
       "outputs": [
         {
           "internalType": "bool",
@@ -497,22 +431,41 @@
     {
       "inputs": [
         {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
+          "internalType": "uint256",
+          "name": "offset",
+          "type": "uint256"
         },
+        {
+          "internalType": "uint256",
+          "name": "length",
+          "type": "uint256"
+        }
+      ],
+      "name": "getStorageAt",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
         {
           "internalType": "address",
-          "name": "recipient",
+          "name": "spender",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "amount",
+          "name": "addedValue",
           "type": "uint256"
         }
       ],
-      "name": "transferFrom",
+      "name": "increaseAllowance",
       "outputs": [
         {
           "internalType": "bool",
@@ -522,7 +475,56 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "targetContract",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "calldataPayload",
+          "type": "bytes"
+        }
+      ],
+      "name": "simulateDelegatecallInternal",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "response",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "timestampLastMinting",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "totalSupply",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/ERC20.json b/contracts/artifacts/ERC20.json
index 4b937d123e..028a5b1ce0 100644
--- a/contracts/artifacts/ERC20.json
+++ b/contracts/artifacts/ERC20.json
@@ -147,43 +147,45 @@
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "spender",
-          "type": "address"
-        },
+      "inputs": [],
+      "name": "name",
+      "outputs": [
         {
-          "internalType": "uint256",
-          "name": "subtractedValue",
-          "type": "uint256"
+          "internalType": "string",
+          "name": "",
+          "type": "string"
         }
       ],
-      "name": "decreaseAllowance",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "symbol",
       "outputs": [
         {
-          "internalType": "bool",
+          "internalType": "string",
           "name": "",
-          "type": "bool"
+          "type": "string"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
           "internalType": "address",
-          "name": "spender",
+          "name": "recipient",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "addedValue",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "name": "increaseAllowance",
+      "name": "transfer",
       "outputs": [
         {
           "internalType": "bool",
@@ -195,58 +197,50 @@
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "name",
-      "outputs": [
+      "inputs": [
         {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        },
         {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "totalSupply",
+      "name": "transferFrom",
       "outputs": [
         {
-          "internalType": "uint256",
+          "internalType": "bool",
           "name": "",
-          "type": "uint256"
+          "type": "bool"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
           "internalType": "address",
-          "name": "recipient",
+          "name": "spender",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "amount",
+          "name": "subtractedValue",
           "type": "uint256"
         }
       ],
-      "name": "transfer",
+      "name": "decreaseAllowance",
       "outputs": [
         {
           "internalType": "bool",
@@ -261,21 +255,16 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
+          "name": "spender",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "amount",
+          "name": "addedValue",
           "type": "uint256"
         }
       ],
-      "name": "transferFrom",
+      "name": "increaseAllowance",
       "outputs": [
         {
           "internalType": "bool",
@@ -285,6 +274,19 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "totalSupply",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/ERC20Mintable.json b/contracts/artifacts/ERC20Mintable.json
index e3eded2cc5..bda0b6acda 100644
--- a/contracts/artifacts/ERC20Mintable.json
+++ b/contracts/artifacts/ERC20Mintable.json
@@ -76,21 +76,6 @@
       "name": "Transfer",
       "type": "event"
     },
-    {
-      "constant": false,
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "account",
-          "type": "address"
-        }
-      ],
-      "name": "addMinter",
-      "outputs": [],
-      "payable": false,
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "constant": true,
       "inputs": [
@@ -169,16 +154,16 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "spender",
+          "name": "account",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "subtractedValue",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "name": "decreaseAllowance",
+      "name": "mint",
       "outputs": [
         {
           "internalType": "bool",
@@ -195,16 +180,16 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "spender",
+          "name": "recipient",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "addedValue",
+          "name": "amount",
           "type": "uint256"
         }
       ],
-      "name": "increaseAllowance",
+      "name": "transfer",
       "outputs": [
         {
           "internalType": "bool",
@@ -217,32 +202,16 @@
       "type": "function"
     },
     {
-      "constant": true,
+      "constant": false,
       "inputs": [
         {
           "internalType": "address",
-          "name": "account",
+          "name": "sender",
           "type": "address"
-        }
-      ],
-      "name": "isMinter",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": false,
-      "inputs": [
+        },
         {
           "internalType": "address",
-          "name": "account",
+          "name": "recipient",
           "type": "address"
         },
         {
@@ -251,7 +220,7 @@
           "type": "uint256"
         }
       ],
-      "name": "mint",
+      "name": "transferFrom",
       "outputs": [
         {
           "internalType": "bool",
@@ -262,29 +231,49 @@
       "payable": false,
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "constant": false,
-      "inputs": [],
-      "name": "renounceMinter",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "account",
+          "type": "address"
+        }
+      ],
+      "name": "addMinter",
       "outputs": [],
       "payable": false,
       "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "constant": true,
-      "inputs": [],
-      "name": "totalSupply",
-      "outputs": [
+      "constant": false,
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        },
         {
           "internalType": "uint256",
-          "name": "",
+          "name": "subtractedValue",
           "type": "uint256"
         }
       ],
+      "name": "decreaseAllowance",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
       "payable": false,
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -292,16 +281,16 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "recipient",
+          "name": "spender",
           "type": "address"
         },
         {
           "internalType": "uint256",
-          "name": "amount",
+          "name": "addedValue",
           "type": "uint256"
         }
       ],
-      "name": "transfer",
+      "name": "increaseAllowance",
       "outputs": [
         {
           "internalType": "bool",
@@ -314,25 +303,15 @@
       "type": "function"
     },
     {
-      "constant": false,
+      "constant": true,
       "inputs": [
         {
           "internalType": "address",
-          "name": "sender",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
+          "name": "account",
           "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
         }
       ],
-      "name": "transferFrom",
+      "name": "isMinter",
       "outputs": [
         {
           "internalType": "bool",
@@ -341,9 +320,32 @@
         }
       ],
       "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [],
+      "name": "renounceMinter",
+      "outputs": [],
+      "payable": false,
       "stateMutability": "nonpayable",
       "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "totalSupply",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/FlashLoanRouter.json b/contracts/artifacts/FlashLoanRouter.json
index a4349a5917..97c8710b21 100644
--- a/contracts/artifacts/FlashLoanRouter.json
+++ b/contracts/artifacts/FlashLoanRouter.json
@@ -11,19 +11,6 @@
       ],
       "stateMutability": "nonpayable"
     },
-    {
-      "type": "function",
-      "name": "borrowerCallback",
-      "inputs": [
-        {
-          "name": "encodedLoansWithSettlement",
-          "type": "bytes",
-          "internalType": "bytes"
-        }
-      ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
-    },
     {
       "type": "function",
       "name": "flashLoanAndSettle",
@@ -64,19 +51,6 @@
       "outputs": [],
       "stateMutability": "nonpayable"
     },
-    {
-      "type": "function",
-      "name": "settlementAuthentication",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "address",
-          "internalType": "contract ICowAuthentication"
-        }
-      ],
-      "stateMutability": "view"
-    },
     {
       "type": "function",
       "name": "settlementContract",
@@ -291,5 +265,33 @@
     },
     "version": 1
   },
-  "id": 27
+  "id": 27,
+  "_disabled": [
+    {
+      "type": "function",
+      "name": "borrowerCallback",
+      "inputs": [
+        {
+          "name": "encodedLoansWithSettlement",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "settlementAuthentication",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "contract ICowAuthentication"
+        }
+      ],
+      "stateMutability": "view"
+    }
+  ]
 }
diff --git a/contracts/artifacts/GPv2AllowListAuthentication.json b/contracts/artifacts/GPv2AllowListAuthentication.json
index 37d526dad7..7dfa98f4de 100644
--- a/contracts/artifacts/GPv2AllowListAuthentication.json
+++ b/contracts/artifacts/GPv2AllowListAuthentication.json
@@ -58,30 +58,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "offset",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "length",
-          "type": "uint256"
-        }
-      ],
-      "name": "getStorageAt",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -140,19 +116,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "manager_",
-          "type": "address"
-        }
-      ],
-      "name": "setManager",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -176,30 +139,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "targetContract",
-          "type": "address"
-        },
-        {
-          "internalType": "bytes",
-          "name": "calldataPayload",
-          "type": "bytes"
-        }
-      ],
-      "name": "simulateDelegatecallInternal",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "response",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ],
   "bytecode": "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",
@@ -291,5 +230,68 @@
     "kind": "user",
     "methods": {},
     "version": 1
-  }
-}
\ No newline at end of file
+  },
+  "_disabled": [
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "offset",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "length",
+          "type": "uint256"
+        }
+      ],
+      "name": "getStorageAt",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "manager_",
+          "type": "address"
+        }
+      ],
+      "name": "setManager",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "targetContract",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "calldataPayload",
+          "type": "bytes"
+        }
+      ],
+      "name": "simulateDelegatecallInternal",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "response",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
diff --git a/contracts/artifacts/GPv2Settlement.json b/contracts/artifacts/GPv2Settlement.json
index 529b2f6263..2fbbfb6403 100644
--- a/contracts/artifacts/GPv2Settlement.json
+++ b/contracts/artifacts/GPv2Settlement.json
@@ -1,5 +1,24 @@
 {
   "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "name": "filledAmount",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -147,6 +166,10 @@
       "name": "Trade",
       "type": "event"
     },
+    {
+      "stateMutability": "payable",
+      "type": "receive"
+    },
     {
       "inputs": [],
       "name": "authenticator",
@@ -173,75 +196,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes",
-          "name": "",
-          "type": "bytes"
-        }
-      ],
-      "name": "filledAmount",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes[]",
-          "name": "orderUids",
-          "type": "bytes[]"
-        }
-      ],
-      "name": "freeFilledAmountStorage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes[]",
-          "name": "orderUids",
-          "type": "bytes[]"
-        }
-      ],
-      "name": "freePreSignatureStorage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "offset",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "length",
-          "type": "uint256"
-        }
-      ],
-      "name": "getStorageAt",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -255,25 +209,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes",
-          "name": "",
-          "type": "bytes"
-        }
-      ],
-      "name": "preSignature",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -418,30 +353,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "targetContract",
-          "type": "address"
-        },
-        {
-          "internalType": "bytes",
-          "name": "calldataPayload",
-          "type": "bytes"
-        }
-      ],
-      "name": "simulateDelegatecallInternal",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "response",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -574,10 +485,6 @@
       ],
       "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "stateMutability": "payable",
-      "type": "receive"
     }
   ],
   "bytecode": "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",
@@ -686,5 +593,100 @@
     "kind": "user",
     "methods": {},
     "version": 1
-  }
-}
\ No newline at end of file
+  },
+  "_disabled": [
+    {
+      "inputs": [
+        {
+          "internalType": "bytes[]",
+          "name": "orderUids",
+          "type": "bytes[]"
+        }
+      ],
+      "name": "freeFilledAmountStorage",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes[]",
+          "name": "orderUids",
+          "type": "bytes[]"
+        }
+      ],
+      "name": "freePreSignatureStorage",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "offset",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "length",
+          "type": "uint256"
+        }
+      ],
+      "name": "getStorageAt",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "",
+          "type": "bytes"
+        }
+      ],
+      "name": "preSignature",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "targetContract",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "calldataPayload",
+          "type": "bytes"
+        }
+      ],
+      "name": "simulateDelegatecallInternal",
+      "outputs": [
+        {
+          "internalType": "bytes",
+          "name": "response",
+          "type": "bytes"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}
diff --git a/contracts/artifacts/GnosisSafe.json b/contracts/artifacts/GnosisSafe.json
index fe0534044e..a356fbec4f 100644
--- a/contracts/artifacts/GnosisSafe.json
+++ b/contracts/artifacts/GnosisSafe.json
@@ -252,6 +252,10 @@
       "stateMutability": "nonpayable",
       "type": "fallback"
     },
+    {
+      "stateMutability": "payable",
+      "type": "receive"
+    },
     {
       "inputs": [],
       "name": "VERSION",
@@ -265,6 +269,147 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "domainSeparator",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        },
+        {
+          "internalType": "enum Enum.Operation",
+          "name": "operation",
+          "type": "uint8"
+        },
+        {
+          "internalType": "uint256",
+          "name": "safeTxGas",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "baseGas",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "gasPrice",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "gasToken",
+          "type": "address"
+        },
+        {
+          "internalType": "address payable",
+          "name": "refundReceiver",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "signatures",
+          "type": "bytes"
+        }
+      ],
+      "name": "execTransaction",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "success",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "nonce",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "_owners",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "_threshold",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        },
+        {
+          "internalType": "address",
+          "name": "fallbackHandler",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "paymentToken",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "payment",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address payable",
+          "name": "paymentReceiver",
+          "type": "address"
+        }
+      ],
+      "name": "setup",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [
         {
@@ -402,19 +547,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "domainSeparator",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -492,70 +624,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        },
-        {
-          "internalType": "enum Enum.Operation",
-          "name": "operation",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint256",
-          "name": "safeTxGas",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "baseGas",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "gasPrice",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "gasToken",
-          "type": "address"
-        },
-        {
-          "internalType": "address payable",
-          "name": "refundReceiver",
-          "type": "address"
-        },
-        {
-          "internalType": "bytes",
-          "name": "signatures",
-          "type": "bytes"
-        }
-      ],
-      "name": "execTransaction",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "success",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -823,19 +891,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "nonce",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -919,54 +974,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address[]",
-          "name": "_owners",
-          "type": "address[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "_threshold",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        },
-        {
-          "internalType": "address",
-          "name": "fallbackHandler",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "paymentToken",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "payment",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address payable",
-          "name": "paymentReceiver",
-          "type": "address"
-        }
-      ],
-      "name": "setup",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -1026,11 +1033,6 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "stateMutability": "payable",
-      "type": "receive"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json b/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json
index 05cb02bd4f..d539a2309a 100644
--- a/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json
+++ b/contracts/artifacts/GnosisSafeCompatibilityFallbackHandler.json
@@ -28,18 +28,23 @@
     },
     {
       "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "_dataHash",
+          "type": "bytes32"
+        },
         {
           "internalType": "bytes",
-          "name": "message",
+          "name": "_signature",
           "type": "bytes"
         }
       ],
-      "name": "getMessageHash",
+      "name": "isValidSignature",
       "outputs": [
         {
-          "internalType": "bytes32",
+          "internalType": "bytes4",
           "name": "",
-          "type": "bytes32"
+          "type": "bytes4"
         }
       ],
       "stateMutability": "view",
@@ -48,59 +53,68 @@
     {
       "inputs": [
         {
-          "internalType": "contract GnosisSafe",
-          "name": "safe",
-          "type": "address"
+          "internalType": "bytes",
+          "name": "_data",
+          "type": "bytes"
         },
         {
           "internalType": "bytes",
-          "name": "message",
+          "name": "_signature",
           "type": "bytes"
         }
       ],
-      "name": "getMessageHashForSafe",
+      "name": "isValidSignature",
       "outputs": [
         {
-          "internalType": "bytes32",
+          "internalType": "bytes4",
           "name": "",
-          "type": "bytes32"
+          "type": "bytes4"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "getModules",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "targetContract",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "calldataPayload",
+          "type": "bytes"
+        }
+      ],
+      "name": "simulate",
       "outputs": [
         {
-          "internalType": "address[]",
-          "name": "",
-          "type": "address[]"
+          "internalType": "bytes",
+          "name": "response",
+          "type": "bytes"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [
-        {
-          "internalType": "bytes32",
-          "name": "_dataHash",
-          "type": "bytes32"
-        },
         {
           "internalType": "bytes",
-          "name": "_signature",
+          "name": "message",
           "type": "bytes"
         }
       ],
-      "name": "isValidSignature",
+      "name": "getMessageHash",
       "outputs": [
         {
-          "internalType": "bytes4",
+          "internalType": "bytes32",
           "name": "",
-          "type": "bytes4"
+          "type": "bytes32"
         }
       ],
       "stateMutability": "view",
@@ -109,22 +123,35 @@
     {
       "inputs": [
         {
-          "internalType": "bytes",
-          "name": "_data",
-          "type": "bytes"
+          "internalType": "contract GnosisSafe",
+          "name": "safe",
+          "type": "address"
         },
         {
           "internalType": "bytes",
-          "name": "_signature",
+          "name": "message",
           "type": "bytes"
         }
       ],
-      "name": "isValidSignature",
+      "name": "getMessageHashForSafe",
       "outputs": [
         {
-          "internalType": "bytes4",
+          "internalType": "bytes32",
           "name": "",
-          "type": "bytes4"
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "getModules",
+      "outputs": [
+        {
+          "internalType": "address[]",
+          "name": "",
+          "type": "address[]"
         }
       ],
       "stateMutability": "view",
@@ -242,30 +269,6 @@
       "stateMutability": "pure",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "targetContract",
-          "type": "address"
-        },
-        {
-          "internalType": "bytes",
-          "name": "calldataPayload",
-          "type": "bytes"
-        }
-      ],
-      "name": "simulate",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "response",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -323,6 +326,5 @@
       "stateMutability": "pure",
       "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/GnosisSafeProxyFactory.json b/contracts/artifacts/GnosisSafeProxyFactory.json
index 0b019cea1f..c97bd6cdcb 100644
--- a/contracts/artifacts/GnosisSafeProxyFactory.json
+++ b/contracts/artifacts/GnosisSafeProxyFactory.json
@@ -23,21 +23,16 @@
       "inputs": [
         {
           "internalType": "address",
-          "name": "_singleton",
+          "name": "singleton",
           "type": "address"
         },
         {
           "internalType": "bytes",
-          "name": "initializer",
+          "name": "data",
           "type": "bytes"
-        },
-        {
-          "internalType": "uint256",
-          "name": "saltNonce",
-          "type": "uint256"
         }
       ],
-      "name": "calculateCreateProxyWithNonceAddress",
+      "name": "createProxy",
       "outputs": [
         {
           "internalType": "contract GnosisSafeProxy",
@@ -47,21 +42,29 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [
         {
           "internalType": "address",
-          "name": "singleton",
+          "name": "_singleton",
           "type": "address"
         },
         {
           "internalType": "bytes",
-          "name": "data",
+          "name": "initializer",
           "type": "bytes"
+        },
+        {
+          "internalType": "uint256",
+          "name": "saltNonce",
+          "type": "uint256"
         }
       ],
-      "name": "createProxy",
+      "name": "calculateCreateProxyWithNonceAddress",
       "outputs": [
         {
           "internalType": "contract GnosisSafeProxy",
@@ -161,6 +164,5 @@
       "stateMutability": "pure",
       "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/HoneyswapRouter.json b/contracts/artifacts/HoneyswapRouter.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/HoneyswapRouter.json
+++ b/contracts/artifacts/HoneyswapRouter.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/ICowWrapper.json b/contracts/artifacts/ICowWrapper.json
index 4a5d36a0a5..845d9ced8b 100644
--- a/contracts/artifacts/ICowWrapper.json
+++ b/contracts/artifacts/ICowWrapper.json
@@ -2,40 +2,42 @@
   "abi": [
     {
       "type": "function",
-      "name": "parseWrapperData",
+      "name": "wrappedSettle",
       "inputs": [
         {
-          "name": "wrapperData",
+          "name": "settleData",
           "type": "bytes",
           "internalType": "bytes"
-        }
-      ],
-      "outputs": [
+        },
         {
-          "name": "remainingWrapperData",
+          "name": "wrapperData",
           "type": "bytes",
           "internalType": "bytes"
         }
       ],
-      "stateMutability": "view"
-    },
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    }
+  ],
+  "_disabled": [
     {
       "type": "function",
-      "name": "wrappedSettle",
+      "name": "parseWrapperData",
       "inputs": [
         {
-          "name": "settleData",
+          "name": "wrapperData",
           "type": "bytes",
           "internalType": "bytes"
-        },
+        }
+      ],
+      "outputs": [
         {
-          "name": "wrapperData",
+          "name": "remainingWrapperData",
           "type": "bytes",
           "internalType": "bytes"
         }
       ],
-      "outputs": [],
-      "stateMutability": "nonpayable"
+      "stateMutability": "view"
     }
   ]
 }
diff --git a/contracts/artifacts/ISwaprPair.json b/contracts/artifacts/ISwaprPair.json
index 94a182ea4b..c14f3336a0 100644
--- a/contracts/artifacts/ISwaprPair.json
+++ b/contracts/artifacts/ISwaprPair.json
@@ -183,36 +183,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "MINIMUM_LIQUIDITY",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "pure",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "PERMIT_TYPEHASH",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "constant": true,
       "inputs": [
@@ -387,21 +357,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "kLast",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "constant": false,
       "inputs": [
@@ -504,66 +459,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "price0CumulativeLast",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "price1CumulativeLast",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": false,
-      "inputs": [
-        {
-          "internalType": "uint32",
-          "name": "",
-          "type": "uint32"
-        }
-      ],
-      "name": "setSwapFee",
-      "outputs": [],
-      "payable": false,
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "constant": false,
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "skim",
-      "outputs": [],
-      "payable": false,
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "constant": false,
       "inputs": [
@@ -663,21 +558,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "totalSupply",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "constant": false,
       "inputs": [
@@ -735,5 +615,127 @@
       "stateMutability": "nonpayable",
       "type": "function"
     }
+  ],
+  "_disabled": [
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "MINIMUM_LIQUIDITY",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "PERMIT_TYPEHASH",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "kLast",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "price0CumulativeLast",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "price1CumulativeLast",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [
+        {
+          "internalType": "uint32",
+          "name": "",
+          "type": "uint32"
+        }
+      ],
+      "name": "setSwapFee",
+      "outputs": [],
+      "payable": false,
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "skim",
+      "outputs": [],
+      "payable": false,
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "totalSupply",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/IUniswapLikePair.json b/contracts/artifacts/IUniswapLikePair.json
index cf71166b47..d4ddb0a82a 100644
--- a/contracts/artifacts/IUniswapLikePair.json
+++ b/contracts/artifacts/IUniswapLikePair.json
@@ -181,32 +181,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "MINIMUM_LIQUIDITY",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "PERMIT_TYPEHASH",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -365,19 +339,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "kLast",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -472,45 +433,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "price0CumulativeLast",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "price1CumulativeLast",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "skim",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -585,19 +507,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "totalSupply",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -651,5 +560,98 @@
       "stateMutability": "nonpayable",
       "type": "function"
     }
+  ],
+  "_disabled": [
+    {
+      "inputs": [],
+      "name": "MINIMUM_LIQUIDITY",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "PERMIT_TYPEHASH",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "kLast",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "price0CumulativeLast",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "price1CumulativeLast",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "skim",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "totalSupply",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/IUniswapLikeRouter.json b/contracts/artifacts/IUniswapLikeRouter.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/IUniswapLikeRouter.json
+++ b/contracts/artifacts/IUniswapLikeRouter.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/IUniswapV3Factory.json b/contracts/artifacts/IUniswapV3Factory.json
index c712812f49..077e501648 100644
--- a/contracts/artifacts/IUniswapV3Factory.json
+++ b/contracts/artifacts/IUniswapV3Factory.json
@@ -93,7 +93,7 @@
           "type": "uint24"
         }
       ],
-      "name": "createPool",
+      "name": "getPool",
       "outputs": [
         {
           "internalType": "address",
@@ -101,46 +101,24 @@
           "type": "address"
         }
       ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint24",
-          "name": "fee",
-          "type": "uint24"
-        },
-        {
-          "internalType": "int24",
-          "name": "tickSpacing",
-          "type": "int24"
-        }
-      ],
-      "name": "enableFeeAmount",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "uint24",
-          "name": "fee",
-          "type": "uint24"
-        }
-      ],
-      "name": "feeAmountTickSpacing",
+      "inputs": [],
+      "name": "owner",
       "outputs": [
         {
-          "internalType": "int24",
+          "internalType": "address",
           "name": "",
-          "type": "int24"
+          "type": "address"
         }
       ],
       "stateMutability": "view",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -159,7 +137,7 @@
           "type": "uint24"
         }
       ],
-      "name": "getPool",
+      "name": "createPool",
       "outputs": [
         {
           "internalType": "address",
@@ -167,17 +145,41 @@
           "type": "address"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "owner",
+      "inputs": [
+        {
+          "internalType": "uint24",
+          "name": "fee",
+          "type": "uint24"
+        },
+        {
+          "internalType": "int24",
+          "name": "tickSpacing",
+          "type": "int24"
+        }
+      ],
+      "name": "enableFeeAmount",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint24",
+          "name": "fee",
+          "type": "uint24"
+        }
+      ],
+      "name": "feeAmountTickSpacing",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "int24",
           "name": "",
-          "type": "address"
+          "type": "int24"
         }
       ],
       "stateMutability": "view",
@@ -197,4 +199,4 @@
       "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/IZeroex.json b/contracts/artifacts/IZeroex.json
index e195fa8a85..bb6f9e0225 100644
--- a/contracts/artifacts/IZeroex.json
+++ b/contracts/artifacts/IZeroex.json
@@ -890,6 +890,24 @@
       "name": "TransformerDeployerUpdated",
       "type": "event"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
+        },
+        {
+          "internalType": "address",
+          "name": "impl",
+          "type": "address"
+        }
+      ],
+      "name": "extend",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -990,25 +1008,10 @@
           "internalType": "uint128",
           "name": "takerTokenFillAmount",
           "type": "uint128"
-        },
-        {
-          "internalType": "address",
-          "name": "taker",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "sender",
-          "type": "address"
         }
       ],
-      "name": "_fillLimitOrder",
+      "name": "fillOrKillLimitOrder",
       "outputs": [
-        {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
-        },
         {
           "internalType": "uint128",
           "name": "makerTokenFilledAmount",
@@ -1042,117 +1045,9 @@
               "name": "takerAmount",
               "type": "uint128"
             },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiryAndNonce",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
-          "name": "order",
-          "type": "tuple"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "makerSignature",
-          "type": "tuple"
-        },
-        {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "address",
-          "name": "taker",
-          "type": "address"
-        },
-        {
-          "internalType": "bool",
-          "name": "useSelfBalance",
-          "type": "bool"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        }
-      ],
-      "name": "_fillOtcOrder",
-      "outputs": [
-        {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
             {
               "internalType": "uint128",
-              "name": "takerAmount",
+              "name": "takerTokenFeeAmount",
               "type": "uint128"
             },
             {
@@ -1167,7 +1062,12 @@
             },
             {
               "internalType": "address",
-              "name": "txOrigin",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "feeRecipient",
               "type": "address"
             },
             {
@@ -1186,7 +1086,7 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
+          "internalType": "struct LibNativeOrder.LimitOrder",
           "name": "order",
           "type": "tuple"
         },
@@ -1216,1778 +1116,1112 @@
           "internalType": "struct LibSignature.Signature",
           "name": "signature",
           "type": "tuple"
-        },
-        {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "address",
-          "name": "taker",
-          "type": "address"
-        },
-        {
-          "internalType": "bool",
-          "name": "useSelfBalance",
-          "type": "bool"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
         }
       ],
-      "name": "_fillRfqOrder",
+      "name": "getLimitOrderRelevantState",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFilledAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OrderInfo",
+          "name": "orderInfo",
+          "type": "tuple"
         },
         {
           "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
+          "name": "actualFillableTakerTokenAmount",
           "type": "uint128"
+        },
+        {
+          "internalType": "bool",
+          "name": "isSignatureValid",
+          "type": "bool"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "bytes",
-          "name": "encodedPath",
-          "type": "bytes"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
+      "inputs": [],
+      "name": "owner",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "recipient",
+          "name": "ownerAddress",
           "type": "address"
         }
       ],
-      "name": "_sellHeldTokenForTokenToUniswapV3",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "buyAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "address payable",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "inputToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "outputToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "inputTokenAmount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "minOutputTokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "uint32",
-                  "name": "deploymentNonce",
-                  "type": "uint32"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "data",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct ITransformERC20Feature.Transformation[]",
-              "name": "transformations",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "bool",
-              "name": "useSelfBalance",
-              "type": "bool"
-            },
-            {
-              "internalType": "address payable",
-              "name": "recipient",
-              "type": "address"
-            }
-          ],
-          "internalType": "struct ITransformERC20Feature.TransformERC20Args",
-          "name": "args",
-          "type": "tuple"
-        }
-      ],
-      "name": "_transformERC20",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "outputTokenAmount",
-          "type": "uint256"
+    }
+  ],
+  "devdoc": {
+    "details": "Interface for a fully featured Exchange Proxy.",
+    "kind": "dev",
+    "methods": {
+      "_fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,address)": {
+        "details": "Fill a limit order. Internal variant. ETH protocol fees can be      attached to this call. Any unspent ETH will be refunded to      `msg.sender` (not `sender`).",
+        "params": {
+          "order": "The limit order.",
+          "sender": "The order sender.",
+          "signature": "The order signature.",
+          "taker": "The order taker.",
+          "takerTokenFillAmount": "Maximum taker token to fill this order with."
+        },
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much maker token was filled."
         }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc1155TokenId",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "uint128",
-              "name": "erc1155TokenAmount",
-              "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNFTOrder.ERC1155Order[]",
-          "name": "sellOrders",
-          "type": "tuple[]"
+      },
+      "_fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)": {
+        "details": "Fill an OTC order for up to `takerTokenFillAmount` taker tokens.      Internal variant.",
+        "params": {
+          "makerSignature": "The order signature from the maker.",
+          "order": "The OTC order.",
+          "recipient": "The recipient of the bought maker tokens.",
+          "taker": "The address to fill the order in the context of.",
+          "takerTokenFillAmount": "Maximum taker token amount to fill this        order with.",
+          "useSelfBalance": "Whether to use the Exchange Proxy's balance        of input tokens."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much taker token was filled."
+        }
+      },
+      "_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)": {
+        "details": "Fill an RFQ order. Internal variant.",
+        "params": {
+          "order": "The RFQ order.",
+          "recipient": "The recipient of the maker tokens.",
+          "signature": "The order signature.",
+          "taker": "The order taker.",
+          "takerTokenFillAmount": "Maximum taker token to fill this order with.",
+          "useSelfBalance": "Whether to use the ExchangeProxy's transient        balance of taker tokens to fill the order."
         },
-        {
-          "internalType": "uint128[]",
-          "name": "erc1155TokenAmounts",
-          "type": "uint128[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much maker token was filled."
+        }
+      },
+      "_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)": {
+        "details": "Sell a token for another token directly against uniswap v3.      Private variant, uses tokens held by `address(this)`.",
+        "params": {
+          "encodedPath": "Uniswap-encoded path.",
+          "minBuyAmount": "Minimum amount of the last token in the path to buy.",
+          "recipient": "The recipient of the bought tokens. Can be zero for sender.",
+          "sellAmount": "amount of the first token in the path to sell."
         },
-        {
-          "internalType": "bytes[]",
-          "name": "callbackData",
-          "type": "bytes[]"
+        "returns": {
+          "buyAmount": "Amount of the last token in the path bought."
+        }
+      },
+      "_transformERC20((address,address,address,uint256,uint256,(uint32,bytes)[],bool,address))": {
+        "details": "Internal version of `transformERC20()`. Only callable from within.",
+        "params": {
+          "args": "A `TransformERC20Args` struct."
         },
-        {
-          "internalType": "bool",
-          "name": "revertIfIncomplete",
-          "type": "bool"
+        "returns": {
+          "outputTokenAmount": "The amount of `outputToken` received by the taker."
         }
-      ],
-      "name": "batchBuyERC1155s",
-      "outputs": [
-        {
-          "internalType": "bool[]",
-          "name": "successes",
-          "type": "bool[]"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc721TokenId",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
-            }
-          ],
-          "internalType": "struct LibNFTOrder.ERC721Order[]",
-          "name": "sellOrders",
-          "type": "tuple[]"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
+      },
+      "batchBuyERC1155s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bytes[],bool)": {
+        "details": "Buys multiple ERC1155 assets by filling the      given orders.",
+        "params": {
+          "callbackData": "The data (if any) to pass to the taker        callback for each order. Refer to the `callbackData`        parameter to for `buyERC1155`.",
+          "erc1155TokenAmounts": "The amounts of the ERC1155 assets        to buy for each order.",
+          "revertIfIncomplete": "If true, reverts if this        function fails to fill any individual order.",
+          "sellOrders": "The ERC1155 sell orders.",
+          "signatures": "The order signatures."
         },
-        {
-          "internalType": "bytes[]",
-          "name": "callbackData",
-          "type": "bytes[]"
+        "returns": {
+          "successes": "An array of booleans corresponding to whether         each order in `orders` was successfully filled."
+        }
+      },
+      "batchBuyERC721s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],bytes[],bool)": {
+        "details": "Buys multiple ERC721 assets by filling the      given orders.",
+        "params": {
+          "callbackData": "The data (if any) to pass to the taker        callback for each order. Refer to the `callbackData`        parameter to for `buyERC721`.",
+          "revertIfIncomplete": "If true, reverts if this        function fails to fill any individual order.",
+          "sellOrders": "The ERC721 sell orders.",
+          "signatures": "The order signatures."
         },
-        {
-          "internalType": "bool",
-          "name": "revertIfIncomplete",
-          "type": "bool"
+        "returns": {
+          "successes": "An array of booleans corresponding to whether         each order in `orders` was successfully filled."
         }
-      ],
-      "name": "batchBuyERC721s",
-      "outputs": [
-        {
-          "internalType": "bool[]",
-          "name": "successes",
-          "type": "bool[]"
+      },
+      "batchCancelERC1155Orders(uint256[])": {
+        "details": "Cancel multiple ERC1155 orders by their nonces. The caller      should be the maker of the orders. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
+        "params": {
+          "orderNonces": "The order nonces."
         }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "orderNonces",
-          "type": "uint256[]"
+      },
+      "batchCancelERC721Orders(uint256[])": {
+        "details": "Cancel multiple ERC721 orders by their nonces. The caller      should be the maker of the orders. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
+        "params": {
+          "orderNonces": "The order nonces."
         }
-      ],
-      "name": "batchCancelERC1155Orders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "orderNonces",
-          "type": "uint256[]"
+      },
+      "batchCancelLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[])": {
+        "details": "Cancel multiple limit orders. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
+        "params": {
+          "orders": "The limit orders."
         }
-      ],
-      "name": "batchCancelERC721Orders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "feeRecipient",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.LimitOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
+      },
+      "batchCancelPairLimitOrders(address[],address[],uint256[])": {
+        "details": "Cancel all limit orders for a given maker and pairs with salts less      than the values provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "makerTokens": "The maker tokens.",
+          "minValidSalts": "The new minimum valid salts.",
+          "takerTokens": "The taker tokens."
         }
-      ],
-      "name": "batchCancelLimitOrders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "makerTokens",
-          "type": "address[]"
-        },
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "takerTokens",
-          "type": "address[]"
-        },
-        {
-          "internalType": "uint256[]",
-          "name": "minValidSalts",
-          "type": "uint256[]"
+      },
+      "batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])": {
+        "details": "Cancel all limit orders for a given maker and pairs with salts less      than the values provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "maker": "The maker for which to cancel.",
+          "makerTokens": "The maker tokens.",
+          "minValidSalts": "The new minimum valid salts.",
+          "takerTokens": "The taker tokens."
         }
-      ],
-      "name": "batchCancelPairLimitOrders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "maker",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "makerTokens",
-          "type": "address[]"
+      },
+      "batchCancelPairRfqOrders(address[],address[],uint256[])": {
+        "details": "Cancel all RFQ orders for a given maker and pairs with salts less      than the values provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "makerTokens": "The maker tokens.",
+          "minValidSalts": "The new minimum valid salts.",
+          "takerTokens": "The taker tokens."
+        }
+      },
+      "batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])": {
+        "details": "Cancel all RFQ orders for a given maker and pairs with salts less      than the values provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "maker": "The maker for which to cancel.",
+          "makerTokens": "The maker tokens.",
+          "minValidSalts": "The new minimum valid salts.",
+          "takerTokens": "The taker tokens."
+        }
+      },
+      "batchCancelRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[])": {
+        "details": "Cancel multiple RFQ orders. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
+        "params": {
+          "orders": "The RFQ orders."
+        }
+      },
+      "batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,bytes32)[])": {
+        "details": "Execute multiple meta-transactions.",
+        "params": {
+          "mtxs": "The meta-transactions.",
+          "signatures": "The signature by each respective `mtx.signer`."
         },
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "takerTokens",
-          "type": "address[]"
+        "returns": {
+          "returnResults": "The ABI-encoded results of the underlying calls."
+        }
+      },
+      "batchFillLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)": {
+        "details": "Fills multiple limit orders.",
+        "params": {
+          "orders": "Array of limit orders.",
+          "revertIfIncomplete": "If true, reverts if this function fails to        fill the full fill amount for any individual order.",
+          "signatures": "Array of signatures corresponding to each order.",
+          "takerTokenFillAmounts": "Array of desired amounts to fill each order."
         },
-        {
-          "internalType": "uint256[]",
-          "name": "minValidSalts",
-          "type": "uint256[]"
+        "returns": {
+          "makerTokenFilledAmounts": "Array of amounts filled, in maker token.",
+          "takerTokenFilledAmounts": "Array of amounts filled, in taker token."
         }
-      ],
-      "name": "batchCancelPairLimitOrdersWithSigner",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "makerTokens",
-          "type": "address[]"
+      },
+      "batchFillRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)": {
+        "details": "Fills multiple RFQ orders.",
+        "params": {
+          "orders": "Array of RFQ orders.",
+          "revertIfIncomplete": "If true, reverts if this function fails to        fill the full fill amount for any individual order.",
+          "signatures": "Array of signatures corresponding to each order.",
+          "takerTokenFillAmounts": "Array of desired amounts to fill each order."
         },
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "takerTokens",
-          "type": "address[]"
+        "returns": {
+          "makerTokenFilledAmounts": "Array of amounts filled, in maker token.",
+          "takerTokenFilledAmounts": "Array of amounts filled, in taker token."
+        }
+      },
+      "batchFillTakerSignedOtcOrders((address,address,uint128,uint128,address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[],bool[])": {
+        "details": "Fills multiple taker-signed OTC orders.",
+        "params": {
+          "makerSignatures": "Array of maker signatures for each order.",
+          "orders": "Array of OTC orders.",
+          "takerSignatures": "Array of taker signatures for each order.",
+          "unwrapWeth": "Array of booleans representing whether or not         to unwrap bought WETH into ETH for each order. Should be set         to false if the maker token is not WETH."
         },
-        {
-          "internalType": "uint256[]",
-          "name": "minValidSalts",
-          "type": "uint256[]"
+        "returns": {
+          "successes": "Array of booleans representing whether or not         each order in `orders` was filled successfully."
         }
-      ],
-      "name": "batchCancelPairRfqOrders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "maker",
-          "type": "address"
+      },
+      "batchGetLimitOrderRelevantStates((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])": {
+        "details": "Batch version of `getLimitOrderRelevantState()`, without reverting.      Orders that would normally cause `getLimitOrderRelevantState()`      to revert will have empty results.",
+        "params": {
+          "orders": "The limit orders.",
+          "signatures": "The order signatures."
         },
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "makerTokens",
-          "type": "address[]"
+        "returns": {
+          "actualFillableTakerTokenAmounts": "How much of each order is fillable         based on maker funds, in taker tokens.",
+          "isSignatureValids": "Whether each signature is valid for the order.",
+          "orderInfos": "Info about the orders."
+        }
+      },
+      "batchGetRfqOrderRelevantStates((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])": {
+        "details": "Batch version of `getRfqOrderRelevantState()`, without reverting.      Orders that would normally cause `getRfqOrderRelevantState()`      to revert will have empty results.",
+        "params": {
+          "orders": "The RFQ orders.",
+          "signatures": "The order signatures."
         },
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "takerTokens",
-          "type": "address[]"
+        "returns": {
+          "actualFillableTakerTokenAmounts": "How much of each order is fillable         based on maker funds, in taker tokens.",
+          "isSignatureValids": "Whether each signature is valid for the order.",
+          "orderInfos": "Info about the orders."
+        }
+      },
+      "batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[])": {
+        "details": "Matches pairs of complementary orders that have      non-negative spreads. Each order is filled at      their respective price, and the matcher receives      a profit denominated in the ERC20 token.",
+        "params": {
+          "buyOrderSignatures": "Signatures for the buy orders.",
+          "buyOrders": "Orders buying ERC721 assets.",
+          "sellOrderSignatures": "Signatures for the sell orders.",
+          "sellOrders": "Orders selling ERC721 assets."
         },
-        {
-          "internalType": "uint256[]",
-          "name": "minValidSalts",
-          "type": "uint256[]"
+        "returns": {
+          "profits": "The amount of profit earned by the caller         of this function for each pair of matched orders         (denominated in the ERC20 token of the order pair).",
+          "successes": "An array of booleans corresponding to         whether each pair of orders was successfully matched."
         }
-      ],
-      "name": "batchCancelPairRfqOrdersWithSigner",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.RfqOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
+      },
+      "buyERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint128,bytes)": {
+        "details": "Buys an ERC1155 asset by filling the given order.",
+        "params": {
+          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC1155OrderCallback` on `msg.sender` after        the ERC1155 asset has been transferred to `msg.sender`        but before transferring the ERC20 tokens to the seller.        Native tokens acquired during the callback can be used        to fill the order.",
+          "erc1155BuyAmount": "The amount of the ERC1155 asset        to buy.",
+          "sellOrder": "The ERC1155 sell order.",
+          "signature": "The order signature."
         }
-      ],
-      "name": "batchCancelRfqOrders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "address payable",
-              "name": "signer",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "minGasPrice",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "maxGasPrice",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expirationTimeSeconds",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            },
-            {
-              "internalType": "bytes",
-              "name": "callData",
-              "type": "bytes"
-            },
-            {
-              "internalType": "uint256",
-              "name": "value",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "feeToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "feeAmount",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData[]",
-          "name": "mtxs",
-          "type": "tuple[]"
+      },
+      "buyERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),bytes)": {
+        "details": "Buys an ERC721 asset by filling the given order.",
+        "params": {
+          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC721OrderCallback` on `msg.sender` after        the ERC721 asset has been transferred to `msg.sender`        but before transferring the ERC20 tokens to the seller.        Native tokens acquired during the callback can be used        to fill the order.",
+          "sellOrder": "The ERC721 sell order.",
+          "signature": "The order signature."
+        }
+      },
+      "cancelERC1155Order(uint256)": {
+        "details": "Cancel a single ERC1155 order by its nonce. The caller      should be the maker of the order. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
+        "params": {
+          "orderNonce": "The order nonce."
+        }
+      },
+      "cancelERC721Order(uint256)": {
+        "details": "Cancel a single ERC721 order by its nonce. The caller      should be the maker of the order. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
+        "params": {
+          "orderNonce": "The order nonce."
+        }
+      },
+      "cancelLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))": {
+        "details": "Cancel a single limit order. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
+        "params": {
+          "order": "The limit order."
+        }
+      },
+      "cancelPairLimitOrders(address,address,uint256)": {
+        "details": "Cancel all limit orders for a given maker and pair with a salt less      than the value provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "makerToken": "The maker token.",
+          "minValidSalt": "The new minimum valid salt.",
+          "takerToken": "The taker token."
+        }
+      },
+      "cancelPairLimitOrdersWithSigner(address,address,address,uint256)": {
+        "details": "Cancel all limit orders for a given maker and pair with a salt less      than the value provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "maker": "The maker for which to cancel.",
+          "makerToken": "The maker token.",
+          "minValidSalt": "The new minimum valid salt.",
+          "takerToken": "The taker token."
+        }
+      },
+      "cancelPairRfqOrders(address,address,uint256)": {
+        "details": "Cancel all RFQ orders for a given maker and pair with a salt less      than the value provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "makerToken": "The maker token.",
+          "minValidSalt": "The new minimum valid salt.",
+          "takerToken": "The taker token."
+        }
+      },
+      "cancelPairRfqOrdersWithSigner(address,address,address,uint256)": {
+        "details": "Cancel all RFQ orders for a given maker and pair with a salt less      than the value provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
+        "params": {
+          "maker": "The maker for which to cancel.",
+          "makerToken": "The maker token.",
+          "minValidSalt": "The new minimum valid salt.",
+          "takerToken": "The taker token."
+        }
+      },
+      "cancelRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))": {
+        "details": "Cancel a single RFQ order. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
+        "params": {
+          "order": "The RFQ order."
+        }
+      },
+      "createTransformWallet()": {
+        "details": "Deploy a new flash wallet instance and replace the current one with it.      Useful if we somehow break the current wallet instance.       Only callable by the owner.",
+        "returns": {
+          "wallet": "The new wallet instance."
+        }
+      },
+      "executeMetaTransaction((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Execute a single meta-transaction.",
+        "params": {
+          "mtx": "The meta-transaction.",
+          "signature": "The signature by `mtx.signer`."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
+        "returns": {
+          "returnResult": "The ABI-encoded result of the underlying call."
         }
-      ],
-      "name": "batchExecuteMetaTransactions",
-      "outputs": [
-        {
-          "internalType": "bytes[]",
-          "name": "returnResults",
-          "type": "bytes[]"
+      },
+      "extend(bytes4,address)": {
+        "details": "Register or replace a function.",
+        "params": {
+          "impl": "The implementation contract for the function.",
+          "selector": "The function selector."
         }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "feeRecipient",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.LimitOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint128[]",
-          "name": "takerTokenFillAmounts",
-          "type": "uint128[]"
+      },
+      "fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
+        "details": "Fill a limit order. The taker and sender will be the caller.",
+        "params": {
+          "order": "The limit order. ETH protocol fees can be      attached to this call. Any unspent ETH will be refunded to      the caller.",
+          "signature": "The order signature.",
+          "takerTokenFillAmount": "Maximum taker token amount to fill this order with."
         },
-        {
-          "internalType": "bool",
-          "name": "revertIfIncomplete",
-          "type": "bool"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much maker token was filled."
         }
-      ],
-      "name": "batchFillLimitOrders",
-      "outputs": [
-        {
-          "internalType": "uint128[]",
-          "name": "takerTokenFilledAmounts",
-          "type": "uint128[]"
+      },
+      "fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
+        "details": "Fill an RFQ order for exactly `takerTokenFillAmount` taker tokens.      The taker will be the caller. ETH protocol fees can be      attached to this call. Any unspent ETH will be refunded to      the caller.",
+        "params": {
+          "order": "The limit order.",
+          "signature": "The order signature.",
+          "takerTokenFillAmount": "How much taker token to fill this order with."
         },
-        {
-          "internalType": "uint128[]",
-          "name": "makerTokenFilledAmounts",
-          "type": "uint128[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled."
         }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.RfqOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
+      },
+      "fillOrKillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
+        "details": "Fill an RFQ order for exactly `takerTokenFillAmount` taker tokens.      The taker will be the caller.",
+        "params": {
+          "order": "The RFQ order.",
+          "signature": "The order signature.",
+          "takerTokenFillAmount": "How much taker token to fill this order with."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled."
+        }
+      },
+      "fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
+        "details": "Fill an OTC order for up to `takerTokenFillAmount` taker tokens.",
+        "params": {
+          "makerSignature": "The order signature from the maker.",
+          "order": "The OTC order.",
+          "takerTokenFillAmount": "Maximum taker token amount to fill this        order with."
         },
-        {
-          "internalType": "uint128[]",
-          "name": "takerTokenFillAmounts",
-          "type": "uint128[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much taker token was filled."
+        }
+      },
+      "fillOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
+        "details": "Fill an OTC order for up to `takerTokenFillAmount` taker tokens.      Unwraps bought WETH into ETH before sending it to       the taker.",
+        "params": {
+          "makerSignature": "The order signature from the maker.",
+          "order": "The OTC order.",
+          "takerTokenFillAmount": "Maximum taker token amount to fill this        order with."
         },
-        {
-          "internalType": "bool",
-          "name": "revertIfIncomplete",
-          "type": "bool"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much taker token was filled."
         }
-      ],
-      "name": "batchFillRfqOrders",
-      "outputs": [
-        {
-          "internalType": "uint128[]",
-          "name": "takerTokenFilledAmounts",
-          "type": "uint128[]"
+      },
+      "fillOtcOrderWithEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Fill an OTC order whose taker token is WETH for up      to `msg.value`.",
+        "params": {
+          "makerSignature": "The order signature from the maker.",
+          "order": "The OTC order."
         },
-        {
-          "internalType": "uint128[]",
-          "name": "makerTokenFilledAmounts",
-          "type": "uint128[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much taker token was filled."
         }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiryAndNonce",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.OtcOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
+      },
+      "fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
+        "details": "Fill an RFQ order for up to `takerTokenFillAmount` taker tokens.      The taker will be the caller.",
+        "params": {
+          "order": "The RFQ order.",
+          "signature": "The order signature.",
+          "takerTokenFillAmount": "Maximum taker token amount to fill this order with."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "makerSignatures",
-          "type": "tuple[]"
+        "returns": {
+          "makerTokenFilledAmount": "How much maker token was filled.",
+          "takerTokenFilledAmount": "How much maker token was filled."
+        }
+      },
+      "fillTakerSignedOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Fully fill an OTC order. \"Meta-transaction\" variant,      requires order to be signed by both maker and taker.",
+        "params": {
+          "makerSignature": "The order signature from the maker.",
+          "order": "The OTC order.",
+          "takerSignature": "The order signature from the taker."
+        }
+      },
+      "fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Fully fill an OTC order. \"Meta-transaction\" variant,      requires order to be signed by both maker and taker.      Unwraps bought WETH into ETH before sending it to       the taker.",
+        "params": {
+          "makerSignature": "The order signature from the maker.",
+          "order": "The OTC order.",
+          "takerSignature": "The order signature from the taker."
+        }
+      },
+      "getERC1155OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))": {
+        "details": "Get the EIP-712 hash of an ERC1155 order.",
+        "params": {
+          "order": "The ERC1155 order."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "takerSignatures",
-          "type": "tuple[]"
+        "returns": {
+          "orderHash": "The order hash."
+        }
+      },
+      "getERC1155OrderInfo((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))": {
+        "details": "Get the order info for an ERC1155 order.",
+        "params": {
+          "order": "The ERC1155 order."
         },
-        {
-          "internalType": "bool[]",
-          "name": "unwrapWeth",
-          "type": "bool[]"
+        "returns": {
+          "orderInfo": "Infor about the order."
         }
-      ],
-      "name": "batchFillTakerSignedOtcOrders",
-      "outputs": [
-        {
-          "internalType": "bool[]",
-          "name": "successes",
-          "type": "bool[]"
+      },
+      "getERC721OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))": {
+        "details": "Get the EIP-712 hash of an ERC721 order.",
+        "params": {
+          "order": "The ERC721 order."
+        },
+        "returns": {
+          "orderHash": "The order hash."
         }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "feeRecipient",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.LimitOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
+      },
+      "getERC721OrderStatus((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))": {
+        "details": "Get the current status of an ERC721 order.",
+        "params": {
+          "order": "The ERC721 order."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
+        "returns": {
+          "status": "The status of the order."
         }
-      ],
-      "name": "batchGetLimitOrderRelevantStates",
-      "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFilledAmount",
-              "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.OrderInfo[]",
-          "name": "orderInfos",
-          "type": "tuple[]"
+      },
+      "getERC721OrderStatusBitVector(address,uint248)": {
+        "details": "Get the order status bit vector for the given      maker address and nonce range.",
+        "params": {
+          "maker": "The maker of the order.",
+          "nonceRange": "Order status bit vectors are indexed        by maker address and the upper 248 bits of the        order nonce. We define `nonceRange` to be these        248 bits."
         },
-        {
-          "internalType": "uint128[]",
-          "name": "actualFillableTakerTokenAmounts",
-          "type": "uint128[]"
+        "returns": {
+          "bitVector": "The order status bit vector for the         given maker and nonce range."
+        }
+      },
+      "getLimitOrderHash((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))": {
+        "details": "Get the canonical hash of a limit order.",
+        "params": {
+          "order": "The limit order."
         },
-        {
-          "internalType": "bool[]",
-          "name": "isSignatureValids",
-          "type": "bool[]"
+        "returns": {
+          "orderHash": "The order hash."
         }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.RfqOrder[]",
-          "name": "orders",
-          "type": "tuple[]"
+      },
+      "getLimitOrderInfo((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))": {
+        "details": "Get the order info for a limit order.",
+        "params": {
+          "order": "The limit order."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "signatures",
-          "type": "tuple[]"
+        "returns": {
+          "orderInfo": "Info about the order."
         }
-      ],
-      "name": "batchGetRfqOrderRelevantStates",
-      "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFilledAmount",
-              "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.OrderInfo[]",
-          "name": "orderInfos",
-          "type": "tuple[]"
+      },
+      "getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Get order info, fillable amount, and signature validity for a limit order.      Fillable amount is determined using balances and allowances of the maker.",
+        "params": {
+          "order": "The limit order.",
+          "signature": "The order signature."
         },
-        {
-          "internalType": "uint128[]",
-          "name": "actualFillableTakerTokenAmounts",
-          "type": "uint128[]"
+        "returns": {
+          "actualFillableTakerTokenAmount": "How much of the order is fillable         based on maker funds, in taker tokens.",
+          "isSignatureValid": "Whether the signature is valid.",
+          "orderInfo": "Info about the order."
+        }
+      },
+      "getMetaTransactionExecutedBlock((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))": {
+        "details": "Get the block at which a meta-transaction has been executed.",
+        "params": {
+          "mtx": "The meta-transaction."
         },
-        {
-          "internalType": "bool[]",
-          "name": "isSignatureValids",
-          "type": "bool[]"
+        "returns": {
+          "blockNumber": "The block height when the meta-transactioin was executed."
         }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc721TokenId",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
-            }
-          ],
-          "internalType": "struct LibNFTOrder.ERC721Order[]",
-          "name": "sellOrders",
-          "type": "tuple[]"
+      },
+      "getMetaTransactionHash((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))": {
+        "details": "Get the EIP712 hash of a meta-transaction.",
+        "params": {
+          "mtx": "The meta-transaction."
+        },
+        "returns": {
+          "mtxHash": "The EIP712 hash of `mtx`."
+        }
+      },
+      "getMetaTransactionHashExecutedBlock(bytes32)": {
+        "details": "Get the block at which a meta-transaction hash has been executed.",
+        "params": {
+          "mtxHash": "The meta-transaction hash."
+        },
+        "returns": {
+          "blockNumber": "The block height when the meta-transactioin was executed."
+        }
+      },
+      "getOtcOrderHash((address,address,uint128,uint128,address,address,address,uint256))": {
+        "details": "Get the canonical hash of an OTC order.",
+        "params": {
+          "order": "The OTC order."
+        },
+        "returns": {
+          "orderHash": "The order hash."
+        }
+      },
+      "getOtcOrderInfo((address,address,uint128,uint128,address,address,address,uint256))": {
+        "details": "Get the order info for an OTC order.",
+        "params": {
+          "order": "The OTC order."
+        },
+        "returns": {
+          "orderInfo": "Info about the order."
+        }
+      },
+      "getProtocolFeeMultiplier()": {
+        "details": "Get the protocol fee multiplier. This should be multiplied by the      gas price to arrive at the required protocol fee to fill a native order.",
+        "returns": {
+          "multiplier": "The protocol fee multiplier."
+        }
+      },
+      "getQuoteSigner()": {
+        "details": "Return the optional signer for `transformERC20()` calldata.",
+        "returns": {
+          "signer": "The transform deployer address."
+        }
+      },
+      "getRfqOrderHash((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))": {
+        "details": "Get the canonical hash of an RFQ order.",
+        "params": {
+          "order": "The RFQ order."
+        },
+        "returns": {
+          "orderHash": "The order hash."
+        }
+      },
+      "getRfqOrderInfo((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))": {
+        "details": "Get the order info for an RFQ order.",
+        "params": {
+          "order": "The RFQ order."
+        },
+        "returns": {
+          "orderInfo": "Info about the order."
+        }
+      },
+      "getRfqOrderRelevantState((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Get order info, fillable amount, and signature validity for an RFQ order.      Fillable amount is determined using balances and allowances of the maker.",
+        "params": {
+          "order": "The RFQ order.",
+          "signature": "The order signature."
+        },
+        "returns": {
+          "actualFillableTakerTokenAmount": "How much of the order is fillable         based on maker funds, in taker tokens.",
+          "isSignatureValid": "Whether the signature is valid.",
+          "orderInfo": "Info about the order."
+        }
+      },
+      "getRollbackEntryAtIndex(bytes4,uint256)": {
+        "details": "Retrieve an entry in the rollback history for a function.",
+        "params": {
+          "idx": "The index in the rollback history.",
+          "selector": "The function selector."
+        },
+        "returns": {
+          "impl": "An implementation address for the function at         index `idx`."
+        }
+      },
+      "getRollbackLength(bytes4)": {
+        "details": "Retrieve the length of the rollback history for a function.",
+        "params": {
+          "selector": "The function selector."
+        },
+        "returns": {
+          "rollbackLength": "The number of items in the rollback history for         the function."
+        }
+      },
+      "getTransformWallet()": {
+        "details": "Return the current wallet instance that will serve as the execution      context for transformations.",
+        "returns": {
+          "wallet": "The wallet instance."
+        }
+      },
+      "getTransformerDeployer()": {
+        "details": "Return the allowed deployer for transformers.",
+        "returns": {
+          "deployer": "The transform deployer address."
+        }
+      },
+      "isValidOrderSigner(address,address)": {
+        "details": "checks if a given address is registered to sign on behalf of a maker address",
+        "params": {
+          "maker": "The maker address encoded in an order (can be a contract)",
+          "signer": "The address that is providing a signature"
+        }
+      },
+      "lastOtcTxOriginNonce(address,uint64)": {
+        "details": "Get the last nonce used for a particular      tx.origin address and nonce bucket.",
+        "params": {
+          "nonceBucket": "The nonce bucket index.",
+          "txOrigin": "The address."
+        },
+        "returns": {
+          "lastNonce": "The last nonce value used."
+        }
+      },
+      "matchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Matches a pair of complementary orders that have      a non-negative spread. Each order is filled at      their respective price, and the matcher receives      a profit denominated in the ERC20 token.",
+        "params": {
+          "buyOrder": "Order buying an ERC721 asset.",
+          "buyOrderSignature": "Signature for the buy order.",
+          "sellOrder": "Order selling an ERC721 asset.",
+          "sellOrderSignature": "Signature for the sell order."
+        },
+        "returns": {
+          "profit": "The amount of profit earned by the caller         of this function (denominated in the ERC20 token         of the matched orders)."
+        }
+      },
+      "migrate(address,bytes,address)": {
+        "details": "Execute a migration function in the context of the ZeroEx contract.      The result of the function being called should be the magic bytes      0x2c64c5ef (`keccack('MIGRATE_SUCCESS')`). Only callable by the owner.      The owner will be temporarily set to `address(this)` inside the call.      Before returning, the owner will be set to `newOwner`.",
+        "params": {
+          "data": "The call data.",
+          "newOwner": "The address of the new owner.",
+          "target": "The migrator contract address."
+        }
+      },
+      "multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)": {
+        "details": "Sells attached ETH for `outputToken` using the provided      calls.",
+        "params": {
+          "calls": "The calls to use to sell the attached ETH.",
+          "minBuyAmount": "The minimum amount of `outputToken` that        must be bought for this function to not revert.",
+          "outputToken": "The token to buy."
+        },
+        "returns": {
+          "boughtAmount": "The amount of `outputToken` bought."
+        }
+      },
+      "multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)": {
+        "details": "Sells `sellAmount` of the given `inputToken` for ETH      using the provided calls.",
+        "params": {
+          "calls": "The calls to use to sell the input tokens.",
+          "inputToken": "The token to sell.",
+          "minBuyAmount": "The minimum amount of ETH that        must be bought for this function to not revert.",
+          "sellAmount": "The amount of `inputToken` to sell."
+        },
+        "returns": {
+          "boughtAmount": "The amount of ETH bought."
+        }
+      },
+      "multiplexBatchSellTokenForToken(address,address,(uint8,uint256,bytes)[],uint256,uint256)": {
+        "details": "Sells `sellAmount` of the given `inputToken` for      `outputToken` using the provided calls.",
+        "params": {
+          "calls": "The calls to use to sell the input tokens.",
+          "inputToken": "The token to sell.",
+          "minBuyAmount": "The minimum amount of `outputToken`        that must be bought for this function to not revert.",
+          "outputToken": "The token to buy.",
+          "sellAmount": "The amount of `inputToken` to sell."
+        },
+        "returns": {
+          "boughtAmount": "The amount of `outputToken` bought."
+        }
+      },
+      "multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)": {
+        "details": "Sells attached ETH via the given sequence of tokens      and calls. `tokens[0]` must be WETH.      The last token in `tokens` is the output token that      will ultimately be sent to `msg.sender`",
+        "params": {
+          "calls": "The sequence of calls to use for the sell.",
+          "minBuyAmount": "The minimum amount of output tokens that        must be bought for this function to not revert.",
+          "tokens": "The sequence of tokens to use for the sell,        i.e. `tokens[i]` will be sold for `tokens[i+1]` via        `calls[i]`."
+        },
+        "returns": {
+          "boughtAmount": "The amount of output tokens bought."
+        }
+      },
+      "multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)": {
+        "details": "Sells `sellAmount` of the input token (`tokens[0]`)      for ETH via the given sequence of tokens and calls.      The last token in `tokens` must be WETH.",
+        "params": {
+          "calls": "The sequence of calls to use for the sell.",
+          "minBuyAmount": "The minimum amount of ETH that        must be bought for this function to not revert.",
+          "tokens": "The sequence of tokens to use for the sell,        i.e. `tokens[i]` will be sold for `tokens[i+1]` via        `calls[i]`."
+        },
+        "returns": {
+          "boughtAmount": "The amount of ETH bought."
+        }
+      },
+      "multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)": {
+        "details": "Sells `sellAmount` of the input token (`tokens[0]`)      via the given sequence of tokens and calls.      The last token in `tokens` is the output token that      will ultimately be sent to `msg.sender`",
+        "params": {
+          "calls": "The sequence of calls to use for the sell.",
+          "minBuyAmount": "The minimum amount of output tokens that        must be bought for this function to not revert.",
+          "tokens": "The sequence of tokens to use for the sell,        i.e. `tokens[i]` will be sold for `tokens[i+1]` via        `calls[i]`."
+        },
+        "returns": {
+          "boughtAmount": "The amount of output tokens bought."
+        }
+      },
+      "onERC1155Received(address,address,uint256,uint256,bytes)": {
+        "details": "Callback for the ERC1155 `safeTransferFrom` function.      This callback can be used to sell an ERC1155 asset if      a valid ERC1155 order, signature and `unwrapNativeToken`      are encoded in `data`. This allows takers to sell their      ERC1155 asset without first calling `setApprovalForAll`.",
+        "params": {
+          "data": "Additional data with no specified format. If a        valid ERC1155 order, signature and `unwrapNativeToken`        are encoded in `data`, this function will try to fill        the order using the received asset.",
+          "from": "The address which previously owned the token.",
+          "operator": "The address which called `safeTransferFrom`.",
+          "tokenId": "The ID of the asset being transferred.",
+          "value": "The amount being transferred."
+        },
+        "returns": {
+          "success": "The selector of this function (0xf23a6e61),         indicating that the callback succeeded."
+        }
+      },
+      "onERC721Received(address,address,uint256,bytes)": {
+        "details": "Callback for the ERC721 `safeTransferFrom` function.      This callback can be used to sell an ERC721 asset if      a valid ERC721 order, signature and `unwrapNativeToken`      are encoded in `data`. This allows takers to sell their      ERC721 asset without first calling `setApprovalForAll`.",
+        "params": {
+          "data": "Additional data with no specified format. If a        valid ERC721 order, signature and `unwrapNativeToken`        are encoded in `data`, this function will try to fill        the order using the received asset.",
+          "from": "The address which previously owned the token.",
+          "operator": "The address which called `safeTransferFrom`.",
+          "tokenId": "The ID of the asset being transferred."
+        },
+        "returns": {
+          "success": "The selector of this function (0x150b7a02),         indicating that the callback succeeded."
+        }
+      },
+      "owner()": {
+        "details": "The owner of this contract.",
+        "returns": {
+          "ownerAddress": "The owner address."
+        }
+      },
+      "preSignERC1155Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))": {
+        "details": "Approves an ERC1155 order on-chain. After pre-signing      the order, the `PRESIGNED` signature type will become      valid for that order and signer.",
+        "params": {
+          "order": "An ERC1155 order."
+        }
+      },
+      "preSignERC721Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))": {
+        "details": "Approves an ERC721 order on-chain. After pre-signing      the order, the `PRESIGNED` signature type will become      valid for that order and signer.",
+        "params": {
+          "order": "An ERC721 order."
+        }
+      },
+      "registerAllowedOrderSigner(address,bool)": {
+        "details": "Register a signer who can sign on behalf of msg.sender      This allows one to sign on behalf of a contract that calls this function",
+        "params": {
+          "allowed": "True to register, false to unregister.",
+          "signer": "The address from which you plan to generate signatures"
+        }
+      },
+      "registerAllowedRfqOrigins(address[],bool)": {
+        "details": "Mark what tx.origin addresses are allowed to fill an order that      specifies the message sender as its txOrigin.",
+        "params": {
+          "allowed": "True to register, false to unregister.",
+          "origins": "An array of origin addresses to update."
+        }
+      },
+      "rollback(bytes4,address)": {
+        "details": "Roll back to a prior implementation of a function.",
+        "params": {
+          "selector": "The function selector.",
+          "targetImpl": "The address of an older implementation of the function."
+        }
+      },
+      "sellERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint256,uint128,bool,bytes)": {
+        "details": "Sells an ERC1155 asset to fill the given order.",
+        "params": {
+          "buyOrder": "The ERC1155 buy order.",
+          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC1155OrderCallback` on `msg.sender` after        the ERC20 tokens have been transferred to `msg.sender`        but before transferring the ERC1155 asset to the buyer.",
+          "erc1155SellAmount": "The amount of the ERC1155 asset        to sell.",
+          "erc1155TokenId": "The ID of the ERC1155 asset being        sold. If the given order specifies properties,        the asset must satisfy those properties. Otherwise,        it must equal the tokenId in the order.",
+          "signature": "The order signature from the maker.",
+          "unwrapNativeToken": "If this parameter is true and the        ERC20 token of the order is e.g. WETH, unwraps the        token before transferring it to the taker."
+        }
+      },
+      "sellERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),uint256,bool,bytes)": {
+        "details": "Sells an ERC721 asset to fill the given order.",
+        "params": {
+          "buyOrder": "The ERC721 buy order.",
+          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC721OrderCallback` on `msg.sender` after        the ERC20 tokens have been transferred to `msg.sender`        but before transferring the ERC721 asset to the buyer.",
+          "erc721TokenId": "The ID of the ERC721 asset being        sold. If the given order specifies properties,        the asset must satisfy those properties. Otherwise,        it must equal the tokenId in the order.",
+          "signature": "The order signature from the maker.",
+          "unwrapNativeToken": "If this parameter is true and the        ERC20 token of the order is e.g. WETH, unwraps the        token before transferring it to the taker."
+        }
+      },
+      "sellEthForTokenToUniswapV3(bytes,uint256,address)": {
+        "details": "Sell attached ETH directly against uniswap v3.",
+        "params": {
+          "encodedPath": "Uniswap-encoded path, where the first token is WETH.",
+          "minBuyAmount": "Minimum amount of the last token in the path to buy.",
+          "recipient": "The recipient of the bought tokens. Can be zero for sender."
+        },
+        "returns": {
+          "buyAmount": "Amount of the last token in the path bought."
+        }
+      },
+      "sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)": {
+        "details": "Sells `sellAmount` of `inputToken` to the liquidity provider      at the given `provider` address.",
+        "params": {
+          "auxiliaryData": "Auxiliary data supplied to the `provider` contract.",
+          "inputToken": "The token being sold.",
+          "minBuyAmount": "The minimum acceptable amount of `outputToken` to        buy. Reverts if this amount is not satisfied.",
+          "outputToken": "The token being bought.",
+          "provider": "The address of the on-chain liquidity provider        to trade with.",
+          "recipient": "The recipient of the bought tokens. If equal to        address(0), `msg.sender` is assumed to be the recipient.",
+          "sellAmount": "The amount of `inputToken` to sell."
+        },
+        "returns": {
+          "boughtAmount": "The amount of `outputToken` bought."
+        }
+      },
+      "sellToPancakeSwap(address[],uint256,uint256,uint8)": {
+        "details": "Efficiently sell directly to PancakeSwap (and forks).",
+        "params": {
+          "fork": "The protocol fork to use.",
+          "minBuyAmount": "Minimum amount of `tokens[-1]` to buy.",
+          "sellAmount": "of `tokens[0]` Amount to sell.",
+          "tokens": "Sell path."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc721TokenId",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
-            }
-          ],
-          "internalType": "struct LibNFTOrder.ERC721Order[]",
-          "name": "buyOrders",
-          "type": "tuple[]"
+        "returns": {
+          "buyAmount": "Amount of `tokens[-1]` bought."
+        }
+      },
+      "sellToUniswap(address[],uint256,uint256,bool)": {
+        "details": "Efficiently sell directly to uniswap/sushiswap.",
+        "params": {
+          "isSushi": "Use sushiswap if true.",
+          "minBuyAmount": "Minimum amount of `tokens[-1]` to buy.",
+          "sellAmount": "of `tokens[0]` Amount to sell.",
+          "tokens": "Sell path."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "sellOrderSignatures",
-          "type": "tuple[]"
+        "returns": {
+          "buyAmount": "Amount of `tokens[-1]` bought."
+        }
+      },
+      "sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)": {
+        "details": "Sell a token for ETH directly against uniswap v3.",
+        "params": {
+          "encodedPath": "Uniswap-encoded path, where the last token is WETH.",
+          "minBuyAmount": "Minimum amount of ETH to buy.",
+          "recipient": "The recipient of the bought tokens. Can be zero for sender.",
+          "sellAmount": "amount of the first token in the path to sell."
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature[]",
-          "name": "buyOrderSignatures",
-          "type": "tuple[]"
+        "returns": {
+          "buyAmount": "Amount of ETH bought."
+        }
+      },
+      "sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)": {
+        "details": "Sell a token for another token directly against uniswap v3.",
+        "params": {
+          "encodedPath": "Uniswap-encoded path.",
+          "minBuyAmount": "Minimum amount of the last token in the path to buy.",
+          "recipient": "The recipient of the bought tokens. Can be zero for sender.",
+          "sellAmount": "amount of the first token in the path to sell."
+        },
+        "returns": {
+          "buyAmount": "Amount of the last token in the path bought."
+        }
+      },
+      "setQuoteSigner(address)": {
+        "details": "Replace the optional signer for `transformERC20()` calldata.      Only callable by the owner.",
+        "params": {
+          "quoteSigner": "The address of the new calldata signer."
+        }
+      },
+      "setTransformerDeployer(address)": {
+        "details": "Replace the allowed deployer for transformers.      Only callable by the owner.",
+        "params": {
+          "transformerDeployer": "The address of the new trusted deployer        for transformers."
+        }
+      },
+      "supportInterface(bytes4)": {
+        "details": "Indicates whether the 0x Exchange Proxy implements a particular      ERC165 interface. This function should use at most 30,000 gas.",
+        "params": {
+          "interfaceId": "The interface identifier, as specified in ERC165."
+        },
+        "returns": {
+          "isSupported": "Whether the given interface is supported by the         0x Exchange Proxy."
+        }
+      },
+      "transferOwnership(address)": {
+        "details": "Transfers ownership of the contract to a new address.",
+        "params": {
+          "newOwner": "The address that will become the owner."
+        }
+      },
+      "transferProtocolFeesForPools(bytes32[])": {
+        "details": "Transfers protocol fees from the `FeeCollector` pools into      the staking contract.",
+        "params": {
+          "poolIds": "Staking pool IDs"
+        }
+      },
+      "transferTrappedTokensTo(address,uint256,address)": {
+        "details": "calledFrom FundRecoveryFeature.transferTrappedTokensTo() This will be delegatecalled in the context of the Exchange Proxy instance being used.",
+        "params": {
+          "amountOut": "Amount of tokens to withdraw.",
+          "erc20": "ERC20 Token Address.",
+          "recipientWallet": "Recipient wallet address."
+        }
+      },
+      "transformERC20(address,address,uint256,uint256,(uint32,bytes)[])": {
+        "details": "Executes a series of transformations to convert an ERC20 `inputToken`      to an ERC20 `outputToken`.",
+        "params": {
+          "inputToken": "The token being provided by the sender.        If `0xeee...`, ETH is implied and should be provided with the call.`",
+          "inputTokenAmount": "The amount of `inputToken` to take from the sender.",
+          "minOutputTokenAmount": "The minimum amount of `outputToken` the sender        must receive for the entire transformation to succeed.",
+          "outputToken": "The token to be acquired by the sender.        `0xeee...` implies ETH.",
+          "transformations": "The transformations to execute on the token balance(s)        in sequence."
+        },
+        "returns": {
+          "outputTokenAmount": "The amount of `outputToken` received by the sender."
+        }
+      },
+      "uniswapV3SwapCallback(int256,int256,bytes)": {
+        "details": "The UniswapV3 pool swap callback which pays the funds requested      by the caller/pool to the pool. Can only be called by a valid      UniswapV3 pool.",
+        "params": {
+          "amount0Delta": "Token0 amount owed.",
+          "amount1Delta": "Token1 amount owed.",
+          "data": "Arbitrary data forwarded from swap() caller. An ABI-encoded        struct of: inputToken, outputToken, fee, payer"
+        }
+      },
+      "validateERC1155OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),uint256)": {
+        "details": "If the given order is buying an ERC1155 asset, checks      whether or not the given token ID satisfies the required      properties specified in the order. If the order does not      specify any properties, this function instead checks      whether the given token ID matches the ID in the order.      Reverts if any checks fail, or if the order is selling      an ERC1155 asset.",
+        "params": {
+          "erc1155TokenId": "The ID of the ERC1155 asset.",
+          "order": "The ERC1155 order."
+        }
+      },
+      "validateERC1155OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Checks whether the given signature is valid for the      the given ERC1155 order. Reverts if not.",
+        "params": {
+          "order": "The ERC1155 order.",
+          "signature": "The signature to validate."
         }
-      ],
-      "name": "batchMatchERC721Orders",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "profits",
-          "type": "uint256[]"
-        },
-        {
-          "internalType": "bool[]",
-          "name": "successes",
-          "type": "bool[]"
+      },
+      "validateERC721OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),uint256)": {
+        "details": "If the given order is buying an ERC721 asset, checks      whether or not the given token ID satisfies the required      properties specified in the order. If the order does not      specify any properties, this function instead checks      whether the given token ID matches the ID in the order.      Reverts if any checks fail, or if the order is selling      an ERC721 asset.",
+        "params": {
+          "erc721TokenId": "The ID of the ERC721 asset.",
+          "order": "The ERC721 order."
         }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
+      },
+      "validateERC721OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32))": {
+        "details": "Checks whether the given signature is valid for the      the given ERC721 order. Reverts if not.",
+        "params": {
+          "order": "The ERC721 order.",
+          "signature": "The signature to validate."
+        }
+      }
     },
+    "version": 1
+  },
+  "_disabled": [
     {
       "inputs": [
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerTokenFeeAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
+              "internalType": "address",
+              "name": "maker",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
             },
             {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
             },
             {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
+              "internalType": "address",
+              "name": "feeRecipient",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc1155TokenId",
-              "type": "uint256"
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
             },
             {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
-              "type": "tuple[]"
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
             },
             {
-              "internalType": "uint128",
-              "name": "erc1155TokenAmount",
-              "type": "uint128"
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC1155Order",
-          "name": "sellOrder",
+          "internalType": "struct LibNativeOrder.LimitOrder",
+          "name": "order",
           "type": "tuple"
         },
         {
@@ -3019,17 +2253,33 @@
         },
         {
           "internalType": "uint128",
-          "name": "erc1155BuyAmount",
+          "name": "takerTokenFillAmount",
           "type": "uint128"
         },
         {
-          "internalType": "bytes",
-          "name": "callbackData",
-          "type": "bytes"
+          "internalType": "address",
+          "name": "taker",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "sender",
+          "type": "address"
+        }
+      ],
+      "name": "_fillLimitOrder",
+      "outputs": [
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "name": "buyERC1155",
-      "outputs": [],
       "stateMutability": "payable",
       "type": "function"
     },
@@ -3038,92 +2288,48 @@
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "taker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
+              "internalType": "address",
+              "name": "maker",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
             },
             {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
+              "internalType": "address",
+              "name": "txOrigin",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "erc721TokenId",
+              "name": "expiryAndNonce",
               "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "sellOrder",
+          "internalType": "struct LibNativeOrder.OtcOrder",
+          "name": "order",
           "type": "tuple"
         },
         {
@@ -3150,43 +2356,43 @@
             }
           ],
           "internalType": "struct LibSignature.Signature",
-          "name": "signature",
+          "name": "makerSignature",
           "type": "tuple"
         },
         {
-          "internalType": "bytes",
-          "name": "callbackData",
-          "type": "bytes"
-        }
-      ],
-      "name": "buyERC721",
-      "outputs": [],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "address",
+          "name": "taker",
+          "type": "address"
+        },
+        {
+          "internalType": "bool",
+          "name": "useSelfBalance",
+          "type": "bool"
+        },
         {
-          "internalType": "uint256",
-          "name": "orderNonce",
-          "type": "uint256"
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         }
       ],
-      "name": "cancelERC1155Order",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
+      "name": "_fillOtcOrder",
+      "outputs": [
         {
-          "internalType": "uint256",
-          "name": "orderNonce",
-          "type": "uint256"
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "name": "cancelERC721Order",
-      "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
     },
@@ -3214,11 +2420,6 @@
               "name": "takerAmount",
               "type": "uint128"
             },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
-            },
             {
               "internalType": "address",
               "name": "maker",
@@ -3231,12 +2432,7 @@
             },
             {
               "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "feeRecipient",
+              "name": "txOrigin",
               "type": "address"
             },
             {
@@ -3255,115 +2451,105 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.LimitOrder",
+          "internalType": "struct LibNativeOrder.RfqOrder",
           "name": "order",
           "type": "tuple"
-        }
-      ],
-      "name": "cancelLimitOrder",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "makerToken",
-          "type": "address"
         },
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "takerToken",
-          "type": "address"
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
         },
         {
-          "internalType": "uint256",
-          "name": "minValidSalt",
-          "type": "uint256"
-        }
-      ],
-      "name": "cancelPairLimitOrders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
+        },
         {
           "internalType": "address",
-          "name": "maker",
+          "name": "taker",
           "type": "address"
         },
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "makerToken",
-          "type": "address"
+          "internalType": "bool",
+          "name": "useSelfBalance",
+          "type": "bool"
         },
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "takerToken",
+          "internalType": "address",
+          "name": "recipient",
           "type": "address"
+        }
+      ],
+      "name": "_fillRfqOrder",
+      "outputs": [
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
         },
         {
-          "internalType": "uint256",
-          "name": "minValidSalt",
-          "type": "uint256"
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "name": "cancelPairLimitOrdersWithSigner",
-      "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "makerToken",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "takerToken",
-          "type": "address"
+          "internalType": "bytes",
+          "name": "encodedPath",
+          "type": "bytes"
         },
         {
           "internalType": "uint256",
-          "name": "minValidSalt",
+          "name": "sellAmount",
           "type": "uint256"
-        }
-      ],
-      "name": "cancelPairRfqOrders",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "maker",
-          "type": "address"
         },
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "makerToken",
-          "type": "address"
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         },
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "takerToken",
+          "internalType": "address",
+          "name": "recipient",
           "type": "address"
-        },
+        }
+      ],
+      "name": "_sellHeldTokenForTokenToUniswapV3",
+      "outputs": [
         {
           "internalType": "uint256",
-          "name": "minValidSalt",
+          "name": "buyAmount",
           "type": "uint256"
         }
       ],
-      "name": "cancelPairRfqOrdersWithSigner",
-      "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
     },
@@ -3372,77 +2558,72 @@
         {
           "components": [
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
+              "internalType": "address payable",
+              "name": "taker",
               "type": "address"
             },
             {
               "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
+              "name": "inputToken",
               "type": "address"
             },
             {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "outputToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "inputTokenAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "minOutputTokenAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
+              "components": [
+                {
+                  "internalType": "uint32",
+                  "name": "deploymentNonce",
+                  "type": "uint32"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "data",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct ITransformERC20Feature.Transformation[]",
+              "name": "transformations",
+              "type": "tuple[]"
             },
             {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
+              "internalType": "bool",
+              "name": "useSelfBalance",
+              "type": "bool"
             },
             {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
+              "internalType": "address payable",
+              "name": "recipient",
+              "type": "address"
             }
           ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
-          "name": "order",
+          "internalType": "struct ITransformERC20Feature.TransformERC20Args",
+          "name": "args",
           "type": "tuple"
         }
       ],
-      "name": "cancelRfqOrder",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "createTransformWallet",
+      "name": "_transformERC20",
       "outputs": [
         {
-          "internalType": "contract IFlashWallet",
-          "name": "wallet",
-          "type": "address"
+          "internalType": "uint256",
+          "name": "outputTokenAmount",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -3450,59 +2631,98 @@
         {
           "components": [
             {
-              "internalType": "address payable",
-              "name": "signer",
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
               "type": "address"
             },
             {
               "internalType": "address",
-              "name": "sender",
+              "name": "taker",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "minGasPrice",
+              "name": "expiry",
               "type": "uint256"
             },
             {
               "internalType": "uint256",
-              "name": "maxGasPrice",
+              "name": "nonce",
               "type": "uint256"
             },
             {
-              "internalType": "uint256",
-              "name": "expirationTimeSeconds",
-              "type": "uint256"
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "salt",
+              "name": "erc20TokenAmount",
               "type": "uint256"
             },
             {
-              "internalType": "bytes",
-              "name": "callData",
-              "type": "bytes"
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "value",
+              "name": "erc1155TokenId",
               "type": "uint256"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "feeToken",
-              "type": "address"
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
             },
             {
-              "internalType": "uint256",
-              "name": "feeAmount",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "erc1155TokenAmount",
+              "type": "uint128"
             }
           ],
-          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
-          "name": "mtx",
-          "type": "tuple"
+          "internalType": "struct LibNFTOrder.ERC1155Order[]",
+          "name": "sellOrders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -3527,68 +2747,45 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "uint128[]",
+          "name": "erc1155TokenAmounts",
+          "type": "uint128[]"
+        },
+        {
+          "internalType": "bytes[]",
+          "name": "callbackData",
+          "type": "bytes[]"
+        },
+        {
+          "internalType": "bool",
+          "name": "revertIfIncomplete",
+          "type": "bool"
         }
       ],
-      "name": "executeMetaTransaction",
+      "name": "batchBuyERC1155s",
       "outputs": [
         {
-          "internalType": "bytes",
-          "name": "returnResult",
-          "type": "bytes"
+          "internalType": "bool[]",
+          "name": "successes",
+          "type": "bool[]"
         }
       ],
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        },
-        {
-          "internalType": "address",
-          "name": "impl",
-          "type": "address"
-        }
-      ],
-      "name": "extend",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
           "components": [
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
             },
             {
               "internalType": "address",
@@ -3601,34 +2798,78 @@
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
             },
             {
-              "internalType": "address",
-              "name": "feeRecipient",
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
               "type": "address"
             },
             {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "salt",
+              "name": "erc721TokenId",
               "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
             }
           ],
-          "internalType": "struct LibNativeOrder.LimitOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNFTOrder.ERC721Order[]",
+          "name": "sellOrders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -3653,32 +2894,58 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "bytes[]",
+          "name": "callbackData",
+          "type": "bytes[]"
         },
         {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
+          "internalType": "bool",
+          "name": "revertIfIncomplete",
+          "type": "bool"
         }
       ],
-      "name": "fillLimitOrder",
+      "name": "batchBuyERC721s",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "bool[]",
+          "name": "successes",
+          "type": "bool[]"
         }
       ],
       "stateMutability": "payable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "orderNonces",
+          "type": "uint256[]"
+        }
+      ],
+      "name": "batchCancelERC1155Orders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "orderNonces",
+          "type": "uint256[]"
+        }
+      ],
+      "name": "batchCancelERC721Orders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -3744,52 +3011,116 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.LimitOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.LimitOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
+        }
+      ],
+      "name": "batchCancelLimitOrders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "makerTokens",
+          "type": "address[]"
         },
         {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "takerTokens",
+          "type": "address[]"
         },
         {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
+          "internalType": "uint256[]",
+          "name": "minValidSalts",
+          "type": "uint256[]"
         }
       ],
-      "name": "fillOrKillLimitOrder",
-      "outputs": [
+      "name": "batchCancelPairLimitOrders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
         {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "address",
+          "name": "maker",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "makerTokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "takerTokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "minValidSalts",
+          "type": "uint256[]"
         }
       ],
-      "stateMutability": "payable",
+      "name": "batchCancelPairLimitOrdersWithSigner",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "makerTokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "takerTokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "minValidSalts",
+          "type": "uint256[]"
+        }
+      ],
+      "name": "batchCancelPairRfqOrders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "maker",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "makerTokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "takerTokens",
+          "type": "address[]"
+        },
+        {
+          "internalType": "uint256[]",
+          "name": "minValidSalts",
+          "type": "uint256[]"
+        }
+      ],
+      "name": "batchCancelPairRfqOrdersWithSigner",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -3847,9 +3178,74 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.RfqOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
+        }
+      ],
+      "name": "batchCancelRfqOrders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address payable",
+              "name": "signer",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "minGasPrice",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "maxGasPrice",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expirationTimeSeconds",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "callData",
+              "type": "bytes"
+            },
+            {
+              "internalType": "uint256",
+              "name": "value",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "feeToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "feeAmount",
+              "type": "uint256"
+            }
+          ],
+          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData[]",
+          "name": "mtxs",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -3874,25 +3270,20 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
-        },
-        {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
         }
       ],
-      "name": "fillOrKillRfqOrder",
+      "name": "batchExecuteMetaTransactions",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "bytes[]",
+          "name": "returnResults",
+          "type": "bytes[]"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -3919,6 +3310,11 @@
               "name": "takerAmount",
               "type": "uint128"
             },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFeeAmount",
+              "type": "uint128"
+            },
             {
               "internalType": "address",
               "name": "maker",
@@ -3931,18 +3327,33 @@
             },
             {
               "internalType": "address",
-              "name": "txOrigin",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "feeRecipient",
               "type": "address"
             },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
             {
               "internalType": "uint256",
-              "name": "expiryAndNonce",
+              "name": "salt",
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.LimitOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -3967,30 +3378,35 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "makerSignature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
         },
         {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "takerTokenFillAmounts",
+          "type": "uint128[]"
+        },
+        {
+          "internalType": "bool",
+          "name": "revertIfIncomplete",
+          "type": "bool"
         }
       ],
-      "name": "fillOtcOrder",
+      "name": "batchFillLimitOrders",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "takerTokenFilledAmounts",
+          "type": "uint128[]"
         },
         {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "makerTokenFilledAmounts",
+          "type": "uint128[]"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -4032,15 +3448,25 @@
               "name": "txOrigin",
               "type": "address"
             },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
             {
               "internalType": "uint256",
-              "name": "expiryAndNonce",
+              "name": "salt",
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.RfqOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -4065,27 +3491,32 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "makerSignature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
         },
         {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "takerTokenFillAmounts",
+          "type": "uint128[]"
+        },
+        {
+          "internalType": "bool",
+          "name": "revertIfIncomplete",
+          "type": "bool"
         }
       ],
-      "name": "fillOtcOrderForEth",
+      "name": "batchFillRfqOrders",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "takerTokenFilledAmounts",
+          "type": "uint128[]"
         },
         {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "makerTokenFilledAmounts",
+          "type": "uint128[]"
         }
       ],
       "stateMutability": "nonpayable",
@@ -4136,9 +3567,9 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.OtcOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -4163,25 +3594,52 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "makerSignature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "makerSignatures",
+          "type": "tuple[]"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "takerSignatures",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "unwrapWeth",
+          "type": "bool[]"
         }
       ],
-      "name": "fillOtcOrderWithEth",
+      "name": "batchFillTakerSignedOtcOrders",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "bool[]",
+          "name": "successes",
+          "type": "bool[]"
         }
       ],
-      "stateMutability": "payable",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -4208,6 +3666,11 @@
               "name": "takerAmount",
               "type": "uint128"
             },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFeeAmount",
+              "type": "uint128"
+            },
             {
               "internalType": "address",
               "name": "maker",
@@ -4220,7 +3683,12 @@
             },
             {
               "internalType": "address",
-              "name": "txOrigin",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "feeRecipient",
               "type": "address"
             },
             {
@@ -4239,9 +3707,9 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.LimitOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -4266,30 +3734,47 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
-        },
-        {
-          "internalType": "uint128",
-          "name": "takerTokenFillAmount",
-          "type": "uint128"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
         }
       ],
-      "name": "fillRfqOrder",
+      "name": "batchGetLimitOrderRelevantStates",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "takerTokenFilledAmount",
-          "type": "uint128"
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFilledAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OrderInfo[]",
+          "name": "orderInfos",
+          "type": "tuple[]"
         },
         {
-          "internalType": "uint128",
-          "name": "makerTokenFilledAmount",
-          "type": "uint128"
+          "internalType": "uint128[]",
+          "name": "actualFillableTakerTokenAmounts",
+          "type": "uint128[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "isSignatureValids",
+          "type": "bool[]"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
@@ -4331,15 +3816,25 @@
               "name": "txOrigin",
               "type": "address"
             },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
             {
               "internalType": "uint256",
-              "name": "expiryAndNonce",
+              "name": "salt",
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.RfqOrder[]",
+          "name": "orders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -4364,41 +3859,47 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "makerSignature",
-          "type": "tuple"
-        },
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "signatures",
+          "type": "tuple[]"
+        }
+      ],
+      "name": "batchGetRfqOrderRelevantStates",
+      "outputs": [
         {
           "components": [
             {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
             },
             {
-              "internalType": "uint8",
-              "name": "v",
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
               "type": "uint8"
             },
             {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
+              "internalType": "uint128",
+              "name": "takerTokenFilledAmount",
+              "type": "uint128"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "takerSignature",
-          "type": "tuple"
+          "internalType": "struct LibNativeOrder.OrderInfo[]",
+          "name": "orderInfos",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "uint128[]",
+          "name": "actualFillableTakerTokenAmounts",
+          "type": "uint128[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "isSignatureValids",
+          "type": "bool[]"
         }
       ],
-      "name": "fillTakerSignedOtcOrder",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
@@ -4406,24 +3907,100 @@
         {
           "components": [
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
               "type": "address"
             },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
             {
               "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
+              "name": "erc20Token",
               "type": "address"
             },
             {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc721TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC721Order[]",
+          "name": "sellOrders",
+          "type": "tuple[]"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
             },
             {
               "internalType": "address",
@@ -4436,19 +4013,78 @@
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "txOrigin",
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "expiryAndNonce",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc721TokenId",
               "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct LibNFTOrder.ERC721Order[]",
+          "name": "buyOrders",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -4473,9 +4109,9 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "makerSignature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "sellOrderSignatures",
+          "type": "tuple[]"
         },
         {
           "components": [
@@ -4500,13 +4136,24 @@
               "type": "bytes32"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "takerSignature",
-          "type": "tuple"
+          "internalType": "struct LibSignature.Signature[]",
+          "name": "buyOrderSignatures",
+          "type": "tuple[]"
+        }
+      ],
+      "name": "batchMatchERC721Orders",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "profits",
+          "type": "uint256[]"
+        },
+        {
+          "internalType": "bool[]",
+          "name": "successes",
+          "type": "bool[]"
         }
       ],
-      "name": "fillTakerSignedOtcOrderForEth",
-      "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
     },
@@ -4605,19 +4252,50 @@
             }
           ],
           "internalType": "struct LibNFTOrder.ERC1155Order",
-          "name": "order",
+          "name": "sellOrder",
           "type": "tuple"
-        }
-      ],
-      "name": "getERC1155OrderHash",
-      "outputs": [
+        },
         {
-          "internalType": "bytes32",
-          "name": "orderHash",
-          "type": "bytes32"
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
+        },
+        {
+          "internalType": "uint128",
+          "name": "erc1155BuyAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "bytes",
+          "name": "callbackData",
+          "type": "bytes"
         }
       ],
-      "stateMutability": "view",
+      "name": "buyERC1155",
+      "outputs": [],
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -4682,13 +4360,13 @@
               "type": "tuple[]"
             },
             {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "erc1155TokenId",
+              "name": "erc721TokenId",
               "type": "uint256"
             },
             {
@@ -4705,61 +4383,278 @@
                 }
               ],
               "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
+              "name": "erc721TokenProperties",
               "type": "tuple[]"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC721Order",
+          "name": "sellOrder",
+          "type": "tuple"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
+        },
+        {
+          "internalType": "bytes",
+          "name": "callbackData",
+          "type": "bytes"
+        }
+      ],
+      "name": "buyERC721",
+      "outputs": [],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "orderNonce",
+          "type": "uint256"
+        }
+      ],
+      "name": "cancelERC1155Order",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "orderNonce",
+          "type": "uint256"
+        }
+      ],
+      "name": "cancelERC721Order",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
             },
             {
               "internalType": "uint128",
-              "name": "erc1155TokenAmount",
+              "name": "makerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFeeAmount",
               "type": "uint128"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "feeRecipient",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "internalType": "struct LibNativeOrder.LimitOrder",
           "name": "order",
           "type": "tuple"
         }
       ],
-      "name": "getERC1155OrderInfo",
-      "outputs": [
+      "name": "cancelLimitOrder",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "makerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "takerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minValidSalt",
+          "type": "uint256"
+        }
+      ],
+      "name": "cancelPairLimitOrders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "maker",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "makerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "takerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minValidSalt",
+          "type": "uint256"
+        }
+      ],
+      "name": "cancelPairLimitOrdersWithSigner",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "makerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "takerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minValidSalt",
+          "type": "uint256"
+        }
+      ],
+      "name": "cancelPairRfqOrders",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "maker",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "makerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "takerToken",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minValidSalt",
+          "type": "uint256"
+        }
+      ],
+      "name": "cancelPairRfqOrdersWithSigner",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
         {
           "components": [
             {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
             },
             {
-              "internalType": "enum LibNFTOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
             },
             {
               "internalType": "uint128",
-              "name": "orderAmount",
+              "name": "makerAmount",
               "type": "uint128"
             },
             {
               "internalType": "uint128",
-              "name": "remainingAmount",
+              "name": "takerAmount",
               "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNFTOrder.OrderInfo",
-          "name": "orderInfo",
-          "type": "tuple"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
             },
             {
               "internalType": "address",
@@ -4772,89 +4667,47 @@
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
+              "internalType": "address",
+              "name": "txOrigin",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
             },
             {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
-              "type": "address"
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
             },
             {
               "internalType": "uint256",
-              "name": "erc721TokenId",
+              "name": "salt",
               "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC721Order",
+          "internalType": "struct LibNativeOrder.RfqOrder",
           "name": "order",
           "type": "tuple"
         }
       ],
-      "name": "getERC721OrderHash",
+      "name": "cancelRfqOrder",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "createTransformWallet",
       "outputs": [
         {
-          "internalType": "bytes32",
-          "name": "orderHash",
-          "type": "bytes32"
+          "internalType": "contract IFlashWallet",
+          "name": "wallet",
+          "type": "address"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -4862,128 +4715,97 @@
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "address payable",
+              "name": "signer",
               "type": "address"
             },
             {
               "internalType": "address",
-              "name": "taker",
+              "name": "sender",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "expiry",
+              "name": "minGasPrice",
               "type": "uint256"
             },
             {
               "internalType": "uint256",
-              "name": "nonce",
+              "name": "maxGasPrice",
               "type": "uint256"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "expirationTimeSeconds",
+              "type": "uint256"
             },
             {
               "internalType": "uint256",
-              "name": "erc20TokenAmount",
+              "name": "salt",
               "type": "uint256"
             },
             {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "bytes",
+              "name": "callData",
+              "type": "bytes"
             },
             {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
+              "internalType": "uint256",
+              "name": "value",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "feeToken",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "erc721TokenId",
+              "name": "feeAmount",
               "type": "uint256"
-            },
+            }
+          ],
+          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
+          "name": "mtx",
+          "type": "tuple"
+        },
+        {
+          "components": [
             {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "order",
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
           "type": "tuple"
         }
       ],
-      "name": "getERC721OrderStatus",
-      "outputs": [
-        {
-          "internalType": "enum LibNFTOrder.OrderStatus",
-          "name": "status",
-          "type": "uint8"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "maker",
-          "type": "address"
-        },
-        {
-          "internalType": "uint248",
-          "name": "nonceRange",
-          "type": "uint248"
-        }
-      ],
-      "name": "getERC721OrderStatusBitVector",
+      "name": "executeMetaTransaction",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "bitVector",
-          "type": "uint256"
+          "internalType": "bytes",
+          "name": "returnResult",
+          "type": "bytes"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -5054,17 +4876,54 @@
           "internalType": "struct LibNativeOrder.LimitOrder",
           "name": "order",
           "type": "tuple"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
+        },
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
         }
       ],
-      "name": "getLimitOrderHash",
+      "name": "fillLimitOrder",
       "outputs": [
         {
-          "internalType": "bytes32",
-          "name": "orderHash",
-          "type": "bytes32"
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -5091,11 +4950,6 @@
               "name": "takerAmount",
               "type": "uint128"
             },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
-            },
             {
               "internalType": "address",
               "name": "maker",
@@ -5108,12 +4962,7 @@
             },
             {
               "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "feeRecipient",
+              "name": "txOrigin",
               "type": "address"
             },
             {
@@ -5132,37 +4981,52 @@
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.LimitOrder",
+          "internalType": "struct LibNativeOrder.RfqOrder",
           "name": "order",
           "type": "tuple"
-        }
-      ],
-      "name": "getLimitOrderInfo",
-      "outputs": [
+        },
         {
           "components": [
             {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
             },
             {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
+              "internalType": "uint8",
+              "name": "v",
               "type": "uint8"
             },
             {
-              "internalType": "uint128",
-              "name": "takerTokenFilledAmount",
-              "type": "uint128"
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
             }
           ],
-          "internalType": "struct LibNativeOrder.OrderInfo",
-          "name": "orderInfo",
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
           "type": "tuple"
+        },
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
         }
       ],
-      "stateMutability": "view",
+      "name": "fillOrKillRfqOrder",
+      "outputs": [
+        {
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
+        }
+      ],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -5189,11 +5053,6 @@
               "name": "takerAmount",
               "type": "uint128"
             },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFeeAmount",
-              "type": "uint128"
-            },
             {
               "internalType": "address",
               "name": "maker",
@@ -5206,31 +5065,114 @@
             },
             {
               "internalType": "address",
-              "name": "sender",
+              "name": "txOrigin",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "feeRecipient",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "expiryAndNonce",
+              "type": "uint256"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OtcOrder",
+          "name": "order",
+          "type": "tuple"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
             },
             {
               "internalType": "bytes32",
-              "name": "pool",
+              "name": "r",
               "type": "bytes32"
             },
             {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "makerSignature",
+          "type": "tuple"
+        },
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
+        }
+      ],
+      "name": "fillOtcOrder",
+      "outputs": [
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "txOrigin",
+              "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "salt",
+              "name": "expiryAndNonce",
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.LimitOrder",
+          "internalType": "struct LibNativeOrder.OtcOrder",
           "name": "order",
           "type": "tuple"
         },
@@ -5258,46 +5200,29 @@
             }
           ],
           "internalType": "struct LibSignature.Signature",
-          "name": "signature",
+          "name": "makerSignature",
           "type": "tuple"
+        },
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
         }
       ],
-      "name": "getLimitOrderRelevantState",
+      "name": "fillOtcOrderForEth",
       "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerTokenFilledAmount",
-              "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.OrderInfo",
-          "name": "orderInfo",
-          "type": "tuple"
-        },
         {
           "internalType": "uint128",
-          "name": "actualFillableTakerTokenAmount",
+          "name": "takerTokenFilledAmount",
           "type": "uint128"
         },
         {
-          "internalType": "bool",
-          "name": "isSignatureValid",
-          "type": "bool"
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -5305,160 +5230,92 @@
         {
           "components": [
             {
-              "internalType": "address payable",
-              "name": "signer",
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "sender",
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "minGasPrice",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "maxGasPrice",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expirationTimeSeconds",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "bytes",
-              "name": "callData",
-              "type": "bytes"
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "value",
-              "type": "uint256"
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "feeToken",
+              "internalType": "address",
+              "name": "txOrigin",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "feeAmount",
+              "name": "expiryAndNonce",
               "type": "uint256"
             }
           ],
-          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
-          "name": "mtx",
+          "internalType": "struct LibNativeOrder.OtcOrder",
+          "name": "order",
           "type": "tuple"
-        }
-      ],
-      "name": "getMetaTransactionExecutedBlock",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "blockNumber",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
+        },
         {
           "components": [
             {
-              "internalType": "address payable",
-              "name": "signer",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "sender",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "minGasPrice",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "maxGasPrice",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expirationTimeSeconds",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
-            },
-            {
-              "internalType": "bytes",
-              "name": "callData",
-              "type": "bytes"
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
             },
             {
-              "internalType": "uint256",
-              "name": "value",
-              "type": "uint256"
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "feeToken",
-              "type": "address"
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
             },
             {
-              "internalType": "uint256",
-              "name": "feeAmount",
-              "type": "uint256"
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
             }
           ],
-          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
-          "name": "mtx",
+          "internalType": "struct LibSignature.Signature",
+          "name": "makerSignature",
           "type": "tuple"
         }
       ],
-      "name": "getMetaTransactionHash",
+      "name": "fillOtcOrderWithEth",
       "outputs": [
         {
-          "internalType": "bytes32",
-          "name": "mtxHash",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes32",
-          "name": "mtxHash",
-          "type": "bytes32"
-        }
-      ],
-      "name": "getMetaTransactionHashExecutedBlock",
-      "outputs": [
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
+        },
         {
-          "internalType": "uint256",
-          "name": "blockNumber",
-          "type": "uint256"
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "payable",
       "type": "function"
     },
     {
@@ -5500,26 +5357,73 @@
               "name": "txOrigin",
               "type": "address"
             },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
             {
               "internalType": "uint256",
-              "name": "expiryAndNonce",
+              "name": "salt",
               "type": "uint256"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrder",
+          "internalType": "struct LibNativeOrder.RfqOrder",
           "name": "order",
           "type": "tuple"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
+        },
+        {
+          "internalType": "uint128",
+          "name": "takerTokenFillAmount",
+          "type": "uint128"
         }
       ],
-      "name": "getOtcOrderHash",
+      "name": "fillRfqOrder",
       "outputs": [
         {
-          "internalType": "bytes32",
-          "name": "orderHash",
-          "type": "bytes32"
+          "internalType": "uint128",
+          "name": "takerTokenFilledAmount",
+          "type": "uint128"
+        },
+        {
+          "internalType": "uint128",
+          "name": "makerTokenFilledAmount",
+          "type": "uint128"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -5570,55 +5474,65 @@
           "internalType": "struct LibNativeOrder.OtcOrder",
           "name": "order",
           "type": "tuple"
-        }
-      ],
-      "name": "getOtcOrderInfo",
-      "outputs": [
+        },
         {
           "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
             {
               "internalType": "bytes32",
-              "name": "orderHash",
+              "name": "r",
               "type": "bytes32"
             },
             {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
             }
           ],
-          "internalType": "struct LibNativeOrder.OtcOrderInfo",
-          "name": "orderInfo",
+          "internalType": "struct LibSignature.Signature",
+          "name": "makerSignature",
           "type": "tuple"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getProtocolFeeMultiplier",
-      "outputs": [
-        {
-          "internalType": "uint32",
-          "name": "multiplier",
-          "type": "uint32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getQuoteSigner",
-      "outputs": [
+        },
         {
-          "internalType": "address",
-          "name": "signer",
-          "type": "address"
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "takerSignature",
+          "type": "tuple"
         }
       ],
-      "stateMutability": "view",
+      "name": "fillTakerSignedOtcOrder",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -5660,36 +5574,74 @@
               "name": "txOrigin",
               "type": "address"
             },
+            {
+              "internalType": "uint256",
+              "name": "expiryAndNonce",
+              "type": "uint256"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OtcOrder",
+          "name": "order",
+          "type": "tuple"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
             {
               "internalType": "bytes32",
-              "name": "pool",
+              "name": "r",
               "type": "bytes32"
             },
             {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "makerSignature",
+          "type": "tuple"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
             },
             {
-              "internalType": "uint256",
-              "name": "salt",
-              "type": "uint256"
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
             }
           ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
-          "name": "order",
+          "internalType": "struct LibSignature.Signature",
+          "name": "takerSignature",
           "type": "tuple"
         }
       ],
-      "name": "getRfqOrderHash",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "orderHash",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
+      "name": "fillTakerSignedOtcOrderForEth",
+      "outputs": [],
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
@@ -5697,86 +5649,108 @@
         {
           "components": [
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
+              "internalType": "address",
+              "name": "maker",
               "type": "address"
             },
             {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
             },
             {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
             },
             {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
             },
             {
-              "internalType": "address",
-              "name": "taker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
             },
             {
-              "internalType": "uint64",
-              "name": "expiry",
-              "type": "uint64"
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "salt",
+              "name": "erc1155TokenId",
               "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
-          "name": "order",
-          "type": "tuple"
-        }
-      ],
-      "name": "getRfqOrderInfo",
-      "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
             },
             {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
             },
             {
               "internalType": "uint128",
-              "name": "takerTokenFilledAmount",
+              "name": "erc1155TokenAmount",
               "type": "uint128"
             }
           ],
-          "internalType": "struct LibNativeOrder.OrderInfo",
-          "name": "orderInfo",
+          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "name": "order",
           "type": "tuple"
         }
       ],
+      "name": "getERC1155OrderHash",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "orderHash",
+          "type": "bytes32"
+        }
+      ],
       "stateMutability": "view",
       "type": "function"
     },
@@ -5785,24 +5759,9 @@
         {
           "components": [
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "makerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "takerToken",
-              "type": "address"
-            },
-            {
-              "internalType": "uint128",
-              "name": "makerAmount",
-              "type": "uint128"
-            },
-            {
-              "internalType": "uint128",
-              "name": "takerAmount",
-              "type": "uint128"
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
             },
             {
               "internalType": "address",
@@ -5815,208 +5774,113 @@
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "txOrigin",
-              "type": "address"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "pool",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "uint64",
+              "internalType": "uint256",
               "name": "expiry",
-              "type": "uint64"
+              "type": "uint256"
             },
             {
               "internalType": "uint256",
-              "name": "salt",
+              "name": "nonce",
               "type": "uint256"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.RfqOrder",
-          "name": "order",
-          "type": "tuple"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
             },
             {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
-        }
-      ],
-      "name": "getRfqOrderRelevantState",
-      "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "bytes32",
-              "name": "orderHash",
-              "type": "bytes32"
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
             },
             {
-              "internalType": "enum LibNativeOrder.OrderStatus",
-              "name": "status",
-              "type": "uint8"
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "uint128",
-              "name": "takerTokenFilledAmount",
-              "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNativeOrder.OrderInfo",
-          "name": "orderInfo",
-          "type": "tuple"
-        },
-        {
-          "internalType": "uint128",
-          "name": "actualFillableTakerTokenAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "bool",
-          "name": "isSignatureValid",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        },
-        {
-          "internalType": "uint256",
-          "name": "idx",
-          "type": "uint256"
-        }
-      ],
-      "name": "getRollbackEntryAtIndex",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "impl",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        }
-      ],
-      "name": "getRollbackLength",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "rollbackLength",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getTransformWallet",
-      "outputs": [
-        {
-          "internalType": "contract IFlashWallet",
-          "name": "wallet",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getTransformerDeployer",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "deployer",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "maker",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "signer",
-          "type": "address"
-        }
-      ],
-      "name": "isValidOrderSigner",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "isAllowed",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "txOrigin",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "nonceBucket",
-          "type": "uint64"
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc1155TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "uint128",
+              "name": "erc1155TokenAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "name": "order",
+          "type": "tuple"
         }
       ],
-      "name": "lastOtcTxOriginNonce",
+      "name": "getERC1155OrderInfo",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "lastNonce",
-          "type": "uint128"
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "enum LibNFTOrder.OrderStatus",
+              "name": "status",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint128",
+              "name": "orderAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "remainingAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.OrderInfo",
+          "name": "orderInfo",
+          "type": "tuple"
         }
       ],
       "stateMutability": "view",
@@ -6112,9 +5976,23 @@
             }
           ],
           "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "sellOrder",
+          "name": "order",
           "type": "tuple"
-        },
+        }
+      ],
+      "name": "getERC721OrderHash",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "orderHash",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
         {
           "components": [
             {
@@ -6203,465 +6081,380 @@
             }
           ],
           "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "buyOrder",
-          "type": "tuple"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "sellOrderSignature",
-          "type": "tuple"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "buyOrderSignature",
+          "name": "order",
           "type": "tuple"
         }
       ],
-      "name": "matchERC721Orders",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "profit",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "target",
-          "type": "address"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        },
-        {
-          "internalType": "address",
-          "name": "newOwner",
-          "type": "address"
-        }
-      ],
-      "name": "migrate",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "outputToken",
-          "type": "address"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
-              "name": "id",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint256",
-              "name": "sellAmount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "bytes",
-              "name": "data",
-              "type": "bytes"
-            }
-          ],
-          "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
-          "name": "calls",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        }
-      ],
-      "name": "multiplexBatchSellEthForToken",
+      "name": "getERC721OrderStatus",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "boughtAmount",
-          "type": "uint256"
+          "internalType": "enum LibNFTOrder.OrderStatus",
+          "name": "status",
+          "type": "uint8"
         }
       ],
-      "stateMutability": "payable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "contract IERC20TokenV06",
-          "name": "inputToken",
-          "type": "address"
-        },
-        {
-          "components": [
-            {
-              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
-              "name": "id",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint256",
-              "name": "sellAmount",
-              "type": "uint256"
-            },
-            {
-              "internalType": "bytes",
-              "name": "data",
-              "type": "bytes"
-            }
-          ],
-          "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
-          "name": "calls",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
+          "internalType": "address",
+          "name": "maker",
+          "type": "address"
         },
         {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
+          "internalType": "uint248",
+          "name": "nonceRange",
+          "type": "uint248"
         }
       ],
-      "name": "multiplexBatchSellTokenForEth",
+      "name": "getERC721OrderStatusBitVector",
       "outputs": [
         {
           "internalType": "uint256",
-          "name": "boughtAmount",
+          "name": "bitVector",
           "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "inputToken",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "outputToken",
-          "type": "address"
-        },
         {
           "components": [
             {
-              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
-              "name": "id",
-              "type": "uint8"
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "sellAmount",
-              "type": "uint256"
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
             },
             {
-              "internalType": "bytes",
-              "name": "data",
-              "type": "bytes"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFeeAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "feeRecipient",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
-          "name": "calls",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
+          "internalType": "struct LibNativeOrder.LimitOrder",
+          "name": "order",
+          "type": "tuple"
         }
       ],
-      "name": "multiplexBatchSellTokenForToken",
+      "name": "getLimitOrderHash",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "boughtAmount",
-          "type": "uint256"
+          "internalType": "bytes32",
+          "name": "orderHash",
+          "type": "bytes32"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
-        {
-          "internalType": "address[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
         {
           "components": [
             {
-              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
-              "name": "id",
-              "type": "uint8"
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
             },
             {
-              "internalType": "bytes",
-              "name": "data",
-              "type": "bytes"
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFeeAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "feeRecipient",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
-          "name": "calls",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
+          "internalType": "struct LibNativeOrder.LimitOrder",
+          "name": "order",
+          "type": "tuple"
         }
       ],
-      "name": "multiplexMultiHopSellEthForToken",
+      "name": "getLimitOrderInfo",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "boughtAmount",
-          "type": "uint256"
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFilledAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OrderInfo",
+          "name": "orderInfo",
+          "type": "tuple"
         }
       ],
-      "stateMutability": "payable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
-        {
-          "internalType": "address[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
         {
           "components": [
             {
-              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
-              "name": "id",
-              "type": "uint8"
+              "internalType": "address payable",
+              "name": "signer",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "minGasPrice",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "maxGasPrice",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expirationTimeSeconds",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             },
             {
               "internalType": "bytes",
-              "name": "data",
+              "name": "callData",
               "type": "bytes"
+            },
+            {
+              "internalType": "uint256",
+              "name": "value",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "feeToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "feeAmount",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
-          "name": "calls",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
+          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
+          "name": "mtx",
+          "type": "tuple"
         }
       ],
-      "name": "multiplexMultiHopSellTokenForEth",
+      "name": "getMetaTransactionExecutedBlock",
       "outputs": [
         {
           "internalType": "uint256",
-          "name": "boughtAmount",
+          "name": "blockNumber",
           "type": "uint256"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
-        {
-          "internalType": "address[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
         {
           "components": [
             {
-              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
-              "name": "id",
-              "type": "uint8"
+              "internalType": "address payable",
+              "name": "signer",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "sender",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "minGasPrice",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "maxGasPrice",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expirationTimeSeconds",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             },
             {
               "internalType": "bytes",
-              "name": "data",
+              "name": "callData",
               "type": "bytes"
+            },
+            {
+              "internalType": "uint256",
+              "name": "value",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "feeToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "feeAmount",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
-          "name": "calls",
-          "type": "tuple[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
+          "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
+          "name": "mtx",
+          "type": "tuple"
         }
       ],
-      "name": "multiplexMultiHopSellTokenForToken",
+      "name": "getMetaTransactionHash",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "boughtAmount",
-          "type": "uint256"
+          "internalType": "bytes32",
+          "name": "mtxHash",
+          "type": "bytes32"
         }
       ],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "address",
-          "name": "operator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "from",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "tokenId",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
+          "internalType": "bytes32",
+          "name": "mtxHash",
+          "type": "bytes32"
         }
       ],
-      "name": "onERC1155Received",
+      "name": "getMetaTransactionHashExecutedBlock",
       "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "success",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "operator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "from",
-          "type": "address"
-        },
         {
           "internalType": "uint256",
-          "name": "tokenId",
+          "name": "blockNumber",
           "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "onERC721Received",
-      "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "success",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "owner",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "ownerAddress",
-          "type": "address"
         }
       ],
       "stateMutability": "view",
@@ -6671,104 +6464,61 @@
       "inputs": [
         {
           "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
             {
               "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
+              "name": "makerToken",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc1155TokenId",
-              "type": "uint256"
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
             },
             {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
-              "type": "tuple[]"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
               "internalType": "uint128",
-              "name": "erc1155TokenAmount",
+              "name": "takerAmount",
               "type": "uint128"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "txOrigin",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiryAndNonce",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "internalType": "struct LibNativeOrder.OtcOrder",
           "name": "order",
           "type": "tuple"
         }
       ],
-      "name": "preSignERC1155Order",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "name": "getOtcOrderHash",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "orderHash",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
       "type": "function"
     },
     {
@@ -6776,152 +6526,169 @@
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "taker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
+              "internalType": "address",
+              "name": "maker",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
             },
             {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
+              "internalType": "address",
+              "name": "txOrigin",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "erc721TokenId",
+              "name": "expiryAndNonce",
               "type": "uint256"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OtcOrder",
+          "name": "order",
+          "type": "tuple"
+        }
+      ],
+      "name": "getOtcOrderInfo",
+      "outputs": [
+        {
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
             },
             {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
+              "type": "uint8"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "order",
+          "internalType": "struct LibNativeOrder.OtcOrderInfo",
+          "name": "orderInfo",
           "type": "tuple"
         }
       ],
-      "name": "preSignERC721Order",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "signer",
-          "type": "address"
-        },
+      "inputs": [],
+      "name": "getProtocolFeeMultiplier",
+      "outputs": [
         {
-          "internalType": "bool",
-          "name": "allowed",
-          "type": "bool"
+          "internalType": "uint32",
+          "name": "multiplier",
+          "type": "uint32"
         }
       ],
-      "name": "registerAllowedOrderSigner",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address[]",
-          "name": "origins",
-          "type": "address[]"
-        },
+      "inputs": [],
+      "name": "getQuoteSigner",
+      "outputs": [
         {
-          "internalType": "bool",
-          "name": "allowed",
-          "type": "bool"
+          "internalType": "address",
+          "name": "signer",
+          "type": "address"
         }
       ],
-      "name": "registerAllowedRfqOrigins",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "bytes4",
-          "name": "selector",
-          "type": "bytes4"
-        },
+          "components": [
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
+              "type": "address"
+            },
+            {
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "txOrigin",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
+            },
+            {
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.RfqOrder",
+          "name": "order",
+          "type": "tuple"
+        }
+      ],
+      "name": "getRfqOrderHash",
+      "outputs": [
         {
-          "internalType": "address",
-          "name": "targetImpl",
-          "type": "address"
+          "internalType": "bytes32",
+          "name": "orderHash",
+          "type": "bytes32"
         }
       ],
-      "name": "rollback",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
@@ -6929,150 +6696,87 @@
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "taker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
+              "internalType": "address",
+              "name": "maker",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
             },
             {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
+              "internalType": "address",
+              "name": "txOrigin",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc1155TokenId",
-              "type": "uint256"
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
             },
             {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
-              "type": "tuple[]"
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
             },
             {
-              "internalType": "uint128",
-              "name": "erc1155TokenAmount",
-              "type": "uint128"
+              "internalType": "uint256",
+              "name": "salt",
+              "type": "uint256"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC1155Order",
-          "name": "buyOrder",
+          "internalType": "struct LibNativeOrder.RfqOrder",
+          "name": "order",
           "type": "tuple"
-        },
+        }
+      ],
+      "name": "getRfqOrderInfo",
+      "outputs": [
         {
           "components": [
             {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
             },
             {
-              "internalType": "uint8",
-              "name": "v",
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
               "type": "uint8"
             },
             {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
+              "internalType": "uint128",
+              "name": "takerTokenFilledAmount",
+              "type": "uint128"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
+          "internalType": "struct LibNativeOrder.OrderInfo",
+          "name": "orderInfo",
           "type": "tuple"
-        },
-        {
-          "internalType": "uint256",
-          "name": "erc1155TokenId",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint128",
-          "name": "erc1155SellAmount",
-          "type": "uint128"
-        },
-        {
-          "internalType": "bool",
-          "name": "unwrapNativeToken",
-          "type": "bool"
-        },
-        {
-          "internalType": "bytes",
-          "name": "callbackData",
-          "type": "bytes"
         }
       ],
-      "name": "sellERC1155",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
@@ -7080,92 +6784,58 @@
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
+              "internalType": "contract IERC20TokenV06",
+              "name": "makerToken",
+              "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "maker",
+              "internalType": "contract IERC20TokenV06",
+              "name": "takerToken",
               "type": "address"
             },
             {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
+              "internalType": "uint128",
+              "name": "makerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
+              "internalType": "uint128",
+              "name": "takerAmount",
+              "type": "uint128"
             },
             {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
+              "internalType": "address",
+              "name": "taker",
               "type": "address"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
+              "internalType": "address",
+              "name": "txOrigin",
+              "type": "address"
             },
             {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
+              "internalType": "bytes32",
+              "name": "pool",
+              "type": "bytes32"
             },
             {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
-              "type": "address"
+              "internalType": "uint64",
+              "name": "expiry",
+              "type": "uint64"
             },
             {
               "internalType": "uint256",
-              "name": "erc721TokenId",
+              "name": "salt",
               "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "buyOrder",
+          "internalType": "struct LibNativeOrder.RfqOrder",
+          "name": "order",
           "type": "tuple"
         },
         {
@@ -7194,516 +6864,160 @@
           "internalType": "struct LibSignature.Signature",
           "name": "signature",
           "type": "tuple"
-        },
-        {
-          "internalType": "uint256",
-          "name": "erc721TokenId",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bool",
-          "name": "unwrapNativeToken",
-          "type": "bool"
-        },
-        {
-          "internalType": "bytes",
-          "name": "callbackData",
-          "type": "bytes"
-        }
-      ],
-      "name": "sellERC721",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes",
-          "name": "encodedPath",
-          "type": "bytes"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        }
-      ],
-      "name": "sellEthForTokenToUniswapV3",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "buyAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "inputToken",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "outputToken",
-          "type": "address"
-        },
-        {
-          "internalType": "contract ILiquidityProvider",
-          "name": "provider",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "auxiliaryData",
-          "type": "bytes"
-        }
-      ],
-      "name": "sellToLiquidityProvider",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "boughtAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "enum IPancakeSwapFeature.ProtocolFork",
-          "name": "fork",
-          "type": "uint8"
-        }
-      ],
-      "name": "sellToPancakeSwap",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "buyAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06[]",
-          "name": "tokens",
-          "type": "address[]"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bool",
-          "name": "isSushi",
-          "type": "bool"
-        }
-      ],
-      "name": "sellToUniswap",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "buyAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "payable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes",
-          "name": "encodedPath",
-          "type": "bytes"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address payable",
-          "name": "recipient",
-          "type": "address"
-        }
-      ],
-      "name": "sellTokenForEthToUniswapV3",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "buyAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes",
-          "name": "encodedPath",
-          "type": "bytes"
-        },
-        {
-          "internalType": "uint256",
-          "name": "sellAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minBuyAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
         }
       ],
-      "name": "sellTokenForTokenToUniswapV3",
+      "name": "getRfqOrderRelevantState",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "buyAmount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
+          "components": [
+            {
+              "internalType": "bytes32",
+              "name": "orderHash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "enum LibNativeOrder.OrderStatus",
+              "name": "status",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint128",
+              "name": "takerTokenFilledAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNativeOrder.OrderInfo",
+          "name": "orderInfo",
+          "type": "tuple"
+        },
         {
-          "internalType": "address",
-          "name": "quoteSigner",
-          "type": "address"
-        }
-      ],
-      "name": "setQuoteSigner",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
+          "internalType": "uint128",
+          "name": "actualFillableTakerTokenAmount",
+          "type": "uint128"
+        },
         {
-          "internalType": "address",
-          "name": "transformerDeployer",
-          "type": "address"
+          "internalType": "bool",
+          "name": "isSignatureValid",
+          "type": "bool"
         }
       ],
-      "name": "setTransformerDeployer",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
           "internalType": "bytes4",
-          "name": "interfaceId",
+          "name": "selector",
           "type": "bytes4"
-        }
-      ],
-      "name": "supportInterface",
-      "outputs": [
+        },
         {
-          "internalType": "bool",
-          "name": "isSupported",
-          "type": "bool"
+          "internalType": "uint256",
+          "name": "idx",
+          "type": "uint256"
         }
       ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
-    {
-      "inputs": [
+      "name": "getRollbackEntryAtIndex",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "newOwner",
+          "name": "impl",
           "type": "address"
         }
       ],
-      "name": "transferOwnership",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "internalType": "bytes32[]",
-          "name": "poolIds",
-          "type": "bytes32[]"
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
         }
       ],
-      "name": "transferProtocolFeesForPools",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "erc20",
-          "type": "address"
-        },
+      "name": "getRollbackLength",
+      "outputs": [
         {
           "internalType": "uint256",
-          "name": "amountOut",
+          "name": "rollbackLength",
           "type": "uint256"
-        },
-        {
-          "internalType": "address payable",
-          "name": "recipientWallet",
-          "type": "address"
         }
       ],
-      "name": "transferTrappedTokensTo",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "inputToken",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC20TokenV06",
-          "name": "outputToken",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "inputTokenAmount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "minOutputTokenAmount",
-          "type": "uint256"
-        },
-        {
-          "components": [
-            {
-              "internalType": "uint32",
-              "name": "deploymentNonce",
-              "type": "uint32"
-            },
-            {
-              "internalType": "bytes",
-              "name": "data",
-              "type": "bytes"
-            }
-          ],
-          "internalType": "struct ITransformERC20Feature.Transformation[]",
-          "name": "transformations",
-          "type": "tuple[]"
-        }
-      ],
-      "name": "transformERC20",
+      "inputs": [],
+      "name": "getTransformWallet",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "outputTokenAmount",
-          "type": "uint256"
+          "internalType": "contract IFlashWallet",
+          "name": "wallet",
+          "type": "address"
         }
       ],
-      "stateMutability": "payable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
-        {
-          "internalType": "int256",
-          "name": "amount0Delta",
-          "type": "int256"
-        },
-        {
-          "internalType": "int256",
-          "name": "amount1Delta",
-          "type": "int256"
-        },
+      "inputs": [],
+      "name": "getTransformerDeployer",
+      "outputs": [
         {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
+          "internalType": "address",
+          "name": "deployer",
+          "type": "address"
         }
       ],
-      "name": "uniswapV3SwapCallback",
-      "outputs": [],
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "inputs": [
         {
-          "components": [
-            {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
-              "type": "uint8"
-            },
-            {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
-            },
-            {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
-            },
-            {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "erc1155TokenId",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
-              "type": "tuple[]"
-            },
-            {
-              "internalType": "uint128",
-              "name": "erc1155TokenAmount",
-              "type": "uint128"
-            }
-          ],
-          "internalType": "struct LibNFTOrder.ERC1155Order",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "address",
+          "name": "maker",
+          "type": "address"
         },
         {
-          "internalType": "uint256",
-          "name": "erc1155TokenId",
-          "type": "uint256"
+          "internalType": "address",
+          "name": "signer",
+          "type": "address"
+        }
+      ],
+      "name": "isValidOrderSigner",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "isAllowed",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "txOrigin",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "nonceBucket",
+          "type": "uint64"
+        }
+      ],
+      "name": "lastOtcTxOriginNonce",
+      "outputs": [
+        {
+          "internalType": "uint128",
+          "name": "lastNonce",
+          "type": "uint128"
         }
       ],
-      "name": "validateERC1155OrderProperties",
-      "outputs": [],
       "stateMutability": "view",
       "type": "function"
     },
@@ -7769,13 +7083,13 @@
               "type": "tuple[]"
             },
             {
-              "internalType": "contract IERC1155Token",
-              "name": "erc1155Token",
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
               "type": "address"
             },
             {
               "internalType": "uint256",
-              "name": "erc1155TokenId",
+              "name": "erc721TokenId",
               "type": "uint256"
             },
             {
@@ -7792,54 +7106,14 @@
                 }
               ],
               "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc1155TokenProperties",
+              "name": "erc721TokenProperties",
               "type": "tuple[]"
-            },
-            {
-              "internalType": "uint128",
-              "name": "erc1155TokenAmount",
-              "type": "uint128"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC1155Order",
-          "name": "order",
+          "internalType": "struct LibNFTOrder.ERC721Order",
+          "name": "sellOrder",
           "type": "tuple"
         },
-        {
-          "components": [
-            {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
-              "type": "uint8"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
-            },
-            {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
-            }
-          ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
-        }
-      ],
-      "name": "validateERC1155OrderSignature",
-      "outputs": [],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
         {
           "components": [
             {
@@ -7928,1129 +7202,1857 @@
             }
           ],
           "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "order",
+          "name": "buyOrder",
           "type": "tuple"
         },
-        {
-          "internalType": "uint256",
-          "name": "erc721TokenId",
-          "type": "uint256"
-        }
-      ],
-      "name": "validateERC721OrderProperties",
-      "outputs": [],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
         {
           "components": [
             {
-              "internalType": "enum LibNFTOrder.TradeDirection",
-              "name": "direction",
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
               "type": "uint8"
             },
             {
-              "internalType": "address",
-              "name": "maker",
-              "type": "address"
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
             },
             {
-              "internalType": "address",
-              "name": "taker",
-              "type": "address"
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
             },
             {
-              "internalType": "uint256",
-              "name": "expiry",
-              "type": "uint256"
-            },
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "sellOrderSignature",
+          "type": "tuple"
+        },
+        {
+          "components": [
             {
-              "internalType": "uint256",
-              "name": "nonce",
-              "type": "uint256"
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
             },
             {
-              "internalType": "contract IERC20TokenV06",
-              "name": "erc20Token",
-              "type": "address"
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
             },
             {
-              "internalType": "uint256",
-              "name": "erc20TokenAmount",
-              "type": "uint256"
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
             },
             {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "recipient",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint256",
-                  "name": "amount",
-                  "type": "uint256"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "feeData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Fee[]",
-              "name": "fees",
-              "type": "tuple[]"
-            },
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "buyOrderSignature",
+          "type": "tuple"
+        }
+      ],
+      "name": "matchERC721Orders",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "profit",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "target",
+          "type": "address"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        },
+        {
+          "internalType": "address",
+          "name": "newOwner",
+          "type": "address"
+        }
+      ],
+      "name": "migrate",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "outputToken",
+          "type": "address"
+        },
+        {
+          "components": [
             {
-              "internalType": "contract IERC721Token",
-              "name": "erc721Token",
-              "type": "address"
+              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
+              "name": "id",
+              "type": "uint8"
             },
             {
               "internalType": "uint256",
-              "name": "erc721TokenId",
-              "type": "uint256"
-            },
-            {
-              "components": [
-                {
-                  "internalType": "contract IPropertyValidator",
-                  "name": "propertyValidator",
-                  "type": "address"
-                },
-                {
-                  "internalType": "bytes",
-                  "name": "propertyData",
-                  "type": "bytes"
-                }
-              ],
-              "internalType": "struct LibNFTOrder.Property[]",
-              "name": "erc721TokenProperties",
-              "type": "tuple[]"
+              "name": "sellAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
             }
           ],
-          "internalType": "struct LibNFTOrder.ERC721Order",
-          "name": "order",
-          "type": "tuple"
+          "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
+          "name": "calls",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
+        }
+      ],
+      "name": "multiplexBatchSellEthForToken",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "inputToken",
+          "type": "address"
         },
         {
           "components": [
             {
-              "internalType": "enum LibSignature.SignatureType",
-              "name": "signatureType",
-              "type": "uint8"
-            },
-            {
-              "internalType": "uint8",
-              "name": "v",
+              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
+              "name": "id",
               "type": "uint8"
             },
             {
-              "internalType": "bytes32",
-              "name": "r",
-              "type": "bytes32"
+              "internalType": "uint256",
+              "name": "sellAmount",
+              "type": "uint256"
             },
             {
-              "internalType": "bytes32",
-              "name": "s",
-              "type": "bytes32"
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
             }
           ],
-          "internalType": "struct LibSignature.Signature",
-          "name": "signature",
-          "type": "tuple"
-        }
-      ],
-      "name": "validateERC721OrderSignature",
-      "outputs": [],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "devdoc": {
-    "details": "Interface for a fully featured Exchange Proxy.",
-    "kind": "dev",
-    "methods": {
-      "_fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,address)": {
-        "details": "Fill a limit order. Internal variant. ETH protocol fees can be      attached to this call. Any unspent ETH will be refunded to      `msg.sender` (not `sender`).",
-        "params": {
-          "order": "The limit order.",
-          "sender": "The order sender.",
-          "signature": "The order signature.",
-          "taker": "The order taker.",
-          "takerTokenFillAmount": "Maximum taker token to fill this order with."
-        },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much maker token was filled."
-        }
-      },
-      "_fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)": {
-        "details": "Fill an OTC order for up to `takerTokenFillAmount` taker tokens.      Internal variant.",
-        "params": {
-          "makerSignature": "The order signature from the maker.",
-          "order": "The OTC order.",
-          "recipient": "The recipient of the bought maker tokens.",
-          "taker": "The address to fill the order in the context of.",
-          "takerTokenFillAmount": "Maximum taker token amount to fill this        order with.",
-          "useSelfBalance": "Whether to use the Exchange Proxy's balance        of input tokens."
-        },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much taker token was filled."
-        }
-      },
-      "_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)": {
-        "details": "Fill an RFQ order. Internal variant.",
-        "params": {
-          "order": "The RFQ order.",
-          "recipient": "The recipient of the maker tokens.",
-          "signature": "The order signature.",
-          "taker": "The order taker.",
-          "takerTokenFillAmount": "Maximum taker token to fill this order with.",
-          "useSelfBalance": "Whether to use the ExchangeProxy's transient        balance of taker tokens to fill the order."
-        },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much maker token was filled."
-        }
-      },
-      "_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)": {
-        "details": "Sell a token for another token directly against uniswap v3.      Private variant, uses tokens held by `address(this)`.",
-        "params": {
-          "encodedPath": "Uniswap-encoded path.",
-          "minBuyAmount": "Minimum amount of the last token in the path to buy.",
-          "recipient": "The recipient of the bought tokens. Can be zero for sender.",
-          "sellAmount": "amount of the first token in the path to sell."
-        },
-        "returns": {
-          "buyAmount": "Amount of the last token in the path bought."
-        }
-      },
-      "_transformERC20((address,address,address,uint256,uint256,(uint32,bytes)[],bool,address))": {
-        "details": "Internal version of `transformERC20()`. Only callable from within.",
-        "params": {
-          "args": "A `TransformERC20Args` struct."
-        },
-        "returns": {
-          "outputTokenAmount": "The amount of `outputToken` received by the taker."
-        }
-      },
-      "batchBuyERC1155s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bytes[],bool)": {
-        "details": "Buys multiple ERC1155 assets by filling the      given orders.",
-        "params": {
-          "callbackData": "The data (if any) to pass to the taker        callback for each order. Refer to the `callbackData`        parameter to for `buyERC1155`.",
-          "erc1155TokenAmounts": "The amounts of the ERC1155 assets        to buy for each order.",
-          "revertIfIncomplete": "If true, reverts if this        function fails to fill any individual order.",
-          "sellOrders": "The ERC1155 sell orders.",
-          "signatures": "The order signatures."
-        },
-        "returns": {
-          "successes": "An array of booleans corresponding to whether         each order in `orders` was successfully filled."
-        }
-      },
-      "batchBuyERC721s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],bytes[],bool)": {
-        "details": "Buys multiple ERC721 assets by filling the      given orders.",
-        "params": {
-          "callbackData": "The data (if any) to pass to the taker        callback for each order. Refer to the `callbackData`        parameter to for `buyERC721`.",
-          "revertIfIncomplete": "If true, reverts if this        function fails to fill any individual order.",
-          "sellOrders": "The ERC721 sell orders.",
-          "signatures": "The order signatures."
-        },
-        "returns": {
-          "successes": "An array of booleans corresponding to whether         each order in `orders` was successfully filled."
-        }
-      },
-      "batchCancelERC1155Orders(uint256[])": {
-        "details": "Cancel multiple ERC1155 orders by their nonces. The caller      should be the maker of the orders. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
-        "params": {
-          "orderNonces": "The order nonces."
-        }
-      },
-      "batchCancelERC721Orders(uint256[])": {
-        "details": "Cancel multiple ERC721 orders by their nonces. The caller      should be the maker of the orders. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
-        "params": {
-          "orderNonces": "The order nonces."
-        }
-      },
-      "batchCancelLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[])": {
-        "details": "Cancel multiple limit orders. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
-        "params": {
-          "orders": "The limit orders."
-        }
-      },
-      "batchCancelPairLimitOrders(address[],address[],uint256[])": {
-        "details": "Cancel all limit orders for a given maker and pairs with salts less      than the values provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "makerTokens": "The maker tokens.",
-          "minValidSalts": "The new minimum valid salts.",
-          "takerTokens": "The taker tokens."
-        }
-      },
-      "batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])": {
-        "details": "Cancel all limit orders for a given maker and pairs with salts less      than the values provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "maker": "The maker for which to cancel.",
-          "makerTokens": "The maker tokens.",
-          "minValidSalts": "The new minimum valid salts.",
-          "takerTokens": "The taker tokens."
-        }
-      },
-      "batchCancelPairRfqOrders(address[],address[],uint256[])": {
-        "details": "Cancel all RFQ orders for a given maker and pairs with salts less      than the values provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "makerTokens": "The maker tokens.",
-          "minValidSalts": "The new minimum valid salts.",
-          "takerTokens": "The taker tokens."
-        }
-      },
-      "batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])": {
-        "details": "Cancel all RFQ orders for a given maker and pairs with salts less      than the values provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "maker": "The maker for which to cancel.",
-          "makerTokens": "The maker tokens.",
-          "minValidSalts": "The new minimum valid salts.",
-          "takerTokens": "The taker tokens."
-        }
-      },
-      "batchCancelRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[])": {
-        "details": "Cancel multiple RFQ orders. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
-        "params": {
-          "orders": "The RFQ orders."
-        }
-      },
-      "batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,bytes32)[])": {
-        "details": "Execute multiple meta-transactions.",
-        "params": {
-          "mtxs": "The meta-transactions.",
-          "signatures": "The signature by each respective `mtx.signer`."
-        },
-        "returns": {
-          "returnResults": "The ABI-encoded results of the underlying calls."
-        }
-      },
-      "batchFillLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)": {
-        "details": "Fills multiple limit orders.",
-        "params": {
-          "orders": "Array of limit orders.",
-          "revertIfIncomplete": "If true, reverts if this function fails to        fill the full fill amount for any individual order.",
-          "signatures": "Array of signatures corresponding to each order.",
-          "takerTokenFillAmounts": "Array of desired amounts to fill each order."
+          "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
+          "name": "calls",
+          "type": "tuple[]"
         },
-        "returns": {
-          "makerTokenFilledAmounts": "Array of amounts filled, in maker token.",
-          "takerTokenFilledAmounts": "Array of amounts filled, in taker token."
-        }
-      },
-      "batchFillRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)": {
-        "details": "Fills multiple RFQ orders.",
-        "params": {
-          "orders": "Array of RFQ orders.",
-          "revertIfIncomplete": "If true, reverts if this function fails to        fill the full fill amount for any individual order.",
-          "signatures": "Array of signatures corresponding to each order.",
-          "takerTokenFillAmounts": "Array of desired amounts to fill each order."
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "makerTokenFilledAmounts": "Array of amounts filled, in maker token.",
-          "takerTokenFilledAmounts": "Array of amounts filled, in taker token."
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         }
-      },
-      "batchFillTakerSignedOtcOrders((address,address,uint128,uint128,address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[],bool[])": {
-        "details": "Fills multiple taker-signed OTC orders.",
-        "params": {
-          "makerSignatures": "Array of maker signatures for each order.",
-          "orders": "Array of OTC orders.",
-          "takerSignatures": "Array of taker signatures for each order.",
-          "unwrapWeth": "Array of booleans representing whether or not         to unwrap bought WETH into ETH for each order. Should be set         to false if the maker token is not WETH."
-        },
-        "returns": {
-          "successes": "Array of booleans representing whether or not         each order in `orders` was filled successfully."
+      ],
+      "name": "multiplexBatchSellTokenForEth",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
         }
-      },
-      "batchGetLimitOrderRelevantStates((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])": {
-        "details": "Batch version of `getLimitOrderRelevantState()`, without reverting.      Orders that would normally cause `getLimitOrderRelevantState()`      to revert will have empty results.",
-        "params": {
-          "orders": "The limit orders.",
-          "signatures": "The order signatures."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "inputToken",
+          "type": "address"
         },
-        "returns": {
-          "actualFillableTakerTokenAmounts": "How much of each order is fillable         based on maker funds, in taker tokens.",
-          "isSignatureValids": "Whether each signature is valid for the order.",
-          "orderInfos": "Info about the orders."
-        }
-      },
-      "batchGetRfqOrderRelevantStates((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])": {
-        "details": "Batch version of `getRfqOrderRelevantState()`, without reverting.      Orders that would normally cause `getRfqOrderRelevantState()`      to revert will have empty results.",
-        "params": {
-          "orders": "The RFQ orders.",
-          "signatures": "The order signatures."
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "outputToken",
+          "type": "address"
         },
-        "returns": {
-          "actualFillableTakerTokenAmounts": "How much of each order is fillable         based on maker funds, in taker tokens.",
-          "isSignatureValids": "Whether each signature is valid for the order.",
-          "orderInfos": "Info about the orders."
-        }
-      },
-      "batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[])": {
-        "details": "Matches pairs of complementary orders that have      non-negative spreads. Each order is filled at      their respective price, and the matcher receives      a profit denominated in the ERC20 token.",
-        "params": {
-          "buyOrderSignatures": "Signatures for the buy orders.",
-          "buyOrders": "Orders buying ERC721 assets.",
-          "sellOrderSignatures": "Signatures for the sell orders.",
-          "sellOrders": "Orders selling ERC721 assets."
+        {
+          "components": [
+            {
+              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
+              "name": "id",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint256",
+              "name": "sellAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
+          "name": "calls",
+          "type": "tuple[]"
         },
-        "returns": {
-          "profits": "The amount of profit earned by the caller         of this function for each pair of matched orders         (denominated in the ERC20 token of the order pair).",
-          "successes": "An array of booleans corresponding to         whether each pair of orders was successfully matched."
-        }
-      },
-      "buyERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint128,bytes)": {
-        "details": "Buys an ERC1155 asset by filling the given order.",
-        "params": {
-          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC1155OrderCallback` on `msg.sender` after        the ERC1155 asset has been transferred to `msg.sender`        but before transferring the ERC20 tokens to the seller.        Native tokens acquired during the callback can be used        to fill the order.",
-          "erc1155BuyAmount": "The amount of the ERC1155 asset        to buy.",
-          "sellOrder": "The ERC1155 sell order.",
-          "signature": "The order signature."
-        }
-      },
-      "buyERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),bytes)": {
-        "details": "Buys an ERC721 asset by filling the given order.",
-        "params": {
-          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC721OrderCallback` on `msg.sender` after        the ERC721 asset has been transferred to `msg.sender`        but before transferring the ERC20 tokens to the seller.        Native tokens acquired during the callback can be used        to fill the order.",
-          "sellOrder": "The ERC721 sell order.",
-          "signature": "The order signature."
-        }
-      },
-      "cancelERC1155Order(uint256)": {
-        "details": "Cancel a single ERC1155 order by its nonce. The caller      should be the maker of the order. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
-        "params": {
-          "orderNonce": "The order nonce."
-        }
-      },
-      "cancelERC721Order(uint256)": {
-        "details": "Cancel a single ERC721 order by its nonce. The caller      should be the maker of the order. Silently succeeds if      an order with the same nonce has already been filled or      cancelled.",
-        "params": {
-          "orderNonce": "The order nonce."
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         }
-      },
-      "cancelLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))": {
-        "details": "Cancel a single limit order. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
-        "params": {
-          "order": "The limit order."
+      ],
+      "name": "multiplexBatchSellTokenForToken",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
         }
-      },
-      "cancelPairLimitOrders(address,address,uint256)": {
-        "details": "Cancel all limit orders for a given maker and pair with a salt less      than the value provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "makerToken": "The maker token.",
-          "minValidSalt": "The new minimum valid salt.",
-          "takerToken": "The taker token."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
+              "name": "id",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
+          "name": "calls",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         }
-      },
-      "cancelPairLimitOrdersWithSigner(address,address,address,uint256)": {
-        "details": "Cancel all limit orders for a given maker and pair with a salt less      than the value provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "maker": "The maker for which to cancel.",
-          "makerToken": "The maker token.",
-          "minValidSalt": "The new minimum valid salt.",
-          "takerToken": "The taker token."
+      ],
+      "name": "multiplexMultiHopSellEthForToken",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
         }
-      },
-      "cancelPairRfqOrders(address,address,uint256)": {
-        "details": "Cancel all RFQ orders for a given maker and pair with a salt less      than the value provided. The caller must be the maker. Subsequent      calls to this function with the same caller and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "makerToken": "The maker token.",
-          "minValidSalt": "The new minimum valid salt.",
-          "takerToken": "The taker token."
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
+              "name": "id",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
+          "name": "calls",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         }
-      },
-      "cancelPairRfqOrdersWithSigner(address,address,address,uint256)": {
-        "details": "Cancel all RFQ orders for a given maker and pair with a salt less      than the value provided. The caller must be a signer registered to the maker.      Subsequent calls to this function with the same maker and pair require the      new salt to be >= the old salt.",
-        "params": {
-          "maker": "The maker for which to cancel.",
-          "makerToken": "The maker token.",
-          "minValidSalt": "The new minimum valid salt.",
-          "takerToken": "The taker token."
+      ],
+      "name": "multiplexMultiHopSellTokenForEth",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
         }
-      },
-      "cancelRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))": {
-        "details": "Cancel a single RFQ order. The caller must be the maker or a valid order signer.      Silently succeeds if the order has already been cancelled.",
-        "params": {
-          "order": "The RFQ order."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "tokens",
+          "type": "address[]"
+        },
+        {
+          "components": [
+            {
+              "internalType": "enum IMultiplexFeature.MultiplexSubcall",
+              "name": "id",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
+          "name": "calls",
+          "type": "tuple[]"
+        },
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         }
-      },
-      "createTransformWallet()": {
-        "details": "Deploy a new flash wallet instance and replace the current one with it.      Useful if we somehow break the current wallet instance.       Only callable by the owner.",
-        "returns": {
-          "wallet": "The new wallet instance."
+      ],
+      "name": "multiplexMultiHopSellTokenForToken",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
         }
-      },
-      "executeMetaTransaction((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Execute a single meta-transaction.",
-        "params": {
-          "mtx": "The meta-transaction.",
-          "signature": "The signature by `mtx.signer`."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "operator",
+          "type": "address"
         },
-        "returns": {
-          "returnResult": "The ABI-encoded result of the underlying call."
+        {
+          "internalType": "address",
+          "name": "from",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "tokenId",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
         }
-      },
-      "extend(bytes4,address)": {
-        "details": "Register or replace a function.",
-        "params": {
-          "impl": "The implementation contract for the function.",
-          "selector": "The function selector."
+      ],
+      "name": "onERC1155Received",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "success",
+          "type": "bytes4"
         }
-      },
-      "fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
-        "details": "Fill a limit order. The taker and sender will be the caller.",
-        "params": {
-          "order": "The limit order. ETH protocol fees can be      attached to this call. Any unspent ETH will be refunded to      the caller.",
-          "signature": "The order signature.",
-          "takerTokenFillAmount": "Maximum taker token amount to fill this order with."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "operator",
+          "type": "address"
         },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much maker token was filled."
-        }
-      },
-      "fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
-        "details": "Fill an RFQ order for exactly `takerTokenFillAmount` taker tokens.      The taker will be the caller. ETH protocol fees can be      attached to this call. Any unspent ETH will be refunded to      the caller.",
-        "params": {
-          "order": "The limit order.",
-          "signature": "The order signature.",
-          "takerTokenFillAmount": "How much taker token to fill this order with."
+        {
+          "internalType": "address",
+          "name": "from",
+          "type": "address"
         },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled."
-        }
-      },
-      "fillOrKillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
-        "details": "Fill an RFQ order for exactly `takerTokenFillAmount` taker tokens.      The taker will be the caller.",
-        "params": {
-          "order": "The RFQ order.",
-          "signature": "The order signature.",
-          "takerTokenFillAmount": "How much taker token to fill this order with."
+        {
+          "internalType": "uint256",
+          "name": "tokenId",
+          "type": "uint256"
         },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled."
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
         }
-      },
-      "fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
-        "details": "Fill an OTC order for up to `takerTokenFillAmount` taker tokens.",
-        "params": {
-          "makerSignature": "The order signature from the maker.",
-          "order": "The OTC order.",
-          "takerTokenFillAmount": "Maximum taker token amount to fill this        order with."
-        },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much taker token was filled."
+      ],
+      "name": "onERC721Received",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "success",
+          "type": "bytes4"
         }
-      },
-      "fillOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
-        "details": "Fill an OTC order for up to `takerTokenFillAmount` taker tokens.      Unwraps bought WETH into ETH before sending it to       the taker.",
-        "params": {
-          "makerSignature": "The order signature from the maker.",
-          "order": "The OTC order.",
-          "takerTokenFillAmount": "Maximum taker token amount to fill this        order with."
-        },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much taker token was filled."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc1155TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "uint128",
+              "name": "erc1155TokenAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "name": "order",
+          "type": "tuple"
         }
-      },
-      "fillOtcOrderWithEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Fill an OTC order whose taker token is WETH for up      to `msg.value`.",
-        "params": {
-          "makerSignature": "The order signature from the maker.",
-          "order": "The OTC order."
-        },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much taker token was filled."
+      ],
+      "name": "preSignERC1155Order",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc721TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC721Order",
+          "name": "order",
+          "type": "tuple"
         }
-      },
-      "fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)": {
-        "details": "Fill an RFQ order for up to `takerTokenFillAmount` taker tokens.      The taker will be the caller.",
-        "params": {
-          "order": "The RFQ order.",
-          "signature": "The order signature.",
-          "takerTokenFillAmount": "Maximum taker token amount to fill this order with."
+      ],
+      "name": "preSignERC721Order",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "signer",
+          "type": "address"
         },
-        "returns": {
-          "makerTokenFilledAmount": "How much maker token was filled.",
-          "takerTokenFilledAmount": "How much maker token was filled."
-        }
-      },
-      "fillTakerSignedOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Fully fill an OTC order. \"Meta-transaction\" variant,      requires order to be signed by both maker and taker.",
-        "params": {
-          "makerSignature": "The order signature from the maker.",
-          "order": "The OTC order.",
-          "takerSignature": "The order signature from the taker."
-        }
-      },
-      "fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Fully fill an OTC order. \"Meta-transaction\" variant,      requires order to be signed by both maker and taker.      Unwraps bought WETH into ETH before sending it to       the taker.",
-        "params": {
-          "makerSignature": "The order signature from the maker.",
-          "order": "The OTC order.",
-          "takerSignature": "The order signature from the taker."
+        {
+          "internalType": "bool",
+          "name": "allowed",
+          "type": "bool"
         }
-      },
-      "getERC1155OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))": {
-        "details": "Get the EIP-712 hash of an ERC1155 order.",
-        "params": {
-          "order": "The ERC1155 order."
+      ],
+      "name": "registerAllowedOrderSigner",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address[]",
+          "name": "origins",
+          "type": "address[]"
         },
-        "returns": {
-          "orderHash": "The order hash."
+        {
+          "internalType": "bool",
+          "name": "allowed",
+          "type": "bool"
         }
-      },
-      "getERC1155OrderInfo((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))": {
-        "details": "Get the order info for an ERC1155 order.",
-        "params": {
-          "order": "The ERC1155 order."
+      ],
+      "name": "registerAllowedRfqOrigins",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "selector",
+          "type": "bytes4"
         },
-        "returns": {
-          "orderInfo": "Infor about the order."
+        {
+          "internalType": "address",
+          "name": "targetImpl",
+          "type": "address"
         }
-      },
-      "getERC721OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))": {
-        "details": "Get the EIP-712 hash of an ERC721 order.",
-        "params": {
-          "order": "The ERC721 order."
+      ],
+      "name": "rollback",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc1155TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "uint128",
+              "name": "erc1155TokenAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "name": "buyOrder",
+          "type": "tuple"
         },
-        "returns": {
-          "orderHash": "The order hash."
-        }
-      },
-      "getERC721OrderStatus((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))": {
-        "details": "Get the current status of an ERC721 order.",
-        "params": {
-          "order": "The ERC721 order."
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
         },
-        "returns": {
-          "status": "The status of the order."
-        }
-      },
-      "getERC721OrderStatusBitVector(address,uint248)": {
-        "details": "Get the order status bit vector for the given      maker address and nonce range.",
-        "params": {
-          "maker": "The maker of the order.",
-          "nonceRange": "Order status bit vectors are indexed        by maker address and the upper 248 bits of the        order nonce. We define `nonceRange` to be these        248 bits."
+        {
+          "internalType": "uint256",
+          "name": "erc1155TokenId",
+          "type": "uint256"
         },
-        "returns": {
-          "bitVector": "The order status bit vector for the         given maker and nonce range."
-        }
-      },
-      "getLimitOrderHash((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))": {
-        "details": "Get the canonical hash of a limit order.",
-        "params": {
-          "order": "The limit order."
+        {
+          "internalType": "uint128",
+          "name": "erc1155SellAmount",
+          "type": "uint128"
         },
-        "returns": {
-          "orderHash": "The order hash."
-        }
-      },
-      "getLimitOrderInfo((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))": {
-        "details": "Get the order info for a limit order.",
-        "params": {
-          "order": "The limit order."
+        {
+          "internalType": "bool",
+          "name": "unwrapNativeToken",
+          "type": "bool"
         },
-        "returns": {
-          "orderInfo": "Info about the order."
+        {
+          "internalType": "bytes",
+          "name": "callbackData",
+          "type": "bytes"
         }
-      },
-      "getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Get order info, fillable amount, and signature validity for a limit order.      Fillable amount is determined using balances and allowances of the maker.",
-        "params": {
-          "order": "The limit order.",
-          "signature": "The order signature."
+      ],
+      "name": "sellERC1155",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc721TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC721Order",
+          "name": "buyOrder",
+          "type": "tuple"
         },
-        "returns": {
-          "actualFillableTakerTokenAmount": "How much of the order is fillable         based on maker funds, in taker tokens.",
-          "isSignatureValid": "Whether the signature is valid.",
-          "orderInfo": "Info about the order."
-        }
-      },
-      "getMetaTransactionExecutedBlock((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))": {
-        "details": "Get the block at which a meta-transaction has been executed.",
-        "params": {
-          "mtx": "The meta-transaction."
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
         },
-        "returns": {
-          "blockNumber": "The block height when the meta-transactioin was executed."
-        }
-      },
-      "getMetaTransactionHash((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))": {
-        "details": "Get the EIP712 hash of a meta-transaction.",
-        "params": {
-          "mtx": "The meta-transaction."
+        {
+          "internalType": "uint256",
+          "name": "erc721TokenId",
+          "type": "uint256"
         },
-        "returns": {
-          "mtxHash": "The EIP712 hash of `mtx`."
-        }
-      },
-      "getMetaTransactionHashExecutedBlock(bytes32)": {
-        "details": "Get the block at which a meta-transaction hash has been executed.",
-        "params": {
-          "mtxHash": "The meta-transaction hash."
+        {
+          "internalType": "bool",
+          "name": "unwrapNativeToken",
+          "type": "bool"
         },
-        "returns": {
-          "blockNumber": "The block height when the meta-transactioin was executed."
+        {
+          "internalType": "bytes",
+          "name": "callbackData",
+          "type": "bytes"
         }
-      },
-      "getOtcOrderHash((address,address,uint128,uint128,address,address,address,uint256))": {
-        "details": "Get the canonical hash of an OTC order.",
-        "params": {
-          "order": "The OTC order."
+      ],
+      "name": "sellERC721",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "encodedPath",
+          "type": "bytes"
         },
-        "returns": {
-          "orderHash": "The order hash."
-        }
-      },
-      "getOtcOrderInfo((address,address,uint128,uint128,address,address,address,uint256))": {
-        "details": "Get the order info for an OTC order.",
-        "params": {
-          "order": "The OTC order."
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "orderInfo": "Info about the order."
-        }
-      },
-      "getProtocolFeeMultiplier()": {
-        "details": "Get the protocol fee multiplier. This should be multiplied by the      gas price to arrive at the required protocol fee to fill a native order.",
-        "returns": {
-          "multiplier": "The protocol fee multiplier."
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         }
-      },
-      "getQuoteSigner()": {
-        "details": "Return the optional signer for `transformERC20()` calldata.",
-        "returns": {
-          "signer": "The transform deployer address."
+      ],
+      "name": "sellEthForTokenToUniswapV3",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "buyAmount",
+          "type": "uint256"
         }
-      },
-      "getRfqOrderHash((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))": {
-        "details": "Get the canonical hash of an RFQ order.",
-        "params": {
-          "order": "The RFQ order."
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "inputToken",
+          "type": "address"
         },
-        "returns": {
-          "orderHash": "The order hash."
-        }
-      },
-      "getRfqOrderInfo((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))": {
-        "details": "Get the order info for an RFQ order.",
-        "params": {
-          "order": "The RFQ order."
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "outputToken",
+          "type": "address"
         },
-        "returns": {
-          "orderInfo": "Info about the order."
-        }
-      },
-      "getRfqOrderRelevantState((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Get order info, fillable amount, and signature validity for an RFQ order.      Fillable amount is determined using balances and allowances of the maker.",
-        "params": {
-          "order": "The RFQ order.",
-          "signature": "The order signature."
+        {
+          "internalType": "contract ILiquidityProvider",
+          "name": "provider",
+          "type": "address"
         },
-        "returns": {
-          "actualFillableTakerTokenAmount": "How much of the order is fillable         based on maker funds, in taker tokens.",
-          "isSignatureValid": "Whether the signature is valid.",
-          "orderInfo": "Info about the order."
-        }
-      },
-      "getRollbackEntryAtIndex(bytes4,uint256)": {
-        "details": "Retrieve an entry in the rollback history for a function.",
-        "params": {
-          "idx": "The index in the rollback history.",
-          "selector": "The function selector."
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         },
-        "returns": {
-          "impl": "An implementation address for the function at         index `idx`."
-        }
-      },
-      "getRollbackLength(bytes4)": {
-        "details": "Retrieve the length of the rollback history for a function.",
-        "params": {
-          "selector": "The function selector."
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "rollbackLength": "The number of items in the rollback history for         the function."
-        }
-      },
-      "getTransformWallet()": {
-        "details": "Return the current wallet instance that will serve as the execution      context for transformations.",
-        "returns": {
-          "wallet": "The wallet instance."
-        }
-      },
-      "getTransformerDeployer()": {
-        "details": "Return the allowed deployer for transformers.",
-        "returns": {
-          "deployer": "The transform deployer address."
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "auxiliaryData",
+          "type": "bytes"
         }
-      },
-      "isValidOrderSigner(address,address)": {
-        "details": "checks if a given address is registered to sign on behalf of a maker address",
-        "params": {
-          "maker": "The maker address encoded in an order (can be a contract)",
-          "signer": "The address that is providing a signature"
+      ],
+      "name": "sellToLiquidityProvider",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "boughtAmount",
+          "type": "uint256"
         }
-      },
-      "lastOtcTxOriginNonce(address,uint64)": {
-        "details": "Get the last nonce used for a particular      tx.origin address and nonce bucket.",
-        "params": {
-          "nonceBucket": "The nonce bucket index.",
-          "txOrigin": "The address."
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "tokens",
+          "type": "address[]"
         },
-        "returns": {
-          "lastNonce": "The last nonce value used."
-        }
-      },
-      "matchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Matches a pair of complementary orders that have      a non-negative spread. Each order is filled at      their respective price, and the matcher receives      a profit denominated in the ERC20 token.",
-        "params": {
-          "buyOrder": "Order buying an ERC721 asset.",
-          "buyOrderSignature": "Signature for the buy order.",
-          "sellOrder": "Order selling an ERC721 asset.",
-          "sellOrderSignature": "Signature for the sell order."
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "profit": "The amount of profit earned by the caller         of this function (denominated in the ERC20 token         of the matched orders)."
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "enum IPancakeSwapFeature.ProtocolFork",
+          "name": "fork",
+          "type": "uint8"
         }
-      },
-      "migrate(address,bytes,address)": {
-        "details": "Execute a migration function in the context of the ZeroEx contract.      The result of the function being called should be the magic bytes      0x2c64c5ef (`keccack('MIGRATE_SUCCESS')`). Only callable by the owner.      The owner will be temporarily set to `address(this)` inside the call.      Before returning, the owner will be set to `newOwner`.",
-        "params": {
-          "data": "The call data.",
-          "newOwner": "The address of the new owner.",
-          "target": "The migrator contract address."
+      ],
+      "name": "sellToPancakeSwap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "buyAmount",
+          "type": "uint256"
         }
-      },
-      "multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)": {
-        "details": "Sells attached ETH for `outputToken` using the provided      calls.",
-        "params": {
-          "calls": "The calls to use to sell the attached ETH.",
-          "minBuyAmount": "The minimum amount of `outputToken` that        must be bought for this function to not revert.",
-          "outputToken": "The token to buy."
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06[]",
+          "name": "tokens",
+          "type": "address[]"
         },
-        "returns": {
-          "boughtAmount": "The amount of `outputToken` bought."
-        }
-      },
-      "multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)": {
-        "details": "Sells `sellAmount` of the given `inputToken` for ETH      using the provided calls.",
-        "params": {
-          "calls": "The calls to use to sell the input tokens.",
-          "inputToken": "The token to sell.",
-          "minBuyAmount": "The minimum amount of ETH that        must be bought for this function to not revert.",
-          "sellAmount": "The amount of `inputToken` to sell."
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "boughtAmount": "The amount of ETH bought."
-        }
-      },
-      "multiplexBatchSellTokenForToken(address,address,(uint8,uint256,bytes)[],uint256,uint256)": {
-        "details": "Sells `sellAmount` of the given `inputToken` for      `outputToken` using the provided calls.",
-        "params": {
-          "calls": "The calls to use to sell the input tokens.",
-          "inputToken": "The token to sell.",
-          "minBuyAmount": "The minimum amount of `outputToken`        that must be bought for this function to not revert.",
-          "outputToken": "The token to buy.",
-          "sellAmount": "The amount of `inputToken` to sell."
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "boughtAmount": "The amount of `outputToken` bought."
+        {
+          "internalType": "bool",
+          "name": "isSushi",
+          "type": "bool"
         }
-      },
-      "multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)": {
-        "details": "Sells attached ETH via the given sequence of tokens      and calls. `tokens[0]` must be WETH.      The last token in `tokens` is the output token that      will ultimately be sent to `msg.sender`",
-        "params": {
-          "calls": "The sequence of calls to use for the sell.",
-          "minBuyAmount": "The minimum amount of output tokens that        must be bought for this function to not revert.",
-          "tokens": "The sequence of tokens to use for the sell,        i.e. `tokens[i]` will be sold for `tokens[i+1]` via        `calls[i]`."
-        },
-        "returns": {
-          "boughtAmount": "The amount of output tokens bought."
+      ],
+      "name": "sellToUniswap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "buyAmount",
+          "type": "uint256"
         }
-      },
-      "multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)": {
-        "details": "Sells `sellAmount` of the input token (`tokens[0]`)      for ETH via the given sequence of tokens and calls.      The last token in `tokens` must be WETH.",
-        "params": {
-          "calls": "The sequence of calls to use for the sell.",
-          "minBuyAmount": "The minimum amount of ETH that        must be bought for this function to not revert.",
-          "tokens": "The sequence of tokens to use for the sell,        i.e. `tokens[i]` will be sold for `tokens[i+1]` via        `calls[i]`."
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "encodedPath",
+          "type": "bytes"
         },
-        "returns": {
-          "boughtAmount": "The amount of ETH bought."
-        }
-      },
-      "multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)": {
-        "details": "Sells `sellAmount` of the input token (`tokens[0]`)      via the given sequence of tokens and calls.      The last token in `tokens` is the output token that      will ultimately be sent to `msg.sender`",
-        "params": {
-          "calls": "The sequence of calls to use for the sell.",
-          "minBuyAmount": "The minimum amount of output tokens that        must be bought for this function to not revert.",
-          "tokens": "The sequence of tokens to use for the sell,        i.e. `tokens[i]` will be sold for `tokens[i+1]` via        `calls[i]`."
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "boughtAmount": "The amount of output tokens bought."
-        }
-      },
-      "onERC1155Received(address,address,uint256,uint256,bytes)": {
-        "details": "Callback for the ERC1155 `safeTransferFrom` function.      This callback can be used to sell an ERC1155 asset if      a valid ERC1155 order, signature and `unwrapNativeToken`      are encoded in `data`. This allows takers to sell their      ERC1155 asset without first calling `setApprovalForAll`.",
-        "params": {
-          "data": "Additional data with no specified format. If a        valid ERC1155 order, signature and `unwrapNativeToken`        are encoded in `data`, this function will try to fill        the order using the received asset.",
-          "from": "The address which previously owned the token.",
-          "operator": "The address which called `safeTransferFrom`.",
-          "tokenId": "The ID of the asset being transferred.",
-          "value": "The amount being transferred."
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
         },
-        "returns": {
-          "success": "The selector of this function (0xf23a6e61),         indicating that the callback succeeded."
+        {
+          "internalType": "address payable",
+          "name": "recipient",
+          "type": "address"
         }
-      },
-      "onERC721Received(address,address,uint256,bytes)": {
-        "details": "Callback for the ERC721 `safeTransferFrom` function.      This callback can be used to sell an ERC721 asset if      a valid ERC721 order, signature and `unwrapNativeToken`      are encoded in `data`. This allows takers to sell their      ERC721 asset without first calling `setApprovalForAll`.",
-        "params": {
-          "data": "Additional data with no specified format. If a        valid ERC721 order, signature and `unwrapNativeToken`        are encoded in `data`, this function will try to fill        the order using the received asset.",
-          "from": "The address which previously owned the token.",
-          "operator": "The address which called `safeTransferFrom`.",
-          "tokenId": "The ID of the asset being transferred."
-        },
-        "returns": {
-          "success": "The selector of this function (0x150b7a02),         indicating that the callback succeeded."
+      ],
+      "name": "sellTokenForEthToUniswapV3",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "buyAmount",
+          "type": "uint256"
         }
-      },
-      "owner()": {
-        "details": "The owner of this contract.",
-        "returns": {
-          "ownerAddress": "The owner address."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "encodedPath",
+          "type": "bytes"
+        },
+        {
+          "internalType": "uint256",
+          "name": "sellAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minBuyAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         }
-      },
-      "preSignERC1155Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))": {
-        "details": "Approves an ERC1155 order on-chain. After pre-signing      the order, the `PRESIGNED` signature type will become      valid for that order and signer.",
-        "params": {
-          "order": "An ERC1155 order."
+      ],
+      "name": "sellTokenForTokenToUniswapV3",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "buyAmount",
+          "type": "uint256"
         }
-      },
-      "preSignERC721Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))": {
-        "details": "Approves an ERC721 order on-chain. After pre-signing      the order, the `PRESIGNED` signature type will become      valid for that order and signer.",
-        "params": {
-          "order": "An ERC721 order."
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "quoteSigner",
+          "type": "address"
         }
-      },
-      "registerAllowedOrderSigner(address,bool)": {
-        "details": "Register a signer who can sign on behalf of msg.sender      This allows one to sign on behalf of a contract that calls this function",
-        "params": {
-          "allowed": "True to register, false to unregister.",
-          "signer": "The address from which you plan to generate signatures"
+      ],
+      "name": "setQuoteSigner",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "transformerDeployer",
+          "type": "address"
         }
-      },
-      "registerAllowedRfqOrigins(address[],bool)": {
-        "details": "Mark what tx.origin addresses are allowed to fill an order that      specifies the message sender as its txOrigin.",
-        "params": {
-          "allowed": "True to register, false to unregister.",
-          "origins": "An array of origin addresses to update."
+      ],
+      "name": "setTransformerDeployer",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "interfaceId",
+          "type": "bytes4"
         }
-      },
-      "rollback(bytes4,address)": {
-        "details": "Roll back to a prior implementation of a function.",
-        "params": {
-          "selector": "The function selector.",
-          "targetImpl": "The address of an older implementation of the function."
+      ],
+      "name": "supportInterface",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "isSupported",
+          "type": "bool"
         }
-      },
-      "sellERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint256,uint128,bool,bytes)": {
-        "details": "Sells an ERC1155 asset to fill the given order.",
-        "params": {
-          "buyOrder": "The ERC1155 buy order.",
-          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC1155OrderCallback` on `msg.sender` after        the ERC20 tokens have been transferred to `msg.sender`        but before transferring the ERC1155 asset to the buyer.",
-          "erc1155SellAmount": "The amount of the ERC1155 asset        to sell.",
-          "erc1155TokenId": "The ID of the ERC1155 asset being        sold. If the given order specifies properties,        the asset must satisfy those properties. Otherwise,        it must equal the tokenId in the order.",
-          "signature": "The order signature from the maker.",
-          "unwrapNativeToken": "If this parameter is true and the        ERC20 token of the order is e.g. WETH, unwraps the        token before transferring it to the taker."
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newOwner",
+          "type": "address"
         }
-      },
-      "sellERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),uint256,bool,bytes)": {
-        "details": "Sells an ERC721 asset to fill the given order.",
-        "params": {
-          "buyOrder": "The ERC721 buy order.",
-          "callbackData": "If this parameter is non-zero, invokes        `zeroExERC721OrderCallback` on `msg.sender` after        the ERC20 tokens have been transferred to `msg.sender`        but before transferring the ERC721 asset to the buyer.",
-          "erc721TokenId": "The ID of the ERC721 asset being        sold. If the given order specifies properties,        the asset must satisfy those properties. Otherwise,        it must equal the tokenId in the order.",
-          "signature": "The order signature from the maker.",
-          "unwrapNativeToken": "If this parameter is true and the        ERC20 token of the order is e.g. WETH, unwraps the        token before transferring it to the taker."
+      ],
+      "name": "transferOwnership",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32[]",
+          "name": "poolIds",
+          "type": "bytes32[]"
         }
-      },
-      "sellEthForTokenToUniswapV3(bytes,uint256,address)": {
-        "details": "Sell attached ETH directly against uniswap v3.",
-        "params": {
-          "encodedPath": "Uniswap-encoded path, where the first token is WETH.",
-          "minBuyAmount": "Minimum amount of the last token in the path to buy.",
-          "recipient": "The recipient of the bought tokens. Can be zero for sender."
+      ],
+      "name": "transferProtocolFeesForPools",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "erc20",
+          "type": "address"
         },
-        "returns": {
-          "buyAmount": "Amount of the last token in the path bought."
-        }
-      },
-      "sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)": {
-        "details": "Sells `sellAmount` of `inputToken` to the liquidity provider      at the given `provider` address.",
-        "params": {
-          "auxiliaryData": "Auxiliary data supplied to the `provider` contract.",
-          "inputToken": "The token being sold.",
-          "minBuyAmount": "The minimum acceptable amount of `outputToken` to        buy. Reverts if this amount is not satisfied.",
-          "outputToken": "The token being bought.",
-          "provider": "The address of the on-chain liquidity provider        to trade with.",
-          "recipient": "The recipient of the bought tokens. If equal to        address(0), `msg.sender` is assumed to be the recipient.",
-          "sellAmount": "The amount of `inputToken` to sell."
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
         },
-        "returns": {
-          "boughtAmount": "The amount of `outputToken` bought."
+        {
+          "internalType": "address payable",
+          "name": "recipientWallet",
+          "type": "address"
         }
-      },
-      "sellToPancakeSwap(address[],uint256,uint256,uint8)": {
-        "details": "Efficiently sell directly to PancakeSwap (and forks).",
-        "params": {
-          "fork": "The protocol fork to use.",
-          "minBuyAmount": "Minimum amount of `tokens[-1]` to buy.",
-          "sellAmount": "of `tokens[0]` Amount to sell.",
-          "tokens": "Sell path."
+      ],
+      "name": "transferTrappedTokensTo",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "inputToken",
+          "type": "address"
         },
-        "returns": {
-          "buyAmount": "Amount of `tokens[-1]` bought."
+        {
+          "internalType": "contract IERC20TokenV06",
+          "name": "outputToken",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "inputTokenAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "minOutputTokenAmount",
+          "type": "uint256"
+        },
+        {
+          "components": [
+            {
+              "internalType": "uint32",
+              "name": "deploymentNonce",
+              "type": "uint32"
+            },
+            {
+              "internalType": "bytes",
+              "name": "data",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct ITransformERC20Feature.Transformation[]",
+          "name": "transformations",
+          "type": "tuple[]"
         }
-      },
-      "sellToUniswap(address[],uint256,uint256,bool)": {
-        "details": "Efficiently sell directly to uniswap/sushiswap.",
-        "params": {
-          "isSushi": "Use sushiswap if true.",
-          "minBuyAmount": "Minimum amount of `tokens[-1]` to buy.",
-          "sellAmount": "of `tokens[0]` Amount to sell.",
-          "tokens": "Sell path."
+      ],
+      "name": "transformERC20",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "outputTokenAmount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "int256",
+          "name": "amount0Delta",
+          "type": "int256"
         },
-        "returns": {
-          "buyAmount": "Amount of `tokens[-1]` bought."
+        {
+          "internalType": "int256",
+          "name": "amount1Delta",
+          "type": "int256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
         }
-      },
-      "sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)": {
-        "details": "Sell a token for ETH directly against uniswap v3.",
-        "params": {
-          "encodedPath": "Uniswap-encoded path, where the last token is WETH.",
-          "minBuyAmount": "Minimum amount of ETH to buy.",
-          "recipient": "The recipient of the bought tokens. Can be zero for sender.",
-          "sellAmount": "amount of the first token in the path to sell."
+      ],
+      "name": "uniswapV3SwapCallback",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc1155TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "uint128",
+              "name": "erc1155TokenAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "name": "order",
+          "type": "tuple"
         },
-        "returns": {
-          "buyAmount": "Amount of ETH bought."
+        {
+          "internalType": "uint256",
+          "name": "erc1155TokenId",
+          "type": "uint256"
         }
-      },
-      "sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)": {
-        "details": "Sell a token for another token directly against uniswap v3.",
-        "params": {
-          "encodedPath": "Uniswap-encoded path.",
-          "minBuyAmount": "Minimum amount of the last token in the path to buy.",
-          "recipient": "The recipient of the bought tokens. Can be zero for sender.",
-          "sellAmount": "amount of the first token in the path to sell."
+      ],
+      "name": "validateERC1155OrderProperties",
+      "outputs": [],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC1155Token",
+              "name": "erc1155Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc1155TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc1155TokenProperties",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "uint128",
+              "name": "erc1155TokenAmount",
+              "type": "uint128"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC1155Order",
+          "name": "order",
+          "type": "tuple"
         },
-        "returns": {
-          "buyAmount": "Amount of the last token in the path bought."
-        }
-      },
-      "setQuoteSigner(address)": {
-        "details": "Replace the optional signer for `transformERC20()` calldata.      Only callable by the owner.",
-        "params": {
-          "quoteSigner": "The address of the new calldata signer."
-        }
-      },
-      "setTransformerDeployer(address)": {
-        "details": "Replace the allowed deployer for transformers.      Only callable by the owner.",
-        "params": {
-          "transformerDeployer": "The address of the new trusted deployer        for transformers."
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
         }
-      },
-      "supportInterface(bytes4)": {
-        "details": "Indicates whether the 0x Exchange Proxy implements a particular      ERC165 interface. This function should use at most 30,000 gas.",
-        "params": {
-          "interfaceId": "The interface identifier, as specified in ERC165."
+      ],
+      "name": "validateERC1155OrderSignature",
+      "outputs": [],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc721TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC721Order",
+          "name": "order",
+          "type": "tuple"
         },
-        "returns": {
-          "isSupported": "Whether the given interface is supported by the         0x Exchange Proxy."
-        }
-      },
-      "transferOwnership(address)": {
-        "details": "Transfers ownership of the contract to a new address.",
-        "params": {
-          "newOwner": "The address that will become the owner."
-        }
-      },
-      "transferProtocolFeesForPools(bytes32[])": {
-        "details": "Transfers protocol fees from the `FeeCollector` pools into      the staking contract.",
-        "params": {
-          "poolIds": "Staking pool IDs"
-        }
-      },
-      "transferTrappedTokensTo(address,uint256,address)": {
-        "details": "calledFrom FundRecoveryFeature.transferTrappedTokensTo() This will be delegatecalled in the context of the Exchange Proxy instance being used.",
-        "params": {
-          "amountOut": "Amount of tokens to withdraw.",
-          "erc20": "ERC20 Token Address.",
-          "recipientWallet": "Recipient wallet address."
+        {
+          "internalType": "uint256",
+          "name": "erc721TokenId",
+          "type": "uint256"
         }
-      },
-      "transformERC20(address,address,uint256,uint256,(uint32,bytes)[])": {
-        "details": "Executes a series of transformations to convert an ERC20 `inputToken`      to an ERC20 `outputToken`.",
-        "params": {
-          "inputToken": "The token being provided by the sender.        If `0xeee...`, ETH is implied and should be provided with the call.`",
-          "inputTokenAmount": "The amount of `inputToken` to take from the sender.",
-          "minOutputTokenAmount": "The minimum amount of `outputToken` the sender        must receive for the entire transformation to succeed.",
-          "outputToken": "The token to be acquired by the sender.        `0xeee...` implies ETH.",
-          "transformations": "The transformations to execute on the token balance(s)        in sequence."
+      ],
+      "name": "validateERC721OrderProperties",
+      "outputs": [],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "enum LibNFTOrder.TradeDirection",
+              "name": "direction",
+              "type": "uint8"
+            },
+            {
+              "internalType": "address",
+              "name": "maker",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "taker",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "expiry",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            },
+            {
+              "internalType": "contract IERC20TokenV06",
+              "name": "erc20Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc20TokenAmount",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "feeData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Fee[]",
+              "name": "fees",
+              "type": "tuple[]"
+            },
+            {
+              "internalType": "contract IERC721Token",
+              "name": "erc721Token",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "erc721TokenId",
+              "type": "uint256"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IPropertyValidator",
+                  "name": "propertyValidator",
+                  "type": "address"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "propertyData",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct LibNFTOrder.Property[]",
+              "name": "erc721TokenProperties",
+              "type": "tuple[]"
+            }
+          ],
+          "internalType": "struct LibNFTOrder.ERC721Order",
+          "name": "order",
+          "type": "tuple"
         },
-        "returns": {
-          "outputTokenAmount": "The amount of `outputToken` received by the sender."
-        }
-      },
-      "uniswapV3SwapCallback(int256,int256,bytes)": {
-        "details": "The UniswapV3 pool swap callback which pays the funds requested      by the caller/pool to the pool. Can only be called by a valid      UniswapV3 pool.",
-        "params": {
-          "amount0Delta": "Token0 amount owed.",
-          "amount1Delta": "Token1 amount owed.",
-          "data": "Arbitrary data forwarded from swap() caller. An ABI-encoded        struct of: inputToken, outputToken, fee, payer"
-        }
-      },
-      "validateERC1155OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),uint256)": {
-        "details": "If the given order is buying an ERC1155 asset, checks      whether or not the given token ID satisfies the required      properties specified in the order. If the order does not      specify any properties, this function instead checks      whether the given token ID matches the ID in the order.      Reverts if any checks fail, or if the order is selling      an ERC1155 asset.",
-        "params": {
-          "erc1155TokenId": "The ID of the ERC1155 asset.",
-          "order": "The ERC1155 order."
-        }
-      },
-      "validateERC1155OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Checks whether the given signature is valid for the      the given ERC1155 order. Reverts if not.",
-        "params": {
-          "order": "The ERC1155 order.",
-          "signature": "The signature to validate."
-        }
-      },
-      "validateERC721OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),uint256)": {
-        "details": "If the given order is buying an ERC721 asset, checks      whether or not the given token ID satisfies the required      properties specified in the order. If the order does not      specify any properties, this function instead checks      whether the given token ID matches the ID in the order.      Reverts if any checks fail, or if the order is selling      an ERC721 asset.",
-        "params": {
-          "erc721TokenId": "The ID of the ERC721 asset.",
-          "order": "The ERC721 order."
-        }
-      },
-      "validateERC721OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32))": {
-        "details": "Checks whether the given signature is valid for the      the given ERC721 order. Reverts if not.",
-        "params": {
-          "order": "The ERC721 order.",
-          "signature": "The signature to validate."
+        {
+          "components": [
+            {
+              "internalType": "enum LibSignature.SignatureType",
+              "name": "signatureType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "uint8",
+              "name": "v",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "r",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "internalType": "struct LibSignature.Signature",
+          "name": "signature",
+          "type": "tuple"
         }
-      }
-    },
-    "version": 1
-  }
-}
\ No newline at end of file
+      ],
+      "name": "validateERC721OrderSignature",
+      "outputs": [],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
diff --git a/contracts/artifacts/LiquoriceSettlement.json b/contracts/artifacts/LiquoriceSettlement.json
index f34c403bdf..a0c1e0a46f 100644
--- a/contracts/artifacts/LiquoriceSettlement.json
+++ b/contracts/artifacts/LiquoriceSettlement.json
@@ -1,4191 +1,4193 @@
 {
-    "abi": [
+  "abi": [
+    {
+      "type": "constructor",
+      "inputs": [
         {
-            "type": "constructor",
-            "inputs": [
-                {
-                    "name": "authenticator_",
-                    "type": "address",
-                    "internalType": "contract IAllowListAuthentication"
-                },
-                {
-                    "name": "repository_",
-                    "type": "address",
-                    "internalType": "contract IRepository"
-                },
-                {
-                    "name": "permit2_",
-                    "type": "address",
-                    "internalType": "address"
-                }
-            ],
-            "stateMutability": "nonpayable"
+          "name": "authenticator_",
+          "type": "address",
+          "internalType": "contract IAllowListAuthentication"
         },
         {
-            "type": "receive",
-            "stateMutability": "payable"
+          "name": "repository_",
+          "type": "address",
+          "internalType": "contract IRepository"
         },
         {
-            "type": "function",
-            "name": "AUTHENTICATOR",
-            "inputs": [],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "address",
-                    "internalType": "contract IAllowListAuthentication"
-                }
-            ],
-            "stateMutability": "view"
-        },
+          "name": "permit2_",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "receive",
+      "stateMutability": "payable"
+    },
+    {
+      "type": "event",
+      "name": "Interaction",
+      "inputs": [
         {
-            "type": "function",
-            "name": "BALANCE_MANAGER",
-            "inputs": [],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "address",
-                    "internalType": "contract IBalanceManager"
-                }
-            ],
-            "stateMutability": "view"
+          "name": "target",
+          "type": "address",
+          "indexed": true,
+          "internalType": "address"
         },
         {
-            "type": "function",
-            "name": "DOMAIN_SEPARATOR",
-            "inputs": [],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                }
-            ],
-            "stateMutability": "view"
+          "name": "value",
+          "type": "uint256",
+          "indexed": false,
+          "internalType": "uint256"
         },
         {
-            "type": "function",
-            "name": "REPOSITORY",
-            "inputs": [],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "address",
-                    "internalType": "contract IRepository"
-                }
-            ],
-            "stateMutability": "view"
-        },
+          "name": "selector",
+          "type": "bytes4",
+          "indexed": false,
+          "internalType": "bytes4"
+        }
+      ],
+      "anonymous": false
+    },
+    {
+      "type": "event",
+      "name": "TradeOrder",
+      "inputs": [
         {
-            "type": "function",
-            "name": "cancelLimitOrder",
-            "inputs": [
-                {
-                    "name": "nonce",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "nonpayable"
+          "name": "rfqId",
+          "type": "string",
+          "indexed": true,
+          "internalType": "string"
         },
         {
-            "type": "function",
-            "name": "hashBaseTokenData",
-            "inputs": [
-                {
-                    "name": "_baseTokenData",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                    "components": [
-                        {
-                            "name": "addr",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "amount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "toRecipient",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "toRepay",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "toSupply",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                }
-            ],
-            "stateMutability": "pure"
+          "name": "trader",
+          "type": "address",
+          "indexed": false,
+          "internalType": "address"
         },
         {
-            "type": "function",
-            "name": "hashOrder",
-            "inputs": [
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Order",
-                    "components": [
-                        {
-                            "name": "market",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "chainId",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "baseTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRecipient",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRepay",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toSupply",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "quoteTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toTrader",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toWithdraw",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toBorrow",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        }
-                    ]
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                }
-            ],
-            "stateMutability": "view"
+          "name": "effectiveTrader",
+          "type": "address",
+          "indexed": false,
+          "internalType": "address"
         },
         {
-            "type": "function",
-            "name": "hashQuoteTokenData",
-            "inputs": [
-                {
-                    "name": "_quoteTokenData",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                    "components": [
-                        {
-                            "name": "addr",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "amount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "toTrader",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "toWithdraw",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "toBorrow",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                }
-            ],
-            "stateMutability": "pure"
+          "name": "baseToken",
+          "type": "address",
+          "indexed": false,
+          "internalType": "address"
         },
         {
-            "type": "function",
-            "name": "hashSingleOrder",
-            "inputs": [
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Single",
-                    "components": [
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "baseToken",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteToken",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "baseTokenAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "quoteTokenAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                }
-            ],
-            "stateMutability": "view"
+          "name": "quoteToken",
+          "type": "address",
+          "indexed": false,
+          "internalType": "address"
         },
         {
-            "type": "function",
-            "name": "isValidSignature",
-            "inputs": [
-                {
-                    "name": "_hash",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                },
-                {
-                    "name": "_signature",
-                    "type": "bytes",
-                    "internalType": "bytes"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bytes4",
-                    "internalType": "bytes4"
-                }
-            ],
-            "stateMutability": "view"
+          "name": "baseTokenAmount",
+          "type": "uint256",
+          "indexed": false,
+          "internalType": "uint256"
         },
         {
-            "type": "function",
-            "name": "settle",
-            "inputs": [
-                {
-                    "name": "_signer",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "_filledTakerAmount",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                },
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Order",
-                    "components": [
-                        {
-                            "name": "market",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "chainId",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "baseTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRecipient",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRepay",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toSupply",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "quoteTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toTrader",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toWithdraw",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toBorrow",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    "name": "_interactions",
-                    "type": "tuple[]",
-                    "internalType": "struct GPv2Interaction.Data[]",
-                    "components": [
-                        {
-                            "name": "target",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "value",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "callData",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_hooks",
-                    "type": "tuple",
-                    "internalType": "struct GPv2Interaction.Hooks",
-                    "components": [
-                        {
-                            "name": "beforeSettle",
-                            "type": "tuple[]",
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "components": [
-                                {
-                                    "name": "target",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "value",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "callData",
-                                    "type": "bytes",
-                                    "internalType": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "afterSettle",
-                            "type": "tuple[]",
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "components": [
-                                {
-                                    "name": "target",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "value",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "callData",
-                                    "type": "bytes",
-                                    "internalType": "bytes"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    "name": "_makerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_takerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "nonpayable"
+          "name": "quoteTokenAmount",
+          "type": "uint256",
+          "indexed": false,
+          "internalType": "uint256"
         },
         {
-            "type": "function",
-            "name": "settleSingle",
-            "inputs": [
-                {
-                    "name": "_signer",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Single",
-                    "components": [
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "baseToken",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteToken",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "baseTokenAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "quoteTokenAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        }
-                    ]
-                },
-                {
-                    "name": "_makerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_filledTakerAmount",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                },
-                {
-                    "name": "_takerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "payable"
-        },
+          "name": "recipient",
+          "type": "address",
+          "indexed": false,
+          "internalType": "address"
+        }
+      ],
+      "anonymous": false
+    },
+    {
+      "type": "error",
+      "name": "ECDSAInvalidSignature",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "ECDSAInvalidSignatureLength",
+      "inputs": [
         {
-            "type": "function",
-            "name": "settleSingleWithPermitsSignatures",
-            "inputs": [
-                {
-                    "name": "_signer",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Single",
-                    "components": [
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "baseToken",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteToken",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "baseTokenAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "quoteTokenAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        }
-                    ]
-                },
-                {
-                    "name": "_makerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_filledTakerAmount",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                },
-                {
-                    "name": "_takerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_takerPermitInfo",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TakerPermitInfo",
-                    "components": [
-                        {
-                            "name": "signature",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint48",
-                            "internalType": "uint48"
-                        },
-                        {
-                            "name": "deadline",
-                            "type": "uint48",
-                            "internalType": "uint48"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "payable"
-        },
+          "name": "length",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ]
+    },
+    {
+      "type": "error",
+      "name": "ECDSAInvalidSignatureS",
+      "inputs": [
         {
-            "type": "function",
-            "name": "settleWithPermitsSignatures",
-            "inputs": [
-                {
-                    "name": "_signer",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "_filledTakerAmount",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                },
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Order",
-                    "components": [
-                        {
-                            "name": "market",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "chainId",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "baseTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRecipient",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRepay",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toSupply",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "quoteTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toTrader",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toWithdraw",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toBorrow",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    "name": "_interactions",
-                    "type": "tuple[]",
-                    "internalType": "struct GPv2Interaction.Data[]",
-                    "components": [
-                        {
-                            "name": "target",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "value",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "callData",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_hooks",
-                    "type": "tuple",
-                    "internalType": "struct GPv2Interaction.Hooks",
-                    "components": [
-                        {
-                            "name": "beforeSettle",
-                            "type": "tuple[]",
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "components": [
-                                {
-                                    "name": "target",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "value",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "callData",
-                                    "type": "bytes",
-                                    "internalType": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "afterSettle",
-                            "type": "tuple[]",
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "components": [
-                                {
-                                    "name": "target",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "value",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "callData",
-                                    "type": "bytes",
-                                    "internalType": "bytes"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    "name": "_makerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_takerSignature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                },
-                {
-                    "name": "_takerPermitInfo",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TakerPermitInfo",
-                    "components": [
-                        {
-                            "name": "signature",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint48",
-                            "internalType": "uint48"
-                        },
-                        {
-                            "name": "deadline",
-                            "type": "uint48",
-                            "internalType": "uint48"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "payable"
-        },
+          "name": "s",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ]
+    },
+    {
+      "type": "error",
+      "name": "InvalidAmount",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidAsset",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidBaseTokenAmounts",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidDestination",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidEIP1271Signature",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidEIP712Signature",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidETHSignSignature",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidFillAmount",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidHooksTarget",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidInteractionsBaseTokenAmounts",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidInteractionsQuoteTokenAmounts",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidLendingPoolInteraction",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidQuoteTokenAmounts",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidSignatureType",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidSigner",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "InvalidSource",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "NonceInvalid",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "NotMaker",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "NotSolver",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "OrderExpired",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "PartialFillNotSupported",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "ReceiverNotManager",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "ReentrancyGuardReentrantCall",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "SafeERC20FailedOperation",
+      "inputs": [
         {
-            "type": "function",
-            "name": "validateHooks",
-            "inputs": [
-                {
-                    "name": "_repository",
-                    "type": "address",
-                    "internalType": "contract IRepository"
-                },
-                {
-                    "name": "_hooks",
-                    "type": "tuple",
-                    "internalType": "struct GPv2Interaction.Hooks",
-                    "components": [
-                        {
-                            "name": "beforeSettle",
-                            "type": "tuple[]",
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "components": [
-                                {
-                                    "name": "target",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "value",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "callData",
-                                    "type": "bytes",
-                                    "internalType": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "afterSettle",
-                            "type": "tuple[]",
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "components": [
-                                {
-                                    "name": "target",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "value",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "callData",
-                                    "type": "bytes",
-                                    "internalType": "bytes"
-                                }
-                            ]
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "view"
-        },
+          "name": "token",
+          "type": "address",
+          "internalType": "address"
+        }
+      ]
+    },
+    {
+      "type": "error",
+      "name": "SignatureIsExpired",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "SignatureIsNotEmpty",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "UpdatedMakerAmountsTooLow",
+      "inputs": []
+    },
+    {
+      "type": "error",
+      "name": "ZeroMakerAmount",
+      "inputs": []
+    },
+    {
+      "type": "function",
+      "name": "AUTHENTICATOR",
+      "inputs": [],
+      "outputs": [
         {
-            "type": "function",
-            "name": "validateInteractions",
-            "inputs": [
-                {
-                    "name": "_repository",
-                    "type": "address",
-                    "internalType": "contract IRepository"
-                },
-                {
-                    "name": "_signer",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "_isPartialFill",
-                    "type": "bool",
-                    "internalType": "bool"
-                },
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Order",
-                    "components": [
-                        {
-                            "name": "market",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "chainId",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "baseTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRecipient",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRepay",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toSupply",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "quoteTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toTrader",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toWithdraw",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toBorrow",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    "name": "_interactions",
-                    "type": "tuple[]",
-                    "internalType": "struct GPv2Interaction.Data[]",
-                    "components": [
-                        {
-                            "name": "target",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "value",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "callData",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "view"
+          "name": "",
+          "type": "address",
+          "internalType": "contract IAllowListAuthentication"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "BALANCE_MANAGER",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "contract IBalanceManager"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "DOMAIN_SEPARATOR",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "hashSingleOrder",
+      "inputs": [
+        {
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Single",
+          "components": [
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "baseToken",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteToken",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "baseTokenAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "quoteTokenAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            }
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "isValidSignature",
+      "inputs": [
+        {
+          "name": "_hash",
+          "type": "bytes32",
+          "internalType": "bytes32"
         },
         {
-            "type": "function",
-            "name": "validateOrderAmounts",
-            "inputs": [
-                {
-                    "name": "_order",
-                    "type": "tuple",
-                    "internalType": "struct ILiquoriceSettlement.Order",
-                    "components": [
-                        {
-                            "name": "market",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "chainId",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "rfqId",
-                            "type": "string",
-                            "internalType": "string"
-                        },
-                        {
-                            "name": "nonce",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "trader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "quoteExpiry",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "recipient",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "minFillAmount",
-                            "type": "uint256",
-                            "internalType": "uint256"
-                        },
-                        {
-                            "name": "baseTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRecipient",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toRepay",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toSupply",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        },
-                        {
-                            "name": "quoteTokenData",
-                            "type": "tuple",
-                            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                            "components": [
-                                {
-                                    "name": "addr",
-                                    "type": "address",
-                                    "internalType": "address"
-                                },
-                                {
-                                    "name": "amount",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toTrader",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toWithdraw",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                },
-                                {
-                                    "name": "toBorrow",
-                                    "type": "uint256",
-                                    "internalType": "uint256"
-                                }
-                            ]
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "pure"
+          "name": "_signature",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes4",
+          "internalType": "bytes4"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "settle",
+      "inputs": [
+        {
+          "name": "_signer",
+          "type": "address",
+          "internalType": "address"
         },
         {
-            "type": "function",
-            "name": "validateSignature",
-            "inputs": [
-                {
-                    "name": "_validationAddress",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "_hash",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                },
-                {
-                    "name": "_signature",
-                    "type": "tuple",
-                    "internalType": "struct Signature.TypedSignature",
-                    "components": [
-                        {
-                            "name": "signatureType",
-                            "type": "uint8",
-                            "internalType": "enum Signature.Type"
-                        },
-                        {
-                            "name": "transferCommand",
-                            "type": "uint8",
-                            "internalType": "enum Signature.TransferCommand"
-                        },
-                        {
-                            "name": "signatureBytes",
-                            "type": "bytes",
-                            "internalType": "bytes"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "view"
+          "name": "_filledTakerAmount",
+          "type": "uint256",
+          "internalType": "uint256"
         },
         {
-            "type": "event",
-            "name": "Interaction",
-            "inputs": [
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Order",
+          "components": [
+            {
+              "name": "market",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "chainId",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "baseTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
                 {
-                    "name": "target",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
+                  "name": "toRecipient",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "value",
-                    "type": "uint256",
-                    "indexed": false,
-                    "internalType": "uint256"
+                  "name": "toRepay",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "selector",
-                    "type": "bytes4",
-                    "indexed": false,
-                    "internalType": "bytes4"
+                  "name": "toSupply",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 }
-            ],
-            "anonymous": false
-        },
-        {
-            "type": "event",
-            "name": "TradeOrder",
-            "inputs": [
+              ]
+            },
+            {
+              "name": "quoteTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
                 {
-                    "name": "rfqId",
-                    "type": "string",
-                    "indexed": true,
-                    "internalType": "string"
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "trader",
-                    "type": "address",
-                    "indexed": false,
-                    "internalType": "address"
+                  "name": "toTrader",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "effectiveTrader",
-                    "type": "address",
-                    "indexed": false,
-                    "internalType": "address"
+                  "name": "toWithdraw",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "baseToken",
-                    "type": "address",
-                    "indexed": false,
-                    "internalType": "address"
+                  "name": "toBorrow",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "_interactions",
+          "type": "tuple[]",
+          "internalType": "struct GPv2Interaction.Data[]",
+          "components": [
+            {
+              "name": "target",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "value",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "callData",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "_hooks",
+          "type": "tuple",
+          "internalType": "struct GPv2Interaction.Hooks",
+          "components": [
+            {
+              "name": "beforeSettle",
+              "type": "tuple[]",
+              "internalType": "struct GPv2Interaction.Data[]",
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                  "internalType": "address"
                 },
                 {
-                    "name": "quoteToken",
-                    "type": "address",
-                    "indexed": false,
-                    "internalType": "address"
+                  "name": "value",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "baseTokenAmount",
-                    "type": "uint256",
-                    "indexed": false,
-                    "internalType": "uint256"
+                  "name": "callData",
+                  "type": "bytes",
+                  "internalType": "bytes"
+                }
+              ]
+            },
+            {
+              "name": "afterSettle",
+              "type": "tuple[]",
+              "internalType": "struct GPv2Interaction.Data[]",
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                  "internalType": "address"
                 },
                 {
-                    "name": "quoteTokenAmount",
-                    "type": "uint256",
-                    "indexed": false,
-                    "internalType": "uint256"
+                  "name": "value",
+                  "type": "uint256",
+                  "internalType": "uint256"
                 },
                 {
-                    "name": "recipient",
-                    "type": "address",
-                    "indexed": false,
-                    "internalType": "address"
+                  "name": "callData",
+                  "type": "bytes",
+                  "internalType": "bytes"
                 }
-            ],
-            "anonymous": false
+              ]
+            }
+          ]
         },
         {
-            "type": "error",
-            "name": "ECDSAInvalidSignature",
-            "inputs": []
+          "name": "_makerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
         },
         {
-            "type": "error",
-            "name": "ECDSAInvalidSignatureLength",
-            "inputs": [
-                {
-                    "name": "length",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ]
+          "name": "_takerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "settleSingle",
+      "inputs": [
+        {
+          "name": "_signer",
+          "type": "address",
+          "internalType": "address"
         },
         {
-            "type": "error",
-            "name": "ECDSAInvalidSignatureS",
-            "inputs": [
-                {
-                    "name": "s",
-                    "type": "bytes32",
-                    "internalType": "bytes32"
-                }
-            ]
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Single",
+          "components": [
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "baseToken",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteToken",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "baseTokenAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "quoteTokenAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            }
+          ]
         },
         {
-            "type": "error",
-            "name": "InvalidAmount",
-            "inputs": []
+          "name": "_makerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
         },
         {
-            "type": "error",
-            "name": "InvalidAsset",
-            "inputs": []
+          "name": "_filledTakerAmount",
+          "type": "uint256",
+          "internalType": "uint256"
         },
         {
-            "type": "error",
-            "name": "InvalidBaseTokenAmounts",
-            "inputs": []
+          "name": "_takerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "payable"
+    }
+  ],
+  "bytecode": {
+    "object": "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",
+    "sourceMap": "975:10890:90:-:0;;;2483:234;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3749:13:91;3730:32;;;;3811:93;;;1026:66;3811:93;;;1092:25:169;879:32:91;1133:18:169;;;1126:34;;;;957:14:91;1176:18:169;;;1169:34;1219:18;;;1212:34;;;;3898:4:91;1262:19:169;;;1255:61;1064:19;;3811:93:91;;;-1:-1:-1;;3811:93:91;;;;;;;;;;3801:104;;3811:93;3801:104;;;;3768:137;;1857:1:44;2061:21;;-1:-1:-1;;;;;2585:30:90;;;;2666:4;;2673:8;;2639:43;;;:::i;:::-;-1:-1:-1;;;;;1557:15:169;;;1539:34;;1609:15;;1604:2;1589:18;;1582:43;1489:2;1474:18;2639:43:90;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2621:61:90;;;;;2688:24;;;;;;-1:-1:-1;975:10890:90;;-1:-1:-1;975:10890:90;;;;;;;;;:::o;14:157:169:-;-1:-1:-1;;;;;115:31:169;;105:42;;95:70;;161:1;158;151:12;95:70;14:157;:::o;176:652::-;319:6;327;335;388:2;376:9;367:7;363:23;359:32;356:52;;;404:1;401;394:12;356:52;436:9;430:16;455:57;506:5;455:57;:::i;:::-;581:2;566:18;;560:25;531:5;;-1:-1:-1;594:59:169;560:25;594:59;:::i;:::-;724:2;709:18;;703:25;672:7;;-1:-1:-1;737:59:169;703:25;737:59;:::i;:::-;815:7;805:17;;;176:652;;;;;:::o;1327:304::-;975:10890:90;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+    "linkReferences": {}
+  },
+  "deployedBytecode": {
+    "object": "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",
+    "sourceMap": "975:10890:90:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7809:308;;;;;;;;;;-1:-1:-1;7809:308:90;;;;;:::i;:::-;;:::i;:::-;;;852:66:169;840:79;;;822:98;;810:2;795:18;7809:308:90;;;;;;;;1318:57;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;1102:74;;1090:2;1075:18;1318:57:90;931:251:169;6790:255:91;;;;;;;;;;;;;:::i;:::-;;;1333:25:169;;;1321:2;1306:18;6790:255:91;1187:177:169;5478:391:91;;;;;;;;;;-1:-1:-1;5478:391:91;;;;;:::i;:::-;;:::i;5859:1907:90:-;;;;;;:::i;:::-;;:::i;:::-;;14436:563:91;;;;;;;;;;-1:-1:-1;14436:563:91;;;;;:::i;:::-;;:::i;1440:48:90:-;;;;;;;;;;;;;;;5092:382:91;;;;;;;;;;-1:-1:-1;5092:382:91;;;;;:::i;:::-;;:::i;4627:523:90:-;;;;;;:::i;:::-;;:::i;4091:109:91:-;;;;;;;;;;-1:-1:-1;4091:109:91;;;;;:::i;:::-;;:::i;7272:1606::-;;;;;;;;;;-1:-1:-1;7272:1606:91;;;;;:::i;:::-;;:::i;15182:1005::-;;;;;;;;;;-1:-1:-1;15182:1005:91;;;;;:::i;:::-;;:::i;6025:761::-;;;;;;;;;;-1:-1:-1;6025:761:91;;;;;:::i;:::-;;:::i;1196:64:90:-;;;;;;;;;;;;;;;2894:1690;;;;;;;;;;-1:-1:-1;2894:1690:90;;;;;:::i;:::-;;:::i;5154:701::-;;;;;;:::i;:::-;;:::i;4336:752:91:-;;;;;;;;;;-1:-1:-1;4336:752:91;;;;;:::i;:::-;;:::i;13818:485::-;;;;;;;;;;-1:-1:-1;13818:485:91;;;;;:::i;:::-;;:::i;7809:308:90:-;7909:6;7923:23;7949:35;7966:5;7973:10;;7949:16;:35::i;:::-;7994:38;;;;;-1:-1:-1;;;;;1120:55:169;;;7994:38:90;;;1102:74:169;7923:61:90;;-1:-1:-1;7994:13:90;:21;;;;;;1075:18:169;;7994:38:90;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7990:123;;;1905:44:91;8042:26:90;;;;;7990:123;-1:-1:-1;8089:17:90;;-1:-1:-1;7809:308:90;;;;;;:::o;6790:255:91:-;6839:7;6878:16;6861:13;:33;:179;;6946:93;;;1026:66;6946:93;;;13746:25:169;879:32:91;13787:18:169;;;13780:34;;;;957:14:91;13830:18:169;;;13823:34;7010:13:91;13873:18:169;;;13866:34;7033:4:91;13916:19:169;;;13909:84;13718:19;;6946:93:91;;;;;;;;;;;;6936:104;;;;;;6854:186;;6790:255;:::o;6861:179::-;-1:-1:-1;6903:24:91;;6790:255::o;5478:391::-;5597:7;2314:68;5694:20;;;;:15;:20;:::i;:::-;5724:15;:22;;;5756:15;:24;;;5790:15;:26;;;5826:15;:24;;;5636:222;;;;;;;;;;;;14543:25:169;;;-1:-1:-1;;;;;14604:55:169;;;;14599:2;14584:18;;14577:83;14691:2;14676:18;;14669:34;;;;14734:2;14719:18;;14712:34;14777:3;14762:19;;14755:35;14821:3;14806:19;;14799:35;14530:3;14515:19;;14256:584;5636:222:91;;;;;;;;;;;;;5619:245;;;;;;5612:252;;5478:391;;;:::o;5859:1907:90:-;2500:21:44;:19;:21::i;:::-;6282:30:90::1;::::0;;;;-1:-1:-1;;;;;1120:55:169;;;6282:30:90::1;::::0;::::1;1102:74:169::0;6282:13:90::1;:21;::::0;::::1;::::0;1075:18:169;;6282:30:90::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6277:54;;6321:10;;;;;;;;;;;;;;6277:54;6366:30:::0;;;::::1;6406:22:::0;;;;;:80:::1;;-1:-1:-1::0;6454:32:90;;;::::1;6432:54:::0;::::1;;6406:80;6402:254;;;6516:133;6537:18:::0;6557:30;;;::::1;6589:32:::0;;;::::1;6623:18;6516:11;:133::i;:::-;6496:153;;6402:254;6662:130;6683:10;6695:7;6704:17;6723:6;6731:13;;6746:6;6754:15;6771;6662:13;:130::i;:::-;-1:-1:-1::0;;;;;6799:15:90::1;:28;;6835:22;::::0;;;::::1;::::0;::::1;;:::i;:::-;6859:25;::::0;;;:20:::1;::::0;::::1;:25;:::i;:::-;6886:32;6799:143:::0;;::::1;::::0;;;;;;::::1;::::0;;;6886:32;;;::::1;::::0;6920:16;;6799:143:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;6949:357;6970:6;6984:7;6999:17;7024:18;7046:1;7024:23;:80;;;-1:-1:-1::0;7072:32:90;;;::::1;7051:53:::0;::::1;7024:80;:152;;7158:18;7024:152;;;7115:32:::0;;;::::1;7024:152;7184:6:::0;7198:13;;7219:42:::1;7269:31;::::0;;;::::1;::::0;::::1;;:::i;:::-;6949:13;:357::i;:::-;7336:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;7318:443;;;;;;;:::i;:::-;;::::0;;;;::::1;::::0;;::::1;7356:13;::::0;;;::::1;::::0;::::1;;:::i;:::-;7377:22;::::0;;;::::1;::::0;::::1;;:::i;:::-;7407:25;::::0;;;:20:::1;::::0;::::1;:25;:::i;:::-;7440:26;::::0;;;:21:::1;::::0;::::1;:26;:::i;:::-;7474:23:::0;;;:80:::1;;-1:-1:-1::0;7522:32:90;;;::::1;7501:53:::0;::::1;7474:80;:147;;7603:18;7474:147;;;7565:27:::0;;;::::1;7474:147;7650:30:::0;;;::::1;7629:51:::0;::::1;:102;;7714:17;7629:102;;;7683:28:::0;;;::::1;7629:102;7739:6;:16;;;;;;;;;;:::i;:::-;7318:443;::::0;;-1:-1:-1;;;;;18257:15:169;;;18239:34;;18309:15;;;18304:2;18289:18;;18282:43;18361:15;;;18341:18;;;18334:43;;;;18413:15;;;18408:2;18393:18;;18386:43;18460:3;18445:19;;18438:35;18504:3;18489:19;;18482:35;18554:15;;;18548:3;18533:19;;18526:44;18165:3;18150:19;7318:443:90::1;;;;;;;6271:1495;2542:20:44::0;1857:1;3068:21;;2888:208;2542:20;5859:1907:90;;;;;;;;;:::o;14436:563:91:-;14546:9;14541:225;14561:19;:6;;:19;:::i;:::-;:26;;14557:1;:30;14541:225;;;14602:34;14639:19;:6;;:19;:::i;:::-;14659:1;14639:22;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;14602:59;-1:-1:-1;;;;;;14674:25:91;;;14700:11;;;;14602:59;14700:11;:::i;:::-;14674:38;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;14674:38:91;;;1102:74:169;1075:18;;14674:38:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14670:90;;;14731:20;;;;;;;;;;;;;;14670:90;-1:-1:-1;14589:3:91;;14541:225;;;;14777:9;14772:223;14792:18;;;;:6;:18;:::i;:::-;:25;;14788:1;:29;14772:223;;;14832:34;14869:18;;;;:6;:18;:::i;:::-;14888:1;14869:21;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;14832:58;-1:-1:-1;;;;;;14903:25:91;;;14929:11;;;;14832:58;14929:11;:::i;:::-;14903:38;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;14903:38:91;;;1102:74:169;1075:18;;14903:38:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14899:90;;;14960:20;;;;;;;;;;;;;;14899:90;-1:-1:-1;14819:3:91;;14772:223;;;;14436:563;;:::o;5092:382::-;5208:7;2182:67;5304:19;;;;:14;:19;:::i;4627:523:90:-;4876:62;4914:6;4922:15;4876:37;:62::i;:::-;4944:201;4971:7;4986:6;5000:15;5023:18;5049:41;5098;4944:19;:201::i;:::-;4627:523;;;;;:::o;4091:109:91:-;4155:40;4177:10;4189:5;4155:21;:40::i;:::-;4091:109;:::o;7272:1606::-;7498:27;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7498:27:91;7537:9;7532:1297;7548:24;;;7532:1297;;;7587:41;7631:13;;7645:1;7631:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;7587:60;-1:-1:-1;7655:23:91;;7681:20;;;;7587:60;7681:20;:::i;:::-;7655:46;;-1:-1:-1;7655:46:91;-1:-1:-1;;;;;;7714:25:91;;;7740:18;;;;:11;:18;:::i;:::-;7714:45;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;7714:45:91;;;1102:74:169;1075:18;;7714:45:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7710:1113;;;7771:10;7796:14;7792:52;;;7819:25;;;;;;;;;;;;;;7792:52;7878:1;7859:20;;7855:119;;-1:-1:-1;7923:29:91;;7855:119;7988:33;;;;;7984:831;;8049:45;8068:8;;8078:7;8087:6;8049:18;:45::i;:::-;8035:1;:10;;:59;;;;;;;:::i;:::-;;;-1:-1:-1;7984:831:91;;;8115:33;;;;;8111:704;;8176:45;8195:8;;8205:7;8214:6;8176:18;:45::i;:::-;8162:1;:10;;:59;;;;;;;:::i;8111:704::-;8242:39;;;;;8238:577;;8340:50;8364:8;;8374:7;8383:6;8340:23;:50::i;:::-;8317:19;;;8295:95;8296:19;;;8295:95;;;8402:10;;;:33;;;;8295:95;;8402:33;:::i;:::-;;;-1:-1:-1;8461:19:91;;;;8447:10;;;:33;;;;8461:19;;8447:33;:::i;8238:577::-;8501:32;;;;;8497:318;;8560:44;8578:8;;8588:7;8597:6;8560:17;:44::i;:::-;8547:57;;:1;;:57;;;;;:::i;8497:318::-;8625:35;;;;;8621:194;;8690:47;8711:8;;8721:7;8730:6;8690:20;:47::i;:::-;8674:1;:12;;:63;;;;;;;:::i;8621:194::-;8773:31;;;;;;;;;;;;;;8621:194;7761:1062;7710:1113;7579:1250;;;7574:3;;;;;7532:1297;;;;8835:38;8863:6;8871:1;8835:27;:38::i;:::-;7492:1386;7272:1606;;;;;;:::o;15182:1005::-;15364:21;15336:24;;;;:10;:24;:::i;:::-;:49;;;;;;;;:::i;:::-;;15332:851;;-1:-1:-1;;;;;15399:72:91;;:50;15416:5;15423:25;;;;:10;:25;:::i;:::-;15399:16;:50::i;:::-;-1:-1:-1;;;;;15399:72:91;;15395:128;;15490:24;;;;;;;;;;;;;;15332:851;15567:22;15539:24;;;;:10;:24;:::i;:::-;:50;;;;;;;;:::i;:::-;;15535:648;;15655:20;15599:19;15645:31;;;15692:2;15685:17;;;15739:2;15726:16;;-1:-1:-1;;;;;15761:78:91;;:56;15726:16;15791:25;;;;:10;:25;:::i;15761:56::-;-1:-1:-1;;;;;15761:78:91;;15757:135;;15858:25;;;;;;;;;;;;;;15757:135;15591:307;14772:223;14436:563;;:::o;15535:648::-;15936:22;15908:24;;;;:10;:24;:::i;:::-;:50;;;;;;;;:::i;:::-;;15904:279;;15972:102;-1:-1:-1;;;;;15972:45:91;;;16018:5;16025:25;;;;:10;:25;:::i;:::-;15972:79;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:102;;;15968:159;;16093:25;;;;;;;;;;;;;;15904:279;16154:22;;;;;;;;;;;;;;6025:761;6124:7;6209:18;:16;:18::i;:::-;2011:107;6381:12;:6;;:12;:::i;:::-;6370:24;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6360:35;;;;;;6397:6;:12;;;6411:6;:13;;;;;;;;;;:::i;:::-;6323:102;;;;;;22262:25:169;;;;22303:18;;22296:34;;;;22346:18;;;22339:34;-1:-1:-1;;;;;22409:55:169;22389:18;;;22382:83;22234:19;;6323:102:91;;;;;;;;;;;;;6465:22;;;;;;;;:::i;:::-;6503:16;;;;;;;;:::i;:::-;6535:17;;;;;;;;:::i;:::-;6568:22;;;;6606:23;;;;6645:20;;;;6681:18;;;;6715:16;;;;;;;;:::i;:::-;6439:306;;;-1:-1:-1;;;;;22898:15:169;;;6439:306:91;;;22880:34:169;22950:15;;;22930:18;;;22923:43;23002:15;;;22982:18;;;22975:43;23034:18;;;23027:34;;;;23077:19;;;23070:35;;;;23121:19;;;23114:35;23165:19;;;23158:35;23230:15;;;23209:19;;;23202:44;22791:19;;6439:306:91;;;;;;;;;;;;;;6258:499;;;6439:306;6258:499;;:::i;:::-;;;;;;;;;;;;;6237:530;;;;;;6163:612;;;;;;;;24120:66:169;24108:79;;24212:1;24203:11;;24196:27;;;;24248:2;24239:12;;24232:28;24285:2;24276:12;;23850:444;2894:1690:90;2500:21:44;:19;:21::i;:::-;2266:34:90::1;::::0;;;;2289:10:::1;2266:34;::::0;::::1;1102:74:169::0;2266:13:90::1;-1:-1:-1::0;;;;;2266:22:90::1;::::0;::::1;::::0;1075:18:169;;2266:34:90::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2261:59;;2309:11;;;;;;;;;;;;;;2261:59;3251:30:::2;::::0;;;;-1:-1:-1;;;;;1120:55:169;;;3251:30:90::2;::::0;::::2;1102:74:169::0;3251:13:90::2;:21;::::0;::::2;::::0;1075:18:169;;3251:30:90::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3246:54;;3290:10;;;;;;;;;;;;;;3246:54;3335:30:::0;;;::::2;3375:22:::0;;;;;:80:::2;;-1:-1:-1::0;3423:32:90;;;::::2;3401:54:::0;::::2;;3375:80;3371:254;;;3485:133;3506:18:::0;3526:30;;;::::2;3558:32:::0;;;::::2;3592:18;3485:11;:133::i;:::-;3465:153;;3371:254;3631:130;3652:10;3664:7;3673:17;3692:6;3700:13;;3715:6;3723:15;3740;3631:13;:130::i;:::-;3768:356;3789:6:::0;3803:7;3818:17;3843:23;;;:80:::2;;-1:-1:-1::0;3891:32:90;;;::::2;3870:53:::0;::::2;3843:80;:152;;3977:18;3843:152;;;3934:32:::0;;;::::2;3843:152;4003:6:::0;4017:13;;4038:41:::2;4087:31;::::0;;;::::2;::::0;::::2;;:::i;3768:356::-;4154:12;;::::0;::::2;:6:::0;:12:::2;:::i;:::-;4136:443;;;;;;;:::i;:::-;;::::0;;;;::::2;::::0;;::::2;4174:13;::::0;;;::::2;::::0;::::2;;:::i;:::-;4195:22;::::0;;;::::2;::::0;::::2;;:::i;:::-;4225:25;::::0;;;:20:::2;::::0;::::2;:25;:::i;:::-;4258:26;::::0;;;:21:::2;::::0;::::2;:26;:::i;:::-;4292:23:::0;;;:80:::2;;-1:-1:-1::0;4340:32:90;;;::::2;4319:53:::0;::::2;4292:80;:147;;4421:18;4292:147;;;4383:27:::0;;;::::2;4292:147;4468:30:::0;;;::::2;4447:51:::0;::::2;:102;;4532:17;4447:102;;;4501:28:::0;;;::::2;4447:102;4557:6;:16;;;;;;;;;;:::i;:::-;4136:443;::::0;;-1:-1:-1;;;;;18257:15:169;;;18239:34;;18309:15;;;18304:2;18289:18;;18282:43;18361:15;;;18341:18;;;18334:43;;;;18413:15;;;18408:2;18393:18;;18386:43;18460:3;18445:19;;18438:35;18504:3;18489:19;;18482:35;18554:15;;;18548:3;18533:19;;18526:44;18165:3;18150:19;4136:443:90::2;;;;;;;3240:1344;2542:20:44::0;1857:1;3068:21;;2888:208;2542:20;2894:1690:90;;;;;;;;:::o;5154:701::-;5472:62;5510:6;5518:15;5472:37;:62::i;:::-;-1:-1:-1;;;;;5540:15:90;:28;;5569:22;;;;;;;;:::i;:::-;5593:16;;;;;;;;:::i;:::-;5611:6;:22;;;5635:16;5540:112;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5658:192;5685:7;5700:6;5714:15;5737:18;5763:42;5813:15;:31;;;;;;;;;;:::i;:::-;5658:19;:192::i;:::-;5154:701;;;;;;:::o;4336:752:91:-;4428:7;4513:18;:16;:18::i;:::-;2439:220;4714:12;;;;:6;:12;:::i;:::-;4703:24;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;4693:35;;4703:24;4693:35;;;;4744:12;;;;4772:13;;;;;;;;:::i;:::-;4801:22;;;;;;;;:::i;:::-;4839:18;;;;4873:16;;;;;;;;:::i;:::-;4627:312;;;;;;24642:25:169;;;;24683:18;;24676:34;;;;24726:18;;;24719:34;;;;-1:-1:-1;;;;;24850:15:169;;;24830:18;;;24823:43;24903:15;;24882:19;;;24875:44;24935:19;;;24928:35;;;;25000:15;24979:19;;;24972:44;4905:20:91;;;;;25032:19:169;;;25025:35;24614:19;;4627:312:91;;;;;;;;;;;;4953:39;4971:6;:20;;4953:17;:39::i;:::-;5006:41;5025:6;:21;;5006:18;:41::i;:::-;4562:497;;;;;;;;;;:::i;13818:485::-;14034:29;;;;13968:63;14003:28;;;;13968:32;;;;:63;:::i;:::-;:95;;;;:::i;:::-;13929:27;;;;:134;13918:184;;14077:25;;;;;;;;;;;;;;13918:184;14228:30;;;;14160:65;14193:32;;;;14160:30;;;;:65;:::i;:::-;:98;;;;:::i;:::-;14120:28;;;;:138;14109:189;;14272:26;;;;;;;;;;;;;;16423:233;16514:7;16529:14;16546:32;16560:5;16567:10;;16546:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16546:13:91;;-1:-1:-1;;;16546:32:91:i;:::-;16529:49;-1:-1:-1;;;;;;16588:20:91;;16584:48;;16617:15;;;;;;;;;;;;;;16584:48;16645:6;16423:233;-1:-1:-1;;;;16423:233:91:o;2575:307:44:-;1899:1;2702:7;;:18;2698:86;;2743:30;;;;;;;;;;;;;;2698:86;1899:1;2858:7;:17;2575:307::o;9351:238:48:-;9452:7;9506:76;9522:26;9539:8;9522:16;:26::i;:::-;:59;;;;;9580:1;9565:11;9552:25;;;;;:::i;:::-;9562:1;9559;9552:25;:29;9522:59;34914:9:49;34907:17;;34795:145;9506:76:48;9478:25;9485:1;9488;9491:11;9478:6;:25::i;:::-;:104;;;;:::i;:::-;9471:111;9351:238;-1:-1:-1;;;;;9351:238:48:o;17073:1250:91:-;17445:17;17465;17475:6;17465:9;:17::i;:::-;17445:37;;17488:54;17506:7;17515:9;17526:15;17488:17;:54::i;:::-;17567:22;;;;;;;;:::i;:::-;-1:-1:-1;;;;;17553:36:91;:10;-1:-1:-1;;;;;17553:36:91;;17549:223;;17599:69;17617:22;;;;;;;;:::i;:::-;17641:9;17652:15;17599:17;:69::i;:::-;17549:223;;;17693:30;;;;:15;:30;:::i;:::-;:37;;17734:1;17693:42;17689:76;;17744:21;;;;;;;;;;;;;;17689:76;17777:59;17799:22;;;;;;;;:::i;:::-;17823:6;:12;;;17777:21;:59::i;:::-;17865:6;:18;;;17847:15;:36;17843:69;;;17892:20;;;;;;;;;;;;;;17843:69;17939:1;17922:14;:18;:61;;;;;17962:6;:20;;;17945:14;:37;17922:61;17918:93;;;17992:19;;;;;;;;;;;;;;17918:93;18018:28;18039:6;18018:20;:28::i;:::-;18053:34;18067:11;18080:6;18053:13;:34::i;:::-;18094:173;18122:11;18141:7;18173:1;18156:14;:18;:70;;;;-1:-1:-1;18196:30:91;;;;18178:48;;;18156:70;18234:6;18248:13;;18094:20;:173::i;:::-;18274:44;18296:7;18305:6;:12;;;18274:21;:44::i;:::-;17439:884;17073:1250;;;;;;;;;:::o;8812:1368:90:-;9164:40;9184:19;:6;;:19;:::i;:::-;9164;:40::i;:::-;9211:23;9237:60;9269:28;;;;9237:29;;;;:60;:::i;:::-;9211:86;;9304:15;-1:-1:-1;;;;;9304:30:90;;9342:150;;;;;;;;9380:6;:22;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9342:150:90;;;;;9412:4;-1:-1:-1;;;;;9342:150:90;;;;;9419:6;:20;;:25;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9342:150:90;;;;;9446:15;9342:150;;;;9463:21;9342:150;;;;;;;;:::i;:::-;;;;9304:194;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9505:15;-1:-1:-1;;;;;9505:30:90;;9543:155;;;;;;;;9581:6;:22;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9543:155:90;;;;;9605:6;:16;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9543:155:90;;;;;9623:6;:20;;:25;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9543:155:90;;;;;9650:17;9543:155;;;;9669:21;9543:155;;;;;;;;:::i;:::-;;;;9505:199;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9711:34;9731:13;;9711:19;:34::i;:::-;9752:15;-1:-1:-1;;;;;9752:30:90;;9790:138;;;;;;;;9828:7;-1:-1:-1;;;;;9790:138:90;;;;;9837:6;:13;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9790:138:90;;;;;9852:6;:21;;:26;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9790:138:90;;;;;9880:17;9790:138;;;;9899:21;9790:138;;;;;;;;:::i;:::-;;;;9752:182;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9941:39:90;;-1:-1:-1;9961:18:90;;-1:-1:-1;;9961:18:90;;;:6;:18;:::i;9941:39::-;9987:15;10012:25;;;;:20;;;:25;:::i;:::-;10005:58;;;;;10057:4;10005:58;;;1102:74:169;-1:-1:-1;;;;;10005:43:90;;;;;;;1075:18:169;;10005:58:90;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9987:76;-1:-1:-1;10074:12:90;;10070:106;;10096:73;10143:16;;;;;;;;:::i;:::-;10161:7;10103:6;:20;;:25;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10096:46:90;;:73;:46;:73::i;:::-;9158:1022;;8812:1368;;;;;;;;;:::o;18485:482:91:-;18673:22;;;;;;;;:::i;:::-;-1:-1:-1;;;;;18659:36:91;:10;-1:-1:-1;;;;;18659:36:91;;18655:237;;18705:83;18723:22;;;;;;;;:::i;:::-;18747:23;18763:6;18747:15;:23::i;:::-;18772:15;18705:17;:83::i;:::-;18655:237;;;18813:30;;;;:15;:30;:::i;:::-;:37;;18854:1;18813:42;18809:76;;18864:21;;;;;;;;;;;;;;18809:76;18897:65;18925:22;;;;;;;;:::i;:::-;18949:6;:12;;;18897:27;:65::i;:::-;18485:482;;:::o;10379:1484:90:-;10694:23;;;;10727;;;;;:70;;;10775:6;:22;;;10754:18;:43;10727:70;10723:216;;;10832:100;10844:18;10864:6;:23;;;10889:6;:22;;;10913:18;10832:11;:100::i;:::-;10807:125;;10723:216;10945:70;10966:7;10975:14;10991:6;10999:15;10945:20;:70::i;:::-;11022:15;-1:-1:-1;;;;;11022:30:90;;11060:297;;;;;;;;11098:6;:22;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11060:297:90;;;;;11130:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11060:297:90;;;;;11156:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11060:297:90;;;;;11182:23;;;:70;;;11230:6;:22;;;11209:18;:43;11182:70;:136;;11300:18;11182:136;;;11265:6;:22;;;11182:136;11060:297;;;;11328:21;11060:297;;;;;;;;:::i;:::-;;;;11022:341;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11370:15;-1:-1:-1;;;;;11370:30:90;;11408:110;;;;;;;;11437:7;-1:-1:-1;;;;;11408:110:90;;;;;11446:6;:13;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11408:110:90;;;;;11461:17;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11408:110:90;;;;;11480:14;11408:110;;;;11496:21;11408:110;;;;;;;;:::i;:::-;;;;11370:154;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11554:12:90;;-1:-1:-1;11554:6:90;;-1:-1:-1;11554:6:90;;-1:-1:-1;11554:12:90;:::i;:::-;11536:322;;;;;;;:::i;:::-;;;;;;;;;11574:6;:13;;;;;;;;;;:::i;:::-;11595:22;;;;;;;;:::i;:::-;11625:16;;;;;;;;:::i;:::-;11649:17;;;;;;;;:::i;:::-;11674:23;;;:70;;;11722:6;:22;;;11701:18;:43;11674:70;:132;;11788:18;11674:132;;;11755:6;:22;;;11674:132;11814:14;11836:6;:16;;;;;;;;;;:::i;:::-;11536:322;;;-1:-1:-1;;;;;18257:15:169;;;18239:34;;18309:15;;;18304:2;18289:18;;18282:43;18361:15;;;18341:18;;;18334:43;;;;18413:15;;;18408:2;18393:18;;18386:43;18460:3;18445:19;;18438:35;18504:3;18489:19;;18482:35;18554:15;;;18548:3;18533:19;;18526:44;18165:3;18150:19;11536:322:90;;;;;;;10663:1200;10379:1484;;;;;;:::o;20053:172:91:-;-1:-1:-1;;;;;20136:16:91;;:7;:16;;;;;;;;;;;:24;;;;;;;;;;;20132:51;;;20169:14;;;;;;;;;;;;;;20132:51;-1:-1:-1;;;;;20189:16:91;;;:7;:16;;;;;;;;;;;:24;;;;;;;:31;;;;20216:4;20189:31;;;20053:172::o;9090:497::-;9242:7;;;;9321:12;:8;9330:1;9321:8;;:12;:::i;:::-;9310:59;;;;;;;:::i;:::-;-1:-1:-1;9257:112:91;;-1:-1:-1;9257:112:91;-1:-1:-1;9257:112:91;-1:-1:-1;9388:25:91;;;;:20;;;:25;:::i;:::-;-1:-1:-1;;;;;9379:34:91;:5;-1:-1:-1;;;;;9379:34:91;;9375:61;;9422:14;;;;;;;;;;;;;;9375:61;9457:8;-1:-1:-1;;;;;9446:19:91;:7;-1:-1:-1;;;;;9446:19:91;;9442:47;;9474:15;;;;;;;;;;;;;;9442:47;9509:29;;;;9499:39;;9495:67;;9547:15;;;;;;;;;;;;;;9495:67;9576:6;9090:497;-1:-1:-1;;;;;;;9090:497:91:o;9799:589::-;9951:7;;;;;10053:12;:8;10062:1;10053:8;;:12;:::i;:::-;10042:62;;;;;;;:::i;:::-;9966:138;;-1:-1:-1;9966:138:91;;-1:-1:-1;9966:138:91;-1:-1:-1;9966:138:91;-1:-1:-1;10123:26:91;;;;:21;;;:26;:::i;:::-;-1:-1:-1;;;;;10114:35:91;:5;-1:-1:-1;;;;;10114:35:91;;10110:62;;10158:14;;;;;;;;;;;;;;10110:62;10193:8;-1:-1:-1;;;;;10182:19:91;:7;-1:-1:-1;;;;;10182:19:91;;10178:47;;10210:15;;;;;;;;;;;;;;10178:47;10247:13;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10235:25:91;:8;-1:-1:-1;;;;;10235:25:91;;10231:58;;10269:20;;;;;;;;;;;;;;10231:58;10309:30;;;;10299:40;;10295:68;;10348:15;;;;;;;;;;;;;;10295:68;10377:6;9799:589;-1:-1:-1;;;;;;;;9799:589:91:o;10633:953::-;10790:7;10799;10822:13;10843:16;10867:14;10889:17;10914:14;10936:18;10962:19;11001:8;;11010:1;11001:12;;;;;;;;;:::i;:::-;10990:89;;;;;;;:::i;:::-;10814:265;;-1:-1:-1;10814:265:91;;-1:-1:-1;10814:265:91;;-1:-1:-1;10814:265:91;-1:-1:-1;10814:265:91;-1:-1:-1;10814:265:91;-1:-1:-1;10814:265:91;-1:-1:-1;11098:26:91;;;;:21;;;:26;:::i;:::-;-1:-1:-1;;;;;11089:35:91;:5;-1:-1:-1;;;;;11089:35:91;;11085:62;;11133:14;;;;;;;;;;;;;;11085:62;11168:8;-1:-1:-1;;;;;11157:19:91;:7;-1:-1:-1;;;;;11157:19:91;;11153:47;;11185:15;;;;;;;;;;;;;;11153:47;-1:-1:-1;;;;;11210:23:91;;11228:4;11210:23;11206:51;;11242:15;;;;;;;;;;;;;;11206:51;11280:13;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11267:26:91;:9;-1:-1:-1;;;;;11267:26:91;;11263:59;;11302:20;;;;;;;;;;;;;;11263:59;11342:30;;;;11332:40;;11328:68;;11381:15;;;;;;;;;;;;;;11328:68;11420:25;;;;:20;;;:25;:::i;:::-;-1:-1:-1;;;;;11406:39:91;:10;-1:-1:-1;;;;;11406:39:91;;11402:66;;11454:14;;;;;;;;;;;;;;11402:66;11493:29;;;;11478:44;;11474:72;;11531:15;;;;;;;;;;;;;;11474:72;11561:6;;;;-1:-1:-1;10633:953:91;;-1:-1:-1;;;;;;;;;;10633:953:91:o;11796:488::-;11947:7;;;;12025:12;:8;12034:1;12025:8;;:12;:::i;:::-;12014:53;;;;;;;:::i;:::-;11962:105;;-1:-1:-1;11962:105:91;-1:-1:-1;11962:105:91;-1:-1:-1;12086:25:91;;;;:20;;;:25;:::i;:::-;-1:-1:-1;;;;;12077:34:91;:5;-1:-1:-1;;;;;12077:34:91;;12073:61;;12120:14;;;;;;;;;;;;;;12073:61;12155:8;-1:-1:-1;;;;;12144:19:91;:7;-1:-1:-1;;;;;12144:19:91;;12140:47;;12172:15;;;;;;;;;;;;;;12140:47;12207:28;;;;12197:38;;12193:66;;12244:15;;;;;;;;;;;;;;12500:602;12654:7;;;;;12758:12;:8;12767:1;12758:8;;:12;:::i;:::-;12747:68;;;;;;;:::i;:::-;-1:-1:-1;12669:146:91;;-1:-1:-1;12669:146:91;;-1:-1:-1;12669:146:91;-1:-1:-1;12669:146:91;-1:-1:-1;12834:26:91;;;;:21;;;:26;:::i;:::-;-1:-1:-1;;;;;12825:35:91;:5;-1:-1:-1;;;;;12825:35:91;;12821:62;;12869:14;;;;;;;;;;;;;;12821:62;12904:9;-1:-1:-1;;;;;12893:20:91;:7;-1:-1:-1;;;;;12893:20:91;;12889:48;;12922:15;;;;;;;;;;;;;;12889:48;12959:13;;;;;;;;:::i;:::-;-1:-1:-1;;;;;12947:25:91;:8;-1:-1:-1;;;;;12947:25:91;;12943:58;;12981:20;;;;;;;;;;;;;;12943:58;13021:32;;;;13011:42;;13007:70;;13062:15;;;;;;;;;;;;;;13259:466;13404:9;;13417:28;;;;13404:41;;;:88;;-1:-1:-1;13449:10:91;;;;13463:29;;;;13449:43;;13404:88;13400:153;;;13509:37;;;;;;;;;;;;;;13400:153;13563:12;;;;13579:32;;;;13563:48;;;:96;;-1:-1:-1;13615:10:91;;;;13629:30;;;;13615:44;;13563:96;13559:162;;;13676:38;;;;;;;;;;;;;;3714:255:45;3792:7;3812:17;3831:18;3851:16;3871:27;3882:4;3888:9;3871:10;:27::i;:::-;3811:87;;;;;;3908:28;3920:5;3927:8;3908:11;:28::i;:::-;-1:-1:-1;3953:9:45;;-1:-1:-1;;3714:255:45;;;;;:::o;29533:122:48:-;29601:4;29642:1;29630:8;29624:15;;;;;;;;:::i;:::-;:19;;;;:::i;:::-;:24;;29647:1;29624:24;29617:31;;29533:122;;;:::o;4996:4226::-;5078:14;5449:5;;;5078:14;5634:6;5453:1;5449;5621:20;5694:5;5690:2;5687:13;5679:5;5675:2;5671:14;5667:34;5658:43;;;5796:5;5805:1;5796:10;5792:368;;6134:11;6126:5;:19;;;;;:::i;:::-;;6119:26;;;;;;5792:368;6285:5;6270:11;:20;6266:143;;6310:84;3066:5;6330:16;;3065:36;940:4:43;3060:42:48;6310:11;:84::i;:::-;6664:17;6799:11;6796:1;6793;6786:25;7199:12;7229:15;;;7214:31;;7348:22;;;;;8094:1;8075;:15;;8074:21;;8327;;;8323:25;;8312:36;8397:21;;;8393:25;;8382:36;8469:21;;;8465:25;;8454:36;8540:21;;;8536:25;;8525:36;8613:21;;;8609:25;;8598:36;8687:21;;;8683:25;;;8672:36;7597:12;;;;7593:23;;;7618:1;7589:31;6913:20;;;6902:32;;;7709:12;;;;6960:21;;;;7446:16;;;;7700:21;;;;9163:15;;;;;-1:-1:-1;;4996:4226:48;;;;;:::o;8348:460:90:-;8452:9;8447:357;8463:24;;;8447:357;;;8502:41;8546:13;;8560:1;8546:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;8502:60;-1:-1:-1;;;;;;8605:15:90;8575:46;:18;;;;8502:60;8575:18;:::i;:::-;-1:-1:-1;;;;;8575:46:90;;8571:79;;8630:20;;;;;;;;;;;;;;8571:79;8658:36;8682:11;8658:23;:36::i;:::-;8720:18;;;;:11;:18;:::i;:::-;-1:-1:-1;;;;;8708:89:90;;8740:11;:17;;;8759:37;8784:11;8759:24;:37::i;:::-;8708:89;;;30953:25:169;;;31026:66;31014:79;;;31009:2;30994:18;;30987:107;30926:18;8708:89:90;;;;;;;-1:-1:-1;8489:3:90;;8447:357;;1219:160:39;1328:43;;;-1:-1:-1;;;;;31297:55:169;;1328:43:39;;;31279:74:169;31369:18;;;;31362:34;;;1328:43:39;;;;;;;;;;31252:18:169;;;;1328:43:39;;;;;;;;;;;;;;1301:71;;1321:5;;1301:19;:71::i;19109:500:91:-;19332:1;19315:14;:18;:61;;;;;19355:6;:20;;;19338:14;:37;19315:61;19311:93;;;19385:19;;;;;;;;;;;;;;19311:93;19410:68;19428:7;19437:23;19453:6;19437:15;:23::i;19410:68::-;19484:50;19512:7;19521:6;:12;;;19484:27;:50::i;:::-;19566:15;19544:6;:18;;;:37;19540:64;;19590:14;;;;;;;;;;;;;;2129:778:45;2232:17;2251:16;2269:14;2299:9;:16;2319:2;2299:22;2295:606;;2604:4;2589:20;;2583:27;2653:4;2638:20;;2632:27;2710:4;2695:20;;2689:27;2337:9;2681:36;2751:25;2762:4;2681:36;2583:27;2632;2751:10;:25::i;:::-;2744:32;;;;;;;;;;;2295:606;-1:-1:-1;;2872:16:45;;2823:1;;-1:-1:-1;2827:35:45;;2295:606;2129:778;;;;;:::o;7280:532::-;7375:20;7366:5;:29;;;;;;;;:::i;:::-;;7362:444;;7280:532;;:::o;7362:444::-;7471:29;7462:5;:38;;;;;;;;:::i;:::-;;7458:348;;7523:23;;;;;;;;;;;;;;7458:348;7576:35;7567:5;:44;;;;;;;;:::i;:::-;;7563:243;;7634:46;;;;;;;;1333:25:169;;;1306:18;;7634:46:45;;;;;;;;7563:243;7710:30;7701:5;:39;;;;;;;;:::i;:::-;;7697:109;;7763:32;;;;;;;;1333:25:169;;;1306:18;;7763:32:45;1187:177:169;1776:194:43;1881:10;1875:4;1868:24;1918:4;1912;1905:18;1949:4;1943;1936:18;582:989:72;649:14;666:18;;;;:11;:18;:::i;:::-;649:35;-1:-1:-1;706:17:72;;;;729:23;690:13;755:20;;;;706:11;755:20;:::i;:::-;729:46;;;;1305:4;1299:11;1366:15;1349;1330:17;1317:65;1465:1;1462;1445:15;1426:17;1419:5;1411:6;1404:5;1399:68;1389:172;;1500:16;1497:1;1494;1479:38;1536:16;1533:1;1526:27;1798:809;1874:13;1895:23;1874:13;1921:20;;;;:11;:20;:::i;:::-;1895:46;;-1:-1:-1;1895:46:72;-1:-1:-1;1970:1:72;1951:20;;1947:656;;2573:15;2560:29;2550:39;;1947:656;1889:718;;1798:809;;;:::o;8370:720:39:-;8450:18;8478:19;8616:4;8613:1;8606:4;8600:11;8593:4;8587;8583:15;8580:1;8573:5;8566;8561:60;8673:7;8663:176;;8717:4;8711:11;8762:16;8759:1;8754:3;8739:40;8808:16;8803:3;8796:29;8663:176;-1:-1:-1;;8916:1:39;8910:8;8866:16;;-1:-1:-1;8942:15:39;;:68;;8994:11;9009:1;8994:16;;8942:68;;;-1:-1:-1;;;;;8960:26:39;;;:31;8942:68;8938:146;;;9033:40;;;;;-1:-1:-1;;;;;1120:55:169;;9033:40:39;;;1102:74:169;1075:18;;9033:40:39;931:251:169;5203:1551:45;5329:17;;;6283:66;6270:79;;6266:164;;;-1:-1:-1;6381:1:45;;-1:-1:-1;6385:30:45;;-1:-1:-1;6417:1:45;6365:54;;6266:164;6541:24;;;6524:14;6541:24;;;;;;;;;31816:25:169;;;31889:4;31877:17;;31857:18;;;31850:45;;;;31911:18;;;31904:34;;;31954:18;;;31947:34;;;6541:24:45;;31788:19:169;;6541:24:45;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6541:24:45;;;;;;-1:-1:-1;;;;;;;6579:20:45;;6575:113;;-1:-1:-1;6631:1:45;;-1:-1:-1;6635:29:45;;-1:-1:-1;6631:1:45;;-1:-1:-1;6615:62:45;;6575:113;6706:6;-1:-1:-1;6714:20:45;;-1:-1:-1;6714:20:45;;-1:-1:-1;5203:1551:45;;;;;;;;;:::o;14:659:169:-;93:6;101;109;162:2;150:9;141:7;137:23;133:32;130:52;;;178:1;175;168:12;130:52;214:9;201:23;191:33;;275:2;264:9;260:18;247:32;298:18;339:2;331:6;328:14;325:34;;;355:1;352;345:12;325:34;393:6;382:9;378:22;368:32;;438:7;431:4;427:2;423:13;419:27;409:55;;460:1;457;450:12;409:55;500:2;487:16;526:2;518:6;515:14;512:34;;;542:1;539;532:12;512:34;587:7;582:2;573:6;569:2;565:15;561:24;558:37;555:57;;;608:1;605;598:12;555:57;639:2;635;631:11;621:21;;661:6;651:16;;;;;14:659;;;;;:::o;1369:163::-;1436:5;1481:3;1472:6;1467:3;1463:16;1459:26;1456:46;;;1498:1;1495;1488:12;1456:46;-1:-1:-1;1520:6:169;1369:163;-1:-1:-1;1369:163:169:o;1537:254::-;1631:6;1684:3;1672:9;1663:7;1659:23;1655:33;1652:53;;;1701:1;1698;1691:12;1652:53;1724:61;1777:7;1766:9;1724:61;:::i;1796:154::-;-1:-1:-1;;;;;1875:5:169;1871:54;1864:5;1861:65;1851:93;;1940:1;1937;1930:12;1955:134;2023:20;;2052:31;2023:20;2052:31;:::i;:::-;1955:134;;;:::o;2094:154::-;2152:5;2197:3;2188:6;2183:3;2179:16;2175:26;2172:46;;;2214:1;2211;2204:12;2253:380;2329:8;2339:6;2393:3;2386:4;2378:6;2374:17;2370:27;2360:55;;2411:1;2408;2401:12;2360:55;-1:-1:-1;2434:20:169;;2477:18;2466:30;;2463:50;;;2509:1;2506;2499:12;2463:50;2546:4;2538:6;2534:17;2522:29;;2606:3;2599:4;2589:6;2586:1;2582:14;2574:6;2570:27;2566:38;2563:47;2560:67;;;2623:1;2620;2613:12;2560:67;2253:380;;;;;:::o;2638:153::-;2696:5;2741:2;2732:6;2727:3;2723:16;2719:25;2716:45;;;2757:1;2754;2747:12;2796:162;2863:5;2908:2;2899:6;2894:3;2890:16;2886:25;2883:45;;;2924:1;2921;2914:12;2963:1853;3295:6;3303;3311;3319;3327;3335;3343;3351;3359;3412:3;3400:9;3391:7;3387:23;3383:33;3380:53;;;3429:1;3426;3419:12;3380:53;3452:29;3471:9;3452:29;:::i;:::-;3442:39;;3528:2;3517:9;3513:18;3500:32;3490:42;;3583:2;3572:9;3568:18;3555:32;3606:18;3647:2;3639:6;3636:14;3633:34;;;3663:1;3660;3653:12;3633:34;3686:65;3743:7;3734:6;3723:9;3719:22;3686:65;:::i;:::-;3676:75;;3804:2;3793:9;3789:18;3776:32;3760:48;;3833:2;3823:8;3820:16;3817:36;;;3849:1;3846;3839:12;3817:36;3888:85;3965:7;3954:8;3943:9;3939:24;3888:85;:::i;:::-;3992:8;;-1:-1:-1;3862:111:169;-1:-1:-1;4080:3:169;4065:19;;4052:33;;-1:-1:-1;4097:16:169;;;4094:36;;;4126:1;4123;4116:12;4094:36;4149:67;4208:7;4197:8;4186:9;4182:24;4149:67;:::i;:::-;4139:77;;4269:3;4258:9;4254:19;4241:33;4225:49;;4299:2;4289:8;4286:16;4283:36;;;4315:1;4312;4305:12;4283:36;4338:76;4406:7;4395:8;4384:9;4380:24;4338:76;:::i;:::-;4328:86;;4467:3;4456:9;4452:19;4439:33;4423:49;;4497:2;4487:8;4484:16;4481:36;;;4513:1;4510;4503:12;4481:36;4536:76;4604:7;4593:8;4582:9;4578:24;4536:76;:::i;:::-;4526:86;;4665:3;4654:9;4650:19;4637:33;4621:49;;4695:2;4685:8;4682:16;4679:36;;;4711:1;4708;4701:12;4679:36;;4734:76;4802:7;4791:8;4780:9;4776:24;4734:76;:::i;:::-;4724:86;;;2963:1853;;;;;;;;;;;:::o;4821:509::-;4936:6;4944;4997:2;4985:9;4976:7;4972:23;4968:32;4965:52;;;5013:1;5010;5003:12;4965:52;5052:9;5039:23;5071:31;5096:5;5071:31;:::i;:::-;5121:5;-1:-1:-1;5177:2:169;5162:18;;5149:32;5204:18;5193:30;;5190:50;;;5236:1;5233;5226:12;5190:50;5259:65;5316:7;5307:6;5296:9;5292:22;5259:65;:::i;:::-;5249:75;;;4821:509;;;;;:::o;5845:155::-;5904:5;5949:3;5940:6;5935:3;5931:16;5927:26;5924:46;;;5966:1;5963;5956:12;6005:1079;6197:6;6205;6213;6221;6229;6282:3;6270:9;6261:7;6257:23;6253:33;6250:53;;;6299:1;6296;6289:12;6250:53;6338:9;6325:23;6357:31;6382:5;6357:31;:::i;:::-;6407:5;-1:-1:-1;6463:2:169;6448:18;;6435:32;6486:18;6516:14;;;6513:34;;;6543:1;6540;6533:12;6513:34;6566:66;6624:7;6615:6;6604:9;6600:22;6566:66;:::i;:::-;6556:76;;6685:2;6674:9;6670:18;6657:32;6641:48;;6714:2;6704:8;6701:16;6698:36;;;6730:1;6727;6720:12;6698:36;6753:76;6821:7;6810:8;6799:9;6795:24;6753:76;:::i;:::-;6743:86;;6876:2;6865:9;6861:18;6848:32;6838:42;;6933:3;6922:9;6918:19;6905:33;6889:49;;6963:2;6953:8;6950:16;6947:36;;;6979:1;6976;6969:12;6947:36;;7002:76;7070:7;7059:8;7048:9;7044:24;7002:76;:::i;:::-;6992:86;;;6005:1079;;;;;;;;:::o;7089:180::-;7148:6;7201:2;7189:9;7180:7;7176:23;7172:32;7169:52;;;7217:1;7214;7207:12;7169:52;-1:-1:-1;7240:23:169;;7089:180;-1:-1:-1;7089:180:169:o;7274:118::-;7360:5;7353:13;7346:21;7339:5;7336:32;7326:60;;7382:1;7379;7372:12;7397:1161;7588:6;7596;7604;7612;7620;7628;7681:3;7669:9;7660:7;7656:23;7652:33;7649:53;;;7698:1;7695;7688:12;7649:53;7737:9;7724:23;7756:31;7781:5;7756:31;:::i;:::-;7806:5;-1:-1:-1;7863:2:169;7848:18;;7835:32;7876:33;7835:32;7876:33;:::i;:::-;7928:7;-1:-1:-1;7987:2:169;7972:18;;7959:32;8000:30;7959:32;8000:30;:::i;:::-;8049:7;-1:-1:-1;8107:2:169;8092:18;;8079:32;8130:18;8160:14;;;8157:34;;;8187:1;8184;8177:12;8157:34;8210:65;8267:7;8258:6;8247:9;8243:22;8210:65;:::i;:::-;8200:75;;8328:3;8317:9;8313:19;8300:33;8284:49;;8358:2;8348:8;8345:16;8342:36;;;8374:1;8371;8364:12;8342:36;;8413:85;8490:7;8479:8;8468:9;8464:24;8413:85;:::i;:::-;7397:1161;;;;-1:-1:-1;7397:1161:169;;-1:-1:-1;7397:1161:169;;8517:8;;7397:1161;-1:-1:-1;;;7397:1161:169:o;8563:574::-;8675:6;8683;8691;8744:2;8732:9;8723:7;8719:23;8715:32;8712:52;;;8760:1;8757;8750:12;8712:52;8799:9;8786:23;8818:31;8843:5;8818:31;:::i;:::-;8868:5;-1:-1:-1;8920:2:169;8905:18;;8892:32;;-1:-1:-1;8975:2:169;8960:18;;8947:32;9002:18;8991:30;;8988:50;;;9034:1;9031;9024:12;8988:50;9057:74;9123:7;9114:6;9103:9;9099:22;9057:74;:::i;:::-;9047:84;;;8563:574;;;;;:::o;9142:355::-;9228:6;9281:2;9269:9;9260:7;9256:23;9252:32;9249:52;;;9297:1;9294;9287:12;9249:52;9337:9;9324:23;9370:18;9362:6;9359:30;9356:50;;;9402:1;9399;9392:12;9356:50;9425:66;9483:7;9474:6;9463:9;9459:22;9425:66;:::i;9767:1602::-;10054:6;10062;10070;10078;10086;10094;10102;10110;10163:3;10151:9;10142:7;10138:23;10134:33;10131:53;;;10180:1;10177;10170:12;10131:53;10203:29;10222:9;10203:29;:::i;:::-;10193:39;;10279:2;10268:9;10264:18;10251:32;10241:42;;10334:2;10323:9;10319:18;10306:32;10357:18;10398:2;10390:6;10387:14;10384:34;;;10414:1;10411;10404:12;10384:34;10437:65;10494:7;10485:6;10474:9;10470:22;10437:65;:::i;:::-;10427:75;;10555:2;10544:9;10540:18;10527:32;10511:48;;10584:2;10574:8;10571:16;10568:36;;;10600:1;10597;10590:12;10568:36;10639:85;10716:7;10705:8;10694:9;10690:24;10639:85;:::i;:::-;10743:8;;-1:-1:-1;10613:111:169;-1:-1:-1;10831:3:169;10816:19;;10803:33;;-1:-1:-1;10848:16:169;;;10845:36;;;10877:1;10874;10867:12;10845:36;10900:67;10959:7;10948:8;10937:9;10933:24;10900:67;:::i;:::-;10890:77;;11020:3;11009:9;11005:19;10992:33;10976:49;;11050:2;11040:8;11037:16;11034:36;;;11066:1;11063;11056:12;11034:36;11089:76;11157:7;11146:8;11135:9;11131:24;11089:76;:::i;:::-;11079:86;;11218:3;11207:9;11203:19;11190:33;11174:49;;11248:2;11238:8;11235:16;11232:36;;;11264:1;11261;11254:12;11232:36;;11287:76;11355:7;11344:8;11333:9;11329:24;11287:76;:::i;:::-;11277:86;;;9767:1602;;;;;;;;;;;:::o;11374:1269::-;11611:6;11619;11627;11635;11643;11651;11704:3;11692:9;11683:7;11679:23;11675:33;11672:53;;;11721:1;11718;11711:12;11672:53;11744:29;11763:9;11744:29;:::i;:::-;11734:39;;11824:2;11813:9;11809:18;11796:32;11847:18;11888:2;11880:6;11877:14;11874:34;;;11904:1;11901;11894:12;11874:34;11927:66;11985:7;11976:6;11965:9;11961:22;11927:66;:::i;:::-;11917:76;;12046:2;12035:9;12031:18;12018:32;12002:48;;12075:2;12065:8;12062:16;12059:36;;;12091:1;12088;12081:12;12059:36;12114:76;12182:7;12171:8;12160:9;12156:24;12114:76;:::i;:::-;12104:86;;12237:2;12226:9;12222:18;12209:32;12199:42;;12294:3;12283:9;12279:19;12266:33;12250:49;;12324:2;12314:8;12311:16;12308:36;;;12340:1;12337;12330:12;12308:36;12363:76;12431:7;12420:8;12409:9;12405:24;12363:76;:::i;:::-;12353:86;;12492:3;12481:9;12477:19;12464:33;12448:49;;12522:2;12512:8;12509:16;12506:36;;;12538:1;12535;12528:12;12506:36;;12561:76;12629:7;12618:8;12607:9;12603:24;12561:76;:::i;:::-;12551:86;;;11374:1269;;;;;;;;:::o;12648:353::-;12733:6;12786:2;12774:9;12765:7;12761:23;12757:32;12754:52;;;12802:1;12799;12792:12;12754:52;12842:9;12829:23;12875:18;12867:6;12864:30;12861:50;;;12907:1;12904;12897:12;12861:50;12930:65;12987:7;12978:6;12967:9;12963:22;12930:65;:::i;13237:245::-;13304:6;13357:2;13345:9;13336:7;13332:23;13328:32;13325:52;;;13373:1;13370;13363:12;13325:52;13405:9;13399:16;13424:28;13446:5;13424:28;:::i;14004:247::-;14063:6;14116:2;14104:9;14095:7;14091:23;14087:32;14084:52;;;14132:1;14129;14122:12;14084:52;14171:9;14158:23;14190:31;14215:5;14190:31;:::i;14845:325::-;14933:6;14928:3;14921:19;14985:6;14978:5;14971:4;14966:3;14962:14;14949:43;;15037:1;15030:4;15021:6;15016:3;15012:16;15008:27;15001:38;14903:3;15159:4;15089:66;15084:2;15076:6;15072:15;15068:88;15063:3;15059:98;15055:109;15048:116;;14845:325;;;;:::o;15175:167::-;15242:20;;15302:14;15291:26;;15281:37;;15271:65;;15332:1;15329;15322:12;15347:1365;15593:4;-1:-1:-1;;;;;15703:2:169;15695:6;15691:15;15680:9;15673:34;15755:2;15747:6;15743:15;15738:2;15727:9;15723:18;15716:43;;15795:6;15790:2;15779:9;15775:18;15768:34;15838:3;15833:2;15822:9;15818:18;15811:31;15890:6;15877:20;15973:66;15964:6;15948:14;15944:27;15940:100;15920:18;15916:125;15906:153;;16055:1;16052;16045:12;15906:153;16081:31;;16189:2;16178:14;;;16135:19;16215:18;16204:30;;16201:50;;;16247:1;16244;16237:12;16201:50;16296:6;16280:14;16276:27;16267:7;16263:41;16260:61;;;16317:1;16314;16307:12;16260:61;16358:2;16352:3;16341:9;16337:19;16330:31;16384:63;16442:3;16431:9;16427:19;16419:6;16410:7;16384:63;:::i;:::-;16370:77;;;16476:34;16506:2;16498:6;16494:15;16476:34;:::i;:::-;16529:14;16598:2;16584:12;16580:21;16574:3;16563:9;16559:19;16552:50;16679:2;16643:34;16673:2;16665:6;16661:15;16643:34;:::i;:::-;16639:43;16633:3;16622:9;16618:19;16611:72;;;16700:6;16692:14;;;15347:1365;;;;;;;:::o;16717:277::-;16797:6;16850:2;16838:9;16829:7;16825:23;16821:32;16818:52;;;16866:1;16863;16856:12;16818:52;16905:9;16892:23;16944:1;16937:5;16934:12;16924:40;;16960:1;16957;16950:12;16999:581;17077:4;17083:6;17143:11;17130:25;17233:66;17222:8;17206:14;17202:29;17198:102;17178:18;17174:127;17164:155;;17315:1;17312;17305:12;17164:155;17342:33;;17394:20;;;-1:-1:-1;17437:18:169;17426:30;;17423:50;;;17469:1;17466;17459:12;17423:50;17502:4;17490:17;;-1:-1:-1;17533:14:169;17529:27;;;17519:38;;17516:58;;;17570:1;17567;17560:12;17585:273;17770:6;17762;17757:3;17744:33;17726:3;17796:16;;17821:13;;;17796:16;17585:273;-1:-1:-1;17585:273:169:o;18581:629::-;18699:4;18705:6;18765:11;18752:25;18855:66;18844:8;18828:14;18824:29;18820:102;18800:18;18796:127;18786:155;;18937:1;18934;18927:12;18786:155;18964:33;;19016:20;;;-1:-1:-1;19059:18:169;19048:30;;19045:50;;;19091:1;19088;19081:12;19045:50;19124:4;19112:17;;-1:-1:-1;19175:1:169;19171:14;;;19155;19151:35;19141:46;;19138:66;;;19200:1;19197;19190:12;19215:184;19267:77;19264:1;19257:88;19364:4;19361:1;19354:15;19388:4;19385:1;19378:15;19404:381;19495:4;19553:11;19540:25;19643:66;19632:8;19616:14;19612:29;19608:102;19588:18;19584:127;19574:155;;19725:1;19722;19715:12;19574:155;19746:33;;;;;19404:381;-1:-1:-1;;19404:381:169:o;20375:279::-;20440:9;;;20461:10;;;20458:190;;;20504:77;20501:1;20494:88;20605:4;20602:1;20595:15;20633:4;20630:1;20623:15;20659:184;20711:77;20708:1;20701:88;20808:4;20805:1;20798:15;20832:4;20829:1;20822:15;20848:266;20917:6;20970:2;20958:9;20949:7;20945:23;20941:32;20938:52;;;20986:1;20983;20976:12;20938:52;21025:9;21012:23;21064:1;21057:5;21054:12;21044:40;;21080:1;21077;21070:12;21119:315;21304:6;21293:9;21286:25;21347:2;21342;21331:9;21327:18;21320:30;21267:4;21367:61;21424:2;21413:9;21409:18;21401:6;21393;21367:61;:::i;21439:336::-;21508:6;21561:2;21549:9;21540:7;21536:23;21532:32;21529:52;;;21577:1;21574;21567:12;21529:52;21609:9;21603:16;21659:66;21652:5;21648:78;21641:5;21638:89;21628:117;;21741:1;21738;21731:12;21780:246;21939:2;21928:9;21921:21;21902:4;21959:61;22016:2;22005:9;22001:18;21993:6;21985;21959:61;:::i;23257:322::-;23298:3;23336:5;23330:12;23360:1;23370:128;23384:6;23381:1;23378:13;23370:128;;;23481:4;23466:13;;;23462:24;;23456:31;23443:11;;;23436:52;23399:12;23370:128;;;-1:-1:-1;23553:1:169;23517:16;;23542:13;;;-1:-1:-1;23517:16:169;;23257:322;-1:-1:-1;23257:322:169:o;23584:261::-;23759:3;23784:55;23809:29;23834:3;23826:6;23809:29;:::i;:::-;23801:6;23784:55;:::i;25071:350::-;25256:3;25287:29;25312:3;25304:6;25287:29;:::i;:::-;25325:21;;;-1:-1:-1;;25373:2:169;25362:14;;25355:30;25412:2;25401:14;;25071:350;-1:-1:-1;25071:350:169:o;25426:184::-;25478:77;25475:1;25468:88;25575:4;25572:1;25565:15;25599:4;25596:1;25589:15;25615:844;25769:4;25811:3;25800:9;25796:19;25788:27;;-1:-1:-1;;;;;25922:2:169;25913:6;25907:13;25903:22;25892:9;25885:41;25994:2;25986:4;25978:6;25974:17;25968:24;25964:33;25957:4;25946:9;25942:20;25935:63;26066:2;26058:4;26050:6;26046:17;26040:24;26036:33;26029:4;26018:9;26014:20;26007:63;;26126:4;26118:6;26114:17;26108:24;26101:4;26090:9;26086:20;26079:54;26180:4;26172:6;26168:17;26162:24;26222:1;26208:12;26205:19;26195:207;;26258:77;26255:1;26248:88;26359:4;26356:1;26349:15;26387:4;26384:1;26377:15;26195:207;26440:12;26433:4;26422:9;26418:20;26411:42;;25615:844;;;;:::o;26464:184::-;26534:6;26587:2;26575:9;26566:7;26562:23;26558:32;26555:52;;;26603:1;26600;26593:12;26555:52;-1:-1:-1;26626:16:169;;26464:184;-1:-1:-1;26464:184:169:o;26653:331::-;26758:9;26769;26811:8;26799:10;26796:24;26793:44;;;26833:1;26830;26823:12;26793:44;26862:6;26852:8;26849:20;26846:40;;;26882:1;26879;26872:12;26846:40;-1:-1:-1;;26908:23:169;;;26953:25;;;;;-1:-1:-1;26653:331:169:o;26989:608::-;27088:6;27096;27104;27112;27165:3;27153:9;27144:7;27140:23;27136:33;27133:53;;;27182:1;27179;27172:12;27133:53;27221:9;27208:23;27240:31;27265:5;27240:31;:::i;:::-;27290:5;-1:-1:-1;27347:2:169;27332:18;;27319:32;27360:33;27319:32;27360:33;:::i;:::-;27412:7;-1:-1:-1;27466:2:169;27451:18;;27438:32;;-1:-1:-1;27522:2:169;27507:18;;27494:32;27535:30;27494:32;27535:30;:::i;:::-;26989:608;;;;-1:-1:-1;26989:608:169;;-1:-1:-1;;26989:608:169:o;27602:622::-;27712:6;27720;27728;27736;27789:3;27777:9;27768:7;27764:23;27760:33;27757:53;;;27806:1;27803;27796:12;27757:53;27845:9;27832:23;27864:31;27889:5;27864:31;:::i;:::-;27914:5;-1:-1:-1;27971:2:169;27956:18;;27943:32;27984:33;27943:32;27984:33;:::i;:::-;28036:7;-1:-1:-1;28095:2:169;28080:18;;28067:32;28108:33;28067:32;28108:33;:::i;:::-;27602:622;;;;-1:-1:-1;28160:7:169;;28214:2;28199:18;28186:32;;-1:-1:-1;;27602:622:169:o;28229:991::-;28382:6;28390;28398;28406;28414;28422;28430;28483:3;28471:9;28462:7;28458:23;28454:33;28451:53;;;28500:1;28497;28490:12;28451:53;28539:9;28526:23;28558:31;28583:5;28558:31;:::i;:::-;28608:5;-1:-1:-1;28665:2:169;28650:18;;28637:32;28678:33;28637:32;28678:33;:::i;:::-;28730:7;-1:-1:-1;28789:2:169;28774:18;;28761:32;28802:33;28761:32;28802:33;:::i;:::-;28854:7;-1:-1:-1;28913:2:169;28898:18;;28885:32;28926:33;28885:32;28926:33;:::i;:::-;28978:7;-1:-1:-1;29032:3:169;29017:19;;29004:33;;-1:-1:-1;29089:3:169;29074:19;;29061:33;29103;29061;29103;:::i;:::-;29155:7;29145:17;;;29209:3;29198:9;29194:19;29181:33;29171:43;;28229:991;;;;;;;;;;:::o;29225:472::-;29318:6;29326;29334;29387:2;29375:9;29366:7;29362:23;29358:32;29355:52;;;29403:1;29400;29393:12;29355:52;29442:9;29429:23;29461:31;29486:5;29461:31;:::i;:::-;29511:5;-1:-1:-1;29568:2:169;29553:18;;29540:32;29581:33;29540:32;29581:33;:::i;:::-;29225:472;;29633:7;;-1:-1:-1;;;29687:2:169;29672:18;;;;29659:32;;29225:472::o;29702:758::-;29818:6;29826;29834;29842;29850;29903:3;29891:9;29882:7;29878:23;29874:33;29871:53;;;29920:1;29917;29910:12;29871:53;29959:9;29946:23;29978:31;30003:5;29978:31;:::i;:::-;30028:5;-1:-1:-1;30085:2:169;30070:18;;30057:32;30098:33;30057:32;30098:33;:::i;:::-;30150:7;-1:-1:-1;30209:2:169;30194:18;;30181:32;30222:33;30181:32;30222:33;:::i;:::-;30274:7;-1:-1:-1;30328:2:169;30313:18;;30300:32;;-1:-1:-1;30384:3:169;30369:19;;30356:33;30398:30;30356:33;30398:30;:::i;:::-;30447:7;30437:17;;;29702:758;;;;;;;;:::o;30465:311::-;30495:1;30529:4;30526:1;30522:12;30553:3;30543:191;;30590:77;30587:1;30580:88;30691:4;30688:1;30681:15;30719:4;30716:1;30709:15;30543:191;30766:3;30759:4;30756:1;30752:12;30748:22;30743:27;;;30465:311;;;;:::o",
+    "linkReferences": {},
+    "immutableReferences": {
+      "65518": [
+        {
+          "start": 824,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidDestination",
-            "inputs": []
+          "start": 1042,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidEIP1271Signature",
-            "inputs": []
+          "start": 1703,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidEIP712Signature",
-            "inputs": []
+          "start": 5408,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidETHSignSignature",
-            "inputs": []
+          "start": 5631,
+          "length": 32
+        }
+      ],
+      "65523": [
+        {
+          "start": 407,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidFillAmount",
-            "inputs": []
+          "start": 1978,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidHooksTarget",
-            "inputs": []
+          "start": 6284,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidInteractionsBaseTokenAmounts",
-            "inputs": []
+          "start": 7724,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidInteractionsQuoteTokenAmounts",
-            "inputs": []
+          "start": 7966,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidLendingPoolInteraction",
-            "inputs": []
+          "start": 8236,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidQuoteTokenAmounts",
-            "inputs": []
+          "start": 8971,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidSignatureType",
-            "inputs": []
+          "start": 9255,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidSigner",
-            "inputs": []
+          "start": 12348,
+          "length": 32
+        }
+      ],
+      "65528": [
+        {
+          "start": 599,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "InvalidSource",
-            "inputs": []
+          "start": 1924,
+          "length": 32
         },
         {
-            "type": "error",
-            "name": "NonceInvalid",
-            "inputs": []
+          "start": 5852,
+          "length": 32
+        }
+      ],
+      "66488": [
+        {
+          "start": 1444,
+          "length": 32
+        }
+      ],
+      "66490": [
+        {
+          "start": 1242,
+          "length": 32
+        }
+      ]
+    }
+  },
+  "methodIdentifiers": {
+    "AUTHENTICATOR()": "c6186181",
+    "BALANCE_MANAGER()": "29bcdc95",
+    "DOMAIN_SEPARATOR()": "3644e515",
+    "REPOSITORY()": "6f35d2d2",
+    "cancelLimitOrder(uint256)": "a5cdc8fc",
+    "hashBaseTokenData((address,uint256,uint256,uint256,uint256))": "875530ff",
+    "hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": "e242924e",
+    "hashQuoteTokenData((address,uint256,uint256,uint256,uint256))": "4c9e03d3",
+    "hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))": "b11f1262",
+    "isValidSignature(bytes32,bytes)": "1626ba7e",
+    "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))": "cba673a7",
+    "settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))": "9935c868",
+    "settleSingleWithPermitsSignatures(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes),(bytes,uint48,uint48))": "db587728",
+    "settleWithPermitsSignatures(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes),(bytes,uint48,uint48))": "51d46815",
+    "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))": "5aa0e95d",
+    "validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])": "a7ab49bc",
+    "validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": "fa5cd56c",
+    "validateSignature(address,bytes32,(uint8,uint8,bytes))": "ae80c584"
+  },
+  "rawMetadata": "{\"compiler\":{\"version\":\"0.8.23+commit.f704f362\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract IAllowListAuthentication\",\"name\":\"authenticator_\",\"type\":\"address\"},{\"internalType\":\"contract IRepository\",\"name\":\"repository_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"permit2_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ECDSAInvalidSignature\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"ECDSAInvalidSignatureLength\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"ECDSAInvalidSignatureS\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAsset\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidBaseTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidDestination\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidEIP1271Signature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidEIP712Signature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidETHSignSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFillAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidHooksTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInteractionsBaseTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInteractionsQuoteTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLendingPoolInteraction\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidQuoteTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignatureType\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSigner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSource\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonceInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotMaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotSolver\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PartialFillNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReceiverNotManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SignatureIsExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SignatureIsNotEmpty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpdatedMakerAmountsTooLow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroMakerAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"Interaction\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TradeOrder\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"AUTHENTICATOR\",\"outputs\":[{\"internalType\":\"contract IAllowListAuthentication\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BALANCE_MANAGER\",\"outputs\":[{\"internalType\":\"contract IBalanceManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REPOSITORY\",\"outputs\":[{\"internalType\":\"contract IRepository\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"cancelLimitOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"_baseTokenData\",\"type\":\"tuple\"}],\"name\":\"hashBaseTokenData\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"_quoteTokenData\",\"type\":\"tuple\"}],\"name\":\"hashQuoteTokenData\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ILiquoriceSettlement.Single\",\"name\":\"_order\",\"type\":\"tuple\"}],\"name\":\"hashSingleOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_hash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"_signature\",\"type\":\"bytes\"}],\"name\":\"isValidSignature\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"_interactions\",\"type\":\"tuple[]\"},{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"beforeSettle\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"afterSettle\",\"type\":\"tuple[]\"}],\"internalType\":\"struct GPv2Interaction.Hooks\",\"name\":\"_hooks\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"}],\"name\":\"settle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ILiquoriceSettlement.Single\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"}],\"name\":\"settleSingle\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ILiquoriceSettlement.Single\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint48\",\"name\":\"nonce\",\"type\":\"uint48\"},{\"internalType\":\"uint48\",\"name\":\"deadline\",\"type\":\"uint48\"}],\"internalType\":\"struct Signature.TakerPermitInfo\",\"name\":\"_takerPermitInfo\",\"type\":\"tuple\"}],\"name\":\"settleSingleWithPermitsSignatures\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"_interactions\",\"type\":\"tuple[]\"},{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"beforeSettle\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"afterSettle\",\"type\":\"tuple[]\"}],\"internalType\":\"struct GPv2Interaction.Hooks\",\"name\":\"_hooks\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint48\",\"name\":\"nonce\",\"type\":\"uint48\"},{\"internalType\":\"uint48\",\"name\":\"deadline\",\"type\":\"uint48\"}],\"internalType\":\"struct Signature.TakerPermitInfo\",\"name\":\"_takerPermitInfo\",\"type\":\"tuple\"}],\"name\":\"settleWithPermitsSignatures\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IRepository\",\"name\":\"_repository\",\"type\":\"address\"},{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"beforeSettle\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"afterSettle\",\"type\":\"tuple[]\"}],\"internalType\":\"struct GPv2Interaction.Hooks\",\"name\":\"_hooks\",\"type\":\"tuple\"}],\"name\":\"validateHooks\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IRepository\",\"name\":\"_repository\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_isPartialFill\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"_interactions\",\"type\":\"tuple[]\"}],\"name\":\"validateInteractions\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"}],\"name\":\"validateOrderAmounts\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_validationAddress\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_hash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_signature\",\"type\":\"tuple\"}],\"name\":\"validateSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"ECDSAInvalidSignature()\":[{\"details\":\"The signature derives the `address(0)`.\"}],\"ECDSAInvalidSignatureLength(uint256)\":[{\"details\":\"The signature has an invalid length.\"}],\"ECDSAInvalidSignatureS(bytes32)\":[{\"details\":\"The signature has an S value that is in the upper half order.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"Interaction(address,uint256,bytes4)\":{\"params\":{\"selector\":\"Selector of the interaction function\",\"target\":\"Address of the interaction target\",\"value\":\"Value associated with the interaction\"}}},\"kind\":\"dev\",\"methods\":{\"cancelLimitOrder(uint256)\":{\"params\":{\"nonce\":\"Nonce of the order to be canceled\"}},\"hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"params\":{\"_order\":\"Order data to hash\"},\"returns\":{\"_0\":\"bytes32 Hash of the order\"}},\"hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))\":{\"params\":{\"_order\":\"Single order data to hash\"},\"returns\":{\"_0\":\"bytes32 Hash of the single order\"}},\"isValidSignature(bytes32,bytes)\":{\"params\":{\"_hash\":\"Hash of the data\",\"_signature\":\"Signature to validate\"},\"returns\":{\"_0\":\"Magic value if signature is valid, otherwise 0xffffffff\"}},\"settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))\":{\"params\":{\"_filledTakerAmount\":\"Amount filled by the taker\",\"_hooks\":\"Hooks to be called before and after settlement\",\"_interactions\":\"Array of interaction data to be executed during settlement\",\"_makerSignature\":\"Typed signature of the maker\",\"_order\":\"Order data\",\"_signer\":\"Address that signed the order\",\"_takerSignature\":\"Typed signature of the taker\"}},\"settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))\":{\"params\":{\"_filledTakerAmount\":\"Amount filled by the taker\",\"_makerSignature\":\"Signature of the maker\",\"_order\":\"Single order data\",\"_signer\":\"Address that signed the order\",\"_takerSignature\":\"Signature of the taker\"}},\"validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))\":{\"params\":{\"_hooks\":\"Hooks data\",\"_repository\":\"Repository interface\"}},\"validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])\":{\"params\":{\"_interactions\":\"Array of interaction data\",\"_order\":\"Order data\",\"_repository\":\"Repository interface\",\"_signer\":\"Signer address\"}},\"validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"params\":{\"_order\":\"Order data\"}},\"validateSignature(address,bytes32,(uint8,uint8,bytes))\":{\"params\":{\"_hash\":\"Hash of the data\",\"_signature\":\"Signature data\",\"_validationAddress\":\"Address to validate against\"}}},\"title\":\"Liquorice Settlement Contract\",\"version\":1},\"userdoc\":{\"events\":{\"Interaction(address,uint256,bytes4)\":{\"notice\":\"Emitted when an interaction is executed\"}},\"kind\":\"user\",\"methods\":{\"AUTHENTICATOR()\":{\"notice\":\"Authenticator for verifying solvers and makers\"},\"BALANCE_MANAGER()\":{\"notice\":\"Manager for handling balance transfers\"},\"REPOSITORY()\":{\"notice\":\"Repository that stores data for Lending Pools\"},\"cancelLimitOrder(uint256)\":{\"notice\":\"Cancels a limit order by invalidating its nonce\"},\"hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"notice\":\"Computes the hash of an order\"},\"hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))\":{\"notice\":\"Computes the hash of a single order\"},\"isValidSignature(bytes32,bytes)\":{\"notice\":\"Validates a signature\"},\"settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))\":{\"notice\":\"Settles a signed order with the given interactions and hooks\"},\"settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))\":{\"notice\":\"Settles a single order\"},\"validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))\":{\"notice\":\"Validates hooks for an order\"},\"validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])\":{\"notice\":\"Validates interactions for an order\"},\"validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"notice\":\"Validates the amounts in an order\"},\"validateSignature(address,bytes32,(uint8,uint8,bytes))\":{\"notice\":\"Validates a signature\"}},\"notice\":\"Handles settlement of orders and interactions\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/contracts/settlement/LiquoriceSettlement.sol\":\"LiquoriceSettlement\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[\":@chainlink/=lib/chainlink/contracts/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/\",\":chainlink/=lib/chainlink/\",\":contracts/=src/contracts/\",\":ds-test/=node_modules/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/\",\":interfaces/=src/interfaces/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/\",\":openzeppelin-upgrades/=lib/openzeppelin-upgrades/\",\":solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/\"]},\"sources\":{\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol\":{\"keccak256\":\"0xc92e946b954f185c3ca5ee56f9721aa73d64464456a46459384cb0ccf3c3856e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ae178b4e7b259557d8b93f3dd4f6f909ac72f914a9e92676e59b8d737f0423e2\",\"dweb:/ipfs/QmXeqyUJYzn6w8wyivQAtSzmwwFQnHaFYPvGad66RW1sPf\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol\":{\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://da62d6be1f5c6edf577f0cb45666a8aa9c2086a4bac87d95d65f02e2f4c36a4b\",\"dweb:/ipfs/QmNkpvBpoCMvX8JwAFNSc5XxJ2q5BXJpL5L1txb4QkqVFF\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a\",\"dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba\",\"dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x6dd0cb67846da3fa1241c520faaa215d6bec8226e37beac6056c51e8af44d24e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://650e533e62b30dcc6edea2b6c91358d5659da3bde42e56adf7316c493b916a15\",\"dweb:/ipfs/QmYkmK2vPE6FjdAoQVpZSJxamTLGno9wzGS495TcMNFViV\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Panic.sol\":{\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a\",\"dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a\",\"dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9\",\"dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x6f61a65c733690afafb4cf528b5677e704828c8350b60b948dbc1d3bb6d7689c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://00265b985b303af62ee243e10db819fa8cf890d9f122f82f4f03f55b02f62654\",\"dweb:/ipfs/QmNneFqZn2uKK6dECxatH6aENk1EMCTETi58dGaz5NCWQe\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol\":{\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8\",\"dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy\"]},\"src/contracts/lib/GPv2Interaction.sol\":{\"keccak256\":\"0x55968a83f6ae3d8d806b8faf02360abc676fb7476d05f33c0c9d324e6336fd0f\",\"license\":\"LGPL-3.0-or-later\",\"urls\":[\"bzz-raw://2d813e60c3fa006d02c8fd1aed73d2d47f9f153ac3c410d408384f3084e46de3\",\"dweb:/ipfs/QmdNyQMmyscMH6CVUkhQQfGdKdxgqhqDEe5K4iwrvcWDsk\"]},\"src/contracts/lib/Signature.sol\":{\"keccak256\":\"0xc084fe793244e2e7b0f4a51440df7dbf97d39b4ad6450a2b8a082cb6d86993b5\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://9bff9732e68149a83f2e044c7f1700432997750166cd15f4a54f73bd68a475aa\",\"dweb:/ipfs/QmZJMNppHQ3nUDcJhAkrMYa4QWhGLDr4Tzah6LndgrDCib\"]},\"src/contracts/settlement/BalanceManager.sol\":{\"keccak256\":\"0x82d5d0de5cf88ff8882f1f7a2d05b98ed32bb3f2a6b9eab728ce55ae943e67c3\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://ebcbe822ad5c68896a12ecd60e17ba6a2ed0ba8e0544c7ad54d88d1c25206b5c\",\"dweb:/ipfs/QmYEZeKUEz7Nw6MW9uZHnXvkeRTmmcS1WZhx77s9kUWSWw\"]},\"src/contracts/settlement/LiquoriceSettlement.sol\":{\"keccak256\":\"0xcac528919829fc8e021cec4325b38835866a7d0630b61349deae6ecfbe0ddaef\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://6d6dafbba3885b42cb97be6d190ac1f611548ceb2116e9b6ed7da9bf422c8b58\",\"dweb:/ipfs/QmZQk6WQNgYqsu9Z85tPF2VQGXgaYzvpEqc7VEmJ4zEEJU\"]},\"src/contracts/settlement/Signing.sol\":{\"keccak256\":\"0xad9e59ae740627e5b71fa1ebde019999084480664d06d18f0a01e4d31fa32ef6\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://ea0e0021cd0074292b04f9921f6ca3cc77a6799c86cacabb9dc6ff7dadbd7933\",\"dweb:/ipfs/QmPjY69PntfUGW5eNrNe98DCTemq6daRqUiLFkcYvVWuvh\"]},\"src/interfaces/IACLManager.sol\":{\"keccak256\":\"0xeee5cbedcfaff01733979b8f439a817aa67b09d9e330d21e11f180dceebed024\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://814431cd9df23d0d7cc0f9761927e2aa18fc7fa599f34422f332ee6352580d69\",\"dweb:/ipfs/QmXLdGsdMyeX5j64rAaByz35SwEMPMQ7usXwruWjEPo6Cz\"]},\"src/interfaces/IAllowListAuthentication.sol\":{\"keccak256\":\"0xbabb9eda80757d9355ab9863fccb3fdb1f15c1cbce458c3236d792d007077a9e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fa97e90b315ffc3cae3998adda6810c856ea96be015e797723e13b436d1a10\",\"dweb:/ipfs/Qme1dzXXcMDQpeqyqfuSbZDY6GKWjyrRBQrNDjitPeXQEF\"]},\"src/interfaces/IBalanceManager.sol\":{\"keccak256\":\"0xc4cff6f33170df6d91a866ee69263c9b90091e94027bea04038558c315e6e127\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://867164a381fb78da320c89db6b15978becd49be61e2349abc805362904bffb4e\",\"dweb:/ipfs/QmPY9UYCi9YVdCC8A1UxmTPcnV5BmMj93Gq1nqxBv4fMJ7\"]},\"src/interfaces/IInterestRateModel.sol\":{\"keccak256\":\"0xccd4c1dea98176c392de07cb8f5a2ac969405090d42d831310fa53464c0d9264\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a22b5b87be29e616142b6c4677e109e9246157c4b7e6378334fbc7ba403d82de\",\"dweb:/ipfs/QmXmSF34VsktTfqSCJU8Mz9sTaXGVk7xdYQwr9NcsR3k43\"]},\"src/interfaces/ILiquoriceSettlement.sol\":{\"keccak256\":\"0xa4a36d51f174d9994c39287f89e63bbea57ff5adcd2a9bc649c67bb5cae75272\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8562fe9fc033c3e3320c5d95ad10e49f5e23ea50a5e9eaf186cbf53d9f1ce7a6\",\"dweb:/ipfs/QmXKSjRi8oxmS5xd5V95HofYtFzYfehbL6s8t2MKoXR7y1\"]},\"src/interfaces/IPriceProvider.sol\":{\"keccak256\":\"0x75812be8d692287010f5ee9ce13556df1bd8299faa64b42c49cd08cf7cc53847\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://623d4faa57b078a33a2afe0d13fc426c4a750ae7f07f9d826000047dab54148e\",\"dweb:/ipfs/QmYmFpZnLug6FBG9C8s1mxPBjZHwiCk7cRBC7A9WXtyGKE\"]},\"src/interfaces/IRepository.sol\":{\"keccak256\":\"0xf08a5812ce10042564d518994db487c49d9f35d511da07a5103b9b886b6e2607\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b602c9f5a61c9796f711330ee56d4f0287adc656c686acf391d4e8c45453e6d0\",\"dweb:/ipfs/QmQ7XJ1qERgRxWurpkS3t1XDtuBUTpQEz14h4eXBc8vp9t\"]},\"src/interfaces/external/permit/IAllowanceTransfer.sol\":{\"keccak256\":\"0x23986b17f0c10296cb8afadb43014cd7901f56dac5ba85067d18ca7db7d3e37e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5f6ec55ce038e045b15a89a7f19fa45aa09d42a52517dd1846968d16777d3a9b\",\"dweb:/ipfs/QmZXthQLUtRFgqGv3bFbijmNk5Vviacrf7VnRDbXEQjdBQ\"]},\"src/interfaces/external/permit/IEIP712.sol\":{\"keccak256\":\"0x07e44e64248ed6316fe1db6f44c80468b950e6d1ab4bfdf21a65cbbd27718f77\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://58487548bc5289e7f5a4d4c278e5c7e9a7829d8a5be024a42938943f8c8fb63b\",\"dweb:/ipfs/QmYg63mq3SgXH6H4Wyvznb1E5fEjw6W7NeLASUcRjMuKYa\"]}},\"version\":1}",
+  "metadata": {
+    "compiler": {
+      "version": "0.8.23+commit.f704f362"
+    },
+    "language": "Solidity",
+    "output": {
+      "abi": [
+        {
+          "inputs": [
+            {
+              "internalType": "contract IAllowListAuthentication",
+              "name": "authenticator_",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IRepository",
+              "name": "repository_",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "permit2_",
+              "type": "address"
+            }
+          ],
+          "stateMutability": "nonpayable",
+          "type": "constructor"
         },
         {
-            "type": "error",
-            "name": "NotMaker",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "ECDSAInvalidSignature"
         },
         {
-            "type": "error",
-            "name": "NotSolver",
-            "inputs": []
+          "inputs": [
+            {
+              "internalType": "uint256",
+              "name": "length",
+              "type": "uint256"
+            }
+          ],
+          "type": "error",
+          "name": "ECDSAInvalidSignatureLength"
         },
         {
-            "type": "error",
-            "name": "OrderExpired",
-            "inputs": []
+          "inputs": [
+            {
+              "internalType": "bytes32",
+              "name": "s",
+              "type": "bytes32"
+            }
+          ],
+          "type": "error",
+          "name": "ECDSAInvalidSignatureS"
         },
         {
-            "type": "error",
-            "name": "PartialFillNotSupported",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidAmount"
         },
         {
-            "type": "error",
-            "name": "ReceiverNotManager",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidAsset"
         },
         {
-            "type": "error",
-            "name": "ReentrancyGuardReentrantCall",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidBaseTokenAmounts"
         },
         {
-            "type": "error",
-            "name": "SafeERC20FailedOperation",
-            "inputs": [
-                {
-                    "name": "token",
-                    "type": "address",
-                    "internalType": "address"
-                }
-            ]
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidDestination"
         },
         {
-            "type": "error",
-            "name": "SignatureIsExpired",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidEIP1271Signature"
         },
         {
-            "type": "error",
-            "name": "SignatureIsNotEmpty",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidEIP712Signature"
         },
         {
-            "type": "error",
-            "name": "UpdatedMakerAmountsTooLow",
-            "inputs": []
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidETHSignSignature"
         },
         {
-            "type": "error",
-            "name": "ZeroMakerAmount",
-            "inputs": []
-        }
-    ],
-    "bytecode": {
-        "object": "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",
-        "sourceMap": "975:10890:90:-:0;;;2483:234;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3749:13:91;3730:32;;;;3811:93;;;1026:66;3811:93;;;1092:25:169;879:32:91;1133:18:169;;;1126:34;;;;957:14:91;1176:18:169;;;1169:34;1219:18;;;1212:34;;;;3898:4:91;1262:19:169;;;1255:61;1064:19;;3811:93:91;;;-1:-1:-1;;3811:93:91;;;;;;;;;;3801:104;;3811:93;3801:104;;;;3768:137;;1857:1:44;2061:21;;-1:-1:-1;;;;;2585:30:90;;;;2666:4;;2673:8;;2639:43;;;:::i;:::-;-1:-1:-1;;;;;1557:15:169;;;1539:34;;1609:15;;1604:2;1589:18;;1582:43;1489:2;1474:18;2639:43:90;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2621:61:90;;;;;2688:24;;;;;;-1:-1:-1;975:10890:90;;-1:-1:-1;975:10890:90;;;;;;;;;:::o;14:157:169:-;-1:-1:-1;;;;;115:31:169;;105:42;;95:70;;161:1;158;151:12;95:70;14:157;:::o;176:652::-;319:6;327;335;388:2;376:9;367:7;363:23;359:32;356:52;;;404:1;401;394:12;356:52;436:9;430:16;455:57;506:5;455:57;:::i;:::-;581:2;566:18;;560:25;531:5;;-1:-1:-1;594:59:169;560:25;594:59;:::i;:::-;724:2;709:18;;703:25;672:7;;-1:-1:-1;737:59:169;703:25;737:59;:::i;:::-;815:7;805:17;;;176:652;;;;;:::o;1327:304::-;975:10890:90;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
-        "linkReferences": {}
-    },
-    "deployedBytecode": {
-        "object": "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",
-        "sourceMap": "975:10890:90:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7809:308;;;;;;;;;;-1:-1:-1;7809:308:90;;;;;:::i;:::-;;:::i;:::-;;;852:66:169;840:79;;;822:98;;810:2;795:18;7809:308:90;;;;;;;;1318:57;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;1102:74;;1090:2;1075:18;1318:57:90;931:251:169;6790:255:91;;;;;;;;;;;;;:::i;:::-;;;1333:25:169;;;1321:2;1306:18;6790:255:91;1187:177:169;5478:391:91;;;;;;;;;;-1:-1:-1;5478:391:91;;;;;:::i;:::-;;:::i;5859:1907:90:-;;;;;;:::i;:::-;;:::i;:::-;;14436:563:91;;;;;;;;;;-1:-1:-1;14436:563:91;;;;;:::i;:::-;;:::i;1440:48:90:-;;;;;;;;;;;;;;;5092:382:91;;;;;;;;;;-1:-1:-1;5092:382:91;;;;;:::i;:::-;;:::i;4627:523:90:-;;;;;;:::i;:::-;;:::i;4091:109:91:-;;;;;;;;;;-1:-1:-1;4091:109:91;;;;;:::i;:::-;;:::i;7272:1606::-;;;;;;;;;;-1:-1:-1;7272:1606:91;;;;;:::i;:::-;;:::i;15182:1005::-;;;;;;;;;;-1:-1:-1;15182:1005:91;;;;;:::i;:::-;;:::i;6025:761::-;;;;;;;;;;-1:-1:-1;6025:761:91;;;;;:::i;:::-;;:::i;1196:64:90:-;;;;;;;;;;;;;;;2894:1690;;;;;;;;;;-1:-1:-1;2894:1690:90;;;;;:::i;:::-;;:::i;5154:701::-;;;;;;:::i;:::-;;:::i;4336:752:91:-;;;;;;;;;;-1:-1:-1;4336:752:91;;;;;:::i;:::-;;:::i;13818:485::-;;;;;;;;;;-1:-1:-1;13818:485:91;;;;;:::i;:::-;;:::i;7809:308:90:-;7909:6;7923:23;7949:35;7966:5;7973:10;;7949:16;:35::i;:::-;7994:38;;;;;-1:-1:-1;;;;;1120:55:169;;;7994:38:90;;;1102:74:169;7923:61:90;;-1:-1:-1;7994:13:90;:21;;;;;;1075:18:169;;7994:38:90;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7990:123;;;1905:44:91;8042:26:90;;;;;7990:123;-1:-1:-1;8089:17:90;;-1:-1:-1;7809:308:90;;;;;;:::o;6790:255:91:-;6839:7;6878:16;6861:13;:33;:179;;6946:93;;;1026:66;6946:93;;;13746:25:169;879:32:91;13787:18:169;;;13780:34;;;;957:14:91;13830:18:169;;;13823:34;7010:13:91;13873:18:169;;;13866:34;7033:4:91;13916:19:169;;;13909:84;13718:19;;6946:93:91;;;;;;;;;;;;6936:104;;;;;;6854:186;;6790:255;:::o;6861:179::-;-1:-1:-1;6903:24:91;;6790:255::o;5478:391::-;5597:7;2314:68;5694:20;;;;:15;:20;:::i;:::-;5724:15;:22;;;5756:15;:24;;;5790:15;:26;;;5826:15;:24;;;5636:222;;;;;;;;;;;;14543:25:169;;;-1:-1:-1;;;;;14604:55:169;;;;14599:2;14584:18;;14577:83;14691:2;14676:18;;14669:34;;;;14734:2;14719:18;;14712:34;14777:3;14762:19;;14755:35;14821:3;14806:19;;14799:35;14530:3;14515:19;;14256:584;5636:222:91;;;;;;;;;;;;;5619:245;;;;;;5612:252;;5478:391;;;:::o;5859:1907:90:-;2500:21:44;:19;:21::i;:::-;6282:30:90::1;::::0;;;;-1:-1:-1;;;;;1120:55:169;;;6282:30:90::1;::::0;::::1;1102:74:169::0;6282:13:90::1;:21;::::0;::::1;::::0;1075:18:169;;6282:30:90::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6277:54;;6321:10;;;;;;;;;;;;;;6277:54;6366:30:::0;;;::::1;6406:22:::0;;;;;:80:::1;;-1:-1:-1::0;6454:32:90;;;::::1;6432:54:::0;::::1;;6406:80;6402:254;;;6516:133;6537:18:::0;6557:30;;;::::1;6589:32:::0;;;::::1;6623:18;6516:11;:133::i;:::-;6496:153;;6402:254;6662:130;6683:10;6695:7;6704:17;6723:6;6731:13;;6746:6;6754:15;6771;6662:13;:130::i;:::-;-1:-1:-1::0;;;;;6799:15:90::1;:28;;6835:22;::::0;;;::::1;::::0;::::1;;:::i;:::-;6859:25;::::0;;;:20:::1;::::0;::::1;:25;:::i;:::-;6886:32;6799:143:::0;;::::1;::::0;;;;;;::::1;::::0;;;6886:32;;;::::1;::::0;6920:16;;6799:143:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;6949:357;6970:6;6984:7;6999:17;7024:18;7046:1;7024:23;:80;;;-1:-1:-1::0;7072:32:90;;;::::1;7051:53:::0;::::1;7024:80;:152;;7158:18;7024:152;;;7115:32:::0;;;::::1;7024:152;7184:6:::0;7198:13;;7219:42:::1;7269:31;::::0;;;::::1;::::0;::::1;;:::i;:::-;6949:13;:357::i;:::-;7336:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;7318:443;;;;;;;:::i;:::-;;::::0;;;;::::1;::::0;;::::1;7356:13;::::0;;;::::1;::::0;::::1;;:::i;:::-;7377:22;::::0;;;::::1;::::0;::::1;;:::i;:::-;7407:25;::::0;;;:20:::1;::::0;::::1;:25;:::i;:::-;7440:26;::::0;;;:21:::1;::::0;::::1;:26;:::i;:::-;7474:23:::0;;;:80:::1;;-1:-1:-1::0;7522:32:90;;;::::1;7501:53:::0;::::1;7474:80;:147;;7603:18;7474:147;;;7565:27:::0;;;::::1;7474:147;7650:30:::0;;;::::1;7629:51:::0;::::1;:102;;7714:17;7629:102;;;7683:28:::0;;;::::1;7629:102;7739:6;:16;;;;;;;;;;:::i;:::-;7318:443;::::0;;-1:-1:-1;;;;;18257:15:169;;;18239:34;;18309:15;;;18304:2;18289:18;;18282:43;18361:15;;;18341:18;;;18334:43;;;;18413:15;;;18408:2;18393:18;;18386:43;18460:3;18445:19;;18438:35;18504:3;18489:19;;18482:35;18554:15;;;18548:3;18533:19;;18526:44;18165:3;18150:19;7318:443:90::1;;;;;;;6271:1495;2542:20:44::0;1857:1;3068:21;;2888:208;2542:20;5859:1907:90;;;;;;;;;:::o;14436:563:91:-;14546:9;14541:225;14561:19;:6;;:19;:::i;:::-;:26;;14557:1;:30;14541:225;;;14602:34;14639:19;:6;;:19;:::i;:::-;14659:1;14639:22;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;14602:59;-1:-1:-1;;;;;;14674:25:91;;;14700:11;;;;14602:59;14700:11;:::i;:::-;14674:38;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;14674:38:91;;;1102:74:169;1075:18;;14674:38:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14670:90;;;14731:20;;;;;;;;;;;;;;14670:90;-1:-1:-1;14589:3:91;;14541:225;;;;14777:9;14772:223;14792:18;;;;:6;:18;:::i;:::-;:25;;14788:1;:29;14772:223;;;14832:34;14869:18;;;;:6;:18;:::i;:::-;14888:1;14869:21;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;14832:58;-1:-1:-1;;;;;;14903:25:91;;;14929:11;;;;14832:58;14929:11;:::i;:::-;14903:38;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;14903:38:91;;;1102:74:169;1075:18;;14903:38:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14899:90;;;14960:20;;;;;;;;;;;;;;14899:90;-1:-1:-1;14819:3:91;;14772:223;;;;14436:563;;:::o;5092:382::-;5208:7;2182:67;5304:19;;;;:14;:19;:::i;4627:523:90:-;4876:62;4914:6;4922:15;4876:37;:62::i;:::-;4944:201;4971:7;4986:6;5000:15;5023:18;5049:41;5098;4944:19;:201::i;:::-;4627:523;;;;;:::o;4091:109:91:-;4155:40;4177:10;4189:5;4155:21;:40::i;:::-;4091:109;:::o;7272:1606::-;7498:27;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7498:27:91;7537:9;7532:1297;7548:24;;;7532:1297;;;7587:41;7631:13;;7645:1;7631:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;7587:60;-1:-1:-1;7655:23:91;;7681:20;;;;7587:60;7681:20;:::i;:::-;7655:46;;-1:-1:-1;7655:46:91;-1:-1:-1;;;;;;7714:25:91;;;7740:18;;;;:11;:18;:::i;:::-;7714:45;;;;;;;;;;-1:-1:-1;;;;;1120:55:169;;;7714:45:91;;;1102:74:169;1075:18;;7714:45:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7710:1113;;;7771:10;7796:14;7792:52;;;7819:25;;;;;;;;;;;;;;7792:52;7878:1;7859:20;;7855:119;;-1:-1:-1;7923:29:91;;7855:119;7988:33;;;;;7984:831;;8049:45;8068:8;;8078:7;8087:6;8049:18;:45::i;:::-;8035:1;:10;;:59;;;;;;;:::i;:::-;;;-1:-1:-1;7984:831:91;;;8115:33;;;;;8111:704;;8176:45;8195:8;;8205:7;8214:6;8176:18;:45::i;:::-;8162:1;:10;;:59;;;;;;;:::i;8111:704::-;8242:39;;;;;8238:577;;8340:50;8364:8;;8374:7;8383:6;8340:23;:50::i;:::-;8317:19;;;8295:95;8296:19;;;8295:95;;;8402:10;;;:33;;;;8295:95;;8402:33;:::i;:::-;;;-1:-1:-1;8461:19:91;;;;8447:10;;;:33;;;;8461:19;;8447:33;:::i;8238:577::-;8501:32;;;;;8497:318;;8560:44;8578:8;;8588:7;8597:6;8560:17;:44::i;:::-;8547:57;;:1;;:57;;;;;:::i;8497:318::-;8625:35;;;;;8621:194;;8690:47;8711:8;;8721:7;8730:6;8690:20;:47::i;:::-;8674:1;:12;;:63;;;;;;;:::i;8621:194::-;8773:31;;;;;;;;;;;;;;8621:194;7761:1062;7710:1113;7579:1250;;;7574:3;;;;;7532:1297;;;;8835:38;8863:6;8871:1;8835:27;:38::i;:::-;7492:1386;7272:1606;;;;;;:::o;15182:1005::-;15364:21;15336:24;;;;:10;:24;:::i;:::-;:49;;;;;;;;:::i;:::-;;15332:851;;-1:-1:-1;;;;;15399:72:91;;:50;15416:5;15423:25;;;;:10;:25;:::i;:::-;15399:16;:50::i;:::-;-1:-1:-1;;;;;15399:72:91;;15395:128;;15490:24;;;;;;;;;;;;;;15332:851;15567:22;15539:24;;;;:10;:24;:::i;:::-;:50;;;;;;;;:::i;:::-;;15535:648;;15655:20;15599:19;15645:31;;;15692:2;15685:17;;;15739:2;15726:16;;-1:-1:-1;;;;;15761:78:91;;:56;15726:16;15791:25;;;;:10;:25;:::i;15761:56::-;-1:-1:-1;;;;;15761:78:91;;15757:135;;15858:25;;;;;;;;;;;;;;15757:135;15591:307;14772:223;14436:563;;:::o;15535:648::-;15936:22;15908:24;;;;:10;:24;:::i;:::-;:50;;;;;;;;:::i;:::-;;15904:279;;15972:102;-1:-1:-1;;;;;15972:45:91;;;16018:5;16025:25;;;;:10;:25;:::i;:::-;15972:79;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:102;;;15968:159;;16093:25;;;;;;;;;;;;;;15904:279;16154:22;;;;;;;;;;;;;;6025:761;6124:7;6209:18;:16;:18::i;:::-;2011:107;6381:12;:6;;:12;:::i;:::-;6370:24;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6360:35;;;;;;6397:6;:12;;;6411:6;:13;;;;;;;;;;:::i;:::-;6323:102;;;;;;22262:25:169;;;;22303:18;;22296:34;;;;22346:18;;;22339:34;-1:-1:-1;;;;;22409:55:169;22389:18;;;22382:83;22234:19;;6323:102:91;;;;;;;;;;;;;6465:22;;;;;;;;:::i;:::-;6503:16;;;;;;;;:::i;:::-;6535:17;;;;;;;;:::i;:::-;6568:22;;;;6606:23;;;;6645:20;;;;6681:18;;;;6715:16;;;;;;;;:::i;:::-;6439:306;;;-1:-1:-1;;;;;22898:15:169;;;6439:306:91;;;22880:34:169;22950:15;;;22930:18;;;22923:43;23002:15;;;22982:18;;;22975:43;23034:18;;;23027:34;;;;23077:19;;;23070:35;;;;23121:19;;;23114:35;23165:19;;;23158:35;23230:15;;;23209:19;;;23202:44;22791:19;;6439:306:91;;;;;;;;;;;;;;6258:499;;;6439:306;6258:499;;:::i;:::-;;;;;;;;;;;;;6237:530;;;;;;6163:612;;;;;;;;24120:66:169;24108:79;;24212:1;24203:11;;24196:27;;;;24248:2;24239:12;;24232:28;24285:2;24276:12;;23850:444;2894:1690:90;2500:21:44;:19;:21::i;:::-;2266:34:90::1;::::0;;;;2289:10:::1;2266:34;::::0;::::1;1102:74:169::0;2266:13:90::1;-1:-1:-1::0;;;;;2266:22:90::1;::::0;::::1;::::0;1075:18:169;;2266:34:90::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2261:59;;2309:11;;;;;;;;;;;;;;2261:59;3251:30:::2;::::0;;;;-1:-1:-1;;;;;1120:55:169;;;3251:30:90::2;::::0;::::2;1102:74:169::0;3251:13:90::2;:21;::::0;::::2;::::0;1075:18:169;;3251:30:90::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3246:54;;3290:10;;;;;;;;;;;;;;3246:54;3335:30:::0;;;::::2;3375:22:::0;;;;;:80:::2;;-1:-1:-1::0;3423:32:90;;;::::2;3401:54:::0;::::2;;3375:80;3371:254;;;3485:133;3506:18:::0;3526:30;;;::::2;3558:32:::0;;;::::2;3592:18;3485:11;:133::i;:::-;3465:153;;3371:254;3631:130;3652:10;3664:7;3673:17;3692:6;3700:13;;3715:6;3723:15;3740;3631:13;:130::i;:::-;3768:356;3789:6:::0;3803:7;3818:17;3843:23;;;:80:::2;;-1:-1:-1::0;3891:32:90;;;::::2;3870:53:::0;::::2;3843:80;:152;;3977:18;3843:152;;;3934:32:::0;;;::::2;3843:152;4003:6:::0;4017:13;;4038:41:::2;4087:31;::::0;;;::::2;::::0;::::2;;:::i;3768:356::-;4154:12;;::::0;::::2;:6:::0;:12:::2;:::i;:::-;4136:443;;;;;;;:::i;:::-;;::::0;;;;::::2;::::0;;::::2;4174:13;::::0;;;::::2;::::0;::::2;;:::i;:::-;4195:22;::::0;;;::::2;::::0;::::2;;:::i;:::-;4225:25;::::0;;;:20:::2;::::0;::::2;:25;:::i;:::-;4258:26;::::0;;;:21:::2;::::0;::::2;:26;:::i;:::-;4292:23:::0;;;:80:::2;;-1:-1:-1::0;4340:32:90;;;::::2;4319:53:::0;::::2;4292:80;:147;;4421:18;4292:147;;;4383:27:::0;;;::::2;4292:147;4468:30:::0;;;::::2;4447:51:::0;::::2;:102;;4532:17;4447:102;;;4501:28:::0;;;::::2;4447:102;4557:6;:16;;;;;;;;;;:::i;:::-;4136:443;::::0;;-1:-1:-1;;;;;18257:15:169;;;18239:34;;18309:15;;;18304:2;18289:18;;18282:43;18361:15;;;18341:18;;;18334:43;;;;18413:15;;;18408:2;18393:18;;18386:43;18460:3;18445:19;;18438:35;18504:3;18489:19;;18482:35;18554:15;;;18548:3;18533:19;;18526:44;18165:3;18150:19;4136:443:90::2;;;;;;;3240:1344;2542:20:44::0;1857:1;3068:21;;2888:208;2542:20;2894:1690:90;;;;;;;;:::o;5154:701::-;5472:62;5510:6;5518:15;5472:37;:62::i;:::-;-1:-1:-1;;;;;5540:15:90;:28;;5569:22;;;;;;;;:::i;:::-;5593:16;;;;;;;;:::i;:::-;5611:6;:22;;;5635:16;5540:112;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5658:192;5685:7;5700:6;5714:15;5737:18;5763:42;5813:15;:31;;;;;;;;;;:::i;:::-;5658:19;:192::i;:::-;5154:701;;;;;;:::o;4336:752:91:-;4428:7;4513:18;:16;:18::i;:::-;2439:220;4714:12;;;;:6;:12;:::i;:::-;4703:24;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;4693:35;;4703:24;4693:35;;;;4744:12;;;;4772:13;;;;;;;;:::i;:::-;4801:22;;;;;;;;:::i;:::-;4839:18;;;;4873:16;;;;;;;;:::i;:::-;4627:312;;;;;;24642:25:169;;;;24683:18;;24676:34;;;;24726:18;;;24719:34;;;;-1:-1:-1;;;;;24850:15:169;;;24830:18;;;24823:43;24903:15;;24882:19;;;24875:44;24935:19;;;24928:35;;;;25000:15;24979:19;;;24972:44;4905:20:91;;;;;25032:19:169;;;25025:35;24614:19;;4627:312:91;;;;;;;;;;;;4953:39;4971:6;:20;;4953:17;:39::i;:::-;5006:41;5025:6;:21;;5006:18;:41::i;:::-;4562:497;;;;;;;;;;:::i;13818:485::-;14034:29;;;;13968:63;14003:28;;;;13968:32;;;;:63;:::i;:::-;:95;;;;:::i;:::-;13929:27;;;;:134;13918:184;;14077:25;;;;;;;;;;;;;;13918:184;14228:30;;;;14160:65;14193:32;;;;14160:30;;;;:65;:::i;:::-;:98;;;;:::i;:::-;14120:28;;;;:138;14109:189;;14272:26;;;;;;;;;;;;;;16423:233;16514:7;16529:14;16546:32;16560:5;16567:10;;16546:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16546:13:91;;-1:-1:-1;;;16546:32:91:i;:::-;16529:49;-1:-1:-1;;;;;;16588:20:91;;16584:48;;16617:15;;;;;;;;;;;;;;16584:48;16645:6;16423:233;-1:-1:-1;;;;16423:233:91:o;2575:307:44:-;1899:1;2702:7;;:18;2698:86;;2743:30;;;;;;;;;;;;;;2698:86;1899:1;2858:7;:17;2575:307::o;9351:238:48:-;9452:7;9506:76;9522:26;9539:8;9522:16;:26::i;:::-;:59;;;;;9580:1;9565:11;9552:25;;;;;:::i;:::-;9562:1;9559;9552:25;:29;9522:59;34914:9:49;34907:17;;34795:145;9506:76:48;9478:25;9485:1;9488;9491:11;9478:6;:25::i;:::-;:104;;;;:::i;:::-;9471:111;9351:238;-1:-1:-1;;;;;9351:238:48:o;17073:1250:91:-;17445:17;17465;17475:6;17465:9;:17::i;:::-;17445:37;;17488:54;17506:7;17515:9;17526:15;17488:17;:54::i;:::-;17567:22;;;;;;;;:::i;:::-;-1:-1:-1;;;;;17553:36:91;:10;-1:-1:-1;;;;;17553:36:91;;17549:223;;17599:69;17617:22;;;;;;;;:::i;:::-;17641:9;17652:15;17599:17;:69::i;:::-;17549:223;;;17693:30;;;;:15;:30;:::i;:::-;:37;;17734:1;17693:42;17689:76;;17744:21;;;;;;;;;;;;;;17689:76;17777:59;17799:22;;;;;;;;:::i;:::-;17823:6;:12;;;17777:21;:59::i;:::-;17865:6;:18;;;17847:15;:36;17843:69;;;17892:20;;;;;;;;;;;;;;17843:69;17939:1;17922:14;:18;:61;;;;;17962:6;:20;;;17945:14;:37;17922:61;17918:93;;;17992:19;;;;;;;;;;;;;;17918:93;18018:28;18039:6;18018:20;:28::i;:::-;18053:34;18067:11;18080:6;18053:13;:34::i;:::-;18094:173;18122:11;18141:7;18173:1;18156:14;:18;:70;;;;-1:-1:-1;18196:30:91;;;;18178:48;;;18156:70;18234:6;18248:13;;18094:20;:173::i;:::-;18274:44;18296:7;18305:6;:12;;;18274:21;:44::i;:::-;17439:884;17073:1250;;;;;;;;;:::o;8812:1368:90:-;9164:40;9184:19;:6;;:19;:::i;:::-;9164;:40::i;:::-;9211:23;9237:60;9269:28;;;;9237:29;;;;:60;:::i;:::-;9211:86;;9304:15;-1:-1:-1;;;;;9304:30:90;;9342:150;;;;;;;;9380:6;:22;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9342:150:90;;;;;9412:4;-1:-1:-1;;;;;9342:150:90;;;;;9419:6;:20;;:25;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9342:150:90;;;;;9446:15;9342:150;;;;9463:21;9342:150;;;;;;;;:::i;:::-;;;;9304:194;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9505:15;-1:-1:-1;;;;;9505:30:90;;9543:155;;;;;;;;9581:6;:22;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9543:155:90;;;;;9605:6;:16;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9543:155:90;;;;;9623:6;:20;;:25;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9543:155:90;;;;;9650:17;9543:155;;;;9669:21;9543:155;;;;;;;;:::i;:::-;;;;9505:199;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9711:34;9731:13;;9711:19;:34::i;:::-;9752:15;-1:-1:-1;;;;;9752:30:90;;9790:138;;;;;;;;9828:7;-1:-1:-1;;;;;9790:138:90;;;;;9837:6;:13;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9790:138:90;;;;;9852:6;:21;;:26;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9790:138:90;;;;;9880:17;9790:138;;;;9899:21;9790:138;;;;;;;;:::i;:::-;;;;9752:182;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9941:39:90;;-1:-1:-1;9961:18:90;;-1:-1:-1;;9961:18:90;;;:6;:18;:::i;9941:39::-;9987:15;10012:25;;;;:20;;;:25;:::i;:::-;10005:58;;;;;10057:4;10005:58;;;1102:74:169;-1:-1:-1;;;;;10005:43:90;;;;;;;1075:18:169;;10005:58:90;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9987:76;-1:-1:-1;10074:12:90;;10070:106;;10096:73;10143:16;;;;;;;;:::i;:::-;10161:7;10103:6;:20;;:25;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10096:46:90;;:73;:46;:73::i;:::-;9158:1022;;8812:1368;;;;;;;;;:::o;18485:482:91:-;18673:22;;;;;;;;:::i;:::-;-1:-1:-1;;;;;18659:36:91;:10;-1:-1:-1;;;;;18659:36:91;;18655:237;;18705:83;18723:22;;;;;;;;:::i;:::-;18747:23;18763:6;18747:15;:23::i;:::-;18772:15;18705:17;:83::i;:::-;18655:237;;;18813:30;;;;:15;:30;:::i;:::-;:37;;18854:1;18813:42;18809:76;;18864:21;;;;;;;;;;;;;;18809:76;18897:65;18925:22;;;;;;;;:::i;:::-;18949:6;:12;;;18897:27;:65::i;:::-;18485:482;;:::o;10379:1484:90:-;10694:23;;;;10727;;;;;:70;;;10775:6;:22;;;10754:18;:43;10727:70;10723:216;;;10832:100;10844:18;10864:6;:23;;;10889:6;:22;;;10913:18;10832:11;:100::i;:::-;10807:125;;10723:216;10945:70;10966:7;10975:14;10991:6;10999:15;10945:20;:70::i;:::-;11022:15;-1:-1:-1;;;;;11022:30:90;;11060:297;;;;;;;;11098:6;:22;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11060:297:90;;;;;11130:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11060:297:90;;;;;11156:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11060:297:90;;;;;11182:23;;;:70;;;11230:6;:22;;;11209:18;:43;11182:70;:136;;11300:18;11182:136;;;11265:6;:22;;;11182:136;11060:297;;;;11328:21;11060:297;;;;;;;;:::i;:::-;;;;11022:341;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11370:15;-1:-1:-1;;;;;11370:30:90;;11408:110;;;;;;;;11437:7;-1:-1:-1;;;;;11408:110:90;;;;;11446:6;:13;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11408:110:90;;;;;11461:17;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11408:110:90;;;;;11480:14;11408:110;;;;11496:21;11408:110;;;;;;;;:::i;:::-;;;;11370:154;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11554:12:90;;-1:-1:-1;11554:6:90;;-1:-1:-1;11554:6:90;;-1:-1:-1;11554:12:90;:::i;:::-;11536:322;;;;;;;:::i;:::-;;;;;;;;;11574:6;:13;;;;;;;;;;:::i;:::-;11595:22;;;;;;;;:::i;:::-;11625:16;;;;;;;;:::i;:::-;11649:17;;;;;;;;:::i;:::-;11674:23;;;:70;;;11722:6;:22;;;11701:18;:43;11674:70;:132;;11788:18;11674:132;;;11755:6;:22;;;11674:132;11814:14;11836:6;:16;;;;;;;;;;:::i;:::-;11536:322;;;-1:-1:-1;;;;;18257:15:169;;;18239:34;;18309:15;;;18304:2;18289:18;;18282:43;18361:15;;;18341:18;;;18334:43;;;;18413:15;;;18408:2;18393:18;;18386:43;18460:3;18445:19;;18438:35;18504:3;18489:19;;18482:35;18554:15;;;18548:3;18533:19;;18526:44;18165:3;18150:19;11536:322:90;;;;;;;10663:1200;10379:1484;;;;;;:::o;20053:172:91:-;-1:-1:-1;;;;;20136:16:91;;:7;:16;;;;;;;;;;;:24;;;;;;;;;;;20132:51;;;20169:14;;;;;;;;;;;;;;20132:51;-1:-1:-1;;;;;20189:16:91;;;:7;:16;;;;;;;;;;;:24;;;;;;;:31;;;;20216:4;20189:31;;;20053:172::o;9090:497::-;9242:7;;;;9321:12;:8;9330:1;9321:8;;:12;:::i;:::-;9310:59;;;;;;;:::i;:::-;-1:-1:-1;9257:112:91;;-1:-1:-1;9257:112:91;-1:-1:-1;9257:112:91;-1:-1:-1;9388:25:91;;;;:20;;;:25;:::i;:::-;-1:-1:-1;;;;;9379:34:91;:5;-1:-1:-1;;;;;9379:34:91;;9375:61;;9422:14;;;;;;;;;;;;;;9375:61;9457:8;-1:-1:-1;;;;;9446:19:91;:7;-1:-1:-1;;;;;9446:19:91;;9442:47;;9474:15;;;;;;;;;;;;;;9442:47;9509:29;;;;9499:39;;9495:67;;9547:15;;;;;;;;;;;;;;9495:67;9576:6;9090:497;-1:-1:-1;;;;;;;9090:497:91:o;9799:589::-;9951:7;;;;;10053:12;:8;10062:1;10053:8;;:12;:::i;:::-;10042:62;;;;;;;:::i;:::-;9966:138;;-1:-1:-1;9966:138:91;;-1:-1:-1;9966:138:91;-1:-1:-1;9966:138:91;-1:-1:-1;10123:26:91;;;;:21;;;:26;:::i;:::-;-1:-1:-1;;;;;10114:35:91;:5;-1:-1:-1;;;;;10114:35:91;;10110:62;;10158:14;;;;;;;;;;;;;;10110:62;10193:8;-1:-1:-1;;;;;10182:19:91;:7;-1:-1:-1;;;;;10182:19:91;;10178:47;;10210:15;;;;;;;;;;;;;;10178:47;10247:13;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10235:25:91;:8;-1:-1:-1;;;;;10235:25:91;;10231:58;;10269:20;;;;;;;;;;;;;;10231:58;10309:30;;;;10299:40;;10295:68;;10348:15;;;;;;;;;;;;;;10295:68;10377:6;9799:589;-1:-1:-1;;;;;;;;9799:589:91:o;10633:953::-;10790:7;10799;10822:13;10843:16;10867:14;10889:17;10914:14;10936:18;10962:19;11001:8;;11010:1;11001:12;;;;;;;;;:::i;:::-;10990:89;;;;;;;:::i;:::-;10814:265;;-1:-1:-1;10814:265:91;;-1:-1:-1;10814:265:91;;-1:-1:-1;10814:265:91;-1:-1:-1;10814:265:91;-1:-1:-1;10814:265:91;-1:-1:-1;10814:265:91;-1:-1:-1;11098:26:91;;;;:21;;;:26;:::i;:::-;-1:-1:-1;;;;;11089:35:91;:5;-1:-1:-1;;;;;11089:35:91;;11085:62;;11133:14;;;;;;;;;;;;;;11085:62;11168:8;-1:-1:-1;;;;;11157:19:91;:7;-1:-1:-1;;;;;11157:19:91;;11153:47;;11185:15;;;;;;;;;;;;;;11153:47;-1:-1:-1;;;;;11210:23:91;;11228:4;11210:23;11206:51;;11242:15;;;;;;;;;;;;;;11206:51;11280:13;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11267:26:91;:9;-1:-1:-1;;;;;11267:26:91;;11263:59;;11302:20;;;;;;;;;;;;;;11263:59;11342:30;;;;11332:40;;11328:68;;11381:15;;;;;;;;;;;;;;11328:68;11420:25;;;;:20;;;:25;:::i;:::-;-1:-1:-1;;;;;11406:39:91;:10;-1:-1:-1;;;;;11406:39:91;;11402:66;;11454:14;;;;;;;;;;;;;;11402:66;11493:29;;;;11478:44;;11474:72;;11531:15;;;;;;;;;;;;;;11474:72;11561:6;;;;-1:-1:-1;10633:953:91;;-1:-1:-1;;;;;;;;;;10633:953:91:o;11796:488::-;11947:7;;;;12025:12;:8;12034:1;12025:8;;:12;:::i;:::-;12014:53;;;;;;;:::i;:::-;11962:105;;-1:-1:-1;11962:105:91;-1:-1:-1;11962:105:91;-1:-1:-1;12086:25:91;;;;:20;;;:25;:::i;:::-;-1:-1:-1;;;;;12077:34:91;:5;-1:-1:-1;;;;;12077:34:91;;12073:61;;12120:14;;;;;;;;;;;;;;12073:61;12155:8;-1:-1:-1;;;;;12144:19:91;:7;-1:-1:-1;;;;;12144:19:91;;12140:47;;12172:15;;;;;;;;;;;;;;12140:47;12207:28;;;;12197:38;;12193:66;;12244:15;;;;;;;;;;;;;;12500:602;12654:7;;;;;12758:12;:8;12767:1;12758:8;;:12;:::i;:::-;12747:68;;;;;;;:::i;:::-;-1:-1:-1;12669:146:91;;-1:-1:-1;12669:146:91;;-1:-1:-1;12669:146:91;-1:-1:-1;12669:146:91;-1:-1:-1;12834:26:91;;;;:21;;;:26;:::i;:::-;-1:-1:-1;;;;;12825:35:91;:5;-1:-1:-1;;;;;12825:35:91;;12821:62;;12869:14;;;;;;;;;;;;;;12821:62;12904:9;-1:-1:-1;;;;;12893:20:91;:7;-1:-1:-1;;;;;12893:20:91;;12889:48;;12922:15;;;;;;;;;;;;;;12889:48;12959:13;;;;;;;;:::i;:::-;-1:-1:-1;;;;;12947:25:91;:8;-1:-1:-1;;;;;12947:25:91;;12943:58;;12981:20;;;;;;;;;;;;;;12943:58;13021:32;;;;13011:42;;13007:70;;13062:15;;;;;;;;;;;;;;13259:466;13404:9;;13417:28;;;;13404:41;;;:88;;-1:-1:-1;13449:10:91;;;;13463:29;;;;13449:43;;13404:88;13400:153;;;13509:37;;;;;;;;;;;;;;13400:153;13563:12;;;;13579:32;;;;13563:48;;;:96;;-1:-1:-1;13615:10:91;;;;13629:30;;;;13615:44;;13563:96;13559:162;;;13676:38;;;;;;;;;;;;;;3714:255:45;3792:7;3812:17;3831:18;3851:16;3871:27;3882:4;3888:9;3871:10;:27::i;:::-;3811:87;;;;;;3908:28;3920:5;3927:8;3908:11;:28::i;:::-;-1:-1:-1;3953:9:45;;-1:-1:-1;;3714:255:45;;;;;:::o;29533:122:48:-;29601:4;29642:1;29630:8;29624:15;;;;;;;;:::i;:::-;:19;;;;:::i;:::-;:24;;29647:1;29624:24;29617:31;;29533:122;;;:::o;4996:4226::-;5078:14;5449:5;;;5078:14;5634:6;5453:1;5449;5621:20;5694:5;5690:2;5687:13;5679:5;5675:2;5671:14;5667:34;5658:43;;;5796:5;5805:1;5796:10;5792:368;;6134:11;6126:5;:19;;;;;:::i;:::-;;6119:26;;;;;;5792:368;6285:5;6270:11;:20;6266:143;;6310:84;3066:5;6330:16;;3065:36;940:4:43;3060:42:48;6310:11;:84::i;:::-;6664:17;6799:11;6796:1;6793;6786:25;7199:12;7229:15;;;7214:31;;7348:22;;;;;8094:1;8075;:15;;8074:21;;8327;;;8323:25;;8312:36;8397:21;;;8393:25;;8382:36;8469:21;;;8465:25;;8454:36;8540:21;;;8536:25;;8525:36;8613:21;;;8609:25;;8598:36;8687:21;;;8683:25;;;8672:36;7597:12;;;;7593:23;;;7618:1;7589:31;6913:20;;;6902:32;;;7709:12;;;;6960:21;;;;7446:16;;;;7700:21;;;;9163:15;;;;;-1:-1:-1;;4996:4226:48;;;;;:::o;8348:460:90:-;8452:9;8447:357;8463:24;;;8447:357;;;8502:41;8546:13;;8560:1;8546:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;8502:60;-1:-1:-1;;;;;;8605:15:90;8575:46;:18;;;;8502:60;8575:18;:::i;:::-;-1:-1:-1;;;;;8575:46:90;;8571:79;;8630:20;;;;;;;;;;;;;;8571:79;8658:36;8682:11;8658:23;:36::i;:::-;8720:18;;;;:11;:18;:::i;:::-;-1:-1:-1;;;;;8708:89:90;;8740:11;:17;;;8759:37;8784:11;8759:24;:37::i;:::-;8708:89;;;30953:25:169;;;31026:66;31014:79;;;31009:2;30994:18;;30987:107;30926:18;8708:89:90;;;;;;;-1:-1:-1;8489:3:90;;8447:357;;1219:160:39;1328:43;;;-1:-1:-1;;;;;31297:55:169;;1328:43:39;;;31279:74:169;31369:18;;;;31362:34;;;1328:43:39;;;;;;;;;;31252:18:169;;;;1328:43:39;;;;;;;;;;;;;;1301:71;;1321:5;;1301:19;:71::i;19109:500:91:-;19332:1;19315:14;:18;:61;;;;;19355:6;:20;;;19338:14;:37;19315:61;19311:93;;;19385:19;;;;;;;;;;;;;;19311:93;19410:68;19428:7;19437:23;19453:6;19437:15;:23::i;19410:68::-;19484:50;19512:7;19521:6;:12;;;19484:27;:50::i;:::-;19566:15;19544:6;:18;;;:37;19540:64;;19590:14;;;;;;;;;;;;;;2129:778:45;2232:17;2251:16;2269:14;2299:9;:16;2319:2;2299:22;2295:606;;2604:4;2589:20;;2583:27;2653:4;2638:20;;2632:27;2710:4;2695:20;;2689:27;2337:9;2681:36;2751:25;2762:4;2681:36;2583:27;2632;2751:10;:25::i;:::-;2744:32;;;;;;;;;;;2295:606;-1:-1:-1;;2872:16:45;;2823:1;;-1:-1:-1;2827:35:45;;2295:606;2129:778;;;;;:::o;7280:532::-;7375:20;7366:5;:29;;;;;;;;:::i;:::-;;7362:444;;7280:532;;:::o;7362:444::-;7471:29;7462:5;:38;;;;;;;;:::i;:::-;;7458:348;;7523:23;;;;;;;;;;;;;;7458:348;7576:35;7567:5;:44;;;;;;;;:::i;:::-;;7563:243;;7634:46;;;;;;;;1333:25:169;;;1306:18;;7634:46:45;;;;;;;;7563:243;7710:30;7701:5;:39;;;;;;;;:::i;:::-;;7697:109;;7763:32;;;;;;;;1333:25:169;;;1306:18;;7763:32:45;1187:177:169;1776:194:43;1881:10;1875:4;1868:24;1918:4;1912;1905:18;1949:4;1943;1936:18;582:989:72;649:14;666:18;;;;:11;:18;:::i;:::-;649:35;-1:-1:-1;706:17:72;;;;729:23;690:13;755:20;;;;706:11;755:20;:::i;:::-;729:46;;;;1305:4;1299:11;1366:15;1349;1330:17;1317:65;1465:1;1462;1445:15;1426:17;1419:5;1411:6;1404:5;1399:68;1389:172;;1500:16;1497:1;1494;1479:38;1536:16;1533:1;1526:27;1798:809;1874:13;1895:23;1874:13;1921:20;;;;:11;:20;:::i;:::-;1895:46;;-1:-1:-1;1895:46:72;-1:-1:-1;1970:1:72;1951:20;;1947:656;;2573:15;2560:29;2550:39;;1947:656;1889:718;;1798:809;;;:::o;8370:720:39:-;8450:18;8478:19;8616:4;8613:1;8606:4;8600:11;8593:4;8587;8583:15;8580:1;8573:5;8566;8561:60;8673:7;8663:176;;8717:4;8711:11;8762:16;8759:1;8754:3;8739:40;8808:16;8803:3;8796:29;8663:176;-1:-1:-1;;8916:1:39;8910:8;8866:16;;-1:-1:-1;8942:15:39;;:68;;8994:11;9009:1;8994:16;;8942:68;;;-1:-1:-1;;;;;8960:26:39;;;:31;8942:68;8938:146;;;9033:40;;;;;-1:-1:-1;;;;;1120:55:169;;9033:40:39;;;1102:74:169;1075:18;;9033:40:39;931:251:169;5203:1551:45;5329:17;;;6283:66;6270:79;;6266:164;;;-1:-1:-1;6381:1:45;;-1:-1:-1;6385:30:45;;-1:-1:-1;6417:1:45;6365:54;;6266:164;6541:24;;;6524:14;6541:24;;;;;;;;;31816:25:169;;;31889:4;31877:17;;31857:18;;;31850:45;;;;31911:18;;;31904:34;;;31954:18;;;31947:34;;;6541:24:45;;31788:19:169;;6541:24:45;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6541:24:45;;;;;;-1:-1:-1;;;;;;;6579:20:45;;6575:113;;-1:-1:-1;6631:1:45;;-1:-1:-1;6635:29:45;;-1:-1:-1;6631:1:45;;-1:-1:-1;6615:62:45;;6575:113;6706:6;-1:-1:-1;6714:20:45;;-1:-1:-1;6714:20:45;;-1:-1:-1;5203:1551:45;;;;;;;;;:::o;14:659:169:-;93:6;101;109;162:2;150:9;141:7;137:23;133:32;130:52;;;178:1;175;168:12;130:52;214:9;201:23;191:33;;275:2;264:9;260:18;247:32;298:18;339:2;331:6;328:14;325:34;;;355:1;352;345:12;325:34;393:6;382:9;378:22;368:32;;438:7;431:4;427:2;423:13;419:27;409:55;;460:1;457;450:12;409:55;500:2;487:16;526:2;518:6;515:14;512:34;;;542:1;539;532:12;512:34;587:7;582:2;573:6;569:2;565:15;561:24;558:37;555:57;;;608:1;605;598:12;555:57;639:2;635;631:11;621:21;;661:6;651:16;;;;;14:659;;;;;:::o;1369:163::-;1436:5;1481:3;1472:6;1467:3;1463:16;1459:26;1456:46;;;1498:1;1495;1488:12;1456:46;-1:-1:-1;1520:6:169;1369:163;-1:-1:-1;1369:163:169:o;1537:254::-;1631:6;1684:3;1672:9;1663:7;1659:23;1655:33;1652:53;;;1701:1;1698;1691:12;1652:53;1724:61;1777:7;1766:9;1724:61;:::i;1796:154::-;-1:-1:-1;;;;;1875:5:169;1871:54;1864:5;1861:65;1851:93;;1940:1;1937;1930:12;1955:134;2023:20;;2052:31;2023:20;2052:31;:::i;:::-;1955:134;;;:::o;2094:154::-;2152:5;2197:3;2188:6;2183:3;2179:16;2175:26;2172:46;;;2214:1;2211;2204:12;2253:380;2329:8;2339:6;2393:3;2386:4;2378:6;2374:17;2370:27;2360:55;;2411:1;2408;2401:12;2360:55;-1:-1:-1;2434:20:169;;2477:18;2466:30;;2463:50;;;2509:1;2506;2499:12;2463:50;2546:4;2538:6;2534:17;2522:29;;2606:3;2599:4;2589:6;2586:1;2582:14;2574:6;2570:27;2566:38;2563:47;2560:67;;;2623:1;2620;2613:12;2560:67;2253:380;;;;;:::o;2638:153::-;2696:5;2741:2;2732:6;2727:3;2723:16;2719:25;2716:45;;;2757:1;2754;2747:12;2796:162;2863:5;2908:2;2899:6;2894:3;2890:16;2886:25;2883:45;;;2924:1;2921;2914:12;2963:1853;3295:6;3303;3311;3319;3327;3335;3343;3351;3359;3412:3;3400:9;3391:7;3387:23;3383:33;3380:53;;;3429:1;3426;3419:12;3380:53;3452:29;3471:9;3452:29;:::i;:::-;3442:39;;3528:2;3517:9;3513:18;3500:32;3490:42;;3583:2;3572:9;3568:18;3555:32;3606:18;3647:2;3639:6;3636:14;3633:34;;;3663:1;3660;3653:12;3633:34;3686:65;3743:7;3734:6;3723:9;3719:22;3686:65;:::i;:::-;3676:75;;3804:2;3793:9;3789:18;3776:32;3760:48;;3833:2;3823:8;3820:16;3817:36;;;3849:1;3846;3839:12;3817:36;3888:85;3965:7;3954:8;3943:9;3939:24;3888:85;:::i;:::-;3992:8;;-1:-1:-1;3862:111:169;-1:-1:-1;4080:3:169;4065:19;;4052:33;;-1:-1:-1;4097:16:169;;;4094:36;;;4126:1;4123;4116:12;4094:36;4149:67;4208:7;4197:8;4186:9;4182:24;4149:67;:::i;:::-;4139:77;;4269:3;4258:9;4254:19;4241:33;4225:49;;4299:2;4289:8;4286:16;4283:36;;;4315:1;4312;4305:12;4283:36;4338:76;4406:7;4395:8;4384:9;4380:24;4338:76;:::i;:::-;4328:86;;4467:3;4456:9;4452:19;4439:33;4423:49;;4497:2;4487:8;4484:16;4481:36;;;4513:1;4510;4503:12;4481:36;4536:76;4604:7;4593:8;4582:9;4578:24;4536:76;:::i;:::-;4526:86;;4665:3;4654:9;4650:19;4637:33;4621:49;;4695:2;4685:8;4682:16;4679:36;;;4711:1;4708;4701:12;4679:36;;4734:76;4802:7;4791:8;4780:9;4776:24;4734:76;:::i;:::-;4724:86;;;2963:1853;;;;;;;;;;;:::o;4821:509::-;4936:6;4944;4997:2;4985:9;4976:7;4972:23;4968:32;4965:52;;;5013:1;5010;5003:12;4965:52;5052:9;5039:23;5071:31;5096:5;5071:31;:::i;:::-;5121:5;-1:-1:-1;5177:2:169;5162:18;;5149:32;5204:18;5193:30;;5190:50;;;5236:1;5233;5226:12;5190:50;5259:65;5316:7;5307:6;5296:9;5292:22;5259:65;:::i;:::-;5249:75;;;4821:509;;;;;:::o;5845:155::-;5904:5;5949:3;5940:6;5935:3;5931:16;5927:26;5924:46;;;5966:1;5963;5956:12;6005:1079;6197:6;6205;6213;6221;6229;6282:3;6270:9;6261:7;6257:23;6253:33;6250:53;;;6299:1;6296;6289:12;6250:53;6338:9;6325:23;6357:31;6382:5;6357:31;:::i;:::-;6407:5;-1:-1:-1;6463:2:169;6448:18;;6435:32;6486:18;6516:14;;;6513:34;;;6543:1;6540;6533:12;6513:34;6566:66;6624:7;6615:6;6604:9;6600:22;6566:66;:::i;:::-;6556:76;;6685:2;6674:9;6670:18;6657:32;6641:48;;6714:2;6704:8;6701:16;6698:36;;;6730:1;6727;6720:12;6698:36;6753:76;6821:7;6810:8;6799:9;6795:24;6753:76;:::i;:::-;6743:86;;6876:2;6865:9;6861:18;6848:32;6838:42;;6933:3;6922:9;6918:19;6905:33;6889:49;;6963:2;6953:8;6950:16;6947:36;;;6979:1;6976;6969:12;6947:36;;7002:76;7070:7;7059:8;7048:9;7044:24;7002:76;:::i;:::-;6992:86;;;6005:1079;;;;;;;;:::o;7089:180::-;7148:6;7201:2;7189:9;7180:7;7176:23;7172:32;7169:52;;;7217:1;7214;7207:12;7169:52;-1:-1:-1;7240:23:169;;7089:180;-1:-1:-1;7089:180:169:o;7274:118::-;7360:5;7353:13;7346:21;7339:5;7336:32;7326:60;;7382:1;7379;7372:12;7397:1161;7588:6;7596;7604;7612;7620;7628;7681:3;7669:9;7660:7;7656:23;7652:33;7649:53;;;7698:1;7695;7688:12;7649:53;7737:9;7724:23;7756:31;7781:5;7756:31;:::i;:::-;7806:5;-1:-1:-1;7863:2:169;7848:18;;7835:32;7876:33;7835:32;7876:33;:::i;:::-;7928:7;-1:-1:-1;7987:2:169;7972:18;;7959:32;8000:30;7959:32;8000:30;:::i;:::-;8049:7;-1:-1:-1;8107:2:169;8092:18;;8079:32;8130:18;8160:14;;;8157:34;;;8187:1;8184;8177:12;8157:34;8210:65;8267:7;8258:6;8247:9;8243:22;8210:65;:::i;:::-;8200:75;;8328:3;8317:9;8313:19;8300:33;8284:49;;8358:2;8348:8;8345:16;8342:36;;;8374:1;8371;8364:12;8342:36;;8413:85;8490:7;8479:8;8468:9;8464:24;8413:85;:::i;:::-;7397:1161;;;;-1:-1:-1;7397:1161:169;;-1:-1:-1;7397:1161:169;;8517:8;;7397:1161;-1:-1:-1;;;7397:1161:169:o;8563:574::-;8675:6;8683;8691;8744:2;8732:9;8723:7;8719:23;8715:32;8712:52;;;8760:1;8757;8750:12;8712:52;8799:9;8786:23;8818:31;8843:5;8818:31;:::i;:::-;8868:5;-1:-1:-1;8920:2:169;8905:18;;8892:32;;-1:-1:-1;8975:2:169;8960:18;;8947:32;9002:18;8991:30;;8988:50;;;9034:1;9031;9024:12;8988:50;9057:74;9123:7;9114:6;9103:9;9099:22;9057:74;:::i;:::-;9047:84;;;8563:574;;;;;:::o;9142:355::-;9228:6;9281:2;9269:9;9260:7;9256:23;9252:32;9249:52;;;9297:1;9294;9287:12;9249:52;9337:9;9324:23;9370:18;9362:6;9359:30;9356:50;;;9402:1;9399;9392:12;9356:50;9425:66;9483:7;9474:6;9463:9;9459:22;9425:66;:::i;9767:1602::-;10054:6;10062;10070;10078;10086;10094;10102;10110;10163:3;10151:9;10142:7;10138:23;10134:33;10131:53;;;10180:1;10177;10170:12;10131:53;10203:29;10222:9;10203:29;:::i;:::-;10193:39;;10279:2;10268:9;10264:18;10251:32;10241:42;;10334:2;10323:9;10319:18;10306:32;10357:18;10398:2;10390:6;10387:14;10384:34;;;10414:1;10411;10404:12;10384:34;10437:65;10494:7;10485:6;10474:9;10470:22;10437:65;:::i;:::-;10427:75;;10555:2;10544:9;10540:18;10527:32;10511:48;;10584:2;10574:8;10571:16;10568:36;;;10600:1;10597;10590:12;10568:36;10639:85;10716:7;10705:8;10694:9;10690:24;10639:85;:::i;:::-;10743:8;;-1:-1:-1;10613:111:169;-1:-1:-1;10831:3:169;10816:19;;10803:33;;-1:-1:-1;10848:16:169;;;10845:36;;;10877:1;10874;10867:12;10845:36;10900:67;10959:7;10948:8;10937:9;10933:24;10900:67;:::i;:::-;10890:77;;11020:3;11009:9;11005:19;10992:33;10976:49;;11050:2;11040:8;11037:16;11034:36;;;11066:1;11063;11056:12;11034:36;11089:76;11157:7;11146:8;11135:9;11131:24;11089:76;:::i;:::-;11079:86;;11218:3;11207:9;11203:19;11190:33;11174:49;;11248:2;11238:8;11235:16;11232:36;;;11264:1;11261;11254:12;11232:36;;11287:76;11355:7;11344:8;11333:9;11329:24;11287:76;:::i;:::-;11277:86;;;9767:1602;;;;;;;;;;;:::o;11374:1269::-;11611:6;11619;11627;11635;11643;11651;11704:3;11692:9;11683:7;11679:23;11675:33;11672:53;;;11721:1;11718;11711:12;11672:53;11744:29;11763:9;11744:29;:::i;:::-;11734:39;;11824:2;11813:9;11809:18;11796:32;11847:18;11888:2;11880:6;11877:14;11874:34;;;11904:1;11901;11894:12;11874:34;11927:66;11985:7;11976:6;11965:9;11961:22;11927:66;:::i;:::-;11917:76;;12046:2;12035:9;12031:18;12018:32;12002:48;;12075:2;12065:8;12062:16;12059:36;;;12091:1;12088;12081:12;12059:36;12114:76;12182:7;12171:8;12160:9;12156:24;12114:76;:::i;:::-;12104:86;;12237:2;12226:9;12222:18;12209:32;12199:42;;12294:3;12283:9;12279:19;12266:33;12250:49;;12324:2;12314:8;12311:16;12308:36;;;12340:1;12337;12330:12;12308:36;12363:76;12431:7;12420:8;12409:9;12405:24;12363:76;:::i;:::-;12353:86;;12492:3;12481:9;12477:19;12464:33;12448:49;;12522:2;12512:8;12509:16;12506:36;;;12538:1;12535;12528:12;12506:36;;12561:76;12629:7;12618:8;12607:9;12603:24;12561:76;:::i;:::-;12551:86;;;11374:1269;;;;;;;;:::o;12648:353::-;12733:6;12786:2;12774:9;12765:7;12761:23;12757:32;12754:52;;;12802:1;12799;12792:12;12754:52;12842:9;12829:23;12875:18;12867:6;12864:30;12861:50;;;12907:1;12904;12897:12;12861:50;12930:65;12987:7;12978:6;12967:9;12963:22;12930:65;:::i;13237:245::-;13304:6;13357:2;13345:9;13336:7;13332:23;13328:32;13325:52;;;13373:1;13370;13363:12;13325:52;13405:9;13399:16;13424:28;13446:5;13424:28;:::i;14004:247::-;14063:6;14116:2;14104:9;14095:7;14091:23;14087:32;14084:52;;;14132:1;14129;14122:12;14084:52;14171:9;14158:23;14190:31;14215:5;14190:31;:::i;14845:325::-;14933:6;14928:3;14921:19;14985:6;14978:5;14971:4;14966:3;14962:14;14949:43;;15037:1;15030:4;15021:6;15016:3;15012:16;15008:27;15001:38;14903:3;15159:4;15089:66;15084:2;15076:6;15072:15;15068:88;15063:3;15059:98;15055:109;15048:116;;14845:325;;;;:::o;15175:167::-;15242:20;;15302:14;15291:26;;15281:37;;15271:65;;15332:1;15329;15322:12;15347:1365;15593:4;-1:-1:-1;;;;;15703:2:169;15695:6;15691:15;15680:9;15673:34;15755:2;15747:6;15743:15;15738:2;15727:9;15723:18;15716:43;;15795:6;15790:2;15779:9;15775:18;15768:34;15838:3;15833:2;15822:9;15818:18;15811:31;15890:6;15877:20;15973:66;15964:6;15948:14;15944:27;15940:100;15920:18;15916:125;15906:153;;16055:1;16052;16045:12;15906:153;16081:31;;16189:2;16178:14;;;16135:19;16215:18;16204:30;;16201:50;;;16247:1;16244;16237:12;16201:50;16296:6;16280:14;16276:27;16267:7;16263:41;16260:61;;;16317:1;16314;16307:12;16260:61;16358:2;16352:3;16341:9;16337:19;16330:31;16384:63;16442:3;16431:9;16427:19;16419:6;16410:7;16384:63;:::i;:::-;16370:77;;;16476:34;16506:2;16498:6;16494:15;16476:34;:::i;:::-;16529:14;16598:2;16584:12;16580:21;16574:3;16563:9;16559:19;16552:50;16679:2;16643:34;16673:2;16665:6;16661:15;16643:34;:::i;:::-;16639:43;16633:3;16622:9;16618:19;16611:72;;;16700:6;16692:14;;;15347:1365;;;;;;;:::o;16717:277::-;16797:6;16850:2;16838:9;16829:7;16825:23;16821:32;16818:52;;;16866:1;16863;16856:12;16818:52;16905:9;16892:23;16944:1;16937:5;16934:12;16924:40;;16960:1;16957;16950:12;16999:581;17077:4;17083:6;17143:11;17130:25;17233:66;17222:8;17206:14;17202:29;17198:102;17178:18;17174:127;17164:155;;17315:1;17312;17305:12;17164:155;17342:33;;17394:20;;;-1:-1:-1;17437:18:169;17426:30;;17423:50;;;17469:1;17466;17459:12;17423:50;17502:4;17490:17;;-1:-1:-1;17533:14:169;17529:27;;;17519:38;;17516:58;;;17570:1;17567;17560:12;17585:273;17770:6;17762;17757:3;17744:33;17726:3;17796:16;;17821:13;;;17796:16;17585:273;-1:-1:-1;17585:273:169:o;18581:629::-;18699:4;18705:6;18765:11;18752:25;18855:66;18844:8;18828:14;18824:29;18820:102;18800:18;18796:127;18786:155;;18937:1;18934;18927:12;18786:155;18964:33;;19016:20;;;-1:-1:-1;19059:18:169;19048:30;;19045:50;;;19091:1;19088;19081:12;19045:50;19124:4;19112:17;;-1:-1:-1;19175:1:169;19171:14;;;19155;19151:35;19141:46;;19138:66;;;19200:1;19197;19190:12;19215:184;19267:77;19264:1;19257:88;19364:4;19361:1;19354:15;19388:4;19385:1;19378:15;19404:381;19495:4;19553:11;19540:25;19643:66;19632:8;19616:14;19612:29;19608:102;19588:18;19584:127;19574:155;;19725:1;19722;19715:12;19574:155;19746:33;;;;;19404:381;-1:-1:-1;;19404:381:169:o;20375:279::-;20440:9;;;20461:10;;;20458:190;;;20504:77;20501:1;20494:88;20605:4;20602:1;20595:15;20633:4;20630:1;20623:15;20659:184;20711:77;20708:1;20701:88;20808:4;20805:1;20798:15;20832:4;20829:1;20822:15;20848:266;20917:6;20970:2;20958:9;20949:7;20945:23;20941:32;20938:52;;;20986:1;20983;20976:12;20938:52;21025:9;21012:23;21064:1;21057:5;21054:12;21044:40;;21080:1;21077;21070:12;21119:315;21304:6;21293:9;21286:25;21347:2;21342;21331:9;21327:18;21320:30;21267:4;21367:61;21424:2;21413:9;21409:18;21401:6;21393;21367:61;:::i;21439:336::-;21508:6;21561:2;21549:9;21540:7;21536:23;21532:32;21529:52;;;21577:1;21574;21567:12;21529:52;21609:9;21603:16;21659:66;21652:5;21648:78;21641:5;21638:89;21628:117;;21741:1;21738;21731:12;21780:246;21939:2;21928:9;21921:21;21902:4;21959:61;22016:2;22005:9;22001:18;21993:6;21985;21959:61;:::i;23257:322::-;23298:3;23336:5;23330:12;23360:1;23370:128;23384:6;23381:1;23378:13;23370:128;;;23481:4;23466:13;;;23462:24;;23456:31;23443:11;;;23436:52;23399:12;23370:128;;;-1:-1:-1;23553:1:169;23517:16;;23542:13;;;-1:-1:-1;23517:16:169;;23257:322;-1:-1:-1;23257:322:169:o;23584:261::-;23759:3;23784:55;23809:29;23834:3;23826:6;23809:29;:::i;:::-;23801:6;23784:55;:::i;25071:350::-;25256:3;25287:29;25312:3;25304:6;25287:29;:::i;:::-;25325:21;;;-1:-1:-1;;25373:2:169;25362:14;;25355:30;25412:2;25401:14;;25071:350;-1:-1:-1;25071:350:169:o;25426:184::-;25478:77;25475:1;25468:88;25575:4;25572:1;25565:15;25599:4;25596:1;25589:15;25615:844;25769:4;25811:3;25800:9;25796:19;25788:27;;-1:-1:-1;;;;;25922:2:169;25913:6;25907:13;25903:22;25892:9;25885:41;25994:2;25986:4;25978:6;25974:17;25968:24;25964:33;25957:4;25946:9;25942:20;25935:63;26066:2;26058:4;26050:6;26046:17;26040:24;26036:33;26029:4;26018:9;26014:20;26007:63;;26126:4;26118:6;26114:17;26108:24;26101:4;26090:9;26086:20;26079:54;26180:4;26172:6;26168:17;26162:24;26222:1;26208:12;26205:19;26195:207;;26258:77;26255:1;26248:88;26359:4;26356:1;26349:15;26387:4;26384:1;26377:15;26195:207;26440:12;26433:4;26422:9;26418:20;26411:42;;25615:844;;;;:::o;26464:184::-;26534:6;26587:2;26575:9;26566:7;26562:23;26558:32;26555:52;;;26603:1;26600;26593:12;26555:52;-1:-1:-1;26626:16:169;;26464:184;-1:-1:-1;26464:184:169:o;26653:331::-;26758:9;26769;26811:8;26799:10;26796:24;26793:44;;;26833:1;26830;26823:12;26793:44;26862:6;26852:8;26849:20;26846:40;;;26882:1;26879;26872:12;26846:40;-1:-1:-1;;26908:23:169;;;26953:25;;;;;-1:-1:-1;26653:331:169:o;26989:608::-;27088:6;27096;27104;27112;27165:3;27153:9;27144:7;27140:23;27136:33;27133:53;;;27182:1;27179;27172:12;27133:53;27221:9;27208:23;27240:31;27265:5;27240:31;:::i;:::-;27290:5;-1:-1:-1;27347:2:169;27332:18;;27319:32;27360:33;27319:32;27360:33;:::i;:::-;27412:7;-1:-1:-1;27466:2:169;27451:18;;27438:32;;-1:-1:-1;27522:2:169;27507:18;;27494:32;27535:30;27494:32;27535:30;:::i;:::-;26989:608;;;;-1:-1:-1;26989:608:169;;-1:-1:-1;;26989:608:169:o;27602:622::-;27712:6;27720;27728;27736;27789:3;27777:9;27768:7;27764:23;27760:33;27757:53;;;27806:1;27803;27796:12;27757:53;27845:9;27832:23;27864:31;27889:5;27864:31;:::i;:::-;27914:5;-1:-1:-1;27971:2:169;27956:18;;27943:32;27984:33;27943:32;27984:33;:::i;:::-;28036:7;-1:-1:-1;28095:2:169;28080:18;;28067:32;28108:33;28067:32;28108:33;:::i;:::-;27602:622;;;;-1:-1:-1;28160:7:169;;28214:2;28199:18;28186:32;;-1:-1:-1;;27602:622:169:o;28229:991::-;28382:6;28390;28398;28406;28414;28422;28430;28483:3;28471:9;28462:7;28458:23;28454:33;28451:53;;;28500:1;28497;28490:12;28451:53;28539:9;28526:23;28558:31;28583:5;28558:31;:::i;:::-;28608:5;-1:-1:-1;28665:2:169;28650:18;;28637:32;28678:33;28637:32;28678:33;:::i;:::-;28730:7;-1:-1:-1;28789:2:169;28774:18;;28761:32;28802:33;28761:32;28802:33;:::i;:::-;28854:7;-1:-1:-1;28913:2:169;28898:18;;28885:32;28926:33;28885:32;28926:33;:::i;:::-;28978:7;-1:-1:-1;29032:3:169;29017:19;;29004:33;;-1:-1:-1;29089:3:169;29074:19;;29061:33;29103;29061;29103;:::i;:::-;29155:7;29145:17;;;29209:3;29198:9;29194:19;29181:33;29171:43;;28229:991;;;;;;;;;;:::o;29225:472::-;29318:6;29326;29334;29387:2;29375:9;29366:7;29362:23;29358:32;29355:52;;;29403:1;29400;29393:12;29355:52;29442:9;29429:23;29461:31;29486:5;29461:31;:::i;:::-;29511:5;-1:-1:-1;29568:2:169;29553:18;;29540:32;29581:33;29540:32;29581:33;:::i;:::-;29225:472;;29633:7;;-1:-1:-1;;;29687:2:169;29672:18;;;;29659:32;;29225:472::o;29702:758::-;29818:6;29826;29834;29842;29850;29903:3;29891:9;29882:7;29878:23;29874:33;29871:53;;;29920:1;29917;29910:12;29871:53;29959:9;29946:23;29978:31;30003:5;29978:31;:::i;:::-;30028:5;-1:-1:-1;30085:2:169;30070:18;;30057:32;30098:33;30057:32;30098:33;:::i;:::-;30150:7;-1:-1:-1;30209:2:169;30194:18;;30181:32;30222:33;30181:32;30222:33;:::i;:::-;30274:7;-1:-1:-1;30328:2:169;30313:18;;30300:32;;-1:-1:-1;30384:3:169;30369:19;;30356:33;30398:30;30356:33;30398:30;:::i;:::-;30447:7;30437:17;;;29702:758;;;;;;;;:::o;30465:311::-;30495:1;30529:4;30526:1;30522:12;30553:3;30543:191;;30590:77;30587:1;30580:88;30691:4;30688:1;30681:15;30719:4;30716:1;30709:15;30543:191;30766:3;30759:4;30756:1;30752:12;30748:22;30743:27;;;30465:311;;;;:::o",
-        "linkReferences": {},
-        "immutableReferences": {
-            "65518": [
-                {
-                    "start": 824,
-                    "length": 32
-                },
-                {
-                    "start": 1042,
-                    "length": 32
-                },
-                {
-                    "start": 1703,
-                    "length": 32
-                },
-                {
-                    "start": 5408,
-                    "length": 32
-                },
-                {
-                    "start": 5631,
-                    "length": 32
-                }
-            ],
-            "65523": [
-                {
-                    "start": 407,
-                    "length": 32
-                },
-                {
-                    "start": 1978,
-                    "length": 32
-                },
-                {
-                    "start": 6284,
-                    "length": 32
-                },
-                {
-                    "start": 7724,
-                    "length": 32
-                },
-                {
-                    "start": 7966,
-                    "length": 32
-                },
-                {
-                    "start": 8236,
-                    "length": 32
-                },
-                {
-                    "start": 8971,
-                    "length": 32
-                },
-                {
-                    "start": 9255,
-                    "length": 32
-                },
-                {
-                    "start": 12348,
-                    "length": 32
-                }
-            ],
-            "65528": [
-                {
-                    "start": 599,
-                    "length": 32
-                },
-                {
-                    "start": 1924,
-                    "length": 32
-                },
-                {
-                    "start": 5852,
-                    "length": 32
-                }
-            ],
-            "66488": [
-                {
-                    "start": 1444,
-                    "length": 32
-                }
-            ],
-            "66490": [
-                {
-                    "start": 1242,
-                    "length": 32
-                }
-            ]
-        }
-    },
-    "methodIdentifiers": {
-        "AUTHENTICATOR()": "c6186181",
-        "BALANCE_MANAGER()": "29bcdc95",
-        "DOMAIN_SEPARATOR()": "3644e515",
-        "REPOSITORY()": "6f35d2d2",
-        "cancelLimitOrder(uint256)": "a5cdc8fc",
-        "hashBaseTokenData((address,uint256,uint256,uint256,uint256))": "875530ff",
-        "hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": "e242924e",
-        "hashQuoteTokenData((address,uint256,uint256,uint256,uint256))": "4c9e03d3",
-        "hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))": "b11f1262",
-        "isValidSignature(bytes32,bytes)": "1626ba7e",
-        "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))": "cba673a7",
-        "settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))": "9935c868",
-        "settleSingleWithPermitsSignatures(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes),(bytes,uint48,uint48))": "db587728",
-        "settleWithPermitsSignatures(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes),(bytes,uint48,uint48))": "51d46815",
-        "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))": "5aa0e95d",
-        "validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])": "a7ab49bc",
-        "validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": "fa5cd56c",
-        "validateSignature(address,bytes32,(uint8,uint8,bytes))": "ae80c584"
-    },
-    "rawMetadata": "{\"compiler\":{\"version\":\"0.8.23+commit.f704f362\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract IAllowListAuthentication\",\"name\":\"authenticator_\",\"type\":\"address\"},{\"internalType\":\"contract IRepository\",\"name\":\"repository_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"permit2_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ECDSAInvalidSignature\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"ECDSAInvalidSignatureLength\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"ECDSAInvalidSignatureS\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAsset\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidBaseTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidDestination\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidEIP1271Signature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidEIP712Signature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidETHSignSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFillAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidHooksTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInteractionsBaseTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInteractionsQuoteTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLendingPoolInteraction\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidQuoteTokenAmounts\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignatureType\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSigner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSource\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonceInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotMaker\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotSolver\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PartialFillNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReceiverNotManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SignatureIsExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SignatureIsNotEmpty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpdatedMakerAmountsTooLow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroMakerAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"Interaction\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"TradeOrder\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"AUTHENTICATOR\",\"outputs\":[{\"internalType\":\"contract IAllowListAuthentication\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BALANCE_MANAGER\",\"outputs\":[{\"internalType\":\"contract IBalanceManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REPOSITORY\",\"outputs\":[{\"internalType\":\"contract IRepository\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"cancelLimitOrder\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"_baseTokenData\",\"type\":\"tuple\"}],\"name\":\"hashBaseTokenData\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"}],\"name\":\"hashOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"_quoteTokenData\",\"type\":\"tuple\"}],\"name\":\"hashQuoteTokenData\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ILiquoriceSettlement.Single\",\"name\":\"_order\",\"type\":\"tuple\"}],\"name\":\"hashSingleOrder\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_hash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"_signature\",\"type\":\"bytes\"}],\"name\":\"isValidSignature\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"_interactions\",\"type\":\"tuple[]\"},{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"beforeSettle\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"afterSettle\",\"type\":\"tuple[]\"}],\"internalType\":\"struct GPv2Interaction.Hooks\",\"name\":\"_hooks\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"}],\"name\":\"settle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ILiquoriceSettlement.Single\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"}],\"name\":\"settleSingle\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"quoteToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteTokenAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ILiquoriceSettlement.Single\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint48\",\"name\":\"nonce\",\"type\":\"uint48\"},{\"internalType\":\"uint48\",\"name\":\"deadline\",\"type\":\"uint48\"}],\"internalType\":\"struct Signature.TakerPermitInfo\",\"name\":\"_takerPermitInfo\",\"type\":\"tuple\"}],\"name\":\"settleSingleWithPermitsSignatures\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_filledTakerAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"_interactions\",\"type\":\"tuple[]\"},{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"beforeSettle\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"afterSettle\",\"type\":\"tuple[]\"}],\"internalType\":\"struct GPv2Interaction.Hooks\",\"name\":\"_hooks\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_makerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_takerSignature\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint48\",\"name\":\"nonce\",\"type\":\"uint48\"},{\"internalType\":\"uint48\",\"name\":\"deadline\",\"type\":\"uint48\"}],\"internalType\":\"struct Signature.TakerPermitInfo\",\"name\":\"_takerPermitInfo\",\"type\":\"tuple\"}],\"name\":\"settleWithPermitsSignatures\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IRepository\",\"name\":\"_repository\",\"type\":\"address\"},{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"beforeSettle\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"afterSettle\",\"type\":\"tuple[]\"}],\"internalType\":\"struct GPv2Interaction.Hooks\",\"name\":\"_hooks\",\"type\":\"tuple\"}],\"name\":\"validateHooks\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IRepository\",\"name\":\"_repository\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_signer\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_isPartialFill\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct GPv2Interaction.Data[]\",\"name\":\"_interactions\",\"type\":\"tuple[]\"}],\"name\":\"validateInteractions\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"rfqId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"trader\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"effectiveTrader\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quoteExpiry\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minFillAmount\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRecipient\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toRepay\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toSupply\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.BaseTokenData\",\"name\":\"baseTokenData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toTrader\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toWithdraw\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBorrow\",\"type\":\"uint256\"}],\"internalType\":\"struct ILiquoriceSettlement.QuoteTokenData\",\"name\":\"quoteTokenData\",\"type\":\"tuple\"}],\"internalType\":\"struct ILiquoriceSettlement.Order\",\"name\":\"_order\",\"type\":\"tuple\"}],\"name\":\"validateOrderAmounts\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_validationAddress\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_hash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"enum Signature.Type\",\"name\":\"signatureType\",\"type\":\"uint8\"},{\"internalType\":\"enum Signature.TransferCommand\",\"name\":\"transferCommand\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"signatureBytes\",\"type\":\"bytes\"}],\"internalType\":\"struct Signature.TypedSignature\",\"name\":\"_signature\",\"type\":\"tuple\"}],\"name\":\"validateSignature\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"ECDSAInvalidSignature()\":[{\"details\":\"The signature derives the `address(0)`.\"}],\"ECDSAInvalidSignatureLength(uint256)\":[{\"details\":\"The signature has an invalid length.\"}],\"ECDSAInvalidSignatureS(bytes32)\":[{\"details\":\"The signature has an S value that is in the upper half order.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"Interaction(address,uint256,bytes4)\":{\"params\":{\"selector\":\"Selector of the interaction function\",\"target\":\"Address of the interaction target\",\"value\":\"Value associated with the interaction\"}}},\"kind\":\"dev\",\"methods\":{\"cancelLimitOrder(uint256)\":{\"params\":{\"nonce\":\"Nonce of the order to be canceled\"}},\"hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"params\":{\"_order\":\"Order data to hash\"},\"returns\":{\"_0\":\"bytes32 Hash of the order\"}},\"hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))\":{\"params\":{\"_order\":\"Single order data to hash\"},\"returns\":{\"_0\":\"bytes32 Hash of the single order\"}},\"isValidSignature(bytes32,bytes)\":{\"params\":{\"_hash\":\"Hash of the data\",\"_signature\":\"Signature to validate\"},\"returns\":{\"_0\":\"Magic value if signature is valid, otherwise 0xffffffff\"}},\"settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))\":{\"params\":{\"_filledTakerAmount\":\"Amount filled by the taker\",\"_hooks\":\"Hooks to be called before and after settlement\",\"_interactions\":\"Array of interaction data to be executed during settlement\",\"_makerSignature\":\"Typed signature of the maker\",\"_order\":\"Order data\",\"_signer\":\"Address that signed the order\",\"_takerSignature\":\"Typed signature of the taker\"}},\"settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))\":{\"params\":{\"_filledTakerAmount\":\"Amount filled by the taker\",\"_makerSignature\":\"Signature of the maker\",\"_order\":\"Single order data\",\"_signer\":\"Address that signed the order\",\"_takerSignature\":\"Signature of the taker\"}},\"validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))\":{\"params\":{\"_hooks\":\"Hooks data\",\"_repository\":\"Repository interface\"}},\"validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])\":{\"params\":{\"_interactions\":\"Array of interaction data\",\"_order\":\"Order data\",\"_repository\":\"Repository interface\",\"_signer\":\"Signer address\"}},\"validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"params\":{\"_order\":\"Order data\"}},\"validateSignature(address,bytes32,(uint8,uint8,bytes))\":{\"params\":{\"_hash\":\"Hash of the data\",\"_signature\":\"Signature data\",\"_validationAddress\":\"Address to validate against\"}}},\"title\":\"Liquorice Settlement Contract\",\"version\":1},\"userdoc\":{\"events\":{\"Interaction(address,uint256,bytes4)\":{\"notice\":\"Emitted when an interaction is executed\"}},\"kind\":\"user\",\"methods\":{\"AUTHENTICATOR()\":{\"notice\":\"Authenticator for verifying solvers and makers\"},\"BALANCE_MANAGER()\":{\"notice\":\"Manager for handling balance transfers\"},\"REPOSITORY()\":{\"notice\":\"Repository that stores data for Lending Pools\"},\"cancelLimitOrder(uint256)\":{\"notice\":\"Cancels a limit order by invalidating its nonce\"},\"hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"notice\":\"Computes the hash of an order\"},\"hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))\":{\"notice\":\"Computes the hash of a single order\"},\"isValidSignature(bytes32,bytes)\":{\"notice\":\"Validates a signature\"},\"settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))\":{\"notice\":\"Settles a signed order with the given interactions and hooks\"},\"settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))\":{\"notice\":\"Settles a single order\"},\"validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))\":{\"notice\":\"Validates hooks for an order\"},\"validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])\":{\"notice\":\"Validates interactions for an order\"},\"validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))\":{\"notice\":\"Validates the amounts in an order\"},\"validateSignature(address,bytes32,(uint8,uint8,bytes))\":{\"notice\":\"Validates a signature\"}},\"notice\":\"Handles settlement of orders and interactions\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/contracts/settlement/LiquoriceSettlement.sol\":\"LiquoriceSettlement\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[\":@chainlink/=lib/chainlink/contracts/\",\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/\",\":chainlink/=lib/chainlink/\",\":contracts/=src/contracts/\",\":ds-test/=node_modules/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/\",\":interfaces/=src/interfaces/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/\",\":openzeppelin-upgrades/=lib/openzeppelin-upgrades/\",\":solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/\"]},\"sources\":{\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol\":{\"keccak256\":\"0xc92e946b954f185c3ca5ee56f9721aa73d64464456a46459384cb0ccf3c3856e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ae178b4e7b259557d8b93f3dd4f6f909ac72f914a9e92676e59b8d737f0423e2\",\"dweb:/ipfs/QmXeqyUJYzn6w8wyivQAtSzmwwFQnHaFYPvGad66RW1sPf\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol\":{\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://da62d6be1f5c6edf577f0cb45666a8aa9c2086a4bac87d95d65f02e2f4c36a4b\",\"dweb:/ipfs/QmNkpvBpoCMvX8JwAFNSc5XxJ2q5BXJpL5L1txb4QkqVFF\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a\",\"dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba\",\"dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x6dd0cb67846da3fa1241c520faaa215d6bec8226e37beac6056c51e8af44d24e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://650e533e62b30dcc6edea2b6c91358d5659da3bde42e56adf7316c493b916a15\",\"dweb:/ipfs/QmYkmK2vPE6FjdAoQVpZSJxamTLGno9wzGS495TcMNFViV\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Panic.sol\":{\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a\",\"dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a\",\"dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9\",\"dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x6f61a65c733690afafb4cf528b5677e704828c8350b60b948dbc1d3bb6d7689c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://00265b985b303af62ee243e10db819fa8cf890d9f122f82f4f03f55b02f62654\",\"dweb:/ipfs/QmNneFqZn2uKK6dECxatH6aENk1EMCTETi58dGaz5NCWQe\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol\":{\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8\",\"dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy\"]},\"src/contracts/lib/GPv2Interaction.sol\":{\"keccak256\":\"0x55968a83f6ae3d8d806b8faf02360abc676fb7476d05f33c0c9d324e6336fd0f\",\"license\":\"LGPL-3.0-or-later\",\"urls\":[\"bzz-raw://2d813e60c3fa006d02c8fd1aed73d2d47f9f153ac3c410d408384f3084e46de3\",\"dweb:/ipfs/QmdNyQMmyscMH6CVUkhQQfGdKdxgqhqDEe5K4iwrvcWDsk\"]},\"src/contracts/lib/Signature.sol\":{\"keccak256\":\"0xc084fe793244e2e7b0f4a51440df7dbf97d39b4ad6450a2b8a082cb6d86993b5\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://9bff9732e68149a83f2e044c7f1700432997750166cd15f4a54f73bd68a475aa\",\"dweb:/ipfs/QmZJMNppHQ3nUDcJhAkrMYa4QWhGLDr4Tzah6LndgrDCib\"]},\"src/contracts/settlement/BalanceManager.sol\":{\"keccak256\":\"0x82d5d0de5cf88ff8882f1f7a2d05b98ed32bb3f2a6b9eab728ce55ae943e67c3\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://ebcbe822ad5c68896a12ecd60e17ba6a2ed0ba8e0544c7ad54d88d1c25206b5c\",\"dweb:/ipfs/QmYEZeKUEz7Nw6MW9uZHnXvkeRTmmcS1WZhx77s9kUWSWw\"]},\"src/contracts/settlement/LiquoriceSettlement.sol\":{\"keccak256\":\"0xcac528919829fc8e021cec4325b38835866a7d0630b61349deae6ecfbe0ddaef\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://6d6dafbba3885b42cb97be6d190ac1f611548ceb2116e9b6ed7da9bf422c8b58\",\"dweb:/ipfs/QmZQk6WQNgYqsu9Z85tPF2VQGXgaYzvpEqc7VEmJ4zEEJU\"]},\"src/contracts/settlement/Signing.sol\":{\"keccak256\":\"0xad9e59ae740627e5b71fa1ebde019999084480664d06d18f0a01e4d31fa32ef6\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://ea0e0021cd0074292b04f9921f6ca3cc77a6799c86cacabb9dc6ff7dadbd7933\",\"dweb:/ipfs/QmPjY69PntfUGW5eNrNe98DCTemq6daRqUiLFkcYvVWuvh\"]},\"src/interfaces/IACLManager.sol\":{\"keccak256\":\"0xeee5cbedcfaff01733979b8f439a817aa67b09d9e330d21e11f180dceebed024\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://814431cd9df23d0d7cc0f9761927e2aa18fc7fa599f34422f332ee6352580d69\",\"dweb:/ipfs/QmXLdGsdMyeX5j64rAaByz35SwEMPMQ7usXwruWjEPo6Cz\"]},\"src/interfaces/IAllowListAuthentication.sol\":{\"keccak256\":\"0xbabb9eda80757d9355ab9863fccb3fdb1f15c1cbce458c3236d792d007077a9e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fa97e90b315ffc3cae3998adda6810c856ea96be015e797723e13b436d1a10\",\"dweb:/ipfs/Qme1dzXXcMDQpeqyqfuSbZDY6GKWjyrRBQrNDjitPeXQEF\"]},\"src/interfaces/IBalanceManager.sol\":{\"keccak256\":\"0xc4cff6f33170df6d91a866ee69263c9b90091e94027bea04038558c315e6e127\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://867164a381fb78da320c89db6b15978becd49be61e2349abc805362904bffb4e\",\"dweb:/ipfs/QmPY9UYCi9YVdCC8A1UxmTPcnV5BmMj93Gq1nqxBv4fMJ7\"]},\"src/interfaces/IInterestRateModel.sol\":{\"keccak256\":\"0xccd4c1dea98176c392de07cb8f5a2ac969405090d42d831310fa53464c0d9264\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a22b5b87be29e616142b6c4677e109e9246157c4b7e6378334fbc7ba403d82de\",\"dweb:/ipfs/QmXmSF34VsktTfqSCJU8Mz9sTaXGVk7xdYQwr9NcsR3k43\"]},\"src/interfaces/ILiquoriceSettlement.sol\":{\"keccak256\":\"0xa4a36d51f174d9994c39287f89e63bbea57ff5adcd2a9bc649c67bb5cae75272\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8562fe9fc033c3e3320c5d95ad10e49f5e23ea50a5e9eaf186cbf53d9f1ce7a6\",\"dweb:/ipfs/QmXKSjRi8oxmS5xd5V95HofYtFzYfehbL6s8t2MKoXR7y1\"]},\"src/interfaces/IPriceProvider.sol\":{\"keccak256\":\"0x75812be8d692287010f5ee9ce13556df1bd8299faa64b42c49cd08cf7cc53847\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://623d4faa57b078a33a2afe0d13fc426c4a750ae7f07f9d826000047dab54148e\",\"dweb:/ipfs/QmYmFpZnLug6FBG9C8s1mxPBjZHwiCk7cRBC7A9WXtyGKE\"]},\"src/interfaces/IRepository.sol\":{\"keccak256\":\"0xf08a5812ce10042564d518994db487c49d9f35d511da07a5103b9b886b6e2607\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b602c9f5a61c9796f711330ee56d4f0287adc656c686acf391d4e8c45453e6d0\",\"dweb:/ipfs/QmQ7XJ1qERgRxWurpkS3t1XDtuBUTpQEz14h4eXBc8vp9t\"]},\"src/interfaces/external/permit/IAllowanceTransfer.sol\":{\"keccak256\":\"0x23986b17f0c10296cb8afadb43014cd7901f56dac5ba85067d18ca7db7d3e37e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5f6ec55ce038e045b15a89a7f19fa45aa09d42a52517dd1846968d16777d3a9b\",\"dweb:/ipfs/QmZXthQLUtRFgqGv3bFbijmNk5Vviacrf7VnRDbXEQjdBQ\"]},\"src/interfaces/external/permit/IEIP712.sol\":{\"keccak256\":\"0x07e44e64248ed6316fe1db6f44c80468b950e6d1ab4bfdf21a65cbbd27718f77\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://58487548bc5289e7f5a4d4c278e5c7e9a7829d8a5be024a42938943f8c8fb63b\",\"dweb:/ipfs/QmYg63mq3SgXH6H4Wyvznb1E5fEjw6W7NeLASUcRjMuKYa\"]}},\"version\":1}",
-    "metadata": {
-        "compiler": {
-            "version": "0.8.23+commit.f704f362"
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidFillAmount"
         },
-        "language": "Solidity",
-        "output": {
-            "abi": [
-                {
-                    "inputs": [
-                        {
-                            "internalType": "contract IAllowListAuthentication",
-                            "name": "authenticator_",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "contract IRepository",
-                            "name": "repository_",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "permit2_",
-                            "type": "address"
-                        }
-                    ],
-                    "stateMutability": "nonpayable",
-                    "type": "constructor"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "ECDSAInvalidSignature"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "uint256",
-                            "name": "length",
-                            "type": "uint256"
-                        }
-                    ],
-                    "type": "error",
-                    "name": "ECDSAInvalidSignatureLength"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "s",
-                            "type": "bytes32"
-                        }
-                    ],
-                    "type": "error",
-                    "name": "ECDSAInvalidSignatureS"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidAmount"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidAsset"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidBaseTokenAmounts"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidDestination"
-                },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidHooksTarget"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidInteractionsBaseTokenAmounts"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidInteractionsQuoteTokenAmounts"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidLendingPoolInteraction"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidQuoteTokenAmounts"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidSignatureType"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidSigner"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "InvalidSource"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "NonceInvalid"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "NotMaker"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "NotSolver"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "OrderExpired"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "PartialFillNotSupported"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "ReceiverNotManager"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "ReentrancyGuardReentrantCall"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "token",
+              "type": "address"
+            }
+          ],
+          "type": "error",
+          "name": "SafeERC20FailedOperation"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "SignatureIsExpired"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "SignatureIsNotEmpty"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "UpdatedMakerAmountsTooLow"
+        },
+        {
+          "inputs": [],
+          "type": "error",
+          "name": "ZeroMakerAmount"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "target",
+              "type": "address",
+              "indexed": true
+            },
+            {
+              "internalType": "uint256",
+              "name": "value",
+              "type": "uint256",
+              "indexed": false
+            },
+            {
+              "internalType": "bytes4",
+              "name": "selector",
+              "type": "bytes4",
+              "indexed": false
+            }
+          ],
+          "type": "event",
+          "name": "Interaction",
+          "anonymous": false
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "string",
+              "name": "rfqId",
+              "type": "string",
+              "indexed": true
+            },
+            {
+              "internalType": "address",
+              "name": "trader",
+              "type": "address",
+              "indexed": false
+            },
+            {
+              "internalType": "address",
+              "name": "effectiveTrader",
+              "type": "address",
+              "indexed": false
+            },
+            {
+              "internalType": "address",
+              "name": "baseToken",
+              "type": "address",
+              "indexed": false
+            },
+            {
+              "internalType": "address",
+              "name": "quoteToken",
+              "type": "address",
+              "indexed": false
+            },
+            {
+              "internalType": "uint256",
+              "name": "baseTokenAmount",
+              "type": "uint256",
+              "indexed": false
+            },
+            {
+              "internalType": "uint256",
+              "name": "quoteTokenAmount",
+              "type": "uint256",
+              "indexed": false
+            },
+            {
+              "internalType": "address",
+              "name": "recipient",
+              "type": "address",
+              "indexed": false
+            }
+          ],
+          "type": "event",
+          "name": "TradeOrder",
+          "anonymous": false
+        },
+        {
+          "inputs": [],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "AUTHENTICATOR",
+          "outputs": [
+            {
+              "internalType": "contract IAllowListAuthentication",
+              "name": "",
+              "type": "address"
+            }
+          ]
+        },
+        {
+          "inputs": [],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "BALANCE_MANAGER",
+          "outputs": [
+            {
+              "internalType": "contract IBalanceManager",
+              "name": "",
+              "type": "address"
+            }
+          ]
+        },
+        {
+          "inputs": [],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "DOMAIN_SEPARATOR",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "",
+              "type": "bytes32"
+            }
+          ]
+        },
+        {
+          "inputs": [],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "REPOSITORY",
+          "outputs": [
+            {
+              "internalType": "contract IRepository",
+              "name": "",
+              "type": "address"
+            }
+          ]
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "uint256",
+              "name": "nonce",
+              "type": "uint256"
+            }
+          ],
+          "stateMutability": "nonpayable",
+          "type": "function",
+          "name": "cancelLimitOrder"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+              "name": "_baseTokenData",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "addr",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "toRecipient",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "toRepay",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "toSupply",
+                  "type": "uint256"
+                }
+              ]
+            }
+          ],
+          "stateMutability": "pure",
+          "type": "function",
+          "name": "hashBaseTokenData",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "",
+              "type": "bytes32"
+            }
+          ]
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "struct ILiquoriceSettlement.Order",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "market",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "chainId",
+                  "type": "uint256"
+                },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidEIP1271Signature"
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidEIP712Signature"
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidETHSignSignature"
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidFillAmount"
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidHooksTarget"
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidInteractionsBaseTokenAmounts"
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+                  "name": "baseTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRecipient",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRepay",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toSupply",
+                      "type": "uint256"
+                    }
+                  ]
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidInteractionsQuoteTokenAmounts"
+                  "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+                  "name": "quoteTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toTrader",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toWithdraw",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toBorrow",
+                      "type": "uint256"
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "hashOrder",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "",
+              "type": "bytes32"
+            }
+          ]
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+              "name": "_quoteTokenData",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "addr",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidLendingPoolInteraction"
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidQuoteTokenAmounts"
+                  "internalType": "uint256",
+                  "name": "toTrader",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidSignatureType"
+                  "internalType": "uint256",
+                  "name": "toWithdraw",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidSigner"
+                  "internalType": "uint256",
+                  "name": "toBorrow",
+                  "type": "uint256"
+                }
+              ]
+            }
+          ],
+          "stateMutability": "pure",
+          "type": "function",
+          "name": "hashQuoteTokenData",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "",
+              "type": "bytes32"
+            }
+          ]
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "struct ILiquoriceSettlement.Single",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "InvalidSource"
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "NonceInvalid"
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "NotMaker"
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "NotSolver"
+                  "internalType": "address",
+                  "name": "baseToken",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "OrderExpired"
+                  "internalType": "address",
+                  "name": "quoteToken",
+                  "type": "address"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "PartialFillNotSupported"
+                  "internalType": "uint256",
+                  "name": "baseTokenAmount",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "ReceiverNotManager"
+                  "internalType": "uint256",
+                  "name": "quoteTokenAmount",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "ReentrancyGuardReentrantCall"
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "token",
-                            "type": "address"
-                        }
-                    ],
-                    "type": "error",
-                    "name": "SafeERC20FailedOperation"
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
                 },
                 {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "SignatureIsExpired"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "SignatureIsNotEmpty"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "UpdatedMakerAmountsTooLow"
-                },
-                {
-                    "inputs": [],
-                    "type": "error",
-                    "name": "ZeroMakerAmount"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "target",
-                            "type": "address",
-                            "indexed": true
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "value",
-                            "type": "uint256",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "bytes4",
-                            "name": "selector",
-                            "type": "bytes4",
-                            "indexed": false
-                        }
-                    ],
-                    "type": "event",
-                    "name": "Interaction",
-                    "anonymous": false
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "string",
-                            "name": "rfqId",
-                            "type": "string",
-                            "indexed": true
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "trader",
-                            "type": "address",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "effectiveTrader",
-                            "type": "address",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "baseToken",
-                            "type": "address",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "quoteToken",
-                            "type": "address",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "baseTokenAmount",
-                            "type": "uint256",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "quoteTokenAmount",
-                            "type": "uint256",
-                            "indexed": false
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "recipient",
-                            "type": "address",
-                            "indexed": false
-                        }
-                    ],
-                    "type": "event",
-                    "name": "TradeOrder",
-                    "anonymous": false
-                },
-                {
-                    "inputs": [],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "AUTHENTICATOR",
-                    "outputs": [
-                        {
-                            "internalType": "contract IAllowListAuthentication",
-                            "name": "",
-                            "type": "address"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "BALANCE_MANAGER",
-                    "outputs": [
-                        {
-                            "internalType": "contract IBalanceManager",
-                            "name": "",
-                            "type": "address"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "DOMAIN_SEPARATOR",
-                    "outputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "",
-                            "type": "bytes32"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "REPOSITORY",
-                    "outputs": [
-                        {
-                            "internalType": "contract IRepository",
-                            "name": "",
-                            "type": "address"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "uint256",
-                            "name": "nonce",
-                            "type": "uint256"
-                        }
-                    ],
-                    "stateMutability": "nonpayable",
-                    "type": "function",
-                    "name": "cancelLimitOrder"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                            "name": "_baseTokenData",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "addr",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "amount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "toRecipient",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "toRepay",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "toSupply",
-                                    "type": "uint256"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "pure",
-                    "type": "function",
-                    "name": "hashBaseTokenData",
-                    "outputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "",
-                            "type": "bytes32"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Order",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "market",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "chainId",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                                    "name": "baseTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRecipient",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRepay",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toSupply",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                                    "name": "quoteTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toTrader",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toWithdraw",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toBorrow",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "hashOrder",
-                    "outputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "",
-                            "type": "bytes32"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                            "name": "_quoteTokenData",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "addr",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "amount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "toTrader",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "toWithdraw",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "toBorrow",
-                                    "type": "uint256"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "pure",
-                    "type": "function",
-                    "name": "hashQuoteTokenData",
-                    "outputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "",
-                            "type": "bytes32"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Single",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "baseToken",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "quoteToken",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "baseTokenAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteTokenAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "hashSingleOrder",
-                    "outputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "",
-                            "type": "bytes32"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "bytes32",
-                            "name": "_hash",
-                            "type": "bytes32"
-                        },
-                        {
-                            "internalType": "bytes",
-                            "name": "_signature",
-                            "type": "bytes"
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "isValidSignature",
-                    "outputs": [
-                        {
-                            "internalType": "bytes4",
-                            "name": "",
-                            "type": "bytes4"
-                        }
-                    ]
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "_signer",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "_filledTakerAmount",
-                            "type": "uint256"
-                        },
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Order",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "market",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "chainId",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                                    "name": "baseTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRecipient",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRepay",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toSupply",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                                    "name": "quoteTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toTrader",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toWithdraw",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toBorrow",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "name": "_interactions",
-                            "type": "tuple[]",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "target",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "value",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "callData",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct GPv2Interaction.Hooks",
-                            "name": "_hooks",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "struct GPv2Interaction.Data[]",
-                                    "name": "beforeSettle",
-                                    "type": "tuple[]",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "target",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "value",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "bytes",
-                                            "name": "callData",
-                                            "type": "bytes"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct GPv2Interaction.Data[]",
-                                    "name": "afterSettle",
-                                    "type": "tuple[]",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "target",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "value",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "bytes",
-                                            "name": "callData",
-                                            "type": "bytes"
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_makerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_takerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "nonpayable",
-                    "type": "function",
-                    "name": "settle"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "_signer",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Single",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "baseToken",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "quoteToken",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "baseTokenAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteTokenAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_makerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "_filledTakerAmount",
-                            "type": "uint256"
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_takerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "payable",
-                    "type": "function",
-                    "name": "settleSingle"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "_signer",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Single",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "baseToken",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "quoteToken",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "baseTokenAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteTokenAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_makerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "_filledTakerAmount",
-                            "type": "uint256"
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_takerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TakerPermitInfo",
-                            "name": "_takerPermitInfo",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signature",
-                                    "type": "bytes"
-                                },
-                                {
-                                    "internalType": "uint48",
-                                    "name": "nonce",
-                                    "type": "uint48"
-                                },
-                                {
-                                    "internalType": "uint48",
-                                    "name": "deadline",
-                                    "type": "uint48"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "payable",
-                    "type": "function",
-                    "name": "settleSingleWithPermitsSignatures"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "_signer",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "uint256",
-                            "name": "_filledTakerAmount",
-                            "type": "uint256"
-                        },
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Order",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "market",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "chainId",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                                    "name": "baseTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRecipient",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRepay",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toSupply",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                                    "name": "quoteTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toTrader",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toWithdraw",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toBorrow",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "name": "_interactions",
-                            "type": "tuple[]",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "target",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "value",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "callData",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct GPv2Interaction.Hooks",
-                            "name": "_hooks",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "struct GPv2Interaction.Data[]",
-                                    "name": "beforeSettle",
-                                    "type": "tuple[]",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "target",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "value",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "bytes",
-                                            "name": "callData",
-                                            "type": "bytes"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct GPv2Interaction.Data[]",
-                                    "name": "afterSettle",
-                                    "type": "tuple[]",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "target",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "value",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "bytes",
-                                            "name": "callData",
-                                            "type": "bytes"
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_makerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_takerSignature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct Signature.TakerPermitInfo",
-                            "name": "_takerPermitInfo",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signature",
-                                    "type": "bytes"
-                                },
-                                {
-                                    "internalType": "uint48",
-                                    "name": "nonce",
-                                    "type": "uint48"
-                                },
-                                {
-                                    "internalType": "uint48",
-                                    "name": "deadline",
-                                    "type": "uint48"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "payable",
-                    "type": "function",
-                    "name": "settleWithPermitsSignatures"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "contract IRepository",
-                            "name": "_repository",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "struct GPv2Interaction.Hooks",
-                            "name": "_hooks",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "struct GPv2Interaction.Data[]",
-                                    "name": "beforeSettle",
-                                    "type": "tuple[]",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "target",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "value",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "bytes",
-                                            "name": "callData",
-                                            "type": "bytes"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct GPv2Interaction.Data[]",
-                                    "name": "afterSettle",
-                                    "type": "tuple[]",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "target",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "value",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "bytes",
-                                            "name": "callData",
-                                            "type": "bytes"
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "validateHooks"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "contract IRepository",
-                            "name": "_repository",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "address",
-                            "name": "_signer",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "bool",
-                            "name": "_isPartialFill",
-                            "type": "bool"
-                        },
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Order",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "market",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "chainId",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                                    "name": "baseTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRecipient",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRepay",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toSupply",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                                    "name": "quoteTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toTrader",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toWithdraw",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toBorrow",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                        {
-                            "internalType": "struct GPv2Interaction.Data[]",
-                            "name": "_interactions",
-                            "type": "tuple[]",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "target",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "value",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "callData",
-                                    "type": "bytes"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "validateInteractions"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "struct ILiquoriceSettlement.Order",
-                            "name": "_order",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "address",
-                                    "name": "market",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "chainId",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "string",
-                                    "name": "rfqId",
-                                    "type": "string"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "nonce",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "trader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "effectiveTrader",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "quoteExpiry",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "address",
-                                    "name": "recipient",
-                                    "type": "address"
-                                },
-                                {
-                                    "internalType": "uint256",
-                                    "name": "minFillAmount",
-                                    "type": "uint256"
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-                                    "name": "baseTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRecipient",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toRepay",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toSupply",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                },
-                                {
-                                    "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-                                    "name": "quoteTokenData",
-                                    "type": "tuple",
-                                    "components": [
-                                        {
-                                            "internalType": "address",
-                                            "name": "addr",
-                                            "type": "address"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "amount",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toTrader",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toWithdraw",
-                                            "type": "uint256"
-                                        },
-                                        {
-                                            "internalType": "uint256",
-                                            "name": "toBorrow",
-                                            "type": "uint256"
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "pure",
-                    "type": "function",
-                    "name": "validateOrderAmounts"
-                },
-                {
-                    "inputs": [
-                        {
-                            "internalType": "address",
-                            "name": "_validationAddress",
-                            "type": "address"
-                        },
-                        {
-                            "internalType": "bytes32",
-                            "name": "_hash",
-                            "type": "bytes32"
-                        },
-                        {
-                            "internalType": "struct Signature.TypedSignature",
-                            "name": "_signature",
-                            "type": "tuple",
-                            "components": [
-                                {
-                                    "internalType": "enum Signature.Type",
-                                    "name": "signatureType",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "enum Signature.TransferCommand",
-                                    "name": "transferCommand",
-                                    "type": "uint8"
-                                },
-                                {
-                                    "internalType": "bytes",
-                                    "name": "signatureBytes",
-                                    "type": "bytes"
-                                }
-                            ]
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function",
-                    "name": "validateSignature"
-                },
-                {
-                    "inputs": [],
-                    "stateMutability": "payable",
-                    "type": "receive"
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
                 }
-            ],
-            "devdoc": {
-                "kind": "dev",
-                "methods": {
-                    "cancelLimitOrder(uint256)": {
-                        "params": {
-                            "nonce": "Nonce of the order to be canceled"
-                        }
-                    },
-                    "hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
-                        "params": {
-                            "_order": "Order data to hash"
-                        },
-                        "returns": {
-                            "_0": "bytes32 Hash of the order"
-                        }
+              ]
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "hashSingleOrder",
+          "outputs": [
+            {
+              "internalType": "bytes32",
+              "name": "",
+              "type": "bytes32"
+            }
+          ]
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes32",
+              "name": "_hash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bytes",
+              "name": "_signature",
+              "type": "bytes"
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "isValidSignature",
+          "outputs": [
+            {
+              "internalType": "bytes4",
+              "name": "",
+              "type": "bytes4"
+            }
+          ]
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "_signer",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "_filledTakerAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "struct ILiquoriceSettlement.Order",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "market",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "chainId",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+                  "name": "baseTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
                     },
-                    "hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))": {
-                        "params": {
-                            "_order": "Single order data to hash"
-                        },
-                        "returns": {
-                            "_0": "bytes32 Hash of the single order"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
                     },
-                    "isValidSignature(bytes32,bytes)": {
-                        "params": {
-                            "_hash": "Hash of the data",
-                            "_signature": "Signature to validate"
-                        },
-                        "returns": {
-                            "_0": "Magic value if signature is valid, otherwise 0xffffffff"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "toRecipient",
+                      "type": "uint256"
                     },
-                    "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))": {
-                        "params": {
-                            "_filledTakerAmount": "Amount filled by the taker",
-                            "_hooks": "Hooks to be called before and after settlement",
-                            "_interactions": "Array of interaction data to be executed during settlement",
-                            "_makerSignature": "Typed signature of the maker",
-                            "_order": "Order data",
-                            "_signer": "Address that signed the order",
-                            "_takerSignature": "Typed signature of the taker"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "toRepay",
+                      "type": "uint256"
                     },
-                    "settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))": {
-                        "params": {
-                            "_filledTakerAmount": "Amount filled by the taker",
-                            "_makerSignature": "Signature of the maker",
-                            "_order": "Single order data",
-                            "_signer": "Address that signed the order",
-                            "_takerSignature": "Signature of the taker"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "toSupply",
+                      "type": "uint256"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+                  "name": "quoteTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
                     },
-                    "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))": {
-                        "params": {
-                            "_hooks": "Hooks data",
-                            "_repository": "Repository interface"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
                     },
-                    "validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])": {
-                        "params": {
-                            "_interactions": "Array of interaction data",
-                            "_order": "Order data",
-                            "_repository": "Repository interface",
-                            "_signer": "Signer address"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "toTrader",
+                      "type": "uint256"
                     },
-                    "validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
-                        "params": {
-                            "_order": "Order data"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "toWithdraw",
+                      "type": "uint256"
                     },
-                    "validateSignature(address,bytes32,(uint8,uint8,bytes))": {
-                        "params": {
-                            "_hash": "Hash of the data",
-                            "_signature": "Signature data",
-                            "_validationAddress": "Address to validate against"
-                        }
+                    {
+                      "internalType": "uint256",
+                      "name": "toBorrow",
+                      "type": "uint256"
                     }
+                  ]
+                }
+              ]
+            },
+            {
+              "internalType": "struct GPv2Interaction.Data[]",
+              "name": "_interactions",
+              "type": "tuple[]",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "target",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "value",
+                  "type": "uint256"
                 },
-                "version": 1
+                {
+                  "internalType": "bytes",
+                  "name": "callData",
+                  "type": "bytes"
+                }
+              ]
             },
-            "userdoc": {
-                "kind": "user",
-                "methods": {
-                    "AUTHENTICATOR()": {
-                        "notice": "Authenticator for verifying solvers and makers"
-                    },
-                    "BALANCE_MANAGER()": {
-                        "notice": "Manager for handling balance transfers"
+            {
+              "internalType": "struct GPv2Interaction.Hooks",
+              "name": "_hooks",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "struct GPv2Interaction.Data[]",
+                  "name": "beforeSettle",
+                  "type": "tuple[]",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "target",
+                      "type": "address"
                     },
-                    "REPOSITORY()": {
-                        "notice": "Repository that stores data for Lending Pools"
+                    {
+                      "internalType": "uint256",
+                      "name": "value",
+                      "type": "uint256"
                     },
-                    "cancelLimitOrder(uint256)": {
-                        "notice": "Cancels a limit order by invalidating its nonce"
-                    },
-                    "hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
-                        "notice": "Computes the hash of an order"
-                    },
-                    "hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))": {
-                        "notice": "Computes the hash of a single order"
-                    },
-                    "isValidSignature(bytes32,bytes)": {
-                        "notice": "Validates a signature"
-                    },
-                    "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))": {
-                        "notice": "Settles a signed order with the given interactions and hooks"
-                    },
-                    "settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))": {
-                        "notice": "Settles a single order"
-                    },
-                    "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))": {
-                        "notice": "Validates hooks for an order"
-                    },
-                    "validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])": {
-                        "notice": "Validates interactions for an order"
+                    {
+                      "internalType": "bytes",
+                      "name": "callData",
+                      "type": "bytes"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct GPv2Interaction.Data[]",
+                  "name": "afterSettle",
+                  "type": "tuple[]",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "target",
+                      "type": "address"
                     },
-                    "validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
-                        "notice": "Validates the amounts in an order"
+                    {
+                      "internalType": "uint256",
+                      "name": "value",
+                      "type": "uint256"
                     },
-                    "validateSignature(address,bytes32,(uint8,uint8,bytes))": {
-                        "notice": "Validates a signature"
+                    {
+                      "internalType": "bytes",
+                      "name": "callData",
+                      "type": "bytes"
                     }
+                  ]
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_makerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_takerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
                 },
-                "version": 1
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
             }
+          ],
+          "stateMutability": "nonpayable",
+          "type": "function",
+          "name": "settle"
         },
-        "settings": {
-            "remappings": [
-                "@chainlink/=lib/chainlink/contracts/",
-                "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
-                "@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
-                "chainlink/=lib/chainlink/",
-                "contracts/=src/contracts/",
-                "ds-test/=node_modules/ds-test/src/",
-                "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
-                "forge-std/=lib/forge-std/src/",
-                "halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
-                "interfaces/=src/interfaces/",
-                "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
-                "openzeppelin-contracts/=lib/openzeppelin-contracts/",
-                "openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
-                "openzeppelin-upgrades/=lib/openzeppelin-upgrades/",
-                "solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/"
-            ],
-            "optimizer": {
-                "enabled": true,
-                "runs": 10000
-            },
-            "metadata": {
-                "bytecodeHash": "ipfs"
-            },
-            "compilationTarget": {
-                "src/contracts/settlement/LiquoriceSettlement.sol": "LiquoriceSettlement"
-            },
-            "evmVersion": "shanghai",
-            "libraries": {}
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "_signer",
+              "type": "address"
+            },
+            {
+              "internalType": "struct ILiquoriceSettlement.Single",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "baseToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "quoteToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "baseTokenAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteTokenAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_makerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "uint256",
+              "name": "_filledTakerAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_takerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            }
+          ],
+          "stateMutability": "payable",
+          "type": "function",
+          "name": "settleSingle"
         },
-        "sources": {
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol": {
-                "keccak256": "0xc92e946b954f185c3ca5ee56f9721aa73d64464456a46459384cb0ccf3c3856e",
-                "urls": [
-                    "bzz-raw://ae178b4e7b259557d8b93f3dd4f6f909ac72f914a9e92676e59b8d737f0423e2",
-                    "dweb:/ipfs/QmXeqyUJYzn6w8wyivQAtSzmwwFQnHaFYPvGad66RW1sPf"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol": {
-                "keccak256": "0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7",
-                "urls": [
-                    "bzz-raw://da62d6be1f5c6edf577f0cb45666a8aa9c2086a4bac87d95d65f02e2f4c36a4b",
-                    "dweb:/ipfs/QmNkpvBpoCMvX8JwAFNSc5XxJ2q5BXJpL5L1txb4QkqVFF"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol": {
-                "keccak256": "0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724",
-                "urls": [
-                    "bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a",
-                    "dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol": {
-                "keccak256": "0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c",
-                "urls": [
-                    "bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba",
-                    "dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol": {
-                "keccak256": "0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7",
-                "urls": [
-                    "bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db",
-                    "dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol": {
-                "keccak256": "0x6dd0cb67846da3fa1241c520faaa215d6bec8226e37beac6056c51e8af44d24e",
-                "urls": [
-                    "bzz-raw://650e533e62b30dcc6edea2b6c91358d5659da3bde42e56adf7316c493b916a15",
-                    "dweb:/ipfs/QmYkmK2vPE6FjdAoQVpZSJxamTLGno9wzGS495TcMNFViV"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Panic.sol": {
-                "keccak256": "0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a",
-                "urls": [
-                    "bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a",
-                    "dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol": {
-                "keccak256": "0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3",
-                "urls": [
-                    "bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a",
-                    "dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol": {
-                "keccak256": "0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84",
-                "urls": [
-                    "bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9",
-                    "dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol": {
-                "keccak256": "0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8",
-                "urls": [
-                    "bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621",
-                    "dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/Math.sol": {
-                "keccak256": "0x6f61a65c733690afafb4cf528b5677e704828c8350b60b948dbc1d3bb6d7689c",
-                "urls": [
-                    "bzz-raw://00265b985b303af62ee243e10db819fa8cf890d9f122f82f4f03f55b02f62654",
-                    "dweb:/ipfs/QmNneFqZn2uKK6dECxatH6aENk1EMCTETi58dGaz5NCWQe"
-                ],
-                "license": "MIT"
-            },
-            "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol": {
-                "keccak256": "0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54",
-                "urls": [
-                    "bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8",
-                    "dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy"
-                ],
-                "license": "MIT"
-            },
-            "src/contracts/lib/GPv2Interaction.sol": {
-                "keccak256": "0x55968a83f6ae3d8d806b8faf02360abc676fb7476d05f33c0c9d324e6336fd0f",
-                "urls": [
-                    "bzz-raw://2d813e60c3fa006d02c8fd1aed73d2d47f9f153ac3c410d408384f3084e46de3",
-                    "dweb:/ipfs/QmdNyQMmyscMH6CVUkhQQfGdKdxgqhqDEe5K4iwrvcWDsk"
-                ],
-                "license": "LGPL-3.0-or-later"
-            },
-            "src/contracts/lib/Signature.sol": {
-                "keccak256": "0xc084fe793244e2e7b0f4a51440df7dbf97d39b4ad6450a2b8a082cb6d86993b5",
-                "urls": [
-                    "bzz-raw://9bff9732e68149a83f2e044c7f1700432997750166cd15f4a54f73bd68a475aa",
-                    "dweb:/ipfs/QmZJMNppHQ3nUDcJhAkrMYa4QWhGLDr4Tzah6LndgrDCib"
-                ],
-                "license": "BUSL-1.1"
-            },
-            "src/contracts/settlement/BalanceManager.sol": {
-                "keccak256": "0x82d5d0de5cf88ff8882f1f7a2d05b98ed32bb3f2a6b9eab728ce55ae943e67c3",
-                "urls": [
-                    "bzz-raw://ebcbe822ad5c68896a12ecd60e17ba6a2ed0ba8e0544c7ad54d88d1c25206b5c",
-                    "dweb:/ipfs/QmYEZeKUEz7Nw6MW9uZHnXvkeRTmmcS1WZhx77s9kUWSWw"
-                ],
-                "license": "BUSL-1.1"
-            },
-            "src/contracts/settlement/LiquoriceSettlement.sol": {
-                "keccak256": "0xcac528919829fc8e021cec4325b38835866a7d0630b61349deae6ecfbe0ddaef",
-                "urls": [
-                    "bzz-raw://6d6dafbba3885b42cb97be6d190ac1f611548ceb2116e9b6ed7da9bf422c8b58",
-                    "dweb:/ipfs/QmZQk6WQNgYqsu9Z85tPF2VQGXgaYzvpEqc7VEmJ4zEEJU"
-                ],
-                "license": "BUSL-1.1"
-            },
-            "src/contracts/settlement/Signing.sol": {
-                "keccak256": "0xad9e59ae740627e5b71fa1ebde019999084480664d06d18f0a01e4d31fa32ef6",
-                "urls": [
-                    "bzz-raw://ea0e0021cd0074292b04f9921f6ca3cc77a6799c86cacabb9dc6ff7dadbd7933",
-                    "dweb:/ipfs/QmPjY69PntfUGW5eNrNe98DCTemq6daRqUiLFkcYvVWuvh"
-                ],
-                "license": "BUSL-1.1"
-            },
-            "src/interfaces/IACLManager.sol": {
-                "keccak256": "0xeee5cbedcfaff01733979b8f439a817aa67b09d9e330d21e11f180dceebed024",
-                "urls": [
-                    "bzz-raw://814431cd9df23d0d7cc0f9761927e2aa18fc7fa599f34422f332ee6352580d69",
-                    "dweb:/ipfs/QmXLdGsdMyeX5j64rAaByz35SwEMPMQ7usXwruWjEPo6Cz"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/IAllowListAuthentication.sol": {
-                "keccak256": "0xbabb9eda80757d9355ab9863fccb3fdb1f15c1cbce458c3236d792d007077a9e",
-                "urls": [
-                    "bzz-raw://f6fa97e90b315ffc3cae3998adda6810c856ea96be015e797723e13b436d1a10",
-                    "dweb:/ipfs/Qme1dzXXcMDQpeqyqfuSbZDY6GKWjyrRBQrNDjitPeXQEF"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/IBalanceManager.sol": {
-                "keccak256": "0xc4cff6f33170df6d91a866ee69263c9b90091e94027bea04038558c315e6e127",
-                "urls": [
-                    "bzz-raw://867164a381fb78da320c89db6b15978becd49be61e2349abc805362904bffb4e",
-                    "dweb:/ipfs/QmPY9UYCi9YVdCC8A1UxmTPcnV5BmMj93Gq1nqxBv4fMJ7"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/IInterestRateModel.sol": {
-                "keccak256": "0xccd4c1dea98176c392de07cb8f5a2ac969405090d42d831310fa53464c0d9264",
-                "urls": [
-                    "bzz-raw://a22b5b87be29e616142b6c4677e109e9246157c4b7e6378334fbc7ba403d82de",
-                    "dweb:/ipfs/QmXmSF34VsktTfqSCJU8Mz9sTaXGVk7xdYQwr9NcsR3k43"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/ILiquoriceSettlement.sol": {
-                "keccak256": "0xa4a36d51f174d9994c39287f89e63bbea57ff5adcd2a9bc649c67bb5cae75272",
-                "urls": [
-                    "bzz-raw://8562fe9fc033c3e3320c5d95ad10e49f5e23ea50a5e9eaf186cbf53d9f1ce7a6",
-                    "dweb:/ipfs/QmXKSjRi8oxmS5xd5V95HofYtFzYfehbL6s8t2MKoXR7y1"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/IPriceProvider.sol": {
-                "keccak256": "0x75812be8d692287010f5ee9ce13556df1bd8299faa64b42c49cd08cf7cc53847",
-                "urls": [
-                    "bzz-raw://623d4faa57b078a33a2afe0d13fc426c4a750ae7f07f9d826000047dab54148e",
-                    "dweb:/ipfs/QmYmFpZnLug6FBG9C8s1mxPBjZHwiCk7cRBC7A9WXtyGKE"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/IRepository.sol": {
-                "keccak256": "0xf08a5812ce10042564d518994db487c49d9f35d511da07a5103b9b886b6e2607",
-                "urls": [
-                    "bzz-raw://b602c9f5a61c9796f711330ee56d4f0287adc656c686acf391d4e8c45453e6d0",
-                    "dweb:/ipfs/QmQ7XJ1qERgRxWurpkS3t1XDtuBUTpQEz14h4eXBc8vp9t"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/external/permit/IAllowanceTransfer.sol": {
-                "keccak256": "0x23986b17f0c10296cb8afadb43014cd7901f56dac5ba85067d18ca7db7d3e37e",
-                "urls": [
-                    "bzz-raw://5f6ec55ce038e045b15a89a7f19fa45aa09d42a52517dd1846968d16777d3a9b",
-                    "dweb:/ipfs/QmZXthQLUtRFgqGv3bFbijmNk5Vviacrf7VnRDbXEQjdBQ"
-                ],
-                "license": "MIT"
-            },
-            "src/interfaces/external/permit/IEIP712.sol": {
-                "keccak256": "0x07e44e64248ed6316fe1db6f44c80468b950e6d1ab4bfdf21a65cbbd27718f77",
-                "urls": [
-                    "bzz-raw://58487548bc5289e7f5a4d4c278e5c7e9a7829d8a5be024a42938943f8c8fb63b",
-                    "dweb:/ipfs/QmYg63mq3SgXH6H4Wyvznb1E5fEjw6W7NeLASUcRjMuKYa"
-                ],
-                "license": "MIT"
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "_signer",
+              "type": "address"
+            },
+            {
+              "internalType": "struct ILiquoriceSettlement.Single",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "baseToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "quoteToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "baseTokenAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteTokenAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_makerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "uint256",
+              "name": "_filledTakerAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_takerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TakerPermitInfo",
+              "name": "_takerPermitInfo",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "bytes",
+                  "name": "signature",
+                  "type": "bytes"
+                },
+                {
+                  "internalType": "uint48",
+                  "name": "nonce",
+                  "type": "uint48"
+                },
+                {
+                  "internalType": "uint48",
+                  "name": "deadline",
+                  "type": "uint48"
+                }
+              ]
             }
+          ],
+          "stateMutability": "payable",
+          "type": "function",
+          "name": "settleSingleWithPermitsSignatures"
         },
-        "version": 1
-    },
-    "id": 90
-}
\ No newline at end of file
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "_signer",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "_filledTakerAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "struct ILiquoriceSettlement.Order",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "market",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "chainId",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+                  "name": "baseTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRecipient",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRepay",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toSupply",
+                      "type": "uint256"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+                  "name": "quoteTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toTrader",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toWithdraw",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toBorrow",
+                      "type": "uint256"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "internalType": "struct GPv2Interaction.Data[]",
+              "name": "_interactions",
+              "type": "tuple[]",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "target",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "value",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "callData",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "struct GPv2Interaction.Hooks",
+              "name": "_hooks",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "struct GPv2Interaction.Data[]",
+                  "name": "beforeSettle",
+                  "type": "tuple[]",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "target",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "value",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "bytes",
+                      "name": "callData",
+                      "type": "bytes"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct GPv2Interaction.Data[]",
+                  "name": "afterSettle",
+                  "type": "tuple[]",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "target",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "value",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "bytes",
+                      "name": "callData",
+                      "type": "bytes"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_makerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_takerSignature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            },
+            {
+              "internalType": "struct Signature.TakerPermitInfo",
+              "name": "_takerPermitInfo",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "bytes",
+                  "name": "signature",
+                  "type": "bytes"
+                },
+                {
+                  "internalType": "uint48",
+                  "name": "nonce",
+                  "type": "uint48"
+                },
+                {
+                  "internalType": "uint48",
+                  "name": "deadline",
+                  "type": "uint48"
+                }
+              ]
+            }
+          ],
+          "stateMutability": "payable",
+          "type": "function",
+          "name": "settleWithPermitsSignatures"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "contract IRepository",
+              "name": "_repository",
+              "type": "address"
+            },
+            {
+              "internalType": "struct GPv2Interaction.Hooks",
+              "name": "_hooks",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "struct GPv2Interaction.Data[]",
+                  "name": "beforeSettle",
+                  "type": "tuple[]",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "target",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "value",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "bytes",
+                      "name": "callData",
+                      "type": "bytes"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct GPv2Interaction.Data[]",
+                  "name": "afterSettle",
+                  "type": "tuple[]",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "target",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "value",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "bytes",
+                      "name": "callData",
+                      "type": "bytes"
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "validateHooks"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "contract IRepository",
+              "name": "_repository",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "_signer",
+              "type": "address"
+            },
+            {
+              "internalType": "bool",
+              "name": "_isPartialFill",
+              "type": "bool"
+            },
+            {
+              "internalType": "struct ILiquoriceSettlement.Order",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "market",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "chainId",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+                  "name": "baseTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRecipient",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRepay",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toSupply",
+                      "type": "uint256"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+                  "name": "quoteTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toTrader",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toWithdraw",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toBorrow",
+                      "type": "uint256"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "internalType": "struct GPv2Interaction.Data[]",
+              "name": "_interactions",
+              "type": "tuple[]",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "target",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "value",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "callData",
+                  "type": "bytes"
+                }
+              ]
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "validateInteractions"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "struct ILiquoriceSettlement.Order",
+              "name": "_order",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "market",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "chainId",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "string",
+                  "name": "rfqId",
+                  "type": "string"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "nonce",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "trader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address",
+                  "name": "effectiveTrader",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "quoteExpiry",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "address",
+                  "name": "recipient",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minFillAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+                  "name": "baseTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRecipient",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toRepay",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toSupply",
+                      "type": "uint256"
+                    }
+                  ]
+                },
+                {
+                  "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+                  "name": "quoteTokenData",
+                  "type": "tuple",
+                  "components": [
+                    {
+                      "internalType": "address",
+                      "name": "addr",
+                      "type": "address"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "amount",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toTrader",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toWithdraw",
+                      "type": "uint256"
+                    },
+                    {
+                      "internalType": "uint256",
+                      "name": "toBorrow",
+                      "type": "uint256"
+                    }
+                  ]
+                }
+              ]
+            }
+          ],
+          "stateMutability": "pure",
+          "type": "function",
+          "name": "validateOrderAmounts"
+        },
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "_validationAddress",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "_hash",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "struct Signature.TypedSignature",
+              "name": "_signature",
+              "type": "tuple",
+              "components": [
+                {
+                  "internalType": "enum Signature.Type",
+                  "name": "signatureType",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "enum Signature.TransferCommand",
+                  "name": "transferCommand",
+                  "type": "uint8"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "signatureBytes",
+                  "type": "bytes"
+                }
+              ]
+            }
+          ],
+          "stateMutability": "view",
+          "type": "function",
+          "name": "validateSignature"
+        },
+        {
+          "inputs": [],
+          "stateMutability": "payable",
+          "type": "receive"
+        }
+      ],
+      "devdoc": {
+        "kind": "dev",
+        "methods": {
+          "cancelLimitOrder(uint256)": {
+            "params": {
+              "nonce": "Nonce of the order to be canceled"
+            }
+          },
+          "hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
+            "params": {
+              "_order": "Order data to hash"
+            },
+            "returns": {
+              "_0": "bytes32 Hash of the order"
+            }
+          },
+          "hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))": {
+            "params": {
+              "_order": "Single order data to hash"
+            },
+            "returns": {
+              "_0": "bytes32 Hash of the single order"
+            }
+          },
+          "isValidSignature(bytes32,bytes)": {
+            "params": {
+              "_hash": "Hash of the data",
+              "_signature": "Signature to validate"
+            },
+            "returns": {
+              "_0": "Magic value if signature is valid, otherwise 0xffffffff"
+            }
+          },
+          "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))": {
+            "params": {
+              "_filledTakerAmount": "Amount filled by the taker",
+              "_hooks": "Hooks to be called before and after settlement",
+              "_interactions": "Array of interaction data to be executed during settlement",
+              "_makerSignature": "Typed signature of the maker",
+              "_order": "Order data",
+              "_signer": "Address that signed the order",
+              "_takerSignature": "Typed signature of the taker"
+            }
+          },
+          "settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))": {
+            "params": {
+              "_filledTakerAmount": "Amount filled by the taker",
+              "_makerSignature": "Signature of the maker",
+              "_order": "Single order data",
+              "_signer": "Address that signed the order",
+              "_takerSignature": "Signature of the taker"
+            }
+          },
+          "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))": {
+            "params": {
+              "_hooks": "Hooks data",
+              "_repository": "Repository interface"
+            }
+          },
+          "validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])": {
+            "params": {
+              "_interactions": "Array of interaction data",
+              "_order": "Order data",
+              "_repository": "Repository interface",
+              "_signer": "Signer address"
+            }
+          },
+          "validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
+            "params": {
+              "_order": "Order data"
+            }
+          },
+          "validateSignature(address,bytes32,(uint8,uint8,bytes))": {
+            "params": {
+              "_hash": "Hash of the data",
+              "_signature": "Signature data",
+              "_validationAddress": "Address to validate against"
+            }
+          }
+        },
+        "version": 1
+      },
+      "userdoc": {
+        "kind": "user",
+        "methods": {
+          "AUTHENTICATOR()": {
+            "notice": "Authenticator for verifying solvers and makers"
+          },
+          "BALANCE_MANAGER()": {
+            "notice": "Manager for handling balance transfers"
+          },
+          "REPOSITORY()": {
+            "notice": "Repository that stores data for Lending Pools"
+          },
+          "cancelLimitOrder(uint256)": {
+            "notice": "Cancels a limit order by invalidating its nonce"
+          },
+          "hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
+            "notice": "Computes the hash of an order"
+          },
+          "hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))": {
+            "notice": "Computes the hash of a single order"
+          },
+          "isValidSignature(bytes32,bytes)": {
+            "notice": "Validates a signature"
+          },
+          "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))": {
+            "notice": "Settles a signed order with the given interactions and hooks"
+          },
+          "settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))": {
+            "notice": "Settles a single order"
+          },
+          "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))": {
+            "notice": "Validates hooks for an order"
+          },
+          "validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])": {
+            "notice": "Validates interactions for an order"
+          },
+          "validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))": {
+            "notice": "Validates the amounts in an order"
+          },
+          "validateSignature(address,bytes32,(uint8,uint8,bytes))": {
+            "notice": "Validates a signature"
+          }
+        },
+        "version": 1
+      }
+    },
+    "settings": {
+      "remappings": [
+        "@chainlink/=lib/chainlink/contracts/",
+        "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
+        "@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
+        "chainlink/=lib/chainlink/",
+        "contracts/=src/contracts/",
+        "ds-test/=node_modules/ds-test/src/",
+        "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
+        "forge-std/=lib/forge-std/src/",
+        "halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
+        "interfaces/=src/interfaces/",
+        "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
+        "openzeppelin-contracts/=lib/openzeppelin-contracts/",
+        "openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
+        "openzeppelin-upgrades/=lib/openzeppelin-upgrades/",
+        "solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/"
+      ],
+      "optimizer": {
+        "enabled": true,
+        "runs": 10000
+      },
+      "metadata": {
+        "bytecodeHash": "ipfs"
+      },
+      "compilationTarget": {
+        "src/contracts/settlement/LiquoriceSettlement.sol": "LiquoriceSettlement"
+      },
+      "evmVersion": "shanghai",
+      "libraries": {}
+    },
+    "sources": {
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol": {
+        "keccak256": "0xc92e946b954f185c3ca5ee56f9721aa73d64464456a46459384cb0ccf3c3856e",
+        "urls": [
+          "bzz-raw://ae178b4e7b259557d8b93f3dd4f6f909ac72f914a9e92676e59b8d737f0423e2",
+          "dweb:/ipfs/QmXeqyUJYzn6w8wyivQAtSzmwwFQnHaFYPvGad66RW1sPf"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol": {
+        "keccak256": "0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7",
+        "urls": [
+          "bzz-raw://da62d6be1f5c6edf577f0cb45666a8aa9c2086a4bac87d95d65f02e2f4c36a4b",
+          "dweb:/ipfs/QmNkpvBpoCMvX8JwAFNSc5XxJ2q5BXJpL5L1txb4QkqVFF"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol": {
+        "keccak256": "0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724",
+        "urls": [
+          "bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a",
+          "dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol": {
+        "keccak256": "0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c",
+        "urls": [
+          "bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba",
+          "dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol": {
+        "keccak256": "0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7",
+        "urls": [
+          "bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db",
+          "dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol": {
+        "keccak256": "0x6dd0cb67846da3fa1241c520faaa215d6bec8226e37beac6056c51e8af44d24e",
+        "urls": [
+          "bzz-raw://650e533e62b30dcc6edea2b6c91358d5659da3bde42e56adf7316c493b916a15",
+          "dweb:/ipfs/QmYkmK2vPE6FjdAoQVpZSJxamTLGno9wzGS495TcMNFViV"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Panic.sol": {
+        "keccak256": "0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a",
+        "urls": [
+          "bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a",
+          "dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol": {
+        "keccak256": "0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3",
+        "urls": [
+          "bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a",
+          "dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol": {
+        "keccak256": "0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84",
+        "urls": [
+          "bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9",
+          "dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol": {
+        "keccak256": "0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8",
+        "urls": [
+          "bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621",
+          "dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/Math.sol": {
+        "keccak256": "0x6f61a65c733690afafb4cf528b5677e704828c8350b60b948dbc1d3bb6d7689c",
+        "urls": [
+          "bzz-raw://00265b985b303af62ee243e10db819fa8cf890d9f122f82f4f03f55b02f62654",
+          "dweb:/ipfs/QmNneFqZn2uKK6dECxatH6aENk1EMCTETi58dGaz5NCWQe"
+        ],
+        "license": "MIT"
+      },
+      "lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol": {
+        "keccak256": "0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54",
+        "urls": [
+          "bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8",
+          "dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy"
+        ],
+        "license": "MIT"
+      },
+      "src/contracts/lib/GPv2Interaction.sol": {
+        "keccak256": "0x55968a83f6ae3d8d806b8faf02360abc676fb7476d05f33c0c9d324e6336fd0f",
+        "urls": [
+          "bzz-raw://2d813e60c3fa006d02c8fd1aed73d2d47f9f153ac3c410d408384f3084e46de3",
+          "dweb:/ipfs/QmdNyQMmyscMH6CVUkhQQfGdKdxgqhqDEe5K4iwrvcWDsk"
+        ],
+        "license": "LGPL-3.0-or-later"
+      },
+      "src/contracts/lib/Signature.sol": {
+        "keccak256": "0xc084fe793244e2e7b0f4a51440df7dbf97d39b4ad6450a2b8a082cb6d86993b5",
+        "urls": [
+          "bzz-raw://9bff9732e68149a83f2e044c7f1700432997750166cd15f4a54f73bd68a475aa",
+          "dweb:/ipfs/QmZJMNppHQ3nUDcJhAkrMYa4QWhGLDr4Tzah6LndgrDCib"
+        ],
+        "license": "BUSL-1.1"
+      },
+      "src/contracts/settlement/BalanceManager.sol": {
+        "keccak256": "0x82d5d0de5cf88ff8882f1f7a2d05b98ed32bb3f2a6b9eab728ce55ae943e67c3",
+        "urls": [
+          "bzz-raw://ebcbe822ad5c68896a12ecd60e17ba6a2ed0ba8e0544c7ad54d88d1c25206b5c",
+          "dweb:/ipfs/QmYEZeKUEz7Nw6MW9uZHnXvkeRTmmcS1WZhx77s9kUWSWw"
+        ],
+        "license": "BUSL-1.1"
+      },
+      "src/contracts/settlement/LiquoriceSettlement.sol": {
+        "keccak256": "0xcac528919829fc8e021cec4325b38835866a7d0630b61349deae6ecfbe0ddaef",
+        "urls": [
+          "bzz-raw://6d6dafbba3885b42cb97be6d190ac1f611548ceb2116e9b6ed7da9bf422c8b58",
+          "dweb:/ipfs/QmZQk6WQNgYqsu9Z85tPF2VQGXgaYzvpEqc7VEmJ4zEEJU"
+        ],
+        "license": "BUSL-1.1"
+      },
+      "src/contracts/settlement/Signing.sol": {
+        "keccak256": "0xad9e59ae740627e5b71fa1ebde019999084480664d06d18f0a01e4d31fa32ef6",
+        "urls": [
+          "bzz-raw://ea0e0021cd0074292b04f9921f6ca3cc77a6799c86cacabb9dc6ff7dadbd7933",
+          "dweb:/ipfs/QmPjY69PntfUGW5eNrNe98DCTemq6daRqUiLFkcYvVWuvh"
+        ],
+        "license": "BUSL-1.1"
+      },
+      "src/interfaces/IACLManager.sol": {
+        "keccak256": "0xeee5cbedcfaff01733979b8f439a817aa67b09d9e330d21e11f180dceebed024",
+        "urls": [
+          "bzz-raw://814431cd9df23d0d7cc0f9761927e2aa18fc7fa599f34422f332ee6352580d69",
+          "dweb:/ipfs/QmXLdGsdMyeX5j64rAaByz35SwEMPMQ7usXwruWjEPo6Cz"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/IAllowListAuthentication.sol": {
+        "keccak256": "0xbabb9eda80757d9355ab9863fccb3fdb1f15c1cbce458c3236d792d007077a9e",
+        "urls": [
+          "bzz-raw://f6fa97e90b315ffc3cae3998adda6810c856ea96be015e797723e13b436d1a10",
+          "dweb:/ipfs/Qme1dzXXcMDQpeqyqfuSbZDY6GKWjyrRBQrNDjitPeXQEF"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/IBalanceManager.sol": {
+        "keccak256": "0xc4cff6f33170df6d91a866ee69263c9b90091e94027bea04038558c315e6e127",
+        "urls": [
+          "bzz-raw://867164a381fb78da320c89db6b15978becd49be61e2349abc805362904bffb4e",
+          "dweb:/ipfs/QmPY9UYCi9YVdCC8A1UxmTPcnV5BmMj93Gq1nqxBv4fMJ7"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/IInterestRateModel.sol": {
+        "keccak256": "0xccd4c1dea98176c392de07cb8f5a2ac969405090d42d831310fa53464c0d9264",
+        "urls": [
+          "bzz-raw://a22b5b87be29e616142b6c4677e109e9246157c4b7e6378334fbc7ba403d82de",
+          "dweb:/ipfs/QmXmSF34VsktTfqSCJU8Mz9sTaXGVk7xdYQwr9NcsR3k43"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/ILiquoriceSettlement.sol": {
+        "keccak256": "0xa4a36d51f174d9994c39287f89e63bbea57ff5adcd2a9bc649c67bb5cae75272",
+        "urls": [
+          "bzz-raw://8562fe9fc033c3e3320c5d95ad10e49f5e23ea50a5e9eaf186cbf53d9f1ce7a6",
+          "dweb:/ipfs/QmXKSjRi8oxmS5xd5V95HofYtFzYfehbL6s8t2MKoXR7y1"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/IPriceProvider.sol": {
+        "keccak256": "0x75812be8d692287010f5ee9ce13556df1bd8299faa64b42c49cd08cf7cc53847",
+        "urls": [
+          "bzz-raw://623d4faa57b078a33a2afe0d13fc426c4a750ae7f07f9d826000047dab54148e",
+          "dweb:/ipfs/QmYmFpZnLug6FBG9C8s1mxPBjZHwiCk7cRBC7A9WXtyGKE"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/IRepository.sol": {
+        "keccak256": "0xf08a5812ce10042564d518994db487c49d9f35d511da07a5103b9b886b6e2607",
+        "urls": [
+          "bzz-raw://b602c9f5a61c9796f711330ee56d4f0287adc656c686acf391d4e8c45453e6d0",
+          "dweb:/ipfs/QmQ7XJ1qERgRxWurpkS3t1XDtuBUTpQEz14h4eXBc8vp9t"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/external/permit/IAllowanceTransfer.sol": {
+        "keccak256": "0x23986b17f0c10296cb8afadb43014cd7901f56dac5ba85067d18ca7db7d3e37e",
+        "urls": [
+          "bzz-raw://5f6ec55ce038e045b15a89a7f19fa45aa09d42a52517dd1846968d16777d3a9b",
+          "dweb:/ipfs/QmZXthQLUtRFgqGv3bFbijmNk5Vviacrf7VnRDbXEQjdBQ"
+        ],
+        "license": "MIT"
+      },
+      "src/interfaces/external/permit/IEIP712.sol": {
+        "keccak256": "0x07e44e64248ed6316fe1db6f44c80468b950e6d1ab4bfdf21a65cbbd27718f77",
+        "urls": [
+          "bzz-raw://58487548bc5289e7f5a4d4c278e5c7e9a7829d8a5be024a42938943f8c8fb63b",
+          "dweb:/ipfs/QmYg63mq3SgXH6H4Wyvznb1E5fEjw6W7NeLASUcRjMuKYa"
+        ],
+        "license": "MIT"
+      }
+    },
+    "version": 1
+  },
+  "id": 90,
+  "_disabled": [
+    {
+      "type": "function",
+      "name": "REPOSITORY",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "contract IRepository"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "cancelLimitOrder",
+      "inputs": [
+        {
+          "name": "nonce",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "hashBaseTokenData",
+      "inputs": [
+        {
+          "name": "_baseTokenData",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+          "components": [
+            {
+              "name": "addr",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "amount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "toRecipient",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "toRepay",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "toSupply",
+              "type": "uint256",
+              "internalType": "uint256"
+            }
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "pure"
+    },
+    {
+      "type": "function",
+      "name": "hashOrder",
+      "inputs": [
+        {
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Order",
+          "components": [
+            {
+              "name": "market",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "chainId",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "baseTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRecipient",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRepay",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toSupply",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            },
+            {
+              "name": "quoteTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toTrader",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toWithdraw",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toBorrow",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "hashQuoteTokenData",
+      "inputs": [
+        {
+          "name": "_quoteTokenData",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+          "components": [
+            {
+              "name": "addr",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "amount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "toTrader",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "toWithdraw",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "toBorrow",
+              "type": "uint256",
+              "internalType": "uint256"
+            }
+          ]
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        }
+      ],
+      "stateMutability": "pure"
+    },
+    {
+      "type": "function",
+      "name": "settleSingleWithPermitsSignatures",
+      "inputs": [
+        {
+          "name": "_signer",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Single",
+          "components": [
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "baseToken",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteToken",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "baseTokenAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "quoteTokenAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            }
+          ]
+        },
+        {
+          "name": "_makerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "_filledTakerAmount",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "_takerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "_takerPermitInfo",
+          "type": "tuple",
+          "internalType": "struct Signature.TakerPermitInfo",
+          "components": [
+            {
+              "name": "signature",
+              "type": "bytes",
+              "internalType": "bytes"
+            },
+            {
+              "name": "nonce",
+              "type": "uint48",
+              "internalType": "uint48"
+            },
+            {
+              "name": "deadline",
+              "type": "uint48",
+              "internalType": "uint48"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "payable"
+    },
+    {
+      "type": "function",
+      "name": "settleWithPermitsSignatures",
+      "inputs": [
+        {
+          "name": "_signer",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "_filledTakerAmount",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Order",
+          "components": [
+            {
+              "name": "market",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "chainId",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "baseTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRecipient",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRepay",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toSupply",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            },
+            {
+              "name": "quoteTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toTrader",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toWithdraw",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toBorrow",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "_interactions",
+          "type": "tuple[]",
+          "internalType": "struct GPv2Interaction.Data[]",
+          "components": [
+            {
+              "name": "target",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "value",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "callData",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "_hooks",
+          "type": "tuple",
+          "internalType": "struct GPv2Interaction.Hooks",
+          "components": [
+            {
+              "name": "beforeSettle",
+              "type": "tuple[]",
+              "internalType": "struct GPv2Interaction.Data[]",
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "value",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "callData",
+                  "type": "bytes",
+                  "internalType": "bytes"
+                }
+              ]
+            },
+            {
+              "name": "afterSettle",
+              "type": "tuple[]",
+              "internalType": "struct GPv2Interaction.Data[]",
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "value",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "callData",
+                  "type": "bytes",
+                  "internalType": "bytes"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "_makerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "_takerSignature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        },
+        {
+          "name": "_takerPermitInfo",
+          "type": "tuple",
+          "internalType": "struct Signature.TakerPermitInfo",
+          "components": [
+            {
+              "name": "signature",
+              "type": "bytes",
+              "internalType": "bytes"
+            },
+            {
+              "name": "nonce",
+              "type": "uint48",
+              "internalType": "uint48"
+            },
+            {
+              "name": "deadline",
+              "type": "uint48",
+              "internalType": "uint48"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "payable"
+    },
+    {
+      "type": "function",
+      "name": "validateHooks",
+      "inputs": [
+        {
+          "name": "_repository",
+          "type": "address",
+          "internalType": "contract IRepository"
+        },
+        {
+          "name": "_hooks",
+          "type": "tuple",
+          "internalType": "struct GPv2Interaction.Hooks",
+          "components": [
+            {
+              "name": "beforeSettle",
+              "type": "tuple[]",
+              "internalType": "struct GPv2Interaction.Data[]",
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "value",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "callData",
+                  "type": "bytes",
+                  "internalType": "bytes"
+                }
+              ]
+            },
+            {
+              "name": "afterSettle",
+              "type": "tuple[]",
+              "internalType": "struct GPv2Interaction.Data[]",
+              "components": [
+                {
+                  "name": "target",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "value",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "callData",
+                  "type": "bytes",
+                  "internalType": "bytes"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "validateInteractions",
+      "inputs": [
+        {
+          "name": "_repository",
+          "type": "address",
+          "internalType": "contract IRepository"
+        },
+        {
+          "name": "_signer",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "_isPartialFill",
+          "type": "bool",
+          "internalType": "bool"
+        },
+        {
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Order",
+          "components": [
+            {
+              "name": "market",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "chainId",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "baseTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRecipient",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRepay",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toSupply",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            },
+            {
+              "name": "quoteTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toTrader",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toWithdraw",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toBorrow",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "_interactions",
+          "type": "tuple[]",
+          "internalType": "struct GPv2Interaction.Data[]",
+          "components": [
+            {
+              "name": "target",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "value",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "callData",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "validateOrderAmounts",
+      "inputs": [
+        {
+          "name": "_order",
+          "type": "tuple",
+          "internalType": "struct ILiquoriceSettlement.Order",
+          "components": [
+            {
+              "name": "market",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "chainId",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "rfqId",
+              "type": "string",
+              "internalType": "string"
+            },
+            {
+              "name": "nonce",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "trader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "effectiveTrader",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "quoteExpiry",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "recipient",
+              "type": "address",
+              "internalType": "address"
+            },
+            {
+              "name": "minFillAmount",
+              "type": "uint256",
+              "internalType": "uint256"
+            },
+            {
+              "name": "baseTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRecipient",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toRepay",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toSupply",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            },
+            {
+              "name": "quoteTokenData",
+              "type": "tuple",
+              "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
+              "components": [
+                {
+                  "name": "addr",
+                  "type": "address",
+                  "internalType": "address"
+                },
+                {
+                  "name": "amount",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toTrader",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toWithdraw",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                },
+                {
+                  "name": "toBorrow",
+                  "type": "uint256",
+                  "internalType": "uint256"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "pure"
+    },
+    {
+      "type": "function",
+      "name": "validateSignature",
+      "inputs": [
+        {
+          "name": "_validationAddress",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "_hash",
+          "type": "bytes32",
+          "internalType": "bytes32"
+        },
+        {
+          "name": "_signature",
+          "type": "tuple",
+          "internalType": "struct Signature.TypedSignature",
+          "components": [
+            {
+              "name": "signatureType",
+              "type": "uint8",
+              "internalType": "enum Signature.Type"
+            },
+            {
+              "name": "transferCommand",
+              "type": "uint8",
+              "internalType": "enum Signature.TransferCommand"
+            },
+            {
+              "name": "signatureBytes",
+              "type": "bytes",
+              "internalType": "bytes"
+            }
+          ]
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "view"
+    }
+  ]
+}
diff --git a/contracts/artifacts/PancakeRouter.json b/contracts/artifacts/PancakeRouter.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/PancakeRouter.json
+++ b/contracts/artifacts/PancakeRouter.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/Permit2.json b/contracts/artifacts/Permit2.json
index 00537570e6..60c0727632 100644
--- a/contracts/artifacts/Permit2.json
+++ b/contracts/artifacts/Permit2.json
@@ -326,6 +326,106 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "owner",
+          "type": "address"
+        },
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "internalType": "address",
+                  "name": "token",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint160",
+                  "name": "amount",
+                  "type": "uint160"
+                },
+                {
+                  "internalType": "uint48",
+                  "name": "expiration",
+                  "type": "uint48"
+                },
+                {
+                  "internalType": "uint48",
+                  "name": "nonce",
+                  "type": "uint48"
+                }
+              ],
+              "internalType": "struct IAllowanceTransfer.PermitDetails",
+              "name": "details",
+              "type": "tuple"
+            },
+            {
+              "internalType": "address",
+              "name": "spender",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "sigDeadline",
+              "type": "uint256"
+            }
+          ],
+          "internalType": "struct IAllowanceTransfer.PermitSingle",
+          "name": "permitSingle",
+          "type": "tuple"
+        },
+        {
+          "internalType": "bytes",
+          "name": "signature",
+          "type": "bytes"
+        }
+      ],
+      "name": "permit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "from",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint160",
+          "name": "amount",
+          "type": "uint160"
+        },
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        }
+      ],
+      "name": "transferFrom",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "devdoc": {
+    "methods": {}
+  },
+  "userdoc": {
+    "methods": {}
+  },
+  "_disabled": [
     {
       "inputs": [
         {
@@ -416,68 +516,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        },
-        {
-          "components": [
-            {
-              "components": [
-                {
-                  "internalType": "address",
-                  "name": "token",
-                  "type": "address"
-                },
-                {
-                  "internalType": "uint160",
-                  "name": "amount",
-                  "type": "uint160"
-                },
-                {
-                  "internalType": "uint48",
-                  "name": "expiration",
-                  "type": "uint48"
-                },
-                {
-                  "internalType": "uint48",
-                  "name": "nonce",
-                  "type": "uint48"
-                }
-              ],
-              "internalType": "struct IAllowanceTransfer.PermitDetails",
-              "name": "details",
-              "type": "tuple"
-            },
-            {
-              "internalType": "address",
-              "name": "spender",
-              "type": "address"
-            },
-            {
-              "internalType": "uint256",
-              "name": "sigDeadline",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct IAllowanceTransfer.PermitSingle",
-          "name": "permitSingle",
-          "type": "tuple"
-        },
-        {
-          "internalType": "bytes",
-          "name": "signature",
-          "type": "bytes"
-        }
-      ],
-      "name": "permit",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -625,42 +663,6 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "from",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint160",
-          "name": "amount",
-          "type": "uint160"
-        },
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "name": "transferFrom",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "devdoc": {
-    "methods": {}
-  },
-  "userdoc": {
-    "methods": {}
-  }
+  ]
 }
diff --git a/contracts/artifacts/SushiSwapRouter.json b/contracts/artifacts/SushiSwapRouter.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/SushiSwapRouter.json
+++ b/contracts/artifacts/SushiSwapRouter.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/SwaprRouter.json b/contracts/artifacts/SwaprRouter.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/SwaprRouter.json
+++ b/contracts/artifacts/SwaprRouter.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/TestnetUniswapV2Router02.json b/contracts/artifacts/TestnetUniswapV2Router02.json
index 1ee16c02cc..c95b7fd70d 100644
--- a/contracts/artifacts/TestnetUniswapV2Router02.json
+++ b/contracts/artifacts/TestnetUniswapV2Router02.json
@@ -77,6 +77,89 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
@@ -131,19 +214,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -250,35 +320,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -911,45 +952,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/contracts/artifacts/UniswapV2Factory.json b/contracts/artifacts/UniswapV2Factory.json
index 2d57f483c5..043c56a2c9 100644
--- a/contracts/artifacts/UniswapV2Factory.json
+++ b/contracts/artifacts/UniswapV2Factory.json
@@ -44,71 +44,70 @@
       "type": "event"
     },
     {
-      "constant": true,
+      "constant": false,
       "inputs": [
         {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "name": "allPairs",
-      "outputs": [
+          "internalType": "address",
+          "name": "tokenA",
+          "type": "address"
+        },
         {
           "internalType": "address",
-          "name": "",
+          "name": "tokenB",
           "type": "address"
         }
       ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "allPairsLength",
+      "name": "createPair",
       "outputs": [
         {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
+          "internalType": "address",
+          "name": "pair",
+          "type": "address"
         }
       ],
       "payable": false,
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "constant": false,
+      "constant": true,
       "inputs": [
         {
           "internalType": "address",
-          "name": "tokenA",
+          "name": "",
           "type": "address"
         },
         {
           "internalType": "address",
-          "name": "tokenB",
+          "name": "",
           "type": "address"
         }
       ],
-      "name": "createPair",
+      "name": "getPair",
       "outputs": [
         {
           "internalType": "address",
-          "name": "pair",
+          "name": "",
           "type": "address"
         }
       ],
       "payable": false,
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
-    },
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "constant": true,
-      "inputs": [],
-      "name": "feeTo",
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "name": "allPairs",
       "outputs": [
         {
           "internalType": "address",
@@ -123,12 +122,12 @@
     {
       "constant": true,
       "inputs": [],
-      "name": "feeToSetter",
+      "name": "allPairsLength",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "uint256",
           "name": "",
-          "type": "address"
+          "type": "uint256"
         }
       ],
       "payable": false,
@@ -137,19 +136,23 @@
     },
     {
       "constant": true,
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        },
+      "inputs": [],
+      "name": "feeTo",
+      "outputs": [
         {
           "internalType": "address",
           "name": "",
           "type": "address"
         }
       ],
-      "name": "getPair",
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "feeToSetter",
       "outputs": [
         {
           "internalType": "address",
@@ -191,6 +194,5 @@
       "stateMutability": "nonpayable",
       "type": "function"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/UniswapV2Router02.json b/contracts/artifacts/UniswapV2Router02.json
index 49d90c0289..93f965d0d8 100644
--- a/contracts/artifacts/UniswapV2Router02.json
+++ b/contracts/artifacts/UniswapV2Router02.json
@@ -16,6 +16,10 @@
       "stateMutability": "nonpayable",
       "type": "constructor"
     },
+    {
+      "stateMutability": "payable",
+      "type": "receive"
+    },
     {
       "inputs": [],
       "name": "WETH",
@@ -93,6 +97,90 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "factory",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveA",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "reserveB",
+          "type": "uint256"
+        }
+      ],
+      "name": "quote",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountB",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "pure",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amountOut",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountInMax",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address[]",
+          "name": "path",
+          "type": "address[]"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "deadline",
+          "type": "uint256"
+        }
+      ],
+      "name": "swapTokensForExactTokens",
+      "outputs": [
+        {
+          "internalType": "uint256[]",
+          "name": "amounts",
+          "type": "uint256[]"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "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",
+  "_disabled": [
     {
       "inputs": [
         {
@@ -147,19 +235,6 @@
       "stateMutability": "payable",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "factory",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -266,35 +341,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveA",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "reserveB",
-          "type": "uint256"
-        }
-      ],
-      "name": "quote",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountB",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -927,50 +973,6 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amountOut",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountInMax",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address[]",
-          "name": "path",
-          "type": "address[]"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "deadline",
-          "type": "uint256"
-        }
-      ],
-      "name": "swapTokensForExactTokens",
-      "outputs": [
-        {
-          "internalType": "uint256[]",
-          "name": "amounts",
-          "type": "uint256[]"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "stateMutability": "payable",
-      "type": "receive"
     }
-  ],
-  "bytecode": "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"
-}
\ No newline at end of file
+  ]
+}
diff --git a/contracts/artifacts/UniswapV3Pool.json b/contracts/artifacts/UniswapV3Pool.json
index 87969854f7..8e04b0b6b5 100644
--- a/contracts/artifacts/UniswapV3Pool.json
+++ b/contracts/artifacts/UniswapV3Pool.json
@@ -410,40 +410,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "recipient",
-          "type": "address"
-        },
-        {
-          "internalType": "uint128",
-          "name": "amount0Requested",
-          "type": "uint128"
-        },
-        {
-          "internalType": "uint128",
-          "name": "amount1Requested",
-          "type": "uint128"
-        }
-      ],
-      "name": "collectProtocol",
-      "outputs": [
-        {
-          "internalType": "uint128",
-          "name": "amount0",
-          "type": "uint128"
-        },
-        {
-          "internalType": "uint128",
-          "name": "amount1",
-          "type": "uint128"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [],
       "name": "factory",
@@ -470,32 +436,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "feeGrowthGlobal0X128",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "feeGrowthGlobal1X128",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -524,19 +464,6 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
-    {
-      "inputs": [
-        {
-          "internalType": "uint16",
-          "name": "observationCardinalityNext",
-          "type": "uint16"
-        }
-      ],
-      "name": "increaseObservationCardinalityNext",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -563,19 +490,6 @@
       "stateMutability": "view",
       "type": "function"
     },
-    {
-      "inputs": [],
-      "name": "maxLiquidityPerTick",
-      "outputs": [
-        {
-          "internalType": "uint128",
-          "name": "",
-          "type": "uint128"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "inputs": [
         {
@@ -738,151 +652,179 @@
     {
       "inputs": [
         {
-          "internalType": "uint8",
-          "name": "feeProtocol0",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint8",
-          "name": "feeProtocol1",
-          "type": "uint8"
-        }
-      ],
-      "name": "setFeeProtocol",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "slot0",
-      "outputs": [
-        {
-          "internalType": "uint160",
-          "name": "sqrtPriceX96",
-          "type": "uint160"
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         },
         {
-          "internalType": "int24",
-          "name": "tick",
-          "type": "int24"
+          "internalType": "bool",
+          "name": "zeroForOne",
+          "type": "bool"
         },
         {
-          "internalType": "uint16",
-          "name": "observationIndex",
-          "type": "uint16"
+          "internalType": "int256",
+          "name": "amountSpecified",
+          "type": "int256"
         },
         {
-          "internalType": "uint16",
-          "name": "observationCardinality",
-          "type": "uint16"
+          "internalType": "uint160",
+          "name": "sqrtPriceLimitX96",
+          "type": "uint160"
         },
         {
-          "internalType": "uint16",
-          "name": "observationCardinalityNext",
-          "type": "uint16"
-        },
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "swap",
+      "outputs": [
         {
-          "internalType": "uint8",
-          "name": "feeProtocol",
-          "type": "uint8"
+          "internalType": "int256",
+          "name": "amount0",
+          "type": "int256"
         },
         {
-          "internalType": "bool",
-          "name": "unlocked",
-          "type": "bool"
+          "internalType": "int256",
+          "name": "amount1",
+          "type": "int256"
         }
       ],
-      "stateMutability": "view",
+      "stateMutability": "nonpayable",
       "type": "function"
     },
     {
       "inputs": [
         {
           "internalType": "int24",
-          "name": "tickLower",
-          "type": "int24"
-        },
-        {
-          "internalType": "int24",
-          "name": "tickUpper",
+          "name": "",
           "type": "int24"
         }
       ],
-      "name": "snapshotCumulativesInside",
+      "name": "ticks",
       "outputs": [
+        {
+          "internalType": "uint128",
+          "name": "liquidityGross",
+          "type": "uint128"
+        },
+        {
+          "internalType": "int128",
+          "name": "liquidityNet",
+          "type": "int128"
+        },
+        {
+          "internalType": "uint256",
+          "name": "feeGrowthOutside0X128",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "feeGrowthOutside1X128",
+          "type": "uint256"
+        },
         {
           "internalType": "int56",
-          "name": "tickCumulativeInside",
+          "name": "tickCumulativeOutside",
           "type": "int56"
         },
         {
           "internalType": "uint160",
-          "name": "secondsPerLiquidityInsideX128",
+          "name": "secondsPerLiquidityOutsideX128",
           "type": "uint160"
         },
         {
           "internalType": "uint32",
-          "name": "secondsInside",
+          "name": "secondsOutside",
           "type": "uint32"
+        },
+        {
+          "internalType": "bool",
+          "name": "initialized",
+          "type": "bool"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "token0",
+      "outputs": [
         {
           "internalType": "address",
-          "name": "recipient",
+          "name": "",
           "type": "address"
-        },
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "token1",
+      "outputs": [
         {
-          "internalType": "bool",
-          "name": "zeroForOne",
-          "type": "bool"
-        },
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "_disabled": [
+    {
+      "inputs": [
         {
-          "internalType": "int256",
-          "name": "amountSpecified",
-          "type": "int256"
+          "internalType": "address",
+          "name": "recipient",
+          "type": "address"
         },
         {
-          "internalType": "uint160",
-          "name": "sqrtPriceLimitX96",
-          "type": "uint160"
+          "internalType": "uint128",
+          "name": "amount0Requested",
+          "type": "uint128"
         },
         {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
+          "internalType": "uint128",
+          "name": "amount1Requested",
+          "type": "uint128"
         }
       ],
-      "name": "swap",
+      "name": "collectProtocol",
       "outputs": [
         {
-          "internalType": "int256",
+          "internalType": "uint128",
           "name": "amount0",
-          "type": "int256"
+          "type": "uint128"
         },
         {
-          "internalType": "int256",
+          "internalType": "uint128",
           "name": "amount1",
-          "type": "int256"
+          "type": "uint128"
         }
       ],
       "stateMutability": "nonpayable",
       "type": "function"
     },
     {
-      "inputs": [
+      "inputs": [],
+      "name": "feeGrowthGlobal0X128",
+      "outputs": [
         {
-          "internalType": "int16",
+          "internalType": "uint256",
           "name": "",
-          "type": "int16"
+          "type": "uint256"
         }
       ],
-      "name": "tickBitmap",
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "feeGrowthGlobal1X128",
       "outputs": [
         {
           "internalType": "uint256",
@@ -893,14 +835,27 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint16",
+          "name": "observationCardinalityNext",
+          "type": "uint16"
+        }
+      ],
+      "name": "increaseObservationCardinalityNext",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [],
-      "name": "tickSpacing",
+      "name": "maxLiquidityPerTick",
       "outputs": [
         {
-          "internalType": "int24",
+          "internalType": "uint128",
           "name": "",
-          "type": "int24"
+          "type": "uint128"
         }
       ],
       "stateMutability": "view",
@@ -909,65 +864,112 @@
     {
       "inputs": [
         {
-          "internalType": "int24",
-          "name": "",
-          "type": "int24"
+          "internalType": "uint8",
+          "name": "feeProtocol0",
+          "type": "uint8"
+        },
+        {
+          "internalType": "uint8",
+          "name": "feeProtocol1",
+          "type": "uint8"
         }
       ],
-      "name": "ticks",
+      "name": "setFeeProtocol",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "slot0",
       "outputs": [
         {
-          "internalType": "uint128",
-          "name": "liquidityGross",
-          "type": "uint128"
+          "internalType": "uint160",
+          "name": "sqrtPriceX96",
+          "type": "uint160"
         },
         {
-          "internalType": "int128",
-          "name": "liquidityNet",
-          "type": "int128"
+          "internalType": "int24",
+          "name": "tick",
+          "type": "int24"
         },
         {
-          "internalType": "uint256",
-          "name": "feeGrowthOutside0X128",
-          "type": "uint256"
+          "internalType": "uint16",
+          "name": "observationIndex",
+          "type": "uint16"
         },
         {
-          "internalType": "uint256",
-          "name": "feeGrowthOutside1X128",
-          "type": "uint256"
+          "internalType": "uint16",
+          "name": "observationCardinality",
+          "type": "uint16"
         },
+        {
+          "internalType": "uint16",
+          "name": "observationCardinalityNext",
+          "type": "uint16"
+        },
+        {
+          "internalType": "uint8",
+          "name": "feeProtocol",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bool",
+          "name": "unlocked",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "int24",
+          "name": "tickLower",
+          "type": "int24"
+        },
+        {
+          "internalType": "int24",
+          "name": "tickUpper",
+          "type": "int24"
+        }
+      ],
+      "name": "snapshotCumulativesInside",
+      "outputs": [
         {
           "internalType": "int56",
-          "name": "tickCumulativeOutside",
+          "name": "tickCumulativeInside",
           "type": "int56"
         },
         {
           "internalType": "uint160",
-          "name": "secondsPerLiquidityOutsideX128",
+          "name": "secondsPerLiquidityInsideX128",
           "type": "uint160"
         },
         {
           "internalType": "uint32",
-          "name": "secondsOutside",
+          "name": "secondsInside",
           "type": "uint32"
-        },
-        {
-          "internalType": "bool",
-          "name": "initialized",
-          "type": "bool"
         }
       ],
       "stateMutability": "view",
       "type": "function"
     },
     {
-      "inputs": [],
-      "name": "token0",
+      "inputs": [
+        {
+          "internalType": "int16",
+          "name": "",
+          "type": "int16"
+        }
+      ],
+      "name": "tickBitmap",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "uint256",
           "name": "",
-          "type": "address"
+          "type": "uint256"
         }
       ],
       "stateMutability": "view",
@@ -975,12 +977,12 @@
     },
     {
       "inputs": [],
-      "name": "token1",
+      "name": "tickSpacing",
       "outputs": [
         {
-          "internalType": "address",
+          "internalType": "int24",
           "name": "",
-          "type": "address"
+          "type": "int24"
         }
       ],
       "stateMutability": "view",
diff --git a/contracts/artifacts/UniswapV3QuoterV2.json b/contracts/artifacts/UniswapV3QuoterV2.json
index 7d72b79934..ffb210fdc1 100644
--- a/contracts/artifacts/UniswapV3QuoterV2.json
+++ b/contracts/artifacts/UniswapV3QuoterV2.json
@@ -241,7 +241,9 @@
       ],
       "stateMutability": "nonpayable",
       "type": "function"
-    },
+    }
+  ],
+  "_disabled": [
     {
       "inputs": [
         {
diff --git a/contracts/artifacts/WETH9.json b/contracts/artifacts/WETH9.json
index a1717577d9..9abe58a0af 100644
--- a/contracts/artifacts/WETH9.json
+++ b/contracts/artifacts/WETH9.json
@@ -1,89 +1,5 @@
 {
   "abi": [
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "name",
-      "outputs": [
-        {
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "decimals",
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint8"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [
-        {
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "balanceOf",
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [],
-      "name": "symbol",
-      "outputs": [
-        {
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "constant": true,
-      "inputs": [
-        {
-          "name": "",
-          "type": "address"
-        },
-        {
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "allowance",
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "payable": false,
-      "stateMutability": "view",
-      "type": "function"
-    },
     {
       "payable": true,
       "stateMutability": "payable",
@@ -168,32 +84,79 @@
       "type": "event"
     },
     {
-      "constant": false,
+      "constant": true,
       "inputs": [],
-      "name": "deposit",
-      "outputs": [],
-      "payable": true,
-      "stateMutability": "payable",
+      "name": "name",
+      "outputs": [
+        {
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
       "type": "function"
     },
     {
-      "constant": false,
+      "constant": true,
+      "inputs": [],
+      "name": "decimals",
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint8"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
       "inputs": [
         {
-          "name": "wad",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "name": "",
           "type": "uint256"
         }
       ],
-      "name": "withdraw",
-      "outputs": [],
       "payable": false,
-      "stateMutability": "nonpayable",
+      "stateMutability": "view",
       "type": "function"
     },
     {
       "constant": true,
       "inputs": [],
-      "name": "totalSupply",
+      "name": "symbol",
+      "outputs": [
+        {
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [
+        {
+          "name": "",
+          "type": "address"
+        },
+        {
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "allowance",
       "outputs": [
         {
           "name": "",
@@ -204,6 +167,29 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "constant": false,
+      "inputs": [],
+      "name": "deposit",
+      "outputs": [],
+      "payable": true,
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [
+        {
+          "name": "wad",
+          "type": "uint256"
+        }
+      ],
+      "name": "withdraw",
+      "outputs": [],
+      "payable": false,
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "constant": false,
       "inputs": [
@@ -284,5 +270,21 @@
   },
   "userdoc": {
     "methods": {}
-  }
-}
\ No newline at end of file
+  },
+  "_disabled": [
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "totalSupply",
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ]
+}
diff --git a/contracts/generated/contracts-generated/balancerqueries/src/lib.rs b/contracts/generated/contracts-generated/balancerqueries/src/lib.rs
index 323bd46d0c..ba9d3eb04d 100644
--- a/contracts/generated/contracts-generated/balancerqueries/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerqueries/src/lib.rs
@@ -6,2743 +6,73 @@
     non_snake_case
 )]
 //! Auto-generated contract bindings. Do not edit.
-///Module containing a contract's types and functions.
 /**
 
-```solidity
-library IVault {
-    type SwapKind is uint8;
-    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
-    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
-    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
-    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
-    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IVault {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapKind(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl SwapKind {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for SwapKind {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<SwapKind> for u8 {
-            fn from(value: SwapKind) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapKind {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapKind {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct BatchSwapStep {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub assetInIndex: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub assetOutIndex: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<BatchSwapStep> for UnderlyingRustTuple<'_> {
-            fn from(value: BatchSwapStep) -> Self {
-                (
-                    value.poolId,
-                    value.assetInIndex,
-                    value.assetOutIndex,
-                    value.amount,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BatchSwapStep {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    poolId: tuple.0,
-                    assetInIndex: tuple.1,
-                    assetOutIndex: tuple.2,
-                    amount: tuple.3,
-                    userData: tuple.4,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for BatchSwapStep {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for BatchSwapStep {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assetInIndex),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assetOutIndex),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for BatchSwapStep {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for BatchSwapStep {
-            const NAME: &'static str = "BatchSwapStep";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "BatchSwapStep(bytes32 poolId,uint256 assetInIndex,uint256 \
-                     assetOutIndex,uint256 amount,bytes userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetInIndex)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assetOutIndex)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for BatchSwapStep {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assetInIndex,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assetOutIndex,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assetInIndex,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assetOutIndex,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ExitPoolRequest {
-        #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub minAmountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub toInternalBalance: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            alloy_sol_types::sol_data::Bytes,
-            alloy_sol_types::sol_data::Bool,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            alloy_sol_types::private::Bytes,
-            bool,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ExitPoolRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: ExitPoolRequest) -> Self {
-                (
-                    value.assets,
-                    value.minAmountsOut,
-                    value.userData,
-                    value.toInternalBalance,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExitPoolRequest {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    assets: tuple.0,
-                    minAmountsOut: tuple.1,
-                    userData: tuple.2,
-                    toInternalBalance: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for ExitPoolRequest {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for ExitPoolRequest {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minAmountsOut),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.toInternalBalance,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for ExitPoolRequest {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for ExitPoolRequest {
-            const NAME: &'static str = "ExitPoolRequest";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "ExitPoolRequest(address[] assets,uint256[] minAmountsOut,bytes userData,bool \
-                     toInternalBalance)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minAmountsOut)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.toInternalBalance,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for ExitPoolRequest {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assets,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.minAmountsOut,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.toInternalBalance,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assets,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.minAmountsOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.toInternalBalance,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct FundManagement {
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub fromInternalBalance: bool,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub toInternalBalance: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bool,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bool,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            bool,
-            alloy_sol_types::private::Address,
-            bool,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<FundManagement> for UnderlyingRustTuple<'_> {
-            fn from(value: FundManagement) -> Self {
-                (
-                    value.sender,
-                    value.fromInternalBalance,
-                    value.recipient,
-                    value.toInternalBalance,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FundManagement {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    sender: tuple.0,
-                    fromInternalBalance: tuple.1,
-                    recipient: tuple.2,
-                    toInternalBalance: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for FundManagement {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for FundManagement {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.fromInternalBalance,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.toInternalBalance,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for FundManagement {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for FundManagement {
-            const NAME: &'static str = "FundManagement";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "FundManagement(address sender,bool fromInternalBalance,address \
-                     recipient,bool toInternalBalance)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.fromInternalBalance,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.recipient,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.toInternalBalance,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for FundManagement {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.fromInternalBalance,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.recipient,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.toInternalBalance,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.fromInternalBalance,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.recipient,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.toInternalBalance,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct JoinPoolRequest {
-        #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub maxAmountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub fromInternalBalance: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            alloy_sol_types::sol_data::Bytes,
-            alloy_sol_types::sol_data::Bool,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            alloy_sol_types::private::Bytes,
-            bool,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<JoinPoolRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: JoinPoolRequest) -> Self {
-                (
-                    value.assets,
-                    value.maxAmountsIn,
-                    value.userData,
-                    value.fromInternalBalance,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for JoinPoolRequest {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    assets: tuple.0,
-                    maxAmountsIn: tuple.1,
-                    userData: tuple.2,
-                    fromInternalBalance: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for JoinPoolRequest {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for JoinPoolRequest {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.maxAmountsIn),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.fromInternalBalance,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for JoinPoolRequest {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for JoinPoolRequest {
-            const NAME: &'static str = "JoinPoolRequest";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "JoinPoolRequest(address[] assets,uint256[] maxAmountsIn,bytes userData,bool \
-                     fromInternalBalance)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxAmountsIn)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.fromInternalBalance,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for JoinPoolRequest {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assets,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maxAmountsIn,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.fromInternalBalance,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assets,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maxAmountsIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.fromInternalBalance,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SingleSwap {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub kind: <SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub assetIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub assetOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            SwapKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::FixedBytes<32>,
-            <SwapKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SingleSwap> for UnderlyingRustTuple<'_> {
-            fn from(value: SingleSwap) -> Self {
-                (
-                    value.poolId,
-                    value.kind,
-                    value.assetIn,
-                    value.assetOut,
-                    value.amount,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SingleSwap {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    poolId: tuple.0,
-                    kind: tuple.1,
-                    assetIn: tuple.2,
-                    assetOut: tuple.3,
-                    amount: tuple.4,
-                    userData: tuple.5,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SingleSwap {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SingleSwap {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.assetIn,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.assetOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SingleSwap {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SingleSwap {
-            const NAME: &'static str = "SingleSwap";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SingleSwap(bytes32 poolId,uint8 kind,address assetIn,address \
-                     assetOut,uint256 amount,bytes userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <SwapKind as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.assetIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.assetOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SingleSwap {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assetIn,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assetOut,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.kind, out);
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assetIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assetOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IVaultInstance<P, N> {
-        IVaultInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IVault`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IVault`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IVaultInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
-            IVaultInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IVault {
-    type SwapKind is uint8;
-    struct BatchSwapStep {
-        bytes32 poolId;
-        uint256 assetInIndex;
-        uint256 assetOutIndex;
-        uint256 amount;
-        bytes userData;
-    }
-    struct ExitPoolRequest {
-        address[] assets;
-        uint256[] minAmountsOut;
-        bytes userData;
-        bool toInternalBalance;
-    }
-    struct FundManagement {
-        address sender;
-        bool fromInternalBalance;
-        address payable recipient;
-        bool toInternalBalance;
-    }
-    struct JoinPoolRequest {
-        address[] assets;
-        uint256[] maxAmountsIn;
-        bytes userData;
-        bool fromInternalBalance;
-    }
-    struct SingleSwap {
-        bytes32 poolId;
-        SwapKind kind;
-        address assetIn;
-        address assetOut;
-        uint256 amount;
-        bytes userData;
-    }
-}
-
-interface BalancerQueries {
-    constructor(address _vault);
-
-    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external returns (int256[] memory assetDeltas);
-    function queryExit(bytes32 poolId, address sender, address recipient, IVault.ExitPoolRequest memory request) external returns (uint256 bptIn, uint256[] memory amountsOut);
-    function queryJoin(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external returns (uint256 bptOut, uint256[] memory amountsIn);
-    function querySwap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds) external returns (uint256);
-    function vault() external view returns (address);
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "constructor",
-    "inputs": [
-      {
-        "name": "_vault",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryBatchSwap",
-    "inputs": [
-      {
-        "name": "kind",
-        "type": "uint8",
-        "internalType": "enum IVault.SwapKind"
-      },
-      {
-        "name": "swaps",
-        "type": "tuple[]",
-        "internalType": "struct IVault.BatchSwapStep[]",
-        "components": [
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "assetInIndex",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "assetOutIndex",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "assets",
-        "type": "address[]",
-        "internalType": "contract IAsset[]"
-      },
-      {
-        "name": "funds",
-        "type": "tuple",
-        "internalType": "struct IVault.FundManagement",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "assetDeltas",
-        "type": "int256[]",
-        "internalType": "int256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryExit",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IVault.ExitPoolRequest",
-        "components": [
-          {
-            "name": "assets",
-            "type": "address[]",
-            "internalType": "contract IAsset[]"
-          },
-          {
-            "name": "minAmountsOut",
-            "type": "uint256[]",
-            "internalType": "uint256[]"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryJoin",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IVault.JoinPoolRequest",
-        "components": [
-          {
-            "name": "assets",
-            "type": "address[]",
-            "internalType": "contract IAsset[]"
-          },
-          {
-            "name": "maxAmountsIn",
-            "type": "uint256[]",
-            "internalType": "uint256[]"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "querySwap",
-    "inputs": [
-      {
-        "name": "singleSwap",
-        "type": "tuple",
-        "internalType": "struct IVault.SingleSwap",
-        "components": [
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "assetIn",
-            "type": "address",
-            "internalType": "contract IAsset"
-          },
-          {
-            "name": "assetOut",
-            "type": "address",
-            "internalType": "contract IAsset"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "funds",
-        "type": "tuple",
-        "internalType": "struct IVault.FundManagement",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "vault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BalancerQueries {
-    use {super::*, alloy_sol_types};
-    /**Constructor`.
-    ```solidity
-    constructor(address _vault);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub _vault: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value._vault,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _vault: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._vault,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool))` and selector `0xf84d066e`.
-    ```solidity
-    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external returns (int256[] memory assetDeltas);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryBatchSwapCall {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub swaps: alloy_sol_types::private::Vec<
-            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],
-    /// address[],(address,bool,address,bool))`](queryBatchSwapCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryBatchSwapReturn {
-        #[allow(missing_docs)]
-        pub assetDeltas:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IVault::SwapKind,
-                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                IVault::FundManagement,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryBatchSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryBatchSwapCall) -> Self {
-                    (value.kind, value.swaps, value.assets, value.funds)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        kind: tuple.0,
-                        swaps: tuple.1,
-                        assets: tuple.2,
-                        funds: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryBatchSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryBatchSwapReturn) -> Self {
-                    (value.assetDeltas,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        assetDeltas: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryBatchSwapCall {
-            type Parameters<'a> = (
-                IVault::SwapKind,
-                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                IVault::FundManagement,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [248u8, 77u8, 6u8, 110u8];
-            const SIGNATURE: &'static str = "queryBatchSwap(uint8,(bytes32,uint256,uint256,\
-                                             uint256,bytes)[],address[],(address,bool,address,\
-                                             bool))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Array<
-                        IVault::BatchSwapStep,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
-                        &self.funds,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Int<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: queryBatchSwapReturn = r.into();
-                        r.assetDeltas
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: queryBatchSwapReturn = r.into();
-                    r.assetDeltas
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryExit(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0xc7b2c52c`.
-    ```solidity
-    function queryExit(bytes32 poolId, address sender, address recipient, IVault.ExitPoolRequest memory request) external returns (uint256 bptIn, uint256[] memory amountsOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryExitCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryExit(bytes32,address,address,(address[],uint256[],bytes,
-    /// bool))`](queryExitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryExitReturn {
-        #[allow(missing_docs)]
-        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::ExitPoolRequest,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitCall) -> Self {
-                    (value.poolId, value.sender, value.recipient, value.request)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        request: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitReturn) -> Self {
-                    (value.bptIn, value.amountsOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptIn: tuple.0,
-                        amountsOut: tuple.1,
-                    }
-                }
-            }
-        }
-        impl queryExitReturn {
-            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryExitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::ExitPoolRequest,
-            );
-            type Return = queryExitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [199u8, 178u8, 197u8, 44u8];
-            const SIGNATURE: &'static str =
-                "queryExit(bytes32,address,address,(address[],uint256[],bytes,bool))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <IVault::ExitPoolRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryExitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryJoin(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0x9ebbf05d`.
-    ```solidity
-    function queryJoin(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external returns (uint256 bptOut, uint256[] memory amountsIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryJoinCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryJoin(bytes32,address,address,(address[],uint256[],bytes,
-    /// bool))`](queryJoinCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryJoinReturn {
-        #[allow(missing_docs)]
-        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::JoinPoolRequest,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinCall) -> Self {
-                    (value.poolId, value.sender, value.recipient, value.request)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        request: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinReturn) -> Self {
-                    (value.bptOut, value.amountsIn)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptOut: tuple.0,
-                        amountsIn: tuple.1,
-                    }
-                }
-            }
-        }
-        impl queryJoinReturn {
-            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryJoinCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::JoinPoolRequest,
-            );
-            type Return = queryJoinReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [158u8, 187u8, 240u8, 93u8];
-            const SIGNATURE: &'static str =
-                "queryJoin(bytes32,address,address,(address[],uint256[],bytes,bool))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <IVault::JoinPoolRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryJoinReturn::_tokenize(ret)
-            }
+Generated by the following Solidity interface...
+```solidity
+interface BalancerQueries {
+    constructor(address _vault);
 
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
+    function vault() external view returns (address);
+}
+```
 
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `querySwap((bytes32,uint8,address,address,uint256,bytes),(address,bool,address,bool))` and selector `0xe969f6b3`.
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "vault",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IVault"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerQueries {
+    use {super::*, alloy_sol_types};
+    /**Constructor`.
     ```solidity
-    function querySwap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds) external returns (uint256);
+    constructor(address _vault);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct querySwapCall {
-        #[allow(missing_docs)]
-        pub singleSwap: <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`querySwap((bytes32,uint8,address,address,uint256,bytes),(address,bool,
-    /// address,bool))`](querySwapCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct querySwapReturn {
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _vault: alloy_sol_types::private::Address,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IVault::SingleSwap, IVault::FundManagement);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
-                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapCall) -> Self {
-                    (value.singleSwap, value.funds)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        singleSwap: tuple.0,
-                        funds: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2754,31 +84,24 @@ pub mod BalancerQueries {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<querySwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._vault,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { _vault: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for querySwapCall {
-            type Parameters<'a> = (IVault::SingleSwap, IVault::FundManagement);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [233u8, 105u8, 246u8, 179u8];
-            const SIGNATURE: &'static str = "querySwap((bytes32,uint8,address,address,uint256,\
-                                             bytes),(address,bool,address,bool))";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -2789,40 +112,11 @@ pub mod BalancerQueries {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IVault::SingleSwap as alloy_sol_types::SolType>::tokenize(&self.singleSwap),
-                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(&self.funds),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._vault,
                     ),
                 )
             }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: querySwapReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: querySwapReturn = r.into();
-                    r._0
-                })
-            }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
@@ -2963,14 +257,6 @@ pub mod BalancerQueries {
     ///Container for all the [`BalancerQueries`](self) function calls.
     #[derive(Clone)]
     pub enum BalancerQueriesCalls {
-        #[allow(missing_docs)]
-        queryBatchSwap(queryBatchSwapCall),
-        #[allow(missing_docs)]
-        queryExit(queryExitCall),
-        #[allow(missing_docs)]
-        queryJoin(queryJoinCall),
-        #[allow(missing_docs)]
-        querySwap(querySwapCall),
         #[allow(missing_docs)]
         vault(vaultCall),
     }
@@ -2982,29 +268,12 @@ pub mod BalancerQueries {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [158u8, 187u8, 240u8, 93u8],
-            [199u8, 178u8, 197u8, 44u8],
-            [233u8, 105u8, 246u8, 179u8],
-            [248u8, 77u8, 6u8, 110u8],
-            [251u8, 250u8, 119u8, 207u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[251u8, 250u8, 119u8, 207u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <querySwapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryBatchSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <vaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<vaultCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(queryJoin),
-            ::core::stringify!(queryExit),
-            ::core::stringify!(querySwap),
-            ::core::stringify!(queryBatchSwap),
-            ::core::stringify!(vault),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(vault)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -3028,19 +297,13 @@ pub mod BalancerQueries {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerQueriesCalls {
-        const COUNT: usize = 5usize;
+        const COUNT: usize = 1usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerQueriesCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::queryBatchSwap(_) => {
-                    <queryBatchSwapCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::querySwap(_) => <querySwapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::vault(_) => <vaultCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -3058,45 +321,14 @@ pub mod BalancerQueries {
         #[inline]
         #[allow(non_snake_case)]
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls>] = &[
-                {
-                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerQueriesCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerQueriesCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn querySwap(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <querySwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerQueriesCalls::querySwap)
-                    }
-                    querySwap
-                },
-                {
-                    fn queryBatchSwap(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerQueriesCalls::queryBatchSwap)
-                    }
-                    queryBatchSwap
-                },
-                {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls>] =
+                &[{
                     fn vault(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
                         <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
                             .map(BalancerQueriesCalls::vault)
                     }
                     vault
-                },
-            ];
+                }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -3115,47 +347,13 @@ pub mod BalancerQueries {
             static DECODE_VALIDATE_SHIMS: &[fn(
                 &[u8],
             )
-                -> alloy_sol_types::Result<BalancerQueriesCalls>] = &[
-                {
-                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerQueriesCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerQueriesCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn querySwap(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <querySwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerQueriesCalls::querySwap)
-                    }
-                    querySwap
-                },
-                {
-                    fn queryBatchSwap(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerQueriesCalls::queryBatchSwap)
-                    }
-                    queryBatchSwap
-                },
-                {
-                    fn vault(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
-                        <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerQueriesCalls::vault)
-                    }
-                    vault
-                },
-            ];
+                -> alloy_sol_types::Result<BalancerQueriesCalls>] = &[{
+                fn vault(data: &[u8]) -> alloy_sol_types::Result<BalancerQueriesCalls> {
+                    <vaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(BalancerQueriesCalls::vault)
+                }
+                vault
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -3168,18 +366,6 @@ pub mod BalancerQueries {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::queryBatchSwap(inner) => {
-                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::querySwap(inner) => {
-                    <querySwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::vault(inner) => {
                     <vaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3189,18 +375,6 @@ pub mod BalancerQueries {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::queryBatchSwap(inner) => {
-                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::querySwap(inner) => {
-                    <querySwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::vault(inner) => {
                     <vaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3316,65 +490,6 @@ pub mod BalancerQueries {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`queryBatchSwap`] function.
-        pub fn queryBatchSwap(
-            &self,
-            kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-            swaps: alloy_sol_types::private::Vec<
-                <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-            >,
-            assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, queryBatchSwapCall, N> {
-            self.call_builder(&queryBatchSwapCall {
-                kind,
-                swaps,
-                assets,
-                funds,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryExit`] function.
-        pub fn queryExit(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
-            self.call_builder(&queryExitCall {
-                poolId,
-                sender,
-                recipient,
-                request,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryJoin`] function.
-        pub fn queryJoin(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
-            self.call_builder(&queryJoinCall {
-                poolId,
-                sender,
-                recipient,
-                request,
-            })
-        }
-
-        ///Creates a new call builder for the [`querySwap`] function.
-        pub fn querySwap(
-            &self,
-            singleSwap: <IVault::SingleSwap as alloy_sol_types::SolType>::RustType,
-            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, querySwapCall, N> {
-            self.call_builder(&querySwapCall { singleSwap, funds })
-        }
-
         ///Creates a new call builder for the [`vault`] function.
         pub fn vault(&self) -> alloy_contract::SolCallBuilder<&P, vaultCall, N> {
             self.call_builder(&vaultCall)
diff --git a/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs b/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs
index d7c9243209..e8c3ca7910 100644
--- a/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2authorizer/src/lib.rs
@@ -17,19 +17,8 @@ interface BalancerV2Authorizer {
 
     constructor(address admin);
 
-    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);
-    function canPerform(bytes32 actionId, address account, address) external view returns (bool);
-    function getRoleAdmin(bytes32 role) external view returns (bytes32);
-    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
-    function getRoleMemberCount(bytes32 role) external view returns (uint256);
     function grantRole(bytes32 role, address account) external;
     function grantRoles(bytes32[] memory roles, address account) external;
-    function grantRolesToMany(bytes32[] memory roles, address[] memory accounts) external;
-    function hasRole(bytes32 role, address account) external view returns (bool);
-    function renounceRole(bytes32 role, address account) external;
-    function revokeRole(bytes32 role, address account) external;
-    function revokeRoles(bytes32[] memory roles, address account) external;
-    function revokeRolesFromMany(bytes32[] memory roles, address[] memory accounts) external;
 }
 ```
 
@@ -47,110 +36,6 @@ interface BalancerV2Authorizer {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "DEFAULT_ADMIN_ROLE",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "canPerform",
-    "inputs": [
-      {
-        "name": "actionId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRoleAdmin",
-    "inputs": [
-      {
-        "name": "role",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRoleMember",
-    "inputs": [
-      {
-        "name": "role",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRoleMemberCount",
-    "inputs": [
-      {
-        "name": "role",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "grantRole",
@@ -187,120 +72,6 @@ interface BalancerV2Authorizer {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "grantRolesToMany",
-    "inputs": [
-      {
-        "name": "roles",
-        "type": "bytes32[]",
-        "internalType": "bytes32[]"
-      },
-      {
-        "name": "accounts",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "hasRole",
-    "inputs": [
-      {
-        "name": "role",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "renounceRole",
-    "inputs": [
-      {
-        "name": "role",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "revokeRole",
-    "inputs": [
-      {
-        "name": "role",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "revokeRoles",
-    "inputs": [
-      {
-        "name": "roles",
-        "type": "bytes32[]",
-        "internalType": "bytes32[]"
-      },
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "revokeRolesFromMany",
-    "inputs": [
-      {
-        "name": "roles",
-        "type": "bytes32[]",
-        "internalType": "bytes32[]"
-      },
-      {
-        "name": "accounts",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "event",
     "name": "RoleAdminChanged",
@@ -849,1708 +620,23 @@ pub mod BalancerV2Authorizer {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DEFAULT_ADMIN_ROLE()` and selector `0xa217fddf`.
-    ```solidity
-    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DEFAULT_ADMIN_ROLECall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DEFAULT_ADMIN_ROLE()`](DEFAULT_ADMIN_ROLECall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DEFAULT_ADMIN_ROLEReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DEFAULT_ADMIN_ROLECall> for UnderlyingRustTuple<'_> {
-                fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DEFAULT_ADMIN_ROLECall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DEFAULT_ADMIN_ROLEReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
-            const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DEFAULT_ADMIN_ROLEReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: DEFAULT_ADMIN_ROLEReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `canPerform(bytes32,address,address)` and selector `0x9be2a884`.
-    ```solidity
-    function canPerform(bytes32 actionId, address account, address) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct canPerformCall {
-        #[allow(missing_docs)]
-        pub actionId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`canPerform(bytes32,address,address)`](canPerformCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct canPerformReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<canPerformCall> for UnderlyingRustTuple<'_> {
-                fn from(value: canPerformCall) -> Self {
-                    (value.actionId, value.account, value._2)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for canPerformCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        actionId: tuple.0,
-                        account: tuple.1,
-                        _2: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<canPerformReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: canPerformReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for canPerformReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for canPerformCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [155u8, 226u8, 168u8, 132u8];
-            const SIGNATURE: &'static str = "canPerform(bytes32,address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.actionId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._2,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: canPerformReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: canPerformReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRoleAdmin(bytes32)` and selector `0x248a9ca3`.
-    ```solidity
-    function getRoleAdmin(bytes32 role) external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRoleAdminCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRoleAdmin(bytes32)`](getRoleAdminCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRoleAdminReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRoleAdminCall) -> Self {
-                    (value.role,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { role: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRoleAdminReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRoleAdminCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
-            const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRoleAdminReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRoleAdminReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRoleMember(bytes32,uint256)` and selector `0x9010d07c`.
-    ```solidity
-    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRoleMemberCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub index: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRoleMember(bytes32,uint256)`](getRoleMemberCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRoleMemberReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRoleMemberCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRoleMemberCall) -> Self {
-                    (value.role, value.index)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        role: tuple.0,
-                        index: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRoleMemberReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRoleMemberReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRoleMemberCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [144u8, 16u8, 208u8, 124u8];
-            const SIGNATURE: &'static str = "getRoleMember(bytes32,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.index),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRoleMemberReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRoleMemberReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRoleMemberCount(bytes32)` and selector `0xca15c873`.
-    ```solidity
-    function getRoleMemberCount(bytes32 role) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRoleMemberCountCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRoleMemberCount(bytes32)`](getRoleMemberCountCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRoleMemberCountReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRoleMemberCountCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRoleMemberCountCall) -> Self {
-                    (value.role,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCountCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { role: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRoleMemberCountReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRoleMemberCountReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleMemberCountReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRoleMemberCountCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [202u8, 21u8, 200u8, 115u8];
-            const SIGNATURE: &'static str = "getRoleMemberCount(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRoleMemberCountReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRoleMemberCountReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `grantRole(bytes32,address)` and selector `0x2f2ff15d`.
-    ```solidity
-    function grantRole(bytes32 role, address account) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct grantRoleCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`grantRole(bytes32,address)`](grantRoleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct grantRoleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: grantRoleCall) -> Self {
-                    (value.role, value.account)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        role: tuple.0,
-                        account: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: grantRoleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl grantRoleReturn {
-            fn _tokenize(&self) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for grantRoleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = grantRoleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
-            const SIGNATURE: &'static str = "grantRole(bytes32,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                grantRoleReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `grantRoles(bytes32[],address)` and selector `0xfcd7627e`.
-    ```solidity
-    function grantRoles(bytes32[] memory roles, address account) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct grantRolesCall {
-        #[allow(missing_docs)]
-        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`grantRoles(bytes32[],address)`](grantRolesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct grantRolesReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<grantRolesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: grantRolesCall) -> Self {
-                    (value.roles, value.account)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        roles: tuple.0,
-                        account: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<grantRolesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: grantRolesReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl grantRolesReturn {
-            fn _tokenize(&self) -> <grantRolesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for grantRolesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = grantRolesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [252u8, 215u8, 98u8, 126u8];
-            const SIGNATURE: &'static str = "grantRoles(bytes32[],address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::FixedBytes<32>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                grantRolesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `grantRolesToMany(bytes32[],address[])` and selector `0xa73cb2ab`.
-    ```solidity
-    function grantRolesToMany(bytes32[] memory roles, address[] memory accounts) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct grantRolesToManyCall {
-        #[allow(missing_docs)]
-        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-        #[allow(missing_docs)]
-        pub accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    ///Container type for the return parameters of the
-    /// [`grantRolesToMany(bytes32[],address[])`](grantRolesToManyCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct grantRolesToManyReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<grantRolesToManyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: grantRolesToManyCall) -> Self {
-                    (value.roles, value.accounts)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesToManyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        roles: tuple.0,
-                        accounts: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<grantRolesToManyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: grantRolesToManyReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesToManyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl grantRolesToManyReturn {
-            fn _tokenize(
-                &self,
-            ) -> <grantRolesToManyCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for grantRolesToManyCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return = grantRolesToManyReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [167u8, 60u8, 178u8, 171u8];
-            const SIGNATURE: &'static str = "grantRolesToMany(bytes32[],address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::FixedBytes<32>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.accounts),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                grantRolesToManyReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `hasRole(bytes32,address)` and selector `0x91d14854`.
-    ```solidity
-    function hasRole(bytes32 role, address account) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hasRoleCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hasRole(bytes32,address)`](hasRoleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hasRoleReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hasRoleCall) -> Self {
-                    (value.role, value.account)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        role: tuple.0,
-                        account: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hasRoleReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for hasRoleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
-            const SIGNATURE: &'static str = "hasRole(bytes32,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: hasRoleReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: hasRoleReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `renounceRole(bytes32,address)` and selector `0x36568abe`.
-    ```solidity
-    function renounceRole(bytes32 role, address account) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct renounceRoleCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`renounceRole(bytes32,address)`](renounceRoleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct renounceRoleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: renounceRoleCall) -> Self {
-                    (value.role, value.account)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        role: tuple.0,
-                        account: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: renounceRoleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl renounceRoleReturn {
-            fn _tokenize(&self) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for renounceRoleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = renounceRoleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
-            const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                renounceRoleReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `revokeRole(bytes32,address)` and selector `0xd547741f`.
-    ```solidity
-    function revokeRole(bytes32 role, address account) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct revokeRoleCall {
-        #[allow(missing_docs)]
-        pub role: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`revokeRole(bytes32,address)`](revokeRoleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct revokeRoleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: revokeRoleCall) -> Self {
-                    (value.role, value.account)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        role: tuple.0,
-                        account: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: revokeRoleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl revokeRoleReturn {
-            fn _tokenize(&self) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for revokeRoleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = revokeRoleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
-            const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.role),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                revokeRoleReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `revokeRoles(bytes32[],address)` and selector `0x988360a3`.
+    /**Function with signature `grantRole(bytes32,address)` and selector `0x2f2ff15d`.
     ```solidity
-    function revokeRoles(bytes32[] memory roles, address account) external;
+    function grantRole(bytes32 role, address account) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct revokeRolesCall {
+    pub struct grantRoleCall {
         #[allow(missing_docs)]
-        pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        pub role: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
         pub account: alloy_sol_types::private::Address,
     }
     ///Container type for the return parameters of the
-    /// [`revokeRoles(bytes32[],address)`](revokeRolesCall) function.
+    /// [`grantRole(bytes32,address)`](grantRoleCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct revokeRolesReturn {}
+    pub struct grantRoleReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2563,12 +649,12 @@ pub mod BalancerV2Authorizer {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+                alloy_sol_types::private::FixedBytes<32>,
                 alloy_sol_types::private::Address,
             );
             #[cfg(test)]
@@ -2582,17 +668,17 @@ pub mod BalancerV2Authorizer {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<revokeRolesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: revokeRolesCall) -> Self {
-                    (value.roles, value.account)
+            impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRoleCall) -> Self {
+                    (value.role, value.account)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        roles: tuple.0,
+                        role: tuple.0,
                         account: tuple.1,
                     }
                 }
@@ -2615,37 +701,37 @@ pub mod BalancerV2Authorizer {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<revokeRolesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: revokeRolesReturn) -> Self {
+            impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRoleReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl revokeRolesReturn {
-            fn _tokenize(&self) -> <revokeRolesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl grantRoleReturn {
+            fn _tokenize(&self) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for revokeRolesCall {
+        impl alloy_sol_types::SolCall for grantRoleCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Address,
             );
-            type Return = revokeRolesReturn;
+            type Return = grantRoleReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [152u8, 131u8, 96u8, 163u8];
-            const SIGNATURE: &'static str = "revokeRoles(bytes32[],address)";
+            const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
+            const SIGNATURE: &'static str = "grantRole(bytes32,address)";
 
             #[inline]
             fn new<'a>(
@@ -2657,9 +743,9 @@ pub mod BalancerV2Authorizer {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::FixedBytes<32>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.roles),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.role),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.account,
                     ),
@@ -2668,7 +754,7 @@ pub mod BalancerV2Authorizer {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                revokeRolesReturn::_tokenize(ret)
+                grantRoleReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -2687,24 +773,23 @@ pub mod BalancerV2Authorizer {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `revokeRolesFromMany(bytes32[],address[])` and selector `0x18b2cde9`.
+    /**Function with signature `grantRoles(bytes32[],address)` and selector `0xfcd7627e`.
     ```solidity
-    function revokeRolesFromMany(bytes32[] memory roles, address[] memory accounts) external;
+    function grantRoles(bytes32[] memory roles, address account) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct revokeRolesFromManyCall {
+    pub struct grantRolesCall {
         #[allow(missing_docs)]
         pub roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
         #[allow(missing_docs)]
-        pub accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub account: alloy_sol_types::private::Address,
     }
     ///Container type for the return parameters of the
-    /// [`revokeRolesFromMany(bytes32[],address[])`](revokeRolesFromManyCall)
-    /// function.
+    /// [`grantRoles(bytes32[],address)`](grantRolesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct revokeRolesFromManyReturn {}
+    pub struct grantRolesReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2718,12 +803,12 @@ pub mod BalancerV2Authorizer {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -2736,18 +821,18 @@ pub mod BalancerV2Authorizer {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<revokeRolesFromManyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: revokeRolesFromManyCall) -> Self {
-                    (value.roles, value.accounts)
+            impl ::core::convert::From<grantRolesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRolesCall) -> Self {
+                    (value.roles, value.account)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesFromManyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
                         roles: tuple.0,
-                        accounts: tuple.1,
+                        account: tuple.1,
                     }
                 }
             }
@@ -2769,40 +854,37 @@ pub mod BalancerV2Authorizer {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<revokeRolesFromManyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: revokeRolesFromManyReturn) -> Self {
+            impl ::core::convert::From<grantRolesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: grantRolesReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRolesFromManyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRolesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl revokeRolesFromManyReturn {
-            fn _tokenize(
-                &self,
-            ) -> <revokeRolesFromManyCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+        impl grantRolesReturn {
+            fn _tokenize(&self) -> <grantRolesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for revokeRolesFromManyCall {
+        impl alloy_sol_types::SolCall for grantRolesCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return = revokeRolesFromManyReturn;
+            type Return = grantRolesReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 178u8, 205u8, 233u8];
-            const SIGNATURE: &'static str = "revokeRolesFromMany(bytes32[],address[])";
+            const SELECTOR: [u8; 4] = [252u8, 215u8, 98u8, 126u8];
+            const SIGNATURE: &'static str = "grantRoles(bytes32[],address)";
 
             #[inline]
             fn new<'a>(
@@ -2817,15 +899,15 @@ pub mod BalancerV2Authorizer {
                     <alloy_sol_types::sol_data::Array<
                         alloy_sol_types::sol_data::FixedBytes<32>,
                     > as alloy_sol_types::SolType>::tokenize(&self.roles),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.accounts),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                revokeRolesFromManyReturn::_tokenize(ret)
+                grantRolesReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -2846,32 +928,10 @@ pub mod BalancerV2Authorizer {
     ///Container for all the [`BalancerV2Authorizer`](self) function calls.
     #[derive(Clone)]
     pub enum BalancerV2AuthorizerCalls {
-        #[allow(missing_docs)]
-        DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
-        #[allow(missing_docs)]
-        canPerform(canPerformCall),
-        #[allow(missing_docs)]
-        getRoleAdmin(getRoleAdminCall),
-        #[allow(missing_docs)]
-        getRoleMember(getRoleMemberCall),
-        #[allow(missing_docs)]
-        getRoleMemberCount(getRoleMemberCountCall),
         #[allow(missing_docs)]
         grantRole(grantRoleCall),
         #[allow(missing_docs)]
         grantRoles(grantRolesCall),
-        #[allow(missing_docs)]
-        grantRolesToMany(grantRolesToManyCall),
-        #[allow(missing_docs)]
-        hasRole(hasRoleCall),
-        #[allow(missing_docs)]
-        renounceRole(renounceRoleCall),
-        #[allow(missing_docs)]
-        revokeRole(revokeRoleCall),
-        #[allow(missing_docs)]
-        revokeRoles(revokeRolesCall),
-        #[allow(missing_docs)]
-        revokeRolesFromMany(revokeRolesFromManyCall),
     }
     impl BalancerV2AuthorizerCalls {
         /// All the selectors of this enum.
@@ -2881,51 +941,16 @@ pub mod BalancerV2Authorizer {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [24u8, 178u8, 205u8, 233u8],
-            [36u8, 138u8, 156u8, 163u8],
-            [47u8, 47u8, 241u8, 93u8],
-            [54u8, 86u8, 138u8, 190u8],
-            [144u8, 16u8, 208u8, 124u8],
-            [145u8, 209u8, 72u8, 84u8],
-            [152u8, 131u8, 96u8, 163u8],
-            [155u8, 226u8, 168u8, 132u8],
-            [162u8, 23u8, 253u8, 223u8],
-            [167u8, 60u8, 178u8, 171u8],
-            [202u8, 21u8, 200u8, 115u8],
-            [213u8, 71u8, 116u8, 31u8],
-            [252u8, 215u8, 98u8, 126u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[47u8, 47u8, 241u8, 93u8], [252u8, 215u8, 98u8, 126u8]];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <revokeRolesFromManyCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRoleAdminCall as alloy_sol_types::SolCall>::SIGNATURE,
             <grantRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <renounceRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRoleMemberCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <hasRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <revokeRolesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <canPerformCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SIGNATURE,
-            <grantRolesToManyCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRoleMemberCountCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <revokeRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
             <grantRolesCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(revokeRolesFromMany),
-            ::core::stringify!(getRoleAdmin),
             ::core::stringify!(grantRole),
-            ::core::stringify!(renounceRole),
-            ::core::stringify!(getRoleMember),
-            ::core::stringify!(hasRole),
-            ::core::stringify!(revokeRoles),
-            ::core::stringify!(canPerform),
-            ::core::stringify!(DEFAULT_ADMIN_ROLE),
-            ::core::stringify!(grantRolesToMany),
-            ::core::stringify!(getRoleMemberCount),
-            ::core::stringify!(revokeRole),
             ::core::stringify!(grantRoles),
         ];
 
@@ -2951,34 +976,15 @@ pub mod BalancerV2Authorizer {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2AuthorizerCalls {
-        const COUNT: usize = 13usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 64usize;
         const NAME: &'static str = "BalancerV2AuthorizerCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::DEFAULT_ADMIN_ROLE(_) => {
-                    <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::canPerform(_) => <canPerformCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRoleAdmin(_) => <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRoleMember(_) => <getRoleMemberCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRoleMemberCount(_) => {
-                    <getRoleMemberCountCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::grantRole(_) => <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::grantRoles(_) => <grantRolesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::grantRolesToMany(_) => {
-                    <grantRolesToManyCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::renounceRole(_) => <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::revokeRole(_) => <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::revokeRoles(_) => <revokeRolesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::revokeRolesFromMany(_) => {
-                    <revokeRolesFromManyCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -2999,24 +1005,6 @@ pub mod BalancerV2Authorizer {
                 &[u8],
             )
                 -> alloy_sol_types::Result<BalancerV2AuthorizerCalls>] = &[
-                {
-                    fn revokeRolesFromMany(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::revokeRolesFromMany)
-                    }
-                    revokeRolesFromMany
-                },
-                {
-                    fn getRoleAdmin(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::getRoleAdmin)
-                    }
-                    getRoleAdmin
-                },
                 {
                     fn grantRole(
                         data: &[u8],
@@ -3026,85 +1014,6 @@ pub mod BalancerV2Authorizer {
                     }
                     grantRole
                 },
-                {
-                    fn renounceRole(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::renounceRole)
-                    }
-                    renounceRole
-                },
-                {
-                    fn getRoleMember(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::getRoleMember)
-                    }
-                    getRoleMember
-                },
-                {
-                    fn hasRole(data: &[u8]) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::hasRole)
-                    }
-                    hasRole
-                },
-                {
-                    fn revokeRoles(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <revokeRolesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::revokeRoles)
-                    }
-                    revokeRoles
-                },
-                {
-                    fn canPerform(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <canPerformCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::canPerform)
-                    }
-                    canPerform
-                },
-                {
-                    fn DEFAULT_ADMIN_ROLE(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::DEFAULT_ADMIN_ROLE)
-                    }
-                    DEFAULT_ADMIN_ROLE
-                },
-                {
-                    fn grantRolesToMany(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::grantRolesToMany)
-                    }
-                    grantRolesToMany
-                },
-                {
-                    fn getRoleMemberCount(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::getRoleMemberCount)
-                    }
-                    getRoleMemberCount
-                },
-                {
-                    fn revokeRole(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2AuthorizerCalls::revokeRole)
-                    }
-                    revokeRole
-                },
                 {
                     fn grantRoles(
                         data: &[u8],
@@ -3135,28 +1044,6 @@ pub mod BalancerV2Authorizer {
             ) -> alloy_sol_types::Result<
                 BalancerV2AuthorizerCalls,
             >] = &[
-                {
-                    fn revokeRolesFromMany(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2AuthorizerCalls::revokeRolesFromMany)
-                    }
-                    revokeRolesFromMany
-                },
-                {
-                    fn getRoleAdmin(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2AuthorizerCalls::getRoleAdmin)
-                    }
-                    getRoleAdmin
-                },
                 {
                     fn grantRole(
                         data: &[u8],
@@ -3166,95 +1053,6 @@ pub mod BalancerV2Authorizer {
                     }
                     grantRole
                 },
-                {
-                    fn renounceRole(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2AuthorizerCalls::renounceRole)
-                    }
-                    renounceRole
-                },
-                {
-                    fn getRoleMember(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <getRoleMemberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2AuthorizerCalls::getRoleMember)
-                    }
-                    getRoleMember
-                },
-                {
-                    fn hasRole(data: &[u8]) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2AuthorizerCalls::hasRole)
-                    }
-                    hasRole
-                },
-                {
-                    fn revokeRoles(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <revokeRolesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2AuthorizerCalls::revokeRoles)
-                    }
-                    revokeRoles
-                },
-                {
-                    fn canPerform(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <canPerformCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2AuthorizerCalls::canPerform)
-                    }
-                    canPerform
-                },
-                {
-                    fn DEFAULT_ADMIN_ROLE(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2AuthorizerCalls::DEFAULT_ADMIN_ROLE)
-                    }
-                    DEFAULT_ADMIN_ROLE
-                },
-                {
-                    fn grantRolesToMany(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2AuthorizerCalls::grantRolesToMany)
-                    }
-                    grantRolesToMany
-                },
-                {
-                    fn getRoleMemberCount(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2AuthorizerCalls::getRoleMemberCount)
-                    }
-                    getRoleMemberCount
-                },
-                {
-                    fn revokeRole(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2AuthorizerCalls> {
-                        <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2AuthorizerCalls::revokeRole)
-                    }
-                    revokeRole
-                },
                 {
                     fn grantRoles(
                         data: &[u8],
@@ -3277,92 +1075,24 @@ pub mod BalancerV2Authorizer {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::DEFAULT_ADMIN_ROLE(inner) => {
-                    <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::canPerform(inner) => {
-                    <canPerformCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getRoleAdmin(inner) => {
-                    <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getRoleMember(inner) => {
-                    <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getRoleMemberCount(inner) => {
-                    <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::grantRole(inner) => {
                     <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::grantRoles(inner) => {
                     <grantRolesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::grantRolesToMany(inner) => {
-                    <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::hasRole(inner) => {
-                    <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::renounceRole(inner) => {
-                    <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::revokeRole(inner) => {
-                    <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::revokeRoles(inner) => {
-                    <revokeRolesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::revokeRolesFromMany(inner) => {
-                    <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::DEFAULT_ADMIN_ROLE(inner) => {
-                    <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::canPerform(inner) => {
-                    <canPerformCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getRoleAdmin(inner) => {
-                    <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getRoleMember(inner) => {
-                    <getRoleMemberCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getRoleMemberCount(inner) => {
-                    <getRoleMemberCountCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::grantRole(inner) => {
                     <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::grantRoles(inner) => {
                     <grantRolesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::grantRolesToMany(inner) => {
-                    <grantRolesToManyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::hasRole(inner) => {
-                    <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::renounceRole(inner) => {
-                    <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::revokeRole(inner) => {
-                    <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::revokeRoles(inner) => {
-                    <revokeRolesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::revokeRolesFromMany(inner) => {
-                    <revokeRolesFromManyCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
             }
         }
     }
@@ -3671,52 +1401,6 @@ pub mod BalancerV2Authorizer {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`DEFAULT_ADMIN_ROLE`] function.
-        pub fn DEFAULT_ADMIN_ROLE(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
-            self.call_builder(&DEFAULT_ADMIN_ROLECall)
-        }
-
-        ///Creates a new call builder for the [`canPerform`] function.
-        pub fn canPerform(
-            &self,
-            actionId: alloy_sol_types::private::FixedBytes<32>,
-            account: alloy_sol_types::private::Address,
-            _2: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, canPerformCall, N> {
-            self.call_builder(&canPerformCall {
-                actionId,
-                account,
-                _2,
-            })
-        }
-
-        ///Creates a new call builder for the [`getRoleAdmin`] function.
-        pub fn getRoleAdmin(
-            &self,
-            role: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
-            self.call_builder(&getRoleAdminCall { role })
-        }
-
-        ///Creates a new call builder for the [`getRoleMember`] function.
-        pub fn getRoleMember(
-            &self,
-            role: alloy_sol_types::private::FixedBytes<32>,
-            index: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCall, N> {
-            self.call_builder(&getRoleMemberCall { role, index })
-        }
-
-        ///Creates a new call builder for the [`getRoleMemberCount`] function.
-        pub fn getRoleMemberCount(
-            &self,
-            role: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, getRoleMemberCountCall, N> {
-            self.call_builder(&getRoleMemberCountCall { role })
-        }
-
         ///Creates a new call builder for the [`grantRole`] function.
         pub fn grantRole(
             &self,
@@ -3734,60 +1418,6 @@ pub mod BalancerV2Authorizer {
         ) -> alloy_contract::SolCallBuilder<&P, grantRolesCall, N> {
             self.call_builder(&grantRolesCall { roles, account })
         }
-
-        ///Creates a new call builder for the [`grantRolesToMany`] function.
-        pub fn grantRolesToMany(
-            &self,
-            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-            accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, grantRolesToManyCall, N> {
-            self.call_builder(&grantRolesToManyCall { roles, accounts })
-        }
-
-        ///Creates a new call builder for the [`hasRole`] function.
-        pub fn hasRole(
-            &self,
-            role: alloy_sol_types::private::FixedBytes<32>,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
-            self.call_builder(&hasRoleCall { role, account })
-        }
-
-        ///Creates a new call builder for the [`renounceRole`] function.
-        pub fn renounceRole(
-            &self,
-            role: alloy_sol_types::private::FixedBytes<32>,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
-            self.call_builder(&renounceRoleCall { role, account })
-        }
-
-        ///Creates a new call builder for the [`revokeRole`] function.
-        pub fn revokeRole(
-            &self,
-            role: alloy_sol_types::private::FixedBytes<32>,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
-            self.call_builder(&revokeRoleCall { role, account })
-        }
-
-        ///Creates a new call builder for the [`revokeRoles`] function.
-        pub fn revokeRoles(
-            &self,
-            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, revokeRolesCall, N> {
-            self.call_builder(&revokeRolesCall { roles, account })
-        }
-
-        ///Creates a new call builder for the [`revokeRolesFromMany`] function.
-        pub fn revokeRolesFromMany(
-            &self,
-            roles: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-            accounts: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, revokeRolesFromManyCall, N> {
-            self.call_builder(&revokeRolesFromManyCall { roles, accounts })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs
index 498db26ba6..fa557b1b9f 100644
--- a/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2basepool/src/lib.rs
@@ -21,24 +21,13 @@ interface BalancerV2BasePool {
     function approve(address spender, uint256 amount) external returns (bool);
     function balanceOf(address account) external view returns (uint256);
     function decimals() external pure returns (uint8);
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getOwner() external view returns (address);
     function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
     function getPoolId() external view returns (bytes32);
     function getSwapFeePercentage() external view returns (uint256);
-    function getVault() external view returns (address);
     function name() external view returns (string memory);
     function nonces(address owner) external view returns (uint256);
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
     function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
-    function setPaused(bool paused) external;
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
     function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
     function transfer(address recipient, uint256 amount) external returns (bool);
     function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 }
@@ -140,51 +129,6 @@ interface BalancerV2BasePool {
     ],
     "stateMutability": "pure"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getOwner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getPausedState",
@@ -234,19 +178,6 @@ interface BalancerV2BasePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "name",
@@ -279,114 +210,6 @@ interface BalancerV2BasePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "onExitPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onJoinPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "permit",
@@ -430,140 +253,6 @@ interface BalancerV2BasePool {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "queryExit",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "queryJoin",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "setPaused",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setSwapFeePercentage",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "symbol",
@@ -577,19 +266,6 @@ interface BalancerV2BasePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -1943,27 +1619,28 @@ pub mod BalancerV2BasePool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct getPausedStateCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`getPausedState()`](getPausedStateCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct getPausedStateReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
         non_snake_case,
         clippy::pub_underscore_fields,
         clippy::style
@@ -1973,9 +1650,9 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1987,25 +1664,33 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2017,29 +1702,58 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
                 }
             }
         }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
 
             #[inline]
             fn new<'a>(
@@ -2050,30 +1764,18 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                getPausedStateReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2081,29 +1783,26 @@ pub mod BalancerV2BasePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
     ```solidity
-    function getAuthorizer() external view returns (address);
+    function getPoolId() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getAuthorizerCall;
+    pub struct getPoolIdCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
+    /// [`getPoolId()`](getPoolIdCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub struct getPoolIdReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -2130,14 +1829,14 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -2146,9 +1845,9 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2160,29 +1859,29 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
+        impl alloy_sol_types::SolCall for getPoolIdCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
 
             #[inline]
             fn new<'a>(
@@ -2198,14 +1897,18 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getAuthorizerReturn = r.into();
+                        let r: getPoolIdReturn = r.into();
                         r._0
                     },
                 )
@@ -2217,28 +1920,28 @@ pub mod BalancerV2BasePool {
                     data,
                 )
                 .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
+                    let r: getPoolIdReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOwner()` and selector `0x893d20e8`.
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
     ```solidity
-    function getOwner() external view returns (address);
+    function getSwapFeePercentage() external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getOwnerCall;
+    pub struct getSwapFeePercentageCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getOwner()`](getOwnerCall) function.
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getOwnerReturn {
+    pub struct getSwapFeePercentageReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -2265,14 +1968,14 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerCall) -> Self {
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -2281,9 +1984,9 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2295,29 +1998,29 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerReturn) -> Self {
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOwnerCall {
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
-            const SIGNATURE: &'static str = "getOwner()";
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
 
             #[inline]
             fn new<'a>(
@@ -2333,14 +2036,18 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getOwnerReturn = r.into();
+                        let r: getSwapFeePercentageReturn = r.into();
                         r._0
                     },
                 )
@@ -2352,32 +2059,28 @@ pub mod BalancerV2BasePool {
                     data,
                 )
                 .map(|r| {
-                    let r: getOwnerReturn = r.into();
+                    let r: getSwapFeePercentageReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function name() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getPausedStateCall;
+    pub struct nameCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPausedState()`](getPausedStateCall) function.
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getPausedStateReturn {
-        #[allow(missing_docs)]
-        pub paused: bool,
-        #[allow(missing_docs)]
-        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct nameReturn {
         #[allow(missing_docs)]
-        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -2404,14 +2107,14 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateCall) -> Self {
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -2420,17 +2123,9 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2442,58 +2137,29 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateReturn) -> Self {
-                    (
-                        value.paused,
-                        value.pauseWindowEndTime,
-                        value.bufferPeriodEndTime,
-                    )
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paused: tuple.0,
-                        pauseWindowEndTime: tuple.1,
-                        bufferPeriodEndTime: tuple.2,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl getPausedStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowEndTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodEndTime,
-                    ),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPausedStateCall {
+        impl alloy_sol_types::SolCall for nameCall {
             type Parameters<'a> = ();
-            type Return = getPausedStateReturn;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
-            const SIGNATURE: &'static str = "getPausedState()";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -2509,13 +2175,17 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPausedStateReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -2523,163 +2193,30 @@ pub mod BalancerV2BasePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function getPoolId() external view returns (bytes32);
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getPoolIdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolId()`](getPoolIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdReturn {
+    pub struct noncesCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub owner: alloy_sol_types::private::Address,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolIdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
-            const SIGNATURE: &'static str = "getPoolId()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
-    ```solidity
-    function getSwapFeePercentage() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapFeePercentageCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getSwapFeePercentageReturn {
+    pub struct noncesReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -2694,9 +2231,9 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2708,16 +2245,16 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageCall) -> Self {
-                    ()
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self { owner: tuple.0 }
                 }
             }
         }
@@ -2738,29 +2275,29 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageReturn) -> Self {
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
-            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -2771,7 +2308,11 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
             }
 
             #[inline]
@@ -2787,7 +2328,7 @@ pub mod BalancerV2BasePool {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getSwapFeePercentageReturn = r.into();
+                        let r: noncesReturn = r.into();
                         r._0
                     },
                 )
@@ -2799,29 +2340,41 @@ pub mod BalancerV2BasePool {
                     data,
                 )
                 .map(|r| {
-                    let r: getSwapFeePercentageReturn = r.into();
+                    let r: noncesReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function getVault() external view returns (address);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
     ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2833,9 +2386,25 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2847,25 +2416,41 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2877,1876 +2462,43 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
-    ```solidity
-    function name() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: nameReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: nameReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
-    ```solidity
-    function nonces(address owner) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: noncesReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: noncesReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
-    ```solidity
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onExitPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onExitPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onExitPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolReturn) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl onExitPoolReturn {
-            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onExitPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onExitPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
-            const SIGNATURE: &'static str =
-                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onExitPoolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
-    ```solidity
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onJoinPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onJoinPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onJoinPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolReturn) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl onJoinPoolReturn {
-            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onJoinPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onJoinPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
-            const SIGNATURE: &'static str =
-                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onJoinPoolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
-    ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = permitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
-    ```solidity
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryExitCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryExitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryExitReturn {
-        #[allow(missing_docs)]
-        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitReturn) -> Self {
-                    (value.bptIn, value.amountsOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptIn: tuple.0,
-                        amountsOut: tuple.1,
-                    }
-                }
-            }
-        }
-        impl queryExitReturn {
-            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryExitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryExitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
-            const SIGNATURE: &'static str =
-                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryExitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
-    ```solidity
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryJoinCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryJoinCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryJoinReturn {
-        #[allow(missing_docs)]
-        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinReturn) -> Self {
-                    (value.bptOut, value.amountsIn)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptOut: tuple.0,
-                        amountsIn: tuple.1,
-                    }
-                }
-            }
-        }
-        impl queryJoinReturn {
-            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryJoinCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryJoinReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
-            const SIGNATURE: &'static str =
-                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryJoinReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
-    ```solidity
-    function setPaused(bool paused) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setPausedCall {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    ///Container type for the return parameters of the
-    /// [`setPaused(bool)`](setPausedCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setPausedReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedCall) -> Self {
-                    (value.paused,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { paused: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setPausedReturn {
-            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setPausedCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Return = setPausedReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
-            const SIGNATURE: &'static str = "setPaused(bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setPausedReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
-    ```solidity
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setSwapFeePercentageCall {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setSwapFeePercentageReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageCall) -> Self {
-                    (value.swapFeePercentage,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapFeePercentage: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setSwapFeePercentageReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = setSwapFeePercentageReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
-            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapFeePercentageReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `symbol()` and selector `0x95d89b41`.
-    ```solidity
-    function symbol() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`symbol()`](symbolCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for symbolCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
-            const SIGNATURE: &'static str = "symbol()";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -4757,22 +2509,40 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: symbolReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -4780,29 +2550,26 @@ pub mod BalancerV2BasePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: symbolReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
     ```solidity
-    function totalSupply() external view returns (uint256);
+    function symbol() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyCall;
+    pub struct symbolCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyReturn {
+    pub struct symbolReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -4829,14 +2596,14 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -4845,9 +2612,9 @@ pub mod BalancerV2BasePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4859,29 +2626,29 @@ pub mod BalancerV2BasePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
+        impl alloy_sol_types::SolCall for symbolCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
 
             #[inline]
             fn new<'a>(
@@ -4897,18 +2664,14 @@ pub mod BalancerV2BasePool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: totalSupplyReturn = r.into();
+                        let r: symbolReturn = r.into();
                         r._0
                     },
                 )
@@ -4920,7 +2683,7 @@ pub mod BalancerV2BasePool {
                     data,
                 )
                 .map(|r| {
-                    let r: totalSupplyReturn = r.into();
+                    let r: symbolReturn = r.into();
                     r._0
                 })
             }
@@ -5267,42 +3030,20 @@ pub mod BalancerV2BasePool {
         #[allow(missing_docs)]
         decimals(decimalsCall),
         #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getOwner(getOwnerCall),
-        #[allow(missing_docs)]
         getPausedState(getPausedStateCall),
         #[allow(missing_docs)]
         getPoolId(getPoolIdCall),
         #[allow(missing_docs)]
         getSwapFeePercentage(getSwapFeePercentageCall),
         #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
         name(nameCall),
         #[allow(missing_docs)]
         nonces(noncesCall),
         #[allow(missing_docs)]
-        onExitPool(onExitPoolCall),
-        #[allow(missing_docs)]
-        onJoinPool(onJoinPoolCall),
-        #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        queryExit(queryExitCall),
-        #[allow(missing_docs)]
-        queryJoin(queryJoinCall),
-        #[allow(missing_docs)]
-        setPaused(setPausedCall),
-        #[allow(missing_docs)]
-        setSwapFeePercentage(setSwapFeePercentageCall),
-        #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -5318,84 +3059,51 @@ pub mod BalancerV2BasePool {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [22u8, 195u8, 139u8, 60u8],
-            [24u8, 22u8, 13u8, 221u8],
             [28u8, 13u8, 224u8, 81u8],
             [35u8, 184u8, 114u8, 221u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
-            [56u8, 233u8, 146u8, 46u8],
             [56u8, 255u8, 242u8, 208u8],
             [85u8, 198u8, 118u8, 40u8],
-            [96u8, 40u8, 191u8, 212u8],
             [112u8, 160u8, 130u8, 49u8],
-            [116u8, 243u8, 176u8, 9u8],
             [126u8, 206u8, 190u8, 0u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [135u8, 236u8, 104u8, 23u8],
-            [137u8, 61u8, 32u8, 232u8],
-            [141u8, 146u8, 138u8, 248u8],
             [149u8, 216u8, 155u8, 65u8],
             [169u8, 5u8, 156u8, 187u8],
-            [170u8, 171u8, 173u8, 197u8],
             [213u8, 5u8, 172u8, 207u8],
-            [213u8, 192u8, 150u8, 196u8],
             [221u8, 98u8, 237u8, 62u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(setPaused),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(getPausedState),
             ::core::stringify!(transferFrom),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(setSwapFeePercentage),
             ::core::stringify!(getPoolId),
             ::core::stringify!(getSwapFeePercentage),
-            ::core::stringify!(queryExit),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(onExitPool),
             ::core::stringify!(nonces),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(queryJoin),
-            ::core::stringify!(getOwner),
-            ::core::stringify!(getVault),
             ::core::stringify!(symbol),
             ::core::stringify!(transfer),
-            ::core::stringify!(getAuthorizer),
             ::core::stringify!(permit),
-            ::core::stringify!(onJoinPool),
             ::core::stringify!(allowance),
         ];
 
@@ -5421,7 +3129,7 @@ pub mod BalancerV2BasePool {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2BasePoolCalls {
-        const COUNT: usize = 25usize;
+        const COUNT: usize = 14usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2BasePoolCalls";
 
@@ -5435,9 +3143,6 @@ pub mod BalancerV2BasePool {
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getPausedState(_) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -5445,20 +3150,10 @@ pub mod BalancerV2BasePool {
                 Self::getSwapFeePercentage(_) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setSwapFeePercentage(_) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -5495,22 +3190,6 @@ pub mod BalancerV2BasePool {
                     }
                     approve
                 },
-                {
-                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -5545,15 +3224,6 @@ pub mod BalancerV2BasePool {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
                 {
                     fn getPoolId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5570,13 +3240,6 @@ pub mod BalancerV2BasePool {
                     }
                     getSwapFeePercentage
                 },
-                {
-                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::queryExit)
-                    }
-                    queryExit
-                },
                 {
                     fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5584,13 +3247,6 @@ pub mod BalancerV2BasePool {
                     }
                     balanceOf
                 },
-                {
-                    fn onExitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5598,36 +3254,6 @@ pub mod BalancerV2BasePool {
                     }
                     nonces
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::getOwner)
-                    }
-                    getOwner
-                },
-                {
-                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::getVault)
-                    }
-                    getVault
-                },
                 {
                     fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5642,15 +3268,6 @@ pub mod BalancerV2BasePool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5658,13 +3275,6 @@ pub mod BalancerV2BasePool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
                 {
                     fn allowance(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5707,22 +3317,6 @@ pub mod BalancerV2BasePool {
                     }
                     approve
                 },
-                {
-                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -5763,17 +3357,6 @@ pub mod BalancerV2BasePool {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2BasePoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
                 {
                     fn getPoolId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5792,13 +3375,6 @@ pub mod BalancerV2BasePool {
                     }
                     getSwapFeePercentage
                 },
-                {
-                    fn queryExit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::queryExit)
-                    }
-                    queryExit
-                },
                 {
                     fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5806,13 +3382,6 @@ pub mod BalancerV2BasePool {
                     }
                     balanceOf
                 },
-                {
-                    fn onExitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5820,36 +3389,6 @@ pub mod BalancerV2BasePool {
                     }
                     nonces
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn queryJoin(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::getOwner)
-                    }
-                    getOwner
-                },
-                {
-                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::getVault)
-                    }
-                    getVault
-                },
                 {
                     fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5864,17 +3403,6 @@ pub mod BalancerV2BasePool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2BasePoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5882,13 +3410,6 @@ pub mod BalancerV2BasePool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
                 {
                     fn allowance(data: &[u8]) -> alloy_sol_types::Result<BalancerV2BasePoolCalls> {
                         <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5924,15 +3445,6 @@ pub mod BalancerV2BasePool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5942,42 +3454,18 @@ pub mod BalancerV2BasePool {
                 Self::getSwapFeePercentage(inner) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6005,15 +3493,6 @@ pub mod BalancerV2BasePool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6025,44 +3504,18 @@ pub mod BalancerV2BasePool {
                         inner, out,
                     )
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6368,24 +3821,6 @@ pub mod BalancerV2BasePool {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getOwner`] function.
-        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
-            self.call_builder(&getOwnerCall)
-        }
-
         ///Creates a new call builder for the [`getPausedState`] function.
         pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
             self.call_builder(&getPausedStateCall)
@@ -6404,11 +3839,6 @@ pub mod BalancerV2BasePool {
             self.call_builder(&getSwapFeePercentageCall)
         }
 
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -6422,54 +3852,6 @@ pub mod BalancerV2BasePool {
             self.call_builder(&noncesCall { owner })
         }
 
-        ///Creates a new call builder for the [`onExitPool`] function.
-        pub fn onExitPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
-            self.call_builder(&onExitPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onJoinPool`] function.
-        pub fn onJoinPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
-            self.call_builder(&onJoinPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
         ///Creates a new call builder for the [`permit`] function.
         pub fn permit(
             &self,
@@ -6492,81 +3874,11 @@ pub mod BalancerV2BasePool {
             })
         }
 
-        ///Creates a new call builder for the [`queryExit`] function.
-        pub fn queryExit(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
-            self.call_builder(&queryExitCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryJoin`] function.
-        pub fn queryJoin(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
-            self.call_builder(&queryJoinCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`setPaused`] function.
-        pub fn setPaused(
-            &self,
-            paused: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
-            self.call_builder(&setPausedCall { paused })
-        }
-
-        ///Creates a new call builder for the [`setSwapFeePercentage`]
-        /// function.
-        pub fn setSwapFeePercentage(
-            &self,
-            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
-            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
-        }
-
         ///Creates a new call builder for the [`symbol`] function.
         pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs
index 02353a218f..4b71d5171c 100644
--- a/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2basepoolfactory/src/lib.rs
@@ -12,47 +12,12 @@ Generated by the following Solidity interface...
 ```solidity
 interface BalancerV2BasePoolFactory {
     event PoolCreated(address indexed pool);
-
-    function getVault() external view returns (address);
-    function isPoolFromFactory(address pool) external view returns (bool);
 }
 ```
 
 ...which was generated by the following JSON ABI:
 ```json
 [
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "PoolCreated",
@@ -185,464 +150,6 @@ pub mod BalancerV2BasePoolFactory {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2BasePoolFactory`](self) function
-    /// calls.
-    #[derive(Clone)]
-    pub enum BalancerV2BasePoolFactoryCalls {
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-    }
-    impl BalancerV2BasePoolFactoryCalls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] =
-            &[[102u8, 52u8, 183u8, 83u8], [141u8, 146u8, 138u8, 248u8]];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(getVault),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
-            }
-        }
-
-        /// Returns the enum variant name for the given selector, if known.
-        #[inline]
-        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
-            let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for BalancerV2BasePoolFactoryCalls {
-        const COUNT: usize = 2usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "BalancerV2BasePoolFactoryCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(
-                &[u8],
-            ) -> alloy_sol_types::Result<
-                BalancerV2BasePoolFactoryCalls,
-            >] = &[
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolFactoryCalls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2BasePoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-            ];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw_validate(
-            selector: [u8; 4],
-            data: &[u8],
-        ) -> alloy_sol_types::Result<Self> {
-            static DECODE_VALIDATE_SHIMS: &[fn(
-                &[u8],
-            ) -> alloy_sol_types::Result<
-                BalancerV2BasePoolFactoryCalls,
-            >] = &[
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2BasePoolFactoryCalls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2BasePoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2BasePoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-            ];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_VALIDATE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        fn abi_encoded_size(&self) -> usize {
-            match self {
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-            }
-        }
-
-        #[inline]
-        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-            match self {
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-            }
-        }
-    }
     ///Container for all the [`BalancerV2BasePoolFactory`](self) events.
     #[derive(Clone, Debug, PartialEq, Eq, Hash)]
     pub enum BalancerV2BasePoolFactoryEvents {
@@ -840,19 +347,6 @@ pub mod BalancerV2BasePoolFactory {
         ) -> alloy_contract::SolCallBuilder<&P, C, N> {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs
index d01e7a3fb9..7a22688432 100644
--- a/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepool/src/lib.rs
@@ -656,13497 +656,4926 @@ pub mod ComposableStablePool {
         }
     }
 }
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
-library IPoolSwapStructs {
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IPoolSwapStructs {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapRequest {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
+library ComposableStablePool {
+    struct NewPoolParams {
+        address vault;
+        address protocolFeeProvider;
+        string name;
+        string symbol;
+        address[] tokens;
+        address[] rateProviders;
+        uint256[] tokenRateCacheDurations;
+        bool[] exemptFromYieldProtocolFeeFlags;
+        uint256 amplificationParameter;
+        uint256 swapFeePercentage;
+        uint256 pauseWindowDuration;
+        uint256 bufferPeriodDuration;
+        address owner;
+        string version;
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            IVault::SwapKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapRequest) -> Self {
-                (
-                    value.kind,
-                    value.tokenIn,
-                    value.tokenOut,
-                    value.amount,
-                    value.poolId,
-                    value.lastChangeBlock,
-                    value.from,
-                    value.to,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    kind: tuple.0,
-                    tokenIn: tuple.1,
-                    tokenOut: tuple.2,
-                    amount: tuple.3,
-                    poolId: tuple.4,
-                    lastChangeBlock: tuple.5,
-                    from: tuple.6,
-                    to: tuple.7,
-                    userData: tuple.8,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapRequest {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.from,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapRequest {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapRequest {
-            const NAME: &'static str = "SwapRequest";
+}
 
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
-                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
-                     userData)",
-                )
-            }
+interface BalancerV2ComposableStablePool {
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    event AmpUpdateStopped(uint256 currentValue);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event ProtocolFeePercentageCacheUpdated(uint256 indexed feeType, uint256 protocolFeePercentage);
+    event RecoveryModeStateChanged(bool enabled);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
+    event TokenRateProviderSet(uint256 indexed tokenIndex, address indexed provider, uint256 cacheDuration);
+    event Transfer(address indexed from, address indexed to, uint256 value);
 
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
+    constructor(ComposableStablePool.NewPoolParams params);
 
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getScalingFactors() external view returns (uint256[] memory);
+    function getSwapFeePercentage() external view returns (uint256);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function pause() external;
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function symbol() external view returns (string memory);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    function version() external view returns (string memory);
+}
+```
 
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.kind,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.lastChangeBlock,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.from,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.to,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapRequest {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenIn,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenOut,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.lastChangeBlock,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.from,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.to,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind, out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.lastChangeBlock,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.from,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.to,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IPoolSwapStructsInstance<P, N> {
-        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IPoolSwapStructs`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IPoolSwapStructs`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IPoolSwapStructsInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
-            IPoolSwapStructsInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library IVault {
-    type SwapKind is uint8;
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IVault {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapKind(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl SwapKind {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for SwapKind {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<SwapKind> for u8 {
-            fn from(value: SwapKind) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapKind {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapKind {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IVaultInstance<P, N> {
-        IVaultInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IVault`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IVault`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IVaultInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
-            IVaultInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library ComposableStablePool {
-    struct NewPoolParams {
-        address vault;
-        address protocolFeeProvider;
-        string name;
-        string symbol;
-        address[] tokens;
-        address[] rateProviders;
-        uint256[] tokenRateCacheDurations;
-        bool[] exemptFromYieldProtocolFeeFlags;
-        uint256 amplificationParameter;
-        uint256 swapFeePercentage;
-        uint256 pauseWindowDuration;
-        uint256 bufferPeriodDuration;
-        address owner;
-        string version;
-    }
-}
-
-library IPoolSwapStructs {
-    struct SwapRequest {
-        IVault.SwapKind kind;
-        address tokenIn;
-        address tokenOut;
-        uint256 amount;
-        bytes32 poolId;
-        uint256 lastChangeBlock;
-        address from;
-        address to;
-        bytes userData;
-    }
-}
-
-library IVault {
-    type SwapKind is uint8;
-}
-
-interface BalancerV2ComposableStablePool {
-    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
-    event AmpUpdateStopped(uint256 currentValue);
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    event PausedStateChanged(bool paused);
-    event ProtocolFeePercentageCacheUpdated(uint256 indexed feeType, uint256 protocolFeePercentage);
-    event RecoveryModeStateChanged(bool enabled);
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
-    event TokenRateProviderSet(uint256 indexed tokenIndex, address indexed provider, uint256 cacheDuration);
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    constructor(ComposableStablePool.NewPoolParams params);
-
-    function DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL() external view returns (uint256);
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function allowance(address owner, address spender) external view returns (uint256);
-    function approve(address spender, uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-    function decimals() external view returns (uint8);
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-    function disableRecoveryMode() external;
-    function enableRecoveryMode() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getActualSupply() external view returns (uint256);
-    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
-    function getAuthorizer() external view returns (address);
-    function getBptIndex() external view returns (uint256);
-    function getDomainSeparator() external view returns (bytes32);
-    function getLastJoinExitData() external view returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
-    function getMinimumBpt() external pure returns (uint256);
-    function getNextNonce(address account) external view returns (uint256);
-    function getOwner() external view returns (address);
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    function getPoolId() external view returns (bytes32);
-    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
-    function getProtocolFeesCollector() external view returns (address);
-    function getProtocolSwapFeeDelegation() external view returns (bool);
-    function getRate() external view returns (uint256);
-    function getRateProviders() external view returns (address[] memory);
-    function getScalingFactors() external view returns (uint256[] memory);
-    function getSwapFeePercentage() external view returns (uint256);
-    function getTokenRate(address token) external view returns (uint256);
-    function getTokenRateCache(address token) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
-    function getVault() external view returns (address);
-    function inRecoveryMode() external view returns (bool);
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    function isTokenExemptFromYieldProtocolFee(address token) external view returns (bool);
-    function name() external view returns (string memory);
-    function nonces(address owner) external view returns (uint256);
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external returns (uint256);
-    function pause() external;
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
-    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-    function setTokenRateCacheDuration(address token, uint256 duration) external;
-    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
-    function stopAmplificationParameterUpdate() external;
-    function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-    function unpause() external;
-    function updateProtocolFeePercentageCache() external;
-    function updateTokenRateCache(address token) external;
-    function version() external view returns (string memory);
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "constructor",
-    "inputs": [
-      {
-        "name": "params",
-        "type": "tuple",
-        "internalType": "struct ComposableStablePool.NewPoolParams",
-        "components": [
-          {
-            "name": "vault",
-            "type": "address",
-            "internalType": "contract IVault"
-          },
-          {
-            "name": "protocolFeeProvider",
-            "type": "address",
-            "internalType": "contract IProtocolFeePercentagesProvider"
-          },
-          {
-            "name": "name",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "symbol",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "tokens",
-            "type": "address[]",
-            "internalType": "contract IERC20[]"
-          },
-          {
-            "name": "rateProviders",
-            "type": "address[]",
-            "internalType": "contract IRateProvider[]"
-          },
-          {
-            "name": "tokenRateCacheDurations",
-            "type": "uint256[]",
-            "internalType": "uint256[]"
-          },
-          {
-            "name": "exemptFromYieldProtocolFeeFlags",
-            "type": "bool[]",
-            "internalType": "bool[]"
-          },
-          {
-            "name": "amplificationParameter",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "swapFeePercentage",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "pauseWindowDuration",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "bufferPeriodDuration",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "owner",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "version",
-            "type": "string",
-            "internalType": "string"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "DOMAIN_SEPARATOR",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "allowance",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "approve",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "balanceOf",
-    "inputs": [
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "decimals",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint8",
-        "internalType": "uint8"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "decreaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "disableRecoveryMode",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "enableRecoveryMode",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getActualSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmplificationParameter",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "isUpdating",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "precision",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getBptIndex",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getDomainSeparator",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getLastJoinExitData",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "lastJoinExitAmplification",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "lastPostJoinExitInvariant",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getMinimumBpt",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getNextNonce",
-    "inputs": [
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getOwner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPausedState",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "pauseWindowEndTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodEndTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolId",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentageCache",
-    "inputs": [
-      {
-        "name": "feeType",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeesCollector",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeesCollector"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolSwapFeeDelegation",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRate",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRateProviders",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address[]",
-        "internalType": "contract IRateProvider[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getScalingFactors",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getSwapFeePercentage",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getTokenRate",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getTokenRateCache",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "rate",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "oldRate",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "duration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "expires",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "inRecoveryMode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "increaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "addedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "isTokenExemptFromYieldProtocolFee",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "name",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "nonces",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "onExitPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onJoinPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onSwap",
-    "inputs": [
-      {
-        "name": "swapRequest",
-        "type": "tuple",
-        "internalType": "struct IPoolSwapStructs.SwapRequest",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "tokenOut",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "lastChangeBlock",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "from",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "indexIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "indexOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "pause",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "permit",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryExit",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryJoin",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setAssetManagerPoolConfig",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "poolConfig",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setSwapFeePercentage",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setTokenRateCacheDuration",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "duration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "startAmplificationParameterUpdate",
-    "inputs": [
-      {
-        "name": "rawEndValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "stopAmplificationParameterUpdate",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "symbol",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "transfer",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferFrom",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "unpause",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "updateProtocolFeePercentageCache",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "updateTokenRateCache",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "version",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "event",
-    "name": "AmpUpdateStarted",
-    "inputs": [
-      {
-        "name": "startValue",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "endValue",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "startTime",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "AmpUpdateStopped",
-    "inputs": [
-      {
-        "name": "currentValue",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Approval",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PausedStateChanged",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ProtocolFeePercentageCacheUpdated",
-    "inputs": [
-      {
-        "name": "feeType",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolFeePercentage",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "RecoveryModeStateChanged",
-    "inputs": [
-      {
-        "name": "enabled",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SwapFeePercentageChanged",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TokenRateCacheUpdated",
-    "inputs": [
-      {
-        "name": "tokenIndex",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "rate",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TokenRateProviderSet",
-    "inputs": [
-      {
-        "name": "tokenIndex",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "provider",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IRateProvider"
-      },
-      {
-        "name": "cacheDuration",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Transfer",
-    "inputs": [
-      {
-        "name": "from",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BalancerV2ComposableStablePool {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `AmpUpdateStarted(uint256,uint256,uint256,uint256)` and selector `0x1835882ee7a34ac194f717a35e09bb1d24c82a3b9d854ab6c9749525b714cdf2`.
-    ```solidity
-    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct AmpUpdateStarted {
-        #[allow(missing_docs)]
-        pub startValue: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endValue: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for AmpUpdateStarted {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "AmpUpdateStarted(uint256,uint256,uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
-                    94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8,
-                    201u8, 116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    startValue: data.0,
-                    endValue: data.1,
-                    startTime: data.2,
-                    endTime: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.startValue,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.endValue,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.startTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.endTime,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for AmpUpdateStarted {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&AmpUpdateStarted> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &AmpUpdateStarted) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `AmpUpdateStopped(uint256)` and selector `0xa0d01593e47e69d07e0ccd87bece09411e07dd1ed40ca8f2e7af2976542a0233`.
-    ```solidity
-    event AmpUpdateStopped(uint256 currentValue);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct AmpUpdateStopped {
-        #[allow(missing_docs)]
-        pub currentValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for AmpUpdateStopped {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "AmpUpdateStopped(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8,
-                    135u8, 190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8,
-                    242u8, 231u8, 175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    currentValue: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.currentValue,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for AmpUpdateStopped {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&AmpUpdateStopped> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &AmpUpdateStopped) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
-    ```solidity
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Approval {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Approval {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
-                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
-                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    spender: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.spender.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Approval {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Approval> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
-    ```solidity
-    event PausedStateChanged(bool paused);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PausedStateChanged {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PausedStateChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
-                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
-                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { paused: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ProtocolFeePercentageCacheUpdated(uint256,uint256)` and selector `0x6bfb689528fa96ec1ad670ad6d6064be1ae96bfd5d2ee35c837fd0fe0c11959a`.
-    ```solidity
-    event ProtocolFeePercentageCacheUpdated(uint256 indexed feeType, uint256 protocolFeePercentage);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ProtocolFeePercentageCacheUpdated {
-        #[allow(missing_docs)]
-        pub feeType: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ProtocolFeePercentageCacheUpdated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ProtocolFeePercentageCacheUpdated(uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    107u8, 251u8, 104u8, 149u8, 40u8, 250u8, 150u8, 236u8, 26u8, 214u8, 112u8,
-                    173u8, 109u8, 96u8, 100u8, 190u8, 26u8, 233u8, 107u8, 253u8, 93u8, 46u8, 227u8,
-                    92u8, 131u8, 127u8, 208u8, 254u8, 12u8, 17u8, 149u8, 154u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    feeType: topics.1,
-                    protocolFeePercentage: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.feeType.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.feeType);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ProtocolFeePercentageCacheUpdated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ProtocolFeePercentageCacheUpdated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ProtocolFeePercentageCacheUpdated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `RecoveryModeStateChanged(bool)` and selector `0xeff3d4d215b42bf0960be9c6d5e05c22cba4df6627a3a523e2acee733b5854c8`.
-    ```solidity
-    event RecoveryModeStateChanged(bool enabled);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct RecoveryModeStateChanged {
-        #[allow(missing_docs)]
-        pub enabled: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for RecoveryModeStateChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "RecoveryModeStateChanged(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    239u8, 243u8, 212u8, 210u8, 21u8, 180u8, 43u8, 240u8, 150u8, 11u8, 233u8,
-                    198u8, 213u8, 224u8, 92u8, 34u8, 203u8, 164u8, 223u8, 102u8, 39u8, 163u8,
-                    165u8, 35u8, 226u8, 172u8, 238u8, 115u8, 59u8, 88u8, 84u8, 200u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { enabled: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.enabled,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for RecoveryModeStateChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&RecoveryModeStateChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &RecoveryModeStateChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
-    ```solidity
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SwapFeePercentageChanged {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
-                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
-                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    swapFeePercentage: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TokenRateCacheUpdated(uint256,uint256)` and selector `0xb77a83204ca282e08dc3a65b0a1ca32ea4e6875c38ef0bf5bf75e52a67354fac`.
-    ```solidity
-    event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TokenRateCacheUpdated {
-        #[allow(missing_docs)]
-        pub tokenIndex: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub rate: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TokenRateCacheUpdated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "TokenRateCacheUpdated(uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    183u8, 122u8, 131u8, 32u8, 76u8, 162u8, 130u8, 224u8, 141u8, 195u8, 166u8,
-                    91u8, 10u8, 28u8, 163u8, 46u8, 164u8, 230u8, 135u8, 92u8, 56u8, 239u8, 11u8,
-                    245u8, 191u8, 117u8, 229u8, 42u8, 103u8, 53u8, 79u8, 172u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    tokenIndex: topics.1,
-                    rate: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.rate,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.tokenIndex.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenIndex);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TokenRateCacheUpdated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TokenRateCacheUpdated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TokenRateCacheUpdated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TokenRateProviderSet(uint256,address,uint256)` and selector `0xdd6d1c9badb346de6925b358a472c937b41698d2632696759e43fd6527feeec4`.
-    ```solidity
-    event TokenRateProviderSet(uint256 indexed tokenIndex, address indexed provider, uint256 cacheDuration);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TokenRateProviderSet {
-        #[allow(missing_docs)]
-        pub tokenIndex: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub provider: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub cacheDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TokenRateProviderSet {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "TokenRateProviderSet(uint256,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    221u8, 109u8, 28u8, 155u8, 173u8, 179u8, 70u8, 222u8, 105u8, 37u8, 179u8, 88u8,
-                    164u8, 114u8, 201u8, 55u8, 180u8, 22u8, 152u8, 210u8, 99u8, 38u8, 150u8, 117u8,
-                    158u8, 67u8, 253u8, 101u8, 39u8, 254u8, 238u8, 196u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    tokenIndex: topics.1,
-                    provider: topics.2,
-                    cacheDuration: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.cacheDuration,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.tokenIndex.clone(),
-                    self.provider.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenIndex);
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.provider,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TokenRateProviderSet {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TokenRateProviderSet> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TokenRateProviderSet) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
-    ```solidity
-    event Transfer(address indexed from, address indexed to, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Transfer {
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Transfer {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
-                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
-                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    from: topics.1,
-                    to: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.from.clone(),
-                    self.to.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.from,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.to,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Transfer {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Transfer> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(ComposableStablePool.NewPoolParams params);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub params: <ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::RustType,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ComposableStablePool::NewPoolParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value.params,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { params: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (ComposableStablePool::NewPoolParams,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL()` and selector `0xddf4627b`.
-    ```solidity
-    function DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL()`](DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [221u8, 244u8, 98u8, 123u8];
-            const SIGNATURE: &'static str = "DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: DELEGATE_PROTOCOL_SWAP_FEES_SENTINELReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
-    ```solidity
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
-            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DOMAIN_SEPARATORReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: DOMAIN_SEPARATORReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
-    ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: allowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: allowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
-    ```solidity
-    function approve(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approveReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: approveReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
-    ```solidity
-    function balanceOf(address account) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: balanceOfReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: balanceOfReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
-    ```solidity
-    function decimals() external view returns (uint8);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsReturn {
-        #[allow(missing_docs)]
-        pub _0: u8,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
-            type Parameters<'a> = ();
-            type Return = u8;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decimalsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decimalsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
-    ```solidity
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
-            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decreaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decreaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `disableRecoveryMode()` and selector `0xb7b814fc`.
-    ```solidity
-    function disableRecoveryMode() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableRecoveryModeCall;
-    ///Container type for the return parameters of the
-    /// [`disableRecoveryMode()`](disableRecoveryModeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableRecoveryModeReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableRecoveryModeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: disableRecoveryModeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableRecoveryModeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableRecoveryModeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: disableRecoveryModeReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableRecoveryModeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl disableRecoveryModeReturn {
-            fn _tokenize(
-                &self,
-            ) -> <disableRecoveryModeCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for disableRecoveryModeCall {
-            type Parameters<'a> = ();
-            type Return = disableRecoveryModeReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [183u8, 184u8, 20u8, 252u8];
-            const SIGNATURE: &'static str = "disableRecoveryMode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                disableRecoveryModeReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `enableRecoveryMode()` and selector `0x54a844ba`.
-    ```solidity
-    function enableRecoveryMode() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableRecoveryModeCall;
-    ///Container type for the return parameters of the
-    /// [`enableRecoveryMode()`](enableRecoveryModeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableRecoveryModeReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableRecoveryModeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: enableRecoveryModeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableRecoveryModeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableRecoveryModeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: enableRecoveryModeReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableRecoveryModeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl enableRecoveryModeReturn {
-            fn _tokenize(
-                &self,
-            ) -> <enableRecoveryModeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for enableRecoveryModeCall {
-            type Parameters<'a> = ();
-            type Return = enableRecoveryModeReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 168u8, 68u8, 186u8];
-            const SIGNATURE: &'static str = "enableRecoveryMode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                enableRecoveryModeReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
-    ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActualSupply()` and selector `0x876f303b`.
-    ```solidity
-    function getActualSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActualSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActualSupply()`](getActualSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActualSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActualSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActualSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActualSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActualSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActualSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActualSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActualSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [135u8, 111u8, 48u8, 59u8];
-            const SIGNATURE: &'static str = "getActualSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActualSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActualSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmplificationParameter()` and selector `0x6daccffa`.
-    ```solidity
-    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmplificationParameterCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmplificationParameter()`](getAmplificationParameterCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmplificationParameterReturn {
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub isUpdating: bool,
-        #[allow(missing_docs)]
-        pub precision: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmplificationParameterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmplificationParameterCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmplificationParameterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmplificationParameterReturn) -> Self {
-                    (value.value, value.isUpdating, value.precision)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        value: tuple.0,
-                        isUpdating: tuple.1,
-                        precision: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getAmplificationParameterReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getAmplificationParameterCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.isUpdating,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.precision,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmplificationParameterCall {
-            type Parameters<'a> = ();
-            type Return = getAmplificationParameterReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [109u8, 172u8, 207u8, 250u8];
-            const SIGNATURE: &'static str = "getAmplificationParameter()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getAmplificationParameterReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getBptIndex()` and selector `0x82687a56`.
-    ```solidity
-    function getBptIndex() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getBptIndexCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getBptIndex()`](getBptIndexCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getBptIndexReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getBptIndexCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getBptIndexCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getBptIndexCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getBptIndexReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getBptIndexReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getBptIndexReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getBptIndexCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [130u8, 104u8, 122u8, 86u8];
-            const SIGNATURE: &'static str = "getBptIndex()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getBptIndexReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getBptIndexReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getDomainSeparator()` and selector `0xed24911d`.
-    ```solidity
-    function getDomainSeparator() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getDomainSeparatorCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getDomainSeparator()`](getDomainSeparatorCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getDomainSeparatorReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getDomainSeparatorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getDomainSeparatorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getDomainSeparatorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getDomainSeparatorReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getDomainSeparatorCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [237u8, 36u8, 145u8, 29u8];
-            const SIGNATURE: &'static str = "getDomainSeparator()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getDomainSeparatorReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getDomainSeparatorReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getLastJoinExitData()` and selector `0x3c975d51`.
-    ```solidity
-    function getLastJoinExitData() external view returns (uint256 lastJoinExitAmplification, uint256 lastPostJoinExitInvariant);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLastJoinExitDataCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getLastJoinExitData()`](getLastJoinExitDataCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLastJoinExitDataReturn {
-        #[allow(missing_docs)]
-        pub lastJoinExitAmplification: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub lastPostJoinExitInvariant: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLastJoinExitDataCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getLastJoinExitDataCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastJoinExitDataCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLastJoinExitDataReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getLastJoinExitDataReturn) -> Self {
-                    (
-                        value.lastJoinExitAmplification,
-                        value.lastPostJoinExitInvariant,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastJoinExitDataReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        lastJoinExitAmplification: tuple.0,
-                        lastPostJoinExitInvariant: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getLastJoinExitDataReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getLastJoinExitDataCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.lastJoinExitAmplification,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.lastPostJoinExitInvariant,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getLastJoinExitDataCall {
-            type Parameters<'a> = ();
-            type Return = getLastJoinExitDataReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [60u8, 151u8, 93u8, 81u8];
-            const SIGNATURE: &'static str = "getLastJoinExitData()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getLastJoinExitDataReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getMinimumBpt()` and selector `0x04842d4c`.
-    ```solidity
-    function getMinimumBpt() external pure returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMinimumBptCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getMinimumBpt()`](getMinimumBptCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMinimumBptReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMinimumBptCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getMinimumBptCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinimumBptCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMinimumBptReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getMinimumBptReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinimumBptReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getMinimumBptCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [4u8, 132u8, 45u8, 76u8];
-            const SIGNATURE: &'static str = "getMinimumBpt()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getMinimumBptReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getMinimumBptReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getNextNonce(address)` and selector `0x90193b7c`.
-    ```solidity
-    function getNextNonce(address account) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNextNonceCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getNextNonce(address)`](getNextNonceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNextNonceReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNextNonceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getNextNonceCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNextNonceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getNextNonceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getNextNonceCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [144u8, 25u8, 59u8, 124u8];
-            const SIGNATURE: &'static str = "getNextNonce(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getNextNonceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getNextNonceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOwner()` and selector `0x893d20e8`.
-    ```solidity
-    function getOwner() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getOwner()`](getOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOwnerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
-            const SIGNATURE: &'static str = "getOwner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOwnerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOwnerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
-    ```solidity
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPausedState()`](getPausedStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateReturn {
-        #[allow(missing_docs)]
-        pub paused: bool,
-        #[allow(missing_docs)]
-        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateReturn) -> Self {
-                    (
-                        value.paused,
-                        value.pauseWindowEndTime,
-                        value.bufferPeriodEndTime,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paused: tuple.0,
-                        pauseWindowEndTime: tuple.1,
-                        bufferPeriodEndTime: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getPausedStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowEndTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodEndTime,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPausedStateCall {
-            type Parameters<'a> = ();
-            type Return = getPausedStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
-            const SIGNATURE: &'static str = "getPausedState()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPausedStateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
-    ```solidity
-    function getPoolId() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolId()`](getPoolIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolIdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
-            const SIGNATURE: &'static str = "getPoolId()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentageCache(uint256)` and selector `0x70464016`.
-    ```solidity
-    function getProtocolFeePercentageCache(uint256 feeType) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentageCacheCall {
-        #[allow(missing_docs)]
-        pub feeType: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentageCache(uint256)`](getProtocolFeePercentageCacheCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentageCacheReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentageCacheCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentageCacheCall) -> Self {
-                    (value.feeType,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentageCacheCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { feeType: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentageCacheReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentageCacheReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentageCacheReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentageCacheCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 70u8, 64u8, 22u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentageCache(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeType,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentageCacheReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentageCacheReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeesCollector()` and selector `0xd2946c2b`.
-    ```solidity
-    function getProtocolFeesCollector() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeesCollectorCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeesCollector()`](getProtocolFeesCollectorCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeesCollectorReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeesCollectorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeesCollectorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeesCollectorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeesCollectorReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeesCollectorCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [210u8, 148u8, 108u8, 43u8];
-            const SIGNATURE: &'static str = "getProtocolFeesCollector()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeesCollectorReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeesCollectorReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolSwapFeeDelegation()` and selector `0x15b0015b`.
-    ```solidity
-    function getProtocolSwapFeeDelegation() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolSwapFeeDelegationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolSwapFeeDelegation()`](getProtocolSwapFeeDelegationCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolSwapFeeDelegationReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolSwapFeeDelegationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolSwapFeeDelegationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolSwapFeeDelegationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolSwapFeeDelegationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolSwapFeeDelegationReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolSwapFeeDelegationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolSwapFeeDelegationCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [21u8, 176u8, 1u8, 91u8];
-            const SIGNATURE: &'static str = "getProtocolSwapFeeDelegation()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolSwapFeeDelegationReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolSwapFeeDelegationReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRate()` and selector `0x679aefce`.
-    ```solidity
-    function getRate() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRate()`](getRateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRateCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
-            const SIGNATURE: &'static str = "getRate()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRateReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRateReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRateProviders()` and selector `0x238a2d59`.
-    ```solidity
-    function getRateProviders() external view returns (address[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateProvidersCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRateProviders()`](getRateProvidersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateProvidersReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateProvidersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateProvidersCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateProvidersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateProvidersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateProvidersReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateProvidersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRateProvidersCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [35u8, 138u8, 45u8, 89u8];
-            const SIGNATURE: &'static str = "getRateProviders()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRateProvidersReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRateProvidersReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getScalingFactors()` and selector `0x1dd746ea`.
-    ```solidity
-    function getScalingFactors() external view returns (uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getScalingFactorsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getScalingFactors()`](getScalingFactorsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getScalingFactorsReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getScalingFactorsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getScalingFactorsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getScalingFactorsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getScalingFactorsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getScalingFactorsCall {
-            type Parameters<'a> = ();
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [29u8, 215u8, 70u8, 234u8];
-            const SIGNATURE: &'static str = "getScalingFactors()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getScalingFactorsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getScalingFactorsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
-    ```solidity
-    function getSwapFeePercentage() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapFeePercentageCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapFeePercentageReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
-            const SIGNATURE: &'static str = "getSwapFeePercentage()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSwapFeePercentageReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getSwapFeePercentageReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTokenRate(address)` and selector `0x54dea00a`.
-    ```solidity
-    function getTokenRate(address token) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTokenRateCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getTokenRate(address)`](getTokenRateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTokenRateReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTokenRateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTokenRateCall) -> Self {
-                    (value.token,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { token: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTokenRateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTokenRateReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTokenRateCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 222u8, 160u8, 10u8];
-            const SIGNATURE: &'static str = "getTokenRate(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getTokenRateReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getTokenRateReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTokenRateCache(address)` and selector `0x7f1260d1`.
-    ```solidity
-    function getTokenRateCache(address token) external view returns (uint256 rate, uint256 oldRate, uint256 duration, uint256 expires);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTokenRateCacheCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getTokenRateCache(address)`](getTokenRateCacheCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTokenRateCacheReturn {
-        #[allow(missing_docs)]
-        pub rate: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub oldRate: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub duration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub expires: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTokenRateCacheCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTokenRateCacheCall) -> Self {
-                    (value.token,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateCacheCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { token: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTokenRateCacheReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTokenRateCacheReturn) -> Self {
-                    (value.rate, value.oldRate, value.duration, value.expires)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTokenRateCacheReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        rate: tuple.0,
-                        oldRate: tuple.1,
-                        duration: tuple.2,
-                        expires: tuple.3,
-                    }
-                }
-            }
-        }
-        impl getTokenRateCacheReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getTokenRateCacheCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.rate,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.oldRate,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.duration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.expires,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTokenRateCacheCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = getTokenRateCacheReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 18u8, 96u8, 209u8];
-            const SIGNATURE: &'static str = "getTokenRateCache(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getTokenRateCacheReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `inRecoveryMode()` and selector `0xb35056b8`.
-    ```solidity
-    function inRecoveryMode() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct inRecoveryModeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`inRecoveryMode()`](inRecoveryModeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct inRecoveryModeReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<inRecoveryModeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: inRecoveryModeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for inRecoveryModeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<inRecoveryModeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: inRecoveryModeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for inRecoveryModeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for inRecoveryModeCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [179u8, 80u8, 86u8, 184u8];
-            const SIGNATURE: &'static str = "inRecoveryMode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: inRecoveryModeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: inRecoveryModeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
-    ```solidity
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceCall) -> Self {
-                    (value.spender, value.addedValue)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        addedValue: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
-            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.addedValue,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: increaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: increaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isTokenExemptFromYieldProtocolFee(address)` and selector `0xab7759f1`.
-    ```solidity
-    function isTokenExemptFromYieldProtocolFee(address token) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isTokenExemptFromYieldProtocolFeeCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isTokenExemptFromYieldProtocolFee(address)`](isTokenExemptFromYieldProtocolFeeCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isTokenExemptFromYieldProtocolFeeReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isTokenExemptFromYieldProtocolFeeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isTokenExemptFromYieldProtocolFeeCall) -> Self {
-                    (value.token,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isTokenExemptFromYieldProtocolFeeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { token: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isTokenExemptFromYieldProtocolFeeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isTokenExemptFromYieldProtocolFeeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isTokenExemptFromYieldProtocolFeeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isTokenExemptFromYieldProtocolFeeCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [171u8, 119u8, 89u8, 241u8];
-            const SIGNATURE: &'static str = "isTokenExemptFromYieldProtocolFee(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isTokenExemptFromYieldProtocolFeeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isTokenExemptFromYieldProtocolFeeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
-    ```solidity
-    function name() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: nameReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: nameReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
-    ```solidity
-    function nonces(address owner) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: noncesReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: noncesReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
-    ```solidity
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onExitPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onExitPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onExitPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolReturn) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl onExitPoolReturn {
-            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onExitPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onExitPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
-            const SIGNATURE: &'static str =
-                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onExitPoolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
-    ```solidity
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onJoinPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onJoinPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onJoinPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolReturn) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl onJoinPoolReturn {
-            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onJoinPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onJoinPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
-            const SIGNATURE: &'static str =
-                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onJoinPoolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256[],uint256,uint256)` and selector `0x01ec954a`.
-    ```solidity
-    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onSwapCall {
-        #[allow(missing_docs)]
-        pub swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub indexIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub indexOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
-    /// bytes),uint256[],uint256,uint256)`](onSwapCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onSwapReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwapCall) -> Self {
-                    (
-                        value.swapRequest,
-                        value.balances,
-                        value.indexIn,
-                        value.indexOut,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapRequest: tuple.0,
-                        balances: tuple.1,
-                        indexIn: tuple.2,
-                        indexOut: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwapReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onSwapCall {
-            type Parameters<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [1u8, 236u8, 149u8, 74u8];
-            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
-                                             uint256,address,address,bytes),uint256[],uint256,\
-                                             uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.swapRequest,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.indexIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.indexOut),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: onSwapReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: onSwapReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `pause()` and selector `0x8456cb59`.
-    ```solidity
-    function pause() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct pauseCall;
-    ///Container type for the return parameters of the [`pause()`](pauseCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct pauseReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
-                fn from(value: pauseCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: pauseReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl pauseReturn {
-            fn _tokenize(&self) -> <pauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for pauseCall {
-            type Parameters<'a> = ();
-            type Return = pauseReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [132u8, 86u8, 203u8, 89u8];
-            const SIGNATURE: &'static str = "pause()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                pauseReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
-    ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = permitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
-    ```solidity
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryExitCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryExitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryExitReturn {
-        #[allow(missing_docs)]
-        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitReturn) -> Self {
-                    (value.bptIn, value.amountsOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptIn: tuple.0,
-                        amountsOut: tuple.1,
-                    }
-                }
-            }
-        }
-        impl queryExitReturn {
-            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryExitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryExitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
-            const SIGNATURE: &'static str =
-                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryExitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
-    ```solidity
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryJoinCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryJoinCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct queryJoinReturn {
-        #[allow(missing_docs)]
-        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinReturn) -> Self {
-                    (value.bptOut, value.amountsIn)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptOut: tuple.0,
-                        amountsIn: tuple.1,
-                    }
-                }
-            }
-        }
-        impl queryJoinReturn {
-            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryJoinCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryJoinReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
-            const SIGNATURE: &'static str =
-                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryJoinReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setAssetManagerPoolConfig(address,bytes)` and selector `0x50dd6ed9`.
-    ```solidity
-    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setAssetManagerPoolConfigCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub poolConfig: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`setAssetManagerPoolConfig(address,
-    /// bytes)`](setAssetManagerPoolConfigCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setAssetManagerPoolConfigReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setAssetManagerPoolConfigCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setAssetManagerPoolConfigCall) -> Self {
-                    (value.token, value.poolConfig)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        poolConfig: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setAssetManagerPoolConfigReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setAssetManagerPoolConfigReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setAssetManagerPoolConfigReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setAssetManagerPoolConfigCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = setAssetManagerPoolConfigReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [80u8, 221u8, 110u8, 217u8];
-            const SIGNATURE: &'static str = "setAssetManagerPoolConfig(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.poolConfig,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setAssetManagerPoolConfigReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
-    ```solidity
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setSwapFeePercentageCall {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setSwapFeePercentageReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageCall) -> Self {
-                    (value.swapFeePercentage,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapFeePercentage: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setSwapFeePercentageReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = setSwapFeePercentageReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
-            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapFeePercentageReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setTokenRateCacheDuration(address,uint256)` and selector `0xf4b7964d`.
-    ```solidity
-    function setTokenRateCacheDuration(address token, uint256 duration) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setTokenRateCacheDurationCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub duration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`setTokenRateCacheDuration(address,
-    /// uint256)`](setTokenRateCacheDurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setTokenRateCacheDurationReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setTokenRateCacheDurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setTokenRateCacheDurationCall) -> Self {
-                    (value.token, value.duration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTokenRateCacheDurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        duration: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setTokenRateCacheDurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setTokenRateCacheDurationReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTokenRateCacheDurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setTokenRateCacheDurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setTokenRateCacheDurationCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = setTokenRateCacheDurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [244u8, 183u8, 150u8, 77u8];
-            const SIGNATURE: &'static str = "setTokenRateCacheDuration(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.duration,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setTokenRateCacheDurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `startAmplificationParameterUpdate(uint256,uint256)` and selector `0x2f1a0bc9`.
-    ```solidity
-    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct startAmplificationParameterUpdateCall {
-        #[allow(missing_docs)]
-        pub rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`startAmplificationParameterUpdate(uint256,
-    /// uint256)`](startAmplificationParameterUpdateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct startAmplificationParameterUpdateReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<startAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: startAmplificationParameterUpdateCall) -> Self {
-                    (value.rawEndValue, value.endTime)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        rawEndValue: tuple.0,
-                        endTime: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<startAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: startAmplificationParameterUpdateReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl startAmplificationParameterUpdateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for startAmplificationParameterUpdateCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = startAmplificationParameterUpdateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [47u8, 26u8, 11u8, 201u8];
-            const SIGNATURE: &'static str = "startAmplificationParameterUpdate(uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.rawEndValue,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.endTime,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                startAmplificationParameterUpdateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `stopAmplificationParameterUpdate()` and selector `0xeb0f24d6`.
-    ```solidity
-    function stopAmplificationParameterUpdate() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct stopAmplificationParameterUpdateCall;
-    ///Container type for the return parameters of the
-    /// [`stopAmplificationParameterUpdate()`](stopAmplificationParameterUpdateCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct stopAmplificationParameterUpdateReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<stopAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: stopAmplificationParameterUpdateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<stopAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: stopAmplificationParameterUpdateReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl stopAmplificationParameterUpdateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for stopAmplificationParameterUpdateCall {
-            type Parameters<'a> = ();
-            type Return = stopAmplificationParameterUpdateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [235u8, 15u8, 36u8, 214u8];
-            const SIGNATURE: &'static str = "stopAmplificationParameterUpdate()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                stopAmplificationParameterUpdateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `symbol()` and selector `0x95d89b41`.
-    ```solidity
-    function symbol() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`symbol()`](symbolCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for symbolCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
-            const SIGNATURE: &'static str = "symbol()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: symbolReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: symbolReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
-    ```solidity
-    function totalSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: totalSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: totalSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
-    ```solidity
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`transfer(address,uint256)`](transferCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferCall) -> Self {
-                    (value.recipient, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
-            const SIGNATURE: &'static str = "transfer(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: transferReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: transferReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
-    ```solidity
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferFromCall {
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferFromReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferFromCall) -> Self {
-                    (value.sender, value.recipient, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sender: tuple.0,
-                        recipient: tuple.1,
-                        amount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferFromReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferFromCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
-            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: transferFromReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: transferFromReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `unpause()` and selector `0x3f4ba83a`.
-    ```solidity
-    function unpause() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct unpauseCall;
-    ///Container type for the return parameters of the
-    /// [`unpause()`](unpauseCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct unpauseReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<unpauseCall> for UnderlyingRustTuple<'_> {
-                fn from(value: unpauseCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<unpauseReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: unpauseReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl unpauseReturn {
-            fn _tokenize(&self) -> <unpauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for unpauseCall {
-            type Parameters<'a> = ();
-            type Return = unpauseReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 75u8, 168u8, 58u8];
-            const SIGNATURE: &'static str = "unpause()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                unpauseReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `updateProtocolFeePercentageCache()` and selector `0x0da0669c`.
-    ```solidity
-    function updateProtocolFeePercentageCache() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct updateProtocolFeePercentageCacheCall;
-    ///Container type for the return parameters of the
-    /// [`updateProtocolFeePercentageCache()`](updateProtocolFeePercentageCacheCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct updateProtocolFeePercentageCacheReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<updateProtocolFeePercentageCacheCall> for UnderlyingRustTuple<'_> {
-                fn from(value: updateProtocolFeePercentageCacheCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateProtocolFeePercentageCacheCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<updateProtocolFeePercentageCacheReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: updateProtocolFeePercentageCacheReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateProtocolFeePercentageCacheReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl updateProtocolFeePercentageCacheReturn {
-            fn _tokenize(
-                &self,
-            ) -> <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for updateProtocolFeePercentageCacheCall {
-            type Parameters<'a> = ();
-            type Return = updateProtocolFeePercentageCacheReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [13u8, 160u8, 102u8, 156u8];
-            const SIGNATURE: &'static str = "updateProtocolFeePercentageCache()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                updateProtocolFeePercentageCacheReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `updateTokenRateCache(address)` and selector `0x2df2c7c0`.
-    ```solidity
-    function updateTokenRateCache(address token) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct updateTokenRateCacheCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`updateTokenRateCache(address)`](updateTokenRateCacheCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct updateTokenRateCacheReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<updateTokenRateCacheCall> for UnderlyingRustTuple<'_> {
-                fn from(value: updateTokenRateCacheCall) -> Self {
-                    (value.token,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateTokenRateCacheCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { token: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<updateTokenRateCacheReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: updateTokenRateCacheReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateTokenRateCacheReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl updateTokenRateCacheReturn {
-            fn _tokenize(
-                &self,
-            ) -> <updateTokenRateCacheCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for updateTokenRateCacheCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = updateTokenRateCacheReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 242u8, 199u8, 192u8];
-            const SIGNATURE: &'static str = "updateTokenRateCache(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                updateTokenRateCacheReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2ComposableStablePool`](self) function
-    /// calls.
-    #[derive(Clone)]
-    pub enum BalancerV2ComposableStablePoolCalls {
-        #[allow(missing_docs)]
-        DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall),
-        #[allow(missing_docs)]
-        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
-        #[allow(missing_docs)]
-        allowance(allowanceCall),
-        #[allow(missing_docs)]
-        approve(approveCall),
-        #[allow(missing_docs)]
-        balanceOf(balanceOfCall),
-        #[allow(missing_docs)]
-        decimals(decimalsCall),
-        #[allow(missing_docs)]
-        decreaseAllowance(decreaseAllowanceCall),
-        #[allow(missing_docs)]
-        disableRecoveryMode(disableRecoveryModeCall),
-        #[allow(missing_docs)]
-        enableRecoveryMode(enableRecoveryModeCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getActualSupply(getActualSupplyCall),
-        #[allow(missing_docs)]
-        getAmplificationParameter(getAmplificationParameterCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getBptIndex(getBptIndexCall),
-        #[allow(missing_docs)]
-        getDomainSeparator(getDomainSeparatorCall),
-        #[allow(missing_docs)]
-        getLastJoinExitData(getLastJoinExitDataCall),
-        #[allow(missing_docs)]
-        getMinimumBpt(getMinimumBptCall),
-        #[allow(missing_docs)]
-        getNextNonce(getNextNonceCall),
-        #[allow(missing_docs)]
-        getOwner(getOwnerCall),
-        #[allow(missing_docs)]
-        getPausedState(getPausedStateCall),
-        #[allow(missing_docs)]
-        getPoolId(getPoolIdCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentageCache(getProtocolFeePercentageCacheCall),
-        #[allow(missing_docs)]
-        getProtocolFeesCollector(getProtocolFeesCollectorCall),
-        #[allow(missing_docs)]
-        getProtocolSwapFeeDelegation(getProtocolSwapFeeDelegationCall),
-        #[allow(missing_docs)]
-        getRate(getRateCall),
-        #[allow(missing_docs)]
-        getRateProviders(getRateProvidersCall),
-        #[allow(missing_docs)]
-        getScalingFactors(getScalingFactorsCall),
-        #[allow(missing_docs)]
-        getSwapFeePercentage(getSwapFeePercentageCall),
-        #[allow(missing_docs)]
-        getTokenRate(getTokenRateCall),
-        #[allow(missing_docs)]
-        getTokenRateCache(getTokenRateCacheCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        inRecoveryMode(inRecoveryModeCall),
-        #[allow(missing_docs)]
-        increaseAllowance(increaseAllowanceCall),
-        #[allow(missing_docs)]
-        isTokenExemptFromYieldProtocolFee(isTokenExemptFromYieldProtocolFeeCall),
-        #[allow(missing_docs)]
-        name(nameCall),
-        #[allow(missing_docs)]
-        nonces(noncesCall),
-        #[allow(missing_docs)]
-        onExitPool(onExitPoolCall),
-        #[allow(missing_docs)]
-        onJoinPool(onJoinPoolCall),
-        #[allow(missing_docs)]
-        onSwap(onSwapCall),
-        #[allow(missing_docs)]
-        pause(pauseCall),
-        #[allow(missing_docs)]
-        permit(permitCall),
-        #[allow(missing_docs)]
-        queryExit(queryExitCall),
-        #[allow(missing_docs)]
-        queryJoin(queryJoinCall),
-        #[allow(missing_docs)]
-        setAssetManagerPoolConfig(setAssetManagerPoolConfigCall),
-        #[allow(missing_docs)]
-        setSwapFeePercentage(setSwapFeePercentageCall),
-        #[allow(missing_docs)]
-        setTokenRateCacheDuration(setTokenRateCacheDurationCall),
-        #[allow(missing_docs)]
-        startAmplificationParameterUpdate(startAmplificationParameterUpdateCall),
-        #[allow(missing_docs)]
-        stopAmplificationParameterUpdate(stopAmplificationParameterUpdateCall),
-        #[allow(missing_docs)]
-        symbol(symbolCall),
-        #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
-        transfer(transferCall),
-        #[allow(missing_docs)]
-        transferFrom(transferFromCall),
-        #[allow(missing_docs)]
-        unpause(unpauseCall),
-        #[allow(missing_docs)]
-        updateProtocolFeePercentageCache(updateProtocolFeePercentageCacheCall),
-        #[allow(missing_docs)]
-        updateTokenRateCache(updateTokenRateCacheCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2ComposableStablePoolCalls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [1u8, 236u8, 149u8, 74u8],
-            [4u8, 132u8, 45u8, 76u8],
-            [6u8, 253u8, 222u8, 3u8],
-            [9u8, 94u8, 167u8, 179u8],
-            [13u8, 160u8, 102u8, 156u8],
-            [21u8, 176u8, 1u8, 91u8],
-            [24u8, 22u8, 13u8, 221u8],
-            [28u8, 13u8, 224u8, 81u8],
-            [29u8, 215u8, 70u8, 234u8],
-            [35u8, 138u8, 45u8, 89u8],
-            [35u8, 184u8, 114u8, 221u8],
-            [45u8, 242u8, 199u8, 192u8],
-            [47u8, 26u8, 11u8, 201u8],
-            [49u8, 60u8, 229u8, 103u8],
-            [54u8, 68u8, 229u8, 21u8],
-            [56u8, 233u8, 146u8, 46u8],
-            [56u8, 255u8, 242u8, 208u8],
-            [57u8, 80u8, 147u8, 81u8],
-            [60u8, 151u8, 93u8, 81u8],
-            [63u8, 75u8, 168u8, 58u8],
-            [80u8, 221u8, 110u8, 217u8],
-            [84u8, 168u8, 68u8, 186u8],
-            [84u8, 222u8, 160u8, 10u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [85u8, 198u8, 118u8, 40u8],
-            [96u8, 40u8, 191u8, 212u8],
-            [103u8, 154u8, 239u8, 206u8],
-            [109u8, 172u8, 207u8, 250u8],
-            [112u8, 70u8, 64u8, 22u8],
-            [112u8, 160u8, 130u8, 49u8],
-            [116u8, 243u8, 176u8, 9u8],
-            [126u8, 206u8, 190u8, 0u8],
-            [127u8, 18u8, 96u8, 209u8],
-            [130u8, 104u8, 122u8, 86u8],
-            [132u8, 86u8, 203u8, 89u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [135u8, 111u8, 48u8, 59u8],
-            [135u8, 236u8, 104u8, 23u8],
-            [137u8, 61u8, 32u8, 232u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [144u8, 25u8, 59u8, 124u8],
-            [149u8, 216u8, 155u8, 65u8],
-            [164u8, 87u8, 194u8, 215u8],
-            [169u8, 5u8, 156u8, 187u8],
-            [170u8, 171u8, 173u8, 197u8],
-            [171u8, 119u8, 89u8, 241u8],
-            [179u8, 80u8, 86u8, 184u8],
-            [183u8, 184u8, 20u8, 252u8],
-            [210u8, 148u8, 108u8, 43u8],
-            [213u8, 5u8, 172u8, 207u8],
-            [213u8, 192u8, 150u8, 196u8],
-            [221u8, 98u8, 237u8, 62u8],
-            [221u8, 244u8, 98u8, 123u8],
-            [235u8, 15u8, 36u8, 214u8],
-            [237u8, 36u8, 145u8, 29u8],
-            [244u8, 183u8, 150u8, 77u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <onSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getMinimumBptCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getScalingFactorsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRateProvidersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <updateTokenRateCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getLastJoinExitDataCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <unpauseCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <enableRecoveryModeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTokenRateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmplificationParameterCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTokenRateCacheCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getBptIndexCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <pauseCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActualSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getNextNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <inRecoveryModeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableRecoveryModeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getDomainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(onSwap),
-            ::core::stringify!(getMinimumBpt),
-            ::core::stringify!(name),
-            ::core::stringify!(approve),
-            ::core::stringify!(updateProtocolFeePercentageCache),
-            ::core::stringify!(getProtocolSwapFeeDelegation),
-            ::core::stringify!(totalSupply),
-            ::core::stringify!(getPausedState),
-            ::core::stringify!(getScalingFactors),
-            ::core::stringify!(getRateProviders),
-            ::core::stringify!(transferFrom),
-            ::core::stringify!(updateTokenRateCache),
-            ::core::stringify!(startAmplificationParameterUpdate),
-            ::core::stringify!(decimals),
-            ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(setSwapFeePercentage),
-            ::core::stringify!(getPoolId),
-            ::core::stringify!(increaseAllowance),
-            ::core::stringify!(getLastJoinExitData),
-            ::core::stringify!(unpause),
-            ::core::stringify!(setAssetManagerPoolConfig),
-            ::core::stringify!(enableRecoveryMode),
-            ::core::stringify!(getTokenRate),
-            ::core::stringify!(version),
-            ::core::stringify!(getSwapFeePercentage),
-            ::core::stringify!(queryExit),
-            ::core::stringify!(getRate),
-            ::core::stringify!(getAmplificationParameter),
-            ::core::stringify!(getProtocolFeePercentageCache),
-            ::core::stringify!(balanceOf),
-            ::core::stringify!(onExitPool),
-            ::core::stringify!(nonces),
-            ::core::stringify!(getTokenRateCache),
-            ::core::stringify!(getBptIndex),
-            ::core::stringify!(pause),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getActualSupply),
-            ::core::stringify!(queryJoin),
-            ::core::stringify!(getOwner),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getNextNonce),
-            ::core::stringify!(symbol),
-            ::core::stringify!(decreaseAllowance),
-            ::core::stringify!(transfer),
-            ::core::stringify!(getAuthorizer),
-            ::core::stringify!(isTokenExemptFromYieldProtocolFee),
-            ::core::stringify!(inRecoveryMode),
-            ::core::stringify!(disableRecoveryMode),
-            ::core::stringify!(getProtocolFeesCollector),
-            ::core::stringify!(permit),
-            ::core::stringify!(onJoinPool),
-            ::core::stringify!(allowance),
-            ::core::stringify!(DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL),
-            ::core::stringify!(stopAmplificationParameterUpdate),
-            ::core::stringify!(getDomainSeparator),
-            ::core::stringify!(setTokenRateCacheDuration),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
-            }
-        }
-
-        /// Returns the enum variant name for the given selector, if known.
-        #[inline]
-        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
-            let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolCalls {
-        const COUNT: usize = 56usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "BalancerV2ComposableStablePoolCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(_) => {
-                    <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::DOMAIN_SEPARATOR(_) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseAllowance(_) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::disableRecoveryMode(_) => {
-                    <disableRecoveryModeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::enableRecoveryMode(_) => {
-                    <enableRecoveryModeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActualSupply(_) => {
-                    <getActualSupplyCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmplificationParameter(_) => {
-                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getBptIndex(_) => <getBptIndexCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getDomainSeparator(_) => {
-                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getLastJoinExitData(_) => {
-                    <getLastJoinExitDataCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getMinimumBpt(_) => <getMinimumBptCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getNextNonce(_) => <getNextNonceCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getPausedState(_) => {
-                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getProtocolFeePercentageCache(_) => {
-                    <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeesCollector(_) => {
-                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolSwapFeeDelegation(_) => {
-                    <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRateProviders(_) => {
-                    <getRateProvidersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getScalingFactors(_) => {
-                    <getScalingFactorsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getSwapFeePercentage(_) => {
-                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getTokenRate(_) => <getTokenRateCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getTokenRateCache(_) => {
-                    <getTokenRateCacheCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::inRecoveryMode(_) => {
-                    <inRecoveryModeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::increaseAllowance(_) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::isTokenExemptFromYieldProtocolFee(_) => {
-                    <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onSwap(_) => <onSwapCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setAssetManagerPoolConfig(_) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setSwapFeePercentage(_) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setTokenRateCacheDuration(_) => {
-                    <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::startAmplificationParameterUpdate(_) => {
-                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::stopAmplificationParameterUpdate(_) => {
-                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::updateProtocolFeePercentageCache(_) => {
-                    <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::updateTokenRateCache(_) => {
-                    <updateTokenRateCacheCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(
-                &[u8],
-            ) -> alloy_sol_types::Result<
-                BalancerV2ComposableStablePoolCalls,
-            >] = &[
-                {
-                    fn onSwap(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::onSwap)
-                    }
-                    onSwap
-                },
-                {
-                    fn getMinimumBpt(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getMinimumBptCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getMinimumBpt)
-                    }
-                    getMinimumBpt
-                },
-                {
-                    fn name(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::name)
-                    }
-                    name
-                },
-                {
-                    fn approve(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::approve)
-                    }
-                    approve
-                },
-                {
-                    fn updateProtocolFeePercentageCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::updateProtocolFeePercentageCache,
-                            )
-                    }
-                    updateProtocolFeePercentageCache
-                },
-                {
-                    fn getProtocolSwapFeeDelegation(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getProtocolSwapFeeDelegation,
-                            )
-                    }
-                    getProtocolSwapFeeDelegation
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
-                {
-                    fn getPausedState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getPausedState)
-                    }
-                    getPausedState
-                },
-                {
-                    fn getScalingFactors(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getScalingFactors)
-                    }
-                    getScalingFactors
-                },
-                {
-                    fn getRateProviders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getRateProvidersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getRateProviders)
-                    }
-                    getRateProviders
-                },
-                {
-                    fn transferFrom(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::transferFrom)
-                    }
-                    transferFrom
-                },
-                {
-                    fn updateTokenRateCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::updateTokenRateCache)
-                    }
-                    updateTokenRateCache
-                },
-                {
-                    fn startAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::startAmplificationParameterUpdate,
-                            )
-                    }
-                    startAmplificationParameterUpdate
-                },
-                {
-                    fn decimals(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::decimals)
-                    }
-                    decimals
-                },
-                {
-                    fn DOMAIN_SEPARATOR(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::DOMAIN_SEPARATOR)
-                    }
-                    DOMAIN_SEPARATOR
-                },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
-                {
-                    fn getPoolId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getPoolId)
-                    }
-                    getPoolId
-                },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
-                {
-                    fn getLastJoinExitData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getLastJoinExitData)
-                    }
-                    getLastJoinExitData
-                },
-                {
-                    fn unpause(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::unpause)
-                    }
-                    unpause
-                },
-                {
-                    fn setAssetManagerPoolConfig(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::setAssetManagerPoolConfig)
-                    }
-                    setAssetManagerPoolConfig
-                },
-                {
-                    fn enableRecoveryMode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::enableRecoveryMode)
-                    }
-                    enableRecoveryMode
-                },
-                {
-                    fn getTokenRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getTokenRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getTokenRate)
-                    }
-                    getTokenRate
-                },
-                {
-                    fn version(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::version)
-                    }
-                    version
-                },
-                {
-                    fn getSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getSwapFeePercentage)
-                    }
-                    getSwapFeePercentage
-                },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn getRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getRate)
-                    }
-                    getRate
-                },
-                {
-                    fn getAmplificationParameter(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getAmplificationParameter)
-                    }
-                    getAmplificationParameter
-                },
-                {
-                    fn getProtocolFeePercentageCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getProtocolFeePercentageCache,
-                            )
-                    }
-                    getProtocolFeePercentageCache
-                },
-                {
-                    fn balanceOf(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::balanceOf)
-                    }
-                    balanceOf
-                },
-                {
-                    fn onExitPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
-                {
-                    fn nonces(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::nonces)
-                    }
-                    nonces
-                },
-                {
-                    fn getTokenRateCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getTokenRateCache)
-                    }
-                    getTokenRateCache
-                },
-                {
-                    fn getBptIndex(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getBptIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getBptIndex)
-                    }
-                    getBptIndex
-                },
-                {
-                    fn pause(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::pause)
-                    }
-                    pause
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getActualSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getActualSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getActualSupply)
-                    }
-                    getActualSupply
-                },
-                {
-                    fn queryJoin(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn getOwner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getOwner)
-                    }
-                    getOwner
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getNextNonce(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getNextNonce)
-                    }
-                    getNextNonce
-                },
-                {
-                    fn symbol(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::symbol)
-                    }
-                    symbol
-                },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
-                {
-                    fn transfer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::transfer)
-                    }
-                    transfer
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
-                {
-                    fn isTokenExemptFromYieldProtocolFee(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::isTokenExemptFromYieldProtocolFee,
-                            )
-                    }
-                    isTokenExemptFromYieldProtocolFee
-                },
-                {
-                    fn inRecoveryMode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::inRecoveryMode)
-                    }
-                    inRecoveryMode
-                },
-                {
-                    fn disableRecoveryMode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::disableRecoveryMode)
-                    }
-                    disableRecoveryMode
-                },
-                {
-                    fn getProtocolFeesCollector(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getProtocolFeesCollector)
-                    }
-                    getProtocolFeesCollector
-                },
-                {
-                    fn permit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::permit)
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "params",
+        "type": "tuple",
+        "internalType": "struct ComposableStablePool.NewPoolParams",
+        "components": [
+          {
+            "name": "vault",
+            "type": "address",
+            "internalType": "contract IVault"
+          },
+          {
+            "name": "protocolFeeProvider",
+            "type": "address",
+            "internalType": "contract IProtocolFeePercentagesProvider"
+          },
+          {
+            "name": "name",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "symbol",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "tokens",
+            "type": "address[]",
+            "internalType": "contract IERC20[]"
+          },
+          {
+            "name": "rateProviders",
+            "type": "address[]",
+            "internalType": "contract IRateProvider[]"
+          },
+          {
+            "name": "tokenRateCacheDurations",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          },
+          {
+            "name": "exemptFromYieldProtocolFeeFlags",
+            "type": "bool[]",
+            "internalType": "bool[]"
+          },
+          {
+            "name": "amplificationParameter",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "swapFeePercentage",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "pauseWindowDuration",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "bufferPeriodDuration",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "owner",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "version",
+            "type": "string",
+            "internalType": "string"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAmplificationParameter",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "isUpdating",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "precision",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolId",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getScalingFactors",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getSwapFeePercentage",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "name",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "pause",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStarted",
+    "inputs": [
+      {
+        "name": "startValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "startTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStopped",
+    "inputs": [
+      {
+        "name": "currentValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProtocolFeePercentageCacheUpdated",
+    "inputs": [
+      {
+        "name": "feeType",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "protocolFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RecoveryModeStateChanged",
+    "inputs": [
+      {
+        "name": "enabled",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokenRateCacheUpdated",
+    "inputs": [
+      {
+        "name": "tokenIndex",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "rate",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokenRateProviderSet",
+    "inputs": [
+      {
+        "name": "tokenIndex",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "provider",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IRateProvider"
+      },
+      {
+        "name": "cacheDuration",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2ComposableStablePool {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AmpUpdateStarted(uint256,uint256,uint256,uint256)` and selector `0x1835882ee7a34ac194f717a35e09bb1d24c82a3b9d854ab6c9749525b714cdf2`.
+    ```solidity
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AmpUpdateStarted {
+        #[allow(missing_docs)]
+        pub startValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AmpUpdateStarted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStarted(uint256,uint256,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
+                    94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8,
+                    201u8, 116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    startValue: data.0,
+                    endValue: data.1,
+                    startTime: data.2,
+                    endTime: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endTime,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStarted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStarted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStarted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `AmpUpdateStopped(uint256)` and selector `0xa0d01593e47e69d07e0ccd87bece09411e07dd1ed40ca8f2e7af2976542a0233`.
+    ```solidity
+    event AmpUpdateStopped(uint256 currentValue);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct AmpUpdateStopped {
+        #[allow(missing_docs)]
+        pub currentValue: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for AmpUpdateStopped {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStopped(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8,
+                    135u8, 190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8,
+                    242u8, 231u8, 175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    currentValue: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.currentValue,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStopped {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStopped> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStopped) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
+    ```solidity
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ProtocolFeePercentageCacheUpdated(uint256,uint256)` and selector `0x6bfb689528fa96ec1ad670ad6d6064be1ae96bfd5d2ee35c837fd0fe0c11959a`.
+    ```solidity
+    event ProtocolFeePercentageCacheUpdated(uint256 indexed feeType, uint256 protocolFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ProtocolFeePercentageCacheUpdated {
+        #[allow(missing_docs)]
+        pub feeType: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub protocolFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ProtocolFeePercentageCacheUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ProtocolFeePercentageCacheUpdated(uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    107u8, 251u8, 104u8, 149u8, 40u8, 250u8, 150u8, 236u8, 26u8, 214u8, 112u8,
+                    173u8, 109u8, 96u8, 100u8, 190u8, 26u8, 233u8, 107u8, 253u8, 93u8, 46u8, 227u8,
+                    92u8, 131u8, 127u8, 208u8, 254u8, 12u8, 17u8, 149u8, 154u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    feeType: topics.1,
+                    protocolFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.protocolFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.feeType.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.feeType);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ProtocolFeePercentageCacheUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ProtocolFeePercentageCacheUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ProtocolFeePercentageCacheUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RecoveryModeStateChanged(bool)` and selector `0xeff3d4d215b42bf0960be9c6d5e05c22cba4df6627a3a523e2acee733b5854c8`.
+    ```solidity
+    event RecoveryModeStateChanged(bool enabled);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RecoveryModeStateChanged {
+        #[allow(missing_docs)]
+        pub enabled: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RecoveryModeStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RecoveryModeStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    239u8, 243u8, 212u8, 210u8, 21u8, 180u8, 43u8, 240u8, 150u8, 11u8, 233u8,
+                    198u8, 213u8, 224u8, 92u8, 34u8, 203u8, 164u8, 223u8, 102u8, 39u8, 163u8,
+                    165u8, 35u8, 226u8, 172u8, 238u8, 115u8, 59u8, 88u8, 84u8, 200u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { enabled: data.0 }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.enabled,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RecoveryModeStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&RecoveryModeStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RecoveryModeStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokenRateCacheUpdated(uint256,uint256)` and selector `0xb77a83204ca282e08dc3a65b0a1ca32ea4e6875c38ef0bf5bf75e52a67354fac`.
+    ```solidity
+    event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokenRateCacheUpdated {
+        #[allow(missing_docs)]
+        pub tokenIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub rate: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokenRateCacheUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokenRateCacheUpdated(uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    183u8, 122u8, 131u8, 32u8, 76u8, 162u8, 130u8, 224u8, 141u8, 195u8, 166u8,
+                    91u8, 10u8, 28u8, 163u8, 46u8, 164u8, 230u8, 135u8, 92u8, 56u8, 239u8, 11u8,
+                    245u8, 191u8, 117u8, 229u8, 42u8, 103u8, 53u8, 79u8, 172u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    tokenIndex: topics.1,
+                    rate: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.rate,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.tokenIndex.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenIndex);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokenRateCacheUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokenRateCacheUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokenRateCacheUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokenRateProviderSet(uint256,address,uint256)` and selector `0xdd6d1c9badb346de6925b358a472c937b41698d2632696759e43fd6527feeec4`.
+    ```solidity
+    event TokenRateProviderSet(uint256 indexed tokenIndex, address indexed provider, uint256 cacheDuration);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokenRateProviderSet {
+        #[allow(missing_docs)]
+        pub tokenIndex: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub provider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub cacheDuration: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokenRateProviderSet {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokenRateProviderSet(uint256,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 109u8, 28u8, 155u8, 173u8, 179u8, 70u8, 222u8, 105u8, 37u8, 179u8, 88u8,
+                    164u8, 114u8, 201u8, 55u8, 180u8, 22u8, 152u8, 210u8, 99u8, 38u8, 150u8, 117u8,
+                    158u8, 67u8, 253u8, 101u8, 39u8, 254u8, 238u8, 196u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    tokenIndex: topics.1,
+                    provider: topics.2,
+                    cacheDuration: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.cacheDuration,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.tokenIndex.clone(),
+                    self.provider.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.tokenIndex);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.provider,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokenRateProviderSet {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokenRateProviderSet> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokenRateProviderSet) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
+    ```solidity
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Transfer {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(ComposableStablePool.NewPoolParams params);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub params: <ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::RustType,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (ComposableStablePool::NewPoolParams,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> =
+                (<ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::RustType,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.params,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { params: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (ComposableStablePool::NewPoolParams,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <ComposableStablePool::NewPoolParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    ```solidity
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address owner, address spender) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
                     }
-                    permit
-                },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::onJoinPool)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
                     }
-                    onJoinPool
-                },
-                {
-                    fn allowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::allowance)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address account) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall {
+        #[allow(missing_docs)]
+        pub account: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { account: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getAmplificationParameter()` and selector `0x6daccffa`.
+    ```solidity
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmplificationParameterCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getAmplificationParameter()`](getAmplificationParameterCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getAmplificationParameterReturn {
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub isUpdating: bool,
+        #[allow(missing_docs)]
+        pub precision: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmplificationParameterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getAmplificationParameterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterReturn) -> Self {
+                    (value.value, value.isUpdating, value.precision)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        value: tuple.0,
+                        isUpdating: tuple.1,
+                        precision: tuple.2,
                     }
-                    allowance
-                },
-                {
-                    fn DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL,
-                            )
+                }
+            }
+        }
+        impl getAmplificationParameterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getAmplificationParameterCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isUpdating,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.precision,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getAmplificationParameterCall {
+            type Parameters<'a> = ();
+            type Return = getAmplificationParameterReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [109u8, 172u8, 207u8, 250u8];
+            const SIGNATURE: &'static str = "getAmplificationParameter()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getAmplificationParameterReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    ```solidity
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
                     }
-                    DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL
-                },
-                {
-                    fn stopAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::stopAmplificationParameterUpdate,
-                            )
+                }
+            }
+        }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getPausedStateReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    ```solidity
+    function getPoolId() external view returns (bytes32);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPoolId()`](getPoolIdCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getScalingFactors()` and selector `0x1dd746ea`.
+    ```solidity
+    function getScalingFactors() external view returns (uint256[] memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getScalingFactorsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getScalingFactors()`](getScalingFactorsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getScalingFactorsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getScalingFactorsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getScalingFactorsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getScalingFactorsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [29u8, 215u8, 70u8, 234u8];
+            const SIGNATURE: &'static str = "getScalingFactors()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getScalingFactorsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getScalingFactorsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    ```solidity
+    function getSwapFeePercentage() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `name()` and selector `0x06fdde03`.
+    ```solidity
+    function name() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    ```solidity
+    function nonces(address owner) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`nonces(address)`](noncesCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { owner: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `pause()` and selector `0x8456cb59`.
+    ```solidity
+    function pause() external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct pauseCall;
+    ///Container type for the return parameters of the [`pause()`](pauseCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct pauseReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<pauseCall> for UnderlyingRustTuple<'_> {
+                fn from(value: pauseCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<pauseReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: pauseReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl pauseReturn {
+            fn _tokenize(&self) -> <pauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for pauseCall {
+            type Parameters<'a> = ();
+            type Return = pauseReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [132u8, 86u8, 203u8, 89u8];
+            const SIGNATURE: &'static str = "pause()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                pauseReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    ```solidity
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
                     }
-                    stopAmplificationParameterUpdate
-                },
-                {
-                    fn getDomainSeparator(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getDomainSeparator)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                permitReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    ```solidity
+    function symbol() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct symbolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for symbolCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: symbolReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: symbolReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        recipient: tuple.0,
+                        amount: tuple.1,
                     }
-                    getDomainSeparator
-                },
-                {
-                    fn setTokenRateCacheDuration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::setTokenRateCacheDuration)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
                     }
-                    setTokenRateCacheDuration
-                },
-            ];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_SHIMS[idx](data)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `version()` and selector `0x54fd4d50`.
+    ```solidity
+    function version() external view returns (string memory);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`version()`](versionCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct versionReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: versionReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: versionReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`BalancerV2ComposableStablePool`](self) function
+    /// calls.
+    #[derive(Clone)]
+    pub enum BalancerV2ComposableStablePoolCalls {
+        #[allow(missing_docs)]
+        DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        getAmplificationParameter(getAmplificationParameterCall),
+        #[allow(missing_docs)]
+        getPausedState(getPausedStateCall),
+        #[allow(missing_docs)]
+        getPoolId(getPoolIdCall),
+        #[allow(missing_docs)]
+        getScalingFactors(getScalingFactorsCall),
+        #[allow(missing_docs)]
+        getSwapFeePercentage(getSwapFeePercentageCall),
+        #[allow(missing_docs)]
+        name(nameCall),
+        #[allow(missing_docs)]
+        nonces(noncesCall),
+        #[allow(missing_docs)]
+        pause(pauseCall),
+        #[allow(missing_docs)]
+        permit(permitCall),
+        #[allow(missing_docs)]
+        symbol(symbolCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+        #[allow(missing_docs)]
+        version(versionCall),
+    }
+    impl BalancerV2ComposableStablePoolCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [6u8, 253u8, 222u8, 3u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [28u8, 13u8, 224u8, 81u8],
+            [29u8, 215u8, 70u8, 234u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [54u8, 68u8, 229u8, 21u8],
+            [56u8, 255u8, 242u8, 208u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [85u8, 198u8, 118u8, 40u8],
+            [109u8, 172u8, 207u8, 250u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [126u8, 206u8, 190u8, 0u8],
+            [132u8, 86u8, 203u8, 89u8],
+            [149u8, 216u8, 155u8, 65u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [213u8, 5u8, 172u8, 207u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getScalingFactorsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <getAmplificationParameterCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <pauseCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(name),
+            ::core::stringify!(approve),
+            ::core::stringify!(getPausedState),
+            ::core::stringify!(getScalingFactors),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(DOMAIN_SEPARATOR),
+            ::core::stringify!(getPoolId),
+            ::core::stringify!(version),
+            ::core::stringify!(getSwapFeePercentage),
+            ::core::stringify!(getAmplificationParameter),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(nonces),
+            ::core::stringify!(pause),
+            ::core::stringify!(symbol),
+            ::core::stringify!(transfer),
+            ::core::stringify!(permit),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
         }
 
+        /// Returns the enum variant name for the given selector, if known.
         #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw_validate(
-            selector: [u8; 4],
-            data: &[u8],
-        ) -> alloy_sol_types::Result<Self> {
-            static DECODE_VALIDATE_SHIMS: &[fn(
-                &[u8],
-            ) -> alloy_sol_types::Result<
-                BalancerV2ComposableStablePoolCalls,
-            >] = &[
-                {
-                    fn onSwap(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::onSwap)
-                    }
-                    onSwap
-                },
-                {
-                    fn getMinimumBpt(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getMinimumBptCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getMinimumBpt)
-                    }
-                    getMinimumBpt
-                },
-                {
-                    fn name(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::name)
-                    }
-                    name
-                },
-                {
-                    fn approve(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::approve)
-                    }
-                    approve
-                },
-                {
-                    fn updateProtocolFeePercentageCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::updateProtocolFeePercentageCache,
-                            )
-                    }
-                    updateProtocolFeePercentageCache
-                },
-                {
-                    fn getProtocolSwapFeeDelegation(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getProtocolSwapFeeDelegation,
-                            )
-                    }
-                    getProtocolSwapFeeDelegation
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
-                {
-                    fn getPausedState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getPausedState)
-                    }
-                    getPausedState
-                },
-                {
-                    fn getScalingFactors(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2ComposableStablePoolCalls::getScalingFactors)
-                    }
-                    getScalingFactors
-                },
-                {
-                    fn getRateProviders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getRateProvidersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getRateProviders)
-                    }
-                    getRateProviders
-                },
-                {
-                    fn transferFrom(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::transferFrom)
-                    }
-                    transferFrom
-                },
-                {
-                    fn updateTokenRateCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::updateTokenRateCache,
-                            )
-                    }
-                    updateTokenRateCache
-                },
-                {
-                    fn startAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::startAmplificationParameterUpdate,
-                            )
-                    }
-                    startAmplificationParameterUpdate
-                },
-                {
-                    fn decimals(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::decimals)
-                    }
-                    decimals
-                },
-                {
-                    fn DOMAIN_SEPARATOR(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::DOMAIN_SEPARATOR)
-                    }
-                    DOMAIN_SEPARATOR
-                },
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolCalls {
+        const COUNT: usize = 18usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2ComposableStablePoolCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::DOMAIN_SEPARATOR(_) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getAmplificationParameter(_) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPausedState(_) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::getScalingFactors(_) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getSwapFeePercentage(_) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolCalls,
+            >] = &[
                 {
-                    fn setSwapFeePercentage(
+                    fn name(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::setSwapFeePercentage,
-                            )
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::name)
                     }
-                    setSwapFeePercentage
+                    name
                 },
                 {
-                    fn getPoolId(
+                    fn approve(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getPoolId)
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::approve)
                     }
-                    getPoolId
+                    approve
                 },
                 {
-                    fn increaseAllowance(
+                    fn getPausedState(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2ComposableStablePoolCalls::increaseAllowance)
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getPausedState)
                     }
-                    increaseAllowance
+                    getPausedState
                 },
                 {
-                    fn getLastJoinExitData(
+                    fn getScalingFactors(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getLastJoinExitData,
-                            )
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getScalingFactors)
                     }
-                    getLastJoinExitData
+                    getScalingFactors
                 },
                 {
-                    fn unpause(
+                    fn transferFrom(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::unpause)
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::transferFrom)
                     }
-                    unpause
+                    transferFrom
                 },
                 {
-                    fn setAssetManagerPoolConfig(
+                    fn decimals(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::setAssetManagerPoolConfig,
-                            )
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::decimals)
                     }
-                    setAssetManagerPoolConfig
+                    decimals
                 },
                 {
-                    fn enableRecoveryMode(
+                    fn DOMAIN_SEPARATOR(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2ComposableStablePoolCalls::enableRecoveryMode)
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::DOMAIN_SEPARATOR)
                     }
-                    enableRecoveryMode
+                    DOMAIN_SEPARATOR
                 },
                 {
-                    fn getTokenRate(
+                    fn getPoolId(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getTokenRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getTokenRate)
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getPoolId)
                     }
-                    getTokenRate
+                    getPoolId
                 },
                 {
                     fn version(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
                             .map(BalancerV2ComposableStablePoolCalls::version)
                     }
                     version
@@ -14156,370 +5585,309 @@ pub mod BalancerV2ComposableStablePool {
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getSwapFeePercentage,
-                            )
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getSwapFeePercentage)
                     }
                     getSwapFeePercentage
                 },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn getRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getRate)
-                    }
-                    getRate
-                },
                 {
                     fn getAmplificationParameter(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getAmplificationParameter,
-                            )
+                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::getAmplificationParameter)
                     }
                     getAmplificationParameter
                 },
-                {
-                    fn getProtocolFeePercentageCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::getProtocolFeePercentageCache,
-                            )
-                    }
-                    getProtocolFeePercentageCache
-                },
                 {
                     fn balanceOf(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
                             .map(BalancerV2ComposableStablePoolCalls::balanceOf)
                     }
                     balanceOf
                 },
-                {
-                    fn onExitPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
                 {
                     fn nonces(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
                             .map(BalancerV2ComposableStablePoolCalls::nonces)
                     }
                     nonces
                 },
                 {
-                    fn getTokenRateCache(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
-                    {
-                        <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2ComposableStablePoolCalls::getTokenRateCache)
-                    }
-                    getTokenRateCache
-                },
-                {
-                    fn getBptIndex(
+                    fn pause(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getBptIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getBptIndex)
+                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::pause)
                     }
-                    getBptIndex
+                    pause
                 },
                 {
-                    fn pause(
+                    fn symbol(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::pause)
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::symbol)
                     }
-                    pause
+                    symbol
                 },
                 {
-                    fn getActionId(
+                    fn transfer(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getActionId)
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::transfer)
                     }
-                    getActionId
+                    transfer
                 },
                 {
-                    fn getActualSupply(
+                    fn permit(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getActualSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::getActualSupply)
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::permit)
                     }
-                    getActualSupply
+                    permit
                 },
                 {
-                    fn queryJoin(
+                    fn allowance(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::queryJoin)
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2ComposableStablePoolCalls::allowance)
                     }
-                    queryJoin
+                    allowance
                 },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                BalancerV2ComposableStablePoolCalls,
+            >] = &[
                 {
-                    fn getOwner(
+                    fn name(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getOwner)
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::name)
                     }
-                    getOwner
+                    name
                 },
                 {
-                    fn getVault(
+                    fn approve(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::getVault)
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::approve)
                     }
-                    getVault
+                    approve
                 },
                 {
-                    fn getNextNonce(
+                    fn getPausedState(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
                             data,
                         )
-                        .map(BalancerV2ComposableStablePoolCalls::getNextNonce)
+                        .map(BalancerV2ComposableStablePoolCalls::getPausedState)
                     }
-                    getNextNonce
+                    getPausedState
                 },
                 {
-                    fn symbol(
+                    fn getScalingFactors(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::symbol)
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(BalancerV2ComposableStablePoolCalls::getScalingFactors)
                     }
-                    symbol
+                    getScalingFactors
                 },
                 {
-                    fn decreaseAllowance(
+                    fn transferFrom(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2ComposableStablePoolCalls::decreaseAllowance)
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2ComposableStablePoolCalls::transferFrom)
                     }
-                    decreaseAllowance
+                    transferFrom
                 },
                 {
-                    fn transfer(
+                    fn decimals(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::transfer)
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::decimals)
                     }
-                    transfer
+                    decimals
                 },
                 {
-                    fn getAuthorizer(
+                    fn DOMAIN_SEPARATOR(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
                             data,
                         )
-                        .map(BalancerV2ComposableStablePoolCalls::getAuthorizer)
+                        .map(BalancerV2ComposableStablePoolCalls::DOMAIN_SEPARATOR)
                     }
-                    getAuthorizer
+                    DOMAIN_SEPARATOR
                 },
                 {
-                    fn isTokenExemptFromYieldProtocolFee(
+                    fn getPoolId(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::isTokenExemptFromYieldProtocolFee,
-                            )
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::getPoolId)
                     }
-                    isTokenExemptFromYieldProtocolFee
+                    getPoolId
                 },
                 {
-                    fn inRecoveryMode(
+                    fn version(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolCalls::inRecoveryMode)
+                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::version)
                     }
-                    inRecoveryMode
+                    version
                 },
                 {
-                    fn disableRecoveryMode(
+                    fn getSwapFeePercentage(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
                                 data,
                             )
                             .map(
-                                BalancerV2ComposableStablePoolCalls::disableRecoveryMode,
+                                BalancerV2ComposableStablePoolCalls::getSwapFeePercentage,
                             )
                     }
-                    disableRecoveryMode
+                    getSwapFeePercentage
                 },
                 {
-                    fn getProtocolFeesCollector(
+                    fn getAmplificationParameter(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
                                 data,
                             )
                             .map(
-                                BalancerV2ComposableStablePoolCalls::getProtocolFeesCollector,
+                                BalancerV2ComposableStablePoolCalls::getAmplificationParameter,
                             )
                     }
-                    getProtocolFeesCollector
+                    getAmplificationParameter
                 },
                 {
-                    fn permit(
+                    fn balanceOf(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::permit)
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::balanceOf)
                     }
-                    permit
+                    balanceOf
                 },
                 {
-                    fn onJoinPool(
+                    fn nonces(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::onJoinPool)
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::nonces)
                     }
-                    onJoinPool
+                    nonces
                 },
                 {
-                    fn allowance(
+                    fn pause(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolCalls::allowance)
+                        <pauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::pause)
                     }
-                    allowance
+                    pause
                 },
                 {
-                    fn DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(
+                    fn symbol(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL,
-                            )
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::symbol)
                     }
-                    DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL
+                    symbol
                 },
                 {
-                    fn stopAmplificationParameterUpdate(
+                    fn transfer(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::stopAmplificationParameterUpdate,
-                            )
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::transfer)
                     }
-                    stopAmplificationParameterUpdate
+                    transfer
                 },
                 {
-                    fn getDomainSeparator(
+                    fn permit(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2ComposableStablePoolCalls::getDomainSeparator)
+                        <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::permit)
                     }
-                    getDomainSeparator
+                    permit
                 },
                 {
-                    fn setTokenRateCacheDuration(
+                    fn allowance(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolCalls>
                     {
-                        <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolCalls::setTokenRateCacheDuration,
-                            )
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2ComposableStablePoolCalls::allowance)
                     }
-                    setTokenRateCacheDuration
+                    allowance
                 },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
@@ -14534,15 +5902,8 @@ pub mod BalancerV2ComposableStablePool {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(inner) => {
-                    <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::DOMAIN_SEPARATOR(inner) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
@@ -14553,533 +5914,110 @@ pub mod BalancerV2ComposableStablePool {
                 Self::balanceOf(inner) => {
                     <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decimals(inner) => {
-                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::disableRecoveryMode(inner) => {
-                    <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::enableRecoveryMode(inner) => {
-                    <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getActualSupply(inner) => {
-                    <getActualSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmplificationParameter(inner) => {
-                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getBptIndex(inner) => {
-                    <getBptIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getDomainSeparator(inner) => {
-                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getLastJoinExitData(inner) => {
-                    <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getMinimumBpt(inner) => {
-                    <getMinimumBptCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getNextNonce(inner) => {
-                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getPausedState(inner) => {
-                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolId(inner) => {
-                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getProtocolFeePercentageCache(inner) => {
-                    <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeesCollector(inner) => {
-                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolSwapFeeDelegation(inner) => {
-                    <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getRateProviders(inner) => {
-                    <getRateProvidersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getScalingFactors(inner) => {
-                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getSwapFeePercentage(inner) => {
-                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTokenRate(inner) => {
-                    <getTokenRateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTokenRateCache(inner) => {
-                    <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::inRecoveryMode(inner) => {
-                    <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::isTokenExemptFromYieldProtocolFee(inner) => {
-                    <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::name(inner) => {
-                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::nonces(inner) => {
-                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onSwap(inner) => {
-                    <onSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::pause(inner) => {
-                    <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::permit(inner) => {
-                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setAssetManagerPoolConfig(inner) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setTokenRateCacheDuration(inner) => {
-                    <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::startAmplificationParameterUpdate(inner) => {
-                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::stopAmplificationParameterUpdate(inner) => {
-                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::symbol(inner) => {
-                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::transfer(inner) => {
-                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::transferFrom(inner) => {
-                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::unpause(inner) => {
-                    <unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::updateProtocolFeePercentageCache(inner) => {
-                    <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::updateTokenRateCache(inner) => {
-                    <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::version(inner) => {
-                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-            }
-        }
-
-        #[inline]
-        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-            match self {
-                Self::DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(inner) => {
-                    <DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::DOMAIN_SEPARATOR(inner) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::allowance(inner) => {
-                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::approve(inner) => {
-                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::balanceOf(inner) => {
-                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::decimals(inner) => {
-                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::disableRecoveryMode(inner) => {
-                    <disableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::enableRecoveryMode(inner) => {
-                    <enableRecoveryModeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getActualSupply(inner) => {
-                    <getActualSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmplificationParameter(inner) => {
-                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getBptIndex(inner) => {
-                    <getBptIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getDomainSeparator(inner) => {
-                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getLastJoinExitData(inner) => {
-                    <getLastJoinExitDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getMinimumBpt(inner) => {
-                    <getMinimumBptCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getNextNonce(inner) => {
-                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPausedState(inner) => {
-                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolId(inner) => {
-                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentageCache(inner) => {
-                    <getProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeesCollector(inner) => {
-                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getProtocolSwapFeeDelegation(inner) => {
-                    <getProtocolSwapFeeDelegationCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                Self::getAmplificationParameter(inner) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encoded_size(
                         inner,
-                        out,
                     )
                 }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getRateProviders(inner) => {
-                    <getRateProvidersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::getScalingFactors(inner) => {
-                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::getSwapFeePercentage(inner) => {
-                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getTokenRate(inner) => {
-                    <getTokenRateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getTokenRateCache(inner) => {
-                    <getTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::pause(inner) => {
+                    <pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::inRecoveryMode(inner) => {
-                    <inRecoveryModeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::symbol(inner) => {
+                    <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::isTokenExemptFromYieldProtocolFee(inner) => {
-                    <isTokenExemptFromYieldProtocolFeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::name(inner) => {
-                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::nonces(inner) => {
-                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                Self::version(inner) => {
+                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::DOMAIN_SEPARATOR(inner) => {
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onSwap(inner) => {
-                    <onSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::pause(inner) => {
-                    <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::permit(inner) => {
-                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                Self::getAmplificationParameter(inner) => {
+                    <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
                     )
                 }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::getPausedState(inner) => {
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::setAssetManagerPoolConfig(inner) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::getPoolId(inner) => {
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::getScalingFactors(inner) => {
+                    <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::setTokenRateCacheDuration(inner) => {
-                    <setTokenRateCacheDurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                Self::getSwapFeePercentage(inner) => {
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
                     )
                 }
-                Self::startAmplificationParameterUpdate(inner) => {
-                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::name(inner) => {
+                    <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::stopAmplificationParameterUpdate(inner) => {
-                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Self::nonces(inner) => {
+                    <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::pause(inner) => {
+                    <pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::permit(inner) => {
+                    <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::transfer(inner) => {
-                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::transferFrom(inner) => {
-                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::unpause(inner) => {
-                    <unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::updateProtocolFeePercentageCache(inner) => {
-                    <updateProtocolFeePercentageCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::updateTokenRateCache(inner) => {
-                    <updateTokenRateCacheCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
@@ -15495,15 +6433,6 @@ pub mod BalancerV2ComposableStablePool {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the
-        /// [`DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL`] function.
-        pub fn DELEGATE_PROTOCOL_SWAP_FEES_SENTINEL(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall, N>
-        {
-            self.call_builder(&DELEGATE_PROTOCOL_SWAP_FEES_SENTINELCall)
-        }
-
         ///Creates a new call builder for the [`DOMAIN_SEPARATOR`] function.
         pub fn DOMAIN_SEPARATOR(
             &self,
@@ -15542,44 +6471,6 @@ pub mod BalancerV2ComposableStablePool {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`decreaseAllowance`] function.
-        pub fn decreaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            amount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
-            self.call_builder(&decreaseAllowanceCall { spender, amount })
-        }
-
-        ///Creates a new call builder for the [`disableRecoveryMode`] function.
-        pub fn disableRecoveryMode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, disableRecoveryModeCall, N> {
-            self.call_builder(&disableRecoveryModeCall)
-        }
-
-        ///Creates a new call builder for the [`enableRecoveryMode`] function.
-        pub fn enableRecoveryMode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, enableRecoveryModeCall, N> {
-            self.call_builder(&enableRecoveryModeCall)
-        }
-
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getActualSupply`] function.
-        pub fn getActualSupply(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getActualSupplyCall, N> {
-            self.call_builder(&getActualSupplyCall)
-        }
-
         ///Creates a new call builder for the [`getAmplificationParameter`]
         /// function.
         pub fn getAmplificationParameter(
@@ -15588,48 +6479,6 @@ pub mod BalancerV2ComposableStablePool {
             self.call_builder(&getAmplificationParameterCall)
         }
 
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getBptIndex`] function.
-        pub fn getBptIndex(&self) -> alloy_contract::SolCallBuilder<&P, getBptIndexCall, N> {
-            self.call_builder(&getBptIndexCall)
-        }
-
-        ///Creates a new call builder for the [`getDomainSeparator`] function.
-        pub fn getDomainSeparator(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getDomainSeparatorCall, N> {
-            self.call_builder(&getDomainSeparatorCall)
-        }
-
-        ///Creates a new call builder for the [`getLastJoinExitData`] function.
-        pub fn getLastJoinExitData(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getLastJoinExitDataCall, N> {
-            self.call_builder(&getLastJoinExitDataCall)
-        }
-
-        ///Creates a new call builder for the [`getMinimumBpt`] function.
-        pub fn getMinimumBpt(&self) -> alloy_contract::SolCallBuilder<&P, getMinimumBptCall, N> {
-            self.call_builder(&getMinimumBptCall)
-        }
-
-        ///Creates a new call builder for the [`getNextNonce`] function.
-        pub fn getNextNonce(
-            &self,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, getNextNonceCall, N> {
-            self.call_builder(&getNextNonceCall { account })
-        }
-
-        ///Creates a new call builder for the [`getOwner`] function.
-        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
-            self.call_builder(&getOwnerCall)
-        }
-
         ///Creates a new call builder for the [`getPausedState`] function.
         pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
             self.call_builder(&getPausedStateCall)
@@ -15640,43 +6489,6 @@ pub mod BalancerV2ComposableStablePool {
             self.call_builder(&getPoolIdCall)
         }
 
-        ///Creates a new call builder for the [`getProtocolFeePercentageCache`]
-        /// function.
-        pub fn getProtocolFeePercentageCache(
-            &self,
-            feeType: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentageCacheCall, N> {
-            self.call_builder(&getProtocolFeePercentageCacheCall { feeType })
-        }
-
-        ///Creates a new call builder for the [`getProtocolFeesCollector`]
-        /// function.
-        pub fn getProtocolFeesCollector(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeesCollectorCall, N> {
-            self.call_builder(&getProtocolFeesCollectorCall)
-        }
-
-        ///Creates a new call builder for the [`getProtocolSwapFeeDelegation`]
-        /// function.
-        pub fn getProtocolSwapFeeDelegation(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolSwapFeeDelegationCall, N> {
-            self.call_builder(&getProtocolSwapFeeDelegationCall)
-        }
-
-        ///Creates a new call builder for the [`getRate`] function.
-        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
-            self.call_builder(&getRateCall)
-        }
-
-        ///Creates a new call builder for the [`getRateProviders`] function.
-        pub fn getRateProviders(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getRateProvidersCall, N> {
-            self.call_builder(&getRateProvidersCall)
-        }
-
         ///Creates a new call builder for the [`getScalingFactors`] function.
         pub fn getScalingFactors(
             &self,
@@ -15692,53 +6504,6 @@ pub mod BalancerV2ComposableStablePool {
             self.call_builder(&getSwapFeePercentageCall)
         }
 
-        ///Creates a new call builder for the [`getTokenRate`] function.
-        pub fn getTokenRate(
-            &self,
-            token: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, getTokenRateCall, N> {
-            self.call_builder(&getTokenRateCall { token })
-        }
-
-        ///Creates a new call builder for the [`getTokenRateCache`] function.
-        pub fn getTokenRateCache(
-            &self,
-            token: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, getTokenRateCacheCall, N> {
-            self.call_builder(&getTokenRateCacheCall { token })
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`inRecoveryMode`] function.
-        pub fn inRecoveryMode(&self) -> alloy_contract::SolCallBuilder<&P, inRecoveryModeCall, N> {
-            self.call_builder(&inRecoveryModeCall)
-        }
-
-        ///Creates a new call builder for the [`increaseAllowance`] function.
-        pub fn increaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            addedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
-            self.call_builder(&increaseAllowanceCall {
-                spender,
-                addedValue,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`isTokenExemptFromYieldProtocolFee`] function.
-        pub fn isTokenExemptFromYieldProtocolFee(
-            &self,
-            token: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isTokenExemptFromYieldProtocolFeeCall, N> {
-            self.call_builder(&isTokenExemptFromYieldProtocolFeeCall { token })
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -15752,72 +6517,6 @@ pub mod BalancerV2ComposableStablePool {
             self.call_builder(&noncesCall { owner })
         }
 
-        ///Creates a new call builder for the [`onExitPool`] function.
-        pub fn onExitPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
-            self.call_builder(&onExitPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onJoinPool`] function.
-        pub fn onJoinPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
-            self.call_builder(&onJoinPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onSwap`] function.
-        pub fn onSwap(
-            &self,
-            swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            indexIn: alloy_sol_types::private::primitives::aliases::U256,
-            indexOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, onSwapCall, N> {
-            self.call_builder(&onSwapCall {
-                swapRequest,
-                balances,
-                indexIn,
-                indexOut,
-            })
-        }
-
         ///Creates a new call builder for the [`pause`] function.
         pub fn pause(&self) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> {
             self.call_builder(&pauseCall)
@@ -15845,114 +6544,11 @@ pub mod BalancerV2ComposableStablePool {
             })
         }
 
-        ///Creates a new call builder for the [`queryExit`] function.
-        pub fn queryExit(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
-            self.call_builder(&queryExitCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryJoin`] function.
-        pub fn queryJoin(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
-            self.call_builder(&queryJoinCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`setAssetManagerPoolConfig`]
-        /// function.
-        pub fn setAssetManagerPoolConfig(
-            &self,
-            token: alloy_sol_types::private::Address,
-            poolConfig: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, setAssetManagerPoolConfigCall, N> {
-            self.call_builder(&setAssetManagerPoolConfigCall { token, poolConfig })
-        }
-
-        ///Creates a new call builder for the [`setSwapFeePercentage`]
-        /// function.
-        pub fn setSwapFeePercentage(
-            &self,
-            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
-            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
-        }
-
-        ///Creates a new call builder for the [`setTokenRateCacheDuration`]
-        /// function.
-        pub fn setTokenRateCacheDuration(
-            &self,
-            token: alloy_sol_types::private::Address,
-            duration: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, setTokenRateCacheDurationCall, N> {
-            self.call_builder(&setTokenRateCacheDurationCall { token, duration })
-        }
-
-        ///Creates a new call builder for the
-        /// [`startAmplificationParameterUpdate`] function.
-        pub fn startAmplificationParameterUpdate(
-            &self,
-            rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
-            endTime: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, startAmplificationParameterUpdateCall, N> {
-            self.call_builder(&startAmplificationParameterUpdateCall {
-                rawEndValue,
-                endTime,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`stopAmplificationParameterUpdate`] function.
-        pub fn stopAmplificationParameterUpdate(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, stopAmplificationParameterUpdateCall, N> {
-            self.call_builder(&stopAmplificationParameterUpdateCall)
-        }
-
         ///Creates a new call builder for the [`symbol`] function.
         pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
@@ -15976,28 +6572,6 @@ pub mod BalancerV2ComposableStablePool {
             })
         }
 
-        ///Creates a new call builder for the [`unpause`] function.
-        pub fn unpause(&self) -> alloy_contract::SolCallBuilder<&P, unpauseCall, N> {
-            self.call_builder(&unpauseCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`updateProtocolFeePercentageCache`] function.
-        pub fn updateProtocolFeePercentageCache(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, updateProtocolFeePercentageCacheCall, N> {
-            self.call_builder(&updateProtocolFeePercentageCacheCall)
-        }
-
-        ///Creates a new call builder for the [`updateTokenRateCache`]
-        /// function.
-        pub fn updateTokenRateCache(
-            &self,
-            token: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, updateTokenRateCacheCall, N> {
-            self.call_builder(&updateTokenRateCacheCall { token })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs
index 77caaadb81..37993f652e 100644
--- a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactory/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2ComposableStablePoolFactory {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -127,158 +117,6 @@ interface BalancerV2ComposableStablePoolFactory {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -1004,24 +842,21 @@ pub mod BalancerV2ComposableStablePoolFactory {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -1034,9 +869,9 @@ pub mod BalancerV2ComposableStablePoolFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1048,25 +883,25 @@ pub mod BalancerV2ComposableStablePoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1078,29 +913,29 @@ pub mod BalancerV2ComposableStablePoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1111,27 +946,19 @@ pub mod BalancerV2ComposableStablePoolFactory {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1143,1511 +970,59 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2ComposableStablePoolFactory`](self)
+    /// function calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2ComposableStablePoolFactoryCalls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2ComposableStablePoolFactoryCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 181u8, 159u8, 108u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2ComposableStablePoolFactory`](self)
-    /// function calls.
-    #[derive(Clone)]
-    pub enum BalancerV2ComposableStablePoolFactoryCalls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2ComposableStablePoolFactoryCalls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [102u8, 181u8, 159u8, 108u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(create),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2660,7 +1035,7 @@ pub mod BalancerV2ComposableStablePoolFactory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryCalls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryCalls";
 
@@ -2669,28 +1044,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2713,40 +1066,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryCalls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryCalls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryCalls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2757,16 +1076,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2777,16 +1086,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2797,60 +1096,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryCalls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2872,46 +1117,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryCalls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryCalls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryCalls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryCalls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2922,18 +1127,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryCalls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2944,20 +1137,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryCalls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2968,62 +1147,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryCalls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryCalls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3043,52 +1166,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3104,66 +1181,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3429,73 +1446,6 @@ pub mod BalancerV2ComposableStablePoolFactory {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs
index 1d100bd34e..7d75717db0 100644
--- a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv3/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2ComposableStablePoolFactoryV3 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -127,158 +117,6 @@ interface BalancerV2ComposableStablePoolFactoryV3 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -1004,24 +842,21 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -1034,9 +869,9 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1048,25 +883,25 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1078,29 +913,29 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1111,27 +946,19 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1143,1511 +970,59 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV3`](self)
+    /// function calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2ComposableStablePoolFactoryV3Calls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2ComposableStablePoolFactoryV3Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 181u8, 159u8, 108u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV3`](self)
-    /// function calls.
-    #[derive(Clone)]
-    pub enum BalancerV2ComposableStablePoolFactoryV3Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2ComposableStablePoolFactoryV3Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [102u8, 181u8, 159u8, 108u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(create),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2660,7 +1035,7 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV3Calls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV3Calls";
 
@@ -2669,28 +1044,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2713,40 +1066,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV3Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2757,16 +1076,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2777,16 +1086,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2797,60 +1096,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV3Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2872,46 +1117,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV3Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV3Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV3Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2922,18 +1127,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2944,20 +1137,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV3Calls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2968,62 +1147,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV3Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV3Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV3Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV3Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3043,52 +1166,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3104,66 +1181,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3429,73 +1446,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV3 {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs
index 41b335c50f..a563e1e24a 100644
--- a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv4/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2ComposableStablePoolFactoryV4 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -127,158 +117,6 @@ interface BalancerV2ComposableStablePoolFactoryV4 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -1004,24 +842,21 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -1034,9 +869,9 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1048,25 +883,25 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1078,29 +913,29 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1111,27 +946,19 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1143,1511 +970,59 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV4`](self)
+    /// function calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2ComposableStablePoolFactoryV4Calls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2ComposableStablePoolFactoryV4Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 181u8, 159u8, 108u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV4`](self)
-    /// function calls.
-    #[derive(Clone)]
-    pub enum BalancerV2ComposableStablePoolFactoryV4Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2ComposableStablePoolFactoryV4Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [102u8, 181u8, 159u8, 108u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(create),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2660,7 +1035,7 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV4Calls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV4Calls";
 
@@ -2669,28 +1044,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2713,40 +1066,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV4Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2757,16 +1076,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2777,16 +1086,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2797,60 +1096,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV4Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2872,46 +1117,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV4Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV4Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV4Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2922,18 +1127,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2944,20 +1137,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV4Calls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2968,62 +1147,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV4Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV4Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV4Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV4Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3043,52 +1166,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3104,66 +1181,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3429,73 +1446,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV4 {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs
index 21d7c8492f..8e2a913865 100644
--- a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv5/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2ComposableStablePoolFactoryV5 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -127,158 +117,6 @@ interface BalancerV2ComposableStablePoolFactoryV5 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -1004,24 +842,21 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -1034,9 +869,9 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1048,25 +883,25 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1078,29 +913,29 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1111,27 +946,19 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1143,1511 +970,59 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV5`](self)
+    /// function calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2ComposableStablePoolFactoryV5Calls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2ComposableStablePoolFactoryV5Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 181u8, 159u8, 108u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV5`](self)
-    /// function calls.
-    #[derive(Clone)]
-    pub enum BalancerV2ComposableStablePoolFactoryV5Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2ComposableStablePoolFactoryV5Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [102u8, 181u8, 159u8, 108u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(create),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2660,7 +1035,7 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV5Calls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV5Calls";
 
@@ -2669,28 +1044,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2713,40 +1066,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV5Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2757,16 +1076,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2777,16 +1086,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2797,60 +1096,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV5Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2872,46 +1117,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV5Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV5Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV5Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2922,18 +1127,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2944,20 +1137,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV5Calls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2968,62 +1147,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV5Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV5Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV5Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV5Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3043,52 +1166,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3104,66 +1181,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3429,73 +1446,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV5 {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs
index 8d19f3a9c5..6e0211989e 100644
--- a/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2composablestablepoolfactoryv6/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2ComposableStablePoolFactoryV6 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, address[] memory rateProviders, uint256[] memory tokenRateCacheDurations, bool[] memory exemptFromYieldProtocolFeeFlags, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -127,158 +117,6 @@ interface BalancerV2ComposableStablePoolFactoryV6 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -1004,24 +842,21 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -1034,9 +869,9 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1048,25 +883,25 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1078,29 +913,29 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1111,27 +946,19 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1143,1511 +970,59 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV6`](self)
+    /// function calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2ComposableStablePoolFactoryV6Calls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2ComposableStablePoolFactoryV6Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [102u8, 181u8, 159u8, 108u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2ComposableStablePoolFactoryV6`](self)
-    /// function calls.
-    #[derive(Clone)]
-    pub enum BalancerV2ComposableStablePoolFactoryV6Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2ComposableStablePoolFactoryV6Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [102u8, 181u8, 159u8, 108u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(create),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2660,7 +1035,7 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2ComposableStablePoolFactoryV6Calls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2ComposableStablePoolFactoryV6Calls";
 
@@ -2669,28 +1044,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2713,40 +1066,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV6Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2757,16 +1076,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2777,16 +1086,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2797,60 +1096,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV6Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2872,46 +1117,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
             ) -> alloy_sol_types::Result<
                 BalancerV2ComposableStablePoolFactoryV6Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV6Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV6Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2922,18 +1127,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2944,20 +1137,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV6Calls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2968,62 +1147,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                     }
                     create
                 },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2ComposableStablePoolFactoryV6Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2ComposableStablePoolFactoryV6Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2ComposableStablePoolFactoryV6Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2ComposableStablePoolFactoryV6Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3043,52 +1166,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3104,66 +1181,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3429,73 +1446,6 @@ pub mod BalancerV2ComposableStablePoolFactoryV6 {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs
index 5f44c0de7f..beb0609a43 100644
--- a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpool/src/lib.rs
@@ -6,862 +6,39 @@
     non_snake_case
 )]
 //! Auto-generated contract bindings. Do not edit.
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
-library IPoolSwapStructs {
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IPoolSwapStructs {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapRequest {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            IVault::SwapKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapRequest) -> Self {
-                (
-                    value.kind,
-                    value.tokenIn,
-                    value.tokenOut,
-                    value.amount,
-                    value.poolId,
-                    value.lastChangeBlock,
-                    value.from,
-                    value.to,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    kind: tuple.0,
-                    tokenIn: tuple.1,
-                    tokenOut: tuple.2,
-                    amount: tuple.3,
-                    poolId: tuple.4,
-                    lastChangeBlock: tuple.5,
-                    from: tuple.6,
-                    to: tuple.7,
-                    userData: tuple.8,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapRequest {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.from,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapRequest {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapRequest {
-            const NAME: &'static str = "SwapRequest";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
-                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
-                     userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.kind,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.lastChangeBlock,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.from,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.to,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapRequest {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenIn,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenOut,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.lastChangeBlock,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.from,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.to,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind, out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.lastChangeBlock,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.from,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.to,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IPoolSwapStructsInstance<P, N> {
-        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IPoolSwapStructs`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IPoolSwapStructs`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IPoolSwapStructsInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
+interface BalancerV2LiquidityBootstrappingPool {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event GradualWeightUpdateScheduled(uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights);
+    event PausedStateChanged(bool paused);
+    event SwapEnabledSet(bool swapEnabled);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
 
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner, bool swapEnabledOnStart);
 
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
-            IPoolSwapStructsInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library IVault {
-    type SwapKind is uint8;
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IVault {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapKind(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl SwapKind {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for SwapKind {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<SwapKind> for u8 {
-            fn from(value: SwapKind) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapKind {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapKind {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IVaultInstance<P, N> {
-        IVaultInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IVault`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IVault`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IVaultInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
-            IVaultInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IPoolSwapStructs {
-    struct SwapRequest {
-        IVault.SwapKind kind;
-        address tokenIn;
-        address tokenOut;
-        uint256 amount;
-        bytes32 poolId;
-        uint256 lastChangeBlock;
-        address from;
-        address to;
-        bytes userData;
-    }
-}
-
-library IVault {
-    type SwapKind is uint8;
-}
-
-interface BalancerV2LiquidityBootstrappingPool {
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    event GradualWeightUpdateScheduled(uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights);
-    event PausedStateChanged(bool paused);
-    event SwapEnabledSet(bool swapEnabled);
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner, bool swapEnabledOnStart);
-
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function allowance(address owner, address spender) external view returns (uint256);
-    function approve(address spender, uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-    function decimals() external view returns (uint8);
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getGradualWeightUpdateParams() external view returns (uint256 startTime, uint256 endTime, uint256[] memory endWeights);
-    function getInvariant() external view returns (uint256);
-    function getLastInvariant() external view returns (uint256);
-    function getNormalizedWeights() external view returns (uint256[] memory);
-    function getOwner() external view returns (address);
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    function getPoolId() external view returns (bytes32);
-    function getRate() external view returns (uint256);
-    function getScalingFactors() external view returns (uint256[] memory);
-    function getSwapEnabled() external view returns (bool);
-    function getSwapFeePercentage() external view returns (uint256);
-    function getVault() external view returns (address);
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    function name() external view returns (string memory);
-    function nonces(address owner) external view returns (uint256);
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external returns (uint256);
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
-    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
-    function setPaused(bool paused) external;
-    function setSwapEnabled(bool swapEnabled) external;
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-    function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-    function updateWeightsGradually(uint256 startTime, uint256 endTime, uint256[] memory endWeights) external;
-}
-```
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function getNormalizedWeights() external view returns (uint256[] memory);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getScalingFactors() external view returns (uint256[] memory);
+    function getSwapEnabled() external view returns (bool);
+    function getSwapFeePercentage() external view returns (uint256);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function symbol() external view returns (string memory);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
 
 ...which was generated by the following JSON ABI:
 ```json
@@ -1015,111 +192,6 @@ interface BalancerV2LiquidityBootstrappingPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "decreaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getGradualWeightUpdateParams",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "startTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "endWeights",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getInvariant",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getLastInvariant",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getNormalizedWeights",
@@ -1133,19 +205,6 @@ interface BalancerV2LiquidityBootstrappingPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getOwner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getPausedState",
@@ -1182,19 +241,6 @@ interface BalancerV2LiquidityBootstrappingPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getRate",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getScalingFactors",
@@ -1234,43 +280,6 @@ interface BalancerV2LiquidityBootstrappingPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "increaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "addedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "name",
@@ -1305,175 +314,100 @@ interface BalancerV2LiquidityBootstrappingPool {
   },
   {
     "type": "function",
-    "name": "onExitPool",
+    "name": "permit",
     "inputs": [
       {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
+        "name": "owner",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "recipient",
+        "name": "spender",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
+        "name": "value",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "protocolSwapFeePercentage",
+        "name": "deadline",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
       }
     ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
     "outputs": [
       {
         "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
+        "type": "string",
+        "internalType": "string"
       }
     ],
-    "stateMutability": "nonpayable"
+    "stateMutability": "view"
   },
   {
     "type": "function",
-    "name": "onJoinPool",
+    "name": "transfer",
     "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
       {
         "name": "recipient",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
+        "name": "amount",
         "type": "uint256",
         "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
       }
     ],
     "outputs": [
       {
         "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
+        "type": "bool",
+        "internalType": "bool"
       }
     ],
     "stateMutability": "nonpayable"
   },
   {
     "type": "function",
-    "name": "onSwap",
+    "name": "transferFrom",
     "inputs": [
       {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IPoolSwapStructs.SwapRequest",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "tokenOut",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "lastChangeBlock",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "from",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
       },
       {
-        "name": "balanceTokenIn",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
       },
       {
-        "name": "balanceTokenOut",
+        "name": "amount",
         "type": "uint256",
         "internalType": "uint256"
       }
@@ -1481,429 +415,119 @@ interface BalancerV2LiquidityBootstrappingPool {
     "outputs": [
       {
         "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
+        "type": "bool",
+        "internalType": "bool"
       }
     ],
     "stateMutability": "nonpayable"
   },
   {
-    "type": "function",
-    "name": "permit",
+    "type": "event",
+    "name": "Approval",
     "inputs": [
       {
         "name": "owner",
         "type": "address",
+        "indexed": true,
         "internalType": "address"
       },
       {
         "name": "spender",
         "type": "address",
+        "indexed": true,
         "internalType": "address"
       },
       {
         "name": "value",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
       }
     ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "queryExit",
+    "type": "event",
+    "name": "GradualWeightUpdateScheduled",
     "inputs": [
       {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
+        "name": "startTime",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       },
       {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptIn",
+        "name": "endTime",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       },
       {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryJoin",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
+        "name": "startWeights",
         "type": "uint256[]",
+        "indexed": false,
         "internalType": "uint256[]"
       },
       {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsIn",
+        "name": "endWeights",
         "type": "uint256[]",
+        "indexed": false,
         "internalType": "uint256[]"
       }
     ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setAssetManagerPoolConfig",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "poolConfig",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "setPaused",
+    "type": "event",
+    "name": "PausedStateChanged",
     "inputs": [
       {
         "name": "paused",
         "type": "bool",
+        "indexed": false,
         "internalType": "bool"
       }
     ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "setSwapEnabled",
+    "type": "event",
+    "name": "SwapEnabledSet",
     "inputs": [
       {
         "name": "swapEnabled",
         "type": "bool",
+        "indexed": false,
         "internalType": "bool"
       }
     ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "setSwapFeePercentage",
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
     "inputs": [
       {
         "name": "swapFeePercentage",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       }
     ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "symbol",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "transfer",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferFrom",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "updateWeightsGradually",
-    "inputs": [
-      {
-        "name": "startTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "endWeights",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
     "type": "event",
-    "name": "Approval",
+    "name": "Transfer",
     "inputs": [
       {
-        "name": "owner",
+        "name": "from",
         "type": "address",
         "indexed": true,
         "internalType": "address"
       },
       {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "GradualWeightUpdateScheduled",
-    "inputs": [
-      {
-        "name": "startTime",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "startWeights",
-        "type": "uint256[]",
-        "indexed": false,
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "endWeights",
-        "type": "uint256[]",
-        "indexed": false,
-        "internalType": "uint256[]"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PausedStateChanged",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SwapEnabledSet",
-    "inputs": [
-      {
-        "name": "swapEnabled",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SwapFeePercentageChanged",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Transfer",
-    "inputs": [
-      {
-        "name": "from",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "to",
+        "name": "to",
         "type": "address",
         "indexed": true,
         "internalType": "address"
@@ -1929,2972 +553,24 @@ interface BalancerV2LiquidityBootstrappingPool {
 pub mod BalancerV2LiquidityBootstrappingPool {
     use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
-    ```solidity
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Approval {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Approval {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
-                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
-                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    spender: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.spender.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Approval {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Approval> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `GradualWeightUpdateScheduled(uint256,uint256,uint256[],uint256[])` and selector `0x0f3631f9dab08169d1db21c6dc5f32536fb2b0a6b9bb5330d71c52132f968be0`.
-    ```solidity
-    event GradualWeightUpdateScheduled(uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct GradualWeightUpdateScheduled {
-        #[allow(missing_docs)]
-        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub startWeights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub endWeights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for GradualWeightUpdateScheduled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "GradualWeightUpdateScheduled(uint256,uint256,uint256[],uint256[])";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    15u8, 54u8, 49u8, 249u8, 218u8, 176u8, 129u8, 105u8, 209u8, 219u8, 33u8, 198u8,
-                    220u8, 95u8, 50u8, 83u8, 111u8, 178u8, 176u8, 166u8, 185u8, 187u8, 83u8, 48u8,
-                    215u8, 28u8, 82u8, 19u8, 47u8, 150u8, 139u8, 224u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    startTime: data.0,
-                    endTime: data.1,
-                    startWeights: data.2,
-                    endWeights: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.startWeights),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for GradualWeightUpdateScheduled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&GradualWeightUpdateScheduled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &GradualWeightUpdateScheduled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
-    ```solidity
-    event PausedStateChanged(bool paused);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PausedStateChanged {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PausedStateChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
-                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
-                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { paused: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SwapEnabledSet(bool)` and selector `0x5a9e84f78f7957cb4ed7478eb0fcad35ee4ecbe2e0f298420b28a3955392573f`.
-    ```solidity
-    event SwapEnabledSet(bool swapEnabled);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SwapEnabledSet {
-        #[allow(missing_docs)]
-        pub swapEnabled: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SwapEnabledSet {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SwapEnabledSet(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    90u8, 158u8, 132u8, 247u8, 143u8, 121u8, 87u8, 203u8, 78u8, 215u8, 71u8, 142u8,
-                    176u8, 252u8, 173u8, 53u8, 238u8, 78u8, 203u8, 226u8, 224u8, 242u8, 152u8,
-                    66u8, 11u8, 40u8, 163u8, 149u8, 83u8, 146u8, 87u8, 63u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    swapEnabled: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.swapEnabled,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SwapEnabledSet {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SwapEnabledSet> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SwapEnabledSet) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
-    ```solidity
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SwapFeePercentageChanged {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
-                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
-                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    swapFeePercentage: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
-    ```solidity
-    event Transfer(address indexed from, address indexed to, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Transfer {
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Transfer {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
-                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
-                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    from: topics.1,
-                    to: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.from.clone(),
-                    self.to.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.from,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.to,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Transfer {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Transfer> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner, bool swapEnabledOnStart);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub vault: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub name: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub symbol: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub normalizedWeights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub swapEnabledOnStart: bool,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (
-                        value.vault,
-                        value.name,
-                        value.symbol,
-                        value.tokens,
-                        value.normalizedWeights,
-                        value.swapFeePercentage,
-                        value.pauseWindowDuration,
-                        value.bufferPeriodDuration,
-                        value.owner,
-                        value.swapEnabledOnStart,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        vault: tuple.0,
-                        name: tuple.1,
-                        symbol: tuple.2,
-                        tokens: tuple.3,
-                        normalizedWeights: tuple.4,
-                        swapFeePercentage: tuple.5,
-                        pauseWindowDuration: tuple.6,
-                        bufferPeriodDuration: tuple.7,
-                        owner: tuple.8,
-                        swapEnabledOnStart: tuple.9,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.vault,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.name,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.symbol,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.swapEnabledOnStart,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
-    ```solidity
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
-            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DOMAIN_SEPARATORReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: DOMAIN_SEPARATORReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
-    ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: allowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: allowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
-    ```solidity
-    function approve(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approveReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: approveReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
-    ```solidity
-    function balanceOf(address account) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: balanceOfReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: balanceOfReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
-    ```solidity
-    function decimals() external view returns (uint8);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsReturn {
-        #[allow(missing_docs)]
-        pub _0: u8,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
-            type Parameters<'a> = ();
-            type Return = u8;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decimalsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decimalsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
-    ```solidity
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
-            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decreaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decreaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
-    ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getGradualWeightUpdateParams()` and selector `0x7beed220`.
-    ```solidity
-    function getGradualWeightUpdateParams() external view returns (uint256 startTime, uint256 endTime, uint256[] memory endWeights);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getGradualWeightUpdateParamsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getGradualWeightUpdateParams()`](getGradualWeightUpdateParamsCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getGradualWeightUpdateParamsReturn {
-        #[allow(missing_docs)]
-        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endWeights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getGradualWeightUpdateParamsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getGradualWeightUpdateParamsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getGradualWeightUpdateParamsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getGradualWeightUpdateParamsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getGradualWeightUpdateParamsReturn) -> Self {
-                    (value.startTime, value.endTime, value.endWeights)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getGradualWeightUpdateParamsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        startTime: tuple.0,
-                        endTime: tuple.1,
-                        endWeights: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getGradualWeightUpdateParamsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getGradualWeightUpdateParamsCall {
-            type Parameters<'a> = ();
-            type Return = getGradualWeightUpdateParamsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [123u8, 238u8, 210u8, 32u8];
-            const SIGNATURE: &'static str = "getGradualWeightUpdateParams()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getGradualWeightUpdateParamsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getInvariant()` and selector `0xc0ff1a15`.
-    ```solidity
-    function getInvariant() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getInvariantCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getInvariant()`](getInvariantCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getInvariantReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getInvariantCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getInvariantCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getInvariantReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getInvariantReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getInvariantCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [192u8, 255u8, 26u8, 21u8];
-            const SIGNATURE: &'static str = "getInvariant()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getInvariantReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getInvariantReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getLastInvariant()` and selector `0x9b02cdde`.
-    ```solidity
-    function getLastInvariant() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLastInvariantCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getLastInvariant()`](getLastInvariantCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLastInvariantReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLastInvariantCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getLastInvariantCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLastInvariantReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getLastInvariantReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getLastInvariantCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [155u8, 2u8, 205u8, 222u8];
-            const SIGNATURE: &'static str = "getLastInvariant()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getLastInvariantReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getLastInvariantReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getNormalizedWeights()` and selector `0xf89f27ed`.
-    ```solidity
-    function getNormalizedWeights() external view returns (uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNormalizedWeightsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getNormalizedWeights()`](getNormalizedWeightsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNormalizedWeightsReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNormalizedWeightsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getNormalizedWeightsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNormalizedWeightsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getNormalizedWeightsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getNormalizedWeightsCall {
-            type Parameters<'a> = ();
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [248u8, 159u8, 39u8, 237u8];
-            const SIGNATURE: &'static str = "getNormalizedWeights()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getNormalizedWeightsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getNormalizedWeightsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOwner()` and selector `0x893d20e8`.
-    ```solidity
-    function getOwner() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getOwner()`](getOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOwnerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
-            const SIGNATURE: &'static str = "getOwner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOwnerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOwnerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
-    ```solidity
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPausedState()`](getPausedStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateReturn {
-        #[allow(missing_docs)]
-        pub paused: bool,
-        #[allow(missing_docs)]
-        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateReturn) -> Self {
-                    (
-                        value.paused,
-                        value.pauseWindowEndTime,
-                        value.bufferPeriodEndTime,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paused: tuple.0,
-                        pauseWindowEndTime: tuple.1,
-                        bufferPeriodEndTime: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getPausedStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowEndTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodEndTime,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPausedStateCall {
-            type Parameters<'a> = ();
-            type Return = getPausedStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
-            const SIGNATURE: &'static str = "getPausedState()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPausedStateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
     ```solidity
-    function getPoolId() external view returns (bytes32);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolId()`](getPoolIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getPoolIdReturn {
+    pub struct Approval {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -4904,275 +580,255 @@ pub mod BalancerV2LiquidityBootstrappingPool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolIdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
-            const SIGNATURE: &'static str = "getPoolId()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolIdReturn = r.into();
-                        r._0
-                    },
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRate()` and selector `0x679aefce`.
-    ```solidity
-    function getRate() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRate()`](getRateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateReturn) -> Self {
-                    (value._0,)
-                }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `GradualWeightUpdateScheduled(uint256,uint256,uint256[],uint256[])` and selector `0x0f3631f9dab08169d1db21c6dc5f32536fb2b0a6b9bb5330d71c52132f968be0`.
+    ```solidity
+    event GradualWeightUpdateScheduled(uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct GradualWeightUpdateScheduled {
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub startWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub endWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRateCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for GradualWeightUpdateScheduled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
-            const SIGNATURE: &'static str = "getRate()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "GradualWeightUpdateScheduled(uint256,uint256,uint256[],uint256[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    15u8, 54u8, 49u8, 249u8, 218u8, 176u8, 129u8, 105u8, 209u8, 219u8, 33u8, 198u8,
+                    220u8, 95u8, 50u8, 83u8, 111u8, 178u8, 176u8, 166u8, 185u8, 187u8, 83u8, 48u8,
+                    215u8, 28u8, 82u8, 19u8, 47u8, 150u8, 139u8, 224u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    startTime: data.0,
+                    endTime: data.1,
+                    startWeights: data.2,
+                    endWeights: data.3,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.startWeights),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRateReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRateReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for GradualWeightUpdateScheduled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&GradualWeightUpdateScheduled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &GradualWeightUpdateScheduled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getScalingFactors()` and selector `0x1dd746ea`.
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
     ```solidity
-    function getScalingFactors() external view returns (uint256[] memory);
+    event PausedStateChanged(bool paused);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getScalingFactorsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getScalingFactors()`](getScalingFactorsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getScalingFactorsReturn {
+    pub struct PausedStateChanged {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub paused: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -5182,139 +838,103 @@ pub mod BalancerV2LiquidityBootstrappingPool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getScalingFactorsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getScalingFactorsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getScalingFactorsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getScalingFactorsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getScalingFactorsCall {
-            type Parameters<'a> = ();
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [29u8, 215u8, 70u8, 234u8];
-            const SIGNATURE: &'static str = "getScalingFactors()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
+            }
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getScalingFactorsReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getScalingFactorsReturn = r.into();
-                    r._0
-                })
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSwapEnabled()` and selector `0x47bc4d92`.
+    /**Event with signature `SwapEnabledSet(bool)` and selector `0x5a9e84f78f7957cb4ed7478eb0fcad35ee4ecbe2e0f298420b28a3955392573f`.
     ```solidity
-    function getSwapEnabled() external view returns (bool);
+    event SwapEnabledSet(bool swapEnabled);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapEnabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSwapEnabled()`](getSwapEnabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getSwapEnabledReturn {
+    pub struct SwapEnabledSet {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub swapEnabled: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -5324,132 +944,217 @@ pub mod BalancerV2LiquidityBootstrappingPool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapEnabledSet {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapEnabledSet(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    90u8, 158u8, 132u8, 247u8, 143u8, 121u8, 87u8, 203u8, 78u8, 215u8, 71u8, 142u8,
+                    176u8, 252u8, 173u8, 53u8, 238u8, 78u8, 203u8, 226u8, 224u8, 242u8, 152u8,
+                    66u8, 11u8, 40u8, 163u8, 149u8, 83u8, 146u8, 87u8, 63u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapEnabled: data.0,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapEnabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapEnabledCall) -> Self {
-                    ()
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapEnabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabled,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapEnabledSet {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapEnabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapEnabledReturn) -> Self {
-                    (value._0,)
-                }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapEnabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+        }
+        #[automatically_derived]
+        impl From<&SwapEnabledSet> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapEnabledSet) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
+    ```solidity
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SwapFeePercentageChanged {
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    swapFeePercentage: data.0,
                 }
             }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSwapEnabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [71u8, 188u8, 77u8, 146u8];
-            const SIGNATURE: &'static str = "getSwapEnabled()";
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSwapEnabledReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getSwapEnabledReturn = r.into();
-                    r._0
-                })
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
     ```solidity
-    function getSwapFeePercentage() external view returns (uint256);
+    event Transfer(address indexed from, address indexed to, uint256 value);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapFeePercentageCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getSwapFeePercentageReturn {
+    pub struct Transfer {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5459,181 +1164,165 @@ pub mod BalancerV2LiquidityBootstrappingPool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
-            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.value,
                     ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSwapFeePercentageReturn = r.into();
-                        r._0
-                    },
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getSwapFeePercentageReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    /**Constructor`.
     ```solidity
-    function getVault() external view returns (address);
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner, bool swapEnabledOnStart);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub normalizedWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub swapEnabledOnStart: bool,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                bool,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5645,30 +1334,57 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.normalizedWeights,
+                        value.swapFeePercentage,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                        value.owner,
+                        value.swapEnabledOnStart,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        vault: tuple.0,
+                        name: tuple.1,
+                        symbol: tuple.2,
+                        tokens: tuple.3,
+                        normalizedWeights: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        pauseWindowDuration: tuple.6,
+                        bufferPeriodDuration: tuple.7,
+                        owner: tuple.8,
+                        swapEnabledOnStart: tuple.9,
+                    }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -5678,57 +1394,57 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabledOnStart,
+                    ),
                 )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
     ```solidity
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct DOMAIN_SEPARATORCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseAllowanceReturn {
+    pub struct DOMAIN_SEPARATORReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -5741,15 +1457,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5761,28 +1471,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceCall) -> Self {
-                    (value.spender, value.addedValue)
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        addedValue: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5794,32 +1501,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceReturn) -> Self {
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
-            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
 
             #[inline]
             fn new<'a>(
@@ -5830,26 +1534,23 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.addedValue,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: increaseAllowanceReturn = r.into();
+                        let r: DOMAIN_SEPARATORReturn = r.into();
                         r._0
                     },
                 )
@@ -5861,28 +1562,33 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     data,
                 )
                 .map(|r| {
-                    let r: increaseAllowanceReturn = r.into();
+                    let r: DOMAIN_SEPARATORReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
-    function name() external view returns (string memory);
+    function allowance(address owner, address spender) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nameCall;
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nameReturn {
+    pub struct allowanceReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5895,9 +1601,15 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5909,25 +1621,28 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5939,29 +1654,32 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -5972,19 +1690,30 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: nameReturn = r.into();
+                        let r: allowanceReturn = r.into();
                         r._0
                     },
                 )
@@ -5996,31 +1725,33 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     data,
                 )
                 .map(|r| {
-                    let r: nameReturn = r.into();
+                    let r: allowanceReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
     ```solidity
-    function nonces(address owner) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct noncesCall {
+    pub struct approveCall {
         #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
+    /// [`approve(address,uint256)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct noncesReturn {
+    pub struct approveReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -6033,9 +1764,15 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6047,25 +1784,28 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6077,29 +1817,32 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -6112,25 +1855,24 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: noncesReturn = r.into();
+                        let r: approveReturn = r.into();
                         r._0
                     },
                 )
@@ -6142,47 +1884,31 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     data,
                 )
                 .map(|r| {
-                    let r: noncesReturn = r.into();
+                    let r: approveReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
     ```solidity
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function balanceOf(address account) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onExitPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct balanceOfCall {
         #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
+        pub account: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onExitPoolCall) function.
+    /// [`balanceOf(address)`](balanceOfCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onExitPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct balanceOfReturn {
         #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -6195,25 +1921,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6225,47 +1935,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self { account: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6277,56 +1965,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolReturn) -> Self {
-                    (value._0, value._1)
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl onExitPoolReturn {
-            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onExitPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onExitPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
-            const SIGNATURE: &'static str =
-                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
 
             #[inline]
             fn new<'a>(
@@ -6338,41 +1999,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
+                        &self.account,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onExitPoolReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6380,45 +2029,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    /**Function with signature `decimals()` and selector `0x313ce567`.
     ```solidity
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function decimals() external view returns (uint8);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onJoinPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct decimalsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onJoinPoolCall) function.
+    /// [`decimals()`](decimalsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onJoinPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct decimalsReturn {
         #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: u8,
     }
     #[allow(
         non_camel_case_types,
@@ -6431,25 +2064,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6461,47 +2078,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (u8,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6513,56 +2108,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolReturn) -> Self {
-                    (value._0, value._1)
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl onJoinPoolReturn {
-            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onJoinPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onJoinPoolReturn;
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
-            const SIGNATURE: &'static str =
-                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
 
             #[inline]
             fn new<'a>(
@@ -6573,42 +2141,22 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onJoinPoolReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6616,34 +2164,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256,uint256)` and selector `0x9d2c110c`.
+    /**Function with signature `getNormalizedWeights()` and selector `0xf89f27ed`.
     ```solidity
-    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external returns (uint256);
+    function getNormalizedWeights() external view returns (uint256[] memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwapCall {
-        #[allow(missing_docs)]
-        pub request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct getNormalizedWeightsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
-    /// bytes),uint256,uint256)`](onSwapCall) function.
+    /// [`getNormalizedWeights()`](getNormalizedWeightsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwapReturn {
+    pub struct getNormalizedWeightsReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
     }
     #[allow(
         non_camel_case_types,
@@ -6656,17 +2199,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6678,29 +2213,28 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwapCall) -> Self {
-                    (value.request, value.balanceTokenIn, value.balanceTokenOut)
+            impl ::core::convert::From<getNormalizedWeightsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        request: tuple.0,
-                        balanceTokenIn: tuple.1,
-                        balanceTokenOut: tuple.2,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6712,34 +2246,31 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwapReturn) -> Self {
+            impl ::core::convert::From<getNormalizedWeightsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onSwapCall {
-            type Parameters<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for getNormalizedWeightsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [157u8, 44u8, 17u8, 12u8];
-            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
-                                             uint256,address,address,bytes),uint256,uint256)";
+            const SELECTOR: [u8; 4] = [248u8, 159u8, 39u8, 237u8];
+            const SIGNATURE: &'static str = "getNormalizedWeights()";
 
             #[inline]
             fn new<'a>(
@@ -6750,33 +2281,21 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.balanceTokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.balanceTokenOut,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: onSwapReturn = r.into();
+                        let r: getNormalizedWeightsReturn = r.into();
                         r._0
                     },
                 )
@@ -6788,41 +2307,33 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     data,
                 )
                 .map(|r| {
-                    let r: onSwapReturn = r.into();
+                    let r: getNormalizedWeightsReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
     ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
         #[allow(missing_docs)]
-        pub v: u8,
+        pub paused: bool,
         #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
     }
-    ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6834,25 +2345,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6864,41 +2359,33 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6910,43 +2397,58 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
                 }
             }
         }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
             );
-            type Return = permitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
 
             #[inline]
             fn new<'a>(
@@ -6957,34 +2459,12 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
+                getPausedStateReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -7003,41 +2483,21 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
     ```solidity
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    function getPoolId() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryExitCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct getPoolIdCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryExitCall) function.
+    /// [`getPoolId()`](getPoolIdCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryExitReturn {
-        #[allow(missing_docs)]
-        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct getPoolIdReturn {
         #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -7050,25 +2510,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7080,47 +2524,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7132,56 +2554,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitReturn) -> Self {
-                    (value.bptIn, value.amountsOut)
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptIn: tuple.0,
-                        amountsOut: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl queryExitReturn {
-            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryExitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryExitReturn;
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
-            const SIGNATURE: &'static str =
-                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
 
             #[inline]
             fn new<'a>(
@@ -7192,42 +2587,26 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryExitReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7235,46 +2614,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    /**Function with signature `getScalingFactors()` and selector `0x1dd746ea`.
     ```solidity
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    function getScalingFactors() external view returns (uint256[] memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryJoinCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct getScalingFactorsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryJoinCall) function.
+    /// [`getScalingFactors()`](getScalingFactorsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryJoinReturn {
-        #[allow(missing_docs)]
-        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct getScalingFactorsReturn {
         #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
     }
     #[allow(
         non_camel_case_types,
@@ -7287,25 +2649,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7317,45 +2663,26 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<getScalingFactorsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
             );
             #[cfg(test)]
@@ -7369,56 +2696,31 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinReturn) -> Self {
-                    (value.bptOut, value.amountsIn)
+            impl ::core::convert::From<getScalingFactorsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getScalingFactorsReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getScalingFactorsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptOut: tuple.0,
-                        amountsIn: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl queryJoinReturn {
-            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryJoinCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryJoinReturn;
+        impl alloy_sol_types::SolCall for getScalingFactorsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
-            const SIGNATURE: &'static str =
-                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [29u8, 215u8, 70u8, 234u8];
+            const SIGNATURE: &'static str = "getScalingFactors()";
 
             #[inline]
             fn new<'a>(
@@ -7429,42 +2731,24 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryJoinReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getScalingFactorsReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7472,29 +2756,30 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getScalingFactorsReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setAssetManagerPoolConfig(address,bytes)` and selector `0x50dd6ed9`.
+    /**Function with signature `getSwapEnabled()` and selector `0x47bc4d92`.
     ```solidity
-    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    function getSwapEnabled() external view returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setAssetManagerPoolConfigCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub poolConfig: alloy_sol_types::private::Bytes,
-    }
+    pub struct getSwapEnabledCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setAssetManagerPoolConfig(address,
-    /// bytes)`](setAssetManagerPoolConfigCall) function.
+    /// [`getSwapEnabled()`](getSwapEnabledCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setAssetManagerPoolConfigReturn {}
+    pub struct getSwapEnabledReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7506,15 +2791,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7526,28 +2805,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setAssetManagerPoolConfigCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setAssetManagerPoolConfigCall) -> Self {
-                    (value.token, value.poolConfig)
+            impl ::core::convert::From<getSwapEnabledCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapEnabledCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapEnabledCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        poolConfig: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7559,40 +2835,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setAssetManagerPoolConfigReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setAssetManagerPoolConfigReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getSwapEnabledReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapEnabledReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapEnabledReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setAssetManagerPoolConfigReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setAssetManagerPoolConfigCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = setAssetManagerPoolConfigReturn;
+        impl alloy_sol_types::SolCall for getSwapEnabledCall {
+            type Parameters<'a> = ();
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [80u8, 221u8, 110u8, 217u8];
-            const SIGNATURE: &'static str = "setAssetManagerPoolConfig(address,bytes)";
+            const SELECTOR: [u8; 4] = [71u8, 188u8, 77u8, 146u8];
+            const SIGNATURE: &'static str = "getSwapEnabled()";
 
             #[inline]
             fn new<'a>(
@@ -7603,25 +2868,22 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.poolConfig,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setAssetManagerPoolConfigReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapEnabledReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7629,26 +2891,30 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getSwapEnabledReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
     ```solidity
-    function setPaused(bool paused) external;
+    function getSwapFeePercentage() external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedCall {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setPaused(bool)`](setPausedCall) function.
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedReturn {}
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7660,9 +2926,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7674,25 +2940,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedCall) -> Self {
-                    (value.paused,)
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { paused: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7704,34 +2970,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setPausedReturn {
-            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setPausedCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Return = setPausedReturn;
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
-            const SIGNATURE: &'static str = "setPaused(bool)";
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
 
             #[inline]
             fn new<'a>(
@@ -7742,22 +3003,26 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setPausedReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7765,26 +3030,30 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapEnabled(bool)` and selector `0xe01af92c`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function setSwapEnabled(bool swapEnabled) external;
+    function name() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapEnabledCall {
-        #[allow(missing_docs)]
-        pub swapEnabled: bool,
-    }
-    ///Container type for the return parameters of the
-    /// [`setSwapEnabled(bool)`](setSwapEnabledCall) function.
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapEnabledReturn {}
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7796,9 +3065,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7810,27 +3079,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapEnabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapEnabledCall) -> Self {
-                    (value.swapEnabled,)
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapEnabledCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapEnabled: tuple.0,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7842,36 +3109,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapEnabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapEnabledReturn) -> Self {
-                    ()
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapEnabledReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setSwapEnabledReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setSwapEnabledCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapEnabledCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Return = setSwapEnabledReturn;
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [224u8, 26u8, 249u8, 44u8];
-            const SIGNATURE: &'static str = "setSwapEnabled(bool)";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -7882,22 +3142,22 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.swapEnabled,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapEnabledReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7905,26 +3165,33 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeePercentageCall {
+    pub struct noncesCall {
         #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        pub owner: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeePercentageReturn {}
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7936,9 +3203,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7950,27 +3217,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageCall) -> Self {
-                    (value.swapFeePercentage,)
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapFeePercentage: tuple.0,
-                    }
+                    Self { owner: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7982,37 +3247,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageReturn) -> Self {
-                    ()
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setSwapFeePercentageReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = setSwapFeePercentageReturn;
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
-            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -8024,21 +3281,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapFeePercentageReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -8046,27 +3311,42 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function symbol() external view returns (string memory);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct symbolCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`symbol()`](symbolCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolReturn {
+    pub struct permitCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
     }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8078,9 +3358,25 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8092,25 +3388,41 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolCall) -> Self {
-                    ()
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8122,29 +3434,43 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for symbolCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
-            const SIGNATURE: &'static str = "symbol()";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -8155,22 +3481,40 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: symbolReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -8178,29 +3522,26 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: symbolReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
     ```solidity
-    function totalSupply() external view returns (uint256);
+    function symbol() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyCall;
+    pub struct symbolCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyReturn {
+    pub struct symbolReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -8227,14 +3568,14 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -8243,9 +3584,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8257,29 +3598,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
+        impl alloy_sol_types::SolCall for symbolCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
 
             #[inline]
             fn new<'a>(
@@ -8295,18 +3636,14 @@ pub mod BalancerV2LiquidityBootstrappingPool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: totalSupplyReturn = r.into();
+                        let r: symbolReturn = r.into();
                         r._0
                     },
                 )
@@ -8318,7 +3655,7 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     data,
                 )
                 .map(|r| {
-                    let r: totalSupplyReturn = r.into();
+                    let r: symbolReturn = r.into();
                     r._0
                 })
             }
@@ -8540,185 +3877,19 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferFromCall) -> Self {
-                    (value.sender, value.recipient, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sender: tuple.0,
-                        recipient: tuple.1,
-                        amount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferFromReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferFromCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
-            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: transferFromReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: transferFromReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `updateWeightsGradually(uint256,uint256,uint256[])` and selector `0x3e569205`.
-    ```solidity
-    function updateWeightsGradually(uint256 startTime, uint256 endTime, uint256[] memory endWeights) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct updateWeightsGraduallyCall {
-        #[allow(missing_docs)]
-        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endWeights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`updateWeightsGradually(uint256,uint256,
-    /// uint256[])`](updateWeightsGraduallyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct updateWeightsGraduallyReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<updateWeightsGraduallyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: updateWeightsGraduallyCall) -> Self {
-                    (value.startTime, value.endTime, value.endWeights)
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.sender, value.recipient, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateWeightsGraduallyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        startTime: tuple.0,
-                        endTime: tuple.1,
-                        endWeights: tuple.2,
+                        sender: tuple.0,
+                        recipient: tuple.1,
+                        amount: tuple.2,
                     }
                 }
             }
@@ -8726,9 +3897,9 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8740,41 +3911,33 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<updateWeightsGraduallyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: updateWeightsGraduallyReturn) -> Self {
-                    ()
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateWeightsGraduallyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl updateWeightsGraduallyReturn {
-            fn _tokenize(
-                &self,
-            ) -> <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for updateWeightsGraduallyCall {
+        impl alloy_sol_types::SolCall for transferFromCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
             );
-            type Return = updateWeightsGraduallyReturn;
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [62u8, 86u8, 146u8, 5u8];
-            const SIGNATURE: &'static str = "updateWeightsGradually(uint256,uint256,uint256[])";
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -8786,27 +3949,31 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.startTime),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.endTime),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.endWeights),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                updateWeightsGraduallyReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -8814,7 +3981,10 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
             }
         }
     };
@@ -8833,71 +4003,29 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         #[allow(missing_docs)]
         decimals(decimalsCall),
         #[allow(missing_docs)]
-        decreaseAllowance(decreaseAllowanceCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getGradualWeightUpdateParams(getGradualWeightUpdateParamsCall),
-        #[allow(missing_docs)]
-        getInvariant(getInvariantCall),
-        #[allow(missing_docs)]
-        getLastInvariant(getLastInvariantCall),
-        #[allow(missing_docs)]
         getNormalizedWeights(getNormalizedWeightsCall),
         #[allow(missing_docs)]
-        getOwner(getOwnerCall),
-        #[allow(missing_docs)]
         getPausedState(getPausedStateCall),
         #[allow(missing_docs)]
         getPoolId(getPoolIdCall),
         #[allow(missing_docs)]
-        getRate(getRateCall),
-        #[allow(missing_docs)]
         getScalingFactors(getScalingFactorsCall),
         #[allow(missing_docs)]
         getSwapEnabled(getSwapEnabledCall),
         #[allow(missing_docs)]
         getSwapFeePercentage(getSwapFeePercentageCall),
         #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        increaseAllowance(increaseAllowanceCall),
-        #[allow(missing_docs)]
         name(nameCall),
         #[allow(missing_docs)]
         nonces(noncesCall),
         #[allow(missing_docs)]
-        onExitPool(onExitPoolCall),
-        #[allow(missing_docs)]
-        onJoinPool(onJoinPoolCall),
-        #[allow(missing_docs)]
-        onSwap(onSwapCall),
-        #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        queryExit(queryExitCall),
-        #[allow(missing_docs)]
-        queryJoin(queryJoinCall),
-        #[allow(missing_docs)]
-        setAssetManagerPoolConfig(setAssetManagerPoolConfigCall),
-        #[allow(missing_docs)]
-        setPaused(setPausedCall),
-        #[allow(missing_docs)]
-        setSwapEnabled(setSwapEnabledCall),
-        #[allow(missing_docs)]
-        setSwapFeePercentage(setSwapFeePercentageCall),
-        #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
-        #[allow(missing_docs)]
-        updateWeightsGradually(updateWeightsGraduallyCall),
     }
     impl BalancerV2LiquidityBootstrappingPoolCalls {
         /// All the selectors of this enum.
@@ -8910,123 +4038,60 @@ pub mod BalancerV2LiquidityBootstrappingPool {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [22u8, 195u8, 139u8, 60u8],
-            [24u8, 22u8, 13u8, 221u8],
             [28u8, 13u8, 224u8, 81u8],
             [29u8, 215u8, 70u8, 234u8],
             [35u8, 184u8, 114u8, 221u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
-            [56u8, 233u8, 146u8, 46u8],
             [56u8, 255u8, 242u8, 208u8],
-            [57u8, 80u8, 147u8, 81u8],
-            [62u8, 86u8, 146u8, 5u8],
             [71u8, 188u8, 77u8, 146u8],
-            [80u8, 221u8, 110u8, 217u8],
             [85u8, 198u8, 118u8, 40u8],
-            [96u8, 40u8, 191u8, 212u8],
-            [103u8, 154u8, 239u8, 206u8],
             [112u8, 160u8, 130u8, 49u8],
-            [116u8, 243u8, 176u8, 9u8],
-            [123u8, 238u8, 210u8, 32u8],
             [126u8, 206u8, 190u8, 0u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [135u8, 236u8, 104u8, 23u8],
-            [137u8, 61u8, 32u8, 232u8],
-            [141u8, 146u8, 138u8, 248u8],
             [149u8, 216u8, 155u8, 65u8],
-            [155u8, 2u8, 205u8, 222u8],
-            [157u8, 44u8, 17u8, 12u8],
-            [164u8, 87u8, 194u8, 215u8],
             [169u8, 5u8, 156u8, 187u8],
-            [170u8, 171u8, 173u8, 197u8],
-            [192u8, 255u8, 26u8, 21u8],
             [213u8, 5u8, 172u8, 207u8],
-            [213u8, 192u8, 150u8, 196u8],
             [221u8, 98u8, 237u8, 62u8],
-            [224u8, 26u8, 249u8, 44u8],
             [248u8, 159u8, 39u8, 237u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getScalingFactorsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getSwapEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getLastInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(setPaused),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(getPausedState),
             ::core::stringify!(getScalingFactors),
             ::core::stringify!(transferFrom),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(setSwapFeePercentage),
             ::core::stringify!(getPoolId),
-            ::core::stringify!(increaseAllowance),
-            ::core::stringify!(updateWeightsGradually),
             ::core::stringify!(getSwapEnabled),
-            ::core::stringify!(setAssetManagerPoolConfig),
             ::core::stringify!(getSwapFeePercentage),
-            ::core::stringify!(queryExit),
-            ::core::stringify!(getRate),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(onExitPool),
-            ::core::stringify!(getGradualWeightUpdateParams),
             ::core::stringify!(nonces),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(queryJoin),
-            ::core::stringify!(getOwner),
-            ::core::stringify!(getVault),
             ::core::stringify!(symbol),
-            ::core::stringify!(getLastInvariant),
-            ::core::stringify!(onSwap),
-            ::core::stringify!(decreaseAllowance),
             ::core::stringify!(transfer),
-            ::core::stringify!(getAuthorizer),
-            ::core::stringify!(getInvariant),
             ::core::stringify!(permit),
-            ::core::stringify!(onJoinPool),
             ::core::stringify!(allowance),
-            ::core::stringify!(setSwapEnabled),
             ::core::stringify!(getNormalizedWeights),
         ];
 
@@ -9052,7 +4117,7 @@ pub mod BalancerV2LiquidityBootstrappingPool {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2LiquidityBootstrappingPoolCalls {
-        const COUNT: usize = 38usize;
+        const COUNT: usize = 17usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2LiquidityBootstrappingPoolCalls";
 
@@ -9066,27 +4131,13 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseAllowance(_) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getGradualWeightUpdateParams(_) => {
-                    <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getInvariant(_) => <getInvariantCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getLastInvariant(_) => {
-                    <getLastInvariantCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::getNormalizedWeights(_) => {
                     <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getPausedState(_) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getScalingFactors(_) => {
                     <getScalingFactorsCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -9096,35 +4147,12 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 Self::getSwapFeePercentage(_) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::increaseAllowance(_) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onSwap(_) => <onSwapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setAssetManagerPoolConfig(_) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setSwapEnabled(_) => {
-                    <setSwapEnabledCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setSwapFeePercentage(_) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::updateWeightsGradually(_) => {
-                    <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -9147,342 +4175,144 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 BalancerV2LiquidityBootstrappingPoolCalls,
             >] = &[
                 {
-                    fn name(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::name)
-                    }
-                    name
-                },
-                {
-                    fn approve(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::approve)
-                    }
-                    approve
-                },
-                {
-                    fn setPaused(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
-                {
-                    fn getPausedState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPausedState)
-                    }
-                    getPausedState
-                },
-                {
-                    fn getScalingFactors(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getScalingFactors)
-                    }
-                    getScalingFactors
-                },
-                {
-                    fn transferFrom(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transferFrom)
-                    }
-                    transferFrom
-                },
-                {
-                    fn decimals(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decimals)
-                    }
-                    decimals
-                },
-                {
-                    fn DOMAIN_SEPARATOR(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::DOMAIN_SEPARATOR)
-                    }
-                    DOMAIN_SEPARATOR
-                },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
-                {
-                    fn getPoolId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPoolId)
-                    }
-                    getPoolId
-                },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
-                {
-                    fn updateWeightsGradually(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::updateWeightsGradually)
-                    }
-                    updateWeightsGradually
-                },
-                {
-                    fn getSwapEnabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapEnabled)
-                    }
-                    getSwapEnabled
-                },
-                {
-                    fn setAssetManagerPoolConfig(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::setAssetManagerPoolConfig)
-                    }
-                    setAssetManagerPoolConfig
-                },
-                {
-                    fn getSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapFeePercentage)
-                    }
-                    getSwapFeePercentage
-                },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn getRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getRate)
-                    }
-                    getRate
-                },
-                {
-                    fn balanceOf(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::balanceOf)
-                    }
-                    balanceOf
-                },
-                {
-                    fn onExitPool(
+                    fn name(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onExitPool)
+                        <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::name)
                     }
-                    onExitPool
+                    name
                 },
                 {
-                    fn getGradualWeightUpdateParams(
+                    fn approve(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::getGradualWeightUpdateParams,
-                            )
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::approve)
                     }
-                    getGradualWeightUpdateParams
+                    approve
                 },
                 {
-                    fn nonces(
+                    fn getPausedState(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::nonces)
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPausedState)
                     }
-                    nonces
+                    getPausedState
                 },
                 {
-                    fn getActionId(
+                    fn getScalingFactors(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getActionId)
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getScalingFactors)
                     }
-                    getActionId
+                    getScalingFactors
                 },
                 {
-                    fn queryJoin(
+                    fn transferFrom(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryJoin)
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transferFrom)
                     }
-                    queryJoin
+                    transferFrom
                 },
                 {
-                    fn getOwner(
+                    fn decimals(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getOwner)
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decimals)
                     }
-                    getOwner
+                    decimals
                 },
                 {
-                    fn getVault(
+                    fn DOMAIN_SEPARATOR(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getVault)
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::DOMAIN_SEPARATOR)
                     }
-                    getVault
+                    DOMAIN_SEPARATOR
                 },
                 {
-                    fn symbol(
+                    fn getPoolId(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::symbol)
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPoolId)
                     }
-                    symbol
+                    getPoolId
                 },
                 {
-                    fn getLastInvariant(
+                    fn getSwapEnabled(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getLastInvariant)
+                        <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapEnabled)
                     }
-                    getLastInvariant
+                    getSwapEnabled
                 },
                 {
-                    fn onSwap(
+                    fn getSwapFeePercentage(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onSwap)
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapFeePercentage)
                     }
-                    onSwap
+                    getSwapFeePercentage
                 },
                 {
-                    fn decreaseAllowance(
+                    fn balanceOf(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decreaseAllowance)
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::balanceOf)
                     }
-                    decreaseAllowance
+                    balanceOf
                 },
                 {
-                    fn transfer(
+                    fn nonces(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transfer)
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::nonces)
                     }
-                    transfer
+                    nonces
                 },
                 {
-                    fn getAuthorizer(
+                    fn symbol(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getAuthorizer)
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::symbol)
                     }
-                    getAuthorizer
+                    symbol
                 },
                 {
-                    fn getInvariant(
+                    fn transfer(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getInvariant)
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::transfer)
                     }
-                    getInvariant
+                    transfer
                 },
                 {
                     fn permit(
@@ -9494,16 +4324,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
                 {
                     fn allowance(
                         data: &[u8],
@@ -9514,16 +4334,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     }
                     allowance
                 },
-                {
-                    fn setSwapEnabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setSwapEnabled)
-                    }
-                    setSwapEnabled
-                },
                 {
                     fn getNormalizedWeights(
                         data: &[u8],
@@ -9561,341 +4371,145 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
                         <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::name)
-                    }
-                    name
-                },
-                {
-                    fn approve(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::approve)
-                    }
-                    approve
-                },
-                {
-                    fn setPaused(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
-                {
-                    fn getPausedState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getPausedState)
-                    }
-                    getPausedState
-                },
-                {
-                    fn getScalingFactors(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::getScalingFactors,
-                            )
-                    }
-                    getScalingFactors
-                },
-                {
-                    fn transferFrom(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::transferFrom)
-                    }
-                    transferFrom
-                },
-                {
-                    fn decimals(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decimals)
-                    }
-                    decimals
-                },
-                {
-                    fn DOMAIN_SEPARATOR(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::DOMAIN_SEPARATOR)
-                    }
-                    DOMAIN_SEPARATOR
-                },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::setSwapFeePercentage,
-                            )
-                    }
-                    setSwapFeePercentage
-                },
-                {
-                    fn getPoolId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPoolId)
-                    }
-                    getPoolId
-                },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::increaseAllowance,
-                            )
-                    }
-                    increaseAllowance
-                },
-                {
-                    fn updateWeightsGradually(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::updateWeightsGradually,
-                            )
-                    }
-                    updateWeightsGradually
-                },
-                {
-                    fn getSwapEnabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapEnabled)
-                    }
-                    getSwapEnabled
-                },
-                {
-                    fn setAssetManagerPoolConfig(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::setAssetManagerPoolConfig,
-                            )
-                    }
-                    setAssetManagerPoolConfig
-                },
-                {
-                    fn getSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::getSwapFeePercentage,
-                            )
-                    }
-                    getSwapFeePercentage
-                },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn getRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getRate)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::name)
                     }
-                    getRate
+                    name
                 },
                 {
-                    fn balanceOf(
+                    fn approve(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::balanceOf)
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::approve)
                     }
-                    balanceOf
+                    approve
                 },
                 {
-                    fn onExitPool(
+                    fn getPausedState(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onExitPool)
+                        <getPausedStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getPausedState)
                     }
-                    onExitPool
+                    getPausedState
                 },
                 {
-                    fn getGradualWeightUpdateParams(
+                    fn getScalingFactors(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                        <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
                                 data,
                             )
                             .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::getGradualWeightUpdateParams,
+                                BalancerV2LiquidityBootstrappingPoolCalls::getScalingFactors,
                             )
                     }
-                    getGradualWeightUpdateParams
+                    getScalingFactors
                 },
                 {
-                    fn nonces(
+                    fn transferFrom(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::nonces)
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::transferFrom)
                     }
-                    nonces
+                    transferFrom
                 },
                 {
-                    fn getActionId(
+                    fn decimals(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getActionId)
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::decimals)
                     }
-                    getActionId
+                    decimals
                 },
                 {
-                    fn queryJoin(
+                    fn DOMAIN_SEPARATOR(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::queryJoin)
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::DOMAIN_SEPARATOR)
                     }
-                    queryJoin
+                    DOMAIN_SEPARATOR
                 },
                 {
-                    fn getOwner(
+                    fn getPoolId(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getOwner)
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getPoolId)
                     }
-                    getOwner
+                    getPoolId
                 },
                 {
-                    fn getVault(
+                    fn getSwapEnabled(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::getVault)
+                        <getSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getSwapEnabled)
                     }
-                    getVault
+                    getSwapEnabled
                 },
                 {
-                    fn symbol(
+                    fn getSwapFeePercentage(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::symbol)
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(
+                                BalancerV2LiquidityBootstrappingPoolCalls::getSwapFeePercentage,
+                            )
                     }
-                    symbol
+                    getSwapFeePercentage
                 },
                 {
-                    fn getLastInvariant(
+                    fn balanceOf(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getLastInvariant)
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::balanceOf)
                     }
-                    getLastInvariant
+                    balanceOf
                 },
                 {
-                    fn onSwap(
+                    fn nonces(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onSwap)
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::nonces)
                     }
-                    onSwap
+                    nonces
                 },
                 {
-                    fn decreaseAllowance(
+                    fn symbol(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
                     {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolCalls::decreaseAllowance,
-                            )
+                        <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(BalancerV2LiquidityBootstrappingPoolCalls::symbol)
                     }
-                    decreaseAllowance
+                    symbol
                 },
                 {
                     fn transfer(
@@ -9907,30 +4521,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
-                {
-                    fn getInvariant(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::getInvariant)
-                    }
-                    getInvariant
-                },
                 {
                     fn permit(
                         data: &[u8],
@@ -9941,16 +4531,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
                 {
                     fn allowance(
                         data: &[u8],
@@ -9961,18 +4541,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                     }
                     allowance
                 },
-                {
-                    fn setSwapEnabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolCalls>
-                    {
-                        <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolCalls::setSwapEnabled)
-                    }
-                    setSwapEnabled
-                },
                 {
                     fn getNormalizedWeights(
                         data: &[u8],
@@ -10015,41 +4583,15 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getGradualWeightUpdateParams(inner) => {
-                    <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getInvariant(inner) => {
-                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getLastInvariant(inner) => {
-                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getNormalizedWeights(inner) => {
                     <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::getPoolId(inner) => {
                     <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getScalingFactors(inner) => {
                     <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -10059,67 +4601,24 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 Self::getSwapFeePercentage(inner) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onSwap(inner) => {
-                    <onSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setAssetManagerPoolConfig(inner) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setSwapEnabled(inner) => {
-                    <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::transferFrom(inner) => {
                     <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::updateWeightsGradually(inner) => {
-                    <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
             }
         }
 
@@ -10141,43 +4640,17 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getGradualWeightUpdateParams(inner) => {
-                    <getGradualWeightUpdateParamsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getInvariant(inner) => {
-                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getLastInvariant(inner) => {
-                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getNormalizedWeights(inner) => {
                     <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encode_raw(
                         inner, out,
                     )
                 }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::getPoolId(inner) => {
                     <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getScalingFactors(inner) => {
                     <getScalingFactorsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -10189,69 +4662,24 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                         inner, out,
                     )
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::onSwap(inner) => {
-                    <onSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setAssetManagerPoolConfig(inner) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setSwapEnabled(inner) => {
-                    <setSwapEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::transferFrom(inner) => {
                     <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::updateWeightsGradually(inner) => {
-                    <updateWeightsGraduallyCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
             }
         }
     }
@@ -10595,48 +5023,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`decreaseAllowance`] function.
-        pub fn decreaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            amount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
-            self.call_builder(&decreaseAllowanceCall { spender, amount })
-        }
-
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getGradualWeightUpdateParams`]
-        /// function.
-        pub fn getGradualWeightUpdateParams(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getGradualWeightUpdateParamsCall, N> {
-            self.call_builder(&getGradualWeightUpdateParamsCall)
-        }
-
-        ///Creates a new call builder for the [`getInvariant`] function.
-        pub fn getInvariant(&self) -> alloy_contract::SolCallBuilder<&P, getInvariantCall, N> {
-            self.call_builder(&getInvariantCall)
-        }
-
-        ///Creates a new call builder for the [`getLastInvariant`] function.
-        pub fn getLastInvariant(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getLastInvariantCall, N> {
-            self.call_builder(&getLastInvariantCall)
-        }
-
         ///Creates a new call builder for the [`getNormalizedWeights`]
         /// function.
         pub fn getNormalizedWeights(
@@ -10645,11 +5031,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             self.call_builder(&getNormalizedWeightsCall)
         }
 
-        ///Creates a new call builder for the [`getOwner`] function.
-        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
-            self.call_builder(&getOwnerCall)
-        }
-
         ///Creates a new call builder for the [`getPausedState`] function.
         pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
             self.call_builder(&getPausedStateCall)
@@ -10660,11 +5041,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             self.call_builder(&getPoolIdCall)
         }
 
-        ///Creates a new call builder for the [`getRate`] function.
-        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
-            self.call_builder(&getRateCall)
-        }
-
         ///Creates a new call builder for the [`getScalingFactors`] function.
         pub fn getScalingFactors(
             &self,
@@ -10685,23 +5061,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             self.call_builder(&getSwapFeePercentageCall)
         }
 
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`increaseAllowance`] function.
-        pub fn increaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            addedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
-            self.call_builder(&increaseAllowanceCall {
-                spender,
-                addedValue,
-            })
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -10715,68 +5074,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             self.call_builder(&noncesCall { owner })
         }
 
-        ///Creates a new call builder for the [`onExitPool`] function.
-        pub fn onExitPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
-            self.call_builder(&onExitPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onJoinPool`] function.
-        pub fn onJoinPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
-            self.call_builder(&onJoinPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onSwap`] function.
-        pub fn onSwap(
-            &self,
-            request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-            balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
-            balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, onSwapCall, N> {
-            self.call_builder(&onSwapCall {
-                request,
-                balanceTokenIn,
-                balanceTokenOut,
-            })
-        }
-
         ///Creates a new call builder for the [`permit`] function.
         pub fn permit(
             &self,
@@ -10799,99 +5096,11 @@ pub mod BalancerV2LiquidityBootstrappingPool {
             })
         }
 
-        ///Creates a new call builder for the [`queryExit`] function.
-        pub fn queryExit(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
-            self.call_builder(&queryExitCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryJoin`] function.
-        pub fn queryJoin(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
-            self.call_builder(&queryJoinCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`setAssetManagerPoolConfig`]
-        /// function.
-        pub fn setAssetManagerPoolConfig(
-            &self,
-            token: alloy_sol_types::private::Address,
-            poolConfig: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, setAssetManagerPoolConfigCall, N> {
-            self.call_builder(&setAssetManagerPoolConfigCall { token, poolConfig })
-        }
-
-        ///Creates a new call builder for the [`setPaused`] function.
-        pub fn setPaused(
-            &self,
-            paused: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
-            self.call_builder(&setPausedCall { paused })
-        }
-
-        ///Creates a new call builder for the [`setSwapEnabled`] function.
-        pub fn setSwapEnabled(
-            &self,
-            swapEnabled: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, setSwapEnabledCall, N> {
-            self.call_builder(&setSwapEnabledCall { swapEnabled })
-        }
-
-        ///Creates a new call builder for the [`setSwapFeePercentage`]
-        /// function.
-        pub fn setSwapFeePercentage(
-            &self,
-            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
-            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
-        }
-
         ///Creates a new call builder for the [`symbol`] function.
         pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
@@ -10914,23 +5123,6 @@ pub mod BalancerV2LiquidityBootstrappingPool {
                 amount,
             })
         }
-
-        ///Creates a new call builder for the [`updateWeightsGradually`]
-        /// function.
-        pub fn updateWeightsGradually(
-            &self,
-            startTime: alloy_sol_types::private::primitives::aliases::U256,
-            endTime: alloy_sol_types::private::primitives::aliases::U256,
-            endWeights: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, updateWeightsGraduallyCall, N> {
-            self.call_builder(&updateWeightsGraduallyCall {
-                startTime,
-                endTime,
-                endWeights,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs
index 7a640bdbf4..dca2df6fdd 100644
--- a/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2liquiditybootstrappingpoolfactory/src/lib.rs
@@ -16,11 +16,6 @@ interface BalancerV2LiquidityBootstrappingPoolFactory {
     constructor(address vault);
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getVault() external view returns (address);
-    function isPoolFromFactory(address pool) external view returns (bool);
 }
 ```
 
@@ -87,87 +82,6 @@ interface BalancerV2LiquidityBootstrappingPoolFactory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "PoolCreated",
@@ -292,797 +206,26 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                 From::from(&self)
             }
         }
-        #[automatically_derived]
-        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(address vault);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub vault: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value.vault,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { vault: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.vault,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `create(string,string,address[],uint256[],uint256,address,bool)` and selector `0x23679719`.
-    ```solidity
-    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createCall {
-        #[allow(missing_docs)]
-        pub name: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub symbol: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub weights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub swapEnabledOnStart: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`create(string,string,address[],uint256[],uint256,address,
-    /// bool)`](createCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createCall) -> Self {
-                    (
-                        value.name,
-                        value.symbol,
-                        value.tokens,
-                        value.weights,
-                        value.swapFeePercentage,
-                        value.owner,
-                        value.swapEnabledOnStart,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        name: tuple.0,
-                        symbol: tuple.1,
-                        tokens: tuple.2,
-                        weights: tuple.3,
-                        swapFeePercentage: tuple.4,
-                        owner: tuple.5,
-                        swapEnabledOnStart: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [35u8, 103u8, 151u8, 25u8];
-            const SIGNATURE: &'static str =
-                "create(string,string,address[],uint256[],uint256,address,bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.name,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.symbol,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.swapEnabledOnStart,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    /**Constructor`.
     ```solidity
-    function getVault() external view returns (address);
+    constructor(address vault);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub vault: alloy_sol_types::private::Address,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
@@ -1100,30 +243,24 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { vault: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -1133,55 +270,47 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
                 )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    /**Function with signature `create(string,string,address[],uint256[],uint256,address,bool)` and selector `0x23679719`.
     ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
+    pub struct createCall {
         #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub weights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub swapEnabledOnStart: bool,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    /// [`create(string,string,address[],uint256[],uint256,address,
+    /// bool)`](createCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
+    pub struct createReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -1194,9 +323,25 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                bool,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1208,25 +353,41 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.weights,
+                        value.swapFeePercentage,
+                        value.owner,
+                        value.swapEnabledOnStart,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        weights: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        owner: tuple.5,
+                        swapEnabledOnStart: tuple.6,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1238,29 +399,38 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+            const SELECTOR: [u8; 4] = [35u8, 103u8, 151u8, 25u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],uint256,address,bool)";
 
             #[inline]
             fn new<'a>(
@@ -1272,22 +442,40 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabledOnStart,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
+                        let r: createReturn = r.into();
                         r._0
                     },
                 )
@@ -1299,7 +487,7 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                     data,
                 )
                 .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
+                    let r: createReturn = r.into();
                     r._0
                 })
             }
@@ -1311,16 +499,6 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
     pub enum BalancerV2LiquidityBootstrappingPoolFactoryCalls {
         #[allow(missing_docs)]
         create(createCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
     }
     impl BalancerV2LiquidityBootstrappingPoolFactoryCalls {
         /// All the selectors of this enum.
@@ -1330,32 +508,12 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [35u8, 103u8, 151u8, 25u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [141u8, 146u8, 138u8, 248u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[35u8, 103u8, 151u8, 25u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<createCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(create),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(getVault),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(create)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1379,27 +537,14 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2LiquidityBootstrappingPoolFactoryCalls {
-        const COUNT: usize = 6usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 352usize;
         const NAME: &'static str = "BalancerV2LiquidityBootstrappingPoolFactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -1420,78 +565,16 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2LiquidityBootstrappingPoolFactoryCalls,
-            >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::create)
-                    }
-                    create
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(
-                            BalancerV2LiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
-                        )
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
                 {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-            ];
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1511,82 +594,16 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2LiquidityBootstrappingPoolFactoryCalls,
-            >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::create)
-                    }
-                    create
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2LiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
                 {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2LiquidityBootstrappingPoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-            ];
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(BalancerV2LiquidityBootstrappingPoolFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1602,23 +619,6 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -1628,25 +628,6 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -1877,42 +858,6 @@ pub mod BalancerV2LiquidityBootstrappingPoolFactory {
                 swapEnabledOnStart,
             })
         }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs
index 53db73ef03..5c3a5c4b69 100644
--- a/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2noprotocolfeeliquiditybootstrappingpoolfactory/src/lib.rs
@@ -16,11 +16,6 @@ interface BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
     constructor(address vault);
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getVault() external view returns (address);
-    function isPoolFromFactory(address pool) external view returns (bool);
 }
 ```
 
@@ -87,87 +82,6 @@ interface BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "PoolCreated",
@@ -281,808 +195,37 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                 );
                 Ok(())
             }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PoolCreated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(address vault);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub vault: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value.vault,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { vault: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.vault,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `create(string,string,address[],uint256[],uint256,address,bool)` and selector `0x23679719`.
-    ```solidity
-    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createCall {
-        #[allow(missing_docs)]
-        pub name: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub symbol: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub weights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub swapEnabledOnStart: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`create(string,string,address[],uint256[],uint256,address,
-    /// bool)`](createCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createCall) -> Self {
-                    (
-                        value.name,
-                        value.symbol,
-                        value.tokens,
-                        value.weights,
-                        value.swapFeePercentage,
-                        value.owner,
-                        value.swapEnabledOnStart,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        name: tuple.0,
-                        symbol: tuple.1,
-                        tokens: tuple.2,
-                        weights: tuple.3,
-                        swapFeePercentage: tuple.4,
-                        owner: tuple.5,
-                        swapEnabledOnStart: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [35u8, 103u8, 151u8, 25u8];
-            const SIGNATURE: &'static str =
-                "create(string,string,address[],uint256[],uint256,address,bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.name,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.symbol,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.swapEnabledOnStart,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolCreated> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &PoolCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    /**Constructor`.
     ```solidity
-    function getVault() external view returns (address);
+    constructor(address vault);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub vault: alloy_sol_types::private::Address,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
@@ -1100,30 +243,24 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { vault: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -1133,55 +270,47 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
                 )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
+    /**Function with signature `create(string,string,address[],uint256[],uint256,address,bool)` and selector `0x23679719`.
     ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
+    function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner, bool swapEnabledOnStart) external returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
+    pub struct createCall {
         #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub weights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub swapEnabledOnStart: bool,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
+    /// [`create(string,string,address[],uint256[],uint256,address,
+    /// bool)`](createCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
+    pub struct createReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -1194,9 +323,25 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                bool,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1208,25 +353,41 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.weights,
+                        value.swapFeePercentage,
+                        value.owner,
+                        value.swapEnabledOnStart,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
+                    Self {
+                        name: tuple.0,
+                        symbol: tuple.1,
+                        tokens: tuple.2,
+                        weights: tuple.3,
+                        swapFeePercentage: tuple.4,
+                        owner: tuple.5,
+                        swapEnabledOnStart: tuple.6,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1238,29 +399,38 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
+            const SELECTOR: [u8; 4] = [35u8, 103u8, 151u8, 25u8];
+            const SIGNATURE: &'static str =
+                "create(string,string,address[],uint256[],uint256,address,bool)";
 
             #[inline]
             fn new<'a>(
@@ -1272,22 +442,40 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.weights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.swapEnabledOnStart,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
+                        let r: createReturn = r.into();
                         r._0
                     },
                 )
@@ -1299,7 +487,7 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                     data,
                 )
                 .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
+                    let r: createReturn = r.into();
                     r._0
                 })
             }
@@ -1312,16 +500,6 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
     pub enum BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls {
         #[allow(missing_docs)]
         create(createCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
     }
     impl BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls {
         /// All the selectors of this enum.
@@ -1331,32 +509,12 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [35u8, 103u8, 151u8, 25u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [141u8, 146u8, 138u8, 248u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[35u8, 103u8, 151u8, 25u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<createCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(create),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(getVault),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(create)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1382,27 +540,14 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
     impl alloy_sol_types::SolInterface
         for BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls
     {
-        const COUNT: usize = 6usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 352usize;
         const NAME: &'static str = "BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -1423,92 +568,17 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-            >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCode,
-                            )
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data).map(
-                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::create,
-                        )
-                    }
-                    create
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data).map(
-                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getVault,
-                        )
-                    }
-                    getVault
-                },
-            ];
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<
+                    BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                > {
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1528,93 +598,17 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-            >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCode,
-                            )
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data).map(
-                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::create,
-                        )
-                    }
-                    create
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<
-                        BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
-                    > {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(
-                            BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::getVault,
-                        )
-                    }
-                    getVault
-                },
-            ];
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<
+                    BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls,
+                > {
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1630,23 +624,6 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -1656,25 +633,6 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -1916,42 +874,6 @@ pub mod BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory {
                 swapEnabledOnStart,
             })
         }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs
index 9e12f5c6e5..bc74bcee38 100644
--- a/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2stablepool/src/lib.rs
@@ -6,858 +6,37 @@
     non_snake_case
 )]
 //! Auto-generated contract bindings. Do not edit.
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
-library IPoolSwapStructs {
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IPoolSwapStructs {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapRequest {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            IVault::SwapKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapRequest) -> Self {
-                (
-                    value.kind,
-                    value.tokenIn,
-                    value.tokenOut,
-                    value.amount,
-                    value.poolId,
-                    value.lastChangeBlock,
-                    value.from,
-                    value.to,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    kind: tuple.0,
-                    tokenIn: tuple.1,
-                    tokenOut: tuple.2,
-                    amount: tuple.3,
-                    poolId: tuple.4,
-                    lastChangeBlock: tuple.5,
-                    from: tuple.6,
-                    to: tuple.7,
-                    userData: tuple.8,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapRequest {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.from,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapRequest {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapRequest {
-            const NAME: &'static str = "SwapRequest";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
-                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
-                     userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.kind,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.lastChangeBlock,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.from,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.to,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapRequest {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenIn,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenOut,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.lastChangeBlock,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.from,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.to,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind, out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.lastChangeBlock,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.from,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.to,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IPoolSwapStructsInstance<P, N> {
-        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IPoolSwapStructs`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IPoolSwapStructs`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IPoolSwapStructsInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
+interface BalancerV2StablePool {
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
+    event AmpUpdateStopped(uint256 currentValue);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
 
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
+    constructor(address vault, string name, string symbol, address[] tokens, uint256 amplificationParameter, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
 
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
-            IPoolSwapStructsInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library IVault {
-    type SwapKind is uint8;
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IVault {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapKind(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl SwapKind {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for SwapKind {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<SwapKind> for u8 {
-            fn from(value: SwapKind) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapKind {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapKind {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IVaultInstance<P, N> {
-        IVaultInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IVault`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IVault`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IVaultInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
-            IVaultInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IPoolSwapStructs {
-    struct SwapRequest {
-        IVault.SwapKind kind;
-        address tokenIn;
-        address tokenOut;
-        uint256 amount;
-        bytes32 poolId;
-        uint256 lastChangeBlock;
-        address from;
-        address to;
-        bytes userData;
-    }
-}
-
-library IVault {
-    type SwapKind is uint8;
-}
-
-interface BalancerV2StablePool {
-    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
-    event AmpUpdateStopped(uint256 currentValue);
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    event PausedStateChanged(bool paused);
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    constructor(address vault, string name, string symbol, address[] tokens, uint256 amplificationParameter, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
-
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function allowance(address owner, address spender) external view returns (uint256);
-    function approve(address spender, uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-    function decimals() external view returns (uint8);
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
-    function getAuthorizer() external view returns (address);
-    function getOwner() external view returns (address);
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    function getPoolId() external view returns (bytes32);
-    function getRate() external view returns (uint256);
-    function getSwapFeePercentage() external view returns (uint256);
-    function getVault() external view returns (address);
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    function name() external view returns (string memory);
-    function nonces(address owner) external view returns (uint256);
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external view returns (uint256);
-    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
-    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
-    function setPaused(bool paused) external;
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
-    function stopAmplificationParameterUpdate() external;
-    function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-}
-```
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getSwapFeePercentage() external view returns (uint256);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function symbol() external view returns (string memory);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
 
 ...which was generated by the following JSON ABI:
 ```json
@@ -1006,49 +185,6 @@ interface BalancerV2StablePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "decreaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getAmplificationParameter",
@@ -1072,32 +208,6 @@ interface BalancerV2StablePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getOwner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getPausedState",
@@ -1134,19 +244,6 @@ interface BalancerV2StablePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getRate",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getSwapFeePercentage",
@@ -1160,43 +257,6 @@ interface BalancerV2StablePool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "increaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "addedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "name",
@@ -1231,256 +291,71 @@ interface BalancerV2StablePool {
   },
   {
     "type": "function",
-    "name": "onExitPool",
+    "name": "permit",
     "inputs": [
       {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
+        "name": "owner",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "recipient",
+        "name": "spender",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
+        "name": "value",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "protocolSwapFeePercentage",
+        "name": "deadline",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
       },
       {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onJoinPool",
-    "inputs": [
-      {
-        "name": "poolId",
+        "name": "r",
         "type": "bytes32",
         "internalType": "bytes32"
       },
       {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
       }
     ],
+    "outputs": [],
     "stateMutability": "nonpayable"
   },
   {
     "type": "function",
-    "name": "onSwap",
-    "inputs": [
-      {
-        "name": "swapRequest",
-        "type": "tuple",
-        "internalType": "struct IPoolSwapStructs.SwapRequest",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "tokenOut",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "lastChangeBlock",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "from",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "indexIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "indexOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
+    "name": "symbol",
+    "inputs": [],
     "outputs": [
       {
         "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
+        "type": "string",
+        "internalType": "string"
       }
     ],
     "stateMutability": "view"
   },
   {
     "type": "function",
-    "name": "onSwap",
+    "name": "transfer",
     "inputs": [
       {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IPoolSwapStructs.SwapRequest",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "tokenOut",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "lastChangeBlock",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "from",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "balanceTokenIn",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
       },
       {
-        "name": "balanceTokenOut",
+        "name": "amount",
         "type": "uint256",
         "internalType": "uint256"
       }
@@ -1488,3114 +363,193 @@ interface BalancerV2StablePool {
     "outputs": [
       {
         "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
+        "type": "bool",
+        "internalType": "bool"
       }
     ],
-    "stateMutability": "view"
+    "stateMutability": "nonpayable"
   },
   {
     "type": "function",
-    "name": "permit",
+    "name": "transferFrom",
     "inputs": [
       {
-        "name": "owner",
+        "name": "sender",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "spender",
+        "name": "recipient",
         "type": "address",
         "internalType": "address"
       },
       {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "deadline",
+        "name": "amount",
         "type": "uint256",
         "internalType": "uint256"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
+      }
+    ],
+    "outputs": [
       {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
       }
     ],
-    "outputs": [],
     "stateMutability": "nonpayable"
   },
   {
-    "type": "function",
-    "name": "queryExit",
+    "type": "event",
+    "name": "AmpUpdateStarted",
     "inputs": [
       {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
+        "name": "startValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
       },
       {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryJoin",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setAssetManagerPoolConfig",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "poolConfig",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setPaused",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setSwapFeePercentage",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "startAmplificationParameterUpdate",
-    "inputs": [
-      {
-        "name": "rawEndValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "stopAmplificationParameterUpdate",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "symbol",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "transfer",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferFrom",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "event",
-    "name": "AmpUpdateStarted",
-    "inputs": [
-      {
-        "name": "startValue",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "endValue",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
+        "name": "endValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
       },
       {
         "name": "startTime",
         "type": "uint256",
         "indexed": false,
         "internalType": "uint256"
-      },
-      {
-        "name": "endTime",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "AmpUpdateStopped",
-    "inputs": [
-      {
-        "name": "currentValue",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Approval",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PausedStateChanged",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SwapFeePercentageChanged",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Transfer",
-    "inputs": [
-      {
-        "name": "from",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BalancerV2StablePool {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `AmpUpdateStarted(uint256,uint256,uint256,uint256)` and selector `0x1835882ee7a34ac194f717a35e09bb1d24c82a3b9d854ab6c9749525b714cdf2`.
-    ```solidity
-    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct AmpUpdateStarted {
-        #[allow(missing_docs)]
-        pub startValue: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endValue: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for AmpUpdateStarted {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "AmpUpdateStarted(uint256,uint256,uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
-                    94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8,
-                    201u8, 116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    startValue: data.0,
-                    endValue: data.1,
-                    startTime: data.2,
-                    endTime: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.startValue,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.endValue,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.startTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.endTime,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for AmpUpdateStarted {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&AmpUpdateStarted> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &AmpUpdateStarted) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `AmpUpdateStopped(uint256)` and selector `0xa0d01593e47e69d07e0ccd87bece09411e07dd1ed40ca8f2e7af2976542a0233`.
-    ```solidity
-    event AmpUpdateStopped(uint256 currentValue);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct AmpUpdateStopped {
-        #[allow(missing_docs)]
-        pub currentValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for AmpUpdateStopped {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "AmpUpdateStopped(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8,
-                    135u8, 190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8,
-                    242u8, 231u8, 175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    currentValue: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.currentValue,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for AmpUpdateStopped {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&AmpUpdateStopped> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &AmpUpdateStopped) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
-    ```solidity
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Approval {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Approval {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
-                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
-                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    spender: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.spender.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Approval {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Approval> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
-    ```solidity
-    event PausedStateChanged(bool paused);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PausedStateChanged {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PausedStateChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
-                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
-                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { paused: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
-    ```solidity
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SwapFeePercentageChanged {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
-                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
-                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    swapFeePercentage: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
-    ```solidity
-    event Transfer(address indexed from, address indexed to, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Transfer {
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Transfer {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
-                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
-                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    from: topics.1,
-                    to: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.from.clone(),
-                    self.to.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.from,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.to,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Transfer {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Transfer> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(address vault, string name, string symbol, address[] tokens, uint256 amplificationParameter, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub vault: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub name: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub symbol: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (
-                        value.vault,
-                        value.name,
-                        value.symbol,
-                        value.tokens,
-                        value.amplificationParameter,
-                        value.swapFeePercentage,
-                        value.pauseWindowDuration,
-                        value.bufferPeriodDuration,
-                        value.owner,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        vault: tuple.0,
-                        name: tuple.1,
-                        symbol: tuple.2,
-                        tokens: tuple.3,
-                        amplificationParameter: tuple.4,
-                        swapFeePercentage: tuple.5,
-                        pauseWindowDuration: tuple.6,
-                        bufferPeriodDuration: tuple.7,
-                        owner: tuple.8,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.vault,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.name,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.symbol,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.amplificationParameter,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
-    ```solidity
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
-            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DOMAIN_SEPARATORReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: DOMAIN_SEPARATORReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
-    ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: allowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: allowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
-    ```solidity
-    function approve(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approveReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: approveReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
-    ```solidity
-    function balanceOf(address account) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: balanceOfReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: balanceOfReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
-    ```solidity
-    function decimals() external view returns (uint8);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsReturn {
-        #[allow(missing_docs)]
-        pub _0: u8,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
-            type Parameters<'a> = ();
-            type Return = u8;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decimalsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decimalsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
-    ```solidity
-    function decreaseAllowance(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
-            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decreaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decreaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
-    ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmplificationParameter()` and selector `0x6daccffa`.
-    ```solidity
-    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmplificationParameterCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmplificationParameter()`](getAmplificationParameterCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmplificationParameterReturn {
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub isUpdating: bool,
-        #[allow(missing_docs)]
-        pub precision: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmplificationParameterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmplificationParameterCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmplificationParameterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmplificationParameterReturn) -> Self {
-                    (value.value, value.isUpdating, value.precision)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        value: tuple.0,
-                        isUpdating: tuple.1,
-                        precision: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getAmplificationParameterReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getAmplificationParameterCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.isUpdating,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.precision,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmplificationParameterCall {
-            type Parameters<'a> = ();
-            type Return = getAmplificationParameterReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [109u8, 172u8, 207u8, 250u8];
-            const SIGNATURE: &'static str = "getAmplificationParameter()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getAmplificationParameterReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOwner()` and selector `0x893d20e8`.
-    ```solidity
-    function getOwner() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getOwner()`](getOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOwnerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
-            const SIGNATURE: &'static str = "getOwner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOwnerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOwnerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
-    ```solidity
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPausedState()`](getPausedStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateReturn {
-        #[allow(missing_docs)]
-        pub paused: bool,
-        #[allow(missing_docs)]
-        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateReturn) -> Self {
-                    (
-                        value.paused,
-                        value.pauseWindowEndTime,
-                        value.bufferPeriodEndTime,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paused: tuple.0,
-                        pauseWindowEndTime: tuple.1,
-                        bufferPeriodEndTime: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getPausedStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowEndTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodEndTime,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPausedStateCall {
-            type Parameters<'a> = ();
-            type Return = getPausedStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
-            const SIGNATURE: &'static str = "getPausedState()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPausedStateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
+      },
+      {
+        "name": "endTime",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "AmpUpdateStopped",
+    "inputs": [
+      {
+        "name": "currentValue",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2StablePool {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    /**Event with signature `AmpUpdateStarted(uint256,uint256,uint256,uint256)` and selector `0x1835882ee7a34ac194f717a35e09bb1d24c82a3b9d854ab6c9749525b714cdf2`.
     ```solidity
-    function getPoolId() external view returns (bytes32);
+    event AmpUpdateStarted(uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolId()`](getPoolIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
         clippy::pub_underscore_fields,
         clippy::style
     )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolIdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
-            const SIGNATURE: &'static str = "getPoolId()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRate()` and selector `0x679aefce`.
-    ```solidity
-    function getRate() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRate()`](getRateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getRateReturn {
+    pub struct AmpUpdateStarted {
+        #[allow(missing_docs)]
+        pub startValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub endValue: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub startTime: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -4605,136 +559,122 @@ pub mod BalancerV2StablePool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRateCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for AmpUpdateStarted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
-            const SIGNATURE: &'static str = "getRate()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStarted(uint256,uint256,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    24u8, 53u8, 136u8, 46u8, 231u8, 163u8, 74u8, 193u8, 148u8, 247u8, 23u8, 163u8,
+                    94u8, 9u8, 187u8, 29u8, 36u8, 200u8, 42u8, 59u8, 157u8, 133u8, 74u8, 182u8,
+                    201u8, 116u8, 149u8, 37u8, 183u8, 20u8, 205u8, 242u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    startValue: data.0,
+                    endValue: data.1,
+                    startTime: data.2,
+                    endTime: data.3,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.startValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endValue,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.startTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.endTime,
                     ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRateReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRateReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStarted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStarted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStarted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    /**Event with signature `AmpUpdateStopped(uint256)` and selector `0xa0d01593e47e69d07e0ccd87bece09411e07dd1ed40ca8f2e7af2976542a0233`.
     ```solidity
-    function getSwapFeePercentage() external view returns (uint256);
+    event AmpUpdateStopped(uint256 currentValue);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapFeePercentageCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getSwapFeePercentageReturn {
+    pub struct AmpUpdateStopped {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub currentValue: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -4744,136 +684,109 @@ pub mod BalancerV2StablePool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for AmpUpdateStopped {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
-            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AmpUpdateStopped(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 208u8, 21u8, 147u8, 228u8, 126u8, 105u8, 208u8, 126u8, 12u8, 205u8,
+                    135u8, 190u8, 206u8, 9u8, 65u8, 30u8, 7u8, 221u8, 30u8, 212u8, 12u8, 168u8,
+                    242u8, 231u8, 175u8, 41u8, 118u8, 84u8, 42u8, 2u8, 51u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    currentValue: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.currentValue,
                     ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSwapFeePercentageReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getSwapFeePercentageReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AmpUpdateStopped {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AmpUpdateStopped> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AmpUpdateStopped) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
     ```solidity
-    function getVault() external view returns (address);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getVaultReturn {
+    pub struct Approval {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -4883,137 +796,121 @@ pub mod BalancerV2StablePool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
-    ```solidity
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
+    ```solidity
+    event PausedStateChanged(bool paused);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct increaseAllowanceReturn {
+    pub struct PausedStateChanged {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub paused: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -5023,151 +920,103 @@ pub mod BalancerV2StablePool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceCall) -> Self {
-                    (value.spender, value.addedValue)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        addedValue: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
-            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { paused: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.addedValue,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: increaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: increaseAllowanceReturn = r.into();
-                    r._0
-                })
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
     ```solidity
-    function name() external view returns (string memory);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct nameReturn {
+    pub struct SwapFeePercentageChanged {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5177,135 +1026,109 @@ pub mod BalancerV2StablePool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    swapFeePercentage: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.swapFeePercentage,
+                    ),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: nameReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: nameReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
     ```solidity
-    function nonces(address owner) external view returns (uint256);
+    event Transfer(address indexed from, address indexed to, uint256 value);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct noncesCall {
+    pub struct Transfer {
         #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesReturn {
+        pub from: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5315,189 +1138,159 @@ pub mod BalancerV2StablePool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
                 )
             }
 
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: noncesReturn = r.into();
-                        r._0
-                    },
-                )
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: noncesReturn = r.into();
-                    r._0
-                })
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    /**Constructor`.
     ```solidity
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    constructor(address vault, string name, string symbol, address[] tokens, uint256 amplificationParameter, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onExitPoolCall {
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        pub vault: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
+        pub name: alloy_sol_types::private::String,
         #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
+        pub symbol: alloy_sol_types::private::String,
         #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
         #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        pub amplificationParameter: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onExitPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onExitPoolReturn {
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub owner: alloy_sol_types::private::Address,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5510,109 +1303,54 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolCall) -> Self {
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
                     (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
+                        value.vault,
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.amplificationParameter,
+                        value.swapFeePercentage,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                        value.owner,
                     )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolReturn) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
+                        vault: tuple.0,
+                        name: tuple.1,
+                        symbol: tuple.2,
+                        tokens: tuple.3,
+                        amplificationParameter: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        pauseWindowDuration: tuple.6,
+                        bufferPeriodDuration: tuple.7,
+                        owner: tuple.8,
                     }
                 }
             }
         }
-        impl onExitPoolReturn {
-            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onExitPoolCall {
+        impl alloy_sol_types::SolConstructor for constructorCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onExitPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
-            const SIGNATURE: &'static str =
-                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -5623,87 +1361,55 @@ pub mod BalancerV2StablePool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
+                        &self.vault,
                     ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
                     ),
                     <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
                     <alloy_sol_types::sol_data::Uint<
                         256,
                     > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
+                        &self.amplificationParameter,
                     ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
                     ),
                 )
             }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onExitPoolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
     ```solidity
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onJoinPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct DOMAIN_SEPARATORCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onJoinPoolCall) function.
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onJoinPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct DOMAIN_SEPARATORReturn {
         #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -5716,25 +1422,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5746,47 +1436,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5798,56 +1466,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolReturn) -> Self {
-                    (value._0, value._1)
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl onJoinPoolReturn {
-            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onJoinPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onJoinPoolReturn;
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
-            const SIGNATURE: &'static str =
-                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
 
             #[inline]
             fn new<'a>(
@@ -5858,42 +1499,26 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onJoinPoolReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5901,35 +1526,32 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256[],uint256,uint256)` and selector `0x01ec954a`.
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
-    function onSwap(IPoolSwapStructs.SwapRequest memory swapRequest, uint256[] memory balances, uint256 indexIn, uint256 indexOut) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwap_0Call {
-        #[allow(missing_docs)]
-        pub swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct allowanceCall {
         #[allow(missing_docs)]
-        pub indexIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub owner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub indexOut: alloy_sol_types::private::primitives::aliases::U256,
+        pub spender: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
-    /// bytes),uint256[],uint256,uint256)`](onSwap_0Call) function.
+    /// [`allowance(address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwap_0Return {
+    pub struct allowanceReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -5945,17 +1567,13 @@ pub mod BalancerV2StablePool {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5968,25 +1586,18 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwap_0Call> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwap_0Call) -> Self {
-                    (
-                        value.swapRequest,
-                        value.balances,
-                        value.indexIn,
-                        value.indexOut,
-                    )
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_0Call {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        swapRequest: tuple.0,
-                        balances: tuple.1,
-                        indexIn: tuple.2,
-                        indexOut: tuple.3,
+                        owner: tuple.0,
+                        spender: tuple.1,
                     }
                 }
             }
@@ -6008,36 +1619,32 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwap_0Return> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwap_0Return) -> Self {
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_0Return {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onSwap_0Call {
+        impl alloy_sol_types::SolCall for allowanceCall {
             type Parameters<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [1u8, 236u8, 149u8, 74u8];
-            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
-                                             uint256,address,address,bytes),uint256[],uint256,\
-                                             uint256)";
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -6049,18 +1656,12 @@ pub mod BalancerV2StablePool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.swapRequest,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
                     ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.indexIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.indexOut),
                 )
             }
 
@@ -6077,7 +1678,7 @@ pub mod BalancerV2StablePool {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: onSwap_0Return = r.into();
+                        let r: allowanceReturn = r.into();
                         r._0
                     },
                 )
@@ -6089,36 +1690,33 @@ pub mod BalancerV2StablePool {
                     data,
                 )
                 .map(|r| {
-                    let r: onSwap_0Return = r.into();
+                    let r: allowanceReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256,uint256)` and selector `0x9d2c110c`.
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
     ```solidity
-    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwap_1Call {
-        #[allow(missing_docs)]
-        pub request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
+    pub struct approveCall {
         #[allow(missing_docs)]
-        pub balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub spender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
-    /// bytes),uint256,uint256)`](onSwap_1Call) function.
+    /// [`approve(address,uint256)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwap_1Return {
+    pub struct approveReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -6132,14 +1730,12 @@ pub mod BalancerV2StablePool {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -6153,19 +1749,18 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwap_1Call> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwap_1Call) -> Self {
-                    (value.request, value.balanceTokenIn, value.balanceTokenOut)
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_1Call {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        request: tuple.0,
-                        balanceTokenIn: tuple.1,
-                        balanceTokenOut: tuple.2,
+                        spender: tuple.0,
+                        amount: tuple.1,
                     }
                 }
             }
@@ -6173,9 +1768,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6187,34 +1782,32 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwap_1Return> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwap_1Return) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwap_1Return {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onSwap_1Call {
+        impl alloy_sol_types::SolCall for approveCall {
             type Parameters<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [157u8, 44u8, 17u8, 12u8];
-            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
-                                             uint256,address,address,bytes),uint256,uint256)";
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -6226,32 +1819,25 @@ pub mod BalancerV2StablePool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.balanceTokenIn,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
                     ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.balanceTokenOut,
+                        &self.amount,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: onSwap_1Return = r.into();
+                        let r: approveReturn = r.into();
                         r._0
                     },
                 )
@@ -6263,41 +1849,32 @@ pub mod BalancerV2StablePool {
                     data,
                 )
                 .map(|r| {
-                    let r: onSwap_1Return = r.into();
+                    let r: approveReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
     ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function balanceOf(address account) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
+    pub struct balanceOfCall {
         #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
+        pub account: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
+    /// [`balanceOf(address)`](balanceOfCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitReturn {}
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6309,25 +1886,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6339,41 +1900,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
+                    Self { account: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6385,43 +1930,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
                 }
             }
-        }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = permitReturn;
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
 
             #[inline]
             fn new<'a>(
@@ -6434,38 +1965,28 @@ pub mod BalancerV2StablePool {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self.account,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6473,46 +1994,29 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    /**Function with signature `decimals()` and selector `0x313ce567`.
     ```solidity
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptIn, uint256[] memory amountsOut);
+    function decimals() external view returns (uint8);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryExitCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct decimalsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryExitCall) function.
+    /// [`decimals()`](decimalsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryExitReturn {
-        #[allow(missing_docs)]
-        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct decimalsReturn {
         #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: u8,
     }
     #[allow(
         non_camel_case_types,
@@ -6525,25 +2029,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6555,47 +2043,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (u8,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6607,56 +2073,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitReturn) -> Self {
-                    (value.bptIn, value.amountsOut)
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptIn: tuple.0,
-                        amountsOut: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl queryExitReturn {
-            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryExitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryExitReturn;
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
-            const SIGNATURE: &'static str =
-                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
 
             #[inline]
             fn new<'a>(
@@ -6667,42 +2106,22 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryExitReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6710,46 +2129,33 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    /**Function with signature `getAmplificationParameter()` and selector `0x6daccffa`.
     ```solidity
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256 bptOut, uint256[] memory amountsIn);
+    function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryJoinCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct getAmplificationParameterCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryJoinCall) function.
+    /// [`getAmplificationParameter()`](getAmplificationParameterCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryJoinReturn {
+    pub struct getAmplificationParameterReturn {
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+        pub isUpdating: bool,
         #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub precision: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -6762,25 +2168,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6792,32 +2182,16 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<getAmplificationParameterCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
@@ -6826,12 +2200,14 @@ pub mod BalancerV2StablePool {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -6844,56 +2220,55 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinReturn) -> Self {
-                    (value.bptOut, value.amountsIn)
+            impl ::core::convert::From<getAmplificationParameterReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getAmplificationParameterReturn) -> Self {
+                    (value.value, value.isUpdating, value.precision)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmplificationParameterReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        bptOut: tuple.0,
-                        amountsIn: tuple.1,
+                        value: tuple.0,
+                        isUpdating: tuple.1,
+                        precision: tuple.2,
                     }
                 }
             }
         }
-        impl queryJoinReturn {
-            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl getAmplificationParameterReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getAmplificationParameterCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isUpdating,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.precision,
+                    ),
                 )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryJoinCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryJoinReturn;
+        impl alloy_sol_types::SolCall for getAmplificationParameterCall {
+            type Parameters<'a> = ();
+            type Return = getAmplificationParameterReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
-            const SIGNATURE: &'static str =
-                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [109u8, 172u8, 207u8, 250u8];
+            const SIGNATURE: &'static str = "getAmplificationParameter()";
 
             #[inline]
             fn new<'a>(
@@ -6904,36 +2279,12 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryJoinReturn::_tokenize(ret)
+                getAmplificationParameterReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -6952,24 +2303,26 @@ pub mod BalancerV2StablePool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setAssetManagerPoolConfig(address,bytes)` and selector `0x50dd6ed9`.
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
     ```solidity
-    function setAssetManagerPoolConfig(address token, bytes memory poolConfig) external;
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setAssetManagerPoolConfigCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub poolConfig: alloy_sol_types::private::Bytes,
-    }
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setAssetManagerPoolConfig(address,
-    /// bytes)`](setAssetManagerPoolConfigCall) function.
+    /// [`getPausedState()`](getPausedStateCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setAssetManagerPoolConfigReturn {}
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6981,15 +2334,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7001,28 +2348,33 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setAssetManagerPoolConfigCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setAssetManagerPoolConfigCall) -> Self {
-                    (value.token, value.poolConfig)
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        poolConfig: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7034,40 +2386,58 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setAssetManagerPoolConfigReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setAssetManagerPoolConfigReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAssetManagerPoolConfigReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
                 }
             }
         }
-        impl setAssetManagerPoolConfigReturn {
+        impl getPausedStateReturn {
             fn _tokenize(
                 &self,
-            ) -> <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setAssetManagerPoolConfigCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = setAssetManagerPoolConfigReturn;
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [80u8, 221u8, 110u8, 217u8];
-            const SIGNATURE: &'static str = "setAssetManagerPoolConfig(address,bytes)";
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
 
             #[inline]
             fn new<'a>(
@@ -7078,19 +2448,12 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.poolConfig,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setAssetManagerPoolConfigReturn::_tokenize(ret)
+                getPausedStateReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -7109,21 +2472,22 @@ pub mod BalancerV2StablePool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
     ```solidity
-    function setPaused(bool paused) external;
+    function getPoolId() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedCall {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
+    pub struct getPoolIdCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setPaused(bool)`](setPausedCall) function.
+    /// [`getPoolId()`](getPoolIdCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedReturn {}
+    pub struct getPoolIdReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7135,9 +2499,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7149,25 +2513,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedCall) -> Self {
-                    (value.paused,)
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { paused: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7179,34 +2543,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setPausedReturn {
-            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setPausedCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Return = setPausedReturn;
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
-            const SIGNATURE: &'static str = "setPaused(bool)";
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
 
             #[inline]
             fn new<'a>(
@@ -7217,22 +2576,26 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setPausedReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7240,26 +2603,30 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
     ```solidity
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function getSwapFeePercentage() external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeePercentageCall {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct getSwapFeePercentageCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeePercentageReturn {}
+    pub struct getSwapFeePercentageReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7271,9 +2638,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7285,27 +2652,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageCall) -> Self {
-                    (value.swapFeePercentage,)
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapFeePercentage: tuple.0,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7317,37 +2682,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setSwapFeePercentageReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = setSwapFeePercentageReturn;
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
-            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
 
             #[inline]
             fn new<'a>(
@@ -7358,22 +2715,26 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapFeePercentageReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7381,29 +2742,30 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `startAmplificationParameterUpdate(uint256,uint256)` and selector `0x2f1a0bc9`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function startAmplificationParameterUpdate(uint256 rawEndValue, uint256 endTime) external;
+    function name() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct startAmplificationParameterUpdateCall {
-        #[allow(missing_docs)]
-        pub rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub endTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`startAmplificationParameterUpdate(uint256,
-    /// uint256)`](startAmplificationParameterUpdateCall) function.
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct startAmplificationParameterUpdateReturn {}
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7415,15 +2777,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7435,28 +2791,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<startAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: startAmplificationParameterUpdateCall) -> Self {
-                    (value.rawEndValue, value.endTime)
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        rawEndValue: tuple.0,
-                        endTime: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7468,40 +2821,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<startAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: startAmplificationParameterUpdateReturn) -> Self {
-                    ()
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for startAmplificationParameterUpdateReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl startAmplificationParameterUpdateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for startAmplificationParameterUpdateCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = startAmplificationParameterUpdateReturn;
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [47u8, 26u8, 11u8, 201u8];
-            const SIGNATURE: &'static str = "startAmplificationParameterUpdate(uint256,uint256)";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -7512,25 +2854,22 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.rawEndValue,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.endTime,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                startAmplificationParameterUpdateReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7538,24 +2877,33 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `stopAmplificationParameterUpdate()` and selector `0xeb0f24d6`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function stopAmplificationParameterUpdate() external;
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct stopAmplificationParameterUpdateCall;
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`stopAmplificationParameterUpdate()`](stopAmplificationParameterUpdateCall)
-    /// function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct stopAmplificationParameterUpdateReturn {}
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7567,9 +2915,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7581,25 +2929,25 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<stopAmplificationParameterUpdateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: stopAmplificationParameterUpdateCall) -> Self {
-                    ()
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self { owner: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7611,37 +2959,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<stopAmplificationParameterUpdateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: stopAmplificationParameterUpdateReturn) -> Self {
-                    ()
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for stopAmplificationParameterUpdateReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl stopAmplificationParameterUpdateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for stopAmplificationParameterUpdateCall {
-            type Parameters<'a> = ();
-            type Return = stopAmplificationParameterUpdateReturn;
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [235u8, 15u8, 36u8, 214u8];
-            const SIGNATURE: &'static str = "stopAmplificationParameterUpdate()";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -7652,18 +2992,30 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                stopAmplificationParameterUpdateReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7671,27 +3023,42 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function symbol() external view returns (string memory);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct symbolCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`symbol()`](symbolCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolReturn {
+    pub struct permitCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
     }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7703,9 +3070,25 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7717,25 +3100,41 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolCall) -> Self {
-                    ()
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7747,29 +3146,43 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for symbolCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
-            const SIGNATURE: &'static str = "symbol()";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -7780,22 +3193,40 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: symbolReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -7803,29 +3234,26 @@ pub mod BalancerV2StablePool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: symbolReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
     ```solidity
-    function totalSupply() external view returns (uint256);
+    function symbol() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyCall;
+    pub struct symbolCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyReturn {
+    pub struct symbolReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -7852,14 +3280,14 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -7868,9 +3296,9 @@ pub mod BalancerV2StablePool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7882,29 +3310,29 @@ pub mod BalancerV2StablePool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
+        impl alloy_sol_types::SolCall for symbolCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
 
             #[inline]
             fn new<'a>(
@@ -7920,18 +3348,14 @@ pub mod BalancerV2StablePool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: totalSupplyReturn = r.into();
+                        let r: symbolReturn = r.into();
                         r._0
                     },
                 )
@@ -7943,7 +3367,7 @@ pub mod BalancerV2StablePool {
                     data,
                 )
                 .map(|r| {
-                    let r: totalSupplyReturn = r.into();
+                    let r: symbolReturn = r.into();
                     r._0
                 })
             }
@@ -8290,60 +3714,22 @@ pub mod BalancerV2StablePool {
         #[allow(missing_docs)]
         decimals(decimalsCall),
         #[allow(missing_docs)]
-        decreaseAllowance(decreaseAllowanceCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
         getAmplificationParameter(getAmplificationParameterCall),
         #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getOwner(getOwnerCall),
-        #[allow(missing_docs)]
         getPausedState(getPausedStateCall),
         #[allow(missing_docs)]
         getPoolId(getPoolIdCall),
         #[allow(missing_docs)]
-        getRate(getRateCall),
-        #[allow(missing_docs)]
         getSwapFeePercentage(getSwapFeePercentageCall),
         #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        increaseAllowance(increaseAllowanceCall),
-        #[allow(missing_docs)]
         name(nameCall),
         #[allow(missing_docs)]
         nonces(noncesCall),
         #[allow(missing_docs)]
-        onExitPool(onExitPoolCall),
-        #[allow(missing_docs)]
-        onJoinPool(onJoinPoolCall),
-        #[allow(missing_docs)]
-        onSwap_0(onSwap_0Call),
-        #[allow(missing_docs)]
-        onSwap_1(onSwap_1Call),
-        #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        queryExit(queryExitCall),
-        #[allow(missing_docs)]
-        queryJoin(queryJoinCall),
-        #[allow(missing_docs)]
-        setAssetManagerPoolConfig(setAssetManagerPoolConfigCall),
-        #[allow(missing_docs)]
-        setPaused(setPausedCall),
-        #[allow(missing_docs)]
-        setSwapFeePercentage(setSwapFeePercentageCall),
-        #[allow(missing_docs)]
-        startAmplificationParameterUpdate(startAmplificationParameterUpdateCall),
-        #[allow(missing_docs)]
-        stopAmplificationParameterUpdate(stopAmplificationParameterUpdateCall),
-        #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -8357,114 +3743,57 @@ pub mod BalancerV2StablePool {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [1u8, 236u8, 149u8, 74u8],
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [22u8, 195u8, 139u8, 60u8],
-            [24u8, 22u8, 13u8, 221u8],
             [28u8, 13u8, 224u8, 81u8],
             [35u8, 184u8, 114u8, 221u8],
-            [47u8, 26u8, 11u8, 201u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
-            [56u8, 233u8, 146u8, 46u8],
             [56u8, 255u8, 242u8, 208u8],
-            [57u8, 80u8, 147u8, 81u8],
-            [80u8, 221u8, 110u8, 217u8],
             [85u8, 198u8, 118u8, 40u8],
-            [96u8, 40u8, 191u8, 212u8],
-            [103u8, 154u8, 239u8, 206u8],
             [109u8, 172u8, 207u8, 250u8],
             [112u8, 160u8, 130u8, 49u8],
-            [116u8, 243u8, 176u8, 9u8],
             [126u8, 206u8, 190u8, 0u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [135u8, 236u8, 104u8, 23u8],
-            [137u8, 61u8, 32u8, 232u8],
-            [141u8, 146u8, 138u8, 248u8],
             [149u8, 216u8, 155u8, 65u8],
-            [157u8, 44u8, 17u8, 12u8],
-            [164u8, 87u8, 194u8, 215u8],
             [169u8, 5u8, 156u8, 187u8],
-            [170u8, 171u8, 173u8, 197u8],
             [213u8, 5u8, 172u8, 207u8],
-            [213u8, 192u8, 150u8, 196u8],
             [221u8, 98u8, 237u8, 62u8],
-            [235u8, 15u8, 36u8, 214u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <onSwap_0Call as alloy_sol_types::SolCall>::SIGNATURE,
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getAmplificationParameterCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onSwap_1Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(onSwap_0),
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(setPaused),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(getPausedState),
             ::core::stringify!(transferFrom),
-            ::core::stringify!(startAmplificationParameterUpdate),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(setSwapFeePercentage),
             ::core::stringify!(getPoolId),
-            ::core::stringify!(increaseAllowance),
-            ::core::stringify!(setAssetManagerPoolConfig),
             ::core::stringify!(getSwapFeePercentage),
-            ::core::stringify!(queryExit),
-            ::core::stringify!(getRate),
             ::core::stringify!(getAmplificationParameter),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(onExitPool),
             ::core::stringify!(nonces),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(queryJoin),
-            ::core::stringify!(getOwner),
-            ::core::stringify!(getVault),
             ::core::stringify!(symbol),
-            ::core::stringify!(onSwap_1),
-            ::core::stringify!(decreaseAllowance),
             ::core::stringify!(transfer),
-            ::core::stringify!(getAuthorizer),
             ::core::stringify!(permit),
-            ::core::stringify!(onJoinPool),
             ::core::stringify!(allowance),
-            ::core::stringify!(stopAmplificationParameterUpdate),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -8489,7 +3818,7 @@ pub mod BalancerV2StablePool {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2StablePoolCalls {
-        const COUNT: usize = 34usize;
+        const COUNT: usize = 15usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2StablePoolCalls";
 
@@ -8503,51 +3832,20 @@ pub mod BalancerV2StablePool {
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseAllowance(_) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getAmplificationParameter(_) => {
                     <getAmplificationParameterCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getPausedState(_) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getSwapFeePercentage(_) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::increaseAllowance(_) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onSwap_0(_) => <onSwap_0Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onSwap_1(_) => <onSwap_1Call as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setAssetManagerPoolConfig(_) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setSwapFeePercentage(_) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::startAmplificationParameterUpdate(_) => {
-                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::stopAmplificationParameterUpdate(_) => {
-                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -8570,13 +3868,6 @@ pub mod BalancerV2StablePool {
                 &[u8],
             )
                 -> alloy_sol_types::Result<BalancerV2StablePoolCalls>] = &[
-                {
-                    fn onSwap_0(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onSwap_0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::onSwap_0)
-                    }
-                    onSwap_0
-                },
                 {
                     fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8591,24 +3882,6 @@ pub mod BalancerV2StablePool {
                     }
                     approve
                 },
-                {
-                    fn setPaused(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -8627,19 +3900,6 @@ pub mod BalancerV2StablePool {
                     }
                     transferFrom
                 },
-                {
-                    fn startAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2StablePoolCalls::startAmplificationParameterUpdate,
-                            )
-                    }
-                    startAmplificationParameterUpdate
-                },
                 {
                     fn decimals(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8656,15 +3916,6 @@ pub mod BalancerV2StablePool {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
                 {
                     fn getPoolId(
                         data: &[u8],
@@ -8674,26 +3925,6 @@ pub mod BalancerV2StablePool {
                     }
                     getPoolId
                 },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
-                {
-                    fn setAssetManagerPoolConfig(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2StablePoolCalls::setAssetManagerPoolConfig)
-                    }
-                    setAssetManagerPoolConfig
-                },
                 {
                     fn getSwapFeePercentage(
                         data: &[u8],
@@ -8703,22 +3934,6 @@ pub mod BalancerV2StablePool {
                     }
                     getSwapFeePercentage
                 },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn getRate(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::getRate)
-                    }
-                    getRate
-                },
                 {
                     fn getAmplificationParameter(
                         data: &[u8],
@@ -8739,15 +3954,6 @@ pub mod BalancerV2StablePool {
                     }
                     balanceOf
                 },
-                {
-                    fn onExitPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8755,38 +3961,6 @@ pub mod BalancerV2StablePool {
                     }
                     nonces
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn queryJoin(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::getOwner)
-                    }
-                    getOwner
-                },
-                {
-                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::getVault)
-                    }
-                    getVault
-                },
                 {
                     fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8794,22 +3968,6 @@ pub mod BalancerV2StablePool {
                     }
                     symbol
                 },
-                {
-                    fn onSwap_1(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onSwap_1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::onSwap_1)
-                    }
-                    onSwap_1
-                },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8817,15 +3975,6 @@ pub mod BalancerV2StablePool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8833,15 +3982,6 @@ pub mod BalancerV2StablePool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
                 {
                     fn allowance(
                         data: &[u8],
@@ -8851,19 +3991,6 @@ pub mod BalancerV2StablePool {
                     }
                     allowance
                 },
-                {
-                    fn stopAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2StablePoolCalls::stopAmplificationParameterUpdate,
-                            )
-                    }
-                    stopAmplificationParameterUpdate
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -8885,13 +4012,6 @@ pub mod BalancerV2StablePool {
             ) -> alloy_sol_types::Result<
                 BalancerV2StablePoolCalls,
             >] = &[
-                {
-                    fn onSwap_0(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onSwap_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::onSwap_0)
-                    }
-                    onSwap_0
-                },
                 {
                     fn name(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8906,24 +4026,6 @@ pub mod BalancerV2StablePool {
                     }
                     approve
                 },
-                {
-                    fn setPaused(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -8946,19 +4048,6 @@ pub mod BalancerV2StablePool {
                     }
                     transferFrom
                 },
-                {
-                    fn startAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2StablePoolCalls::startAmplificationParameterUpdate,
-                            )
-                    }
-                    startAmplificationParameterUpdate
-                },
                 {
                     fn decimals(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8977,17 +4066,6 @@ pub mod BalancerV2StablePool {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2StablePoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
                 {
                     fn getPoolId(
                         data: &[u8],
@@ -8997,28 +4075,6 @@ pub mod BalancerV2StablePool {
                     }
                     getPoolId
                 },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2StablePoolCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
-                {
-                    fn setAssetManagerPoolConfig(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2StablePoolCalls::setAssetManagerPoolConfig)
-                    }
-                    setAssetManagerPoolConfig
-                },
                 {
                     fn getSwapFeePercentage(
                         data: &[u8],
@@ -9030,22 +4086,6 @@ pub mod BalancerV2StablePool {
                     }
                     getSwapFeePercentage
                 },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn getRate(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::getRate)
-                    }
-                    getRate
-                },
                 {
                     fn getAmplificationParameter(
                         data: &[u8],
@@ -9066,15 +4106,6 @@ pub mod BalancerV2StablePool {
                     }
                     balanceOf
                 },
-                {
-                    fn onExitPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -9082,38 +4113,6 @@ pub mod BalancerV2StablePool {
                     }
                     nonces
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn queryJoin(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn getOwner(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::getOwner)
-                    }
-                    getOwner
-                },
-                {
-                    fn getVault(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::getVault)
-                    }
-                    getVault
-                },
                 {
                     fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -9121,24 +4120,6 @@ pub mod BalancerV2StablePool {
                     }
                     symbol
                 },
-                {
-                    fn onSwap_1(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onSwap_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::onSwap_1)
-                    }
-                    onSwap_1
-                },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2StablePoolCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -9146,17 +4127,6 @@ pub mod BalancerV2StablePool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2StablePoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -9164,15 +4134,6 @@ pub mod BalancerV2StablePool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
                 {
                     fn allowance(
                         data: &[u8],
@@ -9182,19 +4143,6 @@ pub mod BalancerV2StablePool {
                     }
                     allowance
                 },
-                {
-                    fn stopAmplificationParameterUpdate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolCalls> {
-                        <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2StablePoolCalls::stopAmplificationParameterUpdate,
-                            )
-                    }
-                    stopAmplificationParameterUpdate
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -9209,9 +4157,7 @@ pub mod BalancerV2StablePool {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::DOMAIN_SEPARATOR(inner) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
@@ -9225,52 +4171,19 @@ pub mod BalancerV2StablePool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::getAmplificationParameter(inner) => {
                     <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encoded_size(
                         inner,
                     )
                 }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPausedState(inner) => {
-                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::getPoolId(inner) => {
                     <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getSwapFeePercentage(inner) => {
-                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
@@ -9278,65 +4191,17 @@ pub mod BalancerV2StablePool {
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onSwap_0(inner) => {
-                    <onSwap_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onSwap_1(inner) => {
-                    <onSwap_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setAssetManagerPoolConfig(inner) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::startAmplificationParameterUpdate(inner) => {
-                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::stopAmplificationParameterUpdate(inner) => {
-                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::transferFrom(inner) => {
-                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
             }
         }
@@ -9345,93 +4210,34 @@ pub mod BalancerV2StablePool {
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
                 Self::DOMAIN_SEPARATOR(inner) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::allowance(inner) => {
-                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::approve(inner) => {
                     <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::balanceOf(inner) => {
-                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::decimals(inner) => {
-                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::getAmplificationParameter(inner) => {
                     <getAmplificationParameterCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
                 Self::getPausedState(inner) => {
-                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::getPoolId(inner) => {
-                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                    <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::getSwapFeePercentage(inner) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
                 Self::name(inner) => {
@@ -9440,95 +4246,17 @@ pub mod BalancerV2StablePool {
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::onSwap_0(inner) => {
-                    <onSwap_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::onSwap_1(inner) => {
-                    <onSwap_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::setAssetManagerPoolConfig(inner) => {
-                    <setAssetManagerPoolConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::startAmplificationParameterUpdate(inner) => {
-                    <startAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::stopAmplificationParameterUpdate(inner) => {
-                    <stopAmplificationParameterUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::transfer(inner) => {
-                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::transferFrom(inner) => {
-                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
             }
         }
@@ -9867,23 +4595,6 @@ pub mod BalancerV2StablePool {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`decreaseAllowance`] function.
-        pub fn decreaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            amount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
-            self.call_builder(&decreaseAllowanceCall { spender, amount })
-        }
-
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
         ///Creates a new call builder for the [`getAmplificationParameter`]
         /// function.
         pub fn getAmplificationParameter(
@@ -9892,16 +4603,6 @@ pub mod BalancerV2StablePool {
             self.call_builder(&getAmplificationParameterCall)
         }
 
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getOwner`] function.
-        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
-            self.call_builder(&getOwnerCall)
-        }
-
         ///Creates a new call builder for the [`getPausedState`] function.
         pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
             self.call_builder(&getPausedStateCall)
@@ -9912,11 +4613,6 @@ pub mod BalancerV2StablePool {
             self.call_builder(&getPoolIdCall)
         }
 
-        ///Creates a new call builder for the [`getRate`] function.
-        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
-            self.call_builder(&getRateCall)
-        }
-
         ///Creates a new call builder for the [`getSwapFeePercentage`]
         /// function.
         pub fn getSwapFeePercentage(
@@ -9925,23 +4621,6 @@ pub mod BalancerV2StablePool {
             self.call_builder(&getSwapFeePercentageCall)
         }
 
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`increaseAllowance`] function.
-        pub fn increaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            addedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
-            self.call_builder(&increaseAllowanceCall {
-                spender,
-                addedValue,
-            })
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -9955,86 +4634,6 @@ pub mod BalancerV2StablePool {
             self.call_builder(&noncesCall { owner })
         }
 
-        ///Creates a new call builder for the [`onExitPool`] function.
-        pub fn onExitPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
-            self.call_builder(&onExitPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onJoinPool`] function.
-        pub fn onJoinPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
-            self.call_builder(&onJoinPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onSwap_0`] function.
-        pub fn onSwap_0(
-            &self,
-            swapRequest: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            indexIn: alloy_sol_types::private::primitives::aliases::U256,
-            indexOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, onSwap_0Call, N> {
-            self.call_builder(&onSwap_0Call {
-                swapRequest,
-                balances,
-                indexIn,
-                indexOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`onSwap_1`] function.
-        pub fn onSwap_1(
-            &self,
-            request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-            balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
-            balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, onSwap_1Call, N> {
-            self.call_builder(&onSwap_1Call {
-                request,
-                balanceTokenIn,
-                balanceTokenOut,
-            })
-        }
-
         ///Creates a new call builder for the [`permit`] function.
         pub fn permit(
             &self,
@@ -10057,112 +4656,11 @@ pub mod BalancerV2StablePool {
             })
         }
 
-        ///Creates a new call builder for the [`queryExit`] function.
-        pub fn queryExit(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
-            self.call_builder(&queryExitCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryJoin`] function.
-        pub fn queryJoin(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
-            self.call_builder(&queryJoinCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`setAssetManagerPoolConfig`]
-        /// function.
-        pub fn setAssetManagerPoolConfig(
-            &self,
-            token: alloy_sol_types::private::Address,
-            poolConfig: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, setAssetManagerPoolConfigCall, N> {
-            self.call_builder(&setAssetManagerPoolConfigCall { token, poolConfig })
-        }
-
-        ///Creates a new call builder for the [`setPaused`] function.
-        pub fn setPaused(
-            &self,
-            paused: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
-            self.call_builder(&setPausedCall { paused })
-        }
-
-        ///Creates a new call builder for the [`setSwapFeePercentage`]
-        /// function.
-        pub fn setSwapFeePercentage(
-            &self,
-            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
-            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
-        }
-
-        ///Creates a new call builder for the
-        /// [`startAmplificationParameterUpdate`] function.
-        pub fn startAmplificationParameterUpdate(
-            &self,
-            rawEndValue: alloy_sol_types::private::primitives::aliases::U256,
-            endTime: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, startAmplificationParameterUpdateCall, N> {
-            self.call_builder(&startAmplificationParameterUpdateCall {
-                rawEndValue,
-                endTime,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`stopAmplificationParameterUpdate`] function.
-        pub fn stopAmplificationParameterUpdate(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, stopAmplificationParameterUpdateCall, N> {
-            self.call_builder(&stopAmplificationParameterUpdateCall)
-        }
-
         ///Creates a new call builder for the [`symbol`] function.
         pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs b/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs
index 06b62741ce..a5a8161061 100644
--- a/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2stablepoolfactoryv2/src/lib.rs
@@ -18,14 +18,6 @@ interface BalancerV2StablePoolFactoryV2 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256 amplificationParameter, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
 }
 ```
 
@@ -94,132 +86,6 @@ interface BalancerV2StablePoolFactoryV2 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "FactoryDisabled",
@@ -856,1278 +722,76 @@ pub mod BalancerV2StablePoolFactoryV2 {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
-    ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2StablePoolFactoryV2`](self) function
+    /// calls.
     #[derive(Clone)]
-    pub struct getActionIdCall {
+    pub enum BalancerV2StablePoolFactoryV2Calls {
         #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdReturn {
+        create(createCall),
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        disable(disableCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+    impl BalancerV2StablePoolFactoryV2Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[47u8, 39u8, 112u8, 219u8], [121u8, 50u8, 199u8, 243u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] =
+            &[::core::stringify!(disable), ::core::stringify!(create)];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
 
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BalancerV2StablePoolFactoryV2Calls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BalancerV2StablePoolFactoryV2Calls";
 
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
             }
+        }
 
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
 
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2StablePoolFactoryV2`](self) function
-    /// calls.
-    #[derive(Clone)]
-    pub enum BalancerV2StablePoolFactoryV2Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-    }
-    impl BalancerV2StablePoolFactoryV2Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [121u8, 50u8, 199u8, 243u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(create),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
-            }
-        }
-
-        /// Returns the enum variant name for the given selector, if known.
-        #[inline]
-        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
-            let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for BalancerV2StablePoolFactoryV2Calls {
-        const COUNT: usize = 10usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "BalancerV2StablePoolFactoryV2Calls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
         }
 
         #[inline]
@@ -2138,40 +802,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
             ) -> alloy_sol_types::Result<
                 BalancerV2StablePoolFactoryV2Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2StablePoolFactoryV2Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2StablePoolFactoryV2Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2182,26 +812,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
                     }
                     disable
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::isDisabled)
-                    }
-                    isDisabled
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2212,36 +822,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
                     }
                     create
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2263,46 +843,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
             ) -> alloy_sol_types::Result<
                 BalancerV2StablePoolFactoryV2Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2StablePoolFactoryV2Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2StablePoolFactoryV2Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2StablePoolFactoryV2Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2313,28 +853,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
                     }
                     disable
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2StablePoolFactoryV2Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::isDisabled)
-                    }
-                    isDisabled
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2345,38 +863,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
                     }
                     create
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2StablePoolFactoryV2Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2StablePoolFactoryV2Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2StablePoolFactoryV2Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2396,32 +882,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -2434,34 +894,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -2711,60 +1143,6 @@ pub mod BalancerV2StablePoolFactoryV2 {
         pub fn disable(&self) -> alloy_contract::SolCallBuilder<&P, disableCall, N> {
             self.call_builder(&disableCall)
         }
-
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs b/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs
index 6c561d4062..7001682f53 100644
--- a/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2vault/src/lib.rs
@@ -11,15 +11,11 @@
 
 ```solidity
 library IVault {
-    type PoolBalanceOpKind is uint8;
     type PoolSpecialization is uint8;
     type SwapKind is uint8;
     type UserBalanceOpKind is uint8;
     struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; }
-    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
     struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
-    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
-    struct PoolBalanceOp { PoolBalanceOpKind kind; bytes32 poolId; address token; uint256 amount; }
     struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
     struct UserBalanceOp { UserBalanceOpKind kind; address asset; uint256 amount; address sender; address recipient; }
 }
@@ -36,140 +32,6 @@ pub mod IVault {
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct PoolBalanceOpKind(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<PoolBalanceOpKind> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl PoolBalanceOpKind {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for PoolBalanceOpKind {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<PoolBalanceOpKind> for u8 {
-            fn from(value: PoolBalanceOpKind) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PoolBalanceOpKind {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PoolBalanceOpKind {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
     pub struct PoolSpecialization(u8);
     const _: () = {
         use alloy_sol_types;
@@ -859,18 +721,17 @@ pub mod IVault {
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct ExitPoolRequest { address[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; }
+    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ExitPoolRequest {
+    pub struct FundManagement {
         #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub sender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub minAmountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub fromInternalBalance: bool,
         #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
+        pub recipient: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
         pub toInternalBalance: bool,
     }
@@ -885,16 +746,16 @@ pub mod IVault {
         #[doc(hidden)]
         #[allow(dead_code)]
         type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            alloy_sol_types::sol_data::Bytes,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Address,
             alloy_sol_types::sol_data::Bool,
         );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            alloy_sol_types::private::Bytes,
+            alloy_sol_types::private::Address,
+            bool,
+            alloy_sol_types::private::Address,
             bool,
         );
         #[cfg(test)]
@@ -908,45 +769,45 @@ pub mod IVault {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<ExitPoolRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: ExitPoolRequest) -> Self {
+        impl ::core::convert::From<FundManagement> for UnderlyingRustTuple<'_> {
+            fn from(value: FundManagement) -> Self {
                 (
-                    value.assets,
-                    value.minAmountsOut,
-                    value.userData,
+                    value.sender,
+                    value.fromInternalBalance,
+                    value.recipient,
                     value.toInternalBalance,
                 )
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExitPoolRequest {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FundManagement {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    assets: tuple.0,
-                    minAmountsOut: tuple.1,
-                    userData: tuple.2,
+                    sender: tuple.0,
+                    fromInternalBalance: tuple.1,
+                    recipient: tuple.2,
                     toInternalBalance: tuple.3,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for ExitPoolRequest {
+        impl alloy_sol_types::SolValue for FundManagement {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for ExitPoolRequest {
+        impl alloy_sol_types::private::SolTypeValue<Self> for FundManagement {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minAmountsOut),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.fromInternalBalance,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
                     ),
                     <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
                         &self.toInternalBalance,
@@ -991,7 +852,7 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for ExitPoolRequest {
+        impl alloy_sol_types::SolType for FundManagement {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -1013,14 +874,14 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for ExitPoolRequest {
-            const NAME: &'static str = "ExitPoolRequest";
+        impl alloy_sol_types::SolStruct for FundManagement {
+            const NAME: &'static str = "FundManagement";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "ExitPoolRequest(address[] assets,uint256[] minAmountsOut,bytes userData,bool \
-                     toInternalBalance)",
+                    "FundManagement(address sender,bool fromInternalBalance,address \
+                     recipient,bool toInternalBalance)",
                 )
             }
 
@@ -1039,16 +900,16 @@ pub mod IVault {
             #[inline]
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
                         .0,
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minAmountsOut)
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.fromInternalBalance,
+                        )
                         .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
                         )
                         .0,
                     <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
@@ -1060,22 +921,18 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for ExitPoolRequest {
+        impl alloy_sol_types::EventTopic for FundManagement {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assets,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
                     )
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.minAmountsOut,
+                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.fromInternalBalance,
                     )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
                     )
                     + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
                         &rust.toInternalBalance,
@@ -1088,20 +945,16 @@ pub mod IVault {
                 out: &mut alloy_sol_types::private::Vec<u8>,
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assets,
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
                     out,
                 );
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.minAmountsOut,
+                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.fromInternalBalance,
                     out,
                 );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
                     out,
                 );
                 <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
@@ -1120,19 +973,23 @@ pub mod IVault {
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct FundManagement { address sender; bool fromInternalBalance; address recipient; bool toInternalBalance; }
+    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct FundManagement {
+    pub struct SingleSwap {
         #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub fromInternalBalance: bool,
+        pub kind: <SwapKind as alloy_sol_types::SolType>::RustType,
         #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
+        pub assetIn: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub toInternalBalance: bool,
+        pub assetOut: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
     }
     #[allow(
         non_camel_case_types,
@@ -1145,17 +1002,21 @@ pub mod IVault {
         #[doc(hidden)]
         #[allow(dead_code)]
         type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            SwapKind,
             alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bool,
             alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bool,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Bytes,
         );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::FixedBytes<32>,
+            <SwapKind as alloy_sol_types::SolType>::RustType,
             alloy_sol_types::private::Address,
-            bool,
             alloy_sol_types::private::Address,
-            bool,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Bytes,
         );
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
@@ -1168,48 +1029,56 @@ pub mod IVault {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<FundManagement> for UnderlyingRustTuple<'_> {
-            fn from(value: FundManagement) -> Self {
+        impl ::core::convert::From<SingleSwap> for UnderlyingRustTuple<'_> {
+            fn from(value: SingleSwap) -> Self {
                 (
-                    value.sender,
-                    value.fromInternalBalance,
-                    value.recipient,
-                    value.toInternalBalance,
+                    value.poolId,
+                    value.kind,
+                    value.assetIn,
+                    value.assetOut,
+                    value.amount,
+                    value.userData,
                 )
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FundManagement {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SingleSwap {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    sender: tuple.0,
-                    fromInternalBalance: tuple.1,
-                    recipient: tuple.2,
-                    toInternalBalance: tuple.3,
+                    poolId: tuple.0,
+                    kind: tuple.1,
+                    assetIn: tuple.2,
+                    assetOut: tuple.3,
+                    amount: tuple.4,
+                    userData: tuple.5,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for FundManagement {
+        impl alloy_sol_types::SolValue for SingleSwap {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for FundManagement {
+        impl alloy_sol_types::private::SolTypeValue<Self> for SingleSwap {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    <SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.fromInternalBalance,
+                        &self.assetIn,
                     ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
+                        &self.assetOut,
                     ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.toInternalBalance,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
                     ),
                 )
             }
@@ -1251,7 +1120,7 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for FundManagement {
+        impl alloy_sol_types::SolType for SingleSwap {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -1273,14 +1142,14 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for FundManagement {
-            const NAME: &'static str = "FundManagement";
+        impl alloy_sol_types::SolStruct for SingleSwap {
+            const NAME: &'static str = "SingleSwap";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "FundManagement(address sender,bool fromInternalBalance,address \
-                     recipient,bool toInternalBalance)",
+                    "SingleSwap(bytes32 poolId,uint8 kind,address assetIn,address \
+                     assetOut,uint256 amount,bytes userData)",
                 )
             }
 
@@ -1299,20 +1168,26 @@ pub mod IVault {
             #[inline]
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
                         .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.fromInternalBalance,
+                    <SwapKind as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.assetIn,
                         )
                         .0,
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.recipient,
+                            &self.assetOut,
                         )
                         .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.toInternalBalance,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.userData,
                         )
                         .0,
                 ]
@@ -1320,21 +1195,31 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for FundManagement {
+        impl alloy_sol_types::EventTopic for SingleSwap {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.poolId,
                     )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.fromInternalBalance,
+                    + <SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
                     )
                     + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.recipient,
+                        &rust.assetIn,
                     )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.toInternalBalance,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.assetOut,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.amount,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.userData,
                     )
             }
 
@@ -1344,20 +1229,29 @@ pub mod IVault {
                 out: &mut alloy_sol_types::private::Vec<u8>,
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.poolId,
                     out,
                 );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.fromInternalBalance,
+                <SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.kind, out);
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.assetIn,
                     out,
                 );
                 <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.recipient,
+                    &rust.assetOut,
                     out,
                 );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.toInternalBalance,
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.amount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.userData,
                     out,
                 );
             }
@@ -1372,20 +1266,21 @@ pub mod IVault {
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct JoinPoolRequest { address[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; }
+    struct UserBalanceOp { UserBalanceOpKind kind; address asset; uint256 amount; address sender; address recipient; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct JoinPoolRequest {
+    pub struct UserBalanceOp {
         #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub kind: <UserBalanceOpKind as alloy_sol_types::SolType>::RustType,
         #[allow(missing_docs)]
-        pub maxAmountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub asset: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub fromInternalBalance: bool,
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -1398,17 +1293,19 @@ pub mod IVault {
         #[doc(hidden)]
         #[allow(dead_code)]
         type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            alloy_sol_types::sol_data::Bytes,
-            alloy_sol_types::sol_data::Bool,
+            UserBalanceOpKind,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<256>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
         );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            alloy_sol_types::private::Bytes,
-            bool,
+            <UserBalanceOpKind as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::primitives::aliases::U256,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
         );
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
@@ -1421,48 +1318,51 @@ pub mod IVault {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<JoinPoolRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: JoinPoolRequest) -> Self {
+        impl ::core::convert::From<UserBalanceOp> for UnderlyingRustTuple<'_> {
+            fn from(value: UserBalanceOp) -> Self {
                 (
-                    value.assets,
-                    value.maxAmountsIn,
-                    value.userData,
-                    value.fromInternalBalance,
+                    value.kind,
+                    value.asset,
+                    value.amount,
+                    value.sender,
+                    value.recipient,
                 )
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for JoinPoolRequest {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UserBalanceOp {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    assets: tuple.0,
-                    maxAmountsIn: tuple.1,
-                    userData: tuple.2,
-                    fromInternalBalance: tuple.3,
+                    kind: tuple.0,
+                    asset: tuple.1,
+                    amount: tuple.2,
+                    sender: tuple.3,
+                    recipient: tuple.4,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for JoinPoolRequest {
+        impl alloy_sol_types::SolValue for UserBalanceOp {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for JoinPoolRequest {
+        impl alloy_sol_types::private::SolTypeValue<Self> for UserBalanceOp {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.maxAmountsIn),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
+                    <UserBalanceOpKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.asset,
                     ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.fromInternalBalance,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
                     ),
                 )
             }
@@ -1504,7 +1404,7 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for JoinPoolRequest {
+        impl alloy_sol_types::SolType for UserBalanceOp {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -1526,14 +1426,14 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for JoinPoolRequest {
-            const NAME: &'static str = "JoinPoolRequest";
+        impl alloy_sol_types::SolStruct for UserBalanceOp {
+            const NAME: &'static str = "UserBalanceOp";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "JoinPoolRequest(address[] assets,uint256[] maxAmountsIn,bytes userData,bool \
-                     fromInternalBalance)",
+                    "UserBalanceOp(uint8 kind,address asset,uint256 amount,address sender,address \
+                     recipient)",
                 )
             }
 
@@ -1552,20 +1452,24 @@ pub mod IVault {
             #[inline]
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.assets)
+                    <UserBalanceOpKind as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.kind,
+                        )
                         .0,
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxAmountsIn)
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.asset,
+                        )
                         .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
                         )
                         .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.fromInternalBalance,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.recipient,
                         )
                         .0,
                 ]
@@ -1573,25 +1477,26 @@ pub mod IVault {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for JoinPoolRequest {
+        impl alloy_sol_types::EventTopic for UserBalanceOp {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assets,
+                    + <UserBalanceOpKind as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.kind,
                     )
-                    + <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.asset,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
                     > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maxAmountsIn,
+                        &rust.amount,
                     )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
                     )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.fromInternalBalance,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.recipient,
                     )
             }
 
@@ -1601,24 +1506,25 @@ pub mod IVault {
                 out: &mut alloy_sol_types::private::Vec<u8>,
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assets,
+                <UserBalanceOpKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.kind, out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.asset,
                     out,
                 );
-                <alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
+                <alloy_sol_types::sol_data::Uint<
+                    256,
                 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maxAmountsIn,
+                    &rust.amount,
                     out,
                 );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
                     out,
                 );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.fromInternalBalance,
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.recipient,
                     out,
                 );
             }
@@ -1631,4622 +1537,999 @@ pub mod IVault {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct PoolBalanceOp { PoolBalanceOpKind kind; bytes32 poolId; address token; uint256 amount; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct PoolBalanceOp {
-        #[allow(missing_docs)]
-        pub kind: <PoolBalanceOpKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            PoolBalanceOpKind,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <PoolBalanceOpKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<PoolBalanceOp> for UnderlyingRustTuple<'_> {
-            fn from(value: PoolBalanceOp) -> Self {
-                (value.kind, value.poolId, value.token, value.amount)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PoolBalanceOp {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    kind: tuple.0,
-                    poolId: tuple.1,
-                    token: tuple.2,
-                    amount: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for PoolBalanceOp {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for PoolBalanceOp {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <PoolBalanceOpKind as alloy_sol_types::SolType>::tokenize(
-                        &self.kind,
-                    ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                )
-            }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
 
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
+    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IVaultInstance<P, N> {
+        IVaultInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IVault`](self) instance.
 
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IVault`](self) contract located at a given `address`, using a given
+    provider `P`.
 
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
+    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.
 
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IVaultInstance")
+                .field(&self.address)
+                .finish()
         }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PoolBalanceOp {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
 
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
             }
         }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for PoolBalanceOp {
-            const NAME: &'static str = "PoolBalanceOp";
 
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "PoolBalanceOp(uint8 kind,bytes32 poolId,address token,uint256 amount)",
-                )
-            }
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
 
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
 
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
 
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <PoolBalanceOpKind as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.kind,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                ]
-                    .concat()
-            }
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
         }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PoolBalanceOp {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <PoolBalanceOpKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <PoolBalanceOpKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind, out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+    }
+    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
+            IVaultInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
             }
         }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SingleSwap { bytes32 poolId; SwapKind kind; address assetIn; address assetOut; uint256 amount; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SingleSwap {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub kind: <SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub assetIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub assetOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            SwapKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::FixedBytes<32>,
-            <SwapKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SingleSwap> for UnderlyingRustTuple<'_> {
-            fn from(value: SingleSwap) -> Self {
-                (
-                    value.poolId,
-                    value.kind,
-                    value.assetIn,
-                    value.assetOut,
-                    value.amount,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SingleSwap {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    poolId: tuple.0,
-                    kind: tuple.1,
-                    assetIn: tuple.2,
-                    assetOut: tuple.3,
-                    amount: tuple.4,
-                    userData: tuple.5,
-                }
-            }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SingleSwap {
-            type SolType = Self;
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IVaultInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
         }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SingleSwap {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.assetIn,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.assetOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
+    }
+}
+/**
 
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
+Generated by the following Solidity interface...
+```solidity
+library IVault {
+    type PoolSpecialization is uint8;
+    type SwapKind is uint8;
+    type UserBalanceOpKind is uint8;
+    struct BatchSwapStep {
+        bytes32 poolId;
+        uint256 assetInIndex;
+        uint256 assetOutIndex;
+        uint256 amount;
+        bytes userData;
+    }
+    struct FundManagement {
+        address sender;
+        bool fromInternalBalance;
+        address payable recipient;
+        bool toInternalBalance;
+    }
+    struct SingleSwap {
+        bytes32 poolId;
+        SwapKind kind;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+        bytes userData;
+    }
+    struct UserBalanceOp {
+        UserBalanceOpKind kind;
+        address asset;
+        uint256 amount;
+        address sender;
+        address payable recipient;
+    }
+}
 
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
+interface BalancerV2Vault {
+    event AuthorizerChanged(address indexed newAuthorizer);
+    event ExternalBalanceTransfer(address indexed token, address indexed sender, address recipient, uint256 amount);
+    event FlashLoan(address indexed recipient, address indexed token, uint256 amount, uint256 feeAmount);
+    event InternalBalanceChanged(address indexed user, address indexed token, int256 delta);
+    event PausedStateChanged(bool paused);
+    event PoolBalanceChanged(bytes32 indexed poolId, address indexed liquidityProvider, address[] tokens, int256[] deltas, uint256[] protocolFeeAmounts);
+    event PoolBalanceManaged(bytes32 indexed poolId, address indexed assetManager, address indexed token, int256 cashDelta, int256 managedDelta);
+    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, IVault.PoolSpecialization specialization);
+    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
+    event Swap(bytes32 indexed poolId, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
+    event TokensDeregistered(bytes32 indexed poolId, address[] tokens);
+    event TokensRegistered(bytes32 indexed poolId, address[] tokens, address[] assetManagers);
 
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SingleSwap {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+    constructor(address authorizer, address weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
 
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+    receive() external payable;
 
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SingleSwap {
-            const NAME: &'static str = "SingleSwap";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SingleSwap(bytes32 poolId,uint8 kind,address assetIn,address \
-                     assetOut,uint256 amount,bytes userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <SwapKind as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.assetIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.assetOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SingleSwap {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assetIn,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.assetOut,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.kind, out);
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assetIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.assetOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct UserBalanceOp { UserBalanceOpKind kind; address asset; uint256 amount; address sender; address recipient; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct UserBalanceOp {
-        #[allow(missing_docs)]
-        pub kind: <UserBalanceOpKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub asset: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            UserBalanceOpKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <UserBalanceOpKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UserBalanceOp> for UnderlyingRustTuple<'_> {
-            fn from(value: UserBalanceOp) -> Self {
-                (
-                    value.kind,
-                    value.asset,
-                    value.amount,
-                    value.sender,
-                    value.recipient,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UserBalanceOp {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    kind: tuple.0,
-                    asset: tuple.1,
-                    amount: tuple.2,
-                    sender: tuple.3,
-                    recipient: tuple.4,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for UserBalanceOp {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for UserBalanceOp {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <UserBalanceOpKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.asset,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
+    function WETH() external view returns (address);
+    function batchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds, int256[] memory limits, uint256 deadline) external payable returns (int256[] memory assetDeltas);
+    function flashLoan(address recipient, address[] memory tokens, uint256[] memory amounts, bytes memory userData) external;
+    function getInternalBalance(address user, address[] memory tokens) external view returns (uint256[] memory balances);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPool(bytes32 poolId) external view returns (address, IVault.PoolSpecialization);
+    function getPoolTokens(bytes32 poolId) external view returns (address[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+    function hasApprovedRelayer(address user, address relayer) external view returns (bool);
+    function manageUserBalance(IVault.UserBalanceOp[] memory ops) external payable;
+    function setRelayerApproval(address sender, address relayer, bool approved) external;
+    function swap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds, uint256 limit, uint256 deadline) external payable returns (uint256 amountCalculated);
+}
+```
 
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for UserBalanceOp {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for UserBalanceOp {
-            const NAME: &'static str = "UserBalanceOp";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "UserBalanceOp(uint8 kind,address asset,uint256 amount,address sender,address \
-                     recipient)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <UserBalanceOpKind as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.kind,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.asset,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.recipient,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for UserBalanceOp {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <UserBalanceOpKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.asset,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.recipient,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <UserBalanceOpKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind, out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.asset,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.recipient,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IVaultInstance<P, N> {
-        IVaultInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IVault`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IVault`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IVaultInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
-            IVaultInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IVault {
-    type PoolBalanceOpKind is uint8;
-    type PoolSpecialization is uint8;
-    type SwapKind is uint8;
-    type UserBalanceOpKind is uint8;
-    struct BatchSwapStep {
-        bytes32 poolId;
-        uint256 assetInIndex;
-        uint256 assetOutIndex;
-        uint256 amount;
-        bytes userData;
-    }
-    struct ExitPoolRequest {
-        address[] assets;
-        uint256[] minAmountsOut;
-        bytes userData;
-        bool toInternalBalance;
-    }
-    struct FundManagement {
-        address sender;
-        bool fromInternalBalance;
-        address payable recipient;
-        bool toInternalBalance;
-    }
-    struct JoinPoolRequest {
-        address[] assets;
-        uint256[] maxAmountsIn;
-        bytes userData;
-        bool fromInternalBalance;
-    }
-    struct PoolBalanceOp {
-        PoolBalanceOpKind kind;
-        bytes32 poolId;
-        address token;
-        uint256 amount;
-    }
-    struct SingleSwap {
-        bytes32 poolId;
-        SwapKind kind;
-        address assetIn;
-        address assetOut;
-        uint256 amount;
-        bytes userData;
-    }
-    struct UserBalanceOp {
-        UserBalanceOpKind kind;
-        address asset;
-        uint256 amount;
-        address sender;
-        address payable recipient;
-    }
-}
-
-interface BalancerV2Vault {
-    event AuthorizerChanged(address indexed newAuthorizer);
-    event ExternalBalanceTransfer(address indexed token, address indexed sender, address recipient, uint256 amount);
-    event FlashLoan(address indexed recipient, address indexed token, uint256 amount, uint256 feeAmount);
-    event InternalBalanceChanged(address indexed user, address indexed token, int256 delta);
-    event PausedStateChanged(bool paused);
-    event PoolBalanceChanged(bytes32 indexed poolId, address indexed liquidityProvider, address[] tokens, int256[] deltas, uint256[] protocolFeeAmounts);
-    event PoolBalanceManaged(bytes32 indexed poolId, address indexed assetManager, address indexed token, int256 cashDelta, int256 managedDelta);
-    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, IVault.PoolSpecialization specialization);
-    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
-    event Swap(bytes32 indexed poolId, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
-    event TokensDeregistered(bytes32 indexed poolId, address[] tokens);
-    event TokensRegistered(bytes32 indexed poolId, address[] tokens, address[] assetManagers);
-
-    constructor(address authorizer, address weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-
-    receive() external payable;
-
-    function WETH() external view returns (address);
-    function batchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds, int256[] memory limits, uint256 deadline) external payable returns (int256[] memory assetDeltas);
-    function deregisterTokens(bytes32 poolId, address[] memory tokens) external;
-    function exitPool(bytes32 poolId, address sender, address payable recipient, IVault.ExitPoolRequest memory request) external;
-    function flashLoan(address recipient, address[] memory tokens, uint256[] memory amounts, bytes memory userData) external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getDomainSeparator() external view returns (bytes32);
-    function getInternalBalance(address user, address[] memory tokens) external view returns (uint256[] memory balances);
-    function getNextNonce(address user) external view returns (uint256);
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    function getPool(bytes32 poolId) external view returns (address, IVault.PoolSpecialization);
-    function getPoolTokenInfo(bytes32 poolId, address token) external view returns (uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager);
-    function getPoolTokens(bytes32 poolId) external view returns (address[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
-    function getProtocolFeesCollector() external view returns (address);
-    function hasApprovedRelayer(address user, address relayer) external view returns (bool);
-    function joinPool(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external payable;
-    function managePoolBalance(IVault.PoolBalanceOp[] memory ops) external;
-    function manageUserBalance(IVault.UserBalanceOp[] memory ops) external payable;
-    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external view returns (int256[] memory);
-    function registerPool(IVault.PoolSpecialization specialization) external returns (bytes32);
-    function registerTokens(bytes32 poolId, address[] memory tokens, address[] memory assetManagers) external;
-    function setAuthorizer(address newAuthorizer) external;
-    function setPaused(bool paused) external;
-    function setRelayerApproval(address sender, address relayer, bool approved) external;
-    function swap(IVault.SingleSwap memory singleSwap, IVault.FundManagement memory funds, uint256 limit, uint256 deadline) external payable returns (uint256 amountCalculated);
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "constructor",
-    "inputs": [
-      {
-        "name": "authorizer",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      },
-      {
-        "name": "weth",
-        "type": "address",
-        "internalType": "contract IWETH"
-      },
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "receive",
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "WETH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IWETH"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "batchSwap",
-    "inputs": [
-      {
-        "name": "kind",
-        "type": "uint8",
-        "internalType": "enum IVault.SwapKind"
-      },
-      {
-        "name": "swaps",
-        "type": "tuple[]",
-        "internalType": "struct IVault.BatchSwapStep[]",
-        "components": [
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "assetInIndex",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "assetOutIndex",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "assets",
-        "type": "address[]",
-        "internalType": "contract IAsset[]"
-      },
-      {
-        "name": "funds",
-        "type": "tuple",
-        "internalType": "struct IVault.FundManagement",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      },
-      {
-        "name": "limits",
-        "type": "int256[]",
-        "internalType": "int256[]"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "assetDeltas",
-        "type": "int256[]",
-        "internalType": "int256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "deregisterTokens",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "exitPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address payable"
-      },
-      {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IVault.ExitPoolRequest",
-        "components": [
-          {
-            "name": "assets",
-            "type": "address[]",
-            "internalType": "contract IAsset[]"
-          },
-          {
-            "name": "minAmountsOut",
-            "type": "uint256[]",
-            "internalType": "uint256[]"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "flashLoan",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "contract IFlashLoanRecipient"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20[]"
-      },
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getDomainSeparator",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getInternalBalance",
-    "inputs": [
-      {
-        "name": "user",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getNextNonce",
-    "inputs": [
-      {
-        "name": "user",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPausedState",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "pauseWindowEndTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodEndTime",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "uint8",
-        "internalType": "enum IVault.PoolSpecialization"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolTokenInfo",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "contract IERC20"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "cash",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "managed",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "assetManager",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolTokens",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20[]"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeesCollector",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract ProtocolFeesCollector"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "hasApprovedRelayer",
-    "inputs": [
-      {
-        "name": "user",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "relayer",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "joinPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IVault.JoinPoolRequest",
-        "components": [
-          {
-            "name": "assets",
-            "type": "address[]",
-            "internalType": "contract IAsset[]"
-          },
-          {
-            "name": "maxAmountsIn",
-            "type": "uint256[]",
-            "internalType": "uint256[]"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "managePoolBalance",
-    "inputs": [
-      {
-        "name": "ops",
-        "type": "tuple[]",
-        "internalType": "struct IVault.PoolBalanceOp[]",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.PoolBalanceOpKind"
-          },
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "token",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "manageUserBalance",
-    "inputs": [
-      {
-        "name": "ops",
-        "type": "tuple[]",
-        "internalType": "struct IVault.UserBalanceOp[]",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.UserBalanceOpKind"
-          },
-          {
-            "name": "asset",
-            "type": "address",
-            "internalType": "contract IAsset"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "queryBatchSwap",
-    "inputs": [
-      {
-        "name": "kind",
-        "type": "uint8",
-        "internalType": "enum IVault.SwapKind"
-      },
-      {
-        "name": "swaps",
-        "type": "tuple[]",
-        "internalType": "struct IVault.BatchSwapStep[]",
-        "components": [
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "assetInIndex",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "assetOutIndex",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "assets",
-        "type": "address[]",
-        "internalType": "contract IAsset[]"
-      },
-      {
-        "name": "funds",
-        "type": "tuple",
-        "internalType": "struct IVault.FundManagement",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "int256[]",
-        "internalType": "int256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "registerPool",
-    "inputs": [
-      {
-        "name": "specialization",
-        "type": "uint8",
-        "internalType": "enum IVault.PoolSpecialization"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "registerTokens",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20[]"
-      },
-      {
-        "name": "assetManagers",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setAuthorizer",
-    "inputs": [
-      {
-        "name": "newAuthorizer",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setPaused",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setRelayerApproval",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "relayer",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "approved",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swap",
-    "inputs": [
-      {
-        "name": "singleSwap",
-        "type": "tuple",
-        "internalType": "struct IVault.SingleSwap",
-        "components": [
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "assetIn",
-            "type": "address",
-            "internalType": "contract IAsset"
-          },
-          {
-            "name": "assetOut",
-            "type": "address",
-            "internalType": "contract IAsset"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "funds",
-        "type": "tuple",
-        "internalType": "struct IVault.FundManagement",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "fromInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "toInternalBalance",
-            "type": "bool",
-            "internalType": "bool"
-          }
-        ]
-      },
-      {
-        "name": "limit",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountCalculated",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "event",
-    "name": "AuthorizerChanged",
-    "inputs": [
-      {
-        "name": "newAuthorizer",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ExternalBalanceTransfer",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "FlashLoan",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IFlashLoanRecipient"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "feeAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "InternalBalanceChanged",
-    "inputs": [
-      {
-        "name": "user",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "delta",
-        "type": "int256",
-        "indexed": false,
-        "internalType": "int256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PausedStateChanged",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PoolBalanceChanged",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "liquidityProvider",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "indexed": false,
-        "internalType": "contract IERC20[]"
-      },
-      {
-        "name": "deltas",
-        "type": "int256[]",
-        "indexed": false,
-        "internalType": "int256[]"
-      },
-      {
-        "name": "protocolFeeAmounts",
-        "type": "uint256[]",
-        "indexed": false,
-        "internalType": "uint256[]"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PoolBalanceManaged",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "assetManager",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "cashDelta",
-        "type": "int256",
-        "indexed": false,
-        "internalType": "int256"
-      },
-      {
-        "name": "managedDelta",
-        "type": "int256",
-        "indexed": false,
-        "internalType": "int256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PoolRegistered",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "poolAddress",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "specialization",
-        "type": "uint8",
-        "indexed": false,
-        "internalType": "enum IVault.PoolSpecialization"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "RelayerApprovalChanged",
-    "inputs": [
-      {
-        "name": "relayer",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "approved",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Swap",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "tokenIn",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "tokenOut",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TokensDeregistered",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "indexed": false,
-        "internalType": "contract IERC20[]"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TokensRegistered",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "indexed": false,
-        "internalType": "contract IERC20[]"
-      },
-      {
-        "name": "assetManagers",
-        "type": "address[]",
-        "indexed": false,
-        "internalType": "address[]"
-      }
-    ],
-    "anonymous": false
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BalancerV2Vault {
-    use {super::*, alloy_sol_types};
-    /// The creation / init bytecode of the contract.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"a\x01\x80`@R4\x80\x15b\0\0\x12W`\0\x80\xFD[P`@Qb\0n\xD68\x03\x80b\0n\xD6\x839\x81\x01`@\x81\x90Rb\0\x005\x91b\0\x02SV[\x83\x82\x82`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01p\x10\x98[\x18[\x98\xD9\\\x88\x15\x8C\x88\x15\x98][\x1D`z\x1B\x81RP\x80`@Q\x80`@\x01`@R\x80`\x01\x81R` \x01`1`\xF8\x1B\x81RP0`\x01`\x01`\xA0\x1B\x03\x16`\0\x1B\x89\x80`\x01`\x01`\xA0\x1B\x03\x16`\x80\x81`\x01`\x01`\xA0\x1B\x03\x16``\x1B\x81RPPP0`@Qb\0\0\xB8\x90b\0\x02EV[b\0\0\xC4\x91\x90b\0\x02\x9FV[`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15b\0\0\xE1W=`\0\x80>=`\0\xFD[P``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0R`\x01`\0U`\xC0R\x81Q` \x92\x83\x01 `\xE0R\x80Q\x91\x01 a\x01\0RP\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0Fa\x01 Rb\0\x01Hbv\xA7\0\x83\x11\x15a\x01\x94b\0\x01\x81V[b\0\x01\\b'\x8D\0\x82\x11\x15a\x01\x95b\0\x01\x81V[B\x90\x91\x01a\x01@\x81\x90R\x01a\x01`Rb\0\x01v\x81b\0\x01\x96V[PPPPPb\0\x02\xCCV[\x81b\0\x01\x92Wb\0\x01\x92\x81b\0\x01\xF2V[PPV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\x94\xB9y\xB6\x83\x1AQ)>&ABo\x97t\x7F\xEE\xD4o\x17w\x9F\xED\x9C\xD1\x8D\x1E\xCE\xFC\xFE\x92\xEF\x90`\0\x90\xA2`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16a\x01\0\x02a\x01\0`\x01`\xA8\x1B\x03\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[a\x0B\xE6\x80b\0b\xF0\x839\x01\x90V[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15b\0\x02iW\x83\x84\xFD[\x84Qb\0\x02v\x81b\0\x02\xB3V[` \x86\x01Q\x90\x94Pb\0\x02\x89\x81b\0\x02\xB3V[`@\x86\x01Q``\x90\x96\x01Q\x94\x97\x90\x96P\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x02\xC9W`\0\x80\xFD[PV[`\x80Q``\x1C`\xA0Q``\x1C`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa_\xC0b\0\x030`\09\x80a\x1A\xEDRP\x80a\x1A\xC9RP\x80a(\x9FRP\x80a(\xE1RP\x80a(\xC0RP\x80a\x10\xFDRP\x80a\x13\xB1RP\x80a\x05(RPa_\xC0`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\xA5W`\x005`\xE0\x1C\x80c\x94[\xCE\xC9\x11a\0\xE1W\x80c\xE6\xC4`\x92\x11a\0\x8AW\x80c\xF8M\x06n\x11a\0dW\x80c\xF8M\x06n\x14a\x04\x8AW\x80c\xF9MFh\x14a\x04\xAAW\x80c\xFAng\x1D\x14a\x04\xD9W\x80c\xFE\xC9\rr\x14a\x04\xF9Wa\x01\xD3V[\x80c\xE6\xC4`\x92\x14a\x04'W\x80c\xED$\x91\x1D\x14a\x04GW\x80c\xF6\xC0\t'\x14a\x04\\Wa\x01\xD3V[\x80c\xB0_\x8EH\x11a\0\xBBW\x80c\xB0_\x8EH\x14a\x03\xCFW\x80c\xB9\\\xAC(\x14a\x03\xFFW\x80c\xD2\x94l+\x14a\x04\x12Wa\x01\xD3V[\x80c\x94[\xCE\xC9\x14a\x03\x85W\x80c\xAA\xAB\xAD\xC5\x14a\x03\x98W\x80c\xAD\\FH\x14a\x03\xBAWa\x01\xD3V[\x80cR\xBB\xBE)\x11a\x01NW\x80c}:\xEB\x96\x11a\x01(W\x80c}:\xEB\x96\x14a\x03\x05W\x80c\x85\x1C\x1B\xB3\x14a\x03%W\x80c\x8B\xDB9\x13\x14a\x03EW\x80c\x90\x19;|\x14a\x03eWa\x01\xD3V[\x80cR\xBB\xBE)\x14a\x02\xB2W\x80c\\8D\x9E\x14a\x02\xC5W\x80cf\xA9\xC7\xD2\x14a\x02\xE5Wa\x01\xD3V[\x80c\x0FZn\xFA\x11a\x01\x7FW\x80c\x0FZn\xFA\x14a\x02AW\x80c\x16\xC3\x8B<\x14a\x02nW\x80c\x1C\r\xE0Q\x14a\x02\x8EWa\x01\xD3V[\x80c\x05\x8Ab\x8F\x14a\x01\xD8W\x80c\t\xB2v\x0F\x14a\x01\xF8W\x80c\x0E\x8E>\x84\x14a\x02.Wa\x01\xD3V[6a\x01\xD3Wa\x01\xD1a\x01\xB5a\x05&V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x06a\x05KV[\0[`\0\x80\xFD[4\x80\x15a\x01\xE4W`\0\x80\xFD[Pa\x01\xD1a\x01\xF36`\x04aQWV[a\x05]V[4\x80\x15a\x02\x04W`\0\x80\xFD[Pa\x02\x18a\x02\x136`\x04aV\xE6V[a\x05\x81V[`@Qa\x02%\x91\x90a]>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xD1a\x02<6`\x04aS\x1EV[a\x064V[4\x80\x15a\x02MW`\0\x80\xFD[Pa\x02aa\x02\\6`\x04aQ\xF5V[a\x07pV[`@Qa\x02%\x91\x90a]\x08V[4\x80\x15a\x02zW`\0\x80\xFD[Pa\x01\xD1a\x02\x896`\x04aT\\V[a\x08\x06V[4\x80\x15a\x02\x9AW`\0\x80\xFD[Pa\x02\xA3a\x08\x1FV[`@Qa\x02%\x93\x92\x91\x90a]&V[a\x02\x18a\x02\xC06`\x04aX\x8FV[a\x08HV[4\x80\x15a\x02\xD1W`\0\x80\xFD[Pa\x01\xD1a\x02\xE06`\x04aV[V[a\t\xE9V[4\x80\x15a\x02\xF1W`\0\x80\xFD[Pa\x01\xD1a\x03\x006`\x04aUEV[a\x0E\x06V[4\x80\x15a\x03\x11W`\0\x80\xFD[Pa\x01\xD1a\x03 6`\x04aU\x16V[a\x0F\xA5V[4\x80\x15a\x031W`\0\x80\xFD[Pa\x02\x18a\x03@6`\x04aV3V[a\x10\xF9V[4\x80\x15a\x03QW`\0\x80\xFD[Pa\x01\xD1a\x03`6`\x04aT\xACV[a\x11KV[4\x80\x15a\x03qW`\0\x80\xFD[Pa\x02\x18a\x03\x806`\x04aQWV[a\x11aV[a\x02aa\x03\x936`\x04aW\x86V[a\x11|V[4\x80\x15a\x03\xA4W`\0\x80\xFD[Pa\x03\xADa\x12\xB0V[`@Qa\x02%\x91\x90a[cV[4\x80\x15a\x03\xC6W`\0\x80\xFD[Pa\x03\xADa\x12\xC4V[4\x80\x15a\x03\xDBW`\0\x80\xFD[Pa\x03\xEFa\x03\xEA6`\x04aV\x0FV[a\x12\xD3V[`@Qa\x02%\x94\x93\x92\x91\x90a^\xB9V[a\x01\xD1a\x04\r6`\x04aT\xACV[a\x13\x96V[4\x80\x15a\x04\x1EW`\0\x80\xFD[Pa\x03\xADa\x13\xAFV[4\x80\x15a\x043W`\0\x80\xFD[Pa\x01\xD1a\x04B6`\x04aRCV[a\x13\xD3V[4\x80\x15a\x04SW`\0\x80\xFD[Pa\x02\x18a\x14\xEFV[4\x80\x15a\x04hW`\0\x80\xFD[Pa\x04|a\x04w6`\x04aT\x94V[a\x14\xF9V[`@Qa\x02%\x92\x91\x90a[\x9BV[4\x80\x15a\x04\x96W`\0\x80\xFD[Pa\x02aa\x04\xA56`\x04aW\x02V[a\x15#V[4\x80\x15a\x04\xB6W`\0\x80\xFD[Pa\x04\xCAa\x04\xC56`\x04aT\x94V[a\x16 V[`@Qa\x02%\x93\x92\x91\x90a\\\xD2V[4\x80\x15a\x04\xE5W`\0\x80\xFD[Pa\x01\xD1a\x04\xF46`\x04aQ\xABV[a\x16TV[4\x80\x15a\x05\x05W`\0\x80\xFD[Pa\x05\x19a\x05\x146`\x04aQsV[a\x16\xE6V[`@Qa\x02%\x91\x90a]\x1BV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0[\x90V[\x81a\x05YWa\x05Y\x81a\x16\xFBV[PPV[a\x05ea\x17hV[a\x05ma\x17\x81V[a\x05v\x81a\x17\xAFV[a\x05~a\x18\"V[PV[`\0a\x05\x8Ba\x17hV[a\x05\x93a\x18)V[`\0a\x05\xA23\x84`\x06Ta\x18>V[`\0\x81\x81R`\x05` R`@\x90 T\x90\x91Pa\x05\xC4\x90`\xFF\x16\x15a\x01\xF4a\x05KV[`\0\x81\x81R`\x05` R`@\x90\x81\x90 \x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91U`\x06\x80T\x90\x91\x01\x90UQ3\x90\x82\x90\x7F<\x13\xBC0\xB8\xE8x\xC5?\xD2\xA3kg\x94\t\xC0s\xAF\xD7YP\xBEC\xD8\x85\x87h\xE9V\xFB\xC2\x0E\x90a\x06\x1D\x90\x87\x90a^:V[`@Q\x80\x91\x03\x90\xA3\x90Pa\x06/a\x18\"V[\x91\x90PV[a\x06<a\x17hV[`\0\x80`\0\x80[\x84Q\x81\x10\x15a\x07[W`\0\x80`\0\x80`\0a\x06q\x8A\x87\x81Q\x81\x10a\x06cW\xFE[` \x02` \x01\x01Q\x89a\x18}V[\x9CP\x93\x98P\x91\x96P\x94P\x92P\x90P`\x01\x85`\x03\x81\x11\x15a\x06\x8DW\xFE[\x14\x15a\x06\xA4Wa\x06\x9F\x84\x83\x83\x86a\x18\xF5V[a\x07JV[\x86a\x06\xB6Wa\x06\xB1a\x18)V[`\x01\x96P[`\0\x85`\x03\x81\x11\x15a\x06\xC4W\xFE[\x14\x15a\x06\xF5Wa\x06\xD6\x84\x83\x83\x86a\x19\x18V[a\x06\xDF\x84a\x198V[\x15a\x06\x9FWa\x06\xEE\x89\x84a\x19EV[\x98Pa\x07JV[a\x07\na\x07\x01\x85a\x198V[\x15a\x02\x07a\x05KV[`\0a\x07\x15\x85a\x05HV[\x90P`\x02\x86`\x03\x81\x11\x15a\x07%W\xFE[\x14\x15a\x07<Wa\x077\x81\x84\x84\x87a\x19WV[a\x07HV[a\x07H\x81\x84\x84\x87a\x19pV[P[PP`\x01\x90\x93\x01\x92Pa\x06C\x91PPV[Pa\x07e\x83a\x19\xDEV[PPPa\x05~a\x18\"V[``\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x07\x8AW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\xB4W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x82Q\x81\x10\x15a\x07\xFFWa\x07\xE0\x84\x84\x83\x81Q\x81\x10a\x07\xD3W\xFE[` \x02` \x01\x01Qa\x1A\x01V[\x82\x82\x81Q\x81\x10a\x07\xECW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07\xBAV[P\x92\x91PPV[a\x08\x0Ea\x17hV[a\x08\x16a\x17\x81V[a\x05v\x81a\x1A,V[`\0\x80`\0a\x08,a\x1A\xAAV[\x15\x92Pa\x087a\x1A\xC7V[\x91Pa\x08Aa\x1A\xEBV[\x90P\x90\x91\x92V[`\0a\x08Ra\x17hV[a\x08Za\x18)V[\x83Qa\x08e\x81a\x1B\x0FV[a\x08t\x83B\x11\x15a\x01\xFCa\x05KV[a\x08\x87`\0\x87`\x80\x01Q\x11a\x01\xFEa\x05KV[`\0a\x08\x96\x87`@\x01Qa\x1BAV[\x90P`\0a\x08\xA7\x88``\x01Qa\x1BAV[\x90Pa\x08\xCA\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x01\xFDa\x05KV[a\x08\xD2aL\xE1V[\x88Q`\x80\x82\x01R` \x89\x01Q\x81\x90`\x01\x81\x11\x15a\x08\xEBW\xFE[\x90\x81`\x01\x81\x11\x15a\x08\xF8W\xFE[\x90RP`\x01`\x01`\xA0\x1B\x03\x80\x84\x16` \x83\x01R\x82\x81\x16`@\x80\x84\x01\x91\x90\x91R`\x80\x8B\x01Q``\x84\x01R`\xA0\x8B\x01Qa\x01\0\x84\x01R\x89Q\x82\x16`\xC0\x84\x01R\x89\x01Q\x16`\xE0\x82\x01R`\0\x80a\tJ\x83a\x1BfV[\x91\x98P\x92P\x90Pa\t\x81`\0\x8C` \x01Q`\x01\x81\x11\x15a\tfW\xFE[\x14a\ttW\x89\x83\x11\x15a\tyV[\x89\x82\x10\x15[a\x01\xFBa\x05KV[a\t\x99\x8B`@\x01Q\x83\x8C`\0\x01Q\x8D` \x01Qa\x1CZV[a\t\xB1\x8B``\x01Q\x82\x8C`@\x01Q\x8D``\x01Qa\x1D8V[a\t\xD3a\t\xC1\x8C`@\x01Qa\x198V[a\t\xCCW`\0a\t\xCEV[\x82[a\x19\xDEV[PPPPPPa\t\xE1a\x18\"V[\x94\x93PPPPV[a\t\xF1a\x17hV[a\t\xF9a\x18)V[a\n\x05\x83Q\x83Qa\x1E\x12V[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\n\x1FW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\nIW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P``\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\nfW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x86Q\x81\x10\x15a\x0C\tW`\0\x87\x82\x81Q\x81\x10a\n\xAEW\xFE[` \x02` \x01\x01Q\x90P`\0\x87\x83\x81Q\x81\x10a\n\xC6W\xFE[` \x02` \x01\x01Q\x90Pa\x0B\x11\x84`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x11`\0`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0B\tW`fa\x0B\x0CV[`h[a\x05KV[\x81\x93P\x81`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0B@\x91\x90a[cV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x0BXW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x0BlW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x90\x91\x90aYhV[\x85\x84\x81Q\x81\x10a\x0B\x9CW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0B\xB1\x81a\x1E\x1FV[\x86\x84\x81Q\x81\x10a\x0B\xBDW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0B\xEB\x81\x86\x85\x81Q\x81\x10a\x0B\xD9W\xFE[` \x02` \x01\x01Q\x10\x15a\x02\x10a\x05KV[a\x0B\xFF`\x01`\x01`\xA0\x1B\x03\x83\x16\x8B\x83a\x1E\xA6V[PP`\x01\x01a\n\x97V[P`@Q\x7F\xF0O'\x07\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x88\x16\x90c\xF0O'\x07\x90a\x0CU\x90\x89\x90\x89\x90\x88\x90\x8A\x90`\x04\x01a\\\x85V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x0CoW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0C\x83W=`\0\x80>=`\0\xFD[PPPP`\0[\x86Q\x81\x10\x15a\r\xF4W`\0\x87\x82\x81Q\x81\x10a\x0C\xA1W\xFE[` \x02` \x01\x01Q\x90P`\0\x84\x83\x81Q\x81\x10a\x0C\xB9W\xFE[` \x02` \x01\x01Q\x90P`\0\x82`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0C\xF1\x91\x90a[cV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\r\tW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\r\x1DW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\rA\x91\x90aYhV[\x90Pa\rR\x82\x82\x10\x15a\x02\x03a\x05KV[`\0\x82\x82\x03\x90Pa\r{\x88\x86\x81Q\x81\x10a\rhW\xFE[` \x02` \x01\x01Q\x82\x10\x15a\x02Za\x05KV[a\r\x85\x84\x82a\x1F\x11V[\x83`\x01`\x01`\xA0\x1B\x03\x16\x8C`\x01`\x01`\xA0\x1B\x03\x16\x7F\r}u\xE0\x1A\xB9W\x80\xD3\xCD\x1C\x8E\xC0\xDDl,\xE1\x9E: B~\xEC\x8B\xF52\x83\xB6\xFB\x8E\x95\xF0\x8C\x88\x81Q\x81\x10a\r\xC6W\xFE[` \x02` \x01\x01Q\x84`@Qa\r\xDD\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA3PPPP\x80`\x01\x01\x90Pa\x0C\x8AV[PPPPa\x0E\0a\x18\"V[PPPPV[a\x0E\x0Ea\x17hV[a\x0E\x16a\x18)V[\x82a\x0E \x81a\x1F3V[a\x0E,\x83Q\x83Qa\x1E\x12V[`\0[\x83Q\x81\x10\x15a\x0E\xCAW`\0\x84\x82\x81Q\x81\x10a\x0EFW\xFE[` \x02` \x01\x01Q\x90Pa\x0Er`\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x015a\x05KV[\x83\x82\x81Q\x81\x10a\x0E~W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\0\x88\x81R`\n\x83R`@\x80\x82 `\x01`\x01`\xA0\x1B\x03\x95\x86\x16\x83R\x90\x93R\x91\x90\x91 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x92\x90\x91\x16\x91\x90\x91\x17\x90U`\x01\x01a\x0E/V[P`\0a\x0E\xD6\x85a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x0E\xE6W\xFE[\x14\x15a\x0F4Wa\x0E\xFC\x84Q`\x02\x14a\x02\x0Ca\x05KV[a\x0F/\x85\x85`\0\x81Q\x81\x10a\x0F\rW\xFE[` \x02` \x01\x01Q\x86`\x01\x81Q\x81\x10a\x0F\"W\xFE[` \x02` \x01\x01Qa\x1F~V[a\x0F\\V[`\x01\x81`\x02\x81\x11\x15a\x0FBW\xFE[\x14\x15a\x0FRWa\x0F/\x85\x85a *V[a\x0F\\\x85\x85a \x82V[\x84\x7F\xF5\x84}?!\x97\xB1l\xDC\xD2\t\x8E\xC9]\t\x05\xCD\x1A\xBD\xAFA_\x07\xBB|\xEF+\xBA\x8A\xC5\xDE\xC4\x85\x85`@Qa\x0F\x8E\x92\x91\x90a[\xEDV[`@Q\x80\x91\x03\x90\xA2PPa\x0F\xA0a\x18\"V[PPPV[a\x0F\xADa\x17hV[a\x0F\xB5a\x18)V[\x81a\x0F\xBF\x81a\x1F3V[`\0a\x0F\xCA\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x0F\xDAW\xFE[\x14\x15a\x10(Wa\x0F\xF0\x83Q`\x02\x14a\x02\x0Ca\x05KV[a\x10#\x84\x84`\0\x81Q\x81\x10a\x10\x01W\xFE[` \x02` \x01\x01Q\x85`\x01\x81Q\x81\x10a\x10\x16W\xFE[` \x02` \x01\x01Qa \xD7V[a\x10PV[`\x01\x81`\x02\x81\x11\x15a\x106W\xFE[\x14\x15a\x10FWa\x10#\x84\x84a!EV[a\x10P\x84\x84a!\xFFV[`\0[\x83Q\x81\x10\x15a\x10\xB6W`\n`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x85\x83\x81Q\x81\x10a\x10}W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x82R\x81\x01\x91\x90\x91R`@\x01`\0 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U`\x01\x01a\x10SV[P\x83\x7F}\xCD\xC6\xD0.\xF4\x0C|\x1ApF\xA0\x11\xB0X\xBD\x7F\x98\x8F\xA1N \xA6cD\xF9\xD4\xE6\x06W\xD6\x10\x84`@Qa\x10\xE7\x91\x90a[\xDAV[`@Q\x80\x91\x03\x90\xA2PPa\x05Ya\x18\"V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x11.\x92\x91\x90aZ\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x0E\0`\x01\x85\x85\x85a\x11\\\x86a\"bV[a\"nV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02` R`@\x90 T\x90V[``a\x11\x86a\x17hV[a\x11\x8Ea\x18)V[\x83Qa\x11\x99\x81a\x1B\x0FV[a\x11\xA8\x83B\x11\x15a\x01\xFCa\x05KV[a\x11\xB4\x86Q\x85Qa\x1E\x12V[a\x11\xC0\x87\x87\x87\x8Ba#\xF4V[\x91P`\0\x80[\x87Q\x81\x10\x15a\x12\x92W`\0\x88\x82\x81Q\x81\x10a\x11\xDDW\xFE[` \x02` \x01\x01Q\x90P`\0\x85\x83\x81Q\x81\x10a\x11\xF5W\xFE[` \x02` \x01\x01Q\x90Pa\x12!\x88\x84\x81Q\x81\x10a\x12\x0EW\xFE[` \x02` \x01\x01Q\x82\x13\x15a\x01\xFBa\x05KV[`\0\x81\x13\x15a\x12aW\x88Q` \x8A\x01Q\x82\x91a\x12@\x91\x85\x91\x84\x91a\x1CZV[a\x12I\x83a\x198V[\x15a\x12[Wa\x12X\x85\x82a\x19EV[\x94P[Pa\x12\x88V[`\0\x81\x12\x15a\x12\x88W`\0\x81`\0\x03\x90Pa\x12\x86\x83\x82\x8C`@\x01Q\x8D``\x01Qa\x1D8V[P[PP`\x01\x01a\x11\xC6V[Pa\x12\x9C\x81a\x19\xDEV[PPa\x12\xA6a\x18\"V[\x96\x95PPPPPPV[`\x03Ta\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\0a\x12\xCEa\x05&V[\x90P\x90V[`\0\x80`\0\x80\x85a\x12\xE3\x81a&\x83V[`\0\x80a\x12\xEF\x89a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x12\xFFW\xFE[\x14\x15a\x13\x16Wa\x13\x0F\x89\x89a&\xA1V[\x91Pa\x13AV[`\x01\x81`\x02\x81\x11\x15a\x13$W\xFE[\x14\x15a\x134Wa\x13\x0F\x89\x89a'\x1BV[a\x13>\x89\x89a'\x89V[\x91P[a\x13J\x82a'\xA1V[\x96Pa\x13U\x82a'\xB4V[\x95Pa\x13`\x82a'\xCAV[`\0\x99\x8AR`\n` \x90\x81R`@\x80\x8C `\x01`\x01`\xA0\x1B\x03\x9B\x8C\x16\x8DR\x90\x91R\x90\x99 T\x96\x99\x95\x98\x97\x96\x90\x96\x16\x95PPPPPV[a\x13\x9Ea\x18)V[a\x0E\0`\0\x85\x85\x85a\x11\\\x86a\"bV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[a\x13\xDBa\x17hV[a\x13\xE3a\x18)V[a\x13\xEBaM1V[`\0[\x82Q\x81\x10\x15a\x14\xE5W\x82\x81\x81Q\x81\x10a\x14\x03W\xFE[` \x02` \x01\x01Q\x91P`\0\x82` \x01Q\x90Pa\x14\x1F\x81a&\x83V[`@\x83\x01Qa\x149a\x141\x83\x83a'\xD0V[a\x02\ta\x05KV[`\0\x82\x81R`\n` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x85R\x92R\x90\x91 Ta\x14l\x91\x163\x14a\x01\xF6a\x05KV[\x83Q``\x85\x01Q`\0\x80a\x14\x82\x84\x87\x87\x86a(,V[\x91P\x91P\x84`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x87\x7Fn\xDC\xAFbA\x10[L\x94\xC2\xEF\xDB\xF3\xA6\xB1$X\xEB=\x07\xBE:\x0E\x81\xD2K\x13\xC4@E\xFEz\x85\x85`@Qa\x14\xCC\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA4PPPPPP\x80`\x01\x01\x90Pa\x13\xEEV[PPa\x05~a\x18\"V[`\0a\x12\xCEa(\x9BV[`\0\x80\x82a\x15\x06\x81a&\x83V[a\x15\x0F\x84a)8V[a\x15\x18\x85a\x1FdV[\x92P\x92P[P\x91P\x91V[``30\x14a\x15\xF6W`\x000`\x01`\x01`\xA0\x1B\x03\x16`\x006`@Qa\x15I\x92\x91\x90aZ\xDAV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x15\x86W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x15\x8BV[``\x91P[PP\x90P\x80`\0\x81\x14a\x15\x9AW\xFE[`\x04`\0\x80>`\0Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x7F\xFAa\xCC\x12\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x15\xDEW=`\0\x80>=`\0\xFD[P` `\0R`\x04=\x03\x80`\x04` >` \x81\x01`\0\xF3[``a\x16\x04\x85\x85\x85\x89a#\xF4V[\x90P` \x81Q\x02c\xFAa\xCC\x12` \x83\x03R`\x04\x82\x03`$\x82\x01\x81\xFD[``\x80`\0\x83a\x16/\x81a&\x83V[``a\x16:\x86a)>V[\x90\x95P\x90Pa\x16H\x81a)\xA0V[\x95\x97\x90\x96P\x93PPPPV[a\x16\\a\x17hV[a\x16da\x18)V[\x82a\x16n\x81a\x1B\x0FV[`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\0\x81\x81R`\x04` \x90\x81R`@\x80\x83 \x94\x88\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x80T`\xFF\x19\x16\x86\x15\x15\x17\x90UQ\x90\x91\x90\x7FF\x96\x1F\xDBE\x02\xB6F\xD5\t_\xBAv\0Hj\x8A\xC0PA\xD5\\\xDF\x0F\x16\xEDgq\x80\xB5\xCA\xD8\x90a\x16\xD5\x90\x86\x90a]\x1BV[`@Q\x80\x91\x03\x90\xA3Pa\x0F\xA0a\x18\"V[`\0a\x16\xF2\x83\x83a*OV[\x90P[\x92\x91PPV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[a\x17z`\x02`\0T\x14\x15a\x01\x90a\x05KV[`\x02`\0UV[`\0a\x17\x98`\x005`\x01`\x01`\xE0\x1B\x03\x19\x16a\x10\xF9V[\x90Pa\x05~a\x17\xA7\x823a*}V[a\x01\x91a\x05KV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\x94\xB9y\xB6\x83\x1AQ)>&ABo\x97t\x7F\xEE\xD4o\x17w\x9F\xED\x9C\xD1\x8D\x1E\xCE\xFC\xFE\x92\xEF\x90`\0\x90\xA2`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16a\x01\0\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\x90\x92\x16\x91\x90\x91\x17\x90UV[`\x01`\0UV[a\x18<a\x184a\x1A\xAAV[a\x01\x92a\x05KV[V[`\0i\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16`P\x84`\x02\x81\x11\x15a\x18[W\xFE[\x90\x1B\x17``\x85\x90\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x17\x90P[\x93\x92PPPV[`\0\x80`\0\x80`\0\x80`\0\x88``\x01Q\x90P3`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14a\x18\xCFW\x87a\x18\xBAWa\x18\xB5a\x17\x81V[`\x01\x97P[a\x18\xCFa\x18\xC7\x823a*OV[a\x01\xF7a\x05KV[\x88Q` \x8A\x01Q`@\x8B\x01Q`\x80\x90\x9B\x01Q\x91\x9B\x90\x9A\x99\x92\x98P\x90\x96P\x90\x94P\x92PPPV[a\x19\n\x83a\x19\x02\x86a\x1BAV[\x83`\0a+ V[Pa\x0E\0\x84\x82\x84`\0a\x1D8V[a\x19+\x82a\x19%\x86a\x1BAV[\x83a+vV[a\x0E\0\x84\x82\x85`\0a\x1CZV[`\x01`\x01`\xA0\x1B\x03\x16\x15\x90V[`\0\x82\x82\x01a\x16\xF2\x84\x82\x10\x15\x83a\x05KV[a\x19d\x83\x85\x83`\0a+ V[Pa\x0E\0\x82\x85\x83a+vV[\x80\x15a\x0E\0Wa\x19\x8B`\x01`\x01`\xA0\x1B\x03\x85\x16\x84\x84\x84a+\xA6V[\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x7FT\n\x1A?(4\x0C\xAE\xC36\xC8\x1D\x8D{=\xF19\xEE\\\xDC\x189\xA4\xF2\x83\xD7\xEB\xB7\xEA\xAE-\\\x84\x84`@Qa\x19\xD0\x92\x91\x90a[\xC1V[`@Q\x80\x91\x03\x90\xA3PPPPV[a\x19\xED\x814\x10\x15a\x02\x04a\x05KV[4\x81\x90\x03\x80\x15a\x05YWa\x05Y3\x82a+\xC7V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x0B` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[\x80\x15a\x1ALWa\x1AGa\x1A=a\x1A\xC7V[B\x10a\x01\x93a\x05KV[a\x1AaV[a\x1Aaa\x1AWa\x1A\xEBV[B\x10a\x01\xA9a\x05KV[`\x03\x80T`\xFF\x19\x16\x82\x15\x15\x17\x90U`@Q\x7F\x9E:^7\"E2\xDE\xA6{\x89\xFA\xCE\x18W\x03s\x8A\"\x8An\x8A#\xDE\xE5F\x96\x01\x80\xD3\xBEd\x90a\x1A\x9F\x90\x83\x90a]\x1BV[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x1A\xB4a\x1A\xEBV[B\x11\x80a\x12\xCEWPP`\x03T`\xFF\x16\x15\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[3`\x01`\x01`\xA0\x1B\x03\x82\x16\x14a\x05~Wa\x1B'a\x17\x81V[a\x1B1\x813a*OV[a\x05~Wa\x05~\x81a\x01\xF7a,AV[`\0a\x1BL\x82a\x198V[a\x1B^Wa\x1BY\x82a\x05HV[a\x16\xF5V[a\x16\xF5a\x05&V[`\0\x80`\0\x80a\x1By\x85`\x80\x01Qa)8V[\x90P`\0a\x1B\x8A\x86`\x80\x01Qa\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x1B\x9AW\xFE[\x14\x15a\x1B\xB1Wa\x1B\xAA\x86\x83a,uV[\x94Pa\x1B\xDCV[`\x01\x81`\x02\x81\x11\x15a\x1B\xBFW\xFE[\x14\x15a\x1B\xCFWa\x1B\xAA\x86\x83a-%V[a\x1B\xD9\x86\x83a-\xB8V[\x94P[a\x1B\xEF\x86`\0\x01Q\x87``\x01Q\x87a/\xF7V[\x80\x94P\x81\x95PPP\x85`@\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x86` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x87`\x80\x01Q\x7F!p\xC7A\xC4\x151\xAE\xC2\x0E|\x10|$\xEE\xCF\xDD\x15\xE6\x9C\x9B\xB0\xA8\xDD7\xB1\x84\x0B\x9E\x0B {\x87\x87`@Qa\x1CI\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA4PP\x91\x93\x90\x92PV[\x82a\x1CdWa\x0E\0V[a\x1Cm\x84a\x198V[\x15a\x1C\xEEWa\x1C\x7F\x81\x15a\x02\x02a\x05KV[a\x1C\x8E\x83G\x10\x15a\x02\x04a\x05KV[a\x1C\x96a\x05&V[`\x01`\x01`\xA0\x1B\x03\x16c\xD0\xE3\r\xB0\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x1C\xD0W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1C\xE4W=`\0\x80>=`\0\xFD[PPPPPa\x0E\0V[`\0a\x1C\xF9\x85a\x05HV[\x90P\x81\x15a\x1D\x16W`\0a\x1D\x10\x84\x83\x87`\x01a+ V[\x90\x94\x03\x93P[\x83\x15a\x1D1Wa\x1D1`\x01`\x01`\xA0\x1B\x03\x82\x16\x840\x87a+\xA6V[PPPPPV[\x82a\x1DBWa\x0E\0V[a\x1DK\x84a\x198V[\x15a\x1D\xDBWa\x1D]\x81\x15a\x02\x02a\x05KV[a\x1Dea\x05&V[`\x01`\x01`\xA0\x1B\x03\x16c.\x1A}M\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1D\x90\x91\x90a]>V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x1D\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1D\xBEW=`\0\x80>=`\0\xFD[Pa\x1D\xD6\x92PPP`\x01`\x01`\xA0\x1B\x03\x83\x16\x84a+\xC7V[a\x0E\0V[`\0a\x1D\xE6\x85a\x05HV[\x90P\x81\x15a\x1D\xFEWa\x1D\xF9\x83\x82\x86a+vV[a\x1D1V[a\x1D1`\x01`\x01`\xA0\x1B\x03\x82\x16\x84\x86a\x1E\xA6V[a\x05Y\x81\x83\x14`ga\x05KV[`\0\x80a\x1E*a\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x16c\xD8w\x84\\`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1EbW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1EvW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1E\x9A\x91\x90aYhV[\x90Pa\x18v\x83\x82a0%V[a\x0F\xA0\x83c\xA9\x05\x9C\xBB`\xE0\x1B\x84\x84`@Q`$\x01a\x1E\xC5\x92\x91\x90a[\xC1V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x90\x91Ra0rV[\x80\x15a\x05YWa\x05Ya\x1F\"a\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x84\x16\x90\x83a\x1E\xA6V[a\x1F<\x81a&\x83V[a\x05~a\x1FH\x82a)8V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x01\xF5a\x05KV[`\0a\xFF\xFF`P\x83\x90\x1C\x16a\x16\xF5`\x03\x82\x10a\x01\xF4a\x05KV[a\x1F\x9F\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x02\na\x05KV[a\x1F\xBE\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x10`fa\x05KV[`\0\x83\x81R`\t` R`@\x90 \x80Ta\x1F\xFB\x90`\x01`\x01`\xA0\x1B\x03\x16\x15\x80\x15a\x1F\xF3WP`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15[a\x02\x0Ba\x05KV[\x80T`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x01`\x01`\xA0\x1B\x03\x19\x91\x82\x16\x17\x82U`\x01\x90\x91\x01\x80T\x92\x90\x93\x16\x91\x16\x17\x90UPV[`\0\x82\x81R`\x08` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0a k\x84\x83\x81Q\x81\x10a TW\xFE[` \x02` \x01\x01Q\x84a1\x12\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90Pa y\x81a\x02\na\x05KV[P`\x01\x01a :V[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0a \xC0\x84\x83\x81Q\x81\x10a \xACW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01Q\x84\x90`\0a1uV[\x90Pa \xCE\x81a\x02\na\x05KV[P`\x01\x01a \x92V[`\0\x80`\0a \xE7\x86\x86\x86a2\"V[\x92P\x92P\x92Pa!\x11a \xF9\x84a2\xE9V[\x80\x15a!\tWPa!\t\x83a2\xE9V[a\x02\ra\x05KV[`\0\x95\x86R`\t` R`@\x86 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16\x82U`\x01\x90\x91\x01\x80T\x90\x91\x16\x90U\x94\x90\x94UPPPPV[`\0\x82\x81R`\x08` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0\x83\x82\x81Q\x81\x10a!lW\xFE[` \x02` \x01\x01Q\x90Pa!\xB8a!\t`\x07`\0\x88\x81R` \x01\x90\x81R` \x01`\0 `\0\x84`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01`\0 Ta2\xE9V[`\0\x85\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 \x81\x90Ua!\xE7\x84\x83a3\x0BV[\x90Pa!\xF5\x81a\x02\ta\x05KV[PP`\x01\x01a!UV[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0\x83\x82\x81Q\x81\x10a\"&W\xFE[` \x02` \x01\x01Q\x90P`\0a\"<\x84\x83a4\x12V[\x90Pa\"Ja!\t\x82a2\xE9V[a\"T\x84\x83a4!V[PPP\x80`\x01\x01\x90Pa\"\x0FV[a\"jaMZV[P\x90V[a\"va\x17hV[\x83a\"\x80\x81a&\x83V[\x83a\"\x8A\x81a\x1B\x0FV[a\"\x9E\x83`\0\x01QQ\x84` \x01QQa\x1E\x12V[``a\"\xAD\x84`\0\x01Qa4\xC3V[\x90P``a\"\xBB\x88\x83a5RV[\x90P``\x80``a\"\xD0\x8C\x8C\x8C\x8C\x8C\x89a5\xE3V[\x92P\x92P\x92P`\0a\"\xE1\x8Ca\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\"\xF1W\xFE[\x14\x15a#YWa#T\x8C\x87`\0\x81Q\x81\x10a#\x08W\xFE[` \x02` \x01\x01Q\x86`\0\x81Q\x81\x10a#\x1DW\xFE[` \x02` \x01\x01Q\x89`\x01\x81Q\x81\x10a#2W\xFE[` \x02` \x01\x01Q\x88`\x01\x81Q\x81\x10a#GW\xFE[` \x02` \x01\x01Qa7\xA8V[a#\x82V[`\x01\x81`\x02\x81\x11\x15a#gW\xFE[\x14\x15a#xWa#T\x8C\x87\x86a7\xE7V[a#\x82\x8C\x85a8TV[`\0\x80\x8E`\x01\x81\x11\x15a#\x91W\xFE[\x14\x90P\x8B`\x01`\x01`\xA0\x1B\x03\x16\x8D\x7F\xE5\xCE$\x90\x87\xCE\x04\xF0Z\x95q\x92CT\0\xFD\x97\x86\x8D\xBA\x0EjKL\x04\x9A\xBF\x8A\xF8\r\xAEx\x89a#\xCB\x88\x86a8\x9DV[\x87`@Qa#\xDB\x93\x92\x91\x90a\\LV[`@Q\x80\x91\x03\x90\xA3PPPPPPPPPa\x1D1a\x18\"V[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a$\x0EW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a$8W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90Pa$CaM\x84V[a$KaL\xE1V[`\0\x80`\0[\x89Q\x81\x10\x15a&vW\x89\x81\x81Q\x81\x10a$fW\xFE[` \x02` \x01\x01Q\x94P`\0\x89Q\x86` \x01Q\x10\x80\x15a$\x8AWP\x89Q\x86`@\x01Q\x10[\x90Pa$\x97\x81`da\x05KV[`\0a$\xB9\x8B\x88` \x01Q\x81Q\x81\x10a$\xACW\xFE[` \x02` \x01\x01Qa\x1BAV[\x90P`\0a$\xD0\x8C\x89`@\x01Q\x81Q\x81\x10a$\xACW\xFE[\x90Pa$\xF3\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x01\xFDa\x05KV[``\x88\x01Qa%CWa%\x0B`\0\x85\x11a\x01\xFEa\x05KV[`\0a%\x18\x8B\x84\x84a9EV[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa%:\x81a\x01\xFFa\x05KV[P``\x88\x01\x85\x90R[\x87Q`\x80\x88\x01R\x86\x8A`\x01\x81\x11\x15a%WW\xFE[\x90\x81`\x01\x81\x11\x15a%dW\xFE[\x90RP`\x01`\x01`\xA0\x1B\x03\x80\x83\x16` \x89\x01R\x81\x81\x16`@\x80\x8A\x01\x91\x90\x91R``\x80\x8B\x01Q\x90\x8A\x01R`\x80\x8A\x01Qa\x01\0\x8A\x01R\x8CQ\x82\x16`\xC0\x8A\x01R\x8C\x01Q\x16`\xE0\x88\x01R`\0\x80a%\xB6\x89a\x1BfV[\x91\x98P\x92P\x90Pa%\xC8\x8C\x85\x85a9gV[\x97Pa%\xFCa%\xD6\x83a9\x81V[\x8C\x8C` \x01Q\x81Q\x81\x10a%\xE6W\xFE[` \x02` \x01\x01Qa9\xB1\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x8B\x8B` \x01Q\x81Q\x81\x10a&\x0CW\xFE[` \x02` \x01\x01\x81\x81RPPa&Ja&$\x82a9\x81V[\x8C\x8C`@\x01Q\x81Q\x81\x10a&4W\xFE[` \x02` \x01\x01Qa9\xE5\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x8B\x8B`@\x01Q\x81Q\x81\x10a&ZW\xFE[` \x02` \x01\x01\x81\x81RPPPPPPP\x80`\x01\x01\x90Pa$QV[PPPPP\x94\x93PPPPV[`\0\x81\x81R`\x05` R`@\x90 Ta\x05~\x90`\xFF\x16a\x01\xF4a\x05KV[`\0\x80`\0\x80`\0a&\xB2\x87a:\x19V[\x94P\x94P\x94P\x94PP\x83`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a&\xE1W\x82\x94PPPPPa\x16\xF5V[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a'\x06W\x93Pa\x16\xF5\x92PPPV[a'\x11a\x02\ta\x16\xFBV[PPPP\x92\x91PPV[`\0\x82\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 T\x81a'H\x82a:\x8FV[\x80a'fWP`\0\x85\x81R`\x08` R`@\x90 a'f\x90\x85a:\xA1V[\x90P\x80a'\x81Wa'v\x85a&\x83V[a'\x81a\x02\ta\x16\xFBV[P\x93\x92PPPV[`\0\x82\x81R`\x01` R`@\x81 a\t\xE1\x81\x84a4\x12V[m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90V[`p\x1Cm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90V[`\xE0\x1C\x90V[`\0\x80a'\xDC\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a'\xECW\xFE[\x14\x15a(\x04Wa'\xFC\x84\x84a:\xC2V[\x91PPa\x16\xF5V[`\x01\x81`\x02\x81\x11\x15a(\x12W\xFE[\x14\x15a(\"Wa'\xFC\x84\x84a;\x13V[a'\xFC\x84\x84a;+V[`\0\x80`\0a(:\x86a\x1FdV[\x90P`\0\x87`\x02\x81\x11\x15a(JW\xFE[\x14\x15a(fWa(\\\x86\x82\x87\x87a;CV[\x92P\x92PPa(\x92V[`\x01\x87`\x02\x81\x11\x15a(tW\xFE[\x14\x15a(\x86Wa(\\\x86\x82\x87\x87a;\xBEV[a(\\\x86\x82\x87\x87a<:V[\x94P\x94\x92PPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a)\x08a<\x9DV[0`@Q` \x01a)\x1D\x95\x94\x93\x92\x91\x90a]\xF0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[``\x1C\x90V[``\x80`\0a)L\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a)\\W\xFE[\x14\x15a)uWa)k\x84a<\xA1V[\x92P\x92PPa)\x9BV[`\x01\x81`\x02\x81\x11\x15a)\x83W\xFE[\x14\x15a)\x92Wa)k\x84a=\xD6V[a)k\x84a>\xFDV[\x91P\x91V[```\0\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a)\xBCW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a)\xE6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0\x90P`\0[\x82Q\x81\x10\x15a\x15\x1DW`\0\x84\x82\x81Q\x81\x10a*\x07W\xFE[` \x02` \x01\x01Q\x90Pa*\x1A\x81a?\xF9V[\x84\x83\x81Q\x81\x10a*&W\xFE[` \x02` \x01\x01\x81\x81RPPa*D\x83a*?\x83a'\xCAV[a@\x14V[\x92PP`\x01\x01a)\xF0V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x04` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T`\xFF\x16\x90V[`\x03T`@Q\x7F\x9B\xE2\xA8\x84\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\0\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c\x9B\xE2\xA8\x84\x90a*\xD0\x90\x86\x90\x86\x900\x90`\x04\x01a]GV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a*\xE8W`\0\x80\xFD[PZ\xFA\x15\x80\x15a*\xFCW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xF2\x91\x90aTxV[`\0\x80a+-\x86\x86a\x1A\x01V[\x90Pa+F\x83\x80a+>WP\x84\x82\x10\x15[a\x02\x01a\x05KV[a+P\x81\x85a@+V[\x91P\x81\x81\x03a+l\x87\x87\x83a+d\x87a9\x81V[`\0\x03a@:V[PP\x94\x93PPPPV[`\0a+\x82\x84\x84a\x1A\x01V[\x90P`\0a+\x90\x82\x84a\x19EV[\x90Pa\x1D1\x85\x85\x83a+\xA1\x87a9\x81V[a@:V[a\x0E\0\x84c#\xB8r\xDD`\xE0\x1B\x85\x85\x85`@Q`$\x01a\x1E\xC5\x93\x92\x91\x90a[wV[a+\xD6\x81G\x10\x15a\x01\xA3a\x05KV[`\0\x82`\x01`\x01`\xA0\x1B\x03\x16\x82`@Qa+\xEF\x90a\x05HV[`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a,,W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a,1V[``\x91P[PP\x90Pa\x0F\xA0\x81a\x01\xA4a\x05KV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02` R`@\x90 \x80T`\x01\x81\x01\x90\x91Ua\x0F\xA0a,o\x84\x83a@\x95V[\x83a\x05KV[`\0\x80`\0\x80a,\x92\x86`\x80\x01Q\x87` \x01Q\x88`@\x01Qa2\"V[\x92P\x92P\x92P`\0\x80\x87`@\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x88` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x10\x15a,\xC7WP\x83\x90P\x82a,\xCDV[P\x82\x90P\x83[a,\xD9\x88\x88\x84\x84aA\xBBV[`@\x8B\x01Q` \x8C\x01Q\x91\x99P\x92\x94P\x90\x92P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x10a-\rWa-\x08\x81\x83aB\xD1V[a-\x17V[a-\x17\x82\x82aB\xD1V[\x90\x92UP\x92\x95\x94PPPPPV[`\0\x80a-:\x84`\x80\x01Q\x85` \x01Qa'\x1BV[\x90P`\0a-P\x85`\x80\x01Q\x86`@\x01Qa'\x1BV[\x90Pa-^\x85\x85\x84\x84aA\xBBV[`\x80\x88\x01\x80Q`\0\x90\x81R`\x07` \x81\x81R`@\x80\x84 \x82\x8E\x01Q`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x86R\x90\x83R\x81\x85 \x98\x90\x98U\x93Q\x83R\x90\x81R\x82\x82 \x9A\x83\x01Q\x90\x95\x16\x81R\x98\x90\x93R\x91\x90\x96 \x95\x90\x95UP\x92\x93\x92PPPV[`\x80\x82\x01Q`\0\x90\x81R`\x01` \x90\x81R`@\x82 \x90\x84\x01Q\x82\x91\x82\x91\x82\x90a-\xE2\x90\x83\x90aC\x0CV[\x90P`\0a-\xFD\x88`@\x01Q\x84aC\x0C\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x81\x15\x80a.\nWP\x80\x15[\x15a.'Wa.\x1C\x88`\x80\x01Qa&\x83V[a.'a\x02\ta\x16\xFBV[`\0\x19\x91\x82\x01\x91\x01`\0a.:\x84aC+V[\x90P``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a.UW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a.\x7FW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P`\0`\xA0\x8C\x01\x81\x90R\x90\x91P[\x82\x81\x10\x15a.\xFFW`\0a.\xA1\x87\x83aC/V[\x90Pa.\xAC\x81a?\xF9V[\x83\x83\x81Q\x81\x10a.\xB8W\xFE[` \x02` \x01\x01\x81\x81RPPa.\xD5\x8C`\xA0\x01Qa*?\x83a'\xCAV[`\xA0\x8D\x01R\x81\x86\x14\x15a.\xEAW\x80\x98Pa.\xF6V[\x84\x82\x14\x15a.\xF6W\x80\x97P[P`\x01\x01a.\x8DV[P`@Q\x7F\x01\xEC\x95J\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x16\x90c\x01\xEC\x95J\x90a/K\x90\x8D\x90\x85\x90\x89\x90\x89\x90`\x04\x01a^[V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a/eW`\0\x80\xFD[PZ\xF1\x15\x80\x15a/yW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a/\x9D\x91\x90aYhV[\x97P`\0\x80a/\xB5\x8C`\0\x01Q\x8D``\x01Q\x8Ca/\xF7V[\x90\x92P\x90Pa/\xC4\x89\x83aCEV[\x98Pa/\xD0\x88\x82aCvV[\x97Pa/\xDD\x87\x87\x8BaC\x8CV[a/\xE8\x87\x86\x8AaC\x8CV[PPPPPPPPP\x92\x91PPV[`\0\x80\x80\x85`\x01\x81\x11\x15a0\x07W\xFE[\x14\x15a0\x17WP\x82\x90P\x81a0\x1DV[P\x81\x90P\x82[\x93P\x93\x91PPV[`\0\x82\x82\x02a0I\x84\x15\x80a0BWP\x83\x85\x83\x81a0?W\xFE[\x04\x14[`\x03a\x05KV[\x80a0XW`\0\x91PPa\x16\xF5V[g\r\xE0\xB6\xB3\xA7d\0\0`\0\x19\x82\x01\x04`\x01\x01\x91PPa\x16\xF5V[`\0``\x83`\x01`\x01`\xA0\x1B\x03\x16\x83`@Qa0\x8E\x91\x90aZ\xEAV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a0\xCBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a0\xD0V[``\x91P[P\x91P\x91P`\0\x82\x14\x15a0\xE8W=`\0\x80>=`\0\xFD[a\x0E\0\x81Q`\0\x14\x80a1\nWP\x81\x80` \x01\x90Q\x81\x01\x90a1\n\x91\x90aTxV[a\x01\xA2a\x05KV[`\0a1\x1E\x83\x83a:\xA1V[a1mWP\x81T`\x01\x80\x82\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x86\x16\x90\x81\x17\x90\x91U\x85T\x90\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x16\xF5V[P`\0a\x16\xF5V[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02\x84\x01` R`@\x81 T\x80a2\x02WPP\x82T`@\x80Q\x80\x82\x01\x82R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x80\x83R` \x80\x84\x01\x87\x81R`\0\x87\x81R`\x01\x80\x8C\x01\x84R\x87\x82 \x96Q\x87T`\x01`\x01`\xA0\x1B\x03\x19\x16\x96\x16\x95\x90\x95\x17\x86U\x90Q\x94\x84\x01\x94\x90\x94U\x94\x82\x01\x80\x89U\x90\x83R`\x02\x88\x01\x90\x94R\x91\x90 \x91\x90\x91Ua\x18vV[`\0\x19\x01`\0\x90\x81R`\x01\x80\x86\x01` R`@\x82 \x01\x83\x90U\x90Pa\x18vV[`\0\x80`\0\x80`\0a24\x87\x87aC\xA4V[\x91P\x91P`\0a2D\x83\x83aC\xD5V[`\0\x8A\x81R`\t` \x90\x81R`@\x80\x83 \x84\x84R`\x02\x01\x90\x91R\x81 \x80T`\x01\x82\x01T\x91\x97P\x92\x93P\x90a2w\x83a:\x8FV[\x80a2\x86WPa2\x86\x82a:\x8FV[\x80a2\xA7WPa2\x96\x8C\x87a:\xC2V[\x80\x15a2\xA7WPa2\xA7\x8C\x86a:\xC2V[\x90P\x80a2\xC2Wa2\xB7\x8Ca&\x83V[a2\xC2a\x02\ta\x16\xFBV[a2\xCC\x83\x83aD\x08V[\x98Pa2\xD8\x83\x83aD-V[\x97PPPPPPP\x93P\x93P\x93\x90PV[{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a4\x08W\x83T`\0\x19\x80\x83\x01\x91\x90\x81\x01\x90`\0\x90\x87\x90\x83\x90\x81\x10a3HW\xFE[`\0\x91\x82R` \x90\x91 \x01T\x87T`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91P\x81\x90\x88\x90\x85\x90\x81\x10a3qW\xFE[`\0\x91\x82R` \x80\x83 \x91\x90\x91\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x17\x90U\x91\x83\x16\x81R`\x01\x89\x81\x01\x90\x92R`@\x90 \x90\x84\x01\x90U\x86T\x87\x90\x80a3\xBAW\xFE[`\0\x82\x81R` \x80\x82 \x83\x01`\0\x19\x90\x81\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U\x90\x92\x01\x90\x92U`\x01`\x01`\xA0\x1B\x03\x88\x16\x82R`\x01\x89\x81\x01\x90\x91R`@\x82 \x91\x90\x91U\x94Pa\x16\xF5\x93PPPPV[`\0\x91PPa\x16\xF5V[`\0a\x16\xF2\x83\x83a\x02\taDDV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x02\x83\x01` R`@\x81 T\x80\x15a4\x08W\x83T`\0\x19\x90\x81\x01`\0\x81\x81R`\x01\x87\x81\x01` \x90\x81R`@\x80\x84 \x95\x87\x01\x84R\x80\x84 \x86T\x81T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x17\x83U\x88\x86\x01\x80T\x93\x87\x01\x93\x90\x93U\x88T\x82\x16\x87R`\x02\x8D\x01\x80\x86R\x84\x88 \x9A\x90\x9AU\x88T\x16\x90\x97U\x84\x90U\x93\x89U\x93\x87\x16\x82R\x93\x90\x92R\x81 U\x90Pa\x16\xF5V[``\x80\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a4\xDEW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a5\x08W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x83Q\x81\x10\x15a\x07\xFFWa5&\x84\x82\x81Q\x81\x10a$\xACW\xFE[\x82\x82\x81Q\x81\x10a52W\xFE[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a5\x0EV[``\x80``a5`\x85a)>V[\x91P\x91Pa5p\x82Q\x85Qa\x1E\x12V[a5\x80`\0\x83Q\x11a\x02\x0Fa\x05KV[`\0[\x82Q\x81\x10\x15a5\xDAWa5\xD2\x85\x82\x81Q\x81\x10a5\x9BW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x84\x83\x81Q\x81\x10a5\xB8W\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x08a\x05KV[`\x01\x01a5\x83V[P\x94\x93PPPPV[``\x80``\x80`\0a5\xF4\x86a)\xA0V[\x91P\x91P`\0a6\x03\x8Ba)8V[\x90P`\0\x8C`\x01\x81\x11\x15a6\x13W\xFE[\x14a6\xB6W\x80`\x01`\x01`\xA0\x1B\x03\x16ct\xF3\xB0\t\x8C\x8C\x8C\x87\x87a64aD\x81V[\x8F`@\x01Q`@Q\x88c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6[\x97\x96\x95\x94\x93\x92\x91\x90a]fV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a6uW`\0\x80\xFD[PZ\xF1\x15\x80\x15a6\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xB1\x91\x90\x81\x01\x90aT\x05V[a7OV[\x80`\x01`\x01`\xA0\x1B\x03\x16c\xD5\xC0\x96\xC4\x8C\x8C\x8C\x87\x87a6\xD2aD\x81V[\x8F`@\x01Q`@Q\x88c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6\xF9\x97\x96\x95\x94\x93\x92\x91\x90a]fV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a7\x13W`\0\x80\xFD[PZ\xF1\x15\x80\x15a7'W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra7O\x91\x90\x81\x01\x90aT\x05V[\x80\x95P\x81\x96PPPa7e\x87Q\x86Q\x86QaD\xFBV[`\0\x8C`\x01\x81\x11\x15a7sW\xFE[\x14a7\x8AWa7\x85\x89\x89\x89\x88\x88aE\x13V[a7\x97V[a7\x97\x8A\x89\x89\x88\x88aFZV[\x95PPPP\x96P\x96P\x96\x93PPPPV[`\0a7\xB4\x85\x84aC\xD5V[`\0\x87\x81R`\t` \x90\x81R`@\x80\x83 \x84\x84R`\x02\x01\x90\x91R\x90 \x90\x91Pa7\xDD\x85\x84aB\xD1V[\x90UPPPPPPV[`\0[\x82Q\x81\x10\x15a\x0E\0W\x81\x81\x81Q\x81\x10a7\xFFW\xFE[` \x02` \x01\x01Q`\x07`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x85\x84\x81Q\x81\x10a8(W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x82R\x81\x01\x91\x90\x91R`@\x01`\0 U`\x01\x01a7\xEAV[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0Wa8\x95\x81\x84\x83\x81Q\x81\x10a8}W\xFE[` \x02` \x01\x01Q\x84aC\x8C\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\x01\x01a8dV[``\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a8\xB7W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8\xE1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x83Q\x81\x10\x15a\x07\xFFW\x82a9\x11W\x83\x81\x81Q\x81\x10a9\x01W\xFE[` \x02` \x01\x01Q`\0\x03a9&V[\x83\x81\x81Q\x81\x10a9\x1DW\xFE[` \x02` \x01\x01Q[\x82\x82\x81Q\x81\x10a92W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a8\xE7V[`\0\x80\x84`\x01\x81\x11\x15a9TW\xFE[\x14a9_W\x81a\t\xE1V[P\x90\x92\x91PPV[`\0\x80\x84`\x01\x81\x11\x15a9vW\xFE[\x14a\x07\xFFW\x82a\t\xE1V[`\0a\"j\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83\x10a\x01\xA5a\x05KV[`\0\x82\x82\x01a\x16\xF2\x82\x84\x12\x80\x15\x90a9\xC9WP\x84\x82\x12\x15[\x80a9\xDEWP`\0\x84\x12\x80\x15a9\xDEWP\x84\x82\x12[`\0a\x05KV[`\0\x81\x83\x03a\x16\xF2\x82\x84\x12\x80\x15\x90a9\xFDWP\x84\x82\x13\x15[\x80a:\x12WP`\0\x84\x12\x80\x15a:\x12WP\x84\x82\x13[`\x01a\x05KV[`\0\x81\x81R`\t` R`@\x81 \x80T`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x84\x92\x90\x91\x16\x90\x82\x90\x81a:M\x86\x85aC\xD5V[`\0\x81\x81R`\x02\x84\x01` R`@\x90 \x80T`\x01\x82\x01T\x91\x99P\x91\x92Pa:t\x82\x82aD\x08V[\x96Pa:\x80\x82\x82aD-V[\x94PPPPP\x91\x93\x95\x90\x92\x94PV[`\0a:\x9A\x82a2\xE9V[\x15\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x01\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[`\0\x82\x81R`\t` R`@\x81 \x80T`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x14\x80a:\xFAWP`\x01\x81\x01T`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x14[\x80\x15a\t\xE1WPPP`\x01`\x01`\xA0\x1B\x03\x16\x15\x15\x91\x90PV[`\0\x82\x81R`\x08` R`@\x81 a\t\xE1\x81\x84a:\xA1V[`\0\x82\x81R`\x01` R`@\x81 a\t\xE1\x81\x84aG\xD0V[`\0\x80`\x02\x85`\x02\x81\x11\x15a;TW\xFE[\x14\x15a;jWa;e\x86\x85\x85aG\xF1V[a;\x94V[`\x01\x85`\x02\x81\x11\x15a;xW\xFE[\x14\x15a;\x89Wa;e\x86\x85\x85aG\xFFV[a;\x94\x86\x85\x85aH\rV[\x82\x15a;\xAEWa;\xAE`\x01`\x01`\xA0\x1B\x03\x85\x163\x85a\x1E\xA6V[PP`\0\x81\x90\x03\x94\x90\x93P\x91PPV[`\0\x80`\x02\x85`\x02\x81\x11\x15a;\xCFW\xFE[\x14\x15a;\xE5Wa;\xE0\x86\x85\x85aH\x1BV[a<\x0FV[`\x01\x85`\x02\x81\x11\x15a;\xF3W\xFE[\x14\x15a<\x04Wa;\xE0\x86\x85\x85aH)V[a<\x0F\x86\x85\x85aH7V[\x82\x15a<*Wa<*`\x01`\x01`\xA0\x1B\x03\x85\x1630\x86a+\xA6V[P\x90\x94`\0\x86\x90\x03\x94P\x92PPPV[`\0\x80`\x02\x85`\x02\x81\x11\x15a<KW\xFE[\x14\x15a<cWa<\\\x86\x85\x85aHEV[\x90Pa<\x90V[`\x01\x85`\x02\x81\x11\x15a<qW\xFE[\x14\x15a<\x82Wa<\\\x86\x85\x85aHUV[a<\x8D\x86\x85\x85aHeV[\x90P[`\0\x91P\x94P\x94\x92PPPV[F\x90V[``\x80`\0\x80`\0\x80a<\xB3\x87a:\x19V[\x92\x97P\x90\x95P\x93P\x91PP`\x01`\x01`\xA0\x1B\x03\x84\x16\x15\x80a<\xDBWP`\x01`\x01`\xA0\x1B\x03\x82\x16\x15[\x15a=\x04WPP`@\x80Q`\0\x80\x82R` \x82\x01\x90\x81R\x81\x83\x01\x90\x92R\x94P\x92Pa)\x9B\x91PPV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x91` \x83\x01\x90\x806\x837\x01\x90PP\x95P\x83\x86`\0\x81Q\x81\x10a=2W\xFE[` \x02` \x01\x01\x90`\x01`\x01`\xA0\x1B\x03\x16\x90\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP\x81\x86`\x01\x81Q\x81\x10a=`W\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01R`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x92\x90\x91\x90\x83\x01\x90\x806\x837\x01\x90PP\x94P\x82\x85`\0\x81Q\x81\x10a=\xA7W\xFE[` \x02` \x01\x01\x81\x81RPP\x80\x85`\x01\x81Q\x81\x10a=\xC1W\xFE[` \x02` \x01\x01\x81\x81RPPPPPP\x91P\x91V[`\0\x81\x81R`\x08` R`@\x90 ``\x90\x81\x90a=\xF2\x81aC+V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a>\x08W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a>2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92P\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a>MW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a>wW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x83Q\x81\x10\x15a>\xF6W`\0a>\x92\x83\x83aHuV[\x90P\x80\x85\x83\x81Q\x81\x10a>\xA1W\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x81\x01\x91\x90\x91R`\0\x88\x81R`\x07\x82R`@\x80\x82 \x93\x85\x16\x82R\x92\x90\x91R T\x84Q\x85\x90\x84\x90\x81\x10a>\xE2W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RP`\x01\x01a>}V[PP\x91P\x91V[`\0\x81\x81R`\x01` R`@\x90 ``\x90\x81\x90a?\x19\x81aC+V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?/W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a?YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92P\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?tW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a?\x9EW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x83Q\x81\x10\x15a>\xF6Wa?\xB7\x82\x82aH\xA2V[\x85\x83\x81Q\x81\x10a?\xC3W\xFE[` \x02` \x01\x01\x85\x84\x81Q\x81\x10a?\xD6W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a?\xA4V[`\0a@\x04\x82a'\xB4V[a@\r\x83a'\xA1V[\x01\x92\x91PPV[`\0\x81\x83\x10\x15a@$W\x81a\x16\xF2V[P\x90\x91\x90PV[`\0\x81\x83\x10a@$W\x81a\x16\xF2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x81\x81R`\x0B` \x90\x81R`@\x80\x83 \x94\x88\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x85\x90UQ\x7F\x18\xE1\xEAA9\xE6\x84\x13\xD7\xD0\x8A\xA7R\xE7\x15h\xE3k,[\xF9@\x893\x14\xC2\xC5\xB0\x1E\xAA\x0CB\x90a\x19\xD0\x90\x85\x90a]>V[`\0\x80a@\xA0aH\xC6V[\x90PB\x81\x10\x15a@\xB4W`\0\x91PPa\x16\xF5V[`\0a@\xBEaH\xD2V[\x90P\x80a@\xD0W`\0\x92PPPa\x16\xF5V[`\0\x81a@\xDBaI\xE3V[\x80Q` \x91\x82\x01 `@Qa@\xF7\x93\x923\x91\x8A\x91\x89\x91\x01a]\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0aA\x1A\x82aJ2V[\x90P`\0\x80`\0aA)aJNV[\x92P\x92P\x92P`\0`\x01\x85\x85\x85\x85`@Q`\0\x81R` \x01`@R`@QaAT\x94\x93\x92\x91\x90a^\x1CV[` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15aAvW=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16\x15\x80\x15\x90aA\xACWP\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14[\x9B\x9APPPPPPPPPPPV[`\0\x80`\0\x80aA\xCA\x86a?\xF9V[\x90P`\0aA\xD7\x86a?\xF9V[\x90PaA\xEEaA\xE5\x88a'\xCAV[a*?\x88a'\xCAV[`\xA0\x8A\x01R`@Q\x7F\x9D,\x11\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x16\x90c\x9D,\x11\x0C\x90aB<\x90\x8C\x90\x86\x90\x86\x90`\x04\x01a^\x94V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aBVW`\0\x80\xFD[PZ\xF1\x15\x80\x15aBjW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90aB\x8E\x91\x90aYhV[\x92P`\0\x80aB\xA6\x8B`\0\x01Q\x8C``\x01Q\x87a/\xF7V[\x90\x92P\x90PaB\xB5\x89\x83aCEV[\x96PaB\xC1\x88\x82aCvV[\x95PPPPP\x94P\x94P\x94\x91PPV[`\0\x80aB\xE9aB\xE0\x85a'\xCAV[a*?\x85a'\xCAV[\x90Pa\t\xE1aB\xF7\x85a'\xA1V[aC\0\x85a'\xA1V[\x83c\xFF\xFF\xFF\xFF\x16aJuV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02\x91\x90\x91\x01` R`@\x90 T\x90V[T\x90V[`\0\x90\x81R`\x01\x91\x82\x01` R`@\x90 \x01T\x90V[`\0\x80aC[\x83aCU\x86a'\xA1V[\x90a\x19EV[\x90P`\0aCh\x85a'\xB4V[\x90PCa\x12\xA6\x83\x83\x83aJ\x83V[`\0\x80aC[\x83aC\x86\x86a'\xA1V[\x90aJ\xBCV[`\0\x91\x82R`\x01\x92\x83\x01` R`@\x90\x91 \x90\x91\x01UV[`\0\x80\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x10aC\xC7W\x82\x84aC\xCAV[\x83\x83[\x91P\x91P\x92P\x92\x90PV[`\0\x82\x82`@Q` \x01aC\xEA\x92\x91\x90a[\x06V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x92\x91PPV[`\0a\x16\xF2aD\x16\x84a'\xA1V[aD\x1F\x84a'\xA1V[aD(\x86a'\xCAV[aJ\x83V[`\0a\x16\xF2aD;\x84a'\xB4V[aD\x1F\x84a'\xB4V[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02\x84\x01` R`@\x81 TaDk\x81\x15\x15\x84a\x05KV[aDx\x85`\x01\x83\x03aC/V[\x95\x94PPPPPV[`\0aD\x8Ba\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x16cU\xC6v(`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aD\xC3W`\0\x80\xFD[PZ\xFA\x15\x80\x15aD\xD7W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xCE\x91\x90aYhV[a\x0F\xA0\x82\x84\x14\x80\x15aE\x0CWP\x81\x83\x14[`ga\x05KV[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aE-W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aEWW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x85QQ\x81\x10\x15aFPW`\0\x84\x82\x81Q\x81\x10aEuW\xFE[` \x02` \x01\x01Q\x90PaE\xA5\x87` \x01Q\x83\x81Q\x81\x10aE\x92W\xFE[` \x02` \x01\x01Q\x82\x10\x15a\x01\xF9a\x05KV[`\0\x87`\0\x01Q\x83\x81Q\x81\x10aE\xB7W\xFE[` \x02` \x01\x01Q\x90PaE\xD1\x81\x83\x8B\x8B``\x01Qa\x1D8V[`\0\x85\x84\x81Q\x81\x10aE\xDFW\xFE[` \x02` \x01\x01Q\x90PaE\xFBaE\xF5\x83a\x1BAV[\x82a\x1F\x11V[aF*aF\x08\x84\x83a\x19EV[\x89\x86\x81Q\x81\x10aF\x14W\xFE[` \x02` \x01\x01QaCv\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x85\x85\x81Q\x81\x10aF6W\xFE[` \x02` \x01\x01\x81\x81RPPPPP\x80`\x01\x01\x90PaE]V[P\x95\x94PPPPPV[```\0\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aFvW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aF\xA0W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x86QQ\x81\x10\x15aG\xC6W`\0\x85\x82\x81Q\x81\x10aF\xBEW\xFE[` \x02` \x01\x01Q\x90PaF\xEE\x88` \x01Q\x83\x81Q\x81\x10aF\xDBW\xFE[` \x02` \x01\x01Q\x82\x11\x15a\x01\xFAa\x05KV[`\0\x88`\0\x01Q\x83\x81Q\x81\x10aG\0W\xFE[` \x02` \x01\x01Q\x90PaG\x1A\x81\x83\x8C\x8C``\x01Qa\x1CZV[aG#\x81a\x198V[\x15aG5WaG2\x84\x83a\x19EV[\x93P[`\0\x86\x84\x81Q\x81\x10aGCW\xFE[` \x02` \x01\x01Q\x90PaGYaE\xF5\x83a\x1BAV[\x80\x83\x10\x15aGxWaGs\x83\x82\x03\x8A\x86\x81Q\x81\x10aF\x14W\xFE[aG\xA0V[aG\xA0\x81\x84\x03\x8A\x86\x81Q\x81\x10aG\x8AW\xFE[` \x02` \x01\x01QaCE\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x86\x85\x81Q\x81\x10aG\xACW\xFE[` \x02` \x01\x01\x81\x81RPPPPP\x80`\x01\x01\x90PaF\xA6V[PaFP\x81a\x19\xDEV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[a\x0E\0\x83\x83aJ\xD2\x84aK\rV[a\x0E\0\x83\x83aJ\xD2\x84aK\xB8V[a\x0E\0\x83\x83aJ\xD2\x84aL\x13V[a\x0E\0\x83\x83aLb\x84aK\rV[a\x0E\0\x83\x83aLb\x84aK\xB8V[a\x0E\0\x83\x83aLb\x84aL\x13V[`\0a\t\xE1\x84\x84aL\x83\x85aK\rV[`\0a\t\xE1\x84\x84aL\x83\x85aK\xB8V[`\0a\t\xE1\x84\x84aL\x83\x85aL\x13V[`\0\x82`\0\x01\x82\x81T\x81\x10aH\x86W\xFE[`\0\x91\x82R` \x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x93\x92PPPV[`\0\x90\x81R`\x01\x91\x82\x01` R`@\x90 \x80T\x91\x01T`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91V[`\0a\x12\xCE`\0aL\x9DV[`\0\x805`\xE0\x1C\x80c\xB9\\\xAC(\x81\x14aI\x1AWc\x8B\xDB9\x13\x81\x14aIBWcR\xBB\xBE)\x81\x14aIjWc\x94[\xCE\xC9\x81\x14aI\x92Wc\xFAng\x1D\x81\x14aI\xBAW`\0\x92PaI\xDEV[\x7F?{q%+\xD1\x91\x13\xFFH\xC1\x9Cn\0J\x9B\xCF\xCC\xA3 \xA0\xD7MX\xE8Xw\xCB\xD7\xDC\xAEX\x92PaI\xDEV[\x7F\x8B\xBCW\xF6n\xA96\x90/P\xA7\x1C\xE1+\x92\xC4?<S@\xBB@\xC2|N\x90\xAB\x84\xEE\xAE3S\x92PaI\xDEV[\x7F\xE1\x92\xDC\xBC\x14;\x1E$J\xD7;\x81?\xD3\xC0\x97\xB82\xAD&\n\x15s@\xB4\xE5\xE5\xBE\xDA\x06z\xBE\x92PaI\xDEV[\x7F\x9B\xFCC\xA4\xD9\x83\x13\xC6vi\x86\xFF\xD7\xC9\x16\xC7H\x15f\xD9\xF2$\xC6\x81\x9A\xF0\xA53\x88\xAC\xED:\x92PaI\xDEV[\x7F\xA3\xF8e\xAA5\x1EQ\xCF\xEB@\xF5\x17\x8D\x15d\xBBb\x9F\xE9\x03\x0B\x83\xCA\xF66\x1D\x1B\xAA\xF5\xB9\x0BZ\x92P[PP\x90V[```\x006\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RPP\x82Q\x92\x93PPP`\x80\x10\x15a\x05HW`\x806\x03\x81R\x90V[`\0aJ<a(\x9BV[\x82`@Q` \x01a\x11.\x92\x91\x90a[-V[`\0\x80`\0aJ]` aL\x9DV[\x92PaJi`@aL\x9DV[\x91Pa\x08A``aL\x9DV[`\xE0\x1B`p\x91\x90\x91\x1B\x01\x01\x90V[`\0\x83\x83\x01aJ\xB1\x85\x82\x10\x80\x15\x90aJ\xA9WPn\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x10[a\x02\x0Ea\x05KV[aDx\x85\x85\x85aJuV[`\0aJ\xCC\x83\x83\x11\x15`\x01a\x05KV[P\x90\x03\x90V[`\0\x80aJ\xE2\x83aC\x86\x86a'\xA1V[\x90P`\0aJ\xF3\x84aCU\x87a'\xB4V[\x90P`\0aK\0\x86a'\xCAV[\x90Pa\x12\xA6\x83\x83\x83aJ\x83V[`\0\x80`\0\x80`\0aK\x1E\x89a:\x19V[\x94PP\x93P\x93P\x93P`\0\x83`\x01`\x01`\xA0\x1B\x03\x16\x89`\x01`\x01`\xA0\x1B\x03\x16\x14\x15aKiW`\0aKS\x84\x89\x8Bc\xFF\xFF\xFF\xFF\x16V[\x90PaK_\x81\x85aL\xA7V[\x90\x93P\x90PaK\x8BV[`\0aKy\x83\x89\x8Bc\xFF\xFF\xFF\xFF\x16V[\x90PaK\x85\x81\x84aL\xA7V[\x90\x92P\x90P[aK\x95\x83\x83aB\xD1V[\x85UaK\xA1\x83\x83aL\xC3V[`\x01\x90\x95\x01\x94\x90\x94UP\x91\x92PPP\x94\x93PPPPV[`\0\x80aK\xC5\x86\x86a'\x1BV[\x90P`\0aK\xD7\x82\x85\x87c\xFF\xFF\xFF\xFF\x16V[`\0\x88\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x8B\x16\x84R\x90\x91R\x90 \x81\x90U\x90PaL\x08\x81\x83aL\xA7V[\x97\x96PPPPPPPV[`\0\x84\x81R`\x01` R`@\x81 \x81aL,\x82\x87a4\x12V[\x90P`\0aL>\x82\x86\x88c\xFF\xFF\xFF\xFF\x16V[\x90PaLK\x83\x88\x83a1uV[PaLV\x81\x83aL\xA7V[\x98\x97PPPPPPPPV[`\0\x80aLr\x83aCU\x86a'\xA1V[\x90P`\0aJ\xF3\x84aC\x86\x87a'\xB4V[`\0\x80aL\x8F\x84a'\xA1V[\x90PCaDx\x82\x85\x83aJ\x83V[6\x01`\x7F\x19\x015\x90V[`\0aL\xB2\x82a'\xB4V[aL\xBB\x84a'\xB4V[\x03\x93\x92PPPV[`\0a\x16\xF2aL\xD1\x84a'\xB4V[aL\xDA\x84a'\xB4V[`\0aJuV[`@\x80Qa\x01 \x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x80\x83\x01\x82\x90R`\x80\x83\x01\x82\x90R`\xA0\x83\x01\x82\x90R`\xC0\x83\x01\x82\x90R`\xE0\x83\x01\x91\x90\x91Ra\x01\0\x90\x91\x01R\x90V[`@\x80Q`\x80\x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[`@Q\x80`\x80\x01`@R\x80``\x81R` \x01``\x81R` \x01``\x81R` \x01`\0\x15\x15\x81RP\x90V[`@Q\x80`\xA0\x01`@R\x80`\0\x80\x19\x16\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01``\x81RP\x90V[\x805a\x16\xF5\x81a_ZV[`\0\x82`\x1F\x83\x01\x12aM\xD1W\x80\x81\xFD[\x815aM\xE4aM\xDF\x82a_\x04V[a^\xDDV[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aN\x05W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x815aN\x1B\x81a_ZV[\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aN\x08V[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12aNHW\x80\x81\xFD[\x815aNVaM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01`\0[\x84\x81\x10\x15aN-W\x815\x87\x01`\xA0\x80`\x1F\x19\x83\x8C\x03\x01\x12\x15aN\x88W`\0\x80\xFD[aN\x91\x81a^\xDDV[\x85\x83\x015\x81R`@\x80\x84\x015\x87\x83\x01R``\x80\x85\x015\x82\x84\x01R`\x80\x91P\x81\x85\x015\x81\x84\x01RP\x82\x84\x015\x92Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x15aN\xD3W`\0\x80\xFD[aN\xE1\x8C\x88\x85\x87\x01\x01aO\xC0V[\x90\x82\x01R\x86RPP\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aNgV[`\0\x82`\x1F\x83\x01\x12aO\tW\x80\x81\xFD[\x815aO\x17aM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aO8W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x815\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aO;V[`\0\x82`\x1F\x83\x01\x12aOgW\x80\x81\xFD[\x81QaOuaM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aO\x96W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x81Q\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aO\x99V[\x805a\x16\xF5\x81a_oV[`\0\x82`\x1F\x83\x01\x12aO\xD0W\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aO\xE6W\x81\x82\xFD[aO\xF9`\x1F\x82\x01`\x1F\x19\x16` \x01a^\xDDV[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15aP\x10W`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[\x805a\x16\xF5\x81a_}V[\x805`\x02\x81\x10a\x16\xF5W`\0\x80\xFD[\x805`\x04\x81\x10a\x16\xF5W`\0\x80\xFD[`\0`\x80\x82\x84\x03\x12\x15aPcW\x80\x81\xFD[aPm`\x80a^\xDDV[\x90P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aP\x87W`\0\x80\xFD[aP\x93\x85\x83\x86\x01aM\xC1V[\x83R` \x84\x015\x91P\x80\x82\x11\x15aP\xA9W`\0\x80\xFD[aP\xB5\x85\x83\x86\x01aN\xF9V[` \x84\x01R`@\x84\x015\x91P\x80\x82\x11\x15aP\xCEW`\0\x80\xFD[PaP\xDB\x84\x82\x85\x01aO\xC0V[`@\x83\x01RPaP\xEE\x83``\x84\x01aO\xB5V[``\x82\x01R\x92\x91PPV[`\0`\x80\x82\x84\x03\x12\x15aQ\nW\x80\x81\xFD[aQ\x14`\x80a^\xDDV[\x90P\x815aQ!\x81a_ZV[\x81R` \x82\x015aQ1\x81a_oV[` \x82\x01R`@\x82\x015aQD\x81a_ZV[`@\x82\x01R``\x82\x015aP\xEE\x81a_oV[`\0` \x82\x84\x03\x12\x15aQhW\x80\x81\xFD[\x815a\x16\xF2\x81a_ZV[`\0\x80`@\x83\x85\x03\x12\x15aQ\x85W\x80\x81\xFD[\x825aQ\x90\x81a_ZV[\x91P` \x83\x015aQ\xA0\x81a_ZV[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15aQ\xBFW\x80\x81\xFD[\x835aQ\xCA\x81a_ZV[\x92P` \x84\x015aQ\xDA\x81a_ZV[\x91P`@\x84\x015aQ\xEA\x81a_oV[\x80\x91PP\x92P\x92P\x92V[`\0\x80`@\x83\x85\x03\x12\x15aR\x07W\x81\x82\xFD[\x825aR\x12\x81a_ZV[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aR-W\x81\x82\xFD[aR9\x85\x82\x86\x01aM\xC1V[\x91PP\x92P\x92\x90PV[`\0` \x80\x83\x85\x03\x12\x15aRUW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aRkW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aR{W\x82\x83\xFD[\x805aR\x89aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`\x80\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aR\xA7W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aS\x10W\x80\x82\x8B\x03\x12\x15aR\xC1W\x87\x88\xFD[aR\xCA\x81a^\xDDV[aR\xD4\x8B\x84aP)V[\x81R\x87\x83\x015\x88\x82\x01R`@aR\xEC\x8C\x82\x86\x01aM\xB6V[\x90\x82\x01R``\x83\x81\x015\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aR\xABV[P\x90\x98\x97PPPPPPPPV[`\0` \x80\x83\x85\x03\x12\x15aS0W\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aSFW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aSVW\x82\x83\xFD[\x805aSdaM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`\xA0\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aS\x82W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aS\x10W\x80\x82\x8B\x03\x12\x15aS\x9CW\x87\x88\xFD[aS\xA5\x81a^\xDDV[aS\xAF\x8B\x84aPCV[\x81RaS\xBD\x8B\x89\x85\x01aM\xB6V[\x81\x89\x01R`@\x83\x81\x015\x90\x82\x01R``aS\xD9\x8C\x82\x86\x01aM\xB6V[\x90\x82\x01R`\x80aS\xEB\x8C\x85\x83\x01aM\xB6V[\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aS\x86V[`\0\x80`@\x83\x85\x03\x12\x15aT\x17W\x81\x82\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aT.W\x83\x84\xFD[aT:\x86\x83\x87\x01aOWV[\x93P` \x85\x01Q\x91P\x80\x82\x11\x15aTOW\x82\x83\xFD[PaR9\x85\x82\x86\x01aOWV[`\0` \x82\x84\x03\x12\x15aTmW\x80\x81\xFD[\x815a\x16\xF2\x81a_oV[`\0` \x82\x84\x03\x12\x15aT\x89W\x80\x81\xFD[\x81Qa\x16\xF2\x81a_oV[`\0` \x82\x84\x03\x12\x15aT\xA5W\x80\x81\xFD[P5\x91\x90PV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15aT\xC1W\x81\x82\xFD[\x845\x93P` \x85\x015aT\xD3\x81a_ZV[\x92P`@\x85\x015aT\xE3\x81a_ZV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aT\xFEW\x81\x82\xFD[aU\n\x87\x82\x88\x01aPRV[\x91PP\x92\x95\x91\x94P\x92PV[`\0\x80`@\x83\x85\x03\x12\x15aU(W\x81\x82\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aR-W\x81\x82\xFD[`\0\x80`\0``\x84\x86\x03\x12\x15aUYW\x80\x81\xFD[\x835\x92P` \x80\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aUxW\x83\x84\xFD[aU\x84\x88\x83\x89\x01aM\xC1V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aU\x99W\x83\x84\xFD[P\x85\x01`\x1F\x81\x01\x87\x13aU\xAAW\x82\x83\xFD[\x805aU\xB8aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x8B\x10\x15aU\xD4W\x86\x87\xFD[\x86\x94P[\x83\x85\x10\x15aU\xFFW\x805aU\xEB\x81a_ZV[\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01aU\xD8V[P\x80\x95PPPPPP\x92P\x92P\x92V[`\0\x80`@\x83\x85\x03\x12\x15aV!W\x81\x82\xFD[\x825\x91P` \x83\x015aQ\xA0\x81a_ZV[`\0` \x82\x84\x03\x12\x15aVDW\x80\x81\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x16\xF2W\x81\x82\xFD[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15aVpW\x81\x82\xFD[\x845aV{\x81a_ZV[\x93P` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aV\x97W\x83\x84\xFD[aV\xA3\x88\x83\x89\x01aM\xC1V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aV\xB8W\x83\x84\xFD[aV\xC4\x88\x83\x89\x01aN\xF9V[\x93P``\x87\x015\x91P\x80\x82\x11\x15aV\xD9W\x82\x83\xFD[PaU\n\x87\x82\x88\x01aO\xC0V[`\0` \x82\x84\x03\x12\x15aV\xF7W\x80\x81\xFD[\x815a\x16\xF2\x81a_}V[`\0\x80`\0\x80`\xE0\x85\x87\x03\x12\x15aW\x17W\x81\x82\xFD[aW!\x86\x86aP4V[\x93P` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aW=W\x83\x84\xFD[aWI\x88\x83\x89\x01aN8V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aW^W\x83\x84\xFD[PaWk\x87\x82\x88\x01aM\xC1V[\x92PPaW{\x86``\x87\x01aP\xF9V[\x90P\x92\x95\x91\x94P\x92PV[`\0\x80`\0\x80`\0\x80a\x01 \x87\x89\x03\x12\x15aW\x9FW\x83\x84\xFD[aW\xA9\x88\x88aP4V[\x95P` \x80\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aW\xC6W\x86\x87\xFD[aW\xD2\x8B\x83\x8C\x01aN8V[\x97P`@\x8A\x015\x91P\x80\x82\x11\x15aW\xE7W\x86\x87\xFD[aW\xF3\x8B\x83\x8C\x01aM\xC1V[\x96PaX\x02\x8B``\x8C\x01aP\xF9V[\x95P`\xE0\x8A\x015\x91P\x80\x82\x11\x15aX\x17W\x84\x85\xFD[P\x88\x01`\x1F\x81\x01\x8A\x13aX(W\x83\x84\xFD[\x805aX6aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x8E\x10\x15aXRW\x87\x88\xFD[\x87\x94P[\x83\x85\x10\x15aXtW\x805\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01aXVV[P\x80\x96PPPPPPa\x01\0\x87\x015\x90P\x92\x95P\x92\x95P\x92\x95V[`\0\x80`\0\x80`\xE0\x85\x87\x03\x12\x15aX\xA4W\x81\x82\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aX\xBBW\x83\x84\xFD[\x90\x86\x01\x90`\xC0\x82\x89\x03\x12\x15aX\xCEW\x83\x84\xFD[aX\xD8`\xC0a^\xDDV[\x825\x81RaX\xE9\x89` \x85\x01aP4V[` \x82\x01R`@\x83\x015aX\xFC\x81a_ZV[`@\x82\x01RaY\x0E\x89``\x85\x01aM\xB6V[``\x82\x01R`\x80\x83\x015`\x80\x82\x01R`\xA0\x83\x015\x82\x81\x11\x15aY.W\x85\x86\xFD[aY:\x8A\x82\x86\x01aO\xC0V[`\xA0\x83\x01RP\x80\x96PPPPaYS\x86` \x87\x01aP\xF9V[\x93\x96\x93\x95PPPP`\xA0\x82\x015\x91`\xC0\x015\x90V[`\0` \x82\x84\x03\x12\x15aYyW\x80\x81\xFD[PQ\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x16\x90RV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aY\xC5W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aY\xA0V[P\x94\x95\x94PPPPPV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aY\xC5W\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aY\xE3V[`\0\x81Q\x80\x84RaZ\x17\x81` \x86\x01` \x86\x01a_$V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\0a\x01 \x82Q`\x02\x81\x10aZ<W\xFE[\x80\x85RP` \x83\x01QaZR` \x86\x01\x82aY\x80V[P`@\x83\x01QaZe`@\x86\x01\x82aY\x80V[P``\x83\x01Q``\x85\x01R`\x80\x83\x01Q`\x80\x85\x01R`\xA0\x83\x01Q`\xA0\x85\x01R`\xC0\x83\x01QaZ\x96`\xC0\x86\x01\x82aY\x80V[P`\xE0\x83\x01QaZ\xA9`\xE0\x86\x01\x82aY\x80V[Pa\x01\0\x80\x84\x01Q\x82\x82\x87\x01Ra\x12\xA6\x83\x87\x01\x82aY\xFFV[\x91\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`$\x01\x90V[`\0\x82\x84\x837\x91\x01\x90\x81R\x91\x90PV[`\0\x82QaZ\xFC\x81\x84` \x87\x01a_$V[\x91\x90\x91\x01\x92\x91PPV[k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19``\x93\x84\x1B\x81\x16\x82R\x91\x90\x92\x1B\x16`\x14\x82\x01R`(\x01\x90V[\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R\x91\x90\x92\x16` \x82\x01R`@\x81\x01\x91\x90\x91R``\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x83\x16\x81R`@\x81\x01a[\xB4\x83a_PV[\x82` \x83\x01R\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[`\0` \x82Ra\x16\xF2` \x83\x01\x84aY\x8DV[`\0`@\x82Ra\\\0`@\x83\x01\x85aY\x8DV[\x82\x81\x03` \x84\x81\x01\x91\x90\x91R\x84Q\x80\x83R\x85\x82\x01\x92\x82\x01\x90\x84[\x81\x81\x10\x15a\\?W\x84Q`\x01`\x01`\xA0\x1B\x03\x16\x83R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01a\\\x1AV[P\x90\x97\x96PPPPPPPV[`\0``\x82Ra\\_``\x83\x01\x86aY\x8DV[\x82\x81\x03` \x84\x01Ra\\q\x81\x86aY\xD0V[\x90P\x82\x81\x03`@\x84\x01Ra\x12\xA6\x81\x85aY\xD0V[`\0`\x80\x82Ra\\\x98`\x80\x83\x01\x87aY\x8DV[\x82\x81\x03` \x84\x01Ra\\\xAA\x81\x87aY\xD0V[\x90P\x82\x81\x03`@\x84\x01Ra\\\xBE\x81\x86aY\xD0V[\x90P\x82\x81\x03``\x84\x01RaL\x08\x81\x85aY\xFFV[`\0``\x82Ra\\\xE5``\x83\x01\x86aY\x8DV[\x82\x81\x03` \x84\x01Ra\\\xF7\x81\x86aY\xD0V[\x91PP\x82`@\x83\x01R\x94\x93PPPPV[`\0` \x82Ra\x16\xF2` \x83\x01\x84aY\xD0V[\x90\x15\x15\x81R` \x01\x90V[\x92\x15\x15\x83R` \x83\x01\x91\x90\x91R`@\x82\x01R``\x01\x90V[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[`\0\x88\x82R`\x01`\x01`\xA0\x1B\x03\x80\x89\x16` \x84\x01R\x80\x88\x16`@\x84\x01RP`\xE0``\x83\x01Ra]\x98`\xE0\x83\x01\x87aY\xD0V[\x85`\x80\x84\x01R\x84`\xA0\x84\x01R\x82\x81\x03`\xC0\x84\x01Ra]\xB6\x81\x85aY\xFFV[\x9A\x99PPPPPPPPPPV[\x94\x85R` \x85\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16`@\x84\x01R``\x83\x01R`\x80\x82\x01R`\xA0\x01\x90V[\x94\x85R` \x85\x01\x93\x90\x93R`@\x84\x01\x91\x90\x91R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01\x90V[\x93\x84R`\xFF\x92\x90\x92\x16` \x84\x01R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[` \x81\x01a^G\x83a_PV[\x91\x90R\x90V[\x91\x82R` \x82\x01R`@\x01\x90V[`\0`\x80\x82Ra^n`\x80\x83\x01\x87aZ+V[\x82\x81\x03` \x84\x01Ra^\x80\x81\x87aY\xD0V[`@\x84\x01\x95\x90\x95RPP``\x01R\x92\x91PPV[`\0``\x82Ra^\xA7``\x83\x01\x86aZ+V[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[\x93\x84R` \x84\x01\x92\x90\x92R`@\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16``\x82\x01R`\x80\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a^\xFCW`\0\x80\xFD[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a_\x1AW\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\0[\x83\x81\x10\x15a_?W\x81\x81\x01Q\x83\x82\x01R` \x01a_'V[\x83\x81\x11\x15a\x0E\0WPP`\0\x91\x01RV[`\x03\x81\x10a\x05~W\xFE[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05~W`\0\x80\xFD[\x80\x15\x15\x81\x14a\x05~W`\0\x80\xFD[`\x03\x81\x10a\x05~W`\0\x80\xFD\xFE\xA2dipfsX\"\x12  \x1EO\x92n9\x0F\xED\x8D\xD51\x8CX\x84j\xF75\xC2\xBE\xBCa\xB8\x06\x93\xAE\x93j_\xE7m\xCF\x14dsolcC\0\x07\x01\x003`\xC0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x0B\xE68\x03\x80a\x0B\xE6\x839\x81\x01`@\x81\x90Ra\0/\x91a\0MV[0`\x80R`\x01`\0U``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0Ra\0{V[`\0` \x82\x84\x03\x12\x15a\0^W\x80\x81\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0tW\x81\x82\xFD[\x93\x92PPPV[`\x80Q`\xA0Q``\x1Ca\x0B@a\0\xA6`\09\x80a\x04\x13R\x80a\x05IRP\x80a\x02\xA7RPa\x0B@`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xA3W`\x005`\xE0\x1C\x80c\x85\x1C\x1B\xB3\x11a\0vW\x80c\xD8w\x84\\\x11a\0[W\x80c\xD8w\x84\\\x14a\x01)W\x80c\xE4*\xBF5\x14a\x011W\x80c\xFB\xFAw\xCF\x14a\x01QWa\0\xA3V[\x80c\x85\x1C\x1B\xB3\x14a\x01\x01W\x80c\xAA\xAB\xAD\xC5\x14a\x01\x14Wa\0\xA3V[\x80c8\xE9\x92.\x14a\0\xA8W\x80cU\xC6v(\x14a\0\xBDW\x80ckk\x9Fi\x14a\0\xDBW\x80cm\xAE\xFA\xB6\x14a\0\xEEW[`\0\x80\xFD[a\0\xBBa\0\xB66`\x04a\t\x9CV[a\x01YV[\0[a\0\xC5a\x01\xB8V[`@Qa\0\xD2\x91\x90a\n\xA6V[`@Q\x80\x91\x03\x90\xF3[a\0\xBBa\0\xE96`\x04a\t\x9CV[a\x01\xBEV[a\0\xBBa\0\xFC6`\x04a\x07\xD1V[a\x02\x11V[a\0\xC5a\x01\x0F6`\x04a\t$V[a\x02\xA3V[a\x01\x1Ca\x02\xF5V[`@Qa\0\xD2\x91\x90a\n5V[a\0\xC5a\x03\x04V[a\x01Da\x01?6`\x04a\x08RV[a\x03\nV[`@Qa\0\xD2\x91\x90a\nbV[a\x01\x1Ca\x04\x11V[a\x01aa\x045V[a\x01xg\x06\xF0[Y\xD3\xB2\0\0\x82\x11\x15a\x02Xa\x04~V[`\x01\x81\x90U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90a\x01\xAD\x90\x83\x90a\n\xA6V[`@Q\x80\x91\x03\x90\xA1PV[`\x01T\x90V[a\x01\xC6a\x045V[a\x01\xDCf#\x86\xF2o\xC1\0\0\x82\x11\x15a\x02Ya\x04~V[`\x02\x81\x90U`@Q\x7FZ\x0Bs\x86#~\x7F\x07\xFAt\x1E\xFCd\xE5\x9C\x93\x87\xD2\xCC\xCA\xFE\xC7`\xEF\xEDMS8\x7F \xE1\x9A\x90a\x01\xAD\x90\x83\x90a\n\xA6V[a\x02\x19a\x04\x90V[a\x02!a\x045V[a\x02+\x84\x83a\x04\xA9V[`\0[\x84\x81\x10\x15a\x02\x93W`\0\x86\x86\x83\x81\x81\x10a\x02DW\xFE[\x90P` \x02\x01` \x81\x01\x90a\x02Y\x91\x90a\t\x80V[\x90P`\0\x85\x85\x84\x81\x81\x10a\x02iW\xFE[` \x02\x91\x90\x91\x015\x91Pa\x02\x89\x90P`\x01`\x01`\xA0\x1B\x03\x83\x16\x85\x83a\x04\xB6V[PP`\x01\x01a\x02.V[Pa\x02\x9Ca\x05>V[PPPPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x02\xD8\x92\x91\x90a\t\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\0a\x02\xFFa\x05EV[\x90P\x90V[`\x02T\x90V[``\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x03$W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x03NW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x82Q\x81\x10\x15a\x04\x0BW\x82\x81\x81Q\x81\x10a\x03iW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\x9C\x91\x90a\n5V[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x03\xB4W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x03\xC8W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xEC\x91\x90a\t\xB4V[\x82\x82\x81Q\x81\x10a\x03\xF8W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x03TV[P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0a\x04d`\x005\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a\x02\xA3V[\x90Pa\x04{a\x04s\x823a\x05\xD8V[a\x01\x91a\x04~V[PV[\x81a\x04\x8CWa\x04\x8C\x81a\x06jV[PPV[a\x04\xA2`\x02`\0T\x14\x15a\x01\x90a\x04~V[`\x02`\0UV[a\x04\x8C\x81\x83\x14`ga\x04~V[a\x059\x83c\xA9\x05\x9C\xBB`\xE0\x1B\x84\x84`@Q`$\x01a\x04\xD5\x92\x91\x90a\nIV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x93\x16\x92\x90\x92\x17\x90\x91Ra\x06\xD7V[PPPV[`\x01`\0UV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xAA\xAB\xAD\xC5`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x05\xA0W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x05\xB4W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xFF\x91\x90a\tdV[`\0a\x05\xE2a\x05EV[`\x01`\x01`\xA0\x1B\x03\x16c\x9B\xE2\xA8\x84\x84\x840`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x06\x11\x93\x92\x91\x90a\n\xAFV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x06)W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x06=W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06a\x91\x90a\x08\xFDV[\x90P[\x92\x91PPV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[`\0``\x83`\x01`\x01`\xA0\x1B\x03\x16\x83`@Qa\x06\xF3\x91\x90a\t\xFCV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x070W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x075V[``\x91P[P\x91P\x91P`\0\x82\x14\x15a\x07MW=`\0\x80>=`\0\xFD[a\x07w\x81Q`\0\x14\x80a\x07oWP\x81\x80` \x01\x90Q\x81\x01\x90a\x07o\x91\x90a\x08\xFDV[a\x01\xA2a\x04~V[PPPPV[`\0\x80\x83`\x1F\x84\x01\x12a\x07\x8EW\x81\x82\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07\xA5W\x81\x82\xFD[` \x83\x01\x91P\x83` \x80\x83\x02\x85\x01\x01\x11\x15a\x07\xBFW`\0\x80\xFD[\x92P\x92\x90PV[\x805a\x06d\x81a\n\xF5V[`\0\x80`\0\x80`\0``\x86\x88\x03\x12\x15a\x07\xE8W\x80\x81\xFD[\x855g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x07\xFFW\x82\x83\xFD[a\x08\x0B\x89\x83\x8A\x01a\x07}V[\x90\x97P\x95P` \x88\x015\x91P\x80\x82\x11\x15a\x08#W\x82\x83\xFD[Pa\x080\x88\x82\x89\x01a\x07}V[\x90\x94P\x92PP`@\x86\x015a\x08D\x81a\n\xF5V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[`\0` \x80\x83\x85\x03\x12\x15a\x08dW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x08{W\x83\x84\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x08\x8EW\x83\x84\xFD[\x815\x81\x81\x11\x15a\x08\x9CW\x84\x85\xFD[\x83\x81\x02\x91Pa\x08\xAC\x84\x83\x01a\n\xCEV[\x81\x81R\x84\x81\x01\x90\x84\x86\x01\x84\x86\x01\x87\x01\x8A\x10\x15a\x08\xC6W\x87\x88\xFD[\x87\x95P[\x83\x86\x10\x15a\x08\xF0Wa\x08\xDC\x8A\x82a\x07\xC6V[\x83R`\x01\x95\x90\x95\x01\x94\x91\x86\x01\x91\x86\x01a\x08\xCAV[P\x98\x97PPPPPPPPV[`\0` \x82\x84\x03\x12\x15a\t\x0EW\x80\x81\xFD[\x81Q\x80\x15\x15\x81\x14a\t\x1DW\x81\x82\xFD[\x93\x92PPPV[`\0` \x82\x84\x03\x12\x15a\t5W\x80\x81\xFD[\x815\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\t\x1DW\x81\x82\xFD[`\0` \x82\x84\x03\x12\x15a\tuW\x80\x81\xFD[\x81Qa\t\x1D\x81a\n\xF5V[`\0` \x82\x84\x03\x12\x15a\t\x91W\x80\x81\xFD[\x815a\t\x1D\x81a\n\xF5V[`\0` \x82\x84\x03\x12\x15a\t\xADW\x80\x81\xFD[P5\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\t\xC5W\x80\x81\xFD[PQ\x91\x90PV[\x91\x82R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16` \x82\x01R`$\x01\x90V[`\0\x82Q\x81[\x81\x81\x10\x15a\n\x1CW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\n\x02V[\x81\x81\x11\x15a\n*W\x82\x82\x85\x01R[P\x91\x90\x91\x01\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15a\n\x9AW\x83Q\x83R\x92\x84\x01\x92\x91\x84\x01\x91`\x01\x01a\n~V[P\x90\x96\x95PPPPPPV[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\xEDW`\0\x80\xFD[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x04{W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xBEr\xBD\xF8\xE7\xA3\xC3\x86\x06\xC5\xF9T\xFB\xE2\xD7w\x984z\xAA\x1C\xFBv\xFEw\xEC/l$]$\xBCdsolcC\0\x07\x01\x003",
-    );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `AuthorizerChanged(address)` and selector `0x94b979b6831a51293e2641426f97747feed46f17779fed9cd18d1ecefcfe92ef`.
-    ```solidity
-    event AuthorizerChanged(address indexed newAuthorizer);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct AuthorizerChanged {
-        #[allow(missing_docs)]
-        pub newAuthorizer: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for AuthorizerChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "AuthorizerChanged(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    148u8, 185u8, 121u8, 182u8, 131u8, 26u8, 81u8, 41u8, 62u8, 38u8, 65u8, 66u8,
-                    111u8, 151u8, 116u8, 127u8, 238u8, 212u8, 111u8, 23u8, 119u8, 159u8, 237u8,
-                    156u8, 209u8, 141u8, 30u8, 206u8, 252u8, 254u8, 146u8, 239u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    newAuthorizer: topics.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.newAuthorizer.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.newAuthorizer,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for AuthorizerChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&AuthorizerChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &AuthorizerChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ExternalBalanceTransfer(address,address,address,uint256)` and selector `0x540a1a3f28340caec336c81d8d7b3df139ee5cdc1839a4f283d7ebb7eaae2d5c`.
-    ```solidity
-    event ExternalBalanceTransfer(address indexed token, address indexed sender, address recipient, uint256 amount);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ExternalBalanceTransfer {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ExternalBalanceTransfer {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "ExternalBalanceTransfer(address,address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    84u8, 10u8, 26u8, 63u8, 40u8, 52u8, 12u8, 174u8, 195u8, 54u8, 200u8, 29u8,
-                    141u8, 123u8, 61u8, 241u8, 57u8, 238u8, 92u8, 220u8, 24u8, 57u8, 164u8, 242u8,
-                    131u8, 215u8, 235u8, 183u8, 234u8, 174u8, 45u8, 92u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    token: topics.1,
-                    sender: topics.2,
-                    recipient: data.0,
-                    amount: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.token.clone(),
-                    self.sender.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.sender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ExternalBalanceTransfer {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ExternalBalanceTransfer> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ExternalBalanceTransfer) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `FlashLoan(address,address,uint256,uint256)` and selector `0x0d7d75e01ab95780d3cd1c8ec0dd6c2ce19e3a20427eec8bf53283b6fb8e95f0`.
-    ```solidity
-    event FlashLoan(address indexed recipient, address indexed token, uint256 amount, uint256 feeAmount);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct FlashLoan {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for FlashLoan {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "FlashLoan(address,address,uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    13u8, 125u8, 117u8, 224u8, 26u8, 185u8, 87u8, 128u8, 211u8, 205u8, 28u8, 142u8,
-                    192u8, 221u8, 108u8, 44u8, 225u8, 158u8, 58u8, 32u8, 66u8, 126u8, 236u8, 139u8,
-                    245u8, 50u8, 131u8, 182u8, 251u8, 142u8, 149u8, 240u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    recipient: topics.1,
-                    token: topics.2,
-                    amount: data.0,
-                    feeAmount: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.recipient.clone(),
-                    self.token.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.recipient,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for FlashLoan {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&FlashLoan> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &FlashLoan) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `InternalBalanceChanged(address,address,int256)` and selector `0x18e1ea4139e68413d7d08aa752e71568e36b2c5bf940893314c2c5b01eaa0c42`.
-    ```solidity
-    event InternalBalanceChanged(address indexed user, address indexed token, int256 delta);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct InternalBalanceChanged {
-        #[allow(missing_docs)]
-        pub user: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub delta: alloy_sol_types::private::primitives::aliases::I256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for InternalBalanceChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Int<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "InternalBalanceChanged(address,address,int256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    24u8, 225u8, 234u8, 65u8, 57u8, 230u8, 132u8, 19u8, 215u8, 208u8, 138u8, 167u8,
-                    82u8, 231u8, 21u8, 104u8, 227u8, 107u8, 44u8, 91u8, 249u8, 64u8, 137u8, 51u8,
-                    20u8, 194u8, 197u8, 176u8, 30u8, 170u8, 12u8, 66u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    user: topics.1,
-                    token: topics.2,
-                    delta: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.delta,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.user.clone(),
-                    self.token.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.user,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for InternalBalanceChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&InternalBalanceChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &InternalBalanceChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
-    ```solidity
-    event PausedStateChanged(bool paused);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PausedStateChanged {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PausedStateChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
-                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
-                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { paused: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PoolBalanceChanged(bytes32,address,address[],int256[],uint256[])` and selector `0xe5ce249087ce04f05a957192435400fd97868dba0e6a4b4c049abf8af80dae78`.
-    ```solidity
-    event PoolBalanceChanged(bytes32 indexed poolId, address indexed liquidityProvider, address[] tokens, int256[] deltas, uint256[] protocolFeeAmounts);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PoolBalanceChanged {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub liquidityProvider: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub deltas:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-        #[allow(missing_docs)]
-        pub protocolFeeAmounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PoolBalanceChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "PoolBalanceChanged(bytes32,address,address[],int256[],uint256[])";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    229u8, 206u8, 36u8, 144u8, 135u8, 206u8, 4u8, 240u8, 90u8, 149u8, 113u8, 146u8,
-                    67u8, 84u8, 0u8, 253u8, 151u8, 134u8, 141u8, 186u8, 14u8, 106u8, 75u8, 76u8,
-                    4u8, 154u8, 191u8, 138u8, 248u8, 13u8, 174u8, 120u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    poolId: topics.1,
-                    liquidityProvider: topics.2,
-                    tokens: data.0,
-                    deltas: data.1,
-                    protocolFeeAmounts: data.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Int<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deltas),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.protocolFeeAmounts),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.poolId.clone(),
-                    self.liquidityProvider.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.liquidityProvider,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PoolBalanceChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PoolBalanceChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PoolBalanceChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PoolBalanceManaged(bytes32,address,address,int256,int256)` and selector `0x6edcaf6241105b4c94c2efdbf3a6b12458eb3d07be3a0e81d24b13c44045fe7a`.
-    ```solidity
-    event PoolBalanceManaged(bytes32 indexed poolId, address indexed assetManager, address indexed token, int256 cashDelta, int256 managedDelta);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PoolBalanceManaged {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub assetManager: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub cashDelta: alloy_sol_types::private::primitives::aliases::I256,
-        #[allow(missing_docs)]
-        pub managedDelta: alloy_sol_types::private::primitives::aliases::I256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PoolBalanceManaged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "PoolBalanceManaged(bytes32,address,address,int256,int256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    110u8, 220u8, 175u8, 98u8, 65u8, 16u8, 91u8, 76u8, 148u8, 194u8, 239u8, 219u8,
-                    243u8, 166u8, 177u8, 36u8, 88u8, 235u8, 61u8, 7u8, 190u8, 58u8, 14u8, 129u8,
-                    210u8, 75u8, 19u8, 196u8, 64u8, 69u8, 254u8, 122u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    poolId: topics.1,
-                    assetManager: topics.2,
-                    token: topics.3,
-                    cashDelta: data.0,
-                    managedDelta: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.cashDelta,
-                    ),
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.managedDelta,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.poolId.clone(),
-                    self.assetManager.clone(),
-                    self.token.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.assetManager,
-                );
-                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PoolBalanceManaged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PoolBalanceManaged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PoolBalanceManaged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PoolRegistered(bytes32,address,uint8)` and selector `0x3c13bc30b8e878c53fd2a36b679409c073afd75950be43d8858768e956fbc20e`.
-    ```solidity
-    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, IVault.PoolSpecialization specialization);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PoolRegistered {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub poolAddress: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PoolRegistered {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (IVault::PoolSpecialization,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "PoolRegistered(bytes32,address,uint8)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    60u8, 19u8, 188u8, 48u8, 184u8, 232u8, 120u8, 197u8, 63u8, 210u8, 163u8, 107u8,
-                    103u8, 148u8, 9u8, 192u8, 115u8, 175u8, 215u8, 89u8, 80u8, 190u8, 67u8, 216u8,
-                    133u8, 135u8, 104u8, 233u8, 86u8, 251u8, 194u8, 14u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    poolId: topics.1,
-                    poolAddress: topics.2,
-                    specialization: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(
-                        &self.specialization,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.poolId.clone(),
-                    self.poolAddress.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.poolAddress,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PoolRegistered {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PoolRegistered> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PoolRegistered) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `RelayerApprovalChanged(address,address,bool)` and selector `0x46961fdb4502b646d5095fba7600486a8ac05041d55cdf0f16ed677180b5cad8`.
-    ```solidity
-    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct RelayerApprovalChanged {
-        #[allow(missing_docs)]
-        pub relayer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub approved: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for RelayerApprovalChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "RelayerApprovalChanged(address,address,bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    70u8, 150u8, 31u8, 219u8, 69u8, 2u8, 182u8, 70u8, 213u8, 9u8, 95u8, 186u8,
-                    118u8, 0u8, 72u8, 106u8, 138u8, 192u8, 80u8, 65u8, 213u8, 92u8, 223u8, 15u8,
-                    22u8, 237u8, 103u8, 113u8, 128u8, 181u8, 202u8, 216u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    relayer: topics.1,
-                    sender: topics.2,
-                    approved: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approved,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.relayer.clone(),
-                    self.sender.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.relayer,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.sender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for RelayerApprovalChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&RelayerApprovalChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &RelayerApprovalChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Swap(bytes32,address,address,uint256,uint256)` and selector `0x2170c741c41531aec20e7c107c24eecfdd15e69c9bb0a8dd37b1840b9e0b207b`.
-    ```solidity
-    event Swap(bytes32 indexed poolId, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Swap {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Swap {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Swap(bytes32,address,address,uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    33u8, 112u8, 199u8, 65u8, 196u8, 21u8, 49u8, 174u8, 194u8, 14u8, 124u8, 16u8,
-                    124u8, 36u8, 238u8, 207u8, 221u8, 21u8, 230u8, 156u8, 155u8, 176u8, 168u8,
-                    221u8, 55u8, 177u8, 132u8, 11u8, 158u8, 11u8, 32u8, 123u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    poolId: topics.1,
-                    tokenIn: topics.2,
-                    tokenOut: topics.3,
-                    amountIn: data.0,
-                    amountOut: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.poolId.clone(),
-                    self.tokenIn.clone(),
-                    self.tokenOut.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.tokenIn,
-                );
-                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.tokenOut,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Swap {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Swap> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Swap) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TokensDeregistered(bytes32,address[])` and selector `0x7dcdc6d02ef40c7c1a7046a011b058bd7f988fa14e20a66344f9d4e60657d610`.
-    ```solidity
-    event TokensDeregistered(bytes32 indexed poolId, address[] tokens);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TokensDeregistered {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TokensDeregistered {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "TokensDeregistered(bytes32,address[])";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    125u8, 205u8, 198u8, 208u8, 46u8, 244u8, 12u8, 124u8, 26u8, 112u8, 70u8, 160u8,
-                    17u8, 176u8, 88u8, 189u8, 127u8, 152u8, 143u8, 161u8, 78u8, 32u8, 166u8, 99u8,
-                    68u8, 249u8, 212u8, 230u8, 6u8, 87u8, 214u8, 16u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    poolId: topics.1,
-                    tokens: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.tokens
-                ),)
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.poolId.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TokensDeregistered {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TokensDeregistered> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TokensDeregistered) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TokensRegistered(bytes32,address[],address[])` and selector `0xf5847d3f2197b16cdcd2098ec95d0905cd1abdaf415f07bb7cef2bba8ac5dec4`.
-    ```solidity
-    event TokensRegistered(bytes32 indexed poolId, address[] tokens, address[] assetManagers);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TokensRegistered {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TokensRegistered {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "TokensRegistered(bytes32,address[],address[])";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    245u8, 132u8, 125u8, 63u8, 33u8, 151u8, 177u8, 108u8, 220u8, 210u8, 9u8, 142u8,
-                    201u8, 93u8, 9u8, 5u8, 205u8, 26u8, 189u8, 175u8, 65u8, 95u8, 7u8, 187u8,
-                    124u8, 239u8, 43u8, 186u8, 138u8, 197u8, 222u8, 196u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    poolId: topics.1,
-                    tokens: data.0,
-                    assetManagers: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assetManagers),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.poolId.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TokensRegistered {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TokensRegistered> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TokensRegistered) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(address authorizer, address weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub authorizer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub weth: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (
-                        value.authorizer,
-                        value.weth,
-                        value.pauseWindowDuration,
-                        value.bufferPeriodDuration,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        authorizer: tuple.0,
-                        weth: tuple.1,
-                        pauseWindowDuration: tuple.2,
-                        bufferPeriodDuration: tuple.3,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.authorizer,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.weth,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256)` and selector `0x945bcec9`.
-    ```solidity
-    function batchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds, int256[] memory limits, uint256 deadline) external payable returns (int256[] memory assetDeltas);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchSwapCall {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub swaps: alloy_sol_types::private::Vec<
-            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub limits:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],
-    /// (address,bool,address,bool),int256[],uint256)`](batchSwapCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchSwapReturn {
-        #[allow(missing_docs)]
-        pub assetDeltas:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IVault::SwapKind,
-                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                IVault::FundManagement,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchSwapCall) -> Self {
-                    (
-                        value.kind,
-                        value.swaps,
-                        value.assets,
-                        value.funds,
-                        value.limits,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchSwapCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        kind: tuple.0,
-                        swaps: tuple.1,
-                        assets: tuple.2,
-                        funds: tuple.3,
-                        limits: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchSwapReturn) -> Self {
-                    (value.assetDeltas,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchSwapReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        assetDeltas: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchSwapCall {
-            type Parameters<'a> = (
-                IVault::SwapKind,
-                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                IVault::FundManagement,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [148u8, 91u8, 206u8, 201u8];
-            const SIGNATURE: &'static str = "batchSwap(uint8,(bytes32,uint256,uint256,uint256,\
-                                             bytes)[],address[],(address,bool,address,bool),\
-                                             int256[],uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Array<
-                        IVault::BatchSwapStep,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
-                        &self.funds,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Int<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.limits),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Int<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: batchSwapReturn = r.into();
-                        r.assetDeltas
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: batchSwapReturn = r.into();
-                    r.assetDeltas
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `deregisterTokens(bytes32,address[])` and selector `0x7d3aeb96`.
-    ```solidity
-    function deregisterTokens(bytes32 poolId, address[] memory tokens) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct deregisterTokensCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    ///Container type for the return parameters of the
-    /// [`deregisterTokens(bytes32,address[])`](deregisterTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct deregisterTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<deregisterTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: deregisterTokensCall) -> Self {
-                    (value.poolId, value.tokens)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        tokens: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<deregisterTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: deregisterTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl deregisterTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <deregisterTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for deregisterTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return = deregisterTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [125u8, 58u8, 235u8, 150u8];
-            const SIGNATURE: &'static str = "deregisterTokens(bytes32,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                deregisterTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `exitPool(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0x8bdb3913`.
-    ```solidity
-    function exitPool(bytes32 poolId, address sender, address recipient, IVault.ExitPoolRequest memory request) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct exitPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`exitPool(bytes32,address,address,(address[],uint256[],bytes,
-    /// bool))`](exitPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct exitPoolReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::ExitPoolRequest,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<exitPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: exitPoolCall) -> Self {
-                    (value.poolId, value.sender, value.recipient, value.request)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exitPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        request: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<exitPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: exitPoolReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for exitPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl exitPoolReturn {
-            fn _tokenize(&self) -> <exitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for exitPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::ExitPoolRequest,
-            );
-            type Return = exitPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [139u8, 219u8, 57u8, 19u8];
-            const SIGNATURE: &'static str =
-                "exitPool(bytes32,address,address,(address[],uint256[],bytes,bool))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <IVault::ExitPoolRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                exitPoolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "authorizer",
+        "type": "address",
+        "internalType": "contract IAuthorizer"
+      },
+      {
+        "name": "weth",
+        "type": "address",
+        "internalType": "contract IWETH"
+      },
+      {
+        "name": "pauseWindowDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodDuration",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "WETH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IWETH"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "batchSwap",
+    "inputs": [
+      {
+        "name": "kind",
+        "type": "uint8",
+        "internalType": "enum IVault.SwapKind"
+      },
+      {
+        "name": "swaps",
+        "type": "tuple[]",
+        "internalType": "struct IVault.BatchSwapStep[]",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "assetInIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "assetOutIndex",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "assets",
+        "type": "address[]",
+        "internalType": "contract IAsset[]"
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      },
+      {
+        "name": "limits",
+        "type": "int256[]",
+        "internalType": "int256[]"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "assetDeltas",
+        "type": "int256[]",
+        "internalType": "int256[]"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "flashLoan",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "contract IFlashLoanRecipient"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "userData",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getInternalBalance",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPausedState",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "pauseWindowEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "bufferPeriodEndTime",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPool",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "enum IVault.PoolSpecialization"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPoolTokens",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "balances",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "lastChangeBlock",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "hasApprovedRelayer",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "manageUserBalance",
+    "inputs": [
+      {
+        "name": "ops",
+        "type": "tuple[]",
+        "internalType": "struct IVault.UserBalanceOp[]",
+        "components": [
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.UserBalanceOpKind"
+          },
+          {
+            "name": "asset",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          }
+        ]
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "setRelayerApproval",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "relayer",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "swap",
+    "inputs": [
+      {
+        "name": "singleSwap",
+        "type": "tuple",
+        "internalType": "struct IVault.SingleSwap",
+        "components": [
+          {
+            "name": "poolId",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "kind",
+            "type": "uint8",
+            "internalType": "enum IVault.SwapKind"
+          },
+          {
+            "name": "assetIn",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "assetOut",
+            "type": "address",
+            "internalType": "contract IAsset"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "userData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "funds",
+        "type": "tuple",
+        "internalType": "struct IVault.FundManagement",
+        "components": [
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "fromInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          },
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address payable"
+          },
+          {
+            "name": "toInternalBalance",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountCalculated",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "event",
+    "name": "AuthorizerChanged",
+    "inputs": [
+      {
+        "name": "newAuthorizer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IAuthorizer"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExternalBalanceTransfer",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "FlashLoan",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IFlashLoanRecipient"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "feeAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "InternalBalanceChanged",
+    "inputs": [
+      {
+        "name": "user",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "delta",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolBalanceChanged",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "liquidityProvider",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "deltas",
+        "type": "int256[]",
+        "indexed": false,
+        "internalType": "int256[]"
+      },
+      {
+        "name": "protocolFeeAmounts",
+        "type": "uint256[]",
+        "indexed": false,
+        "internalType": "uint256[]"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolBalanceManaged",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "assetManager",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "cashDelta",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      },
+      {
+        "name": "managedDelta",
+        "type": "int256",
+        "indexed": false,
+        "internalType": "int256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PoolRegistered",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "poolAddress",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "specialization",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum IVault.PoolSpecialization"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RelayerApprovalChanged",
+    "inputs": [
+      {
+        "name": "relayer",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "approved",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Swap",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokenIn",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "tokenOut",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amountIn",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokensDeregistered",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "contract IERC20[]"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TokensRegistered",
+    "inputs": [
+      {
+        "name": "poolId",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "tokens",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "contract IERC20[]"
+      },
+      {
+        "name": "assetManagers",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2Vault {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\x80`@R4\x80\x15b\0\0\x12W`\0\x80\xFD[P`@Qb\0n\xD68\x03\x80b\0n\xD6\x839\x81\x01`@\x81\x90Rb\0\x005\x91b\0\x02SV[\x83\x82\x82`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01p\x10\x98[\x18[\x98\xD9\\\x88\x15\x8C\x88\x15\x98][\x1D`z\x1B\x81RP\x80`@Q\x80`@\x01`@R\x80`\x01\x81R` \x01`1`\xF8\x1B\x81RP0`\x01`\x01`\xA0\x1B\x03\x16`\0\x1B\x89\x80`\x01`\x01`\xA0\x1B\x03\x16`\x80\x81`\x01`\x01`\xA0\x1B\x03\x16``\x1B\x81RPPP0`@Qb\0\0\xB8\x90b\0\x02EV[b\0\0\xC4\x91\x90b\0\x02\x9FV[`@Q\x80\x91\x03\x90`\0\xF0\x80\x15\x80\x15b\0\0\xE1W=`\0\x80>=`\0\xFD[P``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0R`\x01`\0U`\xC0R\x81Q` \x92\x83\x01 `\xE0R\x80Q\x91\x01 a\x01\0RP\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0Fa\x01 Rb\0\x01Hbv\xA7\0\x83\x11\x15a\x01\x94b\0\x01\x81V[b\0\x01\\b'\x8D\0\x82\x11\x15a\x01\x95b\0\x01\x81V[B\x90\x91\x01a\x01@\x81\x90R\x01a\x01`Rb\0\x01v\x81b\0\x01\x96V[PPPPPb\0\x02\xCCV[\x81b\0\x01\x92Wb\0\x01\x92\x81b\0\x01\xF2V[PPV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\x94\xB9y\xB6\x83\x1AQ)>&ABo\x97t\x7F\xEE\xD4o\x17w\x9F\xED\x9C\xD1\x8D\x1E\xCE\xFC\xFE\x92\xEF\x90`\0\x90\xA2`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16a\x01\0\x02a\x01\0`\x01`\xA8\x1B\x03\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[bF\x1B\xCD`\xE5\x1B`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[a\x0B\xE6\x80b\0b\xF0\x839\x01\x90V[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15b\0\x02iW\x83\x84\xFD[\x84Qb\0\x02v\x81b\0\x02\xB3V[` \x86\x01Q\x90\x94Pb\0\x02\x89\x81b\0\x02\xB3V[`@\x86\x01Q``\x90\x96\x01Q\x94\x97\x90\x96P\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x02\xC9W`\0\x80\xFD[PV[`\x80Q``\x1C`\xA0Q``\x1C`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa_\xC0b\0\x030`\09\x80a\x1A\xEDRP\x80a\x1A\xC9RP\x80a(\x9FRP\x80a(\xE1RP\x80a(\xC0RP\x80a\x10\xFDRP\x80a\x13\xB1RP\x80a\x05(RPa_\xC0`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\xA5W`\x005`\xE0\x1C\x80c\x94[\xCE\xC9\x11a\0\xE1W\x80c\xE6\xC4`\x92\x11a\0\x8AW\x80c\xF8M\x06n\x11a\0dW\x80c\xF8M\x06n\x14a\x04\x8AW\x80c\xF9MFh\x14a\x04\xAAW\x80c\xFAng\x1D\x14a\x04\xD9W\x80c\xFE\xC9\rr\x14a\x04\xF9Wa\x01\xD3V[\x80c\xE6\xC4`\x92\x14a\x04'W\x80c\xED$\x91\x1D\x14a\x04GW\x80c\xF6\xC0\t'\x14a\x04\\Wa\x01\xD3V[\x80c\xB0_\x8EH\x11a\0\xBBW\x80c\xB0_\x8EH\x14a\x03\xCFW\x80c\xB9\\\xAC(\x14a\x03\xFFW\x80c\xD2\x94l+\x14a\x04\x12Wa\x01\xD3V[\x80c\x94[\xCE\xC9\x14a\x03\x85W\x80c\xAA\xAB\xAD\xC5\x14a\x03\x98W\x80c\xAD\\FH\x14a\x03\xBAWa\x01\xD3V[\x80cR\xBB\xBE)\x11a\x01NW\x80c}:\xEB\x96\x11a\x01(W\x80c}:\xEB\x96\x14a\x03\x05W\x80c\x85\x1C\x1B\xB3\x14a\x03%W\x80c\x8B\xDB9\x13\x14a\x03EW\x80c\x90\x19;|\x14a\x03eWa\x01\xD3V[\x80cR\xBB\xBE)\x14a\x02\xB2W\x80c\\8D\x9E\x14a\x02\xC5W\x80cf\xA9\xC7\xD2\x14a\x02\xE5Wa\x01\xD3V[\x80c\x0FZn\xFA\x11a\x01\x7FW\x80c\x0FZn\xFA\x14a\x02AW\x80c\x16\xC3\x8B<\x14a\x02nW\x80c\x1C\r\xE0Q\x14a\x02\x8EWa\x01\xD3V[\x80c\x05\x8Ab\x8F\x14a\x01\xD8W\x80c\t\xB2v\x0F\x14a\x01\xF8W\x80c\x0E\x8E>\x84\x14a\x02.Wa\x01\xD3V[6a\x01\xD3Wa\x01\xD1a\x01\xB5a\x05&V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x06a\x05KV[\0[`\0\x80\xFD[4\x80\x15a\x01\xE4W`\0\x80\xFD[Pa\x01\xD1a\x01\xF36`\x04aQWV[a\x05]V[4\x80\x15a\x02\x04W`\0\x80\xFD[Pa\x02\x18a\x02\x136`\x04aV\xE6V[a\x05\x81V[`@Qa\x02%\x91\x90a]>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xD1a\x02<6`\x04aS\x1EV[a\x064V[4\x80\x15a\x02MW`\0\x80\xFD[Pa\x02aa\x02\\6`\x04aQ\xF5V[a\x07pV[`@Qa\x02%\x91\x90a]\x08V[4\x80\x15a\x02zW`\0\x80\xFD[Pa\x01\xD1a\x02\x896`\x04aT\\V[a\x08\x06V[4\x80\x15a\x02\x9AW`\0\x80\xFD[Pa\x02\xA3a\x08\x1FV[`@Qa\x02%\x93\x92\x91\x90a]&V[a\x02\x18a\x02\xC06`\x04aX\x8FV[a\x08HV[4\x80\x15a\x02\xD1W`\0\x80\xFD[Pa\x01\xD1a\x02\xE06`\x04aV[V[a\t\xE9V[4\x80\x15a\x02\xF1W`\0\x80\xFD[Pa\x01\xD1a\x03\x006`\x04aUEV[a\x0E\x06V[4\x80\x15a\x03\x11W`\0\x80\xFD[Pa\x01\xD1a\x03 6`\x04aU\x16V[a\x0F\xA5V[4\x80\x15a\x031W`\0\x80\xFD[Pa\x02\x18a\x03@6`\x04aV3V[a\x10\xF9V[4\x80\x15a\x03QW`\0\x80\xFD[Pa\x01\xD1a\x03`6`\x04aT\xACV[a\x11KV[4\x80\x15a\x03qW`\0\x80\xFD[Pa\x02\x18a\x03\x806`\x04aQWV[a\x11aV[a\x02aa\x03\x936`\x04aW\x86V[a\x11|V[4\x80\x15a\x03\xA4W`\0\x80\xFD[Pa\x03\xADa\x12\xB0V[`@Qa\x02%\x91\x90a[cV[4\x80\x15a\x03\xC6W`\0\x80\xFD[Pa\x03\xADa\x12\xC4V[4\x80\x15a\x03\xDBW`\0\x80\xFD[Pa\x03\xEFa\x03\xEA6`\x04aV\x0FV[a\x12\xD3V[`@Qa\x02%\x94\x93\x92\x91\x90a^\xB9V[a\x01\xD1a\x04\r6`\x04aT\xACV[a\x13\x96V[4\x80\x15a\x04\x1EW`\0\x80\xFD[Pa\x03\xADa\x13\xAFV[4\x80\x15a\x043W`\0\x80\xFD[Pa\x01\xD1a\x04B6`\x04aRCV[a\x13\xD3V[4\x80\x15a\x04SW`\0\x80\xFD[Pa\x02\x18a\x14\xEFV[4\x80\x15a\x04hW`\0\x80\xFD[Pa\x04|a\x04w6`\x04aT\x94V[a\x14\xF9V[`@Qa\x02%\x92\x91\x90a[\x9BV[4\x80\x15a\x04\x96W`\0\x80\xFD[Pa\x02aa\x04\xA56`\x04aW\x02V[a\x15#V[4\x80\x15a\x04\xB6W`\0\x80\xFD[Pa\x04\xCAa\x04\xC56`\x04aT\x94V[a\x16 V[`@Qa\x02%\x93\x92\x91\x90a\\\xD2V[4\x80\x15a\x04\xE5W`\0\x80\xFD[Pa\x01\xD1a\x04\xF46`\x04aQ\xABV[a\x16TV[4\x80\x15a\x05\x05W`\0\x80\xFD[Pa\x05\x19a\x05\x146`\x04aQsV[a\x16\xE6V[`@Qa\x02%\x91\x90a]\x1BV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0[\x90V[\x81a\x05YWa\x05Y\x81a\x16\xFBV[PPV[a\x05ea\x17hV[a\x05ma\x17\x81V[a\x05v\x81a\x17\xAFV[a\x05~a\x18\"V[PV[`\0a\x05\x8Ba\x17hV[a\x05\x93a\x18)V[`\0a\x05\xA23\x84`\x06Ta\x18>V[`\0\x81\x81R`\x05` R`@\x90 T\x90\x91Pa\x05\xC4\x90`\xFF\x16\x15a\x01\xF4a\x05KV[`\0\x81\x81R`\x05` R`@\x90\x81\x90 \x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91U`\x06\x80T\x90\x91\x01\x90UQ3\x90\x82\x90\x7F<\x13\xBC0\xB8\xE8x\xC5?\xD2\xA3kg\x94\t\xC0s\xAF\xD7YP\xBEC\xD8\x85\x87h\xE9V\xFB\xC2\x0E\x90a\x06\x1D\x90\x87\x90a^:V[`@Q\x80\x91\x03\x90\xA3\x90Pa\x06/a\x18\"V[\x91\x90PV[a\x06<a\x17hV[`\0\x80`\0\x80[\x84Q\x81\x10\x15a\x07[W`\0\x80`\0\x80`\0a\x06q\x8A\x87\x81Q\x81\x10a\x06cW\xFE[` \x02` \x01\x01Q\x89a\x18}V[\x9CP\x93\x98P\x91\x96P\x94P\x92P\x90P`\x01\x85`\x03\x81\x11\x15a\x06\x8DW\xFE[\x14\x15a\x06\xA4Wa\x06\x9F\x84\x83\x83\x86a\x18\xF5V[a\x07JV[\x86a\x06\xB6Wa\x06\xB1a\x18)V[`\x01\x96P[`\0\x85`\x03\x81\x11\x15a\x06\xC4W\xFE[\x14\x15a\x06\xF5Wa\x06\xD6\x84\x83\x83\x86a\x19\x18V[a\x06\xDF\x84a\x198V[\x15a\x06\x9FWa\x06\xEE\x89\x84a\x19EV[\x98Pa\x07JV[a\x07\na\x07\x01\x85a\x198V[\x15a\x02\x07a\x05KV[`\0a\x07\x15\x85a\x05HV[\x90P`\x02\x86`\x03\x81\x11\x15a\x07%W\xFE[\x14\x15a\x07<Wa\x077\x81\x84\x84\x87a\x19WV[a\x07HV[a\x07H\x81\x84\x84\x87a\x19pV[P[PP`\x01\x90\x93\x01\x92Pa\x06C\x91PPV[Pa\x07e\x83a\x19\xDEV[PPPa\x05~a\x18\"V[``\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x07\x8AW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\xB4W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x82Q\x81\x10\x15a\x07\xFFWa\x07\xE0\x84\x84\x83\x81Q\x81\x10a\x07\xD3W\xFE[` \x02` \x01\x01Qa\x1A\x01V[\x82\x82\x81Q\x81\x10a\x07\xECW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07\xBAV[P\x92\x91PPV[a\x08\x0Ea\x17hV[a\x08\x16a\x17\x81V[a\x05v\x81a\x1A,V[`\0\x80`\0a\x08,a\x1A\xAAV[\x15\x92Pa\x087a\x1A\xC7V[\x91Pa\x08Aa\x1A\xEBV[\x90P\x90\x91\x92V[`\0a\x08Ra\x17hV[a\x08Za\x18)V[\x83Qa\x08e\x81a\x1B\x0FV[a\x08t\x83B\x11\x15a\x01\xFCa\x05KV[a\x08\x87`\0\x87`\x80\x01Q\x11a\x01\xFEa\x05KV[`\0a\x08\x96\x87`@\x01Qa\x1BAV[\x90P`\0a\x08\xA7\x88``\x01Qa\x1BAV[\x90Pa\x08\xCA\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x01\xFDa\x05KV[a\x08\xD2aL\xE1V[\x88Q`\x80\x82\x01R` \x89\x01Q\x81\x90`\x01\x81\x11\x15a\x08\xEBW\xFE[\x90\x81`\x01\x81\x11\x15a\x08\xF8W\xFE[\x90RP`\x01`\x01`\xA0\x1B\x03\x80\x84\x16` \x83\x01R\x82\x81\x16`@\x80\x84\x01\x91\x90\x91R`\x80\x8B\x01Q``\x84\x01R`\xA0\x8B\x01Qa\x01\0\x84\x01R\x89Q\x82\x16`\xC0\x84\x01R\x89\x01Q\x16`\xE0\x82\x01R`\0\x80a\tJ\x83a\x1BfV[\x91\x98P\x92P\x90Pa\t\x81`\0\x8C` \x01Q`\x01\x81\x11\x15a\tfW\xFE[\x14a\ttW\x89\x83\x11\x15a\tyV[\x89\x82\x10\x15[a\x01\xFBa\x05KV[a\t\x99\x8B`@\x01Q\x83\x8C`\0\x01Q\x8D` \x01Qa\x1CZV[a\t\xB1\x8B``\x01Q\x82\x8C`@\x01Q\x8D``\x01Qa\x1D8V[a\t\xD3a\t\xC1\x8C`@\x01Qa\x198V[a\t\xCCW`\0a\t\xCEV[\x82[a\x19\xDEV[PPPPPPa\t\xE1a\x18\"V[\x94\x93PPPPV[a\t\xF1a\x17hV[a\t\xF9a\x18)V[a\n\x05\x83Q\x83Qa\x1E\x12V[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\n\x1FW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\nIW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P``\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\nfW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0\x80[\x86Q\x81\x10\x15a\x0C\tW`\0\x87\x82\x81Q\x81\x10a\n\xAEW\xFE[` \x02` \x01\x01Q\x90P`\0\x87\x83\x81Q\x81\x10a\n\xC6W\xFE[` \x02` \x01\x01Q\x90Pa\x0B\x11\x84`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x11`\0`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0B\tW`fa\x0B\x0CV[`h[a\x05KV[\x81\x93P\x81`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0B@\x91\x90a[cV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x0BXW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x0BlW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x90\x91\x90aYhV[\x85\x84\x81Q\x81\x10a\x0B\x9CW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0B\xB1\x81a\x1E\x1FV[\x86\x84\x81Q\x81\x10a\x0B\xBDW\xFE[` \x02` \x01\x01\x81\x81RPPa\x0B\xEB\x81\x86\x85\x81Q\x81\x10a\x0B\xD9W\xFE[` \x02` \x01\x01Q\x10\x15a\x02\x10a\x05KV[a\x0B\xFF`\x01`\x01`\xA0\x1B\x03\x83\x16\x8B\x83a\x1E\xA6V[PP`\x01\x01a\n\x97V[P`@Q\x7F\xF0O'\x07\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x88\x16\x90c\xF0O'\x07\x90a\x0CU\x90\x89\x90\x89\x90\x88\x90\x8A\x90`\x04\x01a\\\x85V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x0CoW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0C\x83W=`\0\x80>=`\0\xFD[PPPP`\0[\x86Q\x81\x10\x15a\r\xF4W`\0\x87\x82\x81Q\x81\x10a\x0C\xA1W\xFE[` \x02` \x01\x01Q\x90P`\0\x84\x83\x81Q\x81\x10a\x0C\xB9W\xFE[` \x02` \x01\x01Q\x90P`\0\x82`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0C\xF1\x91\x90a[cV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\r\tW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\r\x1DW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\rA\x91\x90aYhV[\x90Pa\rR\x82\x82\x10\x15a\x02\x03a\x05KV[`\0\x82\x82\x03\x90Pa\r{\x88\x86\x81Q\x81\x10a\rhW\xFE[` \x02` \x01\x01Q\x82\x10\x15a\x02Za\x05KV[a\r\x85\x84\x82a\x1F\x11V[\x83`\x01`\x01`\xA0\x1B\x03\x16\x8C`\x01`\x01`\xA0\x1B\x03\x16\x7F\r}u\xE0\x1A\xB9W\x80\xD3\xCD\x1C\x8E\xC0\xDDl,\xE1\x9E: B~\xEC\x8B\xF52\x83\xB6\xFB\x8E\x95\xF0\x8C\x88\x81Q\x81\x10a\r\xC6W\xFE[` \x02` \x01\x01Q\x84`@Qa\r\xDD\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA3PPPP\x80`\x01\x01\x90Pa\x0C\x8AV[PPPPa\x0E\0a\x18\"V[PPPPV[a\x0E\x0Ea\x17hV[a\x0E\x16a\x18)V[\x82a\x0E \x81a\x1F3V[a\x0E,\x83Q\x83Qa\x1E\x12V[`\0[\x83Q\x81\x10\x15a\x0E\xCAW`\0\x84\x82\x81Q\x81\x10a\x0EFW\xFE[` \x02` \x01\x01Q\x90Pa\x0Er`\0`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x015a\x05KV[\x83\x82\x81Q\x81\x10a\x0E~W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\0\x88\x81R`\n\x83R`@\x80\x82 `\x01`\x01`\xA0\x1B\x03\x95\x86\x16\x83R\x90\x93R\x91\x90\x91 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x92\x90\x91\x16\x91\x90\x91\x17\x90U`\x01\x01a\x0E/V[P`\0a\x0E\xD6\x85a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x0E\xE6W\xFE[\x14\x15a\x0F4Wa\x0E\xFC\x84Q`\x02\x14a\x02\x0Ca\x05KV[a\x0F/\x85\x85`\0\x81Q\x81\x10a\x0F\rW\xFE[` \x02` \x01\x01Q\x86`\x01\x81Q\x81\x10a\x0F\"W\xFE[` \x02` \x01\x01Qa\x1F~V[a\x0F\\V[`\x01\x81`\x02\x81\x11\x15a\x0FBW\xFE[\x14\x15a\x0FRWa\x0F/\x85\x85a *V[a\x0F\\\x85\x85a \x82V[\x84\x7F\xF5\x84}?!\x97\xB1l\xDC\xD2\t\x8E\xC9]\t\x05\xCD\x1A\xBD\xAFA_\x07\xBB|\xEF+\xBA\x8A\xC5\xDE\xC4\x85\x85`@Qa\x0F\x8E\x92\x91\x90a[\xEDV[`@Q\x80\x91\x03\x90\xA2PPa\x0F\xA0a\x18\"V[PPPV[a\x0F\xADa\x17hV[a\x0F\xB5a\x18)V[\x81a\x0F\xBF\x81a\x1F3V[`\0a\x0F\xCA\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x0F\xDAW\xFE[\x14\x15a\x10(Wa\x0F\xF0\x83Q`\x02\x14a\x02\x0Ca\x05KV[a\x10#\x84\x84`\0\x81Q\x81\x10a\x10\x01W\xFE[` \x02` \x01\x01Q\x85`\x01\x81Q\x81\x10a\x10\x16W\xFE[` \x02` \x01\x01Qa \xD7V[a\x10PV[`\x01\x81`\x02\x81\x11\x15a\x106W\xFE[\x14\x15a\x10FWa\x10#\x84\x84a!EV[a\x10P\x84\x84a!\xFFV[`\0[\x83Q\x81\x10\x15a\x10\xB6W`\n`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x85\x83\x81Q\x81\x10a\x10}W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x82R\x81\x01\x91\x90\x91R`@\x01`\0 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U`\x01\x01a\x10SV[P\x83\x7F}\xCD\xC6\xD0.\xF4\x0C|\x1ApF\xA0\x11\xB0X\xBD\x7F\x98\x8F\xA1N \xA6cD\xF9\xD4\xE6\x06W\xD6\x10\x84`@Qa\x10\xE7\x91\x90a[\xDAV[`@Q\x80\x91\x03\x90\xA2PPa\x05Ya\x18\"V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x11.\x92\x91\x90aZ\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x0E\0`\x01\x85\x85\x85a\x11\\\x86a\"bV[a\"nV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02` R`@\x90 T\x90V[``a\x11\x86a\x17hV[a\x11\x8Ea\x18)V[\x83Qa\x11\x99\x81a\x1B\x0FV[a\x11\xA8\x83B\x11\x15a\x01\xFCa\x05KV[a\x11\xB4\x86Q\x85Qa\x1E\x12V[a\x11\xC0\x87\x87\x87\x8Ba#\xF4V[\x91P`\0\x80[\x87Q\x81\x10\x15a\x12\x92W`\0\x88\x82\x81Q\x81\x10a\x11\xDDW\xFE[` \x02` \x01\x01Q\x90P`\0\x85\x83\x81Q\x81\x10a\x11\xF5W\xFE[` \x02` \x01\x01Q\x90Pa\x12!\x88\x84\x81Q\x81\x10a\x12\x0EW\xFE[` \x02` \x01\x01Q\x82\x13\x15a\x01\xFBa\x05KV[`\0\x81\x13\x15a\x12aW\x88Q` \x8A\x01Q\x82\x91a\x12@\x91\x85\x91\x84\x91a\x1CZV[a\x12I\x83a\x198V[\x15a\x12[Wa\x12X\x85\x82a\x19EV[\x94P[Pa\x12\x88V[`\0\x81\x12\x15a\x12\x88W`\0\x81`\0\x03\x90Pa\x12\x86\x83\x82\x8C`@\x01Q\x8D``\x01Qa\x1D8V[P[PP`\x01\x01a\x11\xC6V[Pa\x12\x9C\x81a\x19\xDEV[PPa\x12\xA6a\x18\"V[\x96\x95PPPPPPV[`\x03Ta\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\0a\x12\xCEa\x05&V[\x90P\x90V[`\0\x80`\0\x80\x85a\x12\xE3\x81a&\x83V[`\0\x80a\x12\xEF\x89a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x12\xFFW\xFE[\x14\x15a\x13\x16Wa\x13\x0F\x89\x89a&\xA1V[\x91Pa\x13AV[`\x01\x81`\x02\x81\x11\x15a\x13$W\xFE[\x14\x15a\x134Wa\x13\x0F\x89\x89a'\x1BV[a\x13>\x89\x89a'\x89V[\x91P[a\x13J\x82a'\xA1V[\x96Pa\x13U\x82a'\xB4V[\x95Pa\x13`\x82a'\xCAV[`\0\x99\x8AR`\n` \x90\x81R`@\x80\x8C `\x01`\x01`\xA0\x1B\x03\x9B\x8C\x16\x8DR\x90\x91R\x90\x99 T\x96\x99\x95\x98\x97\x96\x90\x96\x16\x95PPPPPV[a\x13\x9Ea\x18)V[a\x0E\0`\0\x85\x85\x85a\x11\\\x86a\"bV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[a\x13\xDBa\x17hV[a\x13\xE3a\x18)V[a\x13\xEBaM1V[`\0[\x82Q\x81\x10\x15a\x14\xE5W\x82\x81\x81Q\x81\x10a\x14\x03W\xFE[` \x02` \x01\x01Q\x91P`\0\x82` \x01Q\x90Pa\x14\x1F\x81a&\x83V[`@\x83\x01Qa\x149a\x141\x83\x83a'\xD0V[a\x02\ta\x05KV[`\0\x82\x81R`\n` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x85R\x92R\x90\x91 Ta\x14l\x91\x163\x14a\x01\xF6a\x05KV[\x83Q``\x85\x01Q`\0\x80a\x14\x82\x84\x87\x87\x86a(,V[\x91P\x91P\x84`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x87\x7Fn\xDC\xAFbA\x10[L\x94\xC2\xEF\xDB\xF3\xA6\xB1$X\xEB=\x07\xBE:\x0E\x81\xD2K\x13\xC4@E\xFEz\x85\x85`@Qa\x14\xCC\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA4PPPPPP\x80`\x01\x01\x90Pa\x13\xEEV[PPa\x05~a\x18\"V[`\0a\x12\xCEa(\x9BV[`\0\x80\x82a\x15\x06\x81a&\x83V[a\x15\x0F\x84a)8V[a\x15\x18\x85a\x1FdV[\x92P\x92P[P\x91P\x91V[``30\x14a\x15\xF6W`\x000`\x01`\x01`\xA0\x1B\x03\x16`\x006`@Qa\x15I\x92\x91\x90aZ\xDAV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x15\x86W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x15\x8BV[``\x91P[PP\x90P\x80`\0\x81\x14a\x15\x9AW\xFE[`\x04`\0\x80>`\0Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x7F\xFAa\xCC\x12\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x15\xDEW=`\0\x80>=`\0\xFD[P` `\0R`\x04=\x03\x80`\x04` >` \x81\x01`\0\xF3[``a\x16\x04\x85\x85\x85\x89a#\xF4V[\x90P` \x81Q\x02c\xFAa\xCC\x12` \x83\x03R`\x04\x82\x03`$\x82\x01\x81\xFD[``\x80`\0\x83a\x16/\x81a&\x83V[``a\x16:\x86a)>V[\x90\x95P\x90Pa\x16H\x81a)\xA0V[\x95\x97\x90\x96P\x93PPPPV[a\x16\\a\x17hV[a\x16da\x18)V[\x82a\x16n\x81a\x1B\x0FV[`\x01`\x01`\xA0\x1B\x03\x84\x81\x16`\0\x81\x81R`\x04` \x90\x81R`@\x80\x83 \x94\x88\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x80T`\xFF\x19\x16\x86\x15\x15\x17\x90UQ\x90\x91\x90\x7FF\x96\x1F\xDBE\x02\xB6F\xD5\t_\xBAv\0Hj\x8A\xC0PA\xD5\\\xDF\x0F\x16\xEDgq\x80\xB5\xCA\xD8\x90a\x16\xD5\x90\x86\x90a]\x1BV[`@Q\x80\x91\x03\x90\xA3Pa\x0F\xA0a\x18\"V[`\0a\x16\xF2\x83\x83a*OV[\x90P[\x92\x91PPV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[a\x17z`\x02`\0T\x14\x15a\x01\x90a\x05KV[`\x02`\0UV[`\0a\x17\x98`\x005`\x01`\x01`\xE0\x1B\x03\x19\x16a\x10\xF9V[\x90Pa\x05~a\x17\xA7\x823a*}V[a\x01\x91a\x05KV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\x94\xB9y\xB6\x83\x1AQ)>&ABo\x97t\x7F\xEE\xD4o\x17w\x9F\xED\x9C\xD1\x8D\x1E\xCE\xFC\xFE\x92\xEF\x90`\0\x90\xA2`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16a\x01\0\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\x90\x92\x16\x91\x90\x91\x17\x90UV[`\x01`\0UV[a\x18<a\x184a\x1A\xAAV[a\x01\x92a\x05KV[V[`\0i\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16`P\x84`\x02\x81\x11\x15a\x18[W\xFE[\x90\x1B\x17``\x85\x90\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x17\x90P[\x93\x92PPPV[`\0\x80`\0\x80`\0\x80`\0\x88``\x01Q\x90P3`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14a\x18\xCFW\x87a\x18\xBAWa\x18\xB5a\x17\x81V[`\x01\x97P[a\x18\xCFa\x18\xC7\x823a*OV[a\x01\xF7a\x05KV[\x88Q` \x8A\x01Q`@\x8B\x01Q`\x80\x90\x9B\x01Q\x91\x9B\x90\x9A\x99\x92\x98P\x90\x96P\x90\x94P\x92PPPV[a\x19\n\x83a\x19\x02\x86a\x1BAV[\x83`\0a+ V[Pa\x0E\0\x84\x82\x84`\0a\x1D8V[a\x19+\x82a\x19%\x86a\x1BAV[\x83a+vV[a\x0E\0\x84\x82\x85`\0a\x1CZV[`\x01`\x01`\xA0\x1B\x03\x16\x15\x90V[`\0\x82\x82\x01a\x16\xF2\x84\x82\x10\x15\x83a\x05KV[a\x19d\x83\x85\x83`\0a+ V[Pa\x0E\0\x82\x85\x83a+vV[\x80\x15a\x0E\0Wa\x19\x8B`\x01`\x01`\xA0\x1B\x03\x85\x16\x84\x84\x84a+\xA6V[\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x7FT\n\x1A?(4\x0C\xAE\xC36\xC8\x1D\x8D{=\xF19\xEE\\\xDC\x189\xA4\xF2\x83\xD7\xEB\xB7\xEA\xAE-\\\x84\x84`@Qa\x19\xD0\x92\x91\x90a[\xC1V[`@Q\x80\x91\x03\x90\xA3PPPPV[a\x19\xED\x814\x10\x15a\x02\x04a\x05KV[4\x81\x90\x03\x80\x15a\x05YWa\x05Y3\x82a+\xC7V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x0B` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[\x80\x15a\x1ALWa\x1AGa\x1A=a\x1A\xC7V[B\x10a\x01\x93a\x05KV[a\x1AaV[a\x1Aaa\x1AWa\x1A\xEBV[B\x10a\x01\xA9a\x05KV[`\x03\x80T`\xFF\x19\x16\x82\x15\x15\x17\x90U`@Q\x7F\x9E:^7\"E2\xDE\xA6{\x89\xFA\xCE\x18W\x03s\x8A\"\x8An\x8A#\xDE\xE5F\x96\x01\x80\xD3\xBEd\x90a\x1A\x9F\x90\x83\x90a]\x1BV[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x1A\xB4a\x1A\xEBV[B\x11\x80a\x12\xCEWPP`\x03T`\xFF\x16\x15\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[3`\x01`\x01`\xA0\x1B\x03\x82\x16\x14a\x05~Wa\x1B'a\x17\x81V[a\x1B1\x813a*OV[a\x05~Wa\x05~\x81a\x01\xF7a,AV[`\0a\x1BL\x82a\x198V[a\x1B^Wa\x1BY\x82a\x05HV[a\x16\xF5V[a\x16\xF5a\x05&V[`\0\x80`\0\x80a\x1By\x85`\x80\x01Qa)8V[\x90P`\0a\x1B\x8A\x86`\x80\x01Qa\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\x1B\x9AW\xFE[\x14\x15a\x1B\xB1Wa\x1B\xAA\x86\x83a,uV[\x94Pa\x1B\xDCV[`\x01\x81`\x02\x81\x11\x15a\x1B\xBFW\xFE[\x14\x15a\x1B\xCFWa\x1B\xAA\x86\x83a-%V[a\x1B\xD9\x86\x83a-\xB8V[\x94P[a\x1B\xEF\x86`\0\x01Q\x87``\x01Q\x87a/\xF7V[\x80\x94P\x81\x95PPP\x85`@\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x86` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x87`\x80\x01Q\x7F!p\xC7A\xC4\x151\xAE\xC2\x0E|\x10|$\xEE\xCF\xDD\x15\xE6\x9C\x9B\xB0\xA8\xDD7\xB1\x84\x0B\x9E\x0B {\x87\x87`@Qa\x1CI\x92\x91\x90a^MV[`@Q\x80\x91\x03\x90\xA4PP\x91\x93\x90\x92PV[\x82a\x1CdWa\x0E\0V[a\x1Cm\x84a\x198V[\x15a\x1C\xEEWa\x1C\x7F\x81\x15a\x02\x02a\x05KV[a\x1C\x8E\x83G\x10\x15a\x02\x04a\x05KV[a\x1C\x96a\x05&V[`\x01`\x01`\xA0\x1B\x03\x16c\xD0\xE3\r\xB0\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x1C\xD0W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1C\xE4W=`\0\x80>=`\0\xFD[PPPPPa\x0E\0V[`\0a\x1C\xF9\x85a\x05HV[\x90P\x81\x15a\x1D\x16W`\0a\x1D\x10\x84\x83\x87`\x01a+ V[\x90\x94\x03\x93P[\x83\x15a\x1D1Wa\x1D1`\x01`\x01`\xA0\x1B\x03\x82\x16\x840\x87a+\xA6V[PPPPPV[\x82a\x1DBWa\x0E\0V[a\x1DK\x84a\x198V[\x15a\x1D\xDBWa\x1D]\x81\x15a\x02\x02a\x05KV[a\x1Dea\x05&V[`\x01`\x01`\xA0\x1B\x03\x16c.\x1A}M\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1D\x90\x91\x90a]>V[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x1D\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x1D\xBEW=`\0\x80>=`\0\xFD[Pa\x1D\xD6\x92PPP`\x01`\x01`\xA0\x1B\x03\x83\x16\x84a+\xC7V[a\x0E\0V[`\0a\x1D\xE6\x85a\x05HV[\x90P\x81\x15a\x1D\xFEWa\x1D\xF9\x83\x82\x86a+vV[a\x1D1V[a\x1D1`\x01`\x01`\xA0\x1B\x03\x82\x16\x84\x86a\x1E\xA6V[a\x05Y\x81\x83\x14`ga\x05KV[`\0\x80a\x1E*a\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x16c\xD8w\x84\\`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1EbW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1EvW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1E\x9A\x91\x90aYhV[\x90Pa\x18v\x83\x82a0%V[a\x0F\xA0\x83c\xA9\x05\x9C\xBB`\xE0\x1B\x84\x84`@Q`$\x01a\x1E\xC5\x92\x91\x90a[\xC1V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x90\x91Ra0rV[\x80\x15a\x05YWa\x05Ya\x1F\"a\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x84\x16\x90\x83a\x1E\xA6V[a\x1F<\x81a&\x83V[a\x05~a\x1FH\x82a)8V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x01\xF5a\x05KV[`\0a\xFF\xFF`P\x83\x90\x1C\x16a\x16\xF5`\x03\x82\x10a\x01\xF4a\x05KV[a\x1F\x9F\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x02\na\x05KV[a\x1F\xBE\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x10`fa\x05KV[`\0\x83\x81R`\t` R`@\x90 \x80Ta\x1F\xFB\x90`\x01`\x01`\xA0\x1B\x03\x16\x15\x80\x15a\x1F\xF3WP`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15[a\x02\x0Ba\x05KV[\x80T`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x01`\x01`\xA0\x1B\x03\x19\x91\x82\x16\x17\x82U`\x01\x90\x91\x01\x80T\x92\x90\x93\x16\x91\x16\x17\x90UPV[`\0\x82\x81R`\x08` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0a k\x84\x83\x81Q\x81\x10a TW\xFE[` \x02` \x01\x01Q\x84a1\x12\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90Pa y\x81a\x02\na\x05KV[P`\x01\x01a :V[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0a \xC0\x84\x83\x81Q\x81\x10a \xACW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01Q\x84\x90`\0a1uV[\x90Pa \xCE\x81a\x02\na\x05KV[P`\x01\x01a \x92V[`\0\x80`\0a \xE7\x86\x86\x86a2\"V[\x92P\x92P\x92Pa!\x11a \xF9\x84a2\xE9V[\x80\x15a!\tWPa!\t\x83a2\xE9V[a\x02\ra\x05KV[`\0\x95\x86R`\t` R`@\x86 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16\x82U`\x01\x90\x91\x01\x80T\x90\x91\x16\x90U\x94\x90\x94UPPPPV[`\0\x82\x81R`\x08` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0\x83\x82\x81Q\x81\x10a!lW\xFE[` \x02` \x01\x01Q\x90Pa!\xB8a!\t`\x07`\0\x88\x81R` \x01\x90\x81R` \x01`\0 `\0\x84`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x90\x81R` \x01`\0 Ta2\xE9V[`\0\x85\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 \x81\x90Ua!\xE7\x84\x83a3\x0BV[\x90Pa!\xF5\x81a\x02\ta\x05KV[PP`\x01\x01a!UV[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0W`\0\x83\x82\x81Q\x81\x10a\"&W\xFE[` \x02` \x01\x01Q\x90P`\0a\"<\x84\x83a4\x12V[\x90Pa\"Ja!\t\x82a2\xE9V[a\"T\x84\x83a4!V[PPP\x80`\x01\x01\x90Pa\"\x0FV[a\"jaMZV[P\x90V[a\"va\x17hV[\x83a\"\x80\x81a&\x83V[\x83a\"\x8A\x81a\x1B\x0FV[a\"\x9E\x83`\0\x01QQ\x84` \x01QQa\x1E\x12V[``a\"\xAD\x84`\0\x01Qa4\xC3V[\x90P``a\"\xBB\x88\x83a5RV[\x90P``\x80``a\"\xD0\x8C\x8C\x8C\x8C\x8C\x89a5\xE3V[\x92P\x92P\x92P`\0a\"\xE1\x8Ca\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a\"\xF1W\xFE[\x14\x15a#YWa#T\x8C\x87`\0\x81Q\x81\x10a#\x08W\xFE[` \x02` \x01\x01Q\x86`\0\x81Q\x81\x10a#\x1DW\xFE[` \x02` \x01\x01Q\x89`\x01\x81Q\x81\x10a#2W\xFE[` \x02` \x01\x01Q\x88`\x01\x81Q\x81\x10a#GW\xFE[` \x02` \x01\x01Qa7\xA8V[a#\x82V[`\x01\x81`\x02\x81\x11\x15a#gW\xFE[\x14\x15a#xWa#T\x8C\x87\x86a7\xE7V[a#\x82\x8C\x85a8TV[`\0\x80\x8E`\x01\x81\x11\x15a#\x91W\xFE[\x14\x90P\x8B`\x01`\x01`\xA0\x1B\x03\x16\x8D\x7F\xE5\xCE$\x90\x87\xCE\x04\xF0Z\x95q\x92CT\0\xFD\x97\x86\x8D\xBA\x0EjKL\x04\x9A\xBF\x8A\xF8\r\xAEx\x89a#\xCB\x88\x86a8\x9DV[\x87`@Qa#\xDB\x93\x92\x91\x90a\\LV[`@Q\x80\x91\x03\x90\xA3PPPPPPPPPa\x1D1a\x18\"V[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a$\x0EW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a$8W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90Pa$CaM\x84V[a$KaL\xE1V[`\0\x80`\0[\x89Q\x81\x10\x15a&vW\x89\x81\x81Q\x81\x10a$fW\xFE[` \x02` \x01\x01Q\x94P`\0\x89Q\x86` \x01Q\x10\x80\x15a$\x8AWP\x89Q\x86`@\x01Q\x10[\x90Pa$\x97\x81`da\x05KV[`\0a$\xB9\x8B\x88` \x01Q\x81Q\x81\x10a$\xACW\xFE[` \x02` \x01\x01Qa\x1BAV[\x90P`\0a$\xD0\x8C\x89`@\x01Q\x81Q\x81\x10a$\xACW\xFE[\x90Pa$\xF3\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a\x01\xFDa\x05KV[``\x88\x01Qa%CWa%\x0B`\0\x85\x11a\x01\xFEa\x05KV[`\0a%\x18\x8B\x84\x84a9EV[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa%:\x81a\x01\xFFa\x05KV[P``\x88\x01\x85\x90R[\x87Q`\x80\x88\x01R\x86\x8A`\x01\x81\x11\x15a%WW\xFE[\x90\x81`\x01\x81\x11\x15a%dW\xFE[\x90RP`\x01`\x01`\xA0\x1B\x03\x80\x83\x16` \x89\x01R\x81\x81\x16`@\x80\x8A\x01\x91\x90\x91R``\x80\x8B\x01Q\x90\x8A\x01R`\x80\x8A\x01Qa\x01\0\x8A\x01R\x8CQ\x82\x16`\xC0\x8A\x01R\x8C\x01Q\x16`\xE0\x88\x01R`\0\x80a%\xB6\x89a\x1BfV[\x91\x98P\x92P\x90Pa%\xC8\x8C\x85\x85a9gV[\x97Pa%\xFCa%\xD6\x83a9\x81V[\x8C\x8C` \x01Q\x81Q\x81\x10a%\xE6W\xFE[` \x02` \x01\x01Qa9\xB1\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x8B\x8B` \x01Q\x81Q\x81\x10a&\x0CW\xFE[` \x02` \x01\x01\x81\x81RPPa&Ja&$\x82a9\x81V[\x8C\x8C`@\x01Q\x81Q\x81\x10a&4W\xFE[` \x02` \x01\x01Qa9\xE5\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x8B\x8B`@\x01Q\x81Q\x81\x10a&ZW\xFE[` \x02` \x01\x01\x81\x81RPPPPPPP\x80`\x01\x01\x90Pa$QV[PPPPP\x94\x93PPPPV[`\0\x81\x81R`\x05` R`@\x90 Ta\x05~\x90`\xFF\x16a\x01\xF4a\x05KV[`\0\x80`\0\x80`\0a&\xB2\x87a:\x19V[\x94P\x94P\x94P\x94PP\x83`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a&\xE1W\x82\x94PPPPPa\x16\xF5V[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14\x15a'\x06W\x93Pa\x16\xF5\x92PPPV[a'\x11a\x02\ta\x16\xFBV[PPPP\x92\x91PPV[`\0\x82\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 T\x81a'H\x82a:\x8FV[\x80a'fWP`\0\x85\x81R`\x08` R`@\x90 a'f\x90\x85a:\xA1V[\x90P\x80a'\x81Wa'v\x85a&\x83V[a'\x81a\x02\ta\x16\xFBV[P\x93\x92PPPV[`\0\x82\x81R`\x01` R`@\x81 a\t\xE1\x81\x84a4\x12V[m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90V[`p\x1Cm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90V[`\xE0\x1C\x90V[`\0\x80a'\xDC\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a'\xECW\xFE[\x14\x15a(\x04Wa'\xFC\x84\x84a:\xC2V[\x91PPa\x16\xF5V[`\x01\x81`\x02\x81\x11\x15a(\x12W\xFE[\x14\x15a(\"Wa'\xFC\x84\x84a;\x13V[a'\xFC\x84\x84a;+V[`\0\x80`\0a(:\x86a\x1FdV[\x90P`\0\x87`\x02\x81\x11\x15a(JW\xFE[\x14\x15a(fWa(\\\x86\x82\x87\x87a;CV[\x92P\x92PPa(\x92V[`\x01\x87`\x02\x81\x11\x15a(tW\xFE[\x14\x15a(\x86Wa(\\\x86\x82\x87\x87a;\xBEV[a(\\\x86\x82\x87\x87a<:V[\x94P\x94\x92PPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a)\x08a<\x9DV[0`@Q` \x01a)\x1D\x95\x94\x93\x92\x91\x90a]\xF0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[``\x1C\x90V[``\x80`\0a)L\x84a\x1FdV[\x90P`\x02\x81`\x02\x81\x11\x15a)\\W\xFE[\x14\x15a)uWa)k\x84a<\xA1V[\x92P\x92PPa)\x9BV[`\x01\x81`\x02\x81\x11\x15a)\x83W\xFE[\x14\x15a)\x92Wa)k\x84a=\xD6V[a)k\x84a>\xFDV[\x91P\x91V[```\0\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a)\xBCW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a)\xE6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0\x90P`\0[\x82Q\x81\x10\x15a\x15\x1DW`\0\x84\x82\x81Q\x81\x10a*\x07W\xFE[` \x02` \x01\x01Q\x90Pa*\x1A\x81a?\xF9V[\x84\x83\x81Q\x81\x10a*&W\xFE[` \x02` \x01\x01\x81\x81RPPa*D\x83a*?\x83a'\xCAV[a@\x14V[\x92PP`\x01\x01a)\xF0V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\0\x90\x81R`\x04` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T`\xFF\x16\x90V[`\x03T`@Q\x7F\x9B\xE2\xA8\x84\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\0\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c\x9B\xE2\xA8\x84\x90a*\xD0\x90\x86\x90\x86\x900\x90`\x04\x01a]GV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a*\xE8W`\0\x80\xFD[PZ\xFA\x15\x80\x15a*\xFCW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xF2\x91\x90aTxV[`\0\x80a+-\x86\x86a\x1A\x01V[\x90Pa+F\x83\x80a+>WP\x84\x82\x10\x15[a\x02\x01a\x05KV[a+P\x81\x85a@+V[\x91P\x81\x81\x03a+l\x87\x87\x83a+d\x87a9\x81V[`\0\x03a@:V[PP\x94\x93PPPPV[`\0a+\x82\x84\x84a\x1A\x01V[\x90P`\0a+\x90\x82\x84a\x19EV[\x90Pa\x1D1\x85\x85\x83a+\xA1\x87a9\x81V[a@:V[a\x0E\0\x84c#\xB8r\xDD`\xE0\x1B\x85\x85\x85`@Q`$\x01a\x1E\xC5\x93\x92\x91\x90a[wV[a+\xD6\x81G\x10\x15a\x01\xA3a\x05KV[`\0\x82`\x01`\x01`\xA0\x1B\x03\x16\x82`@Qa+\xEF\x90a\x05HV[`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a,,W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a,1V[``\x91P[PP\x90Pa\x0F\xA0\x81a\x01\xA4a\x05KV[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02` R`@\x90 \x80T`\x01\x81\x01\x90\x91Ua\x0F\xA0a,o\x84\x83a@\x95V[\x83a\x05KV[`\0\x80`\0\x80a,\x92\x86`\x80\x01Q\x87` \x01Q\x88`@\x01Qa2\"V[\x92P\x92P\x92P`\0\x80\x87`@\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x88` \x01Q`\x01`\x01`\xA0\x1B\x03\x16\x10\x15a,\xC7WP\x83\x90P\x82a,\xCDV[P\x82\x90P\x83[a,\xD9\x88\x88\x84\x84aA\xBBV[`@\x8B\x01Q` \x8C\x01Q\x91\x99P\x92\x94P\x90\x92P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x10a-\rWa-\x08\x81\x83aB\xD1V[a-\x17V[a-\x17\x82\x82aB\xD1V[\x90\x92UP\x92\x95\x94PPPPPV[`\0\x80a-:\x84`\x80\x01Q\x85` \x01Qa'\x1BV[\x90P`\0a-P\x85`\x80\x01Q\x86`@\x01Qa'\x1BV[\x90Pa-^\x85\x85\x84\x84aA\xBBV[`\x80\x88\x01\x80Q`\0\x90\x81R`\x07` \x81\x81R`@\x80\x84 \x82\x8E\x01Q`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x86R\x90\x83R\x81\x85 \x98\x90\x98U\x93Q\x83R\x90\x81R\x82\x82 \x9A\x83\x01Q\x90\x95\x16\x81R\x98\x90\x93R\x91\x90\x96 \x95\x90\x95UP\x92\x93\x92PPPV[`\x80\x82\x01Q`\0\x90\x81R`\x01` \x90\x81R`@\x82 \x90\x84\x01Q\x82\x91\x82\x91\x82\x90a-\xE2\x90\x83\x90aC\x0CV[\x90P`\0a-\xFD\x88`@\x01Q\x84aC\x0C\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x81\x15\x80a.\nWP\x80\x15[\x15a.'Wa.\x1C\x88`\x80\x01Qa&\x83V[a.'a\x02\ta\x16\xFBV[`\0\x19\x91\x82\x01\x91\x01`\0a.:\x84aC+V[\x90P``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a.UW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a.\x7FW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P`\0`\xA0\x8C\x01\x81\x90R\x90\x91P[\x82\x81\x10\x15a.\xFFW`\0a.\xA1\x87\x83aC/V[\x90Pa.\xAC\x81a?\xF9V[\x83\x83\x81Q\x81\x10a.\xB8W\xFE[` \x02` \x01\x01\x81\x81RPPa.\xD5\x8C`\xA0\x01Qa*?\x83a'\xCAV[`\xA0\x8D\x01R\x81\x86\x14\x15a.\xEAW\x80\x98Pa.\xF6V[\x84\x82\x14\x15a.\xF6W\x80\x97P[P`\x01\x01a.\x8DV[P`@Q\x7F\x01\xEC\x95J\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x16\x90c\x01\xEC\x95J\x90a/K\x90\x8D\x90\x85\x90\x89\x90\x89\x90`\x04\x01a^[V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a/eW`\0\x80\xFD[PZ\xF1\x15\x80\x15a/yW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a/\x9D\x91\x90aYhV[\x97P`\0\x80a/\xB5\x8C`\0\x01Q\x8D``\x01Q\x8Ca/\xF7V[\x90\x92P\x90Pa/\xC4\x89\x83aCEV[\x98Pa/\xD0\x88\x82aCvV[\x97Pa/\xDD\x87\x87\x8BaC\x8CV[a/\xE8\x87\x86\x8AaC\x8CV[PPPPPPPPP\x92\x91PPV[`\0\x80\x80\x85`\x01\x81\x11\x15a0\x07W\xFE[\x14\x15a0\x17WP\x82\x90P\x81a0\x1DV[P\x81\x90P\x82[\x93P\x93\x91PPV[`\0\x82\x82\x02a0I\x84\x15\x80a0BWP\x83\x85\x83\x81a0?W\xFE[\x04\x14[`\x03a\x05KV[\x80a0XW`\0\x91PPa\x16\xF5V[g\r\xE0\xB6\xB3\xA7d\0\0`\0\x19\x82\x01\x04`\x01\x01\x91PPa\x16\xF5V[`\0``\x83`\x01`\x01`\xA0\x1B\x03\x16\x83`@Qa0\x8E\x91\x90aZ\xEAV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a0\xCBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a0\xD0V[``\x91P[P\x91P\x91P`\0\x82\x14\x15a0\xE8W=`\0\x80>=`\0\xFD[a\x0E\0\x81Q`\0\x14\x80a1\nWP\x81\x80` \x01\x90Q\x81\x01\x90a1\n\x91\x90aTxV[a\x01\xA2a\x05KV[`\0a1\x1E\x83\x83a:\xA1V[a1mWP\x81T`\x01\x80\x82\x01\x84U`\0\x84\x81R` \x80\x82 \x90\x93\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x86\x16\x90\x81\x17\x90\x91U\x85T\x90\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x16\xF5V[P`\0a\x16\xF5V[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02\x84\x01` R`@\x81 T\x80a2\x02WPP\x82T`@\x80Q\x80\x82\x01\x82R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16\x80\x83R` \x80\x84\x01\x87\x81R`\0\x87\x81R`\x01\x80\x8C\x01\x84R\x87\x82 \x96Q\x87T`\x01`\x01`\xA0\x1B\x03\x19\x16\x96\x16\x95\x90\x95\x17\x86U\x90Q\x94\x84\x01\x94\x90\x94U\x94\x82\x01\x80\x89U\x90\x83R`\x02\x88\x01\x90\x94R\x91\x90 \x91\x90\x91Ua\x18vV[`\0\x19\x01`\0\x90\x81R`\x01\x80\x86\x01` R`@\x82 \x01\x83\x90U\x90Pa\x18vV[`\0\x80`\0\x80`\0a24\x87\x87aC\xA4V[\x91P\x91P`\0a2D\x83\x83aC\xD5V[`\0\x8A\x81R`\t` \x90\x81R`@\x80\x83 \x84\x84R`\x02\x01\x90\x91R\x81 \x80T`\x01\x82\x01T\x91\x97P\x92\x93P\x90a2w\x83a:\x8FV[\x80a2\x86WPa2\x86\x82a:\x8FV[\x80a2\xA7WPa2\x96\x8C\x87a:\xC2V[\x80\x15a2\xA7WPa2\xA7\x8C\x86a:\xC2V[\x90P\x80a2\xC2Wa2\xB7\x8Ca&\x83V[a2\xC2a\x02\ta\x16\xFBV[a2\xCC\x83\x83aD\x08V[\x98Pa2\xD8\x83\x83aD-V[\x97PPPPPPP\x93P\x93P\x93\x90PV[{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a4\x08W\x83T`\0\x19\x80\x83\x01\x91\x90\x81\x01\x90`\0\x90\x87\x90\x83\x90\x81\x10a3HW\xFE[`\0\x91\x82R` \x90\x91 \x01T\x87T`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91P\x81\x90\x88\x90\x85\x90\x81\x10a3qW\xFE[`\0\x91\x82R` \x80\x83 \x91\x90\x91\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x17\x90U\x91\x83\x16\x81R`\x01\x89\x81\x01\x90\x92R`@\x90 \x90\x84\x01\x90U\x86T\x87\x90\x80a3\xBAW\xFE[`\0\x82\x81R` \x80\x82 \x83\x01`\0\x19\x90\x81\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U\x90\x92\x01\x90\x92U`\x01`\x01`\xA0\x1B\x03\x88\x16\x82R`\x01\x89\x81\x01\x90\x91R`@\x82 \x91\x90\x91U\x94Pa\x16\xF5\x93PPPPV[`\0\x91PPa\x16\xF5V[`\0a\x16\xF2\x83\x83a\x02\taDDV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x02\x83\x01` R`@\x81 T\x80\x15a4\x08W\x83T`\0\x19\x90\x81\x01`\0\x81\x81R`\x01\x87\x81\x01` \x90\x81R`@\x80\x84 \x95\x87\x01\x84R\x80\x84 \x86T\x81T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x17\x83U\x88\x86\x01\x80T\x93\x87\x01\x93\x90\x93U\x88T\x82\x16\x87R`\x02\x8D\x01\x80\x86R\x84\x88 \x9A\x90\x9AU\x88T\x16\x90\x97U\x84\x90U\x93\x89U\x93\x87\x16\x82R\x93\x90\x92R\x81 U\x90Pa\x16\xF5V[``\x80\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a4\xDEW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a5\x08W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x83Q\x81\x10\x15a\x07\xFFWa5&\x84\x82\x81Q\x81\x10a$\xACW\xFE[\x82\x82\x81Q\x81\x10a52W\xFE[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R`\x01\x01a5\x0EV[``\x80``a5`\x85a)>V[\x91P\x91Pa5p\x82Q\x85Qa\x1E\x12V[a5\x80`\0\x83Q\x11a\x02\x0Fa\x05KV[`\0[\x82Q\x81\x10\x15a5\xDAWa5\xD2\x85\x82\x81Q\x81\x10a5\x9BW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x84\x83\x81Q\x81\x10a5\xB8W\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x08a\x05KV[`\x01\x01a5\x83V[P\x94\x93PPPPV[``\x80``\x80`\0a5\xF4\x86a)\xA0V[\x91P\x91P`\0a6\x03\x8Ba)8V[\x90P`\0\x8C`\x01\x81\x11\x15a6\x13W\xFE[\x14a6\xB6W\x80`\x01`\x01`\xA0\x1B\x03\x16ct\xF3\xB0\t\x8C\x8C\x8C\x87\x87a64aD\x81V[\x8F`@\x01Q`@Q\x88c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6[\x97\x96\x95\x94\x93\x92\x91\x90a]fV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a6uW`\0\x80\xFD[PZ\xF1\x15\x80\x15a6\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra6\xB1\x91\x90\x81\x01\x90aT\x05V[a7OV[\x80`\x01`\x01`\xA0\x1B\x03\x16c\xD5\xC0\x96\xC4\x8C\x8C\x8C\x87\x87a6\xD2aD\x81V[\x8F`@\x01Q`@Q\x88c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a6\xF9\x97\x96\x95\x94\x93\x92\x91\x90a]fV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a7\x13W`\0\x80\xFD[PZ\xF1\x15\x80\x15a7'W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra7O\x91\x90\x81\x01\x90aT\x05V[\x80\x95P\x81\x96PPPa7e\x87Q\x86Q\x86QaD\xFBV[`\0\x8C`\x01\x81\x11\x15a7sW\xFE[\x14a7\x8AWa7\x85\x89\x89\x89\x88\x88aE\x13V[a7\x97V[a7\x97\x8A\x89\x89\x88\x88aFZV[\x95PPPP\x96P\x96P\x96\x93PPPPV[`\0a7\xB4\x85\x84aC\xD5V[`\0\x87\x81R`\t` \x90\x81R`@\x80\x83 \x84\x84R`\x02\x01\x90\x91R\x90 \x90\x91Pa7\xDD\x85\x84aB\xD1V[\x90UPPPPPPV[`\0[\x82Q\x81\x10\x15a\x0E\0W\x81\x81\x81Q\x81\x10a7\xFFW\xFE[` \x02` \x01\x01Q`\x07`\0\x86\x81R` \x01\x90\x81R` \x01`\0 `\0\x85\x84\x81Q\x81\x10a8(W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x82R\x81\x01\x91\x90\x91R`@\x01`\0 U`\x01\x01a7\xEAV[`\0\x82\x81R`\x01` R`@\x81 \x90[\x82Q\x81\x10\x15a\x0E\0Wa8\x95\x81\x84\x83\x81Q\x81\x10a8}W\xFE[` \x02` \x01\x01Q\x84aC\x8C\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[`\x01\x01a8dV[``\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a8\xB7W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8\xE1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x83Q\x81\x10\x15a\x07\xFFW\x82a9\x11W\x83\x81\x81Q\x81\x10a9\x01W\xFE[` \x02` \x01\x01Q`\0\x03a9&V[\x83\x81\x81Q\x81\x10a9\x1DW\xFE[` \x02` \x01\x01Q[\x82\x82\x81Q\x81\x10a92W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a8\xE7V[`\0\x80\x84`\x01\x81\x11\x15a9TW\xFE[\x14a9_W\x81a\t\xE1V[P\x90\x92\x91PPV[`\0\x80\x84`\x01\x81\x11\x15a9vW\xFE[\x14a\x07\xFFW\x82a\t\xE1V[`\0a\"j\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83\x10a\x01\xA5a\x05KV[`\0\x82\x82\x01a\x16\xF2\x82\x84\x12\x80\x15\x90a9\xC9WP\x84\x82\x12\x15[\x80a9\xDEWP`\0\x84\x12\x80\x15a9\xDEWP\x84\x82\x12[`\0a\x05KV[`\0\x81\x83\x03a\x16\xF2\x82\x84\x12\x80\x15\x90a9\xFDWP\x84\x82\x13\x15[\x80a:\x12WP`\0\x84\x12\x80\x15a:\x12WP\x84\x82\x13[`\x01a\x05KV[`\0\x81\x81R`\t` R`@\x81 \x80T`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x84\x92\x90\x91\x16\x90\x82\x90\x81a:M\x86\x85aC\xD5V[`\0\x81\x81R`\x02\x84\x01` R`@\x90 \x80T`\x01\x82\x01T\x91\x99P\x91\x92Pa:t\x82\x82aD\x08V[\x96Pa:\x80\x82\x82aD-V[\x94PPPPP\x91\x93\x95\x90\x92\x94PV[`\0a:\x9A\x82a2\xE9V[\x15\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x01\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[`\0\x82\x81R`\t` R`@\x81 \x80T`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x14\x80a:\xFAWP`\x01\x81\x01T`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x16\x14[\x80\x15a\t\xE1WPPP`\x01`\x01`\xA0\x1B\x03\x16\x15\x15\x91\x90PV[`\0\x82\x81R`\x08` R`@\x81 a\t\xE1\x81\x84a:\xA1V[`\0\x82\x81R`\x01` R`@\x81 a\t\xE1\x81\x84aG\xD0V[`\0\x80`\x02\x85`\x02\x81\x11\x15a;TW\xFE[\x14\x15a;jWa;e\x86\x85\x85aG\xF1V[a;\x94V[`\x01\x85`\x02\x81\x11\x15a;xW\xFE[\x14\x15a;\x89Wa;e\x86\x85\x85aG\xFFV[a;\x94\x86\x85\x85aH\rV[\x82\x15a;\xAEWa;\xAE`\x01`\x01`\xA0\x1B\x03\x85\x163\x85a\x1E\xA6V[PP`\0\x81\x90\x03\x94\x90\x93P\x91PPV[`\0\x80`\x02\x85`\x02\x81\x11\x15a;\xCFW\xFE[\x14\x15a;\xE5Wa;\xE0\x86\x85\x85aH\x1BV[a<\x0FV[`\x01\x85`\x02\x81\x11\x15a;\xF3W\xFE[\x14\x15a<\x04Wa;\xE0\x86\x85\x85aH)V[a<\x0F\x86\x85\x85aH7V[\x82\x15a<*Wa<*`\x01`\x01`\xA0\x1B\x03\x85\x1630\x86a+\xA6V[P\x90\x94`\0\x86\x90\x03\x94P\x92PPPV[`\0\x80`\x02\x85`\x02\x81\x11\x15a<KW\xFE[\x14\x15a<cWa<\\\x86\x85\x85aHEV[\x90Pa<\x90V[`\x01\x85`\x02\x81\x11\x15a<qW\xFE[\x14\x15a<\x82Wa<\\\x86\x85\x85aHUV[a<\x8D\x86\x85\x85aHeV[\x90P[`\0\x91P\x94P\x94\x92PPPV[F\x90V[``\x80`\0\x80`\0\x80a<\xB3\x87a:\x19V[\x92\x97P\x90\x95P\x93P\x91PP`\x01`\x01`\xA0\x1B\x03\x84\x16\x15\x80a<\xDBWP`\x01`\x01`\xA0\x1B\x03\x82\x16\x15[\x15a=\x04WPP`@\x80Q`\0\x80\x82R` \x82\x01\x90\x81R\x81\x83\x01\x90\x92R\x94P\x92Pa)\x9B\x91PPV[`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x91` \x83\x01\x90\x806\x837\x01\x90PP\x95P\x83\x86`\0\x81Q\x81\x10a=2W\xFE[` \x02` \x01\x01\x90`\x01`\x01`\xA0\x1B\x03\x16\x90\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP\x81\x86`\x01\x81Q\x81\x10a=`W\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x82\x01R`@\x80Q`\x02\x80\x82R``\x82\x01\x83R\x90\x92\x90\x91\x90\x83\x01\x90\x806\x837\x01\x90PP\x94P\x82\x85`\0\x81Q\x81\x10a=\xA7W\xFE[` \x02` \x01\x01\x81\x81RPP\x80\x85`\x01\x81Q\x81\x10a=\xC1W\xFE[` \x02` \x01\x01\x81\x81RPPPPPP\x91P\x91V[`\0\x81\x81R`\x08` R`@\x90 ``\x90\x81\x90a=\xF2\x81aC+V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a>\x08W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a>2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92P\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a>MW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a>wW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x83Q\x81\x10\x15a>\xF6W`\0a>\x92\x83\x83aHuV[\x90P\x80\x85\x83\x81Q\x81\x10a>\xA1W\xFE[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x81\x01\x91\x90\x91R`\0\x88\x81R`\x07\x82R`@\x80\x82 \x93\x85\x16\x82R\x92\x90\x91R T\x84Q\x85\x90\x84\x90\x81\x10a>\xE2W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RP`\x01\x01a>}V[PP\x91P\x91V[`\0\x81\x81R`\x01` R`@\x90 ``\x90\x81\x90a?\x19\x81aC+V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?/W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a?YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92P\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?tW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a?\x9EW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x83Q\x81\x10\x15a>\xF6Wa?\xB7\x82\x82aH\xA2V[\x85\x83\x81Q\x81\x10a?\xC3W\xFE[` \x02` \x01\x01\x85\x84\x81Q\x81\x10a?\xD6W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a?\xA4V[`\0a@\x04\x82a'\xB4V[a@\r\x83a'\xA1V[\x01\x92\x91PPV[`\0\x81\x83\x10\x15a@$W\x81a\x16\xF2V[P\x90\x91\x90PV[`\0\x81\x83\x10a@$W\x81a\x16\xF2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`\0\x81\x81R`\x0B` \x90\x81R`@\x80\x83 \x94\x88\x16\x80\x84R\x94\x90\x91R\x90\x81\x90 \x85\x90UQ\x7F\x18\xE1\xEAA9\xE6\x84\x13\xD7\xD0\x8A\xA7R\xE7\x15h\xE3k,[\xF9@\x893\x14\xC2\xC5\xB0\x1E\xAA\x0CB\x90a\x19\xD0\x90\x85\x90a]>V[`\0\x80a@\xA0aH\xC6V[\x90PB\x81\x10\x15a@\xB4W`\0\x91PPa\x16\xF5V[`\0a@\xBEaH\xD2V[\x90P\x80a@\xD0W`\0\x92PPPa\x16\xF5V[`\0\x81a@\xDBaI\xE3V[\x80Q` \x91\x82\x01 `@Qa@\xF7\x93\x923\x91\x8A\x91\x89\x91\x01a]\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\0aA\x1A\x82aJ2V[\x90P`\0\x80`\0aA)aJNV[\x92P\x92P\x92P`\0`\x01\x85\x85\x85\x85`@Q`\0\x81R` \x01`@R`@QaAT\x94\x93\x92\x91\x90a^\x1CV[` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15aAvW=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16\x15\x80\x15\x90aA\xACWP\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14[\x9B\x9APPPPPPPPPPPV[`\0\x80`\0\x80aA\xCA\x86a?\xF9V[\x90P`\0aA\xD7\x86a?\xF9V[\x90PaA\xEEaA\xE5\x88a'\xCAV[a*?\x88a'\xCAV[`\xA0\x8A\x01R`@Q\x7F\x9D,\x11\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x16\x90c\x9D,\x11\x0C\x90aB<\x90\x8C\x90\x86\x90\x86\x90`\x04\x01a^\x94V[` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aBVW`\0\x80\xFD[PZ\xF1\x15\x80\x15aBjW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90aB\x8E\x91\x90aYhV[\x92P`\0\x80aB\xA6\x8B`\0\x01Q\x8C``\x01Q\x87a/\xF7V[\x90\x92P\x90PaB\xB5\x89\x83aCEV[\x96PaB\xC1\x88\x82aCvV[\x95PPPPP\x94P\x94P\x94\x91PPV[`\0\x80aB\xE9aB\xE0\x85a'\xCAV[a*?\x85a'\xCAV[\x90Pa\t\xE1aB\xF7\x85a'\xA1V[aC\0\x85a'\xA1V[\x83c\xFF\xFF\xFF\xFF\x16aJuV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02\x91\x90\x91\x01` R`@\x90 T\x90V[T\x90V[`\0\x90\x81R`\x01\x91\x82\x01` R`@\x90 \x01T\x90V[`\0\x80aC[\x83aCU\x86a'\xA1V[\x90a\x19EV[\x90P`\0aCh\x85a'\xB4V[\x90PCa\x12\xA6\x83\x83\x83aJ\x83V[`\0\x80aC[\x83aC\x86\x86a'\xA1V[\x90aJ\xBCV[`\0\x91\x82R`\x01\x92\x83\x01` R`@\x90\x91 \x90\x91\x01UV[`\0\x80\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x10aC\xC7W\x82\x84aC\xCAV[\x83\x83[\x91P\x91P\x92P\x92\x90PV[`\0\x82\x82`@Q` \x01aC\xEA\x92\x91\x90a[\x06V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x92\x91PPV[`\0a\x16\xF2aD\x16\x84a'\xA1V[aD\x1F\x84a'\xA1V[aD(\x86a'\xCAV[aJ\x83V[`\0a\x16\xF2aD;\x84a'\xB4V[aD\x1F\x84a'\xB4V[`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x02\x84\x01` R`@\x81 TaDk\x81\x15\x15\x84a\x05KV[aDx\x85`\x01\x83\x03aC/V[\x95\x94PPPPPV[`\0aD\x8Ba\x13\xAFV[`\x01`\x01`\xA0\x1B\x03\x16cU\xC6v(`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aD\xC3W`\0\x80\xFD[PZ\xFA\x15\x80\x15aD\xD7W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xCE\x91\x90aYhV[a\x0F\xA0\x82\x84\x14\x80\x15aE\x0CWP\x81\x83\x14[`ga\x05KV[``\x83Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aE-W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aEWW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x85QQ\x81\x10\x15aFPW`\0\x84\x82\x81Q\x81\x10aEuW\xFE[` \x02` \x01\x01Q\x90PaE\xA5\x87` \x01Q\x83\x81Q\x81\x10aE\x92W\xFE[` \x02` \x01\x01Q\x82\x10\x15a\x01\xF9a\x05KV[`\0\x87`\0\x01Q\x83\x81Q\x81\x10aE\xB7W\xFE[` \x02` \x01\x01Q\x90PaE\xD1\x81\x83\x8B\x8B``\x01Qa\x1D8V[`\0\x85\x84\x81Q\x81\x10aE\xDFW\xFE[` \x02` \x01\x01Q\x90PaE\xFBaE\xF5\x83a\x1BAV[\x82a\x1F\x11V[aF*aF\x08\x84\x83a\x19EV[\x89\x86\x81Q\x81\x10aF\x14W\xFE[` \x02` \x01\x01QaCv\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x85\x85\x81Q\x81\x10aF6W\xFE[` \x02` \x01\x01\x81\x81RPPPPP\x80`\x01\x01\x90PaE]V[P\x95\x94PPPPPV[```\0\x84Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aFvW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aF\xA0W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x91P`\0[\x86QQ\x81\x10\x15aG\xC6W`\0\x85\x82\x81Q\x81\x10aF\xBEW\xFE[` \x02` \x01\x01Q\x90PaF\xEE\x88` \x01Q\x83\x81Q\x81\x10aF\xDBW\xFE[` \x02` \x01\x01Q\x82\x11\x15a\x01\xFAa\x05KV[`\0\x88`\0\x01Q\x83\x81Q\x81\x10aG\0W\xFE[` \x02` \x01\x01Q\x90PaG\x1A\x81\x83\x8C\x8C``\x01Qa\x1CZV[aG#\x81a\x198V[\x15aG5WaG2\x84\x83a\x19EV[\x93P[`\0\x86\x84\x81Q\x81\x10aGCW\xFE[` \x02` \x01\x01Q\x90PaGYaE\xF5\x83a\x1BAV[\x80\x83\x10\x15aGxWaGs\x83\x82\x03\x8A\x86\x81Q\x81\x10aF\x14W\xFE[aG\xA0V[aG\xA0\x81\x84\x03\x8A\x86\x81Q\x81\x10aG\x8AW\xFE[` \x02` \x01\x01QaCE\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x86\x85\x81Q\x81\x10aG\xACW\xFE[` \x02` \x01\x01\x81\x81RPPPPP\x80`\x01\x01\x90PaF\xA6V[PaFP\x81a\x19\xDEV[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x02\x91\x90\x91\x01` R`@\x90 T\x15\x15\x90V[a\x0E\0\x83\x83aJ\xD2\x84aK\rV[a\x0E\0\x83\x83aJ\xD2\x84aK\xB8V[a\x0E\0\x83\x83aJ\xD2\x84aL\x13V[a\x0E\0\x83\x83aLb\x84aK\rV[a\x0E\0\x83\x83aLb\x84aK\xB8V[a\x0E\0\x83\x83aLb\x84aL\x13V[`\0a\t\xE1\x84\x84aL\x83\x85aK\rV[`\0a\t\xE1\x84\x84aL\x83\x85aK\xB8V[`\0a\t\xE1\x84\x84aL\x83\x85aL\x13V[`\0\x82`\0\x01\x82\x81T\x81\x10aH\x86W\xFE[`\0\x91\x82R` \x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x93\x92PPPV[`\0\x90\x81R`\x01\x91\x82\x01` R`@\x90 \x80T\x91\x01T`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91V[`\0a\x12\xCE`\0aL\x9DV[`\0\x805`\xE0\x1C\x80c\xB9\\\xAC(\x81\x14aI\x1AWc\x8B\xDB9\x13\x81\x14aIBWcR\xBB\xBE)\x81\x14aIjWc\x94[\xCE\xC9\x81\x14aI\x92Wc\xFAng\x1D\x81\x14aI\xBAW`\0\x92PaI\xDEV[\x7F?{q%+\xD1\x91\x13\xFFH\xC1\x9Cn\0J\x9B\xCF\xCC\xA3 \xA0\xD7MX\xE8Xw\xCB\xD7\xDC\xAEX\x92PaI\xDEV[\x7F\x8B\xBCW\xF6n\xA96\x90/P\xA7\x1C\xE1+\x92\xC4?<S@\xBB@\xC2|N\x90\xAB\x84\xEE\xAE3S\x92PaI\xDEV[\x7F\xE1\x92\xDC\xBC\x14;\x1E$J\xD7;\x81?\xD3\xC0\x97\xB82\xAD&\n\x15s@\xB4\xE5\xE5\xBE\xDA\x06z\xBE\x92PaI\xDEV[\x7F\x9B\xFCC\xA4\xD9\x83\x13\xC6vi\x86\xFF\xD7\xC9\x16\xC7H\x15f\xD9\xF2$\xC6\x81\x9A\xF0\xA53\x88\xAC\xED:\x92PaI\xDEV[\x7F\xA3\xF8e\xAA5\x1EQ\xCF\xEB@\xF5\x17\x8D\x15d\xBBb\x9F\xE9\x03\x0B\x83\xCA\xF66\x1D\x1B\xAA\xF5\xB9\x0BZ\x92P[PP\x90V[```\x006\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RPP\x82Q\x92\x93PPP`\x80\x10\x15a\x05HW`\x806\x03\x81R\x90V[`\0aJ<a(\x9BV[\x82`@Q` \x01a\x11.\x92\x91\x90a[-V[`\0\x80`\0aJ]` aL\x9DV[\x92PaJi`@aL\x9DV[\x91Pa\x08A``aL\x9DV[`\xE0\x1B`p\x91\x90\x91\x1B\x01\x01\x90V[`\0\x83\x83\x01aJ\xB1\x85\x82\x10\x80\x15\x90aJ\xA9WPn\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x10[a\x02\x0Ea\x05KV[aDx\x85\x85\x85aJuV[`\0aJ\xCC\x83\x83\x11\x15`\x01a\x05KV[P\x90\x03\x90V[`\0\x80aJ\xE2\x83aC\x86\x86a'\xA1V[\x90P`\0aJ\xF3\x84aCU\x87a'\xB4V[\x90P`\0aK\0\x86a'\xCAV[\x90Pa\x12\xA6\x83\x83\x83aJ\x83V[`\0\x80`\0\x80`\0aK\x1E\x89a:\x19V[\x94PP\x93P\x93P\x93P`\0\x83`\x01`\x01`\xA0\x1B\x03\x16\x89`\x01`\x01`\xA0\x1B\x03\x16\x14\x15aKiW`\0aKS\x84\x89\x8Bc\xFF\xFF\xFF\xFF\x16V[\x90PaK_\x81\x85aL\xA7V[\x90\x93P\x90PaK\x8BV[`\0aKy\x83\x89\x8Bc\xFF\xFF\xFF\xFF\x16V[\x90PaK\x85\x81\x84aL\xA7V[\x90\x92P\x90P[aK\x95\x83\x83aB\xD1V[\x85UaK\xA1\x83\x83aL\xC3V[`\x01\x90\x95\x01\x94\x90\x94UP\x91\x92PPP\x94\x93PPPPV[`\0\x80aK\xC5\x86\x86a'\x1BV[\x90P`\0aK\xD7\x82\x85\x87c\xFF\xFF\xFF\xFF\x16V[`\0\x88\x81R`\x07` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x8B\x16\x84R\x90\x91R\x90 \x81\x90U\x90PaL\x08\x81\x83aL\xA7V[\x97\x96PPPPPPPV[`\0\x84\x81R`\x01` R`@\x81 \x81aL,\x82\x87a4\x12V[\x90P`\0aL>\x82\x86\x88c\xFF\xFF\xFF\xFF\x16V[\x90PaLK\x83\x88\x83a1uV[PaLV\x81\x83aL\xA7V[\x98\x97PPPPPPPPV[`\0\x80aLr\x83aCU\x86a'\xA1V[\x90P`\0aJ\xF3\x84aC\x86\x87a'\xB4V[`\0\x80aL\x8F\x84a'\xA1V[\x90PCaDx\x82\x85\x83aJ\x83V[6\x01`\x7F\x19\x015\x90V[`\0aL\xB2\x82a'\xB4V[aL\xBB\x84a'\xB4V[\x03\x93\x92PPPV[`\0a\x16\xF2aL\xD1\x84a'\xB4V[aL\xDA\x84a'\xB4V[`\0aJuV[`@\x80Qa\x01 \x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x80\x83\x01\x82\x90R`\x80\x83\x01\x82\x90R`\xA0\x83\x01\x82\x90R`\xC0\x83\x01\x82\x90R`\xE0\x83\x01\x91\x90\x91Ra\x01\0\x90\x91\x01R\x90V[`@\x80Q`\x80\x81\x01\x90\x91R\x80`\0\x81R`\0` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[`@Q\x80`\x80\x01`@R\x80``\x81R` \x01``\x81R` \x01``\x81R` \x01`\0\x15\x15\x81RP\x90V[`@Q\x80`\xA0\x01`@R\x80`\0\x80\x19\x16\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01`\0\x81R` \x01``\x81RP\x90V[\x805a\x16\xF5\x81a_ZV[`\0\x82`\x1F\x83\x01\x12aM\xD1W\x80\x81\xFD[\x815aM\xE4aM\xDF\x82a_\x04V[a^\xDDV[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aN\x05W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x815aN\x1B\x81a_ZV[\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aN\x08V[PPPPP\x92\x91PPV[`\0\x82`\x1F\x83\x01\x12aNHW\x80\x81\xFD[\x815aNVaM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01`\0[\x84\x81\x10\x15aN-W\x815\x87\x01`\xA0\x80`\x1F\x19\x83\x8C\x03\x01\x12\x15aN\x88W`\0\x80\xFD[aN\x91\x81a^\xDDV[\x85\x83\x015\x81R`@\x80\x84\x015\x87\x83\x01R``\x80\x85\x015\x82\x84\x01R`\x80\x91P\x81\x85\x015\x81\x84\x01RP\x82\x84\x015\x92Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x15aN\xD3W`\0\x80\xFD[aN\xE1\x8C\x88\x85\x87\x01\x01aO\xC0V[\x90\x82\x01R\x86RPP\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aNgV[`\0\x82`\x1F\x83\x01\x12aO\tW\x80\x81\xFD[\x815aO\x17aM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aO8W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x815\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aO;V[`\0\x82`\x1F\x83\x01\x12aOgW\x80\x81\xFD[\x81QaOuaM\xDF\x82a_\x04V[\x81\x81R\x91P` \x80\x83\x01\x90\x84\x81\x01\x81\x84\x02\x86\x01\x82\x01\x87\x10\x15aO\x96W`\0\x80\xFD[`\0[\x84\x81\x10\x15aN-W\x81Q\x84R\x92\x82\x01\x92\x90\x82\x01\x90`\x01\x01aO\x99V[\x805a\x16\xF5\x81a_oV[`\0\x82`\x1F\x83\x01\x12aO\xD0W\x80\x81\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aO\xE6W\x81\x82\xFD[aO\xF9`\x1F\x82\x01`\x1F\x19\x16` \x01a^\xDDV[\x91P\x80\x82R\x83` \x82\x85\x01\x01\x11\x15aP\x10W`\0\x80\xFD[\x80` \x84\x01` \x84\x017`\0\x90\x82\x01` \x01R\x92\x91PPV[\x805a\x16\xF5\x81a_}V[\x805`\x02\x81\x10a\x16\xF5W`\0\x80\xFD[\x805`\x04\x81\x10a\x16\xF5W`\0\x80\xFD[`\0`\x80\x82\x84\x03\x12\x15aPcW\x80\x81\xFD[aPm`\x80a^\xDDV[\x90P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aP\x87W`\0\x80\xFD[aP\x93\x85\x83\x86\x01aM\xC1V[\x83R` \x84\x015\x91P\x80\x82\x11\x15aP\xA9W`\0\x80\xFD[aP\xB5\x85\x83\x86\x01aN\xF9V[` \x84\x01R`@\x84\x015\x91P\x80\x82\x11\x15aP\xCEW`\0\x80\xFD[PaP\xDB\x84\x82\x85\x01aO\xC0V[`@\x83\x01RPaP\xEE\x83``\x84\x01aO\xB5V[``\x82\x01R\x92\x91PPV[`\0`\x80\x82\x84\x03\x12\x15aQ\nW\x80\x81\xFD[aQ\x14`\x80a^\xDDV[\x90P\x815aQ!\x81a_ZV[\x81R` \x82\x015aQ1\x81a_oV[` \x82\x01R`@\x82\x015aQD\x81a_ZV[`@\x82\x01R``\x82\x015aP\xEE\x81a_oV[`\0` \x82\x84\x03\x12\x15aQhW\x80\x81\xFD[\x815a\x16\xF2\x81a_ZV[`\0\x80`@\x83\x85\x03\x12\x15aQ\x85W\x80\x81\xFD[\x825aQ\x90\x81a_ZV[\x91P` \x83\x015aQ\xA0\x81a_ZV[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15aQ\xBFW\x80\x81\xFD[\x835aQ\xCA\x81a_ZV[\x92P` \x84\x015aQ\xDA\x81a_ZV[\x91P`@\x84\x015aQ\xEA\x81a_oV[\x80\x91PP\x92P\x92P\x92V[`\0\x80`@\x83\x85\x03\x12\x15aR\x07W\x81\x82\xFD[\x825aR\x12\x81a_ZV[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aR-W\x81\x82\xFD[aR9\x85\x82\x86\x01aM\xC1V[\x91PP\x92P\x92\x90PV[`\0` \x80\x83\x85\x03\x12\x15aRUW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aRkW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aR{W\x82\x83\xFD[\x805aR\x89aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`\x80\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aR\xA7W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aS\x10W\x80\x82\x8B\x03\x12\x15aR\xC1W\x87\x88\xFD[aR\xCA\x81a^\xDDV[aR\xD4\x8B\x84aP)V[\x81R\x87\x83\x015\x88\x82\x01R`@aR\xEC\x8C\x82\x86\x01aM\xB6V[\x90\x82\x01R``\x83\x81\x015\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aR\xABV[P\x90\x98\x97PPPPPPPPV[`\0` \x80\x83\x85\x03\x12\x15aS0W\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aSFW\x82\x83\xFD[\x83\x01`\x1F\x81\x01\x85\x13aSVW\x82\x83\xFD[\x805aSdaM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01`\xA0\x80\x85\x02\x86\x01\x87\x01\x8A\x10\x15aS\x82W\x87\x88\xFD[\x87\x95P[\x84\x86\x10\x15aS\x10W\x80\x82\x8B\x03\x12\x15aS\x9CW\x87\x88\xFD[aS\xA5\x81a^\xDDV[aS\xAF\x8B\x84aPCV[\x81RaS\xBD\x8B\x89\x85\x01aM\xB6V[\x81\x89\x01R`@\x83\x81\x015\x90\x82\x01R``aS\xD9\x8C\x82\x86\x01aM\xB6V[\x90\x82\x01R`\x80aS\xEB\x8C\x85\x83\x01aM\xB6V[\x90\x82\x01R\x84R`\x01\x95\x90\x95\x01\x94\x92\x86\x01\x92\x90\x81\x01\x90aS\x86V[`\0\x80`@\x83\x85\x03\x12\x15aT\x17W\x81\x82\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aT.W\x83\x84\xFD[aT:\x86\x83\x87\x01aOWV[\x93P` \x85\x01Q\x91P\x80\x82\x11\x15aTOW\x82\x83\xFD[PaR9\x85\x82\x86\x01aOWV[`\0` \x82\x84\x03\x12\x15aTmW\x80\x81\xFD[\x815a\x16\xF2\x81a_oV[`\0` \x82\x84\x03\x12\x15aT\x89W\x80\x81\xFD[\x81Qa\x16\xF2\x81a_oV[`\0` \x82\x84\x03\x12\x15aT\xA5W\x80\x81\xFD[P5\x91\x90PV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15aT\xC1W\x81\x82\xFD[\x845\x93P` \x85\x015aT\xD3\x81a_ZV[\x92P`@\x85\x015aT\xE3\x81a_ZV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aT\xFEW\x81\x82\xFD[aU\n\x87\x82\x88\x01aPRV[\x91PP\x92\x95\x91\x94P\x92PV[`\0\x80`@\x83\x85\x03\x12\x15aU(W\x81\x82\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aR-W\x81\x82\xFD[`\0\x80`\0``\x84\x86\x03\x12\x15aUYW\x80\x81\xFD[\x835\x92P` \x80\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aUxW\x83\x84\xFD[aU\x84\x88\x83\x89\x01aM\xC1V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aU\x99W\x83\x84\xFD[P\x85\x01`\x1F\x81\x01\x87\x13aU\xAAW\x82\x83\xFD[\x805aU\xB8aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x8B\x10\x15aU\xD4W\x86\x87\xFD[\x86\x94P[\x83\x85\x10\x15aU\xFFW\x805aU\xEB\x81a_ZV[\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01aU\xD8V[P\x80\x95PPPPPP\x92P\x92P\x92V[`\0\x80`@\x83\x85\x03\x12\x15aV!W\x81\x82\xFD[\x825\x91P` \x83\x015aQ\xA0\x81a_ZV[`\0` \x82\x84\x03\x12\x15aVDW\x80\x81\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x16\xF2W\x81\x82\xFD[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15aVpW\x81\x82\xFD[\x845aV{\x81a_ZV[\x93P` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aV\x97W\x83\x84\xFD[aV\xA3\x88\x83\x89\x01aM\xC1V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aV\xB8W\x83\x84\xFD[aV\xC4\x88\x83\x89\x01aN\xF9V[\x93P``\x87\x015\x91P\x80\x82\x11\x15aV\xD9W\x82\x83\xFD[PaU\n\x87\x82\x88\x01aO\xC0V[`\0` \x82\x84\x03\x12\x15aV\xF7W\x80\x81\xFD[\x815a\x16\xF2\x81a_}V[`\0\x80`\0\x80`\xE0\x85\x87\x03\x12\x15aW\x17W\x81\x82\xFD[aW!\x86\x86aP4V[\x93P` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aW=W\x83\x84\xFD[aWI\x88\x83\x89\x01aN8V[\x94P`@\x87\x015\x91P\x80\x82\x11\x15aW^W\x83\x84\xFD[PaWk\x87\x82\x88\x01aM\xC1V[\x92PPaW{\x86``\x87\x01aP\xF9V[\x90P\x92\x95\x91\x94P\x92PV[`\0\x80`\0\x80`\0\x80a\x01 \x87\x89\x03\x12\x15aW\x9FW\x83\x84\xFD[aW\xA9\x88\x88aP4V[\x95P` \x80\x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aW\xC6W\x86\x87\xFD[aW\xD2\x8B\x83\x8C\x01aN8V[\x97P`@\x8A\x015\x91P\x80\x82\x11\x15aW\xE7W\x86\x87\xFD[aW\xF3\x8B\x83\x8C\x01aM\xC1V[\x96PaX\x02\x8B``\x8C\x01aP\xF9V[\x95P`\xE0\x8A\x015\x91P\x80\x82\x11\x15aX\x17W\x84\x85\xFD[P\x88\x01`\x1F\x81\x01\x8A\x13aX(W\x83\x84\xFD[\x805aX6aM\xDF\x82a_\x04V[\x81\x81R\x83\x81\x01\x90\x83\x85\x01\x85\x84\x02\x85\x01\x86\x01\x8E\x10\x15aXRW\x87\x88\xFD[\x87\x94P[\x83\x85\x10\x15aXtW\x805\x83R`\x01\x94\x90\x94\x01\x93\x91\x85\x01\x91\x85\x01aXVV[P\x80\x96PPPPPPa\x01\0\x87\x015\x90P\x92\x95P\x92\x95P\x92\x95V[`\0\x80`\0\x80`\xE0\x85\x87\x03\x12\x15aX\xA4W\x81\x82\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15aX\xBBW\x83\x84\xFD[\x90\x86\x01\x90`\xC0\x82\x89\x03\x12\x15aX\xCEW\x83\x84\xFD[aX\xD8`\xC0a^\xDDV[\x825\x81RaX\xE9\x89` \x85\x01aP4V[` \x82\x01R`@\x83\x015aX\xFC\x81a_ZV[`@\x82\x01RaY\x0E\x89``\x85\x01aM\xB6V[``\x82\x01R`\x80\x83\x015`\x80\x82\x01R`\xA0\x83\x015\x82\x81\x11\x15aY.W\x85\x86\xFD[aY:\x8A\x82\x86\x01aO\xC0V[`\xA0\x83\x01RP\x80\x96PPPPaYS\x86` \x87\x01aP\xF9V[\x93\x96\x93\x95PPPP`\xA0\x82\x015\x91`\xC0\x015\x90V[`\0` \x82\x84\x03\x12\x15aYyW\x80\x81\xFD[PQ\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x16\x90RV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aY\xC5W\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aY\xA0V[P\x94\x95\x94PPPPPV[`\0\x81Q\x80\x84R` \x80\x85\x01\x94P\x80\x84\x01\x83[\x83\x81\x10\x15aY\xC5W\x81Q\x87R\x95\x82\x01\x95\x90\x82\x01\x90`\x01\x01aY\xE3V[`\0\x81Q\x80\x84RaZ\x17\x81` \x86\x01` \x86\x01a_$V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\0a\x01 \x82Q`\x02\x81\x10aZ<W\xFE[\x80\x85RP` \x83\x01QaZR` \x86\x01\x82aY\x80V[P`@\x83\x01QaZe`@\x86\x01\x82aY\x80V[P``\x83\x01Q``\x85\x01R`\x80\x83\x01Q`\x80\x85\x01R`\xA0\x83\x01Q`\xA0\x85\x01R`\xC0\x83\x01QaZ\x96`\xC0\x86\x01\x82aY\x80V[P`\xE0\x83\x01QaZ\xA9`\xE0\x86\x01\x82aY\x80V[Pa\x01\0\x80\x84\x01Q\x82\x82\x87\x01Ra\x12\xA6\x83\x87\x01\x82aY\xFFV[\x91\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`$\x01\x90V[`\0\x82\x84\x837\x91\x01\x90\x81R\x91\x90PV[`\0\x82QaZ\xFC\x81\x84` \x87\x01a_$V[\x91\x90\x91\x01\x92\x91PPV[k\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19``\x93\x84\x1B\x81\x16\x82R\x91\x90\x92\x1B\x16`\x14\x82\x01R`(\x01\x90V[\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R\x91\x90\x92\x16` \x82\x01R`@\x81\x01\x91\x90\x91R``\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x83\x16\x81R`@\x81\x01a[\xB4\x83a_PV[\x82` \x83\x01R\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[`\0` \x82Ra\x16\xF2` \x83\x01\x84aY\x8DV[`\0`@\x82Ra\\\0`@\x83\x01\x85aY\x8DV[\x82\x81\x03` \x84\x81\x01\x91\x90\x91R\x84Q\x80\x83R\x85\x82\x01\x92\x82\x01\x90\x84[\x81\x81\x10\x15a\\?W\x84Q`\x01`\x01`\xA0\x1B\x03\x16\x83R\x93\x83\x01\x93\x91\x83\x01\x91`\x01\x01a\\\x1AV[P\x90\x97\x96PPPPPPPV[`\0``\x82Ra\\_``\x83\x01\x86aY\x8DV[\x82\x81\x03` \x84\x01Ra\\q\x81\x86aY\xD0V[\x90P\x82\x81\x03`@\x84\x01Ra\x12\xA6\x81\x85aY\xD0V[`\0`\x80\x82Ra\\\x98`\x80\x83\x01\x87aY\x8DV[\x82\x81\x03` \x84\x01Ra\\\xAA\x81\x87aY\xD0V[\x90P\x82\x81\x03`@\x84\x01Ra\\\xBE\x81\x86aY\xD0V[\x90P\x82\x81\x03``\x84\x01RaL\x08\x81\x85aY\xFFV[`\0``\x82Ra\\\xE5``\x83\x01\x86aY\x8DV[\x82\x81\x03` \x84\x01Ra\\\xF7\x81\x86aY\xD0V[\x91PP\x82`@\x83\x01R\x94\x93PPPPV[`\0` \x82Ra\x16\xF2` \x83\x01\x84aY\xD0V[\x90\x15\x15\x81R` \x01\x90V[\x92\x15\x15\x83R` \x83\x01\x91\x90\x91R`@\x82\x01R``\x01\x90V[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[`\0\x88\x82R`\x01`\x01`\xA0\x1B\x03\x80\x89\x16` \x84\x01R\x80\x88\x16`@\x84\x01RP`\xE0``\x83\x01Ra]\x98`\xE0\x83\x01\x87aY\xD0V[\x85`\x80\x84\x01R\x84`\xA0\x84\x01R\x82\x81\x03`\xC0\x84\x01Ra]\xB6\x81\x85aY\xFFV[\x9A\x99PPPPPPPPPPV[\x94\x85R` \x85\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16`@\x84\x01R``\x83\x01R`\x80\x82\x01R`\xA0\x01\x90V[\x94\x85R` \x85\x01\x93\x90\x93R`@\x84\x01\x91\x90\x91R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01\x90V[\x93\x84R`\xFF\x92\x90\x92\x16` \x84\x01R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[` \x81\x01a^G\x83a_PV[\x91\x90R\x90V[\x91\x82R` \x82\x01R`@\x01\x90V[`\0`\x80\x82Ra^n`\x80\x83\x01\x87aZ+V[\x82\x81\x03` \x84\x01Ra^\x80\x81\x87aY\xD0V[`@\x84\x01\x95\x90\x95RPP``\x01R\x92\x91PPV[`\0``\x82Ra^\xA7``\x83\x01\x86aZ+V[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[\x93\x84R` \x84\x01\x92\x90\x92R`@\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16``\x82\x01R`\x80\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a^\xFCW`\0\x80\xFD[`@R\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a_\x1AW\x80\x81\xFD[P` \x90\x81\x02\x01\x90V[`\0[\x83\x81\x10\x15a_?W\x81\x81\x01Q\x83\x82\x01R` \x01a_'V[\x83\x81\x11\x15a\x0E\0WPP`\0\x91\x01RV[`\x03\x81\x10a\x05~W\xFE[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05~W`\0\x80\xFD[\x80\x15\x15\x81\x14a\x05~W`\0\x80\xFD[`\x03\x81\x10a\x05~W`\0\x80\xFD\xFE\xA2dipfsX\"\x12  \x1EO\x92n9\x0F\xED\x8D\xD51\x8CX\x84j\xF75\xC2\xBE\xBCa\xB8\x06\x93\xAE\x93j_\xE7m\xCF\x14dsolcC\0\x07\x01\x003`\xC0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x0B\xE68\x03\x80a\x0B\xE6\x839\x81\x01`@\x81\x90Ra\0/\x91a\0MV[0`\x80R`\x01`\0U``\x1B`\x01`\x01``\x1B\x03\x19\x16`\xA0Ra\0{V[`\0` \x82\x84\x03\x12\x15a\0^W\x80\x81\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0tW\x81\x82\xFD[\x93\x92PPPV[`\x80Q`\xA0Q``\x1Ca\x0B@a\0\xA6`\09\x80a\x04\x13R\x80a\x05IRP\x80a\x02\xA7RPa\x0B@`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xA3W`\x005`\xE0\x1C\x80c\x85\x1C\x1B\xB3\x11a\0vW\x80c\xD8w\x84\\\x11a\0[W\x80c\xD8w\x84\\\x14a\x01)W\x80c\xE4*\xBF5\x14a\x011W\x80c\xFB\xFAw\xCF\x14a\x01QWa\0\xA3V[\x80c\x85\x1C\x1B\xB3\x14a\x01\x01W\x80c\xAA\xAB\xAD\xC5\x14a\x01\x14Wa\0\xA3V[\x80c8\xE9\x92.\x14a\0\xA8W\x80cU\xC6v(\x14a\0\xBDW\x80ckk\x9Fi\x14a\0\xDBW\x80cm\xAE\xFA\xB6\x14a\0\xEEW[`\0\x80\xFD[a\0\xBBa\0\xB66`\x04a\t\x9CV[a\x01YV[\0[a\0\xC5a\x01\xB8V[`@Qa\0\xD2\x91\x90a\n\xA6V[`@Q\x80\x91\x03\x90\xF3[a\0\xBBa\0\xE96`\x04a\t\x9CV[a\x01\xBEV[a\0\xBBa\0\xFC6`\x04a\x07\xD1V[a\x02\x11V[a\0\xC5a\x01\x0F6`\x04a\t$V[a\x02\xA3V[a\x01\x1Ca\x02\xF5V[`@Qa\0\xD2\x91\x90a\n5V[a\0\xC5a\x03\x04V[a\x01Da\x01?6`\x04a\x08RV[a\x03\nV[`@Qa\0\xD2\x91\x90a\nbV[a\x01\x1Ca\x04\x11V[a\x01aa\x045V[a\x01xg\x06\xF0[Y\xD3\xB2\0\0\x82\x11\x15a\x02Xa\x04~V[`\x01\x81\x90U`@Q\x7F\xA9\xBA?\xFE\x0Bl6k\x81#,\xAA\xB3\x86\x05\xA0i\x9A\xD59\x8Dl\xCEv\xF9\x1E\xE8\t\xE3\"\xDA\xFC\x90a\x01\xAD\x90\x83\x90a\n\xA6V[`@Q\x80\x91\x03\x90\xA1PV[`\x01T\x90V[a\x01\xC6a\x045V[a\x01\xDCf#\x86\xF2o\xC1\0\0\x82\x11\x15a\x02Ya\x04~V[`\x02\x81\x90U`@Q\x7FZ\x0Bs\x86#~\x7F\x07\xFAt\x1E\xFCd\xE5\x9C\x93\x87\xD2\xCC\xCA\xFE\xC7`\xEF\xEDMS8\x7F \xE1\x9A\x90a\x01\xAD\x90\x83\x90a\n\xA6V[a\x02\x19a\x04\x90V[a\x02!a\x045V[a\x02+\x84\x83a\x04\xA9V[`\0[\x84\x81\x10\x15a\x02\x93W`\0\x86\x86\x83\x81\x81\x10a\x02DW\xFE[\x90P` \x02\x01` \x81\x01\x90a\x02Y\x91\x90a\t\x80V[\x90P`\0\x85\x85\x84\x81\x81\x10a\x02iW\xFE[` \x02\x91\x90\x91\x015\x91Pa\x02\x89\x90P`\x01`\x01`\xA0\x1B\x03\x83\x16\x85\x83a\x04\xB6V[PP`\x01\x01a\x02.V[Pa\x02\x9Ca\x05>V[PPPPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82`@Q` \x01a\x02\xD8\x92\x91\x90a\t\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[`\0a\x02\xFFa\x05EV[\x90P\x90V[`\x02T\x90V[``\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a\x03$W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x03NW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P`\0[\x82Q\x81\x10\x15a\x04\x0BW\x82\x81\x81Q\x81\x10a\x03iW\xFE[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16cp\xA0\x8210`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\x9C\x91\x90a\n5V[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x03\xB4W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x03\xC8W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xEC\x91\x90a\t\xB4V[\x82\x82\x81Q\x81\x10a\x03\xF8W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x03TV[P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0a\x04d`\x005\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a\x02\xA3V[\x90Pa\x04{a\x04s\x823a\x05\xD8V[a\x01\x91a\x04~V[PV[\x81a\x04\x8CWa\x04\x8C\x81a\x06jV[PPV[a\x04\xA2`\x02`\0T\x14\x15a\x01\x90a\x04~V[`\x02`\0UV[a\x04\x8C\x81\x83\x14`ga\x04~V[a\x059\x83c\xA9\x05\x9C\xBB`\xE0\x1B\x84\x84`@Q`$\x01a\x04\xD5\x92\x91\x90a\nIV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x93\x16\x92\x90\x92\x17\x90\x91Ra\x06\xD7V[PPPV[`\x01`\0UV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xAA\xAB\xAD\xC5`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x05\xA0W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x05\xB4W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xFF\x91\x90a\tdV[`\0a\x05\xE2a\x05EV[`\x01`\x01`\xA0\x1B\x03\x16c\x9B\xE2\xA8\x84\x84\x840`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x06\x11\x93\x92\x91\x90a\n\xAFV[` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x06)W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x06=W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06a\x91\x90a\x08\xFDV[\x90P[\x92\x91PPV[\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x90\x81R` `\x04R`\x07`$RfBAL#\0\x000`\n\x80\x84\x04\x81\x81\x06`0\x90\x81\x01`\x08\x1B\x95\x83\x90\x06\x95\x90\x95\x01\x90\x82\x90\x04\x91\x82\x06\x90\x94\x01`\x10\x1B\x93\x90\x93\x01\x01`\xC8\x1B`DR`d\x90\xFD[`\0``\x83`\x01`\x01`\xA0\x1B\x03\x16\x83`@Qa\x06\xF3\x91\x90a\t\xFCV[`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a\x070W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x075V[``\x91P[P\x91P\x91P`\0\x82\x14\x15a\x07MW=`\0\x80>=`\0\xFD[a\x07w\x81Q`\0\x14\x80a\x07oWP\x81\x80` \x01\x90Q\x81\x01\x90a\x07o\x91\x90a\x08\xFDV[a\x01\xA2a\x04~V[PPPPV[`\0\x80\x83`\x1F\x84\x01\x12a\x07\x8EW\x81\x82\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x07\xA5W\x81\x82\xFD[` \x83\x01\x91P\x83` \x80\x83\x02\x85\x01\x01\x11\x15a\x07\xBFW`\0\x80\xFD[\x92P\x92\x90PV[\x805a\x06d\x81a\n\xF5V[`\0\x80`\0\x80`\0``\x86\x88\x03\x12\x15a\x07\xE8W\x80\x81\xFD[\x855g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x07\xFFW\x82\x83\xFD[a\x08\x0B\x89\x83\x8A\x01a\x07}V[\x90\x97P\x95P` \x88\x015\x91P\x80\x82\x11\x15a\x08#W\x82\x83\xFD[Pa\x080\x88\x82\x89\x01a\x07}V[\x90\x94P\x92PP`@\x86\x015a\x08D\x81a\n\xF5V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[`\0` \x80\x83\x85\x03\x12\x15a\x08dW\x81\x82\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x08{W\x83\x84\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x08\x8EW\x83\x84\xFD[\x815\x81\x81\x11\x15a\x08\x9CW\x84\x85\xFD[\x83\x81\x02\x91Pa\x08\xAC\x84\x83\x01a\n\xCEV[\x81\x81R\x84\x81\x01\x90\x84\x86\x01\x84\x86\x01\x87\x01\x8A\x10\x15a\x08\xC6W\x87\x88\xFD[\x87\x95P[\x83\x86\x10\x15a\x08\xF0Wa\x08\xDC\x8A\x82a\x07\xC6V[\x83R`\x01\x95\x90\x95\x01\x94\x91\x86\x01\x91\x86\x01a\x08\xCAV[P\x98\x97PPPPPPPPV[`\0` \x82\x84\x03\x12\x15a\t\x0EW\x80\x81\xFD[\x81Q\x80\x15\x15\x81\x14a\t\x1DW\x81\x82\xFD[\x93\x92PPPV[`\0` \x82\x84\x03\x12\x15a\t5W\x80\x81\xFD[\x815\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\t\x1DW\x81\x82\xFD[`\0` \x82\x84\x03\x12\x15a\tuW\x80\x81\xFD[\x81Qa\t\x1D\x81a\n\xF5V[`\0` \x82\x84\x03\x12\x15a\t\x91W\x80\x81\xFD[\x815a\t\x1D\x81a\n\xF5V[`\0` \x82\x84\x03\x12\x15a\t\xADW\x80\x81\xFD[P5\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\t\xC5W\x80\x81\xFD[PQ\x91\x90PV[\x91\x82R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16` \x82\x01R`$\x01\x90V[`\0\x82Q\x81[\x81\x81\x10\x15a\n\x1CW` \x81\x86\x01\x81\x01Q\x85\x83\x01R\x01a\n\x02V[\x81\x81\x11\x15a\n*W\x82\x82\x85\x01R[P\x91\x90\x91\x01\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x81R` \x01\x90V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R` \x82\x01R`@\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R`\0\x91\x90\x84\x82\x01\x90`@\x85\x01\x90\x84[\x81\x81\x10\x15a\n\x9AW\x83Q\x83R\x92\x84\x01\x92\x91\x84\x01\x91`\x01\x01a\n~V[P\x90\x96\x95PPPPPPV[\x90\x81R` \x01\x90V[\x92\x83R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16` \x84\x01R\x16`@\x82\x01R``\x01\x90V[`@Q\x81\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n\xEDW`\0\x80\xFD[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x04{W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xBEr\xBD\xF8\xE7\xA3\xC3\x86\x06\xC5\xF9T\xFB\xE2\xD7w\x984z\xAA\x1C\xFBv\xFEw\xEC/l$]$\xBCdsolcC\0\x07\x01\x003",
+    );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `flashLoan(address,address[],uint256[],bytes)` and selector `0x5c38449e`.
+    /**Event with signature `AuthorizerChanged(address)` and selector `0x94b979b6831a51293e2641426f97747feed46f17779fed9cd18d1ecefcfe92ef`.
     ```solidity
-    function flashLoan(address recipient, address[] memory tokens, uint256[] memory amounts, bytes memory userData) external;
+    event AuthorizerChanged(address indexed newAuthorizer);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct flashLoanCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct AuthorizerChanged {
         #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
+        pub newAuthorizer: alloy_sol_types::private::Address,
     }
-    ///Container type for the return parameters of the
-    /// [`flashLoan(address,address[],uint256[],bytes)`](flashLoanCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct flashLoanReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6255,166 +2538,113 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<flashLoanCall> for UnderlyingRustTuple<'_> {
-                fn from(value: flashLoanCall) -> Self {
-                    (value.recipient, value.tokens, value.amounts, value.userData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        tokens: tuple.1,
-                        amounts: tuple.2,
-                        userData: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<flashLoanReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: flashLoanReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl flashLoanReturn {
-            fn _tokenize(&self) -> <flashLoanCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for flashLoanCall {
-            type Parameters<'a> = (
+        impl alloy_sol_types::SolEvent for AuthorizerChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Bytes,
             );
-            type Return = flashLoanReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 56u8, 68u8, 158u8];
-            const SIGNATURE: &'static str = "flashLoan(address,address[],uint256[],bytes)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AuthorizerChanged(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    148u8, 185u8, 121u8, 182u8, 131u8, 26u8, 81u8, 41u8, 62u8, 38u8, 65u8, 66u8,
+                    111u8, 151u8, 116u8, 127u8, 238u8, 212u8, 111u8, 23u8, 119u8, 159u8, 237u8,
+                    156u8, 209u8, 141u8, 30u8, 206u8, 252u8, 254u8, 146u8, 239u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    newAuthorizer: topics.1,
+                }
+            }
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amounts),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                flashLoanReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.newAuthorizer.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.newAuthorizer,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AuthorizerChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&AuthorizerChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &AuthorizerChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Event with signature `ExternalBalanceTransfer(address,address,address,uint256)` and selector `0x540a1a3f28340caec336c81d8d7b3df139ee5cdc1839a4f283d7ebb7eaae2d5c`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    event ExternalBalanceTransfer(address indexed token, address indexed sender, address recipient, uint256 amount);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getActionIdCall {
+    pub struct ExternalBalanceTransfer {
         #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdReturn {
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -6424,140 +2654,135 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ExternalBalanceTransfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "ExternalBalanceTransfer(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    84u8, 10u8, 26u8, 63u8, 40u8, 52u8, 12u8, 174u8, 195u8, 54u8, 200u8, 29u8,
+                    141u8, 123u8, 61u8, 241u8, 57u8, 238u8, 92u8, 220u8, 24u8, 57u8, 164u8, 242u8,
+                    131u8, 215u8, 235u8, 183u8, 234u8, 174u8, 45u8, 92u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    token: topics.1,
+                    sender: topics.2,
+                    recipient: data.0,
+                    amount: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
+                    Self::SIGNATURE_HASH.into(),
+                    self.token.clone(),
+                    self.sender.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExternalBalanceTransfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExternalBalanceTransfer> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
+            fn from(this: &ExternalBalanceTransfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
+    /**Event with signature `FlashLoan(address,address,uint256,uint256)` and selector `0x0d7d75e01ab95780d3cd1c8ec0dd6c2ce19e3a20427eec8bf53283b6fb8e95f0`.
     ```solidity
-    function getAuthorizer() external view returns (address);
+    event FlashLoan(address indexed recipient, address indexed token, uint256 amount, uint256 feeAmount);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub struct FlashLoan {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -6567,132 +2792,132 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for FlashLoan {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "FlashLoan(address,address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    13u8, 125u8, 117u8, 224u8, 26u8, 185u8, 87u8, 128u8, 211u8, 205u8, 28u8, 142u8,
+                    192u8, 221u8, 108u8, 44u8, 225u8, 158u8, 58u8, 32u8, 66u8, 126u8, 236u8, 139u8,
+                    245u8, 50u8, 131u8, 182u8, 251u8, 142u8, 149u8, 240u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    recipient: topics.1,
+                    token: topics.2,
+                    amount: data.0,
+                    feeAmount: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeAmount,
+                    ),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.recipient.clone(),
+                    self.token.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.recipient,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for FlashLoan {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&FlashLoan> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &FlashLoan) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getDomainSeparator()` and selector `0xed24911d`.
+    /**Event with signature `InternalBalanceChanged(address,address,int256)` and selector `0x18e1ea4139e68413d7d08aa752e71568e36b2c5bf940893314c2c5b01eaa0c42`.
     ```solidity
-    function getDomainSeparator() external view returns (bytes32);
+    event InternalBalanceChanged(address indexed user, address indexed token, int256 delta);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getDomainSeparatorCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getDomainSeparator()`](getDomainSeparatorCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getDomainSeparatorReturn {
+    pub struct InternalBalanceChanged {
+        #[allow(missing_docs)]
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub delta: alloy_sol_types::private::primitives::aliases::I256,
     }
     #[allow(
         non_camel_case_types,
@@ -6702,143 +2927,121 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getDomainSeparatorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getDomainSeparatorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getDomainSeparatorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getDomainSeparatorReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getDomainSeparatorReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getDomainSeparatorCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for InternalBalanceChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Int<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [237u8, 36u8, 145u8, 29u8];
-            const SIGNATURE: &'static str = "getDomainSeparator()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "InternalBalanceChanged(address,address,int256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    24u8, 225u8, 234u8, 65u8, 57u8, 230u8, 132u8, 19u8, 215u8, 208u8, 138u8, 167u8,
+                    82u8, 231u8, 21u8, 104u8, 227u8, 107u8, 44u8, 91u8, 249u8, 64u8, 137u8, 51u8,
+                    20u8, 194u8, 197u8, 176u8, 30u8, 170u8, 12u8, 66u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    user: topics.1,
+                    token: topics.2,
+                    delta: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.delta,
+                    ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getDomainSeparatorReturn = r.into();
-                        r._0
-                    },
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.user.clone(),
+                    self.token.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getDomainSeparatorReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.user,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for InternalBalanceChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&InternalBalanceChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &InternalBalanceChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getInternalBalance(address,address[])` and selector `0x0f5a6efa`.
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
     ```solidity
-    function getInternalBalance(address user, address[] memory tokens) external view returns (uint256[] memory balances);
+    event PausedStateChanged(bool paused);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getInternalBalanceCall {
-        #[allow(missing_docs)]
-        pub user: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getInternalBalance(address,address[])`](getInternalBalanceCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getInternalBalanceReturn {
+    pub struct PausedStateChanged {
         #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub paused: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -6848,161 +3051,258 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { paused: data.0 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getInternalBalanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getInternalBalanceCall) -> Self {
-                    (value.user, value.tokens)
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInternalBalanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        user: tuple.0,
-                        tokens: tuple.1,
-                    }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getInternalBalanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getInternalBalanceReturn) -> Self {
-                    (value.balances,)
-                }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInternalBalanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { balances: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PoolBalanceChanged(bytes32,address,address[],int256[],uint256[])` and selector `0xe5ce249087ce04f05a957192435400fd97868dba0e6a4b4c049abf8af80dae78`.
+    ```solidity
+    event PoolBalanceChanged(bytes32 indexed poolId, address indexed liquidityProvider, address[] tokens, int256[] deltas, uint256[] protocolFeeAmounts);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PoolBalanceChanged {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub liquidityProvider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub deltas:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+        #[allow(missing_docs)]
+        pub protocolFeeAmounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getInternalBalanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolEvent for PoolBalanceChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
                 alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [15u8, 90u8, 110u8, 250u8];
-            const SIGNATURE: &'static str = "getInternalBalance(address,address[])";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PoolBalanceChanged(bytes32,address,address[],int256[],uint256[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    229u8, 206u8, 36u8, 144u8, 135u8, 206u8, 4u8, 240u8, 90u8, 149u8, 113u8, 146u8,
+                    67u8, 84u8, 0u8, 253u8, 151u8, 134u8, 141u8, 186u8, 14u8, 106u8, 75u8, 76u8,
+                    4u8, 154u8, 191u8, 138u8, 248u8, 13u8, 174u8, 120u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    poolId: topics.1,
+                    liquidityProvider: topics.2,
+                    tokens: data.0,
+                    deltas: data.1,
+                    protocolFeeAmounts: data.2,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.user,
-                    ),
                     <alloy_sol_types::sol_data::Array<
                         alloy_sol_types::sol_data::Address,
                     > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Int<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deltas),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.protocolFeeAmounts),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.liquidityProvider.clone(),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getInternalBalanceReturn = r.into();
-                        r.balances
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.liquidityProvider,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolBalanceChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolBalanceChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getInternalBalanceReturn = r.into();
-                    r.balances
-                })
+            fn from(this: &PoolBalanceChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getNextNonce(address)` and selector `0x90193b7c`.
+    /**Event with signature `PoolBalanceManaged(bytes32,address,address,int256,int256)` and selector `0x6edcaf6241105b4c94c2efdbf3a6b12458eb3d07be3a0e81d24b13c44045fe7a`.
     ```solidity
-    function getNextNonce(address user) external view returns (uint256);
+    event PoolBalanceManaged(bytes32 indexed poolId, address indexed assetManager, address indexed token, int256 cashDelta, int256 managedDelta);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getNextNonceCall {
+    pub struct PoolBalanceManaged {
         #[allow(missing_docs)]
-        pub user: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getNextNonce(address)`](getNextNonceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNextNonceReturn {
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub assetManager: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub cashDelta: alloy_sol_types::private::primitives::aliases::I256,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub managedDelta: alloy_sol_types::private::primitives::aliases::I256,
     }
     #[allow(
         non_camel_case_types,
@@ -7012,144 +3312,139 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNextNonceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getNextNonceCall) -> Self {
-                    (value.user,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { user: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNextNonceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getNextNonceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNextNonceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PoolBalanceManaged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PoolBalanceManaged(bytes32,address,address,int256,int256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    110u8, 220u8, 175u8, 98u8, 65u8, 16u8, 91u8, 76u8, 148u8, 194u8, 239u8, 219u8,
+                    243u8, 166u8, 177u8, 36u8, 88u8, 235u8, 61u8, 7u8, 190u8, 58u8, 14u8, 129u8,
+                    210u8, 75u8, 19u8, 196u8, 64u8, 69u8, 254u8, 122u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    assetManager: topics.2,
+                    token: topics.3,
+                    cashDelta: data.0,
+                    managedDelta: data.1,
                 }
             }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getNextNonceCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [144u8, 25u8, 59u8, 124u8];
-            const SIGNATURE: &'static str = "getNextNonce(address)";
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.user,
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.cashDelta,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.managedDelta,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.assetManager.clone(),
+                    self.token.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getNextNonceReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.assetManager,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolBalanceManaged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolBalanceManaged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getNextNonceReturn = r.into();
-                    r._0
-                })
+            fn from(this: &PoolBalanceManaged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    /**Event with signature `PoolRegistered(bytes32,address,uint8)` and selector `0x3c13bc30b8e878c53fd2a36b679409c073afd75950be43d8858768e956fbc20e`.
     ```solidity
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, IVault.PoolSpecialization specialization);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPausedState()`](getPausedStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getPausedStateReturn {
+    pub struct PoolRegistered {
         #[allow(missing_docs)]
-        pub paused: bool,
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        pub poolAddress: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
+        pub specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
     }
     #[allow(
         non_camel_case_types,
@@ -7159,167 +3454,125 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateReturn) -> Self {
-                    (
-                        value.paused,
-                        value.pauseWindowEndTime,
-                        value.bufferPeriodEndTime,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paused: tuple.0,
-                        pauseWindowEndTime: tuple.1,
-                        bufferPeriodEndTime: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getPausedStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowEndTime,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodEndTime,
-                    ),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPausedStateCall {
-            type Parameters<'a> = ();
-            type Return = getPausedStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+        impl alloy_sol_types::SolEvent for PoolRegistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (IVault::PoolSpecialization,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
             );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
-            const SIGNATURE: &'static str = "getPausedState()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PoolRegistered(bytes32,address,uint8)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    60u8, 19u8, 188u8, 48u8, 184u8, 232u8, 120u8, 197u8, 63u8, 210u8, 163u8, 107u8,
+                    103u8, 148u8, 9u8, 192u8, 115u8, 175u8, 215u8, 89u8, 80u8, 190u8, 67u8, 216u8,
+                    133u8, 135u8, 104u8, 233u8, 86u8, 251u8, 194u8, 14u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    poolId: topics.1,
+                    poolAddress: topics.2,
+                    specialization: data.0,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(
+                        &self.specialization,
+                    ),
+                )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPausedStateReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.poolAddress.clone(),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.poolAddress,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PoolRegistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PoolRegistered> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &PoolRegistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPool(bytes32)` and selector `0xf6c00927`.
+    /**Event with signature `RelayerApprovalChanged(address,address,bool)` and selector `0x46961fdb4502b646d5095fba7600486a8ac05041d55cdf0f16ed677180b5cad8`.
     ```solidity
-    function getPool(bytes32 poolId) external view returns (address, IVault.PoolSpecialization);
+    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getPoolCall {
+    pub struct RelayerApprovalChanged {
         #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPool(bytes32)`](getPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolReturn {
+        pub relayer: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub sender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _1: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+        pub approved: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -7329,162 +3582,129 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolCall) -> Self {
-                    (value.poolId,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { poolId: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RelayerApprovalChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                IVault::PoolSpecialization,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolReturn) -> Self {
-                    (value._0, value._1)
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RelayerApprovalChanged(address,address,bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    70u8, 150u8, 31u8, 219u8, 69u8, 2u8, 182u8, 70u8, 213u8, 9u8, 95u8, 186u8,
+                    118u8, 0u8, 72u8, 106u8, 138u8, 192u8, 80u8, 65u8, 213u8, 92u8, 223u8, 15u8,
+                    22u8, 237u8, 103u8, 113u8, 128u8, 181u8, 202u8, 216u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    relayer: topics.1,
+                    sender: topics.2,
+                    approved: data.0,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-        }
-        impl getPoolReturn {
-            fn _tokenize(&self) -> <getPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.approved,
                     ),
-                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(&self._1),
                 )
             }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = getPoolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                IVault::PoolSpecialization,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [246u8, 192u8, 9u8, 39u8];
-            const SIGNATURE: &'static str = "getPool(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                    Self::SIGNATURE_HASH.into(),
+                    self.relayer.clone(),
+                    self.sender.clone(),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPoolReturn::_tokenize(ret)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.relayer,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RelayerApprovalChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-
+        }
+        #[automatically_derived]
+        impl From<&RelayerApprovalChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &RelayerApprovalChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolTokenInfo(bytes32,address)` and selector `0xb05f8e48`.
+    /**Event with signature `Swap(bytes32,address,address,uint256,uint256)` and selector `0x2170c741c41531aec20e7c107c24eecfdd15e69c9bb0a8dd37b1840b9e0b207b`.
     ```solidity
-    function getPoolTokenInfo(bytes32 poolId, address token) external view returns (uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager);
+    event Swap(bytes32 indexed poolId, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getPoolTokenInfoCall {
+    pub struct Swap {
         #[allow(missing_docs)]
         pub poolId: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolTokenInfo(bytes32,address)`](getPoolTokenInfoCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolTokenInfoReturn {
-        #[allow(missing_docs)]
-        pub cash: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenIn: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub managed: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenOut: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub assetManager: alloy_sol_types::private::Address,
+        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -7494,197 +3714,256 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolTokenInfoCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolTokenInfoCall) -> Self {
-                    (value.poolId, value.token)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokenInfoCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        token: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Swap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
             );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolTokenInfoReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolTokenInfoReturn) -> Self {
-                    (
-                        value.cash,
-                        value.managed,
-                        value.lastChangeBlock,
-                        value.assetManager,
-                    )
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Swap(bytes32,address,address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    33u8, 112u8, 199u8, 65u8, 196u8, 21u8, 49u8, 174u8, 194u8, 14u8, 124u8, 16u8,
+                    124u8, 36u8, 238u8, 207u8, 221u8, 21u8, 230u8, 156u8, 155u8, 176u8, 168u8,
+                    221u8, 55u8, 177u8, 132u8, 11u8, 158u8, 11u8, 32u8, 123u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    tokenIn: topics.2,
+                    tokenOut: topics.3,
+                    amountIn: data.0,
+                    amountOut: data.1,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokenInfoReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        cash: tuple.0,
-                        managed: tuple.1,
-                        lastChangeBlock: tuple.2,
-                        assetManager: tuple.3,
-                    }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-        }
-        impl getPoolTokenInfoReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPoolTokenInfoCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.cash,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.managed,
+                        &self.amountIn,
                     ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.lastChangeBlock,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.assetManager,
+                        &self.amountOut,
                     ),
                 )
             }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.poolId.clone(),
+                    self.tokenIn.clone(),
+                    self.tokenOut.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.tokenIn,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.tokenOut,
+                );
+                Ok(())
+            }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolTokenInfoCall {
-            type Parameters<'a> = (
+        impl alloy_sol_types::private::IntoLogData for Swap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Swap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Swap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TokensDeregistered(bytes32,address[])` and selector `0x7dcdc6d02ef40c7c1a7046a011b058bd7f988fa14e20a66344f9d4e60657d610`.
+    ```solidity
+    event TokensDeregistered(bytes32 indexed poolId, address[] tokens);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TokensDeregistered {
+        #[allow(missing_docs)]
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokensDeregistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = getPoolTokenInfoReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
             );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [176u8, 95u8, 142u8, 72u8];
-            const SIGNATURE: &'static str = "getPoolTokenInfo(bytes32,address)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokensDeregistered(bytes32,address[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    125u8, 205u8, 198u8, 208u8, 46u8, 244u8, 12u8, 124u8, 26u8, 112u8, 70u8, 160u8,
+                    17u8, 176u8, 88u8, 189u8, 127u8, 152u8, 143u8, 161u8, 78u8, 32u8, 166u8, 99u8,
+                    68u8, 249u8, 212u8, 230u8, 6u8, 87u8, 214u8, 16u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    poolId: topics.1,
+                    tokens: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPoolTokenInfoReturn::_tokenize(ret)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Address,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.tokens
+                ),)
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.poolId.clone())
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokensDeregistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokensDeregistered> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TokensDeregistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolTokens(bytes32)` and selector `0xf94d4668`.
+    /**Event with signature `TokensRegistered(bytes32,address[],address[])` and selector `0xf5847d3f2197b16cdcd2098ec95d0905cd1abdaf415f07bb7cef2bba8ac5dec4`.
     ```solidity
-    function getPoolTokens(bytes32 poolId) external view returns (address[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+    event TokensRegistered(bytes32 indexed poolId, address[] tokens, address[] assetManagers);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getPoolTokensCall {
+    pub struct TokensRegistered {
         #[allow(missing_docs)]
         pub poolId: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolTokens(bytes32)`](getPoolTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolTokensReturn {
         #[allow(missing_docs)]
         pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
         #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+        pub assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
     }
     #[allow(
         non_camel_case_types,
@@ -7694,207 +3973,138 @@ pub mod BalancerV2Vault {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolTokensCall) -> Self {
-                    (value.poolId,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { poolId: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TokensRegistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
             );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolTokensReturn) -> Self {
-                    (value.tokens, value.balances, value.lastChangeBlock)
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TokensRegistered(bytes32,address[],address[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    245u8, 132u8, 125u8, 63u8, 33u8, 151u8, 177u8, 108u8, 220u8, 210u8, 9u8, 142u8,
+                    201u8, 93u8, 9u8, 5u8, 205u8, 26u8, 189u8, 175u8, 65u8, 95u8, 7u8, 187u8,
+                    124u8, 239u8, 43u8, 186u8, 138u8, 197u8, 222u8, 196u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    poolId: topics.1,
+                    tokens: data.0,
+                    assetManagers: data.1,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        balances: tuple.1,
-                        lastChangeBlock: tuple.2,
-                    }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-        }
-        impl getPoolTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPoolTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Array<
                         alloy_sol_types::sol_data::Address,
                     > as alloy_sol_types::SolType>::tokenize(&self.tokens),
                     <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolTokensCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = getPoolTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [249u8, 77u8, 70u8, 104u8];
-            const SIGNATURE: &'static str = "getPoolTokens(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assetManagers),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPoolTokensReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.poolId.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.poolId);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TokensRegistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TokensRegistered> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &TokensRegistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeesCollector()` and selector `0xd2946c2b`.
+    /**Constructor`.
     ```solidity
-    function getProtocolFeesCollector() external view returns (address);
+    constructor(address authorizer, address weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getProtocolFeesCollectorCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeesCollector()`](getProtocolFeesCollectorCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeesCollectorReturn {
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub authorizer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub weth: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeesCollectorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeesCollectorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7906,30 +4116,39 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeesCollectorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeesCollectorReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.authorizer,
+                        value.weth,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeesCollectorReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        authorizer: tuple.0,
+                        weth: tuple.1,
+                        pauseWindowDuration: tuple.2,
+                        bufferPeriodDuration: tuple.3,
+                    }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeesCollectorCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [210u8, 148u8, 108u8, 43u8];
-            const SIGNATURE: &'static str = "getProtocolFeesCollector()";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -7939,58 +4158,39 @@ pub mod BalancerV2Vault {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeesCollectorReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.authorizer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.weth,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowDuration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodDuration,
+                    ),
                 )
-                .map(|r| {
-                    let r: getProtocolFeesCollectorReturn = r.into();
-                    r._0
-                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `hasApprovedRelayer(address,address)` and selector `0xfec90d72`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function hasApprovedRelayer(address user, address relayer) external view returns (bool);
+    function WETH() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct hasApprovedRelayerCall {
-        #[allow(missing_docs)]
-        pub user: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub relayer: alloy_sol_types::private::Address,
-    }
+    pub struct WETHCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hasApprovedRelayer(address,address)`](hasApprovedRelayerCall)
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct hasApprovedRelayerReturn {
+    pub struct WETHReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -8003,15 +4203,9 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8023,28 +4217,25 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<hasApprovedRelayerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hasApprovedRelayerCall) -> Self {
-                    (value.user, value.relayer)
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasApprovedRelayerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        user: tuple.0,
-                        relayer: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8056,32 +4247,29 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<hasApprovedRelayerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hasApprovedRelayerReturn) -> Self {
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasApprovedRelayerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for hasApprovedRelayerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = bool;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [254u8, 201u8, 13u8, 114u8];
-            const SIGNATURE: &'static str = "hasApprovedRelayer(address,address)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -8092,26 +4280,19 @@ pub mod BalancerV2Vault {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.user,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.relayer,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: hasApprovedRelayerReturn = r.into();
+                        let r: WETHReturn = r.into();
                         r._0
                     },
                 )
@@ -8123,35 +4304,47 @@ pub mod BalancerV2Vault {
                     data,
                 )
                 .map(|r| {
-                    let r: hasApprovedRelayerReturn = r.into();
+                    let r: WETHReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `joinPool(bytes32,address,address,(address[],uint256[],bytes,bool))` and selector `0xb95cac28`.
+    /**Function with signature `batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256)` and selector `0x945bcec9`.
     ```solidity
-    function joinPool(bytes32 poolId, address sender, address recipient, IVault.JoinPoolRequest memory request) external payable;
+    function batchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds, int256[] memory limits, uint256 deadline) external payable returns (int256[] memory assetDeltas);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct joinPoolCall {
+    pub struct batchSwapCall {
         #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
+        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
         #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
+        pub swaps: alloy_sol_types::private::Vec<
+            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
         #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
+        pub limits:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
         #[allow(missing_docs)]
-        pub request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`joinPool(bytes32,address,address,(address[],uint256[],bytes,
-    /// bool))`](joinPoolCall) function.
+    /// [`batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],
+    /// (address,bool,address,bool),int256[],uint256)`](batchSwapCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct joinPoolReturn {}
+    pub struct batchSwapReturn {
+        #[allow(missing_docs)]
+        pub assetDeltas:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8164,17 +4357,23 @@ pub mod BalancerV2Vault {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::JoinPoolRequest,
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
+                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
+                >,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -8187,20 +4386,29 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<joinPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: joinPoolCall) -> Self {
-                    (value.poolId, value.sender, value.recipient, value.request)
+            impl ::core::convert::From<batchSwapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: batchSwapCall) -> Self {
+                    (
+                        value.kind,
+                        value.swaps,
+                        value.assets,
+                        value.funds,
+                        value.limits,
+                        value.deadline,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for joinPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchSwapCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        request: tuple.3,
+                        kind: tuple.0,
+                        swaps: tuple.1,
+                        assets: tuple.2,
+                        funds: tuple.3,
+                        limits: tuple.4,
+                        deadline: tuple.5,
                     }
                 }
             }
@@ -8208,9 +4416,12 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8222,40 +4433,42 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<joinPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: joinPoolReturn) -> Self {
-                    ()
+            impl ::core::convert::From<batchSwapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: batchSwapReturn) -> Self {
+                    (value.assetDeltas,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for joinPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchSwapReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        assetDeltas: tuple.0,
+                    }
                 }
             }
         }
-        impl joinPoolReturn {
-            fn _tokenize(&self) -> <joinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for joinPoolCall {
+        impl alloy_sol_types::SolCall for batchSwapCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                IVault::JoinPoolRequest,
+                IVault::SwapKind,
+                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                IVault::FundManagement,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = joinPoolReturn;
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [185u8, 92u8, 172u8, 40u8];
-            const SIGNATURE: &'static str =
-                "joinPool(bytes32,address,address,(address[],uint256[],bytes,bool))";
+            const SELECTOR: [u8; 4] = [148u8, 91u8, 206u8, 201u8];
+            const SIGNATURE: &'static str = "batchSwap(uint8,(bytes32,uint256,uint256,uint256,\
+                                             bytes)[],address[],(address,bool,address,bool),\
+                                             int256[],uint256)";
 
             #[inline]
             fn new<'a>(
@@ -8267,30 +4480,40 @@ pub mod BalancerV2Vault {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <IVault::JoinPoolRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
+                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::BatchSwapStep,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
+                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
+                        &self.funds,
                     ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Int<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.limits),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                joinPoolReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Int<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: batchSwapReturn = r.into();
+                        r.assetDeltas
+                    },
+                )
             }
 
             #[inline]
@@ -8298,29 +4521,37 @@ pub mod BalancerV2Vault {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: batchSwapReturn = r.into();
+                    r.assetDeltas
+                })
             }
         }
     };
-    #[derive()]
-    /**Function with signature `managePoolBalance((uint8,bytes32,address,uint256)[])` and selector `0xe6c46092`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `flashLoan(address,address[],uint256[],bytes)` and selector `0x5c38449e`.
     ```solidity
-    function managePoolBalance(IVault.PoolBalanceOp[] memory ops) external;
+    function flashLoan(address recipient, address[] memory tokens, uint256[] memory amounts, bytes memory userData) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct managePoolBalanceCall {
+    pub struct flashLoanCall {
         #[allow(missing_docs)]
-        pub ops: alloy_sol_types::private::Vec<
-            <IVault::PoolBalanceOp as alloy_sol_types::SolType>::RustType,
-        >,
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub amounts:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub userData: alloy_sol_types::private::Bytes,
     }
     ///Container type for the return parameters of the
-    /// [`managePoolBalance((uint8,bytes32,address,
-    /// uint256)[])`](managePoolBalanceCall) function.
+    /// [`flashLoan(address,address[],uint256[],bytes)`](flashLoanCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct managePoolBalanceReturn {}
+    pub struct flashLoanReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8332,13 +4563,18 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<IVault::PoolBalanceOp>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IVault::PoolBalanceOp as alloy_sol_types::SolType>::RustType,
-                >,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -8351,16 +4587,21 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<managePoolBalanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: managePoolBalanceCall) -> Self {
-                    (value.ops,)
+            impl ::core::convert::From<flashLoanCall> for UnderlyingRustTuple<'_> {
+                fn from(value: flashLoanCall) -> Self {
+                    (value.recipient, value.tokens, value.amounts, value.userData)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managePoolBalanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { ops: tuple.0 }
+                    Self {
+                        recipient: tuple.0,
+                        tokens: tuple.1,
+                        amounts: tuple.2,
+                        userData: tuple.3,
+                    }
                 }
             }
         }
@@ -8381,36 +4622,39 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<managePoolBalanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: managePoolBalanceReturn) -> Self {
+            impl ::core::convert::From<flashLoanReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: flashLoanReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managePoolBalanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashLoanReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl managePoolBalanceReturn {
-            fn _tokenize(
-                &self,
-            ) -> <managePoolBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl flashLoanReturn {
+            fn _tokenize(&self) -> <flashLoanCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for managePoolBalanceCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Array<IVault::PoolBalanceOp>,);
-            type Return = managePoolBalanceReturn;
+        impl alloy_sol_types::SolCall for flashLoanCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = flashLoanReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [230u8, 196u8, 96u8, 146u8];
-            const SIGNATURE: &'static str = "managePoolBalance((uint8,bytes32,address,uint256)[])";
+            const SELECTOR: [u8; 4] = [92u8, 56u8, 68u8, 158u8];
+            const SIGNATURE: &'static str = "flashLoan(address,address[],uint256[],bytes)";
 
             #[inline]
             fn new<'a>(
@@ -8422,15 +4666,24 @@ pub mod BalancerV2Vault {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
                     <alloy_sol_types::sol_data::Array<
-                        IVault::PoolBalanceOp,
-                    > as alloy_sol_types::SolType>::tokenize(&self.ops),
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amounts),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.userData,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                managePoolBalanceReturn::_tokenize(ret)
+                flashLoanReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -8448,25 +4701,30 @@ pub mod BalancerV2Vault {
             }
         }
     };
-    #[derive()]
-    /**Function with signature `manageUserBalance((uint8,address,uint256,address,address)[])` and selector `0x0e8e3e84`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `getInternalBalance(address,address[])` and selector `0x0f5a6efa`.
     ```solidity
-    function manageUserBalance(IVault.UserBalanceOp[] memory ops) external payable;
+    function getInternalBalance(address user, address[] memory tokens) external view returns (uint256[] memory balances);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct manageUserBalanceCall {
+    pub struct getInternalBalanceCall {
         #[allow(missing_docs)]
-        pub ops: alloy_sol_types::private::Vec<
-            <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
-        >,
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`manageUserBalance((uint8,address,uint256,address,
-    /// address)[])`](manageUserBalanceCall) function.
+    /// [`getInternalBalance(address,address[])`](getInternalBalanceCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct manageUserBalanceReturn {}
+    pub struct getInternalBalanceReturn {
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8478,13 +4736,14 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<IVault::UserBalanceOp>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
-                >,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -8497,25 +4756,31 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<manageUserBalanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: manageUserBalanceCall) -> Self {
-                    (value.ops,)
+            impl ::core::convert::From<getInternalBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getInternalBalanceCall) -> Self {
+                    (value.user, value.tokens)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for manageUserBalanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInternalBalanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { ops: tuple.0 }
+                    Self {
+                        user: tuple.0,
+                        tokens: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8527,37 +4792,34 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<manageUserBalanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: manageUserBalanceReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getInternalBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getInternalBalanceReturn) -> Self {
+                    (value.balances,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for manageUserBalanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInternalBalanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { balances: tuple.0 }
                 }
             }
         }
-        impl manageUserBalanceReturn {
-            fn _tokenize(
-                &self,
-            ) -> <manageUserBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for manageUserBalanceCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Array<IVault::UserBalanceOp>,);
-            type Return = manageUserBalanceReturn;
+        impl alloy_sol_types::SolCall for getInternalBalanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+            );
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [14u8, 142u8, 62u8, 132u8];
-            const SIGNATURE: &'static str =
-                "manageUserBalance((uint8,address,uint256,address,address)[])";
+            const SELECTOR: [u8; 4] = [15u8, 90u8, 110u8, 250u8];
+            const SIGNATURE: &'static str = "getInternalBalance(address,address[])";
 
             #[inline]
             fn new<'a>(
@@ -8569,21 +4831,30 @@ pub mod BalancerV2Vault {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.user,
+                    ),
                     <alloy_sol_types::sol_data::Array<
-                        IVault::UserBalanceOp,
-                    > as alloy_sol_types::SolType>::tokenize(&self.ops),
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                manageUserBalanceReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getInternalBalanceReturn = r.into();
+                        r.balances
+                    },
+                )
             }
 
             #[inline]
@@ -8591,38 +4862,33 @@ pub mod BalancerV2Vault {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getInternalBalanceReturn = r.into();
+                    r.balances
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool))` and selector `0xf84d066e`.
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
     ```solidity
-    function queryBatchSwap(IVault.SwapKind kind, IVault.BatchSwapStep[] memory swaps, address[] memory assets, IVault.FundManagement memory funds) external view returns (int256[] memory);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryBatchSwapCall {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub swaps: alloy_sol_types::private::Vec<
-            <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-    }
+    pub struct getPausedStateCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryBatchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],
-    /// address[],(address,bool,address,bool))`](queryBatchSwapCall) function.
+    /// [`getPausedState()`](getPausedStateCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryBatchSwapReturn {
+    pub struct getPausedStateReturn {
+        #[allow(missing_docs)]
+        pub paused: bool,
+        #[allow(missing_docs)]
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -8635,21 +4901,9 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IVault::SwapKind,
-                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                IVault::FundManagement,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8661,32 +4915,32 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryBatchSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryBatchSwapCall) -> Self {
-                    (value.kind, value.swaps, value.assets, value.funds)
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        kind: tuple.0,
-                        swaps: tuple.1,
-                        assets: tuple.2,
-                        funds: tuple.3,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>,
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -8699,38 +4953,58 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryBatchSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryBatchSwapReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryBatchSwapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
                 }
             }
         }
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryBatchSwapCall {
-            type Parameters<'a> = (
-                IVault::SwapKind,
-                alloy_sol_types::sol_data::Array<IVault::BatchSwapStep>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                IVault::FundManagement,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I256>;
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [248u8, 77u8, 6u8, 110u8];
-            const SIGNATURE: &'static str = "queryBatchSwap(uint8,(bytes32,uint256,uint256,\
-                                             uint256,bytes)[],address[],(address,bool,address,\
-                                             bool))";
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
 
             #[inline]
             fn new<'a>(
@@ -8741,35 +5015,18 @@ pub mod BalancerV2Vault {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Array<
-                        IVault::BatchSwapStep,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swaps),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assets),
-                    <IVault::FundManagement as alloy_sol_types::SolType>::tokenize(
-                        &self.funds,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Int<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                getPausedStateReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: queryBatchSwapReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -8777,32 +5034,31 @@ pub mod BalancerV2Vault {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: queryBatchSwapReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `registerPool(uint8)` and selector `0x09b2760f`.
+    /**Function with signature `getPool(bytes32)` and selector `0xf6c00927`.
     ```solidity
-    function registerPool(IVault.PoolSpecialization specialization) external returns (bytes32);
+    function getPool(bytes32 poolId) external view returns (address, IVault.PoolSpecialization);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct registerPoolCall {
+    pub struct getPoolCall {
         #[allow(missing_docs)]
-        pub specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+        pub poolId: alloy_sol_types::private::FixedBytes<32>,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`registerPool(uint8)`](registerPoolCall) function.
+    /// [`getPool(bytes32)`](getPoolCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct registerPoolReturn {
+    pub struct getPoolReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _1: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
     }
     #[allow(
         non_camel_case_types,
@@ -8815,10 +5071,9 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IVault::PoolSpecialization,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8830,27 +5085,31 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<registerPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: registerPoolCall) -> Self {
-                    (value.specialization,)
+            impl ::core::convert::From<getPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolCall) -> Self {
+                    (value.poolId,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        specialization: tuple.0,
-                    }
+                    Self { poolId: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IVault::PoolSpecialization,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8862,29 +5121,45 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<registerPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: registerPoolReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<getPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolReturn) -> Self {
+                    (value._0, value._1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
                 }
             }
         }
+        impl getPoolReturn {
+            fn _tokenize(&self) -> <getPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(&self._1),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for registerPoolCall {
-            type Parameters<'a> = (IVault::PoolSpecialization,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for getPoolCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = getPoolReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                IVault::PoolSpecialization,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [9u8, 178u8, 118u8, 15u8];
-            const SIGNATURE: &'static str = "registerPool(uint8)";
+            const SELECTOR: [u8; 4] = [246u8, 192u8, 9u8, 39u8];
+            const SIGNATURE: &'static str = "getPool(bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -8896,29 +5171,21 @@ pub mod BalancerV2Vault {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IVault::PoolSpecialization as alloy_sol_types::SolType>::tokenize(
-                        &self.specialization,
-                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                getPoolReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: registerPoolReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -8926,34 +5193,35 @@ pub mod BalancerV2Vault {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: registerPoolReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `registerTokens(bytes32,address[],address[])` and selector `0x66a9c7d2`.
+    /**Function with signature `getPoolTokens(bytes32)` and selector `0xf94d4668`.
     ```solidity
-    function registerTokens(bytes32 poolId, address[] memory tokens, address[] memory assetManagers) external;
+    function getPoolTokens(bytes32 poolId) external view returns (address[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct registerTokensCall {
+    pub struct getPoolTokensCall {
         #[allow(missing_docs)]
         pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`registerTokens(bytes32,address[],address[])`](registerTokensCall)
-    /// function.
+    /// [`getPoolTokens(bytes32)`](getPoolTokensCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct registerTokensReturn {}
+    pub struct getPoolTokensReturn {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub balances:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8965,17 +5233,9 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -8987,29 +5247,33 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<registerTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: registerTokensCall) -> Self {
-                    (value.poolId, value.tokens, value.assetManagers)
+            impl ::core::convert::From<getPoolTokensCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolTokensCall) -> Self {
+                    (value.poolId,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokensCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        tokens: tuple.1,
-                        assetManagers: tuple.2,
-                    }
+                    Self { poolId: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9021,40 +5285,54 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<registerTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: registerTokensReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getPoolTokensReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolTokensReturn) -> Self {
+                    (value.tokens, value.balances, value.lastChangeBlock)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolTokensReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        tokens: tuple.0,
+                        balances: tuple.1,
+                        lastChangeBlock: tuple.2,
+                    }
                 }
             }
         }
-        impl registerTokensReturn {
+        impl getPoolTokensReturn {
             fn _tokenize(
                 &self,
-            ) -> <registerTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+            ) -> <getPoolTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
+                )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for registerTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+        impl alloy_sol_types::SolCall for getPoolTokensCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = getPoolTokensReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
                 alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = registerTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [102u8, 169u8, 199u8, 210u8];
-            const SIGNATURE: &'static str = "registerTokens(bytes32,address[],address[])";
+            const SELECTOR: [u8; 4] = [249u8, 77u8, 70u8, 104u8];
+            const SIGNATURE: &'static str = "getPoolTokens(bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -9069,18 +5347,12 @@ pub mod BalancerV2Vault {
                     <alloy_sol_types::sol_data::FixedBytes<
                         32,
                     > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.assetManagers),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                registerTokensReturn::_tokenize(ret)
+                getPoolTokensReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -9099,21 +5371,28 @@ pub mod BalancerV2Vault {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setAuthorizer(address)` and selector `0x058a628f`.
+    /**Function with signature `hasApprovedRelayer(address,address)` and selector `0xfec90d72`.
     ```solidity
-    function setAuthorizer(address newAuthorizer) external;
+    function hasApprovedRelayer(address user, address relayer) external view returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setAuthorizerCall {
+    pub struct hasApprovedRelayerCall {
         #[allow(missing_docs)]
-        pub newAuthorizer: alloy_sol_types::private::Address,
+        pub user: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub relayer: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setAuthorizer(address)`](setAuthorizerCall) function.
+    /// [`hasApprovedRelayer(address,address)`](hasApprovedRelayerCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setAuthorizerReturn {}
+    pub struct hasApprovedRelayerReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -9125,9 +5404,15 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9139,17 +5424,18 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setAuthorizerCall) -> Self {
-                    (value.newAuthorizer,)
+            impl ::core::convert::From<hasApprovedRelayerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hasApprovedRelayerCall) -> Self {
+                    (value.user, value.relayer)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAuthorizerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasApprovedRelayerCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        newAuthorizer: tuple.0,
+                        user: tuple.0,
+                        relayer: tuple.1,
                     }
                 }
             }
@@ -9157,9 +5443,9 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9171,36 +5457,32 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setAuthorizerReturn) -> Self {
-                    ()
+            impl ::core::convert::From<hasApprovedRelayerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hasApprovedRelayerReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAuthorizerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasApprovedRelayerReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setAuthorizerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setAuthorizerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setAuthorizerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setAuthorizerReturn;
+        impl alloy_sol_types::SolCall for hasApprovedRelayerCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [5u8, 138u8, 98u8, 143u8];
-            const SIGNATURE: &'static str = "setAuthorizer(address)";
+            const SELECTOR: [u8; 4] = [254u8, 201u8, 13u8, 114u8];
+            const SIGNATURE: &'static str = "hasApprovedRelayer(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -9213,20 +5495,27 @@ pub mod BalancerV2Vault {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newAuthorizer,
+                        &self.user,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.relayer,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setAuthorizerReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hasApprovedRelayerReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -9234,26 +5523,32 @@ pub mod BalancerV2Vault {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: hasApprovedRelayerReturn = r.into();
+                    r._0
+                })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    #[derive()]
+    /**Function with signature `manageUserBalance((uint8,address,uint256,address,address)[])` and selector `0x0e8e3e84`.
     ```solidity
-    function setPaused(bool paused) external;
+    function manageUserBalance(IVault.UserBalanceOp[] memory ops) external payable;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedCall {
+    pub struct manageUserBalanceCall {
         #[allow(missing_docs)]
-        pub paused: bool,
+        pub ops: alloy_sol_types::private::Vec<
+            <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
+        >,
     }
     ///Container type for the return parameters of the
-    /// [`setPaused(bool)`](setPausedCall) function.
+    /// [`manageUserBalance((uint8,address,uint256,address,
+    /// address)[])`](manageUserBalanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedReturn {}
+    pub struct manageUserBalanceReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -9265,9 +5560,14 @@ pub mod BalancerV2Vault {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<IVault::UserBalanceOp>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<
+                    <IVault::UserBalanceOp as alloy_sol_types::SolType>::RustType,
+                >,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9279,16 +5579,16 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedCall) -> Self {
-                    (value.paused,)
+            impl ::core::convert::From<manageUserBalanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: manageUserBalanceCall) -> Self {
+                    (value.ops,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for manageUserBalanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { paused: tuple.0 }
+                    Self { ops: tuple.0 }
                 }
             }
         }
@@ -9309,34 +5609,37 @@ pub mod BalancerV2Vault {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedReturn) -> Self {
+            impl ::core::convert::From<manageUserBalanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: manageUserBalanceReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for manageUserBalanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl setPausedReturn {
-            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl manageUserBalanceReturn {
+            fn _tokenize(
+                &self,
+            ) -> <manageUserBalanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setPausedCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Return = setPausedReturn;
+        impl alloy_sol_types::SolCall for manageUserBalanceCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Array<IVault::UserBalanceOp>,);
+            type Return = manageUserBalanceReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
-            const SIGNATURE: &'static str = "setPaused(bool)";
+            const SELECTOR: [u8; 4] = [14u8, 142u8, 62u8, 132u8];
+            const SIGNATURE: &'static str =
+                "manageUserBalance((uint8,address,uint256,address,address)[])";
 
             #[inline]
             fn new<'a>(
@@ -9348,15 +5651,15 @@ pub mod BalancerV2Vault {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        IVault::UserBalanceOp,
+                    > as alloy_sol_types::SolType>::tokenize(&self.ops),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setPausedReturn::_tokenize(ret)
+                manageUserBalanceReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -9728,50 +6031,20 @@ pub mod BalancerV2Vault {
         #[allow(missing_docs)]
         batchSwap(batchSwapCall),
         #[allow(missing_docs)]
-        deregisterTokens(deregisterTokensCall),
-        #[allow(missing_docs)]
-        exitPool(exitPoolCall),
-        #[allow(missing_docs)]
         flashLoan(flashLoanCall),
         #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getDomainSeparator(getDomainSeparatorCall),
-        #[allow(missing_docs)]
         getInternalBalance(getInternalBalanceCall),
         #[allow(missing_docs)]
-        getNextNonce(getNextNonceCall),
-        #[allow(missing_docs)]
         getPausedState(getPausedStateCall),
         #[allow(missing_docs)]
         getPool(getPoolCall),
         #[allow(missing_docs)]
-        getPoolTokenInfo(getPoolTokenInfoCall),
-        #[allow(missing_docs)]
         getPoolTokens(getPoolTokensCall),
         #[allow(missing_docs)]
-        getProtocolFeesCollector(getProtocolFeesCollectorCall),
-        #[allow(missing_docs)]
         hasApprovedRelayer(hasApprovedRelayerCall),
         #[allow(missing_docs)]
-        joinPool(joinPoolCall),
-        #[allow(missing_docs)]
-        managePoolBalance(managePoolBalanceCall),
-        #[allow(missing_docs)]
         manageUserBalance(manageUserBalanceCall),
         #[allow(missing_docs)]
-        queryBatchSwap(queryBatchSwapCall),
-        #[allow(missing_docs)]
-        registerPool(registerPoolCall),
-        #[allow(missing_docs)]
-        registerTokens(registerTokensCall),
-        #[allow(missing_docs)]
-        setAuthorizer(setAuthorizerCall),
-        #[allow(missing_docs)]
-        setPaused(setPausedCall),
-        #[allow(missing_docs)]
         setRelayerApproval(setRelayerApprovalCall),
         #[allow(missing_docs)]
         swap(swapCall),
@@ -9785,87 +6058,42 @@ pub mod BalancerV2Vault {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [5u8, 138u8, 98u8, 143u8],
-            [9u8, 178u8, 118u8, 15u8],
             [14u8, 142u8, 62u8, 132u8],
             [15u8, 90u8, 110u8, 250u8],
-            [22u8, 195u8, 139u8, 60u8],
             [28u8, 13u8, 224u8, 81u8],
             [82u8, 187u8, 190u8, 41u8],
             [92u8, 56u8, 68u8, 158u8],
-            [102u8, 169u8, 199u8, 210u8],
-            [125u8, 58u8, 235u8, 150u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [139u8, 219u8, 57u8, 19u8],
-            [144u8, 25u8, 59u8, 124u8],
             [148u8, 91u8, 206u8, 201u8],
-            [170u8, 171u8, 173u8, 197u8],
             [173u8, 92u8, 70u8, 72u8],
-            [176u8, 95u8, 142u8, 72u8],
-            [185u8, 92u8, 172u8, 40u8],
-            [210u8, 148u8, 108u8, 43u8],
-            [230u8, 196u8, 96u8, 146u8],
-            [237u8, 36u8, 145u8, 29u8],
             [246u8, 192u8, 9u8, 39u8],
-            [248u8, 77u8, 6u8, 110u8],
             [249u8, 77u8, 70u8, 104u8],
             [250u8, 110u8, 103u8, 29u8],
             [254u8, 201u8, 13u8, 114u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <setAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <registerPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <manageUserBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getInternalBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
             <flashLoanCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <registerTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <deregisterTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <exitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getNextNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <batchSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolTokenInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <joinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <managePoolBalanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getDomainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryBatchSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <setRelayerApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
             <hasApprovedRelayerCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(setAuthorizer),
-            ::core::stringify!(registerPool),
             ::core::stringify!(manageUserBalance),
             ::core::stringify!(getInternalBalance),
-            ::core::stringify!(setPaused),
             ::core::stringify!(getPausedState),
             ::core::stringify!(swap),
             ::core::stringify!(flashLoan),
-            ::core::stringify!(registerTokens),
-            ::core::stringify!(deregisterTokens),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(exitPool),
-            ::core::stringify!(getNextNonce),
             ::core::stringify!(batchSwap),
-            ::core::stringify!(getAuthorizer),
             ::core::stringify!(WETH),
-            ::core::stringify!(getPoolTokenInfo),
-            ::core::stringify!(joinPool),
-            ::core::stringify!(getProtocolFeesCollector),
-            ::core::stringify!(managePoolBalance),
-            ::core::stringify!(getDomainSeparator),
             ::core::stringify!(getPool),
-            ::core::stringify!(queryBatchSwap),
             ::core::stringify!(getPoolTokens),
             ::core::stringify!(setRelayerApproval),
             ::core::stringify!(hasApprovedRelayer),
@@ -9893,7 +6121,7 @@ pub mod BalancerV2Vault {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2VaultCalls {
-        const COUNT: usize = 26usize;
+        const COUNT: usize = 11usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2VaultCalls";
 
@@ -9902,50 +6130,21 @@ pub mod BalancerV2Vault {
             match self {
                 Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::batchSwap(_) => <batchSwapCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::deregisterTokens(_) => {
-                    <deregisterTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::exitPool(_) => <exitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::flashLoan(_) => <flashLoanCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getDomainSeparator(_) => {
-                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::getInternalBalance(_) => {
                     <getInternalBalanceCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getNextNonce(_) => <getNextNonceCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getPausedState(_) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::getPool(_) => <getPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getPoolTokenInfo(_) => {
-                    <getPoolTokenInfoCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::getPoolTokens(_) => <getPoolTokensCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getProtocolFeesCollector(_) => {
-                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::hasApprovedRelayer(_) => {
                     <hasApprovedRelayerCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::joinPool(_) => <joinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::managePoolBalance(_) => {
-                    <managePoolBalanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::manageUserBalance(_) => {
                     <manageUserBalanceCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::queryBatchSwap(_) => {
-                    <queryBatchSwapCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::registerPool(_) => <registerPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::registerTokens(_) => {
-                    <registerTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setAuthorizer(_) => <setAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::setRelayerApproval(_) => {
                     <setRelayerApprovalCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -9967,20 +6166,6 @@ pub mod BalancerV2Vault {
         #[allow(non_snake_case)]
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
             static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls>] = &[
-                {
-                    fn setAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <setAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::setAuthorizer)
-                    }
-                    setAuthorizer
-                },
-                {
-                    fn registerPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <registerPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::registerPool)
-                    }
-                    registerPool
-                },
                 {
                     fn manageUserBalance(
                         data: &[u8],
@@ -9999,13 +6184,6 @@ pub mod BalancerV2Vault {
                     }
                     getInternalBalance
                 },
-                {
-                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::setPaused)
-                    }
-                    setPaused
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -10029,45 +6207,6 @@ pub mod BalancerV2Vault {
                     }
                     flashLoan
                 },
-                {
-                    fn registerTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <registerTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::registerTokens)
-                    }
-                    registerTokens
-                },
-                {
-                    fn deregisterTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <deregisterTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::deregisterTokens)
-                    }
-                    deregisterTokens
-                },
-                {
-                    fn getActionId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn exitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <exitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::exitPool)
-                    }
-                    exitPool
-                },
-                {
-                    fn getNextNonce(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::getNextNonce)
-                    }
-                    getNextNonce
-                },
                 {
                     fn batchSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <batchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -10075,13 +6214,6 @@ pub mod BalancerV2Vault {
                     }
                     batchSwap
                 },
-                {
-                    fn getAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
                 {
                     fn WETH(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -10089,51 +6221,6 @@ pub mod BalancerV2Vault {
                     }
                     WETH
                 },
-                {
-                    fn getPoolTokenInfo(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::getPoolTokenInfo)
-                    }
-                    getPoolTokenInfo
-                },
-                {
-                    fn joinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <joinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::joinPool)
-                    }
-                    joinPool
-                },
-                {
-                    fn getProtocolFeesCollector(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::getProtocolFeesCollector)
-                    }
-                    getProtocolFeesCollector
-                },
-                {
-                    fn managePoolBalance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::managePoolBalance)
-                    }
-                    managePoolBalance
-                },
-                {
-                    fn getDomainSeparator(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::getDomainSeparator)
-                    }
-                    getDomainSeparator
-                },
                 {
                     fn getPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -10141,15 +6228,6 @@ pub mod BalancerV2Vault {
                     }
                     getPool
                 },
-                {
-                    fn queryBatchSwap(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2VaultCalls::queryBatchSwap)
-                    }
-                    queryBatchSwap
-                },
                 {
                     fn getPoolTokens(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <getPoolTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -10195,24 +6273,6 @@ pub mod BalancerV2Vault {
                 &[u8],
             )
                 -> alloy_sol_types::Result<BalancerV2VaultCalls>] = &[
-                {
-                    fn setAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <setAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::setAuthorizer)
-                    }
-                    setAuthorizer
-                },
-                {
-                    fn registerPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <registerPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::registerPool)
-                    }
-                    registerPool
-                },
                 {
                     fn manageUserBalance(
                         data: &[u8],
@@ -10235,13 +6295,6 @@ pub mod BalancerV2Vault {
                     }
                     getInternalBalance
                 },
-                {
-                    fn setPaused(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2VaultCalls::setPaused)
-                    }
-                    setPaused
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -10267,51 +6320,6 @@ pub mod BalancerV2Vault {
                     }
                     flashLoan
                 },
-                {
-                    fn registerTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <registerTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::registerTokens)
-                    }
-                    registerTokens
-                },
-                {
-                    fn deregisterTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <deregisterTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::deregisterTokens)
-                    }
-                    deregisterTokens
-                },
-                {
-                    fn getActionId(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2VaultCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn exitPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <exitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2VaultCalls::exitPool)
-                    }
-                    exitPool
-                },
-                {
-                    fn getNextNonce(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getNextNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::getNextNonce)
-                    }
-                    getNextNonce
-                },
                 {
                     fn batchSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <batchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -10319,15 +6327,6 @@ pub mod BalancerV2Vault {
                     }
                     batchSwap
                 },
-                {
-                    fn getAuthorizer(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
                 {
                     fn WETH(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -10335,57 +6334,6 @@ pub mod BalancerV2Vault {
                     }
                     WETH
                 },
-                {
-                    fn getPoolTokenInfo(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::getPoolTokenInfo)
-                    }
-                    getPoolTokenInfo
-                },
-                {
-                    fn joinPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <joinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2VaultCalls::joinPool)
-                    }
-                    joinPool
-                },
-                {
-                    fn getProtocolFeesCollector(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2VaultCalls::getProtocolFeesCollector)
-                    }
-                    getProtocolFeesCollector
-                },
-                {
-                    fn managePoolBalance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2VaultCalls::managePoolBalance)
-                    }
-                    managePoolBalance
-                },
-                {
-                    fn getDomainSeparator(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2VaultCalls::getDomainSeparator)
-                    }
-                    getDomainSeparator
-                },
                 {
                     fn getPool(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -10393,17 +6341,6 @@ pub mod BalancerV2Vault {
                     }
                     getPool
                 },
-                {
-                    fn queryBatchSwap(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
-                        <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2VaultCalls::queryBatchSwap)
-                    }
-                    queryBatchSwap
-                },
                 {
                     fn getPoolTokens(data: &[u8]) -> alloy_sol_types::Result<BalancerV2VaultCalls> {
                         <getPoolTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -10454,74 +6391,27 @@ pub mod BalancerV2Vault {
                 Self::batchSwap(inner) => {
                     <batchSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::deregisterTokens(inner) => {
-                    <deregisterTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::exitPool(inner) => {
-                    <exitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::flashLoan(inner) => {
                     <flashLoanCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getDomainSeparator(inner) => {
-                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getInternalBalance(inner) => {
                     <getInternalBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getNextNonce(inner) => {
-                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::getPool(inner) => {
                     <getPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getPoolTokenInfo(inner) => {
-                    <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPoolTokens(inner) => {
                     <getPoolTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getProtocolFeesCollector(inner) => {
-                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::hasApprovedRelayer(inner) => {
                     <hasApprovedRelayerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::joinPool(inner) => {
-                    <joinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::managePoolBalance(inner) => {
-                    <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::manageUserBalance(inner) => {
                     <manageUserBalanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::queryBatchSwap(inner) => {
-                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::registerPool(inner) => {
-                    <registerPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::registerTokens(inner) => {
-                    <registerTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setAuthorizer(inner) => {
-                    <setAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::setRelayerApproval(inner) => {
                     <setRelayerApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -10540,74 +6430,27 @@ pub mod BalancerV2Vault {
                 Self::batchSwap(inner) => {
                     <batchSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::deregisterTokens(inner) => {
-                    <deregisterTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::exitPool(inner) => {
-                    <exitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::flashLoan(inner) => {
                     <flashLoanCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getDomainSeparator(inner) => {
-                    <getDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getInternalBalance(inner) => {
                     <getInternalBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getNextNonce(inner) => {
-                    <getNextNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::getPool(inner) => {
                     <getPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getPoolTokenInfo(inner) => {
-                    <getPoolTokenInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getPoolTokens(inner) => {
                     <getPoolTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getProtocolFeesCollector(inner) => {
-                    <getProtocolFeesCollectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::hasApprovedRelayer(inner) => {
                     <hasApprovedRelayerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::joinPool(inner) => {
-                    <joinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::managePoolBalance(inner) => {
-                    <managePoolBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::manageUserBalance(inner) => {
                     <manageUserBalanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::queryBatchSwap(inner) => {
-                    <queryBatchSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::registerPool(inner) => {
-                    <registerPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::registerTokens(inner) => {
-                    <registerTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setAuthorizer(inner) => {
-                    <setAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::setRelayerApproval(inner) => {
                     <setRelayerApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -11157,31 +7000,6 @@ pub mod BalancerV2Vault {
             })
         }
 
-        ///Creates a new call builder for the [`deregisterTokens`] function.
-        pub fn deregisterTokens(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, deregisterTokensCall, N> {
-            self.call_builder(&deregisterTokensCall { poolId, tokens })
-        }
-
-        ///Creates a new call builder for the [`exitPool`] function.
-        pub fn exitPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            request: <IVault::ExitPoolRequest as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, exitPoolCall, N> {
-            self.call_builder(&exitPoolCall {
-                poolId,
-                sender,
-                recipient,
-                request,
-            })
-        }
-
         ///Creates a new call builder for the [`flashLoan`] function.
         pub fn flashLoan(
             &self,
@@ -11200,26 +7018,6 @@ pub mod BalancerV2Vault {
             })
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getDomainSeparator`] function.
-        pub fn getDomainSeparator(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getDomainSeparatorCall, N> {
-            self.call_builder(&getDomainSeparatorCall)
-        }
-
         ///Creates a new call builder for the [`getInternalBalance`] function.
         pub fn getInternalBalance(
             &self,
@@ -11229,14 +7027,6 @@ pub mod BalancerV2Vault {
             self.call_builder(&getInternalBalanceCall { user, tokens })
         }
 
-        ///Creates a new call builder for the [`getNextNonce`] function.
-        pub fn getNextNonce(
-            &self,
-            user: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, getNextNonceCall, N> {
-            self.call_builder(&getNextNonceCall { user })
-        }
-
         ///Creates a new call builder for the [`getPausedState`] function.
         pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
             self.call_builder(&getPausedStateCall)
@@ -11250,15 +7040,6 @@ pub mod BalancerV2Vault {
             self.call_builder(&getPoolCall { poolId })
         }
 
-        ///Creates a new call builder for the [`getPoolTokenInfo`] function.
-        pub fn getPoolTokenInfo(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            token: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, getPoolTokenInfoCall, N> {
-            self.call_builder(&getPoolTokenInfoCall { poolId, token })
-        }
-
         ///Creates a new call builder for the [`getPoolTokens`] function.
         pub fn getPoolTokens(
             &self,
@@ -11267,14 +7048,6 @@ pub mod BalancerV2Vault {
             self.call_builder(&getPoolTokensCall { poolId })
         }
 
-        ///Creates a new call builder for the [`getProtocolFeesCollector`]
-        /// function.
-        pub fn getProtocolFeesCollector(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeesCollectorCall, N> {
-            self.call_builder(&getProtocolFeesCollectorCall)
-        }
-
         ///Creates a new call builder for the [`hasApprovedRelayer`] function.
         pub fn hasApprovedRelayer(
             &self,
@@ -11284,32 +7057,6 @@ pub mod BalancerV2Vault {
             self.call_builder(&hasApprovedRelayerCall { user, relayer })
         }
 
-        ///Creates a new call builder for the [`joinPool`] function.
-        pub fn joinPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            request: <IVault::JoinPoolRequest as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, joinPoolCall, N> {
-            self.call_builder(&joinPoolCall {
-                poolId,
-                sender,
-                recipient,
-                request,
-            })
-        }
-
-        ///Creates a new call builder for the [`managePoolBalance`] function.
-        pub fn managePoolBalance(
-            &self,
-            ops: alloy_sol_types::private::Vec<
-                <IVault::PoolBalanceOp as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, managePoolBalanceCall, N> {
-            self.call_builder(&managePoolBalanceCall { ops })
-        }
-
         ///Creates a new call builder for the [`manageUserBalance`] function.
         pub fn manageUserBalance(
             &self,
@@ -11320,62 +7067,6 @@ pub mod BalancerV2Vault {
             self.call_builder(&manageUserBalanceCall { ops })
         }
 
-        ///Creates a new call builder for the [`queryBatchSwap`] function.
-        pub fn queryBatchSwap(
-            &self,
-            kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-            swaps: alloy_sol_types::private::Vec<
-                <IVault::BatchSwapStep as alloy_sol_types::SolType>::RustType,
-            >,
-            assets: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            funds: <IVault::FundManagement as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, queryBatchSwapCall, N> {
-            self.call_builder(&queryBatchSwapCall {
-                kind,
-                swaps,
-                assets,
-                funds,
-            })
-        }
-
-        ///Creates a new call builder for the [`registerPool`] function.
-        pub fn registerPool(
-            &self,
-            specialization: <IVault::PoolSpecialization as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, registerPoolCall, N> {
-            self.call_builder(&registerPoolCall { specialization })
-        }
-
-        ///Creates a new call builder for the [`registerTokens`] function.
-        pub fn registerTokens(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            assetManagers: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, registerTokensCall, N> {
-            self.call_builder(&registerTokensCall {
-                poolId,
-                tokens,
-                assetManagers,
-            })
-        }
-
-        ///Creates a new call builder for the [`setAuthorizer`] function.
-        pub fn setAuthorizer(
-            &self,
-            newAuthorizer: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setAuthorizerCall, N> {
-            self.call_builder(&setAuthorizerCall { newAuthorizer })
-        }
-
-        ///Creates a new call builder for the [`setPaused`] function.
-        pub fn setPaused(
-            &self,
-            paused: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
-            self.call_builder(&setPausedCall { paused })
-        }
-
         ///Creates a new call builder for the [`setRelayerApproval`] function.
         pub fn setRelayerApproval(
             &self,
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs
index 634e27e0e7..88378b5913 100644
--- a/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2weightedpool/src/lib.rs
@@ -6,854 +6,35 @@
     non_snake_case
 )]
 //! Auto-generated contract bindings. Do not edit.
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
-library IPoolSwapStructs {
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IPoolSwapStructs {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapRequest { IVault.SwapKind kind; address tokenIn; address tokenOut; uint256 amount; bytes32 poolId; uint256 lastChangeBlock; address from; address to; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapRequest {
-        #[allow(missing_docs)]
-        pub kind: <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            IVault::SwapKind,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <IVault::SwapKind as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapRequest> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapRequest) -> Self {
-                (
-                    value.kind,
-                    value.tokenIn,
-                    value.tokenOut,
-                    value.amount,
-                    value.poolId,
-                    value.lastChangeBlock,
-                    value.from,
-                    value.to,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapRequest {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    kind: tuple.0,
-                    tokenIn: tuple.1,
-                    tokenOut: tuple.2,
-                    amount: tuple.3,
-                    poolId: tuple.4,
-                    lastChangeBlock: tuple.5,
-                    from: tuple.6,
-                    to: tuple.7,
-                    userData: tuple.8,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapRequest {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapRequest {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <IVault::SwapKind as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.from,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapRequest {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapRequest {
-            const NAME: &'static str = "SwapRequest";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapRequest(uint8 kind,address tokenIn,address tokenOut,uint256 \
-                     amount,bytes32 poolId,uint256 lastChangeBlock,address from,address to,bytes \
-                     userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <IVault::SwapKind as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.kind,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.poolId)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.lastChangeBlock,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.from,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.to,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapRequest {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <IVault::SwapKind as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.kind,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenIn,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenOut,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.poolId,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.lastChangeBlock,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.from,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.to,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <IVault::SwapKind as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind, out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.poolId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.lastChangeBlock,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.from,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.to,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-    See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IPoolSwapStructsInstance<P, N> {
-        IPoolSwapStructsInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IPoolSwapStructs`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IPoolSwapStructs`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IPoolSwapStructsInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IPoolSwapStructsInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IPoolSwapStructsInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IPoolSwapStructs`](self) contract instance.
-
-        See the [wrapper's documentation](`IPoolSwapStructsInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
+interface BalancerV2WeightedPool {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event PausedStateChanged(bool paused);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
+    event Transfer(address indexed from, address indexed to, uint256 value);
 
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
 
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IPoolSwapStructsInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IPoolSwapStructsInstance<P, N> {
-            IPoolSwapStructsInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPoolSwapStructsInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library IVault {
-    type SwapKind is uint8;
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IVault {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapKind(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<SwapKind> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl SwapKind {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for SwapKind {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<SwapKind> for u8 {
-            fn from(value: SwapKind) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapKind {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapKind {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-    See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IVaultInstance<P, N> {
-        IVaultInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IVault`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IVault`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IVaultInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IVaultInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IVaultInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IVault`](self) contract instance.
-
-        See the [wrapper's documentation](`IVaultInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IVaultInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IVaultInstance<P, N> {
-            IVaultInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IVaultInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IPoolSwapStructs {
-    struct SwapRequest {
-        IVault.SwapKind kind;
-        address tokenIn;
-        address tokenOut;
-        uint256 amount;
-        bytes32 poolId;
-        uint256 lastChangeBlock;
-        address from;
-        address to;
-        bytes userData;
-    }
-}
-
-library IVault {
-    type SwapKind is uint8;
-}
-
-interface BalancerV2WeightedPool {
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    event PausedStateChanged(bool paused);
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
-
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function allowance(address owner, address spender) external view returns (uint256);
-    function approve(address spender, uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-    function decimals() external pure returns (uint8);
-    function decreaseApproval(address spender, uint256 amount) external returns (bool);
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getInvariant() external view returns (uint256);
-    function getLastInvariant() external view returns (uint256);
-    function getNormalizedWeights() external view returns (uint256[] memory);
-    function getOwner() external view returns (address);
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
-    function getPoolId() external view returns (bytes32);
-    function getRate() external view returns (uint256);
-    function getSwapFeePercentage() external view returns (uint256);
-    function getVault() external view returns (address);
-    function increaseApproval(address spender, uint256 amount) external returns (bool);
-    function name() external view returns (string memory);
-    function nonces(address owner) external view returns (uint256);
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
-    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
-    function setPaused(bool paused) external;
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
-    function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-}
-```
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function decimals() external pure returns (uint8);
+    function getNormalizedWeights() external view returns (uint256[] memory);
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    function getPoolId() external view returns (bytes32);
+    function getSwapFeePercentage() external view returns (uint256);
+    function name() external view returns (string memory);
+    function nonces(address owner) external view returns (uint256);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function symbol() external view returns (string memory);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+}
+```
 
 ...which was generated by the following JSON ABI:
 ```json
@@ -1004,91 +185,9 @@ interface BalancerV2WeightedPool {
   },
   {
     "type": "function",
-    "name": "decreaseApproval",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getInvariant",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getLastInvariant",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getNormalizedWeights",
-    "inputs": [],
-    "outputs": [
+    "name": "getNormalizedWeights",
+    "inputs": [],
+    "outputs": [
       {
         "name": "",
         "type": "uint256[]",
@@ -1097,19 +196,6 @@ interface BalancerV2WeightedPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getOwner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getPausedState",
@@ -1146,19 +232,6 @@ interface BalancerV2WeightedPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getRate",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getSwapFeePercentage",
@@ -1172,43 +245,6 @@ interface BalancerV2WeightedPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "increaseApproval",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "name",
@@ -1241,190 +277,6 @@ interface BalancerV2WeightedPool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "onExitPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onJoinPool",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onSwap",
-    "inputs": [
-      {
-        "name": "request",
-        "type": "tuple",
-        "internalType": "struct IPoolSwapStructs.SwapRequest",
-        "components": [
-          {
-            "name": "kind",
-            "type": "uint8",
-            "internalType": "enum IVault.SwapKind"
-          },
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "tokenOut",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "poolId",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "lastChangeBlock",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "from",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "balanceTokenIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "balanceTokenOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "permit",
@@ -1434,3026 +286,442 @@ interface BalancerV2WeightedPool {
         "type": "address",
         "internalType": "address"
       },
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "queryExit",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "queryJoin",
-    "inputs": [
-      {
-        "name": "poolId",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "balances",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "lastChangeBlock",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "protocolSwapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bptOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "setPaused",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setSwapFeePercentage",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "symbol",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "transfer",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferFrom",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "event",
-    "name": "Approval",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PausedStateChanged",
-    "inputs": [
-      {
-        "name": "paused",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SwapFeePercentageChanged",
-    "inputs": [
-      {
-        "name": "swapFeePercentage",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Transfer",
-    "inputs": [
-      {
-        "name": "from",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BalancerV2WeightedPool {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
-    ```solidity
-    event Approval(address indexed owner, address indexed spender, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Approval {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Approval {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
-                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
-                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    spender: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.spender.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Approval {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Approval> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
-    ```solidity
-    event PausedStateChanged(bool paused);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PausedStateChanged {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PausedStateChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
-                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
-                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { paused: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
-    ```solidity
-    event SwapFeePercentageChanged(uint256 swapFeePercentage);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SwapFeePercentageChanged {
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
-                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
-                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    swapFeePercentage: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
-    ```solidity
-    event Transfer(address indexed from, address indexed to, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Transfer {
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Transfer {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
-                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
-                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    from: topics.1,
-                    to: topics.2,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.from.clone(),
-                    self.to.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.from,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.to,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Transfer {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Transfer> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub vault: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub name: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub symbol: alloy_sol_types::private::String,
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub normalizedWeights:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::String,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (
-                        value.vault,
-                        value.name,
-                        value.symbol,
-                        value.tokens,
-                        value.normalizedWeights,
-                        value.swapFeePercentage,
-                        value.pauseWindowDuration,
-                        value.bufferPeriodDuration,
-                        value.owner,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        vault: tuple.0,
-                        name: tuple.1,
-                        symbol: tuple.2,
-                        tokens: tuple.3,
-                        normalizedWeights: tuple.4,
-                        swapFeePercentage: tuple.5,
-                        pauseWindowDuration: tuple.6,
-                        bufferPeriodDuration: tuple.7,
-                        owner: tuple.8,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::String,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.vault,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.name,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.symbol,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
-    ```solidity
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
-            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DOMAIN_SEPARATORReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: DOMAIN_SEPARATORReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
-    ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: allowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: allowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
-    ```solidity
-    function approve(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approveReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: approveReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
-    ```solidity
-    function balanceOf(address account) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct balanceOfReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: balanceOfReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: balanceOfReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
-    ```solidity
-    function decimals() external pure returns (uint8);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsReturn {
-        #[allow(missing_docs)]
-        pub _0: u8,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
-            type Parameters<'a> = ();
-            type Return = u8;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decimalsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decimalsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseApproval(address,uint256)` and selector `0x66188463`.
-    ```solidity
-    function decreaseApproval(address spender, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseApprovalCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decreaseApproval(address,uint256)`](decreaseApprovalCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseApprovalReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseApprovalCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseApprovalCall) -> Self {
-                    (value.spender, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseApprovalCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseApprovalReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseApprovalReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseApprovalReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseApprovalCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 24u8, 132u8, 99u8];
-            const SIGNATURE: &'static str = "decreaseApproval(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decreaseApprovalReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decreaseApprovalReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
-    ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getActionIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getActionIdReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getActionIdReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getInvariant()` and selector `0xc0ff1a15`.
-    ```solidity
-    function getInvariant() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getInvariantCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getInvariant()`](getInvariantCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getInvariantReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getInvariantCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getInvariantCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getInvariantReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getInvariantReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInvariantReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getInvariantCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [192u8, 255u8, 26u8, 21u8];
-            const SIGNATURE: &'static str = "getInvariant()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getInvariantReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getInvariantReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getLastInvariant()` and selector `0x9b02cdde`.
-    ```solidity
-    function getLastInvariant() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLastInvariantCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getLastInvariant()`](getLastInvariantCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLastInvariantReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLastInvariantCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getLastInvariantCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLastInvariantReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getLastInvariantReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLastInvariantReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getLastInvariantCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [155u8, 2u8, 205u8, 222u8];
-            const SIGNATURE: &'static str = "getLastInvariant()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getLastInvariantReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getLastInvariantReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getNormalizedWeights()` and selector `0xf89f27ed`.
-    ```solidity
-    function getNormalizedWeights() external view returns (uint256[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNormalizedWeightsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getNormalizedWeights()`](getNormalizedWeightsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getNormalizedWeightsReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNormalizedWeightsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getNormalizedWeightsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getNormalizedWeightsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getNormalizedWeightsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getNormalizedWeightsCall {
-            type Parameters<'a> = ();
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [248u8, 159u8, 39u8, 237u8];
-            const SIGNATURE: &'static str = "getNormalizedWeights()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getNormalizedWeightsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getNormalizedWeightsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOwner()` and selector `0x893d20e8`.
-    ```solidity
-    function getOwner() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getOwner()`](getOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOwnerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [137u8, 61u8, 32u8, 232u8];
-            const SIGNATURE: &'static str = "getOwner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOwnerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOwnerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "v",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "r",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "symbol",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PausedStateChanged",
+    "inputs": [
+      {
+        "name": "paused",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SwapFeePercentageChanged",
+    "inputs": [
+      {
+        "name": "swapFeePercentage",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BalancerV2WeightedPool {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
+    /**Event with signature `Approval(address,address,uint256)` and selector `0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925`.
     ```solidity
-    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPausedState()`](getPausedStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPausedStateReturn {
-        #[allow(missing_docs)]
-        pub paused: bool,
-        #[allow(missing_docs)]
-        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
-    }
     #[allow(
         non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                bool,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPausedStateReturn) -> Self {
-                    (
-                        value.paused,
-                        value.pauseWindowEndTime,
-                        value.bufferPeriodEndTime,
-                    )
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
+                    125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
+                    91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    spender: topics.2,
+                    value: data.0,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paused: tuple.0,
-                        pauseWindowEndTime: tuple.1,
-                        bufferPeriodEndTime: tuple.2,
-                    }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-        }
-        impl getPausedStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowEndTime,
-                    ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodEndTime,
+                        &self.value,
                     ),
                 )
             }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPausedStateCall {
-            type Parameters<'a> = ();
-            type Return = getPausedStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
-            const SIGNATURE: &'static str = "getPausedState()";
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.spender.clone(),
+                )
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
             }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPausedStateReturn::_tokenize(ret)
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-
+        }
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
+    /**Event with signature `PausedStateChanged(bool)` and selector `0x9e3a5e37224532dea67b89face185703738a228a6e8a23dee546960180d3be64`.
     ```solidity
-    function getPoolId() external view returns (bytes32);
+    event PausedStateChanged(bool paused);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolId()`](getPoolIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolIdReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PausedStateChanged {
+        #[allow(missing_docs)]
+        pub paused: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolIdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for PausedStateChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
-            const SIGNATURE: &'static str = "getPoolId()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "PausedStateChanged(bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8,
+                    206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8,
+                    229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { paused: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolIdReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolIdReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PausedStateChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PausedStateChanged> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PausedStateChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRate()` and selector `0x679aefce`.
+    /**Event with signature `SwapFeePercentageChanged(uint256)` and selector `0xa9ba3ffe0b6c366b81232caab38605a0699ad5398d6cce76f91ee809e322dafc`.
     ```solidity
-    function getRate() external view returns (uint256);
+    event SwapFeePercentageChanged(uint256 swapFeePercentage);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRateCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRate()`](getRateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getRateReturn {
+    pub struct SwapFeePercentageChanged {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -4463,136 +731,109 @@ pub mod BalancerV2WeightedPool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRateReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRateCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for SwapFeePercentageChanged {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [103u8, 154u8, 239u8, 206u8];
-            const SIGNATURE: &'static str = "getRate()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SwapFeePercentageChanged(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 186u8, 63u8, 254u8, 11u8, 108u8, 54u8, 107u8, 129u8, 35u8, 44u8, 170u8,
+                    179u8, 134u8, 5u8, 160u8, 105u8, 154u8, 213u8, 57u8, 141u8, 108u8, 206u8,
+                    118u8, 249u8, 30u8, 232u8, 9u8, 227u8, 34u8, 218u8, 252u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    swapFeePercentage: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.swapFeePercentage,
                     ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRateReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SwapFeePercentageChanged {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SwapFeePercentageChanged> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRateReturn = r.into();
-                    r._0
-                })
+            fn from(this: &SwapFeePercentageChanged) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
+    /**Event with signature `Transfer(address,address,uint256)` and selector `0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef`.
     ```solidity
-    function getSwapFeePercentage() external view returns (uint256);
+    event Transfer(address indexed from, address indexed to, uint256 value);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSwapFeePercentageCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getSwapFeePercentageReturn {
+    pub struct Transfer {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -4602,181 +843,161 @@ pub mod BalancerV2WeightedPool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSwapFeePercentageReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for Transfer {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
-            const SIGNATURE: &'static str = "getSwapFeePercentage()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
+                    104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
+                    161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    from: topics.1,
+                    to: topics.2,
+                    value: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.value,
                     ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSwapFeePercentageReturn = r.into();
-                        r._0
-                    },
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.from.clone(),
+                    self.to.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getSwapFeePercentageReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.from,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.to,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Transfer {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Transfer> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
+    /**Constructor`.
     ```solidity
-    function getVault() external view returns (address);
+    constructor(address vault, string name, string symbol, address[] tokens, uint256[] normalizedWeights, uint256 swapFeePercentage, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub name: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub symbol: alloy_sol_types::private::String,
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub normalizedWeights:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        #[allow(missing_docs)]
+        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::String,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4788,30 +1009,54 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value.vault,
+                        value.name,
+                        value.symbol,
+                        value.tokens,
+                        value.normalizedWeights,
+                        value.swapFeePercentage,
+                        value.pauseWindowDuration,
+                        value.bufferPeriodDuration,
+                        value.owner,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        vault: tuple.0,
+                        name: tuple.1,
+                        symbol: tuple.2,
+                        tokens: tuple.3,
+                        normalizedWeights: tuple.4,
+                        swapFeePercentage: tuple.5,
+                        pauseWindowDuration: tuple.6,
+                        bufferPeriodDuration: tuple.7,
+                        owner: tuple.8,
+                    }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::String,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -4821,57 +1066,54 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.name,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.symbol,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<256>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.normalizedWeights),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.swapFeePercentage),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pauseWindowDuration),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.bufferPeriodDuration),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
                 )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseApproval(address,uint256)` and selector `0xd73dd623`.
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
     ```solidity
-    function increaseApproval(address spender, uint256 amount) external returns (bool);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseApprovalCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct DOMAIN_SEPARATORCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`increaseApproval(address,uint256)`](increaseApprovalCall) function.
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseApprovalReturn {
+    pub struct DOMAIN_SEPARATORReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -4884,15 +1126,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4904,28 +1140,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseApprovalCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseApprovalCall) -> Self {
-                    (value.spender, value.amount)
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseApprovalCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4937,32 +1170,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseApprovalReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseApprovalReturn) -> Self {
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseApprovalReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseApprovalCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [215u8, 61u8, 214u8, 35u8];
-            const SIGNATURE: &'static str = "increaseApproval(address,uint256)";
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
 
             #[inline]
             fn new<'a>(
@@ -4973,26 +1203,23 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: increaseApprovalReturn = r.into();
+                        let r: DOMAIN_SEPARATORReturn = r.into();
                         r._0
                     },
                 )
@@ -5004,28 +1231,33 @@ pub mod BalancerV2WeightedPool {
                     data,
                 )
                 .map(|r| {
-                    let r: increaseApprovalReturn = r.into();
+                    let r: DOMAIN_SEPARATORReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
-    function name() external view returns (string memory);
+    function allowance(address owner, address spender) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nameCall;
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nameReturn {
+    pub struct allowanceReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5038,9 +1270,15 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5052,25 +1290,28 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5082,29 +1323,32 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -5115,19 +1359,30 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: nameReturn = r.into();
+                        let r: allowanceReturn = r.into();
                         r._0
                     },
                 )
@@ -5139,31 +1394,33 @@ pub mod BalancerV2WeightedPool {
                     data,
                 )
                 .map(|r| {
-                    let r: nameReturn = r.into();
+                    let r: allowanceReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
     ```solidity
-    function nonces(address owner) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct noncesCall {
+    pub struct approveCall {
         #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
+    /// [`approve(address,uint256)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct noncesReturn {
+    pub struct approveReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -5176,9 +1433,15 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5190,25 +1453,28 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5220,29 +1486,32 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5255,25 +1524,24 @@ pub mod BalancerV2WeightedPool {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: noncesReturn = r.into();
+                        let r: approveReturn = r.into();
                         r._0
                     },
                 )
@@ -5285,47 +1553,31 @@ pub mod BalancerV2WeightedPool {
                     data,
                 )
                 .map(|r| {
-                    let r: noncesReturn = r.into();
+                    let r: approveReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x74f3b009`.
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
     ```solidity
-    function onExitPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function balanceOf(address account) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onExitPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct balanceOfCall {
         #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
+        pub account: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onExitPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onExitPoolCall) function.
+    /// [`balanceOf(address)`](balanceOfCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onExitPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct balanceOfReturn {
         #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5338,25 +1590,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5368,47 +1604,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self { account: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5420,56 +1634,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onExitPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onExitPoolReturn) -> Self {
-                    (value._0, value._1)
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onExitPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl onExitPoolReturn {
-            fn _tokenize(&self) -> <onExitPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onExitPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onExitPoolReturn;
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [116u8, 243u8, 176u8, 9u8];
-            const SIGNATURE: &'static str =
-                "onExitPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
 
             #[inline]
             fn new<'a>(
@@ -5481,41 +1668,29 @@ pub mod BalancerV2WeightedPool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
+                        &self.account,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onExitPoolReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5523,45 +1698,29 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0xd5c096c4`.
+    /**Function with signature `decimals()` and selector `0x313ce567`.
     ```solidity
-    function onJoinPool(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external returns (uint256[] memory, uint256[] memory);
+    function decimals() external pure returns (uint8);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onJoinPoolCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct decimalsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onJoinPool(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](onJoinPoolCall) function.
+    /// [`decimals()`](decimalsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onJoinPoolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct decimalsReturn {
         #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: u8,
     }
     #[allow(
         non_camel_case_types,
@@ -5569,30 +1728,14 @@ pub mod BalancerV2WeightedPool {
         clippy::pub_underscore_fields,
         clippy::style
     )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+    const _: () = {
+        use alloy_sol_types;
+        {
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5604,47 +1747,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (u8,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5656,56 +1777,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onJoinPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onJoinPoolReturn) -> Self {
-                    (value._0, value._1)
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onJoinPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl onJoinPoolReturn {
-            fn _tokenize(&self) -> <onJoinPoolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._0),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onJoinPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = onJoinPoolReturn;
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 192u8, 150u8, 196u8];
-            const SIGNATURE: &'static str =
-                "onJoinPool(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
 
             #[inline]
             fn new<'a>(
@@ -5716,42 +1810,22 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                onJoinPoolReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5759,34 +1833,29 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,bytes),uint256,uint256)` and selector `0x9d2c110c`.
+    /**Function with signature `getNormalizedWeights()` and selector `0xf89f27ed`.
     ```solidity
-    function onSwap(IPoolSwapStructs.SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut) external view returns (uint256);
+    function getNormalizedWeights() external view returns (uint256[] memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwapCall {
-        #[allow(missing_docs)]
-        pub request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct getNormalizedWeightsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`onSwap((uint8,address,address,uint256,bytes32,uint256,address,address,
-    /// bytes),uint256,uint256)`](onSwapCall) function.
+    /// [`getNormalizedWeights()`](getNormalizedWeightsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct onSwapReturn {
+    pub struct getNormalizedWeightsReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
     }
     #[allow(
         non_camel_case_types,
@@ -5799,17 +1868,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5821,29 +1882,28 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwapCall) -> Self {
-                    (value.request, value.balanceTokenIn, value.balanceTokenOut)
+            impl ::core::convert::From<getNormalizedWeightsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        request: tuple.0,
-                        balanceTokenIn: tuple.1,
-                        balanceTokenOut: tuple.2,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5855,34 +1915,31 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<onSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onSwapReturn) -> Self {
+            impl ::core::convert::From<getNormalizedWeightsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getNormalizedWeightsReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onSwapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getNormalizedWeightsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for onSwapCall {
-            type Parameters<'a> = (
-                IPoolSwapStructs::SwapRequest,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for getNormalizedWeightsCall {
+            type Parameters<'a> = ();
+            type Return =
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [157u8, 44u8, 17u8, 12u8];
-            const SIGNATURE: &'static str = "onSwap((uint8,address,address,uint256,bytes32,\
-                                             uint256,address,address,bytes),uint256,uint256)";
+            const SELECTOR: [u8; 4] = [248u8, 159u8, 39u8, 237u8];
+            const SIGNATURE: &'static str = "getNormalizedWeights()";
 
             #[inline]
             fn new<'a>(
@@ -5893,33 +1950,21 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::tokenize(
-                        &self.request,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.balanceTokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.balanceTokenOut,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<256>,
+                > as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: onSwapReturn = r.into();
+                        let r: getNormalizedWeightsReturn = r.into();
                         r._0
                     },
                 )
@@ -5931,41 +1976,33 @@ pub mod BalancerV2WeightedPool {
                     data,
                 )
                 .map(|r| {
-                    let r: onSwapReturn = r.into();
+                    let r: getNormalizedWeightsReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    /**Function with signature `getPausedState()` and selector `0x1c0de051`.
     ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function getPausedState() external view returns (bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct getPausedStateCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`getPausedState()`](getPausedStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getPausedStateReturn {
         #[allow(missing_docs)]
-        pub v: u8,
+        pub paused: bool,
         #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
+        pub pauseWindowEndTime: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
+        pub bufferPeriodEndTime: alloy_sol_types::private::primitives::aliases::U256,
     }
-    ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5977,25 +2014,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6007,41 +2028,33 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
+            impl ::core::convert::From<getPausedStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                bool,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6053,43 +2066,58 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getPausedStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPausedStateReturn) -> Self {
+                    (
+                        value.paused,
+                        value.pauseWindowEndTime,
+                        value.bufferPeriodEndTime,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPausedStateReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        paused: tuple.0,
+                        pauseWindowEndTime: tuple.1,
+                        bufferPeriodEndTime: tuple.2,
+                    }
                 }
             }
         }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        impl getPausedStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getPausedStateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.paused,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.pauseWindowEndTime,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.bufferPeriodEndTime,
+                    ),
+                )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolCall for getPausedStateCall {
+            type Parameters<'a> = ();
+            type Return = getPausedStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Bool,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
             );
-            type Return = permitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+            const SELECTOR: [u8; 4] = [28u8, 13u8, 224u8, 81u8];
+            const SIGNATURE: &'static str = "getPausedState()";
 
             #[inline]
             fn new<'a>(
@@ -6100,34 +2128,12 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
+                getPausedStateReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -6146,41 +2152,21 @@ pub mod BalancerV2WeightedPool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x6028bfd4`.
+    /**Function with signature `getPoolId()` and selector `0x38fff2d0`.
     ```solidity
-    function queryExit(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptIn, uint256[] memory amountsOut);
+    function getPoolId() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryExitCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct getPoolIdCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryExit(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryExitCall) function.
+    /// [`getPoolId()`](getPoolIdCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryExitReturn {
-        #[allow(missing_docs)]
-        pub bptIn: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct getPoolIdReturn {
         #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -6193,25 +2179,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6223,47 +2193,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryExitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<getPoolIdCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6275,56 +2223,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryExitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryExitReturn) -> Self {
-                    (value.bptIn, value.amountsOut)
+            impl ::core::convert::From<getPoolIdReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolIdReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryExitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolIdReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptIn: tuple.0,
-                        amountsOut: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl queryExitReturn {
-            fn _tokenize(&self) -> <queryExitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryExitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryExitReturn;
+        impl alloy_sol_types::SolCall for getPoolIdCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [96u8, 40u8, 191u8, 212u8];
-            const SIGNATURE: &'static str =
-                "queryExit(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [56u8, 255u8, 242u8, 208u8];
+            const SIGNATURE: &'static str = "getPoolId()";
 
             #[inline]
             fn new<'a>(
@@ -6335,42 +2256,26 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryExitReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPoolIdReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6378,46 +2283,29 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getPoolIdReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)` and selector `0x87ec6817`.
+    /**Function with signature `getSwapFeePercentage()` and selector `0x55c67628`.
     ```solidity
-    function queryJoin(bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData) external view returns (uint256 bptOut, uint256[] memory amountsIn);
+    function getSwapFeePercentage() external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryJoinCall {
-        #[allow(missing_docs)]
-        pub poolId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub balances:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
+    pub struct getSwapFeePercentageCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`queryJoin(bytes32,address,address,uint256[],uint256,uint256,
-    /// bytes)`](queryJoinCall) function.
+    /// [`getSwapFeePercentage()`](getSwapFeePercentageCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct queryJoinReturn {
-        #[allow(missing_docs)]
-        pub bptOut: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct getSwapFeePercentageReturn {
         #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -6425,30 +2313,14 @@ pub mod BalancerV2WeightedPool {
         clippy::pub_underscore_fields,
         clippy::style
     )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6460,47 +2332,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryJoinCall> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinCall) -> Self {
-                    (
-                        value.poolId,
-                        value.sender,
-                        value.recipient,
-                        value.balances,
-                        value.lastChangeBlock,
-                        value.protocolSwapFeePercentage,
-                        value.userData,
-                    )
+            impl ::core::convert::From<getSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        poolId: tuple.0,
-                        sender: tuple.1,
-                        recipient: tuple.2,
-                        balances: tuple.3,
-                        lastChangeBlock: tuple.4,
-                        protocolSwapFeePercentage: tuple.5,
-                        userData: tuple.6,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6512,56 +2362,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<queryJoinReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: queryJoinReturn) -> Self {
-                    (value.bptOut, value.amountsIn)
+            impl ::core::convert::From<getSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getSwapFeePercentageReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryJoinReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSwapFeePercentageReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        bptOut: tuple.0,
-                        amountsIn: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl queryJoinReturn {
-            fn _tokenize(&self) -> <queryJoinCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.bptOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for queryJoinCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = queryJoinReturn;
+        impl alloy_sol_types::SolCall for getSwapFeePercentageCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [135u8, 236u8, 104u8, 23u8];
-            const SIGNATURE: &'static str =
-                "queryJoin(bytes32,address,address,uint256[],uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [85u8, 198u8, 118u8, 40u8];
+            const SIGNATURE: &'static str = "getSwapFeePercentage()";
 
             #[inline]
             fn new<'a>(
@@ -6572,42 +2395,26 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.poolId),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.balances),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.lastChangeBlock),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.protocolSwapFeePercentage,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                queryJoinReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getSwapFeePercentageReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6615,26 +2422,30 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getSwapFeePercentageReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setPaused(bool)` and selector `0x16c38b3c`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function setPaused(bool paused) external;
+    function name() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedCall {
-        #[allow(missing_docs)]
-        pub paused: bool,
-    }
-    ///Container type for the return parameters of the
-    /// [`setPaused(bool)`](setPausedCall) function.
+    pub struct nameCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setPausedReturn {}
+    pub struct nameReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6646,9 +2457,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6660,25 +2471,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedCall) -> Self {
-                    (value.paused,)
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { paused: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6690,34 +2501,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setPausedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setPausedReturn) -> Self {
-                    ()
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPausedReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setPausedReturn {
-            fn _tokenize(&self) -> <setPausedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setPausedCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Return = setPausedReturn;
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [22u8, 195u8, 139u8, 60u8];
-            const SIGNATURE: &'static str = "setPaused(bool)";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -6728,22 +2534,22 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.paused,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setPausedReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nameReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6751,26 +2557,33 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: nameReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapFeePercentage(uint256)` and selector `0x38e9922e`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function setSwapFeePercentage(uint256 swapFeePercentage) external;
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeePercentageCall {
+    pub struct noncesCall {
         #[allow(missing_docs)]
-        pub swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
+        pub owner: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setSwapFeePercentage(uint256)`](setSwapFeePercentageCall) function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeePercentageReturn {}
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6782,9 +2595,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6796,27 +2609,25 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageCall) -> Self {
-                    (value.swapFeePercentage,)
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        swapFeePercentage: tuple.0,
-                    }
+                    Self { owner: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6828,37 +2639,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeePercentageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeePercentageReturn) -> Self {
-                    ()
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeePercentageReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setSwapFeePercentageReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setSwapFeePercentageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapFeePercentageCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = setSwapFeePercentageReturn;
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 233u8, 146u8, 46u8];
-            const SIGNATURE: &'static str = "setSwapFeePercentage(uint256)";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -6870,21 +2673,29 @@ pub mod BalancerV2WeightedPool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.swapFeePercentage,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapFeePercentageReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -6892,27 +2703,42 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `symbol()` and selector `0x95d89b41`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function symbol() external view returns (string memory);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct symbolCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`symbol()`](symbolCall)
-    /// function.
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
+    ///Container type for the return parameters of the
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct symbolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6924,9 +2750,25 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6938,25 +2780,41 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolCall) -> Self {
-                    ()
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6968,29 +2826,43 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for symbolCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
-            const SIGNATURE: &'static str = "symbol()";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -7001,22 +2873,40 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: symbolReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -7024,29 +2914,26 @@ pub mod BalancerV2WeightedPool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: symbolReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
     ```solidity
-    function totalSupply() external view returns (uint256);
+    function symbol() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyCall;
+    pub struct symbolCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyReturn {
+    pub struct symbolReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -7073,14 +2960,14 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -7089,9 +2976,9 @@ pub mod BalancerV2WeightedPool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7103,29 +2990,29 @@ pub mod BalancerV2WeightedPool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
+        impl alloy_sol_types::SolCall for symbolCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
 
             #[inline]
             fn new<'a>(
@@ -7141,18 +3028,14 @@ pub mod BalancerV2WeightedPool {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: totalSupplyReturn = r.into();
+                        let r: symbolReturn = r.into();
                         r._0
                     },
                 )
@@ -7164,7 +3047,7 @@ pub mod BalancerV2WeightedPool {
                     data,
                 )
                 .map(|r| {
-                    let r: totalSupplyReturn = r.into();
+                    let r: symbolReturn = r.into();
                     r._0
                 })
             }
@@ -7511,56 +3394,22 @@ pub mod BalancerV2WeightedPool {
         #[allow(missing_docs)]
         decimals(decimalsCall),
         #[allow(missing_docs)]
-        decreaseApproval(decreaseApprovalCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getInvariant(getInvariantCall),
-        #[allow(missing_docs)]
-        getLastInvariant(getLastInvariantCall),
-        #[allow(missing_docs)]
         getNormalizedWeights(getNormalizedWeightsCall),
         #[allow(missing_docs)]
-        getOwner(getOwnerCall),
-        #[allow(missing_docs)]
         getPausedState(getPausedStateCall),
         #[allow(missing_docs)]
         getPoolId(getPoolIdCall),
         #[allow(missing_docs)]
-        getRate(getRateCall),
-        #[allow(missing_docs)]
         getSwapFeePercentage(getSwapFeePercentageCall),
         #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        increaseApproval(increaseApprovalCall),
-        #[allow(missing_docs)]
         name(nameCall),
         #[allow(missing_docs)]
         nonces(noncesCall),
         #[allow(missing_docs)]
-        onExitPool(onExitPoolCall),
-        #[allow(missing_docs)]
-        onJoinPool(onJoinPoolCall),
-        #[allow(missing_docs)]
-        onSwap(onSwapCall),
-        #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        queryExit(queryExitCall),
-        #[allow(missing_docs)]
-        queryJoin(queryJoinCall),
-        #[allow(missing_docs)]
-        setPaused(setPausedCall),
-        #[allow(missing_docs)]
-        setSwapFeePercentage(setSwapFeePercentageCall),
-        #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -7576,34 +3425,17 @@ pub mod BalancerV2WeightedPool {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [22u8, 195u8, 139u8, 60u8],
-            [24u8, 22u8, 13u8, 221u8],
             [28u8, 13u8, 224u8, 81u8],
             [35u8, 184u8, 114u8, 221u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
-            [56u8, 233u8, 146u8, 46u8],
             [56u8, 255u8, 242u8, 208u8],
             [85u8, 198u8, 118u8, 40u8],
-            [96u8, 40u8, 191u8, 212u8],
-            [102u8, 24u8, 132u8, 99u8],
-            [103u8, 154u8, 239u8, 206u8],
             [112u8, 160u8, 130u8, 49u8],
-            [116u8, 243u8, 176u8, 9u8],
             [126u8, 206u8, 190u8, 0u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [135u8, 236u8, 104u8, 23u8],
-            [137u8, 61u8, 32u8, 232u8],
-            [141u8, 146u8, 138u8, 248u8],
             [149u8, 216u8, 155u8, 65u8],
-            [155u8, 2u8, 205u8, 222u8],
-            [157u8, 44u8, 17u8, 12u8],
             [169u8, 5u8, 156u8, 187u8],
-            [170u8, 171u8, 173u8, 197u8],
-            [192u8, 255u8, 26u8, 21u8],
             [213u8, 5u8, 172u8, 207u8],
-            [213u8, 192u8, 150u8, 196u8],
-            [215u8, 61u8, 214u8, 35u8],
             [221u8, 98u8, 237u8, 62u8],
             [248u8, 159u8, 39u8, 237u8],
         ];
@@ -7611,34 +3443,17 @@ pub mod BalancerV2WeightedPool {
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setPausedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPausedStateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolIdCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryExitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRateCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onExitPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <queryJoinCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getLastInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getInvariantCall as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onJoinPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
@@ -7646,34 +3461,17 @@ pub mod BalancerV2WeightedPool {
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(setPaused),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(getPausedState),
             ::core::stringify!(transferFrom),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(setSwapFeePercentage),
             ::core::stringify!(getPoolId),
             ::core::stringify!(getSwapFeePercentage),
-            ::core::stringify!(queryExit),
-            ::core::stringify!(decreaseApproval),
-            ::core::stringify!(getRate),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(onExitPool),
             ::core::stringify!(nonces),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(queryJoin),
-            ::core::stringify!(getOwner),
-            ::core::stringify!(getVault),
             ::core::stringify!(symbol),
-            ::core::stringify!(getLastInvariant),
-            ::core::stringify!(onSwap),
             ::core::stringify!(transfer),
-            ::core::stringify!(getAuthorizer),
-            ::core::stringify!(getInvariant),
             ::core::stringify!(permit),
-            ::core::stringify!(onJoinPool),
-            ::core::stringify!(increaseApproval),
             ::core::stringify!(allowance),
             ::core::stringify!(getNormalizedWeights),
         ];
@@ -7700,7 +3498,7 @@ pub mod BalancerV2WeightedPool {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolCalls {
-        const COUNT: usize = 32usize;
+        const COUNT: usize = 15usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2WeightedPoolCalls";
 
@@ -7714,45 +3512,20 @@ pub mod BalancerV2WeightedPool {
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseApproval(_) => {
-                    <decreaseApprovalCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getInvariant(_) => <getInvariantCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getLastInvariant(_) => {
-                    <getLastInvariantCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::getNormalizedWeights(_) => {
                     <getNormalizedWeightsCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getOwner(_) => <getOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getPausedState(_) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::getPoolId(_) => <getPoolIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getRate(_) => <getRateCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getSwapFeePercentage(_) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::increaseApproval(_) => {
-                    <increaseApprovalCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onExitPool(_) => <onExitPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onJoinPool(_) => <onJoinPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::onSwap(_) => <onSwapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryExit(_) => <queryExitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::queryJoin(_) => <queryJoinCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setPaused(_) => <setPausedCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setSwapFeePercentage(_) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -7791,24 +3564,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     approve
                 },
-                {
-                    fn setPaused(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -7840,125 +3595,44 @@ pub mod BalancerV2WeightedPool {
                     fn DOMAIN_SEPARATOR(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::DOMAIN_SEPARATOR)
-                    }
-                    DOMAIN_SEPARATOR
-                },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
-                {
-                    fn getPoolId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getPoolId)
-                    }
-                    getPoolId
-                },
-                {
-                    fn getSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getSwapFeePercentage)
-                    }
-                    getSwapFeePercentage
-                },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn decreaseApproval(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::decreaseApproval)
-                    }
-                    decreaseApproval
-                },
-                {
-                    fn getRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getRate)
-                    }
-                    getRate
-                },
-                {
-                    fn balanceOf(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::balanceOf)
-                    }
-                    balanceOf
-                },
-                {
-                    fn onExitPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
-                {
-                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::nonces)
+                        <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::DOMAIN_SEPARATOR)
                     }
-                    nonces
+                    DOMAIN_SEPARATOR
                 },
                 {
-                    fn getActionId(
+                    fn getPoolId(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getActionId)
+                        <getPoolIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getPoolId)
                     }
-                    getActionId
+                    getPoolId
                 },
                 {
-                    fn queryJoin(
+                    fn getSwapFeePercentage(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::queryJoin)
+                        <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::getSwapFeePercentage)
                     }
-                    queryJoin
+                    getSwapFeePercentage
                 },
                 {
-                    fn getOwner(
+                    fn balanceOf(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getOwner)
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::balanceOf)
                     }
-                    getOwner
+                    balanceOf
                 },
                 {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getVault)
+                    fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
+                        <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(BalancerV2WeightedPoolCalls::nonces)
                     }
-                    getVault
+                    nonces
                 },
                 {
                     fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
@@ -7967,22 +3641,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     symbol
                 },
-                {
-                    fn getLastInvariant(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getLastInvariant)
-                    }
-                    getLastInvariant
-                },
-                {
-                    fn onSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::onSwap)
-                    }
-                    onSwap
-                },
                 {
                     fn transfer(
                         data: &[u8],
@@ -7992,24 +3650,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
-                {
-                    fn getInvariant(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::getInvariant)
-                    }
-                    getInvariant
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8017,24 +3657,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
-                {
-                    fn increaseApproval(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <increaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolCalls::increaseApproval)
-                    }
-                    increaseApproval
-                },
                 {
                     fn allowance(
                         data: &[u8],
@@ -8090,24 +3712,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     approve
                 },
-                {
-                    fn setPaused(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <setPausedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::setPaused)
-                    }
-                    setPaused
-                },
-                {
-                    fn totalSupply(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn getPausedState(
                         data: &[u8],
@@ -8150,17 +3754,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn setSwapFeePercentage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2WeightedPoolCalls::setSwapFeePercentage)
-                    }
-                    setSwapFeePercentage
-                },
                 {
                     fn getPoolId(
                         data: &[u8],
@@ -8181,35 +3774,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     getSwapFeePercentage
                 },
-                {
-                    fn queryExit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <queryExitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::queryExit)
-                    }
-                    queryExit
-                },
-                {
-                    fn decreaseApproval(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolCalls::decreaseApproval)
-                    }
-                    decreaseApproval
-                },
-                {
-                    fn getRate(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getRateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::getRate)
-                    }
-                    getRate
-                },
                 {
                     fn balanceOf(
                         data: &[u8],
@@ -8219,15 +3783,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     balanceOf
                 },
-                {
-                    fn onExitPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <onExitPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::onExitPool)
-                    }
-                    onExitPool
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8235,42 +3790,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     nonces
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn queryJoin(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <queryJoinCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::queryJoin)
-                    }
-                    queryJoin
-                },
-                {
-                    fn getOwner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::getOwner)
-                    }
-                    getOwner
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::getVault)
-                    }
-                    getVault
-                },
                 {
                     fn symbol(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
                         <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8278,24 +3797,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     symbol
                 },
-                {
-                    fn getLastInvariant(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getLastInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolCalls::getLastInvariant)
-                    }
-                    getLastInvariant
-                },
-                {
-                    fn onSwap(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <onSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::onSwap)
-                    }
-                    onSwap
-                },
                 {
                     fn transfer(
                         data: &[u8],
@@ -8305,28 +3806,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     transfer
                 },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolCalls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
-                {
-                    fn getInvariant(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <getInvariantCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolCalls::getInvariant)
-                    }
-                    getInvariant
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8334,26 +3813,6 @@ pub mod BalancerV2WeightedPool {
                     }
                     permit
                 },
-                {
-                    fn onJoinPool(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <onJoinPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolCalls::onJoinPool)
-                    }
-                    onJoinPool
-                },
-                {
-                    fn increaseApproval(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolCalls> {
-                        <increaseApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolCalls::increaseApproval)
-                    }
-                    increaseApproval
-                },
                 {
                     fn allowance(
                         data: &[u8],
@@ -8402,81 +3861,30 @@ pub mod BalancerV2WeightedPool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decreaseApproval(inner) => {
-                    <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getInvariant(inner) => {
-                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getLastInvariant(inner) => {
-                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getNormalizedWeights(inner) => {
                     <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::getPoolId(inner) => {
                     <getPoolIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getSwapFeePercentage(inner) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::increaseApproval(inner) => {
-                    <increaseApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onSwap(inner) => {
-                    <onSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -8504,87 +3912,34 @@ pub mod BalancerV2WeightedPool {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::decreaseApproval(inner) => {
-                    <decreaseApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getInvariant(inner) => {
-                    <getInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getLastInvariant(inner) => {
-                    <getLastInvariantCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getNormalizedWeights(inner) => {
                     <getNormalizedWeightsCall as alloy_sol_types::SolCall>::abi_encode_raw(
                         inner, out,
                     )
                 }
-                Self::getOwner(inner) => {
-                    <getOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getPausedState(inner) => {
                     <getPausedStateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::getPoolId(inner) => {
                     <getPoolIdCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getRate(inner) => {
-                    <getRateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getSwapFeePercentage(inner) => {
                     <getSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
                         inner, out,
                     )
                 }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::increaseApproval(inner) => {
-                    <increaseApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::nonces(inner) => {
                     <noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onExitPool(inner) => {
-                    <onExitPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::onJoinPool(inner) => {
-                    <onJoinPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::onSwap(inner) => {
-                    <onSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::queryExit(inner) => {
-                    <queryExitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::queryJoin(inner) => {
-                    <queryJoinCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setPaused(inner) => {
-                    <setPausedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setSwapFeePercentage(inner) => {
-                    <setSwapFeePercentageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -8890,40 +4245,6 @@ pub mod BalancerV2WeightedPool {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`decreaseApproval`] function.
-        pub fn decreaseApproval(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            amount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseApprovalCall, N> {
-            self.call_builder(&decreaseApprovalCall { spender, amount })
-        }
-
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getInvariant`] function.
-        pub fn getInvariant(&self) -> alloy_contract::SolCallBuilder<&P, getInvariantCall, N> {
-            self.call_builder(&getInvariantCall)
-        }
-
-        ///Creates a new call builder for the [`getLastInvariant`] function.
-        pub fn getLastInvariant(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getLastInvariantCall, N> {
-            self.call_builder(&getLastInvariantCall)
-        }
-
         ///Creates a new call builder for the [`getNormalizedWeights`]
         /// function.
         pub fn getNormalizedWeights(
@@ -8932,11 +4253,6 @@ pub mod BalancerV2WeightedPool {
             self.call_builder(&getNormalizedWeightsCall)
         }
 
-        ///Creates a new call builder for the [`getOwner`] function.
-        pub fn getOwner(&self) -> alloy_contract::SolCallBuilder<&P, getOwnerCall, N> {
-            self.call_builder(&getOwnerCall)
-        }
-
         ///Creates a new call builder for the [`getPausedState`] function.
         pub fn getPausedState(&self) -> alloy_contract::SolCallBuilder<&P, getPausedStateCall, N> {
             self.call_builder(&getPausedStateCall)
@@ -8947,11 +4263,6 @@ pub mod BalancerV2WeightedPool {
             self.call_builder(&getPoolIdCall)
         }
 
-        ///Creates a new call builder for the [`getRate`] function.
-        pub fn getRate(&self) -> alloy_contract::SolCallBuilder<&P, getRateCall, N> {
-            self.call_builder(&getRateCall)
-        }
-
         ///Creates a new call builder for the [`getSwapFeePercentage`]
         /// function.
         pub fn getSwapFeePercentage(
@@ -8960,20 +4271,6 @@ pub mod BalancerV2WeightedPool {
             self.call_builder(&getSwapFeePercentageCall)
         }
 
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`increaseApproval`] function.
-        pub fn increaseApproval(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            amount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseApprovalCall, N> {
-            self.call_builder(&increaseApprovalCall { spender, amount })
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -8987,68 +4284,6 @@ pub mod BalancerV2WeightedPool {
             self.call_builder(&noncesCall { owner })
         }
 
-        ///Creates a new call builder for the [`onExitPool`] function.
-        pub fn onExitPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onExitPoolCall, N> {
-            self.call_builder(&onExitPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onJoinPool`] function.
-        pub fn onJoinPool(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onJoinPoolCall, N> {
-            self.call_builder(&onJoinPoolCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`onSwap`] function.
-        pub fn onSwap(
-            &self,
-            request: <IPoolSwapStructs::SwapRequest as alloy_sol_types::SolType>::RustType,
-            balanceTokenIn: alloy_sol_types::private::primitives::aliases::U256,
-            balanceTokenOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, onSwapCall, N> {
-            self.call_builder(&onSwapCall {
-                request,
-                balanceTokenIn,
-                balanceTokenOut,
-            })
-        }
-
         ///Creates a new call builder for the [`permit`] function.
         pub fn permit(
             &self,
@@ -9071,81 +4306,11 @@ pub mod BalancerV2WeightedPool {
             })
         }
 
-        ///Creates a new call builder for the [`queryExit`] function.
-        pub fn queryExit(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryExitCall, N> {
-            self.call_builder(&queryExitCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`queryJoin`] function.
-        pub fn queryJoin(
-            &self,
-            poolId: alloy_sol_types::private::FixedBytes<32>,
-            sender: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            balances: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-            lastChangeBlock: alloy_sol_types::private::primitives::aliases::U256,
-            protocolSwapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, queryJoinCall, N> {
-            self.call_builder(&queryJoinCall {
-                poolId,
-                sender,
-                recipient,
-                balances,
-                lastChangeBlock,
-                protocolSwapFeePercentage,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`setPaused`] function.
-        pub fn setPaused(
-            &self,
-            paused: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, setPausedCall, N> {
-            self.call_builder(&setPausedCall { paused })
-        }
-
-        ///Creates a new call builder for the [`setSwapFeePercentage`]
-        /// function.
-        pub fn setSwapFeePercentage(
-            &self,
-            swapFeePercentage: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, setSwapFeePercentageCall, N> {
-            self.call_builder(&setSwapFeePercentageCall { swapFeePercentage })
-        }
-
         ///Creates a new call builder for the [`symbol`] function.
         pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs
index a5724c48d5..e6f5149677 100644
--- a/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2weightedpool2tokensfactory/src/lib.rs
@@ -16,9 +16,6 @@ interface BalancerV2WeightedPool2TokensFactory {
     constructor(address vault);
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, bool oracleEnabled, address owner) external returns (address);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getVault() external view returns (address);
-    function isPoolFromFactory(address pool) external view returns (bool);
 }
 ```
 
@@ -85,56 +82,6 @@ interface BalancerV2WeightedPool2TokensFactory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "PoolCreated",
@@ -556,452 +503,12 @@ pub mod BalancerV2WeightedPool2TokensFactory {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
     ///Container for all the [`BalancerV2WeightedPool2TokensFactory`](self)
     /// function calls.
     #[derive(Clone)]
     pub enum BalancerV2WeightedPool2TokensFactoryCalls {
         #[allow(missing_docs)]
         create(createCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
     }
     impl BalancerV2WeightedPool2TokensFactoryCalls {
         /// All the selectors of this enum.
@@ -1011,26 +518,12 @@ pub mod BalancerV2WeightedPool2TokensFactory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [21u8, 150u8, 1u8, 155u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [141u8, 146u8, 138u8, 248u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[21u8, 150u8, 1u8, 155u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<createCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(create),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(getVault),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(create)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1054,21 +547,14 @@ pub mod BalancerV2WeightedPool2TokensFactory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2WeightedPool2TokensFactoryCalls {
-        const COUNT: usize = 4usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 352usize;
         const NAME: &'static str = "BalancerV2WeightedPool2TokensFactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -1089,50 +575,16 @@ pub mod BalancerV2WeightedPool2TokensFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPool2TokensFactoryCalls,
-            >] = &[
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPool2TokensFactoryCalls::create)
-                    }
-                    create
-                },
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
                 {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPool2TokensFactoryCalls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPool2TokensFactoryCalls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPool2TokensFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-            ];
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(BalancerV2WeightedPool2TokensFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1152,56 +604,16 @@ pub mod BalancerV2WeightedPool2TokensFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPool2TokensFactoryCalls,
-            >] = &[
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPool2TokensFactoryCalls::create)
-                    }
-                    create
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPool2TokensFactoryCalls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
                 {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPool2TokensFactoryCalls::isPoolFromFactory,
-                            )
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPool2TokensFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPool2TokensFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-            ];
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(BalancerV2WeightedPool2TokensFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1217,15 +629,6 @@ pub mod BalancerV2WeightedPool2TokensFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -1235,17 +638,6 @@ pub mod BalancerV2WeightedPool2TokensFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -1539,27 +931,6 @@ pub mod BalancerV2WeightedPool2TokensFactory {
                 owner,
             })
         }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs
index 65d9512e70..d735a11363 100644
--- a/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactory/src/lib.rs
@@ -16,9 +16,6 @@ interface BalancerV2WeightedPoolFactory {
     constructor(address vault);
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory weights, uint256 swapFeePercentage, address owner) external returns (address);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getVault() external view returns (address);
-    function isPoolFromFactory(address pool) external view returns (bool);
 }
 ```
 
@@ -80,56 +77,6 @@ interface BalancerV2WeightedPoolFactory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "PoolCreated",
@@ -541,452 +488,12 @@ pub mod BalancerV2WeightedPoolFactory {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
     ///Container for all the [`BalancerV2WeightedPoolFactory`](self) function
     /// calls.
     #[derive(Clone)]
     pub enum BalancerV2WeightedPoolFactoryCalls {
         #[allow(missing_docs)]
         create(createCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
     }
     impl BalancerV2WeightedPoolFactoryCalls {
         /// All the selectors of this enum.
@@ -996,26 +503,12 @@ pub mod BalancerV2WeightedPoolFactory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [45u8, 164u8, 124u8, 64u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [251u8, 206u8, 3u8, 147u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[251u8, 206u8, 3u8, 147u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<createCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(getVault),
-            ::core::stringify!(create),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(create)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1039,21 +532,14 @@ pub mod BalancerV2WeightedPoolFactory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolFactoryCalls {
-        const COUNT: usize = 4usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 320usize;
         const NAME: &'static str = "BalancerV2WeightedPoolFactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -1074,50 +560,15 @@ pub mod BalancerV2WeightedPoolFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPoolFactoryCalls,
-            >] = &[
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryCalls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryCalls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryCalls::create)
-                    }
-                    create
-                },
-            ];
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls> {
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(BalancerV2WeightedPoolFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1137,54 +588,15 @@ pub mod BalancerV2WeightedPoolFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPoolFactoryCalls,
-            >] = &[
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryCalls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2WeightedPoolFactoryCalls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryCalls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn create(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls>
-                    {
-                        <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryCalls::create)
-                    }
-                    create
-                },
-            ];
+            >] = &[{
+                fn create(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryCalls> {
+                    <createCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(BalancerV2WeightedPoolFactoryCalls::create)
+                }
+                create
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1200,15 +612,6 @@ pub mod BalancerV2WeightedPoolFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -1218,17 +621,6 @@ pub mod BalancerV2WeightedPoolFactory {
                 Self::create(inner) => {
                     <createCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -1516,27 +908,6 @@ pub mod BalancerV2WeightedPoolFactory {
                 owner,
             })
         }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs
index 572cd6089d..ed8832987d 100644
--- a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv3/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2WeightedPoolFactoryV3 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory normalizedWeights, address[] memory rateProviders, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -117,158 +107,6 @@ interface BalancerV2WeightedPoolFactoryV3 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -968,24 +806,21 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -998,9 +833,9 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1012,25 +847,25 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1042,29 +877,29 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1075,27 +910,19 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1107,1511 +934,59 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2WeightedPoolFactoryV3`](self) function
+    /// calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2WeightedPoolFactoryV3Calls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2WeightedPoolFactoryV3Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [128u8, 119u8, 58u8, 147u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2WeightedPoolFactoryV3`](self) function
-    /// calls.
-    #[derive(Clone)]
-    pub enum BalancerV2WeightedPoolFactoryV3Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2WeightedPoolFactoryV3Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [128u8, 119u8, 58u8, 147u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(create),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2624,7 +999,7 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolFactoryV3Calls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2WeightedPoolFactoryV3Calls";
 
@@ -2633,28 +1008,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2677,40 +1030,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPoolFactoryV3Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV3Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV3Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2721,16 +1040,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2741,40 +1050,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV3Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2785,36 +1060,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     }
                     create
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2836,46 +1081,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPoolFactoryV3Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV3Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV3Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV3Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2886,18 +1091,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV3Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2908,42 +1101,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV3Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2954,38 +1111,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                     }
                     create
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryV3Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV3Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV3Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3005,52 +1130,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3066,66 +1145,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3383,73 +1402,6 @@ pub mod BalancerV2WeightedPoolFactoryV3 {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs
index f60555694f..792af07fa8 100644
--- a/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv2weightedpoolfactoryv4/src/lib.rs
@@ -18,16 +18,6 @@ interface BalancerV2WeightedPoolFactoryV4 {
 
     function create(string memory name, string memory symbol, address[] memory tokens, uint256[] memory normalizedWeights, address[] memory rateProviders, uint256 swapFeePercentage, address owner) external returns (address);
     function disable() external;
-    function getActionId(bytes4 selector) external view returns (bytes32);
-    function getAuthorizer() external view returns (address);
-    function getCreationCode() external view returns (bytes memory);
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    function getPoolVersion() external view returns (string memory);
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    function getVault() external view returns (address);
-    function isDisabled() external view returns (bool);
-    function isPoolFromFactory(address pool) external view returns (bool);
     function version() external view returns (string memory);
 }
 ```
@@ -117,158 +107,6 @@ interface BalancerV2WeightedPoolFactoryV4 {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getActionId",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAuthorizer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IAuthorizer"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getCreationCodeContracts",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "contractA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "contractB",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPauseConfiguration",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "pauseWindowDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "bufferPeriodDuration",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPoolVersion",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeePercentagesProvider",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IProtocolFeePercentagesProvider"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getVault",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVault"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isDisabled",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isPoolFromFactory",
-    "inputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "version",
@@ -968,24 +806,21 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getActionId(bytes4)` and selector `0x851c1bb3`.
+    /**Function with signature `version()` and selector `0x54fd4d50`.
     ```solidity
-    function getActionId(bytes4 selector) external view returns (bytes32);
+    function version() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct versionCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getActionId(bytes4)`](getActionIdCall) function.
+    /// [`version()`](versionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getActionIdReturn {
+    pub struct versionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -998,9 +833,9 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1012,25 +847,25 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdCall) -> Self {
-                    (value.selector,)
+            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: versionCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1042,29 +877,29 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getActionIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getActionIdReturn) -> Self {
+            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: versionReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getActionIdReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getActionIdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for versionCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [133u8, 28u8, 27u8, 179u8];
-            const SIGNATURE: &'static str = "getActionId(bytes4)";
+            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
+            const SIGNATURE: &'static str = "version()";
 
             #[inline]
             fn new<'a>(
@@ -1075,27 +910,19 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getActionIdReturn = r.into();
+                        let r: versionReturn = r.into();
                         r._0
                     },
                 )
@@ -1107,1511 +934,59 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     data,
                 )
                 .map(|r| {
-                    let r: getActionIdReturn = r.into();
+                    let r: versionReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAuthorizer()` and selector `0xaaabadc5`.
-    ```solidity
-    function getAuthorizer() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAuthorizerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAuthorizer()`](getAuthorizerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    ///Container for all the [`BalancerV2WeightedPoolFactoryV4`](self) function
+    /// calls.
     #[derive(Clone)]
-    pub struct getAuthorizerReturn {
+    pub enum BalancerV2WeightedPoolFactoryV4Calls {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        create(createCall),
+        #[allow(missing_docs)]
+        disable(disableCall),
+        #[allow(missing_docs)]
+        version(versionCall),
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+    impl BalancerV2WeightedPoolFactoryV4Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [47u8, 39u8, 112u8, 219u8],
+            [84u8, 253u8, 77u8, 80u8],
+            [128u8, 119u8, 58u8, 147u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(disable),
+            ::core::stringify!(version),
+            ::core::stringify!(create),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
                 }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAuthorizerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAuthorizerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAuthorizerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAuthorizerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 171u8, 173u8, 197u8];
-            const SIGNATURE: &'static str = "getAuthorizer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAuthorizerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAuthorizerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCode()` and selector `0x00c194db`.
-    ```solidity
-    function getCreationCode() external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCode()`](getCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [0u8, 193u8, 148u8, 219u8];
-            const SIGNATURE: &'static str = "getCreationCode()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getCreationCodeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getCreationCodeContracts()` and selector `0x174481fa`.
-    ```solidity
-    function getCreationCodeContracts() external view returns (address contractA, address contractB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getCreationCodeContracts()`](getCreationCodeContractsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getCreationCodeContractsReturn {
-        #[allow(missing_docs)]
-        pub contractA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub contractB: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getCreationCodeContractsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getCreationCodeContractsReturn) -> Self {
-                    (value.contractA, value.contractB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCreationCodeContractsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        contractA: tuple.0,
-                        contractB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getCreationCodeContractsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getCreationCodeContractsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.contractB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getCreationCodeContractsCall {
-            type Parameters<'a> = ();
-            type Return = getCreationCodeContractsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 68u8, 129u8, 250u8];
-            const SIGNATURE: &'static str = "getCreationCodeContracts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getCreationCodeContractsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPauseConfiguration()` and selector `0x2da47c40`.
-    ```solidity
-    function getPauseConfiguration() external view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPauseConfiguration()`](getPauseConfigurationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPauseConfigurationReturn {
-        #[allow(missing_docs)]
-        pub pauseWindowDuration: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub bufferPeriodDuration: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPauseConfigurationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPauseConfigurationReturn) -> Self {
-                    (value.pauseWindowDuration, value.bufferPeriodDuration)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPauseConfigurationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pauseWindowDuration: tuple.0,
-                        bufferPeriodDuration: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPauseConfigurationReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getPauseConfigurationCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pauseWindowDuration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.bufferPeriodDuration,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPauseConfigurationCall {
-            type Parameters<'a> = ();
-            type Return = getPauseConfigurationReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [45u8, 164u8, 124u8, 64u8];
-            const SIGNATURE: &'static str = "getPauseConfiguration()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPauseConfigurationReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPoolVersion()` and selector `0x3f819b6f`.
-    ```solidity
-    function getPoolVersion() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPoolVersion()`](getPoolVersionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolVersionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolVersionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolVersionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolVersionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolVersionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 129u8, 155u8, 111u8];
-            const SIGNATURE: &'static str = "getPoolVersion()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolVersionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolVersionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeePercentagesProvider()` and selector `0x739238d6`.
-    ```solidity
-    function getProtocolFeePercentagesProvider() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeePercentagesProvider()`](getProtocolFeePercentagesProviderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeePercentagesProviderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeePercentagesProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeePercentagesProviderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeePercentagesProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeePercentagesProviderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [115u8, 146u8, 56u8, 214u8];
-            const SIGNATURE: &'static str = "getProtocolFeePercentagesProvider()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeePercentagesProviderReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeePercentagesProviderReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getVault()` and selector `0x8d928af8`.
-    ```solidity
-    function getVault() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getVault()`](getVaultCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getVaultReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getVaultReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getVaultReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getVaultReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getVaultCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 146u8, 138u8, 248u8];
-            const SIGNATURE: &'static str = "getVault()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getVaultReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getVaultReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isDisabled()` and selector `0x6c57f5a9`.
-    ```solidity
-    function isDisabled() external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isDisabled()`](isDisabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isDisabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isDisabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isDisabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isDisabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isDisabledCall {
-            type Parameters<'a> = ();
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [108u8, 87u8, 245u8, 169u8];
-            const SIGNATURE: &'static str = "isDisabled()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isDisabledReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isDisabledReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isPoolFromFactory(address)` and selector `0x6634b753`.
-    ```solidity
-    function isPoolFromFactory(address pool) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryCall {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isPoolFromFactory(address)`](isPoolFromFactoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isPoolFromFactoryReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryCall) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isPoolFromFactoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isPoolFromFactoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPoolFromFactoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isPoolFromFactoryCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [102u8, 52u8, 183u8, 83u8];
-            const SIGNATURE: &'static str = "isPoolFromFactory(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isPoolFromFactoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isPoolFromFactoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `version()` and selector `0x54fd4d50`.
-    ```solidity
-    function version() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`version()`](versionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct versionReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: versionCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: versionReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for versionCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
-            const SIGNATURE: &'static str = "version()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: versionReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: versionReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    ///Container for all the [`BalancerV2WeightedPoolFactoryV4`](self) function
-    /// calls.
-    #[derive(Clone)]
-    pub enum BalancerV2WeightedPoolFactoryV4Calls {
-        #[allow(missing_docs)]
-        create(createCall),
-        #[allow(missing_docs)]
-        disable(disableCall),
-        #[allow(missing_docs)]
-        getActionId(getActionIdCall),
-        #[allow(missing_docs)]
-        getAuthorizer(getAuthorizerCall),
-        #[allow(missing_docs)]
-        getCreationCode(getCreationCodeCall),
-        #[allow(missing_docs)]
-        getCreationCodeContracts(getCreationCodeContractsCall),
-        #[allow(missing_docs)]
-        getPauseConfiguration(getPauseConfigurationCall),
-        #[allow(missing_docs)]
-        getPoolVersion(getPoolVersionCall),
-        #[allow(missing_docs)]
-        getProtocolFeePercentagesProvider(getProtocolFeePercentagesProviderCall),
-        #[allow(missing_docs)]
-        getVault(getVaultCall),
-        #[allow(missing_docs)]
-        isDisabled(isDisabledCall),
-        #[allow(missing_docs)]
-        isPoolFromFactory(isPoolFromFactoryCall),
-        #[allow(missing_docs)]
-        version(versionCall),
-    }
-    impl BalancerV2WeightedPoolFactoryV4Calls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 193u8, 148u8, 219u8],
-            [23u8, 68u8, 129u8, 250u8],
-            [45u8, 164u8, 124u8, 64u8],
-            [47u8, 39u8, 112u8, 219u8],
-            [63u8, 129u8, 155u8, 111u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [102u8, 52u8, 183u8, 83u8],
-            [108u8, 87u8, 245u8, 169u8],
-            [115u8, 146u8, 56u8, 214u8],
-            [128u8, 119u8, 58u8, 147u8],
-            [133u8, 28u8, 27u8, 179u8],
-            [141u8, 146u8, 138u8, 248u8],
-            [170u8, 171u8, 173u8, 197u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPauseConfigurationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getPoolVersionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isDisabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getActionIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getVaultCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAuthorizerCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getCreationCode),
-            ::core::stringify!(getCreationCodeContracts),
-            ::core::stringify!(getPauseConfiguration),
-            ::core::stringify!(disable),
-            ::core::stringify!(getPoolVersion),
-            ::core::stringify!(version),
-            ::core::stringify!(isPoolFromFactory),
-            ::core::stringify!(isDisabled),
-            ::core::stringify!(getProtocolFeePercentagesProvider),
-            ::core::stringify!(create),
-            ::core::stringify!(getActionId),
-            ::core::stringify!(getVault),
-            ::core::stringify!(getAuthorizer),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
             }
         }
 
@@ -2624,7 +999,7 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV2WeightedPoolFactoryV4Calls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV2WeightedPoolFactoryV4Calls";
 
@@ -2633,28 +1008,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
             match self {
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::disable(_) => <disableCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getActionId(_) => <getActionIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAuthorizer(_) => <getAuthorizerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getCreationCode(_) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getCreationCodeContracts(_) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPauseConfiguration(_) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getPoolVersion(_) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeePercentagesProvider(_) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getVault(_) => <getVaultCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isDisabled(_) => <isDisabledCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isPoolFromFactory(_) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -2677,40 +1030,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPoolFactoryV4Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV4Calls::getCreationCodeContracts)
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV4Calls::getPauseConfiguration)
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2721,16 +1040,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2741,40 +1050,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV4Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2785,36 +1060,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     }
                     create
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2836,46 +1081,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
             ) -> alloy_sol_types::Result<
                 BalancerV2WeightedPoolFactoryV4Calls,
             >] = &[
-                {
-                    fn getCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV4Calls::getCreationCode)
-                    }
-                    getCreationCode
-                },
-                {
-                    fn getCreationCodeContracts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV4Calls::getCreationCodeContracts,
-                            )
-                    }
-                    getCreationCodeContracts
-                },
-                {
-                    fn getPauseConfiguration(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV4Calls::getPauseConfiguration,
-                            )
-                    }
-                    getPauseConfiguration
-                },
                 {
                     fn disable(
                         data: &[u8],
@@ -2886,18 +1091,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     }
                     disable
                 },
-                {
-                    fn getPoolVersion(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getPoolVersionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV4Calls::getPoolVersion)
-                    }
-                    getPoolVersion
-                },
                 {
                     fn version(
                         data: &[u8],
@@ -2908,42 +1101,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     }
                     version
                 },
-                {
-                    fn isPoolFromFactory(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::isPoolFromFactory)
-                    }
-                    isPoolFromFactory
-                },
-                {
-                    fn isDisabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <isDisabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::isDisabled)
-                    }
-                    isDisabled
-                },
-                {
-                    fn getProtocolFeePercentagesProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BalancerV2WeightedPoolFactoryV4Calls::getProtocolFeePercentagesProvider,
-                            )
-                    }
-                    getProtocolFeePercentagesProvider
-                },
                 {
                     fn create(
                         data: &[u8],
@@ -2954,38 +1111,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                     }
                     create
                 },
-                {
-                    fn getActionId(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getActionIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getActionId)
-                    }
-                    getActionId
-                },
-                {
-                    fn getVault(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getVaultCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV2WeightedPoolFactoryV4Calls::getVault)
-                    }
-                    getVault
-                },
-                {
-                    fn getAuthorizer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV2WeightedPoolFactoryV4Calls>
-                    {
-                        <getAuthorizerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV2WeightedPoolFactoryV4Calls::getAuthorizer)
-                    }
-                    getAuthorizer
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -3005,52 +1130,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3066,66 +1145,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
                 Self::disable(inner) => {
                     <disableCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getActionId(inner) => {
-                    <getActionIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAuthorizer(inner) => {
-                    <getAuthorizerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCode(inner) => {
-                    <getCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getCreationCodeContracts(inner) => {
-                    <getCreationCodeContractsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPauseConfiguration(inner) => {
-                    <getPauseConfigurationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getPoolVersion(inner) => {
-                    <getPoolVersionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeePercentagesProvider(inner) => {
-                    <getProtocolFeePercentagesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getVault(inner) => {
-                    <getVaultCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isDisabled(inner) => {
-                    <isDisabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isPoolFromFactory(inner) => {
-                    <isPoolFromFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3383,73 +1402,6 @@ pub mod BalancerV2WeightedPoolFactoryV4 {
             self.call_builder(&disableCall)
         }
 
-        ///Creates a new call builder for the [`getActionId`] function.
-        pub fn getActionId(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getActionIdCall, N> {
-            self.call_builder(&getActionIdCall { selector })
-        }
-
-        ///Creates a new call builder for the [`getAuthorizer`] function.
-        pub fn getAuthorizer(&self) -> alloy_contract::SolCallBuilder<&P, getAuthorizerCall, N> {
-            self.call_builder(&getAuthorizerCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCode`] function.
-        pub fn getCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeCall, N> {
-            self.call_builder(&getCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`getCreationCodeContracts`]
-        /// function.
-        pub fn getCreationCodeContracts(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getCreationCodeContractsCall, N> {
-            self.call_builder(&getCreationCodeContractsCall)
-        }
-
-        ///Creates a new call builder for the [`getPauseConfiguration`]
-        /// function.
-        pub fn getPauseConfiguration(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getPauseConfigurationCall, N> {
-            self.call_builder(&getPauseConfigurationCall)
-        }
-
-        ///Creates a new call builder for the [`getPoolVersion`] function.
-        pub fn getPoolVersion(&self) -> alloy_contract::SolCallBuilder<&P, getPoolVersionCall, N> {
-            self.call_builder(&getPoolVersionCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`getProtocolFeePercentagesProvider`] function.
-        pub fn getProtocolFeePercentagesProvider(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeePercentagesProviderCall, N> {
-            self.call_builder(&getProtocolFeePercentagesProviderCall)
-        }
-
-        ///Creates a new call builder for the [`getVault`] function.
-        pub fn getVault(&self) -> alloy_contract::SolCallBuilder<&P, getVaultCall, N> {
-            self.call_builder(&getVaultCall)
-        }
-
-        ///Creates a new call builder for the [`isDisabled`] function.
-        pub fn isDisabled(&self) -> alloy_contract::SolCallBuilder<&P, isDisabledCall, N> {
-            self.call_builder(&isDisabledCall)
-        }
-
-        ///Creates a new call builder for the [`isPoolFromFactory`] function.
-        pub fn isPoolFromFactory(
-            &self,
-            pool: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isPoolFromFactoryCall, N> {
-            self.call_builder(&isPoolFromFactoryCall { pool })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs b/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs
index 29f345628c..3aab955dfa 100644
--- a/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/balancerv3batchrouter/src/lib.rs
@@ -6,14 +6,180 @@
     non_snake_case
 )]
 //! Auto-generated contract bindings. Do not edit.
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
-library IAllowanceTransfer {
-    struct PermitBatch { PermitDetails[] details; address spender; uint256 sigDeadline; }
-    struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
+interface BalancerV3BatchRouter {
+    error AddressEmptyCode(address target);
+    error AddressInsufficientBalance(address account);
+    error ErrorSelectorNotFound();
+    error EthTransfer();
+    error FailedInnerCall();
+    error InputLengthMismatch();
+    error InsufficientEth();
+    error ReentrancyGuardReentrantCall();
+    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
+    error SafeERC20FailedOperation(address token);
+    error SenderIsNotVault(address sender);
+    error SwapDeadline();
+    error TransientIndexOutOfBounds();
+
+    constructor(address vault, address weth, address permit2, string routerVersion);
+
+    receive() external payable;
+
+    function version() external view returns (string memory);
 }
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "vault",
+        "type": "address",
+        "internalType": "contract IVault"
+      },
+      {
+        "name": "weth",
+        "type": "address",
+        "internalType": "contract IWETH"
+      },
+      {
+        "name": "permit2",
+        "type": "address",
+        "internalType": "contract IPermit2"
+      },
+      {
+        "name": "routerVersion",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "receive",
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "version",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "error",
+    "name": "AddressEmptyCode",
+    "inputs": [
+      {
+        "name": "target",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "AddressInsufficientBalance",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ErrorSelectorNotFound",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "EthTransfer",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "FailedInnerCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InputLengthMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InsufficientEth",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReentrancyGuardReentrantCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SafeCastOverflowedUintDowncast",
+    "inputs": [
+      {
+        "name": "bits",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SafeERC20FailedOperation",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SenderIsNotVault",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SwapDeadline",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "TransientIndexOutOfBounds",
+    "inputs": []
+  }
+]
 ```*/
 #[allow(
     non_camel_case_types,
@@ -22,4513 +188,39 @@ library IAllowanceTransfer {
     clippy::style,
     clippy::empty_structs_with_brackets
 )]
-pub mod IAllowanceTransfer {
+pub mod BalancerV3BatchRouter {
     use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\xC0`@\x90\x80\x82R4a\x05\xC9WaK\xBD\x808\x03\x80\x91a\0\x1F\x82\x85a\x05\xE8V[\x839\x81\x01\x91`\x80\x82\x84\x03\x12a\x05\xC9W\x81Q`\x01`\x01`\xA0\x1B\x03\x93\x90\x84\x81\x16\x81\x03a\x05\xC9W` \x93\x84\x81\x01Q\x92\x86\x84\x16\x84\x03a\x05\xC9W\x84\x82\x01Q\x96\x87\x16\x87\x03a\x05\xC9W``\x82\x01Q`\x01`\x01`@\x1B\x03\x92\x83\x82\x11a\x05\xC9W\x01\x92`\x1F\x90\x82\x82\x86\x01\x12\x15a\x05\xC9W\x84Q\x84\x81\x11a\x05\xB5W`\x1F\x19\x95\x88Q\x94a\0\xA5\x8B\x89\x87\x86\x01\x16\x01\x87a\x05\xE8V[\x82\x86R\x8A\x83\x83\x01\x01\x11a\x05\xC9W\x81_\x92\x8B\x80\x93\x01\x83\x88\x01^\x85\x01\x01R`\x80R\x81Q\x92\x83\x11a\x05\xB5W_T\x91`\x01\x92\x83\x81\x81\x1C\x91\x16\x80\x15a\x05\xABW[\x89\x82\x10\x14a\x05\x97W\x82\x81\x11a\x05TW[P\x87\x91\x84\x11`\x01\x14a\x04\xF7W\x83\x94P\x90\x83\x92\x91_\x94a\x04\xECW[PP\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17_U[a\x01Ia\x01&a\x06\x0BV[\x83Q\x90a\x012\x82a\x05\xCDV[`\x06\x82Re9\xB2\xB722\xB9`\xD1\x1B\x86\x83\x01Ra\x06iV[`\xA0Ra\x01\x85a\x01Wa\x06\x0BV[\x83Q\x90a\x01c\x82a\x05\xCDV[`\x11\x82Rp\x1A\\\xD4\x99]\x1D\\\x9B\x91]\x1A\x13\x1B\xD8\xDA\xD9Y`z\x1B\x86\x83\x01Ra\x06iV[`\xC0R`\xE0Ra\x01\0\x92\x83Ra\x01\xCD\x81Qa\x01\x9F\x81a\x05\xCDV[`\x13\x81R\x7FcurrentSwapTokensIn\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x82\x01Ra\x063V[\x91a\x01 \x92\x83Ra\x02\x10\x82Qa\x01\xE2\x81a\x05\xCDV[`\x14\x81R\x7FcurrentSwapTokensOut\0\0\0\0\0\0\0\0\0\0\0\0\x83\x82\x01Ra\x063V[a\x01@\x90\x81Ra\x02R\x83Qa\x02$\x81a\x05\xCDV[`\x19\x81R\x7FcurrentSwapTokenInAmounts\0\0\0\0\0\0\0\x84\x82\x01Ra\x063V[\x90a\x01`\x91\x82Ra\x02\xD8a\x02\x98\x85Qa\x02j\x81a\x05\xCDV[`\x1A\x81R\x7FcurrentSwapTokenOutAmounts\0\0\0\0\0\0\x86\x82\x01Ra\x063V[\x93a\x01\x80\x94\x85R\x7FsettledTokenAmounts\0\0\0\0\0\0\0\0\0\0\0\0\0\x86Q\x91a\x02\xCC\x83a\x05\xCDV[`\x13\x83R\x82\x01Ra\x063V[\x93a\x01\xA0\x94\x85RQ\x94aD\xA1\x96\x87a\x07\x1C\x889`\x80Q\x87\x81\x81a\x02F\x01R\x81\x81a\x19|\x01R\x81\x81a\x1B\xE0\x01R\x81\x81a\x1E\"\x01R\x81\x81a y\x01R\x81\x81a\"\x12\x01R\x81\x81a##\x01R\x81\x81a#\xB1\x01R\x81\x81a$s\x01R\x81\x81a*\xAD\x01R\x81\x81a,\x8C\x01R\x81\x81a,\xD4\x01R\x81\x81a-R\x01R\x81\x81a-\xF9\x01R\x81\x81a/\x07\x01R\x81\x81a/\x84\x01R\x81\x81a2\x19\x01R\x81\x81a3H\x01R\x81\x81a3\xE5\x01R\x81\x81a4\xAB\x01R\x81\x81a;l\x01R\x81\x81a<\x91\x01R\x81\x81a>\xD0\x01R\x81\x81a@\x15\x01RaBq\x01R`\xA0Q\x87\x81\x81a\x02\xAA\x01R\x81\x81a\x055\x01R\x81\x81a\x18\x1F\x01Ra(\xBE\x01R`\xC0Q\x87\x81\x81a\x17\xA9\x01Ra6\xBA\x01R`\xE0Q\x87\x81\x81`\"\x01R\x81\x81a:\xFE\x01R\x81\x81a=\xE4\x01R\x81\x81a?X\x01Ra@\xAF\x01RQ\x86\x81\x81a\t\xF0\x01R\x81\x81a\x0B\x04\x01R\x81\x81a\x1Fn\x01R\x81\x81a\x1F\xF4\x01R\x81\x81a0y\x01Ra<m\x01RQ\x85\x81\x81a%i\x01R\x81\x81a'P\x01R\x81\x81a)Z\x01Ra5\xD8\x01RQ\x84\x81\x81a\x1CC\x01R\x81\x81a\x1E\x8F\x01R\x81\x81a\"u\x01R\x81\x81a$\xD7\x01R\x81\x81a%\xCE\x01R\x81\x81a',\x01R\x81\x81a+\x12\x01Ra5\xA8\x01RQ\x83\x81\x81a\x1DC\x01R\x81\x81a%\x95\x01R\x81\x81a'|\x01R\x81\x81a2\x8E\x01R\x81\x81a5\t\x01Ra6+\x01RQ\x82\x81\x81a\x1Cl\x01R\x81\x81a\x1E\xC0\x01R\x81\x81a%\x01\x01R\x81\x81a&!\x01R\x81\x81a'\xB4\x01R\x81\x81a+Q\x01Ra2\xD0\x01RQ\x81\x81\x81a\"\x9F\x01R\x81\x81a%\xFF\x01R\x81\x81a+\x82\x01R\x81\x81a.V\x01Ra6\t\x01R\xF3[\x01Q\x92P_\x80a\x01\nV[\x91\x93\x83\x16\x91_\x80R\x83\x88_ \x93_[\x8A\x88\x83\x83\x10a\x05=WPPP\x10a\x05%W[PPP\x81\x1B\x01_Ua\x01\x1BV[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x05\x18V[\x86\x86\x01Q\x88U\x90\x96\x01\x95\x94\x85\x01\x94\x87\x93P\x01a\x05\x06V[_\x80R\x88_ \x83\x80\x87\x01`\x05\x1C\x82\x01\x92\x8B\x88\x10a\x05\x8EW[\x01`\x05\x1C\x01\x90\x84\x90[\x82\x81\x10a\x05\x83WPPa\0\xF0V[_\x81U\x01\x84\x90a\x05uV[\x92P\x81\x92a\x05lV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x90`\x7F\x16\x90a\0\xE0V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80\xFD[`@\x81\x01\x90\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17a\x05\xB5W`@RV[`\x1F\x90\x91\x01`\x1F\x19\x16\x81\x01\x90`\x01`\x01`@\x1B\x03\x82\x11\x90\x82\x10\x17a\x05\xB5W`@RV[`@Q\x90a\x06\x18\x82a\x05\xCDV[`\x0C\x82Rk)7\xBA\xBA2\xB9!\xB7\xB6\xB6\xB7\xB7`\xA1\x1B` \x83\x01RV[a\x06f\x90`@Qa\x06C\x81a\x05\xCDV[`\x11\x81Rp!0\xBA1\xB4)7\xBA\xBA2\xB9!\xB7\xB6\xB6\xB7\xB7`y\x1B` \x82\x01Ra\x06iV[\x90V[\x90a\x06\xD6`:` \x92`@Q\x93\x84\x91\x81\x80\x84\x01\x97\x7Fbalancer-labs.v3.storage.\0\0\0\0\0\0\0\x89R\x80Q\x91\x82\x91\x01`9\x86\x01^\x83\x01\x90`\x17`\xF9\x1B`9\x83\x01R\x80Q\x92\x83\x91\x01\x85\x83\x01^\x01_\x83\x82\x01R\x03`\x1A\x81\x01\x84R\x01\x82a\x05\xE8V[Q\x90 _\x19\x81\x01\x90\x81\x11a\x07\x07W`@Q\x90` \x82\x01\x90\x81R` \x82Ra\x06\xFC\x82a\x05\xCDV[\x90Q\x90 `\xFF\x19\x16\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD\xFE`\x80`@R`\x046\x10\x15a\0rW[6\x15a\0\x18W_\x80\xFD[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\0JW\0[\x7F\x05@\xDD\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[_5`\xE0\x1C\x80c\x08\xA4e\xF6\x14a\x0E\x9DW\x80c\x19\xC6\x98\x9F\x14a\x08NW\x80c(oX\r\x14a\x07\xB7W\x80c)P(n\x14a\x06\xCCW\x80cT\xFDMP\x14a\x05\x8FW\x80cZ<9\x87\x14a\x05fW\x80c^\x01\xEBZ\x14a\x05!W\x80c\x8A\x12\xA0\x8C\x14a\x04\xC6W\x80c\x8E\xB1\xB6^\x14a\x03\xBFW\x80c\x94^\xD3?\x14a\x03DW\x80c\xAC\x96P\xD8\x14a\x03\0Wc\xE3\xB5\xDF\xF4\x03a\0\x0EW4a\x02\xFCW``\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x01-\x906\x90`\x04\x01a\x12\xC4V[a\x015a\x11\xA1V[`D5\x92\x83\x11a\x02\xFCWa\x01Pa\x01X\x936\x90`\x04\x01a\x0F\xCDV[\x93\x90\x91a(\xB9V[\x90_[\x83Q\x81\x10\x15a\x01|W\x80_\x87a\x01s`\x01\x94\x88a\x16\x91V[Q\x01R\x01a\x01[V[Pa\x01\xF0a\x01\xFEa\x029\x94a\x01\xB6_\x94\x88`@Q\x93a\x01\x9A\x85a\x11\x1AV[0\x85R` \x85\x01R_\x19`@\x85\x01R\x86``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x8A\x12\xA0\x8C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[\x03`\x1F\x19\x81\x01\x83R\x82a\x11RV[`@Q\x80\x94\x81\x92\x7F\xED\xFA5h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x92a\x02\x8E\x91_\x91a\x02\xCFW[P` \x80\x82Q\x83\x01\x01\x91\x01a\x15\xD4V[\x90\x93\x91\x92a\x02\xA7W[`@Q\x93\x84\x93\x84a\x0F/V[\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]a\x02\x97V[a\x02\xEB\x91P=\x80_\x83>a\x02\xE3\x81\x83a\x11RV[\x81\x01\x90a\x15MV[\x84a\x02~V[`@Q=_\x82>=\x90\xFD[_\x80\xFD[` `\x03\x196\x01\x12a\x02\xFCW`\x045g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x038a\x032a\x02\xA3\x926\x90`\x04\x01a\x0F\x9CV[\x90a\x17\x9BV[`@Q\x91\x82\x91\x82a\x10 V[4a\x02\xFCWa\x03R6a\x0E\xCAV[a\x03Za\x19EV[a\x03ba\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a(\xFBV[\x91\x93\x90\x94a\x03\x8A``a\x03\x83\x83a\x13DV[\x92\x01a\x13XV[\x90a')V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]`@Q\x93\x84\x93\x84a\x0F/V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x03\xEC\x906\x90`\x04\x01a\x12\xC4V[\x90a\x03\xF5a\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x04Qa\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[a\x04%3a(\xB9V[\x97`@Q\x94a\x043\x86a\x11\x1AV[3\x86R` \x86\x01R`$5`@\x86\x01R\x15\x15``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x94^\xD3?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`@Q\x80\x94\x81\x92\x7FH\xC8\x94\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x04\xDA6a\x0E\xCAV[a\x04\xE2a\x19EV[a\x04\xEAa\x19rV[a\x1A;V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x94\x92\x94]`@Q\x93\x84\x93\x84a\x0F/V[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW` \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\`\x01`\x01`\xA0\x1B\x03`@Q\x91\x16\x81R\xF3[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x05z6a\x0E\xCAV[a\x05\x82a\x19EV[a\x05\x8Aa\x19rV[a(\xFBV[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW`@Q_\x80T\x90`\x01\x82`\x01\x1C\x91`\x01\x84\x16\x91\x82\x15a\x06\xC2W[` \x94\x85\x85\x10\x84\x14a\x06\x95W\x85\x87\x94\x86\x86R\x91\x82_\x14a\x06WWPP`\x01\x14a\x05\xFEW[Pa\x05\xEA\x92P\x03\x83a\x11RV[a\x02\xA3`@Q\x92\x82\x84\x93\x84R\x83\x01\x90a\x0F\xFBV[_\x80\x80R\x85\x92P\x90\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c[\x85\x83\x10a\x06?WPPa\x05\xEA\x93P\x82\x01\x01\x85a\x05\xDDV[\x80T\x83\x89\x01\x85\x01R\x87\x94P\x86\x93\x90\x92\x01\x91\x81\x01a\x06(V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x85\x82\x01Ra\x05\xEA\x95\x15\x15`\x05\x1B\x85\x01\x01\x92P\x87\x91Pa\x05\xDD\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\"`\x04R`$_\xFD[\x92`\x7F\x16\x92a\x05\xB9V[4a\x02\xFCW```\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x06\xFE\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\x07a\x11\xA1V[`D5\x91\x82\x11a\x02\xFCWa\x07\"a\x07*\x926\x90`\x04\x01a\x0F\xCDV[\x92\x90\x91a(\xB9V[\x90_[\x84Q\x81\x10\x15a\x07_W\x80o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@a\x07V`\x01\x94\x89a\x16\x91V[Q\x01R\x01a\x07-V[Pa\x01\xF0a\x01\xFE\x85a\x07}_\x94a\x029\x97`@Q\x93a\x01\x9A\x85a\x11\x1AV[`\x80\x82\x01R`@Q\x92\x83\x91\x7FZ<9\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x07\xE4\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\xEDa\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x08\x14a\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x08\xA4e\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[`\xA0`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x11a\x02\xFCW6`#`\x045\x01\x12\x15a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045`\x04\x015\x11a\x02\xFCW6`$`\xC0`\x045`\x04\x015\x02`\x045\x01\x01\x11a\x02\xFCW`$5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x08\xC4\x906\x90`\x04\x01a\x0F\x9CV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D5\x11a\x02\xFCW```\x03\x19`D56\x03\x01\x12a\x02\xFCW`d5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t\x05\x906\x90`\x04\x01a\x0F\xCDV[`\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t%\x906\x90`\x04\x01a\x0F\x9CV[\x94\x90\x93a\t0a\x19EV[\x80`\x045`\x04\x015\x03a\x0EuW_[`\x045`\x04\x015\x81\x10a\x0B\xD2WPPP`D5`\x04\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDD`D56\x03\x01\x82\x12\x15a\x02\xFCW\x81`D5\x01`\x04\x81\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW`$\x82`\x07\x1B6\x03\x91\x01\x13a\x02\xFCWa\t\xE3W[a\x02\xA3a\x038\x86\x86_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]a\x17\x9BV[`\x01`\x01`\xA0\x1B\x03\x94\x92\x94\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x94\x7F*-\x80\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R3`\x04\x87\x01R```$\x87\x01R`\xC4\x86\x01\x92`D5\x01`$\x81\x01\x93g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04\x83\x015\x11a\x02\xFCW`\x04\x82\x015`\x07\x1B6\x03\x85\x13a\x02\xFCW```d\x89\x01R`\x04\x82\x015\x90R\x91\x92\x86\x92`\xE4\x84\x01\x92\x91\x90_\x90[`\x04\x81\x015\x82\x10a\x0BTWPPP` \x91`\x1F\x19`\x1F\x86_\x97\x87\x95`\x01`\x01`\xA0\x1B\x03a\n\xC8`$`D5\x01a\x11\x8DV[\x16`\x84\x88\x01R`D\x805\x015`\xA4\x88\x01R`\x03\x19\x87\x87\x03\x01`D\x88\x01R\x81\x86R\x87\x86\x017\x87\x86\x82\x86\x01\x01R\x01\x16\x01\x03\x01\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x93a\x038\x93a\x0BEW[\x82\x94P\x81\x93Pa\t\xB3V[a\x0BN\x90a\x11\x06V[\x84a\x0B:V[\x91\x95\x94P\x91\x92`\x01`\x01`\xA0\x1B\x03a\x0Bk\x87a\x11\x8DV[\x16\x81R` \x80\x87\x015\x91`\x01`\x01`\xA0\x1B\x03\x83\x16\x80\x93\x03a\x02\xFCW`\x04\x92`\x01\x92\x82\x01Ra\x0B\x9B`@\x89\x01a(\xA6V[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x91\x16`@\x83\x01Ra\x0B\xB6``\x8A\x01a(\xA6V[\x16``\x82\x01R`\x80\x80\x91\x01\x97\x01\x93\x01\x90P\x88\x94\x95\x93\x92\x91a\n\x97V[a\x0B\xE7a\x0B\xE0\x82\x84\x86a\x19*V[6\x91a\x13\x81V[`@Qa\x0B\xF3\x81a\x10\xA1V[_\x81R` \x91_\x83\x83\x01R_`@\x83\x01R\x82\x81\x01Q\x90```@\x82\x01Q\x91\x01Q_\x1A\x91\x83R\x83\x83\x01R`@\x82\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDC\x81\x85\x02`\x045\x016\x03\x01\x12a\x02\xFCW`@Q\x90a\x0C`\x82a\x10\xEAV[a\x0Cs`$`\xC0\x86\x02`\x045\x01\x01a\x11\x8DV[\x80\x83Ra\x0C\x89`D`\xC0\x87\x02`\x045\x01\x01a\x11\x8DV[\x90\x81\x85\x85\x01Ra\x0C\xA2`d`\xC0\x88\x02`\x045\x01\x01a\x11\x8DV[`@\x85\x81\x01\x91\x90\x91R`\x045`\xC0\x88\x02\x01`\x84\x81\x015``\x87\x01R`\xA4\x81\x015`\x80\x87\x01R`\xC4\x015`\xA0\x86\x01R\x83\x01Q\x83Q\x93\x86\x01Q`\xFF\x91\x90\x91\x16\x92`\x01`\x01`\xA0\x1B\x03\x83\x16;\x15a\x02\xFCW_`\x01`\x01`\xA0\x1B\x03\x80\x94`\xE4\x94\x8B\x98\x84\x98`\xC4`\xC0`@Q\x9C\x8D\x9B\x8C\x9A\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8CR\x16`\x04\x8B\x01R0`$\x8B\x01R`\x84\x82\x82\x02`\x045\x01\x015`D\x8B\x01R\x02`\x045\x01\x015`d\x88\x01R`\x84\x87\x01R`\xA4\x86\x01R`\xC4\x85\x01R\x16Z\xF1\x90\x81a\x0EfW[Pa\x0E\\Wa\r\x7Fa(wV[\x90`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x81\x83\x01Q\x16`D`@Q\x80\x95\x81\x93\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01R0`$\x83\x01RZ\xFA\x91\x82\x15a\x02\xF1W_\x92a\x0E,W[P``\x01Q\x03a\r\xF7WPP`\x01\x90[\x01a\t?V[\x80Q\x15a\x0E\x04W\x80Q\x91\x01\xFD[\x7F\xA7(V\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x0EUW[a\x0ED\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x90``a\r\xE1V[P=a\x0E:V[PP`\x01\x90a\r\xF1V[a\x0Eo\x90a\x11\x06V[\x8Aa\rrV[\x7F\xAA\xAD\x13\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[4a\x02\xFCWa\x0E\xAB6a\x0E\xCAV[a\x0E\xB3a\x19EV[a\x0E\xBBa\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a\x1A;V[`\x03\x19\x90` \x82\x82\x01\x12a\x02\xFCW`\x045\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW\x82`\xA0\x92\x03\x01\x12a\x02\xFCW`\x04\x01\x90V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a\x0F\x1BWPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a\x0F\rV[\x93\x92\x90a\x0FD\x90``\x86R``\x86\x01\x90a\x0E\xFCV[\x93` \x94\x81\x81\x03` \x83\x01R` \x80\x85Q\x92\x83\x81R\x01\x94\x01\x90_[\x81\x81\x10a\x0F\x7FWPPPa\x0F|\x93\x94P`@\x81\x84\x03\x91\x01Ra\x0E\xFCV[\x90V[\x82Q`\x01`\x01`\xA0\x1B\x03\x16\x86R\x94\x87\x01\x94\x91\x87\x01\x91`\x01\x01a\x0F_V[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x80\x85\x01\x94\x84`\x05\x1B\x01\x01\x11a\x02\xFCWV[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x83\x81\x86\x01\x95\x01\x01\x11a\x02\xFCWV[\x90`\x1F\x19`\x1F` \x80\x94\x80Q\x91\x82\x91\x82\x87R\x01\x86\x86\x01^_\x85\x82\x86\x01\x01R\x01\x16\x01\x01\x90V[` \x80\x82\x01\x90` \x83R\x83Q\x80\x92R`@\x83\x01\x92` `@\x84`\x05\x1B\x83\x01\x01\x95\x01\x93_\x91[\x84\x83\x10a\x10UWPPPPPP\x90V[\x90\x91\x92\x93\x94\x95\x84\x80a\x10\x91\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC0\x86`\x01\x96\x03\x01\x87R\x8AQa\x0F\xFBV[\x98\x01\x93\x01\x93\x01\x91\x94\x93\x92\x90a\x10EV[``\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`\xC0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`@RV[`\xA0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[`\xE0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x90`\x1F`\x1F\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x05\x1B` \x01\x90V[5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`D5\x90\x81\x15\x15\x82\x03a\x02\xFCWV[\x91\x90\x91`\x80\x81\x84\x03\x12a\x02\xFCW`@\x90\x81Q\x91`\x80\x83\x01\x94g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x84\x81\x10\x87\x82\x11\x17a\x10\xBDW\x82R\x83\x95a\x12\0\x84a\x11\x8DV[\x85R` \x90\x81\x85\x015\x90\x81\x11a\x02\xFCW\x84\x01\x82`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x90a\x12)\x82a\x11uV[\x93a\x126\x86Q\x95\x86a\x11RV[\x82\x85R\x83\x85\x01\x90\x84``\x80\x95\x02\x84\x01\x01\x92\x81\x84\x11a\x02\xFCW\x85\x01\x91[\x83\x83\x10a\x12tWPPPPP\x84\x01R\x81\x81\x015\x90\x83\x01R``\x90\x81\x015\x91\x01RV[\x84\x83\x83\x03\x12a\x02\xFCW\x87Q\x90a\x12\x89\x82a\x10\xA1V[a\x12\x92\x84a\x11\x8DV[\x82Ra\x12\x9F\x87\x85\x01a\x11\x8DV[\x87\x83\x01R\x88\x84\x015\x90\x81\x15\x15\x82\x03a\x02\xFCW\x82\x88\x92\x8B\x89\x95\x01R\x81R\x01\x92\x01\x91a\x12RV[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x91` \x91a\x12\xDE\x84a\x11uV[\x93a\x12\xEC`@Q\x95\x86a\x11RV[\x80\x85R\x83\x80\x86\x01\x91`\x05\x1B\x83\x01\x01\x92\x80\x84\x11a\x02\xFCW\x84\x83\x01\x91[\x84\x83\x10a\x13\x17WPPPPPP\x90V[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCW\x86\x91a\x139\x84\x84\x80\x94\x89\x01\x01a\x11\xC6V[\x81R\x01\x92\x01\x91a\x13\x07V[5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x90V[5\x80\x15\x15\x81\x03a\x02\xFCW\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x13\x8D\x82a\x13eV[\x91a\x13\x9B`@Q\x93\x84a\x11RV[\x82\x94\x81\x84R\x81\x83\x01\x11a\x02\xFCW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90`\x80\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x80\x82Q\x16\x83R` \x93\x84\x83\x01Q\x94`\x80\x81\x86\x01R\x85Q\x80\x92R\x80`\xA0\x86\x01\x96\x01\x92_\x90[\x83\x82\x10a\x14\x0BWPPPPP``\x81`@\x82\x93\x01Q`@\x85\x01R\x01Q\x91\x01R\x90V[\x84Q\x80Q\x82\x16\x89R\x80\x84\x01Q\x82\x16\x89\x85\x01R`@\x90\x81\x01Q\x15\x15\x90\x89\x01R``\x90\x97\x01\x96\x93\x82\x01\x93`\x01\x90\x91\x01\x90a\x13\xE9V[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x14\xBDWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x14\xF8\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x14\x81V[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x80Q\x90a\x15\x1E\x82a\x13eV[\x92a\x15,`@Q\x94\x85a\x11RV[\x82\x84R` \x83\x83\x01\x01\x11a\x02\xFCW\x81_\x92` \x80\x93\x01\x83\x86\x01^\x83\x01\x01R\x90V[\x90` \x82\x82\x03\x12a\x02\xFCW\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x80`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x90` \x91a\x15\x8E\x81a\x11uV[\x93a\x15\x9C`@Q\x95\x86a\x11RV[\x81\x85R` \x80\x86\x01\x92`\x05\x1B\x82\x01\x01\x92\x83\x11a\x02\xFCW` \x01\x90[\x82\x82\x10a\x15\xC5WPPPP\x90V[\x81Q\x81R\x90\x83\x01\x90\x83\x01a\x15\xB7V[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a\x16\0\x91\x83\x01a\x15sV[\x93` \x80\x83\x01Q\x85\x81\x11a\x02\xFCW\x83\x01\x90\x82`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x91a\x16(\x83a\x11uV[\x92a\x166`@Q\x94\x85a\x11RV[\x80\x84R\x82\x80\x85\x01\x91`\x05\x1B\x83\x01\x01\x91\x85\x83\x11a\x02\xFCW\x83\x01\x90[\x82\x82\x10a\x16rWPPPP\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15sV[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x81R\x90\x83\x01\x90\x83\x01a\x16PV[\x80Q\x82\x10\x15a\x16\xA5W` \x91`\x05\x1B\x01\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x17QWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x17\x8C\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x17\x15V[\x91\x90a\x17\xA63a(\xB9V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x84\\a\x18\xB1W`\x01\x90`\x01\x86]a\x17\xDF\x83a\x11uV[\x92a\x17\xED`@Q\x94\x85a\x11RV[\x80\x84R`\x1F\x19a\x17\xFC\x82a\x11uV[\x01_[\x81\x81\x10a\x18\xA0WPP_[\x81\x81\x10a\x18WWPPPP\x90_a\x18L\x92\x94]\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\\\x91a\x18NW[Pa6\xB1V[V[_\x90]_a\x18FV[\x80a\x18\x84_\x80a\x18la\x0B\xE0\x89\x96\x88\x8Aa\x19*V[` \x81Q\x91\x010Z\xF4a\x18}a(wV[\x900aA\\V[a\x18\x8E\x82\x88a\x16\x91V[Ra\x18\x99\x81\x87a\x16\x91V[P\x01a\x18\nV[\x80``` \x80\x93\x89\x01\x01R\x01a\x17\xFFV[\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x816\x03\x83\x13a\x02\xFCWV[\x90\x82\x10\x15a\x16\xA5Wa\x19A\x91`\x05\x1B\x81\x01\x90a\x18\xD9V[\x90\x91V[\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x80\\a\x18\xB1W`\x01\x90]V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\x19\xA4WV[\x7F\x08\x96v\xD5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R3`\x04R`$_\xFD[\x90a\x19\xDA\x82a\x11uV[a\x19\xE7`@Q\x91\x82a\x11RV[\x82\x81R`\x1F\x19a\x19\xF7\x82\x94a\x11uV[\x01\x90` 6\x91\x017V[\x91\x90\x82\x01\x80\x92\x11a\x1A\x0EWV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[`@\x81\x015B\x11a&\xC3W\x90a\x1A^a\x1AW` \x84\x01\x84a6\xF4V[\x90Pa\x19\xD0V[\x91_[a\x1An` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a%\xC7Wa\x1A\x98\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[6\x93\x91a7HV[a\x11\xC6V[\x93`@\x85\x01Q\x93`\x01`\x01`\xA0\x1B\x03\x86Q\x16\x90` \x87\x01Q\x80Q\x15a\x16\xA5W` \x01Q`@\x01Q\x15\x15\x80a%\xBEW[\x15a%cWa\x1A\xECa\x1A\xD8\x86a\x13DV[\x87\x84a\x1A\xE6``\x8A\x01a\x13XV[\x92a:\xDDV[_[` \x88\x01QQ\x81\x10\x15a%SWa\x1B\x03a7\x88V[` \x89\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW\x82\x14\x80` \x83\x01R\x82\x15\x82R_\x14a%LW``\x89\x01Q\x90[a\x1B;\x83` \x8C\x01Qa\x16\x91V[Q`@\x81\x01Q\x90\x91\x90\x15a\x1C\xEEWa\x1B\xD3`\x01`\x01`\xA0\x1B\x03\x83Q\x16\x93`\x01`\x01`\xA0\x1B\x03\x88\x16\x85\x14_\x14a\x1C\xE7W`\x01\x94[`@Q\x95a\x1B{\x87a\x11\x1AV[_\x87Ra\x1B\x87\x81a7\xBEV[` \x87\x01R`@\x86\x01R``\x94\x85\x91\x8D\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x93\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1C\xB0W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1C\x90\x93`\x01\x96\x95a\x1C8\x8C\x8Ca\x16\x91V[R\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x01a\x1A\xEEV[` \x01Q\x90\x97P`\x01`\x01`\xA0\x1B\x03\x16\x92P`\x01\x90a\x1C\x90V[` \x92\x94P\x90\x81a\x1C\xD5\x92\x90=\x10a\x1C\xE0W[a\x1C\xCD\x81\x83a\x11RV[\x81\x01\x90a7\xF5V[\x91PP\x92\x90_a\x1C\x10V[P=a\x1C\xC3V[_\x94a\x1BnV[\x88\x8A`\x01`\x01`\xA0\x1B\x03\x84\x95\x94Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x8A\x16\x14_\x14a!2WPP\x81Q\x15\x90Pa nW\x88\x8A\x80\x15\x15\x80a SW[a\x1FMW[`\x01`\x01`\xA0\x1B\x03\x93\x92\x91a\x1D\xDD\x82a\x1E\x15\x97\x8B_\x95\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\x16\x80\x88R\x82` R`@\x88 \\a\x1F<W[PPP[`\x01a\x1D\x9C\x89\x83Q\x16` \x84\x01\x99\x8B\x8BQ\x16\x90\x80\x15\x8A\x14a\x1F6WP\x83\x91aB#V[\x99\x90\x92Q\x16\x94a\x1D\xB1`\x80\x91\x82\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a\x1D\xC1\x89a\x10\xEAV[\x88R0` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x96\x81\x92\x7F!Ex\x97\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a9\xB1V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1F\x0CW[P` \x01Q\x15a\x1E\xE9W\x91a\x1E\xBC\x82`\x01`\x01`\xA0\x1B\x03`\x01\x96\x95a\x1Eza\x1E\xE4\x96\x86a\x16\x91V[Qa\x1E\x85\x8D\x8Da\x16\x91V[Ra\x1E\xB3\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x92a\x16\x91V[Q\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1C\x90V[\x98P`\x01\x92\x94Pa\x1F\x02\x90`\x01`\x01`\xA0\x1B\x03\x92a\x16\x91V[Q\x97Q\x16\x92a\x1C\x90V[` \x91\x94Pa\x1F,\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[\x81\x01\x90a9iV[P\x94\x91\x90Pa\x1ERV[\x91aB#V[a\x1FE\x92aCAV[_\x82\x81a\x1DuV[Pa\x1FZ\x90\x92\x91\x92a\x13DV[\x91a\x1Fd\x8BaB\xFDV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x04\x82\x01R0`$\x82\x01R\x90\x84\x16`D\x82\x01R\x92\x87\x16`d\x84\x01R_\x83\x80`\x84\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a DW[P\x97P\x92PP\x91\x92\x93Pa\x1D*V[a M\x90a\x11\x06V[_a 5V[Pa ]\x82a\x13DV[`\x01`\x01`\xA0\x1B\x03\x160\x14\x15a\x1D%V[\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91`\x01`\x01`\xA0\x1B\x03\x84Q\x16\x92\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`\x04\x85\x01R0`$\x85\x01R`D\x84\x01\x8C\x90R_\x90\x84\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a!#W[Pa\x1DyV[a!,\x90a\x11\x06V[_a!\x1DV[`\x01`\x01`\xA0\x1B\x03` \x87\x96\x94\x97\x01Q\x16\x90\x89\x81\x83\x14_\x14a#\xD7Wa!\xCD\x92Pa\"\x05\x97\x91P`\x01a!s_\x96\x95`\x01`\x01`\xA0\x1B\x03\x93\x84\x8BQ\x16aB#V[P\x92\x82\x89Q\x16\x95` \x89\x01Q\x15\x15\x88\x14a#\xAEWa!\x90\x82a\x13DV[\x94[a!\xA1`\x80\x93\x84\x81\x01\x90a\x18\xD9V[\x95\x90\x96`@Q\x99a!\xB1\x8Ba\x10\xEAV[\x8AR\x16` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x95\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W_\x93a#\x84W[P` \x01Q\x15a\"\xC3W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a\"i\x8C\x8Ca\x16\x91V[Ra\"\x99\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x81\x81\x01Q\x91Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R`$\x81\x01\x85\x90R\x93\x9AP\x90\x91\x16\x94P\x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa#YW[P`\x01\x90a\x1C\x90V[` \x90\x81=\x83\x11a#}W[a#o\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a#PV[P=a#eV[` \x91\x93Pa#\xA4\x90=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x81\x01\x90a8|V[P\x93\x91\x90Pa\"BV[\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a!\x92V[`\x01`\x01`\xA0\x1B\x03a$f\x95a$.\x93\x94\x95a#\xF8`\x80\x9B\x8C\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a$\x08\x89a\x116V[_\x89R` \x89\x01R\x16`@\x87\x01R``\x9A\x8B\x97\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x93\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a%%W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a$\xCB\x8C\x8Ca\x16\x91V[Ra$\xFB\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x92\x94P\x90\x81a%A\x92\x90=\x10a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[\x91PP\x92\x90_a$\xA3V[_\x90a\x1B-V[P\x91\x95P\x90\x93PP`\x01\x01a\x1AaV[a%\x8D\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[Pa%\xB9\x86\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1A\xECV[P2\x15\x15a\x1A\xC7V[PPa%\xF2\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a%\xFD\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a&c\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra&\x91`@_ \\\x82a&~\x85\x8Da\x16\x91V[Q\x16_R\x88` R`@_ \\\x90a\x1A\x01V[a&\x9B\x83\x87a\x16\x91V[Ra&\xA6\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a&DV[P\x94\x93\x91P\x91PV[\x7F\xE0\x8B\x8A\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90_\x19\x82\x01\x91\x82\x13`\x01\x16a\x1A\x0EWV[\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x1A\x0EW_\x19\x01\x90V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x81\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a'y\x81\\a&\xEBV[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91[_\x81\x12\x15a(:WPPPa'\xB1\x90a&\xEBV[\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92[_\x81\x12\x15a'\xEAWPPPPa\x18L\x90a6\xB1V[a(5\x90\x82_Ra(/` _\x83\x82\x82 \x01\\\x91\x82\x82R\x88\x81R\x88`@\x91a(\"\x8A\x8D\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a>\xB0V[\x84\x84RR\x81 ]\x84a>\rV[Pa&\xFCV[a'\xD5V[a(r\x90\x82_Ra(/` _\x8A\x87\x85\x84\x84 \x01\\\x93\x84\x84R\x81\x81Ra(\"\x8C`@\x94\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a:\xDDV[a'\x9DV[=\x15a(\xA1W=\x90a(\x88\x82a\x13eV[\x91a(\x96`@Q\x93\x84a\x11RV[\x82R=_` \x84\x01>V[``\x90V[5\x90e\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x82\x03a\x02\xFCWV[\x90_\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x81\\\x16\x15a(\xF1WPPV[\x90\x91\x92P]`\x01\x90V[\x90`@\x82\x015B\x11a&\xC3Wa)\x17a\x1AW` \x84\x01\x84a6\xF4V[\x91_[a)'` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a5\xD1Wa)D\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[``\x81\x01Q\x90a)~`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P` \x81\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW[_\x81\x12\x15a)\xA4WPPP`\x01\x01a)\x1AV[a)\xB2\x81` \x84\x01Qa\x16\x91V[Qa)\xBBa7\x88V[\x90\x82\x15` \x83\x01R` \x84\x01QQ\x80_\x19\x81\x01\x11a\x1A\x0EW_\x19\x01\x83\x14\x80\x83Ra5\x8FW[` \x82\x01Q\x15a5TW`@\x84\x01Q`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x91[`@\x81\x01Q\x15a,\x1DW\x83\x91`\x01`\x01`\xA0\x1B\x03``\x92` a*\xA0\x97\x01Q\x15\x15\x80a,\x14W[a+\xEDW[Q\x16\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x82\x03a+\xE6W`\x01\x91[`@Q\x92a*L\x84a\x11\x1AV[`\x01\x84Ra*Y\x81a7\xBEV[` \x84\x01R`@\x83\x01R\x88\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x95\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a+\xBFW[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a+\x02a+\xAB\x97\x96\x94a+u\x94a\x16\x91V[Ra+6`\x01`\x01`\xA0\x1B\x03\x82\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P`\x01`\x01`\xA0\x1B\x03a+M\x84`@\x8A\x01Qa7\xB1V[\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a&\xFCV[a)\x91V[PPPa+\xAB\x91\x93P\x92a&\xFCV[` \x91\x95Pa+\xDC\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa*\xE1V[_\x91a*?V[a,\x0Fa+\xF9\x8Da\x13DV[\x8D\x8Ba\x1A\xE6\x88`@\x88\x84Q\x16\x93\x01Q\x93\x01a\x13XV[a*(V[P2\x15\x15a*#V[\x90`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x85\x16\x14_\x14a17WP` \x84\x01Qa0IWP`@Q\x92\x7F\x96xp\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x85\x01R` \x84`$\x81`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15a\x02\xF1W_\x94a0\x15W[P\x83\x91`\x01`\x01`\xA0\x1B\x03\x81Q\x16`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x95\x90\x95R_\x85\x80`d\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a0\x06W[P[a\x1D\xDD`\x01`\x01`\xA0\x1B\x03a-\xA8\x8B\x82\x85Q\x16\x83` \x87\x01Q\x16\x90aB#V[P\x92Q\x16\x91\x8C`\x02a-\xBF`\x80\x92\x83\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a-\xCF\x88a\x10\xEAV[\x87R0` \x88\x01R\x89`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a/\xE3W[P` \x01Q\x15a.\xCFW\x90\x82\x91a+\xAB\x94\x93a.E\x89\x8Da\x16\x91V[Ra.z\x83`\x01`\x01`\xA0\x1B\x03\x84\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x80\x83\x10\x80a.\xB4W[a.\x90W[PPPa&\xFCV[a.\xA6a.\xAC\x93a.\xA0\x8Ba\x13DV[\x92a7\xB1V[\x91aCVV[_\x80\x80a.\x88V[P0`\x01`\x01`\xA0\x1B\x03a.\xC7\x8Ba\x13DV[\x16\x14\x15a.\x83V[\x94P\x90\x80\x94\x80\x82\x10a.\xE8W[PPPa+\xAB\x90a&\xFCV[\x91a.\xF8` \x92a/w\x94a7\xB1V[\x90a/-\x82`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83aCVV[`@Q\x93\x84\x92\x83\x92\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa/\xB8W[\x80\x80a.\xDCV[` \x90\x81=\x83\x11a/\xDCW[a/\xCE\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a/\xB1V[P=a/\xC4V[` \x91\x94Pa/\xFB\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[P\x90\x94\x91\x90Pa.)V[a0\x0F\x90a\x11\x06V[_a-\x86V[\x90\x93P` \x81=` \x11a0AW[\x81a01` \x93\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x92_a,\xBCV[=\x91Pa0$V[\x90\x92a0T\x89a\x13DV[`\x01`\x01`\xA0\x1B\x030\x91\x16\x03a0oW[_a-\xEC\x94a-\x88V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a0\xA3\x8Aa\x13DV[a0\xAC\x84aB\xFDV[\x90\x86;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R0`$\x82\x01R\x91\x81\x16`D\x83\x01R\x85\x16`d\x82\x01R\x94_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a1(W[P\x94PPa0eV[a11\x90a\x11\x06V[_a1\x1FV[`\x01`\x01`\xA0\x1B\x03` \x84\x96\x95\x94\x01Q\x16\x8A\x82\x82\x14_\x14a4\x0BWPPPa2\x0Ca1n_\x92\x84`\x01`\x01`\xA0\x1B\x03\x88Q\x16aB#V[\x92\x90a1\xD4\x8C`\x01`\x01`\xA0\x1B\x03\x80\x8AQ\x16\x93\x89Q\x15\x15\x86\x14a3\xDFWa1\xA3a1\x97\x84a\x13DV[\x93[`\x80\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a1\xB3\x88a\x10\xEAV[\x87R\x16` \x86\x01R`@\x85\x01R\x8C``\x85\x01R`\x02`\x80\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x93\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1W_\x91a3\xC4W[P` \x84\x01Q\x8C\x90\x8A\x90\x15a3\xAAW\x83\x83`\x01`\x01`\xA0\x1B\x03\x93a2\x83a2\x89\x94a2|\x8F\x9C\x9B\x9A\x98\x99a2\xB2\x9Aa\x16\x91V[Q\x92a\x16\x91V[Ra\x16\x91V[Q\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[Q\x15a2\xF4Wa+\xAB\x92\x91`\x01`\x01`\xA0\x1B\x03` a+\xA6\x93\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aCAV[Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R` \x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa3\x7FW[Pa+\xAB\x90a&\xFCV[` \x90\x81=\x83\x11a3\xA3W[a3\x95\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a3uV[P=a3\x8BV[PP\x90\x91Pa3\xBB\x92\x93\x96Pa\x16\x91V[Q\x93\x84\x91a2\xB2V[a3\xD8\x91P=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x90Pa2IV[a1\xA3\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a1\x99V[a4\x9E\x96P\x90a4f\x91``\x94\x8Ba4+`\x80\x99\x98\x99\x93\x84\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a4;\x89a\x116V[`\x01\x89R` \x89\x01R`\x01`\x01`\xA0\x1B\x03\x8B\x16`@\x89\x01R\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x95\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a5-W[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a5\x05a+\xAB\x97\x96\x94`\x01`\x01`\xA0\x1B\x03\x94a\x16\x91V[R\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x91\x95Pa5J\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa4\xDFV[o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x01`\x01`\xA0\x1B\x03` a5\x85\x81\x88\x01Qa5\x7F\x88a&\xEBV[\x90a\x16\x91V[Q\x01Q\x16\x91a)\xFCV[a5\xCC\x85`\x01`\x01`\xA0\x1B\x03` \x84\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[a)\xE0V[PPa5\xFC\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a6\x07\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a6m\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra6\x88`@_ \\\x82a&~\x85\x8Da\x16\x91V[a6\x92\x83\x87a\x16\x91V[Ra6\x9D\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a6NV[G\x80\x15a6\xF0W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\a6\xF0W`\x01`\x01`\xA0\x1B\x03a\x18L\x92\x16a@\xE0V[PPV[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x02\xFCWV[\x91\x90\x81\x10\x15a\x16\xA5W`\x05\x1B\x81\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x90V[`@Q\x90`@\x82\x01\x82\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@R_` \x83\x82\x81R\x01RV[\x91\x90\x82\x03\x91\x82\x11a\x1A\x0EWV[`\x02\x11\x15a7\xC8WV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x90\x81``\x91\x03\x12a\x02\xFCW\x80Q\x91`@` \x83\x01Q\x92\x01Q\x90V[a\x01\0`\xC0a\x0F|\x93` \x84R\x80Qa8(\x81a7\xBEV[` \x85\x01R` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x91\x16`@\x86\x01R\x80`@\x83\x01Q\x16``\x86\x01R``\x82\x01Q\x16`\x80\x85\x01R`\x80\x81\x01Q`\xA0\x85\x01R`\xA0\x81\x01Q\x82\x85\x01R\x01Q\x91`\xE0\x80\x82\x01R\x01\x90a\x0F\xFBV[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a8\xA8\x91\x83\x01a\x15sV[\x93` \x82\x01Q\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a8\xE4WPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a8\xD6V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01Ra91`@\x83\x01Q`\xC0``\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90``\x83\x01Q`\x80\x82\x01R`\x80\x83\x01Q`\x05\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91``\x83\x83\x03\x12a\x02\xFCW\x82Q\x92` \x81\x01Q\x92g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x81\x11a\x02\xFCW\x81a9\x9A\x91\x84\x01a\x15sV[\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01R`@\x82\x01Q``\x82\x01Ra9\xF4``\x83\x01Q`\xC0`\x80\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90`\x80\x83\x01Q`\x04\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91\x90\x91`\x80\x80`\xA0\x83\x01\x94\x80Qa:8\x81a7\xBEV[\x84R` \x81\x01Qa:H\x81a7\xBEV[` \x85\x01R`\x01`\x01`\xA0\x1B\x03`@\x82\x01Q\x16`@\x85\x01R``\x81\x01Q``\x85\x01R\x01Q\x91\x01RV[\x90\x81\\a:}\x81a\x11uV[a:\x8A`@Q\x91\x82a\x11RV[\x81\x81Ra:\x96\x82a\x11uV[`\x1F\x19` \x91\x016` \x84\x017\x81\x94_[\x84\x81\x10a:\xB5WPPPPPV[`\x01\x90\x82_R\x80\x84_ \x01\\`\x01`\x01`\xA0\x1B\x03a:\xD3\x83\x88a\x16\x91V[\x91\x16\x90R\x01a:\xA7V[\x91\x92\x80a=\xD8W[\x15a<QWPP\x80G\x10a<)W`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x82;\x15a\x02\xFCW`@Q\x90\x7F\xD0\xE3\r\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R_\x91_\x81`\x04\x81\x85\x89Z\xF1\x80\x15a\x02\xF1Wa<\x12W[P`D` \x92\x93\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a;\x98\x83\x87\x83aCVV[\x84`@Q\x96\x87\x94\x85\x93\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85R`\x04\x85\x01R`$\x84\x01RZ\xF1\x90\x81\x15a<\x06WPa;\xDFWPV[` \x90\x81=\x83\x11a;\xFFW[a;\xF5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWV[P=a;\xEBV[`@Q\x90=\x90\x82>=\x90\xFD[` \x92Pa<\x1F\x90a\x11\x06V[`D_\x92Pa;cV[\x7F\xA0\x1A\x9D\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91_\x90\x80a<aW[PPPPV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91a<\xBB\x84aB\xFDV[\x96\x80;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R\x84\x83\x16`$\x82\x01R\x97\x82\x16`D\x89\x01R\x91\x86\x16\x16`d\x87\x01R_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x94\x85\x15a\x02\xF1Wa=\x80\x95a=\xC4W[P\x82\x93` \x93`@Q\x80\x97\x81\x95\x82\x94\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x92Z\xF1\x90\x81\x15a<\x06WPa=\x99W[\x80\x80\x80a<[V[` \x90\x81=\x83\x11a=\xBDW[a=\xAF\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a=\x91V[P=a=\xA5V[` \x93Pa=\xD1\x90a\x11\x06V[_\x92a=/V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x82\x16\x14a:\xE5V[`\x01\x81\x01\x91\x80_R` \x91\x83\x83R`@_ \\\x80\x15\x15_\x14a>\xA7W_\x19\x90\x81\x81\x01\x83\\\x83\x80\x82\x01\x91\x82\x84\x03a>jW[PPPPP\x81\\\x81\x81\x01\x92\x81\x84\x11a\x1A\x0EW_\x93\x81]\x83R\x84\x83 \x01\x01]_RR_`@\x81 ]`\x01\x90V[a>wa>\x87\x93\x88aD:V[\x86_R\x88_ \x01\x01\\\x91\x85aD:V[\x83_R\x80\x83\x83\x88_ \x01\x01]_R\x85\x85R`@_ ]_\x80\x80\x83\x81a>>V[PPPPP_\x90V[_\x94\x93\x83\x15a@\xD8W\x80a@\xA3W[\x15a@\x07W`\x01`\x01`\xA0\x1B\x03\x91\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`\x04\x83\x01R0`$\x83\x01R`D\x82\x01\x85\x90R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa?\xF4W[P\x84\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a?\xF0W\x81\x90`$`@Q\x80\x94\x81\x93\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R\x89`\x04\x84\x01RZ\xF1\x80\x15a?\xE5Wa?\xCDW[Pa\x18L\x93\x94P\x16a@\xE0V[a?\xD7\x86\x91a\x11\x06V[a?\xE1W\x84a?\xC0V[\x84\x80\xFD[`@Q=\x88\x82>=\x90\xFD[P\x80\xFD[a?\xFF\x91\x95Pa\x11\x06V[_\x93_a?SV[\x92\x93P\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x93\x90\x92\x16`$\x84\x01R`D\x83\x01R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa@\x9AWPV[a\x18L\x90a\x11\x06V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x83\x16\x14a>\xBFV[PPPP\x90PV[\x81G\x10aA0W_\x80\x80\x93`\x01`\x01`\xA0\x1B\x03\x82\x94\x16Z\xF1aA\0a(wV[P\x15aA\x08WV[\x7F\x14%\xEAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x7F\xCDx`Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R0`\x04R`$_\xFD[\x90aAqWP\x80Q\x15aA\x08W\x80Q\x90` \x01\xFD[\x81Q\x15\x80aA\xB7W[aA\x82WP\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x7F\x99\x96\xB3\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R\x16`\x04R`$_\xFD[P\x80;\x15aAzV[`\x01\x81\x01\x90\x82_R\x81` R`@_ \\\x15_\x14aB\x03W\x80\\\x81_R\x83\x81` _ \x01]`\x01\x81\x01\x80\x91\x11a\x1A\x0EW\x81]\\\x91_R` R`@_ ]`\x01\x90V[PPP_\x90V[\x90_R` RaB\x1F`@_ \x91\x82\\a\x1A\x01V[\x90]V[\x91`D\x92\x93\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x94\x85\x92\x82\x80\x85Q\x99\x8A\x95\x86\x94\x7F\xC9\xC1f\x1B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R\x16`\x04\x85\x01R\x16`$\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15aB\xF3W_\x93_\x95aB\xBCW[PPaB\xB9aB\xB2\x85\x94a\x19\xD0V[\x94\x85a\x16\x91V[RV[\x80\x92\x95P\x81\x94P=\x83\x11aB\xECW[aB\xD5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW` \x82Q\x92\x01Q\x92_\x80aB\xA3V[P=aB\xCBV[\x83Q=_\x82>=\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x81\x11aC\x11W\x16\x90V[\x7Fm\xFC\xC6P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\xA0`\x04R`$R`D_\xFD[\x90_R` RaB\x1F`@_ \x91\x82\\a7\xB1V[`@Q\x92` \x84\x01\x90\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R`\x01`\x01`\xA0\x1B\x03\x80\x94\x16`$\x86\x01R`D\x85\x01R`D\x84R`\x80\x84\x01\x90\x84\x82\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x17a\x10\xBDWaC\xD5\x93_\x93\x84\x93`@R\x16\x94Q\x90\x82\x86Z\xF1aC\xCEa(wV[\x90\x83aA\\V[\x80Q\x90\x81\x15\x15\x91\x82aD\x16W[PPaC\xEBWPV[\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04R`$_\xFD[\x81\x92P\x90` \x91\x81\x01\x03\x12a\x02\xFCW` \x01Q\x80\x15\x90\x81\x15\x03a\x02\xFCW_\x80aC\xE2V[\\\x11\x15aDCWV[\x7F\x0FJ\xE0\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD\xFE\xA2dipfsX\"\x12 \"\x9A\\\xF8\x9A\xA7\xC2\xD0\xA4\xB4\xD5\xDB \xBB\xA6\xC2\xB3\xA7K\x08\x03\x03\xFCn\xC0\x0B\xA5\x82\xA5\xDC\xF7QdsolcC\0\x08\x1A\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x60806040526004361015610072575b3615610018575f80fd5b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016330361004a57005b7f0540ddf6000000000000000000000000000000000000000000000000000000005f5260045ffd5b5f3560e01c806308a465f614610e9d57806319c6989f1461084e578063286f580d146107b75780632950286e146106cc57806354fd4d501461058f5780635a3c3987146105665780635e01eb5a146105215780638a12a08c146104c65780638eb1b65e146103bf578063945ed33f14610344578063ac9650d8146103005763e3b5dff40361000e57346102fc576060806003193601126102fc5767ffffffffffffffff6004358181116102fc5761012d9036906004016112c4565b6101356111a1565b6044359283116102fc57610150610158933690600401610fcd565b9390916128b9565b905f5b835181101561017c57805f8761017360019488611691565b5101520161015b565b506101f06101fe610239946101b65f94886040519361019a8561111a565b30855260208501525f1960408501528660608501523691611381565b60808201526040519283917f8a12a08c0000000000000000000000000000000000000000000000000000000060208401526024830161143e565b03601f198101835282611152565b604051809481927fedfa3568000000000000000000000000000000000000000000000000000000008352602060048401526024830190610ffb565b0381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19182156102f1576102a39261028e915f916102cf575b50602080825183010191016115d4565b909391926102a7575b60405193849384610f2f565b0390f35b5f7f00000000000000000000000000000000000000000000000000000000000000005d610297565b6102eb91503d805f833e6102e38183611152565b81019061154d565b8461027e565b6040513d5f823e3d90fd5b5f80fd5b60206003193601126102fc5760043567ffffffffffffffff81116102fc576103386103326102a3923690600401610f9c565b9061179b565b60405191829182611020565b346102fc5761035236610eca565b61035a611945565b610362611972565b6103906102a3610371836128fb565b9193909461038a606061038383611344565b9201611358565b90612729565b5f7f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f005d60405193849384610f2f565b60806003193601126102fc5767ffffffffffffffff6004358181116102fc576103ec9036906004016112c4565b906103f56111b7565b906064359081116102fc576101f061048b6102399461045161041c5f953690600401610fcd565b610425336128b9565b97604051946104338661111a565b33865260208601526024356040860152151560608501523691611381565b60808201526040519283917f945ed33f000000000000000000000000000000000000000000000000000000006020840152602483016116d2565b604051809481927f48c89491000000000000000000000000000000000000000000000000000000008352602060048401526024830190610ffb565b346102fc576102a36104ef6104da36610eca565b6104e2611945565b6104ea611972565b611a3b565b5f7f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f009492945d60405193849384610f2f565b346102fc575f6003193601126102fc5760207f00000000000000000000000000000000000000000000000000000000000000005c6001600160a01b0360405191168152f35b346102fc576102a36104ef61057a36610eca565b610582611945565b61058a611972565b6128fb565b346102fc575f6003193601126102fc576040515f80549060018260011c91600184169182156106c2575b60209485851084146106955785879486865291825f146106575750506001146105fe575b506105ea92500383611152565b6102a3604051928284938452830190610ffb565b5f808052859250907f290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e5635b85831061063f5750506105ea9350820101856105dd565b80548389018501528794508693909201918101610628565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016858201526105ea95151560051b85010192508791506105dd9050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b92607f16926105b9565b346102fc5760606003193601126102fc5767ffffffffffffffff6004358181116102fc576106fe9036906004016112c4565b906107076111a1565b6044359182116102fc5761072261072a923690600401610fcd565b9290916128b9565b905f5b845181101561075f57806fffffffffffffffffffffffffffffffff604061075660019489611691565b5101520161072d565b506101f06101fe8561077d5f94610239976040519361019a8561111a565b60808201526040519283917f5a3c3987000000000000000000000000000000000000000000000000000000006020840152602483016116d2565b60806003193601126102fc5767ffffffffffffffff6004358181116102fc576107e49036906004016112c4565b906107ed6111b7565b906064359081116102fc576101f061048b6102399461081461041c5f953690600401610fcd565b60808201526040519283917f08a465f60000000000000000000000000000000000000000000000000000000060208401526024830161143e565b60a06003193601126102fc5767ffffffffffffffff600435116102fc573660236004350112156102fc5767ffffffffffffffff60043560040135116102fc5736602460c060043560040135026004350101116102fc5760243567ffffffffffffffff81116102fc576108c4903690600401610f9c565b67ffffffffffffffff604435116102fc576060600319604435360301126102fc5760643567ffffffffffffffff81116102fc57610905903690600401610fcd565b60843567ffffffffffffffff81116102fc57610925903690600401610f9c565b949093610930611945565b806004356004013503610e75575f5b600435600401358110610bd25750505060443560040135907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdd6044353603018212156102fc57816044350160048101359067ffffffffffffffff82116102fc5760248260071b36039101136102fc576109e3575b6102a361033886865f7f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f005d61179b565b6001600160a01b039492947f0000000000000000000000000000000000000000000000000000000000000000163b156102fc57604051947f2a2d80d10000000000000000000000000000000000000000000000000000000086523360048701526060602487015260c486019260443501602481019367ffffffffffffffff6004830135116102fc57600482013560071b360385136102fc5760606064890152600482013590529192869260e484019291905f905b60048101358210610b5457505050602091601f19601f865f9787956001600160a01b03610ac860246044350161118d565b16608488015260448035013560a48801526003198787030160448801528186528786013787868286010152011601030181836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19182156102f1576102a39361033893610b45575b8294508193506109b3565b610b4e90611106565b84610b3a565b9195945091926001600160a01b03610b6b8761118d565b168152602080870135916001600160a01b0383168093036102fc57600492600192820152610b9b604089016128a6565b65ffffffffffff8091166040830152610bb660608a016128a6565b1660608201526080809101970193019050889495939291610a97565b610be7610be082848661192a565b3691611381565b604051610bf3816110a1565b5f81526020915f838301525f60408301528281015190606060408201519101515f1a91835283830152604082015260c07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc81850260043501360301126102fc5760405190610c60826110ea565b610c73602460c08602600435010161118d565b808352610c89604460c08702600435010161118d565b908185850152610ca2606460c08802600435010161118d565b60408581019190915260043560c08802016084810135606087015260a4810135608087015260c4013560a086015283015183519386015160ff91909116926001600160a01b0383163b156102fc575f6001600160a01b03809460e4948b98849860c460c06040519c8d9b8c9a7fd505accf000000000000000000000000000000000000000000000000000000008c521660048b01523060248b0152608482820260043501013560448b0152026004350101356064880152608487015260a486015260c4850152165af19081610e66575b50610e5c57610d7f612877565b906001600160a01b0381511690836001600160a01b0381830151166044604051809581937fdd62ed3e00000000000000000000000000000000000000000000000000000000835260048301523060248301525afa9182156102f1575f92610e2c575b506060015103610df75750506001905b0161093f565b805115610e045780519101fd5b7fa7285689000000000000000000000000000000000000000000000000000000005f5260045ffd5b9091508381813d8311610e55575b610e448183611152565b810103126102fc5751906060610de1565b503d610e3a565b5050600190610df1565b610e6f90611106565b8a610d72565b7faaad13f7000000000000000000000000000000000000000000000000000000005f5260045ffd5b346102fc57610eab36610eca565b610eb3611945565b610ebb611972565b6103906102a361037183611a3b565b600319906020828201126102fc576004359167ffffffffffffffff83116102fc578260a0920301126102fc5760040190565b9081518082526020808093019301915f5b828110610f1b575050505090565b835185529381019392810192600101610f0d565b939290610f4490606086526060860190610efc565b936020948181036020830152602080855192838152019401905f5b818110610f7f57505050610f7c9394506040818403910152610efc565b90565b82516001600160a01b031686529487019491870191600101610f5f565b9181601f840112156102fc5782359167ffffffffffffffff83116102fc576020808501948460051b0101116102fc57565b9181601f840112156102fc5782359167ffffffffffffffff83116102fc57602083818601950101116102fc57565b90601f19601f602080948051918291828752018686015e5f8582860101520116010190565b6020808201906020835283518092526040830192602060408460051b8301019501935f915b8483106110555750505050505090565b9091929394958480611091837fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc086600196030187528a51610ffb565b9801930193019194939290611045565b6060810190811067ffffffffffffffff8211176110bd57604052565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b60c0810190811067ffffffffffffffff8211176110bd57604052565b67ffffffffffffffff81116110bd57604052565b60a0810190811067ffffffffffffffff8211176110bd57604052565b60e0810190811067ffffffffffffffff8211176110bd57604052565b90601f601f19910116810190811067ffffffffffffffff8211176110bd57604052565b67ffffffffffffffff81116110bd5760051b60200190565b35906001600160a01b03821682036102fc57565b602435906001600160a01b03821682036102fc57565b6044359081151582036102fc57565b9190916080818403126102fc57604090815191608083019467ffffffffffffffff95848110878211176110bd57825283956112008461118d565b8552602090818501359081116102fc57840182601f820112156102fc5780359061122982611175565b9361123686519586611152565b82855283850190846060809502840101928184116102fc578501915b8383106112745750505050508401528181013590830152606090810135910152565b84838303126102fc57875190611289826110a1565b6112928461118d565b825261129f87850161118d565b87830152888401359081151582036102fc578288928b89950152815201920191611252565b81601f820112156102fc578035916020916112de84611175565b936112ec6040519586611152565b808552838086019160051b830101928084116102fc57848301915b8483106113175750505050505090565b823567ffffffffffffffff81116102fc578691611339848480948901016111c6565b815201920191611307565b356001600160a01b03811681036102fc5790565b3580151581036102fc5790565b67ffffffffffffffff81116110bd57601f01601f191660200190565b92919261138d82611365565b9161139b6040519384611152565b8294818452818301116102fc578281602093845f960137010152565b9060808101916001600160a01b03808251168352602093848301519460808186015285518092528060a086019601925f905b83821061140b5750505050506060816040829301516040850152015191015290565b845180518216895280840151821689850152604090810151151590890152606090970196938201936001909101906113e9565b91909160209081815260c08101916001600160a01b0385511681830152808501519260a06040840152835180915260e08301918060e08360051b8601019501925f905b8382106114bd5750505050506080846040610f7c959601516060840152606081015115158284015201519060a0601f1982850301910152610ffb565b909192939583806114f8837fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff208a600196030186528a516113b7565b98019201920190939291611481565b81601f820112156102fc5780519061151e82611365565b9261152c6040519485611152565b828452602083830101116102fc57815f9260208093018386015e8301015290565b906020828203126102fc57815167ffffffffffffffff81116102fc57610f7c9201611507565b9080601f830112156102fc5781519060209161158e81611175565b9361159c6040519586611152565b81855260208086019260051b8201019283116102fc57602001905b8282106115c5575050505090565b815181529083019083016115b7565b90916060828403126102fc5781519167ffffffffffffffff928381116102fc5784611600918301611573565b936020808301518581116102fc5783019082601f830112156102fc5781519161162883611175565b926116366040519485611152565b808452828085019160051b830101918583116102fc578301905b82821061167257505050509360408301519081116102fc57610f7c9201611573565b81516001600160a01b03811681036102fc578152908301908301611650565b80518210156116a55760209160051b010190565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b91909160209081815260c08101916001600160a01b0385511681830152808501519260a06040840152835180915260e08301918060e08360051b8601019501925f905b8382106117515750505050506080846040610f7c959601516060840152606081015115158284015201519060a0601f1982850301910152610ffb565b9091929395838061178c837fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff208a600196030186528a516113b7565b98019201920190939291611715565b91906117a6336128b9565b907f000000000000000000000000000000000000000000000000000000000000000093845c6118b1576001906001865d6117df83611175565b926117ed6040519485611152565b808452601f196117fc82611175565b015f5b8181106118a05750505f5b8181106118575750505050905f61184c92945d7f0000000000000000000000000000000000000000000000000000000000000000805c9161184e575b506136b1565b565b5f905d5f611846565b806118845f8061186c610be08996888a61192a565b602081519101305af461187d612877565b903061415c565b61188e8288611691565b526118998187611691565b500161180a565b8060606020809389010152016117ff565b7f3ee5aeb5000000000000000000000000000000000000000000000000000000005f5260045ffd5b9035907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1813603018212156102fc570180359067ffffffffffffffff82116102fc576020019181360383136102fc57565b908210156116a5576119419160051b8101906118d9565b9091565b7f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00805c6118b1576001905d565b6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001633036119a457565b7f089676d5000000000000000000000000000000000000000000000000000000005f523360045260245ffd5b906119da82611175565b6119e76040519182611152565b828152601f196119f78294611175565b0190602036910137565b91908201809211611a0e57565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b604081013542116126c35790611a5e611a5760208401846136f4565b90506119d0565b915f5b611a6e60208301836136f4565b90508110156125c757611a9881611a93611a8b60208601866136f4565b369391613748565b6111c6565b936040850151936001600160a01b038651169060208701518051156116a55760200151604001511515806125be575b1561256357611aec611ad886611344565b8784611ae660608a01611358565b92613add565b5f5b60208801515181101561255357611b03613788565b6020890151515f198101908111611a0e578214806020830152821582525f1461254c576060890151905b611b3b8360208c0151611691565b51604081015190919015611cee57611bd36001600160a01b03835116936001600160a01b03881685145f14611ce7576001945b60405195611b7b8761111a565b5f8752611b87816137be565b6020870152604086015260609485918d838301526080820152604051809381927f43583be500000000000000000000000000000000000000000000000000000000835260048301613a22565b03815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19384156102f1575f94611cb0575b50506020015115611c9657816001600160a01b036020611c909360019695611c388c8c611691565b5201611c67828251167f00000000000000000000000000000000000000000000000000000000000000006141c0565b5051167f000000000000000000000000000000000000000000000000000000000000000061420a565b01611aee565b602001519097506001600160a01b03169250600190611c90565b60209294509081611cd592903d10611ce0575b611ccd8183611152565b8101906137f5565b91505092905f611c10565b503d611cc3565b5f94611b6e565b888a6001600160a01b038495945116806001600160a01b038a16145f14612132575050815115905061206e57888a80151580612053575b611f4d575b6001600160a01b03939291611ddd82611e15978b5f95897f0000000000000000000000000000000000000000000000000000000000000000921680885282602052604088205c611f3c575b5050505b6001611d9c8983511660208401998b8b51169080158a14611f3657508391614223565b999092511694611db1608091828101906118d9565b93909460405197611dc1896110ea565b8852306020890152604088015260608701528501523691611381565b60a0820152604051809681927f21457897000000000000000000000000000000000000000000000000000000008352600483016139b1565b0381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19384156102f1575f94611f0c575b506020015115611ee95791611ebc826001600160a01b0360019695611e7a611ee49686611691565b51611e858d8d611691565b52611eb3828251167f00000000000000000000000000000000000000000000000000000000000000006141c0565b50511692611691565b51907f000000000000000000000000000000000000000000000000000000000000000061420a565b611c90565b98506001929450611f02906001600160a01b0392611691565b5197511692611c90565b6020919450611f2c903d805f833e611f248183611152565b810190613969565b5094919050611e52565b91614223565b611f4592614341565b5f8281611d75565b50611f5a90929192611344565b91611f648b6142fd565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000163b156102fc576040517f36c785160000000000000000000000000000000000000000000000000000000081526001600160a01b039485166004820152306024820152908416604482015292871660648401525f8380608481010381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af180156102f1578a611ddd8d611e15976001600160a01b03975f95612044575b50975092505091929350611d2a565b61204d90611106565b5f612035565b5061205d82611344565b6001600160a01b0316301415611d25565b906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016916001600160a01b0384511692803b156102fc576040517fae6393290000000000000000000000000000000000000000000000000000000081526001600160a01b03949094166004850152306024850152604484018c90525f908490606490829084905af180156102f1578a611ddd8d611e15976001600160a01b03975f95612123575b50611d79565b61212c90611106565b5f61211d565b6001600160a01b0360208796949701511690898183145f146123d7576121cd925061220597915060016121735f96956001600160a01b0393848b5116614223565b509282895116956020890151151588146123ae5761219082611344565b945b6121a1608093848101906118d9565b959096604051996121b18b6110ea565b8a52166020890152604088015260608701528501523691611381565b60a0820152604051809581927f4af29ec4000000000000000000000000000000000000000000000000000000008352600483016138f8565b0381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19283156102f1575f93612384575b5060200151156122c357816001600160a01b036020611ee493600196956122698c8c611691565b526122998383830151167f00000000000000000000000000000000000000000000000000000000000000006141c0565b500151167f000000000000000000000000000000000000000000000000000000000000000061420a565b60208181015191516040517f15afd4090000000000000000000000000000000000000000000000000000000081526001600160a01b03918216600482015260248101859052939a50909116945081806044810103815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af180156102f157612359575b50600190611c90565b602090813d831161237d575b61236f8183611152565b810103126102fc575f612350565b503d612365565b60209193506123a4903d805f833e61239c8183611152565b81019061387c565b5093919050612242565b837f00000000000000000000000000000000000000000000000000000000000000001694612192565b6001600160a01b036124669561242e9394956123f860809b8c8101906118d9565b9390946040519761240889611136565b5f8952602089015216604087015260609a8b978888015286015260a08501523691611381565b60c0820152604051809381927f2bfb780c00000000000000000000000000000000000000000000000000000000835260048301613810565b03815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19384156102f1575f94612525575b50506020015115611c9657816001600160a01b036020611ee493600196956124cb8c8c611691565b526124fb8383830151167f00000000000000000000000000000000000000000000000000000000000000006141c0565b500151167f000000000000000000000000000000000000000000000000000000000000000061420a565b6020929450908161254192903d10611ce057611ccd8183611152565b91505092905f6124a3565b5f90611b2d565b5091955090935050600101611a61565b61258d827f00000000000000000000000000000000000000000000000000000000000000006141c0565b506125b986837f000000000000000000000000000000000000000000000000000000000000000061420a565b611aec565b50321515611ac7565b50506125f27f0000000000000000000000000000000000000000000000000000000000000000613a71565b916125fd83516119d0565b7f0000000000000000000000000000000000000000000000000000000000000000917f000000000000000000000000000000000000000000000000000000000000000091905f5b86518110156126ba576001906001600160a01b0380612663838b611691565b51165f528560205261269160405f205c8261267e858d611691565b51165f528860205260405f205c90611a01565b61269b8387611691565b526126a6828a611691565b51165f52856020525f604081205d01612644565b50949391509150565b7fe08b8af0000000000000000000000000000000000000000000000000000000005f5260045ffd5b905f198201918213600116611a0e57565b7f80000000000000000000000000000000000000000000000000000000000000008114611a0e575f190190565b907f000000000000000000000000000000000000000000000000000000000000000090815c7f0000000000000000000000000000000000000000000000000000000000000000612779815c6126eb565b907f0000000000000000000000000000000000000000000000000000000000000000915b5f81121561283a575050506127b1906126eb565b917f0000000000000000000000000000000000000000000000000000000000000000925b5f8112156127ea575050505061184c906136b1565b61283590825f5261282f60205f83828220015c91828252888152886040916128228a8d8587205c906001600160a01b03891690613eb0565b8484525281205d84613e0d565b506126fc565b6127d5565b61287290825f5261282f60205f8a8785848420015c938484528181526128228c6040948587205c906001600160a01b03891690613add565b61279d565b3d156128a1573d9061288882611365565b916128966040519384611152565b82523d5f602084013e565b606090565b359065ffffffffffff821682036102fc57565b905f917f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03815c16156128f1575050565b909192505d600190565b90604082013542116126c357612917611a5760208401846136f4565b915f5b61292760208301836136f4565b90508110156135d15761294481611a93611a8b60208601866136f4565b60608101519061297e6001600160a01b038251167f00000000000000000000000000000000000000000000000000000000000000006141c0565b506020810151515f198101908111611a0e575b5f8112156129a45750505060010161291a565b6129b2816020840151611691565b516129bb613788565b9082156020830152602084015151805f19810111611a0e575f1901831480835261358f575b6020820151156135545760408401516001600160a01b03855116915b604081015115612c1d5783916001600160a01b036060926020612aa0970151151580612c14575b612bed575b5116906001600160a01b0385168203612be6576001915b60405192612a4c8461111a565b60018452612a59816137be565b6020840152604083015288838301526080820152604051809581927f43583be500000000000000000000000000000000000000000000000000000000835260048301613a22565b03815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19283156102f15787918b915f95612bbf575b506020015115612bb057612ba69284612b02612bab979694612b7594611691565b52612b366001600160a01b0382167f00000000000000000000000000000000000000000000000000000000000000006141c0565b506001600160a01b03612b4d8460408a01516137b1565b91167f000000000000000000000000000000000000000000000000000000000000000061420a565b6001600160a01b038551167f000000000000000000000000000000000000000000000000000000000000000061420a565b6126fc565b612991565b505050612bab919350926126fc565b6020919550612bdc9060603d606011611ce057611ccd8183611152565b5095919050612ae1565b5f91612a3f565b612c0f612bf98d611344565b8d8b611ae6886040888451169301519301611358565b612a28565b50321515612a23565b906001600160a01b03825116806001600160a01b038516145f14613137575060208401516130495750604051927f967870920000000000000000000000000000000000000000000000000000000084526001600160a01b03831660048501526020846024816001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165afa9384156102f1575f94613015575b5083916001600160a01b038151166001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000163b156102fc576040517fae6393290000000000000000000000000000000000000000000000000000000081526001600160a01b03909116600482015230602482015260448101959095525f8580606481010381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19081156102f157612dec955f92613006575b505b611ddd6001600160a01b03612da88b828551168360208701511690614223565b50925116918c6002612dbf608092838101906118d9565b92909360405196612dcf886110ea565b875230602088015289604088015260608701528501523691611381565b0381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19384156102f1575f94612fe3575b506020015115612ecf57908291612bab9493612e45898d611691565b52612e7a836001600160a01b0384167f000000000000000000000000000000000000000000000000000000000000000061420a565b80831080612eb4575b612e90575b5050506126fc565b612ea6612eac93612ea08b611344565b926137b1565b91614356565b5f8080612e88565b50306001600160a01b03612ec78b611344565b161415612e83565b9450908094808210612ee8575b505050612bab906126fc565b91612ef8602092612f77946137b1565b90612f2d826001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001683614356565b60405193849283927f15afd40900000000000000000000000000000000000000000000000000000000845260048401602090939291936001600160a01b0360408201951681520152565b03815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af180156102f157612fb8575b8080612edc565b602090813d8311612fdc575b612fce8183611152565b810103126102fc575f612fb1565b503d612fc4565b6020919450612ffb903d805f833e611f248183611152565b509094919050612e29565b61300f90611106565b5f612d86565b9093506020813d602011613041575b8161303160209383611152565b810103126102fc5751925f612cbc565b3d9150613024565b909261305489611344565b6001600160a01b033091160361306f575b5f612dec94612d88565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016936130a38a611344565b6130ac846142fd565b90863b156102fc576040517f36c785160000000000000000000000000000000000000000000000000000000081526001600160a01b039182166004820152306024820152918116604483015285166064820152945f908690608490829084905af19081156102f157612dec955f92613128575b50945050613065565b61313190611106565b5f61311f565b6001600160a01b036020849695940151168a8282145f1461340b5750505061320c61316e5f92846001600160a01b03885116614223565b92906131d48c6001600160a01b03808a5116938951151586146133df576131a361319784611344565b935b60808101906118d9565b929093604051966131b3886110ea565b875216602086015260408501528c6060850152600260808501523691611381565b60a0820152604051809381927f4af29ec4000000000000000000000000000000000000000000000000000000008352600483016138f8565b0381836001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19081156102f1575f916133c4575b5060208401518c908a90156133aa5783836001600160a01b03936132836132899461327c8f9c9b9a98996132b29a611691565b5192611691565b52611691565b5191167f000000000000000000000000000000000000000000000000000000000000000061420a565b51156132f457612bab92916001600160a01b036020612ba6930151167f0000000000000000000000000000000000000000000000000000000000000000614341565b516040517f15afd4090000000000000000000000000000000000000000000000000000000081526001600160a01b0390911660048201526024810191909152602081806044810103815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af180156102f15761337f575b50612bab906126fc565b602090813d83116133a3575b6133958183611152565b810103126102fc575f613375565b503d61338b565b50509091506133bb92939650611691565b519384916132b2565b6133d891503d805f833e61239c8183611152565b9050613249565b6131a3827f00000000000000000000000000000000000000000000000000000000000000001693613199565b61349e965090613466916060948b61342b608099989993848101906118d9565b9390946040519761343b89611136565b6001895260208901526001600160a01b038b1660408901528888015286015260a08501523691611381565b60c0820152604051809581927f2bfb780c00000000000000000000000000000000000000000000000000000000835260048301613810565b03815f6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af19283156102f15787918b915f9561352d575b506020015115612bb057612ba69284613505612bab9796946001600160a01b0394611691565b52167f000000000000000000000000000000000000000000000000000000000000000061420a565b602091955061354a9060603d606011611ce057611ccd8183611152565b50959190506134df565b6fffffffffffffffffffffffffffffffff6001600160a01b0360206135858188015161357f886126eb565b90611691565b51015116916129fc565b6135cc856001600160a01b0360208401611c67828251167f00000000000000000000000000000000000000000000000000000000000000006141c0565b6129e0565b50506135fc7f0000000000000000000000000000000000000000000000000000000000000000613a71565b9161360783516119d0565b7f0000000000000000000000000000000000000000000000000000000000000000917f000000000000000000000000000000000000000000000000000000000000000091905f5b86518110156126ba576001906001600160a01b038061366d838b611691565b51165f528560205261368860405f205c8261267e858d611691565b6136928387611691565b5261369d828a611691565b51165f52856020525f604081205d0161364e565b4780156136f0577f00000000000000000000000000000000000000000000000000000000000000005c6136f0576001600160a01b0361184c92166140e0565b5050565b9035907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1813603018212156102fc570180359067ffffffffffffffff82116102fc57602001918160051b360383136102fc57565b91908110156116a55760051b810135907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81813603018212156102fc570190565b604051906040820182811067ffffffffffffffff8211176110bd576040525f6020838281520152565b91908203918211611a0e57565b600211156137c857565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffd5b908160609103126102fc578051916040602083015192015190565b61010060c0610f7c93602084528051613828816137be565b602085015260208101516001600160a01b0380911660408601528060408301511660608601526060820151166080850152608081015160a085015260a08101518285015201519160e0808201520190610ffb565b90916060828403126102fc5781519167ffffffffffffffff928381116102fc57846138a8918301611573565b9360208201519360408301519081116102fc57610f7c9201611507565b9081518082526020808093019301915f5b8281106138e4575050505090565b8351855293810193928101926001016138d6565b602081526001600160a01b038083511660208301526020830151166040820152613931604083015160c0606084015260e08301906138c5565b9060608301516080820152608083015160058110156137c857610f7c9360a0918284015201519060c0601f1982850301910152610ffb565b916060838303126102fc5782519260208101519267ffffffffffffffff938481116102fc578161399a918401611573565b9360408301519081116102fc57610f7c9201611507565b602081526001600160a01b038083511660208301526020830151166040820152604082015160608201526139f4606083015160c0608084015260e08301906138c5565b90608083015160048110156137c857610f7c9360a0918284015201519060c0601f1982850301910152610ffb565b91909160808060a08301948051613a38816137be565b84526020810151613a48816137be565b60208501526001600160a01b036040820151166040850152606081015160608501520151910152565b90815c613a7d81611175565b613a8a6040519182611152565b818152613a9682611175565b601f196020910136602084013781945f5b848110613ab5575050505050565b600190825f5280845f20015c6001600160a01b03613ad38388611691565b9116905201613aa7565b919280613dd8575b15613c51575050804710613c29576001600160a01b03807f00000000000000000000000000000000000000000000000000000000000000001691823b156102fc57604051907fd0e30db00000000000000000000000000000000000000000000000000000000082525f915f8160048185895af180156102f157613c12575b506044602092937f00000000000000000000000000000000000000000000000000000000000000001694613b98838783614356565b8460405196879485937f15afd409000000000000000000000000000000000000000000000000000000008552600485015260248401525af1908115613c065750613bdf5750565b602090813d8311613bff575b613bf58183611152565b810103126102fc57565b503d613beb565b604051903d90823e3d90fd5b60209250613c1f90611106565b60445f9250613b63565b7fa01a9df6000000000000000000000000000000000000000000000000000000005f5260045ffd5b90915f9080613c61575b50505050565b6001600160a01b0393847f00000000000000000000000000000000000000000000000000000000000000001694807f00000000000000000000000000000000000000000000000000000000000000001691613cbb846142fd565b96803b156102fc576040517f36c785160000000000000000000000000000000000000000000000000000000081526001600160a01b039283166004820152848316602482015297821660448901529186161660648701525f908690608490829084905af19485156102f157613d8095613dc4575b5082936020936040518097819582947f15afd40900000000000000000000000000000000000000000000000000000000845260048401602090939291936001600160a01b0360408201951681520152565b03925af1908115613c065750613d99575b808080613c5b565b602090813d8311613dbd575b613daf8183611152565b810103126102fc575f613d91565b503d613da5565b60209350613dd190611106565b5f92613d2f565b506001600160a01b03807f00000000000000000000000000000000000000000000000000000000000000001690821614613ae5565b6001810191805f5260209183835260405f205c8015155f14613ea7575f1990818101835c8380820191828403613e6a575b5050505050815c81810192818411611a0e575f93815d835284832001015d5f52525f604081205d600190565b613e77613e87938861443a565b865f52885f2001015c918561443a565b835f52808383885f2001015d5f5285855260405f205d5f80808381613e3e565b50505050505f90565b5f949383156140d857806140a3575b15614007576001600160a01b0391827f000000000000000000000000000000000000000000000000000000000000000016803b156102fc576040517fae6393290000000000000000000000000000000000000000000000000000000081526001600160a01b03929092166004830152306024830152604482018590525f908290606490829084905af180156102f157613ff4575b5084827f000000000000000000000000000000000000000000000000000000000000000016803b15613ff05781906024604051809481937f2e1a7d4d0000000000000000000000000000000000000000000000000000000083528960048401525af18015613fe557613fcd575b5061184c939450166140e0565b613fd78691611106565b613fe15784613fc0565b8480fd5b6040513d88823e3d90fd5b5080fd5b613fff919550611106565b5f935f613f53565b929350906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016803b156102fc576040517fae6393290000000000000000000000000000000000000000000000000000000081526001600160a01b03938416600482015293909216602484015260448301525f908290606490829084905af180156102f15761409a5750565b61184c90611106565b506001600160a01b03807f00000000000000000000000000000000000000000000000000000000000000001690831614613ebf565b505050509050565b814710614130575f8080936001600160a01b038294165af1614100612877565b501561410857565b7f1425ea42000000000000000000000000000000000000000000000000000000005f5260045ffd5b7fcd786059000000000000000000000000000000000000000000000000000000005f523060045260245ffd5b90614171575080511561410857805190602001fd5b815115806141b7575b614182575090565b6001600160a01b03907f9996b315000000000000000000000000000000000000000000000000000000005f521660045260245ffd5b50803b1561417a565b6001810190825f528160205260405f205c155f1461420357805c815f52838160205f20015d60018101809111611a0e57815d5c915f5260205260405f205d600190565b5050505f90565b905f5260205261421f60405f2091825c611a01565b905d565b916044929391936001600160a01b03604094859282808551998a9586947fc9c1661b0000000000000000000000000000000000000000000000000000000086521660048501521660248301527f0000000000000000000000000000000000000000000000000000000000000000165afa9384156142f3575f935f956142bc575b50506142b96142b285946119d0565b9485611691565b52565b809295508194503d83116142ec575b6142d58183611152565b810103126102fc5760208251920151925f806142a3565b503d6142cb565b83513d5f823e3d90fd5b6001600160a01b0390818111614311571690565b7f6dfcc650000000000000000000000000000000000000000000000000000000005f5260a060045260245260445ffd5b905f5260205261421f60405f2091825c6137b1565b6040519260208401907fa9059cbb0000000000000000000000000000000000000000000000000000000082526001600160a01b038094166024860152604485015260448452608084019084821067ffffffffffffffff8311176110bd576143d5935f9384936040521694519082865af16143ce612877565b908361415c565b8051908115159182614416575b50506143eb5750565b7f5274afe7000000000000000000000000000000000000000000000000000000005f5260045260245ffd5b81925090602091810103126102fc57602001518015908115036102fc575f806143e2565b5c111561444357565b7f0f4ae0e4000000000000000000000000000000000000000000000000000000005f5260045ffdfea2646970667358221220229a5cf89aa7c2d0a4b4d5db20bba6c2b3a74b080303fc6ec00ba582a5dcf75164736f6c634300081a0033
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`\x046\x10\x15a\0rW[6\x15a\0\x18W_\x80\xFD[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\0JW\0[\x7F\x05@\xDD\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[_5`\xE0\x1C\x80c\x08\xA4e\xF6\x14a\x0E\x9DW\x80c\x19\xC6\x98\x9F\x14a\x08NW\x80c(oX\r\x14a\x07\xB7W\x80c)P(n\x14a\x06\xCCW\x80cT\xFDMP\x14a\x05\x8FW\x80cZ<9\x87\x14a\x05fW\x80c^\x01\xEBZ\x14a\x05!W\x80c\x8A\x12\xA0\x8C\x14a\x04\xC6W\x80c\x8E\xB1\xB6^\x14a\x03\xBFW\x80c\x94^\xD3?\x14a\x03DW\x80c\xAC\x96P\xD8\x14a\x03\0Wc\xE3\xB5\xDF\xF4\x03a\0\x0EW4a\x02\xFCW``\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x01-\x906\x90`\x04\x01a\x12\xC4V[a\x015a\x11\xA1V[`D5\x92\x83\x11a\x02\xFCWa\x01Pa\x01X\x936\x90`\x04\x01a\x0F\xCDV[\x93\x90\x91a(\xB9V[\x90_[\x83Q\x81\x10\x15a\x01|W\x80_\x87a\x01s`\x01\x94\x88a\x16\x91V[Q\x01R\x01a\x01[V[Pa\x01\xF0a\x01\xFEa\x029\x94a\x01\xB6_\x94\x88`@Q\x93a\x01\x9A\x85a\x11\x1AV[0\x85R` \x85\x01R_\x19`@\x85\x01R\x86``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x8A\x12\xA0\x8C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[\x03`\x1F\x19\x81\x01\x83R\x82a\x11RV[`@Q\x80\x94\x81\x92\x7F\xED\xFA5h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x92a\x02\x8E\x91_\x91a\x02\xCFW[P` \x80\x82Q\x83\x01\x01\x91\x01a\x15\xD4V[\x90\x93\x91\x92a\x02\xA7W[`@Q\x93\x84\x93\x84a\x0F/V[\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]a\x02\x97V[a\x02\xEB\x91P=\x80_\x83>a\x02\xE3\x81\x83a\x11RV[\x81\x01\x90a\x15MV[\x84a\x02~V[`@Q=_\x82>=\x90\xFD[_\x80\xFD[` `\x03\x196\x01\x12a\x02\xFCW`\x045g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x038a\x032a\x02\xA3\x926\x90`\x04\x01a\x0F\x9CV[\x90a\x17\x9BV[`@Q\x91\x82\x91\x82a\x10 V[4a\x02\xFCWa\x03R6a\x0E\xCAV[a\x03Za\x19EV[a\x03ba\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a(\xFBV[\x91\x93\x90\x94a\x03\x8A``a\x03\x83\x83a\x13DV[\x92\x01a\x13XV[\x90a')V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]`@Q\x93\x84\x93\x84a\x0F/V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x03\xEC\x906\x90`\x04\x01a\x12\xC4V[\x90a\x03\xF5a\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x04Qa\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[a\x04%3a(\xB9V[\x97`@Q\x94a\x043\x86a\x11\x1AV[3\x86R` \x86\x01R`$5`@\x86\x01R\x15\x15``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x94^\xD3?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`@Q\x80\x94\x81\x92\x7FH\xC8\x94\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x04\xDA6a\x0E\xCAV[a\x04\xE2a\x19EV[a\x04\xEAa\x19rV[a\x1A;V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x94\x92\x94]`@Q\x93\x84\x93\x84a\x0F/V[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW` \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\`\x01`\x01`\xA0\x1B\x03`@Q\x91\x16\x81R\xF3[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x05z6a\x0E\xCAV[a\x05\x82a\x19EV[a\x05\x8Aa\x19rV[a(\xFBV[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW`@Q_\x80T\x90`\x01\x82`\x01\x1C\x91`\x01\x84\x16\x91\x82\x15a\x06\xC2W[` \x94\x85\x85\x10\x84\x14a\x06\x95W\x85\x87\x94\x86\x86R\x91\x82_\x14a\x06WWPP`\x01\x14a\x05\xFEW[Pa\x05\xEA\x92P\x03\x83a\x11RV[a\x02\xA3`@Q\x92\x82\x84\x93\x84R\x83\x01\x90a\x0F\xFBV[_\x80\x80R\x85\x92P\x90\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c[\x85\x83\x10a\x06?WPPa\x05\xEA\x93P\x82\x01\x01\x85a\x05\xDDV[\x80T\x83\x89\x01\x85\x01R\x87\x94P\x86\x93\x90\x92\x01\x91\x81\x01a\x06(V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x85\x82\x01Ra\x05\xEA\x95\x15\x15`\x05\x1B\x85\x01\x01\x92P\x87\x91Pa\x05\xDD\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\"`\x04R`$_\xFD[\x92`\x7F\x16\x92a\x05\xB9V[4a\x02\xFCW```\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x06\xFE\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\x07a\x11\xA1V[`D5\x91\x82\x11a\x02\xFCWa\x07\"a\x07*\x926\x90`\x04\x01a\x0F\xCDV[\x92\x90\x91a(\xB9V[\x90_[\x84Q\x81\x10\x15a\x07_W\x80o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@a\x07V`\x01\x94\x89a\x16\x91V[Q\x01R\x01a\x07-V[Pa\x01\xF0a\x01\xFE\x85a\x07}_\x94a\x029\x97`@Q\x93a\x01\x9A\x85a\x11\x1AV[`\x80\x82\x01R`@Q\x92\x83\x91\x7FZ<9\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x07\xE4\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\xEDa\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x08\x14a\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x08\xA4e\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[`\xA0`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x11a\x02\xFCW6`#`\x045\x01\x12\x15a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045`\x04\x015\x11a\x02\xFCW6`$`\xC0`\x045`\x04\x015\x02`\x045\x01\x01\x11a\x02\xFCW`$5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x08\xC4\x906\x90`\x04\x01a\x0F\x9CV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D5\x11a\x02\xFCW```\x03\x19`D56\x03\x01\x12a\x02\xFCW`d5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t\x05\x906\x90`\x04\x01a\x0F\xCDV[`\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t%\x906\x90`\x04\x01a\x0F\x9CV[\x94\x90\x93a\t0a\x19EV[\x80`\x045`\x04\x015\x03a\x0EuW_[`\x045`\x04\x015\x81\x10a\x0B\xD2WPPP`D5`\x04\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDD`D56\x03\x01\x82\x12\x15a\x02\xFCW\x81`D5\x01`\x04\x81\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW`$\x82`\x07\x1B6\x03\x91\x01\x13a\x02\xFCWa\t\xE3W[a\x02\xA3a\x038\x86\x86_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]a\x17\x9BV[`\x01`\x01`\xA0\x1B\x03\x94\x92\x94\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x94\x7F*-\x80\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R3`\x04\x87\x01R```$\x87\x01R`\xC4\x86\x01\x92`D5\x01`$\x81\x01\x93g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04\x83\x015\x11a\x02\xFCW`\x04\x82\x015`\x07\x1B6\x03\x85\x13a\x02\xFCW```d\x89\x01R`\x04\x82\x015\x90R\x91\x92\x86\x92`\xE4\x84\x01\x92\x91\x90_\x90[`\x04\x81\x015\x82\x10a\x0BTWPPP` \x91`\x1F\x19`\x1F\x86_\x97\x87\x95`\x01`\x01`\xA0\x1B\x03a\n\xC8`$`D5\x01a\x11\x8DV[\x16`\x84\x88\x01R`D\x805\x015`\xA4\x88\x01R`\x03\x19\x87\x87\x03\x01`D\x88\x01R\x81\x86R\x87\x86\x017\x87\x86\x82\x86\x01\x01R\x01\x16\x01\x03\x01\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x93a\x038\x93a\x0BEW[\x82\x94P\x81\x93Pa\t\xB3V[a\x0BN\x90a\x11\x06V[\x84a\x0B:V[\x91\x95\x94P\x91\x92`\x01`\x01`\xA0\x1B\x03a\x0Bk\x87a\x11\x8DV[\x16\x81R` \x80\x87\x015\x91`\x01`\x01`\xA0\x1B\x03\x83\x16\x80\x93\x03a\x02\xFCW`\x04\x92`\x01\x92\x82\x01Ra\x0B\x9B`@\x89\x01a(\xA6V[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x91\x16`@\x83\x01Ra\x0B\xB6``\x8A\x01a(\xA6V[\x16``\x82\x01R`\x80\x80\x91\x01\x97\x01\x93\x01\x90P\x88\x94\x95\x93\x92\x91a\n\x97V[a\x0B\xE7a\x0B\xE0\x82\x84\x86a\x19*V[6\x91a\x13\x81V[`@Qa\x0B\xF3\x81a\x10\xA1V[_\x81R` \x91_\x83\x83\x01R_`@\x83\x01R\x82\x81\x01Q\x90```@\x82\x01Q\x91\x01Q_\x1A\x91\x83R\x83\x83\x01R`@\x82\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDC\x81\x85\x02`\x045\x016\x03\x01\x12a\x02\xFCW`@Q\x90a\x0C`\x82a\x10\xEAV[a\x0Cs`$`\xC0\x86\x02`\x045\x01\x01a\x11\x8DV[\x80\x83Ra\x0C\x89`D`\xC0\x87\x02`\x045\x01\x01a\x11\x8DV[\x90\x81\x85\x85\x01Ra\x0C\xA2`d`\xC0\x88\x02`\x045\x01\x01a\x11\x8DV[`@\x85\x81\x01\x91\x90\x91R`\x045`\xC0\x88\x02\x01`\x84\x81\x015``\x87\x01R`\xA4\x81\x015`\x80\x87\x01R`\xC4\x015`\xA0\x86\x01R\x83\x01Q\x83Q\x93\x86\x01Q`\xFF\x91\x90\x91\x16\x92`\x01`\x01`\xA0\x1B\x03\x83\x16;\x15a\x02\xFCW_`\x01`\x01`\xA0\x1B\x03\x80\x94`\xE4\x94\x8B\x98\x84\x98`\xC4`\xC0`@Q\x9C\x8D\x9B\x8C\x9A\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8CR\x16`\x04\x8B\x01R0`$\x8B\x01R`\x84\x82\x82\x02`\x045\x01\x015`D\x8B\x01R\x02`\x045\x01\x015`d\x88\x01R`\x84\x87\x01R`\xA4\x86\x01R`\xC4\x85\x01R\x16Z\xF1\x90\x81a\x0EfW[Pa\x0E\\Wa\r\x7Fa(wV[\x90`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x81\x83\x01Q\x16`D`@Q\x80\x95\x81\x93\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01R0`$\x83\x01RZ\xFA\x91\x82\x15a\x02\xF1W_\x92a\x0E,W[P``\x01Q\x03a\r\xF7WPP`\x01\x90[\x01a\t?V[\x80Q\x15a\x0E\x04W\x80Q\x91\x01\xFD[\x7F\xA7(V\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x0EUW[a\x0ED\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x90``a\r\xE1V[P=a\x0E:V[PP`\x01\x90a\r\xF1V[a\x0Eo\x90a\x11\x06V[\x8Aa\rrV[\x7F\xAA\xAD\x13\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[4a\x02\xFCWa\x0E\xAB6a\x0E\xCAV[a\x0E\xB3a\x19EV[a\x0E\xBBa\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a\x1A;V[`\x03\x19\x90` \x82\x82\x01\x12a\x02\xFCW`\x045\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW\x82`\xA0\x92\x03\x01\x12a\x02\xFCW`\x04\x01\x90V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a\x0F\x1BWPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a\x0F\rV[\x93\x92\x90a\x0FD\x90``\x86R``\x86\x01\x90a\x0E\xFCV[\x93` \x94\x81\x81\x03` \x83\x01R` \x80\x85Q\x92\x83\x81R\x01\x94\x01\x90_[\x81\x81\x10a\x0F\x7FWPPPa\x0F|\x93\x94P`@\x81\x84\x03\x91\x01Ra\x0E\xFCV[\x90V[\x82Q`\x01`\x01`\xA0\x1B\x03\x16\x86R\x94\x87\x01\x94\x91\x87\x01\x91`\x01\x01a\x0F_V[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x80\x85\x01\x94\x84`\x05\x1B\x01\x01\x11a\x02\xFCWV[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x83\x81\x86\x01\x95\x01\x01\x11a\x02\xFCWV[\x90`\x1F\x19`\x1F` \x80\x94\x80Q\x91\x82\x91\x82\x87R\x01\x86\x86\x01^_\x85\x82\x86\x01\x01R\x01\x16\x01\x01\x90V[` \x80\x82\x01\x90` \x83R\x83Q\x80\x92R`@\x83\x01\x92` `@\x84`\x05\x1B\x83\x01\x01\x95\x01\x93_\x91[\x84\x83\x10a\x10UWPPPPPP\x90V[\x90\x91\x92\x93\x94\x95\x84\x80a\x10\x91\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC0\x86`\x01\x96\x03\x01\x87R\x8AQa\x0F\xFBV[\x98\x01\x93\x01\x93\x01\x91\x94\x93\x92\x90a\x10EV[``\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`\xC0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`@RV[`\xA0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[`\xE0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x90`\x1F`\x1F\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x05\x1B` \x01\x90V[5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`D5\x90\x81\x15\x15\x82\x03a\x02\xFCWV[\x91\x90\x91`\x80\x81\x84\x03\x12a\x02\xFCW`@\x90\x81Q\x91`\x80\x83\x01\x94g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x84\x81\x10\x87\x82\x11\x17a\x10\xBDW\x82R\x83\x95a\x12\0\x84a\x11\x8DV[\x85R` \x90\x81\x85\x015\x90\x81\x11a\x02\xFCW\x84\x01\x82`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x90a\x12)\x82a\x11uV[\x93a\x126\x86Q\x95\x86a\x11RV[\x82\x85R\x83\x85\x01\x90\x84``\x80\x95\x02\x84\x01\x01\x92\x81\x84\x11a\x02\xFCW\x85\x01\x91[\x83\x83\x10a\x12tWPPPPP\x84\x01R\x81\x81\x015\x90\x83\x01R``\x90\x81\x015\x91\x01RV[\x84\x83\x83\x03\x12a\x02\xFCW\x87Q\x90a\x12\x89\x82a\x10\xA1V[a\x12\x92\x84a\x11\x8DV[\x82Ra\x12\x9F\x87\x85\x01a\x11\x8DV[\x87\x83\x01R\x88\x84\x015\x90\x81\x15\x15\x82\x03a\x02\xFCW\x82\x88\x92\x8B\x89\x95\x01R\x81R\x01\x92\x01\x91a\x12RV[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x91` \x91a\x12\xDE\x84a\x11uV[\x93a\x12\xEC`@Q\x95\x86a\x11RV[\x80\x85R\x83\x80\x86\x01\x91`\x05\x1B\x83\x01\x01\x92\x80\x84\x11a\x02\xFCW\x84\x83\x01\x91[\x84\x83\x10a\x13\x17WPPPPPP\x90V[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCW\x86\x91a\x139\x84\x84\x80\x94\x89\x01\x01a\x11\xC6V[\x81R\x01\x92\x01\x91a\x13\x07V[5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x90V[5\x80\x15\x15\x81\x03a\x02\xFCW\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x13\x8D\x82a\x13eV[\x91a\x13\x9B`@Q\x93\x84a\x11RV[\x82\x94\x81\x84R\x81\x83\x01\x11a\x02\xFCW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90`\x80\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x80\x82Q\x16\x83R` \x93\x84\x83\x01Q\x94`\x80\x81\x86\x01R\x85Q\x80\x92R\x80`\xA0\x86\x01\x96\x01\x92_\x90[\x83\x82\x10a\x14\x0BWPPPPP``\x81`@\x82\x93\x01Q`@\x85\x01R\x01Q\x91\x01R\x90V[\x84Q\x80Q\x82\x16\x89R\x80\x84\x01Q\x82\x16\x89\x85\x01R`@\x90\x81\x01Q\x15\x15\x90\x89\x01R``\x90\x97\x01\x96\x93\x82\x01\x93`\x01\x90\x91\x01\x90a\x13\xE9V[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x14\xBDWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x14\xF8\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x14\x81V[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x80Q\x90a\x15\x1E\x82a\x13eV[\x92a\x15,`@Q\x94\x85a\x11RV[\x82\x84R` \x83\x83\x01\x01\x11a\x02\xFCW\x81_\x92` \x80\x93\x01\x83\x86\x01^\x83\x01\x01R\x90V[\x90` \x82\x82\x03\x12a\x02\xFCW\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x80`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x90` \x91a\x15\x8E\x81a\x11uV[\x93a\x15\x9C`@Q\x95\x86a\x11RV[\x81\x85R` \x80\x86\x01\x92`\x05\x1B\x82\x01\x01\x92\x83\x11a\x02\xFCW` \x01\x90[\x82\x82\x10a\x15\xC5WPPPP\x90V[\x81Q\x81R\x90\x83\x01\x90\x83\x01a\x15\xB7V[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a\x16\0\x91\x83\x01a\x15sV[\x93` \x80\x83\x01Q\x85\x81\x11a\x02\xFCW\x83\x01\x90\x82`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x91a\x16(\x83a\x11uV[\x92a\x166`@Q\x94\x85a\x11RV[\x80\x84R\x82\x80\x85\x01\x91`\x05\x1B\x83\x01\x01\x91\x85\x83\x11a\x02\xFCW\x83\x01\x90[\x82\x82\x10a\x16rWPPPP\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15sV[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x81R\x90\x83\x01\x90\x83\x01a\x16PV[\x80Q\x82\x10\x15a\x16\xA5W` \x91`\x05\x1B\x01\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x17QWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x17\x8C\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x17\x15V[\x91\x90a\x17\xA63a(\xB9V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x84\\a\x18\xB1W`\x01\x90`\x01\x86]a\x17\xDF\x83a\x11uV[\x92a\x17\xED`@Q\x94\x85a\x11RV[\x80\x84R`\x1F\x19a\x17\xFC\x82a\x11uV[\x01_[\x81\x81\x10a\x18\xA0WPP_[\x81\x81\x10a\x18WWPPPP\x90_a\x18L\x92\x94]\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\\\x91a\x18NW[Pa6\xB1V[V[_\x90]_a\x18FV[\x80a\x18\x84_\x80a\x18la\x0B\xE0\x89\x96\x88\x8Aa\x19*V[` \x81Q\x91\x010Z\xF4a\x18}a(wV[\x900aA\\V[a\x18\x8E\x82\x88a\x16\x91V[Ra\x18\x99\x81\x87a\x16\x91V[P\x01a\x18\nV[\x80``` \x80\x93\x89\x01\x01R\x01a\x17\xFFV[\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x816\x03\x83\x13a\x02\xFCWV[\x90\x82\x10\x15a\x16\xA5Wa\x19A\x91`\x05\x1B\x81\x01\x90a\x18\xD9V[\x90\x91V[\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x80\\a\x18\xB1W`\x01\x90]V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\x19\xA4WV[\x7F\x08\x96v\xD5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R3`\x04R`$_\xFD[\x90a\x19\xDA\x82a\x11uV[a\x19\xE7`@Q\x91\x82a\x11RV[\x82\x81R`\x1F\x19a\x19\xF7\x82\x94a\x11uV[\x01\x90` 6\x91\x017V[\x91\x90\x82\x01\x80\x92\x11a\x1A\x0EWV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[`@\x81\x015B\x11a&\xC3W\x90a\x1A^a\x1AW` \x84\x01\x84a6\xF4V[\x90Pa\x19\xD0V[\x91_[a\x1An` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a%\xC7Wa\x1A\x98\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[6\x93\x91a7HV[a\x11\xC6V[\x93`@\x85\x01Q\x93`\x01`\x01`\xA0\x1B\x03\x86Q\x16\x90` \x87\x01Q\x80Q\x15a\x16\xA5W` \x01Q`@\x01Q\x15\x15\x80a%\xBEW[\x15a%cWa\x1A\xECa\x1A\xD8\x86a\x13DV[\x87\x84a\x1A\xE6``\x8A\x01a\x13XV[\x92a:\xDDV[_[` \x88\x01QQ\x81\x10\x15a%SWa\x1B\x03a7\x88V[` \x89\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW\x82\x14\x80` \x83\x01R\x82\x15\x82R_\x14a%LW``\x89\x01Q\x90[a\x1B;\x83` \x8C\x01Qa\x16\x91V[Q`@\x81\x01Q\x90\x91\x90\x15a\x1C\xEEWa\x1B\xD3`\x01`\x01`\xA0\x1B\x03\x83Q\x16\x93`\x01`\x01`\xA0\x1B\x03\x88\x16\x85\x14_\x14a\x1C\xE7W`\x01\x94[`@Q\x95a\x1B{\x87a\x11\x1AV[_\x87Ra\x1B\x87\x81a7\xBEV[` \x87\x01R`@\x86\x01R``\x94\x85\x91\x8D\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x93\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1C\xB0W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1C\x90\x93`\x01\x96\x95a\x1C8\x8C\x8Ca\x16\x91V[R\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x01a\x1A\xEEV[` \x01Q\x90\x97P`\x01`\x01`\xA0\x1B\x03\x16\x92P`\x01\x90a\x1C\x90V[` \x92\x94P\x90\x81a\x1C\xD5\x92\x90=\x10a\x1C\xE0W[a\x1C\xCD\x81\x83a\x11RV[\x81\x01\x90a7\xF5V[\x91PP\x92\x90_a\x1C\x10V[P=a\x1C\xC3V[_\x94a\x1BnV[\x88\x8A`\x01`\x01`\xA0\x1B\x03\x84\x95\x94Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x8A\x16\x14_\x14a!2WPP\x81Q\x15\x90Pa nW\x88\x8A\x80\x15\x15\x80a SW[a\x1FMW[`\x01`\x01`\xA0\x1B\x03\x93\x92\x91a\x1D\xDD\x82a\x1E\x15\x97\x8B_\x95\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\x16\x80\x88R\x82` R`@\x88 \\a\x1F<W[PPP[`\x01a\x1D\x9C\x89\x83Q\x16` \x84\x01\x99\x8B\x8BQ\x16\x90\x80\x15\x8A\x14a\x1F6WP\x83\x91aB#V[\x99\x90\x92Q\x16\x94a\x1D\xB1`\x80\x91\x82\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a\x1D\xC1\x89a\x10\xEAV[\x88R0` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x96\x81\x92\x7F!Ex\x97\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a9\xB1V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1F\x0CW[P` \x01Q\x15a\x1E\xE9W\x91a\x1E\xBC\x82`\x01`\x01`\xA0\x1B\x03`\x01\x96\x95a\x1Eza\x1E\xE4\x96\x86a\x16\x91V[Qa\x1E\x85\x8D\x8Da\x16\x91V[Ra\x1E\xB3\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x92a\x16\x91V[Q\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1C\x90V[\x98P`\x01\x92\x94Pa\x1F\x02\x90`\x01`\x01`\xA0\x1B\x03\x92a\x16\x91V[Q\x97Q\x16\x92a\x1C\x90V[` \x91\x94Pa\x1F,\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[\x81\x01\x90a9iV[P\x94\x91\x90Pa\x1ERV[\x91aB#V[a\x1FE\x92aCAV[_\x82\x81a\x1DuV[Pa\x1FZ\x90\x92\x91\x92a\x13DV[\x91a\x1Fd\x8BaB\xFDV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x04\x82\x01R0`$\x82\x01R\x90\x84\x16`D\x82\x01R\x92\x87\x16`d\x84\x01R_\x83\x80`\x84\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a DW[P\x97P\x92PP\x91\x92\x93Pa\x1D*V[a M\x90a\x11\x06V[_a 5V[Pa ]\x82a\x13DV[`\x01`\x01`\xA0\x1B\x03\x160\x14\x15a\x1D%V[\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91`\x01`\x01`\xA0\x1B\x03\x84Q\x16\x92\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`\x04\x85\x01R0`$\x85\x01R`D\x84\x01\x8C\x90R_\x90\x84\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a!#W[Pa\x1DyV[a!,\x90a\x11\x06V[_a!\x1DV[`\x01`\x01`\xA0\x1B\x03` \x87\x96\x94\x97\x01Q\x16\x90\x89\x81\x83\x14_\x14a#\xD7Wa!\xCD\x92Pa\"\x05\x97\x91P`\x01a!s_\x96\x95`\x01`\x01`\xA0\x1B\x03\x93\x84\x8BQ\x16aB#V[P\x92\x82\x89Q\x16\x95` \x89\x01Q\x15\x15\x88\x14a#\xAEWa!\x90\x82a\x13DV[\x94[a!\xA1`\x80\x93\x84\x81\x01\x90a\x18\xD9V[\x95\x90\x96`@Q\x99a!\xB1\x8Ba\x10\xEAV[\x8AR\x16` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x95\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W_\x93a#\x84W[P` \x01Q\x15a\"\xC3W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a\"i\x8C\x8Ca\x16\x91V[Ra\"\x99\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x81\x81\x01Q\x91Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R`$\x81\x01\x85\x90R\x93\x9AP\x90\x91\x16\x94P\x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa#YW[P`\x01\x90a\x1C\x90V[` \x90\x81=\x83\x11a#}W[a#o\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a#PV[P=a#eV[` \x91\x93Pa#\xA4\x90=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x81\x01\x90a8|V[P\x93\x91\x90Pa\"BV[\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a!\x92V[`\x01`\x01`\xA0\x1B\x03a$f\x95a$.\x93\x94\x95a#\xF8`\x80\x9B\x8C\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a$\x08\x89a\x116V[_\x89R` \x89\x01R\x16`@\x87\x01R``\x9A\x8B\x97\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x93\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a%%W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a$\xCB\x8C\x8Ca\x16\x91V[Ra$\xFB\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x92\x94P\x90\x81a%A\x92\x90=\x10a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[\x91PP\x92\x90_a$\xA3V[_\x90a\x1B-V[P\x91\x95P\x90\x93PP`\x01\x01a\x1AaV[a%\x8D\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[Pa%\xB9\x86\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1A\xECV[P2\x15\x15a\x1A\xC7V[PPa%\xF2\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a%\xFD\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a&c\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra&\x91`@_ \\\x82a&~\x85\x8Da\x16\x91V[Q\x16_R\x88` R`@_ \\\x90a\x1A\x01V[a&\x9B\x83\x87a\x16\x91V[Ra&\xA6\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a&DV[P\x94\x93\x91P\x91PV[\x7F\xE0\x8B\x8A\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90_\x19\x82\x01\x91\x82\x13`\x01\x16a\x1A\x0EWV[\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x1A\x0EW_\x19\x01\x90V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x81\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a'y\x81\\a&\xEBV[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91[_\x81\x12\x15a(:WPPPa'\xB1\x90a&\xEBV[\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92[_\x81\x12\x15a'\xEAWPPPPa\x18L\x90a6\xB1V[a(5\x90\x82_Ra(/` _\x83\x82\x82 \x01\\\x91\x82\x82R\x88\x81R\x88`@\x91a(\"\x8A\x8D\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a>\xB0V[\x84\x84RR\x81 ]\x84a>\rV[Pa&\xFCV[a'\xD5V[a(r\x90\x82_Ra(/` _\x8A\x87\x85\x84\x84 \x01\\\x93\x84\x84R\x81\x81Ra(\"\x8C`@\x94\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a:\xDDV[a'\x9DV[=\x15a(\xA1W=\x90a(\x88\x82a\x13eV[\x91a(\x96`@Q\x93\x84a\x11RV[\x82R=_` \x84\x01>V[``\x90V[5\x90e\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x82\x03a\x02\xFCWV[\x90_\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x81\\\x16\x15a(\xF1WPPV[\x90\x91\x92P]`\x01\x90V[\x90`@\x82\x015B\x11a&\xC3Wa)\x17a\x1AW` \x84\x01\x84a6\xF4V[\x91_[a)'` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a5\xD1Wa)D\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[``\x81\x01Q\x90a)~`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P` \x81\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW[_\x81\x12\x15a)\xA4WPPP`\x01\x01a)\x1AV[a)\xB2\x81` \x84\x01Qa\x16\x91V[Qa)\xBBa7\x88V[\x90\x82\x15` \x83\x01R` \x84\x01QQ\x80_\x19\x81\x01\x11a\x1A\x0EW_\x19\x01\x83\x14\x80\x83Ra5\x8FW[` \x82\x01Q\x15a5TW`@\x84\x01Q`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x91[`@\x81\x01Q\x15a,\x1DW\x83\x91`\x01`\x01`\xA0\x1B\x03``\x92` a*\xA0\x97\x01Q\x15\x15\x80a,\x14W[a+\xEDW[Q\x16\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x82\x03a+\xE6W`\x01\x91[`@Q\x92a*L\x84a\x11\x1AV[`\x01\x84Ra*Y\x81a7\xBEV[` \x84\x01R`@\x83\x01R\x88\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x95\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a+\xBFW[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a+\x02a+\xAB\x97\x96\x94a+u\x94a\x16\x91V[Ra+6`\x01`\x01`\xA0\x1B\x03\x82\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P`\x01`\x01`\xA0\x1B\x03a+M\x84`@\x8A\x01Qa7\xB1V[\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a&\xFCV[a)\x91V[PPPa+\xAB\x91\x93P\x92a&\xFCV[` \x91\x95Pa+\xDC\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa*\xE1V[_\x91a*?V[a,\x0Fa+\xF9\x8Da\x13DV[\x8D\x8Ba\x1A\xE6\x88`@\x88\x84Q\x16\x93\x01Q\x93\x01a\x13XV[a*(V[P2\x15\x15a*#V[\x90`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x85\x16\x14_\x14a17WP` \x84\x01Qa0IWP`@Q\x92\x7F\x96xp\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x85\x01R` \x84`$\x81`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15a\x02\xF1W_\x94a0\x15W[P\x83\x91`\x01`\x01`\xA0\x1B\x03\x81Q\x16`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x95\x90\x95R_\x85\x80`d\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a0\x06W[P[a\x1D\xDD`\x01`\x01`\xA0\x1B\x03a-\xA8\x8B\x82\x85Q\x16\x83` \x87\x01Q\x16\x90aB#V[P\x92Q\x16\x91\x8C`\x02a-\xBF`\x80\x92\x83\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a-\xCF\x88a\x10\xEAV[\x87R0` \x88\x01R\x89`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a/\xE3W[P` \x01Q\x15a.\xCFW\x90\x82\x91a+\xAB\x94\x93a.E\x89\x8Da\x16\x91V[Ra.z\x83`\x01`\x01`\xA0\x1B\x03\x84\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x80\x83\x10\x80a.\xB4W[a.\x90W[PPPa&\xFCV[a.\xA6a.\xAC\x93a.\xA0\x8Ba\x13DV[\x92a7\xB1V[\x91aCVV[_\x80\x80a.\x88V[P0`\x01`\x01`\xA0\x1B\x03a.\xC7\x8Ba\x13DV[\x16\x14\x15a.\x83V[\x94P\x90\x80\x94\x80\x82\x10a.\xE8W[PPPa+\xAB\x90a&\xFCV[\x91a.\xF8` \x92a/w\x94a7\xB1V[\x90a/-\x82`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83aCVV[`@Q\x93\x84\x92\x83\x92\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa/\xB8W[\x80\x80a.\xDCV[` \x90\x81=\x83\x11a/\xDCW[a/\xCE\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a/\xB1V[P=a/\xC4V[` \x91\x94Pa/\xFB\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[P\x90\x94\x91\x90Pa.)V[a0\x0F\x90a\x11\x06V[_a-\x86V[\x90\x93P` \x81=` \x11a0AW[\x81a01` \x93\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x92_a,\xBCV[=\x91Pa0$V[\x90\x92a0T\x89a\x13DV[`\x01`\x01`\xA0\x1B\x030\x91\x16\x03a0oW[_a-\xEC\x94a-\x88V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a0\xA3\x8Aa\x13DV[a0\xAC\x84aB\xFDV[\x90\x86;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R0`$\x82\x01R\x91\x81\x16`D\x83\x01R\x85\x16`d\x82\x01R\x94_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a1(W[P\x94PPa0eV[a11\x90a\x11\x06V[_a1\x1FV[`\x01`\x01`\xA0\x1B\x03` \x84\x96\x95\x94\x01Q\x16\x8A\x82\x82\x14_\x14a4\x0BWPPPa2\x0Ca1n_\x92\x84`\x01`\x01`\xA0\x1B\x03\x88Q\x16aB#V[\x92\x90a1\xD4\x8C`\x01`\x01`\xA0\x1B\x03\x80\x8AQ\x16\x93\x89Q\x15\x15\x86\x14a3\xDFWa1\xA3a1\x97\x84a\x13DV[\x93[`\x80\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a1\xB3\x88a\x10\xEAV[\x87R\x16` \x86\x01R`@\x85\x01R\x8C``\x85\x01R`\x02`\x80\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x93\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1W_\x91a3\xC4W[P` \x84\x01Q\x8C\x90\x8A\x90\x15a3\xAAW\x83\x83`\x01`\x01`\xA0\x1B\x03\x93a2\x83a2\x89\x94a2|\x8F\x9C\x9B\x9A\x98\x99a2\xB2\x9Aa\x16\x91V[Q\x92a\x16\x91V[Ra\x16\x91V[Q\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[Q\x15a2\xF4Wa+\xAB\x92\x91`\x01`\x01`\xA0\x1B\x03` a+\xA6\x93\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aCAV[Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R` \x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa3\x7FW[Pa+\xAB\x90a&\xFCV[` \x90\x81=\x83\x11a3\xA3W[a3\x95\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a3uV[P=a3\x8BV[PP\x90\x91Pa3\xBB\x92\x93\x96Pa\x16\x91V[Q\x93\x84\x91a2\xB2V[a3\xD8\x91P=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x90Pa2IV[a1\xA3\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a1\x99V[a4\x9E\x96P\x90a4f\x91``\x94\x8Ba4+`\x80\x99\x98\x99\x93\x84\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a4;\x89a\x116V[`\x01\x89R` \x89\x01R`\x01`\x01`\xA0\x1B\x03\x8B\x16`@\x89\x01R\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x95\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a5-W[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a5\x05a+\xAB\x97\x96\x94`\x01`\x01`\xA0\x1B\x03\x94a\x16\x91V[R\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x91\x95Pa5J\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa4\xDFV[o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x01`\x01`\xA0\x1B\x03` a5\x85\x81\x88\x01Qa5\x7F\x88a&\xEBV[\x90a\x16\x91V[Q\x01Q\x16\x91a)\xFCV[a5\xCC\x85`\x01`\x01`\xA0\x1B\x03` \x84\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[a)\xE0V[PPa5\xFC\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a6\x07\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a6m\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra6\x88`@_ \\\x82a&~\x85\x8Da\x16\x91V[a6\x92\x83\x87a\x16\x91V[Ra6\x9D\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a6NV[G\x80\x15a6\xF0W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\a6\xF0W`\x01`\x01`\xA0\x1B\x03a\x18L\x92\x16a@\xE0V[PPV[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x02\xFCWV[\x91\x90\x81\x10\x15a\x16\xA5W`\x05\x1B\x81\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x90V[`@Q\x90`@\x82\x01\x82\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@R_` \x83\x82\x81R\x01RV[\x91\x90\x82\x03\x91\x82\x11a\x1A\x0EWV[`\x02\x11\x15a7\xC8WV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x90\x81``\x91\x03\x12a\x02\xFCW\x80Q\x91`@` \x83\x01Q\x92\x01Q\x90V[a\x01\0`\xC0a\x0F|\x93` \x84R\x80Qa8(\x81a7\xBEV[` \x85\x01R` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x91\x16`@\x86\x01R\x80`@\x83\x01Q\x16``\x86\x01R``\x82\x01Q\x16`\x80\x85\x01R`\x80\x81\x01Q`\xA0\x85\x01R`\xA0\x81\x01Q\x82\x85\x01R\x01Q\x91`\xE0\x80\x82\x01R\x01\x90a\x0F\xFBV[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a8\xA8\x91\x83\x01a\x15sV[\x93` \x82\x01Q\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a8\xE4WPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a8\xD6V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01Ra91`@\x83\x01Q`\xC0``\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90``\x83\x01Q`\x80\x82\x01R`\x80\x83\x01Q`\x05\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91``\x83\x83\x03\x12a\x02\xFCW\x82Q\x92` \x81\x01Q\x92g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x81\x11a\x02\xFCW\x81a9\x9A\x91\x84\x01a\x15sV[\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01R`@\x82\x01Q``\x82\x01Ra9\xF4``\x83\x01Q`\xC0`\x80\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90`\x80\x83\x01Q`\x04\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91\x90\x91`\x80\x80`\xA0\x83\x01\x94\x80Qa:8\x81a7\xBEV[\x84R` \x81\x01Qa:H\x81a7\xBEV[` \x85\x01R`\x01`\x01`\xA0\x1B\x03`@\x82\x01Q\x16`@\x85\x01R``\x81\x01Q``\x85\x01R\x01Q\x91\x01RV[\x90\x81\\a:}\x81a\x11uV[a:\x8A`@Q\x91\x82a\x11RV[\x81\x81Ra:\x96\x82a\x11uV[`\x1F\x19` \x91\x016` \x84\x017\x81\x94_[\x84\x81\x10a:\xB5WPPPPPV[`\x01\x90\x82_R\x80\x84_ \x01\\`\x01`\x01`\xA0\x1B\x03a:\xD3\x83\x88a\x16\x91V[\x91\x16\x90R\x01a:\xA7V[\x91\x92\x80a=\xD8W[\x15a<QWPP\x80G\x10a<)W`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x82;\x15a\x02\xFCW`@Q\x90\x7F\xD0\xE3\r\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R_\x91_\x81`\x04\x81\x85\x89Z\xF1\x80\x15a\x02\xF1Wa<\x12W[P`D` \x92\x93\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a;\x98\x83\x87\x83aCVV[\x84`@Q\x96\x87\x94\x85\x93\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85R`\x04\x85\x01R`$\x84\x01RZ\xF1\x90\x81\x15a<\x06WPa;\xDFWPV[` \x90\x81=\x83\x11a;\xFFW[a;\xF5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWV[P=a;\xEBV[`@Q\x90=\x90\x82>=\x90\xFD[` \x92Pa<\x1F\x90a\x11\x06V[`D_\x92Pa;cV[\x7F\xA0\x1A\x9D\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91_\x90\x80a<aW[PPPPV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91a<\xBB\x84aB\xFDV[\x96\x80;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R\x84\x83\x16`$\x82\x01R\x97\x82\x16`D\x89\x01R\x91\x86\x16\x16`d\x87\x01R_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x94\x85\x15a\x02\xF1Wa=\x80\x95a=\xC4W[P\x82\x93` \x93`@Q\x80\x97\x81\x95\x82\x94\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x92Z\xF1\x90\x81\x15a<\x06WPa=\x99W[\x80\x80\x80a<[V[` \x90\x81=\x83\x11a=\xBDW[a=\xAF\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a=\x91V[P=a=\xA5V[` \x93Pa=\xD1\x90a\x11\x06V[_\x92a=/V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x82\x16\x14a:\xE5V[`\x01\x81\x01\x91\x80_R` \x91\x83\x83R`@_ \\\x80\x15\x15_\x14a>\xA7W_\x19\x90\x81\x81\x01\x83\\\x83\x80\x82\x01\x91\x82\x84\x03a>jW[PPPPP\x81\\\x81\x81\x01\x92\x81\x84\x11a\x1A\x0EW_\x93\x81]\x83R\x84\x83 \x01\x01]_RR_`@\x81 ]`\x01\x90V[a>wa>\x87\x93\x88aD:V[\x86_R\x88_ \x01\x01\\\x91\x85aD:V[\x83_R\x80\x83\x83\x88_ \x01\x01]_R\x85\x85R`@_ ]_\x80\x80\x83\x81a>>V[PPPPP_\x90V[_\x94\x93\x83\x15a@\xD8W\x80a@\xA3W[\x15a@\x07W`\x01`\x01`\xA0\x1B\x03\x91\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`\x04\x83\x01R0`$\x83\x01R`D\x82\x01\x85\x90R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa?\xF4W[P\x84\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a?\xF0W\x81\x90`$`@Q\x80\x94\x81\x93\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R\x89`\x04\x84\x01RZ\xF1\x80\x15a?\xE5Wa?\xCDW[Pa\x18L\x93\x94P\x16a@\xE0V[a?\xD7\x86\x91a\x11\x06V[a?\xE1W\x84a?\xC0V[\x84\x80\xFD[`@Q=\x88\x82>=\x90\xFD[P\x80\xFD[a?\xFF\x91\x95Pa\x11\x06V[_\x93_a?SV[\x92\x93P\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x93\x90\x92\x16`$\x84\x01R`D\x83\x01R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa@\x9AWPV[a\x18L\x90a\x11\x06V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x83\x16\x14a>\xBFV[PPPP\x90PV[\x81G\x10aA0W_\x80\x80\x93`\x01`\x01`\xA0\x1B\x03\x82\x94\x16Z\xF1aA\0a(wV[P\x15aA\x08WV[\x7F\x14%\xEAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x7F\xCDx`Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R0`\x04R`$_\xFD[\x90aAqWP\x80Q\x15aA\x08W\x80Q\x90` \x01\xFD[\x81Q\x15\x80aA\xB7W[aA\x82WP\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x7F\x99\x96\xB3\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R\x16`\x04R`$_\xFD[P\x80;\x15aAzV[`\x01\x81\x01\x90\x82_R\x81` R`@_ \\\x15_\x14aB\x03W\x80\\\x81_R\x83\x81` _ \x01]`\x01\x81\x01\x80\x91\x11a\x1A\x0EW\x81]\\\x91_R` R`@_ ]`\x01\x90V[PPP_\x90V[\x90_R` RaB\x1F`@_ \x91\x82\\a\x1A\x01V[\x90]V[\x91`D\x92\x93\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x94\x85\x92\x82\x80\x85Q\x99\x8A\x95\x86\x94\x7F\xC9\xC1f\x1B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R\x16`\x04\x85\x01R\x16`$\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15aB\xF3W_\x93_\x95aB\xBCW[PPaB\xB9aB\xB2\x85\x94a\x19\xD0V[\x94\x85a\x16\x91V[RV[\x80\x92\x95P\x81\x94P=\x83\x11aB\xECW[aB\xD5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW` \x82Q\x92\x01Q\x92_\x80aB\xA3V[P=aB\xCBV[\x83Q=_\x82>=\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x81\x11aC\x11W\x16\x90V[\x7Fm\xFC\xC6P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\xA0`\x04R`$R`D_\xFD[\x90_R` RaB\x1F`@_ \x91\x82\\a7\xB1V[`@Q\x92` \x84\x01\x90\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R`\x01`\x01`\xA0\x1B\x03\x80\x94\x16`$\x86\x01R`D\x85\x01R`D\x84R`\x80\x84\x01\x90\x84\x82\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x17a\x10\xBDWaC\xD5\x93_\x93\x84\x93`@R\x16\x94Q\x90\x82\x86Z\xF1aC\xCEa(wV[\x90\x83aA\\V[\x80Q\x90\x81\x15\x15\x91\x82aD\x16W[PPaC\xEBWPV[\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04R`$_\xFD[\x81\x92P\x90` \x91\x81\x01\x03\x12a\x02\xFCW` \x01Q\x80\x15\x90\x81\x15\x03a\x02\xFCW_\x80aC\xE2V[\\\x11\x15aDCWV[\x7F\x0FJ\xE0\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD\xFE\xA2dipfsX\"\x12 \"\x9A\\\xF8\x9A\xA7\xC2\xD0\xA4\xB4\xD5\xDB \xBB\xA6\xC2\xB3\xA7K\x08\x03\x03\xFCn\xC0\x0B\xA5\x82\xA5\xDC\xF7QdsolcC\0\x08\x1A\x003",
+    );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct PermitBatch { PermitDetails[] details; address spender; uint256 sigDeadline; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct PermitBatch {
-        #[allow(missing_docs)]
-        pub details:
-            alloy_sol_types::private::Vec<<PermitDetails as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sigDeadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Array<PermitDetails>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Vec<<PermitDetails as alloy_sol_types::SolType>::RustType>,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<PermitBatch> for UnderlyingRustTuple<'_> {
-            fn from(value: PermitBatch) -> Self {
-                (value.details, value.spender, value.sigDeadline)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitBatch {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    details: tuple.0,
-                    spender: tuple.1,
-                    sigDeadline: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for PermitBatch {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for PermitBatch {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        PermitDetails,
-                    > as alloy_sol_types::SolType>::tokenize(&self.details),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sigDeadline),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PermitBatch {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for PermitBatch {
-            const NAME: &'static str = "PermitBatch";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "PermitBatch(PermitDetails[] details,address spender,uint256 sigDeadline)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components.push(<PermitDetails as alloy_sol_types::SolStruct>::eip712_root_type());
-                components
-                    .extend(<PermitDetails as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Array<
-                        PermitDetails,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.details)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.spender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sigDeadline)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PermitBatch {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Array<
-                        PermitDetails,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.details,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.spender,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sigDeadline,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Array<
-                    PermitDetails,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.details,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.spender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sigDeadline,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct PermitDetails {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<160>,
-            alloy_sol_types::sol_data::Uint<48>,
-            alloy_sol_types::sol_data::Uint<48>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U160,
-            alloy_sol_types::private::primitives::aliases::U48,
-            alloy_sol_types::private::primitives::aliases::U48,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<PermitDetails> for UnderlyingRustTuple<'_> {
-            fn from(value: PermitDetails) -> Self {
-                (value.token, value.amount, value.expiration, value.nonce)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitDetails {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    token: tuple.0,
-                    amount: tuple.1,
-                    expiration: tuple.2,
-                    nonce: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for PermitDetails {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for PermitDetails {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.expiration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PermitDetails {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for PermitDetails {
-            const NAME: &'static str = "PermitDetails";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        160,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiration)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PermitDetails {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        160,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expiration,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    160,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    48,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expiration,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    48,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
-
-    See the [wrapper's documentation](`IAllowanceTransferInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IAllowanceTransferInstance<P, N> {
-        IAllowanceTransferInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IAllowanceTransfer`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IAllowanceTransfer`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IAllowanceTransferInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IAllowanceTransferInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IAllowanceTransferInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IAllowanceTransferInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
-
-        See the [wrapper's documentation](`IAllowanceTransferInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IAllowanceTransferInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IAllowanceTransferInstance<P, N> {
-            IAllowanceTransferInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IAllowanceTransferInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IAllowanceTransferInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library IBatchRouter {
-    struct SwapExactInHookParams { address sender; SwapPathExactAmountIn[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
-    struct SwapExactOutHookParams { address sender; SwapPathExactAmountOut[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
-    struct SwapPathExactAmountIn { address tokenIn; SwapPathStep[] steps; uint256 exactAmountIn; uint256 minAmountOut; }
-    struct SwapPathExactAmountOut { address tokenIn; SwapPathStep[] steps; uint256 maxAmountIn; uint256 exactAmountOut; }
-    struct SwapPathStep { address pool; address tokenOut; bool isBuffer; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IBatchRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapExactInHookParams { address sender; SwapPathExactAmountIn[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapExactInHookParams {
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub paths: alloy_sol_types::private::Vec<
-            <SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub wethIsEth: bool,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Array<SwapPathExactAmountIn>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bool,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Vec<
-                <SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-            >,
-            alloy_sol_types::private::primitives::aliases::U256,
-            bool,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapExactInHookParams> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapExactInHookParams) -> Self {
-                (
-                    value.sender,
-                    value.paths,
-                    value.deadline,
-                    value.wethIsEth,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapExactInHookParams {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    sender: tuple.0,
-                    paths: tuple.1,
-                    deadline: tuple.2,
-                    wethIsEth: tuple.3,
-                    userData: tuple.4,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapExactInHookParams {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapExactInHookParams {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathExactAmountIn,
-                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.wethIsEth,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapExactInHookParams {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapExactInHookParams {
-            const NAME: &'static str = "SwapExactInHookParams";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapExactInHookParams(address sender,SwapPathExactAmountIn[] paths,uint256 \
-                     deadline,bool wethIsEth,bytes userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components.push(
-                    <SwapPathExactAmountIn as alloy_sol_types::SolStruct>::eip712_root_type(),
-                );
-                components.extend(
-                    <SwapPathExactAmountIn as alloy_sol_types::SolStruct>::eip712_components(),
-                );
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathExactAmountIn,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.paths)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.wethIsEth,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapExactInHookParams {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        SwapPathExactAmountIn,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.paths)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deadline,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.wethIsEth,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    SwapPathExactAmountIn,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.paths,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deadline,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.wethIsEth,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapExactOutHookParams { address sender; SwapPathExactAmountOut[] paths; uint256 deadline; bool wethIsEth; bytes userData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapExactOutHookParams {
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub paths: alloy_sol_types::private::Vec<
-            <SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub wethIsEth: bool,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Array<SwapPathExactAmountOut>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bool,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Vec<
-                <SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-            >,
-            alloy_sol_types::private::primitives::aliases::U256,
-            bool,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapExactOutHookParams> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapExactOutHookParams) -> Self {
-                (
-                    value.sender,
-                    value.paths,
-                    value.deadline,
-                    value.wethIsEth,
-                    value.userData,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapExactOutHookParams {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    sender: tuple.0,
-                    paths: tuple.1,
-                    deadline: tuple.2,
-                    wethIsEth: tuple.3,
-                    userData: tuple.4,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapExactOutHookParams {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapExactOutHookParams {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathExactAmountOut,
-                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.wethIsEth,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapExactOutHookParams {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapExactOutHookParams {
-            const NAME: &'static str = "SwapExactOutHookParams";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapExactOutHookParams(address sender,SwapPathExactAmountOut[] paths,uint256 \
-                     deadline,bool wethIsEth,bytes userData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components.push(
-                    <SwapPathExactAmountOut as alloy_sol_types::SolStruct>::eip712_root_type(),
-                );
-                components.extend(
-                    <SwapPathExactAmountOut as alloy_sol_types::SolStruct>::eip712_components(),
-                );
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathExactAmountOut,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.paths)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.wethIsEth,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.userData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapExactOutHookParams {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        SwapPathExactAmountOut,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.paths)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deadline,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.wethIsEth,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.userData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    SwapPathExactAmountOut,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.paths,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deadline,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.wethIsEth,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.userData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapPathExactAmountIn { address tokenIn; SwapPathStep[] steps; uint256 exactAmountIn; uint256 minAmountOut; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapPathExactAmountIn {
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub steps:
-            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub exactAmountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minAmountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Array<SwapPathStep>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapPathExactAmountIn> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapPathExactAmountIn) -> Self {
-                (
-                    value.tokenIn,
-                    value.steps,
-                    value.exactAmountIn,
-                    value.minAmountOut,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapPathExactAmountIn {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    tokenIn: tuple.0,
-                    steps: tuple.1,
-                    exactAmountIn: tuple.2,
-                    minAmountOut: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapPathExactAmountIn {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapPathExactAmountIn {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathStep,
-                    > as alloy_sol_types::SolType>::tokenize(&self.steps),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.exactAmountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minAmountOut),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapPathExactAmountIn {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapPathExactAmountIn {
-            const NAME: &'static str = "SwapPathExactAmountIn";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapPathExactAmountIn(address tokenIn,SwapPathStep[] steps,uint256 \
-                     exactAmountIn,uint256 minAmountOut)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components.push(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_root_type());
-                components
-                    .extend(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathStep,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.steps)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.exactAmountIn)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minAmountOut)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapPathExactAmountIn {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenIn,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        SwapPathStep,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.steps)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.exactAmountIn,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.minAmountOut,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    SwapPathStep,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.steps,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.exactAmountIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.minAmountOut,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapPathExactAmountOut { address tokenIn; SwapPathStep[] steps; uint256 maxAmountIn; uint256 exactAmountOut; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapPathExactAmountOut {
-        #[allow(missing_docs)]
-        pub tokenIn: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub steps:
-            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub maxAmountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub exactAmountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Array<SwapPathStep>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Vec<<SwapPathStep as alloy_sol_types::SolType>::RustType>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapPathExactAmountOut> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapPathExactAmountOut) -> Self {
-                (
-                    value.tokenIn,
-                    value.steps,
-                    value.maxAmountIn,
-                    value.exactAmountOut,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapPathExactAmountOut {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    tokenIn: tuple.0,
-                    steps: tuple.1,
-                    maxAmountIn: tuple.2,
-                    exactAmountOut: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapPathExactAmountOut {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapPathExactAmountOut {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenIn,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathStep,
-                    > as alloy_sol_types::SolType>::tokenize(&self.steps),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.maxAmountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.exactAmountOut),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapPathExactAmountOut {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapPathExactAmountOut {
-            const NAME: &'static str = "SwapPathExactAmountOut";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapPathExactAmountOut(address tokenIn,SwapPathStep[] steps,uint256 \
-                     maxAmountIn,uint256 exactAmountOut)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components.push(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_root_type());
-                components
-                    .extend(<SwapPathStep as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenIn,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        SwapPathStep,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.steps)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxAmountIn)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.exactAmountOut,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapPathExactAmountOut {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenIn,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        SwapPathStep,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.steps)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maxAmountIn,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.exactAmountOut,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    SwapPathStep,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.steps,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maxAmountIn,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.exactAmountOut,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SwapPathStep { address pool; address tokenOut; bool isBuffer; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SwapPathStep {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenOut: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub isBuffer: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bool,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            bool,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SwapPathStep> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapPathStep) -> Self {
-                (value.pool, value.tokenOut, value.isBuffer)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapPathStep {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    pool: tuple.0,
-                    tokenOut: tuple.1,
-                    isBuffer: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SwapPathStep {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SwapPathStep {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.pool,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenOut,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.isBuffer,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SwapPathStep {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SwapPathStep {
-            const NAME: &'static str = "SwapPathStep";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SwapPathStep(address pool,address tokenOut,bool isBuffer)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.pool,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.tokenOut,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.isBuffer,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SwapPathStep {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.pool,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.tokenOut,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.isBuffer,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.pool,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.tokenOut,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.isBuffer,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IBatchRouter`](self) contract instance.
-
-    See the [wrapper's documentation](`IBatchRouterInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IBatchRouterInstance<P, N> {
-        IBatchRouterInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IBatchRouter`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IBatchRouter`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IBatchRouterInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IBatchRouterInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IBatchRouterInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IBatchRouterInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IBatchRouter`](self) contract instance.
-
-        See the [wrapper's documentation](`IBatchRouterInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IBatchRouterInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IBatchRouterInstance<P, N> {
-            IBatchRouterInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IBatchRouterInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IBatchRouterInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library IRouterCommon {
-    struct PermitApproval { address token; address owner; address spender; uint256 amount; uint256 nonce; uint256 deadline; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IRouterCommon {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct PermitApproval { address token; address owner; address spender; uint256 amount; uint256 nonce; uint256 deadline; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct PermitApproval {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<PermitApproval> for UnderlyingRustTuple<'_> {
-            fn from(value: PermitApproval) -> Self {
-                (
-                    value.token,
-                    value.owner,
-                    value.spender,
-                    value.amount,
-                    value.nonce,
-                    value.deadline,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitApproval {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    token: tuple.0,
-                    owner: tuple.1,
-                    spender: tuple.2,
-                    amount: tuple.3,
-                    nonce: tuple.4,
-                    deadline: tuple.5,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for PermitApproval {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for PermitApproval {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PermitApproval {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for PermitApproval {
-            const NAME: &'static str = "PermitApproval";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "PermitApproval(address token,address owner,address spender,uint256 \
-                     amount,uint256 nonce,uint256 deadline)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.owner,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.spender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PermitApproval {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.token,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.owner,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.spender,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deadline,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.owner,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.spender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deadline,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IRouterCommon`](self) contract instance.
-
-    See the [wrapper's documentation](`IRouterCommonInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IRouterCommonInstance<P, N> {
-        IRouterCommonInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IRouterCommon`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IRouterCommon`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IRouterCommonInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IRouterCommonInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IRouterCommonInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IRouterCommonInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IRouterCommon`](self) contract instance.
-
-        See the [wrapper's documentation](`IRouterCommonInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IRouterCommonInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IRouterCommonInstance<P, N> {
-            IRouterCommonInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IRouterCommonInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IRouterCommonInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IAllowanceTransfer {
-    struct PermitBatch {
-        PermitDetails[] details;
-        address spender;
-        uint256 sigDeadline;
-    }
-    struct PermitDetails {
-        address token;
-        uint160 amount;
-        uint48 expiration;
-        uint48 nonce;
-    }
-}
-
-library IBatchRouter {
-    struct SwapExactInHookParams {
-        address sender;
-        SwapPathExactAmountIn[] paths;
-        uint256 deadline;
-        bool wethIsEth;
-        bytes userData;
-    }
-    struct SwapExactOutHookParams {
-        address sender;
-        SwapPathExactAmountOut[] paths;
-        uint256 deadline;
-        bool wethIsEth;
-        bytes userData;
-    }
-    struct SwapPathExactAmountIn {
-        address tokenIn;
-        SwapPathStep[] steps;
-        uint256 exactAmountIn;
-        uint256 minAmountOut;
-    }
-    struct SwapPathExactAmountOut {
-        address tokenIn;
-        SwapPathStep[] steps;
-        uint256 maxAmountIn;
-        uint256 exactAmountOut;
-    }
-    struct SwapPathStep {
-        address pool;
-        address tokenOut;
-        bool isBuffer;
-    }
-}
-
-library IRouterCommon {
-    struct PermitApproval {
-        address token;
-        address owner;
-        address spender;
-        uint256 amount;
-        uint256 nonce;
-        uint256 deadline;
-    }
-}
-
-interface BalancerV3BatchRouter {
-    error AddressEmptyCode(address target);
-    error AddressInsufficientBalance(address account);
-    error ErrorSelectorNotFound();
-    error EthTransfer();
-    error FailedInnerCall();
-    error InputLengthMismatch();
-    error InsufficientEth();
-    error ReentrancyGuardReentrantCall();
-    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
-    error SafeERC20FailedOperation(address token);
-    error SenderIsNotVault(address sender);
-    error SwapDeadline();
-    error TransientIndexOutOfBounds();
-
-    constructor(address vault, address weth, address permit2, string routerVersion);
-
-    receive() external payable;
-
-    function getSender() external view returns (address);
-    function multicall(bytes[] memory data) external payable returns (bytes[] memory results);
-    function permitBatchAndCall(IRouterCommon.PermitApproval[] memory permitBatch, bytes[] memory permitSignatures, IAllowanceTransfer.PermitBatch memory permit2Batch, bytes memory permit2Signature, bytes[] memory multicallData) external payable returns (bytes[] memory results);
-    function querySwapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
-    function querySwapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
-    function querySwapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
-    function querySwapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
-    function swapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
-    function swapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
-    function swapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
-    function swapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
-    function version() external view returns (string memory);
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "constructor",
-    "inputs": [
-      {
-        "name": "vault",
-        "type": "address",
-        "internalType": "contract IVault"
-      },
-      {
-        "name": "weth",
-        "type": "address",
-        "internalType": "contract IWETH"
-      },
-      {
-        "name": "permit2",
-        "type": "address",
-        "internalType": "contract IPermit2"
-      },
-      {
-        "name": "routerVersion",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "receive",
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "getSender",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "multicall",
-    "inputs": [
-      {
-        "name": "data",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "results",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "permitBatchAndCall",
-    "inputs": [
-      {
-        "name": "permitBatch",
-        "type": "tuple[]",
-        "internalType": "struct IRouterCommon.PermitApproval[]",
-        "components": [
-          {
-            "name": "token",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "owner",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "spender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "permitSignatures",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      },
-      {
-        "name": "permit2Batch",
-        "type": "tuple",
-        "internalType": "struct IAllowanceTransfer.PermitBatch",
-        "components": [
-          {
-            "name": "details",
-            "type": "tuple[]",
-            "internalType": "struct IAllowanceTransfer.PermitDetails[]",
-            "components": [
-              {
-                "name": "token",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint160",
-                "internalType": "uint160"
-              },
-              {
-                "name": "expiration",
-                "type": "uint48",
-                "internalType": "uint48"
-              },
-              {
-                "name": "nonce",
-                "type": "uint48",
-                "internalType": "uint48"
-              }
-            ]
-          },
-          {
-            "name": "spender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sigDeadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "permit2Signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "multicallData",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "results",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "querySwapExactIn",
-    "inputs": [
-      {
-        "name": "paths",
-        "type": "tuple[]",
-        "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
-        "components": [
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "steps",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathStep[]",
-            "components": [
-              {
-                "name": "pool",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "tokenOut",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "isBuffer",
-                "type": "bool",
-                "internalType": "bool"
-              }
-            ]
-          },
-          {
-            "name": "exactAmountIn",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "minAmountOut",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensOut",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "querySwapExactInHook",
-    "inputs": [
-      {
-        "name": "params",
-        "type": "tuple",
-        "internalType": "struct IBatchRouter.SwapExactInHookParams",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "paths",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
-            "components": [
-              {
-                "name": "tokenIn",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "steps",
-                "type": "tuple[]",
-                "internalType": "struct IBatchRouter.SwapPathStep[]",
-                "components": [
-                  {
-                    "name": "pool",
-                    "type": "address",
-                    "internalType": "address"
-                  },
-                  {
-                    "name": "tokenOut",
-                    "type": "address",
-                    "internalType": "contract IERC20"
-                  },
-                  {
-                    "name": "isBuffer",
-                    "type": "bool",
-                    "internalType": "bool"
-                  }
-                ]
-              },
-              {
-                "name": "exactAmountIn",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "minAmountOut",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "wethIsEth",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensOut",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "querySwapExactOut",
-    "inputs": [
-      {
-        "name": "paths",
-        "type": "tuple[]",
-        "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
-        "components": [
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "steps",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathStep[]",
-            "components": [
-              {
-                "name": "pool",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "tokenOut",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "isBuffer",
-                "type": "bool",
-                "internalType": "bool"
-              }
-            ]
-          },
-          {
-            "name": "maxAmountIn",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "exactAmountOut",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensIn",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "querySwapExactOutHook",
-    "inputs": [
-      {
-        "name": "params",
-        "type": "tuple",
-        "internalType": "struct IBatchRouter.SwapExactOutHookParams",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "paths",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
-            "components": [
-              {
-                "name": "tokenIn",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "steps",
-                "type": "tuple[]",
-                "internalType": "struct IBatchRouter.SwapPathStep[]",
-                "components": [
-                  {
-                    "name": "pool",
-                    "type": "address",
-                    "internalType": "address"
-                  },
-                  {
-                    "name": "tokenOut",
-                    "type": "address",
-                    "internalType": "contract IERC20"
-                  },
-                  {
-                    "name": "isBuffer",
-                    "type": "bool",
-                    "internalType": "bool"
-                  }
-                ]
-              },
-              {
-                "name": "maxAmountIn",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "exactAmountOut",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "wethIsEth",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensIn",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactIn",
-    "inputs": [
-      {
-        "name": "paths",
-        "type": "tuple[]",
-        "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
-        "components": [
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "steps",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathStep[]",
-            "components": [
-              {
-                "name": "pool",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "tokenOut",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "isBuffer",
-                "type": "bool",
-                "internalType": "bool"
-              }
-            ]
-          },
-          {
-            "name": "exactAmountIn",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "minAmountOut",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "wethIsEth",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensOut",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactInHook",
-    "inputs": [
-      {
-        "name": "params",
-        "type": "tuple",
-        "internalType": "struct IBatchRouter.SwapExactInHookParams",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "paths",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathExactAmountIn[]",
-            "components": [
-              {
-                "name": "tokenIn",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "steps",
-                "type": "tuple[]",
-                "internalType": "struct IBatchRouter.SwapPathStep[]",
-                "components": [
-                  {
-                    "name": "pool",
-                    "type": "address",
-                    "internalType": "address"
-                  },
-                  {
-                    "name": "tokenOut",
-                    "type": "address",
-                    "internalType": "contract IERC20"
-                  },
-                  {
-                    "name": "isBuffer",
-                    "type": "bool",
-                    "internalType": "bool"
-                  }
-                ]
-              },
-              {
-                "name": "exactAmountIn",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "minAmountOut",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "wethIsEth",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensOut",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsOut",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactOut",
-    "inputs": [
-      {
-        "name": "paths",
-        "type": "tuple[]",
-        "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
-        "components": [
-          {
-            "name": "tokenIn",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "steps",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathStep[]",
-            "components": [
-              {
-                "name": "pool",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "tokenOut",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "isBuffer",
-                "type": "bool",
-                "internalType": "bool"
-              }
-            ]
-          },
-          {
-            "name": "maxAmountIn",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "exactAmountOut",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "wethIsEth",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "userData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensIn",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactOutHook",
-    "inputs": [
-      {
-        "name": "params",
-        "type": "tuple",
-        "internalType": "struct IBatchRouter.SwapExactOutHookParams",
-        "components": [
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "paths",
-            "type": "tuple[]",
-            "internalType": "struct IBatchRouter.SwapPathExactAmountOut[]",
-            "components": [
-              {
-                "name": "tokenIn",
-                "type": "address",
-                "internalType": "contract IERC20"
-              },
-              {
-                "name": "steps",
-                "type": "tuple[]",
-                "internalType": "struct IBatchRouter.SwapPathStep[]",
-                "components": [
-                  {
-                    "name": "pool",
-                    "type": "address",
-                    "internalType": "address"
-                  },
-                  {
-                    "name": "tokenOut",
-                    "type": "address",
-                    "internalType": "contract IERC20"
-                  },
-                  {
-                    "name": "isBuffer",
-                    "type": "bool",
-                    "internalType": "bool"
-                  }
-                ]
-              },
-              {
-                "name": "maxAmountIn",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "exactAmountOut",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "wethIsEth",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "userData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pathAmountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "tokensIn",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "amountsIn",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "version",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "error",
-    "name": "AddressEmptyCode",
-    "inputs": [
-      {
-        "name": "target",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "AddressInsufficientBalance",
-    "inputs": [
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "ErrorSelectorNotFound",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "EthTransfer",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "FailedInnerCall",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InputLengthMismatch",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InsufficientEth",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "ReentrancyGuardReentrantCall",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "SafeCastOverflowedUintDowncast",
-    "inputs": [
-      {
-        "name": "bits",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "SafeERC20FailedOperation",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "SenderIsNotVault",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "SwapDeadline",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "TransientIndexOutOfBounds",
-    "inputs": []
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BalancerV3BatchRouter {
-    use {super::*, alloy_sol_types};
-    /// The creation / init bytecode of the contract.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"a\x01\xC0`@\x90\x80\x82R4a\x05\xC9WaK\xBD\x808\x03\x80\x91a\0\x1F\x82\x85a\x05\xE8V[\x839\x81\x01\x91`\x80\x82\x84\x03\x12a\x05\xC9W\x81Q`\x01`\x01`\xA0\x1B\x03\x93\x90\x84\x81\x16\x81\x03a\x05\xC9W` \x93\x84\x81\x01Q\x92\x86\x84\x16\x84\x03a\x05\xC9W\x84\x82\x01Q\x96\x87\x16\x87\x03a\x05\xC9W``\x82\x01Q`\x01`\x01`@\x1B\x03\x92\x83\x82\x11a\x05\xC9W\x01\x92`\x1F\x90\x82\x82\x86\x01\x12\x15a\x05\xC9W\x84Q\x84\x81\x11a\x05\xB5W`\x1F\x19\x95\x88Q\x94a\0\xA5\x8B\x89\x87\x86\x01\x16\x01\x87a\x05\xE8V[\x82\x86R\x8A\x83\x83\x01\x01\x11a\x05\xC9W\x81_\x92\x8B\x80\x93\x01\x83\x88\x01^\x85\x01\x01R`\x80R\x81Q\x92\x83\x11a\x05\xB5W_T\x91`\x01\x92\x83\x81\x81\x1C\x91\x16\x80\x15a\x05\xABW[\x89\x82\x10\x14a\x05\x97W\x82\x81\x11a\x05TW[P\x87\x91\x84\x11`\x01\x14a\x04\xF7W\x83\x94P\x90\x83\x92\x91_\x94a\x04\xECW[PP\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17_U[a\x01Ia\x01&a\x06\x0BV[\x83Q\x90a\x012\x82a\x05\xCDV[`\x06\x82Re9\xB2\xB722\xB9`\xD1\x1B\x86\x83\x01Ra\x06iV[`\xA0Ra\x01\x85a\x01Wa\x06\x0BV[\x83Q\x90a\x01c\x82a\x05\xCDV[`\x11\x82Rp\x1A\\\xD4\x99]\x1D\\\x9B\x91]\x1A\x13\x1B\xD8\xDA\xD9Y`z\x1B\x86\x83\x01Ra\x06iV[`\xC0R`\xE0Ra\x01\0\x92\x83Ra\x01\xCD\x81Qa\x01\x9F\x81a\x05\xCDV[`\x13\x81R\x7FcurrentSwapTokensIn\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x82\x01Ra\x063V[\x91a\x01 \x92\x83Ra\x02\x10\x82Qa\x01\xE2\x81a\x05\xCDV[`\x14\x81R\x7FcurrentSwapTokensOut\0\0\0\0\0\0\0\0\0\0\0\0\x83\x82\x01Ra\x063V[a\x01@\x90\x81Ra\x02R\x83Qa\x02$\x81a\x05\xCDV[`\x19\x81R\x7FcurrentSwapTokenInAmounts\0\0\0\0\0\0\0\x84\x82\x01Ra\x063V[\x90a\x01`\x91\x82Ra\x02\xD8a\x02\x98\x85Qa\x02j\x81a\x05\xCDV[`\x1A\x81R\x7FcurrentSwapTokenOutAmounts\0\0\0\0\0\0\x86\x82\x01Ra\x063V[\x93a\x01\x80\x94\x85R\x7FsettledTokenAmounts\0\0\0\0\0\0\0\0\0\0\0\0\0\x86Q\x91a\x02\xCC\x83a\x05\xCDV[`\x13\x83R\x82\x01Ra\x063V[\x93a\x01\xA0\x94\x85RQ\x94aD\xA1\x96\x87a\x07\x1C\x889`\x80Q\x87\x81\x81a\x02F\x01R\x81\x81a\x19|\x01R\x81\x81a\x1B\xE0\x01R\x81\x81a\x1E\"\x01R\x81\x81a y\x01R\x81\x81a\"\x12\x01R\x81\x81a##\x01R\x81\x81a#\xB1\x01R\x81\x81a$s\x01R\x81\x81a*\xAD\x01R\x81\x81a,\x8C\x01R\x81\x81a,\xD4\x01R\x81\x81a-R\x01R\x81\x81a-\xF9\x01R\x81\x81a/\x07\x01R\x81\x81a/\x84\x01R\x81\x81a2\x19\x01R\x81\x81a3H\x01R\x81\x81a3\xE5\x01R\x81\x81a4\xAB\x01R\x81\x81a;l\x01R\x81\x81a<\x91\x01R\x81\x81a>\xD0\x01R\x81\x81a@\x15\x01RaBq\x01R`\xA0Q\x87\x81\x81a\x02\xAA\x01R\x81\x81a\x055\x01R\x81\x81a\x18\x1F\x01Ra(\xBE\x01R`\xC0Q\x87\x81\x81a\x17\xA9\x01Ra6\xBA\x01R`\xE0Q\x87\x81\x81`\"\x01R\x81\x81a:\xFE\x01R\x81\x81a=\xE4\x01R\x81\x81a?X\x01Ra@\xAF\x01RQ\x86\x81\x81a\t\xF0\x01R\x81\x81a\x0B\x04\x01R\x81\x81a\x1Fn\x01R\x81\x81a\x1F\xF4\x01R\x81\x81a0y\x01Ra<m\x01RQ\x85\x81\x81a%i\x01R\x81\x81a'P\x01R\x81\x81a)Z\x01Ra5\xD8\x01RQ\x84\x81\x81a\x1CC\x01R\x81\x81a\x1E\x8F\x01R\x81\x81a\"u\x01R\x81\x81a$\xD7\x01R\x81\x81a%\xCE\x01R\x81\x81a',\x01R\x81\x81a+\x12\x01Ra5\xA8\x01RQ\x83\x81\x81a\x1DC\x01R\x81\x81a%\x95\x01R\x81\x81a'|\x01R\x81\x81a2\x8E\x01R\x81\x81a5\t\x01Ra6+\x01RQ\x82\x81\x81a\x1Cl\x01R\x81\x81a\x1E\xC0\x01R\x81\x81a%\x01\x01R\x81\x81a&!\x01R\x81\x81a'\xB4\x01R\x81\x81a+Q\x01Ra2\xD0\x01RQ\x81\x81\x81a\"\x9F\x01R\x81\x81a%\xFF\x01R\x81\x81a+\x82\x01R\x81\x81a.V\x01Ra6\t\x01R\xF3[\x01Q\x92P_\x80a\x01\nV[\x91\x93\x83\x16\x91_\x80R\x83\x88_ \x93_[\x8A\x88\x83\x83\x10a\x05=WPPP\x10a\x05%W[PPP\x81\x1B\x01_Ua\x01\x1BV[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x05\x18V[\x86\x86\x01Q\x88U\x90\x96\x01\x95\x94\x85\x01\x94\x87\x93P\x01a\x05\x06V[_\x80R\x88_ \x83\x80\x87\x01`\x05\x1C\x82\x01\x92\x8B\x88\x10a\x05\x8EW[\x01`\x05\x1C\x01\x90\x84\x90[\x82\x81\x10a\x05\x83WPPa\0\xF0V[_\x81U\x01\x84\x90a\x05uV[\x92P\x81\x92a\x05lV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x90`\x7F\x16\x90a\0\xE0V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80\xFD[`@\x81\x01\x90\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17a\x05\xB5W`@RV[`\x1F\x90\x91\x01`\x1F\x19\x16\x81\x01\x90`\x01`\x01`@\x1B\x03\x82\x11\x90\x82\x10\x17a\x05\xB5W`@RV[`@Q\x90a\x06\x18\x82a\x05\xCDV[`\x0C\x82Rk)7\xBA\xBA2\xB9!\xB7\xB6\xB6\xB7\xB7`\xA1\x1B` \x83\x01RV[a\x06f\x90`@Qa\x06C\x81a\x05\xCDV[`\x11\x81Rp!0\xBA1\xB4)7\xBA\xBA2\xB9!\xB7\xB6\xB6\xB7\xB7`y\x1B` \x82\x01Ra\x06iV[\x90V[\x90a\x06\xD6`:` \x92`@Q\x93\x84\x91\x81\x80\x84\x01\x97\x7Fbalancer-labs.v3.storage.\0\0\0\0\0\0\0\x89R\x80Q\x91\x82\x91\x01`9\x86\x01^\x83\x01\x90`\x17`\xF9\x1B`9\x83\x01R\x80Q\x92\x83\x91\x01\x85\x83\x01^\x01_\x83\x82\x01R\x03`\x1A\x81\x01\x84R\x01\x82a\x05\xE8V[Q\x90 _\x19\x81\x01\x90\x81\x11a\x07\x07W`@Q\x90` \x82\x01\x90\x81R` \x82Ra\x06\xFC\x82a\x05\xCDV[\x90Q\x90 `\xFF\x19\x16\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD\xFE`\x80`@R`\x046\x10\x15a\0rW[6\x15a\0\x18W_\x80\xFD[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\0JW\0[\x7F\x05@\xDD\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[_5`\xE0\x1C\x80c\x08\xA4e\xF6\x14a\x0E\x9DW\x80c\x19\xC6\x98\x9F\x14a\x08NW\x80c(oX\r\x14a\x07\xB7W\x80c)P(n\x14a\x06\xCCW\x80cT\xFDMP\x14a\x05\x8FW\x80cZ<9\x87\x14a\x05fW\x80c^\x01\xEBZ\x14a\x05!W\x80c\x8A\x12\xA0\x8C\x14a\x04\xC6W\x80c\x8E\xB1\xB6^\x14a\x03\xBFW\x80c\x94^\xD3?\x14a\x03DW\x80c\xAC\x96P\xD8\x14a\x03\0Wc\xE3\xB5\xDF\xF4\x03a\0\x0EW4a\x02\xFCW``\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x01-\x906\x90`\x04\x01a\x12\xC4V[a\x015a\x11\xA1V[`D5\x92\x83\x11a\x02\xFCWa\x01Pa\x01X\x936\x90`\x04\x01a\x0F\xCDV[\x93\x90\x91a(\xB9V[\x90_[\x83Q\x81\x10\x15a\x01|W\x80_\x87a\x01s`\x01\x94\x88a\x16\x91V[Q\x01R\x01a\x01[V[Pa\x01\xF0a\x01\xFEa\x029\x94a\x01\xB6_\x94\x88`@Q\x93a\x01\x9A\x85a\x11\x1AV[0\x85R` \x85\x01R_\x19`@\x85\x01R\x86``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x8A\x12\xA0\x8C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[\x03`\x1F\x19\x81\x01\x83R\x82a\x11RV[`@Q\x80\x94\x81\x92\x7F\xED\xFA5h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x92a\x02\x8E\x91_\x91a\x02\xCFW[P` \x80\x82Q\x83\x01\x01\x91\x01a\x15\xD4V[\x90\x93\x91\x92a\x02\xA7W[`@Q\x93\x84\x93\x84a\x0F/V[\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]a\x02\x97V[a\x02\xEB\x91P=\x80_\x83>a\x02\xE3\x81\x83a\x11RV[\x81\x01\x90a\x15MV[\x84a\x02~V[`@Q=_\x82>=\x90\xFD[_\x80\xFD[` `\x03\x196\x01\x12a\x02\xFCW`\x045g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x038a\x032a\x02\xA3\x926\x90`\x04\x01a\x0F\x9CV[\x90a\x17\x9BV[`@Q\x91\x82\x91\x82a\x10 V[4a\x02\xFCWa\x03R6a\x0E\xCAV[a\x03Za\x19EV[a\x03ba\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a(\xFBV[\x91\x93\x90\x94a\x03\x8A``a\x03\x83\x83a\x13DV[\x92\x01a\x13XV[\x90a')V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]`@Q\x93\x84\x93\x84a\x0F/V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x03\xEC\x906\x90`\x04\x01a\x12\xC4V[\x90a\x03\xF5a\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x04Qa\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[a\x04%3a(\xB9V[\x97`@Q\x94a\x043\x86a\x11\x1AV[3\x86R` \x86\x01R`$5`@\x86\x01R\x15\x15``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x94^\xD3?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`@Q\x80\x94\x81\x92\x7FH\xC8\x94\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x04\xDA6a\x0E\xCAV[a\x04\xE2a\x19EV[a\x04\xEAa\x19rV[a\x1A;V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x94\x92\x94]`@Q\x93\x84\x93\x84a\x0F/V[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW` \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\`\x01`\x01`\xA0\x1B\x03`@Q\x91\x16\x81R\xF3[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x05z6a\x0E\xCAV[a\x05\x82a\x19EV[a\x05\x8Aa\x19rV[a(\xFBV[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW`@Q_\x80T\x90`\x01\x82`\x01\x1C\x91`\x01\x84\x16\x91\x82\x15a\x06\xC2W[` \x94\x85\x85\x10\x84\x14a\x06\x95W\x85\x87\x94\x86\x86R\x91\x82_\x14a\x06WWPP`\x01\x14a\x05\xFEW[Pa\x05\xEA\x92P\x03\x83a\x11RV[a\x02\xA3`@Q\x92\x82\x84\x93\x84R\x83\x01\x90a\x0F\xFBV[_\x80\x80R\x85\x92P\x90\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c[\x85\x83\x10a\x06?WPPa\x05\xEA\x93P\x82\x01\x01\x85a\x05\xDDV[\x80T\x83\x89\x01\x85\x01R\x87\x94P\x86\x93\x90\x92\x01\x91\x81\x01a\x06(V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x85\x82\x01Ra\x05\xEA\x95\x15\x15`\x05\x1B\x85\x01\x01\x92P\x87\x91Pa\x05\xDD\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\"`\x04R`$_\xFD[\x92`\x7F\x16\x92a\x05\xB9V[4a\x02\xFCW```\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x06\xFE\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\x07a\x11\xA1V[`D5\x91\x82\x11a\x02\xFCWa\x07\"a\x07*\x926\x90`\x04\x01a\x0F\xCDV[\x92\x90\x91a(\xB9V[\x90_[\x84Q\x81\x10\x15a\x07_W\x80o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@a\x07V`\x01\x94\x89a\x16\x91V[Q\x01R\x01a\x07-V[Pa\x01\xF0a\x01\xFE\x85a\x07}_\x94a\x029\x97`@Q\x93a\x01\x9A\x85a\x11\x1AV[`\x80\x82\x01R`@Q\x92\x83\x91\x7FZ<9\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x07\xE4\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\xEDa\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x08\x14a\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x08\xA4e\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[`\xA0`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x11a\x02\xFCW6`#`\x045\x01\x12\x15a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045`\x04\x015\x11a\x02\xFCW6`$`\xC0`\x045`\x04\x015\x02`\x045\x01\x01\x11a\x02\xFCW`$5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x08\xC4\x906\x90`\x04\x01a\x0F\x9CV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D5\x11a\x02\xFCW```\x03\x19`D56\x03\x01\x12a\x02\xFCW`d5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t\x05\x906\x90`\x04\x01a\x0F\xCDV[`\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t%\x906\x90`\x04\x01a\x0F\x9CV[\x94\x90\x93a\t0a\x19EV[\x80`\x045`\x04\x015\x03a\x0EuW_[`\x045`\x04\x015\x81\x10a\x0B\xD2WPPP`D5`\x04\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDD`D56\x03\x01\x82\x12\x15a\x02\xFCW\x81`D5\x01`\x04\x81\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW`$\x82`\x07\x1B6\x03\x91\x01\x13a\x02\xFCWa\t\xE3W[a\x02\xA3a\x038\x86\x86_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]a\x17\x9BV[`\x01`\x01`\xA0\x1B\x03\x94\x92\x94\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x94\x7F*-\x80\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R3`\x04\x87\x01R```$\x87\x01R`\xC4\x86\x01\x92`D5\x01`$\x81\x01\x93g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04\x83\x015\x11a\x02\xFCW`\x04\x82\x015`\x07\x1B6\x03\x85\x13a\x02\xFCW```d\x89\x01R`\x04\x82\x015\x90R\x91\x92\x86\x92`\xE4\x84\x01\x92\x91\x90_\x90[`\x04\x81\x015\x82\x10a\x0BTWPPP` \x91`\x1F\x19`\x1F\x86_\x97\x87\x95`\x01`\x01`\xA0\x1B\x03a\n\xC8`$`D5\x01a\x11\x8DV[\x16`\x84\x88\x01R`D\x805\x015`\xA4\x88\x01R`\x03\x19\x87\x87\x03\x01`D\x88\x01R\x81\x86R\x87\x86\x017\x87\x86\x82\x86\x01\x01R\x01\x16\x01\x03\x01\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x93a\x038\x93a\x0BEW[\x82\x94P\x81\x93Pa\t\xB3V[a\x0BN\x90a\x11\x06V[\x84a\x0B:V[\x91\x95\x94P\x91\x92`\x01`\x01`\xA0\x1B\x03a\x0Bk\x87a\x11\x8DV[\x16\x81R` \x80\x87\x015\x91`\x01`\x01`\xA0\x1B\x03\x83\x16\x80\x93\x03a\x02\xFCW`\x04\x92`\x01\x92\x82\x01Ra\x0B\x9B`@\x89\x01a(\xA6V[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x91\x16`@\x83\x01Ra\x0B\xB6``\x8A\x01a(\xA6V[\x16``\x82\x01R`\x80\x80\x91\x01\x97\x01\x93\x01\x90P\x88\x94\x95\x93\x92\x91a\n\x97V[a\x0B\xE7a\x0B\xE0\x82\x84\x86a\x19*V[6\x91a\x13\x81V[`@Qa\x0B\xF3\x81a\x10\xA1V[_\x81R` \x91_\x83\x83\x01R_`@\x83\x01R\x82\x81\x01Q\x90```@\x82\x01Q\x91\x01Q_\x1A\x91\x83R\x83\x83\x01R`@\x82\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDC\x81\x85\x02`\x045\x016\x03\x01\x12a\x02\xFCW`@Q\x90a\x0C`\x82a\x10\xEAV[a\x0Cs`$`\xC0\x86\x02`\x045\x01\x01a\x11\x8DV[\x80\x83Ra\x0C\x89`D`\xC0\x87\x02`\x045\x01\x01a\x11\x8DV[\x90\x81\x85\x85\x01Ra\x0C\xA2`d`\xC0\x88\x02`\x045\x01\x01a\x11\x8DV[`@\x85\x81\x01\x91\x90\x91R`\x045`\xC0\x88\x02\x01`\x84\x81\x015``\x87\x01R`\xA4\x81\x015`\x80\x87\x01R`\xC4\x015`\xA0\x86\x01R\x83\x01Q\x83Q\x93\x86\x01Q`\xFF\x91\x90\x91\x16\x92`\x01`\x01`\xA0\x1B\x03\x83\x16;\x15a\x02\xFCW_`\x01`\x01`\xA0\x1B\x03\x80\x94`\xE4\x94\x8B\x98\x84\x98`\xC4`\xC0`@Q\x9C\x8D\x9B\x8C\x9A\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8CR\x16`\x04\x8B\x01R0`$\x8B\x01R`\x84\x82\x82\x02`\x045\x01\x015`D\x8B\x01R\x02`\x045\x01\x015`d\x88\x01R`\x84\x87\x01R`\xA4\x86\x01R`\xC4\x85\x01R\x16Z\xF1\x90\x81a\x0EfW[Pa\x0E\\Wa\r\x7Fa(wV[\x90`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x81\x83\x01Q\x16`D`@Q\x80\x95\x81\x93\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01R0`$\x83\x01RZ\xFA\x91\x82\x15a\x02\xF1W_\x92a\x0E,W[P``\x01Q\x03a\r\xF7WPP`\x01\x90[\x01a\t?V[\x80Q\x15a\x0E\x04W\x80Q\x91\x01\xFD[\x7F\xA7(V\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x0EUW[a\x0ED\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x90``a\r\xE1V[P=a\x0E:V[PP`\x01\x90a\r\xF1V[a\x0Eo\x90a\x11\x06V[\x8Aa\rrV[\x7F\xAA\xAD\x13\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[4a\x02\xFCWa\x0E\xAB6a\x0E\xCAV[a\x0E\xB3a\x19EV[a\x0E\xBBa\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a\x1A;V[`\x03\x19\x90` \x82\x82\x01\x12a\x02\xFCW`\x045\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW\x82`\xA0\x92\x03\x01\x12a\x02\xFCW`\x04\x01\x90V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a\x0F\x1BWPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a\x0F\rV[\x93\x92\x90a\x0FD\x90``\x86R``\x86\x01\x90a\x0E\xFCV[\x93` \x94\x81\x81\x03` \x83\x01R` \x80\x85Q\x92\x83\x81R\x01\x94\x01\x90_[\x81\x81\x10a\x0F\x7FWPPPa\x0F|\x93\x94P`@\x81\x84\x03\x91\x01Ra\x0E\xFCV[\x90V[\x82Q`\x01`\x01`\xA0\x1B\x03\x16\x86R\x94\x87\x01\x94\x91\x87\x01\x91`\x01\x01a\x0F_V[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x80\x85\x01\x94\x84`\x05\x1B\x01\x01\x11a\x02\xFCWV[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x83\x81\x86\x01\x95\x01\x01\x11a\x02\xFCWV[\x90`\x1F\x19`\x1F` \x80\x94\x80Q\x91\x82\x91\x82\x87R\x01\x86\x86\x01^_\x85\x82\x86\x01\x01R\x01\x16\x01\x01\x90V[` \x80\x82\x01\x90` \x83R\x83Q\x80\x92R`@\x83\x01\x92` `@\x84`\x05\x1B\x83\x01\x01\x95\x01\x93_\x91[\x84\x83\x10a\x10UWPPPPPP\x90V[\x90\x91\x92\x93\x94\x95\x84\x80a\x10\x91\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC0\x86`\x01\x96\x03\x01\x87R\x8AQa\x0F\xFBV[\x98\x01\x93\x01\x93\x01\x91\x94\x93\x92\x90a\x10EV[``\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`\xC0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`@RV[`\xA0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[`\xE0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x90`\x1F`\x1F\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x05\x1B` \x01\x90V[5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`D5\x90\x81\x15\x15\x82\x03a\x02\xFCWV[\x91\x90\x91`\x80\x81\x84\x03\x12a\x02\xFCW`@\x90\x81Q\x91`\x80\x83\x01\x94g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x84\x81\x10\x87\x82\x11\x17a\x10\xBDW\x82R\x83\x95a\x12\0\x84a\x11\x8DV[\x85R` \x90\x81\x85\x015\x90\x81\x11a\x02\xFCW\x84\x01\x82`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x90a\x12)\x82a\x11uV[\x93a\x126\x86Q\x95\x86a\x11RV[\x82\x85R\x83\x85\x01\x90\x84``\x80\x95\x02\x84\x01\x01\x92\x81\x84\x11a\x02\xFCW\x85\x01\x91[\x83\x83\x10a\x12tWPPPPP\x84\x01R\x81\x81\x015\x90\x83\x01R``\x90\x81\x015\x91\x01RV[\x84\x83\x83\x03\x12a\x02\xFCW\x87Q\x90a\x12\x89\x82a\x10\xA1V[a\x12\x92\x84a\x11\x8DV[\x82Ra\x12\x9F\x87\x85\x01a\x11\x8DV[\x87\x83\x01R\x88\x84\x015\x90\x81\x15\x15\x82\x03a\x02\xFCW\x82\x88\x92\x8B\x89\x95\x01R\x81R\x01\x92\x01\x91a\x12RV[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x91` \x91a\x12\xDE\x84a\x11uV[\x93a\x12\xEC`@Q\x95\x86a\x11RV[\x80\x85R\x83\x80\x86\x01\x91`\x05\x1B\x83\x01\x01\x92\x80\x84\x11a\x02\xFCW\x84\x83\x01\x91[\x84\x83\x10a\x13\x17WPPPPPP\x90V[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCW\x86\x91a\x139\x84\x84\x80\x94\x89\x01\x01a\x11\xC6V[\x81R\x01\x92\x01\x91a\x13\x07V[5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x90V[5\x80\x15\x15\x81\x03a\x02\xFCW\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x13\x8D\x82a\x13eV[\x91a\x13\x9B`@Q\x93\x84a\x11RV[\x82\x94\x81\x84R\x81\x83\x01\x11a\x02\xFCW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90`\x80\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x80\x82Q\x16\x83R` \x93\x84\x83\x01Q\x94`\x80\x81\x86\x01R\x85Q\x80\x92R\x80`\xA0\x86\x01\x96\x01\x92_\x90[\x83\x82\x10a\x14\x0BWPPPPP``\x81`@\x82\x93\x01Q`@\x85\x01R\x01Q\x91\x01R\x90V[\x84Q\x80Q\x82\x16\x89R\x80\x84\x01Q\x82\x16\x89\x85\x01R`@\x90\x81\x01Q\x15\x15\x90\x89\x01R``\x90\x97\x01\x96\x93\x82\x01\x93`\x01\x90\x91\x01\x90a\x13\xE9V[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x14\xBDWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x14\xF8\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x14\x81V[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x80Q\x90a\x15\x1E\x82a\x13eV[\x92a\x15,`@Q\x94\x85a\x11RV[\x82\x84R` \x83\x83\x01\x01\x11a\x02\xFCW\x81_\x92` \x80\x93\x01\x83\x86\x01^\x83\x01\x01R\x90V[\x90` \x82\x82\x03\x12a\x02\xFCW\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x80`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x90` \x91a\x15\x8E\x81a\x11uV[\x93a\x15\x9C`@Q\x95\x86a\x11RV[\x81\x85R` \x80\x86\x01\x92`\x05\x1B\x82\x01\x01\x92\x83\x11a\x02\xFCW` \x01\x90[\x82\x82\x10a\x15\xC5WPPPP\x90V[\x81Q\x81R\x90\x83\x01\x90\x83\x01a\x15\xB7V[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a\x16\0\x91\x83\x01a\x15sV[\x93` \x80\x83\x01Q\x85\x81\x11a\x02\xFCW\x83\x01\x90\x82`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x91a\x16(\x83a\x11uV[\x92a\x166`@Q\x94\x85a\x11RV[\x80\x84R\x82\x80\x85\x01\x91`\x05\x1B\x83\x01\x01\x91\x85\x83\x11a\x02\xFCW\x83\x01\x90[\x82\x82\x10a\x16rWPPPP\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15sV[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x81R\x90\x83\x01\x90\x83\x01a\x16PV[\x80Q\x82\x10\x15a\x16\xA5W` \x91`\x05\x1B\x01\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x17QWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x17\x8C\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x17\x15V[\x91\x90a\x17\xA63a(\xB9V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x84\\a\x18\xB1W`\x01\x90`\x01\x86]a\x17\xDF\x83a\x11uV[\x92a\x17\xED`@Q\x94\x85a\x11RV[\x80\x84R`\x1F\x19a\x17\xFC\x82a\x11uV[\x01_[\x81\x81\x10a\x18\xA0WPP_[\x81\x81\x10a\x18WWPPPP\x90_a\x18L\x92\x94]\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\\\x91a\x18NW[Pa6\xB1V[V[_\x90]_a\x18FV[\x80a\x18\x84_\x80a\x18la\x0B\xE0\x89\x96\x88\x8Aa\x19*V[` \x81Q\x91\x010Z\xF4a\x18}a(wV[\x900aA\\V[a\x18\x8E\x82\x88a\x16\x91V[Ra\x18\x99\x81\x87a\x16\x91V[P\x01a\x18\nV[\x80``` \x80\x93\x89\x01\x01R\x01a\x17\xFFV[\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x816\x03\x83\x13a\x02\xFCWV[\x90\x82\x10\x15a\x16\xA5Wa\x19A\x91`\x05\x1B\x81\x01\x90a\x18\xD9V[\x90\x91V[\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x80\\a\x18\xB1W`\x01\x90]V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\x19\xA4WV[\x7F\x08\x96v\xD5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R3`\x04R`$_\xFD[\x90a\x19\xDA\x82a\x11uV[a\x19\xE7`@Q\x91\x82a\x11RV[\x82\x81R`\x1F\x19a\x19\xF7\x82\x94a\x11uV[\x01\x90` 6\x91\x017V[\x91\x90\x82\x01\x80\x92\x11a\x1A\x0EWV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[`@\x81\x015B\x11a&\xC3W\x90a\x1A^a\x1AW` \x84\x01\x84a6\xF4V[\x90Pa\x19\xD0V[\x91_[a\x1An` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a%\xC7Wa\x1A\x98\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[6\x93\x91a7HV[a\x11\xC6V[\x93`@\x85\x01Q\x93`\x01`\x01`\xA0\x1B\x03\x86Q\x16\x90` \x87\x01Q\x80Q\x15a\x16\xA5W` \x01Q`@\x01Q\x15\x15\x80a%\xBEW[\x15a%cWa\x1A\xECa\x1A\xD8\x86a\x13DV[\x87\x84a\x1A\xE6``\x8A\x01a\x13XV[\x92a:\xDDV[_[` \x88\x01QQ\x81\x10\x15a%SWa\x1B\x03a7\x88V[` \x89\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW\x82\x14\x80` \x83\x01R\x82\x15\x82R_\x14a%LW``\x89\x01Q\x90[a\x1B;\x83` \x8C\x01Qa\x16\x91V[Q`@\x81\x01Q\x90\x91\x90\x15a\x1C\xEEWa\x1B\xD3`\x01`\x01`\xA0\x1B\x03\x83Q\x16\x93`\x01`\x01`\xA0\x1B\x03\x88\x16\x85\x14_\x14a\x1C\xE7W`\x01\x94[`@Q\x95a\x1B{\x87a\x11\x1AV[_\x87Ra\x1B\x87\x81a7\xBEV[` \x87\x01R`@\x86\x01R``\x94\x85\x91\x8D\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x93\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1C\xB0W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1C\x90\x93`\x01\x96\x95a\x1C8\x8C\x8Ca\x16\x91V[R\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x01a\x1A\xEEV[` \x01Q\x90\x97P`\x01`\x01`\xA0\x1B\x03\x16\x92P`\x01\x90a\x1C\x90V[` \x92\x94P\x90\x81a\x1C\xD5\x92\x90=\x10a\x1C\xE0W[a\x1C\xCD\x81\x83a\x11RV[\x81\x01\x90a7\xF5V[\x91PP\x92\x90_a\x1C\x10V[P=a\x1C\xC3V[_\x94a\x1BnV[\x88\x8A`\x01`\x01`\xA0\x1B\x03\x84\x95\x94Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x8A\x16\x14_\x14a!2WPP\x81Q\x15\x90Pa nW\x88\x8A\x80\x15\x15\x80a SW[a\x1FMW[`\x01`\x01`\xA0\x1B\x03\x93\x92\x91a\x1D\xDD\x82a\x1E\x15\x97\x8B_\x95\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\x16\x80\x88R\x82` R`@\x88 \\a\x1F<W[PPP[`\x01a\x1D\x9C\x89\x83Q\x16` \x84\x01\x99\x8B\x8BQ\x16\x90\x80\x15\x8A\x14a\x1F6WP\x83\x91aB#V[\x99\x90\x92Q\x16\x94a\x1D\xB1`\x80\x91\x82\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a\x1D\xC1\x89a\x10\xEAV[\x88R0` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x96\x81\x92\x7F!Ex\x97\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a9\xB1V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1F\x0CW[P` \x01Q\x15a\x1E\xE9W\x91a\x1E\xBC\x82`\x01`\x01`\xA0\x1B\x03`\x01\x96\x95a\x1Eza\x1E\xE4\x96\x86a\x16\x91V[Qa\x1E\x85\x8D\x8Da\x16\x91V[Ra\x1E\xB3\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x92a\x16\x91V[Q\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1C\x90V[\x98P`\x01\x92\x94Pa\x1F\x02\x90`\x01`\x01`\xA0\x1B\x03\x92a\x16\x91V[Q\x97Q\x16\x92a\x1C\x90V[` \x91\x94Pa\x1F,\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[\x81\x01\x90a9iV[P\x94\x91\x90Pa\x1ERV[\x91aB#V[a\x1FE\x92aCAV[_\x82\x81a\x1DuV[Pa\x1FZ\x90\x92\x91\x92a\x13DV[\x91a\x1Fd\x8BaB\xFDV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x04\x82\x01R0`$\x82\x01R\x90\x84\x16`D\x82\x01R\x92\x87\x16`d\x84\x01R_\x83\x80`\x84\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a DW[P\x97P\x92PP\x91\x92\x93Pa\x1D*V[a M\x90a\x11\x06V[_a 5V[Pa ]\x82a\x13DV[`\x01`\x01`\xA0\x1B\x03\x160\x14\x15a\x1D%V[\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91`\x01`\x01`\xA0\x1B\x03\x84Q\x16\x92\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`\x04\x85\x01R0`$\x85\x01R`D\x84\x01\x8C\x90R_\x90\x84\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a!#W[Pa\x1DyV[a!,\x90a\x11\x06V[_a!\x1DV[`\x01`\x01`\xA0\x1B\x03` \x87\x96\x94\x97\x01Q\x16\x90\x89\x81\x83\x14_\x14a#\xD7Wa!\xCD\x92Pa\"\x05\x97\x91P`\x01a!s_\x96\x95`\x01`\x01`\xA0\x1B\x03\x93\x84\x8BQ\x16aB#V[P\x92\x82\x89Q\x16\x95` \x89\x01Q\x15\x15\x88\x14a#\xAEWa!\x90\x82a\x13DV[\x94[a!\xA1`\x80\x93\x84\x81\x01\x90a\x18\xD9V[\x95\x90\x96`@Q\x99a!\xB1\x8Ba\x10\xEAV[\x8AR\x16` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x95\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W_\x93a#\x84W[P` \x01Q\x15a\"\xC3W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a\"i\x8C\x8Ca\x16\x91V[Ra\"\x99\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x81\x81\x01Q\x91Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R`$\x81\x01\x85\x90R\x93\x9AP\x90\x91\x16\x94P\x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa#YW[P`\x01\x90a\x1C\x90V[` \x90\x81=\x83\x11a#}W[a#o\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a#PV[P=a#eV[` \x91\x93Pa#\xA4\x90=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x81\x01\x90a8|V[P\x93\x91\x90Pa\"BV[\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a!\x92V[`\x01`\x01`\xA0\x1B\x03a$f\x95a$.\x93\x94\x95a#\xF8`\x80\x9B\x8C\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a$\x08\x89a\x116V[_\x89R` \x89\x01R\x16`@\x87\x01R``\x9A\x8B\x97\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x93\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a%%W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a$\xCB\x8C\x8Ca\x16\x91V[Ra$\xFB\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x92\x94P\x90\x81a%A\x92\x90=\x10a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[\x91PP\x92\x90_a$\xA3V[_\x90a\x1B-V[P\x91\x95P\x90\x93PP`\x01\x01a\x1AaV[a%\x8D\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[Pa%\xB9\x86\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1A\xECV[P2\x15\x15a\x1A\xC7V[PPa%\xF2\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a%\xFD\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a&c\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra&\x91`@_ \\\x82a&~\x85\x8Da\x16\x91V[Q\x16_R\x88` R`@_ \\\x90a\x1A\x01V[a&\x9B\x83\x87a\x16\x91V[Ra&\xA6\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a&DV[P\x94\x93\x91P\x91PV[\x7F\xE0\x8B\x8A\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90_\x19\x82\x01\x91\x82\x13`\x01\x16a\x1A\x0EWV[\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x1A\x0EW_\x19\x01\x90V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x81\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a'y\x81\\a&\xEBV[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91[_\x81\x12\x15a(:WPPPa'\xB1\x90a&\xEBV[\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92[_\x81\x12\x15a'\xEAWPPPPa\x18L\x90a6\xB1V[a(5\x90\x82_Ra(/` _\x83\x82\x82 \x01\\\x91\x82\x82R\x88\x81R\x88`@\x91a(\"\x8A\x8D\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a>\xB0V[\x84\x84RR\x81 ]\x84a>\rV[Pa&\xFCV[a'\xD5V[a(r\x90\x82_Ra(/` _\x8A\x87\x85\x84\x84 \x01\\\x93\x84\x84R\x81\x81Ra(\"\x8C`@\x94\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a:\xDDV[a'\x9DV[=\x15a(\xA1W=\x90a(\x88\x82a\x13eV[\x91a(\x96`@Q\x93\x84a\x11RV[\x82R=_` \x84\x01>V[``\x90V[5\x90e\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x82\x03a\x02\xFCWV[\x90_\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x81\\\x16\x15a(\xF1WPPV[\x90\x91\x92P]`\x01\x90V[\x90`@\x82\x015B\x11a&\xC3Wa)\x17a\x1AW` \x84\x01\x84a6\xF4V[\x91_[a)'` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a5\xD1Wa)D\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[``\x81\x01Q\x90a)~`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P` \x81\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW[_\x81\x12\x15a)\xA4WPPP`\x01\x01a)\x1AV[a)\xB2\x81` \x84\x01Qa\x16\x91V[Qa)\xBBa7\x88V[\x90\x82\x15` \x83\x01R` \x84\x01QQ\x80_\x19\x81\x01\x11a\x1A\x0EW_\x19\x01\x83\x14\x80\x83Ra5\x8FW[` \x82\x01Q\x15a5TW`@\x84\x01Q`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x91[`@\x81\x01Q\x15a,\x1DW\x83\x91`\x01`\x01`\xA0\x1B\x03``\x92` a*\xA0\x97\x01Q\x15\x15\x80a,\x14W[a+\xEDW[Q\x16\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x82\x03a+\xE6W`\x01\x91[`@Q\x92a*L\x84a\x11\x1AV[`\x01\x84Ra*Y\x81a7\xBEV[` \x84\x01R`@\x83\x01R\x88\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x95\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a+\xBFW[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a+\x02a+\xAB\x97\x96\x94a+u\x94a\x16\x91V[Ra+6`\x01`\x01`\xA0\x1B\x03\x82\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P`\x01`\x01`\xA0\x1B\x03a+M\x84`@\x8A\x01Qa7\xB1V[\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a&\xFCV[a)\x91V[PPPa+\xAB\x91\x93P\x92a&\xFCV[` \x91\x95Pa+\xDC\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa*\xE1V[_\x91a*?V[a,\x0Fa+\xF9\x8Da\x13DV[\x8D\x8Ba\x1A\xE6\x88`@\x88\x84Q\x16\x93\x01Q\x93\x01a\x13XV[a*(V[P2\x15\x15a*#V[\x90`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x85\x16\x14_\x14a17WP` \x84\x01Qa0IWP`@Q\x92\x7F\x96xp\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x85\x01R` \x84`$\x81`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15a\x02\xF1W_\x94a0\x15W[P\x83\x91`\x01`\x01`\xA0\x1B\x03\x81Q\x16`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x95\x90\x95R_\x85\x80`d\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a0\x06W[P[a\x1D\xDD`\x01`\x01`\xA0\x1B\x03a-\xA8\x8B\x82\x85Q\x16\x83` \x87\x01Q\x16\x90aB#V[P\x92Q\x16\x91\x8C`\x02a-\xBF`\x80\x92\x83\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a-\xCF\x88a\x10\xEAV[\x87R0` \x88\x01R\x89`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a/\xE3W[P` \x01Q\x15a.\xCFW\x90\x82\x91a+\xAB\x94\x93a.E\x89\x8Da\x16\x91V[Ra.z\x83`\x01`\x01`\xA0\x1B\x03\x84\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x80\x83\x10\x80a.\xB4W[a.\x90W[PPPa&\xFCV[a.\xA6a.\xAC\x93a.\xA0\x8Ba\x13DV[\x92a7\xB1V[\x91aCVV[_\x80\x80a.\x88V[P0`\x01`\x01`\xA0\x1B\x03a.\xC7\x8Ba\x13DV[\x16\x14\x15a.\x83V[\x94P\x90\x80\x94\x80\x82\x10a.\xE8W[PPPa+\xAB\x90a&\xFCV[\x91a.\xF8` \x92a/w\x94a7\xB1V[\x90a/-\x82`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83aCVV[`@Q\x93\x84\x92\x83\x92\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa/\xB8W[\x80\x80a.\xDCV[` \x90\x81=\x83\x11a/\xDCW[a/\xCE\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a/\xB1V[P=a/\xC4V[` \x91\x94Pa/\xFB\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[P\x90\x94\x91\x90Pa.)V[a0\x0F\x90a\x11\x06V[_a-\x86V[\x90\x93P` \x81=` \x11a0AW[\x81a01` \x93\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x92_a,\xBCV[=\x91Pa0$V[\x90\x92a0T\x89a\x13DV[`\x01`\x01`\xA0\x1B\x030\x91\x16\x03a0oW[_a-\xEC\x94a-\x88V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a0\xA3\x8Aa\x13DV[a0\xAC\x84aB\xFDV[\x90\x86;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R0`$\x82\x01R\x91\x81\x16`D\x83\x01R\x85\x16`d\x82\x01R\x94_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a1(W[P\x94PPa0eV[a11\x90a\x11\x06V[_a1\x1FV[`\x01`\x01`\xA0\x1B\x03` \x84\x96\x95\x94\x01Q\x16\x8A\x82\x82\x14_\x14a4\x0BWPPPa2\x0Ca1n_\x92\x84`\x01`\x01`\xA0\x1B\x03\x88Q\x16aB#V[\x92\x90a1\xD4\x8C`\x01`\x01`\xA0\x1B\x03\x80\x8AQ\x16\x93\x89Q\x15\x15\x86\x14a3\xDFWa1\xA3a1\x97\x84a\x13DV[\x93[`\x80\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a1\xB3\x88a\x10\xEAV[\x87R\x16` \x86\x01R`@\x85\x01R\x8C``\x85\x01R`\x02`\x80\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x93\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1W_\x91a3\xC4W[P` \x84\x01Q\x8C\x90\x8A\x90\x15a3\xAAW\x83\x83`\x01`\x01`\xA0\x1B\x03\x93a2\x83a2\x89\x94a2|\x8F\x9C\x9B\x9A\x98\x99a2\xB2\x9Aa\x16\x91V[Q\x92a\x16\x91V[Ra\x16\x91V[Q\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[Q\x15a2\xF4Wa+\xAB\x92\x91`\x01`\x01`\xA0\x1B\x03` a+\xA6\x93\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aCAV[Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R` \x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa3\x7FW[Pa+\xAB\x90a&\xFCV[` \x90\x81=\x83\x11a3\xA3W[a3\x95\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a3uV[P=a3\x8BV[PP\x90\x91Pa3\xBB\x92\x93\x96Pa\x16\x91V[Q\x93\x84\x91a2\xB2V[a3\xD8\x91P=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x90Pa2IV[a1\xA3\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a1\x99V[a4\x9E\x96P\x90a4f\x91``\x94\x8Ba4+`\x80\x99\x98\x99\x93\x84\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a4;\x89a\x116V[`\x01\x89R` \x89\x01R`\x01`\x01`\xA0\x1B\x03\x8B\x16`@\x89\x01R\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x95\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a5-W[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a5\x05a+\xAB\x97\x96\x94`\x01`\x01`\xA0\x1B\x03\x94a\x16\x91V[R\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x91\x95Pa5J\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa4\xDFV[o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x01`\x01`\xA0\x1B\x03` a5\x85\x81\x88\x01Qa5\x7F\x88a&\xEBV[\x90a\x16\x91V[Q\x01Q\x16\x91a)\xFCV[a5\xCC\x85`\x01`\x01`\xA0\x1B\x03` \x84\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[a)\xE0V[PPa5\xFC\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a6\x07\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a6m\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra6\x88`@_ \\\x82a&~\x85\x8Da\x16\x91V[a6\x92\x83\x87a\x16\x91V[Ra6\x9D\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a6NV[G\x80\x15a6\xF0W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\a6\xF0W`\x01`\x01`\xA0\x1B\x03a\x18L\x92\x16a@\xE0V[PPV[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x02\xFCWV[\x91\x90\x81\x10\x15a\x16\xA5W`\x05\x1B\x81\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x90V[`@Q\x90`@\x82\x01\x82\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@R_` \x83\x82\x81R\x01RV[\x91\x90\x82\x03\x91\x82\x11a\x1A\x0EWV[`\x02\x11\x15a7\xC8WV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x90\x81``\x91\x03\x12a\x02\xFCW\x80Q\x91`@` \x83\x01Q\x92\x01Q\x90V[a\x01\0`\xC0a\x0F|\x93` \x84R\x80Qa8(\x81a7\xBEV[` \x85\x01R` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x91\x16`@\x86\x01R\x80`@\x83\x01Q\x16``\x86\x01R``\x82\x01Q\x16`\x80\x85\x01R`\x80\x81\x01Q`\xA0\x85\x01R`\xA0\x81\x01Q\x82\x85\x01R\x01Q\x91`\xE0\x80\x82\x01R\x01\x90a\x0F\xFBV[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a8\xA8\x91\x83\x01a\x15sV[\x93` \x82\x01Q\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a8\xE4WPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a8\xD6V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01Ra91`@\x83\x01Q`\xC0``\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90``\x83\x01Q`\x80\x82\x01R`\x80\x83\x01Q`\x05\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91``\x83\x83\x03\x12a\x02\xFCW\x82Q\x92` \x81\x01Q\x92g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x81\x11a\x02\xFCW\x81a9\x9A\x91\x84\x01a\x15sV[\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01R`@\x82\x01Q``\x82\x01Ra9\xF4``\x83\x01Q`\xC0`\x80\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90`\x80\x83\x01Q`\x04\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91\x90\x91`\x80\x80`\xA0\x83\x01\x94\x80Qa:8\x81a7\xBEV[\x84R` \x81\x01Qa:H\x81a7\xBEV[` \x85\x01R`\x01`\x01`\xA0\x1B\x03`@\x82\x01Q\x16`@\x85\x01R``\x81\x01Q``\x85\x01R\x01Q\x91\x01RV[\x90\x81\\a:}\x81a\x11uV[a:\x8A`@Q\x91\x82a\x11RV[\x81\x81Ra:\x96\x82a\x11uV[`\x1F\x19` \x91\x016` \x84\x017\x81\x94_[\x84\x81\x10a:\xB5WPPPPPV[`\x01\x90\x82_R\x80\x84_ \x01\\`\x01`\x01`\xA0\x1B\x03a:\xD3\x83\x88a\x16\x91V[\x91\x16\x90R\x01a:\xA7V[\x91\x92\x80a=\xD8W[\x15a<QWPP\x80G\x10a<)W`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x82;\x15a\x02\xFCW`@Q\x90\x7F\xD0\xE3\r\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R_\x91_\x81`\x04\x81\x85\x89Z\xF1\x80\x15a\x02\xF1Wa<\x12W[P`D` \x92\x93\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a;\x98\x83\x87\x83aCVV[\x84`@Q\x96\x87\x94\x85\x93\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85R`\x04\x85\x01R`$\x84\x01RZ\xF1\x90\x81\x15a<\x06WPa;\xDFWPV[` \x90\x81=\x83\x11a;\xFFW[a;\xF5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWV[P=a;\xEBV[`@Q\x90=\x90\x82>=\x90\xFD[` \x92Pa<\x1F\x90a\x11\x06V[`D_\x92Pa;cV[\x7F\xA0\x1A\x9D\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91_\x90\x80a<aW[PPPPV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91a<\xBB\x84aB\xFDV[\x96\x80;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R\x84\x83\x16`$\x82\x01R\x97\x82\x16`D\x89\x01R\x91\x86\x16\x16`d\x87\x01R_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x94\x85\x15a\x02\xF1Wa=\x80\x95a=\xC4W[P\x82\x93` \x93`@Q\x80\x97\x81\x95\x82\x94\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x92Z\xF1\x90\x81\x15a<\x06WPa=\x99W[\x80\x80\x80a<[V[` \x90\x81=\x83\x11a=\xBDW[a=\xAF\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a=\x91V[P=a=\xA5V[` \x93Pa=\xD1\x90a\x11\x06V[_\x92a=/V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x82\x16\x14a:\xE5V[`\x01\x81\x01\x91\x80_R` \x91\x83\x83R`@_ \\\x80\x15\x15_\x14a>\xA7W_\x19\x90\x81\x81\x01\x83\\\x83\x80\x82\x01\x91\x82\x84\x03a>jW[PPPPP\x81\\\x81\x81\x01\x92\x81\x84\x11a\x1A\x0EW_\x93\x81]\x83R\x84\x83 \x01\x01]_RR_`@\x81 ]`\x01\x90V[a>wa>\x87\x93\x88aD:V[\x86_R\x88_ \x01\x01\\\x91\x85aD:V[\x83_R\x80\x83\x83\x88_ \x01\x01]_R\x85\x85R`@_ ]_\x80\x80\x83\x81a>>V[PPPPP_\x90V[_\x94\x93\x83\x15a@\xD8W\x80a@\xA3W[\x15a@\x07W`\x01`\x01`\xA0\x1B\x03\x91\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`\x04\x83\x01R0`$\x83\x01R`D\x82\x01\x85\x90R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa?\xF4W[P\x84\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a?\xF0W\x81\x90`$`@Q\x80\x94\x81\x93\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R\x89`\x04\x84\x01RZ\xF1\x80\x15a?\xE5Wa?\xCDW[Pa\x18L\x93\x94P\x16a@\xE0V[a?\xD7\x86\x91a\x11\x06V[a?\xE1W\x84a?\xC0V[\x84\x80\xFD[`@Q=\x88\x82>=\x90\xFD[P\x80\xFD[a?\xFF\x91\x95Pa\x11\x06V[_\x93_a?SV[\x92\x93P\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x93\x90\x92\x16`$\x84\x01R`D\x83\x01R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa@\x9AWPV[a\x18L\x90a\x11\x06V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x83\x16\x14a>\xBFV[PPPP\x90PV[\x81G\x10aA0W_\x80\x80\x93`\x01`\x01`\xA0\x1B\x03\x82\x94\x16Z\xF1aA\0a(wV[P\x15aA\x08WV[\x7F\x14%\xEAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x7F\xCDx`Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R0`\x04R`$_\xFD[\x90aAqWP\x80Q\x15aA\x08W\x80Q\x90` \x01\xFD[\x81Q\x15\x80aA\xB7W[aA\x82WP\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x7F\x99\x96\xB3\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R\x16`\x04R`$_\xFD[P\x80;\x15aAzV[`\x01\x81\x01\x90\x82_R\x81` R`@_ \\\x15_\x14aB\x03W\x80\\\x81_R\x83\x81` _ \x01]`\x01\x81\x01\x80\x91\x11a\x1A\x0EW\x81]\\\x91_R` R`@_ ]`\x01\x90V[PPP_\x90V[\x90_R` RaB\x1F`@_ \x91\x82\\a\x1A\x01V[\x90]V[\x91`D\x92\x93\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x94\x85\x92\x82\x80\x85Q\x99\x8A\x95\x86\x94\x7F\xC9\xC1f\x1B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R\x16`\x04\x85\x01R\x16`$\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15aB\xF3W_\x93_\x95aB\xBCW[PPaB\xB9aB\xB2\x85\x94a\x19\xD0V[\x94\x85a\x16\x91V[RV[\x80\x92\x95P\x81\x94P=\x83\x11aB\xECW[aB\xD5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW` \x82Q\x92\x01Q\x92_\x80aB\xA3V[P=aB\xCBV[\x83Q=_\x82>=\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x81\x11aC\x11W\x16\x90V[\x7Fm\xFC\xC6P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\xA0`\x04R`$R`D_\xFD[\x90_R` RaB\x1F`@_ \x91\x82\\a7\xB1V[`@Q\x92` \x84\x01\x90\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R`\x01`\x01`\xA0\x1B\x03\x80\x94\x16`$\x86\x01R`D\x85\x01R`D\x84R`\x80\x84\x01\x90\x84\x82\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x17a\x10\xBDWaC\xD5\x93_\x93\x84\x93`@R\x16\x94Q\x90\x82\x86Z\xF1aC\xCEa(wV[\x90\x83aA\\V[\x80Q\x90\x81\x15\x15\x91\x82aD\x16W[PPaC\xEBWPV[\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04R`$_\xFD[\x81\x92P\x90` \x91\x81\x01\x03\x12a\x02\xFCW` \x01Q\x80\x15\x90\x81\x15\x03a\x02\xFCW_\x80aC\xE2V[\\\x11\x15aDCWV[\x7F\x0FJ\xE0\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD\xFE\xA2dipfsX\"\x12 \"\x9A\\\xF8\x9A\xA7\xC2\xD0\xA4\xB4\xD5\xDB \xBB\xA6\xC2\xB3\xA7K\x08\x03\x03\xFCn\xC0\x0B\xA5\x82\xA5\xDC\xF7QdsolcC\0\x08\x1A\x003",
-    );
-    /// The runtime bytecode of the contract, as deployed on the network.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\x80`@R`\x046\x10\x15a\0rW[6\x15a\0\x18W_\x80\xFD[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\0JW\0[\x7F\x05@\xDD\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[_5`\xE0\x1C\x80c\x08\xA4e\xF6\x14a\x0E\x9DW\x80c\x19\xC6\x98\x9F\x14a\x08NW\x80c(oX\r\x14a\x07\xB7W\x80c)P(n\x14a\x06\xCCW\x80cT\xFDMP\x14a\x05\x8FW\x80cZ<9\x87\x14a\x05fW\x80c^\x01\xEBZ\x14a\x05!W\x80c\x8A\x12\xA0\x8C\x14a\x04\xC6W\x80c\x8E\xB1\xB6^\x14a\x03\xBFW\x80c\x94^\xD3?\x14a\x03DW\x80c\xAC\x96P\xD8\x14a\x03\0Wc\xE3\xB5\xDF\xF4\x03a\0\x0EW4a\x02\xFCW``\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x01-\x906\x90`\x04\x01a\x12\xC4V[a\x015a\x11\xA1V[`D5\x92\x83\x11a\x02\xFCWa\x01Pa\x01X\x936\x90`\x04\x01a\x0F\xCDV[\x93\x90\x91a(\xB9V[\x90_[\x83Q\x81\x10\x15a\x01|W\x80_\x87a\x01s`\x01\x94\x88a\x16\x91V[Q\x01R\x01a\x01[V[Pa\x01\xF0a\x01\xFEa\x029\x94a\x01\xB6_\x94\x88`@Q\x93a\x01\x9A\x85a\x11\x1AV[0\x85R` \x85\x01R_\x19`@\x85\x01R\x86``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x8A\x12\xA0\x8C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[\x03`\x1F\x19\x81\x01\x83R\x82a\x11RV[`@Q\x80\x94\x81\x92\x7F\xED\xFA5h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x92a\x02\x8E\x91_\x91a\x02\xCFW[P` \x80\x82Q\x83\x01\x01\x91\x01a\x15\xD4V[\x90\x93\x91\x92a\x02\xA7W[`@Q\x93\x84\x93\x84a\x0F/V[\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]a\x02\x97V[a\x02\xEB\x91P=\x80_\x83>a\x02\xE3\x81\x83a\x11RV[\x81\x01\x90a\x15MV[\x84a\x02~V[`@Q=_\x82>=\x90\xFD[_\x80\xFD[` `\x03\x196\x01\x12a\x02\xFCW`\x045g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x038a\x032a\x02\xA3\x926\x90`\x04\x01a\x0F\x9CV[\x90a\x17\x9BV[`@Q\x91\x82\x91\x82a\x10 V[4a\x02\xFCWa\x03R6a\x0E\xCAV[a\x03Za\x19EV[a\x03ba\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a(\xFBV[\x91\x93\x90\x94a\x03\x8A``a\x03\x83\x83a\x13DV[\x92\x01a\x13XV[\x90a')V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]`@Q\x93\x84\x93\x84a\x0F/V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x03\xEC\x906\x90`\x04\x01a\x12\xC4V[\x90a\x03\xF5a\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x04Qa\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[a\x04%3a(\xB9V[\x97`@Q\x94a\x043\x86a\x11\x1AV[3\x86R` \x86\x01R`$5`@\x86\x01R\x15\x15``\x85\x01R6\x91a\x13\x81V[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x94^\xD3?\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`@Q\x80\x94\x81\x92\x7FH\xC8\x94\x91\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R` `\x04\x84\x01R`$\x83\x01\x90a\x0F\xFBV[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x04\xDA6a\x0E\xCAV[a\x04\xE2a\x19EV[a\x04\xEAa\x19rV[a\x1A;V[_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x94\x92\x94]`@Q\x93\x84\x93\x84a\x0F/V[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW` \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\`\x01`\x01`\xA0\x1B\x03`@Q\x91\x16\x81R\xF3[4a\x02\xFCWa\x02\xA3a\x04\xEFa\x05z6a\x0E\xCAV[a\x05\x82a\x19EV[a\x05\x8Aa\x19rV[a(\xFBV[4a\x02\xFCW_`\x03\x196\x01\x12a\x02\xFCW`@Q_\x80T\x90`\x01\x82`\x01\x1C\x91`\x01\x84\x16\x91\x82\x15a\x06\xC2W[` \x94\x85\x85\x10\x84\x14a\x06\x95W\x85\x87\x94\x86\x86R\x91\x82_\x14a\x06WWPP`\x01\x14a\x05\xFEW[Pa\x05\xEA\x92P\x03\x83a\x11RV[a\x02\xA3`@Q\x92\x82\x84\x93\x84R\x83\x01\x90a\x0F\xFBV[_\x80\x80R\x85\x92P\x90\x7F)\r\xEC\xD9T\x8Bb\xA8\xD6\x03E\xA9\x888o\xC8K\xA6\xBC\x95H@\x08\xF66/\x93\x16\x0E\xF3\xE5c[\x85\x83\x10a\x06?WPPa\x05\xEA\x93P\x82\x01\x01\x85a\x05\xDDV[\x80T\x83\x89\x01\x85\x01R\x87\x94P\x86\x93\x90\x92\x01\x91\x81\x01a\x06(V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16\x85\x82\x01Ra\x05\xEA\x95\x15\x15`\x05\x1B\x85\x01\x01\x92P\x87\x91Pa\x05\xDD\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\"`\x04R`$_\xFD[\x92`\x7F\x16\x92a\x05\xB9V[4a\x02\xFCW```\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x06\xFE\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\x07a\x11\xA1V[`D5\x91\x82\x11a\x02\xFCWa\x07\"a\x07*\x926\x90`\x04\x01a\x0F\xCDV[\x92\x90\x91a(\xB9V[\x90_[\x84Q\x81\x10\x15a\x07_W\x80o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`@a\x07V`\x01\x94\x89a\x16\x91V[Q\x01R\x01a\x07-V[Pa\x01\xF0a\x01\xFE\x85a\x07}_\x94a\x029\x97`@Q\x93a\x01\x9A\x85a\x11\x1AV[`\x80\x82\x01R`@Q\x92\x83\x91\x7FZ<9\x87\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x16\xD2V[`\x80`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x81\x81\x11a\x02\xFCWa\x07\xE4\x906\x90`\x04\x01a\x12\xC4V[\x90a\x07\xEDa\x11\xB7V[\x90`d5\x90\x81\x11a\x02\xFCWa\x01\xF0a\x04\x8Ba\x029\x94a\x08\x14a\x04\x1C_\x956\x90`\x04\x01a\x0F\xCDV[`\x80\x82\x01R`@Q\x92\x83\x91\x7F\x08\xA4e\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x84\x01R`$\x83\x01a\x14>V[`\xA0`\x03\x196\x01\x12a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045\x11a\x02\xFCW6`#`\x045\x01\x12\x15a\x02\xFCWg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x045`\x04\x015\x11a\x02\xFCW6`$`\xC0`\x045`\x04\x015\x02`\x045\x01\x01\x11a\x02\xFCW`$5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x08\xC4\x906\x90`\x04\x01a\x0F\x9CV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`D5\x11a\x02\xFCW```\x03\x19`D56\x03\x01\x12a\x02\xFCW`d5g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t\x05\x906\x90`\x04\x01a\x0F\xCDV[`\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\t%\x906\x90`\x04\x01a\x0F\x9CV[\x94\x90\x93a\t0a\x19EV[\x80`\x045`\x04\x015\x03a\x0EuW_[`\x045`\x04\x015\x81\x10a\x0B\xD2WPPP`D5`\x04\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDD`D56\x03\x01\x82\x12\x15a\x02\xFCW\x81`D5\x01`\x04\x81\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW`$\x82`\x07\x1B6\x03\x91\x01\x13a\x02\xFCWa\t\xE3W[a\x02\xA3a\x038\x86\x86_\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0]a\x17\x9BV[`\x01`\x01`\xA0\x1B\x03\x94\x92\x94\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x94\x7F*-\x80\xD1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R3`\x04\x87\x01R```$\x87\x01R`\xC4\x86\x01\x92`D5\x01`$\x81\x01\x93g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x04\x83\x015\x11a\x02\xFCW`\x04\x82\x015`\x07\x1B6\x03\x85\x13a\x02\xFCW```d\x89\x01R`\x04\x82\x015\x90R\x91\x92\x86\x92`\xE4\x84\x01\x92\x91\x90_\x90[`\x04\x81\x015\x82\x10a\x0BTWPPP` \x91`\x1F\x19`\x1F\x86_\x97\x87\x95`\x01`\x01`\xA0\x1B\x03a\n\xC8`$`D5\x01a\x11\x8DV[\x16`\x84\x88\x01R`D\x805\x015`\xA4\x88\x01R`\x03\x19\x87\x87\x03\x01`D\x88\x01R\x81\x86R\x87\x86\x017\x87\x86\x82\x86\x01\x01R\x01\x16\x01\x03\x01\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x91\x82\x15a\x02\xF1Wa\x02\xA3\x93a\x038\x93a\x0BEW[\x82\x94P\x81\x93Pa\t\xB3V[a\x0BN\x90a\x11\x06V[\x84a\x0B:V[\x91\x95\x94P\x91\x92`\x01`\x01`\xA0\x1B\x03a\x0Bk\x87a\x11\x8DV[\x16\x81R` \x80\x87\x015\x91`\x01`\x01`\xA0\x1B\x03\x83\x16\x80\x93\x03a\x02\xFCW`\x04\x92`\x01\x92\x82\x01Ra\x0B\x9B`@\x89\x01a(\xA6V[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x91\x16`@\x83\x01Ra\x0B\xB6``\x8A\x01a(\xA6V[\x16``\x82\x01R`\x80\x80\x91\x01\x97\x01\x93\x01\x90P\x88\x94\x95\x93\x92\x91a\n\x97V[a\x0B\xE7a\x0B\xE0\x82\x84\x86a\x19*V[6\x91a\x13\x81V[`@Qa\x0B\xF3\x81a\x10\xA1V[_\x81R` \x91_\x83\x83\x01R_`@\x83\x01R\x82\x81\x01Q\x90```@\x82\x01Q\x91\x01Q_\x1A\x91\x83R\x83\x83\x01R`@\x82\x01R`\xC0\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDC\x81\x85\x02`\x045\x016\x03\x01\x12a\x02\xFCW`@Q\x90a\x0C`\x82a\x10\xEAV[a\x0Cs`$`\xC0\x86\x02`\x045\x01\x01a\x11\x8DV[\x80\x83Ra\x0C\x89`D`\xC0\x87\x02`\x045\x01\x01a\x11\x8DV[\x90\x81\x85\x85\x01Ra\x0C\xA2`d`\xC0\x88\x02`\x045\x01\x01a\x11\x8DV[`@\x85\x81\x01\x91\x90\x91R`\x045`\xC0\x88\x02\x01`\x84\x81\x015``\x87\x01R`\xA4\x81\x015`\x80\x87\x01R`\xC4\x015`\xA0\x86\x01R\x83\x01Q\x83Q\x93\x86\x01Q`\xFF\x91\x90\x91\x16\x92`\x01`\x01`\xA0\x1B\x03\x83\x16;\x15a\x02\xFCW_`\x01`\x01`\xA0\x1B\x03\x80\x94`\xE4\x94\x8B\x98\x84\x98`\xC4`\xC0`@Q\x9C\x8D\x9B\x8C\x9A\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8CR\x16`\x04\x8B\x01R0`$\x8B\x01R`\x84\x82\x82\x02`\x045\x01\x015`D\x8B\x01R\x02`\x045\x01\x015`d\x88\x01R`\x84\x87\x01R`\xA4\x86\x01R`\xC4\x85\x01R\x16Z\xF1\x90\x81a\x0EfW[Pa\x0E\\Wa\r\x7Fa(wV[\x90`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x81\x83\x01Q\x16`D`@Q\x80\x95\x81\x93\x7F\xDDb\xED>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01R0`$\x83\x01RZ\xFA\x91\x82\x15a\x02\xF1W_\x92a\x0E,W[P``\x01Q\x03a\r\xF7WPP`\x01\x90[\x01a\t?V[\x80Q\x15a\x0E\x04W\x80Q\x91\x01\xFD[\x7F\xA7(V\x89\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91P\x83\x81\x81=\x83\x11a\x0EUW[a\x0ED\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x90``a\r\xE1V[P=a\x0E:V[PP`\x01\x90a\r\xF1V[a\x0Eo\x90a\x11\x06V[\x8Aa\rrV[\x7F\xAA\xAD\x13\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[4a\x02\xFCWa\x0E\xAB6a\x0E\xCAV[a\x0E\xB3a\x19EV[a\x0E\xBBa\x19rV[a\x03\x90a\x02\xA3a\x03q\x83a\x1A;V[`\x03\x19\x90` \x82\x82\x01\x12a\x02\xFCW`\x045\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW\x82`\xA0\x92\x03\x01\x12a\x02\xFCW`\x04\x01\x90V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a\x0F\x1BWPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a\x0F\rV[\x93\x92\x90a\x0FD\x90``\x86R``\x86\x01\x90a\x0E\xFCV[\x93` \x94\x81\x81\x03` \x83\x01R` \x80\x85Q\x92\x83\x81R\x01\x94\x01\x90_[\x81\x81\x10a\x0F\x7FWPPPa\x0F|\x93\x94P`@\x81\x84\x03\x91\x01Ra\x0E\xFCV[\x90V[\x82Q`\x01`\x01`\xA0\x1B\x03\x16\x86R\x94\x87\x01\x94\x91\x87\x01\x91`\x01\x01a\x0F_V[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x80\x85\x01\x94\x84`\x05\x1B\x01\x01\x11a\x02\xFCWV[\x91\x81`\x1F\x84\x01\x12\x15a\x02\xFCW\x825\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11a\x02\xFCW` \x83\x81\x86\x01\x95\x01\x01\x11a\x02\xFCWV[\x90`\x1F\x19`\x1F` \x80\x94\x80Q\x91\x82\x91\x82\x87R\x01\x86\x86\x01^_\x85\x82\x86\x01\x01R\x01\x16\x01\x01\x90V[` \x80\x82\x01\x90` \x83R\x83Q\x80\x92R`@\x83\x01\x92` `@\x84`\x05\x1B\x83\x01\x01\x95\x01\x93_\x91[\x84\x83\x10a\x10UWPPPPPP\x90V[\x90\x91\x92\x93\x94\x95\x84\x80a\x10\x91\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC0\x86`\x01\x96\x03\x01\x87R\x8AQa\x0F\xFBV[\x98\x01\x93\x01\x93\x01\x91\x94\x93\x92\x90a\x10EV[``\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`\xC0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`@RV[`\xA0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[`\xE0\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[\x90`\x1F`\x1F\x19\x91\x01\x16\x81\x01\x90\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@RV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x05\x1B` \x01\x90V[5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\x02\xFCWV[`D5\x90\x81\x15\x15\x82\x03a\x02\xFCWV[\x91\x90\x91`\x80\x81\x84\x03\x12a\x02\xFCW`@\x90\x81Q\x91`\x80\x83\x01\x94g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x95\x84\x81\x10\x87\x82\x11\x17a\x10\xBDW\x82R\x83\x95a\x12\0\x84a\x11\x8DV[\x85R` \x90\x81\x85\x015\x90\x81\x11a\x02\xFCW\x84\x01\x82`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x90a\x12)\x82a\x11uV[\x93a\x126\x86Q\x95\x86a\x11RV[\x82\x85R\x83\x85\x01\x90\x84``\x80\x95\x02\x84\x01\x01\x92\x81\x84\x11a\x02\xFCW\x85\x01\x91[\x83\x83\x10a\x12tWPPPPP\x84\x01R\x81\x81\x015\x90\x83\x01R``\x90\x81\x015\x91\x01RV[\x84\x83\x83\x03\x12a\x02\xFCW\x87Q\x90a\x12\x89\x82a\x10\xA1V[a\x12\x92\x84a\x11\x8DV[\x82Ra\x12\x9F\x87\x85\x01a\x11\x8DV[\x87\x83\x01R\x88\x84\x015\x90\x81\x15\x15\x82\x03a\x02\xFCW\x82\x88\x92\x8B\x89\x95\x01R\x81R\x01\x92\x01\x91a\x12RV[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x805\x91` \x91a\x12\xDE\x84a\x11uV[\x93a\x12\xEC`@Q\x95\x86a\x11RV[\x80\x85R\x83\x80\x86\x01\x91`\x05\x1B\x83\x01\x01\x92\x80\x84\x11a\x02\xFCW\x84\x83\x01\x91[\x84\x83\x10a\x13\x17WPPPPPP\x90V[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCW\x86\x91a\x139\x84\x84\x80\x94\x89\x01\x01a\x11\xC6V[\x81R\x01\x92\x01\x91a\x13\x07V[5`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x90V[5\x80\x15\x15\x81\x03a\x02\xFCW\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x10\xBDW`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x13\x8D\x82a\x13eV[\x91a\x13\x9B`@Q\x93\x84a\x11RV[\x82\x94\x81\x84R\x81\x83\x01\x11a\x02\xFCW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90`\x80\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x80\x82Q\x16\x83R` \x93\x84\x83\x01Q\x94`\x80\x81\x86\x01R\x85Q\x80\x92R\x80`\xA0\x86\x01\x96\x01\x92_\x90[\x83\x82\x10a\x14\x0BWPPPPP``\x81`@\x82\x93\x01Q`@\x85\x01R\x01Q\x91\x01R\x90V[\x84Q\x80Q\x82\x16\x89R\x80\x84\x01Q\x82\x16\x89\x85\x01R`@\x90\x81\x01Q\x15\x15\x90\x89\x01R``\x90\x97\x01\x96\x93\x82\x01\x93`\x01\x90\x91\x01\x90a\x13\xE9V[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x14\xBDWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x14\xF8\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x14\x81V[\x81`\x1F\x82\x01\x12\x15a\x02\xFCW\x80Q\x90a\x15\x1E\x82a\x13eV[\x92a\x15,`@Q\x94\x85a\x11RV[\x82\x84R` \x83\x83\x01\x01\x11a\x02\xFCW\x81_\x92` \x80\x93\x01\x83\x86\x01^\x83\x01\x01R\x90V[\x90` \x82\x82\x03\x12a\x02\xFCW\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x80`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x90` \x91a\x15\x8E\x81a\x11uV[\x93a\x15\x9C`@Q\x95\x86a\x11RV[\x81\x85R` \x80\x86\x01\x92`\x05\x1B\x82\x01\x01\x92\x83\x11a\x02\xFCW` \x01\x90[\x82\x82\x10a\x15\xC5WPPPP\x90V[\x81Q\x81R\x90\x83\x01\x90\x83\x01a\x15\xB7V[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a\x16\0\x91\x83\x01a\x15sV[\x93` \x80\x83\x01Q\x85\x81\x11a\x02\xFCW\x83\x01\x90\x82`\x1F\x83\x01\x12\x15a\x02\xFCW\x81Q\x91a\x16(\x83a\x11uV[\x92a\x166`@Q\x94\x85a\x11RV[\x80\x84R\x82\x80\x85\x01\x91`\x05\x1B\x83\x01\x01\x91\x85\x83\x11a\x02\xFCW\x83\x01\x90[\x82\x82\x10a\x16rWPPPP\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15sV[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x03a\x02\xFCW\x81R\x90\x83\x01\x90\x83\x01a\x16PV[\x80Q\x82\x10\x15a\x16\xA5W` \x91`\x05\x1B\x01\x01\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[\x91\x90\x91` \x90\x81\x81R`\xC0\x81\x01\x91`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x81\x83\x01R\x80\x85\x01Q\x92`\xA0`@\x84\x01R\x83Q\x80\x91R`\xE0\x83\x01\x91\x80`\xE0\x83`\x05\x1B\x86\x01\x01\x95\x01\x92_\x90[\x83\x82\x10a\x17QWPPPPP`\x80\x84`@a\x0F|\x95\x96\x01Q``\x84\x01R``\x81\x01Q\x15\x15\x82\x84\x01R\x01Q\x90`\xA0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x90\x91\x92\x93\x95\x83\x80a\x17\x8C\x83\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF \x8A`\x01\x96\x03\x01\x86R\x8AQa\x13\xB7V[\x98\x01\x92\x01\x92\x01\x90\x93\x92\x91a\x17\x15V[\x91\x90a\x17\xA63a(\xB9V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\x84\\a\x18\xB1W`\x01\x90`\x01\x86]a\x17\xDF\x83a\x11uV[\x92a\x17\xED`@Q\x94\x85a\x11RV[\x80\x84R`\x1F\x19a\x17\xFC\x82a\x11uV[\x01_[\x81\x81\x10a\x18\xA0WPP_[\x81\x81\x10a\x18WWPPPP\x90_a\x18L\x92\x94]\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\\\x91a\x18NW[Pa6\xB1V[V[_\x90]_a\x18FV[\x80a\x18\x84_\x80a\x18la\x0B\xE0\x89\x96\x88\x8Aa\x19*V[` \x81Q\x91\x010Z\xF4a\x18}a(wV[\x900aA\\V[a\x18\x8E\x82\x88a\x16\x91V[Ra\x18\x99\x81\x87a\x16\x91V[P\x01a\x18\nV[\x80``` \x80\x93\x89\x01\x01R\x01a\x17\xFFV[\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x816\x03\x83\x13a\x02\xFCWV[\x90\x82\x10\x15a\x16\xA5Wa\x19A\x91`\x05\x1B\x81\x01\x90a\x18\xD9V[\x90\x91V[\x7F\x9Bw\x9B\x17B-\r\xF9\"#\x01\x8B2\xB4\xD1\xFAF\xE0qr=h\x17\xE2Hm\0;\xEC\xC5_\0\x80\\a\x18\xB1W`\x01\x90]V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x163\x03a\x19\xA4WV[\x7F\x08\x96v\xD5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R3`\x04R`$_\xFD[\x90a\x19\xDA\x82a\x11uV[a\x19\xE7`@Q\x91\x82a\x11RV[\x82\x81R`\x1F\x19a\x19\xF7\x82\x94a\x11uV[\x01\x90` 6\x91\x017V[\x91\x90\x82\x01\x80\x92\x11a\x1A\x0EWV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[`@\x81\x015B\x11a&\xC3W\x90a\x1A^a\x1AW` \x84\x01\x84a6\xF4V[\x90Pa\x19\xD0V[\x91_[a\x1An` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a%\xC7Wa\x1A\x98\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[6\x93\x91a7HV[a\x11\xC6V[\x93`@\x85\x01Q\x93`\x01`\x01`\xA0\x1B\x03\x86Q\x16\x90` \x87\x01Q\x80Q\x15a\x16\xA5W` \x01Q`@\x01Q\x15\x15\x80a%\xBEW[\x15a%cWa\x1A\xECa\x1A\xD8\x86a\x13DV[\x87\x84a\x1A\xE6``\x8A\x01a\x13XV[\x92a:\xDDV[_[` \x88\x01QQ\x81\x10\x15a%SWa\x1B\x03a7\x88V[` \x89\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW\x82\x14\x80` \x83\x01R\x82\x15\x82R_\x14a%LW``\x89\x01Q\x90[a\x1B;\x83` \x8C\x01Qa\x16\x91V[Q`@\x81\x01Q\x90\x91\x90\x15a\x1C\xEEWa\x1B\xD3`\x01`\x01`\xA0\x1B\x03\x83Q\x16\x93`\x01`\x01`\xA0\x1B\x03\x88\x16\x85\x14_\x14a\x1C\xE7W`\x01\x94[`@Q\x95a\x1B{\x87a\x11\x1AV[_\x87Ra\x1B\x87\x81a7\xBEV[` \x87\x01R`@\x86\x01R``\x94\x85\x91\x8D\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x93\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1C\xB0W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1C\x90\x93`\x01\x96\x95a\x1C8\x8C\x8Ca\x16\x91V[R\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x01a\x1A\xEEV[` \x01Q\x90\x97P`\x01`\x01`\xA0\x1B\x03\x16\x92P`\x01\x90a\x1C\x90V[` \x92\x94P\x90\x81a\x1C\xD5\x92\x90=\x10a\x1C\xE0W[a\x1C\xCD\x81\x83a\x11RV[\x81\x01\x90a7\xF5V[\x91PP\x92\x90_a\x1C\x10V[P=a\x1C\xC3V[_\x94a\x1BnV[\x88\x8A`\x01`\x01`\xA0\x1B\x03\x84\x95\x94Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x8A\x16\x14_\x14a!2WPP\x81Q\x15\x90Pa nW\x88\x8A\x80\x15\x15\x80a SW[a\x1FMW[`\x01`\x01`\xA0\x1B\x03\x93\x92\x91a\x1D\xDD\x82a\x1E\x15\x97\x8B_\x95\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92\x16\x80\x88R\x82` R`@\x88 \\a\x1F<W[PPP[`\x01a\x1D\x9C\x89\x83Q\x16` \x84\x01\x99\x8B\x8BQ\x16\x90\x80\x15\x8A\x14a\x1F6WP\x83\x91aB#V[\x99\x90\x92Q\x16\x94a\x1D\xB1`\x80\x91\x82\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a\x1D\xC1\x89a\x10\xEAV[\x88R0` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x96\x81\x92\x7F!Ex\x97\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a9\xB1V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a\x1F\x0CW[P` \x01Q\x15a\x1E\xE9W\x91a\x1E\xBC\x82`\x01`\x01`\xA0\x1B\x03`\x01\x96\x95a\x1Eza\x1E\xE4\x96\x86a\x16\x91V[Qa\x1E\x85\x8D\x8Da\x16\x91V[Ra\x1E\xB3\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[PQ\x16\x92a\x16\x91V[Q\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1C\x90V[\x98P`\x01\x92\x94Pa\x1F\x02\x90`\x01`\x01`\xA0\x1B\x03\x92a\x16\x91V[Q\x97Q\x16\x92a\x1C\x90V[` \x91\x94Pa\x1F,\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[\x81\x01\x90a9iV[P\x94\x91\x90Pa\x1ERV[\x91aB#V[a\x1FE\x92aCAV[_\x82\x81a\x1DuV[Pa\x1FZ\x90\x92\x91\x92a\x13DV[\x91a\x1Fd\x8BaB\xFDV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16`\x04\x82\x01R0`$\x82\x01R\x90\x84\x16`D\x82\x01R\x92\x87\x16`d\x84\x01R_\x83\x80`\x84\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a DW[P\x97P\x92PP\x91\x92\x93Pa\x1D*V[a M\x90a\x11\x06V[_a 5V[Pa ]\x82a\x13DV[`\x01`\x01`\xA0\x1B\x03\x160\x14\x15a\x1D%V[\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91`\x01`\x01`\xA0\x1B\x03\x84Q\x16\x92\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`\x04\x85\x01R0`$\x85\x01R`D\x84\x01\x8C\x90R_\x90\x84\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1W\x8Aa\x1D\xDD\x8Da\x1E\x15\x97`\x01`\x01`\xA0\x1B\x03\x97_\x95a!#W[Pa\x1DyV[a!,\x90a\x11\x06V[_a!\x1DV[`\x01`\x01`\xA0\x1B\x03` \x87\x96\x94\x97\x01Q\x16\x90\x89\x81\x83\x14_\x14a#\xD7Wa!\xCD\x92Pa\"\x05\x97\x91P`\x01a!s_\x96\x95`\x01`\x01`\xA0\x1B\x03\x93\x84\x8BQ\x16aB#V[P\x92\x82\x89Q\x16\x95` \x89\x01Q\x15\x15\x88\x14a#\xAEWa!\x90\x82a\x13DV[\x94[a!\xA1`\x80\x93\x84\x81\x01\x90a\x18\xD9V[\x95\x90\x96`@Q\x99a!\xB1\x8Ba\x10\xEAV[\x8AR\x16` \x89\x01R`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x95\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W_\x93a#\x84W[P` \x01Q\x15a\"\xC3W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a\"i\x8C\x8Ca\x16\x91V[Ra\"\x99\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x81\x81\x01Q\x91Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R`$\x81\x01\x85\x90R\x93\x9AP\x90\x91\x16\x94P\x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa#YW[P`\x01\x90a\x1C\x90V[` \x90\x81=\x83\x11a#}W[a#o\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a#PV[P=a#eV[` \x91\x93Pa#\xA4\x90=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x81\x01\x90a8|V[P\x93\x91\x90Pa\"BV[\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a!\x92V[`\x01`\x01`\xA0\x1B\x03a$f\x95a$.\x93\x94\x95a#\xF8`\x80\x9B\x8C\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a$\x08\x89a\x116V[_\x89R` \x89\x01R\x16`@\x87\x01R``\x9A\x8B\x97\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x93\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a%%W[PP` \x01Q\x15a\x1C\x96W\x81`\x01`\x01`\xA0\x1B\x03` a\x1E\xE4\x93`\x01\x96\x95a$\xCB\x8C\x8Ca\x16\x91V[Ra$\xFB\x83\x83\x83\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x92\x94P\x90\x81a%A\x92\x90=\x10a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[\x91PP\x92\x90_a$\xA3V[_\x90a\x1B-V[P\x91\x95P\x90\x93PP`\x01\x01a\x1AaV[a%\x8D\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[Pa%\xB9\x86\x83\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a\x1A\xECV[P2\x15\x15a\x1A\xC7V[PPa%\xF2\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a%\xFD\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a&c\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra&\x91`@_ \\\x82a&~\x85\x8Da\x16\x91V[Q\x16_R\x88` R`@_ \\\x90a\x1A\x01V[a&\x9B\x83\x87a\x16\x91V[Ra&\xA6\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a&DV[P\x94\x93\x91P\x91PV[\x7F\xE0\x8B\x8A\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90_\x19\x82\x01\x91\x82\x13`\x01\x16a\x1A\x0EWV[\x7F\x80\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x14a\x1A\x0EW_\x19\x01\x90V[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x81\\\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a'y\x81\\a&\xEBV[\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91[_\x81\x12\x15a(:WPPPa'\xB1\x90a&\xEBV[\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92[_\x81\x12\x15a'\xEAWPPPPa\x18L\x90a6\xB1V[a(5\x90\x82_Ra(/` _\x83\x82\x82 \x01\\\x91\x82\x82R\x88\x81R\x88`@\x91a(\"\x8A\x8D\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a>\xB0V[\x84\x84RR\x81 ]\x84a>\rV[Pa&\xFCV[a'\xD5V[a(r\x90\x82_Ra(/` _\x8A\x87\x85\x84\x84 \x01\\\x93\x84\x84R\x81\x81Ra(\"\x8C`@\x94\x85\x87 \\\x90`\x01`\x01`\xA0\x1B\x03\x89\x16\x90a:\xDDV[a'\x9DV[=\x15a(\xA1W=\x90a(\x88\x82a\x13eV[\x91a(\x96`@Q\x93\x84a\x11RV[\x82R=_` \x84\x01>V[``\x90V[5\x90e\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x82\x03a\x02\xFCWV[\x90_\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x81\\\x16\x15a(\xF1WPPV[\x90\x91\x92P]`\x01\x90V[\x90`@\x82\x015B\x11a&\xC3Wa)\x17a\x1AW` \x84\x01\x84a6\xF4V[\x91_[a)'` \x83\x01\x83a6\xF4V[\x90P\x81\x10\x15a5\xD1Wa)D\x81a\x1A\x93a\x1A\x8B` \x86\x01\x86a6\xF4V[``\x81\x01Q\x90a)~`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P` \x81\x01QQ_\x19\x81\x01\x90\x81\x11a\x1A\x0EW[_\x81\x12\x15a)\xA4WPPP`\x01\x01a)\x1AV[a)\xB2\x81` \x84\x01Qa\x16\x91V[Qa)\xBBa7\x88V[\x90\x82\x15` \x83\x01R` \x84\x01QQ\x80_\x19\x81\x01\x11a\x1A\x0EW_\x19\x01\x83\x14\x80\x83Ra5\x8FW[` \x82\x01Q\x15a5TW`@\x84\x01Q`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x91[`@\x81\x01Q\x15a,\x1DW\x83\x91`\x01`\x01`\xA0\x1B\x03``\x92` a*\xA0\x97\x01Q\x15\x15\x80a,\x14W[a+\xEDW[Q\x16\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x82\x03a+\xE6W`\x01\x91[`@Q\x92a*L\x84a\x11\x1AV[`\x01\x84Ra*Y\x81a7\xBEV[` \x84\x01R`@\x83\x01R\x88\x83\x83\x01R`\x80\x82\x01R`@Q\x80\x95\x81\x92\x7FCX;\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a:\"V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a+\xBFW[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a+\x02a+\xAB\x97\x96\x94a+u\x94a\x16\x91V[Ra+6`\x01`\x01`\xA0\x1B\x03\x82\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[P`\x01`\x01`\xA0\x1B\x03a+M\x84`@\x8A\x01Qa7\xB1V[\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[`\x01`\x01`\xA0\x1B\x03\x85Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[a&\xFCV[a)\x91V[PPPa+\xAB\x91\x93P\x92a&\xFCV[` \x91\x95Pa+\xDC\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa*\xE1V[_\x91a*?V[a,\x0Fa+\xF9\x8Da\x13DV[\x8D\x8Ba\x1A\xE6\x88`@\x88\x84Q\x16\x93\x01Q\x93\x01a\x13XV[a*(V[P2\x15\x15a*#V[\x90`\x01`\x01`\xA0\x1B\x03\x82Q\x16\x80`\x01`\x01`\xA0\x1B\x03\x85\x16\x14_\x14a17WP` \x84\x01Qa0IWP`@Q\x92\x7F\x96xp\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x85\x01R` \x84`$\x81`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15a\x02\xF1W_\x94a0\x15W[P\x83\x91`\x01`\x01`\xA0\x1B\x03\x81Q\x16`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x95\x90\x95R_\x85\x80`d\x81\x01\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a0\x06W[P[a\x1D\xDD`\x01`\x01`\xA0\x1B\x03a-\xA8\x8B\x82\x85Q\x16\x83` \x87\x01Q\x16\x90aB#V[P\x92Q\x16\x91\x8C`\x02a-\xBF`\x80\x92\x83\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a-\xCF\x88a\x10\xEAV[\x87R0` \x88\x01R\x89`@\x88\x01R``\x87\x01R\x85\x01R6\x91a\x13\x81V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x93\x84\x15a\x02\xF1W_\x94a/\xE3W[P` \x01Q\x15a.\xCFW\x90\x82\x91a+\xAB\x94\x93a.E\x89\x8Da\x16\x91V[Ra.z\x83`\x01`\x01`\xA0\x1B\x03\x84\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[\x80\x83\x10\x80a.\xB4W[a.\x90W[PPPa&\xFCV[a.\xA6a.\xAC\x93a.\xA0\x8Ba\x13DV[\x92a7\xB1V[\x91aCVV[_\x80\x80a.\x88V[P0`\x01`\x01`\xA0\x1B\x03a.\xC7\x8Ba\x13DV[\x16\x14\x15a.\x83V[\x94P\x90\x80\x94\x80\x82\x10a.\xE8W[PPPa+\xAB\x90a&\xFCV[\x91a.\xF8` \x92a/w\x94a7\xB1V[\x90a/-\x82`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x83aCVV[`@Q\x93\x84\x92\x83\x92\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa/\xB8W[\x80\x80a.\xDCV[` \x90\x81=\x83\x11a/\xDCW[a/\xCE\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a/\xB1V[P=a/\xC4V[` \x91\x94Pa/\xFB\x90=\x80_\x83>a\x1F$\x81\x83a\x11RV[P\x90\x94\x91\x90Pa.)V[a0\x0F\x90a\x11\x06V[_a-\x86V[\x90\x93P` \x81=` \x11a0AW[\x81a01` \x93\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWQ\x92_a,\xBCV[=\x91Pa0$V[\x90\x92a0T\x89a\x13DV[`\x01`\x01`\xA0\x1B\x030\x91\x16\x03a0oW[_a-\xEC\x94a-\x88V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a0\xA3\x8Aa\x13DV[a0\xAC\x84aB\xFDV[\x90\x86;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01R0`$\x82\x01R\x91\x81\x16`D\x83\x01R\x85\x16`d\x82\x01R\x94_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x90\x81\x15a\x02\xF1Wa-\xEC\x95_\x92a1(W[P\x94PPa0eV[a11\x90a\x11\x06V[_a1\x1FV[`\x01`\x01`\xA0\x1B\x03` \x84\x96\x95\x94\x01Q\x16\x8A\x82\x82\x14_\x14a4\x0BWPPPa2\x0Ca1n_\x92\x84`\x01`\x01`\xA0\x1B\x03\x88Q\x16aB#V[\x92\x90a1\xD4\x8C`\x01`\x01`\xA0\x1B\x03\x80\x8AQ\x16\x93\x89Q\x15\x15\x86\x14a3\xDFWa1\xA3a1\x97\x84a\x13DV[\x93[`\x80\x81\x01\x90a\x18\xD9V[\x92\x90\x93`@Q\x96a1\xB3\x88a\x10\xEAV[\x87R\x16` \x86\x01R`@\x85\x01R\x8C``\x85\x01R`\x02`\x80\x85\x01R6\x91a\x13\x81V[`\xA0\x82\x01R`@Q\x80\x93\x81\x92\x7FJ\xF2\x9E\xC4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\xF8V[\x03\x81\x83`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x90\x81\x15a\x02\xF1W_\x91a3\xC4W[P` \x84\x01Q\x8C\x90\x8A\x90\x15a3\xAAW\x83\x83`\x01`\x01`\xA0\x1B\x03\x93a2\x83a2\x89\x94a2|\x8F\x9C\x9B\x9A\x98\x99a2\xB2\x9Aa\x16\x91V[Q\x92a\x16\x91V[Ra\x16\x91V[Q\x91\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[Q\x15a2\xF4Wa+\xAB\x92\x91`\x01`\x01`\xA0\x1B\x03` a+\xA6\x93\x01Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aCAV[Q`@Q\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R` \x81\x80`D\x81\x01\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x80\x15a\x02\xF1Wa3\x7FW[Pa+\xAB\x90a&\xFCV[` \x90\x81=\x83\x11a3\xA3W[a3\x95\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a3uV[P=a3\x8BV[PP\x90\x91Pa3\xBB\x92\x93\x96Pa\x16\x91V[Q\x93\x84\x91a2\xB2V[a3\xD8\x91P=\x80_\x83>a#\x9C\x81\x83a\x11RV[\x90Pa2IV[a1\xA3\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x93a1\x99V[a4\x9E\x96P\x90a4f\x91``\x94\x8Ba4+`\x80\x99\x98\x99\x93\x84\x81\x01\x90a\x18\xD9V[\x93\x90\x94`@Q\x97a4;\x89a\x116V[`\x01\x89R` \x89\x01R`\x01`\x01`\xA0\x1B\x03\x8B\x16`@\x89\x01R\x88\x88\x01R\x86\x01R`\xA0\x85\x01R6\x91a\x13\x81V[`\xC0\x82\x01R`@Q\x80\x95\x81\x92\x7F+\xFBx\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`\x04\x83\x01a8\x10V[\x03\x81_`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xF1\x92\x83\x15a\x02\xF1W\x87\x91\x8B\x91_\x95a5-W[P` \x01Q\x15a+\xB0Wa+\xA6\x92\x84a5\x05a+\xAB\x97\x96\x94`\x01`\x01`\xA0\x1B\x03\x94a\x16\x91V[R\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aB\nV[` \x91\x95Pa5J\x90``=``\x11a\x1C\xE0Wa\x1C\xCD\x81\x83a\x11RV[P\x95\x91\x90Pa4\xDFV[o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x01`\x01`\xA0\x1B\x03` a5\x85\x81\x88\x01Qa5\x7F\x88a&\xEBV[\x90a\x16\x91V[Q\x01Q\x16\x91a)\xFCV[a5\xCC\x85`\x01`\x01`\xA0\x1B\x03` \x84\x01a\x1Cg\x82\x82Q\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0aA\xC0V[a)\xE0V[PPa5\xFC\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a:qV[\x91a6\x07\x83Qa\x19\xD0V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x91\x90_[\x86Q\x81\x10\x15a&\xBAW`\x01\x90`\x01`\x01`\xA0\x1B\x03\x80a6m\x83\x8Ba\x16\x91V[Q\x16_R\x85` Ra6\x88`@_ \\\x82a&~\x85\x8Da\x16\x91V[a6\x92\x83\x87a\x16\x91V[Ra6\x9D\x82\x8Aa\x16\x91V[Q\x16_R\x85` R_`@\x81 ]\x01a6NV[G\x80\x15a6\xF0W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\a6\xF0W`\x01`\x01`\xA0\x1B\x03a\x18L\x92\x16a@\xE0V[PPV[\x905\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x805\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\x02\xFCW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x02\xFCWV[\x91\x90\x81\x10\x15a\x16\xA5W`\x05\x1B\x81\x015\x90\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x816\x03\x01\x82\x12\x15a\x02\xFCW\x01\x90V[`@Q\x90`@\x82\x01\x82\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x10\xBDW`@R_` \x83\x82\x81R\x01RV[\x91\x90\x82\x03\x91\x82\x11a\x1A\x0EWV[`\x02\x11\x15a7\xC8WV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x90\x81``\x91\x03\x12a\x02\xFCW\x80Q\x91`@` \x83\x01Q\x92\x01Q\x90V[a\x01\0`\xC0a\x0F|\x93` \x84R\x80Qa8(\x81a7\xBEV[` \x85\x01R` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x80\x91\x16`@\x86\x01R\x80`@\x83\x01Q\x16``\x86\x01R``\x82\x01Q\x16`\x80\x85\x01R`\x80\x81\x01Q`\xA0\x85\x01R`\xA0\x81\x01Q\x82\x85\x01R\x01Q\x91`\xE0\x80\x82\x01R\x01\x90a\x0F\xFBV[\x90\x91``\x82\x84\x03\x12a\x02\xFCW\x81Q\x91g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x81\x11a\x02\xFCW\x84a8\xA8\x91\x83\x01a\x15sV[\x93` \x82\x01Q\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[\x90\x81Q\x80\x82R` \x80\x80\x93\x01\x93\x01\x91_[\x82\x81\x10a8\xE4WPPPP\x90V[\x83Q\x85R\x93\x81\x01\x93\x92\x81\x01\x92`\x01\x01a8\xD6V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01Ra91`@\x83\x01Q`\xC0``\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90``\x83\x01Q`\x80\x82\x01R`\x80\x83\x01Q`\x05\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91``\x83\x83\x03\x12a\x02\xFCW\x82Q\x92` \x81\x01Q\x92g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x81\x11a\x02\xFCW\x81a9\x9A\x91\x84\x01a\x15sV[\x93`@\x83\x01Q\x90\x81\x11a\x02\xFCWa\x0F|\x92\x01a\x15\x07V[` \x81R`\x01`\x01`\xA0\x1B\x03\x80\x83Q\x16` \x83\x01R` \x83\x01Q\x16`@\x82\x01R`@\x82\x01Q``\x82\x01Ra9\xF4``\x83\x01Q`\xC0`\x80\x84\x01R`\xE0\x83\x01\x90a8\xC5V[\x90`\x80\x83\x01Q`\x04\x81\x10\x15a7\xC8Wa\x0F|\x93`\xA0\x91\x82\x84\x01R\x01Q\x90`\xC0`\x1F\x19\x82\x85\x03\x01\x91\x01Ra\x0F\xFBV[\x91\x90\x91`\x80\x80`\xA0\x83\x01\x94\x80Qa:8\x81a7\xBEV[\x84R` \x81\x01Qa:H\x81a7\xBEV[` \x85\x01R`\x01`\x01`\xA0\x1B\x03`@\x82\x01Q\x16`@\x85\x01R``\x81\x01Q``\x85\x01R\x01Q\x91\x01RV[\x90\x81\\a:}\x81a\x11uV[a:\x8A`@Q\x91\x82a\x11RV[\x81\x81Ra:\x96\x82a\x11uV[`\x1F\x19` \x91\x016` \x84\x017\x81\x94_[\x84\x81\x10a:\xB5WPPPPPV[`\x01\x90\x82_R\x80\x84_ \x01\\`\x01`\x01`\xA0\x1B\x03a:\xD3\x83\x88a\x16\x91V[\x91\x16\x90R\x01a:\xA7V[\x91\x92\x80a=\xD8W[\x15a<QWPP\x80G\x10a<)W`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x82;\x15a\x02\xFCW`@Q\x90\x7F\xD0\xE3\r\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R_\x91_\x81`\x04\x81\x85\x89Z\xF1\x80\x15a\x02\xF1Wa<\x12W[P`D` \x92\x93\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94a;\x98\x83\x87\x83aCVV[\x84`@Q\x96\x87\x94\x85\x93\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85R`\x04\x85\x01R`$\x84\x01RZ\xF1\x90\x81\x15a<\x06WPa;\xDFWPV[` \x90\x81=\x83\x11a;\xFFW[a;\xF5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCWV[P=a;\xEBV[`@Q\x90=\x90\x82>=\x90\xFD[` \x92Pa<\x1F\x90a\x11\x06V[`D_\x92Pa;cV[\x7F\xA0\x1A\x9D\xF6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x90\x91_\x90\x80a<aW[PPPPV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x94\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91a<\xBB\x84aB\xFDV[\x96\x80;\x15a\x02\xFCW`@Q\x7F6\xC7\x85\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R\x84\x83\x16`$\x82\x01R\x97\x82\x16`D\x89\x01R\x91\x86\x16\x16`d\x87\x01R_\x90\x86\x90`\x84\x90\x82\x90\x84\x90Z\xF1\x94\x85\x15a\x02\xF1Wa=\x80\x95a=\xC4W[P\x82\x93` \x93`@Q\x80\x97\x81\x95\x82\x94\x7F\x15\xAF\xD4\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84R`\x04\x84\x01` \x90\x93\x92\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x82\x01\x95\x16\x81R\x01RV[\x03\x92Z\xF1\x90\x81\x15a<\x06WPa=\x99W[\x80\x80\x80a<[V[` \x90\x81=\x83\x11a=\xBDW[a=\xAF\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW_a=\x91V[P=a=\xA5V[` \x93Pa=\xD1\x90a\x11\x06V[_\x92a=/V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x82\x16\x14a:\xE5V[`\x01\x81\x01\x91\x80_R` \x91\x83\x83R`@_ \\\x80\x15\x15_\x14a>\xA7W_\x19\x90\x81\x81\x01\x83\\\x83\x80\x82\x01\x91\x82\x84\x03a>jW[PPPPP\x81\\\x81\x81\x01\x92\x81\x84\x11a\x1A\x0EW_\x93\x81]\x83R\x84\x83 \x01\x01]_RR_`@\x81 ]`\x01\x90V[a>wa>\x87\x93\x88aD:V[\x86_R\x88_ \x01\x01\\\x91\x85aD:V[\x83_R\x80\x83\x83\x88_ \x01\x01]_R\x85\x85R`@_ ]_\x80\x80\x83\x81a>>V[PPPPP_\x90V[_\x94\x93\x83\x15a@\xD8W\x80a@\xA3W[\x15a@\x07W`\x01`\x01`\xA0\x1B\x03\x91\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16`\x04\x83\x01R0`$\x83\x01R`D\x82\x01\x85\x90R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa?\xF4W[P\x84\x82\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a?\xF0W\x81\x90`$`@Q\x80\x94\x81\x93\x7F.\x1A}M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R\x89`\x04\x84\x01RZ\xF1\x80\x15a?\xE5Wa?\xCDW[Pa\x18L\x93\x94P\x16a@\xE0V[a?\xD7\x86\x91a\x11\x06V[a?\xE1W\x84a?\xC0V[\x84\x80\xFD[`@Q=\x88\x82>=\x90\xFD[P\x80\xFD[a?\xFF\x91\x95Pa\x11\x06V[_\x93_a?SV[\x92\x93P\x90`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x80;\x15a\x02\xFCW`@Q\x7F\xAEc\x93)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16`\x04\x82\x01R\x93\x90\x92\x16`$\x84\x01R`D\x83\x01R_\x90\x82\x90`d\x90\x82\x90\x84\x90Z\xF1\x80\x15a\x02\xF1Wa@\x9AWPV[a\x18L\x90a\x11\x06V[P`\x01`\x01`\xA0\x1B\x03\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90\x83\x16\x14a>\xBFV[PPPP\x90PV[\x81G\x10aA0W_\x80\x80\x93`\x01`\x01`\xA0\x1B\x03\x82\x94\x16Z\xF1aA\0a(wV[P\x15aA\x08WV[\x7F\x14%\xEAB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD[\x7F\xCDx`Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R0`\x04R`$_\xFD[\x90aAqWP\x80Q\x15aA\x08W\x80Q\x90` \x01\xFD[\x81Q\x15\x80aA\xB7W[aA\x82WP\x90V[`\x01`\x01`\xA0\x1B\x03\x90\x7F\x99\x96\xB3\x15\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R\x16`\x04R`$_\xFD[P\x80;\x15aAzV[`\x01\x81\x01\x90\x82_R\x81` R`@_ \\\x15_\x14aB\x03W\x80\\\x81_R\x83\x81` _ \x01]`\x01\x81\x01\x80\x91\x11a\x1A\x0EW\x81]\\\x91_R` R`@_ ]`\x01\x90V[PPP_\x90V[\x90_R` RaB\x1F`@_ \x91\x82\\a\x1A\x01V[\x90]V[\x91`D\x92\x93\x91\x93`\x01`\x01`\xA0\x1B\x03`@\x94\x85\x92\x82\x80\x85Q\x99\x8A\x95\x86\x94\x7F\xC9\xC1f\x1B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86R\x16`\x04\x85\x01R\x16`$\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16Z\xFA\x93\x84\x15aB\xF3W_\x93_\x95aB\xBCW[PPaB\xB9aB\xB2\x85\x94a\x19\xD0V[\x94\x85a\x16\x91V[RV[\x80\x92\x95P\x81\x94P=\x83\x11aB\xECW[aB\xD5\x81\x83a\x11RV[\x81\x01\x03\x12a\x02\xFCW` \x82Q\x92\x01Q\x92_\x80aB\xA3V[P=aB\xCBV[\x83Q=_\x82>=\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x81\x81\x11aC\x11W\x16\x90V[\x7Fm\xFC\xC6P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\xA0`\x04R`$R`D_\xFD[\x90_R` RaB\x1F`@_ \x91\x82\\a7\xB1V[`@Q\x92` \x84\x01\x90\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82R`\x01`\x01`\xA0\x1B\x03\x80\x94\x16`$\x86\x01R`D\x85\x01R`D\x84R`\x80\x84\x01\x90\x84\x82\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x11\x17a\x10\xBDWaC\xD5\x93_\x93\x84\x93`@R\x16\x94Q\x90\x82\x86Z\xF1aC\xCEa(wV[\x90\x83aA\\V[\x80Q\x90\x81\x15\x15\x91\x82aD\x16W[PPaC\xEBWPV[\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04R`$_\xFD[\x81\x92P\x90` \x91\x81\x01\x03\x12a\x02\xFCW` \x01Q\x80\x15\x90\x81\x15\x03a\x02\xFCW_\x80aC\xE2V[\\\x11\x15aDCWV[\x7F\x0FJ\xE0\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x04_\xFD\xFE\xA2dipfsX\"\x12 \"\x9A\\\xF8\x9A\xA7\xC2\xD0\xA4\xB4\xD5\xDB \xBB\xA6\xC2\xB3\xA7K\x08\x03\x03\xFCn\xC0\x0B\xA5\x82\xA5\xDC\xF7QdsolcC\0\x08\x1A\x003",
-    );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`.
-    ```solidity
-    error AddressEmptyCode(address target);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct AddressEmptyCode {
-        #[allow(missing_docs)]
-        pub target: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
-            fn from(value: AddressEmptyCode) -> Self {
-                (value.target,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { target: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for AddressEmptyCode {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
-            const SIGNATURE: &'static str = "AddressEmptyCode(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.target,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `AddressInsufficientBalance(address)` and selector `0xcd786059`.
-    ```solidity
-    error AddressInsufficientBalance(address account);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct AddressInsufficientBalance {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<AddressInsufficientBalance> for UnderlyingRustTuple<'_> {
-            fn from(value: AddressInsufficientBalance) -> Self {
-                (value.account,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressInsufficientBalance {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { account: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for AddressInsufficientBalance {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [205u8, 120u8, 96u8, 89u8];
-            const SIGNATURE: &'static str = "AddressInsufficientBalance(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ErrorSelectorNotFound()` and selector `0xa7285689`.
-    ```solidity
-    error ErrorSelectorNotFound();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ErrorSelectorNotFound;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ErrorSelectorNotFound> for UnderlyingRustTuple<'_> {
-            fn from(value: ErrorSelectorNotFound) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ErrorSelectorNotFound {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for ErrorSelectorNotFound {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [167u8, 40u8, 86u8, 137u8];
-            const SIGNATURE: &'static str = "ErrorSelectorNotFound()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `EthTransfer()` and selector `0x0540ddf6`.
-    ```solidity
-    error EthTransfer();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct EthTransfer;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<EthTransfer> for UnderlyingRustTuple<'_> {
-            fn from(value: EthTransfer) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for EthTransfer {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for EthTransfer {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 64u8, 221u8, 246u8];
-            const SIGNATURE: &'static str = "EthTransfer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`.
-    ```solidity
-    error FailedInnerCall();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct FailedInnerCall;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
-            fn from(value: FailedInnerCall) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for FailedInnerCall {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
-            const SIGNATURE: &'static str = "FailedInnerCall()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InputLengthMismatch()` and selector `0xaaad13f7`.
-    ```solidity
-    error InputLengthMismatch();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InputLengthMismatch;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InputLengthMismatch> for UnderlyingRustTuple<'_> {
-            fn from(value: InputLengthMismatch) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputLengthMismatch {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InputLengthMismatch {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 173u8, 19u8, 247u8];
-            const SIGNATURE: &'static str = "InputLengthMismatch()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InsufficientEth()` and selector `0xa01a9df6`.
-    ```solidity
-    error InsufficientEth();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InsufficientEth;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InsufficientEth> for UnderlyingRustTuple<'_> {
-            fn from(value: InsufficientEth) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientEth {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InsufficientEth {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [160u8, 26u8, 157u8, 246u8];
-            const SIGNATURE: &'static str = "InsufficientEth()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ReentrancyGuardReentrantCall()` and selector `0x3ee5aeb5`.
-    ```solidity
-    error ReentrancyGuardReentrantCall();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ReentrancyGuardReentrantCall;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ReentrancyGuardReentrantCall> for UnderlyingRustTuple<'_> {
-            fn from(value: ReentrancyGuardReentrantCall) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReentrancyGuardReentrantCall {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
-            const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SafeCastOverflowedUintDowncast(uint8,uint256)` and selector `0x6dfcc650`.
-    ```solidity
-    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SafeCastOverflowedUintDowncast {
-        #[allow(missing_docs)]
-        pub bits: u8,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Uint<8>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (u8, alloy_sol_types::private::primitives::aliases::U256);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SafeCastOverflowedUintDowncast> for UnderlyingRustTuple<'_> {
-            fn from(value: SafeCastOverflowedUintDowncast) -> Self {
-                (value.bits, value.value)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeCastOverflowedUintDowncast {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    bits: tuple.0,
-                    value: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for SafeCastOverflowedUintDowncast {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [109u8, 252u8, 198u8, 80u8];
-            const SIGNATURE: &'static str = "SafeCastOverflowedUintDowncast(uint8,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
-                        &self.bits,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SafeERC20FailedOperation(address)` and selector `0x5274afe7`.
-    ```solidity
-    error SafeERC20FailedOperation(address token);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SafeERC20FailedOperation {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SafeERC20FailedOperation> for UnderlyingRustTuple<'_> {
-            fn from(value: SafeERC20FailedOperation) -> Self {
-                (value.token,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeERC20FailedOperation {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { token: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for SafeERC20FailedOperation {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [82u8, 116u8, 175u8, 231u8];
-            const SIGNATURE: &'static str = "SafeERC20FailedOperation(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SenderIsNotVault(address)` and selector `0x089676d5`.
-    ```solidity
-    error SenderIsNotVault(address sender);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SenderIsNotVault {
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SenderIsNotVault> for UnderlyingRustTuple<'_> {
-            fn from(value: SenderIsNotVault) -> Self {
-                (value.sender,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SenderIsNotVault {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { sender: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for SenderIsNotVault {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [8u8, 150u8, 118u8, 213u8];
-            const SIGNATURE: &'static str = "SenderIsNotVault(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SwapDeadline()` and selector `0xe08b8af0`.
+    /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`.
     ```solidity
-    error SwapDeadline();
+    error AddressEmptyCode(address target);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct SwapDeadline;
+    pub struct AddressEmptyCode {
+        #[allow(missing_docs)]
+        pub target: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4539,9 +231,9 @@ pub mod BalancerV3BatchRouter {
         use alloy_sol_types;
         #[doc(hidden)]
         #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
         #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
         fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4553,25 +245,25 @@ pub mod BalancerV3BatchRouter {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<SwapDeadline> for UnderlyingRustTuple<'_> {
-            fn from(value: SwapDeadline) -> Self {
-                ()
+        impl ::core::convert::From<AddressEmptyCode> for UnderlyingRustTuple<'_> {
+            fn from(value: AddressEmptyCode) -> Self {
+                (value.target,)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapDeadline {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressEmptyCode {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
+                Self { target: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for SwapDeadline {
+        impl alloy_sol_types::SolError for AddressEmptyCode {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [224u8, 139u8, 138u8, 240u8];
-            const SIGNATURE: &'static str = "SwapDeadline()";
+            const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8];
+            const SIGNATURE: &'static str = "AddressEmptyCode(address)";
 
             #[inline]
             fn new<'a>(
@@ -4582,80 +274,11 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.target,
+                    ),
                 )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `TransientIndexOutOfBounds()` and selector `0x0f4ae0e4`.
-    ```solidity
-    error TransientIndexOutOfBounds();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct TransientIndexOutOfBounds;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<TransientIndexOutOfBounds> for UnderlyingRustTuple<'_> {
-            fn from(value: TransientIndexOutOfBounds) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TransientIndexOutOfBounds {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for TransientIndexOutOfBounds {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [15u8, 74u8, 224u8, 228u8];
-            const SIGNATURE: &'static str = "TransientIndexOutOfBounds()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
             }
 
             #[inline]
@@ -4667,121 +290,16 @@ pub mod BalancerV3BatchRouter {
             }
         }
     };
-    /**Constructor`.
-    ```solidity
-    constructor(address vault, address weth, address permit2, string routerVersion);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub vault: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub weth: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub permit2: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub routerVersion: alloy_sol_types::private::String,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::String,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value.vault, value.weth, value.permit2, value.routerVersion)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        vault: tuple.0,
-                        weth: tuple.1,
-                        permit2: tuple.2,
-                        routerVersion: tuple.3,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::String,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.vault,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.weth,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.permit2,
-                    ),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.routerVersion,
-                    ),
-                )
-            }
-        }
-    };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSender()` and selector `0x5e01eb5a`.
+    /**Custom error with signature `AddressInsufficientBalance(address)` and selector `0xcd786059`.
     ```solidity
-    function getSender() external view returns (address);
+    error AddressInsufficientBalance(address account);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getSenderCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSender()`](getSenderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSenderReturn {
+    pub struct AddressInsufficientBalance {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub account: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -4791,76 +309,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSenderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSenderCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSenderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSenderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSenderReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<AddressInsufficientBalance> for UnderlyingRustTuple<'_> {
+            fn from(value: AddressInsufficientBalance) -> Self {
+                (value.account,)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSenderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressInsufficientBalance {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { account: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSenderCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolError for AddressInsufficientBalance {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [94u8, 1u8, 235u8, 90u8];
-            const SIGNATURE: &'static str = "getSender()";
+            const SELECTOR: [u8; 4] = [205u8, 120u8, 96u8, 89u8];
+            const SIGNATURE: &'static str = "AddressInsufficientBalance(address)";
 
             #[inline]
             fn new<'a>(
@@ -4871,56 +354,30 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSenderReturn = r.into();
-                        r._0
-                    },
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.account,
+                    ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: getSenderReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `multicall(bytes[])` and selector `0xac9650d8`.
+    /**Custom error with signature `ErrorSelectorNotFound()` and selector `0xa7285689`.
     ```solidity
-    function multicall(bytes[] memory data) external payable returns (bytes[] memory results);
+    error ErrorSelectorNotFound();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct multicallCall {
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multicall(bytes[])`](multicallCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multicallReturn {
-        #[allow(missing_docs)]
-        pub results: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-    }
+    pub struct ErrorSelectorNotFound;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4929,82 +386,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multicallCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multicallCall) -> Self {
-                    (value.data,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multicallCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { data: tuple.0 }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multicallReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multicallReturn) -> Self {
-                    (value.results,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ErrorSelectorNotFound> for UnderlyingRustTuple<'_> {
+            fn from(value: ErrorSelectorNotFound) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multicallReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { results: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ErrorSelectorNotFound {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for multicallCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+        impl alloy_sol_types::SolError for ErrorSelectorNotFound {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [172u8, 150u8, 80u8, 216u8];
-            const SIGNATURE: &'static str = "multicall(bytes[])";
+            const SELECTOR: [u8; 4] = [167u8, 40u8, 86u8, 137u8];
+            const SIGNATURE: &'static str = "ErrorSelectorNotFound()";
 
             #[inline]
             fn new<'a>(
@@ -5015,74 +431,26 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bytes,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.data
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bytes,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multicallReturn = r.into();
-                        r.results
-                    },
-                )
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: multicallReturn = r.into();
-                    r.results
-                })
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `permitBatchAndCall((address,address,address,uint256,uint256,uint256)[],bytes[],((address,uint160,uint48,uint48)[],address,uint256),bytes,bytes[])` and selector `0x19c6989f`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `EthTransfer()` and selector `0x0540ddf6`.
     ```solidity
-    function permitBatchAndCall(IRouterCommon.PermitApproval[] memory permitBatch, bytes[] memory permitSignatures, IAllowanceTransfer.PermitBatch memory permit2Batch, bytes memory permit2Signature, bytes[] memory multicallData) external payable returns (bytes[] memory results);
+    error EthTransfer();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitBatchAndCallCall {
-        #[allow(missing_docs)]
-        pub permitBatch: alloy_sol_types::private::Vec<
-            <IRouterCommon::PermitApproval as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub permitSignatures: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        #[allow(missing_docs)]
-        pub permit2Batch: <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub permit2Signature: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub multicallData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`permitBatchAndCall((address,address,address,uint256,uint256,
-    /// uint256)[],bytes[],((address,uint160,uint48,uint48)[],address,uint256),
-    /// bytes,bytes[])`](permitBatchAndCallCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitBatchAndCallReturn {
-        #[allow(missing_docs)]
-        pub results: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-    }
+    pub struct EthTransfer;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5091,113 +459,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<IRouterCommon::PermitApproval>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-                IAllowanceTransfer::PermitBatch,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IRouterCommon::PermitApproval as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-                <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitBatchAndCallCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitBatchAndCallCall) -> Self {
-                    (
-                        value.permitBatch,
-                        value.permitSignatures,
-                        value.permit2Batch,
-                        value.permit2Signature,
-                        value.multicallData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitBatchAndCallCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        permitBatch: tuple.0,
-                        permitSignatures: tuple.1,
-                        permit2Batch: tuple.2,
-                        permit2Signature: tuple.3,
-                        multicallData: tuple.4,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitBatchAndCallReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitBatchAndCallReturn) -> Self {
-                    (value.results,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<EthTransfer> for UnderlyingRustTuple<'_> {
+            fn from(value: EthTransfer) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitBatchAndCallReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { results: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for EthTransfer {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitBatchAndCallCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<IRouterCommon::PermitApproval>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-                IAllowanceTransfer::PermitBatch,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-            );
-            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+        impl alloy_sol_types::SolError for EthTransfer {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [25u8, 198u8, 152u8, 159u8];
-            const SIGNATURE: &'static str = "permitBatchAndCall((address,address,address,uint256,\
-                                             uint256,uint256)[],bytes[],((address,uint160,uint48,\
-                                             uint48)[],address,uint256),bytes,bytes[])";
+            const SELECTOR: [u8; 4] = [5u8, 64u8, 221u8, 246u8];
+            const SIGNATURE: &'static str = "EthTransfer()";
 
             #[inline]
             fn new<'a>(
@@ -5208,87 +504,26 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        IRouterCommon::PermitApproval,
-                    > as alloy_sol_types::SolType>::tokenize(&self.permitBatch),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bytes,
-                    > as alloy_sol_types::SolType>::tokenize(&self.permitSignatures),
-                    <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::tokenize(
-                        &self.permit2Batch,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.permit2Signature,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bytes,
-                    > as alloy_sol_types::SolType>::tokenize(&self.multicallData),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bytes,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: permitBatchAndCallReturn = r.into();
-                        r.results
-                    },
-                )
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: permitBatchAndCallReturn = r.into();
-                    r.results
-                })
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `querySwapExactIn((address,(address,address,bool)[],uint256,uint256)[],address,bytes)` and selector `0xe3b5dff4`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`.
     ```solidity
-    function querySwapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    error FailedInnerCall();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct querySwapExactInCall {
-        #[allow(missing_docs)]
-        pub paths: alloy_sol_types::private::Vec<
-            <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`querySwapExactIn((address,(address,address,bool)[],uint256,uint256)[],
-    /// address,bytes)`](querySwapExactInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct querySwapExactInReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
+    pub struct FailedInnerCall;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5297,128 +532,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactInCall) -> Self {
-                    (value.paths, value.sender, value.userData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paths: tuple.0,
-                        sender: tuple.1,
-                        userData: tuple.2,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactInReturn) -> Self {
-                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsOut: tuple.0,
-                        tokensOut: tuple.1,
-                        amountsOut: tuple.2,
-                    }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
+            fn from(value: FailedInnerCall) -> Self {
+                ()
             }
         }
-        impl querySwapExactInReturn {
-            fn _tokenize(
-                &self,
-            ) -> <querySwapExactInCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for querySwapExactInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = querySwapExactInReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for FailedInnerCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [227u8, 181u8, 223u8, 244u8];
-            const SIGNATURE: &'static str = "querySwapExactIn((address,(address,address,bool)[],\
-                                             uint256,uint256)[],address,bytes)";
+            const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
+            const SIGNATURE: &'static str = "FailedInnerCall()";
 
             #[inline]
             fn new<'a>(
@@ -5429,67 +577,99 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        IBatchRouter::SwapPathExactAmountIn,
-                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InputLengthMismatch()` and selector `0xaaad13f7`.
+    ```solidity
+    error InputLengthMismatch();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InputLengthMismatch;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InputLengthMismatch> for UnderlyingRustTuple<'_> {
+            fn from(value: InputLengthMismatch) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputLengthMismatch {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InputLengthMismatch {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [170u8, 173u8, 19u8, 247u8];
+            const SIGNATURE: &'static str = "InputLengthMismatch()";
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                querySwapExactInReturn::_tokenize(ret)
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `querySwapExactInHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x8a12a08c`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InsufficientEth()` and selector `0xa01a9df6`.
     ```solidity
-    function querySwapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    error InsufficientEth();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct querySwapExactInHookCall {
-        #[allow(missing_docs)]
-        pub params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`querySwapExactInHook((address,(address,(address,address,bool)[],
-    /// uint256,uint256)[],uint256,bool,bytes))`](querySwapExactInHookCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct querySwapExactInHookReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
+    pub struct InsufficientEth;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5498,113 +678,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactInHookParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactInHookCall> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactInHookCall) -> Self {
-                    (value.params,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInHookCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { params: tuple.0 }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactInHookReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactInHookReturn) -> Self {
-                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactInHookReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsOut: tuple.0,
-                        tokensOut: tuple.1,
-                        amountsOut: tuple.2,
-                    }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InsufficientEth> for UnderlyingRustTuple<'_> {
+            fn from(value: InsufficientEth) -> Self {
+                ()
             }
         }
-        impl querySwapExactInHookReturn {
-            fn _tokenize(
-                &self,
-            ) -> <querySwapExactInHookCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientEth {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for querySwapExactInHookCall {
-            type Parameters<'a> = (IBatchRouter::SwapExactInHookParams,);
-            type Return = querySwapExactInHookReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for InsufficientEth {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [138u8, 18u8, 160u8, 140u8];
-            const SIGNATURE: &'static str = "querySwapExactInHook((address,(address,(address,\
-                                             address,bool)[],uint256,uint256)[],uint256,bool,\
-                                             bytes))";
+            const SELECTOR: [u8; 4] = [160u8, 26u8, 157u8, 246u8];
+            const SIGNATURE: &'static str = "InsufficientEth()";
 
             #[inline]
             fn new<'a>(
@@ -5615,66 +723,26 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                querySwapExactInHookReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `querySwapExactOut((address,(address,address,bool)[],uint256,uint256)[],address,bytes)` and selector `0x2950286e`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `ReentrancyGuardReentrantCall()` and selector `0x3ee5aeb5`.
     ```solidity
-    function querySwapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, address sender, bytes memory userData) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    error ReentrancyGuardReentrantCall();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct querySwapExactOutCall {
-        #[allow(missing_docs)]
-        pub paths: alloy_sol_types::private::Vec<
-            <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`querySwapExactOut((address,(address,address,bool)[],uint256,
-    /// uint256)[],address,bytes)`](querySwapExactOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct querySwapExactOutReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
+    pub struct ReentrancyGuardReentrantCall;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5683,128 +751,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactOutCall) -> Self {
-                    (value.paths, value.sender, value.userData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paths: tuple.0,
-                        sender: tuple.1,
-                        userData: tuple.2,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactOutReturn) -> Self {
-                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsIn: tuple.0,
-                        tokensIn: tuple.1,
-                        amountsIn: tuple.2,
-                    }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReentrancyGuardReentrantCall> for UnderlyingRustTuple<'_> {
+            fn from(value: ReentrancyGuardReentrantCall) -> Self {
+                ()
             }
         }
-        impl querySwapExactOutReturn {
-            fn _tokenize(
-                &self,
-            ) -> <querySwapExactOutCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReentrancyGuardReentrantCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for querySwapExactOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = querySwapExactOutReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [41u8, 80u8, 40u8, 110u8];
-            const SIGNATURE: &'static str = "querySwapExactOut((address,(address,address,bool)[],\
-                                             uint256,uint256)[],address,bytes)";
+            const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
+            const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
 
             #[inline]
             fn new<'a>(
@@ -5815,182 +796,80 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        IBatchRouter::SwapPathExactAmountOut,
-                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                querySwapExactOutReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `querySwapExactOutHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x5a3c3987`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SafeCastOverflowedUintDowncast(uint8,uint256)` and selector `0x6dfcc650`.
     ```solidity
-    function querySwapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct querySwapExactOutHookCall {
-        #[allow(missing_docs)]
-        pub params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`querySwapExactOutHook((address,(address,(address,address,bool)[],
-    /// uint256,uint256)[],uint256,bool,bytes))`](querySwapExactOutHookCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct querySwapExactOutHookReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+    pub struct SafeCastOverflowedUintDowncast {
         #[allow(missing_docs)]
-        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub bits: u8,
         #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
         non_snake_case,
         clippy::pub_underscore_fields,
         clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactOutHookParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactOutHookCall> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactOutHookCall) -> Self {
-                    (value.params,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutHookCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { params: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<querySwapExactOutHookReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: querySwapExactOutHookReturn) -> Self {
-                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
-                }
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Uint<8>,
+            alloy_sol_types::sol_data::Uint<256>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (u8, alloy_sol_types::private::primitives::aliases::U256);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for querySwapExactOutHookReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsIn: tuple.0,
-                        tokensIn: tuple.1,
-                        amountsIn: tuple.2,
-                    }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SafeCastOverflowedUintDowncast> for UnderlyingRustTuple<'_> {
+            fn from(value: SafeCastOverflowedUintDowncast) -> Self {
+                (value.bits, value.value)
             }
         }
-        impl querySwapExactOutHookReturn {
-            fn _tokenize(
-                &self,
-            ) -> <querySwapExactOutHookCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeCastOverflowedUintDowncast {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    bits: tuple.0,
+                    value: tuple.1,
+                }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for querySwapExactOutHookCall {
-            type Parameters<'a> = (IBatchRouter::SwapExactOutHookParams,);
-            type Return = querySwapExactOutHookReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for SafeCastOverflowedUintDowncast {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [90u8, 60u8, 57u8, 135u8];
-            const SIGNATURE: &'static str = "querySwapExactOutHook((address,(address,(address,\
-                                             address,bool)[],uint256,uint256)[],uint256,bool,\
-                                             bytes))";
+            const SELECTOR: [u8; 4] = [109u8, 252u8, 198u8, 80u8];
+            const SIGNATURE: &'static str = "SafeCastOverflowedUintDowncast(uint8,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -6002,66 +881,34 @@ pub mod BalancerV3BatchRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self.bits,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                querySwapExactOutHookReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `swapExactIn((address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes)` and selector `0x286f580d`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SafeERC20FailedOperation(address)` and selector `0x5274afe7`.
     ```solidity
-    function swapExactIn(IBatchRouter.SwapPathExactAmountIn[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    error SafeERC20FailedOperation(address token);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactInCall {
-        #[allow(missing_docs)]
-        pub paths: alloy_sol_types::private::Vec<
-            <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub wethIsEth: bool,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactIn((address,(address,address,bool)[],uint256,uint256)[],
-    /// uint256,bool,bytes)`](swapExactInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactInReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    pub struct SafeERC20FailedOperation {
         #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub token: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -6071,130 +918,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactInCall) -> Self {
-                    (value.paths, value.deadline, value.wethIsEth, value.userData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paths: tuple.0,
-                        deadline: tuple.1,
-                        wethIsEth: tuple.2,
-                        userData: tuple.3,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactInReturn) -> Self {
-                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsOut: tuple.0,
-                        tokensOut: tuple.1,
-                        amountsOut: tuple.2,
-                    }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SafeERC20FailedOperation> for UnderlyingRustTuple<'_> {
+            fn from(value: SafeERC20FailedOperation) -> Self {
+                (value.token,)
             }
         }
-        impl swapExactInReturn {
-            fn _tokenize(&self) -> <swapExactInCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeERC20FailedOperation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { token: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountIn>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = swapExactInReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for SafeERC20FailedOperation {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [40u8, 111u8, 88u8, 13u8];
-            const SIGNATURE: &'static str = "swapExactIn((address,(address,address,bool)[],\
-                                             uint256,uint256)[],uint256,bool,bytes)";
+            const SELECTOR: [u8; 4] = [82u8, 116u8, 175u8, 231u8];
+            const SIGNATURE: &'static str = "SafeERC20FailedOperation(address)";
 
             #[inline]
             fn new<'a>(
@@ -6206,67 +964,31 @@ pub mod BalancerV3BatchRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Array<
-                        IBatchRouter::SwapPathExactAmountIn,
-                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.wethIsEth,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactInReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `swapExactInHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x08a465f6`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SenderIsNotVault(address)` and selector `0x089676d5`.
     ```solidity
-    function swapExactInHook(IBatchRouter.SwapExactInHookParams memory params) external returns (uint256[] memory pathAmountsOut, address[] memory tokensOut, uint256[] memory amountsOut);
+    error SenderIsNotVault(address sender);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactInHookCall {
-        #[allow(missing_docs)]
-        pub params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactInHook((address,(address,(address,address,bool)[],uint256,
-    /// uint256)[],uint256,bool,bytes))`](swapExactInHookCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactInHookReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensOut: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    pub struct SenderIsNotVault {
         #[allow(missing_docs)]
-        pub amountsOut:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub sender: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -6276,111 +998,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactInHookParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactInHookCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactInHookCall) -> Self {
-                    (value.params,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInHookCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { params: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactInHookReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactInHookReturn) -> Self {
-                    (value.pathAmountsOut, value.tokensOut, value.amountsOut)
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactInHookReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsOut: tuple.0,
-                        tokensOut: tuple.1,
-                        amountsOut: tuple.2,
-                    }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SenderIsNotVault> for UnderlyingRustTuple<'_> {
+            fn from(value: SenderIsNotVault) -> Self {
+                (value.sender,)
             }
         }
-        impl swapExactInHookReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactInHookCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsOut),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SenderIsNotVault {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { sender: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactInHookCall {
-            type Parameters<'a> = (IBatchRouter::SwapExactInHookParams,);
-            type Return = swapExactInHookReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for SenderIsNotVault {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [8u8, 164u8, 101u8, 246u8];
-            const SIGNATURE: &'static str = "swapExactInHook((address,(address,(address,address,\
-                                             bool)[],uint256,uint256)[],uint256,bool,bytes))";
+            const SELECTOR: [u8; 4] = [8u8, 150u8, 118u8, 213u8];
+            const SIGNATURE: &'static str = "SenderIsNotVault(address)";
 
             #[inline]
             fn new<'a>(
@@ -6392,67 +1044,29 @@ pub mod BalancerV3BatchRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactInHookReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `swapExactOut((address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes)` and selector `0x8eb1b65e`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SwapDeadline()` and selector `0xe08b8af0`.
     ```solidity
-    function swapExactOut(IBatchRouter.SwapPathExactAmountOut[] memory paths, uint256 deadline, bool wethIsEth, bytes memory userData) external payable returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    error SwapDeadline();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactOutCall {
-        #[allow(missing_docs)]
-        pub paths: alloy_sol_types::private::Vec<
-            <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub wethIsEth: bool,
-        #[allow(missing_docs)]
-        pub userData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactOut((address,(address,address,bool)[],uint256,uint256)[],
-    /// uint256,bool,bytes)`](swapExactOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactOutReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
+    pub struct SwapDeadline;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6461,130 +1075,41 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactOutCall) -> Self {
-                    (value.paths, value.deadline, value.wethIsEth, value.userData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        paths: tuple.0,
-                        deadline: tuple.1,
-                        wethIsEth: tuple.2,
-                        userData: tuple.3,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactOutReturn) -> Self {
-                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        pathAmountsIn: tuple.0,
-                        tokensIn: tuple.1,
-                        amountsIn: tuple.2,
-                    }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SwapDeadline> for UnderlyingRustTuple<'_> {
+            fn from(value: SwapDeadline) -> Self {
+                ()
             }
         }
-        impl swapExactOutReturn {
-            fn _tokenize(&self) -> <swapExactOutCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SwapDeadline {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<IBatchRouter::SwapPathExactAmountOut>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = swapExactOutReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
+        impl alloy_sol_types::SolError for SwapDeadline {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [142u8, 177u8, 182u8, 94u8];
-            const SIGNATURE: &'static str = "swapExactOut((address,(address,address,bool)[],\
-                                             uint256,uint256)[],uint256,bool,bytes)";
+            const SELECTOR: [u8; 4] = [224u8, 139u8, 138u8, 240u8];
+            const SIGNATURE: &'static str = "SwapDeadline()";
 
             #[inline]
             fn new<'a>(
@@ -6595,69 +1120,26 @@ pub mod BalancerV3BatchRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        IBatchRouter::SwapPathExactAmountOut,
-                    > as alloy_sol_types::SolType>::tokenize(&self.paths),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.wethIsEth,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.userData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactOutReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `swapExactOutHook((address,(address,(address,address,bool)[],uint256,uint256)[],uint256,bool,bytes))` and selector `0x945ed33f`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `TransientIndexOutOfBounds()` and selector `0x0f4ae0e4`.
     ```solidity
-    function swapExactOutHook(IBatchRouter.SwapExactOutHookParams memory params) external returns (uint256[] memory pathAmountsIn, address[] memory tokensIn, uint256[] memory amountsIn);
+    error TransientIndexOutOfBounds();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactOutHookCall {
-        #[allow(missing_docs)]
-        pub params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactOutHook((address,(address,(address,address,bool)[],uint256,
-    /// uint256)[],uint256,bool,bytes))`](swapExactOutHookCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactOutHookReturn {
-        #[allow(missing_docs)]
-        pub pathAmountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub tokensIn: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub amountsIn:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
+    pub struct TransientIndexOutOfBounds;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6666,50 +1148,96 @@ pub mod BalancerV3BatchRouter {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IBatchRouter::SwapExactOutHookParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactOutHookCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactOutHookCall) -> Self {
-                    (value.params,)
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<TransientIndexOutOfBounds> for UnderlyingRustTuple<'_> {
+            fn from(value: TransientIndexOutOfBounds) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutHookCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { params: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TransientIndexOutOfBounds {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for TransientIndexOutOfBounds {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [15u8, 74u8, 224u8, 228u8];
+            const SIGNATURE: &'static str = "TransientIndexOutOfBounds()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
             }
         }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address vault, address weth, address permit2, string routerVersion);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub vault: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub weth: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub permit2: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub routerVersion: alloy_sol_types::private::String,
+    }
+    const _: () = {
+        use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::String,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -6722,56 +1250,34 @@ pub mod BalancerV3BatchRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactOutHookReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactOutHookReturn) -> Self {
-                    (value.pathAmountsIn, value.tokensIn, value.amountsIn)
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.vault, value.weth, value.permit2, value.routerVersion)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactOutHookReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        pathAmountsIn: tuple.0,
-                        tokensIn: tuple.1,
-                        amountsIn: tuple.2,
+                        vault: tuple.0,
+                        weth: tuple.1,
+                        permit2: tuple.2,
+                        routerVersion: tuple.3,
                     }
                 }
             }
         }
-        impl swapExactOutHookReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactOutHookCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pathAmountsIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokensIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountsIn),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactOutHookCall {
-            type Parameters<'a> = (IBatchRouter::SwapExactOutHookParams,);
-            type Return = swapExactOutHookReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::String,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [148u8, 94u8, 211u8, 63u8];
-            const SIGNATURE: &'static str = "swapExactOutHook((address,(address,(address,address,\
-                                             bool)[],uint256,uint256)[],uint256,bool,bytes))";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -6782,30 +1288,20 @@ pub mod BalancerV3BatchRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.vault,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.weth,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.permit2,
+                    ),
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.routerVersion,
                     ),
                 )
             }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactOutHookReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
@@ -6946,28 +1442,6 @@ pub mod BalancerV3BatchRouter {
     ///Container for all the [`BalancerV3BatchRouter`](self) function calls.
     #[derive(Clone)]
     pub enum BalancerV3BatchRouterCalls {
-        #[allow(missing_docs)]
-        getSender(getSenderCall),
-        #[allow(missing_docs)]
-        multicall(multicallCall),
-        #[allow(missing_docs)]
-        permitBatchAndCall(permitBatchAndCallCall),
-        #[allow(missing_docs)]
-        querySwapExactIn(querySwapExactInCall),
-        #[allow(missing_docs)]
-        querySwapExactInHook(querySwapExactInHookCall),
-        #[allow(missing_docs)]
-        querySwapExactOut(querySwapExactOutCall),
-        #[allow(missing_docs)]
-        querySwapExactOutHook(querySwapExactOutHookCall),
-        #[allow(missing_docs)]
-        swapExactIn(swapExactInCall),
-        #[allow(missing_docs)]
-        swapExactInHook(swapExactInHookCall),
-        #[allow(missing_docs)]
-        swapExactOut(swapExactOutCall),
-        #[allow(missing_docs)]
-        swapExactOutHook(swapExactOutHookCall),
         #[allow(missing_docs)]
         version(versionCall),
     }
@@ -6979,50 +1453,12 @@ pub mod BalancerV3BatchRouter {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [8u8, 164u8, 101u8, 246u8],
-            [25u8, 198u8, 152u8, 159u8],
-            [40u8, 111u8, 88u8, 13u8],
-            [41u8, 80u8, 40u8, 110u8],
-            [84u8, 253u8, 77u8, 80u8],
-            [90u8, 60u8, 57u8, 135u8],
-            [94u8, 1u8, 235u8, 90u8],
-            [138u8, 18u8, 160u8, 140u8],
-            [142u8, 177u8, 182u8, 94u8],
-            [148u8, 94u8, 211u8, 63u8],
-            [172u8, 150u8, 80u8, 216u8],
-            [227u8, 181u8, 223u8, 244u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[84u8, 253u8, 77u8, 80u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <swapExactInHookCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <permitBatchAndCallCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <querySwapExactOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <versionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <querySwapExactOutHookCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getSenderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <querySwapExactInHookCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactOutHookCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multicallCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <querySwapExactInCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<versionCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(swapExactInHook),
-            ::core::stringify!(permitBatchAndCall),
-            ::core::stringify!(swapExactIn),
-            ::core::stringify!(querySwapExactOut),
-            ::core::stringify!(version),
-            ::core::stringify!(querySwapExactOutHook),
-            ::core::stringify!(getSender),
-            ::core::stringify!(querySwapExactInHook),
-            ::core::stringify!(swapExactOut),
-            ::core::stringify!(swapExactOutHook),
-            ::core::stringify!(multicall),
-            ::core::stringify!(querySwapExactIn),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(version)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -7046,38 +1482,13 @@ pub mod BalancerV3BatchRouter {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for BalancerV3BatchRouterCalls {
-        const COUNT: usize = 12usize;
+        const COUNT: usize = 1usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "BalancerV3BatchRouterCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::getSender(_) => <getSenderCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::multicall(_) => <multicallCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::permitBatchAndCall(_) => {
-                    <permitBatchAndCallCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::querySwapExactIn(_) => {
-                    <querySwapExactInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::querySwapExactInHook(_) => {
-                    <querySwapExactInHookCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::querySwapExactOut(_) => {
-                    <querySwapExactOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::querySwapExactOutHook(_) => {
-                    <querySwapExactOutHookCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactIn(_) => <swapExactInCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::swapExactInHook(_) => {
-                    <swapExactInHookCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactOut(_) => <swapExactOutCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::swapExactOutHook(_) => {
-                    <swapExactOutHookCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -7098,116 +1509,13 @@ pub mod BalancerV3BatchRouter {
             static DECODE_SHIMS: &[fn(
                 &[u8],
             )
-                -> alloy_sol_types::Result<BalancerV3BatchRouterCalls>] = &[
-                {
-                    fn swapExactInHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::swapExactInHook)
-                    }
-                    swapExactInHook
-                },
-                {
-                    fn permitBatchAndCall(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::permitBatchAndCall)
-                    }
-                    permitBatchAndCall
-                },
-                {
-                    fn swapExactIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::swapExactIn)
-                    }
-                    swapExactIn
-                },
-                {
-                    fn querySwapExactOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::querySwapExactOut)
-                    }
-                    querySwapExactOut
-                },
-                {
-                    fn version(data: &[u8]) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::version)
-                    }
-                    version
-                },
-                {
-                    fn querySwapExactOutHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BalancerV3BatchRouterCalls::querySwapExactOutHook)
-                    }
-                    querySwapExactOutHook
-                },
-                {
-                    fn getSender(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <getSenderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::getSender)
-                    }
-                    getSender
-                },
-                {
-                    fn querySwapExactInHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::querySwapExactInHook)
-                    }
-                    querySwapExactInHook
-                },
-                {
-                    fn swapExactOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::swapExactOut)
-                    }
-                    swapExactOut
-                },
-                {
-                    fn swapExactOutHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::swapExactOutHook)
-                    }
-                    swapExactOutHook
-                },
-                {
-                    fn multicall(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <multicallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::multicall)
-                    }
-                    multicall
-                },
-                {
-                    fn querySwapExactIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BalancerV3BatchRouterCalls::querySwapExactIn)
-                    }
-                    querySwapExactIn
-                },
-            ];
+                -> alloy_sol_types::Result<BalancerV3BatchRouterCalls>] = &[{
+                fn version(data: &[u8]) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                    <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(BalancerV3BatchRouterCalls::version)
+                }
+                version
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -7227,130 +1535,13 @@ pub mod BalancerV3BatchRouter {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 BalancerV3BatchRouterCalls,
-            >] = &[
-                {
-                    fn swapExactInHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV3BatchRouterCalls::swapExactInHook)
-                    }
-                    swapExactInHook
-                },
-                {
-                    fn permitBatchAndCall(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV3BatchRouterCalls::permitBatchAndCall)
-                    }
-                    permitBatchAndCall
-                },
-                {
-                    fn swapExactIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV3BatchRouterCalls::swapExactIn)
-                    }
-                    swapExactIn
-                },
-                {
-                    fn querySwapExactOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV3BatchRouterCalls::querySwapExactOut)
-                    }
-                    querySwapExactOut
-                },
-                {
-                    fn version(data: &[u8]) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV3BatchRouterCalls::version)
-                    }
-                    version
-                },
-                {
-                    fn querySwapExactOutHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV3BatchRouterCalls::querySwapExactOutHook)
-                    }
-                    querySwapExactOutHook
-                },
-                {
-                    fn getSender(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <getSenderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV3BatchRouterCalls::getSender)
-                    }
-                    getSender
-                },
-                {
-                    fn querySwapExactInHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BalancerV3BatchRouterCalls::querySwapExactInHook)
-                    }
-                    querySwapExactInHook
-                },
-                {
-                    fn swapExactOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV3BatchRouterCalls::swapExactOut)
-                    }
-                    swapExactOut
-                },
-                {
-                    fn swapExactOutHook(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV3BatchRouterCalls::swapExactOutHook)
-                    }
-                    swapExactOutHook
-                },
-                {
-                    fn multicall(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <multicallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BalancerV3BatchRouterCalls::multicall)
-                    }
-                    multicall
-                },
-                {
-                    fn querySwapExactIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
-                        <querySwapExactInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BalancerV3BatchRouterCalls::querySwapExactIn)
-                    }
-                    querySwapExactIn
-                },
-            ];
+            >] = &[{
+                fn version(data: &[u8]) -> alloy_sol_types::Result<BalancerV3BatchRouterCalls> {
+                    <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(BalancerV3BatchRouterCalls::version)
+                }
+                version
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -7363,39 +1554,6 @@ pub mod BalancerV3BatchRouter {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::getSender(inner) => {
-                    <getSenderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::multicall(inner) => {
-                    <multicallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::permitBatchAndCall(inner) => {
-                    <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::querySwapExactIn(inner) => {
-                    <querySwapExactInCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::querySwapExactInHook(inner) => {
-                    <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::querySwapExactOut(inner) => {
-                    <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::querySwapExactOutHook(inner) => {
-                    <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::swapExactIn(inner) => {
-                    <swapExactInCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::swapExactInHook(inner) => {
-                    <swapExactInHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::swapExactOut(inner) => {
-                    <swapExactOutCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::swapExactOutHook(inner) => {
-                    <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -7405,43 +1563,6 @@ pub mod BalancerV3BatchRouter {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::getSender(inner) => {
-                    <getSenderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::multicall(inner) => {
-                    <multicallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::permitBatchAndCall(inner) => {
-                    <permitBatchAndCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::querySwapExactIn(inner) => {
-                    <querySwapExactInCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::querySwapExactInHook(inner) => {
-                    <querySwapExactInHookCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::querySwapExactOut(inner) => {
-                    <querySwapExactOutCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::querySwapExactOutHook(inner) => {
-                    <querySwapExactOutHookCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::swapExactIn(inner) => {
-                    <swapExactInCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::swapExactInHook(inner) => {
-                    <swapExactInHookCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::swapExactOut(inner) => {
-                    <swapExactOutCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::swapExactOutHook(inner) => {
-                    <swapExactOutHookCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::version(inner) => {
                     <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -8232,141 +2353,6 @@ pub mod BalancerV3BatchRouter {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`getSender`] function.
-        pub fn getSender(&self) -> alloy_contract::SolCallBuilder<&P, getSenderCall, N> {
-            self.call_builder(&getSenderCall)
-        }
-
-        ///Creates a new call builder for the [`multicall`] function.
-        pub fn multicall(
-            &self,
-            data: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        ) -> alloy_contract::SolCallBuilder<&P, multicallCall, N> {
-            self.call_builder(&multicallCall { data })
-        }
-
-        ///Creates a new call builder for the [`permitBatchAndCall`] function.
-        pub fn permitBatchAndCall(
-            &self,
-            permitBatch: alloy_sol_types::private::Vec<
-                <IRouterCommon::PermitApproval as alloy_sol_types::SolType>::RustType,
-            >,
-            permitSignatures: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-            permit2Batch: <IAllowanceTransfer::PermitBatch as alloy_sol_types::SolType>::RustType,
-            permit2Signature: alloy_sol_types::private::Bytes,
-            multicallData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        ) -> alloy_contract::SolCallBuilder<&P, permitBatchAndCallCall, N> {
-            self.call_builder(&permitBatchAndCallCall {
-                permitBatch,
-                permitSignatures,
-                permit2Batch,
-                permit2Signature,
-                multicallData,
-            })
-        }
-
-        ///Creates a new call builder for the [`querySwapExactIn`] function.
-        pub fn querySwapExactIn(
-            &self,
-            paths: alloy_sol_types::private::Vec<
-                <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-            >,
-            sender: alloy_sol_types::private::Address,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactInCall, N> {
-            self.call_builder(&querySwapExactInCall {
-                paths,
-                sender,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`querySwapExactInHook`]
-        /// function.
-        pub fn querySwapExactInHook(
-            &self,
-            params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactInHookCall, N> {
-            self.call_builder(&querySwapExactInHookCall { params })
-        }
-
-        ///Creates a new call builder for the [`querySwapExactOut`] function.
-        pub fn querySwapExactOut(
-            &self,
-            paths: alloy_sol_types::private::Vec<
-                <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-            >,
-            sender: alloy_sol_types::private::Address,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactOutCall, N> {
-            self.call_builder(&querySwapExactOutCall {
-                paths,
-                sender,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`querySwapExactOutHook`]
-        /// function.
-        pub fn querySwapExactOutHook(
-            &self,
-            params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, querySwapExactOutHookCall, N> {
-            self.call_builder(&querySwapExactOutHookCall { params })
-        }
-
-        ///Creates a new call builder for the [`swapExactIn`] function.
-        pub fn swapExactIn(
-            &self,
-            paths: alloy_sol_types::private::Vec<
-                <IBatchRouter::SwapPathExactAmountIn as alloy_sol_types::SolType>::RustType,
-            >,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            wethIsEth: bool,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactInCall, N> {
-            self.call_builder(&swapExactInCall {
-                paths,
-                deadline,
-                wethIsEth,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactInHook`] function.
-        pub fn swapExactInHook(
-            &self,
-            params: <IBatchRouter::SwapExactInHookParams as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactInHookCall, N> {
-            self.call_builder(&swapExactInHookCall { params })
-        }
-
-        ///Creates a new call builder for the [`swapExactOut`] function.
-        pub fn swapExactOut(
-            &self,
-            paths: alloy_sol_types::private::Vec<
-                <IBatchRouter::SwapPathExactAmountOut as alloy_sol_types::SolType>::RustType,
-            >,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            wethIsEth: bool,
-            userData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactOutCall, N> {
-            self.call_builder(&swapExactOutCall {
-                paths,
-                deadline,
-                wethIsEth,
-                userData,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactOutHook`] function.
-        pub fn swapExactOutHook(
-            &self,
-            params: <IBatchRouter::SwapExactOutHookParams as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactOutHookCall, N> {
-            self.call_builder(&swapExactOutHookCall { params })
-        }
-
         ///Creates a new call builder for the [`version`] function.
         pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
             self.call_builder(&versionCall)
diff --git a/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs b/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs
index 31d4431ca1..6e40aa5724 100644
--- a/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/baoswaprouter/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface BaoswapRouter {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -118,60 +99,6 @@ interface BaoswapRouter {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
   {
     "type": "function",
     "name": "factory",
@@ -185,112 +112,6 @@ interface BaoswapRouter {
     ],
     "stateMutability": "pure"
   },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "quote",
@@ -322,130 +143,22 @@ interface BaoswapRouter {
   },
   {
     "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "name": "swapTokensForExactTokens",
     "inputs": [
       {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
+        "name": "amountOut",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountTokenMin",
+        "name": "amountInMax",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
       },
       {
         "name": "to",
@@ -460,4237 +173,40 @@ interface BaoswapRouter {
     ],
     "outputs": [
       {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod BaoswapRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod BaoswapRouter {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct WETHCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
+    pub struct WETHReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -4703,21 +219,9 @@ pub mod BaoswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4729,40 +233,25 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4774,38 +263,29 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -4816,38 +296,20 @@ pub mod BaoswapRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
+                        let r: WETHReturn = r.into();
+                        r._0
                     },
                 )
             }
@@ -4858,229 +320,32 @@ pub mod BaoswapRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
-    ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod BaoswapRouter {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod BaoswapRouter {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod BaoswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod BaoswapRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod BaoswapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod BaoswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5435,34 +683,22 @@ pub mod BaoswapRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod BaoswapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod BaoswapRouter {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod BaoswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod BaoswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod BaoswapRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod BaoswapRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod BaoswapRouter {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl BaoswapRouterCalls {
@@ -5949,84 +1110,27 @@ pub mod BaoswapRouter {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6046,225 +1150,42 @@ pub mod BaoswapRouter {
         #[inline]
         pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
             let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for BaoswapRouterCalls {
-        const COUNT: usize = 24usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "BaoswapRouterCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactTokens(_) => {
-                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for BaoswapRouterCalls {
+        const COUNT: usize = 5usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "BaoswapRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls>] = &[
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6290,39 +1211,6 @@ pub mod BaoswapRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6330,24 +1218,6 @@ pub mod BaoswapRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6355,24 +1225,6 @@ pub mod BaoswapRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(BaoswapRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6393,136 +1245,6 @@ pub mod BaoswapRouter {
                 &[u8],
             )
                 -> alloy_sol_types::Result<BaoswapRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(BaoswapRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6548,41 +1270,6 @@ pub mod BaoswapRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                BaoswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6590,26 +1277,6 @@ pub mod BaoswapRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6619,26 +1286,6 @@ pub mod BaoswapRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(BaoswapRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<BaoswapRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(BaoswapRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6653,115 +1300,16 @@ pub mod BaoswapRouter {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6778,137 +1326,17 @@ pub mod BaoswapRouter {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7052,77 +1480,11 @@ pub mod BaoswapRouter {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7137,327 +1499,6 @@ pub mod BaoswapRouter {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs b/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs
index 086d7b80c5..525e28a420 100644
--- a/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs
+++ b/contracts/generated/contracts-generated/chainalysisoracle/src/lib.rs
@@ -19,14 +19,9 @@ interface ChainalysisOracle {
 
     constructor();
 
-    function addToSanctionsList(address[] memory newSanctions) external;
     function isSanctioned(address addr) external view returns (bool);
-    function isSanctionedVerbose(address addr) external returns (bool);
     function name() external pure returns (string memory);
     function owner() external view returns (address);
-    function removeFromSanctionsList(address[] memory removeSanctions) external;
-    function renounceOwnership() external;
-    function transferOwnership(address newOwner) external;
 }
 ```
 
@@ -38,19 +33,6 @@ interface ChainalysisOracle {
     "inputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "addToSanctionsList",
-    "inputs": [
-      {
-        "name": "newSanctions",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "isSanctioned",
@@ -70,25 +52,6 @@ interface ChainalysisOracle {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "isSanctionedVerbose",
-    "inputs": [
-      {
-        "name": "addr",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "name",
@@ -115,39 +78,6 @@ interface ChainalysisOracle {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "removeFromSanctionsList",
-    "inputs": [
-      {
-        "name": "removeSanctions",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "renounceOwnership",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferOwnership",
-    "inputs": [
-      {
-        "name": "newOwner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "event",
     "name": "NonSanctionedAddress",
@@ -839,149 +769,6 @@ pub mod ChainalysisOracle {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addToSanctionsList(address[])` and selector `0xb972dfcc`.
-    ```solidity
-    function addToSanctionsList(address[] memory newSanctions) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addToSanctionsListCall {
-        #[allow(missing_docs)]
-        pub newSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    ///Container type for the return parameters of the
-    /// [`addToSanctionsList(address[])`](addToSanctionsListCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addToSanctionsListReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addToSanctionsListCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addToSanctionsListCall) -> Self {
-                    (value.newSanctions,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addToSanctionsListCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        newSanctions: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addToSanctionsListReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addToSanctionsListReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addToSanctionsListReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl addToSanctionsListReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addToSanctionsListCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addToSanctionsListCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            type Return = addToSanctionsListReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [185u8, 114u8, 223u8, 204u8];
-            const SIGNATURE: &'static str = "addToSanctionsList(address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.newSanctions
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addToSanctionsListReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `isSanctioned(address)` and selector `0xdf592f7d`.
     ```solidity
     function isSanctioned(address addr) external view returns (bool);
@@ -1124,24 +911,21 @@ pub mod ChainalysisOracle {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isSanctionedVerbose(address)` and selector `0xa2a6bbd8`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function isSanctionedVerbose(address addr) external returns (bool);
+    function name() external pure returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isSanctionedVerboseCall {
-        #[allow(missing_docs)]
-        pub addr: alloy_sol_types::private::Address,
-    }
+    pub struct nameCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isSanctionedVerbose(address)`](isSanctionedVerboseCall) function.
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isSanctionedVerboseReturn {
+    pub struct nameReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -1154,9 +938,9 @@ pub mod ChainalysisOracle {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1168,25 +952,25 @@ pub mod ChainalysisOracle {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<isSanctionedVerboseCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isSanctionedVerboseCall) -> Self {
-                    (value.addr,)
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSanctionedVerboseCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { addr: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1198,29 +982,29 @@ pub mod ChainalysisOracle {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<isSanctionedVerboseReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isSanctionedVerboseReturn) -> Self {
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isSanctionedVerboseReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for isSanctionedVerboseCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
+        impl alloy_sol_types::SolCall for nameCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [162u8, 166u8, 187u8, 216u8];
-            const SIGNATURE: &'static str = "isSanctionedVerbose(address)";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -1231,23 +1015,19 @@ pub mod ChainalysisOracle {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.addr,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: isSanctionedVerboseReturn = r.into();
+                        let r: nameReturn = r.into();
                         r._0
                     },
                 )
@@ -1259,28 +1039,28 @@ pub mod ChainalysisOracle {
                     data,
                 )
                 .map(|r| {
-                    let r: isSanctionedVerboseReturn = r.into();
+                    let r: nameReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
+    /**Function with signature `owner()` and selector `0x8da5cb5b`.
     ```solidity
-    function name() external pure returns (string memory);
+    function owner() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nameCall;
+    pub struct ownerCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
+    ///Container type for the return parameters of the [`owner()`](ownerCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nameReturn {
+    pub struct ownerReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -1307,14 +1087,14 @@ pub mod ChainalysisOracle {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -1323,9 +1103,9 @@ pub mod ChainalysisOracle {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1337,29 +1117,29 @@ pub mod ChainalysisOracle {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
+        impl alloy_sol_types::SolCall for ownerCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
+            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
+            const SIGNATURE: &'static str = "owner()";
 
             #[inline]
             fn new<'a>(
@@ -1375,14 +1155,14 @@ pub mod ChainalysisOracle {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: nameReturn = r.into();
+                        let r: ownerReturn = r.into();
                         r._0
                     },
                 )
@@ -1394,580 +1174,21 @@ pub mod ChainalysisOracle {
                     data,
                 )
                 .map(|r| {
-                    let r: nameReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `owner()` and selector `0x8da5cb5b`.
-    ```solidity
-    function owner() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ownerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`owner()`](ownerCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ownerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for ownerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
-            const SIGNATURE: &'static str = "owner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: ownerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: ownerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeFromSanctionsList(address[])` and selector `0xef782431`.
-    ```solidity
-    function removeFromSanctionsList(address[] memory removeSanctions) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeFromSanctionsListCall {
-        #[allow(missing_docs)]
-        pub removeSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    ///Container type for the return parameters of the
-    /// [`removeFromSanctionsList(address[])`](removeFromSanctionsListCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeFromSanctionsListReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeFromSanctionsListCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeFromSanctionsListCall) -> Self {
-                    (value.removeSanctions,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeFromSanctionsListCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        removeSanctions: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeFromSanctionsListReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeFromSanctionsListReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeFromSanctionsListReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl removeFromSanctionsListReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeFromSanctionsListCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeFromSanctionsListCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            type Return = removeFromSanctionsListReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [239u8, 120u8, 36u8, 49u8];
-            const SIGNATURE: &'static str = "removeFromSanctionsList(address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.removeSanctions,
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeFromSanctionsListReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
-    ```solidity
-    function renounceOwnership() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct renounceOwnershipCall;
-    ///Container type for the return parameters of the
-    /// [`renounceOwnership()`](renounceOwnershipCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct renounceOwnershipReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
-                fn from(value: renounceOwnershipCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: renounceOwnershipReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl renounceOwnershipReturn {
-            fn _tokenize(
-                &self,
-            ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for renounceOwnershipCall {
-            type Parameters<'a> = ();
-            type Return = renounceOwnershipReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
-            const SIGNATURE: &'static str = "renounceOwnership()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                renounceOwnershipReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
-    ```solidity
-    function transferOwnership(address newOwner) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferOwnershipCall {
-        #[allow(missing_docs)]
-        pub newOwner: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`transferOwnership(address)`](transferOwnershipCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferOwnershipReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferOwnershipCall) -> Self {
-                    (value.newOwner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { newOwner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferOwnershipReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl transferOwnershipReturn {
-            fn _tokenize(
-                &self,
-            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferOwnershipCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = transferOwnershipReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
-            const SIGNATURE: &'static str = "transferOwnership(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newOwner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                transferOwnershipReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+                    let r: ownerReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     ///Container for all the [`ChainalysisOracle`](self) function calls.
     #[derive(Clone)]
     pub enum ChainalysisOracleCalls {
-        #[allow(missing_docs)]
-        addToSanctionsList(addToSanctionsListCall),
         #[allow(missing_docs)]
         isSanctioned(isSanctionedCall),
         #[allow(missing_docs)]
-        isSanctionedVerbose(isSanctionedVerboseCall),
-        #[allow(missing_docs)]
         name(nameCall),
         #[allow(missing_docs)]
         owner(ownerCall),
-        #[allow(missing_docs)]
-        removeFromSanctionsList(removeFromSanctionsListCall),
-        #[allow(missing_docs)]
-        renounceOwnership(renounceOwnershipCall),
-        #[allow(missing_docs)]
-        transferOwnership(transferOwnershipCall),
     }
     impl ChainalysisOracleCalls {
         /// All the selectors of this enum.
@@ -1979,35 +1200,20 @@ pub mod ChainalysisOracle {
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
-            [113u8, 80u8, 24u8, 166u8],
             [141u8, 165u8, 203u8, 91u8],
-            [162u8, 166u8, 187u8, 216u8],
-            [185u8, 114u8, 223u8, 204u8],
             [223u8, 89u8, 47u8, 125u8],
-            [239u8, 120u8, 36u8, 49u8],
-            [242u8, 253u8, 227u8, 139u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
             <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isSanctionedVerboseCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addToSanctionsListCall as alloy_sol_types::SolCall>::SIGNATURE,
             <isSanctionedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeFromSanctionsListCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
-            ::core::stringify!(renounceOwnership),
             ::core::stringify!(owner),
-            ::core::stringify!(isSanctionedVerbose),
-            ::core::stringify!(addToSanctionsList),
             ::core::stringify!(isSanctioned),
-            ::core::stringify!(removeFromSanctionsList),
-            ::core::stringify!(transferOwnership),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -2032,31 +1238,16 @@ pub mod ChainalysisOracle {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for ChainalysisOracleCalls {
-        const COUNT: usize = 8usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "ChainalysisOracleCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::addToSanctionsList(_) => {
-                    <addToSanctionsListCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::isSanctioned(_) => <isSanctionedCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isSanctionedVerbose(_) => {
-                    <isSanctionedVerboseCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeFromSanctionsList(_) => {
-                    <removeFromSanctionsListCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::renounceOwnership(_) => {
-                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::transferOwnership(_) => {
-                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -2082,18 +1273,6 @@ pub mod ChainalysisOracle {
                         }
                         name
                     },
-                    {
-                        fn renounceOwnership(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
-                        {
-                            <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::renounceOwnership)
-                        }
-                        renounceOwnership
-                    },
                     {
                         fn owner(data: &[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
                             <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2101,30 +1280,6 @@ pub mod ChainalysisOracle {
                         }
                         owner
                     },
-                    {
-                        fn isSanctionedVerbose(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
-                        {
-                            <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::isSanctionedVerbose)
-                        }
-                        isSanctionedVerbose
-                    },
-                    {
-                        fn addToSanctionsList(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
-                        {
-                            <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::addToSanctionsList)
-                        }
-                        addToSanctionsList
-                    },
                     {
                         fn isSanctioned(
                             data: &[u8],
@@ -2135,30 +1290,6 @@ pub mod ChainalysisOracle {
                         }
                         isSanctioned
                     },
-                    {
-                        fn removeFromSanctionsList(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
-                        {
-                            <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::removeFromSanctionsList)
-                        }
-                        removeFromSanctionsList
-                    },
-                    {
-                        fn transferOwnership(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<ChainalysisOracleCalls>
-                        {
-                            <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::transferOwnership)
-                        }
-                        transferOwnership
-                    },
                 ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2187,17 +1318,6 @@ pub mod ChainalysisOracle {
                     }
                     name
                 },
-                {
-                    fn renounceOwnership(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
-                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::renounceOwnership)
-                    }
-                    renounceOwnership
-                },
                 {
                     fn owner(data: &[u8]) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
                         <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -2205,28 +1325,6 @@ pub mod ChainalysisOracle {
                     }
                     owner
                 },
-                {
-                    fn isSanctionedVerbose(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
-                        <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::isSanctionedVerbose)
-                    }
-                    isSanctionedVerbose
-                },
-                {
-                    fn addToSanctionsList(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
-                        <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::addToSanctionsList)
-                    }
-                    addToSanctionsList
-                },
                 {
                     fn isSanctioned(
                         data: &[u8],
@@ -2238,28 +1336,6 @@ pub mod ChainalysisOracle {
                     }
                     isSanctioned
                 },
-                {
-                    fn removeFromSanctionsList(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
-                        <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::removeFromSanctionsList)
-                    }
-                    removeFromSanctionsList
-                },
-                {
-                    fn transferOwnership(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ChainalysisOracleCalls> {
-                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ChainalysisOracleCalls::transferOwnership)
-                    }
-                    transferOwnership
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2273,66 +1349,30 @@ pub mod ChainalysisOracle {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::addToSanctionsList(inner) => {
-                    <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::isSanctioned(inner) => {
                     <isSanctionedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::isSanctionedVerbose(inner) => {
-                    <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::owner(inner) => {
                     <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::removeFromSanctionsList(inner) => {
-                    <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::renounceOwnership(inner) => {
-                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::transferOwnership(inner) => {
-                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::addToSanctionsList(inner) => {
-                    <addToSanctionsListCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::isSanctioned(inner) => {
                     <isSanctionedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::isSanctionedVerbose(inner) => {
-                    <isSanctionedVerboseCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::owner(inner) => {
                     <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeFromSanctionsList(inner) => {
-                    <removeFromSanctionsListCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::renounceOwnership(inner) => {
-                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::transferOwnership(inner) => {
-                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -2623,14 +1663,6 @@ pub mod ChainalysisOracle {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`addToSanctionsList`] function.
-        pub fn addToSanctionsList(
-            &self,
-            newSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, addToSanctionsListCall, N> {
-            self.call_builder(&addToSanctionsListCall { newSanctions })
-        }
-
         ///Creates a new call builder for the [`isSanctioned`] function.
         pub fn isSanctioned(
             &self,
@@ -2639,14 +1671,6 @@ pub mod ChainalysisOracle {
             self.call_builder(&isSanctionedCall { addr })
         }
 
-        ///Creates a new call builder for the [`isSanctionedVerbose`] function.
-        pub fn isSanctionedVerbose(
-            &self,
-            addr: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isSanctionedVerboseCall, N> {
-            self.call_builder(&isSanctionedVerboseCall { addr })
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -2656,30 +1680,6 @@ pub mod ChainalysisOracle {
         pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
             self.call_builder(&ownerCall)
         }
-
-        ///Creates a new call builder for the [`removeFromSanctionsList`]
-        /// function.
-        pub fn removeFromSanctionsList(
-            &self,
-            removeSanctions: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeFromSanctionsListCall, N> {
-            self.call_builder(&removeFromSanctionsListCall { removeSanctions })
-        }
-
-        ///Creates a new call builder for the [`renounceOwnership`] function.
-        pub fn renounceOwnership(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
-            self.call_builder(&renounceOwnershipCall)
-        }
-
-        ///Creates a new call builder for the [`transferOwnership`] function.
-        pub fn transferOwnership(
-            &self,
-            newOwner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
-            self.call_builder(&transferOwnershipCall { newOwner })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/cowamm/src/lib.rs b/contracts/generated/contracts-generated/cowamm/src/lib.rs
index 4b9d028c82..455d577e4b 100644
--- a/contracts/generated/contracts-generated/cowamm/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowamm/src/lib.rs
@@ -1047,23 +1047,12 @@ interface CowAmm {
 
     constructor(address _solutionSettler, address _token0, address _token1);
 
-    function COMMITMENT_SLOT() external view returns (uint256);
-    function EMPTY_COMMITMENT() external view returns (bytes32);
-    function MAX_ORDER_DURATION() external view returns (uint32);
-    function NO_TRADING() external view returns (bytes32);
     function commit(bytes32 orderHash) external;
-    function commitment() external view returns (bytes32 value);
-    function disableTrading() external;
-    function enableTrading(ConstantProduct.TradingParams memory tradingParams) external;
-    function getTradeableOrder(ConstantProduct.TradingParams memory tradingParams) external view returns (GPv2Order.Data memory order);
     function hash(ConstantProduct.TradingParams memory tradingParams) external pure returns (bytes32);
     function isValidSignature(bytes32 _hash, bytes memory signature) external view returns (bytes4);
     function manager() external view returns (address);
-    function solutionSettler() external view returns (address);
-    function solutionSettlerDomainSeparator() external view returns (bytes32);
     function token0() external view returns (address);
     function token1() external view returns (address);
-    function tradingParamsHash() external view returns (bytes32);
     function verify(ConstantProduct.TradingParams memory tradingParams, GPv2Order.Data memory order) external view;
 }
 ```
@@ -1092,58 +1081,6 @@ interface CowAmm {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "COMMITMENT_SLOT",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "EMPTY_COMMITMENT",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MAX_ORDER_DURATION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint32",
-        "internalType": "uint32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "NO_TRADING",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "commit",
@@ -1157,164 +1094,6 @@ interface CowAmm {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "commitment",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "value",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "disableTrading",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "enableTrading",
-    "inputs": [
-      {
-        "name": "tradingParams",
-        "type": "tuple",
-        "internalType": "struct ConstantProduct.TradingParams",
-        "components": [
-          {
-            "name": "minTradedToken0",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "priceOracle",
-            "type": "address",
-            "internalType": "contract IPriceOracle"
-          },
-          {
-            "name": "priceOracleData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "appData",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getTradeableOrder",
-    "inputs": [
-      {
-        "name": "tradingParams",
-        "type": "tuple",
-        "internalType": "struct ConstantProduct.TradingParams",
-        "components": [
-          {
-            "name": "minTradedToken0",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "priceOracle",
-            "type": "address",
-            "internalType": "contract IPriceOracle"
-          },
-          {
-            "name": "priceOracleData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "appData",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct GPv2Order.Data",
-        "components": [
-          {
-            "name": "sellToken",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "buyToken",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "receiver",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sellAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "buyAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "validTo",
-            "type": "uint32",
-            "internalType": "uint32"
-          },
-          {
-            "name": "appData",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "feeAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "kind",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "partiallyFillable",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "sellTokenBalance",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "buyTokenBalance",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "hash",
@@ -1393,32 +1172,6 @@ interface CowAmm {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "solutionSettler",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract ISettlement"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "solutionSettlerDomainSeparator",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "token0",
@@ -1445,19 +1198,6 @@ interface CowAmm {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "tradingParamsHash",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "verify",
@@ -2612,22 +2352,21 @@ pub mod CowAmm {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `COMMITMENT_SLOT()` and selector `0x3e706e32`.
+    /**Function with signature `commit(bytes32)` and selector `0xf14fcbc8`.
     ```solidity
-    function COMMITMENT_SLOT() external view returns (uint256);
+    function commit(bytes32 orderHash) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct COMMITMENT_SLOTCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    pub struct commitCall {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+    }
     ///Container type for the return parameters of the
-    /// [`COMMITMENT_SLOT()`](COMMITMENT_SLOTCall) function.
+    /// [`commit(bytes32)`](commitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct COMMITMENT_SLOTReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct commitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2639,9 +2378,9 @@ pub mod CowAmm {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2653,25 +2392,25 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<COMMITMENT_SLOTCall> for UnderlyingRustTuple<'_> {
-                fn from(value: COMMITMENT_SLOTCall) -> Self {
-                    ()
+            impl ::core::convert::From<commitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: commitCall) -> Self {
+                    (value.orderHash,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for COMMITMENT_SLOTCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self { orderHash: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2683,29 +2422,34 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<COMMITMENT_SLOTReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: COMMITMENT_SLOTReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<commitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: commitReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for COMMITMENT_SLOTReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl commitReturn {
+            fn _tokenize(&self) -> <commitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for COMMITMENT_SLOTCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for commitCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = commitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [62u8, 112u8, 110u8, 50u8];
-            const SIGNATURE: &'static str = "COMMITMENT_SLOT()";
+            const SELECTOR: [u8; 4] = [241u8, 79u8, 203u8, 200u8];
+            const SIGNATURE: &'static str = "commit(bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -2716,26 +2460,22 @@ pub mod CowAmm {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                commitReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: COMMITMENT_SLOTReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2743,27 +2483,27 @@ pub mod CowAmm {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: COMMITMENT_SLOTReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `EMPTY_COMMITMENT()` and selector `0xff2dbc98`.
+    /**Function with signature `hash((uint256,address,bytes,bytes32))` and selector `0xb09aaaca`.
     ```solidity
-    function EMPTY_COMMITMENT() external view returns (bytes32);
+    function hash(ConstantProduct.TradingParams memory tradingParams) external pure returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct EMPTY_COMMITMENTCall;
+    pub struct hashCall {
+        #[allow(missing_docs)]
+        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`EMPTY_COMMITMENT()`](EMPTY_COMMITMENTCall) function.
+    /// [`hash((uint256,address,bytes,bytes32))`](hashCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct EMPTY_COMMITMENTReturn {
+    pub struct hashReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
@@ -2778,9 +2518,10 @@ pub mod CowAmm {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> =
+                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2792,16 +2533,18 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<EMPTY_COMMITMENTCall> for UnderlyingRustTuple<'_> {
-                fn from(value: EMPTY_COMMITMENTCall) -> Self {
-                    ()
+            impl ::core::convert::From<hashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashCall) -> Self {
+                    (value.tradingParams,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for EMPTY_COMMITMENTCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        tradingParams: tuple.0,
+                    }
                 }
             }
         }
@@ -2822,29 +2565,29 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<EMPTY_COMMITMENTReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: EMPTY_COMMITMENTReturn) -> Self {
+            impl ::core::convert::From<hashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for EMPTY_COMMITMENTReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for EMPTY_COMMITMENTCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for hashCall {
+            type Parameters<'a> = (ConstantProduct::TradingParams,);
             type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [255u8, 45u8, 188u8, 152u8];
-            const SIGNATURE: &'static str = "EMPTY_COMMITMENT()";
+            const SELECTOR: [u8; 4] = [176u8, 154u8, 170u8, 202u8];
+            const SIGNATURE: &'static str = "hash((uint256,address,bytes,bytes32))";
 
             #[inline]
             fn new<'a>(
@@ -2855,7 +2598,11 @@ pub mod CowAmm {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
+                        &self.tradingParams,
+                    ),
+                )
             }
 
             #[inline]
@@ -2871,7 +2618,7 @@ pub mod CowAmm {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: EMPTY_COMMITMENTReturn = r.into();
+                        let r: hashReturn = r.into();
                         r._0
                     },
                 )
@@ -2883,28 +2630,33 @@ pub mod CowAmm {
                     data,
                 )
                 .map(|r| {
-                    let r: EMPTY_COMMITMENTReturn = r.into();
+                    let r: hashReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `MAX_ORDER_DURATION()` and selector `0x981a160b`.
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
     ```solidity
-    function MAX_ORDER_DURATION() external view returns (uint32);
+    function isValidSignature(bytes32 _hash, bytes memory signature) external view returns (bytes4);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MAX_ORDER_DURATIONCall;
+    pub struct isValidSignatureCall {
+        #[allow(missing_docs)]
+        pub _hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub signature: alloy_sol_types::private::Bytes,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`MAX_ORDER_DURATION()`](MAX_ORDER_DURATIONCall) function.
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MAX_ORDER_DURATIONReturn {
+    pub struct isValidSignatureReturn {
         #[allow(missing_docs)]
-        pub _0: u32,
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
     }
     #[allow(
         non_camel_case_types,
@@ -2917,9 +2669,15 @@ pub mod CowAmm {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2931,25 +2689,28 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MAX_ORDER_DURATIONCall> for UnderlyingRustTuple<'_> {
-                fn from(value: MAX_ORDER_DURATIONCall) -> Self {
-                    ()
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value._hash, value.signature)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_ORDER_DURATIONCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        _hash: tuple.0,
+                        signature: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u32,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2961,29 +2722,32 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MAX_ORDER_DURATIONReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: MAX_ORDER_DURATIONReturn) -> Self {
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_ORDER_DURATIONReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for MAX_ORDER_DURATIONCall {
-            type Parameters<'a> = ();
-            type Return = u32;
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [152u8, 26u8, 22u8, 11u8];
-            const SIGNATURE: &'static str = "MAX_ORDER_DURATION()";
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -2994,15 +2758,22 @@ pub mod CowAmm {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
                 )
             }
 
@@ -3010,7 +2781,7 @@ pub mod CowAmm {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: MAX_ORDER_DURATIONReturn = r.into();
+                        let r: isValidSignatureReturn = r.into();
                         r._0
                     },
                 )
@@ -3022,28 +2793,28 @@ pub mod CowAmm {
                     data,
                 )
                 .map(|r| {
-                    let r: MAX_ORDER_DURATIONReturn = r.into();
+                    let r: isValidSignatureReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `NO_TRADING()` and selector `0x1c7de941`.
+    /**Function with signature `manager()` and selector `0x481c6a75`.
     ```solidity
-    function NO_TRADING() external view returns (bytes32);
+    function manager() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct NO_TRADINGCall;
+    pub struct managerCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`NO_TRADING()`](NO_TRADINGCall) function.
+    /// [`manager()`](managerCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct NO_TRADINGReturn {
+    pub struct managerReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -3070,14 +2841,14 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<NO_TRADINGCall> for UnderlyingRustTuple<'_> {
-                fn from(value: NO_TRADINGCall) -> Self {
+            impl ::core::convert::From<managerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: managerCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for NO_TRADINGCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -3086,9 +2857,9 @@ pub mod CowAmm {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3100,1585 +2871,29 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<NO_TRADINGReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: NO_TRADINGReturn) -> Self {
+            impl ::core::convert::From<managerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: managerReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for NO_TRADINGReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for NO_TRADINGCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [28u8, 125u8, 233u8, 65u8];
-            const SIGNATURE: &'static str = "NO_TRADING()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: NO_TRADINGReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: NO_TRADINGReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `commit(bytes32)` and selector `0xf14fcbc8`.
-    ```solidity
-    function commit(bytes32 orderHash) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct commitCall {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    ///Container type for the return parameters of the
-    /// [`commit(bytes32)`](commitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct commitReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<commitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: commitCall) -> Self {
-                    (value.orderHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderHash: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<commitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: commitReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl commitReturn {
-            fn _tokenize(&self) -> <commitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for commitCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = commitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [241u8, 79u8, 203u8, 200u8];
-            const SIGNATURE: &'static str = "commit(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                commitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `commitment()` and selector `0x1303a484`.
-    ```solidity
-    function commitment() external view returns (bytes32 value);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct commitmentCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`commitment()`](commitmentCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct commitmentReturn {
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<commitmentCall> for UnderlyingRustTuple<'_> {
-                fn from(value: commitmentCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitmentCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<commitmentReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: commitmentReturn) -> Self {
-                    (value.value,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for commitmentReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { value: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for commitmentCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [19u8, 3u8, 164u8, 132u8];
-            const SIGNATURE: &'static str = "commitment()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: commitmentReturn = r.into();
-                        r.value
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: commitmentReturn = r.into();
-                    r.value
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `disableTrading()` and selector `0x17700f01`.
-    ```solidity
-    function disableTrading() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableTradingCall;
-    ///Container type for the return parameters of the
-    /// [`disableTrading()`](disableTradingCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableTradingReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableTradingCall> for UnderlyingRustTuple<'_> {
-                fn from(value: disableTradingCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableTradingReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: disableTradingReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl disableTradingReturn {
-            fn _tokenize(
-                &self,
-            ) -> <disableTradingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for disableTradingCall {
-            type Parameters<'a> = ();
-            type Return = disableTradingReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 112u8, 15u8, 1u8];
-            const SIGNATURE: &'static str = "disableTrading()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                disableTradingReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `enableTrading((uint256,address,bytes,bytes32))` and selector `0xc5f3d254`.
-    ```solidity
-    function enableTrading(ConstantProduct.TradingParams memory tradingParams) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableTradingCall {
-        #[allow(missing_docs)]
-        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`enableTrading((uint256,address,bytes,bytes32))`](enableTradingCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableTradingReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableTradingCall> for UnderlyingRustTuple<'_> {
-                fn from(value: enableTradingCall) -> Self {
-                    (value.tradingParams,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableTradingCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tradingParams: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableTradingReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: enableTradingReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableTradingReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl enableTradingReturn {
-            fn _tokenize(
-                &self,
-            ) -> <enableTradingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for enableTradingCall {
-            type Parameters<'a> = (ConstantProduct::TradingParams,);
-            type Return = enableTradingReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [197u8, 243u8, 210u8, 84u8];
-            const SIGNATURE: &'static str = "enableTrading((uint256,address,bytes,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
-                        &self.tradingParams,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                enableTradingReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTradeableOrder((uint256,address,bytes,bytes32))` and selector `0xe3e6f5b2`.
-    ```solidity
-    function getTradeableOrder(ConstantProduct.TradingParams memory tradingParams) external view returns (GPv2Order.Data memory order);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTradeableOrderCall {
-        #[allow(missing_docs)]
-        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getTradeableOrder((uint256,address,bytes,
-    /// bytes32))`](getTradeableOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTradeableOrderReturn {
-        #[allow(missing_docs)]
-        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTradeableOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTradeableOrderCall) -> Self {
-                    (value.tradingParams,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tradingParams: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (GPv2Order::Data,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<GPv2Order::Data as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTradeableOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTradeableOrderReturn) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTradeableOrderCall {
-            type Parameters<'a> = (ConstantProduct::TradingParams,);
-            type Return = <GPv2Order::Data as alloy_sol_types::SolType>::RustType;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (GPv2Order::Data,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [227u8, 230u8, 245u8, 178u8];
-            const SIGNATURE: &'static str = "getTradeableOrder((uint256,address,bytes,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
-                        &self.tradingParams,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<GPv2Order::Data as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getTradeableOrderReturn = r.into();
-                        r.order
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getTradeableOrderReturn = r.into();
-                    r.order
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `hash((uint256,address,bytes,bytes32))` and selector `0xb09aaaca`.
-    ```solidity
-    function hash(ConstantProduct.TradingParams memory tradingParams) external pure returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hashCall {
-        #[allow(missing_docs)]
-        pub tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hash((uint256,address,bytes,bytes32))`](hashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hashReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ConstantProduct::TradingParams,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hashCall) -> Self {
-                    (value.tradingParams,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tradingParams: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hashReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for hashCall {
-            type Parameters<'a> = (ConstantProduct::TradingParams,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [176u8, 154u8, 170u8, 202u8];
-            const SIGNATURE: &'static str = "hash((uint256,address,bytes,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ConstantProduct::TradingParams as alloy_sol_types::SolType>::tokenize(
-                        &self.tradingParams,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: hashReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: hashReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
-    ```solidity
-    function isValidSignature(bytes32 _hash, bytes memory signature) external view returns (bytes4);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignatureCall {
-        #[allow(missing_docs)]
-        pub _hash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub signature: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignatureReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignatureCall) -> Self {
-                    (value._hash, value.signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _hash: tuple.0,
-                        signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignatureReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isValidSignatureCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
-            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isValidSignatureReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isValidSignatureReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `manager()` and selector `0x481c6a75`.
-    ```solidity
-    function manager() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct managerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`manager()`](managerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct managerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<managerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: managerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<managerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: managerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for managerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for managerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [72u8, 28u8, 106u8, 117u8];
-            const SIGNATURE: &'static str = "manager()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: managerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: managerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `solutionSettler()` and selector `0xe516715b`.
-    ```solidity
-    function solutionSettler() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct solutionSettlerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`solutionSettler()`](solutionSettlerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct solutionSettlerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<solutionSettlerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: solutionSettlerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<solutionSettlerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: solutionSettlerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for solutionSettlerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [229u8, 22u8, 113u8, 91u8];
-            const SIGNATURE: &'static str = "solutionSettler()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: solutionSettlerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: solutionSettlerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `solutionSettlerDomainSeparator()` and selector `0xd25e0cb6`.
-    ```solidity
-    function solutionSettlerDomainSeparator() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct solutionSettlerDomainSeparatorCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`solutionSettlerDomainSeparator()`](solutionSettlerDomainSeparatorCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct solutionSettlerDomainSeparatorReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<solutionSettlerDomainSeparatorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: solutionSettlerDomainSeparatorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerDomainSeparatorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<solutionSettlerDomainSeparatorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: solutionSettlerDomainSeparatorReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for solutionSettlerDomainSeparatorReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for solutionSettlerDomainSeparatorCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [210u8, 94u8, 12u8, 182u8];
-            const SIGNATURE: &'static str = "solutionSettlerDomainSeparator()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: solutionSettlerDomainSeparatorReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: solutionSettlerDomainSeparatorReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `token0()` and selector `0x0dfe1681`.
-    ```solidity
-    function token0() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct token0Call;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`token0()`](token0Call)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct token0Return {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<token0Call> for UnderlyingRustTuple<'_> {
-                fn from(value: token0Call) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<token0Return> for UnderlyingRustTuple<'_> {
-                fn from(value: token0Return) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for token0Call {
+        impl alloy_sol_types::SolCall for managerCall {
             type Parameters<'a> = ();
             type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [13u8, 254u8, 22u8, 129u8];
-            const SIGNATURE: &'static str = "token0()";
+            const SELECTOR: [u8; 4] = [72u8, 28u8, 106u8, 117u8];
+            const SIGNATURE: &'static str = "manager()";
 
             #[inline]
             fn new<'a>(
@@ -4701,7 +2916,7 @@ pub mod CowAmm {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: token0Return = r.into();
+                        let r: managerReturn = r.into();
                         r._0
                     },
                 )
@@ -4713,26 +2928,26 @@ pub mod CowAmm {
                     data,
                 )
                 .map(|r| {
-                    let r: token0Return = r.into();
+                    let r: managerReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `token1()` and selector `0xd21220a7`.
+    /**Function with signature `token0()` and selector `0x0dfe1681`.
     ```solidity
-    function token1() external view returns (address);
+    function token0() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct token1Call;
+    pub struct token0Call;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`token1()`](token1Call)
+    ///Container type for the return parameters of the [`token0()`](token0Call)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct token1Return {
+    pub struct token0Return {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::Address,
     }
@@ -4761,14 +2976,14 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<token1Call> for UnderlyingRustTuple<'_> {
-                fn from(value: token1Call) -> Self {
+            impl ::core::convert::From<token0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Call) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Call {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Call {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -4791,29 +3006,29 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<token1Return> for UnderlyingRustTuple<'_> {
-                fn from(value: token1Return) -> Self {
+            impl ::core::convert::From<token0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token0Return) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Return {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token0Return {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for token1Call {
+        impl alloy_sol_types::SolCall for token0Call {
             type Parameters<'a> = ();
             type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [210u8, 18u8, 32u8, 167u8];
-            const SIGNATURE: &'static str = "token1()";
+            const SELECTOR: [u8; 4] = [13u8, 254u8, 22u8, 129u8];
+            const SIGNATURE: &'static str = "token0()";
 
             #[inline]
             fn new<'a>(
@@ -4836,7 +3051,7 @@ pub mod CowAmm {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: token1Return = r.into();
+                        let r: token0Return = r.into();
                         r._0
                     },
                 )
@@ -4848,28 +3063,28 @@ pub mod CowAmm {
                     data,
                 )
                 .map(|r| {
-                    let r: token1Return = r.into();
+                    let r: token0Return = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `tradingParamsHash()` and selector `0xeec50b97`.
+    /**Function with signature `token1()` and selector `0xd21220a7`.
     ```solidity
-    function tradingParamsHash() external view returns (bytes32);
+    function token1() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tradingParamsHashCall;
+    pub struct token1Call;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`tradingParamsHash()`](tradingParamsHashCall) function.
+    ///Container type for the return parameters of the [`token1()`](token1Call)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tradingParamsHashReturn {
+    pub struct token1Return {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -4896,14 +3111,14 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tradingParamsHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: tradingParamsHashCall) -> Self {
+            impl ::core::convert::From<token1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Call) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tradingParamsHashCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Call {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -4912,9 +3127,9 @@ pub mod CowAmm {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4926,29 +3141,29 @@ pub mod CowAmm {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tradingParamsHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: tradingParamsHashReturn) -> Self {
+            impl ::core::convert::From<token1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: token1Return) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tradingParamsHashReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for token1Return {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for tradingParamsHashCall {
+        impl alloy_sol_types::SolCall for token1Call {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [238u8, 197u8, 11u8, 151u8];
-            const SIGNATURE: &'static str = "tradingParamsHash()";
+            const SELECTOR: [u8; 4] = [210u8, 18u8, 32u8, 167u8];
+            const SIGNATURE: &'static str = "token1()";
 
             #[inline]
             fn new<'a>(
@@ -4964,18 +3179,14 @@ pub mod CowAmm {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: tradingParamsHashReturn = r.into();
+                        let r: token1Return = r.into();
                         r._0
                     },
                 )
@@ -4987,7 +3198,7 @@ pub mod CowAmm {
                     data,
                 )
                 .map(|r| {
-                    let r: tradingParamsHashReturn = r.into();
+                    let r: token1Return = r.into();
                     r._0
                 })
             }
@@ -5145,41 +3356,19 @@ pub mod CowAmm {
     ///Container for all the [`CowAmm`](self) function calls.
     #[derive(Clone)]
     pub enum CowAmmCalls {
-        #[allow(missing_docs)]
-        COMMITMENT_SLOT(COMMITMENT_SLOTCall),
-        #[allow(missing_docs)]
-        EMPTY_COMMITMENT(EMPTY_COMMITMENTCall),
-        #[allow(missing_docs)]
-        MAX_ORDER_DURATION(MAX_ORDER_DURATIONCall),
-        #[allow(missing_docs)]
-        NO_TRADING(NO_TRADINGCall),
         #[allow(missing_docs)]
         commit(commitCall),
         #[allow(missing_docs)]
-        commitment(commitmentCall),
-        #[allow(missing_docs)]
-        disableTrading(disableTradingCall),
-        #[allow(missing_docs)]
-        enableTrading(enableTradingCall),
-        #[allow(missing_docs)]
-        getTradeableOrder(getTradeableOrderCall),
-        #[allow(missing_docs)]
         hash(hashCall),
         #[allow(missing_docs)]
         isValidSignature(isValidSignatureCall),
         #[allow(missing_docs)]
         manager(managerCall),
         #[allow(missing_docs)]
-        solutionSettler(solutionSettlerCall),
-        #[allow(missing_docs)]
-        solutionSettlerDomainSeparator(solutionSettlerDomainSeparatorCall),
-        #[allow(missing_docs)]
         token0(token0Call),
         #[allow(missing_docs)]
         token1(token1Call),
         #[allow(missing_docs)]
-        tradingParamsHash(tradingParamsHashCall),
-        #[allow(missing_docs)]
         verify(verifyCall),
     }
     impl CowAmmCalls {
@@ -5192,65 +3381,32 @@ pub mod CowAmm {
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [13u8, 254u8, 22u8, 129u8],
-            [19u8, 3u8, 164u8, 132u8],
             [22u8, 38u8, 186u8, 126u8],
-            [23u8, 112u8, 15u8, 1u8],
-            [28u8, 125u8, 233u8, 65u8],
-            [62u8, 112u8, 110u8, 50u8],
             [72u8, 28u8, 106u8, 117u8],
-            [152u8, 26u8, 22u8, 11u8],
             [160u8, 41u8, 168u8, 212u8],
             [176u8, 154u8, 170u8, 202u8],
-            [197u8, 243u8, 210u8, 84u8],
             [210u8, 18u8, 32u8, 167u8],
-            [210u8, 94u8, 12u8, 182u8],
-            [227u8, 230u8, 245u8, 178u8],
-            [229u8, 22u8, 113u8, 91u8],
-            [238u8, 197u8, 11u8, 151u8],
             [241u8, 79u8, 203u8, 200u8],
-            [255u8, 45u8, 188u8, 152u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <commitmentCall as alloy_sol_types::SolCall>::SIGNATURE,
             <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableTradingCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <NO_TRADINGCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::SIGNATURE,
             <managerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::SIGNATURE,
             <verifyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <hashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <enableTradingCall as alloy_sol_types::SolCall>::SIGNATURE,
             <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTradeableOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <solutionSettlerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <tradingParamsHashCall as alloy_sol_types::SolCall>::SIGNATURE,
             <commitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(token0),
-            ::core::stringify!(commitment),
             ::core::stringify!(isValidSignature),
-            ::core::stringify!(disableTrading),
-            ::core::stringify!(NO_TRADING),
-            ::core::stringify!(COMMITMENT_SLOT),
             ::core::stringify!(manager),
-            ::core::stringify!(MAX_ORDER_DURATION),
             ::core::stringify!(verify),
             ::core::stringify!(hash),
-            ::core::stringify!(enableTrading),
             ::core::stringify!(token1),
-            ::core::stringify!(solutionSettlerDomainSeparator),
-            ::core::stringify!(getTradeableOrder),
-            ::core::stringify!(solutionSettler),
-            ::core::stringify!(tradingParamsHash),
             ::core::stringify!(commit),
-            ::core::stringify!(EMPTY_COMMITMENT),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -5275,48 +3431,21 @@ pub mod CowAmm {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for CowAmmCalls {
-        const COUNT: usize = 18usize;
+        const COUNT: usize = 7usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "CowAmmCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::COMMITMENT_SLOT(_) => {
-                    <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::EMPTY_COMMITMENT(_) => {
-                    <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::MAX_ORDER_DURATION(_) => {
-                    <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::NO_TRADING(_) => <NO_TRADINGCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::commit(_) => <commitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::commitment(_) => <commitmentCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::disableTrading(_) => {
-                    <disableTradingCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::enableTrading(_) => <enableTradingCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getTradeableOrder(_) => {
-                    <getTradeableOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::hash(_) => <hashCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::isValidSignature(_) => {
                     <isValidSignatureCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::manager(_) => <managerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::solutionSettler(_) => {
-                    <solutionSettlerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::solutionSettlerDomainSeparator(_) => {
-                    <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::tradingParamsHash(_) => {
-                    <tradingParamsHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::verify(_) => <verifyCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -5342,13 +3471,6 @@ pub mod CowAmm {
                     }
                     token0
                 },
-                {
-                    fn commitment(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <commitmentCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::commitment)
-                    }
-                    commitment
-                },
                 {
                     fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5356,27 +3478,6 @@ pub mod CowAmm {
                     }
                     isValidSignature
                 },
-                {
-                    fn disableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::disableTrading)
-                    }
-                    disableTrading
-                },
-                {
-                    fn NO_TRADING(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::NO_TRADING)
-                    }
-                    NO_TRADING
-                },
-                {
-                    fn COMMITMENT_SLOT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::COMMITMENT_SLOT)
-                    }
-                    COMMITMENT_SLOT
-                },
                 {
                     fn manager(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <managerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5384,13 +3485,6 @@ pub mod CowAmm {
                     }
                     manager
                 },
-                {
-                    fn MAX_ORDER_DURATION(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::MAX_ORDER_DURATION)
-                    }
-                    MAX_ORDER_DURATION
-                },
                 {
                     fn verify(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <verifyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5405,13 +3499,6 @@ pub mod CowAmm {
                     }
                     hash
                 },
-                {
-                    fn enableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <enableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::enableTrading)
-                    }
-                    enableTrading
-                },
                 {
                     fn token1(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <token1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5419,38 +3506,6 @@ pub mod CowAmm {
                     }
                     token1
                 },
-                {
-                    fn solutionSettlerDomainSeparator(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(CowAmmCalls::solutionSettlerDomainSeparator)
-                    }
-                    solutionSettlerDomainSeparator
-                },
-                {
-                    fn getTradeableOrder(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::getTradeableOrder)
-                    }
-                    getTradeableOrder
-                },
-                {
-                    fn solutionSettler(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <solutionSettlerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::solutionSettler)
-                    }
-                    solutionSettler
-                },
-                {
-                    fn tradingParamsHash(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::tradingParamsHash)
-                    }
-                    tradingParamsHash
-                },
                 {
                     fn commit(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <commitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5458,13 +3513,6 @@ pub mod CowAmm {
                     }
                     commit
                 },
-                {
-                    fn EMPTY_COMMITMENT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmCalls::EMPTY_COMMITMENT)
-                    }
-                    EMPTY_COMMITMENT
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -5489,13 +3537,6 @@ pub mod CowAmm {
                     }
                     token0
                 },
-                {
-                    fn commitment(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <commitmentCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowAmmCalls::commitment)
-                    }
-                    commitment
-                },
                 {
                     fn isValidSignature(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <isValidSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -5505,31 +3546,6 @@ pub mod CowAmm {
                     }
                     isValidSignature
                 },
-                {
-                    fn disableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmCalls::disableTrading)
-                    }
-                    disableTrading
-                },
-                {
-                    fn NO_TRADING(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowAmmCalls::NO_TRADING)
-                    }
-                    NO_TRADING
-                },
-                {
-                    fn COMMITMENT_SLOT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmCalls::COMMITMENT_SLOT)
-                    }
-                    COMMITMENT_SLOT
-                },
                 {
                     fn manager(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <managerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5537,15 +3553,6 @@ pub mod CowAmm {
                     }
                     manager
                 },
-                {
-                    fn MAX_ORDER_DURATION(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowAmmCalls::MAX_ORDER_DURATION)
-                    }
-                    MAX_ORDER_DURATION
-                },
                 {
                     fn verify(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <verifyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5560,15 +3567,6 @@ pub mod CowAmm {
                     }
                     hash
                 },
-                {
-                    fn enableTrading(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <enableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmCalls::enableTrading)
-                    }
-                    enableTrading
-                },
                 {
                     fn token1(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <token1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5576,44 +3574,6 @@ pub mod CowAmm {
                     }
                     token1
                 },
-                {
-                    fn solutionSettlerDomainSeparator(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowAmmCalls::solutionSettlerDomainSeparator)
-                    }
-                    solutionSettlerDomainSeparator
-                },
-                {
-                    fn getTradeableOrder(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowAmmCalls::getTradeableOrder)
-                    }
-                    getTradeableOrder
-                },
-                {
-                    fn solutionSettler(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <solutionSettlerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmCalls::solutionSettler)
-                    }
-                    solutionSettler
-                },
-                {
-                    fn tradingParamsHash(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowAmmCalls::tradingParamsHash)
-                    }
-                    tradingParamsHash
-                },
                 {
                     fn commit(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
                         <commitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5621,15 +3581,6 @@ pub mod CowAmm {
                     }
                     commit
                 },
-                {
-                    fn EMPTY_COMMITMENT(data: &[u8]) -> alloy_sol_types::Result<CowAmmCalls> {
-                        <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmCalls::EMPTY_COMMITMENT)
-                    }
-                    EMPTY_COMMITMENT
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -5643,77 +3594,24 @@ pub mod CowAmm {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::COMMITMENT_SLOT(inner) => {
-                    <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::EMPTY_COMMITMENT(inner) => {
-                    <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::MAX_ORDER_DURATION(inner) => {
-                    <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::NO_TRADING(inner) => {
-                    <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::commit(inner) => {
                     <commitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::commitment(inner) => {
-                    <commitmentCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::disableTrading(inner) => {
-                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::enableTrading(inner) => {
-                    <enableTradingCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTradeableOrder(inner) => {
-                    <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::hash(inner) => {
                     <hashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::isValidSignature(inner) => {
-                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::manager(inner) => {
                     <managerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::solutionSettler(inner) => {
-                    <solutionSettlerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::solutionSettlerDomainSeparator(inner) => {
-                    <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::token0(inner) => {
                     <token0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::token1(inner) => {
                     <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::tradingParamsHash(inner) => {
-                    <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::verify(inner) => {
                     <verifyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5723,33 +3621,9 @@ pub mod CowAmm {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::COMMITMENT_SLOT(inner) => {
-                    <COMMITMENT_SLOTCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::EMPTY_COMMITMENT(inner) => {
-                    <EMPTY_COMMITMENTCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::MAX_ORDER_DURATION(inner) => {
-                    <MAX_ORDER_DURATIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::NO_TRADING(inner) => {
-                    <NO_TRADINGCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::commit(inner) => {
                     <commitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::commitment(inner) => {
-                    <commitmentCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::disableTrading(inner) => {
-                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::enableTrading(inner) => {
-                    <enableTradingCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getTradeableOrder(inner) => {
-                    <getTradeableOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::hash(inner) => {
                     <hashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -5759,23 +3633,12 @@ pub mod CowAmm {
                 Self::manager(inner) => {
                     <managerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::solutionSettler(inner) => {
-                    <solutionSettlerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::solutionSettlerDomainSeparator(inner) => {
-                    <solutionSettlerDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::token0(inner) => {
                     <token0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::token1(inner) => {
                     <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::tradingParamsHash(inner) => {
-                    <tradingParamsHashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::verify(inner) => {
                     <verifyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6485,32 +4348,6 @@ pub mod CowAmm {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`COMMITMENT_SLOT`] function.
-        pub fn COMMITMENT_SLOT(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, COMMITMENT_SLOTCall, N> {
-            self.call_builder(&COMMITMENT_SLOTCall)
-        }
-
-        ///Creates a new call builder for the [`EMPTY_COMMITMENT`] function.
-        pub fn EMPTY_COMMITMENT(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, EMPTY_COMMITMENTCall, N> {
-            self.call_builder(&EMPTY_COMMITMENTCall)
-        }
-
-        ///Creates a new call builder for the [`MAX_ORDER_DURATION`] function.
-        pub fn MAX_ORDER_DURATION(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, MAX_ORDER_DURATIONCall, N> {
-            self.call_builder(&MAX_ORDER_DURATIONCall)
-        }
-
-        ///Creates a new call builder for the [`NO_TRADING`] function.
-        pub fn NO_TRADING(&self) -> alloy_contract::SolCallBuilder<&P, NO_TRADINGCall, N> {
-            self.call_builder(&NO_TRADINGCall)
-        }
-
         ///Creates a new call builder for the [`commit`] function.
         pub fn commit(
             &self,
@@ -6519,32 +4356,6 @@ pub mod CowAmm {
             self.call_builder(&commitCall { orderHash })
         }
 
-        ///Creates a new call builder for the [`commitment`] function.
-        pub fn commitment(&self) -> alloy_contract::SolCallBuilder<&P, commitmentCall, N> {
-            self.call_builder(&commitmentCall)
-        }
-
-        ///Creates a new call builder for the [`disableTrading`] function.
-        pub fn disableTrading(&self) -> alloy_contract::SolCallBuilder<&P, disableTradingCall, N> {
-            self.call_builder(&disableTradingCall)
-        }
-
-        ///Creates a new call builder for the [`enableTrading`] function.
-        pub fn enableTrading(
-            &self,
-            tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, enableTradingCall, N> {
-            self.call_builder(&enableTradingCall { tradingParams })
-        }
-
-        ///Creates a new call builder for the [`getTradeableOrder`] function.
-        pub fn getTradeableOrder(
-            &self,
-            tradingParams: <ConstantProduct::TradingParams as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getTradeableOrderCall, N> {
-            self.call_builder(&getTradeableOrderCall { tradingParams })
-        }
-
         ///Creates a new call builder for the [`hash`] function.
         pub fn hash(
             &self,
@@ -6567,21 +4378,6 @@ pub mod CowAmm {
             self.call_builder(&managerCall)
         }
 
-        ///Creates a new call builder for the [`solutionSettler`] function.
-        pub fn solutionSettler(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, solutionSettlerCall, N> {
-            self.call_builder(&solutionSettlerCall)
-        }
-
-        ///Creates a new call builder for the
-        /// [`solutionSettlerDomainSeparator`] function.
-        pub fn solutionSettlerDomainSeparator(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, solutionSettlerDomainSeparatorCall, N> {
-            self.call_builder(&solutionSettlerDomainSeparatorCall)
-        }
-
         ///Creates a new call builder for the [`token0`] function.
         pub fn token0(&self) -> alloy_contract::SolCallBuilder<&P, token0Call, N> {
             self.call_builder(&token0Call)
@@ -6592,13 +4388,6 @@ pub mod CowAmm {
             self.call_builder(&token1Call)
         }
 
-        ///Creates a new call builder for the [`tradingParamsHash`] function.
-        pub fn tradingParamsHash(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, tradingParamsHashCall, N> {
-            self.call_builder(&tradingParamsHashCall)
-        }
-
         ///Creates a new call builder for the [`verify`] function.
         pub fn verify(
             &self,
diff --git a/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs b/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs
index 2806a011e2..ea4a654388 100644
--- a/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowammconstantproductfactory/src/lib.rs
@@ -10,8 +10,8 @@
 /**
 
 ```solidity
-library GPv2Order {
-    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+library IConditionalOrder {
+    struct ConditionalOrderParams { address handler; bytes32 salt; bytes staticInput; }
 }
 ```*/
 #[allow(
@@ -21,39 +21,21 @@ library GPv2Order {
     clippy::style,
     clippy::empty_structs_with_brackets
 )]
-pub mod GPv2Order {
+pub mod IConditionalOrder {
     use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct Data { address sellToken; address buyToken; address receiver; uint256 sellAmount; uint256 buyAmount; uint32 validTo; bytes32 appData; uint256 feeAmount; bytes32 kind; bool partiallyFillable; bytes32 sellTokenBalance; bytes32 buyTokenBalance; }
+    struct ConditionalOrderParams { address handler; bytes32 salt; bytes staticInput; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct Data {
-        #[allow(missing_docs)]
-        pub sellToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub buyToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub receiver: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub validTo: u32,
-        #[allow(missing_docs)]
-        pub appData: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub kind: alloy_sol_types::private::FixedBytes<32>,
+    pub struct ConditionalOrderParams {
         #[allow(missing_docs)]
-        pub partiallyFillable: bool,
+        pub handler: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub sellTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        pub salt: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub buyTokenBalance: alloy_sol_types::private::FixedBytes<32>,
+        pub staticInput: alloy_sol_types::private::Bytes,
     }
     #[allow(
         non_camel_case_types,
@@ -67,32 +49,14 @@ pub mod GPv2Order {
         #[allow(dead_code)]
         type UnderlyingSolTuple<'a> = (
             alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<32>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Bool,
-            alloy_sol_types::sol_data::FixedBytes<32>,
             alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Bytes,
         );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
             alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            u32,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::FixedBytes<32>,
-            bool,
-            alloy_sol_types::private::FixedBytes<32>,
             alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::Bytes,
         );
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
@@ -105,89 +69,40 @@ pub mod GPv2Order {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<Data> for UnderlyingRustTuple<'_> {
-            fn from(value: Data) -> Self {
-                (
-                    value.sellToken,
-                    value.buyToken,
-                    value.receiver,
-                    value.sellAmount,
-                    value.buyAmount,
-                    value.validTo,
-                    value.appData,
-                    value.feeAmount,
-                    value.kind,
-                    value.partiallyFillable,
-                    value.sellTokenBalance,
-                    value.buyTokenBalance,
-                )
+        impl ::core::convert::From<ConditionalOrderParams> for UnderlyingRustTuple<'_> {
+            fn from(value: ConditionalOrderParams) -> Self {
+                (value.handler, value.salt, value.staticInput)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Data {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ConditionalOrderParams {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    sellToken: tuple.0,
-                    buyToken: tuple.1,
-                    receiver: tuple.2,
-                    sellAmount: tuple.3,
-                    buyAmount: tuple.4,
-                    validTo: tuple.5,
-                    appData: tuple.6,
-                    feeAmount: tuple.7,
-                    kind: tuple.8,
-                    partiallyFillable: tuple.9,
-                    sellTokenBalance: tuple.10,
-                    buyTokenBalance: tuple.11,
+                    handler: tuple.0,
+                    salt: tuple.1,
+                    staticInput: tuple.2,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for Data {
+        impl alloy_sol_types::SolValue for ConditionalOrderParams {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for Data {
+        impl alloy_sol_types::private::SolTypeValue<Self> for ConditionalOrderParams {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sellToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.buyToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.receiver,
+                        &self.handler,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.buyAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.validTo),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.feeAmount),
                     <alloy_sol_types::sol_data::FixedBytes<
                         32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.kind),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.partiallyFillable,
+                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.staticInput,
                     ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellTokenBalance),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.buyTokenBalance),
                 )
             }
 
@@ -228,7 +143,7 @@ pub mod GPv2Order {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for Data {
+        impl alloy_sol_types::SolType for ConditionalOrderParams {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -250,16 +165,13 @@ pub mod GPv2Order {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for Data {
-            const NAME: &'static str = "Data";
+        impl alloy_sol_types::SolStruct for ConditionalOrderParams {
+            const NAME: &'static str = "ConditionalOrderParams";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "Data(address sellToken,address buyToken,address receiver,uint256 \
-                     sellAmount,uint256 buyAmount,uint32 validTo,bytes32 appData,uint256 \
-                     feeAmount,bytes32 kind,bool partiallyFillable,bytes32 \
-                     sellTokenBalance,bytes32 buyTokenBalance)",
+                    "ConditionalOrderParams(address handler,bytes32 salt,bytes staticInput)",
                 )
             }
 
@@ -279,55 +191,15 @@ pub mod GPv2Order {
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sellToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.buyToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.receiver,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.buyAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.validTo)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.appData)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.kind)
-                        .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.partiallyFillable,
+                            &self.handler,
                         )
                         .0,
                     <alloy_sol_types::sol_data::FixedBytes<
                         32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sellTokenBalance,
-                        )
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
                         .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.buyTokenBalance,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.staticInput,
                         )
                         .0,
                 ]
@@ -335,59 +207,18 @@ pub mod GPv2Order {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for Data {
+        impl alloy_sol_types::EventTopic for ConditionalOrderParams {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
                     + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sellToken,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.buyToken,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.receiver,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sellAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.buyAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.validTo,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.appData,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.feeAmount,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.kind)
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.partiallyFillable,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sellTokenBalance,
+                        &rust.handler,
                     )
                     + <alloy_sol_types::sol_data::FixedBytes<
                         32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.buyTokenBalance,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.staticInput,
                     )
             }
 
@@ -398,67 +229,17 @@ pub mod GPv2Order {
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
                 <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sellToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.buyToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.receiver,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sellAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.buyAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.validTo,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.appData,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.feeAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.kind,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.partiallyFillable,
+                    &rust.handler,
                     out,
                 );
                 <alloy_sol_types::sol_data::FixedBytes<
                     32,
                 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sellTokenBalance,
+                    &rust.salt,
                     out,
                 );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.buyTokenBalance,
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.staticInput,
                     out,
                 );
             }
@@ -472,9 +253,9 @@ pub mod GPv2Order {
         }
     };
     use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+    /**Creates a new wrapper around an on-chain [`IConditionalOrder`](self) contract instance.
 
-    See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+    See the [wrapper's documentation](`IConditionalOrderInstance`) for more details.*/
     #[inline]
     pub const fn new<
         P: alloy_contract::private::Provider<N>,
@@ -482,13 +263,13 @@ pub mod GPv2Order {
     >(
         address: alloy_sol_types::private::Address,
         __provider: P,
-    ) -> GPv2OrderInstance<P, N> {
-        GPv2OrderInstance::<P, N>::new(address, __provider)
+    ) -> IConditionalOrderInstance<P, N> {
+        IConditionalOrderInstance::<P, N>::new(address, __provider)
     }
-    /**A [`GPv2Order`](self) instance.
+    /**A [`IConditionalOrder`](self) instance.
 
     Contains type-safe methods for interacting with an on-chain instance of the
-    [`GPv2Order`](self) contract located at a given `address`, using a given
+    [`IConditionalOrder`](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!)
@@ -497,27 +278,27 @@ pub mod GPv2Order {
 
     See the [module-level documentation](self) for all the available methods.*/
     #[derive(Clone)]
-    pub struct GPv2OrderInstance<P, N = alloy_contract::private::Ethereum> {
+    pub struct IConditionalOrderInstance<P, N = alloy_contract::private::Ethereum> {
         address: alloy_sol_types::private::Address,
         provider: P,
         _network: ::core::marker::PhantomData<N>,
     }
     #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for GPv2OrderInstance<P, N> {
+    impl<P, N> ::core::fmt::Debug for IConditionalOrderInstance<P, N> {
         #[inline]
         fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("GPv2OrderInstance")
+            f.debug_tuple("IConditionalOrderInstance")
                 .field(&self.address)
                 .finish()
         }
     }
     /// Instantiation and getters/setters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        GPv2OrderInstance<P, N>
+        IConditionalOrderInstance<P, N>
     {
-        /**Creates a new wrapper around an on-chain [`GPv2Order`](self) contract instance.
+        /**Creates a new wrapper around an on-chain [`IConditionalOrder`](self) contract instance.
 
-        See the [wrapper's documentation](`GPv2OrderInstance`) for more details.*/
+        See the [wrapper's documentation](`IConditionalOrderInstance`) for more details.*/
         #[inline]
         pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
             Self {
@@ -551,12 +332,12 @@ pub mod GPv2Order {
             &self.provider
         }
     }
-    impl<P: ::core::clone::Clone, N> GPv2OrderInstance<&P, N> {
+    impl<P: ::core::clone::Clone, N> IConditionalOrderInstance<&P, N> {
         /// Clones the provider and returns a new instance with the cloned
         /// provider.
         #[inline]
-        pub fn with_cloned_provider(self) -> GPv2OrderInstance<P, N> {
-            GPv2OrderInstance {
+        pub fn with_cloned_provider(self) -> IConditionalOrderInstance<P, N> {
+            IConditionalOrderInstance {
                 address: self.address,
                 provider: ::core::clone::Clone::clone(&self.provider),
                 _network: ::core::marker::PhantomData,
@@ -565,7 +346,7 @@ pub mod GPv2Order {
     }
     /// Function calls.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        GPv2OrderInstance<P, N>
+        IConditionalOrderInstance<P, N>
     {
         /// Creates a new call builder using this contract instance's provider
         /// and address.
@@ -582,7 +363,7 @@ pub mod GPv2Order {
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        GPv2OrderInstance<P, N>
+        IConditionalOrderInstance<P, N>
     {
         /// Creates a new event filter using this contract instance's provider
         /// and address.
@@ -597,1510 +378,341 @@ pub mod GPv2Order {
         }
     }
 }
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
 library IConditionalOrder {
-    struct ConditionalOrderParams { address handler; bytes32 salt; bytes staticInput; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IConditionalOrder {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct ConditionalOrderParams { address handler; bytes32 salt; bytes staticInput; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ConditionalOrderParams {
-        #[allow(missing_docs)]
-        pub handler: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub salt: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub staticInput: alloy_sol_types::private::Bytes,
+    struct ConditionalOrderParams {
+        address handler;
+        bytes32 salt;
+        bytes staticInput;
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ConditionalOrderParams> for UnderlyingRustTuple<'_> {
-            fn from(value: ConditionalOrderParams) -> Self {
-                (value.handler, value.salt, value.staticInput)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ConditionalOrderParams {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    handler: tuple.0,
-                    salt: tuple.1,
-                    staticInput: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for ConditionalOrderParams {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for ConditionalOrderParams {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.handler,
-                    ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.staticInput,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for ConditionalOrderParams {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for ConditionalOrderParams {
-            const NAME: &'static str = "ConditionalOrderParams";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "ConditionalOrderParams(address handler,bytes32 salt,bytes staticInput)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.handler,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.staticInput,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for ConditionalOrderParams {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.handler,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.staticInput,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.handler,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.salt,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.staticInput,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IConditionalOrder`](self) contract instance.
-
-    See the [wrapper's documentation](`IConditionalOrderInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IConditionalOrderInstance<P, N> {
-        IConditionalOrderInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IConditionalOrder`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IConditionalOrder`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IConditionalOrderInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IConditionalOrderInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IConditionalOrderInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IConditionalOrderInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IConditionalOrder`](self) contract instance.
-
-        See the [wrapper's documentation](`IConditionalOrderInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IConditionalOrderInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IConditionalOrderInstance<P, N> {
-            IConditionalOrderInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IConditionalOrderInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IConditionalOrderInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library GPv2Order {
-    struct Data {
-        address sellToken;
-        address buyToken;
-        address receiver;
-        uint256 sellAmount;
-        uint256 buyAmount;
-        uint32 validTo;
-        bytes32 appData;
-        uint256 feeAmount;
-        bytes32 kind;
-        bool partiallyFillable;
-        bytes32 sellTokenBalance;
-        bytes32 buyTokenBalance;
-    }
-}
-
-library IConditionalOrder {
-    struct ConditionalOrderParams {
-        address handler;
-        bytes32 salt;
-        bytes staticInput;
-    }
-}
-
-interface CowAmmConstantProductFactory {
-    error OnlyOwnerCanCall(address owner);
-    error OrderNotValid(string);
-
-    event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params);
-    event Deployed(address indexed amm, address indexed owner, address token0, address token1);
-    event TradingDisabled(address indexed amm);
-
-    constructor(address _settler);
-
-    function ammDeterministicAddress(address ammOwner, address token0, address token1) external view returns (address);
-    function create(address token0, uint256 amount0, address token1, uint256 amount1, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external returns (address amm);
-    function deposit(address amm, uint256 amount0, uint256 amount1) external;
-    function disableTrading(address amm) external;
-    function getTradeableOrderWithSignature(address amm, IConditionalOrder.ConditionalOrderParams memory params, bytes memory, bytes32[] memory) external view returns (GPv2Order.Data memory order, bytes memory signature);
-    function owner(address) external view returns (address);
-    function settler() external view returns (address);
-    function updateParameters(address amm, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external;
-    function withdraw(address amm, uint256 amount0, uint256 amount1) external;
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "constructor",
-    "inputs": [
-      {
-        "name": "_settler",
-        "type": "address",
-        "internalType": "contract ISettlement"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "ammDeterministicAddress",
-    "inputs": [
-      {
-        "name": "ammOwner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "token0",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "token1",
-        "type": "address",
-        "internalType": "contract IERC20"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "create",
-    "inputs": [
-      {
-        "name": "token0",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "amount0",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "token1",
-        "type": "address",
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "amount1",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minTradedToken0",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "priceOracle",
-        "type": "address",
-        "internalType": "contract IPriceOracle"
-      },
-      {
-        "name": "priceOracleData",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "appData",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "deposit",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      },
-      {
-        "name": "amount0",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amount1",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "disableTrading",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getTradeableOrderWithSignature",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      },
-      {
-        "name": "params",
-        "type": "tuple",
-        "internalType": "struct IConditionalOrder.ConditionalOrderParams",
-        "components": [
-          {
-            "name": "handler",
-            "type": "address",
-            "internalType": "contract IConditionalOrder"
-          },
-          {
-            "name": "salt",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "staticInput",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "",
-        "type": "bytes32[]",
-        "internalType": "bytes32[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct GPv2Order.Data",
-        "components": [
-          {
-            "name": "sellToken",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "buyToken",
-            "type": "address",
-            "internalType": "contract IERC20"
-          },
-          {
-            "name": "receiver",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sellAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "buyAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "validTo",
-            "type": "uint32",
-            "internalType": "uint32"
-          },
-          {
-            "name": "appData",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "feeAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "kind",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "partiallyFillable",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "sellTokenBalance",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "buyTokenBalance",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "owner",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "settler",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract ISettlement"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "updateParameters",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      },
-      {
-        "name": "minTradedToken0",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "priceOracle",
-        "type": "address",
-        "internalType": "contract IPriceOracle"
-      },
-      {
-        "name": "priceOracleData",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "appData",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "withdraw",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "contract ConstantProduct"
-      },
-      {
-        "name": "amount0",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amount1",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "event",
-    "name": "ConditionalOrderCreated",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "params",
-        "type": "tuple",
-        "indexed": false,
-        "internalType": "struct IConditionalOrder.ConditionalOrderParams",
-        "components": [
-          {
-            "name": "handler",
-            "type": "address",
-            "internalType": "contract IConditionalOrder"
-          },
-          {
-            "name": "salt",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "staticInput",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Deployed",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract ConstantProduct"
-      },
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token0",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20"
-      },
-      {
-        "name": "token1",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TradingDisabled",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "indexed": true,
-        "internalType": "contract ConstantProduct"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "error",
-    "name": "OnlyOwnerCanCall",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "OrderNotValid",
-    "inputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ]
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod CowAmmConstantProductFactory {
-    use {super::*, alloy_sol_types};
-    /// The creation / init bytecode of the contract.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\xA0`@R4\x80\x15`\x0EW_\x80\xFD[P`@QaA\xB38\x03\x80aA\xB3\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW_\x80\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W_\x80\xFD[\x93\x92PPPV[`\x80QaA'a\0\x8C_9_\x81\x81a\x01\x89\x01R\x81\x81a\x02\xA8\x01Ra\x08\xC4\x01RaA'_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x9FW_5`\xE0\x1C\x80c7\xEB\xDFP\x11a\0rW\x80cfn\x1B9\x11a\0XW\x80cfn\x1B9\x14a\x01OW\x80c\xAB\"\x1Av\x14a\x01\x84W\x80c\xB5\xC5\xF6r\x14a\x01\xABW_\x80\xFD[\x80c7\xEB\xDFP\x14a\x01)W\x80c[]\x9E\xE6\x14a\x01<W_\x80\xFD[\x80c\x0E\xFEj\x8B\x14a\0\xA3W\x80c\"\xB1U\xC6\x14a\0\xB8W\x80c&\xE0\xA1\x96\x14a\0\xF5W\x80c'\x91\x05e\x14a\x01\x16W[_\x80\xFD[a\0\xB6a\0\xB16`\x04a\x11\xEAV[a\x01\xBEV[\0[a\0\xCBa\0\xC66`\x04a\x12aV[a\x02\xA3V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\x08a\x01\x036`\x04a\x12\xFBV[a\x04_V[`@Qa\0\xEC\x92\x91\x90a\x14\xFDV[a\0\xB6a\x01$6`\x04a\x15'V[a\x07\x97V[a\0\xCBa\x0176`\x04a\x15IV[a\x08/V[a\0\xB6a\x01J6`\x04a\x15\x91V[a\n\x01V[a\0\xCBa\x01]6`\x04a\x15'V[_` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\0\xCB\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB6a\x01\xB96`\x04a\x11\xEAV[a\x0B\x17V[a\x02O3\x84\x84\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x021\x91\x90a\x16\x17V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x0CFV[a\x02\x9E3\x84\x83\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPV[_3\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8B`@Qa\x02\xD5\x90a\x11\xB9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x81R\x91\x83\x16` \x83\x01R\x90\x91\x16`@\x82\x01R``\x01\x81\x90`@Q\x80\x91\x03\x90_\xF5\x90P\x80\x15\x80\x15a\x03\x1FW=_\x80>=_\xFD[P`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16\x82R\x8C\x81\x16` \x83\x01R\x92\x94P\x82\x84\x16\x92\x85\x16\x91\x7Fg\x07%[,\\\xA8\x12 \xB2\xF3\xE4\x08\xA2i\xCB\x83\xBA\xA6\xAA~^7\xAA\x17V\x88:l\xDF\x06\xF1\x91\x01`@Q\x80\x91\x03\x90\xA3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16_\x90\x81R` \x81\x90R`@\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x83\x16\x91\x90\x91\x17\x90Ua\x03\xD8\x82\x8B\x8Aa\x01\xBEV[_`@Q\x80`\x80\x01`@R\x80\x89\x81R` \x01\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x85\x90R\x90Pa\x04P\x83\x82a\x0C\xDBV[PP\x99\x98PPPPPPPPPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``0a\x04\xCF` \x89\x01\x89a\x15'V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x05QW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Fcan only handle own orders\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x05_`@\x89\x01\x89a\x162V[\x81\x01\x90a\x05l\x91\x90a\x17\\V[\x90P\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xEE\xC5\x0B\x97`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDB\x91\x90a\x18ZV[`@Q\x7F\xB0\x9A\xAA\xCA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x90c\xB0\x9A\xAA\xCA\x90a\x06-\x90\x85\x90`\x04\x01a\x18\xC3V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06HW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06l\x91\x90a\x18ZV[\x14a\x06\xD3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Finvalid trading parameters\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05HV[`@Q\x7F\xE3\xE6\xF5\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x90c\xE3\xE6\xF5\xB2\x90a\x07%\x90\x84\x90`\x04\x01a\x18\xC3V[a\x01\x80`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a\x18\xF7V[\x92P\x82\x81`@Q` \x01a\x07z\x92\x91\x90a\x19\xB3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x96P\x96\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16_\x90\x81R` \x81\x90R`@\x90 T\x82\x91\x163\x14a\x08\"Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x08+\x82a\x0E\x05V[PPV[_\x80\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16`@Qa\x08y` \x82\x01a\x11\xB9V[\x81\x81\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x01\x83R`\x1F\x90\x91\x01\x16`@\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16` \x84\x01R\x80\x8B\x16\x91\x83\x01\x91\x90\x91R\x88\x16``\x82\x01R`\x80\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\t:\x92\x91` \x01a\x19\xEBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\t\xC2\x94\x93\x92\x91\x90\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\x90\x94\x16\x84R``\x92\x90\x92\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x01\x84\x01R`\x15\x83\x01R`5\x82\x01R`U\x01\x90V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 \x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x87\x16_\x90\x81R` \x81\x90R`@\x90 T\x87\x91\x163\x14a\n\x8CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[_`@Q\x80`\x80\x01`@R\x80\x88\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x86\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x84\x90R\x90Pa\x0B\x03\x88a\x0E\x05V[a\x0B\r\x88\x82a\x0C\xDBV[PPPPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16_\x90\x81R` \x81\x90R`@\x90 T\x84\x91\x163\x14a\x0B\xA2Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x0B\xF1\x843\x85\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[a\x0C@\x843\x84\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C@\x90\x85\x90a\x0E\xA3V[`@Q\x7F\xC5\xF3\xD2T\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xC5\xF3\xD2T\x90a\r-\x90\x84\x90`\x04\x01a\x18\xC3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rDW_\x80\xFD[PZ\xF1\x15\x80\x15a\rVW=_\x80>=_\xFD[PP`@\x80Q``\x81\x01\x82R0\x81R_` \x80\x83\x01\x82\x90R\x83Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x94P\x7F,\xCE\xACUU\xB0\xCAE\xA3tL\xEDT/T\xB5j\xD2\xEBE\xE5!\x96#r\xEE\xF2\x12\xA2\xCB\xF3a\x93\x83\x01\x91a\r\xBD\x91\x88\x91\x01a\x18\xC3V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R\x91RQa\r\xF8\x91\x90a\x19\xFFV[`@Q\x80\x91\x03\x90\xA2PPPV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17p\x0F\x01`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0EJW_\x80\xFD[PZ\xF1\x15\x80\x15a\x0E\\W=_\x80>=_\xFD[PP`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x92P\x7F\xC7[\xF4\xF0<\x02\xFA\xB9AJ}zT\x04\x8C\x04\x86r+\xC7/3\xAD\x92G\t\xA0Y6\x08\xAD'\x91P_\x90\xA2PV[_a\x0F\x04\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xB0\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x80Q_\x14\x80a\x0F$WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0F$\x91\x90a\x1ACV[a\x02\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01R\x7Fot succeed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[``a\x0F\xBE\x84\x84_\x85a\x0F\xC6V[\x94\x93PPPPV[``\x82G\x10\x15a\x10XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01R\x7Fr call\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[_\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x87`@Qa\x10\x80\x91\x90a\x1A\\V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x10\xBAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x10\xBFV[``\x91P[P\x91P\x91Pa\x10\xD0\x87\x83\x83\x87a\x10\xDBV[\x97\x96PPPPPPPV[``\x83\x15a\x11pW\x82Q_\x03a\x11iWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x11iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x05HV[P\x81a\x0F\xBEV[a\x0F\xBE\x83\x83\x81Q\x15a\x11\x85W\x81Q\x80\x83` \x01\xFD[\x80`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x05H\x91\x90a\x1AgV[a&x\x80a\x1Az\x839\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xE7W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x11\xFCW_\x80\xFD[\x835a\x12\x07\x81a\x11\xC6V[\x95` \x85\x015\x95P`@\x90\x94\x015\x93\x92PPPV[_\x80\x83`\x1F\x84\x01\x12a\x12,W_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12CW_\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x12ZW_\x80\xFD[\x92P\x92\x90PV[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a\x12zW_\x80\xFD[\x895a\x12\x85\x81a\x11\xC6V[\x98P` \x8A\x015\x97P`@\x8A\x015a\x12\x9C\x81a\x11\xC6V[\x96P``\x8A\x015\x95P`\x80\x8A\x015\x94P`\xA0\x8A\x015a\x12\xBA\x81a\x11\xC6V[\x93P`\xC0\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xD5W_\x80\xFD[a\x12\xE1\x8C\x82\x8D\x01a\x12\x1CV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x95\x98\x94\x97\x96`\xE0\x015\x94\x93PPPPV[_\x80_\x80_\x80`\x80\x87\x89\x03\x12\x15a\x13\x10W_\x80\xFD[\x865a\x13\x1B\x81a\x11\xC6V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x137W_\x80\xFD[\x90\x88\x01\x90``\x82\x8B\x03\x12\x15a\x13JW_\x80\xFD[\x90\x95P`@\x88\x015\x90\x80\x82\x11\x15a\x13_W_\x80\xFD[a\x13k\x8A\x83\x8B\x01a\x12\x1CV[\x90\x96P\x94P``\x89\x015\x91P\x80\x82\x11\x15a\x13\x83W_\x80\xFD[\x81\x89\x01\x91P\x89`\x1F\x83\x01\x12a\x13\x96W_\x80\xFD[\x815\x81\x81\x11\x15a\x13\xA4W_\x80\xFD[\x8A` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x13\xB8W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa\x14\x0F` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa\x147`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa\x14c`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa\x14\x98\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_a\x01\xA0a\x15\x0B\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x14\xB1V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x157W_\x80\xFD[\x815a\x15B\x81a\x11\xC6V[\x93\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a\x15[W_\x80\xFD[\x835a\x15f\x81a\x11\xC6V[\x92P` \x84\x015a\x15v\x81a\x11\xC6V[\x91P`@\x84\x015a\x15\x86\x81a\x11\xC6V[\x80\x91PP\x92P\x92P\x92V[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a\x15\xA6W_\x80\xFD[\x865a\x15\xB1\x81a\x11\xC6V[\x95P` \x87\x015\x94P`@\x87\x015a\x15\xC8\x81a\x11\xC6V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xE3W_\x80\xFD[a\x15\xEF\x89\x82\x8A\x01a\x12\x1CV[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95`\x80\x90\x95\x015\x94\x93PPPPV[\x80Qa\x16\x12\x81a\x11\xC6V[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16'W_\x80\xFD[\x81Qa\x15B\x81a\x11\xC6V[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x16eW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16\x7FW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x12ZW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17TWa\x17Ta\x16\x93V[`@R\x91\x90PV[_` \x80\x83\x85\x03\x12\x15a\x17mW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x84W_\x80\xFD[\x90\x84\x01\x90`\x80\x82\x87\x03\x12\x15a\x17\x97W_\x80\xFD[a\x17\x9Fa\x16\xC0V[\x825\x81R\x83\x83\x015a\x17\xB0\x81a\x11\xC6V[\x81\x85\x01R`@\x83\x015\x82\x81\x11\x15a\x17\xC5W_\x80\xFD[\x83\x01`\x1F\x81\x01\x88\x13a\x17\xD5W_\x80\xFD[\x805\x83\x81\x11\x15a\x17\xE7Wa\x17\xE7a\x16\x93V[a\x18\x17\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\rV[\x93P\x80\x84R\x88\x86\x82\x84\x01\x01\x11\x15a\x18,W_\x80\xFD[\x80\x86\x83\x01\x87\x86\x017_\x86\x82\x86\x01\x01RPP\x81`@\x82\x01R``\x83\x015``\x82\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x18jW_\x80\xFD[PQ\x91\x90PV[\x80Q\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x83\x01R_`@\x82\x01Q`\x80`@\x85\x01Ra\x18\xAF`\x80\x85\x01\x82a\x14\xB1V[``\x93\x84\x01Q\x94\x90\x93\x01\x93\x90\x93RP\x91\x90PV[` \x81R_a\x15B` \x83\x01\x84a\x18qV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x16\x12W_\x80\xFD[\x80Q\x80\x15\x15\x81\x14a\x16\x12W_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19\x08W_\x80\xFD[a\x19\x10a\x16\xE9V[a\x19\x19\x83a\x16\x07V[\x81Ra\x19'` \x84\x01a\x16\x07V[` \x82\x01Ra\x198`@\x84\x01a\x16\x07V[`@\x82\x01R``\x83\x01Q``\x82\x01R`\x80\x83\x01Q`\x80\x82\x01Ra\x19]`\xA0\x84\x01a\x18\xD5V[`\xA0\x82\x01R`\xC0\x83\x01Q`\xC0\x82\x01R`\xE0\x83\x01Q`\xE0\x82\x01Ra\x01\0\x80\x84\x01Q\x81\x83\x01RPa\x01 a\x19\x90\x81\x85\x01a\x18\xE8V[\x90\x82\x01Ra\x01@\x83\x81\x01Q\x90\x82\x01Ra\x01`\x92\x83\x01Q\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_a\x01\xA0a\x19\xC1\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x18qV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0F\xBEa\x19\xF9\x83\x86a\x19\xD4V[\x84a\x19\xD4V[` \x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82Q\x16` \x82\x01R` \x82\x01Q`@\x82\x01R_`@\x83\x01Q``\x80\x84\x01Ra\x0F\xBE`\x80\x84\x01\x82a\x14\xB1V[_` \x82\x84\x03\x12\x15a\x1ASW_\x80\xFD[a\x15B\x82a\x18\xE8V[_a\x15B\x82\x84a\x19\xD4V[` \x81R_a\x15B` \x83\x01\x84a\x14\xB1V\xFEa\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003\xA2dipfsX\"\x12 \x11\x90\xCFB\xF9\x89\xCE\xE2?\x12Y|\x8C\x1E\x9D\xAA\xB6\xD8\xC8\x16Q3I\xC3\xCE\x7F\xD2)\xCA\xE5\xB0\xFFdsolcC\0\x08\x19\x003",
-    );
-    /// The runtime bytecode of the contract, as deployed on the network.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x9FW_5`\xE0\x1C\x80c7\xEB\xDFP\x11a\0rW\x80cfn\x1B9\x11a\0XW\x80cfn\x1B9\x14a\x01OW\x80c\xAB\"\x1Av\x14a\x01\x84W\x80c\xB5\xC5\xF6r\x14a\x01\xABW_\x80\xFD[\x80c7\xEB\xDFP\x14a\x01)W\x80c[]\x9E\xE6\x14a\x01<W_\x80\xFD[\x80c\x0E\xFEj\x8B\x14a\0\xA3W\x80c\"\xB1U\xC6\x14a\0\xB8W\x80c&\xE0\xA1\x96\x14a\0\xF5W\x80c'\x91\x05e\x14a\x01\x16W[_\x80\xFD[a\0\xB6a\0\xB16`\x04a\x11\xEAV[a\x01\xBEV[\0[a\0\xCBa\0\xC66`\x04a\x12aV[a\x02\xA3V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\x08a\x01\x036`\x04a\x12\xFBV[a\x04_V[`@Qa\0\xEC\x92\x91\x90a\x14\xFDV[a\0\xB6a\x01$6`\x04a\x15'V[a\x07\x97V[a\0\xCBa\x0176`\x04a\x15IV[a\x08/V[a\0\xB6a\x01J6`\x04a\x15\x91V[a\n\x01V[a\0\xCBa\x01]6`\x04a\x15'V[_` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\0\xCB\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB6a\x01\xB96`\x04a\x11\xEAV[a\x0B\x17V[a\x02O3\x84\x84\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x021\x91\x90a\x16\x17V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x0CFV[a\x02\x9E3\x84\x83\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPV[_3\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8B`@Qa\x02\xD5\x90a\x11\xB9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x81R\x91\x83\x16` \x83\x01R\x90\x91\x16`@\x82\x01R``\x01\x81\x90`@Q\x80\x91\x03\x90_\xF5\x90P\x80\x15\x80\x15a\x03\x1FW=_\x80>=_\xFD[P`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16\x82R\x8C\x81\x16` \x83\x01R\x92\x94P\x82\x84\x16\x92\x85\x16\x91\x7Fg\x07%[,\\\xA8\x12 \xB2\xF3\xE4\x08\xA2i\xCB\x83\xBA\xA6\xAA~^7\xAA\x17V\x88:l\xDF\x06\xF1\x91\x01`@Q\x80\x91\x03\x90\xA3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16_\x90\x81R` \x81\x90R`@\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x83\x16\x91\x90\x91\x17\x90Ua\x03\xD8\x82\x8B\x8Aa\x01\xBEV[_`@Q\x80`\x80\x01`@R\x80\x89\x81R` \x01\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x85\x90R\x90Pa\x04P\x83\x82a\x0C\xDBV[PP\x99\x98PPPPPPPPPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``0a\x04\xCF` \x89\x01\x89a\x15'V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x05QW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Fcan only handle own orders\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x05_`@\x89\x01\x89a\x162V[\x81\x01\x90a\x05l\x91\x90a\x17\\V[\x90P\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xEE\xC5\x0B\x97`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDB\x91\x90a\x18ZV[`@Q\x7F\xB0\x9A\xAA\xCA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x90c\xB0\x9A\xAA\xCA\x90a\x06-\x90\x85\x90`\x04\x01a\x18\xC3V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06HW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06l\x91\x90a\x18ZV[\x14a\x06\xD3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Finvalid trading parameters\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05HV[`@Q\x7F\xE3\xE6\xF5\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x90c\xE3\xE6\xF5\xB2\x90a\x07%\x90\x84\x90`\x04\x01a\x18\xC3V[a\x01\x80`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a\x18\xF7V[\x92P\x82\x81`@Q` \x01a\x07z\x92\x91\x90a\x19\xB3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x96P\x96\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16_\x90\x81R` \x81\x90R`@\x90 T\x82\x91\x163\x14a\x08\"Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x08+\x82a\x0E\x05V[PPV[_\x80\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16`@Qa\x08y` \x82\x01a\x11\xB9V[\x81\x81\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x01\x83R`\x1F\x90\x91\x01\x16`@\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16` \x84\x01R\x80\x8B\x16\x91\x83\x01\x91\x90\x91R\x88\x16``\x82\x01R`\x80\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\t:\x92\x91` \x01a\x19\xEBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\t\xC2\x94\x93\x92\x91\x90\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\x90\x94\x16\x84R``\x92\x90\x92\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x01\x84\x01R`\x15\x83\x01R`5\x82\x01R`U\x01\x90V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 \x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x87\x16_\x90\x81R` \x81\x90R`@\x90 T\x87\x91\x163\x14a\n\x8CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[_`@Q\x80`\x80\x01`@R\x80\x88\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x86\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x84\x90R\x90Pa\x0B\x03\x88a\x0E\x05V[a\x0B\r\x88\x82a\x0C\xDBV[PPPPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16_\x90\x81R` \x81\x90R`@\x90 T\x84\x91\x163\x14a\x0B\xA2Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x0B\xF1\x843\x85\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[a\x0C@\x843\x84\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C@\x90\x85\x90a\x0E\xA3V[`@Q\x7F\xC5\xF3\xD2T\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xC5\xF3\xD2T\x90a\r-\x90\x84\x90`\x04\x01a\x18\xC3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rDW_\x80\xFD[PZ\xF1\x15\x80\x15a\rVW=_\x80>=_\xFD[PP`@\x80Q``\x81\x01\x82R0\x81R_` \x80\x83\x01\x82\x90R\x83Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x94P\x7F,\xCE\xACUU\xB0\xCAE\xA3tL\xEDT/T\xB5j\xD2\xEBE\xE5!\x96#r\xEE\xF2\x12\xA2\xCB\xF3a\x93\x83\x01\x91a\r\xBD\x91\x88\x91\x01a\x18\xC3V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R\x91RQa\r\xF8\x91\x90a\x19\xFFV[`@Q\x80\x91\x03\x90\xA2PPPV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17p\x0F\x01`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0EJW_\x80\xFD[PZ\xF1\x15\x80\x15a\x0E\\W=_\x80>=_\xFD[PP`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x92P\x7F\xC7[\xF4\xF0<\x02\xFA\xB9AJ}zT\x04\x8C\x04\x86r+\xC7/3\xAD\x92G\t\xA0Y6\x08\xAD'\x91P_\x90\xA2PV[_a\x0F\x04\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xB0\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x80Q_\x14\x80a\x0F$WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0F$\x91\x90a\x1ACV[a\x02\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01R\x7Fot succeed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[``a\x0F\xBE\x84\x84_\x85a\x0F\xC6V[\x94\x93PPPPV[``\x82G\x10\x15a\x10XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01R\x7Fr call\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[_\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x87`@Qa\x10\x80\x91\x90a\x1A\\V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x10\xBAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x10\xBFV[``\x91P[P\x91P\x91Pa\x10\xD0\x87\x83\x83\x87a\x10\xDBV[\x97\x96PPPPPPPV[``\x83\x15a\x11pW\x82Q_\x03a\x11iWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x11iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x05HV[P\x81a\x0F\xBEV[a\x0F\xBE\x83\x83\x81Q\x15a\x11\x85W\x81Q\x80\x83` \x01\xFD[\x80`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x05H\x91\x90a\x1AgV[a&x\x80a\x1Az\x839\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xE7W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x11\xFCW_\x80\xFD[\x835a\x12\x07\x81a\x11\xC6V[\x95` \x85\x015\x95P`@\x90\x94\x015\x93\x92PPPV[_\x80\x83`\x1F\x84\x01\x12a\x12,W_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12CW_\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x12ZW_\x80\xFD[\x92P\x92\x90PV[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a\x12zW_\x80\xFD[\x895a\x12\x85\x81a\x11\xC6V[\x98P` \x8A\x015\x97P`@\x8A\x015a\x12\x9C\x81a\x11\xC6V[\x96P``\x8A\x015\x95P`\x80\x8A\x015\x94P`\xA0\x8A\x015a\x12\xBA\x81a\x11\xC6V[\x93P`\xC0\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xD5W_\x80\xFD[a\x12\xE1\x8C\x82\x8D\x01a\x12\x1CV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x95\x98\x94\x97\x96`\xE0\x015\x94\x93PPPPV[_\x80_\x80_\x80`\x80\x87\x89\x03\x12\x15a\x13\x10W_\x80\xFD[\x865a\x13\x1B\x81a\x11\xC6V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x137W_\x80\xFD[\x90\x88\x01\x90``\x82\x8B\x03\x12\x15a\x13JW_\x80\xFD[\x90\x95P`@\x88\x015\x90\x80\x82\x11\x15a\x13_W_\x80\xFD[a\x13k\x8A\x83\x8B\x01a\x12\x1CV[\x90\x96P\x94P``\x89\x015\x91P\x80\x82\x11\x15a\x13\x83W_\x80\xFD[\x81\x89\x01\x91P\x89`\x1F\x83\x01\x12a\x13\x96W_\x80\xFD[\x815\x81\x81\x11\x15a\x13\xA4W_\x80\xFD[\x8A` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x13\xB8W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa\x14\x0F` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa\x147`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa\x14c`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa\x14\x98\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_a\x01\xA0a\x15\x0B\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x14\xB1V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x157W_\x80\xFD[\x815a\x15B\x81a\x11\xC6V[\x93\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a\x15[W_\x80\xFD[\x835a\x15f\x81a\x11\xC6V[\x92P` \x84\x015a\x15v\x81a\x11\xC6V[\x91P`@\x84\x015a\x15\x86\x81a\x11\xC6V[\x80\x91PP\x92P\x92P\x92V[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a\x15\xA6W_\x80\xFD[\x865a\x15\xB1\x81a\x11\xC6V[\x95P` \x87\x015\x94P`@\x87\x015a\x15\xC8\x81a\x11\xC6V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xE3W_\x80\xFD[a\x15\xEF\x89\x82\x8A\x01a\x12\x1CV[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95`\x80\x90\x95\x015\x94\x93PPPPV[\x80Qa\x16\x12\x81a\x11\xC6V[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16'W_\x80\xFD[\x81Qa\x15B\x81a\x11\xC6V[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x16eW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16\x7FW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x12ZW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17TWa\x17Ta\x16\x93V[`@R\x91\x90PV[_` \x80\x83\x85\x03\x12\x15a\x17mW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x84W_\x80\xFD[\x90\x84\x01\x90`\x80\x82\x87\x03\x12\x15a\x17\x97W_\x80\xFD[a\x17\x9Fa\x16\xC0V[\x825\x81R\x83\x83\x015a\x17\xB0\x81a\x11\xC6V[\x81\x85\x01R`@\x83\x015\x82\x81\x11\x15a\x17\xC5W_\x80\xFD[\x83\x01`\x1F\x81\x01\x88\x13a\x17\xD5W_\x80\xFD[\x805\x83\x81\x11\x15a\x17\xE7Wa\x17\xE7a\x16\x93V[a\x18\x17\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\rV[\x93P\x80\x84R\x88\x86\x82\x84\x01\x01\x11\x15a\x18,W_\x80\xFD[\x80\x86\x83\x01\x87\x86\x017_\x86\x82\x86\x01\x01RPP\x81`@\x82\x01R``\x83\x015``\x82\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x18jW_\x80\xFD[PQ\x91\x90PV[\x80Q\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x83\x01R_`@\x82\x01Q`\x80`@\x85\x01Ra\x18\xAF`\x80\x85\x01\x82a\x14\xB1V[``\x93\x84\x01Q\x94\x90\x93\x01\x93\x90\x93RP\x91\x90PV[` \x81R_a\x15B` \x83\x01\x84a\x18qV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x16\x12W_\x80\xFD[\x80Q\x80\x15\x15\x81\x14a\x16\x12W_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19\x08W_\x80\xFD[a\x19\x10a\x16\xE9V[a\x19\x19\x83a\x16\x07V[\x81Ra\x19'` \x84\x01a\x16\x07V[` \x82\x01Ra\x198`@\x84\x01a\x16\x07V[`@\x82\x01R``\x83\x01Q``\x82\x01R`\x80\x83\x01Q`\x80\x82\x01Ra\x19]`\xA0\x84\x01a\x18\xD5V[`\xA0\x82\x01R`\xC0\x83\x01Q`\xC0\x82\x01R`\xE0\x83\x01Q`\xE0\x82\x01Ra\x01\0\x80\x84\x01Q\x81\x83\x01RPa\x01 a\x19\x90\x81\x85\x01a\x18\xE8V[\x90\x82\x01Ra\x01@\x83\x81\x01Q\x90\x82\x01Ra\x01`\x92\x83\x01Q\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_a\x01\xA0a\x19\xC1\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x18qV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0F\xBEa\x19\xF9\x83\x86a\x19\xD4V[\x84a\x19\xD4V[` \x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82Q\x16` \x82\x01R` \x82\x01Q`@\x82\x01R_`@\x83\x01Q``\x80\x84\x01Ra\x0F\xBE`\x80\x84\x01\x82a\x14\xB1V[_` \x82\x84\x03\x12\x15a\x1ASW_\x80\xFD[a\x15B\x82a\x18\xE8V[_a\x15B\x82\x84a\x19\xD4V[` \x81R_a\x15B` \x83\x01\x84a\x14\xB1V\xFEa\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003\xA2dipfsX\"\x12 \x11\x90\xCFB\xF9\x89\xCE\xE2?\x12Y|\x8C\x1E\x9D\xAA\xB6\xD8\xC8\x16Q3I\xC3\xCE\x7F\xD2)\xCA\xE5\xB0\xFFdsolcC\0\x08\x19\x003",
-    );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `OnlyOwnerCanCall(address)` and selector `0x68bafff8`.
-    ```solidity
-    error OnlyOwnerCanCall(address owner);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OnlyOwnerCanCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<OnlyOwnerCanCall> for UnderlyingRustTuple<'_> {
-            fn from(value: OnlyOwnerCanCall) -> Self {
-                (value.owner,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyOwnerCanCall {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { owner: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for OnlyOwnerCanCall {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [104u8, 186u8, 255u8, 248u8];
-            const SIGNATURE: &'static str = "OnlyOwnerCanCall(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `OrderNotValid(string)` and selector `0xc8fc2725`.
-    ```solidity
-    error OrderNotValid(string);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OrderNotValid(pub alloy_sol_types::private::String);
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<OrderNotValid> for UnderlyingRustTuple<'_> {
-            fn from(value: OrderNotValid) -> Self {
-                (value.0,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderNotValid {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self(tuple.0)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for OrderNotValid {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [200u8, 252u8, 39u8, 37u8];
-            const SIGNATURE: &'static str = "OrderNotValid(string)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ConditionalOrderCreated(address,(address,bytes32,bytes))` and selector `0x2cceac5555b0ca45a3744ced542f54b56ad2eb45e521962372eef212a2cbf361`.
-    ```solidity
-    event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ConditionalOrderCreated {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub params:
-            <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ConditionalOrderCreated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (IConditionalOrder::ConditionalOrderParams,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "ConditionalOrderCreated(address,(address,bytes32,bytes))";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    44u8, 206u8, 172u8, 85u8, 85u8, 176u8, 202u8, 69u8, 163u8, 116u8, 76u8, 237u8,
-                    84u8, 47u8, 84u8, 181u8, 106u8, 210u8, 235u8, 69u8, 229u8, 33u8, 150u8, 35u8,
-                    114u8, 238u8, 242u8, 18u8, 162u8, 203u8, 243u8, 97u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    params: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.owner.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ConditionalOrderCreated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ConditionalOrderCreated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ConditionalOrderCreated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Deployed(address,address,address,address)` and selector `0x6707255b2c5ca81220b2f3e408a269cb83baa6aa7e5e37aa1756883a6cdf06f1`.
-    ```solidity
-    event Deployed(address indexed amm, address indexed owner, address token0, address token1);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Deployed {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token1: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Deployed {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Deployed(address,address,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    103u8, 7u8, 37u8, 91u8, 44u8, 92u8, 168u8, 18u8, 32u8, 178u8, 243u8, 228u8,
-                    8u8, 162u8, 105u8, 203u8, 131u8, 186u8, 166u8, 170u8, 126u8, 94u8, 55u8, 170u8,
-                    23u8, 86u8, 136u8, 58u8, 108u8, 223u8, 6u8, 241u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    amm: topics.1,
-                    owner: topics.2,
-                    token0: data.0,
-                    token1: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token1,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.amm.clone(),
-                    self.owner.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.amm,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Deployed {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Deployed> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Deployed) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TradingDisabled(address)` and selector `0xc75bf4f03c02fab9414a7d7a54048c0486722bc72f33ad924709a0593608ad27`.
-    ```solidity
-    event TradingDisabled(address indexed amm);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TradingDisabled {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TradingDisabled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "TradingDisabled(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    199u8, 91u8, 244u8, 240u8, 60u8, 2u8, 250u8, 185u8, 65u8, 74u8, 125u8, 122u8,
-                    84u8, 4u8, 140u8, 4u8, 134u8, 114u8, 43u8, 199u8, 47u8, 51u8, 173u8, 146u8,
-                    71u8, 9u8, 160u8, 89u8, 54u8, 8u8, 173u8, 39u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { amm: topics.1 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.amm.clone())
-            }
+}
 
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.amm,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TradingDisabled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
+interface CowAmmConstantProductFactory {
+    error OnlyOwnerCanCall(address owner);
+    error OrderNotValid(string);
+
+    event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params);
+    event Deployed(address indexed amm, address indexed owner, address token0, address token1);
+    event TradingDisabled(address indexed amm);
 
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TradingDisabled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TradingDisabled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
     constructor(address _settler);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub _settler: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value._settler,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _settler: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
+    function ammDeterministicAddress(address ammOwner, address token0, address token1) external view returns (address);
+    function create(address token0, uint256 amount0, address token1, uint256 amount1, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external returns (address amm);
+    function deposit(address amm, uint256 amount0, uint256 amount1) external;
+    function owner(address) external view returns (address);
+    function withdraw(address amm, uint256 amount0, uint256 amount1) external;
+}
+```
 
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._settler,
-                    ),
-                )
-            }
-        }
-    };
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_settler",
+        "type": "address",
+        "internalType": "contract ISettlement"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "ammDeterministicAddress",
+    "inputs": [
+      {
+        "name": "ammOwner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "token0",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "internalType": "contract IERC20"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "create",
+    "inputs": [
+      {
+        "name": "token0",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "minTradedToken0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "priceOracle",
+        "type": "address",
+        "internalType": "contract IPriceOracle"
+      },
+      {
+        "name": "priceOracleData",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "appData",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "deposit",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "withdraw",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "amount0",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amount1",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "ConditionalOrderCreated",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "params",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct IConditionalOrder.ConditionalOrderParams",
+        "components": [
+          {
+            "name": "handler",
+            "type": "address",
+            "internalType": "contract IConditionalOrder"
+          },
+          {
+            "name": "salt",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "staticInput",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Deployed",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract ConstantProduct"
+      },
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token0",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20"
+      },
+      {
+        "name": "token1",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TradingDisabled",
+    "inputs": [
+      {
+        "name": "amm",
+        "type": "address",
+        "indexed": true,
+        "internalType": "contract ConstantProduct"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "OnlyOwnerCanCall",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "OrderNotValid",
+    "inputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod CowAmmConstantProductFactory {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xA0`@R4\x80\x15`\x0EW_\x80\xFD[P`@QaA\xB38\x03\x80aA\xB3\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW_\x80\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W_\x80\xFD[\x93\x92PPPV[`\x80QaA'a\0\x8C_9_\x81\x81a\x01\x89\x01R\x81\x81a\x02\xA8\x01Ra\x08\xC4\x01RaA'_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x9FW_5`\xE0\x1C\x80c7\xEB\xDFP\x11a\0rW\x80cfn\x1B9\x11a\0XW\x80cfn\x1B9\x14a\x01OW\x80c\xAB\"\x1Av\x14a\x01\x84W\x80c\xB5\xC5\xF6r\x14a\x01\xABW_\x80\xFD[\x80c7\xEB\xDFP\x14a\x01)W\x80c[]\x9E\xE6\x14a\x01<W_\x80\xFD[\x80c\x0E\xFEj\x8B\x14a\0\xA3W\x80c\"\xB1U\xC6\x14a\0\xB8W\x80c&\xE0\xA1\x96\x14a\0\xF5W\x80c'\x91\x05e\x14a\x01\x16W[_\x80\xFD[a\0\xB6a\0\xB16`\x04a\x11\xEAV[a\x01\xBEV[\0[a\0\xCBa\0\xC66`\x04a\x12aV[a\x02\xA3V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\x08a\x01\x036`\x04a\x12\xFBV[a\x04_V[`@Qa\0\xEC\x92\x91\x90a\x14\xFDV[a\0\xB6a\x01$6`\x04a\x15'V[a\x07\x97V[a\0\xCBa\x0176`\x04a\x15IV[a\x08/V[a\0\xB6a\x01J6`\x04a\x15\x91V[a\n\x01V[a\0\xCBa\x01]6`\x04a\x15'V[_` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\0\xCB\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB6a\x01\xB96`\x04a\x11\xEAV[a\x0B\x17V[a\x02O3\x84\x84\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x021\x91\x90a\x16\x17V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x0CFV[a\x02\x9E3\x84\x83\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPV[_3\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8B`@Qa\x02\xD5\x90a\x11\xB9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x81R\x91\x83\x16` \x83\x01R\x90\x91\x16`@\x82\x01R``\x01\x81\x90`@Q\x80\x91\x03\x90_\xF5\x90P\x80\x15\x80\x15a\x03\x1FW=_\x80>=_\xFD[P`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16\x82R\x8C\x81\x16` \x83\x01R\x92\x94P\x82\x84\x16\x92\x85\x16\x91\x7Fg\x07%[,\\\xA8\x12 \xB2\xF3\xE4\x08\xA2i\xCB\x83\xBA\xA6\xAA~^7\xAA\x17V\x88:l\xDF\x06\xF1\x91\x01`@Q\x80\x91\x03\x90\xA3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16_\x90\x81R` \x81\x90R`@\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x83\x16\x91\x90\x91\x17\x90Ua\x03\xD8\x82\x8B\x8Aa\x01\xBEV[_`@Q\x80`\x80\x01`@R\x80\x89\x81R` \x01\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x85\x90R\x90Pa\x04P\x83\x82a\x0C\xDBV[PP\x99\x98PPPPPPPPPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``0a\x04\xCF` \x89\x01\x89a\x15'V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x05QW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Fcan only handle own orders\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x05_`@\x89\x01\x89a\x162V[\x81\x01\x90a\x05l\x91\x90a\x17\\V[\x90P\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xEE\xC5\x0B\x97`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDB\x91\x90a\x18ZV[`@Q\x7F\xB0\x9A\xAA\xCA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x90c\xB0\x9A\xAA\xCA\x90a\x06-\x90\x85\x90`\x04\x01a\x18\xC3V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06HW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06l\x91\x90a\x18ZV[\x14a\x06\xD3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Finvalid trading parameters\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05HV[`@Q\x7F\xE3\xE6\xF5\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x90c\xE3\xE6\xF5\xB2\x90a\x07%\x90\x84\x90`\x04\x01a\x18\xC3V[a\x01\x80`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a\x18\xF7V[\x92P\x82\x81`@Q` \x01a\x07z\x92\x91\x90a\x19\xB3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x96P\x96\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16_\x90\x81R` \x81\x90R`@\x90 T\x82\x91\x163\x14a\x08\"Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x08+\x82a\x0E\x05V[PPV[_\x80\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16`@Qa\x08y` \x82\x01a\x11\xB9V[\x81\x81\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x01\x83R`\x1F\x90\x91\x01\x16`@\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16` \x84\x01R\x80\x8B\x16\x91\x83\x01\x91\x90\x91R\x88\x16``\x82\x01R`\x80\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\t:\x92\x91` \x01a\x19\xEBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\t\xC2\x94\x93\x92\x91\x90\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\x90\x94\x16\x84R``\x92\x90\x92\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x01\x84\x01R`\x15\x83\x01R`5\x82\x01R`U\x01\x90V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 \x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x87\x16_\x90\x81R` \x81\x90R`@\x90 T\x87\x91\x163\x14a\n\x8CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[_`@Q\x80`\x80\x01`@R\x80\x88\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x86\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x84\x90R\x90Pa\x0B\x03\x88a\x0E\x05V[a\x0B\r\x88\x82a\x0C\xDBV[PPPPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16_\x90\x81R` \x81\x90R`@\x90 T\x84\x91\x163\x14a\x0B\xA2Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x0B\xF1\x843\x85\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[a\x0C@\x843\x84\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C@\x90\x85\x90a\x0E\xA3V[`@Q\x7F\xC5\xF3\xD2T\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xC5\xF3\xD2T\x90a\r-\x90\x84\x90`\x04\x01a\x18\xC3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rDW_\x80\xFD[PZ\xF1\x15\x80\x15a\rVW=_\x80>=_\xFD[PP`@\x80Q``\x81\x01\x82R0\x81R_` \x80\x83\x01\x82\x90R\x83Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x94P\x7F,\xCE\xACUU\xB0\xCAE\xA3tL\xEDT/T\xB5j\xD2\xEBE\xE5!\x96#r\xEE\xF2\x12\xA2\xCB\xF3a\x93\x83\x01\x91a\r\xBD\x91\x88\x91\x01a\x18\xC3V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R\x91RQa\r\xF8\x91\x90a\x19\xFFV[`@Q\x80\x91\x03\x90\xA2PPPV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17p\x0F\x01`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0EJW_\x80\xFD[PZ\xF1\x15\x80\x15a\x0E\\W=_\x80>=_\xFD[PP`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x92P\x7F\xC7[\xF4\xF0<\x02\xFA\xB9AJ}zT\x04\x8C\x04\x86r+\xC7/3\xAD\x92G\t\xA0Y6\x08\xAD'\x91P_\x90\xA2PV[_a\x0F\x04\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xB0\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x80Q_\x14\x80a\x0F$WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0F$\x91\x90a\x1ACV[a\x02\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01R\x7Fot succeed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[``a\x0F\xBE\x84\x84_\x85a\x0F\xC6V[\x94\x93PPPPV[``\x82G\x10\x15a\x10XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01R\x7Fr call\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[_\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x87`@Qa\x10\x80\x91\x90a\x1A\\V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x10\xBAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x10\xBFV[``\x91P[P\x91P\x91Pa\x10\xD0\x87\x83\x83\x87a\x10\xDBV[\x97\x96PPPPPPPV[``\x83\x15a\x11pW\x82Q_\x03a\x11iWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x11iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x05HV[P\x81a\x0F\xBEV[a\x0F\xBE\x83\x83\x81Q\x15a\x11\x85W\x81Q\x80\x83` \x01\xFD[\x80`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x05H\x91\x90a\x1AgV[a&x\x80a\x1Az\x839\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xE7W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x11\xFCW_\x80\xFD[\x835a\x12\x07\x81a\x11\xC6V[\x95` \x85\x015\x95P`@\x90\x94\x015\x93\x92PPPV[_\x80\x83`\x1F\x84\x01\x12a\x12,W_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12CW_\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x12ZW_\x80\xFD[\x92P\x92\x90PV[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a\x12zW_\x80\xFD[\x895a\x12\x85\x81a\x11\xC6V[\x98P` \x8A\x015\x97P`@\x8A\x015a\x12\x9C\x81a\x11\xC6V[\x96P``\x8A\x015\x95P`\x80\x8A\x015\x94P`\xA0\x8A\x015a\x12\xBA\x81a\x11\xC6V[\x93P`\xC0\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xD5W_\x80\xFD[a\x12\xE1\x8C\x82\x8D\x01a\x12\x1CV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x95\x98\x94\x97\x96`\xE0\x015\x94\x93PPPPV[_\x80_\x80_\x80`\x80\x87\x89\x03\x12\x15a\x13\x10W_\x80\xFD[\x865a\x13\x1B\x81a\x11\xC6V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x137W_\x80\xFD[\x90\x88\x01\x90``\x82\x8B\x03\x12\x15a\x13JW_\x80\xFD[\x90\x95P`@\x88\x015\x90\x80\x82\x11\x15a\x13_W_\x80\xFD[a\x13k\x8A\x83\x8B\x01a\x12\x1CV[\x90\x96P\x94P``\x89\x015\x91P\x80\x82\x11\x15a\x13\x83W_\x80\xFD[\x81\x89\x01\x91P\x89`\x1F\x83\x01\x12a\x13\x96W_\x80\xFD[\x815\x81\x81\x11\x15a\x13\xA4W_\x80\xFD[\x8A` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x13\xB8W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa\x14\x0F` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa\x147`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa\x14c`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa\x14\x98\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_a\x01\xA0a\x15\x0B\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x14\xB1V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x157W_\x80\xFD[\x815a\x15B\x81a\x11\xC6V[\x93\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a\x15[W_\x80\xFD[\x835a\x15f\x81a\x11\xC6V[\x92P` \x84\x015a\x15v\x81a\x11\xC6V[\x91P`@\x84\x015a\x15\x86\x81a\x11\xC6V[\x80\x91PP\x92P\x92P\x92V[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a\x15\xA6W_\x80\xFD[\x865a\x15\xB1\x81a\x11\xC6V[\x95P` \x87\x015\x94P`@\x87\x015a\x15\xC8\x81a\x11\xC6V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xE3W_\x80\xFD[a\x15\xEF\x89\x82\x8A\x01a\x12\x1CV[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95`\x80\x90\x95\x015\x94\x93PPPPV[\x80Qa\x16\x12\x81a\x11\xC6V[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16'W_\x80\xFD[\x81Qa\x15B\x81a\x11\xC6V[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x16eW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16\x7FW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x12ZW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17TWa\x17Ta\x16\x93V[`@R\x91\x90PV[_` \x80\x83\x85\x03\x12\x15a\x17mW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x84W_\x80\xFD[\x90\x84\x01\x90`\x80\x82\x87\x03\x12\x15a\x17\x97W_\x80\xFD[a\x17\x9Fa\x16\xC0V[\x825\x81R\x83\x83\x015a\x17\xB0\x81a\x11\xC6V[\x81\x85\x01R`@\x83\x015\x82\x81\x11\x15a\x17\xC5W_\x80\xFD[\x83\x01`\x1F\x81\x01\x88\x13a\x17\xD5W_\x80\xFD[\x805\x83\x81\x11\x15a\x17\xE7Wa\x17\xE7a\x16\x93V[a\x18\x17\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\rV[\x93P\x80\x84R\x88\x86\x82\x84\x01\x01\x11\x15a\x18,W_\x80\xFD[\x80\x86\x83\x01\x87\x86\x017_\x86\x82\x86\x01\x01RPP\x81`@\x82\x01R``\x83\x015``\x82\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x18jW_\x80\xFD[PQ\x91\x90PV[\x80Q\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x83\x01R_`@\x82\x01Q`\x80`@\x85\x01Ra\x18\xAF`\x80\x85\x01\x82a\x14\xB1V[``\x93\x84\x01Q\x94\x90\x93\x01\x93\x90\x93RP\x91\x90PV[` \x81R_a\x15B` \x83\x01\x84a\x18qV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x16\x12W_\x80\xFD[\x80Q\x80\x15\x15\x81\x14a\x16\x12W_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19\x08W_\x80\xFD[a\x19\x10a\x16\xE9V[a\x19\x19\x83a\x16\x07V[\x81Ra\x19'` \x84\x01a\x16\x07V[` \x82\x01Ra\x198`@\x84\x01a\x16\x07V[`@\x82\x01R``\x83\x01Q``\x82\x01R`\x80\x83\x01Q`\x80\x82\x01Ra\x19]`\xA0\x84\x01a\x18\xD5V[`\xA0\x82\x01R`\xC0\x83\x01Q`\xC0\x82\x01R`\xE0\x83\x01Q`\xE0\x82\x01Ra\x01\0\x80\x84\x01Q\x81\x83\x01RPa\x01 a\x19\x90\x81\x85\x01a\x18\xE8V[\x90\x82\x01Ra\x01@\x83\x81\x01Q\x90\x82\x01Ra\x01`\x92\x83\x01Q\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_a\x01\xA0a\x19\xC1\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x18qV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0F\xBEa\x19\xF9\x83\x86a\x19\xD4V[\x84a\x19\xD4V[` \x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82Q\x16` \x82\x01R` \x82\x01Q`@\x82\x01R_`@\x83\x01Q``\x80\x84\x01Ra\x0F\xBE`\x80\x84\x01\x82a\x14\xB1V[_` \x82\x84\x03\x12\x15a\x1ASW_\x80\xFD[a\x15B\x82a\x18\xE8V[_a\x15B\x82\x84a\x19\xD4V[` \x81R_a\x15B` \x83\x01\x84a\x14\xB1V\xFEa\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003\xA2dipfsX\"\x12 \x11\x90\xCFB\xF9\x89\xCE\xE2?\x12Y|\x8C\x1E\x9D\xAA\xB6\xD8\xC8\x16Q3I\xC3\xCE\x7F\xD2)\xCA\xE5\xB0\xFFdsolcC\0\x08\x19\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x608060405234801561000f575f80fd5b506004361061009f575f3560e01c806337ebdf5011610072578063666e1b3911610058578063666e1b391461014f578063ab221a7614610184578063b5c5f672146101ab575f80fd5b806337ebdf50146101295780635b5d9ee61461013c575f80fd5b80630efe6a8b146100a357806322b155c6146100b857806326e0a196146100f55780632791056514610116575b5f80fd5b6100b66100b13660046111ea565b6101be565b005b6100cb6100c6366004611261565b6102a3565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6101086101033660046112fb565b61045f565b6040516100ec9291906114fd565b6100b6610124366004611527565b610797565b6100cb610137366004611549565b61082f565b6100b661014a366004611591565b610a01565b6100cb61015d366004611527565b5f6020819052908152604090205473ffffffffffffffffffffffffffffffffffffffff1681565b6100cb7f000000000000000000000000000000000000000000000000000000000000000081565b6100b66101b93660046111ea565b610b17565b61024f3384848673ffffffffffffffffffffffffffffffffffffffff16630dfe16816040518163ffffffff1660e01b8152600401602060405180830381865afa15801561020d573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102319190611617565b73ffffffffffffffffffffffffffffffffffffffff16929190610c46565b61029e3384838673ffffffffffffffffffffffffffffffffffffffff1663d21220a76040518163ffffffff1660e01b8152600401602060405180830381865afa15801561020d573d5f803e3d5ffd5b505050565b5f33807f00000000000000000000000000000000000000000000000000000000000000008c8b6040516102d5906111b9565b73ffffffffffffffffffffffffffffffffffffffff9384168152918316602083015290911660408201526060018190604051809103905ff590508015801561031f573d5f803e3d5ffd5b506040805173ffffffffffffffffffffffffffffffffffffffff8e811682528c81166020830152929450828416928516917f6707255b2c5ca81220b2f3e408a269cb83baa6aa7e5e37aa1756883a6cdf06f1910160405180910390a373ffffffffffffffffffffffffffffffffffffffff8281165f90815260208190526040902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169183169190911790556103d8828b8a6101be565b5f60405180608001604052808981526020018873ffffffffffffffffffffffffffffffffffffffff16815260200187878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050509082525060200185905290506104508382610cdb565b50509998505050505050505050565b60408051610180810182525f80825260208201819052918101829052606081018290526080810182905260a0810182905260c0810182905260e081018290526101008101829052610120810182905261014081018290526101608101919091526060306104cf6020890189611527565b73ffffffffffffffffffffffffffffffffffffffff1614610551576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f63616e206f6e6c792068616e646c65206f776e206f726465727300000000000060448201526064015b60405180910390fd5b5f61055f6040890189611632565b81019061056c919061175c565b90508873ffffffffffffffffffffffffffffffffffffffff1663eec50b976040518163ffffffff1660e01b8152600401602060405180830381865afa1580156105b7573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105db919061185a565b6040517fb09aaaca00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8b169063b09aaaca9061062d9085906004016118c3565b602060405180830381865afa158015610648573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061066c919061185a565b146106d3576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f696e76616c69642074726164696e6720706172616d65746572730000000000006044820152606401610548565b6040517fe3e6f5b200000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8a169063e3e6f5b2906107259084906004016118c3565b61018060405180830381865afa158015610741573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061076591906118f7565b9250828160405160200161077a9291906119b3565b604051602081830303815290604052915050965096945050505050565b73ffffffffffffffffffffffffffffffffffffffff8082165f9081526020819052604090205482911633146108225773ffffffffffffffffffffffffffffffffffffffff8181165f90815260208190526040908190205490517f68bafff800000000000000000000000000000000000000000000000000000000815291166004820152602401610548565b61082b82610e05565b5050565b5f807fff000000000000000000000000000000000000000000000000000000000000003073ffffffffffffffffffffffffffffffffffffffff8716604051610879602082016111b9565b8181037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09081018352601f90910116604081815273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000081166020840152808b169183019190915288166060820152608001604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529082905261093a92916020016119eb565b604051602081830303815290604052805190602001206040516020016109c294939291907fff0000000000000000000000000000000000000000000000000000000000000094909416845260609290921b7fffffffffffffffffffffffffffffffffffffffff0000000000000000000000001660018401526015830152603582015260550190565b604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0018152919052805160209091012095945050505050565b73ffffffffffffffffffffffffffffffffffffffff8087165f908152602081905260409020548791163314610a8c5773ffffffffffffffffffffffffffffffffffffffff8181165f90815260208190526040908190205490517f68bafff800000000000000000000000000000000000000000000000000000000815291166004820152602401610548565b5f60405180608001604052808881526020018773ffffffffffffffffffffffffffffffffffffffff16815260200186868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152505050908252506020018490529050610b0388610e05565b610b0d8882610cdb565b5050505050505050565b73ffffffffffffffffffffffffffffffffffffffff8084165f908152602081905260409020548491163314610ba25773ffffffffffffffffffffffffffffffffffffffff8181165f90815260208190526040908190205490517f68bafff800000000000000000000000000000000000000000000000000000000815291166004820152602401610548565b610bf18433858773ffffffffffffffffffffffffffffffffffffffff16630dfe16816040518163ffffffff1660e01b8152600401602060405180830381865afa15801561020d573d5f803e3d5ffd5b610c408433848773ffffffffffffffffffffffffffffffffffffffff1663d21220a76040518163ffffffff1660e01b8152600401602060405180830381865afa15801561020d573d5f803e3d5ffd5b50505050565b6040805173ffffffffffffffffffffffffffffffffffffffff85811660248301528416604482015260648082018490528251808303909101815260849091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f23b872dd00000000000000000000000000000000000000000000000000000000179052610c40908590610ea3565b6040517fc5f3d25400000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83169063c5f3d25490610d2d9084906004016118c3565b5f604051808303815f87803b158015610d44575f80fd5b505af1158015610d56573d5f803e3d5ffd5b5050604080516060810182523081525f6020808301829052835191955073ffffffffffffffffffffffffffffffffffffffff881694507f2cceac5555b0ca45a3744ced542f54b56ad2eb45e521962372eef212a2cbf36193830191610dbd918891016118c3565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152915251610df891906119ff565b60405180910390a2505050565b8073ffffffffffffffffffffffffffffffffffffffff166317700f016040518163ffffffff1660e01b81526004015f604051808303815f87803b158015610e4a575f80fd5b505af1158015610e5c573d5f803e3d5ffd5b505060405173ffffffffffffffffffffffffffffffffffffffff841692507fc75bf4f03c02fab9414a7d7a54048c0486722bc72f33ad924709a0593608ad2791505f90a250565b5f610f04826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16610fb09092919063ffffffff16565b905080515f1480610f24575080806020019051810190610f249190611a43565b61029e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610548565b6060610fbe84845f85610fc6565b949350505050565b606082471015611058576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610548565b5f808673ffffffffffffffffffffffffffffffffffffffff1685876040516110809190611a5c565b5f6040518083038185875af1925050503d805f81146110ba576040519150601f19603f3d011682016040523d82523d5f602084013e6110bf565b606091505b50915091506110d0878383876110db565b979650505050505050565b606083156111705782515f036111695773ffffffffffffffffffffffffffffffffffffffff85163b611169576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610548565b5081610fbe565b610fbe83838151156111855781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105489190611a67565b61267880611a7a83390190565b73ffffffffffffffffffffffffffffffffffffffff811681146111e7575f80fd5b50565b5f805f606084860312156111fc575f80fd5b8335611207816111c6565b95602085013595506040909401359392505050565b5f8083601f84011261122c575f80fd5b50813567ffffffffffffffff811115611243575f80fd5b60208301915083602082850101111561125a575f80fd5b9250929050565b5f805f805f805f805f6101008a8c03121561127a575f80fd5b8935611285816111c6565b985060208a0135975060408a013561129c816111c6565b965060608a0135955060808a0135945060a08a01356112ba816111c6565b935060c08a013567ffffffffffffffff8111156112d5575f80fd5b6112e18c828d0161121c565b9a9d999c50979a9699959894979660e00135949350505050565b5f805f805f8060808789031215611310575f80fd5b863561131b816111c6565b9550602087013567ffffffffffffffff80821115611337575f80fd5b908801906060828b03121561134a575f80fd5b9095506040880135908082111561135f575f80fd5b61136b8a838b0161121c565b90965094506060890135915080821115611383575f80fd5b818901915089601f830112611396575f80fd5b8135818111156113a4575f80fd5b8a60208260051b85010111156113b8575f80fd5b6020830194508093505050509295509295509295565b805173ffffffffffffffffffffffffffffffffffffffff168252602081015161140f602084018273ffffffffffffffffffffffffffffffffffffffff169052565b506040810151611437604084018273ffffffffffffffffffffffffffffffffffffffff169052565b50606081015160608301526080810151608083015260a081015161146360a084018263ffffffff169052565b5060c081015160c083015260e081015160e0830152610100808201518184015250610120808201516114988285018215159052565b5050610140818101519083015261016090810151910152565b5f81518084528060208401602086015e5f6020828601015260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011685010191505092915050565b5f6101a061150b83866113ce565b8061018084015261151e818401856114b1565b95945050505050565b5f60208284031215611537575f80fd5b8135611542816111c6565b9392505050565b5f805f6060848603121561155b575f80fd5b8335611566816111c6565b92506020840135611576816111c6565b91506040840135611586816111c6565b809150509250925092565b5f805f805f8060a087890312156115a6575f80fd5b86356115b1816111c6565b95506020870135945060408701356115c8816111c6565b9350606087013567ffffffffffffffff8111156115e3575f80fd5b6115ef89828a0161121c565b979a9699509497949695608090950135949350505050565b8051611612816111c6565b919050565b5f60208284031215611627575f80fd5b8151611542816111c6565b5f8083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112611665575f80fd5b83018035915067ffffffffffffffff82111561167f575f80fd5b60200191503681900382131561125a575f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516080810167ffffffffffffffff811182821017156116e3576116e3611693565b60405290565b604051610180810167ffffffffffffffff811182821017156116e3576116e3611693565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff8111828210171561175457611754611693565b604052919050565b5f602080838503121561176d575f80fd5b823567ffffffffffffffff80821115611784575f80fd5b9084019060808287031215611797575f80fd5b61179f6116c0565b82358152838301356117b0816111c6565b818501526040830135828111156117c5575f80fd5b8301601f810188136117d5575f80fd5b8035838111156117e7576117e7611693565b611817867fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8401160161170d565b9350808452888682840101111561182c575f80fd5b80868301878601375f8682860101525050816040820152606083013560608201528094505050505092915050565b5f6020828403121561186a575f80fd5b5051919050565b8051825273ffffffffffffffffffffffffffffffffffffffff60208201511660208301525f6040820151608060408501526118af60808501826114b1565b606093840151949093019390935250919050565b602081525f6115426020830184611871565b805163ffffffff81168114611612575f80fd5b80518015158114611612575f80fd5b5f6101808284031215611908575f80fd5b6119106116e9565b61191983611607565b815261192760208401611607565b602082015261193860408401611607565b6040820152606083015160608201526080830151608082015261195d60a084016118d5565b60a082015260c083015160c082015260e083015160e08201526101008084015181830152506101206119908185016118e8565b908201526101408381015190820152610160928301519281019290925250919050565b5f6101a06119c183866113ce565b8061018084015261151e81840185611871565b5f81518060208401855e5f93019283525090919050565b5f610fbe6119f983866119d4565b846119d4565b6020815273ffffffffffffffffffffffffffffffffffffffff8251166020820152602082015160408201525f6040830151606080840152610fbe60808401826114b1565b5f60208284031215611a53575f80fd5b611542826118e8565b5f61154282846119d4565b602081525f61154260208301846114b156fe610120604052348015610010575f80fd5b5060405161267838038061267883398101604081905261002f9161052f565b6001600160a01b03831660808190526040805163f698da2560e01b8152905163f698da259160048082019260209290919082900301815f875af1158015610078573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061009c9190610579565b610100526100aa823361015f565b6100b4813361015f565b336001600160a01b031660e0816001600160a01b0316815250505f836001600160a01b0316639b552cc26040518163ffffffff1660e01b81526004016020604051808303815f875af115801561010c573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101309190610590565b905061013c838261015f565b610146828261015f565b506001600160a01b0391821660a0521660c0525061061c565b6101746001600160a01b038316825f19610178565b5050565b8015806101f05750604051636eb1769f60e11b81523060048201526001600160a01b03838116602483015284169063dd62ed3e90604401602060405180830381865afa1580156101ca573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101ee9190610579565b155b6102675760405162461bcd60e51b815260206004820152603660248201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60448201527f20746f206e6f6e2d7a65726f20616c6c6f77616e63650000000000000000000060648201526084015b60405180910390fd5b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b0390811663095ea7b360e01b179091526102bd9185916102c216565b505050565b6040805180820190915260208082527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564908201525f9061030e906001600160a01b03851690849061038d565b905080515f148061032e57508080602001905181019061032e91906105b2565b6102bd5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840161025e565b606061039b84845f856103a3565b949350505050565b6060824710156104045760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b606482015260840161025e565b5f80866001600160a01b0316858760405161041f91906105d1565b5f6040518083038185875af1925050503d805f8114610459576040519150601f19603f3d011682016040523d82523d5f602084013e61045e565b606091505b5090925090506104708783838761047b565b979650505050505050565b606083156104e95782515f036104e2576001600160a01b0385163b6104e25760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161025e565b508161039b565b61039b83838151156104fe5781518083602001fd5b8060405162461bcd60e51b815260040161025e91906105e7565b6001600160a01b038116811461052c575f80fd5b50565b5f805f60608486031215610541575f80fd5b835161054c81610518565b602085015190935061055d81610518565b604085015190925061056e81610518565b809150509250925092565b5f60208284031215610589575f80fd5b5051919050565b5f602082840312156105a0575f80fd5b81516105ab81610518565b9392505050565b5f602082840312156105c2575f80fd5b815180151581146105ab575f80fd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b60805160a05160c05160e05161010051611fbd6106bb5f395f81816102db015261042b01525f8181610236015281816104d90152610bf901525f81816102b40152818161059901528181610d5c01528181610ebf01528181610f8e015261100d01525f81816101380152818161057701528181610d3b01528181610e2801528181610f6b015261103001525f818161032201526112140152611fbd5ff3fe608060405234801561000f575f80fd5b506004361061012f575f3560e01c8063b09aaaca116100ad578063e3e6f5b21161007d578063eec50b9711610063578063eec50b9714610344578063f14fcbc81461034c578063ff2dbc9814610203575f80fd5b8063e3e6f5b2146102fd578063e516715b1461031d575f80fd5b8063b09aaaca14610289578063c5f3d2541461029c578063d21220a7146102af578063d25e0cb6146102d6575f80fd5b80631c7de94111610102578063481c6a75116100e8578063481c6a7514610231578063981a160b14610258578063a029a8d414610276575f80fd5b80631c7de941146102035780633e706e321461020a575f80fd5b80630dfe1681146101335780631303a484146101845780631626ba7e146101b557806317700f01146101f9575b5f80fd5b61015a7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b7f6c3c90245457060f6517787b2c4b8cf500ca889d2304af02043bd5b513e3b5935c5b60405190815260200161017b565b6101c86101c33660046116bf565b61035f565b6040517fffffffff00000000000000000000000000000000000000000000000000000000909116815260200161017b565b6102016104d7565b005b6101a75f81565b6101a77f6c3c90245457060f6517787b2c4b8cf500ca889d2304af02043bd5b513e3b59381565b61015a7f000000000000000000000000000000000000000000000000000000000000000081565b61026161012c81565b60405163ffffffff909116815260200161017b565b6102016102843660046119ee565b610573565b6101a7610297366004611a3b565b610bc8565b6102016102aa366004611a75565b610bf7565b61015a7f000000000000000000000000000000000000000000000000000000000000000081565b6101a77f000000000000000000000000000000000000000000000000000000000000000081565b61031061030b366004611a3b565b610cb7565b60405161017b9190611aac565b61015a7f000000000000000000000000000000000000000000000000000000000000000081565b6101a75f5481565b61020161035a366004611b9a565b6111fc565b5f808061036e84860186611bb1565b915091505f5461037d82610bc8565b146103b4576040517ff1a6789000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0820180517fd5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e48982526101a0822091526040517f190100000000000000000000000000000000000000000000000000000000000081527f00000000000000000000000000000000000000000000000000000000000000006002820152602281019190915260429020868114610494576040517f593fcacd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61049f818385611291565b6104a98284610573565b507f1626ba7e00000000000000000000000000000000000000000000000000000000925050505b9392505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163314610546576040517ff87d0d1600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f8080556040517fbcb8b8fbdea8aa6dc4ae41213e4da81e605a3d1a56ed851b9355182321c091909190a1565b80517f0000000000000000000000000000000000000000000000000000000000000000907f00000000000000000000000000000000000000000000000000000000000000009073ffffffffffffffffffffffffffffffffffffffff808416911614610677578073ffffffffffffffffffffffffffffffffffffffff16835f015173ffffffffffffffffffffffffffffffffffffffff1614610675576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f696e76616c69642073656c6c20746f6b656e000000000000000000000000000060448201526064015b60405180910390fd5b905b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201525f9073ffffffffffffffffffffffffffffffffffffffff8416906370a0823190602401602060405180830381865afa1580156106e1573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107059190611bff565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8416906370a0823190602401602060405180830381865afa158015610772573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107969190611bff565b90508273ffffffffffffffffffffffffffffffffffffffff16856020015173ffffffffffffffffffffffffffffffffffffffff1614610831576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601160248201527f696e76616c69642062757920746f6b656e000000000000000000000000000000604482015260640161066c565b604085015173ffffffffffffffffffffffffffffffffffffffff16156108b3576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f7265636569766572206d757374206265207a65726f2061646472657373000000604482015260640161066c565b6108bf61012c42611c43565b8560a0015163ffffffff161115610932576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f76616c696469747920746f6f2066617220696e20746865206675747572650000604482015260640161066c565b85606001518560c00151146109a3576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152600f60248201527f696e76616c696420617070446174610000000000000000000000000000000000604482015260640161066c565b60e085015115610a0f576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f66656520616d6f756e74206d757374206265207a65726f000000000000000000604482015260640161066c565b7f5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc985610160015114610a9d576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f627579546f6b656e42616c616e6365206d757374206265206572633230000000604482015260640161066c565b7f5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc985610140015114610b2b576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f73656c6c546f6b656e42616c616e6365206d7573742062652065726332300000604482015260640161066c565b6060850151610b3a9082611c56565b60808601516060870151610b4e9085611c6d565b610b589190611c56565b1015610bc0576040517fc8fc272500000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f726563656976656420616d6f756e7420746f6f206c6f77000000000000000000604482015260640161066c565b505050505050565b5f81604051602001610bda9190611ccc565b604051602081830303815290604052805190602001209050919050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163314610c66576040517ff87d0d1600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f610c7361029783611d27565b9050805f81905550807f510e4a4f76907c2d6158b343f7c4f2f597df385b727c26e9ef90e75093ace19a83604051610cab9190611d79565b60405180910390a25050565b60408051610180810182525f80825260208201819052918101829052606081018290526080810182905260a0810182905260c0810182905260e081018290526101008101829052610120810182905261014081018290526101608101919091525f80836020015173ffffffffffffffffffffffffffffffffffffffff1663355efdd97f00000000000000000000000000000000000000000000000000000000000000007f000000000000000000000000000000000000000000000000000000000000000087604001516040518463ffffffff1660e01b8152600401610d9e93929190611e3a565b6040805180830381865afa158015610db8573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ddc9190611e72565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015291935091505f90819073ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015610e6d573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e919190611bff565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201527f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16906370a0823190602401602060405180830381865afa158015610f19573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f3d9190611bff565b90925090505f80808080610f518888611c56565b90505f610f5e8a88611c56565b90505f8282101561100b577f000000000000000000000000000000000000000000000000000000000000000096507f00000000000000000000000000000000000000000000000000000000000000009550610fd6610fbd60028b611ec1565b610fd184610fcc8e6002611c56565b611346565b61137e565b945061100185610fe6818d611c56565b610ff09085611c43565b610ffa8c8f611c56565b60016113cb565b9350849050611098565b7f000000000000000000000000000000000000000000000000000000000000000096507f0000000000000000000000000000000000000000000000000000000000000000955061106e61105f60028a611ec1565b610fd185610fcc8f6002611c56565b94506110928561107e818e611c56565b6110889086611c43565b610ffa8b8e611c56565b93508390505b8c518110156110df576110df6040518060400160405280601781526020017f74726164656420616d6f756e7420746f6f20736d616c6c000000000000000000815250611426565b6040518061018001604052808873ffffffffffffffffffffffffffffffffffffffff1681526020018773ffffffffffffffffffffffffffffffffffffffff1681526020015f73ffffffffffffffffffffffffffffffffffffffff16815260200186815260200185815260200161115661012c611466565b63ffffffff1681526020018e6060015181526020015f81526020017ff3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee34677581526020016001151581526020017f5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc981526020017f5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc98152509b505050505050505050505050919050565b3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000161461126b576040517fbf84897700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b807f6c3c90245457060f6517787b2c4b8cf500ca889d2304af02043bd5b513e3b5935d50565b7f6c3c90245457060f6517787b2c4b8cf500ca889d2304af02043bd5b513e3b5935c8381146113405780156112f2576040517fdafbdd1f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f6112fc84610cb7565b90506113088382611487565b61133e576040517fd9ff24c700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505b50505050565b5f82156113735781611359600185611c6d565b6113639190611ec1565b61136e906001611c43565b611375565b5f5b90505b92915050565b5f818310156113c5576113c56040518060400160405280601581526020017f7375627472616374696f6e20756e646572666c6f770000000000000000000000815250611426565b50900390565b5f806113d8868686611599565b905060018360028111156113ee576113ee611ed4565b14801561140a57505f848061140557611405611e94565b868809115b1561141d5761141a600182611c43565b90505b95945050505050565b611431436001611c43565b816040517f1fe8506e00000000000000000000000000000000000000000000000000000000815260040161066c929190611f01565b5f81806114738142611f19565b61147d9190611f3b565b6113789190611f63565b5f80825f015173ffffffffffffffffffffffffffffffffffffffff16845f015173ffffffffffffffffffffffffffffffffffffffff161490505f836020015173ffffffffffffffffffffffffffffffffffffffff16856020015173ffffffffffffffffffffffffffffffffffffffff161490505f846060015186606001511490505f856080015187608001511490505f8660a0015163ffffffff168860a0015163ffffffff161490505f8761010001518961010001511490505f88610120015115158a6101200151151514905086801561155e5750855b80156115675750845b80156115705750835b80156115795750825b80156115825750815b801561158b5750805b9a9950505050505050505050565b5f80807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff858709858702925082811083820303915050805f036115ef578382816115e5576115e5611e94565b04925050506104d0565b808411611658576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601560248201527f4d6174683a206d756c446976206f766572666c6f770000000000000000000000604482015260640161066c565b5f8486880960026001871981018816978890046003810283188082028403028082028403028082028403028082028403028082028403029081029092039091025f889003889004909101858311909403939093029303949094049190911702949350505050565b5f805f604084860312156116d1575f80fd5b83359250602084013567ffffffffffffffff808211156116ef575f80fd5b818601915086601f830112611702575f80fd5b813581811115611710575f80fd5b876020828501011115611721575f80fd5b6020830194508093505050509250925092565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516080810167ffffffffffffffff8111828210171561178457611784611734565b60405290565b604051610180810167ffffffffffffffff8111828210171561178457611784611734565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff811182821017156117f5576117f5611734565b604052919050565b73ffffffffffffffffffffffffffffffffffffffff8116811461181e575f80fd5b50565b5f60808284031215611831575f80fd5b611839611761565b90508135815260208083013561184e816117fd565b82820152604083013567ffffffffffffffff8082111561186c575f80fd5b818501915085601f83011261187f575f80fd5b81358181111561189157611891611734565b6118c1847fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116016117ae565b915080825286848285010111156118d6575f80fd5b80848401858401375f848284010152508060408501525050506060820135606082015292915050565b803561190a816117fd565b919050565b803563ffffffff8116811461190a575f80fd5b8035801515811461190a575f80fd5b5f6101808284031215611942575f80fd5b61194a61178a565b9050611955826118ff565b8152611963602083016118ff565b6020820152611974604083016118ff565b6040820152606082013560608201526080820135608082015261199960a0830161190f565b60a082015260c082013560c082015260e082013560e08201526101008083013581830152506101206119cc818401611922565b9082015261014082810135908201526101609182013591810191909152919050565b5f806101a08385031215611a00575f80fd5b823567ffffffffffffffff811115611a16575f80fd5b611a2285828601611821565b925050611a328460208501611931565b90509250929050565b5f60208284031215611a4b575f80fd5b813567ffffffffffffffff811115611a61575f80fd5b611a6d84828501611821565b949350505050565b5f60208284031215611a85575f80fd5b813567ffffffffffffffff811115611a9b575f80fd5b8201608081850312156104d0575f80fd5b815173ffffffffffffffffffffffffffffffffffffffff16815261018081016020830151611af2602084018273ffffffffffffffffffffffffffffffffffffffff169052565b506040830151611b1a604084018273ffffffffffffffffffffffffffffffffffffffff169052565b50606083015160608301526080830151608083015260a0830151611b4660a084018263ffffffff169052565b5060c083015160c083015260e083015160e083015261010080840151818401525061012080840151611b7b8285018215159052565b5050610140838101519083015261016092830151929091019190915290565b5f60208284031215611baa575f80fd5b5035919050565b5f806101a08385031215611bc3575f80fd5b611bcd8484611931565b915061018083013567ffffffffffffffff811115611be9575f80fd5b611bf585828601611821565b9150509250929050565b5f60208284031215611c0f575f80fd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b8082018082111561137857611378611c16565b808202811582820484141761137857611378611c16565b8181038181111561137857611378611c16565b5f81518084528060208401602086015e5f6020828601015260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011685010191505092915050565b602081528151602082015273ffffffffffffffffffffffffffffffffffffffff60208301511660408201525f604083015160806060840152611d1160a0840182611c80565b9050606084015160808401528091505092915050565b5f6113783683611821565b81835281816020850137505f602082840101525f60207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b60208152813560208201525f6020830135611d93816117fd565b73ffffffffffffffffffffffffffffffffffffffff811660408401525060408301357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112611de4575f80fd5b830160208101903567ffffffffffffffff811115611e00575f80fd5b803603821315611e0e575f80fd5b60806060850152611e2360a085018284611d32565b915050606084013560808401528091505092915050565b5f73ffffffffffffffffffffffffffffffffffffffff80861683528085166020840152506060604083015261141d6060830184611c80565b5f8060408385031215611e83575f80fd5b505080516020909101519092909150565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f82611ecf57611ecf611e94565b500490565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffd5b828152604060208201525f611a6d6040830184611c80565b5f63ffffffff80841680611f2f57611f2f611e94565b92169190910492915050565b63ffffffff818116838216028082169190828114611f5b57611f5b611c16565b505092915050565b63ffffffff818116838216019080821115611f8057611f80611c16565b509291505056fea2646970667358221220e3fb228b525d90b942c7e58fe2e2034a17bd258c082fd47740e764a7be45bac664736f6c63430008190033a26469706673582212201190cf42f989cee23f12597c8c1e9daab6d8c816513349c3ce7fd229cae5b0ff64736f6c63430008190033
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x9FW_5`\xE0\x1C\x80c7\xEB\xDFP\x11a\0rW\x80cfn\x1B9\x11a\0XW\x80cfn\x1B9\x14a\x01OW\x80c\xAB\"\x1Av\x14a\x01\x84W\x80c\xB5\xC5\xF6r\x14a\x01\xABW_\x80\xFD[\x80c7\xEB\xDFP\x14a\x01)W\x80c[]\x9E\xE6\x14a\x01<W_\x80\xFD[\x80c\x0E\xFEj\x8B\x14a\0\xA3W\x80c\"\xB1U\xC6\x14a\0\xB8W\x80c&\xE0\xA1\x96\x14a\0\xF5W\x80c'\x91\x05e\x14a\x01\x16W[_\x80\xFD[a\0\xB6a\0\xB16`\x04a\x11\xEAV[a\x01\xBEV[\0[a\0\xCBa\0\xC66`\x04a\x12aV[a\x02\xA3V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\x08a\x01\x036`\x04a\x12\xFBV[a\x04_V[`@Qa\0\xEC\x92\x91\x90a\x14\xFDV[a\0\xB6a\x01$6`\x04a\x15'V[a\x07\x97V[a\0\xCBa\x0176`\x04a\x15IV[a\x08/V[a\0\xB6a\x01J6`\x04a\x15\x91V[a\n\x01V[a\0\xCBa\x01]6`\x04a\x15'V[_` \x81\x90R\x90\x81R`@\x90 Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\0\xCB\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB6a\x01\xB96`\x04a\x11\xEAV[a\x0B\x17V[a\x02O3\x84\x84\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x021\x91\x90a\x16\x17V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x0CFV[a\x02\x9E3\x84\x83\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPV[_3\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8B`@Qa\x02\xD5\x90a\x11\xB9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x81R\x91\x83\x16` \x83\x01R\x90\x91\x16`@\x82\x01R``\x01\x81\x90`@Q\x80\x91\x03\x90_\xF5\x90P\x80\x15\x80\x15a\x03\x1FW=_\x80>=_\xFD[P`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8E\x81\x16\x82R\x8C\x81\x16` \x83\x01R\x92\x94P\x82\x84\x16\x92\x85\x16\x91\x7Fg\x07%[,\\\xA8\x12 \xB2\xF3\xE4\x08\xA2i\xCB\x83\xBA\xA6\xAA~^7\xAA\x17V\x88:l\xDF\x06\xF1\x91\x01`@Q\x80\x91\x03\x90\xA3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16_\x90\x81R` \x81\x90R`@\x90 \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91\x83\x16\x91\x90\x91\x17\x90Ua\x03\xD8\x82\x8B\x8Aa\x01\xBEV[_`@Q\x80`\x80\x01`@R\x80\x89\x81R` \x01\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x85\x90R\x90Pa\x04P\x83\x82a\x0C\xDBV[PP\x99\x98PPPPPPPPPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R``0a\x04\xCF` \x89\x01\x89a\x15'V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x05QW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Fcan only handle own orders\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x05_`@\x89\x01\x89a\x162V[\x81\x01\x90a\x05l\x91\x90a\x17\\V[\x90P\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xEE\xC5\x0B\x97`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDB\x91\x90a\x18ZV[`@Q\x7F\xB0\x9A\xAA\xCA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8B\x16\x90c\xB0\x9A\xAA\xCA\x90a\x06-\x90\x85\x90`\x04\x01a\x18\xC3V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06HW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06l\x91\x90a\x18ZV[\x14a\x06\xD3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7Finvalid trading parameters\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05HV[`@Q\x7F\xE3\xE6\xF5\xB2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x90c\xE3\xE6\xF5\xB2\x90a\x07%\x90\x84\x90`\x04\x01a\x18\xC3V[a\x01\x80`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a\x18\xF7V[\x92P\x82\x81`@Q` \x01a\x07z\x92\x91\x90a\x19\xB3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x96P\x96\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16_\x90\x81R` \x81\x90R`@\x90 T\x82\x91\x163\x14a\x08\"Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x08+\x82a\x0E\x05V[PPV[_\x80\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16`@Qa\x08y` \x82\x01a\x11\xB9V[\x81\x81\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x81\x01\x83R`\x1F\x90\x91\x01\x16`@\x81\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16` \x84\x01R\x80\x8B\x16\x91\x83\x01\x91\x90\x91R\x88\x16``\x82\x01R`\x80\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\t:\x92\x91` \x01a\x19\xEBV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\t\xC2\x94\x93\x92\x91\x90\x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\x90\x94\x16\x84R``\x92\x90\x92\x1B\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\x16`\x01\x84\x01R`\x15\x83\x01R`5\x82\x01R`U\x01\x90V[`@\x80Q\x80\x83\x03\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 \x95\x94PPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x87\x16_\x90\x81R` \x81\x90R`@\x90 T\x87\x91\x163\x14a\n\x8CWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[_`@Q\x80`\x80\x01`@R\x80\x88\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x86\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPPP\x90\x82RP` \x01\x84\x90R\x90Pa\x0B\x03\x88a\x0E\x05V[a\x0B\r\x88\x82a\x0C\xDBV[PPPPPPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16_\x90\x81R` \x81\x90R`@\x90 T\x84\x91\x163\x14a\x0B\xA2Ws\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16_\x90\x81R` \x81\x90R`@\x90\x81\x90 T\x90Q\x7Fh\xBA\xFF\xF8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x91\x16`\x04\x82\x01R`$\x01a\x05HV[a\x0B\xF1\x843\x85\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[a\x0C@\x843\x84\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\rW=_\x80>=_\xFD[PPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C@\x90\x85\x90a\x0E\xA3V[`@Q\x7F\xC5\xF3\xD2T\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xC5\xF3\xD2T\x90a\r-\x90\x84\x90`\x04\x01a\x18\xC3V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rDW_\x80\xFD[PZ\xF1\x15\x80\x15a\rVW=_\x80>=_\xFD[PP`@\x80Q``\x81\x01\x82R0\x81R_` \x80\x83\x01\x82\x90R\x83Q\x91\x95Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x16\x94P\x7F,\xCE\xACUU\xB0\xCAE\xA3tL\xEDT/T\xB5j\xD2\xEBE\xE5!\x96#r\xEE\xF2\x12\xA2\xCB\xF3a\x93\x83\x01\x91a\r\xBD\x91\x88\x91\x01a\x18\xC3V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x81R\x91RQa\r\xF8\x91\x90a\x19\xFFV[`@Q\x80\x91\x03\x90\xA2PPPV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17p\x0F\x01`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0EJW_\x80\xFD[PZ\xF1\x15\x80\x15a\x0E\\W=_\x80>=_\xFD[PP`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x92P\x7F\xC7[\xF4\xF0<\x02\xFA\xB9AJ}zT\x04\x8C\x04\x86r+\xC7/3\xAD\x92G\t\xA0Y6\x08\xAD'\x91P_\x90\xA2PV[_a\x0F\x04\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xB0\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x80Q_\x14\x80a\x0F$WP\x80\x80` \x01\x90Q\x81\x01\x90a\x0F$\x91\x90a\x1ACV[a\x02\x9EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01R\x7Fot succeed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[``a\x0F\xBE\x84\x84_\x85a\x0F\xC6V[\x94\x93PPPPV[``\x82G\x10\x15a\x10XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01R\x7Fr call\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05HV[_\x80\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x87`@Qa\x10\x80\x91\x90a\x1A\\V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x10\xBAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x10\xBFV[``\x91P[P\x91P\x91Pa\x10\xD0\x87\x83\x83\x87a\x10\xDBV[\x97\x96PPPPPPPV[``\x83\x15a\x11pW\x82Q_\x03a\x11iWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x11iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x05HV[P\x81a\x0F\xBEV[a\x0F\xBE\x83\x83\x81Q\x15a\x11\x85W\x81Q\x80\x83` \x01\xFD[\x80`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x05H\x91\x90a\x1AgV[a&x\x80a\x1Az\x839\x01\x90V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x11\xE7W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x11\xFCW_\x80\xFD[\x835a\x12\x07\x81a\x11\xC6V[\x95` \x85\x015\x95P`@\x90\x94\x015\x93\x92PPPV[_\x80\x83`\x1F\x84\x01\x12a\x12,W_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12CW_\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x12ZW_\x80\xFD[\x92P\x92\x90PV[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a\x12zW_\x80\xFD[\x895a\x12\x85\x81a\x11\xC6V[\x98P` \x8A\x015\x97P`@\x8A\x015a\x12\x9C\x81a\x11\xC6V[\x96P``\x8A\x015\x95P`\x80\x8A\x015\x94P`\xA0\x8A\x015a\x12\xBA\x81a\x11\xC6V[\x93P`\xC0\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xD5W_\x80\xFD[a\x12\xE1\x8C\x82\x8D\x01a\x12\x1CV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x95\x98\x94\x97\x96`\xE0\x015\x94\x93PPPPV[_\x80_\x80_\x80`\x80\x87\x89\x03\x12\x15a\x13\x10W_\x80\xFD[\x865a\x13\x1B\x81a\x11\xC6V[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x137W_\x80\xFD[\x90\x88\x01\x90``\x82\x8B\x03\x12\x15a\x13JW_\x80\xFD[\x90\x95P`@\x88\x015\x90\x80\x82\x11\x15a\x13_W_\x80\xFD[a\x13k\x8A\x83\x8B\x01a\x12\x1CV[\x90\x96P\x94P``\x89\x015\x91P\x80\x82\x11\x15a\x13\x83W_\x80\xFD[\x81\x89\x01\x91P\x89`\x1F\x83\x01\x12a\x13\x96W_\x80\xFD[\x815\x81\x81\x11\x15a\x13\xA4W_\x80\xFD[\x8A` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x13\xB8W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92\x95P\x92\x95P\x92\x95V[\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82R` \x81\x01Qa\x14\x0F` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x81\x01Qa\x147`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x81\x01Q``\x83\x01R`\x80\x81\x01Q`\x80\x83\x01R`\xA0\x81\x01Qa\x14c`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x81\x01Q`\xC0\x83\x01R`\xE0\x81\x01Q`\xE0\x83\x01Ra\x01\0\x80\x82\x01Q\x81\x84\x01RPa\x01 \x80\x82\x01Qa\x14\x98\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x81\x81\x01Q\x90\x83\x01Ra\x01`\x90\x81\x01Q\x91\x01RV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_a\x01\xA0a\x15\x0B\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x14\xB1V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x157W_\x80\xFD[\x815a\x15B\x81a\x11\xC6V[\x93\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a\x15[W_\x80\xFD[\x835a\x15f\x81a\x11\xC6V[\x92P` \x84\x015a\x15v\x81a\x11\xC6V[\x91P`@\x84\x015a\x15\x86\x81a\x11\xC6V[\x80\x91PP\x92P\x92P\x92V[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a\x15\xA6W_\x80\xFD[\x865a\x15\xB1\x81a\x11\xC6V[\x95P` \x87\x015\x94P`@\x87\x015a\x15\xC8\x81a\x11\xC6V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xE3W_\x80\xFD[a\x15\xEF\x89\x82\x8A\x01a\x12\x1CV[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95`\x80\x90\x95\x015\x94\x93PPPPV[\x80Qa\x16\x12\x81a\x11\xC6V[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16'W_\x80\xFD[\x81Qa\x15B\x81a\x11\xC6V[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x16eW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16\x7FW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x12ZW_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xE3Wa\x16\xE3a\x16\x93V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17TWa\x17Ta\x16\x93V[`@R\x91\x90PV[_` \x80\x83\x85\x03\x12\x15a\x17mW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x17\x84W_\x80\xFD[\x90\x84\x01\x90`\x80\x82\x87\x03\x12\x15a\x17\x97W_\x80\xFD[a\x17\x9Fa\x16\xC0V[\x825\x81R\x83\x83\x015a\x17\xB0\x81a\x11\xC6V[\x81\x85\x01R`@\x83\x015\x82\x81\x11\x15a\x17\xC5W_\x80\xFD[\x83\x01`\x1F\x81\x01\x88\x13a\x17\xD5W_\x80\xFD[\x805\x83\x81\x11\x15a\x17\xE7Wa\x17\xE7a\x16\x93V[a\x18\x17\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\rV[\x93P\x80\x84R\x88\x86\x82\x84\x01\x01\x11\x15a\x18,W_\x80\xFD[\x80\x86\x83\x01\x87\x86\x017_\x86\x82\x86\x01\x01RPP\x81`@\x82\x01R``\x83\x015``\x82\x01R\x80\x94PPPPP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x18jW_\x80\xFD[PQ\x91\x90PV[\x80Q\x82Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x82\x01Q\x16` \x83\x01R_`@\x82\x01Q`\x80`@\x85\x01Ra\x18\xAF`\x80\x85\x01\x82a\x14\xB1V[``\x93\x84\x01Q\x94\x90\x93\x01\x93\x90\x93RP\x91\x90PV[` \x81R_a\x15B` \x83\x01\x84a\x18qV[\x80Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x16\x12W_\x80\xFD[\x80Q\x80\x15\x15\x81\x14a\x16\x12W_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19\x08W_\x80\xFD[a\x19\x10a\x16\xE9V[a\x19\x19\x83a\x16\x07V[\x81Ra\x19'` \x84\x01a\x16\x07V[` \x82\x01Ra\x198`@\x84\x01a\x16\x07V[`@\x82\x01R``\x83\x01Q``\x82\x01R`\x80\x83\x01Q`\x80\x82\x01Ra\x19]`\xA0\x84\x01a\x18\xD5V[`\xA0\x82\x01R`\xC0\x83\x01Q`\xC0\x82\x01R`\xE0\x83\x01Q`\xE0\x82\x01Ra\x01\0\x80\x84\x01Q\x81\x83\x01RPa\x01 a\x19\x90\x81\x85\x01a\x18\xE8V[\x90\x82\x01Ra\x01@\x83\x81\x01Q\x90\x82\x01Ra\x01`\x92\x83\x01Q\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_a\x01\xA0a\x19\xC1\x83\x86a\x13\xCEV[\x80a\x01\x80\x84\x01Ra\x15\x1E\x81\x84\x01\x85a\x18qV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0F\xBEa\x19\xF9\x83\x86a\x19\xD4V[\x84a\x19\xD4V[` \x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82Q\x16` \x82\x01R` \x82\x01Q`@\x82\x01R_`@\x83\x01Q``\x80\x84\x01Ra\x0F\xBE`\x80\x84\x01\x82a\x14\xB1V[_` \x82\x84\x03\x12\x15a\x1ASW_\x80\xFD[a\x15B\x82a\x18\xE8V[_a\x15B\x82\x84a\x19\xD4V[` \x81R_a\x15B` \x83\x01\x84a\x14\xB1V\xFEa\x01 `@R4\x80\x15a\0\x10W_\x80\xFD[P`@Qa&x8\x03\x80a&x\x839\x81\x01`@\x81\x90Ra\0/\x91a\x05/V[`\x01`\x01`\xA0\x1B\x03\x83\x16`\x80\x81\x90R`@\x80Qc\xF6\x98\xDA%`\xE0\x1B\x81R\x90Qc\xF6\x98\xDA%\x91`\x04\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81_\x87Z\xF1\x15\x80\x15a\0xW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\x9C\x91\x90a\x05yV[a\x01\0Ra\0\xAA\x823a\x01_V[a\0\xB4\x813a\x01_V[3`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x81`\x01`\x01`\xA0\x1B\x03\x16\x81RPP_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x9BU,\xC2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x05\x90V[\x90Pa\x01<\x83\x82a\x01_V[a\x01F\x82\x82a\x01_V[P`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\xA0R\x16`\xC0RPa\x06\x1CV[a\x01t`\x01`\x01`\xA0\x1B\x03\x83\x16\x82_\x19a\x01xV[PPV[\x80\x15\x80a\x01\xF0WP`@Qcn\xB1v\x9F`\xE1\x1B\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`$\x83\x01R\x84\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xCAW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEE\x91\x90a\x05yV[\x15[a\x02gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`6`$\x82\x01R\x7FSafeERC20: approve from non-zero`D\x82\x01R\x7F to non-zero allowance\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q`\x01`\x01`\xE0\x1B\x03\x90\x81\x16c\t^\xA7\xB3`\xE0\x1B\x17\x90\x91Ra\x02\xBD\x91\x85\x91a\x02\xC2\x16V[PPPV[`@\x80Q\x80\x82\x01\x90\x91R` \x80\x82R\x7FSafeERC20: low-level call failed\x90\x82\x01R_\x90a\x03\x0E\x90`\x01`\x01`\xA0\x1B\x03\x85\x16\x90\x84\x90a\x03\x8DV[\x90P\x80Q_\x14\x80a\x03.WP\x80\x80` \x01\x90Q\x81\x01\x90a\x03.\x91\x90a\x05\xB2V[a\x02\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`*`$\x82\x01R\x7FSafeERC20: ERC20 operation did n`D\x82\x01Ri\x1B\xDD\x08\x1C\xDDX\xD8\xD9YY`\xB2\x1B`d\x82\x01R`\x84\x01a\x02^V[``a\x03\x9B\x84\x84_\x85a\x03\xA3V[\x94\x93PPPPV[``\x82G\x10\x15a\x04\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FAddress: insufficient balance fo`D\x82\x01Re\x1C\x88\x18\xD8[\x1B`\xD2\x1B`d\x82\x01R`\x84\x01a\x02^V[_\x80\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x04\x1F\x91\x90a\x05\xD1V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x04YW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04^V[``\x91P[P\x90\x92P\x90Pa\x04p\x87\x83\x83\x87a\x04{V[\x97\x96PPPPPPPV[``\x83\x15a\x04\xE9W\x82Q_\x03a\x04\xE2W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x04\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x02^V[P\x81a\x03\x9BV[a\x03\x9B\x83\x83\x81Q\x15a\x04\xFEW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02^\x91\x90a\x05\xE7V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x05,W_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15a\x05AW_\x80\xFD[\x83Qa\x05L\x81a\x05\x18V[` \x85\x01Q\x90\x93Pa\x05]\x81a\x05\x18V[`@\x85\x01Q\x90\x92Pa\x05n\x81a\x05\x18V[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x05\x89W_\x80\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x05\xA0W_\x80\xFD[\x81Qa\x05\xAB\x81a\x05\x18V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x05\xC2W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xABW_\x80\xFD[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x1F\xBDa\x06\xBB_9_\x81\x81a\x02\xDB\x01Ra\x04+\x01R_\x81\x81a\x026\x01R\x81\x81a\x04\xD9\x01Ra\x0B\xF9\x01R_\x81\x81a\x02\xB4\x01R\x81\x81a\x05\x99\x01R\x81\x81a\r\\\x01R\x81\x81a\x0E\xBF\x01R\x81\x81a\x0F\x8E\x01Ra\x10\r\x01R_\x81\x81a\x018\x01R\x81\x81a\x05w\x01R\x81\x81a\r;\x01R\x81\x81a\x0E(\x01R\x81\x81a\x0Fk\x01Ra\x100\x01R_\x81\x81a\x03\"\x01Ra\x12\x14\x01Ra\x1F\xBD_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\xB0\x9A\xAA\xCA\x11a\0\xADW\x80c\xE3\xE6\xF5\xB2\x11a\0}W\x80c\xEE\xC5\x0B\x97\x11a\0cW\x80c\xEE\xC5\x0B\x97\x14a\x03DW\x80c\xF1O\xCB\xC8\x14a\x03LW\x80c\xFF-\xBC\x98\x14a\x02\x03W_\x80\xFD[\x80c\xE3\xE6\xF5\xB2\x14a\x02\xFDW\x80c\xE5\x16q[\x14a\x03\x1DW_\x80\xFD[\x80c\xB0\x9A\xAA\xCA\x14a\x02\x89W\x80c\xC5\xF3\xD2T\x14a\x02\x9CW\x80c\xD2\x12 \xA7\x14a\x02\xAFW\x80c\xD2^\x0C\xB6\x14a\x02\xD6W_\x80\xFD[\x80c\x1C}\xE9A\x11a\x01\x02W\x80cH\x1Cju\x11a\0\xE8W\x80cH\x1Cju\x14a\x021W\x80c\x98\x1A\x16\x0B\x14a\x02XW\x80c\xA0)\xA8\xD4\x14a\x02vW_\x80\xFD[\x80c\x1C}\xE9A\x14a\x02\x03W\x80c>pn2\x14a\x02\nW_\x80\xFD[\x80c\r\xFE\x16\x81\x14a\x013W\x80c\x13\x03\xA4\x84\x14a\x01\x84W\x80c\x16&\xBA~\x14a\x01\xB5W\x80c\x17p\x0F\x01\x14a\x01\xF9W[_\x80\xFD[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\[`@Q\x90\x81R` \x01a\x01{V[a\x01\xC8a\x01\xC36`\x04a\x16\xBFV[a\x03_V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x04\xD7V[\0[a\x01\xA7_\x81V[a\x01\xA7\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\x81V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x02aa\x01,\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01{V[a\x02\x01a\x02\x846`\x04a\x19\xEEV[a\x05sV[a\x01\xA7a\x02\x976`\x04a\x1A;V[a\x0B\xC8V[a\x02\x01a\x02\xAA6`\x04a\x1AuV[a\x0B\xF7V[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x03\x10a\x03\x0B6`\x04a\x1A;V[a\x0C\xB7V[`@Qa\x01{\x91\x90a\x1A\xACV[a\x01Z\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\xA7_T\x81V[a\x02\x01a\x03Z6`\x04a\x1B\x9AV[a\x11\xFCV[_\x80\x80a\x03n\x84\x86\x01\x86a\x1B\xB1V[\x91P\x91P_Ta\x03}\x82a\x0B\xC8V[\x14a\x03\xB4W`@Q\x7F\xF1\xA6x\x90\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x82\x01\x80Q\x7F\xD5\xA2[\xA2\xE9p\x94\xAD}\x83\xDC(\xA6W-\xA7\x97\xD6\xB3\xE7\xFCfc\xBD\x93\xEF\xB7\x89\xFC\x17\xE4\x89\x82Ra\x01\xA0\x82 \x91R`@Q\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x02\x82\x01R`\"\x81\x01\x91\x90\x91R`B\x90 \x86\x81\x14a\x04\x94W`@Q\x7FY?\xCA\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x9F\x81\x83\x85a\x12\x91V[a\x04\xA9\x82\x84a\x05sV[P\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPP[\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x05FW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80U`@Q\x7F\xBC\xB8\xB8\xFB\xDE\xA8\xAAm\xC4\xAEA!>M\xA8\x1E`Z=\x1AV\xED\x85\x1B\x93U\x18#!\xC0\x91\x90\x91\x90\xA1V[\x80Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x84\x16\x91\x16\x14a\x06wW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06uW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7Finvalid sell token\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x90[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xE1W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x05\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90\x91P_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x96\x91\x90a\x1B\xFFV[\x90P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x081W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x11`$\x82\x01R\x7Finvalid buy token\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`@\x85\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x15a\x08\xB3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7Freceiver must be zero address\0\0\0`D\x82\x01R`d\x01a\x06lV[a\x08\xBFa\x01,Ba\x1CCV[\x85`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x11\x15a\t2W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7Fvalidity too far in the future\0\0`D\x82\x01R`d\x01a\x06lV[\x85``\x01Q\x85`\xC0\x01Q\x14a\t\xA3W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x0F`$\x82\x01R\x7Finvalid appData\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[`\xE0\x85\x01Q\x15a\n\x0FW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Ffee amount must be zero\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01`\x01Q\x14a\n\x9DW`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FbuyTokenBalance must be erc20\0\0\0`D\x82\x01R`d\x01a\x06lV[\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x85a\x01@\x01Q\x14a\x0B+W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FsellTokenBalance must be erc20\0\0`D\x82\x01R`d\x01a\x06lV[``\x85\x01Qa\x0B:\x90\x82a\x1CVV[`\x80\x86\x01Q``\x87\x01Qa\x0BN\x90\x85a\x1CmV[a\x0BX\x91\x90a\x1CVV[\x10\x15a\x0B\xC0W`@Q\x7F\xC8\xFC'%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7Freceived amount too low\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[PPPPPPV[_\x81`@Q` \x01a\x0B\xDA\x91\x90a\x1C\xCCV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0CfW`@Q\x7F\xF8}\r\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x0Csa\x02\x97\x83a\x1D'V[\x90P\x80_\x81\x90UP\x80\x7FQ\x0EJOv\x90|-aX\xB3C\xF7\xC4\xF2\xF5\x97\xDF8[r|&\xE9\xEF\x90\xE7P\x93\xAC\xE1\x9A\x83`@Qa\x0C\xAB\x91\x90a\x1DyV[`@Q\x80\x91\x03\x90\xA2PPV[`@\x80Qa\x01\x80\x81\x01\x82R_\x80\x82R` \x82\x01\x81\x90R\x91\x81\x01\x82\x90R``\x81\x01\x82\x90R`\x80\x81\x01\x82\x90R`\xA0\x81\x01\x82\x90R`\xC0\x81\x01\x82\x90R`\xE0\x81\x01\x82\x90Ra\x01\0\x81\x01\x82\x90Ra\x01 \x81\x01\x82\x90Ra\x01@\x81\x01\x82\x90Ra\x01`\x81\x01\x91\x90\x91R_\x80\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5^\xFD\xD9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87`@\x01Q`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\x9E\x93\x92\x91\x90a\x1E:V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xB8W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDC\x91\x90a\x1ErV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x91\x93P\x91P_\x90\x81\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0EmW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\x91\x91\x90a\x1B\xFFV[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x19W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F=\x91\x90a\x1B\xFFV[\x90\x92P\x90P_\x80\x80\x80\x80a\x0FQ\x88\x88a\x1CVV[\x90P_a\x0F^\x8A\x88a\x1CVV[\x90P_\x82\x82\x10\x15a\x10\x0BW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x0F\xD6a\x0F\xBD`\x02\x8Ba\x1E\xC1V[a\x0F\xD1\x84a\x0F\xCC\x8E`\x02a\x1CVV[a\x13FV[a\x13~V[\x94Pa\x10\x01\x85a\x0F\xE6\x81\x8Da\x1CVV[a\x0F\xF0\x90\x85a\x1CCV[a\x0F\xFA\x8C\x8Fa\x1CVV[`\x01a\x13\xCBV[\x93P\x84\x90Pa\x10\x98V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x95Pa\x10na\x10_`\x02\x8Aa\x1E\xC1V[a\x0F\xD1\x85a\x0F\xCC\x8F`\x02a\x1CVV[\x94Pa\x10\x92\x85a\x10~\x81\x8Ea\x1CVV[a\x10\x88\x90\x86a\x1CCV[a\x0F\xFA\x8B\x8Ea\x1CVV[\x93P\x83\x90P[\x8CQ\x81\x10\x15a\x10\xDFWa\x10\xDF`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7Ftraded amount too small\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[`@Q\x80a\x01\x80\x01`@R\x80\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01a\x11Va\x01,a\x14fV[c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8E``\x01Q\x81R` \x01_\x81R` \x01\x7F\xF3\xB2wr\x8B?\xEEt\x94\x81\xEB>\x0B;H\x98\r\xBB\xABxe\x8F\xC4\x19\x02\\\xB1n\xEE4gu\x81R` \x01`\x01\x15\x15\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81R` \x01\x7FZ(\xE96;\xB9B\xB69'\0b\xAAk\xB2\x95\xF44\xBC\xDF\xC4,\x97&{\xF0\x03\xF2r\x06\r\xC9\x81RP\x9BPPPPPPPPPPPP\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x12kW`@Q\x7F\xBF\x84\x89w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93]PV[\x7Fl<\x90$TW\x06\x0Fe\x17x{,K\x8C\xF5\0\xCA\x88\x9D#\x04\xAF\x02\x04;\xD5\xB5\x13\xE3\xB5\x93\\\x83\x81\x14a\x13@W\x80\x15a\x12\xF2W`@Q\x7F\xDA\xFB\xDD\x1F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xFC\x84a\x0C\xB7V[\x90Pa\x13\x08\x83\x82a\x14\x87V[a\x13>W`@Q\x7F\xD9\xFF$\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPPPV[_\x82\x15a\x13sW\x81a\x13Y`\x01\x85a\x1CmV[a\x13c\x91\x90a\x1E\xC1V[a\x13n\x90`\x01a\x1CCV[a\x13uV[_[\x90P[\x92\x91PPV[_\x81\x83\x10\x15a\x13\xC5Wa\x13\xC5`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7Fsubtraction underflow\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14&V[P\x90\x03\x90V[_\x80a\x13\xD8\x86\x86\x86a\x15\x99V[\x90P`\x01\x83`\x02\x81\x11\x15a\x13\xEEWa\x13\xEEa\x1E\xD4V[\x14\x80\x15a\x14\nWP_\x84\x80a\x14\x05Wa\x14\x05a\x1E\x94V[\x86\x88\t\x11[\x15a\x14\x1DWa\x14\x1A`\x01\x82a\x1CCV[\x90P[\x95\x94PPPPPV[a\x141C`\x01a\x1CCV[\x81`@Q\x7F\x1F\xE8Pn\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x06l\x92\x91\x90a\x1F\x01V[_\x81\x80a\x14s\x81Ba\x1F\x19V[a\x14}\x91\x90a\x1F;V[a\x13x\x91\x90a\x1FcV[_\x80\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x83` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85` \x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x90P_\x84``\x01Q\x86``\x01Q\x14\x90P_\x85`\x80\x01Q\x87`\x80\x01Q\x14\x90P_\x86`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x88`\xA0\x01Qc\xFF\xFF\xFF\xFF\x16\x14\x90P_\x87a\x01\0\x01Q\x89a\x01\0\x01Q\x14\x90P_\x88a\x01 \x01Q\x15\x15\x8Aa\x01 \x01Q\x15\x15\x14\x90P\x86\x80\x15a\x15^WP\x85[\x80\x15a\x15gWP\x84[\x80\x15a\x15pWP\x83[\x80\x15a\x15yWP\x82[\x80\x15a\x15\x82WP\x81[\x80\x15a\x15\x8BWP\x80[\x9A\x99PPPPPPPPPPV[_\x80\x80\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x85\x87\x02\x92P\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a\x15\xEFW\x83\x82\x81a\x15\xE5Wa\x15\xE5a\x1E\x94V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a\x16XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FMath: mulDiv overflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x06lV[_\x84\x86\x88\t`\x02`\x01\x87\x19\x81\x01\x88\x16\x97\x88\x90\x04`\x03\x81\x02\x83\x18\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x80\x82\x02\x84\x03\x02\x90\x81\x02\x90\x92\x03\x90\x91\x02_\x88\x90\x03\x88\x90\x04\x90\x91\x01\x85\x83\x11\x90\x94\x03\x93\x90\x93\x02\x93\x03\x94\x90\x94\x04\x91\x90\x91\x17\x02\x94\x93PPPPV[_\x80_`@\x84\x86\x03\x12\x15a\x16\xD1W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x16\xEFW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\x17\x02W_\x80\xFD[\x815\x81\x81\x11\x15a\x17\x10W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a\x17!W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@R\x90V[`@Qa\x01\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x84Wa\x17\x84a\x174V[`@Q`\x1F\x82\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\xF5Wa\x17\xF5a\x174V[`@R\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x18\x1EW_\x80\xFD[PV[_`\x80\x82\x84\x03\x12\x15a\x181W_\x80\xFD[a\x189a\x17aV[\x90P\x815\x81R` \x80\x83\x015a\x18N\x81a\x17\xFDV[\x82\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x18lW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x18\x7FW_\x80\xFD[\x815\x81\x81\x11\x15a\x18\x91Wa\x18\x91a\x174V[a\x18\xC1\x84\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x01a\x17\xAEV[\x91P\x80\x82R\x86\x84\x82\x85\x01\x01\x11\x15a\x18\xD6W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80`@\x85\x01RPPP``\x82\x015``\x82\x01R\x92\x91PPV[\x805a\x19\n\x81a\x17\xFDV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x19\nW_\x80\xFD[\x805\x80\x15\x15\x81\x14a\x19\nW_\x80\xFD[_a\x01\x80\x82\x84\x03\x12\x15a\x19BW_\x80\xFD[a\x19Ja\x17\x8AV[\x90Pa\x19U\x82a\x18\xFFV[\x81Ra\x19c` \x83\x01a\x18\xFFV[` \x82\x01Ra\x19t`@\x83\x01a\x18\xFFV[`@\x82\x01R``\x82\x015``\x82\x01R`\x80\x82\x015`\x80\x82\x01Ra\x19\x99`\xA0\x83\x01a\x19\x0FV[`\xA0\x82\x01R`\xC0\x82\x015`\xC0\x82\x01R`\xE0\x82\x015`\xE0\x82\x01Ra\x01\0\x80\x83\x015\x81\x83\x01RPa\x01 a\x19\xCC\x81\x84\x01a\x19\"V[\x90\x82\x01Ra\x01@\x82\x81\x015\x90\x82\x01Ra\x01`\x91\x82\x015\x91\x81\x01\x91\x90\x91R\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1A\0W_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x16W_\x80\xFD[a\x1A\"\x85\x82\x86\x01a\x18!V[\x92PPa\x1A2\x84` \x85\x01a\x191V[\x90P\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1AKW_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1AaW_\x80\xFD[a\x1Am\x84\x82\x85\x01a\x18!V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x1A\x85W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\x9BW_\x80\xFD[\x82\x01`\x80\x81\x85\x03\x12\x15a\x04\xD0W_\x80\xFD[\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Ra\x01\x80\x81\x01` \x83\x01Qa\x1A\xF2` \x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P`@\x83\x01Qa\x1B\x1A`@\x84\x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RV[P``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x80\x83\x01R`\xA0\x83\x01Qa\x1BF`\xA0\x84\x01\x82c\xFF\xFF\xFF\xFF\x16\x90RV[P`\xC0\x83\x01Q`\xC0\x83\x01R`\xE0\x83\x01Q`\xE0\x83\x01Ra\x01\0\x80\x84\x01Q\x81\x84\x01RPa\x01 \x80\x84\x01Qa\x1B{\x82\x85\x01\x82\x15\x15\x90RV[PPa\x01@\x83\x81\x01Q\x90\x83\x01Ra\x01`\x92\x83\x01Q\x92\x90\x91\x01\x91\x90\x91R\x90V[_` \x82\x84\x03\x12\x15a\x1B\xAAW_\x80\xFD[P5\x91\x90PV[_\x80a\x01\xA0\x83\x85\x03\x12\x15a\x1B\xC3W_\x80\xFD[a\x1B\xCD\x84\x84a\x191V[\x91Pa\x01\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xE9W_\x80\xFD[a\x1B\xF5\x85\x82\x86\x01a\x18!V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0FW_\x80\xFD[PQ\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x13xWa\x13xa\x1C\x16V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x13xWa\x13xa\x1C\x16V[\x81\x81\x03\x81\x81\x11\x15a\x13xWa\x13xa\x1C\x16V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\x81Q` \x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF` \x83\x01Q\x16`@\x82\x01R_`@\x83\x01Q`\x80``\x84\x01Ra\x1D\x11`\xA0\x84\x01\x82a\x1C\x80V[\x90P``\x84\x01Q`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_a\x13x6\x83a\x18!V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[` \x81R\x815` \x82\x01R_` \x83\x015a\x1D\x93\x81a\x17\xFDV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16`@\x84\x01RP`@\x83\x015\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x1D\xE4W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\0W_\x80\xFD[\x806\x03\x82\x13\x15a\x1E\x0EW_\x80\xFD[`\x80``\x85\x01Ra\x1E#`\xA0\x85\x01\x82\x84a\x1D2V[\x91PP``\x84\x015`\x80\x84\x01R\x80\x91PP\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16\x83R\x80\x85\x16` \x84\x01RP```@\x83\x01Ra\x14\x1D``\x83\x01\x84a\x1C\x80V[_\x80`@\x83\x85\x03\x12\x15a\x1E\x83W_\x80\xFD[PP\x80Q` \x90\x91\x01Q\x90\x92\x90\x91PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_\x82a\x1E\xCFWa\x1E\xCFa\x1E\x94V[P\x04\x90V[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x82\x81R`@` \x82\x01R_a\x1Am`@\x83\x01\x84a\x1C\x80V[_c\xFF\xFF\xFF\xFF\x80\x84\x16\x80a\x1F/Wa\x1F/a\x1E\x94V[\x92\x16\x91\x90\x91\x04\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x80\x82\x16\x91\x90\x82\x81\x14a\x1F[Wa\x1F[a\x1C\x16V[PP\x92\x91PPV[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x1F\x80Wa\x1F\x80a\x1C\x16V[P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xE3\xFB\"\x8BR]\x90\xB9B\xC7\xE5\x8F\xE2\xE2\x03J\x17\xBD%\x8C\x08/\xD4w@\xE7d\xA7\xBEE\xBA\xC6dsolcC\0\x08\x19\x003\xA2dipfsX\"\x12 \x11\x90\xCFB\xF9\x89\xCE\xE2?\x12Y|\x8C\x1E\x9D\xAA\xB6\xD8\xC8\x16Q3I\xC3\xCE\x7F\xD2)\xCA\xE5\xB0\xFFdsolcC\0\x08\x19\x003",
+    );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `ammDeterministicAddress(address,address,address)` and selector `0x37ebdf50`.
+    /**Custom error with signature `OnlyOwnerCanCall(address)` and selector `0x68bafff8`.
     ```solidity
-    function ammDeterministicAddress(address ammOwner, address token0, address token1) external view returns (address);
+    error OnlyOwnerCanCall(address owner);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ammDeterministicAddressCall {
-        #[allow(missing_docs)]
-        pub ammOwner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token1: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`ammDeterministicAddress(address,address,
-    /// address)`](ammDeterministicAddressCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ammDeterministicAddressReturn {
+    pub struct OnlyOwnerCanCall {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub owner: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -2110,92 +722,41 @@ pub mod CowAmmConstantProductFactory {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ammDeterministicAddressCall> for UnderlyingRustTuple<'_> {
-                fn from(value: ammDeterministicAddressCall) -> Self {
-                    (value.ammOwner, value.token0, value.token1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ammDeterministicAddressCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        ammOwner: tuple.0,
-                        token0: tuple.1,
-                        token1: tuple.2,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ammDeterministicAddressReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: ammDeterministicAddressReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OnlyOwnerCanCall> for UnderlyingRustTuple<'_> {
+            fn from(value: OnlyOwnerCanCall) -> Self {
+                (value.owner,)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ammDeterministicAddressReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyOwnerCanCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { owner: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for ammDeterministicAddressCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolError for OnlyOwnerCanCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [55u8, 235u8, 223u8, 80u8];
-            const SIGNATURE: &'static str = "ammDeterministicAddress(address,address,address)";
+            const SELECTOR: [u8; 4] = [104u8, 186u8, 255u8, 248u8];
+            const SIGNATURE: &'static str = "OnlyOwnerCanCall(address)";
 
             #[inline]
             fn new<'a>(
@@ -2208,79 +769,28 @@ pub mod CowAmmConstantProductFactory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.ammOwner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token1,
+                        &self.owner,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: ammDeterministicAddressReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: ammDeterministicAddressReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `create(address,uint256,address,uint256,uint256,address,bytes,bytes32)` and selector `0x22b155c6`.
+    /**Custom error with signature `OrderNotValid(string)` and selector `0xc8fc2725`.
     ```solidity
-    function create(address token0, uint256 amount0, address token1, uint256 amount1, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external returns (address amm);
+    error OrderNotValid(string);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct createCall {
-        #[allow(missing_docs)]
-        pub token0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub token1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub priceOracle: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub priceOracleData: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub appData: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`create(address,uint256,address,uint256,uint256,address,bytes,
-    /// bytes32)`](createCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createReturn {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-    }
+    pub struct OrderNotValid(pub alloy_sol_types::private::String);
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2289,207 +799,208 @@ pub mod CowAmmConstantProductFactory {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createCall) -> Self {
-                    (
-                        value.token0,
-                        value.amount0,
-                        value.token1,
-                        value.amount1,
-                        value.minTradedToken0,
-                        value.priceOracle,
-                        value.priceOracleData,
-                        value.appData,
-                    )
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderNotValid> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderNotValid) -> Self {
+                (value.0,)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token0: tuple.0,
-                        amount0: tuple.1,
-                        token1: tuple.2,
-                        amount1: tuple.3,
-                        minTradedToken0: tuple.4,
-                        priceOracle: tuple.5,
-                        priceOracleData: tuple.6,
-                        appData: tuple.7,
-                    }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderNotValid {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self(tuple.0)
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for OrderNotValid {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [200u8, 252u8, 39u8, 37u8];
+            const SIGNATURE: &'static str = "OrderNotValid(string)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createReturn) -> Self {
-                    (value.amm,)
-                }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amm: tuple.0 }
-                }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
             }
         }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ConditionalOrderCreated(address,(address,bytes32,bytes))` and selector `0x2cceac5555b0ca45a3744ced542f54b56ad2eb45e521962372eef212a2cbf361`.
+    ```solidity
+    event ConditionalOrderCreated(address indexed owner, IConditionalOrder.ConditionalOrderParams params);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ConditionalOrderCreated {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub params:
+            <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ConditionalOrderCreated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (IConditionalOrder::ConditionalOrderParams,);
+            type TopicList = (
                 alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [34u8, 177u8, 85u8, 198u8];
+            const ANONYMOUS: bool = false;
             const SIGNATURE: &'static str =
-                "create(address,uint256,address,uint256,uint256,address,bytes,bytes32)";
+                "ConditionalOrderCreated(address,(address,bytes32,bytes))";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    44u8, 206u8, 172u8, 85u8, 85u8, 176u8, 202u8, 69u8, 163u8, 116u8, 76u8, 237u8,
+                    84u8, 47u8, 84u8, 181u8, 106u8, 210u8, 235u8, 69u8, 229u8, 33u8, 150u8, 35u8,
+                    114u8, 238u8, 242u8, 18u8, 162u8, 203u8, 243u8, 97u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    owner: topics.1,
+                    params: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount0),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token1,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amount1),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minTradedToken0),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.priceOracle,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.priceOracleData,
+                    <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::tokenize(
+                        &self.params,
                     ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createReturn = r.into();
-                        r.amm
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ConditionalOrderCreated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ConditionalOrderCreated> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createReturn = r.into();
-                    r.amm
-                })
+            fn from(this: &ConditionalOrderCreated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `deposit(address,uint256,uint256)` and selector `0x0efe6a8b`.
+    /**Event with signature `Deployed(address,address,address,address)` and selector `0x6707255b2c5ca81220b2f3e408a269cb83baa6aa7e5e37aa1756883a6cdf06f1`.
     ```solidity
-    function deposit(address amm, uint256 amount0, uint256 amount1) external;
+    event Deployed(address indexed amm, address indexed owner, address token0, address token1);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct depositCall {
+    pub struct Deployed {
         #[allow(missing_docs)]
         pub amm: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        pub owner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
     }
-    ///Container type for the return parameters of the
-    /// [`deposit(address,uint256,uint256)`](depositCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct depositReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2498,156 +1009,129 @@ pub mod CowAmmConstantProductFactory {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Deployed {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
-                fn from(value: depositCall) -> Self {
-                    (value.amm, value.amount0, value.amount1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amm: tuple.0,
-                        amount0: tuple.1,
-                        amount1: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: depositReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl depositReturn {
-            fn _tokenize(&self) -> <depositCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for depositCall {
-            type Parameters<'a> = (
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = depositReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [14u8, 254u8, 106u8, 139u8];
-            const SIGNATURE: &'static str = "deposit(address,uint256,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Deployed(address,address,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    103u8, 7u8, 37u8, 91u8, 44u8, 92u8, 168u8, 18u8, 32u8, 178u8, 243u8, 228u8,
+                    8u8, 162u8, 105u8, 203u8, 131u8, 186u8, 166u8, 170u8, 126u8, 94u8, 55u8, 170u8,
+                    23u8, 86u8, 136u8, 58u8, 108u8, 223u8, 6u8, 241u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    amm: topics.1,
+                    owner: topics.2,
+                    token0: data.0,
+                    token1: data.1,
+                }
+            }
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
+                        &self.token0,
                     ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                depositReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.amm.clone(),
+                    self.owner.clone(),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.amm,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Deployed {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Deployed> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &Deployed) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `disableTrading(address)` and selector `0x27910565`.
+    /**Event with signature `TradingDisabled(address)` and selector `0xc75bf4f03c02fab9414a7d7a54048c0486722bc72f33ad924709a0593608ad27`.
     ```solidity
-    function disableTrading(address amm) external;
+    event TradingDisabled(address indexed amm);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct disableTradingCall {
+    pub struct TradingDisabled {
         #[allow(missing_docs)]
         pub amm: alloy_sol_types::private::Address,
     }
-    ///Container type for the return parameters of the
-    /// [`disableTrading(address)`](disableTradingCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableTradingReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2656,42 +1140,108 @@ pub mod CowAmmConstantProductFactory {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TradingDisabled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TradingDisabled(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    199u8, 91u8, 244u8, 240u8, 60u8, 2u8, 250u8, 185u8, 65u8, 74u8, 125u8, 122u8,
+                    84u8, 4u8, 140u8, 4u8, 134u8, 114u8, 43u8, 199u8, 47u8, 51u8, 173u8, 146u8,
+                    71u8, 9u8, 160u8, 89u8, 54u8, 8u8, 173u8, 39u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { amm: topics.1 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableTradingCall> for UnderlyingRustTuple<'_> {
-                fn from(value: disableTradingCall) -> Self {
-                    (value.amm,)
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amm: tuple.0 }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.amm.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.amm,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TradingDisabled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TradingDisabled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TradingDisabled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor(address _settler);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _settler: alloy_sol_types::private::Address,
+    }
+    const _: () = {
+        use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2703,37 +1253,24 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<disableTradingReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: disableTradingReturn) -> Self {
-                    ()
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._settler,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableTradingReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _settler: tuple.0 }
                 }
             }
         }
-        impl disableTradingReturn {
-            fn _tokenize(
-                &self,
-            ) -> <disableTradingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for disableTradingCall {
+        impl alloy_sol_types::SolConstructor for constructorCall {
             type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = disableTradingReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [39u8, 145u8, 5u8, 101u8];
-            const SIGNATURE: &'static str = "disableTrading(address)";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -2745,60 +1282,36 @@ pub mod CowAmmConstantProductFactory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
+                        &self._settler,
                     ),
                 )
             }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                disableTradingReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,bytes32[])` and selector `0x26e0a196`.
+    /**Function with signature `ammDeterministicAddress(address,address,address)` and selector `0x37ebdf50`.
     ```solidity
-    function getTradeableOrderWithSignature(address amm, IConditionalOrder.ConditionalOrderParams memory params, bytes memory, bytes32[] memory) external view returns (GPv2Order.Data memory order, bytes memory signature);
+    function ammDeterministicAddress(address ammOwner, address token0, address token1) external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getTradeableOrderWithSignatureCall {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
+    pub struct ammDeterministicAddressCall {
         #[allow(missing_docs)]
-        pub params:
-            <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
+        pub ammOwner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::Bytes,
+        pub token0: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _3: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+        pub token1: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,
-    /// bytes32[])`](getTradeableOrderWithSignatureCall) function.
+    /// [`ammDeterministicAddress(address,address,
+    /// address)`](ammDeterministicAddressCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getTradeableOrderWithSignatureReturn {
-        #[allow(missing_docs)]
-        pub order: <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
+    pub struct ammDeterministicAddressReturn {
         #[allow(missing_docs)]
-        pub signature: alloy_sol_types::private::Bytes,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -2813,16 +1326,14 @@ pub mod CowAmmConstantProductFactory {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
-                IConditionalOrder::ConditionalOrderParams,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Address,
-                <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -2835,20 +1346,19 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getTradeableOrderWithSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTradeableOrderWithSignatureCall) -> Self {
-                    (value.amm, value.params, value._2, value._3)
+            impl ::core::convert::From<ammDeterministicAddressCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ammDeterministicAddressCall) -> Self {
+                    (value.ammOwner, value.token0, value.token1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderWithSignatureCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ammDeterministicAddressCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amm: tuple.0,
-                        params: tuple.1,
-                        _2: tuple.2,
-                        _3: tuple.3,
+                        ammOwner: tuple.0,
+                        token0: tuple.1,
+                        token1: tuple.2,
                     }
                 }
             }
@@ -2856,12 +1366,9 @@ pub mod CowAmmConstantProductFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (GPv2Order::Data, alloy_sol_types::sol_data::Bytes);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <GPv2Order::Data as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2873,51 +1380,33 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getTradeableOrderWithSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTradeableOrderWithSignatureReturn) -> Self {
-                    (value.order, value.signature)
+            impl ::core::convert::From<ammDeterministicAddressReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ammDeterministicAddressReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTradeableOrderWithSignatureReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ammDeterministicAddressReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl getTradeableOrderWithSignatureReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <GPv2Order::Data as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTradeableOrderWithSignatureCall {
+        impl alloy_sol_types::SolCall for ammDeterministicAddressCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
-                IConditionalOrder::ConditionalOrderParams,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return = getTradeableOrderWithSignatureReturn;
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (GPv2Order::Data, alloy_sol_types::sol_data::Bytes);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [38u8, 224u8, 161u8, 150u8];
-            const SIGNATURE: &'static str =
-                "getTradeableOrderWithSignature(address,(address,bytes32,bytes),bytes,bytes32[])";
+            const SELECTOR: [u8; 4] = [55u8, 235u8, 223u8, 80u8];
+            const SIGNATURE: &'static str = "ammDeterministicAddress(address,address,address)";
 
             #[inline]
             fn new<'a>(
@@ -2930,29 +1419,30 @@ pub mod CowAmmConstantProductFactory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
+                        &self.ammOwner,
                     ),
-                    <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::tokenize(
-                        &self.params,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
                     ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._2,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
                     ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::FixedBytes<32>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._3),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getTradeableOrderWithSignatureReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ammDeterministicAddressReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -2960,26 +1450,47 @@ pub mod CowAmmConstantProductFactory {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: ammDeterministicAddressReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `owner(address)` and selector `0x666e1b39`.
+    /**Function with signature `create(address,uint256,address,uint256,uint256,address,bytes,bytes32)` and selector `0x22b155c6`.
     ```solidity
-    function owner(address) external view returns (address);
+    function create(address token0, uint256 amount0, address token1, uint256 amount1, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external returns (address amm);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ownerCall(pub alloy_sol_types::private::Address);
+    pub struct createCall {
+        #[allow(missing_docs)]
+        pub token0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub token1: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub priceOracle: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub priceOracleData: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub appData: alloy_sol_types::private::FixedBytes<32>,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`owner(address)`](ownerCall) function.
+    /// [`create(address,uint256,address,uint256,uint256,address,bytes,
+    /// bytes32)`](createCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ownerReturn {
+    pub struct createReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub amm: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -2992,9 +1503,27 @@ pub mod CowAmmConstantProductFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3006,16 +1535,34 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerCall) -> Self {
-                    (value.0,)
+            impl ::core::convert::From<createCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createCall) -> Self {
+                    (
+                        value.token0,
+                        value.amount0,
+                        value.token1,
+                        value.amount1,
+                        value.minTradedToken0,
+                        value.priceOracle,
+                        value.priceOracleData,
+                        value.appData,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
+                    Self {
+                        token0: tuple.0,
+                        amount0: tuple.1,
+                        token1: tuple.2,
+                        amount1: tuple.3,
+                        minTradedToken0: tuple.4,
+                        priceOracle: tuple.5,
+                        priceOracleData: tuple.6,
+                        appData: tuple.7,
+                    }
                 }
             }
         }
@@ -3036,29 +1583,39 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<createReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createReturn) -> Self {
+                    (value.amm,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { amm: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for ownerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolCall for createCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [102u8, 110u8, 27u8, 57u8];
-            const SIGNATURE: &'static str = "owner(address)";
+            const SELECTOR: [u8; 4] = [34u8, 177u8, 85u8, 198u8];
+            const SIGNATURE: &'static str =
+                "create(address,uint256,address,uint256,uint256,address,bytes,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -3071,8 +1628,29 @@ pub mod CowAmmConstantProductFactory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.amount1),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.minTradedToken0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracle,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.priceOracleData,
                     ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
                 )
             }
 
@@ -3085,8 +1663,8 @@ pub mod CowAmmConstantProductFactory {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: ownerReturn = r.into();
-                        r._0
+                        let r: createReturn = r.into();
+                        r.amm
                     },
                 )
             }
@@ -3097,29 +1675,32 @@ pub mod CowAmmConstantProductFactory {
                     data,
                 )
                 .map(|r| {
-                    let r: ownerReturn = r.into();
-                    r._0
+                    let r: createReturn = r.into();
+                    r.amm
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `settler()` and selector `0xab221a76`.
+    /**Function with signature `deposit(address,uint256,uint256)` and selector `0x0efe6a8b`.
     ```solidity
-    function settler() external view returns (address);
+    function deposit(address amm, uint256 amount0, uint256 amount1) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settlerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    pub struct depositCall {
+        #[allow(missing_docs)]
+        pub amm: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
     ///Container type for the return parameters of the
-    /// [`settler()`](settlerCall) function.
+    /// [`deposit(address,uint256,uint256)`](depositCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settlerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
+    pub struct depositReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3131,9 +1712,17 @@ pub mod CowAmmConstantProductFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3145,25 +1734,29 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settlerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settlerCall) -> Self {
-                    ()
+            impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
+                fn from(value: depositCall) -> Self {
+                    (value.amm, value.amount0, value.amount1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        amm: tuple.0,
+                        amount0: tuple.1,
+                        amount1: tuple.2,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3175,29 +1768,38 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settlerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settlerReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: depositReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl depositReturn {
+            fn _tokenize(&self) -> <depositCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for settlerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
+        impl alloy_sol_types::SolCall for depositCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = depositReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [171u8, 34u8, 26u8, 118u8];
-            const SIGNATURE: &'static str = "settler()";
+            const SELECTOR: [u8; 4] = [14u8, 254u8, 106u8, 139u8];
+            const SIGNATURE: &'static str = "deposit(address,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -3208,22 +1810,28 @@ pub mod CowAmmConstantProductFactory {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.amm,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+                depositReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: settlerReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -3231,38 +1839,27 @@ pub mod CowAmmConstantProductFactory {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: settlerReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `updateParameters(address,uint256,address,bytes,bytes32)` and selector `0x5b5d9ee6`.
+    /**Function with signature `owner(address)` and selector `0x666e1b39`.
     ```solidity
-    function updateParameters(address amm, uint256 minTradedToken0, address priceOracle, bytes memory priceOracleData, bytes32 appData) external;
+    function owner(address) external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct updateParametersCall {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub priceOracle: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub priceOracleData: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub appData: alloy_sol_types::private::FixedBytes<32>,
-    }
+    pub struct ownerCall(pub alloy_sol_types::private::Address);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`updateParameters(address,uint256,address,bytes,
-    /// bytes32)`](updateParametersCall) function.
+    /// [`owner(address)`](ownerCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct updateParametersReturn {}
+    pub struct ownerReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3274,21 +1871,9 @@ pub mod CowAmmConstantProductFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3300,37 +1885,25 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<updateParametersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: updateParametersCall) -> Self {
-                    (
-                        value.amm,
-                        value.minTradedToken0,
-                        value.priceOracle,
-                        value.priceOracleData,
-                        value.appData,
-                    )
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    (value.0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateParametersCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amm: tuple.0,
-                        minTradedToken0: tuple.1,
-                        priceOracle: tuple.2,
-                        priceOracleData: tuple.3,
-                        appData: tuple.4,
-                    }
+                    Self(tuple.0)
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3342,43 +1915,29 @@ pub mod CowAmmConstantProductFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<updateParametersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: updateParametersReturn) -> Self {
-                    ()
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateParametersReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl updateParametersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <updateParametersCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for updateParametersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = updateParametersReturn;
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [91u8, 93u8, 158u8, 230u8];
-            const SIGNATURE: &'static str =
-                "updateParameters(address,uint256,address,bytes,bytes32)";
+            const SELECTOR: [u8; 4] = [102u8, 110u8, 27u8, 57u8];
+            const SIGNATURE: &'static str = "owner(address)";
 
             #[inline]
             fn new<'a>(
@@ -3391,32 +1950,24 @@ pub mod CowAmmConstantProductFactory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minTradedToken0),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.priceOracle,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.priceOracleData,
+                        &self.0,
                     ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.appData),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                updateParametersReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ownerReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -3424,7 +1975,10 @@ pub mod CowAmmConstantProductFactory {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: ownerReturn = r.into();
+                    r._0
+                })
             }
         }
     };
@@ -3601,16 +2155,8 @@ pub mod CowAmmConstantProductFactory {
         #[allow(missing_docs)]
         deposit(depositCall),
         #[allow(missing_docs)]
-        disableTrading(disableTradingCall),
-        #[allow(missing_docs)]
-        getTradeableOrderWithSignature(getTradeableOrderWithSignatureCall),
-        #[allow(missing_docs)]
         owner(ownerCall),
         #[allow(missing_docs)]
-        settler(settlerCall),
-        #[allow(missing_docs)]
-        updateParameters(updateParametersCall),
-        #[allow(missing_docs)]
         withdraw(withdrawCall),
     }
     impl CowAmmConstantProductFactoryCalls {
@@ -3624,36 +2170,24 @@ pub mod CowAmmConstantProductFactory {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [14u8, 254u8, 106u8, 139u8],
             [34u8, 177u8, 85u8, 198u8],
-            [38u8, 224u8, 161u8, 150u8],
-            [39u8, 145u8, 5u8, 101u8],
             [55u8, 235u8, 223u8, 80u8],
-            [91u8, 93u8, 158u8, 230u8],
             [102u8, 110u8, 27u8, 57u8],
-            [171u8, 34u8, 26u8, 118u8],
             [181u8, 197u8, 246u8, 114u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <depositCall as alloy_sol_types::SolCall>::SIGNATURE,
             <createCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableTradingCall as alloy_sol_types::SolCall>::SIGNATURE,
             <ammDeterministicAddressCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <updateParametersCall as alloy_sol_types::SolCall>::SIGNATURE,
             <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <settlerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <withdrawCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(deposit),
             ::core::stringify!(create),
-            ::core::stringify!(getTradeableOrderWithSignature),
-            ::core::stringify!(disableTrading),
             ::core::stringify!(ammDeterministicAddress),
-            ::core::stringify!(updateParameters),
             ::core::stringify!(owner),
-            ::core::stringify!(settler),
             ::core::stringify!(withdraw),
         ];
 
@@ -3679,8 +2213,8 @@ pub mod CowAmmConstantProductFactory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for CowAmmConstantProductFactoryCalls {
-        const COUNT: usize = 9usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 5usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
         const NAME: &'static str = "CowAmmConstantProductFactoryCalls";
 
         #[inline]
@@ -3691,17 +2225,7 @@ pub mod CowAmmConstantProductFactory {
                 }
                 Self::create(_) => <createCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::disableTrading(_) => {
-                    <disableTradingCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getTradeableOrderWithSignature(_) => {
-                    <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::settler(_) => <settlerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::updateParameters(_) => {
-                    <updateParametersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -3744,30 +2268,6 @@ pub mod CowAmmConstantProductFactory {
                     }
                     create
                 },
-                {
-                    fn getTradeableOrderWithSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                CowAmmConstantProductFactoryCalls::getTradeableOrderWithSignature,
-                            )
-                    }
-                    getTradeableOrderWithSignature
-                },
-                {
-                    fn disableTrading(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmConstantProductFactoryCalls::disableTrading)
-                    }
-                    disableTrading
-                },
                 {
                     fn ammDeterministicAddress(
                         data: &[u8],
@@ -3780,16 +2280,6 @@ pub mod CowAmmConstantProductFactory {
                     }
                     ammDeterministicAddress
                 },
-                {
-                    fn updateParameters(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <updateParametersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmConstantProductFactoryCalls::updateParameters)
-                    }
-                    updateParameters
-                },
                 {
                     fn owner(
                         data: &[u8],
@@ -3800,16 +2290,6 @@ pub mod CowAmmConstantProductFactory {
                     }
                     owner
                 },
-                {
-                    fn settler(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <settlerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmConstantProductFactoryCalls::settler)
-                    }
-                    settler
-                },
                 {
                     fn withdraw(
                         data: &[u8],
@@ -3861,32 +2341,6 @@ pub mod CowAmmConstantProductFactory {
                     }
                     create
                 },
-                {
-                    fn getTradeableOrderWithSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                CowAmmConstantProductFactoryCalls::getTradeableOrderWithSignature,
-                            )
-                    }
-                    getTradeableOrderWithSignature
-                },
-                {
-                    fn disableTrading(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <disableTradingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmConstantProductFactoryCalls::disableTrading)
-                    }
-                    disableTrading
-                },
                 {
                     fn ammDeterministicAddress(
                         data: &[u8],
@@ -3901,18 +2355,6 @@ pub mod CowAmmConstantProductFactory {
                     }
                     ammDeterministicAddress
                 },
-                {
-                    fn updateParameters(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <updateParametersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmConstantProductFactoryCalls::updateParameters)
-                    }
-                    updateParameters
-                },
                 {
                     fn owner(
                         data: &[u8],
@@ -3923,16 +2365,6 @@ pub mod CowAmmConstantProductFactory {
                     }
                     owner
                 },
-                {
-                    fn settler(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmConstantProductFactoryCalls>
-                    {
-                        <settlerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowAmmConstantProductFactoryCalls::settler)
-                    }
-                    settler
-                },
                 {
                     fn withdraw(
                         data: &[u8],
@@ -3967,27 +2399,9 @@ pub mod CowAmmConstantProductFactory {
                 Self::deposit(inner) => {
                     <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::disableTrading(inner) => {
-                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTradeableOrderWithSignature(inner) => {
-                    <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::owner(inner) => {
                     <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::settler(inner) => {
-                    <settlerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::updateParameters(inner) => {
-                    <updateParametersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::withdraw(inner) => {
                     <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -4008,23 +2422,9 @@ pub mod CowAmmConstantProductFactory {
                 Self::deposit(inner) => {
                     <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::disableTrading(inner) => {
-                    <disableTradingCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getTradeableOrderWithSignature(inner) => {
-                    <getTradeableOrderWithSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::owner(inner) => {
                     <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::settler(inner) => {
-                    <settlerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::updateParameters(inner) => {
-                    <updateParametersCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::withdraw(inner) => {
                     <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -4571,31 +2971,6 @@ pub mod CowAmmConstantProductFactory {
             })
         }
 
-        ///Creates a new call builder for the [`disableTrading`] function.
-        pub fn disableTrading(
-            &self,
-            amm: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, disableTradingCall, N> {
-            self.call_builder(&disableTradingCall { amm })
-        }
-
-        ///Creates a new call builder for the
-        /// [`getTradeableOrderWithSignature`] function.
-        pub fn getTradeableOrderWithSignature(
-            &self,
-            amm: alloy_sol_types::private::Address,
-            params: <IConditionalOrder::ConditionalOrderParams as alloy_sol_types::SolType>::RustType,
-            _2: alloy_sol_types::private::Bytes,
-            _3: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-        ) -> alloy_contract::SolCallBuilder<&P, getTradeableOrderWithSignatureCall, N> {
-            self.call_builder(&getTradeableOrderWithSignatureCall {
-                amm,
-                params,
-                _2,
-                _3,
-            })
-        }
-
         ///Creates a new call builder for the [`owner`] function.
         pub fn owner(
             &self,
@@ -4604,29 +2979,6 @@ pub mod CowAmmConstantProductFactory {
             self.call_builder(&ownerCall(_0))
         }
 
-        ///Creates a new call builder for the [`settler`] function.
-        pub fn settler(&self) -> alloy_contract::SolCallBuilder<&P, settlerCall, N> {
-            self.call_builder(&settlerCall)
-        }
-
-        ///Creates a new call builder for the [`updateParameters`] function.
-        pub fn updateParameters(
-            &self,
-            amm: alloy_sol_types::private::Address,
-            minTradedToken0: alloy_sol_types::private::primitives::aliases::U256,
-            priceOracle: alloy_sol_types::private::Address,
-            priceOracleData: alloy_sol_types::private::Bytes,
-            appData: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, updateParametersCall, N> {
-            self.call_builder(&updateParametersCall {
-                amm,
-                minTradedToken0,
-                priceOracle,
-                priceOracleData,
-                appData,
-            })
-        }
-
         ///Creates a new call builder for the [`withdraw`] function.
         pub fn withdraw(
             &self,
diff --git a/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs b/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs
index 2b806732b9..e0d8676626 100644
--- a/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowammlegacyhelper/src/lib.rs
@@ -1011,9 +1011,6 @@ interface CowAmmLegacyHelper {
     constructor();
 
     function factory() external view returns (address);
-    function getSnapshot(address amm) external view returns (bytes memory);
-    function isLegacy(address amm) external view returns (bool);
-    function isLegacyEnabled(address amm) external view returns (bool success);
     function order(address pool, uint256[] memory prices) external view returns (GPv2Order.Data memory _order, GPv2Interaction.Data[] memory preInteractions, GPv2Interaction.Data[] memory postInteractions, bytes memory sig);
     function tokens(address pool) external view returns (address[] memory _tokens);
 }
@@ -1040,63 +1037,6 @@ interface CowAmmLegacyHelper {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getSnapshot",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isLegacy",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isLegacyEnabled",
-    "inputs": [
-      {
-        "name": "amm",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "success",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "order",
@@ -2064,432 +2004,6 @@ pub mod CowAmmLegacyHelper {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getSnapshot(address)` and selector `0x21570256`.
-    ```solidity
-    function getSnapshot(address amm) external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSnapshotCall {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getSnapshot(address)`](getSnapshotCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getSnapshotReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSnapshotCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getSnapshotCall) -> Self {
-                    (value.amm,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSnapshotCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amm: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getSnapshotReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getSnapshotReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getSnapshotReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getSnapshotCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 87u8, 2u8, 86u8];
-            const SIGNATURE: &'static str = "getSnapshot(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getSnapshotReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getSnapshotReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isLegacy(address)` and selector `0x2aec79a0`.
-    ```solidity
-    function isLegacy(address amm) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isLegacyCall {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isLegacy(address)`](isLegacyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isLegacyReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isLegacyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isLegacyCall) -> Self {
-                    (value.amm,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amm: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isLegacyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isLegacyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isLegacyCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [42u8, 236u8, 121u8, 160u8];
-            const SIGNATURE: &'static str = "isLegacy(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isLegacyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isLegacyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isLegacyEnabled(address)` and selector `0x10029daa`.
-    ```solidity
-    function isLegacyEnabled(address amm) external view returns (bool success);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isLegacyEnabledCall {
-        #[allow(missing_docs)]
-        pub amm: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isLegacyEnabled(address)`](isLegacyEnabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isLegacyEnabledReturn {
-        #[allow(missing_docs)]
-        pub success: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isLegacyEnabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isLegacyEnabledCall) -> Self {
-                    (value.amm,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyEnabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amm: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isLegacyEnabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isLegacyEnabledReturn) -> Self {
-                    (value.success,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isLegacyEnabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { success: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isLegacyEnabledCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [16u8, 2u8, 157u8, 170u8];
-            const SIGNATURE: &'static str = "isLegacyEnabled(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.amm,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isLegacyEnabledReturn = r.into();
-                        r.success
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isLegacyEnabledReturn = r.into();
-                    r.success
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `order(address,uint256[])` and selector `0x27242c9b`.
     ```solidity
     function order(address pool, uint256[] memory prices) external view returns (GPv2Order.Data memory _order, GPv2Interaction.Data[] memory preInteractions, GPv2Interaction.Data[] memory postInteractions, bytes memory sig);
@@ -2852,12 +2366,6 @@ pub mod CowAmmLegacyHelper {
         #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getSnapshot(getSnapshotCall),
-        #[allow(missing_docs)]
-        isLegacy(isLegacyCall),
-        #[allow(missing_docs)]
-        isLegacyEnabled(isLegacyEnabledCall),
-        #[allow(missing_docs)]
         order(orderCall),
         #[allow(missing_docs)]
         tokens(tokensCall),
@@ -2871,28 +2379,19 @@ pub mod CowAmmLegacyHelper {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [16u8, 2u8, 157u8, 170u8],
-            [33u8, 87u8, 2u8, 86u8],
             [39u8, 36u8, 44u8, 155u8],
-            [42u8, 236u8, 121u8, 160u8],
             [196u8, 90u8, 1u8, 85u8],
             [228u8, 134u8, 3u8, 57u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <isLegacyEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getSnapshotCall as alloy_sol_types::SolCall>::SIGNATURE,
             <orderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isLegacyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
             <tokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(isLegacyEnabled),
-            ::core::stringify!(getSnapshot),
             ::core::stringify!(order),
-            ::core::stringify!(isLegacy),
             ::core::stringify!(factory),
             ::core::stringify!(tokens),
         ];
@@ -2919,7 +2418,7 @@ pub mod CowAmmLegacyHelper {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for CowAmmLegacyHelperCalls {
-        const COUNT: usize = 6usize;
+        const COUNT: usize = 3usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "CowAmmLegacyHelperCalls";
 
@@ -2927,11 +2426,6 @@ pub mod CowAmmLegacyHelper {
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getSnapshot(_) => <getSnapshotCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isLegacy(_) => <isLegacyCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::isLegacyEnabled(_) => {
-                    <isLegacyEnabledCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::order(_) => <orderCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::tokens(_) => <tokensCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -2954,24 +2448,6 @@ pub mod CowAmmLegacyHelper {
                 &[u8],
             )
                 -> alloy_sol_types::Result<CowAmmLegacyHelperCalls>] = &[
-                {
-                    fn isLegacyEnabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
-                        <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmLegacyHelperCalls::isLegacyEnabled)
-                    }
-                    isLegacyEnabled
-                },
-                {
-                    fn getSnapshot(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
-                        <getSnapshotCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmLegacyHelperCalls::getSnapshot)
-                    }
-                    getSnapshot
-                },
                 {
                     fn order(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
                         <orderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2979,13 +2455,6 @@ pub mod CowAmmLegacyHelper {
                     }
                     order
                 },
-                {
-                    fn isLegacy(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
-                        <isLegacyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowAmmLegacyHelperCalls::isLegacy)
-                    }
-                    isLegacy
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -3021,26 +2490,6 @@ pub mod CowAmmLegacyHelper {
             ) -> alloy_sol_types::Result<
                 CowAmmLegacyHelperCalls,
             >] = &[
-                {
-                    fn isLegacyEnabled(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
-                        <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowAmmLegacyHelperCalls::isLegacyEnabled)
-                    }
-                    isLegacyEnabled
-                },
-                {
-                    fn getSnapshot(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
-                        <getSnapshotCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowAmmLegacyHelperCalls::getSnapshot)
-                    }
-                    getSnapshot
-                },
                 {
                     fn order(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
                         <orderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -3048,13 +2497,6 @@ pub mod CowAmmLegacyHelper {
                     }
                     order
                 },
-                {
-                    fn isLegacy(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
-                        <isLegacyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowAmmLegacyHelperCalls::isLegacy)
-                    }
-                    isLegacy
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<CowAmmLegacyHelperCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -3085,15 +2527,6 @@ pub mod CowAmmLegacyHelper {
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getSnapshot(inner) => {
-                    <getSnapshotCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isLegacy(inner) => {
-                    <isLegacyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isLegacyEnabled(inner) => {
-                    <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::order(inner) => {
                     <orderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3109,15 +2542,6 @@ pub mod CowAmmLegacyHelper {
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getSnapshot(inner) => {
-                    <getSnapshotCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isLegacy(inner) => {
-                    <isLegacyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isLegacyEnabled(inner) => {
-                    <isLegacyEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::order(inner) => {
                     <orderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3684,30 +3108,6 @@ pub mod CowAmmLegacyHelper {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getSnapshot`] function.
-        pub fn getSnapshot(
-            &self,
-            amm: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, getSnapshotCall, N> {
-            self.call_builder(&getSnapshotCall { amm })
-        }
-
-        ///Creates a new call builder for the [`isLegacy`] function.
-        pub fn isLegacy(
-            &self,
-            amm: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isLegacyCall, N> {
-            self.call_builder(&isLegacyCall { amm })
-        }
-
-        ///Creates a new call builder for the [`isLegacyEnabled`] function.
-        pub fn isLegacyEnabled(
-            &self,
-            amm: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isLegacyEnabledCall, N> {
-            self.call_builder(&isLegacyEnabledCall { amm })
-        }
-
         ///Creates a new call builder for the [`order`] function.
         pub fn order(
             &self,
diff --git a/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs b/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs
index 920989fea9..b7847d6413 100644
--- a/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowammuniswapv2priceoracle/src/lib.rs
@@ -10,49 +10,12 @@
 
 Generated by the following Solidity interface...
 ```solidity
-interface CowAmmUniswapV2PriceOracle {
-    function getPrice(address token0, address token1, bytes memory data) external view returns (uint256 priceNumerator, uint256 priceDenominator);
-}
+interface CowAmmUniswapV2PriceOracle {}
 ```
 
 ...which was generated by the following JSON ABI:
 ```json
-[
-  {
-    "type": "function",
-    "name": "getPrice",
-    "inputs": [
-      {
-        "name": "token0",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "token1",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "priceNumerator",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "priceDenominator",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  }
-]
+[]
 ```*/
 #[allow(
     non_camel_case_types,
@@ -83,329 +46,6 @@ pub mod CowAmmUniswapV2PriceOracle {
     pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
         b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c5^\xFD\xD9\x14a\0-W[_\x80\xFD[a\0@a\0;6`\x04a\x03\x86V[a\0YV[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x01`@Q\x80\x91\x03\x90\xF3[_\x80\x80a\0h\x84\x86\x01\x86a\x04\x11V[\x90P\x80_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\xB6W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xDA\x91\x90a\x04\xA2V[\x82m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92P\x81m\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91PP\x80\x93P\x81\x94PPP_\x81_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\r\xFE\x16\x81`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01VW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01z\x91\x90a\x04\xEEV[\x90P_\x82_\x01Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD2\x12 \xA7`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC9W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xED\x91\x90a\x04\xEEV[\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x02'W\x92\x93\x92\x90[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x02\xC1W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7Foracle: invalid token0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x03VW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7Foracle: invalid token1\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02\xB8V[PPP\x94P\x94\x92PPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\x83W_\x80\xFD[PV[_\x80_\x80``\x85\x87\x03\x12\x15a\x03\x99W_\x80\xFD[\x845a\x03\xA4\x81a\x03bV[\x93P` \x85\x015a\x03\xB4\x81a\x03bV[\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x03\xD0W_\x80\xFD[\x81\x87\x01\x91P\x87`\x1F\x83\x01\x12a\x03\xE3W_\x80\xFD[\x815\x81\x81\x11\x15a\x03\xF1W_\x80\xFD[\x88` \x82\x85\x01\x01\x11\x15a\x04\x02W_\x80\xFD[\x95\x98\x94\x97PP` \x01\x94PPPV[_` \x82\x84\x03\x12\x15a\x04!W_\x80\xFD[`@Q` \x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04iW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`A`\x04R`$_\xFD[`@R\x825a\x04w\x81a\x03bV[\x81R\x93\x92PPPV[\x80Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\x9DW_\x80\xFD[\x91\x90PV[_\x80_``\x84\x86\x03\x12\x15a\x04\xB4W_\x80\xFD[a\x04\xBD\x84a\x04\x80V[\x92Pa\x04\xCB` \x85\x01a\x04\x80V[\x91P`@\x84\x01Qc\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xE3W_\x80\xFD[\x80\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x04\xFEW_\x80\xFD[\x81Qa\x05\t\x81a\x03bV[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1F\xE6\xADMk\x89\xD2\x04\xDBS\x94\xBD\xED\xEF#\xD1\x0E\xD8\xC7\xE4\xF8;\xE4\xC5\xFE\x14\xDC\xC0\x94p\"4dsolcC\0\x08\x19\x003",
     );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPrice(address,address,bytes)` and selector `0x355efdd9`.
-    ```solidity
-    function getPrice(address token0, address token1, bytes memory data) external view returns (uint256 priceNumerator, uint256 priceDenominator);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPriceCall {
-        #[allow(missing_docs)]
-        pub token0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPrice(address,address,bytes)`](getPriceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPriceReturn {
-        #[allow(missing_docs)]
-        pub priceNumerator: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub priceDenominator: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPriceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPriceCall) -> Self {
-                    (value.token0, value.token1, value.data)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPriceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token0: tuple.0,
-                        token1: tuple.1,
-                        data: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPriceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPriceReturn) -> Self {
-                    (value.priceNumerator, value.priceDenominator)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPriceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        priceNumerator: tuple.0,
-                        priceDenominator: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getPriceReturn {
-            fn _tokenize(&self) -> <getPriceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.priceNumerator,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.priceDenominator,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPriceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = getPriceReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [53u8, 94u8, 253u8, 217u8];
-            const SIGNATURE: &'static str = "getPrice(address,address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token1,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getPriceReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    ///Container for all the [`CowAmmUniswapV2PriceOracle`](self) function
-    /// calls.
-    #[derive(Clone)]
-    pub enum CowAmmUniswapV2PriceOracleCalls {
-        #[allow(missing_docs)]
-        getPrice(getPriceCall),
-    }
-    impl CowAmmUniswapV2PriceOracleCalls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[[53u8, 94u8, 253u8, 217u8]];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] =
-            &[<getPriceCall as alloy_sol_types::SolCall>::SIGNATURE];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(getPrice)];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
-            }
-        }
-
-        /// Returns the enum variant name for the given selector, if known.
-        #[inline]
-        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
-            let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for CowAmmUniswapV2PriceOracleCalls {
-        const COUNT: usize = 1usize;
-        const MIN_DATA_LENGTH: usize = 128usize;
-        const NAME: &'static str = "CowAmmUniswapV2PriceOracleCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::getPrice(_) => <getPriceCall as alloy_sol_types::SolCall>::SELECTOR,
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(
-                &[u8],
-            ) -> alloy_sol_types::Result<
-                CowAmmUniswapV2PriceOracleCalls,
-            >] = &[{
-                fn getPrice(
-                    data: &[u8],
-                ) -> alloy_sol_types::Result<CowAmmUniswapV2PriceOracleCalls> {
-                    <getPriceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                        .map(CowAmmUniswapV2PriceOracleCalls::getPrice)
-                }
-                getPrice
-            }];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw_validate(
-            selector: [u8; 4],
-            data: &[u8],
-        ) -> alloy_sol_types::Result<Self> {
-            static DECODE_VALIDATE_SHIMS: &[fn(
-                &[u8],
-            ) -> alloy_sol_types::Result<
-                CowAmmUniswapV2PriceOracleCalls,
-            >] = &[{
-                fn getPrice(
-                    data: &[u8],
-                ) -> alloy_sol_types::Result<CowAmmUniswapV2PriceOracleCalls> {
-                    <getPriceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                        .map(CowAmmUniswapV2PriceOracleCalls::getPrice)
-                }
-                getPrice
-            }];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_VALIDATE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        fn abi_encoded_size(&self) -> usize {
-            match self {
-                Self::getPrice(inner) => {
-                    <getPriceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-            }
-        }
-
-        #[inline]
-        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-            match self {
-                Self::getPrice(inner) => {
-                    <getPriceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-            }
-        }
-    }
     use alloy_contract;
     /**Creates a new wrapper around an on-chain [`CowAmmUniswapV2PriceOracle`](self) contract instance.
 
@@ -568,20 +208,6 @@ pub mod CowAmmUniswapV2PriceOracle {
         ) -> alloy_contract::SolCallBuilder<&P, C, N> {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
-
-        ///Creates a new call builder for the [`getPrice`] function.
-        pub fn getPrice(
-            &self,
-            token0: alloy_sol_types::private::Address,
-            token1: alloy_sol_types::private::Address,
-            data: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, getPriceCall, N> {
-            self.call_builder(&getPriceCall {
-                token0,
-                token1,
-                data,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs b/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs
index d2d9bc3ae3..784f5bd013 100644
--- a/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowprotocoltoken/src/lib.rs
@@ -21,25 +21,16 @@ interface CowProtocolToken {
     constructor(address initialTokenHolder, address cowDao, uint256 totalSupply);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function MAX_YEARLY_INFLATION() external view returns (uint256);
-    function TIME_BETWEEN_MINTINGS() external view returns (uint256);
     function allowance(address owner, address spender) external view returns (uint256);
     function approve(address spender, uint256 amount) external returns (bool);
     function balanceOf(address account) external view returns (uint256);
-    function cowDao() external view returns (address);
     function decimals() external view returns (uint8);
-    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
     function mint(address target, uint256 amount) external;
     function name() external view returns (string memory);
     function nonces(address owner) external view returns (uint256);
     function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
     function symbol() external view returns (string memory);
-    function timestampLastMinting() external view returns (uint256);
-    function totalSupply() external view returns (uint256);
     function transfer(address recipient, uint256 amount) external returns (bool);
     function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 }
@@ -82,32 +73,6 @@ interface CowProtocolToken {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "MAX_YEARLY_INFLATION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "TIME_BETWEEN_MINTINGS",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "allowance",
@@ -175,19 +140,6 @@ interface CowProtocolToken {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "cowDao",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "decimals",
@@ -201,78 +153,6 @@ interface CowProtocolToken {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "decreaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "subtractedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getStorageAt",
-    "inputs": [
-      {
-        "name": "offset",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "length",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "increaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "addedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "mint",
@@ -390,30 +270,6 @@ interface CowProtocolToken {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "simulateDelegatecallInternal",
-    "inputs": [
-      {
-        "name": "targetContract",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "calldataPayload",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "response",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "symbol",
@@ -427,32 +283,6 @@ interface CowProtocolToken {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "timestampLastMinting",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -1297,19 +1127,24 @@ pub mod CowProtocolToken {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `MAX_YEARLY_INFLATION()` and selector `0x5862bf3d`.
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
-    function MAX_YEARLY_INFLATION() external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MAX_YEARLY_INFLATIONCall;
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`MAX_YEARLY_INFLATION()`](MAX_YEARLY_INFLATIONCall) function.
+    /// [`allowance(address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MAX_YEARLY_INFLATIONReturn {
+    pub struct allowanceReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -1324,9 +1159,15 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1338,16 +1179,19 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MAX_YEARLY_INFLATIONCall> for UnderlyingRustTuple<'_> {
-                fn from(value: MAX_YEARLY_INFLATIONCall) -> Self {
-                    ()
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_YEARLY_INFLATIONCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
                 }
             }
         }
@@ -1368,29 +1212,32 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MAX_YEARLY_INFLATIONReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: MAX_YEARLY_INFLATIONReturn) -> Self {
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_YEARLY_INFLATIONReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for MAX_YEARLY_INFLATIONCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [88u8, 98u8, 191u8, 61u8];
-            const SIGNATURE: &'static str = "MAX_YEARLY_INFLATION()";
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -1401,7 +1248,14 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
             }
 
             #[inline]
@@ -1417,7 +1271,7 @@ pub mod CowProtocolToken {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: MAX_YEARLY_INFLATIONReturn = r.into();
+                        let r: allowanceReturn = r.into();
                         r._0
                     },
                 )
@@ -1429,28 +1283,33 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: MAX_YEARLY_INFLATIONReturn = r.into();
+                    let r: allowanceReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `TIME_BETWEEN_MINTINGS()` and selector `0xcd42dcbe`.
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
     ```solidity
-    function TIME_BETWEEN_MINTINGS() external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct TIME_BETWEEN_MINTINGSCall;
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`TIME_BETWEEN_MINTINGS()`](TIME_BETWEEN_MINTINGSCall) function.
+    /// [`approve(address,uint256)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct TIME_BETWEEN_MINTINGSReturn {
+    pub struct approveReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -1463,9 +1322,15 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1477,25 +1342,28 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<TIME_BETWEEN_MINTINGSCall> for UnderlyingRustTuple<'_> {
-                fn from(value: TIME_BETWEEN_MINTINGSCall) -> Self {
-                    ()
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for TIME_BETWEEN_MINTINGSCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1507,29 +1375,32 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<TIME_BETWEEN_MINTINGSReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: TIME_BETWEEN_MINTINGSReturn) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for TIME_BETWEEN_MINTINGSReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for TIME_BETWEEN_MINTINGSCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [205u8, 66u8, 220u8, 190u8];
-            const SIGNATURE: &'static str = "TIME_BETWEEN_MINTINGS()";
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -1540,23 +1411,26 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
                 (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.amount,
                     ),
                 )
             }
 
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: TIME_BETWEEN_MINTINGSReturn = r.into();
+                        let r: approveReturn = r.into();
                         r._0
                     },
                 )
@@ -1568,31 +1442,29 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: TIME_BETWEEN_MINTINGSReturn = r.into();
+                    let r: approveReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
     ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
+    pub struct balanceOfCall {
         #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
+        pub account: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
+    /// [`balanceOf(address)`](balanceOfCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceReturn {
+    pub struct balanceOfReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -1607,15 +1479,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1627,19 +1493,16 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.account,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
+                    Self { account: tuple.0 }
                 }
             }
         }
@@ -1660,32 +1523,29 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
 
             #[inline]
             fn new<'a>(
@@ -1698,10 +1558,7 @@ pub mod CowProtocolToken {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self.account,
                     ),
                 )
             }
@@ -1719,7 +1576,7 @@ pub mod CowProtocolToken {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: allowanceReturn = r.into();
+                        let r: balanceOfReturn = r.into();
                         r._0
                     },
                 )
@@ -1731,33 +1588,28 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: allowanceReturn = r.into();
+                    let r: balanceOfReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    /**Function with signature `decimals()` and selector `0x313ce567`.
     ```solidity
-    function approve(address spender, uint256 amount) external returns (bool);
+    function decimals() external view returns (uint8);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct decimalsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
+    /// [`decimals()`](decimalsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveReturn {
+    pub struct decimalsReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub _0: u8,
     }
     #[allow(
         non_camel_case_types,
@@ -1770,15 +1622,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1790,28 +1636,25 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.amount)
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        amount: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (u8,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1823,32 +1666,29 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
 
             #[inline]
             fn new<'a>(
@@ -1859,26 +1699,19 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: approveReturn = r.into();
+                        let r: decimalsReturn = r.into();
                         r._0
                     },
                 )
@@ -1890,32 +1723,30 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: approveReturn = r.into();
+                    let r: decimalsReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
     ```solidity
-    function balanceOf(address account) external view returns (uint256);
+    function mint(address target, uint256 amount) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct balanceOfCall {
+    pub struct mintCall {
         #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
+        pub target: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
+    /// [`mint(address,uint256)`](mintCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct balanceOfReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct mintReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -1927,9 +1758,15 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1941,25 +1778,28 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.account,)
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.target, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
+                    Self {
+                        target: tuple.0,
+                        amount: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1971,29 +1811,37 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = mintReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -2006,28 +1854,23 @@ pub mod CowProtocolToken {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
+                        &self.target,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                mintReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: balanceOfReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2035,29 +1878,26 @@ pub mod CowProtocolToken {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: balanceOfReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cowDao()` and selector `0xe2d51489`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function cowDao() external view returns (address);
+    function name() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct cowDaoCall;
+    pub struct nameCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`cowDao()`](cowDaoCall)
+    ///Container type for the return parameters of the [`name()`](nameCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct cowDaoReturn {
+    pub struct nameReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -2084,14 +1924,14 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<cowDaoCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cowDaoCall) -> Self {
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowDaoCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -2100,9 +1940,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2114,29 +1954,29 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<cowDaoReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cowDaoReturn) -> Self {
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowDaoReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for cowDaoCall {
+        impl alloy_sol_types::SolCall for nameCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [226u8, 213u8, 20u8, 137u8];
-            const SIGNATURE: &'static str = "cowDao()";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -2152,14 +1992,14 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: cowDaoReturn = r.into();
+                        let r: nameReturn = r.into();
                         r._0
                     },
                 )
@@ -2171,28 +2011,31 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: cowDaoReturn = r.into();
+                    let r: nameReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function decimals() external view returns (uint8);
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decimalsCall;
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decimalsReturn {
+    pub struct noncesReturn {
         #[allow(missing_docs)]
-        pub _0: u8,
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -2205,9 +2048,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2219,25 +2062,25 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
-                    ()
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self { owner: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2249,29 +2092,29 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
-            type Parameters<'a> = ();
-            type Return = u8;
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -2282,19 +2125,27 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: decimalsReturn = r.into();
+                        let r: noncesReturn = r.into();
                         r._0
                     },
                 )
@@ -2306,34 +2157,41 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: decimalsReturn = r.into();
+                    let r: noncesReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decreaseAllowanceCall {
+    pub struct permitCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
         pub spender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
     }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decreaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2347,12 +2205,22 @@ pub mod CowProtocolToken {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -2365,18 +2233,31 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceCall) -> Self {
-                    (value.spender, value.subtractedValue)
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        spender: tuple.0,
-                        subtractedValue: tuple.1,
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
                     }
                 }
             }
@@ -2384,9 +2265,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2398,32 +2279,43 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+        impl alloy_sol_types::SolCall for permitCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
             );
-            type Return = bool;
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
-            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -2436,27 +2328,38 @@ pub mod CowProtocolToken {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self.owner,
                     ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.subtractedValue,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
                     ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decreaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2464,34 +2367,32 @@ pub mod CowProtocolToken {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: decreaseAllowanceReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
+    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
     ```solidity
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getStorageAtCall {
+    pub struct simulateDelegatecallCall {
         #[allow(missing_docs)]
-        pub offset: alloy_sol_types::private::primitives::aliases::U256,
+        pub targetContract: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub length: alloy_sol_types::private::primitives::aliases::U256,
+        pub calldataPayload: alloy_sol_types::private::Bytes,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
+    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getStorageAtReturn {
+    pub struct simulateDelegatecallReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
+        pub response: alloy_sol_types::private::Bytes,
     }
     #[allow(
         non_camel_case_types,
@@ -2505,13 +2406,13 @@ pub mod CowProtocolToken {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -2524,18 +2425,18 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtCall) -> Self {
-                    (value.offset, value.length)
+            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        offset: tuple.0,
-                        length: tuple.1,
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
                     }
                 }
             }
@@ -2543,1410 +2444,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getStorageAtCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
-            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.offset,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.length,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getStorageAtReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getStorageAtReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
-    ```solidity
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceCall) -> Self {
-                    (value.spender, value.addedValue)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        addedValue: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
-            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.addedValue,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: increaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: increaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
-    ```solidity
-    function mint(address target, uint256 amount) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintCall {
-        #[allow(missing_docs)]
-        pub target: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`mint(address,uint256)`](mintCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
-                fn from(value: mintCall) -> Self {
-                    (value.target, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        target: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: mintReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl mintReturn {
-            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for mintCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = mintReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
-            const SIGNATURE: &'static str = "mint(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.target,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                mintReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
-    ```solidity
-    function name() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: nameReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: nameReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
-    ```solidity
-    function nonces(address owner) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: noncesReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: noncesReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
-    ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = permitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
-    ```solidity
-    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallReturn {
-        #[allow(missing_docs)]
-        pub response: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallReturn) -> Self {
-                    (value.response,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { response: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
-            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: simulateDelegatecallReturn = r.into();
-                        r.response
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: simulateDelegatecallReturn = r.into();
-                    r.response
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulateDelegatecallInternal(address,bytes)` and selector `0x43218e19`.
-    ```solidity
-    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallInternalCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`simulateDelegatecallInternal(address,
-    /// bytes)`](simulateDelegatecallInternalCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallInternalReturn {
-        #[allow(missing_docs)]
-        pub response: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallInternalCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallInternalCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallInternalReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallInternalReturn) -> Self {
-                    (value.response,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { response: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateDelegatecallInternalCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [67u8, 33u8, 142u8, 25u8];
-            const SIGNATURE: &'static str = "simulateDelegatecallInternal(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: simulateDelegatecallInternalReturn = r.into();
-                        r.response
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: simulateDelegatecallInternalReturn = r.into();
-                    r.response
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `symbol()` and selector `0x95d89b41`.
-    ```solidity
-    function symbol() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`symbol()`](symbolCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct symbolReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: symbolReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for symbolCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
-            const SIGNATURE: &'static str = "symbol()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: symbolReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: symbolReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `timestampLastMinting()` and selector `0xfde9e07a`.
-    ```solidity
-    function timestampLastMinting() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct timestampLastMintingCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`timestampLastMinting()`](timestampLastMintingCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct timestampLastMintingReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<timestampLastMintingCall> for UnderlyingRustTuple<'_> {
-                fn from(value: timestampLastMintingCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for timestampLastMintingCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3958,29 +2458,32 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<timestampLastMintingReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: timestampLastMintingReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallReturn) -> Self {
+                    (value.response,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for timestampLastMintingReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { response: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for timestampLastMintingCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [253u8, 233u8, 224u8, 122u8];
-            const SIGNATURE: &'static str = "timestampLastMinting()";
+            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
+            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -3991,24 +2494,27 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: timestampLastMintingReturn = r.into();
-                        r._0
+                        let r: simulateDelegatecallReturn = r.into();
+                        r.response
                     },
                 )
             }
@@ -4019,28 +2525,28 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: timestampLastMintingReturn = r.into();
-                    r._0
+                    let r: simulateDelegatecallReturn = r.into();
+                    r.response
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
+    /**Function with signature `symbol()` and selector `0x95d89b41`.
     ```solidity
-    function totalSupply() external view returns (uint256);
+    function symbol() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyCall;
+    pub struct symbolCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
+    ///Container type for the return parameters of the [`symbol()`](symbolCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct totalSupplyReturn {
+    pub struct symbolReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -4067,14 +2573,14 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
+            impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -4083,9 +2589,9 @@ pub mod CowProtocolToken {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4097,29 +2603,29 @@ pub mod CowProtocolToken {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
+            impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: symbolReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
+        impl alloy_sol_types::SolCall for symbolCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
+            const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
+            const SIGNATURE: &'static str = "symbol()";
 
             #[inline]
             fn new<'a>(
@@ -4135,18 +2641,14 @@ pub mod CowProtocolToken {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: totalSupplyReturn = r.into();
+                        let r: symbolReturn = r.into();
                         r._0
                     },
                 )
@@ -4158,7 +2660,7 @@ pub mod CowProtocolToken {
                     data,
                 )
                 .map(|r| {
-                    let r: totalSupplyReturn = r.into();
+                    let r: symbolReturn = r.into();
                     r._0
                 })
             }
@@ -4497,26 +2999,14 @@ pub mod CowProtocolToken {
         #[allow(missing_docs)]
         DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
         #[allow(missing_docs)]
-        MAX_YEARLY_INFLATION(MAX_YEARLY_INFLATIONCall),
-        #[allow(missing_docs)]
-        TIME_BETWEEN_MINTINGS(TIME_BETWEEN_MINTINGSCall),
-        #[allow(missing_docs)]
         allowance(allowanceCall),
         #[allow(missing_docs)]
         approve(approveCall),
         #[allow(missing_docs)]
         balanceOf(balanceOfCall),
         #[allow(missing_docs)]
-        cowDao(cowDaoCall),
-        #[allow(missing_docs)]
         decimals(decimalsCall),
         #[allow(missing_docs)]
-        decreaseAllowance(decreaseAllowanceCall),
-        #[allow(missing_docs)]
-        getStorageAt(getStorageAtCall),
-        #[allow(missing_docs)]
-        increaseAllowance(increaseAllowanceCall),
-        #[allow(missing_docs)]
         mint(mintCall),
         #[allow(missing_docs)]
         name(nameCall),
@@ -4527,14 +3017,8 @@ pub mod CowProtocolToken {
         #[allow(missing_docs)]
         simulateDelegatecall(simulateDelegatecallCall),
         #[allow(missing_docs)]
-        simulateDelegatecallInternal(simulateDelegatecallInternalCall),
-        #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        timestampLastMinting(timestampLastMintingCall),
-        #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -4550,76 +3034,49 @@ pub mod CowProtocolToken {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [24u8, 22u8, 13u8, 221u8],
             [35u8, 184u8, 114u8, 221u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
-            [57u8, 80u8, 147u8, 81u8],
             [64u8, 193u8, 15u8, 25u8],
-            [67u8, 33u8, 142u8, 25u8],
-            [86u8, 36u8, 178u8, 91u8],
-            [88u8, 98u8, 191u8, 61u8],
             [112u8, 160u8, 130u8, 49u8],
             [126u8, 206u8, 190u8, 0u8],
             [149u8, 216u8, 155u8, 65u8],
-            [164u8, 87u8, 194u8, 215u8],
             [169u8, 5u8, 156u8, 187u8],
-            [205u8, 66u8, 220u8, 190u8],
             [213u8, 5u8, 172u8, 207u8],
             [221u8, 98u8, 237u8, 62u8],
-            [226u8, 213u8, 20u8, 137u8],
             [248u8, 68u8, 54u8, 189u8],
-            [253u8, 233u8, 224u8, 122u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cowDaoCall as alloy_sol_types::SolCall>::SIGNATURE,
             <simulateDelegatecallCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <timestampLastMintingCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(transferFrom),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(increaseAllowance),
             ::core::stringify!(mint),
-            ::core::stringify!(simulateDelegatecallInternal),
-            ::core::stringify!(getStorageAt),
-            ::core::stringify!(MAX_YEARLY_INFLATION),
             ::core::stringify!(balanceOf),
             ::core::stringify!(nonces),
             ::core::stringify!(symbol),
-            ::core::stringify!(decreaseAllowance),
             ::core::stringify!(transfer),
-            ::core::stringify!(TIME_BETWEEN_MINTINGS),
             ::core::stringify!(permit),
             ::core::stringify!(allowance),
-            ::core::stringify!(cowDao),
             ::core::stringify!(simulateDelegatecall),
-            ::core::stringify!(timestampLastMinting),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -4644,7 +3101,7 @@ pub mod CowProtocolToken {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for CowProtocolTokenCalls {
-        const COUNT: usize = 22usize;
+        const COUNT: usize = 13usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "CowProtocolTokenCalls";
 
@@ -4654,24 +3111,10 @@ pub mod CowProtocolToken {
                 Self::DOMAIN_SEPARATOR(_) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::MAX_YEARLY_INFLATION(_) => {
-                    <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::TIME_BETWEEN_MINTINGS(_) => {
-                    <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::cowDao(_) => <cowDaoCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseAllowance(_) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::increaseAllowance(_) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
@@ -4679,14 +3122,7 @@ pub mod CowProtocolToken {
                 Self::simulateDelegatecall(_) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::simulateDelegatecallInternal(_) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::timestampLastMinting(_) => {
-                    <timestampLastMintingCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -4720,13 +3156,6 @@ pub mod CowProtocolToken {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -4750,15 +3179,6 @@ pub mod CowProtocolToken {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -4766,33 +3186,6 @@ pub mod CowProtocolToken {
                     }
                     mint
                 },
-                {
-                    fn simulateDelegatecallInternal(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::simulateDelegatecallInternal)
-                    }
-                    simulateDelegatecallInternal
-                },
-                {
-                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
-                {
-                    fn MAX_YEARLY_INFLATION(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::MAX_YEARLY_INFLATION)
-                    }
-                    MAX_YEARLY_INFLATION
-                },
                 {
                     fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -4814,15 +3207,6 @@ pub mod CowProtocolToken {
                     }
                     symbol
                 },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -4830,17 +3214,6 @@ pub mod CowProtocolToken {
                     }
                     transfer
                 },
-                {
-                    fn TIME_BETWEEN_MINTINGS(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(CowProtocolTokenCalls::TIME_BETWEEN_MINTINGS)
-                    }
-                    TIME_BETWEEN_MINTINGS
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -4855,13 +3228,6 @@ pub mod CowProtocolToken {
                     }
                     allowance
                 },
-                {
-                    fn cowDao(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <cowDaoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::cowDao)
-                    }
-                    cowDao
-                },
                 {
                     fn simulateDelegatecall(
                         data: &[u8],
@@ -4871,15 +3237,6 @@ pub mod CowProtocolToken {
                     }
                     simulateDelegatecall
                 },
-                {
-                    fn timestampLastMinting(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CowProtocolTokenCalls::timestampLastMinting)
-                    }
-                    timestampLastMinting
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -4915,13 +3272,6 @@ pub mod CowProtocolToken {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowProtocolTokenCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -4949,17 +3299,6 @@ pub mod CowProtocolToken {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -4967,37 +3306,6 @@ pub mod CowProtocolToken {
                     }
                     mint
                 },
-                {
-                    fn simulateDelegatecallInternal(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::simulateDelegatecallInternal)
-                    }
-                    simulateDelegatecallInternal
-                },
-                {
-                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(CowProtocolTokenCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
-                {
-                    fn MAX_YEARLY_INFLATION(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::MAX_YEARLY_INFLATION)
-                    }
-                    MAX_YEARLY_INFLATION
-                },
                 {
                     fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5019,17 +3327,6 @@ pub mod CowProtocolToken {
                     }
                     symbol
                 },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5037,17 +3334,6 @@ pub mod CowProtocolToken {
                     }
                     transfer
                 },
-                {
-                    fn TIME_BETWEEN_MINTINGS(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::TIME_BETWEEN_MINTINGS)
-                    }
-                    TIME_BETWEEN_MINTINGS
-                },
                 {
                     fn permit(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
                         <permitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5062,13 +3348,6 @@ pub mod CowProtocolToken {
                     }
                     allowance
                 },
-                {
-                    fn cowDao(data: &[u8]) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <cowDaoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CowProtocolTokenCalls::cowDao)
-                    }
-                    cowDao
-                },
                 {
                     fn simulateDelegatecall(
                         data: &[u8],
@@ -5080,17 +3359,6 @@ pub mod CowProtocolToken {
                     }
                     simulateDelegatecall
                 },
-                {
-                    fn timestampLastMinting(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CowProtocolTokenCalls> {
-                        <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CowProtocolTokenCalls::timestampLastMinting)
-                    }
-                    timestampLastMinting
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -5107,12 +3375,6 @@ pub mod CowProtocolToken {
                 Self::DOMAIN_SEPARATOR(inner) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::MAX_YEARLY_INFLATION(inner) => {
-                    <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::TIME_BETWEEN_MINTINGS(inner) => {
-                    <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5122,21 +3384,9 @@ pub mod CowProtocolToken {
                 Self::balanceOf(inner) => {
                     <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::cowDao(inner) => {
-                    <cowDaoCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5152,20 +3402,9 @@ pub mod CowProtocolToken {
                 Self::simulateDelegatecall(inner) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::simulateDelegatecallInternal(inner) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::timestampLastMinting(inner) => {
-                    <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5181,16 +3420,6 @@ pub mod CowProtocolToken {
                 Self::DOMAIN_SEPARATOR(inner) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::MAX_YEARLY_INFLATION(inner) => {
-                    <MAX_YEARLY_INFLATIONCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::TIME_BETWEEN_MINTINGS(inner) => {
-                    <TIME_BETWEEN_MINTINGSCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -5200,21 +3429,9 @@ pub mod CowProtocolToken {
                 Self::balanceOf(inner) => {
                     <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::cowDao(inner) => {
-                    <cowDaoCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -5232,22 +3449,9 @@ pub mod CowProtocolToken {
                         inner, out,
                     )
                 }
-                Self::simulateDelegatecallInternal(inner) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::timestampLastMinting(inner) => {
-                    <timestampLastMintingCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -5777,22 +3981,6 @@ pub mod CowProtocolToken {
             self.call_builder(&DOMAIN_SEPARATORCall)
         }
 
-        ///Creates a new call builder for the [`MAX_YEARLY_INFLATION`]
-        /// function.
-        pub fn MAX_YEARLY_INFLATION(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, MAX_YEARLY_INFLATIONCall, N> {
-            self.call_builder(&MAX_YEARLY_INFLATIONCall)
-        }
-
-        ///Creates a new call builder for the [`TIME_BETWEEN_MINTINGS`]
-        /// function.
-        pub fn TIME_BETWEEN_MINTINGS(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, TIME_BETWEEN_MINTINGSCall, N> {
-            self.call_builder(&TIME_BETWEEN_MINTINGSCall)
-        }
-
         ///Creates a new call builder for the [`allowance`] function.
         pub fn allowance(
             &self,
@@ -5819,49 +4007,11 @@ pub mod CowProtocolToken {
             self.call_builder(&balanceOfCall { account })
         }
 
-        ///Creates a new call builder for the [`cowDao`] function.
-        pub fn cowDao(&self) -> alloy_contract::SolCallBuilder<&P, cowDaoCall, N> {
-            self.call_builder(&cowDaoCall)
-        }
-
         ///Creates a new call builder for the [`decimals`] function.
         pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`decreaseAllowance`] function.
-        pub fn decreaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
-            self.call_builder(&decreaseAllowanceCall {
-                spender,
-                subtractedValue,
-            })
-        }
-
-        ///Creates a new call builder for the [`getStorageAt`] function.
-        pub fn getStorageAt(
-            &self,
-            offset: alloy_sol_types::private::primitives::aliases::U256,
-            length: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
-            self.call_builder(&getStorageAtCall { offset, length })
-        }
-
-        ///Creates a new call builder for the [`increaseAllowance`] function.
-        pub fn increaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            addedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
-            self.call_builder(&increaseAllowanceCall {
-                spender,
-                addedValue,
-            })
-        }
-
         ///Creates a new call builder for the [`mint`] function.
         pub fn mint(
             &self,
@@ -5919,37 +4069,11 @@ pub mod CowProtocolToken {
             })
         }
 
-        ///Creates a new call builder for the [`simulateDelegatecallInternal`]
-        /// function.
-        pub fn simulateDelegatecallInternal(
-            &self,
-            targetContract: alloy_sol_types::private::Address,
-            calldataPayload: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallInternalCall, N> {
-            self.call_builder(&simulateDelegatecallInternalCall {
-                targetContract,
-                calldataPayload,
-            })
-        }
-
         ///Creates a new call builder for the [`symbol`] function.
         pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`timestampLastMinting`]
-        /// function.
-        pub fn timestampLastMinting(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, timestampLastMintingCall, N> {
-            self.call_builder(&timestampLastMintingCall)
-        }
-
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs b/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
index a95fc944a7..272812c50a 100644
--- a/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
+++ b/contracts/generated/contracts-generated/cowswapethflow/src/lib.rs
@@ -1656,7 +1656,6 @@ interface CoWSwapEthFlow {
 
     receive() external payable;
 
-    function cowSwapSettlement() external view returns (address);
     function createOrder(EthFlowOrder.Data memory order) external payable returns (bytes32 orderHash);
     function invalidateOrder(EthFlowOrder.Data memory order) external;
     function invalidateOrdersIgnoringNotAllowed(EthFlowOrder.Data[] memory orderArray) external;
@@ -1664,8 +1663,6 @@ interface CoWSwapEthFlow {
     function orders(bytes32) external view returns (address owner, uint32 validTo);
     function unwrap(uint256 amount) external;
     function wrap(uint256 amount) external;
-    function wrapAll() external;
-    function wrappedNativeToken() external view returns (address);
 }
 ```
 
@@ -1692,19 +1689,6 @@ interface CoWSwapEthFlow {
     "type": "receive",
     "stateMutability": "payable"
   },
-  {
-    "type": "function",
-    "name": "cowSwapSettlement",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract ICoWSwapSettlement"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "createOrder",
@@ -1965,26 +1949,6 @@ interface CoWSwapEthFlow {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "wrapAll",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "wrappedNativeToken",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IWrappedNativeToken"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "event",
     "name": "OrderInvalidation",
@@ -3154,141 +3118,6 @@ pub mod CoWSwapEthFlow {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cowSwapSettlement()` and selector `0xec30bb88`.
-    ```solidity
-    function cowSwapSettlement() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cowSwapSettlementCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`cowSwapSettlement()`](cowSwapSettlementCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cowSwapSettlementReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cowSwapSettlementCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cowSwapSettlementCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowSwapSettlementCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cowSwapSettlementReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cowSwapSettlementReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cowSwapSettlementReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cowSwapSettlementCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [236u8, 48u8, 187u8, 136u8];
-            const SIGNATURE: &'static str = "cowSwapSettlement()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: cowSwapSettlementReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: cowSwapSettlementReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `createOrder((address,address,uint256,uint256,bytes32,uint256,uint32,bool,int64))` and selector `0x322bba21`.
     ```solidity
     function createOrder(EthFlowOrder.Data memory order) external payable returns (bytes32 orderHash);
@@ -4314,275 +4143,9 @@ pub mod CoWSwapEthFlow {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `wrapAll()` and selector `0x4c84c1c8`.
-    ```solidity
-    function wrapAll() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct wrapAllCall;
-    ///Container type for the return parameters of the
-    /// [`wrapAll()`](wrapAllCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct wrapAllReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<wrapAllCall> for UnderlyingRustTuple<'_> {
-                fn from(value: wrapAllCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrapAllCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<wrapAllReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: wrapAllReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrapAllReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl wrapAllReturn {
-            fn _tokenize(&self) -> <wrapAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for wrapAllCall {
-            type Parameters<'a> = ();
-            type Return = wrapAllReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [76u8, 132u8, 193u8, 200u8];
-            const SIGNATURE: &'static str = "wrapAll()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                wrapAllReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `wrappedNativeToken()` and selector `0x17fcb39b`.
-    ```solidity
-    function wrappedNativeToken() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct wrappedNativeTokenCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`wrappedNativeToken()`](wrappedNativeTokenCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct wrappedNativeTokenReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<wrappedNativeTokenCall> for UnderlyingRustTuple<'_> {
-                fn from(value: wrappedNativeTokenCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrappedNativeTokenCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<wrappedNativeTokenReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: wrappedNativeTokenReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for wrappedNativeTokenReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for wrappedNativeTokenCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [23u8, 252u8, 179u8, 155u8];
-            const SIGNATURE: &'static str = "wrappedNativeToken()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: wrappedNativeTokenReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: wrappedNativeTokenReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
     ///Container for all the [`CoWSwapEthFlow`](self) function calls.
     #[derive(Clone)]
     pub enum CoWSwapEthFlowCalls {
-        #[allow(missing_docs)]
-        cowSwapSettlement(cowSwapSettlementCall),
         #[allow(missing_docs)]
         createOrder(createOrderCall),
         #[allow(missing_docs)]
@@ -4597,10 +4160,6 @@ pub mod CoWSwapEthFlow {
         unwrap(unwrapCall),
         #[allow(missing_docs)]
         wrap(wrapCall),
-        #[allow(missing_docs)]
-        wrapAll(wrapAllCall),
-        #[allow(missing_docs)]
-        wrappedNativeToken(wrappedNativeTokenCall),
     }
     impl CoWSwapEthFlowCalls {
         /// All the selectors of this enum.
@@ -4612,41 +4171,32 @@ pub mod CoWSwapEthFlow {
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [22u8, 38u8, 186u8, 126u8],
-            [23u8, 252u8, 179u8, 155u8],
             [50u8, 43u8, 186u8, 33u8],
-            [76u8, 132u8, 193u8, 200u8],
             [76u8, 183u8, 100u8, 152u8],
             [123u8, 196u8, 27u8, 150u8],
             [156u8, 63u8, 30u8, 144u8],
             [222u8, 14u8, 154u8, 62u8],
             [234u8, 89u8, 140u8, 176u8],
-            [236u8, 48u8, 187u8, 136u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <wrappedNativeTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
             <createOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <wrapAllCall as alloy_sol_types::SolCall>::SIGNATURE,
             <invalidateOrdersIgnoringNotAllowedCall as alloy_sol_types::SolCall>::SIGNATURE,
             <invalidateOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
             <ordersCall as alloy_sol_types::SolCall>::SIGNATURE,
             <unwrapCall as alloy_sol_types::SolCall>::SIGNATURE,
             <wrapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cowSwapSettlementCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(isValidSignature),
-            ::core::stringify!(wrappedNativeToken),
             ::core::stringify!(createOrder),
-            ::core::stringify!(wrapAll),
             ::core::stringify!(invalidateOrdersIgnoringNotAllowed),
             ::core::stringify!(invalidateOrder),
             ::core::stringify!(orders),
             ::core::stringify!(unwrap),
             ::core::stringify!(wrap),
-            ::core::stringify!(cowSwapSettlement),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -4671,16 +4221,13 @@ pub mod CoWSwapEthFlow {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for CoWSwapEthFlowCalls {
-        const COUNT: usize = 10usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 7usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
         const NAME: &'static str = "CoWSwapEthFlowCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::cowSwapSettlement(_) => {
-                    <cowSwapSettlementCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::createOrder(_) => <createOrderCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::invalidateOrder(_) => {
                     <invalidateOrderCall as alloy_sol_types::SolCall>::SELECTOR
@@ -4694,10 +4241,6 @@ pub mod CoWSwapEthFlow {
                 Self::orders(_) => <ordersCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::unwrap(_) => <unwrapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::wrap(_) => <wrapCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::wrapAll(_) => <wrapAllCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::wrappedNativeToken(_) => {
-                    <wrappedNativeTokenCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -4724,15 +4267,6 @@ pub mod CoWSwapEthFlow {
                     }
                     isValidSignature
                 },
-                {
-                    fn wrappedNativeToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
-                        <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CoWSwapEthFlowCalls::wrappedNativeToken)
-                    }
-                    wrappedNativeToken
-                },
                 {
                     fn createOrder(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
                         <createOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -4740,13 +4274,6 @@ pub mod CoWSwapEthFlow {
                     }
                     createOrder
                 },
-                {
-                    fn wrapAll(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
-                        <wrapAllCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CoWSwapEthFlowCalls::wrapAll)
-                    }
-                    wrapAll
-                },
                 {
                     fn invalidateOrdersIgnoringNotAllowed(
                         data: &[u8],
@@ -4788,15 +4315,6 @@ pub mod CoWSwapEthFlow {
                     }
                     wrap
                 },
-                {
-                    fn cowSwapSettlement(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
-                        <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(CoWSwapEthFlowCalls::cowSwapSettlement)
-                    }
-                    cowSwapSettlement
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -4828,17 +4346,6 @@ pub mod CoWSwapEthFlow {
                     }
                     isValidSignature
                 },
-                {
-                    fn wrappedNativeToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
-                        <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CoWSwapEthFlowCalls::wrappedNativeToken)
-                    }
-                    wrappedNativeToken
-                },
                 {
                     fn createOrder(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
                         <createOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -4846,13 +4353,6 @@ pub mod CoWSwapEthFlow {
                     }
                     createOrder
                 },
-                {
-                    fn wrapAll(data: &[u8]) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
-                        <wrapAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(CoWSwapEthFlowCalls::wrapAll)
-                    }
-                    wrapAll
-                },
                 {
                     fn invalidateOrdersIgnoringNotAllowed(
                         data: &[u8],
@@ -4896,17 +4396,6 @@ pub mod CoWSwapEthFlow {
                     }
                     wrap
                 },
-                {
-                    fn cowSwapSettlement(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<CoWSwapEthFlowCalls> {
-                        <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(CoWSwapEthFlowCalls::cowSwapSettlement)
-                    }
-                    cowSwapSettlement
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -4920,11 +4409,6 @@ pub mod CoWSwapEthFlow {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::cowSwapSettlement(inner) => {
-                    <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::createOrder(inner) => {
                     <createOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
                         inner,
@@ -4954,26 +4438,12 @@ pub mod CoWSwapEthFlow {
                 Self::wrap(inner) => {
                     <wrapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::wrapAll(inner) => {
-                    <wrapAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::wrappedNativeToken(inner) => {
-                    <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
             }
         }
 
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::cowSwapSettlement(inner) => {
-                    <cowSwapSettlementCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::createOrder(inner) => {
                     <createOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
                         inner,
@@ -5007,15 +4477,6 @@ pub mod CoWSwapEthFlow {
                 Self::wrap(inner) => {
                     <wrapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::wrapAll(inner) => {
-                    <wrapAllCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::wrappedNativeToken(inner) => {
-                    <wrappedNativeTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
             }
         }
     }
@@ -5693,13 +5154,6 @@ pub mod CoWSwapEthFlow {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`cowSwapSettlement`] function.
-        pub fn cowSwapSettlement(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, cowSwapSettlementCall, N> {
-            self.call_builder(&cowSwapSettlementCall)
-        }
-
         ///Creates a new call builder for the [`createOrder`] function.
         pub fn createOrder(
             &self,
@@ -5759,18 +5213,6 @@ pub mod CoWSwapEthFlow {
         ) -> alloy_contract::SolCallBuilder<&P, wrapCall, N> {
             self.call_builder(&wrapCall { amount })
         }
-
-        ///Creates a new call builder for the [`wrapAll`] function.
-        pub fn wrapAll(&self) -> alloy_contract::SolCallBuilder<&P, wrapAllCall, N> {
-            self.call_builder(&wrapAllCall)
-        }
-
-        ///Creates a new call builder for the [`wrappedNativeToken`] function.
-        pub fn wrappedNativeToken(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, wrappedNativeTokenCall, N> {
-            self.call_builder(&wrappedNativeTokenCall)
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/erc20/src/lib.rs b/contracts/generated/contracts-generated/erc20/src/lib.rs
index 0170198953..3117b2c8ee 100644
--- a/contracts/generated/contracts-generated/erc20/src/lib.rs
+++ b/contracts/generated/contracts-generated/erc20/src/lib.rs
@@ -20,11 +20,8 @@ interface ERC20 {
     function approve(address spender, uint256 amount) external returns (bool);
     function balanceOf(address account) external view returns (uint256);
     function decimals() external view returns (uint8);
-    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
     function name() external view returns (string memory);
     function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
     function transfer(address recipient, uint256 amount) external returns (bool);
     function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 }
@@ -129,54 +126,6 @@ interface ERC20 {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "decreaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "subtractedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "increaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "addedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "name",
@@ -203,19 +152,6 @@ interface ERC20 {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -1271,324 +1207,6 @@ pub mod ERC20 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
-    ```solidity
-    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decreaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceCall) -> Self {
-                    (value.spender, value.subtractedValue)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        subtractedValue: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
-            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.subtractedValue,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decreaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decreaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
-    ```solidity
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct increaseAllowanceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceCall) -> Self {
-                    (value.spender, value.addedValue)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        addedValue: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseAllowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
-            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.addedValue,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: increaseAllowanceReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: increaseAllowanceReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
     function name() external view returns (string memory);
@@ -1859,145 +1477,6 @@ pub mod ERC20 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
-    ```solidity
-    function totalSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: totalSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: totalSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
     ```solidity
     function transfer(address recipient, uint256 amount) external returns (bool);
@@ -2336,16 +1815,10 @@ pub mod ERC20 {
         #[allow(missing_docs)]
         decimals(decimalsCall),
         #[allow(missing_docs)]
-        decreaseAllowance(decreaseAllowanceCall),
-        #[allow(missing_docs)]
-        increaseAllowance(increaseAllowanceCall),
-        #[allow(missing_docs)]
         name(nameCall),
         #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -2361,13 +1834,10 @@ pub mod ERC20 {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [24u8, 22u8, 13u8, 221u8],
             [35u8, 184u8, 114u8, 221u8],
             [49u8, 60u8, 229u8, 103u8],
-            [57u8, 80u8, 147u8, 81u8],
             [112u8, 160u8, 130u8, 49u8],
             [149u8, 216u8, 155u8, 65u8],
-            [164u8, 87u8, 194u8, 215u8],
             [169u8, 5u8, 156u8, 187u8],
             [221u8, 98u8, 237u8, 62u8],
         ];
@@ -2375,13 +1845,10 @@ pub mod ERC20 {
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
@@ -2389,13 +1856,10 @@ pub mod ERC20 {
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(transferFrom),
             ::core::stringify!(decimals),
-            ::core::stringify!(increaseAllowance),
             ::core::stringify!(balanceOf),
             ::core::stringify!(symbol),
-            ::core::stringify!(decreaseAllowance),
             ::core::stringify!(transfer),
             ::core::stringify!(allowance),
         ];
@@ -2422,7 +1886,7 @@ pub mod ERC20 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for ERC20Calls {
-        const COUNT: usize = 11usize;
+        const COUNT: usize = 8usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "ERC20Calls";
 
@@ -2433,15 +1897,8 @@ pub mod ERC20 {
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseAllowance(_) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::increaseAllowance(_) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -2475,13 +1932,6 @@ pub mod ERC20 {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20Calls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2496,13 +1946,6 @@ pub mod ERC20 {
                     }
                     decimals
                 },
-                {
-                    fn increaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20Calls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
                 {
                     fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
                         <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2517,13 +1960,6 @@ pub mod ERC20 {
                     }
                     symbol
                 },
-                {
-                    fn decreaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20Calls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2569,13 +2005,6 @@ pub mod ERC20 {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ERC20Calls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -2592,15 +2021,6 @@ pub mod ERC20 {
                     }
                     decimals
                 },
-                {
-                    fn increaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ERC20Calls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
                 {
                     fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
                         <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -2615,15 +2035,6 @@ pub mod ERC20 {
                     }
                     symbol
                 },
-                {
-                    fn decreaseAllowance(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ERC20Calls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20Calls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -2663,21 +2074,12 @@ pub mod ERC20 {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -2702,21 +2104,12 @@ pub mod ERC20 {
                 Self::decimals(inner) => {
                     <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::name(inner) => {
                     <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -2971,30 +2364,6 @@ pub mod ERC20 {
             self.call_builder(&decimalsCall)
         }
 
-        ///Creates a new call builder for the [`decreaseAllowance`] function.
-        pub fn decreaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
-            self.call_builder(&decreaseAllowanceCall {
-                spender,
-                subtractedValue,
-            })
-        }
-
-        ///Creates a new call builder for the [`increaseAllowance`] function.
-        pub fn increaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            addedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
-            self.call_builder(&increaseAllowanceCall {
-                spender,
-                addedValue,
-            })
-        }
-
         ///Creates a new call builder for the [`name`] function.
         pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
             self.call_builder(&nameCall)
@@ -3005,11 +2374,6 @@ pub mod ERC20 {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/erc20mintable/src/lib.rs b/contracts/generated/contracts-generated/erc20mintable/src/lib.rs
index d8c69b0f31..9491880637 100644
--- a/contracts/generated/contracts-generated/erc20mintable/src/lib.rs
+++ b/contracts/generated/contracts-generated/erc20mintable/src/lib.rs
@@ -16,16 +16,10 @@ interface ERC20Mintable {
     event MinterRemoved(address indexed account);
     event Transfer(address indexed from, address indexed to, uint256 value);
 
-    function addMinter(address account) external;
     function allowance(address owner, address spender) external view returns (uint256);
     function approve(address spender, uint256 amount) external returns (bool);
     function balanceOf(address account) external view returns (uint256);
-    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
-    function isMinter(address account) external view returns (bool);
     function mint(address account, uint256 amount) external returns (bool);
-    function renounceMinter() external;
-    function totalSupply() external view returns (uint256);
     function transfer(address recipient, uint256 amount) external returns (bool);
     function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 }
@@ -34,19 +28,6 @@ interface ERC20Mintable {
 ...which was generated by the following JSON ABI:
 ```json
 [
-  {
-    "type": "function",
-    "name": "addMinter",
-    "inputs": [
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "allowance",
@@ -114,73 +95,6 @@ interface ERC20Mintable {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "decreaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "subtractedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "increaseAllowance",
-    "inputs": [
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "addedValue",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "isMinter",
-    "inputs": [
-      {
-        "name": "account",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "mint",
@@ -205,26 +119,6 @@ interface ERC20Mintable {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "renounceMinter",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -848,142 +742,6 @@ pub mod ERC20Mintable {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addMinter(address)` and selector `0x983b2d56`.
-    ```solidity
-    function addMinter(address account) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addMinterCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`addMinter(address)`](addMinterCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addMinterReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addMinterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addMinterCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addMinterCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addMinterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addMinterReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addMinterReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl addMinterReturn {
-            fn _tokenize(&self) -> <addMinterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addMinterCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = addMinterReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [152u8, 59u8, 45u8, 86u8];
-            const SIGNATURE: &'static str = "addMinter(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addMinterReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
     function allowance(address owner, address spender) external view returns (uint256);
@@ -1452,24 +1210,24 @@ pub mod ERC20Mintable {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decreaseAllowance(address,uint256)` and selector `0xa457c2d7`.
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
     ```solidity
-    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
+    function mint(address account, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decreaseAllowanceCall {
+    pub struct mintCall {
         #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
+        pub account: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`decreaseAllowance(address,uint256)`](decreaseAllowanceCall) function.
+    /// [`mint(address,uint256)`](mintCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decreaseAllowanceReturn {
+    pub struct mintReturn {
         #[allow(missing_docs)]
         pub _0: bool,
     }
@@ -1504,18 +1262,18 @@ pub mod ERC20Mintable {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceCall) -> Self {
-                    (value.spender, value.subtractedValue)
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.account, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        spender: tuple.0,
-                        subtractedValue: tuple.1,
+                        account: tuple.0,
+                        amount: tuple.1,
                     }
                 }
             }
@@ -1537,21 +1295,21 @@ pub mod ERC20Mintable {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decreaseAllowanceReturn) -> Self {
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for decreaseAllowanceCall {
+        impl alloy_sol_types::SolCall for mintCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
@@ -1561,8 +1319,8 @@ pub mod ERC20Mintable {
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
-            const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -1575,10 +1333,10 @@ pub mod ERC20Mintable {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self.account,
                     ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.subtractedValue,
+                        &self.amount,
                     ),
                 )
             }
@@ -1592,7 +1350,7 @@ pub mod ERC20Mintable {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: decreaseAllowanceReturn = r.into();
+                        let r: mintReturn = r.into();
                         r._0
                     },
                 )
@@ -1604,31 +1362,31 @@ pub mod ERC20Mintable {
                     data,
                 )
                 .map(|r| {
-                    let r: decreaseAllowanceReturn = r.into();
+                    let r: mintReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseAllowance(address,uint256)` and selector `0x39509351`.
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
     ```solidity
-    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
+    function transfer(address recipient, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseAllowanceCall {
+    pub struct transferCall {
         #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
+        pub recipient: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub addedValue: alloy_sol_types::private::primitives::aliases::U256,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`increaseAllowance(address,uint256)`](increaseAllowanceCall) function.
+    /// [`transfer(address,uint256)`](transferCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseAllowanceReturn {
+    pub struct transferReturn {
         #[allow(missing_docs)]
         pub _0: bool,
     }
@@ -1663,18 +1421,18 @@ pub mod ERC20Mintable {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceCall) -> Self {
-                    (value.spender, value.addedValue)
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.recipient, value.amount)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        spender: tuple.0,
-                        addedValue: tuple.1,
+                        recipient: tuple.0,
+                        amount: tuple.1,
                     }
                 }
             }
@@ -1696,21 +1454,21 @@ pub mod ERC20Mintable {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseAllowanceReturn) -> Self {
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseAllowanceCall {
+        impl alloy_sol_types::SolCall for transferCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
@@ -1720,8 +1478,8 @@ pub mod ERC20Mintable {
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
-            const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -1734,10 +1492,10 @@ pub mod ERC20Mintable {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self.recipient,
                     ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.addedValue,
+                        &self.amount,
                     ),
                 )
             }
@@ -1751,7 +1509,7 @@ pub mod ERC20Mintable {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: increaseAllowanceReturn = r.into();
+                        let r: transferReturn = r.into();
                         r._0
                     },
                 )
@@ -1763,750 +1521,20 @@ pub mod ERC20Mintable {
                     data,
                 )
                 .map(|r| {
-                    let r: increaseAllowanceReturn = r.into();
+                    let r: transferReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isMinter(address)` and selector `0xaa271e1a`.
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
     ```solidity
-    function isMinter(address account) external view returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct isMinterCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isMinter(address)`](isMinterCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isMinterReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isMinterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isMinterCall) -> Self {
-                    (value.account,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isMinterCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { account: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isMinterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isMinterReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isMinterReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isMinterCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 39u8, 30u8, 26u8];
-            const SIGNATURE: &'static str = "isMinter(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isMinterReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isMinterReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
-    ```solidity
-    function mint(address account, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintCall {
-        #[allow(missing_docs)]
-        pub account: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`mint(address,uint256)`](mintCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
-                fn from(value: mintCall) -> Self {
-                    (value.account, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        account: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: mintReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for mintCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
-            const SIGNATURE: &'static str = "mint(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.account,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: mintReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: mintReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `renounceMinter()` and selector `0x98650275`.
-    ```solidity
-    function renounceMinter() external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct renounceMinterCall;
-    ///Container type for the return parameters of the
-    /// [`renounceMinter()`](renounceMinterCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct renounceMinterReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<renounceMinterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: renounceMinterCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceMinterCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<renounceMinterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: renounceMinterReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceMinterReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl renounceMinterReturn {
-            fn _tokenize(
-                &self,
-            ) -> <renounceMinterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for renounceMinterCall {
-            type Parameters<'a> = ();
-            type Return = renounceMinterReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [152u8, 101u8, 2u8, 117u8];
-            const SIGNATURE: &'static str = "renounceMinter()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                renounceMinterReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
-    ```solidity
-    function totalSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: totalSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: totalSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
-    ```solidity
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`transfer(address,uint256)`](transferCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferCall) -> Self {
-                    (value.recipient, value.amount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        amount: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
-            const SIGNATURE: &'static str = "transfer(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: transferReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: transferReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
-    ```solidity
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferFromCall {
+    pub struct transferFromCall {
         #[allow(missing_docs)]
         pub sender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -2670,8 +1698,6 @@ pub mod ERC20Mintable {
     ///Container for all the [`ERC20Mintable`](self) function calls.
     #[derive(Clone)]
     pub enum ERC20MintableCalls {
-        #[allow(missing_docs)]
-        addMinter(addMinterCall),
         #[allow(missing_docs)]
         allowance(allowanceCall),
         #[allow(missing_docs)]
@@ -2679,18 +1705,8 @@ pub mod ERC20Mintable {
         #[allow(missing_docs)]
         balanceOf(balanceOfCall),
         #[allow(missing_docs)]
-        decreaseAllowance(decreaseAllowanceCall),
-        #[allow(missing_docs)]
-        increaseAllowance(increaseAllowanceCall),
-        #[allow(missing_docs)]
-        isMinter(isMinterCall),
-        #[allow(missing_docs)]
         mint(mintCall),
         #[allow(missing_docs)]
-        renounceMinter(renounceMinterCall),
-        #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -2705,46 +1721,28 @@ pub mod ERC20Mintable {
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [9u8, 94u8, 167u8, 179u8],
-            [24u8, 22u8, 13u8, 221u8],
             [35u8, 184u8, 114u8, 221u8],
-            [57u8, 80u8, 147u8, 81u8],
             [64u8, 193u8, 15u8, 25u8],
             [112u8, 160u8, 130u8, 49u8],
-            [152u8, 59u8, 45u8, 86u8],
-            [152u8, 101u8, 2u8, 117u8],
-            [164u8, 87u8, 194u8, 215u8],
             [169u8, 5u8, 156u8, 187u8],
-            [170u8, 39u8, 30u8, 26u8],
             [221u8, 98u8, 237u8, 62u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addMinterCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <renounceMinterCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <decreaseAllowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isMinterCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(approve),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(transferFrom),
-            ::core::stringify!(increaseAllowance),
             ::core::stringify!(mint),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(addMinter),
-            ::core::stringify!(renounceMinter),
-            ::core::stringify!(decreaseAllowance),
             ::core::stringify!(transfer),
-            ::core::stringify!(isMinter),
             ::core::stringify!(allowance),
         ];
 
@@ -2770,29 +1768,17 @@ pub mod ERC20Mintable {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for ERC20MintableCalls {
-        const COUNT: usize = 12usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 6usize;
+        const MIN_DATA_LENGTH: usize = 32usize;
         const NAME: &'static str = "ERC20MintableCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::addMinter(_) => <addMinterCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::decreaseAllowance(_) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::increaseAllowance(_) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::isMinter(_) => <isMinterCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::renounceMinter(_) => {
-                    <renounceMinterCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -2819,13 +1805,6 @@ pub mod ERC20Mintable {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20MintableCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2833,15 +1812,6 @@ pub mod ERC20Mintable {
                     }
                     transferFrom
                 },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20MintableCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2856,29 +1826,6 @@ pub mod ERC20Mintable {
                     }
                     balanceOf
                 },
-                {
-                    fn addMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <addMinterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20MintableCalls::addMinter)
-                    }
-                    addMinter
-                },
-                {
-                    fn renounceMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <renounceMinterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20MintableCalls::renounceMinter)
-                    }
-                    renounceMinter
-                },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20MintableCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2886,13 +1833,6 @@ pub mod ERC20Mintable {
                     }
                     transfer
                 },
-                {
-                    fn isMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <isMinterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ERC20MintableCalls::isMinter)
-                    }
-                    isMinter
-                },
                 {
                     fn allowance(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2927,13 +1867,6 @@ pub mod ERC20Mintable {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ERC20MintableCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -2943,17 +1876,6 @@ pub mod ERC20Mintable {
                     }
                     transferFrom
                 },
-                {
-                    fn increaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ERC20MintableCalls::increaseAllowance)
-                    }
-                    increaseAllowance
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -2968,33 +1890,6 @@ pub mod ERC20Mintable {
                     }
                     balanceOf
                 },
-                {
-                    fn addMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <addMinterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ERC20MintableCalls::addMinter)
-                    }
-                    addMinter
-                },
-                {
-                    fn renounceMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <renounceMinterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(ERC20MintableCalls::renounceMinter)
-                    }
-                    renounceMinter
-                },
-                {
-                    fn decreaseAllowance(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ERC20MintableCalls::decreaseAllowance)
-                    }
-                    decreaseAllowance
-                },
                 {
                     fn transfer(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -3002,13 +1897,6 @@ pub mod ERC20Mintable {
                     }
                     transfer
                 },
-                {
-                    fn isMinter(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
-                        <isMinterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ERC20MintableCalls::isMinter)
-                    }
-                    isMinter
-                },
                 {
                     fn allowance(data: &[u8]) -> alloy_sol_types::Result<ERC20MintableCalls> {
                         <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -3029,9 +1917,6 @@ pub mod ERC20Mintable {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::addMinter(inner) => {
-                    <addMinterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3041,24 +1926,9 @@ pub mod ERC20Mintable {
                 Self::balanceOf(inner) => {
                     <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::isMinter(inner) => {
-                    <isMinterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::renounceMinter(inner) => {
-                    <renounceMinterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -3071,9 +1941,6 @@ pub mod ERC20Mintable {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::addMinter(inner) => {
-                    <addMinterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3083,24 +1950,9 @@ pub mod ERC20Mintable {
                 Self::balanceOf(inner) => {
                     <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::decreaseAllowance(inner) => {
-                    <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::increaseAllowance(inner) => {
-                    <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::isMinter(inner) => {
-                    <isMinterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::renounceMinter(inner) => {
-                    <renounceMinterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3417,14 +2269,6 @@ pub mod ERC20Mintable {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`addMinter`] function.
-        pub fn addMinter(
-            &self,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, addMinterCall, N> {
-            self.call_builder(&addMinterCall { account })
-        }
-
         ///Creates a new call builder for the [`allowance`] function.
         pub fn allowance(
             &self,
@@ -3451,38 +2295,6 @@ pub mod ERC20Mintable {
             self.call_builder(&balanceOfCall { account })
         }
 
-        ///Creates a new call builder for the [`decreaseAllowance`] function.
-        pub fn decreaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            subtractedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
-            self.call_builder(&decreaseAllowanceCall {
-                spender,
-                subtractedValue,
-            })
-        }
-
-        ///Creates a new call builder for the [`increaseAllowance`] function.
-        pub fn increaseAllowance(
-            &self,
-            spender: alloy_sol_types::private::Address,
-            addedValue: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
-            self.call_builder(&increaseAllowanceCall {
-                spender,
-                addedValue,
-            })
-        }
-
-        ///Creates a new call builder for the [`isMinter`] function.
-        pub fn isMinter(
-            &self,
-            account: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isMinterCall, N> {
-            self.call_builder(&isMinterCall { account })
-        }
-
         ///Creates a new call builder for the [`mint`] function.
         pub fn mint(
             &self,
@@ -3492,16 +2304,6 @@ pub mod ERC20Mintable {
             self.call_builder(&mintCall { account, amount })
         }
 
-        ///Creates a new call builder for the [`renounceMinter`] function.
-        pub fn renounceMinter(&self) -> alloy_contract::SolCallBuilder<&P, renounceMinterCall, N> {
-            self.call_builder(&renounceMinterCall)
-        }
-
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs b/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs
index 67a120838e..ef292f4028 100644
--- a/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/flashloanrouter/src/lib.rs
@@ -415,9 +415,7 @@ library LoanRequest {
 interface FlashLoanRouter {
     constructor(address _settlementContract);
 
-    function borrowerCallback(bytes memory encodedLoansWithSettlement) external;
     function flashLoanAndSettle(LoanRequest.Data[] memory loans, bytes memory settlement) external;
-    function settlementAuthentication() external view returns (address);
     function settlementContract() external view returns (address);
 }
 ```
@@ -436,19 +434,6 @@ interface FlashLoanRouter {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "borrowerCallback",
-    "inputs": [
-      {
-        "name": "encodedLoansWithSettlement",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "flashLoanAndSettle",
@@ -489,19 +474,6 @@ interface FlashLoanRouter {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "settlementAuthentication",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract ICowAuthentication"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "settlementContract",
@@ -613,146 +585,6 @@ pub mod FlashLoanRouter {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `borrowerCallback(bytes)` and selector `0x0efb1fb6`.
-    ```solidity
-    function borrowerCallback(bytes memory encodedLoansWithSettlement) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct borrowerCallbackCall {
-        #[allow(missing_docs)]
-        pub encodedLoansWithSettlement: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`borrowerCallback(bytes)`](borrowerCallbackCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct borrowerCallbackReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<borrowerCallbackCall> for UnderlyingRustTuple<'_> {
-                fn from(value: borrowerCallbackCall) -> Self {
-                    (value.encodedLoansWithSettlement,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for borrowerCallbackCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        encodedLoansWithSettlement: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<borrowerCallbackReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: borrowerCallbackReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for borrowerCallbackReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl borrowerCallbackReturn {
-            fn _tokenize(
-                &self,
-            ) -> <borrowerCallbackCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for borrowerCallbackCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Return = borrowerCallbackReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [14u8, 251u8, 31u8, 182u8];
-            const SIGNATURE: &'static str = "borrowerCallback(bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.encodedLoansWithSettlement,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                borrowerCallbackReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `flashLoanAndSettle((uint256,address,address,address)[],bytes)` and selector `0xe7c438c9`.
     ```solidity
     function flashLoanAndSettle(LoanRequest.Data[] memory loans, bytes memory settlement) external;
@@ -914,141 +746,6 @@ pub mod FlashLoanRouter {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `settlementAuthentication()` and selector `0x02ebcbea`.
-    ```solidity
-    function settlementAuthentication() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct settlementAuthenticationCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`settlementAuthentication()`](settlementAuthenticationCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct settlementAuthenticationReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<settlementAuthenticationCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settlementAuthenticationCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementAuthenticationCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<settlementAuthenticationReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settlementAuthenticationReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settlementAuthenticationReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for settlementAuthenticationCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 235u8, 203u8, 234u8];
-            const SIGNATURE: &'static str = "settlementAuthentication()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: settlementAuthenticationReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: settlementAuthenticationReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `settlementContract()` and selector `0xea42418b`.
     ```solidity
     function settlementContract() external view returns (address);
@@ -1186,13 +883,9 @@ pub mod FlashLoanRouter {
     ///Container for all the [`FlashLoanRouter`](self) function calls.
     #[derive(Clone)]
     pub enum FlashLoanRouterCalls {
-        #[allow(missing_docs)]
-        borrowerCallback(borrowerCallbackCall),
         #[allow(missing_docs)]
         flashLoanAndSettle(flashLoanAndSettleCall),
         #[allow(missing_docs)]
-        settlementAuthentication(settlementAuthenticationCall),
-        #[allow(missing_docs)]
         settlementContract(settlementContractCall),
     }
     impl FlashLoanRouterCalls {
@@ -1203,23 +896,15 @@ pub mod FlashLoanRouter {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 235u8, 203u8, 234u8],
-            [14u8, 251u8, 31u8, 182u8],
-            [231u8, 196u8, 56u8, 201u8],
-            [234u8, 66u8, 65u8, 139u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[231u8, 196u8, 56u8, 201u8], [234u8, 66u8, 65u8, 139u8]];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <settlementAuthenticationCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <borrowerCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
             <flashLoanAndSettleCall as alloy_sol_types::SolCall>::SIGNATURE,
             <settlementContractCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(settlementAuthentication),
-            ::core::stringify!(borrowerCallback),
             ::core::stringify!(flashLoanAndSettle),
             ::core::stringify!(settlementContract),
         ];
@@ -1246,22 +931,16 @@ pub mod FlashLoanRouter {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for FlashLoanRouterCalls {
-        const COUNT: usize = 4usize;
+        const COUNT: usize = 2usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "FlashLoanRouterCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::borrowerCallback(_) => {
-                    <borrowerCallbackCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::flashLoanAndSettle(_) => {
                     <flashLoanAndSettleCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::settlementAuthentication(_) => {
-                    <settlementAuthenticationCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::settlementContract(_) => {
                     <settlementContractCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -1282,26 +961,6 @@ pub mod FlashLoanRouter {
         #[allow(non_snake_case)]
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
             static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<FlashLoanRouterCalls>] = &[
-                {
-                    fn settlementAuthentication(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
-                        <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(FlashLoanRouterCalls::settlementAuthentication)
-                    }
-                    settlementAuthentication
-                },
-                {
-                    fn borrowerCallback(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
-                        <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(FlashLoanRouterCalls::borrowerCallback)
-                    }
-                    borrowerCallback
-                },
                 {
                     fn flashLoanAndSettle(
                         data: &[u8],
@@ -1340,28 +999,6 @@ pub mod FlashLoanRouter {
                 &[u8],
             )
                 -> alloy_sol_types::Result<FlashLoanRouterCalls>] = &[
-                {
-                    fn settlementAuthentication(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
-                        <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(FlashLoanRouterCalls::settlementAuthentication)
-                    }
-                    settlementAuthentication
-                },
-                {
-                    fn borrowerCallback(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<FlashLoanRouterCalls> {
-                        <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(FlashLoanRouterCalls::borrowerCallback)
-                    }
-                    borrowerCallback
-                },
                 {
                     fn flashLoanAndSettle(
                         data: &[u8],
@@ -1397,17 +1034,9 @@ pub mod FlashLoanRouter {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::borrowerCallback(inner) => {
-                    <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::flashLoanAndSettle(inner) => {
                     <flashLoanAndSettleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::settlementAuthentication(inner) => {
-                    <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::settlementContract(inner) => {
                     <settlementContractCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -1417,17 +1046,9 @@ pub mod FlashLoanRouter {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::borrowerCallback(inner) => {
-                    <borrowerCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::flashLoanAndSettle(inner) => {
                     <flashLoanAndSettleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::settlementAuthentication(inner) => {
-                    <settlementAuthenticationCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::settlementContract(inner) => {
                     <settlementContractCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -1609,16 +1230,6 @@ pub mod FlashLoanRouter {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`borrowerCallback`] function.
-        pub fn borrowerCallback(
-            &self,
-            encodedLoansWithSettlement: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, borrowerCallbackCall, N> {
-            self.call_builder(&borrowerCallbackCall {
-                encodedLoansWithSettlement,
-            })
-        }
-
         ///Creates a new call builder for the [`flashLoanAndSettle`] function.
         pub fn flashLoanAndSettle(
             &self,
@@ -1630,14 +1241,6 @@ pub mod FlashLoanRouter {
             self.call_builder(&flashLoanAndSettleCall { loans, settlement })
         }
 
-        ///Creates a new call builder for the [`settlementAuthentication`]
-        /// function.
-        pub fn settlementAuthentication(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, settlementAuthenticationCall, N> {
-            self.call_builder(&settlementAuthenticationCall)
-        }
-
         ///Creates a new call builder for the [`settlementContract`] function.
         pub fn settlementContract(
             &self,
diff --git a/contracts/generated/contracts-generated/gnosissafe/src/lib.rs b/contracts/generated/contracts-generated/gnosissafe/src/lib.rs
index 5194dadb85..53fdeadaef 100644
--- a/contracts/generated/contracts-generated/gnosissafe/src/lib.rs
+++ b/contracts/generated/contracts-generated/gnosissafe/src/lib.rs
@@ -313,36 +313,10 @@ interface GnosisSafe {
     receive() external payable;
 
     function VERSION() external view returns (string memory);
-    function addOwnerWithThreshold(address owner, uint256 _threshold) external;
-    function approveHash(bytes32 hashToApprove) external;
-    function approvedHashes(address, bytes32) external view returns (uint256);
-    function changeThreshold(uint256 _threshold) external;
-    function checkNSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures, uint256 requiredSignatures) external view;
-    function checkSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures) external view;
-    function disableModule(address prevModule, address module) external;
     function domainSeparator() external view returns (bytes32);
-    function enableModule(address module) external;
-    function encodeTransactionData(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes memory);
     function execTransaction(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address payable refundReceiver, bytes memory signatures) external payable returns (bool success);
-    function execTransactionFromModule(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success);
-    function execTransactionFromModuleReturnData(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success, bytes memory returnData);
-    function getChainId() external view returns (uint256);
-    function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next);
-    function getOwners() external view returns (address[] memory);
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
-    function getThreshold() external view returns (uint256);
-    function getTransactionHash(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes32);
-    function isModuleEnabled(address module) external view returns (bool);
-    function isOwner(address owner) external view returns (bool);
     function nonce() external view returns (uint256);
-    function removeOwner(address prevOwner, address owner, uint256 _threshold) external;
-    function requiredTxGas(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (uint256);
-    function setFallbackHandler(address handler) external;
-    function setGuard(address guard) external;
     function setup(address[] memory _owners, uint256 _threshold, address to, bytes memory data, address fallbackHandler, address paymentToken, uint256 payment, address payable paymentReceiver) external;
-    function signedMessages(bytes32) external view returns (uint256);
-    function simulateAndRevert(address targetContract, bytes memory calldataPayload) external;
-    function swapOwner(address prevOwner, address oldOwner, address newOwner) external;
 }
 ```
 
@@ -375,143 +349,6 @@ interface GnosisSafe {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "addOwnerWithThreshold",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "_threshold",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "approveHash",
-    "inputs": [
-      {
-        "name": "hashToApprove",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "approvedHashes",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "changeThreshold",
-    "inputs": [
-      {
-        "name": "_threshold",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "checkNSignatures",
-    "inputs": [
-      {
-        "name": "dataHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "signatures",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "requiredSignatures",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "checkSignatures",
-    "inputs": [
-      {
-        "name": "dataHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "signatures",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "disableModule",
-    "inputs": [
-      {
-        "name": "prevModule",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "module",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "domainSeparator",
@@ -527,20 +364,7 @@ interface GnosisSafe {
   },
   {
     "type": "function",
-    "name": "enableModule",
-    "inputs": [
-      {
-        "name": "module",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "encodeTransactionData",
+    "name": "execTransaction",
     "inputs": [
       {
         "name": "to",
@@ -585,797 +409,323 @@ interface GnosisSafe {
       {
         "name": "refundReceiver",
         "type": "address",
-        "internalType": "address"
+        "internalType": "address payable"
       },
       {
-        "name": "_nonce",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "signatures",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "success",
+        "type": "bool",
+        "internalType": "bool"
       }
     ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "nonce",
+    "inputs": [],
     "outputs": [
       {
         "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
+        "type": "uint256",
+        "internalType": "uint256"
       }
     ],
     "stateMutability": "view"
   },
   {
     "type": "function",
-    "name": "execTransaction",
+    "name": "setup",
     "inputs": [
       {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
+        "name": "_owners",
+        "type": "address[]",
+        "internalType": "address[]"
       },
       {
-        "name": "value",
+        "name": "_threshold",
         "type": "uint256",
         "internalType": "uint256"
       },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
       {
         "name": "data",
         "type": "bytes",
         "internalType": "bytes"
       },
       {
-        "name": "operation",
-        "type": "uint8",
-        "internalType": "enum Enum.Operation"
+        "name": "fallbackHandler",
+        "type": "address",
+        "internalType": "address"
       },
       {
-        "name": "safeTxGas",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "paymentToken",
+        "type": "address",
+        "internalType": "address"
       },
       {
-        "name": "baseGas",
+        "name": "payment",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "gasPrice",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
+        "name": "paymentReceiver",
+        "type": "address",
+        "internalType": "address payable"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "AddedOwner",
+    "inputs": [
       {
-        "name": "gasToken",
+        "name": "owner",
         "type": "address",
+        "indexed": false,
         "internalType": "address"
-      },
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ApproveHash",
+    "inputs": [
       {
-        "name": "refundReceiver",
-        "type": "address",
-        "internalType": "address payable"
+        "name": "approvedHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
       },
       {
-        "name": "signatures",
-        "type": "bytes",
-        "internalType": "bytes"
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
       }
     ],
-    "outputs": [
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ChangedFallbackHandler",
+    "inputs": [
       {
-        "name": "success",
-        "type": "bool",
-        "internalType": "bool"
+        "name": "handler",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
       }
     ],
-    "stateMutability": "payable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "execTransactionFromModule",
+    "type": "event",
+    "name": "ChangedGuard",
     "inputs": [
       {
-        "name": "to",
+        "name": "guard",
         "type": "address",
+        "indexed": false,
         "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "operation",
-        "type": "uint8",
-        "internalType": "enum Enum.Operation"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "success",
-        "type": "bool",
-        "internalType": "bool"
       }
     ],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "execTransactionFromModuleReturnData",
+    "type": "event",
+    "name": "ChangedThreshold",
     "inputs": [
       {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "value",
+        "name": "threshold",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "operation",
-        "type": "uint8",
-        "internalType": "enum Enum.Operation"
       }
     ],
-    "outputs": [
-      {
-        "name": "success",
-        "type": "bool",
-        "internalType": "bool"
-      },
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "DisabledModule",
+    "inputs": [
       {
-        "name": "returnData",
-        "type": "bytes",
-        "internalType": "bytes"
+        "name": "module",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
       }
     ],
-    "stateMutability": "nonpayable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "getChainId",
-    "inputs": [],
-    "outputs": [
+    "type": "event",
+    "name": "EnabledModule",
+    "inputs": [
       {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "module",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
       }
     ],
-    "stateMutability": "view"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "getModulesPaginated",
+    "type": "event",
+    "name": "ExecutionFailure",
     "inputs": [
       {
-        "name": "start",
-        "type": "address",
-        "internalType": "address"
+        "name": "txHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
       },
       {
-        "name": "pageSize",
+        "name": "payment",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       }
     ],
-    "outputs": [
-      {
-        "name": "array",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ExecutionFromModuleFailure",
+    "inputs": [
       {
-        "name": "next",
+        "name": "module",
         "type": "address",
+        "indexed": true,
         "internalType": "address"
       }
     ],
-    "stateMutability": "view"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "getOwners",
-    "inputs": [],
-    "outputs": [
+    "type": "event",
+    "name": "ExecutionFromModuleSuccess",
+    "inputs": [
       {
-        "name": "",
-        "type": "address[]",
-        "internalType": "address[]"
+        "name": "module",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
       }
     ],
-    "stateMutability": "view"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "getStorageAt",
+    "type": "event",
+    "name": "ExecutionSuccess",
     "inputs": [
       {
-        "name": "offset",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "txHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
       },
       {
-        "name": "length",
+        "name": "payment",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       }
     ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "getThreshold",
-    "inputs": [],
-    "outputs": [
+    "type": "event",
+    "name": "RemovedOwner",
+    "inputs": [
       {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "owner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
       }
     ],
-    "stateMutability": "view"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "getTransactionHash",
+    "type": "event",
+    "name": "SafeReceived",
     "inputs": [
       {
-        "name": "to",
+        "name": "sender",
         "type": "address",
+        "indexed": true,
         "internalType": "address"
       },
       {
         "name": "value",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "operation",
-        "type": "uint8",
-        "internalType": "enum Enum.Operation"
-      },
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "SafeSetup",
+    "inputs": [
       {
-        "name": "safeTxGas",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "initiator",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
       },
       {
-        "name": "baseGas",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "owners",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
       },
       {
-        "name": "gasPrice",
+        "name": "threshold",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       },
       {
-        "name": "gasToken",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "refundReceiver",
+        "name": "initializer",
         "type": "address",
+        "indexed": false,
         "internalType": "address"
       },
       {
-        "name": "_nonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isModuleEnabled",
-    "inputs": [
-      {
-        "name": "module",
+        "name": "fallbackHandler",
         "type": "address",
+        "indexed": false,
         "internalType": "address"
       }
     ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "isOwner",
+    "type": "event",
+    "name": "SignMsg",
     "inputs": [
       {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "nonce",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "removeOwner",
-    "inputs": [
-      {
-        "name": "prevOwner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "_threshold",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "requiredTxGas",
-    "inputs": [
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "operation",
-        "type": "uint8",
-        "internalType": "enum Enum.Operation"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setFallbackHandler",
-    "inputs": [
-      {
-        "name": "handler",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setGuard",
-    "inputs": [
-      {
-        "name": "guard",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setup",
-    "inputs": [
-      {
-        "name": "_owners",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "_threshold",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "fallbackHandler",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "paymentToken",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "payment",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "paymentReceiver",
-        "type": "address",
-        "internalType": "address payable"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "signedMessages",
-    "inputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "simulateAndRevert",
-    "inputs": [
-      {
-        "name": "targetContract",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "calldataPayload",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapOwner",
-    "inputs": [
-      {
-        "name": "prevOwner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "oldOwner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "newOwner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "event",
-    "name": "AddedOwner",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ApproveHash",
-    "inputs": [
-      {
-        "name": "approvedHash",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ChangedFallbackHandler",
-    "inputs": [
-      {
-        "name": "handler",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ChangedGuard",
-    "inputs": [
-      {
-        "name": "guard",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ChangedThreshold",
-    "inputs": [
-      {
-        "name": "threshold",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "DisabledModule",
-    "inputs": [
-      {
-        "name": "module",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "EnabledModule",
-    "inputs": [
-      {
-        "name": "module",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ExecutionFailure",
-    "inputs": [
-      {
-        "name": "txHash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "payment",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ExecutionFromModuleFailure",
-    "inputs": [
-      {
-        "name": "module",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ExecutionFromModuleSuccess",
-    "inputs": [
-      {
-        "name": "module",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ExecutionSuccess",
-    "inputs": [
-      {
-        "name": "txHash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "payment",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "RemovedOwner",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SafeReceived",
-    "inputs": [
-      {
-        "name": "sender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SafeSetup",
-    "inputs": [
-      {
-        "name": "initiator",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "owners",
-        "type": "address[]",
-        "indexed": false,
-        "internalType": "address[]"
-      },
-      {
-        "name": "threshold",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "initializer",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "fallbackHandler",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "SignMsg",
-    "inputs": [
-      {
-        "name": "msgHash",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
+        "name": "msgHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
       }
     ],
     "anonymous": false
@@ -1393,3944 +743,29 @@ pub mod GnosisSafe {
     use {super::*, alloy_sol_types};
     /// The creation / init bytecode of the contract.
     ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x01`\x04\x81\x90UPaY\xAE\x80b\0\0)`\09`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\xDCW`\x005`\xE0\x1C\x80c\xAF\xFE\xD0\xE0\x11a\x01\x02W\x80c\xE1\x9A\x9D\xD9\x11a\0\x95W\x80c\xF0\x8A\x03#\x11a\0dW\x80c\xF0\x8A\x03#\x14a\x16GW\x80c\xF6\x98\xDA%\x14a\x16\x98W\x80c\xF8\xDC]\xD9\x14a\x16\xC3W\x80c\xFF\xA1\xADt\x14a\x17>Wa\x021V[\x80c\xE1\x9A\x9D\xD9\x14a\x13\x9BW\x80c\xE3\x18\xB5+\x14a\x13\xECW\x80c\xE7R5\xB8\x14a\x14}W\x80c\xE8f7\xDB\x14a\x14\xA8Wa\x021V[\x80c\xCC/\x84R\x11a\0\xD1W\x80c\xCC/\x84R\x14a\x10\xE8W\x80c\xD4\xD9\xBD\xCD\x14a\x11\xB5W\x80c\xD8\xD1\x1Fx\x14a\x11\xF0W\x80c\xE0\t\xCF\xDE\x14a\x13*Wa\x021V[\x80c\xAF\xFE\xD0\xE0\x14a\r\x94W\x80c\xB4\xFA\xBA\t\x14a\r\xBFW\x80c\xB6>\x80\r\x14a\x0E\xA7W\x80c\xC4\xCA:\x9C\x14a\x10\x17Wa\x021V[\x80cV$\xB2[\x11a\x01zW\x80cjv\x12\x02\x11a\x01IW\x80cjv\x12\x02\x14a\t\x94W\x80c}\x83)t\x14a\x0BPW\x80c\x93O:\x11\x14a\x0B\xBFW\x80c\xA0\xE6~+\x14a\r(Wa\x021V[\x80cV$\xB2[\x14a\x07\xFBW\x80cZ\xE6\xBD7\x14a\x08\xB9W\x80ca\x0BY%\x14a\t\x08W\x80ciN\x80\xC3\x14a\tYWa\x021V[\x80c/T\xBFn\x11a\x01\xB6W\x80c/T\xBFn\x14a\x04\xD3W\x80c4\x08\xE4p\x14a\x05:W\x80cF\x87!\xA7\x14a\x05eW\x80cR)\x07?\x14a\x06zWa\x021V[\x80c\rX/\x13\x14a\x02\x9EW\x80c\x12\xFBh\xE0\x14a\x02\xF9W\x80c-\x9A\xD5=\x14a\x04lWa\x021V[6a\x021W3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F=\x0C\xE9\xBF\xC3\xED}hb\xDB\xB2\x8B-\xEA\x94V\x1F\xE7\x14\xA1\xB4\xD0\x19\xAA\x8A\xF3\x970\xD1\xAD|=4`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA2\0[4\x80\x15a\x02=W`\0\x80\xFD[P`\0\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\0\x1B\x90P\x80T\x80a\x02rW`\0\x80\xF3[6`\0\x8073``\x1B6R`\0\x80`\x146\x01`\0\x80\x85Z\xF1=`\0\x80>\x80a\x02\x99W=`\0\xFD[=`\0\xF3[4\x80\x15a\x02\xAAW`\0\x80\xFD[Pa\x02\xF7`\x04\x806\x03`@\x81\x10\x15a\x02\xC1W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x17\xCEV[\0[4\x80\x15a\x03\x05W`\0\x80\xFD[Pa\x04j`\x04\x806\x03`\x80\x81\x10\x15a\x03\x1CW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03UW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03wW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03\xDAW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xECW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\x0EW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x1B\xBEV[\0[4\x80\x15a\x04xW`\0\x80\xFD[Pa\x04\xBB`\x04\x806\x03` \x81\x10\x15a\x04\x8FW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa$@V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xDFW`\0\x80\xFD[Pa\x05\"`\x04\x806\x03` \x81\x10\x15a\x04\xF6W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa%\x12V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05FW`\0\x80\xFD[Pa\x05Oa%\xE4V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05qW`\0\x80\xFD[Pa\x06b`\x04\x806\x03`\x80\x81\x10\x15a\x05\x88W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x05\xCFW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\xE1W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x06\x03W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa%\xF1V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\x86W`\0\x80\xFD[Pa\x07w`\x04\x806\x03`\x80\x81\x10\x15a\x06\x9DW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x06\xE4W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\xF6W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\x18W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa'\xD7V[`@Q\x80\x83\x15\x15\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x07\xBFW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x07\xA4V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x07\xECW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x93PPPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x07W`\0\x80\xFD[Pa\x08>`\x04\x806\x03`@\x81\x10\x15a\x08\x1EW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa(\rV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x08~W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x08cV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x08\xABW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xC5W`\0\x80\xFD[Pa\x08\xF2`\x04\x806\x03` \x81\x10\x15a\x08\xDCW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa(\x94V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x14W`\0\x80\xFD[Pa\tW`\x04\x806\x03` \x81\x10\x15a\t+W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa(\xACV[\0[4\x80\x15a\teW`\0\x80\xFD[Pa\t\x92`\x04\x806\x03` \x81\x10\x15a\t|W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa,>V[\0[a\x0B8`\x04\x806\x03a\x01@\x81\x10\x15a\t\xABW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\t\xF2W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\x04W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n&W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\n\xB2W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\xC4W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n\xE6W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa-xV[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x0B\\W`\0\x80\xFD[Pa\x0B\xA9`\x04\x806\x03`@\x81\x10\x15a\x0BsW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa2\xB5V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x0B\xCBW`\0\x80\xFD[Pa\r&`\x04\x806\x03``\x81\x10\x15a\x0B\xE2W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0C\tW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0C\x1BW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0C=W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0C\xA0W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0C\xB2W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0C\xD4W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa2\xDAV[\0[4\x80\x15a\r4W`\0\x80\xFD[Pa\r=a3iV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\r\x80W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\reV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\r\xA0W`\0\x80\xFD[Pa\r\xA9a5\x12V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\r\xCBW`\0\x80\xFD[Pa\x0E\xA5`\x04\x806\x03`@\x81\x10\x15a\r\xE2W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0E\x1FW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0E1W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0ESW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa5\x18V[\0[4\x80\x15a\x0E\xB3W`\0\x80\xFD[Pa\x10\x15`\x04\x806\x03a\x01\0\x81\x10\x15a\x0E\xCBW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0E\xE8W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0E\xFAW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0F\x1CW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0FgW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0FyW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0F\x9BW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa5:V[\0[4\x80\x15a\x10#W`\0\x80\xFD[Pa\x10\xD2`\x04\x806\x03`\x80\x81\x10\x15a\x10:W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x10\x81W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x10\x93W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x10\xB5W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa6\xF8V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x10\xF4W`\0\x80\xFD[Pa\x11A`\x04\x806\x03`@\x81\x10\x15a\x11\x0BW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa8 V[`@Q\x80\x80` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x11\xA0W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x11\x85V[PPPP\x90P\x01\x93PPPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x11\xC1W`\0\x80\xFD[Pa\x11\xEE`\x04\x806\x03` \x81\x10\x15a\x11\xD8W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa:\x12V[\0[4\x80\x15a\x11\xFCW`\0\x80\xFD[Pa\x13\x14`\x04\x806\x03a\x01@\x81\x10\x15a\x12\x14W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x12[W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x12mW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x12\x8FW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa;\xB1V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x136W`\0\x80\xFD[Pa\x13\x99`\x04\x806\x03`@\x81\x10\x15a\x13MW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa;\xDEV[\0[4\x80\x15a\x13\xA7W`\0\x80\xFD[Pa\x13\xEA`\x04\x806\x03` \x81\x10\x15a\x13\xBEW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa?oV[\0[4\x80\x15a\x13\xF8W`\0\x80\xFD[Pa\x14{`\x04\x806\x03``\x81\x10\x15a\x14\x0FW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa?\xF3V[\0[4\x80\x15a\x14\x89W`\0\x80\xFD[Pa\x14\x92aFeV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x14\xB4W`\0\x80\xFD[Pa\x15\xCC`\x04\x806\x03a\x01@\x81\x10\x15a\x14\xCCW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x15\x13W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x15%W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x15GW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPaFoV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x16\x0CW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x15\xF1V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x169W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x16SW`\0\x80\xFD[Pa\x16\x96`\x04\x806\x03` \x81\x10\x15a\x16jW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPaH\x17V[\0[4\x80\x15a\x16\xA4W`\0\x80\xFD[Pa\x16\xADaHxV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x16\xCFW`\0\x80\xFD[Pa\x17<`\x04\x806\x03``\x81\x10\x15a\x16\xE6W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPaH\xF6V[\0[4\x80\x15a\x17JW`\0\x80\xFD[Pa\x17SaM)V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x17\x93W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x17xV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x17\xC0W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x17\xD6aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x18@WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a\x18xWP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a\x18\xEAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x19\xEBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x03`\0\x81T\x80\x92\x91\x90`\x01\x01\x91\x90PUP\x7F\x94e\xFA\x0C\x96,\xC7iX\xE67:\x993&@\x0C\x1C\x94\xF8\xBE/\xE3\xA9R\xAD\xFA\x7F`\xB2\xEA&\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x80`\x04T\x14a\x1B\xBAWa\x1B\xB9\x81a,>V[[PPV[a\x1B\xD2`A\x82aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82Q\x10\x15a\x1CHW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS020\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80\x80`\0\x80`\0[\x86\x81\x10\x15a$4Wa\x1Cd\x88\x82aN?V[\x80\x94P\x81\x95P\x82\x96PPPP`\0\x84`\xFF\x16\x14\x15a mW\x82`\0\x1C\x94Pa\x1C\x96`A\x88aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82`\0\x1C\x10\x15a\x1D\x0EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS021\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x87Qa\x1D'` \x84`\0\x1CaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x11\x15a\x1D\x9BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS022\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0` \x83\x8A\x01\x01Q\x90P\x88Qa\x1D\xD1\x82a\x1D\xC3` \x87`\0\x1CaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x11\x15a\x1EEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS023\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[``` \x84\x8B\x01\x01\x90Pc \xC1;\x0B`\xE0\x1B{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \xC1;\x0B\x8D\x84`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x80` \x01\x80` \x01\x83\x81\x03\x83R\x85\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x1E\xE7W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1E\xCCV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x1F\x14W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x83\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x1FMW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1F2V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x1FzW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x94PPPPP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1F\x99W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\xADW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1F\xC3W`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14a fW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS024\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPa\"\xB2V[`\x01\x84`\xFF\x16\x14\x15a!\x81W\x82`\0\x1C\x94P\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x80a!\nWP`\0`\x08`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x8C\x81R` \x01\x90\x81R` \x01`\0 T\x14\x15[a!|W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS025\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\"\xB1V[`\x1E\x84`\xFF\x16\x11\x15a\"IW`\x01\x8A`@Q` \x01\x80\x80\x7F\x19Ethereum Signed Message:\n32\0\0\0\0\x81RP`\x1C\x01\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `\x04\x86\x03\x85\x85`@Q`\0\x81R` \x01`@R`@Q\x80\x85\x81R` \x01\x84`\xFF\x16\x81R` \x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\"8W=`\0\x80>=`\0\xFD[PPP` `@Q\x03Q\x94Pa\"\xB0V[`\x01\x8A\x85\x85\x85`@Q`\0\x81R` \x01`@R`@Q\x80\x85\x81R` \x01\x84`\xFF\x16\x81R` \x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\"\xA3W=`\0\x80>=`\0\xFD[PPP` `@Q\x03Q\x94P[[[\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11\x80\x15a#yWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a#\xB2WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a$$W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS026\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x84\x95P\x80\x80`\x01\x01\x91PPa\x1CRV[PPPPPPPPPPV[`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a%\x0BWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x91\x90PV[`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a%\xDDWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x91\x90PV[`\0\x80F\x90P\x80\x91PP\x90V[`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a&\xBCWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a'.W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS104\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a';\x85\x85\x85\x85ZaN\x8DV[\x90P\x80\x15a'\x8BW3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fh\x95\xC16d\xAAOg(\x8B%\xD7\xA2\x1Dz\xAA4\x91n5_\xB9\xB6\xFA\xE0\xA19\xA9\x08[\xEC\xB8`@Q`@Q\x80\x91\x03\x90\xA2a'\xCFV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xAC\xD2\xC8p(\x04\x12\x8F\xDB\r\xB2\xBBI\xF6\xD1'\xDD\x01\x81\xC1?\xD4]\xBF\xE1m\xE0\x93\x0E+\xD3u`@Q`@Q\x80\x91\x03\x90\xA2[\x94\x93PPPPV[`\0``a'\xE7\x86\x86\x86\x86a%\xF1V[\x91P`@Q` =\x01\x81\x01`@R=\x81R=`\0` \x83\x01>\x80\x91PP\x94P\x94\x92PPPV[```\0` \x83\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a(+W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a(^W\x81` \x01`\x01\x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x90P`\0[\x83\x81\x10\x15a(\x89W\x80\x85\x01T\x80` \x83\x02` \x85\x01\x01RP\x80\x80`\x01\x01\x91PPa(dV[P\x80\x91PP\x92\x91PPV[`\x07` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a(\xB4aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a)\x1EWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a)\x90W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS101\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a*\x91W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS102\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xEC\xDF:>\xFF\xEAW\x83\xA3\xC4\xC2\x14\x0Eguwfd(\xD4N\xD9\xD4t\xA0\xB3\xA4\xC9\x94?\x84@\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[a,FaMbV[`\x03T\x81\x11\x15a,\xBEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x81\x10\x15a-5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS202\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x04\x81\x90UP\x7Fa\x0F\x7F\xF2\xB3\x04\xAE\x89\x03\xC3\xDEt\xC6\x0Cj\xB1\xF7\xD6\"k?R\xC5\x16\x19\x05\xBBZ\xD4\x03\x9C\x93`\x04T`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[`\0\x80`\0a-\x92\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E`\x05TaFoV[\x90P`\x05`\0\x81T\x80\x92\x91\x90`\x01\x01\x91\x90PUP\x80\x80Q\x90` \x01 \x91Pa-\xBB\x82\x82\x86a2\xDAV[P`\0a-\xC6aN\xD9V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a/\xACW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cu\xF0\xBBR\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F3`@Q\x8Dc\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8C\x81R` \x01\x80` \x01\x8A`\x01\x81\x11\x15a.iW\xFE[\x81R` \x01\x89\x81R` \x01\x88\x81R` \x01\x87\x81R` \x01\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83\x81\x03\x83R\x8D\x8D\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x83\x81\x03\x82R\x85\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a/;W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa/ V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a/hW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x9EPPPPPPPPPPPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a/\x93W`\0\x80\xFD[PZ\xF1\x15\x80\x15a/\xA7W=`\0\x80>=`\0\xFD[PPPP[a\x01\xF4a/\xD3a\t\xC4\x8B\x01`?`@\x8D\x02\x81a/\xC4W\xFE[\x04aO\n\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x01Z\x10\x15a0IW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS010\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0Z\x90Pa0\xB2\x8F\x8F\x8F\x8F\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x8E`\0\x8D\x14a0\xA7W\x8Ea0\xADV[a\t\xC4Z\x03[aN\x8DV[\x93Pa0\xC7Z\x82aO$\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x83\x80a0\xD6WP`\0\x8A\x14\x15[\x80a0\xE2WP`\0\x88\x14\x15[a1TW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS013\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80\x89\x11\x15a1nWa1k\x82\x8B\x8B\x8B\x8BaODV[\x90P[\x84\x15a1\xB8W\x7FD.q_bcF\xE8\xC5C\x81\0-\xA6\x14\xF6+\xEE\x8D'8e5\xB2R\x1E\xC8T\x08\x98Un\x84\x82`@Q\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1a1\xF8V[\x7F#B\x8B\x18\xAC\xFB>\xA6K\x08\xDC\x0C\x1D)n\xA9\xC0\x97\x02\xC0\x90\x83\xCARr\xE6M\x11[h}#\x84\x82`@Q\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1[PP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a2\xA4W\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x93'\x13h\x83\x85`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83\x81R` \x01\x82\x15\x15\x81R` \x01\x92PPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a2\x8BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a2\x9FW=`\0\x80>=`\0\xFD[PPPP[PP\x9B\x9APPPPPPPPPPPV[`\x08` R\x81`\0R`@`\0 ` R\x80`\0R`@`\0 `\0\x91P\x91PPT\x81V[`\0`\x04T\x90P`\0\x81\x11a3WW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS001\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a3c\x84\x84\x84\x84a\x1B\xBEV[PPPPV[```\0`\x03Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a3\x86W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a3\xB5W\x81` \x01` \x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x90P`\0\x80`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a5\tW\x80\x83\x83\x81Q\x81\x10a4`W\xFE[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP`\x02`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81\x80`\x01\x01\x92PPa4\x1FV[\x82\x93PPPP\x90V[`\x05T\x81V[`\0\x80\x82Q` \x84\x01\x85Z\xF4\x80`\0R=` R=`\0`@>`@=\x01`\0\xFD[a5\x85\x8A\x8A\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x89aQJV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a5\xC3Wa5\xC2\x84aVJV[[a6\x11\x87\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPPaVyV[`\0\x82\x11\x15a6+Wa6)\x82`\0`\x01\x86\x85aODV[P[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x14\x1D\xF8h\xA63\x1A\xF5(\xE3\x8C\x83\xB7\xAA\x03\xED\xC1\x9B\xE6n7\xAEg\xF9([\xF4\xF8\xE3\xC6\xA1\xA8\x8B\x8B\x8B\x8B\x89`@Q\x80\x80` \x01\x85\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81\x03\x82R\x87\x87\x82\x81\x81R` \x01\x92P` \x02\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x96PPPPPPP`@Q\x80\x91\x03\x90\xA2PPPPPPPPPPV[`\0\x80Z\x90Pa7O\x87\x87\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x86ZaN\x8DV[a7XW`\0\x80\xFD[`\0Z\x82\x03\x90P\x80`@Q` \x01\x80\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a7\xE5W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa7\xCAV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a8\x12W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xFD[```\0\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a8;W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8jW\x81` \x01` \x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x91P`\0\x80`\x01`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a9=WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a9HWP\x84\x82\x10[\x15a:\x03W\x80\x84\x83\x81Q\x81\x10a9ZW\xFE[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP`\x01`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81\x80`\x01\x01\x92PPa8\xD3V[\x80\x92P\x81\x84RPP\x92P\x92\x90PV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a;\x14W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS030\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\x08`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x83\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x7F\xF2\xA0\xEB\x15dr\xD1D\x02U\xB0\xD7\xC1\xE1\x9C\xC0q\x15\xD1\x05\x1F\xE6\x05\xB0\xDC\xE6\x9A\xCF\xEC\x88M\x9C`@Q`@Q\x80\x91\x03\x90\xA3PV[`\0a;\xC6\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8CaFoV[\x80Q\x90` \x01 \x90P\x9B\x9APPPPPPPPPPPV[a;\xE6aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a<PWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a<\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS101\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a=\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS103\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xAA\xB4\xFA+F?X\x1B+2\xCB;~;pK\x9C\xE3|\xC2\t\xB5\xFBMw\xE5\x93\xAC\xE4\x05Bv\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPV[a?waMbV[`\0\x7FJ Ob\x0C\x8C\\\xCD\xCA?\xD5M\0;\xAD\xD8[\xA5\0CjC\x1F\x0C\xBD\xA4\xF5X\xC9<4\xC8`\0\x1B\x90P\x81\x81U\x7F\x11Q\x11i\x14Q[\xC0\x89\x1F\xF9\x04zl\xB3,\xF9\x02To\x83\x06d\x99\xBC\xF8\xBA3\xD25?\xA2\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPV[a?\xFBaMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a@eWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a@\x9DWP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aA\x0FW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aB\x10W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aBzWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aB\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aC\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS205\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xF8\xD4\x9F\xC5)\x81.\x9A|\\P\xE6\x9C \xF0\xDC\xCC\r\xB8\xFA\x95\xC9\x8B\xC5\x8C\xC9\xA4\xF1\xC1)\x9E\xAF\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x7F\x94e\xFA\x0C\x96,\xC7iX\xE67:\x993&@\x0C\x1C\x94\xF8\xBE/\xE3\xA9R\xAD\xFA\x7F`\xB2\xEA&\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPPV[`\0`\x04T\x90P\x90V[```\0\x7F\xBB\x83\x10\xD4\x866\x8D\xB6\xBDo\x84\x94\x02\xFD\xD7:\xD5=1kZK&D\xADn\xFE\x0F\x94\x12\x86\xD8`\0\x1B\x8D\x8D\x8D\x8D`@Q\x80\x83\x83\x80\x82\x847\x80\x83\x01\x92PPP\x92PPP`@Q\x80\x91\x03\x90 \x8C\x8C\x8C\x8C\x8C\x8C\x8C`@Q` \x01\x80\x8C\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A\x81R` \x01\x89\x81R` \x01\x88`\x01\x81\x11\x15aG\0W\xFE[\x81R` \x01\x87\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x9BPPPPPPPPPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\x19`\xF8\x1B`\x01`\xF8\x1BaG\x8CaHxV[\x83`@Q` \x01\x80\x85~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x84~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x9B\x9APPPPPPPPPPPV[aH\x1FaMbV[aH(\x81aVJV[\x7FZ\xC6\xC4l\x93\xC8\xD0\xE57\x14\xBA;S\xDB>|\x04m\xA9\x941=~\xD0\xD1\x92\x02\x8B\xC7\xC2(\xB0\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[`\0\x7FG\xE7\x954\xA2E\x95.\x8B\x16\x89:3k\x85\xA3\xD9\xEA\x9F\xA8\xC5s\xF3\xD8\x03\xAF\xB9*yF\x92\x18`\0\x1BaH\xA6a%\xE4V[0`@Q` \x01\x80\x84\x81R` \x01\x83\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x93PPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[aH\xFEaMbV[\x80`\x01`\x03T\x03\x10\x15aIyW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aI\xE3WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aJUW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aKUW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS205\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x03`\0\x81T\x80\x92\x91\x90`\x01\x90\x03\x91\x90PUP\x7F\xF8\xD4\x9F\xC5)\x81.\x9A|\\P\xE6\x9C \xF0\xDC\xCC\r\xB8\xFA\x95\xC9\x8B\xC5\x8C\xC9\xA4\xF1\xC1)\x9E\xAF\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x80`\x04T\x14aM$WaM#\x81a,>V[[PPPV[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F1.3.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aN\x03W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS031\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[V[`\0\x80\x83\x14\x15aN\x18W`\0\x90PaN9V[`\0\x82\x84\x02\x90P\x82\x84\x82\x81aN)W\xFE[\x04\x14aN4W`\0\x80\xFD[\x80\x91PP[\x92\x91PPV[`\0\x80`\0\x83`A\x02` \x81\x01\x86\x01Q\x92P`@\x81\x01\x86\x01Q\x91P`\xFF`A\x82\x01\x87\x01Q\x16\x93PP\x92P\x92P\x92V[`\0\x80\x82\x84\x01\x90P\x83\x81\x10\x15aN\x83W`\0\x80\xFD[\x80\x91PP\x92\x91PPV[`\0`\x01\x80\x81\x11\x15aN\x9BW\xFE[\x83`\x01\x81\x11\x15aN\xA7W\xFE[\x14\x15aN\xC0W`\0\x80\x85Q` \x87\x01\x89\x86\xF4\x90PaN\xD0V[`\0\x80\x85Q` \x87\x01\x88\x8A\x87\xF1\x90P[\x95\x94PPPPPV[`\0\x80\x7FJ Ob\x0C\x8C\\\xCD\xCA?\xD5M\0;\xAD\xD8[\xA5\0CjC\x1F\x0C\xBD\xA4\xF5X\xC9<4\xC8`\0\x1B\x90P\x80T\x91PP\x90V[`\0\x81\x83\x10\x15aO\x1AW\x81aO\x1CV[\x82[\x90P\x92\x91PPV[`\0\x82\x82\x11\x15aO3W`\0\x80\xFD[`\0\x82\x84\x03\x90P\x80\x91PP\x92\x91PPV[`\0\x80`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aO\x81W\x82aO\x83V[2[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aP\x9BWaO\xED:\x86\x10aO\xCAW:aO\xCCV[\x85[aO\xDF\x88\x8AaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x08\xFC\x83\x90\x81\x15\x02\x90`@Q`\0`@Q\x80\x83\x03\x81\x85\x88\x88\xF1\x93PPPPaP\x96W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS011\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[aQ@V[aP\xC0\x85aP\xB2\x88\x8AaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91PaP\xCD\x84\x82\x84aX\xB4V[aQ?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS012\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[[P\x95\x94PPPPPV[`\0`\x04T\x14aQ\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81Q\x81\x11\x15aR9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x81\x10\x15aR\xB0W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS202\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0`\x01\x90P`\0[\x83Q\x81\x10\x15aU\xB6W`\0\x84\x82\x81Q\x81\x10aR\xD0W\xFE[` \x02` \x01\x01Q\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aSDWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15aS|WP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15aS\xB4WP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aT&W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aU'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80\x92PP\x80\x80`\x01\x01\x91PPaR\xB9V[P`\x01`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x82Q`\x03\x81\x90UP\x81`\x04\x81\x90UPPPPV[`\0\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\0\x1B\x90P\x81\x81UPPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aW{W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS100\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x80`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aX\xB0WaX=\x82`\0\x83`\x01ZaN\x8DV[aX\xAFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS000\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[[PPV[`\0\x80c\xA9\x05\x9C\xBB\x84\x84`@Q`$\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90`\xE0\x1B` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x83\x16\x17\x83RPPPP\x90P` `\0\x82Q` \x84\x01`\0\x89a'\x10Z\x03\xF1=`\0\x81\x14aY[W` \x81\x14aYcW`\0\x93PaYnV[\x81\x93PaYnV[`\0Q\x15\x82\x15\x17\x15\x93P[PPP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 8t\xBC\xF9.\x17\"\xCC{\xFA\x0C\xEF\x1A\t\x85\xCF\r\xC3H[\xA0f=\xB3t|\xCD\xF1`]\xF54dsolcC\0\x07\x06\x003",
-    );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `AddedOwner(address)` and selector `0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26`.
-    ```solidity
-    event AddedOwner(address owner);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct AddedOwner {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for AddedOwner {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "AddedOwner(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    148u8, 101u8, 250u8, 12u8, 150u8, 44u8, 199u8, 105u8, 88u8, 230u8, 55u8, 58u8,
-                    153u8, 51u8, 38u8, 64u8, 12u8, 28u8, 148u8, 248u8, 190u8, 47u8, 227u8, 169u8,
-                    82u8, 173u8, 250u8, 127u8, 96u8, 178u8, 234u8, 38u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { owner: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for AddedOwner {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&AddedOwner> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &AddedOwner) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ApproveHash(bytes32,address)` and selector `0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c`.
-    ```solidity
-    event ApproveHash(bytes32 indexed approvedHash, address indexed owner);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ApproveHash {
-        #[allow(missing_docs)]
-        pub approvedHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ApproveHash {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ApproveHash(bytes32,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    242u8, 160u8, 235u8, 21u8, 100u8, 114u8, 209u8, 68u8, 2u8, 85u8, 176u8, 215u8,
-                    193u8, 225u8, 156u8, 192u8, 113u8, 21u8, 209u8, 5u8, 31u8, 230u8, 5u8, 176u8,
-                    220u8, 230u8, 154u8, 207u8, 236u8, 136u8, 77u8, 156u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    approvedHash: topics.1,
-                    owner: topics.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.approvedHash.clone(),
-                    self.owner.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.approvedHash);
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ApproveHash {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ApproveHash> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ApproveHash) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ChangedFallbackHandler(address)` and selector `0x5ac6c46c93c8d0e53714ba3b53db3e7c046da994313d7ed0d192028bc7c228b0`.
-    ```solidity
-    event ChangedFallbackHandler(address handler);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ChangedFallbackHandler {
-        #[allow(missing_docs)]
-        pub handler: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ChangedFallbackHandler {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ChangedFallbackHandler(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    90u8, 198u8, 196u8, 108u8, 147u8, 200u8, 208u8, 229u8, 55u8, 20u8, 186u8, 59u8,
-                    83u8, 219u8, 62u8, 124u8, 4u8, 109u8, 169u8, 148u8, 49u8, 61u8, 126u8, 208u8,
-                    209u8, 146u8, 2u8, 139u8, 199u8, 194u8, 40u8, 176u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { handler: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.handler,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ChangedFallbackHandler {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ChangedFallbackHandler> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ChangedFallbackHandler) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ChangedGuard(address)` and selector `0x1151116914515bc0891ff9047a6cb32cf902546f83066499bcf8ba33d2353fa2`.
-    ```solidity
-    event ChangedGuard(address guard);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ChangedGuard {
-        #[allow(missing_docs)]
-        pub guard: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ChangedGuard {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ChangedGuard(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    17u8, 81u8, 17u8, 105u8, 20u8, 81u8, 91u8, 192u8, 137u8, 31u8, 249u8, 4u8,
-                    122u8, 108u8, 179u8, 44u8, 249u8, 2u8, 84u8, 111u8, 131u8, 6u8, 100u8, 153u8,
-                    188u8, 248u8, 186u8, 51u8, 210u8, 53u8, 63u8, 162u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { guard: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.guard,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ChangedGuard {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ChangedGuard> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ChangedGuard) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ChangedThreshold(uint256)` and selector `0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93`.
-    ```solidity
-    event ChangedThreshold(uint256 threshold);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ChangedThreshold {
-        #[allow(missing_docs)]
-        pub threshold: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ChangedThreshold {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ChangedThreshold(uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    97u8, 15u8, 127u8, 242u8, 179u8, 4u8, 174u8, 137u8, 3u8, 195u8, 222u8, 116u8,
-                    198u8, 12u8, 106u8, 177u8, 247u8, 214u8, 34u8, 107u8, 63u8, 82u8, 197u8, 22u8,
-                    25u8, 5u8, 187u8, 90u8, 212u8, 3u8, 156u8, 147u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { threshold: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.threshold,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ChangedThreshold {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ChangedThreshold> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ChangedThreshold) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `DisabledModule(address)` and selector `0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276`.
-    ```solidity
-    event DisabledModule(address module);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct DisabledModule {
-        #[allow(missing_docs)]
-        pub module: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for DisabledModule {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "DisabledModule(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    170u8, 180u8, 250u8, 43u8, 70u8, 63u8, 88u8, 27u8, 43u8, 50u8, 203u8, 59u8,
-                    126u8, 59u8, 112u8, 75u8, 156u8, 227u8, 124u8, 194u8, 9u8, 181u8, 251u8, 77u8,
-                    119u8, 229u8, 147u8, 172u8, 228u8, 5u8, 66u8, 118u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { module: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.module,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for DisabledModule {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&DisabledModule> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &DisabledModule) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `EnabledModule(address)` and selector `0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440`.
-    ```solidity
-    event EnabledModule(address module);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct EnabledModule {
-        #[allow(missing_docs)]
-        pub module: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for EnabledModule {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "EnabledModule(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    236u8, 223u8, 58u8, 62u8, 255u8, 234u8, 87u8, 131u8, 163u8, 196u8, 194u8, 20u8,
-                    14u8, 103u8, 117u8, 119u8, 102u8, 100u8, 40u8, 212u8, 78u8, 217u8, 212u8,
-                    116u8, 160u8, 179u8, 164u8, 201u8, 148u8, 63u8, 132u8, 64u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { module: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.module,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for EnabledModule {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&EnabledModule> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &EnabledModule) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ExecutionFailure(bytes32,uint256)` and selector `0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23`.
-    ```solidity
-    event ExecutionFailure(bytes32 txHash, uint256 payment);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ExecutionFailure {
-        #[allow(missing_docs)]
-        pub txHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub payment: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ExecutionFailure {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ExecutionFailure(bytes32,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    35u8, 66u8, 139u8, 24u8, 172u8, 251u8, 62u8, 166u8, 75u8, 8u8, 220u8, 12u8,
-                    29u8, 41u8, 110u8, 169u8, 192u8, 151u8, 2u8, 192u8, 144u8, 131u8, 202u8, 82u8,
-                    114u8, 230u8, 77u8, 17u8, 91u8, 104u8, 125u8, 35u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    txHash: data.0,
-                    payment: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.txHash),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ExecutionFailure {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ExecutionFailure> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ExecutionFailure) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ExecutionFromModuleFailure(address)` and selector `0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375`.
-    ```solidity
-    event ExecutionFromModuleFailure(address indexed module);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ExecutionFromModuleFailure {
-        #[allow(missing_docs)]
-        pub module: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ExecutionFromModuleFailure {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ExecutionFromModuleFailure(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    172u8, 210u8, 200u8, 112u8, 40u8, 4u8, 18u8, 143u8, 219u8, 13u8, 178u8, 187u8,
-                    73u8, 246u8, 209u8, 39u8, 221u8, 1u8, 129u8, 193u8, 63u8, 212u8, 93u8, 191u8,
-                    225u8, 109u8, 224u8, 147u8, 14u8, 43u8, 211u8, 117u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { module: topics.1 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.module.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.module,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ExecutionFromModuleFailure {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ExecutionFromModuleFailure> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ExecutionFromModuleFailure) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ExecutionFromModuleSuccess(address)` and selector `0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8`.
-    ```solidity
-    event ExecutionFromModuleSuccess(address indexed module);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ExecutionFromModuleSuccess {
-        #[allow(missing_docs)]
-        pub module: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ExecutionFromModuleSuccess {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ExecutionFromModuleSuccess(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    104u8, 149u8, 193u8, 54u8, 100u8, 170u8, 79u8, 103u8, 40u8, 139u8, 37u8, 215u8,
-                    162u8, 29u8, 122u8, 170u8, 52u8, 145u8, 110u8, 53u8, 95u8, 185u8, 182u8, 250u8,
-                    224u8, 161u8, 57u8, 169u8, 8u8, 91u8, 236u8, 184u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { module: topics.1 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.module.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.module,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ExecutionFromModuleSuccess {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ExecutionFromModuleSuccess> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ExecutionFromModuleSuccess) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ExecutionSuccess(bytes32,uint256)` and selector `0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e`.
-    ```solidity
-    event ExecutionSuccess(bytes32 txHash, uint256 payment);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ExecutionSuccess {
-        #[allow(missing_docs)]
-        pub txHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub payment: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ExecutionSuccess {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ExecutionSuccess(bytes32,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    68u8, 46u8, 113u8, 95u8, 98u8, 99u8, 70u8, 232u8, 197u8, 67u8, 129u8, 0u8,
-                    45u8, 166u8, 20u8, 246u8, 43u8, 238u8, 141u8, 39u8, 56u8, 101u8, 53u8, 178u8,
-                    82u8, 30u8, 200u8, 84u8, 8u8, 152u8, 85u8, 110u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    txHash: data.0,
-                    payment: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.txHash),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ExecutionSuccess {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ExecutionSuccess> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ExecutionSuccess) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `RemovedOwner(address)` and selector `0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf`.
-    ```solidity
-    event RemovedOwner(address owner);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct RemovedOwner {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for RemovedOwner {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "RemovedOwner(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    248u8, 212u8, 159u8, 197u8, 41u8, 129u8, 46u8, 154u8, 124u8, 92u8, 80u8, 230u8,
-                    156u8, 32u8, 240u8, 220u8, 204u8, 13u8, 184u8, 250u8, 149u8, 201u8, 139u8,
-                    197u8, 140u8, 201u8, 164u8, 241u8, 193u8, 41u8, 158u8, 175u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { owner: data.0 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for RemovedOwner {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&RemovedOwner> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &RemovedOwner) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SafeReceived(address,uint256)` and selector `0x3d0ce9bfc3ed7d6862dbb28b2dea94561fe714a1b4d019aa8af39730d1ad7c3d`.
-    ```solidity
-    event SafeReceived(address indexed sender, uint256 value);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SafeReceived {
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SafeReceived {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SafeReceived(address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    61u8, 12u8, 233u8, 191u8, 195u8, 237u8, 125u8, 104u8, 98u8, 219u8, 178u8,
-                    139u8, 45u8, 234u8, 148u8, 86u8, 31u8, 231u8, 20u8, 161u8, 180u8, 208u8, 25u8,
-                    170u8, 138u8, 243u8, 151u8, 48u8, 209u8, 173u8, 124u8, 61u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    sender: topics.1,
-                    value: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.sender.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.sender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SafeReceived {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SafeReceived> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SafeReceived) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SafeSetup(address,address[],uint256,address,address)` and selector `0x141df868a6331af528e38c83b7aa03edc19be66e37ae67f9285bf4f8e3c6a1a8`.
-    ```solidity
-    event SafeSetup(address indexed initiator, address[] owners, uint256 threshold, address initializer, address fallbackHandler);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SafeSetup {
-        #[allow(missing_docs)]
-        pub initiator: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub threshold: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub initializer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub fallbackHandler: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SafeSetup {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SafeSetup(address,address[],uint256,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    20u8, 29u8, 248u8, 104u8, 166u8, 51u8, 26u8, 245u8, 40u8, 227u8, 140u8, 131u8,
-                    183u8, 170u8, 3u8, 237u8, 193u8, 155u8, 230u8, 110u8, 55u8, 174u8, 103u8,
-                    249u8, 40u8, 91u8, 244u8, 248u8, 227u8, 198u8, 161u8, 168u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    initiator: topics.1,
-                    owners: data.0,
-                    threshold: data.1,
-                    initializer: data.2,
-                    fallbackHandler: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.owners),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.threshold),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.initializer,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.fallbackHandler,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.initiator.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.initiator,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SafeSetup {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SafeSetup> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SafeSetup) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `SignMsg(bytes32)` and selector `0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4`.
-    ```solidity
-    event SignMsg(bytes32 indexed msgHash);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct SignMsg {
-        #[allow(missing_docs)]
-        pub msgHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for SignMsg {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "SignMsg(bytes32)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    231u8, 244u8, 103u8, 80u8, 56u8, 244u8, 246u8, 3u8, 77u8, 252u8, 187u8, 178u8,
-                    76u8, 77u8, 192u8, 142u8, 78u8, 191u8, 16u8, 235u8, 157u8, 37u8, 125u8, 61u8,
-                    2u8, 192u8, 243u8, 141u8, 18u8, 42u8, 198u8, 228u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self { msgHash: topics.1 }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.msgHash.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.msgHash);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for SignMsg {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&SignMsg> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &SignMsg) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    /**Constructor`.
-    ```solidity
-    constructor();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {}
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `VERSION()` and selector `0xffa1ad74`.
-    ```solidity
-    function VERSION() external view returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct VERSIONCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`VERSION()`](VERSIONCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct VERSIONReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<VERSIONCall> for UnderlyingRustTuple<'_> {
-                fn from(value: VERSIONCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<VERSIONReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: VERSIONReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for VERSIONCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [255u8, 161u8, 173u8, 116u8];
-            const SIGNATURE: &'static str = "VERSION()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: VERSIONReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: VERSIONReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addOwnerWithThreshold(address,uint256)` and selector `0x0d582f13`.
-    ```solidity
-    function addOwnerWithThreshold(address owner, uint256 _threshold) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addOwnerWithThresholdCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`addOwnerWithThreshold(address,uint256)`](addOwnerWithThresholdCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addOwnerWithThresholdReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addOwnerWithThresholdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addOwnerWithThresholdCall) -> Self {
-                    (value.owner, value._threshold)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addOwnerWithThresholdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        _threshold: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addOwnerWithThresholdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addOwnerWithThresholdReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addOwnerWithThresholdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl addOwnerWithThresholdReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addOwnerWithThresholdCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addOwnerWithThresholdReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [13u8, 88u8, 47u8, 19u8];
-            const SIGNATURE: &'static str = "addOwnerWithThreshold(address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._threshold,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addOwnerWithThresholdReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approveHash(bytes32)` and selector `0xd4d9bdcd`.
-    ```solidity
-    function approveHash(bytes32 hashToApprove) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveHashCall {
-        #[allow(missing_docs)]
-        pub hashToApprove: alloy_sol_types::private::FixedBytes<32>,
-    }
-    ///Container type for the return parameters of the
-    /// [`approveHash(bytes32)`](approveHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveHashReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveHashCall) -> Self {
-                    (value.hashToApprove,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        hashToApprove: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveHashReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl approveHashReturn {
-            fn _tokenize(&self) -> <approveHashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveHashCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = approveHashReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [212u8, 217u8, 189u8, 205u8];
-            const SIGNATURE: &'static str = "approveHash(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.hashToApprove),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                approveHashReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approvedHashes(address,bytes32)` and selector `0x7d832974`.
-    ```solidity
-    function approvedHashes(address, bytes32) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approvedHashesCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`approvedHashes(address,bytes32)`](approvedHashesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approvedHashesReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approvedHashesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approvedHashesCall) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approvedHashesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approvedHashesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approvedHashesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approvedHashesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for approvedHashesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [125u8, 131u8, 41u8, 116u8];
-            const SIGNATURE: &'static str = "approvedHashes(address,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self._1),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approvedHashesReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: approvedHashesReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `changeThreshold(uint256)` and selector `0x694e80c3`.
-    ```solidity
-    function changeThreshold(uint256 _threshold) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct changeThresholdCall {
-        #[allow(missing_docs)]
-        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`changeThreshold(uint256)`](changeThresholdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct changeThresholdReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<changeThresholdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: changeThresholdCall) -> Self {
-                    (value._threshold,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for changeThresholdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _threshold: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<changeThresholdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: changeThresholdReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for changeThresholdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl changeThresholdReturn {
-            fn _tokenize(
-                &self,
-            ) -> <changeThresholdCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for changeThresholdCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = changeThresholdReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [105u8, 78u8, 128u8, 195u8];
-            const SIGNATURE: &'static str = "changeThreshold(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._threshold,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                changeThresholdReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `checkNSignatures(bytes32,bytes,bytes,uint256)` and selector `0x12fb68e0`.
-    ```solidity
-    function checkNSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures, uint256 requiredSignatures) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct checkNSignaturesCall {
-        #[allow(missing_docs)]
-        pub dataHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub requiredSignatures: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`checkNSignatures(bytes32,bytes,bytes,uint256)`](checkNSignaturesCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct checkNSignaturesReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<checkNSignaturesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: checkNSignaturesCall) -> Self {
-                    (
-                        value.dataHash,
-                        value.data,
-                        value.signatures,
-                        value.requiredSignatures,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkNSignaturesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        dataHash: tuple.0,
-                        data: tuple.1,
-                        signatures: tuple.2,
-                        requiredSignatures: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<checkNSignaturesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: checkNSignaturesReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkNSignaturesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl checkNSignaturesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <checkNSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for checkNSignaturesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = checkNSignaturesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [18u8, 251u8, 104u8, 224u8];
-            const SIGNATURE: &'static str = "checkNSignatures(bytes32,bytes,bytes,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.dataHash),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signatures,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.requiredSignatures),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                checkNSignaturesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `checkSignatures(bytes32,bytes,bytes)` and selector `0x934f3a11`.
-    ```solidity
-    function checkSignatures(bytes32 dataHash, bytes memory data, bytes memory signatures) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct checkSignaturesCall {
-        #[allow(missing_docs)]
-        pub dataHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`checkSignatures(bytes32,bytes,bytes)`](checkSignaturesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct checkSignaturesReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<checkSignaturesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: checkSignaturesCall) -> Self {
-                    (value.dataHash, value.data, value.signatures)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkSignaturesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        dataHash: tuple.0,
-                        data: tuple.1,
-                        signatures: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<checkSignaturesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: checkSignaturesReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for checkSignaturesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl checkSignaturesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <checkSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for checkSignaturesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = checkSignaturesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [147u8, 79u8, 58u8, 17u8];
-            const SIGNATURE: &'static str = "checkSignatures(bytes32,bytes,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.dataHash),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signatures,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                checkSignaturesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `disableModule(address,address)` and selector `0xe009cfde`.
-    ```solidity
-    function disableModule(address prevModule, address module) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableModuleCall {
-        #[allow(missing_docs)]
-        pub prevModule: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub module: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`disableModule(address,address)`](disableModuleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct disableModuleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableModuleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: disableModuleCall) -> Self {
-                    (value.prevModule, value.module)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableModuleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        prevModule: tuple.0,
-                        module: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<disableModuleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: disableModuleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for disableModuleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl disableModuleReturn {
-            fn _tokenize(
-                &self,
-            ) -> <disableModuleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for disableModuleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = disableModuleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [224u8, 9u8, 207u8, 222u8];
-            const SIGNATURE: &'static str = "disableModule(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.prevModule,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.module,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                disableModuleReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `domainSeparator()` and selector `0xf698da25`.
-    ```solidity
-    function domainSeparator() external view returns (bytes32);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct domainSeparatorCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`domainSeparator()`](domainSeparatorCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct domainSeparatorReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<domainSeparatorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: domainSeparatorCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<domainSeparatorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: domainSeparatorReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for domainSeparatorCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [246u8, 152u8, 218u8, 37u8];
-            const SIGNATURE: &'static str = "domainSeparator()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: domainSeparatorReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: domainSeparatorReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `enableModule(address)` and selector `0x610b5925`.
-    ```solidity
-    function enableModule(address module) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableModuleCall {
-        #[allow(missing_docs)]
-        pub module: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`enableModule(address)`](enableModuleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableModuleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableModuleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: enableModuleCall) -> Self {
-                    (value.module,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableModuleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { module: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableModuleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: enableModuleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableModuleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl enableModuleReturn {
-            fn _tokenize(&self) -> <enableModuleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for enableModuleCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = enableModuleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [97u8, 11u8, 89u8, 37u8];
-            const SIGNATURE: &'static str = "enableModule(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.module,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                enableModuleReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `encodeTransactionData(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)` and selector `0xe86637db`.
-    ```solidity
-    function encodeTransactionData(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct encodeTransactionDataCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub gasToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub refundReceiver: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _nonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`encodeTransactionData(address,uint256,bytes,uint8,uint256,uint256,
-    /// uint256,address,address,uint256)`](encodeTransactionDataCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct encodeTransactionDataReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-                <Enum::Operation as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<encodeTransactionDataCall> for UnderlyingRustTuple<'_> {
-                fn from(value: encodeTransactionDataCall) -> Self {
-                    (
-                        value.to,
-                        value.value,
-                        value.data,
-                        value.operation,
-                        value.safeTxGas,
-                        value.baseGas,
-                        value.gasPrice,
-                        value.gasToken,
-                        value.refundReceiver,
-                        value._nonce,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for encodeTransactionDataCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        to: tuple.0,
-                        value: tuple.1,
-                        data: tuple.2,
-                        operation: tuple.3,
-                        safeTxGas: tuple.4,
-                        baseGas: tuple.5,
-                        gasPrice: tuple.6,
-                        gasToken: tuple.7,
-                        refundReceiver: tuple.8,
-                        _nonce: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<encodeTransactionDataReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: encodeTransactionDataReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for encodeTransactionDataReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for encodeTransactionDataCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 102u8, 55u8, 219u8];
-            const SIGNATURE: &'static str = "encodeTransactionData(address,uint256,bytes,uint8,\
-                                             uint256,uint256,uint256,address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.safeTxGas,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.baseGas,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.gasPrice,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.gasToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.refundReceiver,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._nonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: encodeTransactionDataReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: encodeTransactionDataReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)` and selector `0x6a761202`.
-    ```solidity
-    function execTransaction(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes memory signatures) external payable returns (bool success);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct execTransactionCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub gasToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub refundReceiver: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,
-    /// address,address,bytes)`](execTransactionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct execTransactionReturn {
-        #[allow(missing_docs)]
-        pub success: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-                <Enum::Operation as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<execTransactionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: execTransactionCall) -> Self {
-                    (
-                        value.to,
-                        value.value,
-                        value.data,
-                        value.operation,
-                        value.safeTxGas,
-                        value.baseGas,
-                        value.gasPrice,
-                        value.gasToken,
-                        value.refundReceiver,
-                        value.signatures,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        to: tuple.0,
-                        value: tuple.1,
-                        data: tuple.2,
-                        operation: tuple.3,
-                        safeTxGas: tuple.4,
-                        baseGas: tuple.5,
-                        gasPrice: tuple.6,
-                        gasToken: tuple.7,
-                        refundReceiver: tuple.8,
-                        signatures: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<execTransactionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: execTransactionReturn) -> Self {
-                    (value.success,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { success: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for execTransactionCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [106u8, 118u8, 18u8, 2u8];
-            const SIGNATURE: &'static str = "execTransaction(address,uint256,bytes,uint8,uint256,\
-                                             uint256,uint256,address,address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.safeTxGas,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.baseGas,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.gasPrice,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.gasToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.refundReceiver,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signatures,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: execTransactionReturn = r.into();
-                        r.success
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: execTransactionReturn = r.into();
-                    r.success
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `execTransactionFromModule(address,uint256,bytes,uint8)` and selector `0x468721a7`.
-    ```solidity
-    function execTransactionFromModule(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct execTransactionFromModuleCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`execTransactionFromModule(address,uint256,bytes,
-    /// uint8)`](execTransactionFromModuleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct execTransactionFromModuleReturn {
-        #[allow(missing_docs)]
-        pub success: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-                <Enum::Operation as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<execTransactionFromModuleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: execTransactionFromModuleCall) -> Self {
-                    (value.to, value.value, value.data, value.operation)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        to: tuple.0,
-                        value: tuple.1,
-                        data: tuple.2,
-                        operation: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<execTransactionFromModuleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: execTransactionFromModuleReturn) -> Self {
-                    (value.success,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { success: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for execTransactionFromModuleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [70u8, 135u8, 33u8, 167u8];
-            const SIGNATURE: &'static str =
-                "execTransactionFromModule(address,uint256,bytes,uint8)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: execTransactionFromModuleReturn = r.into();
-                        r.success
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: execTransactionFromModuleReturn = r.into();
-                    r.success
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `execTransactionFromModuleReturnData(address,uint256,bytes,uint8)` and selector `0x5229073f`.
-    ```solidity
-    function execTransactionFromModuleReturnData(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (bool success, bytes memory returnData);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct execTransactionFromModuleReturnDataCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-    }
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x01`\x04\x81\x90UPaY\xAE\x80b\0\0)`\09`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\xDCW`\x005`\xE0\x1C\x80c\xAF\xFE\xD0\xE0\x11a\x01\x02W\x80c\xE1\x9A\x9D\xD9\x11a\0\x95W\x80c\xF0\x8A\x03#\x11a\0dW\x80c\xF0\x8A\x03#\x14a\x16GW\x80c\xF6\x98\xDA%\x14a\x16\x98W\x80c\xF8\xDC]\xD9\x14a\x16\xC3W\x80c\xFF\xA1\xADt\x14a\x17>Wa\x021V[\x80c\xE1\x9A\x9D\xD9\x14a\x13\x9BW\x80c\xE3\x18\xB5+\x14a\x13\xECW\x80c\xE7R5\xB8\x14a\x14}W\x80c\xE8f7\xDB\x14a\x14\xA8Wa\x021V[\x80c\xCC/\x84R\x11a\0\xD1W\x80c\xCC/\x84R\x14a\x10\xE8W\x80c\xD4\xD9\xBD\xCD\x14a\x11\xB5W\x80c\xD8\xD1\x1Fx\x14a\x11\xF0W\x80c\xE0\t\xCF\xDE\x14a\x13*Wa\x021V[\x80c\xAF\xFE\xD0\xE0\x14a\r\x94W\x80c\xB4\xFA\xBA\t\x14a\r\xBFW\x80c\xB6>\x80\r\x14a\x0E\xA7W\x80c\xC4\xCA:\x9C\x14a\x10\x17Wa\x021V[\x80cV$\xB2[\x11a\x01zW\x80cjv\x12\x02\x11a\x01IW\x80cjv\x12\x02\x14a\t\x94W\x80c}\x83)t\x14a\x0BPW\x80c\x93O:\x11\x14a\x0B\xBFW\x80c\xA0\xE6~+\x14a\r(Wa\x021V[\x80cV$\xB2[\x14a\x07\xFBW\x80cZ\xE6\xBD7\x14a\x08\xB9W\x80ca\x0BY%\x14a\t\x08W\x80ciN\x80\xC3\x14a\tYWa\x021V[\x80c/T\xBFn\x11a\x01\xB6W\x80c/T\xBFn\x14a\x04\xD3W\x80c4\x08\xE4p\x14a\x05:W\x80cF\x87!\xA7\x14a\x05eW\x80cR)\x07?\x14a\x06zWa\x021V[\x80c\rX/\x13\x14a\x02\x9EW\x80c\x12\xFBh\xE0\x14a\x02\xF9W\x80c-\x9A\xD5=\x14a\x04lWa\x021V[6a\x021W3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F=\x0C\xE9\xBF\xC3\xED}hb\xDB\xB2\x8B-\xEA\x94V\x1F\xE7\x14\xA1\xB4\xD0\x19\xAA\x8A\xF3\x970\xD1\xAD|=4`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA2\0[4\x80\x15a\x02=W`\0\x80\xFD[P`\0\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\0\x1B\x90P\x80T\x80a\x02rW`\0\x80\xF3[6`\0\x8073``\x1B6R`\0\x80`\x146\x01`\0\x80\x85Z\xF1=`\0\x80>\x80a\x02\x99W=`\0\xFD[=`\0\xF3[4\x80\x15a\x02\xAAW`\0\x80\xFD[Pa\x02\xF7`\x04\x806\x03`@\x81\x10\x15a\x02\xC1W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x17\xCEV[\0[4\x80\x15a\x03\x05W`\0\x80\xFD[Pa\x04j`\x04\x806\x03`\x80\x81\x10\x15a\x03\x1CW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03UW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03wW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x03\xDAW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xECW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\x0EW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90\x92\x91\x90PPPa\x1B\xBEV[\0[4\x80\x15a\x04xW`\0\x80\xFD[Pa\x04\xBB`\x04\x806\x03` \x81\x10\x15a\x04\x8FW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa$@V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xDFW`\0\x80\xFD[Pa\x05\"`\x04\x806\x03` \x81\x10\x15a\x04\xF6W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa%\x12V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05FW`\0\x80\xFD[Pa\x05Oa%\xE4V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05qW`\0\x80\xFD[Pa\x06b`\x04\x806\x03`\x80\x81\x10\x15a\x05\x88W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x05\xCFW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\xE1W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x06\x03W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa%\xF1V[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\x86W`\0\x80\xFD[Pa\x07w`\x04\x806\x03`\x80\x81\x10\x15a\x06\x9DW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x06\xE4W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\xF6W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\x18W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa'\xD7V[`@Q\x80\x83\x15\x15\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x07\xBFW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x07\xA4V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x07\xECW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x93PPPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x07W`\0\x80\xFD[Pa\x08>`\x04\x806\x03`@\x81\x10\x15a\x08\x1EW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa(\rV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x08~W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x08cV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x08\xABW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xC5W`\0\x80\xFD[Pa\x08\xF2`\x04\x806\x03` \x81\x10\x15a\x08\xDCW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa(\x94V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x14W`\0\x80\xFD[Pa\tW`\x04\x806\x03` \x81\x10\x15a\t+W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa(\xACV[\0[4\x80\x15a\teW`\0\x80\xFD[Pa\t\x92`\x04\x806\x03` \x81\x10\x15a\t|W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa,>V[\0[a\x0B8`\x04\x806\x03a\x01@\x81\x10\x15a\t\xABW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\t\xF2W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\x04W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n&W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\n\xB2W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\n\xC4W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n\xE6W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa-xV[`@Q\x80\x82\x15\x15\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x0B\\W`\0\x80\xFD[Pa\x0B\xA9`\x04\x806\x03`@\x81\x10\x15a\x0BsW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa2\xB5V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x0B\xCBW`\0\x80\xFD[Pa\r&`\x04\x806\x03``\x81\x10\x15a\x0B\xE2W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0C\tW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0C\x1BW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0C=W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0C\xA0W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0C\xB2W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0C\xD4W`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa2\xDAV[\0[4\x80\x15a\r4W`\0\x80\xFD[Pa\r=a3iV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\r\x80W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\reV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\r\xA0W`\0\x80\xFD[Pa\r\xA9a5\x12V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\r\xCBW`\0\x80\xFD[Pa\x0E\xA5`\x04\x806\x03`@\x81\x10\x15a\r\xE2W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0E\x1FW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0E1W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0ESW`\0\x80\xFD[\x91\x90\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x91\x92\x91\x92\x90PPPa5\x18V[\0[4\x80\x15a\x0E\xB3W`\0\x80\xFD[Pa\x10\x15`\x04\x806\x03a\x01\0\x81\x10\x15a\x0E\xCBW`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0E\xE8W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0E\xFAW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0F\x1CW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x0FgW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0FyW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0F\x9BW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa5:V[\0[4\x80\x15a\x10#W`\0\x80\xFD[Pa\x10\xD2`\x04\x806\x03`\x80\x81\x10\x15a\x10:W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x10\x81W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x10\x93W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x10\xB5W`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa6\xF8V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x10\xF4W`\0\x80\xFD[Pa\x11A`\x04\x806\x03`@\x81\x10\x15a\x11\x0BW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa8 V[`@Q\x80\x80` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90` \x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x11\xA0W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x11\x85V[PPPP\x90P\x01\x93PPPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x11\xC1W`\0\x80\xFD[Pa\x11\xEE`\x04\x806\x03` \x81\x10\x15a\x11\xD8W`\0\x80\xFD[\x81\x01\x90\x80\x805\x90` \x01\x90\x92\x91\x90PPPa:\x12V[\0[4\x80\x15a\x11\xFCW`\0\x80\xFD[Pa\x13\x14`\x04\x806\x03a\x01@\x81\x10\x15a\x12\x14W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x12[W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x12mW`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x12\x8FW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPa;\xB1V[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x136W`\0\x80\xFD[Pa\x13\x99`\x04\x806\x03`@\x81\x10\x15a\x13MW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa;\xDEV[\0[4\x80\x15a\x13\xA7W`\0\x80\xFD[Pa\x13\xEA`\x04\x806\x03` \x81\x10\x15a\x13\xBEW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa?oV[\0[4\x80\x15a\x13\xF8W`\0\x80\xFD[Pa\x14{`\x04\x806\x03``\x81\x10\x15a\x14\x0FW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPa?\xF3V[\0[4\x80\x15a\x14\x89W`\0\x80\xFD[Pa\x14\x92aFeV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x14\xB4W`\0\x80\xFD[Pa\x15\xCC`\x04\x806\x03a\x01@\x81\x10\x15a\x14\xCCW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90d\x01\0\0\0\0\x81\x11\x15a\x15\x13W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x15%W`\0\x80\xFD[\x805\x90` \x01\x91\x84`\x01\x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x15GW`\0\x80\xFD[\x90\x91\x92\x93\x91\x92\x93\x90\x805`\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPaFoV[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x16\x0CW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x15\xF1V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x169W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x16SW`\0\x80\xFD[Pa\x16\x96`\x04\x806\x03` \x81\x10\x15a\x16jW`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90PPPaH\x17V[\0[4\x80\x15a\x16\xA4W`\0\x80\xFD[Pa\x16\xADaHxV[`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x16\xCFW`\0\x80\xFD[Pa\x17<`\x04\x806\x03``\x81\x10\x15a\x16\xE6W`\0\x80\xFD[\x81\x01\x90\x80\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90` \x01\x90\x92\x91\x90\x805\x90` \x01\x90\x92\x91\x90PPPaH\xF6V[\0[4\x80\x15a\x17JW`\0\x80\xFD[Pa\x17SaM)V[`@Q\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x17\x93W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x17xV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x17\xC0W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xF3[a\x17\xD6aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x18@WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a\x18xWP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a\x18\xEAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x19\xEBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x03`\0\x81T\x80\x92\x91\x90`\x01\x01\x91\x90PUP\x7F\x94e\xFA\x0C\x96,\xC7iX\xE67:\x993&@\x0C\x1C\x94\xF8\xBE/\xE3\xA9R\xAD\xFA\x7F`\xB2\xEA&\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x80`\x04T\x14a\x1B\xBAWa\x1B\xB9\x81a,>V[[PPV[a\x1B\xD2`A\x82aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82Q\x10\x15a\x1CHW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS020\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80\x80`\0\x80`\0[\x86\x81\x10\x15a$4Wa\x1Cd\x88\x82aN?V[\x80\x94P\x81\x95P\x82\x96PPPP`\0\x84`\xFF\x16\x14\x15a mW\x82`\0\x1C\x94Pa\x1C\x96`A\x88aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82`\0\x1C\x10\x15a\x1D\x0EW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS021\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x87Qa\x1D'` \x84`\0\x1CaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x11\x15a\x1D\x9BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS022\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0` \x83\x8A\x01\x01Q\x90P\x88Qa\x1D\xD1\x82a\x1D\xC3` \x87`\0\x1CaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x11\x15a\x1EEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS023\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[``` \x84\x8B\x01\x01\x90Pc \xC1;\x0B`\xE0\x1B{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \xC1;\x0B\x8D\x84`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x80` \x01\x80` \x01\x83\x81\x03\x83R\x85\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x1E\xE7W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1E\xCCV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x1F\x14W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x83\x81\x03\x82R\x84\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a\x1FMW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1F2V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a\x1FzW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x94PPPPP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1F\x99W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\xADW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1F\xC3W`\0\x80\xFD[\x81\x01\x90\x80\x80Q\x90` \x01\x90\x92\x91\x90PPP{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x14a fW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS024\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPa\"\xB2V[`\x01\x84`\xFF\x16\x14\x15a!\x81W\x82`\0\x1C\x94P\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x80a!\nWP`\0`\x08`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x8C\x81R` \x01\x90\x81R` \x01`\0 T\x14\x15[a!|W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS025\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\"\xB1V[`\x1E\x84`\xFF\x16\x11\x15a\"IW`\x01\x8A`@Q` \x01\x80\x80\x7F\x19Ethereum Signed Message:\n32\0\0\0\0\x81RP`\x1C\x01\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `\x04\x86\x03\x85\x85`@Q`\0\x81R` \x01`@R`@Q\x80\x85\x81R` \x01\x84`\xFF\x16\x81R` \x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\"8W=`\0\x80>=`\0\xFD[PPP` `@Q\x03Q\x94Pa\"\xB0V[`\x01\x8A\x85\x85\x85`@Q`\0\x81R` \x01`@R`@Q\x80\x85\x81R` \x01\x84`\xFF\x16\x81R` \x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\"\xA3W=`\0\x80>=`\0\xFD[PPP` `@Q\x03Q\x94P[[[\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11\x80\x15a#yWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a#\xB2WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a$$W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS026\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x84\x95P\x80\x80`\x01\x01\x91PPa\x1CRV[PPPPPPPPPPV[`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a%\x0BWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x91\x90PV[`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a%\xDDWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x91\x90PV[`\0\x80F\x90P\x80\x91PP\x90V[`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a&\xBCWP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a'.W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS104\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a';\x85\x85\x85\x85ZaN\x8DV[\x90P\x80\x15a'\x8BW3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fh\x95\xC16d\xAAOg(\x8B%\xD7\xA2\x1Dz\xAA4\x91n5_\xB9\xB6\xFA\xE0\xA19\xA9\x08[\xEC\xB8`@Q`@Q\x80\x91\x03\x90\xA2a'\xCFV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xAC\xD2\xC8p(\x04\x12\x8F\xDB\r\xB2\xBBI\xF6\xD1'\xDD\x01\x81\xC1?\xD4]\xBF\xE1m\xE0\x93\x0E+\xD3u`@Q`@Q\x80\x91\x03\x90\xA2[\x94\x93PPPPV[`\0``a'\xE7\x86\x86\x86\x86a%\xF1V[\x91P`@Q` =\x01\x81\x01`@R=\x81R=`\0` \x83\x01>\x80\x91PP\x94P\x94\x92PPPV[```\0` \x83\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a(+W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a(^W\x81` \x01`\x01\x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x90P`\0[\x83\x81\x10\x15a(\x89W\x80\x85\x01T\x80` \x83\x02` \x85\x01\x01RP\x80\x80`\x01\x01\x91PPa(dV[P\x80\x91PP\x92\x91PPV[`\x07` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a(\xB4aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a)\x1EWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a)\x90W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS101\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a*\x91W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS102\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xEC\xDF:>\xFF\xEAW\x83\xA3\xC4\xC2\x14\x0Eguwfd(\xD4N\xD9\xD4t\xA0\xB3\xA4\xC9\x94?\x84@\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[a,FaMbV[`\x03T\x81\x11\x15a,\xBEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x81\x10\x15a-5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS202\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x04\x81\x90UP\x7Fa\x0F\x7F\xF2\xB3\x04\xAE\x89\x03\xC3\xDEt\xC6\x0Cj\xB1\xF7\xD6\"k?R\xC5\x16\x19\x05\xBBZ\xD4\x03\x9C\x93`\x04T`@Q\x80\x82\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[`\0\x80`\0a-\x92\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E\x8E`\x05TaFoV[\x90P`\x05`\0\x81T\x80\x92\x91\x90`\x01\x01\x91\x90PUP\x80\x80Q\x90` \x01 \x91Pa-\xBB\x82\x82\x86a2\xDAV[P`\0a-\xC6aN\xD9V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a/\xACW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cu\xF0\xBBR\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F\x8F3`@Q\x8Dc\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8C\x81R` \x01\x80` \x01\x8A`\x01\x81\x11\x15a.iW\xFE[\x81R` \x01\x89\x81R` \x01\x88\x81R` \x01\x87\x81R` \x01\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83\x81\x03\x83R\x8D\x8D\x82\x81\x81R` \x01\x92P\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x83\x81\x03\x82R\x85\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a/;W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa/ V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a/hW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x9EPPPPPPPPPPPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a/\x93W`\0\x80\xFD[PZ\xF1\x15\x80\x15a/\xA7W=`\0\x80>=`\0\xFD[PPPP[a\x01\xF4a/\xD3a\t\xC4\x8B\x01`?`@\x8D\x02\x81a/\xC4W\xFE[\x04aO\n\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x01Z\x10\x15a0IW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS010\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0Z\x90Pa0\xB2\x8F\x8F\x8F\x8F\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x8E`\0\x8D\x14a0\xA7W\x8Ea0\xADV[a\t\xC4Z\x03[aN\x8DV[\x93Pa0\xC7Z\x82aO$\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P\x83\x80a0\xD6WP`\0\x8A\x14\x15[\x80a0\xE2WP`\0\x88\x14\x15[a1TW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS013\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80\x89\x11\x15a1nWa1k\x82\x8B\x8B\x8B\x8BaODV[\x90P[\x84\x15a1\xB8W\x7FD.q_bcF\xE8\xC5C\x81\0-\xA6\x14\xF6+\xEE\x8D'8e5\xB2R\x1E\xC8T\x08\x98Un\x84\x82`@Q\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1a1\xF8V[\x7F#B\x8B\x18\xAC\xFB>\xA6K\x08\xDC\x0C\x1D)n\xA9\xC0\x97\x02\xC0\x90\x83\xCARr\xE6M\x11[h}#\x84\x82`@Q\x80\x83\x81R` \x01\x82\x81R` \x01\x92PPP`@Q\x80\x91\x03\x90\xA1[PP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a2\xA4W\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x93'\x13h\x83\x85`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83\x81R` \x01\x82\x15\x15\x81R` \x01\x92PPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a2\x8BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a2\x9FW=`\0\x80>=`\0\xFD[PPPP[PP\x9B\x9APPPPPPPPPPPV[`\x08` R\x81`\0R`@`\0 ` R\x80`\0R`@`\0 `\0\x91P\x91PPT\x81V[`\0`\x04T\x90P`\0\x81\x11a3WW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS001\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[a3c\x84\x84\x84\x84a\x1B\xBEV[PPPPV[```\0`\x03Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a3\x86W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a3\xB5W\x81` \x01` \x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x90P`\0\x80`\x02`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a5\tW\x80\x83\x83\x81Q\x81\x10a4`W\xFE[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP`\x02`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81\x80`\x01\x01\x92PPa4\x1FV[\x82\x93PPPP\x90V[`\x05T\x81V[`\0\x80\x82Q` \x84\x01\x85Z\xF4\x80`\0R=` R=`\0`@>`@=\x01`\0\xFD[a5\x85\x8A\x8A\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x89aQJV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a5\xC3Wa5\xC2\x84aVJV[[a6\x11\x87\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPPaVyV[`\0\x82\x11\x15a6+Wa6)\x82`\0`\x01\x86\x85aODV[P[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x14\x1D\xF8h\xA63\x1A\xF5(\xE3\x8C\x83\xB7\xAA\x03\xED\xC1\x9B\xE6n7\xAEg\xF9([\xF4\xF8\xE3\xC6\xA1\xA8\x8B\x8B\x8B\x8B\x89`@Q\x80\x80` \x01\x85\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81\x03\x82R\x87\x87\x82\x81\x81R` \x01\x92P` \x02\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPP\x96PPPPPPP`@Q\x80\x91\x03\x90\xA2PPPPPPPPPPV[`\0\x80Z\x90Pa7O\x87\x87\x87\x87\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x81\x84\x01R`\x1F\x19`\x1F\x82\x01\x16\x90P\x80\x83\x01\x92PPPPPPP\x86ZaN\x8DV[a7XW`\0\x80\xFD[`\0Z\x82\x03\x90P\x80`@Q` \x01\x80\x82\x81R` \x01\x91PP`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15a7\xE5W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa7\xCAV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15a8\x12W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x92PPP`@Q\x80\x91\x03\x90\xFD[```\0\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a8;W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a8jW\x81` \x01` \x82\x02\x806\x837\x80\x82\x01\x91PP\x90P[P\x91P`\0\x80`\x01`\0\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a9=WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a9HWP\x84\x82\x10[\x15a:\x03W\x80\x84\x83\x81Q\x81\x10a9ZW\xFE[` \x02` \x01\x01\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP`\x01`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81\x80`\x01\x01\x92PPa8\xD3V[\x80\x92P\x81\x84RPP\x92P\x92\x90PV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15a;\x14W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS030\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\x08`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x83\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x7F\xF2\xA0\xEB\x15dr\xD1D\x02U\xB0\xD7\xC1\xE1\x9C\xC0q\x15\xD1\x05\x1F\xE6\x05\xB0\xDC\xE6\x9A\xCF\xEC\x88M\x9C`@Q`@Q\x80\x91\x03\x90\xA3PV[`\0a;\xC6\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8C\x8CaFoV[\x80Q\x90` \x01 \x90P\x9B\x9APPPPPPPPPPPV[a;\xE6aMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a<PWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[a<\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS101\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a=\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS103\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xAA\xB4\xFA+F?X\x1B+2\xCB;~;pK\x9C\xE3|\xC2\t\xB5\xFBMw\xE5\x93\xAC\xE4\x05Bv\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPV[a?waMbV[`\0\x7FJ Ob\x0C\x8C\\\xCD\xCA?\xD5M\0;\xAD\xD8[\xA5\0CjC\x1F\x0C\xBD\xA4\xF5X\xC9<4\xC8`\0\x1B\x90P\x81\x81U\x7F\x11Q\x11i\x14Q[\xC0\x89\x1F\xF9\x04zl\xB3,\xF9\x02To\x83\x06d\x99\xBC\xF8\xBA3\xD25?\xA2\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPV[a?\xFBaMbV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a@eWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15a@\x9DWP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aA\x0FW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aB\x10W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aBzWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aB\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aC\xECW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS205\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xF8\xD4\x9F\xC5)\x81.\x9A|\\P\xE6\x9C \xF0\xDC\xCC\r\xB8\xFA\x95\xC9\x8B\xC5\x8C\xC9\xA4\xF1\xC1)\x9E\xAF\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x7F\x94e\xFA\x0C\x96,\xC7iX\xE67:\x993&@\x0C\x1C\x94\xF8\xBE/\xE3\xA9R\xAD\xFA\x7F`\xB2\xEA&\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PPPV[`\0`\x04T\x90P\x90V[```\0\x7F\xBB\x83\x10\xD4\x866\x8D\xB6\xBDo\x84\x94\x02\xFD\xD7:\xD5=1kZK&D\xADn\xFE\x0F\x94\x12\x86\xD8`\0\x1B\x8D\x8D\x8D\x8D`@Q\x80\x83\x83\x80\x82\x847\x80\x83\x01\x92PPP\x92PPP`@Q\x80\x91\x03\x90 \x8C\x8C\x8C\x8C\x8C\x8C\x8C`@Q` \x01\x80\x8C\x81R` \x01\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x8A\x81R` \x01\x89\x81R` \x01\x88`\x01\x81\x11\x15aG\0W\xFE[\x81R` \x01\x87\x81R` \x01\x86\x81R` \x01\x85\x81R` \x01\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x9BPPPPPPPPPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P`\x19`\xF8\x1B`\x01`\xF8\x1BaG\x8CaHxV[\x83`@Q` \x01\x80\x85~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x84~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16\x81R`\x01\x01\x83\x81R` \x01\x82\x81R` \x01\x94PPPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x91PP\x9B\x9APPPPPPPPPPPV[aH\x1FaMbV[aH(\x81aVJV[\x7FZ\xC6\xC4l\x93\xC8\xD0\xE57\x14\xBA;S\xDB>|\x04m\xA9\x941=~\xD0\xD1\x92\x02\x8B\xC7\xC2(\xB0\x81`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1PV[`\0\x7FG\xE7\x954\xA2E\x95.\x8B\x16\x89:3k\x85\xA3\xD9\xEA\x9F\xA8\xC5s\xF3\xD8\x03\xAF\xB9*yF\x92\x18`\0\x1BaH\xA6a%\xE4V[0`@Q` \x01\x80\x84\x81R` \x01\x83\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x93PPPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[aH\xFEaMbV[\x80`\x01`\x03T\x03\x10\x15aIyW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aI\xE3WP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aJUW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aKUW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS205\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x03`\0\x81T\x80\x92\x91\x90`\x01\x90\x03\x91\x90PUP\x7F\xF8\xD4\x9F\xC5)\x81.\x9A|\\P\xE6\x9C \xF0\xDC\xCC\r\xB8\xFA\x95\xC9\x8B\xC5\x8C\xC9\xA4\xF1\xC1)\x9E\xAF\x82`@Q\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP`@Q\x80\x91\x03\x90\xA1\x80`\x04T\x14aM$WaM#\x81a,>V[[PPPV[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F1.3.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aN\x03W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS031\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[V[`\0\x80\x83\x14\x15aN\x18W`\0\x90PaN9V[`\0\x82\x84\x02\x90P\x82\x84\x82\x81aN)W\xFE[\x04\x14aN4W`\0\x80\xFD[\x80\x91PP[\x92\x91PPV[`\0\x80`\0\x83`A\x02` \x81\x01\x86\x01Q\x92P`@\x81\x01\x86\x01Q\x91P`\xFF`A\x82\x01\x87\x01Q\x16\x93PP\x92P\x92P\x92V[`\0\x80\x82\x84\x01\x90P\x83\x81\x10\x15aN\x83W`\0\x80\xFD[\x80\x91PP\x92\x91PPV[`\0`\x01\x80\x81\x11\x15aN\x9BW\xFE[\x83`\x01\x81\x11\x15aN\xA7W\xFE[\x14\x15aN\xC0W`\0\x80\x85Q` \x87\x01\x89\x86\xF4\x90PaN\xD0V[`\0\x80\x85Q` \x87\x01\x88\x8A\x87\xF1\x90P[\x95\x94PPPPPV[`\0\x80\x7FJ Ob\x0C\x8C\\\xCD\xCA?\xD5M\0;\xAD\xD8[\xA5\0CjC\x1F\x0C\xBD\xA4\xF5X\xC9<4\xC8`\0\x1B\x90P\x80T\x91PP\x90V[`\0\x81\x83\x10\x15aO\x1AW\x81aO\x1CV[\x82[\x90P\x92\x91PPV[`\0\x82\x82\x11\x15aO3W`\0\x80\xFD[`\0\x82\x84\x03\x90P\x80\x91PP\x92\x91PPV[`\0\x80`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aO\x81W\x82aO\x83V[2[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aP\x9BWaO\xED:\x86\x10aO\xCAW:aO\xCCV[\x85[aO\xDF\x88\x8AaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x08\xFC\x83\x90\x81\x15\x02\x90`@Q`\0`@Q\x80\x83\x03\x81\x85\x88\x88\xF1\x93PPPPaP\x96W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS011\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[aQ@V[aP\xC0\x85aP\xB2\x88\x8AaNn\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[aN\x05\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x91PaP\xCD\x84\x82\x84aX\xB4V[aQ?W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS012\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[[P\x95\x94PPPPPV[`\0`\x04T\x14aQ\xC2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x81Q\x81\x11\x15aR9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS201\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x81\x10\x15aR\xB0W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS202\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0`\x01\x90P`\0[\x83Q\x81\x10\x15aU\xB6W`\0\x84\x82\x81Q\x81\x10aR\xD0W\xFE[` \x02` \x01\x01Q\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15aSDWP`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15aS|WP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x80\x15aS\xB4WP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[aT&W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS203\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aU'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS204\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x80`\x02`\0\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80\x92PP\x80\x80`\x01\x01\x91PPaR\xB9V[P`\x01`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x82Q`\x03\x81\x90UP\x81`\x04\x81\x90UPPPPV[`\0\x7Fl\x9AlJ9(N7\xED\x1C\xF5=3uw\xD1B\x12\xA4\x87\x0F\xB9v\xA46li;\x93\x99\x18\xD5`\0\x1B\x90P\x81\x81UPPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aW{W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS100\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\x01\x80`\0`\x01s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aX\xB0WaX=\x82`\0\x83`\x01ZaN\x8DV[aX\xAFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`\x05\x81R` \x01\x80\x7FGS000\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x01\x91PP`@Q\x80\x91\x03\x90\xFD[[PPV[`\0\x80c\xA9\x05\x9C\xBB\x84\x84`@Q`$\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90`\xE0\x1B` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x83\x16\x17\x83RPPPP\x90P` `\0\x82Q` \x84\x01`\0\x89a'\x10Z\x03\xF1=`\0\x81\x14aY[W` \x81\x14aYcW`\0\x93PaYnV[\x81\x93PaYnV[`\0Q\x15\x82\x15\x17\x15\x93P[PPP\x93\x92PPPV\xFE\xA2dipfsX\"\x12 8t\xBC\xF9.\x17\"\xCC{\xFA\x0C\xEF\x1A\t\x85\xCF\r\xC3H[\xA0f=\xB3t|\xCD\xF1`]\xF54dsolcC\0\x07\x06\x003",
+    );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`execTransactionFromModuleReturnData(address,uint256,bytes,
-    /// uint8)`](execTransactionFromModuleReturnDataCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    /**Event with signature `AddedOwner(address)` and selector `0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26`.
+    ```solidity
+    event AddedOwner(address owner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct execTransactionFromModuleReturnDataReturn {
-        #[allow(missing_docs)]
-        pub success: bool,
+    pub struct AddedOwner {
         #[allow(missing_docs)]
-        pub returnData: alloy_sol_types::private::Bytes,
+        pub owner: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -5340,329 +775,224 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-                <Enum::Operation as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<execTransactionFromModuleReturnDataCall> for UnderlyingRustTuple<'_> {
-                fn from(value: execTransactionFromModuleReturnDataCall) -> Self {
-                    (value.to, value.value, value.data, value.operation)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleReturnDataCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        to: tuple.0,
-                        value: tuple.1,
-                        data: tuple.2,
-                        operation: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool, alloy_sol_types::private::Bytes);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<execTransactionFromModuleReturnDataReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: execTransactionFromModuleReturnDataReturn) -> Self {
-                    (value.success, value.returnData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionFromModuleReturnDataReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        success: tuple.0,
-                        returnData: tuple.1,
-                    }
-                }
-            }
-        }
-        impl execTransactionFromModuleReturnDataReturn {
-            fn _tokenize(
-                &self,
-            ) -> <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                (
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.success,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.returnData,
-                    ),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for execTransactionFromModuleReturnDataCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-            );
-            type Return = execTransactionFromModuleReturnDataReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for AddedOwner {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [82u8, 41u8, 7u8, 63u8];
-            const SIGNATURE: &'static str =
-                "execTransactionFromModuleReturnData(address,uint256,bytes,uint8)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "AddedOwner(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    148u8, 101u8, 250u8, 12u8, 150u8, 44u8, 199u8, 105u8, 88u8, 230u8, 55u8, 58u8,
+                    153u8, 51u8, 38u8, 64u8, 12u8, 28u8, 148u8, 248u8, 190u8, 47u8, 227u8, 169u8,
+                    82u8, 173u8, 250u8, 127u8, 96u8, 178u8, 234u8, 38u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { owner: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
+                        &self.owner,
                     ),
-                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                execTransactionFromModuleReturnDataReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getChainId()` and selector `0x3408e470`.
-    ```solidity
-    function getChainId() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getChainIdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getChainId()`](getChainIdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getChainIdReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getChainIdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getChainIdCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getChainIdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for AddedOwner {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getChainIdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getChainIdReturn) -> Self {
-                    (value._0,)
-                }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getChainIdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        impl From<&AddedOwner> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &AddedOwner) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ApproveHash(bytes32,address)` and selector `0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c`.
+    ```solidity
+    event ApproveHash(bytes32 indexed approvedHash, address indexed owner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ApproveHash {
+        #[allow(missing_docs)]
+        pub approvedHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getChainIdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ApproveHash {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [52u8, 8u8, 228u8, 112u8];
-            const SIGNATURE: &'static str = "getChainId()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ApproveHash(bytes32,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    242u8, 160u8, 235u8, 21u8, 100u8, 114u8, 209u8, 68u8, 2u8, 85u8, 176u8, 215u8,
+                    193u8, 225u8, 156u8, 192u8, 113u8, 21u8, 209u8, 5u8, 31u8, 230u8, 5u8, 176u8,
+                    220u8, 230u8, 154u8, 207u8, 236u8, 136u8, 77u8, 156u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    approvedHash: topics.1,
+                    owner: topics.2,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 ()
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    Self::SIGNATURE_HASH.into(),
+                    self.approvedHash.clone(),
+                    self.owner.clone(),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getChainIdReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.approvedHash);
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ApproveHash {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ApproveHash> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getChainIdReturn = r.into();
-                    r._0
-                })
+            fn from(this: &ApproveHash) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getModulesPaginated(address,uint256)` and selector `0xcc2f8452`.
+    /**Event with signature `ChangedFallbackHandler(address)` and selector `0x5ac6c46c93c8d0e53714ba3b53db3e7c046da994313d7ed0d192028bc7c228b0`.
     ```solidity
-    function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next);
+    event ChangedFallbackHandler(address handler);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getModulesPaginatedCall {
-        #[allow(missing_docs)]
-        pub start: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub pageSize: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getModulesPaginated(address,uint256)`](getModulesPaginatedCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getModulesPaginatedReturn {
-        #[allow(missing_docs)]
-        pub array: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+    pub struct ChangedFallbackHandler {
         #[allow(missing_docs)]
-        pub next: alloy_sol_types::private::Address,
+        pub handler: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -5672,171 +1002,103 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getModulesPaginatedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getModulesPaginatedCall) -> Self {
-                    (value.start, value.pageSize)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesPaginatedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        start: tuple.0,
-                        pageSize: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getModulesPaginatedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getModulesPaginatedReturn) -> Self {
-                    (value.array, value.next)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesPaginatedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        array: tuple.0,
-                        next: tuple.1,
-                    }
-                }
-            }
-        }
-        impl getModulesPaginatedReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getModulesPaginatedCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.array),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.next,
-                    ),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getModulesPaginatedCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = getModulesPaginatedReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ChangedFallbackHandler {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [204u8, 47u8, 132u8, 82u8];
-            const SIGNATURE: &'static str = "getModulesPaginated(address,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ChangedFallbackHandler(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    90u8, 198u8, 196u8, 108u8, 147u8, 200u8, 208u8, 229u8, 55u8, 20u8, 186u8, 59u8,
+                    83u8, 219u8, 62u8, 124u8, 4u8, 109u8, 169u8, 148u8, 49u8, 61u8, 126u8, 208u8,
+                    209u8, 146u8, 2u8, 139u8, 199u8, 194u8, 40u8, 176u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { handler: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.start,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.pageSize,
+                        &self.handler,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getModulesPaginatedReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ChangedFallbackHandler {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ChangedFallbackHandler> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &ChangedFallbackHandler) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOwners()` and selector `0xa0e67e2b`.
+    /**Event with signature `ChangedGuard(address)` and selector `0x1151116914515bc0891ff9047a6cb32cf902546f83066499bcf8ba33d2353fa2`.
     ```solidity
-    function getOwners() external view returns (address[] memory);
+    event ChangedGuard(address guard);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOwnersCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getOwners()`](getOwnersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getOwnersReturn {
+    pub struct ChangedGuard {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub guard: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -5846,296 +1108,209 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnersCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOwnersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOwnersReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOwnersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOwnersCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ChangedGuard {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [160u8, 230u8, 126u8, 43u8];
-            const SIGNATURE: &'static str = "getOwners()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ChangedGuard(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    17u8, 81u8, 17u8, 105u8, 20u8, 81u8, 91u8, 192u8, 137u8, 31u8, 249u8, 4u8,
+                    122u8, 108u8, 179u8, 44u8, 249u8, 2u8, 84u8, 111u8, 131u8, 6u8, 100u8, 153u8,
+                    188u8, 248u8, 186u8, 51u8, 210u8, 53u8, 63u8, 162u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { guard: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.guard,
+                    ),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOwnersReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOwnersReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
-    ```solidity
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getStorageAtCall {
-        #[allow(missing_docs)]
-        pub offset: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub length: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getStorageAtReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtCall) -> Self {
-                    (value.offset, value.length)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        offset: tuple.0,
-                        length: tuple.1,
-                    }
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ChangedGuard {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtReturn) -> Self {
-                    (value._0,)
-                }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        impl From<&ChangedGuard> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ChangedGuard) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ChangedThreshold(uint256)` and selector `0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93`.
+    ```solidity
+    event ChangedThreshold(uint256 threshold);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ChangedThreshold {
+        #[allow(missing_docs)]
+        pub threshold: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getStorageAtCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ChangedThreshold {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
-            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ChangedThreshold(uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    97u8, 15u8, 127u8, 242u8, 179u8, 4u8, 174u8, 137u8, 3u8, 195u8, 222u8, 116u8,
+                    198u8, 12u8, 106u8, 177u8, 247u8, 214u8, 34u8, 107u8, 63u8, 82u8, 197u8, 22u8,
+                    25u8, 5u8, 187u8, 90u8, 212u8, 3u8, 156u8, 147u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { threshold: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.offset,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.length,
+                        &self.threshold,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getStorageAtReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ChangedThreshold {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ChangedThreshold> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getStorageAtReturn = r.into();
-                    r._0
-                })
+            fn from(this: &ChangedThreshold) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getThreshold()` and selector `0xe75235b8`.
+    /**Event with signature `DisabledModule(address)` and selector `0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276`.
     ```solidity
-    function getThreshold() external view returns (uint256);
+    event DisabledModule(address module);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getThresholdCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getThreshold()`](getThresholdCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getThresholdReturn {
+    pub struct DisabledModule {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub module: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -6145,158 +1320,211 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for DisabledModule {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "DisabledModule(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    170u8, 180u8, 250u8, 43u8, 70u8, 63u8, 88u8, 27u8, 43u8, 50u8, 203u8, 59u8,
+                    126u8, 59u8, 112u8, 75u8, 156u8, 227u8, 124u8, 194u8, 9u8, 181u8, 251u8, 77u8,
+                    119u8, 229u8, 147u8, 172u8, 228u8, 5u8, 66u8, 118u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { module: data.0 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getThresholdCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getThresholdCall) -> Self {
-                    ()
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getThresholdCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for DisabledModule {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getThresholdReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getThresholdReturn) -> Self {
-                    (value._0,)
-                }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getThresholdReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        impl From<&DisabledModule> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &DisabledModule) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `EnabledModule(address)` and selector `0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440`.
+    ```solidity
+    event EnabledModule(address module);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct EnabledModule {
+        #[allow(missing_docs)]
+        pub module: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getThresholdCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for EnabledModule {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [231u8, 82u8, 53u8, 184u8];
-            const SIGNATURE: &'static str = "getThreshold()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "EnabledModule(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    236u8, 223u8, 58u8, 62u8, 255u8, 234u8, 87u8, 131u8, 163u8, 196u8, 194u8, 20u8,
+                    14u8, 103u8, 117u8, 119u8, 102u8, 100u8, 40u8, 212u8, 78u8, 217u8, 212u8,
+                    116u8, 160u8, 179u8, 164u8, 201u8, 148u8, 63u8, 132u8, 64u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { module: data.0 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.module,
                     ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getThresholdReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getThresholdReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for EnabledModule {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&EnabledModule> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &EnabledModule) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)` and selector `0xd8d11f78`.
+    /**Event with signature `ExecutionFailure(bytes32,uint256)` and selector `0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23`.
     ```solidity
-    function getTransactionHash(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) external view returns (bytes32);
+    event ExecutionFailure(bytes32 txHash, uint256 payment);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct getTransactionHashCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub gasToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub refundReceiver: alloy_sol_types::private::Address,
+    pub struct ExecutionFailure {
         #[allow(missing_docs)]
-        pub _nonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,
-    /// uint256,address,address,uint256)`](getTransactionHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTransactionHashReturn {
+        pub txHash: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub payment: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -6306,225 +1534,113 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-                <Enum::Operation as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTransactionHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTransactionHashCall) -> Self {
-                    (
-                        value.to,
-                        value.value,
-                        value.data,
-                        value.operation,
-                        value.safeTxGas,
-                        value.baseGas,
-                        value.gasPrice,
-                        value.gasToken,
-                        value.refundReceiver,
-                        value._nonce,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransactionHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        to: tuple.0,
-                        value: tuple.1,
-                        data: tuple.2,
-                        operation: tuple.3,
-                        safeTxGas: tuple.4,
-                        baseGas: tuple.5,
-                        gasPrice: tuple.6,
-                        gasToken: tuple.7,
-                        refundReceiver: tuple.8,
-                        _nonce: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTransactionHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTransactionHashReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransactionHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTransactionHashCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolEvent for ExecutionFailure {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [216u8, 209u8, 31u8, 120u8];
-            const SIGNATURE: &'static str = "getTransactionHash(address,uint256,bytes,uint8,\
-                                             uint256,uint256,uint256,address,address,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionFailure(bytes32,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    35u8, 66u8, 139u8, 24u8, 172u8, 251u8, 62u8, 166u8, 75u8, 8u8, 220u8, 12u8,
+                    29u8, 41u8, 110u8, 169u8, 192u8, 151u8, 2u8, 192u8, 144u8, 131u8, 202u8, 82u8,
+                    114u8, 230u8, 77u8, 17u8, 91u8, 104u8, 125u8, 35u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    txHash: data.0,
+                    payment: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.safeTxGas,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.baseGas,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.gasPrice,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.gasToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.refundReceiver,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._nonce,
-                    ),
-                )
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::FixedBytes<
                         32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
+                    > as alloy_sol_types::SolType>::tokenize(&self.txHash),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getTransactionHashReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getTransactionHashReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionFailure {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionFailure> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionFailure) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isModuleEnabled(address)` and selector `0x2d9ad53d`.
+    /**Event with signature `ExecutionFromModuleFailure(address)` and selector `0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375`.
     ```solidity
-    function isModuleEnabled(address module) external view returns (bool);
+    event ExecutionFromModuleFailure(address indexed module);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct isModuleEnabledCall {
+    pub struct ExecutionFromModuleFailure {
         #[allow(missing_docs)]
         pub module: alloy_sol_types::private::Address,
     }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isModuleEnabled(address)`](isModuleEnabledCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isModuleEnabledReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6533,139 +1649,105 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isModuleEnabledCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isModuleEnabledCall) -> Self {
-                    (value.module,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isModuleEnabledCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { module: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isModuleEnabledReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isModuleEnabledReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isModuleEnabledReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for isModuleEnabledCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ExecutionFromModuleFailure {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [45u8, 154u8, 213u8, 61u8];
-            const SIGNATURE: &'static str = "isModuleEnabled(address)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionFromModuleFailure(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    172u8, 210u8, 200u8, 112u8, 40u8, 4u8, 18u8, 143u8, 219u8, 13u8, 178u8, 187u8,
+                    73u8, 246u8, 209u8, 39u8, 221u8, 1u8, 129u8, 193u8, 63u8, 212u8, 93u8, 191u8,
+                    225u8, 109u8, 224u8, 147u8, 14u8, 43u8, 211u8, 117u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { module: topics.1 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.module,
-                    ),
-                )
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isModuleEnabledReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.module.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.module,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionFromModuleFailure {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionFromModuleFailure> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isModuleEnabledReturn = r.into();
-                    r._0
-                })
+            fn from(this: &ExecutionFromModuleFailure) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isOwner(address)` and selector `0x2f54bf6e`.
+    /**Event with signature `ExecutionFromModuleSuccess(address)` and selector `0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8`.
     ```solidity
-    function isOwner(address owner) external view returns (bool);
+    event ExecutionFromModuleSuccess(address indexed module);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isOwnerCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isOwner(address)`](isOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct isOwnerReturn {
+    pub struct ExecutionFromModuleSuccess {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub module: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -6675,279 +1757,223 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isOwnerCall) -> Self {
-                    (value.owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isOwnerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for isOwnerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ExecutionFromModuleSuccess {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [47u8, 84u8, 191u8, 110u8];
-            const SIGNATURE: &'static str = "isOwner(address)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionFromModuleSuccess(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    104u8, 149u8, 193u8, 54u8, 100u8, 170u8, 79u8, 103u8, 40u8, 139u8, 37u8, 215u8,
+                    162u8, 29u8, 122u8, 170u8, 52u8, 145u8, 110u8, 53u8, 95u8, 185u8, 182u8, 250u8,
+                    224u8, 161u8, 57u8, 169u8, 8u8, 91u8, 236u8, 184u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self { module: topics.1 }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isOwnerReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.module.clone())
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isOwnerReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.module,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionFromModuleSuccess {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionFromModuleSuccess> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionFromModuleSuccess) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonce()` and selector `0xaffed0e0`.
+    /**Event with signature `ExecutionSuccess(bytes32,uint256)` and selector `0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e`.
     ```solidity
-    function nonce() external view returns (uint256);
+    event ExecutionSuccess(bytes32 txHash, uint256 payment);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nonceCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`nonce()`](nonceCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nonceReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
         clippy::pub_underscore_fields,
         clippy::style
     )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nonceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nonceCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nonceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nonceReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
+    #[derive(Clone)]
+    pub struct ExecutionSuccess {
+        #[allow(missing_docs)]
+        pub txHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub payment: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nonceCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ExecutionSuccess {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [175u8, 254u8, 208u8, 224u8];
-            const SIGNATURE: &'static str = "nonce()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ExecutionSuccess(bytes32,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    68u8, 46u8, 113u8, 95u8, 98u8, 99u8, 70u8, 232u8, 197u8, 67u8, 129u8, 0u8,
+                    45u8, 166u8, 20u8, 246u8, 43u8, 238u8, 141u8, 39u8, 56u8, 101u8, 53u8, 178u8,
+                    82u8, 30u8, 200u8, 84u8, 8u8, 152u8, 85u8, 110u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    txHash: data.0,
+                    payment: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.txHash),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: nonceReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: nonceReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ExecutionSuccess {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ExecutionSuccess> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ExecutionSuccess) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeOwner(address,address,uint256)` and selector `0xf8dc5dd9`.
+    /**Event with signature `RemovedOwner(address)` and selector `0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf`.
     ```solidity
-    function removeOwner(address prevOwner, address owner, uint256 _threshold) external;
+    event RemovedOwner(address owner);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct removeOwnerCall {
-        #[allow(missing_docs)]
-        pub prevOwner: alloy_sol_types::private::Address,
+    pub struct RemovedOwner {
         #[allow(missing_docs)]
         pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
     }
-    ///Container type for the return parameters of the
-    /// [`removeOwner(address,address,uint256)`](removeOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeOwnerReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6956,166 +1982,228 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RemovedOwner {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RemovedOwner(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    248u8, 212u8, 159u8, 197u8, 41u8, 129u8, 46u8, 154u8, 124u8, 92u8, 80u8, 230u8,
+                    156u8, 32u8, 240u8, 220u8, 204u8, 13u8, 184u8, 250u8, 149u8, 201u8, 139u8,
+                    197u8, 140u8, 201u8, 164u8, 241u8, 193u8, 41u8, 158u8, 175u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { owner: data.0 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeOwnerCall) -> Self {
-                    (value.prevOwner, value.owner, value._threshold)
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        prevOwner: tuple.0,
-                        owner: tuple.1,
-                        _threshold: tuple.2,
-                    }
-                }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
             }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeOwnerReturn) -> Self {
-                    ()
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RemovedOwner {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
         }
-        impl removeOwnerReturn {
-            fn _tokenize(&self) -> <removeOwnerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        #[automatically_derived]
+        impl From<&RemovedOwner> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RemovedOwner) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `SafeReceived(address,uint256)` and selector `0x3d0ce9bfc3ed7d6862dbb28b2dea94561fe714a1b4d019aa8af39730d1ad7c3d`.
+    ```solidity
+    event SafeReceived(address indexed sender, uint256 value);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct SafeReceived {
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeOwnerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolEvent for SafeReceived {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = removeOwnerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [248u8, 220u8, 93u8, 217u8];
-            const SIGNATURE: &'static str = "removeOwner(address,address,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SafeReceived(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    61u8, 12u8, 233u8, 191u8, 195u8, 237u8, 125u8, 104u8, 98u8, 219u8, 178u8,
+                    139u8, 45u8, 234u8, 148u8, 86u8, 31u8, 231u8, 20u8, 161u8, 180u8, 208u8, 25u8,
+                    170u8, 138u8, 243u8, 151u8, 48u8, 209u8, 173u8, 124u8, 61u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    sender: topics.1,
+                    value: data.0,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.prevOwner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._threshold,
+                        &self.value,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeOwnerReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.sender.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.sender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SafeReceived {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SafeReceived> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &SafeReceived) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `requiredTxGas(address,uint256,bytes,uint8)` and selector `0xc4ca3a9c`.
+    /**Event with signature `SafeSetup(address,address[],uint256,address,address)` and selector `0x141df868a6331af528e38c83b7aa03edc19be66e37ae67f9285bf4f8e3c6a1a8`.
     ```solidity
-    function requiredTxGas(address to, uint256 value, bytes memory data, Enum.Operation operation) external returns (uint256);
+    event SafeSetup(address indexed initiator, address[] owners, uint256 threshold, address initializer, address fallbackHandler);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct requiredTxGasCall {
+    pub struct SafeSetup {
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub initiator: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        pub owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
         #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
+        pub threshold: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`requiredTxGas(address,uint256,bytes,uint8)`](requiredTxGasCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct requiredTxGasReturn {
+        pub initializer: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub fallbackHandler: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -7125,167 +2213,130 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SafeSetup {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<requiredTxGasCall> for UnderlyingRustTuple<'_> {
-                fn from(value: requiredTxGasCall) -> Self {
-                    (value.to, value.value, value.data, value.operation)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requiredTxGasCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        to: tuple.0,
-                        value: tuple.1,
-                        data: tuple.2,
-                        operation: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<requiredTxGasReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: requiredTxGasReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for requiredTxGasReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for requiredTxGasCall {
-            type Parameters<'a> = (
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-                Enum::Operation,
             );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [196u8, 202u8, 58u8, 156u8];
-            const SIGNATURE: &'static str = "requiredTxGas(address,uint256,bytes,uint8)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SafeSetup(address,address[],uint256,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    20u8, 29u8, 248u8, 104u8, 166u8, 51u8, 26u8, 245u8, 40u8, 227u8, 140u8, 131u8,
+                    183u8, 170u8, 3u8, 237u8, 193u8, 155u8, 230u8, 110u8, 55u8, 174u8, 103u8,
+                    249u8, 40u8, 91u8, 244u8, 248u8, 227u8, 198u8, 161u8, 168u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    initiator: topics.1,
+                    owners: data.0,
+                    threshold: data.1,
+                    initializer: data.2,
+                    fallbackHandler: data.3,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.owners),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.threshold),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
+                        &self.initializer,
                     ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.fallbackHandler,
                     ),
-                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.initiator.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: requiredTxGasReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.initiator,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SafeSetup {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SafeSetup> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: requiredTxGasReturn = r.into();
-                    r._0
-                })
+            fn from(this: &SafeSetup) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setFallbackHandler(address)` and selector `0xf08a0323`.
+    /**Event with signature `SignMsg(bytes32)` and selector `0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4`.
     ```solidity
-    function setFallbackHandler(address handler) external;
+    event SignMsg(bytes32 indexed msgHash);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct setFallbackHandlerCall {
+    pub struct SignMsg {
         #[allow(missing_docs)]
-        pub handler: alloy_sol_types::private::Address,
+        pub msgHash: alloy_sol_types::private::FixedBytes<32>,
     }
-    ///Container type for the return parameters of the
-    /// [`setFallbackHandler(address)`](setFallbackHandlerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setFallbackHandlerReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7294,36 +2345,99 @@ pub mod GnosisSafe {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for SignMsg {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "SignMsg(bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    231u8, 244u8, 103u8, 80u8, 56u8, 244u8, 246u8, 3u8, 77u8, 252u8, 187u8, 178u8,
+                    76u8, 77u8, 192u8, 142u8, 78u8, 191u8, 16u8, 235u8, 157u8, 37u8, 125u8, 61u8,
+                    2u8, 192u8, 243u8, 141u8, 18u8, 42u8, 198u8, 228u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self { msgHash: topics.1 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setFallbackHandlerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setFallbackHandlerCall) -> Self {
-                    (value.handler,)
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFallbackHandlerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { handler: tuple.0 }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.msgHash.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.msgHash);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for SignMsg {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&SignMsg> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &SignMsg) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    /**Constructor`.
+    ```solidity
+    constructor();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {}
+    const _: () = {
+        use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
@@ -7341,37 +2455,24 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setFallbackHandlerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setFallbackHandlerReturn) -> Self {
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFallbackHandlerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl setFallbackHandlerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setFallbackHandlerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setFallbackHandlerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setFallbackHandlerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [240u8, 138u8, 3u8, 35u8];
-            const SIGNATURE: &'static str = "setFallbackHandler(address)";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -7381,49 +2482,27 @@ pub mod GnosisSafe {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.handler,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setFallbackHandlerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+                ()
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setGuard(address)` and selector `0xe19a9dd9`.
+    /**Function with signature `VERSION()` and selector `0xffa1ad74`.
     ```solidity
-    function setGuard(address guard) external;
+    function VERSION() external view returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setGuardCall {
-        #[allow(missing_docs)]
-        pub guard: alloy_sol_types::private::Address,
-    }
+    pub struct VERSIONCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setGuard(address)`](setGuardCall) function.
+    /// [`VERSION()`](VERSIONCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setGuardReturn {}
+    pub struct VERSIONReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::String,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7435,9 +2514,9 @@ pub mod GnosisSafe {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7449,25 +2528,25 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setGuardCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setGuardCall) -> Self {
-                    (value.guard,)
+            impl ::core::convert::From<VERSIONCall> for UnderlyingRustTuple<'_> {
+                fn from(value: VERSIONCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setGuardCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { guard: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7479,34 +2558,29 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setGuardReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setGuardReturn) -> Self {
-                    ()
+            impl ::core::convert::From<VERSIONReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: VERSIONReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setGuardReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setGuardReturn {
-            fn _tokenize(&self) -> <setGuardCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setGuardCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setGuardReturn;
+        impl alloy_sol_types::SolCall for VERSIONCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [225u8, 154u8, 157u8, 217u8];
-            const SIGNATURE: &'static str = "setGuard(address)";
+            const SELECTOR: [u8; 4] = [255u8, 161u8, 173u8, 116u8];
+            const SIGNATURE: &'static str = "VERSION()";
 
             #[inline]
             fn new<'a>(
@@ -7517,22 +2591,22 @@ pub mod GnosisSafe {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.guard,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setGuardReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: VERSIONReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7540,41 +2614,30 @@ pub mod GnosisSafe {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: VERSIONReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setup(address[],uint256,address,bytes,address,address,uint256,address)` and selector `0xb63e800d`.
+    /**Function with signature `domainSeparator()` and selector `0xf698da25`.
     ```solidity
-    function setup(address[] memory _owners, uint256 _threshold, address to, bytes memory data, address fallbackHandler, address paymentToken, uint256 payment, address paymentReceiver) external;
+    function domainSeparator() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setupCall {
-        #[allow(missing_docs)]
-        pub _owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub fallbackHandler: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub paymentToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub payment: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub paymentReceiver: alloy_sol_types::private::Address,
-    }
+    pub struct domainSeparatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setup(address[],uint256,address,bytes,address,address,uint256,
-    /// address)`](setupCall) function.
+    /// [`domainSeparator()`](domainSeparatorCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setupReturn {}
+    pub struct domainSeparatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7586,27 +2649,9 @@ pub mod GnosisSafe {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7618,43 +2663,25 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setupCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setupCall) -> Self {
-                    (
-                        value._owners,
-                        value._threshold,
-                        value.to,
-                        value.data,
-                        value.fallbackHandler,
-                        value.paymentToken,
-                        value.payment,
-                        value.paymentReceiver,
-                    )
+            impl ::core::convert::From<domainSeparatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: domainSeparatorCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setupCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _owners: tuple.0,
-                        _threshold: tuple.1,
-                        to: tuple.2,
-                        data: tuple.3,
-                        fallbackHandler: tuple.4,
-                        paymentToken: tuple.5,
-                        payment: tuple.6,
-                        paymentReceiver: tuple.7,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7666,44 +2693,29 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setupReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setupReturn) -> Self {
-                    ()
+            impl ::core::convert::From<domainSeparatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: domainSeparatorReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setupReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setupReturn {
-            fn _tokenize(&self) -> <setupCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setupCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = setupReturn;
+        impl alloy_sol_types::SolCall for domainSeparatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [182u8, 62u8, 128u8, 13u8];
-            const SIGNATURE: &'static str =
-                "setup(address[],uint256,address,bytes,address,address,uint256,address)";
+            const SELECTOR: [u8; 4] = [246u8, 152u8, 218u8, 37u8];
+            const SIGNATURE: &'static str = "domainSeparator()";
 
             #[inline]
             fn new<'a>(
@@ -7714,43 +2726,26 @@ pub mod GnosisSafe {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self._owners),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self._threshold),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.fallbackHandler,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.paymentToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.paymentReceiver,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setupReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: domainSeparatorReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -7758,26 +2753,51 @@ pub mod GnosisSafe {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: domainSeparatorReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `signedMessages(bytes32)` and selector `0x5ae6bd37`.
+    /**Function with signature `execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)` and selector `0x6a761202`.
     ```solidity
-    function signedMessages(bytes32) external view returns (uint256);
+    function execTransaction(address to, uint256 value, bytes memory data, Enum.Operation operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes memory signatures) external payable returns (bool success);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct signedMessagesCall(pub alloy_sol_types::private::FixedBytes<32>);
+    pub struct execTransactionCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub baseGas: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasPrice: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub gasToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub refundReceiver: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub signatures: alloy_sol_types::private::Bytes,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`signedMessages(bytes32)`](signedMessagesCall) function.
+    /// [`execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,
+    /// address,address,bytes)`](execTransactionCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct signedMessagesReturn {
+    pub struct execTransactionReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub success: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -7790,9 +2810,31 @@ pub mod GnosisSafe {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+                <Enum::Operation as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7804,25 +2846,47 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<signedMessagesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: signedMessagesCall) -> Self {
-                    (value.0,)
+            impl ::core::convert::From<execTransactionCall> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionCall) -> Self {
+                    (
+                        value.to,
+                        value.value,
+                        value.data,
+                        value.operation,
+                        value.safeTxGas,
+                        value.baseGas,
+                        value.gasPrice,
+                        value.gasToken,
+                        value.refundReceiver,
+                        value.signatures,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for signedMessagesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
+                    Self {
+                        to: tuple.0,
+                        value: tuple.1,
+                        data: tuple.2,
+                        operation: tuple.3,
+                        safeTxGas: tuple.4,
+                        baseGas: tuple.5,
+                        gasPrice: tuple.6,
+                        gasToken: tuple.7,
+                        refundReceiver: tuple.8,
+                        signatures: tuple.9,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7834,29 +2898,41 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<signedMessagesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: signedMessagesReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<execTransactionReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: execTransactionReturn) -> Self {
+                    (value.success,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for signedMessagesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for execTransactionReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { success: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for signedMessagesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for execTransactionCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+                Enum::Operation,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [90u8, 230u8, 189u8, 55u8];
-            const SIGNATURE: &'static str = "signedMessages(bytes32)";
+            const SELECTOR: [u8; 4] = [106u8, 118u8, 18u8, 2u8];
+            const SIGNATURE: &'static str = "execTransaction(address,uint256,bytes,uint8,uint256,\
+                                             uint256,uint256,address,address,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -7868,27 +2944,48 @@ pub mod GnosisSafe {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.0),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                    <Enum::Operation as alloy_sol_types::SolType>::tokenize(&self.operation),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.safeTxGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseGas,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.gasPrice,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.gasToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.refundReceiver,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.signatures,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: signedMessagesReturn = r.into();
-                        r._0
+                        let r: execTransactionReturn = r.into();
+                        r.success
                     },
                 )
             }
@@ -7899,30 +2996,29 @@ pub mod GnosisSafe {
                     data,
                 )
                 .map(|r| {
-                    let r: signedMessagesReturn = r.into();
-                    r._0
+                    let r: execTransactionReturn = r.into();
+                    r.success
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulateAndRevert(address,bytes)` and selector `0xb4faba09`.
+    /**Function with signature `nonce()` and selector `0xaffed0e0`.
     ```solidity
-    function simulateAndRevert(address targetContract, bytes memory calldataPayload) external;
+    function nonce() external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct simulateAndRevertCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`simulateAndRevert(address,bytes)`](simulateAndRevertCall) function.
+    pub struct nonceCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`nonce()`](nonceCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct simulateAndRevertReturn {}
+    pub struct nonceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7934,15 +3030,9 @@ pub mod GnosisSafe {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7954,28 +3044,25 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<simulateAndRevertCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateAndRevertCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
+            impl ::core::convert::From<nonceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nonceCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateAndRevertCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -7987,39 +3074,29 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<simulateAndRevertReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateAndRevertReturn) -> Self {
-                    ()
+            impl ::core::convert::From<nonceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nonceReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateAndRevertReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl simulateAndRevertReturn {
-            fn _tokenize(
-                &self,
-            ) -> <simulateAndRevertCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateAndRevertCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = simulateAndRevertReturn;
+        impl alloy_sol_types::SolCall for nonceCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [180u8, 250u8, 186u8, 9u8];
-            const SIGNATURE: &'static str = "simulateAndRevert(address,bytes)";
+            const SELECTOR: [u8; 4] = [175u8, 254u8, 208u8, 224u8];
+            const SIGNATURE: &'static str = "nonce()";
 
             #[inline]
             fn new<'a>(
@@ -8030,25 +3107,26 @@ pub mod GnosisSafe {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                simulateAndRevertReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: nonceReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -8056,30 +3134,44 @@ pub mod GnosisSafe {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: nonceReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapOwner(address,address,address)` and selector `0xe318b52b`.
+    /**Function with signature `setup(address[],uint256,address,bytes,address,address,uint256,address)` and selector `0xb63e800d`.
     ```solidity
-    function swapOwner(address prevOwner, address oldOwner, address newOwner) external;
+    function setup(address[] memory _owners, uint256 _threshold, address to, bytes memory data, address fallbackHandler, address paymentToken, uint256 payment, address paymentReceiver) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapOwnerCall {
+    pub struct setupCall {
+        #[allow(missing_docs)]
+        pub _owners: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub _threshold: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+        #[allow(missing_docs)]
+        pub fallbackHandler: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub prevOwner: alloy_sol_types::private::Address,
+        pub paymentToken: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub oldOwner: alloy_sol_types::private::Address,
+        pub payment: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub newOwner: alloy_sol_types::private::Address,
+        pub paymentReceiver: alloy_sol_types::private::Address,
     }
     ///Container type for the return parameters of the
-    /// [`swapOwner(address,address,address)`](swapOwnerCall) function.
+    /// [`setup(address[],uint256,address,bytes,address,address,uint256,
+    /// address)`](setupCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapOwnerReturn {}
+    pub struct setupReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8092,14 +3184,24 @@ pub mod GnosisSafe {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::Address,
             );
             #[cfg(test)]
@@ -8113,19 +3215,33 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapOwnerCall) -> Self {
-                    (value.prevOwner, value.oldOwner, value.newOwner)
+            impl ::core::convert::From<setupCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setupCall) -> Self {
+                    (
+                        value._owners,
+                        value._threshold,
+                        value.to,
+                        value.data,
+                        value.fallbackHandler,
+                        value.paymentToken,
+                        value.payment,
+                        value.paymentReceiver,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapOwnerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setupCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        prevOwner: tuple.0,
-                        oldOwner: tuple.1,
-                        newOwner: tuple.2,
+                        _owners: tuple.0,
+                        _threshold: tuple.1,
+                        to: tuple.2,
+                        data: tuple.3,
+                        fallbackHandler: tuple.4,
+                        paymentToken: tuple.5,
+                        payment: tuple.6,
+                        paymentReceiver: tuple.7,
                     }
                 }
             }
@@ -8147,38 +3263,44 @@ pub mod GnosisSafe {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapOwnerReturn) -> Self {
+            impl ::core::convert::From<setupReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setupReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapOwnerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setupReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl swapOwnerReturn {
-            fn _tokenize(&self) -> <swapOwnerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl setupReturn {
+            fn _tokenize(&self) -> <setupCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapOwnerCall {
+        impl alloy_sol_types::SolCall for setupCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Address,
             );
-            type Return = swapOwnerReturn;
+            type Return = setupReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [227u8, 24u8, 181u8, 43u8];
-            const SIGNATURE: &'static str = "swapOwner(address,address,address)";
+            const SELECTOR: [u8; 4] = [182u8, 62u8, 128u8, 13u8];
+            const SIGNATURE: &'static str =
+                "setup(address[],uint256,address,bytes,address,address,uint256,address)";
 
             #[inline]
             fn new<'a>(
@@ -8190,21 +3312,36 @@ pub mod GnosisSafe {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self._owners),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self._threshold),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.prevOwner,
+                        &self.fallbackHandler,
                     ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.oldOwner,
+                        &self.paymentToken,
                     ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.payment),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newOwner,
+                        &self.paymentReceiver,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapOwnerReturn::_tokenize(ret)
+                setupReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -8228,65 +3365,13 @@ pub mod GnosisSafe {
         #[allow(missing_docs)]
         VERSION(VERSIONCall),
         #[allow(missing_docs)]
-        addOwnerWithThreshold(addOwnerWithThresholdCall),
-        #[allow(missing_docs)]
-        approveHash(approveHashCall),
-        #[allow(missing_docs)]
-        approvedHashes(approvedHashesCall),
-        #[allow(missing_docs)]
-        changeThreshold(changeThresholdCall),
-        #[allow(missing_docs)]
-        checkNSignatures(checkNSignaturesCall),
-        #[allow(missing_docs)]
-        checkSignatures(checkSignaturesCall),
-        #[allow(missing_docs)]
-        disableModule(disableModuleCall),
-        #[allow(missing_docs)]
         domainSeparator(domainSeparatorCall),
         #[allow(missing_docs)]
-        enableModule(enableModuleCall),
-        #[allow(missing_docs)]
-        encodeTransactionData(encodeTransactionDataCall),
-        #[allow(missing_docs)]
         execTransaction(execTransactionCall),
         #[allow(missing_docs)]
-        execTransactionFromModule(execTransactionFromModuleCall),
-        #[allow(missing_docs)]
-        execTransactionFromModuleReturnData(execTransactionFromModuleReturnDataCall),
-        #[allow(missing_docs)]
-        getChainId(getChainIdCall),
-        #[allow(missing_docs)]
-        getModulesPaginated(getModulesPaginatedCall),
-        #[allow(missing_docs)]
-        getOwners(getOwnersCall),
-        #[allow(missing_docs)]
-        getStorageAt(getStorageAtCall),
-        #[allow(missing_docs)]
-        getThreshold(getThresholdCall),
-        #[allow(missing_docs)]
-        getTransactionHash(getTransactionHashCall),
-        #[allow(missing_docs)]
-        isModuleEnabled(isModuleEnabledCall),
-        #[allow(missing_docs)]
-        isOwner(isOwnerCall),
-        #[allow(missing_docs)]
         nonce(nonceCall),
         #[allow(missing_docs)]
-        removeOwner(removeOwnerCall),
-        #[allow(missing_docs)]
-        requiredTxGas(requiredTxGasCall),
-        #[allow(missing_docs)]
-        setFallbackHandler(setFallbackHandlerCall),
-        #[allow(missing_docs)]
-        setGuard(setGuardCall),
-        #[allow(missing_docs)]
         setup(setupCall),
-        #[allow(missing_docs)]
-        signedMessages(signedMessagesCall),
-        #[allow(missing_docs)]
-        simulateAndRevert(simulateAndRevertCall),
-        #[allow(missing_docs)]
-        swapOwner(swapOwnerCall),
     }
     impl GnosisSafeCalls {
         /// All the selectors of this enum.
@@ -8297,104 +3382,26 @@ pub mod GnosisSafe {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [13u8, 88u8, 47u8, 19u8],
-            [18u8, 251u8, 104u8, 224u8],
-            [45u8, 154u8, 213u8, 61u8],
-            [47u8, 84u8, 191u8, 110u8],
-            [52u8, 8u8, 228u8, 112u8],
-            [70u8, 135u8, 33u8, 167u8],
-            [82u8, 41u8, 7u8, 63u8],
-            [86u8, 36u8, 178u8, 91u8],
-            [90u8, 230u8, 189u8, 55u8],
-            [97u8, 11u8, 89u8, 37u8],
-            [105u8, 78u8, 128u8, 195u8],
             [106u8, 118u8, 18u8, 2u8],
-            [125u8, 131u8, 41u8, 116u8],
-            [147u8, 79u8, 58u8, 17u8],
-            [160u8, 230u8, 126u8, 43u8],
             [175u8, 254u8, 208u8, 224u8],
-            [180u8, 250u8, 186u8, 9u8],
             [182u8, 62u8, 128u8, 13u8],
-            [196u8, 202u8, 58u8, 156u8],
-            [204u8, 47u8, 132u8, 82u8],
-            [212u8, 217u8, 189u8, 205u8],
-            [216u8, 209u8, 31u8, 120u8],
-            [224u8, 9u8, 207u8, 222u8],
-            [225u8, 154u8, 157u8, 217u8],
-            [227u8, 24u8, 181u8, 43u8],
-            [231u8, 82u8, 53u8, 184u8],
-            [232u8, 102u8, 55u8, 219u8],
-            [240u8, 138u8, 3u8, 35u8],
             [246u8, 152u8, 218u8, 37u8],
-            [248u8, 220u8, 93u8, 217u8],
             [255u8, 161u8, 173u8, 116u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <checkNSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isModuleEnabledCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <isOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getChainIdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <execTransactionFromModuleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <signedMessagesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <enableModuleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <changeThresholdCall as alloy_sol_types::SolCall>::SIGNATURE,
             <execTransactionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <approvedHashesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <checkSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOwnersCall as alloy_sol_types::SolCall>::SIGNATURE,
             <nonceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <simulateAndRevertCall as alloy_sol_types::SolCall>::SIGNATURE,
             <setupCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <requiredTxGasCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getModulesPaginatedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <approveHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTransactionHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <disableModuleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setGuardCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getThresholdCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <encodeTransactionDataCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setFallbackHandlerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <domainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(addOwnerWithThreshold),
-            ::core::stringify!(checkNSignatures),
-            ::core::stringify!(isModuleEnabled),
-            ::core::stringify!(isOwner),
-            ::core::stringify!(getChainId),
-            ::core::stringify!(execTransactionFromModule),
-            ::core::stringify!(execTransactionFromModuleReturnData),
-            ::core::stringify!(getStorageAt),
-            ::core::stringify!(signedMessages),
-            ::core::stringify!(enableModule),
-            ::core::stringify!(changeThreshold),
             ::core::stringify!(execTransaction),
-            ::core::stringify!(approvedHashes),
-            ::core::stringify!(checkSignatures),
-            ::core::stringify!(getOwners),
             ::core::stringify!(nonce),
-            ::core::stringify!(simulateAndRevert),
             ::core::stringify!(setup),
-            ::core::stringify!(requiredTxGas),
-            ::core::stringify!(getModulesPaginated),
-            ::core::stringify!(approveHash),
-            ::core::stringify!(getTransactionHash),
-            ::core::stringify!(disableModule),
-            ::core::stringify!(setGuard),
-            ::core::stringify!(swapOwner),
-            ::core::stringify!(getThreshold),
-            ::core::stringify!(encodeTransactionData),
-            ::core::stringify!(setFallbackHandler),
             ::core::stringify!(domainSeparator),
-            ::core::stringify!(removeOwner),
             ::core::stringify!(VERSION),
         ];
 
@@ -8420,7 +3427,7 @@ pub mod GnosisSafe {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for GnosisSafeCalls {
-        const COUNT: usize = 31usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "GnosisSafeCalls";
 
@@ -8428,68 +3435,14 @@ pub mod GnosisSafe {
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::VERSION(_) => <VERSIONCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addOwnerWithThreshold(_) => {
-                    <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::approveHash(_) => <approveHashCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::approvedHashes(_) => {
-                    <approvedHashesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::changeThreshold(_) => {
-                    <changeThresholdCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::checkNSignatures(_) => {
-                    <checkNSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::checkSignatures(_) => {
-                    <checkSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::disableModule(_) => <disableModuleCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::domainSeparator(_) => {
                     <domainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::enableModule(_) => <enableModuleCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::encodeTransactionData(_) => {
-                    <encodeTransactionDataCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::execTransaction(_) => {
                     <execTransactionCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::execTransactionFromModule(_) => {
-                    <execTransactionFromModuleCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::execTransactionFromModuleReturnData(_) => {
-                    <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getChainId(_) => <getChainIdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getModulesPaginated(_) => {
-                    <getModulesPaginatedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getOwners(_) => <getOwnersCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getThreshold(_) => <getThresholdCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getTransactionHash(_) => {
-                    <getTransactionHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::isModuleEnabled(_) => {
-                    <isModuleEnabledCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::isOwner(_) => <isOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonce(_) => <nonceCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeOwner(_) => <removeOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::requiredTxGas(_) => <requiredTxGasCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setFallbackHandler(_) => {
-                    <setFallbackHandlerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setGuard(_) => <setGuardCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::setup(_) => <setupCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::signedMessages(_) => {
-                    <signedMessagesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::simulateAndRevert(_) => {
-                    <simulateAndRevertCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapOwner(_) => <swapOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
 
@@ -8507,95 +3460,6 @@ pub mod GnosisSafe {
         #[allow(non_snake_case)]
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
             static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<GnosisSafeCalls>] = &[
-                {
-                    fn addOwnerWithThreshold(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::addOwnerWithThreshold)
-                    }
-                    addOwnerWithThreshold
-                },
-                {
-                    fn checkNSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::checkNSignatures)
-                    }
-                    checkNSignatures
-                },
-                {
-                    fn isModuleEnabled(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::isModuleEnabled)
-                    }
-                    isModuleEnabled
-                },
-                {
-                    fn isOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <isOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::isOwner)
-                    }
-                    isOwner
-                },
-                {
-                    fn getChainId(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getChainIdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::getChainId)
-                    }
-                    getChainId
-                },
-                {
-                    fn execTransactionFromModule(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::execTransactionFromModule)
-                    }
-                    execTransactionFromModule
-                },
-                {
-                    fn execTransactionFromModuleReturnData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::execTransactionFromModuleReturnData)
-                    }
-                    execTransactionFromModuleReturnData
-                },
-                {
-                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
-                {
-                    fn signedMessages(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <signedMessagesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::signedMessages)
-                    }
-                    signedMessages
-                },
-                {
-                    fn enableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <enableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::enableModule)
-                    }
-                    enableModule
-                },
-                {
-                    fn changeThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <changeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::changeThreshold)
-                    }
-                    changeThreshold
-                },
                 {
                     fn execTransaction(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <execTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8603,27 +3467,6 @@ pub mod GnosisSafe {
                     }
                     execTransaction
                 },
-                {
-                    fn approvedHashes(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <approvedHashesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::approvedHashes)
-                    }
-                    approvedHashes
-                },
-                {
-                    fn checkSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <checkSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::checkSignatures)
-                    }
-                    checkSignatures
-                },
-                {
-                    fn getOwners(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getOwnersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::getOwners)
-                    }
-                    getOwners
-                },
                 {
                     fn nonce(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <nonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8631,13 +3474,6 @@ pub mod GnosisSafe {
                     }
                     nonce
                 },
-                {
-                    fn simulateAndRevert(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::simulateAndRevert)
-                    }
-                    simulateAndRevert
-                },
                 {
                     fn setup(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <setupCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8645,82 +3481,6 @@ pub mod GnosisSafe {
                     }
                     setup
                 },
-                {
-                    fn requiredTxGas(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <requiredTxGasCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::requiredTxGas)
-                    }
-                    requiredTxGas
-                },
-                {
-                    fn getModulesPaginated(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::getModulesPaginated)
-                    }
-                    getModulesPaginated
-                },
-                {
-                    fn approveHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <approveHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::approveHash)
-                    }
-                    approveHash
-                },
-                {
-                    fn getTransactionHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::getTransactionHash)
-                    }
-                    getTransactionHash
-                },
-                {
-                    fn disableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <disableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::disableModule)
-                    }
-                    disableModule
-                },
-                {
-                    fn setGuard(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <setGuardCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::setGuard)
-                    }
-                    setGuard
-                },
-                {
-                    fn swapOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <swapOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::swapOwner)
-                    }
-                    swapOwner
-                },
-                {
-                    fn getThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::getThreshold)
-                    }
-                    getThreshold
-                },
-                {
-                    fn encodeTransactionData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::encodeTransactionData)
-                    }
-                    encodeTransactionData
-                },
-                {
-                    fn setFallbackHandler(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::setFallbackHandler)
-                    }
-                    setFallbackHandler
-                },
                 {
                     fn domainSeparator(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8728,13 +3488,6 @@ pub mod GnosisSafe {
                     }
                     domainSeparator
                 },
-                {
-                    fn removeOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <removeOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCalls::removeOwner)
-                    }
-                    removeOwner
-                },
                 {
                     fn VERSION(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -8762,107 +3515,6 @@ pub mod GnosisSafe {
                 &[u8],
             )
                 -> alloy_sol_types::Result<GnosisSafeCalls>] = &[
-                {
-                    fn addOwnerWithThreshold(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::addOwnerWithThreshold)
-                    }
-                    addOwnerWithThreshold
-                },
-                {
-                    fn checkNSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::checkNSignatures)
-                    }
-                    checkNSignatures
-                },
-                {
-                    fn isModuleEnabled(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::isModuleEnabled)
-                    }
-                    isModuleEnabled
-                },
-                {
-                    fn isOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <isOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::isOwner)
-                    }
-                    isOwner
-                },
-                {
-                    fn getChainId(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getChainIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::getChainId)
-                    }
-                    getChainId
-                },
-                {
-                    fn execTransactionFromModule(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::execTransactionFromModule)
-                    }
-                    execTransactionFromModule
-                },
-                {
-                    fn execTransactionFromModuleReturnData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::execTransactionFromModuleReturnData)
-                    }
-                    execTransactionFromModuleReturnData
-                },
-                {
-                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
-                {
-                    fn signedMessages(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <signedMessagesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::signedMessages)
-                    }
-                    signedMessages
-                },
-                {
-                    fn enableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <enableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::enableModule)
-                    }
-                    enableModule
-                },
-                {
-                    fn changeThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <changeThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::changeThreshold)
-                    }
-                    changeThreshold
-                },
                 {
                     fn execTransaction(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <execTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -8872,31 +3524,6 @@ pub mod GnosisSafe {
                     }
                     execTransaction
                 },
-                {
-                    fn approvedHashes(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <approvedHashesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::approvedHashes)
-                    }
-                    approvedHashes
-                },
-                {
-                    fn checkSignatures(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <checkSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::checkSignatures)
-                    }
-                    checkSignatures
-                },
-                {
-                    fn getOwners(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getOwnersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::getOwners)
-                    }
-                    getOwners
-                },
                 {
                     fn nonce(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <nonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8904,15 +3531,6 @@ pub mod GnosisSafe {
                     }
                     nonce
                 },
-                {
-                    fn simulateAndRevert(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::simulateAndRevert)
-                    }
-                    simulateAndRevert
-                },
                 {
                     fn setup(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <setupCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -8920,94 +3538,6 @@ pub mod GnosisSafe {
                     }
                     setup
                 },
-                {
-                    fn requiredTxGas(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <requiredTxGasCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::requiredTxGas)
-                    }
-                    requiredTxGas
-                },
-                {
-                    fn getModulesPaginated(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::getModulesPaginated)
-                    }
-                    getModulesPaginated
-                },
-                {
-                    fn approveHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <approveHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::approveHash)
-                    }
-                    approveHash
-                },
-                {
-                    fn getTransactionHash(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::getTransactionHash)
-                    }
-                    getTransactionHash
-                },
-                {
-                    fn disableModule(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <disableModuleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::disableModule)
-                    }
-                    disableModule
-                },
-                {
-                    fn setGuard(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <setGuardCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::setGuard)
-                    }
-                    setGuard
-                },
-                {
-                    fn swapOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <swapOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::swapOwner)
-                    }
-                    swapOwner
-                },
-                {
-                    fn getThreshold(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <getThresholdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCalls::getThreshold)
-                    }
-                    getThreshold
-                },
-                {
-                    fn encodeTransactionData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::encodeTransactionData)
-                    }
-                    encodeTransactionData
-                },
-                {
-                    fn setFallbackHandler(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeCalls::setFallbackHandler)
-                    }
-                    setFallbackHandler
-                },
                 {
                     fn domainSeparator(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -9017,13 +3547,6 @@ pub mod GnosisSafe {
                     }
                     domainSeparator
                 },
-                {
-                    fn removeOwner(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
-                        <removeOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCalls::removeOwner)
-                    }
-                    removeOwner
-                },
                 {
                     fn VERSION(data: &[u8]) -> alloy_sol_types::Result<GnosisSafeCalls> {
                         <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -9036,153 +3559,29 @@ pub mod GnosisSafe {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
                     selector,
-                ));
-            };
-            DECODE_VALIDATE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        fn abi_encoded_size(&self) -> usize {
-            match self {
-                Self::VERSION(inner) => {
-                    <VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addOwnerWithThreshold(inner) => {
-                    <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::approveHash(inner) => {
-                    <approveHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::approvedHashes(inner) => {
-                    <approvedHashesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::changeThreshold(inner) => {
-                    <changeThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::checkNSignatures(inner) => {
-                    <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::checkSignatures(inner) => {
-                    <checkSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::disableModule(inner) => {
-                    <disableModuleCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::VERSION(inner) => {
+                    <VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::domainSeparator(inner) => {
-                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::enableModule(inner) => {
-                    <enableModuleCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::encodeTransactionData(inner) => {
-                    <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::execTransaction(inner) => {
-                    <execTransactionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::execTransactionFromModule(inner) => {
-                    <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::execTransactionFromModuleReturnData(inner) => {
-                    <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getChainId(inner) => {
-                    <getChainIdCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getModulesPaginated(inner) => {
-                    <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getOwners(inner) => {
-                    <getOwnersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getThreshold(inner) => {
-                    <getThresholdCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTransactionHash(inner) => {
-                    <getTransactionHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::isModuleEnabled(inner) => {
-                    <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::isOwner(inner) => {
-                    <isOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                    <execTransactionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::nonce(inner) => {
                     <nonceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::removeOwner(inner) => {
-                    <removeOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::requiredTxGas(inner) => {
-                    <requiredTxGasCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setFallbackHandler(inner) => {
-                    <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setGuard(inner) => {
-                    <setGuardCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::setup(inner) => {
                     <setupCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::signedMessages(inner) => {
-                    <signedMessagesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::simulateAndRevert(inner) => {
-                    <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapOwner(inner) => {
-                    <swapOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -9192,177 +3591,18 @@ pub mod GnosisSafe {
                 Self::VERSION(inner) => {
                     <VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::addOwnerWithThreshold(inner) => {
-                    <addOwnerWithThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::approveHash(inner) => {
-                    <approveHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::approvedHashes(inner) => {
-                    <approvedHashesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::changeThreshold(inner) => {
-                    <changeThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::checkNSignatures(inner) => {
-                    <checkNSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::checkSignatures(inner) => {
-                    <checkSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::disableModule(inner) => {
-                    <disableModuleCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::domainSeparator(inner) => {
-                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::enableModule(inner) => {
-                    <enableModuleCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::encodeTransactionData(inner) => {
-                    <encodeTransactionDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::execTransaction(inner) => {
-                    <execTransactionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::execTransactionFromModule(inner) => {
-                    <execTransactionFromModuleCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::execTransactionFromModuleReturnData(inner) => {
-                    <execTransactionFromModuleReturnDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getChainId(inner) => {
-                    <getChainIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getModulesPaginated(inner) => {
-                    <getModulesPaginatedCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getOwners(inner) => {
-                    <getOwnersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getThreshold(inner) => {
-                    <getThresholdCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getTransactionHash(inner) => {
-                    <getTransactionHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isModuleEnabled(inner) => {
-                    <isModuleEnabledCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isOwner(inner) => {
-                    <isOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                    <execTransactionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::nonce(inner) => {
                     <nonceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeOwner(inner) => {
-                    <removeOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::requiredTxGas(inner) => {
-                    <requiredTxGasCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::setFallbackHandler(inner) => {
-                    <setFallbackHandlerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::setGuard(inner) => {
-                    <setGuardCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::setup(inner) => {
                     <setupCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::signedMessages(inner) => {
-                    <signedMessagesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::simulateAndRevert(inner) => {
-                    <simulateAndRevertCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapOwner(inner) => {
-                    <swapOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
             }
         }
     }
@@ -9891,80 +4131,6 @@ pub mod GnosisSafe {
             self.call_builder(&VERSIONCall)
         }
 
-        ///Creates a new call builder for the [`addOwnerWithThreshold`]
-        /// function.
-        pub fn addOwnerWithThreshold(
-            &self,
-            owner: alloy_sol_types::private::Address,
-            _threshold: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addOwnerWithThresholdCall, N> {
-            self.call_builder(&addOwnerWithThresholdCall { owner, _threshold })
-        }
-
-        ///Creates a new call builder for the [`approveHash`] function.
-        pub fn approveHash(
-            &self,
-            hashToApprove: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, approveHashCall, N> {
-            self.call_builder(&approveHashCall { hashToApprove })
-        }
-
-        ///Creates a new call builder for the [`approvedHashes`] function.
-        pub fn approvedHashes(
-            &self,
-            _0: alloy_sol_types::private::Address,
-            _1: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, approvedHashesCall, N> {
-            self.call_builder(&approvedHashesCall { _0, _1 })
-        }
-
-        ///Creates a new call builder for the [`changeThreshold`] function.
-        pub fn changeThreshold(
-            &self,
-            _threshold: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, changeThresholdCall, N> {
-            self.call_builder(&changeThresholdCall { _threshold })
-        }
-
-        ///Creates a new call builder for the [`checkNSignatures`] function.
-        pub fn checkNSignatures(
-            &self,
-            dataHash: alloy_sol_types::private::FixedBytes<32>,
-            data: alloy_sol_types::private::Bytes,
-            signatures: alloy_sol_types::private::Bytes,
-            requiredSignatures: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, checkNSignaturesCall, N> {
-            self.call_builder(&checkNSignaturesCall {
-                dataHash,
-                data,
-                signatures,
-                requiredSignatures,
-            })
-        }
-
-        ///Creates a new call builder for the [`checkSignatures`] function.
-        pub fn checkSignatures(
-            &self,
-            dataHash: alloy_sol_types::private::FixedBytes<32>,
-            data: alloy_sol_types::private::Bytes,
-            signatures: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, checkSignaturesCall, N> {
-            self.call_builder(&checkSignaturesCall {
-                dataHash,
-                data,
-                signatures,
-            })
-        }
-
-        ///Creates a new call builder for the [`disableModule`] function.
-        pub fn disableModule(
-            &self,
-            prevModule: alloy_sol_types::private::Address,
-            module: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, disableModuleCall, N> {
-            self.call_builder(&disableModuleCall { prevModule, module })
-        }
-
         ///Creates a new call builder for the [`domainSeparator`] function.
         pub fn domainSeparator(
             &self,
@@ -9972,43 +4138,6 @@ pub mod GnosisSafe {
             self.call_builder(&domainSeparatorCall)
         }
 
-        ///Creates a new call builder for the [`enableModule`] function.
-        pub fn enableModule(
-            &self,
-            module: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, enableModuleCall, N> {
-            self.call_builder(&enableModuleCall { module })
-        }
-
-        ///Creates a new call builder for the [`encodeTransactionData`]
-        /// function.
-        pub fn encodeTransactionData(
-            &self,
-            to: alloy_sol_types::private::Address,
-            value: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-            safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
-            baseGas: alloy_sol_types::private::primitives::aliases::U256,
-            gasPrice: alloy_sol_types::private::primitives::aliases::U256,
-            gasToken: alloy_sol_types::private::Address,
-            refundReceiver: alloy_sol_types::private::Address,
-            _nonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, encodeTransactionDataCall, N> {
-            self.call_builder(&encodeTransactionDataCall {
-                to,
-                value,
-                data,
-                operation,
-                safeTxGas,
-                baseGas,
-                gasPrice,
-                gasToken,
-                refundReceiver,
-                _nonce,
-            })
-        }
-
         ///Creates a new call builder for the [`execTransaction`] function.
         pub fn execTransaction(
             &self,
@@ -10037,169 +4166,11 @@ pub mod GnosisSafe {
             })
         }
 
-        ///Creates a new call builder for the [`execTransactionFromModule`]
-        /// function.
-        pub fn execTransactionFromModule(
-            &self,
-            to: alloy_sol_types::private::Address,
-            value: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, execTransactionFromModuleCall, N> {
-            self.call_builder(&execTransactionFromModuleCall {
-                to,
-                value,
-                data,
-                operation,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`execTransactionFromModuleReturnData`] function.
-        pub fn execTransactionFromModuleReturnData(
-            &self,
-            to: alloy_sol_types::private::Address,
-            value: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, execTransactionFromModuleReturnDataCall, N>
-        {
-            self.call_builder(&execTransactionFromModuleReturnDataCall {
-                to,
-                value,
-                data,
-                operation,
-            })
-        }
-
-        ///Creates a new call builder for the [`getChainId`] function.
-        pub fn getChainId(&self) -> alloy_contract::SolCallBuilder<&P, getChainIdCall, N> {
-            self.call_builder(&getChainIdCall)
-        }
-
-        ///Creates a new call builder for the [`getModulesPaginated`] function.
-        pub fn getModulesPaginated(
-            &self,
-            start: alloy_sol_types::private::Address,
-            pageSize: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getModulesPaginatedCall, N> {
-            self.call_builder(&getModulesPaginatedCall { start, pageSize })
-        }
-
-        ///Creates a new call builder for the [`getOwners`] function.
-        pub fn getOwners(&self) -> alloy_contract::SolCallBuilder<&P, getOwnersCall, N> {
-            self.call_builder(&getOwnersCall)
-        }
-
-        ///Creates a new call builder for the [`getStorageAt`] function.
-        pub fn getStorageAt(
-            &self,
-            offset: alloy_sol_types::private::primitives::aliases::U256,
-            length: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
-            self.call_builder(&getStorageAtCall { offset, length })
-        }
-
-        ///Creates a new call builder for the [`getThreshold`] function.
-        pub fn getThreshold(&self) -> alloy_contract::SolCallBuilder<&P, getThresholdCall, N> {
-            self.call_builder(&getThresholdCall)
-        }
-
-        ///Creates a new call builder for the [`getTransactionHash`] function.
-        pub fn getTransactionHash(
-            &self,
-            to: alloy_sol_types::private::Address,
-            value: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-            safeTxGas: alloy_sol_types::private::primitives::aliases::U256,
-            baseGas: alloy_sol_types::private::primitives::aliases::U256,
-            gasPrice: alloy_sol_types::private::primitives::aliases::U256,
-            gasToken: alloy_sol_types::private::Address,
-            refundReceiver: alloy_sol_types::private::Address,
-            _nonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getTransactionHashCall, N> {
-            self.call_builder(&getTransactionHashCall {
-                to,
-                value,
-                data,
-                operation,
-                safeTxGas,
-                baseGas,
-                gasPrice,
-                gasToken,
-                refundReceiver,
-                _nonce,
-            })
-        }
-
-        ///Creates a new call builder for the [`isModuleEnabled`] function.
-        pub fn isModuleEnabled(
-            &self,
-            module: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isModuleEnabledCall, N> {
-            self.call_builder(&isModuleEnabledCall { module })
-        }
-
-        ///Creates a new call builder for the [`isOwner`] function.
-        pub fn isOwner(
-            &self,
-            owner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isOwnerCall, N> {
-            self.call_builder(&isOwnerCall { owner })
-        }
-
         ///Creates a new call builder for the [`nonce`] function.
         pub fn nonce(&self) -> alloy_contract::SolCallBuilder<&P, nonceCall, N> {
             self.call_builder(&nonceCall)
         }
 
-        ///Creates a new call builder for the [`removeOwner`] function.
-        pub fn removeOwner(
-            &self,
-            prevOwner: alloy_sol_types::private::Address,
-            owner: alloy_sol_types::private::Address,
-            _threshold: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeOwnerCall, N> {
-            self.call_builder(&removeOwnerCall {
-                prevOwner,
-                owner,
-                _threshold,
-            })
-        }
-
-        ///Creates a new call builder for the [`requiredTxGas`] function.
-        pub fn requiredTxGas(
-            &self,
-            to: alloy_sol_types::private::Address,
-            value: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-            operation: <Enum::Operation as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, requiredTxGasCall, N> {
-            self.call_builder(&requiredTxGasCall {
-                to,
-                value,
-                data,
-                operation,
-            })
-        }
-
-        ///Creates a new call builder for the [`setFallbackHandler`] function.
-        pub fn setFallbackHandler(
-            &self,
-            handler: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setFallbackHandlerCall, N> {
-            self.call_builder(&setFallbackHandlerCall { handler })
-        }
-
-        ///Creates a new call builder for the [`setGuard`] function.
-        pub fn setGuard(
-            &self,
-            guard: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setGuardCall, N> {
-            self.call_builder(&setGuardCall { guard })
-        }
-
         ///Creates a new call builder for the [`setup`] function.
         pub fn setup(
             &self,
@@ -10223,40 +4194,6 @@ pub mod GnosisSafe {
                 paymentReceiver,
             })
         }
-
-        ///Creates a new call builder for the [`signedMessages`] function.
-        pub fn signedMessages(
-            &self,
-            _0: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, signedMessagesCall, N> {
-            self.call_builder(&signedMessagesCall(_0))
-        }
-
-        ///Creates a new call builder for the [`simulateAndRevert`] function.
-        pub fn simulateAndRevert(
-            &self,
-            targetContract: alloy_sol_types::private::Address,
-            calldataPayload: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, simulateAndRevertCall, N> {
-            self.call_builder(&simulateAndRevertCall {
-                targetContract,
-                calldataPayload,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapOwner`] function.
-        pub fn swapOwner(
-            &self,
-            prevOwner: alloy_sol_types::private::Address,
-            oldOwner: alloy_sol_types::private::Address,
-            newOwner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, swapOwnerCall, N> {
-            self.call_builder(&swapOwnerCall {
-                prevOwner,
-                oldOwner,
-                newOwner,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs b/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs
index 26b06b3e20..ed62c79403 100644
--- a/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs
+++ b/contracts/generated/contracts-generated/gnosissafecompatibilityfallbackhandler/src/lib.rs
@@ -13,17 +13,9 @@ Generated by the following Solidity interface...
 interface GnosisSafeCompatibilityFallbackHandler {
     function NAME() external view returns (string memory);
     function VERSION() external view returns (string memory);
-    function getMessageHash(bytes memory message) external view returns (bytes32);
-    function getMessageHashForSafe(address safe, bytes memory message) external view returns (bytes32);
-    function getModules() external view returns (address[] memory);
     function isValidSignature(bytes32 _dataHash, bytes memory _signature) external view returns (bytes4);
     function isValidSignature(bytes memory _data, bytes memory _signature) external view returns (bytes4);
-    function onERC1155BatchReceived(address, address, uint256[] memory, uint256[] memory, bytes memory) external pure returns (bytes4);
-    function onERC1155Received(address, address, uint256, uint256, bytes memory) external pure returns (bytes4);
-    function onERC721Received(address, address, uint256, bytes memory) external pure returns (bytes4);
     function simulate(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    function supportsInterface(bytes4 interfaceId) external view returns (bool);
-    function tokensReceived(address, address, address, uint256, bytes memory, bytes memory) external pure;
 }
 ```
 
@@ -56,62 +48,6 @@ interface GnosisSafeCompatibilityFallbackHandler {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getMessageHash",
-    "inputs": [
-      {
-        "name": "message",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getMessageHashForSafe",
-    "inputs": [
-      {
-        "name": "safe",
-        "type": "address",
-        "internalType": "contract GnosisSafe"
-      },
-      {
-        "name": "message",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getModules",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "isValidSignature",
@@ -160,118 +96,6 @@ interface GnosisSafeCompatibilityFallbackHandler {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "onERC1155BatchReceived",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "onERC1155Received",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "onERC721Received",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "stateMutability": "pure"
-  },
   {
     "type": "function",
     "name": "simulate",
@@ -295,63 +119,6 @@ interface GnosisSafeCompatibilityFallbackHandler {
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "supportsInterface",
-    "inputs": [
-      {
-        "name": "interfaceId",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "tokensReceived",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "pure"
   }
 ]
 ```*/
@@ -645,24 +412,26 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getMessageHash(bytes)` and selector `0x0a1028c4`.
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
     ```solidity
-    function getMessageHash(bytes memory message) external view returns (bytes32);
+    function isValidSignature(bytes32 _dataHash, bytes memory _signature) external view returns (bytes4);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getMessageHashCall {
+    pub struct isValidSignature_0Call {
+        #[allow(missing_docs)]
+        pub _dataHash: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub message: alloy_sol_types::private::Bytes,
+        pub _signature: alloy_sol_types::private::Bytes,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getMessageHash(bytes)`](getMessageHashCall) function.
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignature_0Call) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getMessageHashReturn {
+    pub struct isValidSignature_0Return {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
     }
     #[allow(
         non_camel_case_types,
@@ -675,9 +444,15 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -689,25 +464,28 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getMessageHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getMessageHashCall) -> Self {
-                    (value.message,)
+            impl ::core::convert::From<isValidSignature_0Call> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_0Call) -> Self {
+                    (value._dataHash, value._signature)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_0Call {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { message: tuple.0 }
+                    Self {
+                        _dataHash: tuple.0,
+                        _signature: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -719,29 +497,32 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getMessageHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getMessageHashReturn) -> Self {
+            impl ::core::convert::From<isValidSignature_0Return> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_0Return) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_0Return {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getMessageHashCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for isValidSignature_0Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [10u8, 16u8, 40u8, 196u8];
-            const SIGNATURE: &'static str = "getMessageHash(bytes)";
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -753,8 +534,11 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._dataHash),
                     <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.message,
+                        &self._signature,
                     ),
                 )
             }
@@ -763,7 +547,7 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
                 (
                     <alloy_sol_types::sol_data::FixedBytes<
-                        32,
+                        4,
                     > as alloy_sol_types::SolType>::tokenize(ret),
                 )
             }
@@ -772,7 +556,7 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: getMessageHashReturn = r.into();
+                        let r: isValidSignature_0Return = r.into();
                         r._0
                     },
                 )
@@ -784,34 +568,33 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     data,
                 )
                 .map(|r| {
-                    let r: getMessageHashReturn = r.into();
+                    let r: isValidSignature_0Return = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getMessageHashForSafe(address,bytes)` and selector `0x6ac24784`.
+    /**Function with signature `isValidSignature(bytes,bytes)` and selector `0x20c13b0b`.
     ```solidity
-    function getMessageHashForSafe(address safe, bytes memory message) external view returns (bytes32);
+    function isValidSignature(bytes memory _data, bytes memory _signature) external view returns (bytes4);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getMessageHashForSafeCall {
+    pub struct isValidSignature_1Call {
         #[allow(missing_docs)]
-        pub safe: alloy_sol_types::private::Address,
+        pub _data: alloy_sol_types::private::Bytes,
         #[allow(missing_docs)]
-        pub message: alloy_sol_types::private::Bytes,
+        pub _signature: alloy_sol_types::private::Bytes,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getMessageHashForSafe(address,bytes)`](getMessageHashForSafeCall)
-    /// function.
+    /// [`isValidSignature(bytes,bytes)`](isValidSignature_1Call) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getMessageHashForSafeReturn {
+    pub struct isValidSignature_1Return {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
     }
     #[allow(
         non_camel_case_types,
@@ -825,12 +608,12 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
                 alloy_sol_types::sol_data::Bytes,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
                 alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
@@ -844,1335 +627,22 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getMessageHashForSafeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getMessageHashForSafeCall) -> Self {
-                    (value.safe, value.message)
+            impl ::core::convert::From<isValidSignature_1Call> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_1Call) -> Self {
+                    (value._data, value._signature)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashForSafeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        safe: tuple.0,
-                        message: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMessageHashForSafeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getMessageHashForSafeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMessageHashForSafeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getMessageHashForSafeCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [106u8, 194u8, 71u8, 132u8];
-            const SIGNATURE: &'static str = "getMessageHashForSafe(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.safe,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.message,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getMessageHashForSafeReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getMessageHashForSafeReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getModules()` and selector `0xb2494df3`.
-    ```solidity
-    function getModules() external view returns (address[] memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getModulesCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getModules()`](getModulesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getModulesReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getModulesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getModulesCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getModulesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getModulesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getModulesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getModulesCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Address>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [178u8, 73u8, 77u8, 243u8];
-            const SIGNATURE: &'static str = "getModules()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Address,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getModulesReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getModulesReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
-    ```solidity
-    function isValidSignature(bytes32 _dataHash, bytes memory _signature) external view returns (bytes4);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignature_0Call {
-        #[allow(missing_docs)]
-        pub _dataHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub _signature: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isValidSignature(bytes32,bytes)`](isValidSignature_0Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignature_0Return {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignature_0Call> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignature_0Call) -> Self {
-                    (value._dataHash, value._signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_0Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _dataHash: tuple.0,
-                        _signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignature_0Return> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignature_0Return) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_0Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isValidSignature_0Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
-            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self._dataHash),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isValidSignature_0Return = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isValidSignature_0Return = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isValidSignature(bytes,bytes)` and selector `0x20c13b0b`.
-    ```solidity
-    function isValidSignature(bytes memory _data, bytes memory _signature) external view returns (bytes4);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignature_1Call {
-        #[allow(missing_docs)]
-        pub _data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub _signature: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isValidSignature(bytes,bytes)`](isValidSignature_1Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignature_1Return {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignature_1Call> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignature_1Call) -> Self {
-                    (value._data, value._signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_1Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _data: tuple.0,
-                        _signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignature_1Return> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignature_1Return) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_1Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isValidSignature_1Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [32u8, 193u8, 59u8, 11u8];
-            const SIGNATURE: &'static str = "isValidSignature(bytes,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._data,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isValidSignature_1Return = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isValidSignature_1Return = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)` and selector `0xbc197c81`.
-    ```solidity
-    function onERC1155BatchReceived(address, address, uint256[] memory, uint256[] memory, bytes memory) external pure returns (bytes4);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC1155BatchReceivedCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub _3: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub _4: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onERC1155BatchReceived(address,address,uint256[],uint256[],
-    /// bytes)`](onERC1155BatchReceivedCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC1155BatchReceivedReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC1155BatchReceivedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC1155BatchReceivedCall) -> Self {
-                    (value._0, value._1, value._2, value._3, value._4)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155BatchReceivedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                        _2: tuple.2,
-                        _3: tuple.3,
-                        _4: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC1155BatchReceivedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC1155BatchReceivedReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155BatchReceivedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onERC1155BatchReceivedCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [188u8, 25u8, 124u8, 129u8];
-            const SIGNATURE: &'static str =
-                "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._2),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self._3),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._4,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: onERC1155BatchReceivedReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: onERC1155BatchReceivedReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onERC1155Received(address,address,uint256,uint256,bytes)` and selector `0xf23a6e61`.
-    ```solidity
-    function onERC1155Received(address, address, uint256, uint256, bytes memory) external pure returns (bytes4);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC1155ReceivedCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _3: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _4: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onERC1155Received(address,address,uint256,uint256,
-    /// bytes)`](onERC1155ReceivedCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC1155ReceivedReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC1155ReceivedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC1155ReceivedCall) -> Self {
-                    (value._0, value._1, value._2, value._3, value._4)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                        _2: tuple.2,
-                        _3: tuple.3,
-                        _4: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC1155ReceivedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC1155ReceivedReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
-            const SIGNATURE: &'static str =
-                "onERC1155Received(address,address,uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._2,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._3,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._4,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: onERC1155ReceivedReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: onERC1155ReceivedReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onERC721Received(address,address,uint256,bytes)` and selector `0x150b7a02`.
-    ```solidity
-    function onERC721Received(address, address, uint256, bytes memory) external pure returns (bytes4);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC721ReceivedCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _3: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onERC721Received(address,address,uint256,
-    /// bytes)`](onERC721ReceivedCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC721ReceivedReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC721ReceivedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC721ReceivedCall) -> Self {
-                    (value._0, value._1, value._2, value._3)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                        _2: tuple.2,
-                        _3: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC721ReceivedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC721ReceivedReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onERC721ReceivedCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
-            const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._2,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._3,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: onERC721ReceivedReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: onERC721ReceivedReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulate(address,bytes)` and selector `0xbd61951d`.
-    ```solidity
-    function simulate(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`simulate(address,bytes)`](simulateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateReturn {
-        #[allow(missing_docs)]
-        pub response: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_1Call {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
+                        _data: tuple.0,
+                        _signature: tuple.1,
                     }
                 }
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateReturn) -> Self {
-                    (value.response,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { response: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [189u8, 97u8, 149u8, 29u8];
-            const SIGNATURE: &'static str = "simulate(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: simulateReturn = r.into();
-                        r.response
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: simulateReturn = r.into();
-                    r.response
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `supportsInterface(bytes4)` and selector `0x01ffc9a7`.
-    ```solidity
-    function supportsInterface(bytes4 interfaceId) external view returns (bool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct supportsInterfaceCall {
-        #[allow(missing_docs)]
-        pub interfaceId: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`supportsInterface(bytes4)`](supportsInterfaceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct supportsInterfaceReturn {
-        #[allow(missing_docs)]
-        pub _0: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
@@ -2190,61 +660,32 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<supportsInterfaceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: supportsInterfaceCall) -> Self {
-                    (value.interfaceId,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsInterfaceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        interfaceId: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<supportsInterfaceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: supportsInterfaceReturn) -> Self {
+            impl ::core::convert::From<isValidSignature_1Return> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignature_1Return) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportsInterfaceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignature_1Return {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for supportsInterfaceCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = bool;
+        impl alloy_sol_types::SolCall for isValidSignature_1Call {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::FixedBytes<4>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
-            const SIGNATURE: &'static str = "supportsInterface(bytes4)";
+            const SELECTOR: [u8; 4] = [32u8, 193u8, 59u8, 11u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -2256,22 +697,29 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._data,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._signature,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: supportsInterfaceReturn = r.into();
+                        let r: isValidSignature_1Return = r.into();
                         r._0
                     },
                 )
@@ -2283,39 +731,34 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     data,
                 )
                 .map(|r| {
-                    let r: supportsInterfaceReturn = r.into();
+                    let r: isValidSignature_1Return = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `tokensReceived(address,address,address,uint256,bytes,bytes)` and selector `0x0023de29`.
+    /**Function with signature `simulate(address,bytes)` and selector `0xbd61951d`.
     ```solidity
-    function tokensReceived(address, address, address, uint256, bytes memory, bytes memory) external pure;
+    function simulate(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tokensReceivedCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _3: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct simulateCall {
         #[allow(missing_docs)]
-        pub _4: alloy_sol_types::private::Bytes,
+        pub targetContract: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _5: alloy_sol_types::private::Bytes,
+        pub calldataPayload: alloy_sol_types::private::Bytes,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`tokensReceived(address,address,address,uint256,bytes,
-    /// bytes)`](tokensReceivedCall) function.
+    /// [`simulate(address,bytes)`](simulateCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tokensReceivedReturn {}
+    pub struct simulateReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2329,19 +772,11 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
                 alloy_sol_types::sol_data::Bytes,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
                 alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
@@ -2355,22 +790,18 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tokensReceivedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: tokensReceivedCall) -> Self {
-                    (value._0, value._1, value._2, value._3, value._4, value._5)
+            impl ::core::convert::From<simulateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokensReceivedCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                        _2: tuple.2,
-                        _3: tuple.3,
-                        _4: tuple.4,
-                        _5: tuple.5,
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
                     }
                 }
             }
@@ -2378,9 +809,9 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2392,44 +823,32 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tokensReceivedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: tokensReceivedReturn) -> Self {
-                    ()
+            impl ::core::convert::From<simulateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateReturn) -> Self {
+                    (value.response,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tokensReceivedReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { response: tuple.0 }
                 }
             }
         }
-        impl tokensReceivedReturn {
-            fn _tokenize(
-                &self,
-            ) -> <tokensReceivedCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for tokensReceivedCall {
+        impl alloy_sol_types::SolCall for simulateCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
                 alloy_sol_types::sol_data::Bytes,
             );
-            type Return = tokensReceivedReturn;
+            type Return = alloy_sol_types::private::Bytes;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [0u8, 35u8, 222u8, 41u8];
-            const SIGNATURE: &'static str =
-                "tokensReceived(address,address,address,uint256,bytes,bytes)";
+            const SELECTOR: [u8; 4] = [189u8, 97u8, 149u8, 29u8];
+            const SIGNATURE: &'static str = "simulate(address,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -2442,35 +861,27 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._2,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._3,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._4,
+                        &self.targetContract,
                     ),
                     <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._5,
+                        &self.calldataPayload,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                tokensReceivedReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateReturn = r.into();
+                        r.response
+                    },
+                )
             }
 
             #[inline]
@@ -2478,7 +889,10 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: simulateReturn = r.into();
+                    r.response
+                })
             }
         }
     };
@@ -2491,27 +905,11 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
         #[allow(missing_docs)]
         VERSION(VERSIONCall),
         #[allow(missing_docs)]
-        getMessageHash(getMessageHashCall),
-        #[allow(missing_docs)]
-        getMessageHashForSafe(getMessageHashForSafeCall),
-        #[allow(missing_docs)]
-        getModules(getModulesCall),
-        #[allow(missing_docs)]
         isValidSignature_0(isValidSignature_0Call),
         #[allow(missing_docs)]
         isValidSignature_1(isValidSignature_1Call),
         #[allow(missing_docs)]
-        onERC1155BatchReceived(onERC1155BatchReceivedCall),
-        #[allow(missing_docs)]
-        onERC1155Received(onERC1155ReceivedCall),
-        #[allow(missing_docs)]
-        onERC721Received(onERC721ReceivedCall),
-        #[allow(missing_docs)]
         simulate(simulateCall),
-        #[allow(missing_docs)]
-        supportsInterface(supportsInterfaceCall),
-        #[allow(missing_docs)]
-        tokensReceived(tokensReceivedCall),
     }
     impl GnosisSafeCompatibilityFallbackHandlerCalls {
         /// All the selectors of this enum.
@@ -2522,50 +920,26 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [0u8, 35u8, 222u8, 41u8],
-            [1u8, 255u8, 201u8, 167u8],
-            [10u8, 16u8, 40u8, 196u8],
-            [21u8, 11u8, 122u8, 2u8],
             [22u8, 38u8, 186u8, 126u8],
             [32u8, 193u8, 59u8, 11u8],
-            [106u8, 194u8, 71u8, 132u8],
             [163u8, 244u8, 223u8, 126u8],
-            [178u8, 73u8, 77u8, 243u8],
-            [188u8, 25u8, 124u8, 129u8],
             [189u8, 97u8, 149u8, 29u8],
-            [242u8, 58u8, 110u8, 97u8],
             [255u8, 161u8, 173u8, 116u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <tokensReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <supportsInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getMessageHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onERC721ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
             <isValidSignature_0Call as alloy_sol_types::SolCall>::SIGNATURE,
             <isValidSignature_1Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <getMessageHashForSafeCall as alloy_sol_types::SolCall>::SIGNATURE,
             <NAMECall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getModulesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
             <simulateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
             <VERSIONCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(tokensReceived),
-            ::core::stringify!(supportsInterface),
-            ::core::stringify!(getMessageHash),
-            ::core::stringify!(onERC721Received),
             ::core::stringify!(isValidSignature_0),
             ::core::stringify!(isValidSignature_1),
-            ::core::stringify!(getMessageHashForSafe),
             ::core::stringify!(NAME),
-            ::core::stringify!(getModules),
-            ::core::stringify!(onERC1155BatchReceived),
             ::core::stringify!(simulate),
-            ::core::stringify!(onERC1155Received),
             ::core::stringify!(VERSION),
         ];
 
@@ -2591,7 +965,7 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for GnosisSafeCompatibilityFallbackHandlerCalls {
-        const COUNT: usize = 13usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "GnosisSafeCompatibilityFallbackHandlerCalls";
 
@@ -2600,35 +974,13 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             match self {
                 Self::NAME(_) => <NAMECall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::VERSION(_) => <VERSIONCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getMessageHash(_) => {
-                    <getMessageHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getMessageHashForSafe(_) => {
-                    <getMessageHashForSafeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getModules(_) => <getModulesCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::isValidSignature_0(_) => {
                     <isValidSignature_0Call as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::isValidSignature_1(_) => {
                     <isValidSignature_1Call as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::onERC1155BatchReceived(_) => {
-                    <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::onERC1155Received(_) => {
-                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::onERC721Received(_) => {
-                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::simulate(_) => <simulateCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::supportsInterface(_) => {
-                    <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::tokensReceived(_) => {
-                    <tokensReceivedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -2650,46 +1002,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             ) -> alloy_sol_types::Result<
                 GnosisSafeCompatibilityFallbackHandlerCalls,
             >] = &[
-                {
-                    fn tokensReceived(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <tokensReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::tokensReceived)
-                    }
-                    tokensReceived
-                },
-                {
-                    fn supportsInterface(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::supportsInterface)
-                    }
-                    supportsInterface
-                },
-                {
-                    fn getMessageHash(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <getMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHash)
-                    }
-                    getMessageHash
-                },
-                {
-                    fn onERC721Received(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC721Received)
-                    }
-                    onERC721Received
-                },
                 {
                     fn isValidSignature_0(
                         data: &[u8],
@@ -2710,18 +1022,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     }
                     isValidSignature_1
                 },
-                {
-                    fn getMessageHashForSafe(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHashForSafe)
-                    }
-                    getMessageHashForSafe
-                },
                 {
                     fn NAME(
                         data: &[u8],
@@ -2732,28 +1032,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     }
                     NAME
                 },
-                {
-                    fn getModules(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <getModulesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::getModules)
-                    }
-                    getModules
-                },
-                {
-                    fn onERC1155BatchReceived(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155BatchReceived)
-                    }
-                    onERC1155BatchReceived
-                },
                 {
                     fn simulate(
                         data: &[u8],
@@ -2764,16 +1042,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     }
                     simulate
                 },
-                {
-                    fn onERC1155Received(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155Received)
-                    }
-                    onERC1155Received
-                },
                 {
                     fn VERSION(
                         data: &[u8],
@@ -2805,56 +1073,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             ) -> alloy_sol_types::Result<
                 GnosisSafeCompatibilityFallbackHandlerCalls,
             >] = &[
-                {
-                    fn tokensReceived(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <tokensReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::tokensReceived)
-                    }
-                    tokensReceived
-                },
-                {
-                    fn supportsInterface(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                GnosisSafeCompatibilityFallbackHandlerCalls::supportsInterface,
-                            )
-                    }
-                    supportsInterface
-                },
-                {
-                    fn getMessageHash(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <getMessageHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHash)
-                    }
-                    getMessageHash
-                },
-                {
-                    fn onERC721Received(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeCompatibilityFallbackHandlerCalls::onERC721Received)
-                    }
-                    onERC721Received
-                },
                 {
                     fn isValidSignature_0(
                         data: &[u8],
@@ -2883,20 +1101,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     }
                     isValidSignature_1
                 },
-                {
-                    fn getMessageHashForSafe(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                GnosisSafeCompatibilityFallbackHandlerCalls::getMessageHashForSafe,
-                            )
-                    }
-                    getMessageHashForSafe
-                },
                 {
                     fn NAME(
                         data: &[u8],
@@ -2907,30 +1111,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     }
                     NAME
                 },
-                {
-                    fn getModules(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <getModulesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeCompatibilityFallbackHandlerCalls::getModules)
-                    }
-                    getModules
-                },
-                {
-                    fn onERC1155BatchReceived(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155BatchReceived,
-                            )
-                    }
-                    onERC1155BatchReceived
-                },
                 {
                     fn simulate(
                         data: &[u8],
@@ -2941,20 +1121,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                     }
                     simulate
                 },
-                {
-                    fn onERC1155Received(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeCompatibilityFallbackHandlerCalls>
-                    {
-                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                GnosisSafeCompatibilityFallbackHandlerCalls::onERC1155Received,
-                            )
-                    }
-                    onERC1155Received
-                },
                 {
                     fn VERSION(
                         data: &[u8],
@@ -2984,41 +1150,15 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                 Self::VERSION(inner) => {
                     <VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getMessageHash(inner) => {
-                    <getMessageHashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getMessageHashForSafe(inner) => {
-                    <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getModules(inner) => {
-                    <getModulesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::isValidSignature_0(inner) => {
                     <isValidSignature_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::isValidSignature_1(inner) => {
                     <isValidSignature_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::onERC1155BatchReceived(inner) => {
-                    <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::onERC1155Received(inner) => {
-                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::onERC721Received(inner) => {
-                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::simulate(inner) => {
                     <simulateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::supportsInterface(inner) => {
-                    <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::tokensReceived(inner) => {
-                    <tokensReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -3031,43 +1171,15 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                 Self::VERSION(inner) => {
                     <VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getMessageHash(inner) => {
-                    <getMessageHashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::getMessageHashForSafe(inner) => {
-                    <getMessageHashForSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getModules(inner) => {
-                    <getModulesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::isValidSignature_0(inner) => {
                     <isValidSignature_0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::isValidSignature_1(inner) => {
                     <isValidSignature_1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::onERC1155BatchReceived(inner) => {
-                    <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::onERC1155Received(inner) => {
-                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::onERC721Received(inner) => {
-                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::simulate(inner) => {
                     <simulateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::supportsInterface(inner) => {
-                    <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::tokensReceived(inner) => {
-                    <tokensReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -3247,29 +1359,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             self.call_builder(&VERSIONCall)
         }
 
-        ///Creates a new call builder for the [`getMessageHash`] function.
-        pub fn getMessageHash(
-            &self,
-            message: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, getMessageHashCall, N> {
-            self.call_builder(&getMessageHashCall { message })
-        }
-
-        ///Creates a new call builder for the [`getMessageHashForSafe`]
-        /// function.
-        pub fn getMessageHashForSafe(
-            &self,
-            safe: alloy_sol_types::private::Address,
-            message: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, getMessageHashForSafeCall, N> {
-            self.call_builder(&getMessageHashForSafeCall { safe, message })
-        }
-
-        ///Creates a new call builder for the [`getModules`] function.
-        pub fn getModules(&self) -> alloy_contract::SolCallBuilder<&P, getModulesCall, N> {
-            self.call_builder(&getModulesCall)
-        }
-
         ///Creates a new call builder for the [`isValidSignature_0`] function.
         pub fn isValidSignature_0(
             &self,
@@ -3291,42 +1380,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
             self.call_builder(&isValidSignature_1Call { _data, _signature })
         }
 
-        ///Creates a new call builder for the [`onERC1155BatchReceived`]
-        /// function.
-        pub fn onERC1155BatchReceived(
-            &self,
-            _0: alloy_sol_types::private::Address,
-            _1: alloy_sol_types::private::Address,
-            _2: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            _3: alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            _4: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onERC1155BatchReceivedCall, N> {
-            self.call_builder(&onERC1155BatchReceivedCall { _0, _1, _2, _3, _4 })
-        }
-
-        ///Creates a new call builder for the [`onERC1155Received`] function.
-        pub fn onERC1155Received(
-            &self,
-            _0: alloy_sol_types::private::Address,
-            _1: alloy_sol_types::private::Address,
-            _2: alloy_sol_types::private::primitives::aliases::U256,
-            _3: alloy_sol_types::private::primitives::aliases::U256,
-            _4: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
-            self.call_builder(&onERC1155ReceivedCall { _0, _1, _2, _3, _4 })
-        }
-
-        ///Creates a new call builder for the [`onERC721Received`] function.
-        pub fn onERC721Received(
-            &self,
-            _0: alloy_sol_types::private::Address,
-            _1: alloy_sol_types::private::Address,
-            _2: alloy_sol_types::private::primitives::aliases::U256,
-            _3: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
-            self.call_builder(&onERC721ReceivedCall { _0, _1, _2, _3 })
-        }
-
         ///Creates a new call builder for the [`simulate`] function.
         pub fn simulate(
             &self,
@@ -3338,34 +1391,6 @@ pub mod GnosisSafeCompatibilityFallbackHandler {
                 calldataPayload,
             })
         }
-
-        ///Creates a new call builder for the [`supportsInterface`] function.
-        pub fn supportsInterface(
-            &self,
-            interfaceId: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
-            self.call_builder(&supportsInterfaceCall { interfaceId })
-        }
-
-        ///Creates a new call builder for the [`tokensReceived`] function.
-        pub fn tokensReceived(
-            &self,
-            _0: alloy_sol_types::private::Address,
-            _1: alloy_sol_types::private::Address,
-            _2: alloy_sol_types::private::Address,
-            _3: alloy_sol_types::private::primitives::aliases::U256,
-            _4: alloy_sol_types::private::Bytes,
-            _5: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, tokensReceivedCall, N> {
-            self.call_builder(&tokensReceivedCall {
-                _0,
-                _1,
-                _2,
-                _3,
-                _4,
-                _5,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs b/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs
index a77305e207..8a43d2404b 100644
--- a/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs
+++ b/contracts/generated/contracts-generated/gnosissafeproxyfactory/src/lib.rs
@@ -13,47 +13,13 @@ Generated by the following Solidity interface...
 interface GnosisSafeProxyFactory {
     event ProxyCreation(address proxy, address singleton);
 
-    function calculateCreateProxyWithNonceAddress(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
     function createProxy(address singleton, bytes memory data) external returns (address proxy);
-    function createProxyWithCallback(address _singleton, bytes memory initializer, uint256 saltNonce, address callback) external returns (address proxy);
-    function createProxyWithNonce(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
-    function proxyCreationCode() external pure returns (bytes memory);
-    function proxyRuntimeCode() external pure returns (bytes memory);
 }
 ```
 
 ...which was generated by the following JSON ABI:
 ```json
 [
-  {
-    "type": "function",
-    "name": "calculateCreateProxyWithNonceAddress",
-    "inputs": [
-      {
-        "name": "_singleton",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "initializer",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "saltNonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "proxy",
-        "type": "address",
-        "internalType": "contract GnosisSafeProxy"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "createProxy",
@@ -78,95 +44,6 @@ interface GnosisSafeProxyFactory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "createProxyWithCallback",
-    "inputs": [
-      {
-        "name": "_singleton",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "initializer",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "saltNonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "callback",
-        "type": "address",
-        "internalType": "contract IProxyCreationCallback"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "proxy",
-        "type": "address",
-        "internalType": "contract GnosisSafeProxy"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "createProxyWithNonce",
-    "inputs": [
-      {
-        "name": "_singleton",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "initializer",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "saltNonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "proxy",
-        "type": "address",
-        "internalType": "contract GnosisSafeProxy"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "proxyCreationCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "proxyRuntimeCode",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "pure"
-  },
   {
     "type": "event",
     "name": "ProxyCreation",
@@ -212,816 +89,18 @@ pub mod GnosisSafeProxyFactory {
     ```solidity
     event ProxyCreation(address proxy, address singleton);
     ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ProxyCreation {
-        #[allow(missing_docs)]
-        pub proxy: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub singleton: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ProxyCreation {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ProxyCreation(address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    79u8, 81u8, 250u8, 246u8, 196u8, 86u8, 31u8, 249u8, 95u8, 6u8, 118u8, 87u8,
-                    228u8, 52u8, 57u8, 240u8, 248u8, 86u8, 217u8, 124u8, 4u8, 217u8, 236u8, 144u8,
-                    112u8, 166u8, 25u8, 154u8, 212u8, 24u8, 226u8, 53u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    proxy: data.0,
-                    singleton: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.proxy,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.singleton,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ProxyCreation {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ProxyCreation> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ProxyCreation) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `calculateCreateProxyWithNonceAddress(address,bytes,uint256)` and selector `0x2500510e`.
-    ```solidity
-    function calculateCreateProxyWithNonceAddress(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct calculateCreateProxyWithNonceAddressCall {
-        #[allow(missing_docs)]
-        pub _singleton: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub initializer: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub saltNonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`calculateCreateProxyWithNonceAddress(address,bytes,
-    /// uint256)`](calculateCreateProxyWithNonceAddressCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct calculateCreateProxyWithNonceAddressReturn {
-        #[allow(missing_docs)]
-        pub proxy: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<calculateCreateProxyWithNonceAddressCall> for UnderlyingRustTuple<'_> {
-                fn from(value: calculateCreateProxyWithNonceAddressCall) -> Self {
-                    (value._singleton, value.initializer, value.saltNonce)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for calculateCreateProxyWithNonceAddressCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _singleton: tuple.0,
-                        initializer: tuple.1,
-                        saltNonce: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<calculateCreateProxyWithNonceAddressReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: calculateCreateProxyWithNonceAddressReturn) -> Self {
-                    (value.proxy,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for calculateCreateProxyWithNonceAddressReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { proxy: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for calculateCreateProxyWithNonceAddressCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [37u8, 0u8, 81u8, 14u8];
-            const SIGNATURE: &'static str =
-                "calculateCreateProxyWithNonceAddress(address,bytes,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._singleton,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.initializer,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.saltNonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: calculateCreateProxyWithNonceAddressReturn = r.into();
-                        r.proxy
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: calculateCreateProxyWithNonceAddressReturn = r.into();
-                    r.proxy
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `createProxy(address,bytes)` and selector `0x61b69abd`.
-    ```solidity
-    function createProxy(address singleton, bytes memory data) external returns (address proxy);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createProxyCall {
-        #[allow(missing_docs)]
-        pub singleton: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`createProxy(address,bytes)`](createProxyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createProxyReturn {
-        #[allow(missing_docs)]
-        pub proxy: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createProxyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createProxyCall) -> Self {
-                    (value.singleton, value.data)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        singleton: tuple.0,
-                        data: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createProxyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createProxyReturn) -> Self {
-                    (value.proxy,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { proxy: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createProxyCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [97u8, 182u8, 154u8, 189u8];
-            const SIGNATURE: &'static str = "createProxy(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.singleton,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createProxyReturn = r.into();
-                        r.proxy
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createProxyReturn = r.into();
-                    r.proxy
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `createProxyWithCallback(address,bytes,uint256,address)` and selector `0xd18af54d`.
-    ```solidity
-    function createProxyWithCallback(address _singleton, bytes memory initializer, uint256 saltNonce, address callback) external returns (address proxy);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createProxyWithCallbackCall {
-        #[allow(missing_docs)]
-        pub _singleton: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub initializer: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub saltNonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub callback: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`createProxyWithCallback(address,bytes,uint256,
-    /// address)`](createProxyWithCallbackCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createProxyWithCallbackReturn {
-        #[allow(missing_docs)]
-        pub proxy: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createProxyWithCallbackCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createProxyWithCallbackCall) -> Self {
-                    (
-                        value._singleton,
-                        value.initializer,
-                        value.saltNonce,
-                        value.callback,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithCallbackCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _singleton: tuple.0,
-                        initializer: tuple.1,
-                        saltNonce: tuple.2,
-                        callback: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createProxyWithCallbackReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createProxyWithCallbackReturn) -> Self {
-                    (value.proxy,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithCallbackReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { proxy: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createProxyWithCallbackCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [209u8, 138u8, 245u8, 77u8];
-            const SIGNATURE: &'static str =
-                "createProxyWithCallback(address,bytes,uint256,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._singleton,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.initializer,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.saltNonce,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.callback,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createProxyWithCallbackReturn = r.into();
-                        r.proxy
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createProxyWithCallbackReturn = r.into();
-                    r.proxy
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `createProxyWithNonce(address,bytes,uint256)` and selector `0x1688f0b9`.
-    ```solidity
-    function createProxyWithNonce(address _singleton, bytes memory initializer, uint256 saltNonce) external returns (address proxy);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createProxyWithNonceCall {
-        #[allow(missing_docs)]
-        pub _singleton: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub initializer: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub saltNonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`createProxyWithNonce(address,bytes,
-    /// uint256)`](createProxyWithNonceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createProxyWithNonceReturn {
-        #[allow(missing_docs)]
-        pub proxy: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createProxyWithNonceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createProxyWithNonceCall) -> Self {
-                    (value._singleton, value.initializer, value.saltNonce)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithNonceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _singleton: tuple.0,
-                        initializer: tuple.1,
-                        saltNonce: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createProxyWithNonceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createProxyWithNonceReturn) -> Self {
-                    (value.proxy,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyWithNonceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { proxy: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createProxyWithNonceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [22u8, 136u8, 240u8, 185u8];
-            const SIGNATURE: &'static str = "createProxyWithNonce(address,bytes,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._singleton,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.initializer,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.saltNonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createProxyWithNonceReturn = r.into();
-                        r.proxy
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createProxyWithNonceReturn = r.into();
-                    r.proxy
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `proxyCreationCode()` and selector `0x53e5d935`.
-    ```solidity
-    function proxyCreationCode() external pure returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct proxyCreationCodeCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`proxyCreationCode()`](proxyCreationCodeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct proxyCreationCodeReturn {
+    pub struct ProxyCreation {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
+        pub proxy: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub singleton: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -1031,132 +110,118 @@ pub mod GnosisSafeProxyFactory {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<proxyCreationCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: proxyCreationCodeCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyCreationCodeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<proxyCreationCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: proxyCreationCodeReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyCreationCodeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for proxyCreationCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for ProxyCreation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-            const SELECTOR: [u8; 4] = [83u8, 229u8, 217u8, 53u8];
-            const SIGNATURE: &'static str = "proxyCreationCode()";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ProxyCreation(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    79u8, 81u8, 250u8, 246u8, 196u8, 86u8, 31u8, 249u8, 95u8, 6u8, 118u8, 87u8,
+                    228u8, 52u8, 57u8, 240u8, 248u8, 86u8, 217u8, 124u8, 4u8, 217u8, 236u8, 144u8,
+                    112u8, 166u8, 25u8, 154u8, 212u8, 24u8, 226u8, 53u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    proxy: data.0,
+                    singleton: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.proxy,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.singleton,
+                    ),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: proxyCreationCodeReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: proxyCreationCodeReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ProxyCreation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ProxyCreation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ProxyCreation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `proxyRuntimeCode()` and selector `0xaddacc0f`.
+    /**Function with signature `createProxy(address,bytes)` and selector `0x61b69abd`.
     ```solidity
-    function proxyRuntimeCode() external pure returns (bytes memory);
+    function createProxy(address singleton, bytes memory data) external returns (address proxy);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct proxyRuntimeCodeCall;
+    pub struct createProxyCall {
+        #[allow(missing_docs)]
+        pub singleton: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`proxyRuntimeCode()`](proxyRuntimeCodeCall) function.
+    /// [`createProxy(address,bytes)`](createProxyCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct proxyRuntimeCodeReturn {
+    pub struct createProxyReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
+        pub proxy: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -1169,9 +234,15 @@ pub mod GnosisSafeProxyFactory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1183,25 +254,28 @@ pub mod GnosisSafeProxyFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<proxyRuntimeCodeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: proxyRuntimeCodeCall) -> Self {
-                    ()
+            impl ::core::convert::From<createProxyCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyCall) -> Self {
+                    (value.singleton, value.data)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyRuntimeCodeCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        singleton: tuple.0,
+                        data: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1213,29 +287,32 @@ pub mod GnosisSafeProxyFactory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<proxyRuntimeCodeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: proxyRuntimeCodeReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<createProxyReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createProxyReturn) -> Self {
+                    (value.proxy,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for proxyRuntimeCodeReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createProxyReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { proxy: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for proxyRuntimeCodeCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Bytes;
+        impl alloy_sol_types::SolCall for createProxyCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [173u8, 218u8, 204u8, 15u8];
-            const SIGNATURE: &'static str = "proxyRuntimeCode()";
+            const SELECTOR: [u8; 4] = [97u8, 182u8, 154u8, 189u8];
+            const SIGNATURE: &'static str = "createProxy(address,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -1246,20 +323,27 @@ pub mod GnosisSafeProxyFactory {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.singleton,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: proxyRuntimeCodeReturn = r.into();
-                        r._0
+                        let r: createProxyReturn = r.into();
+                        r.proxy
                     },
                 )
             }
@@ -1270,8 +354,8 @@ pub mod GnosisSafeProxyFactory {
                     data,
                 )
                 .map(|r| {
-                    let r: proxyRuntimeCodeReturn = r.into();
-                    r._0
+                    let r: createProxyReturn = r.into();
+                    r.proxy
                 })
             }
         }
@@ -1279,18 +363,8 @@ pub mod GnosisSafeProxyFactory {
     ///Container for all the [`GnosisSafeProxyFactory`](self) function calls.
     #[derive(Clone)]
     pub enum GnosisSafeProxyFactoryCalls {
-        #[allow(missing_docs)]
-        calculateCreateProxyWithNonceAddress(calculateCreateProxyWithNonceAddressCall),
         #[allow(missing_docs)]
         createProxy(createProxyCall),
-        #[allow(missing_docs)]
-        createProxyWithCallback(createProxyWithCallbackCall),
-        #[allow(missing_docs)]
-        createProxyWithNonce(createProxyWithNonceCall),
-        #[allow(missing_docs)]
-        proxyCreationCode(proxyCreationCodeCall),
-        #[allow(missing_docs)]
-        proxyRuntimeCode(proxyRuntimeCodeCall),
     }
     impl GnosisSafeProxyFactoryCalls {
         /// All the selectors of this enum.
@@ -1300,32 +374,12 @@ pub mod GnosisSafeProxyFactory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [22u8, 136u8, 240u8, 185u8],
-            [37u8, 0u8, 81u8, 14u8],
-            [83u8, 229u8, 217u8, 53u8],
-            [97u8, 182u8, 154u8, 189u8],
-            [173u8, 218u8, 204u8, 15u8],
-            [209u8, 138u8, 245u8, 77u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[97u8, 182u8, 154u8, 189u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <createProxyWithNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <proxyCreationCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createProxyCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createProxyWithCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<createProxyCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(createProxyWithNonce),
-            ::core::stringify!(calculateCreateProxyWithNonceAddress),
-            ::core::stringify!(proxyCreationCode),
-            ::core::stringify!(createProxy),
-            ::core::stringify!(proxyRuntimeCode),
-            ::core::stringify!(createProxyWithCallback),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(createProxy)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1349,29 +403,14 @@ pub mod GnosisSafeProxyFactory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for GnosisSafeProxyFactoryCalls {
-        const COUNT: usize = 6usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 96usize;
         const NAME: &'static str = "GnosisSafeProxyFactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::calculateCreateProxyWithNonceAddress(_) => {
-                    <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::createProxy(_) => <createProxyCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::createProxyWithCallback(_) => {
-                    <createProxyWithCallbackCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::createProxyWithNonce(_) => {
-                    <createProxyWithNonceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::proxyCreationCode(_) => {
-                    <proxyCreationCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::proxyRuntimeCode(_) => {
-                    <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -1391,68 +430,15 @@ pub mod GnosisSafeProxyFactory {
             static DECODE_SHIMS: &[fn(
                 &[u8],
             )
-                -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls>] = &[
-                {
-                    fn createProxyWithNonce(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeProxyFactoryCalls::createProxyWithNonce)
-                    }
-                    createProxyWithNonce
-                },
-                {
-                    fn calculateCreateProxyWithNonceAddress(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                GnosisSafeProxyFactoryCalls::calculateCreateProxyWithNonceAddress,
-                            )
-                    }
-                    calculateCreateProxyWithNonceAddress
-                },
-                {
-                    fn proxyCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeProxyFactoryCalls::proxyCreationCode)
-                    }
-                    proxyCreationCode
-                },
-                {
-                    fn createProxy(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <createProxyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeProxyFactoryCalls::createProxy)
-                    }
-                    createProxy
-                },
-                {
-                    fn proxyRuntimeCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GnosisSafeProxyFactoryCalls::proxyRuntimeCode)
-                    }
-                    proxyRuntimeCode
-                },
-                {
-                    fn createProxyWithCallback(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GnosisSafeProxyFactoryCalls::createProxyWithCallback)
-                    }
-                    createProxyWithCallback
-                },
-            ];
+                -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls>] = &[{
+                fn createProxy(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                    <createProxyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(GnosisSafeProxyFactoryCalls::createProxy)
+                }
+                createProxy
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1472,74 +458,15 @@ pub mod GnosisSafeProxyFactory {
                 &[u8],
             ) -> alloy_sol_types::Result<
                 GnosisSafeProxyFactoryCalls,
-            >] = &[
-                {
-                    fn createProxyWithNonce(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeProxyFactoryCalls::createProxyWithNonce)
-                    }
-                    createProxyWithNonce
-                },
-                {
-                    fn calculateCreateProxyWithNonceAddress(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                GnosisSafeProxyFactoryCalls::calculateCreateProxyWithNonceAddress,
-                            )
-                    }
-                    calculateCreateProxyWithNonceAddress
-                },
-                {
-                    fn proxyCreationCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeProxyFactoryCalls::proxyCreationCode)
-                    }
-                    proxyCreationCode
-                },
-                {
-                    fn createProxy(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <createProxyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GnosisSafeProxyFactoryCalls::createProxy)
-                    }
-                    createProxy
-                },
-                {
-                    fn proxyRuntimeCode(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GnosisSafeProxyFactoryCalls::proxyRuntimeCode)
-                    }
-                    proxyRuntimeCode
-                },
-                {
-                    fn createProxyWithCallback(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
-                        <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GnosisSafeProxyFactoryCalls::createProxyWithCallback)
-                    }
-                    createProxyWithCallback
-                },
-            ];
+            >] = &[{
+                fn createProxy(
+                    data: &[u8],
+                ) -> alloy_sol_types::Result<GnosisSafeProxyFactoryCalls> {
+                    <createProxyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                        .map(GnosisSafeProxyFactoryCalls::createProxy)
+                }
+                createProxy
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -1552,35 +479,8 @@ pub mod GnosisSafeProxyFactory {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::calculateCreateProxyWithNonceAddress(inner) => {
-                    <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::createProxy(inner) => {
-                    <createProxyCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::createProxyWithCallback(inner) => {
-                    <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::createProxyWithNonce(inner) => {
-                    <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::proxyCreationCode(inner) => {
-                    <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::proxyRuntimeCode(inner) => {
-                    <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <createProxyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
             }
         }
@@ -1588,41 +488,8 @@ pub mod GnosisSafeProxyFactory {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::calculateCreateProxyWithNonceAddress(inner) => {
-                    <calculateCreateProxyWithNonceAddressCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::createProxy(inner) => {
-                    <createProxyCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::createProxyWithCallback(inner) => {
-                    <createProxyWithCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::createProxyWithNonce(inner) => {
-                    <createProxyWithNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::proxyCreationCode(inner) => {
-                    <proxyCreationCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::proxyRuntimeCode(inner) => {
-                    <proxyRuntimeCodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <createProxyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
             }
         }
@@ -1878,22 +745,6 @@ pub mod GnosisSafeProxyFactory {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the
-        /// [`calculateCreateProxyWithNonceAddress`] function.
-        pub fn calculateCreateProxyWithNonceAddress(
-            &self,
-            _singleton: alloy_sol_types::private::Address,
-            initializer: alloy_sol_types::private::Bytes,
-            saltNonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, calculateCreateProxyWithNonceAddressCall, N>
-        {
-            self.call_builder(&calculateCreateProxyWithNonceAddressCall {
-                _singleton,
-                initializer,
-                saltNonce,
-            })
-        }
-
         ///Creates a new call builder for the [`createProxy`] function.
         pub fn createProxy(
             &self,
@@ -1902,52 +753,6 @@ pub mod GnosisSafeProxyFactory {
         ) -> alloy_contract::SolCallBuilder<&P, createProxyCall, N> {
             self.call_builder(&createProxyCall { singleton, data })
         }
-
-        ///Creates a new call builder for the [`createProxyWithCallback`]
-        /// function.
-        pub fn createProxyWithCallback(
-            &self,
-            _singleton: alloy_sol_types::private::Address,
-            initializer: alloy_sol_types::private::Bytes,
-            saltNonce: alloy_sol_types::private::primitives::aliases::U256,
-            callback: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, createProxyWithCallbackCall, N> {
-            self.call_builder(&createProxyWithCallbackCall {
-                _singleton,
-                initializer,
-                saltNonce,
-                callback,
-            })
-        }
-
-        ///Creates a new call builder for the [`createProxyWithNonce`]
-        /// function.
-        pub fn createProxyWithNonce(
-            &self,
-            _singleton: alloy_sol_types::private::Address,
-            initializer: alloy_sol_types::private::Bytes,
-            saltNonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, createProxyWithNonceCall, N> {
-            self.call_builder(&createProxyWithNonceCall {
-                _singleton,
-                initializer,
-                saltNonce,
-            })
-        }
-
-        ///Creates a new call builder for the [`proxyCreationCode`] function.
-        pub fn proxyCreationCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, proxyCreationCodeCall, N> {
-            self.call_builder(&proxyCreationCodeCall)
-        }
-
-        ///Creates a new call builder for the [`proxyRuntimeCode`] function.
-        pub fn proxyRuntimeCode(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, proxyRuntimeCodeCall, N> {
-            self.call_builder(&proxyRuntimeCodeCall)
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs b/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
index 4aafc4e0f0..e3bdd29ab2 100644
--- a/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
+++ b/contracts/generated/contracts-generated/gpv2allowlistauthentication/src/lib.rs
@@ -16,14 +16,11 @@ interface GPv2AllowListAuthentication {
     event SolverRemoved(address solver);
 
     function addSolver(address solver) external;
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
     function initializeManager(address manager_) external;
     function isSolver(address prospectiveSolver) external view returns (bool);
     function manager() external view returns (address);
     function removeSolver(address solver) external;
-    function setManager(address manager_) external;
     function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
 }
 ```
 
@@ -43,30 +40,6 @@ interface GPv2AllowListAuthentication {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "getStorageAt",
-    "inputs": [
-      {
-        "name": "offset",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "length",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "initializeManager",
@@ -125,19 +98,6 @@ interface GPv2AllowListAuthentication {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "setManager",
-    "inputs": [
-      {
-        "name": "manager_",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "simulateDelegatecall",
@@ -162,30 +122,6 @@ interface GPv2AllowListAuthentication {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "simulateDelegatecallInternal",
-    "inputs": [
-      {
-        "name": "targetContract",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "calldataPayload",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "response",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "event",
     "name": "ManagerChanged",
@@ -718,165 +654,6 @@ pub mod GPv2AllowListAuthentication {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
-    ```solidity
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getStorageAtCall {
-        #[allow(missing_docs)]
-        pub offset: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub length: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getStorageAtReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtCall) -> Self {
-                    (value.offset, value.length)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        offset: tuple.0,
-                        length: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getStorageAtCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
-            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.offset,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.length,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getStorageAtReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getStorageAtReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `initializeManager(address)` and selector `0x7f7120fe`.
     ```solidity
     function initializeManager(address manager_) external;
@@ -1430,21 +1207,28 @@ pub mod GPv2AllowListAuthentication {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setManager(address)` and selector `0xd0ebdbe7`.
+    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
     ```solidity
-    function setManager(address manager_) external;
+    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setManagerCall {
+    pub struct simulateDelegatecallCall {
         #[allow(missing_docs)]
-        pub manager_: alloy_sol_types::private::Address,
+        pub targetContract: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub calldataPayload: alloy_sol_types::private::Bytes,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setManager(address)`](setManagerCall) function.
+    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setManagerReturn {}
+    pub struct simulateDelegatecallReturn {
+        #[allow(missing_docs)]
+        pub response: alloy_sol_types::private::Bytes,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -1456,9 +1240,15 @@ pub mod GPv2AllowListAuthentication {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1470,25 +1260,28 @@ pub mod GPv2AllowListAuthentication {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setManagerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setManagerCall) -> Self {
-                    (value.manager_,)
+            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallCall) -> Self {
+                    (value.targetContract, value.calldataPayload)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setManagerCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { manager_: tuple.0 }
+                    Self {
+                        targetContract: tuple.0,
+                        calldataPayload: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1500,34 +1293,32 @@ pub mod GPv2AllowListAuthentication {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setManagerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setManagerReturn) -> Self {
-                    ()
+            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: simulateDelegatecallReturn) -> Self {
+                    (value.response,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setManagerReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { response: tuple.0 }
                 }
             }
         }
-        impl setManagerReturn {
-            fn _tokenize(&self) -> <setManagerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setManagerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setManagerReturn;
+        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = alloy_sol_types::private::Bytes;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [208u8, 235u8, 219u8, 231u8];
-            const SIGNATURE: &'static str = "setManager(address)";
+            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
+            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -1540,177 +1331,27 @@ pub mod GPv2AllowListAuthentication {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.manager_,
+                        &self.targetContract,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.calldataPayload,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setManagerReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulateDelegatecall(address,bytes)` and selector `0xf84436bd`.
-    ```solidity
-    function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`simulateDelegatecall(address,bytes)`](simulateDelegatecallCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallReturn {
-        #[allow(missing_docs)]
-        pub response: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallReturn) -> Self {
-                    (value.response,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { response: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateDelegatecallCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [248u8, 68u8, 54u8, 189u8];
-            const SIGNATURE: &'static str = "simulateDelegatecall(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: simulateDelegatecallReturn = r.into();
-                        r.response
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: simulateDelegatecallReturn = r.into();
+                        r.response
+                    },
+                )
             }
 
             #[inline]
@@ -1725,166 +1366,6 @@ pub mod GPv2AllowListAuthentication {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulateDelegatecallInternal(address,bytes)` and selector `0x43218e19`.
-    ```solidity
-    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallInternalCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`simulateDelegatecallInternal(address,
-    /// bytes)`](simulateDelegatecallInternalCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallInternalReturn {
-        #[allow(missing_docs)]
-        pub response: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallInternalCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallInternalCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallInternalReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallInternalReturn) -> Self {
-                    (value.response,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { response: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateDelegatecallInternalCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [67u8, 33u8, 142u8, 25u8];
-            const SIGNATURE: &'static str = "simulateDelegatecallInternal(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: simulateDelegatecallInternalReturn = r.into();
-                        r.response
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: simulateDelegatecallInternalReturn = r.into();
-                    r.response
-                })
-            }
-        }
-    };
     ///Container for all the [`GPv2AllowListAuthentication`](self) function
     /// calls.
     #[derive(Clone)]
@@ -1892,8 +1373,6 @@ pub mod GPv2AllowListAuthentication {
         #[allow(missing_docs)]
         addSolver(addSolverCall),
         #[allow(missing_docs)]
-        getStorageAt(getStorageAtCall),
-        #[allow(missing_docs)]
         initializeManager(initializeManagerCall),
         #[allow(missing_docs)]
         isSolver(isSolverCall),
@@ -1902,11 +1381,7 @@ pub mod GPv2AllowListAuthentication {
         #[allow(missing_docs)]
         removeSolver(removeSolverCall),
         #[allow(missing_docs)]
-        setManager(setManagerCall),
-        #[allow(missing_docs)]
         simulateDelegatecall(simulateDelegatecallCall),
-        #[allow(missing_docs)]
-        simulateDelegatecallInternal(simulateDelegatecallInternalCall),
     }
     impl GPv2AllowListAuthenticationCalls {
         /// All the selectors of this enum.
@@ -1918,36 +1393,27 @@ pub mod GPv2AllowListAuthentication {
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [2u8, 204u8, 37u8, 13u8],
-            [67u8, 33u8, 142u8, 25u8],
             [72u8, 28u8, 106u8, 117u8],
-            [86u8, 36u8, 178u8, 91u8],
             [127u8, 113u8, 32u8, 254u8],
             [143u8, 213u8, 123u8, 146u8],
-            [208u8, 235u8, 219u8, 231u8],
             [236u8, 88u8, 244u8, 184u8],
             [248u8, 68u8, 54u8, 189u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <isSolverCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SIGNATURE,
             <managerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
             <initializeManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <removeSolverCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addSolverCall as alloy_sol_types::SolCall>::SIGNATURE,
             <simulateDelegatecallCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(isSolver),
-            ::core::stringify!(simulateDelegatecallInternal),
             ::core::stringify!(manager),
-            ::core::stringify!(getStorageAt),
             ::core::stringify!(initializeManager),
             ::core::stringify!(removeSolver),
-            ::core::stringify!(setManager),
             ::core::stringify!(addSolver),
             ::core::stringify!(simulateDelegatecall),
         ];
@@ -1974,7 +1440,7 @@ pub mod GPv2AllowListAuthentication {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for GPv2AllowListAuthenticationCalls {
-        const COUNT: usize = 9usize;
+        const COUNT: usize = 6usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "GPv2AllowListAuthenticationCalls";
 
@@ -1982,20 +1448,15 @@ pub mod GPv2AllowListAuthentication {
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::addSolver(_) => <addSolverCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::initializeManager(_) => {
                     <initializeManagerCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::isSolver(_) => <isSolverCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::manager(_) => <managerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::removeSolver(_) => <removeSolverCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setManager(_) => <setManagerCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::simulateDelegatecall(_) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::simulateDelegatecallInternal(_) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -2027,20 +1488,6 @@ pub mod GPv2AllowListAuthentication {
                     }
                     isSolver
                 },
-                {
-                    fn simulateDelegatecallInternal(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
-                    {
-                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                GPv2AllowListAuthenticationCalls::simulateDelegatecallInternal,
-                            )
-                    }
-                    simulateDelegatecallInternal
-                },
                 {
                     fn manager(
                         data: &[u8],
@@ -2051,16 +1498,6 @@ pub mod GPv2AllowListAuthentication {
                     }
                     manager
                 },
-                {
-                    fn getStorageAt(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
-                    {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GPv2AllowListAuthenticationCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
                 {
                     fn initializeManager(
                         data: &[u8],
@@ -2081,16 +1518,6 @@ pub mod GPv2AllowListAuthentication {
                     }
                     removeSolver
                 },
-                {
-                    fn setManager(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
-                    {
-                        <setManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GPv2AllowListAuthenticationCalls::setManager)
-                    }
-                    setManager
-                },
                 {
                     fn addSolver(
                         data: &[u8],
@@ -2142,20 +1569,6 @@ pub mod GPv2AllowListAuthentication {
                     }
                     isSolver
                 },
-                {
-                    fn simulateDelegatecallInternal(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
-                    {
-                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                GPv2AllowListAuthenticationCalls::simulateDelegatecallInternal,
-                            )
-                    }
-                    simulateDelegatecallInternal
-                },
                 {
                     fn manager(
                         data: &[u8],
@@ -2166,18 +1579,6 @@ pub mod GPv2AllowListAuthentication {
                     }
                     manager
                 },
-                {
-                    fn getStorageAt(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
-                    {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GPv2AllowListAuthenticationCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
                 {
                     fn initializeManager(
                         data: &[u8],
@@ -2202,16 +1603,6 @@ pub mod GPv2AllowListAuthentication {
                     }
                     removeSolver
                 },
-                {
-                    fn setManager(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2AllowListAuthenticationCalls>
-                    {
-                        <setManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(GPv2AllowListAuthenticationCalls::setManager)
-                    }
-                    setManager
-                },
                 {
                     fn addSolver(
                         data: &[u8],
@@ -2250,9 +1641,6 @@ pub mod GPv2AllowListAuthentication {
                 Self::addSolver(inner) => {
                     <addSolverCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::initializeManager(inner) => {
                     <initializeManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -2265,17 +1653,9 @@ pub mod GPv2AllowListAuthentication {
                 Self::removeSolver(inner) => {
                     <removeSolverCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::setManager(inner) => {
-                    <setManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::simulateDelegatecall(inner) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::simulateDelegatecallInternal(inner) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
             }
         }
 
@@ -2285,9 +1665,6 @@ pub mod GPv2AllowListAuthentication {
                 Self::addSolver(inner) => {
                     <addSolverCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::initializeManager(inner) => {
                     <initializeManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -2300,19 +1677,11 @@ pub mod GPv2AllowListAuthentication {
                 Self::removeSolver(inner) => {
                     <removeSolverCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::setManager(inner) => {
-                    <setManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::simulateDelegatecall(inner) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encode_raw(
                         inner, out,
                     )
                 }
-                Self::simulateDelegatecallInternal(inner) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
             }
         }
     }
@@ -2619,15 +1988,6 @@ pub mod GPv2AllowListAuthentication {
             self.call_builder(&addSolverCall { solver })
         }
 
-        ///Creates a new call builder for the [`getStorageAt`] function.
-        pub fn getStorageAt(
-            &self,
-            offset: alloy_sol_types::private::primitives::aliases::U256,
-            length: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
-            self.call_builder(&getStorageAtCall { offset, length })
-        }
-
         ///Creates a new call builder for the [`initializeManager`] function.
         pub fn initializeManager(
             &self,
@@ -2657,14 +2017,6 @@ pub mod GPv2AllowListAuthentication {
             self.call_builder(&removeSolverCall { solver })
         }
 
-        ///Creates a new call builder for the [`setManager`] function.
-        pub fn setManager(
-            &self,
-            manager_: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setManagerCall, N> {
-            self.call_builder(&setManagerCall { manager_ })
-        }
-
         ///Creates a new call builder for the [`simulateDelegatecall`]
         /// function.
         pub fn simulateDelegatecall(
@@ -2677,19 +2029,6 @@ pub mod GPv2AllowListAuthentication {
                 calldataPayload,
             })
         }
-
-        ///Creates a new call builder for the [`simulateDelegatecallInternal`]
-        /// function.
-        pub fn simulateDelegatecallInternal(
-            &self,
-            targetContract: alloy_sol_types::private::Address,
-            calldataPayload: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallInternalCall, N> {
-            self.call_builder(&simulateDelegatecallInternalCall {
-                targetContract,
-                calldataPayload,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs b/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
index edadccd68a..ca024bc92e 100644
--- a/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
+++ b/contracts/generated/contracts-generated/gpv2settlement/src/lib.rs
@@ -1435,15 +1435,10 @@ interface GPv2Settlement {
     function authenticator() external view returns (address);
     function domainSeparator() external view returns (bytes32);
     function filledAmount(bytes memory) external view returns (uint256);
-    function freeFilledAmountStorage(bytes[] memory orderUids) external;
-    function freePreSignatureStorage(bytes[] memory orderUids) external;
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
     function invalidateOrder(bytes memory orderUid) external;
-    function preSignature(bytes memory) external view returns (uint256);
     function setPreSignature(bytes memory orderUid, bool signed) external;
     function settle(address[] memory tokens, uint256[] memory clearingPrices, GPv2Trade.Data[] memory trades, GPv2Interaction.Data[][3] memory interactions) external;
     function simulateDelegatecall(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
     function swap(IVault.BatchSwapStep[] memory swaps, address[] memory tokens, GPv2Trade.Data memory trade) external;
     function vault() external view returns (address);
     function vaultRelayer() external view returns (address);
@@ -1518,56 +1513,6 @@ interface GPv2Settlement {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "freeFilledAmountStorage",
-    "inputs": [
-      {
-        "name": "orderUids",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "freePreSignatureStorage",
-    "inputs": [
-      {
-        "name": "orderUids",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getStorageAt",
-    "inputs": [
-      {
-        "name": "offset",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "length",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "invalidateOrder",
@@ -1581,25 +1526,6 @@ interface GPv2Settlement {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "preSignature",
-    "inputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "setPreSignature",
@@ -1744,30 +1670,6 @@ interface GPv2Settlement {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "simulateDelegatecallInternal",
-    "inputs": [
-      {
-        "name": "targetContract",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "calldataPayload",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "response",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "swap",
@@ -3184,22 +3086,21 @@ pub mod GPv2Settlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `freeFilledAmountStorage(bytes[])` and selector `0xed9f35ce`.
+    /**Function with signature `invalidateOrder(bytes)` and selector `0x15337bc0`.
     ```solidity
-    function freeFilledAmountStorage(bytes[] memory orderUids) external;
+    function invalidateOrder(bytes memory orderUid) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct freeFilledAmountStorageCall {
+    pub struct invalidateOrderCall {
         #[allow(missing_docs)]
-        pub orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        pub orderUid: alloy_sol_types::private::Bytes,
     }
     ///Container type for the return parameters of the
-    /// [`freeFilledAmountStorage(bytes[])`](freeFilledAmountStorageCall)
-    /// function.
+    /// [`invalidateOrder(bytes)`](invalidateOrderCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct freeFilledAmountStorageReturn {}
+    pub struct invalidateOrderReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3211,11 +3112,9 @@ pub mod GPv2Settlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3227,16 +3126,16 @@ pub mod GPv2Settlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<freeFilledAmountStorageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: freeFilledAmountStorageCall) -> Self {
-                    (value.orderUids,)
+            impl ::core::convert::From<invalidateOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrderCall) -> Self {
+                    (value.orderUid,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freeFilledAmountStorageCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderUids: tuple.0 }
+                    Self { orderUid: tuple.0 }
                 }
             }
         }
@@ -3257,38 +3156,36 @@ pub mod GPv2Settlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<freeFilledAmountStorageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: freeFilledAmountStorageReturn) -> Self {
+            impl ::core::convert::From<invalidateOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: invalidateOrderReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freeFilledAmountStorageReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl freeFilledAmountStorageReturn {
+        impl invalidateOrderReturn {
             fn _tokenize(
                 &self,
-            ) -> <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+            ) -> <invalidateOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for freeFilledAmountStorageCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            type Return = freeFilledAmountStorageReturn;
+        impl alloy_sol_types::SolCall for invalidateOrderCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type Return = invalidateOrderReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [237u8, 159u8, 53u8, 206u8];
-            const SIGNATURE: &'static str = "freeFilledAmountStorage(bytes[])";
+            const SELECTOR: [u8; 4] = [21u8, 51u8, 123u8, 192u8];
+            const SIGNATURE: &'static str = "invalidateOrder(bytes)";
 
             #[inline]
             fn new<'a>(
@@ -3299,16 +3196,16 @@ pub mod GPv2Settlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bytes,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.orderUids
-                ),)
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                freeFilledAmountStorageReturn::_tokenize(ret)
+                invalidateOrderReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -3327,22 +3224,23 @@ pub mod GPv2Settlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `freePreSignatureStorage(bytes[])` and selector `0xa2a7d51b`.
+    /**Function with signature `setPreSignature(bytes,bool)` and selector `0xec6cb13f`.
     ```solidity
-    function freePreSignatureStorage(bytes[] memory orderUids) external;
+    function setPreSignature(bytes memory orderUid, bool signed) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct freePreSignatureStorageCall {
+    pub struct setPreSignatureCall {
+        #[allow(missing_docs)]
+        pub orderUid: alloy_sol_types::private::Bytes,
         #[allow(missing_docs)]
-        pub orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
+        pub signed: bool,
     }
     ///Container type for the return parameters of the
-    /// [`freePreSignatureStorage(bytes[])`](freePreSignatureStorageCall)
-    /// function.
+    /// [`setPreSignature(bytes,bool)`](setPreSignatureCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct freePreSignatureStorageReturn {}
+    pub struct setPreSignatureReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3354,11 +3252,12 @@ pub mod GPv2Settlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bool,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes, bool);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3370,16 +3269,19 @@ pub mod GPv2Settlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<freePreSignatureStorageCall> for UnderlyingRustTuple<'_> {
-                fn from(value: freePreSignatureStorageCall) -> Self {
-                    (value.orderUids,)
+            impl ::core::convert::From<setPreSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: setPreSignatureCall) -> Self {
+                    (value.orderUid, value.signed)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freePreSignatureStorageCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPreSignatureCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderUids: tuple.0 }
+                    Self {
+                        orderUid: tuple.0,
+                        signed: tuple.1,
+                    }
                 }
             }
         }
@@ -3400,38 +3302,39 @@ pub mod GPv2Settlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<freePreSignatureStorageReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: freePreSignatureStorageReturn) -> Self {
+            impl ::core::convert::From<setPreSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: setPreSignatureReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for freePreSignatureStorageReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPreSignatureReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl freePreSignatureStorageReturn {
+        impl setPreSignatureReturn {
             fn _tokenize(
                 &self,
-            ) -> <freePreSignatureStorageCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+            ) -> <setPreSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for freePreSignatureStorageCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            type Return = freePreSignatureStorageReturn;
+        impl alloy_sol_types::SolCall for setPreSignatureCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Return = setPreSignatureReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [162u8, 167u8, 213u8, 27u8];
-            const SIGNATURE: &'static str = "freePreSignatureStorage(bytes[])";
+            const SELECTOR: [u8; 4] = [236u8, 108u8, 177u8, 63u8];
+            const SIGNATURE: &'static str = "setPreSignature(bytes,bool)";
 
             #[inline]
             fn new<'a>(
@@ -3442,16 +3345,19 @@ pub mod GPv2Settlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bytes,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.orderUids
-                ),)
+                (
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.orderUid,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.signed,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                freePreSignatureStorageReturn::_tokenize(ret)
+                setPreSignatureReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -3470,27 +3376,33 @@ pub mod GPv2Settlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getStorageAt(uint256,uint256)` and selector `0x5624b25b`.
+    /**Function with signature `settle(address[],uint256[],(uint256,uint256,address,uint256,uint256,uint32,bytes32,uint256,uint256,uint256,bytes)[],(address,uint256,bytes)[][3])` and selector `0x13d79a0b`.
     ```solidity
-    function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
+    function settle(address[] memory tokens, uint256[] memory clearingPrices, GPv2Trade.Data[] memory trades, GPv2Interaction.Data[][3] memory interactions) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getStorageAtCall {
+    pub struct settleCall {
+        #[allow(missing_docs)]
+        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub clearingPrices:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
         #[allow(missing_docs)]
-        pub offset: alloy_sol_types::private::primitives::aliases::U256,
+        pub trades:
+            alloy_sol_types::private::Vec<<GPv2Trade::Data as alloy_sol_types::SolType>::RustType>,
         #[allow(missing_docs)]
-        pub length: alloy_sol_types::private::primitives::aliases::U256,
+        pub interactions: [alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >; 3usize],
     }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getStorageAt(uint256,uint256)`](getStorageAtCall) function.
+    /// [`settle(address[],uint256[],(uint256,uint256,address,uint256,uint256,
+    /// uint32,bytes32,uint256,uint256,uint256,bytes)[],(address,uint256,
+    /// bytes)[][3])`](settleCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getStorageAtReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Bytes,
-    }
+    pub struct settleReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3503,13 +3415,24 @@ pub mod GPv2Settlement {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<GPv2Trade::Data>,
+                alloy_sol_types::sol_data::FixedArray<
+                    alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                    3usize,
+                >,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::Vec<
+                    <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                [alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >; 3usize],
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -3522,18 +3445,25 @@ pub mod GPv2Settlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtCall) -> Self {
-                    (value.offset, value.length)
+            impl ::core::convert::From<settleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleCall) -> Self {
+                    (
+                        value.tokens,
+                        value.clearingPrices,
+                        value.trades,
+                        value.interactions,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        offset: tuple.0,
-                        length: tuple.1,
+                        tokens: tuple.0,
+                        clearingPrices: tuple.1,
+                        trades: tuple.2,
+                        interactions: tuple.3,
                     }
                 }
             }
@@ -3541,9 +3471,9 @@ pub mod GPv2Settlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3555,660 +3485,44 @@ pub mod GPv2Settlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<getStorageAtReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getStorageAtReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<settleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getStorageAtReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl settleReturn {
+            fn _tokenize(&self) -> <settleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getStorageAtCall {
+        impl alloy_sol_types::SolCall for settleCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
+                alloy_sol_types::sol_data::Array<GPv2Trade::Data>,
+                alloy_sol_types::sol_data::FixedArray<
+                    alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                    3usize,
+                >,
             );
-            type Return = alloy_sol_types::private::Bytes;
+            type Return = settleReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [86u8, 36u8, 178u8, 91u8];
-            const SIGNATURE: &'static str = "getStorageAt(uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.offset,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.length,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getStorageAtReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getStorageAtReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `invalidateOrder(bytes)` and selector `0x15337bc0`.
-    ```solidity
-    function invalidateOrder(bytes memory orderUid) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct invalidateOrderCall {
-        #[allow(missing_docs)]
-        pub orderUid: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`invalidateOrder(bytes)`](invalidateOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct invalidateOrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<invalidateOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: invalidateOrderCall) -> Self {
-                    (value.orderUid,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderUid: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<invalidateOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: invalidateOrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl invalidateOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <invalidateOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for invalidateOrderCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Return = invalidateOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [21u8, 51u8, 123u8, 192u8];
-            const SIGNATURE: &'static str = "invalidateOrder(bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.orderUid,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                invalidateOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `preSignature(bytes)` and selector `0xd08d33d1`.
-    ```solidity
-    function preSignature(bytes memory) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct preSignatureCall(pub alloy_sol_types::private::Bytes);
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`preSignature(bytes)`](preSignatureCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct preSignatureReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<preSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: preSignatureCall) -> Self {
-                    (value.0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignatureCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<preSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: preSignatureReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignatureReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for preSignatureCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 141u8, 51u8, 209u8];
-            const SIGNATURE: &'static str = "preSignature(bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: preSignatureReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: preSignatureReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setPreSignature(bytes,bool)` and selector `0xec6cb13f`.
-    ```solidity
-    function setPreSignature(bytes memory orderUid, bool signed) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setPreSignatureCall {
-        #[allow(missing_docs)]
-        pub orderUid: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub signed: bool,
-    }
-    ///Container type for the return parameters of the
-    /// [`setPreSignature(bytes,bool)`](setPreSignatureCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setPreSignatureReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes, bool);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setPreSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setPreSignatureCall) -> Self {
-                    (value.orderUid, value.signed)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPreSignatureCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderUid: tuple.0,
-                        signed: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setPreSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setPreSignatureReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setPreSignatureReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setPreSignatureReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setPreSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setPreSignatureCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = setPreSignatureReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [236u8, 108u8, 177u8, 63u8];
-            const SIGNATURE: &'static str = "setPreSignature(bytes,bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.orderUid,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.signed,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setPreSignatureReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `settle(address[],uint256[],(uint256,uint256,address,uint256,uint256,uint32,bytes32,uint256,uint256,uint256,bytes)[],(address,uint256,bytes)[][3])` and selector `0x13d79a0b`.
-    ```solidity
-    function settle(address[] memory tokens, uint256[] memory clearingPrices, GPv2Trade.Data[] memory trades, GPv2Interaction.Data[][3] memory interactions) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct settleCall {
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub clearingPrices:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub trades:
-            alloy_sol_types::private::Vec<<GPv2Trade::Data as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub interactions: [alloy_sol_types::private::Vec<
-            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-        >; 3usize],
-    }
-    ///Container type for the return parameters of the
-    /// [`settle(address[],uint256[],(uint256,uint256,address,uint256,uint256,
-    /// uint32,bytes32,uint256,uint256,uint256,bytes)[],(address,uint256,
-    /// bytes)[][3])`](settleCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct settleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<GPv2Trade::Data>,
-                alloy_sol_types::sol_data::FixedArray<
-                    alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
-                    3usize,
-                >,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<
-                    <GPv2Trade::Data as alloy_sol_types::SolType>::RustType,
-                >,
-                [alloy_sol_types::private::Vec<
-                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-                >; 3usize],
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<settleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settleCall) -> Self {
-                    (
-                        value.tokens,
-                        value.clearingPrices,
-                        value.trades,
-                        value.interactions,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        clearingPrices: tuple.1,
-                        trades: tuple.2,
-                        interactions: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<settleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl settleReturn {
-            fn _tokenize(&self) -> <settleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for settleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<GPv2Trade::Data>,
-                alloy_sol_types::sol_data::FixedArray<
-                    alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
-                    3usize,
-                >,
-            );
-            type Return = settleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [19u8, 215u8, 154u8, 11u8];
-            const SIGNATURE: &'static str = "settle(address[],uint256[],(uint256,uint256,address,\
-                                             uint256,uint256,uint32,bytes32,uint256,uint256,\
-                                             uint256,bytes)[],(address,uint256,bytes)[][3])";
+            const SELECTOR: [u8; 4] = [19u8, 215u8, 154u8, 11u8];
+            const SIGNATURE: &'static str = "settle(address[],uint256[],(uint256,uint256,address,\
+                                             uint256,uint256,uint32,bytes32,uint256,uint256,\
+                                             uint256,bytes)[],(address,uint256,bytes)[][3])";
 
             #[inline]
             fn new<'a>(
@@ -4417,166 +3731,6 @@ pub mod GPv2Settlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `simulateDelegatecallInternal(address,bytes)` and selector `0x43218e19`.
-    ```solidity
-    function simulateDelegatecallInternal(address targetContract, bytes memory calldataPayload) external returns (bytes memory response);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallInternalCall {
-        #[allow(missing_docs)]
-        pub targetContract: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calldataPayload: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`simulateDelegatecallInternal(address,
-    /// bytes)`](simulateDelegatecallInternalCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct simulateDelegatecallInternalReturn {
-        #[allow(missing_docs)]
-        pub response: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallInternalCall> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallInternalCall) -> Self {
-                    (value.targetContract, value.calldataPayload)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        targetContract: tuple.0,
-                        calldataPayload: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<simulateDelegatecallInternalReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: simulateDelegatecallInternalReturn) -> Self {
-                    (value.response,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for simulateDelegatecallInternalReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { response: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for simulateDelegatecallInternalCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [67u8, 33u8, 142u8, 25u8];
-            const SIGNATURE: &'static str = "simulateDelegatecallInternal(address,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetContract,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.calldataPayload,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: simulateDelegatecallInternalReturn = r.into();
-                        r.response
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: simulateDelegatecallInternalReturn = r.into();
-                    r.response
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `swap((bytes32,uint256,uint256,uint256,bytes)[],address[],(uint256,uint256,address,uint256,uint256,uint32,bytes32,uint256,uint256,uint256,bytes))` and selector `0x845a101f`.
     ```solidity
     function swap(IVault.BatchSwapStep[] memory swaps, address[] memory tokens, GPv2Trade.Data memory trade) external;
@@ -5024,24 +4178,14 @@ pub mod GPv2Settlement {
         #[allow(missing_docs)]
         filledAmount(filledAmountCall),
         #[allow(missing_docs)]
-        freeFilledAmountStorage(freeFilledAmountStorageCall),
-        #[allow(missing_docs)]
-        freePreSignatureStorage(freePreSignatureStorageCall),
-        #[allow(missing_docs)]
-        getStorageAt(getStorageAtCall),
-        #[allow(missing_docs)]
         invalidateOrder(invalidateOrderCall),
         #[allow(missing_docs)]
-        preSignature(preSignatureCall),
-        #[allow(missing_docs)]
         setPreSignature(setPreSignatureCall),
         #[allow(missing_docs)]
         settle(settleCall),
         #[allow(missing_docs)]
         simulateDelegatecall(simulateDelegatecallCall),
         #[allow(missing_docs)]
-        simulateDelegatecallInternal(simulateDelegatecallInternalCall),
-        #[allow(missing_docs)]
         swap(swapCall),
         #[allow(missing_docs)]
         vault(vaultCall),
@@ -5061,14 +4205,9 @@ pub mod GPv2Settlement {
             [21u8, 51u8, 123u8, 192u8],
             [35u8, 53u8, 199u8, 107u8],
             [36u8, 121u8, 251u8, 110u8],
-            [67u8, 33u8, 142u8, 25u8],
-            [86u8, 36u8, 178u8, 91u8],
             [132u8, 90u8, 16u8, 31u8],
             [155u8, 85u8, 44u8, 194u8],
-            [162u8, 167u8, 213u8, 27u8],
-            [208u8, 141u8, 51u8, 209u8],
             [236u8, 108u8, 177u8, 63u8],
-            [237u8, 159u8, 53u8, 206u8],
             [246u8, 152u8, 218u8, 37u8],
             [248u8, 68u8, 54u8, 189u8],
             [251u8, 250u8, 119u8, 207u8],
@@ -5079,14 +4218,9 @@ pub mod GPv2Settlement {
             <invalidateOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
             <authenticatorCall as alloy_sol_types::SolCall>::SIGNATURE,
             <filledAmountCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getStorageAtCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapCall as alloy_sol_types::SolCall>::SIGNATURE,
             <vaultRelayerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <freePreSignatureStorageCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <preSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
             <setPreSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::SIGNATURE,
             <domainSeparatorCall as alloy_sol_types::SolCall>::SIGNATURE,
             <simulateDelegatecallCall as alloy_sol_types::SolCall>::SIGNATURE,
             <vaultCall as alloy_sol_types::SolCall>::SIGNATURE,
@@ -5097,14 +4231,9 @@ pub mod GPv2Settlement {
             ::core::stringify!(invalidateOrder),
             ::core::stringify!(authenticator),
             ::core::stringify!(filledAmount),
-            ::core::stringify!(simulateDelegatecallInternal),
-            ::core::stringify!(getStorageAt),
             ::core::stringify!(swap),
             ::core::stringify!(vaultRelayer),
-            ::core::stringify!(freePreSignatureStorage),
-            ::core::stringify!(preSignature),
             ::core::stringify!(setPreSignature),
-            ::core::stringify!(freeFilledAmountStorage),
             ::core::stringify!(domainSeparator),
             ::core::stringify!(simulateDelegatecall),
             ::core::stringify!(vault),
@@ -5132,7 +4261,7 @@ pub mod GPv2Settlement {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for GPv2SettlementCalls {
-        const COUNT: usize = 15usize;
+        const COUNT: usize = 10usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "GPv2SettlementCalls";
 
@@ -5144,17 +4273,9 @@ pub mod GPv2Settlement {
                     <domainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
                 }
                 Self::filledAmount(_) => <filledAmountCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::freeFilledAmountStorage(_) => {
-                    <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::freePreSignatureStorage(_) => {
-                    <freePreSignatureStorageCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getStorageAt(_) => <getStorageAtCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::invalidateOrder(_) => {
                     <invalidateOrderCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::preSignature(_) => <preSignatureCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::setPreSignature(_) => {
                     <setPreSignatureCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -5162,9 +4283,6 @@ pub mod GPv2Settlement {
                 Self::simulateDelegatecall(_) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::simulateDelegatecallInternal(_) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::vault(_) => <vaultCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::vaultRelayer(_) => <vaultRelayerCall as alloy_sol_types::SolCall>::SELECTOR,
@@ -5215,24 +4333,6 @@ pub mod GPv2Settlement {
                     }
                     filledAmount
                 },
-                {
-                    fn simulateDelegatecallInternal(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(GPv2SettlementCalls::simulateDelegatecallInternal)
-                    }
-                    simulateDelegatecallInternal
-                },
-                {
-                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GPv2SettlementCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
                 {
                     fn swap(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
                         <swapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5247,24 +4347,6 @@ pub mod GPv2Settlement {
                     }
                     vaultRelayer
                 },
-                {
-                    fn freePreSignatureStorage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GPv2SettlementCalls::freePreSignatureStorage)
-                    }
-                    freePreSignatureStorage
-                },
-                {
-                    fn preSignature(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <preSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(GPv2SettlementCalls::preSignature)
-                    }
-                    preSignature
-                },
                 {
                     fn setPreSignature(
                         data: &[u8],
@@ -5274,17 +4356,6 @@ pub mod GPv2Settlement {
                     }
                     setPreSignature
                 },
-                {
-                    fn freeFilledAmountStorage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(GPv2SettlementCalls::freeFilledAmountStorage)
-                    }
-                    freeFilledAmountStorage
-                },
                 {
                     fn domainSeparator(
                         data: &[u8],
@@ -5366,26 +4437,6 @@ pub mod GPv2Settlement {
                     }
                     filledAmount
                 },
-                {
-                    fn simulateDelegatecallInternal(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GPv2SettlementCalls::simulateDelegatecallInternal)
-                    }
-                    simulateDelegatecallInternal
-                },
-                {
-                    fn getStorageAt(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <getStorageAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GPv2SettlementCalls::getStorageAt)
-                    }
-                    getStorageAt
-                },
                 {
                     fn swap(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
                         <swapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -5402,26 +4453,6 @@ pub mod GPv2Settlement {
                     }
                     vaultRelayer
                 },
-                {
-                    fn freePreSignatureStorage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GPv2SettlementCalls::freePreSignatureStorage)
-                    }
-                    freePreSignatureStorage
-                },
-                {
-                    fn preSignature(data: &[u8]) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <preSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(GPv2SettlementCalls::preSignature)
-                    }
-                    preSignature
-                },
                 {
                     fn setPreSignature(
                         data: &[u8],
@@ -5433,17 +4464,6 @@ pub mod GPv2Settlement {
                     }
                     setPreSignature
                 },
-                {
-                    fn freeFilledAmountStorage(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<GPv2SettlementCalls> {
-                        <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(GPv2SettlementCalls::freeFilledAmountStorage)
-                    }
-                    freeFilledAmountStorage
-                },
                 {
                     fn domainSeparator(
                         data: &[u8],
@@ -5495,25 +4515,9 @@ pub mod GPv2Settlement {
                 Self::filledAmount(inner) => {
                     <filledAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::freeFilledAmountStorage(inner) => {
-                    <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::freePreSignatureStorage(inner) => {
-                    <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::invalidateOrder(inner) => {
                     <invalidateOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::preSignature(inner) => {
-                    <preSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::setPreSignature(inner) => {
                     <setPreSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5523,11 +4527,6 @@ pub mod GPv2Settlement {
                 Self::simulateDelegatecall(inner) => {
                     <simulateDelegatecallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::simulateDelegatecallInternal(inner) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -5552,25 +4551,9 @@ pub mod GPv2Settlement {
                 Self::filledAmount(inner) => {
                     <filledAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::freeFilledAmountStorage(inner) => {
-                    <freeFilledAmountStorageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::freePreSignatureStorage(inner) => {
-                    <freePreSignatureStorageCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::getStorageAt(inner) => {
-                    <getStorageAtCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::invalidateOrder(inner) => {
                     <invalidateOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::preSignature(inner) => {
-                    <preSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::setPreSignature(inner) => {
                     <setPreSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -5582,11 +4565,6 @@ pub mod GPv2Settlement {
                         inner, out,
                     )
                 }
-                Self::simulateDelegatecallInternal(inner) => {
-                    <simulateDelegatecallInternalCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -5965,33 +4943,6 @@ pub mod GPv2Settlement {
             self.call_builder(&filledAmountCall(_0))
         }
 
-        ///Creates a new call builder for the [`freeFilledAmountStorage`]
-        /// function.
-        pub fn freeFilledAmountStorage(
-            &self,
-            orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        ) -> alloy_contract::SolCallBuilder<&P, freeFilledAmountStorageCall, N> {
-            self.call_builder(&freeFilledAmountStorageCall { orderUids })
-        }
-
-        ///Creates a new call builder for the [`freePreSignatureStorage`]
-        /// function.
-        pub fn freePreSignatureStorage(
-            &self,
-            orderUids: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        ) -> alloy_contract::SolCallBuilder<&P, freePreSignatureStorageCall, N> {
-            self.call_builder(&freePreSignatureStorageCall { orderUids })
-        }
-
-        ///Creates a new call builder for the [`getStorageAt`] function.
-        pub fn getStorageAt(
-            &self,
-            offset: alloy_sol_types::private::primitives::aliases::U256,
-            length: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getStorageAtCall, N> {
-            self.call_builder(&getStorageAtCall { offset, length })
-        }
-
         ///Creates a new call builder for the [`invalidateOrder`] function.
         pub fn invalidateOrder(
             &self,
@@ -6000,14 +4951,6 @@ pub mod GPv2Settlement {
             self.call_builder(&invalidateOrderCall { orderUid })
         }
 
-        ///Creates a new call builder for the [`preSignature`] function.
-        pub fn preSignature(
-            &self,
-            _0: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, preSignatureCall, N> {
-            self.call_builder(&preSignatureCall(_0))
-        }
-
         ///Creates a new call builder for the [`setPreSignature`] function.
         pub fn setPreSignature(
             &self,
@@ -6052,19 +4995,6 @@ pub mod GPv2Settlement {
             })
         }
 
-        ///Creates a new call builder for the [`simulateDelegatecallInternal`]
-        /// function.
-        pub fn simulateDelegatecallInternal(
-            &self,
-            targetContract: alloy_sol_types::private::Address,
-            calldataPayload: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, simulateDelegatecallInternalCall, N> {
-            self.call_builder(&simulateDelegatecallInternalCall {
-                targetContract,
-                calldataPayload,
-            })
-        }
-
         ///Creates a new call builder for the [`swap`] function.
         pub fn swap(
             &self,
diff --git a/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs b/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs
index 33f9dbf01d..446d527c3f 100644
--- a/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/honeyswaprouter/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface HoneyswapRouter {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -120,4777 +101,113 @@ interface HoneyswapRouter {
   },
   {
     "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "factory",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "quote",
-    "inputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod HoneyswapRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
-    ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod HoneyswapRouter {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4902,21 +219,9 @@ pub mod HoneyswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4928,41 +233,25 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4974,50 +263,29 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -5028,34 +296,22 @@ pub mod HoneyswapRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5063,24 +319,33 @@ pub mod HoneyswapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod HoneyswapRouter {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod HoneyswapRouter {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod HoneyswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod HoneyswapRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod HoneyswapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod HoneyswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5435,34 +683,22 @@ pub mod HoneyswapRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod HoneyswapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod HoneyswapRouter {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod HoneyswapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod HoneyswapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod HoneyswapRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod HoneyswapRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod HoneyswapRouter {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl HoneyswapRouterCalls {
@@ -5949,84 +1110,27 @@ pub mod HoneyswapRouter {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6051,220 +1155,37 @@ pub mod HoneyswapRouter {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for HoneyswapRouterCalls {
-        const COUNT: usize = 24usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "HoneyswapRouterCalls";
 
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactTokens(_) => {
-                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls>] = &[
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6290,41 +1211,6 @@ pub mod HoneyswapRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6332,24 +1218,6 @@ pub mod HoneyswapRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6357,26 +1225,6 @@ pub mod HoneyswapRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(HoneyswapRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6397,136 +1245,6 @@ pub mod HoneyswapRouter {
                 &[u8],
             )
                 -> alloy_sol_types::Result<HoneyswapRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(HoneyswapRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6552,43 +1270,6 @@ pub mod HoneyswapRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                HoneyswapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6596,26 +1277,6 @@ pub mod HoneyswapRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6625,28 +1286,6 @@ pub mod HoneyswapRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(HoneyswapRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<HoneyswapRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(HoneyswapRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6661,115 +1300,16 @@ pub mod HoneyswapRouter {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6786,137 +1326,17 @@ pub mod HoneyswapRouter {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7060,77 +1480,11 @@ pub mod HoneyswapRouter {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7145,327 +1499,6 @@ pub mod HoneyswapRouter {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/icowwrapper/src/lib.rs b/contracts/generated/contracts-generated/icowwrapper/src/lib.rs
index 58cbc1ceee..500a73c78b 100644
--- a/contracts/generated/contracts-generated/icowwrapper/src/lib.rs
+++ b/contracts/generated/contracts-generated/icowwrapper/src/lib.rs
@@ -11,7 +11,6 @@
 Generated by the following Solidity interface...
 ```solidity
 interface ICowWrapper {
-    function parseWrapperData(bytes memory wrapperData) external view returns (bytes memory remainingWrapperData);
     function wrappedSettle(bytes memory settleData, bytes memory wrapperData) external;
 }
 ```
@@ -19,25 +18,6 @@ interface ICowWrapper {
 ...which was generated by the following JSON ABI:
 ```json
 [
-  {
-    "type": "function",
-    "name": "parseWrapperData",
-    "inputs": [
-      {
-        "name": "wrapperData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "remainingWrapperData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "wrappedSettle",
@@ -68,152 +48,6 @@ interface ICowWrapper {
 pub mod ICowWrapper {
     use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `parseWrapperData(bytes)` and selector `0x79abe637`.
-    ```solidity
-    function parseWrapperData(bytes memory wrapperData) external view returns (bytes memory remainingWrapperData);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct parseWrapperDataCall {
-        #[allow(missing_docs)]
-        pub wrapperData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`parseWrapperData(bytes)`](parseWrapperDataCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct parseWrapperDataReturn {
-        #[allow(missing_docs)]
-        pub remainingWrapperData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<parseWrapperDataCall> for UnderlyingRustTuple<'_> {
-                fn from(value: parseWrapperDataCall) -> Self {
-                    (value.wrapperData,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for parseWrapperDataCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        wrapperData: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<parseWrapperDataReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: parseWrapperDataReturn) -> Self {
-                    (value.remainingWrapperData,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for parseWrapperDataReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        remainingWrapperData: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for parseWrapperDataCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [121u8, 171u8, 230u8, 55u8];
-            const SIGNATURE: &'static str = "parseWrapperData(bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.wrapperData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: parseWrapperDataReturn = r.into();
-                        r.remainingWrapperData
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: parseWrapperDataReturn = r.into();
-                    r.remainingWrapperData
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `wrappedSettle(bytes,bytes)` and selector `0xd20e71e7`.
     ```solidity
     function wrappedSettle(bytes memory settleData, bytes memory wrapperData) external;
@@ -371,8 +205,6 @@ pub mod ICowWrapper {
     ///Container for all the [`ICowWrapper`](self) function calls.
     #[derive(Clone)]
     pub enum ICowWrapperCalls {
-        #[allow(missing_docs)]
-        parseWrapperData(parseWrapperDataCall),
         #[allow(missing_docs)]
         wrappedSettle(wrappedSettleCall),
     }
@@ -384,18 +216,12 @@ pub mod ICowWrapper {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] =
-            &[[121u8, 171u8, 230u8, 55u8], [210u8, 14u8, 113u8, 231u8]];
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[[210u8, 14u8, 113u8, 231u8]];
         /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <parseWrapperDataCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <wrappedSettleCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
+        pub const SIGNATURES: &'static [&'static str] =
+            &[<wrappedSettleCall as alloy_sol_types::SolCall>::SIGNATURE];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(parseWrapperData),
-            ::core::stringify!(wrappedSettle),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] = &[::core::stringify!(wrappedSettle)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -419,16 +245,13 @@ pub mod ICowWrapper {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for ICowWrapperCalls {
-        const COUNT: usize = 2usize;
-        const MIN_DATA_LENGTH: usize = 64usize;
+        const COUNT: usize = 1usize;
+        const MIN_DATA_LENGTH: usize = 128usize;
         const NAME: &'static str = "ICowWrapperCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::parseWrapperData(_) => {
-                    <parseWrapperDataCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::wrappedSettle(_) => <wrappedSettleCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -446,22 +269,13 @@ pub mod ICowWrapper {
         #[inline]
         #[allow(non_snake_case)]
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ICowWrapperCalls>] = &[
-                {
-                    fn parseWrapperData(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
-                        <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ICowWrapperCalls::parseWrapperData)
-                    }
-                    parseWrapperData
-                },
-                {
-                    fn wrappedSettle(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
-                        <wrappedSettleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ICowWrapperCalls::wrappedSettle)
-                    }
-                    wrappedSettle
-                },
-            ];
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ICowWrapperCalls>] = &[{
+                fn wrappedSettle(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
+                    <wrappedSettleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                        .map(ICowWrapperCalls::wrappedSettle)
+                }
+                wrappedSettle
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -480,26 +294,13 @@ pub mod ICowWrapper {
             static DECODE_VALIDATE_SHIMS: &[fn(
                 &[u8],
             )
-                -> alloy_sol_types::Result<ICowWrapperCalls>] = &[
-                {
-                    fn parseWrapperData(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
-                        <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(ICowWrapperCalls::parseWrapperData)
-                    }
-                    parseWrapperData
-                },
-                {
-                    fn wrappedSettle(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
-                        <wrappedSettleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
+                -> alloy_sol_types::Result<ICowWrapperCalls>] = &[{
+                fn wrappedSettle(data: &[u8]) -> alloy_sol_types::Result<ICowWrapperCalls> {
+                    <wrappedSettleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
                         .map(ICowWrapperCalls::wrappedSettle)
-                    }
-                    wrappedSettle
-                },
-            ];
+                }
+                wrappedSettle
+            }];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
                     <Self as alloy_sol_types::SolInterface>::NAME,
@@ -512,9 +313,6 @@ pub mod ICowWrapper {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::parseWrapperData(inner) => {
-                    <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::wrappedSettle(inner) => {
                     <wrappedSettleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -524,9 +322,6 @@ pub mod ICowWrapper {
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::parseWrapperData(inner) => {
-                    <parseWrapperDataCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::wrappedSettle(inner) => {
                     <wrappedSettleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -642,14 +437,6 @@ pub mod ICowWrapper {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`parseWrapperData`] function.
-        pub fn parseWrapperData(
-            &self,
-            wrapperData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, parseWrapperDataCall, N> {
-            self.call_builder(&parseWrapperDataCall { wrapperData })
-        }
-
         ///Creates a new call builder for the [`wrappedSettle`] function.
         pub fn wrappedSettle(
             &self,
diff --git a/contracts/generated/contracts-generated/iswaprpair/src/lib.rs b/contracts/generated/contracts-generated/iswaprpair/src/lib.rs
index 8c1fdec219..80abaf0f55 100644
--- a/contracts/generated/contracts-generated/iswaprpair/src/lib.rs
+++ b/contracts/generated/contracts-generated/iswaprpair/src/lib.rs
@@ -19,8 +19,6 @@ interface ISwaprPair {
     event Transfer(address indexed from, address indexed to, uint256 value);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function MINIMUM_LIQUIDITY() external pure returns (uint256);
-    function PERMIT_TYPEHASH() external pure returns (bytes32);
     function allowance(address owner, address spender) external view returns (uint256);
     function approve(address spender, uint256 value) external returns (bool);
     function balanceOf(address owner) external view returns (uint256);
@@ -29,22 +27,16 @@ interface ISwaprPair {
     function factory() external view returns (address);
     function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
     function initialize(address, address) external;
-    function kLast() external view returns (uint256);
     function mint(address to) external returns (uint256 liquidity);
     function name() external pure returns (string memory);
     function nonces(address owner) external view returns (uint256);
     function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function price0CumulativeLast() external view returns (uint256);
-    function price1CumulativeLast() external view returns (uint256);
-    function setSwapFee(uint32) external;
-    function skim(address to) external;
     function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes memory data) external;
     function swapFee() external view returns (uint32);
     function symbol() external pure returns (string memory);
     function sync() external;
     function token0() external view returns (address);
     function token1() external view returns (address);
-    function totalSupply() external view returns (uint256);
     function transfer(address to, uint256 value) external returns (bool);
     function transferFrom(address from, address to, uint256 value) external returns (bool);
 }
@@ -66,32 +58,6 @@ interface ISwaprPair {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "MINIMUM_LIQUIDITY",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "PERMIT_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "pure"
-  },
   {
     "type": "function",
     "name": "allowance",
@@ -250,19 +216,6 @@ interface ISwaprPair {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "kLast",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "mint",
@@ -357,58 +310,6 @@ interface ISwaprPair {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "price0CumulativeLast",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "price1CumulativeLast",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "setSwapFee",
-    "inputs": [
-      {
-        "name": "",
-        "type": "uint32",
-        "internalType": "uint32"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "skim",
-    "inputs": [
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "swap",
@@ -496,19 +397,6 @@ interface ISwaprPair {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -1668,19 +1556,24 @@ pub mod ISwaprPair {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `MINIMUM_LIQUIDITY()` and selector `0xba9a7a56`.
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
-    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MINIMUM_LIQUIDITYCall;
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`MINIMUM_LIQUIDITY()`](MINIMUM_LIQUIDITYCall) function.
+    /// [`allowance(address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MINIMUM_LIQUIDITYReturn {
+    pub struct allowanceReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -1695,9 +1588,15 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1709,16 +1608,19 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MINIMUM_LIQUIDITYCall> for UnderlyingRustTuple<'_> {
-                fn from(value: MINIMUM_LIQUIDITYCall) -> Self {
-                    ()
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
                 }
             }
         }
@@ -1739,29 +1641,32 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MINIMUM_LIQUIDITYReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: MINIMUM_LIQUIDITYReturn) -> Self {
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for MINIMUM_LIQUIDITYCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [186u8, 154u8, 122u8, 86u8];
-            const SIGNATURE: &'static str = "MINIMUM_LIQUIDITY()";
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -1772,7 +1677,14 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
             }
 
             #[inline]
@@ -1788,7 +1700,7 @@ pub mod ISwaprPair {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: MINIMUM_LIQUIDITYReturn = r.into();
+                        let r: allowanceReturn = r.into();
                         r._0
                     },
                 )
@@ -1800,28 +1712,33 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: MINIMUM_LIQUIDITYReturn = r.into();
+                    let r: allowanceReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `PERMIT_TYPEHASH()` and selector `0x30adf81f`.
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
     ```solidity
-    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function approve(address spender, uint256 value) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct PERMIT_TYPEHASHCall;
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`PERMIT_TYPEHASH()`](PERMIT_TYPEHASHCall) function.
+    /// [`approve(address,uint256)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct PERMIT_TYPEHASHReturn {
+    pub struct approveReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -1834,9 +1751,15 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1848,25 +1771,28 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<PERMIT_TYPEHASHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: PERMIT_TYPEHASHCall) -> Self {
-                    ()
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.value)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        spender: tuple.0,
+                        value: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1878,29 +1804,32 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<PERMIT_TYPEHASHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: PERMIT_TYPEHASHReturn) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for PERMIT_TYPEHASHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [48u8, 173u8, 248u8, 31u8];
-            const SIGNATURE: &'static str = "PERMIT_TYPEHASH()";
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -1911,23 +1840,26 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: PERMIT_TYPEHASHReturn = r.into();
+                        let r: approveReturn = r.into();
                         r._0
                     },
                 )
@@ -1939,31 +1871,29 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: PERMIT_TYPEHASHReturn = r.into();
+                    let r: approveReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
     ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
+    function balanceOf(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceCall {
+    pub struct balanceOfCall {
         #[allow(missing_docs)]
         pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
+    /// [`balanceOf(address)`](balanceOfCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceReturn {
+    pub struct balanceOfReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -1978,15 +1908,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1998,19 +1922,16 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
+                    Self { owner: tuple.0 }
                 }
             }
         }
@@ -2031,32 +1952,29 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
 
             #[inline]
             fn new<'a>(
@@ -2071,9 +1989,6 @@ pub mod ISwaprPair {
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.owner,
                     ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
                 )
             }
 
@@ -2090,7 +2005,7 @@ pub mod ISwaprPair {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: allowanceReturn = r.into();
+                        let r: balanceOfReturn = r.into();
                         r._0
                     },
                 )
@@ -2102,33 +2017,33 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: allowanceReturn = r.into();
+                    let r: balanceOfReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    /**Function with signature `burn(address)` and selector `0x89afcb44`.
     ```solidity
-    function approve(address spender, uint256 value) external returns (bool);
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
+    pub struct burnCall {
         #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        pub to: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
+    /// [`burn(address)`](burnCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveReturn {
+    pub struct burnReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -2141,15 +2056,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2161,28 +2070,31 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.value)
+            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
+                fn from(value: burnCall) -> Self {
+                    (value.to,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        value: tuple.1,
-                    }
+                    Self { to: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2194,32 +2106,47 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: burnReturn) -> Self {
+                    (value.amount0, value.amount1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
                 }
             }
         }
+        impl burnReturn {
+            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolCall for burnCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = burnReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
+            const SELECTOR: [u8; 4] = [137u8, 175u8, 203u8, 68u8];
+            const SIGNATURE: &'static str = "burn(address)";
 
             #[inline]
             fn new<'a>(
@@ -2232,27 +2159,20 @@ pub mod ISwaprPair {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
+                        &self.to,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                burnReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approveReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2260,32 +2180,26 @@ pub mod ISwaprPair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: approveReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    /**Function with signature `decimals()` and selector `0x313ce567`.
     ```solidity
-    function balanceOf(address owner) external view returns (uint256);
+    function decimals() external pure returns (uint8);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct balanceOfCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
+    pub struct decimalsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
+    /// [`decimals()`](decimalsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct balanceOfReturn {
+    pub struct decimalsReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: u8,
     }
     #[allow(
         non_camel_case_types,
@@ -2298,9 +2212,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2312,25 +2226,25 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.owner,)
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (u8,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2342,29 +2256,29 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
 
             #[inline]
             fn new<'a>(
@@ -2375,27 +2289,19 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: balanceOfReturn = r.into();
+                        let r: decimalsReturn = r.into();
                         r._0
                     },
                 )
@@ -2407,33 +2313,28 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: balanceOfReturn = r.into();
+                    let r: decimalsReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `burn(address)` and selector `0x89afcb44`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+    function factory() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct burnCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-    }
+    pub struct factoryCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`burn(address)`](burnCall) function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct burnReturn {
-        #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct factoryReturn {
         #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -2446,9 +2347,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2460,31 +2361,25 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
-                fn from(value: burnCall) -> Self {
-                    (value.to,)
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { to: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2496,1050 +2391,29 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: burnReturn) -> Self {
-                    (value.amount0, value.amount1)
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount0: tuple.0,
-                        amount1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl burnReturn {
-            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for burnCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = burnReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [137u8, 175u8, 203u8, 68u8];
-            const SIGNATURE: &'static str = "burn(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                burnReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
-    ```solidity
-    function decimals() external pure returns (uint8);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct decimalsReturn {
-        #[allow(missing_docs)]
-        pub _0: u8,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
-            type Parameters<'a> = ();
-            type Return = u8;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decimalsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: decimalsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getReserves()` and selector `0x0902f1ac`.
-    ```solidity
-    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getReservesCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getReserves()`](getReservesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getReservesReturn {
-        #[allow(missing_docs)]
-        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
-        #[allow(missing_docs)]
-        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
-        #[allow(missing_docs)]
-        pub blockTimestampLast: u32,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getReservesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getReservesCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U112,
-                alloy_sol_types::private::primitives::aliases::U112,
-                u32,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getReservesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getReservesReturn) -> Self {
-                    (value.reserve0, value.reserve1, value.blockTimestampLast)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        reserve0: tuple.0,
-                        reserve1: tuple.1,
-                        blockTimestampLast: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getReservesReturn {
-            fn _tokenize(&self) -> <getReservesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserve0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserve1,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        &self.blockTimestampLast,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getReservesCall {
-            type Parameters<'a> = ();
-            type Return = getReservesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<32>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 2u8, 241u8, 172u8];
-            const SIGNATURE: &'static str = "getReserves()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getReservesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `initialize(address,address)` and selector `0x485cc955`.
-    ```solidity
-    function initialize(address, address) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct initializeCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`initialize(address,address)`](initializeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct initializeReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: initializeCall) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: initializeReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl initializeReturn {
-            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for initializeCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = initializeReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
-            const SIGNATURE: &'static str = "initialize(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                initializeReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `kLast()` and selector `0x7464fc3d`.
-    ```solidity
-    function kLast() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct kLastCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`kLast()`](kLastCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct kLastReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<kLastCall> for UnderlyingRustTuple<'_> {
-                fn from(value: kLastCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<kLastReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: kLastReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for kLastCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [116u8, 100u8, 252u8, 61u8];
-            const SIGNATURE: &'static str = "kLast()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: kLastReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: kLastReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `mint(address)` and selector `0x6a627842`.
-    ```solidity
-    function mint(address to) external returns (uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`mint(address)`](mintCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintReturn {
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
-                fn from(value: mintCall) -> Self {
-                    (value.to,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { to: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: mintReturn) -> Self {
-                    (value.liquidity,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { liquidity: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for mintCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [106u8, 98u8, 120u8, 66u8];
-            const SIGNATURE: &'static str = "mint(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: mintReturn = r.into();
-                        r.liquidity
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: mintReturn = r.into();
-                    r.liquidity
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
-    ```solidity
-    function name() external pure returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
+        impl alloy_sol_types::SolCall for factoryCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -3555,14 +2429,14 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: nameReturn = r.into();
+                        let r: factoryReturn = r.into();
                         r._0
                     },
                 )
@@ -3574,31 +2448,32 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: nameReturn = r.into();
+                    let r: factoryReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
+    /**Function with signature `getReserves()` and selector `0x0902f1ac`.
     ```solidity
-    function nonces(address owner) external view returns (uint256);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct noncesCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
+    pub struct getReservesCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
+    /// [`getReserves()`](getReservesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct noncesReturn {
+    pub struct getReservesReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub blockTimestampLast: u32,
     }
     #[allow(
         non_camel_case_types,
@@ -3611,9 +2486,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3625,25 +2500,33 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
+            impl ::core::convert::From<getReservesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U112,
+                alloy_sol_types::private::primitives::aliases::U112,
+                u32,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3655,29 +2538,52 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<getReservesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesReturn) -> Self {
+                    (value.reserve0, value.reserve1, value.blockTimestampLast)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        reserve0: tuple.0,
+                        reserve1: tuple.1,
+                        blockTimestampLast: tuple.2,
+                    }
                 }
             }
         }
+        impl getReservesReturn {
+            fn _tokenize(&self) -> <getReservesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockTimestampLast,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for getReservesCall {
+            type Parameters<'a> = ();
+            type Return = getReservesReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
+            const SELECTOR: [u8; 4] = [9u8, 2u8, 241u8, 172u8];
+            const SIGNATURE: &'static str = "getReserves()";
 
             #[inline]
             fn new<'a>(
@@ -3688,30 +2594,18 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                getReservesReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: noncesReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -3719,42 +2613,28 @@ pub mod ISwaprPair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: noncesReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
+    /**Function with signature `initialize(address,address)` and selector `0x485cc955`.
     ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+    function initialize(address, address) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub v: u8,
+    pub struct initializeCall {
         #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
+        pub _1: alloy_sol_types::private::Address,
     }
     ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
+    /// [`initialize(address,address)`](initializeCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitReturn {}
+    pub struct initializeReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3769,21 +2649,11 @@ pub mod ISwaprPair {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -3796,31 +2666,18 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
+            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeCall) -> Self {
+                    (value._0, value._1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
+                        _0: tuple.0,
+                        _1: tuple.1,
                     }
                 }
             }
@@ -3842,43 +2699,37 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
+            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl initializeReturn {
+            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
+        impl alloy_sol_types::SolCall for initializeCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
             );
-            type Return = permitReturn;
+            type Return = initializeReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+            const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
+            const SIGNATURE: &'static str = "initialize(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -3891,32 +2742,17 @@ pub mod ISwaprPair {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
+                        &self._0,
                     ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self._1,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
+                initializeReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -3935,21 +2771,24 @@ pub mod ISwaprPair {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `price0CumulativeLast()` and selector `0x5909c0d5`.
+    /**Function with signature `mint(address)` and selector `0x6a627842`.
     ```solidity
-    function price0CumulativeLast() external view returns (uint256);
+    function mint(address to) external returns (uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price0CumulativeLastCall;
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`price0CumulativeLast()`](price0CumulativeLastCall) function.
+    /// [`mint(address)`](mintCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price0CumulativeLastReturn {
+    pub struct mintReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -3962,9 +2801,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3976,16 +2815,16 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price0CumulativeLastCall> for UnderlyingRustTuple<'_> {
-                fn from(value: price0CumulativeLastCall) -> Self {
-                    ()
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.to,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self { to: tuple.0 }
                 }
             }
         }
@@ -4006,29 +2845,29 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price0CumulativeLastReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: price0CumulativeLastReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value.liquidity,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { liquidity: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for price0CumulativeLastCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [89u8, 9u8, 192u8, 213u8];
-            const SIGNATURE: &'static str = "price0CumulativeLast()";
+            const SELECTOR: [u8; 4] = [106u8, 98u8, 120u8, 66u8];
+            const SIGNATURE: &'static str = "mint(address)";
 
             #[inline]
             fn new<'a>(
@@ -4039,7 +2878,11 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                )
             }
 
             #[inline]
@@ -4055,8 +2898,8 @@ pub mod ISwaprPair {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: price0CumulativeLastReturn = r.into();
-                        r._0
+                        let r: mintReturn = r.into();
+                        r.liquidity
                     },
                 )
             }
@@ -4067,28 +2910,28 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: price0CumulativeLastReturn = r.into();
-                    r._0
+                    let r: mintReturn = r.into();
+                    r.liquidity
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `price1CumulativeLast()` and selector `0x5a3d5493`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function price1CumulativeLast() external view returns (uint256);
+    function name() external pure returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price1CumulativeLastCall;
+    pub struct nameCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`price1CumulativeLast()`](price1CumulativeLastCall) function.
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price1CumulativeLastReturn {
+    pub struct nameReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -4115,14 +2958,14 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price1CumulativeLastCall> for UnderlyingRustTuple<'_> {
-                fn from(value: price1CumulativeLastCall) -> Self {
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -4131,9 +2974,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4145,29 +2988,29 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price1CumulativeLastReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: price1CumulativeLastReturn) -> Self {
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for price1CumulativeLastCall {
+        impl alloy_sol_types::SolCall for nameCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [90u8, 61u8, 84u8, 147u8];
-            const SIGNATURE: &'static str = "price1CumulativeLast()";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -4183,18 +3026,14 @@ pub mod ISwaprPair {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: price1CumulativeLastReturn = r.into();
+                        let r: nameReturn = r.into();
                         r._0
                     },
                 )
@@ -4206,25 +3045,32 @@ pub mod ISwaprPair {
                     data,
                 )
                 .map(|r| {
-                    let r: price1CumulativeLastReturn = r.into();
+                    let r: nameReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setSwapFee(uint32)` and selector `0xd6d788c3`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function setSwapFee(uint32) external;
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeeCall(pub u32);
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setSwapFee(uint32)`](setSwapFeeCall) function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setSwapFeeReturn {}
+    pub struct noncesReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4236,9 +3082,9 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u32,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4250,25 +3096,25 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeeCall) -> Self {
-                    (value.0,)
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeeCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
+                    Self { owner: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4280,34 +3126,29 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setSwapFeeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setSwapFeeReturn) -> Self {
-                    ()
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setSwapFeeReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setSwapFeeReturn {
-            fn _tokenize(&self) -> <setSwapFeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setSwapFeeCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<32>,);
-            type Return = setSwapFeeReturn;
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [214u8, 215u8, 136u8, 195u8];
-            const SIGNATURE: &'static str = "setSwapFee(uint32)";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -4319,21 +3160,29 @@ pub mod ISwaprPair {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setSwapFeeReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: noncesReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -4341,26 +3190,42 @@ pub mod ISwaprPair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: noncesReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `skim(address)` and selector `0xbc25cf77`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function skim(address to) external;
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct skimCall {
+    pub struct permitCall {
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
     }
     ///Container type for the return parameters of the
-    /// [`skim(address)`](skimCall) function.
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct skimReturn {}
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4372,9 +3237,25 @@ pub mod ISwaprPair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4386,16 +3267,32 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<skimCall> for UnderlyingRustTuple<'_> {
-                fn from(value: skimCall) -> Self {
-                    (value.to,)
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { to: tuple.0 }
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
                 }
             }
         }
@@ -4416,34 +3313,43 @@ pub mod ISwaprPair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<skimReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: skimReturn) -> Self {
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl skimReturn {
-            fn _tokenize(&self) -> <skimCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for skimCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = skimReturn;
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [188u8, 37u8, 207u8, 119u8];
-            const SIGNATURE: &'static str = "skim(address)";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -4456,14 +3362,32 @@ pub mod ISwaprPair {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                        &self.owner,
                     ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                skimReturn::_tokenize(ret)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5326,145 +4250,6 @@ pub mod ISwaprPair {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
-    ```solidity
-    function totalSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: totalSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: totalSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
     ```solidity
     function transfer(address to, uint256 value) external returns (bool);
@@ -5797,10 +4582,6 @@ pub mod ISwaprPair {
         #[allow(missing_docs)]
         DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
         #[allow(missing_docs)]
-        MINIMUM_LIQUIDITY(MINIMUM_LIQUIDITYCall),
-        #[allow(missing_docs)]
-        PERMIT_TYPEHASH(PERMIT_TYPEHASHCall),
-        #[allow(missing_docs)]
         allowance(allowanceCall),
         #[allow(missing_docs)]
         approve(approveCall),
@@ -5817,8 +4598,6 @@ pub mod ISwaprPair {
         #[allow(missing_docs)]
         initialize(initializeCall),
         #[allow(missing_docs)]
-        kLast(kLastCall),
-        #[allow(missing_docs)]
         mint(mintCall),
         #[allow(missing_docs)]
         name(nameCall),
@@ -5827,14 +4606,6 @@ pub mod ISwaprPair {
         #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        price0CumulativeLast(price0CumulativeLastCall),
-        #[allow(missing_docs)]
-        price1CumulativeLast(price1CumulativeLastCall),
-        #[allow(missing_docs)]
-        setSwapFee(setSwapFeeCall),
-        #[allow(missing_docs)]
-        skim(skimCall),
-        #[allow(missing_docs)]
         swap(swapCall),
         #[allow(missing_docs)]
         swapFee(swapFeeCall),
@@ -5847,8 +4618,6 @@ pub mod ISwaprPair {
         #[allow(missing_docs)]
         token1(token1Call),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -5867,28 +4636,20 @@ pub mod ISwaprPair {
             [9u8, 2u8, 241u8, 172u8],
             [9u8, 94u8, 167u8, 179u8],
             [13u8, 254u8, 22u8, 129u8],
-            [24u8, 22u8, 13u8, 221u8],
             [35u8, 184u8, 114u8, 221u8],
-            [48u8, 173u8, 248u8, 31u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
             [72u8, 92u8, 201u8, 85u8],
             [84u8, 207u8, 42u8, 235u8],
-            [89u8, 9u8, 192u8, 213u8],
-            [90u8, 61u8, 84u8, 147u8],
             [106u8, 98u8, 120u8, 66u8],
             [112u8, 160u8, 130u8, 49u8],
-            [116u8, 100u8, 252u8, 61u8],
             [126u8, 206u8, 190u8, 0u8],
             [137u8, 175u8, 203u8, 68u8],
             [149u8, 216u8, 155u8, 65u8],
             [169u8, 5u8, 156u8, 187u8],
-            [186u8, 154u8, 122u8, 86u8],
-            [188u8, 37u8, 207u8, 119u8],
             [196u8, 90u8, 1u8, 85u8],
             [210u8, 18u8, 32u8, 167u8],
             [213u8, 5u8, 172u8, 207u8],
-            [214u8, 215u8, 136u8, 195u8],
             [221u8, 98u8, 237u8, 62u8],
             [255u8, 246u8, 202u8, 233u8],
         ];
@@ -5899,28 +4660,20 @@ pub mod ISwaprPair {
             <getReservesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
             <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
             <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapFeeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <price0CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <price1CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
             <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <kLastCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <burnCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <skimCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
             <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setSwapFeeCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
             <syncCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
@@ -5931,28 +4684,20 @@ pub mod ISwaprPair {
             ::core::stringify!(getReserves),
             ::core::stringify!(approve),
             ::core::stringify!(token0),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(transferFrom),
-            ::core::stringify!(PERMIT_TYPEHASH),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
             ::core::stringify!(initialize),
             ::core::stringify!(swapFee),
-            ::core::stringify!(price0CumulativeLast),
-            ::core::stringify!(price1CumulativeLast),
             ::core::stringify!(mint),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(kLast),
             ::core::stringify!(nonces),
             ::core::stringify!(burn),
             ::core::stringify!(symbol),
             ::core::stringify!(transfer),
-            ::core::stringify!(MINIMUM_LIQUIDITY),
-            ::core::stringify!(skim),
             ::core::stringify!(factory),
             ::core::stringify!(token1),
             ::core::stringify!(permit),
-            ::core::stringify!(setSwapFee),
             ::core::stringify!(allowance),
             ::core::stringify!(sync),
         ];
@@ -5979,7 +4724,7 @@ pub mod ISwaprPair {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for ISwaprPairCalls {
-        const COUNT: usize = 29usize;
+        const COUNT: usize = 21usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "ISwaprPairCalls";
 
@@ -5989,12 +4734,6 @@ pub mod ISwaprPair {
                 Self::DOMAIN_SEPARATOR(_) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::MINIMUM_LIQUIDITY(_) => {
-                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::PERMIT_TYPEHASH(_) => {
-                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
@@ -6003,26 +4742,16 @@ pub mod ISwaprPair {
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getReserves(_) => <getReservesCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::kLast(_) => <kLastCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::price0CumulativeLast(_) => {
-                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::price1CumulativeLast(_) => {
-                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setSwapFee(_) => <setSwapFeeCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::skim(_) => <skimCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::swapFee(_) => <swapFeeCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::sync(_) => <syncCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -6077,13 +4806,6 @@ pub mod ISwaprPair {
                     }
                     token0
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6091,13 +4813,6 @@ pub mod ISwaprPair {
                     }
                     transferFrom
                 },
-                {
-                    fn PERMIT_TYPEHASH(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::PERMIT_TYPEHASH)
-                    }
-                    PERMIT_TYPEHASH
-                },
                 {
                     fn decimals(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6126,24 +4841,6 @@ pub mod ISwaprPair {
                     }
                     swapFee
                 },
-                {
-                    fn price0CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::price0CumulativeLast)
-                    }
-                    price0CumulativeLast
-                },
-                {
-                    fn price1CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::price1CumulativeLast)
-                    }
-                    price1CumulativeLast
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6158,13 +4855,6 @@ pub mod ISwaprPair {
                     }
                     balanceOf
                 },
-                {
-                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::kLast)
-                    }
-                    kLast
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6193,20 +4883,6 @@ pub mod ISwaprPair {
                     }
                     transfer
                 },
-                {
-                    fn MINIMUM_LIQUIDITY(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::MINIMUM_LIQUIDITY)
-                    }
-                    MINIMUM_LIQUIDITY
-                },
-                {
-                    fn skim(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::skim)
-                    }
-                    skim
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6228,13 +4904,6 @@ pub mod ISwaprPair {
                     }
                     permit
                 },
-                {
-                    fn setSwapFee(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <setSwapFeeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(ISwaprPairCalls::setSwapFee)
-                    }
-                    setSwapFee
-                },
                 {
                     fn allowance(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6304,13 +4973,6 @@ pub mod ISwaprPair {
                     }
                     token0
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ISwaprPairCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6320,15 +4982,6 @@ pub mod ISwaprPair {
                     }
                     transferFrom
                 },
-                {
-                    fn PERMIT_TYPEHASH(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(ISwaprPairCalls::PERMIT_TYPEHASH)
-                    }
-                    PERMIT_TYPEHASH
-                },
                 {
                     fn decimals(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6359,28 +5012,6 @@ pub mod ISwaprPair {
                     }
                     swapFee
                 },
-                {
-                    fn price0CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ISwaprPairCalls::price0CumulativeLast)
-                    }
-                    price0CumulativeLast
-                },
-                {
-                    fn price1CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ISwaprPairCalls::price1CumulativeLast)
-                    }
-                    price1CumulativeLast
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6395,13 +5026,6 @@ pub mod ISwaprPair {
                     }
                     balanceOf
                 },
-                {
-                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ISwaprPairCalls::kLast)
-                    }
-                    kLast
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6430,22 +5054,6 @@ pub mod ISwaprPair {
                     }
                     transfer
                 },
-                {
-                    fn MINIMUM_LIQUIDITY(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(ISwaprPairCalls::MINIMUM_LIQUIDITY)
-                    }
-                    MINIMUM_LIQUIDITY
-                },
-                {
-                    fn skim(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ISwaprPairCalls::skim)
-                    }
-                    skim
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6467,13 +5075,6 @@ pub mod ISwaprPair {
                     }
                     permit
                 },
-                {
-                    fn setSwapFee(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
-                        <setSwapFeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(ISwaprPairCalls::setSwapFee)
-                    }
-                    setSwapFee
-                },
                 {
                     fn allowance(data: &[u8]) -> alloy_sol_types::Result<ISwaprPairCalls> {
                         <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6504,12 +5105,6 @@ pub mod ISwaprPair {
                 Self::DOMAIN_SEPARATOR(inner) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::MINIMUM_LIQUIDITY(inner) => {
-                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::PERMIT_TYPEHASH(inner) => {
-                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6534,9 +5129,6 @@ pub mod ISwaprPair {
                 Self::initialize(inner) => {
                     <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::kLast(inner) => {
-                    <kLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6549,18 +5141,6 @@ pub mod ISwaprPair {
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::price0CumulativeLast(inner) => {
-                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::price1CumulativeLast(inner) => {
-                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setSwapFee(inner) => {
-                    <setSwapFeeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::skim(inner) => {
-                    <skimCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6579,9 +5159,6 @@ pub mod ISwaprPair {
                 Self::token1(inner) => {
                     <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6597,12 +5174,6 @@ pub mod ISwaprPair {
                 Self::DOMAIN_SEPARATOR(inner) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::MINIMUM_LIQUIDITY(inner) => {
-                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::PERMIT_TYPEHASH(inner) => {
-                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6627,9 +5198,6 @@ pub mod ISwaprPair {
                 Self::initialize(inner) => {
                     <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::kLast(inner) => {
-                    <kLastCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6642,22 +5210,6 @@ pub mod ISwaprPair {
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::price0CumulativeLast(inner) => {
-                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::price1CumulativeLast(inner) => {
-                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::setSwapFee(inner) => {
-                    <setSwapFeeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::skim(inner) => {
-                    <skimCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6676,9 +5228,6 @@ pub mod ISwaprPair {
                 Self::token1(inner) => {
                     <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6973,20 +5522,6 @@ pub mod ISwaprPair {
             self.call_builder(&DOMAIN_SEPARATORCall)
         }
 
-        ///Creates a new call builder for the [`MINIMUM_LIQUIDITY`] function.
-        pub fn MINIMUM_LIQUIDITY(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, MINIMUM_LIQUIDITYCall, N> {
-            self.call_builder(&MINIMUM_LIQUIDITYCall)
-        }
-
-        ///Creates a new call builder for the [`PERMIT_TYPEHASH`] function.
-        pub fn PERMIT_TYPEHASH(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, PERMIT_TYPEHASHCall, N> {
-            self.call_builder(&PERMIT_TYPEHASHCall)
-        }
-
         ///Creates a new call builder for the [`allowance`] function.
         pub fn allowance(
             &self,
@@ -7045,11 +5580,6 @@ pub mod ISwaprPair {
             self.call_builder(&initializeCall { _0, _1 })
         }
 
-        ///Creates a new call builder for the [`kLast`] function.
-        pub fn kLast(&self) -> alloy_contract::SolCallBuilder<&P, kLastCall, N> {
-            self.call_builder(&kLastCall)
-        }
-
         ///Creates a new call builder for the [`mint`] function.
         pub fn mint(
             &self,
@@ -7093,35 +5623,6 @@ pub mod ISwaprPair {
             })
         }
 
-        ///Creates a new call builder for the [`price0CumulativeLast`]
-        /// function.
-        pub fn price0CumulativeLast(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, price0CumulativeLastCall, N> {
-            self.call_builder(&price0CumulativeLastCall)
-        }
-
-        ///Creates a new call builder for the [`price1CumulativeLast`]
-        /// function.
-        pub fn price1CumulativeLast(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, price1CumulativeLastCall, N> {
-            self.call_builder(&price1CumulativeLastCall)
-        }
-
-        ///Creates a new call builder for the [`setSwapFee`] function.
-        pub fn setSwapFee(&self, _0: u32) -> alloy_contract::SolCallBuilder<&P, setSwapFeeCall, N> {
-            self.call_builder(&setSwapFeeCall(_0))
-        }
-
-        ///Creates a new call builder for the [`skim`] function.
-        pub fn skim(
-            &self,
-            to: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, skimCall, N> {
-            self.call_builder(&skimCall { to })
-        }
-
         ///Creates a new call builder for the [`swap`] function.
         pub fn swap(
             &self,
@@ -7163,11 +5664,6 @@ pub mod ISwaprPair {
             self.call_builder(&token1Call)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs b/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs
index 1922d1d1b6..c15f524821 100644
--- a/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs
+++ b/contracts/generated/contracts-generated/iuniswaplikepair/src/lib.rs
@@ -19,8 +19,6 @@ interface IUniswapLikePair {
     event Transfer(address indexed from, address indexed to, uint256 value);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function MINIMUM_LIQUIDITY() external pure returns (uint256);
-    function PERMIT_TYPEHASH() external pure returns (bytes32);
     function allowance(address owner, address spender) external view returns (uint256);
     function approve(address spender, uint256 value) external returns (bool);
     function balanceOf(address owner) external view returns (uint256);
@@ -29,20 +27,15 @@ interface IUniswapLikePair {
     function factory() external view returns (address);
     function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
     function initialize(address, address) external;
-    function kLast() external view returns (uint256);
     function mint(address to) external returns (uint256 liquidity);
     function name() external pure returns (string memory);
     function nonces(address owner) external view returns (uint256);
     function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function price0CumulativeLast() external view returns (uint256);
-    function price1CumulativeLast() external view returns (uint256);
-    function skim(address to) external;
     function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes memory data) external;
     function symbol() external pure returns (string memory);
     function sync() external;
     function token0() external view returns (address);
     function token1() external view returns (address);
-    function totalSupply() external view returns (uint256);
     function transfer(address to, uint256 value) external returns (bool);
     function transferFrom(address from, address to, uint256 value) external returns (bool);
 }
@@ -64,32 +57,6 @@ interface IUniswapLikePair {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "MINIMUM_LIQUIDITY",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "PERMIT_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "pure"
-  },
   {
     "type": "function",
     "name": "allowance",
@@ -248,19 +215,6 @@ interface IUniswapLikePair {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "kLast",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "mint",
@@ -355,45 +309,6 @@ interface IUniswapLikePair {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "price0CumulativeLast",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "price1CumulativeLast",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "skim",
-    "inputs": [
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "swap",
@@ -468,19 +383,6 @@ interface IUniswapLikePair {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -1640,19 +1542,24 @@ pub mod IUniswapLikePair {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `MINIMUM_LIQUIDITY()` and selector `0xba9a7a56`.
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
     ```solidity
-    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MINIMUM_LIQUIDITYCall;
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`MINIMUM_LIQUIDITY()`](MINIMUM_LIQUIDITYCall) function.
+    /// [`allowance(address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MINIMUM_LIQUIDITYReturn {
+    pub struct allowanceReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -1667,9 +1574,15 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1681,16 +1594,19 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MINIMUM_LIQUIDITYCall> for UnderlyingRustTuple<'_> {
-                fn from(value: MINIMUM_LIQUIDITYCall) -> Self {
-                    ()
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value.owner, value.spender)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                    }
                 }
             }
         }
@@ -1711,29 +1627,32 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<MINIMUM_LIQUIDITYReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: MINIMUM_LIQUIDITYReturn) -> Self {
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for MINIMUM_LIQUIDITYReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for MINIMUM_LIQUIDITYCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [186u8, 154u8, 122u8, 86u8];
-            const SIGNATURE: &'static str = "MINIMUM_LIQUIDITY()";
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -1744,7 +1663,14 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                )
             }
 
             #[inline]
@@ -1760,7 +1686,7 @@ pub mod IUniswapLikePair {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: MINIMUM_LIQUIDITYReturn = r.into();
+                        let r: allowanceReturn = r.into();
                         r._0
                     },
                 )
@@ -1772,28 +1698,33 @@ pub mod IUniswapLikePair {
                     data,
                 )
                 .map(|r| {
-                    let r: MINIMUM_LIQUIDITYReturn = r.into();
+                    let r: allowanceReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `PERMIT_TYPEHASH()` and selector `0x30adf81f`.
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
     ```solidity
-    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function approve(address spender, uint256 value) external returns (bool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct PERMIT_TYPEHASHCall;
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`PERMIT_TYPEHASH()`](PERMIT_TYPEHASHCall) function.
+    /// [`approve(address,uint256)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct PERMIT_TYPEHASHReturn {
+    pub struct approveReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub _0: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -1806,9 +1737,15 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1820,25 +1757,28 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<PERMIT_TYPEHASHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: PERMIT_TYPEHASHCall) -> Self {
-                    ()
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.value)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        spender: tuple.0,
+                        value: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
+            type UnderlyingRustTuple<'a> = (bool,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1850,29 +1790,32 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<PERMIT_TYPEHASHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: PERMIT_TYPEHASHReturn) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for PERMIT_TYPEHASHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for PERMIT_TYPEHASHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [48u8, 173u8, 248u8, 31u8];
-            const SIGNATURE: &'static str = "PERMIT_TYPEHASH()";
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -1883,23 +1826,26 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.value,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: PERMIT_TYPEHASHReturn = r.into();
+                        let r: approveReturn = r.into();
                         r._0
                     },
                 )
@@ -1911,31 +1857,29 @@ pub mod IUniswapLikePair {
                     data,
                 )
                 .map(|r| {
-                    let r: PERMIT_TYPEHASHReturn = r.into();
+                    let r: approveReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
     ```solidity
-    function allowance(address owner, address spender) external view returns (uint256);
+    function balanceOf(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceCall {
+    pub struct balanceOfCall {
         #[allow(missing_docs)]
         pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`allowance(address,address)`](allowanceCall) function.
+    /// [`balanceOf(address)`](balanceOfCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceReturn {
+    pub struct balanceOfReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -1950,15 +1894,9 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1970,19 +1908,16 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value.owner, value.spender)
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                    }
+                    Self { owner: tuple.0 }
                 }
             }
         }
@@ -2003,32 +1938,29 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "allowance(address,address)";
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
 
             #[inline]
             fn new<'a>(
@@ -2043,9 +1975,6 @@ pub mod IUniswapLikePair {
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.owner,
                     ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
                 )
             }
 
@@ -2062,7 +1991,7 @@ pub mod IUniswapLikePair {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: allowanceReturn = r.into();
+                        let r: balanceOfReturn = r.into();
                         r._0
                     },
                 )
@@ -2074,33 +2003,33 @@ pub mod IUniswapLikePair {
                     data,
                 )
                 .map(|r| {
-                    let r: allowanceReturn = r.into();
+                    let r: balanceOfReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    /**Function with signature `burn(address)` and selector `0x89afcb44`.
     ```solidity
-    function approve(address spender, uint256 value) external returns (bool);
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
+    pub struct burnCall {
         #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        pub to: alloy_sol_types::private::Address,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`approve(address,uint256)`](approveCall) function.
+    /// [`burn(address)`](burnCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveReturn {
+    pub struct burnReturn {
         #[allow(missing_docs)]
-        pub _0: bool,
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -2113,15 +2042,9 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2133,28 +2056,31 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.spender, value.value)
+            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
+                fn from(value: burnCall) -> Self {
+                    (value.to,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        spender: tuple.0,
-                        value: tuple.1,
-                    }
+                    Self { to: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2166,32 +2092,47 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: burnReturn) -> Self {
+                    (value.amount0, value.amount1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
                 }
             }
         }
+        impl burnReturn {
+            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
+        impl alloy_sol_types::SolCall for burnCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = burnReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
-            const SIGNATURE: &'static str = "approve(address,uint256)";
+            const SELECTOR: [u8; 4] = [137u8, 175u8, 203u8, 68u8];
+            const SIGNATURE: &'static str = "burn(address)";
 
             #[inline]
             fn new<'a>(
@@ -2204,27 +2145,20 @@ pub mod IUniswapLikePair {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
+                        &self.to,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+                burnReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: approveReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2232,32 +2166,26 @@ pub mod IUniswapLikePair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: approveReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    /**Function with signature `decimals()` and selector `0x313ce567`.
     ```solidity
-    function balanceOf(address owner) external view returns (uint256);
+    function decimals() external pure returns (uint8);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct balanceOfCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
+    pub struct decimalsCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`balanceOf(address)`](balanceOfCall) function.
+    /// [`decimals()`](decimalsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct balanceOfReturn {
+    pub struct decimalsReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: u8,
     }
     #[allow(
         non_camel_case_types,
@@ -2270,9 +2198,9 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2284,25 +2212,25 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfCall) -> Self {
-                    (value.owner,)
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (u8,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2314,29 +2242,29 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: balanceOfReturn) -> Self {
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for balanceOfCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
-            const SIGNATURE: &'static str = "balanceOf(address)";
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
 
             #[inline]
             fn new<'a>(
@@ -2347,27 +2275,19 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: balanceOfReturn = r.into();
+                        let r: decimalsReturn = r.into();
                         r._0
                     },
                 )
@@ -2379,33 +2299,28 @@ pub mod IUniswapLikePair {
                     data,
                 )
                 .map(|r| {
-                    let r: balanceOfReturn = r.into();
+                    let r: decimalsReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `burn(address)` and selector `0x89afcb44`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+    function factory() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct burnCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-    }
+    pub struct factoryCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`burn(address)`](burnCall) function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct burnReturn {
-        #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct factoryReturn {
         #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -2418,9 +2333,9 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2432,31 +2347,25 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<burnCall> for UnderlyingRustTuple<'_> {
-                fn from(value: burnCall) -> Self {
-                    (value.to,)
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { to: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2468,47 +2377,29 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<burnReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: burnReturn) -> Self {
-                    (value.amount0, value.amount1)
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount0: tuple.0,
-                        amount1: tuple.1,
-                    }
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl burnReturn {
-            fn _tokenize(&self) -> <burnCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
-                    ),
-                )
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for burnCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = burnReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [137u8, 175u8, 203u8, 68u8];
-            const SIGNATURE: &'static str = "burn(address)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -2519,22 +2410,22 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                burnReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -2542,26 +2433,33 @@ pub mod IUniswapLikePair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `decimals()` and selector `0x313ce567`.
+    /**Function with signature `getReserves()` and selector `0x0902f1ac`.
     ```solidity
-    function decimals() external pure returns (uint8);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decimalsCall;
+    pub struct getReservesCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`decimals()`](decimalsCall) function.
+    /// [`getReserves()`](getReservesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct decimalsReturn {
+    pub struct getReservesReturn {
         #[allow(missing_docs)]
-        pub _0: u8,
+        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+        #[allow(missing_docs)]
+        pub blockTimestampLast: u32,
     }
     #[allow(
         non_camel_case_types,
@@ -2588,14 +2486,14 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsCall) -> Self {
+            impl ::core::convert::From<getReservesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -2604,9 +2502,17 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U112,
+                alloy_sol_types::private::primitives::aliases::U112,
+                u32,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2618,29 +2524,52 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: decimalsReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<getReservesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getReservesReturn) -> Self {
+                    (value.reserve0, value.reserve1, value.blockTimestampLast)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        reserve0: tuple.0,
+                        reserve1: tuple.1,
+                        blockTimestampLast: tuple.2,
+                    }
                 }
             }
         }
+        impl getReservesReturn {
+            fn _tokenize(&self) -> <getReservesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserve1,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockTimestampLast,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for decimalsCall {
+        impl alloy_sol_types::SolCall for getReservesCall {
             type Parameters<'a> = ();
-            type Return = u8;
+            type Return = getReservesReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<112>,
+                alloy_sol_types::sol_data::Uint<32>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
-            const SIGNATURE: &'static str = "decimals()";
+            const SELECTOR: [u8; 4] = [9u8, 2u8, 241u8, 172u8];
+            const SIGNATURE: &'static str = "getReserves()";
 
             #[inline]
             fn new<'a>(
@@ -2656,17 +2585,13 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+                getReservesReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: decimalsReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2674,30 +2599,28 @@ pub mod IUniswapLikePair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: decimalsReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
+    /**Function with signature `initialize(address,address)` and selector `0x485cc955`.
     ```solidity
-    function factory() external view returns (address);
+    function initialize(address, address) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
+    pub struct initializeCall {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
     }
+    ///Container type for the return parameters of the
+    /// [`initialize(address,address)`](initializeCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct initializeReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -2709,9 +2632,15 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2723,25 +2652,28 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
+            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeCall) -> Self {
+                    (value._0, value._1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2753,29 +2685,37 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl initializeReturn {
+            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
+        impl alloy_sol_types::SolCall for initializeCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = initializeReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
+            const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
+            const SIGNATURE: &'static str = "initialize(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -2786,22 +2726,25 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+                initializeReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -2809,33 +2752,29 @@ pub mod IUniswapLikePair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getReserves()` and selector `0x0902f1ac`.
+    /**Function with signature `mint(address)` and selector `0x6a627842`.
     ```solidity
-    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    function mint(address to) external returns (uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getReservesCall;
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`getReserves()`](getReservesCall) function.
+    /// [`mint(address)`](mintCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct getReservesReturn {
-        #[allow(missing_docs)]
-        pub reserve0: alloy_sol_types::private::primitives::aliases::U112,
-        #[allow(missing_docs)]
-        pub reserve1: alloy_sol_types::private::primitives::aliases::U112,
+    pub struct mintReturn {
         #[allow(missing_docs)]
-        pub blockTimestampLast: u32,
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -2847,916 +2786,10 @@ pub mod IUniswapLikePair {
         use alloy_sol_types;
         {
             #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getReservesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getReservesCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U112,
-                alloy_sol_types::private::primitives::aliases::U112,
-                u32,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getReservesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getReservesReturn) -> Self {
-                    (value.reserve0, value.reserve1, value.blockTimestampLast)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getReservesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        reserve0: tuple.0,
-                        reserve1: tuple.1,
-                        blockTimestampLast: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getReservesReturn {
-            fn _tokenize(&self) -> <getReservesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserve0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<112> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserve1,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        &self.blockTimestampLast,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getReservesCall {
-            type Parameters<'a> = ();
-            type Return = getReservesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<112>,
-                alloy_sol_types::sol_data::Uint<32>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 2u8, 241u8, 172u8];
-            const SIGNATURE: &'static str = "getReserves()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getReservesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `initialize(address,address)` and selector `0x485cc955`.
-    ```solidity
-    function initialize(address, address) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct initializeCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`initialize(address,address)`](initializeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct initializeReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: initializeCall) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: initializeReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl initializeReturn {
-            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for initializeCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = initializeReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
-            const SIGNATURE: &'static str = "initialize(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                initializeReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `kLast()` and selector `0x7464fc3d`.
-    ```solidity
-    function kLast() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct kLastCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`kLast()`](kLastCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct kLastReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<kLastCall> for UnderlyingRustTuple<'_> {
-                fn from(value: kLastCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<kLastReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: kLastReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for kLastReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for kLastCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [116u8, 100u8, 252u8, 61u8];
-            const SIGNATURE: &'static str = "kLast()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: kLastReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: kLastReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `mint(address)` and selector `0x6a627842`.
-    ```solidity
-    function mint(address to) external returns (uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintCall {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`mint(address)`](mintCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintReturn {
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
-                fn from(value: mintCall) -> Self {
-                    (value.to,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { to: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: mintReturn) -> Self {
-                    (value.liquidity,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { liquidity: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for mintCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [106u8, 98u8, 120u8, 66u8];
-            const SIGNATURE: &'static str = "mint(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: mintReturn = r.into();
-                        r.liquidity
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: mintReturn = r.into();
-                    r.liquidity
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `name()` and selector `0x06fdde03`.
-    ```solidity
-    function name() external pure returns (string memory);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`name()`](nameCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct nameReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::String,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nameCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nameReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for nameCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::String;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
-            const SIGNATURE: &'static str = "name()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: nameReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: nameReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
-    ```solidity
-    function nonces(address owner) external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`nonces(address)`](noncesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct noncesReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesCall) -> Self {
-                    (value.owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: noncesReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for noncesCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
-            const SIGNATURE: &'static str = "nonces(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: noncesReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: noncesReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
-    ```solidity
-    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitCall {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    ///Container type for the return parameters of the
-    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
-    /// bytes32)`](permitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct permitReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3768,41 +2801,25 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (
-                        value.owner,
-                        value.spender,
-                        value.value,
-                        value.deadline,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.to,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        owner: tuple.0,
-                        spender: tuple.1,
-                        value: tuple.2,
-                        deadline: tuple.3,
-                        v: tuple.4,
-                        r: tuple.5,
-                        s: tuple.6,
-                    }
+                    Self { to: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3814,43 +2831,29 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value.liquidity,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { liquidity: tuple.0 }
                 }
             }
         }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = permitReturn;
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
-            const SIGNATURE: &'static str =
-                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
+            const SELECTOR: [u8; 4] = [106u8, 98u8, 120u8, 66u8];
+            const SIGNATURE: &'static str = "mint(address)";
 
             #[inline]
             fn new<'a>(
@@ -3863,38 +2866,28 @@ pub mod IUniswapLikePair {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
+                        &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: mintReturn = r.into();
+                        r.liquidity
+                    },
+                )
             }
 
             #[inline]
@@ -3902,26 +2895,29 @@ pub mod IUniswapLikePair {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: mintReturn = r.into();
+                    r.liquidity
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `price0CumulativeLast()` and selector `0x5909c0d5`.
+    /**Function with signature `name()` and selector `0x06fdde03`.
     ```solidity
-    function price0CumulativeLast() external view returns (uint256);
+    function name() external pure returns (string memory);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price0CumulativeLastCall;
+    pub struct nameCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`price0CumulativeLast()`](price0CumulativeLastCall) function.
+    ///Container type for the return parameters of the [`name()`](nameCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price0CumulativeLastReturn {
+    pub struct nameReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::String,
     }
     #[allow(
         non_camel_case_types,
@@ -3948,14 +2944,14 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price0CumulativeLastCall> for UnderlyingRustTuple<'_> {
-                fn from(value: price0CumulativeLastCall) -> Self {
+            impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
+                fn from(value: nameCall) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self
                 }
@@ -3964,9 +2960,9 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::String,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::String,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3978,29 +2974,29 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price0CumulativeLastReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: price0CumulativeLastReturn) -> Self {
+            impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: nameReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price0CumulativeLastReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for price0CumulativeLastCall {
+        impl alloy_sol_types::SolCall for nameCall {
             type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type Return = alloy_sol_types::private::String;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::String,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [89u8, 9u8, 192u8, 213u8];
-            const SIGNATURE: &'static str = "price0CumulativeLast()";
+            const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
+            const SIGNATURE: &'static str = "name()";
 
             #[inline]
             fn new<'a>(
@@ -4016,18 +3012,14 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: price0CumulativeLastReturn = r.into();
+                        let r: nameReturn = r.into();
                         r._0
                     },
                 )
@@ -4039,26 +3031,29 @@ pub mod IUniswapLikePair {
                     data,
                 )
                 .map(|r| {
-                    let r: price0CumulativeLastReturn = r.into();
+                    let r: nameReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `price1CumulativeLast()` and selector `0x5a3d5493`.
+    /**Function with signature `nonces(address)` and selector `0x7ecebe00`.
     ```solidity
-    function price1CumulativeLast() external view returns (uint256);
+    function nonces(address owner) external view returns (uint256);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price1CumulativeLastCall;
+    pub struct noncesCall {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`price1CumulativeLast()`](price1CumulativeLastCall) function.
+    /// [`nonces(address)`](noncesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct price1CumulativeLastReturn {
+    pub struct noncesReturn {
         #[allow(missing_docs)]
         pub _0: alloy_sol_types::private::primitives::aliases::U256,
     }
@@ -4073,9 +3068,9 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4087,16 +3082,16 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price1CumulativeLastCall> for UnderlyingRustTuple<'_> {
-                fn from(value: price1CumulativeLastCall) -> Self {
-                    ()
+            impl ::core::convert::From<noncesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesCall) -> Self {
+                    (value.owner,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self { owner: tuple.0 }
                 }
             }
         }
@@ -4117,29 +3112,29 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<price1CumulativeLastReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: price1CumulativeLastReturn) -> Self {
+            impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: noncesReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for price1CumulativeLastReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for price1CumulativeLastCall {
-            type Parameters<'a> = ();
+        impl alloy_sol_types::SolCall for noncesCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [90u8, 61u8, 84u8, 147u8];
-            const SIGNATURE: &'static str = "price1CumulativeLast()";
+            const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
+            const SIGNATURE: &'static str = "nonces(address)";
 
             #[inline]
             fn new<'a>(
@@ -4150,7 +3145,11 @@ pub mod IUniswapLikePair {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.owner,
+                    ),
+                )
             }
 
             #[inline]
@@ -4166,7 +3165,7 @@ pub mod IUniswapLikePair {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: price1CumulativeLastReturn = r.into();
+                        let r: noncesReturn = r.into();
                         r._0
                     },
                 )
@@ -4178,28 +3177,41 @@ pub mod IUniswapLikePair {
                     data,
                 )
                 .map(|r| {
-                    let r: price1CumulativeLastReturn = r.into();
+                    let r: noncesReturn = r.into();
                     r._0
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `skim(address)` and selector `0xbc25cf77`.
+    /**Function with signature `permit(address,address,uint256,uint256,uint8,bytes32,bytes32)` and selector `0xd505accf`.
     ```solidity
-    function skim(address to) external;
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct skimCall {
+    pub struct permitCall {
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
     }
     ///Container type for the return parameters of the
-    /// [`skim(address)`](skimCall) function.
+    /// [`permit(address,address,uint256,uint256,uint8,bytes32,
+    /// bytes32)`](permitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct skimReturn {}
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4211,9 +3223,25 @@ pub mod IUniswapLikePair {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u8,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::FixedBytes<32>,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4225,16 +3253,32 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<skimCall> for UnderlyingRustTuple<'_> {
-                fn from(value: skimCall) -> Self {
-                    (value.to,)
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (
+                        value.owner,
+                        value.spender,
+                        value.value,
+                        value.deadline,
+                        value.v,
+                        value.r,
+                        value.s,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { to: tuple.0 }
+                    Self {
+                        owner: tuple.0,
+                        spender: tuple.1,
+                        value: tuple.2,
+                        deadline: tuple.3,
+                        v: tuple.4,
+                        r: tuple.5,
+                        s: tuple.6,
+                    }
                 }
             }
         }
@@ -4255,34 +3299,43 @@ pub mod IUniswapLikePair {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<skimReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: skimReturn) -> Self {
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for skimReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl skimReturn {
-            fn _tokenize(&self) -> <skimCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for skimCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = skimReturn;
+        impl alloy_sol_types::SolCall for permitCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [188u8, 37u8, 207u8, 119u8];
-            const SIGNATURE: &'static str = "skim(address)";
+            const SELECTOR: [u8; 4] = [213u8, 5u8, 172u8, 207u8];
+            const SIGNATURE: &'static str =
+                "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -4295,14 +3348,32 @@ pub mod IUniswapLikePair {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                        &self.owner,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
                     ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                skimReturn::_tokenize(ret)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5026,145 +4097,6 @@ pub mod IUniswapLikePair {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
-    ```solidity
-    function totalSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: totalSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: totalSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
     ```solidity
     function transfer(address to, uint256 value) external returns (bool);
@@ -5497,10 +4429,6 @@ pub mod IUniswapLikePair {
         #[allow(missing_docs)]
         DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
         #[allow(missing_docs)]
-        MINIMUM_LIQUIDITY(MINIMUM_LIQUIDITYCall),
-        #[allow(missing_docs)]
-        PERMIT_TYPEHASH(PERMIT_TYPEHASHCall),
-        #[allow(missing_docs)]
         allowance(allowanceCall),
         #[allow(missing_docs)]
         approve(approveCall),
@@ -5517,8 +4445,6 @@ pub mod IUniswapLikePair {
         #[allow(missing_docs)]
         initialize(initializeCall),
         #[allow(missing_docs)]
-        kLast(kLastCall),
-        #[allow(missing_docs)]
         mint(mintCall),
         #[allow(missing_docs)]
         name(nameCall),
@@ -5527,12 +4453,6 @@ pub mod IUniswapLikePair {
         #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        price0CumulativeLast(price0CumulativeLastCall),
-        #[allow(missing_docs)]
-        price1CumulativeLast(price1CumulativeLastCall),
-        #[allow(missing_docs)]
-        skim(skimCall),
-        #[allow(missing_docs)]
         swap(swapCall),
         #[allow(missing_docs)]
         symbol(symbolCall),
@@ -5543,8 +4463,6 @@ pub mod IUniswapLikePair {
         #[allow(missing_docs)]
         token1(token1Call),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -5563,23 +4481,16 @@ pub mod IUniswapLikePair {
             [9u8, 2u8, 241u8, 172u8],
             [9u8, 94u8, 167u8, 179u8],
             [13u8, 254u8, 22u8, 129u8],
-            [24u8, 22u8, 13u8, 221u8],
             [35u8, 184u8, 114u8, 221u8],
-            [48u8, 173u8, 248u8, 31u8],
             [49u8, 60u8, 229u8, 103u8],
             [54u8, 68u8, 229u8, 21u8],
             [72u8, 92u8, 201u8, 85u8],
-            [89u8, 9u8, 192u8, 213u8],
-            [90u8, 61u8, 84u8, 147u8],
             [106u8, 98u8, 120u8, 66u8],
             [112u8, 160u8, 130u8, 49u8],
-            [116u8, 100u8, 252u8, 61u8],
             [126u8, 206u8, 190u8, 0u8],
             [137u8, 175u8, 203u8, 68u8],
             [149u8, 216u8, 155u8, 65u8],
             [169u8, 5u8, 156u8, 187u8],
-            [186u8, 154u8, 122u8, 86u8],
-            [188u8, 37u8, 207u8, 119u8],
             [196u8, 90u8, 1u8, 85u8],
             [210u8, 18u8, 32u8, 167u8],
             [213u8, 5u8, 172u8, 207u8],
@@ -5593,23 +4504,16 @@ pub mod IUniswapLikePair {
             <getReservesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
             <token0Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
             <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <price0CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <price1CumulativeLastCall as alloy_sol_types::SolCall>::SIGNATURE,
             <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
             <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <kLastCall as alloy_sol_types::SolCall>::SIGNATURE,
             <noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <burnCall as alloy_sol_types::SolCall>::SIGNATURE,
             <symbolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <skimCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
             <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
@@ -5623,23 +4527,16 @@ pub mod IUniswapLikePair {
             ::core::stringify!(getReserves),
             ::core::stringify!(approve),
             ::core::stringify!(token0),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(transferFrom),
-            ::core::stringify!(PERMIT_TYPEHASH),
             ::core::stringify!(decimals),
             ::core::stringify!(DOMAIN_SEPARATOR),
             ::core::stringify!(initialize),
-            ::core::stringify!(price0CumulativeLast),
-            ::core::stringify!(price1CumulativeLast),
             ::core::stringify!(mint),
             ::core::stringify!(balanceOf),
-            ::core::stringify!(kLast),
             ::core::stringify!(nonces),
             ::core::stringify!(burn),
             ::core::stringify!(symbol),
             ::core::stringify!(transfer),
-            ::core::stringify!(MINIMUM_LIQUIDITY),
-            ::core::stringify!(skim),
             ::core::stringify!(factory),
             ::core::stringify!(token1),
             ::core::stringify!(permit),
@@ -5669,7 +4566,7 @@ pub mod IUniswapLikePair {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for IUniswapLikePairCalls {
-        const COUNT: usize = 27usize;
+        const COUNT: usize = 20usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "IUniswapLikePairCalls";
 
@@ -5679,12 +4576,6 @@ pub mod IUniswapLikePair {
                 Self::DOMAIN_SEPARATOR(_) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::MINIMUM_LIQUIDITY(_) => {
-                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::PERMIT_TYPEHASH(_) => {
-                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
@@ -5693,24 +4584,15 @@ pub mod IUniswapLikePair {
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getReserves(_) => <getReservesCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::kLast(_) => <kLastCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::price0CumulativeLast(_) => {
-                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::price1CumulativeLast(_) => {
-                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::skim(_) => <skimCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::sync(_) => <syncCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
@@ -5765,13 +4647,6 @@ pub mod IUniswapLikePair {
                     }
                     token0
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5779,15 +4654,6 @@ pub mod IUniswapLikePair {
                     }
                     transferFrom
                 },
-                {
-                    fn PERMIT_TYPEHASH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::PERMIT_TYPEHASH)
-                    }
-                    PERMIT_TYPEHASH
-                },
                 {
                     fn decimals(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5811,24 +4677,6 @@ pub mod IUniswapLikePair {
                     }
                     initialize
                 },
-                {
-                    fn price0CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::price0CumulativeLast)
-                    }
-                    price0CumulativeLast
-                },
-                {
-                    fn price1CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::price1CumulativeLast)
-                    }
-                    price1CumulativeLast
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5843,13 +4691,6 @@ pub mod IUniswapLikePair {
                     }
                     balanceOf
                 },
-                {
-                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::kLast)
-                    }
-                    kLast
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5878,22 +4719,6 @@ pub mod IUniswapLikePair {
                     }
                     transfer
                 },
-                {
-                    fn MINIMUM_LIQUIDITY(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::MINIMUM_LIQUIDITY)
-                    }
-                    MINIMUM_LIQUIDITY
-                },
-                {
-                    fn skim(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikePairCalls::skim)
-                    }
-                    skim
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -5985,13 +4810,6 @@ pub mod IUniswapLikePair {
                     }
                     token0
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IUniswapLikePairCalls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6001,17 +4819,6 @@ pub mod IUniswapLikePair {
                     }
                     transferFrom
                 },
-                {
-                    fn PERMIT_TYPEHASH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapLikePairCalls::PERMIT_TYPEHASH)
-                    }
-                    PERMIT_TYPEHASH
-                },
                 {
                     fn decimals(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6037,28 +4844,6 @@ pub mod IUniswapLikePair {
                     }
                     initialize
                 },
-                {
-                    fn price0CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikePairCalls::price0CumulativeLast)
-                    }
-                    price0CumulativeLast
-                },
-                {
-                    fn price1CumulativeLast(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikePairCalls::price1CumulativeLast)
-                    }
-                    price1CumulativeLast
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6073,13 +4858,6 @@ pub mod IUniswapLikePair {
                     }
                     balanceOf
                 },
-                {
-                    fn kLast(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <kLastCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IUniswapLikePairCalls::kLast)
-                    }
-                    kLast
-                },
                 {
                     fn nonces(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6108,24 +4886,6 @@ pub mod IUniswapLikePair {
                     }
                     transfer
                 },
-                {
-                    fn MINIMUM_LIQUIDITY(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikePairCalls::MINIMUM_LIQUIDITY)
-                    }
-                    MINIMUM_LIQUIDITY
-                },
-                {
-                    fn skim(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
-                        <skimCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IUniswapLikePairCalls::skim)
-                    }
-                    skim
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikePairCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6177,12 +4937,6 @@ pub mod IUniswapLikePair {
                 Self::DOMAIN_SEPARATOR(inner) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::MINIMUM_LIQUIDITY(inner) => {
-                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::PERMIT_TYPEHASH(inner) => {
-                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6207,9 +4961,6 @@ pub mod IUniswapLikePair {
                 Self::initialize(inner) => {
                     <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::kLast(inner) => {
-                    <kLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6222,15 +4973,6 @@ pub mod IUniswapLikePair {
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::price0CumulativeLast(inner) => {
-                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::price1CumulativeLast(inner) => {
-                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::skim(inner) => {
-                    <skimCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6246,9 +4988,6 @@ pub mod IUniswapLikePair {
                 Self::token1(inner) => {
                     <token1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6264,12 +5003,6 @@ pub mod IUniswapLikePair {
                 Self::DOMAIN_SEPARATOR(inner) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::MINIMUM_LIQUIDITY(inner) => {
-                    <MINIMUM_LIQUIDITYCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::PERMIT_TYPEHASH(inner) => {
-                    <PERMIT_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::allowance(inner) => {
                     <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6294,9 +5027,6 @@ pub mod IUniswapLikePair {
                 Self::initialize(inner) => {
                     <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::kLast(inner) => {
-                    <kLastCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6309,19 +5039,6 @@ pub mod IUniswapLikePair {
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::price0CumulativeLast(inner) => {
-                    <price0CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::price1CumulativeLast(inner) => {
-                    <price1CumulativeLastCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::skim(inner) => {
-                    <skimCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6337,9 +5054,6 @@ pub mod IUniswapLikePair {
                 Self::token1(inner) => {
                     <token1Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -6634,20 +5348,6 @@ pub mod IUniswapLikePair {
             self.call_builder(&DOMAIN_SEPARATORCall)
         }
 
-        ///Creates a new call builder for the [`MINIMUM_LIQUIDITY`] function.
-        pub fn MINIMUM_LIQUIDITY(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, MINIMUM_LIQUIDITYCall, N> {
-            self.call_builder(&MINIMUM_LIQUIDITYCall)
-        }
-
-        ///Creates a new call builder for the [`PERMIT_TYPEHASH`] function.
-        pub fn PERMIT_TYPEHASH(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, PERMIT_TYPEHASHCall, N> {
-            self.call_builder(&PERMIT_TYPEHASHCall)
-        }
-
         ///Creates a new call builder for the [`allowance`] function.
         pub fn allowance(
             &self,
@@ -6706,11 +5406,6 @@ pub mod IUniswapLikePair {
             self.call_builder(&initializeCall { _0, _1 })
         }
 
-        ///Creates a new call builder for the [`kLast`] function.
-        pub fn kLast(&self) -> alloy_contract::SolCallBuilder<&P, kLastCall, N> {
-            self.call_builder(&kLastCall)
-        }
-
         ///Creates a new call builder for the [`mint`] function.
         pub fn mint(
             &self,
@@ -6754,30 +5449,6 @@ pub mod IUniswapLikePair {
             })
         }
 
-        ///Creates a new call builder for the [`price0CumulativeLast`]
-        /// function.
-        pub fn price0CumulativeLast(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, price0CumulativeLastCall, N> {
-            self.call_builder(&price0CumulativeLastCall)
-        }
-
-        ///Creates a new call builder for the [`price1CumulativeLast`]
-        /// function.
-        pub fn price1CumulativeLast(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, price1CumulativeLastCall, N> {
-            self.call_builder(&price1CumulativeLastCall)
-        }
-
-        ///Creates a new call builder for the [`skim`] function.
-        pub fn skim(
-            &self,
-            to: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, skimCall, N> {
-            self.call_builder(&skimCall { to })
-        }
-
         ///Creates a new call builder for the [`swap`] function.
         pub fn swap(
             &self,
@@ -6814,11 +5485,6 @@ pub mod IUniswapLikePair {
             self.call_builder(&token1Call)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,
diff --git a/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs b/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs
index 0e40935392..f9916afb59 100644
--- a/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/iuniswaplikerouter/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface IUniswapLikeRouter {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -118,60 +99,6 @@ interface IUniswapLikeRouter {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
   {
     "type": "function",
     "name": "factory",
@@ -185,112 +112,6 @@ interface IUniswapLikeRouter {
     ],
     "stateMutability": "pure"
   },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "quote",
@@ -322,130 +143,22 @@ interface IUniswapLikeRouter {
   },
   {
     "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "name": "swapTokensForExactTokens",
     "inputs": [
       {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
+        "name": "amountOut",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountTokenMin",
+        "name": "amountInMax",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
       },
       {
         "name": "to",
@@ -460,4237 +173,40 @@ interface IUniswapLikeRouter {
     ],
     "outputs": [
       {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IUniswapLikeRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IUniswapLikeRouter {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct WETHCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
+    pub struct WETHReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -4703,21 +219,9 @@ pub mod IUniswapLikeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4729,40 +233,25 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4774,38 +263,29 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -4816,38 +296,20 @@ pub mod IUniswapLikeRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
+                        let r: WETHReturn = r.into();
+                        r._0
                     },
                 )
             }
@@ -4857,230 +319,33 @@ pub mod IUniswapLikeRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
-    ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod IUniswapLikeRouter {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod IUniswapLikeRouter {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod IUniswapLikeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod IUniswapLikeRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod IUniswapLikeRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod IUniswapLikeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5434,35 +682,23 @@ pub mod IUniswapLikeRouter {
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod IUniswapLikeRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod IUniswapLikeRouter {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod IUniswapLikeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod IUniswapLikeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod IUniswapLikeRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod IUniswapLikeRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod IUniswapLikeRouter {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl IUniswapLikeRouterCalls {
@@ -5949,84 +1110,27 @@ pub mod IUniswapLikeRouter {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6051,7 +1155,7 @@ pub mod IUniswapLikeRouter {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for IUniswapLikeRouterCalls {
-        const COUNT: usize = 24usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "IUniswapLikeRouterCalls";
 
@@ -6059,68 +1163,9 @@ pub mod IUniswapLikeRouter {
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::swapTokensForExactTokens(_) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -6128,152 +1173,22 @@ pub mod IUniswapLikeRouter {
         }
 
         #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(
-                &[u8],
-            )
-                -> alloy_sol_types::Result<IUniswapLikeRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<IUniswapLikeRouterCalls>] = &[
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6299,41 +1214,6 @@ pub mod IUniswapLikeRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6341,26 +1221,6 @@ pub mod IUniswapLikeRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(
                         data: &[u8],
@@ -6370,26 +1230,6 @@ pub mod IUniswapLikeRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IUniswapLikeRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6411,142 +1251,6 @@ pub mod IUniswapLikeRouter {
             ) -> alloy_sol_types::Result<
                 IUniswapLikeRouterCalls,
             >] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IUniswapLikeRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6572,43 +1276,6 @@ pub mod IUniswapLikeRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                IUniswapLikeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6616,28 +1283,6 @@ pub mod IUniswapLikeRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(
                         data: &[u8],
@@ -6649,28 +1294,6 @@ pub mod IUniswapLikeRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapLikeRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapLikeRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapLikeRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6685,115 +1308,16 @@ pub mod IUniswapLikeRouter {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6810,137 +1334,17 @@ pub mod IUniswapLikeRouter {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7084,77 +1488,11 @@ pub mod IUniswapLikeRouter {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7169,327 +1507,6 @@ pub mod IUniswapLikeRouter {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
index 19886c69ec..9bcf2a8c65 100644
--- a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
+++ b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
@@ -15,84 +15,14 @@ interface IUniswapV3Factory {
     event OwnerChanged(address indexed oldOwner, address indexed newOwner);
     event PoolCreated(address indexed token0, address indexed token1, uint24 indexed fee, int24 tickSpacing, address pool);
 
-    function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);
-    function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
-    function feeAmountTickSpacing(uint24 fee) external view returns (int24);
     function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);
     function owner() external view returns (address);
-    function setOwner(address _owner) external;
 }
 ```
 
 ...which was generated by the following JSON ABI:
 ```json
 [
-  {
-    "type": "function",
-    "name": "createPool",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "fee",
-        "type": "uint24",
-        "internalType": "uint24"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pool",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "enableFeeAmount",
-    "inputs": [
-      {
-        "name": "fee",
-        "type": "uint24",
-        "internalType": "uint24"
-      },
-      {
-        "name": "tickSpacing",
-        "type": "int24",
-        "internalType": "int24"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "feeAmountTickSpacing",
-    "inputs": [
-      {
-        "name": "fee",
-        "type": "uint24",
-        "internalType": "uint24"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "int24",
-        "internalType": "int24"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getPool",
@@ -135,19 +65,6 @@ interface IUniswapV3Factory {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "setOwner",
-    "inputs": [
-      {
-        "name": "_owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "event",
     "name": "FeeAmountEnabled",
@@ -622,13 +539,13 @@ pub mod IUniswapV3Factory {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `createPool(address,address,uint24)` and selector `0xa1671295`.
+    /**Function with signature `getPool(address,address,uint24)` and selector `0x1698ee82`.
     ```solidity
-    function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);
+    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct createPoolCall {
+    pub struct getPoolCall {
         #[allow(missing_docs)]
         pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -638,10 +555,10 @@ pub mod IUniswapV3Factory {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`createPool(address,address,uint24)`](createPoolCall) function.
+    /// [`getPool(address,address,uint24)`](getPoolCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct createPoolReturn {
+    pub struct getPoolReturn {
         #[allow(missing_docs)]
         pub pool: alloy_sol_types::private::Address,
     }
@@ -678,14 +595,14 @@ pub mod IUniswapV3Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<createPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createPoolCall) -> Self {
+            impl ::core::convert::From<getPoolCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolCall) -> Self {
                     (value.tokenA, value.tokenB, value.fee)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPoolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
                         tokenA: tuple.0,
@@ -712,21 +629,21 @@ pub mod IUniswapV3Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<createPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createPoolReturn) -> Self {
+            impl ::core::convert::From<getPoolReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPoolReturn) -> Self {
                     (value.pool,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPoolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { pool: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for createPoolCall {
+        impl alloy_sol_types::SolCall for getPoolCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
@@ -737,8 +654,8 @@ pub mod IUniswapV3Factory {
             type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [161u8, 103u8, 18u8, 149u8];
-            const SIGNATURE: &'static str = "createPool(address,address,uint24)";
+            const SELECTOR: [u8; 4] = [22u8, 152u8, 238u8, 130u8];
+            const SIGNATURE: &'static str = "getPool(address,address,uint24)";
 
             #[inline]
             fn new<'a>(
@@ -771,7 +688,7 @@ pub mod IUniswapV3Factory {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: createPoolReturn = r.into();
+                        let r: getPoolReturn = r.into();
                         r.pool
                     },
                 )
@@ -783,186 +700,28 @@ pub mod IUniswapV3Factory {
                     data,
                 )
                 .map(|r| {
-                    let r: createPoolReturn = r.into();
+                    let r: getPoolReturn = r.into();
                     r.pool
                 })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `enableFeeAmount(uint24,int24)` and selector `0x8a7c195f`.
-    ```solidity
-    function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableFeeAmountCall {
-        #[allow(missing_docs)]
-        pub fee: alloy_sol_types::private::primitives::aliases::U24,
-        #[allow(missing_docs)]
-        pub tickSpacing: alloy_sol_types::private::primitives::aliases::I24,
-    }
-    ///Container type for the return parameters of the
-    /// [`enableFeeAmount(uint24,int24)`](enableFeeAmountCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct enableFeeAmountReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<24>,
-                alloy_sol_types::sol_data::Int<24>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U24,
-                alloy_sol_types::private::primitives::aliases::I24,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableFeeAmountCall> for UnderlyingRustTuple<'_> {
-                fn from(value: enableFeeAmountCall) -> Self {
-                    (value.fee, value.tickSpacing)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableFeeAmountCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        fee: tuple.0,
-                        tickSpacing: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<enableFeeAmountReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: enableFeeAmountReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for enableFeeAmountReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl enableFeeAmountReturn {
-            fn _tokenize(
-                &self,
-            ) -> <enableFeeAmountCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for enableFeeAmountCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<24>,
-                alloy_sol_types::sol_data::Int<24>,
-            );
-            type Return = enableFeeAmountReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [138u8, 124u8, 25u8, 95u8];
-            const SIGNATURE: &'static str = "enableFeeAmount(uint24,int24)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.fee,
-                    ),
-                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickSpacing,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                enableFeeAmountReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `feeAmountTickSpacing(uint24)` and selector `0x22afcccb`.
+    /**Function with signature `owner()` and selector `0x8da5cb5b`.
     ```solidity
-    function feeAmountTickSpacing(uint24 fee) external view returns (int24);
+    function owner() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct feeAmountTickSpacingCall {
-        #[allow(missing_docs)]
-        pub fee: alloy_sol_types::private::primitives::aliases::U24,
-    }
+    pub struct ownerCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`feeAmountTickSpacing(uint24)`](feeAmountTickSpacingCall) function.
+    ///Container type for the return parameters of the [`owner()`](ownerCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct feeAmountTickSpacingReturn {
+    pub struct ownerReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::I24,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -975,9 +734,9 @@ pub mod IUniswapV3Factory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<24>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U24,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -989,25 +748,25 @@ pub mod IUniswapV3Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<feeAmountTickSpacingCall> for UnderlyingRustTuple<'_> {
-                fn from(value: feeAmountTickSpacingCall) -> Self {
-                    (value.fee,)
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeAmountTickSpacingCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { fee: tuple.0 }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::I24,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1019,29 +778,29 @@ pub mod IUniswapV3Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<feeAmountTickSpacingReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: feeAmountTickSpacingReturn) -> Self {
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeAmountTickSpacingReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for feeAmountTickSpacingCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<24>,);
-            type Return = alloy_sol_types::private::primitives::aliases::I24;
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [34u8, 175u8, 204u8, 203u8];
-            const SIGNATURE: &'static str = "feeAmountTickSpacing(uint24)";
+            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
+            const SIGNATURE: &'static str = "owner()";
 
             #[inline]
             fn new<'a>(
@@ -1052,23 +811,19 @@ pub mod IUniswapV3Factory {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.fee,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: feeAmountTickSpacingReturn = r.into();
+                        let r: ownerReturn = r.into();
                         r._0
                     },
                 )
@@ -1080,466 +835,19 @@ pub mod IUniswapV3Factory {
                     data,
                 )
                 .map(|r| {
-                    let r: feeAmountTickSpacingReturn = r.into();
+                    let r: ownerReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPool(address,address,uint24)` and selector `0x1698ee82`.
-    ```solidity
-    function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub fee: alloy_sol_types::private::primitives::aliases::U24,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPool(address,address,uint24)`](getPoolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPoolReturn {
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<24>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U24,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolCall) -> Self {
-                    (value.tokenA, value.tokenB, value.fee)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        fee: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPoolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPoolReturn) -> Self {
-                    (value.pool,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPoolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pool: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPoolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<24>,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [22u8, 152u8, 238u8, 130u8];
-            const SIGNATURE: &'static str = "getPool(address,address,uint24)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.fee,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPoolReturn = r.into();
-                        r.pool
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPoolReturn = r.into();
-                    r.pool
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `owner()` and selector `0x8da5cb5b`.
-    ```solidity
-    function owner() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ownerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`owner()`](ownerCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ownerReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for ownerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
-            const SIGNATURE: &'static str = "owner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: ownerReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: ownerReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setOwner(address)` and selector `0x13af4035`.
-    ```solidity
-    function setOwner(address _owner) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setOwnerCall {
-        #[allow(missing_docs)]
-        pub _owner: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`setOwner(address)`](setOwnerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setOwnerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setOwnerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setOwnerCall) -> Self {
-                    (value._owner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setOwnerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _owner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setOwnerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setOwnerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setOwnerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setOwnerReturn {
-            fn _tokenize(&self) -> <setOwnerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setOwnerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setOwnerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [19u8, 175u8, 64u8, 53u8];
-            const SIGNATURE: &'static str = "setOwner(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._owner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setOwnerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
     ///Container for all the [`IUniswapV3Factory`](self) function calls.
     #[derive(Clone)]
     pub enum IUniswapV3FactoryCalls {
-        #[allow(missing_docs)]
-        createPool(createPoolCall),
-        #[allow(missing_docs)]
-        enableFeeAmount(enableFeeAmountCall),
-        #[allow(missing_docs)]
-        feeAmountTickSpacing(feeAmountTickSpacingCall),
         #[allow(missing_docs)]
         getPool(getPoolCall),
         #[allow(missing_docs)]
         owner(ownerCall),
-        #[allow(missing_docs)]
-        setOwner(setOwnerCall),
     }
     impl IUniswapV3FactoryCalls {
         /// All the selectors of this enum.
@@ -1549,32 +857,16 @@ pub mod IUniswapV3Factory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [19u8, 175u8, 64u8, 53u8],
-            [22u8, 152u8, 238u8, 130u8],
-            [34u8, 175u8, 204u8, 203u8],
-            [138u8, 124u8, 25u8, 95u8],
-            [141u8, 165u8, 203u8, 91u8],
-            [161u8, 103u8, 18u8, 149u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[22u8, 152u8, 238u8, 130u8], [141u8, 165u8, 203u8, 91u8]];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <setOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <enableFeeAmountCall as alloy_sol_types::SolCall>::SIGNATURE,
             <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createPoolCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(setOwner),
-            ::core::stringify!(getPool),
-            ::core::stringify!(feeAmountTickSpacing),
-            ::core::stringify!(enableFeeAmount),
-            ::core::stringify!(owner),
-            ::core::stringify!(createPool),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] =
+            &[::core::stringify!(getPool), ::core::stringify!(owner)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1598,23 +890,15 @@ pub mod IUniswapV3Factory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for IUniswapV3FactoryCalls {
-        const COUNT: usize = 6usize;
+        const COUNT: usize = 2usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "IUniswapV3FactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::createPool(_) => <createPoolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::enableFeeAmount(_) => {
-                    <enableFeeAmountCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::feeAmountTickSpacing(_) => {
-                    <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::getPool(_) => <getPoolCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setOwner(_) => <setOwnerCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
 
@@ -1633,16 +917,6 @@ pub mod IUniswapV3Factory {
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
             static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>] =
                 &[
-                    {
-                        fn setOwner(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
-                        {
-                            <setOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(IUniswapV3FactoryCalls::setOwner)
-                        }
-                        setOwner
-                    },
                     {
                         fn getPool(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
                             <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -1650,28 +924,6 @@ pub mod IUniswapV3Factory {
                         }
                         getPool
                     },
-                    {
-                        fn feeAmountTickSpacing(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
-                        {
-                            <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IUniswapV3FactoryCalls::feeAmountTickSpacing)
-                        }
-                        feeAmountTickSpacing
-                    },
-                    {
-                        fn enableFeeAmount(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
-                        {
-                            <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(IUniswapV3FactoryCalls::enableFeeAmount)
-                        }
-                        enableFeeAmount
-                    },
                     {
                         fn owner(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
                             <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -1679,16 +931,6 @@ pub mod IUniswapV3Factory {
                         }
                         owner
                     },
-                    {
-                        fn createPool(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls>
-                        {
-                            <createPoolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(IUniswapV3FactoryCalls::createPool)
-                        }
-                        createPool
-                    },
                 ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -1710,13 +952,6 @@ pub mod IUniswapV3Factory {
             ) -> alloy_sol_types::Result<
                 IUniswapV3FactoryCalls,
             >] = &[
-                {
-                    fn setOwner(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
-                        <setOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IUniswapV3FactoryCalls::setOwner)
-                    }
-                    setOwner
-                },
                 {
                     fn getPool(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
                         <getPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -1724,28 +959,6 @@ pub mod IUniswapV3Factory {
                     }
                     getPool
                 },
-                {
-                    fn feeAmountTickSpacing(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
-                        <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IUniswapV3FactoryCalls::feeAmountTickSpacing)
-                    }
-                    feeAmountTickSpacing
-                },
-                {
-                    fn enableFeeAmount(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
-                        <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IUniswapV3FactoryCalls::enableFeeAmount)
-                    }
-                    enableFeeAmount
-                },
                 {
                     fn owner(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
                         <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -1753,13 +966,6 @@ pub mod IUniswapV3Factory {
                     }
                     owner
                 },
-                {
-                    fn createPool(data: &[u8]) -> alloy_sol_types::Result<IUniswapV3FactoryCalls> {
-                        <createPoolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IUniswapV3FactoryCalls::createPool)
-                    }
-                    createPool
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -1773,50 +979,24 @@ pub mod IUniswapV3Factory {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::createPool(inner) => {
-                    <createPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::enableFeeAmount(inner) => {
-                    <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::feeAmountTickSpacing(inner) => {
-                    <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPool(inner) => {
                     <getPoolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::owner(inner) => {
                     <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::setOwner(inner) => {
-                    <setOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::createPool(inner) => {
-                    <createPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::enableFeeAmount(inner) => {
-                    <enableFeeAmountCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::feeAmountTickSpacing(inner) => {
-                    <feeAmountTickSpacingCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::getPool(inner) => {
                     <getPoolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::owner(inner) => {
                     <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::setOwner(inner) => {
-                    <setOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -2061,38 +1241,6 @@ pub mod IUniswapV3Factory {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`createPool`] function.
-        pub fn createPool(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            fee: alloy_sol_types::private::primitives::aliases::U24,
-        ) -> alloy_contract::SolCallBuilder<&P, createPoolCall, N> {
-            self.call_builder(&createPoolCall {
-                tokenA,
-                tokenB,
-                fee,
-            })
-        }
-
-        ///Creates a new call builder for the [`enableFeeAmount`] function.
-        pub fn enableFeeAmount(
-            &self,
-            fee: alloy_sol_types::private::primitives::aliases::U24,
-            tickSpacing: alloy_sol_types::private::primitives::aliases::I24,
-        ) -> alloy_contract::SolCallBuilder<&P, enableFeeAmountCall, N> {
-            self.call_builder(&enableFeeAmountCall { fee, tickSpacing })
-        }
-
-        ///Creates a new call builder for the [`feeAmountTickSpacing`]
-        /// function.
-        pub fn feeAmountTickSpacing(
-            &self,
-            fee: alloy_sol_types::private::primitives::aliases::U24,
-        ) -> alloy_contract::SolCallBuilder<&P, feeAmountTickSpacingCall, N> {
-            self.call_builder(&feeAmountTickSpacingCall { fee })
-        }
-
         ///Creates a new call builder for the [`getPool`] function.
         pub fn getPool(
             &self,
@@ -2111,14 +1259,6 @@ pub mod IUniswapV3Factory {
         pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
             self.call_builder(&ownerCall)
         }
-
-        ///Creates a new call builder for the [`setOwner`] function.
-        pub fn setOwner(
-            &self,
-            _owner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setOwnerCall, N> {
-            self.call_builder(&setOwnerCall { _owner })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/izeroex/src/lib.rs b/contracts/generated/contracts-generated/izeroex/src/lib.rs
index 4b1cc35f1d..05d2728ef7 100644
--- a/contracts/generated/contracts-generated/izeroex/src/lib.rs
+++ b/contracts/generated/contracts-generated/izeroex/src/lib.rs
@@ -10,8 +10,10 @@
 /**
 
 ```solidity
-library IMetaTransactionsFeature {
-    struct MetaTransactionData { address signer; address sender; uint256 minGasPrice; uint256 maxGasPrice; uint256 expirationTimeSeconds; uint256 salt; bytes callData; uint256 value; address feeToken; uint256 feeAmount; }
+library LibNFTOrder {
+    type TradeDirection is uint8;
+    struct Fee { address recipient; uint256 amount; bytes feeData; }
+    struct Property { address propertyValidator; bytes propertyData; }
 }
 ```*/
 #[allow(
@@ -21,35 +23,155 @@ library IMetaTransactionsFeature {
     clippy::style,
     clippy::empty_structs_with_brackets
 )]
-pub mod IMetaTransactionsFeature {
+pub mod LibNFTOrder {
     use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct TradeDirection(u8);
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<TradeDirection> for u8 {
+            #[inline]
+            fn stv_to_tokens(
+                &self,
+            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
+            {
+                alloy_sol_types::private::SolTypeValue::<
+                    alloy_sol_types::sol_data::Uint<8>,
+                >::stv_to_tokens(self)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
+                    self,
+                )
+            }
+        }
+        impl TradeDirection {
+            /// The Solidity type name.
+            pub const NAME: &'static str = stringify!(@ name);
+
+            /// Convert from the underlying value type.
+            #[inline]
+            pub const fn from_underlying(value: u8) -> Self {
+                Self(value)
+            }
+
+            /// Return the underlying value.
+            #[inline]
+            pub const fn into_underlying(self) -> u8 {
+                self.0
+            }
+
+            /// Return the single encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
+            }
+
+            /// Return the packed encoding of this value, delegating to the
+            /// underlying type.
+            #[inline]
+            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
+                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
+            }
+        }
+        #[automatically_derived]
+        impl From<u8> for TradeDirection {
+            fn from(value: u8) -> Self {
+                Self::from_underlying(value)
+            }
+        }
+        #[automatically_derived]
+        impl From<TradeDirection> for u8 {
+            fn from(value: TradeDirection) -> Self {
+                value.into_underlying()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for TradeDirection {
+            type RustType = u8;
+            type Token<'a> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
+                8,
+            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = Self::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                Self::type_check(token).is_ok()
+            }
+
+            #[inline]
+            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for TradeDirection {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
+                    rust,
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct MetaTransactionData { address signer; address sender; uint256 minGasPrice; uint256 maxGasPrice; uint256 expirationTimeSeconds; uint256 salt; bytes callData; uint256 value; address feeToken; uint256 feeAmount; }
+    struct Fee { address recipient; uint256 amount; bytes feeData; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MetaTransactionData {
-        #[allow(missing_docs)]
-        pub signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minGasPrice: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub maxGasPrice: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub expirationTimeSeconds: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub salt: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub callData: alloy_sol_types::private::Bytes,
+    pub struct Fee {
         #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        pub recipient: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub feeToken: alloy_sol_types::private::Address,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub feeAmount: alloy_sol_types::private::primitives::aliases::U256,
+        pub feeData: alloy_sol_types::private::Bytes,
     }
     #[allow(
         non_camel_case_types,
@@ -63,28 +185,14 @@ pub mod IMetaTransactionsFeature {
         #[allow(dead_code)]
         type UnderlyingSolTuple<'a> = (
             alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
             alloy_sol_types::sol_data::Uint<256>,
             alloy_sol_types::sol_data::Bytes,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
         );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
             alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
             alloy_sol_types::private::primitives::aliases::U256,
             alloy_sol_types::private::Bytes,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
         );
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
@@ -97,78 +205,39 @@ pub mod IMetaTransactionsFeature {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<MetaTransactionData> for UnderlyingRustTuple<'_> {
-            fn from(value: MetaTransactionData) -> Self {
-                (
-                    value.signer,
-                    value.sender,
-                    value.minGasPrice,
-                    value.maxGasPrice,
-                    value.expirationTimeSeconds,
-                    value.salt,
-                    value.callData,
-                    value.value,
-                    value.feeToken,
-                    value.feeAmount,
-                )
+        impl ::core::convert::From<Fee> for UnderlyingRustTuple<'_> {
+            fn from(value: Fee) -> Self {
+                (value.recipient, value.amount, value.feeData)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MetaTransactionData {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Fee {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    signer: tuple.0,
-                    sender: tuple.1,
-                    minGasPrice: tuple.2,
-                    maxGasPrice: tuple.3,
-                    expirationTimeSeconds: tuple.4,
-                    salt: tuple.5,
-                    callData: tuple.6,
-                    value: tuple.7,
-                    feeToken: tuple.8,
-                    feeAmount: tuple.9,
+                    recipient: tuple.0,
+                    amount: tuple.1,
+                    feeData: tuple.2,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for MetaTransactionData {
+        impl alloy_sol_types::SolValue for Fee {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for MetaTransactionData {
+        impl alloy_sol_types::private::SolTypeValue<Self> for Fee {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.signer,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minGasPrice,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.maxGasPrice,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.expirationTimeSeconds,
+                        &self.recipient,
                     ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.salt,
+                        &self.amount,
                     ),
                     <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.callData,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.feeToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeAmount,
+                        &self.feeData,
                     ),
                 )
             }
@@ -210,7 +279,7 @@ pub mod IMetaTransactionsFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for MetaTransactionData {
+        impl alloy_sol_types::SolType for Fee {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -232,15 +301,13 @@ pub mod IMetaTransactionsFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for MetaTransactionData {
-            const NAME: &'static str = "MetaTransactionData";
+        impl alloy_sol_types::SolStruct for Fee {
+            const NAME: &'static str = "Fee";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "MetaTransactionData(address signer,address sender,uint256 \
-                     minGasPrice,uint256 maxGasPrice,uint256 expirationTimeSeconds,uint256 \
-                     salt,bytes callData,uint256 value,address feeToken,uint256 feeAmount)",
+                    "Fee(address recipient,uint256 amount,bytes feeData)",
                 )
             }
 
@@ -260,93 +327,36 @@ pub mod IMetaTransactionsFeature {
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.signer,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.minGasPrice)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.maxGasPrice)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.expirationTimeSeconds,
+                            &self.recipient,
                         )
                         .0,
                     <alloy_sol_types::sol_data::Uint<
                         256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
                         .0,
                     <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.callData,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.value)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.feeToken,
+                            &self.feeData,
                         )
                         .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.feeAmount)
-                        .0,
                 ]
                     .concat()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for MetaTransactionData {
+        impl alloy_sol_types::EventTopic for Fee {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
                     + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.signer,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.minGasPrice,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maxGasPrice,
+                        &rust.recipient,
                     )
                     + <alloy_sol_types::sol_data::Uint<
                         256,
                     > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expirationTimeSeconds,
+                        &rust.amount,
                     )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
                     + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.callData,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.value)
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.feeToken,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.feeAmount,
+                        &rust.feeData,
                     )
             }
 
@@ -357,55 +367,225 @@ pub mod IMetaTransactionsFeature {
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
                 <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.signer,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.minGasPrice,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maxGasPrice,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expirationTimeSeconds,
+                    &rust.recipient,
                     out,
                 );
                 <alloy_sol_types::sol_data::Uint<
                     256,
                 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.salt,
+                    &rust.amount,
                     out,
                 );
                 <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.callData,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.value,
+                    &rust.feeData,
                     out,
                 );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Property { address propertyValidator; bytes propertyData; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct Property {
+        #[allow(missing_docs)]
+        pub propertyValidator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub propertyData: alloy_sol_types::private::Bytes,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Bytes,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Bytes,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Property> for UnderlyingRustTuple<'_> {
+            fn from(value: Property) -> Self {
+                (value.propertyValidator, value.propertyData)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Property {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    propertyValidator: tuple.0,
+                    propertyData: tuple.1,
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolValue for Property {
+            type SolType = Self;
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::SolTypeValue<Self> for Property {
+            #[inline]
+            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.propertyValidator,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.propertyData,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn stv_abi_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
+            }
+
+            #[inline]
+            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
+                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
+            }
+
+            #[inline]
+            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
+                    &tuple, out,
+                )
+            }
+
+            #[inline]
+            fn stv_abi_packed_encoded_size(&self) -> usize {
+                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
+                    return size;
+                }
+                let tuple =
+                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
+                    &tuple,
+                )
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolType for Property {
+            type RustType = Self;
+            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
+            const PACKED_ENCODED_SIZE: Option<usize> =
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
+            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
+
+            #[inline]
+            fn valid_token(token: &Self::Token<'_>) -> bool {
+                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
+            }
+
+            #[inline]
+            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
+                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
+                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolStruct for Property {
+            const NAME: &'static str = "Property";
+
+            #[inline]
+            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
+                alloy_sol_types::private::Cow::Borrowed(
+                    "Property(address propertyValidator,bytes propertyData)",
+                )
+            }
+
+            #[inline]
+            fn eip712_components()
+            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
+            {
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
+            }
+
+            #[inline]
+            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
+                [
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.propertyValidator,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.propertyData,
+                        )
+                        .0,
+                ]
+                    .concat()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::EventTopic for Property {
+            #[inline]
+            fn topic_preimage_length(rust: &Self::RustType) -> usize {
+                0usize
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.propertyValidator,
+                    )
+                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.propertyData,
+                    )
+            }
+
+            #[inline]
+            fn encode_topic_preimage(
+                rust: &Self::RustType,
+                out: &mut alloy_sol_types::private::Vec<u8>,
+            ) {
+                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
                 <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.feeToken,
+                    &rust.propertyValidator,
                     out,
                 );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.feeAmount,
+                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.propertyData,
                     out,
                 );
             }
@@ -419,9 +599,9 @@ pub mod IMetaTransactionsFeature {
         }
     };
     use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IMetaTransactionsFeature`](self) contract instance.
+    /**Creates a new wrapper around an on-chain [`LibNFTOrder`](self) contract instance.
 
-    See the [wrapper's documentation](`IMetaTransactionsFeatureInstance`) for more details.*/
+    See the [wrapper's documentation](`LibNFTOrderInstance`) for more details.*/
     #[inline]
     pub const fn new<
         P: alloy_contract::private::Provider<N>,
@@ -429,13 +609,13 @@ pub mod IMetaTransactionsFeature {
     >(
         address: alloy_sol_types::private::Address,
         __provider: P,
-    ) -> IMetaTransactionsFeatureInstance<P, N> {
-        IMetaTransactionsFeatureInstance::<P, N>::new(address, __provider)
+    ) -> LibNFTOrderInstance<P, N> {
+        LibNFTOrderInstance::<P, N>::new(address, __provider)
     }
-    /**A [`IMetaTransactionsFeature`](self) instance.
+    /**A [`LibNFTOrder`](self) instance.
 
     Contains type-safe methods for interacting with an on-chain instance of the
-    [`IMetaTransactionsFeature`](self) contract located at a given `address`, using a given
+    [`LibNFTOrder`](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!)
@@ -444,27 +624,27 @@ pub mod IMetaTransactionsFeature {
 
     See the [module-level documentation](self) for all the available methods.*/
     #[derive(Clone)]
-    pub struct IMetaTransactionsFeatureInstance<P, N = alloy_contract::private::Ethereum> {
+    pub struct LibNFTOrderInstance<P, N = alloy_contract::private::Ethereum> {
         address: alloy_sol_types::private::Address,
         provider: P,
         _network: ::core::marker::PhantomData<N>,
     }
     #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IMetaTransactionsFeatureInstance<P, N> {
+    impl<P, N> ::core::fmt::Debug for LibNFTOrderInstance<P, N> {
         #[inline]
         fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IMetaTransactionsFeatureInstance")
+            f.debug_tuple("LibNFTOrderInstance")
                 .field(&self.address)
                 .finish()
         }
     }
     /// Instantiation and getters/setters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IMetaTransactionsFeatureInstance<P, N>
+        LibNFTOrderInstance<P, N>
     {
-        /**Creates a new wrapper around an on-chain [`IMetaTransactionsFeature`](self) contract instance.
+        /**Creates a new wrapper around an on-chain [`LibNFTOrder`](self) contract instance.
 
-        See the [wrapper's documentation](`IMetaTransactionsFeatureInstance`) for more details.*/
+        See the [wrapper's documentation](`LibNFTOrderInstance`) for more details.*/
         #[inline]
         pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
             Self {
@@ -498,12 +678,12 @@ pub mod IMetaTransactionsFeature {
             &self.provider
         }
     }
-    impl<P: ::core::clone::Clone, N> IMetaTransactionsFeatureInstance<&P, N> {
+    impl<P: ::core::clone::Clone, N> LibNFTOrderInstance<&P, N> {
         /// Clones the provider and returns a new instance with the cloned
         /// provider.
         #[inline]
-        pub fn with_cloned_provider(self) -> IMetaTransactionsFeatureInstance<P, N> {
-            IMetaTransactionsFeatureInstance {
+        pub fn with_cloned_provider(self) -> LibNFTOrderInstance<P, N> {
+            LibNFTOrderInstance {
                 address: self.address,
                 provider: ::core::clone::Clone::clone(&self.provider),
                 _network: ::core::marker::PhantomData,
@@ -512,7 +692,7 @@ pub mod IMetaTransactionsFeature {
     }
     /// Function calls.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IMetaTransactionsFeatureInstance<P, N>
+        LibNFTOrderInstance<P, N>
     {
         /// Creates a new call builder using this contract instance's provider
         /// and address.
@@ -529,7 +709,7 @@ pub mod IMetaTransactionsFeature {
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IMetaTransactionsFeatureInstance<P, N>
+        LibNFTOrderInstance<P, N>
     {
         /// Creates a new event filter using this contract instance's provider
         /// and address.
@@ -548,29 +728,29 @@ pub mod IMetaTransactionsFeature {
 /**
 
 ```solidity
-library IMultiplexFeature {
-    type MultiplexSubcall is uint8;
-    struct BatchSellSubcall { MultiplexSubcall id; uint256 sellAmount; bytes data; }
-    struct MultiHopSellSubcall { MultiplexSubcall id; bytes data; }
-}
-```*/
-#[allow(
+library LibNativeOrder {
+    type OrderStatus is uint8;
+    struct LimitOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; uint128 takerTokenFeeAmount; address maker; address taker; address sender; address feeRecipient; bytes32 pool; uint64 expiry; uint256 salt; }
+    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 takerTokenFilledAmount; }
+}
+```*/
+#[allow(
     non_camel_case_types,
     non_snake_case,
     clippy::pub_underscore_fields,
     clippy::style,
     clippy::empty_structs_with_brackets
 )]
-pub mod IMultiplexFeature {
+pub mod LibNativeOrder {
     use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct MultiplexSubcall(u8);
+    pub struct OrderStatus(u8);
     const _: () = {
         use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<MultiplexSubcall> for u8 {
+        impl alloy_sol_types::private::SolTypeValue<OrderStatus> for u8 {
             #[inline]
             fn stv_to_tokens(
                 &self,
@@ -600,7 +780,7 @@ pub mod IMultiplexFeature {
                 )
             }
         }
-        impl MultiplexSubcall {
+        impl OrderStatus {
             /// The Solidity type name.
             pub const NAME: &'static str = stringify!(@ name);
 
@@ -631,19 +811,19 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl From<u8> for MultiplexSubcall {
+        impl From<u8> for OrderStatus {
             fn from(value: u8) -> Self {
                 Self::from_underlying(value)
             }
         }
         #[automatically_derived]
-        impl From<MultiplexSubcall> for u8 {
-            fn from(value: MultiplexSubcall) -> Self {
+        impl From<OrderStatus> for u8 {
+            fn from(value: OrderStatus) -> Self {
                 value.into_underlying()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for MultiplexSubcall {
+        impl alloy_sol_types::SolType for OrderStatus {
             type RustType = u8;
             type Token<'a> =
                 <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
@@ -671,7 +851,7 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for MultiplexSubcall {
+        impl alloy_sol_types::EventTopic for OrderStatus {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 <alloy_sol_types::sol_data::Uint<
@@ -699,17 +879,35 @@ pub mod IMultiplexFeature {
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct BatchSellSubcall { MultiplexSubcall id; uint256 sellAmount; bytes data; }
+    struct LimitOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; uint128 takerTokenFeeAmount; address maker; address taker; address sender; address feeRecipient; bytes32 pool; uint64 expiry; uint256 salt; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct BatchSellSubcall {
+    pub struct LimitOrder {
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerAmount: u128,
+        #[allow(missing_docs)]
+        pub takerAmount: u128,
+        #[allow(missing_docs)]
+        pub takerTokenFeeAmount: u128,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub id: <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
+        pub sender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub feeRecipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
+        pub expiry: u64,
         #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
+        pub salt: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -722,15 +920,33 @@ pub mod IMultiplexFeature {
         #[doc(hidden)]
         #[allow(dead_code)]
         type UnderlyingSolTuple<'a> = (
-            MultiplexSubcall,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Uint<128>,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::Address,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::Uint<64>,
             alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bytes,
         );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
-            <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            u128,
+            u128,
+            u128,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::Address,
+            alloy_sol_types::private::FixedBytes<32>,
+            u64,
             alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Bytes,
         );
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
@@ -743,38 +959,89 @@ pub mod IMultiplexFeature {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<BatchSellSubcall> for UnderlyingRustTuple<'_> {
-            fn from(value: BatchSellSubcall) -> Self {
-                (value.id, value.sellAmount, value.data)
+        impl ::core::convert::From<LimitOrder> for UnderlyingRustTuple<'_> {
+            fn from(value: LimitOrder) -> Self {
+                (
+                    value.makerToken,
+                    value.takerToken,
+                    value.makerAmount,
+                    value.takerAmount,
+                    value.takerTokenFeeAmount,
+                    value.maker,
+                    value.taker,
+                    value.sender,
+                    value.feeRecipient,
+                    value.pool,
+                    value.expiry,
+                    value.salt,
+                )
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for BatchSellSubcall {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LimitOrder {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    id: tuple.0,
-                    sellAmount: tuple.1,
-                    data: tuple.2,
+                    makerToken: tuple.0,
+                    takerToken: tuple.1,
+                    makerAmount: tuple.2,
+                    takerAmount: tuple.3,
+                    takerTokenFeeAmount: tuple.4,
+                    maker: tuple.5,
+                    taker: tuple.6,
+                    sender: tuple.7,
+                    feeRecipient: tuple.8,
+                    pool: tuple.9,
+                    expiry: tuple.10,
+                    salt: tuple.11,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for BatchSellSubcall {
+        impl alloy_sol_types::SolValue for LimitOrder {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for BatchSellSubcall {
+        impl alloy_sol_types::private::SolTypeValue<Self> for LimitOrder {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
-                    <MultiplexSubcall as alloy_sol_types::SolType>::tokenize(&self.id),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.sellAmount,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
                     ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.makerAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerAmount),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokenFeeAmount),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
                     ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.feeRecipient,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                    <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
                 )
             }
 
@@ -815,7 +1082,7 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for BatchSellSubcall {
+        impl alloy_sol_types::SolType for LimitOrder {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -837,13 +1104,15 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for BatchSellSubcall {
-            const NAME: &'static str = "BatchSellSubcall";
+        impl alloy_sol_types::SolStruct for LimitOrder {
+            const NAME: &'static str = "LimitOrder";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "BatchSellSubcall(uint8 id,uint256 sellAmount,bytes data)",
+                    "LimitOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
+                     takerAmount,uint128 takerTokenFeeAmount,address maker,address taker,address \
+                     sender,address feeRecipient,bytes32 pool,uint64 expiry,uint256 salt)",
                 )
             }
 
@@ -862,38 +1131,109 @@ pub mod IMultiplexFeature {
             #[inline]
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
-                    <MultiplexSubcall as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.id,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.makerToken,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerToken,
                         )
                         .0,
                     <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount)
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
                         .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.data,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerTokenFeeAmount,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.maker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.taker,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.sender,
+                        )
+                        .0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.feeRecipient,
                         )
                         .0,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pool)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
+                        .0,
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
+                        .0,
                 ]
                     .concat()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for BatchSellSubcall {
+        impl alloy_sol_types::EventTopic for LimitOrder {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
-                    + <MultiplexSubcall as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.id,
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.makerToken,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerToken,
                     )
                     + <alloy_sol_types::sol_data::Uint<
-                        256,
+                        128,
                     > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sellAmount,
+                        &rust.makerAmount,
                     )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.data,
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerTokenFeeAmount,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.maker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.taker,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.sender,
+                    )
+                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.feeRecipient,
+                    )
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.pool)
+                    + <alloy_sol_types::sol_data::Uint<
+                        64,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.expiry,
                     )
+                    + <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
             }
 
             #[inline]
@@ -902,40 +1242,89 @@ pub mod IMultiplexFeature {
                 out: &mut alloy_sol_types::private::Vec<u8>,
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <MultiplexSubcall as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.id, out,
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.makerToken,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerToken,
+                    out,
                 );
                 <alloy_sol_types::sol_data::Uint<
-                    256,
+                    128,
                 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sellAmount,
+                    &rust.makerAmount,
                     out,
                 );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.data,
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerAmount,
                     out,
                 );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct MultiHopSellSubcall { MultiplexSubcall id; bytes data; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct MultiHopSellSubcall {
-        #[allow(missing_docs)]
-        pub id: <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerTokenFeeAmount,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.maker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.taker,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.sender,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.feeRecipient,
+                    out,
+                );
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.pool,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    64,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.expiry,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    256,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.salt,
+                    out,
+                );
+            }
+
+            #[inline]
+            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
+                let mut out = alloy_sol_types::private::Vec::new();
+                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
+                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 takerTokenFilledAmount; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct OrderInfo {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
     }
     #[allow(
         non_camel_case_types,
@@ -947,11 +1336,16 @@ pub mod IMultiplexFeature {
         use alloy_sol_types;
         #[doc(hidden)]
         #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (MultiplexSubcall, alloy_sol_types::sol_data::Bytes);
+        type UnderlyingSolTuple<'a> = (
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            OrderStatus,
+            alloy_sol_types::sol_data::Uint<128>,
+        );
         #[doc(hidden)]
         type UnderlyingRustTuple<'a> = (
-            <MultiplexSubcall as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Bytes,
+            alloy_sol_types::private::FixedBytes<32>,
+            <OrderStatus as alloy_sol_types::SolType>::RustType,
+            u128,
         );
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
@@ -964,33 +1358,39 @@ pub mod IMultiplexFeature {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<MultiHopSellSubcall> for UnderlyingRustTuple<'_> {
-            fn from(value: MultiHopSellSubcall) -> Self {
-                (value.id, value.data)
+        impl ::core::convert::From<OrderInfo> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderInfo) -> Self {
+                (value.orderHash, value.status, value.takerTokenFilledAmount)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for MultiHopSellSubcall {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderInfo {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    id: tuple.0,
-                    data: tuple.1,
+                    orderHash: tuple.0,
+                    status: tuple.1,
+                    takerTokenFilledAmount: tuple.2,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for MultiHopSellSubcall {
+        impl alloy_sol_types::SolValue for OrderInfo {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for MultiHopSellSubcall {
+        impl alloy_sol_types::private::SolTypeValue<Self> for OrderInfo {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
-                    <MultiplexSubcall as alloy_sol_types::SolType>::tokenize(&self.id),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
                     ),
                 )
             }
@@ -1032,7 +1432,7 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for MultiHopSellSubcall {
+        impl alloy_sol_types::SolType for OrderInfo {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -1054,12 +1454,14 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for MultiHopSellSubcall {
-            const NAME: &'static str = "MultiHopSellSubcall";
+        impl alloy_sol_types::SolStruct for OrderInfo {
+            const NAME: &'static str = "OrderInfo";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed("MultiHopSellSubcall(uint8 id,bytes data)")
+                alloy_sol_types::private::Cow::Borrowed(
+                    "OrderInfo(bytes32 orderHash,uint8 status,uint128 takerTokenFilledAmount)",
+                )
             }
 
             #[inline]
@@ -1077,12 +1479,18 @@ pub mod IMultiplexFeature {
             #[inline]
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
-                    <MultiplexSubcall as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.id,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
+                        .0,
+                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.status,
                         )
                         .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.data,
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.takerTokenFilledAmount,
                         )
                         .0,
                 ]
@@ -1090,15 +1498,22 @@ pub mod IMultiplexFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for MultiHopSellSubcall {
+        impl alloy_sol_types::EventTopic for OrderInfo {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
-                    + <MultiplexSubcall as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.id,
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.orderHash,
                     )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.data,
+                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.status,
+                    )
+                    + <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.takerTokenFilledAmount,
                     )
             }
 
@@ -1108,11 +1523,20 @@ pub mod IMultiplexFeature {
                 out: &mut alloy_sol_types::private::Vec<u8>,
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <MultiplexSubcall as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.id, out,
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.orderHash,
+                    out,
                 );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.data,
+                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.status,
+                    out,
+                );
+                <alloy_sol_types::sol_data::Uint<
+                    128,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.takerTokenFilledAmount,
                     out,
                 );
             }
@@ -1126,9 +1550,9 @@ pub mod IMultiplexFeature {
         }
     };
     use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IMultiplexFeature`](self) contract instance.
+    /**Creates a new wrapper around an on-chain [`LibNativeOrder`](self) contract instance.
 
-    See the [wrapper's documentation](`IMultiplexFeatureInstance`) for more details.*/
+    See the [wrapper's documentation](`LibNativeOrderInstance`) for more details.*/
     #[inline]
     pub const fn new<
         P: alloy_contract::private::Provider<N>,
@@ -1136,13 +1560,13 @@ pub mod IMultiplexFeature {
     >(
         address: alloy_sol_types::private::Address,
         __provider: P,
-    ) -> IMultiplexFeatureInstance<P, N> {
-        IMultiplexFeatureInstance::<P, N>::new(address, __provider)
+    ) -> LibNativeOrderInstance<P, N> {
+        LibNativeOrderInstance::<P, N>::new(address, __provider)
     }
-    /**A [`IMultiplexFeature`](self) instance.
+    /**A [`LibNativeOrder`](self) instance.
 
     Contains type-safe methods for interacting with an on-chain instance of the
-    [`IMultiplexFeature`](self) contract located at a given `address`, using a given
+    [`LibNativeOrder`](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!)
@@ -1151,27 +1575,27 @@ pub mod IMultiplexFeature {
 
     See the [module-level documentation](self) for all the available methods.*/
     #[derive(Clone)]
-    pub struct IMultiplexFeatureInstance<P, N = alloy_contract::private::Ethereum> {
+    pub struct LibNativeOrderInstance<P, N = alloy_contract::private::Ethereum> {
         address: alloy_sol_types::private::Address,
         provider: P,
         _network: ::core::marker::PhantomData<N>,
     }
     #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IMultiplexFeatureInstance<P, N> {
+    impl<P, N> ::core::fmt::Debug for LibNativeOrderInstance<P, N> {
         #[inline]
         fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IMultiplexFeatureInstance")
+            f.debug_tuple("LibNativeOrderInstance")
                 .field(&self.address)
                 .finish()
         }
     }
     /// Instantiation and getters/setters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IMultiplexFeatureInstance<P, N>
+        LibNativeOrderInstance<P, N>
     {
-        /**Creates a new wrapper around an on-chain [`IMultiplexFeature`](self) contract instance.
+        /**Creates a new wrapper around an on-chain [`LibNativeOrder`](self) contract instance.
 
-        See the [wrapper's documentation](`IMultiplexFeatureInstance`) for more details.*/
+        See the [wrapper's documentation](`LibNativeOrderInstance`) for more details.*/
         #[inline]
         pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
             Self {
@@ -1205,12 +1629,12 @@ pub mod IMultiplexFeature {
             &self.provider
         }
     }
-    impl<P: ::core::clone::Clone, N> IMultiplexFeatureInstance<&P, N> {
+    impl<P: ::core::clone::Clone, N> LibNativeOrderInstance<&P, N> {
         /// Clones the provider and returns a new instance with the cloned
         /// provider.
         #[inline]
-        pub fn with_cloned_provider(self) -> IMultiplexFeatureInstance<P, N> {
-            IMultiplexFeatureInstance {
+        pub fn with_cloned_provider(self) -> LibNativeOrderInstance<P, N> {
+            LibNativeOrderInstance {
                 address: self.address,
                 provider: ::core::clone::Clone::clone(&self.provider),
                 _network: ::core::marker::PhantomData,
@@ -1219,7 +1643,7 @@ pub mod IMultiplexFeature {
     }
     /// Function calls.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IMultiplexFeatureInstance<P, N>
+        LibNativeOrderInstance<P, N>
     {
         /// Creates a new call builder using this contract instance's provider
         /// and address.
@@ -1236,7 +1660,7 @@ pub mod IMultiplexFeature {
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IMultiplexFeatureInstance<P, N>
+        LibNativeOrderInstance<P, N>
     {
         /// Creates a new event filter using this contract instance's provider
         /// and address.
@@ -1255,8 +1679,9 @@ pub mod IMultiplexFeature {
 /**
 
 ```solidity
-library IPancakeSwapFeature {
-    type ProtocolFork is uint8;
+library LibSignature {
+    type SignatureType is uint8;
+    struct Signature { SignatureType signatureType; uint8 v; bytes32 r; bytes32 s; }
 }
 ```*/
 #[allow(
@@ -1266,16 +1691,16 @@ library IPancakeSwapFeature {
     clippy::style,
     clippy::empty_structs_with_brackets
 )]
-pub mod IPancakeSwapFeature {
+pub mod LibSignature {
     use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ProtocolFork(u8);
+    pub struct SignatureType(u8);
     const _: () = {
         use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<ProtocolFork> for u8 {
+        impl alloy_sol_types::private::SolTypeValue<SignatureType> for u8 {
             #[inline]
             fn stv_to_tokens(
                 &self,
@@ -1305,7 +1730,7 @@ pub mod IPancakeSwapFeature {
                 )
             }
         }
-        impl ProtocolFork {
+        impl SignatureType {
             /// The Solidity type name.
             pub const NAME: &'static str = stringify!(@ name);
 
@@ -1336,19 +1761,19 @@ pub mod IPancakeSwapFeature {
             }
         }
         #[automatically_derived]
-        impl From<u8> for ProtocolFork {
+        impl From<u8> for SignatureType {
             fn from(value: u8) -> Self {
                 Self::from_underlying(value)
             }
         }
         #[automatically_derived]
-        impl From<ProtocolFork> for u8 {
-            fn from(value: ProtocolFork) -> Self {
+        impl From<SignatureType> for u8 {
+            fn from(value: SignatureType) -> Self {
                 value.into_underlying()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for ProtocolFork {
+        impl alloy_sol_types::SolType for SignatureType {
             type RustType = u8;
             type Token<'a> =
                 <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
@@ -1376,7 +1801,7 @@ pub mod IPancakeSwapFeature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for ProtocolFork {
+        impl alloy_sol_types::EventTopic for SignatureType {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 <alloy_sol_types::sol_data::Uint<
@@ -1402,280 +1827,94 @@ pub mod IPancakeSwapFeature {
             }
         }
     };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IPancakeSwapFeature`](self) contract instance.
-
-    See the [wrapper's documentation](`IPancakeSwapFeatureInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IPancakeSwapFeatureInstance<P, N> {
-        IPancakeSwapFeatureInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`IPancakeSwapFeature`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IPancakeSwapFeature`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**```solidity
+    struct Signature { SignatureType signatureType; uint8 v; bytes32 r; bytes32 s; }
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct IPancakeSwapFeatureInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
+    pub struct Signature {
+        #[allow(missing_docs)]
+        pub signatureType: <SignatureType as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub v: u8,
+        #[allow(missing_docs)]
+        pub r: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
     }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IPancakeSwapFeatureInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IPancakeSwapFeatureInstance")
-                .field(&self.address)
-                .finish()
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (
+            SignatureType,
+            alloy_sol_types::sol_data::Uint<8>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+            alloy_sol_types::sol_data::FixedBytes<32>,
+        );
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (
+            <SignatureType as alloy_sol_types::SolType>::RustType,
+            u8,
+            alloy_sol_types::private::FixedBytes<32>,
+            alloy_sol_types::private::FixedBytes<32>,
+        );
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
         }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPancakeSwapFeatureInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IPancakeSwapFeature`](self) contract instance.
-
-        See the [wrapper's documentation](`IPancakeSwapFeatureInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> IPancakeSwapFeatureInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IPancakeSwapFeatureInstance<P, N> {
-            IPancakeSwapFeatureInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPancakeSwapFeatureInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IPancakeSwapFeatureInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library ITransformERC20Feature {
-    struct TransformERC20Args { address taker; address inputToken; address outputToken; uint256 inputTokenAmount; uint256 minOutputTokenAmount; Transformation[] transformations; bool useSelfBalance; address recipient; }
-    struct Transformation { uint32 deploymentNonce; bytes data; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod ITransformERC20Feature {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct TransformERC20Args { address taker; address inputToken; address outputToken; uint256 inputTokenAmount; uint256 minOutputTokenAmount; Transformation[] transformations; bool useSelfBalance; address recipient; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct TransformERC20Args {
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minOutputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub transformations:
-            alloy_sol_types::private::Vec<<Transformation as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub useSelfBalance: bool,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Array<Transformation>,
-            alloy_sol_types::sol_data::Bool,
-            alloy_sol_types::sol_data::Address,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Vec<<Transformation as alloy_sol_types::SolType>::RustType>,
-            bool,
-            alloy_sol_types::private::Address,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<TransformERC20Args> for UnderlyingRustTuple<'_> {
-            fn from(value: TransformERC20Args) -> Self {
-                (
-                    value.taker,
-                    value.inputToken,
-                    value.outputToken,
-                    value.inputTokenAmount,
-                    value.minOutputTokenAmount,
-                    value.transformations,
-                    value.useSelfBalance,
-                    value.recipient,
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<Signature> for UnderlyingRustTuple<'_> {
+            fn from(value: Signature) -> Self {
+                (value.signatureType, value.v, value.r, value.s)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TransformERC20Args {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Signature {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self {
-                    taker: tuple.0,
-                    inputToken: tuple.1,
-                    outputToken: tuple.2,
-                    inputTokenAmount: tuple.3,
-                    minOutputTokenAmount: tuple.4,
-                    transformations: tuple.5,
-                    useSelfBalance: tuple.6,
-                    recipient: tuple.7,
+                    signatureType: tuple.0,
+                    v: tuple.1,
+                    r: tuple.2,
+                    s: tuple.3,
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolValue for TransformERC20Args {
+        impl alloy_sol_types::SolValue for Signature {
             type SolType = Self;
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for TransformERC20Args {
+        impl alloy_sol_types::private::SolTypeValue<Self> for Signature {
             #[inline]
             fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
+                    <SignatureType as alloy_sol_types::SolType>::tokenize(
+                        &self.signatureType,
                     ),
                     <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.inputTokenAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minOutputTokenAmount),
-                    <alloy_sol_types::sol_data::Array<
-                        Transformation,
-                    > as alloy_sol_types::SolType>::tokenize(&self.transformations),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.useSelfBalance,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
+                        8,
+                    > as alloy_sol_types::SolType>::tokenize(&self.v),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.r),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
                 )
             }
 
@@ -1716,7 +1955,7 @@ pub mod ITransformERC20Feature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolType for TransformERC20Args {
+        impl alloy_sol_types::SolType for Signature {
             type RustType = Self;
             type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
 
@@ -1738,16 +1977,13 @@ pub mod ITransformERC20Feature {
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolStruct for TransformERC20Args {
-            const NAME: &'static str = "TransformERC20Args";
+        impl alloy_sol_types::SolStruct for Signature {
+            const NAME: &'static str = "Signature";
 
             #[inline]
             fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
                 alloy_sol_types::private::Cow::Borrowed(
-                    "TransformERC20Args(address taker,address inputToken,address \
-                     outputToken,uint256 inputTokenAmount,uint256 \
-                     minOutputTokenAmount,Transformation[] transformations,bool \
-                     useSelfBalance,address recipient)",
+                    "Signature(uint8 signatureType,uint8 v,bytes32 r,bytes32 s)",
                 )
             }
 
@@ -1755,93 +1991,54 @@ pub mod ITransformERC20Feature {
             fn eip712_components()
             -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
             {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components.push(<Transformation as alloy_sol_types::SolStruct>::eip712_root_type());
-                components
-                    .extend(<Transformation as alloy_sol_types::SolStruct>::eip712_components());
-                components
+                alloy_sol_types::private::Vec::new()
+            }
+
+            #[inline]
+            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
+                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
             }
 
             #[inline]
             fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
                 [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.taker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.inputToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.outputToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.inputTokenAmount,
+                    <SignatureType as alloy_sol_types::SolType>::eip712_data_word(
+                            &self.signatureType,
                         )
                         .0,
                     <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.minOutputTokenAmount,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        Transformation,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.transformations,
-                        )
+                        8,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.v)
                         .0,
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.useSelfBalance,
-                        )
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.r)
                         .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.recipient,
-                        )
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::eip712_data_word(&self.s)
                         .0,
                 ]
                     .concat()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::EventTopic for TransformERC20Args {
+        impl alloy_sol_types::EventTopic for Signature {
             #[inline]
             fn topic_preimage_length(rust: &Self::RustType) -> usize {
                 0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.taker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.inputToken,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.outputToken,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.inputTokenAmount,
+                    + <SignatureType as alloy_sol_types::EventTopic>::topic_preimage_length(
+                        &rust.signatureType,
                     )
                     + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.minOutputTokenAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        Transformation,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.transformations,
-                    )
-                    + <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.useSelfBalance,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.recipient,
-                    )
+                        8,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.v)
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.r)
+                    + <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.s)
             }
 
             #[inline]
@@ -1850,255 +2047,19 @@ pub mod ITransformERC20Feature {
                 out: &mut alloy_sol_types::private::Vec<u8>,
             ) {
                 out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.taker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.inputToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.outputToken,
+                <SignatureType as alloy_sol_types::EventTopic>::encode_topic_preimage(
+                    &rust.signatureType,
                     out,
                 );
                 <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.inputTokenAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.minOutputTokenAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    Transformation,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.transformations,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.useSelfBalance,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.recipient,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct Transformation { uint32 deploymentNonce; bytes data; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct Transformation {
-        #[allow(missing_docs)]
-        pub deploymentNonce: u32,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Uint<32>,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (u32, alloy_sol_types::private::Bytes);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<Transformation> for UnderlyingRustTuple<'_> {
-            fn from(value: Transformation) -> Self {
-                (value.deploymentNonce, value.data)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Transformation {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    deploymentNonce: tuple.0,
-                    data: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for Transformation {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for Transformation {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        &self.deploymentNonce,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for Transformation {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for Transformation {
-            const NAME: &'static str = "Transformation";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "Transformation(uint32 deploymentNonce,bytes data)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Uint<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.deploymentNonce,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.data,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for Transformation {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Uint<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deploymentNonce,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.data,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Uint<
+                    8,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.v, out);
+                <alloy_sol_types::sol_data::FixedBytes<
                     32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deploymentNonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.data,
-                    out,
-                );
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.r, out);
+                <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.s, out);
             }
 
             #[inline]
@@ -2110,9 +2071,9 @@ pub mod ITransformERC20Feature {
         }
     };
     use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`ITransformERC20Feature`](self) contract instance.
+    /**Creates a new wrapper around an on-chain [`LibSignature`](self) contract instance.
 
-    See the [wrapper's documentation](`ITransformERC20FeatureInstance`) for more details.*/
+    See the [wrapper's documentation](`LibSignatureInstance`) for more details.*/
     #[inline]
     pub const fn new<
         P: alloy_contract::private::Provider<N>,
@@ -2120,13 +2081,13 @@ pub mod ITransformERC20Feature {
     >(
         address: alloy_sol_types::private::Address,
         __provider: P,
-    ) -> ITransformERC20FeatureInstance<P, N> {
-        ITransformERC20FeatureInstance::<P, N>::new(address, __provider)
+    ) -> LibSignatureInstance<P, N> {
+        LibSignatureInstance::<P, N>::new(address, __provider)
     }
-    /**A [`ITransformERC20Feature`](self) instance.
+    /**A [`LibSignature`](self) instance.
 
     Contains type-safe methods for interacting with an on-chain instance of the
-    [`ITransformERC20Feature`](self) contract located at a given `address`, using a given
+    [`LibSignature`](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!)
@@ -2135,27 +2096,27 @@ pub mod ITransformERC20Feature {
 
     See the [module-level documentation](self) for all the available methods.*/
     #[derive(Clone)]
-    pub struct ITransformERC20FeatureInstance<P, N = alloy_contract::private::Ethereum> {
+    pub struct LibSignatureInstance<P, N = alloy_contract::private::Ethereum> {
         address: alloy_sol_types::private::Address,
         provider: P,
         _network: ::core::marker::PhantomData<N>,
     }
     #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for ITransformERC20FeatureInstance<P, N> {
+    impl<P, N> ::core::fmt::Debug for LibSignatureInstance<P, N> {
         #[inline]
         fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("ITransformERC20FeatureInstance")
+            f.debug_tuple("LibSignatureInstance")
                 .field(&self.address)
                 .finish()
         }
     }
     /// Instantiation and getters/setters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        ITransformERC20FeatureInstance<P, N>
+        LibSignatureInstance<P, N>
     {
-        /**Creates a new wrapper around an on-chain [`ITransformERC20Feature`](self) contract instance.
+        /**Creates a new wrapper around an on-chain [`LibSignature`](self) contract instance.
 
-        See the [wrapper's documentation](`ITransformERC20FeatureInstance`) for more details.*/
+        See the [wrapper's documentation](`LibSignatureInstance`) for more details.*/
         #[inline]
         pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
             Self {
@@ -2189,12 +2150,12 @@ pub mod ITransformERC20Feature {
             &self.provider
         }
     }
-    impl<P: ::core::clone::Clone, N> ITransformERC20FeatureInstance<&P, N> {
+    impl<P: ::core::clone::Clone, N> LibSignatureInstance<&P, N> {
         /// Clones the provider and returns a new instance with the cloned
         /// provider.
         #[inline]
-        pub fn with_cloned_provider(self) -> ITransformERC20FeatureInstance<P, N> {
-            ITransformERC20FeatureInstance {
+        pub fn with_cloned_provider(self) -> LibSignatureInstance<P, N> {
+            LibSignatureInstance {
                 address: self.address,
                 provider: ::core::clone::Clone::clone(&self.provider),
                 _network: ::core::marker::PhantomData,
@@ -2203,7 +2164,7 @@ pub mod ITransformERC20Feature {
     }
     /// Function calls.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        ITransformERC20FeatureInstance<P, N>
+        LibSignatureInstance<P, N>
     {
         /// Creates a new call builder using this contract instance's provider
         /// and address.
@@ -2220,7 +2181,7 @@ pub mod ITransformERC20Feature {
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        ITransformERC20FeatureInstance<P, N>
+        LibSignatureInstance<P, N>
     {
         /// Creates a new event filter using this contract instance's provider
         /// and address.
@@ -2235,39489 +2196,5919 @@ pub mod ITransformERC20Feature {
         }
     }
 }
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
 library LibNFTOrder {
-    type OrderStatus is uint8;
     type TradeDirection is uint8;
-    struct ERC1155Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc1155Token; uint256 erc1155TokenId; Property[] erc1155TokenProperties; uint128 erc1155TokenAmount; }
-    struct ERC721Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc721Token; uint256 erc721TokenId; Property[] erc721TokenProperties; }
-    struct Fee { address recipient; uint256 amount; bytes feeData; }
-    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 orderAmount; uint128 remainingAmount; }
-    struct Property { address propertyValidator; bytes propertyData; }
+    struct Fee {
+        address recipient;
+        uint256 amount;
+        bytes feeData;
+    }
+    struct Property {
+        address propertyValidator;
+        bytes propertyData;
+    }
 }
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod LibNFTOrder {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OrderStatus(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<OrderStatus> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl OrderStatus {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for OrderStatus {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<OrderStatus> for u8 {
-            fn from(value: OrderStatus) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for OrderStatus {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for OrderStatus {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct TradeDirection(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<TradeDirection> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
 
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl TradeDirection {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
+library LibNativeOrder {
+    type OrderStatus is uint8;
+    struct LimitOrder {
+        address makerToken;
+        address takerToken;
+        uint128 makerAmount;
+        uint128 takerAmount;
+        uint128 takerTokenFeeAmount;
+        address maker;
+        address taker;
+        address sender;
+        address feeRecipient;
+        bytes32 pool;
+        uint64 expiry;
+        uint256 salt;
+    }
+    struct OrderInfo {
+        bytes32 orderHash;
+        OrderStatus status;
+        uint128 takerTokenFilledAmount;
+    }
+}
 
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
+library LibSignature {
+    type SignatureType is uint8;
+    struct Signature {
+        SignatureType signatureType;
+        uint8 v;
+        bytes32 r;
+        bytes32 s;
+    }
+}
 
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
+interface IZeroex {
+    event ERC1155OrderCancelled(address maker, uint256 nonce);
+    event ERC1155OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20FillAmount, address erc1155Token, uint256 erc1155TokenId, uint128 erc1155FillAmount, address matcher);
+    event ERC1155OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc1155Token, uint256 erc1155TokenId, LibNFTOrder.Property[] erc1155TokenProperties, uint128 erc1155TokenAmount);
+    event ERC721OrderCancelled(address maker, uint256 nonce);
+    event ERC721OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, address erc721Token, uint256 erc721TokenId, address matcher);
+    event ERC721OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc721Token, uint256 erc721TokenId, LibNFTOrder.Property[] erc721TokenProperties);
+    event LimitOrderFilled(bytes32 orderHash, address maker, address taker, address feeRecipient, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, uint128 takerTokenFeeFilledAmount, uint256 protocolFeePaid, bytes32 pool);
+    event LiquidityProviderSwap(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount, address provider, address recipient);
+    event MetaTransactionExecuted(bytes32 hash, bytes4 indexed selector, address signer, address sender);
+    event Migrated(address caller, address migrator, address newOwner);
+    event OrderCancelled(bytes32 orderHash, address maker);
+    event OrderSignerRegistered(address maker, address signer, bool allowed);
+    event OtcOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 makerTokenFilledAmount, uint128 takerTokenFilledAmount);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event PairCancelledLimitOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    event PairCancelledRfqOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    event ProxyFunctionUpdated(bytes4 indexed selector, address oldImpl, address newImpl);
+    event QuoteSignerUpdated(address quoteSigner);
+    event RfqOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, bytes32 pool);
+    event RfqOrderOriginsAllowed(address origin, address[] addrs, bool allowed);
+    event TransformedERC20(address indexed taker, address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount);
+    event TransformerDeployerUpdated(address transformerDeployer);
 
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
+    function extend(bytes4 selector, address impl) external;
+    function fillOrKillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 makerTokenFilledAmount);
+    function getLimitOrderRelevantState(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
+    function owner() external view returns (address ownerAddress);
+}
+```
 
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for TradeDirection {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<TradeDirection> for u8 {
-            fn from(value: TradeDirection) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for TradeDirection {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for TradeDirection {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct ERC1155Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc1155Token; uint256 erc1155TokenId; Property[] erc1155TokenProperties; uint128 erc1155TokenAmount; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ERC1155Order {
-        #[allow(missing_docs)]
-        pub direction: <TradeDirection as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc20Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub fees: alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub erc1155Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc1155TokenProperties:
-            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub erc1155TokenAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            TradeDirection,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Array<Fee>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Array<Property>,
-            alloy_sol_types::sol_data::Uint<128>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <TradeDirection as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
-            u128,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ERC1155Order> for UnderlyingRustTuple<'_> {
-            fn from(value: ERC1155Order) -> Self {
-                (
-                    value.direction,
-                    value.maker,
-                    value.taker,
-                    value.expiry,
-                    value.nonce,
-                    value.erc20Token,
-                    value.erc20TokenAmount,
-                    value.fees,
-                    value.erc1155Token,
-                    value.erc1155TokenId,
-                    value.erc1155TokenProperties,
-                    value.erc1155TokenAmount,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC1155Order {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    direction: tuple.0,
-                    maker: tuple.1,
-                    taker: tuple.2,
-                    expiry: tuple.3,
-                    nonce: tuple.4,
-                    erc20Token: tuple.5,
-                    erc20TokenAmount: tuple.6,
-                    fees: tuple.7,
-                    erc1155Token: tuple.8,
-                    erc1155TokenId: tuple.9,
-                    erc1155TokenProperties: tuple.10,
-                    erc1155TokenAmount: tuple.11,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for ERC1155Order {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for ERC1155Order {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <TradeDirection as alloy_sol_types::SolType>::tokenize(
-                        &self.direction,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
-                    <alloy_sol_types::sol_data::Array<
-                        Fee,
-                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenId),
-                    <alloy_sol_types::sol_data::Array<
-                        Property,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155TokenProperties,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmount),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for ERC1155Order {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for ERC1155Order {
-            const NAME: &'static str = "ERC1155Order";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "ERC1155Order(uint8 direction,address maker,address taker,uint256 \
-                     expiry,uint256 nonce,address erc20Token,uint256 erc20TokenAmount,Fee[] \
-                     fees,address erc1155Token,uint256 erc1155TokenId,Property[] \
-                     erc1155TokenProperties,uint128 erc1155TokenAmount)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
-                components.push(<Fee as alloy_sol_types::SolStruct>::eip712_root_type());
-                components.extend(<Fee as alloy_sol_types::SolStruct>::eip712_components());
-                components.push(<Property as alloy_sol_types::SolStruct>::eip712_root_type());
-                components.extend(<Property as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <TradeDirection as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.direction,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.maker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.taker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc20Token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc20TokenAmount,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        Fee,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fees)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc1155Token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc1155TokenId,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        Property,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc1155TokenProperties,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc1155TokenAmount,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for ERC1155Order {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <TradeDirection as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.direction,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.taker,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expiry,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc20Token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc20TokenAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        Fee,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fees)
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc1155Token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc1155TokenId,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        Property,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc1155TokenProperties,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc1155TokenAmount,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <TradeDirection as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.direction,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.taker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expiry,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc20Token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc20TokenAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    Fee,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.fees,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc1155Token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc1155TokenId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    Property,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc1155TokenProperties,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc1155TokenAmount,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct ERC721Order { TradeDirection direction; address maker; address taker; uint256 expiry; uint256 nonce; address erc20Token; uint256 erc20TokenAmount; Fee[] fees; address erc721Token; uint256 erc721TokenId; Property[] erc721TokenProperties; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ERC721Order {
-        #[allow(missing_docs)]
-        pub direction: <TradeDirection as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc20Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub fees: alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub erc721Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc721TokenProperties:
-            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            TradeDirection,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Array<Fee>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Array<Property>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <TradeDirection as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Vec<<Fee as alloy_sol_types::SolType>::RustType>,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Vec<<Property as alloy_sol_types::SolType>::RustType>,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ERC721Order> for UnderlyingRustTuple<'_> {
-            fn from(value: ERC721Order) -> Self {
-                (
-                    value.direction,
-                    value.maker,
-                    value.taker,
-                    value.expiry,
-                    value.nonce,
-                    value.erc20Token,
-                    value.erc20TokenAmount,
-                    value.fees,
-                    value.erc721Token,
-                    value.erc721TokenId,
-                    value.erc721TokenProperties,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721Order {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    direction: tuple.0,
-                    maker: tuple.1,
-                    taker: tuple.2,
-                    expiry: tuple.3,
-                    nonce: tuple.4,
-                    erc20Token: tuple.5,
-                    erc20TokenAmount: tuple.6,
-                    fees: tuple.7,
-                    erc721Token: tuple.8,
-                    erc721TokenId: tuple.9,
-                    erc721TokenProperties: tuple.10,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for ERC721Order {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for ERC721Order {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <TradeDirection as alloy_sol_types::SolType>::tokenize(
-                        &self.direction,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
-                    <alloy_sol_types::sol_data::Array<
-                        Fee,
-                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc721Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenId),
-                    <alloy_sol_types::sol_data::Array<
-                        Property,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenProperties),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for ERC721Order {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for ERC721Order {
-            const NAME: &'static str = "ERC721Order";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "ERC721Order(uint8 direction,address maker,address taker,uint256 \
-                     expiry,uint256 nonce,address erc20Token,uint256 erc20TokenAmount,Fee[] \
-                     fees,address erc721Token,uint256 erc721TokenId,Property[] \
-                     erc721TokenProperties)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
-                components.push(<Fee as alloy_sol_types::SolStruct>::eip712_root_type());
-                components.extend(<Fee as alloy_sol_types::SolStruct>::eip712_components());
-                components.push(<Property as alloy_sol_types::SolStruct>::eip712_root_type());
-                components.extend(<Property as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <TradeDirection as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.direction,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.maker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.taker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc20Token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc20TokenAmount,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        Fee,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.fees)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc721Token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.erc721TokenId)
-                        .0,
-                    <alloy_sol_types::sol_data::Array<
-                        Property,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.erc721TokenProperties,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for ERC721Order {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <TradeDirection as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.direction,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.taker,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expiry,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc20Token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc20TokenAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        Fee,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.fees)
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc721Token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc721TokenId,
-                    )
-                    + <alloy_sol_types::sol_data::Array<
-                        Property,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.erc721TokenProperties,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <TradeDirection as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.direction,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.taker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expiry,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc20Token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc20TokenAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    Fee,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.fees,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc721Token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc721TokenId,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Array<
-                    Property,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.erc721TokenProperties,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct Fee { address recipient; uint256 amount; bytes feeData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct Fee {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub feeData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<Fee> for UnderlyingRustTuple<'_> {
-            fn from(value: Fee) -> Self {
-                (value.recipient, value.amount, value.feeData)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Fee {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    recipient: tuple.0,
-                    amount: tuple.1,
-                    feeData: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for Fee {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for Fee {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.feeData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for Fee {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for Fee {
-            const NAME: &'static str = "Fee";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "Fee(address recipient,uint256 amount,bytes feeData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.recipient,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.feeData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for Fee {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.recipient,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.feeData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.recipient,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.feeData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 orderAmount; uint128 remainingAmount; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OrderInfo {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub orderAmount: u128,
-        #[allow(missing_docs)]
-        pub remainingAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            OrderStatus,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Uint<128>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::FixedBytes<32>,
-            <OrderStatus as alloy_sol_types::SolType>::RustType,
-            u128,
-            u128,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<OrderInfo> for UnderlyingRustTuple<'_> {
-            fn from(value: OrderInfo) -> Self {
-                (
-                    value.orderHash,
-                    value.status,
-                    value.orderAmount,
-                    value.remainingAmount,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderInfo {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    orderHash: tuple.0,
-                    status: tuple.1,
-                    orderAmount: tuple.2,
-                    remainingAmount: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for OrderInfo {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for OrderInfo {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.remainingAmount),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for OrderInfo {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for OrderInfo {
-            const NAME: &'static str = "OrderInfo";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "OrderInfo(bytes32 orderHash,uint8 status,uint128 orderAmount,uint128 \
-                     remainingAmount)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
-                        .0,
-                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.status,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.remainingAmount,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for OrderInfo {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.orderHash,
-                    )
-                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.status,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.orderAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.remainingAmount,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.orderHash,
-                    out,
-                );
-                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.status,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.orderAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.remainingAmount,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct Property { address propertyValidator; bytes propertyData; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct Property {
-        #[allow(missing_docs)]
-        pub propertyValidator: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub propertyData: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Bytes,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Bytes,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<Property> for UnderlyingRustTuple<'_> {
-            fn from(value: Property) -> Self {
-                (value.propertyValidator, value.propertyData)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Property {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    propertyValidator: tuple.0,
-                    propertyData: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for Property {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for Property {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.propertyValidator,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.propertyData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for Property {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for Property {
-            const NAME: &'static str = "Property";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "Property(address propertyValidator,bytes propertyData)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.propertyValidator,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.propertyData,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for Property {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.propertyValidator,
-                    )
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.propertyData,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.propertyValidator,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.propertyData,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`LibNFTOrder`](self) contract instance.
-
-    See the [wrapper's documentation](`LibNFTOrderInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> LibNFTOrderInstance<P, N> {
-        LibNFTOrderInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`LibNFTOrder`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`LibNFTOrder`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct LibNFTOrderInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for LibNFTOrderInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("LibNFTOrderInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibNFTOrderInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`LibNFTOrder`](self) contract instance.
-
-        See the [wrapper's documentation](`LibNFTOrderInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> LibNFTOrderInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> LibNFTOrderInstance<P, N> {
-            LibNFTOrderInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibNFTOrderInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibNFTOrderInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library LibNativeOrder {
-    type OrderStatus is uint8;
-    struct LimitOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; uint128 takerTokenFeeAmount; address maker; address taker; address sender; address feeRecipient; bytes32 pool; uint64 expiry; uint256 salt; }
-    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 takerTokenFilledAmount; }
-    struct OtcOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; uint256 expiryAndNonce; }
-    struct OtcOrderInfo { bytes32 orderHash; OrderStatus status; }
-    struct RfqOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; bytes32 pool; uint64 expiry; uint256 salt; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod LibNativeOrder {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OrderStatus(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<OrderStatus> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl OrderStatus {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for OrderStatus {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<OrderStatus> for u8 {
-            fn from(value: OrderStatus) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for OrderStatus {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for OrderStatus {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct LimitOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; uint128 takerTokenFeeAmount; address maker; address taker; address sender; address feeRecipient; bytes32 pool; uint64 expiry; uint256 salt; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct LimitOrder {
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerAmount: u128,
-        #[allow(missing_docs)]
-        pub takerAmount: u128,
-        #[allow(missing_docs)]
-        pub takerTokenFeeAmount: u128,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub feeRecipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub expiry: u64,
-        #[allow(missing_docs)]
-        pub salt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<64>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            u128,
-            u128,
-            u128,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::FixedBytes<32>,
-            u64,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<LimitOrder> for UnderlyingRustTuple<'_> {
-            fn from(value: LimitOrder) -> Self {
-                (
-                    value.makerToken,
-                    value.takerToken,
-                    value.makerAmount,
-                    value.takerAmount,
-                    value.takerTokenFeeAmount,
-                    value.maker,
-                    value.taker,
-                    value.sender,
-                    value.feeRecipient,
-                    value.pool,
-                    value.expiry,
-                    value.salt,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LimitOrder {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    makerToken: tuple.0,
-                    takerToken: tuple.1,
-                    makerAmount: tuple.2,
-                    takerAmount: tuple.3,
-                    takerTokenFeeAmount: tuple.4,
-                    maker: tuple.5,
-                    taker: tuple.6,
-                    sender: tuple.7,
-                    feeRecipient: tuple.8,
-                    pool: tuple.9,
-                    expiry: tuple.10,
-                    salt: tuple.11,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for LimitOrder {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for LimitOrder {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokenFeeAmount),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.feeRecipient,
-                    ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
-                    <alloy_sol_types::sol_data::Uint<
-                        64,
-                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for LimitOrder {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for LimitOrder {
-            const NAME: &'static str = "LimitOrder";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "LimitOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
-                     takerAmount,uint128 takerTokenFeeAmount,address maker,address taker,address \
-                     sender,address feeRecipient,bytes32 pool,uint64 expiry,uint256 salt)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.makerToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.takerToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.takerTokenFeeAmount,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.maker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.taker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.sender,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.feeRecipient,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pool)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        64,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for LimitOrder {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.makerToken,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerToken,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.makerAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerTokenFeeAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.taker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.sender,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.feeRecipient,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.pool)
-                    + <alloy_sol_types::sol_data::Uint<
-                        64,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expiry,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.makerToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.makerAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerTokenFeeAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.taker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.sender,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.feeRecipient,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.pool,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    64,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expiry,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.salt,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct OrderInfo { bytes32 orderHash; OrderStatus status; uint128 takerTokenFilledAmount; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OrderInfo {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            OrderStatus,
-            alloy_sol_types::sol_data::Uint<128>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::FixedBytes<32>,
-            <OrderStatus as alloy_sol_types::SolType>::RustType,
-            u128,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<OrderInfo> for UnderlyingRustTuple<'_> {
-            fn from(value: OrderInfo) -> Self {
-                (value.orderHash, value.status, value.takerTokenFilledAmount)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderInfo {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    orderHash: tuple.0,
-                    status: tuple.1,
-                    takerTokenFilledAmount: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for OrderInfo {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for OrderInfo {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for OrderInfo {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for OrderInfo {
-            const NAME: &'static str = "OrderInfo";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "OrderInfo(bytes32 orderHash,uint8 status,uint128 takerTokenFilledAmount)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
-                        .0,
-                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.status,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.takerTokenFilledAmount,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for OrderInfo {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.orderHash,
-                    )
-                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.status,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerTokenFilledAmount,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.orderHash,
-                    out,
-                );
-                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.status,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerTokenFilledAmount,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct OtcOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; uint256 expiryAndNonce; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OtcOrder {
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerAmount: u128,
-        #[allow(missing_docs)]
-        pub takerAmount: u128,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub txOrigin: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub expiryAndNonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            u128,
-            u128,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<OtcOrder> for UnderlyingRustTuple<'_> {
-            fn from(value: OtcOrder) -> Self {
-                (
-                    value.makerToken,
-                    value.takerToken,
-                    value.makerAmount,
-                    value.takerAmount,
-                    value.maker,
-                    value.taker,
-                    value.txOrigin,
-                    value.expiryAndNonce,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OtcOrder {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    makerToken: tuple.0,
-                    takerToken: tuple.1,
-                    makerAmount: tuple.2,
-                    takerAmount: tuple.3,
-                    maker: tuple.4,
-                    taker: tuple.5,
-                    txOrigin: tuple.6,
-                    expiryAndNonce: tuple.7,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for OtcOrder {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for OtcOrder {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.txOrigin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.expiryAndNonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for OtcOrder {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for OtcOrder {
-            const NAME: &'static str = "OtcOrder";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "OtcOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
-                     takerAmount,address maker,address taker,address txOrigin,uint256 \
-                     expiryAndNonce)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.makerToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.takerToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.maker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.taker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.txOrigin,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.expiryAndNonce,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for OtcOrder {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.makerToken,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerToken,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.makerAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.taker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.txOrigin,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expiryAndNonce,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.makerToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.makerAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.taker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.txOrigin,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expiryAndNonce,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct OtcOrderInfo { bytes32 orderHash; OrderStatus status; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct OtcOrderInfo {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub status: <OrderStatus as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>, OrderStatus);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::FixedBytes<32>,
-            <OrderStatus as alloy_sol_types::SolType>::RustType,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<OtcOrderInfo> for UnderlyingRustTuple<'_> {
-            fn from(value: OtcOrderInfo) -> Self {
-                (value.orderHash, value.status)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OtcOrderInfo {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    orderHash: tuple.0,
-                    status: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for OtcOrderInfo {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for OtcOrderInfo {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <OrderStatus as alloy_sol_types::SolType>::tokenize(&self.status),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for OtcOrderInfo {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for OtcOrderInfo {
-            const NAME: &'static str = "OtcOrderInfo";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "OtcOrderInfo(bytes32 orderHash,uint8 status)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.orderHash)
-                        .0,
-                    <OrderStatus as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.status,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for OtcOrderInfo {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.orderHash,
-                    )
-                    + <OrderStatus as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.status,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.orderHash,
-                    out,
-                );
-                <OrderStatus as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.status,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct RfqOrder { address makerToken; address takerToken; uint128 makerAmount; uint128 takerAmount; address maker; address taker; address txOrigin; bytes32 pool; uint64 expiry; uint256 salt; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct RfqOrder {
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerAmount: u128,
-        #[allow(missing_docs)]
-        pub takerAmount: u128,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub txOrigin: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub expiry: u64,
-        #[allow(missing_docs)]
-        pub salt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Uint<128>,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::Uint<64>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            u128,
-            u128,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::FixedBytes<32>,
-            u64,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<RfqOrder> for UnderlyingRustTuple<'_> {
-            fn from(value: RfqOrder) -> Self {
-                (
-                    value.makerToken,
-                    value.takerToken,
-                    value.makerAmount,
-                    value.takerAmount,
-                    value.maker,
-                    value.taker,
-                    value.txOrigin,
-                    value.pool,
-                    value.expiry,
-                    value.salt,
-                )
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for RfqOrder {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    makerToken: tuple.0,
-                    takerToken: tuple.1,
-                    makerAmount: tuple.2,
-                    takerAmount: tuple.3,
-                    maker: tuple.4,
-                    taker: tuple.5,
-                    txOrigin: tuple.6,
-                    pool: tuple.7,
-                    expiry: tuple.8,
-                    salt: tuple.9,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for RfqOrder {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for RfqOrder {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerAmount),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.txOrigin,
-                    ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
-                    <alloy_sol_types::sol_data::Uint<
-                        64,
-                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for RfqOrder {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for RfqOrder {
-            const NAME: &'static str = "RfqOrder";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "RfqOrder(address makerToken,address takerToken,uint128 makerAmount,uint128 \
-                     takerAmount,address maker,address taker,address txOrigin,bytes32 pool,uint64 \
-                     expiry,uint256 salt)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.makerToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.takerToken,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.makerAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.takerAmount)
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.maker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.taker,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.txOrigin,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pool)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        64,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for RfqOrder {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.makerToken,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerToken,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.makerAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.takerAmount,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.maker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.taker,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.txOrigin,
-                    )
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.pool)
-                    + <alloy_sol_types::sol_data::Uint<
-                        64,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.expiry,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.makerToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerToken,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.makerAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    128,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.takerAmount,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.maker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.taker,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.txOrigin,
-                    out,
-                );
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.pool,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    64,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.expiry,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.salt,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`LibNativeOrder`](self) contract instance.
-
-    See the [wrapper's documentation](`LibNativeOrderInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> LibNativeOrderInstance<P, N> {
-        LibNativeOrderInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`LibNativeOrder`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`LibNativeOrder`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct LibNativeOrderInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for LibNativeOrderInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("LibNativeOrderInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibNativeOrderInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`LibNativeOrder`](self) contract instance.
-
-        See the [wrapper's documentation](`LibNativeOrderInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> LibNativeOrderInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> LibNativeOrderInstance<P, N> {
-            LibNativeOrderInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibNativeOrderInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibNativeOrderInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-///Module containing a contract's types and functions.
-/**
-
-```solidity
-library LibSignature {
-    type SignatureType is uint8;
-    struct Signature { SignatureType signatureType; uint8 v; bytes32 r; bytes32 s; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod LibSignature {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SignatureType(u8);
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<SignatureType> for u8 {
-            #[inline]
-            fn stv_to_tokens(
-                &self,
-            ) -> <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'_>
-            {
-                alloy_sol_types::private::SolTypeValue::<
-                    alloy_sol_types::sol_data::Uint<8>,
-                >::stv_to_tokens(self)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(self).0
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::abi_encoded_size(
-                    self,
-                )
-            }
-        }
-        impl SignatureType {
-            /// The Solidity type name.
-            pub const NAME: &'static str = stringify!(@ name);
-
-            /// Convert from the underlying value type.
-            #[inline]
-            pub const fn from_underlying(value: u8) -> Self {
-                Self(value)
-            }
-
-            /// Return the underlying value.
-            #[inline]
-            pub const fn into_underlying(self) -> u8 {
-                self.0
-            }
-
-            /// Return the single encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
-            }
-
-            /// Return the packed encoding of this value, delegating to the
-            /// underlying type.
-            #[inline]
-            pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
-                <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
-            }
-        }
-        #[automatically_derived]
-        impl From<u8> for SignatureType {
-            fn from(value: u8) -> Self {
-                Self::from_underlying(value)
-            }
-        }
-        #[automatically_derived]
-        impl From<SignatureType> for u8 {
-            fn from(value: SignatureType) -> Self {
-                value.into_underlying()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SignatureType {
-            type RustType = u8;
-            type Token<'a> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> = <alloy_sol_types::sol_data::Uint<
-                8,
-            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = Self::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                Self::type_check(token).is_ok()
-            }
-
-            #[inline]
-            fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::type_check(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::detokenize(token)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SignatureType {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::EventTopic>::encode_topic(
-                    rust,
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct Signature { SignatureType signatureType; uint8 v; bytes32 r; bytes32 s; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct Signature {
-        #[allow(missing_docs)]
-        pub signatureType: <SignatureType as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            SignatureType,
-            alloy_sol_types::sol_data::Uint<8>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-            alloy_sol_types::sol_data::FixedBytes<32>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <SignatureType as alloy_sol_types::SolType>::RustType,
-            u8,
-            alloy_sol_types::private::FixedBytes<32>,
-            alloy_sol_types::private::FixedBytes<32>,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<Signature> for UnderlyingRustTuple<'_> {
-            fn from(value: Signature) -> Self {
-                (value.signatureType, value.v, value.r, value.s)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Signature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    signatureType: tuple.0,
-                    v: tuple.1,
-                    r: tuple.2,
-                    s: tuple.3,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for Signature {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for Signature {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <SignatureType as alloy_sol_types::SolType>::tokenize(
-                        &self.signatureType,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for Signature {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for Signature {
-            const NAME: &'static str = "Signature";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "Signature(uint8 signatureType,uint8 v,bytes32 r,bytes32 s)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <SignatureType as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.signatureType,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.v)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.r)
-                        .0,
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.s)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for Signature {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <SignatureType as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.signatureType,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.v)
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.r)
-                    + <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.s)
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <SignatureType as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.signatureType,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    8,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.v, out);
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.r, out);
-                <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.s, out);
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`LibSignature`](self) contract instance.
-
-    See the [wrapper's documentation](`LibSignatureInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> LibSignatureInstance<P, N> {
-        LibSignatureInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`LibSignature`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`LibSignature`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct LibSignatureInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for LibSignatureInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("LibSignatureInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibSignatureInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`LibSignature`](self) contract instance.
-
-        See the [wrapper's documentation](`LibSignatureInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> LibSignatureInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> LibSignatureInstance<P, N> {
-            LibSignatureInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibSignatureInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        LibSignatureInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IMetaTransactionsFeature {
-    struct MetaTransactionData {
-        address payable signer;
-        address sender;
-        uint256 minGasPrice;
-        uint256 maxGasPrice;
-        uint256 expirationTimeSeconds;
-        uint256 salt;
-        bytes callData;
-        uint256 value;
-        address feeToken;
-        uint256 feeAmount;
-    }
-}
-
-library IMultiplexFeature {
-    type MultiplexSubcall is uint8;
-    struct BatchSellSubcall {
-        MultiplexSubcall id;
-        uint256 sellAmount;
-        bytes data;
-    }
-    struct MultiHopSellSubcall {
-        MultiplexSubcall id;
-        bytes data;
-    }
-}
-
-library IPancakeSwapFeature {
-    type ProtocolFork is uint8;
-}
-
-library ITransformERC20Feature {
-    struct TransformERC20Args {
-        address payable taker;
-        address inputToken;
-        address outputToken;
-        uint256 inputTokenAmount;
-        uint256 minOutputTokenAmount;
-        Transformation[] transformations;
-        bool useSelfBalance;
-        address payable recipient;
-    }
-    struct Transformation {
-        uint32 deploymentNonce;
-        bytes data;
-    }
-}
-
-library LibNFTOrder {
-    type OrderStatus is uint8;
-    type TradeDirection is uint8;
-    struct ERC1155Order {
-        TradeDirection direction;
-        address maker;
-        address taker;
-        uint256 expiry;
-        uint256 nonce;
-        address erc20Token;
-        uint256 erc20TokenAmount;
-        Fee[] fees;
-        address erc1155Token;
-        uint256 erc1155TokenId;
-        Property[] erc1155TokenProperties;
-        uint128 erc1155TokenAmount;
-    }
-    struct ERC721Order {
-        TradeDirection direction;
-        address maker;
-        address taker;
-        uint256 expiry;
-        uint256 nonce;
-        address erc20Token;
-        uint256 erc20TokenAmount;
-        Fee[] fees;
-        address erc721Token;
-        uint256 erc721TokenId;
-        Property[] erc721TokenProperties;
-    }
-    struct Fee {
-        address recipient;
-        uint256 amount;
-        bytes feeData;
-    }
-    struct OrderInfo {
-        bytes32 orderHash;
-        OrderStatus status;
-        uint128 orderAmount;
-        uint128 remainingAmount;
-    }
-    struct Property {
-        address propertyValidator;
-        bytes propertyData;
-    }
-}
-
-library LibNativeOrder {
-    type OrderStatus is uint8;
-    struct LimitOrder {
-        address makerToken;
-        address takerToken;
-        uint128 makerAmount;
-        uint128 takerAmount;
-        uint128 takerTokenFeeAmount;
-        address maker;
-        address taker;
-        address sender;
-        address feeRecipient;
-        bytes32 pool;
-        uint64 expiry;
-        uint256 salt;
-    }
-    struct OrderInfo {
-        bytes32 orderHash;
-        OrderStatus status;
-        uint128 takerTokenFilledAmount;
-    }
-    struct OtcOrder {
-        address makerToken;
-        address takerToken;
-        uint128 makerAmount;
-        uint128 takerAmount;
-        address maker;
-        address taker;
-        address txOrigin;
-        uint256 expiryAndNonce;
-    }
-    struct OtcOrderInfo {
-        bytes32 orderHash;
-        OrderStatus status;
-    }
-    struct RfqOrder {
-        address makerToken;
-        address takerToken;
-        uint128 makerAmount;
-        uint128 takerAmount;
-        address maker;
-        address taker;
-        address txOrigin;
-        bytes32 pool;
-        uint64 expiry;
-        uint256 salt;
-    }
-}
-
-library LibSignature {
-    type SignatureType is uint8;
-    struct Signature {
-        SignatureType signatureType;
-        uint8 v;
-        bytes32 r;
-        bytes32 s;
-    }
-}
-
-interface IZeroex {
-    event ERC1155OrderCancelled(address maker, uint256 nonce);
-    event ERC1155OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20FillAmount, address erc1155Token, uint256 erc1155TokenId, uint128 erc1155FillAmount, address matcher);
-    event ERC1155OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc1155Token, uint256 erc1155TokenId, LibNFTOrder.Property[] erc1155TokenProperties, uint128 erc1155TokenAmount);
-    event ERC721OrderCancelled(address maker, uint256 nonce);
-    event ERC721OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, address erc721Token, uint256 erc721TokenId, address matcher);
-    event ERC721OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc721Token, uint256 erc721TokenId, LibNFTOrder.Property[] erc721TokenProperties);
-    event LimitOrderFilled(bytes32 orderHash, address maker, address taker, address feeRecipient, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, uint128 takerTokenFeeFilledAmount, uint256 protocolFeePaid, bytes32 pool);
-    event LiquidityProviderSwap(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount, address provider, address recipient);
-    event MetaTransactionExecuted(bytes32 hash, bytes4 indexed selector, address signer, address sender);
-    event Migrated(address caller, address migrator, address newOwner);
-    event OrderCancelled(bytes32 orderHash, address maker);
-    event OrderSignerRegistered(address maker, address signer, bool allowed);
-    event OtcOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 makerTokenFilledAmount, uint128 takerTokenFilledAmount);
-    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
-    event PairCancelledLimitOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
-    event PairCancelledRfqOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
-    event ProxyFunctionUpdated(bytes4 indexed selector, address oldImpl, address newImpl);
-    event QuoteSignerUpdated(address quoteSigner);
-    event RfqOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, bytes32 pool);
-    event RfqOrderOriginsAllowed(address origin, address[] addrs, bool allowed);
-    event TransformedERC20(address indexed taker, address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount);
-    event TransformerDeployerUpdated(address transformerDeployer);
-
-    function _fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, address sender) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function _fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function _fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function _sellHeldTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
-    function _transformERC20(ITransformERC20Feature.TransformERC20Args memory args) external payable returns (uint256 outputTokenAmount);
-    function batchBuyERC1155s(LibNFTOrder.ERC1155Order[] memory sellOrders, LibSignature.Signature[] memory signatures, uint128[] memory erc1155TokenAmounts, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
-    function batchBuyERC721s(LibNFTOrder.ERC721Order[] memory sellOrders, LibSignature.Signature[] memory signatures, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
-    function batchCancelERC1155Orders(uint256[] memory orderNonces) external;
-    function batchCancelERC721Orders(uint256[] memory orderNonces) external;
-    function batchCancelLimitOrders(LibNativeOrder.LimitOrder[] memory orders) external;
-    function batchCancelPairLimitOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    function batchCancelPairLimitOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    function batchCancelPairRfqOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    function batchCancelPairRfqOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    function batchCancelRfqOrders(LibNativeOrder.RfqOrder[] memory orders) external;
-    function batchExecuteMetaTransactions(IMetaTransactionsFeature.MetaTransactionData[] memory mtxs, LibSignature.Signature[] memory signatures) external payable returns (bytes[] memory returnResults);
-    function batchFillLimitOrders(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external payable returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
-    function batchFillRfqOrders(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
-    function batchFillTakerSignedOtcOrders(LibNativeOrder.OtcOrder[] memory orders, LibSignature.Signature[] memory makerSignatures, LibSignature.Signature[] memory takerSignatures, bool[] memory unwrapWeth) external returns (bool[] memory successes);
-    function batchGetLimitOrderRelevantStates(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
-    function batchGetRfqOrderRelevantStates(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
-    function batchMatchERC721Orders(LibNFTOrder.ERC721Order[] memory sellOrders, LibNFTOrder.ERC721Order[] memory buyOrders, LibSignature.Signature[] memory sellOrderSignatures, LibSignature.Signature[] memory buyOrderSignatures) external returns (uint256[] memory profits, bool[] memory successes);
-    function buyERC1155(LibNFTOrder.ERC1155Order memory sellOrder, LibSignature.Signature memory signature, uint128 erc1155BuyAmount, bytes memory callbackData) external payable;
-    function buyERC721(LibNFTOrder.ERC721Order memory sellOrder, LibSignature.Signature memory signature, bytes memory callbackData) external payable;
-    function cancelERC1155Order(uint256 orderNonce) external;
-    function cancelERC721Order(uint256 orderNonce) external;
-    function cancelLimitOrder(LibNativeOrder.LimitOrder memory order) external;
-    function cancelPairLimitOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
-    function cancelPairLimitOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
-    function cancelPairRfqOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
-    function cancelPairRfqOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
-    function cancelRfqOrder(LibNativeOrder.RfqOrder memory order) external;
-    function createTransformWallet() external returns (address wallet);
-    function executeMetaTransaction(IMetaTransactionsFeature.MetaTransactionData memory mtx, LibSignature.Signature memory signature) external payable returns (bytes memory returnResult);
-    function extend(bytes4 selector, address impl) external;
-    function fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function fillOrKillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 makerTokenFilledAmount);
-    function fillOrKillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 makerTokenFilledAmount);
-    function fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function fillOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function fillOtcOrderWithEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    function fillTakerSignedOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
-    function fillTakerSignedOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
-    function getERC1155OrderHash(LibNFTOrder.ERC1155Order memory order) external view returns (bytes32 orderHash);
-    function getERC1155OrderInfo(LibNFTOrder.ERC1155Order memory order) external view returns (LibNFTOrder.OrderInfo memory orderInfo);
-    function getERC721OrderHash(LibNFTOrder.ERC721Order memory order) external view returns (bytes32 orderHash);
-    function getERC721OrderStatus(LibNFTOrder.ERC721Order memory order) external view returns (LibNFTOrder.OrderStatus status);
-    function getERC721OrderStatusBitVector(address maker, uint248 nonceRange) external view returns (uint256 bitVector);
-    function getLimitOrderHash(LibNativeOrder.LimitOrder memory order) external view returns (bytes32 orderHash);
-    function getLimitOrderInfo(LibNativeOrder.LimitOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
-    function getLimitOrderRelevantState(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
-    function getMetaTransactionExecutedBlock(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (uint256 blockNumber);
-    function getMetaTransactionHash(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (bytes32 mtxHash);
-    function getMetaTransactionHashExecutedBlock(bytes32 mtxHash) external view returns (uint256 blockNumber);
-    function getOtcOrderHash(LibNativeOrder.OtcOrder memory order) external view returns (bytes32 orderHash);
-    function getOtcOrderInfo(LibNativeOrder.OtcOrder memory order) external view returns (LibNativeOrder.OtcOrderInfo memory orderInfo);
-    function getProtocolFeeMultiplier() external view returns (uint32 multiplier);
-    function getQuoteSigner() external view returns (address signer);
-    function getRfqOrderHash(LibNativeOrder.RfqOrder memory order) external view returns (bytes32 orderHash);
-    function getRfqOrderInfo(LibNativeOrder.RfqOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
-    function getRfqOrderRelevantState(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
-    function getRollbackEntryAtIndex(bytes4 selector, uint256 idx) external view returns (address impl);
-    function getRollbackLength(bytes4 selector) external view returns (uint256 rollbackLength);
-    function getTransformWallet() external view returns (address wallet);
-    function getTransformerDeployer() external view returns (address deployer);
-    function isValidOrderSigner(address maker, address signer) external view returns (bool isAllowed);
-    function lastOtcTxOriginNonce(address txOrigin, uint64 nonceBucket) external view returns (uint128 lastNonce);
-    function matchERC721Orders(LibNFTOrder.ERC721Order memory sellOrder, LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory sellOrderSignature, LibSignature.Signature memory buyOrderSignature) external returns (uint256 profit);
-    function migrate(address target, bytes memory data, address newOwner) external;
-    function multiplexBatchSellEthForToken(address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
-    function multiplexBatchSellTokenForEth(address inputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    function multiplexBatchSellTokenForToken(address inputToken, address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    function multiplexMultiHopSellEthForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
-    function multiplexMultiHopSellTokenForEth(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    function multiplexMultiHopSellTokenForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    function onERC1155Received(address operator, address from, uint256 tokenId, uint256 value, bytes memory data) external returns (bytes4 success);
-    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) external returns (bytes4 success);
-    function owner() external view returns (address ownerAddress);
-    function preSignERC1155Order(LibNFTOrder.ERC1155Order memory order) external;
-    function preSignERC721Order(LibNFTOrder.ERC721Order memory order) external;
-    function registerAllowedOrderSigner(address signer, bool allowed) external;
-    function registerAllowedRfqOrigins(address[] memory origins, bool allowed) external;
-    function rollback(bytes4 selector, address targetImpl) external;
-    function sellERC1155(LibNFTOrder.ERC1155Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc1155TokenId, uint128 erc1155SellAmount, bool unwrapNativeToken, bytes memory callbackData) external;
-    function sellERC721(LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc721TokenId, bool unwrapNativeToken, bytes memory callbackData) external;
-    function sellEthForTokenToUniswapV3(bytes memory encodedPath, uint256 minBuyAmount, address recipient) external payable returns (uint256 buyAmount);
-    function sellToLiquidityProvider(address inputToken, address outputToken, address provider, address recipient, uint256 sellAmount, uint256 minBuyAmount, bytes memory auxiliaryData) external payable returns (uint256 boughtAmount);
-    function sellToPancakeSwap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, IPancakeSwapFeature.ProtocolFork fork) external payable returns (uint256 buyAmount);
-    function sellToUniswap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, bool isSushi) external payable returns (uint256 buyAmount);
-    function sellTokenForEthToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address payable recipient) external returns (uint256 buyAmount);
-    function sellTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
-    function setQuoteSigner(address quoteSigner) external;
-    function setTransformerDeployer(address transformerDeployer) external;
-    function supportInterface(bytes4 interfaceId) external pure returns (bool isSupported);
-    function transferOwnership(address newOwner) external;
-    function transferProtocolFeesForPools(bytes32[] memory poolIds) external;
-    function transferTrappedTokensTo(address erc20, uint256 amountOut, address payable recipientWallet) external;
-    function transformERC20(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 minOutputTokenAmount, ITransformERC20Feature.Transformation[] memory transformations) external payable returns (uint256 outputTokenAmount);
-    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data) external;
-    function validateERC1155OrderProperties(LibNFTOrder.ERC1155Order memory order, uint256 erc1155TokenId) external view;
-    function validateERC1155OrderSignature(LibNFTOrder.ERC1155Order memory order, LibSignature.Signature memory signature) external view;
-    function validateERC721OrderProperties(LibNFTOrder.ERC721Order memory order, uint256 erc721TokenId) external view;
-    function validateERC721OrderSignature(LibNFTOrder.ERC721Order memory order, LibSignature.Signature memory signature) external view;
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "function",
-    "name": "_fillLimitOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "_fillOtcOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "useSelfBalance",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "_fillRfqOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "useSelfBalance",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "_sellHeldTokenForTokenToUniswapV3",
-    "inputs": [
-      {
-        "name": "encodedPath",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "buyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "_transformERC20",
-    "inputs": [
-      {
-        "name": "args",
-        "type": "tuple",
-        "internalType": "struct ITransformERC20Feature.TransformERC20Args",
-        "components": [
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "inputToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "outputToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "inputTokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "minOutputTokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "transformations",
-            "type": "tuple[]",
-            "internalType": "struct ITransformERC20Feature.Transformation[]",
-            "components": [
-              {
-                "name": "deploymentNonce",
-                "type": "uint32",
-                "internalType": "uint32"
-              },
-              {
-                "name": "data",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "useSelfBalance",
-            "type": "bool",
-            "internalType": "bool"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address payable"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "outputTokenAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "batchBuyERC1155s",
-    "inputs": [
-      {
-        "name": "sellOrders",
-        "type": "tuple[]",
-        "internalType": "struct LibNFTOrder.ERC1155Order[]",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "erc1155TokenAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "callbackData",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      },
-      {
-        "name": "revertIfIncomplete",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "successes",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "batchBuyERC721s",
-    "inputs": [
-      {
-        "name": "sellOrders",
-        "type": "tuple[]",
-        "internalType": "struct LibNFTOrder.ERC721Order[]",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "callbackData",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      },
-      {
-        "name": "revertIfIncomplete",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "successes",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelERC1155Orders",
-    "inputs": [
-      {
-        "name": "orderNonces",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelERC721Orders",
-    "inputs": [
-      {
-        "name": "orderNonces",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelLimitOrders",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.LimitOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelPairLimitOrders",
-    "inputs": [
-      {
-        "name": "makerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "takerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "minValidSalts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelPairLimitOrdersWithSigner",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "makerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "takerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "minValidSalts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelPairRfqOrders",
-    "inputs": [
-      {
-        "name": "makerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "takerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "minValidSalts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelPairRfqOrdersWithSigner",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "makerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "takerTokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "minValidSalts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchCancelRfqOrders",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.RfqOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchExecuteMetaTransactions",
-    "inputs": [
-      {
-        "name": "mtxs",
-        "type": "tuple[]",
-        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData[]",
-        "components": [
-          {
-            "name": "signer",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "maxGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "expirationTimeSeconds",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "callData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "value",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "feeToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "feeAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "returnResults",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "batchFillLimitOrders",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.LimitOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "revertIfIncomplete",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "makerTokenFilledAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "batchFillRfqOrders",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.RfqOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "revertIfIncomplete",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "makerTokenFilledAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchFillTakerSignedOtcOrders",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.OtcOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerSignatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "unwrapWeth",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "successes",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "batchGetLimitOrderRelevantStates",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.LimitOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfos",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.OrderInfo[]",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          },
-          {
-            "name": "takerTokenFilledAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "actualFillableTakerTokenAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "isSignatureValids",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "batchGetRfqOrderRelevantStates",
-    "inputs": [
-      {
-        "name": "orders",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.RfqOrder[]",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfos",
-        "type": "tuple[]",
-        "internalType": "struct LibNativeOrder.OrderInfo[]",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          },
-          {
-            "name": "takerTokenFilledAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "actualFillableTakerTokenAmounts",
-        "type": "uint128[]",
-        "internalType": "uint128[]"
-      },
-      {
-        "name": "isSignatureValids",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "batchMatchERC721Orders",
-    "inputs": [
-      {
-        "name": "sellOrders",
-        "type": "tuple[]",
-        "internalType": "struct LibNFTOrder.ERC721Order[]",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "buyOrders",
-        "type": "tuple[]",
-        "internalType": "struct LibNFTOrder.ERC721Order[]",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "sellOrderSignatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "buyOrderSignatures",
-        "type": "tuple[]",
-        "internalType": "struct LibSignature.Signature[]",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "profits",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      },
-      {
-        "name": "successes",
-        "type": "bool[]",
-        "internalType": "bool[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "buyERC1155",
-    "inputs": [
-      {
-        "name": "sellOrder",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "erc1155BuyAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "callbackData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "buyERC721",
-    "inputs": [
-      {
-        "name": "sellOrder",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "callbackData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "cancelERC1155Order",
-    "inputs": [
-      {
-        "name": "orderNonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelERC721Order",
-    "inputs": [
-      {
-        "name": "orderNonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelLimitOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelPairLimitOrders",
-    "inputs": [
-      {
-        "name": "makerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "minValidSalt",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelPairLimitOrdersWithSigner",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "minValidSalt",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelPairRfqOrders",
-    "inputs": [
-      {
-        "name": "makerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "minValidSalt",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelPairRfqOrdersWithSigner",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "minValidSalt",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "cancelRfqOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "createTransformWallet",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "wallet",
-        "type": "address",
-        "internalType": "contract IFlashWallet"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "executeMetaTransaction",
-    "inputs": [
-      {
-        "name": "mtx",
-        "type": "tuple",
-        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
-        "components": [
-          {
-            "name": "signer",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "maxGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "expirationTimeSeconds",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "callData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "value",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "feeToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "feeAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "returnResult",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "extend",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      },
-      {
-        "name": "impl",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "fillLimitOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "fillOrKillLimitOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "fillOrKillRfqOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "fillOtcOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "fillOtcOrderForEth",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "fillOtcOrderWithEth",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "fillRfqOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerTokenFillAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "fillTakerSignedOtcOrder",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "fillTakerSignedOtcOrderForEth",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "makerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "takerSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "getERC1155OrderHash",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getERC1155OrderInfo",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfo",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.OrderInfo",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.OrderStatus"
-          },
-          {
-            "name": "orderAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "remainingAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getERC721OrderHash",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getERC721OrderStatus",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "status",
-        "type": "uint8",
-        "internalType": "enum LibNFTOrder.OrderStatus"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getERC721OrderStatusBitVector",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "nonceRange",
-        "type": "uint248",
-        "internalType": "uint248"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "bitVector",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getLimitOrderHash",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getLimitOrderInfo",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfo",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OrderInfo",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          },
-          {
-            "name": "takerTokenFilledAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getLimitOrderRelevantState",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.LimitOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerTokenFeeAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "feeRecipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfo",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OrderInfo",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          },
-          {
-            "name": "takerTokenFilledAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "actualFillableTakerTokenAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "isSignatureValid",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getMetaTransactionExecutedBlock",
-    "inputs": [
-      {
-        "name": "mtx",
-        "type": "tuple",
-        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
-        "components": [
-          {
-            "name": "signer",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "maxGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "expirationTimeSeconds",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "callData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "value",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "feeToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "feeAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "blockNumber",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getMetaTransactionHash",
-    "inputs": [
-      {
-        "name": "mtx",
-        "type": "tuple",
-        "internalType": "struct IMetaTransactionsFeature.MetaTransactionData",
-        "components": [
-          {
-            "name": "signer",
-            "type": "address",
-            "internalType": "address payable"
-          },
-          {
-            "name": "sender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "maxGasPrice",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "expirationTimeSeconds",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "callData",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "value",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "feeToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "feeAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "mtxHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getMetaTransactionHashExecutedBlock",
-    "inputs": [
-      {
-        "name": "mtxHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "blockNumber",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getOtcOrderHash",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getOtcOrderInfo",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiryAndNonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfo",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OtcOrderInfo",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getProtocolFeeMultiplier",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "multiplier",
-        "type": "uint32",
-        "internalType": "uint32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getQuoteSigner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "signer",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRfqOrderHash",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRfqOrderInfo",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfo",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OrderInfo",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          },
-          {
-            "name": "takerTokenFilledAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRfqOrderRelevantState",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.RfqOrder",
-        "components": [
-          {
-            "name": "makerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "takerToken",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "makerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "takerAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "txOrigin",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "pool",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "expiry",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "salt",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "orderInfo",
-        "type": "tuple",
-        "internalType": "struct LibNativeOrder.OrderInfo",
-        "components": [
-          {
-            "name": "orderHash",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "status",
-            "type": "uint8",
-            "internalType": "enum LibNativeOrder.OrderStatus"
-          },
-          {
-            "name": "takerTokenFilledAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "actualFillableTakerTokenAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "isSignatureValid",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRollbackEntryAtIndex",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      },
-      {
-        "name": "idx",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "impl",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getRollbackLength",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "rollbackLength",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getTransformWallet",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "wallet",
-        "type": "address",
-        "internalType": "contract IFlashWallet"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getTransformerDeployer",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "deployer",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "isValidOrderSigner",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "signer",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "isAllowed",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "lastOtcTxOriginNonce",
-    "inputs": [
-      {
-        "name": "txOrigin",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "nonceBucket",
-        "type": "uint64",
-        "internalType": "uint64"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "lastNonce",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "matchERC721Orders",
-    "inputs": [
-      {
-        "name": "sellOrder",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "buyOrder",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "sellOrderSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "buyOrderSignature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "profit",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "migrate",
-    "inputs": [
-      {
-        "name": "target",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "newOwner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "multiplexBatchSellEthForToken",
-    "inputs": [
-      {
-        "name": "outputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "calls",
-        "type": "tuple[]",
-        "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
-        "components": [
-          {
-            "name": "id",
-            "type": "uint8",
-            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
-          },
-          {
-            "name": "sellAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "multiplexBatchSellTokenForEth",
-    "inputs": [
-      {
-        "name": "inputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "calls",
-        "type": "tuple[]",
-        "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
-        "components": [
-          {
-            "name": "id",
-            "type": "uint8",
-            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
-          },
-          {
-            "name": "sellAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "multiplexBatchSellTokenForToken",
-    "inputs": [
-      {
-        "name": "inputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "outputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "calls",
-        "type": "tuple[]",
-        "internalType": "struct IMultiplexFeature.BatchSellSubcall[]",
-        "components": [
-          {
-            "name": "id",
-            "type": "uint8",
-            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
-          },
-          {
-            "name": "sellAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "multiplexMultiHopSellEthForToken",
-    "inputs": [
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "calls",
-        "type": "tuple[]",
-        "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
-        "components": [
-          {
-            "name": "id",
-            "type": "uint8",
-            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "multiplexMultiHopSellTokenForEth",
-    "inputs": [
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "calls",
-        "type": "tuple[]",
-        "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
-        "components": [
-          {
-            "name": "id",
-            "type": "uint8",
-            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "multiplexMultiHopSellTokenForToken",
-    "inputs": [
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "calls",
-        "type": "tuple[]",
-        "internalType": "struct IMultiplexFeature.MultiHopSellSubcall[]",
-        "components": [
-          {
-            "name": "id",
-            "type": "uint8",
-            "internalType": "enum IMultiplexFeature.MultiplexSubcall"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onERC1155Received",
-    "inputs": [
-      {
-        "name": "operator",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "from",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenId",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "success",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "onERC721Received",
-    "inputs": [
-      {
-        "name": "operator",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "from",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenId",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "success",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "owner",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "ownerAddress",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "preSignERC1155Order",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "preSignERC721Order",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "registerAllowedOrderSigner",
-    "inputs": [
-      {
-        "name": "signer",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "allowed",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "registerAllowedRfqOrigins",
-    "inputs": [
-      {
-        "name": "origins",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "allowed",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "rollback",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      },
-      {
-        "name": "targetImpl",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "sellERC1155",
-    "inputs": [
-      {
-        "name": "buyOrder",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "erc1155TokenId",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc1155SellAmount",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "unwrapNativeToken",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "callbackData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "sellERC721",
-    "inputs": [
-      {
-        "name": "buyOrder",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      },
-      {
-        "name": "erc721TokenId",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "unwrapNativeToken",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "callbackData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "sellEthForTokenToUniswapV3",
-    "inputs": [
-      {
-        "name": "encodedPath",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "buyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "sellToLiquidityProvider",
-    "inputs": [
-      {
-        "name": "inputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "outputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "provider",
-        "type": "address",
-        "internalType": "contract ILiquidityProvider"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "auxiliaryData",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "boughtAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "sellToPancakeSwap",
-    "inputs": [
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "fork",
-        "type": "uint8",
-        "internalType": "enum IPancakeSwapFeature.ProtocolFork"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "buyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "sellToUniswap",
-    "inputs": [
-      {
-        "name": "tokens",
-        "type": "address[]",
-        "internalType": "contract IERC20TokenV06[]"
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "isSushi",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "buyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "sellTokenForEthToUniswapV3",
-    "inputs": [
-      {
-        "name": "encodedPath",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address payable"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "buyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "sellTokenForTokenToUniswapV3",
-    "inputs": [
-      {
-        "name": "encodedPath",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "sellAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minBuyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "buyAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setQuoteSigner",
-    "inputs": [
-      {
-        "name": "quoteSigner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setTransformerDeployer",
-    "inputs": [
-      {
-        "name": "transformerDeployer",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "supportInterface",
-    "inputs": [
-      {
-        "name": "interfaceId",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "isSupported",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "transferOwnership",
-    "inputs": [
-      {
-        "name": "newOwner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferProtocolFeesForPools",
-    "inputs": [
-      {
-        "name": "poolIds",
-        "type": "bytes32[]",
-        "internalType": "bytes32[]"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferTrappedTokensTo",
-    "inputs": [
-      {
-        "name": "erc20",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "recipientWallet",
-        "type": "address",
-        "internalType": "address payable"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transformERC20",
-    "inputs": [
-      {
-        "name": "inputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "outputToken",
-        "type": "address",
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "inputTokenAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "minOutputTokenAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "transformations",
-        "type": "tuple[]",
-        "internalType": "struct ITransformERC20Feature.Transformation[]",
-        "components": [
-          {
-            "name": "deploymentNonce",
-            "type": "uint32",
-            "internalType": "uint32"
-          },
-          {
-            "name": "data",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "outputTokenAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "uniswapV3SwapCallback",
-    "inputs": [
-      {
-        "name": "amount0Delta",
-        "type": "int256",
-        "internalType": "int256"
-      },
-      {
-        "name": "amount1Delta",
-        "type": "int256",
-        "internalType": "int256"
-      },
-      {
-        "name": "data",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "validateERC1155OrderProperties",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "erc1155TokenId",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "validateERC1155OrderSignature",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC1155Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155Token",
-            "type": "address",
-            "internalType": "contract IERC1155Token"
-          },
-          {
-            "name": "erc1155TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc1155TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc1155TokenAmount",
-            "type": "uint128",
-            "internalType": "uint128"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "validateERC721OrderProperties",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "erc721TokenId",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "validateERC721OrderSignature",
-    "inputs": [
-      {
-        "name": "order",
-        "type": "tuple",
-        "internalType": "struct LibNFTOrder.ERC721Order",
-        "components": [
-          {
-            "name": "direction",
-            "type": "uint8",
-            "internalType": "enum LibNFTOrder.TradeDirection"
-          },
-          {
-            "name": "maker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "taker",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "expiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc20Token",
-            "type": "address",
-            "internalType": "contract IERC20TokenV06"
-          },
-          {
-            "name": "erc20TokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "fees",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Fee[]",
-            "components": [
-              {
-                "name": "recipient",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "feeData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "erc721Token",
-            "type": "address",
-            "internalType": "contract IERC721Token"
-          },
-          {
-            "name": "erc721TokenId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "erc721TokenProperties",
-            "type": "tuple[]",
-            "internalType": "struct LibNFTOrder.Property[]",
-            "components": [
-              {
-                "name": "propertyValidator",
-                "type": "address",
-                "internalType": "contract IPropertyValidator"
-              },
-              {
-                "name": "propertyData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "tuple",
-        "internalType": "struct LibSignature.Signature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum LibSignature.SignatureType"
-          },
-          {
-            "name": "v",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "r",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          },
-          {
-            "name": "s",
-            "type": "bytes32",
-            "internalType": "bytes32"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "event",
-    "name": "ERC1155OrderCancelled",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ERC1155OrderFilled",
-    "inputs": [
-      {
-        "name": "direction",
-        "type": "uint8",
-        "indexed": false,
-        "internalType": "enum LibNFTOrder.TradeDirection"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc20Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "erc20FillAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc1155Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC1155Token"
-      },
-      {
-        "name": "erc1155TokenId",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc1155FillAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "matcher",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ERC1155OrderPreSigned",
-    "inputs": [
-      {
-        "name": "direction",
-        "type": "uint8",
-        "indexed": false,
-        "internalType": "enum LibNFTOrder.TradeDirection"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "expiry",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc20Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "erc20TokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "fees",
-        "type": "tuple[]",
-        "indexed": false,
-        "internalType": "struct LibNFTOrder.Fee[]",
-        "components": [
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "feeData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "erc1155Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC1155Token"
-      },
-      {
-        "name": "erc1155TokenId",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc1155TokenProperties",
-        "type": "tuple[]",
-        "indexed": false,
-        "internalType": "struct LibNFTOrder.Property[]",
-        "components": [
-          {
-            "name": "propertyValidator",
-            "type": "address",
-            "internalType": "contract IPropertyValidator"
-          },
-          {
-            "name": "propertyData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "erc1155TokenAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ERC721OrderCancelled",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ERC721OrderFilled",
-    "inputs": [
-      {
-        "name": "direction",
-        "type": "uint8",
-        "indexed": false,
-        "internalType": "enum LibNFTOrder.TradeDirection"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc20Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "erc20TokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc721Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC721Token"
-      },
-      {
-        "name": "erc721TokenId",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "matcher",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ERC721OrderPreSigned",
-    "inputs": [
-      {
-        "name": "direction",
-        "type": "uint8",
-        "indexed": false,
-        "internalType": "enum LibNFTOrder.TradeDirection"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "expiry",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc20Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "erc20TokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "fees",
-        "type": "tuple[]",
-        "indexed": false,
-        "internalType": "struct LibNFTOrder.Fee[]",
-        "components": [
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "feeData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "erc721Token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC721Token"
-      },
-      {
-        "name": "erc721TokenId",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "erc721TokenProperties",
-        "type": "tuple[]",
-        "indexed": false,
-        "internalType": "struct LibNFTOrder.Property[]",
-        "components": [
-          {
-            "name": "propertyValidator",
-            "type": "address",
-            "internalType": "contract IPropertyValidator"
-          },
-          {
-            "name": "propertyData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "LimitOrderFilled",
-    "inputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "feeRecipient",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "takerTokenFeeFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "protocolFeePaid",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "pool",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "LiquidityProviderSwap",
-    "inputs": [
-      {
-        "name": "inputToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "outputToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract IERC20TokenV06"
-      },
-      {
-        "name": "inputTokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "outputTokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "provider",
-        "type": "address",
-        "indexed": false,
-        "internalType": "contract ILiquidityProvider"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "MetaTransactionExecuted",
-    "inputs": [
-      {
-        "name": "hash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "indexed": true,
-        "internalType": "bytes4"
-      },
-      {
-        "name": "signer",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "sender",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Migrated",
-    "inputs": [
-      {
-        "name": "caller",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "migrator",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "newOwner",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "OrderCancelled",
-    "inputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "OrderSignerRegistered",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "signer",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "allowed",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "OtcOrderFilled",
-    "inputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "OwnershipTransferred",
-    "inputs": [
-      {
-        "name": "previousOwner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "newOwner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PairCancelledLimitOrders",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "minValidSalt",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "PairCancelledRfqOrders",
-    "inputs": [
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "minValidSalt",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "ProxyFunctionUpdated",
-    "inputs": [
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "indexed": true,
-        "internalType": "bytes4"
-      },
-      {
-        "name": "oldImpl",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "newImpl",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "QuoteSignerUpdated",
-    "inputs": [
-      {
-        "name": "quoteSigner",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "RfqOrderFilled",
-    "inputs": [
-      {
-        "name": "orderHash",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "maker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "makerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "takerTokenFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "makerTokenFilledAmount",
-        "type": "uint128",
-        "indexed": false,
-        "internalType": "uint128"
-      },
-      {
-        "name": "pool",
-        "type": "bytes32",
-        "indexed": false,
-        "internalType": "bytes32"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "RfqOrderOriginsAllowed",
-    "inputs": [
-      {
-        "name": "origin",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "addrs",
-        "type": "address[]",
-        "indexed": false,
-        "internalType": "address[]"
-      },
-      {
-        "name": "allowed",
-        "type": "bool",
-        "indexed": false,
-        "internalType": "bool"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TransformedERC20",
-    "inputs": [
-      {
-        "name": "taker",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "inputToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "outputToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "inputTokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "outputTokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TransformerDeployerUpdated",
-    "inputs": [
-      {
-        "name": "transformerDeployer",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod IZeroex {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ERC1155OrderCancelled(address,uint256)` and selector `0x4d5ea7da64f50a4a329921b8d2cab52dff4ebcc58b61d10ff839e28e91445684`.
-    ```solidity
-    event ERC1155OrderCancelled(address maker, uint256 nonce);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ERC1155OrderCancelled {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ERC1155OrderCancelled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ERC1155OrderCancelled(address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    77u8, 94u8, 167u8, 218u8, 100u8, 245u8, 10u8, 74u8, 50u8, 153u8, 33u8, 184u8,
-                    210u8, 202u8, 181u8, 45u8, 255u8, 78u8, 188u8, 197u8, 139u8, 97u8, 209u8, 15u8,
-                    248u8, 57u8, 226u8, 142u8, 145u8, 68u8, 86u8, 132u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    maker: data.0,
-                    nonce: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ERC1155OrderCancelled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ERC1155OrderCancelled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ERC1155OrderCancelled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ERC1155OrderFilled(uint8,address,address,uint256,address,uint256,address,uint256,uint128,address)` and selector `0x20cca81b0e269b265b3229d6b537da91ef475ca0ef55caed7dd30731700ba98d`.
-    ```solidity
-    event ERC1155OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20FillAmount, address erc1155Token, uint256 erc1155TokenId, uint128 erc1155FillAmount, address matcher);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ERC1155OrderFilled {
-        #[allow(missing_docs)]
-        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc20Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc20FillAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc1155Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc1155FillAmount: u128,
-        #[allow(missing_docs)]
-        pub matcher: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ERC1155OrderFilled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                LibNFTOrder::TradeDirection,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ERC1155OrderFilled(uint8,address,address,uint256,\
-                                             address,uint256,address,uint256,uint128,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    32u8, 204u8, 168u8, 27u8, 14u8, 38u8, 155u8, 38u8, 91u8, 50u8, 41u8, 214u8,
-                    181u8, 55u8, 218u8, 145u8, 239u8, 71u8, 92u8, 160u8, 239u8, 85u8, 202u8, 237u8,
-                    125u8, 211u8, 7u8, 49u8, 112u8, 11u8, 169u8, 141u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    direction: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    nonce: data.3,
-                    erc20Token: data.4,
-                    erc20FillAmount: data.5,
-                    erc1155Token: data.6,
-                    erc1155TokenId: data.7,
-                    erc1155FillAmount: data.8,
-                    matcher: data.9,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
-                        &self.direction,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20FillAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155TokenId,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155FillAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.matcher,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ERC1155OrderFilled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ERC1155OrderFilled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ERC1155OrderFilled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ERC1155OrderPreSigned(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)` and selector `0x5e91ddfeb7bf2e12f7e8ab017d2b63a9217f004a15a53346ad90353ec63d14e4`.
-    ```solidity
-    event ERC1155OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc1155Token, uint256 erc1155TokenId, LibNFTOrder.Property[] erc1155TokenProperties, uint128 erc1155TokenAmount);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ERC1155OrderPreSigned {
-        #[allow(missing_docs)]
-        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc20Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub fees:
-            alloy_sol_types::private::Vec<<LibNFTOrder::Fee as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub erc1155Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc1155TokenProperties: alloy_sol_types::private::Vec<
-            <LibNFTOrder::Property as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub erc1155TokenAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ERC1155OrderPreSigned {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                LibNFTOrder::TradeDirection,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<LibNFTOrder::Fee>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<LibNFTOrder::Property>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ERC1155OrderPreSigned(uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[],uint128)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    94u8, 145u8, 221u8, 254u8, 183u8, 191u8, 46u8, 18u8, 247u8, 232u8, 171u8, 1u8,
-                    125u8, 43u8, 99u8, 169u8, 33u8, 127u8, 0u8, 74u8, 21u8, 165u8, 51u8, 70u8,
-                    173u8, 144u8, 53u8, 62u8, 198u8, 61u8, 20u8, 228u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    direction: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    expiry: data.3,
-                    nonce: data.4,
-                    erc20Token: data.5,
-                    erc20TokenAmount: data.6,
-                    fees: data.7,
-                    erc1155Token: data.8,
-                    erc1155TokenId: data.9,
-                    erc1155TokenProperties: data.10,
-                    erc1155TokenAmount: data.11,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
-                        &self.direction,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::Fee,
-                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenId),
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::Property,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155TokenProperties,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmount),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ERC1155OrderPreSigned {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ERC1155OrderPreSigned> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ERC1155OrderPreSigned) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ERC721OrderCancelled(address,uint256)` and selector `0xa015ad2dc32f266993958a0fd9884c746b971b254206f3478bc43e2f125c7b9e`.
-    ```solidity
-    event ERC721OrderCancelled(address maker, uint256 nonce);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ERC721OrderCancelled {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ERC721OrderCancelled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ERC721OrderCancelled(address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    160u8, 21u8, 173u8, 45u8, 195u8, 47u8, 38u8, 105u8, 147u8, 149u8, 138u8, 15u8,
-                    217u8, 136u8, 76u8, 116u8, 107u8, 151u8, 27u8, 37u8, 66u8, 6u8, 243u8, 71u8,
-                    139u8, 196u8, 62u8, 47u8, 18u8, 92u8, 123u8, 158u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    maker: data.0,
-                    nonce: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ERC721OrderCancelled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ERC721OrderCancelled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ERC721OrderCancelled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ERC721OrderFilled(uint8,address,address,uint256,address,uint256,address,uint256,address)` and selector `0x50273fa02273cceea9cf085b42de5c8af60624140168bd71357db833535877af`.
-    ```solidity
-    event ERC721OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, address erc721Token, uint256 erc721TokenId, address matcher);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ERC721OrderFilled {
-        #[allow(missing_docs)]
-        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc20Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc721Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub matcher: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ERC721OrderFilled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                LibNFTOrder::TradeDirection,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ERC721OrderFilled(uint8,address,address,uint256,\
-                                             address,uint256,address,uint256,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    80u8, 39u8, 63u8, 160u8, 34u8, 115u8, 204u8, 238u8, 169u8, 207u8, 8u8, 91u8,
-                    66u8, 222u8, 92u8, 138u8, 246u8, 6u8, 36u8, 20u8, 1u8, 104u8, 189u8, 113u8,
-                    53u8, 125u8, 184u8, 51u8, 83u8, 88u8, 119u8, 175u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    direction: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    nonce: data.3,
-                    erc20Token: data.4,
-                    erc20TokenAmount: data.5,
-                    erc721Token: data.6,
-                    erc721TokenId: data.7,
-                    matcher: data.8,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
-                        &self.direction,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20TokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc721Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc721TokenId,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.matcher,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ERC721OrderFilled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ERC721OrderFilled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ERC721OrderFilled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ERC721OrderPreSigned(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])` and selector `0x8c5d0c41fb16a7317a6c55ff7ba93d9d74f79e434fefa694e50d6028afbfa3f0`.
-    ```solidity
-    event ERC721OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc721Token, uint256 erc721TokenId, LibNFTOrder.Property[] erc721TokenProperties);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ERC721OrderPreSigned {
-        #[allow(missing_docs)]
-        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc20Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub fees:
-            alloy_sol_types::private::Vec<<LibNFTOrder::Fee as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub erc721Token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc721TokenProperties: alloy_sol_types::private::Vec<
-            <LibNFTOrder::Property as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ERC721OrderPreSigned {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                LibNFTOrder::TradeDirection,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<LibNFTOrder::Fee>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<LibNFTOrder::Property>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ERC721OrderPreSigned(uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[])";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    140u8, 93u8, 12u8, 65u8, 251u8, 22u8, 167u8, 49u8, 122u8, 108u8, 85u8, 255u8,
-                    123u8, 169u8, 61u8, 157u8, 116u8, 247u8, 158u8, 67u8, 79u8, 239u8, 166u8,
-                    148u8, 229u8, 13u8, 96u8, 40u8, 175u8, 191u8, 163u8, 240u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    direction: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    expiry: data.3,
-                    nonce: data.4,
-                    erc20Token: data.5,
-                    erc20TokenAmount: data.6,
-                    fees: data.7,
-                    erc721Token: data.8,
-                    erc721TokenId: data.9,
-                    erc721TokenProperties: data.10,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
-                        &self.direction,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::Fee,
-                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc721Token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenId),
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::Property,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenProperties),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ERC721OrderPreSigned {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ERC721OrderPreSigned> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ERC721OrderPreSigned) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `LimitOrderFilled(bytes32,address,address,address,address,address,uint128,uint128,uint128,uint256,bytes32)` and selector `0xab614d2b738543c0ea21f56347cf696a3a0c42a7cbec3212a5ca22a4dcff2124`.
-    ```solidity
-    event LimitOrderFilled(bytes32 orderHash, address maker, address taker, address feeRecipient, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, uint128 takerTokenFeeFilledAmount, uint256 protocolFeePaid, bytes32 pool);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct LimitOrderFilled {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub feeRecipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub takerTokenFeeFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub protocolFeePaid: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for LimitOrderFilled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "LimitOrderFilled(bytes32,address,address,address,\
-                                             address,address,uint128,uint128,uint128,uint256,\
-                                             bytes32)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    171u8, 97u8, 77u8, 43u8, 115u8, 133u8, 67u8, 192u8, 234u8, 33u8, 245u8, 99u8,
-                    71u8, 207u8, 105u8, 106u8, 58u8, 12u8, 66u8, 167u8, 203u8, 236u8, 50u8, 18u8,
-                    165u8, 202u8, 34u8, 164u8, 220u8, 255u8, 33u8, 36u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    orderHash: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    feeRecipient: data.3,
-                    makerToken: data.4,
-                    takerToken: data.5,
-                    takerTokenFilledAmount: data.6,
-                    makerTokenFilledAmount: data.7,
-                    takerTokenFeeFilledAmount: data.8,
-                    protocolFeePaid: data.9,
-                    pool: data.10,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.feeRecipient,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFeeFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.protocolFeePaid),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for LimitOrderFilled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&LimitOrderFilled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &LimitOrderFilled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `LiquidityProviderSwap(address,address,uint256,uint256,address,address)` and selector `0x40a6ba9513d09e3488135e0e0d10e2d4382b792720155b144cbea89ac9db6d34`.
-    ```solidity
-    event LiquidityProviderSwap(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount, address provider, address recipient);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct LiquidityProviderSwap {
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub provider: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for LiquidityProviderSwap {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "LiquidityProviderSwap(address,address,uint256,uint256,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    64u8, 166u8, 186u8, 149u8, 19u8, 208u8, 158u8, 52u8, 136u8, 19u8, 94u8, 14u8,
-                    13u8, 16u8, 226u8, 212u8, 56u8, 43u8, 121u8, 39u8, 32u8, 21u8, 91u8, 20u8,
-                    76u8, 190u8, 168u8, 154u8, 201u8, 219u8, 109u8, 52u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    inputToken: data.0,
-                    outputToken: data.1,
-                    inputTokenAmount: data.2,
-                    outputTokenAmount: data.3,
-                    provider: data.4,
-                    recipient: data.5,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.inputTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.outputTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.provider,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for LiquidityProviderSwap {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&LiquidityProviderSwap> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &LiquidityProviderSwap) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `MetaTransactionExecuted(bytes32,bytes4,address,address)` and selector `0x7f4fe3ff8ae440e1570c558da08440b26f89fb1c1f2910cd91ca6452955f121a`.
-    ```solidity
-    event MetaTransactionExecuted(bytes32 hash, bytes4 indexed selector, address signer, address sender);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct MetaTransactionExecuted {
-        #[allow(missing_docs)]
-        pub hash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-        #[allow(missing_docs)]
-        pub signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for MetaTransactionExecuted {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<4>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "MetaTransactionExecuted(bytes32,bytes4,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    127u8, 79u8, 227u8, 255u8, 138u8, 228u8, 64u8, 225u8, 87u8, 12u8, 85u8, 141u8,
-                    160u8, 132u8, 64u8, 178u8, 111u8, 137u8, 251u8, 28u8, 31u8, 41u8, 16u8, 205u8,
-                    145u8, 202u8, 100u8, 82u8, 149u8, 95u8, 18u8, 26u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    hash: data.0,
-                    selector: topics.1,
-                    signer: data.1,
-                    sender: data.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.hash),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.signer,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.selector.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    4,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.selector);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for MetaTransactionExecuted {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&MetaTransactionExecuted> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &MetaTransactionExecuted) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Migrated(address,address,address)` and selector `0xe1b831b0e6f3aa16b4b1a6bd526b5cdeab4940744ca6e0251f5fe5f8caf1c81a`.
-    ```solidity
-    event Migrated(address caller, address migrator, address newOwner);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Migrated {
-        #[allow(missing_docs)]
-        pub caller: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub migrator: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub newOwner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Migrated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Migrated(address,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    225u8, 184u8, 49u8, 176u8, 230u8, 243u8, 170u8, 22u8, 180u8, 177u8, 166u8,
-                    189u8, 82u8, 107u8, 92u8, 222u8, 171u8, 73u8, 64u8, 116u8, 76u8, 166u8, 224u8,
-                    37u8, 31u8, 95u8, 229u8, 248u8, 202u8, 241u8, 200u8, 26u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    caller: data.0,
-                    migrator: data.1,
-                    newOwner: data.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.caller,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.migrator,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newOwner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Migrated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Migrated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Migrated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `OrderCancelled(bytes32,address)` and selector `0xa6eb7cdc219e1518ced964e9a34e61d68a94e4f1569db3e84256ba981ba52753`.
-    ```solidity
-    event OrderCancelled(bytes32 orderHash, address maker);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct OrderCancelled {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for OrderCancelled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "OrderCancelled(bytes32,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    166u8, 235u8, 124u8, 220u8, 33u8, 158u8, 21u8, 24u8, 206u8, 217u8, 100u8,
-                    233u8, 163u8, 78u8, 97u8, 214u8, 138u8, 148u8, 228u8, 241u8, 86u8, 157u8,
-                    179u8, 232u8, 66u8, 86u8, 186u8, 152u8, 27u8, 165u8, 39u8, 83u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    orderHash: data.0,
-                    maker: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for OrderCancelled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&OrderCancelled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &OrderCancelled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `OrderSignerRegistered(address,address,bool)` and selector `0x6ea9dbe8b2cc119348716a9220a0742ad62b7884ecb0ff4b32cd508121fd9379`.
-    ```solidity
-    event OrderSignerRegistered(address maker, address signer, bool allowed);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct OrderSignerRegistered {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub allowed: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for OrderSignerRegistered {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "OrderSignerRegistered(address,address,bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    110u8, 169u8, 219u8, 232u8, 178u8, 204u8, 17u8, 147u8, 72u8, 113u8, 106u8,
-                    146u8, 32u8, 160u8, 116u8, 42u8, 214u8, 43u8, 120u8, 132u8, 236u8, 176u8,
-                    255u8, 75u8, 50u8, 205u8, 80u8, 129u8, 33u8, 253u8, 147u8, 121u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    maker: data.0,
-                    signer: data.1,
-                    allowed: data.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.signer,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.allowed,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for OrderSignerRegistered {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&OrderSignerRegistered> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &OrderSignerRegistered) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `OtcOrderFilled(bytes32,address,address,address,address,uint128,uint128)` and selector `0xac75f773e3a92f1a02b12134d65e1f47f8a14eabe4eaf1e24624918e6a8b269f`.
-    ```solidity
-    event OtcOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 makerTokenFilledAmount, uint128 takerTokenFilledAmount);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct OtcOrderFilled {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for OtcOrderFilled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "OtcOrderFilled(bytes32,address,address,address,address,uint128,uint128)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    172u8, 117u8, 247u8, 115u8, 227u8, 169u8, 47u8, 26u8, 2u8, 177u8, 33u8, 52u8,
-                    214u8, 94u8, 31u8, 71u8, 248u8, 161u8, 78u8, 171u8, 228u8, 234u8, 241u8, 226u8,
-                    70u8, 36u8, 145u8, 142u8, 106u8, 139u8, 38u8, 159u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    orderHash: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    makerToken: data.3,
-                    takerToken: data.4,
-                    makerTokenFilledAmount: data.5,
-                    takerTokenFilledAmount: data.6,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for OtcOrderFilled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&OtcOrderFilled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &OtcOrderFilled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
-    ```solidity
-    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct OwnershipTransferred {
-        #[allow(missing_docs)]
-        pub previousOwner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub newOwner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for OwnershipTransferred {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = ();
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
-                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
-                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    previousOwner: topics.1,
-                    newOwner: topics.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                ()
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.previousOwner.clone(),
-                    self.newOwner.clone(),
-                )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.previousOwner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.newOwner,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PairCancelledLimitOrders(address,address,address,uint256)` and selector `0xa91fe7ae62fce669df2c7f880f8c14d178531aae72515558e5c948e37c32a572`.
-    ```solidity
-    event PairCancelledLimitOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PairCancelledLimitOrders {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PairCancelledLimitOrders {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "PairCancelledLimitOrders(address,address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    169u8, 31u8, 231u8, 174u8, 98u8, 252u8, 230u8, 105u8, 223u8, 44u8, 127u8,
-                    136u8, 15u8, 140u8, 20u8, 209u8, 120u8, 83u8, 26u8, 174u8, 114u8, 81u8, 85u8,
-                    88u8, 229u8, 201u8, 72u8, 227u8, 124u8, 50u8, 165u8, 114u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    maker: data.0,
-                    makerToken: data.1,
-                    takerToken: data.2,
-                    minValidSalt: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minValidSalt,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PairCancelledLimitOrders {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PairCancelledLimitOrders> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PairCancelledLimitOrders) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `PairCancelledRfqOrders(address,address,address,uint256)` and selector `0xfe7ffb1edfe79f4df716cb2dcad21cf2f31b104d816a7976ba1e6e4653c1efb1`.
-    ```solidity
-    event PairCancelledRfqOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct PairCancelledRfqOrders {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for PairCancelledRfqOrders {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "PairCancelledRfqOrders(address,address,address,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    254u8, 127u8, 251u8, 30u8, 223u8, 231u8, 159u8, 77u8, 247u8, 22u8, 203u8, 45u8,
-                    202u8, 210u8, 28u8, 242u8, 243u8, 27u8, 16u8, 77u8, 129u8, 106u8, 121u8, 118u8,
-                    186u8, 30u8, 110u8, 70u8, 83u8, 193u8, 239u8, 177u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    maker: data.0,
-                    makerToken: data.1,
-                    takerToken: data.2,
-                    minValidSalt: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minValidSalt,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for PairCancelledRfqOrders {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&PairCancelledRfqOrders> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &PairCancelledRfqOrders) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `ProxyFunctionUpdated(bytes4,address,address)` and selector `0x2ae221083467de52078b0096696ab88d8d53a7ecb44bb65b56a2bab687598367`.
-    ```solidity
-    event ProxyFunctionUpdated(bytes4 indexed selector, address oldImpl, address newImpl);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct ProxyFunctionUpdated {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-        #[allow(missing_docs)]
-        pub oldImpl: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub newImpl: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for ProxyFunctionUpdated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<4>,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "ProxyFunctionUpdated(bytes4,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    42u8, 226u8, 33u8, 8u8, 52u8, 103u8, 222u8, 82u8, 7u8, 139u8, 0u8, 150u8,
-                    105u8, 106u8, 184u8, 141u8, 141u8, 83u8, 167u8, 236u8, 180u8, 75u8, 182u8,
-                    91u8, 86u8, 162u8, 186u8, 182u8, 135u8, 89u8, 131u8, 103u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    selector: topics.1,
-                    oldImpl: data.0,
-                    newImpl: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.oldImpl,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newImpl,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.selector.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    4,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.selector);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for ProxyFunctionUpdated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&ProxyFunctionUpdated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &ProxyFunctionUpdated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `QuoteSignerUpdated(address)` and selector `0xf5550c5eea19b48ac6eb5f03abdc4f59c0a60697abb3d973cd68669703b5c8b9`.
-    ```solidity
-    event QuoteSignerUpdated(address quoteSigner);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct QuoteSignerUpdated {
-        #[allow(missing_docs)]
-        pub quoteSigner: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for QuoteSignerUpdated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "QuoteSignerUpdated(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    245u8, 85u8, 12u8, 94u8, 234u8, 25u8, 180u8, 138u8, 198u8, 235u8, 95u8, 3u8,
-                    171u8, 220u8, 79u8, 89u8, 192u8, 166u8, 6u8, 151u8, 171u8, 179u8, 217u8, 115u8,
-                    205u8, 104u8, 102u8, 151u8, 3u8, 181u8, 200u8, 185u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    quoteSigner: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.quoteSigner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for QuoteSignerUpdated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&QuoteSignerUpdated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &QuoteSignerUpdated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `RfqOrderFilled(bytes32,address,address,address,address,uint128,uint128,bytes32)` and selector `0x829fa99d94dc4636925b38632e625736a614c154d55006b7ab6bea979c210c32`.
-    ```solidity
-    event RfqOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, bytes32 pool);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct RfqOrderFilled {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub pool: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for RfqOrderFilled {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "RfqOrderFilled(bytes32,address,address,address,address,uint128,uint128,bytes32)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    130u8, 159u8, 169u8, 157u8, 148u8, 220u8, 70u8, 54u8, 146u8, 91u8, 56u8, 99u8,
-                    46u8, 98u8, 87u8, 54u8, 166u8, 20u8, 193u8, 84u8, 213u8, 80u8, 6u8, 183u8,
-                    171u8, 107u8, 234u8, 151u8, 156u8, 33u8, 12u8, 50u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    orderHash: data.0,
-                    maker: data.1,
-                    taker: data.2,
-                    makerToken: data.3,
-                    takerToken: data.4,
-                    takerTokenFilledAmount: data.5,
-                    makerTokenFilledAmount: data.6,
-                    pool: data.7,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        128,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for RfqOrderFilled {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&RfqOrderFilled> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &RfqOrderFilled) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `RfqOrderOriginsAllowed(address,address[],bool)` and selector `0x02dfead5eb769b298e82dd9650b31c40559a3d42701dbf53c931bc2682847c31`.
-    ```solidity
-    event RfqOrderOriginsAllowed(address origin, address[] addrs, bool allowed);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct RfqOrderOriginsAllowed {
-        #[allow(missing_docs)]
-        pub origin: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub addrs: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub allowed: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for RfqOrderOriginsAllowed {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "RfqOrderOriginsAllowed(address,address[],bool)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    2u8, 223u8, 234u8, 213u8, 235u8, 118u8, 155u8, 41u8, 142u8, 130u8, 221u8,
-                    150u8, 80u8, 179u8, 28u8, 64u8, 85u8, 154u8, 61u8, 66u8, 112u8, 29u8, 191u8,
-                    83u8, 201u8, 49u8, 188u8, 38u8, 130u8, 132u8, 124u8, 49u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    origin: data.0,
-                    addrs: data.1,
-                    allowed: data.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.origin,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.addrs),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.allowed,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for RfqOrderOriginsAllowed {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&RfqOrderOriginsAllowed> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &RfqOrderOriginsAllowed) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TransformedERC20(address,address,address,uint256,uint256)` and selector `0x0f6672f78a59ba8e5e5b5d38df3ebc67f3c792e2c9259b8d97d7f00dd78ba1b3`.
-    ```solidity
-    event TransformedERC20(address indexed taker, address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TransformedERC20 {
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TransformedERC20 {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "TransformedERC20(address,address,address,uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    15u8, 102u8, 114u8, 247u8, 138u8, 89u8, 186u8, 142u8, 94u8, 91u8, 93u8, 56u8,
-                    223u8, 62u8, 188u8, 103u8, 243u8, 199u8, 146u8, 226u8, 201u8, 37u8, 155u8,
-                    141u8, 151u8, 215u8, 240u8, 13u8, 215u8, 139u8, 161u8, 179u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    taker: topics.1,
-                    inputToken: data.0,
-                    outputToken: data.1,
-                    inputTokenAmount: data.2,
-                    outputTokenAmount: data.3,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.inputTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.outputTokenAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.taker.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.taker,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TransformedERC20 {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TransformedERC20> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TransformedERC20) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TransformerDeployerUpdated(address)` and selector `0xfd45604abad79c16e23348a137ed8292661be1b8eba6e4806ebed6833b1c046a`.
-    ```solidity
-    event TransformerDeployerUpdated(address transformerDeployer);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TransformerDeployerUpdated {
-        #[allow(missing_docs)]
-        pub transformerDeployer: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TransformerDeployerUpdated {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "TransformerDeployerUpdated(address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    253u8, 69u8, 96u8, 74u8, 186u8, 215u8, 156u8, 22u8, 226u8, 51u8, 72u8, 161u8,
-                    55u8, 237u8, 130u8, 146u8, 102u8, 27u8, 225u8, 184u8, 235u8, 166u8, 228u8,
-                    128u8, 110u8, 190u8, 214u8, 131u8, 59u8, 28u8, 4u8, 106u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    transformerDeployer: data.0,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.transformerDeployer,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(),)
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TransformerDeployerUpdated {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&TransformerDeployerUpdated> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &TransformerDeployerUpdated) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `_fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,address)` and selector `0x414e4ccf`.
-    ```solidity
-    function _fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, address sender) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _fillLimitOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sender: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`_fillLimitOrder((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
-    /// bytes32),uint128,address,address)`](_fillLimitOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _fillLimitOrderReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::LimitOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_fillLimitOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: _fillLimitOrderCall) -> Self {
-                    (
-                        value.order,
-                        value.signature,
-                        value.takerTokenFillAmount,
-                        value.taker,
-                        value.sender,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillLimitOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                        taker: tuple.3,
-                        sender: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_fillLimitOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: _fillLimitOrderReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillLimitOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl _fillLimitOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <_fillLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for _fillLimitOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::LimitOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = _fillLimitOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [65u8, 78u8, 76u8, 207u8];
-            const SIGNATURE: &'static str = "_fillLimitOrder((address,address,uint128,uint128,\
-                                             uint128,address,address,address,address,bytes32,\
-                                             uint64,uint256),(uint8,uint8,bytes32,bytes32),\
-                                             uint128,address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.sender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                _fillLimitOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `_fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)` and selector `0xe4ba8439`.
-    ```solidity
-    function _fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _fillOtcOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub useSelfBalance: bool,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`_fillOtcOrder((address,address,uint128,uint128,address,address,
-    /// address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,
-    /// address)`](_fillOtcOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _fillOtcOrderReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-                alloy_sol_types::private::Address,
-                bool,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_fillOtcOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: _fillOtcOrderCall) -> Self {
-                    (
-                        value.order,
-                        value.makerSignature,
-                        value.takerTokenFillAmount,
-                        value.taker,
-                        value.useSelfBalance,
-                        value.recipient,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillOtcOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        makerSignature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                        taker: tuple.3,
-                        useSelfBalance: tuple.4,
-                        recipient: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_fillOtcOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: _fillOtcOrderReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillOtcOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl _fillOtcOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <_fillOtcOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for _fillOtcOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = _fillOtcOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [228u8, 186u8, 132u8, 57u8];
-            const SIGNATURE: &'static str = "_fillOtcOrder((address,address,uint128,uint128,\
-                                             address,address,address,uint256),(uint8,uint8,\
-                                             bytes32,bytes32),uint128,address,bool,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.makerSignature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.useSelfBalance,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                _fillOtcOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)` and selector `0xaa6b21cd`.
-    ```solidity
-    function _fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount, address taker, bool useSelfBalance, address recipient) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _fillRfqOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-        #[allow(missing_docs)]
-        pub taker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub useSelfBalance: bool,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`_fillRfqOrder((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,
-    /// address,bool,address)`](_fillRfqOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _fillRfqOrderReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::RfqOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-                alloy_sol_types::private::Address,
-                bool,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_fillRfqOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: _fillRfqOrderCall) -> Self {
-                    (
-                        value.order,
-                        value.signature,
-                        value.takerTokenFillAmount,
-                        value.taker,
-                        value.useSelfBalance,
-                        value.recipient,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillRfqOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                        taker: tuple.3,
-                        useSelfBalance: tuple.4,
-                        recipient: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_fillRfqOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: _fillRfqOrderReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _fillRfqOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl _fillRfqOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <_fillRfqOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for _fillRfqOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::RfqOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = _fillRfqOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 107u8, 33u8, 205u8];
-            const SIGNATURE: &'static str =
-                "_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,\
-                 uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.taker,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.useSelfBalance,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                _fillRfqOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)` and selector `0x4a931ba1`.
-    ```solidity
-    function _sellHeldTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _sellHeldTokenForTokenToUniswapV3Call {
-        #[allow(missing_docs)]
-        pub encodedPath: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,
-    /// address)`](_sellHeldTokenForTokenToUniswapV3Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _sellHeldTokenForTokenToUniswapV3Return {
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_sellHeldTokenForTokenToUniswapV3Call> for UnderlyingRustTuple<'_> {
-                fn from(value: _sellHeldTokenForTokenToUniswapV3Call) -> Self {
-                    (
-                        value.encodedPath,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                        value.recipient,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _sellHeldTokenForTokenToUniswapV3Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        encodedPath: tuple.0,
-                        sellAmount: tuple.1,
-                        minBuyAmount: tuple.2,
-                        recipient: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_sellHeldTokenForTokenToUniswapV3Return> for UnderlyingRustTuple<'_> {
-                fn from(value: _sellHeldTokenForTokenToUniswapV3Return) -> Self {
-                    (value.buyAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _sellHeldTokenForTokenToUniswapV3Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { buyAmount: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for _sellHeldTokenForTokenToUniswapV3Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [74u8, 147u8, 27u8, 161u8];
-            const SIGNATURE: &'static str =
-                "_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.encodedPath,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.sellAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minBuyAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: _sellHeldTokenForTokenToUniswapV3Return = r.into();
-                        r.buyAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: _sellHeldTokenForTokenToUniswapV3Return = r.into();
-                    r.buyAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `_transformERC20((address,address,address,uint256,uint256,(uint32,bytes)[],bool,address))` and selector `0x8aa6539b`.
-    ```solidity
-    function _transformERC20(ITransformERC20Feature.TransformERC20Args memory args) external payable returns (uint256 outputTokenAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _transformERC20Call {
-        #[allow(missing_docs)]
-        pub args:
-            <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`_transformERC20((address,address,address,uint256,uint256,(uint32,
-    /// bytes)[],bool,address))`](_transformERC20Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct _transformERC20Return {
-        #[allow(missing_docs)]
-        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ITransformERC20Feature::TransformERC20Args,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_transformERC20Call> for UnderlyingRustTuple<'_> {
-                fn from(value: _transformERC20Call) -> Self {
-                    (value.args,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _transformERC20Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { args: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<_transformERC20Return> for UnderlyingRustTuple<'_> {
-                fn from(value: _transformERC20Return) -> Self {
-                    (value.outputTokenAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for _transformERC20Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        outputTokenAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for _transformERC20Call {
-            type Parameters<'a> = (ITransformERC20Feature::TransformERC20Args,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [138u8, 166u8, 83u8, 155u8];
-            const SIGNATURE: &'static str = "_transformERC20((address,address,address,uint256,\
-                                             uint256,(uint32,bytes)[],bool,address))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::tokenize(
-                        &self.args,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: _transformERC20Return = r.into();
-                        r.outputTokenAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: _transformERC20Return = r.into();
-                    r.outputTokenAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchBuyERC1155s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bytes[],bool)` and selector `0x84680615`.
-    ```solidity
-    function batchBuyERC1155s(LibNFTOrder.ERC1155Order[] memory sellOrders, LibSignature.Signature[] memory signatures, uint128[] memory erc1155TokenAmounts, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchBuyERC1155sCall {
-        #[allow(missing_docs)]
-        pub sellOrders: alloy_sol_types::private::Vec<
-            <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub erc1155TokenAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        #[allow(missing_docs)]
-        pub revertIfIncomplete: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchBuyERC1155s((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
-    /// uint128)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bytes[],
-    /// bool)`](batchBuyERC1155sCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchBuyERC1155sReturn {
-        #[allow(missing_docs)]
-        pub successes: alloy_sol_types::private::Vec<bool>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC1155Order>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<u128>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchBuyERC1155sCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchBuyERC1155sCall) -> Self {
-                    (
-                        value.sellOrders,
-                        value.signatures,
-                        value.erc1155TokenAmounts,
-                        value.callbackData,
-                        value.revertIfIncomplete,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC1155sCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sellOrders: tuple.0,
-                        signatures: tuple.1,
-                        erc1155TokenAmounts: tuple.2,
-                        callbackData: tuple.3,
-                        revertIfIncomplete: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<bool>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchBuyERC1155sReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchBuyERC1155sReturn) -> Self {
-                    (value.successes,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC1155sReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { successes: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchBuyERC1155sCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC1155Order>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = alloy_sol_types::private::Vec<bool>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [132u8, 104u8, 6u8, 21u8];
-            const SIGNATURE: &'static str = "batchBuyERC1155s((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[],uint128)[],(uint8,\
-                                             uint8,bytes32,bytes32)[],uint128[],bytes[],bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::ERC1155Order,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmounts),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bytes,
-                    > as alloy_sol_types::SolType>::tokenize(&self.callbackData),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.revertIfIncomplete,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bool,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: batchBuyERC1155sReturn = r.into();
-                        r.successes
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: batchBuyERC1155sReturn = r.into();
-                    r.successes
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchBuyERC721s((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],bytes[],bool)` and selector `0xeae93ee7`.
-    ```solidity
-    function batchBuyERC721s(LibNFTOrder.ERC721Order[] memory sellOrders, LibSignature.Signature[] memory signatures, bytes[] memory callbackData, bool revertIfIncomplete) external payable returns (bool[] memory successes);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchBuyERC721sCall {
-        #[allow(missing_docs)]
-        pub sellOrders: alloy_sol_types::private::Vec<
-            <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-        #[allow(missing_docs)]
-        pub revertIfIncomplete: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchBuyERC721s((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],
-    /// (uint8,uint8,bytes32,bytes32)[],bytes[],bool)`](batchBuyERC721sCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchBuyERC721sReturn {
-        #[allow(missing_docs)]
-        pub successes: alloy_sol_types::private::Vec<bool>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchBuyERC721sCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchBuyERC721sCall) -> Self {
-                    (
-                        value.sellOrders,
-                        value.signatures,
-                        value.callbackData,
-                        value.revertIfIncomplete,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC721sCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sellOrders: tuple.0,
-                        signatures: tuple.1,
-                        callbackData: tuple.2,
-                        revertIfIncomplete: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<bool>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchBuyERC721sReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchBuyERC721sReturn) -> Self {
-                    (value.successes,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchBuyERC721sReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { successes: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchBuyERC721sCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = alloy_sol_types::private::Vec<bool>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [234u8, 233u8, 62u8, 231u8];
-            const SIGNATURE: &'static str = "batchBuyERC721s((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[])[],(uint8,uint8,\
-                                             bytes32,bytes32)[],bytes[],bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::ERC721Order,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bytes,
-                    > as alloy_sol_types::SolType>::tokenize(&self.callbackData),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.revertIfIncomplete,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bool,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: batchBuyERC721sReturn = r.into();
-                        r.successes
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: batchBuyERC721sReturn = r.into();
-                    r.successes
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelERC1155Orders(uint256[])` and selector `0xa1865d6f`.
-    ```solidity
-    function batchCancelERC1155Orders(uint256[] memory orderNonces) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelERC1155OrdersCall {
-        #[allow(missing_docs)]
-        pub orderNonces:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelERC1155Orders(uint256[])`](batchCancelERC1155OrdersCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelERC1155OrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelERC1155OrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelERC1155OrdersCall) -> Self {
-                    (value.orderNonces,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC1155OrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderNonces: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelERC1155OrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelERC1155OrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC1155OrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelERC1155OrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelERC1155OrdersCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Return = batchCancelERC1155OrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [161u8, 134u8, 93u8, 111u8];
-            const SIGNATURE: &'static str = "batchCancelERC1155Orders(uint256[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.orderNonces
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelERC1155OrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelERC721Orders(uint256[])` and selector `0x86219940`.
-    ```solidity
-    function batchCancelERC721Orders(uint256[] memory orderNonces) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelERC721OrdersCall {
-        #[allow(missing_docs)]
-        pub orderNonces:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelERC721Orders(uint256[])`](batchCancelERC721OrdersCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelERC721OrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelERC721OrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelERC721OrdersCall) -> Self {
-                    (value.orderNonces,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC721OrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderNonces: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelERC721OrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelERC721OrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelERC721OrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelERC721OrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelERC721OrdersCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Return = batchCancelERC721OrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [134u8, 33u8, 153u8, 64u8];
-            const SIGNATURE: &'static str = "batchCancelERC721Orders(uint256[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.orderNonces
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelERC721OrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[])` and selector `0x9baa45a8`.
-    ```solidity
-    function batchCancelLimitOrders(LibNativeOrder.LimitOrder[] memory orders) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelLimitOrdersCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelLimitOrders((address,address,uint128,uint128,uint128,
-    /// address,address,address,address,bytes32,uint64,
-    /// uint256)[])`](batchCancelLimitOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelLimitOrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelLimitOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelLimitOrdersCall) -> Self {
-                    (value.orders,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelLimitOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orders: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelLimitOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelLimitOrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelLimitOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelLimitOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelLimitOrdersCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,);
-            type Return = batchCancelLimitOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [155u8, 170u8, 69u8, 168u8];
-            const SIGNATURE: &'static str = "batchCancelLimitOrders((address,address,uint128,\
-                                             uint128,uint128,address,address,address,address,\
-                                             bytes32,uint64,uint256)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::LimitOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelLimitOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelPairLimitOrders(address[],address[],uint256[])` and selector `0x86a0c8d7`.
-    ```solidity
-    function batchCancelPairLimitOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairLimitOrdersCall {
-        #[allow(missing_docs)]
-        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub minValidSalts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelPairLimitOrders(address[],address[],
-    /// uint256[])`](batchCancelPairLimitOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairLimitOrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairLimitOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairLimitOrdersCall) -> Self {
-                    (value.makerTokens, value.takerTokens, value.minValidSalts)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        makerTokens: tuple.0,
-                        takerTokens: tuple.1,
-                        minValidSalts: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairLimitOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairLimitOrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelPairLimitOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelPairLimitOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Return = batchCancelPairLimitOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [134u8, 160u8, 200u8, 215u8];
-            const SIGNATURE: &'static str =
-                "batchCancelPairLimitOrders(address[],address[],uint256[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelPairLimitOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])` and selector `0x9f0434f5`.
-    ```solidity
-    function batchCancelPairLimitOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairLimitOrdersWithSignerCall {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub minValidSalts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelPairLimitOrdersWithSigner(address,address[],address[],
-    /// uint256[])`](batchCancelPairLimitOrdersWithSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairLimitOrdersWithSignerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairLimitOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairLimitOrdersWithSignerCall) -> Self {
-                    (
-                        value.maker,
-                        value.makerTokens,
-                        value.takerTokens,
-                        value.minValidSalts,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersWithSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        maker: tuple.0,
-                        makerTokens: tuple.1,
-                        takerTokens: tuple.2,
-                        minValidSalts: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairLimitOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairLimitOrdersWithSignerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairLimitOrdersWithSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelPairLimitOrdersWithSignerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelPairLimitOrdersWithSignerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Return = batchCancelPairLimitOrdersWithSignerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [159u8, 4u8, 52u8, 245u8];
-            const SIGNATURE: &'static str =
-                "batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelPairLimitOrdersWithSignerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelPairRfqOrders(address[],address[],uint256[])` and selector `0x0f0e8cf7`.
-    ```solidity
-    function batchCancelPairRfqOrders(address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairRfqOrdersCall {
-        #[allow(missing_docs)]
-        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub minValidSalts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelPairRfqOrders(address[],address[],
-    /// uint256[])`](batchCancelPairRfqOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairRfqOrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairRfqOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairRfqOrdersCall) -> Self {
-                    (value.makerTokens, value.takerTokens, value.minValidSalts)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        makerTokens: tuple.0,
-                        takerTokens: tuple.1,
-                        minValidSalts: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairRfqOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairRfqOrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelPairRfqOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelPairRfqOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Return = batchCancelPairRfqOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [15u8, 14u8, 140u8, 247u8];
-            const SIGNATURE: &'static str =
-                "batchCancelPairRfqOrders(address[],address[],uint256[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelPairRfqOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])` and selector `0xfd5f995b`.
-    ```solidity
-    function batchCancelPairRfqOrdersWithSigner(address maker, address[] memory makerTokens, address[] memory takerTokens, uint256[] memory minValidSalts) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairRfqOrdersWithSignerCall {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub minValidSalts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelPairRfqOrdersWithSigner(address,address[],address[],
-    /// uint256[])`](batchCancelPairRfqOrdersWithSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelPairRfqOrdersWithSignerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairRfqOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairRfqOrdersWithSignerCall) -> Self {
-                    (
-                        value.maker,
-                        value.makerTokens,
-                        value.takerTokens,
-                        value.minValidSalts,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersWithSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        maker: tuple.0,
-                        makerTokens: tuple.1,
-                        takerTokens: tuple.2,
-                        minValidSalts: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelPairRfqOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelPairRfqOrdersWithSignerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelPairRfqOrdersWithSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelPairRfqOrdersWithSignerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelPairRfqOrdersWithSignerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-            );
-            type Return = batchCancelPairRfqOrdersWithSignerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [253u8, 95u8, 153u8, 91u8];
-            const SIGNATURE: &'static str =
-                "batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerTokens),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minValidSalts),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelPairRfqOrdersWithSignerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `batchCancelRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[])` and selector `0xf6e0f6a5`.
-    ```solidity
-    function batchCancelRfqOrders(LibNativeOrder.RfqOrder[] memory orders) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelRfqOrdersCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    ///Container type for the return parameters of the
-    /// [`batchCancelRfqOrders((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256)[])`](batchCancelRfqOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchCancelRfqOrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelRfqOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelRfqOrdersCall) -> Self {
-                    (value.orders,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelRfqOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orders: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchCancelRfqOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchCancelRfqOrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchCancelRfqOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl batchCancelRfqOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchCancelRfqOrdersCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,);
-            type Return = batchCancelRfqOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [246u8, 224u8, 246u8, 165u8];
-            const SIGNATURE: &'static str = "batchCancelRfqOrders((address,address,uint128,\
-                                             uint128,address,address,address,bytes32,uint64,\
-                                             uint256)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::RfqOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchCancelRfqOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0xc5579ec8`.
-    ```solidity
-    function batchExecuteMetaTransactions(IMetaTransactionsFeature.MetaTransactionData[] memory mtxs, LibSignature.Signature[] memory signatures) external payable returns (bytes[] memory returnResults);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchExecuteMetaTransactionsCall {
-        #[allow(missing_docs)]
-        pub mtxs: alloy_sol_types::private::Vec<
-            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,
-    /// uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,
-    /// bytes32)[])`](batchExecuteMetaTransactionsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchExecuteMetaTransactionsReturn {
-        #[allow(missing_docs)]
-        pub returnResults: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<IMetaTransactionsFeature::MetaTransactionData>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchExecuteMetaTransactionsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchExecuteMetaTransactionsCall) -> Self {
-                    (value.mtxs, value.signatures)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchExecuteMetaTransactionsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        mtxs: tuple.0,
-                        signatures: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchExecuteMetaTransactionsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchExecuteMetaTransactionsReturn) -> Self {
-                    (value.returnResults,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchExecuteMetaTransactionsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        returnResults: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchExecuteMetaTransactionsCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<IMetaTransactionsFeature::MetaTransactionData>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            type Return = alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bytes>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [197u8, 87u8, 158u8, 200u8];
-            const SIGNATURE: &'static str = "batchExecuteMetaTransactions((address,address,\
-                                             uint256,uint256,uint256,uint256,bytes,uint256,\
-                                             address,uint256)[],(uint8,uint8,bytes32,bytes32)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        IMetaTransactionsFeature::MetaTransactionData,
-                    > as alloy_sol_types::SolType>::tokenize(&self.mtxs),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bytes,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: batchExecuteMetaTransactionsReturn = r.into();
-                        r.returnResults
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: batchExecuteMetaTransactionsReturn = r.into();
-                    r.returnResults
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchFillLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)` and selector `0x1baaa00b`.
-    ```solidity
-    function batchFillLimitOrders(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external payable returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchFillLimitOrdersCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub revertIfIncomplete: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchFillLimitOrders((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,
-    /// bytes32)[],uint128[],bool)`](batchFillLimitOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchFillLimitOrdersReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<u128>,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchFillLimitOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchFillLimitOrdersCall) -> Self {
-                    (
-                        value.orders,
-                        value.signatures,
-                        value.takerTokenFillAmounts,
-                        value.revertIfIncomplete,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillLimitOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orders: tuple.0,
-                        signatures: tuple.1,
-                        takerTokenFillAmounts: tuple.2,
-                        revertIfIncomplete: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<u128>,
-                alloy_sol_types::private::Vec<u128>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchFillLimitOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchFillLimitOrdersReturn) -> Self {
-                    (value.takerTokenFilledAmounts, value.makerTokenFilledAmounts)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillLimitOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmounts: tuple.0,
-                        makerTokenFilledAmounts: tuple.1,
-                    }
-                }
-            }
-        }
-        impl batchFillLimitOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmounts,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmounts,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchFillLimitOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = batchFillLimitOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [27u8, 170u8, 160u8, 11u8];
-            const SIGNATURE: &'static str = "batchFillLimitOrders((address,address,uint128,\
-                                             uint128,uint128,address,address,address,address,\
-                                             bytes32,uint64,uint256)[],(uint8,uint8,bytes32,\
-                                             bytes32)[],uint128[],bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::LimitOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmounts,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.revertIfIncomplete,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchFillLimitOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchFillRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)` and selector `0x75103cb9`.
-    ```solidity
-    function batchFillRfqOrders(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures, uint128[] memory takerTokenFillAmounts, bool revertIfIncomplete) external returns (uint128[] memory takerTokenFilledAmounts, uint128[] memory makerTokenFilledAmounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchFillRfqOrdersCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub revertIfIncomplete: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchFillRfqOrders((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],
-    /// uint128[],bool)`](batchFillRfqOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchFillRfqOrdersReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmounts: alloy_sol_types::private::Vec<u128>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<u128>,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchFillRfqOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchFillRfqOrdersCall) -> Self {
-                    (
-                        value.orders,
-                        value.signatures,
-                        value.takerTokenFillAmounts,
-                        value.revertIfIncomplete,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillRfqOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orders: tuple.0,
-                        signatures: tuple.1,
-                        takerTokenFillAmounts: tuple.2,
-                        revertIfIncomplete: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<u128>,
-                alloy_sol_types::private::Vec<u128>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchFillRfqOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchFillRfqOrdersReturn) -> Self {
-                    (value.takerTokenFilledAmounts, value.makerTokenFilledAmounts)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillRfqOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmounts: tuple.0,
-                        makerTokenFilledAmounts: tuple.1,
-                    }
-                }
-            }
-        }
-        impl batchFillRfqOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmounts,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmounts,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchFillRfqOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = batchFillRfqOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [117u8, 16u8, 60u8, 185u8];
-            const SIGNATURE: &'static str = "batchFillRfqOrders((address,address,uint128,uint128,\
-                                             address,address,address,bytes32,uint64,uint256)[],\
-                                             (uint8,uint8,bytes32,bytes32)[],uint128[],bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::RfqOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmounts,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.revertIfIncomplete,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchFillRfqOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchFillTakerSignedOtcOrders((address,address,uint128,uint128,address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[],bool[])` and selector `0xe52d1764`.
-    ```solidity
-    function batchFillTakerSignedOtcOrders(LibNativeOrder.OtcOrder[] memory orders, LibSignature.Signature[] memory makerSignatures, LibSignature.Signature[] memory takerSignatures, bool[] memory unwrapWeth) external returns (bool[] memory successes);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchFillTakerSignedOtcOrdersCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub makerSignatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub takerSignatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub unwrapWeth: alloy_sol_types::private::Vec<bool>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchFillTakerSignedOtcOrders((address,address,uint128,uint128,
-    /// address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],
-    /// (uint8,uint8,bytes32,bytes32)[],
-    /// bool[])`](batchFillTakerSignedOtcOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchFillTakerSignedOtcOrdersReturn {
-        #[allow(missing_docs)]
-        pub successes: alloy_sol_types::private::Vec<bool>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::OtcOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<bool>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchFillTakerSignedOtcOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchFillTakerSignedOtcOrdersCall) -> Self {
-                    (
-                        value.orders,
-                        value.makerSignatures,
-                        value.takerSignatures,
-                        value.unwrapWeth,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillTakerSignedOtcOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orders: tuple.0,
-                        makerSignatures: tuple.1,
-                        takerSignatures: tuple.2,
-                        unwrapWeth: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<bool>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchFillTakerSignedOtcOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchFillTakerSignedOtcOrdersReturn) -> Self {
-                    (value.successes,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchFillTakerSignedOtcOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { successes: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchFillTakerSignedOtcOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::OtcOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            type Return = alloy_sol_types::private::Vec<bool>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [229u8, 45u8, 23u8, 100u8];
-            const SIGNATURE: &'static str = "batchFillTakerSignedOtcOrders((address,address,\
-                                             uint128,uint128,address,address,address,uint256)[],\
-                                             (uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,\
-                                             bytes32)[],bool[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::OtcOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.makerSignatures),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.takerSignatures),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bool,
-                    > as alloy_sol_types::SolType>::tokenize(&self.unwrapWeth),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Bool,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: batchFillTakerSignedOtcOrdersReturn = r.into();
-                        r.successes
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: batchFillTakerSignedOtcOrdersReturn = r.into();
-                    r.successes
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchGetLimitOrderRelevantStates((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0xb4658bfb`.
-    ```solidity
-    function batchGetLimitOrderRelevantStates(LibNativeOrder.LimitOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchGetLimitOrderRelevantStatesCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`batchGetLimitOrderRelevantStates((address,address,uint128,uint128,
-    /// uint128,address,address,address,address,bytes32,uint64,uint256)[],
-    /// (uint8,uint8,bytes32,bytes32)[])`](batchGetLimitOrderRelevantStatesCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchGetLimitOrderRelevantStatesReturn {
-        #[allow(missing_docs)]
-        pub orderInfos: alloy_sol_types::private::Vec<
-            <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub actualFillableTakerTokenAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub isSignatureValids: alloy_sol_types::private::Vec<bool>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchGetLimitOrderRelevantStatesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchGetLimitOrderRelevantStatesCall) -> Self {
-                    (value.orders, value.signatures)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetLimitOrderRelevantStatesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orders: tuple.0,
-                        signatures: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<u128>,
-                alloy_sol_types::private::Vec<bool>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchGetLimitOrderRelevantStatesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchGetLimitOrderRelevantStatesReturn) -> Self {
-                    (
-                        value.orderInfos,
-                        value.actualFillableTakerTokenAmounts,
-                        value.isSignatureValids,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetLimitOrderRelevantStatesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderInfos: tuple.0,
-                        actualFillableTakerTokenAmounts: tuple.1,
-                        isSignatureValids: tuple.2,
-                    }
-                }
-            }
-        }
-        impl batchGetLimitOrderRelevantStatesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::OrderInfo,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderInfos),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.actualFillableTakerTokenAmounts,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bool,
-                    > as alloy_sol_types::SolType>::tokenize(&self.isSignatureValids),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchGetLimitOrderRelevantStatesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::LimitOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            type Return = batchGetLimitOrderRelevantStatesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [180u8, 101u8, 139u8, 251u8];
-            const SIGNATURE: &'static str = "batchGetLimitOrderRelevantStates((address,address,\
-                                             uint128,uint128,uint128,address,address,address,\
-                                             address,bytes32,uint64,uint256)[],(uint8,uint8,\
-                                             bytes32,bytes32)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::LimitOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchGetLimitOrderRelevantStatesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchGetRfqOrderRelevantStates((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0xad354eeb`.
-    ```solidity
-    function batchGetRfqOrderRelevantStates(LibNativeOrder.RfqOrder[] memory orders, LibSignature.Signature[] memory signatures) external view returns (LibNativeOrder.OrderInfo[] memory orderInfos, uint128[] memory actualFillableTakerTokenAmounts, bool[] memory isSignatureValids);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchGetRfqOrderRelevantStatesCall {
-        #[allow(missing_docs)]
-        pub orders: alloy_sol_types::private::Vec<
-            <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub signatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`batchGetRfqOrderRelevantStates((address,address,uint128,uint128,
-    /// address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,
-    /// bytes32)[])`](batchGetRfqOrderRelevantStatesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchGetRfqOrderRelevantStatesReturn {
-        #[allow(missing_docs)]
-        pub orderInfos: alloy_sol_types::private::Vec<
-            <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub actualFillableTakerTokenAmounts: alloy_sol_types::private::Vec<u128>,
-        #[allow(missing_docs)]
-        pub isSignatureValids: alloy_sol_types::private::Vec<bool>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchGetRfqOrderRelevantStatesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchGetRfqOrderRelevantStatesCall) -> Self {
-                    (value.orders, value.signatures)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetRfqOrderRelevantStatesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orders: tuple.0,
-                        signatures: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<u128>,
-                alloy_sol_types::private::Vec<bool>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchGetRfqOrderRelevantStatesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchGetRfqOrderRelevantStatesReturn) -> Self {
-                    (
-                        value.orderInfos,
-                        value.actualFillableTakerTokenAmounts,
-                        value.isSignatureValids,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchGetRfqOrderRelevantStatesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderInfos: tuple.0,
-                        actualFillableTakerTokenAmounts: tuple.1,
-                        isSignatureValids: tuple.2,
-                    }
-                }
-            }
-        }
-        impl batchGetRfqOrderRelevantStatesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::OrderInfo,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orderInfos),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<128>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.actualFillableTakerTokenAmounts,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bool,
-                    > as alloy_sol_types::SolType>::tokenize(&self.isSignatureValids),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchGetRfqOrderRelevantStatesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::RfqOrder>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            type Return = batchGetRfqOrderRelevantStatesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNativeOrder::OrderInfo>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<128>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 53u8, 78u8, 235u8];
-            const SIGNATURE: &'static str = "batchGetRfqOrderRelevantStates((address,address,\
-                                             uint128,uint128,address,address,address,bytes32,\
-                                             uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNativeOrder::RfqOrder,
-                    > as alloy_sol_types::SolType>::tokenize(&self.orders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.signatures),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchGetRfqOrderRelevantStatesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[])` and selector `0x7da9e2cf`.
-    ```solidity
-    function batchMatchERC721Orders(LibNFTOrder.ERC721Order[] memory sellOrders, LibNFTOrder.ERC721Order[] memory buyOrders, LibSignature.Signature[] memory sellOrderSignatures, LibSignature.Signature[] memory buyOrderSignatures) external returns (uint256[] memory profits, bool[] memory successes);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchMatchERC721OrdersCall {
-        #[allow(missing_docs)]
-        pub sellOrders: alloy_sol_types::private::Vec<
-            <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub buyOrders: alloy_sol_types::private::Vec<
-            <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sellOrderSignatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub buyOrderSignatures: alloy_sol_types::private::Vec<
-            <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])[],
-    /// (uint8,address,address,uint256,uint256,address,uint256,(address,uint256,
-    /// bytes)[],address,uint256,(address,bytes)[])[],(uint8,uint8,bytes32,
-    /// bytes32)[],(uint8,uint8,bytes32,
-    /// bytes32)[])`](batchMatchERC721OrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct batchMatchERC721OrdersReturn {
-        #[allow(missing_docs)]
-        pub profits:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-        #[allow(missing_docs)]
-        pub successes: alloy_sol_types::private::Vec<bool>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::Vec<
-                    <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchMatchERC721OrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: batchMatchERC721OrdersCall) -> Self {
-                    (
-                        value.sellOrders,
-                        value.buyOrders,
-                        value.sellOrderSignatures,
-                        value.buyOrderSignatures,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchMatchERC721OrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sellOrders: tuple.0,
-                        buyOrders: tuple.1,
-                        sellOrderSignatures: tuple.2,
-                        buyOrderSignatures: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-                alloy_sol_types::private::Vec<bool>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<batchMatchERC721OrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: batchMatchERC721OrdersReturn) -> Self {
-                    (value.profits, value.successes)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for batchMatchERC721OrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        profits: tuple.0,
-                        successes: tuple.1,
-                    }
-                }
-            }
-        }
-        impl batchMatchERC721OrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<256>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.profits),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Bool,
-                    > as alloy_sol_types::SolType>::tokenize(&self.successes),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for batchMatchERC721OrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
-                alloy_sol_types::sol_data::Array<LibNFTOrder::ERC721Order>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-                alloy_sol_types::sol_data::Array<LibSignature::Signature>,
-            );
-            type Return = batchMatchERC721OrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Bool>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [125u8, 169u8, 226u8, 207u8];
-            const SIGNATURE: &'static str =
-                "batchMatchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,\
-                 (address,uint256,bytes)[],address,uint256,(address,bytes)[])[],(uint8,address,\
-                 address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,\
-                 uint256,(address,bytes)[])[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,\
-                 bytes32,bytes32)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::ERC721Order,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibNFTOrder::ERC721Order,
-                    > as alloy_sol_types::SolType>::tokenize(&self.buyOrders),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellOrderSignatures),
-                    <alloy_sol_types::sol_data::Array<
-                        LibSignature::Signature,
-                    > as alloy_sol_types::SolType>::tokenize(&self.buyOrderSignatures),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                batchMatchERC721OrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `buyERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint128,bytes)` and selector `0x7cdb54d8`.
-    ```solidity
-    function buyERC1155(LibNFTOrder.ERC1155Order memory sellOrder, LibSignature.Signature memory signature, uint128 erc1155BuyAmount, bytes memory callbackData) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct buyERC1155Call {
-        #[allow(missing_docs)]
-        pub sellOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub erc1155BuyAmount: u128,
-        #[allow(missing_docs)]
-        pub callbackData: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`buyERC1155((uint8,address,address,uint256,uint256,address,uint256,
-    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),
-    /// (uint8,uint8,bytes32,bytes32),uint128,bytes)`](buyERC1155Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct buyERC1155Return {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC1155Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<buyERC1155Call> for UnderlyingRustTuple<'_> {
-                fn from(value: buyERC1155Call) -> Self {
-                    (
-                        value.sellOrder,
-                        value.signature,
-                        value.erc1155BuyAmount,
-                        value.callbackData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC1155Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sellOrder: tuple.0,
-                        signature: tuple.1,
-                        erc1155BuyAmount: tuple.2,
-                        callbackData: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<buyERC1155Return> for UnderlyingRustTuple<'_> {
-                fn from(value: buyERC1155Return) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC1155Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl buyERC1155Return {
-            fn _tokenize(&self) -> <buyERC1155Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for buyERC1155Call {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC1155Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = buyERC1155Return;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [124u8, 219u8, 84u8, 216u8];
-            const SIGNATURE: &'static str = "buyERC1155((uint8,address,address,uint256,uint256,\
-                                             address,uint256,(address,uint256,bytes)[],address,\
-                                             uint256,(address,bytes)[],uint128),(uint8,uint8,\
-                                             bytes32,bytes32),uint128,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(
-                        &self.sellOrder,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155BuyAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.callbackData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                buyERC1155Return::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `buyERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),bytes)` and selector `0xfbee349d`.
-    ```solidity
-    function buyERC721(LibNFTOrder.ERC721Order memory sellOrder, LibSignature.Signature memory signature, bytes memory callbackData) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct buyERC721Call {
-        #[allow(missing_docs)]
-        pub sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub callbackData: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`buyERC721((uint8,address,address,uint256,uint256,address,uint256,
-    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,
-    /// uint8,bytes32,bytes32),bytes)`](buyERC721Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct buyERC721Return {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC721Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<buyERC721Call> for UnderlyingRustTuple<'_> {
-                fn from(value: buyERC721Call) -> Self {
-                    (value.sellOrder, value.signature, value.callbackData)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC721Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sellOrder: tuple.0,
-                        signature: tuple.1,
-                        callbackData: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<buyERC721Return> for UnderlyingRustTuple<'_> {
-                fn from(value: buyERC721Return) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for buyERC721Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl buyERC721Return {
-            fn _tokenize(&self) -> <buyERC721Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for buyERC721Call {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC721Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = buyERC721Return;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 238u8, 52u8, 157u8];
-            const SIGNATURE: &'static str = "buyERC721((uint8,address,address,uint256,uint256,\
-                                             address,uint256,(address,uint256,bytes)[],address,\
-                                             uint256,(address,bytes)[]),(uint8,uint8,bytes32,\
-                                             bytes32),bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
-                        &self.sellOrder,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.callbackData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                buyERC721Return::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelERC1155Order(uint256)` and selector `0x06d2596b`.
-    ```solidity
-    function cancelERC1155Order(uint256 orderNonce) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelERC1155OrderCall {
-        #[allow(missing_docs)]
-        pub orderNonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelERC1155Order(uint256)`](cancelERC1155OrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelERC1155OrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelERC1155OrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelERC1155OrderCall) -> Self {
-                    (value.orderNonce,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC1155OrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderNonce: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelERC1155OrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelERC1155OrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC1155OrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelERC1155OrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelERC1155OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelERC1155OrderCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = cancelERC1155OrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [6u8, 210u8, 89u8, 107u8];
-            const SIGNATURE: &'static str = "cancelERC1155Order(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.orderNonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelERC1155OrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelERC721Order(uint256)` and selector `0xbe167b9d`.
-    ```solidity
-    function cancelERC721Order(uint256 orderNonce) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelERC721OrderCall {
-        #[allow(missing_docs)]
-        pub orderNonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelERC721Order(uint256)`](cancelERC721OrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelERC721OrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelERC721OrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelERC721OrderCall) -> Self {
-                    (value.orderNonce,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC721OrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderNonce: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelERC721OrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelERC721OrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelERC721OrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelERC721OrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelERC721OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelERC721OrderCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = cancelERC721OrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [190u8, 22u8, 123u8, 157u8];
-            const SIGNATURE: &'static str = "cancelERC721Order(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.orderNonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelERC721OrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))` and selector `0x7d49ec1a`.
-    ```solidity
-    function cancelLimitOrder(LibNativeOrder.LimitOrder memory order) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelLimitOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelLimitOrder((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,uint256))`](cancelLimitOrderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelLimitOrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelLimitOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelLimitOrderCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelLimitOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelLimitOrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelLimitOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelLimitOrderCall {
-            type Parameters<'a> = (LibNativeOrder::LimitOrder,);
-            type Return = cancelLimitOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [125u8, 73u8, 236u8, 26u8];
-            const SIGNATURE: &'static str = "cancelLimitOrder((address,address,uint128,uint128,\
-                                             uint128,address,address,address,address,bytes32,\
-                                             uint64,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelLimitOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelPairLimitOrders(address,address,uint256)` and selector `0xd0a55fb0`.
-    ```solidity
-    function cancelPairLimitOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairLimitOrdersCall {
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelPairLimitOrders(address,address,
-    /// uint256)`](cancelPairLimitOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairLimitOrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairLimitOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairLimitOrdersCall) -> Self {
-                    (value.makerToken, value.takerToken, value.minValidSalt)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        makerToken: tuple.0,
-                        takerToken: tuple.1,
-                        minValidSalt: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairLimitOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairLimitOrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelPairLimitOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelPairLimitOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = cancelPairLimitOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 165u8, 95u8, 176u8];
-            const SIGNATURE: &'static str = "cancelPairLimitOrders(address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minValidSalt,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelPairLimitOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelPairLimitOrdersWithSigner(address,address,address,uint256)` and selector `0xb10a33f4`.
-    ```solidity
-    function cancelPairLimitOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairLimitOrdersWithSignerCall {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelPairLimitOrdersWithSigner(address,address,address,
-    /// uint256)`](cancelPairLimitOrdersWithSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairLimitOrdersWithSignerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairLimitOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairLimitOrdersWithSignerCall) -> Self {
-                    (
-                        value.maker,
-                        value.makerToken,
-                        value.takerToken,
-                        value.minValidSalt,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersWithSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        maker: tuple.0,
-                        makerToken: tuple.1,
-                        takerToken: tuple.2,
-                        minValidSalt: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairLimitOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairLimitOrdersWithSignerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairLimitOrdersWithSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelPairLimitOrdersWithSignerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelPairLimitOrdersWithSignerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = cancelPairLimitOrdersWithSignerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [177u8, 10u8, 51u8, 244u8];
-            const SIGNATURE: &'static str =
-                "cancelPairLimitOrdersWithSigner(address,address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minValidSalt,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelPairLimitOrdersWithSignerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelPairRfqOrders(address,address,uint256)` and selector `0x9a4f809c`.
-    ```solidity
-    function cancelPairRfqOrders(address makerToken, address takerToken, uint256 minValidSalt) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairRfqOrdersCall {
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelPairRfqOrders(address,address,
-    /// uint256)`](cancelPairRfqOrdersCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairRfqOrdersReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairRfqOrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairRfqOrdersCall) -> Self {
-                    (value.makerToken, value.takerToken, value.minValidSalt)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        makerToken: tuple.0,
-                        takerToken: tuple.1,
-                        minValidSalt: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairRfqOrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairRfqOrdersReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelPairRfqOrdersReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelPairRfqOrdersCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = cancelPairRfqOrdersReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [154u8, 79u8, 128u8, 156u8];
-            const SIGNATURE: &'static str = "cancelPairRfqOrders(address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minValidSalt,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelPairRfqOrdersReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelPairRfqOrdersWithSigner(address,address,address,uint256)` and selector `0x935c82a4`.
-    ```solidity
-    function cancelPairRfqOrdersWithSigner(address maker, address makerToken, address takerToken, uint256 minValidSalt) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairRfqOrdersWithSignerCall {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub makerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub takerToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelPairRfqOrdersWithSigner(address,address,address,
-    /// uint256)`](cancelPairRfqOrdersWithSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelPairRfqOrdersWithSignerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairRfqOrdersWithSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairRfqOrdersWithSignerCall) -> Self {
-                    (
-                        value.maker,
-                        value.makerToken,
-                        value.takerToken,
-                        value.minValidSalt,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersWithSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        maker: tuple.0,
-                        makerToken: tuple.1,
-                        takerToken: tuple.2,
-                        minValidSalt: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelPairRfqOrdersWithSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelPairRfqOrdersWithSignerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelPairRfqOrdersWithSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelPairRfqOrdersWithSignerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelPairRfqOrdersWithSignerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = cancelPairRfqOrdersWithSignerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [147u8, 92u8, 130u8, 164u8];
-            const SIGNATURE: &'static str =
-                "cancelPairRfqOrdersWithSigner(address,address,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.makerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.takerToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minValidSalt,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelPairRfqOrdersWithSignerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))` and selector `0xfe55a3ef`.
-    ```solidity
-    function cancelRfqOrder(LibNativeOrder.RfqOrder memory order) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelRfqOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelRfqOrder((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256))`](cancelRfqOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelRfqOrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelRfqOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelRfqOrderCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelRfqOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelRfqOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelRfqOrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelRfqOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl cancelRfqOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelRfqOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelRfqOrderCall {
-            type Parameters<'a> = (LibNativeOrder::RfqOrder,);
-            type Return = cancelRfqOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [254u8, 85u8, 163u8, 239u8];
-            const SIGNATURE: &'static str = "cancelRfqOrder((address,address,uint128,uint128,\
-                                             address,address,address,bytes32,uint64,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelRfqOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `createTransformWallet()` and selector `0x287b071b`.
-    ```solidity
-    function createTransformWallet() external returns (address wallet);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createTransformWalletCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`createTransformWallet()`](createTransformWalletCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createTransformWalletReturn {
-        #[allow(missing_docs)]
-        pub wallet: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createTransformWalletCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createTransformWalletCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createTransformWalletCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createTransformWalletReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createTransformWalletReturn) -> Self {
-                    (value.wallet,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createTransformWalletReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { wallet: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createTransformWalletCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [40u8, 123u8, 7u8, 27u8];
-            const SIGNATURE: &'static str = "createTransformWallet()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createTransformWalletReturn = r.into();
-                        r.wallet
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createTransformWalletReturn = r.into();
-                    r.wallet
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `executeMetaTransaction((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x3d61ed3e`.
-    ```solidity
-    function executeMetaTransaction(IMetaTransactionsFeature.MetaTransactionData memory mtx, LibSignature.Signature memory signature) external payable returns (bytes memory returnResult);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct executeMetaTransactionCall {
-        #[allow(missing_docs)]
-        pub mtx:
-            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`executeMetaTransaction((address,address,uint256,uint256,uint256,
-    /// uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,
-    /// bytes32))`](executeMetaTransactionCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct executeMetaTransactionReturn {
-        #[allow(missing_docs)]
-        pub returnResult: alloy_sol_types::private::Bytes,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                IMetaTransactionsFeature::MetaTransactionData,
-                LibSignature::Signature,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<executeMetaTransactionCall> for UnderlyingRustTuple<'_> {
-                fn from(value: executeMetaTransactionCall) -> Self {
-                    (value.mtx, value.signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeMetaTransactionCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        mtx: tuple.0,
-                        signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Bytes,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<executeMetaTransactionReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: executeMetaTransactionReturn) -> Self {
-                    (value.returnResult,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeMetaTransactionReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        returnResult: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for executeMetaTransactionCall {
-            type Parameters<'a> = (
-                IMetaTransactionsFeature::MetaTransactionData,
-                LibSignature::Signature,
-            );
-            type Return = alloy_sol_types::private::Bytes;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bytes,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [61u8, 97u8, 237u8, 62u8];
-            const SIGNATURE: &'static str = "executeMetaTransaction((address,address,uint256,\
-                                             uint256,uint256,uint256,bytes,uint256,address,\
-                                             uint256),(uint8,uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::tokenize(
-                        &self.mtx,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: executeMetaTransactionReturn = r.into();
-                        r.returnResult
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: executeMetaTransactionReturn = r.into();
-                    r.returnResult
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `extend(bytes4,address)` and selector `0x6eb224cb`.
-    ```solidity
-    function extend(bytes4 selector, address r#impl) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct extendCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-        #[allow(missing_docs)]
-        pub r#impl: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`extend(bytes4,address)`](extendCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct extendReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<4>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<4>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<extendCall> for UnderlyingRustTuple<'_> {
-                fn from(value: extendCall) -> Self {
-                    (value.selector, value.r#impl)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for extendCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        selector: tuple.0,
-                        r#impl: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<extendReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: extendReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for extendReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl extendReturn {
-            fn _tokenize(&self) -> <extendCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for extendCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<4>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = extendReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [110u8, 178u8, 36u8, 203u8];
-            const SIGNATURE: &'static str = "extend(bytes4,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.r#impl,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                extendReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xf6274f66`.
-    ```solidity
-    function fillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillLimitOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillLimitOrder((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
-    /// bytes32),uint128)`](fillLimitOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillLimitOrderReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::LimitOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillLimitOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillLimitOrderCall) -> Self {
-                    (value.order, value.signature, value.takerTokenFillAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillLimitOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillLimitOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillLimitOrderReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillLimitOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl fillLimitOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <fillLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillLimitOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::LimitOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = fillLimitOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [246u8, 39u8, 79u8, 102u8];
-            const SIGNATURE: &'static str =
-                "fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,\
-                 address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillLimitOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0x9240529c`.
-    ```solidity
-    function fillOrKillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOrKillLimitOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
-    /// bytes32),uint128)`](fillOrKillLimitOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOrKillLimitOrderReturn {
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::LimitOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOrKillLimitOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOrKillLimitOrderCall) -> Self {
-                    (value.order, value.signature, value.takerTokenFillAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillLimitOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOrKillLimitOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOrKillLimitOrderReturn) -> Self {
-                    (value.makerTokenFilledAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillLimitOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        makerTokenFilledAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillOrKillLimitOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::LimitOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = u128;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [146u8, 64u8, 82u8, 156u8];
-            const SIGNATURE: &'static str =
-                "fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,\
-                 address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: fillOrKillLimitOrderReturn = r.into();
-                        r.makerTokenFilledAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: fillOrKillLimitOrderReturn = r.into();
-                    r.makerTokenFilledAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillOrKillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0x438cdfc5`.
-    ```solidity
-    function fillOrKillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOrKillRfqOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillOrKillRfqOrder((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),
-    /// uint128)`](fillOrKillRfqOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOrKillRfqOrderReturn {
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::RfqOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOrKillRfqOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOrKillRfqOrderCall) -> Self {
-                    (value.order, value.signature, value.takerTokenFillAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillRfqOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOrKillRfqOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOrKillRfqOrderReturn) -> Self {
-                    (value.makerTokenFilledAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillRfqOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        makerTokenFilledAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillOrKillRfqOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::RfqOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = u128;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [67u8, 140u8, 223u8, 197u8];
-            const SIGNATURE: &'static str = "fillOrKillRfqOrder((address,address,uint128,uint128,\
-                                             address,address,address,bytes32,uint64,uint256),\
-                                             (uint8,uint8,bytes32,bytes32),uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: fillOrKillRfqOrderReturn = r.into();
-                        r.makerTokenFilledAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: fillOrKillRfqOrderReturn = r.into();
-                    r.makerTokenFilledAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xdac748d4`.
-    ```solidity
-    function fillOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOtcOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillOtcOrder((address,address,uint128,uint128,address,address,address,
-    /// uint256),(uint8,uint8,bytes32,bytes32),uint128)`](fillOtcOrderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOtcOrderReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOtcOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOtcOrderCall) -> Self {
-                    (
-                        value.order,
-                        value.makerSignature,
-                        value.takerTokenFillAmount,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        makerSignature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOtcOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOtcOrderReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl fillOtcOrderReturn {
-            fn _tokenize(&self) -> <fillOtcOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillOtcOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = fillOtcOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [218u8, 199u8, 72u8, 212u8];
-            const SIGNATURE: &'static str = "fillOtcOrder((address,address,uint128,uint128,\
-                                             address,address,address,uint256),(uint8,uint8,\
-                                             bytes32,bytes32),uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.makerSignature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillOtcOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xa578efaf`.
-    ```solidity
-    function fillOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOtcOrderForEthCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillOtcOrderForEth((address,address,uint128,uint128,address,address,
-    /// address,uint256),(uint8,uint8,bytes32,bytes32),
-    /// uint128)`](fillOtcOrderForEthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOtcOrderForEthReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOtcOrderForEthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOtcOrderForEthCall) -> Self {
-                    (
-                        value.order,
-                        value.makerSignature,
-                        value.takerTokenFillAmount,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderForEthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        makerSignature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOtcOrderForEthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOtcOrderForEthReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderForEthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl fillOtcOrderForEthReturn {
-            fn _tokenize(
-                &self,
-            ) -> <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillOtcOrderForEthCall {
-            type Parameters<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = fillOtcOrderForEthReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [165u8, 120u8, 239u8, 175u8];
-            const SIGNATURE: &'static str = "fillOtcOrderForEth((address,address,uint128,uint128,\
-                                             address,address,address,uint256),(uint8,uint8,\
-                                             bytes32,bytes32),uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.makerSignature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillOtcOrderForEthReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillOtcOrderWithEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x706394d5`.
-    ```solidity
-    function fillOtcOrderWithEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature) external payable returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOtcOrderWithEthCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillOtcOrderWithEth((address,address,uint128,uint128,address,address,
-    /// address,uint256),(uint8,uint8,bytes32,
-    /// bytes32))`](fillOtcOrderWithEthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillOtcOrderWithEthReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrder, LibSignature::Signature);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOtcOrderWithEthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOtcOrderWithEthCall) -> Self {
-                    (value.order, value.makerSignature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderWithEthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        makerSignature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillOtcOrderWithEthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillOtcOrderWithEthReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOtcOrderWithEthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl fillOtcOrderWithEthReturn {
-            fn _tokenize(
-                &self,
-            ) -> <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillOtcOrderWithEthCall {
-            type Parameters<'a> = (LibNativeOrder::OtcOrder, LibSignature::Signature);
-            type Return = fillOtcOrderWithEthReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 99u8, 148u8, 213u8];
-            const SIGNATURE: &'static str = "fillOtcOrderWithEth((address,address,uint128,uint128,\
-                                             address,address,address,uint256),(uint8,uint8,\
-                                             bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.makerSignature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillOtcOrderWithEthReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0xaa77476c`.
-    ```solidity
-    function fillRfqOrder(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillRfqOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerTokenFillAmount: u128,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`fillRfqOrder((address,address,uint128,uint128,address,address,address,
-    /// bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),
-    /// uint128)`](fillRfqOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillRfqOrderReturn {
-        #[allow(missing_docs)]
-        pub takerTokenFilledAmount: u128,
-        #[allow(missing_docs)]
-        pub makerTokenFilledAmount: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::RfqOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillRfqOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillRfqOrderCall) -> Self {
-                    (value.order, value.signature, value.takerTokenFillAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillRfqOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                        takerTokenFillAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillRfqOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillRfqOrderReturn) -> Self {
-                    (value.takerTokenFilledAmount, value.makerTokenFilledAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillRfqOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        takerTokenFilledAmount: tuple.0,
-                        makerTokenFilledAmount: tuple.1,
-                    }
-                }
-            }
-        }
-        impl fillRfqOrderReturn {
-            fn _tokenize(&self) -> <fillRfqOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFilledAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.makerTokenFilledAmount,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillRfqOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::RfqOrder,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = fillRfqOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [170u8, 119u8, 71u8, 108u8];
-            const SIGNATURE: &'static str = "fillRfqOrder((address,address,uint128,uint128,\
-                                             address,address,address,bytes32,uint64,uint256),\
-                                             (uint8,uint8,bytes32,bytes32),uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.takerTokenFillAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillRfqOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillTakerSignedOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))` and selector `0x4f948110`.
-    ```solidity
-    function fillTakerSignedOtcOrder(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillTakerSignedOtcOrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`fillTakerSignedOtcOrder((address,address,uint128,uint128,address,
-    /// address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,
-    /// bytes32,bytes32))`](fillTakerSignedOtcOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillTakerSignedOtcOrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                LibSignature::Signature,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillTakerSignedOtcOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillTakerSignedOtcOrderCall) -> Self {
-                    (value.order, value.makerSignature, value.takerSignature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        makerSignature: tuple.1,
-                        takerSignature: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillTakerSignedOtcOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillTakerSignedOtcOrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl fillTakerSignedOtcOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillTakerSignedOtcOrderCall {
-            type Parameters<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                LibSignature::Signature,
-            );
-            type Return = fillTakerSignedOtcOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [79u8, 148u8, 129u8, 16u8];
-            const SIGNATURE: &'static str = "fillTakerSignedOtcOrder((address,address,uint128,\
-                                             uint128,address,address,address,uint256),(uint8,\
-                                             uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.makerSignature,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.takerSignature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillTakerSignedOtcOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))` and selector `0x724d3953`.
-    ```solidity
-    function fillTakerSignedOtcOrderForEth(LibNativeOrder.OtcOrder memory order, LibSignature.Signature memory makerSignature, LibSignature.Signature memory takerSignature) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillTakerSignedOtcOrderForEthCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,
-    /// address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,
-    /// uint8,bytes32,bytes32))`](fillTakerSignedOtcOrderForEthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct fillTakerSignedOtcOrderForEthReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                LibSignature::Signature,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillTakerSignedOtcOrderForEthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: fillTakerSignedOtcOrderForEthCall) -> Self {
-                    (value.order, value.makerSignature, value.takerSignature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderForEthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        makerSignature: tuple.1,
-                        takerSignature: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<fillTakerSignedOtcOrderForEthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: fillTakerSignedOtcOrderForEthReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillTakerSignedOtcOrderForEthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl fillTakerSignedOtcOrderForEthReturn {
-            fn _tokenize(
-                &self,
-            ) -> <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for fillTakerSignedOtcOrderForEthCall {
-            type Parameters<'a> = (
-                LibNativeOrder::OtcOrder,
-                LibSignature::Signature,
-                LibSignature::Signature,
-            );
-            type Return = fillTakerSignedOtcOrderForEthReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [114u8, 77u8, 57u8, 83u8];
-            const SIGNATURE: &'static str =
-                "fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,\
-                 address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.makerSignature,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.takerSignature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                fillTakerSignedOtcOrderForEthReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `getERC1155OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))` and selector `0x1de3a7ac`.
-    ```solidity
-    function getERC1155OrderHash(LibNFTOrder.ERC1155Order memory order) external view returns (bytes32 orderHash);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC1155OrderHashCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getERC1155OrderHash((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
-    /// uint128))`](getERC1155OrderHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC1155OrderHashReturn {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC1155OrderHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC1155OrderHashCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC1155OrderHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC1155OrderHashReturn) -> Self {
-                    (value.orderHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderHash: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getERC1155OrderHashCall {
-            type Parameters<'a> = (LibNFTOrder::ERC1155Order,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [29u8, 227u8, 167u8, 172u8];
-            const SIGNATURE: &'static str = "getERC1155OrderHash((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[],uint128))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getERC1155OrderHashReturn = r.into();
-                        r.orderHash
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getERC1155OrderHashReturn = r.into();
-                    r.orderHash
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `getERC1155OrderInfo((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))` and selector `0x4991fd72`.
-    ```solidity
-    function getERC1155OrderInfo(LibNFTOrder.ERC1155Order memory order) external view returns (LibNFTOrder.OrderInfo memory orderInfo);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC1155OrderInfoCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`getERC1155OrderInfo((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
-    /// uint128))`](getERC1155OrderInfoCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC1155OrderInfoReturn {
-        #[allow(missing_docs)]
-        pub orderInfo: <LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC1155OrderInfoCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC1155OrderInfoCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderInfoCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::OrderInfo,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC1155OrderInfoReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC1155OrderInfoReturn) -> Self {
-                    (value.orderInfo,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC1155OrderInfoReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderInfo: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getERC1155OrderInfoCall {
-            type Parameters<'a> = (LibNFTOrder::ERC1155Order,);
-            type Return = <LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::RustType;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (LibNFTOrder::OrderInfo,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [73u8, 145u8, 253u8, 114u8];
-            const SIGNATURE: &'static str = "getERC1155OrderInfo((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[],uint128))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<LibNFTOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getERC1155OrderInfoReturn = r.into();
-                        r.orderInfo
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getERC1155OrderInfoReturn = r.into();
-                    r.orderInfo
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `getERC721OrderHash((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))` and selector `0xb73a6027`.
-    ```solidity
-    function getERC721OrderHash(LibNFTOrder.ERC721Order memory order) external view returns (bytes32 orderHash);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC721OrderHashCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getERC721OrderHash((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[]))`](getERC721OrderHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC721OrderHashReturn {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC721OrderHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC721OrderHashCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC721OrderHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC721OrderHashReturn) -> Self {
-                    (value.orderHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderHash: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getERC721OrderHashCall {
-            type Parameters<'a> = (LibNFTOrder::ERC721Order,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [183u8, 58u8, 96u8, 39u8];
-            const SIGNATURE: &'static str = "getERC721OrderHash((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[]))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getERC721OrderHashReturn = r.into();
-                        r.orderHash
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getERC721OrderHashReturn = r.into();
-                    r.orderHash
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `getERC721OrderStatus((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))` and selector `0xfbc4a518`.
-    ```solidity
-    function getERC721OrderStatus(LibNFTOrder.ERC721Order memory order) external view returns (LibNFTOrder.OrderStatus status);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC721OrderStatusCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getERC721OrderStatus((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[]))`](getERC721OrderStatusCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC721OrderStatusReturn {
-        #[allow(missing_docs)]
-        pub status: <LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC721OrderStatusCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC721OrderStatusCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::OrderStatus,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC721OrderStatusReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC721OrderStatusReturn) -> Self {
-                    (value.status,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { status: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getERC721OrderStatusCall {
-            type Parameters<'a> = (LibNFTOrder::ERC721Order,);
-            type Return = <LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::RustType;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (LibNFTOrder::OrderStatus,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 196u8, 165u8, 24u8];
-            const SIGNATURE: &'static str = "getERC721OrderStatus((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[]))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<LibNFTOrder::OrderStatus as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getERC721OrderStatusReturn = r.into();
-                        r.status
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getERC721OrderStatusReturn = r.into();
-                    r.status
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getERC721OrderStatusBitVector(address,uint248)` and selector `0x030b2730`.
-    ```solidity
-    function getERC721OrderStatusBitVector(address maker, uint248 nonceRange) external view returns (uint256 bitVector);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC721OrderStatusBitVectorCall {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub nonceRange: alloy_sol_types::private::primitives::aliases::U248,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getERC721OrderStatusBitVector(address,
-    /// uint248)`](getERC721OrderStatusBitVectorCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getERC721OrderStatusBitVectorReturn {
-        #[allow(missing_docs)]
-        pub bitVector: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<248>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U248,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC721OrderStatusBitVectorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC721OrderStatusBitVectorCall) -> Self {
-                    (value.maker, value.nonceRange)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusBitVectorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        maker: tuple.0,
-                        nonceRange: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getERC721OrderStatusBitVectorReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getERC721OrderStatusBitVectorReturn) -> Self {
-                    (value.bitVector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getERC721OrderStatusBitVectorReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { bitVector: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getERC721OrderStatusBitVectorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<248>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [3u8, 11u8, 39u8, 48u8];
-            const SIGNATURE: &'static str = "getERC721OrderStatusBitVector(address,uint248)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<248> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonceRange,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getERC721OrderStatusBitVectorReturn = r.into();
-                        r.bitVector
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getERC721OrderStatusBitVectorReturn = r.into();
-                    r.bitVector
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getLimitOrderHash((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))` and selector `0xdd11d225`.
-    ```solidity
-    function getLimitOrderHash(LibNativeOrder.LimitOrder memory order) external view returns (bytes32 orderHash);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLimitOrderHashCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getLimitOrderHash((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,
-    /// uint256))`](getLimitOrderHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLimitOrderHashReturn {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLimitOrderHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getLimitOrderHashCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLimitOrderHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getLimitOrderHashReturn) -> Self {
-                    (value.orderHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderHash: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getLimitOrderHashCall {
-            type Parameters<'a> = (LibNativeOrder::LimitOrder,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [221u8, 17u8, 210u8, 37u8];
-            const SIGNATURE: &'static str = "getLimitOrderHash((address,address,uint128,uint128,\
-                                             uint128,address,address,address,address,bytes32,\
-                                             uint64,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getLimitOrderHashReturn = r.into();
-                        r.orderHash
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getLimitOrderHashReturn = r.into();
-                    r.orderHash
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getLimitOrderInfo((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))` and selector `0x95480889`.
-    ```solidity
-    function getLimitOrderInfo(LibNativeOrder.LimitOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLimitOrderInfoCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`getLimitOrderInfo((address,address,uint128,uint128,uint128,address,
-    /// address,address,address,bytes32,uint64,
-    /// uint256))`](getLimitOrderInfoCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLimitOrderInfoReturn {
-        #[allow(missing_docs)]
-        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLimitOrderInfoCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getLimitOrderInfoCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderInfoCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::OrderInfo,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLimitOrderInfoReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getLimitOrderInfoReturn) -> Self {
-                    (value.orderInfo,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderInfoReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderInfo: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getLimitOrderInfoCall {
-            type Parameters<'a> = (LibNativeOrder::LimitOrder,);
-            type Return = <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (LibNativeOrder::OrderInfo,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [149u8, 72u8, 8u8, 137u8];
-            const SIGNATURE: &'static str = "getLimitOrderInfo((address,address,uint128,uint128,\
-                                             uint128,address,address,address,address,bytes32,\
-                                             uint64,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getLimitOrderInfoReturn = r.into();
-                        r.orderInfo
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getLimitOrderInfoReturn = r.into();
-                    r.orderInfo
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x1fb09795`.
-    ```solidity
-    function getLimitOrderRelevantState(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLimitOrderRelevantStateCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`getLimitOrderRelevantState((address,address,uint128,uint128,uint128,
-    /// address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,
-    /// bytes32,bytes32))`](getLimitOrderRelevantStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getLimitOrderRelevantStateReturn {
-        #[allow(missing_docs)]
-        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub actualFillableTakerTokenAmount: u128,
-        #[allow(missing_docs)]
-        pub isSignatureValid: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder, LibSignature::Signature);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLimitOrderRelevantStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getLimitOrderRelevantStateCall) -> Self {
-                    (value.order, value.signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderRelevantStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OrderInfo,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-                u128,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getLimitOrderRelevantStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getLimitOrderRelevantStateReturn) -> Self {
-                    (
-                        value.orderInfo,
-                        value.actualFillableTakerTokenAmount,
-                        value.isSignatureValid,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderRelevantStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderInfo: tuple.0,
-                        actualFillableTakerTokenAmount: tuple.1,
-                        isSignatureValid: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getLimitOrderRelevantStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(
-                        &self.orderInfo,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.actualFillableTakerTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.isSignatureValid,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getLimitOrderRelevantStateCall {
-            type Parameters<'a> = (LibNativeOrder::LimitOrder, LibSignature::Signature);
-            type Return = getLimitOrderRelevantStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                LibNativeOrder::OrderInfo,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 176u8, 151u8, 149u8];
-            const SIGNATURE: &'static str =
-                "getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,\
-                 address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getLimitOrderRelevantStateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getMetaTransactionExecutedBlock((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))` and selector `0x3fb2da38`.
-    ```solidity
-    function getMetaTransactionExecutedBlock(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (uint256 blockNumber);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMetaTransactionExecutedBlockCall {
-        #[allow(missing_docs)]
-        pub mtx:
-            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getMetaTransactionExecutedBlock((address,address,uint256,uint256,
-    /// uint256,uint256,bytes,uint256,address,
-    /// uint256))`](getMetaTransactionExecutedBlockCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMetaTransactionExecutedBlockReturn {
-        #[allow(missing_docs)]
-        pub blockNumber: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMetaTransactionExecutedBlockCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getMetaTransactionExecutedBlockCall) -> Self {
-                    (value.mtx,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionExecutedBlockCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { mtx: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMetaTransactionExecutedBlockReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getMetaTransactionExecutedBlockReturn) -> Self {
-                    (value.blockNumber,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionExecutedBlockReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        blockNumber: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getMetaTransactionExecutedBlockCall {
-            type Parameters<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [63u8, 178u8, 218u8, 56u8];
-            const SIGNATURE: &'static str = "getMetaTransactionExecutedBlock((address,address,\
-                                             uint256,uint256,uint256,uint256,bytes,uint256,\
-                                             address,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::tokenize(
-                        &self.mtx,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getMetaTransactionExecutedBlockReturn = r.into();
-                        r.blockNumber
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getMetaTransactionExecutedBlockReturn = r.into();
-                    r.blockNumber
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getMetaTransactionHash((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))` and selector `0xae550497`.
-    ```solidity
-    function getMetaTransactionHash(IMetaTransactionsFeature.MetaTransactionData memory mtx) external view returns (bytes32 mtxHash);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMetaTransactionHashCall {
-        #[allow(missing_docs)]
-        pub mtx:
-            <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getMetaTransactionHash((address,address,uint256,uint256,uint256,
-    /// uint256,bytes,uint256,address,uint256))`](getMetaTransactionHashCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMetaTransactionHashReturn {
-        #[allow(missing_docs)]
-        pub mtxHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMetaTransactionHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getMetaTransactionHashCall) -> Self {
-                    (value.mtx,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { mtx: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMetaTransactionHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getMetaTransactionHashReturn) -> Self {
-                    (value.mtxHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { mtxHash: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getMetaTransactionHashCall {
-            type Parameters<'a> = (IMetaTransactionsFeature::MetaTransactionData,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [174u8, 85u8, 4u8, 151u8];
-            const SIGNATURE: &'static str = "getMetaTransactionHash((address,address,uint256,\
-                                             uint256,uint256,uint256,bytes,uint256,address,\
-                                             uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::tokenize(
-                        &self.mtx,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getMetaTransactionHashReturn = r.into();
-                        r.mtxHash
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getMetaTransactionHashReturn = r.into();
-                    r.mtxHash
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getMetaTransactionHashExecutedBlock(bytes32)` and selector `0x72d17d03`.
-    ```solidity
-    function getMetaTransactionHashExecutedBlock(bytes32 mtxHash) external view returns (uint256 blockNumber);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMetaTransactionHashExecutedBlockCall {
-        #[allow(missing_docs)]
-        pub mtxHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getMetaTransactionHashExecutedBlock(bytes32)`](getMetaTransactionHashExecutedBlockCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getMetaTransactionHashExecutedBlockReturn {
-        #[allow(missing_docs)]
-        pub blockNumber: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMetaTransactionHashExecutedBlockCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getMetaTransactionHashExecutedBlockCall) -> Self {
-                    (value.mtxHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashExecutedBlockCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { mtxHash: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getMetaTransactionHashExecutedBlockReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getMetaTransactionHashExecutedBlockReturn) -> Self {
-                    (value.blockNumber,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetaTransactionHashExecutedBlockReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        blockNumber: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getMetaTransactionHashExecutedBlockCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [114u8, 209u8, 125u8, 3u8];
-            const SIGNATURE: &'static str = "getMetaTransactionHashExecutedBlock(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.mtxHash),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getMetaTransactionHashExecutedBlockReturn = r.into();
-                        r.blockNumber
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getMetaTransactionHashExecutedBlockReturn = r.into();
-                    r.blockNumber
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOtcOrderHash((address,address,uint128,uint128,address,address,address,uint256))` and selector `0x53476b89`.
-    ```solidity
-    function getOtcOrderHash(LibNativeOrder.OtcOrder memory order) external view returns (bytes32 orderHash);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOtcOrderHashCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getOtcOrderHash((address,address,uint128,uint128,address,address,
-    /// address,uint256))`](getOtcOrderHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOtcOrderHashReturn {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOtcOrderHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOtcOrderHashCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOtcOrderHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOtcOrderHashReturn) -> Self {
-                    (value.orderHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderHash: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOtcOrderHashCall {
-            type Parameters<'a> = (LibNativeOrder::OtcOrder,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [83u8, 71u8, 107u8, 137u8];
-            const SIGNATURE: &'static str = "getOtcOrderHash((address,address,uint128,uint128,\
-                                             address,address,address,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOtcOrderHashReturn = r.into();
-                        r.orderHash
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOtcOrderHashReturn = r.into();
-                    r.orderHash
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getOtcOrderInfo((address,address,uint128,uint128,address,address,address,uint256))` and selector `0x8c807c43`.
-    ```solidity
-    function getOtcOrderInfo(LibNativeOrder.OtcOrder memory order) external view returns (LibNativeOrder.OtcOrderInfo memory orderInfo);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOtcOrderInfoCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`getOtcOrderInfo((address,address,uint128,uint128,address,address,
-    /// address,uint256))`](getOtcOrderInfoCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getOtcOrderInfoReturn {
-        #[allow(missing_docs)]
-        pub orderInfo: <LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOtcOrderInfoCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getOtcOrderInfoCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderInfoCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::OtcOrderInfo,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getOtcOrderInfoReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getOtcOrderInfoReturn) -> Self {
-                    (value.orderInfo,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOtcOrderInfoReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderInfo: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getOtcOrderInfoCall {
-            type Parameters<'a> = (LibNativeOrder::OtcOrder,);
-            type Return = <LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::RustType;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (LibNativeOrder::OtcOrderInfo,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [140u8, 128u8, 124u8, 67u8];
-            const SIGNATURE: &'static str = "getOtcOrderInfo((address,address,uint128,uint128,\
-                                             address,address,address,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<LibNativeOrder::OtcOrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getOtcOrderInfoReturn = r.into();
-                        r.orderInfo
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getOtcOrderInfoReturn = r.into();
-                    r.orderInfo
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getProtocolFeeMultiplier()` and selector `0x487b5c20`.
-    ```solidity
-    function getProtocolFeeMultiplier() external view returns (uint32 multiplier);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeeMultiplierCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getProtocolFeeMultiplier()`](getProtocolFeeMultiplierCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getProtocolFeeMultiplierReturn {
-        #[allow(missing_docs)]
-        pub multiplier: u32,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeeMultiplierCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeeMultiplierCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeeMultiplierCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u32,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getProtocolFeeMultiplierReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getProtocolFeeMultiplierReturn) -> Self {
-                    (value.multiplier,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getProtocolFeeMultiplierReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        multiplier: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getProtocolFeeMultiplierCall {
-            type Parameters<'a> = ();
-            type Return = u32;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [72u8, 123u8, 92u8, 32u8];
-            const SIGNATURE: &'static str = "getProtocolFeeMultiplier()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getProtocolFeeMultiplierReturn = r.into();
-                        r.multiplier
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getProtocolFeeMultiplierReturn = r.into();
-                    r.multiplier
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getQuoteSigner()` and selector `0x9f1ec78b`.
-    ```solidity
-    function getQuoteSigner() external view returns (address signer);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getQuoteSignerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getQuoteSigner()`](getQuoteSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getQuoteSignerReturn {
-        #[allow(missing_docs)]
-        pub signer: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getQuoteSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getQuoteSignerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getQuoteSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getQuoteSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getQuoteSignerReturn) -> Self {
-                    (value.signer,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getQuoteSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { signer: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getQuoteSignerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [159u8, 30u8, 199u8, 139u8];
-            const SIGNATURE: &'static str = "getQuoteSigner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getQuoteSignerReturn = r.into();
-                        r.signer
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getQuoteSignerReturn = r.into();
-                    r.signer
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRfqOrderHash((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))` and selector `0x016a6d65`.
-    ```solidity
-    function getRfqOrderHash(LibNativeOrder.RfqOrder memory order) external view returns (bytes32 orderHash);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRfqOrderHashCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRfqOrderHash((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256))`](getRfqOrderHashCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRfqOrderHashReturn {
-        #[allow(missing_docs)]
-        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRfqOrderHashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRfqOrderHashCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderHashCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRfqOrderHashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRfqOrderHashReturn) -> Self {
-                    (value.orderHash,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderHashReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderHash: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRfqOrderHashCall {
-            type Parameters<'a> = (LibNativeOrder::RfqOrder,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [1u8, 106u8, 109u8, 101u8];
-            const SIGNATURE: &'static str = "getRfqOrderHash((address,address,uint128,uint128,\
-                                             address,address,address,bytes32,uint64,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRfqOrderHashReturn = r.into();
-                        r.orderHash
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRfqOrderHashReturn = r.into();
-                    r.orderHash
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRfqOrderInfo((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))` and selector `0x346693c5`.
-    ```solidity
-    function getRfqOrderInfo(LibNativeOrder.RfqOrder memory order) external view returns (LibNativeOrder.OrderInfo memory orderInfo);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRfqOrderInfoCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`getRfqOrderInfo((address,address,uint128,uint128,address,address,
-    /// address,bytes32,uint64,uint256))`](getRfqOrderInfoCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRfqOrderInfoReturn {
-        #[allow(missing_docs)]
-        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRfqOrderInfoCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRfqOrderInfoCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderInfoCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::OrderInfo,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRfqOrderInfoReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRfqOrderInfoReturn) -> Self {
-                    (value.orderInfo,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderInfoReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { orderInfo: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRfqOrderInfoCall {
-            type Parameters<'a> = (LibNativeOrder::RfqOrder,);
-            type Return = <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (LibNativeOrder::OrderInfo,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [52u8, 102u8, 147u8, 197u8];
-            const SIGNATURE: &'static str = "getRfqOrderInfo((address,address,uint128,uint128,\
-                                             address,address,address,bytes32,uint64,uint256))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRfqOrderInfoReturn = r.into();
-                        r.orderInfo
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRfqOrderInfoReturn = r.into();
-                    r.orderInfo
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `getRfqOrderRelevantState((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x37f381d8`.
-    ```solidity
-    function getRfqOrderRelevantState(LibNativeOrder.RfqOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRfqOrderRelevantStateCall {
-        #[allow(missing_docs)]
-        pub order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive()]
-    ///Container type for the return parameters of the
-    /// [`getRfqOrderRelevantState((address,address,uint128,uint128,address,
-    /// address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
-    /// bytes32))`](getRfqOrderRelevantStateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRfqOrderRelevantStateReturn {
-        #[allow(missing_docs)]
-        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub actualFillableTakerTokenAmount: u128,
-        #[allow(missing_docs)]
-        pub isSignatureValid: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNativeOrder::RfqOrder, LibSignature::Signature);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRfqOrderRelevantStateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRfqOrderRelevantStateCall) -> Self {
-                    (value.order, value.signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderRelevantStateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNativeOrder::OrderInfo,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
-                u128,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRfqOrderRelevantStateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRfqOrderRelevantStateReturn) -> Self {
-                    (
-                        value.orderInfo,
-                        value.actualFillableTakerTokenAmount,
-                        value.isSignatureValid,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRfqOrderRelevantStateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        orderInfo: tuple.0,
-                        actualFillableTakerTokenAmount: tuple.1,
-                        isSignatureValid: tuple.2,
-                    }
-                }
-            }
-        }
-        impl getRfqOrderRelevantStateReturn {
-            fn _tokenize(
-                &self,
-            ) -> <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(
-                        &self.orderInfo,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.actualFillableTakerTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.isSignatureValid,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRfqOrderRelevantStateCall {
-            type Parameters<'a> = (LibNativeOrder::RfqOrder, LibSignature::Signature);
-            type Return = getRfqOrderRelevantStateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                LibNativeOrder::OrderInfo,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [55u8, 243u8, 129u8, 216u8];
-            const SIGNATURE: &'static str = "getRfqOrderRelevantState((address,address,uint128,\
-                                             uint128,address,address,address,bytes32,uint64,\
-                                             uint256),(uint8,uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                getRfqOrderRelevantStateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRollbackEntryAtIndex(bytes4,uint256)` and selector `0x6ba6bbc2`.
-    ```solidity
-    function getRollbackEntryAtIndex(bytes4 selector, uint256 idx) external view returns (address r#impl);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRollbackEntryAtIndexCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-        #[allow(missing_docs)]
-        pub idx: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRollbackEntryAtIndex(bytes4,uint256)`](getRollbackEntryAtIndexCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRollbackEntryAtIndexReturn {
-        #[allow(missing_docs)]
-        pub r#impl: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<4>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<4>,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRollbackEntryAtIndexCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRollbackEntryAtIndexCall) -> Self {
-                    (value.selector, value.idx)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackEntryAtIndexCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        selector: tuple.0,
-                        idx: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRollbackEntryAtIndexReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRollbackEntryAtIndexReturn) -> Self {
-                    (value.r#impl,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackEntryAtIndexReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { r#impl: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRollbackEntryAtIndexCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<4>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [107u8, 166u8, 187u8, 194u8];
-            const SIGNATURE: &'static str = "getRollbackEntryAtIndex(bytes4,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.idx),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRollbackEntryAtIndexReturn = r.into();
-                        r.r#impl
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRollbackEntryAtIndexReturn = r.into();
-                    r.r#impl
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getRollbackLength(bytes4)` and selector `0xdfd00749`.
-    ```solidity
-    function getRollbackLength(bytes4 selector) external view returns (uint256 rollbackLength);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRollbackLengthCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getRollbackLength(bytes4)`](getRollbackLengthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getRollbackLengthReturn {
-        #[allow(missing_docs)]
-        pub rollbackLength: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRollbackLengthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getRollbackLengthCall) -> Self {
-                    (value.selector,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackLengthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { selector: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getRollbackLengthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getRollbackLengthReturn) -> Self {
-                    (value.rollbackLength,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRollbackLengthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        rollbackLength: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getRollbackLengthCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [223u8, 208u8, 7u8, 73u8];
-            const SIGNATURE: &'static str = "getRollbackLength(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getRollbackLengthReturn = r.into();
-                        r.rollbackLength
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getRollbackLengthReturn = r.into();
-                    r.rollbackLength
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTransformWallet()` and selector `0xf028e9be`.
-    ```solidity
-    function getTransformWallet() external view returns (address wallet);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTransformWalletCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getTransformWallet()`](getTransformWalletCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTransformWalletReturn {
-        #[allow(missing_docs)]
-        pub wallet: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTransformWalletCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTransformWalletCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformWalletCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTransformWalletReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTransformWalletReturn) -> Self {
-                    (value.wallet,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformWalletReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { wallet: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTransformWalletCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [240u8, 40u8, 233u8, 190u8];
-            const SIGNATURE: &'static str = "getTransformWallet()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getTransformWalletReturn = r.into();
-                        r.wallet
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getTransformWalletReturn = r.into();
-                    r.wallet
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getTransformerDeployer()` and selector `0x4d54cdb6`.
-    ```solidity
-    function getTransformerDeployer() external view returns (address deployer);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTransformerDeployerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getTransformerDeployer()`](getTransformerDeployerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getTransformerDeployerReturn {
-        #[allow(missing_docs)]
-        pub deployer: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTransformerDeployerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getTransformerDeployerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformerDeployerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getTransformerDeployerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getTransformerDeployerReturn) -> Self {
-                    (value.deployer,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTransformerDeployerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { deployer: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getTransformerDeployerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [77u8, 84u8, 205u8, 182u8];
-            const SIGNATURE: &'static str = "getTransformerDeployer()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getTransformerDeployerReturn = r.into();
-                        r.deployer
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getTransformerDeployerReturn = r.into();
-                    r.deployer
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isValidOrderSigner(address,address)` and selector `0x6b52a4a8`.
-    ```solidity
-    function isValidOrderSigner(address maker, address signer) external view returns (bool isAllowed);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidOrderSignerCall {
-        #[allow(missing_docs)]
-        pub maker: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub signer: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isValidOrderSigner(address,address)`](isValidOrderSignerCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidOrderSignerReturn {
-        #[allow(missing_docs)]
-        pub isAllowed: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidOrderSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidOrderSignerCall) -> Self {
-                    (value.maker, value.signer)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidOrderSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        maker: tuple.0,
-                        signer: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidOrderSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidOrderSignerReturn) -> Self {
-                    (value.isAllowed,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidOrderSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { isAllowed: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for isValidOrderSignerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [107u8, 82u8, 164u8, 168u8];
-            const SIGNATURE: &'static str = "isValidOrderSigner(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.maker,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.signer,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isValidOrderSignerReturn = r.into();
-                        r.isAllowed
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isValidOrderSignerReturn = r.into();
-                    r.isAllowed
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `lastOtcTxOriginNonce(address,uint64)` and selector `0x59ebfb45`.
-    ```solidity
-    function lastOtcTxOriginNonce(address txOrigin, uint64 nonceBucket) external view returns (uint128 lastNonce);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct lastOtcTxOriginNonceCall {
-        #[allow(missing_docs)]
-        pub txOrigin: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub nonceBucket: u64,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`lastOtcTxOriginNonce(address,uint64)`](lastOtcTxOriginNonceCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct lastOtcTxOriginNonceReturn {
-        #[allow(missing_docs)]
-        pub lastNonce: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<64>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, u64);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<lastOtcTxOriginNonceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: lastOtcTxOriginNonceCall) -> Self {
-                    (value.txOrigin, value.nonceBucket)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lastOtcTxOriginNonceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        txOrigin: tuple.0,
-                        nonceBucket: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<lastOtcTxOriginNonceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: lastOtcTxOriginNonceReturn) -> Self {
-                    (value.lastNonce,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lastOtcTxOriginNonceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { lastNonce: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for lastOtcTxOriginNonceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<64>,
-            );
-            type Return = u128;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [89u8, 235u8, 251u8, 69u8];
-            const SIGNATURE: &'static str = "lastOtcTxOriginNonce(address,uint64)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.txOrigin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonceBucket,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: lastOtcTxOriginNonceReturn = r.into();
-                        r.lastNonce
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: lastOtcTxOriginNonceReturn = r.into();
-                    r.lastNonce
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `matchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))` and selector `0x0d8261eb`.
-    ```solidity
-    function matchERC721Orders(LibNFTOrder.ERC721Order memory sellOrder, LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory sellOrderSignature, LibSignature.Signature memory buyOrderSignature) external returns (uint256 profit);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct matchERC721OrdersCall {
-        #[allow(missing_docs)]
-        pub sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub sellOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub buyOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`matchERC721Orders((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),
-    /// (uint8,address,address,uint256,uint256,address,uint256,(address,uint256,
-    /// bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,
-    /// bytes32),(uint8,uint8,bytes32,bytes32))`](matchERC721OrdersCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct matchERC721OrdersReturn {
-        #[allow(missing_docs)]
-        pub profit: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC721Order,
-                LibNFTOrder::ERC721Order,
-                LibSignature::Signature,
-                LibSignature::Signature,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<matchERC721OrdersCall> for UnderlyingRustTuple<'_> {
-                fn from(value: matchERC721OrdersCall) -> Self {
-                    (
-                        value.sellOrder,
-                        value.buyOrder,
-                        value.sellOrderSignature,
-                        value.buyOrderSignature,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for matchERC721OrdersCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sellOrder: tuple.0,
-                        buyOrder: tuple.1,
-                        sellOrderSignature: tuple.2,
-                        buyOrderSignature: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<matchERC721OrdersReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: matchERC721OrdersReturn) -> Self {
-                    (value.profit,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for matchERC721OrdersReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { profit: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for matchERC721OrdersCall {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC721Order,
-                LibNFTOrder::ERC721Order,
-                LibSignature::Signature,
-                LibSignature::Signature,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [13u8, 130u8, 97u8, 235u8];
-            const SIGNATURE: &'static str =
-                "matchERC721Orders((uint8,address,address,uint256,uint256,address,uint256,\
-                 (address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,address,\
-                 address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,\
-                 uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,\
-                 bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
-                        &self.sellOrder,
-                    ),
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
-                        &self.buyOrder,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.sellOrderSignature,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.buyOrderSignature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: matchERC721OrdersReturn = r.into();
-                        r.profit
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: matchERC721OrdersReturn = r.into();
-                    r.profit
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `migrate(address,bytes,address)` and selector `0x261fe679`.
-    ```solidity
-    function migrate(address target, bytes memory data, address newOwner) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct migrateCall {
-        #[allow(missing_docs)]
-        pub target: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub newOwner: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`migrate(address,bytes,address)`](migrateCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct migrateReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<migrateCall> for UnderlyingRustTuple<'_> {
-                fn from(value: migrateCall) -> Self {
-                    (value.target, value.data, value.newOwner)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for migrateCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        target: tuple.0,
-                        data: tuple.1,
-                        newOwner: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<migrateReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: migrateReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for migrateReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl migrateReturn {
-            fn _tokenize(&self) -> <migrateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for migrateCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = migrateReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [38u8, 31u8, 230u8, 121u8];
-            const SIGNATURE: &'static str = "migrate(address,bytes,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.target,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newOwner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                migrateReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)` and selector `0xf35b4733`.
-    ```solidity
-    function multiplexBatchSellEthForToken(address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexBatchSellEthForTokenCall {
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calls: alloy_sol_types::private::Vec<
-            <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],
-    /// uint256)`](multiplexBatchSellEthForTokenCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexBatchSellEthForTokenReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<
-                    <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexBatchSellEthForTokenCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexBatchSellEthForTokenCall) -> Self {
-                    (value.outputToken, value.calls, value.minBuyAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellEthForTokenCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        outputToken: tuple.0,
-                        calls: tuple.1,
-                        minBuyAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexBatchSellEthForTokenReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexBatchSellEthForTokenReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellEthForTokenReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for multiplexBatchSellEthForTokenCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 91u8, 71u8, 51u8];
-            const SIGNATURE: &'static str =
-                "multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        IMultiplexFeature::BatchSellSubcall,
-                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multiplexBatchSellEthForTokenReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: multiplexBatchSellEthForTokenReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)` and selector `0x77725df6`.
-    ```solidity
-    function multiplexBatchSellTokenForEth(address inputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexBatchSellTokenForEthCall {
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calls: alloy_sol_types::private::Vec<
-            <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,
-    /// uint256)`](multiplexBatchSellTokenForEthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexBatchSellTokenForEthReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<
-                    <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexBatchSellTokenForEthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexBatchSellTokenForEthCall) -> Self {
-                    (
-                        value.inputToken,
-                        value.calls,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForEthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        inputToken: tuple.0,
-                        calls: tuple.1,
-                        sellAmount: tuple.2,
-                        minBuyAmount: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexBatchSellTokenForEthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexBatchSellTokenForEthReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForEthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for multiplexBatchSellTokenForEthCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [119u8, 114u8, 93u8, 246u8];
-            const SIGNATURE: &'static str =
-                "multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        IMultiplexFeature::BatchSellSubcall,
-                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multiplexBatchSellTokenForEthReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: multiplexBatchSellTokenForEthReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `multiplexBatchSellTokenForToken(address,address,(uint8,uint256,bytes)[],uint256,uint256)` and selector `0x7a1eb1b9`.
-    ```solidity
-    function multiplexBatchSellTokenForToken(address inputToken, address outputToken, IMultiplexFeature.BatchSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexBatchSellTokenForTokenCall {
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub calls: alloy_sol_types::private::Vec<
-            <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multiplexBatchSellTokenForToken(address,address,(uint8,uint256,
-    /// bytes)[],uint256,uint256)`](multiplexBatchSellTokenForTokenCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexBatchSellTokenForTokenReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Vec<
-                    <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexBatchSellTokenForTokenCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexBatchSellTokenForTokenCall) -> Self {
-                    (
-                        value.inputToken,
-                        value.outputToken,
-                        value.calls,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForTokenCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        inputToken: tuple.0,
-                        outputToken: tuple.1,
-                        calls: tuple.2,
-                        sellAmount: tuple.3,
-                        minBuyAmount: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexBatchSellTokenForTokenReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexBatchSellTokenForTokenReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexBatchSellTokenForTokenReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for multiplexBatchSellTokenForTokenCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::BatchSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [122u8, 30u8, 177u8, 185u8];
-            const SIGNATURE: &'static str = "multiplexBatchSellTokenForToken(address,address,\
-                                             (uint8,uint256,bytes)[],uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        IMultiplexFeature::BatchSellSubcall,
-                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multiplexBatchSellTokenForTokenReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: multiplexBatchSellTokenForTokenReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)` and selector `0x5161b966`.
-    ```solidity
-    function multiplexMultiHopSellEthForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 minBuyAmount) external payable returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexMultiHopSellEthForTokenCall {
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub calls: alloy_sol_types::private::Vec<
-            <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],
-    /// uint256)`](multiplexMultiHopSellEthForTokenCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexMultiHopSellEthForTokenReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<
-                    <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexMultiHopSellEthForTokenCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexMultiHopSellEthForTokenCall) -> Self {
-                    (value.tokens, value.calls, value.minBuyAmount)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellEthForTokenCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        calls: tuple.1,
-                        minBuyAmount: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexMultiHopSellEthForTokenReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexMultiHopSellEthForTokenReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellEthForTokenReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for multiplexMultiHopSellEthForTokenCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [81u8, 97u8, 185u8, 102u8];
-            const SIGNATURE: &'static str =
-                "multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        IMultiplexFeature::MultiHopSellSubcall,
-                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multiplexMultiHopSellEthForTokenReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: multiplexMultiHopSellEthForTokenReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)` and selector `0x9a2967d2`.
-    ```solidity
-    function multiplexMultiHopSellTokenForEth(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexMultiHopSellTokenForEthCall {
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub calls: alloy_sol_types::private::Vec<
-            <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,
-    /// uint256)`](multiplexMultiHopSellTokenForEthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexMultiHopSellTokenForEthReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<
-                    <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexMultiHopSellTokenForEthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexMultiHopSellTokenForEthCall) -> Self {
-                    (
-                        value.tokens,
-                        value.calls,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForEthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        calls: tuple.1,
-                        sellAmount: tuple.2,
-                        minBuyAmount: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexMultiHopSellTokenForEthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexMultiHopSellTokenForEthReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForEthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for multiplexMultiHopSellTokenForEthCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [154u8, 41u8, 103u8, 210u8];
-            const SIGNATURE: &'static str =
-                "multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        IMultiplexFeature::MultiHopSellSubcall,
-                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multiplexMultiHopSellTokenForEthReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: multiplexMultiHopSellTokenForEthReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)` and selector `0x0f3b31b2`.
-    ```solidity
-    function multiplexMultiHopSellTokenForToken(address[] memory tokens, IMultiplexFeature.MultiHopSellSubcall[] memory calls, uint256 sellAmount, uint256 minBuyAmount) external returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexMultiHopSellTokenForTokenCall {
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub calls: alloy_sol_types::private::Vec<
-            <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,
-    /// uint256)`](multiplexMultiHopSellTokenForTokenCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct multiplexMultiHopSellTokenForTokenReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Vec<
-                    <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-                >,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexMultiHopSellTokenForTokenCall> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexMultiHopSellTokenForTokenCall) -> Self {
-                    (
-                        value.tokens,
-                        value.calls,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForTokenCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        calls: tuple.1,
-                        sellAmount: tuple.2,
-                        minBuyAmount: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<multiplexMultiHopSellTokenForTokenReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: multiplexMultiHopSellTokenForTokenReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for multiplexMultiHopSellTokenForTokenReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for multiplexMultiHopSellTokenForTokenCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Array<IMultiplexFeature::MultiHopSellSubcall>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [15u8, 59u8, 49u8, 178u8];
-            const SIGNATURE: &'static str =
-                "multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Array<
-                        IMultiplexFeature::MultiHopSellSubcall,
-                    > as alloy_sol_types::SolType>::tokenize(&self.calls),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: multiplexMultiHopSellTokenForTokenReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: multiplexMultiHopSellTokenForTokenReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onERC1155Received(address,address,uint256,uint256,bytes)` and selector `0xf23a6e61`.
-    ```solidity
-    function onERC1155Received(address operator, address from, uint256 tokenId, uint256 value, bytes memory data) external returns (bytes4 success);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC1155ReceivedCall {
-        #[allow(missing_docs)]
-        pub operator: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onERC1155Received(address,address,uint256,uint256,
-    /// bytes)`](onERC1155ReceivedCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC1155ReceivedReturn {
-        #[allow(missing_docs)]
-        pub success: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC1155ReceivedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC1155ReceivedCall) -> Self {
-                    (
-                        value.operator,
-                        value.from,
-                        value.tokenId,
-                        value.value,
-                        value.data,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        operator: tuple.0,
-                        from: tuple.1,
-                        tokenId: tuple.2,
-                        value: tuple.3,
-                        data: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC1155ReceivedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC1155ReceivedReturn) -> Self {
-                    (value.success,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC1155ReceivedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { success: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
-            const SIGNATURE: &'static str =
-                "onERC1155Received(address,address,uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.operator,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.from,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenId,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.value,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: onERC1155ReceivedReturn = r.into();
-                        r.success
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: onERC1155ReceivedReturn = r.into();
-                    r.success
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `onERC721Received(address,address,uint256,bytes)` and selector `0x150b7a02`.
-    ```solidity
-    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) external returns (bytes4 success);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC721ReceivedCall {
-        #[allow(missing_docs)]
-        pub operator: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub from: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`onERC721Received(address,address,uint256,
-    /// bytes)`](onERC721ReceivedCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct onERC721ReceivedReturn {
-        #[allow(missing_docs)]
-        pub success: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC721ReceivedCall> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC721ReceivedCall) -> Self {
-                    (value.operator, value.from, value.tokenId, value.data)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        operator: tuple.0,
-                        from: tuple.1,
-                        tokenId: tuple.2,
-                        data: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<onERC721ReceivedReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: onERC721ReceivedReturn) -> Self {
-                    (value.success,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for onERC721ReceivedReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { success: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for onERC721ReceivedCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
-            const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.operator,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.from,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenId,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: onERC721ReceivedReturn = r.into();
-                        r.success
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: onERC721ReceivedReturn = r.into();
-                    r.success
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `owner()` and selector `0x8da5cb5b`.
-    ```solidity
-    function owner() external view returns (address ownerAddress);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ownerCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`owner()`](ownerCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ownerReturn {
-        #[allow(missing_docs)]
-        pub ownerAddress: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: ownerReturn) -> Self {
-                    (value.ownerAddress,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        ownerAddress: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for ownerCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
-            const SIGNATURE: &'static str = "owner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: ownerReturn = r.into();
-                        r.ownerAddress
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: ownerReturn = r.into();
-                    r.ownerAddress
-                })
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `preSignERC1155Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128))` and selector `0x7b757d97`.
-    ```solidity
-    function preSignERC1155Order(LibNFTOrder.ERC1155Order memory order) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct preSignERC1155OrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`preSignERC1155Order((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],
-    /// uint128))`](preSignERC1155OrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct preSignERC1155OrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<preSignERC1155OrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: preSignERC1155OrderCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC1155OrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<preSignERC1155OrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: preSignERC1155OrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC1155OrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl preSignERC1155OrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <preSignERC1155OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for preSignERC1155OrderCall {
-            type Parameters<'a> = (LibNFTOrder::ERC1155Order,);
-            type Return = preSignERC1155OrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [123u8, 117u8, 125u8, 151u8];
-            const SIGNATURE: &'static str = "preSignERC1155Order((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[],uint128))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                preSignERC1155OrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `preSignERC721Order((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]))` and selector `0x462103af`.
-    ```solidity
-    function preSignERC721Order(LibNFTOrder.ERC721Order memory order) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct preSignERC721OrderCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`preSignERC721Order((uint8,address,address,uint256,uint256,address,
-    /// uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[]))`](preSignERC721OrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct preSignERC721OrderReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<preSignERC721OrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: preSignERC721OrderCall) -> Self {
-                    (value.order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC721OrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<preSignERC721OrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: preSignERC721OrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for preSignERC721OrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl preSignERC721OrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <preSignERC721OrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for preSignERC721OrderCall {
-            type Parameters<'a> = (LibNFTOrder::ERC721Order,);
-            type Return = preSignERC721OrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [70u8, 33u8, 3u8, 175u8];
-            const SIGNATURE: &'static str = "preSignERC721Order((uint8,address,address,uint256,\
-                                             uint256,address,uint256,(address,uint256,bytes)[],\
-                                             address,uint256,(address,bytes)[]))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                preSignERC721OrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `registerAllowedOrderSigner(address,bool)` and selector `0xea7faa61`.
-    ```solidity
-    function registerAllowedOrderSigner(address signer, bool allowed) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct registerAllowedOrderSignerCall {
-        #[allow(missing_docs)]
-        pub signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub allowed: bool,
-    }
-    ///Container type for the return parameters of the
-    /// [`registerAllowedOrderSigner(address,
-    /// bool)`](registerAllowedOrderSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct registerAllowedOrderSignerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, bool);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<registerAllowedOrderSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: registerAllowedOrderSignerCall) -> Self {
-                    (value.signer, value.allowed)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedOrderSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        signer: tuple.0,
-                        allowed: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<registerAllowedOrderSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: registerAllowedOrderSignerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedOrderSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl registerAllowedOrderSignerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for registerAllowedOrderSignerCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = registerAllowedOrderSignerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [234u8, 127u8, 170u8, 97u8];
-            const SIGNATURE: &'static str = "registerAllowedOrderSigner(address,bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.signer,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.allowed,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                registerAllowedOrderSignerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `registerAllowedRfqOrigins(address[],bool)` and selector `0xb09f1fb1`.
-    ```solidity
-    function registerAllowedRfqOrigins(address[] memory origins, bool allowed) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct registerAllowedRfqOriginsCall {
-        #[allow(missing_docs)]
-        pub origins: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub allowed: bool,
-    }
-    ///Container type for the return parameters of the
-    /// [`registerAllowedRfqOrigins(address[],
-    /// bool)`](registerAllowedRfqOriginsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct registerAllowedRfqOriginsReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<registerAllowedRfqOriginsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: registerAllowedRfqOriginsCall) -> Self {
-                    (value.origins, value.allowed)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedRfqOriginsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        origins: tuple.0,
-                        allowed: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<registerAllowedRfqOriginsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: registerAllowedRfqOriginsReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerAllowedRfqOriginsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl registerAllowedRfqOriginsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for registerAllowedRfqOriginsCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = registerAllowedRfqOriginsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [176u8, 159u8, 31u8, 177u8];
-            const SIGNATURE: &'static str = "registerAllowedRfqOrigins(address[],bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.origins),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.allowed,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                registerAllowedRfqOriginsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `rollback(bytes4,address)` and selector `0x9db64a40`.
-    ```solidity
-    function rollback(bytes4 selector, address targetImpl) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct rollbackCall {
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-        #[allow(missing_docs)]
-        pub targetImpl: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`rollback(bytes4,address)`](rollbackCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct rollbackReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<4>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<4>,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<rollbackCall> for UnderlyingRustTuple<'_> {
-                fn from(value: rollbackCall) -> Self {
-                    (value.selector, value.targetImpl)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rollbackCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        selector: tuple.0,
-                        targetImpl: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<rollbackReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: rollbackReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rollbackReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl rollbackReturn {
-            fn _tokenize(&self) -> <rollbackCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for rollbackCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<4>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = rollbackReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [157u8, 182u8, 74u8, 64u8];
-            const SIGNATURE: &'static str = "rollback(bytes4,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.targetImpl,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                rollbackReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `sellERC1155((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32),uint256,uint128,bool,bytes)` and selector `0x6e2eec9e`.
-    ```solidity
-    function sellERC1155(LibNFTOrder.ERC1155Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc1155TokenId, uint128 erc1155SellAmount, bool unwrapNativeToken, bytes memory callbackData) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellERC1155Call {
-        #[allow(missing_docs)]
-        pub buyOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub erc1155SellAmount: u128,
-        #[allow(missing_docs)]
-        pub unwrapNativeToken: bool,
-        #[allow(missing_docs)]
-        pub callbackData: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`sellERC1155((uint8,address,address,uint256,uint256,address,uint256,
-    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),
-    /// (uint8,uint8,bytes32,bytes32),uint256,uint128,bool,
-    /// bytes)`](sellERC1155Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellERC1155Return {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC1155Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u128,
-                bool,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellERC1155Call> for UnderlyingRustTuple<'_> {
-                fn from(value: sellERC1155Call) -> Self {
-                    (
-                        value.buyOrder,
-                        value.signature,
-                        value.erc1155TokenId,
-                        value.erc1155SellAmount,
-                        value.unwrapNativeToken,
-                        value.callbackData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC1155Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        buyOrder: tuple.0,
-                        signature: tuple.1,
-                        erc1155TokenId: tuple.2,
-                        erc1155SellAmount: tuple.3,
-                        unwrapNativeToken: tuple.4,
-                        callbackData: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellERC1155Return> for UnderlyingRustTuple<'_> {
-                fn from(value: sellERC1155Return) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC1155Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl sellERC1155Return {
-            fn _tokenize(&self) -> <sellERC1155Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellERC1155Call {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC1155Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = sellERC1155Return;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [110u8, 46u8, 236u8, 158u8];
-            const SIGNATURE: &'static str = "sellERC1155((uint8,address,address,uint256,uint256,\
-                                             address,uint256,(address,uint256,bytes)[],address,\
-                                             uint256,(address,bytes)[],uint128),(uint8,uint8,\
-                                             bytes32,bytes32),uint256,uint128,bool,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(
-                        &self.buyOrder,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155TokenId,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155SellAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.unwrapNativeToken,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.callbackData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                sellERC1155Return::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `sellERC721((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32),uint256,bool,bytes)` and selector `0xafde1b3c`.
-    ```solidity
-    function sellERC721(LibNFTOrder.ERC721Order memory buyOrder, LibSignature.Signature memory signature, uint256 erc721TokenId, bool unwrapNativeToken, bytes memory callbackData) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellERC721Call {
-        #[allow(missing_docs)]
-        pub buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub unwrapNativeToken: bool,
-        #[allow(missing_docs)]
-        pub callbackData: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`sellERC721((uint8,address,address,uint256,uint256,address,uint256,
-    /// (address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,
-    /// uint8,bytes32,bytes32),uint256,bool,bytes)`](sellERC721Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellERC721Return {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC721Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellERC721Call> for UnderlyingRustTuple<'_> {
-                fn from(value: sellERC721Call) -> Self {
-                    (
-                        value.buyOrder,
-                        value.signature,
-                        value.erc721TokenId,
-                        value.unwrapNativeToken,
-                        value.callbackData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC721Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        buyOrder: tuple.0,
-                        signature: tuple.1,
-                        erc721TokenId: tuple.2,
-                        unwrapNativeToken: tuple.3,
-                        callbackData: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellERC721Return> for UnderlyingRustTuple<'_> {
-                fn from(value: sellERC721Return) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellERC721Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl sellERC721Return {
-            fn _tokenize(&self) -> <sellERC721Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellERC721Call {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC721Order,
-                LibSignature::Signature,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = sellERC721Return;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 222u8, 27u8, 60u8];
-            const SIGNATURE: &'static str = "sellERC721((uint8,address,address,uint256,uint256,\
-                                             address,uint256,(address,uint256,bytes)[],address,\
-                                             uint256,(address,bytes)[]),(uint8,uint8,bytes32,\
-                                             bytes32),uint256,bool,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(
-                        &self.buyOrder,
-                    ),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc721TokenId,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.unwrapNativeToken,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.callbackData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                sellERC721Return::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `sellEthForTokenToUniswapV3(bytes,uint256,address)` and selector `0x3598d8ab`.
-    ```solidity
-    function sellEthForTokenToUniswapV3(bytes memory encodedPath, uint256 minBuyAmount, address recipient) external payable returns (uint256 buyAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellEthForTokenToUniswapV3Call {
-        #[allow(missing_docs)]
-        pub encodedPath: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`sellEthForTokenToUniswapV3(bytes,uint256,
-    /// address)`](sellEthForTokenToUniswapV3Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellEthForTokenToUniswapV3Return {
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellEthForTokenToUniswapV3Call> for UnderlyingRustTuple<'_> {
-                fn from(value: sellEthForTokenToUniswapV3Call) -> Self {
-                    (value.encodedPath, value.minBuyAmount, value.recipient)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellEthForTokenToUniswapV3Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        encodedPath: tuple.0,
-                        minBuyAmount: tuple.1,
-                        recipient: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellEthForTokenToUniswapV3Return> for UnderlyingRustTuple<'_> {
-                fn from(value: sellEthForTokenToUniswapV3Return) -> Self {
-                    (value.buyAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellEthForTokenToUniswapV3Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { buyAmount: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellEthForTokenToUniswapV3Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [53u8, 152u8, 216u8, 171u8];
-            const SIGNATURE: &'static str = "sellEthForTokenToUniswapV3(bytes,uint256,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.encodedPath,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minBuyAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: sellEthForTokenToUniswapV3Return = r.into();
-                        r.buyAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: sellEthForTokenToUniswapV3Return = r.into();
-                    r.buyAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)` and selector `0xf7fcd384`.
-    ```solidity
-    function sellToLiquidityProvider(address inputToken, address outputToken, address provider, address recipient, uint256 sellAmount, uint256 minBuyAmount, bytes memory auxiliaryData) external payable returns (uint256 boughtAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellToLiquidityProviderCall {
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub provider: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub auxiliaryData: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`sellToLiquidityProvider(address,address,address,address,uint256,
-    /// uint256,bytes)`](sellToLiquidityProviderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellToLiquidityProviderReturn {
-        #[allow(missing_docs)]
-        pub boughtAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellToLiquidityProviderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: sellToLiquidityProviderCall) -> Self {
-                    (
-                        value.inputToken,
-                        value.outputToken,
-                        value.provider,
-                        value.recipient,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                        value.auxiliaryData,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToLiquidityProviderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        inputToken: tuple.0,
-                        outputToken: tuple.1,
-                        provider: tuple.2,
-                        recipient: tuple.3,
-                        sellAmount: tuple.4,
-                        minBuyAmount: tuple.5,
-                        auxiliaryData: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellToLiquidityProviderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: sellToLiquidityProviderReturn) -> Self {
-                    (value.boughtAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToLiquidityProviderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        boughtAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellToLiquidityProviderCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [247u8, 252u8, 211u8, 132u8];
-            const SIGNATURE: &'static str =
-                "sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.provider,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.sellAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minBuyAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.auxiliaryData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: sellToLiquidityProviderReturn = r.into();
-                        r.boughtAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: sellToLiquidityProviderReturn = r.into();
-                    r.boughtAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `sellToPancakeSwap(address[],uint256,uint256,uint8)` and selector `0xc43c9ef6`.
-    ```solidity
-    function sellToPancakeSwap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, IPancakeSwapFeature.ProtocolFork fork) external payable returns (uint256 buyAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellToPancakeSwapCall {
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub fork: <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`sellToPancakeSwap(address[],uint256,uint256,
-    /// uint8)`](sellToPancakeSwapCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellToPancakeSwapReturn {
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                IPancakeSwapFeature::ProtocolFork,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellToPancakeSwapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: sellToPancakeSwapCall) -> Self {
-                    (
-                        value.tokens,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                        value.fork,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToPancakeSwapCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        sellAmount: tuple.1,
-                        minBuyAmount: tuple.2,
-                        fork: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellToPancakeSwapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: sellToPancakeSwapReturn) -> Self {
-                    (value.buyAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToPancakeSwapReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { buyAmount: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellToPancakeSwapCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                IPancakeSwapFeature::ProtocolFork,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 60u8, 158u8, 246u8];
-            const SIGNATURE: &'static str = "sellToPancakeSwap(address[],uint256,uint256,uint8)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                    <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::tokenize(
-                        &self.fork,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: sellToPancakeSwapReturn = r.into();
-                        r.buyAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: sellToPancakeSwapReturn = r.into();
-                    r.buyAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `sellToUniswap(address[],uint256,uint256,bool)` and selector `0xd9627aa4`.
-    ```solidity
-    function sellToUniswap(address[] memory tokens, uint256 sellAmount, uint256 minBuyAmount, bool isSushi) external payable returns (uint256 buyAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellToUniswapCall {
-        #[allow(missing_docs)]
-        pub tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub isSushi: bool,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`sellToUniswap(address[],uint256,uint256,bool)`](sellToUniswapCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellToUniswapReturn {
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellToUniswapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: sellToUniswapCall) -> Self {
-                    (
-                        value.tokens,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                        value.isSushi,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToUniswapCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokens: tuple.0,
-                        sellAmount: tuple.1,
-                        minBuyAmount: tuple.2,
-                        isSushi: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellToUniswapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: sellToUniswapReturn) -> Self {
-                    (value.buyAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellToUniswapReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { buyAmount: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellToUniswapCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [217u8, 98u8, 122u8, 164u8];
-            const SIGNATURE: &'static str = "sellToUniswap(address[],uint256,uint256,bool)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tokens),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.sellAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minBuyAmount),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.isSushi,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: sellToUniswapReturn = r.into();
-                        r.buyAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: sellToUniswapReturn = r.into();
-                    r.buyAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)` and selector `0x803ba26d`.
-    ```solidity
-    function sellTokenForEthToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellTokenForEthToUniswapV3Call {
-        #[allow(missing_docs)]
-        pub encodedPath: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`sellTokenForEthToUniswapV3(bytes,uint256,uint256,
-    /// address)`](sellTokenForEthToUniswapV3Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellTokenForEthToUniswapV3Return {
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellTokenForEthToUniswapV3Call> for UnderlyingRustTuple<'_> {
-                fn from(value: sellTokenForEthToUniswapV3Call) -> Self {
-                    (
-                        value.encodedPath,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                        value.recipient,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForEthToUniswapV3Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        encodedPath: tuple.0,
-                        sellAmount: tuple.1,
-                        minBuyAmount: tuple.2,
-                        recipient: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellTokenForEthToUniswapV3Return> for UnderlyingRustTuple<'_> {
-                fn from(value: sellTokenForEthToUniswapV3Return) -> Self {
-                    (value.buyAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForEthToUniswapV3Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { buyAmount: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellTokenForEthToUniswapV3Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [128u8, 59u8, 162u8, 109u8];
-            const SIGNATURE: &'static str =
-                "sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.encodedPath,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.sellAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minBuyAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: sellTokenForEthToUniswapV3Return = r.into();
-                        r.buyAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: sellTokenForEthToUniswapV3Return = r.into();
-                    r.buyAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)` and selector `0x6af479b2`.
-    ```solidity
-    function sellTokenForTokenToUniswapV3(bytes memory encodedPath, uint256 sellAmount, uint256 minBuyAmount, address recipient) external returns (uint256 buyAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellTokenForTokenToUniswapV3Call {
-        #[allow(missing_docs)]
-        pub encodedPath: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`sellTokenForTokenToUniswapV3(bytes,uint256,uint256,
-    /// address)`](sellTokenForTokenToUniswapV3Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct sellTokenForTokenToUniswapV3Return {
-        #[allow(missing_docs)]
-        pub buyAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Bytes,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellTokenForTokenToUniswapV3Call> for UnderlyingRustTuple<'_> {
-                fn from(value: sellTokenForTokenToUniswapV3Call) -> Self {
-                    (
-                        value.encodedPath,
-                        value.sellAmount,
-                        value.minBuyAmount,
-                        value.recipient,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForTokenToUniswapV3Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        encodedPath: tuple.0,
-                        sellAmount: tuple.1,
-                        minBuyAmount: tuple.2,
-                        recipient: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<sellTokenForTokenToUniswapV3Return> for UnderlyingRustTuple<'_> {
-                fn from(value: sellTokenForTokenToUniswapV3Return) -> Self {
-                    (value.buyAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for sellTokenForTokenToUniswapV3Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { buyAmount: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for sellTokenForTokenToUniswapV3Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Bytes,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [106u8, 244u8, 121u8, 178u8];
-            const SIGNATURE: &'static str =
-                "sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.encodedPath,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.sellAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.minBuyAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: sellTokenForTokenToUniswapV3Return = r.into();
-                        r.buyAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: sellTokenForTokenToUniswapV3Return = r.into();
-                    r.buyAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setQuoteSigner(address)` and selector `0x56ce180a`.
-    ```solidity
-    function setQuoteSigner(address quoteSigner) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setQuoteSignerCall {
-        #[allow(missing_docs)]
-        pub quoteSigner: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`setQuoteSigner(address)`](setQuoteSignerCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setQuoteSignerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setQuoteSignerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setQuoteSignerCall) -> Self {
-                    (value.quoteSigner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setQuoteSignerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        quoteSigner: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setQuoteSignerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setQuoteSignerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setQuoteSignerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setQuoteSignerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setQuoteSignerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setQuoteSignerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setQuoteSignerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [86u8, 206u8, 24u8, 10u8];
-            const SIGNATURE: &'static str = "setQuoteSigner(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.quoteSigner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setQuoteSignerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setTransformerDeployer(address)` and selector `0x87c96419`.
-    ```solidity
-    function setTransformerDeployer(address transformerDeployer) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setTransformerDeployerCall {
-        #[allow(missing_docs)]
-        pub transformerDeployer: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`setTransformerDeployer(address)`](setTransformerDeployerCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setTransformerDeployerReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setTransformerDeployerCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setTransformerDeployerCall) -> Self {
-                    (value.transformerDeployer,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTransformerDeployerCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        transformerDeployer: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setTransformerDeployerReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setTransformerDeployerReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTransformerDeployerReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setTransformerDeployerReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setTransformerDeployerCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for setTransformerDeployerCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setTransformerDeployerReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [135u8, 201u8, 100u8, 25u8];
-            const SIGNATURE: &'static str = "setTransformerDeployer(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.transformerDeployer,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setTransformerDeployerReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `supportInterface(bytes4)` and selector `0x75e79be6`.
-    ```solidity
-    function supportInterface(bytes4 interfaceId) external pure returns (bool isSupported);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct supportInterfaceCall {
-        #[allow(missing_docs)]
-        pub interfaceId: alloy_sol_types::private::FixedBytes<4>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`supportInterface(bytes4)`](supportInterfaceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct supportInterfaceReturn {
-        #[allow(missing_docs)]
-        pub isSupported: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<supportInterfaceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: supportInterfaceCall) -> Self {
-                    (value.interfaceId,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportInterfaceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        interfaceId: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (bool,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<supportInterfaceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: supportInterfaceReturn) -> Self {
-                    (value.isSupported,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for supportInterfaceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        isSupported: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for supportInterfaceCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Return = bool;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [117u8, 231u8, 155u8, 230u8];
-            const SIGNATURE: &'static str = "supportInterface(bytes4)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: supportInterfaceReturn = r.into();
-                        r.isSupported
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: supportInterfaceReturn = r.into();
-                    r.isSupported
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
-    ```solidity
-    function transferOwnership(address newOwner) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferOwnershipCall {
-        #[allow(missing_docs)]
-        pub newOwner: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`transferOwnership(address)`](transferOwnershipCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferOwnershipReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferOwnershipCall) -> Self {
-                    (value.newOwner,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { newOwner: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferOwnershipReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl transferOwnershipReturn {
-            fn _tokenize(
-                &self,
-            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferOwnershipCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = transferOwnershipReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
-            const SIGNATURE: &'static str = "transferOwnership(address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.newOwner,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                transferOwnershipReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transferProtocolFeesForPools(bytes32[])` and selector `0x3cd2f026`.
-    ```solidity
-    function transferProtocolFeesForPools(bytes32[] memory poolIds) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferProtocolFeesForPoolsCall {
-        #[allow(missing_docs)]
-        pub poolIds: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-    }
-    ///Container type for the return parameters of the
-    /// [`transferProtocolFeesForPools(bytes32[])`](transferProtocolFeesForPoolsCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferProtocolFeesForPoolsReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferProtocolFeesForPoolsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferProtocolFeesForPoolsCall) -> Self {
-                    (value.poolIds,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferProtocolFeesForPoolsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { poolIds: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferProtocolFeesForPoolsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferProtocolFeesForPoolsReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferProtocolFeesForPoolsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl transferProtocolFeesForPoolsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferProtocolFeesForPoolsCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::FixedBytes<32>>,);
-            type Return = transferProtocolFeesForPoolsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [60u8, 210u8, 240u8, 38u8];
-            const SIGNATURE: &'static str = "transferProtocolFeesForPools(bytes32[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::FixedBytes<32>,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.poolIds
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                transferProtocolFeesForPoolsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transferTrappedTokensTo(address,uint256,address)` and selector `0x0d375884`.
-    ```solidity
-    function transferTrappedTokensTo(address erc20, uint256 amountOut, address recipientWallet) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferTrappedTokensToCall {
-        #[allow(missing_docs)]
-        pub erc20: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub recipientWallet: alloy_sol_types::private::Address,
-    }
-    ///Container type for the return parameters of the
-    /// [`transferTrappedTokensTo(address,uint256,
-    /// address)`](transferTrappedTokensToCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transferTrappedTokensToReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferTrappedTokensToCall> for UnderlyingRustTuple<'_> {
-                fn from(value: transferTrappedTokensToCall) -> Self {
-                    (value.erc20, value.amountOut, value.recipientWallet)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferTrappedTokensToCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        erc20: tuple.0,
-                        amountOut: tuple.1,
-                        recipientWallet: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transferTrappedTokensToReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: transferTrappedTokensToReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferTrappedTokensToReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl transferTrappedTokensToReturn {
-            fn _tokenize(
-                &self,
-            ) -> <transferTrappedTokensToCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transferTrappedTokensToCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = transferTrappedTokensToReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [13u8, 55u8, 88u8, 132u8];
-            const SIGNATURE: &'static str = "transferTrappedTokensTo(address,uint256,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.erc20,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipientWallet,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                transferTrappedTokensToReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `transformERC20(address,address,uint256,uint256,(uint32,bytes)[])` and selector `0x415565b0`.
-    ```solidity
-    function transformERC20(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 minOutputTokenAmount, ITransformERC20Feature.Transformation[] memory transformations) external payable returns (uint256 outputTokenAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transformERC20Call {
-        #[allow(missing_docs)]
-        pub inputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub outputToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub minOutputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub transformations: alloy_sol_types::private::Vec<
-            <ITransformERC20Feature::Transformation as alloy_sol_types::SolType>::RustType,
-        >,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`transformERC20(address,address,uint256,uint256,(uint32,
-    /// bytes)[])`](transformERC20Call) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct transformERC20Return {
-        #[allow(missing_docs)]
-        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<ITransformERC20Feature::Transformation>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<
-                    <ITransformERC20Feature::Transformation as alloy_sol_types::SolType>::RustType,
-                >,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transformERC20Call> for UnderlyingRustTuple<'_> {
-                fn from(value: transformERC20Call) -> Self {
-                    (
-                        value.inputToken,
-                        value.outputToken,
-                        value.inputTokenAmount,
-                        value.minOutputTokenAmount,
-                        value.transformations,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transformERC20Call {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        inputToken: tuple.0,
-                        outputToken: tuple.1,
-                        inputTokenAmount: tuple.2,
-                        minOutputTokenAmount: tuple.3,
-                        transformations: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<transformERC20Return> for UnderlyingRustTuple<'_> {
-                fn from(value: transformERC20Return) -> Self {
-                    (value.outputTokenAmount,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transformERC20Return {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        outputTokenAmount: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for transformERC20Call {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<ITransformERC20Feature::Transformation>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [65u8, 85u8, 101u8, 176u8];
-            const SIGNATURE: &'static str =
-                "transformERC20(address,address,uint256,uint256,(uint32,bytes)[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.inputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.outputToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.inputTokenAmount),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.minOutputTokenAmount),
-                    <alloy_sol_types::sol_data::Array<
-                        ITransformERC20Feature::Transformation,
-                    > as alloy_sol_types::SolType>::tokenize(&self.transformations),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: transformERC20Return = r.into();
-                        r.outputTokenAmount
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: transformERC20Return = r.into();
-                    r.outputTokenAmount
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `uniswapV3SwapCallback(int256,int256,bytes)` and selector `0xfa461e33`.
-    ```solidity
-    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct uniswapV3SwapCallbackCall {
-        #[allow(missing_docs)]
-        pub amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
-        #[allow(missing_docs)]
-        pub amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`uniswapV3SwapCallback(int256,int256,
-    /// bytes)`](uniswapV3SwapCallbackCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct uniswapV3SwapCallbackReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::I256,
-                alloy_sol_types::private::primitives::aliases::I256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<uniswapV3SwapCallbackCall> for UnderlyingRustTuple<'_> {
-                fn from(value: uniswapV3SwapCallbackCall) -> Self {
-                    (value.amount0Delta, value.amount1Delta, value.data)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount0Delta: tuple.0,
-                        amount1Delta: tuple.1,
-                        data: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<uniswapV3SwapCallbackReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: uniswapV3SwapCallbackReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl uniswapV3SwapCallbackReturn {
-            fn _tokenize(
-                &self,
-            ) -> <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for uniswapV3SwapCallbackCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = uniswapV3SwapCallbackReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [250u8, 70u8, 30u8, 51u8];
-            const SIGNATURE: &'static str = "uniswapV3SwapCallback(int256,int256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0Delta,
-                    ),
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1Delta,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                uniswapV3SwapCallbackReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `validateERC1155OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),uint256)` and selector `0x2ac6f62a`.
-    ```solidity
-    function validateERC1155OrderProperties(LibNFTOrder.ERC1155Order memory order, uint256 erc1155TokenId) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC1155OrderPropertiesCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`validateERC1155OrderProperties((uint8,address,address,uint256,uint256,
-    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[],uint128),uint256)`](validateERC1155OrderPropertiesCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC1155OrderPropertiesReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC1155Order,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC1155OrderPropertiesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC1155OrderPropertiesCall) -> Self {
-                    (value.order, value.erc1155TokenId)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderPropertiesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        erc1155TokenId: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC1155OrderPropertiesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC1155OrderPropertiesReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderPropertiesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl validateERC1155OrderPropertiesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateERC1155OrderPropertiesCall {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC1155Order,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = validateERC1155OrderPropertiesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [42u8, 198u8, 246u8, 42u8];
-            const SIGNATURE: &'static str = "validateERC1155OrderProperties((uint8,address,\
-                                             address,uint256,uint256,address,uint256,(address,\
-                                             uint256,bytes)[],address,uint256,(address,bytes)[],\
-                                             uint128),uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc1155TokenId,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateERC1155OrderPropertiesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `validateERC1155OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128),(uint8,uint8,bytes32,bytes32))` and selector `0x0d32a531`.
-    ```solidity
-    function validateERC1155OrderSignature(LibNFTOrder.ERC1155Order memory order, LibSignature.Signature memory signature) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC1155OrderSignatureCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`validateERC1155OrderSignature((uint8,address,address,uint256,uint256,
-    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[],uint128),(uint8,uint8,bytes32,
-    /// bytes32))`](validateERC1155OrderSignatureCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC1155OrderSignatureReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC1155Order, LibSignature::Signature);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC1155OrderSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC1155OrderSignatureCall) -> Self {
-                    (value.order, value.signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderSignatureCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC1155OrderSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC1155OrderSignatureReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC1155OrderSignatureReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl validateERC1155OrderSignatureReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateERC1155OrderSignatureCall {
-            type Parameters<'a> = (LibNFTOrder::ERC1155Order, LibSignature::Signature);
-            type Return = validateERC1155OrderSignatureReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [13u8, 50u8, 165u8, 49u8];
-            const SIGNATURE: &'static str = "validateERC1155OrderSignature((uint8,address,address,\
-                                             uint256,uint256,address,uint256,(address,uint256,\
-                                             bytes)[],address,uint256,(address,bytes)[],uint128),\
-                                             (uint8,uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateERC1155OrderSignatureReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `validateERC721OrderProperties((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),uint256)` and selector `0x4a13d797`.
-    ```solidity
-    function validateERC721OrderProperties(LibNFTOrder.ERC721Order memory order, uint256 erc721TokenId) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC721OrderPropertiesCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`validateERC721OrderProperties((uint8,address,address,uint256,uint256,
-    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[]),uint256)`](validateERC721OrderPropertiesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC721OrderPropertiesReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                LibNFTOrder::ERC721Order,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC721OrderPropertiesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC721OrderPropertiesCall) -> Self {
-                    (value.order, value.erc721TokenId)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderPropertiesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        erc721TokenId: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC721OrderPropertiesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC721OrderPropertiesReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderPropertiesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl validateERC721OrderPropertiesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateERC721OrderPropertiesCall {
-            type Parameters<'a> = (
-                LibNFTOrder::ERC721Order,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = validateERC721OrderPropertiesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [74u8, 19u8, 215u8, 151u8];
-            const SIGNATURE: &'static str = "validateERC721OrderProperties((uint8,address,address,\
-                                             uint256,uint256,address,uint256,(address,uint256,\
-                                             bytes)[],address,uint256,(address,bytes)[]),uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.erc721TokenId,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateERC721OrderPropertiesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive()]
-    /**Function with signature `validateERC721OrderSignature((uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[]),(uint8,uint8,bytes32,bytes32))` and selector `0xd1ca183b`.
-    ```solidity
-    function validateERC721OrderSignature(LibNFTOrder.ERC721Order memory order, LibSignature.Signature memory signature) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC721OrderSignatureCall {
-        #[allow(missing_docs)]
-        pub order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`validateERC721OrderSignature((uint8,address,address,uint256,uint256,
-    /// address,uint256,(address,uint256,bytes)[],address,uint256,(address,
-    /// bytes)[]),(uint8,uint8,bytes32,
-    /// bytes32))`](validateERC721OrderSignatureCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct validateERC721OrderSignatureReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (LibNFTOrder::ERC721Order, LibSignature::Signature);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC721OrderSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC721OrderSignatureCall) -> Self {
-                    (value.order, value.signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderSignatureCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        order: tuple.0,
-                        signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<validateERC721OrderSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateERC721OrderSignatureReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateERC721OrderSignatureReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl validateERC721OrderSignatureReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateERC721OrderSignatureCall {
-            type Parameters<'a> = (LibNFTOrder::ERC721Order, LibSignature::Signature);
-            type Return = validateERC721OrderSignatureReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [209u8, 202u8, 24u8, 59u8];
-            const SIGNATURE: &'static str = "validateERC721OrderSignature((uint8,address,address,\
-                                             uint256,uint256,address,uint256,(address,uint256,\
-                                             bytes)[],address,uint256,(address,bytes)[]),(uint8,\
-                                             uint8,bytes32,bytes32))";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::tokenize(&self.order),
-                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateERC721OrderSignatureReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    ///Container for all the [`IZeroex`](self) function calls.
-    #[derive(Clone)]
-    pub enum IZeroexCalls {
-        #[allow(missing_docs)]
-        _fillLimitOrder(_fillLimitOrderCall),
-        #[allow(missing_docs)]
-        _fillOtcOrder(_fillOtcOrderCall),
-        #[allow(missing_docs)]
-        _fillRfqOrder(_fillRfqOrderCall),
-        #[allow(missing_docs)]
-        _sellHeldTokenForTokenToUniswapV3(_sellHeldTokenForTokenToUniswapV3Call),
-        #[allow(missing_docs)]
-        _transformERC20(_transformERC20Call),
-        #[allow(missing_docs)]
-        batchBuyERC1155s(batchBuyERC1155sCall),
-        #[allow(missing_docs)]
-        batchBuyERC721s(batchBuyERC721sCall),
-        #[allow(missing_docs)]
-        batchCancelERC1155Orders(batchCancelERC1155OrdersCall),
-        #[allow(missing_docs)]
-        batchCancelERC721Orders(batchCancelERC721OrdersCall),
-        #[allow(missing_docs)]
-        batchCancelLimitOrders(batchCancelLimitOrdersCall),
-        #[allow(missing_docs)]
-        batchCancelPairLimitOrders(batchCancelPairLimitOrdersCall),
-        #[allow(missing_docs)]
-        batchCancelPairLimitOrdersWithSigner(batchCancelPairLimitOrdersWithSignerCall),
-        #[allow(missing_docs)]
-        batchCancelPairRfqOrders(batchCancelPairRfqOrdersCall),
-        #[allow(missing_docs)]
-        batchCancelPairRfqOrdersWithSigner(batchCancelPairRfqOrdersWithSignerCall),
-        #[allow(missing_docs)]
-        batchCancelRfqOrders(batchCancelRfqOrdersCall),
-        #[allow(missing_docs)]
-        batchExecuteMetaTransactions(batchExecuteMetaTransactionsCall),
-        #[allow(missing_docs)]
-        batchFillLimitOrders(batchFillLimitOrdersCall),
-        #[allow(missing_docs)]
-        batchFillRfqOrders(batchFillRfqOrdersCall),
-        #[allow(missing_docs)]
-        batchFillTakerSignedOtcOrders(batchFillTakerSignedOtcOrdersCall),
-        #[allow(missing_docs)]
-        batchGetLimitOrderRelevantStates(batchGetLimitOrderRelevantStatesCall),
-        #[allow(missing_docs)]
-        batchGetRfqOrderRelevantStates(batchGetRfqOrderRelevantStatesCall),
-        #[allow(missing_docs)]
-        batchMatchERC721Orders(batchMatchERC721OrdersCall),
-        #[allow(missing_docs)]
-        buyERC1155(buyERC1155Call),
-        #[allow(missing_docs)]
-        buyERC721(buyERC721Call),
-        #[allow(missing_docs)]
-        cancelERC1155Order(cancelERC1155OrderCall),
-        #[allow(missing_docs)]
-        cancelERC721Order(cancelERC721OrderCall),
-        #[allow(missing_docs)]
-        cancelLimitOrder(cancelLimitOrderCall),
-        #[allow(missing_docs)]
-        cancelPairLimitOrders(cancelPairLimitOrdersCall),
-        #[allow(missing_docs)]
-        cancelPairLimitOrdersWithSigner(cancelPairLimitOrdersWithSignerCall),
-        #[allow(missing_docs)]
-        cancelPairRfqOrders(cancelPairRfqOrdersCall),
-        #[allow(missing_docs)]
-        cancelPairRfqOrdersWithSigner(cancelPairRfqOrdersWithSignerCall),
-        #[allow(missing_docs)]
-        cancelRfqOrder(cancelRfqOrderCall),
-        #[allow(missing_docs)]
-        createTransformWallet(createTransformWalletCall),
-        #[allow(missing_docs)]
-        executeMetaTransaction(executeMetaTransactionCall),
-        #[allow(missing_docs)]
-        extend(extendCall),
-        #[allow(missing_docs)]
-        fillLimitOrder(fillLimitOrderCall),
-        #[allow(missing_docs)]
-        fillOrKillLimitOrder(fillOrKillLimitOrderCall),
-        #[allow(missing_docs)]
-        fillOrKillRfqOrder(fillOrKillRfqOrderCall),
-        #[allow(missing_docs)]
-        fillOtcOrder(fillOtcOrderCall),
-        #[allow(missing_docs)]
-        fillOtcOrderForEth(fillOtcOrderForEthCall),
-        #[allow(missing_docs)]
-        fillOtcOrderWithEth(fillOtcOrderWithEthCall),
-        #[allow(missing_docs)]
-        fillRfqOrder(fillRfqOrderCall),
-        #[allow(missing_docs)]
-        fillTakerSignedOtcOrder(fillTakerSignedOtcOrderCall),
-        #[allow(missing_docs)]
-        fillTakerSignedOtcOrderForEth(fillTakerSignedOtcOrderForEthCall),
-        #[allow(missing_docs)]
-        getERC1155OrderHash(getERC1155OrderHashCall),
-        #[allow(missing_docs)]
-        getERC1155OrderInfo(getERC1155OrderInfoCall),
-        #[allow(missing_docs)]
-        getERC721OrderHash(getERC721OrderHashCall),
-        #[allow(missing_docs)]
-        getERC721OrderStatus(getERC721OrderStatusCall),
-        #[allow(missing_docs)]
-        getERC721OrderStatusBitVector(getERC721OrderStatusBitVectorCall),
-        #[allow(missing_docs)]
-        getLimitOrderHash(getLimitOrderHashCall),
-        #[allow(missing_docs)]
-        getLimitOrderInfo(getLimitOrderInfoCall),
-        #[allow(missing_docs)]
-        getLimitOrderRelevantState(getLimitOrderRelevantStateCall),
-        #[allow(missing_docs)]
-        getMetaTransactionExecutedBlock(getMetaTransactionExecutedBlockCall),
-        #[allow(missing_docs)]
-        getMetaTransactionHash(getMetaTransactionHashCall),
-        #[allow(missing_docs)]
-        getMetaTransactionHashExecutedBlock(getMetaTransactionHashExecutedBlockCall),
-        #[allow(missing_docs)]
-        getOtcOrderHash(getOtcOrderHashCall),
-        #[allow(missing_docs)]
-        getOtcOrderInfo(getOtcOrderInfoCall),
-        #[allow(missing_docs)]
-        getProtocolFeeMultiplier(getProtocolFeeMultiplierCall),
-        #[allow(missing_docs)]
-        getQuoteSigner(getQuoteSignerCall),
-        #[allow(missing_docs)]
-        getRfqOrderHash(getRfqOrderHashCall),
-        #[allow(missing_docs)]
-        getRfqOrderInfo(getRfqOrderInfoCall),
-        #[allow(missing_docs)]
-        getRfqOrderRelevantState(getRfqOrderRelevantStateCall),
-        #[allow(missing_docs)]
-        getRollbackEntryAtIndex(getRollbackEntryAtIndexCall),
-        #[allow(missing_docs)]
-        getRollbackLength(getRollbackLengthCall),
-        #[allow(missing_docs)]
-        getTransformWallet(getTransformWalletCall),
-        #[allow(missing_docs)]
-        getTransformerDeployer(getTransformerDeployerCall),
-        #[allow(missing_docs)]
-        isValidOrderSigner(isValidOrderSignerCall),
-        #[allow(missing_docs)]
-        lastOtcTxOriginNonce(lastOtcTxOriginNonceCall),
-        #[allow(missing_docs)]
-        matchERC721Orders(matchERC721OrdersCall),
-        #[allow(missing_docs)]
-        migrate(migrateCall),
-        #[allow(missing_docs)]
-        multiplexBatchSellEthForToken(multiplexBatchSellEthForTokenCall),
-        #[allow(missing_docs)]
-        multiplexBatchSellTokenForEth(multiplexBatchSellTokenForEthCall),
-        #[allow(missing_docs)]
-        multiplexBatchSellTokenForToken(multiplexBatchSellTokenForTokenCall),
-        #[allow(missing_docs)]
-        multiplexMultiHopSellEthForToken(multiplexMultiHopSellEthForTokenCall),
-        #[allow(missing_docs)]
-        multiplexMultiHopSellTokenForEth(multiplexMultiHopSellTokenForEthCall),
-        #[allow(missing_docs)]
-        multiplexMultiHopSellTokenForToken(multiplexMultiHopSellTokenForTokenCall),
-        #[allow(missing_docs)]
-        onERC1155Received(onERC1155ReceivedCall),
-        #[allow(missing_docs)]
-        onERC721Received(onERC721ReceivedCall),
-        #[allow(missing_docs)]
-        owner(ownerCall),
-        #[allow(missing_docs)]
-        preSignERC1155Order(preSignERC1155OrderCall),
-        #[allow(missing_docs)]
-        preSignERC721Order(preSignERC721OrderCall),
-        #[allow(missing_docs)]
-        registerAllowedOrderSigner(registerAllowedOrderSignerCall),
-        #[allow(missing_docs)]
-        registerAllowedRfqOrigins(registerAllowedRfqOriginsCall),
-        #[allow(missing_docs)]
-        rollback(rollbackCall),
-        #[allow(missing_docs)]
-        sellERC1155(sellERC1155Call),
-        #[allow(missing_docs)]
-        sellERC721(sellERC721Call),
-        #[allow(missing_docs)]
-        sellEthForTokenToUniswapV3(sellEthForTokenToUniswapV3Call),
-        #[allow(missing_docs)]
-        sellToLiquidityProvider(sellToLiquidityProviderCall),
-        #[allow(missing_docs)]
-        sellToPancakeSwap(sellToPancakeSwapCall),
-        #[allow(missing_docs)]
-        sellToUniswap(sellToUniswapCall),
-        #[allow(missing_docs)]
-        sellTokenForEthToUniswapV3(sellTokenForEthToUniswapV3Call),
-        #[allow(missing_docs)]
-        sellTokenForTokenToUniswapV3(sellTokenForTokenToUniswapV3Call),
-        #[allow(missing_docs)]
-        setQuoteSigner(setQuoteSignerCall),
-        #[allow(missing_docs)]
-        setTransformerDeployer(setTransformerDeployerCall),
-        #[allow(missing_docs)]
-        supportInterface(supportInterfaceCall),
-        #[allow(missing_docs)]
-        transferOwnership(transferOwnershipCall),
-        #[allow(missing_docs)]
-        transferProtocolFeesForPools(transferProtocolFeesForPoolsCall),
-        #[allow(missing_docs)]
-        transferTrappedTokensTo(transferTrappedTokensToCall),
-        #[allow(missing_docs)]
-        transformERC20(transformERC20Call),
-        #[allow(missing_docs)]
-        uniswapV3SwapCallback(uniswapV3SwapCallbackCall),
-        #[allow(missing_docs)]
-        validateERC1155OrderProperties(validateERC1155OrderPropertiesCall),
-        #[allow(missing_docs)]
-        validateERC1155OrderSignature(validateERC1155OrderSignatureCall),
-        #[allow(missing_docs)]
-        validateERC721OrderProperties(validateERC721OrderPropertiesCall),
-        #[allow(missing_docs)]
-        validateERC721OrderSignature(validateERC721OrderSignatureCall),
-    }
-    impl IZeroexCalls {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [1u8, 106u8, 109u8, 101u8],
-            [3u8, 11u8, 39u8, 48u8],
-            [6u8, 210u8, 89u8, 107u8],
-            [13u8, 50u8, 165u8, 49u8],
-            [13u8, 55u8, 88u8, 132u8],
-            [13u8, 130u8, 97u8, 235u8],
-            [15u8, 14u8, 140u8, 247u8],
-            [15u8, 59u8, 49u8, 178u8],
-            [21u8, 11u8, 122u8, 2u8],
-            [27u8, 170u8, 160u8, 11u8],
-            [29u8, 227u8, 167u8, 172u8],
-            [31u8, 176u8, 151u8, 149u8],
-            [38u8, 31u8, 230u8, 121u8],
-            [40u8, 123u8, 7u8, 27u8],
-            [42u8, 198u8, 246u8, 42u8],
-            [52u8, 102u8, 147u8, 197u8],
-            [53u8, 152u8, 216u8, 171u8],
-            [55u8, 243u8, 129u8, 216u8],
-            [60u8, 210u8, 240u8, 38u8],
-            [61u8, 97u8, 237u8, 62u8],
-            [63u8, 178u8, 218u8, 56u8],
-            [65u8, 78u8, 76u8, 207u8],
-            [65u8, 85u8, 101u8, 176u8],
-            [67u8, 140u8, 223u8, 197u8],
-            [70u8, 33u8, 3u8, 175u8],
-            [72u8, 123u8, 92u8, 32u8],
-            [73u8, 145u8, 253u8, 114u8],
-            [74u8, 19u8, 215u8, 151u8],
-            [74u8, 147u8, 27u8, 161u8],
-            [77u8, 84u8, 205u8, 182u8],
-            [79u8, 148u8, 129u8, 16u8],
-            [81u8, 97u8, 185u8, 102u8],
-            [83u8, 71u8, 107u8, 137u8],
-            [86u8, 206u8, 24u8, 10u8],
-            [89u8, 235u8, 251u8, 69u8],
-            [106u8, 244u8, 121u8, 178u8],
-            [107u8, 82u8, 164u8, 168u8],
-            [107u8, 166u8, 187u8, 194u8],
-            [110u8, 46u8, 236u8, 158u8],
-            [110u8, 178u8, 36u8, 203u8],
-            [112u8, 99u8, 148u8, 213u8],
-            [114u8, 77u8, 57u8, 83u8],
-            [114u8, 209u8, 125u8, 3u8],
-            [117u8, 16u8, 60u8, 185u8],
-            [117u8, 231u8, 155u8, 230u8],
-            [119u8, 114u8, 93u8, 246u8],
-            [122u8, 30u8, 177u8, 185u8],
-            [123u8, 117u8, 125u8, 151u8],
-            [124u8, 219u8, 84u8, 216u8],
-            [125u8, 73u8, 236u8, 26u8],
-            [125u8, 169u8, 226u8, 207u8],
-            [128u8, 59u8, 162u8, 109u8],
-            [132u8, 104u8, 6u8, 21u8],
-            [134u8, 33u8, 153u8, 64u8],
-            [134u8, 160u8, 200u8, 215u8],
-            [135u8, 201u8, 100u8, 25u8],
-            [138u8, 166u8, 83u8, 155u8],
-            [140u8, 128u8, 124u8, 67u8],
-            [141u8, 165u8, 203u8, 91u8],
-            [146u8, 64u8, 82u8, 156u8],
-            [147u8, 92u8, 130u8, 164u8],
-            [149u8, 72u8, 8u8, 137u8],
-            [154u8, 41u8, 103u8, 210u8],
-            [154u8, 79u8, 128u8, 156u8],
-            [155u8, 170u8, 69u8, 168u8],
-            [157u8, 182u8, 74u8, 64u8],
-            [159u8, 4u8, 52u8, 245u8],
-            [159u8, 30u8, 199u8, 139u8],
-            [161u8, 134u8, 93u8, 111u8],
-            [165u8, 120u8, 239u8, 175u8],
-            [170u8, 107u8, 33u8, 205u8],
-            [170u8, 119u8, 71u8, 108u8],
-            [173u8, 53u8, 78u8, 235u8],
-            [174u8, 85u8, 4u8, 151u8],
-            [175u8, 222u8, 27u8, 60u8],
-            [176u8, 159u8, 31u8, 177u8],
-            [177u8, 10u8, 51u8, 244u8],
-            [180u8, 101u8, 139u8, 251u8],
-            [183u8, 58u8, 96u8, 39u8],
-            [190u8, 22u8, 123u8, 157u8],
-            [196u8, 60u8, 158u8, 246u8],
-            [197u8, 87u8, 158u8, 200u8],
-            [208u8, 165u8, 95u8, 176u8],
-            [209u8, 202u8, 24u8, 59u8],
-            [217u8, 98u8, 122u8, 164u8],
-            [218u8, 199u8, 72u8, 212u8],
-            [221u8, 17u8, 210u8, 37u8],
-            [223u8, 208u8, 7u8, 73u8],
-            [228u8, 186u8, 132u8, 57u8],
-            [229u8, 45u8, 23u8, 100u8],
-            [234u8, 127u8, 170u8, 97u8],
-            [234u8, 233u8, 62u8, 231u8],
-            [240u8, 40u8, 233u8, 190u8],
-            [242u8, 58u8, 110u8, 97u8],
-            [242u8, 253u8, 227u8, 139u8],
-            [243u8, 91u8, 71u8, 51u8],
-            [246u8, 39u8, 79u8, 102u8],
-            [246u8, 224u8, 246u8, 165u8],
-            [247u8, 252u8, 211u8, 132u8],
-            [250u8, 70u8, 30u8, 51u8],
-            [251u8, 196u8, 165u8, 24u8],
-            [251u8, 238u8, 52u8, 157u8],
-            [253u8, 95u8, 153u8, 91u8],
-            [254u8, 85u8, 163u8, 239u8],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <getRfqOrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelERC1155OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transferTrappedTokensToCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <matchERC721OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onERC721ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getERC1155OrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <migrateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <createTransformWalletCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRfqOrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <executeMetaTransactionCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <_fillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transformERC20Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <preSignERC721OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTransformerDeployerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOtcOrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setQuoteSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <isValidOrderSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellERC1155Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <extendCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <supportInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <preSignERC1155OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <buyERC1155Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchBuyERC1155sCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setTransformerDeployerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <_transformERC20Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <getOtcOrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getLimitOrderInfoCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <rollbackCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getQuoteSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <_fillRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getMetaTransactionHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellERC721Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getERC721OrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelERC721OrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellToPancakeSwapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellToUniswapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillOtcOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getLimitOrderHashCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getRollbackLengthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <_fillOtcOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchBuyERC721sCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getTransformWalletCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <fillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getERC721OrderStatusCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <buyERC721Call as alloy_sol_types::SolCall>::SIGNATURE,
-            <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelRfqOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(getRfqOrderHash),
-            ::core::stringify!(getERC721OrderStatusBitVector),
-            ::core::stringify!(cancelERC1155Order),
-            ::core::stringify!(validateERC1155OrderSignature),
-            ::core::stringify!(transferTrappedTokensTo),
-            ::core::stringify!(matchERC721Orders),
-            ::core::stringify!(batchCancelPairRfqOrders),
-            ::core::stringify!(multiplexMultiHopSellTokenForToken),
-            ::core::stringify!(onERC721Received),
-            ::core::stringify!(batchFillLimitOrders),
-            ::core::stringify!(getERC1155OrderHash),
-            ::core::stringify!(getLimitOrderRelevantState),
-            ::core::stringify!(migrate),
-            ::core::stringify!(createTransformWallet),
-            ::core::stringify!(validateERC1155OrderProperties),
-            ::core::stringify!(getRfqOrderInfo),
-            ::core::stringify!(sellEthForTokenToUniswapV3),
-            ::core::stringify!(getRfqOrderRelevantState),
-            ::core::stringify!(transferProtocolFeesForPools),
-            ::core::stringify!(executeMetaTransaction),
-            ::core::stringify!(getMetaTransactionExecutedBlock),
-            ::core::stringify!(_fillLimitOrder),
-            ::core::stringify!(transformERC20),
-            ::core::stringify!(fillOrKillRfqOrder),
-            ::core::stringify!(preSignERC721Order),
-            ::core::stringify!(getProtocolFeeMultiplier),
-            ::core::stringify!(getERC1155OrderInfo),
-            ::core::stringify!(validateERC721OrderProperties),
-            ::core::stringify!(_sellHeldTokenForTokenToUniswapV3),
-            ::core::stringify!(getTransformerDeployer),
-            ::core::stringify!(fillTakerSignedOtcOrder),
-            ::core::stringify!(multiplexMultiHopSellEthForToken),
-            ::core::stringify!(getOtcOrderHash),
-            ::core::stringify!(setQuoteSigner),
-            ::core::stringify!(lastOtcTxOriginNonce),
-            ::core::stringify!(sellTokenForTokenToUniswapV3),
-            ::core::stringify!(isValidOrderSigner),
-            ::core::stringify!(getRollbackEntryAtIndex),
-            ::core::stringify!(sellERC1155),
-            ::core::stringify!(extend),
-            ::core::stringify!(fillOtcOrderWithEth),
-            ::core::stringify!(fillTakerSignedOtcOrderForEth),
-            ::core::stringify!(getMetaTransactionHashExecutedBlock),
-            ::core::stringify!(batchFillRfqOrders),
-            ::core::stringify!(supportInterface),
-            ::core::stringify!(multiplexBatchSellTokenForEth),
-            ::core::stringify!(multiplexBatchSellTokenForToken),
-            ::core::stringify!(preSignERC1155Order),
-            ::core::stringify!(buyERC1155),
-            ::core::stringify!(cancelLimitOrder),
-            ::core::stringify!(batchMatchERC721Orders),
-            ::core::stringify!(sellTokenForEthToUniswapV3),
-            ::core::stringify!(batchBuyERC1155s),
-            ::core::stringify!(batchCancelERC721Orders),
-            ::core::stringify!(batchCancelPairLimitOrders),
-            ::core::stringify!(setTransformerDeployer),
-            ::core::stringify!(_transformERC20),
-            ::core::stringify!(getOtcOrderInfo),
-            ::core::stringify!(owner),
-            ::core::stringify!(fillOrKillLimitOrder),
-            ::core::stringify!(cancelPairRfqOrdersWithSigner),
-            ::core::stringify!(getLimitOrderInfo),
-            ::core::stringify!(multiplexMultiHopSellTokenForEth),
-            ::core::stringify!(cancelPairRfqOrders),
-            ::core::stringify!(batchCancelLimitOrders),
-            ::core::stringify!(rollback),
-            ::core::stringify!(batchCancelPairLimitOrdersWithSigner),
-            ::core::stringify!(getQuoteSigner),
-            ::core::stringify!(batchCancelERC1155Orders),
-            ::core::stringify!(fillOtcOrderForEth),
-            ::core::stringify!(_fillRfqOrder),
-            ::core::stringify!(fillRfqOrder),
-            ::core::stringify!(batchGetRfqOrderRelevantStates),
-            ::core::stringify!(getMetaTransactionHash),
-            ::core::stringify!(sellERC721),
-            ::core::stringify!(registerAllowedRfqOrigins),
-            ::core::stringify!(cancelPairLimitOrdersWithSigner),
-            ::core::stringify!(batchGetLimitOrderRelevantStates),
-            ::core::stringify!(getERC721OrderHash),
-            ::core::stringify!(cancelERC721Order),
-            ::core::stringify!(sellToPancakeSwap),
-            ::core::stringify!(batchExecuteMetaTransactions),
-            ::core::stringify!(cancelPairLimitOrders),
-            ::core::stringify!(validateERC721OrderSignature),
-            ::core::stringify!(sellToUniswap),
-            ::core::stringify!(fillOtcOrder),
-            ::core::stringify!(getLimitOrderHash),
-            ::core::stringify!(getRollbackLength),
-            ::core::stringify!(_fillOtcOrder),
-            ::core::stringify!(batchFillTakerSignedOtcOrders),
-            ::core::stringify!(registerAllowedOrderSigner),
-            ::core::stringify!(batchBuyERC721s),
-            ::core::stringify!(getTransformWallet),
-            ::core::stringify!(onERC1155Received),
-            ::core::stringify!(transferOwnership),
-            ::core::stringify!(multiplexBatchSellEthForToken),
-            ::core::stringify!(fillLimitOrder),
-            ::core::stringify!(batchCancelRfqOrders),
-            ::core::stringify!(sellToLiquidityProvider),
-            ::core::stringify!(uniswapV3SwapCallback),
-            ::core::stringify!(getERC721OrderStatus),
-            ::core::stringify!(buyERC721),
-            ::core::stringify!(batchCancelPairRfqOrdersWithSigner),
-            ::core::stringify!(cancelRfqOrder),
-        ];
-
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 4usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
-                }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
-            }
-        }
-
-        /// Returns the enum variant name for the given selector, if known.
-        #[inline]
-        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
-            let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for IZeroexCalls {
-        const COUNT: usize = 104usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "IZeroexCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::_fillLimitOrder(_) => {
-                    <_fillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::_fillOtcOrder(_) => <_fillOtcOrderCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::_fillRfqOrder(_) => <_fillRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::_sellHeldTokenForTokenToUniswapV3(_) => {
-                    <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::_transformERC20(_) => {
-                    <_transformERC20Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchBuyERC1155s(_) => {
-                    <batchBuyERC1155sCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchBuyERC721s(_) => {
-                    <batchBuyERC721sCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelERC1155Orders(_) => {
-                    <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelERC721Orders(_) => {
-                    <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelLimitOrders(_) => {
-                    <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelPairLimitOrders(_) => {
-                    <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelPairLimitOrdersWithSigner(_) => {
-                    <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelPairRfqOrders(_) => {
-                    <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelPairRfqOrdersWithSigner(_) => {
-                    <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchCancelRfqOrders(_) => {
-                    <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchExecuteMetaTransactions(_) => {
-                    <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchFillLimitOrders(_) => {
-                    <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchFillRfqOrders(_) => {
-                    <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchFillTakerSignedOtcOrders(_) => {
-                    <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchGetLimitOrderRelevantStates(_) => {
-                    <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchGetRfqOrderRelevantStates(_) => {
-                    <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::batchMatchERC721Orders(_) => {
-                    <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::buyERC1155(_) => <buyERC1155Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::buyERC721(_) => <buyERC721Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::cancelERC1155Order(_) => {
-                    <cancelERC1155OrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelERC721Order(_) => {
-                    <cancelERC721OrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelLimitOrder(_) => {
-                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelPairLimitOrders(_) => {
-                    <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelPairLimitOrdersWithSigner(_) => {
-                    <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelPairRfqOrders(_) => {
-                    <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelPairRfqOrdersWithSigner(_) => {
-                    <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::cancelRfqOrder(_) => {
-                    <cancelRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::createTransformWallet(_) => {
-                    <createTransformWalletCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::executeMetaTransaction(_) => {
-                    <executeMetaTransactionCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::extend(_) => <extendCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::fillLimitOrder(_) => {
-                    <fillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::fillOrKillLimitOrder(_) => {
-                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::fillOrKillRfqOrder(_) => {
-                    <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::fillOtcOrder(_) => <fillOtcOrderCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::fillOtcOrderForEth(_) => {
-                    <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::fillOtcOrderWithEth(_) => {
-                    <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::fillRfqOrder(_) => <fillRfqOrderCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::fillTakerSignedOtcOrder(_) => {
-                    <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::fillTakerSignedOtcOrderForEth(_) => {
-                    <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getERC1155OrderHash(_) => {
-                    <getERC1155OrderHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getERC1155OrderInfo(_) => {
-                    <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getERC721OrderHash(_) => {
-                    <getERC721OrderHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getERC721OrderStatus(_) => {
-                    <getERC721OrderStatusCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getERC721OrderStatusBitVector(_) => {
-                    <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getLimitOrderHash(_) => {
-                    <getLimitOrderHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getLimitOrderInfo(_) => {
-                    <getLimitOrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getLimitOrderRelevantState(_) => {
-                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getMetaTransactionExecutedBlock(_) => {
-                    <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getMetaTransactionHash(_) => {
-                    <getMetaTransactionHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getMetaTransactionHashExecutedBlock(_) => {
-                    <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getOtcOrderHash(_) => {
-                    <getOtcOrderHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getOtcOrderInfo(_) => {
-                    <getOtcOrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getProtocolFeeMultiplier(_) => {
-                    <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getQuoteSigner(_) => {
-                    <getQuoteSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getRfqOrderHash(_) => {
-                    <getRfqOrderHashCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getRfqOrderInfo(_) => {
-                    <getRfqOrderInfoCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getRfqOrderRelevantState(_) => {
-                    <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getRollbackEntryAtIndex(_) => {
-                    <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getRollbackLength(_) => {
-                    <getRollbackLengthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getTransformWallet(_) => {
-                    <getTransformWalletCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getTransformerDeployer(_) => {
-                    <getTransformerDeployerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::isValidOrderSigner(_) => {
-                    <isValidOrderSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::lastOtcTxOriginNonce(_) => {
-                    <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::matchERC721Orders(_) => {
-                    <matchERC721OrdersCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::migrate(_) => <migrateCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::multiplexBatchSellEthForToken(_) => {
-                    <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::multiplexBatchSellTokenForEth(_) => {
-                    <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::multiplexBatchSellTokenForToken(_) => {
-                    <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::multiplexMultiHopSellEthForToken(_) => {
-                    <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::multiplexMultiHopSellTokenForEth(_) => {
-                    <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::multiplexMultiHopSellTokenForToken(_) => {
-                    <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::onERC1155Received(_) => {
-                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::onERC721Received(_) => {
-                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::preSignERC1155Order(_) => {
-                    <preSignERC1155OrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::preSignERC721Order(_) => {
-                    <preSignERC721OrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::registerAllowedOrderSigner(_) => {
-                    <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::registerAllowedRfqOrigins(_) => {
-                    <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::rollback(_) => <rollbackCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::sellERC1155(_) => <sellERC1155Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::sellERC721(_) => <sellERC721Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::sellEthForTokenToUniswapV3(_) => {
-                    <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::sellToLiquidityProvider(_) => {
-                    <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::sellToPancakeSwap(_) => {
-                    <sellToPancakeSwapCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::sellToUniswap(_) => <sellToUniswapCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::sellTokenForEthToUniswapV3(_) => {
-                    <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::sellTokenForTokenToUniswapV3(_) => {
-                    <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setQuoteSigner(_) => {
-                    <setQuoteSignerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::setTransformerDeployer(_) => {
-                    <setTransformerDeployerCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::supportInterface(_) => {
-                    <supportInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::transferOwnership(_) => {
-                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::transferProtocolFeesForPools(_) => {
-                    <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::transferTrappedTokensTo(_) => {
-                    <transferTrappedTokensToCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::transformERC20(_) => {
-                    <transformERC20Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::uniswapV3SwapCallback(_) => {
-                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateERC1155OrderProperties(_) => {
-                    <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateERC1155OrderSignature(_) => {
-                    <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateERC721OrderProperties(_) => {
-                    <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateERC721OrderSignature(_) => {
-                    <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IZeroexCalls>] = &[
-                {
-                    fn getRfqOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getRfqOrderHash)
-                    }
-                    getRfqOrderHash
-                },
-                {
-                    fn getERC721OrderStatusBitVector(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::getERC721OrderStatusBitVector)
-                    }
-                    getERC721OrderStatusBitVector
-                },
-                {
-                    fn cancelERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::cancelERC1155Order)
-                    }
-                    cancelERC1155Order
-                },
-                {
-                    fn validateERC1155OrderSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC1155OrderSignature)
-                    }
-                    validateERC1155OrderSignature
-                },
-                {
-                    fn transferTrappedTokensTo(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::transferTrappedTokensTo)
-                    }
-                    transferTrappedTokensTo
-                },
-                {
-                    fn matchERC721Orders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::matchERC721Orders)
-                    }
-                    matchERC721Orders
-                },
-                {
-                    fn batchCancelPairRfqOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchCancelPairRfqOrders)
-                    }
-                    batchCancelPairRfqOrders
-                },
-                {
-                    fn multiplexMultiHopSellTokenForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexMultiHopSellTokenForToken)
-                    }
-                    multiplexMultiHopSellTokenForToken
-                },
-                {
-                    fn onERC721Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::onERC721Received)
-                    }
-                    onERC721Received
-                },
-                {
-                    fn batchFillLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::batchFillLimitOrders)
-                    }
-                    batchFillLimitOrders
-                },
-                {
-                    fn getERC1155OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getERC1155OrderHash)
-                    }
-                    getERC1155OrderHash
-                },
-                {
-                    fn getLimitOrderRelevantState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::getLimitOrderRelevantState)
-                    }
-                    getLimitOrderRelevantState
-                },
-                {
-                    fn migrate(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <migrateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::migrate)
-                    }
-                    migrate
-                },
-                {
-                    fn createTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <createTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::createTransformWallet)
-                    }
-                    createTransformWallet
-                },
-                {
-                    fn validateERC1155OrderProperties(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC1155OrderProperties)
-                    }
-                    validateERC1155OrderProperties
-                },
-                {
-                    fn getRfqOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getRfqOrderInfo)
-                    }
-                    getRfqOrderInfo
-                },
-                {
-                    fn sellEthForTokenToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellEthForTokenToUniswapV3)
-                    }
-                    sellEthForTokenToUniswapV3
-                },
-                {
-                    fn getRfqOrderRelevantState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::getRfqOrderRelevantState)
-                    }
-                    getRfqOrderRelevantState
-                },
-                {
-                    fn transferProtocolFeesForPools(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::transferProtocolFeesForPools)
-                    }
-                    transferProtocolFeesForPools
-                },
-                {
-                    fn executeMetaTransaction(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::executeMetaTransaction)
-                    }
-                    executeMetaTransaction
-                },
-                {
-                    fn getMetaTransactionExecutedBlock(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::getMetaTransactionExecutedBlock)
-                    }
-                    getMetaTransactionExecutedBlock
-                },
-                {
-                    fn _fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::_fillLimitOrder)
-                    }
-                    _fillLimitOrder
-                },
-                {
-                    fn transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::transformERC20)
-                    }
-                    transformERC20
-                },
-                {
-                    fn fillOrKillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillOrKillRfqOrder)
-                    }
-                    fillOrKillRfqOrder
-                },
-                {
-                    fn preSignERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::preSignERC721Order)
-                    }
-                    preSignERC721Order
-                },
-                {
-                    fn getProtocolFeeMultiplier(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::getProtocolFeeMultiplier)
-                    }
-                    getProtocolFeeMultiplier
-                },
-                {
-                    fn getERC1155OrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getERC1155OrderInfo)
-                    }
-                    getERC1155OrderInfo
-                },
-                {
-                    fn validateERC721OrderProperties(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC721OrderProperties)
-                    }
-                    validateERC721OrderProperties
-                },
-                {
-                    fn _sellHeldTokenForTokenToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::_sellHeldTokenForTokenToUniswapV3)
-                    }
-                    _sellHeldTokenForTokenToUniswapV3
-                },
-                {
-                    fn getTransformerDeployer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::getTransformerDeployer)
-                    }
-                    getTransformerDeployer
-                },
-                {
-                    fn fillTakerSignedOtcOrder(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::fillTakerSignedOtcOrder)
-                    }
-                    fillTakerSignedOtcOrder
-                },
-                {
-                    fn multiplexMultiHopSellEthForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexMultiHopSellEthForToken)
-                    }
-                    multiplexMultiHopSellEthForToken
-                },
-                {
-                    fn getOtcOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getOtcOrderHash)
-                    }
-                    getOtcOrderHash
-                },
-                {
-                    fn setQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::setQuoteSigner)
-                    }
-                    setQuoteSigner
-                },
-                {
-                    fn lastOtcTxOriginNonce(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::lastOtcTxOriginNonce)
-                    }
-                    lastOtcTxOriginNonce
-                },
-                {
-                    fn sellTokenForTokenToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellTokenForTokenToUniswapV3)
-                    }
-                    sellTokenForTokenToUniswapV3
-                },
-                {
-                    fn isValidOrderSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::isValidOrderSigner)
-                    }
-                    isValidOrderSigner
-                },
-                {
-                    fn getRollbackEntryAtIndex(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::getRollbackEntryAtIndex)
-                    }
-                    getRollbackEntryAtIndex
-                },
-                {
-                    fn sellERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::sellERC1155)
-                    }
-                    sellERC1155
-                },
-                {
-                    fn extend(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <extendCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::extend)
-                    }
-                    extend
-                },
-                {
-                    fn fillOtcOrderWithEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillOtcOrderWithEth)
-                    }
-                    fillOtcOrderWithEth
-                },
-                {
-                    fn fillTakerSignedOtcOrderForEth(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillTakerSignedOtcOrderForEth)
-                    }
-                    fillTakerSignedOtcOrderForEth
-                },
-                {
-                    fn getMetaTransactionHashExecutedBlock(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::getMetaTransactionHashExecutedBlock)
-                    }
-                    getMetaTransactionHashExecutedBlock
-                },
-                {
-                    fn batchFillRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::batchFillRfqOrders)
-                    }
-                    batchFillRfqOrders
-                },
-                {
-                    fn supportInterface(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <supportInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::supportInterface)
-                    }
-                    supportInterface
-                },
-                {
-                    fn multiplexBatchSellTokenForEth(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexBatchSellTokenForEth)
-                    }
-                    multiplexBatchSellTokenForEth
-                },
-                {
-                    fn multiplexBatchSellTokenForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexBatchSellTokenForToken)
-                    }
-                    multiplexBatchSellTokenForToken
-                },
-                {
-                    fn preSignERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::preSignERC1155Order)
-                    }
-                    preSignERC1155Order
-                },
-                {
-                    fn buyERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <buyERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::buyERC1155)
-                    }
-                    buyERC1155
-                },
-                {
-                    fn cancelLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::cancelLimitOrder)
-                    }
-                    cancelLimitOrder
-                },
-                {
-                    fn batchMatchERC721Orders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchMatchERC721Orders)
-                    }
-                    batchMatchERC721Orders
-                },
-                {
-                    fn sellTokenForEthToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellTokenForEthToUniswapV3)
-                    }
-                    sellTokenForEthToUniswapV3
-                },
-                {
-                    fn batchBuyERC1155s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::batchBuyERC1155s)
-                    }
-                    batchBuyERC1155s
-                },
-                {
-                    fn batchCancelERC721Orders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchCancelERC721Orders)
-                    }
-                    batchCancelERC721Orders
-                },
-                {
-                    fn batchCancelPairLimitOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairLimitOrders)
-                    }
-                    batchCancelPairLimitOrders
-                },
-                {
-                    fn setTransformerDeployer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::setTransformerDeployer)
-                    }
-                    setTransformerDeployer
-                },
-                {
-                    fn _transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::_transformERC20)
-                    }
-                    _transformERC20
-                },
-                {
-                    fn getOtcOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getOtcOrderInfo)
-                    }
-                    getOtcOrderInfo
-                },
-                {
-                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::owner)
-                    }
-                    owner
-                },
-                {
-                    fn fillOrKillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillOrKillLimitOrder)
-                    }
-                    fillOrKillLimitOrder
-                },
-                {
-                    fn cancelPairRfqOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelPairRfqOrdersWithSigner)
-                    }
-                    cancelPairRfqOrdersWithSigner
-                },
-                {
-                    fn getLimitOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getLimitOrderInfo)
-                    }
-                    getLimitOrderInfo
-                },
-                {
-                    fn multiplexMultiHopSellTokenForEth(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexMultiHopSellTokenForEth)
-                    }
-                    multiplexMultiHopSellTokenForEth
-                },
-                {
-                    fn cancelPairRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::cancelPairRfqOrders)
-                    }
-                    cancelPairRfqOrders
-                },
-                {
-                    fn batchCancelLimitOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchCancelLimitOrders)
-                    }
-                    batchCancelLimitOrders
-                },
-                {
-                    fn rollback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <rollbackCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::rollback)
-                    }
-                    rollback
-                },
-                {
-                    fn batchCancelPairLimitOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairLimitOrdersWithSigner)
-                    }
-                    batchCancelPairLimitOrdersWithSigner
-                },
-                {
-                    fn getQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getQuoteSigner)
-                    }
-                    getQuoteSigner
-                },
-                {
-                    fn batchCancelERC1155Orders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchCancelERC1155Orders)
-                    }
-                    batchCancelERC1155Orders
-                },
-                {
-                    fn fillOtcOrderForEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillOtcOrderForEth)
-                    }
-                    fillOtcOrderForEth
-                },
-                {
-                    fn _fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::_fillRfqOrder)
-                    }
-                    _fillRfqOrder
-                },
-                {
-                    fn fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillRfqOrder)
-                    }
-                    fillRfqOrder
-                },
-                {
-                    fn batchGetRfqOrderRelevantStates(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchGetRfqOrderRelevantStates)
-                    }
-                    batchGetRfqOrderRelevantStates
-                },
-                {
-                    fn getMetaTransactionHash(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::getMetaTransactionHash)
-                    }
-                    getMetaTransactionHash
-                },
-                {
-                    fn sellERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellERC721Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::sellERC721)
-                    }
-                    sellERC721
-                },
-                {
-                    fn registerAllowedRfqOrigins(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::registerAllowedRfqOrigins)
-                    }
-                    registerAllowedRfqOrigins
-                },
-                {
-                    fn cancelPairLimitOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelPairLimitOrdersWithSigner)
-                    }
-                    cancelPairLimitOrdersWithSigner
-                },
-                {
-                    fn batchGetLimitOrderRelevantStates(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchGetLimitOrderRelevantStates)
-                    }
-                    batchGetLimitOrderRelevantStates
-                },
-                {
-                    fn getERC721OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getERC721OrderHash)
-                    }
-                    getERC721OrderHash
-                },
-                {
-                    fn cancelERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::cancelERC721Order)
-                    }
-                    cancelERC721Order
-                },
-                {
-                    fn sellToPancakeSwap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::sellToPancakeSwap)
-                    }
-                    sellToPancakeSwap
-                },
-                {
-                    fn batchExecuteMetaTransactions(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchExecuteMetaTransactions)
-                    }
-                    batchExecuteMetaTransactions
-                },
-                {
-                    fn cancelPairLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::cancelPairLimitOrders)
-                    }
-                    cancelPairLimitOrders
-                },
-                {
-                    fn validateERC721OrderSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC721OrderSignature)
-                    }
-                    validateERC721OrderSignature
-                },
-                {
-                    fn sellToUniswap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellToUniswapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::sellToUniswap)
-                    }
-                    sellToUniswap
-                },
-                {
-                    fn fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillOtcOrder)
-                    }
-                    fillOtcOrder
-                },
-                {
-                    fn getLimitOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getLimitOrderHash)
-                    }
-                    getLimitOrderHash
-                },
-                {
-                    fn getRollbackLength(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getRollbackLength)
-                    }
-                    getRollbackLength
-                },
-                {
-                    fn _fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::_fillOtcOrder)
-                    }
-                    _fillOtcOrder
-                },
-                {
-                    fn batchFillTakerSignedOtcOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchFillTakerSignedOtcOrders)
-                    }
-                    batchFillTakerSignedOtcOrders
-                },
-                {
-                    fn registerAllowedOrderSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::registerAllowedOrderSigner)
-                    }
-                    registerAllowedOrderSigner
-                },
-                {
-                    fn batchBuyERC721s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::batchBuyERC721s)
-                    }
-                    batchBuyERC721s
-                },
-                {
-                    fn getTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getTransformWallet)
-                    }
-                    getTransformWallet
-                },
-                {
-                    fn onERC1155Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::onERC1155Received)
-                    }
-                    onERC1155Received
-                },
-                {
-                    fn transferOwnership(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::transferOwnership)
-                    }
-                    transferOwnership
-                },
-                {
-                    fn multiplexBatchSellEthForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexBatchSellEthForToken)
-                    }
-                    multiplexBatchSellEthForToken
-                },
-                {
-                    fn fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::fillLimitOrder)
-                    }
-                    fillLimitOrder
-                },
-                {
-                    fn batchCancelRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::batchCancelRfqOrders)
-                    }
-                    batchCancelRfqOrders
-                },
-                {
-                    fn sellToLiquidityProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::sellToLiquidityProvider)
-                    }
-                    sellToLiquidityProvider
-                },
-                {
-                    fn uniswapV3SwapCallback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(IZeroexCalls::uniswapV3SwapCallback)
-                    }
-                    uniswapV3SwapCallback
-                },
-                {
-                    fn getERC721OrderStatus(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::getERC721OrderStatus)
-                    }
-                    getERC721OrderStatus
-                },
-                {
-                    fn buyERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <buyERC721Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::buyERC721)
-                    }
-                    buyERC721
-                },
-                {
-                    fn batchCancelPairRfqOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairRfqOrdersWithSigner)
-                    }
-                    batchCancelPairRfqOrdersWithSigner
-                },
-                {
-                    fn cancelRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(IZeroexCalls::cancelRfqOrder)
-                    }
-                    cancelRfqOrder
-                },
-            ];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw_validate(
-            selector: [u8; 4],
-            data: &[u8],
-        ) -> alloy_sol_types::Result<Self> {
-            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IZeroexCalls>] = &[
-                {
-                    fn getRfqOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::getRfqOrderHash)
-                    }
-                    getRfqOrderHash
-                },
-                {
-                    fn getERC721OrderStatusBitVector(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getERC721OrderStatusBitVector)
-                    }
-                    getERC721OrderStatusBitVector
-                },
-                {
-                    fn cancelERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelERC1155Order)
-                    }
-                    cancelERC1155Order
-                },
-                {
-                    fn validateERC1155OrderSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC1155OrderSignature)
-                    }
-                    validateERC1155OrderSignature
-                },
-                {
-                    fn transferTrappedTokensTo(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::transferTrappedTokensTo)
-                    }
-                    transferTrappedTokensTo
-                },
-                {
-                    fn matchERC721Orders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::matchERC721Orders)
-                    }
-                    matchERC721Orders
-                },
-                {
-                    fn batchCancelPairRfqOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairRfqOrders)
-                    }
-                    batchCancelPairRfqOrders
-                },
-                {
-                    fn multiplexMultiHopSellTokenForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexMultiHopSellTokenForToken)
-                    }
-                    multiplexMultiHopSellTokenForToken
-                },
-                {
-                    fn onERC721Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::onERC721Received)
-                    }
-                    onERC721Received
-                },
-                {
-                    fn batchFillLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchFillLimitOrders)
-                    }
-                    batchFillLimitOrders
-                },
-                {
-                    fn getERC1155OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getERC1155OrderHash)
-                    }
-                    getERC1155OrderHash
-                },
-                {
-                    fn getLimitOrderRelevantState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getLimitOrderRelevantState)
-                    }
-                    getLimitOrderRelevantState
-                },
-                {
-                    fn migrate(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <migrateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::migrate)
-                    }
-                    migrate
-                },
-                {
-                    fn createTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <createTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::createTransformWallet)
-                    }
-                    createTransformWallet
-                },
-                {
-                    fn validateERC1155OrderProperties(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC1155OrderProperties)
-                    }
-                    validateERC1155OrderProperties
-                },
-                {
-                    fn getRfqOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::getRfqOrderInfo)
-                    }
-                    getRfqOrderInfo
-                },
-                {
-                    fn sellEthForTokenToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellEthForTokenToUniswapV3)
-                    }
-                    sellEthForTokenToUniswapV3
-                },
-                {
-                    fn getRfqOrderRelevantState(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getRfqOrderRelevantState)
-                    }
-                    getRfqOrderRelevantState
-                },
-                {
-                    fn transferProtocolFeesForPools(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::transferProtocolFeesForPools)
-                    }
-                    transferProtocolFeesForPools
-                },
-                {
-                    fn executeMetaTransaction(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::executeMetaTransaction)
-                    }
-                    executeMetaTransaction
-                },
-                {
-                    fn getMetaTransactionExecutedBlock(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getMetaTransactionExecutedBlock)
-                    }
-                    getMetaTransactionExecutedBlock
-                },
-                {
-                    fn _fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::_fillLimitOrder)
-                    }
-                    _fillLimitOrder
-                },
-                {
-                    fn transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::transformERC20)
-                    }
-                    transformERC20
-                },
-                {
-                    fn fillOrKillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillOrKillRfqOrder)
-                    }
-                    fillOrKillRfqOrder
-                },
-                {
-                    fn preSignERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::preSignERC721Order)
-                    }
-                    preSignERC721Order
-                },
-                {
-                    fn getProtocolFeeMultiplier(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getProtocolFeeMultiplier)
-                    }
-                    getProtocolFeeMultiplier
-                },
-                {
-                    fn getERC1155OrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getERC1155OrderInfo)
-                    }
-                    getERC1155OrderInfo
-                },
-                {
-                    fn validateERC721OrderProperties(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC721OrderProperties)
-                    }
-                    validateERC721OrderProperties
-                },
-                {
-                    fn _sellHeldTokenForTokenToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::_sellHeldTokenForTokenToUniswapV3)
-                    }
-                    _sellHeldTokenForTokenToUniswapV3
-                },
-                {
-                    fn getTransformerDeployer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getTransformerDeployer)
-                    }
-                    getTransformerDeployer
-                },
-                {
-                    fn fillTakerSignedOtcOrder(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillTakerSignedOtcOrder)
-                    }
-                    fillTakerSignedOtcOrder
-                },
-                {
-                    fn multiplexMultiHopSellEthForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexMultiHopSellEthForToken)
-                    }
-                    multiplexMultiHopSellEthForToken
-                },
-                {
-                    fn getOtcOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::getOtcOrderHash)
-                    }
-                    getOtcOrderHash
-                },
-                {
-                    fn setQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::setQuoteSigner)
-                    }
-                    setQuoteSigner
-                },
-                {
-                    fn lastOtcTxOriginNonce(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::lastOtcTxOriginNonce)
-                    }
-                    lastOtcTxOriginNonce
-                },
-                {
-                    fn sellTokenForTokenToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellTokenForTokenToUniswapV3)
-                    }
-                    sellTokenForTokenToUniswapV3
-                },
-                {
-                    fn isValidOrderSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::isValidOrderSigner)
-                    }
-                    isValidOrderSigner
-                },
-                {
-                    fn getRollbackEntryAtIndex(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getRollbackEntryAtIndex)
-                    }
-                    getRollbackEntryAtIndex
-                },
-                {
-                    fn sellERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::sellERC1155)
-                    }
-                    sellERC1155
-                },
-                {
-                    fn extend(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <extendCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::extend)
-                    }
-                    extend
-                },
-                {
-                    fn fillOtcOrderWithEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillOtcOrderWithEth)
-                    }
-                    fillOtcOrderWithEth
-                },
-                {
-                    fn fillTakerSignedOtcOrderForEth(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillTakerSignedOtcOrderForEth)
-                    }
-                    fillTakerSignedOtcOrderForEth
-                },
-                {
-                    fn getMetaTransactionHashExecutedBlock(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getMetaTransactionHashExecutedBlock)
-                    }
-                    getMetaTransactionHashExecutedBlock
-                },
-                {
-                    fn batchFillRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchFillRfqOrders)
-                    }
-                    batchFillRfqOrders
-                },
-                {
-                    fn supportInterface(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <supportInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::supportInterface)
-                    }
-                    supportInterface
-                },
-                {
-                    fn multiplexBatchSellTokenForEth(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexBatchSellTokenForEth)
-                    }
-                    multiplexBatchSellTokenForEth
-                },
-                {
-                    fn multiplexBatchSellTokenForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexBatchSellTokenForToken)
-                    }
-                    multiplexBatchSellTokenForToken
-                },
-                {
-                    fn preSignERC1155Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::preSignERC1155Order)
-                    }
-                    preSignERC1155Order
-                },
-                {
-                    fn buyERC1155(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <buyERC1155Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::buyERC1155)
-                    }
-                    buyERC1155
-                },
-                {
-                    fn cancelLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::cancelLimitOrder)
-                    }
-                    cancelLimitOrder
-                },
-                {
-                    fn batchMatchERC721Orders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchMatchERC721Orders)
-                    }
-                    batchMatchERC721Orders
-                },
-                {
-                    fn sellTokenForEthToUniswapV3(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellTokenForEthToUniswapV3)
-                    }
-                    sellTokenForEthToUniswapV3
-                },
-                {
-                    fn batchBuyERC1155s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchBuyERC1155s)
-                    }
-                    batchBuyERC1155s
-                },
-                {
-                    fn batchCancelERC721Orders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelERC721Orders)
-                    }
-                    batchCancelERC721Orders
-                },
-                {
-                    fn batchCancelPairLimitOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairLimitOrders)
-                    }
-                    batchCancelPairLimitOrders
-                },
-                {
-                    fn setTransformerDeployer(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::setTransformerDeployer)
-                    }
-                    setTransformerDeployer
-                },
-                {
-                    fn _transformERC20(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_transformERC20Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::_transformERC20)
-                    }
-                    _transformERC20
-                },
-                {
-                    fn getOtcOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::getOtcOrderInfo)
-                    }
-                    getOtcOrderInfo
-                },
-                {
-                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::owner)
-                    }
-                    owner
-                },
-                {
-                    fn fillOrKillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillOrKillLimitOrder)
-                    }
-                    fillOrKillLimitOrder
-                },
-                {
-                    fn cancelPairRfqOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelPairRfqOrdersWithSigner)
-                    }
-                    cancelPairRfqOrdersWithSigner
-                },
-                {
-                    fn getLimitOrderInfo(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getLimitOrderInfo)
-                    }
-                    getLimitOrderInfo
-                },
-                {
-                    fn multiplexMultiHopSellTokenForEth(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexMultiHopSellTokenForEth)
-                    }
-                    multiplexMultiHopSellTokenForEth
-                },
-                {
-                    fn cancelPairRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelPairRfqOrders)
-                    }
-                    cancelPairRfqOrders
-                },
-                {
-                    fn batchCancelLimitOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelLimitOrders)
-                    }
-                    batchCancelLimitOrders
-                },
-                {
-                    fn rollback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <rollbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::rollback)
-                    }
-                    rollback
-                },
-                {
-                    fn batchCancelPairLimitOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairLimitOrdersWithSigner)
-                    }
-                    batchCancelPairLimitOrdersWithSigner
-                },
-                {
-                    fn getQuoteSigner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::getQuoteSigner)
-                    }
-                    getQuoteSigner
-                },
-                {
-                    fn batchCancelERC1155Orders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelERC1155Orders)
-                    }
-                    batchCancelERC1155Orders
-                },
-                {
-                    fn fillOtcOrderForEth(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::fillOtcOrderForEth)
-                    }
-                    fillOtcOrderForEth
-                },
-                {
-                    fn _fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::_fillRfqOrder)
-                    }
-                    _fillRfqOrder
-                },
-                {
-                    fn fillRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::fillRfqOrder)
-                    }
-                    fillRfqOrder
-                },
-                {
-                    fn batchGetRfqOrderRelevantStates(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchGetRfqOrderRelevantStates)
-                    }
-                    batchGetRfqOrderRelevantStates
-                },
-                {
-                    fn getMetaTransactionHash(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getMetaTransactionHash)
-                    }
-                    getMetaTransactionHash
-                },
-                {
-                    fn sellERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellERC721Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::sellERC721)
-                    }
-                    sellERC721
-                },
-                {
-                    fn registerAllowedRfqOrigins(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::registerAllowedRfqOrigins)
-                    }
-                    registerAllowedRfqOrigins
-                },
-                {
-                    fn cancelPairLimitOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelPairLimitOrdersWithSigner)
-                    }
-                    cancelPairLimitOrdersWithSigner
-                },
-                {
-                    fn batchGetLimitOrderRelevantStates(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchGetLimitOrderRelevantStates)
-                    }
-                    batchGetLimitOrderRelevantStates
-                },
-                {
-                    fn getERC721OrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getERC721OrderHash)
-                    }
-                    getERC721OrderHash
-                },
-                {
-                    fn cancelERC721Order(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelERC721Order)
-                    }
-                    cancelERC721Order
-                },
-                {
-                    fn sellToPancakeSwap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellToPancakeSwap)
-                    }
-                    sellToPancakeSwap
-                },
-                {
-                    fn batchExecuteMetaTransactions(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchExecuteMetaTransactions)
-                    }
-                    batchExecuteMetaTransactions
-                },
-                {
-                    fn cancelPairLimitOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::cancelPairLimitOrders)
-                    }
-                    cancelPairLimitOrders
-                },
-                {
-                    fn validateERC721OrderSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::validateERC721OrderSignature)
-                    }
-                    validateERC721OrderSignature
-                },
-                {
-                    fn sellToUniswap(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellToUniswapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::sellToUniswap)
-                    }
-                    sellToUniswap
-                },
-                {
-                    fn fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::fillOtcOrder)
-                    }
-                    fillOtcOrder
-                },
-                {
-                    fn getLimitOrderHash(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getLimitOrderHash)
-                    }
-                    getLimitOrderHash
-                },
-                {
-                    fn getRollbackLength(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getRollbackLength)
-                    }
-                    getRollbackLength
-                },
-                {
-                    fn _fillOtcOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::_fillOtcOrder)
-                    }
-                    _fillOtcOrder
-                },
-                {
-                    fn batchFillTakerSignedOtcOrders(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchFillTakerSignedOtcOrders)
-                    }
-                    batchFillTakerSignedOtcOrders
-                },
-                {
-                    fn registerAllowedOrderSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::registerAllowedOrderSigner)
-                    }
-                    registerAllowedOrderSigner
-                },
-                {
-                    fn batchBuyERC721s(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::batchBuyERC721s)
-                    }
-                    batchBuyERC721s
-                },
-                {
-                    fn getTransformWallet(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getTransformWalletCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getTransformWallet)
-                    }
-                    getTransformWallet
-                },
-                {
-                    fn onERC1155Received(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::onERC1155Received)
-                    }
-                    onERC1155Received
-                },
-                {
-                    fn transferOwnership(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::transferOwnership)
-                    }
-                    transferOwnership
-                },
-                {
-                    fn multiplexBatchSellEthForToken(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::multiplexBatchSellEthForToken)
-                    }
-                    multiplexBatchSellEthForToken
-                },
-                {
-                    fn fillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::fillLimitOrder)
-                    }
-                    fillLimitOrder
-                },
-                {
-                    fn batchCancelRfqOrders(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelRfqOrders)
-                    }
-                    batchCancelRfqOrders
-                },
-                {
-                    fn sellToLiquidityProvider(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::sellToLiquidityProvider)
-                    }
-                    sellToLiquidityProvider
-                },
-                {
-                    fn uniswapV3SwapCallback(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::uniswapV3SwapCallback)
-                    }
-                    uniswapV3SwapCallback
-                },
-                {
-                    fn getERC721OrderStatus(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::getERC721OrderStatus)
-                    }
-                    getERC721OrderStatus
-                },
-                {
-                    fn buyERC721(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <buyERC721Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(IZeroexCalls::buyERC721)
-                    }
-                    buyERC721
-                },
-                {
-                    fn batchCancelPairRfqOrdersWithSigner(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(IZeroexCalls::batchCancelPairRfqOrdersWithSigner)
-                    }
-                    batchCancelPairRfqOrdersWithSigner
-                },
-                {
-                    fn cancelRfqOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
-                        <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(IZeroexCalls::cancelRfqOrder)
-                    }
-                    cancelRfqOrder
-                },
-            ];
-            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
-                return Err(alloy_sol_types::Error::unknown_selector(
-                    <Self as alloy_sol_types::SolInterface>::NAME,
-                    selector,
-                ));
-            };
-            DECODE_VALIDATE_SHIMS[idx](data)
-        }
-
-        #[inline]
-        fn abi_encoded_size(&self) -> usize {
-            match self {
-                Self::_fillLimitOrder(inner) => {
-                    <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::_fillOtcOrder(inner) => {
-                    <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::_fillRfqOrder(inner) => {
-                    <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::_sellHeldTokenForTokenToUniswapV3(inner) => {
-                    <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::_transformERC20(inner) => {
-                    <_transformERC20Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchBuyERC1155s(inner) => {
-                    <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchBuyERC721s(inner) => {
-                    <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelERC1155Orders(inner) => {
-                    <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelERC721Orders(inner) => {
-                    <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelLimitOrders(inner) => {
-                    <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelPairLimitOrders(inner) => {
-                    <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelPairLimitOrdersWithSigner(inner) => {
-                    <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelPairRfqOrders(inner) => {
-                    <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelPairRfqOrdersWithSigner(inner) => {
-                    <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchCancelRfqOrders(inner) => {
-                    <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchExecuteMetaTransactions(inner) => {
-                    <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchFillLimitOrders(inner) => {
-                    <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchFillRfqOrders(inner) => {
-                    <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchFillTakerSignedOtcOrders(inner) => {
-                    <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchGetLimitOrderRelevantStates(inner) => {
-                    <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchGetRfqOrderRelevantStates(inner) => {
-                    <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::batchMatchERC721Orders(inner) => {
-                    <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::buyERC1155(inner) => {
-                    <buyERC1155Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::buyERC721(inner) => {
-                    <buyERC721Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::cancelERC1155Order(inner) => {
-                    <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelERC721Order(inner) => {
-                    <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelLimitOrder(inner) => {
-                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelPairLimitOrders(inner) => {
-                    <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelPairLimitOrdersWithSigner(inner) => {
-                    <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelPairRfqOrders(inner) => {
-                    <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelPairRfqOrdersWithSigner(inner) => {
-                    <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::cancelRfqOrder(inner) => {
-                    <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::createTransformWallet(inner) => {
-                    <createTransformWalletCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::executeMetaTransaction(inner) => {
-                    <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::extend(inner) => {
-                    <extendCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::fillLimitOrder(inner) => {
-                    <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillOrKillLimitOrder(inner) => {
-                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillOrKillRfqOrder(inner) => {
-                    <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillOtcOrder(inner) => {
-                    <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillOtcOrderForEth(inner) => {
-                    <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillOtcOrderWithEth(inner) => {
-                    <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillRfqOrder(inner) => {
-                    <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillTakerSignedOtcOrder(inner) => {
-                    <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::fillTakerSignedOtcOrderForEth(inner) => {
-                    <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getERC1155OrderHash(inner) => {
-                    <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getERC1155OrderInfo(inner) => {
-                    <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getERC721OrderHash(inner) => {
-                    <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getERC721OrderStatus(inner) => {
-                    <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getERC721OrderStatusBitVector(inner) => {
-                    <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getLimitOrderHash(inner) => {
-                    <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getLimitOrderInfo(inner) => {
-                    <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getLimitOrderRelevantState(inner) => {
-                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getMetaTransactionExecutedBlock(inner) => {
-                    <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getMetaTransactionHash(inner) => {
-                    <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getMetaTransactionHashExecutedBlock(inner) => {
-                    <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getOtcOrderHash(inner) => {
-                    <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getOtcOrderInfo(inner) => {
-                    <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getProtocolFeeMultiplier(inner) => {
-                    <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getQuoteSigner(inner) => {
-                    <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getRfqOrderHash(inner) => {
-                    <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getRfqOrderInfo(inner) => {
-                    <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getRfqOrderRelevantState(inner) => {
-                    <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getRollbackEntryAtIndex(inner) => {
-                    <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getRollbackLength(inner) => {
-                    <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTransformWallet(inner) => {
-                    <getTransformWalletCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getTransformerDeployer(inner) => {
-                    <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::isValidOrderSigner(inner) => {
-                    <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::lastOtcTxOriginNonce(inner) => {
-                    <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::matchERC721Orders(inner) => {
-                    <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::migrate(inner) => {
-                    <migrateCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::multiplexBatchSellEthForToken(inner) => {
-                    <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::multiplexBatchSellTokenForEth(inner) => {
-                    <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::multiplexBatchSellTokenForToken(inner) => {
-                    <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::multiplexMultiHopSellEthForToken(inner) => {
-                    <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::multiplexMultiHopSellTokenForEth(inner) => {
-                    <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::multiplexMultiHopSellTokenForToken(inner) => {
-                    <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::onERC1155Received(inner) => {
-                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::onERC721Received(inner) => {
-                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::owner(inner) => {
-                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::preSignERC1155Order(inner) => {
-                    <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::preSignERC721Order(inner) => {
-                    <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::registerAllowedOrderSigner(inner) => {
-                    <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::registerAllowedRfqOrigins(inner) => {
-                    <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::rollback(inner) => {
-                    <rollbackCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::sellERC1155(inner) => {
-                    <sellERC1155Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::sellERC721(inner) => {
-                    <sellERC721Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::sellEthForTokenToUniswapV3(inner) => {
-                    <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::sellToLiquidityProvider(inner) => {
-                    <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::sellToPancakeSwap(inner) => {
-                    <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::sellToUniswap(inner) => {
-                    <sellToUniswapCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::sellTokenForEthToUniswapV3(inner) => {
-                    <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::sellTokenForTokenToUniswapV3(inner) => {
-                    <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setQuoteSigner(inner) => {
-                    <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setTransformerDeployer(inner) => {
-                    <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::supportInterface(inner) => {
-                    <supportInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::transferOwnership(inner) => {
-                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::transferProtocolFeesForPools(inner) => {
-                    <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::transferTrappedTokensTo(inner) => {
-                    <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::transformERC20(inner) => {
-                    <transformERC20Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::uniswapV3SwapCallback(inner) => {
-                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateERC1155OrderProperties(inner) => {
-                    <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateERC1155OrderSignature(inner) => {
-                    <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateERC721OrderProperties(inner) => {
-                    <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateERC721OrderSignature(inner) => {
-                    <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-            }
-        }
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "extend",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "internalType": "bytes4"
+      },
+      {
+        "name": "impl",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "fillOrKillLimitOrder",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      },
+      {
+        "name": "takerTokenFillAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      }
+    ],
+    "stateMutability": "payable"
+  },
+  {
+    "type": "function",
+    "name": "getLimitOrderRelevantState",
+    "inputs": [
+      {
+        "name": "order",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.LimitOrder",
+        "components": [
+          {
+            "name": "makerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "takerToken",
+            "type": "address",
+            "internalType": "contract IERC20TokenV06"
+          },
+          {
+            "name": "makerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "takerTokenFeeAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          },
+          {
+            "name": "maker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "taker",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "feeRecipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "pool",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "expiry",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "salt",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "tuple",
+        "internalType": "struct LibSignature.Signature",
+        "components": [
+          {
+            "name": "signatureType",
+            "type": "uint8",
+            "internalType": "enum LibSignature.SignatureType"
+          },
+          {
+            "name": "v",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "r",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "s",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          }
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "orderInfo",
+        "type": "tuple",
+        "internalType": "struct LibNativeOrder.OrderInfo",
+        "components": [
+          {
+            "name": "orderHash",
+            "type": "bytes32",
+            "internalType": "bytes32"
+          },
+          {
+            "name": "status",
+            "type": "uint8",
+            "internalType": "enum LibNativeOrder.OrderStatus"
+          },
+          {
+            "name": "takerTokenFilledAmount",
+            "type": "uint128",
+            "internalType": "uint128"
+          }
+        ]
+      },
+      {
+        "name": "actualFillableTakerTokenAmount",
+        "type": "uint128",
+        "internalType": "uint128"
+      },
+      {
+        "name": "isSignatureValid",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "owner",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "ownerAddress",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "ERC1155OrderCancelled",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC1155OrderFilled",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20FillAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC1155Token"
+      },
+      {
+        "name": "erc1155TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155FillAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "matcher",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC1155OrderPreSigned",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "expiry",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20TokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "fees",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Fee[]",
+        "components": [
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "erc1155Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC1155Token"
+      },
+      {
+        "name": "erc1155TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc1155TokenProperties",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Property[]",
+        "components": [
+          {
+            "name": "propertyValidator",
+            "type": "address",
+            "internalType": "contract IPropertyValidator"
+          },
+          {
+            "name": "propertyData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "erc1155TokenAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC721OrderCancelled",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC721OrderFilled",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20TokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc721Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC721Token"
+      },
+      {
+        "name": "erc721TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "matcher",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ERC721OrderPreSigned",
+    "inputs": [
+      {
+        "name": "direction",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "enum LibNFTOrder.TradeDirection"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "expiry",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc20Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "erc20TokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "fees",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Fee[]",
+        "components": [
+          {
+            "name": "recipient",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "feeData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      },
+      {
+        "name": "erc721Token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC721Token"
+      },
+      {
+        "name": "erc721TokenId",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "erc721TokenProperties",
+        "type": "tuple[]",
+        "indexed": false,
+        "internalType": "struct LibNFTOrder.Property[]",
+        "components": [
+          {
+            "name": "propertyValidator",
+            "type": "address",
+            "internalType": "contract IPropertyValidator"
+          },
+          {
+            "name": "propertyData",
+            "type": "bytes",
+            "internalType": "bytes"
+          }
+        ]
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "LimitOrderFilled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "feeRecipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "takerTokenFeeFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "protocolFeePaid",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "pool",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "LiquidityProviderSwap",
+    "inputs": [
+      {
+        "name": "inputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract IERC20TokenV06"
+      },
+      {
+        "name": "inputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "outputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "provider",
+        "type": "address",
+        "indexed": false,
+        "internalType": "contract ILiquidityProvider"
+      },
+      {
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "MetaTransactionExecuted",
+    "inputs": [
+      {
+        "name": "hash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": true,
+        "internalType": "bytes4"
+      },
+      {
+        "name": "signer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Migrated",
+    "inputs": [
+      {
+        "name": "caller",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "migrator",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderCancelled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OrderSignerRegistered",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "signer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OtcOrderFilled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "OwnershipTransferred",
+    "inputs": [
+      {
+        "name": "previousOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newOwner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PairCancelledLimitOrders",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "PairCancelledRfqOrders",
+    "inputs": [
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "minValidSalt",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ProxyFunctionUpdated",
+    "inputs": [
+      {
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": true,
+        "internalType": "bytes4"
+      },
+      {
+        "name": "oldImpl",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "newImpl",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "QuoteSignerUpdated",
+    "inputs": [
+      {
+        "name": "quoteSigner",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RfqOrderFilled",
+    "inputs": [
+      {
+        "name": "orderHash",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "maker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "makerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "takerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "makerTokenFilledAmount",
+        "type": "uint128",
+        "indexed": false,
+        "internalType": "uint128"
+      },
+      {
+        "name": "pool",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RfqOrderOriginsAllowed",
+    "inputs": [
+      {
+        "name": "origin",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "addrs",
+        "type": "address[]",
+        "indexed": false,
+        "internalType": "address[]"
+      },
+      {
+        "name": "allowed",
+        "type": "bool",
+        "indexed": false,
+        "internalType": "bool"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TransformedERC20",
+    "inputs": [
+      {
+        "name": "taker",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "inputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "outputToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "inputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "outputTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TransformerDeployerUpdated",
+    "inputs": [
+      {
+        "name": "transformerDeployer",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IZeroex {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC1155OrderCancelled(address,uint256)` and selector `0x4d5ea7da64f50a4a329921b8d2cab52dff4ebcc58b61d10ff839e28e91445684`.
+    ```solidity
+    event ERC1155OrderCancelled(address maker, uint256 nonce);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC1155OrderCancelled {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC1155OrderCancelled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-        #[inline]
-        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-            match self {
-                Self::_fillLimitOrder(inner) => {
-                    <_fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::_fillOtcOrder(inner) => {
-                    <_fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::_fillRfqOrder(inner) => {
-                    <_fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::_sellHeldTokenForTokenToUniswapV3(inner) => {
-                    <_sellHeldTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::_transformERC20(inner) => {
-                    <_transformERC20Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchBuyERC1155s(inner) => {
-                    <batchBuyERC1155sCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchBuyERC721s(inner) => {
-                    <batchBuyERC721sCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelERC1155Orders(inner) => {
-                    <batchCancelERC1155OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelERC721Orders(inner) => {
-                    <batchCancelERC721OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelLimitOrders(inner) => {
-                    <batchCancelLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelPairLimitOrders(inner) => {
-                    <batchCancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelPairLimitOrdersWithSigner(inner) => {
-                    <batchCancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelPairRfqOrders(inner) => {
-                    <batchCancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelPairRfqOrdersWithSigner(inner) => {
-                    <batchCancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchCancelRfqOrders(inner) => {
-                    <batchCancelRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchExecuteMetaTransactions(inner) => {
-                    <batchExecuteMetaTransactionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchFillLimitOrders(inner) => {
-                    <batchFillLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchFillRfqOrders(inner) => {
-                    <batchFillRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchFillTakerSignedOtcOrders(inner) => {
-                    <batchFillTakerSignedOtcOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchGetLimitOrderRelevantStates(inner) => {
-                    <batchGetLimitOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchGetRfqOrderRelevantStates(inner) => {
-                    <batchGetRfqOrderRelevantStatesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::batchMatchERC721Orders(inner) => {
-                    <batchMatchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::buyERC1155(inner) => {
-                    <buyERC1155Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::buyERC721(inner) => {
-                    <buyERC721Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelERC1155Order(inner) => {
-                    <cancelERC1155OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelERC721Order(inner) => {
-                    <cancelERC721OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelLimitOrder(inner) => {
-                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelPairLimitOrders(inner) => {
-                    <cancelPairLimitOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelPairLimitOrdersWithSigner(inner) => {
-                    <cancelPairLimitOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelPairRfqOrders(inner) => {
-                    <cancelPairRfqOrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelPairRfqOrdersWithSigner(inner) => {
-                    <cancelPairRfqOrdersWithSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelRfqOrder(inner) => {
-                    <cancelRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::createTransformWallet(inner) => {
-                    <createTransformWalletCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::executeMetaTransaction(inner) => {
-                    <executeMetaTransactionCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::extend(inner) => {
-                    <extendCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::fillLimitOrder(inner) => {
-                    <fillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillOrKillLimitOrder(inner) => {
-                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillOrKillRfqOrder(inner) => {
-                    <fillOrKillRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillOtcOrder(inner) => {
-                    <fillOtcOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillOtcOrderForEth(inner) => {
-                    <fillOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillOtcOrderWithEth(inner) => {
-                    <fillOtcOrderWithEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillRfqOrder(inner) => {
-                    <fillRfqOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillTakerSignedOtcOrder(inner) => {
-                    <fillTakerSignedOtcOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::fillTakerSignedOtcOrderForEth(inner) => {
-                    <fillTakerSignedOtcOrderForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getERC1155OrderHash(inner) => {
-                    <getERC1155OrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getERC1155OrderInfo(inner) => {
-                    <getERC1155OrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getERC721OrderHash(inner) => {
-                    <getERC721OrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getERC721OrderStatus(inner) => {
-                    <getERC721OrderStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getERC721OrderStatusBitVector(inner) => {
-                    <getERC721OrderStatusBitVectorCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getLimitOrderHash(inner) => {
-                    <getLimitOrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getLimitOrderInfo(inner) => {
-                    <getLimitOrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getLimitOrderRelevantState(inner) => {
-                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getMetaTransactionExecutedBlock(inner) => {
-                    <getMetaTransactionExecutedBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getMetaTransactionHash(inner) => {
-                    <getMetaTransactionHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getMetaTransactionHashExecutedBlock(inner) => {
-                    <getMetaTransactionHashExecutedBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getOtcOrderHash(inner) => {
-                    <getOtcOrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getOtcOrderInfo(inner) => {
-                    <getOtcOrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getProtocolFeeMultiplier(inner) => {
-                    <getProtocolFeeMultiplierCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getQuoteSigner(inner) => {
-                    <getQuoteSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getRfqOrderHash(inner) => {
-                    <getRfqOrderHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getRfqOrderInfo(inner) => {
-                    <getRfqOrderInfoCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getRfqOrderRelevantState(inner) => {
-                    <getRfqOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getRollbackEntryAtIndex(inner) => {
-                    <getRollbackEntryAtIndexCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getRollbackLength(inner) => {
-                    <getRollbackLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getTransformWallet(inner) => {
-                    <getTransformWalletCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getTransformerDeployer(inner) => {
-                    <getTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::isValidOrderSigner(inner) => {
-                    <isValidOrderSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::lastOtcTxOriginNonce(inner) => {
-                    <lastOtcTxOriginNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::matchERC721Orders(inner) => {
-                    <matchERC721OrdersCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::migrate(inner) => {
-                    <migrateCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::multiplexBatchSellEthForToken(inner) => {
-                    <multiplexBatchSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::multiplexBatchSellTokenForEth(inner) => {
-                    <multiplexBatchSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC1155OrderCancelled(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    77u8, 94u8, 167u8, 218u8, 100u8, 245u8, 10u8, 74u8, 50u8, 153u8, 33u8, 184u8,
+                    210u8, 202u8, 181u8, 45u8, 255u8, 78u8, 188u8, 197u8, 139u8, 97u8, 209u8, 15u8,
+                    248u8, 57u8, 226u8, 142u8, 145u8, 68u8, 86u8, 132u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    nonce: data.1,
                 }
-                Self::multiplexBatchSellTokenForToken(inner) => {
-                    <multiplexBatchSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::multiplexMultiHopSellEthForToken(inner) => {
-                    <multiplexMultiHopSellEthForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::multiplexMultiHopSellTokenForEth(inner) => {
-                    <multiplexMultiHopSellTokenForEthCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC1155OrderCancelled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC1155OrderCancelled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC1155OrderCancelled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC1155OrderFilled(uint8,address,address,uint256,address,uint256,address,uint256,uint128,address)` and selector `0x20cca81b0e269b265b3229d6b537da91ef475ca0ef55caed7dd30731700ba98d`.
+    ```solidity
+    event ERC1155OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20FillAmount, address erc1155Token, uint256 erc1155TokenId, uint128 erc1155FillAmount, address matcher);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC1155OrderFilled {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20FillAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155FillAmount: u128,
+        #[allow(missing_docs)]
+        pub matcher: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC1155OrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC1155OrderFilled(uint8,address,address,uint256,\
+                                             address,uint256,address,uint256,uint128,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    32u8, 204u8, 168u8, 27u8, 14u8, 38u8, 155u8, 38u8, 91u8, 50u8, 41u8, 214u8,
+                    181u8, 55u8, 218u8, 145u8, 239u8, 71u8, 92u8, 160u8, 239u8, 85u8, 202u8, 237u8,
+                    125u8, 211u8, 7u8, 49u8, 112u8, 11u8, 169u8, 141u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    nonce: data.3,
+                    erc20Token: data.4,
+                    erc20FillAmount: data.5,
+                    erc1155Token: data.6,
+                    erc1155TokenId: data.7,
+                    erc1155FillAmount: data.8,
+                    matcher: data.9,
                 }
-                Self::multiplexMultiHopSellTokenForToken(inner) => {
-                    <multiplexMultiHopSellTokenForTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::onERC1155Received(inner) => {
-                    <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20FillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155FillAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.matcher,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::onERC721Received(inner) => {
-                    <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC1155OrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC1155OrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC1155OrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC1155OrderPreSigned(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[],uint128)` and selector `0x5e91ddfeb7bf2e12f7e8ab017d2b63a9217f004a15a53346ad90353ec63d14e4`.
+    ```solidity
+    event ERC1155OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc1155Token, uint256 erc1155TokenId, LibNFTOrder.Property[] erc1155TokenProperties, uint128 erc1155TokenAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC1155OrderPreSigned {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fees:
+            alloy_sol_types::private::Vec<<LibNFTOrder::Fee as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc1155Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc1155TokenProperties: alloy_sol_types::private::Vec<
+            <LibNFTOrder::Property as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub erc1155TokenAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC1155OrderPreSigned {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Fee>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Property>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC1155OrderPreSigned(uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[],uint128)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    94u8, 145u8, 221u8, 254u8, 183u8, 191u8, 46u8, 18u8, 247u8, 232u8, 171u8, 1u8,
+                    125u8, 43u8, 99u8, 169u8, 33u8, 127u8, 0u8, 74u8, 21u8, 165u8, 51u8, 70u8,
+                    173u8, 144u8, 53u8, 62u8, 198u8, 61u8, 20u8, 228u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    expiry: data.3,
+                    nonce: data.4,
+                    erc20Token: data.5,
+                    erc20TokenAmount: data.6,
+                    fees: data.7,
+                    erc1155Token: data.8,
+                    erc1155TokenId: data.9,
+                    erc1155TokenProperties: data.10,
+                    erc1155TokenAmount: data.11,
                 }
-                Self::owner(inner) => {
-                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::preSignERC1155Order(inner) => {
-                    <preSignERC1155OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Fee,
+                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenId),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Property,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.erc1155TokenProperties,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc1155TokenAmount),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::preSignERC721Order(inner) => {
-                    <preSignERC721OrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC1155OrderPreSigned {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC1155OrderPreSigned> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC1155OrderPreSigned) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC721OrderCancelled(address,uint256)` and selector `0xa015ad2dc32f266993958a0fd9884c746b971b254206f3478bc43e2f125c7b9e`.
+    ```solidity
+    event ERC721OrderCancelled(address maker, uint256 nonce);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC721OrderCancelled {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC721OrderCancelled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC721OrderCancelled(address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    160u8, 21u8, 173u8, 45u8, 195u8, 47u8, 38u8, 105u8, 147u8, 149u8, 138u8, 15u8,
+                    217u8, 136u8, 76u8, 116u8, 107u8, 151u8, 27u8, 37u8, 66u8, 6u8, 243u8, 71u8,
+                    139u8, 196u8, 62u8, 47u8, 18u8, 92u8, 123u8, 158u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    nonce: data.1,
                 }
-                Self::registerAllowedOrderSigner(inner) => {
-                    <registerAllowedOrderSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::registerAllowedRfqOrigins(inner) => {
-                    <registerAllowedRfqOriginsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::rollback(inner) => {
-                    <rollbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC721OrderCancelled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC721OrderCancelled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC721OrderCancelled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC721OrderFilled(uint8,address,address,uint256,address,uint256,address,uint256,address)` and selector `0x50273fa02273cceea9cf085b42de5c8af60624140168bd71357db833535877af`.
+    ```solidity
+    event ERC721OrderFilled(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, address erc721Token, uint256 erc721TokenId, address matcher);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC721OrderFilled {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc721Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub matcher: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC721OrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC721OrderFilled(uint8,address,address,uint256,\
+                                             address,uint256,address,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    80u8, 39u8, 63u8, 160u8, 34u8, 115u8, 204u8, 238u8, 169u8, 207u8, 8u8, 91u8,
+                    66u8, 222u8, 92u8, 138u8, 246u8, 6u8, 36u8, 20u8, 1u8, 104u8, 189u8, 113u8,
+                    53u8, 125u8, 184u8, 51u8, 83u8, 88u8, 119u8, 175u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    nonce: data.3,
+                    erc20Token: data.4,
+                    erc20TokenAmount: data.5,
+                    erc721Token: data.6,
+                    erc721TokenId: data.7,
+                    matcher: data.8,
                 }
-                Self::sellERC1155(inner) => {
-                    <sellERC1155Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::sellERC721(inner) => {
-                    <sellERC721Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20TokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721TokenId,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.matcher,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::sellEthForTokenToUniswapV3(inner) => {
-                    <sellEthForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC721OrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC721OrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC721OrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ERC721OrderPreSigned(uint8,address,address,uint256,uint256,address,uint256,(address,uint256,bytes)[],address,uint256,(address,bytes)[])` and selector `0x8c5d0c41fb16a7317a6c55ff7ba93d9d74f79e434fefa694e50d6028afbfa3f0`.
+    ```solidity
+    event ERC721OrderPreSigned(LibNFTOrder.TradeDirection direction, address maker, address taker, uint256 expiry, uint256 nonce, address erc20Token, uint256 erc20TokenAmount, LibNFTOrder.Fee[] fees, address erc721Token, uint256 erc721TokenId, LibNFTOrder.Property[] erc721TokenProperties);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ERC721OrderPreSigned {
+        #[allow(missing_docs)]
+        pub direction: <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub expiry: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc20Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc20TokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub fees:
+            alloy_sol_types::private::Vec<<LibNFTOrder::Fee as alloy_sol_types::SolType>::RustType>,
+        #[allow(missing_docs)]
+        pub erc721Token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub erc721TokenProperties: alloy_sol_types::private::Vec<
+            <LibNFTOrder::Property as alloy_sol_types::SolType>::RustType,
+        >,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ERC721OrderPreSigned {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                LibNFTOrder::TradeDirection,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Fee>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Array<LibNFTOrder::Property>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ERC721OrderPreSigned(uint8,address,address,uint256,\
+                                             uint256,address,uint256,(address,uint256,bytes)[],\
+                                             address,uint256,(address,bytes)[])";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    140u8, 93u8, 12u8, 65u8, 251u8, 22u8, 167u8, 49u8, 122u8, 108u8, 85u8, 255u8,
+                    123u8, 169u8, 61u8, 157u8, 116u8, 247u8, 158u8, 67u8, 79u8, 239u8, 166u8,
+                    148u8, 229u8, 13u8, 96u8, 40u8, 175u8, 191u8, 163u8, 240u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    direction: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    expiry: data.3,
+                    nonce: data.4,
+                    erc20Token: data.5,
+                    erc20TokenAmount: data.6,
+                    fees: data.7,
+                    erc721Token: data.8,
+                    erc721TokenId: data.9,
+                    erc721TokenProperties: data.10,
                 }
-                Self::sellToLiquidityProvider(inner) => {
-                    <sellToLiquidityProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::sellToPancakeSwap(inner) => {
-                    <sellToPancakeSwapCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <LibNFTOrder::TradeDirection as alloy_sol_types::SolType>::tokenize(
+                        &self.direction,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc20Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc20TokenAmount),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Fee,
+                    > as alloy_sol_types::SolType>::tokenize(&self.fees),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.erc721Token,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenId),
+                    <alloy_sol_types::sol_data::Array<
+                        LibNFTOrder::Property,
+                    > as alloy_sol_types::SolType>::tokenize(&self.erc721TokenProperties),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::sellToUniswap(inner) => {
-                    <sellToUniswapCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ERC721OrderPreSigned {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&ERC721OrderPreSigned> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ERC721OrderPreSigned) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `LimitOrderFilled(bytes32,address,address,address,address,address,uint128,uint128,uint128,uint256,bytes32)` and selector `0xab614d2b738543c0ea21f56347cf696a3a0c42a7cbec3212a5ca22a4dcff2124`.
+    ```solidity
+    event LimitOrderFilled(bytes32 orderHash, address maker, address taker, address feeRecipient, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, uint128 takerTokenFeeFilledAmount, uint256 protocolFeePaid, bytes32 pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct LimitOrderFilled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub feeRecipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub takerTokenFeeFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub protocolFeePaid: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for LimitOrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "LimitOrderFilled(bytes32,address,address,address,\
+                                             address,address,uint128,uint128,uint128,uint256,\
+                                             bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    171u8, 97u8, 77u8, 43u8, 115u8, 133u8, 67u8, 192u8, 234u8, 33u8, 245u8, 99u8,
+                    71u8, 207u8, 105u8, 106u8, 58u8, 12u8, 66u8, 167u8, 203u8, 236u8, 50u8, 18u8,
+                    165u8, 202u8, 34u8, 164u8, 220u8, 255u8, 33u8, 36u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    feeRecipient: data.3,
+                    makerToken: data.4,
+                    takerToken: data.5,
+                    takerTokenFilledAmount: data.6,
+                    makerTokenFilledAmount: data.7,
+                    takerTokenFeeFilledAmount: data.8,
+                    protocolFeePaid: data.9,
+                    pool: data.10,
                 }
-                Self::sellTokenForEthToUniswapV3(inner) => {
-                    <sellTokenForEthToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::sellTokenForTokenToUniswapV3(inner) => {
-                    <sellTokenForTokenToUniswapV3Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.feeRecipient,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFeeFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.protocolFeePaid),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::setQuoteSigner(inner) => {
-                    <setQuoteSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for LimitOrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&LimitOrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &LimitOrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `LiquidityProviderSwap(address,address,uint256,uint256,address,address)` and selector `0x40a6ba9513d09e3488135e0e0d10e2d4382b792720155b144cbea89ac9db6d34`.
+    ```solidity
+    event LiquidityProviderSwap(address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount, address provider, address recipient);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct LiquidityProviderSwap {
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub provider: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for LiquidityProviderSwap {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "LiquidityProviderSwap(address,address,uint256,uint256,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    64u8, 166u8, 186u8, 149u8, 19u8, 208u8, 158u8, 52u8, 136u8, 19u8, 94u8, 14u8,
+                    13u8, 16u8, 226u8, 212u8, 56u8, 43u8, 121u8, 39u8, 32u8, 21u8, 91u8, 20u8,
+                    76u8, 190u8, 168u8, 154u8, 201u8, 219u8, 109u8, 52u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    inputToken: data.0,
+                    outputToken: data.1,
+                    inputTokenAmount: data.2,
+                    outputTokenAmount: data.3,
+                    provider: data.4,
+                    recipient: data.5,
                 }
-                Self::setTransformerDeployer(inner) => {
-                    <setTransformerDeployerCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::supportInterface(inner) => {
-                    <supportInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.inputTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.outputTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.provider,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::transferOwnership(inner) => {
-                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for LiquidityProviderSwap {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&LiquidityProviderSwap> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &LiquidityProviderSwap) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `MetaTransactionExecuted(bytes32,bytes4,address,address)` and selector `0x7f4fe3ff8ae440e1570c558da08440b26f89fb1c1f2910cd91ca6452955f121a`.
+    ```solidity
+    event MetaTransactionExecuted(bytes32 hash, bytes4 indexed selector, address signer, address sender);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct MetaTransactionExecuted {
+        #[allow(missing_docs)]
+        pub hash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub sender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for MetaTransactionExecuted {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "MetaTransactionExecuted(bytes32,bytes4,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    127u8, 79u8, 227u8, 255u8, 138u8, 228u8, 64u8, 225u8, 87u8, 12u8, 85u8, 141u8,
+                    160u8, 132u8, 64u8, 178u8, 111u8, 137u8, 251u8, 28u8, 31u8, 41u8, 16u8, 205u8,
+                    145u8, 202u8, 100u8, 82u8, 149u8, 95u8, 18u8, 26u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    hash: data.0,
+                    selector: topics.1,
+                    signer: data.1,
+                    sender: data.2,
                 }
-                Self::transferProtocolFeesForPools(inner) => {
-                    <transferProtocolFeesForPoolsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::transferTrappedTokensTo(inner) => {
-                    <transferTrappedTokensToCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.hash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.sender,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.selector.clone())
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::transformERC20(inner) => {
-                    <transformERC20Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    4,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.selector);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for MetaTransactionExecuted {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&MetaTransactionExecuted> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &MetaTransactionExecuted) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Migrated(address,address,address)` and selector `0xe1b831b0e6f3aa16b4b1a6bd526b5cdeab4940744ca6e0251f5fe5f8caf1c81a`.
+    ```solidity
+    event Migrated(address caller, address migrator, address newOwner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Migrated {
+        #[allow(missing_docs)]
+        pub caller: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub migrator: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Migrated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Migrated(address,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    225u8, 184u8, 49u8, 176u8, 230u8, 243u8, 170u8, 22u8, 180u8, 177u8, 166u8,
+                    189u8, 82u8, 107u8, 92u8, 222u8, 171u8, 73u8, 64u8, 116u8, 76u8, 166u8, 224u8,
+                    37u8, 31u8, 95u8, 229u8, 248u8, 202u8, 241u8, 200u8, 26u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    caller: data.0,
+                    migrator: data.1,
+                    newOwner: data.2,
                 }
-                Self::uniswapV3SwapCallback(inner) => {
-                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::validateERC1155OrderProperties(inner) => {
-                    <validateERC1155OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.caller,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.migrator,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newOwner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::validateERC1155OrderSignature(inner) => {
-                    <validateERC1155OrderSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Migrated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Migrated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Migrated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderCancelled(bytes32,address)` and selector `0xa6eb7cdc219e1518ced964e9a34e61d68a94e4f1569db3e84256ba981ba52753`.
+    ```solidity
+    event OrderCancelled(bytes32 orderHash, address maker);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderCancelled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderCancelled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderCancelled(bytes32,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    166u8, 235u8, 124u8, 220u8, 33u8, 158u8, 21u8, 24u8, 206u8, 217u8, 100u8,
+                    233u8, 163u8, 78u8, 97u8, 214u8, 138u8, 148u8, 228u8, 241u8, 86u8, 157u8,
+                    179u8, 232u8, 66u8, 86u8, 186u8, 152u8, 27u8, 165u8, 39u8, 83u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
                 }
-                Self::validateERC721OrderProperties(inner) => {
-                    <validateERC721OrderPropertiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::validateERC721OrderSignature(inner) => {
-                    <validateERC721OrderSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-    }
-    ///Container for all the [`IZeroex`](self) events.
-    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-    pub enum IZeroexEvents {
-        #[allow(missing_docs)]
-        ERC1155OrderCancelled(ERC1155OrderCancelled),
-        #[allow(missing_docs)]
-        ERC1155OrderFilled(ERC1155OrderFilled),
-        #[allow(missing_docs)]
-        ERC1155OrderPreSigned(ERC1155OrderPreSigned),
-        #[allow(missing_docs)]
-        ERC721OrderCancelled(ERC721OrderCancelled),
-        #[allow(missing_docs)]
-        ERC721OrderFilled(ERC721OrderFilled),
-        #[allow(missing_docs)]
-        ERC721OrderPreSigned(ERC721OrderPreSigned),
-        #[allow(missing_docs)]
-        LimitOrderFilled(LimitOrderFilled),
-        #[allow(missing_docs)]
-        LiquidityProviderSwap(LiquidityProviderSwap),
-        #[allow(missing_docs)]
-        MetaTransactionExecuted(MetaTransactionExecuted),
-        #[allow(missing_docs)]
-        Migrated(Migrated),
-        #[allow(missing_docs)]
-        OrderCancelled(OrderCancelled),
-        #[allow(missing_docs)]
-        OrderSignerRegistered(OrderSignerRegistered),
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderCancelled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderCancelled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderCancelled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OrderSignerRegistered(address,address,bool)` and selector `0x6ea9dbe8b2cc119348716a9220a0742ad62b7884ecb0ff4b32cd508121fd9379`.
+    ```solidity
+    event OrderSignerRegistered(address maker, address signer, bool allowed);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OrderSignerRegistered {
         #[allow(missing_docs)]
-        OtcOrderFilled(OtcOrderFilled),
+        pub maker: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        OwnershipTransferred(OwnershipTransferred),
+        pub signer: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        PairCancelledLimitOrders(PairCancelledLimitOrders),
+        pub allowed: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OrderSignerRegistered {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OrderSignerRegistered(address,address,bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    110u8, 169u8, 219u8, 232u8, 178u8, 204u8, 17u8, 147u8, 72u8, 113u8, 106u8,
+                    146u8, 32u8, 160u8, 116u8, 42u8, 214u8, 43u8, 120u8, 132u8, 236u8, 176u8,
+                    255u8, 75u8, 50u8, 205u8, 80u8, 129u8, 33u8, 253u8, 147u8, 121u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    signer: data.1,
+                    allowed: data.2,
+                }
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.signer,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.allowed,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OrderSignerRegistered {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OrderSignerRegistered> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OrderSignerRegistered) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OtcOrderFilled(bytes32,address,address,address,address,uint128,uint128)` and selector `0xac75f773e3a92f1a02b12134d65e1f47f8a14eabe4eaf1e24624918e6a8b269f`.
+    ```solidity
+    event OtcOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 makerTokenFilledAmount, uint128 takerTokenFilledAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OtcOrderFilled {
         #[allow(missing_docs)]
-        PairCancelledRfqOrders(PairCancelledRfqOrders),
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        ProxyFunctionUpdated(ProxyFunctionUpdated),
+        pub maker: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        QuoteSignerUpdated(QuoteSignerUpdated),
+        pub taker: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        RfqOrderFilled(RfqOrderFilled),
+        pub makerToken: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        RfqOrderOriginsAllowed(RfqOrderOriginsAllowed),
+        pub takerToken: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        TransformedERC20(TransformedERC20),
+        pub makerTokenFilledAmount: u128,
         #[allow(missing_docs)]
-        TransformerDeployerUpdated(TransformerDeployerUpdated),
+        pub takerTokenFilledAmount: u128,
     }
-    impl IZeroexEvents {
-        /// All the selectors of this enum.
-        ///
-        /// Note that the selectors might not be in the same order as the
-        /// variants. No guarantees are made about the order of the
-        /// selectors.
-        ///
-        /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 32usize]] = &[
-            [
-                2u8, 223u8, 234u8, 213u8, 235u8, 118u8, 155u8, 41u8, 142u8, 130u8, 221u8, 150u8,
-                80u8, 179u8, 28u8, 64u8, 85u8, 154u8, 61u8, 66u8, 112u8, 29u8, 191u8, 83u8, 201u8,
-                49u8, 188u8, 38u8, 130u8, 132u8, 124u8, 49u8,
-            ],
-            [
-                15u8, 102u8, 114u8, 247u8, 138u8, 89u8, 186u8, 142u8, 94u8, 91u8, 93u8, 56u8,
-                223u8, 62u8, 188u8, 103u8, 243u8, 199u8, 146u8, 226u8, 201u8, 37u8, 155u8, 141u8,
-                151u8, 215u8, 240u8, 13u8, 215u8, 139u8, 161u8, 179u8,
-            ],
-            [
-                32u8, 204u8, 168u8, 27u8, 14u8, 38u8, 155u8, 38u8, 91u8, 50u8, 41u8, 214u8, 181u8,
-                55u8, 218u8, 145u8, 239u8, 71u8, 92u8, 160u8, 239u8, 85u8, 202u8, 237u8, 125u8,
-                211u8, 7u8, 49u8, 112u8, 11u8, 169u8, 141u8,
-            ],
-            [
-                42u8, 226u8, 33u8, 8u8, 52u8, 103u8, 222u8, 82u8, 7u8, 139u8, 0u8, 150u8, 105u8,
-                106u8, 184u8, 141u8, 141u8, 83u8, 167u8, 236u8, 180u8, 75u8, 182u8, 91u8, 86u8,
-                162u8, 186u8, 182u8, 135u8, 89u8, 131u8, 103u8,
-            ],
-            [
-                64u8, 166u8, 186u8, 149u8, 19u8, 208u8, 158u8, 52u8, 136u8, 19u8, 94u8, 14u8, 13u8,
-                16u8, 226u8, 212u8, 56u8, 43u8, 121u8, 39u8, 32u8, 21u8, 91u8, 20u8, 76u8, 190u8,
-                168u8, 154u8, 201u8, 219u8, 109u8, 52u8,
-            ],
-            [
-                77u8, 94u8, 167u8, 218u8, 100u8, 245u8, 10u8, 74u8, 50u8, 153u8, 33u8, 184u8,
-                210u8, 202u8, 181u8, 45u8, 255u8, 78u8, 188u8, 197u8, 139u8, 97u8, 209u8, 15u8,
-                248u8, 57u8, 226u8, 142u8, 145u8, 68u8, 86u8, 132u8,
-            ],
-            [
-                80u8, 39u8, 63u8, 160u8, 34u8, 115u8, 204u8, 238u8, 169u8, 207u8, 8u8, 91u8, 66u8,
-                222u8, 92u8, 138u8, 246u8, 6u8, 36u8, 20u8, 1u8, 104u8, 189u8, 113u8, 53u8, 125u8,
-                184u8, 51u8, 83u8, 88u8, 119u8, 175u8,
-            ],
-            [
-                94u8, 145u8, 221u8, 254u8, 183u8, 191u8, 46u8, 18u8, 247u8, 232u8, 171u8, 1u8,
-                125u8, 43u8, 99u8, 169u8, 33u8, 127u8, 0u8, 74u8, 21u8, 165u8, 51u8, 70u8, 173u8,
-                144u8, 53u8, 62u8, 198u8, 61u8, 20u8, 228u8,
-            ],
-            [
-                110u8, 169u8, 219u8, 232u8, 178u8, 204u8, 17u8, 147u8, 72u8, 113u8, 106u8, 146u8,
-                32u8, 160u8, 116u8, 42u8, 214u8, 43u8, 120u8, 132u8, 236u8, 176u8, 255u8, 75u8,
-                50u8, 205u8, 80u8, 129u8, 33u8, 253u8, 147u8, 121u8,
-            ],
-            [
-                127u8, 79u8, 227u8, 255u8, 138u8, 228u8, 64u8, 225u8, 87u8, 12u8, 85u8, 141u8,
-                160u8, 132u8, 64u8, 178u8, 111u8, 137u8, 251u8, 28u8, 31u8, 41u8, 16u8, 205u8,
-                145u8, 202u8, 100u8, 82u8, 149u8, 95u8, 18u8, 26u8,
-            ],
-            [
-                130u8, 159u8, 169u8, 157u8, 148u8, 220u8, 70u8, 54u8, 146u8, 91u8, 56u8, 99u8,
-                46u8, 98u8, 87u8, 54u8, 166u8, 20u8, 193u8, 84u8, 213u8, 80u8, 6u8, 183u8, 171u8,
-                107u8, 234u8, 151u8, 156u8, 33u8, 12u8, 50u8,
-            ],
-            [
-                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
-                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
-                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
-            ],
-            [
-                140u8, 93u8, 12u8, 65u8, 251u8, 22u8, 167u8, 49u8, 122u8, 108u8, 85u8, 255u8,
-                123u8, 169u8, 61u8, 157u8, 116u8, 247u8, 158u8, 67u8, 79u8, 239u8, 166u8, 148u8,
-                229u8, 13u8, 96u8, 40u8, 175u8, 191u8, 163u8, 240u8,
-            ],
-            [
-                160u8, 21u8, 173u8, 45u8, 195u8, 47u8, 38u8, 105u8, 147u8, 149u8, 138u8, 15u8,
-                217u8, 136u8, 76u8, 116u8, 107u8, 151u8, 27u8, 37u8, 66u8, 6u8, 243u8, 71u8, 139u8,
-                196u8, 62u8, 47u8, 18u8, 92u8, 123u8, 158u8,
-            ],
-            [
-                166u8, 235u8, 124u8, 220u8, 33u8, 158u8, 21u8, 24u8, 206u8, 217u8, 100u8, 233u8,
-                163u8, 78u8, 97u8, 214u8, 138u8, 148u8, 228u8, 241u8, 86u8, 157u8, 179u8, 232u8,
-                66u8, 86u8, 186u8, 152u8, 27u8, 165u8, 39u8, 83u8,
-            ],
-            [
-                169u8, 31u8, 231u8, 174u8, 98u8, 252u8, 230u8, 105u8, 223u8, 44u8, 127u8, 136u8,
-                15u8, 140u8, 20u8, 209u8, 120u8, 83u8, 26u8, 174u8, 114u8, 81u8, 85u8, 88u8, 229u8,
-                201u8, 72u8, 227u8, 124u8, 50u8, 165u8, 114u8,
-            ],
-            [
-                171u8, 97u8, 77u8, 43u8, 115u8, 133u8, 67u8, 192u8, 234u8, 33u8, 245u8, 99u8, 71u8,
-                207u8, 105u8, 106u8, 58u8, 12u8, 66u8, 167u8, 203u8, 236u8, 50u8, 18u8, 165u8,
-                202u8, 34u8, 164u8, 220u8, 255u8, 33u8, 36u8,
-            ],
-            [
-                172u8, 117u8, 247u8, 115u8, 227u8, 169u8, 47u8, 26u8, 2u8, 177u8, 33u8, 52u8,
-                214u8, 94u8, 31u8, 71u8, 248u8, 161u8, 78u8, 171u8, 228u8, 234u8, 241u8, 226u8,
-                70u8, 36u8, 145u8, 142u8, 106u8, 139u8, 38u8, 159u8,
-            ],
-            [
-                225u8, 184u8, 49u8, 176u8, 230u8, 243u8, 170u8, 22u8, 180u8, 177u8, 166u8, 189u8,
-                82u8, 107u8, 92u8, 222u8, 171u8, 73u8, 64u8, 116u8, 76u8, 166u8, 224u8, 37u8, 31u8,
-                95u8, 229u8, 248u8, 202u8, 241u8, 200u8, 26u8,
-            ],
-            [
-                245u8, 85u8, 12u8, 94u8, 234u8, 25u8, 180u8, 138u8, 198u8, 235u8, 95u8, 3u8, 171u8,
-                220u8, 79u8, 89u8, 192u8, 166u8, 6u8, 151u8, 171u8, 179u8, 217u8, 115u8, 205u8,
-                104u8, 102u8, 151u8, 3u8, 181u8, 200u8, 185u8,
-            ],
-            [
-                253u8, 69u8, 96u8, 74u8, 186u8, 215u8, 156u8, 22u8, 226u8, 51u8, 72u8, 161u8, 55u8,
-                237u8, 130u8, 146u8, 102u8, 27u8, 225u8, 184u8, 235u8, 166u8, 228u8, 128u8, 110u8,
-                190u8, 214u8, 131u8, 59u8, 28u8, 4u8, 106u8,
-            ],
-            [
-                254u8, 127u8, 251u8, 30u8, 223u8, 231u8, 159u8, 77u8, 247u8, 22u8, 203u8, 45u8,
-                202u8, 210u8, 28u8, 242u8, 243u8, 27u8, 16u8, 77u8, 129u8, 106u8, 121u8, 118u8,
-                186u8, 30u8, 110u8, 70u8, 83u8, 193u8, 239u8, 177u8,
-            ],
-        ];
-        /// The signatures in the same order as `SELECTORS`.
-        pub const SIGNATURES: &'static [&'static str] = &[
-            <RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::SIGNATURE,
-            <TransformedERC20 as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ERC1155OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ProxyFunctionUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
-            <LiquidityProviderSwap as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ERC1155OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ERC721OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE,
-            <OrderSignerRegistered as alloy_sol_types::SolEvent>::SIGNATURE,
-            <MetaTransactionExecuted as alloy_sol_types::SolEvent>::SIGNATURE,
-            <RfqOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ERC721OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE,
-            <ERC721OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <PairCancelledLimitOrders as alloy_sol_types::SolEvent>::SIGNATURE,
-            <LimitOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <OtcOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
-            <Migrated as alloy_sol_types::SolEvent>::SIGNATURE,
-            <QuoteSignerUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
-            <TransformerDeployerUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
-            <PairCancelledRfqOrders as alloy_sol_types::SolEvent>::SIGNATURE,
-        ];
-        /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(RfqOrderOriginsAllowed),
-            ::core::stringify!(TransformedERC20),
-            ::core::stringify!(ERC1155OrderFilled),
-            ::core::stringify!(ProxyFunctionUpdated),
-            ::core::stringify!(LiquidityProviderSwap),
-            ::core::stringify!(ERC1155OrderCancelled),
-            ::core::stringify!(ERC721OrderFilled),
-            ::core::stringify!(ERC1155OrderPreSigned),
-            ::core::stringify!(OrderSignerRegistered),
-            ::core::stringify!(MetaTransactionExecuted),
-            ::core::stringify!(RfqOrderFilled),
-            ::core::stringify!(OwnershipTransferred),
-            ::core::stringify!(ERC721OrderPreSigned),
-            ::core::stringify!(ERC721OrderCancelled),
-            ::core::stringify!(OrderCancelled),
-            ::core::stringify!(PairCancelledLimitOrders),
-            ::core::stringify!(LimitOrderFilled),
-            ::core::stringify!(OtcOrderFilled),
-            ::core::stringify!(Migrated),
-            ::core::stringify!(QuoteSignerUpdated),
-            ::core::stringify!(TransformerDeployerUpdated),
-            ::core::stringify!(PairCancelledRfqOrders),
-        ];
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OtcOrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "OtcOrderFilled(bytes32,address,address,address,address,uint128,uint128)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    172u8, 117u8, 247u8, 115u8, 227u8, 169u8, 47u8, 26u8, 2u8, 177u8, 33u8, 52u8,
+                    214u8, 94u8, 31u8, 71u8, 248u8, 161u8, 78u8, 171u8, 228u8, 234u8, 241u8, 226u8,
+                    70u8, 36u8, 145u8, 142u8, 106u8, 139u8, 38u8, 159u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    makerToken: data.3,
+                    takerToken: data.4,
+                    makerTokenFilledAmount: data.5,
+                    takerTokenFilledAmount: data.6,
+                }
+            }
 
-        /// Returns the signature for the given selector, if known.
-        #[inline]
-        pub fn signature_by_selector(
-            selector: [u8; 32usize],
-        ) -> ::core::option::Option<&'static str> {
-            match Self::SELECTORS.binary_search(&selector) {
-                ::core::result::Result::Ok(idx) => {
-                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                ::core::result::Result::Err(_) => ::core::option::Option::None,
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OtcOrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        /// Returns the enum variant name for the given selector, if known.
-        #[inline]
-        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
-            let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OtcOrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OtcOrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
+    ```solidity
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct OwnershipTransferred {
+        #[allow(missing_docs)]
+        pub previousOwner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newOwner: alloy_sol_types::private::Address,
     }
-    #[automatically_derived]
-    impl alloy_sol_types::SolEventInterface for IZeroexEvents {
-        const COUNT: usize = 22usize;
-        const NAME: &'static str = "IZeroexEvents";
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for OwnershipTransferred {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = ();
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
 
-        fn decode_raw_log(
-            topics: &[alloy_sol_types::Word],
-            data: &[u8],
-        ) -> alloy_sol_types::Result<Self> {
-            match topics.first().copied() {
-                Some(<ERC1155OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ERC1155OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::ERC1155OrderCancelled)
-                }
-                Some(<ERC1155OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ERC1155OrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::ERC1155OrderFilled)
-                }
-                Some(<ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::ERC1155OrderPreSigned)
-                }
-                Some(<ERC721OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ERC721OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::ERC721OrderCancelled)
-                }
-                Some(<ERC721OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ERC721OrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::ERC721OrderFilled)
-                }
-                Some(<ERC721OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ERC721OrderPreSigned as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::ERC721OrderPreSigned)
-                }
-                Some(<LimitOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <LimitOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::LimitOrderFilled)
-                }
-                Some(<LiquidityProviderSwap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <LiquidityProviderSwap as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::LiquidityProviderSwap)
-                }
-                Some(<MetaTransactionExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <MetaTransactionExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::MetaTransactionExecuted)
-                }
-                Some(<Migrated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <Migrated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::Migrated)
-                }
-                Some(<OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::OrderCancelled)
-                }
-                Some(<OrderSignerRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <OrderSignerRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::OrderSignerRegistered)
-                }
-                Some(<OtcOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <OtcOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::OtcOrderFilled)
-                }
-                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::OwnershipTransferred)
-                }
-                Some(<PairCancelledLimitOrders as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <PairCancelledLimitOrders as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::PairCancelledLimitOrders)
-                }
-                Some(<PairCancelledRfqOrders as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <PairCancelledRfqOrders as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::PairCancelledRfqOrders)
-                }
-                Some(<ProxyFunctionUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <ProxyFunctionUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::ProxyFunctionUpdated)
-                }
-                Some(<QuoteSignerUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <QuoteSignerUpdated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::QuoteSignerUpdated)
-                }
-                Some(<RfqOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <RfqOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::RfqOrderFilled)
-                }
-                Some(<RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::RfqOrderOriginsAllowed)
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
+                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
+                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    previousOwner: topics.1,
+                    newOwner: topics.2,
                 }
-                Some(<TransformedERC20 as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <TransformedERC20 as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
-                        .map(Self::TransformedERC20)
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Some(<TransformerDeployerUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
-                    <TransformerDeployerUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
-                        topics, data,
-                    )
-                    .map(Self::TransformerDeployerUpdated)
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                ()
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.previousOwner.clone(),
+                    self.newOwner.clone(),
+                )
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
-                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
-                    log: alloy_sol_types::private::Box::new(
-                        alloy_sol_types::private::LogData::new_unchecked(
-                            topics.to_vec(),
-                            data.to_vec().into(),
-                        ),
-                    ),
-                }),
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.previousOwner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.newOwner,
+                );
+                Ok(())
             }
         }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::private::IntoLogData for IZeroexEvents {
-        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-            match self {
-                Self::ERC1155OrderCancelled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::ERC1155OrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::ERC1155OrderPreSigned(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::ERC721OrderCancelled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::ERC721OrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::ERC721OrderPreSigned(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::LimitOrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::LiquidityProviderSwap(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::MetaTransactionExecuted(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::Migrated(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
-                Self::OrderCancelled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::OrderSignerRegistered(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::OtcOrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::OwnershipTransferred(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::PairCancelledLimitOrders(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::PairCancelledRfqOrders(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::ProxyFunctionUpdated(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::QuoteSignerUpdated(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::RfqOrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::RfqOrderOriginsAllowed(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::TransformedERC20(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
-                Self::TransformerDeployerUpdated(inner) => {
-                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PairCancelledLimitOrders(address,address,address,uint256)` and selector `0xa91fe7ae62fce669df2c7f880f8c14d178531aae72515558e5c948e37c32a572`.
+    ```solidity
+    event PairCancelledLimitOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PairCancelledLimitOrders {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PairCancelledLimitOrders {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-        fn into_log_data(self) -> alloy_sol_types::private::LogData {
-            match self {
-                Self::ERC1155OrderCancelled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::ERC1155OrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::ERC1155OrderPreSigned(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::ERC721OrderCancelled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::ERC721OrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::ERC721OrderPreSigned(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::LimitOrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::LiquidityProviderSwap(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::MetaTransactionExecuted(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::Migrated(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::OrderCancelled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::OrderSignerRegistered(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::OtcOrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::OwnershipTransferred(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::PairCancelledLimitOrders(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::PairCancelledRfqOrders(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
-                }
-                Self::ProxyFunctionUpdated(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PairCancelledLimitOrders(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    169u8, 31u8, 231u8, 174u8, 98u8, 252u8, 230u8, 105u8, 223u8, 44u8, 127u8,
+                    136u8, 15u8, 140u8, 20u8, 209u8, 120u8, 83u8, 26u8, 174u8, 114u8, 81u8, 85u8,
+                    88u8, 229u8, 201u8, 72u8, 227u8, 124u8, 50u8, 165u8, 114u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    makerToken: data.1,
+                    takerToken: data.2,
+                    minValidSalt: data.3,
                 }
-                Self::QuoteSignerUpdated(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::RfqOrderFilled(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
-                Self::RfqOrderOriginsAllowed(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PairCancelledLimitOrders {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PairCancelledLimitOrders> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PairCancelledLimitOrders) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `PairCancelledRfqOrders(address,address,address,uint256)` and selector `0xfe7ffb1edfe79f4df716cb2dcad21cf2f31b104d816a7976ba1e6e4653c1efb1`.
+    ```solidity
+    event PairCancelledRfqOrders(address maker, address makerToken, address takerToken, uint256 minValidSalt);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct PairCancelledRfqOrders {
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for PairCancelledRfqOrders {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "PairCancelledRfqOrders(address,address,address,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    254u8, 127u8, 251u8, 30u8, 223u8, 231u8, 159u8, 77u8, 247u8, 22u8, 203u8, 45u8,
+                    202u8, 210u8, 28u8, 242u8, 243u8, 27u8, 16u8, 77u8, 129u8, 106u8, 121u8, 118u8,
+                    186u8, 30u8, 110u8, 70u8, 83u8, 193u8, 239u8, 177u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    maker: data.0,
+                    makerToken: data.1,
+                    takerToken: data.2,
+                    minValidSalt: data.3,
                 }
-                Self::TransformedERC20(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+            }
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
-                Self::TransformerDeployerUpdated(inner) => {
-                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.minValidSalt,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
             }
         }
-    }
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`IZeroex`](self) contract instance.
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for PairCancelledRfqOrders {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-    See the [wrapper's documentation](`IZeroexInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> IZeroexInstance<P, N> {
-        IZeroexInstance::<P, N>::new(address, __provider)
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&PairCancelledRfqOrders> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &PairCancelledRfqOrders) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `ProxyFunctionUpdated(bytes4,address,address)` and selector `0x2ae221083467de52078b0096696ab88d8d53a7ecb44bb65b56a2bab687598367`.
+    ```solidity
+    event ProxyFunctionUpdated(bytes4 indexed selector, address oldImpl, address newImpl);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct ProxyFunctionUpdated {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub oldImpl: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newImpl: alloy_sol_types::private::Address,
     }
-    /**A [`IZeroex`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`IZeroex`](self) contract located at a given `address`, using a given
-    provider `P`.
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for ProxyFunctionUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
 
-    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.
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "ProxyFunctionUpdated(bytes4,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    42u8, 226u8, 33u8, 8u8, 52u8, 103u8, 222u8, 82u8, 7u8, 139u8, 0u8, 150u8,
+                    105u8, 106u8, 184u8, 141u8, 141u8, 83u8, 167u8, 236u8, 180u8, 75u8, 182u8,
+                    91u8, 86u8, 162u8, 186u8, 182u8, 135u8, 89u8, 131u8, 103u8,
+                ]);
 
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct IZeroexInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for IZeroexInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("IZeroexInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IZeroexInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`IZeroex`](self) contract instance.
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    selector: topics.1,
+                    oldImpl: data.0,
+                    newImpl: data.1,
+                }
+            }
 
-        See the [wrapper's documentation](`IZeroexInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
-        }
 
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.oldImpl,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.newImpl,
+                    ),
+                )
+            }
 
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.selector.clone())
+            }
 
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    4,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.selector);
+                Ok(())
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for ProxyFunctionUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
         }
-    }
-    impl<P: ::core::clone::Clone, N> IZeroexInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> IZeroexInstance<P, N> {
-            IZeroexInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
+        #[automatically_derived]
+        impl From<&ProxyFunctionUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &ProxyFunctionUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `QuoteSignerUpdated(address)` and selector `0xf5550c5eea19b48ac6eb5f03abdc4f59c0a60697abb3d973cd68669703b5c8b9`.
+    ```solidity
+    event QuoteSignerUpdated(address quoteSigner);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct QuoteSignerUpdated {
+        #[allow(missing_docs)]
+        pub quoteSigner: alloy_sol_types::private::Address,
     }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        IZeroexInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for QuoteSignerUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-        ///Creates a new call builder for the [`_fillLimitOrder`] function.
-        pub fn _fillLimitOrder(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-            taker: alloy_sol_types::private::Address,
-            sender: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, _fillLimitOrderCall, N> {
-            self.call_builder(&_fillLimitOrderCall {
-                order,
-                signature,
-                takerTokenFillAmount,
-                taker,
-                sender,
-            })
-        }
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "QuoteSignerUpdated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    245u8, 85u8, 12u8, 94u8, 234u8, 25u8, 180u8, 138u8, 198u8, 235u8, 95u8, 3u8,
+                    171u8, 220u8, 79u8, 89u8, 192u8, 166u8, 6u8, 151u8, 171u8, 179u8, 217u8, 115u8,
+                    205u8, 104u8, 102u8, 151u8, 3u8, 181u8, 200u8, 185u8,
+                ]);
 
-        ///Creates a new call builder for the [`_fillOtcOrder`] function.
-        pub fn _fillOtcOrder(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-            taker: alloy_sol_types::private::Address,
-            useSelfBalance: bool,
-            recipient: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, _fillOtcOrderCall, N> {
-            self.call_builder(&_fillOtcOrderCall {
-                order,
-                makerSignature,
-                takerTokenFillAmount,
-                taker,
-                useSelfBalance,
-                recipient,
-            })
-        }
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    quoteSigner: data.0,
+                }
+            }
 
-        ///Creates a new call builder for the [`_fillRfqOrder`] function.
-        pub fn _fillRfqOrder(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-            taker: alloy_sol_types::private::Address,
-            useSelfBalance: bool,
-            recipient: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, _fillRfqOrderCall, N> {
-            self.call_builder(&_fillRfqOrderCall {
-                order,
-                signature,
-                takerTokenFillAmount,
-                taker,
-                useSelfBalance,
-                recipient,
-            })
-        }
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
 
-        ///Creates a new call builder for the
-        /// [`_sellHeldTokenForTokenToUniswapV3`] function.
-        pub fn _sellHeldTokenForTokenToUniswapV3(
-            &self,
-            encodedPath: alloy_sol_types::private::Bytes,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            recipient: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, _sellHeldTokenForTokenToUniswapV3Call, N> {
-            self.call_builder(&_sellHeldTokenForTokenToUniswapV3Call {
-                encodedPath,
-                sellAmount,
-                minBuyAmount,
-                recipient,
-            })
-        }
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteSigner,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
 
-        ///Creates a new call builder for the [`_transformERC20`] function.
-        pub fn _transformERC20(
-            &self,
-            args: <ITransformERC20Feature::TransformERC20Args as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, _transformERC20Call, N> {
-            self.call_builder(&_transformERC20Call { args })
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for QuoteSignerUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        ///Creates a new call builder for the [`batchBuyERC1155s`] function.
-        pub fn batchBuyERC1155s(
-            &self,
-            sellOrders: alloy_sol_types::private::Vec<
-                <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            erc1155TokenAmounts: alloy_sol_types::private::Vec<u128>,
-            callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-            revertIfIncomplete: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, batchBuyERC1155sCall, N> {
-            self.call_builder(&batchBuyERC1155sCall {
-                sellOrders,
-                signatures,
-                erc1155TokenAmounts,
-                callbackData,
-                revertIfIncomplete,
-            })
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
         }
-
-        ///Creates a new call builder for the [`batchBuyERC721s`] function.
-        pub fn batchBuyERC721s(
-            &self,
-            sellOrders: alloy_sol_types::private::Vec<
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            callbackData: alloy_sol_types::private::Vec<alloy_sol_types::private::Bytes>,
-            revertIfIncomplete: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, batchBuyERC721sCall, N> {
-            self.call_builder(&batchBuyERC721sCall {
-                sellOrders,
-                signatures,
-                callbackData,
-                revertIfIncomplete,
-            })
+        #[automatically_derived]
+        impl From<&QuoteSignerUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &QuoteSignerUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RfqOrderFilled(bytes32,address,address,address,address,uint128,uint128,bytes32)` and selector `0x829fa99d94dc4636925b38632e625736a614c154d55006b7ab6bea979c210c32`.
+    ```solidity
+    event RfqOrderFilled(bytes32 orderHash, address maker, address taker, address makerToken, address takerToken, uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount, bytes32 pool);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RfqOrderFilled {
+        #[allow(missing_docs)]
+        pub orderHash: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub maker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub makerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub takerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+        #[allow(missing_docs)]
+        pub pool: alloy_sol_types::private::FixedBytes<32>,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RfqOrderFilled {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-        ///Creates a new call builder for the [`batchCancelERC1155Orders`]
-        /// function.
-        pub fn batchCancelERC1155Orders(
-            &self,
-            orderNonces: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelERC1155OrdersCall, N> {
-            self.call_builder(&batchCancelERC1155OrdersCall { orderNonces })
-        }
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "RfqOrderFilled(bytes32,address,address,address,address,uint128,uint128,bytes32)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    130u8, 159u8, 169u8, 157u8, 148u8, 220u8, 70u8, 54u8, 146u8, 91u8, 56u8, 99u8,
+                    46u8, 98u8, 87u8, 54u8, 166u8, 20u8, 193u8, 84u8, 213u8, 80u8, 6u8, 183u8,
+                    171u8, 107u8, 234u8, 151u8, 156u8, 33u8, 12u8, 50u8,
+                ]);
 
-        ///Creates a new call builder for the [`batchCancelERC721Orders`]
-        /// function.
-        pub fn batchCancelERC721Orders(
-            &self,
-            orderNonces: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelERC721OrdersCall, N> {
-            self.call_builder(&batchCancelERC721OrdersCall { orderNonces })
-        }
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    orderHash: data.0,
+                    maker: data.1,
+                    taker: data.2,
+                    makerToken: data.3,
+                    takerToken: data.4,
+                    takerTokenFilledAmount: data.5,
+                    makerTokenFilledAmount: data.6,
+                    pool: data.7,
+                }
+            }
 
-        ///Creates a new call builder for the [`batchCancelLimitOrders`]
-        /// function.
-        pub fn batchCancelLimitOrders(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelLimitOrdersCall, N> {
-            self.call_builder(&batchCancelLimitOrdersCall { orders })
-        }
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
 
-        ///Creates a new call builder for the [`batchCancelPairLimitOrders`]
-        /// function.
-        pub fn batchCancelPairLimitOrders(
-            &self,
-            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            minValidSalts: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairLimitOrdersCall, N> {
-            self.call_builder(&batchCancelPairLimitOrdersCall {
-                makerTokens,
-                takerTokens,
-                minValidSalts,
-            })
-        }
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.orderHash),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.maker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.taker,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.makerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.takerToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        128,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.makerTokenFilledAmount,
+                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.pool),
+                )
+            }
 
-        ///Creates a new call builder for the
-        /// [`batchCancelPairLimitOrdersWithSigner`] function.
-        pub fn batchCancelPairLimitOrdersWithSigner(
-            &self,
-            maker: alloy_sol_types::private::Address,
-            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            minValidSalts: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairLimitOrdersWithSignerCall, N>
-        {
-            self.call_builder(&batchCancelPairLimitOrdersWithSignerCall {
-                maker,
-                makerTokens,
-                takerTokens,
-                minValidSalts,
-            })
-        }
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
 
-        ///Creates a new call builder for the [`batchCancelPairRfqOrders`]
-        /// function.
-        pub fn batchCancelPairRfqOrders(
-            &self,
-            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            minValidSalts: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairRfqOrdersCall, N> {
-            self.call_builder(&batchCancelPairRfqOrdersCall {
-                makerTokens,
-                takerTokens,
-                minValidSalts,
-            })
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RfqOrderFilled {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        ///Creates a new call builder for the
-        /// [`batchCancelPairRfqOrdersWithSigner`] function.
-        pub fn batchCancelPairRfqOrdersWithSigner(
-            &self,
-            maker: alloy_sol_types::private::Address,
-            makerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            takerTokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            minValidSalts: alloy_sol_types::private::Vec<
-                alloy_sol_types::private::primitives::aliases::U256,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelPairRfqOrdersWithSignerCall, N> {
-            self.call_builder(&batchCancelPairRfqOrdersWithSignerCall {
-                maker,
-                makerTokens,
-                takerTokens,
-                minValidSalts,
-            })
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
         }
-
-        ///Creates a new call builder for the [`batchCancelRfqOrders`]
-        /// function.
-        pub fn batchCancelRfqOrders(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchCancelRfqOrdersCall, N> {
-            self.call_builder(&batchCancelRfqOrdersCall { orders })
+        #[automatically_derived]
+        impl From<&RfqOrderFilled> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RfqOrderFilled) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `RfqOrderOriginsAllowed(address,address[],bool)` and selector `0x02dfead5eb769b298e82dd9650b31c40559a3d42701dbf53c931bc2682847c31`.
+    ```solidity
+    event RfqOrderOriginsAllowed(address origin, address[] addrs, bool allowed);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct RfqOrderOriginsAllowed {
+        #[allow(missing_docs)]
+        pub origin: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub addrs: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        #[allow(missing_docs)]
+        pub allowed: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for RfqOrderOriginsAllowed {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "RfqOrderOriginsAllowed(address,address[],bool)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    2u8, 223u8, 234u8, 213u8, 235u8, 118u8, 155u8, 41u8, 142u8, 130u8, 221u8,
+                    150u8, 80u8, 179u8, 28u8, 64u8, 85u8, 154u8, 61u8, 66u8, 112u8, 29u8, 191u8,
+                    83u8, 201u8, 49u8, 188u8, 38u8, 130u8, 132u8, 124u8, 49u8,
+                ]);
 
-        ///Creates a new call builder for the [`batchExecuteMetaTransactions`]
-        /// function.
-        pub fn batchExecuteMetaTransactions(
-            &self,
-            mtxs: alloy_sol_types::private::Vec<
-                <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchExecuteMetaTransactionsCall, N> {
-            self.call_builder(&batchExecuteMetaTransactionsCall { mtxs, signatures })
-        }
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    origin: data.0,
+                    addrs: data.1,
+                    allowed: data.2,
+                }
+            }
 
-        ///Creates a new call builder for the [`batchFillLimitOrders`]
-        /// function.
-        pub fn batchFillLimitOrders(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
-            revertIfIncomplete: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, batchFillLimitOrdersCall, N> {
-            self.call_builder(&batchFillLimitOrdersCall {
-                orders,
-                signatures,
-                takerTokenFillAmounts,
-                revertIfIncomplete,
-            })
-        }
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
 
-        ///Creates a new call builder for the [`batchFillRfqOrders`] function.
-        pub fn batchFillRfqOrders(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            takerTokenFillAmounts: alloy_sol_types::private::Vec<u128>,
-            revertIfIncomplete: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, batchFillRfqOrdersCall, N> {
-            self.call_builder(&batchFillRfqOrdersCall {
-                orders,
-                signatures,
-                takerTokenFillAmounts,
-                revertIfIncomplete,
-            })
-        }
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.origin,
+                    ),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Address,
+                    > as alloy_sol_types::SolType>::tokenize(&self.addrs),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.allowed,
+                    ),
+                )
+            }
 
-        ///Creates a new call builder for the [`batchFillTakerSignedOtcOrders`]
-        /// function.
-        pub fn batchFillTakerSignedOtcOrders(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            >,
-            makerSignatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            takerSignatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            unwrapWeth: alloy_sol_types::private::Vec<bool>,
-        ) -> alloy_contract::SolCallBuilder<&P, batchFillTakerSignedOtcOrdersCall, N> {
-            self.call_builder(&batchFillTakerSignedOtcOrdersCall {
-                orders,
-                makerSignatures,
-                takerSignatures,
-                unwrapWeth,
-            })
-        }
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
 
-        ///Creates a new call builder for the
-        /// [`batchGetLimitOrderRelevantStates`] function.
-        pub fn batchGetLimitOrderRelevantStates(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchGetLimitOrderRelevantStatesCall, N> {
-            self.call_builder(&batchGetLimitOrderRelevantStatesCall { orders, signatures })
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for RfqOrderOriginsAllowed {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        ///Creates a new call builder for the
-        /// [`batchGetRfqOrderRelevantStates`] function.
-        pub fn batchGetRfqOrderRelevantStates(
-            &self,
-            orders: alloy_sol_types::private::Vec<
-                <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            >,
-            signatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchGetRfqOrderRelevantStatesCall, N> {
-            self.call_builder(&batchGetRfqOrderRelevantStatesCall { orders, signatures })
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
         }
-
-        ///Creates a new call builder for the [`batchMatchERC721Orders`]
-        /// function.
-        pub fn batchMatchERC721Orders(
-            &self,
-            sellOrders: alloy_sol_types::private::Vec<
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            >,
-            buyOrders: alloy_sol_types::private::Vec<
-                <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            >,
-            sellOrderSignatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-            buyOrderSignatures: alloy_sol_types::private::Vec<
-                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, batchMatchERC721OrdersCall, N> {
-            self.call_builder(&batchMatchERC721OrdersCall {
-                sellOrders,
-                buyOrders,
-                sellOrderSignatures,
-                buyOrderSignatures,
-            })
+        #[automatically_derived]
+        impl From<&RfqOrderOriginsAllowed> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &RfqOrderOriginsAllowed) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TransformedERC20(address,address,address,uint256,uint256)` and selector `0x0f6672f78a59ba8e5e5b5d38df3ebc67f3c792e2c9259b8d97d7f00dd78ba1b3`.
+    ```solidity
+    event TransformedERC20(address indexed taker, address inputToken, address outputToken, uint256 inputTokenAmount, uint256 outputTokenAmount);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TransformedERC20 {
+        #[allow(missing_docs)]
+        pub taker: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub outputToken: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub outputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TransformedERC20 {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-        ///Creates a new call builder for the [`buyERC1155`] function.
-        pub fn buyERC1155(
-            &self,
-            sellOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            erc1155BuyAmount: u128,
-            callbackData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, buyERC1155Call, N> {
-            self.call_builder(&buyERC1155Call {
-                sellOrder,
-                signature,
-                erc1155BuyAmount,
-                callbackData,
-            })
-        }
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "TransformedERC20(address,address,address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    15u8, 102u8, 114u8, 247u8, 138u8, 89u8, 186u8, 142u8, 94u8, 91u8, 93u8, 56u8,
+                    223u8, 62u8, 188u8, 103u8, 243u8, 199u8, 146u8, 226u8, 201u8, 37u8, 155u8,
+                    141u8, 151u8, 215u8, 240u8, 13u8, 215u8, 139u8, 161u8, 179u8,
+                ]);
 
-        ///Creates a new call builder for the [`buyERC721`] function.
-        pub fn buyERC721(
-            &self,
-            sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            callbackData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, buyERC721Call, N> {
-            self.call_builder(&buyERC721Call {
-                sellOrder,
-                signature,
-                callbackData,
-            })
-        }
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    taker: topics.1,
+                    inputToken: data.0,
+                    outputToken: data.1,
+                    inputTokenAmount: data.2,
+                    outputTokenAmount: data.3,
+                }
+            }
 
-        ///Creates a new call builder for the [`cancelERC1155Order`] function.
-        pub fn cancelERC1155Order(
-            &self,
-            orderNonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelERC1155OrderCall, N> {
-            self.call_builder(&cancelERC1155OrderCall { orderNonce })
-        }
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
 
-        ///Creates a new call builder for the [`cancelERC721Order`] function.
-        pub fn cancelERC721Order(
-            &self,
-            orderNonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelERC721OrderCall, N> {
-            self.call_builder(&cancelERC721OrderCall { orderNonce })
-        }
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.inputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.outputToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.inputTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.outputTokenAmount,
+                    ),
+                )
+            }
 
-        ///Creates a new call builder for the [`cancelLimitOrder`] function.
-        pub fn cancelLimitOrder(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelLimitOrderCall, N> {
-            self.call_builder(&cancelLimitOrderCall { order })
-        }
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.taker.clone())
+            }
 
-        ///Creates a new call builder for the [`cancelPairLimitOrders`]
-        /// function.
-        pub fn cancelPairLimitOrders(
-            &self,
-            makerToken: alloy_sol_types::private::Address,
-            takerToken: alloy_sol_types::private::Address,
-            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelPairLimitOrdersCall, N> {
-            self.call_builder(&cancelPairLimitOrdersCall {
-                makerToken,
-                takerToken,
-                minValidSalt,
-            })
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.taker,
+                );
+                Ok(())
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TransformedERC20 {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        ///Creates a new call builder for the
-        /// [`cancelPairLimitOrdersWithSigner`] function.
-        pub fn cancelPairLimitOrdersWithSigner(
-            &self,
-            maker: alloy_sol_types::private::Address,
-            makerToken: alloy_sol_types::private::Address,
-            takerToken: alloy_sol_types::private::Address,
-            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelPairLimitOrdersWithSignerCall, N> {
-            self.call_builder(&cancelPairLimitOrdersWithSignerCall {
-                maker,
-                makerToken,
-                takerToken,
-                minValidSalt,
-            })
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
         }
-
-        ///Creates a new call builder for the [`cancelPairRfqOrders`] function.
-        pub fn cancelPairRfqOrders(
-            &self,
-            makerToken: alloy_sol_types::private::Address,
-            takerToken: alloy_sol_types::private::Address,
-            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelPairRfqOrdersCall, N> {
-            self.call_builder(&cancelPairRfqOrdersCall {
-                makerToken,
-                takerToken,
-                minValidSalt,
-            })
+        #[automatically_derived]
+        impl From<&TransformedERC20> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TransformedERC20) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `TransformerDeployerUpdated(address)` and selector `0xfd45604abad79c16e23348a137ed8292661be1b8eba6e4806ebed6833b1c046a`.
+    ```solidity
+    event TransformerDeployerUpdated(address transformerDeployer);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct TransformerDeployerUpdated {
+        #[allow(missing_docs)]
+        pub transformerDeployer: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for TransformerDeployerUpdated {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
 
-        ///Creates a new call builder for the [`cancelPairRfqOrdersWithSigner`]
-        /// function.
-        pub fn cancelPairRfqOrdersWithSigner(
-            &self,
-            maker: alloy_sol_types::private::Address,
-            makerToken: alloy_sol_types::private::Address,
-            takerToken: alloy_sol_types::private::Address,
-            minValidSalt: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelPairRfqOrdersWithSignerCall, N> {
-            self.call_builder(&cancelPairRfqOrdersWithSignerCall {
-                maker,
-                makerToken,
-                takerToken,
-                minValidSalt,
-            })
-        }
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "TransformerDeployerUpdated(address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    253u8, 69u8, 96u8, 74u8, 186u8, 215u8, 156u8, 22u8, 226u8, 51u8, 72u8, 161u8,
+                    55u8, 237u8, 130u8, 146u8, 102u8, 27u8, 225u8, 184u8, 235u8, 166u8, 228u8,
+                    128u8, 110u8, 190u8, 214u8, 131u8, 59u8, 28u8, 4u8, 106u8,
+                ]);
 
-        ///Creates a new call builder for the [`cancelRfqOrder`] function.
-        pub fn cancelRfqOrder(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelRfqOrderCall, N> {
-            self.call_builder(&cancelRfqOrderCall { order })
-        }
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    transformerDeployer: data.0,
+                }
+            }
 
-        ///Creates a new call builder for the [`createTransformWallet`]
-        /// function.
-        pub fn createTransformWallet(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, createTransformWalletCall, N> {
-            self.call_builder(&createTransformWalletCall)
-        }
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
 
-        ///Creates a new call builder for the [`executeMetaTransaction`]
-        /// function.
-        pub fn executeMetaTransaction(
-            &self,
-            mtx: <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, executeMetaTransactionCall, N> {
-            self.call_builder(&executeMetaTransactionCall { mtx, signature })
-        }
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.transformerDeployer,
+                    ),
+                )
+            }
 
-        ///Creates a new call builder for the [`extend`] function.
-        pub fn extend(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-            r#impl: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, extendCall, N> {
-            self.call_builder(&extendCall { selector, r#impl })
-        }
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(),)
+            }
 
-        ///Creates a new call builder for the [`fillLimitOrder`] function.
-        pub fn fillLimitOrder(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, fillLimitOrderCall, N> {
-            self.call_builder(&fillLimitOrderCall {
-                order,
-                signature,
-                takerTokenFillAmount,
-            })
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                Ok(())
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TransformerDeployerUpdated {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
 
-        ///Creates a new call builder for the [`fillOrKillLimitOrder`]
-        /// function.
-        pub fn fillOrKillLimitOrder(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, fillOrKillLimitOrderCall, N> {
-            self.call_builder(&fillOrKillLimitOrderCall {
-                order,
-                signature,
-                takerTokenFillAmount,
-            })
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
         }
-
-        ///Creates a new call builder for the [`fillOrKillRfqOrder`] function.
-        pub fn fillOrKillRfqOrder(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, fillOrKillRfqOrderCall, N> {
-            self.call_builder(&fillOrKillRfqOrderCall {
-                order,
-                signature,
-                takerTokenFillAmount,
-            })
+        #[automatically_derived]
+        impl From<&TransformerDeployerUpdated> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &TransformerDeployerUpdated) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
+            }
         }
-
-        ///Creates a new call builder for the [`fillOtcOrder`] function.
-        pub fn fillOtcOrder(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, fillOtcOrderCall, N> {
-            self.call_builder(&fillOtcOrderCall {
-                order,
-                makerSignature,
-                takerTokenFillAmount,
-            })
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `extend(bytes4,address)` and selector `0x6eb224cb`.
+    ```solidity
+    function extend(bytes4 selector, address r#impl) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct extendCall {
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
+        #[allow(missing_docs)]
+        pub r#impl: alloy_sol_types::private::Address,
+    }
+    ///Container type for the return parameters of the
+    /// [`extend(bytes4,address)`](extendCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct extendReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::FixedBytes<4>,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<extendCall> for UnderlyingRustTuple<'_> {
+                fn from(value: extendCall) -> Self {
+                    (value.selector, value.r#impl)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for extendCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        selector: tuple.0,
+                        r#impl: tuple.1,
+                    }
+                }
+            }
         }
-
-        ///Creates a new call builder for the [`fillOtcOrderForEth`] function.
-        pub fn fillOtcOrderForEth(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, fillOtcOrderForEthCall, N> {
-            self.call_builder(&fillOtcOrderForEthCall {
-                order,
-                makerSignature,
-                takerTokenFillAmount,
-            })
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<extendReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: extendReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for extendReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
         }
-
-        ///Creates a new call builder for the [`fillOtcOrderWithEth`] function.
-        pub fn fillOtcOrderWithEth(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, fillOtcOrderWithEthCall, N> {
-            self.call_builder(&fillOtcOrderWithEthCall {
-                order,
-                makerSignature,
-            })
+        impl extendReturn {
+            fn _tokenize(&self) -> <extendCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for extendCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::FixedBytes<4>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = extendReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-        ///Creates a new call builder for the [`fillRfqOrder`] function.
-        pub fn fillRfqOrder(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerTokenFillAmount: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, fillRfqOrderCall, N> {
-            self.call_builder(&fillRfqOrderCall {
-                order,
-                signature,
-                takerTokenFillAmount,
-            })
-        }
+            const SELECTOR: [u8; 4] = [110u8, 178u8, 36u8, 203u8];
+            const SIGNATURE: &'static str = "extend(bytes4,address)";
 
-        ///Creates a new call builder for the [`fillTakerSignedOtcOrder`]
-        /// function.
-        pub fn fillTakerSignedOtcOrder(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, fillTakerSignedOtcOrderCall, N> {
-            self.call_builder(&fillTakerSignedOtcOrderCall {
-                order,
-                makerSignature,
-                takerSignature,
-            })
-        }
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
 
-        ///Creates a new call builder for the [`fillTakerSignedOtcOrderForEth`]
-        /// function.
-        pub fn fillTakerSignedOtcOrderForEth(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-            makerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            takerSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, fillTakerSignedOtcOrderForEthCall, N> {
-            self.call_builder(&fillTakerSignedOtcOrderForEthCall {
-                order,
-                makerSignature,
-                takerSignature,
-            })
-        }
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.r#impl,
+                    ),
+                )
+            }
 
-        ///Creates a new call builder for the [`getERC1155OrderHash`] function.
-        pub fn getERC1155OrderHash(
-            &self,
-            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getERC1155OrderHashCall, N> {
-            self.call_builder(&getERC1155OrderHashCall { order })
-        }
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                extendReturn::_tokenize(ret)
+            }
 
-        ///Creates a new call builder for the [`getERC1155OrderInfo`] function.
-        pub fn getERC1155OrderInfo(
-            &self,
-            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getERC1155OrderInfoCall, N> {
-            self.call_builder(&getERC1155OrderInfoCall { order })
-        }
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
 
-        ///Creates a new call builder for the [`getERC721OrderHash`] function.
-        pub fn getERC721OrderHash(
-            &self,
-            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getERC721OrderHashCall, N> {
-            self.call_builder(&getERC721OrderHashCall { order })
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
         }
-
-        ///Creates a new call builder for the [`getERC721OrderStatus`]
-        /// function.
-        pub fn getERC721OrderStatus(
-            &self,
-            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getERC721OrderStatusCall, N> {
-            self.call_builder(&getERC721OrderStatusCall { order })
+    };
+    #[derive()]
+    /**Function with signature `fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)` and selector `0x9240529c`.
+    ```solidity
+    function fillOrKillLimitOrder(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature, uint128 takerTokenFillAmount) external payable returns (uint128 makerTokenFilledAmount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOrKillLimitOrderCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub takerTokenFillAmount: u128,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,
+    /// address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,
+    /// bytes32),uint128)`](fillOrKillLimitOrderCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct fillOrKillLimitOrderReturn {
+        #[allow(missing_docs)]
+        pub makerTokenFilledAmount: u128,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+                u128,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOrKillLimitOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOrKillLimitOrderCall) -> Self {
+                    (value.order, value.signature, value.takerTokenFillAmount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillLimitOrderCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                        takerTokenFillAmount: tuple.2,
+                    }
+                }
+            }
         }
-
-        ///Creates a new call builder for the [`getERC721OrderStatusBitVector`]
-        /// function.
-        pub fn getERC721OrderStatusBitVector(
-            &self,
-            maker: alloy_sol_types::private::Address,
-            nonceRange: alloy_sol_types::private::primitives::aliases::U248,
-        ) -> alloy_contract::SolCallBuilder<&P, getERC721OrderStatusBitVectorCall, N> {
-            self.call_builder(&getERC721OrderStatusBitVectorCall { maker, nonceRange })
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u128,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<fillOrKillLimitOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: fillOrKillLimitOrderReturn) -> Self {
+                    (value.makerTokenFilledAmount,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for fillOrKillLimitOrderReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        makerTokenFilledAmount: tuple.0,
+                    }
+                }
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for fillOrKillLimitOrderCall {
+            type Parameters<'a> = (
+                LibNativeOrder::LimitOrder,
+                LibSignature::Signature,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
+            type Return = u128;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-        ///Creates a new call builder for the [`getLimitOrderHash`] function.
-        pub fn getLimitOrderHash(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderHashCall, N> {
-            self.call_builder(&getLimitOrderHashCall { order })
-        }
+            const SELECTOR: [u8; 4] = [146u8, 64u8, 82u8, 156u8];
+            const SIGNATURE: &'static str =
+                "fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,\
+                 address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)";
 
-        ///Creates a new call builder for the [`getLimitOrderInfo`] function.
-        pub fn getLimitOrderInfo(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderInfoCall, N> {
-            self.call_builder(&getLimitOrderInfoCall { order })
-        }
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
 
-        ///Creates a new call builder for the [`getLimitOrderRelevantState`]
-        /// function.
-        pub fn getLimitOrderRelevantState(
-            &self,
-            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderRelevantStateCall, N> {
-            self.call_builder(&getLimitOrderRelevantStateCall { order, signature })
-        }
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.takerTokenFillAmount,
+                    ),
+                )
+            }
 
-        ///Creates a new call builder for the
-        /// [`getMetaTransactionExecutedBlock`] function.
-        pub fn getMetaTransactionExecutedBlock(
-            &self,
-            mtx: <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getMetaTransactionExecutedBlockCall, N> {
-            self.call_builder(&getMetaTransactionExecutedBlockCall { mtx })
-        }
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: fillOrKillLimitOrderReturn = r.into();
+                        r.makerTokenFilledAmount
+                    },
+                )
+            }
 
-        ///Creates a new call builder for the [`getMetaTransactionHash`]
-        /// function.
-        pub fn getMetaTransactionHash(
-            &self,
-            mtx: <IMetaTransactionsFeature::MetaTransactionData as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getMetaTransactionHashCall, N> {
-            self.call_builder(&getMetaTransactionHashCall { mtx })
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: fillOrKillLimitOrderReturn = r.into();
+                    r.makerTokenFilledAmount
+                })
+            }
         }
-
-        ///Creates a new call builder for the
-        /// [`getMetaTransactionHashExecutedBlock`] function.
-        pub fn getMetaTransactionHashExecutedBlock(
-            &self,
-            mtxHash: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, getMetaTransactionHashExecutedBlockCall, N>
+    };
+    #[derive()]
+    /**Function with signature `getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))` and selector `0x1fb09795`.
+    ```solidity
+    function getLimitOrderRelevantState(LibNativeOrder.LimitOrder memory order, LibSignature.Signature memory signature) external view returns (LibNativeOrder.OrderInfo memory orderInfo, uint128 actualFillableTakerTokenAmount, bool isSignatureValid);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderRelevantStateCall {
+        #[allow(missing_docs)]
+        pub order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+    }
+    #[derive()]
+    ///Container type for the return parameters of the
+    /// [`getLimitOrderRelevantState((address,address,uint128,uint128,uint128,
+    /// address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,
+    /// bytes32,bytes32))`](getLimitOrderRelevantStateCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct getLimitOrderRelevantStateReturn {
+        #[allow(missing_docs)]
+        pub orderInfo: <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub actualFillableTakerTokenAmount: u128,
+        #[allow(missing_docs)]
+        pub isSignatureValid: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         {
-            self.call_builder(&getMetaTransactionHashExecutedBlockCall { mtxHash })
-        }
-
-        ///Creates a new call builder for the [`getOtcOrderHash`] function.
-        pub fn getOtcOrderHash(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getOtcOrderHashCall, N> {
-            self.call_builder(&getOtcOrderHashCall { order })
-        }
-
-        ///Creates a new call builder for the [`getOtcOrderInfo`] function.
-        pub fn getOtcOrderInfo(
-            &self,
-            order: <LibNativeOrder::OtcOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getOtcOrderInfoCall, N> {
-            self.call_builder(&getOtcOrderInfoCall { order })
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (LibNativeOrder::LimitOrder, LibSignature::Signature);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+                <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderRelevantStateCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderRelevantStateCall) -> Self {
+                    (value.order, value.signature)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderRelevantStateCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        order: tuple.0,
+                        signature: tuple.1,
+                    }
+                }
+            }
         }
-
-        ///Creates a new call builder for the [`getProtocolFeeMultiplier`]
-        /// function.
-        pub fn getProtocolFeeMultiplier(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getProtocolFeeMultiplierCall, N> {
-            self.call_builder(&getProtocolFeeMultiplierCall)
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                LibNativeOrder::OrderInfo,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::RustType,
+                u128,
+                bool,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<getLimitOrderRelevantStateReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getLimitOrderRelevantStateReturn) -> Self {
+                    (
+                        value.orderInfo,
+                        value.actualFillableTakerTokenAmount,
+                        value.isSignatureValid,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getLimitOrderRelevantStateReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        orderInfo: tuple.0,
+                        actualFillableTakerTokenAmount: tuple.1,
+                        isSignatureValid: tuple.2,
+                    }
+                }
+            }
         }
-
-        ///Creates a new call builder for the [`getQuoteSigner`] function.
-        pub fn getQuoteSigner(&self) -> alloy_contract::SolCallBuilder<&P, getQuoteSignerCall, N> {
-            self.call_builder(&getQuoteSignerCall)
+        impl getLimitOrderRelevantStateReturn {
+            fn _tokenize(
+                &self,
+            ) -> <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
+            {
+                (
+                    <LibNativeOrder::OrderInfo as alloy_sol_types::SolType>::tokenize(
+                        &self.orderInfo,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.actualFillableTakerTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.isSignatureValid,
+                    ),
+                )
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for getLimitOrderRelevantStateCall {
+            type Parameters<'a> = (LibNativeOrder::LimitOrder, LibSignature::Signature);
+            type Return = getLimitOrderRelevantStateReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (
+                LibNativeOrder::OrderInfo,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bool,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-        ///Creates a new call builder for the [`getRfqOrderHash`] function.
-        pub fn getRfqOrderHash(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getRfqOrderHashCall, N> {
-            self.call_builder(&getRfqOrderHashCall { order })
-        }
+            const SELECTOR: [u8; 4] = [31u8, 176u8, 151u8, 149u8];
+            const SIGNATURE: &'static str =
+                "getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,\
+                 address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))";
 
-        ///Creates a new call builder for the [`getRfqOrderInfo`] function.
-        pub fn getRfqOrderInfo(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getRfqOrderInfoCall, N> {
-            self.call_builder(&getRfqOrderInfoCall { order })
-        }
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
 
-        ///Creates a new call builder for the [`getRfqOrderRelevantState`]
-        /// function.
-        pub fn getRfqOrderRelevantState(
-            &self,
-            order: <LibNativeOrder::RfqOrder as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, getRfqOrderRelevantStateCall, N> {
-            self.call_builder(&getRfqOrderRelevantStateCall { order, signature })
-        }
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::tokenize(&self.order),
+                    <LibSignature::Signature as alloy_sol_types::SolType>::tokenize(
+                        &self.signature,
+                    ),
+                )
+            }
 
-        ///Creates a new call builder for the [`getRollbackEntryAtIndex`]
-        /// function.
-        pub fn getRollbackEntryAtIndex(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-            idx: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getRollbackEntryAtIndexCall, N> {
-            self.call_builder(&getRollbackEntryAtIndexCall { selector, idx })
-        }
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                getLimitOrderRelevantStateReturn::_tokenize(ret)
+            }
 
-        ///Creates a new call builder for the [`getRollbackLength`] function.
-        pub fn getRollbackLength(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, getRollbackLengthCall, N> {
-            self.call_builder(&getRollbackLengthCall { selector })
-        }
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
 
-        ///Creates a new call builder for the [`getTransformWallet`] function.
-        pub fn getTransformWallet(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getTransformWalletCall, N> {
-            self.call_builder(&getTransformWalletCall)
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
         }
-
-        ///Creates a new call builder for the [`getTransformerDeployer`]
-        /// function.
-        pub fn getTransformerDeployer(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, getTransformerDeployerCall, N> {
-            self.call_builder(&getTransformerDeployerCall)
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `owner()` and selector `0x8da5cb5b`.
+    ```solidity
+    function owner() external view returns (address ownerAddress);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`owner()`](ownerCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct ownerReturn {
+        #[allow(missing_docs)]
+        pub ownerAddress: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
         }
-
-        ///Creates a new call builder for the [`isValidOrderSigner`] function.
-        pub fn isValidOrderSigner(
-            &self,
-            maker: alloy_sol_types::private::Address,
-            signer: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, isValidOrderSignerCall, N> {
-            self.call_builder(&isValidOrderSignerCall { maker, signer })
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: ownerReturn) -> Self {
+                    (value.ownerAddress,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        ownerAddress: tuple.0,
+                    }
+                }
+            }
         }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for ownerCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-        ///Creates a new call builder for the [`lastOtcTxOriginNonce`]
-        /// function.
-        pub fn lastOtcTxOriginNonce(
-            &self,
-            txOrigin: alloy_sol_types::private::Address,
-            nonceBucket: u64,
-        ) -> alloy_contract::SolCallBuilder<&P, lastOtcTxOriginNonceCall, N> {
-            self.call_builder(&lastOtcTxOriginNonceCall {
-                txOrigin,
-                nonceBucket,
-            })
-        }
+            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
+            const SIGNATURE: &'static str = "owner()";
 
-        ///Creates a new call builder for the [`matchERC721Orders`] function.
-        pub fn matchERC721Orders(
-            &self,
-            sellOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            sellOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            buyOrderSignature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, matchERC721OrdersCall, N> {
-            self.call_builder(&matchERC721OrdersCall {
-                sellOrder,
-                buyOrder,
-                sellOrderSignature,
-                buyOrderSignature,
-            })
-        }
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
 
-        ///Creates a new call builder for the [`migrate`] function.
-        pub fn migrate(
-            &self,
-            target: alloy_sol_types::private::Address,
-            data: alloy_sol_types::private::Bytes,
-            newOwner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, migrateCall, N> {
-            self.call_builder(&migrateCall {
-                target,
-                data,
-                newOwner,
-            })
-        }
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
 
-        ///Creates a new call builder for the [`multiplexBatchSellEthForToken`]
-        /// function.
-        pub fn multiplexBatchSellEthForToken(
-            &self,
-            outputToken: alloy_sol_types::private::Address,
-            calls: alloy_sol_types::private::Vec<
-                <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-            >,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, multiplexBatchSellEthForTokenCall, N> {
-            self.call_builder(&multiplexBatchSellEthForTokenCall {
-                outputToken,
-                calls,
-                minBuyAmount,
-            })
-        }
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
 
-        ///Creates a new call builder for the [`multiplexBatchSellTokenForEth`]
-        /// function.
-        pub fn multiplexBatchSellTokenForEth(
-            &self,
-            inputToken: alloy_sol_types::private::Address,
-            calls: alloy_sol_types::private::Vec<
-                <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-            >,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, multiplexBatchSellTokenForEthCall, N> {
-            self.call_builder(&multiplexBatchSellTokenForEthCall {
-                inputToken,
-                calls,
-                sellAmount,
-                minBuyAmount,
-            })
-        }
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: ownerReturn = r.into();
+                        r.ownerAddress
+                    },
+                )
+            }
 
-        ///Creates a new call builder for the
-        /// [`multiplexBatchSellTokenForToken`] function.
-        pub fn multiplexBatchSellTokenForToken(
-            &self,
-            inputToken: alloy_sol_types::private::Address,
-            outputToken: alloy_sol_types::private::Address,
-            calls: alloy_sol_types::private::Vec<
-                <IMultiplexFeature::BatchSellSubcall as alloy_sol_types::SolType>::RustType,
-            >,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, multiplexBatchSellTokenForTokenCall, N> {
-            self.call_builder(&multiplexBatchSellTokenForTokenCall {
-                inputToken,
-                outputToken,
-                calls,
-                sellAmount,
-                minBuyAmount,
-            })
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: ownerReturn = r.into();
+                    r.ownerAddress
+                })
+            }
         }
+    };
+    ///Container for all the [`IZeroex`](self) function calls.
+    #[derive(Clone)]
+    pub enum IZeroexCalls {
+        #[allow(missing_docs)]
+        extend(extendCall),
+        #[allow(missing_docs)]
+        fillOrKillLimitOrder(fillOrKillLimitOrderCall),
+        #[allow(missing_docs)]
+        getLimitOrderRelevantState(getLimitOrderRelevantStateCall),
+        #[allow(missing_docs)]
+        owner(ownerCall),
+    }
+    impl IZeroexCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [31u8, 176u8, 151u8, 149u8],
+            [110u8, 178u8, 36u8, 203u8],
+            [141u8, 165u8, 203u8, 91u8],
+            [146u8, 64u8, 82u8, 156u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <extendCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(getLimitOrderRelevantState),
+            ::core::stringify!(extend),
+            ::core::stringify!(owner),
+            ::core::stringify!(fillOrKillLimitOrder),
+        ];
 
-        ///Creates a new call builder for the
-        /// [`multiplexMultiHopSellEthForToken`] function.
-        pub fn multiplexMultiHopSellEthForToken(
-            &self,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            calls: alloy_sol_types::private::Vec<
-                <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-            >,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, multiplexMultiHopSellEthForTokenCall, N> {
-            self.call_builder(&multiplexMultiHopSellEthForTokenCall {
-                tokens,
-                calls,
-                minBuyAmount,
-            })
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
         }
 
-        ///Creates a new call builder for the
-        /// [`multiplexMultiHopSellTokenForEth`] function.
-        pub fn multiplexMultiHopSellTokenForEth(
-            &self,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            calls: alloy_sol_types::private::Vec<
-                <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-            >,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, multiplexMultiHopSellTokenForEthCall, N> {
-            self.call_builder(&multiplexMultiHopSellTokenForEthCall {
-                tokens,
-                calls,
-                sellAmount,
-                minBuyAmount,
-            })
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
         }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for IZeroexCalls {
+        const COUNT: usize = 4usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "IZeroexCalls";
 
-        ///Creates a new call builder for the
-        /// [`multiplexMultiHopSellTokenForToken`] function.
-        pub fn multiplexMultiHopSellTokenForToken(
-            &self,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            calls: alloy_sol_types::private::Vec<
-                <IMultiplexFeature::MultiHopSellSubcall as alloy_sol_types::SolType>::RustType,
-            >,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, multiplexMultiHopSellTokenForTokenCall, N> {
-            self.call_builder(&multiplexMultiHopSellTokenForTokenCall {
-                tokens,
-                calls,
-                sellAmount,
-                minBuyAmount,
-            })
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::extend(_) => <extendCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::fillOrKillLimitOrder(_) => {
+                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::getLimitOrderRelevantState(_) => {
+                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
         }
 
-        ///Creates a new call builder for the [`onERC1155Received`] function.
-        pub fn onERC1155Received(
-            &self,
-            operator: alloy_sol_types::private::Address,
-            from: alloy_sol_types::private::Address,
-            tokenId: alloy_sol_types::private::primitives::aliases::U256,
-            value: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
-            self.call_builder(&onERC1155ReceivedCall {
-                operator,
-                from,
-                tokenId,
-                value,
-                data,
-            })
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
         }
 
-        ///Creates a new call builder for the [`onERC721Received`] function.
-        pub fn onERC721Received(
-            &self,
-            operator: alloy_sol_types::private::Address,
-            from: alloy_sol_types::private::Address,
-            tokenId: alloy_sol_types::private::primitives::aliases::U256,
-            data: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
-            self.call_builder(&onERC721ReceivedCall {
-                operator,
-                from,
-                tokenId,
-                data,
-            })
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
         }
 
-        ///Creates a new call builder for the [`owner`] function.
-        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
-            self.call_builder(&ownerCall)
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IZeroexCalls>] = &[
+                {
+                    fn getLimitOrderRelevantState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
+                                data,
+                            )
+                            .map(IZeroexCalls::getLimitOrderRelevantState)
+                    }
+                    getLimitOrderRelevantState
+                },
+                {
+                    fn extend(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <extendCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::extend)
+                    }
+                    extend
+                },
+                {
+                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn fillOrKillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IZeroexCalls::fillOrKillLimitOrder)
+                    }
+                    fillOrKillLimitOrder
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
         }
 
-        ///Creates a new call builder for the [`preSignERC1155Order`] function.
-        pub fn preSignERC1155Order(
-            &self,
-            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, preSignERC1155OrderCall, N> {
-            self.call_builder(&preSignERC1155OrderCall { order })
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IZeroexCalls>] = &[
+                {
+                    fn getLimitOrderRelevantState(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::getLimitOrderRelevantState)
+                    }
+                    getLimitOrderRelevantState
+                },
+                {
+                    fn extend(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <extendCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::extend)
+                    }
+                    extend
+                },
+                {
+                    fn owner(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(IZeroexCalls::owner)
+                    }
+                    owner
+                },
+                {
+                    fn fillOrKillLimitOrder(data: &[u8]) -> alloy_sol_types::Result<IZeroexCalls> {
+                        <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IZeroexCalls::fillOrKillLimitOrder)
+                    }
+                    fillOrKillLimitOrder
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
         }
 
-        ///Creates a new call builder for the [`preSignERC721Order`] function.
-        pub fn preSignERC721Order(
-            &self,
-            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, preSignERC721OrderCall, N> {
-            self.call_builder(&preSignERC721OrderCall { order })
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::extend(inner) => {
+                    <extendCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::fillOrKillLimitOrder(inner) => {
+                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::getLimitOrderRelevantState(inner) => {
+                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
+                        inner,
+                    )
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
         }
 
-        ///Creates a new call builder for the [`registerAllowedOrderSigner`]
-        /// function.
-        pub fn registerAllowedOrderSigner(
-            &self,
-            signer: alloy_sol_types::private::Address,
-            allowed: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, registerAllowedOrderSignerCall, N> {
-            self.call_builder(&registerAllowedOrderSignerCall { signer, allowed })
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::extend(inner) => {
+                    <extendCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::fillOrKillLimitOrder(inner) => {
+                    <fillOrKillLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::getLimitOrderRelevantState(inner) => {
+                    <getLimitOrderRelevantStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
+                        inner, out,
+                    )
+                }
+                Self::owner(inner) => {
+                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
         }
+    }
+    ///Container for all the [`IZeroex`](self) events.
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    pub enum IZeroexEvents {
+        #[allow(missing_docs)]
+        ERC1155OrderCancelled(ERC1155OrderCancelled),
+        #[allow(missing_docs)]
+        ERC1155OrderFilled(ERC1155OrderFilled),
+        #[allow(missing_docs)]
+        ERC1155OrderPreSigned(ERC1155OrderPreSigned),
+        #[allow(missing_docs)]
+        ERC721OrderCancelled(ERC721OrderCancelled),
+        #[allow(missing_docs)]
+        ERC721OrderFilled(ERC721OrderFilled),
+        #[allow(missing_docs)]
+        ERC721OrderPreSigned(ERC721OrderPreSigned),
+        #[allow(missing_docs)]
+        LimitOrderFilled(LimitOrderFilled),
+        #[allow(missing_docs)]
+        LiquidityProviderSwap(LiquidityProviderSwap),
+        #[allow(missing_docs)]
+        MetaTransactionExecuted(MetaTransactionExecuted),
+        #[allow(missing_docs)]
+        Migrated(Migrated),
+        #[allow(missing_docs)]
+        OrderCancelled(OrderCancelled),
+        #[allow(missing_docs)]
+        OrderSignerRegistered(OrderSignerRegistered),
+        #[allow(missing_docs)]
+        OtcOrderFilled(OtcOrderFilled),
+        #[allow(missing_docs)]
+        OwnershipTransferred(OwnershipTransferred),
+        #[allow(missing_docs)]
+        PairCancelledLimitOrders(PairCancelledLimitOrders),
+        #[allow(missing_docs)]
+        PairCancelledRfqOrders(PairCancelledRfqOrders),
+        #[allow(missing_docs)]
+        ProxyFunctionUpdated(ProxyFunctionUpdated),
+        #[allow(missing_docs)]
+        QuoteSignerUpdated(QuoteSignerUpdated),
+        #[allow(missing_docs)]
+        RfqOrderFilled(RfqOrderFilled),
+        #[allow(missing_docs)]
+        RfqOrderOriginsAllowed(RfqOrderOriginsAllowed),
+        #[allow(missing_docs)]
+        TransformedERC20(TransformedERC20),
+        #[allow(missing_docs)]
+        TransformerDeployerUpdated(TransformerDeployerUpdated),
+    }
+    impl IZeroexEvents {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 32usize]] = &[
+            [
+                2u8, 223u8, 234u8, 213u8, 235u8, 118u8, 155u8, 41u8, 142u8, 130u8, 221u8, 150u8,
+                80u8, 179u8, 28u8, 64u8, 85u8, 154u8, 61u8, 66u8, 112u8, 29u8, 191u8, 83u8, 201u8,
+                49u8, 188u8, 38u8, 130u8, 132u8, 124u8, 49u8,
+            ],
+            [
+                15u8, 102u8, 114u8, 247u8, 138u8, 89u8, 186u8, 142u8, 94u8, 91u8, 93u8, 56u8,
+                223u8, 62u8, 188u8, 103u8, 243u8, 199u8, 146u8, 226u8, 201u8, 37u8, 155u8, 141u8,
+                151u8, 215u8, 240u8, 13u8, 215u8, 139u8, 161u8, 179u8,
+            ],
+            [
+                32u8, 204u8, 168u8, 27u8, 14u8, 38u8, 155u8, 38u8, 91u8, 50u8, 41u8, 214u8, 181u8,
+                55u8, 218u8, 145u8, 239u8, 71u8, 92u8, 160u8, 239u8, 85u8, 202u8, 237u8, 125u8,
+                211u8, 7u8, 49u8, 112u8, 11u8, 169u8, 141u8,
+            ],
+            [
+                42u8, 226u8, 33u8, 8u8, 52u8, 103u8, 222u8, 82u8, 7u8, 139u8, 0u8, 150u8, 105u8,
+                106u8, 184u8, 141u8, 141u8, 83u8, 167u8, 236u8, 180u8, 75u8, 182u8, 91u8, 86u8,
+                162u8, 186u8, 182u8, 135u8, 89u8, 131u8, 103u8,
+            ],
+            [
+                64u8, 166u8, 186u8, 149u8, 19u8, 208u8, 158u8, 52u8, 136u8, 19u8, 94u8, 14u8, 13u8,
+                16u8, 226u8, 212u8, 56u8, 43u8, 121u8, 39u8, 32u8, 21u8, 91u8, 20u8, 76u8, 190u8,
+                168u8, 154u8, 201u8, 219u8, 109u8, 52u8,
+            ],
+            [
+                77u8, 94u8, 167u8, 218u8, 100u8, 245u8, 10u8, 74u8, 50u8, 153u8, 33u8, 184u8,
+                210u8, 202u8, 181u8, 45u8, 255u8, 78u8, 188u8, 197u8, 139u8, 97u8, 209u8, 15u8,
+                248u8, 57u8, 226u8, 142u8, 145u8, 68u8, 86u8, 132u8,
+            ],
+            [
+                80u8, 39u8, 63u8, 160u8, 34u8, 115u8, 204u8, 238u8, 169u8, 207u8, 8u8, 91u8, 66u8,
+                222u8, 92u8, 138u8, 246u8, 6u8, 36u8, 20u8, 1u8, 104u8, 189u8, 113u8, 53u8, 125u8,
+                184u8, 51u8, 83u8, 88u8, 119u8, 175u8,
+            ],
+            [
+                94u8, 145u8, 221u8, 254u8, 183u8, 191u8, 46u8, 18u8, 247u8, 232u8, 171u8, 1u8,
+                125u8, 43u8, 99u8, 169u8, 33u8, 127u8, 0u8, 74u8, 21u8, 165u8, 51u8, 70u8, 173u8,
+                144u8, 53u8, 62u8, 198u8, 61u8, 20u8, 228u8,
+            ],
+            [
+                110u8, 169u8, 219u8, 232u8, 178u8, 204u8, 17u8, 147u8, 72u8, 113u8, 106u8, 146u8,
+                32u8, 160u8, 116u8, 42u8, 214u8, 43u8, 120u8, 132u8, 236u8, 176u8, 255u8, 75u8,
+                50u8, 205u8, 80u8, 129u8, 33u8, 253u8, 147u8, 121u8,
+            ],
+            [
+                127u8, 79u8, 227u8, 255u8, 138u8, 228u8, 64u8, 225u8, 87u8, 12u8, 85u8, 141u8,
+                160u8, 132u8, 64u8, 178u8, 111u8, 137u8, 251u8, 28u8, 31u8, 41u8, 16u8, 205u8,
+                145u8, 202u8, 100u8, 82u8, 149u8, 95u8, 18u8, 26u8,
+            ],
+            [
+                130u8, 159u8, 169u8, 157u8, 148u8, 220u8, 70u8, 54u8, 146u8, 91u8, 56u8, 99u8,
+                46u8, 98u8, 87u8, 54u8, 166u8, 20u8, 193u8, 84u8, 213u8, 80u8, 6u8, 183u8, 171u8,
+                107u8, 234u8, 151u8, 156u8, 33u8, 12u8, 50u8,
+            ],
+            [
+                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
+                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
+                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
+            ],
+            [
+                140u8, 93u8, 12u8, 65u8, 251u8, 22u8, 167u8, 49u8, 122u8, 108u8, 85u8, 255u8,
+                123u8, 169u8, 61u8, 157u8, 116u8, 247u8, 158u8, 67u8, 79u8, 239u8, 166u8, 148u8,
+                229u8, 13u8, 96u8, 40u8, 175u8, 191u8, 163u8, 240u8,
+            ],
+            [
+                160u8, 21u8, 173u8, 45u8, 195u8, 47u8, 38u8, 105u8, 147u8, 149u8, 138u8, 15u8,
+                217u8, 136u8, 76u8, 116u8, 107u8, 151u8, 27u8, 37u8, 66u8, 6u8, 243u8, 71u8, 139u8,
+                196u8, 62u8, 47u8, 18u8, 92u8, 123u8, 158u8,
+            ],
+            [
+                166u8, 235u8, 124u8, 220u8, 33u8, 158u8, 21u8, 24u8, 206u8, 217u8, 100u8, 233u8,
+                163u8, 78u8, 97u8, 214u8, 138u8, 148u8, 228u8, 241u8, 86u8, 157u8, 179u8, 232u8,
+                66u8, 86u8, 186u8, 152u8, 27u8, 165u8, 39u8, 83u8,
+            ],
+            [
+                169u8, 31u8, 231u8, 174u8, 98u8, 252u8, 230u8, 105u8, 223u8, 44u8, 127u8, 136u8,
+                15u8, 140u8, 20u8, 209u8, 120u8, 83u8, 26u8, 174u8, 114u8, 81u8, 85u8, 88u8, 229u8,
+                201u8, 72u8, 227u8, 124u8, 50u8, 165u8, 114u8,
+            ],
+            [
+                171u8, 97u8, 77u8, 43u8, 115u8, 133u8, 67u8, 192u8, 234u8, 33u8, 245u8, 99u8, 71u8,
+                207u8, 105u8, 106u8, 58u8, 12u8, 66u8, 167u8, 203u8, 236u8, 50u8, 18u8, 165u8,
+                202u8, 34u8, 164u8, 220u8, 255u8, 33u8, 36u8,
+            ],
+            [
+                172u8, 117u8, 247u8, 115u8, 227u8, 169u8, 47u8, 26u8, 2u8, 177u8, 33u8, 52u8,
+                214u8, 94u8, 31u8, 71u8, 248u8, 161u8, 78u8, 171u8, 228u8, 234u8, 241u8, 226u8,
+                70u8, 36u8, 145u8, 142u8, 106u8, 139u8, 38u8, 159u8,
+            ],
+            [
+                225u8, 184u8, 49u8, 176u8, 230u8, 243u8, 170u8, 22u8, 180u8, 177u8, 166u8, 189u8,
+                82u8, 107u8, 92u8, 222u8, 171u8, 73u8, 64u8, 116u8, 76u8, 166u8, 224u8, 37u8, 31u8,
+                95u8, 229u8, 248u8, 202u8, 241u8, 200u8, 26u8,
+            ],
+            [
+                245u8, 85u8, 12u8, 94u8, 234u8, 25u8, 180u8, 138u8, 198u8, 235u8, 95u8, 3u8, 171u8,
+                220u8, 79u8, 89u8, 192u8, 166u8, 6u8, 151u8, 171u8, 179u8, 217u8, 115u8, 205u8,
+                104u8, 102u8, 151u8, 3u8, 181u8, 200u8, 185u8,
+            ],
+            [
+                253u8, 69u8, 96u8, 74u8, 186u8, 215u8, 156u8, 22u8, 226u8, 51u8, 72u8, 161u8, 55u8,
+                237u8, 130u8, 146u8, 102u8, 27u8, 225u8, 184u8, 235u8, 166u8, 228u8, 128u8, 110u8,
+                190u8, 214u8, 131u8, 59u8, 28u8, 4u8, 106u8,
+            ],
+            [
+                254u8, 127u8, 251u8, 30u8, 223u8, 231u8, 159u8, 77u8, 247u8, 22u8, 203u8, 45u8,
+                202u8, 210u8, 28u8, 242u8, 243u8, 27u8, 16u8, 77u8, 129u8, 106u8, 121u8, 118u8,
+                186u8, 30u8, 110u8, 70u8, 83u8, 193u8, 239u8, 177u8,
+            ],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TransformedERC20 as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC1155OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ProxyFunctionUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <LiquidityProviderSwap as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC1155OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC721OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderSignerRegistered as alloy_sol_types::SolEvent>::SIGNATURE,
+            <MetaTransactionExecuted as alloy_sol_types::SolEvent>::SIGNATURE,
+            <RfqOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC721OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE,
+            <ERC721OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PairCancelledLimitOrders as alloy_sol_types::SolEvent>::SIGNATURE,
+            <LimitOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <OtcOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE,
+            <Migrated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <QuoteSignerUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <TransformerDeployerUpdated as alloy_sol_types::SolEvent>::SIGNATURE,
+            <PairCancelledRfqOrders as alloy_sol_types::SolEvent>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(RfqOrderOriginsAllowed),
+            ::core::stringify!(TransformedERC20),
+            ::core::stringify!(ERC1155OrderFilled),
+            ::core::stringify!(ProxyFunctionUpdated),
+            ::core::stringify!(LiquidityProviderSwap),
+            ::core::stringify!(ERC1155OrderCancelled),
+            ::core::stringify!(ERC721OrderFilled),
+            ::core::stringify!(ERC1155OrderPreSigned),
+            ::core::stringify!(OrderSignerRegistered),
+            ::core::stringify!(MetaTransactionExecuted),
+            ::core::stringify!(RfqOrderFilled),
+            ::core::stringify!(OwnershipTransferred),
+            ::core::stringify!(ERC721OrderPreSigned),
+            ::core::stringify!(ERC721OrderCancelled),
+            ::core::stringify!(OrderCancelled),
+            ::core::stringify!(PairCancelledLimitOrders),
+            ::core::stringify!(LimitOrderFilled),
+            ::core::stringify!(OtcOrderFilled),
+            ::core::stringify!(Migrated),
+            ::core::stringify!(QuoteSignerUpdated),
+            ::core::stringify!(TransformerDeployerUpdated),
+            ::core::stringify!(PairCancelledRfqOrders),
+        ];
 
-        ///Creates a new call builder for the [`registerAllowedRfqOrigins`]
-        /// function.
-        pub fn registerAllowedRfqOrigins(
-            &self,
-            origins: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            allowed: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, registerAllowedRfqOriginsCall, N> {
-            self.call_builder(&registerAllowedRfqOriginsCall { origins, allowed })
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 32usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
         }
 
-        ///Creates a new call builder for the [`rollback`] function.
-        pub fn rollback(
-            &self,
-            selector: alloy_sol_types::private::FixedBytes<4>,
-            targetImpl: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, rollbackCall, N> {
-            self.call_builder(&rollbackCall {
-                selector,
-                targetImpl,
-            })
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 32usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
         }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolEventInterface for IZeroexEvents {
+        const COUNT: usize = 22usize;
+        const NAME: &'static str = "IZeroexEvents";
 
-        ///Creates a new call builder for the [`sellERC1155`] function.
-        pub fn sellERC1155(
-            &self,
-            buyOrder: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-            erc1155SellAmount: u128,
-            unwrapNativeToken: bool,
-            callbackData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, sellERC1155Call, N> {
-            self.call_builder(&sellERC1155Call {
-                buyOrder,
-                signature,
-                erc1155TokenId,
-                erc1155SellAmount,
-                unwrapNativeToken,
-                callbackData,
-            })
+        fn decode_raw_log(
+            topics: &[alloy_sol_types::Word],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            match topics.first().copied() {
+                Some(<ERC1155OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC1155OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC1155OrderCancelled)
+                }
+                Some(<ERC1155OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC1155OrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ERC1155OrderFilled)
+                }
+                Some(<ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC1155OrderPreSigned as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC1155OrderPreSigned)
+                }
+                Some(<ERC721OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC721OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC721OrderCancelled)
+                }
+                Some(<ERC721OrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC721OrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::ERC721OrderFilled)
+                }
+                Some(<ERC721OrderPreSigned as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ERC721OrderPreSigned as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ERC721OrderPreSigned)
+                }
+                Some(<LimitOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <LimitOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::LimitOrderFilled)
+                }
+                Some(<LiquidityProviderSwap as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <LiquidityProviderSwap as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::LiquidityProviderSwap)
+                }
+                Some(<MetaTransactionExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <MetaTransactionExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::MetaTransactionExecuted)
+                }
+                Some(<Migrated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <Migrated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::Migrated)
+                }
+                Some(<OrderCancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderCancelled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OrderCancelled)
+                }
+                Some(<OrderSignerRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OrderSignerRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::OrderSignerRegistered)
+                }
+                Some(<OtcOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OtcOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::OtcOrderFilled)
+                }
+                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::OwnershipTransferred)
+                }
+                Some(<PairCancelledLimitOrders as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PairCancelledLimitOrders as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::PairCancelledLimitOrders)
+                }
+                Some(<PairCancelledRfqOrders as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <PairCancelledRfqOrders as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::PairCancelledRfqOrders)
+                }
+                Some(<ProxyFunctionUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <ProxyFunctionUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::ProxyFunctionUpdated)
+                }
+                Some(<QuoteSignerUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <QuoteSignerUpdated as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::QuoteSignerUpdated)
+                }
+                Some(<RfqOrderFilled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RfqOrderFilled as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::RfqOrderFilled)
+                }
+                Some(<RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <RfqOrderOriginsAllowed as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::RfqOrderOriginsAllowed)
+                }
+                Some(<TransformedERC20 as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TransformedERC20 as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
+                        .map(Self::TransformedERC20)
+                }
+                Some(<TransformerDeployerUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
+                    <TransformerDeployerUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
+                        topics, data,
+                    )
+                    .map(Self::TransformerDeployerUpdated)
+                }
+                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
+                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
+                    log: alloy_sol_types::private::Box::new(
+                        alloy_sol_types::private::LogData::new_unchecked(
+                            topics.to_vec(),
+                            data.to_vec().into(),
+                        ),
+                    ),
+                }),
+            }
         }
-
-        ///Creates a new call builder for the [`sellERC721`] function.
-        pub fn sellERC721(
-            &self,
-            buyOrder: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-            erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-            unwrapNativeToken: bool,
-            callbackData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, sellERC721Call, N> {
-            self.call_builder(&sellERC721Call {
-                buyOrder,
-                signature,
-                erc721TokenId,
-                unwrapNativeToken,
-                callbackData,
-            })
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::private::IntoLogData for IZeroexEvents {
+        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ERC1155OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC1155OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC1155OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC721OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC721OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ERC721OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::LimitOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::LiquidityProviderSwap(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::MetaTransactionExecuted(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::Migrated(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
+                Self::OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OrderSignerRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OtcOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::OwnershipTransferred(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PairCancelledLimitOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::PairCancelledRfqOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::ProxyFunctionUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::QuoteSignerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RfqOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::RfqOrderOriginsAllowed(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TransformedERC20(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+                Self::TransformerDeployerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
+                }
+            }
         }
 
-        ///Creates a new call builder for the [`sellEthForTokenToUniswapV3`]
-        /// function.
-        pub fn sellEthForTokenToUniswapV3(
-            &self,
-            encodedPath: alloy_sol_types::private::Bytes,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            recipient: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, sellEthForTokenToUniswapV3Call, N> {
-            self.call_builder(&sellEthForTokenToUniswapV3Call {
-                encodedPath,
-                minBuyAmount,
-                recipient,
-            })
+        fn into_log_data(self) -> alloy_sol_types::private::LogData {
+            match self {
+                Self::ERC1155OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC1155OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC1155OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC721OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC721OrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ERC721OrderPreSigned(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::LimitOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::LiquidityProviderSwap(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::MetaTransactionExecuted(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::Migrated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderCancelled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OrderSignerRegistered(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OtcOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::OwnershipTransferred(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PairCancelledLimitOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::PairCancelledRfqOrders(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::ProxyFunctionUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::QuoteSignerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RfqOrderFilled(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::RfqOrderOriginsAllowed(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TransformedERC20(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+                Self::TransformerDeployerUpdated(inner) => {
+                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
+                }
+            }
         }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IZeroex`](self) contract instance.
 
-        ///Creates a new call builder for the [`sellToLiquidityProvider`]
-        /// function.
-        pub fn sellToLiquidityProvider(
-            &self,
-            inputToken: alloy_sol_types::private::Address,
-            outputToken: alloy_sol_types::private::Address,
-            provider: alloy_sol_types::private::Address,
-            recipient: alloy_sol_types::private::Address,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            auxiliaryData: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, sellToLiquidityProviderCall, N> {
-            self.call_builder(&sellToLiquidityProviderCall {
-                inputToken,
-                outputToken,
-                provider,
-                recipient,
-                sellAmount,
-                minBuyAmount,
-                auxiliaryData,
-            })
-        }
+    See the [wrapper's documentation](`IZeroexInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IZeroexInstance<P, N> {
+        IZeroexInstance::<P, N>::new(address, __provider)
+    }
+    /**A [`IZeroex`](self) instance.
 
-        ///Creates a new call builder for the [`sellToPancakeSwap`] function.
-        pub fn sellToPancakeSwap(
-            &self,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            fork: <IPancakeSwapFeature::ProtocolFork as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, sellToPancakeSwapCall, N> {
-            self.call_builder(&sellToPancakeSwapCall {
-                tokens,
-                sellAmount,
-                minBuyAmount,
-                fork,
-            })
-        }
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IZeroex`](self) contract located at a given `address`, using a given
+    provider `P`.
 
-        ///Creates a new call builder for the [`sellToUniswap`] function.
-        pub fn sellToUniswap(
-            &self,
-            tokens: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            isSushi: bool,
-        ) -> alloy_contract::SolCallBuilder<&P, sellToUniswapCall, N> {
-            self.call_builder(&sellToUniswapCall {
-                tokens,
-                sellAmount,
-                minBuyAmount,
-                isSushi,
-            })
-        }
+    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.
 
-        ///Creates a new call builder for the [`sellTokenForEthToUniswapV3`]
-        /// function.
-        pub fn sellTokenForEthToUniswapV3(
-            &self,
-            encodedPath: alloy_sol_types::private::Bytes,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            recipient: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, sellTokenForEthToUniswapV3Call, N> {
-            self.call_builder(&sellTokenForEthToUniswapV3Call {
-                encodedPath,
-                sellAmount,
-                minBuyAmount,
-                recipient,
-            })
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IZeroexInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IZeroexInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IZeroexInstance")
+                .field(&self.address)
+                .finish()
         }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IZeroexInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IZeroex`](self) contract instance.
 
-        ///Creates a new call builder for the [`sellTokenForTokenToUniswapV3`]
-        /// function.
-        pub fn sellTokenForTokenToUniswapV3(
-            &self,
-            encodedPath: alloy_sol_types::private::Bytes,
-            sellAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minBuyAmount: alloy_sol_types::private::primitives::aliases::U256,
-            recipient: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, sellTokenForTokenToUniswapV3Call, N> {
-            self.call_builder(&sellTokenForTokenToUniswapV3Call {
-                encodedPath,
-                sellAmount,
-                minBuyAmount,
-                recipient,
-            })
+        See the [wrapper's documentation](`IZeroexInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
         }
 
-        ///Creates a new call builder for the [`setQuoteSigner`] function.
-        pub fn setQuoteSigner(
-            &self,
-            quoteSigner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setQuoteSignerCall, N> {
-            self.call_builder(&setQuoteSignerCall { quoteSigner })
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
         }
 
-        ///Creates a new call builder for the [`setTransformerDeployer`]
-        /// function.
-        pub fn setTransformerDeployer(
-            &self,
-            transformerDeployer: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setTransformerDeployerCall, N> {
-            self.call_builder(&setTransformerDeployerCall {
-                transformerDeployer,
-            })
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
         }
 
-        ///Creates a new call builder for the [`supportInterface`] function.
-        pub fn supportInterface(
-            &self,
-            interfaceId: alloy_sol_types::private::FixedBytes<4>,
-        ) -> alloy_contract::SolCallBuilder<&P, supportInterfaceCall, N> {
-            self.call_builder(&supportInterfaceCall { interfaceId })
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
         }
 
-        ///Creates a new call builder for the [`transferOwnership`] function.
-        pub fn transferOwnership(
-            &self,
-            newOwner: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
-            self.call_builder(&transferOwnershipCall { newOwner })
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
         }
-
-        ///Creates a new call builder for the [`transferProtocolFeesForPools`]
-        /// function.
-        pub fn transferProtocolFeesForPools(
-            &self,
-            poolIds: alloy_sol_types::private::Vec<alloy_sol_types::private::FixedBytes<32>>,
-        ) -> alloy_contract::SolCallBuilder<&P, transferProtocolFeesForPoolsCall, N> {
-            self.call_builder(&transferProtocolFeesForPoolsCall { poolIds })
+    }
+    impl<P: ::core::clone::Clone, N> IZeroexInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IZeroexInstance<P, N> {
+            IZeroexInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
         }
-
-        ///Creates a new call builder for the [`transferTrappedTokensTo`]
-        /// function.
-        pub fn transferTrappedTokensTo(
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IZeroexInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
             &self,
-            erc20: alloy_sol_types::private::Address,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            recipientWallet: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, transferTrappedTokensToCall, N> {
-            self.call_builder(&transferTrappedTokensToCall {
-                erc20,
-                amountOut,
-                recipientWallet,
-            })
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`transformERC20`] function.
-        pub fn transformERC20(
+        ///Creates a new call builder for the [`extend`] function.
+        pub fn extend(
             &self,
-            inputToken: alloy_sol_types::private::Address,
-            outputToken: alloy_sol_types::private::Address,
-            inputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-            minOutputTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-            transformations: alloy_sol_types::private::Vec<
-                <ITransformERC20Feature::Transformation as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, transformERC20Call, N> {
-            self.call_builder(&transformERC20Call {
-                inputToken,
-                outputToken,
-                inputTokenAmount,
-                minOutputTokenAmount,
-                transformations,
-            })
+            selector: alloy_sol_types::private::FixedBytes<4>,
+            r#impl: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, extendCall, N> {
+            self.call_builder(&extendCall { selector, r#impl })
         }
 
-        ///Creates a new call builder for the [`uniswapV3SwapCallback`]
+        ///Creates a new call builder for the [`fillOrKillLimitOrder`]
         /// function.
-        pub fn uniswapV3SwapCallback(
-            &self,
-            amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
-            amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
-            data: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, uniswapV3SwapCallbackCall, N> {
-            self.call_builder(&uniswapV3SwapCallbackCall {
-                amount0Delta,
-                amount1Delta,
-                data,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`validateERC1155OrderProperties`] function.
-        pub fn validateERC1155OrderProperties(
+        pub fn fillOrKillLimitOrder(
             &self,
-            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
-            erc1155TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, validateERC1155OrderPropertiesCall, N> {
-            self.call_builder(&validateERC1155OrderPropertiesCall {
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
+            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
+            takerTokenFillAmount: u128,
+        ) -> alloy_contract::SolCallBuilder<&P, fillOrKillLimitOrderCall, N> {
+            self.call_builder(&fillOrKillLimitOrderCall {
                 order,
-                erc1155TokenId,
+                signature,
+                takerTokenFillAmount,
             })
         }
 
-        ///Creates a new call builder for the [`validateERC1155OrderSignature`]
+        ///Creates a new call builder for the [`getLimitOrderRelevantState`]
         /// function.
-        pub fn validateERC1155OrderSignature(
+        pub fn getLimitOrderRelevantState(
             &self,
-            order: <LibNFTOrder::ERC1155Order as alloy_sol_types::SolType>::RustType,
+            order: <LibNativeOrder::LimitOrder as alloy_sol_types::SolType>::RustType,
             signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, validateERC1155OrderSignatureCall, N> {
-            self.call_builder(&validateERC1155OrderSignatureCall { order, signature })
-        }
-
-        ///Creates a new call builder for the [`validateERC721OrderProperties`]
-        /// function.
-        pub fn validateERC721OrderProperties(
-            &self,
-            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            erc721TokenId: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, validateERC721OrderPropertiesCall, N> {
-            self.call_builder(&validateERC721OrderPropertiesCall {
-                order,
-                erc721TokenId,
-            })
+        ) -> alloy_contract::SolCallBuilder<&P, getLimitOrderRelevantStateCall, N> {
+            self.call_builder(&getLimitOrderRelevantStateCall { order, signature })
         }
 
-        ///Creates a new call builder for the [`validateERC721OrderSignature`]
-        /// function.
-        pub fn validateERC721OrderSignature(
-            &self,
-            order: <LibNFTOrder::ERC721Order as alloy_sol_types::SolType>::RustType,
-            signature: <LibSignature::Signature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, validateERC721OrderSignatureCall, N> {
-            self.call_builder(&validateERC721OrderSignatureCall { order, signature })
+        ///Creates a new call builder for the [`owner`] function.
+        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
+            self.call_builder(&ownerCall)
         }
     }
     /// Event filters.
diff --git a/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs b/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs
index 2815eb02ab..1e034b5f65 100644
--- a/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs
+++ b/contracts/generated/contracts-generated/liquoricesettlement/src/lib.rs
@@ -2147,7 +2147,6 @@ pub mod ILiquoriceSettlement {
 library Signature {
     type TransferCommand is uint8;
     type Type is uint8;
-    struct TakerPermitInfo { bytes signature; uint48 nonce; uint48 deadline; }
     struct TypedSignature { Type signatureType; TransferCommand transferCommand; bytes signatureBytes; }
 }
 ```*/
@@ -2430,239 +2429,6 @@ pub mod Signature {
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**```solidity
-    struct TakerPermitInfo { bytes signature; uint48 nonce; uint48 deadline; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct TakerPermitInfo {
-        #[allow(missing_docs)]
-        pub signature: alloy_sol_types::private::Bytes,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U48,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Bytes,
-            alloy_sol_types::sol_data::Uint<48>,
-            alloy_sol_types::sol_data::Uint<48>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Bytes,
-            alloy_sol_types::private::primitives::aliases::U48,
-            alloy_sol_types::private::primitives::aliases::U48,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<TakerPermitInfo> for UnderlyingRustTuple<'_> {
-            fn from(value: TakerPermitInfo) -> Self {
-                (value.signature, value.nonce, value.deadline)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TakerPermitInfo {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    signature: tuple.0,
-                    nonce: tuple.1,
-                    deadline: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for TakerPermitInfo {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for TakerPermitInfo {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for TakerPermitInfo {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for TakerPermitInfo {
-            const NAME: &'static str = "TakerPermitInfo";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "TakerPermitInfo(bytes signature,uint48 nonce,uint48 deadline)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.signature,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for TakerPermitInfo {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.signature,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-                    + <alloy_sol_types::sol_data::Uint<
-                        48,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deadline,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.signature,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    48,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    48,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deadline,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
     struct TypedSignature { Type signatureType; TransferCommand transferCommand; bytes signatureBytes; }
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
@@ -3073,11 +2839,6 @@ library ILiquoriceSettlement {
 library Signature {
     type TransferCommand is uint8;
     type Type is uint8;
-    struct TakerPermitInfo {
-        bytes signature;
-        uint48 nonce;
-        uint48 deadline;
-    }
     struct TypedSignature {
         Type signatureType;
         TransferCommand transferCommand;
@@ -3128,21 +2889,10 @@ interface LiquoriceSettlement {
     function AUTHENTICATOR() external view returns (address);
     function BALANCE_MANAGER() external view returns (address);
     function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function REPOSITORY() external view returns (address);
-    function cancelLimitOrder(uint256 nonce) external;
-    function hashBaseTokenData(ILiquoriceSettlement.BaseTokenData memory _baseTokenData) external pure returns (bytes32);
-    function hashOrder(ILiquoriceSettlement.Order memory _order) external view returns (bytes32);
-    function hashQuoteTokenData(ILiquoriceSettlement.QuoteTokenData memory _quoteTokenData) external pure returns (bytes32);
     function hashSingleOrder(ILiquoriceSettlement.Single memory _order) external view returns (bytes32);
     function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4);
     function settle(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature) external;
     function settleSingle(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature) external payable;
-    function settleSingleWithPermitsSignatures(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
-    function settleWithPermitsSignatures(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
-    function validateHooks(address _repository, GPv2Interaction.Hooks memory _hooks) external view;
-    function validateInteractions(address _repository, address _signer, bool _isPartialFill, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions) external view;
-    function validateOrderAmounts(ILiquoriceSettlement.Order memory _order) external pure;
-    function validateSignature(address _validationAddress, bytes32 _hash, Signature.TypedSignature memory _signature) external view;
 }
 ```
 
@@ -3215,308 +2965,60 @@ interface LiquoriceSettlement {
   },
   {
     "type": "function",
-    "name": "REPOSITORY",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IRepository"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "cancelLimitOrder",
-    "inputs": [
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "hashBaseTokenData",
+    "name": "hashSingleOrder",
     "inputs": [
       {
-        "name": "_baseTokenData",
+        "name": "_order",
         "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.BaseTokenData",
+        "internalType": "struct ILiquoriceSettlement.Single",
         "components": [
           {
-            "name": "addr",
+            "name": "rfqId",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "nonce",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "trader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "effectiveTrader",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "baseToken",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "quoteToken",
             "type": "address",
             "internalType": "address"
           },
           {
-            "name": "amount",
+            "name": "baseTokenAmount",
             "type": "uint256",
             "internalType": "uint256"
           },
           {
-            "name": "toRecipient",
+            "name": "quoteTokenAmount",
             "type": "uint256",
             "internalType": "uint256"
           },
           {
-            "name": "toRepay",
+            "name": "minFillAmount",
             "type": "uint256",
             "internalType": "uint256"
           },
           {
-            "name": "toSupply",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "hashOrder",
-    "inputs": [
-      {
-        "name": "_order",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.Order",
-        "components": [
-          {
-            "name": "market",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "chainId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "rfqId",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "trader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "effectiveTrader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "quoteExpiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minFillAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "baseTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRecipient",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRepay",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toSupply",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "quoteTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toTrader",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toWithdraw",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toBorrow",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "hashQuoteTokenData",
-    "inputs": [
-      {
-        "name": "_quoteTokenData",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-        "components": [
-          {
-            "name": "addr",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "toTrader",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "toWithdraw",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "toBorrow",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "hashSingleOrder",
-    "inputs": [
-      {
-        "name": "_order",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.Single",
-        "components": [
-          {
-            "name": "rfqId",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "trader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "effectiveTrader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "baseToken",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "quoteToken",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "baseTokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "quoteTokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "minFillAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "quoteExpiry",
+            "name": "quoteExpiry",
             "type": "uint256",
             "internalType": "uint256"
           },
@@ -3937,929 +3439,121 @@ interface LiquoriceSettlement {
     "stateMutability": "payable"
   },
   {
-    "type": "function",
-    "name": "settleSingleWithPermitsSignatures",
+    "type": "event",
+    "name": "Interaction",
     "inputs": [
       {
-        "name": "_signer",
+        "name": "target",
         "type": "address",
+        "indexed": true,
         "internalType": "address"
       },
       {
-        "name": "_order",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.Single",
-        "components": [
-          {
-            "name": "rfqId",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "trader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "effectiveTrader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "baseToken",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "quoteToken",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "baseTokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "quoteTokenAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "minFillAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "quoteExpiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          }
-        ]
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
       },
       {
-        "name": "_makerSignature",
-        "type": "tuple",
-        "internalType": "struct Signature.TypedSignature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum Signature.Type"
-          },
-          {
-            "name": "transferCommand",
-            "type": "uint8",
-            "internalType": "enum Signature.TransferCommand"
-          },
-          {
-            "name": "signatureBytes",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
+        "name": "selector",
+        "type": "bytes4",
+        "indexed": false,
+        "internalType": "bytes4"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "TradeOrder",
+    "inputs": [
+      {
+        "name": "rfqId",
+        "type": "string",
+        "indexed": true,
+        "internalType": "string"
       },
       {
-        "name": "_filledTakerAmount",
+        "name": "trader",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "effectiveTrader",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "baseToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "quoteToken",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "baseTokenAmount",
         "type": "uint256",
+        "indexed": false,
         "internalType": "uint256"
       },
       {
-        "name": "_takerSignature",
-        "type": "tuple",
-        "internalType": "struct Signature.TypedSignature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum Signature.Type"
-          },
-          {
-            "name": "transferCommand",
-            "type": "uint8",
-            "internalType": "enum Signature.TransferCommand"
-          },
-          {
-            "name": "signatureBytes",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
+        "name": "quoteTokenAmount",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
       },
       {
-        "name": "_takerPermitInfo",
-        "type": "tuple",
-        "internalType": "struct Signature.TakerPermitInfo",
-        "components": [
-          {
-            "name": "signature",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "nonce",
-            "type": "uint48",
-            "internalType": "uint48"
-          },
-          {
-            "name": "deadline",
-            "type": "uint48",
-            "internalType": "uint48"
-          }
-        ]
+        "name": "recipient",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
       }
     ],
-    "outputs": [],
-    "stateMutability": "payable"
+    "anonymous": false
   },
   {
-    "type": "function",
-    "name": "settleWithPermitsSignatures",
+    "type": "error",
+    "name": "ECDSAInvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureLength",
     "inputs": [
       {
-        "name": "_signer",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "_filledTakerAmount",
+        "name": "length",
         "type": "uint256",
         "internalType": "uint256"
-      },
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ECDSAInvalidSignatureS",
+    "inputs": [
       {
-        "name": "_order",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.Order",
-        "components": [
-          {
-            "name": "market",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "chainId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "rfqId",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "trader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "effectiveTrader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "quoteExpiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minFillAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "baseTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRecipient",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRepay",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toSupply",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "quoteTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toTrader",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toWithdraw",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toBorrow",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "_interactions",
-        "type": "tuple[]",
-        "internalType": "struct GPv2Interaction.Data[]",
-        "components": [
-          {
-            "name": "target",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "value",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "callData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "_hooks",
-        "type": "tuple",
-        "internalType": "struct GPv2Interaction.Hooks",
-        "components": [
-          {
-            "name": "beforeSettle",
-            "type": "tuple[]",
-            "internalType": "struct GPv2Interaction.Data[]",
-            "components": [
-              {
-                "name": "target",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "value",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "callData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "afterSettle",
-            "type": "tuple[]",
-            "internalType": "struct GPv2Interaction.Data[]",
-            "components": [
-              {
-                "name": "target",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "value",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "callData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "_makerSignature",
-        "type": "tuple",
-        "internalType": "struct Signature.TypedSignature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum Signature.Type"
-          },
-          {
-            "name": "transferCommand",
-            "type": "uint8",
-            "internalType": "enum Signature.TransferCommand"
-          },
-          {
-            "name": "signatureBytes",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "_takerSignature",
-        "type": "tuple",
-        "internalType": "struct Signature.TypedSignature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum Signature.Type"
-          },
-          {
-            "name": "transferCommand",
-            "type": "uint8",
-            "internalType": "enum Signature.TransferCommand"
-          },
-          {
-            "name": "signatureBytes",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      },
-      {
-        "name": "_takerPermitInfo",
-        "type": "tuple",
-        "internalType": "struct Signature.TakerPermitInfo",
-        "components": [
-          {
-            "name": "signature",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "nonce",
-            "type": "uint48",
-            "internalType": "uint48"
-          },
-          {
-            "name": "deadline",
-            "type": "uint48",
-            "internalType": "uint48"
-          }
-        ]
+        "name": "s",
+        "type": "bytes32",
+        "internalType": "bytes32"
       }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
+    ]
   },
   {
-    "type": "function",
-    "name": "validateHooks",
-    "inputs": [
-      {
-        "name": "_repository",
-        "type": "address",
-        "internalType": "contract IRepository"
-      },
-      {
-        "name": "_hooks",
-        "type": "tuple",
-        "internalType": "struct GPv2Interaction.Hooks",
-        "components": [
-          {
-            "name": "beforeSettle",
-            "type": "tuple[]",
-            "internalType": "struct GPv2Interaction.Data[]",
-            "components": [
-              {
-                "name": "target",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "value",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "callData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          },
-          {
-            "name": "afterSettle",
-            "type": "tuple[]",
-            "internalType": "struct GPv2Interaction.Data[]",
-            "components": [
-              {
-                "name": "target",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "value",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "callData",
-                "type": "bytes",
-                "internalType": "bytes"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
+    "type": "error",
+    "name": "InvalidAmount",
+    "inputs": []
   },
   {
-    "type": "function",
-    "name": "validateInteractions",
-    "inputs": [
-      {
-        "name": "_repository",
-        "type": "address",
-        "internalType": "contract IRepository"
-      },
-      {
-        "name": "_signer",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "_isPartialFill",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "_order",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.Order",
-        "components": [
-          {
-            "name": "market",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "chainId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "rfqId",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "trader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "effectiveTrader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "quoteExpiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minFillAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "baseTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRecipient",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRepay",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toSupply",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "quoteTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toTrader",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toWithdraw",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toBorrow",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "_interactions",
-        "type": "tuple[]",
-        "internalType": "struct GPv2Interaction.Data[]",
-        "components": [
-          {
-            "name": "target",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "value",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "callData",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "validateOrderAmounts",
-    "inputs": [
-      {
-        "name": "_order",
-        "type": "tuple",
-        "internalType": "struct ILiquoriceSettlement.Order",
-        "components": [
-          {
-            "name": "market",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "chainId",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "rfqId",
-            "type": "string",
-            "internalType": "string"
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "trader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "effectiveTrader",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "quoteExpiry",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "recipient",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "minFillAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "baseTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.BaseTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRecipient",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toRepay",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toSupply",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "quoteTokenData",
-            "type": "tuple",
-            "internalType": "struct ILiquoriceSettlement.QuoteTokenData",
-            "components": [
-              {
-                "name": "addr",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toTrader",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toWithdraw",
-                "type": "uint256",
-                "internalType": "uint256"
-              },
-              {
-                "name": "toBorrow",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "validateSignature",
-    "inputs": [
-      {
-        "name": "_validationAddress",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "_hash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "_signature",
-        "type": "tuple",
-        "internalType": "struct Signature.TypedSignature",
-        "components": [
-          {
-            "name": "signatureType",
-            "type": "uint8",
-            "internalType": "enum Signature.Type"
-          },
-          {
-            "name": "transferCommand",
-            "type": "uint8",
-            "internalType": "enum Signature.TransferCommand"
-          },
-          {
-            "name": "signatureBytes",
-            "type": "bytes",
-            "internalType": "bytes"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
-  },
-  {
-    "type": "event",
-    "name": "Interaction",
-    "inputs": [
-      {
-        "name": "target",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "value",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "indexed": false,
-        "internalType": "bytes4"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "TradeOrder",
-    "inputs": [
-      {
-        "name": "rfqId",
-        "type": "string",
-        "indexed": true,
-        "internalType": "string"
-      },
-      {
-        "name": "trader",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "effectiveTrader",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "baseToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "quoteToken",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "baseTokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "quoteTokenAmount",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "recipient",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "error",
-    "name": "ECDSAInvalidSignature",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "ECDSAInvalidSignatureLength",
-    "inputs": [
-      {
-        "name": "length",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "ECDSAInvalidSignatureS",
-    "inputs": [
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "InvalidAmount",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidAsset",
-    "inputs": []
+    "type": "error",
+    "name": "InvalidAsset",
+    "inputs": []
   },
   {
     "type": "error",
@@ -4908,951 +3602,134 @@ interface LiquoriceSettlement {
   },
   {
     "type": "error",
-    "name": "InvalidLendingPoolInteraction",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidQuoteTokenAmounts",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidSignatureType",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidSigner",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidSource",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "NonceInvalid",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "NotMaker",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "NotSolver",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "OrderExpired",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "PartialFillNotSupported",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "ReceiverNotManager",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "ReentrancyGuardReentrantCall",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "SafeERC20FailedOperation",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "SignatureIsExpired",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "SignatureIsNotEmpty",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "UpdatedMakerAmountsTooLow",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "ZeroMakerAmount",
-    "inputs": []
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod LiquoriceSettlement {
-    use {super::*, alloy_sol_types};
-    /// The creation / init bytecode of the contract.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"a\x01 `@R4\x80\x15b\0\0\x11W_\x80\xFD[P`@Qb\0N\xF68\x03\x80b\0N\xF6\x839\x81\x01`@\x81\x90Rb\0\x004\x91b\0\x01uV[F`\xA0\x81\x81R`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01R`\x80\x81\x01\x92\x90\x92R0\x90\x82\x01R`\xC0\x01`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x80Q` \x90\x91\x01 `\x80R`\x01\x80U`\x01`\x01`\xA0\x1B\x03\x84\x16`\xC0R0\x90\x82\x90b\0\0\xFE\x90b\0\x01OV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15b\0\x01/W=_\x80>=_\xFD[P`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\xE0R\x91\x90\x91\x16a\x01\0RPb\0\x01\xC6\x90PV[a\tc\x80b\0E\x93\x839\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x01rW_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15b\0\x01\x88W_\x80\xFD[\x83Qb\0\x01\x95\x81b\0\x01]V[` \x85\x01Q\x90\x93Pb\0\x01\xA8\x81b\0\x01]V[`@\x85\x01Q\x90\x92Pb\0\x01\xBB\x81b\0\x01]V[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0QaC-b\0\x02f_9_\x81\x81a\x02W\x01R\x81\x81a\x07\x84\x01Ra\x16\xDC\x01R_\x81\x81a\x01\x97\x01R\x81\x81a\x07\xBA\x01R\x81\x81a\x18\x8C\x01R\x81\x81a\x1E,\x01R\x81\x81a\x1F\x1E\x01R\x81\x81a ,\x01R\x81\x81a#\x0B\x01R\x81\x81a$'\x01Ra0<\x01R_\x81\x81a\x038\x01R\x81\x81a\x04\x12\x01R\x81\x81a\x06\xA7\x01R\x81\x81a\x15 \x01Ra\x15\xFF\x01R_a\x04\xDA\x01R_a\x05\xA4\x01RaC-_\xF3\xFE`\x80`@R`\x046\x10a\x01&W_5`\xE0\x1C\x80c\xA5\xCD\xC8\xFC\x11a\0\xA1W\x80c\xC6\x18a\x81\x11a\0qW\x80c\xDBXw(\x11a\0WW\x80c\xDBXw(\x14a\x03yW\x80c\xE2B\x92N\x14a\x03\x8CW\x80c\xFA\\\xD5l\x14a\x03\xABW_\x80\xFD[\x80c\xC6\x18a\x81\x14a\x03'W\x80c\xCB\xA6s\xA7\x14a\x03ZW_\x80\xFD[\x80c\xA5\xCD\xC8\xFC\x14a\x02\xABW\x80c\xA7\xABI\xBC\x14a\x02\xCAW\x80c\xAE\x80\xC5\x84\x14a\x02\xE9W\x80c\xB1\x1F\x12b\x14a\x03\x08W_\x80\xFD[\x80cQ\xD4h\x15\x11a\0\xF6W\x80co5\xD2\xD2\x11a\0\xDCW\x80co5\xD2\xD2\x14a\x02FW\x80c\x87U0\xFF\x14a\x02yW\x80c\x995\xC8h\x14a\x02\x98W_\x80\xFD[\x80cQ\xD4h\x15\x14a\x02\x12W\x80cZ\xA0\xE9]\x14a\x02'W_\x80\xFD[\x80c\x16&\xBA~\x14a\x011W\x80c)\xBC\xDC\x95\x14a\x01\x86W\x80c6D\xE5\x15\x14a\x01\xD1W\x80cL\x9E\x03\xD3\x14a\x01\xF3W_\x80\xFD[6a\x01-W\0[_\x80\xFD[4\x80\x15a\x01<W_\x80\xFD[Pa\x01Pa\x01K6`\x04a5\x95V[a\x03\xCAV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x91W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01}V[4\x80\x15a\x01\xDCW_\x80\xFD[Pa\x01\xE5a\x04\xD7V[`@Q\x90\x81R` \x01a\x01}V[4\x80\x15a\x01\xFEW_\x80\xFD[Pa\x01\xE5a\x02\r6`\x04a6 V[a\x05\xC6V[a\x02%a\x02 6`\x04a6\xD7V[a\x06gV[\0[4\x80\x15a\x022W_\x80\xFD[Pa\x02%a\x02A6`\x04a7\xE1V[a\t\xE8V[4\x80\x15a\x02QW_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x02\x84W_\x80\xFD[Pa\x01\xE5a\x02\x936`\x04a6 V[a\x0C0V[a\x02%a\x02\xA66`\x04a8?V[a\x0C_V[4\x80\x15a\x02\xB6W_\x80\xFD[Pa\x02%a\x02\xC56`\x04a8\xDDV[a\x0C\x7FV[4\x80\x15a\x02\xD5W_\x80\xFD[Pa\x02%a\x02\xE46`\x04a9\x01V[a\x0C\x8CV[4\x80\x15a\x02\xF4W_\x80\xFD[Pa\x02%a\x03\x036`\x04a9\x9DV[a\x10gV[4\x80\x15a\x03\x13W_\x80\xFD[Pa\x01\xE5a\x03\"6`\x04a9\xF2V[a\x12\xEBV[4\x80\x15a\x032W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x03eW_\x80\xFD[Pa\x02%a\x03t6`\x04a:$V[a\x14\xEAV[a\x02%a\x03\x876`\x04a;\x0BV[a\x18xV[4\x80\x15a\x03\x97W_\x80\xFD[Pa\x01\xE5a\x03\xA66`\x04a;\xC9V[a\x19LV[4\x80\x15a\x03\xB6W_\x80\xFD[Pa\x02%a\x03\xC56`\x04a;\xC9V[a\x1A\x8EV[_\x80a\x03\xD7\x85\x85\x85a\x1BPV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\x04\x83\x01R\x91\x92P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04YW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04}\x91\x90a;\xFBV[\x15a\x04\xABW\x7F\x16&\xBA~5oYy\xDD5Z=+\xFBC\xE8\x04 \xA4\x80\xC3\xB8T\xED\xCE(j\x82\xD7Ihi\x91PPa\x04\xD0V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14a\x05\xA1W`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[_\x7Fh\xB8\xE9M\xC0wE\x82A\xD6\xC8\xD8\x9F\nve\xC7\xCD\xA2\xCF\xE7\x0C\x9E\xB4C~\xFE\xE1f<f\xFEa\x05\xF5` \x84\x01\x84a<\x16V[\x83` \x015\x84`@\x015\x85``\x015\x86`\x80\x015`@Q` \x01a\x06J\x96\x95\x94\x93\x92\x91\x90\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16` \x86\x01R`@\x85\x01\x92\x90\x92R``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x06oa\x1B\xDBV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xECW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x10\x91\x90a;\xFBV[a\x07FW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x87\x015\x88\x15\x80\x15\x90a\x07`WPa\x01`\x88\x015\x89\x11\x15[\x15a\x07\x7FWa\x07|\x89a\x02\0\x8A\x015a\x01`\x8B\x015`\x01a\x1C\x1EV[\x90P[a\x07\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x83\x8B\x8B\x8B\x8B\x8B\x8Ba\x1CiV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x07\xEF`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x08\x01a\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Ra\x08D\x92\x91\x90a\x01`\x8E\x015\x90\x88\x90`\x04\x01a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08[W_\x80\xFD[PZ\xF1\x15\x80\x15a\x08mW=_\x80>=_\xFD[PPPPa\x08\xB4\x88\x8B\x83\x8C_\x14\x80a\x08\x89WPa\x01`\x8C\x015\x8D\x11[a\x08\x93W\x8Ca\x08\x9AV[a\x01`\x8C\x015[\x89\x8C\x8C`\x02a\x08\xAF`@\x8E\x01` \x8F\x01a=aV[a\x1E\x01V[a\x08\xC1`@\x89\x01\x89a=\x7FV[`@Qa\x08\xCF\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\t\t`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a\t\x19`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[a\t+a\x01@\x8D\x01a\x01 \x8E\x01a<\x16V[a\t=a\x01\xE0\x8E\x01a\x01\xC0\x8F\x01a<\x16V[\x8E\x15\x80a\tNWPa\x01`\x8E\x015\x8F\x11[a\tXW\x8Ea\t_V[a\x01@\x8E\x015[a\x02\0\x8F\x015\x88\x14a\tqW\x87a\txV[a\x01\xE0\x8F\x015[\x8F`\xE0\x01` \x81\x01\x90a\t\x8B\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\t\xDD`\x01\x80UV[PPPPPPPPPV[_[a\t\xF4\x82\x80a=\xEFV[\x90P\x81\x10\x15a\x0B\x06W6a\n\x08\x83\x80a=\xEFV[\x83\x81\x81\x10a\n\x18Wa\n\x18a>SV[\x90P` \x02\x81\x01\x90a\n*\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\nH` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xA2W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xC6\x91\x90a;\xFBV[\x15a\n\xFDW`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\t\xEAV[P_[a\x0B\x16` \x83\x01\x83a=\xEFV[\x90P\x81\x10\x15a\x0C+W6a\x0B-` \x84\x01\x84a=\xEFV[\x83\x81\x81\x10a\x0B=Wa\x0B=a>SV[\x90P` \x02\x81\x01\x90a\x0BO\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\x0Bm` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xC7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xEB\x91\x90a;\xFBV[\x15a\x0C\"W`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x0B\tV[PPPV[_\x7F\xAEgk\xF6\x91:\xC2h\x9Bs1)<\x98\x9F\xE7r1$\xFA\xF8\xB5\xD2u\xF0o\xBC\xEB\xC7yP\ta\x05\xF5` \x84\x01\x84a<\x16V[a\x0Ci\x84\x82a\"\x12V[a\x0Cx\x85\x85\x85\x85`\x01\x80a\"\xC9V[PPPPPV[a\x0C\x893\x82a&\x1EV[PV[a\x0C\xBF`@Q\x80`\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[_[\x82\x81\x10\x15a\x10SW6\x84\x84\x83\x81\x81\x10a\x0C\xDCWa\x0C\xDCa>SV[\x90P` \x02\x81\x01\x90a\x0C\xEE\x91\x90a>\x80V[\x90P6_a\x0C\xFF`@\x84\x01\x84a=\x7FV[\x90\x92P\x90P`\x01`\x01`\xA0\x1B\x03\x8B\x16c\xA8\xC4\xBC\x95a\r ` \x86\x01\x86a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\rzW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x9E\x91\x90a;\xFBV[\x15a\x10EW_\x89\x15a\r\xDCW`@Q\x7F}a{\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04\x82\x10a\r\xE8WP\x815[\x7F\xC0:\x9D\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0EVWa\x0E=\x83\x83\x8D\x8Ca&\xC4V[\x86` \x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x90RPa\x10CV[\x7F$:K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0E\xBCWa\x0E\xAB\x83\x83\x8D\x8Ca'\xDAV[\x86``\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x7F}\xC4\xF4X\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0FGWa\x0F\x11\x83\x83\x8D\x8Ca)NV[`\xA0\x88\x01R`\x80\x87\x01\x81\x90R``\x87\x01\x80Qa\x0F.\x90\x83\x90a>\xBCV[\x90RP`\xA0\x86\x01Q` \x87\x01\x80Qa\x0EN\x90\x83\x90a>\xBCV[\x7Fh\x93\x1Bk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0F\xABWa\x0F\x9C\x83\x83\x8D\x8Ca+\xB6V[\x86Q\x87\x90a\x0EN\x90\x83\x90a>\xBCV[\x7F\x0C\x9B\xE7\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x10\x11Wa\x10\0\x83\x83\x8D\x8Ca,\xC0V[\x86`@\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[`@Q\x7F\x05a\xD8\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPP\x80`\x01\x01\x90Pa\x0C\xC1V[Pa\x10^\x84\x82a.)V[PPPPPPPV[`\x03a\x10v` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x10\x87Wa\x10\x87a>\xF4V[\x03a\x10\xECW`\x01`\x01`\xA0\x1B\x03\x83\x16a\x10\xAC\x83a\x10\xA7`@\x85\x01\x85a=\x7FV[a\x1BPV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0C+W`@Q\x7F\xB8\x1DX\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01a\x10\xFB` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\x0CWa\x11\x0Ca>\xF4V[\x03a\x11\xA0W\x7F\x19Ethereum Signed Message:\n32\0\0\0\0_\x90\x81R`\x1C\x83\x90R`<\x90 `\x01`\x01`\xA0\x1B\x03\x84\x16a\x11Z\x82a\x10\xA7`@\x86\x01\x86a=\x7FV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x11\x9AW`@Q\x7FdJ\xE6\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\x02a\x11\xAF` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\xC0Wa\x11\xC0a>\xF4V[\x03a\x12\xB9W\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x84\x16c\x16&\xBA~\x84a\x12\x03`@\x86\x01\x86a=\x7FV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12!\x93\x92\x91\x90a??V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12<W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12`\x91\x90a?XV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x0C+W`@Q\x7F]R\xCB\xE3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F`\xCD@-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xF4a\x04\xD7V[\x7F\xD2\x8E\x80\x9Bp\x8F^\xE3\x8B\xE84}m\x86\x9D\x822I<\tJ\xB2\xDD\xE9\x83i\xE4\x10#i\xA9\x9Da\x13\x1F\x84\x80a=\x7FV[`@Q` \x01a\x130\x92\x91\x90a?\x97V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x84` \x015\x85`@\x01` \x81\x01\x90a\x13^\x91\x90a<\x16V[`@\x80Q` \x81\x01\x95\x90\x95R\x84\x01\x92\x90\x92R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90Ra\x13\xC4`\x80\x85\x01``\x86\x01a<\x16V[a\x13\xD4`\xA0\x86\x01`\x80\x87\x01a<\x16V[a\x13\xE4`\xC0\x87\x01`\xA0\x88\x01a<\x16V[`\xC0\x87\x015`\xE0\x88\x015a\x01\0\x89\x015a\x01 \x8A\x015a\x14\x0Ca\x01`\x8C\x01a\x01@\x8D\x01a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x99\x8A\x16` \x82\x01R\x97\x89\x16\x90\x88\x01R\x94\x87\x16``\x87\x01R`\x80\x86\x01\x93\x90\x93R`\xA0\x85\x01\x91\x90\x91R`\xC0\x84\x01R`\xE0\x83\x01R\x90\x91\x16a\x01\0\x82\x01Ra\x01 \x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x14\x92\x92\x91` \x01a?\xD7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\x06J\x92\x91\x90\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[a\x14\xF2a\x1B\xDBV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15mW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x91\x91\x90a;\xFBV[a\x15\xC7W`@Q\x7F\xC19\xEA\xBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16DW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16h\x91\x90a;\xFBV[a\x16\x9EW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x86\x015\x87\x15\x80\x15\x90a\x16\xB8WPa\x01`\x87\x015\x88\x11\x15[\x15a\x16\xD7Wa\x16\xD4\x88a\x02\0\x89\x015a\x01`\x8A\x015`\x01a\x1C\x1EV[\x90P[a\x17\x08\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x83\x8A\x8A\x8A\x8A\x8A\x8Aa\x1CiV[a\x17E\x87\x8A\x83\x8B\x15\x80a\x17\x1FWPa\x01`\x8B\x015\x8C\x11[a\x17)W\x8Ba\x170V[a\x01`\x8B\x015[\x88\x8B\x8B`\x01a\x08\xAF`@\x8D\x01` \x8E\x01a=aV[a\x17R`@\x88\x01\x88a=\x7FV[`@Qa\x17`\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\x17\x9A`\xA0\x8A\x01`\x80\x8B\x01a<\x16V[a\x17\xAA`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x17\xBCa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[a\x17\xCEa\x01\xE0\x8D\x01a\x01\xC0\x8E\x01a<\x16V[\x8D\x15\x80a\x17\xDFWPa\x01`\x8D\x015\x8E\x11[a\x17\xE9W\x8Da\x17\xF0V[a\x01@\x8D\x015[a\x02\0\x8E\x015\x88\x14a\x18\x02W\x87a\x18\tV[a\x01\xE0\x8E\x015[\x8E`\xE0\x01` \x81\x01\x90a\x18\x1C\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\x18n`\x01\x80UV[PPPPPPPPV[a\x18\x82\x85\x83a\"\x12V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x18\xC1`\x80\x88\x01``\x89\x01a<\x16V[a\x18\xD1`\xA0\x89\x01`\x80\x8A\x01a<\x16V[\x88`\xC0\x015\x85`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x18\xF6\x94\x93\x92\x91\x90a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x19\rW_\x80\xFD[PZ\xF1\x15\x80\x15a\x19\x1FW=_\x80>=_\xFD[PPPPa\x19D\x86\x86\x86\x86`\x02\x89` \x01` \x81\x01\x90a\x19?\x91\x90a=aV[a\"\xC9V[PPPPPPV[_a\x19Ua\x04\xD7V[\x7F\xC9\x94\xD2\xCA\x03u\xD6\xD4sx^\x0C\xE0\xB1\xD2\x03\xF0i\x12\x1B\xAC\x13\x14\xF7,\\\x0F\xE6\x01\xEB9\x10a\x19\x83`@\x85\x01\x85a=\x7FV[`@Q` \x01a\x19\x94\x92\x91\x90a?\x97V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 ``\x85\x015a\x19\xDF`\xA0\x87\x01`\x80\x88\x01a<\x16V[a\x19\xEF`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\xC0\x88\x015a\x1A\x05a\x01\0\x8A\x01`\xE0\x8B\x01a<\x16V[`@\x80Q` \x81\x01\x98\x90\x98R\x87\x01\x95\x90\x95R``\x86\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80\x86\x01R\x81\x16`\xA0\x85\x01R`\xC0\x84\x01\x91\x90\x91R\x16`\xE0\x82\x01Ra\x01\0\x80\x85\x015\x90\x82\x01Ra\x01 \x01`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1Ao\x84a\x01 \x01a\x0C0V[a\x1A|\x85a\x01\xC0\x01a\x05\xC6V[`@Q` \x01a\x14\x92\x93\x92\x91\x90a?\xEBV[a\x01\xA0\x81\x015a\x1A\xA8a\x01\x80\x83\x015a\x01`\x84\x015a>\xBCV[a\x1A\xB2\x91\x90a>\xBCV[a\x01@\x82\x015\x14a\x1A\xEFW`@Q\x7F\xC0Cw\xD3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x81\x015a\x1B\ta\x02 \x83\x015a\x02\0\x84\x015a>\xBCV[a\x1B\x13\x91\x90a>\xBCV[a\x01\xE0\x82\x015\x14a\x0C\x89W`@Q\x7F\x87v0\xBE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x91\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa.\xD6\x92PPPV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1B\xD3W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x94\x93PPPPV[`\x02`\x01T\x03a\x1C\x17W`@Q\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01UV[_a\x1CKa\x1C+\x83a/\0V[\x80\x15a\x1CFWP_\x84\x80a\x1CAWa\x1CAa@\x08V[\x86\x88\t\x11[\x15\x15\x90V[a\x1CV\x86\x86\x86a/,V[a\x1C`\x91\x90a>\xBCV[\x95\x94PPPPPV[_a\x1Cs\x87a\x19LV[\x90Pa\x1C\x80\x89\x82\x85a\x10gV[a\x1C\x90`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1C\xC7Wa\x1C\xC2a\x1C\xBB`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x82\x84a\x10gV[a\x1D\x0EV[a\x1C\xD4`@\x83\x01\x83a=\x7FV[\x90P_\x03a\x1D\x0EW`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D+a\x1D!`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x88``\x015a&\x1EV[\x86`\xC0\x015B\x11\x15a\x1DiW`@Q\x7F\x13=\xF0)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x88\x11\x80\x15a\x1D|WP\x86a\x01\0\x015\x88\x10[\x15a\x1D\xB3W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\xBC\x87a\x1A\x8EV[a\x1D\xC6\x8A\x85a\t\xE8V[a\x1D\xE7\x8A\x8A_\x8B\x11\x80\x15a\x1D\xDFWPa\x02\0\x8A\x015\x8B\x14\x15[\x8A\x8A\x8Aa\x0C\x8CV[a\x1D\xF5\x89\x88``\x015a&\x1EV[PPPPPPPPPPV[a\x1E\x13a\x1E\x0E\x86\x80a=\xEFV[a0\x01V[_a\x1E(a\x01\x80\x8B\x015a\x01\xA0\x8C\x015a>\xBCV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Ew\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x010`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1E\xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x86`\x02\x81\x11\x15a\x1E\xD0Wa\x1E\xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1F\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a\x1F\x18W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Fi\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\xE0\x01` \x81\x01\x90a\x1F\x8A\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1F\xAE\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A\x81R` \x01\x86`\x02\x81\x11\x15a\x1F\xD4Wa\x1F\xD4a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F\xF3\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a \nW_\x80\xFD[PZ\xF1\x15\x80\x15a \x1CW=_\x80>=_\xFD[PPPPa *\x85\x85a0\x01V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8C`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\x80\x01` \x81\x01\x90a \x86\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01\xC0\x01_\x01` \x81\x01\x90a \xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8B\x81R` \x01\x85`\x02\x81\x11\x15a \xD0Wa \xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a!\x18W=_\x80>=_\xFD[Pa!.\x92Pa\x1E\x0E\x91PP` \x88\x01\x88a=\xEFV[_a!Aa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!\x9EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\xC2\x91\x90a@\xB4V[\x90P\x80\x15a\"\x05Wa\"\x05a!\xDEa\x01\0\x8D\x01`\xE0\x8E\x01a<\x16V[\x82\x8Da\x01 \x01_\x01` \x81\x01\x90a!\xF5\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a19V[PPPPPPPPPPPV[a\"\"`\x80\x83\x01``\x84\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\"aWa\"\\a\"M`\x80\x84\x01``\x85\x01a<\x16V[a\"V\x84a\x12\xEBV[\x83a\x10gV[a\"\xA8V[a\"n`@\x82\x01\x82a=\x7FV[\x90P_\x03a\"\xA8W`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\"\xC5a\"\xBB`\x80\x84\x01``\x85\x01a<\x16V[\x83` \x015a&\x1EV[PPV[`\xE0\x85\x015\x83\x15\x80\x15\x90a\"\xE0WP\x85`\xC0\x015\x84\x10[\x15a\"\xFDWa\"\xFA\x84\x87`\xE0\x015\x88`\xC0\x015`\x01a\x1C\x1EV[\x90P[a#\t\x87\x82\x88\x88a1\xB9V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x89``\x01` \x81\x01\x90a#V\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#va\x01`\x8B\x01a\x01@\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#\x94`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x87\x15\x80a#\xB2WP\x89`\xC0\x015\x88\x11[a#\xBCW\x87a#\xC2V[\x89`\xC0\x015[\x81R` \x01\x86`\x02\x81\x11\x15a#\xD9Wa#\xD9a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\xF8\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\x0FW_\x80\xFD[PZ\xF1\x15\x80\x15a$!W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`@\x01` \x81\x01\x90a$\x81\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a$\x9F`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x02\x81\x11\x15a$\xC5Wa$\xC5a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a$\xE4\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\xFBW_\x80\xFD[PZ\xF1\x15\x80\x15a%\rW=_\x80>=_\xFD[Pa%\x1E\x92P\x88\x91P\x81\x90Pa=\x7FV[`@Qa%,\x92\x91\x90a=\xE0V[`@Q\x80\x91\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6\x87`@\x01` \x81\x01\x90a%h\x91\x90a<\x16V[a%x`\x80\x8A\x01``\x8B\x01a<\x16V[a%\x88`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a%\x98`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[\x89\x15\x80a%\xA8WP\x8B`\xC0\x015\x8A\x11[a%\xB2W\x89a%\xB8V[\x8B`\xC0\x015[\x87\x8Da\x01@\x01` \x81\x01\x90a%\xCD\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x84\x84R\x90\x91R\x90 T`\xFF\x16\x15a&yW`@Q\x7F\xBC\r\xA7\xD6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x83R\x92\x90R \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16`\x01\x17\x90UV[_\x80\x80\x80a&\xD5\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a&\xE2\x91\x90a@\xF2V[P\x91\x94P\x92P\x90Pa&\xFCa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a'FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a'\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x97\x96PPPPPPPV[_\x80\x80\x80\x80a'\xEC\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a'\xF9\x91\x90aABV[\x92\x96P\x90\x94P\x92P\x90Pa(\x15a\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a(_W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a(\xAAW`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a(\xBA`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a)\x04W`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x98\x97PPPPPPPPV[_\x80_\x80_\x80_\x80_\x8C\x8C`\x04\x90\x80\x92a)j\x93\x92\x91\x90a@\xCBV[\x81\x01\x90a)w\x91\x90aA\x90V[\x95\x9CP\x93\x9AP\x91\x98P\x96P\x94P\x92P\x90Pa)\x9Aa\x01\xE0\x8B\x01a\x01\xC0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a)\xE4W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85`\x01`\x01`\xA0\x1B\x03\x16\x8B`\x01`\x01`\xA0\x1B\x03\x16\x14a*/W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x160\x14a*qW`@Q\x7F\x81T7K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x81`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a*\xCBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x8A\x015\x83\x14a+\tW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+\x1Ba\x01@\x8B\x01a\x01 \x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a+eW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x8A\x015\x81\x14a+\xA3W`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x9C\x91\x9BP\x90\x99PPPPPPPPPPV[_\x80\x80\x80a+\xC7\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a+\xD4\x91\x90aB\x0FV[\x91\x94P\x92P\x90Pa+\xEDa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a,7W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a,\x82W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\x80\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80\x80\x80a,\xD2\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a,\xDF\x91\x90aBMV[P\x92\x96P\x90\x94P\x92P\x90Pa,\xFCa\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a-FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a-\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a-\xA1`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a-\xEBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02 \x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01\x80\x83\x015\x14\x15\x80a.GWP` \x81\x01Qa\x01\xA0\x83\x015\x14\x15[\x15a.~W`@Q\x7FJU\xDA \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x81\x01Qa\x02 \x83\x015\x14\x15\x80a.\x9FWP``\x81\x01Qa\x02@\x83\x015\x14\x15[\x15a\"\xC5W`@Q\x7Fw\xA5\x92\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x80a.\xE4\x86\x86a2\\V[\x92P\x92P\x92Pa.\xF4\x82\x82a2\xA5V[P\x90\x91PP[\x92\x91PPV[_`\x02\x82`\x03\x81\x11\x15a/\x15Wa/\x15a>\xF4V[a/\x1F\x91\x90aB\xB1V[`\xFF\x16`\x01\x14\x90P\x91\x90PV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a/\x7FW\x83\x82\x81a/uWa/ua@\x08V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a/\x96Wa/\x96`\x03\x85\x15\x02`\x11\x18a3\xADV[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP\x93\x92PPPV[_[\x81\x81\x10\x15a\x0C+W6\x83\x83\x83\x81\x81\x10a0\x1EWa0\x1Ea>SV[\x90P` \x02\x81\x01\x90a00\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a0i` \x83\x01\x83a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x03a0\xA9W`@Q\x7Fy\xA1\xBF\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a0\xB2\x81a3\xBEV[a0\xBF` \x82\x01\x82a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a0\xF7\x84a4\x01V[`@\x80Q\x92\x83R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA2P`\x01\x01a0\x03V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C+\x90\x84\x90a4*V[_\x83\x11\x80\x15a1\xCCWP\x81a\x01\0\x015\x83\x10[\x15a2\x03W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2\x10\x84a\"V\x84a\x12\xEBV[a2\x1E\x84\x83` \x015a&\x1EV[B\x82a\x01 \x015\x11a\x11\x9AW`@Q\x7F\xC5hs\xBA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x83Q`A\x03a2\x93W` \x84\x01Q`@\x85\x01Q``\x86\x01Q_\x1Aa2\x85\x88\x82\x85\x85a4\xAFV[\x95P\x95P\x95PPPPa2\x9EV[PP\x81Q_\x91P`\x02\x90[\x92P\x92P\x92V[_\x82`\x03\x81\x11\x15a2\xB8Wa2\xB8a>\xF4V[\x03a2\xC1WPPV[`\x01\x82`\x03\x81\x11\x15a2\xD5Wa2\xD5a>\xF4V[\x03a3\x0CW`@Q\x7F\xF6E\xEE\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x82`\x03\x81\x11\x15a3 Wa3 a>\xF4V[\x03a3_W`@Q\x7F\xFC\xE6\x98\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x03\x82`\x03\x81\x11\x15a3sWa3sa>\xF4V[\x03a\"\xC5W`@Q\x7F\xD7\x8B\xCE\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01a3VV[cNH{q_R\x80` R`$`\x1C\xFD[_a3\xCC` \x83\x01\x83a<\x16V[\x90P` \x82\x0156_a3\xE2`@\x86\x01\x86a=\x7FV[\x91P\x91P`@Q\x81\x83\x827_\x80\x83\x83\x87\x89Z\xF1a\x19DW=_\x80>=_\xFD[_6\x81a4\x11`@\x85\x01\x85a=\x7FV[\x90\x92P\x90P`\x04\x81\x10a4#W\x815\x92P[PP\x91\x90PV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a4IW`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a4`W\x80`\x01\x14\x15a4mV[`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x11\x9AW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a3VV[_\x80\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x84\x11\x15a4\xE8WP_\x91P`\x03\x90P\x82a5\x8BV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x8A\x90R`\xFF\x89\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x87\x90R`\x80\x81\x01\x86\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a59W=_\x80>=_\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a5\x82WP_\x92P`\x01\x91P\x82\x90Pa5\x8BV[\x92P_\x91P\x81\x90P[\x94P\x94P\x94\x91PPV[_\x80_`@\x84\x86\x03\x12\x15a5\xA7W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a5\xC5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a5\xD8W_\x80\xFD[\x815\x81\x81\x11\x15a5\xE6W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a5\xF7W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[_`\xA0\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[P\x91\x90PV[_`\xA0\x82\x84\x03\x12\x15a60W_\x80\xFD[a\x04\xD0\x83\x83a6\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x89W_\x80\xFD[\x805a6Y\x81a6:V[\x91\x90PV[_a\x02`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80\x83`\x1F\x84\x01\x12a6\x7FW_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x96W_\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a6\xB0W_\x80\xFD[\x92P\x92\x90PV[_`@\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_``\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a6\xF0W_\x80\xFD[a6\xF9\x8Aa6NV[\x98P` \x8A\x015\x97P`@\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a7\x1CW_\x80\xFD[a7(\x8D\x83\x8E\x01a6^V[\x98P``\x8C\x015\x91P\x80\x82\x11\x15a7=W_\x80\xFD[a7I\x8D\x83\x8E\x01a6oV[\x90\x98P\x96P`\x80\x8C\x015\x91P\x80\x82\x11\x15a7aW_\x80\xFD[a7m\x8D\x83\x8E\x01a6\xB7V[\x95P`\xA0\x8C\x015\x91P\x80\x82\x11\x15a7\x82W_\x80\xFD[a7\x8E\x8D\x83\x8E\x01a6\xC7V[\x94P`\xC0\x8C\x015\x91P\x80\x82\x11\x15a7\xA3W_\x80\xFD[a7\xAF\x8D\x83\x8E\x01a6\xC7V[\x93P`\xE0\x8C\x015\x91P\x80\x82\x11\x15a7\xC4W_\x80\xFD[Pa7\xD1\x8C\x82\x8D\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[_\x80`@\x83\x85\x03\x12\x15a7\xF2W_\x80\xFD[\x825a7\xFD\x81a6:V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x18W_\x80\xFD[a8$\x85\x82\x86\x01a6\xB7V[\x91PP\x92P\x92\x90PV[_a\x01`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15a8SW_\x80\xFD[\x855a8^\x81a6:V[\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a8zW_\x80\xFD[a8\x86\x89\x83\x8A\x01a8.V[\x95P`@\x88\x015\x91P\x80\x82\x11\x15a8\x9BW_\x80\xFD[a8\xA7\x89\x83\x8A\x01a6\xC7V[\x94P``\x88\x015\x93P`\x80\x88\x015\x91P\x80\x82\x11\x15a8\xC3W_\x80\xFD[Pa8\xD0\x88\x82\x89\x01a6\xC7V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_` \x82\x84\x03\x12\x15a8\xEDW_\x80\xFD[P5\x91\x90PV[\x80\x15\x15\x81\x14a\x0C\x89W_\x80\xFD[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a9\x16W_\x80\xFD[\x865a9!\x81a6:V[\x95P` \x87\x015a91\x81a6:V[\x94P`@\x87\x015a9A\x81a8\xF4V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a9]W_\x80\xFD[a9i\x8A\x83\x8B\x01a6^V[\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a9~W_\x80\xFD[Pa9\x8B\x89\x82\x8A\x01a6oV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a9\xAFW_\x80\xFD[\x835a9\xBA\x81a6:V[\x92P` \x84\x015\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9\xDCW_\x80\xFD[a9\xE8\x86\x82\x87\x01a6\xC7V[\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a:\x02W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a:\x18W_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a8.V[_\x80_\x80_\x80_\x80`\xE0\x89\x8B\x03\x12\x15a:;W_\x80\xFD[a:D\x89a6NV[\x97P` \x89\x015\x96P`@\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a:gW_\x80\xFD[a:s\x8C\x83\x8D\x01a6^V[\x97P``\x8B\x015\x91P\x80\x82\x11\x15a:\x88W_\x80\xFD[a:\x94\x8C\x83\x8D\x01a6oV[\x90\x97P\x95P`\x80\x8B\x015\x91P\x80\x82\x11\x15a:\xACW_\x80\xFD[a:\xB8\x8C\x83\x8D\x01a6\xB7V[\x94P`\xA0\x8B\x015\x91P\x80\x82\x11\x15a:\xCDW_\x80\xFD[a:\xD9\x8C\x83\x8D\x01a6\xC7V[\x93P`\xC0\x8B\x015\x91P\x80\x82\x11\x15a:\xEEW_\x80\xFD[Pa:\xFB\x8B\x82\x8C\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[_\x80_\x80_\x80`\xC0\x87\x89\x03\x12\x15a; W_\x80\xFD[a;)\x87a6NV[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a;EW_\x80\xFD[a;Q\x8A\x83\x8B\x01a8.V[\x96P`@\x89\x015\x91P\x80\x82\x11\x15a;fW_\x80\xFD[a;r\x8A\x83\x8B\x01a6\xC7V[\x95P``\x89\x015\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a;\x8EW_\x80\xFD[a;\x9A\x8A\x83\x8B\x01a6\xC7V[\x93P`\xA0\x89\x015\x91P\x80\x82\x11\x15a;\xAFW_\x80\xFD[Pa;\xBC\x89\x82\x8A\x01a6\xC7V[\x91PP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a;\xD9W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a;\xEFW_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a6^V[_` \x82\x84\x03\x12\x15a<\x0BW_\x80\xFD[\x81Qa\x04\xD0\x81a8\xF4V[_` \x82\x84\x03\x12\x15a<&W_\x80\xFD[\x815a\x04\xD0\x81a6:V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[\x805e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a6YW_\x80\xFD[_`\x01`\x01`\xA0\x1B\x03\x80\x87\x16\x83R\x80\x86\x16` \x84\x01RP\x83`@\x83\x01R`\x80``\x83\x01R\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a<\xE2W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a<\xFEW_\x80\xFD[\x806\x03\x82\x13\x15a=\x0CW_\x80\xFD[```\x80\x85\x01Ra=!`\xE0\x85\x01\x82\x84a<1V[\x91PPa=0` \x85\x01a<xV[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16`\xA0\x86\x01R\x80a=L`@\x88\x01a<xV[\x16`\xC0\x86\x01RPP\x80\x91PP\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a=qW_\x80\xFD[\x815`\x03\x81\x10a\x04\xD0W_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xB2W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xCCW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a>\"W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a><W_\x80\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a>\xB2W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a.\xFAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a?1W_\x80\xFD[\x815`\x04\x81\x10a\x04\xD0W_\x80\xFD[\x83\x81R`@` \x82\x01R_a\x1C``@\x83\x01\x84\x86a<1V[_` \x82\x84\x03\x12\x15a?hW_\x80\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x04\xD0W_\x80\xFD[` \x81R_a\x1B\xD3` \x83\x01\x84\x86a<1V[_\x81Q_[\x81\x81\x10\x15a?\xC9W` \x81\x85\x01\x81\x01Q\x86\x83\x01R\x01a?\xAFV[P_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x1B\xD3a?\xE5\x83\x86a?\xAAV[\x84a?\xAAV[_a?\xF6\x82\x86a?\xAAV[\x93\x84RPP` \x82\x01R`@\x01\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_`\xA0\x82\x01\x90P`\x01`\x01`\xA0\x1B\x03\x80\x84Q\x16\x83R\x80` \x85\x01Q\x16` \x84\x01R\x80`@\x85\x01Q\x16`@\x84\x01RP``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x03\x81\x10a@\xA7W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x80`\x80\x84\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a@\xC4W_\x80\xFD[PQ\x91\x90PV[_\x80\x85\x85\x11\x15a@\xD9W_\x80\xFD[\x83\x86\x11\x15a@\xE5W_\x80\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aA\x05W_\x80\xFD[\x845aA\x10\x81a6:V[\x93P` \x85\x015aA \x81a6:V[\x92P`@\x85\x015\x91P``\x85\x015aA7\x81a8\xF4V[\x93\x96\x92\x95P\x90\x93PPV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aAUW_\x80\xFD[\x845aA`\x81a6:V[\x93P` \x85\x015aAp\x81a6:V[\x92P`@\x85\x015aA\x80\x81a6:V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_\x80_\x80_\x80_`\xE0\x88\x8A\x03\x12\x15aA\xA6W_\x80\xFD[\x875aA\xB1\x81a6:V[\x96P` \x88\x015aA\xC1\x81a6:V[\x95P`@\x88\x015aA\xD1\x81a6:V[\x94P``\x88\x015aA\xE1\x81a6:V[\x93P`\x80\x88\x015\x92P`\xA0\x88\x015aA\xF8\x81a6:V[\x80\x92PP`\xC0\x88\x015\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[_\x80_``\x84\x86\x03\x12\x15aB!W_\x80\xFD[\x835aB,\x81a6:V[\x92P` \x84\x015aB<\x81a6:V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15aBaW_\x80\xFD[\x855aBl\x81a6:V[\x94P` \x86\x015aB|\x81a6:V[\x93P`@\x86\x015aB\x8C\x81a6:V[\x92P``\x86\x015\x91P`\x80\x86\x015aB\xA3\x81a8\xF4V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_`\xFF\x83\x16\x80aB\xE8W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x9B\xE5\x8A\xCA\xDA50a\xA2\xA2\x02\xCCp\x11\xF3\xC9\x13\x93\xE0\xF2\xE3\x05\xE9 $E\xB0B\xFCJL\xE6dsolcC\0\x08\x17\x003`\xC0`@R4\x80\x15a\0\x0FW_\x80\xFD[P`@Qa\tc8\x03\x80a\tc\x839\x81\x01`@\x81\x90Ra\0.\x91a\0`V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x91V[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0[W_\x80\xFD[\x91\x90PV[_\x80`@\x83\x85\x03\x12\x15a\0qW_\x80\xFD[a\0z\x83a\0EV[\x91Pa\0\x88` \x84\x01a\0EV[\x90P\x92P\x92\x90PV[`\x80Q`\xA0Qa\x08\x9Ea\0\xC5_9_\x81\x81`H\x01R\x81\x81a\x01\xF2\x01Ra\x03\x81\x01R_\x81\x81`\xD3\x01Ra\x03'\x01Ra\x08\x9E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cj\xFD\xD8P\x14a\0CW\x80c\xB5\x19\xD3i\x14a\0\x93W\x80c\xBC\x11x\xE6\x14a\0\xA8W[_\x80\xFD[a\0j\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xA6a\0\xA16`\x04a\x06\nV[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\x06HV[a\x03\x0FV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81\x14a\x01+W`@Q\x7F|!O\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82\x015\x15a\x01\xAFW`\x01a\x01G`\xA0\x84\x01`\x80\x85\x01a\x06\xDDV[`\x02\x81\x11\x15a\x01XWa\x01Xa\x06\xB0V[\x03a\x01\xB3Wa\x01\xAFa\x01m` \x84\x01\x84a\x07\x02V[a\x01}`@\x85\x01` \x86\x01a\x07\x02V[``\x85\x01\x805\x90a\x01\x91\x90`@\x88\x01a\x07\x02V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x04\xCCV[PPV[`\x02a\x01\xC5`\xA0\x84\x01`\x80\x85\x01a\x06\xDDV[`\x02\x81\x11\x15a\x01\xD6Wa\x01\xD6a\x06\xB0V[\x03a\x02\xDDWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c6\xC7\x85\x16a\x02$` \x85\x01\x85a\x07\x02V[a\x024`@\x86\x01` \x87\x01a\x07\x02V[``\x86\x01\x805\x90a\x02H\x90`@\x89\x01a\x07\x02V[`@Q`\xE0\x86\x90\x1B\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16`\x04\x82\x01R\x92\x84\x16`$\x84\x01R\x90\x83\x16`D\x83\x01R\x90\x91\x16`d\x82\x01R`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xC3W_\x80\xFD[PZ\xF1\x15\x80\x15a\x02\xD5W=_\x80>=_\xFD[PPPPPPV[`@Q\x7F\xC7\x9A\xAAD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81\x14a\x03\x7FW`@Q\x7F|!O\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c+g\xB5p\x86`@Q\x80``\x01`@R\x80`@Q\x80`\x80\x01`@R\x80\x8As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x88`@\x01` \x81\x01\x90a\x04\x1D\x91\x90a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x88` \x01` \x81\x01\x90a\x04=\x91\x90a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90R\x81R0` \x82\x01R`@\x90\x81\x01\x90a\x04e\x90``\x89\x01\x90\x89\x01a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90Ra\x04y\x86\x80a\x07@V[`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x98\x94\x93\x92\x91\x90a\x07\xA8V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xAFW_\x80\xFD[PZ\xF1\x15\x80\x15a\x04\xC1W=_\x80>=_\xFD[PPPPPPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x05a\x90\x85\x90a\x05gV[PPPPV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a\x05\x86W`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a\x05\x9DW\x80`\x01\x14\x15a\x05\xB7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16;\x15[\x15a\x05aW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`\x04\x82\x01R`$\x01`@Q\x80\x91\x03\x90\xFD[_`\xA0\x82\x84\x03\x12\x15a\x06\x1AW_\x80\xFD[P\x91\x90PV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06CW_\x80\xFD[\x91\x90PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15a\x06[W_\x80\xFD[a\x06d\x85a\x06 V[\x93Pa\x06r` \x86\x01a\x06 V[\x92P`@\x85\x015\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x94W_\x80\xFD[\x85\x01``\x81\x88\x03\x12\x15a\x06\xA5W_\x80\xFD[\x93\x96\x92\x95P\x90\x93PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x06\xEDW_\x80\xFD[\x815`\x03\x81\x10a\x06\xFBW_\x80\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x07\x12W_\x80\xFD[a\x06\xFB\x82a\x06 V[_` \x82\x84\x03\x12\x15a\x07+W_\x80\xFD[\x815e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06\xFBW_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x07sW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x07\x8DW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x07\xA1W_\x80\xFD[\x92P\x92\x90PV[_a\x01\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16\x84R\x86Q\x81\x81Q\x16` \x86\x01R\x81` \x82\x01Q\x16`@\x86\x01R`@\x81\x01Qe\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16``\x88\x01R\x80``\x84\x01Q\x16`\x80\x88\x01RPPP\x80` \x88\x01Q\x16`\xA0\x85\x01RP`@\x86\x01Q`\xC0\x84\x01R\x80`\xE0\x84\x01R\x83\x81\x84\x01RPa\x01 \x83\x85\x82\x85\x017_\x83\x85\x01\x82\x01R`\x1F\x90\x93\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x90\x91\x01\x90\x91\x01\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xF3V_e\x89P\x02v\xFC\xBBo\xB3=>\xE3\xB54\xD9Vl['2\xFE\x10\xA6\x03\x9Bu<:\x07dsolcC\0\x08\x17\x003",
-    );
-    /// The runtime bytecode of the contract, as deployed on the network.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\x80`@R`\x046\x10a\x01&W_5`\xE0\x1C\x80c\xA5\xCD\xC8\xFC\x11a\0\xA1W\x80c\xC6\x18a\x81\x11a\0qW\x80c\xDBXw(\x11a\0WW\x80c\xDBXw(\x14a\x03yW\x80c\xE2B\x92N\x14a\x03\x8CW\x80c\xFA\\\xD5l\x14a\x03\xABW_\x80\xFD[\x80c\xC6\x18a\x81\x14a\x03'W\x80c\xCB\xA6s\xA7\x14a\x03ZW_\x80\xFD[\x80c\xA5\xCD\xC8\xFC\x14a\x02\xABW\x80c\xA7\xABI\xBC\x14a\x02\xCAW\x80c\xAE\x80\xC5\x84\x14a\x02\xE9W\x80c\xB1\x1F\x12b\x14a\x03\x08W_\x80\xFD[\x80cQ\xD4h\x15\x11a\0\xF6W\x80co5\xD2\xD2\x11a\0\xDCW\x80co5\xD2\xD2\x14a\x02FW\x80c\x87U0\xFF\x14a\x02yW\x80c\x995\xC8h\x14a\x02\x98W_\x80\xFD[\x80cQ\xD4h\x15\x14a\x02\x12W\x80cZ\xA0\xE9]\x14a\x02'W_\x80\xFD[\x80c\x16&\xBA~\x14a\x011W\x80c)\xBC\xDC\x95\x14a\x01\x86W\x80c6D\xE5\x15\x14a\x01\xD1W\x80cL\x9E\x03\xD3\x14a\x01\xF3W_\x80\xFD[6a\x01-W\0[_\x80\xFD[4\x80\x15a\x01<W_\x80\xFD[Pa\x01Pa\x01K6`\x04a5\x95V[a\x03\xCAV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x91W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01}V[4\x80\x15a\x01\xDCW_\x80\xFD[Pa\x01\xE5a\x04\xD7V[`@Q\x90\x81R` \x01a\x01}V[4\x80\x15a\x01\xFEW_\x80\xFD[Pa\x01\xE5a\x02\r6`\x04a6 V[a\x05\xC6V[a\x02%a\x02 6`\x04a6\xD7V[a\x06gV[\0[4\x80\x15a\x022W_\x80\xFD[Pa\x02%a\x02A6`\x04a7\xE1V[a\t\xE8V[4\x80\x15a\x02QW_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x02\x84W_\x80\xFD[Pa\x01\xE5a\x02\x936`\x04a6 V[a\x0C0V[a\x02%a\x02\xA66`\x04a8?V[a\x0C_V[4\x80\x15a\x02\xB6W_\x80\xFD[Pa\x02%a\x02\xC56`\x04a8\xDDV[a\x0C\x7FV[4\x80\x15a\x02\xD5W_\x80\xFD[Pa\x02%a\x02\xE46`\x04a9\x01V[a\x0C\x8CV[4\x80\x15a\x02\xF4W_\x80\xFD[Pa\x02%a\x03\x036`\x04a9\x9DV[a\x10gV[4\x80\x15a\x03\x13W_\x80\xFD[Pa\x01\xE5a\x03\"6`\x04a9\xF2V[a\x12\xEBV[4\x80\x15a\x032W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x03eW_\x80\xFD[Pa\x02%a\x03t6`\x04a:$V[a\x14\xEAV[a\x02%a\x03\x876`\x04a;\x0BV[a\x18xV[4\x80\x15a\x03\x97W_\x80\xFD[Pa\x01\xE5a\x03\xA66`\x04a;\xC9V[a\x19LV[4\x80\x15a\x03\xB6W_\x80\xFD[Pa\x02%a\x03\xC56`\x04a;\xC9V[a\x1A\x8EV[_\x80a\x03\xD7\x85\x85\x85a\x1BPV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\x04\x83\x01R\x91\x92P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04YW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04}\x91\x90a;\xFBV[\x15a\x04\xABW\x7F\x16&\xBA~5oYy\xDD5Z=+\xFBC\xE8\x04 \xA4\x80\xC3\xB8T\xED\xCE(j\x82\xD7Ihi\x91PPa\x04\xD0V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14a\x05\xA1W`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[_\x7Fh\xB8\xE9M\xC0wE\x82A\xD6\xC8\xD8\x9F\nve\xC7\xCD\xA2\xCF\xE7\x0C\x9E\xB4C~\xFE\xE1f<f\xFEa\x05\xF5` \x84\x01\x84a<\x16V[\x83` \x015\x84`@\x015\x85``\x015\x86`\x80\x015`@Q` \x01a\x06J\x96\x95\x94\x93\x92\x91\x90\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16` \x86\x01R`@\x85\x01\x92\x90\x92R``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x06oa\x1B\xDBV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xECW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x10\x91\x90a;\xFBV[a\x07FW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x87\x015\x88\x15\x80\x15\x90a\x07`WPa\x01`\x88\x015\x89\x11\x15[\x15a\x07\x7FWa\x07|\x89a\x02\0\x8A\x015a\x01`\x8B\x015`\x01a\x1C\x1EV[\x90P[a\x07\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x83\x8B\x8B\x8B\x8B\x8B\x8Ba\x1CiV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x07\xEF`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x08\x01a\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Ra\x08D\x92\x91\x90a\x01`\x8E\x015\x90\x88\x90`\x04\x01a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08[W_\x80\xFD[PZ\xF1\x15\x80\x15a\x08mW=_\x80>=_\xFD[PPPPa\x08\xB4\x88\x8B\x83\x8C_\x14\x80a\x08\x89WPa\x01`\x8C\x015\x8D\x11[a\x08\x93W\x8Ca\x08\x9AV[a\x01`\x8C\x015[\x89\x8C\x8C`\x02a\x08\xAF`@\x8E\x01` \x8F\x01a=aV[a\x1E\x01V[a\x08\xC1`@\x89\x01\x89a=\x7FV[`@Qa\x08\xCF\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\t\t`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a\t\x19`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[a\t+a\x01@\x8D\x01a\x01 \x8E\x01a<\x16V[a\t=a\x01\xE0\x8E\x01a\x01\xC0\x8F\x01a<\x16V[\x8E\x15\x80a\tNWPa\x01`\x8E\x015\x8F\x11[a\tXW\x8Ea\t_V[a\x01@\x8E\x015[a\x02\0\x8F\x015\x88\x14a\tqW\x87a\txV[a\x01\xE0\x8F\x015[\x8F`\xE0\x01` \x81\x01\x90a\t\x8B\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\t\xDD`\x01\x80UV[PPPPPPPPPV[_[a\t\xF4\x82\x80a=\xEFV[\x90P\x81\x10\x15a\x0B\x06W6a\n\x08\x83\x80a=\xEFV[\x83\x81\x81\x10a\n\x18Wa\n\x18a>SV[\x90P` \x02\x81\x01\x90a\n*\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\nH` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xA2W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xC6\x91\x90a;\xFBV[\x15a\n\xFDW`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\t\xEAV[P_[a\x0B\x16` \x83\x01\x83a=\xEFV[\x90P\x81\x10\x15a\x0C+W6a\x0B-` \x84\x01\x84a=\xEFV[\x83\x81\x81\x10a\x0B=Wa\x0B=a>SV[\x90P` \x02\x81\x01\x90a\x0BO\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\x0Bm` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xC7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xEB\x91\x90a;\xFBV[\x15a\x0C\"W`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x0B\tV[PPPV[_\x7F\xAEgk\xF6\x91:\xC2h\x9Bs1)<\x98\x9F\xE7r1$\xFA\xF8\xB5\xD2u\xF0o\xBC\xEB\xC7yP\ta\x05\xF5` \x84\x01\x84a<\x16V[a\x0Ci\x84\x82a\"\x12V[a\x0Cx\x85\x85\x85\x85`\x01\x80a\"\xC9V[PPPPPV[a\x0C\x893\x82a&\x1EV[PV[a\x0C\xBF`@Q\x80`\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[_[\x82\x81\x10\x15a\x10SW6\x84\x84\x83\x81\x81\x10a\x0C\xDCWa\x0C\xDCa>SV[\x90P` \x02\x81\x01\x90a\x0C\xEE\x91\x90a>\x80V[\x90P6_a\x0C\xFF`@\x84\x01\x84a=\x7FV[\x90\x92P\x90P`\x01`\x01`\xA0\x1B\x03\x8B\x16c\xA8\xC4\xBC\x95a\r ` \x86\x01\x86a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\rzW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x9E\x91\x90a;\xFBV[\x15a\x10EW_\x89\x15a\r\xDCW`@Q\x7F}a{\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04\x82\x10a\r\xE8WP\x815[\x7F\xC0:\x9D\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0EVWa\x0E=\x83\x83\x8D\x8Ca&\xC4V[\x86` \x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x90RPa\x10CV[\x7F$:K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0E\xBCWa\x0E\xAB\x83\x83\x8D\x8Ca'\xDAV[\x86``\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x7F}\xC4\xF4X\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0FGWa\x0F\x11\x83\x83\x8D\x8Ca)NV[`\xA0\x88\x01R`\x80\x87\x01\x81\x90R``\x87\x01\x80Qa\x0F.\x90\x83\x90a>\xBCV[\x90RP`\xA0\x86\x01Q` \x87\x01\x80Qa\x0EN\x90\x83\x90a>\xBCV[\x7Fh\x93\x1Bk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0F\xABWa\x0F\x9C\x83\x83\x8D\x8Ca+\xB6V[\x86Q\x87\x90a\x0EN\x90\x83\x90a>\xBCV[\x7F\x0C\x9B\xE7\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x10\x11Wa\x10\0\x83\x83\x8D\x8Ca,\xC0V[\x86`@\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[`@Q\x7F\x05a\xD8\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPP\x80`\x01\x01\x90Pa\x0C\xC1V[Pa\x10^\x84\x82a.)V[PPPPPPPV[`\x03a\x10v` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x10\x87Wa\x10\x87a>\xF4V[\x03a\x10\xECW`\x01`\x01`\xA0\x1B\x03\x83\x16a\x10\xAC\x83a\x10\xA7`@\x85\x01\x85a=\x7FV[a\x1BPV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0C+W`@Q\x7F\xB8\x1DX\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01a\x10\xFB` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\x0CWa\x11\x0Ca>\xF4V[\x03a\x11\xA0W\x7F\x19Ethereum Signed Message:\n32\0\0\0\0_\x90\x81R`\x1C\x83\x90R`<\x90 `\x01`\x01`\xA0\x1B\x03\x84\x16a\x11Z\x82a\x10\xA7`@\x86\x01\x86a=\x7FV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x11\x9AW`@Q\x7FdJ\xE6\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\x02a\x11\xAF` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\xC0Wa\x11\xC0a>\xF4V[\x03a\x12\xB9W\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x84\x16c\x16&\xBA~\x84a\x12\x03`@\x86\x01\x86a=\x7FV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12!\x93\x92\x91\x90a??V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12<W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12`\x91\x90a?XV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x0C+W`@Q\x7F]R\xCB\xE3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F`\xCD@-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xF4a\x04\xD7V[\x7F\xD2\x8E\x80\x9Bp\x8F^\xE3\x8B\xE84}m\x86\x9D\x822I<\tJ\xB2\xDD\xE9\x83i\xE4\x10#i\xA9\x9Da\x13\x1F\x84\x80a=\x7FV[`@Q` \x01a\x130\x92\x91\x90a?\x97V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x84` \x015\x85`@\x01` \x81\x01\x90a\x13^\x91\x90a<\x16V[`@\x80Q` \x81\x01\x95\x90\x95R\x84\x01\x92\x90\x92R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90Ra\x13\xC4`\x80\x85\x01``\x86\x01a<\x16V[a\x13\xD4`\xA0\x86\x01`\x80\x87\x01a<\x16V[a\x13\xE4`\xC0\x87\x01`\xA0\x88\x01a<\x16V[`\xC0\x87\x015`\xE0\x88\x015a\x01\0\x89\x015a\x01 \x8A\x015a\x14\x0Ca\x01`\x8C\x01a\x01@\x8D\x01a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x99\x8A\x16` \x82\x01R\x97\x89\x16\x90\x88\x01R\x94\x87\x16``\x87\x01R`\x80\x86\x01\x93\x90\x93R`\xA0\x85\x01\x91\x90\x91R`\xC0\x84\x01R`\xE0\x83\x01R\x90\x91\x16a\x01\0\x82\x01Ra\x01 \x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x14\x92\x92\x91` \x01a?\xD7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\x06J\x92\x91\x90\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[a\x14\xF2a\x1B\xDBV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15mW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x91\x91\x90a;\xFBV[a\x15\xC7W`@Q\x7F\xC19\xEA\xBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16DW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16h\x91\x90a;\xFBV[a\x16\x9EW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x86\x015\x87\x15\x80\x15\x90a\x16\xB8WPa\x01`\x87\x015\x88\x11\x15[\x15a\x16\xD7Wa\x16\xD4\x88a\x02\0\x89\x015a\x01`\x8A\x015`\x01a\x1C\x1EV[\x90P[a\x17\x08\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x83\x8A\x8A\x8A\x8A\x8A\x8Aa\x1CiV[a\x17E\x87\x8A\x83\x8B\x15\x80a\x17\x1FWPa\x01`\x8B\x015\x8C\x11[a\x17)W\x8Ba\x170V[a\x01`\x8B\x015[\x88\x8B\x8B`\x01a\x08\xAF`@\x8D\x01` \x8E\x01a=aV[a\x17R`@\x88\x01\x88a=\x7FV[`@Qa\x17`\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\x17\x9A`\xA0\x8A\x01`\x80\x8B\x01a<\x16V[a\x17\xAA`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x17\xBCa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[a\x17\xCEa\x01\xE0\x8D\x01a\x01\xC0\x8E\x01a<\x16V[\x8D\x15\x80a\x17\xDFWPa\x01`\x8D\x015\x8E\x11[a\x17\xE9W\x8Da\x17\xF0V[a\x01@\x8D\x015[a\x02\0\x8E\x015\x88\x14a\x18\x02W\x87a\x18\tV[a\x01\xE0\x8E\x015[\x8E`\xE0\x01` \x81\x01\x90a\x18\x1C\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\x18n`\x01\x80UV[PPPPPPPPV[a\x18\x82\x85\x83a\"\x12V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x18\xC1`\x80\x88\x01``\x89\x01a<\x16V[a\x18\xD1`\xA0\x89\x01`\x80\x8A\x01a<\x16V[\x88`\xC0\x015\x85`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x18\xF6\x94\x93\x92\x91\x90a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x19\rW_\x80\xFD[PZ\xF1\x15\x80\x15a\x19\x1FW=_\x80>=_\xFD[PPPPa\x19D\x86\x86\x86\x86`\x02\x89` \x01` \x81\x01\x90a\x19?\x91\x90a=aV[a\"\xC9V[PPPPPPV[_a\x19Ua\x04\xD7V[\x7F\xC9\x94\xD2\xCA\x03u\xD6\xD4sx^\x0C\xE0\xB1\xD2\x03\xF0i\x12\x1B\xAC\x13\x14\xF7,\\\x0F\xE6\x01\xEB9\x10a\x19\x83`@\x85\x01\x85a=\x7FV[`@Q` \x01a\x19\x94\x92\x91\x90a?\x97V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 ``\x85\x015a\x19\xDF`\xA0\x87\x01`\x80\x88\x01a<\x16V[a\x19\xEF`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\xC0\x88\x015a\x1A\x05a\x01\0\x8A\x01`\xE0\x8B\x01a<\x16V[`@\x80Q` \x81\x01\x98\x90\x98R\x87\x01\x95\x90\x95R``\x86\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80\x86\x01R\x81\x16`\xA0\x85\x01R`\xC0\x84\x01\x91\x90\x91R\x16`\xE0\x82\x01Ra\x01\0\x80\x85\x015\x90\x82\x01Ra\x01 \x01`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1Ao\x84a\x01 \x01a\x0C0V[a\x1A|\x85a\x01\xC0\x01a\x05\xC6V[`@Q` \x01a\x14\x92\x93\x92\x91\x90a?\xEBV[a\x01\xA0\x81\x015a\x1A\xA8a\x01\x80\x83\x015a\x01`\x84\x015a>\xBCV[a\x1A\xB2\x91\x90a>\xBCV[a\x01@\x82\x015\x14a\x1A\xEFW`@Q\x7F\xC0Cw\xD3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x81\x015a\x1B\ta\x02 \x83\x015a\x02\0\x84\x015a>\xBCV[a\x1B\x13\x91\x90a>\xBCV[a\x01\xE0\x82\x015\x14a\x0C\x89W`@Q\x7F\x87v0\xBE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x91\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa.\xD6\x92PPPV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1B\xD3W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x94\x93PPPPV[`\x02`\x01T\x03a\x1C\x17W`@Q\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01UV[_a\x1CKa\x1C+\x83a/\0V[\x80\x15a\x1CFWP_\x84\x80a\x1CAWa\x1CAa@\x08V[\x86\x88\t\x11[\x15\x15\x90V[a\x1CV\x86\x86\x86a/,V[a\x1C`\x91\x90a>\xBCV[\x95\x94PPPPPV[_a\x1Cs\x87a\x19LV[\x90Pa\x1C\x80\x89\x82\x85a\x10gV[a\x1C\x90`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1C\xC7Wa\x1C\xC2a\x1C\xBB`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x82\x84a\x10gV[a\x1D\x0EV[a\x1C\xD4`@\x83\x01\x83a=\x7FV[\x90P_\x03a\x1D\x0EW`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D+a\x1D!`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x88``\x015a&\x1EV[\x86`\xC0\x015B\x11\x15a\x1DiW`@Q\x7F\x13=\xF0)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x88\x11\x80\x15a\x1D|WP\x86a\x01\0\x015\x88\x10[\x15a\x1D\xB3W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\xBC\x87a\x1A\x8EV[a\x1D\xC6\x8A\x85a\t\xE8V[a\x1D\xE7\x8A\x8A_\x8B\x11\x80\x15a\x1D\xDFWPa\x02\0\x8A\x015\x8B\x14\x15[\x8A\x8A\x8Aa\x0C\x8CV[a\x1D\xF5\x89\x88``\x015a&\x1EV[PPPPPPPPPPV[a\x1E\x13a\x1E\x0E\x86\x80a=\xEFV[a0\x01V[_a\x1E(a\x01\x80\x8B\x015a\x01\xA0\x8C\x015a>\xBCV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Ew\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x010`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1E\xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x86`\x02\x81\x11\x15a\x1E\xD0Wa\x1E\xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1F\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a\x1F\x18W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Fi\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\xE0\x01` \x81\x01\x90a\x1F\x8A\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1F\xAE\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A\x81R` \x01\x86`\x02\x81\x11\x15a\x1F\xD4Wa\x1F\xD4a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F\xF3\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a \nW_\x80\xFD[PZ\xF1\x15\x80\x15a \x1CW=_\x80>=_\xFD[PPPPa *\x85\x85a0\x01V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8C`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\x80\x01` \x81\x01\x90a \x86\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01\xC0\x01_\x01` \x81\x01\x90a \xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8B\x81R` \x01\x85`\x02\x81\x11\x15a \xD0Wa \xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a!\x18W=_\x80>=_\xFD[Pa!.\x92Pa\x1E\x0E\x91PP` \x88\x01\x88a=\xEFV[_a!Aa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!\x9EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\xC2\x91\x90a@\xB4V[\x90P\x80\x15a\"\x05Wa\"\x05a!\xDEa\x01\0\x8D\x01`\xE0\x8E\x01a<\x16V[\x82\x8Da\x01 \x01_\x01` \x81\x01\x90a!\xF5\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a19V[PPPPPPPPPPPV[a\"\"`\x80\x83\x01``\x84\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\"aWa\"\\a\"M`\x80\x84\x01``\x85\x01a<\x16V[a\"V\x84a\x12\xEBV[\x83a\x10gV[a\"\xA8V[a\"n`@\x82\x01\x82a=\x7FV[\x90P_\x03a\"\xA8W`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\"\xC5a\"\xBB`\x80\x84\x01``\x85\x01a<\x16V[\x83` \x015a&\x1EV[PPV[`\xE0\x85\x015\x83\x15\x80\x15\x90a\"\xE0WP\x85`\xC0\x015\x84\x10[\x15a\"\xFDWa\"\xFA\x84\x87`\xE0\x015\x88`\xC0\x015`\x01a\x1C\x1EV[\x90P[a#\t\x87\x82\x88\x88a1\xB9V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x89``\x01` \x81\x01\x90a#V\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#va\x01`\x8B\x01a\x01@\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#\x94`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x87\x15\x80a#\xB2WP\x89`\xC0\x015\x88\x11[a#\xBCW\x87a#\xC2V[\x89`\xC0\x015[\x81R` \x01\x86`\x02\x81\x11\x15a#\xD9Wa#\xD9a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\xF8\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\x0FW_\x80\xFD[PZ\xF1\x15\x80\x15a$!W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`@\x01` \x81\x01\x90a$\x81\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a$\x9F`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x02\x81\x11\x15a$\xC5Wa$\xC5a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a$\xE4\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\xFBW_\x80\xFD[PZ\xF1\x15\x80\x15a%\rW=_\x80>=_\xFD[Pa%\x1E\x92P\x88\x91P\x81\x90Pa=\x7FV[`@Qa%,\x92\x91\x90a=\xE0V[`@Q\x80\x91\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6\x87`@\x01` \x81\x01\x90a%h\x91\x90a<\x16V[a%x`\x80\x8A\x01``\x8B\x01a<\x16V[a%\x88`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a%\x98`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[\x89\x15\x80a%\xA8WP\x8B`\xC0\x015\x8A\x11[a%\xB2W\x89a%\xB8V[\x8B`\xC0\x015[\x87\x8Da\x01@\x01` \x81\x01\x90a%\xCD\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x84\x84R\x90\x91R\x90 T`\xFF\x16\x15a&yW`@Q\x7F\xBC\r\xA7\xD6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x83R\x92\x90R \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16`\x01\x17\x90UV[_\x80\x80\x80a&\xD5\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a&\xE2\x91\x90a@\xF2V[P\x91\x94P\x92P\x90Pa&\xFCa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a'FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a'\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x97\x96PPPPPPPV[_\x80\x80\x80\x80a'\xEC\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a'\xF9\x91\x90aABV[\x92\x96P\x90\x94P\x92P\x90Pa(\x15a\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a(_W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a(\xAAW`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a(\xBA`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a)\x04W`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x98\x97PPPPPPPPV[_\x80_\x80_\x80_\x80_\x8C\x8C`\x04\x90\x80\x92a)j\x93\x92\x91\x90a@\xCBV[\x81\x01\x90a)w\x91\x90aA\x90V[\x95\x9CP\x93\x9AP\x91\x98P\x96P\x94P\x92P\x90Pa)\x9Aa\x01\xE0\x8B\x01a\x01\xC0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a)\xE4W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85`\x01`\x01`\xA0\x1B\x03\x16\x8B`\x01`\x01`\xA0\x1B\x03\x16\x14a*/W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x160\x14a*qW`@Q\x7F\x81T7K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x81`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a*\xCBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x8A\x015\x83\x14a+\tW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+\x1Ba\x01@\x8B\x01a\x01 \x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a+eW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x8A\x015\x81\x14a+\xA3W`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x9C\x91\x9BP\x90\x99PPPPPPPPPPV[_\x80\x80\x80a+\xC7\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a+\xD4\x91\x90aB\x0FV[\x91\x94P\x92P\x90Pa+\xEDa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a,7W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a,\x82W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\x80\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80\x80\x80a,\xD2\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a,\xDF\x91\x90aBMV[P\x92\x96P\x90\x94P\x92P\x90Pa,\xFCa\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a-FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a-\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a-\xA1`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a-\xEBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02 \x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01\x80\x83\x015\x14\x15\x80a.GWP` \x81\x01Qa\x01\xA0\x83\x015\x14\x15[\x15a.~W`@Q\x7FJU\xDA \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x81\x01Qa\x02 \x83\x015\x14\x15\x80a.\x9FWP``\x81\x01Qa\x02@\x83\x015\x14\x15[\x15a\"\xC5W`@Q\x7Fw\xA5\x92\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x80a.\xE4\x86\x86a2\\V[\x92P\x92P\x92Pa.\xF4\x82\x82a2\xA5V[P\x90\x91PP[\x92\x91PPV[_`\x02\x82`\x03\x81\x11\x15a/\x15Wa/\x15a>\xF4V[a/\x1F\x91\x90aB\xB1V[`\xFF\x16`\x01\x14\x90P\x91\x90PV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a/\x7FW\x83\x82\x81a/uWa/ua@\x08V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a/\x96Wa/\x96`\x03\x85\x15\x02`\x11\x18a3\xADV[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP\x93\x92PPPV[_[\x81\x81\x10\x15a\x0C+W6\x83\x83\x83\x81\x81\x10a0\x1EWa0\x1Ea>SV[\x90P` \x02\x81\x01\x90a00\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a0i` \x83\x01\x83a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x03a0\xA9W`@Q\x7Fy\xA1\xBF\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a0\xB2\x81a3\xBEV[a0\xBF` \x82\x01\x82a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a0\xF7\x84a4\x01V[`@\x80Q\x92\x83R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA2P`\x01\x01a0\x03V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C+\x90\x84\x90a4*V[_\x83\x11\x80\x15a1\xCCWP\x81a\x01\0\x015\x83\x10[\x15a2\x03W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2\x10\x84a\"V\x84a\x12\xEBV[a2\x1E\x84\x83` \x015a&\x1EV[B\x82a\x01 \x015\x11a\x11\x9AW`@Q\x7F\xC5hs\xBA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x83Q`A\x03a2\x93W` \x84\x01Q`@\x85\x01Q``\x86\x01Q_\x1Aa2\x85\x88\x82\x85\x85a4\xAFV[\x95P\x95P\x95PPPPa2\x9EV[PP\x81Q_\x91P`\x02\x90[\x92P\x92P\x92V[_\x82`\x03\x81\x11\x15a2\xB8Wa2\xB8a>\xF4V[\x03a2\xC1WPPV[`\x01\x82`\x03\x81\x11\x15a2\xD5Wa2\xD5a>\xF4V[\x03a3\x0CW`@Q\x7F\xF6E\xEE\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x82`\x03\x81\x11\x15a3 Wa3 a>\xF4V[\x03a3_W`@Q\x7F\xFC\xE6\x98\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x03\x82`\x03\x81\x11\x15a3sWa3sa>\xF4V[\x03a\"\xC5W`@Q\x7F\xD7\x8B\xCE\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01a3VV[cNH{q_R\x80` R`$`\x1C\xFD[_a3\xCC` \x83\x01\x83a<\x16V[\x90P` \x82\x0156_a3\xE2`@\x86\x01\x86a=\x7FV[\x91P\x91P`@Q\x81\x83\x827_\x80\x83\x83\x87\x89Z\xF1a\x19DW=_\x80>=_\xFD[_6\x81a4\x11`@\x85\x01\x85a=\x7FV[\x90\x92P\x90P`\x04\x81\x10a4#W\x815\x92P[PP\x91\x90PV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a4IW`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a4`W\x80`\x01\x14\x15a4mV[`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x11\x9AW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a3VV[_\x80\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x84\x11\x15a4\xE8WP_\x91P`\x03\x90P\x82a5\x8BV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x8A\x90R`\xFF\x89\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x87\x90R`\x80\x81\x01\x86\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a59W=_\x80>=_\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a5\x82WP_\x92P`\x01\x91P\x82\x90Pa5\x8BV[\x92P_\x91P\x81\x90P[\x94P\x94P\x94\x91PPV[_\x80_`@\x84\x86\x03\x12\x15a5\xA7W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a5\xC5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a5\xD8W_\x80\xFD[\x815\x81\x81\x11\x15a5\xE6W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a5\xF7W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[_`\xA0\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[P\x91\x90PV[_`\xA0\x82\x84\x03\x12\x15a60W_\x80\xFD[a\x04\xD0\x83\x83a6\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x89W_\x80\xFD[\x805a6Y\x81a6:V[\x91\x90PV[_a\x02`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80\x83`\x1F\x84\x01\x12a6\x7FW_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x96W_\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a6\xB0W_\x80\xFD[\x92P\x92\x90PV[_`@\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_``\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a6\xF0W_\x80\xFD[a6\xF9\x8Aa6NV[\x98P` \x8A\x015\x97P`@\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a7\x1CW_\x80\xFD[a7(\x8D\x83\x8E\x01a6^V[\x98P``\x8C\x015\x91P\x80\x82\x11\x15a7=W_\x80\xFD[a7I\x8D\x83\x8E\x01a6oV[\x90\x98P\x96P`\x80\x8C\x015\x91P\x80\x82\x11\x15a7aW_\x80\xFD[a7m\x8D\x83\x8E\x01a6\xB7V[\x95P`\xA0\x8C\x015\x91P\x80\x82\x11\x15a7\x82W_\x80\xFD[a7\x8E\x8D\x83\x8E\x01a6\xC7V[\x94P`\xC0\x8C\x015\x91P\x80\x82\x11\x15a7\xA3W_\x80\xFD[a7\xAF\x8D\x83\x8E\x01a6\xC7V[\x93P`\xE0\x8C\x015\x91P\x80\x82\x11\x15a7\xC4W_\x80\xFD[Pa7\xD1\x8C\x82\x8D\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[_\x80`@\x83\x85\x03\x12\x15a7\xF2W_\x80\xFD[\x825a7\xFD\x81a6:V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x18W_\x80\xFD[a8$\x85\x82\x86\x01a6\xB7V[\x91PP\x92P\x92\x90PV[_a\x01`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15a8SW_\x80\xFD[\x855a8^\x81a6:V[\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a8zW_\x80\xFD[a8\x86\x89\x83\x8A\x01a8.V[\x95P`@\x88\x015\x91P\x80\x82\x11\x15a8\x9BW_\x80\xFD[a8\xA7\x89\x83\x8A\x01a6\xC7V[\x94P``\x88\x015\x93P`\x80\x88\x015\x91P\x80\x82\x11\x15a8\xC3W_\x80\xFD[Pa8\xD0\x88\x82\x89\x01a6\xC7V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_` \x82\x84\x03\x12\x15a8\xEDW_\x80\xFD[P5\x91\x90PV[\x80\x15\x15\x81\x14a\x0C\x89W_\x80\xFD[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a9\x16W_\x80\xFD[\x865a9!\x81a6:V[\x95P` \x87\x015a91\x81a6:V[\x94P`@\x87\x015a9A\x81a8\xF4V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a9]W_\x80\xFD[a9i\x8A\x83\x8B\x01a6^V[\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a9~W_\x80\xFD[Pa9\x8B\x89\x82\x8A\x01a6oV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a9\xAFW_\x80\xFD[\x835a9\xBA\x81a6:V[\x92P` \x84\x015\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9\xDCW_\x80\xFD[a9\xE8\x86\x82\x87\x01a6\xC7V[\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a:\x02W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a:\x18W_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a8.V[_\x80_\x80_\x80_\x80`\xE0\x89\x8B\x03\x12\x15a:;W_\x80\xFD[a:D\x89a6NV[\x97P` \x89\x015\x96P`@\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a:gW_\x80\xFD[a:s\x8C\x83\x8D\x01a6^V[\x97P``\x8B\x015\x91P\x80\x82\x11\x15a:\x88W_\x80\xFD[a:\x94\x8C\x83\x8D\x01a6oV[\x90\x97P\x95P`\x80\x8B\x015\x91P\x80\x82\x11\x15a:\xACW_\x80\xFD[a:\xB8\x8C\x83\x8D\x01a6\xB7V[\x94P`\xA0\x8B\x015\x91P\x80\x82\x11\x15a:\xCDW_\x80\xFD[a:\xD9\x8C\x83\x8D\x01a6\xC7V[\x93P`\xC0\x8B\x015\x91P\x80\x82\x11\x15a:\xEEW_\x80\xFD[Pa:\xFB\x8B\x82\x8C\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[_\x80_\x80_\x80`\xC0\x87\x89\x03\x12\x15a; W_\x80\xFD[a;)\x87a6NV[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a;EW_\x80\xFD[a;Q\x8A\x83\x8B\x01a8.V[\x96P`@\x89\x015\x91P\x80\x82\x11\x15a;fW_\x80\xFD[a;r\x8A\x83\x8B\x01a6\xC7V[\x95P``\x89\x015\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a;\x8EW_\x80\xFD[a;\x9A\x8A\x83\x8B\x01a6\xC7V[\x93P`\xA0\x89\x015\x91P\x80\x82\x11\x15a;\xAFW_\x80\xFD[Pa;\xBC\x89\x82\x8A\x01a6\xC7V[\x91PP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a;\xD9W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a;\xEFW_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a6^V[_` \x82\x84\x03\x12\x15a<\x0BW_\x80\xFD[\x81Qa\x04\xD0\x81a8\xF4V[_` \x82\x84\x03\x12\x15a<&W_\x80\xFD[\x815a\x04\xD0\x81a6:V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[\x805e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a6YW_\x80\xFD[_`\x01`\x01`\xA0\x1B\x03\x80\x87\x16\x83R\x80\x86\x16` \x84\x01RP\x83`@\x83\x01R`\x80``\x83\x01R\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a<\xE2W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a<\xFEW_\x80\xFD[\x806\x03\x82\x13\x15a=\x0CW_\x80\xFD[```\x80\x85\x01Ra=!`\xE0\x85\x01\x82\x84a<1V[\x91PPa=0` \x85\x01a<xV[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16`\xA0\x86\x01R\x80a=L`@\x88\x01a<xV[\x16`\xC0\x86\x01RPP\x80\x91PP\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a=qW_\x80\xFD[\x815`\x03\x81\x10a\x04\xD0W_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xB2W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xCCW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a>\"W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a><W_\x80\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a>\xB2W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a.\xFAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a?1W_\x80\xFD[\x815`\x04\x81\x10a\x04\xD0W_\x80\xFD[\x83\x81R`@` \x82\x01R_a\x1C``@\x83\x01\x84\x86a<1V[_` \x82\x84\x03\x12\x15a?hW_\x80\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x04\xD0W_\x80\xFD[` \x81R_a\x1B\xD3` \x83\x01\x84\x86a<1V[_\x81Q_[\x81\x81\x10\x15a?\xC9W` \x81\x85\x01\x81\x01Q\x86\x83\x01R\x01a?\xAFV[P_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x1B\xD3a?\xE5\x83\x86a?\xAAV[\x84a?\xAAV[_a?\xF6\x82\x86a?\xAAV[\x93\x84RPP` \x82\x01R`@\x01\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_`\xA0\x82\x01\x90P`\x01`\x01`\xA0\x1B\x03\x80\x84Q\x16\x83R\x80` \x85\x01Q\x16` \x84\x01R\x80`@\x85\x01Q\x16`@\x84\x01RP``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x03\x81\x10a@\xA7W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x80`\x80\x84\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a@\xC4W_\x80\xFD[PQ\x91\x90PV[_\x80\x85\x85\x11\x15a@\xD9W_\x80\xFD[\x83\x86\x11\x15a@\xE5W_\x80\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aA\x05W_\x80\xFD[\x845aA\x10\x81a6:V[\x93P` \x85\x015aA \x81a6:V[\x92P`@\x85\x015\x91P``\x85\x015aA7\x81a8\xF4V[\x93\x96\x92\x95P\x90\x93PPV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aAUW_\x80\xFD[\x845aA`\x81a6:V[\x93P` \x85\x015aAp\x81a6:V[\x92P`@\x85\x015aA\x80\x81a6:V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_\x80_\x80_\x80_`\xE0\x88\x8A\x03\x12\x15aA\xA6W_\x80\xFD[\x875aA\xB1\x81a6:V[\x96P` \x88\x015aA\xC1\x81a6:V[\x95P`@\x88\x015aA\xD1\x81a6:V[\x94P``\x88\x015aA\xE1\x81a6:V[\x93P`\x80\x88\x015\x92P`\xA0\x88\x015aA\xF8\x81a6:V[\x80\x92PP`\xC0\x88\x015\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[_\x80_``\x84\x86\x03\x12\x15aB!W_\x80\xFD[\x835aB,\x81a6:V[\x92P` \x84\x015aB<\x81a6:V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15aBaW_\x80\xFD[\x855aBl\x81a6:V[\x94P` \x86\x015aB|\x81a6:V[\x93P`@\x86\x015aB\x8C\x81a6:V[\x92P``\x86\x015\x91P`\x80\x86\x015aB\xA3\x81a8\xF4V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_`\xFF\x83\x16\x80aB\xE8W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x9B\xE5\x8A\xCA\xDA50a\xA2\xA2\x02\xCCp\x11\xF3\xC9\x13\x93\xE0\xF2\xE3\x05\xE9 $E\xB0B\xFCJL\xE6dsolcC\0\x08\x17\x003",
-    );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ECDSAInvalidSignature()` and selector `0xf645eedf`.
-    ```solidity
-    error ECDSAInvalidSignature();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ECDSAInvalidSignature;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ECDSAInvalidSignature> for UnderlyingRustTuple<'_> {
-            fn from(value: ECDSAInvalidSignature) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for ECDSAInvalidSignature {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [246u8, 69u8, 238u8, 223u8];
-            const SIGNATURE: &'static str = "ECDSAInvalidSignature()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ECDSAInvalidSignatureLength(uint256)` and selector `0xfce698f7`.
-    ```solidity
-    error ECDSAInvalidSignatureLength(uint256 length);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ECDSAInvalidSignatureLength {
-        #[allow(missing_docs)]
-        pub length: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ECDSAInvalidSignatureLength> for UnderlyingRustTuple<'_> {
-            fn from(value: ECDSAInvalidSignatureLength) -> Self {
-                (value.length,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignatureLength {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { length: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for ECDSAInvalidSignatureLength {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [252u8, 230u8, 152u8, 247u8];
-            const SIGNATURE: &'static str = "ECDSAInvalidSignatureLength(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.length,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ECDSAInvalidSignatureS(bytes32)` and selector `0xd78bce0c`.
-    ```solidity
-    error ECDSAInvalidSignatureS(bytes32 s);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ECDSAInvalidSignatureS {
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ECDSAInvalidSignatureS> for UnderlyingRustTuple<'_> {
-            fn from(value: ECDSAInvalidSignatureS) -> Self {
-                (value.s,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignatureS {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { s: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for ECDSAInvalidSignatureS {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [215u8, 139u8, 206u8, 12u8];
-            const SIGNATURE: &'static str = "ECDSAInvalidSignatureS(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidAmount()` and selector `0x2c5211c6`.
-    ```solidity
-    error InvalidAmount();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidAmount;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidAmount> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidAmount) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAmount {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidAmount {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [44u8, 82u8, 17u8, 198u8];
-            const SIGNATURE: &'static str = "InvalidAmount()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidAsset()` and selector `0xc891add2`.
-    ```solidity
-    error InvalidAsset();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidAsset;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidAsset> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidAsset) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAsset {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidAsset {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [200u8, 145u8, 173u8, 210u8];
-            const SIGNATURE: &'static str = "InvalidAsset()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidBaseTokenAmounts()` and selector `0xc04377d3`.
-    ```solidity
-    error InvalidBaseTokenAmounts();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidBaseTokenAmounts;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidBaseTokenAmounts> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidBaseTokenAmounts) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidBaseTokenAmounts {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidBaseTokenAmounts {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [192u8, 67u8, 119u8, 211u8];
-            const SIGNATURE: &'static str = "InvalidBaseTokenAmounts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidDestination()` and selector `0xac6b05f5`.
-    ```solidity
-    error InvalidDestination();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidDestination;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidDestination> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidDestination) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidDestination {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidDestination {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [172u8, 107u8, 5u8, 245u8];
-            const SIGNATURE: &'static str = "InvalidDestination()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidEIP1271Signature()` and selector `0x5d52cbe3`.
-    ```solidity
-    error InvalidEIP1271Signature();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidEIP1271Signature;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidEIP1271Signature> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidEIP1271Signature) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEIP1271Signature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidEIP1271Signature {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [93u8, 82u8, 203u8, 227u8];
-            const SIGNATURE: &'static str = "InvalidEIP1271Signature()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidEIP712Signature()` and selector `0xb81d58e7`.
-    ```solidity
-    error InvalidEIP712Signature();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidEIP712Signature;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidEIP712Signature> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidEIP712Signature) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEIP712Signature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidEIP712Signature {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [184u8, 29u8, 88u8, 231u8];
-            const SIGNATURE: &'static str = "InvalidEIP712Signature()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidETHSignSignature()` and selector `0x644ae6c3`.
-    ```solidity
-    error InvalidETHSignSignature();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidETHSignSignature;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidETHSignSignature> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidETHSignSignature) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidETHSignSignature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidETHSignSignature {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [100u8, 74u8, 230u8, 195u8];
-            const SIGNATURE: &'static str = "InvalidETHSignSignature()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidFillAmount()` and selector `0x94697444`.
-    ```solidity
-    error InvalidFillAmount();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidFillAmount;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidFillAmount> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidFillAmount) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidFillAmount {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidFillAmount {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [148u8, 105u8, 116u8, 68u8];
-            const SIGNATURE: &'static str = "InvalidFillAmount()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
+    "name": "InvalidLendingPoolInteraction",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidQuoteTokenAmounts",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignatureType",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSigner",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSource",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NonceInvalid",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotMaker",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "NotSolver",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "OrderExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PartialFillNotSupported",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReceiverNotManager",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ReentrancyGuardReentrantCall",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SafeERC20FailedOperation",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "SignatureIsExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SignatureIsNotEmpty",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "UpdatedMakerAmountsTooLow",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "ZeroMakerAmount",
+    "inputs": []
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod LiquoriceSettlement {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01 `@R4\x80\x15b\0\0\x11W_\x80\xFD[P`@Qb\0N\xF68\x03\x80b\0N\xF6\x839\x81\x01`@\x81\x90Rb\0\x004\x91b\0\x01uV[F`\xA0\x81\x81R`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01R`\x80\x81\x01\x92\x90\x92R0\x90\x82\x01R`\xC0\x01`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90R\x80Q` \x90\x91\x01 `\x80R`\x01\x80U`\x01`\x01`\xA0\x1B\x03\x84\x16`\xC0R0\x90\x82\x90b\0\0\xFE\x90b\0\x01OV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15b\0\x01/W=_\x80>=_\xFD[P`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\xE0R\x91\x90\x91\x16a\x01\0RPb\0\x01\xC6\x90PV[a\tc\x80b\0E\x93\x839\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14b\0\x01rW_\x80\xFD[PV[_\x80_``\x84\x86\x03\x12\x15b\0\x01\x88W_\x80\xFD[\x83Qb\0\x01\x95\x81b\0\x01]V[` \x85\x01Q\x90\x93Pb\0\x01\xA8\x81b\0\x01]V[`@\x85\x01Q\x90\x92Pb\0\x01\xBB\x81b\0\x01]V[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0QaC-b\0\x02f_9_\x81\x81a\x02W\x01R\x81\x81a\x07\x84\x01Ra\x16\xDC\x01R_\x81\x81a\x01\x97\x01R\x81\x81a\x07\xBA\x01R\x81\x81a\x18\x8C\x01R\x81\x81a\x1E,\x01R\x81\x81a\x1F\x1E\x01R\x81\x81a ,\x01R\x81\x81a#\x0B\x01R\x81\x81a$'\x01Ra0<\x01R_\x81\x81a\x038\x01R\x81\x81a\x04\x12\x01R\x81\x81a\x06\xA7\x01R\x81\x81a\x15 \x01Ra\x15\xFF\x01R_a\x04\xDA\x01R_a\x05\xA4\x01RaC-_\xF3\xFE`\x80`@R`\x046\x10a\x01&W_5`\xE0\x1C\x80c\xA5\xCD\xC8\xFC\x11a\0\xA1W\x80c\xC6\x18a\x81\x11a\0qW\x80c\xDBXw(\x11a\0WW\x80c\xDBXw(\x14a\x03yW\x80c\xE2B\x92N\x14a\x03\x8CW\x80c\xFA\\\xD5l\x14a\x03\xABW_\x80\xFD[\x80c\xC6\x18a\x81\x14a\x03'W\x80c\xCB\xA6s\xA7\x14a\x03ZW_\x80\xFD[\x80c\xA5\xCD\xC8\xFC\x14a\x02\xABW\x80c\xA7\xABI\xBC\x14a\x02\xCAW\x80c\xAE\x80\xC5\x84\x14a\x02\xE9W\x80c\xB1\x1F\x12b\x14a\x03\x08W_\x80\xFD[\x80cQ\xD4h\x15\x11a\0\xF6W\x80co5\xD2\xD2\x11a\0\xDCW\x80co5\xD2\xD2\x14a\x02FW\x80c\x87U0\xFF\x14a\x02yW\x80c\x995\xC8h\x14a\x02\x98W_\x80\xFD[\x80cQ\xD4h\x15\x14a\x02\x12W\x80cZ\xA0\xE9]\x14a\x02'W_\x80\xFD[\x80c\x16&\xBA~\x14a\x011W\x80c)\xBC\xDC\x95\x14a\x01\x86W\x80c6D\xE5\x15\x14a\x01\xD1W\x80cL\x9E\x03\xD3\x14a\x01\xF3W_\x80\xFD[6a\x01-W\0[_\x80\xFD[4\x80\x15a\x01<W_\x80\xFD[Pa\x01Pa\x01K6`\x04a5\x95V[a\x03\xCAV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x91W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01}V[4\x80\x15a\x01\xDCW_\x80\xFD[Pa\x01\xE5a\x04\xD7V[`@Q\x90\x81R` \x01a\x01}V[4\x80\x15a\x01\xFEW_\x80\xFD[Pa\x01\xE5a\x02\r6`\x04a6 V[a\x05\xC6V[a\x02%a\x02 6`\x04a6\xD7V[a\x06gV[\0[4\x80\x15a\x022W_\x80\xFD[Pa\x02%a\x02A6`\x04a7\xE1V[a\t\xE8V[4\x80\x15a\x02QW_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x02\x84W_\x80\xFD[Pa\x01\xE5a\x02\x936`\x04a6 V[a\x0C0V[a\x02%a\x02\xA66`\x04a8?V[a\x0C_V[4\x80\x15a\x02\xB6W_\x80\xFD[Pa\x02%a\x02\xC56`\x04a8\xDDV[a\x0C\x7FV[4\x80\x15a\x02\xD5W_\x80\xFD[Pa\x02%a\x02\xE46`\x04a9\x01V[a\x0C\x8CV[4\x80\x15a\x02\xF4W_\x80\xFD[Pa\x02%a\x03\x036`\x04a9\x9DV[a\x10gV[4\x80\x15a\x03\x13W_\x80\xFD[Pa\x01\xE5a\x03\"6`\x04a9\xF2V[a\x12\xEBV[4\x80\x15a\x032W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x03eW_\x80\xFD[Pa\x02%a\x03t6`\x04a:$V[a\x14\xEAV[a\x02%a\x03\x876`\x04a;\x0BV[a\x18xV[4\x80\x15a\x03\x97W_\x80\xFD[Pa\x01\xE5a\x03\xA66`\x04a;\xC9V[a\x19LV[4\x80\x15a\x03\xB6W_\x80\xFD[Pa\x02%a\x03\xC56`\x04a;\xC9V[a\x1A\x8EV[_\x80a\x03\xD7\x85\x85\x85a\x1BPV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\x04\x83\x01R\x91\x92P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04YW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04}\x91\x90a;\xFBV[\x15a\x04\xABW\x7F\x16&\xBA~5oYy\xDD5Z=+\xFBC\xE8\x04 \xA4\x80\xC3\xB8T\xED\xCE(j\x82\xD7Ihi\x91PPa\x04\xD0V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14a\x05\xA1W`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[_\x7Fh\xB8\xE9M\xC0wE\x82A\xD6\xC8\xD8\x9F\nve\xC7\xCD\xA2\xCF\xE7\x0C\x9E\xB4C~\xFE\xE1f<f\xFEa\x05\xF5` \x84\x01\x84a<\x16V[\x83` \x015\x84`@\x015\x85``\x015\x86`\x80\x015`@Q` \x01a\x06J\x96\x95\x94\x93\x92\x91\x90\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16` \x86\x01R`@\x85\x01\x92\x90\x92R``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x06oa\x1B\xDBV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xECW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x10\x91\x90a;\xFBV[a\x07FW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x87\x015\x88\x15\x80\x15\x90a\x07`WPa\x01`\x88\x015\x89\x11\x15[\x15a\x07\x7FWa\x07|\x89a\x02\0\x8A\x015a\x01`\x8B\x015`\x01a\x1C\x1EV[\x90P[a\x07\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x83\x8B\x8B\x8B\x8B\x8B\x8Ba\x1CiV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x07\xEF`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x08\x01a\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Ra\x08D\x92\x91\x90a\x01`\x8E\x015\x90\x88\x90`\x04\x01a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08[W_\x80\xFD[PZ\xF1\x15\x80\x15a\x08mW=_\x80>=_\xFD[PPPPa\x08\xB4\x88\x8B\x83\x8C_\x14\x80a\x08\x89WPa\x01`\x8C\x015\x8D\x11[a\x08\x93W\x8Ca\x08\x9AV[a\x01`\x8C\x015[\x89\x8C\x8C`\x02a\x08\xAF`@\x8E\x01` \x8F\x01a=aV[a\x1E\x01V[a\x08\xC1`@\x89\x01\x89a=\x7FV[`@Qa\x08\xCF\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\t\t`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a\t\x19`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[a\t+a\x01@\x8D\x01a\x01 \x8E\x01a<\x16V[a\t=a\x01\xE0\x8E\x01a\x01\xC0\x8F\x01a<\x16V[\x8E\x15\x80a\tNWPa\x01`\x8E\x015\x8F\x11[a\tXW\x8Ea\t_V[a\x01@\x8E\x015[a\x02\0\x8F\x015\x88\x14a\tqW\x87a\txV[a\x01\xE0\x8F\x015[\x8F`\xE0\x01` \x81\x01\x90a\t\x8B\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\t\xDD`\x01\x80UV[PPPPPPPPPV[_[a\t\xF4\x82\x80a=\xEFV[\x90P\x81\x10\x15a\x0B\x06W6a\n\x08\x83\x80a=\xEFV[\x83\x81\x81\x10a\n\x18Wa\n\x18a>SV[\x90P` \x02\x81\x01\x90a\n*\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\nH` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xA2W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xC6\x91\x90a;\xFBV[\x15a\n\xFDW`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\t\xEAV[P_[a\x0B\x16` \x83\x01\x83a=\xEFV[\x90P\x81\x10\x15a\x0C+W6a\x0B-` \x84\x01\x84a=\xEFV[\x83\x81\x81\x10a\x0B=Wa\x0B=a>SV[\x90P` \x02\x81\x01\x90a\x0BO\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\x0Bm` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xC7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xEB\x91\x90a;\xFBV[\x15a\x0C\"W`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x0B\tV[PPPV[_\x7F\xAEgk\xF6\x91:\xC2h\x9Bs1)<\x98\x9F\xE7r1$\xFA\xF8\xB5\xD2u\xF0o\xBC\xEB\xC7yP\ta\x05\xF5` \x84\x01\x84a<\x16V[a\x0Ci\x84\x82a\"\x12V[a\x0Cx\x85\x85\x85\x85`\x01\x80a\"\xC9V[PPPPPV[a\x0C\x893\x82a&\x1EV[PV[a\x0C\xBF`@Q\x80`\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[_[\x82\x81\x10\x15a\x10SW6\x84\x84\x83\x81\x81\x10a\x0C\xDCWa\x0C\xDCa>SV[\x90P` \x02\x81\x01\x90a\x0C\xEE\x91\x90a>\x80V[\x90P6_a\x0C\xFF`@\x84\x01\x84a=\x7FV[\x90\x92P\x90P`\x01`\x01`\xA0\x1B\x03\x8B\x16c\xA8\xC4\xBC\x95a\r ` \x86\x01\x86a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\rzW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x9E\x91\x90a;\xFBV[\x15a\x10EW_\x89\x15a\r\xDCW`@Q\x7F}a{\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04\x82\x10a\r\xE8WP\x815[\x7F\xC0:\x9D\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0EVWa\x0E=\x83\x83\x8D\x8Ca&\xC4V[\x86` \x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x90RPa\x10CV[\x7F$:K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0E\xBCWa\x0E\xAB\x83\x83\x8D\x8Ca'\xDAV[\x86``\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x7F}\xC4\xF4X\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0FGWa\x0F\x11\x83\x83\x8D\x8Ca)NV[`\xA0\x88\x01R`\x80\x87\x01\x81\x90R``\x87\x01\x80Qa\x0F.\x90\x83\x90a>\xBCV[\x90RP`\xA0\x86\x01Q` \x87\x01\x80Qa\x0EN\x90\x83\x90a>\xBCV[\x7Fh\x93\x1Bk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0F\xABWa\x0F\x9C\x83\x83\x8D\x8Ca+\xB6V[\x86Q\x87\x90a\x0EN\x90\x83\x90a>\xBCV[\x7F\x0C\x9B\xE7\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x10\x11Wa\x10\0\x83\x83\x8D\x8Ca,\xC0V[\x86`@\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[`@Q\x7F\x05a\xD8\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPP\x80`\x01\x01\x90Pa\x0C\xC1V[Pa\x10^\x84\x82a.)V[PPPPPPPV[`\x03a\x10v` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x10\x87Wa\x10\x87a>\xF4V[\x03a\x10\xECW`\x01`\x01`\xA0\x1B\x03\x83\x16a\x10\xAC\x83a\x10\xA7`@\x85\x01\x85a=\x7FV[a\x1BPV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0C+W`@Q\x7F\xB8\x1DX\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01a\x10\xFB` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\x0CWa\x11\x0Ca>\xF4V[\x03a\x11\xA0W\x7F\x19Ethereum Signed Message:\n32\0\0\0\0_\x90\x81R`\x1C\x83\x90R`<\x90 `\x01`\x01`\xA0\x1B\x03\x84\x16a\x11Z\x82a\x10\xA7`@\x86\x01\x86a=\x7FV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x11\x9AW`@Q\x7FdJ\xE6\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\x02a\x11\xAF` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\xC0Wa\x11\xC0a>\xF4V[\x03a\x12\xB9W\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x84\x16c\x16&\xBA~\x84a\x12\x03`@\x86\x01\x86a=\x7FV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12!\x93\x92\x91\x90a??V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12<W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12`\x91\x90a?XV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x0C+W`@Q\x7F]R\xCB\xE3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F`\xCD@-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xF4a\x04\xD7V[\x7F\xD2\x8E\x80\x9Bp\x8F^\xE3\x8B\xE84}m\x86\x9D\x822I<\tJ\xB2\xDD\xE9\x83i\xE4\x10#i\xA9\x9Da\x13\x1F\x84\x80a=\x7FV[`@Q` \x01a\x130\x92\x91\x90a?\x97V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x84` \x015\x85`@\x01` \x81\x01\x90a\x13^\x91\x90a<\x16V[`@\x80Q` \x81\x01\x95\x90\x95R\x84\x01\x92\x90\x92R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90Ra\x13\xC4`\x80\x85\x01``\x86\x01a<\x16V[a\x13\xD4`\xA0\x86\x01`\x80\x87\x01a<\x16V[a\x13\xE4`\xC0\x87\x01`\xA0\x88\x01a<\x16V[`\xC0\x87\x015`\xE0\x88\x015a\x01\0\x89\x015a\x01 \x8A\x015a\x14\x0Ca\x01`\x8C\x01a\x01@\x8D\x01a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x99\x8A\x16` \x82\x01R\x97\x89\x16\x90\x88\x01R\x94\x87\x16``\x87\x01R`\x80\x86\x01\x93\x90\x93R`\xA0\x85\x01\x91\x90\x91R`\xC0\x84\x01R`\xE0\x83\x01R\x90\x91\x16a\x01\0\x82\x01Ra\x01 \x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x14\x92\x92\x91` \x01a?\xD7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\x06J\x92\x91\x90\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[a\x14\xF2a\x1B\xDBV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15mW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x91\x91\x90a;\xFBV[a\x15\xC7W`@Q\x7F\xC19\xEA\xBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16DW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16h\x91\x90a;\xFBV[a\x16\x9EW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x86\x015\x87\x15\x80\x15\x90a\x16\xB8WPa\x01`\x87\x015\x88\x11\x15[\x15a\x16\xD7Wa\x16\xD4\x88a\x02\0\x89\x015a\x01`\x8A\x015`\x01a\x1C\x1EV[\x90P[a\x17\x08\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x83\x8A\x8A\x8A\x8A\x8A\x8Aa\x1CiV[a\x17E\x87\x8A\x83\x8B\x15\x80a\x17\x1FWPa\x01`\x8B\x015\x8C\x11[a\x17)W\x8Ba\x170V[a\x01`\x8B\x015[\x88\x8B\x8B`\x01a\x08\xAF`@\x8D\x01` \x8E\x01a=aV[a\x17R`@\x88\x01\x88a=\x7FV[`@Qa\x17`\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\x17\x9A`\xA0\x8A\x01`\x80\x8B\x01a<\x16V[a\x17\xAA`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x17\xBCa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[a\x17\xCEa\x01\xE0\x8D\x01a\x01\xC0\x8E\x01a<\x16V[\x8D\x15\x80a\x17\xDFWPa\x01`\x8D\x015\x8E\x11[a\x17\xE9W\x8Da\x17\xF0V[a\x01@\x8D\x015[a\x02\0\x8E\x015\x88\x14a\x18\x02W\x87a\x18\tV[a\x01\xE0\x8E\x015[\x8E`\xE0\x01` \x81\x01\x90a\x18\x1C\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\x18n`\x01\x80UV[PPPPPPPPV[a\x18\x82\x85\x83a\"\x12V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x18\xC1`\x80\x88\x01``\x89\x01a<\x16V[a\x18\xD1`\xA0\x89\x01`\x80\x8A\x01a<\x16V[\x88`\xC0\x015\x85`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x18\xF6\x94\x93\x92\x91\x90a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x19\rW_\x80\xFD[PZ\xF1\x15\x80\x15a\x19\x1FW=_\x80>=_\xFD[PPPPa\x19D\x86\x86\x86\x86`\x02\x89` \x01` \x81\x01\x90a\x19?\x91\x90a=aV[a\"\xC9V[PPPPPPV[_a\x19Ua\x04\xD7V[\x7F\xC9\x94\xD2\xCA\x03u\xD6\xD4sx^\x0C\xE0\xB1\xD2\x03\xF0i\x12\x1B\xAC\x13\x14\xF7,\\\x0F\xE6\x01\xEB9\x10a\x19\x83`@\x85\x01\x85a=\x7FV[`@Q` \x01a\x19\x94\x92\x91\x90a?\x97V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 ``\x85\x015a\x19\xDF`\xA0\x87\x01`\x80\x88\x01a<\x16V[a\x19\xEF`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\xC0\x88\x015a\x1A\x05a\x01\0\x8A\x01`\xE0\x8B\x01a<\x16V[`@\x80Q` \x81\x01\x98\x90\x98R\x87\x01\x95\x90\x95R``\x86\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80\x86\x01R\x81\x16`\xA0\x85\x01R`\xC0\x84\x01\x91\x90\x91R\x16`\xE0\x82\x01Ra\x01\0\x80\x85\x015\x90\x82\x01Ra\x01 \x01`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1Ao\x84a\x01 \x01a\x0C0V[a\x1A|\x85a\x01\xC0\x01a\x05\xC6V[`@Q` \x01a\x14\x92\x93\x92\x91\x90a?\xEBV[a\x01\xA0\x81\x015a\x1A\xA8a\x01\x80\x83\x015a\x01`\x84\x015a>\xBCV[a\x1A\xB2\x91\x90a>\xBCV[a\x01@\x82\x015\x14a\x1A\xEFW`@Q\x7F\xC0Cw\xD3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x81\x015a\x1B\ta\x02 \x83\x015a\x02\0\x84\x015a>\xBCV[a\x1B\x13\x91\x90a>\xBCV[a\x01\xE0\x82\x015\x14a\x0C\x89W`@Q\x7F\x87v0\xBE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x91\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa.\xD6\x92PPPV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1B\xD3W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x94\x93PPPPV[`\x02`\x01T\x03a\x1C\x17W`@Q\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01UV[_a\x1CKa\x1C+\x83a/\0V[\x80\x15a\x1CFWP_\x84\x80a\x1CAWa\x1CAa@\x08V[\x86\x88\t\x11[\x15\x15\x90V[a\x1CV\x86\x86\x86a/,V[a\x1C`\x91\x90a>\xBCV[\x95\x94PPPPPV[_a\x1Cs\x87a\x19LV[\x90Pa\x1C\x80\x89\x82\x85a\x10gV[a\x1C\x90`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1C\xC7Wa\x1C\xC2a\x1C\xBB`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x82\x84a\x10gV[a\x1D\x0EV[a\x1C\xD4`@\x83\x01\x83a=\x7FV[\x90P_\x03a\x1D\x0EW`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D+a\x1D!`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x88``\x015a&\x1EV[\x86`\xC0\x015B\x11\x15a\x1DiW`@Q\x7F\x13=\xF0)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x88\x11\x80\x15a\x1D|WP\x86a\x01\0\x015\x88\x10[\x15a\x1D\xB3W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\xBC\x87a\x1A\x8EV[a\x1D\xC6\x8A\x85a\t\xE8V[a\x1D\xE7\x8A\x8A_\x8B\x11\x80\x15a\x1D\xDFWPa\x02\0\x8A\x015\x8B\x14\x15[\x8A\x8A\x8Aa\x0C\x8CV[a\x1D\xF5\x89\x88``\x015a&\x1EV[PPPPPPPPPPV[a\x1E\x13a\x1E\x0E\x86\x80a=\xEFV[a0\x01V[_a\x1E(a\x01\x80\x8B\x015a\x01\xA0\x8C\x015a>\xBCV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Ew\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x010`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1E\xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x86`\x02\x81\x11\x15a\x1E\xD0Wa\x1E\xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1F\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a\x1F\x18W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Fi\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\xE0\x01` \x81\x01\x90a\x1F\x8A\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1F\xAE\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A\x81R` \x01\x86`\x02\x81\x11\x15a\x1F\xD4Wa\x1F\xD4a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F\xF3\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a \nW_\x80\xFD[PZ\xF1\x15\x80\x15a \x1CW=_\x80>=_\xFD[PPPPa *\x85\x85a0\x01V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8C`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\x80\x01` \x81\x01\x90a \x86\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01\xC0\x01_\x01` \x81\x01\x90a \xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8B\x81R` \x01\x85`\x02\x81\x11\x15a \xD0Wa \xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a!\x18W=_\x80>=_\xFD[Pa!.\x92Pa\x1E\x0E\x91PP` \x88\x01\x88a=\xEFV[_a!Aa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!\x9EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\xC2\x91\x90a@\xB4V[\x90P\x80\x15a\"\x05Wa\"\x05a!\xDEa\x01\0\x8D\x01`\xE0\x8E\x01a<\x16V[\x82\x8Da\x01 \x01_\x01` \x81\x01\x90a!\xF5\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a19V[PPPPPPPPPPPV[a\"\"`\x80\x83\x01``\x84\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\"aWa\"\\a\"M`\x80\x84\x01``\x85\x01a<\x16V[a\"V\x84a\x12\xEBV[\x83a\x10gV[a\"\xA8V[a\"n`@\x82\x01\x82a=\x7FV[\x90P_\x03a\"\xA8W`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\"\xC5a\"\xBB`\x80\x84\x01``\x85\x01a<\x16V[\x83` \x015a&\x1EV[PPV[`\xE0\x85\x015\x83\x15\x80\x15\x90a\"\xE0WP\x85`\xC0\x015\x84\x10[\x15a\"\xFDWa\"\xFA\x84\x87`\xE0\x015\x88`\xC0\x015`\x01a\x1C\x1EV[\x90P[a#\t\x87\x82\x88\x88a1\xB9V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x89``\x01` \x81\x01\x90a#V\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#va\x01`\x8B\x01a\x01@\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#\x94`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x87\x15\x80a#\xB2WP\x89`\xC0\x015\x88\x11[a#\xBCW\x87a#\xC2V[\x89`\xC0\x015[\x81R` \x01\x86`\x02\x81\x11\x15a#\xD9Wa#\xD9a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\xF8\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\x0FW_\x80\xFD[PZ\xF1\x15\x80\x15a$!W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`@\x01` \x81\x01\x90a$\x81\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a$\x9F`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x02\x81\x11\x15a$\xC5Wa$\xC5a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a$\xE4\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\xFBW_\x80\xFD[PZ\xF1\x15\x80\x15a%\rW=_\x80>=_\xFD[Pa%\x1E\x92P\x88\x91P\x81\x90Pa=\x7FV[`@Qa%,\x92\x91\x90a=\xE0V[`@Q\x80\x91\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6\x87`@\x01` \x81\x01\x90a%h\x91\x90a<\x16V[a%x`\x80\x8A\x01``\x8B\x01a<\x16V[a%\x88`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a%\x98`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[\x89\x15\x80a%\xA8WP\x8B`\xC0\x015\x8A\x11[a%\xB2W\x89a%\xB8V[\x8B`\xC0\x015[\x87\x8Da\x01@\x01` \x81\x01\x90a%\xCD\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x84\x84R\x90\x91R\x90 T`\xFF\x16\x15a&yW`@Q\x7F\xBC\r\xA7\xD6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x83R\x92\x90R \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16`\x01\x17\x90UV[_\x80\x80\x80a&\xD5\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a&\xE2\x91\x90a@\xF2V[P\x91\x94P\x92P\x90Pa&\xFCa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a'FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a'\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x97\x96PPPPPPPV[_\x80\x80\x80\x80a'\xEC\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a'\xF9\x91\x90aABV[\x92\x96P\x90\x94P\x92P\x90Pa(\x15a\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a(_W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a(\xAAW`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a(\xBA`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a)\x04W`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x98\x97PPPPPPPPV[_\x80_\x80_\x80_\x80_\x8C\x8C`\x04\x90\x80\x92a)j\x93\x92\x91\x90a@\xCBV[\x81\x01\x90a)w\x91\x90aA\x90V[\x95\x9CP\x93\x9AP\x91\x98P\x96P\x94P\x92P\x90Pa)\x9Aa\x01\xE0\x8B\x01a\x01\xC0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a)\xE4W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85`\x01`\x01`\xA0\x1B\x03\x16\x8B`\x01`\x01`\xA0\x1B\x03\x16\x14a*/W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x160\x14a*qW`@Q\x7F\x81T7K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x81`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a*\xCBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x8A\x015\x83\x14a+\tW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+\x1Ba\x01@\x8B\x01a\x01 \x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a+eW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x8A\x015\x81\x14a+\xA3W`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x9C\x91\x9BP\x90\x99PPPPPPPPPPV[_\x80\x80\x80a+\xC7\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a+\xD4\x91\x90aB\x0FV[\x91\x94P\x92P\x90Pa+\xEDa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a,7W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a,\x82W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\x80\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80\x80\x80a,\xD2\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a,\xDF\x91\x90aBMV[P\x92\x96P\x90\x94P\x92P\x90Pa,\xFCa\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a-FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a-\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a-\xA1`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a-\xEBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02 \x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01\x80\x83\x015\x14\x15\x80a.GWP` \x81\x01Qa\x01\xA0\x83\x015\x14\x15[\x15a.~W`@Q\x7FJU\xDA \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x81\x01Qa\x02 \x83\x015\x14\x15\x80a.\x9FWP``\x81\x01Qa\x02@\x83\x015\x14\x15[\x15a\"\xC5W`@Q\x7Fw\xA5\x92\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x80a.\xE4\x86\x86a2\\V[\x92P\x92P\x92Pa.\xF4\x82\x82a2\xA5V[P\x90\x91PP[\x92\x91PPV[_`\x02\x82`\x03\x81\x11\x15a/\x15Wa/\x15a>\xF4V[a/\x1F\x91\x90aB\xB1V[`\xFF\x16`\x01\x14\x90P\x91\x90PV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a/\x7FW\x83\x82\x81a/uWa/ua@\x08V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a/\x96Wa/\x96`\x03\x85\x15\x02`\x11\x18a3\xADV[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP\x93\x92PPPV[_[\x81\x81\x10\x15a\x0C+W6\x83\x83\x83\x81\x81\x10a0\x1EWa0\x1Ea>SV[\x90P` \x02\x81\x01\x90a00\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a0i` \x83\x01\x83a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x03a0\xA9W`@Q\x7Fy\xA1\xBF\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a0\xB2\x81a3\xBEV[a0\xBF` \x82\x01\x82a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a0\xF7\x84a4\x01V[`@\x80Q\x92\x83R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA2P`\x01\x01a0\x03V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C+\x90\x84\x90a4*V[_\x83\x11\x80\x15a1\xCCWP\x81a\x01\0\x015\x83\x10[\x15a2\x03W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2\x10\x84a\"V\x84a\x12\xEBV[a2\x1E\x84\x83` \x015a&\x1EV[B\x82a\x01 \x015\x11a\x11\x9AW`@Q\x7F\xC5hs\xBA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x83Q`A\x03a2\x93W` \x84\x01Q`@\x85\x01Q``\x86\x01Q_\x1Aa2\x85\x88\x82\x85\x85a4\xAFV[\x95P\x95P\x95PPPPa2\x9EV[PP\x81Q_\x91P`\x02\x90[\x92P\x92P\x92V[_\x82`\x03\x81\x11\x15a2\xB8Wa2\xB8a>\xF4V[\x03a2\xC1WPPV[`\x01\x82`\x03\x81\x11\x15a2\xD5Wa2\xD5a>\xF4V[\x03a3\x0CW`@Q\x7F\xF6E\xEE\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x82`\x03\x81\x11\x15a3 Wa3 a>\xF4V[\x03a3_W`@Q\x7F\xFC\xE6\x98\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x03\x82`\x03\x81\x11\x15a3sWa3sa>\xF4V[\x03a\"\xC5W`@Q\x7F\xD7\x8B\xCE\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01a3VV[cNH{q_R\x80` R`$`\x1C\xFD[_a3\xCC` \x83\x01\x83a<\x16V[\x90P` \x82\x0156_a3\xE2`@\x86\x01\x86a=\x7FV[\x91P\x91P`@Q\x81\x83\x827_\x80\x83\x83\x87\x89Z\xF1a\x19DW=_\x80>=_\xFD[_6\x81a4\x11`@\x85\x01\x85a=\x7FV[\x90\x92P\x90P`\x04\x81\x10a4#W\x815\x92P[PP\x91\x90PV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a4IW`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a4`W\x80`\x01\x14\x15a4mV[`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x11\x9AW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a3VV[_\x80\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x84\x11\x15a4\xE8WP_\x91P`\x03\x90P\x82a5\x8BV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x8A\x90R`\xFF\x89\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x87\x90R`\x80\x81\x01\x86\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a59W=_\x80>=_\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a5\x82WP_\x92P`\x01\x91P\x82\x90Pa5\x8BV[\x92P_\x91P\x81\x90P[\x94P\x94P\x94\x91PPV[_\x80_`@\x84\x86\x03\x12\x15a5\xA7W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a5\xC5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a5\xD8W_\x80\xFD[\x815\x81\x81\x11\x15a5\xE6W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a5\xF7W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[_`\xA0\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[P\x91\x90PV[_`\xA0\x82\x84\x03\x12\x15a60W_\x80\xFD[a\x04\xD0\x83\x83a6\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x89W_\x80\xFD[\x805a6Y\x81a6:V[\x91\x90PV[_a\x02`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80\x83`\x1F\x84\x01\x12a6\x7FW_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x96W_\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a6\xB0W_\x80\xFD[\x92P\x92\x90PV[_`@\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_``\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a6\xF0W_\x80\xFD[a6\xF9\x8Aa6NV[\x98P` \x8A\x015\x97P`@\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a7\x1CW_\x80\xFD[a7(\x8D\x83\x8E\x01a6^V[\x98P``\x8C\x015\x91P\x80\x82\x11\x15a7=W_\x80\xFD[a7I\x8D\x83\x8E\x01a6oV[\x90\x98P\x96P`\x80\x8C\x015\x91P\x80\x82\x11\x15a7aW_\x80\xFD[a7m\x8D\x83\x8E\x01a6\xB7V[\x95P`\xA0\x8C\x015\x91P\x80\x82\x11\x15a7\x82W_\x80\xFD[a7\x8E\x8D\x83\x8E\x01a6\xC7V[\x94P`\xC0\x8C\x015\x91P\x80\x82\x11\x15a7\xA3W_\x80\xFD[a7\xAF\x8D\x83\x8E\x01a6\xC7V[\x93P`\xE0\x8C\x015\x91P\x80\x82\x11\x15a7\xC4W_\x80\xFD[Pa7\xD1\x8C\x82\x8D\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[_\x80`@\x83\x85\x03\x12\x15a7\xF2W_\x80\xFD[\x825a7\xFD\x81a6:V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x18W_\x80\xFD[a8$\x85\x82\x86\x01a6\xB7V[\x91PP\x92P\x92\x90PV[_a\x01`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15a8SW_\x80\xFD[\x855a8^\x81a6:V[\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a8zW_\x80\xFD[a8\x86\x89\x83\x8A\x01a8.V[\x95P`@\x88\x015\x91P\x80\x82\x11\x15a8\x9BW_\x80\xFD[a8\xA7\x89\x83\x8A\x01a6\xC7V[\x94P``\x88\x015\x93P`\x80\x88\x015\x91P\x80\x82\x11\x15a8\xC3W_\x80\xFD[Pa8\xD0\x88\x82\x89\x01a6\xC7V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_` \x82\x84\x03\x12\x15a8\xEDW_\x80\xFD[P5\x91\x90PV[\x80\x15\x15\x81\x14a\x0C\x89W_\x80\xFD[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a9\x16W_\x80\xFD[\x865a9!\x81a6:V[\x95P` \x87\x015a91\x81a6:V[\x94P`@\x87\x015a9A\x81a8\xF4V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a9]W_\x80\xFD[a9i\x8A\x83\x8B\x01a6^V[\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a9~W_\x80\xFD[Pa9\x8B\x89\x82\x8A\x01a6oV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a9\xAFW_\x80\xFD[\x835a9\xBA\x81a6:V[\x92P` \x84\x015\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9\xDCW_\x80\xFD[a9\xE8\x86\x82\x87\x01a6\xC7V[\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a:\x02W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a:\x18W_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a8.V[_\x80_\x80_\x80_\x80`\xE0\x89\x8B\x03\x12\x15a:;W_\x80\xFD[a:D\x89a6NV[\x97P` \x89\x015\x96P`@\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a:gW_\x80\xFD[a:s\x8C\x83\x8D\x01a6^V[\x97P``\x8B\x015\x91P\x80\x82\x11\x15a:\x88W_\x80\xFD[a:\x94\x8C\x83\x8D\x01a6oV[\x90\x97P\x95P`\x80\x8B\x015\x91P\x80\x82\x11\x15a:\xACW_\x80\xFD[a:\xB8\x8C\x83\x8D\x01a6\xB7V[\x94P`\xA0\x8B\x015\x91P\x80\x82\x11\x15a:\xCDW_\x80\xFD[a:\xD9\x8C\x83\x8D\x01a6\xC7V[\x93P`\xC0\x8B\x015\x91P\x80\x82\x11\x15a:\xEEW_\x80\xFD[Pa:\xFB\x8B\x82\x8C\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[_\x80_\x80_\x80`\xC0\x87\x89\x03\x12\x15a; W_\x80\xFD[a;)\x87a6NV[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a;EW_\x80\xFD[a;Q\x8A\x83\x8B\x01a8.V[\x96P`@\x89\x015\x91P\x80\x82\x11\x15a;fW_\x80\xFD[a;r\x8A\x83\x8B\x01a6\xC7V[\x95P``\x89\x015\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a;\x8EW_\x80\xFD[a;\x9A\x8A\x83\x8B\x01a6\xC7V[\x93P`\xA0\x89\x015\x91P\x80\x82\x11\x15a;\xAFW_\x80\xFD[Pa;\xBC\x89\x82\x8A\x01a6\xC7V[\x91PP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a;\xD9W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a;\xEFW_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a6^V[_` \x82\x84\x03\x12\x15a<\x0BW_\x80\xFD[\x81Qa\x04\xD0\x81a8\xF4V[_` \x82\x84\x03\x12\x15a<&W_\x80\xFD[\x815a\x04\xD0\x81a6:V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[\x805e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a6YW_\x80\xFD[_`\x01`\x01`\xA0\x1B\x03\x80\x87\x16\x83R\x80\x86\x16` \x84\x01RP\x83`@\x83\x01R`\x80``\x83\x01R\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a<\xE2W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a<\xFEW_\x80\xFD[\x806\x03\x82\x13\x15a=\x0CW_\x80\xFD[```\x80\x85\x01Ra=!`\xE0\x85\x01\x82\x84a<1V[\x91PPa=0` \x85\x01a<xV[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16`\xA0\x86\x01R\x80a=L`@\x88\x01a<xV[\x16`\xC0\x86\x01RPP\x80\x91PP\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a=qW_\x80\xFD[\x815`\x03\x81\x10a\x04\xD0W_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xB2W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xCCW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a>\"W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a><W_\x80\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a>\xB2W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a.\xFAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a?1W_\x80\xFD[\x815`\x04\x81\x10a\x04\xD0W_\x80\xFD[\x83\x81R`@` \x82\x01R_a\x1C``@\x83\x01\x84\x86a<1V[_` \x82\x84\x03\x12\x15a?hW_\x80\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x04\xD0W_\x80\xFD[` \x81R_a\x1B\xD3` \x83\x01\x84\x86a<1V[_\x81Q_[\x81\x81\x10\x15a?\xC9W` \x81\x85\x01\x81\x01Q\x86\x83\x01R\x01a?\xAFV[P_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x1B\xD3a?\xE5\x83\x86a?\xAAV[\x84a?\xAAV[_a?\xF6\x82\x86a?\xAAV[\x93\x84RPP` \x82\x01R`@\x01\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_`\xA0\x82\x01\x90P`\x01`\x01`\xA0\x1B\x03\x80\x84Q\x16\x83R\x80` \x85\x01Q\x16` \x84\x01R\x80`@\x85\x01Q\x16`@\x84\x01RP``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x03\x81\x10a@\xA7W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x80`\x80\x84\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a@\xC4W_\x80\xFD[PQ\x91\x90PV[_\x80\x85\x85\x11\x15a@\xD9W_\x80\xFD[\x83\x86\x11\x15a@\xE5W_\x80\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aA\x05W_\x80\xFD[\x845aA\x10\x81a6:V[\x93P` \x85\x015aA \x81a6:V[\x92P`@\x85\x015\x91P``\x85\x015aA7\x81a8\xF4V[\x93\x96\x92\x95P\x90\x93PPV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aAUW_\x80\xFD[\x845aA`\x81a6:V[\x93P` \x85\x015aAp\x81a6:V[\x92P`@\x85\x015aA\x80\x81a6:V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_\x80_\x80_\x80_`\xE0\x88\x8A\x03\x12\x15aA\xA6W_\x80\xFD[\x875aA\xB1\x81a6:V[\x96P` \x88\x015aA\xC1\x81a6:V[\x95P`@\x88\x015aA\xD1\x81a6:V[\x94P``\x88\x015aA\xE1\x81a6:V[\x93P`\x80\x88\x015\x92P`\xA0\x88\x015aA\xF8\x81a6:V[\x80\x92PP`\xC0\x88\x015\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[_\x80_``\x84\x86\x03\x12\x15aB!W_\x80\xFD[\x835aB,\x81a6:V[\x92P` \x84\x015aB<\x81a6:V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15aBaW_\x80\xFD[\x855aBl\x81a6:V[\x94P` \x86\x015aB|\x81a6:V[\x93P`@\x86\x015aB\x8C\x81a6:V[\x92P``\x86\x015\x91P`\x80\x86\x015aB\xA3\x81a8\xF4V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_`\xFF\x83\x16\x80aB\xE8W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x9B\xE5\x8A\xCA\xDA50a\xA2\xA2\x02\xCCp\x11\xF3\xC9\x13\x93\xE0\xF2\xE3\x05\xE9 $E\xB0B\xFCJL\xE6dsolcC\0\x08\x17\x003`\xC0`@R4\x80\x15a\0\x0FW_\x80\xFD[P`@Qa\tc8\x03\x80a\tc\x839\x81\x01`@\x81\x90Ra\0.\x91a\0`V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x91V[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0[W_\x80\xFD[\x91\x90PV[_\x80`@\x83\x85\x03\x12\x15a\0qW_\x80\xFD[a\0z\x83a\0EV[\x91Pa\0\x88` \x84\x01a\0EV[\x90P\x92P\x92\x90PV[`\x80Q`\xA0Qa\x08\x9Ea\0\xC5_9_\x81\x81`H\x01R\x81\x81a\x01\xF2\x01Ra\x03\x81\x01R_\x81\x81`\xD3\x01Ra\x03'\x01Ra\x08\x9E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cj\xFD\xD8P\x14a\0CW\x80c\xB5\x19\xD3i\x14a\0\x93W\x80c\xBC\x11x\xE6\x14a\0\xA8W[_\x80\xFD[a\0j\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0\xA6a\0\xA16`\x04a\x06\nV[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\x06HV[a\x03\x0FV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81\x14a\x01+W`@Q\x7F|!O\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82\x015\x15a\x01\xAFW`\x01a\x01G`\xA0\x84\x01`\x80\x85\x01a\x06\xDDV[`\x02\x81\x11\x15a\x01XWa\x01Xa\x06\xB0V[\x03a\x01\xB3Wa\x01\xAFa\x01m` \x84\x01\x84a\x07\x02V[a\x01}`@\x85\x01` \x86\x01a\x07\x02V[``\x85\x01\x805\x90a\x01\x91\x90`@\x88\x01a\x07\x02V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92\x91\x90a\x04\xCCV[PPV[`\x02a\x01\xC5`\xA0\x84\x01`\x80\x85\x01a\x06\xDDV[`\x02\x81\x11\x15a\x01\xD6Wa\x01\xD6a\x06\xB0V[\x03a\x02\xDDWs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c6\xC7\x85\x16a\x02$` \x85\x01\x85a\x07\x02V[a\x024`@\x86\x01` \x87\x01a\x07\x02V[``\x86\x01\x805\x90a\x02H\x90`@\x89\x01a\x07\x02V[`@Q`\xE0\x86\x90\x1B\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x94\x85\x16`\x04\x82\x01R\x92\x84\x16`$\x84\x01R\x90\x83\x16`D\x83\x01R\x90\x91\x16`d\x82\x01R`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xC3W_\x80\xFD[PZ\xF1\x15\x80\x15a\x02\xD5W=_\x80>=_\xFD[PPPPPPV[`@Q\x7F\xC7\x9A\xAAD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x81\x14a\x03\x7FW`@Q\x7F|!O\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c+g\xB5p\x86`@Q\x80``\x01`@R\x80`@Q\x80`\x80\x01`@R\x80\x8As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x88`@\x01` \x81\x01\x90a\x04\x1D\x91\x90a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x88` \x01` \x81\x01\x90a\x04=\x91\x90a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90R\x81R0` \x82\x01R`@\x90\x81\x01\x90a\x04e\x90``\x89\x01\x90\x89\x01a\x07\x1BV[e\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90Ra\x04y\x86\x80a\x07@V[`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x98\x94\x93\x92\x91\x90a\x07\xA8V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xAFW_\x80\xFD[PZ\xF1\x15\x80\x15a\x04\xC1W=_\x80>=_\xFD[PPPPPPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x16`D\x82\x01R`d\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`\x84\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x05a\x90\x85\x90a\x05gV[PPPPV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a\x05\x86W`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a\x05\x9DW\x80`\x01\x14\x15a\x05\xB7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16;\x15[\x15a\x05aW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`\x04\x82\x01R`$\x01`@Q\x80\x91\x03\x90\xFD[_`\xA0\x82\x84\x03\x12\x15a\x06\x1AW_\x80\xFD[P\x91\x90PV[\x805s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06CW_\x80\xFD[\x91\x90PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15a\x06[W_\x80\xFD[a\x06d\x85a\x06 V[\x93Pa\x06r` \x86\x01a\x06 V[\x92P`@\x85\x015\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x94W_\x80\xFD[\x85\x01``\x81\x88\x03\x12\x15a\x06\xA5W_\x80\xFD[\x93\x96\x92\x95P\x90\x93PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x06\xEDW_\x80\xFD[\x815`\x03\x81\x10a\x06\xFBW_\x80\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x07\x12W_\x80\xFD[a\x06\xFB\x82a\x06 V[_` \x82\x84\x03\x12\x15a\x07+W_\x80\xFD[\x815e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x06\xFBW_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a\x07sW_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x07\x8DW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x07\xA1W_\x80\xFD[\x92P\x92\x90PV[_a\x01\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x88\x16\x84R\x86Q\x81\x81Q\x16` \x86\x01R\x81` \x82\x01Q\x16`@\x86\x01R`@\x81\x01Qe\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16``\x88\x01R\x80``\x84\x01Q\x16`\x80\x88\x01RPPP\x80` \x88\x01Q\x16`\xA0\x85\x01RP`@\x86\x01Q`\xC0\x84\x01R\x80`\xE0\x84\x01R\x83\x81\x84\x01RPa\x01 \x83\x85\x82\x85\x017_\x83\x85\x01\x82\x01R`\x1F\x90\x93\x01\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x16\x90\x91\x01\x90\x91\x01\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xF3V_e\x89P\x02v\xFC\xBBo\xB3=>\xE3\xB54\xD9Vl['2\xFE\x10\xA6\x03\x9Bu<:\x07dsolcC\0\x08\x17\x003",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\x80`@R`\x046\x10a\x01&W_5`\xE0\x1C\x80c\xA5\xCD\xC8\xFC\x11a\0\xA1W\x80c\xC6\x18a\x81\x11a\0qW\x80c\xDBXw(\x11a\0WW\x80c\xDBXw(\x14a\x03yW\x80c\xE2B\x92N\x14a\x03\x8CW\x80c\xFA\\\xD5l\x14a\x03\xABW_\x80\xFD[\x80c\xC6\x18a\x81\x14a\x03'W\x80c\xCB\xA6s\xA7\x14a\x03ZW_\x80\xFD[\x80c\xA5\xCD\xC8\xFC\x14a\x02\xABW\x80c\xA7\xABI\xBC\x14a\x02\xCAW\x80c\xAE\x80\xC5\x84\x14a\x02\xE9W\x80c\xB1\x1F\x12b\x14a\x03\x08W_\x80\xFD[\x80cQ\xD4h\x15\x11a\0\xF6W\x80co5\xD2\xD2\x11a\0\xDCW\x80co5\xD2\xD2\x14a\x02FW\x80c\x87U0\xFF\x14a\x02yW\x80c\x995\xC8h\x14a\x02\x98W_\x80\xFD[\x80cQ\xD4h\x15\x14a\x02\x12W\x80cZ\xA0\xE9]\x14a\x02'W_\x80\xFD[\x80c\x16&\xBA~\x14a\x011W\x80c)\xBC\xDC\x95\x14a\x01\x86W\x80c6D\xE5\x15\x14a\x01\xD1W\x80cL\x9E\x03\xD3\x14a\x01\xF3W_\x80\xFD[6a\x01-W\0[_\x80\xFD[4\x80\x15a\x01<W_\x80\xFD[Pa\x01Pa\x01K6`\x04a5\x95V[a\x03\xCAV[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x91W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01}V[4\x80\x15a\x01\xDCW_\x80\xFD[Pa\x01\xE5a\x04\xD7V[`@Q\x90\x81R` \x01a\x01}V[4\x80\x15a\x01\xFEW_\x80\xFD[Pa\x01\xE5a\x02\r6`\x04a6 V[a\x05\xC6V[a\x02%a\x02 6`\x04a6\xD7V[a\x06gV[\0[4\x80\x15a\x022W_\x80\xFD[Pa\x02%a\x02A6`\x04a7\xE1V[a\t\xE8V[4\x80\x15a\x02QW_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x02\x84W_\x80\xFD[Pa\x01\xE5a\x02\x936`\x04a6 V[a\x0C0V[a\x02%a\x02\xA66`\x04a8?V[a\x0C_V[4\x80\x15a\x02\xB6W_\x80\xFD[Pa\x02%a\x02\xC56`\x04a8\xDDV[a\x0C\x7FV[4\x80\x15a\x02\xD5W_\x80\xFD[Pa\x02%a\x02\xE46`\x04a9\x01V[a\x0C\x8CV[4\x80\x15a\x02\xF4W_\x80\xFD[Pa\x02%a\x03\x036`\x04a9\x9DV[a\x10gV[4\x80\x15a\x03\x13W_\x80\xFD[Pa\x01\xE5a\x03\"6`\x04a9\xF2V[a\x12\xEBV[4\x80\x15a\x032W_\x80\xFD[Pa\x01\xB9\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[4\x80\x15a\x03eW_\x80\xFD[Pa\x02%a\x03t6`\x04a:$V[a\x14\xEAV[a\x02%a\x03\x876`\x04a;\x0BV[a\x18xV[4\x80\x15a\x03\x97W_\x80\xFD[Pa\x01\xE5a\x03\xA66`\x04a;\xC9V[a\x19LV[4\x80\x15a\x03\xB6W_\x80\xFD[Pa\x02%a\x03\xC56`\x04a;\xC9V[a\x1A\x8EV[_\x80a\x03\xD7\x85\x85\x85a\x1BPV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x80\x83\x16`\x04\x83\x01R\x91\x92P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04YW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04}\x91\x90a;\xFBV[\x15a\x04\xABW\x7F\x16&\xBA~5oYy\xDD5Z=+\xFBC\xE8\x04 \xA4\x80\xC3\xB8T\xED\xCE(j\x82\xD7Ihi\x91PPa\x04\xD0V[P\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P[\x93\x92PPPV[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x14a\x05\xA1W`@\x80Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F` \x82\x01R\x7Fd\xAF\xEC{\xE6Q\xC9/\x86uK\xEB+\xD5\xEE\xAF/\xA9^\x83\xFA\xF4\xAE\xE9\x89\x87}\xDE\x08\xE4I\x8C\x91\x81\x01\x91\x90\x91R\x7F\xC8\x9E\xFD\xAAT\xC0\xF2\x0Cz\xDFa(\x82\xDF\tP\xF5\xA9Qc~\x03\x07\xCD\xCBLg/)\x8B\x8B\xC6``\x82\x01RF`\x80\x82\x01R0`\xA0\x82\x01R`\xC0\x01`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x90V[P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90V[_\x7Fh\xB8\xE9M\xC0wE\x82A\xD6\xC8\xD8\x9F\nve\xC7\xCD\xA2\xCF\xE7\x0C\x9E\xB4C~\xFE\xE1f<f\xFEa\x05\xF5` \x84\x01\x84a<\x16V[\x83` \x015\x84`@\x015\x85``\x015\x86`\x80\x015`@Q` \x01a\x06J\x96\x95\x94\x93\x92\x91\x90\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16` \x86\x01R`@\x85\x01\x92\x90\x92R``\x84\x01R`\x80\x83\x01R`\xA0\x82\x01R`\xC0\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x06oa\x1B\xDBV[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x8A\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xECW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x10\x91\x90a;\xFBV[a\x07FW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x87\x015\x88\x15\x80\x15\x90a\x07`WPa\x01`\x88\x015\x89\x11\x15[\x15a\x07\x7FWa\x07|\x89a\x02\0\x8A\x015a\x01`\x8B\x015`\x01a\x1C\x1EV[\x90P[a\x07\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x83\x8B\x8B\x8B\x8B\x8B\x8Ba\x1CiV[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x07\xEF`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x08\x01a\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x85\x90\x1B\x16\x81Ra\x08D\x92\x91\x90a\x01`\x8E\x015\x90\x88\x90`\x04\x01a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08[W_\x80\xFD[PZ\xF1\x15\x80\x15a\x08mW=_\x80>=_\xFD[PPPPa\x08\xB4\x88\x8B\x83\x8C_\x14\x80a\x08\x89WPa\x01`\x8C\x015\x8D\x11[a\x08\x93W\x8Ca\x08\x9AV[a\x01`\x8C\x015[\x89\x8C\x8C`\x02a\x08\xAF`@\x8E\x01` \x8F\x01a=aV[a\x1E\x01V[a\x08\xC1`@\x89\x01\x89a=\x7FV[`@Qa\x08\xCF\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\t\t`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a\t\x19`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[a\t+a\x01@\x8D\x01a\x01 \x8E\x01a<\x16V[a\t=a\x01\xE0\x8E\x01a\x01\xC0\x8F\x01a<\x16V[\x8E\x15\x80a\tNWPa\x01`\x8E\x015\x8F\x11[a\tXW\x8Ea\t_V[a\x01@\x8E\x015[a\x02\0\x8F\x015\x88\x14a\tqW\x87a\txV[a\x01\xE0\x8F\x015[\x8F`\xE0\x01` \x81\x01\x90a\t\x8B\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\t\xDD`\x01\x80UV[PPPPPPPPPV[_[a\t\xF4\x82\x80a=\xEFV[\x90P\x81\x10\x15a\x0B\x06W6a\n\x08\x83\x80a=\xEFV[\x83\x81\x81\x10a\n\x18Wa\n\x18a>SV[\x90P` \x02\x81\x01\x90a\n*\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\nH` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xA2W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xC6\x91\x90a;\xFBV[\x15a\n\xFDW`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\t\xEAV[P_[a\x0B\x16` \x83\x01\x83a=\xEFV[\x90P\x81\x10\x15a\x0C+W6a\x0B-` \x84\x01\x84a=\xEFV[\x83\x81\x81\x10a\x0B=Wa\x0B=a>SV[\x90P` \x02\x81\x01\x90a\x0BO\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x84\x16c\xA8\xC4\xBC\x95a\x0Bm` \x84\x01\x84a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xC7W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xEB\x91\x90a;\xFBV[\x15a\x0C\"W`@Q\x7F\xC9\x9E\x88r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P`\x01\x01a\x0B\tV[PPPV[_\x7F\xAEgk\xF6\x91:\xC2h\x9Bs1)<\x98\x9F\xE7r1$\xFA\xF8\xB5\xD2u\xF0o\xBC\xEB\xC7yP\ta\x05\xF5` \x84\x01\x84a<\x16V[a\x0Ci\x84\x82a\"\x12V[a\x0Cx\x85\x85\x85\x85`\x01\x80a\"\xC9V[PPPPPV[a\x0C\x893\x82a&\x1EV[PV[a\x0C\xBF`@Q\x80`\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[_[\x82\x81\x10\x15a\x10SW6\x84\x84\x83\x81\x81\x10a\x0C\xDCWa\x0C\xDCa>SV[\x90P` \x02\x81\x01\x90a\x0C\xEE\x91\x90a>\x80V[\x90P6_a\x0C\xFF`@\x84\x01\x84a=\x7FV[\x90\x92P\x90P`\x01`\x01`\xA0\x1B\x03\x8B\x16c\xA8\xC4\xBC\x95a\r ` \x86\x01\x86a<\x16V[`@Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\xE0\x84\x90\x1B\x16\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01R`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\rzW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\x9E\x91\x90a;\xFBV[\x15a\x10EW_\x89\x15a\r\xDCW`@Q\x7F}a{\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x04\x82\x10a\r\xE8WP\x815[\x7F\xC0:\x9D\xE9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0EVWa\x0E=\x83\x83\x8D\x8Ca&\xC4V[\x86` \x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x90RPa\x10CV[\x7F$:K\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0E\xBCWa\x0E\xAB\x83\x83\x8D\x8Ca'\xDAV[\x86``\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[\x7F}\xC4\xF4X\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0FGWa\x0F\x11\x83\x83\x8D\x8Ca)NV[`\xA0\x88\x01R`\x80\x87\x01\x81\x90R``\x87\x01\x80Qa\x0F.\x90\x83\x90a>\xBCV[\x90RP`\xA0\x86\x01Q` \x87\x01\x80Qa\x0EN\x90\x83\x90a>\xBCV[\x7Fh\x93\x1Bk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x0F\xABWa\x0F\x9C\x83\x83\x8D\x8Ca+\xB6V[\x86Q\x87\x90a\x0EN\x90\x83\x90a>\xBCV[\x7F\x0C\x9B\xE7\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\x16\x01a\x10\x11Wa\x10\0\x83\x83\x8D\x8Ca,\xC0V[\x86`@\x01\x81\x81Qa\x0EN\x91\x90a>\xBCV[`@Q\x7F\x05a\xD8\xB3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P[PPP\x80`\x01\x01\x90Pa\x0C\xC1V[Pa\x10^\x84\x82a.)V[PPPPPPPV[`\x03a\x10v` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x10\x87Wa\x10\x87a>\xF4V[\x03a\x10\xECW`\x01`\x01`\xA0\x1B\x03\x83\x16a\x10\xAC\x83a\x10\xA7`@\x85\x01\x85a=\x7FV[a\x1BPV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x0C+W`@Q\x7F\xB8\x1DX\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01a\x10\xFB` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\x0CWa\x11\x0Ca>\xF4V[\x03a\x11\xA0W\x7F\x19Ethereum Signed Message:\n32\0\0\0\0_\x90\x81R`\x1C\x83\x90R`<\x90 `\x01`\x01`\xA0\x1B\x03\x84\x16a\x11Z\x82a\x10\xA7`@\x86\x01\x86a=\x7FV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x11\x9AW`@Q\x7FdJ\xE6\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\x02a\x11\xAF` \x83\x01\x83a?!V[`\x03\x81\x11\x15a\x11\xC0Wa\x11\xC0a>\xF4V[\x03a\x12\xB9W\x7F\x16&\xBA~\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x84\x16c\x16&\xBA~\x84a\x12\x03`@\x86\x01\x86a=\x7FV[`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12!\x93\x92\x91\x90a??V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12<W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12`\x91\x90a?XV[\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x0C+W`@Q\x7F]R\xCB\xE3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F`\xCD@-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x12\xF4a\x04\xD7V[\x7F\xD2\x8E\x80\x9Bp\x8F^\xE3\x8B\xE84}m\x86\x9D\x822I<\tJ\xB2\xDD\xE9\x83i\xE4\x10#i\xA9\x9Da\x13\x1F\x84\x80a=\x7FV[`@Q` \x01a\x130\x92\x91\x90a?\x97V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x84` \x015\x85`@\x01` \x81\x01\x90a\x13^\x91\x90a<\x16V[`@\x80Q` \x81\x01\x95\x90\x95R\x84\x01\x92\x90\x92R``\x83\x01R`\x01`\x01`\xA0\x1B\x03\x16`\x80\x82\x01R`\xA0\x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90Ra\x13\xC4`\x80\x85\x01``\x86\x01a<\x16V[a\x13\xD4`\xA0\x86\x01`\x80\x87\x01a<\x16V[a\x13\xE4`\xC0\x87\x01`\xA0\x88\x01a<\x16V[`\xC0\x87\x015`\xE0\x88\x015a\x01\0\x89\x015a\x01 \x8A\x015a\x14\x0Ca\x01`\x8C\x01a\x01@\x8D\x01a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x99\x8A\x16` \x82\x01R\x97\x89\x16\x90\x88\x01R\x94\x87\x16``\x87\x01R`\x80\x86\x01\x93\x90\x93R`\xA0\x85\x01\x91\x90\x91R`\xC0\x84\x01R`\xE0\x83\x01R\x90\x91\x16a\x01\0\x82\x01Ra\x01 \x01`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x14\x92\x92\x91` \x01a?\xD7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 `@Q` \x01a\x06J\x92\x91\x90\x7F\x19\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x02\x81\x01\x92\x90\x92R`\"\x82\x01R`B\x01\x90V[a\x14\xF2a\x1B\xDBV[`@Q\x7F\x02\xCC%\r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x90c\x02\xCC%\r\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15mW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x91\x91\x90a;\xFBV[a\x15\xC7W`@Q\x7F\xC19\xEA\xBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xE7V\0\xC3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x89\x81\x16`\x04\x83\x01R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x90c\xE7V\0\xC3\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16DW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16h\x91\x90a;\xFBV[a\x16\x9EW`@Q\x7F\xB31\xE4!\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\0\x86\x015\x87\x15\x80\x15\x90a\x16\xB8WPa\x01`\x87\x015\x88\x11\x15[\x15a\x16\xD7Wa\x16\xD4\x88a\x02\0\x89\x015a\x01`\x8A\x015`\x01a\x1C\x1EV[\x90P[a\x17\x08\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x83\x8A\x8A\x8A\x8A\x8A\x8Aa\x1CiV[a\x17E\x87\x8A\x83\x8B\x15\x80a\x17\x1FWPa\x01`\x8B\x015\x8C\x11[a\x17)W\x8Ba\x170V[a\x01`\x8B\x015[\x88\x8B\x8B`\x01a\x08\xAF`@\x8D\x01` \x8E\x01a=aV[a\x17R`@\x88\x01\x88a=\x7FV[`@Qa\x17`\x92\x91\x90a=\xE0V[`@Q\x90\x81\x90\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6a\x17\x9A`\xA0\x8A\x01`\x80\x8B\x01a<\x16V[a\x17\xAA`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[a\x17\xBCa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[a\x17\xCEa\x01\xE0\x8D\x01a\x01\xC0\x8E\x01a<\x16V[\x8D\x15\x80a\x17\xDFWPa\x01`\x8D\x015\x8E\x11[a\x17\xE9W\x8Da\x17\xF0V[a\x01@\x8D\x015[a\x02\0\x8E\x015\x88\x14a\x18\x02W\x87a\x18\tV[a\x01\xE0\x8E\x015[\x8E`\xE0\x01` \x81\x01\x90a\x18\x1C\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2Pa\x18n`\x01\x80UV[PPPPPPPPV[a\x18\x82\x85\x83a\"\x12V[`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16c\xBC\x11x\xE6a\x18\xC1`\x80\x88\x01``\x89\x01a<\x16V[a\x18\xD1`\xA0\x89\x01`\x80\x8A\x01a<\x16V[\x88`\xC0\x015\x85`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x18\xF6\x94\x93\x92\x91\x90a<\x8DV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x19\rW_\x80\xFD[PZ\xF1\x15\x80\x15a\x19\x1FW=_\x80>=_\xFD[PPPPa\x19D\x86\x86\x86\x86`\x02\x89` \x01` \x81\x01\x90a\x19?\x91\x90a=aV[a\"\xC9V[PPPPPPV[_a\x19Ua\x04\xD7V[\x7F\xC9\x94\xD2\xCA\x03u\xD6\xD4sx^\x0C\xE0\xB1\xD2\x03\xF0i\x12\x1B\xAC\x13\x14\xF7,\\\x0F\xE6\x01\xEB9\x10a\x19\x83`@\x85\x01\x85a=\x7FV[`@Q` \x01a\x19\x94\x92\x91\x90a?\x97V[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x81\x84\x03\x01\x81R\x91\x90R\x80Q` \x90\x91\x01 ``\x85\x015a\x19\xDF`\xA0\x87\x01`\x80\x88\x01a<\x16V[a\x19\xEF`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\xC0\x88\x015a\x1A\x05a\x01\0\x8A\x01`\xE0\x8B\x01a<\x16V[`@\x80Q` \x81\x01\x98\x90\x98R\x87\x01\x95\x90\x95R``\x86\x01\x93\x90\x93R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80\x86\x01R\x81\x16`\xA0\x85\x01R`\xC0\x84\x01\x91\x90\x91R\x16`\xE0\x82\x01Ra\x01\0\x80\x85\x015\x90\x82\x01Ra\x01 \x01`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x1Ao\x84a\x01 \x01a\x0C0V[a\x1A|\x85a\x01\xC0\x01a\x05\xC6V[`@Q` \x01a\x14\x92\x93\x92\x91\x90a?\xEBV[a\x01\xA0\x81\x015a\x1A\xA8a\x01\x80\x83\x015a\x01`\x84\x015a>\xBCV[a\x1A\xB2\x91\x90a>\xBCV[a\x01@\x82\x015\x14a\x1A\xEFW`@Q\x7F\xC0Cw\xD3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x81\x015a\x1B\ta\x02 \x83\x015a\x02\0\x84\x015a>\xBCV[a\x1B\x13\x91\x90a>\xBCV[a\x01\xE0\x82\x015\x14a\x0C\x89W`@Q\x7F\x87v0\xBE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80a\x1B\x91\x85\x85\x85\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847_\x92\x01\x91\x90\x91RPa.\xD6\x92PPPV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16a\x1B\xD3W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x94\x93PPPPV[`\x02`\x01T\x03a\x1C\x17W`@Q\x7F>\xE5\xAE\xB5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02`\x01UV[_a\x1CKa\x1C+\x83a/\0V[\x80\x15a\x1CFWP_\x84\x80a\x1CAWa\x1CAa@\x08V[\x86\x88\t\x11[\x15\x15\x90V[a\x1CV\x86\x86\x86a/,V[a\x1C`\x91\x90a>\xBCV[\x95\x94PPPPPV[_a\x1Cs\x87a\x19LV[\x90Pa\x1C\x80\x89\x82\x85a\x10gV[a\x1C\x90`\xC0\x88\x01`\xA0\x89\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\x1C\xC7Wa\x1C\xC2a\x1C\xBB`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x82\x84a\x10gV[a\x1D\x0EV[a\x1C\xD4`@\x83\x01\x83a=\x7FV[\x90P_\x03a\x1D\x0EW`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D+a\x1D!`\xC0\x89\x01`\xA0\x8A\x01a<\x16V[\x88``\x015a&\x1EV[\x86`\xC0\x015B\x11\x15a\x1DiW`@Q\x7F\x13=\xF0)\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x88\x11\x80\x15a\x1D|WP\x86a\x01\0\x015\x88\x10[\x15a\x1D\xB3W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1D\xBC\x87a\x1A\x8EV[a\x1D\xC6\x8A\x85a\t\xE8V[a\x1D\xE7\x8A\x8A_\x8B\x11\x80\x15a\x1D\xDFWPa\x02\0\x8A\x015\x8B\x14\x15[\x8A\x8A\x8Aa\x0C\x8CV[a\x1D\xF5\x89\x88``\x015a&\x1EV[PPPPPPPPPPV[a\x1E\x13a\x1E\x0E\x86\x80a=\xEFV[a0\x01V[_a\x1E(a\x01\x80\x8B\x015a\x01\xA0\x8C\x015a>\xBCV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Ew\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x010`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1E\xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x86`\x02\x81\x11\x15a\x1E\xD0Wa\x1E\xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1F\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a\x1F\x18W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8D`\xA0\x01` \x81\x01\x90a\x1Fi\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\xE0\x01` \x81\x01\x90a\x1F\x8A\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01 \x01_\x01` \x81\x01\x90a\x1F\xAE\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8A\x81R` \x01\x86`\x02\x81\x11\x15a\x1F\xD4Wa\x1F\xD4a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F\xF3\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a \nW_\x80\xFD[PZ\xF1\x15\x80\x15a \x1CW=_\x80>=_\xFD[PPPPa *\x85\x85a0\x01V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8C`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8D`\x80\x01` \x81\x01\x90a \x86\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8Da\x01\xC0\x01_\x01` \x81\x01\x90a \xAA\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x8B\x81R` \x01\x85`\x02\x81\x11\x15a \xD0Wa \xD0a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \xEF\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a!\x06W_\x80\xFD[PZ\xF1\x15\x80\x15a!\x18W=_\x80>=_\xFD[Pa!.\x92Pa\x1E\x0E\x91PP` \x88\x01\x88a=\xEFV[_a!Aa\x01@\x8C\x01a\x01 \x8D\x01a<\x16V[`@Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!\x9EW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\xC2\x91\x90a@\xB4V[\x90P\x80\x15a\"\x05Wa\"\x05a!\xDEa\x01\0\x8D\x01`\xE0\x8E\x01a<\x16V[\x82\x8Da\x01 \x01_\x01` \x81\x01\x90a!\xF5\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a19V[PPPPPPPPPPPV[a\"\"`\x80\x83\x01``\x84\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x163`\x01`\x01`\xA0\x1B\x03\x16\x14a\"aWa\"\\a\"M`\x80\x84\x01``\x85\x01a<\x16V[a\"V\x84a\x12\xEBV[\x83a\x10gV[a\"\xA8V[a\"n`@\x82\x01\x82a=\x7FV[\x90P_\x03a\"\xA8W`@Q\x7F\x0E6N\xFC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\"\xC5a\"\xBB`\x80\x84\x01``\x85\x01a<\x16V[\x83` \x015a&\x1EV[PPV[`\xE0\x85\x015\x83\x15\x80\x15\x90a\"\xE0WP\x85`\xC0\x015\x84\x10[\x15a\"\xFDWa\"\xFA\x84\x87`\xE0\x015\x88`\xC0\x015`\x01a\x1C\x1EV[\x90P[a#\t\x87\x82\x88\x88a1\xB9V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x89``\x01` \x81\x01\x90a#V\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#va\x01`\x8B\x01a\x01@\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a#\x94`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x87\x15\x80a#\xB2WP\x89`\xC0\x015\x88\x11[a#\xBCW\x87a#\xC2V[\x89`\xC0\x015[\x81R` \x01\x86`\x02\x81\x11\x15a#\xD9Wa#\xD9a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a#\xF8\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\x0FW_\x80\xFD[PZ\xF1\x15\x80\x15a$!W=_\x80>=_\xFD[PPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xB5\x19\xD3i`@Q\x80`\xA0\x01`@R\x80\x8A`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x89`@\x01` \x81\x01\x90a$\x81\x91\x90a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a$\x9F`\xC0\x8B\x01`\xA0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x02\x81\x11\x15a$\xC5Wa$\xC5a>\xF4V[\x81RP`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a$\xE4\x91\x90a@5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a$\xFBW_\x80\xFD[PZ\xF1\x15\x80\x15a%\rW=_\x80>=_\xFD[Pa%\x1E\x92P\x88\x91P\x81\x90Pa=\x7FV[`@Qa%,\x92\x91\x90a=\xE0V[`@Q\x80\x91\x03\x90 \x7F\x0F\xCE\0|8\xC6\xC8\xED\x9ET[:\x14\x80\x95v'8a\x8F\x8C!\xB6s\"&\x13\xE4\xD4W4\xB6\x87`@\x01` \x81\x01\x90a%h\x91\x90a<\x16V[a%x`\x80\x8A\x01``\x8B\x01a<\x16V[a%\x88`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[a%\x98`\xC0\x8C\x01`\xA0\x8D\x01a<\x16V[\x89\x15\x80a%\xA8WP\x8B`\xC0\x015\x8A\x11[a%\xB2W\x89a%\xB8V[\x8B`\xC0\x015[\x87\x8Da\x01@\x01` \x81\x01\x90a%\xCD\x91\x90a<\x16V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x98\x89\x16\x81R\x96\x88\x16` \x88\x01R\x94\x87\x16\x94\x86\x01\x94\x90\x94R\x91\x85\x16``\x85\x01R`\x80\x84\x01R`\xA0\x83\x01R\x90\x91\x16`\xC0\x82\x01R`\xE0\x01`@Q\x80\x91\x03\x90\xA2PPPPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x84\x84R\x90\x91R\x90 T`\xFF\x16\x15a&yW`@Q\x7F\xBC\r\xA7\xD6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16_\x90\x81R` \x81\x81R`@\x80\x83 \x93\x83R\x92\x90R \x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\x16`\x01\x17\x90UV[_\x80\x80\x80a&\xD5\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a&\xE2\x91\x90a@\xF2V[P\x91\x94P\x92P\x90Pa&\xFCa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a'FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a'\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x97\x96PPPPPPPV[_\x80\x80\x80\x80a'\xEC\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a'\xF9\x91\x90aABV[\x92\x96P\x90\x94P\x92P\x90Pa(\x15a\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a(_W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a(\xAAW`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a(\xBA`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a)\x04W`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x98\x97PPPPPPPPV[_\x80_\x80_\x80_\x80_\x8C\x8C`\x04\x90\x80\x92a)j\x93\x92\x91\x90a@\xCBV[\x81\x01\x90a)w\x91\x90aA\x90V[\x95\x9CP\x93\x9AP\x91\x98P\x96P\x94P\x92P\x90Pa)\x9Aa\x01\xE0\x8B\x01a\x01\xC0\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a)\xE4W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85`\x01`\x01`\xA0\x1B\x03\x16\x8B`\x01`\x01`\xA0\x1B\x03\x16\x14a*/W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x160\x14a*qW`@Q\x7F\x81T7K\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x81`\xA0\x8B\x01`\x80\x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a*\xCBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02@\x8A\x015\x83\x14a+\tW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a+\x1Ba\x01@\x8B\x01a\x01 \x8C\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a+eW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xA0\x8A\x015\x81\x14a+\xA3W`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x91\x9C\x91\x9BP\x90\x99PPPPPPPPPPV[_\x80\x80\x80a+\xC7\x87`\x04\x81\x8Ba@\xCBV[\x81\x01\x90a+\xD4\x91\x90aB\x0FV[\x91\x94P\x92P\x90Pa+\xEDa\x01@\x86\x01a\x01 \x87\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14a,7W`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x01`\x01`\xA0\x1B\x03\x16\x86`\x01`\x01`\xA0\x1B\x03\x16\x14a,\x82W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\x80\x85\x015\x81\x14a'\xCFW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80\x80\x80a,\xD2\x88`\x04\x81\x8Ca@\xCBV[\x81\x01\x90a,\xDF\x91\x90aBMV[P\x92\x96P\x90\x94P\x92P\x90Pa,\xFCa\x01\xE0\x87\x01a\x01\xC0\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\x16\x14a-FW`@Q\x7F\xC8\x91\xAD\xD2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x14a-\x91W`@Q\x7F\x81^\x1Dd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a-\xA1`\xA0\x87\x01`\x80\x88\x01a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14a-\xEBW`@Q\x7F\xACk\x05\xF5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02 \x86\x015\x81\x14a)BW`@Q\x7F,R\x11\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80Qa\x01\x80\x83\x015\x14\x15\x80a.GWP` \x81\x01Qa\x01\xA0\x83\x015\x14\x15[\x15a.~W`@Q\x7FJU\xDA \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@\x81\x01Qa\x02 \x83\x015\x14\x15\x80a.\x9FWP``\x81\x01Qa\x02@\x83\x015\x14\x15[\x15a\"\xC5W`@Q\x7Fw\xA5\x92\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x80a.\xE4\x86\x86a2\\V[\x92P\x92P\x92Pa.\xF4\x82\x82a2\xA5V[P\x90\x91PP[\x92\x91PPV[_`\x02\x82`\x03\x81\x11\x15a/\x15Wa/\x15a>\xF4V[a/\x1F\x91\x90aB\xB1V[`\xFF\x16`\x01\x14\x90P\x91\x90PV[_\x83\x83\x02\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x87\t\x82\x81\x10\x83\x82\x03\x03\x91PP\x80_\x03a/\x7FW\x83\x82\x81a/uWa/ua@\x08V[\x04\x92PPPa\x04\xD0V[\x80\x84\x11a/\x96Wa/\x96`\x03\x85\x15\x02`\x11\x18a3\xADV[_\x84\x86\x88\t_\x86\x81\x03\x87\x16\x96\x87\x90\x04\x96`\x02`\x03\x89\x02\x81\x18\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x82\x03\x02\x80\x8A\x02\x90\x91\x03\x02\x91\x81\x90\x03\x81\x90\x04`\x01\x01\x86\x84\x11\x90\x95\x03\x94\x90\x94\x02\x91\x90\x94\x03\x92\x90\x92\x04\x91\x90\x91\x17\x91\x90\x91\x02\x91PP\x93\x92PPPV[_[\x81\x81\x10\x15a\x0C+W6\x83\x83\x83\x81\x81\x10a0\x1EWa0\x1Ea>SV[\x90P` \x02\x81\x01\x90a00\x91\x90a>\x80V[\x90P`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16a0i` \x83\x01\x83a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x03a0\xA9W`@Q\x7Fy\xA1\xBF\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a0\xB2\x81a3\xBEV[a0\xBF` \x82\x01\x82a<\x16V[`\x01`\x01`\xA0\x1B\x03\x16\x7F\xED\x99\x82~\xFB7\x01o\"u\xF9\x8CK\xCFq\xC7U\x1Cu\xD5\x9E\x9BE\x0Fy\xFA2\xE6\x0B\xE6r\xC2\x82` \x015a0\xF7\x84a4\x01V[`@\x80Q\x92\x83R\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16` \x83\x01R\x01`@Q\x80\x91\x03\x90\xA2P`\x01\x01a0\x03V[`@\x80Q`\x01`\x01`\xA0\x1B\x03\x84\x16`$\x82\x01R`D\x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x90\x91\x01\x81R`d\x90\x91\x01\x90\x91R` \x81\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x90Ra\x0C+\x90\x84\x90a4*V[_\x83\x11\x80\x15a1\xCCWP\x81a\x01\0\x015\x83\x10[\x15a2\x03W`@Q\x7F\x94itD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a2\x10\x84a\"V\x84a\x12\xEBV[a2\x1E\x84\x83` \x015a&\x1EV[B\x82a\x01 \x015\x11a\x11\x9AW`@Q\x7F\xC5hs\xBA\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80_\x83Q`A\x03a2\x93W` \x84\x01Q`@\x85\x01Q``\x86\x01Q_\x1Aa2\x85\x88\x82\x85\x85a4\xAFV[\x95P\x95P\x95PPPPa2\x9EV[PP\x81Q_\x91P`\x02\x90[\x92P\x92P\x92V[_\x82`\x03\x81\x11\x15a2\xB8Wa2\xB8a>\xF4V[\x03a2\xC1WPPV[`\x01\x82`\x03\x81\x11\x15a2\xD5Wa2\xD5a>\xF4V[\x03a3\x0CW`@Q\x7F\xF6E\xEE\xDF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x02\x82`\x03\x81\x11\x15a3 Wa3 a>\xF4V[\x03a3_W`@Q\x7F\xFC\xE6\x98\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x03\x82`\x03\x81\x11\x15a3sWa3sa>\xF4V[\x03a\"\xC5W`@Q\x7F\xD7\x8B\xCE\x0C\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x81\x01\x82\x90R`$\x01a3VV[cNH{q_R\x80` R`$`\x1C\xFD[_a3\xCC` \x83\x01\x83a<\x16V[\x90P` \x82\x0156_a3\xE2`@\x86\x01\x86a=\x7FV[\x91P\x91P`@Q\x81\x83\x827_\x80\x83\x83\x87\x89Z\xF1a\x19DW=_\x80>=_\xFD[_6\x81a4\x11`@\x85\x01\x85a=\x7FV[\x90\x92P\x90P`\x04\x81\x10a4#W\x815\x92P[PP\x91\x90PV[_\x80` _\x84Q` \x86\x01_\x88Z\xF1\x80a4IW`@Q=_\x82>=\x81\xFD[PP_Q=\x91P\x81\x15a4`W\x80`\x01\x14\x15a4mV[`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x11\x9AW`@Q\x7FRt\xAF\xE7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a3VV[_\x80\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x84\x11\x15a4\xE8WP_\x91P`\x03\x90P\x82a5\x8BV[`@\x80Q_\x80\x82R` \x82\x01\x80\x84R\x8A\x90R`\xFF\x89\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x87\x90R`\x80\x81\x01\x86\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a59W=_\x80>=_\xFD[PP`@Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a5\x82WP_\x92P`\x01\x91P\x82\x90Pa5\x8BV[\x92P_\x91P\x81\x90P[\x94P\x94P\x94\x91PPV[_\x80_`@\x84\x86\x03\x12\x15a5\xA7W_\x80\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a5\xC5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a5\xD8W_\x80\xFD[\x815\x81\x81\x11\x15a5\xE6W_\x80\xFD[\x87` \x82\x85\x01\x01\x11\x15a5\xF7W_\x80\xFD[` \x83\x01\x94P\x80\x93PPPP\x92P\x92P\x92V[_`\xA0\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[P\x91\x90PV[_`\xA0\x82\x84\x03\x12\x15a60W_\x80\xFD[a\x04\xD0\x83\x83a6\nV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x89W_\x80\xFD[\x805a6Y\x81a6:V[\x91\x90PV[_a\x02`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80\x83`\x1F\x84\x01\x12a6\x7FW_\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x96W_\x80\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a6\xB0W_\x80\xFD[\x92P\x92\x90PV[_`@\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_``\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_\x80_\x80_a\x01\0\x8A\x8C\x03\x12\x15a6\xF0W_\x80\xFD[a6\xF9\x8Aa6NV[\x98P` \x8A\x015\x97P`@\x8A\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a7\x1CW_\x80\xFD[a7(\x8D\x83\x8E\x01a6^V[\x98P``\x8C\x015\x91P\x80\x82\x11\x15a7=W_\x80\xFD[a7I\x8D\x83\x8E\x01a6oV[\x90\x98P\x96P`\x80\x8C\x015\x91P\x80\x82\x11\x15a7aW_\x80\xFD[a7m\x8D\x83\x8E\x01a6\xB7V[\x95P`\xA0\x8C\x015\x91P\x80\x82\x11\x15a7\x82W_\x80\xFD[a7\x8E\x8D\x83\x8E\x01a6\xC7V[\x94P`\xC0\x8C\x015\x91P\x80\x82\x11\x15a7\xA3W_\x80\xFD[a7\xAF\x8D\x83\x8E\x01a6\xC7V[\x93P`\xE0\x8C\x015\x91P\x80\x82\x11\x15a7\xC4W_\x80\xFD[Pa7\xD1\x8C\x82\x8D\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98P\x92\x95\x98V[_\x80`@\x83\x85\x03\x12\x15a7\xF2W_\x80\xFD[\x825a7\xFD\x81a6:V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x18W_\x80\xFD[a8$\x85\x82\x86\x01a6\xB7V[\x91PP\x92P\x92\x90PV[_a\x01`\x82\x84\x03\x12\x15a6\x1AW_\x80\xFD[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15a8SW_\x80\xFD[\x855a8^\x81a6:V[\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a8zW_\x80\xFD[a8\x86\x89\x83\x8A\x01a8.V[\x95P`@\x88\x015\x91P\x80\x82\x11\x15a8\x9BW_\x80\xFD[a8\xA7\x89\x83\x8A\x01a6\xC7V[\x94P``\x88\x015\x93P`\x80\x88\x015\x91P\x80\x82\x11\x15a8\xC3W_\x80\xFD[Pa8\xD0\x88\x82\x89\x01a6\xC7V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_` \x82\x84\x03\x12\x15a8\xEDW_\x80\xFD[P5\x91\x90PV[\x80\x15\x15\x81\x14a\x0C\x89W_\x80\xFD[_\x80_\x80_\x80`\xA0\x87\x89\x03\x12\x15a9\x16W_\x80\xFD[\x865a9!\x81a6:V[\x95P` \x87\x015a91\x81a6:V[\x94P`@\x87\x015a9A\x81a8\xF4V[\x93P``\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a9]W_\x80\xFD[a9i\x8A\x83\x8B\x01a6^V[\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a9~W_\x80\xFD[Pa9\x8B\x89\x82\x8A\x01a6oV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_\x80_``\x84\x86\x03\x12\x15a9\xAFW_\x80\xFD[\x835a9\xBA\x81a6:V[\x92P` \x84\x015\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a9\xDCW_\x80\xFD[a9\xE8\x86\x82\x87\x01a6\xC7V[\x91PP\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a:\x02W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a:\x18W_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a8.V[_\x80_\x80_\x80_\x80`\xE0\x89\x8B\x03\x12\x15a:;W_\x80\xFD[a:D\x89a6NV[\x97P` \x89\x015\x96P`@\x89\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a:gW_\x80\xFD[a:s\x8C\x83\x8D\x01a6^V[\x97P``\x8B\x015\x91P\x80\x82\x11\x15a:\x88W_\x80\xFD[a:\x94\x8C\x83\x8D\x01a6oV[\x90\x97P\x95P`\x80\x8B\x015\x91P\x80\x82\x11\x15a:\xACW_\x80\xFD[a:\xB8\x8C\x83\x8D\x01a6\xB7V[\x94P`\xA0\x8B\x015\x91P\x80\x82\x11\x15a:\xCDW_\x80\xFD[a:\xD9\x8C\x83\x8D\x01a6\xC7V[\x93P`\xC0\x8B\x015\x91P\x80\x82\x11\x15a:\xEEW_\x80\xFD[Pa:\xFB\x8B\x82\x8C\x01a6\xC7V[\x91PP\x92\x95\x98P\x92\x95\x98\x90\x93\x96PV[_\x80_\x80_\x80`\xC0\x87\x89\x03\x12\x15a; W_\x80\xFD[a;)\x87a6NV[\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a;EW_\x80\xFD[a;Q\x8A\x83\x8B\x01a8.V[\x96P`@\x89\x015\x91P\x80\x82\x11\x15a;fW_\x80\xFD[a;r\x8A\x83\x8B\x01a6\xC7V[\x95P``\x89\x015\x94P`\x80\x89\x015\x91P\x80\x82\x11\x15a;\x8EW_\x80\xFD[a;\x9A\x8A\x83\x8B\x01a6\xC7V[\x93P`\xA0\x89\x015\x91P\x80\x82\x11\x15a;\xAFW_\x80\xFD[Pa;\xBC\x89\x82\x8A\x01a6\xC7V[\x91PP\x92\x95P\x92\x95P\x92\x95V[_` \x82\x84\x03\x12\x15a;\xD9W_\x80\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a;\xEFW_\x80\xFD[a\x1B\xD3\x84\x82\x85\x01a6^V[_` \x82\x84\x03\x12\x15a<\x0BW_\x80\xFD[\x81Qa\x04\xD0\x81a8\xF4V[_` \x82\x84\x03\x12\x15a<&W_\x80\xFD[\x815a\x04\xD0\x81a6:V[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[\x805e\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a6YW_\x80\xFD[_`\x01`\x01`\xA0\x1B\x03\x80\x87\x16\x83R\x80\x86\x16` \x84\x01RP\x83`@\x83\x01R`\x80``\x83\x01R\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a<\xE2W_\x80\xFD[\x83\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a<\xFEW_\x80\xFD[\x806\x03\x82\x13\x15a=\x0CW_\x80\xFD[```\x80\x85\x01Ra=!`\xE0\x85\x01\x82\x84a<1V[\x91PPa=0` \x85\x01a<xV[e\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x16`\xA0\x86\x01R\x80a=L`@\x88\x01a<xV[\x16`\xC0\x86\x01RPP\x80\x91PP\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a=qW_\x80\xFD[\x815`\x03\x81\x10a\x04\xD0W_\x80\xFD[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a=\xB2W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a=\xCCW_\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV[_\x80\x835\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE1\x846\x03\x01\x81\x12a>\"W_\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a><W_\x80\xFD[` \x01\x91P`\x05\x81\x90\x1B6\x03\x82\x13\x15a6\xB0W_\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`2`\x04R`$_\xFD[_\x825\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA1\x836\x03\x01\x81\x12a>\xB2W_\x80\xFD[\x91\x90\x91\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a.\xFAW\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a?1W_\x80\xFD[\x815`\x04\x81\x10a\x04\xD0W_\x80\xFD[\x83\x81R`@` \x82\x01R_a\x1C``@\x83\x01\x84\x86a<1V[_` \x82\x84\x03\x12\x15a?hW_\x80\xFD[\x81Q\x7F\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x16\x81\x14a\x04\xD0W_\x80\xFD[` \x81R_a\x1B\xD3` \x83\x01\x84\x86a<1V[_\x81Q_[\x81\x81\x10\x15a?\xC9W` \x81\x85\x01\x81\x01Q\x86\x83\x01R\x01a?\xAFV[P_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x1B\xD3a?\xE5\x83\x86a?\xAAV[\x84a?\xAAV[_a?\xF6\x82\x86a?\xAAV[\x93\x84RPP` \x82\x01R`@\x01\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_`\xA0\x82\x01\x90P`\x01`\x01`\xA0\x1B\x03\x80\x84Q\x16\x83R\x80` \x85\x01Q\x16` \x84\x01R\x80`@\x85\x01Q\x16`@\x84\x01RP``\x83\x01Q``\x83\x01R`\x80\x83\x01Q`\x03\x81\x10a@\xA7W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`!`\x04R`$_\xFD[\x80`\x80\x84\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a@\xC4W_\x80\xFD[PQ\x91\x90PV[_\x80\x85\x85\x11\x15a@\xD9W_\x80\xFD[\x83\x86\x11\x15a@\xE5W_\x80\xFD[PP\x82\x01\x93\x91\x90\x92\x03\x91PV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aA\x05W_\x80\xFD[\x845aA\x10\x81a6:V[\x93P` \x85\x015aA \x81a6:V[\x92P`@\x85\x015\x91P``\x85\x015aA7\x81a8\xF4V[\x93\x96\x92\x95P\x90\x93PPV[_\x80_\x80`\x80\x85\x87\x03\x12\x15aAUW_\x80\xFD[\x845aA`\x81a6:V[\x93P` \x85\x015aAp\x81a6:V[\x92P`@\x85\x015aA\x80\x81a6:V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_\x80_\x80_\x80_`\xE0\x88\x8A\x03\x12\x15aA\xA6W_\x80\xFD[\x875aA\xB1\x81a6:V[\x96P` \x88\x015aA\xC1\x81a6:V[\x95P`@\x88\x015aA\xD1\x81a6:V[\x94P``\x88\x015aA\xE1\x81a6:V[\x93P`\x80\x88\x015\x92P`\xA0\x88\x015aA\xF8\x81a6:V[\x80\x92PP`\xC0\x88\x015\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[_\x80_``\x84\x86\x03\x12\x15aB!W_\x80\xFD[\x835aB,\x81a6:V[\x92P` \x84\x015aB<\x81a6:V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_\x80_\x80_`\xA0\x86\x88\x03\x12\x15aBaW_\x80\xFD[\x855aBl\x81a6:V[\x94P` \x86\x015aB|\x81a6:V[\x93P`@\x86\x015aB\x8C\x81a6:V[\x92P``\x86\x015\x91P`\x80\x86\x015aB\xA3\x81a8\xF4V[\x80\x91PP\x92\x95P\x92\x95\x90\x93PV[_`\xFF\x83\x16\x80aB\xE8W\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[\x80`\xFF\x84\x16\x06\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x9B\xE5\x8A\xCA\xDA50a\xA2\xA2\x02\xCCp\x11\xF3\xC9\x13\x93\xE0\xF2\xE3\x05\xE9 $E\xB0B\xFCJL\xE6dsolcC\0\x08\x17\x003",
+    );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidHooksTarget()` and selector `0xc99e8872`.
+    /**Custom error with signature `ECDSAInvalidSignature()` and selector `0xf645eedf`.
     ```solidity
-    error InvalidHooksTarget();
+    error ECDSAInvalidSignature();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidHooksTarget;
+    pub struct ECDSAInvalidSignature;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5877,25 +3754,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidHooksTarget> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidHooksTarget) -> Self {
+        impl ::core::convert::From<ECDSAInvalidSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: ECDSAInvalidSignature) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidHooksTarget {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignature {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidHooksTarget {
+        impl alloy_sol_types::SolError for ECDSAInvalidSignature {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [201u8, 158u8, 136u8, 114u8];
-            const SIGNATURE: &'static str = "InvalidHooksTarget()";
+            const SELECTOR: [u8; 4] = [246u8, 69u8, 238u8, 223u8];
+            const SIGNATURE: &'static str = "ECDSAInvalidSignature()";
 
             #[inline]
             fn new<'a>(
@@ -5919,13 +3796,16 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidInteractionsBaseTokenAmounts()` and selector `0x4a55da20`.
+    /**Custom error with signature `ECDSAInvalidSignatureLength(uint256)` and selector `0xfce698f7`.
     ```solidity
-    error InvalidInteractionsBaseTokenAmounts();
+    error ECDSAInvalidSignatureLength(uint256 length);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidInteractionsBaseTokenAmounts;
+    pub struct ECDSAInvalidSignatureLength {
+        #[allow(missing_docs)]
+        pub length: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5936,9 +3816,9 @@ pub mod LiquoriceSettlement {
         use alloy_sol_types;
         #[doc(hidden)]
         #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
         #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
         fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5950,25 +3830,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidInteractionsBaseTokenAmounts> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidInteractionsBaseTokenAmounts) -> Self {
-                ()
+        impl ::core::convert::From<ECDSAInvalidSignatureLength> for UnderlyingRustTuple<'_> {
+            fn from(value: ECDSAInvalidSignatureLength) -> Self {
+                (value.length,)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInteractionsBaseTokenAmounts {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignatureLength {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
+                Self { length: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidInteractionsBaseTokenAmounts {
+        impl alloy_sol_types::SolError for ECDSAInvalidSignatureLength {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 85u8, 218u8, 32u8];
-            const SIGNATURE: &'static str = "InvalidInteractionsBaseTokenAmounts()";
+            const SELECTOR: [u8; 4] = [252u8, 230u8, 152u8, 247u8];
+            const SIGNATURE: &'static str = "ECDSAInvalidSignatureLength(uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5979,80 +3859,11 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.length,
+                    ),
                 )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidInteractionsQuoteTokenAmounts()` and selector `0x77a59203`.
-    ```solidity
-    error InvalidInteractionsQuoteTokenAmounts();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidInteractionsQuoteTokenAmounts;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidInteractionsQuoteTokenAmounts> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidInteractionsQuoteTokenAmounts) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInteractionsQuoteTokenAmounts {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidInteractionsQuoteTokenAmounts {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [119u8, 165u8, 146u8, 3u8];
-            const SIGNATURE: &'static str = "InvalidInteractionsQuoteTokenAmounts()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
             }
 
             #[inline]
@@ -6065,13 +3876,16 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidLendingPoolInteraction()` and selector `0x0561d8b3`.
+    /**Custom error with signature `ECDSAInvalidSignatureS(bytes32)` and selector `0xd78bce0c`.
     ```solidity
-    error InvalidLendingPoolInteraction();
+    error ECDSAInvalidSignatureS(bytes32 s);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidLendingPoolInteraction;
+    pub struct ECDSAInvalidSignatureS {
+        #[allow(missing_docs)]
+        pub s: alloy_sol_types::private::FixedBytes<32>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6082,9 +3896,9 @@ pub mod LiquoriceSettlement {
         use alloy_sol_types;
         #[doc(hidden)]
         #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
         #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
         fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6096,25 +3910,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidLendingPoolInteraction> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidLendingPoolInteraction) -> Self {
-                ()
+        impl ::core::convert::From<ECDSAInvalidSignatureS> for UnderlyingRustTuple<'_> {
+            fn from(value: ECDSAInvalidSignatureS) -> Self {
+                (value.s,)
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidLendingPoolInteraction {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ECDSAInvalidSignatureS {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
+                Self { s: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidLendingPoolInteraction {
+        impl alloy_sol_types::SolError for ECDSAInvalidSignatureS {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [5u8, 97u8, 216u8, 179u8];
-            const SIGNATURE: &'static str = "InvalidLendingPoolInteraction()";
+            const SELECTOR: [u8; 4] = [215u8, 139u8, 206u8, 12u8];
+            const SIGNATURE: &'static str = "ECDSAInvalidSignatureS(bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -6125,7 +3939,11 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.s),
+                )
             }
 
             #[inline]
@@ -6138,13 +3956,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidQuoteTokenAmounts()` and selector `0x877630be`.
+    /**Custom error with signature `InvalidAmount()` and selector `0x2c5211c6`.
     ```solidity
-    error InvalidQuoteTokenAmounts();
+    error InvalidAmount();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidQuoteTokenAmounts;
+    pub struct InvalidAmount;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6169,25 +3987,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidQuoteTokenAmounts> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidQuoteTokenAmounts) -> Self {
+        impl ::core::convert::From<InvalidAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidAmount) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidQuoteTokenAmounts {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAmount {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidQuoteTokenAmounts {
+        impl alloy_sol_types::SolError for InvalidAmount {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [135u8, 118u8, 48u8, 190u8];
-            const SIGNATURE: &'static str = "InvalidQuoteTokenAmounts()";
+            const SELECTOR: [u8; 4] = [44u8, 82u8, 17u8, 198u8];
+            const SIGNATURE: &'static str = "InvalidAmount()";
 
             #[inline]
             fn new<'a>(
@@ -6211,13 +4029,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidSignatureType()` and selector `0x60cd402d`.
+    /**Custom error with signature `InvalidAsset()` and selector `0xc891add2`.
     ```solidity
-    error InvalidSignatureType();
+    error InvalidAsset();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidSignatureType;
+    pub struct InvalidAsset;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6242,25 +4060,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidSignatureType> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidSignatureType) -> Self {
+        impl ::core::convert::From<InvalidAsset> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidAsset) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignatureType {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAsset {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidSignatureType {
+        impl alloy_sol_types::SolError for InvalidAsset {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [96u8, 205u8, 64u8, 45u8];
-            const SIGNATURE: &'static str = "InvalidSignatureType()";
+            const SELECTOR: [u8; 4] = [200u8, 145u8, 173u8, 210u8];
+            const SIGNATURE: &'static str = "InvalidAsset()";
 
             #[inline]
             fn new<'a>(
@@ -6284,13 +4102,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidSigner()` and selector `0x815e1d64`.
+    /**Custom error with signature `InvalidBaseTokenAmounts()` and selector `0xc04377d3`.
     ```solidity
-    error InvalidSigner();
+    error InvalidBaseTokenAmounts();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidSigner;
+    pub struct InvalidBaseTokenAmounts;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6315,25 +4133,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidSigner> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidSigner) -> Self {
+        impl ::core::convert::From<InvalidBaseTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidBaseTokenAmounts) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSigner {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidBaseTokenAmounts {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidSigner {
+        impl alloy_sol_types::SolError for InvalidBaseTokenAmounts {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [129u8, 94u8, 29u8, 100u8];
-            const SIGNATURE: &'static str = "InvalidSigner()";
+            const SELECTOR: [u8; 4] = [192u8, 67u8, 119u8, 211u8];
+            const SIGNATURE: &'static str = "InvalidBaseTokenAmounts()";
 
             #[inline]
             fn new<'a>(
@@ -6357,13 +4175,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidSource()` and selector `0x8154374b`.
+    /**Custom error with signature `InvalidDestination()` and selector `0xac6b05f5`.
     ```solidity
-    error InvalidSource();
+    error InvalidDestination();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct InvalidSource;
+    pub struct InvalidDestination;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6388,25 +4206,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<InvalidSource> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidSource) -> Self {
+        impl ::core::convert::From<InvalidDestination> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidDestination) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSource {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidDestination {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidSource {
+        impl alloy_sol_types::SolError for InvalidDestination {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [129u8, 84u8, 55u8, 75u8];
-            const SIGNATURE: &'static str = "InvalidSource()";
+            const SELECTOR: [u8; 4] = [172u8, 107u8, 5u8, 245u8];
+            const SIGNATURE: &'static str = "InvalidDestination()";
 
             #[inline]
             fn new<'a>(
@@ -6430,13 +4248,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `NonceInvalid()` and selector `0xbc0da7d6`.
+    /**Custom error with signature `InvalidEIP1271Signature()` and selector `0x5d52cbe3`.
     ```solidity
-    error NonceInvalid();
+    error InvalidEIP1271Signature();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct NonceInvalid;
+    pub struct InvalidEIP1271Signature;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6461,25 +4279,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<NonceInvalid> for UnderlyingRustTuple<'_> {
-            fn from(value: NonceInvalid) -> Self {
+        impl ::core::convert::From<InvalidEIP1271Signature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidEIP1271Signature) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NonceInvalid {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEIP1271Signature {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for NonceInvalid {
+        impl alloy_sol_types::SolError for InvalidEIP1271Signature {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [188u8, 13u8, 167u8, 214u8];
-            const SIGNATURE: &'static str = "NonceInvalid()";
+            const SELECTOR: [u8; 4] = [93u8, 82u8, 203u8, 227u8];
+            const SIGNATURE: &'static str = "InvalidEIP1271Signature()";
 
             #[inline]
             fn new<'a>(
@@ -6503,13 +4321,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `NotMaker()` and selector `0xb331e421`.
+    /**Custom error with signature `InvalidEIP712Signature()` and selector `0xb81d58e7`.
     ```solidity
-    error NotMaker();
+    error InvalidEIP712Signature();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct NotMaker;
+    pub struct InvalidEIP712Signature;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6534,25 +4352,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<NotMaker> for UnderlyingRustTuple<'_> {
-            fn from(value: NotMaker) -> Self {
+        impl ::core::convert::From<InvalidEIP712Signature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidEIP712Signature) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotMaker {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEIP712Signature {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for NotMaker {
+        impl alloy_sol_types::SolError for InvalidEIP712Signature {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [179u8, 49u8, 228u8, 33u8];
-            const SIGNATURE: &'static str = "NotMaker()";
+            const SELECTOR: [u8; 4] = [184u8, 29u8, 88u8, 231u8];
+            const SIGNATURE: &'static str = "InvalidEIP712Signature()";
 
             #[inline]
             fn new<'a>(
@@ -6576,13 +4394,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `NotSolver()` and selector `0xc139eabd`.
+    /**Custom error with signature `InvalidETHSignSignature()` and selector `0x644ae6c3`.
     ```solidity
-    error NotSolver();
+    error InvalidETHSignSignature();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct NotSolver;
+    pub struct InvalidETHSignSignature;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6607,25 +4425,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<NotSolver> for UnderlyingRustTuple<'_> {
-            fn from(value: NotSolver) -> Self {
+        impl ::core::convert::From<InvalidETHSignSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidETHSignSignature) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotSolver {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidETHSignSignature {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for NotSolver {
+        impl alloy_sol_types::SolError for InvalidETHSignSignature {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [193u8, 57u8, 234u8, 189u8];
-            const SIGNATURE: &'static str = "NotSolver()";
+            const SELECTOR: [u8; 4] = [100u8, 74u8, 230u8, 195u8];
+            const SIGNATURE: &'static str = "InvalidETHSignSignature()";
 
             #[inline]
             fn new<'a>(
@@ -6649,13 +4467,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `OrderExpired()` and selector `0xc56873ba`.
+    /**Custom error with signature `InvalidFillAmount()` and selector `0x94697444`.
     ```solidity
-    error OrderExpired();
+    error InvalidFillAmount();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct OrderExpired;
+    pub struct InvalidFillAmount;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6680,25 +4498,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<OrderExpired> for UnderlyingRustTuple<'_> {
-            fn from(value: OrderExpired) -> Self {
+        impl ::core::convert::From<InvalidFillAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidFillAmount) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderExpired {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidFillAmount {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for OrderExpired {
+        impl alloy_sol_types::SolError for InvalidFillAmount {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [197u8, 104u8, 115u8, 186u8];
-            const SIGNATURE: &'static str = "OrderExpired()";
+            const SELECTOR: [u8; 4] = [148u8, 105u8, 116u8, 68u8];
+            const SIGNATURE: &'static str = "InvalidFillAmount()";
 
             #[inline]
             fn new<'a>(
@@ -6722,13 +4540,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `PartialFillNotSupported()` and selector `0x7d617bb3`.
+    /**Custom error with signature `InvalidHooksTarget()` and selector `0xc99e8872`.
     ```solidity
-    error PartialFillNotSupported();
+    error InvalidHooksTarget();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct PartialFillNotSupported;
+    pub struct InvalidHooksTarget;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6753,25 +4571,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<PartialFillNotSupported> for UnderlyingRustTuple<'_> {
-            fn from(value: PartialFillNotSupported) -> Self {
+        impl ::core::convert::From<InvalidHooksTarget> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidHooksTarget) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PartialFillNotSupported {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidHooksTarget {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for PartialFillNotSupported {
+        impl alloy_sol_types::SolError for InvalidHooksTarget {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [125u8, 97u8, 123u8, 179u8];
-            const SIGNATURE: &'static str = "PartialFillNotSupported()";
+            const SELECTOR: [u8; 4] = [201u8, 158u8, 136u8, 114u8];
+            const SIGNATURE: &'static str = "InvalidHooksTarget()";
 
             #[inline]
             fn new<'a>(
@@ -6795,13 +4613,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ReceiverNotManager()` and selector `0x79a1bff0`.
+    /**Custom error with signature `InvalidInteractionsBaseTokenAmounts()` and selector `0x4a55da20`.
     ```solidity
-    error ReceiverNotManager();
+    error InvalidInteractionsBaseTokenAmounts();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ReceiverNotManager;
+    pub struct InvalidInteractionsBaseTokenAmounts;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6826,25 +4644,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<ReceiverNotManager> for UnderlyingRustTuple<'_> {
-            fn from(value: ReceiverNotManager) -> Self {
+        impl ::core::convert::From<InvalidInteractionsBaseTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidInteractionsBaseTokenAmounts) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReceiverNotManager {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInteractionsBaseTokenAmounts {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for ReceiverNotManager {
+        impl alloy_sol_types::SolError for InvalidInteractionsBaseTokenAmounts {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [121u8, 161u8, 191u8, 240u8];
-            const SIGNATURE: &'static str = "ReceiverNotManager()";
+            const SELECTOR: [u8; 4] = [74u8, 85u8, 218u8, 32u8];
+            const SIGNATURE: &'static str = "InvalidInteractionsBaseTokenAmounts()";
 
             #[inline]
             fn new<'a>(
@@ -6868,13 +4686,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ReentrancyGuardReentrantCall()` and selector `0x3ee5aeb5`.
+    /**Custom error with signature `InvalidInteractionsQuoteTokenAmounts()` and selector `0x77a59203`.
     ```solidity
-    error ReentrancyGuardReentrantCall();
+    error InvalidInteractionsQuoteTokenAmounts();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ReentrancyGuardReentrantCall;
+    pub struct InvalidInteractionsQuoteTokenAmounts;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6899,25 +4717,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<ReentrancyGuardReentrantCall> for UnderlyingRustTuple<'_> {
-            fn from(value: ReentrancyGuardReentrantCall) -> Self {
+        impl ::core::convert::From<InvalidInteractionsQuoteTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidInteractionsQuoteTokenAmounts) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReentrancyGuardReentrantCall {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInteractionsQuoteTokenAmounts {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
+        impl alloy_sol_types::SolError for InvalidInteractionsQuoteTokenAmounts {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
-            const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
+            const SELECTOR: [u8; 4] = [119u8, 165u8, 146u8, 3u8];
+            const SIGNATURE: &'static str = "InvalidInteractionsQuoteTokenAmounts()";
 
             #[inline]
             fn new<'a>(
@@ -6941,16 +4759,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SafeERC20FailedOperation(address)` and selector `0x5274afe7`.
+    /**Custom error with signature `InvalidLendingPoolInteraction()` and selector `0x0561d8b3`.
     ```solidity
-    error SafeERC20FailedOperation(address token);
+    error InvalidLendingPoolInteraction();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct SafeERC20FailedOperation {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-    }
+    pub struct InvalidLendingPoolInteraction;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -6961,9 +4776,9 @@ pub mod LiquoriceSettlement {
         use alloy_sol_types;
         #[doc(hidden)]
         #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        type UnderlyingSolTuple<'a> = ();
         #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        type UnderlyingRustTuple<'a> = ();
         #[cfg(test)]
         #[allow(dead_code, unreachable_patterns)]
         fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6975,25 +4790,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<SafeERC20FailedOperation> for UnderlyingRustTuple<'_> {
-            fn from(value: SafeERC20FailedOperation) -> Self {
-                (value.token,)
+        impl ::core::convert::From<InvalidLendingPoolInteraction> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidLendingPoolInteraction) -> Self {
+                ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeERC20FailedOperation {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidLendingPoolInteraction {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { token: tuple.0 }
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for SafeERC20FailedOperation {
+        impl alloy_sol_types::SolError for InvalidLendingPoolInteraction {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [82u8, 116u8, 175u8, 231u8];
-            const SIGNATURE: &'static str = "SafeERC20FailedOperation(address)";
+            const SELECTOR: [u8; 4] = [5u8, 97u8, 216u8, 179u8];
+            const SIGNATURE: &'static str = "InvalidLendingPoolInteraction()";
 
             #[inline]
             fn new<'a>(
@@ -7004,11 +4819,7 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                )
+                ()
             }
 
             #[inline]
@@ -7021,13 +4832,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SignatureIsExpired()` and selector `0x133df029`.
+    /**Custom error with signature `InvalidQuoteTokenAmounts()` and selector `0x877630be`.
     ```solidity
-    error SignatureIsExpired();
+    error InvalidQuoteTokenAmounts();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct SignatureIsExpired;
+    pub struct InvalidQuoteTokenAmounts;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7052,25 +4863,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<SignatureIsExpired> for UnderlyingRustTuple<'_> {
-            fn from(value: SignatureIsExpired) -> Self {
+        impl ::core::convert::From<InvalidQuoteTokenAmounts> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidQuoteTokenAmounts) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureIsExpired {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidQuoteTokenAmounts {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for SignatureIsExpired {
+        impl alloy_sol_types::SolError for InvalidQuoteTokenAmounts {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [19u8, 61u8, 240u8, 41u8];
-            const SIGNATURE: &'static str = "SignatureIsExpired()";
+            const SELECTOR: [u8; 4] = [135u8, 118u8, 48u8, 190u8];
+            const SIGNATURE: &'static str = "InvalidQuoteTokenAmounts()";
 
             #[inline]
             fn new<'a>(
@@ -7094,13 +4905,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SignatureIsNotEmpty()` and selector `0x0e364efc`.
+    /**Custom error with signature `InvalidSignatureType()` and selector `0x60cd402d`.
     ```solidity
-    error SignatureIsNotEmpty();
+    error InvalidSignatureType();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct SignatureIsNotEmpty;
+    pub struct InvalidSignatureType;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7125,25 +4936,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<SignatureIsNotEmpty> for UnderlyingRustTuple<'_> {
-            fn from(value: SignatureIsNotEmpty) -> Self {
+        impl ::core::convert::From<InvalidSignatureType> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSignatureType) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureIsNotEmpty {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignatureType {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for SignatureIsNotEmpty {
+        impl alloy_sol_types::SolError for InvalidSignatureType {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [14u8, 54u8, 78u8, 252u8];
-            const SIGNATURE: &'static str = "SignatureIsNotEmpty()";
+            const SELECTOR: [u8; 4] = [96u8, 205u8, 64u8, 45u8];
+            const SIGNATURE: &'static str = "InvalidSignatureType()";
 
             #[inline]
             fn new<'a>(
@@ -7167,13 +4978,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `UpdatedMakerAmountsTooLow()` and selector `0x711dbe4a`.
+    /**Custom error with signature `InvalidSigner()` and selector `0x815e1d64`.
     ```solidity
-    error UpdatedMakerAmountsTooLow();
+    error InvalidSigner();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct UpdatedMakerAmountsTooLow;
+    pub struct InvalidSigner;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7198,25 +5009,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UpdatedMakerAmountsTooLow> for UnderlyingRustTuple<'_> {
-            fn from(value: UpdatedMakerAmountsTooLow) -> Self {
+        impl ::core::convert::From<InvalidSigner> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSigner) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UpdatedMakerAmountsTooLow {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSigner {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for UpdatedMakerAmountsTooLow {
+        impl alloy_sol_types::SolError for InvalidSigner {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [113u8, 29u8, 190u8, 74u8];
-            const SIGNATURE: &'static str = "UpdatedMakerAmountsTooLow()";
+            const SELECTOR: [u8; 4] = [129u8, 94u8, 29u8, 100u8];
+            const SIGNATURE: &'static str = "InvalidSigner()";
 
             #[inline]
             fn new<'a>(
@@ -7240,13 +5051,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ZeroMakerAmount()` and selector `0xb2f300d0`.
+    /**Custom error with signature `InvalidSource()` and selector `0x8154374b`.
     ```solidity
-    error ZeroMakerAmount();
+    error InvalidSource();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct ZeroMakerAmount;
+    pub struct InvalidSource;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7271,25 +5082,25 @@ pub mod LiquoriceSettlement {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<ZeroMakerAmount> for UnderlyingRustTuple<'_> {
-            fn from(value: ZeroMakerAmount) -> Self {
+        impl ::core::convert::From<InvalidSource> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSource) -> Self {
                 ()
             }
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroMakerAmount {
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSource {
             fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                 Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolError for ZeroMakerAmount {
+        impl alloy_sol_types::SolError for InvalidSource {
             type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [178u8, 243u8, 0u8, 208u8];
-            const SIGNATURE: &'static str = "ZeroMakerAmount()";
+            const SELECTOR: [u8; 4] = [129u8, 84u8, 55u8, 75u8];
+            const SIGNATURE: &'static str = "InvalidSource()";
 
             #[inline]
             fn new<'a>(
@@ -7313,25 +5124,13 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Interaction(address,uint256,bytes4)` and selector `0xed99827efb37016f2275f98c4bcf71c7551c75d59e9b450f79fa32e60be672c2`.
+    /**Custom error with signature `NonceInvalid()` and selector `0xbc0da7d6`.
     ```solidity
-    event Interaction(address indexed target, uint256 value, bytes4 selector);
+    error NonceInvalid();
     ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct Interaction {
-        #[allow(missing_docs)]
-        pub target: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub value: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub selector: alloy_sol_types::private::FixedBytes<4>,
-    }
+    pub struct NonceInvalid;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7340,333 +5139,188 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Interaction {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::FixedBytes<4>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Interaction(address,uint256,bytes4)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    237u8, 153u8, 130u8, 126u8, 251u8, 55u8, 1u8, 111u8, 34u8, 117u8, 249u8, 140u8,
-                    75u8, 207u8, 113u8, 199u8, 85u8, 28u8, 117u8, 213u8, 158u8, 155u8, 69u8, 15u8,
-                    121u8, 250u8, 50u8, 230u8, 11u8, 230u8, 114u8, 194u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    target: topics.1,
-                    value: data.0,
-                    selector: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
-            }
-
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.value),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
-                )
-            }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.target.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.target,
-                );
-                Ok(())
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Interaction {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
+        #[doc(hidden)]
+        impl ::core::convert::From<NonceInvalid> for UnderlyingRustTuple<'_> {
+            fn from(value: NonceInvalid) -> Self {
+                ()
             }
         }
         #[automatically_derived]
-        impl From<&Interaction> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Interaction) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NonceInvalid {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `TradeOrder(string,address,address,address,address,uint256,uint256,address)` and selector `0x0fce007c38c6c8ed9e545b3a148095762738618f8c21b673222613e4d45734b6`.
-    ```solidity
-    event TradeOrder(string indexed rfqId, address trader, address effectiveTrader, address baseToken, address quoteToken, uint256 baseTokenAmount, uint256 quoteTokenAmount, address recipient);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct TradeOrder {
-        #[allow(missing_docs)]
-        pub rfqId: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub trader: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub effectiveTrader: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub baseToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub quoteToken: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub baseTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub quoteTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for TradeOrder {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for NonceInvalid {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "TradeOrder(string,address,address,address,address,uint256,uint256,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    15u8, 206u8, 0u8, 124u8, 56u8, 198u8, 200u8, 237u8, 158u8, 84u8, 91u8, 58u8,
-                    20u8, 128u8, 149u8, 118u8, 39u8, 56u8, 97u8, 143u8, 140u8, 33u8, 182u8, 115u8,
-                    34u8, 38u8, 19u8, 228u8, 212u8, 87u8, 52u8, 182u8,
-                ]);
+            const SELECTOR: [u8; 4] = [188u8, 13u8, 167u8, 214u8];
+            const SIGNATURE: &'static str = "NonceInvalid()";
 
-            #[allow(unused_variables)]
             #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                Self {
-                    rfqId: topics.1,
-                    trader: data.0,
-                    effectiveTrader: data.1,
-                    baseToken: data.2,
-                    quoteToken: data.3,
-                    baseTokenAmount: data.4,
-                    quoteTokenAmount: data.5,
-                    recipient: data.6,
-                }
+                tuple.into()
             }
 
             #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
             }
 
             #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.trader,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.effectiveTrader,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.baseToken,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.quoteToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.baseTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.quoteTokenAmount,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
+                .map(Self::new)
             }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.rfqId.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
-                    32,
-                > as alloy_sol_types::EventTopic>::encode_topic(&self.rfqId);
-                Ok(())
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotMaker()` and selector `0xb331e421`.
+    ```solidity
+    error NotMaker();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct NotMaker;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for TradeOrder {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
+        #[doc(hidden)]
+        impl ::core::convert::From<NotMaker> for UnderlyingRustTuple<'_> {
+            fn from(value: NotMaker) -> Self {
+                ()
             }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotMaker {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl From<&TradeOrder> for alloy_sol_types::private::LogData {
+        impl alloy_sol_types::SolError for NotMaker {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [179u8, 49u8, 228u8, 33u8];
+            const SIGNATURE: &'static str = "NotMaker()";
+
             #[inline]
-            fn from(this: &TradeOrder) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
             }
         }
     };
-    /**Constructor`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `NotSolver()` and selector `0xc139eabd`.
     ```solidity
-    constructor(address authenticator_, address repository_, address permit2_);
+    error NotSolver();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub authenticator_: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub repository_: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub permit2_: alloy_sol_types::private::Address,
-    }
+    pub struct NotSolver;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value.authenticator_, value.repository_, value.permit2_)
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<NotSolver> for UnderlyingRustTuple<'_> {
+            fn from(value: NotSolver) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        authenticator_: tuple.0,
-                        repository_: tuple.1,
-                        permit2_: tuple.2,
-                    }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotSolver {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+        impl alloy_sol_types::SolError for NotSolver {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
+            const SELECTOR: [u8; 4] = [193u8, 57u8, 234u8, 189u8];
+            const SIGNATURE: &'static str = "NotSolver()";
+
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -7676,37 +5330,26 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.authenticator_,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.repository_,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.permit2_,
-                    ),
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `AUTHENTICATOR()` and selector `0xc6186181`.
+    /**Custom error with signature `OrderExpired()` and selector `0xc56873ba`.
     ```solidity
-    function AUTHENTICATOR() external view returns (address);
+    error OrderExpired();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct AUTHENTICATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`AUTHENTICATOR()`](AUTHENTICATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct AUTHENTICATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
+    pub struct OrderExpired;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7715,76 +5358,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<AUTHENTICATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: AUTHENTICATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for AUTHENTICATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<AUTHENTICATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: AUTHENTICATORReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<OrderExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: OrderExpired) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for AUTHENTICATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OrderExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for AUTHENTICATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolError for OrderExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [198u8, 24u8, 97u8, 129u8];
-            const SIGNATURE: &'static str = "AUTHENTICATOR()";
+            const SELECTOR: [u8; 4] = [197u8, 104u8, 115u8, 186u8];
+            const SIGNATURE: &'static str = "OrderExpired()";
 
             #[inline]
             fn new<'a>(
@@ -7799,49 +5407,95 @@ pub mod LiquoriceSettlement {
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `PartialFillNotSupported()` and selector `0x7d617bb3`.
+    ```solidity
+    error PartialFillNotSupported();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct PartialFillNotSupported;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<PartialFillNotSupported> for UnderlyingRustTuple<'_> {
+            fn from(value: PartialFillNotSupported) -> Self {
+                ()
             }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PartialFillNotSupported {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for PartialFillNotSupported {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [125u8, 97u8, 123u8, 179u8];
+            const SIGNATURE: &'static str = "PartialFillNotSupported()";
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: AUTHENTICATORReturn = r.into();
-                        r._0
-                    },
-                )
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: AUTHENTICATORReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `BALANCE_MANAGER()` and selector `0x29bcdc95`.
+    /**Custom error with signature `ReceiverNotManager()` and selector `0x79a1bff0`.
     ```solidity
-    function BALANCE_MANAGER() external view returns (address);
+    error ReceiverNotManager();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct BALANCE_MANAGERCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`BALANCE_MANAGER()`](BALANCE_MANAGERCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct BALANCE_MANAGERReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
+    pub struct ReceiverNotManager;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7850,76 +5504,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<BALANCE_MANAGERCall> for UnderlyingRustTuple<'_> {
-                fn from(value: BALANCE_MANAGERCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for BALANCE_MANAGERCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<BALANCE_MANAGERReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: BALANCE_MANAGERReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReceiverNotManager> for UnderlyingRustTuple<'_> {
+            fn from(value: ReceiverNotManager) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for BALANCE_MANAGERReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReceiverNotManager {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for BALANCE_MANAGERCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolError for ReceiverNotManager {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [41u8, 188u8, 220u8, 149u8];
-            const SIGNATURE: &'static str = "BALANCE_MANAGER()";
+            const SELECTOR: [u8; 4] = [121u8, 161u8, 191u8, 240u8];
+            const SIGNATURE: &'static str = "ReceiverNotManager()";
 
             #[inline]
             fn new<'a>(
@@ -7934,49 +5553,22 @@ pub mod LiquoriceSettlement {
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: BALANCE_MANAGERReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: BALANCE_MANAGERReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    /**Custom error with signature `ReentrancyGuardReentrantCall()` and selector `0x3ee5aeb5`.
     ```solidity
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    error ReentrancyGuardReentrantCall();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
+    pub struct ReentrancyGuardReentrantCall;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -7985,76 +5577,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ReentrancyGuardReentrantCall> for UnderlyingRustTuple<'_> {
+            fn from(value: ReentrancyGuardReentrantCall) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ReentrancyGuardReentrantCall {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
-            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+            const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
+            const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
 
             #[inline]
             fn new<'a>(
@@ -8069,52 +5626,24 @@ pub mod LiquoriceSettlement {
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DOMAIN_SEPARATORReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: DOMAIN_SEPARATORReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `REPOSITORY()` and selector `0x6f35d2d2`.
+    /**Custom error with signature `SafeERC20FailedOperation(address)` and selector `0x5274afe7`.
     ```solidity
-    function REPOSITORY() external view returns (address);
+    error SafeERC20FailedOperation(address token);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct REPOSITORYCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`REPOSITORY()`](REPOSITORYCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct REPOSITORYReturn {
+    pub struct SafeERC20FailedOperation {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
+        pub token: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -8124,76 +5653,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<REPOSITORYCall> for UnderlyingRustTuple<'_> {
-                fn from(value: REPOSITORYCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for REPOSITORYCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<REPOSITORYReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: REPOSITORYReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SafeERC20FailedOperation> for UnderlyingRustTuple<'_> {
+            fn from(value: SafeERC20FailedOperation) -> Self {
+                (value.token,)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for REPOSITORYReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeERC20FailedOperation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { token: tuple.0 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for REPOSITORYCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolError for SafeERC20FailedOperation {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [111u8, 53u8, 210u8, 210u8];
-            const SIGNATURE: &'static str = "REPOSITORY()";
+            const SELECTOR: [u8; 4] = [82u8, 116u8, 175u8, 231u8];
+            const SIGNATURE: &'static str = "SafeERC20FailedOperation(address)";
 
             #[inline]
             fn new<'a>(
@@ -8204,52 +5698,30 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: REPOSITORYReturn = r.into();
-                        r._0
-                    },
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
+                    ),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: REPOSITORYReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `cancelLimitOrder(uint256)` and selector `0xa5cdc8fc`.
+    /**Custom error with signature `SignatureIsExpired()` and selector `0x133df029`.
     ```solidity
-    function cancelLimitOrder(uint256 nonce) external;
+    error SignatureIsExpired();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct cancelLimitOrderCall {
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`cancelLimitOrder(uint256)`](cancelLimitOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct cancelLimitOrderReturn {}
+    pub struct SignatureIsExpired;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8258,83 +5730,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelLimitOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelLimitOrderCall) -> Self {
-                    (value.nonce,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { nonce: tuple.0 }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<cancelLimitOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: cancelLimitOrderReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelLimitOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureIsExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureIsExpired) -> Self {
+                ()
             }
         }
-        impl cancelLimitOrderReturn {
-            fn _tokenize(
-                &self,
-            ) -> <cancelLimitOrderCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureIsExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for cancelLimitOrderCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = cancelLimitOrderReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+        impl alloy_sol_types::SolError for SignatureIsExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [165u8, 205u8, 200u8, 252u8];
-            const SIGNATURE: &'static str = "cancelLimitOrder(uint256)";
+            const SELECTOR: [u8; 4] = [19u8, 61u8, 240u8, 41u8];
+            const SIGNATURE: &'static str = "SignatureIsExpired()";
 
             #[inline]
             fn new<'a>(
@@ -8345,55 +5775,26 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                cancelLimitOrderReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `hashBaseTokenData((address,uint256,uint256,uint256,uint256))` and selector `0x875530ff`.
+    /**Custom error with signature `SignatureIsNotEmpty()` and selector `0x0e364efc`.
     ```solidity
-    function hashBaseTokenData(ILiquoriceSettlement.BaseTokenData memory _baseTokenData) external pure returns (bytes32);
+    error SignatureIsNotEmpty();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct hashBaseTokenDataCall {
-        #[allow(missing_docs)]
-        pub _baseTokenData:
-            <ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hashBaseTokenData((address,uint256,uint256,uint256,
-    /// uint256))`](hashBaseTokenDataCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hashBaseTokenDataReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
+    pub struct SignatureIsNotEmpty;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8402,80 +5803,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::BaseTokenData,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashBaseTokenDataCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hashBaseTokenDataCall) -> Self {
-                    (value._baseTokenData,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashBaseTokenDataCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _baseTokenData: tuple.0,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashBaseTokenDataReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hashBaseTokenDataReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashBaseTokenDataReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureIsNotEmpty> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureIsNotEmpty) -> Self {
+                ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for hashBaseTokenDataCall {
-            type Parameters<'a> = (ILiquoriceSettlement::BaseTokenData,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureIsNotEmpty {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for SignatureIsNotEmpty {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [135u8, 85u8, 48u8, 255u8];
-            const SIGNATURE: &'static str =
-                "hashBaseTokenData((address,uint256,uint256,uint256,uint256))";
+            const SELECTOR: [u8; 4] = [14u8, 54u8, 78u8, 252u8];
+            const SIGNATURE: &'static str = "SignatureIsNotEmpty()";
 
             #[inline]
             fn new<'a>(
@@ -8486,66 +5848,26 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::tokenize(
-                        &self._baseTokenData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: hashBaseTokenDataReturn = r.into();
-                        r._0
-                    },
-                )
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: hashBaseTokenDataReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `hashOrder((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))` and selector `0xe242924e`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `UpdatedMakerAmountsTooLow()` and selector `0x711dbe4a`.
     ```solidity
-    function hashOrder(ILiquoriceSettlement.Order memory _order) external view returns (bytes32);
+    error UpdatedMakerAmountsTooLow();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct hashOrderCall {
-        #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hashOrder((address,uint256,string,uint256,address,address,uint256,
-    /// address,uint256,(address,uint256,uint256,uint256,uint256),(address,
-    /// uint256,uint256,uint256,uint256)))`](hashOrderCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hashOrderReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
+    pub struct UpdatedMakerAmountsTooLow;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8554,80 +5876,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Order,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hashOrderCall) -> Self {
-                    (value._order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _order: tuple.0 }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hashOrderReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UpdatedMakerAmountsTooLow> for UnderlyingRustTuple<'_> {
+            fn from(value: UpdatedMakerAmountsTooLow) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for UpdatedMakerAmountsTooLow {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for hashOrderCall {
-            type Parameters<'a> = (ILiquoriceSettlement::Order,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        impl alloy_sol_types::SolError for UpdatedMakerAmountsTooLow {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [226u8, 66u8, 146u8, 78u8];
-            const SIGNATURE: &'static str = "hashOrder((address,uint256,string,uint256,address,\
-                                             address,uint256,address,uint256,(address,uint256,\
-                                             uint256,uint256,uint256),(address,uint256,uint256,\
-                                             uint256,uint256)))";
+            const SELECTOR: [u8; 4] = [113u8, 29u8, 190u8, 74u8];
+            const SIGNATURE: &'static str = "UpdatedMakerAmountsTooLow()";
 
             #[inline]
             fn new<'a>(
@@ -8638,66 +5921,26 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: hashOrderReturn = r.into();
-                        r._0
-                    },
-                )
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: hashOrderReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `hashQuoteTokenData((address,uint256,uint256,uint256,uint256))` and selector `0x4c9e03d3`.
+    /**Custom error with signature `ZeroMakerAmount()` and selector `0xb2f300d0`.
     ```solidity
-    function hashQuoteTokenData(ILiquoriceSettlement.QuoteTokenData memory _quoteTokenData) external pure returns (bytes32);
+    error ZeroMakerAmount();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct hashQuoteTokenDataCall {
-        #[allow(missing_docs)]
-        pub _quoteTokenData:
-            <ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hashQuoteTokenData((address,uint256,uint256,uint256,
-    /// uint256))`](hashQuoteTokenDataCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hashQuoteTokenDataReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
+    pub struct ZeroMakerAmount;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -8706,80 +5949,41 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::QuoteTokenData,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashQuoteTokenDataCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hashQuoteTokenDataCall) -> Self {
-                    (value._quoteTokenData,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashQuoteTokenDataCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _quoteTokenData: tuple.0,
-                    }
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashQuoteTokenDataReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hashQuoteTokenDataReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashQuoteTokenDataReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<ZeroMakerAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: ZeroMakerAmount) -> Self {
+                ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for hashQuoteTokenDataCall {
-            type Parameters<'a> = (ILiquoriceSettlement::QuoteTokenData,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroMakerAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ZeroMakerAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [76u8, 158u8, 3u8, 211u8];
-            const SIGNATURE: &'static str =
-                "hashQuoteTokenData((address,uint256,uint256,uint256,uint256))";
+            const SELECTOR: [u8; 4] = [178u8, 243u8, 0u8, 208u8];
+            const SIGNATURE: &'static str = "ZeroMakerAmount()";
 
             #[inline]
             fn new<'a>(
@@ -8790,65 +5994,37 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::tokenize(
-                        &self._quoteTokenData,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: hashQuoteTokenDataReturn = r.into();
-                        r._0
-                    },
-                )
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: hashQuoteTokenDataReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))` and selector `0xb11f1262`.
+    /**Event with signature `Interaction(address,uint256,bytes4)` and selector `0xed99827efb37016f2275f98c4bcf71c7551c75d59e9b450f79fa32e60be672c2`.
     ```solidity
-    function hashSingleOrder(ILiquoriceSettlement.Single memory _order) external view returns (bytes32);
+    event Interaction(address indexed target, uint256 value, bytes4 selector);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct hashSingleOrderCall {
+    pub struct Interaction {
         #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`hashSingleOrder((string,uint256,address,address,address,address,
-    /// uint256,uint256,uint256,uint256,address))`](hashSingleOrderCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct hashSingleOrderReturn {
+        pub target: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
+        pub value: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub selector: alloy_sol_types::private::FixedBytes<4>,
     }
     #[allow(
         non_camel_case_types,
@@ -8858,148 +6034,133 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Single,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashSingleOrderCall> for UnderlyingRustTuple<'_> {
-                fn from(value: hashSingleOrderCall) -> Self {
-                    (value._order,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashSingleOrderCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _order: tuple.0 }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<hashSingleOrderReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: hashSingleOrderReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashSingleOrderReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for hashSingleOrderCall {
-            type Parameters<'a> = (ILiquoriceSettlement::Single,);
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for Interaction {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::FixedBytes<4>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [177u8, 31u8, 18u8, 98u8];
-            const SIGNATURE: &'static str = "hashSingleOrder((string,uint256,address,address,\
-                                             address,address,uint256,uint256,uint256,uint256,\
-                                             address))";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Interaction(address,uint256,bytes4)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    237u8, 153u8, 130u8, 126u8, 251u8, 55u8, 1u8, 111u8, 34u8, 117u8, 249u8, 140u8,
+                    75u8, 207u8, 113u8, 199u8, 85u8, 28u8, 117u8, 213u8, 158u8, 155u8, 69u8, 15u8,
+                    121u8, 250u8, 50u8, 230u8, 11u8, 230u8, 114u8, 194u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    target: topics.1,
+                    value: data.0,
+                    selector: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
-                    ),
-                )
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self.value),
                     <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
                 )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: hashSingleOrderReturn = r.into();
-                        r._0
-                    },
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.target.clone())
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: hashSingleOrderReturn = r.into();
-                    r._0
-                })
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.target,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Interaction {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Interaction> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Interaction) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
+    /**Event with signature `TradeOrder(string,address,address,address,address,uint256,uint256,address)` and selector `0x0fce007c38c6c8ed9e545b3a148095762738618f8c21b673222613e4d45734b6`.
     ```solidity
-    function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4);
+    event TradeOrder(string indexed rfqId, address trader, address effectiveTrader, address baseToken, address quoteToken, uint256 baseTokenAmount, uint256 quoteTokenAmount, address recipient);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct isValidSignatureCall {
+    pub struct TradeOrder {
+        #[allow(missing_docs)]
+        pub rfqId: alloy_sol_types::private::FixedBytes<32>,
+        #[allow(missing_docs)]
+        pub trader: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub effectiveTrader: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _hash: alloy_sol_types::private::FixedBytes<32>,
+        pub baseToken: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _signature: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct isValidSignatureReturn {
+        pub quoteToken: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<4>,
+        pub baseTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub quoteTokenAmount: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -9009,179 +6170,144 @@ pub mod LiquoriceSettlement {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignatureCall) -> Self {
-                    (value._hash, value._signature)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _hash: tuple.0,
-                        _signature: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: isValidSignatureReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for isValidSignatureCall {
-            type Parameters<'a> = (
+        impl alloy_sol_types::SolEvent for TradeOrder {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
                 alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Bytes,
             );
-            type Return = alloy_sol_types::private::FixedBytes<4>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
-            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "TradeOrder(string,address,address,address,address,uint256,uint256,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    15u8, 206u8, 0u8, 124u8, 56u8, 198u8, 200u8, 237u8, 158u8, 84u8, 91u8, 58u8,
+                    20u8, 128u8, 149u8, 118u8, 39u8, 56u8, 97u8, 143u8, 140u8, 33u8, 182u8, 115u8,
+                    34u8, 38u8, 19u8, 228u8, 212u8, 87u8, 52u8, 182u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    rfqId: topics.1,
+                    trader: data.0,
+                    effectiveTrader: data.1,
+                    baseToken: data.2,
+                    quoteToken: data.3,
+                    baseTokenAmount: data.4,
+                    quoteTokenAmount: data.5,
+                    recipient: data.6,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self._signature,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.trader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.effectiveTrader,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.baseToken,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteToken,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.baseTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.quoteTokenAmount,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        4,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.rfqId.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: isValidSignatureReturn = r.into();
-                        r._0
-                    },
-                )
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::FixedBytes<
+                    32,
+                > as alloy_sol_types::EventTopic>::encode_topic(&self.rfqId);
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for TradeOrder {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&TradeOrder> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: isValidSignatureReturn = r.into();
-                    r._0
-                })
+            fn from(this: &TradeOrder) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
-    #[derive()]
-    /**Function with signature `settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))` and selector `0xcba673a7`.
+    /**Constructor`.
     ```solidity
-    function settle(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct settleCall {
-        #[allow(missing_docs)]
-        pub _signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _interactions: alloy_sol_types::private::Vec<
-            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-    }
-    ///Container type for the return parameters of the
-    /// [`settle(address,uint256,(address,uint256,string,uint256,address,
-    /// address,uint256,address,uint256,(address,uint256,uint256,uint256,
-    /// uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,
-    /// bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,
-    /// uint8,bytes),(uint8,uint8,bytes))`](settleCall) function.
+    constructor(address authenticator_, address repository_, address permit2_);
+    ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub authenticator_: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub repository_: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub permit2_: alloy_sol_types::private::Address,
+    }
     const _: () = {
         use alloy_sol_types;
         {
@@ -9189,24 +6315,14 @@ pub mod LiquoriceSettlement {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                ILiquoriceSettlement::Order,
-                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
-                GPv2Interaction::Hooks,
-                Signature::TypedSignature,
-                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-                >,
-                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -9219,93 +6335,32 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settleCall) -> Self {
-                    (
-                        value._signer,
-                        value._filledTakerAmount,
-                        value._order,
-                        value._interactions,
-                        value._hooks,
-                        value._makerSignature,
-                        value._takerSignature,
-                    )
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value.authenticator_, value.repository_, value.permit2_)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        _signer: tuple.0,
-                        _filledTakerAmount: tuple.1,
-                        _order: tuple.2,
-                        _interactions: tuple.3,
-                        _hooks: tuple.4,
-                        _makerSignature: tuple.5,
-                        _takerSignature: tuple.6,
+                        authenticator_: tuple.0,
+                        repository_: tuple.1,
+                        permit2_: tuple.2,
                     }
                 }
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<settleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settleReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl settleReturn {
-            fn _tokenize(&self) -> <settleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for settleCall {
+        impl alloy_sol_types::SolConstructor for constructorCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                ILiquoriceSettlement::Order,
-                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
-                GPv2Interaction::Hooks,
-                Signature::TypedSignature,
-                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return = settleReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [203u8, 166u8, 115u8, 167u8];
-            const SIGNATURE: &'static str =
-                "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,\
-                 address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,\
-                 uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],\
-                 (address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -9317,75 +6372,35 @@ pub mod LiquoriceSettlement {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._signer,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self._filledTakerAmount),
-                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        GPv2Interaction::Data,
-                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
-                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(
-                        &self._hooks,
+                        &self.authenticator_,
                     ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._makerSignature,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.repository_,
                     ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._takerSignature,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.permit2_,
                     ),
                 )
             }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                settleReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
         }
     };
-    #[derive()]
-    /**Function with signature `settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))` and selector `0x9935c868`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `AUTHENTICATOR()` and selector `0xc6186181`.
     ```solidity
-    function settleSingle(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature) external payable;
+    function AUTHENTICATOR() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleSingleCall {
-        #[allow(missing_docs)]
-        pub _signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-    }
+    pub struct AUTHENTICATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`settleSingle(address,(string,uint256,address,address,address,address,
-    /// uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,
-    /// (uint8,uint8,bytes))`](settleSingleCall) function.
+    /// [`AUTHENTICATOR()`](AUTHENTICATORCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleSingleReturn {}
+    pub struct AUTHENTICATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -9397,21 +6412,9 @@ pub mod LiquoriceSettlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                ILiquoriceSettlement::Single,
-                Signature::TypedSignature,
-                alloy_sol_types::sol_data::Uint<256>,
-                Signature::TypedSignature,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9423,37 +6426,25 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleSingleCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settleSingleCall) -> Self {
-                    (
-                        value._signer,
-                        value._order,
-                        value._makerSignature,
-                        value._filledTakerAmount,
-                        value._takerSignature,
-                    )
+            impl ::core::convert::From<AUTHENTICATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: AUTHENTICATORCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for AUTHENTICATORCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _signer: tuple.0,
-                        _order: tuple.1,
-                        _makerSignature: tuple.2,
-                        _filledTakerAmount: tuple.3,
-                        _takerSignature: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9465,42 +6456,29 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleSingleReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settleSingleReturn) -> Self {
-                    ()
+            impl ::core::convert::From<AUTHENTICATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: AUTHENTICATORReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl settleSingleReturn {
-            fn _tokenize(&self) -> <settleSingleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for settleSingleCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                ILiquoriceSettlement::Single,
-                Signature::TypedSignature,
-                alloy_sol_types::sol_data::Uint<256>,
-                Signature::TypedSignature,
-            );
-            type Return = settleSingleReturn;
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for AUTHENTICATORReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for AUTHENTICATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [153u8, 53u8, 200u8, 104u8];
-            const SIGNATURE: &'static str =
-                "settleSingle(address,(string,uint256,address,address,address,address,uint256,\
-                 uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))";
+            const SELECTOR: [u8; 4] = [198u8, 24u8, 97u8, 129u8];
+            const SIGNATURE: &'static str = "AUTHENTICATOR()";
 
             #[inline]
             fn new<'a>(
@@ -9511,34 +6489,22 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._signer,
-                    ),
-                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
-                    ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._makerSignature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._filledTakerAmount,
-                    ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._takerSignature,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                settleSingleReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: AUTHENTICATORReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -9546,39 +6512,30 @@ pub mod LiquoriceSettlement {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: AUTHENTICATORReturn = r.into();
+                    r._0
+                })
             }
         }
     };
-    #[derive()]
-    /**Function with signature `settleSingleWithPermitsSignatures(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes),(bytes,uint48,uint48))` and selector `0xdb587728`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `BALANCE_MANAGER()` and selector `0x29bcdc95`.
     ```solidity
-    function settleSingleWithPermitsSignatures(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
+    function BALANCE_MANAGER() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleSingleWithPermitsSignaturesCall {
-        #[allow(missing_docs)]
-        pub _signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
-    }
+    pub struct BALANCE_MANAGERCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`settleSingleWithPermitsSignatures(address,(string,uint256,address,
-    /// address,address,address,uint256,uint256,uint256,uint256,address),(uint8,
-    /// uint8,bytes),uint256,(uint8,uint8,bytes),(bytes,uint48,
-    /// uint48))`](settleSingleWithPermitsSignaturesCall) function.
+    /// [`BALANCE_MANAGER()`](BALANCE_MANAGERCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleSingleWithPermitsSignaturesReturn {}
+    pub struct BALANCE_MANAGERReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -9590,23 +6547,9 @@ pub mod LiquoriceSettlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                ILiquoriceSettlement::Single,
-                Signature::TypedSignature,
-                alloy_sol_types::sol_data::Uint<256>,
-                Signature::TypedSignature,
-                Signature::TakerPermitInfo,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::primitives::aliases::U256,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-                <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9618,39 +6561,25 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleSingleWithPermitsSignaturesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settleSingleWithPermitsSignaturesCall) -> Self {
-                    (
-                        value._signer,
-                        value._order,
-                        value._makerSignature,
-                        value._filledTakerAmount,
-                        value._takerSignature,
-                        value._takerPermitInfo,
-                    )
+            impl ::core::convert::From<BALANCE_MANAGERCall> for UnderlyingRustTuple<'_> {
+                fn from(value: BALANCE_MANAGERCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleWithPermitsSignaturesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for BALANCE_MANAGERCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _signer: tuple.0,
-                        _order: tuple.1,
-                        _makerSignature: tuple.2,
-                        _filledTakerAmount: tuple.3,
-                        _takerSignature: tuple.4,
-                        _takerPermitInfo: tuple.5,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9662,47 +6591,29 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleSingleWithPermitsSignaturesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settleSingleWithPermitsSignaturesReturn) -> Self {
-                    ()
+            impl ::core::convert::From<BALANCE_MANAGERReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: BALANCE_MANAGERReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleWithPermitsSignaturesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for BALANCE_MANAGERReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl settleSingleWithPermitsSignaturesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for settleSingleWithPermitsSignaturesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                ILiquoriceSettlement::Single,
-                Signature::TypedSignature,
-                alloy_sol_types::sol_data::Uint<256>,
-                Signature::TypedSignature,
-                Signature::TakerPermitInfo,
-            );
-            type Return = settleSingleWithPermitsSignaturesReturn;
+        impl alloy_sol_types::SolCall for BALANCE_MANAGERCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [219u8, 88u8, 119u8, 40u8];
-            const SIGNATURE: &'static str = "settleSingleWithPermitsSignatures(address,(string,\
-                                             uint256,address,address,address,address,uint256,\
-                                             uint256,uint256,uint256,address),(uint8,uint8,bytes),\
-                                             uint256,(uint8,uint8,bytes),(bytes,uint48,uint48))";
+            const SELECTOR: [u8; 4] = [41u8, 188u8, 220u8, 149u8];
+            const SIGNATURE: &'static str = "BALANCE_MANAGER()";
 
             #[inline]
             fn new<'a>(
@@ -9713,37 +6624,22 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._signer,
-                    ),
-                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
-                    ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._makerSignature,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._filledTakerAmount,
-                    ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._takerSignature,
-                    ),
-                    <Signature::TakerPermitInfo as alloy_sol_types::SolType>::tokenize(
-                        &self._takerPermitInfo,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                settleSingleWithPermitsSignaturesReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: BALANCE_MANAGERReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -9751,47 +6647,30 @@ pub mod LiquoriceSettlement {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: BALANCE_MANAGERReturn = r.into();
+                    r._0
+                })
             }
         }
     };
-    #[derive()]
-    /**Function with signature `settleWithPermitsSignatures(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes),(bytes,uint48,uint48))` and selector `0x51d46815`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
     ```solidity
-    function settleWithPermitsSignatures(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature, Signature.TakerPermitInfo memory _takerPermitInfo) external payable;
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleWithPermitsSignaturesCall {
-        #[allow(missing_docs)]
-        pub _signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _interactions: alloy_sol_types::private::Vec<
-            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-        >,
-        #[allow(missing_docs)]
-        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
-    }
+    pub struct DOMAIN_SEPARATORCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`settleWithPermitsSignatures(address,uint256,(address,uint256,string,
-    /// uint256,address,address,uint256,address,uint256,(address,uint256,
-    /// uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),
-    /// (address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,
-    /// bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes),(bytes,uint48,
-    /// uint48))`](settleWithPermitsSignaturesCall) function.
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct settleWithPermitsSignaturesReturn {}
+    pub struct DOMAIN_SEPARATORReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -9803,29 +6682,9 @@ pub mod LiquoriceSettlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                ILiquoriceSettlement::Order,
-                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
-                GPv2Interaction::Hooks,
-                Signature::TypedSignature,
-                Signature::TypedSignature,
-                Signature::TakerPermitInfo,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-                >,
-                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-                <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9837,43 +6696,25 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleWithPermitsSignaturesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: settleWithPermitsSignaturesCall) -> Self {
-                    (
-                        value._signer,
-                        value._filledTakerAmount,
-                        value._order,
-                        value._interactions,
-                        value._hooks,
-                        value._makerSignature,
-                        value._takerSignature,
-                        value._takerPermitInfo,
-                    )
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleWithPermitsSignaturesCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _signer: tuple.0,
-                        _filledTakerAmount: tuple.1,
-                        _order: tuple.2,
-                        _interactions: tuple.3,
-                        _hooks: tuple.4,
-                        _makerSignature: tuple.5,
-                        _takerSignature: tuple.6,
-                        _takerPermitInfo: tuple.7,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -9885,51 +6726,29 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<settleWithPermitsSignaturesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: settleWithPermitsSignaturesReturn) -> Self {
-                    ()
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleWithPermitsSignaturesReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl settleWithPermitsSignaturesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for settleWithPermitsSignaturesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                ILiquoriceSettlement::Order,
-                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
-                GPv2Interaction::Hooks,
-                Signature::TypedSignature,
-                Signature::TypedSignature,
-                Signature::TakerPermitInfo,
-            );
-            type Return = settleWithPermitsSignaturesReturn;
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [81u8, 212u8, 104u8, 21u8];
-            const SIGNATURE: &'static str =
-                "settleWithPermitsSignatures(address,uint256,(address,uint256,string,uint256,\
-                 address,address,uint256,address,uint256,(address,uint256,uint256,uint256,\
-                 uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],\
-                 ((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,\
-                 uint8,bytes),(bytes,uint48,uint48))";
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
 
             #[inline]
             fn new<'a>(
@@ -9940,43 +6759,26 @@ pub mod LiquoriceSettlement {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._signer,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self._filledTakerAmount),
-                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        GPv2Interaction::Data,
-                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
-                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(
-                        &self._hooks,
-                    ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._makerSignature,
-                    ),
-                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._takerSignature,
-                    ),
-                    <Signature::TakerPermitInfo as alloy_sol_types::SolType>::tokenize(
-                        &self._takerPermitInfo,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                settleWithPermitsSignaturesReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: DOMAIN_SEPARATORReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -9984,29 +6786,35 @@ pub mod LiquoriceSettlement {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: DOMAIN_SEPARATORReturn = r.into();
+                    r._0
+                })
             }
         }
     };
-    #[derive()]
-    /**Function with signature `validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))` and selector `0x5aa0e95d`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `hashSingleOrder((string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address))` and selector `0xb11f1262`.
     ```solidity
-    function validateHooks(address _repository, GPv2Interaction.Hooks memory _hooks) external view;
+    function hashSingleOrder(ILiquoriceSettlement.Single memory _order) external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateHooksCall {
-        #[allow(missing_docs)]
-        pub _repository: alloy_sol_types::private::Address,
+    pub struct hashSingleOrderCall {
         #[allow(missing_docs)]
-        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`validateHooks(address,((address,uint256,bytes)[],(address,uint256,
-    /// bytes)[]))`](validateHooksCall) function.
+    /// [`hashSingleOrder((string,uint256,address,address,address,address,
+    /// uint256,uint256,uint256,uint256,address))`](hashSingleOrderCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateHooksReturn {}
+    pub struct hashSingleOrderReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -10018,13 +6826,10 @@ pub mod LiquoriceSettlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Address, GPv2Interaction::Hooks);
+            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Single,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-            );
+            type UnderlyingRustTuple<'a> =
+                (<ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -10036,28 +6841,25 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateHooksCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateHooksCall) -> Self {
-                    (value._repository, value._hooks)
+            impl ::core::convert::From<hashSingleOrderCall> for UnderlyingRustTuple<'_> {
+                fn from(value: hashSingleOrderCall) -> Self {
+                    (value._order,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateHooksCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashSingleOrderCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _repository: tuple.0,
-                        _hooks: tuple.1,
-                    }
+                    Self { _order: tuple.0 }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -10069,37 +6871,31 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateHooksReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateHooksReturn) -> Self {
-                    ()
+            impl ::core::convert::From<hashSingleOrderReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: hashSingleOrderReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateHooksReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashSingleOrderReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl validateHooksReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateHooksCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateHooksCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address, GPv2Interaction::Hooks);
-            type Return = validateHooksReturn;
+        impl alloy_sol_types::SolCall for hashSingleOrderCall {
+            type Parameters<'a> = (ILiquoriceSettlement::Single,);
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [90u8, 160u8, 233u8, 93u8];
-            const SIGNATURE: &'static str =
-                "validateHooks(address,((address,uint256,bytes)[],(address,uint256,bytes)[]))";
+            const SELECTOR: [u8; 4] = [177u8, 31u8, 18u8, 98u8];
+            const SIGNATURE: &'static str = "hashSingleOrder((string,uint256,address,address,\
+                                             address,address,uint256,uint256,uint256,uint256,\
+                                             address))";
 
             #[inline]
             fn new<'a>(
@@ -10111,22 +6907,29 @@ pub mod LiquoriceSettlement {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._repository,
+                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
                     ),
-                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(&self._hooks),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateHooksReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: hashSingleOrderReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -10134,39 +6937,35 @@ pub mod LiquoriceSettlement {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: hashSingleOrderReturn = r.into();
+                    r._0
+                })
             }
         }
     };
-    #[derive()]
-    /**Function with signature `validateInteractions(address,address,bool,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])` and selector `0xa7ab49bc`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `isValidSignature(bytes32,bytes)` and selector `0x1626ba7e`.
     ```solidity
-    function validateInteractions(address _repository, address _signer, bool _isPartialFill, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions) external view;
+    function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateInteractionsCall {
-        #[allow(missing_docs)]
-        pub _repository: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _signer: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _isPartialFill: bool,
+    pub struct isValidSignatureCall {
         #[allow(missing_docs)]
-        pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        pub _hash: alloy_sol_types::private::FixedBytes<32>,
         #[allow(missing_docs)]
-        pub _interactions: alloy_sol_types::private::Vec<
-            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-        >,
+        pub _signature: alloy_sol_types::private::Bytes,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`validateInteractions(address,address,bool,(address,uint256,string,
-    /// uint256,address,address,uint256,address,uint256,(address,uint256,
-    /// uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),
-    /// (address,uint256,bytes)[])`](validateInteractionsCall) function.
+    /// [`isValidSignature(bytes32,bytes)`](isValidSignatureCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateInteractionsReturn {}
+    pub struct isValidSignatureReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::FixedBytes<4>,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -10179,21 +6978,13 @@ pub mod LiquoriceSettlement {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                ILiquoriceSettlement::Order,
-                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                bool,
-                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-                >,
+                alloy_sol_types::private::FixedBytes<32>,
+                alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -10206,27 +6997,18 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateInteractionsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateInteractionsCall) -> Self {
-                    (
-                        value._repository,
-                        value._signer,
-                        value._isPartialFill,
-                        value._order,
-                        value._interactions,
-                    )
+            impl ::core::convert::From<isValidSignatureCall> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureCall) -> Self {
+                    (value._hash, value._signature)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateInteractionsCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        _repository: tuple.0,
-                        _signer: tuple.1,
-                        _isPartialFill: tuple.2,
-                        _order: tuple.3,
-                        _interactions: tuple.4,
+                        _hash: tuple.0,
+                        _signature: tuple.1,
                     }
                 }
             }
@@ -10234,9 +7016,9 @@ pub mod LiquoriceSettlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<4>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -10248,46 +7030,32 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateInteractionsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateInteractionsReturn) -> Self {
-                    ()
+            impl ::core::convert::From<isValidSignatureReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: isValidSignatureReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateInteractionsReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isValidSignatureReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl validateInteractionsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateInteractionsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateInteractionsCall {
+        impl alloy_sol_types::SolCall for isValidSignatureCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                ILiquoriceSettlement::Order,
-                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Bytes,
             );
-            type Return = validateInteractionsReturn;
+            type Return = alloy_sol_types::private::FixedBytes<4>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<4>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [167u8, 171u8, 73u8, 188u8];
-            const SIGNATURE: &'static str =
-                "validateInteractions(address,address,bool,(address,uint256,string,uint256,\
-                 address,address,uint256,address,uint256,(address,uint256,uint256,uint256,\
-                 uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[])";
+            const SELECTOR: [u8; 4] = [22u8, 38u8, 186u8, 126u8];
+            const SIGNATURE: &'static str = "isValidSignature(bytes32,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -10299,33 +7067,32 @@ pub mod LiquoriceSettlement {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._repository,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._signer,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self._isPartialFill,
-                    ),
-                    <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
-                        &self._order,
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self._signature,
                     ),
-                    <alloy_sol_types::sol_data::Array<
-                        GPv2Interaction::Data,
-                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateInteractionsReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        4,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: isValidSignatureReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -10333,29 +7100,47 @@ pub mod LiquoriceSettlement {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: isValidSignatureReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive()]
-    /**Function with signature `validateOrderAmounts((address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)))` and selector `0xfa5cd56c`.
+    /**Function with signature `settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))` and selector `0xcba673a7`.
     ```solidity
-    function validateOrderAmounts(ILiquoriceSettlement.Order memory _order) external pure;
+    function settle(address _signer, uint256 _filledTakerAmount, ILiquoriceSettlement.Order memory _order, GPv2Interaction.Data[] memory _interactions, GPv2Interaction.Hooks memory _hooks, Signature.TypedSignature memory _makerSignature, Signature.TypedSignature memory _takerSignature) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateOrderAmountsCall {
+    pub struct settleCall {
+        #[allow(missing_docs)]
+        pub _signer: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _interactions: alloy_sol_types::private::Vec<
+            <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+        >,
+        #[allow(missing_docs)]
+        pub _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
     }
     ///Container type for the return parameters of the
-    /// [`validateOrderAmounts((address,uint256,string,uint256,address,address,
-    /// uint256,address,uint256,(address,uint256,uint256,uint256,uint256),
-    /// (address,uint256,uint256,uint256,uint256)))`](validateOrderAmountsCall)
-    /// function.
+    /// [`settle(address,uint256,(address,uint256,string,uint256,address,
+    /// address,uint256,address,uint256,(address,uint256,uint256,uint256,
+    /// uint256),(address,uint256,uint256,uint256,uint256)),(address,uint256,
+    /// bytes)[],((address,uint256,bytes)[],(address,uint256,bytes)[]),(uint8,
+    /// uint8,bytes),(uint8,uint8,bytes))`](settleCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateOrderAmountsReturn {}
+    pub struct settleReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -10367,10 +7152,27 @@ pub mod LiquoriceSettlement {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (ILiquoriceSettlement::Order,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                GPv2Interaction::Hooks,
+                Signature::TypedSignature,
+                Signature::TypedSignature,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> =
-                (<ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::Vec<
+                    <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
+                >,
+                <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -10382,16 +7184,32 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateOrderAmountsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateOrderAmountsCall) -> Self {
-                    (value._order,)
+            impl ::core::convert::From<settleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleCall) -> Self {
+                    (
+                        value._signer,
+                        value._filledTakerAmount,
+                        value._order,
+                        value._interactions,
+                        value._hooks,
+                        value._makerSignature,
+                        value._takerSignature,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateOrderAmountsCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _order: tuple.0 }
+                    Self {
+                        _signer: tuple.0,
+                        _filledTakerAmount: tuple.1,
+                        _order: tuple.2,
+                        _interactions: tuple.3,
+                        _hooks: tuple.4,
+                        _makerSignature: tuple.5,
+                        _takerSignature: tuple.6,
+                    }
                 }
             }
         }
@@ -10412,40 +7230,46 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateOrderAmountsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateOrderAmountsReturn) -> Self {
+            impl ::core::convert::From<settleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateOrderAmountsReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl validateOrderAmountsReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateOrderAmountsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+        impl settleReturn {
+            fn _tokenize(&self) -> <settleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateOrderAmountsCall {
-            type Parameters<'a> = (ILiquoriceSettlement::Order,);
-            type Return = validateOrderAmountsReturn;
+        impl alloy_sol_types::SolCall for settleCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                ILiquoriceSettlement::Order,
+                alloy_sol_types::sol_data::Array<GPv2Interaction::Data>,
+                GPv2Interaction::Hooks,
+                Signature::TypedSignature,
+                Signature::TypedSignature,
+            );
+            type Return = settleReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [250u8, 92u8, 213u8, 108u8];
-            const SIGNATURE: &'static str = "validateOrderAmounts((address,uint256,string,uint256,\
-                                             address,address,uint256,address,uint256,(address,\
-                                             uint256,uint256,uint256,uint256),(address,uint256,\
-                                             uint256,uint256,uint256)))";
+            const SELECTOR: [u8; 4] = [203u8, 166u8, 115u8, 167u8];
+            const SIGNATURE: &'static str =
+                "settle(address,uint256,(address,uint256,string,uint256,address,address,uint256,\
+                 address,uint256,(address,uint256,uint256,uint256,uint256),(address,uint256,\
+                 uint256,uint256,uint256)),(address,uint256,bytes)[],((address,uint256,bytes)[],\
+                 (address,uint256,bytes)[]),(uint8,uint8,bytes),(uint8,uint8,bytes))";
 
             #[inline]
             fn new<'a>(
@@ -10457,15 +7281,33 @@ pub mod LiquoriceSettlement {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._signer,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<
+                        256,
+                    > as alloy_sol_types::SolType>::tokenize(&self._filledTakerAmount),
                     <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::tokenize(
                         &self._order,
                     ),
+                    <alloy_sol_types::sol_data::Array<
+                        GPv2Interaction::Data,
+                    > as alloy_sol_types::SolType>::tokenize(&self._interactions),
+                    <GPv2Interaction::Hooks as alloy_sol_types::SolType>::tokenize(
+                        &self._hooks,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._makerSignature,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._takerSignature,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateOrderAmountsReturn::_tokenize(ret)
+                settleReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -10484,26 +7326,31 @@ pub mod LiquoriceSettlement {
         }
     };
     #[derive()]
-    /**Function with signature `validateSignature(address,bytes32,(uint8,uint8,bytes))` and selector `0xae80c584`.
+    /**Function with signature `settleSingle(address,(string,uint256,address,address,address,address,uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))` and selector `0x9935c868`.
     ```solidity
-    function validateSignature(address _validationAddress, bytes32 _hash, Signature.TypedSignature memory _signature) external view;
+    function settleSingle(address _signer, ILiquoriceSettlement.Single memory _order, Signature.TypedSignature memory _makerSignature, uint256 _filledTakerAmount, Signature.TypedSignature memory _takerSignature) external payable;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateSignatureCall {
+    pub struct settleSingleCall {
         #[allow(missing_docs)]
-        pub _validationAddress: alloy_sol_types::private::Address,
+        pub _signer: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _hash: alloy_sol_types::private::FixedBytes<32>,
+        pub _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        #[allow(missing_docs)]
+        pub _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub _signature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+        pub _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
     }
     ///Container type for the return parameters of the
-    /// [`validateSignature(address,bytes32,(uint8,uint8,
-    /// bytes))`](validateSignatureCall) function.
+    /// [`settleSingle(address,(string,uint256,address,address,address,address,
+    /// uint256,uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,
+    /// (uint8,uint8,bytes))`](settleSingleCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct validateSignatureReturn {}
+    pub struct settleSingleReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -10517,13 +7364,17 @@ pub mod LiquoriceSettlement {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::FixedBytes<32>,
+                ILiquoriceSettlement::Single,
+                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Uint<256>,
                 Signature::TypedSignature,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::FixedBytes<32>,
+                <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
+                <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
+                alloy_sol_types::private::primitives::aliases::U256,
                 <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
             );
             #[cfg(test)]
@@ -10537,19 +7388,27 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateSignatureCall> for UnderlyingRustTuple<'_> {
-                fn from(value: validateSignatureCall) -> Self {
-                    (value._validationAddress, value._hash, value._signature)
+            impl ::core::convert::From<settleSingleCall> for UnderlyingRustTuple<'_> {
+                fn from(value: settleSingleCall) -> Self {
+                    (
+                        value._signer,
+                        value._order,
+                        value._makerSignature,
+                        value._filledTakerAmount,
+                        value._takerSignature,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateSignatureCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        _validationAddress: tuple.0,
-                        _hash: tuple.1,
-                        _signature: tuple.2,
+                        _signer: tuple.0,
+                        _order: tuple.1,
+                        _makerSignature: tuple.2,
+                        _filledTakerAmount: tuple.3,
+                        _takerSignature: tuple.4,
                     }
                 }
             }
@@ -10571,41 +7430,42 @@ pub mod LiquoriceSettlement {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<validateSignatureReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: validateSignatureReturn) -> Self {
+            impl ::core::convert::From<settleSingleReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: settleSingleReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateSignatureReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for settleSingleReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl validateSignatureReturn {
-            fn _tokenize(
-                &self,
-            ) -> <validateSignatureCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl settleSingleReturn {
+            fn _tokenize(&self) -> <settleSingleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for validateSignatureCall {
+        impl alloy_sol_types::SolCall for settleSingleCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::FixedBytes<32>,
+                ILiquoriceSettlement::Single,
+                Signature::TypedSignature,
+                alloy_sol_types::sol_data::Uint<256>,
                 Signature::TypedSignature,
             );
-            type Return = validateSignatureReturn;
+            type Return = settleSingleReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [174u8, 128u8, 197u8, 132u8];
+            const SELECTOR: [u8; 4] = [153u8, 53u8, 200u8, 104u8];
             const SIGNATURE: &'static str =
-                "validateSignature(address,bytes32,(uint8,uint8,bytes))";
+                "settleSingle(address,(string,uint256,address,address,address,address,uint256,\
+                 uint256,uint256,uint256,address),(uint8,uint8,bytes),uint256,(uint8,uint8,bytes))";
 
             #[inline]
             fn new<'a>(
@@ -10618,20 +7478,26 @@ pub mod LiquoriceSettlement {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._validationAddress,
+                        &self._signer,
+                    ),
+                    <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::tokenize(
+                        &self._order,
                     ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self._hash),
                     <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
-                        &self._signature,
+                        &self._makerSignature,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._filledTakerAmount,
+                    ),
+                    <Signature::TypedSignature as alloy_sol_types::SolType>::tokenize(
+                        &self._takerSignature,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                validateSignatureReturn::_tokenize(ret)
+                settleSingleReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -10659,16 +7525,6 @@ pub mod LiquoriceSettlement {
         #[allow(missing_docs)]
         DOMAIN_SEPARATOR(DOMAIN_SEPARATORCall),
         #[allow(missing_docs)]
-        REPOSITORY(REPOSITORYCall),
-        #[allow(missing_docs)]
-        cancelLimitOrder(cancelLimitOrderCall),
-        #[allow(missing_docs)]
-        hashBaseTokenData(hashBaseTokenDataCall),
-        #[allow(missing_docs)]
-        hashOrder(hashOrderCall),
-        #[allow(missing_docs)]
-        hashQuoteTokenData(hashQuoteTokenDataCall),
-        #[allow(missing_docs)]
         hashSingleOrder(hashSingleOrderCall),
         #[allow(missing_docs)]
         isValidSignature(isValidSignatureCall),
@@ -10676,18 +7532,6 @@ pub mod LiquoriceSettlement {
         settle(settleCall),
         #[allow(missing_docs)]
         settleSingle(settleSingleCall),
-        #[allow(missing_docs)]
-        settleSingleWithPermitsSignatures(settleSingleWithPermitsSignaturesCall),
-        #[allow(missing_docs)]
-        settleWithPermitsSignatures(settleWithPermitsSignaturesCall),
-        #[allow(missing_docs)]
-        validateHooks(validateHooksCall),
-        #[allow(missing_docs)]
-        validateInteractions(validateInteractionsCall),
-        #[allow(missing_docs)]
-        validateOrderAmounts(validateOrderAmountsCall),
-        #[allow(missing_docs)]
-        validateSignature(validateSignatureCall),
     }
     impl LiquoriceSettlementCalls {
         /// All the selectors of this enum.
@@ -10701,63 +7545,30 @@ pub mod LiquoriceSettlement {
             [22u8, 38u8, 186u8, 126u8],
             [41u8, 188u8, 220u8, 149u8],
             [54u8, 68u8, 229u8, 21u8],
-            [76u8, 158u8, 3u8, 211u8],
-            [81u8, 212u8, 104u8, 21u8],
-            [90u8, 160u8, 233u8, 93u8],
-            [111u8, 53u8, 210u8, 210u8],
-            [135u8, 85u8, 48u8, 255u8],
             [153u8, 53u8, 200u8, 104u8],
-            [165u8, 205u8, 200u8, 252u8],
-            [167u8, 171u8, 73u8, 188u8],
-            [174u8, 128u8, 197u8, 132u8],
             [177u8, 31u8, 18u8, 98u8],
             [198u8, 24u8, 97u8, 129u8],
             [203u8, 166u8, 115u8, 167u8],
-            [219u8, 88u8, 119u8, 40u8],
-            [226u8, 66u8, 146u8, 78u8],
-            [250u8, 92u8, 213u8, 108u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <isValidSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
             <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateHooksCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <REPOSITORYCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <hashBaseTokenDataCall as alloy_sol_types::SolCall>::SIGNATURE,
             <settleSingleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <cancelLimitOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateInteractionsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateSignatureCall as alloy_sol_types::SolCall>::SIGNATURE,
             <hashSingleOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
             <AUTHENTICATORCall as alloy_sol_types::SolCall>::SIGNATURE,
             <settleCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <hashOrderCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <validateOrderAmountsCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(isValidSignature),
             ::core::stringify!(BALANCE_MANAGER),
             ::core::stringify!(DOMAIN_SEPARATOR),
-            ::core::stringify!(hashQuoteTokenData),
-            ::core::stringify!(settleWithPermitsSignatures),
-            ::core::stringify!(validateHooks),
-            ::core::stringify!(REPOSITORY),
-            ::core::stringify!(hashBaseTokenData),
             ::core::stringify!(settleSingle),
-            ::core::stringify!(cancelLimitOrder),
-            ::core::stringify!(validateInteractions),
-            ::core::stringify!(validateSignature),
             ::core::stringify!(hashSingleOrder),
             ::core::stringify!(AUTHENTICATOR),
             ::core::stringify!(settle),
-            ::core::stringify!(settleSingleWithPermitsSignatures),
-            ::core::stringify!(hashOrder),
-            ::core::stringify!(validateOrderAmounts),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -10782,7 +7593,7 @@ pub mod LiquoriceSettlement {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for LiquoriceSettlementCalls {
-        const COUNT: usize = 18usize;
+        const COUNT: usize = 7usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "LiquoriceSettlementCalls";
 
@@ -10796,17 +7607,6 @@ pub mod LiquoriceSettlement {
                 Self::DOMAIN_SEPARATOR(_) => {
                     <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::REPOSITORY(_) => <REPOSITORYCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::cancelLimitOrder(_) => {
-                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::hashBaseTokenData(_) => {
-                    <hashBaseTokenDataCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::hashOrder(_) => <hashOrderCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::hashQuoteTokenData(_) => {
-                    <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::hashSingleOrder(_) => {
                     <hashSingleOrderCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -10815,22 +7615,6 @@ pub mod LiquoriceSettlement {
                 }
                 Self::settle(_) => <settleCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::settleSingle(_) => <settleSingleCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::settleSingleWithPermitsSignatures(_) => {
-                    <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::settleWithPermitsSignatures(_) => {
-                    <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateHooks(_) => <validateHooksCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::validateInteractions(_) => {
-                    <validateInteractionsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateOrderAmounts(_) => {
-                    <validateOrderAmountsCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::validateSignature(_) => {
-                    <validateSignatureCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -10878,53 +7662,6 @@ pub mod LiquoriceSettlement {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn hashQuoteTokenData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::hashQuoteTokenData)
-                    }
-                    hashQuoteTokenData
-                },
-                {
-                    fn settleWithPermitsSignatures(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::settleWithPermitsSignatures)
-                    }
-                    settleWithPermitsSignatures
-                },
-                {
-                    fn validateHooks(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateHooksCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::validateHooks)
-                    }
-                    validateHooks
-                },
-                {
-                    fn REPOSITORY(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <REPOSITORYCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::REPOSITORY)
-                    }
-                    REPOSITORY
-                },
-                {
-                    fn hashBaseTokenData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::hashBaseTokenData)
-                    }
-                    hashBaseTokenData
-                },
                 {
                     fn settleSingle(
                         data: &[u8],
@@ -10934,33 +7671,6 @@ pub mod LiquoriceSettlement {
                     }
                     settleSingle
                 },
-                {
-                    fn cancelLimitOrder(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::cancelLimitOrder)
-                    }
-                    cancelLimitOrder
-                },
-                {
-                    fn validateInteractions(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateInteractionsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::validateInteractions)
-                    }
-                    validateInteractions
-                },
-                {
-                    fn validateSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::validateSignature)
-                    }
-                    validateSignature
-                },
                 {
                     fn hashSingleOrder(
                         data: &[u8],
@@ -10980,40 +7690,11 @@ pub mod LiquoriceSettlement {
                     AUTHENTICATOR
                 },
                 {
-                    fn settle(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <settleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::settle)
-                    }
-                    settle
-                },
-                {
-                    fn settleSingleWithPermitsSignatures(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                LiquoriceSettlementCalls::settleSingleWithPermitsSignatures,
-                            )
-                    }
-                    settleSingleWithPermitsSignatures
-                },
-                {
-                    fn hashOrder(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <hashOrderCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::hashOrder)
-                    }
-                    hashOrder
-                },
-                {
-                    fn validateOrderAmounts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(LiquoriceSettlementCalls::validateOrderAmounts)
+                    fn settle(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
+                        <settleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(LiquoriceSettlementCalls::settle)
                     }
-                    validateOrderAmounts
+                    settle
                 },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
@@ -11069,59 +7750,6 @@ pub mod LiquoriceSettlement {
                     }
                     DOMAIN_SEPARATOR
                 },
-                {
-                    fn hashQuoteTokenData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::hashQuoteTokenData)
-                    }
-                    hashQuoteTokenData
-                },
-                {
-                    fn settleWithPermitsSignatures(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::settleWithPermitsSignatures)
-                    }
-                    settleWithPermitsSignatures
-                },
-                {
-                    fn validateHooks(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateHooksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(LiquoriceSettlementCalls::validateHooks)
-                    }
-                    validateHooks
-                },
-                {
-                    fn REPOSITORY(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <REPOSITORYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(LiquoriceSettlementCalls::REPOSITORY)
-                    }
-                    REPOSITORY
-                },
-                {
-                    fn hashBaseTokenData(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::hashBaseTokenData)
-                    }
-                    hashBaseTokenData
-                },
                 {
                     fn settleSingle(
                         data: &[u8],
@@ -11133,39 +7761,6 @@ pub mod LiquoriceSettlement {
                     }
                     settleSingle
                 },
-                {
-                    fn cancelLimitOrder(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(LiquoriceSettlementCalls::cancelLimitOrder)
-                    }
-                    cancelLimitOrder
-                },
-                {
-                    fn validateInteractions(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateInteractionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::validateInteractions)
-                    }
-                    validateInteractions
-                },
-                {
-                    fn validateSignature(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateSignatureCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::validateSignature)
-                    }
-                    validateSignature
-                },
                 {
                     fn hashSingleOrder(
                         data: &[u8],
@@ -11195,37 +7790,6 @@ pub mod LiquoriceSettlement {
                     }
                     settle
                 },
-                {
-                    fn settleSingleWithPermitsSignatures(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                LiquoriceSettlementCalls::settleSingleWithPermitsSignatures,
-                            )
-                    }
-                    settleSingleWithPermitsSignatures
-                },
-                {
-                    fn hashOrder(data: &[u8]) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <hashOrderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(LiquoriceSettlementCalls::hashOrder)
-                    }
-                    hashOrder
-                },
-                {
-                    fn validateOrderAmounts(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<LiquoriceSettlementCalls> {
-                        <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(LiquoriceSettlementCalls::validateOrderAmounts)
-                    }
-                    validateOrderAmounts
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -11240,88 +7804,25 @@ pub mod LiquoriceSettlement {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::AUTHENTICATOR(inner) => {
-                    <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::BALANCE_MANAGER(inner) => {
-                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::DOMAIN_SEPARATOR(inner) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::REPOSITORY(inner) => {
-                    <REPOSITORYCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::cancelLimitOrder(inner) => {
-                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::hashBaseTokenData(inner) => {
-                    <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::hashOrder(inner) => {
-                    <hashOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::hashQuoteTokenData(inner) => {
-                    <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::hashSingleOrder(inner) => {
-                    <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::isValidSignature(inner) => {
-                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::settle(inner) => {
                     <settleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::settleSingle(inner) => {
-                    <settleSingleCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::settleSingleWithPermitsSignatures(inner) => {
-                    <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::settleWithPermitsSignatures(inner) => {
-                    <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateHooks(inner) => {
-                    <validateHooksCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateInteractions(inner) => {
-                    <validateInteractionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateOrderAmounts(inner) => {
-                    <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::validateSignature(inner) => {
-                    <validateSignatureCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <settleSingleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
             }
         }
@@ -11330,109 +7831,25 @@ pub mod LiquoriceSettlement {
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
                 Self::AUTHENTICATOR(inner) => {
-                    <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <AUTHENTICATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::BALANCE_MANAGER(inner) => {
-                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <BALANCE_MANAGERCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::DOMAIN_SEPARATOR(inner) => {
-                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::REPOSITORY(inner) => {
-                    <REPOSITORYCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::cancelLimitOrder(inner) => {
-                    <cancelLimitOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::hashBaseTokenData(inner) => {
-                    <hashBaseTokenDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::hashOrder(inner) => {
-                    <hashOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::hashQuoteTokenData(inner) => {
-                    <hashQuoteTokenDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::hashSingleOrder(inner) => {
-                    <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <hashSingleOrderCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::isValidSignature(inner) => {
-                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <isValidSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::settle(inner) => {
                     <settleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::settleSingle(inner) => {
-                    <settleSingleCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::settleSingleWithPermitsSignatures(inner) => {
-                    <settleSingleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::settleWithPermitsSignatures(inner) => {
-                    <settleWithPermitsSignaturesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::validateHooks(inner) => {
-                    <validateHooksCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::validateInteractions(inner) => {
-                    <validateInteractionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::validateOrderAmounts(inner) => {
-                    <validateOrderAmountsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::validateSignature(inner) => {
-                    <validateSignatureCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <settleSingleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
             }
         }
@@ -13057,43 +9474,6 @@ pub mod LiquoriceSettlement {
             self.call_builder(&DOMAIN_SEPARATORCall)
         }
 
-        ///Creates a new call builder for the [`REPOSITORY`] function.
-        pub fn REPOSITORY(&self) -> alloy_contract::SolCallBuilder<&P, REPOSITORYCall, N> {
-            self.call_builder(&REPOSITORYCall)
-        }
-
-        ///Creates a new call builder for the [`cancelLimitOrder`] function.
-        pub fn cancelLimitOrder(
-            &self,
-            nonce: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, cancelLimitOrderCall, N> {
-            self.call_builder(&cancelLimitOrderCall { nonce })
-        }
-
-        ///Creates a new call builder for the [`hashBaseTokenData`] function.
-        pub fn hashBaseTokenData(
-            &self,
-            _baseTokenData: <ILiquoriceSettlement::BaseTokenData as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, hashBaseTokenDataCall, N> {
-            self.call_builder(&hashBaseTokenDataCall { _baseTokenData })
-        }
-
-        ///Creates a new call builder for the [`hashOrder`] function.
-        pub fn hashOrder(
-            &self,
-            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, hashOrderCall, N> {
-            self.call_builder(&hashOrderCall { _order })
-        }
-
-        ///Creates a new call builder for the [`hashQuoteTokenData`] function.
-        pub fn hashQuoteTokenData(
-            &self,
-            _quoteTokenData: <ILiquoriceSettlement::QuoteTokenData as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, hashQuoteTokenDataCall, N> {
-            self.call_builder(&hashQuoteTokenDataCall { _quoteTokenData })
-        }
-
         ///Creates a new call builder for the [`hashSingleOrder`] function.
         pub fn hashSingleOrder(
             &self,
@@ -13152,110 +9532,6 @@ pub mod LiquoriceSettlement {
                 _takerSignature,
             })
         }
-
-        ///Creates a new call builder for the
-        /// [`settleSingleWithPermitsSignatures`] function.
-        pub fn settleSingleWithPermitsSignatures(
-            &self,
-            _signer: alloy_sol_types::private::Address,
-            _order: <ILiquoriceSettlement::Single as alloy_sol_types::SolType>::RustType,
-            _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-            _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
-            _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-            _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, settleSingleWithPermitsSignaturesCall, N> {
-            self.call_builder(&settleSingleWithPermitsSignaturesCall {
-                _signer,
-                _order,
-                _makerSignature,
-                _filledTakerAmount,
-                _takerSignature,
-                _takerPermitInfo,
-            })
-        }
-
-        ///Creates a new call builder for the [`settleWithPermitsSignatures`]
-        /// function.
-        pub fn settleWithPermitsSignatures(
-            &self,
-            _signer: alloy_sol_types::private::Address,
-            _filledTakerAmount: alloy_sol_types::private::primitives::aliases::U256,
-            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-            _interactions: alloy_sol_types::private::Vec<
-                <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-            >,
-            _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-            _makerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-            _takerSignature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-            _takerPermitInfo: <Signature::TakerPermitInfo as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, settleWithPermitsSignaturesCall, N> {
-            self.call_builder(&settleWithPermitsSignaturesCall {
-                _signer,
-                _filledTakerAmount,
-                _order,
-                _interactions,
-                _hooks,
-                _makerSignature,
-                _takerSignature,
-                _takerPermitInfo,
-            })
-        }
-
-        ///Creates a new call builder for the [`validateHooks`] function.
-        pub fn validateHooks(
-            &self,
-            _repository: alloy_sol_types::private::Address,
-            _hooks: <GPv2Interaction::Hooks as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, validateHooksCall, N> {
-            self.call_builder(&validateHooksCall {
-                _repository,
-                _hooks,
-            })
-        }
-
-        ///Creates a new call builder for the [`validateInteractions`]
-        /// function.
-        pub fn validateInteractions(
-            &self,
-            _repository: alloy_sol_types::private::Address,
-            _signer: alloy_sol_types::private::Address,
-            _isPartialFill: bool,
-            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-            _interactions: alloy_sol_types::private::Vec<
-                <GPv2Interaction::Data as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, validateInteractionsCall, N> {
-            self.call_builder(&validateInteractionsCall {
-                _repository,
-                _signer,
-                _isPartialFill,
-                _order,
-                _interactions,
-            })
-        }
-
-        ///Creates a new call builder for the [`validateOrderAmounts`]
-        /// function.
-        pub fn validateOrderAmounts(
-            &self,
-            _order: <ILiquoriceSettlement::Order as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, validateOrderAmountsCall, N> {
-            self.call_builder(&validateOrderAmountsCall { _order })
-        }
-
-        ///Creates a new call builder for the [`validateSignature`] function.
-        pub fn validateSignature(
-            &self,
-            _validationAddress: alloy_sol_types::private::Address,
-            _hash: alloy_sol_types::private::FixedBytes<32>,
-            _signature: <Signature::TypedSignature as alloy_sol_types::SolType>::RustType,
-        ) -> alloy_contract::SolCallBuilder<&P, validateSignatureCall, N> {
-            self.call_builder(&validateSignatureCall {
-                _validationAddress,
-                _hash,
-                _signature,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/pancakerouter/src/lib.rs b/contracts/generated/contracts-generated/pancakerouter/src/lib.rs
index 23b132d8fb..7427fc054d 100644
--- a/contracts/generated/contracts-generated/pancakerouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/pancakerouter/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface PancakeRouter {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -118,60 +99,6 @@ interface PancakeRouter {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
   {
     "type": "function",
     "name": "factory",
@@ -185,112 +112,6 @@ interface PancakeRouter {
     ],
     "stateMutability": "pure"
   },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "quote",
@@ -322,130 +143,22 @@ interface PancakeRouter {
   },
   {
     "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "name": "swapTokensForExactTokens",
     "inputs": [
       {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
+        "name": "amountOut",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountTokenMin",
+        "name": "amountInMax",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
       },
       {
         "name": "to",
@@ -460,4237 +173,40 @@ interface PancakeRouter {
     ],
     "outputs": [
       {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod PancakeRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod PancakeRouter {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct WETHCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
+    pub struct WETHReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -4703,21 +219,9 @@ pub mod PancakeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4729,40 +233,25 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4774,38 +263,29 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -4816,38 +296,20 @@ pub mod PancakeRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
+                        let r: WETHReturn = r.into();
+                        r._0
                     },
                 )
             }
@@ -4858,229 +320,32 @@ pub mod PancakeRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
-    ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod PancakeRouter {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod PancakeRouter {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod PancakeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod PancakeRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod PancakeRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod PancakeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5435,34 +683,22 @@ pub mod PancakeRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod PancakeRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod PancakeRouter {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod PancakeRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod PancakeRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod PancakeRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod PancakeRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod PancakeRouter {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl PancakeRouterCalls {
@@ -5949,84 +1110,27 @@ pub mod PancakeRouter {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6046,225 +1150,42 @@ pub mod PancakeRouter {
         #[inline]
         pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
             let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for PancakeRouterCalls {
-        const COUNT: usize = 24usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "PancakeRouterCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactTokens(_) => {
-                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<PancakeRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for PancakeRouterCalls {
+        const COUNT: usize = 5usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "PancakeRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<PancakeRouterCalls>] = &[
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6290,39 +1211,6 @@ pub mod PancakeRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6330,24 +1218,6 @@ pub mod PancakeRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6355,24 +1225,6 @@ pub mod PancakeRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(PancakeRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6393,136 +1245,6 @@ pub mod PancakeRouter {
                 &[u8],
             )
                 -> alloy_sol_types::Result<PancakeRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(PancakeRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6548,41 +1270,6 @@ pub mod PancakeRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                PancakeRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6590,26 +1277,6 @@ pub mod PancakeRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6619,26 +1286,6 @@ pub mod PancakeRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(PancakeRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<PancakeRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(PancakeRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6653,115 +1300,16 @@ pub mod PancakeRouter {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6778,137 +1326,17 @@ pub mod PancakeRouter {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7052,77 +1480,11 @@ pub mod PancakeRouter {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7137,327 +1499,6 @@ pub mod PancakeRouter {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/permit2/src/lib.rs b/contracts/generated/contracts-generated/permit2/src/lib.rs
index 26243a5948..a3af444fbc 100644
--- a/contracts/generated/contracts-generated/permit2/src/lib.rs
+++ b/contracts/generated/contracts-generated/permit2/src/lib.rs
@@ -13,7 +13,6 @@
 library IAllowanceTransfer {
     struct PermitDetails { address token; uint160 amount; uint48 expiration; uint48 nonce; }
     struct PermitSingle { PermitDetails details; address spender; uint256 sigDeadline; }
-    struct TokenSpenderPair { address token; address spender; }
 }
 ```*/
 #[allow(
@@ -509,214 +508,6 @@ pub mod IAllowanceTransfer {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct TokenSpenderPair { address token; address spender; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct TokenSpenderPair {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Address,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::Address,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<TokenSpenderPair> for UnderlyingRustTuple<'_> {
-            fn from(value: TokenSpenderPair) -> Self {
-                (value.token, value.spender)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TokenSpenderPair {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    token: tuple.0,
-                    spender: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for TokenSpenderPair {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for TokenSpenderPair {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for TokenSpenderPair {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for TokenSpenderPair {
-            const NAME: &'static str = "TokenSpenderPair";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "TokenSpenderPair(address token,address spender)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.spender,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for TokenSpenderPair {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.token,
-                    )
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.spender,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.spender,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
     use alloy_contract;
     /**Creates a new wrapper around an on-chain [`IAllowanceTransfer`](self) contract instance.
 
@@ -843,2573 +634,511 @@ pub mod IAllowanceTransfer {
         }
     }
 }
-///Module containing a contract's types and functions.
 /**
 
+Generated by the following Solidity interface...
 ```solidity
-library ISignatureTransfer {
-    struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }
-    struct PermitTransferFrom { TokenPermissions permitted; uint256 nonce; uint256 deadline; }
-    struct SignatureTransferDetails { address to; uint256 requestedAmount; }
-    struct TokenPermissions { address token; uint256 amount; }
-}
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod ISignatureTransfer {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct PermitBatchTransferFrom { TokenPermissions[] permitted; uint256 nonce; uint256 deadline; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct PermitBatchTransferFrom {
-        #[allow(missing_docs)]
-        pub permitted:
-            alloy_sol_types::private::Vec<<TokenPermissions as alloy_sol_types::SolType>::RustType>,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+library IAllowanceTransfer {
+    struct PermitDetails {
+        address token;
+        uint160 amount;
+        uint48 expiration;
+        uint48 nonce;
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Array<TokenPermissions>,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Vec<<TokenPermissions as alloy_sol_types::SolType>::RustType>,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<PermitBatchTransferFrom> for UnderlyingRustTuple<'_> {
-            fn from(value: PermitBatchTransferFrom) -> Self {
-                (value.permitted, value.nonce, value.deadline)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitBatchTransferFrom {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    permitted: tuple.0,
-                    nonce: tuple.1,
-                    deadline: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for PermitBatchTransferFrom {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for PermitBatchTransferFrom {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        TokenPermissions,
-                    > as alloy_sol_types::SolType>::tokenize(&self.permitted),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.nonce),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PermitBatchTransferFrom {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for PermitBatchTransferFrom {
-            const NAME: &'static str = "PermitBatchTransferFrom";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "PermitBatchTransferFrom(TokenPermissions[] permitted,uint256 nonce,uint256 \
-                     deadline)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components
-                    .push(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_root_type());
-                components
-                    .extend(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Array<
-                        TokenPermissions,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.permitted)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PermitBatchTransferFrom {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Array<
-                        TokenPermissions,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.permitted,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deadline,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Array<
-                    TokenPermissions,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.permitted,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deadline,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct PermitTransferFrom { TokenPermissions permitted; uint256 nonce; uint256 deadline; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct PermitTransferFrom {
-        #[allow(missing_docs)]
-        pub permitted: <TokenPermissions as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+    struct PermitSingle {
+        PermitDetails details;
+        address spender;
+        uint256 sigDeadline;
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            TokenPermissions,
-            alloy_sol_types::sol_data::Uint<256>,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            <TokenPermissions as alloy_sol_types::SolType>::RustType,
-            alloy_sol_types::private::primitives::aliases::U256,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<PermitTransferFrom> for UnderlyingRustTuple<'_> {
-            fn from(value: PermitTransferFrom) -> Self {
-                (value.permitted, value.nonce, value.deadline)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermitTransferFrom {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    permitted: tuple.0,
-                    nonce: tuple.1,
-                    deadline: tuple.2,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for PermitTransferFrom {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for PermitTransferFrom {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <TokenPermissions as alloy_sol_types::SolType>::tokenize(&self.permitted),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
+}
 
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
+interface Permit2 {
+    error AllowanceExpired(uint256 deadline);
+    error ExcessiveInvalidation();
+    error InsufficientAllowance(uint256 amount);
+    error InvalidAmount(uint256 maxAmount);
+    error InvalidContractSignature();
+    error InvalidNonce();
+    error InvalidSignature();
+    error InvalidSignatureLength();
+    error InvalidSigner();
+    error LengthMismatch();
+    error SignatureExpired(uint256 signatureDeadline);
 
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
+    event Approval(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration);
+    event Lockdown(address indexed owner, address token, address spender);
+    event NonceInvalidation(address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce);
+    event Permit(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce);
+    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
 
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for PermitTransferFrom {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for PermitTransferFrom {
-            const NAME: &'static str = "PermitTransferFrom";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "PermitTransferFrom(TokenPermissions permitted,uint256 nonce,uint256 deadline)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
-                components
-                    .push(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_root_type());
-                components
-                    .extend(<TokenPermissions as alloy_sol_types::SolStruct>::eip712_components());
-                components
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <TokenPermissions as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.permitted,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.nonce)
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.deadline)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for PermitTransferFrom {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <TokenPermissions as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.permitted,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.nonce)
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.deadline,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <TokenPermissions as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.permitted,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.nonce,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.deadline,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct SignatureTransferDetails { address to; uint256 requestedAmount; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct SignatureTransferDetails {
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub requestedAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<SignatureTransferDetails> for UnderlyingRustTuple<'_> {
-            fn from(value: SignatureTransferDetails) -> Self {
-                (value.to, value.requestedAmount)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureTransferDetails {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    to: tuple.0,
-                    requestedAmount: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for SignatureTransferDetails {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for SignatureTransferDetails {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.requestedAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for SignatureTransferDetails {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for SignatureTransferDetails {
-            const NAME: &'static str = "SignatureTransferDetails";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "SignatureTransferDetails(address to,uint256 requestedAmount)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function allowance(address, address, address) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
+    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
+    function permit(address owner, IAllowanceTransfer.PermitSingle memory permitSingle, bytes memory signature) external;
+    function transferFrom(address from, address to, uint160 amount, address token) external;
+}
+```
 
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.to,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.requestedAmount,
-                        )
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for SignatureTransferDetails {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.to,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.requestedAmount,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.to,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.requestedAmount,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**```solidity
-    struct TokenPermissions { address token; uint256 amount; }
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct TokenPermissions {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (
-            alloy_sol_types::sol_data::Address,
-            alloy_sol_types::sol_data::Uint<256>,
-        );
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (
-            alloy_sol_types::private::Address,
-            alloy_sol_types::private::primitives::aliases::U256,
-        );
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<TokenPermissions> for UnderlyingRustTuple<'_> {
-            fn from(value: TokenPermissions) -> Self {
-                (value.token, value.amount)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for TokenPermissions {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    token: tuple.0,
-                    amount: tuple.1,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolValue for TokenPermissions {
-            type SolType = Self;
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::SolTypeValue<Self> for TokenPermissions {
-            #[inline]
-            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn stv_abi_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
-            }
-
-            #[inline]
-            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
-                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
-            }
-
-            #[inline]
-            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
-                    &tuple, out,
-                )
-            }
-
-            #[inline]
-            fn stv_abi_packed_encoded_size(&self) -> usize {
-                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
-                    return size;
-                }
-                let tuple =
-                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
-                    &tuple,
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolType for TokenPermissions {
-            type RustType = Self;
-            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
-            const PACKED_ENCODED_SIZE: Option<usize> =
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
-            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
-
-            #[inline]
-            fn valid_token(token: &Self::Token<'_>) -> bool {
-                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
-            }
-
-            #[inline]
-            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
-                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
-                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolStruct for TokenPermissions {
-            const NAME: &'static str = "TokenPermissions";
-
-            #[inline]
-            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
-                alloy_sol_types::private::Cow::Borrowed(
-                    "TokenPermissions(address token,uint256 amount)",
-                )
-            }
-
-            #[inline]
-            fn eip712_components()
-            -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
-            {
-                alloy_sol_types::private::Vec::new()
-            }
-
-            #[inline]
-            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
-                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
-            }
-
-            #[inline]
-            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
-                [
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
-                            &self.token,
-                        )
-                        .0,
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
-                        .0,
-                ]
-                    .concat()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::EventTopic for TokenPermissions {
-            #[inline]
-            fn topic_preimage_length(rust: &Self::RustType) -> usize {
-                0usize
-                    + <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.token,
-                    )
-                    + <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
-                        &rust.amount,
-                    )
-            }
-
-            #[inline]
-            fn encode_topic_preimage(
-                rust: &Self::RustType,
-                out: &mut alloy_sol_types::private::Vec<u8>,
-            ) {
-                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
-                <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.token,
-                    out,
-                );
-                <alloy_sol_types::sol_data::Uint<
-                    256,
-                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
-                    &rust.amount,
-                    out,
-                );
-            }
-
-            #[inline]
-            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
-                let mut out = alloy_sol_types::private::Vec::new();
-                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
-                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
-            }
-        }
-    };
-    use alloy_contract;
-    /**Creates a new wrapper around an on-chain [`ISignatureTransfer`](self) contract instance.
-
-    See the [wrapper's documentation](`ISignatureTransferInstance`) for more details.*/
-    #[inline]
-    pub const fn new<
-        P: alloy_contract::private::Provider<N>,
-        N: alloy_contract::private::Network,
-    >(
-        address: alloy_sol_types::private::Address,
-        __provider: P,
-    ) -> ISignatureTransferInstance<P, N> {
-        ISignatureTransferInstance::<P, N>::new(address, __provider)
-    }
-    /**A [`ISignatureTransfer`](self) instance.
-
-    Contains type-safe methods for interacting with an on-chain instance of the
-    [`ISignatureTransfer`](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.
-
-    See the [module-level documentation](self) for all the available methods.*/
-    #[derive(Clone)]
-    pub struct ISignatureTransferInstance<P, N = alloy_contract::private::Ethereum> {
-        address: alloy_sol_types::private::Address,
-        provider: P,
-        _network: ::core::marker::PhantomData<N>,
-    }
-    #[automatically_derived]
-    impl<P, N> ::core::fmt::Debug for ISignatureTransferInstance<P, N> {
-        #[inline]
-        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-            f.debug_tuple("ISignatureTransferInstance")
-                .field(&self.address)
-                .finish()
-        }
-    }
-    /// Instantiation and getters/setters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        ISignatureTransferInstance<P, N>
-    {
-        /**Creates a new wrapper around an on-chain [`ISignatureTransfer`](self) contract instance.
-
-        See the [wrapper's documentation](`ISignatureTransferInstance`) for more details.*/
-        #[inline]
-        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
-            Self {
-                address,
-                provider: __provider,
-                _network: ::core::marker::PhantomData,
-            }
-        }
-
-        /// Returns a reference to the address.
-        #[inline]
-        pub const fn address(&self) -> &alloy_sol_types::private::Address {
-            &self.address
-        }
-
-        /// Sets the address.
-        #[inline]
-        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
-            self.address = address;
-        }
-
-        /// Sets the address and returns `self`.
-        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
-            self.set_address(address);
-            self
-        }
-
-        /// Returns a reference to the provider.
-        #[inline]
-        pub const fn provider(&self) -> &P {
-            &self.provider
-        }
-    }
-    impl<P: ::core::clone::Clone, N> ISignatureTransferInstance<&P, N> {
-        /// Clones the provider and returns a new instance with the cloned
-        /// provider.
-        #[inline]
-        pub fn with_cloned_provider(self) -> ISignatureTransferInstance<P, N> {
-            ISignatureTransferInstance {
-                address: self.address,
-                provider: ::core::clone::Clone::clone(&self.provider),
-                _network: ::core::marker::PhantomData,
-            }
-        }
-    }
-    /// Function calls.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        ISignatureTransferInstance<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 contract. Prefer using the other methods for
-        /// building type-safe contract calls.
-        pub fn call_builder<C: alloy_sol_types::SolCall>(
-            &self,
-            call: &C,
-        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
-            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
-        }
-    }
-    /// Event filters.
-    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
-        ISignatureTransferInstance<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. Prefer using the other methods for building
-        /// type-safe event filters.
-        pub fn event_filter<E: alloy_sol_types::SolEvent>(
-            &self,
-        ) -> alloy_contract::Event<&P, E, N> {
-            alloy_contract::Event::new_sol(&self.provider, &self.address)
-        }
-    }
-}
-/**
-
-Generated by the following Solidity interface...
-```solidity
-library IAllowanceTransfer {
-    struct PermitDetails {
-        address token;
-        uint160 amount;
-        uint48 expiration;
-        uint48 nonce;
-    }
-    struct PermitSingle {
-        PermitDetails details;
-        address spender;
-        uint256 sigDeadline;
-    }
-    struct TokenSpenderPair {
-        address token;
-        address spender;
-    }
-}
-
-library ISignatureTransfer {
-    struct PermitBatchTransferFrom {
-        TokenPermissions[] permitted;
-        uint256 nonce;
-        uint256 deadline;
-    }
-    struct PermitTransferFrom {
-        TokenPermissions permitted;
-        uint256 nonce;
-        uint256 deadline;
-    }
-    struct SignatureTransferDetails {
-        address to;
-        uint256 requestedAmount;
-    }
-    struct TokenPermissions {
-        address token;
-        uint256 amount;
-    }
-}
-
-interface Permit2 {
-    error AllowanceExpired(uint256 deadline);
-    error ExcessiveInvalidation();
-    error InsufficientAllowance(uint256 amount);
-    error InvalidAmount(uint256 maxAmount);
-    error InvalidContractSignature();
-    error InvalidNonce();
-    error InvalidSignature();
-    error InvalidSignatureLength();
-    error InvalidSigner();
-    error LengthMismatch();
-    error SignatureExpired(uint256 signatureDeadline);
-
-    event Approval(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration);
-    event Lockdown(address indexed owner, address token, address spender);
-    event NonceInvalidation(address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce);
-    event Permit(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce);
-    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
-
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
-    function allowance(address, address, address) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
-    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
-    function invalidateNonces(address token, address spender, uint48 newNonce) external;
-    function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
-    function lockdown(IAllowanceTransfer.TokenSpenderPair[] memory approvals) external;
-    function nonceBitmap(address, uint256) external view returns (uint256);
-    function permit(address owner, IAllowanceTransfer.PermitSingle memory permitSingle, bytes memory signature) external;
-    function permitTransferFrom(ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address owner, bytes memory signature) external;
-    function permitWitnessTransferFrom(ISignatureTransfer.PermitBatchTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails[] memory transferDetails, address owner, bytes32 witness, string memory witnessTypeString, bytes memory signature) external;
-    function transferFrom(address from, address to, uint160 amount, address token) external;
-}
-```
-
-...which was generated by the following JSON ABI:
-```json
-[
-  {
-    "type": "function",
-    "name": "DOMAIN_SEPARATOR",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "allowance",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amount",
-        "type": "uint160",
-        "internalType": "uint160"
-      },
-      {
-        "name": "expiration",
-        "type": "uint48",
-        "internalType": "uint48"
-      },
-      {
-        "name": "nonce",
-        "type": "uint48",
-        "internalType": "uint48"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "approve",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint160",
-        "internalType": "uint160"
-      },
-      {
-        "name": "expiration",
-        "type": "uint48",
-        "internalType": "uint48"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "invalidateNonces",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "newNonce",
-        "type": "uint48",
-        "internalType": "uint48"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "invalidateUnorderedNonces",
-    "inputs": [
-      {
-        "name": "wordPos",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "mask",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "lockdown",
-    "inputs": [
-      {
-        "name": "approvals",
-        "type": "tuple[]",
-        "internalType": "struct IAllowanceTransfer.TokenSpenderPair[]",
-        "components": [
-          {
-            "name": "token",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "spender",
-            "type": "address",
-            "internalType": "address"
-          }
-        ]
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "nonceBitmap",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "permit",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "permitSingle",
-        "type": "tuple",
-        "internalType": "struct IAllowanceTransfer.PermitSingle",
-        "components": [
-          {
-            "name": "details",
-            "type": "tuple",
-            "internalType": "struct IAllowanceTransfer.PermitDetails",
-            "components": [
-              {
-                "name": "token",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint160",
-                "internalType": "uint160"
-              },
-              {
-                "name": "expiration",
-                "type": "uint48",
-                "internalType": "uint48"
-              },
-              {
-                "name": "nonce",
-                "type": "uint48",
-                "internalType": "uint48"
-              }
-            ]
-          },
-          {
-            "name": "spender",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sigDeadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "permitTransferFrom",
-    "inputs": [
-      {
-        "name": "permit",
-        "type": "tuple",
-        "internalType": "struct ISignatureTransfer.PermitTransferFrom",
-        "components": [
-          {
-            "name": "permitted",
-            "type": "tuple",
-            "internalType": "struct ISignatureTransfer.TokenPermissions",
-            "components": [
-              {
-                "name": "token",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "transferDetails",
-        "type": "tuple",
-        "internalType": "struct ISignatureTransfer.SignatureTransferDetails",
-        "components": [
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "requestedAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "permitWitnessTransferFrom",
-    "inputs": [
-      {
-        "name": "permit",
-        "type": "tuple",
-        "internalType": "struct ISignatureTransfer.PermitBatchTransferFrom",
-        "components": [
-          {
-            "name": "permitted",
-            "type": "tuple[]",
-            "internalType": "struct ISignatureTransfer.TokenPermissions[]",
-            "components": [
-              {
-                "name": "token",
-                "type": "address",
-                "internalType": "address"
-              },
-              {
-                "name": "amount",
-                "type": "uint256",
-                "internalType": "uint256"
-              }
-            ]
-          },
-          {
-            "name": "nonce",
-            "type": "uint256",
-            "internalType": "uint256"
-          },
-          {
-            "name": "deadline",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "transferDetails",
-        "type": "tuple[]",
-        "internalType": "struct ISignatureTransfer.SignatureTransferDetails[]",
-        "components": [
-          {
-            "name": "to",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "requestedAmount",
-            "type": "uint256",
-            "internalType": "uint256"
-          }
-        ]
-      },
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "witness",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "witnessTypeString",
-        "type": "string",
-        "internalType": "string"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "transferFrom",
-    "inputs": [
-      {
-        "name": "from",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint160",
-        "internalType": "uint160"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "event",
-    "name": "Approval",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint160",
-        "indexed": false,
-        "internalType": "uint160"
-      },
-      {
-        "name": "expiration",
-        "type": "uint48",
-        "indexed": false,
-        "internalType": "uint48"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Lockdown",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "NonceInvalidation",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "newNonce",
-        "type": "uint48",
-        "indexed": false,
-        "internalType": "uint48"
-      },
-      {
-        "name": "oldNonce",
-        "type": "uint48",
-        "indexed": false,
-        "internalType": "uint48"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Permit",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "token",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "spender",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "amount",
-        "type": "uint160",
-        "indexed": false,
-        "internalType": "uint160"
-      },
-      {
-        "name": "expiration",
-        "type": "uint48",
-        "indexed": false,
-        "internalType": "uint48"
-      },
-      {
-        "name": "nonce",
-        "type": "uint48",
-        "indexed": false,
-        "internalType": "uint48"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "UnorderedNonceInvalidation",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "word",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      },
-      {
-        "name": "mask",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "error",
-    "name": "AllowanceExpired",
-    "inputs": [
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "ExcessiveInvalidation",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InsufficientAllowance",
-    "inputs": [
-      {
-        "name": "amount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "InvalidAmount",
-    "inputs": [
-      {
-        "name": "maxAmount",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "InvalidContractSignature",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidNonce",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidSignature",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidSignatureLength",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidSigner",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "LengthMismatch",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "SignatureExpired",
-    "inputs": [
-      {
-        "name": "signatureDeadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod Permit2 {
-    use {super::*, alloy_sol_types};
-    /// The creation / init bytecode of the contract.
-    ///
-    /// ```text
-    ///0x
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"",
-    );
-    /// The runtime bytecode of the contract, as deployed on the network.
-    ///
-    /// ```text
-    ///0x
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"",
-    );
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `AllowanceExpired(uint256)` and selector `0xd81b2f2e`.
-    ```solidity
-    error AllowanceExpired(uint256 deadline);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct AllowanceExpired {
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<AllowanceExpired> for UnderlyingRustTuple<'_> {
-            fn from(value: AllowanceExpired) -> Self {
-                (value.deadline,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AllowanceExpired {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { deadline: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for AllowanceExpired {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [216u8, 27u8, 47u8, 46u8];
-            const SIGNATURE: &'static str = "AllowanceExpired(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `ExcessiveInvalidation()` and selector `0x24d35a26`.
-    ```solidity
-    error ExcessiveInvalidation();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct ExcessiveInvalidation;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<ExcessiveInvalidation> for UnderlyingRustTuple<'_> {
-            fn from(value: ExcessiveInvalidation) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExcessiveInvalidation {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for ExcessiveInvalidation {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [36u8, 211u8, 90u8, 38u8];
-            const SIGNATURE: &'static str = "ExcessiveInvalidation()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InsufficientAllowance(uint256)` and selector `0xf96fb071`.
-    ```solidity
-    error InsufficientAllowance(uint256 amount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InsufficientAllowance {
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InsufficientAllowance> for UnderlyingRustTuple<'_> {
-            fn from(value: InsufficientAllowance) -> Self {
-                (value.amount,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientAllowance {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { amount: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InsufficientAllowance {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [249u8, 111u8, 176u8, 113u8];
-            const SIGNATURE: &'static str = "InsufficientAllowance(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidAmount(uint256)` and selector `0x3728b83d`.
-    ```solidity
-    error InvalidAmount(uint256 maxAmount);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidAmount {
-        #[allow(missing_docs)]
-        pub maxAmount: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidAmount> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidAmount) -> Self {
-                (value.maxAmount,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAmount {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self { maxAmount: tuple.0 }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidAmount {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [55u8, 40u8, 184u8, 61u8];
-            const SIGNATURE: &'static str = "InvalidAmount(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.maxAmount,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidContractSignature()` and selector `0xb0669cbc`.
-    ```solidity
-    error InvalidContractSignature();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidContractSignature;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidContractSignature> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidContractSignature) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidContractSignature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidContractSignature {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [176u8, 102u8, 156u8, 188u8];
-            const SIGNATURE: &'static str = "InvalidContractSignature()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidNonce()` and selector `0x756688fe`.
-    ```solidity
-    error InvalidNonce();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidNonce;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidNonce> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidNonce) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNonce {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidNonce {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [117u8, 102u8, 136u8, 254u8];
-            const SIGNATURE: &'static str = "InvalidNonce()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidSignature()` and selector `0x8baa579f`.
-    ```solidity
-    error InvalidSignature();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidSignature;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidSignature> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidSignature) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignature {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidSignature {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [139u8, 170u8, 87u8, 159u8];
-            const SIGNATURE: &'static str = "InvalidSignature()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidSignatureLength()` and selector `0x4be6321b`.
-    ```solidity
-    error InvalidSignatureLength();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidSignatureLength;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidSignatureLength> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidSignatureLength) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignatureLength {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidSignatureLength {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [75u8, 230u8, 50u8, 27u8];
-            const SIGNATURE: &'static str = "InvalidSignatureLength()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `InvalidSigner()` and selector `0x815e1d64`.
-    ```solidity
-    error InvalidSigner();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct InvalidSigner;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<InvalidSigner> for UnderlyingRustTuple<'_> {
-            fn from(value: InvalidSigner) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSigner {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for InvalidSigner {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [129u8, 94u8, 29u8, 100u8];
-            const SIGNATURE: &'static str = "InvalidSigner()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `LengthMismatch()` and selector `0xff633a38`.
-    ```solidity
-    error LengthMismatch();
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct LengthMismatch;
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[doc(hidden)]
-        #[allow(dead_code)]
-        type UnderlyingSolTuple<'a> = ();
-        #[doc(hidden)]
-        type UnderlyingRustTuple<'a> = ();
-        #[cfg(test)]
-        #[allow(dead_code, unreachable_patterns)]
-        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-            match _t {
-                alloy_sol_types::private::AssertTypeEq::<
-                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                >(_) => {}
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<LengthMismatch> for UnderlyingRustTuple<'_> {
-            fn from(value: LengthMismatch) -> Self {
-                ()
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LengthMismatch {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for LengthMismatch {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [255u8, 99u8, 58u8, 56u8];
-            const SIGNATURE: &'static str = "LengthMismatch()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amount",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "internalType": "uint48"
+      },
+      {
+        "name": "nonce",
+        "type": "uint48",
+        "internalType": "uint48"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "internalType": "uint48"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "permitSingle",
+        "type": "tuple",
+        "internalType": "struct IAllowanceTransfer.PermitSingle",
+        "components": [
+          {
+            "name": "details",
+            "type": "tuple",
+            "internalType": "struct IAllowanceTransfer.PermitDetails",
+            "components": [
+              {
+                "name": "token",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint160",
+                "internalType": "uint160"
+              },
+              {
+                "name": "expiration",
+                "type": "uint48",
+                "internalType": "uint48"
+              },
+              {
+                "name": "nonce",
+                "type": "uint48",
+                "internalType": "uint48"
+              }
+            ]
+          },
+          {
+            "name": "spender",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigDeadline",
+            "type": "uint256",
+            "internalType": "uint256"
+          }
+        ]
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "internalType": "uint160"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Approval",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "indexed": false,
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Lockdown",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "NonceInvalidation",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "newNonce",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      },
+      {
+        "name": "oldNonce",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Permit",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "token",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "spender",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint160",
+        "indexed": false,
+        "internalType": "uint160"
+      },
+      {
+        "name": "expiration",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      },
+      {
+        "name": "nonce",
+        "type": "uint48",
+        "indexed": false,
+        "internalType": "uint48"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "UnorderedNonceInvalidation",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "word",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      },
+      {
+        "name": "mask",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AllowanceExpired",
+    "inputs": [
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "ExcessiveInvalidation",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InsufficientAllowance",
+    "inputs": [
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidAmount",
+    "inputs": [
+      {
+        "name": "maxAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  },
+  {
+    "type": "error",
+    "name": "InvalidContractSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidNonce",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSignatureLength",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidSigner",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "LengthMismatch",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SignatureExpired",
+    "inputs": [
+      {
+        "name": "signatureDeadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ]
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod Permit2 {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    ///0x
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"",
+    );
+    /// The runtime bytecode of the contract, as deployed on the network.
+    ///
+    /// ```text
+    ///0x
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"",
+    );
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Custom error with signature `SignatureExpired(uint256)` and selector `0xcd21db4f`.
+    /**Custom error with signature `AllowanceExpired(uint256)` and selector `0xd81b2f2e`.
     ```solidity
-    error SignatureExpired(uint256 signatureDeadline);
+    error AllowanceExpired(uint256 deadline);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct SignatureExpired {
+    pub struct AllowanceExpired {
         #[allow(missing_docs)]
-        pub signatureDeadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -3435,218 +1164,59 @@ pub mod Permit2 {
         }
         #[automatically_derived]
         #[doc(hidden)]
-        impl ::core::convert::From<SignatureExpired> for UnderlyingRustTuple<'_> {
-            fn from(value: SignatureExpired) -> Self {
-                (value.signatureDeadline,)
-            }
-        }
-        #[automatically_derived]
-        #[doc(hidden)]
-        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureExpired {
-            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                Self {
-                    signatureDeadline: tuple.0,
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolError for SignatureExpired {
-            type Parameters<'a> = UnderlyingSolTuple<'a>;
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [205u8, 33u8, 219u8, 79u8];
-            const SIGNATURE: &'static str = "SignatureExpired(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.signatureDeadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
-                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Self::new)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Approval(address,address,address,uint160,uint48)` and selector `0xda9fa7c1b00402c17d0161b249b1ab8bbec047c5a52207b9c112deffd817036b`.
-    ```solidity
-    event Approval(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct Approval {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Approval {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Approval(address,address,address,uint160,uint48)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    218u8, 159u8, 167u8, 193u8, 176u8, 4u8, 2u8, 193u8, 125u8, 1u8, 97u8, 178u8,
-                    73u8, 177u8, 171u8, 139u8, 190u8, 192u8, 71u8, 197u8, 165u8, 34u8, 7u8, 185u8,
-                    193u8, 18u8, 222u8, 255u8, 216u8, 23u8, 3u8, 107u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    token: topics.2,
-                    spender: topics.3,
-                    amount: data.0,
-                    expiration: data.1,
-                }
+        impl ::core::convert::From<AllowanceExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: AllowanceExpired) -> Self {
+                (value.deadline,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AllowanceExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { deadline: tuple.0 }
             }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for AllowanceExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [216u8, 27u8, 47u8, 46u8];
+            const SIGNATURE: &'static str = "AllowanceExpired(uint256)";
 
             #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
             }
 
             #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
+            fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.expiration,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
                     ),
                 )
             }
 
             #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.token.clone(),
-                    self.spender.clone(),
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Approval {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Approval> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Lockdown(address,address,address)` and selector `0x89b1add15eff56b3dfe299ad94e01f2b52fbcb80ae1a3baea6ae8c04cb2b98a4`.
+    /**Custom error with signature `ExcessiveInvalidation()` and selector `0x24d35a26`.
     ```solidity
-    event Lockdown(address indexed owner, address token, address spender);
+    error ExcessiveInvalidation();
     ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct Lockdown {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-    }
+    pub struct ExcessiveInvalidation;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3655,127 +1225,73 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Lockdown {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
-
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Lockdown(address,address,address)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    137u8, 177u8, 173u8, 209u8, 94u8, 255u8, 86u8, 179u8, 223u8, 226u8, 153u8,
-                    173u8, 148u8, 224u8, 31u8, 43u8, 82u8, 251u8, 203u8, 128u8, 174u8, 26u8, 59u8,
-                    174u8, 166u8, 174u8, 140u8, 4u8, 203u8, 43u8, 152u8, 164u8,
-                ]);
-
-            #[allow(unused_variables)]
-            #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                Self {
-                    owner: topics.1,
-                    token: data.0,
-                    spender: data.1,
-                }
+        #[doc(hidden)]
+        impl ::core::convert::From<ExcessiveInvalidation> for UnderlyingRustTuple<'_> {
+            fn from(value: ExcessiveInvalidation) -> Self {
+                ()
             }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ExcessiveInvalidation {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for ExcessiveInvalidation {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                )
-            }
+            const SELECTOR: [u8; 4] = [36u8, 211u8, 90u8, 38u8];
+            const SIGNATURE: &'static str = "ExcessiveInvalidation()";
 
             #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.owner.clone())
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
             }
 
             #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Lockdown {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
             }
 
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Lockdown> for alloy_sol_types::private::LogData {
             #[inline]
-            fn from(this: &Lockdown) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `NonceInvalidation(address,address,address,uint48,uint48)` and selector `0x55eb90d810e1700b35a8e7e25395ff7f2b2259abd7415ca2284dfb1c246418f3`.
-    ```solidity
-    event NonceInvalidation(address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce);
-    ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    #[derive(Clone)]
-    pub struct NonceInvalidation {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub newNonce: alloy_sol_types::private::primitives::aliases::U48,
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InsufficientAllowance(uint256)` and selector `0xf96fb071`.
+    ```solidity
+    error InsufficientAllowance(uint256 amount);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InsufficientAllowance {
         #[allow(missing_docs)]
-        pub oldNonce: alloy_sol_types::private::primitives::aliases::U48,
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -3785,145 +1301,77 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolEvent for NonceInvalidation {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<48>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+        #[doc(hidden)]
+        impl ::core::convert::From<InsufficientAllowance> for UnderlyingRustTuple<'_> {
+            fn from(value: InsufficientAllowance) -> Self {
+                (value.amount,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientAllowance {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { amount: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InsufficientAllowance {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str =
-                "NonceInvalidation(address,address,address,uint48,uint48)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    85u8, 235u8, 144u8, 216u8, 16u8, 225u8, 112u8, 11u8, 53u8, 168u8, 231u8, 226u8,
-                    83u8, 149u8, 255u8, 127u8, 43u8, 34u8, 89u8, 171u8, 215u8, 65u8, 92u8, 162u8,
-                    40u8, 77u8, 251u8, 28u8, 36u8, 100u8, 24u8, 243u8,
-                ]);
+            const SELECTOR: [u8; 4] = [249u8, 111u8, 176u8, 113u8];
+            const SIGNATURE: &'static str = "InsufficientAllowance(uint256)";
 
-            #[allow(unused_variables)]
             #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                Self {
-                    owner: topics.1,
-                    token: topics.2,
-                    spender: topics.3,
-                    newNonce: data.0,
-                    oldNonce: data.1,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
+                tuple.into()
             }
 
             #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
+            fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.newNonce,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.oldNonce,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
                     ),
                 )
             }
 
             #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.token.clone(),
-                    self.spender.clone(),
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for NonceInvalidation {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&NonceInvalidation> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &NonceInvalidation) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `Permit(address,address,address,uint160,uint48,uint48)` and selector `0xc6a377bfc4eb120024a8ac08eef205be16b817020812c73223e81d1bdb9708ec`.
+    /**Custom error with signature `InvalidAmount(uint256)` and selector `0x3728b83d`.
     ```solidity
-    event Permit(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce);
+    error InvalidAmount(uint256 maxAmount);
     ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct Permit {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+    pub struct InvalidAmount {
         #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+        pub maxAmount: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -3933,144 +1381,75 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolEvent for Permit {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<48>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidAmount> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidAmount) -> Self {
+                (value.maxAmount,)
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAmount {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self { maxAmount: tuple.0 }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidAmount {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "Permit(address,address,address,uint160,uint48,uint48)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    198u8, 163u8, 119u8, 191u8, 196u8, 235u8, 18u8, 0u8, 36u8, 168u8, 172u8, 8u8,
-                    238u8, 242u8, 5u8, 190u8, 22u8, 184u8, 23u8, 2u8, 8u8, 18u8, 199u8, 50u8, 35u8,
-                    232u8, 29u8, 27u8, 219u8, 151u8, 8u8, 236u8,
-                ]);
+            const SELECTOR: [u8; 4] = [55u8, 40u8, 184u8, 61u8];
+            const SIGNATURE: &'static str = "InvalidAmount(uint256)";
 
-            #[allow(unused_variables)]
             #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                Self {
-                    owner: topics.1,
-                    token: topics.2,
-                    spender: topics.3,
-                    amount: data.0,
-                    expiration: data.1,
-                    nonce: data.2,
-                }
-            }
-
-            #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
+                tuple.into()
             }
 
             #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
+            fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.expiration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.maxAmount,
                     ),
                 )
             }
 
             #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (
-                    Self::SIGNATURE_HASH.into(),
-                    self.owner.clone(),
-                    self.token.clone(),
-                    self.spender.clone(),
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.token,
-                );
-                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.spender,
-                );
-                Ok(())
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for Permit {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
-            }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
-            }
-        }
-        #[automatically_derived]
-        impl From<&Permit> for alloy_sol_types::private::LogData {
-            #[inline]
-            fn from(this: &Permit) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Event with signature `UnorderedNonceInvalidation(address,uint256,uint256)` and selector `0x3704902f963766a4e561bbaab6e6cdc1b1dd12f6e9e99648da8843b3f46b918d`.
+    /**Custom error with signature `InvalidContractSignature()` and selector `0xb0669cbc`.
     ```solidity
-    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
+    error InvalidContractSignature();
     ```*/
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct UnorderedNonceInvalidation {
-        #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub word: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub mask: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct InvalidContractSignature;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4079,121 +1458,144 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolEvent for UnorderedNonceInvalidation {
-            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type DataTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type TopicList = (
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::Address,
-            );
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidContractSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidContractSignature) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidContractSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidContractSignature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const ANONYMOUS: bool = false;
-            const SIGNATURE: &'static str = "UnorderedNonceInvalidation(address,uint256,uint256)";
-            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
-                alloy_sol_types::private::B256::new([
-                    55u8, 4u8, 144u8, 47u8, 150u8, 55u8, 102u8, 164u8, 229u8, 97u8, 187u8, 170u8,
-                    182u8, 230u8, 205u8, 193u8, 177u8, 221u8, 18u8, 246u8, 233u8, 233u8, 150u8,
-                    72u8, 218u8, 136u8, 67u8, 179u8, 244u8, 107u8, 145u8, 141u8,
-                ]);
+            const SELECTOR: [u8; 4] = [176u8, 102u8, 156u8, 188u8];
+            const SIGNATURE: &'static str = "InvalidContractSignature()";
 
-            #[allow(unused_variables)]
             #[inline]
-            fn new(
-                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
-                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                Self {
-                    owner: topics.1,
-                    word: data.0,
-                    mask: data.1,
-                }
+                tuple.into()
             }
 
             #[inline]
-            fn check_signature(
-                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
-            ) -> alloy_sol_types::Result<()> {
-                if topics.0 != Self::SIGNATURE_HASH {
-                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
-                        Self::SIGNATURE,
-                        topics.0,
-                        Self::SIGNATURE_HASH,
-                    ));
-                }
-                Ok(())
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
             }
 
             #[inline]
-            fn tokenize_body(&self) -> Self::DataToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.word,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.mask,
-                    ),
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
+                .map(Self::new)
             }
-
-            #[inline]
-            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
-                (Self::SIGNATURE_HASH.into(), self.owner.clone())
-            }
-
-            #[inline]
-            fn encode_topics_raw(
-                &self,
-                out: &mut [alloy_sol_types::abi::token::WordToken],
-            ) -> alloy_sol_types::Result<()> {
-                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
-                    return Err(alloy_sol_types::Error::Overrun);
-                }
-                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
-                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
-                    &self.owner,
-                );
-                Ok(())
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidNonce()` and selector `0x756688fe`.
+    ```solidity
+    error InvalidNonce();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidNonce;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::private::IntoLogData for UnorderedNonceInvalidation {
-            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
-                From::from(self)
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidNonce> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidNonce) -> Self {
+                ()
             }
-
-            fn into_log_data(self) -> alloy_sol_types::private::LogData {
-                From::from(&self)
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNonce {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl From<&UnorderedNonceInvalidation> for alloy_sol_types::private::LogData {
+        impl alloy_sol_types::SolError for InvalidNonce {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [117u8, 102u8, 136u8, 254u8];
+            const SIGNATURE: &'static str = "InvalidNonce()";
+
             #[inline]
-            fn from(this: &UnorderedNonceInvalidation) -> alloy_sol_types::private::LogData {
-                alloy_sol_types::SolEvent::encode_log_data(this)
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
+    /**Custom error with signature `InvalidSignature()` and selector `0x8baa579f`.
     ```solidity
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    error InvalidSignature();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct DOMAIN_SEPARATORReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::FixedBytes<32>,
-    }
+    pub struct InvalidSignature;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4202,76 +1604,41 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
-                    (value._0,)
-                }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSignature> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSignature) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignature {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::FixedBytes<32>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+        impl alloy_sol_types::SolError for InvalidSignature {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
-            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
+            const SELECTOR: [u8; 4] = [139u8, 170u8, 87u8, 159u8];
+            const SIGNATURE: &'static str = "InvalidSignature()";
 
             #[inline]
             fn new<'a>(
@@ -4286,64 +1653,22 @@ pub mod Permit2 {
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(ret),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: DOMAIN_SEPARATORReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: DOMAIN_SEPARATORReturn = r.into();
-                    r._0
-                })
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allowance(address,address,address)` and selector `0x927da105`.
+    /**Custom error with signature `InvalidSignatureLength()` and selector `0x4be6321b`.
     ```solidity
-    function allowance(address, address, address) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
+    error InvalidSignatureLength();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct allowanceCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _2: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allowance(address,address,address)`](allowanceCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allowanceReturn {
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
-        #[allow(missing_docs)]
-        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
-    }
+    pub struct InvalidSignatureLength;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4352,123 +1677,41 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceCall) -> Self {
-                    (value._0, value._1, value._2)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                        _2: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<48>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U160,
-                alloy_sol_types::private::primitives::aliases::U48,
-                alloy_sol_types::private::primitives::aliases::U48,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allowanceReturn) -> Self {
-                    (value.amount, value.expiration, value.nonce)
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount: tuple.0,
-                        expiration: tuple.1,
-                        nonce: tuple.2,
-                    }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSignatureLength> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSignatureLength) -> Self {
+                ()
             }
         }
-        impl allowanceReturn {
-            fn _tokenize(&self) -> <allowanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.expiration,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.nonce,
-                    ),
-                )
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignatureLength {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for allowanceCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = allowanceReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<48>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
+        impl alloy_sol_types::SolError for InvalidSignatureLength {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [146u8, 125u8, 161u8, 5u8];
-            const SIGNATURE: &'static str = "allowance(address,address,address)";
+            const SELECTOR: [u8; 4] = [75u8, 230u8, 50u8, 27u8];
+            const SIGNATURE: &'static str = "InvalidSignatureLength()";
 
             #[inline]
             fn new<'a>(
@@ -4479,61 +1722,99 @@ pub mod Permit2 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._2,
-                    ),
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
                 )
+                .map(Self::new)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `InvalidSigner()` and selector `0x815e1d64`.
+    ```solidity
+    error InvalidSigner();
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct InvalidSigner;
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<InvalidSigner> for UnderlyingRustTuple<'_> {
+            fn from(value: InvalidSigner) -> Self {
+                ()
+            }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSigner {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for InvalidSigner {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [129u8, 94u8, 29u8, 100u8];
+            const SIGNATURE: &'static str = "InvalidSigner()";
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                allowanceReturn::_tokenize(ret)
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `approve(address,address,uint160,uint48)` and selector `0x87517c45`.
+    /**Custom error with signature `LengthMismatch()` and selector `0xff633a38`.
     ```solidity
-    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
+    error LengthMismatch();
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct approveCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub spender: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
-    }
-    ///Container type for the return parameters of the
-    /// [`approve(address,address,uint160,uint48)`](approveCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct approveReturn {}
+    pub struct LengthMismatch;
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4542,101 +1823,119 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U160,
-                alloy_sol_types::private::primitives::aliases::U48,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = ();
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = ();
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
-                fn from(value: approveCall) -> Self {
-                    (value.token, value.spender, value.amount, value.expiration)
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<LengthMismatch> for UnderlyingRustTuple<'_> {
+            fn from(value: LengthMismatch) -> Self {
+                ()
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        spender: tuple.1,
-                        amount: tuple.2,
-                        expiration: tuple.3,
-                    }
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for LengthMismatch {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+        #[automatically_derived]
+        impl alloy_sol_types::SolError for LengthMismatch {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [255u8, 99u8, 58u8, 56u8];
+            const SIGNATURE: &'static str = "LengthMismatch()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Self::new)
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: approveReturn) -> Self {
-                    ()
-                }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Custom error with signature `SignatureExpired(uint256)` and selector `0xcd21db4f`.
+    ```solidity
+    error SignatureExpired(uint256 signatureDeadline);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct SignatureExpired {
+        #[allow(missing_docs)]
+        pub signatureDeadline: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        #[doc(hidden)]
+        #[allow(dead_code)]
+        type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+        #[doc(hidden)]
+        type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+        #[cfg(test)]
+        #[allow(dead_code, unreachable_patterns)]
+        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+            match _t {
+                alloy_sol_types::private::AssertTypeEq::<
+                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                >(_) => {}
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
+        }
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<SignatureExpired> for UnderlyingRustTuple<'_> {
+            fn from(value: SignatureExpired) -> Self {
+                (value.signatureDeadline,)
             }
         }
-        impl approveReturn {
-            fn _tokenize(&self) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        #[automatically_derived]
+        #[doc(hidden)]
+        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureExpired {
+            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                Self {
+                    signatureDeadline: tuple.0,
+                }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for approveCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<48>,
-            );
-            type Return = approveReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+        impl alloy_sol_types::SolError for SignatureExpired {
+            type Parameters<'a> = UnderlyingSolTuple<'a>;
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [135u8, 81u8, 124u8, 69u8];
-            const SIGNATURE: &'static str = "approve(address,address,uint160,uint48)";
+            const SELECTOR: [u8; 4] = [205u8, 33u8, 219u8, 79u8];
+            const SIGNATURE: &'static str = "SignatureExpired(uint256)";
 
             #[inline]
             fn new<'a>(
@@ -4648,62 +1947,45 @@ pub mod Permit2 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.spender,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.expiration,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.signatureDeadline,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                approveReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
+                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(Self::new)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `invalidateNonces(address,address,uint48)` and selector `0x65d9723c`.
+    /**Event with signature `Approval(address,address,address,uint160,uint48)` and selector `0xda9fa7c1b00402c17d0161b249b1ab8bbec047c5a52207b9c112deffd817036b`.
     ```solidity
-    function invalidateNonces(address token, address spender, uint48 newNonce) external;
+    event Approval(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct invalidateNoncesCall {
+    pub struct Approval {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
         pub token: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
         pub spender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub newNonce: alloy_sol_types::private::primitives::aliases::U48,
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
     }
-    ///Container type for the return parameters of the
-    /// [`invalidateNonces(address,address,uint48)`](invalidateNoncesCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct invalidateNoncesReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4712,109 +1994,197 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Approval {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
                 alloy_sol_types::sol_data::Uint<48>,
             );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U48,
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Approval(address,address,address,uint160,uint48)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    218u8, 159u8, 167u8, 193u8, 176u8, 4u8, 2u8, 193u8, 125u8, 1u8, 97u8, 178u8,
+                    73u8, 177u8, 171u8, 139u8, 190u8, 192u8, 71u8, 197u8, 165u8, 34u8, 7u8, 185u8,
+                    193u8, 18u8, 222u8, 255u8, 216u8, 23u8, 3u8, 107u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: topics.2,
+                    spender: topics.3,
+                    amount: data.0,
+                    expiration: data.1,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<invalidateNoncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: invalidateNoncesCall) -> Self {
-                    (value.token, value.spender, value.newNonce)
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateNoncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        spender: tuple.1,
-                        newNonce: tuple.2,
-                    }
-                }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                )
             }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.token.clone(),
+                    self.spender.clone(),
+                )
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<invalidateNoncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: invalidateNoncesReturn) -> Self {
-                    ()
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateNoncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Approval {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
         }
-        impl invalidateNoncesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <invalidateNoncesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        #[automatically_derived]
+        impl From<&Approval> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Approval) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `Lockdown(address,address,address)` and selector `0x89b1add15eff56b3dfe299ad94e01f2b52fbcb80ae1a3baea6ae8c04cb2b98a4`.
+    ```solidity
+    event Lockdown(address indexed owner, address token, address spender);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct Lockdown {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for invalidateNoncesCall {
-            type Parameters<'a> = (
+        impl alloy_sol_types::SolEvent for Lockdown {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<48>,
             );
-            type Return = invalidateNoncesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [101u8, 217u8, 114u8, 60u8];
-            const SIGNATURE: &'static str = "invalidateNonces(address,address,uint48)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Lockdown(address,address,address)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    137u8, 177u8, 173u8, 209u8, 94u8, 255u8, 86u8, 179u8, 223u8, 226u8, 153u8,
+                    173u8, 148u8, 224u8, 31u8, 43u8, 82u8, 251u8, 203u8, 128u8, 174u8, 26u8, 59u8,
+                    174u8, 166u8, 174u8, 140u8, 4u8, 203u8, 43u8, 152u8, 164u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    owner: topics.1,
+                    token: data.0,
+                    spender: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
+            }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.token,
@@ -4822,51 +2192,71 @@ pub mod Permit2 {
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.spender,
                     ),
-                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
-                        &self.newNonce,
-                    ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                invalidateNoncesReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Lockdown {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&Lockdown> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &Lockdown) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `invalidateUnorderedNonces(uint256,uint256)` and selector `0x3ff9dcb1`.
+    /**Event with signature `NonceInvalidation(address,address,address,uint48,uint48)` and selector `0x55eb90d810e1700b35a8e7e25395ff7f2b2259abd7415ca2284dfb1c246418f3`.
     ```solidity
-    function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
+    event NonceInvalidation(address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct invalidateUnorderedNoncesCall {
+    pub struct NonceInvalidation {
         #[allow(missing_docs)]
-        pub wordPos: alloy_sol_types::private::primitives::aliases::U256,
+        pub owner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub mask: alloy_sol_types::private::primitives::aliases::U256,
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub newNonce: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub oldNonce: alloy_sol_types::private::primitives::aliases::U48,
     }
-    ///Container type for the return parameters of the
-    /// [`invalidateUnorderedNonces(uint256,
-    /// uint256)`](invalidateUnorderedNoncesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct invalidateUnorderedNoncesReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4875,154 +2265,146 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<invalidateUnorderedNoncesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: invalidateUnorderedNoncesCall) -> Self {
-                    (value.wordPos, value.mask)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateUnorderedNoncesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        wordPos: tuple.0,
-                        mask: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<invalidateUnorderedNoncesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: invalidateUnorderedNoncesReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for invalidateUnorderedNoncesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl invalidateUnorderedNoncesReturn {
-            fn _tokenize(
-                &self,
-            ) -> <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for invalidateUnorderedNoncesCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
+        impl alloy_sol_types::SolEvent for NonceInvalidation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return = invalidateUnorderedNoncesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [63u8, 249u8, 220u8, 177u8];
-            const SIGNATURE: &'static str = "invalidateUnorderedNonces(uint256,uint256)";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str =
+                "NonceInvalidation(address,address,address,uint48,uint48)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    85u8, 235u8, 144u8, 216u8, 16u8, 225u8, 112u8, 11u8, 53u8, 168u8, 231u8, 226u8,
+                    83u8, 149u8, 255u8, 127u8, 43u8, 34u8, 89u8, 171u8, 215u8, 65u8, 92u8, 162u8,
+                    40u8, 77u8, 251u8, 28u8, 36u8, 100u8, 24u8, 243u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: topics.2,
+                    spender: topics.3,
+                    newNonce: data.0,
+                    oldNonce: data.1,
+                }
+            }
 
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.wordPos,
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.newNonce,
                     ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.mask,
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.oldNonce,
                     ),
                 )
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                invalidateUnorderedNoncesReturn::_tokenize(ret)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.token.clone(),
+                    self.spender.clone(),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for NonceInvalidation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
             }
 
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&NonceInvalidation> for alloy_sol_types::private::LogData {
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn from(this: &NonceInvalidation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `lockdown((address,address)[])` and selector `0xcc53287f`.
+    /**Event with signature `Permit(address,address,address,uint160,uint48,uint48)` and selector `0xc6a377bfc4eb120024a8ac08eef205be16b817020812c73223e81d1bdb9708ec`.
     ```solidity
-    function lockdown(IAllowanceTransfer.TokenSpenderPair[] memory approvals) external;
+    event Permit(address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration, uint48 nonce);
     ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
     #[derive(Clone)]
-    pub struct lockdownCall {
+    pub struct Permit {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub token: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub approvals: alloy_sol_types::private::Vec<
-            <IAllowanceTransfer::TokenSpenderPair as alloy_sol_types::SolType>::RustType,
-        >,
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
     }
-    ///Container type for the return parameters of the
-    /// [`lockdown((address,address)[])`](lockdownCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct lockdownReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5031,145 +2413,266 @@ pub mod Permit2 {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<IAllowanceTransfer::TokenSpenderPair>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<
-                    <IAllowanceTransfer::TokenSpenderPair as alloy_sol_types::SolType>::RustType,
-                >,
+        #[automatically_derived]
+        impl alloy_sol_types::SolEvent for Permit {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
             );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "Permit(address,address,address,uint160,uint48,uint48)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    198u8, 163u8, 119u8, 191u8, 196u8, 235u8, 18u8, 0u8, 36u8, 168u8, 172u8, 8u8,
+                    238u8, 242u8, 5u8, 190u8, 22u8, 184u8, 23u8, 2u8, 8u8, 18u8, 199u8, 50u8, 35u8,
+                    232u8, 29u8, 27u8, 219u8, 151u8, 8u8, 236u8,
+                ]);
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                Self {
+                    owner: topics.1,
+                    token: topics.2,
+                    spender: topics.3,
+                    amount: data.0,
+                    expiration: data.1,
+                    nonce: data.2,
                 }
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<lockdownCall> for UnderlyingRustTuple<'_> {
-                fn from(value: lockdownCall) -> Self {
-                    (value.approvals,)
+
+            #[inline]
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
                 }
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lockdownCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { approvals: tuple.0 }
-                }
+
+            #[inline]
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
             }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
+
+            #[inline]
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (
+                    Self::SIGNATURE_HASH.into(),
+                    self.owner.clone(),
+                    self.token.clone(),
+                    self.spender.clone(),
+                )
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<lockdownReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: lockdownReturn) -> Self {
-                    ()
+
+            #[inline]
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
                 }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                out[2usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.token,
+                );
+                out[3usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.spender,
+                );
+                Ok(())
             }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for lockdownReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for Permit {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
             }
         }
-        impl lockdownReturn {
-            fn _tokenize(&self) -> <lockdownCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        #[automatically_derived]
+        impl From<&Permit> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &Permit) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Event with signature `UnorderedNonceInvalidation(address,uint256,uint256)` and selector `0x3704902f963766a4e561bbaab6e6cdc1b1dd12f6e9e99648da8843b3f46b918d`.
+    ```solidity
+    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
+    ```*/
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    #[derive(Clone)]
+    pub struct UnorderedNonceInvalidation {
+        #[allow(missing_docs)]
+        pub owner: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub word: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub mask: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for lockdownCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<IAllowanceTransfer::TokenSpenderPair>,);
-            type Return = lockdownReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+        impl alloy_sol_types::SolEvent for UnorderedNonceInvalidation {
+            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type DataTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type TopicList = (
+                alloy_sol_types::sol_data::FixedBytes<32>,
+                alloy_sol_types::sol_data::Address,
+            );
 
-            const SELECTOR: [u8; 4] = [204u8, 83u8, 40u8, 127u8];
-            const SIGNATURE: &'static str = "lockdown((address,address)[])";
+            const ANONYMOUS: bool = false;
+            const SIGNATURE: &'static str = "UnorderedNonceInvalidation(address,uint256,uint256)";
+            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
+                alloy_sol_types::private::B256::new([
+                    55u8, 4u8, 144u8, 47u8, 150u8, 55u8, 102u8, 164u8, 229u8, 97u8, 187u8, 170u8,
+                    182u8, 230u8, 205u8, 193u8, 177u8, 221u8, 18u8, 246u8, 233u8, 233u8, 150u8,
+                    72u8, 218u8, 136u8, 67u8, 179u8, 244u8, 107u8, 145u8, 141u8,
+                ]);
 
+            #[allow(unused_variables)]
             #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            fn new(
+                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
+                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
             ) -> Self {
-                tuple.into()
+                Self {
+                    owner: topics.1,
+                    word: data.0,
+                    mask: data.1,
+                }
             }
 
             #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    IAllowanceTransfer::TokenSpenderPair,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.approvals
-                ),)
+            fn check_signature(
+                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
+            ) -> alloy_sol_types::Result<()> {
+                if topics.0 != Self::SIGNATURE_HASH {
+                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
+                        Self::SIGNATURE,
+                        topics.0,
+                        Self::SIGNATURE_HASH,
+                    ));
+                }
+                Ok(())
             }
 
             #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                lockdownReturn::_tokenize(ret)
+            fn tokenize_body(&self) -> Self::DataToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.word,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.mask,
+                    ),
+                )
             }
 
             #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
+                (Self::SIGNATURE_HASH.into(), self.owner.clone())
             }
 
             #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+            fn encode_topics_raw(
+                &self,
+                out: &mut [alloy_sol_types::abi::token::WordToken],
+            ) -> alloy_sol_types::Result<()> {
+                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
+                    return Err(alloy_sol_types::Error::Overrun);
+                }
+                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
+                out[1usize] = <alloy_sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
+                    &self.owner,
+                );
+                Ok(())
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::private::IntoLogData for UnorderedNonceInvalidation {
+            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
+                From::from(self)
+            }
+
+            fn into_log_data(self) -> alloy_sol_types::private::LogData {
+                From::from(&self)
+            }
+        }
+        #[automatically_derived]
+        impl From<&UnorderedNonceInvalidation> for alloy_sol_types::private::LogData {
+            #[inline]
+            fn from(this: &UnorderedNonceInvalidation) -> alloy_sol_types::private::LogData {
+                alloy_sol_types::SolEvent::encode_log_data(this)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `nonceBitmap(address,uint256)` and selector `0x4fe02b44`.
+    /**Function with signature `DOMAIN_SEPARATOR()` and selector `0x3644e515`.
     ```solidity
-    function nonceBitmap(address, uint256) external view returns (uint256);
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nonceBitmapCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct DOMAIN_SEPARATORCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`nonceBitmap(address,uint256)`](nonceBitmapCall) function.
+    /// [`DOMAIN_SEPARATOR()`](DOMAIN_SEPARATORCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct nonceBitmapReturn {
+    pub struct DOMAIN_SEPARATORReturn {
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub _0: alloy_sol_types::private::FixedBytes<32>,
     }
     #[allow(
         non_camel_case_types,
@@ -5182,15 +2685,9 @@ pub mod Permit2 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5202,28 +2699,25 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nonceBitmapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: nonceBitmapCall) -> Self {
-                    (value._0, value._1)
+            impl ::core::convert::From<DOMAIN_SEPARATORCall> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceBitmapCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5235,32 +2729,29 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<nonceBitmapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: nonceBitmapReturn) -> Self {
+            impl ::core::convert::From<DOMAIN_SEPARATORReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: DOMAIN_SEPARATORReturn) -> Self {
                     (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for nonceBitmapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for DOMAIN_SEPARATORReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for nonceBitmapCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for DOMAIN_SEPARATORCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::FixedBytes<32>;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [79u8, 224u8, 43u8, 68u8];
-            const SIGNATURE: &'static str = "nonceBitmap(address,uint256)";
+            const SELECTOR: [u8; 4] = [54u8, 68u8, 229u8, 21u8];
+            const SIGNATURE: &'static str = "DOMAIN_SEPARATOR()";
 
             #[inline]
             fn new<'a>(
@@ -5271,22 +2762,15 @@ pub mod Permit2 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(ret),
                 )
             }
 
@@ -5294,7 +2778,7 @@ pub mod Permit2 {
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: nonceBitmapReturn = r.into();
+                        let r: DOMAIN_SEPARATORReturn = r.into();
                         r._0
                     },
                 )
@@ -5306,33 +2790,40 @@ pub mod Permit2 {
                     data,
                 )
                 .map(|r| {
-                    let r: nonceBitmapReturn = r.into();
+                    let r: DOMAIN_SEPARATORReturn = r.into();
                     r._0
                 })
             }
         }
     };
-    #[derive()]
-    /**Function with signature `permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)` and selector `0x2b67b570`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address,address)` and selector `0x927da105`.
     ```solidity
-    function permit(address owner, IAllowanceTransfer.PermitSingle memory permitSingle, bytes memory signature) external;
+    function allowance(address, address, address) external view returns (uint160 amount, uint48 expiration, uint48 nonce);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitCall {
+    pub struct allowanceCall {
         #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
+        pub _0: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub permitSingle: <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
+        pub _1: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub signature: alloy_sol_types::private::Bytes,
+        pub _2: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`permit(address,((address,uint160,uint48,uint48),address,uint256),
-    /// bytes)`](permitCall) function.
+    /// [`allowance(address,address,address)`](allowanceCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitReturn {}
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
+        #[allow(missing_docs)]
+        pub nonce: alloy_sol_types::private::primitives::aliases::U48,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5346,14 +2837,14 @@ pub mod Permit2 {
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Address,
-                IAllowanceTransfer::PermitSingle,
-                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::Address,
-                <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5366,19 +2857,19 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitCall) -> Self {
-                    (value.owner, value.permitSingle, value.signature)
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value._0, value._1, value._2)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        owner: tuple.0,
-                        permitSingle: tuple.1,
-                        signature: tuple.2,
+                        _0: tuple.0,
+                        _1: tuple.1,
+                        _2: tuple.2,
                     }
                 }
             }
@@ -5386,9 +2877,17 @@ pub mod Permit2 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::primitives::aliases::U48,
+                alloy_sol_types::private::primitives::aliases::U48,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5400,39 +2899,56 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitReturn) -> Self {
-                    ()
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value.amount, value.expiration, value.nonce)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        amount: tuple.0,
+                        expiration: tuple.1,
+                        nonce: tuple.2,
+                    }
                 }
             }
         }
-        impl permitReturn {
-            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+        impl allowanceReturn {
+            fn _tokenize(&self) -> <allowanceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.nonce,
+                    ),
+                )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitCall {
+        impl alloy_sol_types::SolCall for allowanceCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Address,
-                IAllowanceTransfer::PermitSingle,
-                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return = permitReturn;
+            type Return = allowanceReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
+                alloy_sol_types::sol_data::Uint<48>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [43u8, 103u8, 181u8, 112u8];
-            const SIGNATURE: &'static str =
-                "permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)";
+            const SELECTOR: [u8; 4] = [146u8, 125u8, 161u8, 5u8];
+            const SIGNATURE: &'static str = "allowance(address,address,address)";
 
             #[inline]
             fn new<'a>(
@@ -5445,20 +2961,20 @@ pub mod Permit2 {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
+                        &self._0,
                     ),
-                    <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::tokenize(
-                        &self.permitSingle,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
                     ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._2,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitReturn::_tokenize(ret)
+                allowanceReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5476,30 +2992,28 @@ pub mod Permit2 {
             }
         }
     };
-    #[derive()]
-    /**Function with signature `permitTransferFrom(((address,uint256),uint256,uint256),(address,uint256),address,bytes)` and selector `0x30f28b7a`.
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,address,uint160,uint48)` and selector `0x87517c45`.
     ```solidity
-    function permitTransferFrom(ISignatureTransfer.PermitTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails memory transferDetails, address owner, bytes memory signature) external;
+    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitTransferFromCall {
+    pub struct approveCall {
         #[allow(missing_docs)]
-        pub permit: <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::RustType,
+        pub token: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub transferDetails:
-            <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
+        pub spender: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub owner: alloy_sol_types::private::Address,
+        pub amount: alloy_sol_types::private::primitives::aliases::U160,
         #[allow(missing_docs)]
-        pub signature: alloy_sol_types::private::Bytes,
+        pub expiration: alloy_sol_types::private::primitives::aliases::U48,
     }
     ///Container type for the return parameters of the
-    /// [`permitTransferFrom(((address,uint256),uint256,uint256),(address,
-    /// uint256),address,bytes)`](permitTransferFromCall) function.
+    /// [`approve(address,address,uint160,uint48)`](approveCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitTransferFromReturn {}
+    pub struct approveReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5512,17 +3026,17 @@ pub mod Permit2 {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                ISignatureTransfer::PermitTransferFrom,
-                ISignatureTransfer::SignatureTransferDetails,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::RustType,
-                <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::Bytes,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::primitives::aliases::U48,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5535,25 +3049,20 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitTransferFromCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitTransferFromCall) -> Self {
-                    (
-                        value.permit,
-                        value.transferDetails,
-                        value.owner,
-                        value.signature,
-                    )
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.token, value.spender, value.amount, value.expiration)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitTransferFromCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        permit: tuple.0,
-                        transferDetails: tuple.1,
-                        owner: tuple.2,
-                        signature: tuple.3,
+                        token: tuple.0,
+                        spender: tuple.1,
+                        amount: tuple.2,
+                        expiration: tuple.3,
                     }
                 }
             }
@@ -5575,42 +3084,39 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitTransferFromReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitTransferFromReturn) -> Self {
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitTransferFromReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl permitTransferFromReturn {
-            fn _tokenize(
-                &self,
-            ) -> <permitTransferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl approveReturn {
+            fn _tokenize(&self) -> <approveCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitTransferFromCall {
+        impl alloy_sol_types::SolCall for approveCall {
             type Parameters<'a> = (
-                ISignatureTransfer::PermitTransferFrom,
-                ISignatureTransfer::SignatureTransferDetails,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bytes,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Uint<48>,
             );
-            type Return = permitTransferFromReturn;
+            type Return = approveReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [48u8, 242u8, 139u8, 122u8];
-            const SIGNATURE: &'static str = "permitTransferFrom(((address,uint256),uint256,\
-                                             uint256),(address,uint256),address,bytes)";
+            const SELECTOR: [u8; 4] = [135u8, 81u8, 124u8, 69u8];
+            const SIGNATURE: &'static str = "approve(address,address,uint160,uint48)";
 
             #[inline]
             fn new<'a>(
@@ -5622,24 +3128,24 @@ pub mod Permit2 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::tokenize(
-                        &self.permit,
-                    ),
-                    <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::tokenize(
-                        &self.transferDetails,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.token,
                     ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.owner,
+                        &self.spender,
                     ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.signature,
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<48> as alloy_sol_types::SolType>::tokenize(
+                        &self.expiration,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitTransferFromReturn::_tokenize(ret)
+                approveReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5658,36 +3164,26 @@ pub mod Permit2 {
         }
     };
     #[derive()]
-    /**Function with signature `permitWitnessTransferFrom(((address,uint256)[],uint256,uint256),(address,uint256)[],address,bytes32,string,bytes)` and selector `0xfe8ec1a7`.
+    /**Function with signature `permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)` and selector `0x2b67b570`.
     ```solidity
-    function permitWitnessTransferFrom(ISignatureTransfer.PermitBatchTransferFrom memory permit, ISignatureTransfer.SignatureTransferDetails[] memory transferDetails, address owner, bytes32 witness, string memory witnessTypeString, bytes memory signature) external;
+    function permit(address owner, IAllowanceTransfer.PermitSingle memory permitSingle, bytes memory signature) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitWitnessTransferFromCall {
-        #[allow(missing_docs)]
-        pub permit:
-            <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::RustType,
-        #[allow(missing_docs)]
-        pub transferDetails: alloy_sol_types::private::Vec<
-            <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
-        >,
+    pub struct permitCall {
         #[allow(missing_docs)]
         pub owner: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub witness: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub witnessTypeString: alloy_sol_types::private::String,
+        pub permitSingle: <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
         #[allow(missing_docs)]
         pub signature: alloy_sol_types::private::Bytes,
     }
     ///Container type for the return parameters of the
-    /// [`permitWitnessTransferFrom(((address,uint256)[],uint256,uint256),
-    /// (address,uint256)[],address,bytes32,string,
-    /// bytes)`](permitWitnessTransferFromCall) function.
+    /// [`permit(address,((address,uint160,uint48,uint48),address,uint256),
+    /// bytes)`](permitCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct permitWitnessTransferFromReturn {}
+    pub struct permitReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5700,22 +3196,14 @@ pub mod Permit2 {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                ISignatureTransfer::PermitBatchTransferFrom,
-                alloy_sol_types::sol_data::Array<ISignatureTransfer::SignatureTransferDetails>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::String,
+                IAllowanceTransfer::PermitSingle,
                 alloy_sol_types::sol_data::Bytes,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::RustType,
-                alloy_sol_types::private::Vec<
-                    <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
-                >,
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::String,
+                <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::RustType,
                 alloy_sol_types::private::Bytes,
             );
             #[cfg(test)]
@@ -5729,29 +3217,19 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitWitnessTransferFromCall> for UnderlyingRustTuple<'_> {
-                fn from(value: permitWitnessTransferFromCall) -> Self {
-                    (
-                        value.permit,
-                        value.transferDetails,
-                        value.owner,
-                        value.witness,
-                        value.witnessTypeString,
-                        value.signature,
-                    )
+            impl ::core::convert::From<permitCall> for UnderlyingRustTuple<'_> {
+                fn from(value: permitCall) -> Self {
+                    (value.owner, value.permitSingle, value.signature)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitWitnessTransferFromCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        permit: tuple.0,
-                        transferDetails: tuple.1,
-                        owner: tuple.2,
-                        witness: tuple.3,
-                        witnessTypeString: tuple.4,
-                        signature: tuple.5,
+                        owner: tuple.0,
+                        permitSingle: tuple.1,
+                        signature: tuple.2,
                     }
                 }
             }
@@ -5773,46 +3251,39 @@ pub mod Permit2 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<permitWitnessTransferFromReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: permitWitnessTransferFromReturn) -> Self {
+            impl ::core::convert::From<permitReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: permitReturn) -> Self {
                     ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitWitnessTransferFromReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for permitReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {}
                 }
             }
         }
-        impl permitWitnessTransferFromReturn {
-            fn _tokenize(
-                &self,
-            ) -> <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+        impl permitReturn {
+            fn _tokenize(&self) -> <permitCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 ()
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for permitWitnessTransferFromCall {
+        impl alloy_sol_types::SolCall for permitCall {
             type Parameters<'a> = (
-                ISignatureTransfer::PermitBatchTransferFrom,
-                alloy_sol_types::sol_data::Array<ISignatureTransfer::SignatureTransferDetails>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::String,
+                IAllowanceTransfer::PermitSingle,
                 alloy_sol_types::sol_data::Bytes,
             );
-            type Return = permitWitnessTransferFromReturn;
+            type Return = permitReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [254u8, 142u8, 193u8, 167u8];
-            const SIGNATURE: &'static str = "permitWitnessTransferFrom(((address,uint256)[],\
-                                             uint256,uint256),(address,uint256)[],address,bytes32,\
-                                             string,bytes)";
+            const SELECTOR: [u8; 4] = [43u8, 103u8, 181u8, 112u8];
+            const SIGNATURE: &'static str =
+                "permit(address,((address,uint160,uint48,uint48),address,uint256),bytes)";
 
             #[inline]
             fn new<'a>(
@@ -5824,20 +3295,11 @@ pub mod Permit2 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::tokenize(
-                        &self.permit,
-                    ),
-                    <alloy_sol_types::sol_data::Array<
-                        ISignatureTransfer::SignatureTransferDetails,
-                    > as alloy_sol_types::SolType>::tokenize(&self.transferDetails),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.owner,
                     ),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.witness),
-                    <alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
-                        &self.witnessTypeString,
+                    <IAllowanceTransfer::PermitSingle as alloy_sol_types::SolType>::tokenize(
+                        &self.permitSingle,
                     ),
                     <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
                         &self.signature,
@@ -5847,7 +3309,7 @@ pub mod Permit2 {
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                permitWitnessTransferFromReturn::_tokenize(ret)
+                permitReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -6047,20 +3509,8 @@ pub mod Permit2 {
         #[allow(missing_docs)]
         approve(approveCall),
         #[allow(missing_docs)]
-        invalidateNonces(invalidateNoncesCall),
-        #[allow(missing_docs)]
-        invalidateUnorderedNonces(invalidateUnorderedNoncesCall),
-        #[allow(missing_docs)]
-        lockdown(lockdownCall),
-        #[allow(missing_docs)]
-        nonceBitmap(nonceBitmapCall),
-        #[allow(missing_docs)]
         permit(permitCall),
         #[allow(missing_docs)]
-        permitTransferFrom(permitTransferFromCall),
-        #[allow(missing_docs)]
-        permitWitnessTransferFrom(permitWitnessTransferFromCall),
-        #[allow(missing_docs)]
         transferFrom(transferFromCall),
     }
     impl Permit2Calls {
@@ -6073,44 +3523,26 @@ pub mod Permit2 {
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [43u8, 103u8, 181u8, 112u8],
-            [48u8, 242u8, 139u8, 122u8],
             [54u8, 68u8, 229u8, 21u8],
             [54u8, 199u8, 133u8, 22u8],
-            [63u8, 249u8, 220u8, 177u8],
-            [79u8, 224u8, 43u8, 68u8],
-            [101u8, 217u8, 114u8, 60u8],
             [135u8, 81u8, 124u8, 69u8],
             [146u8, 125u8, 161u8, 5u8],
-            [204u8, 83u8, 40u8, 127u8],
-            [254u8, 142u8, 193u8, 167u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
             <permitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <permitTransferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <nonceBitmapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <invalidateNoncesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
             <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <lockdownCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(permit),
-            ::core::stringify!(permitTransferFrom),
             ::core::stringify!(DOMAIN_SEPARATOR),
             ::core::stringify!(transferFrom),
-            ::core::stringify!(invalidateUnorderedNonces),
-            ::core::stringify!(nonceBitmap),
-            ::core::stringify!(invalidateNonces),
             ::core::stringify!(approve),
             ::core::stringify!(allowance),
-            ::core::stringify!(lockdown),
-            ::core::stringify!(permitWitnessTransferFrom),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6135,7 +3567,7 @@ pub mod Permit2 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for Permit2Calls {
-        const COUNT: usize = 11usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "Permit2Calls";
 
@@ -6147,21 +3579,7 @@ pub mod Permit2 {
                 }
                 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::invalidateNonces(_) => {
-                    <invalidateNoncesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::invalidateUnorderedNonces(_) => {
-                    <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::lockdown(_) => <lockdownCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::nonceBitmap(_) => <nonceBitmapCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::permit(_) => <permitCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::permitTransferFrom(_) => {
-                    <permitTransferFromCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::permitWitnessTransferFrom(_) => {
-                    <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
             }
         }
@@ -6187,13 +3605,6 @@ pub mod Permit2 {
                     }
                     permit
                 },
-                {
-                    fn permitTransferFrom(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <permitTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(Permit2Calls::permitTransferFrom)
-                    }
-                    permitTransferFrom
-                },
                 {
                     fn DOMAIN_SEPARATOR(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
                         <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6208,31 +3619,6 @@ pub mod Permit2 {
                     }
                     transferFrom
                 },
-                {
-                    fn invalidateUnorderedNonces(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<Permit2Calls> {
-                        <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(Permit2Calls::invalidateUnorderedNonces)
-                    }
-                    invalidateUnorderedNonces
-                },
-                {
-                    fn nonceBitmap(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <nonceBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(Permit2Calls::nonceBitmap)
-                    }
-                    nonceBitmap
-                },
-                {
-                    fn invalidateNonces(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(Permit2Calls::invalidateNonces)
-                    }
-                    invalidateNonces
-                },
                 {
                     fn approve(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
                         <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6247,24 +3633,6 @@ pub mod Permit2 {
                     }
                     allowance
                 },
-                {
-                    fn lockdown(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <lockdownCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(Permit2Calls::lockdown)
-                    }
-                    lockdown
-                },
-                {
-                    fn permitWitnessTransferFrom(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<Permit2Calls> {
-                        <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(Permit2Calls::permitWitnessTransferFrom)
-                    }
-                    permitWitnessTransferFrom
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6289,15 +3657,6 @@ pub mod Permit2 {
                     }
                     permit
                 },
-                {
-                    fn permitTransferFrom(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <permitTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(Permit2Calls::permitTransferFrom)
-                    }
-                    permitTransferFrom
-                },
                 {
                     fn DOMAIN_SEPARATOR(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
                         <DOMAIN_SEPARATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6316,33 +3675,6 @@ pub mod Permit2 {
                     }
                     transferFrom
                 },
-                {
-                    fn invalidateUnorderedNonces(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<Permit2Calls> {
-                        <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(Permit2Calls::invalidateUnorderedNonces)
-                    }
-                    invalidateUnorderedNonces
-                },
-                {
-                    fn nonceBitmap(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <nonceBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(Permit2Calls::nonceBitmap)
-                    }
-                    nonceBitmap
-                },
-                {
-                    fn invalidateNonces(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(Permit2Calls::invalidateNonces)
-                    }
-                    invalidateNonces
-                },
                 {
                     fn approve(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
                         <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6357,24 +3689,6 @@ pub mod Permit2 {
                     }
                     allowance
                 },
-                {
-                    fn lockdown(data: &[u8]) -> alloy_sol_types::Result<Permit2Calls> {
-                        <lockdownCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(Permit2Calls::lockdown)
-                    }
-                    lockdown
-                },
-                {
-                    fn permitWitnessTransferFrom(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<Permit2Calls> {
-                        <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(Permit2Calls::permitWitnessTransferFrom)
-                    }
-                    permitWitnessTransferFrom
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6397,31 +3711,9 @@ pub mod Permit2 {
                 Self::approve(inner) => {
                     <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::invalidateNonces(inner) => {
-                    <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::invalidateUnorderedNonces(inner) => {
-                    <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::lockdown(inner) => {
-                    <lockdownCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::nonceBitmap(inner) => {
-                    <nonceBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::permitTransferFrom(inner) => {
-                    <permitTransferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::permitWitnessTransferFrom(inner) => {
-                    <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::transferFrom(inner) => {
                     <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -6440,31 +3732,9 @@ pub mod Permit2 {
                 Self::approve(inner) => {
                     <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::invalidateNonces(inner) => {
-                    <invalidateNoncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::invalidateUnorderedNonces(inner) => {
-                    <invalidateUnorderedNoncesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
-                Self::lockdown(inner) => {
-                    <lockdownCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::nonceBitmap(inner) => {
-                    <nonceBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::permit(inner) => {
                     <permitCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::permitTransferFrom(inner) => {
-                    <permitTransferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::permitWitnessTransferFrom(inner) => {
-                    <permitWitnessTransferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
                 Self::transferFrom(inner) => {
                     <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -7278,49 +4548,6 @@ pub mod Permit2 {
             })
         }
 
-        ///Creates a new call builder for the [`invalidateNonces`] function.
-        pub fn invalidateNonces(
-            &self,
-            token: alloy_sol_types::private::Address,
-            spender: alloy_sol_types::private::Address,
-            newNonce: alloy_sol_types::private::primitives::aliases::U48,
-        ) -> alloy_contract::SolCallBuilder<&P, invalidateNoncesCall, N> {
-            self.call_builder(&invalidateNoncesCall {
-                token,
-                spender,
-                newNonce,
-            })
-        }
-
-        ///Creates a new call builder for the [`invalidateUnorderedNonces`]
-        /// function.
-        pub fn invalidateUnorderedNonces(
-            &self,
-            wordPos: alloy_sol_types::private::primitives::aliases::U256,
-            mask: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, invalidateUnorderedNoncesCall, N> {
-            self.call_builder(&invalidateUnorderedNoncesCall { wordPos, mask })
-        }
-
-        ///Creates a new call builder for the [`lockdown`] function.
-        pub fn lockdown(
-            &self,
-            approvals: alloy_sol_types::private::Vec<
-                <IAllowanceTransfer::TokenSpenderPair as alloy_sol_types::SolType>::RustType,
-            >,
-        ) -> alloy_contract::SolCallBuilder<&P, lockdownCall, N> {
-            self.call_builder(&lockdownCall { approvals })
-        }
-
-        ///Creates a new call builder for the [`nonceBitmap`] function.
-        pub fn nonceBitmap(
-            &self,
-            _0: alloy_sol_types::private::Address,
-            _1: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, nonceBitmapCall, N> {
-            self.call_builder(&nonceBitmapCall { _0, _1 })
-        }
-
         ///Creates a new call builder for the [`permit`] function.
         pub fn permit(
             &self,
@@ -7335,45 +4562,6 @@ pub mod Permit2 {
             })
         }
 
-        ///Creates a new call builder for the [`permitTransferFrom`] function.
-        pub fn permitTransferFrom(
-            &self,
-            permit: <ISignatureTransfer::PermitTransferFrom as alloy_sol_types::SolType>::RustType,
-            transferDetails: <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
-            owner: alloy_sol_types::private::Address,
-            signature: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, permitTransferFromCall, N> {
-            self.call_builder(&permitTransferFromCall {
-                permit,
-                transferDetails,
-                owner,
-                signature,
-            })
-        }
-
-        ///Creates a new call builder for the [`permitWitnessTransferFrom`]
-        /// function.
-        pub fn permitWitnessTransferFrom(
-            &self,
-            permit: <ISignatureTransfer::PermitBatchTransferFrom as alloy_sol_types::SolType>::RustType,
-            transferDetails: alloy_sol_types::private::Vec<
-                <ISignatureTransfer::SignatureTransferDetails as alloy_sol_types::SolType>::RustType,
-            >,
-            owner: alloy_sol_types::private::Address,
-            witness: alloy_sol_types::private::FixedBytes<32>,
-            witnessTypeString: alloy_sol_types::private::String,
-            signature: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, permitWitnessTransferFromCall, N> {
-            self.call_builder(&permitWitnessTransferFromCall {
-                permit,
-                transferDetails,
-                owner,
-                witness,
-                witnessTypeString,
-                signature,
-            })
-        }
-
         ///Creates a new call builder for the [`transferFrom`] function.
         pub fn transferFrom(
             &self,
diff --git a/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs b/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs
index c62b7b87f0..2bc72c6cbe 100644
--- a/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/sushiswaprouter/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface SushiSwapRouter {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -120,4777 +101,113 @@ interface SushiSwapRouter {
   },
   {
     "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "factory",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "quote",
-    "inputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod SushiSwapRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
-    ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod SushiSwapRouter {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4902,21 +219,9 @@ pub mod SushiSwapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4928,41 +233,25 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4974,50 +263,29 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -5028,34 +296,22 @@ pub mod SushiSwapRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5063,24 +319,33 @@ pub mod SushiSwapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod SushiSwapRouter {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod SushiSwapRouter {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod SushiSwapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod SushiSwapRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod SushiSwapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod SushiSwapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5435,34 +683,22 @@ pub mod SushiSwapRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod SushiSwapRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod SushiSwapRouter {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod SushiSwapRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod SushiSwapRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod SushiSwapRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod SushiSwapRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod SushiSwapRouter {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl SushiSwapRouterCalls {
@@ -5949,84 +1110,27 @@ pub mod SushiSwapRouter {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6051,220 +1155,37 @@ pub mod SushiSwapRouter {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for SushiSwapRouterCalls {
-        const COUNT: usize = 24usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "SushiSwapRouterCalls";
 
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactTokens(_) => {
-                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls>] = &[
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6290,41 +1211,6 @@ pub mod SushiSwapRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6332,24 +1218,6 @@ pub mod SushiSwapRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6357,26 +1225,6 @@ pub mod SushiSwapRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SushiSwapRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6397,136 +1245,6 @@ pub mod SushiSwapRouter {
                 &[u8],
             )
                 -> alloy_sol_types::Result<SushiSwapRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(SushiSwapRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6552,43 +1270,6 @@ pub mod SushiSwapRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SushiSwapRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6596,26 +1277,6 @@ pub mod SushiSwapRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6625,28 +1286,6 @@ pub mod SushiSwapRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SushiSwapRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SushiSwapRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SushiSwapRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6661,115 +1300,16 @@ pub mod SushiSwapRouter {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6786,137 +1326,17 @@ pub mod SushiSwapRouter {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7060,77 +1480,11 @@ pub mod SushiSwapRouter {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7145,327 +1499,6 @@ pub mod SushiSwapRouter {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/swaprrouter/src/lib.rs b/contracts/generated/contracts-generated/swaprrouter/src/lib.rs
index f343552f44..08100f9c89 100644
--- a/contracts/generated/contracts-generated/swaprrouter/src/lib.rs
+++ b/contracts/generated/contracts-generated/swaprrouter/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface SwaprRouter {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -118,60 +99,6 @@ interface SwaprRouter {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
   {
     "type": "function",
     "name": "factory",
@@ -185,112 +112,6 @@ interface SwaprRouter {
     ],
     "stateMutability": "pure"
   },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "quote",
@@ -322,130 +143,22 @@ interface SwaprRouter {
   },
   {
     "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "name": "swapTokensForExactTokens",
     "inputs": [
       {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
+        "name": "amountOut",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountTokenMin",
+        "name": "amountInMax",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
       },
       {
         "name": "to",
@@ -460,4237 +173,40 @@ interface SwaprRouter {
     ],
     "outputs": [
       {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod SwaprRouter {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod SwaprRouter {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct WETHCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
+    /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
+    pub struct WETHReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -4703,21 +219,9 @@ pub mod SwaprRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4729,40 +233,25 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4774,38 +263,29 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { _0: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -4816,38 +296,20 @@ pub mod SwaprRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
+                        let r: WETHReturn = r.into();
+                        r._0
                     },
                 )
             }
@@ -4858,229 +320,32 @@ pub mod SwaprRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
-    ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod SwaprRouter {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod SwaprRouter {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod SwaprRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod SwaprRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod SwaprRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod SwaprRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5435,34 +683,22 @@ pub mod SwaprRouter {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod SwaprRouter {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod SwaprRouter {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod SwaprRouter {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod SwaprRouter {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod SwaprRouter {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod SwaprRouter {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod SwaprRouter {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl SwaprRouterCalls {
@@ -5949,84 +1110,27 @@ pub mod SwaprRouter {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6046,225 +1150,42 @@ pub mod SwaprRouter {
         #[inline]
         pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
             let sig = Self::signature_by_selector(selector)?;
-            sig.split_once('(').map(|(name, _)| name)
-        }
-    }
-    #[automatically_derived]
-    impl alloy_sol_types::SolInterface for SwaprRouterCalls {
-        const COUNT: usize = 24usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
-        const NAME: &'static str = "SwaprRouterCalls";
-
-        #[inline]
-        fn selector(&self) -> [u8; 4] {
-            match self {
-                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactTokens(_) => {
-                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-            }
-        }
-
-        #[inline]
-        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
-            Self::SELECTORS.get(i).copied()
-        }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SwaprRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for SwaprRouterCalls {
+        const COUNT: usize = 5usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "SwaprRouterCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::swapTokensForExactTokens(_) => {
+                    <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<SwaprRouterCalls>] = &[
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6290,39 +1211,6 @@ pub mod SwaprRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6330,24 +1218,6 @@ pub mod SwaprRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6355,24 +1225,6 @@ pub mod SwaprRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(SwaprRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6393,136 +1245,6 @@ pub mod SwaprRouter {
                 &[u8],
             )
                 -> alloy_sol_types::Result<SwaprRouterCalls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(SwaprRouterCalls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6548,41 +1270,6 @@ pub mod SwaprRouter {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                SwaprRouterCalls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6590,26 +1277,6 @@ pub mod SwaprRouter {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
                         <addLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -6619,26 +1286,6 @@ pub mod SwaprRouter {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(data: &[u8]) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(SwaprRouterCalls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<SwaprRouterCalls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(SwaprRouterCalls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6653,115 +1300,16 @@ pub mod SwaprRouter {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6778,137 +1326,17 @@ pub mod SwaprRouter {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7052,77 +1480,11 @@ pub mod SwaprRouter {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7137,327 +1499,6 @@ pub mod SwaprRouter {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs b/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs
index 5947b91bf4..82fea0f265 100644
--- a/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs
+++ b/contracts/generated/contracts-generated/testnetuniswapv2router02/src/lib.rs
@@ -13,27 +13,8 @@ Generated by the following Solidity interface...
 interface TestnetUniswapV2Router02 {
     function WETH() external pure returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external pure returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -120,4777 +101,113 @@ interface TestnetUniswapV2Router02 {
   },
   {
     "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "factory",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "quote",
-    "inputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod TestnetUniswapV2Router02 {
-    use {super::*, alloy_sol_types};
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external pure returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
-    ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
+    "name": "factory",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "quote",
+    "inputs": [
+      {
+        "name": "amountA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveA",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "reserveB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amountB",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "swapTokensForExactTokens",
+    "inputs": [
+      {
+        "name": "amountOut",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "amountInMax",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod TestnetUniswapV2Router02 {
+    use {super::*, alloy_sol_types};
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function WETH() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -4902,21 +219,9 @@ pub mod TestnetUniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4928,41 +233,25 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -4974,50 +263,29 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -5028,34 +296,22 @@ pub mod TestnetUniswapV2Router02 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5063,24 +319,33 @@ pub mod TestnetUniswapV2Router02 {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5088,14 +353,17 @@ pub mod TestnetUniswapV2Router02 {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
+        #[allow(missing_docs)]
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5109,17 +377,23 @@ pub mod TestnetUniswapV2Router02 {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5134,12 +408,15 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5147,14 +424,17 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5162,11 +442,16 @@ pub mod TestnetUniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5179,38 +464,62 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5222,39 +531,42 @@ pub mod TestnetUniswapV2Router02 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5262,40 +574,27 @@ pub mod TestnetUniswapV2Router02 {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external pure returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5307,21 +606,9 @@ pub mod TestnetUniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5333,41 +620,25 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5379,52 +650,29 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5435,34 +683,22 @@ pub mod TestnetUniswapV2Router02 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5470,39 +706,36 @@ pub mod TestnetUniswapV2Router02 {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5518,16 +751,12 @@ pub mod TestnetUniswapV2Router02 {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5541,27 +770,19 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5569,12 +790,9 @@ pub mod TestnetUniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5586,38 +804,33 @@ pub mod TestnetUniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5629,37 +842,33 @@ pub mod TestnetUniswapV2Router02 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5670,8 +879,8 @@ pub mod TestnetUniswapV2Router02 {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -5886,58 +1095,10 @@ pub mod TestnetUniswapV2Router02 {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl TestnetUniswapV2Router02Calls {
@@ -5949,84 +1110,27 @@ pub mod TestnetUniswapV2Router02 {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6051,7 +1155,7 @@ pub mod TestnetUniswapV2Router02 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for TestnetUniswapV2Router02Calls {
-        const COUNT: usize = 24usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "TestnetUniswapV2Router02Calls";
 
@@ -6059,68 +1163,9 @@ pub mod TestnetUniswapV2Router02 {
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::swapTokensForExactTokens(_) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -6144,148 +1189,6 @@ pub mod TestnetUniswapV2Router02 {
                 &[u8],
             )
                 -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6296,62 +1199,24 @@ pub mod TestnetUniswapV2Router02 {
                         )
                         .map(TestnetUniswapV2Router02Calls::swapTokensForExactTokens)
                     }
-                    swapTokensForExactTokens
-                },
-                {
-                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls> {
-                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::WETH)
-                    }
-                    WETH
-                },
-                {
-                    fn quote(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::quote)
-                    }
-                    quote
-                },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
+                    swapTokensForExactTokens
+                },
+                {
+                    fn WETH(data: &[u8]) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls> {
+                        <WETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::WETH)
                     }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
+                    WETH
                 },
                 {
-                    fn removeLiquidity(
+                    fn quote(
                         data: &[u8],
                     ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
                     {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::removeLiquidity)
+                        <quoteCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(TestnetUniswapV2Router02Calls::quote)
                     }
-                    removeLiquidity
+                    quote
                 },
                 {
                     fn factory(
@@ -6363,30 +1228,6 @@ pub mod TestnetUniswapV2Router02 {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermit,
-                            )
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(
                         data: &[u8],
@@ -6397,28 +1238,6 @@ pub mod TestnetUniswapV2Router02 {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(TestnetUniswapV2Router02Calls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6440,156 +1259,6 @@ pub mod TestnetUniswapV2Router02 {
             ) -> alloy_sol_types::Result<
                 TestnetUniswapV2Router02Calls,
             >] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(TestnetUniswapV2Router02Calls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(TestnetUniswapV2Router02Calls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityWithPermit,
-                            )
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(TestnetUniswapV2Router02Calls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(TestnetUniswapV2Router02Calls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(TestnetUniswapV2Router02Calls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(TestnetUniswapV2Router02Calls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6619,46 +1288,6 @@ pub mod TestnetUniswapV2Router02 {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(
                         data: &[u8],
@@ -6669,32 +1298,6 @@ pub mod TestnetUniswapV2Router02 {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                TestnetUniswapV2Router02Calls::removeLiquidityETHWithPermit,
-                            )
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(
                         data: &[u8],
@@ -6707,30 +1310,6 @@ pub mod TestnetUniswapV2Router02 {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(TestnetUniswapV2Router02Calls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<TestnetUniswapV2Router02Calls>
-                    {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(TestnetUniswapV2Router02Calls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6745,115 +1324,16 @@ pub mod TestnetUniswapV2Router02 {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6870,137 +1350,17 @@ pub mod TestnetUniswapV2Router02 {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7144,77 +1504,11 @@ pub mod TestnetUniswapV2Router02 {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7229,327 +1523,6 @@ pub mod TestnetUniswapV2Router02 {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs b/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs
index 33b655e28e..910bde2c93 100644
--- a/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv2factory/src/lib.rs
@@ -15,14 +15,8 @@ interface UniswapV2Factory {
 
     constructor(address _feeToSetter);
 
-    function allPairs(uint256) external view returns (address);
-    function allPairsLength() external view returns (uint256);
     function createPair(address tokenA, address tokenB) external returns (address pair);
-    function feeTo() external view returns (address);
-    function feeToSetter() external view returns (address);
     function getPair(address, address) external view returns (address);
-    function setFeeTo(address _feeTo) external;
-    function setFeeToSetter(address _feeToSetter) external;
 }
 ```
 
@@ -40,38 +34,6 @@ interface UniswapV2Factory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "allPairs",
-    "inputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "allPairsLength",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "createPair",
@@ -96,32 +58,6 @@ interface UniswapV2Factory {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "feeTo",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "feeToSetter",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "getPair",
@@ -146,32 +82,6 @@ interface UniswapV2Factory {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "setFeeTo",
-    "inputs": [
-      {
-        "name": "_feeTo",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setFeeToSetter",
-    "inputs": [
-      {
-        "name": "_feeToSetter",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "event",
     "name": "PairCreated",
@@ -392,861 +302,24 @@ pub mod UniswapV2Factory {
             #[doc(hidden)]
             impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
                 fn from(value: constructorCall) -> Self {
-                    (value._feeToSetter,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _feeToSetter: tuple.0,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._feeToSetter,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allPairs(uint256)` and selector `0x1e3dd18b`.
-    ```solidity
-    function allPairs(uint256) external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allPairsCall(pub alloy_sol_types::private::primitives::aliases::U256);
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allPairs(uint256)`](allPairsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allPairsReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allPairsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allPairsCall) -> Self {
-                    (value.0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allPairsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allPairsReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for allPairsCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [30u8, 61u8, 209u8, 139u8];
-            const SIGNATURE: &'static str = "allPairs(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: allPairsReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: allPairsReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `allPairsLength()` and selector `0x574f2ba3`.
-    ```solidity
-    function allPairsLength() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allPairsLengthCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`allPairsLength()`](allPairsLengthCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct allPairsLengthReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allPairsLengthCall> for UnderlyingRustTuple<'_> {
-                fn from(value: allPairsLengthCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsLengthCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<allPairsLengthReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: allPairsLengthReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allPairsLengthReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for allPairsLengthCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [87u8, 79u8, 43u8, 163u8];
-            const SIGNATURE: &'static str = "allPairsLength()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: allPairsLengthReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: allPairsLengthReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `createPair(address,address)` and selector `0xc9c65396`.
-    ```solidity
-    function createPair(address tokenA, address tokenB) external returns (address pair);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createPairCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`createPair(address,address)`](createPairCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct createPairReturn {
-        #[allow(missing_docs)]
-        pub pair: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createPairCall> for UnderlyingRustTuple<'_> {
-                fn from(value: createPairCall) -> Self {
-                    (value.tokenA, value.tokenB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPairCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<createPairReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: createPairReturn) -> Self {
-                    (value.pair,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPairReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { pair: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for createPairCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [201u8, 198u8, 83u8, 150u8];
-            const SIGNATURE: &'static str = "createPair(address,address)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: createPairReturn = r.into();
-                        r.pair
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: createPairReturn = r.into();
-                    r.pair
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `feeTo()` and selector `0x017e7e58`.
-    ```solidity
-    function feeTo() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct feeToCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`feeTo()`](feeToCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct feeToReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<feeToCall> for UnderlyingRustTuple<'_> {
-                fn from(value: feeToCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<feeToReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: feeToReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for feeToCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [1u8, 126u8, 126u8, 88u8];
-            const SIGNATURE: &'static str = "feeTo()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: feeToReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: feeToReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `feeToSetter()` and selector `0x094b7415`.
-    ```solidity
-    function feeToSetter() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct feeToSetterCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`feeToSetter()`](feeToSetterCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct feeToSetterReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<feeToSetterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: feeToSetterCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToSetterCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<feeToSetterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: feeToSetterReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeToSetterReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for feeToSetterCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [9u8, 75u8, 116u8, 21u8];
-            const SIGNATURE: &'static str = "feeToSetter()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: feeToSetterReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: feeToSetterReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getPair(address,address)` and selector `0xe6a43905`.
-    ```solidity
-    function getPair(address, address) external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPairCall {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _1: alloy_sol_types::private::Address,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getPair(address,address)`](getPairCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getPairReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPairCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getPairCall) -> Self {
-                    (value._0, value._1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPairCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _0: tuple.0,
-                        _1: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getPairReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getPairReturn) -> Self {
-                    (value._0,)
+                    (value._feeToSetter,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPairReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        _feeToSetter: tuple.0,
+                    }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for getPairCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [230u8, 164u8, 57u8, 5u8];
-            const SIGNATURE: &'static str = "getPair(address,address)";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -1258,57 +331,34 @@ pub mod UniswapV2Factory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._0,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._1,
+                        &self._feeToSetter,
                     ),
                 )
             }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getPairReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getPairReturn = r.into();
-                    r._0
-                })
-            }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setFeeTo(address)` and selector `0xf46901ed`.
+    /**Function with signature `createPair(address,address)` and selector `0xc9c65396`.
     ```solidity
-    function setFeeTo(address _feeTo) external;
+    function createPair(address tokenA, address tokenB) external returns (address pair);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setFeeToCall {
+    pub struct createPairCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub _feeTo: alloy_sol_types::private::Address,
+        pub tokenB: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setFeeTo(address)`](setFeeToCall) function.
+    /// [`createPair(address,address)`](createPairCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setFeeToReturn {}
+    pub struct createPairReturn {
+        #[allow(missing_docs)]
+        pub pair: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -1320,9 +370,15 @@ pub mod UniswapV2Factory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1334,25 +390,28 @@ pub mod UniswapV2Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setFeeToCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setFeeToCall) -> Self {
-                    (value._feeTo,)
+            impl ::core::convert::From<createPairCall> for UnderlyingRustTuple<'_> {
+                fn from(value: createPairCall) -> Self {
+                    (value.tokenA, value.tokenB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPairCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _feeTo: tuple.0 }
+                    Self {
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1364,34 +423,32 @@ pub mod UniswapV2Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setFeeToReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setFeeToReturn) -> Self {
-                    ()
+            impl ::core::convert::From<createPairReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: createPairReturn) -> Self {
+                    (value.pair,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPairReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { pair: tuple.0 }
                 }
             }
         }
-        impl setFeeToReturn {
-            fn _tokenize(&self) -> <setFeeToCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setFeeToCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setFeeToReturn;
+        impl alloy_sol_types::SolCall for createPairCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [244u8, 105u8, 1u8, 237u8];
-            const SIGNATURE: &'static str = "setFeeTo(address)";
+            const SELECTOR: [u8; 4] = [201u8, 198u8, 83u8, 150u8];
+            const SIGNATURE: &'static str = "createPair(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -1404,20 +461,27 @@ pub mod UniswapV2Factory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._feeTo,
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setFeeToReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: createPairReturn = r.into();
+                        r.pair
+                    },
+                )
             }
 
             #[inline]
@@ -1425,26 +489,35 @@ pub mod UniswapV2Factory {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: createPairReturn = r.into();
+                    r.pair
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setFeeToSetter(address)` and selector `0xa2e74af6`.
+    /**Function with signature `getPair(address,address)` and selector `0xe6a43905`.
     ```solidity
-    function setFeeToSetter(address _feeToSetter) external;
+    function getPair(address, address) external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setFeeToSetterCall {
+    pub struct getPairCall {
         #[allow(missing_docs)]
-        pub _feeToSetter: alloy_sol_types::private::Address,
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`setFeeToSetter(address)`](setFeeToSetterCall) function.
+    /// [`getPair(address,address)`](getPairCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct setFeeToSetterReturn {}
+    pub struct getPairReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -1456,9 +529,15 @@ pub mod UniswapV2Factory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1470,17 +549,18 @@ pub mod UniswapV2Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setFeeToSetterCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setFeeToSetterCall) -> Self {
-                    (value._feeToSetter,)
+            impl ::core::convert::From<getPairCall> for UnderlyingRustTuple<'_> {
+                fn from(value: getPairCall) -> Self {
+                    (value._0, value._1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToSetterCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPairCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        _feeToSetter: tuple.0,
+                        _0: tuple.0,
+                        _1: tuple.1,
                     }
                 }
             }
@@ -1488,9 +568,9 @@ pub mod UniswapV2Factory {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -1502,36 +582,32 @@ pub mod UniswapV2Factory {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<setFeeToSetterReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setFeeToSetterReturn) -> Self {
-                    ()
+            impl ::core::convert::From<getPairReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: getPairReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeToSetterReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPairReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl setFeeToSetterReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setFeeToSetterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setFeeToSetterCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
-            type Return = setFeeToSetterReturn;
+        impl alloy_sol_types::SolCall for getPairCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [162u8, 231u8, 74u8, 246u8];
-            const SIGNATURE: &'static str = "setFeeToSetter(address)";
+            const SELECTOR: [u8; 4] = [230u8, 164u8, 57u8, 5u8];
+            const SIGNATURE: &'static str = "getPair(address,address)";
 
             #[inline]
             fn new<'a>(
@@ -1544,20 +620,27 @@ pub mod UniswapV2Factory {
             fn tokenize(&self) -> Self::Token<'_> {
                 (
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._feeToSetter,
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setFeeToSetterReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: getPairReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -1565,29 +648,20 @@ pub mod UniswapV2Factory {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: getPairReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     ///Container for all the [`UniswapV2Factory`](self) function calls.
     #[derive(Clone)]
     pub enum UniswapV2FactoryCalls {
-        #[allow(missing_docs)]
-        allPairs(allPairsCall),
-        #[allow(missing_docs)]
-        allPairsLength(allPairsLengthCall),
         #[allow(missing_docs)]
         createPair(createPairCall),
         #[allow(missing_docs)]
-        feeTo(feeToCall),
-        #[allow(missing_docs)]
-        feeToSetter(feeToSetterCall),
-        #[allow(missing_docs)]
         getPair(getPairCall),
-        #[allow(missing_docs)]
-        setFeeTo(setFeeToCall),
-        #[allow(missing_docs)]
-        setFeeToSetter(setFeeToSetterCall),
     }
     impl UniswapV2FactoryCalls {
         /// All the selectors of this enum.
@@ -1597,38 +671,16 @@ pub mod UniswapV2Factory {
         /// selectors.
         ///
         /// Prefer using `SolInterface` methods instead.
-        pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [1u8, 126u8, 126u8, 88u8],
-            [9u8, 75u8, 116u8, 21u8],
-            [30u8, 61u8, 209u8, 139u8],
-            [87u8, 79u8, 43u8, 163u8],
-            [162u8, 231u8, 74u8, 246u8],
-            [201u8, 198u8, 83u8, 150u8],
-            [230u8, 164u8, 57u8, 5u8],
-            [244u8, 105u8, 1u8, 237u8],
-        ];
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[201u8, 198u8, 83u8, 150u8], [230u8, 164u8, 57u8, 5u8]];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <feeToCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <feeToSetterCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <allPairsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <allPairsLengthCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setFeeToSetterCall as alloy_sol_types::SolCall>::SIGNATURE,
             <createPairCall as alloy_sol_types::SolCall>::SIGNATURE,
             <getPairCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setFeeToCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
-        pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(feeTo),
-            ::core::stringify!(feeToSetter),
-            ::core::stringify!(allPairs),
-            ::core::stringify!(allPairsLength),
-            ::core::stringify!(setFeeToSetter),
-            ::core::stringify!(createPair),
-            ::core::stringify!(getPair),
-            ::core::stringify!(setFeeTo),
-        ];
+        pub const VARIANT_NAMES: &'static [&'static str] =
+            &[::core::stringify!(createPair), ::core::stringify!(getPair)];
 
         /// Returns the signature for the given selector, if known.
         #[inline]
@@ -1652,25 +704,15 @@ pub mod UniswapV2Factory {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for UniswapV2FactoryCalls {
-        const COUNT: usize = 8usize;
-        const MIN_DATA_LENGTH: usize = 0usize;
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 64usize;
         const NAME: &'static str = "UniswapV2FactoryCalls";
 
         #[inline]
         fn selector(&self) -> [u8; 4] {
             match self {
-                Self::allPairs(_) => <allPairsCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::allPairsLength(_) => {
-                    <allPairsLengthCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::createPair(_) => <createPairCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::feeTo(_) => <feeToCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::feeToSetter(_) => <feeToSetterCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::getPair(_) => <getPairCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setFeeTo(_) => <setFeeToCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setFeeToSetter(_) => {
-                    <setFeeToSetterCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -1688,45 +730,6 @@ pub mod UniswapV2Factory {
         #[allow(non_snake_case)]
         fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
             static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls>] = &[
-                {
-                    fn feeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <feeToCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV2FactoryCalls::feeTo)
-                    }
-                    feeTo
-                },
-                {
-                    fn feeToSetter(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <feeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV2FactoryCalls::feeToSetter)
-                    }
-                    feeToSetter
-                },
-                {
-                    fn allPairs(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <allPairsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV2FactoryCalls::allPairs)
-                    }
-                    allPairs
-                },
-                {
-                    fn allPairsLength(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <allPairsLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV2FactoryCalls::allPairsLength)
-                    }
-                    allPairsLength
-                },
-                {
-                    fn setFeeToSetter(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV2FactoryCalls::setFeeToSetter)
-                    }
-                    setFeeToSetter
-                },
                 {
                     fn createPair(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
                         <createPairCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -1741,13 +744,6 @@ pub mod UniswapV2Factory {
                     }
                     getPair
                 },
-                {
-                    fn setFeeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <setFeeToCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV2FactoryCalls::setFeeTo)
-                    }
-                    setFeeTo
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -1769,49 +765,6 @@ pub mod UniswapV2Factory {
             ) -> alloy_sol_types::Result<
                 UniswapV2FactoryCalls,
             >] = &[
-                {
-                    fn feeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <feeToCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV2FactoryCalls::feeTo)
-                    }
-                    feeTo
-                },
-                {
-                    fn feeToSetter(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <feeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV2FactoryCalls::feeToSetter)
-                    }
-                    feeToSetter
-                },
-                {
-                    fn allPairs(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <allPairsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV2FactoryCalls::allPairs)
-                    }
-                    allPairs
-                },
-                {
-                    fn allPairsLength(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <allPairsLengthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2FactoryCalls::allPairsLength)
-                    }
-                    allPairsLength
-                },
-                {
-                    fn setFeeToSetter(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2FactoryCalls::setFeeToSetter)
-                    }
-                    setFeeToSetter
-                },
                 {
                     fn createPair(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
                         <createPairCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -1826,13 +779,6 @@ pub mod UniswapV2Factory {
                     }
                     getPair
                 },
-                {
-                    fn setFeeTo(data: &[u8]) -> alloy_sol_types::Result<UniswapV2FactoryCalls> {
-                        <setFeeToCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV2FactoryCalls::setFeeTo)
-                    }
-                    setFeeTo
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -1846,60 +792,24 @@ pub mod UniswapV2Factory {
         #[inline]
         fn abi_encoded_size(&self) -> usize {
             match self {
-                Self::allPairs(inner) => {
-                    <allPairsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::allPairsLength(inner) => {
-                    <allPairsLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::createPair(inner) => {
                     <createPairCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::feeTo(inner) => {
-                    <feeToCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::feeToSetter(inner) => {
-                    <feeToSetterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::getPair(inner) => {
                     <getPairCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::setFeeTo(inner) => {
-                    <setFeeToCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::setFeeToSetter(inner) => {
-                    <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
         #[inline]
         fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
             match self {
-                Self::allPairs(inner) => {
-                    <allPairsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::allPairsLength(inner) => {
-                    <allPairsLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::createPair(inner) => {
                     <createPairCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::feeTo(inner) => {
-                    <feeToCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::feeToSetter(inner) => {
-                    <feeToSetterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::getPair(inner) => {
                     <getPairCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::setFeeTo(inner) => {
-                    <setFeeToCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::setFeeToSetter(inner) => {
-                    <setFeeToSetterCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
             }
         }
     }
@@ -2166,19 +1076,6 @@ pub mod UniswapV2Factory {
             alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
         }
 
-        ///Creates a new call builder for the [`allPairs`] function.
-        pub fn allPairs(
-            &self,
-            _0: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, allPairsCall, N> {
-            self.call_builder(&allPairsCall(_0))
-        }
-
-        ///Creates a new call builder for the [`allPairsLength`] function.
-        pub fn allPairsLength(&self) -> alloy_contract::SolCallBuilder<&P, allPairsLengthCall, N> {
-            self.call_builder(&allPairsLengthCall)
-        }
-
         ///Creates a new call builder for the [`createPair`] function.
         pub fn createPair(
             &self,
@@ -2188,16 +1085,6 @@ pub mod UniswapV2Factory {
             self.call_builder(&createPairCall { tokenA, tokenB })
         }
 
-        ///Creates a new call builder for the [`feeTo`] function.
-        pub fn feeTo(&self) -> alloy_contract::SolCallBuilder<&P, feeToCall, N> {
-            self.call_builder(&feeToCall)
-        }
-
-        ///Creates a new call builder for the [`feeToSetter`] function.
-        pub fn feeToSetter(&self) -> alloy_contract::SolCallBuilder<&P, feeToSetterCall, N> {
-            self.call_builder(&feeToSetterCall)
-        }
-
         ///Creates a new call builder for the [`getPair`] function.
         pub fn getPair(
             &self,
@@ -2206,22 +1093,6 @@ pub mod UniswapV2Factory {
         ) -> alloy_contract::SolCallBuilder<&P, getPairCall, N> {
             self.call_builder(&getPairCall { _0, _1 })
         }
-
-        ///Creates a new call builder for the [`setFeeTo`] function.
-        pub fn setFeeTo(
-            &self,
-            _feeTo: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setFeeToCall, N> {
-            self.call_builder(&setFeeToCall { _feeTo })
-        }
-
-        ///Creates a new call builder for the [`setFeeToSetter`] function.
-        pub fn setFeeToSetter(
-            &self,
-            _feeToSetter: alloy_sol_types::private::Address,
-        ) -> alloy_contract::SolCallBuilder<&P, setFeeToSetterCall, N> {
-            self.call_builder(&setFeeToSetterCall { _feeToSetter })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs b/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs
index 2d04f9b08e..e7ca2dc6fc 100644
--- a/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv2router02/src/lib.rs
@@ -17,27 +17,8 @@ interface UniswapV2Router02 {
 
     function WETH() external view returns (address);
     function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
     function factory() external view returns (address);
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
     function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
     function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
 }
 ```
@@ -142,60 +123,6 @@ interface UniswapV2Router02 {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "addLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amountTokenDesired",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "payable"
-  },
   {
     "type": "function",
     "name": "factory",
@@ -209,112 +136,6 @@ interface UniswapV2Router02 {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "getAmountIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "reserveOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "pure"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsIn",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAmountsOut",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "quote",
@@ -346,130 +167,22 @@ interface UniswapV2Router02 {
   },
   {
     "type": "function",
-    "name": "removeLiquidity",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETH",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "name": "swapTokensForExactTokens",
     "inputs": [
       {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
+        "name": "amountOut",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountTokenMin",
+        "name": "amountInMax",
         "type": "uint256",
         "internalType": "uint256"
       },
       {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "path",
+        "type": "address[]",
+        "internalType": "address[]"
       },
       {
         "name": "to",
@@ -484,4354 +197,59 @@ interface UniswapV2Router02 {
     ],
     "outputs": [
       {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
+        "name": "amounts",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermit",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountToken",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "token",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountTokenMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountETHMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountETH",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "removeLiquidityWithPermit",
-    "inputs": [
-      {
-        "name": "tokenA",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "tokenB",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "liquidity",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountAMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountBMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "approveMax",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "v",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "r",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "s",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amountA",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountB",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapETHForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "payable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETH",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
-    "inputs": [
-      {
-        "name": "amountIn",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountOutMin",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactETH",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "swapTokensForExactTokens",
-    "inputs": [
-      {
-        "name": "amountOut",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "amountInMax",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "path",
-        "type": "address[]",
-        "internalType": "address[]"
-      },
-      {
-        "name": "to",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amounts",
-        "type": "uint256[]",
-        "internalType": "uint256[]"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  }
-]
-```*/
-#[allow(
-    non_camel_case_types,
-    non_snake_case,
-    clippy::pub_underscore_fields,
-    clippy::style,
-    clippy::empty_structs_with_brackets
-)]
-pub mod UniswapV2Router02 {
-    use {super::*, alloy_sol_types};
-    /// The creation / init bytecode of the contract.
-    ///
-    /// ```text
-    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
-    /// ```
-    #[rustfmt::skip]
-    #[allow(clippy::all)]
-    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
-        b"`\xC0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0W>8\x03\x80b\0W>\x839\x81\x81\x01`@R`@\x81\x10\x15b\0\x007W`\0\x80\xFD[P\x80Q` \x90\x91\x01Q`\x01`\x01``\x1B\x03\x19``\x92\x83\x1B\x81\x16`\x80R\x91\x1B\x16`\xA0R`\x80Q``\x1C`\xA0Q``\x1CaU\xB7b\0\x01\x87`\09\x80a\x01\xACR\x80a\x0E]R\x80a\x0E\x98R\x80a\x0F\xD5R\x80a\x12\x98R\x80a\x16\xF2R\x80a\x18\xD6R\x80a\x1E\x1ER\x80a\x1F\xA2R\x80a rR\x80a!yR\x80a#,R\x80a#\xC1R\x80a&sR\x80a'\x1AR\x80a'\xEFR\x80a(\xF4R\x80a)\xDCR\x80a*]R\x80a0\xECR\x80a4\"R\x80a4xR\x80a4\xACR\x80a5-R\x80a7GR\x80a8\xF7R\x80a9\x8CRP\x80a\x10\xC7R\x80a\x11\xC5R\x80a\x13kR\x80a\x13\xA4R\x80a\x15OR\x80a\x17\xE4R\x80a\x18\xB4R\x80a\x1A\xA1R\x80a\"_R\x80a$\0R\x80a%\xA9R\x80a*\x9CR\x80a-\xDFR\x80a0qR\x80a0\x9AR\x80a0\xCAR\x80a2\xA7R\x80a4VR\x80a8-R\x80a9\xCBR\x80aDJR\x80aD\x8DR\x80aG\xEDR\x80aI\xCER\x80aOIR\x80aP*R\x80aP\xAARPaU\xB7`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\x8FW`\x005`\xE0\x1C\x80c\x88\x03\xDB\xEE\x11a\0\xD6W\x80c\xC4Z\x01U\x11a\0\x7FW\x80c\xE8\xE37\0\x11a\0YW\x80c\xE8\xE37\0\x14a\x0CqW\x80c\xF3\x05\xD7\x19\x14a\x0C\xFEW\x80c\xFB;\xDBA\x14a\rQWa\x01\xD5V[\x80c\xC4Z\x01U\x14a\x0B%W\x80c\xD0l\xA6\x1F\x14a\x0B:W\x80c\xDE\xD98*\x14a\x0B\xF1Wa\x01\xD5V[\x80c\xAF)y\xEB\x11a\0\xB0W\x80c\xAF)y\xEB\x14a\t\xC8W\x80c\xB6\xF9\xDE\x95\x14a\n(W\x80c\xBA\xA2\xAB\xDE\x14a\n\xBBWa\x01\xD5V[\x80c\x88\x03\xDB\xEE\x14a\x08\xAFW\x80c\xAD\\FH\x14a\tTW\x80c\xADa]\xEC\x14a\t\x92Wa\x01\xD5V[\x80cJ%\xD9J\x11a\x018W\x80cy\x1A\xC9G\x11a\x01\x12W\x80cy\x1A\xC9G\x14a\x07AW\x80c\x7F\xF3j\xB5\x14a\x07\xE6W\x80c\x85\xF8\xC2Y\x14a\x08yWa\x01\xD5V[\x80cJ%\xD9J\x14a\x05wW\x80c[\rY\x84\x14a\x06\x1CW\x80c\\\x11\xD7\x95\x14a\x06\x9CWa\x01\xD5V[\x80c\x1F\0\xCAt\x11a\x01iW\x80c\x1F\0\xCAt\x14a\x03\x90W\x80c!\x95\x99\\\x14a\x04GW\x80c8\xED\x179\x14a\x04\xD2Wa\x01\xD5V[\x80c\x02u\x1C\xEC\x14a\x01\xDAW\x80c\x05MP\xD4\x14a\x02SW\x80c\x18\xCB\xAF\xE5\x14a\x02\x9BWa\x01\xD5V[6a\x01\xD5W3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x01\xD3W\xFE[\0[`\0\x80\xFD[4\x80\x15a\x01\xE6W`\0\x80\xFD[Pa\x02:`\x04\x806\x03`\xC0\x81\x10\x15a\x01\xFDW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a\r\xE4V[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x80Q\x91\x82\x90\x03\x01\x90\xF3[4\x80\x15a\x02_W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\x02vW`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a\x0F7V[`@\x80Q\x91\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[4\x80\x15a\x02\xA7W`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x02\xBEW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x02\xE5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x02\xF7W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03\x19W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x0FLV[`@\x80Q` \x80\x82R\x83Q\x81\x83\x01R\x83Q\x91\x92\x83\x92\x90\x83\x01\x91\x85\x81\x01\x91\x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x03|W\x81\x81\x01Q\x83\x82\x01R` \x01a\x03dV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x9CW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`@\x81\x10\x15a\x03\xB3W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x03\xD5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xE7W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\tW`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x13d\x94PPPPPV[4\x80\x15a\x04SW`\0\x80\xFD[Pa\x02:`\x04\x806\x03a\x01`\x81\x10\x15a\x04kW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x90\x91\x16\x90`\xC0\x81\x015\x90`\xE0\x81\x015\x15\x15\x90`\xFFa\x01\0\x82\x015\x16\x90a\x01 \x81\x015\x90a\x01@\x015a\x13\x9AV[4\x80\x15a\x04\xDEW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x04\xF5W`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x05\x1CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05.W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05PW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x14\xD8V[4\x80\x15a\x05\x83W`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x05\x9AW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x05\xC1W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\xD3W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05\xF5W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x16iV[4\x80\x15a\x06(W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03a\x01@\x81\x10\x15a\x06@W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x81\x015\x15\x15\x90`\xFF`\xE0\x82\x015\x16\x90a\x01\0\x81\x015\x90a\x01 \x015a\x18\xACV[4\x80\x15a\x06\xA8W`\0\x80\xFD[Pa\x01\xD3`\x04\x806\x03`\xA0\x81\x10\x15a\x06\xBFW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x06\xE6W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\xF8W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\x1AW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x19\xFEV[4\x80\x15a\x07MW`\0\x80\xFD[Pa\x01\xD3`\x04\x806\x03`\xA0\x81\x10\x15a\x07dW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x07\x8BW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x07\x9DW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\xBFW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x1D\x97V[a\x03@`\x04\x806\x03`\x80\x81\x10\x15a\x07\xFCW`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x08\x1EW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x080W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x08RW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a!\x05V[4\x80\x15a\x08\x85W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\x08\x9CW`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a%%V[4\x80\x15a\x08\xBBW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x08\xD2W`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x08\xF9W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\t\x0BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\t-W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a%2V[4\x80\x15a\t`W`\0\x80\xFD[Pa\tia&qV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[4\x80\x15a\t\x9EW`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\t\xB5W`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a&\x95V[4\x80\x15a\t\xD4W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03`\xC0\x81\x10\x15a\t\xEBW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a&\xA2V[a\x01\xD3`\x04\x806\x03`\x80\x81\x10\x15a\n>W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\n`W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\nrW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n\x94W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a(\x82V[4\x80\x15a\n\xC7W`\0\x80\xFD[Pa\x02:`\x04\x806\x03`\xE0\x81\x10\x15a\n\xDEW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x90\x91\x16\x90`\xC0\x015a-eV[4\x80\x15a\x0B1W`\0\x80\xFD[Pa\tia0oV[4\x80\x15a\x0BFW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`@\x81\x10\x15a\x0B]W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x0B\x7FW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0B\x91W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0B\xB3W`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa0\x93\x94PPPPPV[4\x80\x15a\x0B\xFDW`\0\x80\xFD[Pa\x02:`\x04\x806\x03a\x01@\x81\x10\x15a\x0C\x15W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x81\x015\x15\x15\x90`\xFF`\xE0\x82\x015\x16\x90a\x01\0\x81\x015\x90a\x01 \x015a0\xC0V[4\x80\x15a\x0C}W`\0\x80\xFD[Pa\x0C\xE0`\x04\x806\x03a\x01\0\x81\x10\x15a\x0C\x95W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x91`\xC0\x82\x015\x16\x90`\xE0\x015a2\x18V[`@\x80Q\x93\x84R` \x84\x01\x92\x90\x92R\x82\x82\x01RQ\x90\x81\x90\x03``\x01\x90\xF3[a\x0C\xE0`\x04\x806\x03`\xC0\x81\x10\x15a\r\x14W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a3\xA7V[a\x03@`\x04\x806\x03`\x80\x81\x10\x15a\rgW`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\r\x89W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\r\x9BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\r\xBDW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a6\xD3V[`\0\x80\x82B\x81\x10\x15a\x0EWW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x0E\x86\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x8A\x8A0\x8Aa-eV[\x90\x93P\x91Pa\x0E\x96\x89\x86\x85a;\"V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x0F\tW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0F\x1DW=`\0\x80>=`\0\xFD[PPPPa\x0F+\x85\x83a<\xFFV[P\x96P\x96\x94PPPPPV[`\0a\x0FD\x84\x84\x84a><V[\x94\x93PPPPV[``\x81B\x81\x10\x15a\x0F\xBEW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x10#W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x10\xC2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x11 \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\x113W\xFE[` \x02` \x01\x01Q\x10\x15a\x11\x92W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x12W\x86\x86`\0\x81\x81\x10a\x11\xA2W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163a\x12=\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x8A`\0\x81\x81\x10a\x11\xF1W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8B\x8B`\x01\x81\x81\x10a\x12\x1BW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a@\xC6V[\x85`\0\x81Q\x81\x10a\x12JW\xFE[` \x02` \x01\x01QaA\xB1V[a\x12\x96\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP0\x92PaC\x81\x91PPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`\x01\x85Q\x03\x81Q\x81\x10a\x12\xE2W\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x13 W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x134W=`\0\x80>=`\0\xFD[PPPPa\x13Y\x84\x83`\x01\x85Q\x03\x81Q\x81\x10a\x13LW\xFE[` \x02` \x01\x01Qa<\xFFV[P\x96\x95PPPPPPV[``a\x13\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x84aF\x08V[\x90P[\x92\x91PPV[`\0\x80`\0a\x13\xCA\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8F\x8Fa@\xC6V[\x90P`\0\x87a\x13\xD9W\x8Ca\x13\xFBV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8C\x90R`\xFF\x8A\x16`\x84\x82\x01R`\xA4\x81\x01\x89\x90R`\xC4\x81\x01\x88\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x14\x97W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x14\xABW=`\0\x80>=`\0\xFD[PPPPa\x14\xBE\x8F\x8F\x8F\x8F\x8F\x8F\x8Fa-eV[\x80\x94P\x81\x95PPPPP\x9BP\x9B\x99PPPPPPPPPPV[``\x81B\x81\x10\x15a\x15JW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x15\xA8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\x15\xBBW\xFE[` \x02` \x01\x01Q\x10\x15a\x16\x1AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x16*\x86\x86`\0\x81\x81\x10a\x11\xA2W\xFE[a\x13Y\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[``\x81B\x81\x10\x15a\x16\xDBW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x17@W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x17\xDFW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x18=\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P\x86\x82`\0\x81Q\x81\x10a\x18MW\xFE[` \x02` \x01\x01Q\x11\x15a\x11\x92W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80a\x18\xFA\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8D\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90P`\0\x86a\x19\tW\x8Ba\x19+V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8B\x90R`\xFF\x89\x16`\x84\x82\x01R`\xA4\x81\x01\x88\x90R`\xC4\x81\x01\x87\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x19\xC7W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x19\xDBW=`\0\x80>=`\0\xFD[PPPPa\x19\xED\x8D\x8D\x8D\x8D\x8D\x8Da&\xA2V[\x9D\x9CPPPPPPPPPPPPPV[\x80B\x81\x10\x15a\x1AnW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1A\xFD\x85\x85`\0\x81\x81\x10a\x1A~W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163a\x1A\xF7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8A\x8A`\x01\x81\x81\x10a\x12\x1BW\xFE[\x8AaA\xB1V[`\0\x85\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1B-W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x85`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1B\xC6W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1B\xDAW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1B\xF0W`\0\x80\xFD[PQ`@\x80Q` \x88\x81\x02\x82\x81\x01\x82\x01\x90\x93R\x88\x82R\x92\x93Pa\x1C2\x92\x90\x91\x89\x91\x89\x91\x82\x91\x85\x01\x90\x84\x90\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x88\x92PaG\x96\x91PPV[\x86a\x1D6\x82\x88\x88\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1CeW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1D\x12W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1D(W`\0\x80\xFD[PQ\x90c\xFF\xFF\xFF\xFFaK)\x16V[\x10\x15a\x1D\x8DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPPPPPV[\x80B\x81\x10\x15a\x1E\x07W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x85\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1ElW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1F\x0BW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1F\x1B\x85\x85`\0\x81\x81\x10a\x1A~W\xFE[a\x1FY\x85\x85\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP0\x92PaG\x96\x91PPV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q`\0\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x1F\xE9W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\xFDW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a \x13W`\0\x80\xFD[PQ\x90P\x86\x81\x10\x15a pW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a \xE3W`\0\x80\xFD[PZ\xF1\x15\x80\x15a \xF7W=`\0\x80>=`\0\xFD[PPPPa\x1D\x8D\x84\x82a<\xFFV[``\x81B\x81\x10\x15a!wW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x86`\0\x81\x81\x10a!\xBBW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\"ZW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\"\xB8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x004\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\"\xCBW\xFE[` \x02` \x01\x01Q\x10\x15a#*W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x83`\0\x81Q\x81\x10a#sW\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a#\xA6W`\0\x80\xFD[PZ\xF1\x15\x80\x15a#\xBAW=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa$,\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x84`\0\x81Q\x81\x10a$9W\xFE[` \x02` \x01\x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a$\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a$\xBEW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a$\xD4W`\0\x80\xFD[PQa$\xDCW\xFE[a%\x1B\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[P\x95\x94PPPPPV[`\0a\x0FD\x84\x84\x84aK\x9BV[``\x81B\x81\x10\x15a%\xA4W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a&\x02\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P\x86\x82`\0\x81Q\x81\x10a&\x12W\xFE[` \x02` \x01\x01Q\x11\x15a\x16\x1AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0a\x0FD\x84\x84\x84aL\xBFV[`\0\x81B\x81\x10\x15a'\x14W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a'C\x88\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89\x890\x89a-eV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x91\x94Pa'\xED\x92P\x8A\x91\x87\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a'\xBCW`\0\x80\xFD[PZ\xFA\x15\x80\x15a'\xD0W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a'\xE6W`\0\x80\xFD[PQa;\"V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a(`W`\0\x80\xFD[PZ\xF1\x15\x80\x15a(tW=`\0\x80>=`\0\xFD[PPPPa\x13Y\x84\x83a<\xFFV[\x80B\x81\x10\x15a(\xF2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x85`\0\x81\x81\x10a)6W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a)\xD5W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x004\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a*BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a*VW=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa*\xC8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a+2W`\0\x80\xFD[PZ\xF1\x15\x80\x15a+FW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a+\\W`\0\x80\xFD[PQa+dW\xFE[`\0\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a+\x94W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x86`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a,-W`\0\x80\xFD[PZ\xFA\x15\x80\x15a,AW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a,WW`\0\x80\xFD[PQ`@\x80Q` \x89\x81\x02\x82\x81\x01\x82\x01\x90\x93R\x89\x82R\x92\x93Pa,\x99\x92\x90\x91\x8A\x91\x8A\x91\x82\x91\x85\x01\x90\x84\x90\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaG\x96\x91PPV[\x87a\x1D6\x82\x89\x89\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a,\xCCW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x89`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[`\0\x80\x82B\x81\x10\x15a-\xD8W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0a.\x05\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8Ca@\xC6V[`@\x80Q\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01\x81\x90R`D\x82\x01\x8D\x90R\x91Q\x92\x93P\x90\x91c#\xB8r\xDD\x91`d\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81`\0\x87\x80;\x15\x80\x15a.\x86W`\0\x80\xFD[PZ\xF1\x15\x80\x15a.\x9AW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a.\xB0W`\0\x80\xFD[PP`@\x80Q\x7F\x89\xAF\xCBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x82Q`\0\x93\x84\x93\x92\x86\x16\x92c\x89\xAF\xCBD\x92`$\x80\x83\x01\x93\x92\x82\x90\x03\x01\x81\x87\x87\x80;\x15\x80\x15a/#W`\0\x80\xFD[PZ\xF1\x15\x80\x15a/7W=`\0\x80>=`\0\xFD[PPPP`@Q=`@\x81\x10\x15a/MW`\0\x80\xFD[P\x80Q` \x90\x91\x01Q\x90\x92P\x90P`\0a/g\x8E\x8EaM\x9FV[P\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a/\xA4W\x81\x83a/\xA7V[\x82\x82[\x90\x97P\x95P\x8A\x87\x10\x15a0\x05W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT\xBF`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x89\x86\x10\x15a0^W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT%`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPP\x97P\x97\x95PPPPPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[``a\x13\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x84a?`V[`\0\x80`\0a1\x10\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8E\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90P`\0\x87a1\x1FW\x8Ca1AV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8C\x90R`\xFF\x8A\x16`\x84\x82\x01R`\xA4\x81\x01\x89\x90R`\xC4\x81\x01\x88\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a1\xDDW`\0\x80\xFD[PZ\xF1\x15\x80\x15a1\xF1W=`\0\x80>=`\0\xFD[PPPPa2\x03\x8E\x8E\x8E\x8E\x8E\x8Ea\r\xE4V[\x90\x9F\x90\x9EP\x9CPPPPPPPPPPPPPV[`\0\x80`\0\x83B\x81\x10\x15a2\x8DW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a2\x9B\x8C\x8C\x8C\x8C\x8C\x8CaN\xF2V[\x90\x94P\x92P`\0a2\xCD\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8E\x8Ea@\xC6V[\x90Pa2\xDB\x8D3\x83\x88aA\xB1V[a2\xE7\x8C3\x83\x87aA\xB1V[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cjbxB\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a3fW`\0\x80\xFD[PZ\xF1\x15\x80\x15a3zW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a3\x90W`\0\x80\xFD[PQ\x94\x9D\x93\x9CP\x93\x9AP\x91\x98PPPPPPPPPV[`\0\x80`\0\x83B\x81\x10\x15a4\x1CW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a4J\x8A\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B4\x8C\x8CaN\xF2V[\x90\x94P\x92P`\0a4\x9C\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90Pa4\xAA\x8B3\x83\x88aA\xB1V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x85`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a5\x12W`\0\x80\xFD[PZ\xF1\x15\x80\x15a5&W=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBB\x82\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a5\xD2W`\0\x80\xFD[PZ\xF1\x15\x80\x15a5\xE6W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a5\xFCW`\0\x80\xFD[PQa6\x04W\xFE[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cjbxB\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a6\x83W`\0\x80\xFD[PZ\xF1\x15\x80\x15a6\x97W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a6\xADW`\0\x80\xFD[PQ\x92P4\x84\x10\x15a6\xC5Wa6\xC53\x854\x03a<\xFFV[PP\x96P\x96P\x96\x93PPPPV[``\x81B\x81\x10\x15a7EW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x86`\0\x81\x81\x10a7\x89W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a8(W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a8\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P4\x82`\0\x81Q\x81\x10a8\x96W\xFE[` \x02` \x01\x01Q\x11\x15a8\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x83`\0\x81Q\x81\x10a9>W\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a9qW`\0\x80\xFD[PZ\xF1\x15\x80\x15a9\x85W=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa9\xF7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x84`\0\x81Q\x81\x10a:\x04W\xFE[` \x02` \x01\x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a:uW`\0\x80\xFD[PZ\xF1\x15\x80\x15a:\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a:\x9FW`\0\x80\xFD[PQa:\xA7W\xFE[a:\xE6\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[\x81`\0\x81Q\x81\x10a:\xF3W\xFE[` \x02` \x01\x01Q4\x11\x15a%\x1BWa%\x1B3\x83`\0\x81Q\x81\x10a;\x13W\xFE[` \x02` \x01\x01Q4\x03a<\xFFV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x83R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x82Q`\0\x94``\x94\x93\x89\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10a;\xF8W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a;\xBBV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a<ZW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a<_V[``\x91P[P\x91P\x91P\x81\x80\x15a<\x8DWP\x80Q\x15\x80a<\x8DWP\x80\x80` \x01\x90Q` \x81\x10\x15a<\x8AW`\0\x80\xFD[PQ[a<\xF8W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FTransferHelper: TRANSFER_FAILED\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPPPPV[`@\x80Q`\0\x80\x82R` \x82\x01\x90\x92Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90\x83\x90`@Q\x80\x82\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a=vW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a=9V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a=\xD8W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a=\xDDV[``\x91P[PP\x90P\x80a>7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`#\x81R` \x01\x80aT\xE5`#\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPV[`\0\x80\x84\x11a>\x96W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aUW`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15a>\xA6WP`\0\x82\x11[a>\xFBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0a?\x0F\x85a\x03\xE5c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0a?#\x82\x85c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0a?I\x83a?=\x88a\x03\xE8c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90c\xFF\xFF\xFF\xFFaRy\x16V[\x90P\x80\x82\x81a?TW\xFE[\x04\x97\x96PPPPPPPV[```\x02\x82Q\x10\x15a?\xD3W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: INVALID_PATH\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?\xEBW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a@\x15W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82\x81`\0\x81Q\x81\x10a@&W\xFE[` \x02` \x01\x01\x81\x81RPP`\0[`\x01\x83Q\x03\x81\x10\x15a@\xBEW`\0\x80a@x\x87\x86\x85\x81Q\x81\x10a@TW\xFE[` \x02` \x01\x01Q\x87\x86`\x01\x01\x81Q\x81\x10a@kW\xFE[` \x02` \x01\x01QaR\xEBV[\x91P\x91Pa@\x9A\x84\x84\x81Q\x81\x10a@\x8BW\xFE[` \x02` \x01\x01Q\x83\x83a><V[\x84\x84`\x01\x01\x81Q\x81\x10a@\xA9W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP`\x01\x01a@5V[P\x93\x92PPPV[`\0\x80`\0a@\xD5\x85\x85aM\x9FV[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0``\x94\x85\x1B\x81\x16` \x80\x84\x01\x91\x90\x91R\x93\x85\x1B\x81\x16`4\x83\x01R\x82Q`(\x81\x84\x03\x01\x81R`H\x83\x01\x84R\x80Q\x90\x85\x01 \x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`h\x84\x01R\x9A\x90\x94\x1B\x90\x93\x16`i\x84\x01R`}\x83\x01\x98\x90\x98R\x7F\x96\xE8\xACBw\x19\x8F\xF8\xB6\xF7\x85G\x8A\xA9\xA3\x9F@<\xB7h\xDD\x02\xCB\xEE2l>}\xA3H\x84_`\x9D\x80\x84\x01\x91\x90\x91R\x88Q\x80\x84\x03\x90\x91\x01\x81R`\xBD\x90\x92\x01\x90\x97R\x80Q\x96\x01\x95\x90\x95 \x95\x94PPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x81\x16`D\x83\x01R`d\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`\x84\x90\x92\x01\x83R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x82Q`\0\x94``\x94\x93\x8A\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10aB\x8FW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01aBRV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14aB\xF1W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>aB\xF6V[``\x91P[P\x91P\x91P\x81\x80\x15aC$WP\x80Q\x15\x80aC$WP\x80\x80` \x01\x90Q` \x81\x10\x15aC!W`\0\x80\xFD[PQ[aCyW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`$\x81R` \x01\x80aU3`$\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPPPV[`\0[`\x01\x83Q\x03\x81\x10\x15aF\x02W`\0\x80\x84\x83\x81Q\x81\x10aC\x9FW\xFE[` \x02` \x01\x01Q\x85\x84`\x01\x01\x81Q\x81\x10aC\xB6W\xFE[` \x02` \x01\x01Q\x91P\x91P`\0aC\xCE\x83\x83aM\x9FV[P\x90P`\0\x87\x85`\x01\x01\x81Q\x81\x10aC\xE2W\xFE[` \x02` \x01\x01Q\x90P`\0\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aD*W\x82`\0aD.V[`\0\x83[\x91P\x91P`\0`\x02\x8AQ\x03\x88\x10aDEW\x88aD\x86V[aD\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87\x8C\x8B`\x02\x01\x81Q\x81\x10aDyW\xFE[` \x02` \x01\x01Qa@\xC6V[\x90PaD\xB3\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88a@\xC6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x02,\r\x9F\x84\x84\x84`\0`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15aD\xFDW` \x82\x01\x81\x806\x837\x01\x90P[P`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x85\x81R` \x01\x84\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15aE\x88W\x81\x81\x01Q\x83\x82\x01R` \x01aEpV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15aE\xB5W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aE\xD7W`\0\x80\xFD[PZ\xF1\x15\x80\x15aE\xEBW=`\0\x80>=`\0\xFD[PP`\x01\x90\x99\x01\x98PaC\x84\x97PPPPPPPPV[PPPPV[```\x02\x82Q\x10\x15aF{W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: INVALID_PATH\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aF\x93W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aF\xBDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82\x81`\x01\x83Q\x03\x81Q\x81\x10aF\xD1W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01[\x80\x15a@\xBEW`\0\x80aG1\x87\x86`\x01\x86\x03\x81Q\x81\x10aG\x1DW\xFE[` \x02` \x01\x01Q\x87\x86\x81Q\x81\x10a@kW\xFE[\x91P\x91PaGS\x84\x84\x81Q\x81\x10aGDW\xFE[` \x02` \x01\x01Q\x83\x83aK\x9BV[\x84`\x01\x85\x03\x81Q\x81\x10aGbW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01aG\x01V[`\0[`\x01\x83Q\x03\x81\x10\x15a>7W`\0\x80\x84\x83\x81Q\x81\x10aG\xB4W\xFE[` \x02` \x01\x01Q\x85\x84`\x01\x01\x81Q\x81\x10aG\xCBW\xFE[` \x02` \x01\x01Q\x91P\x91P`\0aG\xE3\x83\x83aM\x9FV[P\x90P`\0aH\x13\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85\x85a@\xC6V[\x90P`\0\x80`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aHaW`\0\x80\xFD[PZ\xFA\x15\x80\x15aHuW=`\0\x80>=`\0\xFD[PPPP`@Q=``\x81\x10\x15aH\x8BW`\0\x80\xFD[P\x80Q` \x90\x91\x01Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93P\x16\x90P`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x81\x16\x90\x89\x16\x14aH\xD5W\x82\x84aH\xD8V[\x83\x83[\x91P\x91PaI]\x82\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x8A`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[\x95PaIj\x86\x83\x83a><V[\x94PPPPP`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aI\xAEW\x82`\0aI\xB2V[`\0\x83[\x91P\x91P`\0`\x02\x8CQ\x03\x8A\x10aI\xC9W\x8AaI\xFDV[aI\xFD\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x8E\x8D`\x02\x01\x81Q\x81\x10aDyW\xFE[`@\x80Q`\0\x80\x82R` \x82\x01\x92\x83\x90R\x7F\x02,\r\x9F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`$\x82\x01\x87\x81R`D\x83\x01\x87\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16`d\x85\x01R`\x80`\x84\x85\x01\x90\x81R\x84Q`\xA4\x86\x01\x81\x90R\x96\x97P\x90\x8C\x16\x95c\x02,\r\x9F\x95\x8A\x95\x8A\x95\x8A\x95\x91\x94\x91\x93\x91\x92`\xC4\x86\x01\x92\x90\x91\x81\x90\x84\x90\x84\x90[\x83\x81\x10\x15aJ\xADW\x81\x81\x01Q\x83\x82\x01R` \x01aJ\x95V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15aJ\xDAW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aJ\xFCW`\0\x80\xFD[PZ\xF1\x15\x80\x15aK\x10W=`\0\x80>=`\0\xFD[PP`\x01\x90\x9B\x01\x9APaG\x99\x99PPPPPPPPPPV[\x80\x82\x03\x82\x81\x11\x15a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7Fds-math-sub-underflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80\x84\x11aK\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`,\x81R` \x01\x80aS\xD4`,\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15aL\x05WP`\0\x82\x11[aLZW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0aL~a\x03\xE8aLr\x86\x88c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0aL\x98a\x03\xE5aLr\x86\x89c\xFF\xFF\xFF\xFFaK)\x16V[\x90PaL\xB5`\x01\x82\x84\x81aL\xA8W\xFE[\x04\x90c\xFF\xFF\xFF\xFFaRy\x16V[\x96\x95PPPPPPV[`\0\x80\x84\x11aM\x19W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80aTs`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15aM)WP`\0\x82\x11[aM~W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82aM\x8F\x85\x84c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x81aM\x96W\xFE[\x04\x94\x93PPPPV[`\0\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aN'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80aT\0`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10aNaW\x82\x84aNdV[\x83\x83[\x90\x92P\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16aN\xEBW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: ZERO_ADDRESS\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x92P\x92\x90PV[`@\x80Q\x7F\xE6\xA49\x05\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x87\x81\x16`$\x83\x01R\x91Q`\0\x92\x83\x92\x83\x92\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16\x91c\xE6\xA49\x05\x91`D\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15aO\x92W`\0\x80\xFD[PZ\xFA\x15\x80\x15aO\xA6W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15aO\xBCW`\0\x80\xFD[PQs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aP\xA2W`@\x80Q\x7F\xC9\xC6S\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x81\x16`\x04\x83\x01R\x89\x81\x16`$\x83\x01R\x91Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16\x91c\xC9\xC6S\x96\x91`D\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81`\0\x87\x80;\x15\x80\x15aPuW`\0\x80\xFD[PZ\xF1\x15\x80\x15aP\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15aP\x9FW`\0\x80\xFD[PP[`\0\x80aP\xD0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x8BaR\xEBV[\x91P\x91P\x81`\0\x14\x80\x15aP\xE2WP\x80\x15[\x15aP\xF2W\x87\x93P\x86\x92PaQ\xE6V[`\0aP\xFF\x89\x84\x84aL\xBFV[\x90P\x87\x81\x11aQlW\x85\x81\x10\x15aQaW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT%`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x88\x94P\x92P\x82aQ\xE4V[`\0aQy\x89\x84\x86aL\xBFV[\x90P\x89\x81\x11\x15aQ\x85W\xFE[\x87\x81\x10\x15aQ\xDEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT\xBF`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x94P\x87\x93P[P[PP\x96P\x96\x94PPPPPV[`\0\x81\x15\x80aR\x0EWPP\x80\x82\x02\x82\x82\x82\x81aR\x0BW\xFE[\x04\x14[a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-mul-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x80\x82\x01\x82\x81\x10\x15a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-add-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80`\0aR\xFA\x85\x85aM\x9FV[P\x90P`\0\x80aS\x0B\x88\x88\x88a@\xC6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aSPW`\0\x80\xFD[PZ\xFA\x15\x80\x15aSdW=`\0\x80>=`\0\xFD[PPPP`@Q=``\x81\x10\x15aSzW`\0\x80\xFD[P\x80Q` \x90\x91\x01Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93P\x16\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x81\x16\x90\x84\x16\x14aS\xC1W\x80\x82aS\xC4V[\x81\x81[\x90\x99\x90\x98P\x96PPPPPPPV\xFEUniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNTUniswapV2Library: IDENTICAL_ADDRESSESUniswapV2Router: INSUFFICIENT_B_AMOUNTUniswapV2Library: INSUFFICIENT_LIQUIDITYUniswapV2Library: INSUFFICIENT_AMOUNTUniswapV2Router: EXCESSIVE_INPUT_AMOUNTUniswapV2Router: INSUFFICIENT_A_AMOUNTTransferHelper: ETH_TRANSFER_FAILEDUniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNTTransferHelper: TRANSFER_FROM_FAILEDUniswapV2Library: INSUFFICIENT_INPUT_AMOUNT\xA2dipfsX\"\x12 m\xD6\xE0<K,\n\x8EU!I&\"z\xE9\xE2\xD6\xF9\xFE\xC2\xCEt\xA6DmaZ\xFA5\\\x84\xF3dsolcC\0\x06\x06\x003",
-    );
-    /**Constructor`.
-    ```solidity
-    constructor(address _factory, address _WETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct constructorCall {
-        #[allow(missing_docs)]
-        pub _factory: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub _WETH: alloy_sol_types::private::Address,
-    }
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
-                fn from(value: constructorCall) -> Self {
-                    (value._factory, value._WETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        _factory: tuple.0,
-                        _WETH: tuple.1,
-                    }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolConstructor for constructorCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._factory,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self._WETH,
-                    ),
-                )
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `WETH()` and selector `0xad5c4648`.
-    ```solidity
-    function WETH() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`WETH()`](WETHCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct WETHReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: WETHReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for WETHCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
-            const SIGNATURE: &'static str = "WETH()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: WETHReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: WETHReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
-    ```solidity
-    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.amountADesired,
-                        value.amountBDesired,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        amountADesired: tuple.2,
-                        amountBDesired: tuple.3,
-                        amountAMin: tuple.4,
-                        amountBMin: tuple.5,
-                        to: tuple.6,
-                        deadline: tuple.7,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityReturn {
-            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
-            const SIGNATURE: &'static str =
-                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountADesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `addLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0xf305d719`.
-    ```solidity
-    function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`addLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](addLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct addLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.amountTokenDesired,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        amountTokenDesired: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<addLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: addLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH, value.liquidity)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                        liquidity: tuple.2,
-                    }
-                }
-            }
-        }
-        impl addLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <addLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for addLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = addLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 215u8, 25u8];
-            const SIGNATURE: &'static str =
-                "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenDesired,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                addLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for factoryCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::Address;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
-            const SIGNATURE: &'static str = "factory()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: factoryReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: factoryReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountIn(uint256,uint256,uint256)` and selector `0x85f8c259`.
-    ```solidity
-    function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountIn);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountIn(uint256,uint256,uint256)`](getAmountInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountInReturn {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInCall) -> Self {
-                    (value.amountOut, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountInReturn) -> Self {
-                    (value.amountIn,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountIn: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 248u8, 194u8, 89u8];
-            const SIGNATURE: &'static str = "getAmountIn(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountOut,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountInReturn = r.into();
-                        r.amountIn
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountInReturn = r.into();
-                    r.amountIn
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountOut(uint256,uint256,uint256)` and selector `0x054d50d4`.
-    ```solidity
-    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) external pure returns (uint256 amountOut);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountOut(uint256,uint256,uint256)`](getAmountOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountOutReturn {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutCall) -> Self {
-                    (value.amountIn, value.reserveIn, value.reserveOut)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        reserveIn: tuple.1,
-                        reserveOut: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountOutReturn) -> Self {
-                    (value.amountOut,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountOut: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [5u8, 77u8, 80u8, 212u8];
-            const SIGNATURE: &'static str = "getAmountOut(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveIn,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveOut,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountOutReturn = r.into();
-                        r.amountOut
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountOutReturn = r.into();
-                    r.amountOut
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsIn(uint256,address[])` and selector `0x1f00ca74`.
-    ```solidity
-    function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsIn(uint256,address[])`](getAmountsInCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsInReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInCall) -> Self {
-                    (value.amountOut, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsInReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsInReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsInReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsInCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [31u8, 0u8, 202u8, 116u8];
-            const SIGNATURE: &'static str = "getAmountsIn(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsInReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsInReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `getAmountsOut(uint256,address[])` and selector `0xd06ca61f`.
-    ```solidity
-    function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`getAmountsOut(uint256,address[])`](getAmountsOutCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct getAmountsOutReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutCall> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutCall) -> Self {
-                    (value.amountIn, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        path: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<getAmountsOutReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: getAmountsOutReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAmountsOutReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for getAmountsOutCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [208u8, 108u8, 166u8, 31u8];
-            const SIGNATURE: &'static str = "getAmountsOut(uint256,address[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: getAmountsOutReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: getAmountsOutReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
-    ```solidity
-    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteCall {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct quoteReturn {
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteCall) -> Self {
-                    (value.amountA, value.reserveA, value.reserveB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        reserveA: tuple.1,
-                        reserveB: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: quoteReturn) -> Self {
-                    (value.amountB,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountB: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for quoteCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
-            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.reserveB,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: quoteReturn = r.into();
-                        r.amountB
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: quoteReturn = r.into();
-                    r.amountB
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)` and selector `0xbaa2abde`.
-    ```solidity
-    function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidity(address,address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [186u8, 162u8, 171u8, 222u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountAMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountBMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)` and selector `0x02751cec`.
-    ```solidity
-    function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETH(address,uint256,uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = removeLiquidityETHReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [2u8, 117u8, 28u8, 236u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256)` and selector `0xaf2979eb`.
-    ```solidity
-    function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,
-    /// uint256,uint256,address,
-    /// uint256)`](removeLiquidityETHSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: removeLiquidityETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [175u8, 41u8, 121u8, 235u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,\
-                 address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountTokenMin,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETHMin,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.deadline,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHSupportingFeeOnTransferTokensReturn = r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0xded9382a`.
-    ```solidity
-    function removeLiquidityETHWithPermit(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermit(address,uint256,uint256,uint256,address,
-    /// uint256,bool,uint8,bytes32,bytes32)`](removeLiquidityETHWithPermitCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountToken: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitCall) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityETHWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityETHWithPermitReturn) -> Self {
-                    (value.amountToken, value.amountETH)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityETHWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountToken: tuple.0,
-                        amountETH: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityETHWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountToken,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountETH,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityETHWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [222u8, 217u8, 56u8, 42u8];
-            const SIGNATURE: &'static str = "removeLiquidityETHWithPermit(address,uint256,uint256,\
-                                             uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityETHWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x5b0d5984`.
-    ```solidity
-    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountETH);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub token: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,
-    /// uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn {
-        #[allow(missing_docs)]
-        pub amountETH: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-                ) -> Self {
-                    (
-                        value.token,
-                        value.liquidity,
-                        value.amountTokenMin,
-                        value.amountETHMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token: tuple.0,
-                        liquidity: tuple.1,
-                        amountTokenMin: tuple.2,
-                        amountETHMin: tuple.3,
-                        to: tuple.4,
-                        deadline: tuple.5,
-                        approveMax: tuple.6,
-                        v: tuple.7,
-                        r: tuple.8,
-                        s: tuple.9,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl
-                ::core::convert::From<
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                > for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    (value.amountETH,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amountETH: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [91u8, 13u8, 89u8, 132u8];
-            const SIGNATURE: &'static str =
-                "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,uint256,\
-                 uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.token,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountTokenMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountETHMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                            r.into();
-                        r.amountETH
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: removeLiquidityETHWithPermitSupportingFeeOnTransferTokensReturn =
-                        r.into();
-                    r.amountETH
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `removeLiquidityWithPermit(address,address,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)` and selector `0x2195995c`.
-    ```solidity
-    function removeLiquidityWithPermit(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint256 amountA, uint256 amountB);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitCall {
-        #[allow(missing_docs)]
-        pub tokenA: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tokenB: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub approveMax: bool,
-        #[allow(missing_docs)]
-        pub v: u8,
-        #[allow(missing_docs)]
-        pub r: alloy_sol_types::private::FixedBytes<32>,
-        #[allow(missing_docs)]
-        pub s: alloy_sol_types::private::FixedBytes<32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`removeLiquidityWithPermit(address,address,uint256,uint256,uint256,
-    /// address,uint256,bool,uint8,bytes32,
-    /// bytes32)`](removeLiquidityWithPermitCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct removeLiquidityWithPermitReturn {
-        #[allow(missing_docs)]
-        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                bool,
-                u8,
-                alloy_sol_types::private::FixedBytes<32>,
-                alloy_sol_types::private::FixedBytes<32>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitCall> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitCall) -> Self {
-                    (
-                        value.tokenA,
-                        value.tokenB,
-                        value.liquidity,
-                        value.amountAMin,
-                        value.amountBMin,
-                        value.to,
-                        value.deadline,
-                        value.approveMax,
-                        value.v,
-                        value.r,
-                        value.s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tokenA: tuple.0,
-                        tokenB: tuple.1,
-                        liquidity: tuple.2,
-                        amountAMin: tuple.3,
-                        amountBMin: tuple.4,
-                        to: tuple.5,
-                        deadline: tuple.6,
-                        approveMax: tuple.7,
-                        v: tuple.8,
-                        r: tuple.9,
-                        s: tuple.10,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<removeLiquidityWithPermitReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: removeLiquidityWithPermitReturn) -> Self {
-                    (value.amountA, value.amountB)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeLiquidityWithPermitReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountA: tuple.0,
-                        amountB: tuple.1,
-                    }
-                }
-            }
-        }
-        impl removeLiquidityWithPermitReturn {
-            fn _tokenize(
-                &self,
-            ) -> <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountA,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountB,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for removeLiquidityWithPermitCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-                alloy_sol_types::sol_data::FixedBytes<32>,
-            );
-            type Return = removeLiquidityWithPermitReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [33u8, 149u8, 153u8, 92u8];
-            const SIGNATURE: &'static str = "removeLiquidityWithPermit(address,address,uint256,\
-                                             uint256,uint256,address,uint256,bool,uint8,bytes32,\
-                                             bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenA,
-                    ),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.tokenB,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.liquidity),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountAMin),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountBMin),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.approveMax,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        8,
-                    > as alloy_sol_types::SolType>::tokenize(&self.v),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.r),
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.s),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                removeLiquidityWithPermitReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapETHForExactTokens(uint256,address[],address,uint256)` and selector `0xfb3bdb41`.
-    ```solidity
-    function swapETHForExactTokens(uint256 amountOut, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapETHForExactTokens(uint256,address[],address,
-    /// uint256)`](swapETHForExactTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapETHForExactTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensCall) -> Self {
-                    (value.amountOut, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOut: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapETHForExactTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapETHForExactTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapETHForExactTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapETHForExactTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [251u8, 59u8, 219u8, 65u8];
-            const SIGNATURE: &'static str =
-                "swapETHForExactTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapETHForExactTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapETHForExactTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokens(uint256,address[],address,uint256)` and selector `0x7ff36ab5`.
-    ```solidity
-    function swapExactETHForTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokens(uint256,address[],address,
-    /// uint256)`](swapExactETHForTokensCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensReturn {
-        #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactETHForTokensReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactETHForTokensReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [127u8, 243u8, 106u8, 181u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokens(uint256,address[],address,uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactETHForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: swapExactETHForTokensReturn = r.into();
-                    r.amounts
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,uint256)` and selector `0xb6f9de95`.
-    ```solidity
-    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external payable;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],
-    /// address,uint256)`](swapExactETHForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactETHForTokensSupportingFeeOnTransferTokensReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (value.amountOutMin, value.path, value.to, value.deadline)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensCall
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountOutMin: tuple.0,
-                        path: tuple.1,
-                        to: tuple.2,
-                        deadline: tuple.3,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactETHForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactETHForTokensSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactETHForTokensSupportingFeeOnTransferTokensReturn
-            {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl swapExactETHForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactETHForTokensSupportingFeeOnTransferTokensReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [182u8, 249u8, 222u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,address[],address,\
-                 uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactETHForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETH(uint256,uint256,address[],address,uint256)` and selector `0x18cbafe5`.
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod UniswapV2Router02 {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"`\xC0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0W>8\x03\x80b\0W>\x839\x81\x81\x01`@R`@\x81\x10\x15b\0\x007W`\0\x80\xFD[P\x80Q` \x90\x91\x01Q`\x01`\x01``\x1B\x03\x19``\x92\x83\x1B\x81\x16`\x80R\x91\x1B\x16`\xA0R`\x80Q``\x1C`\xA0Q``\x1CaU\xB7b\0\x01\x87`\09\x80a\x01\xACR\x80a\x0E]R\x80a\x0E\x98R\x80a\x0F\xD5R\x80a\x12\x98R\x80a\x16\xF2R\x80a\x18\xD6R\x80a\x1E\x1ER\x80a\x1F\xA2R\x80a rR\x80a!yR\x80a#,R\x80a#\xC1R\x80a&sR\x80a'\x1AR\x80a'\xEFR\x80a(\xF4R\x80a)\xDCR\x80a*]R\x80a0\xECR\x80a4\"R\x80a4xR\x80a4\xACR\x80a5-R\x80a7GR\x80a8\xF7R\x80a9\x8CRP\x80a\x10\xC7R\x80a\x11\xC5R\x80a\x13kR\x80a\x13\xA4R\x80a\x15OR\x80a\x17\xE4R\x80a\x18\xB4R\x80a\x1A\xA1R\x80a\"_R\x80a$\0R\x80a%\xA9R\x80a*\x9CR\x80a-\xDFR\x80a0qR\x80a0\x9AR\x80a0\xCAR\x80a2\xA7R\x80a4VR\x80a8-R\x80a9\xCBR\x80aDJR\x80aD\x8DR\x80aG\xEDR\x80aI\xCER\x80aOIR\x80aP*R\x80aP\xAARPaU\xB7`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\x8FW`\x005`\xE0\x1C\x80c\x88\x03\xDB\xEE\x11a\0\xD6W\x80c\xC4Z\x01U\x11a\0\x7FW\x80c\xE8\xE37\0\x11a\0YW\x80c\xE8\xE37\0\x14a\x0CqW\x80c\xF3\x05\xD7\x19\x14a\x0C\xFEW\x80c\xFB;\xDBA\x14a\rQWa\x01\xD5V[\x80c\xC4Z\x01U\x14a\x0B%W\x80c\xD0l\xA6\x1F\x14a\x0B:W\x80c\xDE\xD98*\x14a\x0B\xF1Wa\x01\xD5V[\x80c\xAF)y\xEB\x11a\0\xB0W\x80c\xAF)y\xEB\x14a\t\xC8W\x80c\xB6\xF9\xDE\x95\x14a\n(W\x80c\xBA\xA2\xAB\xDE\x14a\n\xBBWa\x01\xD5V[\x80c\x88\x03\xDB\xEE\x14a\x08\xAFW\x80c\xAD\\FH\x14a\tTW\x80c\xADa]\xEC\x14a\t\x92Wa\x01\xD5V[\x80cJ%\xD9J\x11a\x018W\x80cy\x1A\xC9G\x11a\x01\x12W\x80cy\x1A\xC9G\x14a\x07AW\x80c\x7F\xF3j\xB5\x14a\x07\xE6W\x80c\x85\xF8\xC2Y\x14a\x08yWa\x01\xD5V[\x80cJ%\xD9J\x14a\x05wW\x80c[\rY\x84\x14a\x06\x1CW\x80c\\\x11\xD7\x95\x14a\x06\x9CWa\x01\xD5V[\x80c\x1F\0\xCAt\x11a\x01iW\x80c\x1F\0\xCAt\x14a\x03\x90W\x80c!\x95\x99\\\x14a\x04GW\x80c8\xED\x179\x14a\x04\xD2Wa\x01\xD5V[\x80c\x02u\x1C\xEC\x14a\x01\xDAW\x80c\x05MP\xD4\x14a\x02SW\x80c\x18\xCB\xAF\xE5\x14a\x02\x9BWa\x01\xD5V[6a\x01\xD5W3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x01\xD3W\xFE[\0[`\0\x80\xFD[4\x80\x15a\x01\xE6W`\0\x80\xFD[Pa\x02:`\x04\x806\x03`\xC0\x81\x10\x15a\x01\xFDW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a\r\xE4V[`@\x80Q\x92\x83R` \x83\x01\x91\x90\x91R\x80Q\x91\x82\x90\x03\x01\x90\xF3[4\x80\x15a\x02_W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\x02vW`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a\x0F7V[`@\x80Q\x91\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[4\x80\x15a\x02\xA7W`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x02\xBEW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x02\xE5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x02\xF7W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x03\x19W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x0FLV[`@\x80Q` \x80\x82R\x83Q\x81\x83\x01R\x83Q\x91\x92\x83\x92\x90\x83\x01\x91\x85\x81\x01\x91\x02\x80\x83\x83`\0[\x83\x81\x10\x15a\x03|W\x81\x81\x01Q\x83\x82\x01R` \x01a\x03dV[PPPP\x90P\x01\x92PPP`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x9CW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`@\x81\x10\x15a\x03\xB3W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x03\xD5W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x03\xE7W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x04\tW`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa\x13d\x94PPPPPV[4\x80\x15a\x04SW`\0\x80\xFD[Pa\x02:`\x04\x806\x03a\x01`\x81\x10\x15a\x04kW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x90\x91\x16\x90`\xC0\x81\x015\x90`\xE0\x81\x015\x15\x15\x90`\xFFa\x01\0\x82\x015\x16\x90a\x01 \x81\x015\x90a\x01@\x015a\x13\x9AV[4\x80\x15a\x04\xDEW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x04\xF5W`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x05\x1CW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05.W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05PW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x14\xD8V[4\x80\x15a\x05\x83W`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x05\x9AW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x05\xC1W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x05\xD3W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x05\xF5W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x16iV[4\x80\x15a\x06(W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03a\x01@\x81\x10\x15a\x06@W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x81\x015\x15\x15\x90`\xFF`\xE0\x82\x015\x16\x90a\x01\0\x81\x015\x90a\x01 \x015a\x18\xACV[4\x80\x15a\x06\xA8W`\0\x80\xFD[Pa\x01\xD3`\x04\x806\x03`\xA0\x81\x10\x15a\x06\xBFW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x06\xE6W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x06\xF8W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\x1AW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x19\xFEV[4\x80\x15a\x07MW`\0\x80\xFD[Pa\x01\xD3`\x04\x806\x03`\xA0\x81\x10\x15a\x07dW`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x07\x8BW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x07\x9DW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x07\xBFW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a\x1D\x97V[a\x03@`\x04\x806\x03`\x80\x81\x10\x15a\x07\xFCW`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x08\x1EW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x080W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x08RW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a!\x05V[4\x80\x15a\x08\x85W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\x08\x9CW`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a%%V[4\x80\x15a\x08\xBBW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`\xA0\x81\x10\x15a\x08\xD2W`\0\x80\xFD[\x815\x91` \x81\x015\x91\x81\x01\x90``\x81\x01`@\x82\x015d\x01\0\0\0\0\x81\x11\x15a\x08\xF9W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\t\x0BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\t-W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a%2V[4\x80\x15a\t`W`\0\x80\xFD[Pa\tia&qV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x82RQ\x90\x81\x90\x03` \x01\x90\xF3[4\x80\x15a\t\x9EW`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03``\x81\x10\x15a\t\xB5W`\0\x80\xFD[P\x805\x90` \x81\x015\x90`@\x015a&\x95V[4\x80\x15a\t\xD4W`\0\x80\xFD[Pa\x02\x89`\x04\x806\x03`\xC0\x81\x10\x15a\t\xEBW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a&\xA2V[a\x01\xD3`\x04\x806\x03`\x80\x81\x10\x15a\n>W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\n`W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\nrW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\n\x94W`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a(\x82V[4\x80\x15a\n\xC7W`\0\x80\xFD[Pa\x02:`\x04\x806\x03`\xE0\x81\x10\x15a\n\xDEW`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x90\x91\x16\x90`\xC0\x015a-eV[4\x80\x15a\x0B1W`\0\x80\xFD[Pa\tia0oV[4\x80\x15a\x0BFW`\0\x80\xFD[Pa\x03@`\x04\x806\x03`@\x81\x10\x15a\x0B]W`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\x0B\x7FW`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\x0B\x91W`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\x0B\xB3W`\0\x80\xFD[\x91\x90\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x92\x95Pa0\x93\x94PPPPPV[4\x80\x15a\x0B\xFDW`\0\x80\xFD[Pa\x02:`\x04\x806\x03a\x01@\x81\x10\x15a\x0C\x15W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x81\x015\x90`\xC0\x81\x015\x15\x15\x90`\xFF`\xE0\x82\x015\x16\x90a\x01\0\x81\x015\x90a\x01 \x015a0\xC0V[4\x80\x15a\x0C}W`\0\x80\xFD[Pa\x0C\xE0`\x04\x806\x03a\x01\0\x81\x10\x15a\x0C\x95W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x82\x16\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x91`\xA0\x81\x015\x91`\xC0\x82\x015\x16\x90`\xE0\x015a2\x18V[`@\x80Q\x93\x84R` \x84\x01\x92\x90\x92R\x82\x82\x01RQ\x90\x81\x90\x03``\x01\x90\xF3[a\x0C\xE0`\x04\x806\x03`\xC0\x81\x10\x15a\r\x14W`\0\x80\xFD[Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x81\x16\x91` \x81\x015\x91`@\x82\x015\x91``\x81\x015\x91`\x80\x82\x015\x16\x90`\xA0\x015a3\xA7V[a\x03@`\x04\x806\x03`\x80\x81\x10\x15a\rgW`\0\x80\xFD[\x815\x91\x90\x81\x01\x90`@\x81\x01` \x82\x015d\x01\0\0\0\0\x81\x11\x15a\r\x89W`\0\x80\xFD[\x82\x01\x83` \x82\x01\x11\x15a\r\x9BW`\0\x80\xFD[\x805\x90` \x01\x91\x84` \x83\x02\x84\x01\x11d\x01\0\0\0\0\x83\x11\x17\x15a\r\xBDW`\0\x80\xFD[\x91\x93P\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x815\x16\x90` \x015a6\xD3V[`\0\x80\x82B\x81\x10\x15a\x0EWW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x0E\x86\x89\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x8A\x8A0\x8Aa-eV[\x90\x93P\x91Pa\x0E\x96\x89\x86\x85a;\"V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x0F\tW`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0F\x1DW=`\0\x80>=`\0\xFD[PPPPa\x0F+\x85\x83a<\xFFV[P\x96P\x96\x94PPPPPV[`\0a\x0FD\x84\x84\x84a><V[\x94\x93PPPPV[``\x81B\x81\x10\x15a\x0F\xBEW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x10#W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x10\xC2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x11 \x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\x113W\xFE[` \x02` \x01\x01Q\x10\x15a\x11\x92W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x12W\x86\x86`\0\x81\x81\x10a\x11\xA2W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163a\x12=\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8A\x8A`\0\x81\x81\x10a\x11\xF1W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8B\x8B`\x01\x81\x81\x10a\x12\x1BW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a@\xC6V[\x85`\0\x81Q\x81\x10a\x12JW\xFE[` \x02` \x01\x01QaA\xB1V[a\x12\x96\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP0\x92PaC\x81\x91PPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`\x01\x85Q\x03\x81Q\x81\x10a\x12\xE2W\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x13 W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x134W=`\0\x80>=`\0\xFD[PPPPa\x13Y\x84\x83`\x01\x85Q\x03\x81Q\x81\x10a\x13LW\xFE[` \x02` \x01\x01Qa<\xFFV[P\x96\x95PPPPPPV[``a\x13\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x84aF\x08V[\x90P[\x92\x91PPV[`\0\x80`\0a\x13\xCA\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8F\x8Fa@\xC6V[\x90P`\0\x87a\x13\xD9W\x8Ca\x13\xFBV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8C\x90R`\xFF\x8A\x16`\x84\x82\x01R`\xA4\x81\x01\x89\x90R`\xC4\x81\x01\x88\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x14\x97W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x14\xABW=`\0\x80>=`\0\xFD[PPPPa\x14\xBE\x8F\x8F\x8F\x8F\x8F\x8F\x8Fa-eV[\x80\x94P\x81\x95PPPPP\x9BP\x9B\x99PPPPPPPPPPV[``\x81B\x81\x10\x15a\x15JW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x15\xA8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\x15\xBBW\xFE[` \x02` \x01\x01Q\x10\x15a\x16\x1AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[a\x16*\x86\x86`\0\x81\x81\x10a\x11\xA2W\xFE[a\x13Y\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[``\x81B\x81\x10\x15a\x16\xDBW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x17@W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x17\xDFW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x18=\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P\x86\x82`\0\x81Q\x81\x10a\x18MW\xFE[` \x02` \x01\x01Q\x11\x15a\x11\x92W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x80a\x18\xFA\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8D\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90P`\0\x86a\x19\tW\x8Ba\x19+V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8B\x90R`\xFF\x89\x16`\x84\x82\x01R`\xA4\x81\x01\x88\x90R`\xC4\x81\x01\x87\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a\x19\xC7W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x19\xDBW=`\0\x80>=`\0\xFD[PPPPa\x19\xED\x8D\x8D\x8D\x8D\x8D\x8Da&\xA2V[\x9D\x9CPPPPPPPPPPPPPV[\x80B\x81\x10\x15a\x1AnW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1A\xFD\x85\x85`\0\x81\x81\x10a\x1A~W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163a\x1A\xF7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8A\x8A`\x01\x81\x81\x10a\x12\x1BW\xFE[\x8AaA\xB1V[`\0\x85\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1B-W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x85`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1B\xC6W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1B\xDAW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1B\xF0W`\0\x80\xFD[PQ`@\x80Q` \x88\x81\x02\x82\x81\x01\x82\x01\x90\x93R\x88\x82R\x92\x93Pa\x1C2\x92\x90\x91\x89\x91\x89\x91\x82\x91\x85\x01\x90\x84\x90\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x88\x92PaG\x96\x91PPV[\x86a\x1D6\x82\x88\x88\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1CeW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1D\x12W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a\x1D(W`\0\x80\xFD[PQ\x90c\xFF\xFF\xFF\xFFaK)\x16V[\x10\x15a\x1D\x8DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPPPPPV[\x80B\x81\x10\x15a\x1E\x07W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x85\x85\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a\x1ElW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1F\x0BW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\x1F\x1B\x85\x85`\0\x81\x81\x10a\x1A~W\xFE[a\x1FY\x85\x85\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP0\x92PaG\x96\x91PPV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q`\0\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a\x1F\xE9W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x1F\xFDW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a \x13W`\0\x80\xFD[PQ\x90P\x86\x81\x10\x15a pW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a \xE3W`\0\x80\xFD[PZ\xF1\x15\x80\x15a \xF7W=`\0\x80>=`\0\xFD[PPPPa\x1D\x8D\x84\x82a<\xFFV[``\x81B\x81\x10\x15a!wW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x86`\0\x81\x81\x10a!\xBBW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\"ZW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a\"\xB8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x004\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa?`\x92PPPV[\x91P\x86\x82`\x01\x84Q\x03\x81Q\x81\x10a\"\xCBW\xFE[` \x02` \x01\x01Q\x10\x15a#*W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aU\x08`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x83`\0\x81Q\x81\x10a#sW\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a#\xA6W`\0\x80\xFD[PZ\xF1\x15\x80\x15a#\xBAW=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa$,\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x84`\0\x81Q\x81\x10a$9W\xFE[` \x02` \x01\x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a$\xAAW`\0\x80\xFD[PZ\xF1\x15\x80\x15a$\xBEW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a$\xD4W`\0\x80\xFD[PQa$\xDCW\xFE[a%\x1B\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[P\x95\x94PPPPPV[`\0a\x0FD\x84\x84\x84aK\x9BV[``\x81B\x81\x10\x15a%\xA4W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a&\x02\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P\x86\x82`\0\x81Q\x81\x10a&\x12W\xFE[` \x02` \x01\x01Q\x11\x15a\x16\x1AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0a\x0FD\x84\x84\x84aL\xBFV[`\0\x81B\x81\x10\x15a'\x14W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a'C\x88\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89\x890\x89a-eV[`@\x80Q\x7Fp\xA0\x821\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R0`\x04\x82\x01R\x90Q\x91\x94Pa'\xED\x92P\x8A\x91\x87\x91s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91cp\xA0\x821\x91`$\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15a'\xBCW`\0\x80\xFD[PZ\xFA\x15\x80\x15a'\xD0W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a'\xE6W`\0\x80\xFD[PQa;\"V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c.\x1A}M\x83`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82\x81R` \x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a(`W`\0\x80\xFD[PZ\xF1\x15\x80\x15a(tW=`\0\x80>=`\0\xFD[PPPPa\x13Y\x84\x83a<\xFFV[\x80B\x81\x10\x15a(\xF2W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85\x85`\0\x81\x81\x10a)6W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a)\xD5W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\x004\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a*BW`\0\x80\xFD[PZ\xF1\x15\x80\x15a*VW=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa*\xC8\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a+2W`\0\x80\xFD[PZ\xF1\x15\x80\x15a+FW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a+\\W`\0\x80\xFD[PQa+dW\xFE[`\0\x86\x86\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a+\x94W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x86`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a,-W`\0\x80\xFD[PZ\xFA\x15\x80\x15a,AW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a,WW`\0\x80\xFD[PQ`@\x80Q` \x89\x81\x02\x82\x81\x01\x82\x01\x90\x93R\x89\x82R\x92\x93Pa,\x99\x92\x90\x91\x8A\x91\x8A\x91\x82\x91\x85\x01\x90\x84\x90\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaG\x96\x91PPV[\x87a\x1D6\x82\x89\x89\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x01\x81\x81\x10a,\xCCW\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x89`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[`\0\x80\x82B\x81\x10\x15a-\xD8W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0a.\x05\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x8Ca@\xC6V[`@\x80Q\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01\x81\x90R`D\x82\x01\x8D\x90R\x91Q\x92\x93P\x90\x91c#\xB8r\xDD\x91`d\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81`\0\x87\x80;\x15\x80\x15a.\x86W`\0\x80\xFD[PZ\xF1\x15\x80\x15a.\x9AW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a.\xB0W`\0\x80\xFD[PP`@\x80Q\x7F\x89\xAF\xCBD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x82Q`\0\x93\x84\x93\x92\x86\x16\x92c\x89\xAF\xCBD\x92`$\x80\x83\x01\x93\x92\x82\x90\x03\x01\x81\x87\x87\x80;\x15\x80\x15a/#W`\0\x80\xFD[PZ\xF1\x15\x80\x15a/7W=`\0\x80>=`\0\xFD[PPPP`@Q=`@\x81\x10\x15a/MW`\0\x80\xFD[P\x80Q` \x90\x91\x01Q\x90\x92P\x90P`\0a/g\x8E\x8EaM\x9FV[P\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x8Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a/\xA4W\x81\x83a/\xA7V[\x82\x82[\x90\x97P\x95P\x8A\x87\x10\x15a0\x05W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT\xBF`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x89\x86\x10\x15a0^W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT%`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPP\x97P\x97\x95PPPPPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[``a\x13\x91\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x84a?`V[`\0\x80`\0a1\x10\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8E\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90P`\0\x87a1\x1FW\x8Ca1AV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF[`@\x80Q\x7F\xD5\x05\xAC\xCF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R3`\x04\x82\x01R0`$\x82\x01R`D\x81\x01\x83\x90R`d\x81\x01\x8C\x90R`\xFF\x8A\x16`\x84\x82\x01R`\xA4\x81\x01\x89\x90R`\xC4\x81\x01\x88\x90R\x90Q\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91c\xD5\x05\xAC\xCF\x91`\xE4\x80\x82\x01\x92`\0\x92\x90\x91\x90\x82\x90\x03\x01\x81\x83\x87\x80;\x15\x80\x15a1\xDDW`\0\x80\xFD[PZ\xF1\x15\x80\x15a1\xF1W=`\0\x80>=`\0\xFD[PPPPa2\x03\x8E\x8E\x8E\x8E\x8E\x8Ea\r\xE4V[\x90\x9F\x90\x9EP\x9CPPPPPPPPPPPPPV[`\0\x80`\0\x83B\x81\x10\x15a2\x8DW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a2\x9B\x8C\x8C\x8C\x8C\x8C\x8CaN\xF2V[\x90\x94P\x92P`\0a2\xCD\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8E\x8Ea@\xC6V[\x90Pa2\xDB\x8D3\x83\x88aA\xB1V[a2\xE7\x8C3\x83\x87aA\xB1V[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cjbxB\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a3fW`\0\x80\xFD[PZ\xF1\x15\x80\x15a3zW=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a3\x90W`\0\x80\xFD[PQ\x94\x9D\x93\x9CP\x93\x9AP\x91\x98PPPPPPPPPV[`\0\x80`\0\x83B\x81\x10\x15a4\x1CW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a4J\x8A\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B4\x8C\x8CaN\xF2V[\x90\x94P\x92P`\0a4\x9C\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8C\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a@\xC6V[\x90Pa4\xAA\x8B3\x83\x88aA\xB1V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x85`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a5\x12W`\0\x80\xFD[PZ\xF1\x15\x80\x15a5&W=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBB\x82\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a5\xD2W`\0\x80\xFD[PZ\xF1\x15\x80\x15a5\xE6W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a5\xFCW`\0\x80\xFD[PQa6\x04W\xFE[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cjbxB\x88`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a6\x83W`\0\x80\xFD[PZ\xF1\x15\x80\x15a6\x97W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a6\xADW`\0\x80\xFD[PQ\x92P4\x84\x10\x15a6\xC5Wa6\xC53\x854\x03a<\xFFV[PP\x96P\x96P\x96\x93PPPPV[``\x81B\x81\x10\x15a7EW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FUniswapV2Router: EXPIRED\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86\x86`\0\x81\x81\x10a7\x89W\xFE[\x90P` \x02\x015s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a8(W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUniswapV2Router: INVALID_PATH\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[a8\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88\x88\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RPaF\x08\x92PPPV[\x91P4\x82`\0\x81Q\x81\x10a8\x96W\xFE[` \x02` \x01\x01Q\x11\x15a8\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`'\x81R` \x01\x80aT\x98`'\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xD0\xE3\r\xB0\x83`\0\x81Q\x81\x10a9>W\xFE[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a9qW`\0\x80\xFD[PZ\xF1\x15\x80\x15a9\x85W=`\0\x80>=`\0\xFD[PPPPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA9\x05\x9C\xBBa9\xF7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x89`\0\x81\x81\x10a\x1A\xCDW\xFE[\x84`\0\x81Q\x81\x10a:\x04W\xFE[` \x02` \x01\x01Q`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x92PPP` `@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a:uW`\0\x80\xFD[PZ\xF1\x15\x80\x15a:\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15a:\x9FW`\0\x80\xFD[PQa:\xA7W\xFE[a:\xE6\x82\x87\x87\x80\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83` \x02\x80\x82\x847`\0\x92\x01\x91\x90\x91RP\x89\x92PaC\x81\x91PPV[\x81`\0\x81Q\x81\x10a:\xF3W\xFE[` \x02` \x01\x01Q4\x11\x15a%\x1BWa%\x1B3\x83`\0\x81Q\x81\x10a;\x13W\xFE[` \x02` \x01\x01Q4\x03a<\xFFV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`$\x83\x01R`D\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`d\x90\x92\x01\x83R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xA9\x05\x9C\xBB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x82Q`\0\x94``\x94\x93\x89\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10a;\xF8W\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a;\xBBV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14a<ZW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a<_V[``\x91P[P\x91P\x91P\x81\x80\x15a<\x8DWP\x80Q\x15\x80a<\x8DWP\x80\x80` \x01\x90Q` \x81\x10\x15a<\x8AW`\0\x80\xFD[PQ[a<\xF8W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FTransferHelper: TRANSFER_FAILED\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[PPPPPV[`@\x80Q`\0\x80\x82R` \x82\x01\x90\x92Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90\x83\x90`@Q\x80\x82\x80Q\x90` \x01\x90\x80\x83\x83[` \x83\x10a=vW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01a=9V[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a=\xD8W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a=\xDDV[``\x91P[PP\x90P\x80a>7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`#\x81R` \x01\x80aT\xE5`#\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPV[`\0\x80\x84\x11a>\x96W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`+\x81R` \x01\x80aUW`+\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15a>\xA6WP`\0\x82\x11[a>\xFBW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0a?\x0F\x85a\x03\xE5c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0a?#\x82\x85c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0a?I\x83a?=\x88a\x03\xE8c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90c\xFF\xFF\xFF\xFFaRy\x16V[\x90P\x80\x82\x81a?TW\xFE[\x04\x97\x96PPPPPPPV[```\x02\x82Q\x10\x15a?\xD3W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: INVALID_PATH\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15a?\xEBW`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a@\x15W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82\x81`\0\x81Q\x81\x10a@&W\xFE[` \x02` \x01\x01\x81\x81RPP`\0[`\x01\x83Q\x03\x81\x10\x15a@\xBEW`\0\x80a@x\x87\x86\x85\x81Q\x81\x10a@TW\xFE[` \x02` \x01\x01Q\x87\x86`\x01\x01\x81Q\x81\x10a@kW\xFE[` \x02` \x01\x01QaR\xEBV[\x91P\x91Pa@\x9A\x84\x84\x81Q\x81\x10a@\x8BW\xFE[` \x02` \x01\x01Q\x83\x83a><V[\x84\x84`\x01\x01\x81Q\x81\x10a@\xA9W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP`\x01\x01a@5V[P\x93\x92PPPV[`\0\x80`\0a@\xD5\x85\x85aM\x9FV[`@\x80Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0``\x94\x85\x1B\x81\x16` \x80\x84\x01\x91\x90\x91R\x93\x85\x1B\x81\x16`4\x83\x01R\x82Q`(\x81\x84\x03\x01\x81R`H\x83\x01\x84R\x80Q\x90\x85\x01 \x7F\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`h\x84\x01R\x9A\x90\x94\x1B\x90\x93\x16`i\x84\x01R`}\x83\x01\x98\x90\x98R\x7F\x96\xE8\xACBw\x19\x8F\xF8\xB6\xF7\x85G\x8A\xA9\xA3\x9F@<\xB7h\xDD\x02\xCB\xEE2l>}\xA3H\x84_`\x9D\x80\x84\x01\x91\x90\x91R\x88Q\x80\x84\x03\x90\x91\x01\x81R`\xBD\x90\x92\x01\x90\x97R\x80Q\x96\x01\x95\x90\x95 \x95\x94PPPPPV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x81\x16`$\x83\x01R\x84\x81\x16`D\x83\x01R`d\x80\x83\x01\x85\x90R\x83Q\x80\x84\x03\x90\x91\x01\x81R`\x84\x90\x92\x01\x83R` \x82\x01\x80Q{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F#\xB8r\xDD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x17\x81R\x92Q\x82Q`\0\x94``\x94\x93\x8A\x16\x93\x92\x91\x82\x91\x90\x80\x83\x83[` \x83\x10aB\x8FW\x80Q\x82R\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xE0\x90\x92\x01\x91` \x91\x82\x01\x91\x01aBRV[`\x01\x83` \x03a\x01\0\n\x03\x80\x19\x82Q\x16\x81\x84Q\x16\x80\x82\x17\x85RPPPPPP\x90P\x01\x91PP`\0`@Q\x80\x83\x03\x81`\0\x86Z\xF1\x91PP=\x80`\0\x81\x14aB\xF1W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>aB\xF6V[``\x91P[P\x91P\x91P\x81\x80\x15aC$WP\x80Q\x15\x80aC$WP\x80\x80` \x01\x90Q` \x81\x10\x15aC!W`\0\x80\xFD[PQ[aCyW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`$\x81R` \x01\x80aU3`$\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[PPPPPPV[`\0[`\x01\x83Q\x03\x81\x10\x15aF\x02W`\0\x80\x84\x83\x81Q\x81\x10aC\x9FW\xFE[` \x02` \x01\x01Q\x85\x84`\x01\x01\x81Q\x81\x10aC\xB6W\xFE[` \x02` \x01\x01Q\x91P\x91P`\0aC\xCE\x83\x83aM\x9FV[P\x90P`\0\x87\x85`\x01\x01\x81Q\x81\x10aC\xE2W\xFE[` \x02` \x01\x01Q\x90P`\0\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aD*W\x82`\0aD.V[`\0\x83[\x91P\x91P`\0`\x02\x8AQ\x03\x88\x10aDEW\x88aD\x86V[aD\x86\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x87\x8C\x8B`\x02\x01\x81Q\x81\x10aDyW\xFE[` \x02` \x01\x01Qa@\xC6V[\x90PaD\xB3\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x88\x88a@\xC6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x02,\r\x9F\x84\x84\x84`\0`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15aD\xFDW` \x82\x01\x81\x806\x837\x01\x90P[P`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x85\x81R` \x01\x84\x81R` \x01\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x80` \x01\x82\x81\x03\x82R\x83\x81\x81Q\x81R` \x01\x91P\x80Q\x90` \x01\x90\x80\x83\x83`\0[\x83\x81\x10\x15aE\x88W\x81\x81\x01Q\x83\x82\x01R` \x01aEpV[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15aE\xB5W\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aE\xD7W`\0\x80\xFD[PZ\xF1\x15\x80\x15aE\xEBW=`\0\x80>=`\0\xFD[PP`\x01\x90\x99\x01\x98PaC\x84\x97PPPPPPPPV[PPPPV[```\x02\x82Q\x10\x15aF{W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: INVALID_PATH\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x80\x15aF\x93W`\0\x80\xFD[P`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15aF\xBDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x82\x81`\x01\x83Q\x03\x81Q\x81\x10aF\xD1W\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01[\x80\x15a@\xBEW`\0\x80aG1\x87\x86`\x01\x86\x03\x81Q\x81\x10aG\x1DW\xFE[` \x02` \x01\x01Q\x87\x86\x81Q\x81\x10a@kW\xFE[\x91P\x91PaGS\x84\x84\x81Q\x81\x10aGDW\xFE[` \x02` \x01\x01Q\x83\x83aK\x9BV[\x84`\x01\x85\x03\x81Q\x81\x10aGbW\xFE[` \x90\x81\x02\x91\x90\x91\x01\x01RPP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01aG\x01V[`\0[`\x01\x83Q\x03\x81\x10\x15a>7W`\0\x80\x84\x83\x81Q\x81\x10aG\xB4W\xFE[` \x02` \x01\x01Q\x85\x84`\x01\x01\x81Q\x81\x10aG\xCBW\xFE[` \x02` \x01\x01Q\x91P\x91P`\0aG\xE3\x83\x83aM\x9FV[P\x90P`\0aH\x13\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85\x85a@\xC6V[\x90P`\0\x80`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aHaW`\0\x80\xFD[PZ\xFA\x15\x80\x15aHuW=`\0\x80>=`\0\xFD[PPPP`@Q=``\x81\x10\x15aH\x8BW`\0\x80\xFD[P\x80Q` \x90\x91\x01Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93P\x16\x90P`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x81\x16\x90\x89\x16\x14aH\xD5W\x82\x84aH\xD8V[\x83\x83[\x91P\x91PaI]\x82\x8Bs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cp\xA0\x821\x8A`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x91PP` `@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C\xFEW`\0\x80\xFD[\x95PaIj\x86\x83\x83a><V[\x94PPPPP`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x88s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14aI\xAEW\x82`\0aI\xB2V[`\0\x83[\x91P\x91P`\0`\x02\x8CQ\x03\x8A\x10aI\xC9W\x8AaI\xFDV[aI\xFD\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\x8E\x8D`\x02\x01\x81Q\x81\x10aDyW\xFE[`@\x80Q`\0\x80\x82R` \x82\x01\x92\x83\x90R\x7F\x02,\r\x9F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83R`$\x82\x01\x87\x81R`D\x83\x01\x87\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x86\x16`d\x85\x01R`\x80`\x84\x85\x01\x90\x81R\x84Q`\xA4\x86\x01\x81\x90R\x96\x97P\x90\x8C\x16\x95c\x02,\r\x9F\x95\x8A\x95\x8A\x95\x8A\x95\x91\x94\x91\x93\x91\x92`\xC4\x86\x01\x92\x90\x91\x81\x90\x84\x90\x84\x90[\x83\x81\x10\x15aJ\xADW\x81\x81\x01Q\x83\x82\x01R` \x01aJ\x95V[PPPP\x90P\x90\x81\x01\x90`\x1F\x16\x80\x15aJ\xDAW\x80\x82\x03\x80Q`\x01\x83` \x03a\x01\0\n\x03\x19\x16\x81R` \x01\x91P[P\x95PPPPPP`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15aJ\xFCW`\0\x80\xFD[PZ\xF1\x15\x80\x15aK\x10W=`\0\x80>=`\0\xFD[PP`\x01\x90\x9B\x01\x9APaG\x99\x99PPPPPPPPPPV[\x80\x82\x03\x82\x81\x11\x15a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7Fds-math-sub-underflow\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80\x84\x11aK\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`,\x81R` \x01\x80aS\xD4`,\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15aL\x05WP`\0\x82\x11[aLZW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0aL~a\x03\xE8aLr\x86\x88c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x90P`\0aL\x98a\x03\xE5aLr\x86\x89c\xFF\xFF\xFF\xFFaK)\x16V[\x90PaL\xB5`\x01\x82\x84\x81aL\xA8W\xFE[\x04\x90c\xFF\xFF\xFF\xFFaRy\x16V[\x96\x95PPPPPPV[`\0\x80\x84\x11aM\x19W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80aTs`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[`\0\x83\x11\x80\x15aM)WP`\0\x82\x11[aM~W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`(\x81R` \x01\x80aTK`(\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82aM\x8F\x85\x84c\xFF\xFF\xFF\xFFaQ\xF3\x16V[\x81aM\x96W\xFE[\x04\x94\x93PPPPV[`\0\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aN'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`%\x81R` \x01\x80aT\0`%\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10aNaW\x82\x84aNdV[\x83\x83[\x90\x92P\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16aN\xEBW`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FUniswapV2Library: ZERO_ADDRESS\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x92P\x92\x90PV[`@\x80Q\x7F\xE6\xA49\x05\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x88\x81\x16`\x04\x83\x01R\x87\x81\x16`$\x83\x01R\x91Q`\0\x92\x83\x92\x83\x92\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16\x91c\xE6\xA49\x05\x91`D\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81\x86\x80;\x15\x80\x15aO\x92W`\0\x80\xFD[PZ\xFA\x15\x80\x15aO\xA6W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15aO\xBCW`\0\x80\xFD[PQs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15aP\xA2W`@\x80Q\x7F\xC9\xC6S\x96\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x81\x16`\x04\x83\x01R\x89\x81\x16`$\x83\x01R\x91Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x92\x16\x91c\xC9\xC6S\x96\x91`D\x80\x82\x01\x92` \x92\x90\x91\x90\x82\x90\x03\x01\x81`\0\x87\x80;\x15\x80\x15aPuW`\0\x80\xFD[PZ\xF1\x15\x80\x15aP\x89W=`\0\x80>=`\0\xFD[PPPP`@Q=` \x81\x10\x15aP\x9FW`\0\x80\xFD[PP[`\0\x80aP\xD0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8B\x8BaR\xEBV[\x91P\x91P\x81`\0\x14\x80\x15aP\xE2WP\x80\x15[\x15aP\xF2W\x87\x93P\x86\x92PaQ\xE6V[`\0aP\xFF\x89\x84\x84aL\xBFV[\x90P\x87\x81\x11aQlW\x85\x81\x10\x15aQaW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT%`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x88\x94P\x92P\x82aQ\xE4V[`\0aQy\x89\x84\x86aL\xBFV[\x90P\x89\x81\x11\x15aQ\x85W\xFE[\x87\x81\x10\x15aQ\xDEW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01\x80\x80` \x01\x82\x81\x03\x82R`&\x81R` \x01\x80aT\xBF`&\x919`@\x01\x91PP`@Q\x80\x91\x03\x90\xFD[\x94P\x87\x93P[P[PP\x96P\x96\x94PPPPPV[`\0\x81\x15\x80aR\x0EWPP\x80\x82\x02\x82\x82\x82\x81aR\x0BW\xFE[\x04\x14[a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-mul-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[\x80\x82\x01\x82\x81\x10\x15a\x13\x94W`@\x80Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7Fds-math-add-overflow\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R\x90Q\x90\x81\x90\x03`d\x01\x90\xFD[`\0\x80`\0aR\xFA\x85\x85aM\x9FV[P\x90P`\0\x80aS\x0B\x88\x88\x88a@\xC6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\t\x02\xF1\xAC`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01```@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15aSPW`\0\x80\xFD[PZ\xFA\x15\x80\x15aSdW=`\0\x80>=`\0\xFD[PPPP`@Q=``\x81\x10\x15aSzW`\0\x80\xFD[P\x80Q` \x90\x91\x01Qm\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16\x93P\x16\x90Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x81\x16\x90\x84\x16\x14aS\xC1W\x80\x82aS\xC4V[\x81\x81[\x90\x99\x90\x98P\x96PPPPPPPV\xFEUniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNTUniswapV2Library: IDENTICAL_ADDRESSESUniswapV2Router: INSUFFICIENT_B_AMOUNTUniswapV2Library: INSUFFICIENT_LIQUIDITYUniswapV2Library: INSUFFICIENT_AMOUNTUniswapV2Router: EXCESSIVE_INPUT_AMOUNTUniswapV2Router: INSUFFICIENT_A_AMOUNTTransferHelper: ETH_TRANSFER_FAILEDUniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNTTransferHelper: TRANSFER_FROM_FAILEDUniswapV2Library: INSUFFICIENT_INPUT_AMOUNT\xA2dipfsX\"\x12 m\xD6\xE0<K,\n\x8EU!I&\"z\xE9\xE2\xD6\xF9\xFE\xC2\xCEt\xA6DmaZ\xFA5\\\x84\xF3dsolcC\0\x06\x06\x003",
+    );
+    /**Constructor`.
     ```solidity
-    function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    constructor(address _factory, address _WETH);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+    pub struct constructorCall {
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETH(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForETHCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct swapExactTokensForETHReturn {
+        pub _factory: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub _WETH: alloy_sol_types::private::Address,
     }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
     const _: () = {
         use alloy_sol_types;
         {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Address,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -4844,84 +262,30 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (value._factory, value._WETH)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        _factory: tuple.0,
+                        _WETH: tuple.1,
                     }
                 }
             }
         }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForETHReturn) -> Self {
-                    (value.amounts,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForETHReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
-                }
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHCall {
+        impl alloy_sol_types::SolConstructor for constructorCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Address,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [24u8, 203u8, 175u8, 229u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETH(uint256,uint256,address[],address,uint256)";
-
             #[inline]
             fn new<'a>(
                 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
@@ -4932,80 +296,33 @@ pub mod UniswapV2Router02 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                        &self._factory,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._WETH,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForETHReturn = r.into();
-                        r.amounts
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForETHReturn = r.into();
-                    r.amounts
-                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x791ac947`.
+    /**Function with signature `WETH()` and selector `0xad5c4648`.
     ```solidity
-    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function WETH() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    ///Container type for the return parameters of the
-    /// [`swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForETHSupportingFeeOnTransferTokensCall)
+    pub struct WETHCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`WETH()`](WETHCall)
     /// function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForETHSupportingFeeOnTransferTokensReturn {}
+    pub struct WETHReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5017,21 +334,9 @@ pub mod UniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5043,41 +348,25 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<WETHCall> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5089,50 +378,29 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForETHSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForETHSupportingFeeOnTransferTokensReturn) -> Self {
-                    ()
+            impl ::core::convert::From<WETHReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: WETHReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForETHSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for WETHReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForETHSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForETHSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for WETHCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [121u8, 26u8, 201u8, 71u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 92u8, 70u8, 72u8];
+            const SIGNATURE: &'static str = "WETH()";
 
             #[inline]
             fn new<'a>(
@@ -5143,34 +411,22 @@ pub mod UniswapV2Router02 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForETHSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: WETHReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5178,24 +434,33 @@ pub mod UniswapV2Router02 {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: WETHReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokens(uint256,uint256,address[],address,uint256)` and selector `0x38ed1739`.
+    /**Function with signature `addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)` and selector `0xe8e33700`.
     ```solidity
-    function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensCall {
+    pub struct addLiquidityCall {
+        #[allow(missing_docs)]
+        pub tokenA: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
+        pub tokenB: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
+        pub amountADesired: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountBDesired: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountAMin: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountBMin: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
         pub to: alloy_sol_types::private::Address,
         #[allow(missing_docs)]
@@ -5203,14 +468,17 @@ pub mod UniswapV2Router02 {
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokens(uint256,uint256,address[],address,
-    /// uint256)`](swapExactTokensForTokensCall) function.
+    /// [`addLiquidity(address,address,uint256,uint256,uint256,uint256,address,
+    /// uint256)`](addLiquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensReturn {
+    pub struct addLiquidityReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub liquidity: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5224,17 +492,23 @@ pub mod UniswapV2Router02 {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
                 alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
@@ -5249,12 +523,15 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensCall) -> Self {
+            impl ::core::convert::From<addLiquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityCall) -> Self {
                     (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
+                        value.tokenA,
+                        value.tokenB,
+                        value.amountADesired,
+                        value.amountBDesired,
+                        value.amountAMin,
+                        value.amountBMin,
                         value.to,
                         value.deadline,
                     )
@@ -5262,14 +539,17 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        tokenA: tuple.0,
+                        tokenB: tuple.1,
+                        amountADesired: tuple.2,
+                        amountBDesired: tuple.3,
+                        amountAMin: tuple.4,
+                        amountBMin: tuple.5,
+                        to: tuple.6,
+                        deadline: tuple.7,
                     }
                 }
             }
@@ -5277,11 +557,16 @@ pub mod UniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5294,38 +579,62 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapExactTokensForTokensReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<addLiquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: addLiquidityReturn) -> Self {
+                    (value.amountA, value.amountB, value.liquidity)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapExactTokensForTokensReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addLiquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self {
+                        amountA: tuple.0,
+                        amountB: tuple.1,
+                        liquidity: tuple.2,
+                    }
                 }
             }
         }
+        impl addLiquidityReturn {
+            fn _tokenize(&self) -> <addLiquidityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensCall {
+        impl alloy_sol_types::SolCall for addLiquidityCall {
             type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
                 alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = addLiquidityReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 237u8, 23u8, 57u8];
+            const SELECTOR: [u8; 4] = [232u8, 227u8, 55u8, 0u8];
             const SIGNATURE: &'static str =
-                "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+                "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5337,39 +646,42 @@ pub mod UniswapV2Router02 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenA,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.tokenB,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountADesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBDesired,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountAMin,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountBMin,
+                    ),
                     <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
                         &self.to,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.deadline,
+                    ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                addLiquidityReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: swapExactTokensForTokensReturn = r.into();
-                        r.amounts
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -5377,40 +689,27 @@ pub mod UniswapV2Router02 {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: swapExactTokensForTokensReturn = r.into();
-                    r.amounts
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],address,uint256)` and selector `0x5c11d795`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] memory path, address to, uint256 deadline) external;
+    function factory() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-        #[allow(missing_docs)]
-        pub amountIn: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct factoryCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,
-    /// address[],address,
-    /// uint256)`](swapExactTokensForTokensSupportingFeeOnTransferTokensCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {}
+    pub struct factoryReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -5422,21 +721,9 @@ pub mod UniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5448,41 +735,25 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensCall>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(value: swapExactTokensForTokensSupportingFeeOnTransferTokensCall) -> Self {
-                    (
-                        value.amountIn,
-                        value.amountOutMin,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensCall
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amountIn: tuple.0,
-                        amountOutMin: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5494,52 +765,29 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapExactTokensForTokensSupportingFeeOnTransferTokensReturn>
-                for UnderlyingRustTuple<'_>
-            {
-                fn from(
-                    value: swapExactTokensForTokensSupportingFeeOnTransferTokensReturn,
-                ) -> Self {
-                    ()
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>>
-                for swapExactTokensForTokensSupportingFeeOnTransferTokensReturn
-            {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl swapExactTokensForTokensSupportingFeeOnTransferTokensReturn {
-            fn _tokenize(
-                &self,
-            ) -> <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::ReturnToken<
-                '_,
-            >{
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Return = swapExactTokensForTokensSupportingFeeOnTransferTokensReturn;
+        impl alloy_sol_types::SolCall for factoryCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [92u8, 17u8, 215u8, 149u8];
-            const SIGNATURE: &'static str =
-                "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,address[],\
-                 address,uint256)";
+            const SELECTOR: [u8; 4] = [196u8, 90u8, 1u8, 85u8];
+            const SIGNATURE: &'static str = "factory()";
 
             #[inline]
             fn new<'a>(
@@ -5550,34 +798,22 @@ pub mod UniswapV2Router02 {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountIn),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOutMin),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapExactTokensForTokensSupportingFeeOnTransferTokensReturn::_tokenize(ret)
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: factoryReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -5585,39 +821,36 @@ pub mod UniswapV2Router02 {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: factoryReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swapTokensForExactETH(uint256,uint256,address[],address,uint256)` and selector `0x4a25d94a`.
+    /**Function with signature `quote(uint256,uint256,uint256)` and selector `0xad615dec`.
     ```solidity
-    function swapTokensForExactETH(uint256 amountOut, uint256 amountInMax, address[] memory path, address to, uint256 deadline) external returns (uint256[] memory amounts);
+    function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) external pure returns (uint256 amountB);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHCall {
-        #[allow(missing_docs)]
-        pub amountOut: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amountInMax: alloy_sol_types::private::primitives::aliases::U256,
+    pub struct quoteCall {
         #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
+        pub amountA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub to: alloy_sol_types::private::Address,
+        pub reserveA: alloy_sol_types::private::primitives::aliases::U256,
         #[allow(missing_docs)]
-        pub deadline: alloy_sol_types::private::primitives::aliases::U256,
+        pub reserveB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swapTokensForExactETH(uint256,uint256,address[],address,
-    /// uint256)`](swapTokensForExactETHCall) function.
+    /// [`quote(uint256,uint256,uint256)`](quoteCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapTokensForExactETHReturn {
+    pub struct quoteReturn {
         #[allow(missing_docs)]
-        pub amounts:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
+        pub amountB: alloy_sol_types::private::primitives::aliases::U256,
     }
     #[allow(
         non_camel_case_types,
@@ -5633,16 +866,12 @@ pub mod UniswapV2Router02 {
             type UnderlyingSolTuple<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
                 alloy_sol_types::private::primitives::aliases::U256,
                 alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-                alloy_sol_types::private::Address,
                 alloy_sol_types::private::primitives::aliases::U256,
             );
             #[cfg(test)]
@@ -5656,27 +885,19 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHCall) -> Self {
-                    (
-                        value.amountOut,
-                        value.amountInMax,
-                        value.path,
-                        value.to,
-                        value.deadline,
-                    )
+            impl ::core::convert::From<quoteCall> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteCall) -> Self {
+                    (value.amountA, value.reserveA, value.reserveB)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amountOut: tuple.0,
-                        amountInMax: tuple.1,
-                        path: tuple.2,
-                        to: tuple.3,
-                        deadline: tuple.4,
+                        amountA: tuple.0,
+                        reserveA: tuple.1,
+                        reserveB: tuple.2,
                     }
                 }
             }
@@ -5684,12 +905,9 @@ pub mod UniswapV2Router02 {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5701,38 +919,33 @@ pub mod UniswapV2Router02 {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapTokensForExactETHReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapTokensForExactETHReturn) -> Self {
-                    (value.amounts,)
+            impl ::core::convert::From<quoteReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: quoteReturn) -> Self {
+                    (value.amountB,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapTokensForExactETHReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for quoteReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { amounts: tuple.0 }
+                    Self { amountB: tuple.0 }
                 }
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapTokensForExactETHCall {
+        impl alloy_sol_types::SolCall for quoteCall {
             type Parameters<'a> = (
                 alloy_sol_types::sol_data::Uint<256>,
                 alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Address>,
-                alloy_sol_types::sol_data::Address,
                 alloy_sol_types::sol_data::Uint<256>,
             );
-            type Return =
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U256>;
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<256>>,);
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [74u8, 37u8, 217u8, 74u8];
-            const SIGNATURE: &'static str =
-                "swapTokensForExactETH(uint256,uint256,address[],address,uint256)";
+            const SELECTOR: [u8; 4] = [173u8, 97u8, 93u8, 236u8];
+            const SIGNATURE: &'static str = "quote(uint256,uint256,uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5744,37 +957,33 @@ pub mod UniswapV2Router02 {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountOut),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.amountInMax),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Address,
-                    > as alloy_sol_types::SolType>::tokenize(&self.path),
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.to,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveA,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.reserveB,
                     ),
-                    <alloy_sol_types::sol_data::Uint<
-                        256,
-                    > as alloy_sol_types::SolType>::tokenize(&self.deadline),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<256>,
-                > as alloy_sol_types::SolType>::tokenize(ret),)
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
                     |r| {
-                        let r: swapTokensForExactETHReturn = r.into();
-                        r.amounts
+                        let r: quoteReturn = r.into();
+                        r.amountB
                     },
                 )
             }
@@ -5785,8 +994,8 @@ pub mod UniswapV2Router02 {
                     data,
                 )
                 .map(|r| {
-                    let r: swapTokensForExactETHReturn = r.into();
-                    r.amounts
+                    let r: quoteReturn = r.into();
+                    r.amountB
                 })
             }
         }
@@ -6001,58 +1210,10 @@ pub mod UniswapV2Router02 {
         #[allow(missing_docs)]
         addLiquidity(addLiquidityCall),
         #[allow(missing_docs)]
-        addLiquidityETH(addLiquidityETHCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
-        getAmountIn(getAmountInCall),
-        #[allow(missing_docs)]
-        getAmountOut(getAmountOutCall),
-        #[allow(missing_docs)]
-        getAmountsIn(getAmountsInCall),
-        #[allow(missing_docs)]
-        getAmountsOut(getAmountsOutCall),
-        #[allow(missing_docs)]
         quote(quoteCall),
         #[allow(missing_docs)]
-        removeLiquidity(removeLiquidityCall),
-        #[allow(missing_docs)]
-        removeLiquidityETH(removeLiquidityETHCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHSupportingFeeOnTransferTokens(
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermit(removeLiquidityETHWithPermitCall),
-        #[allow(missing_docs)]
-        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        removeLiquidityWithPermit(removeLiquidityWithPermitCall),
-        #[allow(missing_docs)]
-        swapETHForExactTokens(swapETHForExactTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokens(swapExactETHForTokensCall),
-        #[allow(missing_docs)]
-        swapExactETHForTokensSupportingFeeOnTransferTokens(
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForETH(swapExactTokensForETHCall),
-        #[allow(missing_docs)]
-        swapExactTokensForETHSupportingFeeOnTransferTokens(
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapExactTokensForTokens(swapExactTokensForTokensCall),
-        #[allow(missing_docs)]
-        swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-        ),
-        #[allow(missing_docs)]
-        swapTokensForExactETH(swapTokensForExactETHCall),
-        #[allow(missing_docs)]
         swapTokensForExactTokens(swapTokensForExactTokensCall),
     }
     impl UniswapV2Router02Calls {
@@ -6064,84 +1225,27 @@ pub mod UniswapV2Router02 {
         ///
         /// Prefer using `SolInterface` methods instead.
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
-            [2u8, 117u8, 28u8, 236u8],
-            [5u8, 77u8, 80u8, 212u8],
-            [24u8, 203u8, 175u8, 229u8],
-            [31u8, 0u8, 202u8, 116u8],
-            [33u8, 149u8, 153u8, 92u8],
-            [56u8, 237u8, 23u8, 57u8],
-            [74u8, 37u8, 217u8, 74u8],
-            [91u8, 13u8, 89u8, 132u8],
-            [92u8, 17u8, 215u8, 149u8],
-            [121u8, 26u8, 201u8, 71u8],
-            [127u8, 243u8, 106u8, 181u8],
-            [133u8, 248u8, 194u8, 89u8],
             [136u8, 3u8, 219u8, 238u8],
             [173u8, 92u8, 70u8, 72u8],
             [173u8, 97u8, 93u8, 236u8],
-            [175u8, 41u8, 121u8, 235u8],
-            [182u8, 249u8, 222u8, 149u8],
-            [186u8, 162u8, 171u8, 222u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 108u8, 166u8, 31u8],
-            [222u8, 217u8, 56u8, 42u8],
             [232u8, 227u8, 55u8, 0u8],
-            [243u8, 5u8, 215u8, 25u8],
-            [251u8, 59u8, 219u8, 65u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
-            <removeLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsInCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountInCall as alloy_sol_types::SolCall>::SIGNATURE,
             <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
             <WETHCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <getAmountsOutCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SIGNATURE,
             <addLiquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <addLiquidityETHCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
-            ::core::stringify!(removeLiquidityETH),
-            ::core::stringify!(getAmountOut),
-            ::core::stringify!(swapExactTokensForETH),
-            ::core::stringify!(getAmountsIn),
-            ::core::stringify!(removeLiquidityWithPermit),
-            ::core::stringify!(swapExactTokensForTokens),
-            ::core::stringify!(swapTokensForExactETH),
-            ::core::stringify!(removeLiquidityETHWithPermitSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactTokensForETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokens),
-            ::core::stringify!(getAmountIn),
             ::core::stringify!(swapTokensForExactTokens),
             ::core::stringify!(WETH),
             ::core::stringify!(quote),
-            ::core::stringify!(removeLiquidityETHSupportingFeeOnTransferTokens),
-            ::core::stringify!(swapExactETHForTokensSupportingFeeOnTransferTokens),
-            ::core::stringify!(removeLiquidity),
             ::core::stringify!(factory),
-            ::core::stringify!(getAmountsOut),
-            ::core::stringify!(removeLiquidityETHWithPermit),
             ::core::stringify!(addLiquidity),
-            ::core::stringify!(addLiquidityETH),
-            ::core::stringify!(swapETHForExactTokens),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -6166,7 +1270,7 @@ pub mod UniswapV2Router02 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for UniswapV2Router02Calls {
-        const COUNT: usize = 24usize;
+        const COUNT: usize = 5usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "UniswapV2Router02Calls";
 
@@ -6174,68 +1278,9 @@ pub mod UniswapV2Router02 {
         fn selector(&self) -> [u8; 4] {
             match self {
                 Self::WETH(_) => <WETHCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::addLiquidity(_) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::addLiquidityETH(_) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
+                Self::addLiquidity(_) => <addLiquidityCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::getAmountIn(_) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountOut(_) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsIn(_) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::getAmountsOut(_) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::quote(_) => <quoteCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::removeLiquidity(_) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETH(_) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermit(_) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(_) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::removeLiquidityWithPermit(_) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapETHForExactTokens(_) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokens(_) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETH(_) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokens(_) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(_) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::swapTokensForExactETH(_) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::swapTokensForExactTokens(_) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::SELECTOR
                 }
@@ -6246,161 +1291,17 @@ pub mod UniswapV2Router02 {
         fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
             Self::SELECTORS.get(i).copied()
         }
-
-        #[inline]
-        fn valid_selector(selector: [u8; 4]) -> bool {
-            Self::SELECTORS.binary_search(&selector).is_ok()
-        }
-
-        #[inline]
-        #[allow(non_snake_case)]
-        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
-            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls>] =
-                &[
-                    {
-                        fn removeLiquidityETH(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::removeLiquidityETH)
-                        }
-                        removeLiquidityETH
-                    },
-                    {
-                        fn getAmountOut(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(UniswapV2Router02Calls::getAmountOut)
-                        }
-                        getAmountOut
-                    },
-                    {
-                        fn swapExactTokensForETH(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapExactTokensForETH)
-                        }
-                        swapExactTokensForETH
-                    },
-                    {
-                        fn getAmountsIn(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(UniswapV2Router02Calls::getAmountsIn)
-                        }
-                        getAmountsIn
-                    },
-                    {
-                        fn removeLiquidityWithPermit(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::removeLiquidityWithPermit)
-                        }
-                        removeLiquidityWithPermit
-                    },
-                    {
-                        fn swapExactTokensForTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapExactTokensForTokens)
-                        }
-                        swapExactTokensForTokens
-                    },
-                    {
-                        fn swapTokensForExactETH(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapTokensForExactETH)
-                        }
-                        swapTokensForExactETH
-                    },
-                    {
-                        fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                        }
-                        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                    },
-                    {
-                        fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                        }
-                        swapExactTokensForTokensSupportingFeeOnTransferTokens
-                    },
-                    {
-                        fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                        }
-                        swapExactTokensForETHSupportingFeeOnTransferTokens
-                    },
-                    {
-                        fn swapExactETHForTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapExactETHForTokens)
-                        }
-                        swapExactETHForTokens
-                    },
-                    {
-                        fn getAmountIn(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(UniswapV2Router02Calls::getAmountIn)
-                        }
-                        getAmountIn
-                    },
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls>] =
+                &[
                     {
                         fn swapTokensForExactTokens(
                             data: &[u8],
@@ -6427,44 +1328,6 @@ pub mod UniswapV2Router02 {
                         }
                         quote
                     },
-                    {
-                        fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                        }
-                        removeLiquidityETHSupportingFeeOnTransferTokens
-                    },
-                    {
-                        fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                        }
-                        swapExactETHForTokensSupportingFeeOnTransferTokens
-                    },
-                    {
-                        fn removeLiquidity(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(UniswapV2Router02Calls::removeLiquidity)
-                        }
-                        removeLiquidity
-                    },
                     {
                         fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
                             <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6472,28 +1335,6 @@ pub mod UniswapV2Router02 {
                         }
                         factory
                     },
-                    {
-                        fn getAmountsOut(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(UniswapV2Router02Calls::getAmountsOut)
-                        }
-                        getAmountsOut
-                    },
-                    {
-                        fn removeLiquidityETHWithPermit(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::removeLiquidityETHWithPermit)
-                        }
-                        removeLiquidityETHWithPermit
-                    },
                     {
                         fn addLiquidity(
                             data: &[u8],
@@ -6504,28 +1345,6 @@ pub mod UniswapV2Router02 {
                         }
                         addLiquidity
                     },
-                    {
-                        fn addLiquidityETH(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                                .map(UniswapV2Router02Calls::addLiquidityETH)
-                        }
-                        addLiquidityETH
-                    },
-                    {
-                        fn swapETHForExactTokens(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV2Router02Calls>
-                        {
-                            <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapETHForExactTokens)
-                        }
-                        swapETHForExactTokens
-                    },
                 ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6547,140 +1366,6 @@ pub mod UniswapV2Router02 {
             ) -> alloy_sol_types::Result<
                 UniswapV2Router02Calls,
             >] = &[
-                {
-                    fn removeLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::removeLiquidityETH)
-                    }
-                    removeLiquidityETH
-                },
-                {
-                    fn getAmountOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <getAmountOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2Router02Calls::getAmountOut)
-                    }
-                    getAmountOut
-                },
-                {
-                    fn swapExactTokensForETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapExactTokensForETH)
-                    }
-                    swapExactTokensForETH
-                },
-                {
-                    fn getAmountsIn(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <getAmountsInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2Router02Calls::getAmountsIn)
-                    }
-                    getAmountsIn
-                },
-                {
-                    fn removeLiquidityWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::removeLiquidityWithPermit)
-                    }
-                    removeLiquidityWithPermit
-                },
-                {
-                    fn swapExactTokensForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapExactTokensForTokens)
-                    }
-                    swapExactTokensForTokens
-                },
-                {
-                    fn swapTokensForExactETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapTokensForExactETH)
-                    }
-                    swapTokensForExactETH
-                },
-                {
-                    fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::swapExactTokensForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::swapExactTokensForETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactTokensForETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapExactETHForTokens)
-                    }
-                    swapExactETHForTokens
-                },
-                {
-                    fn getAmountIn(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <getAmountInCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV2Router02Calls::getAmountIn)
-                    }
-                    getAmountIn
-                },
                 {
                     fn swapTokensForExactTokens(
                         data: &[u8],
@@ -6706,43 +1391,6 @@ pub mod UniswapV2Router02 {
                     }
                     quote
                 },
-                {
-                    fn removeLiquidityETHSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::removeLiquidityETHSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    removeLiquidityETHSupportingFeeOnTransferTokens
-                },
-                {
-                    fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(
-                                UniswapV2Router02Calls::swapExactETHForTokensSupportingFeeOnTransferTokens,
-                            )
-                    }
-                    swapExactETHForTokensSupportingFeeOnTransferTokens
-                },
-                {
-                    fn removeLiquidity(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <removeLiquidityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2Router02Calls::removeLiquidity)
-                    }
-                    removeLiquidity
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -6750,28 +1398,6 @@ pub mod UniswapV2Router02 {
                     }
                     factory
                 },
-                {
-                    fn getAmountsOut(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <getAmountsOutCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2Router02Calls::getAmountsOut)
-                    }
-                    getAmountsOut
-                },
-                {
-                    fn removeLiquidityETHWithPermit(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::removeLiquidityETHWithPermit)
-                    }
-                    removeLiquidityETHWithPermit
-                },
                 {
                     fn addLiquidity(
                         data: &[u8],
@@ -6783,28 +1409,6 @@ pub mod UniswapV2Router02 {
                     }
                     addLiquidity
                 },
-                {
-                    fn addLiquidityETH(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV2Router02Calls::addLiquidityETH)
-                    }
-                    addLiquidityETH
-                },
-                {
-                    fn swapETHForExactTokens(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV2Router02Calls> {
-                        <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV2Router02Calls::swapETHForExactTokens)
-                    }
-                    swapETHForExactTokens
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -6819,115 +1423,16 @@ pub mod UniswapV2Router02 {
         fn abi_encoded_size(&self) -> usize {
             match self {
                 Self::WETH(inner) => {
-                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::factory(inner) => {
-                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::quote(inner) => {
-                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <WETHCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::addLiquidity(inner) => {
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::factory(inner) => {
+                    <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                Self::quote(inner) => {
+                    <quoteCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encoded_size(
@@ -6944,137 +1449,17 @@ pub mod UniswapV2Router02 {
                     <WETHCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::addLiquidity(inner) => {
-                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::addLiquidityETH(inner) => {
-                    <addLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <addLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::getAmountIn(inner) => {
-                    <getAmountInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountOut(inner) => {
-                    <getAmountOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsIn(inner) => {
-                    <getAmountsInCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::getAmountsOut(inner) => {
-                    <getAmountsOutCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::quote(inner) => {
                     <quoteCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::removeLiquidity(inner) => {
-                    <removeLiquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETH(inner) => {
-                    <removeLiquidityETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHSupportingFeeOnTransferTokens(inner) => {
-                    <removeLiquidityETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermit(inner) => {
-                    <removeLiquidityETHWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-                    inner,
-                ) => {
-                    <removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::removeLiquidityWithPermit(inner) => {
-                    <removeLiquidityWithPermitCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapETHForExactTokens(inner) => {
-                    <swapETHForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokens(inner) => {
-                    <swapExactETHForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactETHForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactETHForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETH(inner) => {
-                    <swapExactTokensForETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForETHSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForETHSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokens(inner) => {
-                    <swapExactTokensForTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapExactTokensForTokensSupportingFeeOnTransferTokens(inner) => {
-                    <swapExactTokensForTokensSupportingFeeOnTransferTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::swapTokensForExactETH(inner) => {
-                    <swapTokensForExactETHCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::swapTokensForExactTokens(inner) => {
                     <swapTokensForExactTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
+                        inner, out,
                     )
                 }
             }
@@ -7289,77 +1674,11 @@ pub mod UniswapV2Router02 {
             })
         }
 
-        ///Creates a new call builder for the [`addLiquidityETH`] function.
-        pub fn addLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            amountTokenDesired: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, addLiquidityETHCall, N> {
-            self.call_builder(&addLiquidityETHCall {
-                token,
-                amountTokenDesired,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
         }
 
-        ///Creates a new call builder for the [`getAmountIn`] function.
-        pub fn getAmountIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountInCall, N> {
-            self.call_builder(&getAmountInCall {
-                amountOut,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountOut`] function.
-        pub fn getAmountOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveIn: alloy_sol_types::private::primitives::aliases::U256,
-            reserveOut: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountOutCall, N> {
-            self.call_builder(&getAmountOutCall {
-                amountIn,
-                reserveIn,
-                reserveOut,
-            })
-        }
-
-        ///Creates a new call builder for the [`getAmountsIn`] function.
-        pub fn getAmountsIn(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsInCall, N> {
-            self.call_builder(&getAmountsInCall { amountOut, path })
-        }
-
-        ///Creates a new call builder for the [`getAmountsOut`] function.
-        pub fn getAmountsOut(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-        ) -> alloy_contract::SolCallBuilder<&P, getAmountsOutCall, N> {
-            self.call_builder(&getAmountsOutCall { amountIn, path })
-        }
-
         ///Creates a new call builder for the [`quote`] function.
         pub fn quote(
             &self,
@@ -7374,327 +1693,6 @@ pub mod UniswapV2Router02 {
             })
         }
 
-        ///Creates a new call builder for the [`removeLiquidity`] function.
-        pub fn removeLiquidity(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityCall, N> {
-            self.call_builder(&removeLiquidityCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETH`] function.
-        pub fn removeLiquidityETH(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHCall, N> {
-            self.call_builder(&removeLiquidityETHCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHSupportingFeeOnTransferTokens`] function.
-        pub fn removeLiquidityETHSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&removeLiquidityETHSupportingFeeOnTransferTokensCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityETHWithPermit`]
-        /// function.
-        pub fn removeLiquidityETHWithPermit(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityETHWithPermitCall, N> {
-            self.call_builder(&removeLiquidityETHWithPermitCall {
-                token,
-                liquidity,
-                amountTokenMin,
-                amountETHMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`removeLiquidityETHWithPermitSupportingFeeOnTransferTokens`]
-        /// function.
-        pub fn removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
-            &self,
-            token: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountTokenMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountETHMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(
-                &removeLiquidityETHWithPermitSupportingFeeOnTransferTokensCall {
-                    token,
-                    liquidity,
-                    amountTokenMin,
-                    amountETHMin,
-                    to,
-                    deadline,
-                    approveMax,
-                    v,
-                    r,
-                    s,
-                },
-            )
-        }
-
-        ///Creates a new call builder for the [`removeLiquidityWithPermit`]
-        /// function.
-        pub fn removeLiquidityWithPermit(
-            &self,
-            tokenA: alloy_sol_types::private::Address,
-            tokenB: alloy_sol_types::private::Address,
-            liquidity: alloy_sol_types::private::primitives::aliases::U256,
-            amountAMin: alloy_sol_types::private::primitives::aliases::U256,
-            amountBMin: alloy_sol_types::private::primitives::aliases::U256,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-            approveMax: bool,
-            v: u8,
-            r: alloy_sol_types::private::FixedBytes<32>,
-            s: alloy_sol_types::private::FixedBytes<32>,
-        ) -> alloy_contract::SolCallBuilder<&P, removeLiquidityWithPermitCall, N> {
-            self.call_builder(&removeLiquidityWithPermitCall {
-                tokenA,
-                tokenB,
-                liquidity,
-                amountAMin,
-                amountBMin,
-                to,
-                deadline,
-                approveMax,
-                v,
-                r,
-                s,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapETHForExactTokens`]
-        /// function.
-        pub fn swapETHForExactTokens(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapETHForExactTokensCall, N> {
-            self.call_builder(&swapETHForExactTokensCall {
-                amountOut,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactETHForTokens`]
-        /// function.
-        pub fn swapExactETHForTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactETHForTokensCall, N> {
-            self.call_builder(&swapExactETHForTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactETHForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactETHForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactETHForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactETHForTokensSupportingFeeOnTransferTokensCall {
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForETH`]
-        /// function.
-        pub fn swapExactTokensForETH(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForETHCall, N> {
-            self.call_builder(&swapExactTokensForETHCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForETHSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForETHSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForETHSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForETHSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapExactTokensForTokens`]
-        /// function.
-        pub fn swapExactTokensForTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapExactTokensForTokensCall, N> {
-            self.call_builder(&swapExactTokensForTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the
-        /// [`swapExactTokensForTokensSupportingFeeOnTransferTokens`] function.
-        pub fn swapExactTokensForTokensSupportingFeeOnTransferTokens(
-            &self,
-            amountIn: alloy_sol_types::private::primitives::aliases::U256,
-            amountOutMin: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<
-            &P,
-            swapExactTokensForTokensSupportingFeeOnTransferTokensCall,
-            N,
-        > {
-            self.call_builder(&swapExactTokensForTokensSupportingFeeOnTransferTokensCall {
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline,
-            })
-        }
-
-        ///Creates a new call builder for the [`swapTokensForExactETH`]
-        /// function.
-        pub fn swapTokensForExactETH(
-            &self,
-            amountOut: alloy_sol_types::private::primitives::aliases::U256,
-            amountInMax: alloy_sol_types::private::primitives::aliases::U256,
-            path: alloy_sol_types::private::Vec<alloy_sol_types::private::Address>,
-            to: alloy_sol_types::private::Address,
-            deadline: alloy_sol_types::private::primitives::aliases::U256,
-        ) -> alloy_contract::SolCallBuilder<&P, swapTokensForExactETHCall, N> {
-            self.call_builder(&swapTokensForExactETHCall {
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline,
-            })
-        }
-
         ///Creates a new call builder for the [`swapTokensForExactTokens`]
         /// function.
         pub fn swapTokensForExactTokens(
diff --git a/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs
index 1a2b108692..bb14908ba7 100644
--- a/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv3pool/src/lib.rs
@@ -25,27 +25,17 @@ interface UniswapV3Pool {
 
     function burn(int24 tickLower, int24 tickUpper, uint128 amount) external returns (uint256 amount0, uint256 amount1);
     function collect(address recipient, int24 tickLower, int24 tickUpper, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
-    function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
     function factory() external view returns (address);
     function fee() external view returns (uint24);
-    function feeGrowthGlobal0X128() external view returns (uint256);
-    function feeGrowthGlobal1X128() external view returns (uint256);
     function flash(address recipient, uint256 amount0, uint256 amount1, bytes memory data) external;
-    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
     function initialize(uint160 sqrtPriceX96) external;
     function liquidity() external view returns (uint128);
-    function maxLiquidityPerTick() external view returns (uint128);
     function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes memory data) external returns (uint256 amount0, uint256 amount1);
     function observations(uint256) external view returns (uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized);
     function observe(uint32[] memory secondsAgos) external view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
     function positions(bytes32) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1);
     function protocolFees() external view returns (uint128 token0, uint128 token1);
-    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
-    function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked);
-    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) external view returns (int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside);
     function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes memory data) external returns (int256 amount0, int256 amount1);
-    function tickBitmap(int16) external view returns (uint256);
-    function tickSpacing() external view returns (int24);
     function ticks(int24) external view returns (uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized);
     function token0() external view returns (address);
     function token1() external view returns (address);
@@ -138,40 +128,6 @@ interface UniswapV3Pool {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "collectProtocol",
-    "inputs": [
-      {
-        "name": "recipient",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "amount0Requested",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "amount1Requested",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "amount0",
-        "type": "uint128",
-        "internalType": "uint128"
-      },
-      {
-        "name": "amount1",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "factory",
@@ -198,32 +154,6 @@ interface UniswapV3Pool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "feeGrowthGlobal0X128",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "feeGrowthGlobal1X128",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "flash",
@@ -252,19 +182,6 @@ interface UniswapV3Pool {
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "increaseObservationCardinalityNext",
-    "inputs": [
-      {
-        "name": "observationCardinalityNext",
-        "type": "uint16",
-        "internalType": "uint16"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
   {
     "type": "function",
     "name": "initialize",
@@ -291,19 +208,6 @@ interface UniswapV3Pool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "maxLiquidityPerTick",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint128",
-        "internalType": "uint128"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "mint",
@@ -463,101 +367,6 @@ interface UniswapV3Pool {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "setFeeProtocol",
-    "inputs": [
-      {
-        "name": "feeProtocol0",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "feeProtocol1",
-        "type": "uint8",
-        "internalType": "uint8"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "slot0",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "sqrtPriceX96",
-        "type": "uint160",
-        "internalType": "uint160"
-      },
-      {
-        "name": "tick",
-        "type": "int24",
-        "internalType": "int24"
-      },
-      {
-        "name": "observationIndex",
-        "type": "uint16",
-        "internalType": "uint16"
-      },
-      {
-        "name": "observationCardinality",
-        "type": "uint16",
-        "internalType": "uint16"
-      },
-      {
-        "name": "observationCardinalityNext",
-        "type": "uint16",
-        "internalType": "uint16"
-      },
-      {
-        "name": "feeProtocol",
-        "type": "uint8",
-        "internalType": "uint8"
-      },
-      {
-        "name": "unlocked",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "snapshotCumulativesInside",
-    "inputs": [
-      {
-        "name": "tickLower",
-        "type": "int24",
-        "internalType": "int24"
-      },
-      {
-        "name": "tickUpper",
-        "type": "int24",
-        "internalType": "int24"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "tickCumulativeInside",
-        "type": "int56",
-        "internalType": "int56"
-      },
-      {
-        "name": "secondsPerLiquidityInsideX128",
-        "type": "uint160",
-        "internalType": "uint160"
-      },
-      {
-        "name": "secondsInside",
-        "type": "uint32",
-        "internalType": "uint32"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "swap",
@@ -602,38 +411,6 @@ interface UniswapV3Pool {
     ],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "tickBitmap",
-    "inputs": [
-      {
-        "name": "",
-        "type": "int16",
-        "internalType": "int16"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "tickSpacing",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "int24",
-        "internalType": "int24"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "ticks",
@@ -2784,31 +2561,21 @@ pub mod UniswapV3Pool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `collectProtocol(address,uint128,uint128)` and selector `0x85b66729`.
+    /**Function with signature `factory()` and selector `0xc45a0155`.
     ```solidity
-    function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) external returns (uint128 amount0, uint128 amount1);
+    function factory() external view returns (address);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct collectProtocolCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount0Requested: u128,
-        #[allow(missing_docs)]
-        pub amount1Requested: u128,
-    }
+    pub struct factoryCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`collectProtocol(address,uint128,uint128)`](collectProtocolCall)
-    /// function.
+    /// [`factory()`](factoryCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct collectProtocolReturn {
-        #[allow(missing_docs)]
-        pub amount0: u128,
+    pub struct factoryReturn {
         #[allow(missing_docs)]
-        pub amount1: u128,
+        pub _0: alloy_sol_types::private::Address,
     }
     #[allow(
         non_camel_case_types,
@@ -2821,13 +2588,9 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address, u128, u128);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2839,36 +2602,25 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<collectProtocolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: collectProtocolCall) -> Self {
-                    (
-                        value.recipient,
-                        value.amount0Requested,
-                        value.amount1Requested,
-                    )
+            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for collectProtocolCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        amount0Requested: tuple.1,
-                        amount1Requested: tuple.2,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -2880,178 +2632,16 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<collectProtocolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: collectProtocolReturn) -> Self {
-                    (value.amount0, value.amount1)
+            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: factoryReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for collectProtocolReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount0: tuple.0,
-                        amount1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl collectProtocolReturn {
-            fn _tokenize(
-                &self,
-            ) -> <collectProtocolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for collectProtocolCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Return = collectProtocolReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [133u8, 182u8, 103u8, 41u8];
-            const SIGNATURE: &'static str = "collectProtocol(address,uint128,uint128)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0Requested,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1Requested,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                collectProtocolReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `factory()` and selector `0xc45a0155`.
-    ```solidity
-    function factory() external view returns (address);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`factory()`](factoryCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct factoryReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::Address,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryCall> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<factoryReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: factoryReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for factoryReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self { _0: tuple.0 }
                 }
             }
         }
@@ -3245,22 +2835,27 @@ pub mod UniswapV3Pool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `feeGrowthGlobal0X128()` and selector `0xf3058399`.
+    /**Function with signature `flash(address,uint256,uint256,bytes)` and selector `0x490e6cbc`.
     ```solidity
-    function feeGrowthGlobal0X128() external view returns (uint256);
+    function flash(address recipient, uint256 amount0, uint256 amount1, bytes memory data) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct feeGrowthGlobal0X128Call;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    pub struct flashCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
     ///Container type for the return parameters of the
-    /// [`feeGrowthGlobal0X128()`](feeGrowthGlobal0X128Call) function.
+    /// [`flash(address,uint256,uint256,bytes)`](flashCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct feeGrowthGlobal0X128Return {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct flashReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3272,9 +2867,19 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3286,25 +2891,30 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<feeGrowthGlobal0X128Call> for UnderlyingRustTuple<'_> {
-                fn from(value: feeGrowthGlobal0X128Call) -> Self {
-                    ()
+            impl ::core::convert::From<flashCall> for UnderlyingRustTuple<'_> {
+                fn from(value: flashCall) -> Self {
+                    (value.recipient, value.amount0, value.amount1, value.data)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal0X128Call {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        recipient: tuple.0,
+                        amount0: tuple.1,
+                        amount1: tuple.2,
+                        data: tuple.3,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3316,29 +2926,39 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<feeGrowthGlobal0X128Return> for UnderlyingRustTuple<'_> {
-                fn from(value: feeGrowthGlobal0X128Return) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<flashReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: flashReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal0X128Return {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl flashReturn {
+            fn _tokenize(&self) -> <flashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for feeGrowthGlobal0X128Call {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for flashCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = flashReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [243u8, 5u8, 131u8, 153u8];
-            const SIGNATURE: &'static str = "feeGrowthGlobal0X128()";
+            const SELECTOR: [u8; 4] = [73u8, 14u8, 108u8, 188u8];
+            const SIGNATURE: &'static str = "flash(address,uint256,uint256,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -3349,26 +2969,31 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
                 (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
                     <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
                     ),
                 )
             }
 
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                flashReturn::_tokenize(ret)
+            }
+
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: feeGrowthGlobal0X128Return = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -3376,30 +3001,26 @@ pub mod UniswapV3Pool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: feeGrowthGlobal0X128Return = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `feeGrowthGlobal1X128()` and selector `0x46141319`.
+    /**Function with signature `initialize(uint160)` and selector `0xf637731d`.
     ```solidity
-    function feeGrowthGlobal1X128() external view returns (uint256);
+    function initialize(uint160 sqrtPriceX96) external;
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct feeGrowthGlobal1X128Call;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    pub struct initializeCall {
+        #[allow(missing_docs)]
+        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
+    }
     ///Container type for the return parameters of the
-    /// [`feeGrowthGlobal1X128()`](feeGrowthGlobal1X128Call) function.
+    /// [`initialize(uint160)`](initializeCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct feeGrowthGlobal1X128Return {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
+    pub struct initializeReturn {}
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3411,9 +3032,9 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<160>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U160,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3425,25 +3046,27 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<feeGrowthGlobal1X128Call> for UnderlyingRustTuple<'_> {
-                fn from(value: feeGrowthGlobal1X128Call) -> Self {
-                    ()
+            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeCall) -> Self {
+                    (value.sqrtPriceX96,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal1X128Call {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        sqrtPriceX96: tuple.0,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3455,29 +3078,34 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<feeGrowthGlobal1X128Return> for UnderlyingRustTuple<'_> {
-                fn from(value: feeGrowthGlobal1X128Return) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: initializeReturn) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for feeGrowthGlobal1X128Return {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {}
                 }
             }
         }
+        impl initializeReturn {
+            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for feeGrowthGlobal1X128Call {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for initializeCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<160>,);
+            type Return = initializeReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = ();
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [70u8, 20u8, 19u8, 25u8];
-            const SIGNATURE: &'static str = "feeGrowthGlobal1X128()";
+            const SELECTOR: [u8; 4] = [246u8, 55u8, 115u8, 29u8];
+            const SIGNATURE: &'static str = "initialize(uint160)";
 
             #[inline]
             fn new<'a>(
@@ -3488,26 +3116,22 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceX96,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                initializeReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: feeGrowthGlobal1X128Return = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -3515,35 +3139,27 @@ pub mod UniswapV3Pool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: feeGrowthGlobal1X128Return = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `flash(address,uint256,uint256,bytes)` and selector `0x490e6cbc`.
+    /**Function with signature `liquidity()` and selector `0x1a686502`.
     ```solidity
-    function flash(address recipient, uint256 amount0, uint256 amount1, bytes memory data) external;
+    function liquidity() external view returns (uint128);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct flashCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
+    pub struct liquidityCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`flash(address,uint256,uint256,bytes)`](flashCall) function.
+    /// [`liquidity()`](liquidityCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct flashReturn {}
+    pub struct liquidityReturn {
+        #[allow(missing_docs)]
+        pub _0: u128,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3555,19 +3171,9 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::Bytes,
-            );
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3579,30 +3185,25 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<flashCall> for UnderlyingRustTuple<'_> {
-                fn from(value: flashCall) -> Self {
-                    (value.recipient, value.amount0, value.amount1, value.data)
+            impl ::core::convert::From<liquidityCall> for UnderlyingRustTuple<'_> {
+                fn from(value: liquidityCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for liquidityCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        amount0: tuple.1,
-                        amount1: tuple.2,
-                        data: tuple.3,
-                    }
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (u128,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3614,39 +3215,29 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<flashReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: flashReturn) -> Self {
-                    ()
+            impl ::core::convert::From<liquidityReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: liquidityReturn) -> Self {
+                    (value._0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for flashReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for liquidityReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self { _0: tuple.0 }
                 }
             }
         }
-        impl flashReturn {
-            fn _tokenize(&self) -> <flashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for flashCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = flashReturn;
+        impl alloy_sol_types::SolCall for liquidityCall {
+            type Parameters<'a> = ();
+            type Return = u128;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [73u8, 14u8, 108u8, 188u8];
-            const SIGNATURE: &'static str = "flash(address,uint256,uint256,bytes)";
+            const SELECTOR: [u8; 4] = [26u8, 104u8, 101u8, 2u8];
+            const SIGNATURE: &'static str = "liquidity()";
 
             #[inline]
             fn new<'a>(
@@ -3657,31 +3248,26 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                flashReturn::_tokenize(ret)
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: liquidityReturn = r.into();
+                        r._0
+                    },
+                )
             }
 
             #[inline]
@@ -3689,27 +3275,43 @@ pub mod UniswapV3Pool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(Into::into)
+                .map(|r| {
+                    let r: liquidityReturn = r.into();
+                    r._0
+                })
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `increaseObservationCardinalityNext(uint16)` and selector `0x32148f67`.
+    /**Function with signature `mint(address,int24,int24,uint128,bytes)` and selector `0x3c8a7d8d`.
     ```solidity
-    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
+    function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes memory data) external returns (uint256 amount0, uint256 amount1);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseObservationCardinalityNextCall {
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        #[allow(missing_docs)]
+        pub amount: u128,
         #[allow(missing_docs)]
-        pub observationCardinalityNext: u16,
+        pub data: alloy_sol_types::private::Bytes,
     }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`increaseObservationCardinalityNext(uint16)`](increaseObservationCardinalityNextCall)
-    /// function.
+    /// [`mint(address,int24,int24,uint128,bytes)`](mintCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct increaseObservationCardinalityNextReturn {}
+    pub struct mintReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
+    }
     #[allow(
         non_camel_case_types,
         non_snake_case,
@@ -3721,9 +3323,21 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<16>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u16,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::I24,
+                alloy_sol_types::private::primitives::aliases::I24,
+                u128,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3735,17 +3349,27 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseObservationCardinalityNextCall> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseObservationCardinalityNextCall) -> Self {
-                    (value.observationCardinalityNext,)
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (
+                        value.recipient,
+                        value.tickLower,
+                        value.tickUpper,
+                        value.amount,
+                        value.data,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseObservationCardinalityNextCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        observationCardinalityNext: tuple.0,
+                        recipient: tuple.0,
+                        tickLower: tuple.1,
+                        tickUpper: tuple.2,
+                        amount: tuple.3,
+                        data: tuple.4,
                     }
                 }
             }
@@ -3753,9 +3377,15 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -3767,1508 +3397,53 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<increaseObservationCardinalityNextReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: increaseObservationCardinalityNextReturn) -> Self {
-                    ()
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    (value.amount0, value.amount1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseObservationCardinalityNextReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
                 }
             }
         }
-        impl increaseObservationCardinalityNextReturn {
-            fn _tokenize(
-                &self,
-            ) -> <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for increaseObservationCardinalityNextCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<16>,);
-            type Return = increaseObservationCardinalityNextReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [50u8, 20u8, 143u8, 103u8];
-            const SIGNATURE: &'static str = "increaseObservationCardinalityNext(uint16)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
-                        &self.observationCardinalityNext,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                increaseObservationCardinalityNextReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `initialize(uint160)` and selector `0xf637731d`.
-    ```solidity
-    function initialize(uint160 sqrtPriceX96) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct initializeCall {
-        #[allow(missing_docs)]
-        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
-    }
-    ///Container type for the return parameters of the
-    /// [`initialize(uint160)`](initializeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct initializeReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<160>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U160,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: initializeCall) -> Self {
-                    (value.sqrtPriceX96,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        sqrtPriceX96: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: initializeReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl initializeReturn {
-            fn _tokenize(&self) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for initializeCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<160>,);
-            type Return = initializeReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [246u8, 55u8, 115u8, 29u8];
-            const SIGNATURE: &'static str = "initialize(uint160)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.sqrtPriceX96,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                initializeReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `liquidity()` and selector `0x1a686502`.
-    ```solidity
-    function liquidity() external view returns (uint128);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct liquidityCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`liquidity()`](liquidityCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct liquidityReturn {
-        #[allow(missing_docs)]
-        pub _0: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<liquidityCall> for UnderlyingRustTuple<'_> {
-                fn from(value: liquidityCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for liquidityCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<liquidityReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: liquidityReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for liquidityReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for liquidityCall {
-            type Parameters<'a> = ();
-            type Return = u128;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [26u8, 104u8, 101u8, 2u8];
-            const SIGNATURE: &'static str = "liquidity()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: liquidityReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: liquidityReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `maxLiquidityPerTick()` and selector `0x70cf754a`.
-    ```solidity
-    function maxLiquidityPerTick() external view returns (uint128);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct maxLiquidityPerTickCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`maxLiquidityPerTick()`](maxLiquidityPerTickCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct maxLiquidityPerTickReturn {
-        #[allow(missing_docs)]
-        pub _0: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<maxLiquidityPerTickCall> for UnderlyingRustTuple<'_> {
-                fn from(value: maxLiquidityPerTickCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for maxLiquidityPerTickCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<maxLiquidityPerTickReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: maxLiquidityPerTickReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for maxLiquidityPerTickReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for maxLiquidityPerTickCall {
-            type Parameters<'a> = ();
-            type Return = u128;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<128>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [112u8, 207u8, 117u8, 74u8];
-            const SIGNATURE: &'static str = "maxLiquidityPerTick()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: maxLiquidityPerTickReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: maxLiquidityPerTickReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `mint(address,int24,int24,uint128,bytes)` and selector `0x3c8a7d8d`.
-    ```solidity
-    function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes memory data) external returns (uint256 amount0, uint256 amount1);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
-        #[allow(missing_docs)]
-        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
-        #[allow(missing_docs)]
-        pub amount: u128,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`mint(address,int24,int24,uint128,bytes)`](mintCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct mintReturn {
-        #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                alloy_sol_types::private::primitives::aliases::I24,
-                alloy_sol_types::private::primitives::aliases::I24,
-                u128,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
-                fn from(value: mintCall) -> Self {
-                    (
-                        value.recipient,
-                        value.tickLower,
-                        value.tickUpper,
-                        value.amount,
-                        value.data,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        tickLower: tuple.1,
-                        tickUpper: tuple.2,
-                        amount: tuple.3,
-                        data: tuple.4,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: mintReturn) -> Self {
-                    (value.amount0, value.amount1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount0: tuple.0,
-                        amount1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl mintReturn {
-            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for mintCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = mintReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [60u8, 138u8, 125u8, 141u8];
-            const SIGNATURE: &'static str = "mint(address,int24,int24,uint128,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickLower,
-                    ),
-                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickUpper,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                mintReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `observations(uint256)` and selector `0x252c09d7`.
-    ```solidity
-    function observations(uint256) external view returns (uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct observationsCall(pub alloy_sol_types::private::primitives::aliases::U256);
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`observations(uint256)`](observationsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct observationsReturn {
-        #[allow(missing_docs)]
-        pub blockTimestamp: u32,
-        #[allow(missing_docs)]
-        pub tickCumulative: alloy_sol_types::private::primitives::aliases::I56,
-        #[allow(missing_docs)]
-        pub secondsPerLiquidityCumulativeX128: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub initialized: bool,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<observationsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: observationsCall) -> Self {
-                    (value.0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observationsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<32>,
-                alloy_sol_types::sol_data::Int<56>,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                u32,
-                alloy_sol_types::private::primitives::aliases::I56,
-                alloy_sol_types::private::primitives::aliases::U160,
-                bool,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<observationsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: observationsReturn) -> Self {
-                    (
-                        value.blockTimestamp,
-                        value.tickCumulative,
-                        value.secondsPerLiquidityCumulativeX128,
-                        value.initialized,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observationsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        blockTimestamp: tuple.0,
-                        tickCumulative: tuple.1,
-                        secondsPerLiquidityCumulativeX128: tuple.2,
-                        initialized: tuple.3,
-                    }
-                }
-            }
-        }
-        impl observationsReturn {
-            fn _tokenize(&self) -> <observationsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        &self.blockTimestamp,
-                    ),
-                    <alloy_sol_types::sol_data::Int<56> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickCumulative,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.secondsPerLiquidityCumulativeX128,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.initialized,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for observationsCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Return = observationsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<32>,
-                alloy_sol_types::sol_data::Int<56>,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Bool,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [37u8, 44u8, 9u8, 215u8];
-            const SIGNATURE: &'static str = "observations(uint256)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                observationsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `observe(uint32[])` and selector `0x883bdbfd`.
-    ```solidity
-    function observe(uint32[] memory secondsAgos) external view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct observeCall {
-        #[allow(missing_docs)]
-        pub secondsAgos: alloy_sol_types::private::Vec<u32>,
-    }
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`observe(uint32[])`](observeCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct observeReturn {
-        #[allow(missing_docs)]
-        pub tickCumulatives:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I56>,
-        #[allow(missing_docs)]
-        pub secondsPerLiquidityCumulativeX128s:
-            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<u32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<observeCall> for UnderlyingRustTuple<'_> {
-                fn from(value: observeCall) -> Self {
-                    (value.secondsAgos,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observeCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        secondsAgos: tuple.0,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<56>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I56>,
-                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<observeReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: observeReturn) -> Self {
-                    (
-                        value.tickCumulatives,
-                        value.secondsPerLiquidityCumulativeX128s,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observeReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        tickCumulatives: tuple.0,
-                        secondsPerLiquidityCumulativeX128s: tuple.1,
-                    }
-                }
-            }
-        }
-        impl observeReturn {
-            fn _tokenize(&self) -> <observeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Int<56>,
-                    > as alloy_sol_types::SolType>::tokenize(&self.tickCumulatives),
-                    <alloy_sol_types::sol_data::Array<
-                        alloy_sol_types::sol_data::Uint<160>,
-                    > as alloy_sol_types::SolType>::tokenize(
-                        &self.secondsPerLiquidityCumulativeX128s,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for observeCall {
-            type Parameters<'a> =
-                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,);
-            type Return = observeReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<56>>,
-                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [136u8, 59u8, 219u8, 253u8];
-            const SIGNATURE: &'static str = "observe(uint32[])";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (<alloy_sol_types::sol_data::Array<
-                    alloy_sol_types::sol_data::Uint<32>,
-                > as alloy_sol_types::SolType>::tokenize(
-                    &self.secondsAgos
-                ),)
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                observeReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `positions(bytes32)` and selector `0x514ea4bf`.
-    ```solidity
-    function positions(bytes32) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct positionsCall(pub alloy_sol_types::private::FixedBytes<32>);
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`positions(bytes32)`](positionsCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct positionsReturn {
-        #[allow(missing_docs)]
-        pub liquidity: u128,
-        #[allow(missing_docs)]
-        pub feeGrowthInside0LastX128: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub feeGrowthInside1LastX128: alloy_sol_types::private::primitives::aliases::U256,
-        #[allow(missing_docs)]
-        pub tokensOwed0: u128,
-        #[allow(missing_docs)]
-        pub tokensOwed1: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<positionsCall> for UnderlyingRustTuple<'_> {
-                fn from(value: positionsCall) -> Self {
-                    (value.0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for positionsCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                u128,
-                alloy_sol_types::private::primitives::aliases::U256,
-                alloy_sol_types::private::primitives::aliases::U256,
-                u128,
-                u128,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<positionsReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: positionsReturn) -> Self {
-                    (
-                        value.liquidity,
-                        value.feeGrowthInside0LastX128,
-                        value.feeGrowthInside1LastX128,
-                        value.tokensOwed0,
-                        value.tokensOwed1,
-                    )
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for positionsReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        liquidity: tuple.0,
-                        feeGrowthInside0LastX128: tuple.1,
-                        feeGrowthInside1LastX128: tuple.2,
-                        tokensOwed0: tuple.3,
-                        tokensOwed1: tuple.4,
-                    }
-                }
-            }
-        }
-        impl positionsReturn {
-            fn _tokenize(&self) -> <positionsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.liquidity,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeGrowthInside0LastX128,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeGrowthInside1LastX128,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.tokensOwed0,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.tokensOwed1,
-                    ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for positionsCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
-            type Return = positionsReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<256>,
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [81u8, 78u8, 164u8, 191u8];
-            const SIGNATURE: &'static str = "positions(bytes32)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::FixedBytes<
-                        32,
-                    > as alloy_sol_types::SolType>::tokenize(&self.0),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                positionsReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `protocolFees()` and selector `0x1ad8b03b`.
-    ```solidity
-    function protocolFees() external view returns (uint128 token0, uint128 token1);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct protocolFeesCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`protocolFees()`](protocolFeesCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct protocolFeesReturn {
-        #[allow(missing_docs)]
-        pub token0: u128,
-        #[allow(missing_docs)]
-        pub token1: u128,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<protocolFeesCall> for UnderlyingRustTuple<'_> {
-                fn from(value: protocolFeesCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for protocolFeesCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u128, u128);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<protocolFeesReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: protocolFeesReturn) -> Self {
-                    (value.token0, value.token1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for protocolFeesReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        token0: tuple.0,
-                        token1: tuple.1,
-                    }
-                }
-            }
-        }
-        impl protocolFeesReturn {
-            fn _tokenize(&self) -> <protocolFeesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.token0,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
                     ),
-                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
-                        &self.token1,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
                     ),
-                )
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for protocolFeesCall {
-            type Parameters<'a> = ();
-            type Return = protocolFeesReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<128>,
-                alloy_sol_types::sol_data::Uint<128>,
-            );
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [26u8, 216u8, 176u8, 59u8];
-            const SIGNATURE: &'static str = "protocolFees()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                protocolFeesReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `setFeeProtocol(uint8,uint8)` and selector `0x8206a4d1`.
-    ```solidity
-    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setFeeProtocolCall {
-        #[allow(missing_docs)]
-        pub feeProtocol0: u8,
-        #[allow(missing_docs)]
-        pub feeProtocol1: u8,
-    }
-    ///Container type for the return parameters of the
-    /// [`setFeeProtocol(uint8,uint8)`](setFeeProtocolCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct setFeeProtocolReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::Uint<8>,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (u8, u8);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setFeeProtocolCall> for UnderlyingRustTuple<'_> {
-                fn from(value: setFeeProtocolCall) -> Self {
-                    (value.feeProtocol0, value.feeProtocol1)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeProtocolCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        feeProtocol0: tuple.0,
-                        feeProtocol1: tuple.1,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<setFeeProtocolReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: setFeeProtocolReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setFeeProtocolReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl setFeeProtocolReturn {
-            fn _tokenize(
-                &self,
-            ) -> <setFeeProtocolCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
-                ()
+                )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for setFeeProtocolCall {
+        impl alloy_sol_types::SolCall for mintCall {
             type Parameters<'a> = (
-                alloy_sol_types::sol_data::Uint<8>,
-                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Int<24>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Bytes,
             );
-            type Return = setFeeProtocolReturn;
+            type Return = mintReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [130u8, 6u8, 164u8, 209u8];
-            const SIGNATURE: &'static str = "setFeeProtocol(uint8,uint8)";
+            const SELECTOR: [u8; 4] = [60u8, 138u8, 125u8, 141u8];
+            const SIGNATURE: &'static str = "mint(address,int24,int24,uint128,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -5280,18 +3455,27 @@ pub mod UniswapV3Pool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeProtocol0,
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
                     ),
-                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeProtocol1,
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickLower,
+                    ),
+                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickUpper,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
                     ),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                setFeeProtocolReturn::_tokenize(ret)
+                mintReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5310,33 +3494,27 @@ pub mod UniswapV3Pool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `slot0()` and selector `0x3850c7bd`.
+    /**Function with signature `observations(uint256)` and selector `0x252c09d7`.
     ```solidity
-    function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked);
+    function observations(uint256) external view returns (uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct slot0Call;
+    pub struct observationsCall(pub alloy_sol_types::private::primitives::aliases::U256);
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the [`slot0()`](slot0Call)
-    /// function.
+    ///Container type for the return parameters of the
+    /// [`observations(uint256)`](observationsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct slot0Return {
-        #[allow(missing_docs)]
-        pub sqrtPriceX96: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub tick: alloy_sol_types::private::primitives::aliases::I24,
-        #[allow(missing_docs)]
-        pub observationIndex: u16,
+    pub struct observationsReturn {
         #[allow(missing_docs)]
-        pub observationCardinality: u16,
+        pub blockTimestamp: u32,
         #[allow(missing_docs)]
-        pub observationCardinalityNext: u16,
+        pub tickCumulative: alloy_sol_types::private::primitives::aliases::I56,
         #[allow(missing_docs)]
-        pub feeProtocol: u8,
+        pub secondsPerLiquidityCumulativeX128: alloy_sol_types::private::primitives::aliases::U160,
         #[allow(missing_docs)]
-        pub unlocked: bool,
+        pub initialized: bool,
     }
     #[allow(
         non_camel_case_types,
@@ -5349,9 +3527,9 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5363,16 +3541,16 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<slot0Call> for UnderlyingRustTuple<'_> {
-                fn from(value: slot0Call) -> Self {
-                    ()
+            impl ::core::convert::From<observationsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: observationsCall) -> Self {
+                    (value.0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slot0Call {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observationsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self(tuple.0)
                 }
             }
         }
@@ -5380,22 +3558,16 @@ pub mod UniswapV3Pool {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Int<56>,
                 alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Uint<16>,
-                alloy_sol_types::sol_data::Uint<16>,
-                alloy_sol_types::sol_data::Uint<16>,
-                alloy_sol_types::sol_data::Uint<8>,
                 alloy_sol_types::sol_data::Bool,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
+                u32,
+                alloy_sol_types::private::primitives::aliases::I56,
                 alloy_sol_types::private::primitives::aliases::U160,
-                alloy_sol_types::private::primitives::aliases::I24,
-                u16,
-                u16,
-                u16,
-                u8,
                 bool,
             );
             #[cfg(test)]
@@ -5409,80 +3581,62 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<slot0Return> for UnderlyingRustTuple<'_> {
-                fn from(value: slot0Return) -> Self {
+            impl ::core::convert::From<observationsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: observationsReturn) -> Self {
                     (
-                        value.sqrtPriceX96,
-                        value.tick,
-                        value.observationIndex,
-                        value.observationCardinality,
-                        value.observationCardinalityNext,
-                        value.feeProtocol,
-                        value.unlocked,
+                        value.blockTimestamp,
+                        value.tickCumulative,
+                        value.secondsPerLiquidityCumulativeX128,
+                        value.initialized,
                     )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slot0Return {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observationsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        sqrtPriceX96: tuple.0,
-                        tick: tuple.1,
-                        observationIndex: tuple.2,
-                        observationCardinality: tuple.3,
-                        observationCardinalityNext: tuple.4,
-                        feeProtocol: tuple.5,
-                        unlocked: tuple.6,
+                        blockTimestamp: tuple.0,
+                        tickCumulative: tuple.1,
+                        secondsPerLiquidityCumulativeX128: tuple.2,
+                        initialized: tuple.3,
                     }
                 }
             }
         }
-        impl slot0Return {
-            fn _tokenize(&self) -> <slot0Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl observationsReturn {
+            fn _tokenize(&self) -> <observationsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.sqrtPriceX96,
-                    ),
-                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.tick,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
-                        &self.observationIndex,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
-                        &self.observationCardinality,
+                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
+                        &self.blockTimestamp,
                     ),
-                    <alloy_sol_types::sol_data::Uint<16> as alloy_sol_types::SolType>::tokenize(
-                        &self.observationCardinalityNext,
+                    <alloy_sol_types::sol_data::Int<56> as alloy_sol_types::SolType>::tokenize(
+                        &self.tickCumulative,
                     ),
-                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
-                        &self.feeProtocol,
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsPerLiquidityCumulativeX128,
                     ),
                     <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.unlocked,
+                        &self.initialized,
                     ),
                 )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for slot0Call {
-            type Parameters<'a> = ();
-            type Return = slot0Return;
+        impl alloy_sol_types::SolCall for observationsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = observationsReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Int<56>,
                 alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Uint<16>,
-                alloy_sol_types::sol_data::Uint<16>,
-                alloy_sol_types::sol_data::Uint<16>,
-                alloy_sol_types::sol_data::Uint<8>,
                 alloy_sol_types::sol_data::Bool,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [56u8, 80u8, 199u8, 189u8];
-            const SIGNATURE: &'static str = "slot0()";
+            const SELECTOR: [u8; 4] = [37u8, 44u8, 9u8, 215u8];
+            const SIGNATURE: &'static str = "observations(uint256)";
 
             #[inline]
             fn new<'a>(
@@ -5493,12 +3647,16 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                slot0Return::_tokenize(ret)
+                observationsReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5517,31 +3675,28 @@ pub mod UniswapV3Pool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `snapshotCumulativesInside(int24,int24)` and selector `0xa38807f2`.
+    /**Function with signature `observe(uint32[])` and selector `0x883bdbfd`.
     ```solidity
-    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) external view returns (int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside);
+    function observe(uint32[] memory secondsAgos) external view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct snapshotCumulativesInsideCall {
-        #[allow(missing_docs)]
-        pub tickLower: alloy_sol_types::private::primitives::aliases::I24,
+    pub struct observeCall {
         #[allow(missing_docs)]
-        pub tickUpper: alloy_sol_types::private::primitives::aliases::I24,
+        pub secondsAgos: alloy_sol_types::private::Vec<u32>,
     }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`snapshotCumulativesInside(int24,
-    /// int24)`](snapshotCumulativesInsideCall) function.
+    /// [`observe(uint32[])`](observeCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct snapshotCumulativesInsideReturn {
-        #[allow(missing_docs)]
-        pub tickCumulativeInside: alloy_sol_types::private::primitives::aliases::I56,
+    pub struct observeReturn {
         #[allow(missing_docs)]
-        pub secondsPerLiquidityInsideX128: alloy_sol_types::private::primitives::aliases::U160,
+        pub tickCumulatives:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I56>,
         #[allow(missing_docs)]
-        pub secondsInside: u32,
+        pub secondsPerLiquidityCumulativeX128s:
+            alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
     }
     #[allow(
         non_camel_case_types,
@@ -5554,15 +3709,10 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Int<24>,
-            );
+            type UnderlyingSolTuple<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,);
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::I24,
-                alloy_sol_types::private::primitives::aliases::I24,
-            );
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Vec<u32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5574,18 +3724,17 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<snapshotCumulativesInsideCall> for UnderlyingRustTuple<'_> {
-                fn from(value: snapshotCumulativesInsideCall) -> Self {
-                    (value.tickLower, value.tickUpper)
+            impl ::core::convert::From<observeCall> for UnderlyingRustTuple<'_> {
+                fn from(value: observeCall) -> Self {
+                    (value.secondsAgos,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for snapshotCumulativesInsideCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observeCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        tickLower: tuple.0,
-                        tickUpper: tuple.1,
+                        secondsAgos: tuple.0,
                     }
                 }
             }
@@ -5594,15 +3743,13 @@ pub mod UniswapV3Pool {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Int<56>,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<56>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::I56,
-                alloy_sol_types::private::primitives::aliases::U160,
-                u32,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::I56>,
+                alloy_sol_types::private::Vec<alloy_sol_types::private::primitives::aliases::U160>,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5615,62 +3762,53 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<snapshotCumulativesInsideReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: snapshotCumulativesInsideReturn) -> Self {
+            impl ::core::convert::From<observeReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: observeReturn) -> Self {
                     (
-                        value.tickCumulativeInside,
-                        value.secondsPerLiquidityInsideX128,
-                        value.secondsInside,
+                        value.tickCumulatives,
+                        value.secondsPerLiquidityCumulativeX128s,
                     )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for snapshotCumulativesInsideReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for observeReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        tickCumulativeInside: tuple.0,
-                        secondsPerLiquidityInsideX128: tuple.1,
-                        secondsInside: tuple.2,
+                        tickCumulatives: tuple.0,
+                        secondsPerLiquidityCumulativeX128s: tuple.1,
                     }
                 }
             }
         }
-        impl snapshotCumulativesInsideReturn {
-            fn _tokenize(
-                &self,
-            ) -> <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
+        impl observeReturn {
+            fn _tokenize(&self) -> <observeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Int<56> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickCumulativeInside,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.secondsPerLiquidityInsideX128,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
-                        &self.secondsInside,
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Int<56>,
+                    > as alloy_sol_types::SolType>::tokenize(&self.tickCumulatives),
+                    <alloy_sol_types::sol_data::Array<
+                        alloy_sol_types::sol_data::Uint<160>,
+                    > as alloy_sol_types::SolType>::tokenize(
+                        &self.secondsPerLiquidityCumulativeX128s,
                     ),
                 )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for snapshotCumulativesInsideCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Int<24>,
-                alloy_sol_types::sol_data::Int<24>,
-            );
-            type Return = snapshotCumulativesInsideReturn;
+        impl alloy_sol_types::SolCall for observeCall {
+            type Parameters<'a> =
+                (alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<32>>,);
+            type Return = observeReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Int<56>,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Uint<32>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Int<56>>,
+                alloy_sol_types::sol_data::Array<alloy_sol_types::sol_data::Uint<160>>,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [163u8, 136u8, 7u8, 242u8];
-            const SIGNATURE: &'static str = "snapshotCumulativesInside(int24,int24)";
+            const SELECTOR: [u8; 4] = [136u8, 59u8, 219u8, 253u8];
+            const SIGNATURE: &'static str = "observe(uint32[])";
 
             #[inline]
             fn new<'a>(
@@ -5681,19 +3819,16 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickLower,
-                    ),
-                    <alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(
-                        &self.tickUpper,
-                    ),
-                )
+                (<alloy_sol_types::sol_data::Array<
+                    alloy_sol_types::sol_data::Uint<32>,
+                > as alloy_sol_types::SolType>::tokenize(
+                    &self.secondsAgos
+                ),)
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                snapshotCumulativesInsideReturn::_tokenize(ret)
+                observeReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5712,34 +3847,29 @@ pub mod UniswapV3Pool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `swap(address,bool,int256,uint160,bytes)` and selector `0x128acb08`.
+    /**Function with signature `positions(bytes32)` and selector `0x514ea4bf`.
     ```solidity
-    function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes memory data) external returns (int256 amount0, int256 amount1);
+    function positions(bytes32) external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapCall {
-        #[allow(missing_docs)]
-        pub recipient: alloy_sol_types::private::Address,
-        #[allow(missing_docs)]
-        pub zeroForOne: bool,
-        #[allow(missing_docs)]
-        pub amountSpecified: alloy_sol_types::private::primitives::aliases::I256,
-        #[allow(missing_docs)]
-        pub sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
-        #[allow(missing_docs)]
-        pub data: alloy_sol_types::private::Bytes,
-    }
+    pub struct positionsCall(pub alloy_sol_types::private::FixedBytes<32>);
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`swap(address,bool,int256,uint160,bytes)`](swapCall) function.
+    /// [`positions(bytes32)`](positionsCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct swapReturn {
+    pub struct positionsReturn {
         #[allow(missing_docs)]
-        pub amount0: alloy_sol_types::private::primitives::aliases::I256,
+        pub liquidity: u128,
         #[allow(missing_docs)]
-        pub amount1: alloy_sol_types::private::primitives::aliases::I256,
+        pub feeGrowthInside0LastX128: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub feeGrowthInside1LastX128: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub tokensOwed0: u128,
+        #[allow(missing_docs)]
+        pub tokensOwed1: u128,
     }
     #[allow(
         non_camel_case_types,
@@ -5749,24 +3879,12 @@ pub mod UniswapV3Pool {
     )]
     const _: () = {
         use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Bytes,
-            );
+        {
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::Address,
-                bool,
-                alloy_sol_types::private::primitives::aliases::I256,
-                alloy_sol_types::private::primitives::aliases::U160,
-                alloy_sol_types::private::Bytes,
-            );
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::FixedBytes<32>,);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5778,28 +3896,16 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: swapCall) -> Self {
-                    (
-                        value.recipient,
-                        value.zeroForOne,
-                        value.amountSpecified,
-                        value.sqrtPriceLimitX96,
-                        value.data,
-                    )
+            impl ::core::convert::From<positionsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: positionsCall) -> Self {
+                    (value.0,)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for positionsCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        recipient: tuple.0,
-                        zeroForOne: tuple.1,
-                        amountSpecified: tuple.2,
-                        sqrtPriceLimitX96: tuple.3,
-                        data: tuple.4,
-                    }
+                    Self(tuple.0)
                 }
             }
         }
@@ -5807,13 +3913,19 @@ pub mod UniswapV3Pool {
             #[doc(hidden)]
             #[allow(dead_code)]
             type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
             );
             #[doc(hidden)]
             type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::I256,
-                alloy_sol_types::private::primitives::aliases::I256,
+                u128,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+                u128,
+                u128,
             );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
@@ -5826,53 +3938,68 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: swapReturn) -> Self {
-                    (value.amount0, value.amount1)
+            impl ::core::convert::From<positionsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: positionsReturn) -> Self {
+                    (
+                        value.liquidity,
+                        value.feeGrowthInside0LastX128,
+                        value.feeGrowthInside1LastX128,
+                        value.tokensOwed0,
+                        value.tokensOwed1,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for positionsReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
                     Self {
-                        amount0: tuple.0,
-                        amount1: tuple.1,
+                        liquidity: tuple.0,
+                        feeGrowthInside0LastX128: tuple.1,
+                        feeGrowthInside1LastX128: tuple.2,
+                        tokensOwed0: tuple.3,
+                        tokensOwed1: tuple.4,
                     }
                 }
             }
         }
-        impl swapReturn {
-            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+        impl positionsReturn {
+            fn _tokenize(&self) -> <positionsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
                 (
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0,
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.liquidity,
                     ),
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1,
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeGrowthInside0LastX128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.feeGrowthInside1LastX128,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokensOwed0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.tokensOwed1,
                     ),
                 )
             }
         }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for swapCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Address,
-                alloy_sol_types::sol_data::Bool,
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Uint<160>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = swapReturn;
+        impl alloy_sol_types::SolCall for positionsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::FixedBytes<32>,);
+            type Return = positionsReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
             type ReturnTuple<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
             );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [18u8, 138u8, 203u8, 8u8];
-            const SIGNATURE: &'static str = "swap(address,bool,int256,uint160,bytes)";
+            const SELECTOR: [u8; 4] = [81u8, 78u8, 164u8, 191u8];
+            const SIGNATURE: &'static str = "positions(bytes32)";
 
             #[inline]
             fn new<'a>(
@@ -5884,27 +4011,15 @@ pub mod UniswapV3Pool {
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
                 (
-                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
-                        &self.recipient,
-                    ),
-                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
-                        &self.zeroForOne,
-                    ),
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amountSpecified,
-                    ),
-                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
-                        &self.sqrtPriceLimitX96,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.data,
-                    ),
+                    <alloy_sol_types::sol_data::FixedBytes<
+                        32,
+                    > as alloy_sol_types::SolType>::tokenize(&self.0),
                 )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                swapReturn::_tokenize(ret)
+                positionsReturn::_tokenize(ret)
             }
 
             #[inline]
@@ -5923,21 +4038,23 @@ pub mod UniswapV3Pool {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `tickBitmap(int16)` and selector `0x5339c296`.
+    /**Function with signature `protocolFees()` and selector `0x1ad8b03b`.
     ```solidity
-    function tickBitmap(int16) external view returns (uint256);
+    function protocolFees() external view returns (uint128 token0, uint128 token1);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tickBitmapCall(pub i16);
+    pub struct protocolFeesCall;
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`tickBitmap(int16)`](tickBitmapCall) function.
+    /// [`protocolFees()`](protocolFeesCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tickBitmapReturn {
+    pub struct protocolFeesReturn {
+        #[allow(missing_docs)]
+        pub token0: u128,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+        pub token1: u128,
     }
     #[allow(
         non_camel_case_types,
@@ -5950,9 +4067,9 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<16>,);
+            type UnderlyingSolTuple<'a> = ();
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (i16,);
+            type UnderlyingRustTuple<'a> = ();
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5964,25 +4081,28 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tickBitmapCall> for UnderlyingRustTuple<'_> {
-                fn from(value: tickBitmapCall) -> Self {
-                    (value.0,)
+            impl ::core::convert::From<protocolFeesCall> for UnderlyingRustTuple<'_> {
+                fn from(value: protocolFeesCall) -> Self {
+                    ()
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickBitmapCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for protocolFeesCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self(tuple.0)
+                    Self
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            type UnderlyingRustTuple<'a> = (u128, u128);
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -5994,29 +4114,47 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tickBitmapReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: tickBitmapReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<protocolFeesReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: protocolFeesReturn) -> Self {
+                    (value.token0, value.token1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickBitmapReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for protocolFeesReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        token0: tuple.0,
+                        token1: tuple.1,
+                    }
                 }
             }
         }
+        impl protocolFeesReturn {
+            fn _tokenize(&self) -> <protocolFeesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.token0,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<128> as alloy_sol_types::SolType>::tokenize(
+                        &self.token1,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for tickBitmapCall {
-            type Parameters<'a> = (alloy_sol_types::sol_data::Int<16>,);
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
+        impl alloy_sol_types::SolCall for protocolFeesCall {
+            type Parameters<'a> = ();
+            type Return = protocolFeesReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Uint<128>,
+                alloy_sol_types::sol_data::Uint<128>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [83u8, 57u8, 194u8, 150u8];
-            const SIGNATURE: &'static str = "tickBitmap(int16)";
+            const SELECTOR: [u8; 4] = [26u8, 216u8, 176u8, 59u8];
+            const SIGNATURE: &'static str = "protocolFees()";
 
             #[inline]
             fn new<'a>(
@@ -6027,30 +4165,18 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Int<16> as alloy_sol_types::SolType>::tokenize(
-                        &self.0,
-                    ),
-                )
+                ()
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
+                protocolFeesReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: tickBitmapReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -6058,29 +4184,39 @@ pub mod UniswapV3Pool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: tickBitmapReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `tickSpacing()` and selector `0xd0c93a7c`.
+    /**Function with signature `swap(address,bool,int256,uint160,bytes)` and selector `0x128acb08`.
     ```solidity
-    function tickSpacing() external view returns (int24);
+    function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes memory data) external returns (int256 amount0, int256 amount1);
     ```*/
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tickSpacingCall;
+    pub struct swapCall {
+        #[allow(missing_docs)]
+        pub recipient: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub zeroForOne: bool,
+        #[allow(missing_docs)]
+        pub amountSpecified: alloy_sol_types::private::primitives::aliases::I256,
+        #[allow(missing_docs)]
+        pub sqrtPriceLimitX96: alloy_sol_types::private::primitives::aliases::U160,
+        #[allow(missing_docs)]
+        pub data: alloy_sol_types::private::Bytes,
+    }
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
     ///Container type for the return parameters of the
-    /// [`tickSpacing()`](tickSpacingCall) function.
+    /// [`swap(address,bool,int256,uint160,bytes)`](swapCall) function.
     #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
     #[derive(Clone)]
-    pub struct tickSpacingReturn {
+    pub struct swapReturn {
+        #[allow(missing_docs)]
+        pub amount0: alloy_sol_types::private::primitives::aliases::I256,
         #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::I24,
+        pub amount1: alloy_sol_types::private::primitives::aliases::I256,
     }
     #[allow(
         non_camel_case_types,
@@ -6093,9 +4229,21 @@ pub mod UniswapV3Pool {
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Bytes,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                bool,
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::primitives::aliases::U160,
+                alloy_sol_types::private::Bytes,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6107,25 +4255,43 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tickSpacingCall> for UnderlyingRustTuple<'_> {
-                fn from(value: tickSpacingCall) -> Self {
-                    ()
+            impl ::core::convert::From<swapCall> for UnderlyingRustTuple<'_> {
+                fn from(value: swapCall) -> Self {
+                    (
+                        value.recipient,
+                        value.zeroForOne,
+                        value.amountSpecified,
+                        value.sqrtPriceLimitX96,
+                        value.data,
+                    )
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickSpacingCall {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapCall {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
+                    Self {
+                        recipient: tuple.0,
+                        zeroForOne: tuple.1,
+                        amountSpecified: tuple.2,
+                        sqrtPriceLimitX96: tuple.3,
+                        data: tuple.4,
+                    }
                 }
             }
         }
         {
             #[doc(hidden)]
             #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+            );
             #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::I24,);
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::primitives::aliases::I256,
+                alloy_sol_types::private::primitives::aliases::I256,
+            );
             #[cfg(test)]
             #[allow(dead_code, unreachable_patterns)]
             fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
@@ -6137,29 +4303,53 @@ pub mod UniswapV3Pool {
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<tickSpacingReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: tickSpacingReturn) -> Self {
-                    (value._0,)
+            impl ::core::convert::From<swapReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: swapReturn) -> Self {
+                    (value.amount0, value.amount1)
                 }
             }
             #[automatically_derived]
             #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for tickSpacingReturn {
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for swapReturn {
                 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
+                    Self {
+                        amount0: tuple.0,
+                        amount1: tuple.1,
+                    }
                 }
             }
         }
+        impl swapReturn {
+            fn _tokenize(&self) -> <swapCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount0,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount1,
+                    ),
+                )
+            }
+        }
         #[automatically_derived]
-        impl alloy_sol_types::SolCall for tickSpacingCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::I24;
+        impl alloy_sol_types::SolCall for swapCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Bool,
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Uint<160>,
+                alloy_sol_types::sol_data::Bytes,
+            );
+            type Return = swapReturn;
             type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Int<24>,);
+            type ReturnTuple<'a> = (
+                alloy_sol_types::sol_data::Int<256>,
+                alloy_sol_types::sol_data::Int<256>,
+            );
             type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
 
-            const SELECTOR: [u8; 4] = [208u8, 201u8, 58u8, 124u8];
-            const SIGNATURE: &'static str = "tickSpacing()";
+            const SELECTOR: [u8; 4] = [18u8, 138u8, 203u8, 8u8];
+            const SIGNATURE: &'static str = "swap(address,bool,int256,uint160,bytes)";
 
             #[inline]
             fn new<'a>(
@@ -6170,22 +4360,34 @@ pub mod UniswapV3Pool {
 
             #[inline]
             fn tokenize(&self) -> Self::Token<'_> {
-                ()
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.recipient,
+                    ),
+                    <alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
+                        &self.zeroForOne,
+                    ),
+                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amountSpecified,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<160> as alloy_sol_types::SolType>::tokenize(
+                        &self.sqrtPriceLimitX96,
+                    ),
+                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
+                        &self.data,
+                    ),
+                )
             }
 
             #[inline]
             fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (<alloy_sol_types::sol_data::Int<24> as alloy_sol_types::SolType>::tokenize(ret),)
+                swapReturn::_tokenize(ret)
             }
 
             #[inline]
             fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: tickSpacingReturn = r.into();
-                        r._0
-                    },
-                )
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
             }
 
             #[inline]
@@ -6193,10 +4395,7 @@ pub mod UniswapV3Pool {
                 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
                     data,
                 )
-                .map(|r| {
-                    let r: tickSpacingReturn = r.into();
-                    r._0
-                })
+                .map(Into::into)
             }
         }
     };
@@ -6699,26 +4898,16 @@ pub mod UniswapV3Pool {
         #[allow(missing_docs)]
         collect(collectCall),
         #[allow(missing_docs)]
-        collectProtocol(collectProtocolCall),
-        #[allow(missing_docs)]
         factory(factoryCall),
         #[allow(missing_docs)]
         fee(feeCall),
         #[allow(missing_docs)]
-        feeGrowthGlobal0X128(feeGrowthGlobal0X128Call),
-        #[allow(missing_docs)]
-        feeGrowthGlobal1X128(feeGrowthGlobal1X128Call),
-        #[allow(missing_docs)]
         flash(flashCall),
         #[allow(missing_docs)]
-        increaseObservationCardinalityNext(increaseObservationCardinalityNextCall),
-        #[allow(missing_docs)]
         initialize(initializeCall),
         #[allow(missing_docs)]
         liquidity(liquidityCall),
         #[allow(missing_docs)]
-        maxLiquidityPerTick(maxLiquidityPerTickCall),
-        #[allow(missing_docs)]
         mint(mintCall),
         #[allow(missing_docs)]
         observations(observationsCall),
@@ -6729,18 +4918,8 @@ pub mod UniswapV3Pool {
         #[allow(missing_docs)]
         protocolFees(protocolFeesCall),
         #[allow(missing_docs)]
-        setFeeProtocol(setFeeProtocolCall),
-        #[allow(missing_docs)]
-        slot0(slot0Call),
-        #[allow(missing_docs)]
-        snapshotCumulativesInside(snapshotCumulativesInsideCall),
-        #[allow(missing_docs)]
         swap(swapCall),
         #[allow(missing_docs)]
-        tickBitmap(tickBitmapCall),
-        #[allow(missing_docs)]
-        tickSpacing(tickSpacingCall),
-        #[allow(missing_docs)]
         ticks(ticksCall),
         #[allow(missing_docs)]
         token0(token0Call),
@@ -6761,25 +4940,15 @@ pub mod UniswapV3Pool {
             [26u8, 104u8, 101u8, 2u8],
             [26u8, 216u8, 176u8, 59u8],
             [37u8, 44u8, 9u8, 215u8],
-            [50u8, 20u8, 143u8, 103u8],
-            [56u8, 80u8, 199u8, 189u8],
             [60u8, 138u8, 125u8, 141u8],
-            [70u8, 20u8, 19u8, 25u8],
             [73u8, 14u8, 108u8, 188u8],
             [79u8, 30u8, 179u8, 216u8],
             [81u8, 78u8, 164u8, 191u8],
-            [83u8, 57u8, 194u8, 150u8],
-            [112u8, 207u8, 117u8, 74u8],
-            [130u8, 6u8, 164u8, 209u8],
-            [133u8, 182u8, 103u8, 41u8],
             [136u8, 59u8, 219u8, 253u8],
             [163u8, 65u8, 35u8, 167u8],
-            [163u8, 136u8, 7u8, 242u8],
             [196u8, 90u8, 1u8, 85u8],
-            [208u8, 201u8, 58u8, 124u8],
             [210u8, 18u8, 32u8, 167u8],
             [221u8, 202u8, 63u8, 67u8],
-            [243u8, 5u8, 131u8, 153u8],
             [243u8, 13u8, 186u8, 147u8],
             [246u8, 55u8, 115u8, 29u8],
         ];
@@ -6790,25 +4959,15 @@ pub mod UniswapV3Pool {
             <liquidityCall as alloy_sol_types::SolCall>::SIGNATURE,
             <protocolFeesCall as alloy_sol_types::SolCall>::SIGNATURE,
             <observationsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <slot0Call as alloy_sol_types::SolCall>::SIGNATURE,
             <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::SIGNATURE,
             <flashCall as alloy_sol_types::SolCall>::SIGNATURE,
             <collectCall as alloy_sol_types::SolCall>::SIGNATURE,
             <positionsCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <tickBitmapCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <setFeeProtocolCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <collectProtocolCall as alloy_sol_types::SolCall>::SIGNATURE,
             <observeCall as alloy_sol_types::SolCall>::SIGNATURE,
             <burnCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::SIGNATURE,
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <tickSpacingCall as alloy_sol_types::SolCall>::SIGNATURE,
             <token1Call as alloy_sol_types::SolCall>::SIGNATURE,
             <feeCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::SIGNATURE,
             <ticksCall as alloy_sol_types::SolCall>::SIGNATURE,
             <initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
@@ -6819,25 +4978,15 @@ pub mod UniswapV3Pool {
             ::core::stringify!(liquidity),
             ::core::stringify!(protocolFees),
             ::core::stringify!(observations),
-            ::core::stringify!(increaseObservationCardinalityNext),
-            ::core::stringify!(slot0),
             ::core::stringify!(mint),
-            ::core::stringify!(feeGrowthGlobal1X128),
             ::core::stringify!(flash),
             ::core::stringify!(collect),
             ::core::stringify!(positions),
-            ::core::stringify!(tickBitmap),
-            ::core::stringify!(maxLiquidityPerTick),
-            ::core::stringify!(setFeeProtocol),
-            ::core::stringify!(collectProtocol),
             ::core::stringify!(observe),
             ::core::stringify!(burn),
-            ::core::stringify!(snapshotCumulativesInside),
             ::core::stringify!(factory),
-            ::core::stringify!(tickSpacing),
             ::core::stringify!(token1),
             ::core::stringify!(fee),
-            ::core::stringify!(feeGrowthGlobal0X128),
             ::core::stringify!(ticks),
             ::core::stringify!(initialize),
         ];
@@ -6864,7 +5013,7 @@ pub mod UniswapV3Pool {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for UniswapV3PoolCalls {
-        const COUNT: usize = 26usize;
+        const COUNT: usize = 16usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "UniswapV3PoolCalls";
 
@@ -6873,41 +5022,17 @@ pub mod UniswapV3Pool {
             match self {
                 Self::burn(_) => <burnCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::collect(_) => <collectCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::collectProtocol(_) => {
-                    <collectProtocolCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::factory(_) => <factoryCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::fee(_) => <feeCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::feeGrowthGlobal0X128(_) => {
-                    <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::feeGrowthGlobal1X128(_) => {
-                    <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::flash(_) => <flashCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::increaseObservationCardinalityNext(_) => {
-                    <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::initialize(_) => <initializeCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::liquidity(_) => <liquidityCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::maxLiquidityPerTick(_) => {
-                    <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::observations(_) => <observationsCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::observe(_) => <observeCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::positions(_) => <positionsCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::protocolFees(_) => <protocolFeesCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::setFeeProtocol(_) => {
-                    <setFeeProtocolCall as alloy_sol_types::SolCall>::SELECTOR
-                }
-                Self::slot0(_) => <slot0Call as alloy_sol_types::SolCall>::SELECTOR,
-                Self::snapshotCumulativesInside(_) => {
-                    <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::SELECTOR
-                }
                 Self::swap(_) => <swapCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::tickBitmap(_) => <tickBitmapCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::tickSpacing(_) => <tickSpacingCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::ticks(_) => <ticksCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token0(_) => <token0Call as alloy_sol_types::SolCall>::SELECTOR,
                 Self::token1(_) => <token1Call as alloy_sol_types::SolCall>::SELECTOR,
@@ -6963,24 +5088,6 @@ pub mod UniswapV3Pool {
                     }
                     observations
                 },
-                {
-                    fn increaseObservationCardinalityNext(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV3PoolCalls::increaseObservationCardinalityNext)
-                    }
-                    increaseObservationCardinalityNext
-                },
-                {
-                    fn slot0(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <slot0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::slot0)
-                    }
-                    slot0
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -6988,15 +5095,6 @@ pub mod UniswapV3Pool {
                     }
                     mint
                 },
-                {
-                    fn feeGrowthGlobal1X128(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::feeGrowthGlobal1X128)
-                    }
-                    feeGrowthGlobal1X128
-                },
                 {
                     fn flash(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <flashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -7018,36 +5116,6 @@ pub mod UniswapV3Pool {
                     }
                     positions
                 },
-                {
-                    fn tickBitmap(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <tickBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::tickBitmap)
-                    }
-                    tickBitmap
-                },
-                {
-                    fn maxLiquidityPerTick(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::maxLiquidityPerTick)
-                    }
-                    maxLiquidityPerTick
-                },
-                {
-                    fn setFeeProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::setFeeProtocol)
-                    }
-                    setFeeProtocol
-                },
-                {
-                    fn collectProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <collectProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::collectProtocol)
-                    }
-                    collectProtocol
-                },
                 {
                     fn observe(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <observeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -7062,17 +5130,6 @@ pub mod UniswapV3Pool {
                     }
                     burn
                 },
-                {
-                    fn snapshotCumulativesInside(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                            data,
-                        )
-                        .map(UniswapV3PoolCalls::snapshotCumulativesInside)
-                    }
-                    snapshotCumulativesInside
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -7080,13 +5137,6 @@ pub mod UniswapV3Pool {
                     }
                     factory
                 },
-                {
-                    fn tickSpacing(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <tickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::tickSpacing)
-                    }
-                    tickSpacing
-                },
                 {
                     fn token1(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <token1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -7101,15 +5151,6 @@ pub mod UniswapV3Pool {
                     }
                     fee
                 },
-                {
-                    fn feeGrowthGlobal0X128(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(UniswapV3PoolCalls::feeGrowthGlobal0X128)
-                    }
-                    feeGrowthGlobal0X128
-                },
                 {
                     fn ticks(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <ticksCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -7183,24 +5224,6 @@ pub mod UniswapV3Pool {
                     }
                     observations
                 },
-                {
-                    fn increaseObservationCardinalityNext(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV3PoolCalls::increaseObservationCardinalityNext)
-                    }
-                    increaseObservationCardinalityNext
-                },
-                {
-                    fn slot0(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <slot0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV3PoolCalls::slot0)
-                    }
-                    slot0
-                },
                 {
                     fn mint(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -7208,17 +5231,6 @@ pub mod UniswapV3Pool {
                     }
                     mint
                 },
-                {
-                    fn feeGrowthGlobal1X128(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV3PoolCalls::feeGrowthGlobal1X128)
-                    }
-                    feeGrowthGlobal1X128
-                },
                 {
                     fn flash(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <flashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -7240,42 +5252,6 @@ pub mod UniswapV3Pool {
                     }
                     positions
                 },
-                {
-                    fn tickBitmap(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <tickBitmapCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV3PoolCalls::tickBitmap)
-                    }
-                    tickBitmap
-                },
-                {
-                    fn maxLiquidityPerTick(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV3PoolCalls::maxLiquidityPerTick)
-                    }
-                    maxLiquidityPerTick
-                },
-                {
-                    fn setFeeProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV3PoolCalls::setFeeProtocol)
-                    }
-                    setFeeProtocol
-                },
-                {
-                    fn collectProtocol(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <collectProtocolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                            data,
-                        )
-                        .map(UniswapV3PoolCalls::collectProtocol)
-                    }
-                    collectProtocol
-                },
                 {
                     fn observe(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <observeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -7290,17 +5266,6 @@ pub mod UniswapV3Pool {
                     }
                     burn
                 },
-                {
-                    fn snapshotCumulativesInside(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV3PoolCalls::snapshotCumulativesInside)
-                    }
-                    snapshotCumulativesInside
-                },
                 {
                     fn factory(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <factoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -7308,13 +5273,6 @@ pub mod UniswapV3Pool {
                     }
                     factory
                 },
-                {
-                    fn tickSpacing(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <tickSpacingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(UniswapV3PoolCalls::tickSpacing)
-                    }
-                    tickSpacing
-                },
                 {
                     fn token1(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <token1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -7329,17 +5287,6 @@ pub mod UniswapV3Pool {
                     }
                     fee
                 },
-                {
-                    fn feeGrowthGlobal0X128(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
-                        <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV3PoolCalls::feeGrowthGlobal0X128)
-                    }
-                    feeGrowthGlobal0X128
-                },
                 {
                     fn ticks(data: &[u8]) -> alloy_sol_types::Result<UniswapV3PoolCalls> {
                         <ticksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
@@ -7373,53 +5320,24 @@ pub mod UniswapV3Pool {
                 Self::collect(inner) => {
                     <collectCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::collectProtocol(inner) => {
-                    <collectProtocolCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::fee(inner) => {
-                    <feeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::feeGrowthGlobal0X128(inner) => {
-                    <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::feeGrowthGlobal1X128(inner) => {
-                    <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
+                Self::fee(inner) => <feeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner),
                 Self::flash(inner) => {
                     <flashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::increaseObservationCardinalityNext(inner) => {
-                    <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::initialize(inner) => {
                     <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::liquidity(inner) => {
                     <liquidityCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::maxLiquidityPerTick(inner) => {
-                    <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::observations(inner) => {
-                    <observationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <observationsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::observe(inner) => {
                     <observeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
@@ -7428,34 +5346,11 @@ pub mod UniswapV3Pool {
                     <positionsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::protocolFees(inner) => {
-                    <protocolFeesCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::setFeeProtocol(inner) => {
-                    <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
-                Self::slot0(inner) => {
-                    <slot0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::snapshotCumulativesInside(inner) => {
-                    <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
+                    <protocolFeesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::tickBitmap(inner) => {
-                    <tickBitmapCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
-                Self::tickSpacing(inner) => {
-                    <tickSpacingCall as alloy_sol_types::SolCall>::abi_encoded_size(
-                        inner,
-                    )
-                }
                 Self::ticks(inner) => {
                     <ticksCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -7477,111 +5372,39 @@ pub mod UniswapV3Pool {
                 Self::collect(inner) => {
                     <collectCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::collectProtocol(inner) => {
-                    <collectProtocolCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::factory(inner) => {
                     <factoryCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::fee(inner) => {
                     <feeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::feeGrowthGlobal0X128(inner) => {
-                    <feeGrowthGlobal0X128Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::feeGrowthGlobal1X128(inner) => {
-                    <feeGrowthGlobal1X128Call as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::flash(inner) => {
                     <flashCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::increaseObservationCardinalityNext(inner) => {
-                    <increaseObservationCardinalityNextCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::initialize(inner) => {
-                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::liquidity(inner) => {
-                    <liquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::maxLiquidityPerTick(inner) => {
-                    <maxLiquidityPerTickCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <liquidityCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::mint(inner) => {
                     <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::observations(inner) => {
-                    <observationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <observationsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::observe(inner) => {
                     <observeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::positions(inner) => {
-                    <positionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <positionsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::protocolFees(inner) => {
-                    <protocolFeesCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::setFeeProtocol(inner) => {
-                    <setFeeProtocolCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::slot0(inner) => {
-                    <slot0Call as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
-                Self::snapshotCumulativesInside(inner) => {
-                    <snapshotCumulativesInsideCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
+                    <protocolFeesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
                 Self::swap(inner) => {
                     <swapCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::tickBitmap(inner) => {
-                    <tickBitmapCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
-                Self::tickSpacing(inner) => {
-                    <tickSpacingCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner,
-                        out,
-                    )
-                }
                 Self::ticks(inner) => {
                     <ticksCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -7977,20 +5800,6 @@ pub mod UniswapV3Pool {
             })
         }
 
-        ///Creates a new call builder for the [`collectProtocol`] function.
-        pub fn collectProtocol(
-            &self,
-            recipient: alloy_sol_types::private::Address,
-            amount0Requested: u128,
-            amount1Requested: u128,
-        ) -> alloy_contract::SolCallBuilder<&P, collectProtocolCall, N> {
-            self.call_builder(&collectProtocolCall {
-                recipient,
-                amount0Requested,
-                amount1Requested,
-            })
-        }
-
         ///Creates a new call builder for the [`factory`] function.
         pub fn factory(&self) -> alloy_contract::SolCallBuilder<&P, factoryCall, N> {
             self.call_builder(&factoryCall)
@@ -8001,22 +5810,6 @@ pub mod UniswapV3Pool {
             self.call_builder(&feeCall)
         }
 
-        ///Creates a new call builder for the [`feeGrowthGlobal0X128`]
-        /// function.
-        pub fn feeGrowthGlobal0X128(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, feeGrowthGlobal0X128Call, N> {
-            self.call_builder(&feeGrowthGlobal0X128Call)
-        }
-
-        ///Creates a new call builder for the [`feeGrowthGlobal1X128`]
-        /// function.
-        pub fn feeGrowthGlobal1X128(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, feeGrowthGlobal1X128Call, N> {
-            self.call_builder(&feeGrowthGlobal1X128Call)
-        }
-
         ///Creates a new call builder for the [`flash`] function.
         pub fn flash(
             &self,
@@ -8033,17 +5826,6 @@ pub mod UniswapV3Pool {
             })
         }
 
-        ///Creates a new call builder for the
-        /// [`increaseObservationCardinalityNext`] function.
-        pub fn increaseObservationCardinalityNext(
-            &self,
-            observationCardinalityNext: u16,
-        ) -> alloy_contract::SolCallBuilder<&P, increaseObservationCardinalityNextCall, N> {
-            self.call_builder(&increaseObservationCardinalityNextCall {
-                observationCardinalityNext,
-            })
-        }
-
         ///Creates a new call builder for the [`initialize`] function.
         pub fn initialize(
             &self,
@@ -8057,13 +5839,6 @@ pub mod UniswapV3Pool {
             self.call_builder(&liquidityCall)
         }
 
-        ///Creates a new call builder for the [`maxLiquidityPerTick`] function.
-        pub fn maxLiquidityPerTick(
-            &self,
-        ) -> alloy_contract::SolCallBuilder<&P, maxLiquidityPerTickCall, N> {
-            self.call_builder(&maxLiquidityPerTickCall)
-        }
-
         ///Creates a new call builder for the [`mint`] function.
         pub fn mint(
             &self,
@@ -8111,36 +5886,6 @@ pub mod UniswapV3Pool {
             self.call_builder(&protocolFeesCall)
         }
 
-        ///Creates a new call builder for the [`setFeeProtocol`] function.
-        pub fn setFeeProtocol(
-            &self,
-            feeProtocol0: u8,
-            feeProtocol1: u8,
-        ) -> alloy_contract::SolCallBuilder<&P, setFeeProtocolCall, N> {
-            self.call_builder(&setFeeProtocolCall {
-                feeProtocol0,
-                feeProtocol1,
-            })
-        }
-
-        ///Creates a new call builder for the [`slot0`] function.
-        pub fn slot0(&self) -> alloy_contract::SolCallBuilder<&P, slot0Call, N> {
-            self.call_builder(&slot0Call)
-        }
-
-        ///Creates a new call builder for the [`snapshotCumulativesInside`]
-        /// function.
-        pub fn snapshotCumulativesInside(
-            &self,
-            tickLower: alloy_sol_types::private::primitives::aliases::I24,
-            tickUpper: alloy_sol_types::private::primitives::aliases::I24,
-        ) -> alloy_contract::SolCallBuilder<&P, snapshotCumulativesInsideCall, N> {
-            self.call_builder(&snapshotCumulativesInsideCall {
-                tickLower,
-                tickUpper,
-            })
-        }
-
         ///Creates a new call builder for the [`swap`] function.
         pub fn swap(
             &self,
@@ -8159,16 +5904,6 @@ pub mod UniswapV3Pool {
             })
         }
 
-        ///Creates a new call builder for the [`tickBitmap`] function.
-        pub fn tickBitmap(&self, _0: i16) -> alloy_contract::SolCallBuilder<&P, tickBitmapCall, N> {
-            self.call_builder(&tickBitmapCall(_0))
-        }
-
-        ///Creates a new call builder for the [`tickSpacing`] function.
-        pub fn tickSpacing(&self) -> alloy_contract::SolCallBuilder<&P, tickSpacingCall, N> {
-            self.call_builder(&tickSpacingCall)
-        }
-
         ///Creates a new call builder for the [`ticks`] function.
         pub fn ticks(
             &self,
diff --git a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
index f9d342e7ed..79d6ecd088 100644
--- a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
@@ -742,7 +742,6 @@ interface UniswapV3QuoterV2 {
     function quoteExactInputSingle(IQuoterV2.QuoteExactInputSingleParams memory params) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
     function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn, uint160[] memory sqrtPriceX96AfterList, uint32[] memory initializedTicksCrossedList, uint256 gasEstimate);
     function quoteExactOutputSingle(IQuoterV2.QuoteExactOutputSingleParams memory params) external returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
-    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory path) external view;
 }
 ```
 
@@ -990,29 +989,6 @@ interface UniswapV3QuoterV2 {
       }
     ],
     "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "uniswapV3SwapCallback",
-    "inputs": [
-      {
-        "name": "amount0Delta",
-        "type": "int256",
-        "internalType": "int256"
-      },
-      {
-        "name": "amount1Delta",
-        "type": "int256",
-        "internalType": "int256"
-      },
-      {
-        "name": "path",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "view"
   }
 ]
 ```*/
@@ -2172,172 +2148,6 @@ pub mod UniswapV3QuoterV2 {
             }
         }
     };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `uniswapV3SwapCallback(int256,int256,bytes)` and selector `0xfa461e33`.
-    ```solidity
-    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory path) external view;
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct uniswapV3SwapCallbackCall {
-        #[allow(missing_docs)]
-        pub amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
-        #[allow(missing_docs)]
-        pub amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
-        #[allow(missing_docs)]
-        pub path: alloy_sol_types::private::Bytes,
-    }
-    ///Container type for the return parameters of the
-    /// [`uniswapV3SwapCallback(int256,int256,
-    /// bytes)`](uniswapV3SwapCallbackCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct uniswapV3SwapCallbackReturn {}
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (
-                alloy_sol_types::private::primitives::aliases::I256,
-                alloy_sol_types::private::primitives::aliases::I256,
-                alloy_sol_types::private::Bytes,
-            );
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<uniswapV3SwapCallbackCall> for UnderlyingRustTuple<'_> {
-                fn from(value: uniswapV3SwapCallbackCall) -> Self {
-                    (value.amount0Delta, value.amount1Delta, value.path)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {
-                        amount0Delta: tuple.0,
-                        amount1Delta: tuple.1,
-                        path: tuple.2,
-                    }
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<uniswapV3SwapCallbackReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: uniswapV3SwapCallbackReturn) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for uniswapV3SwapCallbackReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self {}
-                }
-            }
-        }
-        impl uniswapV3SwapCallbackReturn {
-            fn _tokenize(
-                &self,
-            ) -> <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::ReturnToken<'_>
-            {
-                ()
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for uniswapV3SwapCallbackCall {
-            type Parameters<'a> = (
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Int<256>,
-                alloy_sol_types::sol_data::Bytes,
-            );
-            type Return = uniswapV3SwapCallbackReturn;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = ();
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [250u8, 70u8, 30u8, 51u8];
-            const SIGNATURE: &'static str = "uniswapV3SwapCallback(int256,int256,bytes)";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                (
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount0Delta,
-                    ),
-                    <alloy_sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
-                        &self.amount1Delta,
-                    ),
-                    <alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
-                        &self.path,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                uniswapV3SwapCallbackReturn::_tokenize(ret)
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
-                    .map(Into::into)
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(Into::into)
-            }
-        }
-    };
     ///Container for all the [`UniswapV3QuoterV2`](self) function calls.
     #[derive(Clone)]
     pub enum UniswapV3QuoterV2Calls {
@@ -2353,8 +2163,6 @@ pub mod UniswapV3QuoterV2 {
         quoteExactOutput(quoteExactOutputCall),
         #[allow(missing_docs)]
         quoteExactOutputSingle(quoteExactOutputSingleCall),
-        #[allow(missing_docs)]
-        uniswapV3SwapCallback(uniswapV3SwapCallbackCall),
     }
     impl UniswapV3QuoterV2Calls {
         /// All the selectors of this enum.
@@ -2371,7 +2179,6 @@ pub mod UniswapV3QuoterV2 {
             [196u8, 90u8, 1u8, 85u8],
             [198u8, 165u8, 2u8, 106u8],
             [205u8, 202u8, 23u8, 83u8],
-            [250u8, 70u8, 30u8, 51u8],
         ];
         /// The signatures in the same order as `SELECTORS`.
         pub const SIGNATURES: &'static [&'static str] = &[
@@ -2381,7 +2188,6 @@ pub mod UniswapV3QuoterV2 {
             <factoryCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteExactInputSingleCall as alloy_sol_types::SolCall>::SIGNATURE,
             <quoteExactInputCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SIGNATURE,
         ];
         /// The names of the variants in the same order as `SELECTORS`.
         pub const VARIANT_NAMES: &'static [&'static str] = &[
@@ -2391,7 +2197,6 @@ pub mod UniswapV3QuoterV2 {
             ::core::stringify!(factory),
             ::core::stringify!(quoteExactInputSingle),
             ::core::stringify!(quoteExactInput),
-            ::core::stringify!(uniswapV3SwapCallback),
         ];
 
         /// Returns the signature for the given selector, if known.
@@ -2416,7 +2221,7 @@ pub mod UniswapV3QuoterV2 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for UniswapV3QuoterV2Calls {
-        const COUNT: usize = 7usize;
+        const COUNT: usize = 6usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "UniswapV3QuoterV2Calls";
 
@@ -2437,9 +2242,6 @@ pub mod UniswapV3QuoterV2 {
                 Self::quoteExactOutputSingle(_) => {
                     <quoteExactOutputSingleCall as alloy_sol_types::SolCall>::SELECTOR
                 }
-                Self::uniswapV3SwapCallback(_) => {
-                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::SELECTOR
-                }
             }
         }
 
@@ -2516,18 +2318,6 @@ pub mod UniswapV3QuoterV2 {
                         }
                         quoteExactInput
                     },
-                    {
-                        fn uniswapV3SwapCallback(
-                            data: &[u8],
-                        ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls>
-                        {
-                            <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw(
-                                data,
-                            )
-                            .map(UniswapV3QuoterV2Calls::uniswapV3SwapCallback)
-                        }
-                        uniswapV3SwapCallback
-                    },
                 ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2607,17 +2397,6 @@ pub mod UniswapV3QuoterV2 {
                     }
                     quoteExactInput
                 },
-                {
-                    fn uniswapV3SwapCallback(
-                        data: &[u8],
-                    ) -> alloy_sol_types::Result<UniswapV3QuoterV2Calls> {
-                        <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
-                                data,
-                            )
-                            .map(UniswapV3QuoterV2Calls::uniswapV3SwapCallback)
-                    }
-                    uniswapV3SwapCallback
-                },
             ];
             let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
                 return Err(alloy_sol_types::Error::unknown_selector(
@@ -2651,9 +2430,6 @@ pub mod UniswapV3QuoterV2 {
                         inner,
                     )
                 }
-                Self::uniswapV3SwapCallback(inner) => {
-                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
             }
         }
 
@@ -2682,11 +2458,6 @@ pub mod UniswapV3QuoterV2 {
                         inner, out,
                     )
                 }
-                Self::uniswapV3SwapCallback(inner) => {
-                    <uniswapV3SwapCallbackCall as alloy_sol_types::SolCall>::abi_encode_raw(
-                        inner, out,
-                    )
-                }
             }
         }
     }
@@ -2844,21 +2615,6 @@ pub mod UniswapV3QuoterV2 {
         ) -> alloy_contract::SolCallBuilder<&P, quoteExactOutputSingleCall, N> {
             self.call_builder(&quoteExactOutputSingleCall { params })
         }
-
-        ///Creates a new call builder for the [`uniswapV3SwapCallback`]
-        /// function.
-        pub fn uniswapV3SwapCallback(
-            &self,
-            amount0Delta: alloy_sol_types::private::primitives::aliases::I256,
-            amount1Delta: alloy_sol_types::private::primitives::aliases::I256,
-            path: alloy_sol_types::private::Bytes,
-        ) -> alloy_contract::SolCallBuilder<&P, uniswapV3SwapCallbackCall, N> {
-            self.call_builder(&uniswapV3SwapCallbackCall {
-                amount0Delta,
-                amount1Delta,
-                path,
-            })
-        }
     }
     /// Event filters.
     impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
diff --git a/contracts/generated/contracts-generated/weth9/src/lib.rs b/contracts/generated/contracts-generated/weth9/src/lib.rs
index 7e647d9e38..dc0b098bb5 100644
--- a/contracts/generated/contracts-generated/weth9/src/lib.rs
+++ b/contracts/generated/contracts-generated/weth9/src/lib.rs
@@ -25,7 +25,6 @@ interface WETH9 {
     function deposit() external payable;
     function name() external view returns (string memory);
     function symbol() external view returns (string memory);
-    function totalSupply() external view returns (uint256);
     function transfer(address dst, uint256 wad) external returns (bool);
     function transferFrom(address src, address dst, uint256 wad) external returns (bool);
     function withdraw(uint256 wad) external;
@@ -141,18 +140,6 @@ interface WETH9 {
     ],
     "stateMutability": "view"
   },
-  {
-    "type": "function",
-    "name": "totalSupply",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "transfer",
@@ -1800,145 +1787,6 @@ pub mod WETH9 {
         }
     };
     #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    /**Function with signature `totalSupply()` and selector `0x18160ddd`.
-    ```solidity
-    function totalSupply() external view returns (uint256);
-    ```*/
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyCall;
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
-    ///Container type for the return parameters of the
-    /// [`totalSupply()`](totalSupplyCall) function.
-    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
-    #[derive(Clone)]
-    pub struct totalSupplyReturn {
-        #[allow(missing_docs)]
-        pub _0: alloy_sol_types::private::primitives::aliases::U256,
-    }
-    #[allow(
-        non_camel_case_types,
-        non_snake_case,
-        clippy::pub_underscore_fields,
-        clippy::style
-    )]
-    const _: () = {
-        use alloy_sol_types;
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = ();
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = ();
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyCall) -> Self {
-                    ()
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self
-                }
-            }
-        }
-        {
-            #[doc(hidden)]
-            #[allow(dead_code)]
-            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            #[doc(hidden)]
-            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
-            #[cfg(test)]
-            #[allow(dead_code, unreachable_patterns)]
-            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
-                match _t {
-                    alloy_sol_types::private::AssertTypeEq::<
-                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
-                    >(_) => {}
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
-                fn from(value: totalSupplyReturn) -> Self {
-                    (value._0,)
-                }
-            }
-            #[automatically_derived]
-            #[doc(hidden)]
-            impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
-                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
-                    Self { _0: tuple.0 }
-                }
-            }
-        }
-        #[automatically_derived]
-        impl alloy_sol_types::SolCall for totalSupplyCall {
-            type Parameters<'a> = ();
-            type Return = alloy_sol_types::private::primitives::aliases::U256;
-            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
-            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
-            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
-
-            const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
-            const SIGNATURE: &'static str = "totalSupply()";
-
-            #[inline]
-            fn new<'a>(
-                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
-            ) -> Self {
-                tuple.into()
-            }
-
-            #[inline]
-            fn tokenize(&self) -> Self::Token<'_> {
-                ()
-            }
-
-            #[inline]
-            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
-                (
-                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
-                        ret,
-                    ),
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
-                    |r| {
-                        let r: totalSupplyReturn = r.into();
-                        r._0
-                    },
-                )
-            }
-
-            #[inline]
-            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
-                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
-                    data,
-                )
-                .map(|r| {
-                    let r: totalSupplyReturn = r.into();
-                    r._0
-                })
-            }
-        }
-    };
-    #[derive(Default, Debug, PartialEq, Eq, Hash)]
     /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
     ```solidity
     function transfer(address dst, uint256 wad) external returns (bool);
@@ -2419,8 +2267,6 @@ pub mod WETH9 {
         #[allow(missing_docs)]
         symbol(symbolCall),
         #[allow(missing_docs)]
-        totalSupply(totalSupplyCall),
-        #[allow(missing_docs)]
         transfer(transferCall),
         #[allow(missing_docs)]
         transferFrom(transferFromCall),
@@ -2438,7 +2284,6 @@ pub mod WETH9 {
         pub const SELECTORS: &'static [[u8; 4usize]] = &[
             [6u8, 253u8, 222u8, 3u8],
             [9u8, 94u8, 167u8, 179u8],
-            [24u8, 22u8, 13u8, 221u8],
             [35u8, 184u8, 114u8, 221u8],
             [46u8, 26u8, 125u8, 77u8],
             [49u8, 60u8, 229u8, 103u8],
@@ -2452,7 +2297,6 @@ pub mod WETH9 {
         pub const SIGNATURES: &'static [&'static str] = &[
             <nameCall as alloy_sol_types::SolCall>::SIGNATURE,
             <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
-            <totalSupplyCall as alloy_sol_types::SolCall>::SIGNATURE,
             <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
             <withdrawCall as alloy_sol_types::SolCall>::SIGNATURE,
             <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
@@ -2466,7 +2310,6 @@ pub mod WETH9 {
         pub const VARIANT_NAMES: &'static [&'static str] = &[
             ::core::stringify!(name),
             ::core::stringify!(approve),
-            ::core::stringify!(totalSupply),
             ::core::stringify!(transferFrom),
             ::core::stringify!(withdraw),
             ::core::stringify!(decimals),
@@ -2499,7 +2342,7 @@ pub mod WETH9 {
     }
     #[automatically_derived]
     impl alloy_sol_types::SolInterface for WETH9Calls {
-        const COUNT: usize = 11usize;
+        const COUNT: usize = 10usize;
         const MIN_DATA_LENGTH: usize = 0usize;
         const NAME: &'static str = "WETH9Calls";
 
@@ -2513,7 +2356,6 @@ pub mod WETH9 {
                 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
-                Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
                 Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
@@ -2548,13 +2390,6 @@ pub mod WETH9 {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
-                            .map(WETH9Calls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
@@ -2642,13 +2477,6 @@ pub mod WETH9 {
                     }
                     approve
                 },
-                {
-                    fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
-                        <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
-                            .map(WETH9Calls::totalSupply)
-                    }
-                    totalSupply
-                },
                 {
                     fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<WETH9Calls> {
                         <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
@@ -2741,9 +2569,6 @@ pub mod WETH9 {
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
                 }
@@ -2780,9 +2605,6 @@ pub mod WETH9 {
                 Self::symbol(inner) => {
                     <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
-                Self::totalSupply(inner) => {
-                    <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
-                }
                 Self::transfer(inner) => {
                     <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
                 }
@@ -3141,11 +2963,6 @@ pub mod WETH9 {
             self.call_builder(&symbolCall)
         }
 
-        ///Creates a new call builder for the [`totalSupply`] function.
-        pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
-            self.call_builder(&totalSupplyCall)
-        }
-
         ///Creates a new call builder for the [`transfer`] function.
         pub fn transfer(
             &self,

From ab8839815ffa859ae759a73953b87afca6544f33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Mon, 13 Apr 2026 13:38:55 +0100
Subject: [PATCH 196/219] Remove uniform clearing prices from winner selection
 (#4313)

# Description

Uniform clearing prices (UCP) are no longer part of the core CoW
Protocol scoring mechanism since CIP-67. In winner selection, the UCP
variables were already dead code (`_uniform_sell_price` /
`_uniform_buy_price`). All scoring uses
`calculate_custom_prices_from_executed()` from per-trade executed
amounts instead.

This is the first PR in a series to remove UCP from the entire backend.
It targets only the winner-selection crate and its integration points in
the autopilot, which is low-risk since the code was already unused.

# Changes

* Remove `prices: HashMap<Address, U256>` field and `prices()` accessor
from `winner_selection::Solution`
* Remove dead `_uniform_sell_price` / `_uniform_buy_price` lookups in
`compute_order_score()`
* Stop passing clearing prices when constructing `winsel::Solution` in
the autopilot
* Set `clearing_prices` to `Default::default()` in the run loop (kept to
avoid breaking the solver competition API)
* Update test in `settlement/mod.rs` to match new `Solution::new()`
signature

## How to test

1. `cargo nextest run -p winner-selection`
2. `cargo nextest run -p autopilot`
3. `cargo clippy --locked -p winner-selection -p autopilot
--all-features --all-targets -- -D warnings`

## Staging test

| Value | Before | After |
| --- | --- | --- |
| 0.1 |
[0x749d2](https://dev.explorer.cow.fi/orders/0x749d2c5ebf346a47be288f20d96ffab2dcafc2ff48eebccbe8f053f8d9a3832909fbad1ea29c36dfe4f8f7baa87c5edf85e0d9f369d78f53)
|
[0x13873](https://dev.explorer.cow.fi/orders/0x138734c29ac9fff883f5f6784e74a3ed3cbdf82c14b5f7e4a54b08fd04a6f78809fbad1ea29c36dfe4f8f7baa87c5edf85e0d9f369d78ee4)|
---
 .../domain/competition/winner_selection.rs    |  5 -----
 crates/autopilot/src/domain/settlement/mod.rs |  2 +-
 crates/autopilot/src/run_loop.rs              |  9 +++-----
 crates/winner-selection/src/arbitrator.rs     | 18 ++-------------
 crates/winner-selection/src/solution.rs       | 22 +------------------
 5 files changed, 7 insertions(+), 49 deletions(-)

diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 6fcf605c86..d779bd52ee 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -155,11 +155,6 @@ impl From<&Solution> for winsel::Solution<winsel::Unscored> {
                 .iter()
                 .map(|(uid, order)| to_winsel_order(*uid, order))
                 .collect(),
-            solution
-                .prices()
-                .iter()
-                .map(|(token, price)| (Address::from(*token), price.get().0))
-                .collect(),
         )
     }
 }
diff --git a/crates/autopilot/src/domain/settlement/mod.rs b/crates/autopilot/src/domain/settlement/mod.rs
index 1cddcf3b0b..40fd64de2f 100644
--- a/crates/autopilot/src/domain/settlement/mod.rs
+++ b/crates/autopilot/src/domain/settlement/mod.rs
@@ -400,7 +400,7 @@ mod tests {
                 .collect(),
             native_prices: prices.clone(),
         };
-        let solution = ws::Solution::new(0, ws::Address::ZERO, vec![order], prices);
+        let solution = ws::Solution::new(0, ws::Address::ZERO, vec![order]);
         let arbitrator = ws::Arbitrator {
             max_winners: 1,
             weth: ws::Address::ZERO,
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index e983feb808..f67b7dc6fe 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -492,12 +492,9 @@ impl RunLoop {
                         buy_amount: order.executed_buy.0,
                     })
                     .collect(),
-                clearing_prices: bid
-                    .solution()
-                    .prices()
-                    .iter()
-                    .map(|(token, price)| (Address::from(*token), price.get().0))
-                    .collect(),
+                // Always empty — kept to avoid breaking the solver competition
+                // API (`/api/v1/solver_competition`).
+                clearing_prices: Default::default(),
                 is_winner: bid.is_winner(),
                 filtered_out: bid.is_filtered_out(),
             })
diff --git a/crates/winner-selection/src/arbitrator.rs b/crates/winner-selection/src/arbitrator.rs
index 446df78572..3a41651732 100644
--- a/crates/winner-selection/src/arbitrator.rs
+++ b/crates/winner-selection/src/arbitrator.rs
@@ -182,7 +182,7 @@ impl Arbitrator {
                 continue;
             }
 
-            let score = self.compute_order_score(order, solution, context)?;
+            let score = self.compute_order_score(order, context)?;
 
             let token_pair = DirectedTokenPair {
                 sell: order.sell_token,
@@ -202,26 +202,12 @@ impl Arbitrator {
     /// Follows CIP-38 as the base of the score computation.
     ///
     /// Denominated in NATIVE token.
-    fn compute_order_score<T>(
-        &self,
-        order: &Order,
-        solution: &Solution<T>,
-        context: &AuctionContext,
-    ) -> Result<U256> {
+    fn compute_order_score(&self, order: &Order, context: &AuctionContext) -> Result<U256> {
         let native_price_buy = context
             .native_prices
             .get(&order.buy_token)
             .context("missing native price for buy token")?;
 
-        let _uniform_sell_price = solution
-            .prices()
-            .get(&order.sell_token)
-            .context("missing uniform clearing price for sell token")?;
-        let _uniform_buy_price = solution
-            .prices()
-            .get(&order.buy_token)
-            .context("missing uniform clearing price for buy token")?;
-
         let custom_prices = self.calculate_custom_prices_from_executed(order);
 
         // Calculate surplus in surplus token (buy token for sell orders, sell token for
diff --git a/crates/winner-selection/src/solution.rs b/crates/winner-selection/src/solution.rs
index 4996335d86..f3f816fa1b 100644
--- a/crates/winner-selection/src/solution.rs
+++ b/crates/winner-selection/src/solution.rs
@@ -10,7 +10,6 @@ use {
         state,
     },
     alloy_primitives::{Address, U256},
-    std::collections::HashMap,
 };
 pub type Scored = state::Scored<U256>;
 pub type Ranked = state::Ranked<U256>;
@@ -30,13 +29,6 @@ pub struct Solution<State> {
     /// Orders executed in this solution.
     orders: Vec<Order>,
 
-    /// Uniform clearing prices for all tokens in the solution.
-    ///
-    /// Maps token address to its price in the native token.
-    /// These are the prices at which all orders trading these tokens are
-    /// settled.
-    prices: HashMap<Address, U256>,
-
     /// State marker (score and ranking information).
     state: State,
 }
@@ -56,11 +48,6 @@ impl<T> Solution<T> {
     pub fn orders(&self) -> &[Order] {
         &self.orders
     }
-
-    /// Get the clearing prices.
-    pub fn prices(&self) -> &HashMap<Address, U256> {
-        &self.prices
-    }
 }
 
 impl<State> state::HasState for Solution<State> {
@@ -72,7 +59,6 @@ impl<State> state::HasState for Solution<State> {
             id: self.id,
             solver: self.solver,
             orders: self.orders,
-            prices: self.prices,
             state,
         }
     }
@@ -84,17 +70,11 @@ impl<State> state::HasState for Solution<State> {
 
 impl Solution<Unscored> {
     /// Create a new unscored solution.
-    pub fn new(
-        id: u64,
-        solver: Address,
-        orders: Vec<Order>,
-        prices: HashMap<Address, U256>,
-    ) -> Self {
+    pub fn new(id: u64, solver: Address, orders: Vec<Order>) -> Self {
         Self {
             id,
             solver,
             orders,
-            prices,
             state: Unscored,
         }
     }

From 6cb520f05f38a611daff36c0859ec7c20159b7c6 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Mon, 13 Apr 2026 15:15:24 +0200
Subject: [PATCH 197/219] Update claude's log instructions (#4319)

# Description

Instruct Claude to use MPC to access logs instead of using helper
script.
---
 CLAUDE.md                     | 55 +++++++++++++++-----
 docs/COW_ORDER_DEBUG_SKILL.md | 95 +++++++++++++++++++----------------
 scripts/vlogs                 | 84 -------------------------------
 3 files changed, 95 insertions(+), 139 deletions(-)
 delete mode 100755 scripts/vlogs

diff --git a/CLAUDE.md b/CLAUDE.md
index 9ee0767c07..45269b7fd2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -182,26 +182,55 @@ Databases: `mainnet`, `arbitrum-one`, `base`, `linea`, `polygon`, `xdai`, `sepol
 
 Use `$ETH_MAINNET_RPC` from `.env.claude` for mainnet. Use `cast` or whatever tools you want freely.
 
-## Grafana Logs Access
+## Victoria Logs Access
 
-Use the `scripts/vlogs` wrapper to query Victoria Logs.
+Use the `CoW-Prod` MCP tools to query Victoria Logs directly.
 
-**IMPORTANT**: When running `scripts/vlogs`, do NOT use bash comments before the command (e.g., `# comment\nscripts/vlogs ...`) as this causes unnecessary permission prompts. Just run the command directly.
+**Timestamps**: MCP requires RFC3339 format (e.g., `2026-04-09T00:00:00Z`). Compute absolute timestamps from the current date rather than using relative time.
 
-**IMPORTANT**: Order UIDs and other structured fields (like `quote_id`, `auction_id`) live inside the `all` field in Victoria Logs. You MUST prefix them with `all:` to match. Plain text terms (like `order created`, `filtered`) match the log message directly and don't need the prefix.
+**IMPORTANT**: Order UIDs and other structured fields (like `quote_id`, `auction_id`) live inside the `all` field in Victoria Logs. You MUST prefix them with `all:` to match. Plain text terms (like `order created`, `filtered`) match the log message directly and don't need the prefix. You can also use parsed fields directly (e.g., `parsed.fields.order_uid:0x...`) for more precise matching.
 
-```bash
-scripts/vlogs "<expr>" [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]
+**IMPORTANT — Protect context window**: Raw log entries contain ~4KB of kubernetes/ec2 metadata each. **Always** append `| fields _time, _msg, all` (or specific `parsed.fields.*`) to strip noise. Use small `limit` values (10-20) and only increase if needed. Examples:
+- General order search: `... | fields _time, _msg, all`
+- When you only need specific parsed fields: `... | fields _time, _msg, parsed.fields.err, parsed.fields.driver, parsed.spans.auction.auction_id`
 
-scripts/vlogs "NOT container:controller order created all:0xabc..." --from now-24h
-scripts/vlogs "NOT container:controller network:mainnet settlement failed" --from now-6h --max 50
-scripts/vlogs "error" --env staging --from now-1h
-scripts/vlogs "NOT container:controller all:0xabc..." --raw
-```
+**Available MCP tools:**
+- `victorialogs_query` — Main log search (LogsQL expression + time range + limit)
+- `victorialogs_hits` — Count matching logs grouped by time buckets
+- `victorialogs_field_names` / `victorialogs_field_values` — Explore available fields
+- `victorialogs_facets` — Most frequent values per field
+- `victorialogs_stats_query` / `victorialogs_stats_query_range` — Aggregation queries
+- `victorialogs_stream_field_names` / `victorialogs_stream_field_values` — Stream metadata
 
-Defaults: `--from now-12h`, `--to now`, `--max 100`, `--env prod`
+**Key fields:**
+- Stream fields (efficient filters): `container`, `namespace`, `pod`
+- `network` — chain name (mainnet, arbitrum-one, base, etc.)
+- `all` — full structured JSON log (search with `all:` prefix for UIDs)
+- `parsed.fields.*` — individual parsed fields (e.g., `parsed.fields.order_uid`, `parsed.fields.quote_id`)
+- `_msg` — the log message text
 
-Datasource UIDs (hardcoded in script): `vm-auth-prod` (production), `vm-auth-staging` (staging)
+**Example queries:**
+```
+# Search for order logs (exclude nginx controller, strip metadata)
+query: "container:!controller AND network:mainnet AND all:0xabc... | fields _time, _msg, all"
+start: "<COMPUTED_RFC3339>"
+limit: 20
+
+# Search for order creation on mainnet
+query: "container:!controller AND network:mainnet AND \"order created\" AND all:0xabc... | fields _time, _msg, all"
+start: "<COMPUTED_RFC3339>"
+limit: 10
+
+# Settlement failures with just error details
+query: "container:!controller AND network:mainnet AND \"settlement failed\" | fields _time, _msg, parsed.fields.err, parsed.fields.driver, parsed.spans.auction.auction_id"
+start: "<COMPUTED_RFC3339>"
+limit: 10
+
+# Sort results by time
+query: "container:!controller AND network:mainnet AND all:0xabc... | fields _time, _msg, all | sort by (_time) asc"
+start: "<COMPUTED_RFC3339>"
+limit: 20
+```
 
 ## Etherscan API (V2)
 
diff --git a/docs/COW_ORDER_DEBUG_SKILL.md b/docs/COW_ORDER_DEBUG_SKILL.md
index 46f8706420..387b8d66ae 100644
--- a/docs/COW_ORDER_DEBUG_SKILL.md
+++ b/docs/COW_ORDER_DEBUG_SKILL.md
@@ -1,13 +1,13 @@
 # CoW Protocol Order Debug Skill
 
-Debug why CoW Protocol orders fail to match. Requires DB access + Victoria Logs access (via Grafana).
+Debug why CoW Protocol orders fail to match. Requires DB access + Victoria Logs access (via CoW-Prod MCP).
 
 ## Quick Checklist
 
 Run through these in order:
 
 1. [ ] **Order status** — Check API status first (cancelled/expired/fulfilled/open)
-2. [ ] **User cancellation** — If cancelled, search logs for `order cancelled all:ORDER_UID` FIRST
+2. [ ] **User cancellation** — If cancelled, search logs for `"order cancelled" AND all:ORDER_UID` FIRST
 3. [ ] **Order in auction** — Was order in autopilot auction? When?
 4. [ ] **Solver bids** — Did any solver bid? What happened to their solution?
 5. [ ] **Settlement outcome** — Did settlement succeed/fail/timeout?
@@ -81,43 +81,54 @@ cast call $SETTLEMENT_CONTRACT "preSignature(bytes)" $ORDER_UID --rpc-url $RPC
 
 ---
 
-## 3. Check Logs (Victoria Logs via Grafana)
+## 3. Check Logs (Victoria Logs via MCP)
 
-Logs are stored in Victoria Logs and accessible via Grafana API.
+Logs are stored in Victoria Logs and accessible via the `CoW-Prod` MCP tools. Use `mcp__CoW-Prod__victorialogs_query` for log searches. Timestamps must be RFC3339 format (compute from current date).
 
-**Query using `scripts/vlogs`:**
-```bash
-scripts/vlogs "NOT container:controller all:ORDER_UID"
+**IMPORTANT — Protect context window**: Always append `| fields _time, _msg, all` to queries to strip kubernetes/ec2 metadata (~4KB per entry). Use small `limit` values (10-20). When you only need specific fields, use `| fields _time, _msg, parsed.fields.err, parsed.fields.driver` etc.
+
+**Example queries (use `victorialogs_query` tool):**
+```
+# All order logs (exclude nginx controller, filter by network, strip metadata)
+query: "container:!controller AND network:$NETWORK AND all:ORDER_UID | fields _time, _msg, all"
+start: "<24h-ago-RFC3339>"
+limit: 20
 
-scripts/vlogs "NOT container:controller network:bnb all:ORDER_UID"
+# Search by quote ID
+query: "container:!controller AND network:$NETWORK AND all:22788649 | fields _time, _msg, all"
 
-scripts/vlogs "NOT container:controller all:22788649"
+# Search specific solver
+query: "container:!controller AND network:$NETWORK AND baseline AND all:22788649 | fields _time, _msg, all"
+```
+
+**Useful filters (part of the LogsQL expression):**
+- `container:!controller` — excludes nginx access logs (REQUIRED for order UID searches)
+- `network:$NETWORK` — **always include when debugging an order** to filter by chain (mainnet, bnb, arbitrum-one, base, etc). Reduces noise and speeds up queries.
+- `all:` — prefix for searching structured fields (order UIDs, auction IDs, quote IDs). Without a field prefix, Victoria Logs only searches the log message text, not structured fields. You can also use `parsed.fields.order_uid:0x...` for precise matching, but `all:` works universally.
+- `| fields _time, _msg, all` — **always append** to strip k8s metadata and protect context window
 
-scripts/vlogs "NOT container:controller baseline all:22788649"
+**Note:** Always use the **full order UID with 0x prefix** and the `all:` field prefix for reliable matching.
 
-scripts/vlogs "NOT container:controller all:ORDER_UID" --from now-24h --max 200
+**IMPORTANT - Run targeted lifecycle queries in parallel** (use FULL order UID with 0x). Call multiple `victorialogs_query` MCP tools simultaneously. Always include `network:$NETWORK` and `| fields` pipe:
 
-scripts/vlogs "NOT container:controller all:ORDER_UID" --raw
 ```
+# Order creation
+query: "container:!controller AND network:$NETWORK AND \"order created\" AND all:ORDER_UID | fields _time, _msg, all"
 
-**Useful filters (part of the expr):**
-- `NOT container:controller` — excludes nginx access logs (REQUIRED for order UID searches)
-- `network:$NETWORK` — filter by chain (mainnet, bnb, arbitrum-one, base, etc)
-- `all:` — prefix for searching structured fields (order UIDs, auction IDs, quote IDs). Without a field prefix, Victoria Logs only searches the log message text, not structured fields. You can also use specific field names (e.g., `order_uid:0x...`) but `all:` works universally.
+# Order cancellation
+query: "container:!controller AND network:$NETWORK AND \"order cancelled\" AND all:ORDER_UID | fields _time, _msg, all"
 
-**Note:** Always use the **full order UID with 0x prefix** and the `all:` field prefix for reliable matching.
+# Proposed solutions
+query: "container:!controller AND network:$NETWORK AND \"proposed solution\" AND all:ORDER_UID | fields _time, _msg, all"
 
-**IMPORTANT - Run targeted lifecycle queries in parallel** (use FULL order UID with 0x):
+# Settlement failures (use specific parsed fields for concise output)
+query: "container:!controller AND network:$NETWORK AND \"settlement failed\" AND all:ORDER_UID | fields _time, _msg, parsed.fields.err, parsed.fields.driver, parsed.spans.auction.auction_id"
 
-```bash
-scripts/vlogs "NOT container:controller order created all:ORDER_UID"
-scripts/vlogs "NOT container:controller order cancelled all:ORDER_UID"
-scripts/vlogs "NOT container:controller proposed solution all:ORDER_UID"
-scripts/vlogs "NOT container:controller settlement failed all:ORDER_UID"
-scripts/vlogs "NOT container:controller filtered all:ORDER_UID"
+# Filtering
+query: "container:!controller AND network:$NETWORK AND filtered AND all:ORDER_UID | fields _time, _msg, all"
 
-# Find discarded solutions where order appears in calldata (use order UID bytes without 0x prefix)
-scripts/vlogs "discarded all:ORDER_UID_WITHOUT_0X"
+# Find discarded solutions (use order UID bytes without 0x prefix)
+query: "container:!controller AND network:$NETWORK AND discarded AND all:ORDER_UID_WITHOUT_0X | fields _time, _msg, all"
 ```
 
 **What to look for:**
@@ -191,10 +202,10 @@ WHERE oq.order_uid = '\x$ORDER_UID_HEX';
 ```
 
 ### Method 3: Logs (fallback)
-Find the quote_id from the "order created" log:
+Find the quote_id from the "order created" log using `victorialogs_query`:
 
-```bash
-scripts/vlogs "NOT container:controller order created all:ORDER_UID"
+```
+query: "container:!controller AND network:$NETWORK AND \"order created\" AND all:ORDER_UID | fields _time, _msg, all"
 ```
 
 **Example log line:**
@@ -203,8 +214,8 @@ orderbook::api::post_order: order created order_uid=0x... quote_id=Some(2720468)
 ```
 
 Then search for quote details by ID:
-```bash
-scripts/vlogs "NOT container:controller all:$QUOTE_ID"
+```
+query: "container:!controller AND network:$NETWORK AND all:$QUOTE_ID | fields _time, _msg, all"
 ```
 
 ---
@@ -297,13 +308,13 @@ surplusFeeTimestamp is within last 10 minutes
 ```
 
 **If missing/stale, check surplus fee computation logs:**
-```bash
-scripts/vlogs "surplus_fee all:ORDER_UID"
+```
+query: "network:$NETWORK AND surplus_fee AND all:ORDER_UID | fields _time, _msg, all"
 ```
 
 **Surplus fee error logs:**
-```bash
-scripts/vlogs "surplus_fee error"
+```
+query: "network:$NETWORK AND surplus_fee AND error | fields _time, _msg, all"
 ```
 
 ### 9.2 Auction Filtering Check
@@ -314,8 +325,8 @@ curl -s "https://api.cow.fi/$NETWORK/api/v1/auction" | jq '.orders[] | select(.u
 ```
 
 If not present, order is filtered. Check filter logs:
-```bash
-scripts/vlogs "filtered all:ORDER_UID"
+```
+query: "network:$NETWORK AND filtered AND all:ORDER_UID | fields _time, _msg, all"
 ```
 
 **Common filter reasons:**
@@ -403,13 +414,13 @@ settle(
 Order is in auction but still not matching?
 
 **Auction orders log:**
-```bash
-scripts/vlogs "all:$AUCTION_ID"
+```
+query: "network:$NETWORK AND all:$AUCTION_ID | fields _time, _msg, all"
 ```
 
 **Specific auction run:**
-```bash
-scripts/vlogs "all:$RUN_ID"
+```
+query: "network:$NETWORK AND all:$RUN_ID | fields _time, _msg, all"
 ```
 
 ### JIT Orders & CoW AMMs
@@ -560,7 +571,7 @@ curl -s "https://api.cow.fi/$NETWORK/api/v1/app_data/$APP_DATA_HASH"
 | Resource | URL |
 |----------|-----|
 | Order Explorer | `https://explorer.cow.fi/orders/$ORDER_UID` |
-| Grafana Logs (Victoria Logs) | `$GRAFANA_URL/explore` (see .env.claude) |
+| Victoria Logs | Via `CoW-Prod` MCP tools (`victorialogs_query`, etc.) |
 | API Docs | `https://api.cow.fi/docs/` |
 | Block-to-Date | `https://etherscan.io/blockdateconverter` |
 | Barn (Staging) | `https://barn.cow.fi` |
diff --git a/scripts/vlogs b/scripts/vlogs
deleted file mode 100755
index 048ae26720..0000000000
--- a/scripts/vlogs
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/env bash
-# Query Victoria Logs via Grafana API
-# Usage: vlogs <expr> [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]
-#
-# Examples:
-#   vlogs "order cancelled 0xabc123..."
-#   vlogs "NOT container:controller order created" --from now-24h --max 50
-#   vlogs "network:mainnet settlement failed" --from now-6h --env prod
-#   vlogs "error" --raw   # output full JSON instead of just log lines
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-source "$SCRIPT_DIR/.env.claude"
-
-# Defaults
-FROM="now-12h"
-TO="now"
-MAX_LINES=100
-ENV="prod"
-RAW=false
-
-# Parse arguments
-EXPR=""
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --from) FROM="$2"; shift 2 ;;
-    --to) TO="$2"; shift 2 ;;
-    --max) MAX_LINES="$2"; shift 2 ;;
-    --env) ENV="$2"; shift 2 ;;
-    --raw) RAW=true; shift ;;
-    --help|-h)
-      sed -n '2,8p' "$0"
-      exit 0
-      ;;
-    *)
-      if [[ -z "$EXPR" ]]; then
-        EXPR="$1"
-      else
-        EXPR="$EXPR $1"
-      fi
-      shift
-      ;;
-  esac
-done
-
-if [[ -z "$EXPR" ]]; then
-  echo "Usage: vlogs <expr> [--from <time>] [--to <time>] [--max <lines>] [--env <prod|staging>] [--raw]" >&2
-  exit 1
-fi
-
-case "$ENV" in
-  prod)    DS_UID="vm-auth-prod" ;;
-  staging) DS_UID="vm-auth-staging" ;;
-  *)       echo "Unknown env: $ENV (use prod or staging)" >&2; exit 1 ;;
-esac
-
-PAYLOAD=$(jq -n \
-  --arg uid "$DS_UID" \
-  --arg expr "$EXPR | sort by (_time) asc" \
-  --argjson maxLines "$MAX_LINES" \
-  --arg from "$FROM" \
-  --arg to "$TO" \
-  '{queries: [{refId: "A", datasource: {type: "victoriametrics-logs-datasource", uid: $uid}, expr: $expr, queryType: "instant", maxLines: $maxLines}], from: $from, to: $to}')
-
-RESPONSE=$(curl -s --max-time 60 \
-  "${GRAFANA_URL}/api/ds/query?ds_type=victoriametrics-logs-datasource" \
-  -H 'content-type: application/json' \
-  -H "Authorization: Bearer ${GRAFANA_API_TOKEN}" \
-  -d "$PAYLOAD")
-
-if [[ -z "$RESPONSE" ]]; then
-  echo "Error: empty response (timeout or connection failure)" >&2
-  exit 1
-fi
-
-if [[ "$RAW" == "true" ]]; then
-  echo "$RESPONSE" | jq .
-else
-  echo "$RESPONSE" | jq -r '.results.A.frames[0].data.values[1][]' 2>/dev/null || {
-    echo "No results or unexpected response:" >&2
-    echo "$RESPONSE" | jq . 2>/dev/null || echo "$RESPONSE" >&2
-  }
-fi

From 8789f93290912d44f6660a38de15244aad264469 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Tue, 14 Apr 2026 08:47:30 +0100
Subject: [PATCH 198/219] Add E2E test to ensure flashloan filtering is
 performed correctly (#4329)

# Description
While reviewing #4309 I noticed a super small bug that would have been a
pain in the ass to debug.
The implemented parallelization strategy changed the order of the
flashloan filter, it essentially was filtering flashloans without full
information on them, meaning some flashloan orders would be sent to
solvers that explicitly don't support them.

This PR adds a test to ensure it doesn't break unexpectedly

# Changes

* Add flashloan support configuration to driver tests
* Add test to ensure flashloans are correctly filtered

## How to test
Run test as is and merge this PR's branch into
https://github.com/cowprotocol/services/pull/4309 and check it fails
---
 .../driver/src/tests/cases/flashloan_hints.rs | 49 +++++++++++++++++++
 crates/driver/src/tests/setup/driver.rs       |  3 +-
 crates/driver/src/tests/setup/mod.rs          | 10 ++++
 3 files changed, 61 insertions(+), 1 deletion(-)

diff --git a/crates/driver/src/tests/cases/flashloan_hints.rs b/crates/driver/src/tests/cases/flashloan_hints.rs
index 6b1a0a4923..08bcbb0002 100644
--- a/crates/driver/src/tests/cases/flashloan_hints.rs
+++ b/crates/driver/src/tests/cases/flashloan_hints.rs
@@ -82,6 +82,55 @@ async fn solutions_without_flashloan() {
     test.solve().await.ok();
 }
 
+/// A flashloan-hint order is only visible as a flashloan order after
+/// `update_orders` promotes its `AppData` from `Hash` to `Full`. If the
+/// `flashloans_enabled=false` retain runs *before* promotion (as in the buggy
+/// parallelized ordering), the driver sees `AppData::Hash(_).flashloan() ==
+/// None` and the order survives. When the bug regresses, the flashloan order
+/// reaches the solver mock and the `/solve` body `assert_eq!` panics.
+#[tokio::test]
+#[ignore]
+async fn flashloan_order_filtered_when_flashloans_disabled() {
+    let flashloan = Flashloan {
+        liquidity_provider: Address::from_slice(&[1; 20]),
+        receiver: Address::from_slice(&[2; 20]),
+        token: Address::from_slice(&[3; 20]),
+        protocol_adapter: Address::from_slice(&[4; 20]),
+        amount: ::alloy::primitives::U256::from(3),
+    };
+    let protocol_app_data = ProtocolAppData {
+        flashloan: Some(flashloan),
+        ..Default::default()
+    };
+    let app_data = AppData::Full(Arc::new(protocol_app_data_into_validated(
+        protocol_app_data,
+    )));
+
+    let test = setup()
+        .flashloans_enabled(false)
+        .pool(ab_pool())
+        // Normal order: expected to reach the solver and settle.
+        .order(ab_order())
+        // Flashloan-hint order: the driver must drop this before /solve. The
+        // mock orderbook indexes it by hash; the driver only sees the hash on
+        // /solve and must fetch + promote it before the retain runs.
+        .order(
+            ab_order()
+                .rename("flashloan-ab")
+                .app_data(app_data)
+                .filtered(),
+        )
+        .solution(ab_solution())
+        .done()
+        .await;
+
+    // If the ordering bug regresses, the flashloan order reaches the solver
+    // and the solver mock's `check_solve_request` panics with
+    // "/solve request body does not match expectation" plus an orders-array
+    // diff.
+    test.solve().await.ok();
+}
+
 fn protocol_app_data_into_validated(protocol: ProtocolAppData) -> app_data::ValidatedAppData {
     let root = app_data::Root::new(Some(protocol.clone()));
     let document = serde_json::to_string(&root).unwrap();
diff --git a/crates/driver/src/tests/setup/driver.rs b/crates/driver/src/tests/setup/driver.rs
index d48d8c686f..42219ccee8 100644
--- a/crates/driver/src/tests/setup/driver.rs
+++ b/crates/driver/src/tests/setup/driver.rs
@@ -20,6 +20,7 @@ pub struct Config {
     pub mempools: Vec<Mempool>,
     pub order_priority_strategies: Vec<OrderPriorityStrategy>,
     pub orderbook: Orderbook,
+    pub flashloans_enabled: bool,
 }
 
 pub struct Driver {
@@ -219,7 +220,7 @@ async fn create_config_file(
         config.orderbook.addr
     )
     .unwrap();
-    writeln!(file, "flashloans-enabled = true").unwrap();
+    writeln!(file, "flashloans-enabled = {}", config.flashloans_enabled).unwrap();
     writeln!(file, "tx-gas-limit = \"45000000\"").unwrap();
     write!(
         file,
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 602699d5ee..7677704e7e 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -500,6 +500,7 @@ pub fn setup() -> Setup {
         allow_multiple_solve_requests: false,
         auction_id: 1,
         settle_submission_deadline: 3,
+        flashloans_enabled: true,
         ..Default::default()
     }
 }
@@ -541,6 +542,8 @@ pub struct Setup {
     /// The maximum number of blocks to wait for a settlement to appear on
     /// chain.
     settle_submission_deadline: u64,
+    /// Should flashloan-hint orders be accepted by the driver? True by default.
+    flashloans_enabled: bool,
 }
 
 /// The validity of a solution.
@@ -890,6 +893,12 @@ impl Setup {
         self
     }
 
+    /// Toggle acceptance of flashloan-hint orders at the driver level.
+    pub fn flashloans_enabled(mut self, flashloans_enabled: bool) -> Self {
+        self.flashloans_enabled = flashloans_enabled;
+        self
+    }
+
     /// Create the test: set up onchain contracts and pools, start a mock HTTP
     /// server for the solver and start the HTTP server for the driver.
     pub async fn done(self) -> Test {
@@ -997,6 +1006,7 @@ impl Setup {
                 mempools: self.mempools,
                 order_priority_strategies: self.order_priority_strategies,
                 orderbook,
+                flashloans_enabled: self.flashloans_enabled,
             },
             &solvers_with_address,
             &blockchain,

From df3de517c4fff5eec4c70520a85bc77960a6072c Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Tue, 14 Apr 2026 15:44:16 +0100
Subject: [PATCH 199/219] Support reading TenderlyConfig api_key from
 environment variable (#4332)

# Description
The `TenderlyConfig.api_key` field currently deserializes as a plain
string from TOML config. This means it cannot use the `%ENV_VAR` pattern
to read secrets from environment variables at runtime, unlike
`CoinGeckoConfig.api_key` which already supports this.

Since PR #4225 moved price estimation into a separate crate and removed
the old CLI `--tenderly-*` arguments, the only way to configure Tenderly
for the trade verifier is via the TOML `[price-estimation.tenderly]`
section. Without env var support on the `api-key` field, the API key
would need to be hardcoded in the ConfigMap, which is a security
concern.

# Changes
- Added `deserialize_string_from_env` to `TenderlyConfig.api_key` so it
supports the `%ENV_VAR` pattern (same as `CoinGeckoConfig.api_key`)

# How to test
Existing tests.
---
 crates/configs/src/simulator.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/crates/configs/src/simulator.rs b/crates/configs/src/simulator.rs
index 7ded37a1b5..78263ac8c0 100644
--- a/crates/configs/src/simulator.rs
+++ b/crates/configs/src/simulator.rs
@@ -64,7 +64,12 @@ pub struct TenderlyConfig {
 
     /// Tenderly requires api key to work. Optional since Tenderly could be
     /// skipped in access lists estimators.
-    #[serde(default)]
+    /// Supports reading from an environment variable with the `%ENV_VAR`
+    /// format.
+    #[serde(
+        default,
+        deserialize_with = "crate::deserialize_env::deserialize_string_from_env"
+    )]
     pub api_key: String,
 
     /// The URL of the Tenderly API.

From 689cce1b51f5ebdf1c25cebc40347f76c9376435 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 15 Apr 2026 13:33:10 +0200
Subject: [PATCH 200/219] Hide competition until deadline passes (#4330)

# Description

Hides solver competition API data until the auction's submission
deadline block has passed. Feature-gated via
hide-competition-before-deadline (default off) to avoid breaking
external solver monitoring that depends on these endpoints.

# Changes

- Added hide-competition-before-deadline bool to orderbook config
(default false)
- Wired CurrentBlockWatcher into AppState so handlers can check the
current block
- Return 404 while deadline hasn't passed
- E2E test updated to exercise both the 404 and the post-deadline
visibility

## How to test

```
cargo test -p e2e 'solver_competition::local_node_solver_competition' -- --exact --ignored
```

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/configs/src/orderbook/mod.rs           | 14 +++++
 crates/database/src/solver_competition.rs     | 54 +++++++++++++------
 crates/database/src/solver_competition_v2.rs  | 30 ++++++-----
 crates/e2e/tests/e2e/solver_competition.rs    | 19 ++++++-
 crates/orderbook/src/api.rs                   | 18 +++++++
 .../src/api/get_solver_competition.rs         | 31 +++++++----
 .../src/api/get_solver_competition_v2.rs      | 12 +++--
 .../src/database/solver_competition.rs        | 37 +++++++------
 .../src/database/solver_competition_v2.rs     | 25 ++++++---
 crates/orderbook/src/orderbook.rs             |  9 ++--
 crates/orderbook/src/run.rs                   |  6 +++
 crates/orderbook/src/solver_competition.rs    |  6 +++
 12 files changed, 191 insertions(+), 70 deletions(-)

diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index 5362370643..ef3b6fdb01 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -128,6 +128,11 @@ pub struct Configuration {
     /// Order simulation configuration. If `None`, the endpoint is disabled.
     #[serde(default)]
     pub order_simulation: Option<OrderSimulationConfig>,
+
+    /// When enabled, solver competition endpoints return 404 until the
+    /// auction's submission deadline block has been reached.
+    #[serde(default)]
+    pub hide_competition_before_deadline: bool,
 }
 
 impl Configuration {
@@ -224,6 +229,7 @@ pub mod test_util {
                     gas_limit: U256::try_from(16777215).expect("u64 can be converted to U256"),
                     tenderly: None,
                 }),
+                hide_competition_before_deadline: false,
             }
         }
     }
@@ -248,6 +254,7 @@ mod tests {
         active-order-competition-threshold = 10
         unsupported-tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
         eip1271-skip-creation-validation = true
+        hide-competition-before-deadline = true
 
         [banned-users]
         addresses = ["0xdead000000000000000000000000000000000000"]
@@ -285,6 +292,7 @@ mod tests {
         assert_eq!(config.unsupported_tokens.len(), 1);
         assert_eq!(config.banned_users.addresses.len(), 1);
         assert!(config.eip1271_skip_creation_validation);
+        assert!(config.hide_competition_before_deadline);
         assert_eq!(
             config.order_simulation.map(|config| config.gas_limit),
             Some(U256::from(123456789u64))
@@ -350,6 +358,7 @@ mod tests {
         assert!(config.unsupported_tokens.is_empty());
         assert!(config.banned_users.addresses.is_empty());
         assert!(!config.eip1271_skip_creation_validation);
+        assert!(!config.hide_competition_before_deadline);
     }
 
     #[test]
@@ -382,6 +391,7 @@ mod tests {
             ],
             banned_users: Default::default(),
             eip1271_skip_creation_validation: true,
+            hide_competition_before_deadline: true,
             native_price_estimation: NativePriceConfig {
                 estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
                 fallback_estimators: None,
@@ -422,6 +432,10 @@ mod tests {
             config.eip1271_skip_creation_validation,
             deserialized.eip1271_skip_creation_validation
         );
+        assert_eq!(
+            config.hide_competition_before_deadline,
+            deserialized.hide_competition_before_deadline
+        );
         assert_eq!(config.http_client.timeout, deserialized.http_client.timeout)
     }
 }
diff --git a/crates/database/src/solver_competition.rs b/crates/database/src/solver_competition.rs
index 5f73c7b7e2..a51b94b458 100644
--- a/crates/database/src/solver_competition.rs
+++ b/crates/database/src/solver_competition.rs
@@ -50,51 +50,61 @@ pub async fn auction_start_block(
 pub async fn load_by_id(
     ex: &mut PgConnection,
     id: AuctionId,
+    after_block: Option<i64>,
 ) -> Result<Option<LoadCompetition>, sqlx::Error> {
     const QUERY: &str = r#"
 SELECT sc.json, sc.id, COALESCE(ARRAY_AGG(s.tx_hash) FILTER (WHERE s.solution_uid IS NOT NULL), '{}') AS tx_hashes
 FROM solver_competitions sc
 -- outer joins because the data might not have been indexed yet
 LEFT OUTER JOIN settlements s ON sc.id = s.auction_id
--- exclude settlements from another environment for which observation is guaranteed to not exist
-WHERE sc.id = $1
+LEFT JOIN competition_auctions ca ON sc.id = ca.id
+WHERE sc.id = $1 AND ($2::bigint IS NULL OR ca.deadline <= $2)
 GROUP BY sc.id
     ;"#;
-    sqlx::query_as(QUERY).bind(id).fetch_optional(ex).await
+    sqlx::query_as(QUERY)
+        .bind(id)
+        .bind(after_block)
+        .fetch_optional(ex)
+        .await
 }
 
 #[instrument(skip_all)]
 pub async fn load_latest_competitions(
     ex: &mut PgConnection,
     latest_competitions_count: u32,
+    after_block: Option<i64>,
 ) -> Result<Vec<LoadCompetition>, sqlx::Error> {
     const QUERY: &str = r#"
 SELECT sc.json, sc.id, COALESCE(ARRAY_AGG(s.tx_hash) FILTER (WHERE s.solution_uid IS NOT NULL), '{}') AS tx_hashes
 FROM solver_competitions sc
 -- outer joins because the data might not have been indexed yet
 LEFT OUTER JOIN settlements s ON sc.id = s.auction_id
+LEFT JOIN competition_auctions ca ON sc.id = ca.id
+WHERE ($2::bigint IS NULL OR ca.deadline <= $2)
 GROUP BY sc.id
 ORDER BY sc.id DESC
 LIMIT $1
     ;"#;
     sqlx::query_as(QUERY)
         .bind(i64::from(latest_competitions_count))
+        .bind(after_block)
         .fetch_all(ex)
         .await
 }
 
 pub async fn load_latest_competition(
     ex: &mut PgConnection,
+    after_block: Option<i64>,
 ) -> Result<Option<LoadCompetition>, sqlx::Error> {
-    let competitions = load_latest_competitions(ex, 1).await?;
-    let latest = competitions.into_iter().next();
-    Ok(latest)
+    let competitions = load_latest_competitions(ex, 1, after_block).await?;
+    Ok(competitions.into_iter().next())
 }
 
 #[instrument(skip_all)]
 pub async fn load_by_tx_hash(
     ex: &mut PgConnection,
     tx_hash: &TransactionHash,
+    after_block: Option<i64>,
 ) -> Result<Option<LoadCompetition>, sqlx::Error> {
     const QUERY: &str = r#"
 WITH competition AS (
@@ -106,10 +116,16 @@ WITH competition AS (
 SELECT sc.json, sc.id, COALESCE(ARRAY_AGG(s.tx_hash) FILTER (WHERE s.solution_uid IS NOT NULL), '{}') AS tx_hashes
 FROM solver_competitions sc
 JOIN settlements s ON sc.id = s.auction_id
+LEFT JOIN competition_auctions ca ON sc.id = ca.id
 WHERE sc.id = (SELECT id FROM competition) AND s.solution_uid IS NOT NULL
+    AND ($2::bigint IS NULL OR ca.deadline <= $2)
 GROUP BY sc.id
     ;"#;
-    sqlx::query_as(QUERY).bind(tx_hash).fetch_optional(ex).await
+    sqlx::query_as(QUERY)
+        .bind(tx_hash)
+        .bind(after_block)
+        .fetch_optional(ex)
+        .await
 }
 
 #[cfg(test)]
@@ -142,24 +158,27 @@ mod tests {
         assert_eq!(value_, "1234");
 
         // load by id works
-        let value_ = load_by_id(&mut db, 0).await.unwrap().unwrap();
+        let value_ = load_by_id(&mut db, 0, None).await.unwrap().unwrap();
         assert_eq!(value, value_.json);
         assert!(value_.tx_hashes.is_empty());
 
         // load as latest works
-        let value_ = load_latest_competition(&mut db).await.unwrap().unwrap();
+        let value_ = load_latest_competition(&mut db, None)
+            .await
+            .unwrap()
+            .unwrap();
         assert_eq!(value, value_.json);
         assert!(value_.tx_hashes.is_empty());
         // load by tx doesn't work, as there is no settlement yet
         assert!(
-            load_by_tx_hash(&mut db, &ByteArray([0u8; 32]))
+            load_by_tx_hash(&mut db, &ByteArray([0u8; 32]), None)
                 .await
                 .unwrap()
                 .is_none()
         );
 
         // non-existent auction returns none
-        assert!(load_by_id(&mut db, 1).await.unwrap().is_none());
+        assert!(load_by_id(&mut db, 1, None).await.unwrap().is_none());
 
         // insert three settlement events for the same auction id, with one of them not
         // having solution UID (in practice, usually meaning it's from a different
@@ -221,26 +240,29 @@ mod tests {
             .unwrap();
 
         // load by id works, and finds two hashes
-        let value_ = load_by_id(&mut db, 0).await.unwrap().unwrap();
+        let value_ = load_by_id(&mut db, 0, None).await.unwrap().unwrap();
         assert!(value_.tx_hashes.len() == 2);
 
         // load as latest works, and finds two hashes
-        let value_ = load_latest_competition(&mut db).await.unwrap().unwrap();
+        let value_ = load_latest_competition(&mut db, None)
+            .await
+            .unwrap()
+            .unwrap();
         assert!(value_.tx_hashes.len() == 2);
 
         // load by tx works, and finds two hashes, no matter which tx hash is used
-        let value_ = load_by_tx_hash(&mut db, &ByteArray([0u8; 32]))
+        let value_ = load_by_tx_hash(&mut db, &ByteArray([0u8; 32]), None)
             .await
             .unwrap()
             .unwrap();
         assert!(value_.tx_hashes.len() == 2);
-        let value_ = load_by_tx_hash(&mut db, &ByteArray([1u8; 32]))
+        let value_ = load_by_tx_hash(&mut db, &ByteArray([1u8; 32]), None)
             .await
             .unwrap()
             .unwrap();
         assert!(value_.tx_hashes.len() == 2);
         // this one should not find any hashes since it's from another environment
-        let value_ = load_by_tx_hash(&mut db, &ByteArray([2u8; 32]))
+        let value_ = load_by_tx_hash(&mut db, &ByteArray([2u8; 32]), None)
             .await
             .unwrap();
         assert!(value_.is_none());
diff --git a/crates/database/src/solver_competition_v2.rs b/crates/database/src/solver_competition_v2.rs
index 97f749eb8e..5768b328e4 100644
--- a/crates/database/src/solver_competition_v2.rs
+++ b/crates/database/src/solver_competition_v2.rs
@@ -75,6 +75,7 @@ pub struct SolverCompetition {
 pub async fn load_by_tx_hash(
     mut ex: &mut PgConnection,
     tx_hash: TransactionHash,
+    after_block: Option<i64>,
 ) -> Result<Option<SolverCompetition>, sqlx::Error> {
     const FETCH_AUCTION_ID: &str = r#"
         SELECT s.auction_id
@@ -88,40 +89,45 @@ pub async fn load_by_tx_hash(
     let Some(auction_id) = auction_id else {
         return Ok(None);
     };
-    load_by_id(ex.deref_mut(), auction_id).await
+    load_by_id(ex.deref_mut(), auction_id, after_block).await
 }
 
 #[instrument(skip_all)]
 pub async fn load_latest(
     mut ex: &mut PgConnection,
+    after_block: Option<i64>,
 ) -> Result<Option<SolverCompetition>, sqlx::Error> {
     const FETCH_AUCTION_ID: &str = r#"
         SELECT id
         FROM competition_auctions
+        WHERE ($1::bigint IS NULL OR deadline <= $1)
         ORDER BY id DESC
         LIMIT 1;
     "#;
     let auction_id: Option<i64> = sqlx::query_scalar(FETCH_AUCTION_ID)
+        .bind(after_block)
         .fetch_optional(ex.deref_mut())
         .await?;
     let Some(auction_id) = auction_id else {
         return Ok(None);
     };
-    load_by_id(ex.deref_mut(), auction_id).await
+    load_by_id(ex.deref_mut(), auction_id, after_block).await
 }
 
 #[instrument(skip_all)]
 pub async fn load_by_id(
     mut ex: &mut PgConnection,
     id: AuctionId,
+    after_block: Option<i64>,
 ) -> Result<Option<SolverCompetition>, sqlx::Error> {
     const FETCH_AUCTION: &str = r#"
         SELECT id, order_uids, price_tokens, price_values, block, deadline
         FROM competition_auctions
-        WHERE id = $1;
+        WHERE id = $1 AND ($2::bigint IS NULL OR deadline <= $2);
     "#;
     let auction: Option<Auction> = sqlx::query_as(FETCH_AUCTION)
         .bind(id)
+        .bind(after_block)
         .fetch_optional(ex.deref_mut())
         .await?;
     let Some(auction) = auction else {
@@ -643,10 +649,10 @@ mod tests {
             .await
             .unwrap();
 
-        let solver_competition = load_by_tx_hash(&mut db, tx_hash).await.unwrap();
+        let solver_competition = load_by_tx_hash(&mut db, tx_hash, None).await.unwrap();
         assert!(solver_competition.is_none());
 
-        let solver_competition = load_by_tx_hash(&mut db, tx_hash).await.unwrap();
+        let solver_competition = load_by_tx_hash(&mut db, tx_hash, None).await.unwrap();
         assert!(solver_competition.is_none());
 
         // update settlements
@@ -669,7 +675,7 @@ mod tests {
         };
         auction::save(&mut db, auction).await.unwrap();
 
-        let solver_competition = load_by_tx_hash(&mut db, tx_hash).await.unwrap();
+        let solver_competition = load_by_tx_hash(&mut db, tx_hash, None).await.unwrap();
         assert!(solver_competition.is_some());
         let solver_competition = solver_competition.unwrap();
         assert_eq!(solver_competition.settlements.len(), 1);
@@ -690,7 +696,7 @@ mod tests {
         let log_index = 0;
         let auction_id = 1;
 
-        let solver_competition = load_by_id(&mut db, auction_id).await.unwrap();
+        let solver_competition = load_by_id(&mut db, auction_id, None).await.unwrap();
         assert!(solver_competition.is_none());
 
         // example order
@@ -715,7 +721,7 @@ mod tests {
         };
         auction::save(&mut db, auction).await.unwrap();
 
-        let solver_competition = load_by_id(&mut db, auction_id).await.unwrap();
+        let solver_competition = load_by_id(&mut db, auction_id, None).await.unwrap();
         assert!(solver_competition.is_some());
 
         // settlements
@@ -733,14 +739,14 @@ mod tests {
             .unwrap();
 
         // Check before the joined table is populated
-        let solver_competition = load_by_id(&mut db, auction_id).await.unwrap();
+        let solver_competition = load_by_id(&mut db, auction_id, None).await.unwrap();
         assert!(solver_competition.is_some());
         let solver_competition = solver_competition.unwrap();
         assert!(solver_competition.settlements.is_empty());
         assert_eq!(solver_competition.auction.id, 1);
 
         // Check after the joined table is populated
-        let solver_competition = load_by_id(&mut db, auction_id).await.unwrap();
+        let solver_competition = load_by_id(&mut db, auction_id, None).await.unwrap();
         assert!(solver_competition.is_some());
         let solver_competition = solver_competition.unwrap();
         assert!(solver_competition.settlements.is_empty());
@@ -761,7 +767,7 @@ mod tests {
         .unwrap();
 
         // Check after both tables are linked
-        let solver_competition = load_by_id(&mut db, auction_id).await.unwrap();
+        let solver_competition = load_by_id(&mut db, auction_id, None).await.unwrap();
         assert!(solver_competition.is_some());
         let solver_competition = solver_competition.unwrap();
         assert_eq!(solver_competition.settlements.len(), 1);
@@ -825,7 +831,7 @@ mod tests {
         .await
         .unwrap();
 
-        let solver_competition = load_by_id(&mut db, auction_id).await.unwrap();
+        let solver_competition = load_by_id(&mut db, auction_id, None).await.unwrap();
         assert!(solver_competition.is_some());
         let solver_competition = solver_competition.unwrap();
         assert_eq!(solver_competition.settlements.len(), 1);
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index d6ac28951b..dc99576b64 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -16,6 +16,7 @@ use {
         signature::EcdsaSigningScheme,
     },
     number::units::EthUnit,
+    reqwest::StatusCode,
     shared::web3::Web3,
     solvers_dto::solution::Solution,
     std::{collections::HashMap, str::FromStr},
@@ -91,6 +92,7 @@ async fn solver_competition(web3: Web3) {
 
     let services = Services::new(&onchain).await;
 
+    let base_config = Configuration::test_no_drivers();
     services
         .start_autopilot(
             None,
@@ -103,12 +105,17 @@ async fn solver_competition(web3: Web3) {
                     ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver"),
                     ExternalSolver::new("solver2", "http://localhost:11088/solver2"),
                 ]),
-                ..Configuration::test_no_drivers()
+                run_loop: RunLoopConfig {
+                    submission_deadline: 3,
+                    ..base_config.run_loop
+                },
+                ..base_config
             },
         )
         .await;
     services
         .start_api(configs::orderbook::Configuration {
+            hide_competition_before_deadline: true,
             order_quoting: OrderQuoting::test_with_drivers(vec![
                 ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver"),
                 ExternalSolver::new("solver2", "http://localhost:11088/solver2"),
@@ -146,6 +153,16 @@ async fn solver_competition(web3: Web3) {
     };
     wait_for_condition(TIMEOUT, trade_happened).await.unwrap();
 
+    // Competition data is saved before the settlement tx, so it is already in
+    // the DB. The deadline hasn't passed yet → 404.
+    assert_eq!(
+        services.get_latest_solver_competition().await.unwrap_err(),
+        StatusCode::NOT_FOUND,
+    );
+
+    // The indexed_trades poll mints a block on every iteration, which will
+    // advance past the 3-block deadline while also waiting for the event
+    // indexer to pick up the settlement.
     let indexed_trades = || async {
         onchain.mint_block().await;
         match services.get_trades(&uid).await.unwrap().first() {
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 0977680efa..8ce797cfdb 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -14,6 +14,7 @@ use {
         response::{IntoResponse, Json, Response},
         routing::{delete, get, post, put},
     },
+    ethrpc::block_stream::CurrentBlockWatcher,
     observe::tracing::distributed::axum::{make_span, record_trace_id},
     price_estimation::{PriceEstimationError, native::NativePriceEstimating},
     serde::{Deserialize, Serialize},
@@ -69,6 +70,18 @@ pub struct AppState {
     pub app_data: Arc<app_data::Registry>,
     pub native_price_estimator: Arc<dyn NativePriceEstimating>,
     pub quote_timeout: Duration,
+    pub current_block_stream: CurrentBlockWatcher,
+    pub hide_competition_before_deadline: bool,
+}
+
+impl AppState {
+    /// When the feature is enabled, returns the current block number so DB
+    /// queries can hide competition data whose deadline hasn't passed yet.
+    /// Returns `None` when the feature is off (no filtering).
+    pub(crate) fn hide_competition_before_block(&self) -> Option<i64> {
+        self.hide_competition_before_deadline
+            .then(|| self.current_block_stream.borrow().number.cast_signed())
+    }
 }
 
 async fn summarize_request(req: Request<axum::body::Body>, next: Next) -> Response {
@@ -138,6 +151,7 @@ async fn with_matched_path_metric(req: Request<axum::body::Body>, next: Next) ->
 
 const MAX_JSON_BODY_PAYLOAD: u64 = 1024 * 16;
 
+#[expect(clippy::too_many_arguments)]
 pub fn handle_all_routes(
     database_write: Postgres,
     database_read: Postgres,
@@ -146,6 +160,8 @@ pub fn handle_all_routes(
     app_data: Arc<app_data::Registry>,
     native_price_estimator: Arc<dyn NativePriceEstimating>,
     quote_timeout: Duration,
+    current_block_stream: CurrentBlockWatcher,
+    hide_competition_before_deadline: bool,
 ) -> Router {
     let app_data_size_limit = app_data.size_limit();
 
@@ -157,6 +173,8 @@ pub fn handle_all_routes(
         app_data,
         native_price_estimator,
         quote_timeout,
+        current_block_stream,
+        hide_competition_before_deadline,
     });
 
     let routes = [
diff --git a/crates/orderbook/src/api/get_solver_competition.rs b/crates/orderbook/src/api/get_solver_competition.rs
index c1addf4873..eba8e3bc01 100644
--- a/crates/orderbook/src/api/get_solver_competition.rs
+++ b/crates/orderbook/src/api/get_solver_competition.rs
@@ -1,12 +1,12 @@
 use {
     crate::{
         api::AppState,
-        solver_competition::{Identifier, SolverCompetitionStoring},
+        solver_competition::{Identifier, LoadSolverCompetitionError, SolverCompetitionStoring},
     },
     alloy::primitives::B256,
     axum::{
         extract::{Path, State},
-        response::{IntoResponse, Json, Response},
+        response::Json,
     },
     model::{AuctionId, solver_competition::SolverCompetitionAPI},
     std::sync::Arc,
@@ -15,37 +15,46 @@ use {
 pub async fn get_solver_competition_by_id_handler(
     State(state): State<Arc<AppState>>,
     Path(auction_id): Path<u64>,
-) -> Response {
+) -> Result<Json<SolverCompetitionAPI>, LoadSolverCompetitionError> {
     // We use u64 to ensure that negative numbers are returned as BAD_REQUEST
     // however, there's a gap between u64::MAX and i64::MAX, numbers beyond i64::MAX
     // will be marked as NOT_FOUND as they're positive (and as such, valid) but
     // they are not covered by our system
     if auction_id >= AuctionId::MAX.cast_unsigned() {
-        return crate::solver_competition::LoadSolverCompetitionError::NotFound.into_response();
+        return Err(LoadSolverCompetitionError::NotFound);
     }
 
     db(&state)
-        .load_competition(Identifier::Id(auction_id.cast_signed()))
+        .load_competition(
+            Identifier::Id(auction_id.cast_signed()),
+            state.hide_competition_before_block(),
+        )
         .await
         .map(Json)
-        .into_response()
 }
 
 pub async fn get_solver_competition_by_hash_handler(
     State(state): State<Arc<AppState>>,
     Path(tx_hash): Path<B256>,
-) -> Response {
+) -> Result<Json<SolverCompetitionAPI>, LoadSolverCompetitionError> {
     db(&state)
-        .load_competition(Identifier::Transaction(tx_hash))
+        .load_competition(
+            Identifier::Transaction(tx_hash),
+            state.hide_competition_before_block(),
+        )
         .await
         .map(Json)
-        .into_response()
 }
 
 pub async fn get_solver_competition_latest_handler(
     State(state): State<Arc<AppState>>,
-) -> Result<Json<SolverCompetitionAPI>, crate::solver_competition::LoadSolverCompetitionError> {
-    db(&state).load_latest_competition().await.map(Json)
+) -> Result<Json<SolverCompetitionAPI>, LoadSolverCompetitionError> {
+    SolverCompetitionStoring::load_latest_competition(
+        db(&state),
+        state.hide_competition_before_block(),
+    )
+    .await
+    .map(Json)
 }
 
 fn db(state: &AppState) -> &dyn SolverCompetitionStoring {
diff --git a/crates/orderbook/src/api/get_solver_competition_v2.rs b/crates/orderbook/src/api/get_solver_competition_v2.rs
index eab9dc3a2a..3c39aef7e2 100644
--- a/crates/orderbook/src/api/get_solver_competition_v2.rs
+++ b/crates/orderbook/src/api/get_solver_competition_v2.rs
@@ -22,7 +22,10 @@ pub async fn get_solver_competition_by_id_handler(
     }
 
     db(&state)
-        .load_competition_by_id(auction_id.cast_signed())
+        .load_competition_by_id(
+            auction_id.cast_signed(),
+            state.hide_competition_before_block(),
+        )
         .await
         .map(Json)
         .into_response()
@@ -33,7 +36,7 @@ pub async fn get_solver_competition_by_hash_handler(
     Path(tx_hash): Path<B256>,
 ) -> Response {
     db(&state)
-        .load_competition_by_tx_hash(tx_hash)
+        .load_competition_by_tx_hash(tx_hash, state.hide_competition_before_block())
         .await
         .map(Json)
         .into_response()
@@ -42,7 +45,10 @@ pub async fn get_solver_competition_by_hash_handler(
 pub async fn get_solver_competition_latest_handler(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<CompetitionResponse>, LoadSolverCompetitionError> {
-    db(&state).load_latest_competition().await.map(Json)
+    db(&state)
+        .load_latest_competition(state.hide_competition_before_block())
+        .await
+        .map(Json)
 }
 
 fn db(state: &AppState) -> &Postgres {
diff --git a/crates/orderbook/src/database/solver_competition.rs b/crates/orderbook/src/database/solver_competition.rs
index a04ece3e1d..e812883364 100644
--- a/crates/orderbook/src/database/solver_competition.rs
+++ b/crates/orderbook/src/database/solver_competition.rs
@@ -30,6 +30,7 @@ impl SolverCompetitionStoring for Postgres {
     async fn load_competition(
         &self,
         id: Identifier,
+        after_block: Option<i64>,
     ) -> Result<SolverCompetitionAPI, LoadSolverCompetitionError> {
         let _timer = super::Metrics::get()
             .database_queries
@@ -38,20 +39,10 @@ impl SolverCompetitionStoring for Postgres {
 
         let mut ex = self.pool.acquire().await.map_err(anyhow::Error::from)?;
         match id {
-            Identifier::Id(id) => database::solver_competition::load_by_id(&mut ex, id)
-                .await
-                .context("solver_competition::load_by_id")?
-                .map(|row| {
-                    deserialize_solver_competition(
-                        row.json,
-                        row.id,
-                        row.tx_hashes.iter().map(|hash| B256::new(hash.0)).collect(),
-                    )
-                }),
-            Identifier::Transaction(hash) => {
-                database::solver_competition::load_by_tx_hash(&mut ex, &ByteArray(hash.0))
+            Identifier::Id(id) => {
+                database::solver_competition::load_by_id(&mut ex, id, after_block)
                     .await
-                    .context("solver_competition::load_by_tx_hash")?
+                    .context("solver_competition::load_by_id")?
                     .map(|row| {
                         deserialize_solver_competition(
                             row.json,
@@ -60,12 +51,27 @@ impl SolverCompetitionStoring for Postgres {
                         )
                     })
             }
+            Identifier::Transaction(hash) => database::solver_competition::load_by_tx_hash(
+                &mut ex,
+                &ByteArray(hash.0),
+                after_block,
+            )
+            .await
+            .context("solver_competition::load_by_tx_hash")?
+            .map(|row| {
+                deserialize_solver_competition(
+                    row.json,
+                    row.id,
+                    row.tx_hashes.iter().map(|hash| B256::new(hash.0)).collect(),
+                )
+            }),
         }
         .ok_or(LoadSolverCompetitionError::NotFound)?
     }
 
     async fn load_latest_competition(
         &self,
+        after_block: Option<i64>,
     ) -> Result<SolverCompetitionAPI, LoadSolverCompetitionError> {
         let _timer = super::Metrics::get()
             .database_queries
@@ -73,7 +79,7 @@ impl SolverCompetitionStoring for Postgres {
             .start_timer();
 
         let mut ex = self.pool.acquire().await.map_err(anyhow::Error::from)?;
-        database::solver_competition::load_latest_competition(&mut ex)
+        database::solver_competition::load_latest_competition(&mut ex, after_block)
             .await
             .context("solver_competition::load_latest_competition")?
             .map(|row| {
@@ -100,6 +106,7 @@ impl SolverCompetitionStoring for Postgres {
         let latest_competitions = database::solver_competition::load_latest_competitions(
             &mut ex,
             latest_competitions_count,
+            None,
         )
         .await
         .context("solver_competition::load_latest_competitions")?
@@ -128,7 +135,7 @@ mod tests {
         database::clear_DANGER(&db.pool).await.unwrap();
 
         let result = db
-            .load_competition(Identifier::Transaction(Default::default()))
+            .load_competition(Identifier::Transaction(Default::default()), None)
             .await
             .unwrap_err();
         assert!(matches!(result, LoadSolverCompetitionError::NotFound));
diff --git a/crates/orderbook/src/database/solver_competition_v2.rs b/crates/orderbook/src/database/solver_competition_v2.rs
index 2496859997..6a22438723 100644
--- a/crates/orderbook/src/database/solver_competition_v2.rs
+++ b/crates/orderbook/src/database/solver_competition_v2.rs
@@ -16,6 +16,7 @@ impl Postgres {
     pub async fn load_competition_by_id(
         &self,
         auction_id: i64,
+        current_block: Option<i64>,
     ) -> Result<ApiResponse, LoadSolverCompetitionError> {
         let _timer = super::Metrics::get()
             .database_queries
@@ -23,7 +24,7 @@ impl Postgres {
             .start_timer();
 
         let mut ex = self.pool.acquire().await.map_err(anyhow::Error::from)?;
-        database::solver_competition_v2::load_by_id(&mut ex, auction_id)
+        database::solver_competition_v2::load_by_id(&mut ex, auction_id, current_block)
             .await
             .context("solver_competition_v2::load_by_id")?
             .map(try_into_dto)
@@ -33,6 +34,7 @@ impl Postgres {
     pub async fn load_competition_by_tx_hash(
         &self,
         tx_hash: B256,
+        current_block: Option<i64>,
     ) -> Result<ApiResponse, LoadSolverCompetitionError> {
         let _timer = super::Metrics::get()
             .database_queries
@@ -40,21 +42,28 @@ impl Postgres {
             .start_timer();
 
         let mut ex = self.pool.acquire().await.map_err(anyhow::Error::from)?;
-        database::solver_competition_v2::load_by_tx_hash(&mut ex, ByteArray(tx_hash.0))
-            .await
-            .context("solver_competition_v2::load_by_tx_hash")?
-            .map(try_into_dto)
-            .ok_or(LoadSolverCompetitionError::NotFound)?
+        database::solver_competition_v2::load_by_tx_hash(
+            &mut ex,
+            ByteArray(tx_hash.0),
+            current_block,
+        )
+        .await
+        .context("solver_competition_v2::load_by_tx_hash")?
+        .map(try_into_dto)
+        .ok_or(LoadSolverCompetitionError::NotFound)?
     }
 
-    pub async fn load_latest_competition(&self) -> Result<ApiResponse, LoadSolverCompetitionError> {
+    pub async fn load_latest_competition(
+        &self,
+        current_block: Option<i64>,
+    ) -> Result<ApiResponse, LoadSolverCompetitionError> {
         let _timer = super::Metrics::get()
             .database_queries
             .with_label_values(&["load_latest_solver_competition_v2"])
             .start_timer();
 
         let mut ex = self.pool.acquire().await.map_err(anyhow::Error::from)?;
-        database::solver_competition_v2::load_latest(&mut ex)
+        database::solver_competition_v2::load_latest(&mut ex, current_block)
             .await
             .context("solver_competition_v2::load_latest")?
             .map(try_into_dto)
diff --git a/crates/orderbook/src/orderbook.rs b/crates/orderbook/src/orderbook.rs
index cdbdc57c8e..2058f8a91c 100644
--- a/crates/orderbook/src/orderbook.rs
+++ b/crates/orderbook/src/orderbook.rs
@@ -563,9 +563,10 @@ impl Orderbook {
         };
 
         let latest_competition = async {
-            let competition = SolverCompetitionStoring::load_latest_competition(&self.database)
-                .await
-                .map_err(Into::<OrderStatusError>::into)?;
+            let competition =
+                SolverCompetitionStoring::load_latest_competition(&self.database, None)
+                    .await
+                    .map_err(Into::<OrderStatusError>::into)?;
             Ok::<_, OrderStatusError>(solutions(competition))
         };
 
@@ -586,7 +587,7 @@ impl Orderbook {
             Some(Some(tx_hash)) => {
                 let competition = self
                     .database
-                    .load_competition(Identifier::Transaction(tx_hash))
+                    .load_competition(Identifier::Transaction(tx_hash), None)
                     .await?;
                 return Ok(dto::order::Status::Traded(solutions(competition)));
             }
diff --git a/crates/orderbook/src/run.rs b/crates/orderbook/src/run.rs
index 68b4fcd307..912680642c 100644
--- a/crates/orderbook/src/run.rs
+++ b/crates/orderbook/src/run.rs
@@ -482,6 +482,8 @@ pub async fn run(config: Configuration) {
         },
         native_price_estimator,
         config.price_estimation.quote_timeout,
+        current_block_stream,
+        config.hide_competition_before_deadline,
     );
 
     let mut metrics_address = config.bind_address;
@@ -554,6 +556,8 @@ fn serve_api(
     shutdown_receiver: impl Future<Output = ()> + Send + 'static,
     native_price_estimator: Arc<dyn NativePriceEstimating>,
     quote_timeout: Duration,
+    current_block_stream: ethrpc::block_stream::CurrentBlockWatcher,
+    hide_competition_before_deadline: bool,
 ) -> JoinHandle<()> {
     let app = api::handle_all_routes(
         database,
@@ -563,6 +567,8 @@ fn serve_api(
         app_data,
         native_price_estimator,
         quote_timeout,
+        current_block_stream,
+        hide_competition_before_deadline,
     );
     tracing::info!(%address, "serving order book");
 
diff --git a/crates/orderbook/src/solver_competition.rs b/crates/orderbook/src/solver_competition.rs
index 1e852019af..5ca19dc995 100644
--- a/crates/orderbook/src/solver_competition.rs
+++ b/crates/orderbook/src/solver_competition.rs
@@ -21,16 +21,22 @@ pub trait SolverCompetitionStoring: Send + Sync {
     ///
     /// Returns a `NotFound` error if no solver competition with that ID could
     /// be found.
+    /// When `after_block` is `Some`, competitions whose deadline hasn't
+    /// passed are treated as not found.
     async fn load_competition(
         &self,
         identifier: Identifier,
+        after_block: Option<i64>,
     ) -> Result<SolverCompetitionAPI, crate::solver_competition::LoadSolverCompetitionError>;
 
     /// Retrieves the solver competition for the most recent auction.
     ///
     /// Returns a `NotFound` error if no solver competition could be found.
+    /// When `after_block` is `Some`, only auctions whose deadline has passed
+    /// are considered.
     async fn load_latest_competition(
         &self,
+        after_block: Option<i64>,
     ) -> Result<SolverCompetitionAPI, crate::solver_competition::LoadSolverCompetitionError>;
 
     /// Retrieves the solver competitions for the most recent auctions.

From 54fd0127e1c6175a8a7c75cfac649c793850554f Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Wed, 15 Apr 2026 14:29:39 +0200
Subject: [PATCH 201/219] Fix RUSTSEC issues (#4334)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Fixed (vulnerabilities):
- RUSTSEC-2026-0098 & RUSTSEC-2026-0099: rustls-webpki 0.103.10 →
0.103.12 (lockfile update only)
Fixed (unsound warning):
- RUSTSEC-2026-0097: rand 0.9.2 → 0.9.4 (lockfile update only)
- RUSTSEC-2026-0097: Workspace rand dependency bumped from 0.8.5 → 0.9.4
in Cargo.toml, with code updates to use the new API (thread_rng() →
rng(), gen_range() → random_range())
---
 Cargo.lock                                    | 44 +++++++++----------
 Cargo.toml                                    |  2 +-
 .../src/domain/settlement/observer.rs         |  4 +-
 crates/autopilot/src/run_loop.rs              |  2 +-
 crates/driver/src/tests/setup/driver.rs       |  2 +-
 .../src/native_price_cache.rs                 |  4 +-
 6 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 89b5c56454..a5e95a136b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -369,7 +369,7 @@ dependencies = [
  "keccak-asm",
  "paste",
  "proptest",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rapidhash",
  "ruint",
  "rustc-hash",
@@ -1246,7 +1246,7 @@ dependencies = [
  "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
- "rand 0.8.5",
+ "rand 0.9.4",
  "reqwest 0.13.2",
  "rust_decimal",
  "s3",
@@ -3692,7 +3692,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ab67060fc6b8ef687992d439ca0fa36e7ed17e9a0b16b25b601e8757df720de"
 dependencies = [
  "data-encoding",
- "syn 1.0.109",
+ "syn 2.0.114",
 ]
 
 [[package]]
@@ -3886,7 +3886,7 @@ dependencies = [
  "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
- "rand 0.8.5",
+ "rand 0.9.4",
  "request-sharing",
  "reqwest 0.13.2",
  "s3",
@@ -4122,7 +4122,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "rand 0.8.5",
+ "rand 0.9.4",
  "reqwest 0.13.2",
  "scopeguard",
  "serde",
@@ -4899,7 +4899,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -5975,7 +5975,7 @@ dependencies = [
  "futures-util",
  "opentelemetry",
  "percent-encoding",
- "rand 0.9.2",
+ "rand 0.9.4",
  "thiserror 2.0.17",
 ]
 
@@ -6345,7 +6345,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "rand 0.8.5",
+ "rand 0.9.4",
  "rate-limit",
  "request-sharing",
  "reqwest 0.13.2",
@@ -6460,7 +6460,7 @@ dependencies = [
  "bit-vec",
  "bitflags 2.10.0",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rand_chacha 0.9.0",
  "rand_xorshift",
  "regex-syntax",
@@ -6602,7 +6602,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "thiserror 2.0.17",
  "tokio",
  "tracing",
@@ -6619,7 +6619,7 @@ dependencies = [
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
- "rand 0.9.2",
+ "rand 0.9.4",
  "ring",
  "rustc-hash",
  "rustls",
@@ -6640,7 +6640,7 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "tracing",
  "windows-sys 0.60.2",
 ]
@@ -6686,9 +6686,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.5",
@@ -6749,7 +6749,7 @@ version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d8b5b858a440a0bc02625b62dd95131b9201aa9f69f411195dd4a7cfb1de3d7"
 dependencies = [
- "rand 0.9.2",
+ "rand 0.9.4",
  "rustversion",
 ]
 
@@ -6832,7 +6832,7 @@ dependencies = [
  "observe",
  "prometheus",
  "prometheus-metric-storage",
- "rand 0.8.5",
+ "rand 0.9.4",
  "rstest",
  "shared",
  "sqlx",
@@ -7091,7 +7091,7 @@ dependencies = [
  "primitive-types",
  "proptest",
  "rand 0.8.5",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rlp",
  "ruint-macro",
  "serde_core",
@@ -7232,9 +7232,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.10"
+version = "0.103.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+checksum = "8279bb85272c9f10811ae6a6c547ff594d6a7f3c6c6b02ee9726d1d0dcfcdd06"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -7651,7 +7651,7 @@ dependencies = [
  "price-estimation",
  "prometheus",
  "prometheus-metric-storage",
- "rand 0.8.5",
+ "rand 0.9.4",
  "rate-limit",
  "regex",
  "request-sharing",
@@ -8901,7 +8901,7 @@ dependencies = [
  "http 1.4.0",
  "httparse",
  "log",
- "rand 0.9.2",
+ "rand 0.9.4",
  "rustls",
  "rustls-pki-types",
  "sha1",
@@ -9309,7 +9309,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index ece4f4e931..b50ec8054c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -96,7 +96,7 @@ proc-macro2 = "1.0.103"
 prometheus = "0.14"
 prometheus-metric-storage = "0.6"
 quote = "1.0.41"
-rand = "0.8.5"
+rand = "0.9.4"
 rate-limit = { path = "crates/rate-limit" }
 refunder = { path = "crates/refunder" }
 regex = "1.10.4"
diff --git a/crates/autopilot/src/domain/settlement/observer.rs b/crates/autopilot/src/domain/settlement/observer.rs
index 97c0ef1c3e..33caa31ac7 100644
--- a/crates/autopilot/src/domain/settlement/observer.rs
+++ b/crates/autopilot/src/domain/settlement/observer.rs
@@ -18,7 +18,7 @@ use {
     anyhow::{Context, Result, anyhow},
     eth_domain_types as eth,
     futures::StreamExt,
-    rand::Rng,
+    rand::Rng as _,
     std::time::Duration,
 };
 
@@ -177,7 +177,7 @@ impl Observer {
                     errors.push(err);
                     tries += 1;
                     // wait a little to give temporary errors a chance to resolve themselves
-                    let timeout_with_jitter = 50u64 + rand::thread_rng().gen_range(0..=50);
+                    let timeout_with_jitter = 50u64 + rand::rng().random_range(0..=50);
                     tokio::time::sleep(Duration::from_millis(timeout_with_jitter)).await;
                 }
             }
diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs
index f67b7dc6fe..d95fbd7b7f 100644
--- a/crates/autopilot/src/run_loop.rs
+++ b/crates/autopilot/src/run_loop.rs
@@ -612,7 +612,7 @@ impl RunLoop {
         });
 
         // Shuffle so that sorting randomly splits ties.
-        bids.shuffle(&mut rand::thread_rng());
+        bids.shuffle(&mut rand::rng());
         bids
     }
 
diff --git a/crates/driver/src/tests/setup/driver.rs b/crates/driver/src/tests/setup/driver.rs
index 42219ccee8..e3e6cb3991 100644
--- a/crates/driver/src/tests/setup/driver.rs
+++ b/crates/driver/src/tests/setup/driver.rs
@@ -70,7 +70,7 @@ pub fn solve_req(test: &Test) -> serde_json::Value {
     // The orders are shuffled before being sent to the driver, to ensure that the
     // driver sorts them correctly before forwarding them to the solver.
     let mut quotes = test.quoted_orders.clone();
-    quotes.shuffle(&mut rand::thread_rng());
+    quotes.shuffle(&mut rand::rng());
     for quote in quotes.iter() {
         let mut order = json!({
             "uid": quote.order_uid(&test.blockchain),
diff --git a/crates/price-estimation/src/native_price_cache.rs b/crates/price-estimation/src/native_price_cache.rs
index e2e908520f..95768316e4 100644
--- a/crates/price-estimation/src/native_price_cache.rs
+++ b/crates/price-estimation/src/native_price_cache.rs
@@ -165,7 +165,7 @@ struct CacheInner {
 
 impl Cache {
     pub fn new(max_age: Duration, initial_prices: HashMap<Address, BigDecimal>) -> Self {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let now = std::time::Instant::now();
 
         let data = moka::sync::Cache::builder()
@@ -197,7 +197,7 @@ impl Cache {
     /// in the past, to avoid spikes of expired prices all being fetched at
     /// once.
     fn random_updated_at(max_age: Duration, now: Instant, rng: &mut impl Rng) -> Instant {
-        let percent_expired = rng.gen_range(50..=90);
+        let percent_expired = rng.random_range(50..=90);
         let age = max_age.as_secs() * percent_expired / 100;
         now - Duration::from_secs(age)
     }

From 6cccc33762f9bd6f1b4f3083804e18067b880aea Mon Sep 17 00:00:00 2001
From: Aryan Godara <65490434+AryanGodara@users.noreply.github.com>
Date: Wed, 15 Apr 2026 21:18:56 +0530
Subject: [PATCH 202/219] Bump alloy crates from 1.7.3 to 1.8.3 (#4333)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Checked latest versions available for all alloy and sub dependencies.
Bumps all alloy workspace dependencies to their latest 1.x versions:

alloy, alloy-consensus, alloy-contract, alloy-eips, alloy-json-rpc,
alloy-network, alloy-provider, alloy-rpc-client, alloy-rpc-types,
alloy-rpc-types-eth, alloy-rpc-types-trace, alloy-signer,
alloy-signer-local, alloy-transport, alloy-transport-ws: 1.7.3 → 1.8.3
alloy-primitives: 1.5.2 → 1.5.7
alloy-sol-types: 1.5.2 → 1.5.7
alloy-dyn-abi, alloy-json-abi were already at latest (1.5.7)


Separated from #4205 (pod network integration) PR to isolate the
dependency upgrade.
---
 Cargo.lock | 208 +++++++++++++++++++++++++++--------------------------
 Cargo.toml |  34 ++++-----
 2 files changed, 124 insertions(+), 118 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a5e95a136b..ccf00d13fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -83,9 +83,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "alloy"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4973038846323e4e69a433916522195dce2947770076c03078fc21c80ea0f1c4"
+checksum = "50ab0cd8afe573d1f7dc2353698a51b1f93aec362c8211e28cfd3948c6adba39"
 dependencies = [
  "alloy-consensus",
  "alloy-contract",
@@ -118,9 +118,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c0dc44157867da82c469c13186015b86abef209bf0e41625e4b68bac61d728"
+checksum = "7f16daaf7e1f95f62c6c3bf8a3fc3d78b08ae9777810c0bb5e94966c7cd57ef0"
 dependencies = [
  "alloy-eips",
  "alloy-primitives",
@@ -145,9 +145,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-consensus-any"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4cdb42df3871cd6b346d6a938ec2ba69a9a0f49d1f82714bc5c48349268434"
+checksum = "118998d9015332ab1b4720ae1f1e3009491966a0349938a1f43ff45a8a4c6299"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -159,9 +159,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-contract"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca63b7125a981415898ffe2a2a696c83696c9c6bdb1671c8a912946bbd8e49e7"
+checksum = "7ac9e0c34dc6bce643b182049cdfcca1b8ce7d9c260cbdd561f511873b7e26cd"
 dependencies = [
  "alloy-consensus",
  "alloy-dyn-abi",
@@ -177,13 +177,14 @@ dependencies = [
  "futures-util",
  "serde_json",
  "thiserror 2.0.17",
+ "tracing",
 ]
 
 [[package]]
 name = "alloy-core"
-version = "1.5.2"
+version = "1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d4087016b0896051dd3d03e0bedda2f4d4d1689af8addc8450288c63a9e5f68"
+checksum = "23e8604b0c092fabc80d075ede181c9b9e596249c70b99253082d7e689836529"
 dependencies = [
  "alloy-dyn-abi",
  "alloy-json-abi",
@@ -261,9 +262,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-eips"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f7ef09f21bd1e9cb8a686f168cb4a206646804567f0889eadb8dcc4c9288c8"
+checksum = "e6ef28c9fdad22d4eec52d894f5f2673a0895f1e5ef196734568e68c0f6caca8"
 dependencies = [
  "alloy-eip2124",
  "alloy-eip2930",
@@ -280,7 +281,6 @@ dependencies = [
  "serde",
  "serde_with",
  "sha2",
- "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -297,9 +297,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-json-rpc"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff42cd777eea61f370c0b10f2648a1c81e0b783066cd7269228aa993afd487f7"
+checksum = "422d110f1c40f1f8d0e5562b0b649c35f345fccb7093d9f02729943dcd1eef71"
 dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
@@ -312,9 +312,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-network"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cbca04f9b410fdc51aaaf88433cbac761213905a65fe832058bcf6690585762"
+checksum = "7197a66d94c4de1591cdc16a9bcea5f8cccd0da81b865b49aef97b1b4016e0fa"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
@@ -338,9 +338,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-network-primitives"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d6d15e069a8b11f56bef2eccbad2a873c6dd4d4c81d04dda29710f5ea52f04"
+checksum = "eb82711d59a43fdfd79727c99f270b974c784ec4eb5728a0d0d22f26716c87ef"
 dependencies = [
  "alloy-consensus",
  "alloy-eips",
@@ -379,9 +379,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-provider"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d181c8cc7cf4805d7e589bf4074d56d55064fa1a979f005a45a62b047616d870"
+checksum = "bf6b18b929ef1d078b834c3631e9c925177f3b23ddc6fa08a722d13047205876"
 dependencies = [
  "alloy-chains",
  "alloy-consensus",
@@ -412,7 +412,7 @@ dependencies = [
  "lru",
  "parking_lot",
  "pin-project",
- "reqwest 0.12.28",
+ "reqwest 0.13.2",
  "serde",
  "serde_json",
  "thiserror 2.0.17",
@@ -424,9 +424,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-pubsub"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8bd82953194dec221aa4cbbbb0b1e2df46066fe9d0333ac25b43a311e122d13"
+checksum = "5ad54073131e7292d4e03e1aa2287730f737280eb160d8b579fb31939f558c11"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -468,9 +468,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-client"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2792758a93ae32a32e9047c843d536e1448044f78422d71bf7d7c05149e103f"
+checksum = "94fcc9604042ca80bd37aa5e232ea1cd851f337e31e2babbbb345bc0b1c30de3"
 dependencies = [
  "alloy-json-rpc",
  "alloy-primitives",
@@ -480,7 +480,7 @@ dependencies = [
  "alloy-transport-ws",
  "futures",
  "pin-project",
- "reqwest 0.12.28",
+ "reqwest 0.13.2",
  "serde",
  "serde_json",
  "tokio",
@@ -493,9 +493,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bdcbf9dfd5eea8bfeb078b1d906da8cd3a39c4d4dbe7a628025648e323611f6"
+checksum = "4faad925d3a669ffc15f43b3deec7fbdf2adeb28a4d6f9cf4bc661698c0f8f4b"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-anvil",
@@ -509,9 +509,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-anvil"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a3100b76987c1b1dc81f3abe592b7edc29e92b1242067a69d65e0030b35cf9"
+checksum = "47df51bedb3e6062cb9981187a51e86d0d64a4de66eb0855e9efe6574b044ddf"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -521,9 +521,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-any"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd720b63f82b457610f2eaaf1f32edf44efffe03ae25d537632e7d23e7929e1a"
+checksum = "3823026d1ed239a40f12364fac50726c8daf1b6ab8077a97212c5123910429ed"
 dependencies = [
  "alloy-consensus-any",
  "alloy-rpc-types-eth",
@@ -532,9 +532,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-debug"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1b21e1ad18ff1b31ff1030e046462ab8168cf8894e6778cd805c8bdfe2bd649"
+checksum = "2145138f3214928f08cd13da3cb51ef7482b5920d8ac5a02ecd4e38d1a8f6d1e"
 dependencies = [
  "alloy-primitives",
  "derive_more 2.1.1",
@@ -544,9 +544,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-eth"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b2dc411f13092f237d2bf6918caf80977fc2f51485f9b90cb2a2f956912c8c9"
+checksum = "59c095f92c4e1ff4981d89e9aa02d5f98c762a1980ab66bec49c44be11349da2"
 dependencies = [
  "alloy-consensus",
  "alloy-consensus-any",
@@ -565,9 +565,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-trace"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad79f1e27e161943b5a4f99fe5534ef0849876214be411e0032c12f38e94daa"
+checksum = "2e5a4d010f86cd4e01e5205ec273911e538e1738e76d8bafe9ecd245910ea5a3"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -579,9 +579,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rpc-types-txpool"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d459f902a2313737bc66d18ed094c25d2aeb268b74d98c26bbbda2aa44182ab0"
+checksum = "942d26a2ca8891b26de4a8529d21091e21c1093e27eb99698f1a86405c76b1ff"
 dependencies = [
  "alloy-primitives",
  "alloy-rpc-types-eth",
@@ -591,9 +591,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-serde"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2ce1e0dbf7720eee747700e300c99aac01b1a95bb93f493a01e78ee28bb1a37"
+checksum = "11ece63b89294b8614ab3f483560c08d016930f842bf36da56bf0b764a15c11e"
 dependencies = [
  "alloy-primitives",
  "serde",
@@ -602,9 +602,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2425c6f314522c78e8198979c8cbf6769362be4da381d4152ea8eefce383535d"
+checksum = "43f447aefab0f1c0649f71edc33f590992d4e122bc35fb9cdbbf67d4421ace85"
 dependencies = [
  "alloy-dyn-abi",
  "alloy-primitives",
@@ -619,9 +619,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-aws"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e38b411077d7b17e464de7dfa599f5b94161cdffc25c2f28a90a3a345b6d6490"
+checksum = "8194c416115dc27f03796c0075dee0731239e2d7fbce735a74894aa8f6a47d7d"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -638,9 +638,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-signer-local"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3ecb71ee53d8d9c3fa7bac17542c8116ebc7a9726c91b1bf333ec3d04f5a789"
+checksum = "f721f4bf2e4812e5505aaf5de16ef3065a8e26b9139ac885862d00b5a55a659a"
 dependencies = [
  "alloy-consensus",
  "alloy-network",
@@ -730,9 +730,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa186e560d523d196580c48bf00f1bf62e63041f28ecf276acc22f8b27bb9f53"
+checksum = "8098f965442a9feb620965ba4b4be5e2b320f4ec5a3fff6bfa9e1ff7ef42bed1"
 dependencies = [
  "alloy-json-rpc",
  "auto_impl",
@@ -753,14 +753,14 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-http"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa501ad58dd20acddbfebc65b52e60f05ebf97c52fa40d1b35e91f5e2da0ad0e"
+checksum = "e8597d36d546e1dab822345ad563243ec3920e199322cb554ce56c8ef1a1e2e7"
 dependencies = [
  "alloy-json-rpc",
  "alloy-transport",
  "itertools 0.14.0",
- "reqwest 0.12.28",
+ "reqwest 0.13.2",
  "serde_json",
  "tower 0.5.3",
  "tracing",
@@ -769,18 +769,20 @@ dependencies = [
 
 [[package]]
 name = "alloy-transport-ws"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f00445db69d63298e2b00a0ea1d859f00e6424a3144ffc5eba9c31da995e16"
+checksum = "ec3ab7a72b180992881acc112628b7668337a19ce15293ee974600ea7b693691"
 dependencies = [
  "alloy-pubsub",
  "alloy-transport",
  "futures",
  "http 1.4.0",
+ "rustls",
  "serde_json",
  "tokio",
  "tokio-tungstenite",
  "tracing",
+ "url",
  "ws_stream_wasm",
 ]
 
@@ -802,11 +804,11 @@ dependencies = [
 
 [[package]]
 name = "alloy-tx-macros"
-version = "1.7.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fa0c53e8c1e1ef4d01066b01c737fb62fc9397ab52c6e7bb5669f97d281b9bc"
+checksum = "d69722eddcdf1ce096c3ab66cf8116999363f734eb36fe94a148f4f71c85da84"
 dependencies = [
- "darling 0.21.3",
+ "darling 0.23.0",
  "proc-macro2",
  "quote",
  "syn 2.0.114",
@@ -857,7 +859,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -868,7 +870,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -3604,6 +3606,16 @@ dependencies = [
  "darling_macro 0.21.3",
 ]
 
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core 0.23.0",
+ "darling_macro 0.23.0",
+]
+
 [[package]]
 name = "darling_core"
 version = "0.14.4"
@@ -3625,6 +3637,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
 dependencies = [
  "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim 0.11.1",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
@@ -3655,6 +3680,17 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core 0.23.0",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "dashmap"
 version = "6.1.0"
@@ -4072,7 +4108,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4865,22 +4901,6 @@ dependencies = [
  "tower-service",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes",
- "http-body-util",
- "hyper 1.8.1",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
-]
-
 [[package]]
 name = "hyper-util"
 version = "0.1.19"
@@ -5640,7 +5660,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -6909,20 +6929,16 @@ dependencies = [
  "http-body 1.0.1",
  "http-body-util",
  "hyper 1.8.1",
- "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
- "native-tls",
  "percent-encoding",
  "pin-project-lite",
- "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper 1.0.2",
  "tokio",
- "tokio-native-tls",
  "tower 0.5.3",
  "tower-http",
  "tower-service",
@@ -7164,7 +7180,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -7221,7 +7237,7 @@ dependencies = [
  "security-framework 3.5.1",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8300,7 +8316,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8521,16 +8537,6 @@ dependencies = [
  "syn 2.0.114",
 ]
 
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
@@ -8555,9 +8561,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.26.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
 dependencies = [
  "futures-util",
  "log",
@@ -8892,9 +8898,9 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "tungstenite"
-version = "0.26.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 dependencies = [
  "bytes",
  "data-encoding",
@@ -9309,7 +9315,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index b50ec8054c..7ad6cdcfab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,25 +5,25 @@ exclude = ["contracts/"]
 
 [workspace.dependencies]
 account-balances = { path = "crates/account-balances" }
-alloy = { version = "1.7.3", default-features = false }
-alloy-consensus = { version = "1.7.3", default-features = false }
-alloy-contract = { version = "1.7.3", default-features = false }
+alloy = { version = "1.8.3", default-features = false }
+alloy-consensus = { version = "1.8.3", default-features = false }
+alloy-contract = { version = "1.8.3", default-features = false }
 alloy-dyn-abi = { version = "1.5.7", default-features = false }
-alloy-eips = { version = "1.7.3", default-features = false }
+alloy-eips = { version = "1.8.3", default-features = false }
 alloy-json-abi = { version = "1.5.7", default-features = false }
-alloy-json-rpc = { version = "1.7.3", default-features = false }
-alloy-network = { version = "1.7.3", default-features = false }
-alloy-primitives = { version = "1.5.2", default-features = false }
-alloy-provider = { version = "1.7.3", default-features = false }
-alloy-rpc-client = { version = "1.7.3", default-features = false }
-alloy-rpc-types = { version = "1.7.3", default-features = false }
-alloy-rpc-types-eth = { version = "1.7.3", default-features = false }
-alloy-rpc-types-trace = { version = "1.7.3", default-features = false }
-alloy-signer = { version = "1.7.3", default-features = false }
-alloy-signer-local = { version = "1.7.3", default-features = false }
-alloy-sol-types = { version = "1.5.2" }
-alloy-transport = { version = "1.7.3", default-features = false }
-alloy-transport-ws = { version = "1.7.3", default-features = false }
+alloy-json-rpc = { version = "1.8.3", default-features = false }
+alloy-network = { version = "1.8.3", default-features = false }
+alloy-primitives = { version = "1.5.7", default-features = false }
+alloy-provider = { version = "1.8.3", default-features = false }
+alloy-rpc-client = { version = "1.8.3", default-features = false }
+alloy-rpc-types = { version = "1.8.3", default-features = false }
+alloy-rpc-types-eth = { version = "1.8.3", default-features = false }
+alloy-rpc-types-trace = { version = "1.8.3", default-features = false }
+alloy-signer = { version = "1.8.3", default-features = false }
+alloy-signer-local = { version = "1.8.3", default-features = false }
+alloy-sol-types = { version = "1.5.7" }
+alloy-transport = { version = "1.8.3", default-features = false }
+alloy-transport-ws = { version = "1.8.3", default-features = false }
 anyhow = "1.0.100"
 app-data = { path = "crates/app-data" }
 arc-swap = "1.7.1"

From ea53cdc020f91493b27a2b4a3d27c30689f30e42 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 16 Apr 2026 14:00:22 +0200
Subject: [PATCH 203/219] Respect settle queue size (#4338)

# Description

The reference driver rejects new solutions when there is already a
backlog of solutions that still need to be submitted because they will
most likely not be mined in time. This is intended to protect very
competitive solvers from penalties when they win too much but can't
submit fast enough.
https://github.com/cowprotocol/services/pull/4167 introduced a bug where
the check whether to reject the `/solve` request only looks at the
available tx submission slots but not the settle queue.
This has the consequence that a solver with only a single submission EOA
that won an auction will reject `/solve` requests until the previous
solution was submitted.

# Changes

Add a semaphore with capacity equal to queue size to mimic missing queue
behavior.

---------

Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/driver/src/domain/competition/mod.rs | 210 ++++++++------------
 crates/driver/src/infra/api/mod.rs          |   2 +-
 crates/driver/src/tests/cases/settle.rs     | 167 +++++-----------
 3 files changed, 131 insertions(+), 248 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index c9c29f4ecf..a466456516 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -23,19 +23,16 @@ use {
     anyhow::Context as _,
     axum::{body::Body, http::Request},
     eth_domain_types as eth,
-    futures::{FutureExt, StreamExt, future::Either, stream::FuturesUnordered},
+    futures::{FutureExt, StreamExt, stream::FuturesUnordered},
     itertools::Itertools,
     simulator::{RevertError, Simulator, SimulatorError},
     std::{
         cmp::Reverse,
         collections::{HashMap, HashSet, VecDeque},
         sync::{Arc, Mutex},
-        time::{Duration, Instant},
-    },
-    tokio::{
-        sync::{mpsc, oneshot},
-        task,
+        time::Instant,
     },
+    tokio::{sync::mpsc, task},
     tracing::{Instrument, instrument},
 };
 
@@ -70,6 +67,10 @@ struct SubmitterPool {
     direct_slot: Arc<tokio::sync::Semaphore>,
     /// EIP-7702 submission accounts. `None` in legacy single-EOA mode.
     delegated: Option<DelegatedSlots>,
+    /// Limits total in-flight settle requests (including those waiting for a
+    /// pool slot). This replaces the old settle-queue-based admission check
+    /// and allows buffering requests beyond the number of physical slots.
+    admission: Arc<tokio::sync::Semaphore>,
     solver_address: eth::Address,
 }
 
@@ -80,7 +81,12 @@ struct DelegatedSlots {
 }
 
 impl SubmitterPool {
-    fn new(solver_address: eth::Address, submission_accounts: Vec<Account>) -> Self {
+    fn new(
+        solver_address: eth::Address,
+        submission_accounts: Vec<Account>,
+        settle_queue_size: usize,
+    ) -> Self {
+        let num_delegated = submission_accounts.len();
         let delegated = if submission_accounts.is_empty() {
             None
         } else {
@@ -94,9 +100,12 @@ impl SubmitterPool {
                 acquire: tokio::sync::Mutex::new(rx),
             })
         };
+        let total_slots = 1 + num_delegated;
+        let admission_capacity = total_slots + settle_queue_size;
         Self {
             direct_slot: Arc::new(tokio::sync::Semaphore::new(1)),
             delegated,
+            admission: Arc::new(tokio::sync::Semaphore::new(admission_capacity)),
             solver_address,
         }
     }
@@ -152,21 +161,10 @@ impl SubmitterPool {
         })
     }
 
-    fn total_slots(&self) -> usize {
-        // 1 slot for solver EOA + number of delegated EIP7702 accounts (if any)
-        1 + self
-            .delegated
-            .as_ref()
-            .map_or(0, |d| d.release.max_capacity())
-    }
-
-    fn has_capacity(&self) -> bool {
-        if self.direct_slot.available_permits() > 0 {
-            return true;
-        }
-        self.delegated
-            .as_ref()
-            .is_some_and(|d| d.release.capacity() < d.release.max_capacity())
+    /// Try to reserve an admission permit without blocking. Returns `None` if
+    /// the maximum number of in-flight settle requests has been reached.
+    fn try_admit(&self) -> Option<tokio::sync::OwnedSemaphorePermit> {
+        Arc::clone(&self.admission).try_acquire_owned().ok()
     }
 }
 
@@ -215,6 +213,40 @@ impl Drop for SubmitterGuard {
     }
 }
 
+/// Wrapper around a spawned settlement task's [`JoinHandle`]. When dropped
+/// (e.g. because the HTTP handler was cancelled by the autopilot), the task is
+/// aborted after a short grace period to allow cleanup (e.g. cancelling a
+/// pending mempool tx).
+struct SettleTaskHandle(task::JoinHandle<Result<Settled, Error>>);
+
+impl std::future::Future for SettleTaskHandle {
+    type Output = Result<Settled, Error>;
+
+    fn poll(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        std::pin::Pin::new(&mut self.0).poll(cx).map(|join_result| {
+            join_result.map_err(|err| {
+                tracing::error!(?err, "settle task panicked");
+                Error::SubmissionError
+            })?
+        })
+    }
+}
+
+impl Drop for SettleTaskHandle {
+    fn drop(&mut self) {
+        if !self.0.is_finished() {
+            let handle = self.0.abort_handle();
+            tokio::spawn(async move {
+                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                handle.abort();
+            });
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Competition {
     pub solver: Solver,
@@ -228,7 +260,6 @@ pub struct Competition {
     /// bad token and orders detector
     pub risk_detector: Arc<risk_detector::Detector>,
     fetcher: Arc<pre_processing::DataAggregator>,
-    settle_queue: mpsc::Sender<SettleRequest>,
     order_sorting_strategies: Vec<Arc<dyn sorting::SortingStrategy>>,
     submitter_pool: SubmitterPool,
 }
@@ -253,11 +284,11 @@ impl Competition {
                 "EIP-7702 parallel submission enabled"
             );
         }
-        let submitter_pool = SubmitterPool::new(solver.address(), submission_accounts);
-        let queue_size = submitter_pool.total_slots().max(solver.settle_queue_size());
-        let (settle_sender, settle_receiver) = mpsc::channel(queue_size);
+        let settle_queue_size = solver.settle_queue_size();
+        let submitter_pool =
+            SubmitterPool::new(solver.address(), submission_accounts, settle_queue_size);
 
-        let competition = Arc::new(Self {
+        Arc::new(Self {
             solver,
             eth,
             liquidity,
@@ -265,21 +296,11 @@ impl Competition {
             simulator,
             mempools,
             settlements: Default::default(),
-            settle_queue: settle_sender,
             risk_detector,
             fetcher,
             order_sorting_strategies,
             submitter_pool,
-        });
-
-        let competition_clone = Arc::clone(&competition);
-        tokio::spawn(async move {
-            competition_clone
-                .process_settle_requests(settle_receiver)
-                .await;
-        });
-
-        competition
+        })
     }
 
     /// Solve an auction as part of this competition.
@@ -744,34 +765,41 @@ impl Competition {
     /// Execute the solution generated as part of this competition. Use
     /// [`Competition::solve`] to generate the solution.
     pub async fn settle(
-        &self,
+        self: &Arc<Self>,
         auction_id: auction::Id,
         solution_id: u64,
         submission_deadline: BlockNo,
     ) -> Result<Settled, Error> {
-        let (response_sender, response_receiver) = oneshot::channel();
-
-        let request = SettleRequest {
-            auction_id,
-            solution_id,
-            submission_deadline,
-            response_sender,
-            tracing_span: tracing::Span::current(),
-        };
-
-        self.settle_queue.try_send(request).map_err(|err| {
-            tracing::warn!(?err, "Failed to enqueue /settle request");
+        let admission_permit = self.submitter_pool.try_admit().ok_or_else(|| {
+            tracing::warn!("too many pending settlements; settle request rejected");
             Error::TooManyPendingSettlements
         })?;
 
-        response_receiver.await.map_err(|err| {
-            tracing::error!(?err, "Failed to dequeue /settle response");
-            Error::SubmissionError
-        })?
+        if self.eth.current_block().borrow().number >= submission_deadline.0 {
+            return Err(DeadlineExceeded.into());
+        }
+
+        let this = Arc::clone(self);
+        let tracing_span = tracing::Span::current();
+        // Spawn as a separate task to enable concurrent EIP-7702 submissions.
+        // SettleTaskHandle aborts the task (with a grace period) if the caller
+        // disconnects.
+        let handle = tokio::spawn(
+            async move {
+                let result = this
+                    .process_settle_request(auction_id, solution_id, submission_deadline)
+                    .await;
+                observe::settled(this.solver.name(), &result);
+                drop(admission_permit);
+                result
+            }
+            .instrument(tracing_span),
+        );
+        SettleTaskHandle(handle).await
     }
 
     pub fn ensure_settle_queue_capacity(&self) -> Result<(), Error> {
-        if !self.submitter_pool.has_capacity() {
+        if self.submitter_pool.admission.available_permits() == 0 {
             tracing::warn!("no idle submission slots; auction is rejected");
             Err(Error::TooManyPendingSettlements)
         } else {
@@ -779,68 +807,6 @@ impl Competition {
         }
     }
 
-    async fn process_settle_requests(
-        self: Arc<Self>,
-        mut settle_receiver: mpsc::Receiver<SettleRequest>,
-    ) {
-        while let Some(request) = settle_receiver.recv().await {
-            // When only the direct solver EOA slot exists and no delegated accounts are set
-            // up, the pool's acquire() blocks until the slot is free,  serializing
-            // settlements.
-            let this = Arc::clone(&self);
-            tokio::spawn(async move {
-                this.handle_settle_request(request).await;
-            });
-        }
-    }
-
-    async fn handle_settle_request(self: &Arc<Self>, request: SettleRequest) {
-        let SettleRequest {
-            auction_id,
-            solution_id,
-            submission_deadline,
-            mut response_sender,
-            tracing_span,
-        } = request;
-        async {
-            if self.eth.current_block().borrow().number >= submission_deadline.0 {
-                if let Err(err) = response_sender.send(Err(DeadlineExceeded.into())) {
-                    tracing::error!(
-                        ?err,
-                        "settle deadline exceeded. unable to return a response"
-                    );
-                }
-                return;
-            }
-
-            observe::settling();
-            let settle_fut =
-                Box::pin(self.process_settle_request(auction_id, solution_id, submission_deadline));
-            let closed_fut = Box::pin(response_sender.closed());
-            let result = match futures::future::select(closed_fut, settle_fut).await {
-                // Cancel the settlement task if the sender is closed (client likely
-                // disconnected). This is a fallback to recover from issues
-                // like a stuck driver (e.g., stalled block stream).
-                Either::Left((_closed, settle_fut)) => {
-                    tracing::debug!("autopilot terminated settle call");
-                    // Add a grace period to give driver the last chance to cancel the
-                    // tx if needed.
-                    tokio::time::timeout(Duration::from_secs(1), settle_fut)
-                        .await
-                        .unwrap_or_else(|_| {
-                            tracing::error!("didn't finish tx submission within grace period");
-                            Err(DeadlineExceeded.into())
-                        })
-                }
-                Either::Right((res, _)) => res,
-            };
-            observe::settled(self.solver.name(), &result);
-            let _ = response_sender.send(result);
-        }
-        .instrument(tracing_span)
-        .await
-    }
-
     async fn process_settle_request(
         &self,
         auction_id: auction::Id,
@@ -989,14 +955,6 @@ fn merge(
     merged
 }
 
-struct SettleRequest {
-    auction_id: auction::Id,
-    solution_id: u64,
-    submission_deadline: BlockNo,
-    response_sender: oneshot::Sender<Result<Settled, Error>>,
-    tracing_span: tracing::Span,
-}
-
 /// Solution information sent to the protocol by the driver before the solution
 /// ranking happens.
 #[derive(Debug)]
diff --git a/crates/driver/src/infra/api/mod.rs b/crates/driver/src/infra/api/mod.rs
index 45ec0dde24..e9d0ce022b 100644
--- a/crates/driver/src/infra/api/mod.rs
+++ b/crates/driver/src/infra/api/mod.rs
@@ -195,7 +195,7 @@ impl State {
         &self.0.solver
     }
 
-    fn competition(&self) -> &domain::Competition {
+    fn competition(&self) -> &Arc<domain::Competition> {
         &self.0.competition
     }
 
diff --git a/crates/driver/src/tests/cases/settle.rs b/crates/driver/src/tests/cases/settle.rs
index f184381c0e..0273694d0d 100644
--- a/crates/driver/src/tests/cases/settle.rs
+++ b/crates/driver/src/tests/cases/settle.rs
@@ -143,9 +143,15 @@ async fn does_not_bid_huge_solution() {
     test.solve().await.ok().empty();
 }
 
+/// Verifies the admission semaphore correctly limits in-flight settle requests
+/// to `pool_slots + settle_queue_size` (default 1 + 2 = 3). We can submit as
+/// many bids as we want as long as there is at least 1 settle queue spot
+/// available, but once the queue is full, new /solve requests are rejected.
+/// After the settlements complete, capacity is restored and new bids can be
+/// submitted.
 #[tokio::test]
 #[ignore]
-async fn discards_excess_settle_and_solve_requests() {
+async fn settle_queue_capacity_is_respected() {
     let test = Arc::new(
         tests::setup()
             .allow_multiple_solve_requests()
@@ -157,8 +163,9 @@ async fn discards_excess_settle_and_solve_requests() {
             .await,
     );
 
-    // MAX_SOLUTION_STORAGE = 5. Since this is hardcoded, no more solutions can be
-    // stored.
+    // Admission permits are only consumed by /settle, not /solve, so we can
+    // generate as many bids as we want. MAX_SOLUTION_STORAGE = 5 is the only
+    // cap here.
     let solution_ids = join_all(vec![
         test.solve(),
         test.solve(),
@@ -174,143 +181,61 @@ async fn discards_excess_settle_and_solve_requests() {
     let unique_solutions_count = solution_ids.iter().unique().count();
     assert_eq!(unique_solutions_count, solution_ids.len());
 
-    // Disable auto mining to accumulate all the settlement requests.
+    // Disable auto mining so settlements block on confirmation.
     test.set_auto_mining(false).await;
 
-    // To avoid race conditions with the settlement queue processing, a
-    // `/settle` request needs to be sent first, so it is dequeued, and it's
-    // execution is paused before any subsequent request is received.
-    let test_clone = Arc::clone(&test);
-    let first_solution_id = solution_ids[0];
-    let first_settlement_fut =
-        tokio::spawn(async move { test_clone.settle(first_solution_id).await });
-    // Make sure the first settlement gets dequeued before sending the remaining
-    // requests.
-    tokio::time::sleep(Duration::from_millis(100)).await;
-    let remaining_solutions = solution_ids[1..].to_vec();
-    let remaining_settlements = {
+    // Send settle requests one at a time so admission is deterministic.
+    // Admission capacity = 1 (pool slot) + 2 (settle_queue_size) = 3.
+    let mut settle_futs = Vec::new();
+    for &id in &solution_ids {
         let test_clone = Arc::clone(&test);
-        remaining_solutions.into_iter().map(move |id| {
-            let test_clone = Arc::clone(&test_clone);
-            async move { test_clone.settle(id).await }
-        })
-    };
-    let remaining_settlements_fut = tokio::spawn(join_all(remaining_settlements));
+        settle_futs.push(tokio::spawn(async move { test_clone.settle(id).await }));
+        tokio::time::sleep(Duration::from_millis(50)).await;
+    }
 
-    // Sleep for a bit to make sure all the settlement requests are queued.
-    tokio::time::sleep(Duration::from_millis(500)).await;
+    // Wait for all requests to be either in-flight or rejected.
+    tokio::time::sleep(Duration::from_millis(200)).await;
 
-    // While there is no room in the settlement queue, `/solve` requests must be
-    // rejected.
+    // While all admission slots are taken, /solve requests must be rejected.
     test.solve().await.err().kind("TooManyPendingSettlements");
 
     // Enable auto mining to process all the settlement requests.
-    // *Note that processing the settlement requests will change the gas estimates!*
+    // *Note that processing the settlement requests will change the gas
+    // estimates!*
     test.set_auto_mining(true).await;
 
-    // The first settlement must be successful.
-    let first_settlement = first_settlement_fut.await.unwrap();
-    first_settlement.ok().await.ab_order_executed(&test).await;
-
-    let remaining_settlements = remaining_settlements_fut.await.unwrap();
-    assert_eq!(remaining_settlements.len(), 4);
-
-    for (idx, result) in remaining_settlements.into_iter().enumerate() {
-        match idx {
-            // The next 2 settlements failed to submit due to the framework's limitation(unable to
-            // fulfill the same order again).
-            0 | 1 => result.err().kind("FailedToSubmit"),
-            // All the subsequent settlements rejected due to the settlement queue being full.
-            2 | 3 => result.err().kind("TooManyPendingSettlements"),
-            _ => unreachable!(),
-        }
-    }
-
-    // `/solve` works again.
-    test.solve().await.ok();
-}
-
-#[tokio::test]
-#[ignore]
-async fn accepts_new_settle_requests_after_timeout() {
-    let test = Arc::new(
-        tests::setup()
-            .allow_multiple_solve_requests()
-            .pool(ab_pool())
-            .order(ab_order())
-            .solution(ab_solution())
-            .settle_submission_deadline(6)
-            .done()
-            .await,
-    );
-
-    // MAX_SOLUTION_STORAGE = 5. Since this is hardcoded, no more solutions can be
-    // stored.
-    let solution_ids = join_all(vec![
-        test.solve(),
-        test.solve(),
-        test.solve(),
-        test.solve(),
-        test.solve(),
-    ])
-    .await
-    .into_iter()
-    .map(|res| res.ok().id())
-    .collect::<Vec<_>>();
-
-    let unique_solutions_count = solution_ids.iter().unique().count();
-    assert_eq!(unique_solutions_count, solution_ids.len());
-
-    // Disable auto mining to accumulate all the settlement requests.
-    test.set_auto_mining(false).await;
-
-    // To avoid race conditions with the settlement queue processing, a
-    // `/settle` request needs to be sent first, so it is dequeued, and it's
-    // execution is paused before any subsequent request is received.
-    let test_clone = Arc::clone(&test);
-    let first_solution_id = solution_ids[0];
-    let first_settlement_fut =
-        tokio::spawn(async move { test_clone.settle(first_solution_id).await });
-    // Make sure the first settlement gets dequeued before sending the remaining
-    // requests.
-    tokio::time::sleep(Duration::from_millis(100)).await;
-    // Send only 3 more settle requests.
-    let additional_solutions = solution_ids[1..4].to_vec();
-    let additional_settlements = {
-        let test_clone = Arc::clone(&test);
-        additional_solutions.into_iter().map(move |id| {
-            let test_clone = Arc::clone(&test_clone);
-            async move { test_clone.settle(id).await }
-        })
-    };
-    let additional_settlements_fut = tokio::spawn(join_all(additional_settlements));
-
-    // Sleep for a bit to make sure all the settlement requests are queued.
-    tokio::time::sleep(Duration::from_millis(500)).await;
-    test.set_auto_mining(true).await;
+    let results: Vec<_> = join_all(settle_futs)
+        .await
+        .into_iter()
+        .map(|r| r.unwrap())
+        .collect();
 
-    let first_settlement = first_settlement_fut.await.unwrap();
-    // The first settlement must be successful.
-    first_settlement.ok().await.ab_order_executed(&test).await;
+    let mut results = results.into_iter();
 
-    let additional_settlements = additional_settlements_fut.await.unwrap();
-    assert_eq!(additional_settlements.len(), 3);
+    // The first settle should succeed on-chain.
+    results
+        .next()
+        .unwrap()
+        .ok()
+        .await
+        .ab_order_executed(&test)
+        .await;
 
-    for (idx, result) in additional_settlements.into_iter().enumerate() {
+    for (idx, result) in results.enumerate() {
         match idx {
-            // The next 2 settlements failed to submit due to the framework's limitation(unable to
-            // fulfill the same order again).
+            // Admitted but can't fulfill the same order again.
             0 | 1 => result.err().kind("FailedToSubmit"),
-            // The next request gets rejected due to the settlement queue being full.
-            2 => result.err().kind("TooManyPendingSettlements"),
+            // Rejected by the admission semaphore.
+            2 | 3 => result.err().kind("TooManyPendingSettlements"),
             _ => unreachable!(),
         }
     }
 
-    // Now we send the last settlement request. It fails due to the framework's
-    // limitation(unable to fulfill the same order again).
-    test.settle(solution_ids[4])
+    // Capacity is restored — settle works again. Use an existing solution ID
+    // (it was already removed from cache by the first settle, so this returns
+    // SolutionNotAvailable — but it proves admission doesn't reject).
+    test.settle(solution_ids[0])
         .await
         .err()
-        .kind("FailedToSubmit");
+        .kind("SolutionNotAvailable");
 }

From 63bcb85aa445da8784f8e68d8a08ad840b515e50 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Thu, 16 Apr 2026 14:02:51 +0200
Subject: [PATCH 204/219] Use a common prefix for internal endpoints (#4339)

# Description

We now have a few endpoints that we don't want to expose to the public
and every single one of them has a) a rule in WAF b) a rule on the infra
level that exposes it to partners with an API key.

Instead of setting these every time we create a new internal endpoint we
can use the same rules for all endpoints with the `/api/internal`
prefix.

# How to test

Existing e2e tests.
---
 .claude/commands/debug-order.md            |  2 +-
 crates/e2e/tests/e2e/debug_order.rs        | 10 +++++---
 crates/e2e/tests/e2e/malformed_requests.rs | 29 ++++++++++++----------
 crates/e2e/tests/e2e/order_simulation.rs   | 20 +++++++++------
 crates/orderbook/openapi.yml               |  6 ++---
 crates/orderbook/src/api.rs                |  9 ++++---
 crates/orderbook/src/dto/mod.rs            |  2 +-
 7 files changed, 46 insertions(+), 32 deletions(-)

diff --git a/.claude/commands/debug-order.md b/.claude/commands/debug-order.md
index b2816273ef..359648cf0a 100644
--- a/.claude/commands/debug-order.md
+++ b/.claude/commands/debug-order.md
@@ -10,7 +10,7 @@ Key steps:
 1. Parse the order UID and network from arguments (default: mainnet)
 2. **Start with the debug endpoint** — fetch the comprehensive debug report first:
    ```bash
-   source .env.claude && curl -s -H "X-API-Key: $COW_DEBUG_API_KEY" "https://partners.cow.fi/$NETWORK/api/v1/debug/order/$ORDER_UID" | jq .
+   source .env.claude && curl -s -H "X-API-Key: $COW_DEBUG_API_KEY" "https://partners.cow.fi/$NETWORK/restricted/api/v1/debug/order/$ORDER_UID" | jq .
    ```
    This returns order details, lifecycle events, auction participation, proposed solutions, executions, trades, and settlement attempts — all in one call.
 3. Analyze the debug report — key event meanings:
diff --git a/crates/e2e/tests/e2e/debug_order.rs b/crates/e2e/tests/e2e/debug_order.rs
index d78d92470e..c98fdd4d8d 100644
--- a/crates/e2e/tests/e2e/debug_order.rs
+++ b/crates/e2e/tests/e2e/debug_order.rs
@@ -88,7 +88,7 @@ async fn debug_order(web3: Web3) {
     // Helper to fetch the debug report.
     let fetch_debug_report = || async {
         let response = client
-            .get(format!("{API_HOST}/api/v1/debug/order/{uid}"))
+            .get(format!("{API_HOST}/restricted/api/v1/debug/order/{uid}"))
             .send()
             .await
             .unwrap();
@@ -151,7 +151,9 @@ async fn debug_order(web3: Web3) {
     // Non-existent order -> 404.
     let fake_uid = "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/order/{fake_uid}"))
+        .get(format!(
+            "{API_HOST}/restricted/api/v1/debug/order/{fake_uid}"
+        ))
         .send()
         .await
         .unwrap();
@@ -232,7 +234,7 @@ async fn debug_order_filter_reason(web3: Web3) {
     let has_invalid_event = || async {
         onchain.mint_block().await;
         let response = client
-            .get(format!("{API_HOST}/api/v1/debug/order/{uid}"))
+            .get(format!("{API_HOST}/restricted/api/v1/debug/order/{uid}"))
             .send()
             .await
             .unwrap();
@@ -247,7 +249,7 @@ async fn debug_order_filter_reason(web3: Web3) {
         .unwrap();
 
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/order/{uid}"))
+        .get(format!("{API_HOST}/restricted/api/v1/debug/order/{uid}"))
         .send()
         .await
         .unwrap();
diff --git a/crates/e2e/tests/e2e/malformed_requests.rs b/crates/e2e/tests/e2e/malformed_requests.rs
index c60d6635dc..f6ccc40a66 100644
--- a/crates/e2e/tests/e2e/malformed_requests.rs
+++ b/crates/e2e/tests/e2e/malformed_requests.rs
@@ -343,11 +343,13 @@ async fn http_validation(web3: Web3) {
 
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
-    // GET /api/v1/debug/simulation/{uid} error cases
+    // GET /restricted/api/v1/debug/simulation/{uid} error cases
 
     // Malformed UID → 400
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/simulation/bad_uid"))
+        .get(format!(
+            "{API_HOST}/restricted/api/v1/debug/simulation/bad_uid"
+        ))
         .send()
         .await
         .unwrap();
@@ -360,7 +362,7 @@ async fn http_validation(web3: Web3) {
     // Valid UID but order not found → 404
     let response = client
         .get(format!(
-            "{API_HOST}/api/v1/debug/simulation/{VALID_ORDER_UID}"
+            "{API_HOST}/restricted/api/v1/debug/simulation/{VALID_ORDER_UID}"
         ))
         .send()
         .await
@@ -377,7 +379,8 @@ async fn http_validation(web3: Web3) {
     // Invalid block_number query param → 400
     let response = client
         .get(format!(
-            "{API_HOST}/api/v1/debug/simulation/{VALID_ORDER_UID}?block_number=notanumber"
+            "{API_HOST}/restricted/api/v1/debug/simulation/{VALID_ORDER_UID}?\
+             block_number=notanumber"
         ))
         .send()
         .await
@@ -388,11 +391,11 @@ async fn http_validation(web3: Web3) {
         "non-numeric block_number should return 400"
     );
 
-    // POST /api/v1/debug/simulation error cases
+    // POST /restricted/api/v1/debug/simulation error cases
 
     // Invalid JSON body → 400
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .header("Content-Type", "application/json")
         .body("{invalid json}")
         .send()
@@ -406,7 +409,7 @@ async fn http_validation(web3: Web3) {
 
     // Missing required fields → 422
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({}))
         .send()
         .await
@@ -419,7 +422,7 @@ async fn http_validation(web3: Web3) {
 
     // Invalid field type (bad address) → 422
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({
             "sellToken": "not-an-address",
             "buyToken": VALID_ADDRESS,
@@ -439,7 +442,7 @@ async fn http_validation(web3: Web3) {
 
     // Zero sellAmount (NonZeroU256 rejects zero at deserialization) → 422
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({
             "sellToken": VALID_ADDRESS,
             "buyToken": VALID_ADDRESS,
@@ -459,7 +462,7 @@ async fn http_validation(web3: Web3) {
 
     // Invalid kind enum value → 422
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({
             "sellToken": VALID_ADDRESS,
             "buyToken": VALID_ADDRESS,
@@ -480,7 +483,7 @@ async fn http_validation(web3: Web3) {
     // Invalid appData (non-JSON string triggers MalformedInput) → 400
     let bad_app_data = "not valid json";
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({
             "sellToken": VALID_ADDRESS,
             "buyToken": VALID_ADDRESS,
@@ -539,7 +542,7 @@ async fn simulation_not_enabled(web3: Web3) {
     // GET → 405 when simulation is not enabled
     let response = client
         .get(format!(
-            "{API_HOST}/api/v1/debug/simulation/{VALID_ORDER_UID}"
+            "{API_HOST}/restricted/api/v1/debug/simulation/{VALID_ORDER_UID}"
         ))
         .send()
         .await
@@ -552,7 +555,7 @@ async fn simulation_not_enabled(web3: Web3) {
 
     // POST → 405 when simulation is not enabled
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&json!({
             "sellToken": VALID_ADDRESS,
             "buyToken": VALID_ADDRESS,
diff --git a/crates/e2e/tests/e2e/order_simulation.rs b/crates/e2e/tests/e2e/order_simulation.rs
index 4d574a6748..e7c63dc762 100644
--- a/crates/e2e/tests/e2e/order_simulation.rs
+++ b/crates/e2e/tests/e2e/order_simulation.rs
@@ -63,7 +63,7 @@ async fn custom_order_simulation(web3: Web3) {
 
     // Trader has no sell tokens — simulation should revert.
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&request)
         .send()
         .await
@@ -87,7 +87,7 @@ async fn custom_order_simulation(web3: Web3) {
 
     // Simulation should now succeed.
     let response = client
-        .post(format!("{API_HOST}/api/v1/debug/simulation"))
+        .post(format!("{API_HOST}/restricted/api/v1/debug/simulation"))
         .json(&request)
         .send()
         .await
@@ -183,7 +183,7 @@ async fn order_simulation(web3: Web3) {
     // Simulation at the block where the trader had no WETH must fail.
     let response = client
         .get(format!(
-            "{API_HOST}/api/v1/debug/simulation/{uid}?block_number={block_no_funds}"
+            "{API_HOST}/restricted/api/v1/debug/simulation/{uid}?block_number={block_no_funds}"
         ))
         .send()
         .await
@@ -199,7 +199,7 @@ async fn order_simulation(web3: Web3) {
     // Simulation at the block where the trader has WETH must succeed.
     let response = client
         .get(format!(
-            "{API_HOST}/api/v1/debug/simulation/{uid}?block_number={block_with_funds}"
+            "{API_HOST}/restricted/api/v1/debug/simulation/{uid}?block_number={block_with_funds}"
         ))
         .send()
         .await
@@ -215,7 +215,9 @@ async fn order_simulation(web3: Web3) {
     // Simulation at the latest block (block_number parameter omitted), must
     // succeed.
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .get(format!(
+            "{API_HOST}/restricted/api/v1/debug/simulation/{uid}"
+        ))
         .send()
         .await
         .unwrap();
@@ -313,7 +315,9 @@ async fn order_simulation_partial_fill(web3: Web3) {
 
     // filledAmount=0 on-chain; full 4 WETH needed; trader only has 1 → must fail.
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .get(format!(
+            "{API_HOST}/restricted/api/v1/debug/simulation/{uid}"
+        ))
         .send()
         .await
         .unwrap();
@@ -356,7 +360,9 @@ async fn order_simulation_partial_fill(web3: Web3) {
     // Without reading on-chain fill state the simulator would need the full
     // 4 WETH from the trader (who only holds ~2) and revert.
     let response = client
-        .get(format!("{API_HOST}/api/v1/debug/simulation/{uid}"))
+        .get(format!(
+            "{API_HOST}/restricted/api/v1/debug/simulation/{uid}"
+        ))
         .send()
         .await
         .unwrap();
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 836e895e8f..b2191161ea 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -765,7 +765,7 @@ paths:
                 $ref: "#/components/schemas/TotalSurplus"
         "400":
           description: Invalid address.
-  "/api/v1/debug/simulation":
+  "/restricted/api/v1/debug/simulation":
     post:
       operationId: debugSimulationPost
       summary: Simulate an arbitrary order.
@@ -797,7 +797,7 @@ paths:
             wrong field type, zero `sellAmount`, or unrecognised `kind` value.
         "500":
           description: Internal error.
-  "/api/v1/debug/simulation/{uid}":
+  "/restricted/api/v1/debug/simulation/{uid}":
     get:
       operationId: debugSimulation
       summary: Get Tenderly simulation request for an order.
@@ -836,7 +836,7 @@ paths:
           description: Order simulation endpoint is not enabled.
         "500":
           description: Internal error.
-  "/api/v1/debug/order/{uid}":
+  "/restricted/api/v1/debug/order/{uid}":
     get:
       operationId: debugOrder
       summary: Debug an order's lifecycle.
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 8ce797cfdb..441715d635 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -279,19 +279,22 @@ pub fn handle_all_routes(
             get(get_total_surplus::get_total_surplus_handler),
         ),
         ("GET", "/api/v1/version", get(version::version_handler)),
+        // Routes under `/restricted/api/` are not exposed publicly. WAF and
+        // infra rules restrict access to authenticated partners.
+        // New internal-only endpoints MUST use this prefix.
         (
             "GET",
-            "/api/v1/debug/order/{uid}",
+            "/restricted/api/v1/debug/order/{uid}",
             get(debug_order::debug_order_handler),
         ),
         (
             "GET",
-            "/api/v1/debug/simulation/{uid}",
+            "/restricted/api/v1/debug/simulation/{uid}",
             get(debug_simulation::debug_simulation_handler),
         ),
         (
             "POST",
-            "/api/v1/debug/simulation",
+            "/restricted/api/v1/debug/simulation",
             post(debug_simulation::debug_simulation_post_handler),
         ),
         // V2 routes
diff --git a/crates/orderbook/src/dto/mod.rs b/crates/orderbook/src/dto/mod.rs
index 9c14e3e259..75b868d17f 100644
--- a/crates/orderbook/src/dto/mod.rs
+++ b/crates/orderbook/src/dto/mod.rs
@@ -15,7 +15,7 @@ pub use {
     order::Order,
 };
 
-/// Request body for the POST /api/v1/debug/simulation endpoint.
+/// Request body for the POST /restricted/api/v1/debug/simulation endpoint.
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug, Default)]
 #[serde(rename_all = "camelCase")]

From 17d9f10d054e33aba20eea5e5b3838ca26240005 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Thu, 16 Apr 2026 17:23:10 +0100
Subject: [PATCH 205/219] Workflow to test contract generated code (#4336)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Adds a CI job to ensure that generated contract code was *just*
generated

# Changes

* CI job to detect manual tampering of generated code

## How to test
There are commits associated with this PR that should launch jobs that
will fail or pass, will add them here as they're done

"Successful failure" — i.e. detected changes:
https://github.com/cowprotocol/services/actions/runs/24463810679/job/71485172786?pr=4336
Successful success — i.e. no changes = nothing detected:
https://github.com/cowprotocol/services/actions/runs/24464073112/job/71486114618?pr=4336

---------

Co-authored-by: Jan [Yann] <4518474+fafk@users.noreply.github.com>
---
 .github/workflows/pull-request.yaml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/.github/workflows/pull-request.yaml b/.github/workflows/pull-request.yaml
index c5dda4d4c0..24a7e0caf6 100644
--- a/.github/workflows/pull-request.yaml
+++ b/.github/workflows/pull-request.yaml
@@ -301,3 +301,27 @@ jobs:
             fi
             attempt=$((attempt+1))
           done
+
+  generated-contracts:
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+      - run: rustup toolchain install stable --profile minimal
+      - run: rustup toolchain install nightly --profile minimal --component rustfmt
+      - uses: Swatinem/rust-cache@98c8021b550208e191a6a3145459bfc9fb29c4c0 # v2.8.0
+      - uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4.0.0
+        with:
+          just-version: 1.39.0
+      - uses: tombi-toml/setup-tombi@cebfd308ba02edadfcee148b7473536990950c92 # v1.0.8
+      - name: Verify the code hasn't been tampered with by generating contracts again and making sure there has been no changes
+        run: |
+          just generate-contracts
+          if git diff --exit-code; then
+            echo "✓ Generated contracts are up-to-date"
+          else
+            echo "✗ Generated contracts are out-of-date or were modified by hand. Please run 'just generate-contracts' and commit the changes."
+            exit 1
+          fi

From 32597206e6227064ec2f37ffa97cedf99ec88e3e Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Fri, 17 Apr 2026 17:44:42 +0200
Subject: [PATCH 206/219] Add internal solver competition endpoint (#4335)

# Description

In https://github.com/cowprotocol/services/pull/4330 we started hiding
auctions until their deadline passed. Our solver team however needs to
have access to the unfiltered data, so this PR adds and endpoint that
returns it and we're going to restrict access to it on the infra level.

---------

Co-authored-by: Aryan Godara <65490434+AryanGodara@users.noreply.github.com>
Co-authored-by: Martin Magnus <martin.beckmann@protonmail.com>
---
 crates/e2e/src/setup/services.rs              | 22 +++++++++++++++++++
 crates/e2e/tests/e2e/solver_competition.rs    | 15 +++++++++++++
 crates/orderbook/src/api.rs                   |  5 +++++
 .../src/api/get_solver_competition_v2.rs      | 17 ++++++++++++++
 4 files changed, 59 insertions(+)

diff --git a/crates/e2e/src/setup/services.rs b/crates/e2e/src/setup/services.rs
index 7edc2ecf95..10210baf7b 100644
--- a/crates/e2e/src/setup/services.rs
+++ b/crates/e2e/src/setup/services.rs
@@ -497,6 +497,28 @@ impl<'a> Services<'a> {
         }
     }
 
+    pub async fn get_solver_competition_unfiltered(
+        &self,
+        auction_id: AuctionId,
+    ) -> Result<solver_competition_v2::Response, StatusCode> {
+        let response = self
+            .http
+            .get(format!(
+                "{API_HOST}/restricted/api/v2/solver_competition/{auction_id}"
+            ))
+            .send()
+            .await
+            .unwrap();
+
+        let status = response.status();
+        let body = response.text().await.unwrap();
+
+        match status {
+            StatusCode::OK => Ok(serde_json::from_str(&body).unwrap()),
+            code => Err(code),
+        }
+    }
+
     pub async fn get_trades(&self, order: &OrderUid) -> Result<Vec<Trade>, StatusCode> {
         let url = format!("{API_HOST}/api/v1/trades?orderUid={order}");
         let response = self.http.get(url).send().await.unwrap();
diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs
index dc99576b64..f6ae64a9e5 100644
--- a/crates/e2e/tests/e2e/solver_competition.rs
+++ b/crates/e2e/tests/e2e/solver_competition.rs
@@ -160,6 +160,21 @@ async fn solver_competition(web3: Web3) {
         StatusCode::NOT_FOUND,
     );
 
+    // The internal (unfiltered) endpoint returns the data regardless.
+    let auction_id: i64 = {
+        let mut db = services.db().acquire().await.unwrap();
+        sqlx::query_scalar("SELECT id FROM competition_auctions ORDER BY id DESC LIMIT 1")
+            .fetch_one(&mut *db)
+            .await
+            .unwrap()
+    };
+    assert!(
+        services
+            .get_solver_competition_unfiltered(auction_id)
+            .await
+            .is_ok()
+    );
+
     // The indexed_trades poll mints a block on every iteration, which will
     // advance past the 3-block deadline while also waiting for the event
     // indexer to pick up the settlement.
diff --git a/crates/orderbook/src/api.rs b/crates/orderbook/src/api.rs
index 441715d635..243b1f6a2c 100644
--- a/crates/orderbook/src/api.rs
+++ b/crates/orderbook/src/api.rs
@@ -319,6 +319,11 @@ pub fn handle_all_routes(
             "/api/v2/trades",
             get(get_trades_v2::get_trades_handler),
         ),
+        (
+            "GET",
+            "/restricted/api/v2/solver_competition/{auction_id}",
+            get(get_solver_competition_v2::get_solver_competition_by_id_unfiltered_handler),
+        ),
     ];
 
     // Initialize metrics
diff --git a/crates/orderbook/src/api/get_solver_competition_v2.rs b/crates/orderbook/src/api/get_solver_competition_v2.rs
index 3c39aef7e2..66db3216b9 100644
--- a/crates/orderbook/src/api/get_solver_competition_v2.rs
+++ b/crates/orderbook/src/api/get_solver_competition_v2.rs
@@ -51,6 +51,23 @@ pub async fn get_solver_competition_latest_handler(
         .map(Json)
 }
 
+/// Internal endpoint that skips deadline filtering (access restricted on
+/// infra level).
+pub async fn get_solver_competition_by_id_unfiltered_handler(
+    State(state): State<Arc<AppState>>,
+    Path(auction_id): Path<u64>,
+) -> Response {
+    if auction_id > AuctionId::MAX.cast_unsigned() {
+        return LoadSolverCompetitionError::NotFound.into_response();
+    }
+
+    db(&state)
+        .load_competition_by_id(auction_id.cast_signed(), None)
+        .await
+        .map(Json)
+        .into_response()
+}
+
 fn db(state: &AppState) -> &Postgres {
     // While these queries actually don't write to the DB
     // the latency incurred by the DB replication process

From 33a63b5d45f8367963f89ed8286a75e95f0351f1 Mon Sep 17 00:00:00 2001
From: Kaze <230549489+kaze-cow@users.noreply.github.com>
Date: Mon, 20 Apr 2026 17:08:43 +0900
Subject: [PATCH 207/219] Add EIP-4626 native price estimator (#4243)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description

Adds a native price estimator for EIP-4626 vault tokens (e.g. sDAI,
wrapped yield vaults).

Many vault tokens lack direct DEX liquidity, causing native price
estimation to fail. This estimator unwraps the vault by querying the
on-chain `asset()` and `convertToAssets()` functions, then delegates
pricing of the underlying token to the next estimator in the stage.

# Changes

* **New `Eip4626` native price estimator**
(`crates/price-estimation/src/native/eip4626.rs`):
calls `asset()` + `decimals()` in parallel, then
`convertToAssets(10^decimals)` to compute the
shares-to-assets conversion rate, and multiplies by the inner
estimator's price for the
  underlying token.
* **Negative cache for non-vault tokens**: tokens whose `asset()` call
reverts are remembered in
a `Mutex<HashSet<Address>>` so subsequent requests skip the RPC
entirely. Cleared on process
  restart.
* **Timeout budget forwarding**: each vault RPC call is individually
bounded by
`tokio::time::timeout`, and whatever time remains is forwarded to the
inner estimator. This
keeps the total wall-clock time within the caller's original timeout,
which matters for
  recursive vault chains.
* **Configurable recursion depth**: the `Eip4626` config variant accepts
a `depth` parameter
(default: 1) controlling how many nested vault layers to unwrap. In the
factory, `depth` layers
  of `Eip4626` wrap the next estimator in the stage.
* **Config validation**: `NativePriceEstimators` deserialization rejects
stages where `Eip4626` is
the last entry (it must be followed by another estimator to price the
underlying asset).
* **Contract bindings**: added `IERC4626` interface and
`MockERC4626Wrapper` test contract for
  e2e tests.
* **Factory wiring** (`crates/price-estimation/src/factory.rs`):
`create_native_estimator` now
consumes the next estimator from the stage iterator when it encounters
`Eip4626`, wrapping it
  in `depth` layers of instrumented `Eip4626` estimators.
* **Re-added config deserialization tests** to
`crates/configs/src/native_price_estimators.rs`
that were lost during the extraction from `price-estimation` to
`configs`.

## How to test

1. Unit tests: `cargo nextest run -p price-estimation eip4626` and
`cargo nextest run -p configs native_price_estimators`
2. Live mainnet smoke test (requires `NODE_URL`): `NODE_URL=... cargo
nextest run -p price-estimation -- eip4626 --run-ignored ignored-only`
3. E2e forked tests (requires `FORK_URL_MAINNET`):
- Single vault: `cargo nextest run -p e2e
forked_node_mainnet_eip4626_native_price --test-threads 1 --run-ignored
ignored-only`
- Recursive vaults: `cargo nextest run -p e2e
forked_node_mainnet_eip4626_recursive_native_price --test-threads 1
--run-ignored ignored-only`

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: José Duarte <duarte.gmj@gmail.com>
Co-authored-by: José Duarte <15343819+jmg-duarte@users.noreply.github.com>
---
 Cargo.lock                                    |   25 +
 contracts/.gitignore                          |    2 +
 contracts/artifacts/IERC4626.json             |   36 +
 contracts/artifacts/MockERC4626Wrapper.json   |  240 ++
 contracts/generated/Cargo.lock                |   36 +
 .../generated/contracts-facade/Cargo.toml     |    2 +
 .../generated/contracts-facade/src/lib.rs     |    2 +
 .../contracts-generated/ierc4626/Cargo.toml   |   19 +
 .../contracts-generated/ierc4626/src/lib.rs   |  648 ++++
 .../mockerc4626wrapper/Cargo.toml             |   19 +
 .../mockerc4626wrapper/src/lib.rs             | 2768 +++++++++++++++++
 contracts/solidity/interfaces/IERC4626.sol    |    8 +
 .../solidity/tests/MockERC4626Wrapper.sol     |   54 +
 contracts/src/main.rs                         |    2 +
 contracts/src/vendor.rs                       |    4 +
 crates/autopilot/src/run.rs                   |    2 +
 crates/autopilot/src/solvable_orders.rs       |   27 +-
 crates/configs/src/autopilot/native_price.rs  |    7 +
 crates/e2e/tests/e2e/eip4626.rs               |  236 ++
 crates/e2e/tests/e2e/main.rs                  |    1 +
 crates/price-estimation/Cargo.toml            |    1 +
 crates/price-estimation/src/factory.rs        |   16 +-
 crates/price-estimation/src/native/eip4626.rs |  275 ++
 crates/price-estimation/src/native/mod.rs     |    2 +
 24 files changed, 4411 insertions(+), 21 deletions(-)
 create mode 100644 contracts/artifacts/IERC4626.json
 create mode 100644 contracts/artifacts/MockERC4626Wrapper.json
 create mode 100644 contracts/generated/contracts-generated/ierc4626/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/ierc4626/src/lib.rs
 create mode 100644 contracts/generated/contracts-generated/mockerc4626wrapper/Cargo.toml
 create mode 100644 contracts/generated/contracts-generated/mockerc4626wrapper/src/lib.rs
 create mode 100644 contracts/solidity/interfaces/IERC4626.sol
 create mode 100644 contracts/solidity/tests/MockERC4626Wrapper.sol
 create mode 100644 crates/e2e/tests/e2e/eip4626.rs
 create mode 100644 crates/price-estimation/src/native/eip4626.rs

diff --git a/Cargo.lock b/Cargo.lock
index ccf00d13fb..9d6a24c147 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2539,12 +2539,14 @@ dependencies = [
  "cow-contract-honeyswaprouter",
  "cow-contract-hookstrampoline",
  "cow-contract-icowwrapper",
+ "cow-contract-ierc4626",
  "cow-contract-iswaprpair",
  "cow-contract-iuniswaplikepair",
  "cow-contract-iuniswaplikerouter",
  "cow-contract-iuniswapv3factory",
  "cow-contract-izeroex",
  "cow-contract-liquoricesettlement",
+ "cow-contract-mockerc4626wrapper",
  "cow-contract-nonstandarderc20balances",
  "cow-contract-pancakerouter",
  "cow-contract-permit2",
@@ -3216,6 +3218,17 @@ dependencies = [
  "anyhow",
 ]
 
+[[package]]
+name = "cow-contract-ierc4626"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
 [[package]]
 name = "cow-contract-iswaprpair"
 version = "0.1.0"
@@ -3282,6 +3295,17 @@ dependencies = [
  "anyhow",
 ]
 
+[[package]]
+name = "cow-contract-mockerc4626wrapper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
 [[package]]
 name = "cow-contract-nonstandarderc20balances"
 version = "0.1.0"
@@ -6347,6 +6371,7 @@ dependencies = [
  "configs",
  "const-hex",
  "contracts",
+ "dashmap",
  "derive_more 1.0.0",
  "ethrpc",
  "futures",
diff --git a/contracts/.gitignore b/contracts/.gitignore
index 05923927ff..c0388e3cc4 100644
--- a/contracts/.gitignore
+++ b/contracts/.gitignore
@@ -1,2 +1,4 @@
 /target
+/out
+/cache
 .DS_Store
diff --git a/contracts/artifacts/IERC4626.json b/contracts/artifacts/IERC4626.json
new file mode 100644
index 0000000000..2d0eac6929
--- /dev/null
+++ b/contracts/artifacts/IERC4626.json
@@ -0,0 +1,36 @@
+{
+  "abi": [
+    {
+      "type": "function",
+      "name": "asset",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "assetTokenAddress",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "convertToAssets",
+      "inputs": [
+        {
+          "name": "shares",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "assets",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    }
+  ]
+}
diff --git a/contracts/artifacts/MockERC4626Wrapper.json b/contracts/artifacts/MockERC4626Wrapper.json
new file mode 100644
index 0000000000..4bbe02465e
--- /dev/null
+++ b/contracts/artifacts/MockERC4626Wrapper.json
@@ -0,0 +1,240 @@
+{
+  "abi": [
+    {
+      "type": "constructor",
+      "inputs": [
+        {
+          "name": "_asset",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "_decimals",
+          "type": "uint8",
+          "internalType": "uint8"
+        },
+        {
+          "name": "_rateNumerator",
+          "type": "uint256",
+          "internalType": "uint256"
+        },
+        {
+          "name": "_rateDenominator",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "allowance",
+      "inputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "approve",
+      "inputs": [
+        {
+          "name": "spender",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "amount",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bool",
+          "internalType": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "asset",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "balanceOf",
+      "inputs": [
+        {
+          "name": "",
+          "type": "address",
+          "internalType": "address"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "convertToAssets",
+      "inputs": [
+        {
+          "name": "shares",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "decimals",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint8",
+          "internalType": "uint8"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "mint",
+      "inputs": [
+        {
+          "name": "to",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "amount",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "rateDenominator",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "rateNumerator",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "transfer",
+      "inputs": [
+        {
+          "name": "to",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "amount",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bool",
+          "internalType": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "transferFrom",
+      "inputs": [
+        {
+          "name": "from",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "to",
+          "type": "address",
+          "internalType": "address"
+        },
+        {
+          "name": "amount",
+          "type": "uint256",
+          "internalType": "uint256"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bool",
+          "internalType": "bool"
+        }
+      ],
+      "stateMutability": "nonpayable"
+    }
+  ],
+  "bytecode": "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"
+}
diff --git a/contracts/generated/Cargo.lock b/contracts/generated/Cargo.lock
index fd0489b2d0..100d862231 100644
--- a/contracts/generated/Cargo.lock
+++ b/contracts/generated/Cargo.lock
@@ -1048,6 +1048,7 @@ dependencies = [
  "cow-contract-cowammlegacyhelper",
  "cow-contract-cowammuniswapv2priceoracle",
  "cow-contract-cowprotocoltoken",
+ "cow-contract-cowsettlementforwarder",
  "cow-contract-cowswapethflow",
  "cow-contract-cowswaponchainorders",
  "cow-contract-erc1271signaturevalidator",
@@ -1064,12 +1065,14 @@ dependencies = [
  "cow-contract-honeyswaprouter",
  "cow-contract-hookstrampoline",
  "cow-contract-icowwrapper",
+ "cow-contract-ierc4626",
  "cow-contract-iswaprpair",
  "cow-contract-iuniswaplikepair",
  "cow-contract-iuniswaplikerouter",
  "cow-contract-iuniswapv3factory",
  "cow-contract-izeroex",
  "cow-contract-liquoricesettlement",
+ "cow-contract-mockerc4626wrapper",
  "cow-contract-nonstandarderc20balances",
  "cow-contract-pancakerouter",
  "cow-contract-permit2",
@@ -1468,6 +1471,17 @@ dependencies = [
  "anyhow",
 ]
 
+[[package]]
+name = "cow-contract-cowsettlementforwarder"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
 [[package]]
 name = "cow-contract-cowswapethflow"
 version = "0.1.0"
@@ -1644,6 +1658,17 @@ dependencies = [
  "anyhow",
 ]
 
+[[package]]
+name = "cow-contract-ierc4626"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
 [[package]]
 name = "cow-contract-iswaprpair"
 version = "0.1.0"
@@ -1710,6 +1735,17 @@ dependencies = [
  "anyhow",
 ]
 
+[[package]]
+name = "cow-contract-mockerc4626wrapper"
+version = "0.1.0"
+dependencies = [
+ "alloy-contract",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-sol-types",
+ "anyhow",
+]
+
 [[package]]
 name = "cow-contract-nonstandarderc20balances"
 version = "0.1.0"
diff --git a/contracts/generated/contracts-facade/Cargo.toml b/contracts/generated/contracts-facade/Cargo.toml
index ca824f689c..902099c993 100644
--- a/contracts/generated/contracts-facade/Cargo.toml
+++ b/contracts/generated/contracts-facade/Cargo.toml
@@ -59,12 +59,14 @@ cow-contract-gpv2settlement = { path = "../contracts-generated/gpv2settlement" }
 cow-contract-honeyswaprouter = { path = "../contracts-generated/honeyswaprouter" }
 cow-contract-hookstrampoline = { path = "../contracts-generated/hookstrampoline" }
 cow-contract-icowwrapper = { path = "../contracts-generated/icowwrapper" }
+cow-contract-ierc4626 = { path = "../contracts-generated/ierc4626" }
 cow-contract-iswaprpair = { path = "../contracts-generated/iswaprpair" }
 cow-contract-iuniswaplikepair = { path = "../contracts-generated/iuniswaplikepair" }
 cow-contract-iuniswaplikerouter = { path = "../contracts-generated/iuniswaplikerouter" }
 cow-contract-iuniswapv3factory = { path = "../contracts-generated/iuniswapv3factory" }
 cow-contract-izeroex = { path = "../contracts-generated/izeroex" }
 cow-contract-liquoricesettlement = { path = "../contracts-generated/liquoricesettlement" }
+cow-contract-mockerc4626wrapper = { path = "../contracts-generated/mockerc4626wrapper" }
 cow-contract-nonstandarderc20balances = { path = "../contracts-generated/nonstandarderc20balances" }
 cow-contract-pancakerouter = { path = "../contracts-generated/pancakerouter" }
 cow-contract-permit2 = { path = "../contracts-generated/permit2" }
diff --git a/contracts/generated/contracts-facade/src/lib.rs b/contracts/generated/contracts-facade/src/lib.rs
index 91abfdf567..331b6a21aa 100644
--- a/contracts/generated/contracts-facade/src/lib.rs
+++ b/contracts/generated/contracts-facade/src/lib.rs
@@ -48,6 +48,7 @@ pub use {
     cow_contract_honeyswaprouter as HoneyswapRouter,
     cow_contract_hookstrampoline as HooksTrampoline,
     cow_contract_icowwrapper as ICowWrapper,
+    cow_contract_ierc4626 as IERC4626,
     cow_contract_iswaprpair as ISwaprPair,
     cow_contract_iuniswaplikepair as IUniswapLikePair,
     cow_contract_iuniswaplikerouter as IUniswapLikeRouter,
@@ -82,6 +83,7 @@ pub mod test {
         cow_contract_counter as Counter,
         cow_contract_cowprotocoltoken as CowProtocolToken,
         cow_contract_gashog as GasHog,
+        cow_contract_mockerc4626wrapper as MockERC4626Wrapper,
         cow_contract_nonstandarderc20balances as NonStandardERC20Balances,
         cow_contract_remoteerc20balances as RemoteERC20Balances,
     };
diff --git a/contracts/generated/contracts-generated/ierc4626/Cargo.toml b/contracts/generated/contracts-generated/ierc4626/Cargo.toml
new file mode 100644
index 0000000000..fe00f44d09
--- /dev/null
+++ b/contracts/generated/contracts-generated/ierc4626/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-ierc4626"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/ierc4626/src/lib.rs b/contracts/generated/contracts-generated/ierc4626/src/lib.rs
new file mode 100644
index 0000000000..11f48918c2
--- /dev/null
+++ b/contracts/generated/contracts-generated/ierc4626/src/lib.rs
@@ -0,0 +1,648 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface IERC4626 {
+    function asset() external view returns (address assetTokenAddress);
+    function convertToAssets(uint256 shares) external view returns (uint256 assets);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "function",
+    "name": "asset",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "assetTokenAddress",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "convertToAssets",
+    "inputs": [
+      {
+        "name": "shares",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "assets",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod IERC4626 {
+    use {super::*, alloy_sol_types};
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `asset()` and selector `0x38d52e0f`.
+    ```solidity
+    function asset() external view returns (address assetTokenAddress);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct assetCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`asset()`](assetCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct assetReturn {
+        #[allow(missing_docs)]
+        pub assetTokenAddress: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<assetCall> for UnderlyingRustTuple<'_> {
+                fn from(value: assetCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for assetCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<assetReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: assetReturn) -> Self {
+                    (value.assetTokenAddress,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for assetReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        assetTokenAddress: tuple.0,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for assetCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 213u8, 46u8, 15u8];
+            const SIGNATURE: &'static str = "asset()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: assetReturn = r.into();
+                        r.assetTokenAddress
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: assetReturn = r.into();
+                    r.assetTokenAddress
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `convertToAssets(uint256)` and selector `0x07a2d13a`.
+    ```solidity
+    function convertToAssets(uint256 shares) external view returns (uint256 assets);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct convertToAssetsCall {
+        #[allow(missing_docs)]
+        pub shares: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`convertToAssets(uint256)`](convertToAssetsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct convertToAssetsReturn {
+        #[allow(missing_docs)]
+        pub assets: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<convertToAssetsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: convertToAssetsCall) -> Self {
+                    (value.shares,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for convertToAssetsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { shares: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<convertToAssetsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: convertToAssetsReturn) -> Self {
+                    (value.assets,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for convertToAssetsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { assets: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for convertToAssetsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [7u8, 162u8, 209u8, 58u8];
+            const SIGNATURE: &'static str = "convertToAssets(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.shares,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: convertToAssetsReturn = r.into();
+                        r.assets
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: convertToAssetsReturn = r.into();
+                    r.assets
+                })
+            }
+        }
+    };
+    ///Container for all the [`IERC4626`](self) function calls.
+    #[derive(Clone)]
+    pub enum IERC4626Calls {
+        #[allow(missing_docs)]
+        asset(assetCall),
+        #[allow(missing_docs)]
+        convertToAssets(convertToAssetsCall),
+    }
+    impl IERC4626Calls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] =
+            &[[7u8, 162u8, 209u8, 58u8], [56u8, 213u8, 46u8, 15u8]];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <convertToAssetsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <assetCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(convertToAssets),
+            ::core::stringify!(asset),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for IERC4626Calls {
+        const COUNT: usize = 2usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "IERC4626Calls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::asset(_) => <assetCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::convertToAssets(_) => {
+                    <convertToAssetsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IERC4626Calls>] = &[
+                {
+                    fn convertToAssets(data: &[u8]) -> alloy_sol_types::Result<IERC4626Calls> {
+                        <convertToAssetsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IERC4626Calls::convertToAssets)
+                    }
+                    convertToAssets
+                },
+                {
+                    fn asset(data: &[u8]) -> alloy_sol_types::Result<IERC4626Calls> {
+                        <assetCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(IERC4626Calls::asset)
+                    }
+                    asset
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<IERC4626Calls>] =
+                &[
+                    {
+                        fn convertToAssets(data: &[u8]) -> alloy_sol_types::Result<IERC4626Calls> {
+                            <convertToAssetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                                data,
+                            )
+                            .map(IERC4626Calls::convertToAssets)
+                        }
+                        convertToAssets
+                    },
+                    {
+                        fn asset(data: &[u8]) -> alloy_sol_types::Result<IERC4626Calls> {
+                            <assetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                                .map(IERC4626Calls::asset)
+                        }
+                        asset
+                    },
+                ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::asset(inner) => {
+                    <assetCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::convertToAssets(inner) => {
+                    <convertToAssetsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::asset(inner) => {
+                    <assetCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::convertToAssets(inner) => {
+                    <convertToAssetsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`IERC4626`](self) contract instance.
+
+    See the [wrapper's documentation](`IERC4626Instance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> IERC4626Instance<P, N> {
+        IERC4626Instance::<P, N>::new(address, __provider)
+    }
+    /**A [`IERC4626`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`IERC4626`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct IERC4626Instance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for IERC4626Instance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("IERC4626Instance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IERC4626Instance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`IERC4626`](self) contract instance.
+
+        See the [wrapper's documentation](`IERC4626Instance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::core::marker::PhantomData,
+            }
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> IERC4626Instance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> IERC4626Instance<P, N> {
+            IERC4626Instance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IERC4626Instance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`asset`] function.
+        pub fn asset(&self) -> alloy_contract::SolCallBuilder<&P, assetCall, N> {
+            self.call_builder(&assetCall)
+        }
+
+        ///Creates a new call builder for the [`convertToAssets`] function.
+        pub fn convertToAssets(
+            &self,
+            shares: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, convertToAssetsCall, N> {
+            self.call_builder(&convertToAssetsCall { shares })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        IERC4626Instance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = IERC4626::IERC4626Instance<::alloy_provider::DynProvider>;
diff --git a/contracts/generated/contracts-generated/mockerc4626wrapper/Cargo.toml b/contracts/generated/contracts-generated/mockerc4626wrapper/Cargo.toml
new file mode 100644
index 0000000000..77ca06c21e
--- /dev/null
+++ b/contracts/generated/contracts-generated/mockerc4626wrapper/Cargo.toml
@@ -0,0 +1,19 @@
+# Auto-generated by contracts-generate. Do not edit.
+[package]
+name = "cow-contract-mockerc4626wrapper"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+doctest = false
+
+[dependencies]
+alloy-contract = { workspace = true }
+alloy-primitives = { workspace = true }
+alloy-provider = { workspace = true }
+alloy-sol-types = { workspace = true }
+anyhow = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/contracts/generated/contracts-generated/mockerc4626wrapper/src/lib.rs b/contracts/generated/contracts-generated/mockerc4626wrapper/src/lib.rs
new file mode 100644
index 0000000000..33f38b216f
--- /dev/null
+++ b/contracts/generated/contracts-generated/mockerc4626wrapper/src/lib.rs
@@ -0,0 +1,2768 @@
+#![allow(
+    unused_imports,
+    unused_attributes,
+    clippy::all,
+    rustdoc::all,
+    non_snake_case
+)]
+//! Auto-generated contract bindings. Do not edit.
+/**
+
+Generated by the following Solidity interface...
+```solidity
+interface MockERC4626Wrapper {
+    constructor(address _asset, uint8 _decimals, uint256 _rateNumerator, uint256 _rateDenominator);
+
+    function allowance(address, address) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function asset() external view returns (address);
+    function balanceOf(address) external view returns (uint256);
+    function convertToAssets(uint256 shares) external view returns (uint256);
+    function decimals() external view returns (uint8);
+    function mint(address to, uint256 amount) external;
+    function rateDenominator() external view returns (uint256);
+    function rateNumerator() external view returns (uint256);
+    function transfer(address to, uint256 amount) external returns (bool);
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+}
+```
+
+...which was generated by the following JSON ABI:
+```json
+[
+  {
+    "type": "constructor",
+    "inputs": [
+      {
+        "name": "_asset",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "_decimals",
+        "type": "uint8",
+        "internalType": "uint8"
+      },
+      {
+        "name": "_rateNumerator",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "_rateDenominator",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "allowance",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "approve",
+    "inputs": [
+      {
+        "name": "spender",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "asset",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "convertToAssets",
+    "inputs": [
+      {
+        "name": "shares",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "decimals",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "mint",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "rateDenominator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "rateNumerator",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "transfer",
+    "inputs": [
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "transferFrom",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  }
+]
+```*/
+#[allow(
+    non_camel_case_types,
+    non_snake_case,
+    clippy::pub_underscore_fields,
+    clippy::style,
+    clippy::empty_structs_with_brackets
+)]
+pub mod MockERC4626Wrapper {
+    use {super::*, alloy_sol_types};
+    /// The creation / init bytecode of the contract.
+    ///
+    /// ```text
+    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
+    /// ```
+    #[rustfmt::skip]
+    #[allow(clippy::all)]
+    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
+        b"a\x01\0`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0C\x178\x03\x80a\x0C\x17\x839\x81\x81\x01`@R\x81\x01\x90a\x002\x91\x90a\x01TV[\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x80\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x82`\xFF\x16`\xA0\x81`\xFF\x16\x81RPP\x81`\xC0\x81\x81RPP\x80`\xE0\x81\x81RPPPPPPa\x01\xB8V[__\xFD[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[_a\0\xBA\x82a\0\x91V[\x90P\x91\x90PV[a\0\xCA\x81a\0\xB0V[\x81\x14a\0\xD4W__\xFD[PV[_\x81Q\x90Pa\0\xE5\x81a\0\xC1V[\x92\x91PPV[_`\xFF\x82\x16\x90P\x91\x90PV[a\x01\0\x81a\0\xEBV[\x81\x14a\x01\nW__\xFD[PV[_\x81Q\x90Pa\x01\x1B\x81a\0\xF7V[\x92\x91PPV[_\x81\x90P\x91\x90PV[a\x013\x81a\x01!V[\x81\x14a\x01=W__\xFD[PV[_\x81Q\x90Pa\x01N\x81a\x01*V[\x92\x91PPV[____`\x80\x85\x87\x03\x12\x15a\x01lWa\x01ka\0\x8DV[[_a\x01y\x87\x82\x88\x01a\0\xD7V[\x94PP` a\x01\x8A\x87\x82\x88\x01a\x01\rV[\x93PP`@a\x01\x9B\x87\x82\x88\x01a\x01@V[\x92PP``a\x01\xAC\x87\x82\x88\x01a\x01@V[\x91PP\x92\x95\x91\x94P\x92PV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\n\x1Ea\x01\xF9_9_\x81\x81a\x02b\x01Ra\x05\\\x01R_\x81\x81a\x02\x83\x01Ra\x03H\x01R_a\x04\xAA\x01R_a\x04\xCE\x01Ra\n\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xA7W_5`\xE0\x1C\x80c8\xD5.\x0F\x11a\0oW\x80c8\xD5.\x0F\x14a\x01wW\x80c@\xC1\x0F\x19\x14a\x01\x95W\x80cp\xA0\x821\x14a\x01\xB1W\x80c\x86Q\x92\xF7\x14a\x01\xE1W\x80c\xA9\x05\x9C\xBB\x14a\x01\xFFW\x80c\xDDb\xED>\x14a\x02/Wa\0\xA7V[\x80c\x07\xA2\xD1:\x14a\0\xABW\x80c\t^\xA7\xB3\x14a\0\xDBW\x80c\x0B6\xB8\xDB\x14a\x01\x0BW\x80c#\xB8r\xDD\x14a\x01)W\x80c1<\xE5g\x14a\x01YW[__\xFD[a\0\xC5`\x04\x806\x03\x81\x01\x90a\0\xC0\x91\x90a\x06\x84V[a\x02_V[`@Qa\0\xD2\x91\x90a\x06\xBEV[`@Q\x80\x91\x03\x90\xF3[a\0\xF5`\x04\x806\x03\x81\x01\x90a\0\xF0\x91\x90a\x071V[a\x02\xBEV[`@Qa\x01\x02\x91\x90a\x07\x89V[`@Q\x80\x91\x03\x90\xF3[a\x01\x13a\x03FV[`@Qa\x01 \x91\x90a\x06\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01C`\x04\x806\x03\x81\x01\x90a\x01>\x91\x90a\x07\xA2V[a\x03jV[`@Qa\x01P\x91\x90a\x07\x89V[`@Q\x80\x91\x03\x90\xF3[a\x01aa\x04\xA8V[`@Qa\x01n\x91\x90a\x08\rV[`@Q\x80\x91\x03\x90\xF3[a\x01\x7Fa\x04\xCCV[`@Qa\x01\x8C\x91\x90a\x085V[`@Q\x80\x91\x03\x90\xF3[a\x01\xAF`\x04\x806\x03\x81\x01\x90a\x01\xAA\x91\x90a\x071V[a\x04\xF0V[\0[a\x01\xCB`\x04\x806\x03\x81\x01\x90a\x01\xC6\x91\x90a\x08NV[a\x05FV[`@Qa\x01\xD8\x91\x90a\x06\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01\xE9a\x05ZV[`@Qa\x01\xF6\x91\x90a\x06\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x02\x19`\x04\x806\x03\x81\x01\x90a\x02\x14\x91\x90a\x071V[a\x05~V[`@Qa\x02&\x91\x90a\x07\x89V[`@Q\x80\x91\x03\x90\xF3[a\x02I`\x04\x806\x03\x81\x01\x90a\x02D\x91\x90a\x08yV[a\x06-V[`@Qa\x02V\x91\x90a\x06\xBEV[`@Q\x80\x91\x03\x90\xF3[_\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83a\x02\xAD\x91\x90a\x08\xE4V[a\x02\xB7\x91\x90a\tRV[\x90P\x91\x90PV[_\x81`\x01_3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ \x81\x90UP`\x01\x90P\x92\x91PPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[_\x81`\x01_\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x82\x82Ta\x03\xF2\x91\x90a\t\x82V[\x92PP\x81\x90UP\x81__\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x82\x82Ta\x04D\x91\x90a\t\x82V[\x92PP\x81\x90UP\x81__\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x82\x82Ta\x04\x96\x91\x90a\t\xB5V[\x92PP\x81\x90UP`\x01\x90P\x93\x92PPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[\x80__\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x82\x82Ta\x05;\x91\x90a\t\xB5V[\x92PP\x81\x90UPPPV[_` R\x80_R`@_ _\x91P\x90PT\x81V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[_\x81__3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x82\x82Ta\x05\xCA\x91\x90a\t\x82V[\x92PP\x81\x90UP\x81__\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01_ _\x82\x82Ta\x06\x1C\x91\x90a\t\xB5V[\x92PP\x81\x90UP`\x01\x90P\x92\x91PPV[`\x01` R\x81_R`@_ ` R\x80_R`@_ _\x91P\x91PPT\x81V[__\xFD[_\x81\x90P\x91\x90PV[a\x06c\x81a\x06QV[\x81\x14a\x06mW__\xFD[PV[_\x815\x90Pa\x06~\x81a\x06ZV[\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\x99Wa\x06\x98a\x06MV[[_a\x06\xA6\x84\x82\x85\x01a\x06pV[\x91PP\x92\x91PPV[a\x06\xB8\x81a\x06QV[\x82RPPV[_` \x82\x01\x90Pa\x06\xD1_\x83\x01\x84a\x06\xAFV[\x92\x91PPV[_s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[_a\x07\0\x82a\x06\xD7V[\x90P\x91\x90PV[a\x07\x10\x81a\x06\xF6V[\x81\x14a\x07\x1AW__\xFD[PV[_\x815\x90Pa\x07+\x81a\x07\x07V[\x92\x91PPV[__`@\x83\x85\x03\x12\x15a\x07GWa\x07Fa\x06MV[[_a\x07T\x85\x82\x86\x01a\x07\x1DV[\x92PP` a\x07e\x85\x82\x86\x01a\x06pV[\x91PP\x92P\x92\x90PV[_\x81\x15\x15\x90P\x91\x90PV[a\x07\x83\x81a\x07oV[\x82RPPV[_` \x82\x01\x90Pa\x07\x9C_\x83\x01\x84a\x07zV[\x92\x91PPV[___``\x84\x86\x03\x12\x15a\x07\xB9Wa\x07\xB8a\x06MV[[_a\x07\xC6\x86\x82\x87\x01a\x07\x1DV[\x93PP` a\x07\xD7\x86\x82\x87\x01a\x07\x1DV[\x92PP`@a\x07\xE8\x86\x82\x87\x01a\x06pV[\x91PP\x92P\x92P\x92V[_`\xFF\x82\x16\x90P\x91\x90PV[a\x08\x07\x81a\x07\xF2V[\x82RPPV[_` \x82\x01\x90Pa\x08 _\x83\x01\x84a\x07\xFEV[\x92\x91PPV[a\x08/\x81a\x06\xF6V[\x82RPPV[_` \x82\x01\x90Pa\x08H_\x83\x01\x84a\x08&V[\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x08cWa\x08ba\x06MV[[_a\x08p\x84\x82\x85\x01a\x07\x1DV[\x91PP\x92\x91PPV[__`@\x83\x85\x03\x12\x15a\x08\x8FWa\x08\x8Ea\x06MV[[_a\x08\x9C\x85\x82\x86\x01a\x07\x1DV[\x92PP` a\x08\xAD\x85\x82\x86\x01a\x07\x1DV[\x91PP\x92P\x92\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x11`\x04R`$_\xFD[_a\x08\xEE\x82a\x06QV[\x91Pa\x08\xF9\x83a\x06QV[\x92P\x82\x82\x02a\t\x07\x81a\x06QV[\x91P\x82\x82\x04\x84\x14\x83\x15\x17a\t\x1EWa\t\x1Da\x08\xB7V[[P\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_R`\x12`\x04R`$_\xFD[_a\t\\\x82a\x06QV[\x91Pa\tg\x83a\x06QV[\x92P\x82a\twWa\tva\t%V[[\x82\x82\x04\x90P\x92\x91PPV[_a\t\x8C\x82a\x06QV[\x91Pa\t\x97\x83a\x06QV[\x92P\x82\x82\x03\x90P\x81\x81\x11\x15a\t\xAFWa\t\xAEa\x08\xB7V[[\x92\x91PPV[_a\t\xBF\x82a\x06QV[\x91Pa\t\xCA\x83a\x06QV[\x92P\x82\x82\x01\x90P\x80\x82\x11\x15a\t\xE2Wa\t\xE1a\x08\xB7V[[\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xB5\xEB\xAF\xAB\"p\xA2\xC4\x1E\xB9\xCDG>\xB8\xAC\xA9XQ\x1F\xE1+s\x02U\x9D\x19~*\x87\x04\xC9KdsolcC\0\x08\x1E\x003",
+    );
+    /**Constructor`.
+    ```solidity
+    constructor(address _asset, uint8 _decimals, uint256 _rateNumerator, uint256 _rateDenominator);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct constructorCall {
+        #[allow(missing_docs)]
+        pub _asset: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _decimals: u8,
+        #[allow(missing_docs)]
+        pub _rateNumerator: alloy_sol_types::private::primitives::aliases::U256,
+        #[allow(missing_docs)]
+        pub _rateDenominator: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                u8,
+                alloy_sol_types::private::primitives::aliases::U256,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: constructorCall) -> Self {
+                    (
+                        value._asset,
+                        value._decimals,
+                        value._rateNumerator,
+                        value._rateDenominator,
+                    )
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _asset: tuple.0,
+                        _decimals: tuple.1,
+                        _rateNumerator: tuple.2,
+                        _rateDenominator: tuple.3,
+                    }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolConstructor for constructorCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<8>,
+                alloy_sol_types::sol_data::Uint<256>,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._asset,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
+                        &self._decimals,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._rateNumerator,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self._rateDenominator,
+                    ),
+                )
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `allowance(address,address)` and selector `0xdd62ed3e`.
+    ```solidity
+    function allowance(address, address) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceCall {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub _1: alloy_sol_types::private::Address,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`allowance(address,address)`](allowanceCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct allowanceReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceCall) -> Self {
+                    (value._0, value._1)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        _0: tuple.0,
+                        _1: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: allowanceReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for allowanceCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+            );
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
+            const SIGNATURE: &'static str = "allowance(address,address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._0,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self._1,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: allowanceReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: allowanceReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `approve(address,uint256)` and selector `0x095ea7b3`.
+    ```solidity
+    function approve(address spender, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveCall {
+        #[allow(missing_docs)]
+        pub spender: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`approve(address,uint256)`](approveCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct approveReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
+                fn from(value: approveCall) -> Self {
+                    (value.spender, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        spender: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: approveReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for approveCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
+            const SIGNATURE: &'static str = "approve(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.spender,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: approveReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: approveReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `asset()` and selector `0x38d52e0f`.
+    ```solidity
+    function asset() external view returns (address);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct assetCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the [`asset()`](assetCall)
+    /// function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct assetReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::Address,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<assetCall> for UnderlyingRustTuple<'_> {
+                fn from(value: assetCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for assetCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<assetReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: assetReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for assetReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for assetCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::Address;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [56u8, 213u8, 46u8, 15u8];
+            const SIGNATURE: &'static str = "asset()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: assetReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: assetReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `balanceOf(address)` and selector `0x70a08231`.
+    ```solidity
+    function balanceOf(address) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfCall(pub alloy_sol_types::private::Address);
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`balanceOf(address)`](balanceOfCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct balanceOfReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Address,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::Address,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfCall) -> Self {
+                    (value.0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self(tuple.0)
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: balanceOfReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for balanceOfCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Address,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
+            const SIGNATURE: &'static str = "balanceOf(address)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.0,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: balanceOfReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: balanceOfReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `convertToAssets(uint256)` and selector `0x07a2d13a`.
+    ```solidity
+    function convertToAssets(uint256 shares) external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct convertToAssetsCall {
+        #[allow(missing_docs)]
+        pub shares: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`convertToAssets(uint256)`](convertToAssetsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct convertToAssetsReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<convertToAssetsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: convertToAssetsCall) -> Self {
+                    (value.shares,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for convertToAssetsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { shares: tuple.0 }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<convertToAssetsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: convertToAssetsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for convertToAssetsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for convertToAssetsCall {
+            type Parameters<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [7u8, 162u8, 209u8, 58u8];
+            const SIGNATURE: &'static str = "convertToAssets(uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.shares,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: convertToAssetsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: convertToAssetsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `decimals()` and selector `0x313ce567`.
+    ```solidity
+    function decimals() external view returns (uint8);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`decimals()`](decimalsCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct decimalsReturn {
+        #[allow(missing_docs)]
+        pub _0: u8,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (u8,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: decimalsReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for decimalsCall {
+            type Parameters<'a> = ();
+            type Return = u8;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<8>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
+            const SIGNATURE: &'static str = "decimals()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: decimalsReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: decimalsReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`.
+    ```solidity
+    function mint(address to, uint256 amount) external;
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    ///Container type for the return parameters of the
+    /// [`mint(address,uint256)`](mintCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct mintReturn {}
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
+                fn from(value: mintCall) -> Self {
+                    (value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: mintReturn) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {}
+                }
+            }
+        }
+        impl mintReturn {
+            fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
+                ()
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for mintCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = mintReturn;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = ();
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
+            const SIGNATURE: &'static str = "mint(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                mintReturn::_tokenize(ret)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
+                    .map(Into::into)
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(Into::into)
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `rateDenominator()` and selector `0x865192f7`.
+    ```solidity
+    function rateDenominator() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct rateDenominatorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`rateDenominator()`](rateDenominatorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct rateDenominatorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<rateDenominatorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: rateDenominatorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rateDenominatorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<rateDenominatorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: rateDenominatorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rateDenominatorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for rateDenominatorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [134u8, 81u8, 146u8, 247u8];
+            const SIGNATURE: &'static str = "rateDenominator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: rateDenominatorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: rateDenominatorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `rateNumerator()` and selector `0x0b36b8db`.
+    ```solidity
+    function rateNumerator() external view returns (uint256);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct rateNumeratorCall;
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`rateNumerator()`](rateNumeratorCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct rateNumeratorReturn {
+        #[allow(missing_docs)]
+        pub _0: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = ();
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = ();
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<rateNumeratorCall> for UnderlyingRustTuple<'_> {
+                fn from(value: rateNumeratorCall) -> Self {
+                    ()
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rateNumeratorCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (alloy_sol_types::private::primitives::aliases::U256,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<rateNumeratorReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: rateNumeratorReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rateNumeratorReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for rateNumeratorCall {
+            type Parameters<'a> = ();
+            type Return = alloy_sol_types::private::primitives::aliases::U256;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Uint<256>,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [11u8, 54u8, 184u8, 219u8];
+            const SIGNATURE: &'static str = "rateNumerator()";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                ()
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        ret,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: rateNumeratorReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: rateNumeratorReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transfer(address,uint256)` and selector `0xa9059cbb`.
+    ```solidity
+    function transfer(address to, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferCall {
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transfer(address,uint256)`](transferCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferCall) -> Self {
+                    (value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        to: tuple.0,
+                        amount: tuple.1,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
+            const SIGNATURE: &'static str = "transfer(address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    /**Function with signature `transferFrom(address,address,uint256)` and selector `0x23b872dd`.
+    ```solidity
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+    ```*/
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromCall {
+        #[allow(missing_docs)]
+        pub from: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub to: alloy_sol_types::private::Address,
+        #[allow(missing_docs)]
+        pub amount: alloy_sol_types::private::primitives::aliases::U256,
+    }
+    #[derive(Default, Debug, PartialEq, Eq, Hash)]
+    ///Container type for the return parameters of the
+    /// [`transferFrom(address,address,uint256)`](transferFromCall) function.
+    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
+    #[derive(Clone)]
+    pub struct transferFromReturn {
+        #[allow(missing_docs)]
+        pub _0: bool,
+    }
+    #[allow(
+        non_camel_case_types,
+        non_snake_case,
+        clippy::pub_underscore_fields,
+        clippy::style
+    )]
+    const _: () = {
+        use alloy_sol_types;
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::Address,
+                alloy_sol_types::private::primitives::aliases::U256,
+            );
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromCall) -> Self {
+                    (value.from, value.to, value.amount)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self {
+                        from: tuple.0,
+                        to: tuple.1,
+                        amount: tuple.2,
+                    }
+                }
+            }
+        }
+        {
+            #[doc(hidden)]
+            #[allow(dead_code)]
+            type UnderlyingSolTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            #[doc(hidden)]
+            type UnderlyingRustTuple<'a> = (bool,);
+            #[cfg(test)]
+            #[allow(dead_code, unreachable_patterns)]
+            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
+                match _t {
+                    alloy_sol_types::private::AssertTypeEq::<
+                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
+                    >(_) => {}
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
+                fn from(value: transferFromReturn) -> Self {
+                    (value._0,)
+                }
+            }
+            #[automatically_derived]
+            #[doc(hidden)]
+            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
+                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
+                    Self { _0: tuple.0 }
+                }
+            }
+        }
+        #[automatically_derived]
+        impl alloy_sol_types::SolCall for transferFromCall {
+            type Parameters<'a> = (
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Address,
+                alloy_sol_types::sol_data::Uint<256>,
+            );
+            type Return = bool;
+            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
+            type ReturnTuple<'a> = (alloy_sol_types::sol_data::Bool,);
+            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
+
+            const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
+            const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
+
+            #[inline]
+            fn new<'a>(
+                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
+            ) -> Self {
+                tuple.into()
+            }
+
+            #[inline]
+            fn tokenize(&self) -> Self::Token<'_> {
+                (
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.from,
+                    ),
+                    <alloy_sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
+                        &self.to,
+                    ),
+                    <alloy_sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
+                        &self.amount,
+                    ),
+                )
+            }
+
+            #[inline]
+            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
+                (<alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
+            }
+
+            #[inline]
+            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
+                    |r| {
+                        let r: transferFromReturn = r.into();
+                        r._0
+                    },
+                )
+            }
+
+            #[inline]
+            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
+                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
+                    data,
+                )
+                .map(|r| {
+                    let r: transferFromReturn = r.into();
+                    r._0
+                })
+            }
+        }
+    };
+    ///Container for all the [`MockERC4626Wrapper`](self) function calls.
+    #[derive(Clone)]
+    pub enum MockERC4626WrapperCalls {
+        #[allow(missing_docs)]
+        allowance(allowanceCall),
+        #[allow(missing_docs)]
+        approve(approveCall),
+        #[allow(missing_docs)]
+        asset(assetCall),
+        #[allow(missing_docs)]
+        balanceOf(balanceOfCall),
+        #[allow(missing_docs)]
+        convertToAssets(convertToAssetsCall),
+        #[allow(missing_docs)]
+        decimals(decimalsCall),
+        #[allow(missing_docs)]
+        mint(mintCall),
+        #[allow(missing_docs)]
+        rateDenominator(rateDenominatorCall),
+        #[allow(missing_docs)]
+        rateNumerator(rateNumeratorCall),
+        #[allow(missing_docs)]
+        transfer(transferCall),
+        #[allow(missing_docs)]
+        transferFrom(transferFromCall),
+    }
+    impl MockERC4626WrapperCalls {
+        /// All the selectors of this enum.
+        ///
+        /// Note that the selectors might not be in the same order as the
+        /// variants. No guarantees are made about the order of the
+        /// selectors.
+        ///
+        /// Prefer using `SolInterface` methods instead.
+        pub const SELECTORS: &'static [[u8; 4usize]] = &[
+            [7u8, 162u8, 209u8, 58u8],
+            [9u8, 94u8, 167u8, 179u8],
+            [11u8, 54u8, 184u8, 219u8],
+            [35u8, 184u8, 114u8, 221u8],
+            [49u8, 60u8, 229u8, 103u8],
+            [56u8, 213u8, 46u8, 15u8],
+            [64u8, 193u8, 15u8, 25u8],
+            [112u8, 160u8, 130u8, 49u8],
+            [134u8, 81u8, 146u8, 247u8],
+            [169u8, 5u8, 156u8, 187u8],
+            [221u8, 98u8, 237u8, 62u8],
+        ];
+        /// The signatures in the same order as `SELECTORS`.
+        pub const SIGNATURES: &'static [&'static str] = &[
+            <convertToAssetsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <approveCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <rateNumeratorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferFromCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <decimalsCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <assetCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <mintCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <balanceOfCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <rateDenominatorCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <transferCall as alloy_sol_types::SolCall>::SIGNATURE,
+            <allowanceCall as alloy_sol_types::SolCall>::SIGNATURE,
+        ];
+        /// The names of the variants in the same order as `SELECTORS`.
+        pub const VARIANT_NAMES: &'static [&'static str] = &[
+            ::core::stringify!(convertToAssets),
+            ::core::stringify!(approve),
+            ::core::stringify!(rateNumerator),
+            ::core::stringify!(transferFrom),
+            ::core::stringify!(decimals),
+            ::core::stringify!(asset),
+            ::core::stringify!(mint),
+            ::core::stringify!(balanceOf),
+            ::core::stringify!(rateDenominator),
+            ::core::stringify!(transfer),
+            ::core::stringify!(allowance),
+        ];
+
+        /// Returns the signature for the given selector, if known.
+        #[inline]
+        pub fn signature_by_selector(
+            selector: [u8; 4usize],
+        ) -> ::core::option::Option<&'static str> {
+            match Self::SELECTORS.binary_search(&selector) {
+                ::core::result::Result::Ok(idx) => {
+                    ::core::option::Option::Some(Self::SIGNATURES[idx])
+                }
+                ::core::result::Result::Err(_) => ::core::option::Option::None,
+            }
+        }
+
+        /// Returns the enum variant name for the given selector, if known.
+        #[inline]
+        pub fn name_by_selector(selector: [u8; 4usize]) -> ::core::option::Option<&'static str> {
+            let sig = Self::signature_by_selector(selector)?;
+            sig.split_once('(').map(|(name, _)| name)
+        }
+    }
+    #[automatically_derived]
+    impl alloy_sol_types::SolInterface for MockERC4626WrapperCalls {
+        const COUNT: usize = 11usize;
+        const MIN_DATA_LENGTH: usize = 0usize;
+        const NAME: &'static str = "MockERC4626WrapperCalls";
+
+        #[inline]
+        fn selector(&self) -> [u8; 4] {
+            match self {
+                Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::asset(_) => <assetCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::convertToAssets(_) => {
+                    <convertToAssetsCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::rateDenominator(_) => {
+                    <rateDenominatorCall as alloy_sol_types::SolCall>::SELECTOR
+                }
+                Self::rateNumerator(_) => <rateNumeratorCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
+                Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
+            }
+        }
+
+        #[inline]
+        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
+            Self::SELECTORS.get(i).copied()
+        }
+
+        #[inline]
+        fn valid_selector(selector: [u8; 4]) -> bool {
+            Self::SELECTORS.binary_search(&selector).is_ok()
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
+            static DECODE_SHIMS: &[fn(
+                &[u8],
+            )
+                -> alloy_sol_types::Result<MockERC4626WrapperCalls>] = &[
+                {
+                    fn convertToAssets(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <convertToAssetsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::convertToAssets)
+                    }
+                    convertToAssets
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn rateNumerator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <rateNumeratorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::rateNumerator)
+                    }
+                    rateNumerator
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn asset(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <assetCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::asset)
+                    }
+                    asset
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn rateDenominator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <rateDenominatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::rateDenominator)
+                    }
+                    rateDenominator
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
+                            .map(MockERC4626WrapperCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        fn abi_decode_raw_validate(
+            selector: [u8; 4],
+            data: &[u8],
+        ) -> alloy_sol_types::Result<Self> {
+            static DECODE_VALIDATE_SHIMS: &[fn(
+                &[u8],
+            ) -> alloy_sol_types::Result<
+                MockERC4626WrapperCalls,
+            >] = &[
+                {
+                    fn convertToAssets(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <convertToAssetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(MockERC4626WrapperCalls::convertToAssets)
+                    }
+                    convertToAssets
+                },
+                {
+                    fn approve(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::approve)
+                    }
+                    approve
+                },
+                {
+                    fn rateNumerator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <rateNumeratorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(MockERC4626WrapperCalls::rateNumerator)
+                    }
+                    rateNumerator
+                },
+                {
+                    fn transferFrom(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(MockERC4626WrapperCalls::transferFrom)
+                    }
+                    transferFrom
+                },
+                {
+                    fn decimals(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::decimals)
+                    }
+                    decimals
+                },
+                {
+                    fn asset(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <assetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::asset)
+                    }
+                    asset
+                },
+                {
+                    fn mint(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::mint)
+                    }
+                    mint
+                },
+                {
+                    fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::balanceOf)
+                    }
+                    balanceOf
+                },
+                {
+                    fn rateDenominator(
+                        data: &[u8],
+                    ) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <rateDenominatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
+                            data,
+                        )
+                        .map(MockERC4626WrapperCalls::rateDenominator)
+                    }
+                    rateDenominator
+                },
+                {
+                    fn transfer(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::transfer)
+                    }
+                    transfer
+                },
+                {
+                    fn allowance(data: &[u8]) -> alloy_sol_types::Result<MockERC4626WrapperCalls> {
+                        <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
+                            .map(MockERC4626WrapperCalls::allowance)
+                    }
+                    allowance
+                },
+            ];
+            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
+                return Err(alloy_sol_types::Error::unknown_selector(
+                    <Self as alloy_sol_types::SolInterface>::NAME,
+                    selector,
+                ));
+            };
+            DECODE_VALIDATE_SHIMS[idx](data)
+        }
+
+        #[inline]
+        fn abi_encoded_size(&self) -> usize {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::asset(inner) => {
+                    <assetCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::convertToAssets(inner) => {
+                    <convertToAssetsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::rateDenominator(inner) => {
+                    <rateDenominatorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::rateNumerator(inner) => {
+                    <rateNumeratorCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
+                }
+            }
+        }
+
+        #[inline]
+        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
+            match self {
+                Self::allowance(inner) => {
+                    <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::approve(inner) => {
+                    <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::asset(inner) => {
+                    <assetCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::balanceOf(inner) => {
+                    <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::convertToAssets(inner) => {
+                    <convertToAssetsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::decimals(inner) => {
+                    <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::mint(inner) => {
+                    <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::rateDenominator(inner) => {
+                    <rateDenominatorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::rateNumerator(inner) => {
+                    <rateNumeratorCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transfer(inner) => {
+                    <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+                Self::transferFrom(inner) => {
+                    <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
+                }
+            }
+        }
+    }
+    use alloy_contract;
+    /**Creates a new wrapper around an on-chain [`MockERC4626Wrapper`](self) contract instance.
+
+    See the [wrapper's documentation](`MockERC4626WrapperInstance`) for more details.*/
+    #[inline]
+    pub const fn new<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        address: alloy_sol_types::private::Address,
+        __provider: P,
+    ) -> MockERC4626WrapperInstance<P, N> {
+        MockERC4626WrapperInstance::<P, N>::new(address, __provider)
+    }
+    /**Deploys this contract using the given `provider` and constructor arguments, if any.
+
+    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.*/
+    #[inline]
+    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
+        __provider: P,
+        _asset: alloy_sol_types::private::Address,
+        _decimals: u8,
+        _rateNumerator: alloy_sol_types::private::primitives::aliases::U256,
+        _rateDenominator: alloy_sol_types::private::primitives::aliases::U256,
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<MockERC4626WrapperInstance<P, N>>>
+    {
+        MockERC4626WrapperInstance::<P, N>::deploy(
+            __provider,
+            _asset,
+            _decimals,
+            _rateNumerator,
+            _rateDenominator,
+        )
+    }
+    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+    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.*/
+    #[inline]
+    pub fn deploy_builder<
+        P: alloy_contract::private::Provider<N>,
+        N: alloy_contract::private::Network,
+    >(
+        __provider: P,
+        _asset: alloy_sol_types::private::Address,
+        _decimals: u8,
+        _rateNumerator: alloy_sol_types::private::primitives::aliases::U256,
+        _rateDenominator: alloy_sol_types::private::primitives::aliases::U256,
+    ) -> alloy_contract::RawCallBuilder<P, N> {
+        MockERC4626WrapperInstance::<P, N>::deploy_builder(
+            __provider,
+            _asset,
+            _decimals,
+            _rateNumerator,
+            _rateDenominator,
+        )
+    }
+    /**A [`MockERC4626Wrapper`](self) instance.
+
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`MockERC4626Wrapper`](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.
+
+    See the [module-level documentation](self) for all the available methods.*/
+    #[derive(Clone)]
+    pub struct MockERC4626WrapperInstance<P, N = alloy_contract::private::Ethereum> {
+        address: alloy_sol_types::private::Address,
+        provider: P,
+        _network: ::core::marker::PhantomData<N>,
+    }
+    #[automatically_derived]
+    impl<P, N> ::core::fmt::Debug for MockERC4626WrapperInstance<P, N> {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            f.debug_tuple("MockERC4626WrapperInstance")
+                .field(&self.address)
+                .finish()
+        }
+    }
+    /// Instantiation and getters/setters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        MockERC4626WrapperInstance<P, N>
+    {
+        /**Creates a new wrapper around an on-chain [`MockERC4626Wrapper`](self) contract instance.
+
+        See the [wrapper's documentation](`MockERC4626WrapperInstance`) for more details.*/
+        #[inline]
+        pub const fn new(address: alloy_sol_types::private::Address, __provider: P) -> Self {
+            Self {
+                address,
+                provider: __provider,
+                _network: ::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.
+
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        #[inline]
+        pub async fn deploy(
+            __provider: P,
+            _asset: alloy_sol_types::private::Address,
+            _decimals: u8,
+            _rateNumerator: alloy_sol_types::private::primitives::aliases::U256,
+            _rateDenominator: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::Result<MockERC4626WrapperInstance<P, N>> {
+            let call_builder = Self::deploy_builder(
+                __provider,
+                _asset,
+                _decimals,
+                _rateNumerator,
+                _rateDenominator,
+            );
+            let contract_address = call_builder.deploy().await?;
+            Ok(Self::new(contract_address, call_builder.provider))
+        }
+
+        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
+        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.*/
+        #[inline]
+        pub fn deploy_builder(
+            __provider: P,
+            _asset: alloy_sol_types::private::Address,
+            _decimals: u8,
+            _rateNumerator: alloy_sol_types::private::primitives::aliases::U256,
+            _rateDenominator: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::RawCallBuilder<P, N> {
+            alloy_contract::RawCallBuilder::new_raw_deploy(
+                __provider,
+                [
+                    &BYTECODE[..],
+                    &alloy_sol_types::SolConstructor::abi_encode(&constructorCall {
+                        _asset,
+                        _decimals,
+                        _rateNumerator,
+                        _rateDenominator,
+                    })[..],
+                ]
+                .concat()
+                .into(),
+            )
+        }
+
+        /// Returns a reference to the address.
+        #[inline]
+        pub const fn address(&self) -> &alloy_sol_types::private::Address {
+            &self.address
+        }
+
+        /// Sets the address.
+        #[inline]
+        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
+            self.address = address;
+        }
+
+        /// Sets the address and returns `self`.
+        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
+            self.set_address(address);
+            self
+        }
+
+        /// Returns a reference to the provider.
+        #[inline]
+        pub const fn provider(&self) -> &P {
+            &self.provider
+        }
+    }
+    impl<P: ::core::clone::Clone, N> MockERC4626WrapperInstance<&P, N> {
+        /// Clones the provider and returns a new instance with the cloned
+        /// provider.
+        #[inline]
+        pub fn with_cloned_provider(self) -> MockERC4626WrapperInstance<P, N> {
+            MockERC4626WrapperInstance {
+                address: self.address,
+                provider: ::core::clone::Clone::clone(&self.provider),
+                _network: ::core::marker::PhantomData,
+            }
+        }
+    }
+    /// Function calls.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        MockERC4626WrapperInstance<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 contract. Prefer using the other methods for
+        /// building type-safe contract calls.
+        pub fn call_builder<C: alloy_sol_types::SolCall>(
+            &self,
+            call: &C,
+        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
+            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
+        }
+
+        ///Creates a new call builder for the [`allowance`] function.
+        pub fn allowance(
+            &self,
+            _0: alloy_sol_types::private::Address,
+            _1: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
+            self.call_builder(&allowanceCall { _0, _1 })
+        }
+
+        ///Creates a new call builder for the [`approve`] function.
+        pub fn approve(
+            &self,
+            spender: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
+            self.call_builder(&approveCall { spender, amount })
+        }
+
+        ///Creates a new call builder for the [`asset`] function.
+        pub fn asset(&self) -> alloy_contract::SolCallBuilder<&P, assetCall, N> {
+            self.call_builder(&assetCall)
+        }
+
+        ///Creates a new call builder for the [`balanceOf`] function.
+        pub fn balanceOf(
+            &self,
+            _0: alloy_sol_types::private::Address,
+        ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
+            self.call_builder(&balanceOfCall(_0))
+        }
+
+        ///Creates a new call builder for the [`convertToAssets`] function.
+        pub fn convertToAssets(
+            &self,
+            shares: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, convertToAssetsCall, N> {
+            self.call_builder(&convertToAssetsCall { shares })
+        }
+
+        ///Creates a new call builder for the [`decimals`] function.
+        pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
+            self.call_builder(&decimalsCall)
+        }
+
+        ///Creates a new call builder for the [`mint`] function.
+        pub fn mint(
+            &self,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
+            self.call_builder(&mintCall { to, amount })
+        }
+
+        ///Creates a new call builder for the [`rateDenominator`] function.
+        pub fn rateDenominator(
+            &self,
+        ) -> alloy_contract::SolCallBuilder<&P, rateDenominatorCall, N> {
+            self.call_builder(&rateDenominatorCall)
+        }
+
+        ///Creates a new call builder for the [`rateNumerator`] function.
+        pub fn rateNumerator(&self) -> alloy_contract::SolCallBuilder<&P, rateNumeratorCall, N> {
+            self.call_builder(&rateNumeratorCall)
+        }
+
+        ///Creates a new call builder for the [`transfer`] function.
+        pub fn transfer(
+            &self,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
+            self.call_builder(&transferCall { to, amount })
+        }
+
+        ///Creates a new call builder for the [`transferFrom`] function.
+        pub fn transferFrom(
+            &self,
+            from: alloy_sol_types::private::Address,
+            to: alloy_sol_types::private::Address,
+            amount: alloy_sol_types::private::primitives::aliases::U256,
+        ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
+            self.call_builder(&transferFromCall { from, to, amount })
+        }
+    }
+    /// Event filters.
+    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
+        MockERC4626WrapperInstance<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. Prefer using the other methods for building
+        /// type-safe event filters.
+        pub fn event_filter<E: alloy_sol_types::SolEvent>(
+            &self,
+        ) -> alloy_contract::Event<&P, E, N> {
+            alloy_contract::Event::new_sol(&self.provider, &self.address)
+        }
+    }
+}
+pub type Instance = MockERC4626Wrapper::MockERC4626WrapperInstance<::alloy_provider::DynProvider>;
diff --git a/contracts/solidity/interfaces/IERC4626.sol b/contracts/solidity/interfaces/IERC4626.sol
new file mode 100644
index 0000000000..ca6522cca7
--- /dev/null
+++ b/contracts/solidity/interfaces/IERC4626.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+/// @title ERC-4626 vaults interface
+interface IERC4626 {
+    function asset() external view returns (address assetTokenAddress);
+    function convertToAssets(uint256 shares) external view returns (uint256 assets);
+}
diff --git a/contracts/solidity/tests/MockERC4626Wrapper.sol b/contracts/solidity/tests/MockERC4626Wrapper.sol
new file mode 100644
index 0000000000..8a33eef4e8
--- /dev/null
+++ b/contracts/solidity/tests/MockERC4626Wrapper.sol
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+/// @title MockERC4626Wrapper
+/// @notice Minimal EIP-4626 wrapper for testing recursive vault pricing.
+/// @dev Wraps another ERC-4626 vault (or any ERC-20) with a configurable
+/// conversion rate. Not a real vault -- just enough to satisfy `asset()`,
+/// `decimals()`, `convertToAssets()`, `balanceOf()`, `approve()`, and
+/// `transfer()` so the e2e pricing pipeline works.
+contract MockERC4626Wrapper {
+    address public immutable asset;
+    uint8 public immutable decimals;
+    uint256 public immutable rateNumerator;
+    uint256 public immutable rateDenominator;
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    constructor(address _asset, uint8 _decimals, uint256 _rateNumerator, uint256 _rateDenominator) {
+        asset = _asset;
+        decimals = _decimals;
+        rateNumerator = _rateNumerator;
+        rateDenominator = _rateDenominator;
+    }
+
+    /// @notice Returns the equivalent amount of underlying assets for the
+    /// given number of vault shares, scaled by the configured rate.
+    function convertToAssets(uint256 shares) external view returns (uint256) {
+        return shares * rateNumerator / rateDenominator;
+    }
+
+    function transfer(address to, uint256 amount) external returns (bool) {
+        balanceOf[msg.sender] -= amount;
+        balanceOf[to] += amount;
+        return true;
+    }
+
+    function approve(address spender, uint256 amount) external returns (bool) {
+        allowance[msg.sender][spender] = amount;
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
+        allowance[from][msg.sender] -= amount;
+        balanceOf[from] -= amount;
+        balanceOf[to] += amount;
+        return true;
+    }
+
+    /// @notice Mints tokens to an address. Only for testing.
+    function mint(address to, uint256 amount) external {
+        balanceOf[to] += amount;
+    }
+}
diff --git a/contracts/src/main.rs b/contracts/src/main.rs
index 1f4ed17afa..61962946fe 100644
--- a/contracts/src/main.rs
+++ b/contracts/src/main.rs
@@ -105,6 +105,7 @@ fn build_module() -> Module {
         // Misc
         .add_contract(Contract::new("ERC20"))
         .add_contract(Contract::new("ERC20Mintable"))
+        .add_contract(Contract::new("IERC4626"))
         // GnosisSafe
         .add_contract(Contract::new("GnosisSafe"))
         .add_contract(Contract::new("GnosisSafeCompatibilityFallbackHandler"))
@@ -505,6 +506,7 @@ fn build_module() -> Module {
             Submodule::new("test")
                 .add_contract(Contract::new("GasHog"))
                 .add_contract(Contract::new("Counter"))
+                .add_contract(Contract::new("MockERC4626Wrapper"))
                 .add_contract(Contract::new("CowProtocolToken").with_networks(networks![
                     MAINNET => "0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB",
                     GNOSIS => "0x177127622c4A00F3d409B75571e12cB3c8973d3c",
diff --git a/contracts/src/vendor.rs b/contracts/src/vendor.rs
index 576ae5fe2a..4c9584243e 100644
--- a/contracts/src/vendor.rs
+++ b/contracts/src/vendor.rs
@@ -162,6 +162,10 @@ pub fn run(artifacts_dir: &Path) -> Result<()> {
             "ERC1271SignatureValidator",
             "Manually vendored ABI for ERC-1271 signature validation",
         )
+        .manual(
+            "IERC4626",
+            "Manually vendored ABI for ERC-4626 tokenized vault interface",
+        )
         .npm(
             "IUniswapLikePair",
             "@uniswap/v2-periphery@1.1.0-beta.0/build/IUniswapV2Pair.json",
diff --git a/crates/autopilot/src/run.rs b/crates/autopilot/src/run.rs
index 9d0a1cdf24..1f0482cf66 100644
--- a/crates/autopilot/src/run.rs
+++ b/crates/autopilot/src/run.rs
@@ -346,6 +346,7 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
                 config.native_price_estimation.shared.results_required,
                 &weth,
                 shared_cache.clone(),
+                config.native_price_estimation.eip4626,
             )
             .instrument(info_span!("api_native_price_estimator"))
             .await,
@@ -358,6 +359,7 @@ pub async fn run(config: Configuration, shutdown_controller: ShutdownController)
                 config.native_price_estimation.shared.results_required,
                 &weth,
                 shared_cache.clone(),
+                config.native_price_estimation.eip4626,
             )
             .instrument(info_span!("competition_native_price_updater"))
             .await;
diff --git a/crates/autopilot/src/solvable_orders.rs b/crates/autopilot/src/solvable_orders.rs
index ee1c0cd603..dd3007b7e1 100644
--- a/crates/autopilot/src/solvable_orders.rs
+++ b/crates/autopilot/src/solvable_orders.rs
@@ -28,14 +28,11 @@ use {
         signature::Signature,
         time::now_in_epoch_seconds,
     },
-    price_estimation::{
-        native::{NativePriceEstimating, to_normalized_price},
-        native_price_cache::NativePriceUpdater,
-    },
+    price_estimation::{native::to_normalized_price, native_price_cache::NativePriceUpdater},
     prometheus::{Histogram, HistogramVec, IntCounter, IntCounterVec, IntGauge, IntGaugeVec},
     shared::remaining_amounts,
     std::{
-        collections::{BTreeMap, HashMap, HashSet, btree_map::Entry},
+        collections::{BTreeMap, HashMap, HashSet},
         future::Future,
         sync::Arc,
         time::{Duration, Instant},
@@ -292,21 +289,11 @@ impl SolvableOrdersCache {
             )
             .await;
         tracing::trace!("fetched native prices for solvable orders");
-        // Add WETH price if it's not already there to support ETH wrap when required.
-        if let Entry::Vacant(entry) = prices.entry(self.weth) {
-            let weth_price = self
-                .timed_future(
-                    "weth_price_fetch",
-                    self.native_price_estimator
-                        .estimate_native_price(self.weth, Default::default()),
-                )
-                .await
-                .expect("weth price fetching can never fail");
-            let weth_price = to_normalized_price(weth_price)
-                .expect("weth price can never be outside of U256 range");
-
-            entry.insert(weth_price);
-        }
+        // WETH's native price is 1 by definition — insert it directly to
+        // support ETH wrap when required.
+        prices
+            .entry(self.weth)
+            .or_insert_with(|| to_normalized_price(1.0).unwrap());
         Metrics::track_filtered_orders(MissingNativePrice, &removed);
         filtered_order_events.extend(removed.into_iter().map(|uid| (uid, MissingNativePrice)));
 
diff --git a/crates/configs/src/autopilot/native_price.rs b/crates/configs/src/autopilot/native_price.rs
index 74ac52635f..7ebf0f77bc 100644
--- a/crates/configs/src/autopilot/native_price.rs
+++ b/crates/configs/src/autopilot/native_price.rs
@@ -46,6 +46,12 @@ pub struct NativePriceConfig {
     )]
     pub prefetch_time: Duration,
 
+    /// Enable EIP-4626 vault token pricing. When enabled, the native price
+    /// estimator will attempt to price vault tokens by querying their
+    /// underlying asset and conversion rate on-chain.
+    #[serde(default)]
+    pub eip4626: bool,
+
     /// Shared native price settings (cache, approximation tokens, etc.).
     #[serde(flatten)]
     pub shared: crate::native_price::NativePriceConfig,
@@ -62,6 +68,7 @@ impl NativePriceConfig {
             api_estimators: Default::default(),
             cache_refresh_interval: default_native_price_cache_refresh(),
             prefetch_time: Duration::from_millis(500),
+            eip4626: false,
             shared: crate::native_price::NativePriceConfig {
                 cache: crate::native_price::CacheConfig {
                     max_age: Duration::from_secs(2),
diff --git a/crates/e2e/tests/e2e/eip4626.rs b/crates/e2e/tests/e2e/eip4626.rs
new file mode 100644
index 0000000000..fd7fef837e
--- /dev/null
+++ b/crates/e2e/tests/e2e/eip4626.rs
@@ -0,0 +1,236 @@
+use {
+    ::alloy::{
+        primitives::{Address, U256, address},
+        providers::ext::{AnvilApi, ImpersonateConfig},
+    },
+    configs::{
+        autopilot::{Configuration, native_price::NativePriceConfig},
+        native_price_estimators::{NativePriceEstimator, NativePriceEstimators},
+        test_util::TestDefault,
+    },
+    contracts::ERC20,
+    e2e::setup::*,
+    ethrpc::alloy::CallBuilderExt,
+    model::quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
+    number::units::EthUnit,
+    shared::web3::Web3,
+};
+
+/// The block number from which we will fetch state for the forked test.
+const FORK_BLOCK_MAINNET: u64 = 23112197;
+
+/// sDAI (Savings DAI) – an EIP-4626 vault wrapping DAI.
+const SDAI: Address = address!("83F20F44975D03b1b09e64809B757c47f942BEeA");
+
+/// sDAI whale at [`FORK_BLOCK_MAINNET`].
+const SDAI_WHALE: Address = address!("4C612E3B15b96Ff9A6faED838F8d07d479a8dD4c");
+
+/// WETH on mainnet.
+const WETH: Address = address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
+
+#[tokio::test]
+#[ignore]
+async fn forked_node_mainnet_eip4626_native_price() {
+    run_forked_test_with_block_number(
+        eip4626_native_price_test,
+        std::env::var("FORK_URL_MAINNET")
+            .expect("FORK_URL_MAINNET must be set to run forked tests"),
+        FORK_BLOCK_MAINNET,
+    )
+    .await;
+}
+
+async fn eip4626_native_price_test(web3: Web3) {
+    let mut onchain = OnchainComponents::deployed(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers_forked(1u64.eth()).await;
+    let [trader] = onchain.make_accounts(1u64.eth()).await;
+
+    let sdai = ERC20::Instance::new(SDAI, web3.provider.clone());
+
+    // Transfer sDAI from whale to trader.
+    web3.provider
+        .anvil_send_impersonated_transaction_with_config(
+            sdai.transfer(trader.address(), 1000u64.eth())
+                .from(SDAI_WHALE)
+                .into_transaction_request(),
+            ImpersonateConfig {
+                fund_amount: Some(1u64.eth()),
+                stop_impersonate: true,
+            },
+        )
+        .await
+        .unwrap()
+        .get_receipt()
+        .await
+        .unwrap();
+
+    // Approve the vault-relayer for trading.
+    sdai.approve(onchain.contracts().allowance, 1000u64.eth())
+        .from(trader.address())
+        .send_and_watch()
+        .await
+        .unwrap();
+
+    let driver_url: url::Url = "http://localhost:11088/test_solver".parse().unwrap();
+    let autopilot_config = Configuration {
+        native_price_estimation: NativePriceConfig {
+            eip4626: true,
+            estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
+                "test_quoter".to_string(),
+                driver_url,
+            )]]),
+            shared: configs::native_price::NativePriceConfig {
+                results_required: 1.try_into().unwrap(),
+                ..Default::default()
+            },
+            ..NativePriceConfig::test_default()
+        },
+        ..Configuration::test("test_solver", solver.address())
+    };
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            autopilot_config,
+            configs::orderbook::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    onchain.mint_block().await;
+
+    // Submit a quote selling sDAI for WETH. If the EIP-4626 native price
+    // estimator works, the protocol can price sDAI and the quote succeeds.
+    let quote = services
+        .submit_quote(&OrderQuoteRequest {
+            from: trader.address(),
+            sell_token: SDAI,
+            buy_token: WETH,
+            side: OrderQuoteSide::Sell {
+                sell_amount: SellAmount::BeforeFee {
+                    value: (100u64.eth()).try_into().unwrap(),
+                },
+            },
+            ..Default::default()
+        })
+        .await;
+
+    assert!(
+        quote.is_ok(),
+        "quote for sDAI should succeed with EIP-4626 native price estimator: {:?}",
+        quote.err()
+    );
+}
+
+#[tokio::test]
+#[ignore]
+async fn forked_node_mainnet_eip4626_recursive_native_price() {
+    run_forked_test_with_block_number(
+        eip4626_recursive_native_price_test,
+        std::env::var("FORK_URL_MAINNET")
+            .expect("FORK_URL_MAINNET must be set to run forked tests"),
+        FORK_BLOCK_MAINNET,
+    )
+    .await;
+}
+
+/// Tests pricing of mock EIP-4626 vaults with non-trivial conversion rates.
+/// Deploys wrapper vaults on top of sDAI (which itself wraps DAI) with
+/// different rates and verifies native prices are proportional to their
+/// conversion rates.
+async fn eip4626_recursive_native_price_test(web3: Web3) {
+    let mut onchain = OnchainComponents::deployed(web3.clone()).await;
+
+    let [solver] = onchain.make_solvers_forked(1u64.eth()).await;
+
+    // Deploy mock EIP-4626 vaults wrapping sDAI with different conversion rates.
+    // Each wrapper applies `convertToAssets(shares) = shares * num / den`, so a
+    // (3, 2) wrapper means 1 share = 1.5 sDAI, making it 1.5x the sDAI price.
+    let rates: &[(u64, u64)] = &[(3, 2), (2, 1), (1, 3)];
+    let mut wrapper_addrs = Vec::with_capacity(rates.len());
+    for &(num, den) in rates {
+        let wrapper = contracts::test::MockERC4626Wrapper::Instance::deploy(
+            web3.provider.clone(),
+            SDAI,
+            18u8,
+            U256::from(num),
+            U256::from(den),
+        )
+        .await
+        .unwrap();
+        wrapper_addrs.push(*wrapper.address());
+    }
+
+    let driver_url: url::Url = "http://localhost:11088/test_solver".parse().unwrap();
+    let autopilot_config = Configuration {
+        native_price_estimation: NativePriceConfig {
+            eip4626: true,
+            estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::driver(
+                "test_quoter".to_string(),
+                driver_url,
+            )]]),
+            shared: configs::native_price::NativePriceConfig {
+                results_required: 1.try_into().unwrap(),
+                ..Default::default()
+            },
+            ..NativePriceConfig::test_default()
+        },
+        ..Configuration::test("test_solver", solver.address())
+    };
+
+    let services = Services::new(&onchain).await;
+    services
+        .start_protocol_with_args(
+            autopilot_config,
+            configs::orderbook::Configuration::test_default(),
+            solver,
+        )
+        .await;
+
+    onchain.mint_block().await;
+
+    // Verify native prices: use the first wrapper (3/2) as a baseline and
+    // check that the others are priced proportionally to their conversion rate.
+    let baseline_addr = wrapper_addrs[0];
+    wait_for_condition(TIMEOUT, || async {
+        services.get_native_price(&baseline_addr).await.is_ok()
+    })
+    .await
+    .expect("native price for wrapper (3/2) should be available");
+    let baseline_price = services
+        .get_native_price(&baseline_addr)
+        .await
+        .unwrap()
+        .price;
+
+    // Wrapper (2/1) has rate 2/1 vs baseline 3/2, so its price should be
+    // (2/1) / (3/2) = 4/3 of the baseline.
+    let addr = wrapper_addrs[1];
+    wait_for_condition(TIMEOUT, || async {
+        services.get_native_price(&addr).await.is_ok()
+    })
+    .await
+    .expect("native price for wrapper (2/1) should be available");
+    let price = services.get_native_price(&addr).await.unwrap().price;
+    let ratio = price / baseline_price;
+    assert!(
+        (ratio - 4.0 / 3.0).abs() / (4.0 / 3.0) < 0.01,
+        "wrapper (2/1) price ratio to baseline (3/2) should be 4/3: got {ratio:.6}",
+    );
+
+    // Wrapper (1/3) has rate 1/3 vs baseline 3/2, so its price should be
+    // (1/3) / (3/2) = 2/9 of the baseline.
+    let addr = wrapper_addrs[2];
+    wait_for_condition(TIMEOUT, || async {
+        services.get_native_price(&addr).await.is_ok()
+    })
+    .await
+    .expect("native price for wrapper (1/3) should be available");
+    let price = services.get_native_price(&addr).await.unwrap().price;
+    let ratio = price / baseline_price;
+    assert!(
+        (ratio - 2.0 / 9.0).abs() / (2.0 / 9.0) < 0.01,
+        "wrapper (1/3) price ratio to baseline (3/2) should be 2/9: got {ratio:.6}",
+    );
+}
diff --git a/crates/e2e/tests/e2e/main.rs b/crates/e2e/tests/e2e/main.rs
index 7240e75349..fdf61242bf 100644
--- a/crates/e2e/tests/e2e/main.rs
+++ b/crates/e2e/tests/e2e/main.rs
@@ -15,6 +15,7 @@ mod cow_amm;
 mod database;
 mod debug_order;
 mod deprecated_endpoints;
+mod eip4626;
 mod eth_integration;
 mod eth_safe;
 mod ethflow;
diff --git a/crates/price-estimation/Cargo.toml b/crates/price-estimation/Cargo.toml
index c2596b132a..42f08ca145 100644
--- a/crates/price-estimation/Cargo.toml
+++ b/crates/price-estimation/Cargo.toml
@@ -22,6 +22,7 @@ clap = { workspace = true }
 configs = { workspace = true }
 const-hex = { workspace = true }
 contracts = { workspace = true }
+dashmap = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
diff --git a/crates/price-estimation/src/factory.rs b/crates/price-estimation/src/factory.rs
index 4d5268ca64..6dc1e9c971 100644
--- a/crates/price-estimation/src/factory.rs
+++ b/crates/price-estimation/src/factory.rs
@@ -368,7 +368,9 @@ impl<'a> PriceEstimatorFactory<'a> {
         ))
     }
 
-    /// Creates a native price estimator from the given sources.
+    /// Creates a native price estimator from the given sources. When `eip4626`
+    /// is true the resulting estimator is wrapped in an [`native::Eip4626`]
+    /// layer that transparently prices vault tokens.
     pub async fn native_price_estimator(
         &mut self,
         native: &[Vec<NativePriceEstimatorSource>],
@@ -393,17 +395,29 @@ impl<'a> PriceEstimatorFactory<'a> {
 
     /// Creates a [`CachingNativePriceEstimator`] that wraps a native price
     /// estimator with an in-memory cache.
+    ///
+    /// If `eip4626` is true, it will wrap the estimator with EIP-4626
+    /// unwrapping.
     pub async fn caching_native_price_estimator(
         &mut self,
         native: &[Vec<NativePriceEstimatorSource>],
         results_required: NonZeroUsize,
         weth: &WETH9::Instance,
         cache: native_price_cache::Cache,
+        eip4626: bool,
     ) -> native_price_cache::CachingNativePriceEstimator {
         let inner = self
             .native_price_estimator(native, results_required, weth)
             .await
             .expect("failed to build native price estimator");
+        let inner = if eip4626 {
+            Box::new(InstrumentedPriceEstimator::new(
+                native::Eip4626::new(inner, self.network.web3.provider.clone()),
+                "Eip4626".to_string(),
+            ))
+        } else {
+            inner
+        };
         self.caching_native_price_estimator_from_inner(inner, cache)
             .await
     }
diff --git a/crates/price-estimation/src/native/eip4626.rs b/crates/price-estimation/src/native/eip4626.rs
new file mode 100644
index 0000000000..7493294ad7
--- /dev/null
+++ b/crates/price-estimation/src/native/eip4626.rs
@@ -0,0 +1,275 @@
+use {
+    super::{NativePriceEstimateResult, NativePriceEstimating},
+    crate::PriceEstimationError,
+    alloy::primitives::{Address, U256},
+    anyhow::Context,
+    contracts::{ERC20, IERC4626},
+    dashmap::DashSet,
+    ethrpc::{AlloyProvider, alloy::errors::ContractErrorExt},
+    futures::{FutureExt, future::BoxFuture},
+    num::{BigInt, BigRational, ToPrimitive},
+    number::conversions::u256_to_big_rational,
+    std::time::{Duration, Instant},
+};
+
+/// Estimates the native price of EIP-4626 vault tokens by:
+/// 1. Querying `asset()` and `decimals()` on the vault
+/// 2. Querying `convertToAssets(10^vault_decimals)` and `decimals()` on the
+///    underlying asset
+/// 3. Computing the conversion rate accounting for decimal differences
+/// 4. Delegating to an inner estimator for the underlying token's native price
+///
+/// For non-vault tokens, delegates directly to the inner estimator
+/// (pass-through).
+///
+/// Tokens whose `asset()` call reverts are remembered in a negative cache so
+/// subsequent requests skip the RPC and go straight to the inner estimator.
+pub struct Eip4626 {
+    inner: Box<dyn NativePriceEstimating>,
+    provider: AlloyProvider,
+    /// Addresses that are known *not* to be EIP-4626 vaults (i.e. `asset()`
+    /// reverted). Checked before making any RPC calls.
+    non_vault_tokens: DashSet<Address>,
+}
+
+impl Eip4626 {
+    pub fn new(inner: Box<dyn NativePriceEstimating>, provider: AlloyProvider) -> Self {
+        Self {
+            inner,
+            provider,
+            non_vault_tokens: DashSet::new(),
+        }
+    }
+
+    async fn estimate(&self, token: Address, timeout: Duration) -> NativePriceEstimateResult {
+        let deadline = Instant::now() + timeout;
+        let (underlying, cumulative_rate) =
+            tokio::time::timeout(timeout, self.unwrap_all_layers(token))
+                .await
+                .map_err(|_| {
+                    PriceEstimationError::EstimatorInternal(anyhow::anyhow!(
+                        "timeout while unwrapping EIP-4626 layers for {token}"
+                    ))
+                })??;
+
+        let remaining = deadline.saturating_duration_since(Instant::now());
+        let asset_price = self
+            .inner
+            .estimate_native_price(underlying, remaining)
+            .await?;
+        Ok(asset_price * cumulative_rate)
+    }
+
+    /// Follows the vault chain (e.g. vault → vault → asset) until reaching a
+    /// non-vault token, returning the terminal token and the cumulative
+    /// shares-to-assets rate.
+    async fn unwrap_all_layers(
+        &self,
+        token: Address,
+    ) -> Result<(Address, f64), PriceEstimationError> {
+        let mut current_token = token;
+        let mut cumulative_rate = 1.0;
+        while let Some((asset, rate)) = self.unwrap_vault_layer(current_token).await? {
+            cumulative_rate *= rate;
+            current_token = asset;
+        }
+        Ok((current_token, cumulative_rate))
+    }
+
+    /// Returns:
+    /// - `Ok(Some((asset, rate)))` when `token` is a vault.
+    /// - `Ok(None)` when it's a plain ERC-20.
+    /// - `Err` on RPC/computation failures that don't let us classify the
+    ///   token.
+    async fn unwrap_vault_layer(
+        &self,
+        token: Address,
+    ) -> Result<Option<(Address, f64)>, PriceEstimationError> {
+        if self.non_vault_tokens.contains(&token) {
+            return Ok(None);
+        }
+
+        let Some((asset, vault_decimals)) = self.fetch_vault_info(token).await? else {
+            self.non_vault_tokens.insert(token);
+            metrics::non_vault_cache_size(self.non_vault_tokens.len());
+            return Ok(None);
+        };
+        let (assets, asset_decimals) = self
+            .fetch_conversion_data(token, asset, vault_decimals)
+            .await?;
+        let rate = conversion_rate(assets, asset_decimals)
+            .context("conversion rate is not representable as f64")
+            .map_err(PriceEstimationError::EstimatorInternal)?;
+        Ok(Some((asset, rate)))
+    }
+
+    /// Fetches the vault's underlying asset address and vault token decimals.
+    ///
+    /// Returns:
+    /// - `Ok(Some(...))` when `token` is a vault.
+    /// - `Ok(None)` when `asset()` reverts (indicating it is a regular ERC-20).
+    /// - `Err` on transient transport failures — those are *not* cached as
+    ///   non-vault.
+    async fn fetch_vault_info(
+        &self,
+        token: Address,
+    ) -> Result<Option<(Address, u8)>, PriceEstimationError> {
+        let vault = IERC4626::IERC4626::new(token, &self.provider);
+        let vault_erc20 = ERC20::ERC20::new(token, &self.provider);
+        let asset_call = vault.asset();
+        let decimals_call = vault_erc20.decimals();
+        let (asset_result, decimals_result) = tokio::join!(asset_call.call(), decimals_call.call());
+
+        match asset_result {
+            Ok(asset) => {
+                // EIP-4626 vaults implement ERC-20 so decimals() must succeed too.
+                let vault_decimals = decimals_result.map_err(|err| {
+                    PriceEstimationError::EstimatorInternal(anyhow::anyhow!(
+                        "failed to call decimals() on {token}: {err}"
+                    ))
+                })?;
+                Ok(Some((asset, vault_decimals)))
+            }
+            // `asset()` reverted but the contract is a valid ERC-20 (decimals()
+            // succeeded). Classify as non-vault.
+            Err(err) if err.is_contract_error() && decimals_result.is_ok() => Ok(None),
+            Err(err) => Err(PriceEstimationError::EstimatorInternal(anyhow::anyhow!(
+                "failed to call asset() on {token}: {err}"
+            ))),
+        }
+    }
+
+    /// Fetches `convertToAssets(10^vault_decimals)` — how many atomic units of
+    /// the underlying asset correspond to one full vault token — and the
+    /// asset's decimals.
+    async fn fetch_conversion_data(
+        &self,
+        token: Address,
+        asset: Address,
+        vault_decimals: u8,
+    ) -> Result<(U256, u8), PriceEstimationError> {
+        let one_token = U256::from(10u64)
+            .checked_pow(U256::from(vault_decimals))
+            .ok_or_else(|| {
+                PriceEstimationError::EstimatorInternal(anyhow::anyhow!(
+                    "vault decimals {vault_decimals} for {token} cause U256 overflow"
+                ))
+            })?;
+
+        let vault = IERC4626::IERC4626::new(token, &self.provider);
+        let asset_erc20 = ERC20::ERC20::new(asset, &self.provider);
+        let convert_call = vault.convertToAssets(one_token);
+        let asset_decimals_call = asset_erc20.decimals();
+        tokio::try_join!(convert_call.call(), asset_decimals_call.call()).map_err(|err| {
+            PriceEstimationError::EstimatorInternal(anyhow::anyhow!(
+                "failed to call convertToAssets()/decimals() on {token}: {err}"
+            ))
+        })
+    }
+}
+
+impl NativePriceEstimating for Eip4626 {
+    fn estimate_native_price(
+        &self,
+        token: Address,
+        timeout: Duration,
+    ) -> BoxFuture<'_, NativePriceEstimateResult> {
+        self.estimate(token, timeout).boxed()
+    }
+}
+
+/// Computes the full-asset-tokens per full-vault-token conversion rate.
+///
+/// `assets` is the return value of `convertToAssets(10^vault_decimals)` — i.e.
+/// asset-atomic-units for exactly 1 full vault token. Dividing by
+/// `10^asset_decimals` converts to full asset tokens.
+///
+/// Returns `None` when the result is not representable as `f64`.
+fn conversion_rate(assets: U256, asset_decimals: u8) -> Option<f64> {
+    let denominator = BigRational::from_integer(BigInt::from(10u64).pow(asset_decimals as u32));
+    (u256_to_big_rational(&assets) / denominator).to_f64()
+}
+
+mod metrics {
+    use {observe::metrics, prometheus::IntGauge};
+
+    #[derive(prometheus_metric_storage::MetricStorage)]
+    struct Metrics {
+        /// Number of tokens in the EIP-4626 negative cache (known non-vault
+        /// tokens).
+        eip4626_non_vault_cache_size: IntGauge,
+    }
+
+    impl Metrics {
+        fn get() -> &'static Self {
+            Metrics::instance(metrics::get_storage_registry()).unwrap()
+        }
+    }
+
+    pub(super) fn non_vault_cache_size(size: usize) {
+        Metrics::get()
+            .eip4626_non_vault_cache_size
+            .set(i64::try_from(size).unwrap_or(i64::MAX));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        crate::{HEALTHY_PRICE_ESTIMATION_TIME, native::MockNativePriceEstimating},
+    };
+
+    #[test]
+    fn rate_math_same_decimals() {
+        // 18-decimal vault wrapping 18-decimal asset, 1 share = 1.5 asset tokens.
+        // convertToAssets(10^18) = 1.5 * 10^18 asset-atomic-units
+        let assets = U256::from(15u64) * U256::from(10u64).pow(U256::from(17u64));
+        let rate = conversion_rate(assets, 18).unwrap();
+        assert!((rate - 1.5).abs() < 1e-9, "rate={rate}");
+    }
+
+    #[test]
+    fn rate_math_vault_18_asset_6() {
+        // 18-decimal vault wrapping 6-decimal USDC, 1 share = 1.5 USDC.
+        // convertToAssets(10^18) = 1_500_000 asset-atomic-units (1.5 * 10^6)
+        let assets = U256::from(1_500_000u64);
+        let rate = conversion_rate(assets, 6).unwrap();
+        assert!((rate - 1.5).abs() < 1e-9, "rate={rate}");
+    }
+
+    #[test]
+    fn rate_math_vault_6_asset_18() {
+        // 6-decimal vault wrapping 18-decimal asset, 1 share = 2 asset tokens.
+        // convertToAssets(10^6) = 2 * 10^18 asset-atomic-units
+        let assets = U256::from(2u64) * U256::from(10u64).pow(U256::from(18u64));
+        let rate = conversion_rate(assets, 18).unwrap();
+        assert!((rate - 2.0).abs() < 1e-9, "rate={rate}");
+    }
+
+    #[tokio::test]
+    async fn non_vault_tokens_delegate_to_inner() {
+        let mut inner = MockNativePriceEstimating::new();
+        let token = Address::repeat_byte(0x42);
+        let expected_price = 1.5;
+        inner
+            .expect_estimate_native_price()
+            .withf(move |t, _| *t == token)
+            .returning(move |_, _| Box::pin(async move { Ok(expected_price) }));
+
+        let non_vault_tokens = DashSet::new();
+        non_vault_tokens.insert(token);
+
+        let estimator = Eip4626 {
+            inner: Box::new(inner),
+            // The provider is never reached because the cache short-circuits.
+            provider: ethrpc::Web3::new_from_url("http://localhost:1").provider,
+            non_vault_tokens,
+        };
+
+        let result = estimator
+            .estimate(token, HEALTHY_PRICE_ESTIMATION_TIME)
+            .await;
+        assert_eq!(result.unwrap(), expected_price);
+    }
+}
diff --git a/crates/price-estimation/src/native/mod.rs b/crates/price-estimation/src/native/mod.rs
index f39dd7666c..95338b3562 100644
--- a/crates/price-estimation/src/native/mod.rs
+++ b/crates/price-estimation/src/native/mod.rs
@@ -13,12 +13,14 @@ use {
 };
 
 mod coingecko;
+mod eip4626;
 pub mod fallback;
 mod forwarder;
 mod oneinch;
 
 pub use self::{
     coingecko::CoinGecko,
+    eip4626::Eip4626,
     fallback::FallbackNativePriceEstimator,
     forwarder::Forwarder,
     oneinch::OneInch,

From 9d28f2a132a0f12b9594cc55c9bbbb240692fd58 Mon Sep 17 00:00:00 2001
From: Nikita Kirsanov <n.kirsanov@alumni.nsu.ru>
Date: Mon, 20 Apr 2026 22:12:03 +0700
Subject: [PATCH 208/219] [Driver] Add SettlementStarted solver notification
 (#4327)

# Description
## Context
Some PMMs benefit from knowing that their quotes will be used in
settlement as early as possible because they can hedge earlier, manage
their risks better, and as a result provide better prices. The example
would be #3452 feature request from Liquorice PMM - they solved their
problem in PR #3451 by implementing a notification system that can
notify PMM directly from driver. However, this approach requires PMMs to
be involved in pushing a PR to cowprotocol, which is not always
possible/feasible/desirable.

## Solution
This PR introduces a new solver notification called SettlementStarted,
that fires off whenever a solver has won and the settlement of its
solution is about to start.

# Changes
`crates/solvers-dto`
* `notification::Kind::SettlementStarted` was added.
`crates/driver`
* `infra/notify/notification.rs` - domain notification kind
`Kind::SettlementStarted` was added.
* `infra/solver/dto/notification.rs` - a mapping from `driver` domain to
`solvers-dto` notification kind was added.
* `infra/notify/mod.rs` - function `settlement_started` was added, that
fires-and-forgets the named notification.
* `domain/competition/mod.rs` - a `notify::settlement_started()` call
was added right before trying to settle the solution.

## How to test
I found no existing notification testing system, so I decided I am not
the one to include that. However, it's possible to do in e2e tests by
setting up a driver, a solver, calling driver's `settle` with the
solver's name on it and look for the notification to be received on the
solver's side.

## Related Issues
Implements #4326

Co-authored-by: Haris Angelidakis <64154020+harisang@users.noreply.github.com>
---
 crates/driver/src/domain/competition/mod.rs        | 2 ++
 crates/driver/src/infra/notify/mod.rs              | 8 ++++++++
 crates/driver/src/infra/notify/notification.rs     | 2 ++
 crates/driver/src/infra/solver/dto/notification.rs | 1 +
 crates/solvers-dto/src/notification.rs             | 1 +
 5 files changed, 14 insertions(+)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index a466456516..bbb905dc74 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -841,6 +841,8 @@ impl Competition {
             });
         }
 
+        notify::settlement_started(&self.solver, settlement.auction_id, settlement.solution());
+
         // Acquire a submission slot. The pool prefers the direct solver EOA
         // (no forwarding overhead); falls back to a delegated EIP-7702
         // submission account when the solver EOA is busy.
diff --git a/crates/driver/src/infra/notify/mod.rs b/crates/driver/src/infra/notify/mod.rs
index 1e5a41d0b7..8e6d8d97d9 100644
--- a/crates/driver/src/infra/notify/mod.rs
+++ b/crates/driver/src/infra/notify/mod.rs
@@ -95,6 +95,14 @@ pub fn simulation_failed(
     solver.notify(auction_id, Some(solution_id.clone()), kind);
 }
 
+pub fn settlement_started(solver: &Solver, auction_id: auction::Id, solution_id: &solution::Id) {
+    solver.notify(
+        Some(auction_id),
+        Some(solution_id.clone()),
+        notification::Kind::SettlementStarted,
+    );
+}
+
 pub fn executed(
     solver: &Solver,
     auction_id: auction::Id,
diff --git a/crates/driver/src/infra/notify/notification.rs b/crates/driver/src/infra/notify/notification.rs
index ab680ad34c..b8f50e0d9b 100644
--- a/crates/driver/src/infra/notify/notification.rs
+++ b/crates/driver/src/infra/notify/notification.rs
@@ -36,6 +36,8 @@ pub enum Kind {
     NonBufferableTokensUsed(TokensUsed),
     /// Solver don't have enough balance to submit the solution onchain.
     SolverAccountInsufficientBalance(RequiredEther),
+    /// Solver won, driver is trying to  settle the transaction onchain.
+    SettlementStarted,
     /// Result of winning solver trying to settle the transaction onchain.
     Settled(Settlement),
     /// Some aspect of the driver logic failed preventing the solution from
diff --git a/crates/driver/src/infra/solver/dto/notification.rs b/crates/driver/src/infra/solver/dto/notification.rs
index 83c5b8fe0a..d974d577a0 100644
--- a/crates/driver/src/infra/solver/dto/notification.rs
+++ b/crates/driver/src/infra/solver/dto/notification.rs
@@ -44,6 +44,7 @@ pub fn new(
             notify::Kind::DriverError(reason) => {
                 solvers_dto::notification::Kind::DriverError { reason }
             }
+            notify::Kind::SettlementStarted => solvers_dto::notification::Kind::SettlementStarted,
             notify::Kind::Settled(kind) => match kind {
                 notify::Settlement::Success(hash) => solvers_dto::notification::Kind::Success {
                     transaction: hash.0,
diff --git a/crates/solvers-dto/src/notification.rs b/crates/solvers-dto/src/notification.rs
index c0acc7e2ee..dbbff28c23 100644
--- a/crates/solvers-dto/src/notification.rs
+++ b/crates/solvers-dto/src/notification.rs
@@ -52,6 +52,7 @@ pub enum Kind {
         #[serde_as(as = "HexOrDecimalU256")]
         required: U256,
     },
+    SettlementStarted,
     Success {
         transaction: B256,
     },

From 2c34db9a386cbc4ac5537d2e8953a62e7587b980 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Tue, 21 Apr 2026 12:04:57 +0000
Subject: [PATCH 209/219] Correctly encode approval interactions for USDT-like
 tokens (#4354)

# Description
Alternative to https://github.com/cowprotocol/services/pull/4340

USDT is a bit special because it is one of very few tokens where the
`approve()` function requires you to set the allowance back to 0 before
you can alter it again to avoid a vulnerability (see
[here](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729)).

# Changes
This PR adjusts the driver's approval encoding logic such that it checks
whether the regular `approve()` call would revert. In case that happens
it encodes an `approve(0)` and `approve(desired_value)` to be compatible
with this security measure / quirk.
That way we support all those tokens on all chains without needing any
extra configuration parameters or hardcoded values. The downside is 1
extra RPC call every time we have to increase an approval which is
extremely rare so it's fine.

## How to test
Converted an existing `USDC -> USDT` order fork test to be a `USDT ->
USDC` test. This test fails without the PR's change.
---
 .../src/domain/competition/solution/mod.rs    | 45 +++++++++++++++----
 crates/e2e/tests/e2e/limit_orders.rs          | 28 ++++++------
 2 files changed, 51 insertions(+), 22 deletions(-)

diff --git a/crates/driver/src/domain/competition/solution/mod.rs b/crates/driver/src/domain/competition/solution/mod.rs
index 1f5c38c2cd..11d63dfa80 100644
--- a/crates/driver/src/domain/competition/solution/mod.rs
+++ b/crates/driver/src/domain/competition/solution/mod.rs
@@ -15,6 +15,7 @@ use {
     },
     alloy::network::TxSigner,
     chrono::Utc,
+    contracts::ERC20::ERC20,
     eth_domain_types::{self as eth, TokenAddress},
     futures::future::try_join_all,
     itertools::Itertools,
@@ -298,24 +299,52 @@ impl Solution {
     }
 
     /// Approval interactions necessary for encoding the settlement.
+    /// To support tokens like USDT which first need to have their allowance
+    /// set to 0 before it can be set to the desired value we simulate each
+    /// `approve()` call and inject additional `approve(0)` interactions when
+    /// we encounter a revert.
+    /// Whenever the needed allowance is less the current allowance no
+    /// `approve()` interactions get encoded to save on gas.
+    /// See <https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729>
     pub async fn approvals(
         &self,
         eth: &Ethereum,
         internalization: settlement::Internalization,
     ) -> Result<impl Iterator<Item = eth::allowance::Approval> + use<>, Error> {
-        let settlement_contract = &eth.contracts().settlement();
+        let settlement_contract = *eth.contracts().settlement().address();
         let allowances =
             try_join_all(self.allowances(internalization).map(|required| async move {
-                eth.erc20(required.0.token)
-                    .allowance(*settlement_contract.address(), required.0.spender)
+                let erc20_token = ERC20::new(required.0.token.into(), &eth.web3().provider);
+
+                let current_allowance = erc20_token
+                    .allowance(settlement_contract, required.0.spender)
+                    .call()
+                    .await?;
+
+                // if the current allowance is sufficient we can skip that interaction
+                if current_allowance >= required.0.amount {
+                    return Ok::<_, blockchain::Error>(vec![]);
+                }
+
+                let regular_approval_succeeds = erc20_token
+                    .approve(required.0.spender, required.0.amount)
+                    .from(settlement_contract)
+                    .call()
                     .await
-                    .map(|existing| (required, existing))
+                    .is_ok();
+
+                let approval = eth::allowance::Approval(required.0);
+                if regular_approval_succeeds {
+                    Ok(vec![approval])
+                } else {
+                    // setting the desired approval reverts so we assume we are
+                    // dealing with a USDT-like token that needs to have the
+                    // approval reset to 0 first
+                    Ok(vec![approval.revoke(), approval])
+                }
             }))
             .await?;
-        let approvals = allowances
-            .into_iter()
-            .filter_map(|(required, existing)| required.approval(&existing));
-        Ok(approvals)
+        Ok(allowances.into_iter().flatten())
     }
 
     /// An empty solution has no trades which is allowed to capture surplus and
diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs
index 1ba0d40c74..3c9da8d972 100644
--- a/crates/e2e/tests/e2e/limit_orders.rs
+++ b/crates/e2e/tests/e2e/limit_orders.rs
@@ -102,8 +102,8 @@ async fn local_node_buy_order_with_haircut() {
 
 /// The block number from which we will fetch state for the forked tests.
 const FORK_BLOCK_MAINNET: u64 = 24843565;
-/// USDC whale address as per [FORK_BLOCK_MAINNET].
-const USDC_WHALE_MAINNET: Address = address!("28c6c06298d514db089934071355e5743bf21d60");
+/// USDT whale address as per [FORK_BLOCK_MAINNET].
+const USDT_WHALE_MAINNET: Address = address!("F977814e90dA44bFA03b6295A0616a897441aceC");
 
 #[tokio::test]
 #[ignore]
@@ -981,12 +981,12 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
         web3.provider.clone(),
     );
 
-    // Give trader some USDC
+    // Give trader some USDT
     web3.provider
         .anvil_send_impersonated_transaction_with_config(
-            token_usdc
+            token_usdt
                 .transfer(trader.address(), 1000u64.matom())
-                .from(USDC_WHALE_MAINNET)
+                .from(USDT_WHALE_MAINNET)
                 .into_transaction_request(),
             ImpersonateConfig {
                 fund_amount: None,
@@ -1000,7 +1000,7 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
         .unwrap();
 
     // Approve GPv2 for trading
-    token_usdc
+    token_usdt
         .approve(onchain.contracts().allowance, 1000u64.matom())
         .from(trader.address())
         .send_and_watch()
@@ -1014,9 +1014,9 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
     onchain.mint_block().await;
 
     let order = OrderCreation {
-        sell_token: *token_usdc.address(),
+        sell_token: *token_usdt.address(),
         sell_amount: 1000u64.matom(),
-        buy_token: *token_usdt.address(),
+        buy_token: *token_usdc.address(),
         buy_amount: 500u64.matom(),
         valid_to: model::time::now_in_epoch_seconds() + 300,
         kind: OrderKind::Sell,
@@ -1032,8 +1032,8 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
     // may time out)
     let _ = services
         .submit_quote(&OrderQuoteRequest {
-            sell_token: *token_usdc.address(),
-            buy_token: *token_usdt.address(),
+            sell_token: *token_usdt.address(),
+            buy_token: *token_usdc.address(),
             side: OrderQuoteSide::Sell {
                 sell_amount: SellAmount::BeforeFee {
                     value: (1000u64.matom()).try_into().unwrap(),
@@ -1043,8 +1043,8 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
         })
         .await;
 
-    let sell_token_balance_before = token_usdc.balanceOf(trader.address()).call().await.unwrap();
-    let buy_token_balance_before = token_usdt.balanceOf(trader.address()).call().await.unwrap();
+    let sell_token_balance_before = token_usdt.balanceOf(trader.address()).call().await.unwrap();
+    let buy_token_balance_before = token_usdc.balanceOf(trader.address()).call().await.unwrap();
     let order_id = services.create_order(&order).await.unwrap();
     let limit_order = services.get_order(&order_id).await.unwrap();
     assert_eq!(limit_order.metadata.class, OrderClass::Limit);
@@ -1054,8 +1054,8 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) {
 
     wait_for_condition(TIMEOUT, || async {
         onchain.mint_block().await;
-        let sell_token_balance_after = token_usdc.balanceOf(trader.address()).call().await.unwrap();
-        let buy_token_balance_after = token_usdt.balanceOf(trader.address()).call().await.unwrap();
+        let sell_token_balance_after = token_usdt.balanceOf(trader.address()).call().await.unwrap();
+        let buy_token_balance_after = token_usdc.balanceOf(trader.address()).call().await.unwrap();
 
         (sell_token_balance_before > sell_token_balance_after)
             && (buy_token_balance_after >= buy_token_balance_before + 500u64.matom())

From 2f337af30a4b8586c323a58a800b74644a26f97d Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 22 Apr 2026 08:52:08 +0100
Subject: [PATCH 210/219] Use inline PR review comments from Claude code review
 (#4356)

# Description
The Claude code-review action currently posts one big summary as an
issue comment (example:
https://github.com/cowprotocol/services/pull/4355#issuecomment-4291257773).
The `code-review` plugin has a `--comment` flag that switches it from
the summary-text mode to posting one PR review comment per issue
anchored to the exact line in the diff, matching how
`gemini-code-assist[bot]` already behaves. Per the plugin spec (step 9),
this flag triggers `mcp__github_inline_comment__create_inline_comment`
instead of a single `gh pr comment`.

# Changes
- Append `--comment` to the `/code-review:code-review` prompt in
`.github/workflows/claude-code-review.yml`.

# How to test
Run the `claude /review` command.
---
 .github/workflows/claude-code-review.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml
index 2dc7b0fa7c..5a1d3228c8 100644
--- a/.github/workflows/claude-code-review.yml
+++ b/.github/workflows/claude-code-review.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: read
-      pull-requests: read
+      pull-requests: write
       issues: read
       id-token: write
 
@@ -27,5 +27,5 @@ jobs:
           anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
           plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
           plugins: 'code-review@claude-code-plugins'
-          prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}'
+          prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }} --comment'
 

From 3f806569b3685635f818ab887766632c940d25f7 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 22 Apr 2026 12:08:20 +0100
Subject: [PATCH 211/219] Bump rustls-webpki to 0.103.13 (RUSTSEC-2026-0104)
 (#4357)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

- `cargo audit` is currently failing on `main` due to
[RUSTSEC-2026-0104](https://rustsec.org/advisories/RUSTSEC-2026-0104) —
a reachable panic in `rustls-webpki`'s CRL parsing (affected:
`0.103.0..0.103.13`).
- `rustls-webpki` is a transitive dep (via `rustls-platform-verifier` →
`reqwest`); no direct manifest bump is needed. Ran `cargo update -p
rustls-webpki --precise 0.103.13` to move the lockfile from `0.103.12` →
`0.103.13`.
- While re-resolving, cargo also deduped a few consumers onto
`windows-sys 0.60.2` and `syn 1.0.109`, both of which already existed in
the lockfile on `main` — no new crate versions were introduced.

## Test plan

- [ ] CI green
---
 Cargo.lock | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9d6a24c147..c84cdcab27 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3752,7 +3752,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ab67060fc6b8ef687992d439ca0fa36e7ed17e9a0b16b25b601e8757df720de"
 dependencies = [
  "data-encoding",
- "syn 2.0.114",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -4132,7 +4132,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -7205,7 +7205,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -7262,7 +7262,7 @@ dependencies = [
  "security-framework 3.5.1",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -7273,9 +7273,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.12"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8279bb85272c9f10811ae6a6c547ff594d6a7f3c6c6b02ee9726d1d0dcfcdd06"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -8341,7 +8341,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]

From 8ce89a669bf4b60c16fc1894c9e31390a062d58c Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 22 Apr 2026 12:29:25 +0100
Subject: [PATCH 212/219] Support Aave v3 aToken balance overrides (#4345)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Quote verification was silently failing for any Aave v3 aToken as the
sell token (e.g. aEthWETH → WETH) because the balance-override mechanism
assumes the value at the balance storage slot is what `balanceOf`
returns. Aave v3 aTokens break both assumptions: `balanceOf` applies a
`rayMul(scaled, liquidityIndex)` scaling, and storage is packed
`UserState { uint128 balance; uint128 additionalData }`. The
auto-detector's verify step therefore never matched, returned
`NotFound`, and the trade verifier silently skipped the override,
producing the production revert `execution reverted: trader does not
have enough sell token` visible in barn logs for aEthWETH quotes today
(reproduced on Tenderly:
https://dashboard.tenderly.co/cow-protocol/barn/simulator/1e69fa91-9496-44d1-9aec-a0e34166f9df).

# Changes
- New `Strategy::AaveV3AToken { target_contract, pool, underlying,
map_slot }` variant in `configs::balance_overrides::Strategy` and a
corresponding async resolver on `BalanceOverrides` that fetches the
current `getReserveNormalizedIncome` from the Aave v3 Pool, rayDivs the
requested amount (round-half-up, bit-for-bit compatible with
`WadRayMath.rayDiv`), and writes it into the low 128 bits of the packed
`_userState` slot.
- Auto-detector is now Aave-aware: the detector probes the token with
`UNDERLYING_ASSET_ADDRESS()` + `POOL()` and then calls
`pool.getReserveData(underlying)` and verifies the returned
`aTokenAddress` equals the probed token — an identity check that only
passes for tokens the pool itself has registered as an aToken for their
underlying, preventing rogue contracts that merely implement the aToken
selectors from being accepted. When the probe succeeds, mapping-style
slots are also offered as `AaveV3AToken` candidates and verified with a
1-wei round-trip tolerance instead of strict equality. No hardcoded
per-token list is needed. aEthWETH and every other Aave v3 aToken on
every chain (mainnet, Arbitrum, Base, Gnosis, Polygon, BNB, Linea,
Plasma, Ink, Avalanche, etc.) are picked up automatically the first time
they're quoted.
- Shared Aave math lives in a new `balance-overrides::aave` module so
the production override builder and the detector probe/verify use
identical arithmetic.
- `trade_verifier::prepare_state_overrides` now emits `tracing::warn!`
when the spardose balance override for the sell token can't be resolved
— mirroring the existing warn on the buy-side path so future missing
overrides surface in logs instead of only showing up as downstream
reverts.

# Aave v4 note
Aave v4's user-facing deposit receipt is `TokenizationSpoke`, an
ERC-4626 vault built on OpenZeppelin's `ERC20Upgradeable` — not a scaled
aToken. `balanceOf` is the plain OZ `_balances[user]` mapping (no
`rayMul` scaling), and the contract doesn't expose
`UNDERLYING_ASSET_ADDRESS()` or `POOL()`. Our probe therefore correctly
rejects v4 Spokes and the detector falls through to the existing
`SolidityMapping` / `DirectSlot` heuristics, which handle them as
standard ERC-20s. No v4-specific work is needed here.
Source:
<https://github.com/aave/aave-v4/blob/main/src/spoke/TokenizationSpoke.sol>

# How to test
Unit tests:
- `balance-overrides::tests::a_token_balance_override_bug_reproduction`
— pins the arithmetic: writing the raw amount (what the old strategies
do) makes `balanceOf` return `rayMul(amount, index)` (off by ~6e16 wei
at aEthWETH's current index); writing `rayDiv(amount, index)`
round-trips within 1 wei.
- `balance-overrides::aave::tests` — mock-provider tests for the probe:
accepts a valid aToken, rejects when either selector reverts, rejects
when the claimed pool doesn't look like Aave v3, rejects when the pool
registers a *different* aToken for the declared underlying.
-
`balance-overrides::tests::aave_v3_a_token_override_scales_amount_and_writes_low_128`
— mock-provider integration test for the override builder.

e2e local + forked node tests:
- `balance-overrides::detector::tests::detects_aave_v3_a_token_mainnet`
— asserts the detector returns `AaveV3AToken { pool=0x87870bca…4fa4e2,
underlying=WETH, map_slot=52 }` for aEthWETH.
- `balance-overrides::tests::aave_v3_a_token_override_mainnet_roundtrip`
— applies the override via `eth_call` against real aEthWETH and asserts
`balanceOf(holder) ≈ amount`.
- `e2e::quote_verification::forked_node_mainnet_aave_atoken_quote` —
same round-trip against an anvil mainnet fork, exercising the full
`BalanceOverrides::state_override` path.

# Follow-up items
- **Registry-based detection.** The current probe costs 3 `eth_call`s
per cold-cache token. An alternative is to enumerate all reserves once
per chain from Aave's `AaveProtocolDataProvider` (or equivalent), cache
the full list of aTokens, and do a pure `HashMap` lookup on each quote.
That would make detection amortised O(1) and provide the strongest
identity guarantee (taken from Aave's own registry), at the cost of
introducing a per-chain constant for the DataProvider address, a refresh
cadence for new markets, and handling multiple Aave v3 markets per chain
(e.g. mainnet has Ethereum + Prime). Probably worth doing once aToken
quote volume warrants the optimisation.
- **Cache the accrued liquidity index for ~1 block.** Each aToken quote
currently re-fetches `getReserveNormalizedIncome`. The index drifts
slowly (fractions of a wei per block), so caching for 6–12 s would drop
the per-quote cost to zero without meaningful accuracy loss.
- **Aave v2 support.** Same scaling + packed-storage shape; different
`LendingPool` interface. v2 is deprecated but still has markets; worth
revisiting if any start to attract volume.
---
 Cargo.lock                                    |   1 +
 crates/balance-overrides/Cargo.toml           |   1 +
 crates/balance-overrides/src/aave.rs          | 295 ++++++++++++++++++
 crates/balance-overrides/src/detector.rs      |  85 ++++-
 crates/balance-overrides/src/lib.rs           | 235 ++++++++++++--
 crates/configs/src/balance_overrides.rs       |  48 +++
 crates/e2e/tests/e2e/quote_verification.rs    | 126 +++++++-
 .../src/config/price_estimation.rs            |   3 +-
 .../src/trade_verifier/mod.rs                 |   5 +
 9 files changed, 762 insertions(+), 37 deletions(-)
 create mode 100644 crates/balance-overrides/src/aave.rs

diff --git a/Cargo.lock b/Cargo.lock
index c84cdcab27..02a5c983e4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1863,6 +1863,7 @@ dependencies = [
 name = "balance-overrides"
 version = "0.1.0"
 dependencies = [
+ "alloy-contract",
  "alloy-eips",
  "alloy-primitives",
  "alloy-provider",
diff --git a/crates/balance-overrides/Cargo.toml b/crates/balance-overrides/Cargo.toml
index cd97be3fdf..f1266c42d5 100644
--- a/crates/balance-overrides/Cargo.toml
+++ b/crates/balance-overrides/Cargo.toml
@@ -9,6 +9,7 @@ license = "MIT OR Apache-2.0"
 doctest = false
 
 [dependencies]
+alloy-contract = { workspace = true }
 alloy-eips = { workspace = true }
 alloy-primitives = { workspace = true, features = ["rand"] }
 alloy-provider = { workspace = true, features = ["debug-api", "trace-api"] }
diff --git a/crates/balance-overrides/src/aave.rs b/crates/balance-overrides/src/aave.rs
new file mode 100644
index 0000000000..c745097a3f
--- /dev/null
+++ b/crates/balance-overrides/src/aave.rs
@@ -0,0 +1,295 @@
+//! Helpers shared between the `BalanceOverrides` override builder and the
+//! `Detector` probe/verify for Aave v3 aTokens.
+//!
+//! aTokens break the usual "balanceOf = storage[slot]" assumption twice:
+//! - `balanceOf` returns `scaled_balance × getReserveNormalizedIncome / RAY`,
+//!   not the raw slot value.
+//! - Storage is packed `UserState { uint128 balance; uint128 additionalData }`
+//!   in a single slot per holder.
+
+use {
+    alloy_primitives::{Address, B256, U256, keccak256},
+    alloy_rpc_types::state::AccountOverride,
+    alloy_sol_types::sol,
+    ethrpc::Web3,
+    std::iter,
+};
+
+sol! {
+    /// Mirrors Aave v3's `DataTypes.ReserveConfigurationMap`.
+    ///
+    /// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/protocol/libraries/types/DataTypes.sol>
+    struct ReserveConfigurationMap {
+        uint256 data;
+    }
+
+    /// Mirrors Aave v3's `DataTypes.ReserveData`. Only the `aTokenAddress`
+    /// field is consumed here; the rest are present to keep the ABI layout
+    /// exactly matched so decoding doesn't go off the rails.
+    ///
+    /// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/protocol/libraries/types/DataTypes.sol>
+    struct ReserveData {
+        ReserveConfigurationMap configuration;
+        uint128 liquidityIndex;
+        uint128 currentLiquidityRate;
+        uint128 variableBorrowIndex;
+        uint128 currentVariableBorrowRate;
+        uint128 currentStableBorrowRate;
+        uint40 lastUpdateTimestamp;
+        uint16 id;
+        address aTokenAddress;
+        address stableDebtTokenAddress;
+        address variableDebtTokenAddress;
+        address interestRateStrategyAddress;
+        uint128 accruedToTreasury;
+        uint128 unbacked;
+        uint128 isolationModeTotalDebt;
+    }
+
+    /// Minimal interface for the Aave v3 `Pool`. `getReserveNormalizedIncome`
+    /// gives the accrued liquidity index used when scaling `balanceOf`;
+    /// `getReserveData` returns the full reserve record which we use to
+    /// confirm a probed token really is the registered aToken for its
+    /// underlying.
+    ///
+    /// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/interfaces/IPool.sol>
+    #[sol(rpc)]
+    interface IAaveV3Pool {
+        function getReserveNormalizedIncome(address asset) external view returns (uint256);
+        function getReserveData(address asset) external view returns (ReserveData memory);
+    }
+
+    /// Minimal interface for an Aave v3 `AToken`; used by the detector to
+    /// decide whether a token is an aToken without any hardcoded list.
+    ///
+    /// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/interfaces/IAToken.sol>
+    #[sol(rpc)]
+    interface IAaveV3AToken {
+        function UNDERLYING_ASSET_ADDRESS() external view returns (address);
+        function POOL() external view returns (address);
+    }
+}
+
+/// Ray (1e27) — Aave's 27-decimal fixed-point unit.
+///
+/// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/protocol/libraries/math/WadRayMath.sol>
+pub const RAY: U256 = U256::from_limbs([0x9fd0803ce8000000, 0x33b2e3c, 0, 0]);
+
+/// Storage slot index of `_userState` in the Aave v3 `IncentivizedERC20`
+/// base contract. All canonical v3 aTokens inherit this layout, so the
+/// detector can try this slot directly without a `debug_traceCall`.
+///
+/// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/protocol/tokenization/base/IncentivizedERC20.sol>
+pub const USER_STATE_SLOT: u64 = 52;
+
+/// Ray-division: `(a * RAY + b/2) / b`, round-half-up. Matches Aave's
+/// `WadRayMath.rayDiv` bit-for-bit so the scaled amount we write into
+/// storage equals the one Aave will itself compute during a subsequent
+/// `_transfer`. Returns `None` if `b == 0` or the intermediate product
+/// overflows `U256`.
+pub fn ray_div(a: U256, b: U256) -> Option<U256> {
+    if b.is_zero() {
+        return None;
+    }
+    let half_b = b >> 1;
+    a.checked_mul(RAY)
+        .and_then(|prod| prod.checked_add(half_b))
+        .map(|num| num / b)
+}
+
+/// `keccak256(pad32(holder) ++ map_slot)` — the storage slot of
+/// `mapping(address => _)` entries in Solidity.
+pub fn mapping_slot_hash(holder: &Address, map_slot: &[u8; 32]) -> B256 {
+    let mut buf = [0u8; 64];
+    buf[12..32].copy_from_slice(holder.as_slice());
+    buf[32..64].copy_from_slice(map_slot);
+    keccak256(buf)
+}
+
+/// Packs a `UserState { uint128 balance; uint128 additionalData }` into a
+/// 32-byte word. The balance occupies the lower 128 bits; `additional_data`
+/// sits in the upper 128 bits.
+pub fn pack_user_state(balance: U256, additional_data: U256) -> B256 {
+    let mask = (U256::from(1u64) << 128) - U256::from(1u64);
+    let packed: U256 = ((additional_data & mask) << 128) | (balance & mask);
+    B256::new(packed.to_be_bytes::<32>())
+}
+
+/// Probes whether `token` is an Aave v3 aToken and returns its `(pool,
+/// underlying)` pair. Accepts the token iff the pool registers it as the
+/// aToken for its declared underlying — rogue contracts implementing the
+/// aToken selectors aren't enough.
+pub async fn probe_aave_token(web3: &Web3, token: Address) -> Option<(Address, Address)> {
+    let a_token = IAaveV3AToken::new(token, web3.provider.clone());
+    let underlying_call = a_token.UNDERLYING_ASSET_ADDRESS();
+    let pool_call = a_token.POOL();
+    let (underlying, pool) = tokio::try_join!(underlying_call.call(), pool_call.call()).ok()?;
+    let reserve = IAaveV3Pool::new(pool, web3.provider.clone())
+        .getReserveData(underlying)
+        .call()
+        .await
+        .ok()?;
+    (reserve.aTokenAddress == token).then_some((pool, underlying))
+}
+
+/// Builds a state override that makes `balanceOf(holder)` on the aToken
+/// report approximately `amount`. Writes into the canonical `_userState`
+/// slot (`USER_STATE_SLOT`) shared by all Aave v3 aTokens. Returns `None`
+/// if we can't reach the pool or the math overflows.
+pub async fn build_override(
+    web3: &Web3,
+    a_token: Address,
+    pool: Address,
+    underlying: Address,
+    holder: Address,
+    amount: U256,
+) -> Option<(Address, AccountOverride)> {
+    let Ok(index) = IAaveV3Pool::new(pool, web3.provider.clone())
+        .getReserveNormalizedIncome(underlying)
+        .call()
+        .await
+    else {
+        tracing::warn!(
+            ?pool,
+            ?underlying,
+            "failed to fetch Aave reserve normalized income"
+        );
+        return None;
+    };
+
+    let Some(scaled) = ray_div(amount, index) else {
+        // Either `amount * RAY` overflowed U256 (only possible for an
+        // astronomically large requested amount) or the pool returned a
+        // zero index (never should happen for a live reserve). Either way,
+        // surface it explicitly so we don't silently drop the override.
+        tracing::warn!(
+            ?a_token,
+            %amount,
+            %index,
+            "ray_div overflow computing AaveV3AToken scaled balance"
+        );
+        return None;
+    };
+    let slot = mapping_slot_hash(&holder, &U256::from(USER_STATE_SLOT).to_be_bytes());
+    let value = pack_user_state(scaled, U256::ZERO);
+
+    tracing::trace!(
+        ?a_token,
+        ?holder,
+        %amount,
+        %index,
+        %scaled,
+        "computed AaveV3AToken balance override"
+    );
+
+    let state_override = AccountOverride {
+        state_diff: Some(iter::once((slot, value)).collect()),
+        ..Default::default()
+    };
+    Some((a_token, state_override))
+}
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        alloy_primitives::{address, hex},
+        alloy_provider::mock::Asserter,
+        alloy_sol_types::SolValue,
+    };
+
+    fn encode_address(addr: Address) -> String {
+        hex::encode_prefixed(addr.into_word())
+    }
+
+    /// Encodes a `ReserveData` struct as the ABI return payload the pool
+    /// would produce. All fields other than `aTokenAddress` are zero — we
+    /// only care about that one for the probe.
+    fn encode_reserve_data(a_token: Address) -> String {
+        let data = ReserveData {
+            configuration: ReserveConfigurationMap { data: U256::ZERO },
+            liquidityIndex: 0,
+            currentLiquidityRate: 0,
+            variableBorrowIndex: 0,
+            currentVariableBorrowRate: 0,
+            currentStableBorrowRate: 0,
+            lastUpdateTimestamp: alloy_primitives::Uint::ZERO,
+            id: 0,
+            aTokenAddress: a_token,
+            stableDebtTokenAddress: Address::ZERO,
+            variableDebtTokenAddress: Address::ZERO,
+            interestRateStrategyAddress: Address::ZERO,
+            accruedToTreasury: 0,
+            unbacked: 0,
+            isolationModeTotalDebt: 0,
+        };
+        hex::encode_prefixed(data.abi_encode())
+    }
+
+    /// Builds an `Asserter` primed with the three responses the probe
+    /// expects, in order: `UNDERLYING_ASSET_ADDRESS()`, `POOL()`, and
+    /// `getReserveData(underlying)`. `None` maps to a reverted call; `Some`
+    /// maps to a success response containing the given value.
+    fn probe_asserter(
+        underlying: Option<Address>,
+        pool: Option<Address>,
+        reserve_a_token: Option<Address>,
+    ) -> Asserter {
+        let asserter = Asserter::new();
+        match underlying {
+            Some(u) => asserter.push_success(&encode_address(u)),
+            None => asserter.push_failure_msg("execution reverted"),
+        }
+        match pool {
+            Some(p) => asserter.push_success(&encode_address(p)),
+            None => asserter.push_failure_msg("execution reverted"),
+        }
+        match reserve_a_token {
+            Some(a) => asserter.push_success(&encode_reserve_data(a)),
+            None => asserter.push_failure_msg("execution reverted"),
+        }
+        asserter
+    }
+
+    /// A contract that doesn't expose the aToken selectors — `balanceOf`
+    /// throws when the probe calls `UNDERLYING_ASSET_ADDRESS()` — is
+    /// cleanly rejected so non-aToken ERC-20s don't accidentally pick up
+    /// the Aave strategy.
+    #[tokio::test]
+    async fn probe_aave_token_rejects_when_underlying_call_reverts() {
+        let token = address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
+        let web3 = Web3::with_asserter(probe_asserter(None, None, None));
+        assert_eq!(probe_aave_token(&web3, token).await, None);
+    }
+
+    /// The probe bails if the claimed pool doesn't respond to
+    /// `getReserveData` — guards against a contract exposing both
+    /// `UNDERLYING_ASSET_ADDRESS()` and `POOL()` while pointing at
+    /// something that isn't actually an Aave v3 pool.
+    #[tokio::test]
+    async fn probe_aave_token_rejects_when_pool_is_not_aave() {
+        let token = address!("1111111111111111111111111111111111111111");
+        let pool = address!("2222222222222222222222222222222222222222");
+        let underlying = address!("3333333333333333333333333333333333333333");
+        let web3 = Web3::with_asserter(probe_asserter(Some(underlying), Some(pool), None));
+        assert_eq!(probe_aave_token(&web3, token).await, None);
+    }
+
+    /// A rogue contract that impersonates the aToken interface and points
+    /// at a real Aave pool is rejected: the pool registers a *different*
+    /// `aTokenAddress` for the underlying, so the identity check fails.
+    #[tokio::test]
+    async fn probe_aave_token_rejects_when_pool_registers_a_different_atoken() {
+        let rogue = address!("bad000000000000000000000000000000000cafe");
+        let real_a_token = address!("4d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8");
+        let pool = address!("87870bca3f3fd6335c3f4ce8392d69350b4fa4e2");
+        let underlying = address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
+        let web3 = Web3::with_asserter(probe_asserter(
+            Some(underlying),
+            Some(pool),
+            // Pool agrees on the pair but names the *real* aToken, not the rogue.
+            Some(real_a_token),
+        ));
+        assert_eq!(probe_aave_token(&web3, rogue).await, None);
+    }
+}
diff --git a/crates/balance-overrides/src/detector.rs b/crates/balance-overrides/src/detector.rs
index 5dacf85c35..494b9d57be 100644
--- a/crates/balance-overrides/src/detector.rs
+++ b/crates/balance-overrides/src/detector.rs
@@ -1,6 +1,6 @@
 use {
     super::Strategy,
-    crate::StrategyExt,
+    crate::{StrategyExt, aave},
     alloy_eips::BlockId,
     alloy_primitives::{Address, B256, TxKind, U256, keccak256},
     alloy_provider::ext::DebugApi,
@@ -66,6 +66,10 @@ impl std::ops::Deref for Detector {
 /// 2. Use the Solidity mapping hashes as a heuristic and prioritize scanning
 ///    those storage slots first - these return `SolidityMapping` strategy
 /// 3. For non-heuristic slots, return `DirectSlot` strategy
+///
+/// Note: this function does not emit `AaveV3AToken` candidates. Aave v3 is
+/// handled by the fast-path in `detect()` which tries the canonical
+/// `_userState` slot directly; the fallback here is for non-Aave tokens only.
 fn create_strategies_from_slots(
     storage_slots: &[(Address, B256)],
     holder: &Address,
@@ -124,17 +128,51 @@ impl Detector {
         }))
     }
 
-    /// Detects the balance storage slot using debug_traceCall, similar to
-    /// Foundry's `deal`. This traces a balanceOf call and finds which
-    /// storage slot is accessed. If more than one slot is accessed, we reverse
-    /// by order accessed, sort by if the slot was one that would normally
-    /// be seen in solidity mapping, and test one by one to see if the
-    /// override is effective.
+    /// The `Web3` handle shared with whoever constructed the detector; also
+    /// used by `BalanceOverrides` for strategies that need on-chain reads at
+    /// override-resolution time (e.g. `AaveV3AToken`).
+    pub fn web3(&self) -> &ethrpc::Web3 {
+        &self.web3
+    }
+
+    /// Detects the balance storage slot for `token`.
+    ///
+    /// Takes a fast path for Aave v3 aTokens: a cheap two-call probe, plus
+    /// a single verification using the canonical `_userState` slot — no
+    /// `debug_traceCall` needed on the happy path. Everything else falls
+    /// through to the generic SLOAD-trace detection.
     pub async fn detect(
         &self,
         token: Address,
         holder: Address,
     ) -> Result<Strategy, DetectionError<TransportErrorKind>> {
+        // Aave fast-path. If the token self-identifies as a v3 aToken and
+        // the pool confirms it, try the canonical `_userState` slot
+        // directly — no `debug_traceCall` needed. An Aave v3 fork that
+        // moved `_userState` to a different slot won't verify here and
+        // will fall through to the generic trace-based path, which only
+        // ever returns non-Aave strategies; such a fork needs an explicit
+        // hardcoded config entry.
+        if let Some((pool, underlying)) = aave::probe_aave_token(&self.web3, token).await {
+            let candidate = Strategy::AaveV3AToken {
+                target_contract: token,
+                pool,
+                underlying,
+            };
+            if self
+                .verify_strategy(token, holder, &candidate)
+                .await
+                .is_ok()
+            {
+                tracing::debug!(?token, "detected Aave v3 aToken");
+                return Ok(candidate);
+            }
+            tracing::debug!(
+                ?token,
+                "Aave probe succeeded but canonical slot didn't verify; falling back to trace"
+            );
+        }
+
         let balance_of_call = ERC20::ERC20::balanceOfCall { account: holder };
         let calldata = balance_of_call.abi_encode();
 
@@ -315,6 +353,11 @@ impl Detector {
 
     /// Verifies that a strategy correctly controls the balance by applying it
     /// and checking balanceOf.
+    ///
+    /// For the `AaveV3AToken` variant we allow `balanceOf` to be off by one
+    /// wei, since Aave's ray rounding can slightly differ from our locally
+    /// computed scaled value; for every other variant the check is still an
+    /// exact equality.
     async fn verify_strategy(
         &self,
         token: Address,
@@ -324,8 +367,12 @@ impl Detector {
         // Use a unique test value to verify this strategy works
         let test_balance = U256::from(0x1337_1337_1337_1337_u64);
 
-        // Create state override using the strategy
-        let overrides = strategy.state_override(&holder, &test_balance);
+        let overrides = strategy
+            .state_override(Some(&self.web3), &holder, &test_balance)
+            .await;
+        if overrides.is_empty() {
+            return Err(DetectionError::NotFound);
+        }
 
         // Call balanceOf with the override
         let token_contract = ERC20::Instance::new(token, self.web3.provider.clone());
@@ -340,12 +387,20 @@ impl Detector {
                 )))
             })?;
 
-        // If the balance matches our test value, the strategy works
-        if balance == test_balance {
-            Ok(())
-        } else {
-            Err(DetectionError::NotFound)
-        }
+        verified_balance_matches(strategy, balance, test_balance)
+            .then_some(())
+            .ok_or(DetectionError::NotFound)
+    }
+}
+
+/// Is the `balance` returned by `balanceOf` after applying the override
+/// consistent with the `test_balance` we wrote? For `AaveV3AToken` we tolerate
+/// 1 wei of difference because Aave's ray-div / ray-mul round-trip is not
+/// identity by construction; every other strategy must match exactly.
+fn verified_balance_matches(strategy: &Strategy, balance: U256, test_balance: U256) -> bool {
+    match strategy {
+        Strategy::AaveV3AToken { .. } => balance.abs_diff(test_balance) <= U256::ONE,
+        _ => balance == test_balance,
     }
 }
 
diff --git a/crates/balance-overrides/src/lib.rs b/crates/balance-overrides/src/lib.rs
index 8dcb97e638..03e2754a4a 100644
--- a/crates/balance-overrides/src/lib.rs
+++ b/crates/balance-overrides/src/lib.rs
@@ -1,11 +1,16 @@
+mod aave;
 pub mod detector;
 
 use {
-    self::detector::{DetectionError, Detector},
+    self::{
+        aave::mapping_slot_hash,
+        detector::{DetectionError, Detector},
+    },
     alloy_primitives::{Address, B256, U256, keccak256, map::AddressMap},
     alloy_rpc_types::state::AccountOverride,
     cached::{Cached, SizedCache},
     configs::balance_overrides::Strategy,
+    ethrpc::Web3,
     std::{collections::HashMap, iter, sync::Mutex},
 };
 /// Token configurations for the `BalanceOverriding` component.
@@ -45,36 +50,74 @@ pub struct BalanceOverrideRequest {
     pub amount: U256,
 }
 
+#[async_trait::async_trait]
 trait StrategyExt {
     /// Computes the storage slot and value to override for a particular token
-    /// holder and amount.
-    fn state_override(&self, holder: &Address, amount: &U256) -> AddressMap<AccountOverride>;
+    /// holder and amount. `web3` is only consulted by strategies that need
+    /// on-chain reads at override time (currently `AaveV3AToken`); other
+    /// variants ignore it and complete synchronously.
+    async fn state_override(
+        &self,
+        web3: Option<&Web3>,
+        holder: &Address,
+        amount: &U256,
+    ) -> AddressMap<AccountOverride>;
 
     fn is_valid_for_all_holders(&self) -> bool;
 }
 
+#[async_trait::async_trait]
 impl StrategyExt for Strategy {
-    fn state_override(&self, holder: &Address, amount: &U256) -> AddressMap<AccountOverride> {
+    async fn state_override(
+        &self,
+        web3: Option<&Web3>,
+        holder: &Address,
+        amount: &U256,
+    ) -> AddressMap<AccountOverride> {
         let (target_contract, key) = match self {
             Self::SolidityMapping {
                 target_contract,
                 map_slot,
-            } => {
-                let mut buf = [0; 64];
-                buf[12..32].copy_from_slice(holder.as_slice());
-                buf[32..64].copy_from_slice(&map_slot.to_be_bytes::<32>());
-                (target_contract, keccak256(buf))
-            }
+            } => (
+                *target_contract,
+                mapping_slot_hash(holder, &map_slot.to_be_bytes()),
+            ),
             Self::SoladyMapping { target_contract } => {
                 let mut buf = [0; 32];
                 buf[0..20].copy_from_slice(holder.as_slice());
                 buf[28..32].copy_from_slice(&[0x87, 0xa2, 0x11, 0xa2]);
-                (target_contract, keccak256(buf))
+                (*target_contract, keccak256(buf))
             }
             Self::DirectSlot {
                 target_contract,
                 slot,
-            } => (target_contract, *slot),
+            } => (*target_contract, *slot),
+            Self::AaveV3AToken {
+                target_contract,
+                pool,
+                underlying,
+            } => {
+                let Some(web3) = web3 else {
+                    tracing::warn!(
+                        ?target_contract,
+                        "AaveV3AToken balance override requested but web3 is not configured",
+                    );
+                    return AddressMap::default();
+                };
+                return match aave::build_override(
+                    web3,
+                    *target_contract,
+                    *pool,
+                    *underlying,
+                    *holder,
+                    *amount,
+                )
+                .await
+                {
+                    Some((addr, override_)) => iter::once((addr, override_)).collect(),
+                    None => AddressMap::default(),
+                };
+            }
         };
 
         let state_override = AccountOverride {
@@ -82,11 +125,15 @@ impl StrategyExt for Strategy {
             ..Default::default()
         };
 
-        iter::once((*target_contract, state_override)).collect()
+        iter::once((target_contract, state_override)).collect()
     }
 
     fn is_valid_for_all_holders(&self) -> bool {
-        matches!(self, Self::DirectSlot { .. })
+        // `AaveV3AToken` fields (target, pool, underlying) are all token-level
+        // constants; the slot and value are derived per-holder at override
+        // time. Caching the strategy once per token avoids re-running the
+        // probe for every new `from` address.
+        matches!(self, Self::DirectSlot { .. } | Self::AaveV3AToken { .. })
     }
 }
 
@@ -102,8 +149,17 @@ pub struct BalanceOverrides {
     /// the caching policy.
     pub hardcoded: HashMap<Address, Strategy>,
     /// The balance override detector and its cache. Set to `None` if
-    /// auto-detection is not enabled.
+    /// auto-detection is disabled. The detector internally holds its own
+    /// `Web3` handle for tracing and verification calls.
     pub detector: Option<(Detector, DetectorCache)>,
+    /// `Web3` handle used by strategies that need on-chain reads at
+    /// override-resolution time (currently only `AaveV3AToken`, which
+    /// fetches the live liquidity index from the Aave pool). Kept separate
+    /// from the detector's own web3 so that hardcoded `AaveV3AToken`
+    /// entries still resolve when auto-detection is disabled. Both handles
+    /// typically point at the same underlying `Web3` instance; `Web3` is
+    /// cheaply cloneable, so the double-reference is just two `Arc` bumps.
+    pub web3: Option<Web3>,
 }
 
 impl BalanceOverrides {
@@ -112,9 +168,10 @@ impl BalanceOverrides {
         Self {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(web3, 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
+                Detector::new(web3.clone(), 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
                 Mutex::new(SizedCache::with_size(1000)),
             )),
+            web3: Some(web3),
         }
     }
 
@@ -184,7 +241,8 @@ impl BalanceOverriding for BalanceOverrides {
         }?;
 
         strategy
-            .state_override(&request.holder, &request.amount)
+            .state_override(self.web3.as_ref(), &request.holder, &request.amount)
+            .await
             .into_iter()
             .last()
     }
@@ -208,6 +266,7 @@ impl BalanceOverriding for DummyOverrider {
 mod tests {
     use {
         super::*,
+        crate::aave::{pack_user_state, ray_div},
         alloy_primitives::{address, b256},
         ethrpc::mock,
         maplit::hashmap,
@@ -372,9 +431,14 @@ mod tests {
         let balance_overrides = BalanceOverrides {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(mock_web3, 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
+                Detector::new(
+                    mock_web3.clone(),
+                    60,
+                    detector::DEFAULT_VERIFICATION_TIMEOUT,
+                ),
                 Mutex::new(SizedCache::with_size(100)),
             )),
+            web3: Some(mock_web3),
         };
 
         // Manually populate the cache as if detector found this holder-agnostic
@@ -420,9 +484,14 @@ mod tests {
         let balance_overrides = BalanceOverrides {
             hardcoded: Default::default(),
             detector: Some((
-                Detector::new(mock_web3, 60, detector::DEFAULT_VERIFICATION_TIMEOUT),
+                Detector::new(
+                    mock_web3.clone(),
+                    60,
+                    detector::DEFAULT_VERIFICATION_TIMEOUT,
+                ),
                 Mutex::new(SizedCache::with_size(100)),
             )),
+            web3: Some(mock_web3),
         };
 
         // Manually populate cache with holder-specific strategies
@@ -448,4 +517,132 @@ mod tests {
             Some(strategy_h2)
         );
     }
+
+    #[test]
+    fn ray_div_edge_cases() {
+        let index = U256::from_str_radix("1063000000000000000000000000", 10).unwrap();
+        // 0 / x = 0.
+        assert_eq!(ray_div(U256::ZERO, index).unwrap(), U256::ZERO);
+        // Divide by zero returns None.
+        assert_eq!(
+            ray_div(U256::from(1_000_000_000_000_000_000u128), U256::ZERO),
+            None,
+        );
+    }
+
+    #[test]
+    fn pack_user_state_leaves_additional_data_intact() {
+        let balance = U256::from(0x1234_5678u64);
+        let extra = U256::from(0xabcd_ef01u64);
+        let packed = pack_user_state(balance, extra);
+        let word = U256::from_be_bytes(packed.0);
+
+        let mask = (U256::from(1u64) << 128) - U256::from(1u64);
+        assert_eq!(word & mask, balance);
+        assert_eq!(word >> 128, extra);
+    }
+
+    #[test]
+    fn pack_user_state_truncates_to_uint128() {
+        // A value larger than uint128 should be masked down to its low 128
+        // bits. Using 2^128 + 7 so we can check the wrap visibly.
+        let overflow = (U256::from(1u64) << 128) + U256::from(7u64);
+        let packed = pack_user_state(overflow, U256::ZERO);
+        let word = U256::from_be_bytes(packed.0);
+        assert_eq!(word, U256::from(7u64));
+    }
+
+    #[test]
+    fn mapping_slot_hash_matches_solidity_layout() {
+        // keccak256(pad32(holder) || map_slot) — verified with
+        // `cast keccak $(cast abi-encode "f(address,uint256)" $HOLDER 52)`.
+        let holder = address!("18709E89BD403F470088aBDAcEbE86CC60dda12e");
+        let slot = mapping_slot_hash(&holder, &U256::from(52).to_be_bytes::<32>());
+        assert_eq!(
+            slot,
+            b256!("6785743a4ad9de6e692f819936c9d0b94b199ed36f2660e82404737b769718e5")
+        );
+    }
+
+    #[tokio::test]
+    async fn aave_v3_a_token_override_scales_amount_and_writes_low_128() {
+        use alloy_provider::mock::Asserter;
+
+        // aEthWETH mainnet triple.
+        let a_token = address!("4d5F47FA6A74757f35C14fD3a6Ef8E3C9BC514E8");
+        let pool = address!("87870bca3f3fd6335c3f4ce8392d69350b4fa4e2");
+        let underlying = address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
+        let holder = address!("18709E89BD403F470088aBDAcEbE86CC60dda12e");
+        let amount = U256::from(1_000_000_000_000_000_000u128); // 1 aEthWETH
+
+        let asserter = Asserter::new();
+        // The mock responds to our `eth_call` with the encoded `uint256`
+        // normalized income — a ray value just above 1.063.
+        let index = U256::from_str_radix("1063000000000000000000000000", 10).unwrap();
+        asserter.push_success(&format!("0x{:064x}", index));
+
+        let balance_overrides = BalanceOverrides {
+            hardcoded: hashmap! {
+                a_token => Strategy::AaveV3AToken {
+                    target_contract: a_token,
+                    pool,
+                    underlying,
+                },
+            },
+            detector: None,
+            web3: Some(Web3::with_asserter(asserter)),
+        };
+
+        let (addr, override_) = balance_overrides
+            .state_override(BalanceOverrideRequest {
+                token: a_token,
+                holder,
+                amount,
+            })
+            .await
+            .expect("override computed");
+
+        assert_eq!(addr, a_token);
+
+        let diff = override_.state_diff.expect("state diff present");
+        assert_eq!(diff.len(), 1);
+        let (slot, value) = diff.into_iter().next().unwrap();
+        // Slot is keccak256(holder || 52) — same one used by aEthWETH.
+        assert_eq!(
+            slot,
+            b256!("6785743a4ad9de6e692f819936c9d0b94b199ed36f2660e82404737b769718e5")
+        );
+        // Scaled balance in low 128, zero in high 128 (safe for fresh
+        // holders like the spardose).
+        let word = U256::from_be_bytes(value.0);
+        assert_eq!(word >> 128, U256::ZERO);
+        assert_eq!(word, ray_div(amount, index).unwrap());
+    }
+
+    /// When no detector is configured, there's no `Web3` handle available
+    /// and the `AaveV3AToken` resolver must cleanly fail rather than panic.
+    #[tokio::test]
+    async fn aave_v3_a_token_override_none_without_web3() {
+        let a_token = address!("4d5F47FA6A74757f35C14fD3a6Ef8E3C9BC514E8");
+        let balance_overrides = BalanceOverrides {
+            hardcoded: hashmap! {
+                a_token => Strategy::AaveV3AToken {
+                    target_contract: a_token,
+                    pool: address!("87870bca3f3fd6335c3f4ce8392d69350b4fa4e2"),
+                    underlying: address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"),
+                },
+            },
+            detector: None,
+            web3: None,
+        };
+
+        let result = balance_overrides
+            .state_override(BalanceOverrideRequest {
+                token: a_token,
+                holder: address!("18709E89BD403F470088aBDAcEbE86CC60dda12e"),
+                amount: U256::from(1u64),
+            })
+            .await;
+        assert!(result.is_none());
+    }
 }
diff --git a/crates/configs/src/balance_overrides.rs b/crates/configs/src/balance_overrides.rs
index d8c78b62fa..80140ce10b 100644
--- a/crates/configs/src/balance_overrides.rs
+++ b/crates/configs/src/balance_overrides.rs
@@ -36,6 +36,21 @@ pub enum Strategy {
         target_contract: Address,
         slot: B256,
     },
+    /// Balance override strategy for Aave v3 aTokens whose `balanceOf` applies
+    /// a scaling factor (the reserve's normalized income) and whose storage
+    /// packs `UserState { uint128 balance; uint128 additionalData }` into a
+    /// single slot. The override is resolved at call time by fetching the
+    /// current normalized income from the Aave pool and dividing the target
+    /// amount by it (ray division), so that `balanceOf` returns the desired
+    /// amount. The high 128 bits of the slot (`additionalData`) are zeroed,
+    /// which is safe for fresh holders like the spardose.
+    ///
+    /// Source: <https://github.com/aave-dao/aave-v3-origin/blob/main/src/contracts/protocol/tokenization/base/IncentivizedERC20.sol>
+    AaveV3AToken {
+        target_contract: Address,
+        pool: Address,
+        underlying: Address,
+    },
 }
 
 /// Token configurations for the `BalanceOverriding` component.
@@ -67,6 +82,15 @@ impl std::fmt::Display for TokenConfiguration {
                     target_contract,
                     slot,
                 } => write!(f, "DirectSlot({addr:?}: {target_contract:?}@{slot})"),
+                Strategy::AaveV3AToken {
+                    target_contract,
+                    pool,
+                    underlying,
+                } => write!(
+                    f,
+                    "AaveV3AToken({addr:?}: {target_contract:?}, pool={pool:?}, \
+                     underlying={underlying:?})"
+                ),
             };
 
         let mut entries = self.0.iter();
@@ -192,6 +216,30 @@ target_contract = "0x0000000000000000000000000000000000000005"
         assert!(config.0.is_empty());
     }
 
+    #[test]
+    fn deserialize_aave_v3_a_token() {
+        use alloy::primitives::address;
+
+        let input = r#"
+[0x4d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8]
+type = "AaveV3AToken"
+target_contract = "0x4d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8"
+pool = "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2"
+underlying = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+"#;
+        let config: TokenConfiguration = toml::from_str(input).unwrap();
+        let a_token = address!("4d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8");
+        let strategy = config.0.get(&a_token).unwrap();
+        assert_eq!(
+            *strategy,
+            Strategy::AaveV3AToken {
+                target_contract: a_token,
+                pool: address!("87870bca3f3fd6335c3f4ce8392d69350b4fa4e2"),
+                underlying: address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"),
+            }
+        );
+    }
+
     #[test]
     fn deserialize_unknown_type_fails() {
         let input = r#"
diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs
index bcc5c933fa..a7561b96ad 100644
--- a/crates/e2e/tests/e2e/quote_verification.rs
+++ b/crates/e2e/tests/e2e/quote_verification.rs
@@ -2,8 +2,9 @@ use {
     ::alloy::{
         primitives::{Address, U256, address, map::AddressMap},
         providers::Provider,
+        rpc::types::state::StateOverride,
     },
-    balance_overrides::{BalanceOverrides, BalanceOverriding},
+    balance_overrides::{BalanceOverrideRequest, BalanceOverrides, BalanceOverriding},
     bigdecimal::{BigDecimal, Zero},
     configs::{
         autopilot::Configuration,
@@ -11,6 +12,7 @@ use {
         price_estimation::BalanceOverridesConfig,
         test_util::TestDefault,
     },
+    contracts::ERC20,
     e2e::setup::*,
     ethrpc::{Web3, alloy::CallBuilderExt},
     model::{
@@ -27,7 +29,7 @@ use {
     },
     serde_json::json,
     simulator::swap_simulator::SwapSimulator,
-    std::sync::Arc,
+    std::{collections::HashMap, sync::Arc},
 };
 
 #[tokio::test]
@@ -84,6 +86,44 @@ async fn forked_node_mainnet_usdt_quote() {
     .await;
 }
 
+/// Quote verification for an Aave v3 aToken as the sell token. Exercises
+/// the `AaveV3AToken` strategy end-to-end through `BalanceOverrides`. The
+/// detector is disabled (`detector: None`) to isolate the hardcoded-strategy
+/// path; auto-detection is covered by
+/// `forked_node_mainnet_aave_atoken_detection` below.
+#[tokio::test]
+#[ignore]
+async fn forked_node_mainnet_aave_atoken_quote() {
+    // Fork a block that matches the solver whitelist used for the quotes we
+    // inspected on barn (same day as the debugging session). The default
+    // `FORK_BLOCK_MAINNET` is a few weeks older and can miss newly
+    // whitelisted solvers.
+    const FORK_BLOCK: u64 = 24920000;
+    run_forked_test_with_extra_filters_and_block_number(
+        aave_atoken_quote_verification,
+        std::env::var("FORK_URL_MAINNET")
+            .expect("FORK_URL_MAINNET must be set to run forked tests"),
+        FORK_BLOCK,
+        ["price_estimation=trace", "balance_overrides=trace"],
+    )
+    .await;
+}
+
+/// The auto-detector identifies aEthWETH as a canonical Aave v3 aToken via
+/// the probe + canonical-slot fast-path, returning the right strategy
+/// without running a `debug_traceCall`. This runs in the forked-e2e CI job.
+#[tokio::test]
+#[ignore]
+async fn forked_node_mainnet_aave_atoken_detection() {
+    run_forked_test_with_block_number(
+        aave_atoken_detection,
+        std::env::var("FORK_URL_MAINNET")
+            .expect("FORK_URL_MAINNET must be set to run forked tests"),
+        FORK_BLOCK_MAINNET,
+    )
+    .await;
+}
+
 /// Verified quotes work as expected.
 async fn standard_verified_quote(web3: Web3) {
     tracing::info!("Setting up chain state.");
@@ -716,6 +756,7 @@ async fn trace_based_balance_detection(web3: Web3) {
         let balance_overrides = BalanceOverrides {
             hardcoded: HashMap::from([(token, strategy)]),
             detector: None,
+            web3: None,
         };
 
         let override_result = balance_overrides
@@ -790,3 +831,84 @@ async fn trace_based_balance_detection(web3: Web3) {
     )
     .await;
 }
+
+/// Exercises the `AaveV3AToken` balance override strategy against a real
+/// mainnet fork. We build the override with the forked web3 (so it reads
+/// the live `getReserveNormalizedIncome` from the Aave v3 Pool), then apply
+/// it in an `eth_call` to `aToken.balanceOf(holder)` and assert the
+/// reported balance matches the requested amount within one wei of ray
+/// rounding. This is the property `TradeVerifier` relies on when using
+/// the override to fund the spardose.
+async fn aave_atoken_quote_verification(web3: Web3) {
+    // aEthWETH / WETH / Aave v3 Pool on mainnet.
+    let a_eth_weth = address!("4d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8");
+    let weth = address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
+    let aave_v3_pool = address!("87870bca3f3fd6335c3f4ce8392d69350b4fa4e2");
+    let spardose = address!("0000000000000000000000000000000000020000");
+
+    let hardcoded = HashMap::from([(
+        a_eth_weth,
+        Strategy::AaveV3AToken {
+            target_contract: a_eth_weth,
+            pool: aave_v3_pool,
+            underlying: weth,
+        },
+    )]);
+    let balance_overrides = BalanceOverrides {
+        hardcoded,
+        detector: None,
+        web3: Some(web3.clone()),
+    };
+
+    let amount = 5u64.eth(); // 5 aEthWETH
+
+    let (target, override_) = balance_overrides
+        .state_override(BalanceOverrideRequest {
+            token: a_eth_weth,
+            holder: spardose,
+            amount,
+        })
+        .await
+        .expect("override computed");
+    assert_eq!(target, a_eth_weth);
+
+    // Apply the override to a live `balanceOf` call via the forked node and
+    // make sure the contract now reports the requested amount (± 1 wei of
+    // ray rounding).
+    let overrides: StateOverride = [(target, override_)].into_iter().collect();
+    let a_token_contract = ERC20::Instance::new(a_eth_weth, web3.provider.clone());
+    let reported = a_token_contract
+        .balanceOf(spardose)
+        .state(overrides)
+        .call()
+        .await
+        .unwrap();
+
+    let diff = reported.abs_diff(amount);
+    assert!(
+        diff <= U256::from(1u64),
+        "balanceOf after override returned {reported}, expected ~{amount} (diff {diff} wei)",
+    );
+}
+
+/// Auto-detection against the mainnet fork: the probe + canonical-slot
+/// fast-path must identify aEthWETH as an `AaveV3AToken` without falling
+/// through to `debug_traceCall`.
+async fn aave_atoken_detection(web3: Web3) {
+    use balance_overrides::detector::{DEFAULT_VERIFICATION_TIMEOUT, Detector};
+
+    let detector = Detector::new(web3, 60, DEFAULT_VERIFICATION_TIMEOUT);
+    let a_eth_weth = address!("4d5f47fa6a74757f35c14fd3a6ef8e3c9bc514e8");
+    let strategy = detector
+        .detect(a_eth_weth, Address::with_last_byte(1))
+        .await
+        .unwrap();
+    assert_eq!(
+        strategy,
+        Strategy::AaveV3AToken {
+            target_contract: a_eth_weth,
+            pool: address!("87870bca3f3fd6335c3f4ce8392d69350b4fa4e2"),
+            underlying: address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"),
+        }
+    );
+}
diff --git a/crates/price-estimation/src/config/price_estimation.rs b/crates/price-estimation/src/config/price_estimation.rs
index cf4c409cd5..0f9108d40d 100644
--- a/crates/price-estimation/src/config/price_estimation.rs
+++ b/crates/price-estimation/src/config/price_estimation.rs
@@ -15,13 +15,14 @@ impl BalanceOverridesConfigExt for BalanceOverridesConfig {
             detector: self.autodetect.then(|| {
                 (
                     balance_overrides::detector::Detector::new(
-                        web3,
+                        web3.clone(),
                         self.probing_depth,
                         self.detection_timeout,
                     ),
                     std::sync::Mutex::new(cached::SizedCache::with_size(self.cache_size)),
                 )
             }),
+            web3: Some(web3),
         })
     }
 }
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index 0edb4ff55a..48856753d3 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -408,6 +408,11 @@ impl TradeVerifier {
                 }
             }
             _ => {
+                tracing::warn!(
+                    sell_token = ?query.sell_token,
+                    "could not set spardose balance override for sell token; trade \
+                     verification will rely on the trader's real balance"
+                );
                 if verification.from.is_zero() {
                     anyhow::bail!("trader is zero address and balances can not be faked");
                 }

From ebe8968c970339f69e32bc73941768db4b9975c6 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Wed, 22 Apr 2026 14:37:38 +0100
Subject: [PATCH 213/219] Include block number in logged Tenderly simulation
 command (#4359)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
The Tenderly simulation command logged during quote verification cannot
be replayed as-is: Tenderly rejects it with `Transaction index is not
allowed when block number is pending`. The verifier passed `block: None`
to `log_simulation_command`, which leaves `block_number` null in the
JSON body (Tenderly treats this as pending) while `prepare_request`
still set `transaction_index: -1`, and that combination is invalid. On
top of that, `simulate_swap_with_solver` did not pin `.call()` to a
specific block, so the node picked "latest" at request time and the
logged block could diverge from what was actually simulated.

# Changes
- `simulate_swap_with_solver` now takes the block as a parameter and
pins `.call()` to it. The caller (`trade_verifier`) snapshots
`current_block` once and passes the same value to the simulator and to
`log_simulation_command`, so the gas-price computation, the simulation,
and the logged curl all reference identical chain state.
- `log_simulation_command` and `prepare_request` now require a `BlockNo`
(no longer `Option<BlockNo>`), reflecting that every caller already
supplies one and eliminating the pending-block edge case at the type
level.

# How to test
Existing tests. After deploy, copy the curl command from the
quote-verification log and run it — Tenderly should return a simulation
instead of the validation error, and the result should match the
driver's simulation for that block.
---
 crates/orderbook/src/order_simulator.rs           |  2 +-
 crates/price-estimation/src/trade_verifier/mod.rs |  9 +++++++--
 crates/simulator/src/swap_simulator.rs            | 14 +++++++++++---
 crates/simulator/src/tenderly/mod.rs              | 12 ++++++------
 4 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/crates/orderbook/src/order_simulator.rs b/crates/orderbook/src/order_simulator.rs
index b87fe17936..4dde5e9dc0 100644
--- a/crates/orderbook/src/order_simulator.rs
+++ b/crates/orderbook/src/order_simulator.rs
@@ -176,7 +176,7 @@ impl OrderSimulator {
                 self.chain_id.clone(),
                 &result.tx,
                 result.overrides,
-                Some(BlockNo(block_number)),
+                BlockNo(block_number),
             )
             .map_err(|err| Error::Other(anyhow!(err)))?
         };
diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index 48856753d3..bee0e7356d 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -227,10 +227,15 @@ impl TradeVerifier {
                 &self.simulator.domain_separator,
             )?);
         }
-        let output = self.simulator.simulate_swap_with_solver(swap).await?;
+        let block = *self.simulator.current_block.borrow();
+        let output = self
+            .simulator
+            .simulate_swap_with_solver(swap, block)
+            .await?;
 
         if let Some(tenderly) = &self.tenderly
-            && let Err(err) = tenderly.log_simulation_command(output.tx, output.overrides, None)
+            && let Err(err) =
+                tenderly.log_simulation_command(output.tx, output.overrides, block.number.into())
         {
             tracing::debug!(?err, "could not log tenderly simulation command");
         }
diff --git a/crates/simulator/src/swap_simulator.rs b/crates/simulator/src/swap_simulator.rs
index e7c5a81f08..bf0b9f840d 100644
--- a/crates/simulator/src/swap_simulator.rs
+++ b/crates/simulator/src/swap_simulator.rs
@@ -19,7 +19,10 @@ use {
         support::Solver::{self, Solver::swapReturn},
     },
     eth_domain_types::NonZeroU256,
-    ethrpc::{Web3, block_stream::CurrentBlockWatcher},
+    ethrpc::{
+        Web3,
+        block_stream::{BlockInfo, CurrentBlockWatcher},
+    },
     model::{
         DomainSeparator,
         order::{BUY_ETH_ADDRESS, BuyTokenDestination, OrderData, OrderKind, SellTokenSource},
@@ -192,12 +195,16 @@ impl SwapSimulator {
     /// Simulates a solver call to settlement contract with the provided swap
     /// data. The swap call result is contained in the returned
     /// SwapSimulation struct, along with the original TransactionRequest
-    /// and State overrides (if needed to be logged, or processed elsewhere)
+    /// and State overrides (if needed to be logged, or processed elsewhere).
+    ///
+    /// The caller supplies the `block` so the gas-price computation, the
+    /// pinned `.call()` block, and any downstream logging all reference the
+    /// same snapshot of chain state.
     pub async fn simulate_swap_with_solver(
         &self,
         swap: EncodedSwap,
+        block: BlockInfo,
     ) -> Result<SwapSimulation<swapReturn>> {
-        let block = *self.current_block.borrow();
         let (settlement_target, calldata) = self.get_target_and_calldata(&swap);
         let solver = Solver::Instance::new(swap.solver, self.web3.provider.clone());
         let overrides = swap.overrides;
@@ -224,6 +231,7 @@ impl SwapSimulator {
         let result = swap
             .call()
             .overrides(overrides.clone())
+            .block(block.number.into())
             .await
             .map_err(|err| anyhow!(err))
             .context("failed to simulate swap");
diff --git a/crates/simulator/src/tenderly/mod.rs b/crates/simulator/src/tenderly/mod.rs
index fe6c55d66d..a60e8be629 100644
--- a/crates/simulator/src/tenderly/mod.rs
+++ b/crates/simulator/src/tenderly/mod.rs
@@ -45,7 +45,7 @@ pub trait Api: Send + Sync + 'static {
         &self,
         tx: TransactionRequest,
         overrides: StateOverride,
-        block: Option<BlockNo>,
+        block: BlockNo,
     ) -> Result<()>;
 
     async fn simulate(&self, request: dto::Request) -> Result<dto::Response>;
@@ -85,7 +85,7 @@ impl Tenderly {
                 self.eth.chain().id().to_string(),
                 &tx,
                 Default::default(),
-                Some(block),
+                block,
             )?
         };
 
@@ -162,7 +162,7 @@ impl Api for TenderlyApi {
         &self,
         tx: TransactionRequest,
         overrides: StateOverride,
-        block: Option<BlockNo>,
+        block: BlockNo,
     ) -> Result<()> {
         let request = dto::Request {
             save: Some(true),
@@ -215,10 +215,10 @@ pub fn prepare_request(
     chain_id: String,
     tx: &TransactionRequest,
     overrides: StateOverride,
-    block: Option<BlockNo>,
+    block: BlockNo,
 ) -> Result<dto::Request, Error> {
     Ok(dto::Request {
-        block_number: block.map(|block| block.0),
+        block_number: Some(block.0),
         // By default, tenderly simulates on the top of the specified block, whereas regular
         // nodes simulate at the end of the specified block. This is to make
         // simulation results match in case critical state changed within the block.
@@ -319,7 +319,7 @@ impl Api for Instrumented {
         &self,
         tx: TransactionRequest,
         overrides: StateOverride,
-        block: Option<BlockNo>,
+        block: BlockNo,
     ) -> Result<()> {
         self.inner.log_simulation_command(tx, overrides, block)
     }

From 11bbbb7740af626a73c34f0e11a1e15b94491c17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Duarte?=
 <15343819+jmg-duarte@users.noreply.github.com>
Date: Thu, 23 Apr 2026 18:00:01 +0100
Subject: [PATCH 214/219] Fix EIP-4626 contract revert classification (#4360)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

# Description
Testing the Euler vault tokens I found that the revert condition is a
bit too strict for the Eip4626 purposes and it would think that the
underlying asset was *not* valid because `asset()` failed; even though
that's the expected behavior.

This PR adds a new condition for a revert caused by a lack of selector,
specifically for this case.

Tested in staging, results can be seen in —
https://victorialogs.dev.cow.fi/goto/ffjuyxx1tk6psc?orgId=1
native_price requests were done for
`0x53afe3343f322c4189ab69e0d048efd154259419`

# Changes

* More logs, helps tracing through the layer peeling
* Less strict variant of is_contract_error, including empty reverts as
contract errors

## How to test
Call the native_price endpoint with a Euler vault address (ensure that
staging has them enabled)
---
 crates/e2e/tests/e2e/eip4626.rs               | 50 +++++++++++++
 crates/ethrpc/src/alloy/errors.rs             | 73 ++++++++++++++++++-
 crates/price-estimation/src/native/eip4626.rs | 14 +++-
 3 files changed, 129 insertions(+), 8 deletions(-)

diff --git a/crates/e2e/tests/e2e/eip4626.rs b/crates/e2e/tests/e2e/eip4626.rs
index fd7fef837e..cfcb2c5607 100644
--- a/crates/e2e/tests/e2e/eip4626.rs
+++ b/crates/e2e/tests/e2e/eip4626.rs
@@ -11,9 +11,15 @@ use {
     contracts::ERC20,
     e2e::setup::*,
     ethrpc::alloy::CallBuilderExt,
+    futures::{FutureExt, future::BoxFuture},
     model::quote::{OrderQuoteRequest, OrderQuoteSide, SellAmount},
     number::units::EthUnit,
+    price_estimation::{
+        HEALTHY_PRICE_ESTIMATION_TIME,
+        native::{Eip4626, NativePriceEstimateResult, NativePriceEstimating},
+    },
     shared::web3::Web3,
+    std::time::Duration,
 };
 
 /// The block number from which we will fetch state for the forked test.
@@ -28,6 +34,10 @@ const SDAI_WHALE: Address = address!("4C612E3B15b96Ff9A6faED838F8d07d479a8dD4c")
 /// WETH on mainnet.
 const WETH: Address = address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
 
+/// USDC on mainnet. The proxy has no `asset()` selector, so calls to it
+/// revert with *empty* revert data — the regression case below.
+const USDC: Address = address!("A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+
 #[tokio::test]
 #[ignore]
 async fn forked_node_mainnet_eip4626_native_price() {
@@ -234,3 +244,43 @@ async fn eip4626_recursive_native_price_test(web3: Web3) {
         "wrapper (1/3) price ratio to baseline (3/2) should be 2/9: got {ratio:.6}",
     );
 }
+
+/// Regression: tokens that revert `asset()` with empty data (e.g. USDC) must
+/// classify as non-vault, not abort as a transport failure.
+#[tokio::test]
+#[ignore]
+async fn forked_node_mainnet_eip4626_empty_revert_terminal_token() {
+    run_forked_test_with_block_number(
+        eip4626_empty_revert_terminal_token_test,
+        std::env::var("FORK_URL_MAINNET")
+            .expect("FORK_URL_MAINNET must be set to run forked tests"),
+        FORK_BLOCK_MAINNET,
+    )
+    .await;
+}
+
+async fn eip4626_empty_revert_terminal_token_test(web3: Web3) {
+    // USDC is expected to classify as non-vault, so `inner`'s price round-trips
+    // unchanged — any fixed value works.
+    let expected_price = 0.0001;
+    let inner = FixedPrice(expected_price);
+    let estimator = Eip4626::new(Box::new(inner), web3.provider);
+    let price = estimator
+        .estimate_native_price(USDC, HEALTHY_PRICE_ESTIMATION_TIME)
+        .await
+        .expect("empty-revert on terminal token must not abort the unwrap");
+    assert_eq!(price, expected_price);
+}
+
+struct FixedPrice(f64);
+
+impl NativePriceEstimating for FixedPrice {
+    fn estimate_native_price(
+        &self,
+        _token: Address,
+        _timeout: Duration,
+    ) -> BoxFuture<'_, NativePriceEstimateResult> {
+        let price = self.0;
+        async move { Ok(price) }.boxed()
+    }
+}
diff --git a/crates/ethrpc/src/alloy/errors.rs b/crates/ethrpc/src/alloy/errors.rs
index a469049983..0093c50b74 100644
--- a/crates/ethrpc/src/alloy/errors.rs
+++ b/crates/ethrpc/src/alloy/errors.rs
@@ -16,6 +16,12 @@ pub trait ContractErrorExt {
 
     /// Returns whether a given error is a node error.
     fn is_node_error(&self) -> bool;
+
+    /// Contract-level rejection of the call: an explicit revert (including
+    /// empty-data reverts from missing selectors, which [`is_contract_error`]
+    /// misses) or a `0x` response. Transport failures and caller-side bugs
+    /// return `false` so they keep bubbling up for retry.
+    fn is_contract_revert(&self) -> bool;
 }
 
 impl ContractErrorExt for ContractError {
@@ -50,6 +56,25 @@ impl ContractErrorExt for ContractError {
             _ => false,
         }
     }
+
+    fn is_contract_revert(&self) -> bool {
+        match self {
+            // Revert data, geth code 3, or a "revert" message — any is a
+            // contract-level rejection. Other ErrorResps (rate limits,
+            // bad params) are transport and must retry.
+            ContractError::TransportError(RpcError::ErrorResp(err)) => {
+                err.as_revert_data().is_some()
+                    // https://github.com/ethereum/go-ethereum/blob/8e2107dc39dc9dab132150ec915e7ac299f9eb48/internal/ethapi/errors.go#L42-L46
+                    // https://github.com/alloy-rs/alloy/blob/b6753088241a50730c092bdba7036f52887c4c57/crates/rpc-types-eth/src/error.rs#L32
+                    || err.code == 3
+                    || err.message.to_lowercase().contains("revert")
+            }
+            ContractError::ZeroData(..)
+            | ContractError::UnknownFunction(..)
+            | ContractError::UnknownSelector(..) => true,
+            _ => false,
+        }
+    }
 }
 
 /// Create an arbitrary alloy error that will convert into a "contract" error.
@@ -70,12 +95,25 @@ pub fn testing_alloy_node_error() -> alloy_contract::Error {
 
 #[cfg(test)]
 mod tests {
-    use crate::alloy::errors::{
-        ContractErrorExt,
-        testing_alloy_contract_error,
-        testing_alloy_node_error,
+    use {
+        crate::alloy::errors::{
+            ContractErrorExt,
+            testing_alloy_contract_error,
+            testing_alloy_node_error,
+        },
+        alloy_contract::Error as ContractError,
+        alloy_json_rpc::ErrorPayload,
+        alloy_transport::TransportError,
     };
 
+    fn error_resp(code: i64, message: &'static str) -> ContractError {
+        ContractError::TransportError(TransportError::ErrorResp(ErrorPayload {
+            code,
+            message: message.into(),
+            data: None,
+        }))
+    }
+
     #[test]
     fn test_contract_error() {
         assert!(testing_alloy_contract_error().is_contract_error());
@@ -87,4 +125,31 @@ mod tests {
         assert!(!testing_alloy_contract_error().is_node_error());
         assert!(testing_alloy_node_error().is_node_error());
     }
+
+    #[test]
+    fn contract_revert_accepts_empty_data_reverts() {
+        // Geth-family "execution reverted" with no data — the USDC case.
+        assert!(error_resp(3, "execution reverted").is_contract_revert());
+        // Non-standard code but unmistakable message.
+        assert!(error_resp(-32000, "execution reverted at pc=...").is_contract_revert());
+        assert!(error_resp(-32000, "VM Exception: revert").is_contract_revert());
+        // Case-insensitive: capitalized node messages still match.
+        assert!(error_resp(-32000, "Execution Reverted").is_contract_revert());
+    }
+
+    #[test]
+    fn contract_revert_rejects_transport_failures() {
+        // Generic internal error without revert context — likely transport.
+        assert!(!testing_alloy_node_error().is_contract_revert());
+        // Rate-limit-like codes without a revert message.
+        assert!(!error_resp(429, "too many requests").is_contract_revert());
+        assert!(!error_resp(-32005, "daily request count exceeded").is_contract_revert());
+    }
+
+    #[test]
+    fn contract_revert_rejects_caller_usage_bugs() {
+        // `NotADeploymentTransaction` and siblings are local-usage errors,
+        // not contract behaviour — must not be classified as reverts.
+        assert!(!testing_alloy_contract_error().is_contract_revert());
+    }
 }
diff --git a/crates/price-estimation/src/native/eip4626.rs b/crates/price-estimation/src/native/eip4626.rs
index 7493294ad7..802380c45e 100644
--- a/crates/price-estimation/src/native/eip4626.rs
+++ b/crates/price-estimation/src/native/eip4626.rs
@@ -57,7 +57,9 @@ impl Eip4626 {
             .inner
             .estimate_native_price(underlying, remaining)
             .await?;
-        Ok(asset_price * cumulative_rate)
+        let estimate = asset_price * cumulative_rate;
+        tracing::debug!(%token, estimate, "eip4626: estimated native price");
+        Ok(estimate)
     }
 
     /// Follows the vault chain (e.g. vault → vault → asset) until reaching a
@@ -86,12 +88,14 @@ impl Eip4626 {
         token: Address,
     ) -> Result<Option<(Address, f64)>, PriceEstimationError> {
         if self.non_vault_tokens.contains(&token) {
+            tracing::debug!(%token, "eip4626: cached non-vault, stop unwrapping");
             return Ok(None);
         }
 
         let Some((asset, vault_decimals)) = self.fetch_vault_info(token).await? else {
             self.non_vault_tokens.insert(token);
             metrics::non_vault_cache_size(self.non_vault_tokens.len());
+            tracing::debug!(%token, "eip4626: classified as non-vault");
             return Ok(None);
         };
         let (assets, asset_decimals) = self
@@ -100,6 +104,7 @@ impl Eip4626 {
         let rate = conversion_rate(assets, asset_decimals)
             .context("conversion rate is not representable as f64")
             .map_err(PriceEstimationError::EstimatorInternal)?;
+        tracing::debug!(%token, %asset, rate, "eip4626: unwrapped vault layer");
         Ok(Some((asset, rate)))
     }
 
@@ -130,9 +135,10 @@ impl Eip4626 {
                 })?;
                 Ok(Some((asset, vault_decimals)))
             }
-            // `asset()` reverted but the contract is a valid ERC-20 (decimals()
-            // succeeded). Classify as non-vault.
-            Err(err) if err.is_contract_error() && decimals_result.is_ok() => Ok(None),
+            // Contract-level revert on `asset()` + working `decimals()` =
+            // plain ERC-20. Transient transport failures propagate so they
+            // retry instead of pinning the token as non-vault.
+            Err(err) if err.is_contract_revert() && decimals_result.is_ok() => Ok(None),
             Err(err) => Err(PriceEstimationError::EstimatorInternal(anyhow::anyhow!(
                 "failed to call asset() on {token}: {err}"
             ))),

From f58cbda38b5fbaeb7d3fa3e13618ccdd727ac4a5 Mon Sep 17 00:00:00 2001
From: Martin Magnus <martin.beckmann@protonmail.com>
Date: Fri, 24 Apr 2026 07:32:17 +0000
Subject: [PATCH 215/219] Add uni v3 defaults on gnosis chain (#4350)

# Description
By now there is an official uniswap v3 deployment on gnosis chain so we
can now add all the default values. Values were taken from
[here](https://gov.uniswap.org/t/official-uniswap-v3-deployments-list/24323/3#p-53385-gnosis-7).
Note, that uniswap v3 so far was manually configured in the driver but
having defaults for all those contracts is just nicer.

This issue was surfaced by @daveai on slack.

# Changes
- added addresses for router, quoter, and factory
    - also re-generated the rust code
- added uni v3 to list of default liquidity sources (this is actually
not used anymore and should be removed but since it makes more sense to
delete it in a follow up PR it seemed proper to still add the value for
gnosis to not leave the code base in an inconsistent state - it's just 1
line anyway)
---
 .../contracts-generated/iuniswapv3factory/src/lib.rs          | 4 ++++
 .../contracts-generated/uniswapv3quoterv2/src/lib.rs          | 4 ++++
 .../contracts-generated/uniswapv3swaprouterv2/src/lib.rs      | 4 ++++
 contracts/src/main.rs                                         | 3 +++
 crates/liquidity-sources/src/lib.rs                           | 1 +
 5 files changed, 16 insertions(+)

diff --git a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
index 9bcf2a8c65..b2a65a95e4 100644
--- a/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
+++ b/contracts/generated/contracts-generated/iuniswapv3factory/src/lib.rs
@@ -1313,6 +1313,10 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7"),
             None,
         )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xe32F7dD7e3f098D518ff19A22d5f028e076489B1"),
+            None,
+        )),
         137u64 => Some((
             ::alloy_primitives::address!("0x1F98431c8aD98523631AE4a59f267346ea31F984"),
             None,
diff --git a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
index 79d6ecd088..075674a2bc 100644
--- a/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv3quoterv2/src/lib.rs
@@ -2654,6 +2654,10 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0x78D78E420Da98ad378D7799bE8f4AF69033EB077"),
             None,
         )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0x7E9cB3499A6cee3baBe5c8a3D328EA7FD36578f4"),
+            None,
+        )),
         137u64 => Some((
             ::alloy_primitives::address!("0x61fFE014bA17989E743c5F6cB21bF9697530B21e"),
             None,
diff --git a/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
index 0bb24e41c1..677099792b 100644
--- a/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
+++ b/contracts/generated/contracts-generated/uniswapv3swaprouterv2/src/lib.rs
@@ -1011,6 +1011,10 @@ pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
             ::alloy_primitives::address!("0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2"),
             None,
         )),
+        100u64 => Some((
+            ::alloy_primitives::address!("0xc6D25285D5C5b62b7ca26D6092751A145D50e9Be"),
+            None,
+        )),
         137u64 => Some((
             ::alloy_primitives::address!("0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"),
             None,
diff --git a/contracts/src/main.rs b/contracts/src/main.rs
index 61962946fe..b031174ca3 100644
--- a/contracts/src/main.rs
+++ b/contracts/src/main.rs
@@ -327,6 +327,7 @@ fn build_module() -> Module {
         .add_contract(Contract::new("UniswapV3Pool"))
         .add_contract(Contract::new("UniswapV3QuoterV2").with_networks(networks![
             MAINNET => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+            GNOSIS => "0x7E9cB3499A6cee3baBe5c8a3D328EA7FD36578f4",
             ARBITRUM_ONE => "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
             BASE => "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
             AVALANCHE => "0xbe0F5544EC67e9B3b2D979aaA43f18Fd87E6257F",
@@ -341,6 +342,7 @@ fn build_module() -> Module {
             Contract::new("UniswapV3SwapRouterV2").with_networks(networks![
                 ARBITRUM_ONE => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
                 MAINNET => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+                GNOSIS => "0xc6D25285D5C5b62b7ca26D6092751A145D50e9Be",
                 POLYGON => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
                 OPTIMISM => "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
                 BASE => "0x2626664c2603336E57B271c5C0b26F421741e481",
@@ -353,6 +355,7 @@ fn build_module() -> Module {
         )
         .add_contract(Contract::new("IUniswapV3Factory").with_networks(networks![
             MAINNET => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            GNOSIS => "0xe32F7dD7e3f098D518ff19A22d5f028e076489B1",
             SEPOLIA => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
             ARBITRUM_ONE => "0x1F98431c8aD98523631AE4a59f267346ea31F984",
             BASE => "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
diff --git a/crates/liquidity-sources/src/lib.rs b/crates/liquidity-sources/src/lib.rs
index 62a89b5d10..f05e472af2 100644
--- a/crates/liquidity-sources/src/lib.rs
+++ b/crates/liquidity-sources/src/lib.rs
@@ -49,6 +49,7 @@ pub fn defaults_for_network(chain: &Chain) -> Vec<BaselineSource> {
             BaselineSource::SushiSwap,
             BaselineSource::Baoswap,
             BaselineSource::Swapr,
+            BaselineSource::UniswapV3,
         ],
         Chain::ArbitrumOne => vec![
             BaselineSource::UniswapV2,

From 3cda241363d2923120ca0c9c40c2d1eb099238e8 Mon Sep 17 00:00:00 2001
From: ilya <ilya@cow.fi>
Date: Fri, 24 Apr 2026 10:29:14 +0100
Subject: [PATCH 216/219] Overshoot Spardose fake balance by 1% (#4362)

# Problem

Quote verification for small aToken sell amounts intermittently failed
in prod with `execution reverted: trader does not have enough sell
token`: [0.1 aEthWETH
quote](https://victorialogs.dev.cow.fi/explore?schemaVersion=1&panes=%7B%22vdl%22%3A%7B%22datasource%22%3A%22vm-auth-prod%22%2C%22queries%22%3A%5B%7B%22refId%22%3A%22A%22%2C%22datasource%22%3A%7B%22type%22%3A%22victoriametrics-logs-datasource%22%2C%22uid%22%3A%22vm-auth-prod%22%7D%2C%22editorMode%22%3A%22code%22%2C%22expr%22%3A%22container%3A%21controller%20AND%20network%3Amainnet%20AND%20all%3A40880b4ceb2f4dbe7a25aa1877279ddd%22%2C%22queryType%22%3A%22range%22%7D%5D%2C%22range%22%3A%7B%22from%22%3A%221776965400000%22%2C%22to%22%3A%221776965700000%22%7D%2C%22panelsState%22%3A%7B%22logs%22%3A%7B%22visualisationType%22%3A%22logs%22%7D%7D%2C%22compact%22%3Afalse%7D%7D&orgId=1)
failed, [1 aEthWETH
quote](https://victorialogs.dev.cow.fi/explore?schemaVersion=1&panes=%7B%22vdl%22%3A%7B%22datasource%22%3A%22vm-auth-prod%22%2C%22queries%22%3A%5B%7B%22refId%22%3A%22A%22%2C%22datasource%22%3A%7B%22type%22%3A%22victoriametrics-logs-datasource%22%2C%22uid%22%3A%22vm-auth-prod%22%7D%2C%22editorMode%22%3A%22code%22%2C%22expr%22%3A%22container%3A%21controller%20AND%20network%3Amainnet%20AND%20all%3A98c568a44d1b6ce7ea068648fdfc7c94%22%2C%22queryType%22%3A%22range%22%7D%5D%2C%22range%22%3A%7B%22from%22%3A%221776965400000%22%2C%22to%22%3A%221776965700000%22%7D%2C%22panelsState%22%3A%7B%22logs%22%3A%7B%22visualisationType%22%3A%22logs%22%7D%7D%2C%22compact%22%3Afalse%7D%7D&orgId=1)
minutes earlier passed.

aToken does not store a balance directly. It stores a deposit and a
growth factor, where `balanceOf() = deposit * growth_factor`. The factor
ticks up every second as interest accrues.

Quote verification writes a fake deposit into the Spardose (our donor
contract) so the sim can pretend the trader has funds. The old code
sized the fake deposit from a pre-sim `getReserveNormalizedIncome` RPC
read. The sim then re-read the growth factor inside the EVM at its own
pinned block. Those two reads can disagree by one block, leaving the
Spardose's `balanceOf` one wei below `amount` when it tries to fund the
trader. Aave's internal scaled-balance subtraction underflows, revert.

The same kind of boundary issue could in principle hit other tokens
(rebasing, tiny fee-on-transfer, future weird ones).

# Fix

Bump the Spardose's fake balance by 1% before passing it to the
override:

```
spardose_amount = needed + needed / 100
```

Spardose ends up slightly richer than the sim will ever transfer. Any
rounding, accrual, or per-block drift is absorbed by the buffer. The
Spardose is a throwaway donor, overshoot costs nothing: no gas
difference, no side effects, only the trader-requested `amount` actually
moves.

Generic by construction. Fixes aToken and covers any future token with
similar near-boundary math.

# Context

Supersedes #4361, which took an Aave-specific approach (scale against
the stored `liquidityIndex` instead of the accrued one). Replaced with
this generic overshoot per [Martin's
review](https://github.com/cowprotocol/services/pull/4361#pullrequestreview-4168763147).

# Changes

- `price-estimation/trade_verifier`: 1% overshoot on the amount passed
to the Spardose balance override.
- Unit test covering the overshoot helper.

# How to test

`cargo test -p price-estimation trade_verifier`. Existing tests pass
plus the new `spardose_amount_applies_1pct_overshoot`.
---
 .../src/trade_verifier/mod.rs                 | 49 +++++++++++++++----
 1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/crates/price-estimation/src/trade_verifier/mod.rs b/crates/price-estimation/src/trade_verifier/mod.rs
index bee0e7356d..2bca6404e5 100644
--- a/crates/price-estimation/src/trade_verifier/mod.rs
+++ b/crates/price-estimation/src/trade_verifier/mod.rs
@@ -383,20 +383,21 @@ impl TradeVerifier {
         // not alter solver balances which may be used during settlement. We use
         // a similar strategy for determining whether or not to set approvals on
         // behalf of the trader.
+        let needed = match query.kind {
+            OrderKind::Sell => query.in_amount.get(),
+            OrderKind::Buy => trade.out_amount(
+                &query.buy_token,
+                &query.sell_token,
+                &query.in_amount.get(),
+                &query.kind,
+            )?,
+        };
         match self
             .balance_overrides
             .state_override(BalanceOverrideRequest {
                 token: query.sell_token,
                 holder: Self::SPARDOSE,
-                amount: match query.kind {
-                    OrderKind::Sell => query.in_amount.get(),
-                    OrderKind::Buy => trade.out_amount(
-                        &query.buy_token,
-                        &query.sell_token,
-                        &query.in_amount.get(),
-                        &query.kind,
-                    )?,
-                },
+                amount: spardose_amount_with_buffer(needed),
             })
             .await
         {
@@ -852,10 +853,40 @@ enum Error {
     SimulationFailed(#[from] anyhow::Error),
 }
 
+/// Spardose gets `needed` plus a 1% headroom, floored at 1 wei so the
+/// 1-wei boundary is still covered for small amounts where `needed / 100`
+/// truncates to 0. The buffer absorbs rounding or per-block accrual
+/// (aToken, rebasing, tiny fee-on-transfer) between our state_override
+/// read and the sim's execution. Spardose is a throwaway donor, so
+/// overshoot has no cost.
+fn spardose_amount_with_buffer(needed: U256) -> U256 {
+    let buffer = std::cmp::max(U256::ONE, needed / U256::from(100u64));
+    needed.saturating_add(buffer)
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, U256, maplit::hashmap, std::str::FromStr};
 
+    #[test]
+    fn spardose_amount_applies_1pct_overshoot() {
+        assert_eq!(
+            spardose_amount_with_buffer(U256::from(1_000_000_000_000_000_000u128)),
+            U256::from(1_010_000_000_000_000_000u128)
+        );
+        // Amounts below 100 still get at least 1 wei of headroom, so the
+        // boundary stays covered when integer division would otherwise
+        // round the 1% buffer to 0.
+        assert_eq!(
+            spardose_amount_with_buffer(U256::from(99u64)),
+            U256::from(100u64)
+        );
+        assert_eq!(spardose_amount_with_buffer(U256::ONE), U256::from(2u64));
+        assert_eq!(spardose_amount_with_buffer(U256::ZERO), U256::ONE);
+        // Saturates at U256::MAX instead of overflowing.
+        assert_eq!(spardose_amount_with_buffer(U256::MAX), U256::MAX);
+    }
+
     #[test]
     fn discards_inaccurate_quotes() {
         // let's use 0.5 as the base case to avoid rounding issues introduced by float

From 1ca655670a0d923833a5880059a9ba336cec36c6 Mon Sep 17 00:00:00 2001
From: "Jan [Yann]" <4518474+fafk@users.noreply.github.com>
Date: Fri, 24 Apr 2026 14:47:25 +0200
Subject: [PATCH 217/219] Propose multiple winning solutions in the driver
 (#4267)

# Description

The driver currently proposes only the single highest-scoring solution
to the autopilot. With EIP-7702 parallel submission in place, the
autopilot's combinatorial auction can now benefit from receiving all
valid solutions from a driver to find the optimal set of winners.

# Changes

[x] Driver's solve() now returns Vec<Solved> instead of Option<Solved>
with all valid solutions sorted best-first
[x] Block re-simulation loop now monitors all proposed solutions
individually, voiding only those that revert
[x] New per-solver config flag propose-all-solutions (default: false)
keeps existing behavior until EIP-7702 infrastructure is ready

## How to test

```
cargo nextest run -p driver --test-threads 1 --run-ignored ignored-only -E 'test(multiple_solutions)'
```

To enable in production, add to the solver config:
`propose-all-solutions = true` (requires submission-accounts to also be
configured along with the forwarder contract).
---
 crates/driver/src/domain/competition/mod.rs   | 167 +++++++++++-------
 .../api/routes/solve/dto/solve_response.rs    |   2 +-
 crates/driver/src/infra/config/file/load.rs   |   1 +
 crates/driver/src/infra/config/file/mod.rs    |  13 +-
 crates/driver/src/infra/observe/mod.rs        |  16 +-
 crates/driver/src/infra/solver/eip7702.rs     |  33 +++-
 crates/driver/src/infra/solver/mod.rs         |   7 +
 .../src/tests/cases/multiple_solutions.rs     | 102 ++++++++++-
 crates/driver/src/tests/setup/driver.rs       |  11 ++
 crates/driver/src/tests/setup/mod.rs          |  23 ++-
 10 files changed, 296 insertions(+), 79 deletions(-)

diff --git a/crates/driver/src/domain/competition/mod.rs b/crates/driver/src/domain/competition/mod.rs
index bbb905dc74..864dbf39dc 100644
--- a/crates/driver/src/domain/competition/mod.rs
+++ b/crates/driver/src/domain/competition/mod.rs
@@ -46,12 +46,19 @@ pub mod sorting;
 use {
     crate::infra::notify::liquidity_sources::LiquiditySourceNotifying,
     eth_domain_types::BlockNo,
+    ethrpc::block_stream::BlockInfo,
 };
 pub use {auction::Auction, order::Order, pre_processing::DataAggregator, solution::Solution};
 
 type BalanceGroup = (order::Trader, eth::TokenAddress, order::SellTokenBalance);
 type Balances = HashMap<BalanceGroup, order::SellAmount>;
 
+/// How many concurrent auction generations we size the settlement cache for.
+/// Each auction can propose up to `max_solutions_to_propose` settlements;
+/// keeping this many generations around lets a stale /settle for a previous
+/// auction still find its settlement.
+const MAX_CONCURRENT_AUCTIONS: usize = 5;
+
 /// An ongoing competition. There is one competition going on per solver at any
 /// time. The competition stores settlements to solutions generated by the
 /// driver, and allows them to be executed onchain when requested later. The
@@ -304,7 +311,7 @@ impl Competition {
     }
 
     /// Solve an auction as part of this competition.
-    pub async fn solve(&self, request: Request<Body>) -> Result<Option<Solved>, Error> {
+    pub async fn solve(&self, request: Request<Body>) -> Result<Vec<Solved>, Error> {
         let start = Instant::now();
         let timer = ::observe::metrics::metrics()
             .on_auction_overhead_start("driver", "pre_processing_total");
@@ -365,7 +372,7 @@ impl Competition {
 
         if auction.orders.is_empty() {
             tracing::info!("no orders left after pre-processing; skipping solving");
-            return Ok(None);
+            return Ok(vec![]);
         }
 
         let auction = &auction;
@@ -519,76 +526,116 @@ impl Competition {
             observe::score(settlement, score);
         }
 
-        // Pick the best-scoring settlement.
-        let (mut score, settlement) = scores
+        // Build scored settlements sorted best-first.
+        let scored: Vec<(Solved, Settlement)> = scores
             .into_iter()
-            .max_by_key(|(score, _)| score.to_owned())
+            .sorted_by_key(|(score, _)| Reverse(*score))
             .map(|(score, settlement)| {
-                (
-                    Solved {
-                        id: settlement.solution().clone(),
-                        score,
-                        trades: settlement.orders(),
-                        prices: settlement.prices(),
-                        gas: Some(settlement.gas.estimate),
-                    },
-                    settlement,
-                )
+                let solved = Solved {
+                    id: settlement.solution().clone(),
+                    score,
+                    trades: settlement.orders(),
+                    prices: settlement.prices(),
+                    gas: Some(settlement.gas.estimate),
+                };
+                (solved, settlement)
             })
-            .unzip();
+            .collect();
 
-        let Some(settlement) = settlement else {
-            // Don't wait for the deadline because we can't produce a solution anyway.
-            return Ok(score);
-        };
-        let solution_id = settlement.solution().get();
+        if scored.is_empty() {
+            return Ok(vec![]);
+        }
 
+        let max_to_propose = self.solver.max_solutions_to_propose();
+        let mut scored: Vec<(Solved, Settlement)> =
+            scored.into_iter().take(max_to_propose).collect();
+
+        // Cache all settlements so they can be revealed/settled later. Keep
+        // solutions from previous overlapping auctions around long enough
+        // for their /settle to complete.
         {
             let mut lock = self.settlements.lock().unwrap();
-            lock.push_front(settlement.clone());
-
-            /// Number of solutions that may be cached at most.
-            const MAX_SOLUTION_STORAGE: usize = 5;
-            lock.truncate(MAX_SOLUTION_STORAGE);
+            for (_, settlement) in &scored {
+                lock.push_front(settlement.clone());
+            }
+            lock.truncate(max_to_propose * MAX_CONCURRENT_AUCTIONS);
         }
 
-        // Re-simulate the solution on every new block until the deadline ends to make
-        // sure we actually submit a working solution close to when the winner
-        // gets picked by the procotol.
         if let Ok(remaining) = deadline.remaining() {
-            let score_ref = &mut score;
-            let has_haircut = settlement.has_haircut();
-            let simulate_on_new_blocks = async move {
-                let mut stream =
-                    ethrpc::block_stream::into_stream(self.eth.current_block().clone());
-                while let Some(block) = stream.next().await {
-                    if let Err(simulator::Error::Revert(err)) =
-                        self.simulate_settlement(&settlement).await
-                    {
-                        observe::winner_voided(self.solver.name(), block, &err, has_haircut);
-                        *score_ref = None;
-                        self.settlements
-                            .lock()
-                            .unwrap()
-                            .retain(|s| s.solution().get() != solution_id);
-                        // Only notify solver if solution doesn't have haircut
-                        if !has_haircut {
-                            notify::simulation_failed(
-                                &self.solver,
-                                auction.id(),
-                                settlement.solution(),
-                                &simulator::Error::Revert(err),
-                                true,
-                            );
-                        }
-                        return;
-                    }
-                }
-            };
-            let _ = tokio::time::timeout(remaining, simulate_on_new_blocks).await;
+            let _ = tokio::time::timeout(
+                remaining,
+                self.resimulate_until_revert(&mut scored, auction),
+            )
+            .await;
+        }
+
+        Ok(scored.into_iter().map(|(solved, _)| solved).collect())
+    }
+
+    /// Re-simulate all proposed solutions on every new block and drop any
+    /// that start reverting. Returns once every solution has reverted;
+    /// otherwise runs forever and the caller must impose a deadline.
+    /// Mutates `scored` and the cached settlements in place.
+    async fn resimulate_until_revert(
+        &self,
+        scored: &mut Vec<(Solved, Settlement)>,
+        auction: &Auction,
+    ) -> anyhow::Result<()> {
+        let mut stream = ethrpc::block_stream::into_stream(self.eth.current_block().clone());
+        while let Some(block) = stream.next().await {
+            let voided_ids: HashSet<u64> =
+                futures::future::join_all(scored.iter().map(|(solved, settlement)| {
+                    self.reverts_on_block(block, solved, settlement, auction)
+                }))
+                .await
+                .into_iter()
+                .flatten()
+                .collect();
+
+            if voided_ids.is_empty() {
+                continue;
+            }
+
+            scored.retain(|(solved, _)| !voided_ids.contains(&solved.id.get()));
+            let mut lock = self
+                .settlements
+                .lock()
+                .map_err(|_| anyhow::anyhow!("settlements mutex poisoned"))?;
+            lock.retain(|s| !voided_ids.contains(&s.solution().get()));
+
+            if scored.is_empty() {
+                return Ok(());
+            }
         }
+        Ok(())
+    }
 
-        Ok(score)
+    /// Re-simulate a single solution and return its id if it started
+    /// reverting on this block. Reports metrics and solver notifications as
+    /// a side effect.
+    async fn reverts_on_block(
+        &self,
+        block: BlockInfo,
+        solved: &Solved,
+        settlement: &Settlement,
+        auction: &Auction,
+    ) -> Option<u64> {
+        let err = match self.simulate_settlement(settlement).await {
+            Err(simulator::Error::Revert(err)) => err,
+            _ => return None,
+        };
+        let has_haircut = settlement.has_haircut();
+        observe::winner_voided(self.solver.name(), block, &err, has_haircut);
+        if !has_haircut {
+            notify::simulation_failed(
+                &self.solver,
+                auction.id(),
+                settlement.solution(),
+                &simulator::Error::Revert(err),
+                true,
+            );
+        }
+        Some(solved.id.get())
     }
 
     // Oders already need to be sorted from most relevant to least relevant so that
diff --git a/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs b/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
index 4b8f1e66b2..3db573f820 100644
--- a/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
+++ b/crates/driver/src/infra/api/routes/solve/dto/solve_response.rs
@@ -10,7 +10,7 @@ use {
 };
 
 impl SolveResponse {
-    pub fn new(solved: Option<competition::Solved>, solver: &Solver) -> Self {
+    pub fn new(solved: Vec<competition::Solved>, solver: &Solver) -> Self {
         let solutions = solved
             .into_iter()
             .map(|solved| Solution::new(solved.id.get(), solved, solver))
diff --git a/crates/driver/src/infra/config/file/load.rs b/crates/driver/src/infra/config/file/load.rs
index e8b053f12d..6149891e2c 100644
--- a/crates/driver/src/infra/config/file/load.rs
+++ b/crates/driver/src/infra/config/file/load.rs
@@ -144,6 +144,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                 )
                 .await,
                 forwarder_contract: solver_config.forwarder_contract,
+                max_solutions_to_propose: solver_config.max_solutions_to_propose,
             }
         }))
         .await,
diff --git a/crates/driver/src/infra/config/file/mod.rs b/crates/driver/src/infra/config/file/mod.rs
index d4e689cb69..054028be10 100644
--- a/crates/driver/src/infra/config/file/mod.rs
+++ b/crates/driver/src/infra/config/file/mod.rs
@@ -9,7 +9,7 @@ use {
     serde::{Deserialize, Deserializer, Serialize},
     serde_with::serde_as,
     solver::solver::Arn,
-    std::{collections::HashMap, time::Duration},
+    std::{collections::HashMap, num::NonZeroUsize, time::Duration},
 };
 
 mod load;
@@ -234,6 +234,10 @@ pub fn default_solving_share_of_deadline() -> f64 {
     0.8
 }
 
+fn default_max_solutions_to_propose() -> NonZeroUsize {
+    NonZeroUsize::new(1).unwrap()
+}
+
 #[serde_as]
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
@@ -322,6 +326,13 @@ struct SolverConfig {
     /// Address of the deployed CowSettlementForwarder contract for EIP-7702
     /// delegation. Required when `submission_accounts` is non-empty.
     forwarder_contract: Option<eth::Address>,
+
+    /// Maximum number of solutions the driver proposes to the autopilot per
+    /// auction. Defaults to 1 (only the best-scoring solution). Values > 1
+    /// require `submission-accounts` to be configured; the driver will refuse
+    /// to start otherwise.
+    #[serde(default = "default_max_solutions_to_propose")]
+    max_solutions_to_propose: NonZeroUsize,
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]
diff --git a/crates/driver/src/infra/observe/mod.rs b/crates/driver/src/infra/observe/mod.rs
index 6db4cc4de3..6a69180f6c 100644
--- a/crates/driver/src/infra/observe/mod.rs
+++ b/crates/driver/src/infra/observe/mod.rs
@@ -254,21 +254,21 @@ pub fn settled(solver: &solver::Name, result: &Result<competition::Settled, comp
 }
 
 /// Observe the result of solving an auction.
-pub fn solved(solver: &str, result: &Result<Option<Solved>, competition::Error>) {
+pub fn solved(solver: &str, result: &Result<Vec<Solved>, competition::Error>) {
     match result {
-        Ok(Some(solved)) => {
-            tracing::info!(?solved, "solved auction");
+        Ok(solutions) if solutions.is_empty() => {
+            tracing::debug!("no solution found");
             metrics::get()
                 .solutions
-                .with_label_values(&[solver, "Success"])
+                .with_label_values(&[solver, "SolutionNotFound"])
                 .inc();
         }
-        Ok(None) => {
-            tracing::debug!("no solution found");
+        Ok(solutions) => {
+            tracing::info!(?solutions, "solved auction");
             metrics::get()
                 .solutions
-                .with_label_values(&[solver, "SolutionNotFound"])
-                .inc();
+                .with_label_values(&[solver, "Success"])
+                .inc_by(solutions.len() as u64);
         }
         Err(err) => {
             tracing::warn!(?err, "failed to solve auction");
diff --git a/crates/driver/src/infra/solver/eip7702.rs b/crates/driver/src/infra/solver/eip7702.rs
index b0e195a7dd..4f34b0f2c8 100644
--- a/crates/driver/src/infra/solver/eip7702.rs
+++ b/crates/driver/src/infra/solver/eip7702.rs
@@ -23,17 +23,46 @@ const DELEGATION_PREFIX: [u8; 3] = [0xef, 0x01, 0x00];
 
 /// Ensure EIP-7702 delegation and caller approval are set up for all solvers
 /// with parallel submission accounts. Called once at driver startup.
+///
+/// # Errors
+/// - `max-solutions-to-propose > 1` without any `submission-accounts`
+///   configured (parallel submission is required for multi-solution mode).
+/// - `submission-accounts` configured without a `forwarder-contract` address.
+/// - `submission-accounts` configured but the main solver account is read-only,
+///   so it cannot sign the EIP-7702 authorization.
+/// - The EIP-7702 delegation tx lands but the on-chain code does not reflect
+///   the expected designator (e.g. a concurrent tx shifted the nonce).
+/// - Any underlying RPC error (code fetch, chain id, tx send, receipt).
 #[instrument(name = "setup_eip7702", skip_all)]
 pub async fn setup(solvers: &[Solver], eth: &Ethereum) -> anyhow::Result<()> {
     for solver in solvers {
         let config = solver.config();
         if config.submission_accounts.is_empty() {
+            anyhow::ensure!(
+                config.max_solutions_to_propose.get() == 1,
+                "solver '{}': max-solutions-to-propose > 1 requires at least one \
+                 submission-account (EIP-7702 parallel submission must be enabled)",
+                config.name,
+            );
             continue;
         }
-        if matches!(config.account, super::Account::Address(_)) {
-            tracing::debug!(solver = %config.name, "read-only mode, skipping EIP-7702 setup");
+        if config
+            .submission_accounts
+            .iter()
+            .all(|a| matches!(a, super::Account::Address(_)))
+        {
+            tracing::debug!(
+                solver = %config.name,
+                "all submission accounts are read-only, skipping EIP-7702 setup"
+            );
             continue;
         }
+        anyhow::ensure!(
+            !matches!(config.account, super::Account::Address(_)),
+            "solver '{}': main account must be a signer to set up EIP-7702 delegation when \
+             submission accounts are configured",
+            config.name,
+        );
         let forwarder = config.forwarder_contract.ok_or_else(|| {
             anyhow::anyhow!(
                 "solver {}: submission_accounts configured but forwarder_contract missing",
diff --git a/crates/driver/src/infra/solver/mod.rs b/crates/driver/src/infra/solver/mod.rs
index ae1ff46b8a..f3cc96005a 100644
--- a/crates/driver/src/infra/solver/mod.rs
+++ b/crates/driver/src/infra/solver/mod.rs
@@ -219,6 +219,9 @@ pub struct Config {
     /// Address of the deployed CowSettlementForwarder contract for EIP-7702
     /// delegation. Required when `submission_accounts` is non-empty.
     pub forwarder_contract: Option<eth::Address>,
+    /// Maximum number of solutions the driver proposes to the autopilot per
+    /// auction. When 1 (the default), only the best-scoring solution is sent.
+    pub max_solutions_to_propose: std::num::NonZeroUsize,
 }
 
 impl Solver {
@@ -325,6 +328,10 @@ impl Solver {
         self.config.forwarder_contract
     }
 
+    pub fn max_solutions_to_propose(&self) -> usize {
+        self.config.max_solutions_to_propose.get()
+    }
+
     /// Make a POST request instructing the solver to solve an auction.
     /// Allocates at most `timeout` time for the solving.
     #[instrument(name = "solver_engine", skip_all)]
diff --git a/crates/driver/src/tests/cases/multiple_solutions.rs b/crates/driver/src/tests/cases/multiple_solutions.rs
index 33c78efd5d..5ded9688c8 100644
--- a/crates/driver/src/tests/cases/multiple_solutions.rs
+++ b/crates/driver/src/tests/cases/multiple_solutions.rs
@@ -1,6 +1,10 @@
-use crate::tests::{
-    setup,
-    setup::{ab_order, ab_pool, ab_solution},
+use {
+    crate::tests::{
+        setup,
+        setup::{ab_order, ab_pool, ab_solution, ad_order, ad_pool, ad_solution, test_solver},
+    },
+    alloy::primitives::address,
+    eth_domain_types as eth,
 };
 
 /// Test that the best-scoring solution is picked when the /solve endpoint
@@ -21,6 +25,98 @@ async fn valid() {
     test.reveal(id).await.ok().calldata();
 }
 
+/// Test that when multiple solutions are proposed they are returned sorted
+/// best-first (by score) and each can be revealed independently.
+/// Uses two different orders (AB and AD with different sell amounts) so the
+/// solutions have genuinely different surplus and therefore different scores.
+#[tokio::test]
+#[ignore]
+async fn all_proposed() {
+    let test = setup()
+        .solvers(vec![
+            test_solver()
+                .max_solutions_to_propose(5)
+                .submission_account(address!("0000000000000000000000000000000000000001")),
+        ])
+        .pool(ab_pool())
+        .pool(ad_pool())
+        .order(ab_order())
+        .order(ad_order())
+        // Add the lower-scoring solution first so the sort has to reorder.
+        .solution(ad_solution())
+        .solution(ab_solution())
+        .done()
+        .await;
+
+    let solve = test.solve().await.ok();
+    let solutions = solve.solutions();
+    assert_eq!(solutions.len(), 2);
+
+    // Solutions must be sorted best-first (strictly descending score).
+    let score0 = solutions[0].get("score").unwrap().as_str().unwrap();
+    let score1 = solutions[1].get("score").unwrap().as_str().unwrap();
+    let score0 = eth::U256::from_str_radix(score0, 10).unwrap();
+    let score1 = eth::U256::from_str_radix(score1, 10).unwrap();
+    assert!(score0 > score1, "expected strictly descending scores");
+
+    // Both solutions should be revealable.
+    let id0 = solutions[0].get("solutionId").unwrap().as_u64().unwrap();
+    let id1 = solutions[1].get("solutionId").unwrap().as_u64().unwrap();
+    test.reveal(id0).await.ok().calldata();
+    test.reveal(id1).await.ok().calldata();
+}
+
+/// Test that `max-solutions-to-propose` caps the number of returned solutions.
+#[tokio::test]
+#[ignore]
+async fn capped() {
+    let test = setup()
+        .solvers(vec![
+            test_solver()
+                .max_solutions_to_propose(1)
+                .submission_account(address!("0000000000000000000000000000000000000001")),
+        ])
+        .pool(ab_pool())
+        .pool(ad_pool())
+        .order(ab_order())
+        .order(ad_order())
+        .solution(ab_solution())
+        .solution(ad_solution())
+        .done()
+        .await;
+
+    let solve = test.solve().await.ok();
+    let solutions = solve.solutions();
+    assert_eq!(solutions.len(), 1, "should be capped to 1 solution");
+}
+
+/// Test that when multiple solutions are proposed, invalid solutions are
+/// discarded and only valid ones are returned.
+#[tokio::test]
+#[ignore]
+async fn only_proposes_valid_solutions() {
+    let order = ab_order();
+    let test = setup()
+        .solvers(vec![
+            test_solver()
+                .max_solutions_to_propose(5)
+                .submission_account(address!("0000000000000000000000000000000000000001")),
+        ])
+        .pool(ab_pool())
+        .order(order.clone())
+        .solution(ab_solution())
+        .solution(ab_solution().invalid())
+        .done()
+        .await;
+
+    let solve = test.solve().await.ok();
+    let solutions = solve.solutions();
+    assert_eq!(solutions.len(), 1);
+
+    let id = solutions[0].get("solutionId").unwrap().as_u64().unwrap();
+    test.reveal(id).await.ok().calldata();
+}
+
 /// Test that the invalid solution is discarded when the /solve endpoint
 /// returns multiple solutions.
 #[tokio::test]
diff --git a/crates/driver/src/tests/setup/driver.rs b/crates/driver/src/tests/setup/driver.rs
index e3e6cb3991..be91f6ccab 100644
--- a/crates/driver/src/tests/setup/driver.rs
+++ b/crates/driver/src/tests/setup/driver.rs
@@ -321,6 +321,7 @@ async fn create_config_file(
                fee-handler = {}
                merge-solutions = {}
                haircut-bps = {}
+               max-solutions-to-propose = {}
                "#,
             solver.name,
             addr,
@@ -336,8 +337,18 @@ async fn create_config_file(
             serde_json::to_string(&solver.fee_handler).unwrap(),
             solver.merge_solutions,
             solver.haircut_bps,
+            solver.max_solutions_to_propose,
         )
         .unwrap();
+        if !solver.submission_accounts.is_empty() {
+            let accounts = solver
+                .submission_accounts
+                .iter()
+                .map(|a| format!("\"{a}\""))
+                .collect::<Vec<_>>()
+                .join(", ");
+            writeln!(file, "               submission-accounts = [{accounts}]").unwrap();
+        }
     }
     file.into_temp_path()
 }
diff --git a/crates/driver/src/tests/setup/mod.rs b/crates/driver/src/tests/setup/mod.rs
index 7677704e7e..9eada0359a 100644
--- a/crates/driver/src/tests/setup/mod.rs
+++ b/crates/driver/src/tests/setup/mod.rs
@@ -361,6 +361,10 @@ pub struct Solver {
     merge_solutions: bool,
     /// Haircut in basis points (0-10000) for conservative bidding.
     haircut_bps: u32,
+    /// Maximum number of solutions the driver proposes per auction.
+    max_solutions_to_propose: usize,
+    /// Additional submission accounts for EIP-7702 parallel settlement.
+    submission_accounts: Vec<eth::Address>,
 }
 
 #[derive(Debug, Clone)]
@@ -388,6 +392,8 @@ pub fn test_solver() -> Solver {
         fee_handler: FeeHandler::default(),
         merge_solutions: false,
         haircut_bps: 0,
+        max_solutions_to_propose: 1,
+        submission_accounts: vec![],
     }
 }
 
@@ -433,6 +439,16 @@ impl Solver {
             ..self
         }
     }
+
+    pub fn max_solutions_to_propose(mut self, n: usize) -> Self {
+        self.max_solutions_to_propose = n;
+        self
+    }
+
+    pub fn submission_account(mut self, address: eth::Address) -> Self {
+        self.submission_accounts.push(address);
+        self
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -1265,7 +1281,7 @@ impl<'a> Solve<'a> {
 }
 
 impl SolveOk<'_> {
-    fn solutions(&self) -> Vec<serde_json::Value> {
+    pub fn solutions(&self) -> Vec<serde_json::Value> {
         #[derive(serde::Deserialize)]
         struct Body {
             solutions: Vec<serde_json::Value>,
@@ -1285,9 +1301,8 @@ impl SolveOk<'_> {
             .to_owned()
     }
 
-    /// Extracts the first solution from the response. This is expected to be
-    /// always valid if there is a valid solution, as we expect from driver to
-    /// not send multiple solutions (yet).
+    /// Extracts the only solution from the response. Panics if the response
+    /// contains more than one solution (i.e. `max-solutions-to-propose > 1`).
     pub fn solution(&self) -> serde_json::Value {
         let solutions = self.solutions();
         assert_eq!(solutions.len(), 1);

From fb72f961a73b4e4b5b112d973d30664b24548e86 Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Thu, 30 Apr 2026 11:52:55 +0200
Subject: [PATCH 218/219] Fix Justfile repeat fmt-toml

---
 Justfile | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/Justfile b/Justfile
index d3fcff2b11..829eef830b 100644
--- a/Justfile
+++ b/Justfile
@@ -56,10 +56,6 @@ fmt *extra:
     cargo +nightly fmt --all -- {{extra}}
     cd contracts && cargo +nightly fmt --all -- {{extra}}
 
-# Format .toml files in the repository
-fmt-toml *extra:
-    tombi format {{extra}}
-
 
 # Format .toml files in the repository
 fmt-toml *extra:

From 77ef335db5b8fe34305cef3a9720aec0f11bd9db Mon Sep 17 00:00:00 2001
From: Marcin Szymczak <mail@marszy.com>
Date: Thu, 30 Apr 2026 12:24:03 +0200
Subject: [PATCH 219/219] Remove leftover config dirs

---
 crates/autopilot/src/config/banned_users.rs   |  58 ---
 crates/autopilot/src/config/fee_policy.rs     | 182 ---------
 crates/autopilot/src/config/mod.rs            | 377 ------------------
 crates/autopilot/src/config/native_price.rs   | 105 -----
 .../src/config/order_events_cleanup.rs        |  59 ---
 crates/autopilot/src/config/s3.rs             |  56 ---
 crates/autopilot/src/config/solver.rs         | 195 ---------
 crates/autopilot/src/config/trusted_tokens.rs |  63 ---
 .../domain/competition/winner_selection.rs    |   1 -
 crates/autopilot/src/lib.rs                   |   1 -
 crates/configs/src/orderbook/mod.rs           |   1 +
 crates/orderbook/src/config/banned_users.rs   |  28 --
 crates/orderbook/src/config/ipfs.rs           |  94 -----
 crates/orderbook/src/config/mod.rs            | 335 ----------------
 crates/orderbook/src/config/native_price.rs   |  98 -----
 .../orderbook/src/config/order_validation.rs  | 149 -------
 crates/orderbook/src/lib.rs                   |   1 -
 17 files changed, 1 insertion(+), 1802 deletions(-)
 delete mode 100644 crates/autopilot/src/config/banned_users.rs
 delete mode 100644 crates/autopilot/src/config/fee_policy.rs
 delete mode 100644 crates/autopilot/src/config/mod.rs
 delete mode 100644 crates/autopilot/src/config/native_price.rs
 delete mode 100644 crates/autopilot/src/config/order_events_cleanup.rs
 delete mode 100644 crates/autopilot/src/config/s3.rs
 delete mode 100644 crates/autopilot/src/config/solver.rs
 delete mode 100644 crates/autopilot/src/config/trusted_tokens.rs
 delete mode 100644 crates/orderbook/src/config/banned_users.rs
 delete mode 100644 crates/orderbook/src/config/ipfs.rs
 delete mode 100644 crates/orderbook/src/config/mod.rs
 delete mode 100644 crates/orderbook/src/config/native_price.rs
 delete mode 100644 crates/orderbook/src/config/order_validation.rs

diff --git a/crates/autopilot/src/config/banned_users.rs b/crates/autopilot/src/config/banned_users.rs
deleted file mode 100644
index 7a2ef3fc6e..0000000000
--- a/crates/autopilot/src/config/banned_users.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use {
-    alloy::primitives::Address,
-    serde::{Deserialize, Serialize},
-    std::num::NonZeroUsize,
-};
-
-fn default_max_cache_size() -> NonZeroUsize {
-    NonZeroUsize::new(10000).unwrap()
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct BannedUsersConfig {
-    /// List of account addresses to be denied from order creation.
-    #[serde(default)]
-    pub addresses: Vec<Address>,
-
-    /// Maximum number of entries to keep in the banned users cache.
-    #[serde(default = "default_max_cache_size")]
-    pub max_cache_size: NonZeroUsize,
-}
-
-impl Default for BannedUsersConfig {
-    fn default() -> Self {
-        Self {
-            addresses: Vec::new(),
-            max_cache_size: default_max_cache_size(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {super::*, alloy::primitives::address};
-
-    #[test]
-    fn deserialize_defaults() {
-        let toml = "";
-        let config: BannedUsersConfig = toml::from_str(toml).unwrap();
-        assert!(config.addresses.is_empty());
-        assert_eq!(config.max_cache_size.get(), 10000);
-    }
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        addresses = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
-        max-cache-size = 5000
-        "#;
-        let config: BannedUsersConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.addresses.len(), 1);
-        assert_eq!(
-            config.addresses[0],
-            address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")
-        );
-        assert_eq!(config.max_cache_size.get(), 5000);
-    }
-}
diff --git a/crates/autopilot/src/config/fee_policy.rs b/crates/autopilot/src/config/fee_policy.rs
deleted file mode 100644
index 809023ec98..0000000000
--- a/crates/autopilot/src/config/fee_policy.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-use {
-    chrono::{DateTime, Utc},
-    configs::fee_factor::FeeFactor,
-    serde::{Deserialize, Serialize},
-};
-
-pub const fn default_max_partner_fee() -> FeeFactor {
-    FeeFactor::new(0.01)
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct FeePoliciesConfig {
-    /// Describes how the protocol fees should be calculated.
-    #[serde(default)]
-    pub policies: Vec<FeePolicy>,
-
-    /// Maximum partner fee allowed. If the partner fee specified is greater
-    /// than this maximum, the partner fee will be capped.
-    #[serde(default = "default_max_partner_fee")]
-    pub max_partner_fee: FeeFactor,
-
-    /// Fee policies that will become effective at a future timestamp.
-    #[serde(default)]
-    pub upcoming_policies: UpcomingFeePolicies,
-}
-
-impl Default for FeePoliciesConfig {
-    fn default() -> Self {
-        Self {
-            policies: Default::default(),
-            max_partner_fee: default_max_partner_fee(),
-            upcoming_policies: Default::default(),
-        }
-    }
-}
-
-/// A fee policy to be used for orders based on its class.
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct FeePolicy {
-    pub kind: FeePolicyKind,
-    pub order_class: FeePolicyOrderClass,
-}
-
-/// Fee policies that will become effective at a future timestamp.
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct UpcomingFeePolicies {
-    #[serde(default)]
-    pub policies: Vec<FeePolicy>,
-
-    /// Timestamp from which the `policies` will become active.
-    pub effective_from_timestamp: Option<DateTime<Utc>>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum FeePolicyKind {
-    /// How much of the order's surplus should be taken as a protocol fee.
-    #[serde(rename_all = "kebab-case")]
-    Surplus {
-        factor: FeeFactor,
-        max_volume_factor: FeeFactor,
-    },
-    /// How much of the order's price improvement should be taken as a protocol
-    /// fee where price improvement is a difference between the executed price
-    /// and the best quote.
-    #[serde(rename_all = "kebab-case")]
-    PriceImprovement {
-        factor: FeeFactor,
-        max_volume_factor: FeeFactor,
-    },
-    /// How much of the order's volume should be taken as a protocol fee.
-    Volume { factor: FeeFactor },
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum FeePolicyOrderClass {
-    /// If a fee policy needs to be applied to in-market orders.
-    Market,
-    /// If a fee policy needs to be applied to limit orders.
-    Limit,
-    /// If a fee policy needs to be applied regardless of the order class.
-    Any,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_fee_policy_surplus() {
-        let toml = r#"
-        kind.surplus = { factor = 0.5, max-volume-factor = 0.9 }
-        order-class = "limit"
-        "#;
-        let policy: FeePolicy = toml::from_str(toml).unwrap();
-        assert!(matches!(
-            policy.kind,
-            FeePolicyKind::Surplus { factor, max_volume_factor }
-            if factor.get() == 0.5 && max_volume_factor.get() == 0.9
-        ));
-        assert!(matches!(policy.order_class, FeePolicyOrderClass::Limit));
-    }
-
-    #[test]
-    fn deserialize_fee_policy_volume() {
-        let toml = r#"
-        kind.volume = { factor = 0.1 }
-        order-class = "any"
-        "#;
-        let policy: FeePolicy = toml::from_str(toml).unwrap();
-        assert!(matches!(
-            policy.kind,
-            FeePolicyKind::Volume { factor } if factor.get() == 0.1
-        ));
-        assert!(matches!(policy.order_class, FeePolicyOrderClass::Any));
-    }
-
-    #[test]
-    fn deserialize_fee_policy_price_improvement() {
-        let toml = r#"
-        kind.price-improvement = { factor = 0.5, max-volume-factor = 0.06 }
-        order-class = "market"
-        "#;
-        let policy: FeePolicy = toml::from_str(toml).unwrap();
-        assert!(matches!(
-            policy.kind,
-            FeePolicyKind::PriceImprovement { factor, max_volume_factor }
-            if factor.get() == 0.5 && max_volume_factor.get() == 0.06
-        ));
-        assert!(matches!(policy.order_class, FeePolicyOrderClass::Market));
-    }
-
-    #[test]
-    fn deserialize_fee_policies_config_defaults() {
-        let toml = "";
-        let config: FeePoliciesConfig = toml::from_str(toml).unwrap();
-        assert!(config.policies.is_empty());
-        assert_eq!(config.max_partner_fee.get(), 0.01);
-        assert!(config.upcoming_policies.policies.is_empty());
-        assert!(config.upcoming_policies.effective_from_timestamp.is_none());
-    }
-
-    #[test]
-    fn deserialize_fee_policies_config_full() {
-        let toml = r#"
-        max-partner-fee = 0.005
-
-        [[policies]]
-        kind.surplus = { factor = 0.5, max-volume-factor = 0.9 }
-        order-class = "limit"
-
-        [[policies]]
-        kind.volume = { factor = 0.1 }
-        order-class = "any"
-
-        [upcoming-policies]
-        effective-from-timestamp = "2025-06-01T00:00:00Z"
-
-        [[upcoming-policies.policies]]
-        kind.volume = { factor = 0.2 }
-        order-class = "any"
-        "#;
-        let config: FeePoliciesConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.policies.len(), 2);
-        assert_eq!(config.max_partner_fee.get(), 0.005);
-        assert_eq!(config.upcoming_policies.policies.len(), 1);
-        assert!(config.upcoming_policies.effective_from_timestamp.is_some());
-    }
-
-    #[test]
-    fn deserialize_invalid_fee_factor() {
-        let toml = r#"
-        kind.volume = { factor = 1.5 }
-        order-class = "any"
-        "#;
-        assert!(toml::from_str::<FeePolicy>(toml).is_err());
-    }
-}
diff --git a/crates/autopilot/src/config/mod.rs b/crates/autopilot/src/config/mod.rs
deleted file mode 100644
index a96a51ceb7..0000000000
--- a/crates/autopilot/src/config/mod.rs
+++ /dev/null
@@ -1,377 +0,0 @@
-use {
-    crate::config::{
-        banned_users::BannedUsersConfig,
-        fee_policy::FeePoliciesConfig,
-        native_price::NativePriceConfig,
-        order_events_cleanup::OrderEventsCleanupConfig,
-        s3::S3Config,
-        solver::Solver,
-        trusted_tokens::TrustedTokensConfig,
-    },
-    anyhow::{anyhow, ensure},
-    configs::database::DatabasePoolConfig,
-    serde::Deserialize,
-    std::path::Path,
-};
-
-pub mod banned_users;
-pub mod fee_policy;
-pub mod native_price;
-pub mod order_events_cleanup;
-pub mod s3;
-pub mod solver;
-pub mod trusted_tokens;
-
-// Does not implement Default because `native_price_estimation` *cannot* have
-// empty `estimators`, as such, we cannot provide a proper default value for
-// this structure.
-#[derive(Debug, Deserialize)]
-#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
-// NOTE: cannot add deny_unknown_fields during the config migration
-// as new ones get added in the config will fail parsing if extra fields are present
-#[serde(rename_all = "kebab-case", /* deny_unknown_fields */)]
-pub struct Configuration {
-    pub drivers: Vec<Solver>,
-
-    /// Describes how the protocol fees should be calculated.
-    pub fee_policies: FeePoliciesConfig,
-
-    /// Configuration for trusted tokens that the settlement contract is willing
-    /// to internalize.
-    #[serde(default)]
-    pub trusted_tokens: TrustedTokensConfig,
-
-    /// Configuration for periodic cleanup of order events.
-    #[serde(default)]
-    pub order_events_cleanup: OrderEventsCleanupConfig,
-
-    /// Configuration for order validation rules.
-    #[serde(default)]
-    pub banned_users: BannedUsersConfig,
-
-    /// Configuration for uploading auction instances to S3.
-    /// If absent, S3 uploads are disabled.
-    pub s3: Option<S3Config>,
-
-    pub native_price_estimation: NativePriceConfig,
-
-    #[serde(default)]
-    pub database: DatabasePoolConfig,
-}
-
-impl Configuration {
-    pub async fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
-        match toml::from_str(&tokio::fs::read_to_string(&path).await?) {
-            Ok(self_) => Ok(self_),
-            Err(err) if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") => Err(anyhow!(
-                "failed to parse TOML config at {}: {err:#?}",
-                path.as_ref().display()
-            )),
-            Err(_) => Err(anyhow!(
-                "failed to parse TOML config at: {}. Set TOML_TRACE_ERROR=1 to print parsing \
-                 error but this may leak secrets.",
-                path.as_ref().display()
-            )),
-        }
-    }
-
-    // Note for reviewers: if this and other validations are always applied,
-    // we should instead move them to the deserialization stage
-    // https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/
-    pub fn validate(self) -> anyhow::Result<Self> {
-        ensure!(
-            !self.drivers.is_empty(),
-            "colocation is enabled but no drivers are configured"
-        );
-        Ok(self)
-    }
-}
-
-#[cfg(any(test, feature = "test-util"))]
-impl Configuration {
-    /// This function *does not* return a valid configuration!
-    /// It is rather useful for tests where drivers are setup separately or not
-    /// actually used (like the `order_cancellation` test).
-    pub fn test_no_drivers() -> Self {
-        use configs::test_util::TestDefault;
-
-        Self {
-            drivers: vec![],
-            fee_policies: Default::default(),
-            trusted_tokens: Default::default(),
-            order_events_cleanup: Default::default(),
-            banned_users: Default::default(),
-            s3: Default::default(),
-            native_price_estimation: NativePriceConfig::test_default(),
-            database: DatabasePoolConfig::test_default(),
-        }
-    }
-
-    pub fn test(name: &str, solver_address: alloy::primitives::Address) -> Self {
-        use configs::test_util::TestDefault;
-
-        Self {
-            drivers: vec![Solver::test(name, solver_address)],
-            fee_policies: Default::default(),
-            trusted_tokens: Default::default(),
-            order_events_cleanup: Default::default(),
-            banned_users: Default::default(),
-            s3: Default::default(),
-            native_price_estimation: NativePriceConfig::test_default(),
-            database: DatabasePoolConfig::test_default(),
-        }
-    }
-
-    pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
-        use std::io::Write;
-
-        let mut file = tempfile::NamedTempFile::new().expect("temp file creation should not fail");
-        file.write_all(
-            toml::to_string_pretty(self)
-                .expect("serialization should not fail")
-                .as_bytes(),
-        )
-        .expect("writing to temp file should not fail");
-        file
-    }
-
-    pub fn to_cli_args(&self) -> (tempfile::NamedTempFile, String) {
-        // Must return the temp_file because it gets deleted on drop
-        // disabling the cleanup will lead to a bunch of artifacts laying around
-        let named_temp_file = self.to_temp_path();
-        let cli_arg = format!("--config={}", named_temp_file.path().display());
-        (named_temp_file, cli_arg)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        crate::config::{
-            fee_policy::{FeePolicy, FeePolicyKind, FeePolicyOrderClass, UpcomingFeePolicies},
-            solver::Account,
-        },
-        alloy::primitives::address,
-        std::time::Duration,
-    };
-
-    #[test]
-    fn deserialize_full_configuration() {
-        let toml = r#"
-        [[drivers]]
-        name = "solver1"
-        url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-
-        [[drivers]]
-        name = "solver2"
-        url = "http://localhost:8081"
-        submission-account.kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
-
-        [fee-policies]
-        max-partner-fee = 0.005
-
-        [[fee-policies.policies]]
-        kind.surplus = { factor = 0.5, max-volume-factor = 0.9 }
-        order-class = "limit"
-
-        [[fee-policies.policies]]
-        kind.volume = { factor = 0.1 }
-        order-class = "any"
-
-        [fee-policies.upcoming-policies]
-        effective-from-timestamp = "2025-06-01T00:00:00Z"
-
-        [[fee-policies.upcoming-policies.policies]]
-        kind.volume = { factor = 0.2 }
-        order-class = "any"
-
-        [trusted-tokens]
-        url = "https://example.com/tokens.json"
-        tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
-        update-interval = "30m"
-
-        [order-events-cleanup]
-        cleanup-interval = "12h"
-        cleanup-threshold = "7d"
-
-        [banned-users]
-        addresses = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
-        max-cache-size = 5000
-
-        [s3]
-        bucket = "my-bucket"
-        filename-prefix = "staging/mainnet/"
-
-        [native-price-estimation]
-        estimators = [
-            [{type = "CoinGecko"}, {type = "OneInchSpotPriceApi"}],
-            [{type = "Driver", name = "solver1", url = "http://localhost:8080"}],
-            [{type = "Forwarder", url = "http://localhost:12088"}],
-        ]
-        "#;
-
-        let config: Configuration = toml::from_str(toml).unwrap();
-
-        assert_eq!(config.drivers.len(), 2);
-        assert_eq!(config.drivers[0].name, "solver1");
-        assert_eq!(
-            config.drivers[0].submission_account,
-            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"))
-        );
-        assert_eq!(config.drivers[1].name, "solver2");
-
-        assert_eq!(config.fee_policies.max_partner_fee.get(), 0.005);
-        assert_eq!(config.fee_policies.policies.len(), 2);
-        assert!(matches!(
-            config.fee_policies.policies[0].kind,
-            FeePolicyKind::Surplus { .. }
-        ));
-        assert!(matches!(
-            config.fee_policies.policies[0].order_class,
-            FeePolicyOrderClass::Limit
-        ));
-        assert!(matches!(
-            config.fee_policies.policies[1].kind,
-            FeePolicyKind::Volume { .. }
-        ));
-        assert!(matches!(
-            config.fee_policies.policies[1].order_class,
-            FeePolicyOrderClass::Any
-        ));
-
-        assert_eq!(config.fee_policies.upcoming_policies.policies.len(), 1);
-        assert!(
-            config
-                .fee_policies
-                .upcoming_policies
-                .effective_from_timestamp
-                .is_some()
-        );
-
-        assert!(config.trusted_tokens.url.is_some());
-        assert_eq!(config.trusted_tokens.tokens.len(), 1);
-        assert_eq!(
-            config.trusted_tokens.update_interval,
-            Duration::from_secs(1800)
-        );
-
-        assert_eq!(
-            config.order_events_cleanup.cleanup_interval,
-            Duration::from_secs(43200)
-        );
-        assert_eq!(
-            config.order_events_cleanup.cleanup_threshold,
-            Duration::from_secs(604800)
-        );
-
-        assert_eq!(config.banned_users.addresses.len(), 1);
-        assert_eq!(config.banned_users.max_cache_size.get(), 5000);
-
-        let s3 = config.s3.unwrap();
-        assert_eq!(s3.bucket, "my-bucket");
-        assert_eq!(s3.filename_prefix, "staging/mainnet/");
-
-        use price_estimation::{ExternalSolver, NativePriceEstimator};
-        assert_eq!(
-            config.native_price_estimation.estimators.as_slice(),
-            vec![
-                vec![
-                    NativePriceEstimator::CoinGecko,
-                    NativePriceEstimator::OneInchSpotPriceApi,
-                ],
-                vec![NativePriceEstimator::Driver(ExternalSolver {
-                    name: "solver1".to_string(),
-                    url: "http://localhost:8080".parse().unwrap(),
-                })],
-                vec![NativePriceEstimator::Forwarder {
-                    url: "http://localhost:12088".parse().unwrap(),
-                }],
-            ]
-        );
-    }
-
-    #[test]
-    fn deserialize_configuration_defaults() {
-        let toml = r#"
-        [[drivers]]
-        name = "solver1"
-        url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-
-        [fee-policies]
-
-        [native-price-estimation]
-        estimators = [[{type = "CoinGecko"}]]
-        "#;
-
-        let config: Configuration = toml::from_str(toml).unwrap();
-
-        assert_eq!(config.drivers.len(), 1);
-        assert_eq!(
-            config.native_price_estimation.estimators.as_slice().len(),
-            1
-        );
-        assert!(config.fee_policies.policies.is_empty());
-        assert_eq!(config.fee_policies.max_partner_fee.get(), 0.01);
-        assert!(config.fee_policies.upcoming_policies.policies.is_empty());
-        assert!(
-            config
-                .fee_policies
-                .upcoming_policies
-                .effective_from_timestamp
-                .is_none()
-        );
-
-        assert!(config.trusted_tokens.url.is_none());
-        assert!(config.trusted_tokens.tokens.is_empty());
-        assert_eq!(
-            config.trusted_tokens.update_interval,
-            Duration::from_secs(3600)
-        );
-
-        assert_eq!(
-            config.order_events_cleanup.cleanup_interval,
-            Duration::from_secs(86400)
-        );
-        assert_eq!(
-            config.order_events_cleanup.cleanup_threshold,
-            Duration::from_secs(2592000)
-        );
-
-        assert!(config.banned_users.addresses.is_empty());
-        assert_eq!(config.banned_users.max_cache_size.get(), 10000);
-
-        assert!(config.s3.is_none());
-    }
-
-    #[test]
-    fn roundtrip_serialization() {
-        let config = Configuration {
-            drivers: vec![Solver::test(
-                "solver1",
-                address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
-            )],
-            fee_policies: FeePoliciesConfig {
-                policies: vec![FeePolicy {
-                    kind: FeePolicyKind::Surplus {
-                        factor: 0.5.try_into().unwrap(),
-                        max_volume_factor: 0.9.try_into().unwrap(),
-                    },
-                    order_class: FeePolicyOrderClass::Limit,
-                }],
-                max_partner_fee: 0.02.try_into().unwrap(),
-                upcoming_policies: UpcomingFeePolicies::default(),
-            },
-            ..Configuration::test_no_drivers()
-        };
-
-        let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: Configuration = toml::from_str(&serialized).unwrap();
-
-        assert_eq!(deserialized.drivers.len(), 1);
-        assert_eq!(deserialized.fee_policies.policies.len(), 1);
-        assert_eq!(deserialized.fee_policies.max_partner_fee.get(), 0.02);
-    }
-}
diff --git a/crates/autopilot/src/config/native_price.rs b/crates/autopilot/src/config/native_price.rs
deleted file mode 100644
index 849be21e12..0000000000
--- a/crates/autopilot/src/config/native_price.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use {
-    price_estimation::NativePriceEstimators,
-    serde::{Deserialize, Serialize},
-    std::time::Duration,
-};
-
-const fn default_native_price_cache_refresh() -> Duration {
-    Duration::from_secs(1)
-}
-
-const fn default_native_price_prefetch_time() -> Duration {
-    Duration::from_secs(80)
-}
-
-// Does not implement Default because `estimators` *cannot* be empty,
-// as such, we cannot provide a proper default value for this structure.
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct NativePriceConfig {
-    /// Which estimators to use to estimate token prices in terms of the chain's
-    /// native token. Estimators with the same name need to also be specified as
-    /// built-in, legacy or external price estimators (lookup happens in this
-    /// order in case of name collisions)
-    pub estimators: NativePriceEstimators,
-
-    /// Estimators for the API endpoint. Falls back to
-    /// `--native-price-estimators` if unset.
-    pub api_estimators: Option<NativePriceEstimators>,
-
-    /// How often the native price estimator should check for prices that need
-    /// to be udpated.
-    #[serde(
-        with = "humantime_serde",
-        default = "default_native_price_cache_refresh"
-    )]
-    pub cache_refresh_interval: Duration,
-
-    /// How long before expiry the native price cache should try to update the
-    /// price in the background. This value has to be smaller than
-    /// `--native-price-cache-max-age`.
-    #[serde(
-        with = "humantime_serde",
-        default = "default_native_price_prefetch_time"
-    )]
-    pub prefetch_time: Duration,
-
-    #[serde(flatten)]
-    pub shared: price_estimation::config::native_price::NativePriceConfig,
-}
-
-#[cfg(any(test, feature = "test-util"))]
-impl NativePriceConfig {
-    /// Test configuration for [`NativePriceConfig`], must always be able to do
-    /// a serialization/deserialization roundtrip, as otherwise it may not
-    /// be loadable in end-to-end tests.
-    pub fn test_default() -> Self {
-        Self {
-            estimators: NativePriceEstimators::test_default(),
-            api_estimators: Default::default(),
-            cache_refresh_interval: default_native_price_cache_refresh(),
-            prefetch_time: Duration::from_millis(500),
-            shared: price_estimation::config::native_price::NativePriceConfig {
-                cache: price_estimation::config::native_price::CacheConfig {
-                    max_age: Duration::from_secs(2),
-                    ..Default::default()
-                },
-                ..Default::default()
-            },
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        estimators = [[{type = "CoinGecko"}]]
-        api-estimators = [[{type = "OneInchSpotPriceApi"}]]
-        cache-refresh-interval = "30s"
-        prefetch-time = "2m"
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.estimators.as_slice().len(), 1);
-        assert!(config.api_estimators.is_some());
-        assert_eq!(config.cache_refresh_interval, Duration::from_secs(30));
-        assert_eq!(config.prefetch_time, Duration::from_secs(120));
-    }
-
-    #[test]
-    fn missing_estimators_fails() {
-        let toml = "";
-        assert!(toml::from_str::<NativePriceConfig>(toml).is_err());
-    }
-
-    // This test keeps the sanity of `test_default` upon which other tests rely!
-    #[test]
-    fn test_default_roundtrip() {
-        let config = NativePriceConfig::test_default();
-        let serialized = toml::to_string(&config).unwrap();
-        let _: NativePriceConfig = toml::from_str(&serialized).unwrap();
-    }
-}
diff --git a/crates/autopilot/src/config/order_events_cleanup.rs b/crates/autopilot/src/config/order_events_cleanup.rs
deleted file mode 100644
index 5b21ccbf91..0000000000
--- a/crates/autopilot/src/config/order_events_cleanup.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use {
-    serde::{Deserialize, Serialize},
-    std::time::Duration,
-};
-
-fn default_cleanup_interval() -> Duration {
-    Duration::from_secs(86400) // 1d
-}
-
-fn default_cleanup_threshold() -> Duration {
-    Duration::from_secs(2592000) // 30d
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct OrderEventsCleanupConfig {
-    /// Time interval between each cleanup operation of the `order_events`
-    /// database table.
-    #[serde(with = "humantime_serde", default = "default_cleanup_interval")]
-    pub cleanup_interval: Duration,
-
-    /// Age threshold for order events to be eligible for cleanup in the
-    /// `order_events` database table.
-    #[serde(with = "humantime_serde", default = "default_cleanup_threshold")]
-    pub cleanup_threshold: Duration,
-}
-
-impl Default for OrderEventsCleanupConfig {
-    fn default() -> Self {
-        Self {
-            cleanup_interval: default_cleanup_interval(),
-            cleanup_threshold: default_cleanup_threshold(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_defaults() {
-        let toml = "";
-        let config: OrderEventsCleanupConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.cleanup_interval, Duration::from_secs(86400));
-        assert_eq!(config.cleanup_threshold, Duration::from_secs(2592000));
-    }
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        cleanup-interval = "12h"
-        cleanup-threshold = "7d"
-        "#;
-        let config: OrderEventsCleanupConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.cleanup_interval, Duration::from_secs(43200));
-        assert_eq!(config.cleanup_threshold, Duration::from_secs(604800));
-    }
-}
diff --git a/crates/autopilot/src/config/s3.rs b/crates/autopilot/src/config/s3.rs
deleted file mode 100644
index f6b5329a95..0000000000
--- a/crates/autopilot/src/config/s3.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct S3Config {
-    /// The S3 bucket where auction instances should be uploaded.
-    pub bucket: String,
-
-    /// Prepended to the auction id to form the final instance filename on S3.
-    /// Something like "staging/mainnet/"
-    pub filename_prefix: String,
-}
-
-impl From<S3Config> for s3::Config {
-    fn from(config: S3Config) -> Self {
-        Self {
-            bucket: config.bucket,
-            filename_prefix: config.filename_prefix,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        bucket = "my-bucket"
-        filename-prefix = "staging/mainnet/"
-        "#;
-        let config: S3Config = toml::from_str(toml).unwrap();
-        assert_eq!(config.bucket, "my-bucket");
-        assert_eq!(config.filename_prefix, "staging/mainnet/");
-    }
-
-    #[test]
-    fn missing_field_fails() {
-        let toml = r#"
-        bucket = "my-bucket"
-        "#;
-        assert!(toml::from_str::<S3Config>(toml).is_err());
-    }
-
-    #[test]
-    fn into_s3_config() {
-        let config = S3Config {
-            bucket: "my-bucket".to_string(),
-            filename_prefix: "prefix/".to_string(),
-        };
-        let s3_config: s3::Config = config.into();
-        assert_eq!(s3_config.bucket, "my-bucket");
-        assert_eq!(s3_config.filename_prefix, "prefix/");
-    }
-}
diff --git a/crates/autopilot/src/config/solver.rs b/crates/autopilot/src/config/solver.rs
deleted file mode 100644
index e00c06b810..0000000000
--- a/crates/autopilot/src/config/solver.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-use {
-    alloy::primitives::Address,
-    core::fmt,
-    serde::{Deserialize, Deserializer, Serialize},
-    std::fmt::{Display, Formatter},
-    url::Url,
-};
-
-/// External solver driver configuration
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct Solver {
-    pub name: String,
-    pub url: Url,
-    pub submission_account: Account,
-}
-
-impl Solver {
-    pub fn new(name: String, url: Url, account: Account) -> Self {
-        Self {
-            name,
-            url,
-            submission_account: account,
-        }
-    }
-}
-
-impl Display for Solver {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}({})", self.name, self.url)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum Account {
-    /// AWS KMS is used to retrieve the solver public key
-    #[serde(deserialize_with = "deserialize_arn")]
-    Kms(Arn),
-    /// Solver public key
-    Address(Address),
-}
-
-// Wrapper type for AWS ARN identifiers
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
-pub struct Arn(pub String);
-
-fn deserialize_arn<'de, D>(deserializer: D) -> Result<Arn, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let raw_arn = String::deserialize(deserializer)?;
-    if raw_arn.starts_with("arn:aws:kms:") {
-        Ok(Arn(raw_arn))
-    } else {
-        Err(serde::de::Error::invalid_value(
-            serde::de::Unexpected::Str(raw_arn.as_str()),
-            &"expected value starting with \"arn:aws:kms\"",
-        ))
-    }
-}
-
-#[cfg(any(test, feature = "test-util"))]
-impl Solver {
-    pub fn test(name: &str, address: Address) -> Self {
-        Self {
-            name: name.to_string(),
-            url: format!("http://localhost:11088/{name}").parse().unwrap(),
-            submission_account: Account::Address(address),
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use {super::*, alloy::primitives::address};
-
-    #[test]
-    fn parse_driver_submission_account_address() {
-        let toml = r#"
-        name = "name1"
-        url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-        "#;
-        let driver = toml::from_str::<Solver>(toml).unwrap();
-
-        let expected = Solver::new(
-            "name1".into(),
-            Url::parse("http://localhost:8080").unwrap(),
-            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
-        );
-        assert_eq!(driver, expected);
-    }
-
-    #[test]
-    fn parse_driver_submission_account_arn() {
-        let toml = r#"
-        name = "name1"
-        url = "http://localhost:8080"
-        submission-account.kms = "arn:aws:kms:supersecretstuff"
-        "#;
-        let driver = toml::from_str::<Solver>(toml).unwrap();
-
-        let expected = Solver::new(
-            "name1".into(),
-            Url::parse("http://localhost:8080").unwrap(),
-            Account::Kms(Arn("arn:aws:kms:supersecretstuff".into())),
-        );
-        assert_eq!(driver, expected);
-    }
-
-    #[test]
-    fn deserialize_valid_arn() {
-        let toml = r#"kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012""#;
-        let account = toml::from_str::<Account>(toml).unwrap();
-
-        let expected = Account::Kms(Arn("arn:aws:kms:us-east-1:123456789012:key/\
-                                         12345678-1234-1234-1234-123456789012"
-            .into()));
-        assert_eq!(account, expected);
-    }
-
-    #[test]
-    fn deserialize_invalid_arn_wrong_prefix() {
-        let toml = r#"kms = "arn:aws:s3:us-east-1:123456789012:bucket/mybucket""#;
-        let result = toml::from_str::<Account>(toml);
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(
-            err.to_string()
-                .contains("expected value starting with \"arn:aws:kms\""),
-            "Error message: {}",
-            err
-        );
-    }
-
-    #[test]
-    fn deserialize_invalid_arn_not_arn() {
-        let toml = r#"kms = "not-an-arn""#;
-        let result = toml::from_str::<Account>(toml);
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(
-            err.to_string()
-                .contains("expected value starting with \"arn:aws:kms\""),
-            "Error message: {}",
-            err
-        );
-    }
-
-    #[test]
-    fn parse_multiple_solvers() {
-        let toml = r#"
-        [[drivers]]
-        name = "solver1"
-        url = "http://localhost:8080"
-        submission-account.address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-
-        [[drivers]]
-        name = "solver2"
-        url = "http://localhost:8081"
-        # test the format used in the infra repo
-        [drivers.submission-account]
-        kms = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"
-        "#;
-
-        #[derive(Deserialize)]
-        struct Config {
-            drivers: Vec<Solver>,
-        }
-
-        let config = toml::from_str::<Config>(toml).unwrap();
-
-        assert_eq!(config.drivers.len(), 2);
-
-        let expected_solver1 = Solver::new(
-            "solver1".into(),
-            Url::parse("http://localhost:8080").unwrap(),
-            Account::Address(address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")),
-        );
-
-        let expected_solver2 = Solver::new(
-            "solver2".into(),
-            Url::parse("http://localhost:8081").unwrap(),
-            Account::Kms(Arn("arn:aws:kms:us-east-1:123456789012:key/\
-                              12345678-1234-1234-1234-123456789012"
-                .into())),
-        );
-
-        assert_eq!(config.drivers[0], expected_solver1);
-        assert_eq!(config.drivers[1], expected_solver2);
-    }
-}
diff --git a/crates/autopilot/src/config/trusted_tokens.rs b/crates/autopilot/src/config/trusted_tokens.rs
deleted file mode 100644
index 75d7b7849b..0000000000
--- a/crates/autopilot/src/config/trusted_tokens.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use {
-    alloy::primitives::Address,
-    serde::{Deserialize, Serialize},
-    std::time::Duration,
-    url::Url,
-};
-
-fn default_update_interval() -> Duration {
-    Duration::from_secs(3600) // 1h
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct TrustedTokensConfig {
-    /// The URL of a list of tokens our settlement contract is willing to
-    /// internalize.
-    pub url: Option<Url>,
-
-    /// Hardcoded list of trusted tokens to use in addition to `url`.
-    #[serde(default)]
-    pub tokens: Vec<Address>,
-
-    /// Time interval after which the trusted tokens list needs to be updated.
-    #[serde(with = "humantime_serde", default = "default_update_interval")]
-    pub update_interval: Duration,
-}
-
-impl Default for TrustedTokensConfig {
-    fn default() -> Self {
-        Self {
-            url: None,
-            tokens: Vec::new(),
-            update_interval: default_update_interval(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_defaults() {
-        let toml = "";
-        let config: TrustedTokensConfig = toml::from_str(toml).unwrap();
-        assert!(config.url.is_none());
-        assert!(config.tokens.is_empty());
-        assert_eq!(config.update_interval, Duration::from_secs(3600));
-    }
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        url = "https://example.com/tokens.json"
-        tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
-        update-interval = "30m"
-        "#;
-        let config: TrustedTokensConfig = toml::from_str(toml).unwrap();
-        assert!(config.url.is_some());
-        assert_eq!(config.tokens.len(), 1);
-        assert_eq!(config.update_interval, Duration::from_secs(1800));
-    }
-}
diff --git a/crates/autopilot/src/domain/competition/winner_selection.rs b/crates/autopilot/src/domain/competition/winner_selection.rs
index 534d4d3778..d779bd52ee 100644
--- a/crates/autopilot/src/domain/competition/winner_selection.rs
+++ b/crates/autopilot/src/domain/competition/winner_selection.rs
@@ -278,7 +278,6 @@ impl Ranking {
 mod tests {
     use {
         crate::{
-            config::solver::Account,
             domain::{
                 Auction,
                 Order,
diff --git a/crates/autopilot/src/lib.rs b/crates/autopilot/src/lib.rs
index ad4f8a7420..fad6e62fab 100644
--- a/crates/autopilot/src/lib.rs
+++ b/crates/autopilot/src/lib.rs
@@ -2,7 +2,6 @@
 
 pub mod arguments;
 pub mod boundary;
-pub mod config;
 pub mod database;
 pub mod domain;
 pub mod event_updater;
diff --git a/crates/configs/src/orderbook/mod.rs b/crates/configs/src/orderbook/mod.rs
index fc51580ecc..a20f6e6886 100644
--- a/crates/configs/src/orderbook/mod.rs
+++ b/crates/configs/src/orderbook/mod.rs
@@ -409,6 +409,7 @@ mod tests {
             http_client: Default::default(),
             price_estimation: Default::default(),
             order_simulation: Default::default(),
+            skip_domain_separator_verification: Default::default(),
         };
 
         let serialized = toml::to_string_pretty(&config).unwrap();
diff --git a/crates/orderbook/src/config/banned_users.rs b/crates/orderbook/src/config/banned_users.rs
deleted file mode 100644
index e970795915..0000000000
--- a/crates/orderbook/src/config/banned_users.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use {
-    alloy::primitives::Address,
-    serde::{Deserialize, Serialize},
-    std::num::NonZeroUsize,
-};
-
-const fn default_max_cache_size() -> NonZeroUsize {
-    NonZeroUsize::new(100).expect("value should be non-zero")
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct BannedUsersConfig {
-    #[serde(default)]
-    pub addresses: Vec<Address>,
-
-    /// Maximum number of entries to keep in the banned users cache.
-    #[serde(default = "default_max_cache_size")]
-    pub max_cache_size: NonZeroUsize,
-}
-
-impl Default for BannedUsersConfig {
-    fn default() -> Self {
-        Self {
-            addresses: Default::default(),
-            max_cache_size: default_max_cache_size(),
-        }
-    }
-}
diff --git a/crates/orderbook/src/config/ipfs.rs b/crates/orderbook/src/config/ipfs.rs
deleted file mode 100644
index bc365ecdf5..0000000000
--- a/crates/orderbook/src/config/ipfs.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-use {
-    serde::{Deserialize, Deserializer, Serialize},
-    url::Url,
-};
-
-/// The IPFS authentication token is injected by 1Password directly into the
-/// Pod's environment, completely bypassing Pulumi and making it unusable in the
-/// configuration file. Since the token does not contain `%` this is a
-/// workaround to allow the token to be read from the environment.
-fn deserialize_auth_token<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let Some(raw_auth_token) = Option::<String>::deserialize(deserializer)? else {
-        return Ok(None);
-    };
-    if let Some(env_var_name) = raw_auth_token.strip_prefix("%") {
-        let env_var_contents = std::env::var(env_var_name).map_err(|err| {
-            tracing::error!(%err, %env_var_name, "failed to load env var");
-            serde::de::Error::invalid_value(
-                serde::de::Unexpected::Str(env_var_name),
-                &"expected environment variable to be available",
-            )
-        })?;
-        Ok(Some(env_var_contents))
-    } else {
-        Ok(Some(raw_auth_token))
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct IpfsConfig {
-    /// IPFS gateway to fetch full app data for orders that only specify the
-    /// contract app data hash.
-    pub gateway: Url,
-
-    /// Authentication key for Pinata IPFS gateway.
-    #[serde(deserialize_with = "deserialize_auth_token")]
-    pub auth_token: Option<String>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        gateway = "https://gateway.pinata.cloud/ipfs/"
-        auth-token = "my-secret-key"
-        "#;
-        let config: IpfsConfig = toml::from_str(toml).unwrap();
-        assert_eq!(
-            config.gateway.as_str(),
-            "https://gateway.pinata.cloud/ipfs/"
-        );
-        assert_eq!(config.auth_token.unwrap(), "my-secret-key");
-    }
-
-    #[test]
-    fn deserialize_auth_token_from_env() {
-        let env_var_name = "TEST_IPFS_AUTH_TOKEN_SECRET";
-        let env_var_value = "my-secret-from-env";
-        // SAFETY: no other threads access this env var.
-        unsafe { std::env::set_var(env_var_name, env_var_value) };
-
-        let toml = format!(
-            r#"
-            gateway = "https://gateway.pinata.cloud/ipfs/"
-            auth-token = "%{env_var_name}"
-            "#,
-        );
-        let config: IpfsConfig = toml::from_str(&toml).unwrap();
-        assert_eq!(config.auth_token.as_deref(), Some(env_var_value));
-
-        // SAFETY: no other threads access this env var.
-        unsafe { std::env::remove_var(env_var_name) };
-    }
-
-    #[test]
-    fn roundtrip_serialization() {
-        let config = IpfsConfig {
-            gateway: "https://gateway.pinata.cloud/ipfs/".parse().unwrap(),
-            auth_token: Some("my-secret-key".to_string()),
-        };
-
-        let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: IpfsConfig = toml::from_str(&serialized).unwrap();
-
-        assert_eq!(config.gateway.as_str(), deserialized.gateway.as_str());
-        assert_eq!(config.auth_token, deserialized.auth_token);
-    }
-}
diff --git a/crates/orderbook/src/config/mod.rs b/crates/orderbook/src/config/mod.rs
deleted file mode 100644
index 81698cad8f..0000000000
--- a/crates/orderbook/src/config/mod.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-use {
-    crate::config::{
-        banned_users::BannedUsersConfig,
-        ipfs::IpfsConfig,
-        native_price::NativePriceConfig,
-        order_validation::OrderValidationConfig,
-    },
-    alloy::primitives::Address,
-    anyhow::anyhow,
-    chrono::{DateTime, Utc},
-    configs::{database::DatabasePoolConfig, fee_factor::FeeFactor},
-    serde::{Deserialize, Serialize},
-    std::path::Path,
-};
-
-pub mod banned_users;
-pub mod ipfs;
-pub mod native_price;
-pub mod order_validation;
-
-const fn default_app_data_size_limit() -> usize {
-    8192
-}
-
-const fn default_active_order_competition_threshold() -> u32 {
-    5
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct VolumeFeeConfig {
-    pub factor: Option<FeeFactor>,
-    pub effective_from_timestamp: Option<DateTime<Utc>>,
-}
-
-// NOTE: cannot add deny_unknown_fields during the config migration
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "kebab-case" /* deny_unknown_fields */)]
-#[cfg_attr(any(test, feature = "test-util"), derive(serde::Serialize))]
-pub struct Configuration {
-    /// Configuration for the order validation system.
-    #[serde(default)]
-    pub order_validation: OrderValidationConfig,
-
-    /// Configuration for the banned users mechanism,
-    /// such as their addresses and the size of the banned user's cache.
-    #[serde(default)]
-    pub banned_users: BannedUsersConfig,
-
-    /// Configuration for the IPFS gateway, supports token authentication.
-    pub ipfs: Option<IpfsConfig>,
-
-    /// Configuration for the volume fee.
-    pub volume_fee: Option<VolumeFeeConfig>,
-
-    #[serde(default = "default_app_data_size_limit")]
-    pub app_data_size_limit: usize,
-
-    /// Missed auctions threshold after which an order is no longer "active".
-    #[serde(default = "default_active_order_competition_threshold")]
-    pub active_order_competition_threshold: u32,
-
-    /// Denylist of tokens (due to lack of support, or other reason).
-    #[serde(default)]
-    pub unsupported_tokens: Vec<Address>,
-
-    /// Whether to skip EIP-1271 signature validation.
-    #[serde(default)]
-    pub eip1271_skip_creation_validation: bool,
-
-    /// Configuration for the native price estimation mechanism.
-    pub native_price_estimation: NativePriceConfig,
-
-    #[serde(default)]
-    pub database: DatabasePoolConfig,
-
-    /// Skip domain separator verification. Useful for forks where contracts
-    /// were deployed with a different chain ID.
-    #[serde(default)]
-    pub skip_domain_separator_verification: bool,
-}
-
-impl Configuration {
-    pub async fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Self> {
-        match toml::from_str(&tokio::fs::read_to_string(&path).await?) {
-            Ok(self_) => Ok(self_),
-            Err(err) if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") => Err(anyhow!(
-                "failed to parse TOML config at {}: {err:#?}",
-                path.as_ref().display()
-            )),
-            Err(_) => Err(anyhow!(
-                "failed to parse TOML config at: {}. Set TOML_TRACE_ERROR=1 to print parsing \
-                 error but this may leak secrets.",
-                path.as_ref().display()
-            )),
-        }
-    }
-}
-
-#[cfg(any(test, feature = "test-util"))]
-pub mod test_util {
-    use {
-        crate::config::{
-            Configuration,
-            default_active_order_competition_threshold,
-            default_app_data_size_limit,
-            native_price::NativePriceConfig,
-        },
-        configs::test_util::TestDefault,
-        std::path::Path,
-    };
-
-    impl Configuration {
-        pub async fn to_path<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
-            Ok(tokio::fs::write(path, toml::to_string_pretty(self)?).await?)
-        }
-
-        pub fn to_temp_path(&self) -> tempfile::NamedTempFile {
-            use std::io::Write;
-            let mut file =
-                tempfile::NamedTempFile::new().expect("temp file creation should not fail");
-            file.write_all(
-                toml::to_string_pretty(self)
-                    .expect("serialization should not fail")
-                    .as_bytes(),
-            )
-            .expect("writing to temp file should not fail");
-            file
-        }
-
-        pub fn to_cli_args(&self) -> (tempfile::NamedTempFile, String) {
-            let named_temp_file = self.to_temp_path();
-            let cli_arg = format!("--config={}", named_temp_file.path().display());
-            (named_temp_file, cli_arg)
-        }
-    }
-
-    impl TestDefault for Configuration {
-        fn test_default() -> Self {
-            use configs::test_util::TestDefault;
-
-            Self {
-                order_validation: Default::default(),
-                banned_users: Default::default(),
-                ipfs: Default::default(),
-                volume_fee: Default::default(),
-                app_data_size_limit: default_app_data_size_limit(),
-                active_order_competition_threshold: default_active_order_competition_threshold(),
-                unsupported_tokens: Default::default(),
-                eip1271_skip_creation_validation: Default::default(),
-                // NOTE: NativePriceConfig needs to be moved to the config crate and then it can
-                // have the test_default trait impl
-                native_price_estimation: NativePriceConfig::test_default(),
-                database: TestDefault::test_default(),
-                skip_domain_separator_verification: Default::default(),
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use {
-        super::*,
-        configs::test_util::TestDefault,
-        price_estimation::{NativePriceEstimator, NativePriceEstimators},
-        shared::order_validation::SameTokensPolicy,
-        std::time::Duration,
-    };
-
-    #[test]
-    fn deserialize_full_configuration() {
-        let toml = r#"
-        app-data-size-limit = 4096
-        active-order-competition-threshold = 10
-        unsupported-tokens = ["0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"]
-        eip1271-skip-creation-validation = true
-
-        [banned-users]
-        addresses = ["0xdead000000000000000000000000000000000000"]
-
-        [order-validation]
-        min-order-validity-period = "2m"
-        max-order-validity-period = "6h"
-        max-limit-order-validity-period = "30d"
-        max-limit-orders-per-user = 5
-        max-gas-per-order = 5000000
-        same-tokens-policy = "allow-sell"
-
-        [ipfs]
-        gateway = "https://gateway.pinata.cloud/ipfs/"
-        auth-token = "my-secret-key"
-
-        [volume-fee]
-        factor = 0.0002
-        effective-from-timestamp = "2025-06-01T00:00:00Z"
-
-        [native-price-estimation]
-        estimators = [[{type = "CoinGecko"}]]
-        "#;
-
-        let config: Configuration = toml::from_str(toml).unwrap();
-
-        assert_eq!(config.app_data_size_limit, 4096);
-        assert_eq!(config.active_order_competition_threshold, 10);
-        assert_eq!(config.unsupported_tokens.len(), 1);
-        assert_eq!(config.banned_users.addresses.len(), 1);
-        assert!(config.eip1271_skip_creation_validation);
-
-        assert!(matches!(
-            config.order_validation.same_tokens_policy,
-            SameTokensPolicy::AllowSell
-        ));
-        assert_eq!(config.order_validation.max_limit_orders_per_user, 5);
-
-        assert_eq!(
-            config.order_validation.min_order_validity_period,
-            Duration::from_secs(120)
-        );
-        assert_eq!(
-            config.order_validation.max_order_validity_period,
-            Duration::from_secs(21600)
-        );
-        assert_eq!(
-            config.order_validation.max_limit_order_validity_period,
-            Duration::from_secs(2_592_000)
-        );
-
-        let ipfs = config.ipfs.unwrap();
-        assert_eq!(ipfs.gateway.as_str(), "https://gateway.pinata.cloud/ipfs/");
-        assert_eq!(ipfs.auth_token.unwrap(), "my-secret-key");
-
-        let vol_fee = config.volume_fee.unwrap();
-        assert_eq!(vol_fee.factor.unwrap().get(), 0.0002);
-        assert!(vol_fee.effective_from_timestamp.is_some());
-    }
-
-    #[test]
-    fn deserialize_configuration_defaults() {
-        let toml = r#"
-        [native-price-estimation]
-        estimators = [[{type = "CoinGecko"}]]
-        "#;
-        let config: Configuration = toml::from_str(toml).unwrap();
-
-        assert_eq!(config.app_data_size_limit, 8192);
-        assert_eq!(config.active_order_competition_threshold, 5);
-
-        assert_eq!(
-            config.order_validation.min_order_validity_period,
-            Duration::from_secs(60)
-        );
-        assert_eq!(
-            config.order_validation.max_order_validity_period,
-            Duration::from_secs(10800)
-        );
-        assert_eq!(
-            config.order_validation.max_limit_order_validity_period,
-            Duration::from_secs(31_536_000)
-        );
-
-        assert!(config.ipfs.is_none());
-        assert!(config.volume_fee.is_none());
-        assert!(config.unsupported_tokens.is_empty());
-        assert!(config.banned_users.addresses.is_empty());
-        assert!(!config.eip1271_skip_creation_validation);
-    }
-
-    #[test]
-    fn roundtrip_serialization() {
-        let config = Configuration {
-            order_validation: OrderValidationConfig {
-                min_order_validity_period: Duration::from_secs(120),
-                max_order_validity_period: Duration::from_secs(7200),
-                max_limit_order_validity_period: Duration::from_secs(86400),
-                max_limit_orders_per_user: 5,
-                max_gas_per_order: 6_000_000,
-                same_tokens_policy: SameTokensPolicy::AllowSell,
-            },
-            ipfs: Some(IpfsConfig {
-                gateway: "https://gateway.pinata.cloud/ipfs/".parse().unwrap(),
-                auth_token: Some("secret".to_string()),
-            }),
-            app_data_size_limit: 4096,
-            active_order_competition_threshold: 10,
-            volume_fee: Some(VolumeFeeConfig {
-                factor: Some(0.0002.try_into().unwrap()),
-                effective_from_timestamp: None,
-            }),
-            unsupported_tokens: vec![
-                "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
-                    .parse()
-                    .unwrap(),
-            ],
-            banned_users: Default::default(),
-            eip1271_skip_creation_validation: true,
-            native_price_estimation: NativePriceConfig {
-                estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
-                fallback_estimators: None,
-                ..NativePriceConfig::test_default()
-            },
-            database: TestDefault::test_default(),
-            skip_domain_separator_verification: false,
-        };
-
-        let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: Configuration = toml::from_str(&serialized).unwrap();
-
-        assert_eq!(config.app_data_size_limit, deserialized.app_data_size_limit);
-        assert_eq!(
-            config.active_order_competition_threshold,
-            deserialized.active_order_competition_threshold
-        );
-        assert!(deserialized.volume_fee.is_some());
-        assert_eq!(
-            config.volume_fee.as_ref().unwrap().factor.unwrap().get(),
-            deserialized
-                .volume_fee
-                .as_ref()
-                .unwrap()
-                .factor
-                .unwrap()
-                .get()
-        );
-        assert_eq!(config.unsupported_tokens, deserialized.unsupported_tokens);
-        assert_eq!(
-            config.banned_users.addresses,
-            deserialized.banned_users.addresses
-        );
-        assert_eq!(
-            config.eip1271_skip_creation_validation,
-            deserialized.eip1271_skip_creation_validation
-        );
-    }
-}
diff --git a/crates/orderbook/src/config/native_price.rs b/crates/orderbook/src/config/native_price.rs
deleted file mode 100644
index bd7dc80158..0000000000
--- a/crates/orderbook/src/config/native_price.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use {
-    price_estimation::{
-        NativePriceEstimators,
-        config::native_price::NativePriceConfig as SharedNativePriceConfig,
-    },
-    serde::{Deserialize, Serialize},
-    std::str::FromStr,
-};
-
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct NativePriceConfig {
-    /// Which estimators to use to estimate token prices in terms of the chain's
-    /// native token.
-    pub estimators: NativePriceEstimators,
-
-    /// Fallback native price estimators to use when all primary estimators
-    /// are down.
-    pub fallback_estimators: Option<NativePriceEstimators>,
-
-    #[serde(flatten)]
-    pub shared: SharedNativePriceConfig,
-}
-
-#[cfg(any(test, feature = "test-util"))]
-impl NativePriceConfig {
-    /// The orderbook forwards native price requests to the autopilot.
-    pub fn test_default() -> Self {
-        use price_estimation::NativePriceEstimator;
-        Self {
-            estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::forwarder(
-                reqwest::Url::from_str("http://localhost:12088").unwrap(),
-            )]]),
-            fallback_estimators: Default::default(),
-            shared: Default::default(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_defaults() {
-        let config: NativePriceConfig =
-            toml::from_str(r#"estimators = [[{type = "CoinGecko"}]]"#).unwrap();
-        assert_eq!(config.estimators.as_slice().len(), 1);
-        assert!(config.fallback_estimators.is_none());
-    }
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-            estimators = [[{ type = "CoinGecko" }, { type = "OneInchSpotPriceApi" }]]
-            fallback-estimators = [[{ type = "CoinGecko" }]]
-            results-required = 3
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert!(config.fallback_estimators.is_some());
-    }
-
-    #[test]
-    fn deserialize_driver_estimator() {
-        let toml = r#"
-            estimators = [[{ type = "Driver", name = "test", url = "http://localhost:8080" }]]
-        "#;
-        let config: NativePriceConfig = toml::from_str(toml).unwrap();
-        assert!(!config.estimators.as_slice().is_empty());
-    }
-
-    #[test]
-    fn roundtrip_serialization() {
-        use price_estimation::NativePriceEstimator;
-
-        let config = NativePriceConfig {
-            estimators: NativePriceEstimators::new(vec![vec![NativePriceEstimator::CoinGecko]]),
-            fallback_estimators: Some(NativePriceEstimators::new(vec![vec![
-                NativePriceEstimator::OneInchSpotPriceApi,
-            ]])),
-            shared: Default::default(),
-        };
-
-        let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: NativePriceConfig = toml::from_str(&serialized).unwrap();
-        assert_eq!(
-            deserialized.estimators.as_slice(),
-            config.estimators.as_slice(),
-        );
-        assert_eq!(
-            deserialized
-                .fallback_estimators
-                .as_ref()
-                .map(|e| e.as_slice()),
-            config.fallback_estimators.as_ref().map(|e| e.as_slice()),
-        );
-    }
-}
diff --git a/crates/orderbook/src/config/order_validation.rs b/crates/orderbook/src/config/order_validation.rs
deleted file mode 100644
index f6e882ad43..0000000000
--- a/crates/orderbook/src/config/order_validation.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-use {
-    serde::{Deserialize, Serialize},
-    shared::order_validation::SameTokensPolicy,
-    std::time::Duration,
-};
-
-const fn default_min_order_validity_period() -> Duration {
-    Duration::from_secs(60) // 1m
-}
-
-const fn default_max_order_validity_period() -> Duration {
-    Duration::from_secs(10800) // 3h
-}
-
-const fn default_max_limit_order_validity_period() -> Duration {
-    Duration::from_secs(31_536_000) // 1y
-}
-
-const fn default_max_limit_orders_per_user() -> u64 {
-    10
-}
-
-const fn default_max_gas_per_order() -> u64 {
-    8_000_000
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
-pub struct OrderValidationConfig {
-    /// The minimum amount of time an order has to be valid for.
-    #[serde(
-        with = "humantime_serde",
-        default = "default_min_order_validity_period"
-    )]
-    pub min_order_validity_period: Duration,
-
-    /// The maximum amount of time a market order can be valid for.
-    /// This restriction does not apply to liquidity owner orders or presign
-    /// orders.
-    #[serde(
-        with = "humantime_serde",
-        default = "default_max_order_validity_period"
-    )]
-    pub max_order_validity_period: Duration,
-
-    /// The maximum amount of time a limit order can be valid for.
-    #[serde(
-        with = "humantime_serde",
-        default = "default_max_limit_order_validity_period"
-    )]
-    pub max_limit_order_validity_period: Duration,
-
-    /// The maximum number of limit orders a user can have open.
-    #[serde(default = "default_max_limit_orders_per_user")]
-    pub max_limit_orders_per_user: u64,
-
-    /// Maximum gas value that can be spent per order.
-    #[serde(default = "default_max_gas_per_order")]
-    pub max_gas_per_order: u64,
-
-    /// Policy for orders where the buy and sell tokens are equal.
-    #[serde(default)]
-    pub same_tokens_policy: SameTokensPolicy,
-}
-
-impl Default for OrderValidationConfig {
-    fn default() -> Self {
-        Self {
-            min_order_validity_period: default_min_order_validity_period(),
-            max_order_validity_period: default_max_order_validity_period(),
-            max_limit_order_validity_period: default_max_limit_order_validity_period(),
-            max_limit_orders_per_user: default_max_limit_orders_per_user(),
-            max_gas_per_order: default_max_gas_per_order(),
-            same_tokens_policy: Default::default(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn deserialize_defaults() {
-        let config: OrderValidationConfig = toml::from_str("").unwrap();
-        assert_eq!(config.min_order_validity_period, Duration::from_secs(60));
-        assert_eq!(config.max_order_validity_period, Duration::from_secs(10800));
-        assert_eq!(
-            config.max_limit_order_validity_period,
-            Duration::from_secs(31_536_000)
-        );
-    }
-
-    #[test]
-    fn deserialize_full() {
-        let toml = r#"
-        min-order-validity-period = "2m"
-        max-order-validity-period = "6h"
-        max-limit-order-validity-period = "30d"
-        max-limit-orders-per-user = 10
-        max-gas-per-order = 5000000
-        same-tokens-policy = "allow-sell"
-        "#;
-        let config: OrderValidationConfig = toml::from_str(toml).unwrap();
-        assert_eq!(config.min_order_validity_period, Duration::from_secs(120));
-        assert_eq!(config.max_order_validity_period, Duration::from_secs(21600));
-        assert_eq!(
-            config.max_limit_order_validity_period,
-            Duration::from_secs(2_592_000)
-        );
-        assert_eq!(config.max_limit_orders_per_user, 10);
-        assert_eq!(config.max_gas_per_order, 5_000_000);
-        assert_eq!(config.same_tokens_policy, SameTokensPolicy::AllowSell);
-    }
-
-    #[test]
-    fn roundtrip_serialization() {
-        let config = OrderValidationConfig {
-            min_order_validity_period: Duration::from_secs(120),
-            max_order_validity_period: Duration::from_secs(7200),
-            max_limit_order_validity_period: Duration::from_secs(86400),
-            max_limit_orders_per_user: 5,
-            max_gas_per_order: 5_000_000,
-            same_tokens_policy: SameTokensPolicy::AllowSell,
-        };
-
-        let serialized = toml::to_string_pretty(&config).unwrap();
-        let deserialized: OrderValidationConfig = toml::from_str(&serialized).unwrap();
-
-        assert_eq!(
-            config.min_order_validity_period,
-            deserialized.min_order_validity_period
-        );
-        assert_eq!(
-            config.max_order_validity_period,
-            deserialized.max_order_validity_period
-        );
-        assert_eq!(
-            config.max_limit_order_validity_period,
-            deserialized.max_limit_order_validity_period
-        );
-        assert_eq!(
-            config.max_limit_orders_per_user,
-            deserialized.max_limit_orders_per_user
-        );
-        assert_eq!(config.max_gas_per_order, deserialized.max_gas_per_order);
-        assert_eq!(config.same_tokens_policy, deserialized.same_tokens_policy);
-    }
-}
diff --git a/crates/orderbook/src/lib.rs b/crates/orderbook/src/lib.rs
index ba29804397..c5c92d4a6a 100644
--- a/crates/orderbook/src/lib.rs
+++ b/crates/orderbook/src/lib.rs
@@ -1,7 +1,6 @@
 pub mod api;
 pub mod app_data;
 pub mod arguments;
-pub mod config;
 pub mod database;
 pub mod dto;
 mod ipfs;